diff --git a/.github/ISSUE_TEMPLATE/blank-issue.md b/.github/ISSUE_TEMPLATE/blank-issue.md
deleted file mode 100644
index a08ad07cbf8d..000000000000
--- a/.github/ISSUE_TEMPLATE/blank-issue.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-name: Blank Issue
-about: Create a blank issue.
-title: ''
-labels: ''
-assignees: ''
-
----
-
-
diff --git a/.github/ISSUE_TEMPLATE/clif-bug-report.md b/.github/ISSUE_TEMPLATE/clif-bug-report.md
deleted file mode 100644
index 2acc0b06f4f7..000000000000
--- a/.github/ISSUE_TEMPLATE/clif-bug-report.md
+++ /dev/null
@@ -1,43 +0,0 @@
----
-name: Cranelift Bug Report
-about: Report a bug or a crash in Cranelift.
-title: 'Cranelift: '
-labels: bug, cranelift
-assignees: ''
-
----
-
-Thanks for filing an issue! Please fill out the TODOs below.
-
-### `.clif` Test Case
-
-```
-TODO: paste .clif test case here. Ideally, a test case that has been reduced via
-the `clif-util bugpoint` command.
-```
-
-### Steps to Reproduce
-
-* TODO: First, ...
-* TODO: Then, ...
-* Etc...
-
-### Expected Results
-
-TODO: What do you expect to happen?
-
-### Actual Results
-
-TODO: What actually happens? Panic? Segfault? Incorrect result?
-
-### Versions and Environment
-
-Cranelift version or commit: TODO
-
-Operating system: TODO
-
-Architecture: TODO
-
-### Extra Info
-
-Anything else you'd like to add?
diff --git a/.github/ISSUE_TEMPLATE/fuzzbug.md b/.github/ISSUE_TEMPLATE/fuzzbug.md
deleted file mode 100644
index 52cd30bf6144..000000000000
--- a/.github/ISSUE_TEMPLATE/fuzzbug.md
+++ /dev/null
@@ -1,44 +0,0 @@
----
-name: Fuzz Bug Report
-about: Report a fuzz bug in Wasmtime or Cranelift
-title: '<target> fuzzbug: '
-labels: bug, fuzz-bug
-assignees: ''
----
-
-Thanks for filing an issue! Please fill out the TODOs below, and change `<target>` in the title to the corresponding fuzzing target.
-
-<!-- TODO: add link to an external bug report, if there is one, such as from OSS-Fuzz -->
-
-<details>
-<summary>Test case input</summary>
-
-<!-- Please base64-encode the input that libFuzzer generated, and paste it in the code-block below. This is required for us to reproduce the issue. -->
-
-```
-TODO_paste_the_base64_encoded_input_here
-```
-
-</details>
-
-<details>
-<summary>`cargo +nightly fuzz fmt` output</summary>
-
-<!-- If you can, please paste the output of `cargo +nightly fuzz fmt <target> <input>` in the code-block below. This will help reviewers more quickly triage this report. -->
-
-```
-TODO_paste_cargo_fuzz_fmt_output_here
-```
-
-</details>
-
-<details>
-<summary>Stack trace or other relevant details</summary>
-
-<!-- If you can, please paste anything that looks relevant from the failure message in the code-block below. This will help reviewers more quickly triage this report. -->
-
-```
-TODO_paste_the_report_here
-```
-
-</details>
diff --git a/.github/ISSUE_TEMPLATE/improvement.md b/.github/ISSUE_TEMPLATE/improvement.md
deleted file mode 100644
index 8146e0c58c0a..000000000000
--- a/.github/ISSUE_TEMPLATE/improvement.md
+++ /dev/null
@@ -1,31 +0,0 @@
----
-name: Improvement
-about: A feature request or code improvement.
-title: ''
-labels: ''
-assignees: ''
-
----
-
-Thanks for filing a feature request! Please fill out the TODOs below.
-
-#### Feature
-
-TODO: Brief description of the feature/improvement you'd like to see in
-Cranelift/Wasmtime.
-
-#### Benefit
-
-TODO: What is the value of adding this in Cranelift/Wasmtime? What problems does
-it solve?
-
-#### Implementation
-
-TODO: Do you have an implementation plan, and/or ideas for data structures or
-algorithms to use?
-
-#### Alternatives
-
-TODO: What are the alternative implementation approaches or alternative ways to
-solve the problem that this feature would solve? How do these alternatives
-compare to this proposal?
diff --git a/.github/ISSUE_TEMPLATE/wasmtime-bug-report.md b/.github/ISSUE_TEMPLATE/wasmtime-bug-report.md
deleted file mode 100644
index cc2e349af8c0..000000000000
--- a/.github/ISSUE_TEMPLATE/wasmtime-bug-report.md
+++ /dev/null
@@ -1,42 +0,0 @@
----
-name: Wasmtime Bug Report
-about: Report a bug or a crash in Wasmtime
-title: ''
-labels: bug
-assignees: ''
-
----
-
-Thanks for filing a bug report! Please fill out the TODOs below.
-
-**Note: if you want to report a security issue, please read our [security policy](https://bytecodealliance.org/security)!**
-
-### Test Case
-
-TODO: upload Wasm file here
-
-### Steps to Reproduce
-
-* TODO: first, ...
-* TODO: second, ...
-* Etc...
-
-### Expected Results
-
-TODO: What do you expect to happen?
-
-### Actual Results
-
-TODO: What actually happens? Panic? Segfault? Incorrect result?
-
-### Versions and Environment
-
-Wasmtime version or commit: TODO
-
-Operating system: TODO
-
-Architecture: TODO
-
-### Extra Info
-
-Anything else you'd like to add?
diff --git a/.github/actions/android-ndk/action.yml b/.github/actions/android-ndk/action.yml
new file mode 100644
index 000000000000..cbf88a14f891
--- /dev/null
+++ b/.github/actions/android-ndk/action.yml
@@ -0,0 +1,32 @@
+# This is a small action which uses the pre-installed Android NDK on GitHub
+# Actions builders, configured with `$ANDROID_NDK`, to compile and link Android
+# code. For Rust we mostly need to configure the linker to Cargo and the C
+# compiler to the `cc` crate, so this sets various environment variables to the
+# appropriate tool within `$ANDROID_NDK`.
+
+name: 'Setup Rust to use the Android NDK'
+description: 'Setup Rust to use the android NDK'
+
+inputs:
+  target:
+    description: 'Rust target being used'
+    required: true
+  android-platform:
+    description: 'Platform version to use for the C compiler'
+    required: false
+    default: '26'
+
+runs:
+  using: composite
+  steps:
+    - run: |
+        target=${{ inputs.target }}
+        cc_target=$(echo ${{ inputs.target }} | tr - _)
+        upcase=$(echo $target | tr a-z- A-Z_)
+        ndk_bin=$ANDROID_NDK/toolchains/llvm/prebuilt/linux-x86_64/bin
+        linker=$ndk_bin/${target}${{ inputs.android-platform }}-clang
+        echo CARGO_TARGET_${upcase}_LINKER=$linker >> $GITHUB_ENV
+        echo CC_${cc_target}=$linker >> $GITHUB_ENV
+        echo RANLIB_${cc_target}=$ndk_bin/llvm-ranlib >> $GITHUB_ENV
+        echo AR_${cc_target}=$ndk_bin/llvm-ar >> $GITHUB_ENV
+      shell: bash
diff --git a/.github/actions/binary-compatible-builds/action.yml b/.github/actions/binary-compatible-builds/action.yml
index b5a190c4a06f..8abc72d63742 100644
--- a/.github/actions/binary-compatible-builds/action.yml
+++ b/.github/actions/binary-compatible-builds/action.yml
@@ -2,7 +2,7 @@ name: 'Set up a CentOS 6 container to build releases in'
 description: 'Set up a CentOS 6 container to build releases in'
 
 runs:
-  using: node16
+  using: node20
   main: 'main.js'
 inputs:
   name:
diff --git a/.github/actions/binary-compatible-builds/main.js b/.github/actions/binary-compatible-builds/main.js
index 378c5c202c9c..1101d78e4a41 100755
--- a/.github/actions/binary-compatible-builds/main.js
+++ b/.github/actions/binary-compatible-builds/main.js
@@ -21,12 +21,37 @@ if (process.platform == 'win32') {
   return;
 }
 
+// Android doesn't use a container as it's controlled by the installation of the
+// SDK/NDK.
+if (process.env.INPUT_NAME && process.env.INPUT_NAME.indexOf("android") >= 0) {
+  return;
+}
+
 // ... and on Linux we do fancy things with containers. We'll spawn an old
 // CentOS container in the background with a super old glibc, and then we'll run
 // commands in there with the `$CENTOS` env var.
 
 if (process.env.CENTOS !== undefined) {
-  const args = ['exec', '-w', process.cwd(), '-i', 'build-container'];
+  const args = ['exec', '--workdir', process.cwd(), '--interactive'];
+  // Forward any rust-looking env vars from the environment into the container
+  // itself.
+  for (let key in process.env) {
+    if (key.startsWith('CARGO') || key.startsWith('RUST')) {
+      args.push('--env');
+      args.push(key);
+    }
+  }
+  args.push('build-container')
+
+  // Start the container by appending to `$PATH` with the `/rust/bin` path that
+  // is mounted below.
+  args.push('bash');
+  args.push('-c');
+  args.push('export PATH=$PATH:/rust/bin; export RUSTFLAGS="$RUSTFLAGS $EXTRA_RUSTFLAGS"; exec "$@"');
+  args.push('bash');
+
+  // Add in whatever we're running which will get executed in the sub-shell with
+  // an augmented PATH.
   for (const arg of process.argv.slice(2)) {
     args.push(arg);
   }
@@ -34,7 +59,7 @@ if (process.env.CENTOS !== undefined) {
   return;
 }
 
-const name = process.env.INPUT_NAME;
+const name = process.env.INPUT_NAME.replace(/-min$/, '');
 
 child_process.execFileSync('docker', [
   'build',
diff --git a/.github/actions/build-adapter-provider/action.yml b/.github/actions/build-adapter-provider/action.yml
new file mode 100644
index 000000000000..60b9d08a37a0
--- /dev/null
+++ b/.github/actions/build-adapter-provider/action.yml
@@ -0,0 +1,25 @@
+name: 'Build wasi component adapter provider'
+description: 'Build the wasi-preview1-component-adapter provider using the adapter artefacts'
+
+inputs:
+  run-id:
+    description: 'run id of the main.yml action that produced the adapter artefacts'
+    required: true
+
+runs:
+  using: composite
+  steps:
+    - uses: actions/download-artifact@v4
+      with:
+        name: bins-wasi-preview1-component-adapter
+        path: crates/wasi-preview1-component-adapter/provider/artefacts
+        github-token: ${{ github.token }}
+        run-id: ${{ inputs.run-id }}
+
+    - name: Install required Rust components
+      shell: bash
+      run: rustup component add rustfmt clippy
+
+    - name: Build and checl the adapter provider
+      shell: bash
+      run: ./ci/build-wasi-preview1-component-adapter-provider.sh
diff --git a/.github/actions/fetch-run-id/action.yml b/.github/actions/fetch-run-id/action.yml
new file mode 100644
index 000000000000..614f2e37c64a
--- /dev/null
+++ b/.github/actions/fetch-run-id/action.yml
@@ -0,0 +1,18 @@
+name: 'Fetch run id for commit'
+description: 'Fetch the main.yml run id for the current commit'
+
+runs:
+  using: composite
+  steps:
+    - name: Fetch run id
+      shell: bash
+      run: |
+        run_id=$(
+          gh api -H 'Accept: application/vnd.github+json' \
+              /repos/${{ github.repository }}/actions/workflows/main.yml/runs\?exclude_pull_requests=true \
+              | jq '.workflow_runs' \
+              | jq "map(select(.head_commit.id == \"${{ github.sha }}\"))[0].id" \
+        )
+        echo COMMIT_RUN_ID=${run_id} >> "$GITHUB_ENV"
+      env:
+        GH_TOKEN: ${{ github.token }}
diff --git a/.github/actions/github-release/main.js b/.github/actions/github-release/main.js
index d61b24ed5ef3..bcf4f75b490a 100644
--- a/.github/actions/github-release/main.js
+++ b/.github/actions/github-release/main.js
@@ -91,13 +91,25 @@ async function runOnce() {
   } catch (e) {
     console.log("ERROR: ", JSON.stringify(e, null, 2));
     core.info(`creating a release`);
+
+    const releaseNotes = fs.readFileSync('RELEASES.md').toString();
+    let notes = null;
+    const opts = {
+      owner,
+      repo,
+      tag_name: name,
+      prerelease: name === 'dev',
+    };
+    if (name !== 'dev') {
+      for (let x of releaseNotes.split(/^---+$/m)) {
+        if (x.indexOf(name.substring(1)) == -1)
+          continue;
+        opts.body = x;
+        break;
+      }
+    }
     try {
-      release = await octokit.rest.repos.createRelease({
-        owner,
-        repo,
-        tag_name: name,
-        prerelease: name === 'dev',
-      });
+      release = await octokit.rest.repos.createRelease(opts);
     } catch(e) {
       console.log("ERROR: ", JSON.stringify(e, null, 2));
       core.info(`fetching one more time`);
diff --git a/.github/actions/install-cargo-vet/action.yml b/.github/actions/install-cargo-vet/action.yml
index 0d481d744236..7757f78956b5 100644
--- a/.github/actions/install-cargo-vet/action.yml
+++ b/.github/actions/install-cargo-vet/action.yml
@@ -5,16 +5,16 @@ inputs:
   version:
     description: 'Version to install'
     required: false
-    default: '0.8.0'
+    default: '0.9.0'
 
 runs:
   using: composite
   steps:
-    - uses: actions/cache@v3
+    - uses: actions/cache@v4
       with:
         path: ${{ runner.tool_cache }}/cargo-vet
         key: cargo-vet-bin-${{ inputs.version }}
     - run: echo "${{ runner.tool_cache }}/cargo-vet/bin" >> $GITHUB_PATH
       shell: bash
-    - run: cargo install --root ${{ runner.tool_cache }}/cargo-vet --version ${{ inputs.version }} cargo-vet
+    - run: cargo install --root ${{ runner.tool_cache }}/cargo-vet --version ${{ inputs.version }} cargo-vet --locked
       shell: bash
diff --git a/.github/actions/install-rust/action.yml b/.github/actions/install-rust/action.yml
index 003c994f6dfc..c5f40462ac58 100644
--- a/.github/actions/install-rust/action.yml
+++ b/.github/actions/install-rust/action.yml
@@ -1,15 +1,11 @@
 name: 'Install Rust toolchain'
-description: 'Install a rust toolchain and cache the crates index'
+description: 'Install a rust toolchain'
 
 inputs:
   toolchain:
     description: 'Default toolchan to install'
     required: false
     default: 'default'
-  lockfiles:
-    description: 'Path glob for Cargo.lock files to use as cache keys'
-    required: false
-    default: '**/Cargo.lock'
 
 runs:
   using: composite
@@ -26,6 +22,8 @@ runs:
           echo "version=1.$((msrv+2)).0" >> "$GITHUB_OUTPUT"
         elif [ "${{ inputs.toolchain }}" = "msrv" ]; then
           echo "version=1.$msrv.0" >> "$GITHUB_OUTPUT"
+        elif [ "${{ inputs.toolchain }}" = "wasmtime-ci-pinned-nightly" ]; then
+          echo "version=nightly-2024-08-12" >> "$GITHUB_OUTPUT"
         else
           echo "version=${{ inputs.toolchain }}" >> "$GITHUB_OUTPUT"
         fi
@@ -55,49 +53,10 @@ runs:
         EOF
         fi
 
-        # Use a more efficient method for fetching the crates.io-index than
-        # the (currently) default git-based index.
-        cat >> "$GITHUB_ENV" <<EOF
-        CARGO_REGISTRIES_CRATES_IO_PROTOCOL=sparse
-        EOF
-
-    - name: Choose registry cache key
+    - name: Require semicolons in WIT
       shell: bash
-      # Update the registry index cache at most once per day. actions/cache
-      # won't write changes back to the cache if the cache key already exists,
-      # so this means every job may have to re-download the index entries which
-      # are new since the last time the cache key changed. Changing the cache
-      # key relatively frequently keeps the amount of duplicated work down. But
-      # changing it too frequently means we might hit the 10GB quota too
-      # quickly, which would cause GitHub to evict other caches we still want.
-      run: echo CARGO_REGISTRY_CACHE_KEY=$(date +%Y%m%d) >> $GITHUB_ENV
+      run: echo WIT_REQUIRE_SEMICOLONS=1 >> "$GITHUB_ENV"
 
-    - name: Cache Cargo registry index
-      uses: actions/cache@v3
-      with:
-        path: ~/.cargo/registry/index/
-        key: cargo-registry-${{ env.CARGO_REGISTRY_CACHE_KEY }}
-        # Any older registry-index cache is still valid. It's a git clone, so
-        # cargo only has to pull down the changes since the index was cached.
-        restore-keys: cargo-registry-
-
-    - name: Cache crate sources for dependencies
-      uses: actions/cache@v3
-      with:
-        path: |
-          ~/.cargo/registry/cache/
-          ~/.cargo/git/db/
-        key: cargo-crates-${{ inputs.lockfiles }}-${{ hashFiles(inputs.lockfiles) }}
-        # If Cargo.lock has changed, we probably will need to get the source
-        # code for some crates we don't already have. But any crates we have
-        # source cached for are still valid. The only problem is nothing
-        # removes old crate sources from the cache, so using `restore-keys`
-        # this way may use more of our GitHub cache quota than we'd like.
-        #
-        # Also, scope this cache by which Cargo.lock we're building from.
-        # Otherwise, whichever job writes the cache first will get its
-        # dependencies cached, and that cache will be used as the basis for the
-        # next job, even though odds are pretty good the cache is useless.
-        restore-keys: cargo-crates-${{ inputs.lockfiles }}-
-
-# TODO: on cache miss, after cargo has updated the registry index, run `git gc`
+    - name: Install the WASI target
+      shell: bash
+      run: rustup target add wasm32-wasip1 wasm32-unknown-unknown
diff --git a/.github/labeler.yml b/.github/labeler.yml
index 0c91d826b44d..e404e6b4920c 100644
--- a/.github/labeler.yml
+++ b/.github/labeler.yml
@@ -56,6 +56,9 @@
   - "cranelift/codegen/src/isa/*/lower/isle/**"
   - "cranelift/codegen/src/opts/*"
 
+"pulley":
+  - "pulley/**"
+
 "wasi":
   - "crates/wasi/**"
   - "crates/wasi-common/**"
@@ -76,8 +79,12 @@
   - "docs/**"
 
 "wasmtime:ref-types":
-  - "crates/wasmtime/src/ref.rs"
-  - "crates/runtime/src/externref.rs"
+  - "crates/cranelift/src/gc.rs"
+  - "crates/cranelift/src/gc/**"
+  - "crates/wasmtime/src/runtime/gc.rs"
+  - "crates/wasmtime/src/runtime/gc/**"
+  - "crates/wasmtime/src/runtime/vm/gc.rs"
+  - "crates/wasmtime/src/runtime/vm/gc/**"
 
 "winch":
   - "winch/**"
diff --git a/.github/subscribe-to-label.json b/.github/subscribe-to-label.json
index a39d316323eb..6623355d469b 100644
--- a/.github/subscribe-to-label.json
+++ b/.github/subscribe-to-label.json
@@ -1,6 +1,5 @@
 {
   "cfallin": ["isle"],
-  "fitzgen": ["fuzzing", "isle", "wasmtime:ref-types"],
-  "peterhuene": ["wasmtime:api", "wasmtime:c-api"],
+  "fitzgen": ["fuzzing", "isle", "pulley", "wasmtime:ref-types"],
   "saulecabrera": ["winch"]
 }
diff --git a/.github/workflows/aslp.yml b/.github/workflows/aslp.yml
new file mode 100644
index 000000000000..20b57b66a041
--- /dev/null
+++ b/.github/workflows/aslp.yml
@@ -0,0 +1,83 @@
+name: aslp
+
+on:
+  push:
+    branches:
+      - veriisle
+    paths:
+      - '.github/workflows/aslp.yml'
+      - '**/aslp/**'
+      - '**/isaspec/**'
+      - 'cranelift/codegen/src/isa/aarch64/spec/*.isle'
+  pull_request:
+    branches:
+      - veriisle
+    paths:
+      - '.github/workflows/aslp.yml'
+      - '**/aslp/**'
+      - '**/isaspec/**'
+      - 'cranelift/codegen/src/isa/aarch64/spec/*.isle'
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    env:
+      ASLP_PATH: ${{ github.workspace }}/tools/aslp
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          path: main
+      - name: Setup Rust Toolchain
+        uses: dtolnay/rust-toolchain@stable
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: main
+      - name: Install LLVM
+        env:
+          LLVM_VERSION: 18
+        run: |
+          wget https://apt.llvm.org/llvm.sh
+          chmod +x llvm.sh
+          sudo ./llvm.sh "${LLVM_VERSION}"
+          echo "/usr/lib/llvm-${LLVM_VERSION}/bin" >> "${GITHUB_PATH}"
+      - name: Install OPAM
+        run: sudo apt-get install -y opam
+      - name: Cache ASLp
+        id: cache-aslp
+        uses: actions/cache@v4
+        with:
+          path: ${{ env.ASLP_PATH }}
+          key: aslp-${{ runner.os }}-${{ hashFiles('main/cranelift/isle/veri/veri/script/install/aslp.sh') }}
+      - name: Install ASLp
+        if: steps.cache-aslp.outputs.cache-hit != 'true'
+        working-directory: main/cranelift/isle/veri/veri
+        run: |
+          mkdir -p "${ASLP_PATH}"
+          ./script/install/aslp.sh -i "${ASLP_PATH}" -t "${RUNNER_TEMP}"
+      - name: Configure ASLp
+        run: echo "${ASLP_PATH}/bin" >> $GITHUB_PATH
+
+      - name: Generate ISA Specifications
+        working-directory: main/cranelift/isle/veri/isaspec
+        run: ./script/generate.sh -l
+      - name: Git Status
+        working-directory: main
+        run: |
+          git diff
+          test -z "$(git status --porcelain)"
+
+      - name: Generate ASLp Test Data
+        working-directory: main/cranelift/isle/veri/aslp/tests/data
+        run: ./generate.sh
+      - name: Git Status
+        working-directory: main
+        run: |
+          git diff
+          test -z "$(git status --porcelain)"
diff --git a/.github/workflows/cargo-audit.yml b/.github/workflows/cargo-audit.yml
deleted file mode 100644
index d17cc3674230..000000000000
--- a/.github/workflows/cargo-audit.yml
+++ /dev/null
@@ -1,15 +0,0 @@
-name: Run cargo-audit
-on:
-  schedule:
-    - cron: '0 0 * * *'
-jobs:
-  security_audit:
-    if: github.repository == 'bytecodealliance/wasmtime'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          submodules: true
-      - uses: actions-rs/audit-check@v1
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 000000000000..d6064760f399
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,95 @@
+name: ci
+
+on:
+  push:
+    branches:
+      - veriisle
+  pull_request:
+    branches:
+      - veriisle
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: true
+      - name: Setup Rust Toolchain
+        uses: dtolnay/rust-toolchain@1.85
+        with:
+          targets: wasm32-wasip1,wasm32-unknown-unknown
+          components: rustfmt
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@v2
+      - name: Setup Tools Directory
+        run: |
+          mkdir -p "${{ runner.workspace }}/tools"
+          echo "${{ runner.workspace }}/tools/bin" >> $GITHUB_PATH
+      - name: Install CVC5
+        working-directory: cranelift/isle/veri/veri
+        run: ./script/install/cvc5.sh -i "${{ runner.workspace }}/tools" -t "${RUNNER_TEMP}"
+      - name: Show CVC5 Version
+        run: cvc5 --version
+      - name: Install Z3
+        working-directory: cranelift/isle/veri/veri
+        run: ./script/install/z3.sh -b "${{ runner.workspace }}/tools/bin" -t "${RUNNER_TEMP}"
+      - name: Show Z3 Version
+        run: z3 --version
+      - name: Build
+        run: cargo build --features cranelift-isle/printer --package 'cranelift-isle*'
+      - name: Test
+        run: cargo test --features cranelift-isle/printer --package 'cranelift-isle*'
+      - name: Wast Tests
+        run: cargo test --test wast
+      - name: Format
+        run: cargo fmt --check --verbose
+
+  veri:
+    strategy:
+      matrix:
+        arch: [aarch64, x64]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          path: main
+      - name: Setup Rust Toolchain
+        uses: dtolnay/rust-toolchain@stable
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: main
+      - name: Setup Tools Directory
+        run: |
+          mkdir -p "${{ runner.workspace }}/tools"
+          echo "${{ runner.workspace }}/tools/bin" >> $GITHUB_PATH
+      - name: Install CVC5
+        working-directory: main/cranelift/isle/veri/veri
+        run: ./script/install/cvc5.sh -i "${{ runner.workspace }}/tools" -t "${RUNNER_TEMP}"
+      - name: Show CVC5 Version
+        run: cvc5 --version
+      - name: Install Z3
+        working-directory: main/cranelift/isle/veri/veri
+        run: ./script/install/z3.sh -b "${{ runner.workspace }}/tools/bin" -t "${RUNNER_TEMP}"
+      - name: Show Z3 Version
+        run: z3 --version
+      - name: Build
+        run: cargo build --release -p cranelift-isle-veri
+        working-directory: main
+      - name: Verify
+        working-directory: main/cranelift/isle/veri/veri
+        run: ./script/verify/ci.sh -a ${{ matrix.arch }} -p release -t "${RUNNER_TEMP}" -o "${{ runner.workspace }}/output"
+      - uses: actions/upload-artifact@v4
+        if: github.event_name == 'push'
+        with:
+          name: veri-${{ matrix.arch }}
+          path: ${{ runner.workspace }}/output
+          if-no-files-found: error
+          compression-level: 9
diff --git a/.github/workflows/explorer.yml b/.github/workflows/explorer.yml
new file mode 100644
index 000000000000..fe15ec67cf94
--- /dev/null
+++ b/.github/workflows/explorer.yml
@@ -0,0 +1,51 @@
+name: explorer
+
+on:
+  push:
+    branches:
+      - veriisle
+  workflow_dispatch:
+  pull_request:
+    branches:
+      - veriisle
+    paths:
+      - '.github/workflows/explorer.yml'
+      - 'cranelift/isle/veri/veri/script/explorer.sh'
+
+# Sets permissions to allow deployment to Github Pages.
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: "pages"
+  cancel-in-progress: false
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Setup Rust Toolchain
+        uses: dtolnay/rust-toolchain@stable
+      - name: Rust Cache
+        uses: Swatinem/rust-cache@v2
+      - name: Install Tools
+        run: sudo apt-get install -y graphviz
+      - name: Build Explorer
+        working-directory: cranelift/isle/veri/veri
+        run: ./script/explorer.sh -o "${{ runner.temp }}/explorer"
+        env:
+          ISLE_EXPLORER_GRAPHS: 'true'
+      - name: Upload artifact
+        if: github.event_name != 'pull_request'
+        id: upload
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: ${{ runner.temp }}/explorer
+      - name: Deploy to GitHub Pages
+        if: steps.upload.outcome == 'success'
+        id: deployment
+        uses: actions/deploy-pages@v4
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
deleted file mode 100644
index a1ab4c206332..000000000000
--- a/.github/workflows/main.yml
+++ /dev/null
@@ -1,836 +0,0 @@
-name: CI
-on:
-  # Run CI for PRs to `main` and to release branches.
-  #
-  # Note that PRs to `main` will run a subset of tests and PRs to the
-  # `release-*` branches will run full CI.
-  pull_request:
-    branches:
-    - main
-    - 'release-*'
-
-  # Run full CI on the `main` branch once a day to prime the GitHub Actions
-  # caches used by PRs and the merge queue.
-  schedule:
-  - cron: '13 4 * * *'
-
-  # This is the CI that runs for PRs-to-merge.
-  merge_group:
-
-  push:
-    branches:
-    # Right now merge queues can't be used with wildcards in branch protections
-    # so full CI runs both on PRs to release branches as well as merges to
-    # release branches. Note that the merge to a release branch may produce a
-    # tag at the end of CI if successful and the tag will trigger the artifact
-    # uploads as well as publication to crates.io.
-    - 'release-*'
-
-defaults:
-  run:
-    shell: bash
-
-# Cancel any in-flight jobs for the same PR/branch so there's only one active
-# at a time
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  # Check Code style quickly by running `rustfmt` over all code
-  rustfmt:
-    name: Rustfmt
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - uses: ./.github/actions/install-rust
-    - run: rustup component add rustfmt
-    - run: cargo fmt --all -- --check
-
-    # common logic to cancel the entire run if this job fails
-    - run: gh run cancel ${{ github.run_id }}
-      if: failure() && github.event_name != 'pull_request'
-      env:
-        GH_TOKEN: ${{ github.token }}
-
-  # Lint dependency graph for security advisories, duplicate versions, and
-  # incompatible licences
-  cargo_deny:
-    name: Cargo deny
-    needs: determine
-    if: needs.determine.outputs.audit
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - uses: ./.github/actions/install-rust
-    - run: |
-        set -e
-        curl -L https://github.com/EmbarkStudios/cargo-deny/releases/download/0.8.5/cargo-deny-0.8.5-x86_64-unknown-linux-musl.tar.gz | tar xzf -
-        mv cargo-deny-*-x86_64-unknown-linux-musl/cargo-deny cargo-deny
-        echo `pwd` >> $GITHUB_PATH
-    - run: cargo deny check bans licenses
-
-    # common logic to cancel the entire run if this job fails
-    - run: gh run cancel ${{ github.run_id }}
-      if: failure() && github.event_name != 'pull_request'
-      env:
-        GH_TOKEN: ${{ github.token }}
-
-  # Ensure dependencies are vetted. See https://mozilla.github.io/cargo-vet/
-  cargo_vet:
-    name: Cargo vet
-    needs: determine
-    if: needs.determine.outputs.audit
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - uses: ./.github/actions/install-rust
-    - uses: ./.github/actions/install-cargo-vet
-    - run: cargo vet --locked
-
-    # common logic to cancel the entire run if this job fails
-    - run: gh run cancel ${{ github.run_id }}
-      if: failure() && github.event_name != 'pull_request'
-      env:
-        GH_TOKEN: ${{ github.token }}
-
-  # This job is a dependency of many of the jobs below. This calculates what's
-  # actually being run for this workflow. For example:
-  #
-  # * Pushes to branches, which is currently both pushes to merge queue branches
-  #   as well as release branches, perform full CI.
-  # * PRs to release branches (not `main`) run full CI.
-  # * PRs to `main` will only run a few smoke tests above plus some elements of
-  #   the test matrix. The test matrix here is determined dynamically by the
-  #   `./ci/build-test-matrix.js` script given the commits that happened and
-  #   the files modified.
-  determine:
-    name: Determine CI jobs to run
-    runs-on: ubuntu-latest
-    outputs:
-      run-full: ${{ steps.calculate.outputs.run-full }}
-      test-matrix: ${{ steps.calculate.outputs.test-matrix }}
-      test-capi: ${{ steps.calculate.outputs.test-capi }}
-      build-fuzz: ${{ steps.calculate.outputs.build-fuzz }}
-      audit: ${{ steps.calculate.outputs.audit }}
-      preview1-adapter: ${{ steps.calculate.outputs.preview1-adapter }}
-    steps:
-    - uses: actions/checkout@v3
-    - id: calculate
-      env:
-        GH_TOKEN: ${{ github.token }}
-      run: |
-        touch commits.log names.log
-        # Note that CI doesn't run on pushes to `main`, only pushes to merge
-        # queue branches and release branches, so this only runs full CI in
-        # those locations.
-        if [ "${{ github.event_name }}" != "pull_request" ]; then
-          run_full=true
-        else
-          pr=${{ github.event.number }}
-          gh pr view $pr --json commits | tee commits.log
-          gh pr diff $pr --name-only | tee names.log
-          if [ "${{ github.base_ref }}" != "main" ]; then
-            run_full=true
-          elif grep -q 'prtest:full' commits.log; then
-            run_full=true
-          fi
-          if grep -q crates.c-api names.log; then
-            echo test-capi=true >> $GITHUB_OUTPUT
-          fi
-          if grep -q fuzz names.log; then
-            echo build-fuzz=true >> $GITHUB_OUTPUT
-          fi
-          if grep -q Cargo.lock names.log; then
-            echo audit=true >> $GITHUB_OUTPUT
-          fi
-          if grep -q supply-chain names.log; then
-            echo audit=true >> $GITHUB_OUTPUT
-          fi
-          if grep -q component-adapter names.log; then
-            echo preview1-adapter=true >> $GITHUB_OUTPUT
-          fi
-        fi
-        matrix="$(node ./ci/build-test-matrix.js ./commits.log ./names.log $run_full)"
-        echo "test-matrix={\"include\":$(echo $matrix)}" >> $GITHUB_OUTPUT
-        echo "$matrix"
-
-        if [ "$run_full" = "true" ]; then
-            echo run-full=true >> $GITHUB_OUTPUT
-            echo test-capi=true >> $GITHUB_OUTPUT
-            echo build-fuzz=true >> $GITHUB_OUTPUT
-            echo audit=true >> $GITHUB_OUTPUT
-            echo preview1-adapter=true >> $GITHUB_OUTPUT
-        fi
-
-  # Build all documentation of Wasmtime, including the C API documentation,
-  # mdbook documentation, etc. This produces a `gh-pages` artifact which is what
-  # gets uploaded to the `gh-pages` branch later on.
-  doc:
-    needs: determine
-    if: needs.determine.outputs.run-full
-    name: Doc build
-    runs-on: ubuntu-latest
-    env:
-      CARGO_MDBOOK_VERSION: 0.4.21
-      RUSTDOCFLAGS: -Dbroken_intra_doc_links --cfg nightlydoc
-      OPENVINO_SKIP_LINKING: 1
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - uses: ./.github/actions/install-rust
-      with:
-        toolchain: nightly-2023-07-02
-
-    # Build C API documentation
-    - run: curl -L https://sourceforge.net/projects/doxygen/files/rel-1.9.3/doxygen-1.9.3.linux.bin.tar.gz/download | tar xzf -
-    - run: echo "`pwd`/doxygen-1.9.3/bin" >> $GITHUB_PATH
-    - run: cd crates/c-api && doxygen doxygen.conf
-
-    # install mdbook, build the docs, and test the docs
-    - uses: actions/cache@v3
-      with:
-        path: ${{ runner.tool_cache }}/mdbook
-        key: cargo-mdbook-bin-${{ env.CARGO_MDBOOK_VERSION }}
-    - run: |
-        echo "${{ runner.tool_cache }}/mdbook/bin" >> $GITHUB_PATH
-        cargo install --root ${{ runner.tool_cache }}/mdbook --version ${{ env.CARGO_MDBOOK_VERSION }} mdbook
-    - run: (cd docs && mdbook build)
-    - run: cargo build -p wasmtime-wasi --features wasmtime/wat,wasmtime/cranelift
-    - run: (cd docs/rust_wasi_markdown_parser && cargo build)
-    - run: (cd docs && mdbook test -L ../target/debug/deps)
-
-    # Build Rust API documentation.
-    # We pass in the `component-model` feature
-    # to match the docs.rs metadata in
-    # crates/wasmtime/Cargo.toml.
-    - run: |
-        cargo doc --no-deps --workspace \
-          --exclude wasmtime-cli \
-          --exclude test-programs \
-          --exclude wasi-http-tests \
-          --exclude cranelift-codegen-meta \
-          --features component-model
-    - run: cargo doc --package cranelift-codegen-meta --document-private-items
-
-    # Assemble the documentation, and always upload it as an artifact for
-    # inspection on PRs and such.
-    - run: |
-        mv docs/book gh-pages
-        mv crates/c-api/html gh-pages/c-api
-        mv target/doc gh-pages/api
-        tar czf gh-pages.tar.gz gh-pages
-    - uses: actions/upload-artifact@v3
-      with:
-        name: gh-pages
-        path: gh-pages.tar.gz
-
-    # common logic to cancel the entire run if this job fails
-    - run: gh run cancel ${{ github.run_id }}
-      if: failure() && github.event_name != 'pull_request'
-      env:
-        GH_TOKEN: ${{ github.token }}
-
-  # Checks of various feature combinations and whether things
-  # compile. The goal here isn't to run tests, mostly just serve as a
-  # double-check that Rust code compiles and is likely to work everywhere else.
-  checks:
-    needs: determine
-    if: needs.determine.outputs.run-full
-    name: Check
-    runs-on: ubuntu-latest
-    env:
-      CARGO_NDK_VERSION: 2.12.2
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - uses: ./.github/actions/install-rust
-
-    # Check some feature combinations of the `wasmtime` crate
-    - run: cargo check -p wasmtime --no-default-features
-    - run: cargo check -p wasmtime --no-default-features --features wat
-    - run: cargo check -p wasmtime --no-default-features --features jitdump
-    - run: cargo check -p wasmtime --no-default-features --features vtune
-    - run: cargo check -p wasmtime --no-default-features --features cache
-    - run: cargo check -p wasmtime --no-default-features --features async
-    - run: cargo check -p wasmtime --no-default-features --features pooling-allocator
-    - run: cargo check -p wasmtime --no-default-features --features cranelift
-    - run: cargo check -p wasmtime --no-default-features --features component-model
-    - run: cargo check -p wasmtime --no-default-features --features cranelift,wat,async,cache
-    - run: cargo check -p wasmtime --no-default-features --features winch
-    - run: cargo check -p wasmtime --no-default-features --features wmemcheck
-    - run: cargo check --features component-model
-    - run: cargo check -p wasmtime --features incremental-cache
-
-    # Check that benchmarks of the cranelift project build
-    - run: cargo check --benches -p cranelift-codegen
-
-    # Check some feature combinations of the `wasmtime-c-api` crate
-    - run: cargo check -p wasmtime-c-api --no-default-features
-    - run: cargo check -p wasmtime-c-api --no-default-features --features wat
-    - run: cargo check -p wasmtime-c-api --no-default-features --features wasi
-
-    # Check a few builds of the cranelift backend
-    # - only x86 backend support,
-    # - only arm64 backend support,
-    # - no debug_assertions.
-    - run: cargo check --manifest-path=./cranelift/Cargo.toml --bin clif-util --no-default-features --features=cranelift-codegen/arm64
-    - run: cargo check --manifest-path=./cranelift/Cargo.toml --bin clif-util --no-default-features --features=cranelift-codegen/x86
-    - run: cargo check --manifest-path=./cranelift/Cargo.toml --bin clif-util
-      env:
-        CARGO_PROFILE_DEV_DEBUG_ASSERTIONS: false
-
-    # Check whether `wasmtime` cross-compiles to x86_64-unknown-freebsd
-    # TODO: We aren't building with default features since the `ittapi` crate fails to compile on freebsd.
-    - run: rustup target add x86_64-unknown-freebsd
-    - run: cargo check -p wasmtime --no-default-features --features cranelift,wat,async,cache --target x86_64-unknown-freebsd
-
-    # Check whether `wasmtime` cross-compiles to aarch64-linux-android
-    - run: rustup target add aarch64-linux-android
-    - name: Setup Android SDK
-      uses: android-actions/setup-android@v2
-    - uses: actions/cache@v3
-      with:
-        path: ${{ runner.tool_cache }}/cargo-ndk
-        key: cargo-ndk-bin-${{ env.CARGO_NDK_VERSION }}
-    - run: echo "${{ runner.tool_cache }}/cargo-ndk/bin" >> $GITHUB_PATH
-    - run: cargo install --root ${{ runner.tool_cache }}/cargo-ndk --version ${{ env.CARGO_NDK_VERSION }} cargo-ndk
-    - run: cargo ndk -t arm64-v8a check -p wasmtime
-
-    # common logic to cancel the entire run if this job fails
-    - run: gh run cancel ${{ github.run_id }}
-      if: failure() && github.event_name != 'pull_request'
-      env:
-        GH_TOKEN: ${{ github.token }}
-
-  # Check whether `wasmtime` cross-compiles to aarch64-pc-windows-msvc
-  # We don't build nor test it because it lacks trap handling.
-  # Tracking issue: https://github.com/bytecodealliance/wasmtime/issues/4992
-  checks_winarm64:
-    needs: determine
-    if: needs.determine.outputs.run-full
-    name: Check Windows ARM64
-    runs-on: windows-latest
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - uses: ./.github/actions/install-rust
-    - run: rustup target add aarch64-pc-windows-msvc
-    - run: cargo check -p wasmtime --target aarch64-pc-windows-msvc
-
-    # common logic to cancel the entire run if this job fails
-    - run: gh run cancel ${{ github.run_id }}
-      if: failure() && github.event_name != 'pull_request'
-      env:
-        GH_TOKEN: ${{ github.token }}
-
-  # Verify all fuzz targets compile successfully
-  fuzz_targets:
-    needs: determine
-    if: needs.determine.outputs.build-fuzz
-    name: Fuzz Targets
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    # Note that building with fuzzers requires nightly since it uses unstable
-    # flags to rustc.
-    - uses: ./.github/actions/install-rust
-      with:
-        toolchain: nightly-2023-07-02
-    - run: cargo install cargo-fuzz --vers "^0.11"
-    # Install the OCaml packages necessary for fuzz targets that use the
-    # `wasm-spec-interpreter`.
-    - run: sudo apt-get update && sudo apt install -y ocaml-nox ocamlbuild ocaml-findlib libzarith-ocaml-dev
-    - run: cargo fetch
-      working-directory: ./fuzz
-    - run: cargo fuzz build --dev -s none
-    # Check that the ISLE fuzz targets build too.
-    - run: cargo fuzz build --dev -s none --fuzz-dir ./cranelift/isle/fuzz
-
-    # common logic to cancel the entire run if this job fails
-    - run: gh run cancel ${{ github.run_id }}
-      if: failure() && github.event_name != 'pull_request'
-      env:
-        GH_TOKEN: ${{ github.token }}
-
-  # Perform all tests (debug mode) for `wasmtime`.
-  #
-  # Note that the full matrix for what may run here is defined within
-  # `./ci/build-test-matrix.js` and the execution of the `determine` step will
-  # calculate whether the tests are actually run as part of PRs and such.
-  test:
-    needs: determine
-    name: ${{ matrix.name }}
-    runs-on: ${{ matrix.os }}
-    env:
-      QEMU_BUILD_VERSION: 8.1.1
-    strategy:
-      fail-fast: true
-      matrix: ${{ fromJson(needs.determine.outputs.test-matrix) }}
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - uses: ./.github/actions/install-rust
-      with:
-        toolchain: ${{ matrix.rust }}
-
-    # Install targets in order to build various tests throughout the repo
-    - run: rustup target add wasm32-wasi wasm32-unknown-unknown ${{ matrix.target }}
-    - run: echo CARGO_BUILD_TARGET=${{ matrix.target }} >> $GITHUB_ENV
-      if: matrix.target != ''
-
-    # Fix an ICE for now in gcc when compiling zstd with debuginfo (??)
-    - run: echo CFLAGS=-g0 >> $GITHUB_ENV
-      if: matrix.target == 'x86_64-pc-windows-gnu'
-
-    - run: cargo fetch --locked
-    - run: cargo fetch --locked --manifest-path crates/test-programs/wasi-tests/Cargo.toml
-    - run: cargo fetch --locked --manifest-path crates/test-programs/wasi-http-tests/Cargo.toml
-
-    - uses: actions/cache@v3
-      with:
-        path: ${{ runner.tool_cache }}/qemu
-        key: qemu-${{ matrix.target }}-${{ env.QEMU_BUILD_VERSION }}-patchcpuinfo
-      if: matrix.target != '' && matrix.os == 'ubuntu-latest'
-    - name: Install cross-compilation tools
-      run: |
-        set -ex
-        sudo apt-get update
-        sudo apt-get install -y ${{ matrix.gcc_package }} ninja-build
-
-        # Configure Cargo for cross compilation and tell it how it can run
-        # cross executables
-        upcase=$(echo ${{ matrix.target }} | awk '{ print toupper($0) }' | sed 's/-/_/g')
-        echo CARGO_TARGET_${upcase}_RUNNER=${{ runner.tool_cache }}/qemu/bin/${{ matrix.qemu }} >> $GITHUB_ENV
-        echo CARGO_TARGET_${upcase}_LINKER=${{ matrix.gcc }} >> $GITHUB_ENV
-
-        # QEMU emulation is not always the speediest, so total testing time
-        # goes down if we build the libs in release mode when running tests.
-        echo CARGO_PROFILE_DEV_OPT_LEVEL=2 >> $GITHUB_ENV
-
-        # See comments in the source for why we enable this during QEMU
-        # emulation.
-        echo WASMTIME_TEST_NO_HOG_MEMORY=1 >> $GITHUB_ENV
-
-        # See if qemu is already in the cache
-        if [ -f ${{ runner.tool_cache }}/qemu/built ]; then
-          exit 0
-        fi
-
-        # Download and build qemu from source since the most recent release is
-        # way faster at arm emulation than the current version github actions'
-        # ubuntu image uses. Disable as much as we can to get it to build
-        # quickly.
-        curl https://download.qemu.org/qemu-$QEMU_BUILD_VERSION.tar.xz | tar xJf -
-        cd qemu-$QEMU_BUILD_VERSION
-        ./configure --target-list=${{ matrix.qemu_target }} --prefix=${{ runner.tool_cache}}/qemu --disable-tools --disable-slirp --disable-fdt --disable-capstone --disable-docs
-        ninja -C build install
-        touch ${{ runner.tool_cache }}/qemu/built
-      if: matrix.gcc != ''
-
-    # Build and test the C API with example C programs along with the example
-    # Rust programs. Note that this only executes if the `determine` step told
-    # us to test the capi which is off-by-default for PRs.
-    - run: cmake -Sexamples -Bexamples/build -DBUILD_SHARED_LIBS=OFF
-      if: matrix.target == '' && needs.determine.outputs.test-capi
-    - run: cmake --build examples/build --config Debug
-      if: matrix.target == '' && needs.determine.outputs.test-capi
-    - run: cmake -E env CTEST_OUTPUT_ON_FAILURE=1 cmake --build examples/build --config Debug --target RUN_TESTS
-      env:
-        RUST_BACKTRACE: 1
-      if: matrix.target == '' && matrix.os == 'windows-latest' && needs.determine.outputs.test-capi
-    - run: cmake -E env CTEST_OUTPUT_ON_FAILURE=1 cmake --build examples/build --config Debug --target test
-      env:
-        RUST_BACKTRACE: 1
-      if: matrix.target == '' && matrix.os != 'windows-latest' && needs.determine.outputs.test-capi
-
-    # Ensure wit definitions are in sync: both wasmtime-wasi and wasmtime-wasi-http need their own
-    # copy of the wit definitions so publishing works, but we need to ensure they are identical copies.
-    - name: Check that the wasi and wasi-http wit directories agree
-      run: |
-        diff -ru crates/wasi/wit crates/wasi-http/wit
-
-    # Build and test all features
-    - run: ./ci/run-tests.sh --locked
-      env:
-        RUST_BACKTRACE: 1
-
-    # Test debug (DWARF) related functionality.
-    - run: |
-        sudo apt-get update && sudo apt-get install -y gdb lldb llvm
-        cargo test test_debug_dwarf -- --ignored --test-threads 1
-      if: matrix.os == 'ubuntu-latest' && matrix.target == ''&& needs.determine.outputs.run-full
-      env:
-        RUST_BACKTRACE: 1
-
-    # NB: the test job here is explicitly lacking in cancellation of this run if
-    # something goes wrong. These take the longest anyway and otherwise if
-    # Windows fails GitHub Actions will confusingly mark the failed Windows job
-    # as cancelled instead of failed.
-
-  # Build and test the wasi-nn module.
-  test_wasi_nn:
-    needs: determine
-    # FIXME(#7125) flaky at the moment
-    if: needs.determine.outputs.run-full && false
-    name: Test wasi-nn module
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          submodules: true
-      - uses: ./.github/actions/install-rust
-      - run: rustup target add wasm32-wasi
-      - uses: abrown/install-openvino-action@v6
-        with:
-          version: 2022.3.0
-          apt: true
-      - run: ./ci/run-wasi-nn-example.sh
-        env:
-          RUST_BACKTRACE: 1
-
-      # common logic to cancel the entire run if this job fails
-      - run: gh run cancel ${{ github.run_id }}
-        if: failure() && github.event_name != 'pull_request'
-        env:
-          GH_TOKEN: ${{ github.token }}
-
-  build-preview1-component-adapter:
-    name: Build wasi-preview1-component-adapter
-    needs: determine
-    if: needs.determine.outputs.preview1-adapter
-    runs-on: ubuntu-latest
-    permissions:
-      deployments: write
-      contents: write
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - run: rustup update stable && rustup default stable
-    - run: rustup target add wasm32-wasi wasm32-unknown-unknown
-
-    - name: Install wasm-tools
-      run: |
-        curl -L https://github.com/bytecodealliance/wasm-tools/releases/download/wasm-tools-1.0.27/wasm-tools-1.0.27-x86_64-linux.tar.gz | tar xfz -
-        echo `pwd`/wasm-tools-1.0.27-x86_64-linux >> $GITHUB_PATH
-
-    - run: ./ci/build-wasi-preview1-component-adapter.sh
-      env:
-        VERSION: ${{ github.sha }}
-
-    - uses: actions/upload-artifact@v3
-      with:
-        name: bins-wasi-preview1-component-adapter
-        path: target/wasm32-unknown-unknown/release/wasi_snapshot_preview1.*.wasm
-
-
-    # common logic to cancel the entire run if this job fails
-    - run: gh run cancel ${{ github.run_id }}
-      if: failure() && github.event_name != 'pull_request'
-      env:
-        GH_TOKEN: ${{ github.token }}
-
-
-  bench:
-    needs: determine
-    if: needs.determine.outputs.run-full
-    name: Run benchmarks
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - uses: ./.github/actions/install-rust
-    - run: rustup target add wasm32-wasi
-    - run: cargo test --benches --release
-
-    # common logic to cancel the entire run if this job fails
-    - run: gh run cancel ${{ github.run_id }}
-      if: failure() && github.event_name != 'pull_request'
-      env:
-        GH_TOKEN: ${{ github.token }}
-
-  # Verify that cranelift's code generation is deterministic
-  meta_deterministic_check:
-    needs: determine
-    if: needs.determine.outputs.run-full
-    name: Meta deterministic check
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - uses: ./.github/actions/install-rust
-    - run: cd cranelift/codegen && cargo build --features all-arch
-    - run: ci/ensure_deterministic_build.sh
-
-    # common logic to cancel the entire run if this job fails
-    - run: gh run cancel ${{ github.run_id }}
-      if: failure() && github.event_name != 'pull_request'
-      env:
-        GH_TOKEN: ${{ github.token }}
-
-  verify-publish:
-    needs: determine
-    if: github.repository == 'bytecodealliance/wasmtime' && needs.determine.outputs.run-full
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - run: rustup update stable && rustup default stable
-    - run: |
-        cd ${{ runner.tool_cache }}
-        curl -L https://github.com/mozilla/sccache/releases/download/0.2.13/sccache-0.2.13-x86_64-unknown-linux-musl.tar.gz | tar xzf -
-        echo "`pwd`/sccache-0.2.13-x86_64-unknown-linux-musl" >> $GITHUB_PATH
-        echo RUSTC_WRAPPER=sccache >> $GITHUB_ENV
-    - run: rustc scripts/publish.rs
-    # Make sure the tree is publish-able as-is
-    - run: ./publish verify
-    # Make sure we can bump version numbers for the next release
-    - run: ./publish bump
-
-    # common logic to cancel the entire run if this job fails
-    - run: gh run cancel ${{ github.run_id }}
-      if: failure() && github.event_name != 'pull_request'
-      env:
-        GH_TOKEN: ${{ github.token }}
-
-  # Run a subset of tests under MIRI on CI to help check the `unsafe` code in
-  # Wasmtime to make sure it's at least not obviously incorrect for basic usage.
-  # Note that this doesn't run the full test suite since MIRI can't actually run
-  # WebAssembly itself at this time (aka it doesn't support a JIT). There are a
-  # number of annotations throughout the code which gates some tests on MIRI not
-  # being run.
-  #
-  # Note that `cargo nextest` is used here additionally to get parallel test
-  # execution by default to help cut down on the time in CI.
-  miri:
-    needs: determine
-    if: needs.determine.outputs.run-full && github.repository == 'bytecodealliance/wasmtime'
-    name: Miri
-    runs-on: ubuntu-latest
-    env:
-      CARGO_NEXTEST_VERSION: 0.9.51
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - uses: ./.github/actions/install-rust
-      with:
-        toolchain: nightly-2023-07-02
-    - run: rustup component add rust-src miri
-    - uses: actions/cache@v3
-      with:
-        path: ${{ runner.tool_cache }}/cargo-nextest
-        key: cargo-nextest-bin-${{ env.CARGO_NEXTEST_VERSION }}
-    - run: echo "${{ runner.tool_cache }}/cargo-nextest/bin" >> $GITHUB_PATH
-    - run: cargo install --root ${{ runner.tool_cache }}/cargo-nextest --version ${{ env.CARGO_NEXTEST_VERSION }} cargo-nextest
-    - run: |
-        cargo miri nextest run -j4 --no-fail-fast \
-          -p wasmtime \
-          -p wasmtime-cli \
-          -p wasmtime-runtime \
-          -p wasmtime-environ
-      env:
-        MIRIFLAGS: -Zmiri-strict-provenance
-
-    # common logic to cancel the entire run if this job fails
-    - run: gh run cancel ${{ github.run_id }}
-      if: failure() && github.event_name != 'pull_request'
-      env:
-        GH_TOKEN: ${{ github.token }}
-
-  # Perform release builds of `wasmtime` and `libwasmtime.so`. Builds a variety
-  # of platforms and architectures and then uploads the release artifacts to
-  # this workflow run's list of artifacts.
-  build:
-    needs: determine
-    if: needs.determine.outputs.run-full
-    name: Release build for ${{ matrix.build }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        include:
-        - build: x86_64-linux
-          os: ubuntu-latest
-        - build: x86_64-macos
-          os: macos-latest
-        - build: aarch64-macos
-          os: macos-latest
-          target: aarch64-apple-darwin
-        - build: x86_64-windows
-          os: windows-latest
-        - build: x86_64-mingw
-          os: windows-latest
-          target: x86_64-pc-windows-gnu
-        - build: aarch64-linux
-          os: ubuntu-latest
-          target: aarch64-unknown-linux-gnu
-        - build: s390x-linux
-          os: ubuntu-latest
-          target: s390x-unknown-linux-gnu
-        - build: riscv64gc-linux
-          os: ubuntu-latest
-          target: riscv64gc-unknown-linux-gnu
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - uses: ./.github/actions/install-rust
-    # On one builder produce the source tarball since there's no need to produce
-    # it everywhere
-    - run: ./ci/build-src-tarball.sh
-      if: matrix.build == 'x86_64-linux'
-    - uses: ./.github/actions/binary-compatible-builds
-      with:
-        name: ${{ matrix.build }}
-    - run: |
-        echo CARGO_BUILD_TARGET=${{ matrix.target }} >> $GITHUB_ENV
-        rustup target add ${{ matrix.target }}
-      if: matrix.target != ''
-
-    # Build `wasmtime` and executables. Note that we include some non-default
-    # features so the # release artifacts can be maximally feature-ful.
-    - run: $CENTOS cargo build --release --bin wasmtime --features all-arch,component-model
-
-    # Build `libwasmtime.so`
-    - run: $CENTOS cargo build --release --manifest-path crates/c-api/Cargo.toml
-
-    # Assemble release artifats appropriate for this platform, then upload them
-    # unconditionally to this workflow's files so we have a copy of them.
-    - run: ./ci/build-tarballs.sh "${{ matrix.build }}" "${{ matrix.target }}"
-    - uses: actions/upload-artifact@v3
-      with:
-        name: bins-${{ matrix.build }}
-        path: dist
-
-    # common logic to cancel the entire run if this job fails
-    - run: gh run cancel ${{ github.run_id }}
-      if: failure() && github.event_name != 'pull_request'
-      env:
-        GH_TOKEN: ${{ github.token }}
-
-  # This is a "join node" which depends on all prior workflows. The merge queue,
-  # for example, gates on this to ensure that everything has executed
-  # successfully.
-  #
-  # Note that this is required currently for odd reasons with github. Notably
-  # the set of checks to enter the merge queue and leave the merge queue must
-  # be the same which means that the "build" step for example shows as skipped
-  # for PRs but expands to many different steps for merge-queue-based PRs. That
-  # means that for that step there's no single name to gate on, so it's required
-  # to have a "join" node here which joins everything.
-  #
-  # Note that this currently always runs to always report a status, even on
-  # cancellation and even if dependency steps fail. Each dependency tries to
-  # cancel the whole run if it fails, so if a test matrix entry fails, for
-  # example, it cancels the build matrix entries too. This step then tries to
-  # fail on cancellation to ensure that the dependency failures are propagated
-  # correctly.
-  ci-status:
-    name: Record the result of testing and building steps
-    runs-on: ubuntu-latest
-    needs:
-      - test
-      - build
-      - rustfmt
-      - cargo_deny
-      - cargo_vet
-      - doc
-      - checks
-      - checks_winarm64
-      - fuzz_targets
-      - test_wasi_nn
-      - bench
-      - meta_deterministic_check
-      - verify-publish
-      - determine
-      - miri
-      - build-preview1-component-adapter
-    if: always()
-    steps:
-    - name: Dump needs context
-      env:
-        CONTEXT: ${{ toJson(needs) }}
-      run: |
-        echo -e "\033[33;1;4mDump context\033[0m"
-        echo -e "$CONTEXT\n"
-    - name: Successful test and build
-      if: ${{ !(contains(needs.*.result, 'failure')) }}
-      run: exit 0
-    - name: Failing test and build
-      if: ${{ contains(needs.*.result, 'failure') }}
-      run: exit 1
-    - name: Report failure on cancellation
-      if: ${{ contains(needs.*.result, 'cancelled') || cancelled() }}
-      run: exit 1
-
-  # The purpose of this jobs is to watch for changes on the `release-*`
-  # branches of this repository and look for the term
-  # "automatically-tag-and-release-this-commit" within merged PRs/commits. Once
-  # that term is found the current version of `Cargo.toml`, the `wasmtime-cli`
-  # Cargo.toml, is created as a tag and the tag is pushed to the repo.
-  # Currently the tag is created through the GitHub API with an access token to
-  # ensure that CI is further triggered for the tag itself which performs the
-  # full release process.
-  #
-  # Note that this depends on the `ci-status` step above which is the "join"
-  # point of this workflow for when everything succeeds. the purpose of that is
-  # so that the tag is only created after the aftifacts have been uploaded for
-  # this workflow as the `publish-artifacts.yml` workflow will download these
-  # artifacts and then publish them to the tag.
-  push-tag:
-    runs-on: ubuntu-latest
-    needs: ci-status
-    if: |
-      always()
-      && needs.ci-status.result == 'success'
-      && github.event_name == 'push'
-      && startsWith(github.ref, 'refs/heads/release-')
-      && github.repository == 'bytecodealliance/wasmtime'
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-        fetch-depth: 0
-    - name: Test if tag is needed
-      run: |
-        git log ${{ github.event.before }}...${{ github.event.after }} | tee main.log
-        version=$(grep '^version =' Cargo.toml | head -n 1 | sed 's/.*"\(.*\)"/\1/')
-        echo "version: $version"
-        echo "version=$version" >> $GITHUB_OUTPUT
-        echo "sha=$(git rev-parse HEAD)" >> $GITHUB_OUTPUT
-        if grep -q "automatically-tag-and-release-this-commit" main.log; then
-          echo push-tag
-          echo "push_tag=yes" >> $GITHUB_OUTPUT
-        else
-          echo no-push-tag
-          echo "push_tag=no" >> $GITHUB_OUTPUT
-        fi
-      id: tag
-    - name: Push the tag
-      run: |
-        git_refs_url=$(jq .repository.git_refs_url $GITHUB_EVENT_PATH | tr -d '"' | sed 's/{\/sha}//g')
-        curl -iX POST $git_refs_url \
-          -H "Authorization: token ${{ secrets.PERSONAL_ACCESS_TOKEN }}" \
-          -d @- << EOF
-        {
-          "ref": "refs/tags/v${{ steps.tag.outputs.version }}",
-          "sha": "${{ steps.tag.outputs.sha }}"
-        }
-        EOF
-      if: steps.tag.outputs.push_tag == 'yes'
diff --git a/.github/workflows/performance.yml b/.github/workflows/performance.yml
deleted file mode 100644
index 0b39524a70f6..000000000000
--- a/.github/workflows/performance.yml
+++ /dev/null
@@ -1,133 +0,0 @@
-# This is a workflow triggered by PR or triggered manually
-# Runs quick performance tests and reports the comparison against HEAD
-# Test should take less than 10 minutes to run on current self-hosted devices
-name: "Performance Testing"
-
-# Controls when the action will run.
-# This workflow runs when manually triggered by keywords used in the start of a review comment
-# Currently that phrase is /bench_x64. /bench_aarch64 and /bench_all are TODOs.
-on:
-  issue_comment:
-    types: [created]
-  push:
-
-# Env variables
-env:
-  SG_COMMIT: 2ab01ac
-  GITHUB_CONTEXT: ${{ toJson(github) }}
-
-jobs:
-  Wasmtime_Repo_On_PR_Comment:
-    name: Benchmark x64 on PR comment Wasmtime repo
-    runs-on: ubuntu-latest
-    if: |
-      (github.event_name == 'issue_comment') &&
-      (github.event.issue.pull_request.url) &&
-      (contains(github.event.comment.body, '/bench_x64')) &&
-      (('abrown' == github.event.comment.user.login)
-        || ('afonso360' == github.event.comment.user.login)
-        || ('akirilov-arm' == github.event.comment.user.login)
-        || ('alexcrichton' == github.event.comment.user.login)
-        || ('bbouvier' == github.event.comment.user.login)
-        || ('bjorn3' == github.event.comment.user.login)
-        || ('cfallin' == github.event.comment.user.login)
-        || ('elliottt' == github.event.comment.user.login)
-        || ('fitzgen' == github.event.comment.user.login)
-        || ('jameysharp' == github.event.comment.user.login)
-        || ('jlb6740' == github.event.comment.user.login)
-        || ('sparker-arm' == github.event.comment.user.login)
-        || ('uweigand' == github.event.comment.user.login))
-    steps:
-      - run: echo "$GITHUB_CONTEXT"
-      - run: |
-          # Create and Push Branch
-          git clone https://wasmtime-publish:${{secrets.PERSONAL_ACCESS_TOKEN}}@github.com/bytecodealliance/wasmtime-sightglass-benchmarking.git
-          cd wasmtime-sightglass-benchmarking
-          git remote add wasmtime ${{ github.event.repository.clone_url }}
-          git fetch wasmtime refs/pull/*/merge:refs/remotes/wasmtime/pull/*/merge
-          export issue_pr_url=${{ github.event.issue.pull_request.url }}
-          export issue_commits_url=${{ github.event.issue.comments_url }}
-          export issue_ref_name=$(curl -sSL $issue_pr_url | jq -r '.head.ref' | head -n 1)
-          export issue_number=$(curl -sSL $issue_pr_url | jq -r '.number' | head -n 1)
-          export issue_merge_commit_sha=$(curl -sSL $issue_pr_url | jq -r '.merge_commit_sha' | head -n 1)
-          git submodule update --init --recursive
-          git checkout wasmtime/pull/${issue_number}/merge -b pull/${issue_number}/merge/${issue_merge_commit_sha}
-          git config user.name $(curl -sSL $issue_commits_url | jq -r '.[].commit.committer.name' | tail -n 1)
-          git config user.email $(curl -sSL $issue_commits_url | jq -r '.[].commit.committer.email' | tail -n 1)
-          git log -n 1
-          git commit --allow-empty -m "${issue_commits_url}"
-          git push origin --force pull/${issue_number}/merge/${issue_merge_commit_sha}
-          git log -n 1
-
-  Performance_Repo_On_Push:
-    name: Benchmark x64 on push Performance repo
-    runs-on: [self-hosted, linux, x64]
-    if: (github.event_name == 'push') && (github.repository == 'bytecodealliance/wasmtime-sightglass-benchmarking')
-    steps:
-      - run: echo "$GITHUB_CONTEXT"
-      - run: echo "${{ github.event.head_commit.message }}"
-      - name: "Build sightglass commit '${{ env.SG_COMMIT }}'"
-        run: |
-          cd ../ && ls -l && rm -rf ./sightglass
-          git clone https://github.com/bytecodealliance/sightglass.git && cd ./sightglass
-          git checkout ${{env.SG_COMMIT}}
-          cargo build --release
-
-      - name: Checkout patch from bytecodealliance/wasmtime (pushed and triggering on this perf repo)
-        uses: actions/checkout@v3
-        with:
-          submodules: true
-          path: wasmtime_commit
-
-      - run: rustup update nightly && rustup default nightly
-
-      - name: Build patch from bytecodealliance/wasmtime (pushed and triggering on this perf repo)
-        working-directory: ./wasmtime_commit
-        run: |
-          cargo --version
-          cargo build --release -p wasmtime-bench-api
-          cp target/release/libwasmtime_bench_api.so /tmp/wasmtime_commit.so
-
-      - name: Checkout main from bytecodealliance/wasmtime
-        uses: actions/checkout@v3
-        with:
-          ref: 'main'
-          repository: 'bytecodealliance/wasmtime'
-          submodules: true
-          path: wasmtime_main
-
-      - name: Build main from bytecodealliance/wasmtime
-        working-directory: ./wasmtime_main
-        run: |
-          cargo build --release -p wasmtime-bench-api
-          cp target/release/libwasmtime_bench_api.so /tmp/wasmtime_main.so
-
-      - name: Run performance tests
-        working-directory: ../sightglass
-        run: |
-          cargo run -- \
-          benchmark \
-          --processes 5 \
-          --iterations-per-process 5 \
-          --engine /tmp/wasmtime_main.so \
-          --engine /tmp/wasmtime_commit.so \
-          --output-file /tmp/results.txt
-
-      - name: Print Results
-        run: cat /tmp/results.txt
-
-      - id: get-comment-body
-        name: Create Results Body
-        run: |
-            body="$(cat /tmp/results.txt)"
-            body="${body//'%'/'%25'}"
-            body="${body//$'\n'/'%0A'}"
-            body="${body//$'\r'/'%0D'}"
-            echo "::set-output name=body::$body"
-
-      - name: Publish Results
-        run: |
-          curl -X POST -H "Accept: application/vnd.github.v3+json" \
-          -H "Authorization: token ${{ secrets.WASMTIME_PUBLISHING_TOKEN }}" \
-          ${{ github.event.head_commit.message }} \
-          -d '{"body": ${{ toJSON(steps.get-comment-body.outputs.body) }}}'
diff --git a/.github/workflows/publish-artifacts.yml b/.github/workflows/publish-artifacts.yml
deleted file mode 100644
index e036474d24eb..000000000000
--- a/.github/workflows/publish-artifacts.yml
+++ /dev/null
@@ -1,53 +0,0 @@
-name: Publish Artifacts
-on:
-  push:
-    branches: [main]
-    tags-ignore: [dev]
-
-permissions:
-  contents: write
-
-jobs:
-  publish:
-    name: Publish artifacts of build
-    runs-on: ubuntu-latest
-    if: github.repository == 'bytecodealliance/wasmtime'
-    steps:
-    - uses: actions/checkout@v3
-    - run: |
-        sha=${{ github.sha }}
-        run_id=$(
-          gh api -H 'Accept: application/vnd.github+json' \
-              /repos/${{ github.repository }}/actions/workflows/main.yml/runs\?exclude_pull_requests=true \
-              | jq '.workflow_runs' \
-              | jq "map(select(.head_commit.id == \"$sha\"))[0].id" \
-        )
-        gh run download $run_id
-        ls
-        find bins-*
-      env:
-        GH_TOKEN: ${{ github.token }}
-
-    # Deploy the `gh-pages.tar.gz` artifact to the `gh-pages` branch.
-    - run: tar xf gh-pages.tar.gz
-      working-directory: gh-pages
-    - name: Deploy to gh-pages
-      uses: JamesIves/github-pages-deploy-action@v4
-      with:
-        folder: ./gh-pages/gh-pages
-        single-commit: true
-        clean: true
-      if: github.ref == 'refs/heads/main'
-
-    - run: npm install --production
-      working-directory: .github/actions/github-release
-    - run: |
-        mkdir dist
-        mv -t dist bins-*/*.tar.*
-        mv -t dist bins-*/*.{zip,msi,wasm}
-    - name: Publish Release
-      uses: ./.github/actions/github-release
-      with:
-        files: "dist/*"
-        token: ${{ github.token }}
-      continue-on-error: true
diff --git a/.github/workflows/publish-to-cratesio.yml b/.github/workflows/publish-to-cratesio.yml
deleted file mode 100644
index 6d05b66778a4..000000000000
--- a/.github/workflows/publish-to-cratesio.yml
+++ /dev/null
@@ -1,25 +0,0 @@
-# The purpose of this workflow is to publish the wasmtime workspace of crates
-# whenever a wasmtime tag is created. This baiscally boils down to running
-# `scripts/publish.rs` at the right time.
-
-name: "Publish to crates.io"
-
-on:
-  push:
-    tags:
-    - 'v*'
-
-jobs:
-  publish:
-    if: github.repository == 'bytecodealliance/wasmtime'
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v3
-      with:
-        submodules: true
-    - run: rustup update stable && rustup default stable
-    - run: |
-        rustc scripts/publish.rs
-        ./publish publish
-      env:
-        CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
diff --git a/.github/workflows/release-process.yml b/.github/workflows/release-process.yml
deleted file mode 100644
index e2003a456d92..000000000000
--- a/.github/workflows/release-process.yml
+++ /dev/null
@@ -1,252 +0,0 @@
-# The purpose of this workflow is to orchestrate Wasmtime's release process as
-# much as possible. This specific workflow is responsible for a few timed parts
-# of the process:
-#
-# * On the 5th of every month a new release branch is automatically created and
-#   the version number of the `main` branch is increased
-# * On the 20th of every month the previous release branch is published.
-#
-# This automation is all done through PRs except for the creation of the release
-# branch itself which is an write-action performed by this script. Otherwise
-# humans are ideally reviewing and rubber-stamping the output of the script all
-# other steps of the way.
-#
-# Note that this script also helps manage patch releases by sending a PR to the
-# release branch with a bumped version number for all crates with a patch-bump.
-
-name: "Automated Release Process"
-on:
-  schedule:
-    # “At 00:00 on day-of-month 5.”
-    #
-    # https://crontab.guru/#0_0_5_*_*
-    - cron: '0 0 5 * *'
-    - cron: '0 0 20 * *'
-
-  # Allow manually triggering this request via the button at
-  # https://github.com/bytecodealliance/wasmtime/actions/workflows/release-process.yml
-  workflow_dispatch:
-    inputs:
-      action:
-        description: 'Publish script argument: "cut", "release-latest", or "release-patch"'
-        required: false
-        default: 'cut'
-
-jobs:
-  release_process:
-    if: "github.repository == 'bytecodealliance/wasmtime' || !github.event.schedule"
-    name: Run the release process
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          submodules: true
-      - name: Setup
-        run: |
-          rustc scripts/publish.rs
-          git config user.name 'Wasmtime Publish'
-          git config user.email 'wasmtime-publish@users.noreply.github.com'
-          git remote set-url origin https://git:${{ secrets.PERSONAL_ACCESS_TOKEN }}@github.com/${{ github.repository }}
-
-      - uses: ./.github/actions/install-rust
-      - uses: ./.github/actions/install-cargo-vet
-
-      - name: Bump major version number
-        run: |
-          set -ex
-          # Push the current contents of `main` to a new release branch
-          cur=$(./ci/print-current-version.sh)
-          git push origin HEAD:release-$cur
-
-          # Update version numbers and make a commit indicating that. Note that
-          # on merge this will not trigger a publish.
-          ./publish bump
-          num=$(./ci/print-current-version.sh)
-
-          # Add a new section to the release notes for the new version.
-          cp RELEASES.md backup-releases
-          sed "s/VERSION/$num/" ci/RELEASES-template.md > RELEASES.md
-          cat backup-releases >> RELEASES.md
-          rm backup-releases
-
-          # Update `cargo vet` entries for all the new crate versions
-          cargo vet
-
-          # Commit all of the above changes.
-          git commit -am "Bump Wasmtime to $num"
-
-          # Push the result to a branch and setup metadata for the step below
-          # that creates a PR
-          git push origin HEAD:ci/bump-to-$num
-          echo "PR_HEAD=ci/bump-to-$num" >> $GITHUB_ENV
-          echo "PR_TITLE=Bump Wasmtime to $num" >> $GITHUB_ENV
-          echo "PR_BASE=main" >> $GITHUB_ENV
-          cat > pr-body <<-EOF
-          This is an [automated pull request][process] from CI which indicates
-          that the next [\`release-$cur\` branch][branch] has been created and
-          the \`main\` branch is getting its version number bumped from $cur to
-          $num.
-
-          Maintainers should take a moment to review the [release
-          notes][RELEASES.md] for $cur, and if any changes are necessary send
-          PRs to the \`main\` branch to update [RELEASES.md] and then backport
-          these PRs to the [release branch][branch].
-
-          Maintainers should also review that aarch64-apple-darwin builds
-          are passing via [embark's CI](https://buildkite.com/embark-studios/wasmtime-aarch64-apple-darwin).
-
-          Another automated PR will be made in roughly 2 weeks time when for
-          the actual release itself.
-
-          If any issues arise on the \`main\` branch before the release is made
-          then the issue should first be fixed on \`main\` and then backported
-          to the \`release-$cur\` branch.
-
-          [RELEASES.md]: https://github.com/${{ github.repository }}/blob/main/RELEASES.md
-          [branch]: https://github.com/${{ github.repository }}/tree/release-$cur
-          [process]: https://docs.wasmtime.dev/contributing-release-process.html
-          EOF
-        if: >-
-          github.event.schedule == '0 0 5 * *' ||
-          github.event.inputs.action == 'cut'
-
-      - name: Perform latest release
-        run: |
-          set -ex
-          git fetch origin
-
-          # Determine the latest release branch
-          rustc ci/find-latest-release.rs -o /tmp/find-latest-release
-          cur=`/tmp/find-latest-release`
-
-          # Update the release date of $cur in RELEASES.md
-          rustc ci/update-release-date.rs -o /tmp/update-release-date
-          /tmp/update-release-date $(date +'%Y-%m-%d')
-
-          git commit --allow-empty -a -F-<<EOF
-          Update release date of Wasmtime $cur
-          EOF
-          git push origin HEAD:ci/release-date-for-$cur
-
-          # In addition to the PR we'll make below to perform the actual release
-          # make a second PR to the `main` branch to note the release date in
-          # the release notes.
-          cat > pr-body <<-EOF
-          This is an [automated pull request][process] from CI which is updating
-          the release date of Wasmtime $cur to today. This PR's base branch
-          is \`main\` and a second PR will be coming to perform the actual
-          release which will be targeted at \`release-$cur\`.
-
-          [process]: https://docs.wasmtime.dev/contributing-release-process.html
-          EOF
-          body=$(jq -sR < ./pr-body)
-          curl --include --request POST \
-            https://api.github.com/repos/${{ github.repository }}/pulls \
-            --header "Authorization: token ${{ secrets.PERSONAL_ACCESS_TOKEN }}" \
-            --data @- << EOF
-          {
-            "head": "ci/release-date-for-$cur",
-            "base": "main",
-            "title": "Update release date of Wasmtime $cur",
-            "body": $body,
-            "maintainer_can_modify": true
-          }
-          EOF
-
-          # Move to the most recent release branch, update the release date and
-          # commit it, indicating that the commit is what will get tagged and
-          # released
-          git reset --hard origin/release-$cur
-          git submodule update --init --recursive
-          sed -i "s/^Unreleased/Released $(date +'%Y-%m-%d')/" RELEASES.md
-          git commit --allow-empty -a -F-<<EOF
-          Release Wasmtime $cur
-
-          [automatically-tag-and-release-this-commit]
-          EOF
-
-          # Push the result to a branch and setup metadata for the step below
-          # that creates a PR
-          git push origin HEAD:ci/release-$cur
-          echo "PR_HEAD=ci/release-$cur" >> $GITHUB_ENV
-          echo "PR_TITLE=Release Wasmtime $cur" >> $GITHUB_ENV
-          echo "PR_BASE=release-$cur" >> $GITHUB_ENV
-          cat > pr-body <<-EOF
-          This is an [automated pull request][process] from CI which is
-          intended to notify maintainers that it's time to release Wasmtime
-          $cur. The [release branch][branch] was created roughly two weeks ago
-          and it's now time for it to be published and released.
-
-          It's recommended that maintainers double-check that [RELEASES.md]
-          is up-to-date and that there are no known issues before merging this
-          PR. When this PR is merged a release tag will automatically be
-          created, crates will be published, and CI artifacts will be produced.
-
-          [RELEASES.md]: https://github.com/${{ github.repository }}/blob/main/RELEASES.md
-          [process]: https://docs.wasmtime.dev/contributing-release-process.html
-          [branch]: https://github.com/${{ github.repository }}/tree/release-$cur
-          EOF
-        if: >-
-          github.event.schedule == '0 0 20 * *' ||
-          github.event.inputs.action == 'release-latest'
-
-      - name: Bump and release patch version number
-        run: |
-          set -ex
-          # Update version numbers on a patch basis and update RELEASES.md if a
-          # patch release marker is already in there. Note that this commit
-          # message indicates that on-merge a release will be made.
-          ./publish bump-patch
-          # Update `cargo vet` entries for all the new crate versions
-          cargo vet
-          sed -i "s/^Unreleased/Released $(date +'%Y-%m-%d')/" RELEASES.md
-          num=$(./ci/print-current-version.sh)
-          git commit -a -F-<<EOF
-          Release Wasmtime $num
-
-          [automatically-tag-and-release-this-commit]
-          EOF
-
-          # Push the result to a branch and setup metadata for the step below
-          # that creates a PR
-          git push origin HEAD:ci/bump-to-$num
-          echo "PR_HEAD=ci/bump-to-$num" >> $GITHUB_ENV
-          echo "PR_TITLE=Release Wasmtime $num" >> $GITHUB_ENV
-          echo "PR_BASE=${{ github.ref_name }}" >> $GITHUB_ENV
-          cat > pr-body <<-EOF
-          This is an [automated pull request][process] from CI to create a patch
-          release for Wasmtime $num, requested by @${{ github.actor }}.
-
-          It's recommended that maintainers double-check that [RELEASES.md]
-          is up-to-date and that there are no known issues before merging this
-          PR. When this PR is merged a release tag will automatically be
-          created, crates will be published, and CI artifacts will be produced.
-
-          [RELEASES.md]: https://github.com/${{ github.repository }}/blob/main/RELEASES.md
-          [process]: https://docs.wasmtime.dev/contributing-release-process.html
-          EOF
-
-        if: github.event.inputs.action == 'release-patch'
-
-      - name: Make a PR
-        # Note that the syntax here is kinda funky, and the general gist is that
-        # I couldn't figure out a good way to have a multiline string-literal
-        # become a json-encoded string literal to send to GitHub. This
-        # represents my best attempt.
-        run: |
-          set -ex
-          body=$(jq -sR < ./pr-body)
-
-          curl --include --request POST \
-            https://api.github.com/repos/${{ github.repository }}/pulls \
-            --header "Authorization: token ${{ secrets.PERSONAL_ACCESS_TOKEN }}" \
-            --data @- << EOF
-          {
-            "head": "$PR_HEAD",
-            "base": "$PR_BASE",
-            "title": "$PR_TITLE",
-            "body": $body,
-            "maintainer_can_modify": true
-
-          }
-          EOF
diff --git a/.github/workflows/triage.yml b/.github/workflows/triage.yml
deleted file mode 100644
index c7bde9931c42..000000000000
--- a/.github/workflows/triage.yml
+++ /dev/null
@@ -1,38 +0,0 @@
-name: "Issue / PR Triage"
-
-on:
-  issues:
-    types: ["labeled"]
-  schedule:
-    # Run pull request triage once an hour. Ideally, this would be on
-    # "labeled" types of pull request events, but that doesn't work if the pull
-    # request is from another fork. For example, see
-    # https://github.com/actions/labeler/issues/12
-    - cron: '42 * * * *'
-
-concurrency:
-  group: issue-triage
-  cancel-in-progress: true
-
-jobs:
-  triage:
-    if: github.repository == 'bytecodealliance/wasmtime'
-    runs-on: ubuntu-latest
-    steps:
-
-    # Automatically label PRs that touch certain directories with certain
-    # labels.
-    - uses: bytecodealliance/labeler@schedule-fork
-      with:
-        repo-token: "${{ secrets.GITHUB_TOKEN }}"
-
-    # @-mention people who are subscribed to a label when an issue/PR is given
-    # that label.
-    - uses: bytecodealliance/subscribe-to-label-action@v1
-      with:
-        repo-token: "${{ secrets.GITHUB_TOKEN }}"
-
-    # Leave pre-determined comments on issues/PRs that are given a certain label.
-    - uses: bytecodealliance/label-messager-action@v1
-      with:
-        repo-token: "${{ secrets.GITHUB_TOKEN }}"
diff --git a/.gitignore b/.gitignore
index 7790b83f8725..c28c8df7f777 100644
--- a/.gitignore
+++ b/.gitignore
@@ -23,3 +23,4 @@ vendor
 examples/build
 examples/.cache
 *.coredump
+crates/explorer/node_modules
diff --git a/.gitmodules b/.gitmodules
index 2f6c628a2f24..e1fa8b72c643 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,15 +1,6 @@
 [submodule "tests/spec_testsuite"]
 	path = tests/spec_testsuite
 	url = https://github.com/WebAssembly/testsuite
-[submodule "crates/c-api/wasm-c-api"]
-	path = crates/c-api/wasm-c-api
-	url = https://github.com/WebAssembly/wasm-c-api
-[submodule "crates/wasi-common/WASI"]
-	path = crates/wasi-common/WASI
-	url = https://github.com/WebAssembly/WASI
-[submodule "crates/wasi-nn/spec"]
-	path = crates/wasi-nn/spec
-	url = https://github.com/WebAssembly/wasi-nn
 [submodule "tests/wasi_testsuite/wasi-threads"]
 	path = tests/wasi_testsuite/wasi-threads
 	url = https://github.com/WebAssembly/wasi-threads
diff --git a/ADOPTERS.md b/ADOPTERS.md
index 581828946d9d..e211ab5378d6 100644
--- a/ADOPTERS.md
+++ b/ADOPTERS.md
@@ -14,5 +14,6 @@ Wasmtime is used in many different production use-cases. This list has grown sig
 | [Fermyon](https://fermyon.com) | [@tschneidereit](https://github.com/tschneidereit) | ![production](https://img.shields.io/badge/-production-blue?style=flat) | Fermyon Cloud is a cloud application platform for WebAssembly-based serverless functions and microservices. |
 | [InfinyOn](https://infinyon.com/) | [@sehz](https://github.com/sehz) | ![production](https://img.shields.io/badge/-production-blue?style=flat) | InfinyOn leverages the power of WebAssembly SmartModules to execute real-time data transformations. |
 | [Microsoft](https://microsoft.com/) | [@devigned](https://gist.github.com/devigned) | ![production](https://img.shields.io/badge/-production-blue?style=flat) | Microsoft has had Wasmtime in preview for its WebAssembly System Interface (WASI) node pools in Azure Kubernetes Service since October 2021. |
+| [Redpanda](https://redpanda.com/) | [@rockwotj](https://github.com/rockwotj) | ![beta](https://img.shields.io/badge/-production-blue?style=flat) | Redpanda Data Transforms allow developers to transform data directly in the message broker. |
 | [Shopify](https://www.shopify.com/) | [@saulecabrera](https://github.com/saulecabrera) | ![production](https://img.shields.io/badge/-production-blue?style=flat) | Shopify Functions allow developers to customize the backend logic of Shopify. |
-| [SingleStore](https://www.singlestore.com/) | [@Kylebrown9](https://github.com/Kylebrown9) | ![production](https://img.shields.io/badge/-production-blue?style=flat) | SingleStoreDB Cloud embeds Wasmtime to bring developers' code to the data, safely and with speed and scale. |
+| [SingleStore](https://www.singlestore.com/) | [@pvetere](https://github.com/pvetere) | ![production](https://img.shields.io/badge/-production-blue?style=flat) | SingleStoreDB Cloud embeds Wasmtime to bring developers' code to the data, safely and with speed and scale. |
diff --git a/CODEOWNERS b/CODEOWNERS
index 61d8a372db8d..b4bbf31eff2f 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -39,4 +39,5 @@
 /winch/     @bytecodealliance/wasmtime-compiler-reviewers
 
 # Fuzz testing
-/fuzz/ @bytecodealliance/wasmtime-fuzz-reviewers
+/fuzz/          @bytecodealliance/wasmtime-fuzz-reviewers
+/crates/fuzzing @bytecodealliance/wasmtime-fuzz-reviewers
diff --git a/Cargo.lock b/Cargo.lock
index ebde4e29ce0a..33fbe023c07b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4,9 +4,9 @@ version = 3
 
 [[package]]
 name = "addr2line"
-version = "0.21.0"
+version = "0.22.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a30b2e23b9e17a9f90641c7ab1549cd9b44f296d3ccbf309d2863cfe398a0cb"
+checksum = "6e4503c46a5c0c7844e948c9a4d6acd9f50cccb4de1c48eb9e291ea17470c678"
 dependencies = [
  "gimli",
 ]
@@ -19,13 +19,14 @@ checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
 
 [[package]]
 name = "ahash"
-version = "0.8.2"
+version = "0.8.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf6ccdb167abbf410dcb915cabd428929d7f6a04980b54a11f26a39f1c7f7107"
+checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011"
 dependencies = [
  "cfg-if",
  "once_cell",
  "version_check",
+ "zerocopy",
 ]
 
 [[package]]
@@ -43,6 +44,15 @@ version = "0.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e9d4ee0d472d1cd2e28c97dfa124b3d8d992e10eb0a035f33f5d12e3a177ba3b"
 
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "anes"
 version = "0.1.6"
@@ -85,7 +95,7 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5ca11d4be1bab0c8bc8734a9aa7bf4ee8316d462a08c6ac5052f888fef5b494b"
 dependencies = [
- "windows-sys",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -95,7 +105,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "180abfa45703aebe0093f79badacc01b8fd4ea2e35118747e5811127f926e188"
 dependencies = [
  "anstyle",
- "windows-sys",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -103,16 +113,25 @@ name = "anyhow"
 version = "1.0.75"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a4668cab20f66d8d020e1fbc0ebe47217433c1b6c8f2040faf858554e394ace6"
+dependencies = [
+ "backtrace",
+]
 
 [[package]]
 name = "arbitrary"
-version = "1.3.0"
+version = "1.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2d098ff73c1ca148721f37baad5ea6a465a13f9573aba8641fbbbae8164a54e"
+checksum = "a2e1373abdaa212b704512ec2bd8b26bd0b7d5c3f70117411a5d9a451383c859"
 dependencies = [
  "derive_arbitrary",
 ]
 
+[[package]]
+name = "arrayvec"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b"
+
 [[package]]
 name = "async-trait"
 version = "0.1.71"
@@ -121,18 +140,7 @@ checksum = "a564d521dd56509c4c47480d00b80ee55f7e385ae48db5744c67ad50c92d2ebf"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.29",
-]
-
-[[package]]
-name = "atty"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
-dependencies = [
- "hermit-abi 0.1.19",
- "libc",
- "winapi",
+ "syn 2.0.60",
 ]
 
 [[package]]
@@ -143,9 +151,9 @@ checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
 
 [[package]]
 name = "backtrace"
-version = "0.3.69"
+version = "0.3.73"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2089b7e3f35b9dd2d0ed921ead4f6d318c27680d4a5bd167b3ee120edb105837"
+checksum = "5cc23269a4f8976d0a4d2e7109211a419fe30e8d88d677cd60b6bc79c5732e0a"
 dependencies = [
  "addr2line",
  "cc",
@@ -163,13 +171,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a4a4ddaa51a5bc52a6948f74c06d20aaaddb71924eab79b8c97a8c556e942d6a"
 
 [[package]]
-name = "bincode"
-version = "1.3.3"
+name = "base64"
+version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
-dependencies = [
- "serde",
-]
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
 [[package]]
 name = "bit-set"
@@ -194,9 +199,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.3.3"
+version = "2.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "630be753d4e58660abd17930c71b647fe46c27ea6b63cc59e1e3851406972e42"
+checksum = "327762f6e5a765692301e5bb513e0d9fef63be86bbc14528052b1cd3e6f03e07"
 
 [[package]]
 name = "block-buffer"
@@ -220,13 +225,13 @@ dependencies = [
 
 [[package]]
 name = "bumpalo"
-version = "3.12.0"
+version = "3.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d261e256854913907f67ed06efbc3338dfe6179796deefc1ff763fc1aee5535"
+checksum = "7f30e7476521f6f8af1a1c4c0b8cc94f0bee37d91763d0ca2665f299b6cd8aec"
 
 [[package]]
 name = "byte-array-literals"
-version = "14.0.0"
+version = "25.0.0"
 
 [[package]]
 name = "byteorder"
@@ -236,9 +241,15 @@ checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
 
 [[package]]
 name = "bytes"
-version = "1.4.0"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2bd12c1caf447e69cd4528f47f94d203fd2582878ecb9e9465484c4148a8223"
+
+[[package]]
+name = "bytesize"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89b2fd2a0dcf38d7971e2194b6b6eebab45ae01067456a7fd93d5547a61b70be"
+checksum = "a3e368af43e418a04d52505cf3dbc23dda4e3407ae2fa99fd0e4f308ce546acc"
 
 [[package]]
 name = "camino"
@@ -251,50 +262,50 @@ dependencies = [
 
 [[package]]
 name = "cap-fs-ext"
-version = "2.0.0"
+version = "3.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b779b2d0a001c125b4584ad586268fb4b92d957bff8d26d7fe0dd78283faa814"
+checksum = "769f8cd02eb04d57f14e2e371ebb533f96817f9b2525d73a5c72b61ca7973747"
 dependencies = [
  "cap-primitives",
  "cap-std",
- "io-lifetimes 2.0.2",
- "windows-sys",
+ "io-lifetimes 2.0.3",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "cap-net-ext"
-version = "2.0.0"
+version = "3.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ffc30dee200c20b4dcb80572226f42658e1d9c4b668656d7cc59c33d50e396e"
+checksum = "59ff6d3fb274292a9af283417e383afe6ded1fe66f6472d2c781216d3d80c218"
 dependencies = [
  "cap-primitives",
  "cap-std",
- "rustix 0.38.8",
+ "rustix 0.38.31",
  "smallvec",
 ]
 
 [[package]]
 name = "cap-primitives"
-version = "2.0.0"
+version = "3.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2bf30c373a3bee22c292b1b6a7a26736a38376840f1af3d2d806455edf8c3899"
+checksum = "90a0b44fc796b1a84535a63753d50ba3972c4db55c7255c186f79140e63d56d0"
 dependencies = [
  "ambient-authority",
  "fs-set-times",
  "io-extras",
- "io-lifetimes 2.0.2",
+ "io-lifetimes 2.0.3",
  "ipnet",
  "maybe-owned",
- "rustix 0.38.8",
- "windows-sys",
+ "rustix 0.38.31",
+ "windows-sys 0.52.0",
  "winx",
 ]
 
 [[package]]
 name = "cap-rand"
-version = "2.0.0"
+version = "3.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "577de6cff7c2a47d6b13efe5dd28bf116bd7f8f7db164ea95b7cc2640711f522"
+checksum = "4327f08daac33a99bb03c54ae18c8f32c3ba31c728a33ddf683c6c6a5043de68"
 dependencies = [
  "ambient-authority",
  "rand",
@@ -302,45 +313,35 @@ dependencies = [
 
 [[package]]
 name = "cap-std"
-version = "2.0.0"
+version = "3.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84bade423fa6403efeebeafe568fdb230e8c590a275fba2ba978dd112efcf6e9"
+checksum = "266626ce180cf9709f317d0bf9754e3a5006359d87f4bf792f06c9c5f1b63c0f"
 dependencies = [
  "cap-primitives",
  "io-extras",
- "io-lifetimes 2.0.2",
- "rustix 0.38.8",
-]
-
-[[package]]
-name = "cap-tempfile"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b9e3348a3510c4619b4c7a7bcdef09a71221da18f266bda3ed6b9aea2c509e2"
-dependencies = [
- "cap-std",
- "rand",
- "rustix 0.38.8",
- "uuid",
+ "io-lifetimes 2.0.3",
+ "rustix 0.38.31",
 ]
 
 [[package]]
 name = "cap-time-ext"
-version = "2.0.0"
+version = "3.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8f52b3c8f4abfe3252fd0a071f3004aaa3b18936ec97bdbd8763ce03aff6247"
+checksum = "e1353421ba83c19da60726e35db0a89abef984b3be183ff6f58c5b8084fcd0c5"
 dependencies = [
+ "ambient-authority",
  "cap-primitives",
+ "iana-time-zone",
  "once_cell",
- "rustix 0.38.8",
+ "rustix 0.38.31",
  "winx",
 ]
 
 [[package]]
 name = "capstone"
-version = "0.9.0"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "178b3c80b4ce3939792d1dd6600575e012da806a10e81abe812dc29cbfe629ec"
+checksum = "b08ca438d9585a2b216b0c2e88ea51e096286c5f197f7be2526bb515ef775b6c"
 dependencies = [
  "capstone-sys",
  "libc",
@@ -348,9 +349,9 @@ dependencies = [
 
 [[package]]
 name = "capstone-sys"
-version = "0.13.0"
+version = "0.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf2f3d97b88fa4a9a6464c7c08b8c4588aaea8c18d0651eca11f2ca15f50f1f6"
+checksum = "fe7183271711ffb7c63a6480e4baf480e0140da59eeba9b18fcc8bf3478950e3"
 dependencies = [
  "cc",
  "libc",
@@ -367,9 +368,9 @@ dependencies = [
 
 [[package]]
 name = "cargo_metadata"
-version = "0.15.3"
+version = "0.18.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08a1ec454bc3eead8719cb56e15dbbfecdbc14e4b3a3ae4936cc6e31f5fc0d07"
+checksum = "2d886547e41f740c616ae73108f6eb70afe6d940c7bc697cb30f13daec073037"
 dependencies = [
  "camino",
  "cargo-platform",
@@ -387,11 +388,12 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.0.73"
+version = "1.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2fff2a6927b3bb87f9595d67196a70493f627687a71d87a0d692242c33f58c11"
+checksum = "2aba8f4e9906c7ce3c73463f62a7f0c65183ada1a2d47e397cc8810827f9694f"
 dependencies = [
  "jobserver",
+ "libc",
 ]
 
 [[package]]
@@ -448,6 +450,7 @@ dependencies = [
  "anstyle",
  "clap_lex",
  "strsim",
+ "terminal_size 0.2.6",
 ]
 
 [[package]]
@@ -456,10 +459,10 @@ version = "4.3.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "54a9bb5758fc5dfe728d1019941681eccaf0cf8a4189b692a0ee2f2ecf90a050"
 dependencies = [
- "heck",
+ "heck 0.4.0",
  "proc-macro2",
  "quote",
- "syn 2.0.29",
+ "syn 2.0.60",
 ]
 
 [[package]]
@@ -468,6 +471,12 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2da6da31387c7e4ef160ffab6d5e7f00c42626fe39aea70a7b0f1773f7dd6c1b"
 
+[[package]]
+name = "cobs"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67ba02a97a2bd10f4b59b25c7973101c79642302776489e030cd13cdab09ed15"
+
 [[package]]
 name = "codespan-reporting"
 version = "0.11.1"
@@ -484,15 +493,6 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "acbf1af155f9b9ef647e42cdc158db4b64a1b61f743629225fde6f3e0be2a7c7"
 
-[[package]]
-name = "command-tests"
-version = "0.0.0"
-dependencies = [
- "anyhow",
- "getrandom",
- "wit-bindgen",
-]
-
 [[package]]
 name = "component-fuzz-util"
 version = "0.0.0"
@@ -510,7 +510,7 @@ version = "0.0.0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.29",
+ "syn 2.0.60",
 ]
 
 [[package]]
@@ -527,7 +527,7 @@ version = "0.0.0"
 dependencies = [
  "anyhow",
  "arbitrary",
- "env_logger 0.10.0",
+ "env_logger",
  "wasmtime",
 ]
 
@@ -541,16 +541,32 @@ dependencies = [
  "libc",
  "once_cell",
  "regex",
- "terminal_size",
+ "terminal_size 0.1.17",
  "unicode-width",
  "winapi",
 ]
 
+[[package]]
+name = "core-foundation"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
+
 [[package]]
 name = "cpp_demangle"
-version = "0.3.5"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eeaa953eaad386a53111e47172c2fedba671e5684c8dd601a5f474f4f118710f"
+checksum = "7e8227005286ec39567949b33df9896bcadfa6051bccca2488129f108ca23119"
 dependencies = [
  "cfg-if",
 ]
@@ -566,38 +582,56 @@ dependencies = [
 
 [[package]]
 name = "cranelift"
-version = "0.101.0"
+version = "0.112.0"
 dependencies = [
  "cranelift-codegen",
  "cranelift-frontend",
+ "cranelift-interpreter",
+ "cranelift-jit",
+ "cranelift-module",
+ "cranelift-native",
+ "cranelift-object",
 ]
 
 [[package]]
 name = "cranelift-bforest"
-version = "0.101.0"
+version = "0.112.0"
 dependencies = [
  "cranelift-entity",
 ]
 
+[[package]]
+name = "cranelift-bitset"
+version = "0.112.0"
+dependencies = [
+ "arbitrary",
+ "serde",
+ "serde_derive",
+]
+
 [[package]]
 name = "cranelift-codegen"
-version = "0.101.0"
+version = "0.112.0"
 dependencies = [
  "anyhow",
- "bincode",
  "bumpalo",
  "capstone",
  "cranelift-bforest",
+ "cranelift-bitset",
  "cranelift-codegen-meta",
  "cranelift-codegen-shared",
  "cranelift-control",
  "cranelift-entity",
  "cranelift-isle",
  "criterion",
+ "env_logger",
  "gimli",
- "hashbrown 0.14.0",
+ "hashbrown 0.14.3",
  "log",
+ "postcard",
+ "pulley-interpreter",
  "regalloc2",
+ "rustc-hash",
  "serde",
  "serde_derive",
  "sha2",
@@ -609,26 +643,27 @@ dependencies = [
 
 [[package]]
 name = "cranelift-codegen-meta"
-version = "0.101.0"
+version = "0.112.0"
 dependencies = [
  "cranelift-codegen-shared",
 ]
 
 [[package]]
 name = "cranelift-codegen-shared"
-version = "0.101.0"
+version = "0.112.0"
 
 [[package]]
 name = "cranelift-control"
-version = "0.101.0"
+version = "0.112.0"
 dependencies = [
  "arbitrary",
 ]
 
 [[package]]
 name = "cranelift-entity"
-version = "0.101.0"
+version = "0.112.0"
 dependencies = [
+ "cranelift-bitset",
  "serde",
  "serde_derive",
 ]
@@ -647,28 +682,29 @@ dependencies = [
  "cranelift-module",
  "cranelift-native",
  "cranelift-reader",
- "cranelift-wasm",
  "file-per-thread-logger",
  "filecheck",
  "gimli",
  "log",
  "num_cpus",
+ "pulley-interpreter",
  "serde",
  "serde_derive",
  "similar",
+ "smallvec",
  "target-lexicon",
  "thiserror",
  "toml",
- "wasmparser",
  "wat",
 ]
 
 [[package]]
 name = "cranelift-frontend"
-version = "0.101.0"
+version = "0.112.0"
 dependencies = [
  "cranelift-codegen",
- "hashbrown 0.14.0",
+ "env_logger",
+ "hashbrown 0.14.3",
  "log",
  "similar",
  "smallvec",
@@ -689,7 +725,7 @@ dependencies = [
 
 [[package]]
 name = "cranelift-interpreter"
-version = "0.101.0"
+version = "0.112.0"
 dependencies = [
  "cranelift-codegen",
  "cranelift-entity",
@@ -703,16 +739,85 @@ dependencies = [
 
 [[package]]
 name = "cranelift-isle"
-version = "0.101.0"
+version = "0.112.0"
 dependencies = [
  "codespan-reporting",
  "log",
+ "pretty",
+ "tempfile",
+]
+
+[[package]]
+name = "cranelift-isle-veri"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "clap",
+ "cranelift-codegen-meta",
+ "cranelift-isle",
+ "cranelift-isle-veri-test-macros",
+ "easy-smt",
+ "env_logger",
+ "log",
+ "num-bigint",
+ "num-traits",
+ "rayon",
+ "serde",
+ "serde_json",
  "tempfile",
 ]
 
+[[package]]
+name = "cranelift-isle-veri-aslp"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "clap",
+ "cranelift-isle-veri-test-macros",
+ "enquote",
+ "pest",
+ "pest_derive",
+ "reqwest",
+ "serde",
+ "tracing",
+ "tracing-subscriber",
+]
+
+[[package]]
+name = "cranelift-isle-veri-isaspec"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "clap",
+ "cranelift-codegen",
+ "cranelift-isle",
+ "cranelift-isle-veri-aslp",
+ "itertools 0.12.1",
+ "reqwest",
+ "tracing",
+ "tracing-subscriber",
+]
+
+[[package]]
+name = "cranelift-isle-veri-meta"
+version = "0.1.0"
+dependencies = [
+ "wasmparser 0.216.0",
+]
+
+[[package]]
+name = "cranelift-isle-veri-test-macros"
+version = "0.1.0"
+dependencies = [
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+]
+
 [[package]]
 name = "cranelift-jit"
-version = "0.101.0"
+version = "0.112.0"
 dependencies = [
  "anyhow",
  "cranelift",
@@ -728,24 +833,24 @@ dependencies = [
  "region",
  "target-lexicon",
  "wasmtime-jit-icache-coherence",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "cranelift-module"
-version = "0.101.0"
+version = "0.112.0"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
  "cranelift-control",
- "hashbrown 0.14.0",
+ "hashbrown 0.14.3",
  "serde",
  "serde_derive",
 ]
 
 [[package]]
 name = "cranelift-native"
-version = "0.101.0"
+version = "0.112.0"
 dependencies = [
  "cranelift-codegen",
  "libc",
@@ -754,7 +859,7 @@ dependencies = [
 
 [[package]]
 name = "cranelift-object"
-version = "0.101.0"
+version = "0.112.0"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
@@ -769,7 +874,7 @@ dependencies = [
 
 [[package]]
 name = "cranelift-reader"
-version = "0.101.0"
+version = "0.112.0"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
@@ -779,7 +884,7 @@ dependencies = [
 
 [[package]]
 name = "cranelift-serde"
-version = "0.101.0"
+version = "0.112.0"
 dependencies = [
  "clap",
  "cranelift-codegen",
@@ -806,39 +911,36 @@ dependencies = [
  "cranelift-native",
  "cranelift-object",
  "cranelift-reader",
- "cranelift-wasm",
  "filecheck",
- "fxhash",
  "indicatif",
  "log",
- "pretty_env_logger 0.5.0",
+ "pretty_env_logger",
  "rayon",
  "regalloc2",
+ "rustc-hash",
  "serde",
  "similar",
  "target-lexicon",
- "termcolor",
  "thiserror",
  "toml",
  "walkdir",
- "wat",
 ]
 
 [[package]]
 name = "cranelift-wasm"
-version = "0.101.0"
+version = "0.112.0"
 dependencies = [
  "cranelift-codegen",
  "cranelift-entity",
  "cranelift-frontend",
- "hashbrown 0.14.0",
- "itertools",
+ "hashbrown 0.14.3",
+ "itertools 0.12.1",
  "log",
  "serde",
  "serde_derive",
  "smallvec",
  "target-lexicon",
- "wasmparser",
+ "wasmparser 0.216.0",
  "wasmtime-types",
  "wat",
 ]
@@ -864,11 +966,10 @@ dependencies = [
  "clap",
  "criterion-plot",
  "is-terminal",
- "itertools",
+ "itertools 0.10.5",
  "num-traits",
  "once_cell",
  "oorandom",
- "plotters",
  "rayon",
  "regex",
  "serde",
@@ -885,17 +986,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
 dependencies = [
  "cast",
- "itertools",
-]
-
-[[package]]
-name = "crossbeam-channel"
-version = "0.5.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a33c2bf77f2df06183c3aa30d1e96c0695a313d4f9c453cc3762a6db39f99200"
-dependencies = [
- "cfg-if",
- "crossbeam-utils",
+ "itertools 0.10.5",
 ]
 
 [[package]]
@@ -965,7 +1056,7 @@ checksum = "53e0efad4403bfc52dc201159c4b842a246a14b98c64b55dfd0f2d89729dfeb8"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.29",
+ "syn 2.0.60",
 ]
 
 [[package]]
@@ -1009,12 +1100,31 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "dlmalloc"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "203540e710bfadb90e5e29930baf5d10270cec1f43ab34f46f78b147b2de715a"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "downcast-rs"
 version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9ea835d29036a4087793836fa931b08837ad5e957da9e23886b29586fb9b6650"
 
+[[package]]
+name = "easy-smt"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47cdc2566d8faac2fc64d33fdce1441600f59dcaa45f59ea846c8e5b04191623"
+dependencies = [
+ "log",
+ "unicode-segmentation",
+]
+
 [[package]]
 name = "egg"
 version = "0.6.0"
@@ -1035,6 +1145,21 @@ version = "1.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"
 
+[[package]]
+name = "embedded-io"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef1a6892d9eef45c8fa6b9e0086428a2cca8491aca8f787c534a3d6d0bcb3ced"
+
+[[package]]
+name = "embedding"
+version = "25.0.0"
+dependencies = [
+ "anyhow",
+ "dlmalloc",
+ "wasmtime",
+]
+
 [[package]]
 name = "encode_unicode"
 version = "0.3.6"
@@ -1051,16 +1176,12 @@ dependencies = [
 ]
 
 [[package]]
-name = "env_logger"
-version = "0.7.1"
+name = "enquote"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44533bbbb3bb3c1fa17d9f2e4e38bbbaf8396ba82193c4cb1b6445d711445d36"
+checksum = "06c36cb11dbde389f4096111698d8b567c0720e3452fd5ac3e6b4e47e1939932"
 dependencies = [
- "atty",
- "humantime 1.3.0",
- "log",
- "regex",
- "termcolor",
+ "thiserror",
 ]
 
 [[package]]
@@ -1069,7 +1190,7 @@ version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "85cdab6a89accf66733ad5a1693a4dcced6aeff64602b634530dd73c1f3ee9f0"
 dependencies = [
- "humantime 2.1.0",
+ "humantime",
  "is-terminal",
  "log",
  "regex",
@@ -1084,23 +1205,28 @@ checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
 
 [[package]]
 name = "errno"
-version = "0.3.1"
+version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4bcfec3a70f97c962c307b2d2c56e358cf1d00b558d74262b5f929ee8cc7e73a"
+checksum = "a258e46cdc063eb8519c00b9fc845fc47bcfca4130e2f08e88665ceda8474245"
 dependencies = [
- "errno-dragonfly",
  "libc",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
-name = "errno-dragonfly"
-version = "0.1.2"
+name = "escape8259"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf"
+checksum = "ba4f4911e3666fcd7826997b4745c8224295a6f3072f1418c3067b97a67557ee"
 dependencies = [
- "cc",
- "libc",
+ "rustversion",
+]
+
+[[package]]
+name = "example-component-wasm"
+version = "0.0.0"
+dependencies = [
+ "wit-bindgen",
 ]
 
 [[package]]
@@ -1123,22 +1249,19 @@ checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
 
 [[package]]
 name = "fastrand"
-version = "1.9.0"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e51093e27b0797c359783294ca4f0a911c270184cb10f85783b118614a1501be"
-dependencies = [
- "instant",
-]
+checksum = "25cbce373ec4653f1a01a31e8a5e5ec0c622dc27ff9c4e6606eefef5cbbed4a5"
 
 [[package]]
 name = "fd-lock"
-version = "4.0.0"
+version = "4.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b0377f1edc77dbd1118507bc7a66e4ab64d2b90c66f90726dc801e73a8c68f9"
+checksum = "7e5768da2206272c81ef0b5e951a41862938a6070da63bcea197899942d3b947"
 dependencies = [
  "cfg-if",
- "rustix 0.38.8",
- "windows-sys",
+ "rustix 0.38.31",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -1147,7 +1270,7 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a3cc21c33af89af0930c8cae4ade5e6fdc17b5d2c97b3d2e2edb67a1cf683f3"
 dependencies = [
- "env_logger 0.10.0",
+ "env_logger",
  "log",
 ]
 
@@ -1179,12 +1302,37 @@ version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cda653ca797810c02f7ca4b804b40b8b95ae046eb989d356bce17919a8c25499"
 
+[[package]]
+name = "flate2"
+version = "1.0.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f54427cfd1c7829e2a139fcefea601bf088ebca651d2bf53ebc600eac295dae"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+]
+
 [[package]]
 name = "fnv"
 version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
+[[package]]
+name = "foreign-types"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
+dependencies = [
+ "foreign-types-shared",
+]
+
+[[package]]
+name = "foreign-types-shared"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
+
 [[package]]
 name = "form_urlencoded"
 version = "1.1.0"
@@ -1196,20 +1344,20 @@ dependencies = [
 
 [[package]]
 name = "fs-set-times"
-version = "0.20.0"
+version = "0.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd738b84894214045e8414eaded76359b4a5773f0a0a56b16575110739cdcf39"
+checksum = "033b337d725b97690d86893f9de22b67b80dcc4e9ad815f348254c38119db8fb"
 dependencies = [
- "io-lifetimes 2.0.2",
- "rustix 0.38.8",
- "windows-sys",
+ "io-lifetimes 2.0.3",
+ "rustix 0.38.31",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "fslock"
-version = "0.1.8"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57eafdd0c16f57161105ae1b98a1238f97645f2f588438b2949c99a2af9616bf"
+checksum = "04412b8935272e3a9bae6f48c7bfff74c2911f60525404edfdd28e49884c3bfb"
 dependencies = [
  "libc",
  "winapi",
@@ -1270,10 +1418,13 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3ef6b17e481503ec85211fed8f39d1970f128935ca1f814cd32ac4a6842e84ab"
 dependencies = [
  "futures-core",
+ "futures-io",
  "futures-sink",
  "futures-task",
+ "memchr",
  "pin-project-lite",
  "pin-utils",
+ "slab",
 ]
 
 [[package]]
@@ -1291,7 +1442,7 @@ version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "27d12c0aed7f1e24276a241aadc4cb8ea9f83000f34bc062b7cc2d51e3b0fabd"
 dependencies = [
- "bitflags 2.3.3",
+ "bitflags 2.4.1",
  "debugid",
  "fxhash",
  "serde",
@@ -1321,34 +1472,47 @@ dependencies = [
 
 [[package]]
 name = "gimli"
-version = "0.28.0"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fb8d784f27acf97159b40fc4db5ecd8aa23b9ad5ef69cdd136d3bc80665f0c0"
+checksum = "40ecd4077b5ae9fd2e9e169b102c6c330d0605168eb0e8bf79952b256dbefffd"
 dependencies = [
  "fallible-iterator",
- "indexmap 2.0.0",
+ "indexmap 2.2.6",
  "stable_deref_trait",
 ]
 
 [[package]]
-name = "glob"
-version = "0.3.0"
+name = "h2"
+version = "0.3.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574"
+checksum = "81fe527a889e1532da5c525686d96d4c2e74cdd345badf8dfef9f6b39dd5f5e8"
+dependencies = [
+ "bytes",
+ "fnv",
+ "futures-core",
+ "futures-sink",
+ "futures-util",
+ "http 0.2.12",
+ "indexmap 2.2.6",
+ "slab",
+ "tokio",
+ "tokio-util",
+ "tracing",
+]
 
 [[package]]
 name = "h2"
-version = "0.3.19"
+version = "0.4.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d357c7ae988e7d2182f7d7871d0b963962420b0678b0997ce7de72001aeab782"
+checksum = "816ec7294445779408f36fe57bc5b7fc1cf59664059096c65f905c1c61f58069"
 dependencies = [
  "bytes",
  "fnv",
  "futures-core",
  "futures-sink",
  "futures-util",
- "http",
- "indexmap 1.9.1",
+ "http 1.0.0",
+ "indexmap 2.2.6",
  "slab",
  "tokio",
  "tokio-util",
@@ -1369,20 +1533,12 @@ checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
 
 [[package]]
 name = "hashbrown"
-version = "0.13.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e"
-dependencies = [
- "ahash",
-]
-
-[[package]]
-name = "hashbrown"
-version = "0.14.0"
+version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c6201b9ff9fd90a5a3bac2e56a830d0caa509576f0e503818ee82c181b3437a"
+checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604"
 dependencies = [
  "ahash",
+ "serde",
 ]
 
 [[package]]
@@ -1390,39 +1546,44 @@ name = "heck"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9"
-dependencies = [
- "unicode-segmentation",
-]
 
 [[package]]
-name = "hermit-abi"
-version = "0.1.19"
+name = "heck"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
-dependencies = [
- "libc",
-]
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
 name = "hermit-abi"
-version = "0.2.6"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee512640fe35acbfb4bb779db6f0d80704c2cacfa2e39b601ef3e3f47d1ae4c7"
-dependencies = [
- "libc",
+checksum = "856b5cb0902c2b6d65d5fd97dfa30f9b70c7538e770b98eab5ed52d8db923e01"
+
+[[package]]
+name = "home"
+version = "0.5.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3d1354bf6b7235cb4a0576c2619fd4ed18183f689b12b006a0ee7329eeff9a5"
+dependencies = [
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
-name = "hermit-abi"
-version = "0.3.0"
+name = "http"
+version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "856b5cb0902c2b6d65d5fd97dfa30f9b70c7538e770b98eab5ed52d8db923e01"
+checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1"
+dependencies = [
+ "bytes",
+ "fnv",
+ "itoa",
+]
 
 [[package]]
 name = "http"
-version = "0.2.9"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd6effc99afb63425aff9b05836f029929e345a6148a14b7ecd5ab67af944482"
+checksum = "b32afd38673a8016f7c9ae69e5af41a58f81b1d31689040f2f1959594ce194ea"
 dependencies = [
  "bytes",
  "fnv",
@@ -1431,24 +1592,35 @@ dependencies = [
 
 [[package]]
 name = "http-body"
-version = "1.0.0-rc.2"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2"
+dependencies = [
+ "bytes",
+ "http 0.2.12",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "http-body"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "951dfc2e32ac02d67c90c0d65bd27009a635dc9b381a2cc7d284ab01e3a0150d"
+checksum = "1cac85db508abc24a2e48553ba12a996e87244a0395ce011e62b37158745d643"
 dependencies = [
  "bytes",
- "http",
+ "http 1.0.0",
 ]
 
 [[package]]
 name = "http-body-util"
-version = "0.1.0-rc.2"
+version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92445bc9cc14bfa0a3ce56817dc3b5bcc227a168781a356b702410789cec0d10"
+checksum = "41cb79eb393015dadd30fc252023adb0b2400a0caee0fa2a077e6e21a551e840"
 dependencies = [
  "bytes",
  "futures-util",
- "http",
- "http-body",
+ "http 1.0.0",
+ "http-body 1.0.0",
  "pin-project-lite",
 ]
 
@@ -1464,15 +1636,6 @@ version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c4a1e36c821dbe04574f602848a19f742f4fb3c98d40449f11bcad18d6b17421"
 
-[[package]]
-name = "humantime"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df004cfca50ef23c36850aaaa59ad52cc70d0e90243c3c7737a4dd32dc7a3c4f"
-dependencies = [
- "quick-error 1.2.3",
-]
-
 [[package]]
 name = "humantime"
 version = "2.1.0"
@@ -1481,26 +1644,84 @@ checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
 
 [[package]]
 name = "hyper"
-version = "1.0.0-rc.3"
+version = "0.14.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b75264b2003a3913f118d35c586e535293b3e22e41f074930762929d071e092"
+checksum = "a152ddd61dfaec7273fe8419ab357f33aee0d914c5f4efbf0d96fa749eea5ec9"
 dependencies = [
  "bytes",
  "futures-channel",
  "futures-core",
  "futures-util",
- "h2",
- "http",
- "http-body",
+ "h2 0.3.26",
+ "http 0.2.12",
+ "http-body 0.4.6",
  "httparse",
  "httpdate",
  "itoa",
  "pin-project-lite",
+ "socket2",
  "tokio",
+ "tower-service",
  "tracing",
  "want",
 ]
 
+[[package]]
+name = "hyper"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "403f9214f3e703236b221f1a9cd88ec8b4adfa5296de01ab96216361f4692f56"
+dependencies = [
+ "bytes",
+ "futures-channel",
+ "futures-util",
+ "h2 0.4.4",
+ "http 1.0.0",
+ "http-body 1.0.0",
+ "httparse",
+ "httpdate",
+ "itoa",
+ "pin-project-lite",
+ "tokio",
+ "want",
+]
+
+[[package]]
+name = "hyper-tls"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905"
+dependencies = [
+ "bytes",
+ "hyper 0.14.30",
+ "native-tls",
+ "tokio",
+ "tokio-native-tls",
+]
+
+[[package]]
+name = "iana-time-zone"
+version = "0.1.59"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6a67363e2aa4443928ce15e57ebae94fd8949958fd1223c4cfc0cd473ad7539"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "wasm-bindgen",
+ "windows-core",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "id-arena"
 version = "2.2.1"
@@ -1529,12 +1750,12 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.0.0"
+version = "2.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5477fe2230a79769d8dc68e0eabf5437907c0457a5614a9e8dddb67f65eb65d"
+checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
 dependencies = [
  "equivalent",
- "hashbrown 0.14.0",
+ "hashbrown 0.14.3",
  "serde",
 ]
 
@@ -1567,30 +1788,30 @@ dependencies = [
 
 [[package]]
 name = "io-extras"
-version = "0.18.0"
+version = "0.18.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d3c230ee517ee76b1cc593b52939ff68deda3fae9e41eca426c6b4993df51c4"
+checksum = "c301e73fb90e8a29e600a9f402d095765f74310d582916a952f618836a1bd1ed"
 dependencies = [
- "io-lifetimes 2.0.2",
- "windows-sys",
+ "io-lifetimes 2.0.3",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "io-lifetimes"
-version = "1.0.10"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c66c74d2ae7e79a5a8f7ac924adbe38ee42a859c6539ad869eb51f0b52dc220"
+checksum = "eae7b9aee968036d54dce06cebaefd919e4472e753296daccd6d344e3e2df0c2"
 dependencies = [
- "hermit-abi 0.3.0",
+ "hermit-abi",
  "libc",
- "windows-sys",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
 name = "io-lifetimes"
-version = "2.0.2"
+version = "2.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bffb4def18c48926ccac55c1223e02865ce1a821751a95920448662696e7472c"
+checksum = "5a611371471e98973dbcab4e0ec66c31a10bc356eeb4d54a0e05eac8158fe38c"
 
 [[package]]
 name = "ipnet"
@@ -1600,14 +1821,13 @@ checksum = "879d54834c8c76457ef4293a689b2a8c59b076067ad77b15efafbb05f92a592b"
 
 [[package]]
 name = "is-terminal"
-version = "0.4.7"
+version = "0.4.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "adcf93614601c8129ddf72e2d5633df827ba6551541c6d8c59520a371475be1f"
+checksum = "0bad00257d07be169d870ab665980b06cdb366d792ad690bf2e76876dc503455"
 dependencies = [
- "hermit-abi 0.3.0",
- "io-lifetimes 1.0.10",
- "rustix 0.37.13",
- "windows-sys",
+ "hermit-abi",
+ "rustix 0.38.31",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -1615,7 +1835,7 @@ name = "isle-fuzz"
 version = "0.0.0"
 dependencies = [
  "cranelift-isle",
- "env_logger 0.10.0",
+ "env_logger",
  "libfuzzer-sys",
  "log",
 ]
@@ -1626,14 +1846,23 @@ version = "0.0.0"
 dependencies = [
  "clap",
  "cranelift-isle",
- "env_logger 0.10.0",
+ "env_logger",
 ]
 
 [[package]]
 name = "itertools"
-version = "0.10.3"
+version = "0.10.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9a9d19fa1e79b6215ff29b9d6880b706147f16e9b1dbb1e4e5947b5b02bc5e3"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itertools"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
 dependencies = [
  "either",
 ]
@@ -1646,9 +1875,9 @@ checksum = "1aab8fc367588b89dcee83ab0fd66b72b50b72fa1904d7095045ace2b0c81c35"
 
 [[package]]
 name = "ittapi"
-version = "0.3.4"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41e0d0b7b3b53d92a7e8b80ede3400112a6b8b4c98d1f5b8b16bb787c780582c"
+checksum = "6b996fe614c41395cdaedf3cf408a9534851090959d90d54a535f675550b64b1"
 dependencies = [
  "anyhow",
  "ittapi-sys",
@@ -1657,18 +1886,18 @@ dependencies = [
 
 [[package]]
 name = "ittapi-sys"
-version = "0.3.4"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2f8763c96e54e6d6a0dccc2990d8b5e33e3313aaeae6185921a3f4c1614a77c"
+checksum = "52f5385394064fa2c886205dba02598013ce83d3e92d33dbdc0c52fe0e7bf4fc"
 dependencies = [
  "cc",
 ]
 
 [[package]]
 name = "jobserver"
-version = "0.1.24"
+version = "0.1.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af25a77299a7f711a01975c35a6a424eb6862092cc2d6c72c4ed6cbc56dfc1fa"
+checksum = "48d1dbcbbeb6a7fec7e059840aa538bd62aaccf972c7346c4d9d2059312853d0"
 dependencies = [
  "libc",
 ]
@@ -1696,9 +1925,9 @@ checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67"
 
 [[package]]
 name = "libc"
-version = "0.2.147"
+version = "0.2.153"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4668fb0ea861c1df094127ac5f1da3409a82116a4ba74fca2e58ef927159bb3"
+checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"
 
 [[package]]
 name = "libfuzzer-sys"
@@ -1713,12 +1942,12 @@ dependencies = [
 
 [[package]]
 name = "libloading"
-version = "0.7.3"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "efbc0f03f9a775e9f6aed295c6a1ba2253c5757a9e03d55c6caa46a681abcddd"
+checksum = "c571b676ddfc9a8c12f1f3d3085a7b163966a8fd8098a90640953ce5f6170161"
 dependencies = [
  "cfg-if",
- "winapi",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -1727,17 +1956,29 @@ version = "0.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f7012b1bbb0719e1097c47611d3898568c546d597c2e74d66f6087edd5233ff4"
 
+[[package]]
+name = "libtest-mimic"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f0f4c6f44ecfd52e8b443f2ad18f2b996540135771561283c2352ce56a1c70b"
+dependencies = [
+ "clap",
+ "escape8259",
+ "termcolor",
+ "threadpool",
+]
+
 [[package]]
 name = "linux-raw-sys"
-version = "0.3.3"
+version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b085a4f2cde5781fc4b1717f2e86c62f5cda49de7ba99a7c2eae02b61c9064c"
+checksum = "ef53942eb7bf7ff43a617b3e2c1c4a5ecf5944a7c1bc12d7ee39bbb15e5c1519"
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.4.3"
+version = "0.4.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09fc20d2ca12cb9f044c93e3bd6d32d523e6e2ec3db4f7b2939cd99026ecd3f0"
+checksum = "c4cd1a83af159aa67994778be9070f0ae1bd732942279cabb14f86f986a21456"
 
 [[package]]
 name = "listenfd"
@@ -1768,6 +2009,15 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "mach2"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19b955cdeb2a02b9117f121ce63aa52d08ade45de53e48fe6a38b39c10f6f709"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "matchers"
 version = "0.1.0"
@@ -1791,11 +2041,11 @@ checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
 
 [[package]]
 name = "memfd"
-version = "0.6.3"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffc89ccdc6e10d6907450f753537ebc5c5d3460d2e4e62ea74bd571db62c0f9e"
+checksum = "b2cffa4ad52c6f791f4f8b15f0c05f9824b2ced1160e88cc393d64fff9a8ac64"
 dependencies = [
- "rustix 0.37.13",
+ "rustix 0.38.31",
 ]
 
 [[package]]
@@ -1816,6 +2066,22 @@ dependencies = [
  "autocfg",
 ]
 
+[[package]]
+name = "mime"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
+
+[[package]]
+name = "min-platform-host"
+version = "25.0.0"
+dependencies = [
+ "anyhow",
+ "libloading",
+ "object",
+ "wasmtime",
+]
+
 [[package]]
 name = "miniz_oxide"
 version = "0.7.1"
@@ -1827,31 +2093,77 @@ dependencies = [
 
 [[package]]
 name = "mio"
-version = "0.8.8"
+version = "0.8.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "927a765cd3fc26206e66b296465fa9d3e5ab003e651c1b3c060e7956d96b19d2"
+checksum = "a4a650543ca06a924e8b371db273b2756685faae30f8487da1b56505a8f78b0c"
 dependencies = [
  "libc",
  "wasi",
- "windows-sys",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "native-tls"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8614eb2c83d59d1c8cc974dd3f920198647674a0a035e1af1fa58707e317466"
+dependencies = [
+ "libc",
+ "log",
+ "openssl",
+ "openssl-probe",
+ "openssl-sys",
+ "schannel",
+ "security-framework",
+ "security-framework-sys",
+ "tempfile",
+]
+
+[[package]]
+name = "nu-ansi-term"
+version = "0.46.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84"
+dependencies = [
+ "overload",
+ "winapi",
+]
+
+[[package]]
+name = "num-bigint"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
 ]
 
 [[package]]
 name = "num-traits"
-version = "0.2.15"
+version = "0.2.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
 dependencies = [
  "autocfg",
 ]
 
 [[package]]
 name = "num_cpus"
-version = "1.15.0"
+version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fac9e2da13b5eb447a6ce3d392f23a29d8694bff781bf03a16cd9ac8697593b"
+checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
 dependencies = [
- "hermit-abi 0.2.6",
+ "hermit-abi",
  "libc",
 ]
 
@@ -1863,13 +2175,13 @@ checksum = "17b02fc0ff9a9e4b35b3342880f48e896ebf69f2967921fe8646bf5b7125956a"
 
 [[package]]
 name = "object"
-version = "0.32.0"
+version = "0.36.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77ac5bbd07aea88c60a577a1ce218075ffd59208b2d7ca97adf9bfc5aeb21ebe"
+checksum = "576dfe1fc8f9df304abb159d767a29d0476f7750fbf8aa7ad07816004a207434"
 dependencies = [
  "crc32fast",
- "hashbrown 0.14.0",
- "indexmap 2.0.0",
+ "hashbrown 0.14.3",
+ "indexmap 2.2.6",
  "memchr",
 ]
 
@@ -1904,9 +2216,9 @@ dependencies = [
 
 [[package]]
 name = "once_cell"
-version = "1.18.0"
+version = "1.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d"
+checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
 
 [[package]]
 name = "oorandom"
@@ -1914,11 +2226,55 @@ version = "11.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
 
+[[package]]
+name = "openssl"
+version = "0.10.66"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9529f4786b70a3e8c61e11179af17ab6188ad8d0ded78c5529441ed39d4bd9c1"
+dependencies = [
+ "bitflags 2.4.1",
+ "cfg-if",
+ "foreign-types",
+ "libc",
+ "once_cell",
+ "openssl-macros",
+ "openssl-sys",
+]
+
+[[package]]
+name = "openssl-macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "openssl-probe"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
+
+[[package]]
+name = "openssl-sys"
+version = "0.9.103"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f9e8deee91df40a943c71b917e5874b951d32a802526c85721ce3b776c929d6"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+ "vcpkg",
+]
+
 [[package]]
 name = "openvino"
-version = "0.5.0"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cbc731d9a7805dd533b69de3ee33062d5ea1dfa9fca1c19f8fd165b62e2cdde7"
+checksum = "aee013796927eec6012a344f10ecdc06bf26de79c626a2395e3f115464907ef6"
 dependencies = [
  "openvino-finder",
  "openvino-sys",
@@ -1927,9 +2283,9 @@ dependencies = [
 
 [[package]]
 name = "openvino-finder"
-version = "0.5.0"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8bbd80eea06c2b9ec3dce85900ff3ae596c01105b759b38a005af69bbeb4d07"
+checksum = "af4c6841df4cd60fef743015f3348f81b6b225bd255ed0c4cab6e8c479e45eaa"
 dependencies = [
  "cfg-if",
  "log",
@@ -1937,16 +2293,47 @@ dependencies = [
 
 [[package]]
 name = "openvino-sys"
-version = "0.5.0"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "318ed662bdf05a3f86486408159e806d53363171621a8000b81366fab5158713"
+checksum = "f62fc2bd6882f2300a6b5017eaad292586d70995d333582aabcf1f1121cd147c"
 dependencies = [
+ "env_logger",
  "libloading",
  "once_cell",
  "openvino-finder",
- "pretty_env_logger 0.4.0",
 ]
 
+[[package]]
+name = "ort"
+version = "2.0.0-rc.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bc80894094c6a875bfac64415ed456fa661081a278a035e22be661305c87e14"
+dependencies = [
+ "js-sys",
+ "ort-sys",
+ "thiserror",
+ "tracing",
+ "web-sys",
+]
+
+[[package]]
+name = "ort-sys"
+version = "2.0.0-rc.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3d9c1373fc813d3f024d394f621f4c6dde0734c79b1c17113c3bb5bf0084bbe"
+dependencies = [
+ "flate2",
+ "sha2",
+ "tar",
+ "ureq",
+]
+
+[[package]]
+name = "overload"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
+
 [[package]]
 name = "paste"
 version = "1.0.7"
@@ -1960,43 +2347,77 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "478c572c3d73181ff3c2539045f6eb99e5491218eae919370993b890cdbdd98e"
 
 [[package]]
-name = "pin-project-lite"
-version = "0.2.9"
+name = "pest"
+version = "2.7.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0a7ae3ac2f1173085d398531c705756c94a4c56843785df85a60c1a0afac116"
+checksum = "9c73c26c01b8c87956cea613c907c9d6ecffd8d18a2a5908e5de0adfaa185cea"
+dependencies = [
+ "memchr",
+ "thiserror",
+ "ucd-trie",
+]
 
 [[package]]
-name = "pin-utils"
-version = "0.1.0"
+name = "pest_derive"
+version = "2.7.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+checksum = "664d22978e2815783adbdd2c588b455b1bd625299ce36b2a99881ac9627e6d8d"
+dependencies = [
+ "pest",
+ "pest_generator",
+]
 
 [[package]]
-name = "plotters"
-version = "0.3.1"
+name = "pest_generator"
+version = "2.7.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a3fd9ec30b9749ce28cd91f255d569591cdf937fe280c312143e3c4bad6f2a"
+checksum = "a2d5487022d5d33f4c30d91c22afa240ce2a644e87fe08caad974d4eab6badbe"
 dependencies = [
- "num-traits",
- "plotters-backend",
- "plotters-svg",
- "wasm-bindgen",
- "web-sys",
+ "pest",
+ "pest_meta",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
 ]
 
 [[package]]
-name = "plotters-backend"
-version = "0.3.2"
+name = "pest_meta"
+version = "2.7.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d88417318da0eaf0fdcdb51a0ee6c3bed624333bff8f946733049380be67ac1c"
+checksum = "0091754bbd0ea592c4deb3a122ce8ecbb0753b738aa82bc055fcc2eccc8d8174"
+dependencies = [
+ "once_cell",
+ "pest",
+ "sha2",
+]
 
 [[package]]
-name = "plotters-svg"
-version = "0.3.1"
+name = "pin-project-lite"
+version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "521fa9638fa597e1dc53e9412a4f9cefb01187ee1f7413076f9e6749e2885ba9"
+checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02"
+
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
+[[package]]
+name = "pkg-config"
+version = "0.3.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2900ede94e305130c13ddd391e0ab7cbaeb783945ae07a279c268cb05109c6cb"
+
+[[package]]
+name = "postcard"
+version = "1.0.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a55c51ee6c0db07e68448e336cf8ea4131a620edefebf9893e759b2d793420f8"
 dependencies = [
- "plotters-backend",
+ "cobs",
+ "embedded-io",
+ "serde",
 ]
 
 [[package]]
@@ -2006,13 +2427,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eb9f9e6e233e5c4a35559a617bf40a4ec447db2e84c20b55a6f83167b7e57872"
 
 [[package]]
-name = "pretty_env_logger"
-version = "0.4.0"
+name = "pretty"
+version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "926d36b9553851b8b0005f1275891b392ee4d2d833852c417ed025477350fb9d"
+checksum = "b55c4d17d994b637e2f4daf6e5dc5d660d209d5642377d675d7a1c3ab69fa579"
 dependencies = [
- "env_logger 0.7.1",
- "log",
+ "arrayvec",
+ "typed-arena",
+ "unicode-width",
 ]
 
 [[package]]
@@ -2021,15 +2443,49 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "865724d4dbe39d9f3dd3b52b88d859d66bcb2d6a0acfd5ea68a65fb66d4bdc1c"
 dependencies = [
- "env_logger 0.10.0",
+ "env_logger",
  "log",
 ]
 
+[[package]]
+name = "prettyplease"
+version = "0.2.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f12335488a2f3b0a83b14edad48dca9879ce89b2edd10e80237e4e852dd645e"
+dependencies = [
+ "proc-macro2",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "proc-macro-error"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
+dependencies = [
+ "proc-macro-error-attr",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.92",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro-error-attr"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "version_check",
+]
+
 [[package]]
 name = "proc-macro2"
-version = "1.0.63"
+version = "1.0.81"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b368fba921b0dce7e60f5e04ec15e565b3303972b42bcfde1d0713b881959eb"
+checksum = "3d1597b0c024618f09a9c3b8655b7e430397a36d23fdafec26d6965e9eec3eba"
 dependencies = [
  "unicode-ident",
 ]
@@ -2064,14 +2520,23 @@ dependencies = [
 ]
 
 [[package]]
-name = "pulldown-cmark"
-version = "0.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77a1a2f1f0a7ecff9c31abbe177637be0e97a0aef46cf8738ece09327985d998"
+name = "pulley-interpreter"
+version = "0.1.0"
 dependencies = [
- "bitflags 1.3.2",
- "memchr",
- "unicase",
+ "arbitrary",
+ "cranelift-bitset",
+ "env_logger",
+ "log",
+ "sptr",
+]
+
+[[package]]
+name = "pulley-interpreter-fuzz"
+version = "0.0.0"
+dependencies = [
+ "env_logger",
+ "log",
+ "pulley-interpreter",
 ]
 
 [[package]]
@@ -2088,9 +2553,9 @@ checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
 
 [[package]]
 name = "quote"
-version = "1.0.29"
+version = "1.0.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "573015e8ab27661678357f27dc26460738fd2b6c86e46f386fde94cb5d913105"
+checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
 dependencies = [
  "proc-macro2",
 ]
@@ -2148,21 +2613,12 @@ dependencies = [
 
 [[package]]
 name = "rayon-core"
-version = "1.9.3"
+version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "258bcdb5ac6dad48491bb2992db6b7cf74878b0384908af124823d118c99683f"
+checksum = "5ce3fb6ad83f861aac485e76e1985cd109d9a3713802152be56c3b1f0e0658ed"
 dependencies = [
- "crossbeam-channel",
  "crossbeam-deque",
  "crossbeam-utils",
- "num_cpus",
-]
-
-[[package]]
-name = "reactor-tests"
-version = "0.1.0"
-dependencies = [
- "wit-bindgen",
 ]
 
 [[package]]
@@ -2196,11 +2652,11 @@ dependencies = [
 
 [[package]]
 name = "regalloc2"
-version = "0.9.2"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b4dcbd3a2ae7fb94b5813fa0e957c6ab51bf5d0a8ee1b69e0c2d0f1e6eb8485"
+checksum = "7d3060e21243fead477032ee2824bd68dfc70596b3333317e5295f6afb1d779d"
 dependencies = [
- "hashbrown 0.13.2",
+ "hashbrown 0.14.3",
  "log",
  "rustc-hash",
  "serde",
@@ -2264,26 +2720,65 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "reqwest"
+version = "0.11.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd67538700a17451e7cba03ac727fb961abb7607553461627b97de0b89cf4a62"
+dependencies = [
+ "base64 0.21.0",
+ "bytes",
+ "encoding_rs",
+ "futures-core",
+ "futures-util",
+ "h2 0.3.26",
+ "http 0.2.12",
+ "http-body 0.4.6",
+ "hyper 0.14.30",
+ "hyper-tls",
+ "ipnet",
+ "js-sys",
+ "log",
+ "mime",
+ "native-tls",
+ "once_cell",
+ "percent-encoding",
+ "pin-project-lite",
+ "rustls-pemfile",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "sync_wrapper",
+ "system-configuration",
+ "tokio",
+ "tokio-native-tls",
+ "tower-service",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+ "winreg",
+]
+
 [[package]]
 name = "ring"
-version = "0.16.20"
+version = "0.17.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc"
+checksum = "9babe80d5c16becf6594aa32ad2be8fe08498e7ae60b77de8df700e67f191d7e"
 dependencies = [
  "cc",
+ "getrandom",
  "libc",
- "once_cell",
- "spin 0.5.2",
+ "spin",
  "untrusted",
- "web-sys",
- "winapi",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
 name = "rustc-demangle"
-version = "0.1.21"
+version = "0.1.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ef03e0a2b150c7a90d01faf6254c9c48a41e95fb2a8c2ac1c6f0d2b9aefc342"
+checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f"
 
 [[package]]
 name = "rustc-hash"
@@ -2293,55 +2788,94 @@ checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
 
 [[package]]
 name = "rustix"
-version = "0.37.13"
+version = "0.37.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f79bef90eb6d984c72722595b5b1348ab39275a5e5123faca6863bf07d75a4e0"
+checksum = "fea8ca367a3a01fe35e6943c400addf443c0f57670e6ec51196f71a4b8762dd2"
 dependencies = [
  "bitflags 1.3.2",
  "errno",
- "io-lifetimes 1.0.10",
+ "io-lifetimes 1.0.11",
  "libc",
- "linux-raw-sys 0.3.3",
- "windows-sys",
+ "linux-raw-sys 0.3.8",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
 name = "rustix"
-version = "0.38.8"
+version = "0.38.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19ed4fa021d81c8392ce04db050a3da9a60299050b7ae1cf482d862b54a7218f"
+checksum = "6ea3e1a662af26cd7a3ba09c0297a31af215563ecf42817c98df621387f4e949"
 dependencies = [
- "bitflags 2.3.3",
+ "bitflags 2.4.1",
  "errno",
  "itoa",
  "libc",
- "linux-raw-sys 0.4.3",
+ "linux-raw-sys 0.4.12",
  "once_cell",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "rustls"
-version = "0.21.6"
+version = "0.22.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d1feddffcfcc0b33f5c6ce9a29e341e4cd59c3f78e7ee45f4a40c038b1d6cbb"
+checksum = "bf4ef73721ac7bcd79b2b315da7779d8fc09718c6b3d2d1b2d94850eb8c18432"
 dependencies = [
  "log",
  "ring",
+ "rustls-pki-types",
  "rustls-webpki",
- "sct",
+ "subtle",
+ "zeroize",
 ]
 
+[[package]]
+name = "rustls"
+version = "0.23.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebbbdb961df0ad3f2652da8f3fdc4b36122f568f968f45ad3316f26c025c677b"
+dependencies = [
+ "log",
+ "once_cell",
+ "ring",
+ "rustls-pki-types",
+ "rustls-webpki",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-pemfile"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c"
+dependencies = [
+ "base64 0.21.0",
+]
+
+[[package]]
+name = "rustls-pki-types"
+version = "1.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ede67b28608b4c60685c7d54122d4400d90f62b40caee7700e700380a390fa8"
+
 [[package]]
 name = "rustls-webpki"
-version = "0.101.4"
+version = "0.102.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d93931baf2d282fff8d3a532bbfd7653f734643161b87e3e01e59a04439bf0d"
+checksum = "faaa0a62740bedb9b2ef5afa303da42764c012f743917351dc9a237ea1663610"
 dependencies = [
  "ring",
+ "rustls-pki-types",
  "untrusted",
 ]
 
+[[package]]
+name = "rustversion"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ffc183a10b4478d04cbbbfc96d0873219d962dd5accaff2ffbd4ceb7df837f4"
+
 [[package]]
 name = "rusty-fork"
 version = "0.3.0"
@@ -2369,6 +2903,15 @@ dependencies = [
  "winapi-util",
 ]
 
+[[package]]
+name = "schannel"
+version = "0.1.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fbc91545643bcf3a0bbb6569265615222618bdf33ce4ffbbd13c4bbd4c093534"
+dependencies = [
+ "windows-sys 0.52.0",
+]
+
 [[package]]
 name = "scopeguard"
 version = "1.1.0"
@@ -2376,13 +2919,26 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 
 [[package]]
-name = "sct"
-version = "0.7.0"
+name = "security-framework"
+version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d53dcdb7c9f8158937a7981b48accfd39a43af418591a5d008c7b22b5e1b7ca4"
+checksum = "770452e37cad93e0a50d5abc3990d2bc351c36d0328f86cefec2f2fb206eaef6"
 dependencies = [
- "ring",
- "untrusted",
+ "bitflags 1.3.2",
+ "core-foundation",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework-sys"
+version = "2.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75da29fe9b9b08fe9d6b22b5b4bcbc75d8db3aa31e639aa56bb62e9d46bfceaf"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
 ]
 
 [[package]]
@@ -2411,7 +2967,7 @@ checksum = "4eca7ac642d82aa35b60049a6eccb4be6be75e599bd2e9adb5f875a737654af2"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.29",
+ "syn 2.0.60",
 ]
 
 [[package]]
@@ -2425,6 +2981,27 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "serde_spanned"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb3622f419d1296904700073ea6cc23ad690adbd66f13ea683df73298736f0c1"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "serde_urlencoded"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
+dependencies = [
+ "form_urlencoded",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
 [[package]]
 name = "sha2"
 version = "0.10.2"
@@ -2507,12 +3084,12 @@ dependencies = [
 
 [[package]]
 name = "socket2"
-version = "0.4.9"
+version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64a4a911eed85daf18834cfaa86a79b7d266ff93ff5ba14005426219480ed662"
+checksum = "ce305eb0b4296696835b71df73eb912e0f1ffd2556a501fcede6e0c50349191c"
 dependencies = [
  "libc",
- "winapi",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -2533,12 +3110,6 @@ dependencies = [
  "smallvec",
 ]
 
-[[package]]
-name = "spin"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
-
 [[package]]
 name = "spin"
 version = "0.9.4"
@@ -2569,6 +3140,12 @@ version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
 
+[[package]]
+name = "subtle"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc"
+
 [[package]]
 name = "symbolic_expressions"
 version = "5.0.3"
@@ -2588,56 +3165,93 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.29"
+version = "2.0.60"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c324c494eba9d92503e6f1ef2e6df781e78f6a7705a0202d9801b198807d518a"
+checksum = "909518bc7b1c9b779f1bbf07f2929d35af9f0f37e47c6e9ef7f9dddc1e1821f3"
 dependencies = [
  "proc-macro2",
  "quote",
  "unicode-ident",
 ]
 
+[[package]]
+name = "sync_wrapper"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160"
+
+[[package]]
+name = "system-configuration"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7"
+dependencies = [
+ "bitflags 1.3.2",
+ "core-foundation",
+ "system-configuration-sys",
+]
+
+[[package]]
+name = "system-configuration-sys"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75fb188eb626b924683e3b95e3a48e63551fcfb51949de2f06a9d91dbee93c9"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
 [[package]]
 name = "system-interface"
-version = "0.26.0"
+version = "0.27.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "27ce32341b2c0b70c144bbf35627fdc1ef18c76ced5e5e7b3ee8b5ba6b2ab6a0"
+checksum = "9aef1f9d4c1dbdd1cb3a63be9efd2f04d8ddbc919d46112982c76818ffc2f1a7"
 dependencies = [
- "bitflags 2.3.3",
+ "bitflags 2.4.1",
  "cap-fs-ext",
  "cap-std",
  "fd-lock",
- "io-lifetimes 2.0.2",
- "rustix 0.38.8",
- "windows-sys",
+ "io-lifetimes 2.0.3",
+ "rustix 0.38.31",
+ "windows-sys 0.52.0",
  "winx",
 ]
 
+[[package]]
+name = "tar"
+version = "0.4.41"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb797dad5fb5b76fcf519e702f4a589483b5ef06567f160c392832c1f5e44909"
+dependencies = [
+ "filetime",
+ "libc",
+ "xattr",
+]
+
 [[package]]
 name = "target-lexicon"
-version = "0.12.3"
+version = "0.12.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7fa7e55043acb85fca6b3c01485a2eeb6b69c5d21002e273c79e465f43b7ac1"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
 
 [[package]]
 name = "tempfile"
-version = "3.6.0"
+version = "3.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31c0432476357e58790aaa47a8efb0c5138f137343f3b5f23bd36a27e3b0a6d6"
+checksum = "cb94d2f3cc536af71caac6b6fcebf65860b347e7ce0cc9ebe8f70d3e521054ef"
 dependencies = [
- "autocfg",
  "cfg-if",
  "fastrand",
  "redox_syscall 0.3.5",
- "rustix 0.37.13",
- "windows-sys",
+ "rustix 0.38.31",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
 name = "termcolor"
-version = "1.1.3"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bab24d30b911b2376f3a13cc2cd443142f0c81dda04c118693e35b3835757755"
+checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
 dependencies = [
  "winapi-util",
 ]
@@ -2652,6 +3266,16 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "terminal_size"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e6bf6f19e9f8ed8d4048dc22981458ebcf406d67e94cd422e5ecd73d63b3237"
+dependencies = [
+ "rustix 0.37.27",
+ "windows-sys 0.48.0",
+]
+
 [[package]]
 name = "test-log"
 version = "0.2.11"
@@ -2664,32 +3288,29 @@ dependencies = [
 ]
 
 [[package]]
-name = "test-programs"
+name = "test-programs"
+version = "0.0.0"
+dependencies = [
+ "anyhow",
+ "base64 0.21.0",
+ "futures",
+ "getrandom",
+ "libc",
+ "sha2",
+ "url",
+ "wasi",
+ "wasi-nn",
+ "wit-bindgen",
+]
+
+[[package]]
+name = "test-programs-artifacts"
 version = "0.0.0"
 dependencies = [
- "anyhow",
- "bytes",
- "cap-rand",
- "cap-std",
  "cargo_metadata",
- "cfg-if",
- "heck",
- "http",
- "http-body",
- "http-body-util",
- "hyper",
- "lazy_static",
- "tempfile",
- "test-log",
- "tokio",
- "tracing",
- "tracing-subscriber",
- "wasi-cap-std-sync",
- "wasi-common",
+ "heck 0.4.0",
  "wasmtime",
- "wasmtime-wasi",
- "wasmtime-wasi-http",
- "wit-component",
+ "wit-component 0.216.0",
 ]
 
 [[package]]
@@ -2709,7 +3330,7 @@ checksum = "463fe12d7993d3b327787537ce8dd4dfa058de32fc2b195ef3cde03dc4771e8f"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.29",
+ "syn 2.0.60",
 ]
 
 [[package]]
@@ -2721,6 +3342,15 @@ dependencies = [
  "once_cell",
 ]
 
+[[package]]
+name = "threadpool"
+version = "1.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d050e60b33d41c19108b32cea32164033a9013fe3b46cbd4457559bfbf77afaa"
+dependencies = [
+ "num_cpus",
+]
+
 [[package]]
 name = "tinytemplate"
 version = "1.2.1"
@@ -2748,11 +3378,10 @@ checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"
 
 [[package]]
 name = "tokio"
-version = "1.29.1"
+version = "1.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "532826ff75199d5833b9d2c5fe410f29235e25704ee5f0ef599fb51c21f4a4da"
+checksum = "2d3ce25f50619af8b0aec2eb23deebe84249e19e2ddd393a6e16e3300a6dadfd"
 dependencies = [
- "autocfg",
  "backtrace",
  "bytes",
  "libc",
@@ -2762,7 +3391,7 @@ dependencies = [
  "signal-hook-registry",
  "socket2",
  "tokio-macros",
- "windows-sys",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -2773,16 +3402,27 @@ checksum = "630bdcf245f78637c13ec01ffae6187cca34625e8c63150d424b59e55af2675e"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.29",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "tokio-native-tls"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2"
+dependencies = [
+ "native-tls",
+ "tokio",
 ]
 
 [[package]]
 name = "tokio-rustls"
-version = "0.24.0"
+version = "0.25.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0d409377ff5b1e3ca6437aa86c1eb7d40c134bfec254e44c830defa92669db5"
+checksum = "775e0c0f0adb3a2f22a00c4745d728b479985fc15ee7ca6a2608388c5569860f"
 dependencies = [
- "rustls",
+ "rustls 0.22.4",
+ "rustls-pki-types",
  "tokio",
 ]
 
@@ -2802,13 +3442,44 @@ dependencies = [
 
 [[package]]
 name = "toml"
-version = "0.5.9"
+version = "0.8.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a9aad4a3066010876e8dcf5a8a06e70a558751117a145c6ce2b82c2e2054290"
+dependencies = [
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_edit",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3550f4e9685620ac18a50ed434eb3aec30db8ba93b0287467bca5826ea25baf1"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.22.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d82e1a7758622a465f8cee077614c73484dac5b836c02ff6a40d5d1010324d7"
+checksum = "0c9ffdf896f8daaabf9b66ba8e77ea1ed5ed0f72821b398aba62352e95062951"
 dependencies = [
+ "indexmap 2.2.6",
  "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "winnow",
 ]
 
+[[package]]
+name = "tower-service"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
+
 [[package]]
 name = "tracing"
 version = "0.1.37"
@@ -2830,7 +3501,7 @@ checksum = "5f4f31f56159e98206da9efd823404b79b6ef3143b4a7ab76e67b1751b25a4ab"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.29",
+ "syn 2.0.60",
 ]
 
 [[package]]
@@ -2840,6 +3511,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0955b8137a1df6f1a2e9a37d8a6656291ff0297c1a97c24e0d8425fe2312f79a"
 dependencies = [
  "once_cell",
+ "valuable",
+]
+
+[[package]]
+name = "tracing-log"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78ddad33d2d10b1ed7eb9d1f518a5674713876e97e5bb9b7345a7984fbb4f922"
+dependencies = [
+ "lazy_static",
+ "log",
+ "tracing-core",
 ]
 
 [[package]]
@@ -2849,12 +3532,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "30a651bc37f915e81f087d86e62a18eec5f79550c7faff886f7090b4ea757c77"
 dependencies = [
  "matchers",
+ "nu-ansi-term",
  "once_cell",
  "regex",
  "sharded-slab",
  "thread_local",
  "tracing",
  "tracing-core",
+ "tracing-log",
 ]
 
 [[package]]
@@ -2863,6 +3548,12 @@ version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3528ecfd12c466c6f163363caf2d02a71161dd5e1cc6ae7b34207ea2d42d81ed"
 
+[[package]]
+name = "typed-arena"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6af6ae20167a9ece4bcb41af5b80f8a1f1df981f6391189ce00fd257af04126a"
+
 [[package]]
 name = "typenum"
 version = "1.15.0"
@@ -2870,13 +3561,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987"
 
 [[package]]
-name = "unicase"
-version = "2.6.0"
+name = "ucd-trie"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50f37be617794602aabbeee0be4f259dc1778fabe05e2d67ee8f79326d5cb4f6"
-dependencies = [
- "version_check",
-]
+checksum = "ed646292ffc8188ef8ea4d1e0e0150fb15a5c2e12ad9b8fc191ae7a8a7f3c4b9"
 
 [[package]]
 name = "unicode-bidi"
@@ -2901,9 +3589,9 @@ dependencies = [
 
 [[package]]
 name = "unicode-segmentation"
-version = "1.10.1"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1dd624098567895118886609431a7c3b8f516e41d30e0643f03d94592a147e36"
+checksum = "d4c87d22b6e3f4a18d4d40ef354e97c90fcb14dd91d7dc0aa9d8a1172ebf7202"
 
 [[package]]
 name = "unicode-width"
@@ -2919,9 +3607,24 @@ checksum = "957e51f3646910546462e67d5f7599b9e4fb8acdd304b087a6494730f9eebf04"
 
 [[package]]
 name = "untrusted"
-version = "0.7.1"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+
+[[package]]
+name = "ureq"
+version = "2.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72139d247e5f97a3eff96229a7ae85ead5328a39efe76f8bf5a06313d505b6ea"
+dependencies = [
+ "base64 0.22.1",
+ "log",
+ "once_cell",
+ "rustls 0.23.7",
+ "rustls-pki-types",
+ "url",
+ "webpki-roots",
+]
 
 [[package]]
 name = "url"
@@ -2945,28 +3648,37 @@ name = "uuid"
 version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8cfcd319456c4d6ea10087ed423473267e1a071f3bc0aa89f80d60997843c6f0"
-dependencies = [
- "getrandom",
-]
 
 [[package]]
 name = "v8"
-version = "0.74.1"
+version = "0.86.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1202e0bd078112bf8d521491560645e1fd6955c4afd975c75b05596a7e7e4eea"
+checksum = "0d30d72faeef07020ec4428dbfa2909801e5e36becf650c1b49c92b70f6771d8"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.4.1",
  "fslock",
  "once_cell",
  "which",
 ]
 
+[[package]]
+name = "valuable"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d"
+
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
 [[package]]
 name = "verify-component-adapter"
-version = "14.0.0"
+version = "25.0.0"
 dependencies = [
  "anyhow",
- "wasmparser",
+ "wasmparser 0.216.0",
  "wat",
 ]
 
@@ -3012,104 +3724,55 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
-name = "wasi-cap-std-sync"
-version = "14.0.0"
+name = "wasi-common"
+version = "25.0.0"
 dependencies = [
  "anyhow",
- "async-trait",
+ "bitflags 2.4.1",
  "cap-fs-ext",
  "cap-rand",
  "cap-std",
  "cap-time-ext",
  "fs-set-times",
  "io-extras",
- "io-lifetimes 2.0.2",
+ "io-lifetimes 2.0.3",
+ "libc",
+ "log",
  "once_cell",
- "rustix 0.38.8",
+ "rustix 0.38.31",
  "system-interface",
  "tempfile",
- "tracing",
- "wasi-common",
- "windows-sys",
-]
-
-[[package]]
-name = "wasi-common"
-version = "14.0.0"
-dependencies = [
- "anyhow",
- "bitflags 2.3.3",
- "cap-rand",
- "cap-std",
- "io-extras",
- "log",
- "rustix 0.38.8",
+ "test-log",
+ "test-programs-artifacts",
  "thiserror",
+ "tokio",
  "tracing",
+ "tracing-subscriber",
+ "wasi-common",
  "wasmtime",
  "wiggle",
- "windows-sys",
-]
-
-[[package]]
-name = "wasi-http-proxy-tests"
-version = "0.0.0"
-dependencies = [
- "wit-bindgen",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
-name = "wasi-http-tests"
-version = "0.0.0"
+name = "wasi-nn"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7031683cc05a71515d9200fb159b28d717ded3c40dbb979d1602cf46f3a68f40"
 dependencies = [
- "anyhow",
- "wit-bindgen",
+ "thiserror",
 ]
 
 [[package]]
 name = "wasi-preview1-component-adapter"
-version = "14.0.0"
+version = "25.0.0"
 dependencies = [
+ "bitflags 2.4.1",
  "byte-array-literals",
  "object",
  "wasi",
- "wasm-encoder",
- "wit-bindgen",
-]
-
-[[package]]
-name = "wasi-sockets-tests"
-version = "0.0.0"
-dependencies = [
- "anyhow",
- "wit-bindgen",
-]
-
-[[package]]
-name = "wasi-tests"
-version = "0.0.0"
-dependencies = [
- "libc",
- "once_cell",
- "wasi",
- "wit-bindgen",
-]
-
-[[package]]
-name = "wasi-tokio"
-version = "14.0.0"
-dependencies = [
- "anyhow",
- "cap-std",
- "cap-tempfile",
- "io-extras",
- "io-lifetimes 2.0.2",
- "rustix 0.38.8",
- "tempfile",
- "tokio",
- "wasi-cap-std-sync",
- "wasi-common",
- "wiggle",
+ "wasm-encoder 0.216.0",
+ "wit-bindgen-rust-macro",
 ]
 
 [[package]]
@@ -3133,10 +3796,22 @@ dependencies = [
  "once_cell",
  "proc-macro2",
  "quote",
- "syn 2.0.29",
+ "syn 2.0.60",
  "wasm-bindgen-shared",
 ]
 
+[[package]]
+name = "wasm-bindgen-futures"
+version = "0.4.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f741de44b75e14c35df886aff5f1eb73aa114fa5d4d00dcd37b5e01259bf3b2"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "wasm-bindgen",
+ "web-sys",
+]
+
 [[package]]
 name = "wasm-bindgen-macro"
 version = "0.2.87"
@@ -3155,7 +3830,7 @@ checksum = "54681b18a46765f095758388f2d0cf16eb8d4169b639ab575a8f5693af210c7b"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.29",
+ "syn 2.0.60",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
@@ -3168,54 +3843,82 @@ checksum = "ca6ad05a4870b2bf5fe995117d3728437bd27d7cd5f06f13c17443ef369775a1"
 
 [[package]]
 name = "wasm-encoder"
-version = "0.33.2"
+version = "0.215.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fb56df3e06b8e6b77e37d2969a50ba51281029a9aeb3855e76b7f49b6418847"
+dependencies = [
+ "leb128",
+ "wasmparser 0.215.0",
+]
+
+[[package]]
+name = "wasm-encoder"
+version = "0.216.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34180c89672b3e4825c3a8db4b61a674f1447afd5fe2445b2d22c3d8b6ea086c"
+checksum = "04c23aebea22c8a75833ae08ed31ccc020835b12a41999e58c31464271b94a88"
 dependencies = [
  "leb128",
+ "wasmparser 0.216.0",
+]
+
+[[package]]
+name = "wasm-metadata"
+version = "0.215.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c6bb07c5576b608f7a2a9baa2294c1a3584a249965d695a9814a496cb6d232f"
+dependencies = [
+ "anyhow",
+ "indexmap 2.2.6",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "spdx",
+ "wasm-encoder 0.215.0",
+ "wasmparser 0.215.0",
 ]
 
 [[package]]
 name = "wasm-metadata"
-version = "0.10.6"
+version = "0.216.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "577508d8a45bc54ad97efe77c95ba57bb10e7e5c5bac9c31295ce88b8045cd7d"
+checksum = "47c8154d703a6b0e45acf6bd172fa002fc3c7058a9f7615e517220aeca27c638"
 dependencies = [
  "anyhow",
- "indexmap 2.0.0",
+ "indexmap 2.2.6",
  "serde",
+ "serde_derive",
  "serde_json",
  "spdx",
- "wasm-encoder",
- "wasmparser",
+ "wasm-encoder 0.216.0",
+ "wasmparser 0.216.0",
 ]
 
 [[package]]
 name = "wasm-mutate"
-version = "0.2.35"
+version = "0.216.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f22ff62504d0e55a4e4c32cdf4e65f9c925ba0bc9904e141394eb2ad2b8f319d"
+checksum = "17002e0f291e0c330a81b9285cf0e4e316e10e75b00d4f5c625d325f14582d11"
 dependencies = [
  "egg",
  "log",
  "rand",
  "thiserror",
- "wasm-encoder",
- "wasmparser",
+ "wasm-encoder 0.216.0",
+ "wasmparser 0.216.0",
 ]
 
 [[package]]
 name = "wasm-smith"
-version = "0.12.18"
+version = "0.216.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7499466e905b4e8d0cc1720c1bfddf1e5040f6fa42efd4f43edd1b88dbe9ce9b"
+checksum = "b25e5a09d7934b471fb84ea864cc91ed1a4467ea8aaa32c09f60f3fb262e070e"
 dependencies = [
+ "anyhow",
  "arbitrary",
  "flagset",
- "indexmap 2.0.0",
+ "indexmap 2.2.6",
  "leb128",
- "wasm-encoder",
- "wasmparser",
+ "wasm-encoder 0.216.0",
 ]
 
 [[package]]
@@ -3229,11 +3932,12 @@ dependencies = [
 
 [[package]]
 name = "wasmi"
-version = "0.20.0"
+version = "0.31.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "01bf50edb2ea9d922aa75a7bf3c15e26a6c9e2d18c56e862b49737a582901729"
+checksum = "acfc1e384a36ca532d070a315925887247f3c7e23567e23e0ac9b1c5d6b8bf76"
 dependencies = [
- "spin 0.9.4",
+ "smallvec",
+ "spin",
  "wasmi_arena",
  "wasmi_core",
  "wasmparser-nostd",
@@ -3241,126 +3945,171 @@ dependencies = [
 
 [[package]]
 name = "wasmi_arena"
-version = "0.1.0"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1ea379cbb0b41f3a9f0bf7b47036d036aae7f43383d8cc487d4deccf40dee0a"
+checksum = "104a7f73be44570cac297b3035d76b169d6599637631cf37a1703326a0727073"
 
 [[package]]
 name = "wasmi_core"
-version = "0.5.0"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5bf998ab792be85e20e771fe14182b4295571ad1d4f89d3da521c1bef5f597a"
+checksum = "dcf1a7db34bff95b85c261002720c00c3a6168256dcb93041d3fa2054d19856a"
 dependencies = [
  "downcast-rs",
  "libm",
  "num-traits",
+ "paste",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.215.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53fbde0881f24199b81cf49b6ff8f9c145ac8eb1b7fc439adb5c099734f7d90e"
+dependencies = [
+ "ahash",
+ "bitflags 2.4.1",
+ "hashbrown 0.14.3",
+ "indexmap 2.2.6",
+ "semver",
 ]
 
 [[package]]
 name = "wasmparser"
-version = "0.113.2"
+version = "0.216.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fd0d44fab0bd78404e352f3399324eef76516a4580b52bc9031c60f064e98f3"
+checksum = "bcdee6bea3619d311fb4b299721e89a986c3470f804b6d534340e412589028e3"
 dependencies = [
- "indexmap 2.0.0",
+ "ahash",
+ "bitflags 2.4.1",
+ "hashbrown 0.14.3",
+ "indexmap 2.2.6",
  "semver",
+ "serde",
 ]
 
 [[package]]
 name = "wasmparser-nostd"
-version = "0.91.0"
+version = "0.100.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c37f310b5a62bfd5ae7c0f1d8e6f98af16a5d6d84ba764e9c36439ec14e318b"
+checksum = "9157cab83003221bfd385833ab587a039f5d6fa7304854042ba358a3b09e0724"
 dependencies = [
  "indexmap-nostd",
 ]
 
 [[package]]
 name = "wasmprinter"
-version = "0.2.67"
+version = "0.216.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6615a5587149e753bf4b93f90fa3c3f41c88597a7a2da72879afcabeda9648f"
+checksum = "8f82916f3892e53620639217d6ec78fe15c678352a3fbf3f3745b6417d0bd70f"
 dependencies = [
  "anyhow",
- "wasmparser",
+ "termcolor",
+ "wasmparser 0.216.0",
 ]
 
 [[package]]
 name = "wasmtime"
-version = "14.0.0"
+version = "25.0.0"
 dependencies = [
+ "addr2line",
  "anyhow",
  "async-trait",
- "bincode",
+ "bitflags 2.4.1",
  "bumpalo",
+ "cc",
  "cfg-if",
  "encoding_rs",
+ "env_logger",
  "fxprof-processed-profile",
- "indexmap 2.0.0",
+ "gimli",
+ "hashbrown 0.14.3",
+ "indexmap 2.2.6",
+ "ittapi",
  "libc",
+ "libm",
  "log",
+ "mach2",
+ "memfd",
  "object",
  "once_cell",
  "paste",
+ "postcard",
+ "proptest",
  "psm",
+ "rand",
  "rayon",
+ "rustix 0.38.31",
+ "semver",
  "serde",
  "serde_derive",
  "serde_json",
+ "smallvec",
+ "sptr",
  "target-lexicon",
  "tempfile",
- "wasi-cap-std-sync",
- "wasm-encoder",
- "wasmparser",
+ "wasi-common",
+ "wasm-encoder 0.216.0",
+ "wasmparser 0.216.0",
+ "wasmtime-asm-macros",
  "wasmtime-cache",
  "wasmtime-component-macro",
  "wasmtime-component-util",
  "wasmtime-cranelift",
  "wasmtime-environ",
  "wasmtime-fiber",
- "wasmtime-jit",
- "wasmtime-runtime",
- "wasmtime-wasi",
+ "wasmtime-jit-debug",
+ "wasmtime-jit-icache-coherence",
+ "wasmtime-slab",
+ "wasmtime-versioned-export-macros",
  "wasmtime-winch",
+ "wasmtime-wmemcheck",
  "wat",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "wasmtime-asm-macros"
-version = "14.0.0"
+version = "25.0.0"
 dependencies = [
  "cfg-if",
 ]
 
 [[package]]
 name = "wasmtime-bench-api"
-version = "14.0.0"
+version = "25.0.0"
 dependencies = [
  "anyhow",
  "cap-std",
  "clap",
  "shuffling-allocator",
  "target-lexicon",
- "wasi-cap-std-sync",
+ "wasi-common",
  "wasmtime",
  "wasmtime-cli-flags",
- "wasmtime-wasi",
  "wasmtime-wasi-nn",
  "wat",
 ]
 
 [[package]]
 name = "wasmtime-c-api"
-version = "14.0.0"
+version = "25.0.0"
+dependencies = [
+ "wasmtime-c-api-impl",
+]
+
+[[package]]
+name = "wasmtime-c-api-impl"
+version = "25.0.0"
 dependencies = [
  "anyhow",
  "cap-std",
- "env_logger 0.10.0",
+ "env_logger",
  "futures",
+ "log",
  "once_cell",
- "wasi-cap-std-sync",
- "wasi-common",
+ "tokio",
+ "tracing",
  "wasmtime",
  "wasmtime-c-api-macros",
  "wasmtime-wasi",
@@ -3369,7 +4118,7 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-c-api-macros"
-version = "0.0.0"
+version = "25.0.0"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3377,60 +4126,73 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-cache"
-version = "14.0.0"
+version = "25.0.0"
 dependencies = [
  "anyhow",
- "base64",
- "bincode",
+ "base64 0.21.0",
  "directories-next",
  "filetime",
  "log",
  "once_cell",
- "pretty_env_logger 0.5.0",
- "rustix 0.38.8",
+ "postcard",
+ "pretty_env_logger",
+ "rustix 0.38.31",
  "serde",
  "serde_derive",
  "sha2",
  "tempfile",
  "toml",
- "windows-sys",
+ "windows-sys 0.52.0",
  "zstd",
 ]
 
 [[package]]
 name = "wasmtime-cli"
-version = "14.0.0"
+version = "25.0.0"
 dependencies = [
  "anyhow",
  "async-trait",
  "bstr",
+ "bytes",
+ "bytesize",
+ "capstone",
+ "cfg-if",
  "clap",
  "component-macro-test",
  "component-test-util",
+ "cranelift-codegen",
+ "cranelift-filetests",
+ "cranelift-reader",
  "criterion",
- "env_logger 0.10.0",
+ "env_logger",
  "filecheck",
- "http-body",
+ "http 1.0.0",
  "http-body-util",
- "hyper",
+ "humantime",
+ "hyper 1.0.1",
  "libc",
+ "libtest-mimic",
  "listenfd",
  "log",
  "memchr",
  "num_cpus",
+ "object",
  "once_cell",
  "rayon",
- "rustix 0.38.8",
+ "rustix 0.38.31",
  "serde",
  "serde_derive",
  "serde_json",
+ "similar",
  "target-lexicon",
  "tempfile",
- "test-programs",
+ "test-programs-artifacts",
  "tokio",
+ "toml",
+ "tracing",
  "walkdir",
- "wasm-encoder",
- "wasmparser",
+ "wasi-common",
+ "wasmparser 0.216.0",
  "wasmtime",
  "wasmtime-cache",
  "wasmtime-cli-flags",
@@ -3438,105 +4200,102 @@ dependencies = [
  "wasmtime-cranelift",
  "wasmtime-environ",
  "wasmtime-explorer",
- "wasmtime-runtime",
+ "wasmtime-test-macros",
  "wasmtime-wasi",
  "wasmtime-wasi-http",
+ "wasmtime-wasi-keyvalue",
  "wasmtime-wasi-nn",
+ "wasmtime-wasi-runtime-config",
  "wasmtime-wasi-threads",
  "wasmtime-wast",
- "wast 65.0.2",
+ "wast 216.0.0",
  "wat",
- "windows-sys",
+ "windows-sys 0.52.0",
+ "wit-component 0.216.0",
 ]
 
 [[package]]
 name = "wasmtime-cli-flags"
-version = "14.0.0"
+version = "25.0.0"
 dependencies = [
  "anyhow",
  "clap",
  "file-per-thread-logger",
- "humantime 2.1.0",
- "pretty_env_logger 0.5.0",
+ "humantime",
  "rayon",
+ "tracing-subscriber",
  "wasmtime",
 ]
 
 [[package]]
 name = "wasmtime-component-macro"
-version = "14.0.0"
+version = "25.0.0"
 dependencies = [
  "anyhow",
  "component-macro-test-helpers",
+ "prettyplease",
  "proc-macro2",
  "quote",
- "syn 2.0.29",
+ "serde",
+ "serde_json",
+ "similar",
+ "syn 2.0.60",
  "tracing",
  "wasmtime",
  "wasmtime-component-util",
  "wasmtime-wit-bindgen",
- "wit-parser",
+ "wit-parser 0.216.0",
 ]
 
 [[package]]
 name = "wasmtime-component-util"
-version = "14.0.0"
+version = "25.0.0"
 
 [[package]]
 name = "wasmtime-cranelift"
-version = "14.0.0"
+version = "25.0.0"
 dependencies = [
  "anyhow",
  "cfg-if",
  "cranelift-codegen",
  "cranelift-control",
  "cranelift-entity",
- "cranelift-frontend",
- "cranelift-native",
- "cranelift-wasm",
- "gimli",
- "log",
- "object",
- "target-lexicon",
- "thiserror",
- "wasmparser",
- "wasmtime-cranelift-shared",
- "wasmtime-environ",
- "wasmtime-versioned-export-macros",
-]
-
-[[package]]
-name = "wasmtime-cranelift-shared"
-version = "14.0.0"
-dependencies = [
- "anyhow",
- "cranelift-codegen",
- "cranelift-control",
+ "cranelift-frontend",
  "cranelift-native",
+ "cranelift-wasm",
  "gimli",
+ "log",
  "object",
+ "smallvec",
  "target-lexicon",
+ "thiserror",
+ "wasmparser 0.216.0",
  "wasmtime-environ",
+ "wasmtime-versioned-export-macros",
 ]
 
 [[package]]
 name = "wasmtime-environ"
-version = "14.0.0"
+version = "25.0.0"
 dependencies = [
  "anyhow",
  "clap",
+ "cpp_demangle",
+ "cranelift-bitset",
  "cranelift-entity",
- "env_logger 0.10.0",
+ "env_logger",
  "gimli",
- "indexmap 2.0.0",
+ "indexmap 2.2.6",
  "log",
  "object",
+ "postcard",
+ "rustc-demangle",
+ "semver",
  "serde",
  "serde_derive",
  "target-lexicon",
- "thiserror",
- "wasm-encoder",
- "wasmparser",
+ "wasm-encoder 0.216.0",
+ "wasmparser 0.216.0",
  "wasmprinter",
  "wasmtime-component-util",
  "wasmtime-types",
@@ -3549,9 +4308,9 @@ version = "0.0.0"
 dependencies = [
  "arbitrary",
  "component-fuzz-util",
- "env_logger 0.10.0",
+ "env_logger",
  "libfuzzer-sys",
- "wasmparser",
+ "wasmparser 0.216.0",
  "wasmprinter",
  "wasmtime-environ",
  "wat",
@@ -3559,7 +4318,7 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-explorer"
-version = "14.0.0"
+version = "25.0.0"
 dependencies = [
  "anyhow",
  "capstone",
@@ -3569,19 +4328,21 @@ dependencies = [
  "target-lexicon",
  "wasmprinter",
  "wasmtime",
+ "wasmtime-environ",
 ]
 
 [[package]]
 name = "wasmtime-fiber"
-version = "14.0.0"
+version = "25.0.0"
 dependencies = [
+ "anyhow",
  "backtrace",
  "cc",
  "cfg-if",
- "rustix 0.38.8",
+ "rustix 0.38.31",
  "wasmtime-asm-macros",
  "wasmtime-versioned-export-macros",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -3600,14 +4361,16 @@ dependencies = [
  "cranelift-native",
  "cranelift-reader",
  "cranelift-wasm",
+ "env_logger",
  "libfuzzer-sys",
  "once_cell",
  "proc-macro2",
+ "pulley-interpreter-fuzz",
  "quote",
  "rand",
  "smallvec",
  "target-lexicon",
- "wasmparser",
+ "wasmparser 0.216.0",
  "wasmtime",
  "wasmtime-fuzzing",
 ]
@@ -3620,126 +4383,88 @@ dependencies = [
  "arbitrary",
  "component-fuzz-util",
  "component-test-util",
- "env_logger 0.10.0",
+ "env_logger",
+ "futures",
  "log",
  "rand",
  "rayon",
  "target-lexicon",
  "tempfile",
  "v8",
- "wasm-encoder",
+ "wasm-encoder 0.216.0",
  "wasm-mutate",
  "wasm-smith",
  "wasm-spec-interpreter",
  "wasmi",
- "wasmparser",
+ "wasmparser 0.216.0",
  "wasmprinter",
  "wasmtime",
  "wasmtime-wast",
  "wat",
 ]
 
-[[package]]
-name = "wasmtime-jit"
-version = "14.0.0"
-dependencies = [
- "addr2line",
- "anyhow",
- "bincode",
- "cfg-if",
- "cpp_demangle",
- "gimli",
- "ittapi",
- "log",
- "object",
- "rustc-demangle",
- "rustix 0.38.8",
- "serde",
- "serde_derive",
- "target-lexicon",
- "wasmtime-environ",
- "wasmtime-jit-debug",
- "wasmtime-jit-icache-coherence",
- "wasmtime-runtime",
- "windows-sys",
-]
-
 [[package]]
 name = "wasmtime-jit-debug"
-version = "14.0.0"
+version = "25.0.0"
 dependencies = [
  "object",
  "once_cell",
- "rustix 0.38.8",
+ "rustix 0.38.31",
  "wasmtime-versioned-export-macros",
 ]
 
 [[package]]
 name = "wasmtime-jit-icache-coherence"
-version = "14.0.0"
+version = "25.0.0"
 dependencies = [
+ "anyhow",
  "cfg-if",
  "libc",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
-name = "wasmtime-runtime"
-version = "14.0.0"
+name = "wasmtime-slab"
+version = "25.0.0"
+
+[[package]]
+name = "wasmtime-test-macros"
+version = "0.0.0"
 dependencies = [
  "anyhow",
- "cc",
- "cfg-if",
- "encoding_rs",
- "indexmap 2.0.0",
- "libc",
- "log",
- "mach",
- "memfd",
- "memoffset",
- "once_cell",
- "paste",
- "proptest",
- "rand",
- "rustix 0.38.8",
- "sptr",
- "wasm-encoder",
- "wasmtime-asm-macros",
- "wasmtime-environ",
- "wasmtime-fiber",
- "wasmtime-jit-debug",
- "wasmtime-versioned-export-macros",
- "wasmtime-wmemcheck",
- "windows-sys",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
 ]
 
 [[package]]
 name = "wasmtime-types"
-version = "14.0.0"
+version = "25.0.0"
 dependencies = [
+ "anyhow",
  "cranelift-entity",
  "serde",
  "serde_derive",
- "thiserror",
- "wasmparser",
+ "smallvec",
+ "wasmparser 0.216.0",
 ]
 
 [[package]]
 name = "wasmtime-versioned-export-macros"
-version = "14.0.0"
+version = "25.0.0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.29",
+ "syn 2.0.60",
 ]
 
 [[package]]
 name = "wasmtime-wasi"
-version = "14.0.0"
+version = "25.0.0"
 dependencies = [
  "anyhow",
  "async-trait",
- "bitflags 2.3.3",
+ "bitflags 2.4.1",
  "bytes",
  "cap-fs-ext",
  "cap-net-ext",
@@ -3749,63 +4474,94 @@ dependencies = [
  "fs-set-times",
  "futures",
  "io-extras",
- "io-lifetimes 2.0.2",
- "libc",
- "log",
+ "io-lifetimes 2.0.3",
  "once_cell",
- "rustix 0.38.8",
+ "rustix 0.38.31",
  "system-interface",
+ "tempfile",
  "test-log",
+ "test-programs-artifacts",
  "thiserror",
  "tokio",
  "tracing",
  "tracing-subscriber",
  "url",
- "wasi-cap-std-sync",
- "wasi-common",
- "wasi-tokio",
  "wasmtime",
  "wiggle",
- "windows-sys",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "wasmtime-wasi-http"
-version = "14.0.0"
+version = "25.0.0"
 dependencies = [
  "anyhow",
  "async-trait",
+ "base64 0.21.0",
  "bytes",
  "futures",
- "http",
- "http-body",
+ "http 1.0.0",
+ "http-body 1.0.0",
  "http-body-util",
- "hyper",
- "rustls",
+ "hyper 1.0.1",
+ "rustls 0.22.4",
+ "sha2",
+ "test-log",
+ "test-programs-artifacts",
  "tokio",
  "tokio-rustls",
  "tracing",
+ "tracing-subscriber",
  "wasmtime",
  "wasmtime-wasi",
  "webpki-roots",
 ]
 
+[[package]]
+name = "wasmtime-wasi-keyvalue"
+version = "25.0.0"
+dependencies = [
+ "anyhow",
+ "test-programs-artifacts",
+ "tokio",
+ "wasmtime",
+ "wasmtime-wasi",
+]
+
 [[package]]
 name = "wasmtime-wasi-nn"
-version = "14.0.0"
+version = "25.0.0"
 dependencies = [
  "anyhow",
+ "cap-std",
+ "libtest-mimic",
  "openvino",
+ "ort",
+ "test-programs-artifacts",
  "thiserror",
  "tracing",
+ "tracing-subscriber",
  "walkdir",
  "wasmtime",
+ "wasmtime-wasi",
  "wiggle",
+ "windows",
+]
+
+[[package]]
+name = "wasmtime-wasi-runtime-config"
+version = "25.0.0"
+dependencies = [
+ "anyhow",
+ "test-programs-artifacts",
+ "tokio",
+ "wasmtime",
+ "wasmtime-wasi",
 ]
 
 [[package]]
 name = "wasmtime-wasi-threads"
-version = "14.0.0"
+version = "25.0.0"
 dependencies = [
  "anyhow",
  "log",
@@ -3817,42 +4573,42 @@ dependencies = [
 
 [[package]]
 name = "wasmtime-wast"
-version = "14.0.0"
+version = "25.0.0"
 dependencies = [
  "anyhow",
  "log",
  "wasmtime",
- "wast 65.0.2",
+ "wast 216.0.0",
 ]
 
 [[package]]
 name = "wasmtime-winch"
-version = "14.0.0"
+version = "25.0.0"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
  "gimli",
  "object",
  "target-lexicon",
- "wasmparser",
- "wasmtime-cranelift-shared",
+ "wasmparser 0.216.0",
+ "wasmtime-cranelift",
  "wasmtime-environ",
  "winch-codegen",
 ]
 
 [[package]]
 name = "wasmtime-wit-bindgen"
-version = "14.0.0"
+version = "25.0.0"
 dependencies = [
  "anyhow",
- "heck",
- "indexmap 2.0.0",
- "wit-parser",
+ "heck 0.4.0",
+ "indexmap 2.2.6",
+ "wit-parser 0.216.0",
 ]
 
 [[package]]
 name = "wasmtime-wmemcheck"
-version = "14.0.0"
+version = "25.0.0"
 
 [[package]]
 name = "wast"
@@ -3865,23 +4621,24 @@ dependencies = [
 
 [[package]]
 name = "wast"
-version = "65.0.2"
+version = "216.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a55a88724cf8c2c0ebbf32c8e8f4ac0d6aa7ba6d73a1cfd94b254aa8f894317e"
+checksum = "f7eb1f2eecd913fdde0dc6c3439d0f24530a98ac6db6cb3d14d92a5328554a08"
 dependencies = [
+ "bumpalo",
  "leb128",
  "memchr",
  "unicode-width",
- "wasm-encoder",
+ "wasm-encoder 0.216.0",
 ]
 
 [[package]]
 name = "wat"
-version = "1.0.74"
+version = "1.216.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d83e1a8d86d008adc7bafa5cf4332d448699a08fcf2a715a71fbb75e2c5ca188"
+checksum = "ac0409090fb5154f95fb5ba3235675fd9e579e731524d63b6a2f653e1280c82a"
 dependencies = [
- "wast 65.0.2",
+ "wast 216.0.0",
 ]
 
 [[package]]
@@ -3896,28 +4653,33 @@ dependencies = [
 
 [[package]]
 name = "webpki-roots"
-version = "0.25.2"
+version = "0.26.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14247bb57be4f377dfb94c72830b8ce8fc6beac03cf4bf7b9732eadd414123fc"
+checksum = "b3de34ae270483955a94f4b21bdaaeb83d508bb84a01435f393818edb0012009"
+dependencies = [
+ "rustls-pki-types",
+]
 
 [[package]]
 name = "which"
-version = "4.2.5"
+version = "5.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c4fb54e6113b6a8772ee41c3404fb0301ac79604489467e0a9ce1f3e97c24ae"
+checksum = "9bf3ea8596f3a0dd5980b46430f2058dfe2c36a27ccfbb1845d6fbfcd9ba6e14"
 dependencies = [
  "either",
- "lazy_static",
- "libc",
+ "home",
+ "once_cell",
+ "rustix 0.38.31",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
 name = "wiggle"
-version = "14.0.0"
+version = "25.0.0"
 dependencies = [
  "anyhow",
  "async-trait",
- "bitflags 2.3.3",
+ "bitflags 2.4.1",
  "proptest",
  "thiserror",
  "tokio",
@@ -3930,24 +4692,24 @@ dependencies = [
 
 [[package]]
 name = "wiggle-generate"
-version = "14.0.0"
+version = "25.0.0"
 dependencies = [
  "anyhow",
- "heck",
+ "heck 0.4.0",
  "proc-macro2",
  "quote",
  "shellexpand",
- "syn 2.0.29",
+ "syn 2.0.60",
  "witx",
 ]
 
 [[package]]
 name = "wiggle-macro"
-version = "14.0.0"
+version = "25.0.0"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.29",
+ "syn 2.0.60",
  "wiggle",
  "wiggle-generate",
 ]
@@ -3957,7 +4719,7 @@ name = "wiggle-test"
 version = "0.0.0"
 dependencies = [
  "anyhow",
- "env_logger 0.10.0",
+ "env_logger",
  "proptest",
  "thiserror",
  "tracing",
@@ -3998,7 +4760,7 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
 name = "winch-codegen"
-version = "0.12.0"
+version = "0.23.0"
 dependencies = [
  "anyhow",
  "cranelift-codegen",
@@ -4006,57 +4768,52 @@ dependencies = [
  "regalloc2",
  "smallvec",
  "target-lexicon",
- "wasmparser",
+ "wasmparser 0.216.0",
+ "wasmtime-cranelift",
  "wasmtime-environ",
 ]
 
 [[package]]
-name = "winch-filetests"
-version = "0.0.0"
+name = "windows"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e48a53791691ab099e5e2ad123536d0fff50652600abaf43bbf952894110d0be"
 dependencies = [
- "anyhow",
- "capstone",
- "cranelift-codegen",
- "serde",
- "serde_derive",
- "similar",
- "target-lexicon",
- "toml",
- "wasmtime-environ",
- "wat",
- "winch-codegen",
- "winch-test-macros",
+ "windows-core",
+ "windows-implement",
+ "windows-interface",
+ "windows-targets 0.52.0",
 ]
 
 [[package]]
-name = "winch-test-macros"
-version = "0.0.0"
+name = "windows-core"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
+dependencies = [
+ "windows-targets 0.52.0",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12168c33176773b86799be25e2a2ba07c7aab9968b37541f1094dbd7a60c8946"
 dependencies = [
- "glob",
  "proc-macro2",
  "quote",
- "syn 2.0.29",
+ "syn 2.0.60",
 ]
 
 [[package]]
-name = "winch-tools"
-version = "0.0.0"
+name = "windows-interface"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d8dc32e0095a7eeccebd0e3f09e9509365ecb3fc6ac4d6f5f14a3f6392942d1"
 dependencies = [
- "anyhow",
- "capstone",
- "clap",
- "cranelift-codegen",
- "glob",
- "serde",
- "similar",
- "target-lexicon",
- "toml",
- "wasmparser",
- "wasmtime-environ",
- "wat",
- "winch-codegen",
- "winch-filetests",
- "winch-test-macros",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
 ]
 
 [[package]]
@@ -4065,208 +4822,369 @@ version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
 dependencies = [
- "windows-targets",
+ "windows-targets 0.48.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets 0.52.0",
 ]
 
 [[package]]
 name = "windows-targets"
-version = "0.48.0"
+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.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b1eb6f0cd7c80c79759c929114ef071b87354ce476d9d94271031c0497adfd5"
+checksum = "8a18201040b24831fbb9e4eb208f8892e1f50a37feb53cc7ff887feb8f50e7cd"
 dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
+ "windows_aarch64_gnullvm 0.52.0",
+ "windows_aarch64_msvc 0.52.0",
+ "windows_i686_gnu 0.52.0",
+ "windows_i686_msvc 0.52.0",
+ "windows_x86_64_gnu 0.52.0",
+ "windows_x86_64_gnullvm 0.52.0",
+ "windows_x86_64_msvc 0.52.0",
 ]
 
 [[package]]
 name = "windows_aarch64_gnullvm"
-version = "0.48.0"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91ae572e1b79dba883e0d315474df7305d12f569b400fcf90581b06062f7e1bc"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb7764e35d4db8a7921e09562a0304bf2f93e0a51bfccee0bd0bb0b666b015ea"
 
 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.48.0"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2ef27e0d7bdfcfc7b868b317c1d32c641a6fe4629c171b8928c7b08d98d7cf3"
+checksum = "bbaa0368d4f1d2aaefc55b6fcfee13f41544ddf36801e793edbbfd7d7df075ef"
 
 [[package]]
 name = "windows_i686_gnu"
-version = "0.48.0"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "622a1962a7db830d6fd0a69683c80a18fda201879f0f447f065a3b7467daa241"
+checksum = "a28637cb1fa3560a16915793afb20081aba2c92ee8af57b4d5f28e4b3e7df313"
 
 [[package]]
 name = "windows_i686_msvc"
-version = "0.48.0"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4542c6e364ce21bf45d69fdd2a8e455fa38d316158cfd43b3ac1c5b1b19f8e00"
+checksum = "ffe5e8e31046ce6230cc7215707b816e339ff4d4d67c65dffa206fd0f7aa7b9a"
 
 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.48.0"
+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.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca2b8a661f7628cbd23440e50b05d705db3686f894fc9580820623656af974b1"
+checksum = "3d6fa32db2bc4a2f5abeacf2b69f7992cd09dca97498da74a151a3132c26befd"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
-version = "0.48.0"
+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.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7896dbc1f41e08872e9d5e8f8baa8fdd2677f29468c4e156210174edc7f7b953"
+checksum = "1a657e1e9d3f514745a572a6846d3c7aa7dbe1658c056ed9c3344c4109a6949e"
 
 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.48.0"
+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.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dff9641d1cd4be8d1a070daf9e3773c5f67e78b4d9d42263020c057706765c04"
+
+[[package]]
+name = "winnow"
+version = "0.5.39"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5389a154b01683d28c77f8f68f49dea75f0a4da32557a58f68ee51ebba472d29"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "winreg"
+version = "0.50.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a"
+checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1"
+dependencies = [
+ "cfg-if",
+ "windows-sys 0.48.0",
+]
 
 [[package]]
 name = "winx"
-version = "0.36.1"
+version = "0.36.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4857cedf8371f690bb6782a3e2b065c54d1b6661be068aaf3eac8b45e813fdf8"
+checksum = "f9643b83820c0cd246ecabe5fa454dd04ba4fa67996369466d0747472d337346"
 dependencies = [
- "bitflags 2.3.3",
- "windows-sys",
+ "bitflags 2.4.1",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "wit-bindgen"
-version = "0.12.0"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4f7c5d6f59ae013fc4c013c76eab667844a46e86b51987acb71b1e32953211a"
+checksum = "7b4bac478334a647374ff24a74b66737a4cb586dc8288bc3080a93252cd1105c"
 dependencies = [
- "bitflags 2.3.3",
+ "wit-bindgen-rt",
  "wit-bindgen-rust-macro",
 ]
 
 [[package]]
 name = "wit-bindgen-core"
-version = "0.12.0"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f0371c47784e7559efb422f74473e395b49f7101725584e2673657e0b4fc104"
+checksum = "bb7e3df01cd43cfa1cb52602e4fc05cb2b62217655f6705639b6953eb0a3fed2"
 dependencies = [
  "anyhow",
- "wit-component",
- "wit-parser",
+ "heck 0.5.0",
+ "wit-parser 0.215.0",
 ]
 
 [[package]]
-name = "wit-bindgen-rust"
-version = "0.12.0"
+name = "wit-bindgen-rt"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eeab5a09a85b1641690922ce05d79d868a2f2e78e9415a5302f58b9846fab8f1"
+checksum = "b2de7a3b06b9725d129b5cbd1beca968feed919c433305a23da46843185ecdd6"
 dependencies = [
- "anyhow",
- "heck",
- "wasm-metadata",
- "wit-bindgen-core",
- "wit-bindgen-rust-lib",
- "wit-component",
+ "bitflags 2.4.1",
 ]
 
 [[package]]
-name = "wit-bindgen-rust-lib"
-version = "0.12.0"
+name = "wit-bindgen-rust"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a13c89c9c1a93e164318745841026f63f889376f38664f86a7f678930280e728"
+checksum = "61a767d1a8eb4e908bfc53febc48b87ada545703b16fe0148ee7736a29a01417"
 dependencies = [
- "heck",
+ "anyhow",
+ "heck 0.5.0",
+ "indexmap 2.2.6",
+ "prettyplease",
+ "syn 2.0.60",
+ "wasm-metadata 0.215.0",
  "wit-bindgen-core",
+ "wit-component 0.215.0",
 ]
 
 [[package]]
 name = "wit-bindgen-rust-macro"
-version = "0.12.0"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a70c97e09751a9a95a592bd8ef84e953e5cdce6ebbfdb35ceefa5cc511da3b71"
+checksum = "9b185c342d0d27bd83d4080f5a66cf3b4f247fa49d679bceb66e11cc7eb58b99"
 dependencies = [
  "anyhow",
+ "prettyplease",
  "proc-macro2",
- "syn 2.0.29",
+ "quote",
+ "syn 2.0.60",
  "wit-bindgen-core",
  "wit-bindgen-rust",
- "wit-bindgen-rust-lib",
- "wit-component",
 ]
 
 [[package]]
 name = "wit-component"
-version = "0.14.4"
+version = "0.215.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f725e3885fc5890648be5c5cbc1353b755dc932aa5f1aa7de968b912a3280743"
+dependencies = [
+ "anyhow",
+ "bitflags 2.4.1",
+ "indexmap 2.2.6",
+ "log",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "wasm-encoder 0.215.0",
+ "wasm-metadata 0.215.0",
+ "wasmparser 0.215.0",
+ "wit-parser 0.215.0",
+]
+
+[[package]]
+name = "wit-component"
+version = "0.216.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee23614740bf871dac9856e3062c7a308506eb3f0a2759939ab8d0aa8436a1c0"
+checksum = "7e2ca3ece38ea2447a9069b43074ba73d96dde1944cba276c54e41371745f9dc"
 dependencies = [
  "anyhow",
- "bitflags 2.3.3",
- "indexmap 2.0.0",
+ "bitflags 2.4.1",
+ "indexmap 2.2.6",
  "log",
  "serde",
+ "serde_derive",
  "serde_json",
- "wasm-encoder",
- "wasm-metadata",
- "wasmparser",
- "wit-parser",
+ "wasm-encoder 0.216.0",
+ "wasm-metadata 0.216.0",
+ "wasmparser 0.216.0",
+ "wit-parser 0.216.0",
 ]
 
 [[package]]
 name = "wit-parser"
-version = "0.11.3"
+version = "0.215.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a39edca9abb16309def3843af73b58d47d243fe33a9ceee572446bcc57556b9a"
+checksum = "935a97eaffd57c3b413aa510f8f0b550a4a9fe7d59e79cd8b89a83dcb860321f"
 dependencies = [
  "anyhow",
  "id-arena",
- "indexmap 2.0.0",
+ "indexmap 2.2.6",
  "log",
- "pulldown-cmark",
  "semver",
  "serde",
+ "serde_derive",
  "serde_json",
  "unicode-xid",
- "url",
+ "wasmparser 0.215.0",
+]
+
+[[package]]
+name = "wit-parser"
+version = "0.216.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4d108165c1167a4ccc8a803dcf5c28e0a51d6739fd228cc7adce768632c764c"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "indexmap 2.2.6",
+ "log",
+ "semver",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser 0.216.0",
 ]
 
 [[package]]
 name = "witx"
 version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e366f27a5cabcddb2706a78296a40b8fcc451e1a6aba2fc1d94b4a01bdaaef4b"
 dependencies = [
  "anyhow",
  "log",
- "rayon",
  "thiserror",
  "wast 35.0.2",
 ]
 
+[[package]]
+name = "xattr"
+version = "1.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8da84f1a25939b27f6820d92aed108f83ff920fdf11a7b19366c27c4cda81d4f"
+dependencies = [
+ "libc",
+ "linux-raw-sys 0.4.12",
+ "rustix 0.38.31",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.7.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74d4d3961e53fa4c9a25a8637fc2bfaf2595b3d3ae34875568a5cf64787716be"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.60",
+]
+
+[[package]]
+name = "zeroize"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "525b4ec142c6b68a2d10f01f7bbf6755599ca3f81ea53b8431b7dd348f5fdb2d"
+
 [[package]]
 name = "zstd"
-version = "0.11.1+zstd.1.5.2"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77a16b8414fde0414e90c612eba70985577451c4c504b99885ebed24762cb81a"
+checksum = "bffb3309596d527cfcba7dfc6ed6052f1d39dfbd7c867aa2e865e4a449c10110"
 dependencies = [
  "zstd-safe",
 ]
 
 [[package]]
 name = "zstd-safe"
-version = "5.0.1+zstd.1.5.2"
+version = "7.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c12659121420dd6365c5c3de4901f97145b79651fb1d25814020ed2ed0585ae"
+checksum = "43747c7422e2924c11144d5229878b98180ef8b06cca4ab5af37afc8a8d8ea3e"
 dependencies = [
- "libc",
  "zstd-sys",
 ]
 
 [[package]]
 name = "zstd-sys"
-version = "2.0.1+zstd.1.5.2"
+version = "2.0.9+zstd.1.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fd07cbbc53846d9145dbffdf6dd09a7a0aa52be46741825f5c97bdd4f73f12b"
+checksum = "9e16efa8a874a0481a574084d34cc26fdb3b99627480f785888deb6386506656"
 dependencies = [
  "cc",
- "libc",
+ "pkg-config",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index d4cc8fc06a95..e5a47c2366b7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,6 +13,27 @@ edition.workspace = true
 default-run = "wasmtime"
 rust-version.workspace = true
 
+[package.metadata.binstall]
+pkg-url = "{repo}/releases/download/v{version}/wasmtime-v{version}-{target-arch}-{target-family}{archive-suffix}"
+bin-dir = "wasmtime-v{version}-{target-arch}-{target-family}/{bin}{binary-ext}"
+pkg-fmt = "txz"
+[package.metadata.binstall.overrides.x86_64-apple-darwin]
+pkg-url = "{repo}/releases/download/v{version}/wasmtime-v{version}-{target-arch}-macos{archive-suffix}"
+bin-dir = "wasmtime-v{version}-{target-arch}-macos/{bin}{binary-ext}"
+[package.metadata.binstall.overrides.aarch64-apple-darwin]
+pkg-url = "{repo}/releases/download/v{version}/wasmtime-v{version}-{target-arch}-macos{archive-suffix}"
+bin-dir = "wasmtime-v{version}-{target-arch}-macos/{bin}{binary-ext}"
+[package.metadata.binstall.overrides.x86_64-pc-windows-msvc]
+pkg-fmt = "zip"
+[package.metadata.binstall.overrides.x86_64-pc-windows-gnu]
+pkg-fmt = "zip"
+[package.metadata.binstall.overrides.x86_64-unknown-linux-musl]
+pkg-url = "{repo}/releases/download/v{version}/wasmtime-v{version}-{target-arch}-musl{archive-suffix}"
+bin-dir = "wasmtime-v{version}-{target-arch}-musl/{bin}{binary-ext}"
+
+[lints]
+workspace = true
+
 [lib]
 doctest = false
 
@@ -22,53 +43,56 @@ path = "src/bin/wasmtime.rs"
 doc = false
 
 [dependencies]
-wasmtime = { workspace = true, features = ['cache', 'cranelift'] }
-wasmtime-cache = { workspace = true }
+wasmtime = { workspace = true, features = ['std'] }
+wasmtime-cache = { workspace = true, optional = true }
 wasmtime-cli-flags = { workspace = true }
-wasmtime-cranelift = { workspace = true }
+wasmtime-cranelift = { workspace = true, optional = true }
 wasmtime-environ = { workspace = true }
-wasmtime-explorer = { workspace = true }
-wasmtime-wast = { workspace = true }
-wasmtime-wasi = { workspace = true, default-features = true, features = [
-  "exit",
-] }
+wasmtime-explorer = { workspace = true, optional = true }
+wasmtime-wast = { workspace = true, optional = true }
+wasi-common = { workspace = true, default-features = true, features = ["exit", "tokio"], optional = true }
+wasmtime-wasi = { workspace = true, default-features = true, optional = true }
 wasmtime-wasi-nn = { workspace = true, optional = true }
+wasmtime-wasi-runtime-config = { workspace = true, optional = true }
+wasmtime-wasi-keyvalue = { workspace = true, optional = true }
 wasmtime-wasi-threads = { workspace = true, optional = true }
 wasmtime-wasi-http = { workspace = true, optional = true }
-wasmtime-runtime = { workspace = true }
-clap = { workspace = true, features = ["color", "suggestions", "derive"] }
-anyhow = { workspace = true }
+clap = { workspace = true }
+anyhow = { workspace = true, features = ['std'] }
 target-lexicon = { workspace = true }
 once_cell = { workspace = true }
-listenfd = "1.0.0"
-wat = { workspace = true }
+listenfd = { version = "1.0.0", optional = true }
+wat = { workspace = true, optional = true }
 serde = { workspace = true }
 serde_derive = { workspace = true }
 serde_json = { workspace = true }
 wasmparser = { workspace = true }
-wasm-encoder = { workspace = true }
+tracing = { workspace = true }
+log = { workspace = true }
+humantime = { workspace = true }
+tempfile = { workspace = true, optional = true }
 
 async-trait = { workspace = true }
+bytes = { workspace = true }
+cfg-if = { workspace = true }
 tokio = { workspace = true, optional = true, features = [ "signal", "macros" ] }
 hyper = { workspace = true, optional = true }
-http-body = { workspace = true }
-http-body-util = { workspace = true }
+http = { workspace = true, optional = true }
+http-body-util = { workspace = true, optional = true }
 
 [target.'cfg(unix)'.dependencies]
-rustix = { workspace = true, features = ["mm", "param"] }
+rustix = { workspace = true, features = ["mm", "param", "process"] }
 
 [dev-dependencies]
 # depend again on wasmtime to activate its default features for tests
-wasmtime = { workspace = true, features = ['component-model', 'async', 'default', 'winch'] }
+wasmtime = { workspace = true, features = ['default', 'winch', 'all-arch', 'call-hook', 'memory-protection-keys'] }
 env_logger = { workspace = true }
 log = { workspace = true }
 filecheck = { workspace = true }
 tempfile = { workspace = true }
-test-programs = { path = "crates/test-programs" }
-wasmtime-runtime = { workspace = true }
 tokio = { workspace = true, features = ["rt", "time", "macros", "rt-multi-thread"] }
 wast = { workspace = true }
-criterion = "0.5.0"
+criterion = { workspace = true }
 num_cpus = "1.13.0"
 memchr = "2.4"
 async-trait = { workspace = true }
@@ -83,12 +107,24 @@ libc = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 walkdir = { workspace = true }
+test-programs-artifacts = { workspace = true }
+bytesize = "1.3.0"
+wit-component = { workspace = true }
+cranelift-filetests = { workspace = true }
+cranelift-codegen = { workspace = true, features = ["disas", "trace-log", "timing"] }
+cranelift-reader = { workspace = true }
+toml = { workspace = true }
+similar = { workspace = true }
+libtest-mimic = { workspace = true }
+capstone = { workspace = true }
+object = { workspace = true, features = ['std'] }
+wasmtime-test-macros = { path = "crates/test-macros" }
 
 [target.'cfg(windows)'.dev-dependencies]
 windows-sys = { workspace = true, features = ["Win32_System_Memory"] }
 
 [build-dependencies]
-anyhow = { workspace = true }
+anyhow = { workspace = true, features = ['std'] }
 
 [profile.release.build-override]
 opt-level = 0
@@ -99,145 +135,166 @@ members = [
   "cranelift",
   "cranelift/isle/fuzz",
   "cranelift/isle/islec",
+  "cranelift/isle/veri/aslp",
+  "cranelift/isle/veri/isaspec",
+  "cranelift/isle/veri/meta",
+  "cranelift/isle/veri/test-macros",
+  "cranelift/isle/veri/veri",
   "cranelift/serde",
   "crates/bench-api",
-  "crates/c-api",
-  "crates/cli-flags",
+  "crates/c-api/artifact",
   "crates/environ/fuzz",
-  "crates/jit-icache-coherence",
-  "crates/test-programs/wasi-tests",
-  "crates/test-programs/wasi-http-tests",
-  "crates/test-programs/wasi-http-proxy-tests",
-  "crates/test-programs/wasi-sockets-tests",
-  "crates/test-programs/command-tests",
-  "crates/test-programs/reactor-tests",
-  "crates/wmemcheck",
+  "crates/test-programs",
   "crates/wasi-preview1-component-adapter",
   "crates/wasi-preview1-component-adapter/verify",
-  "crates/winch",
   "examples/fib-debug/wasm",
   "examples/wasi/wasm",
   "examples/tokio/wasm",
+  "examples/component/wasm",
+  "examples/min-platform",
+  "examples/min-platform/embedding",
   "fuzz",
-  "winch",
   "winch/codegen",
 ]
 exclude = [
-  'crates/wasi-common/WASI/tools/witx-cli',
   'docs/rust_wasi_markdown_parser',
 ]
 
 [workspace.package]
-version = "14.0.0"
+version = "25.0.0"
 authors = ["The Wasmtime Project Developers"]
 edition = "2021"
 # Wasmtime's current policy is that this number can be no larger than the
 # current stable release of Rust minus 2.
-rust-version = "1.70.0"
+rust-version = "1.78.0"
+
+[workspace.lints.rust]
+# Turn on some lints which are otherwise allow-by-default in rustc.
+unused_extern_crates = 'warn'
+trivial_numeric_casts = 'warn'
+unstable_features = 'warn'
+unused_import_braces = 'warn'
+unused-lifetimes = 'warn'
+
+[workspace.lints.clippy]
+# The default set of lints in Clippy is viewed as "too noisy" right now so
+# they're all turned off by default. Selective lints are then enabled below as
+# necessary.
+all = { level = 'allow', priority = -1 }
+clone_on_copy = 'warn'
+map_clone = 'warn'
+uninlined_format_args = 'warn'
+unnecessary_to_owned = 'warn'
+manual_strip = 'warn'
 
 [workspace.dependencies]
-wasmtime-wmemcheck = { path = "crates/wmemcheck", version = "=14.0.0" }
-wasmtime = { path = "crates/wasmtime", version = "14.0.0", default-features = false }
-wasmtime-cache = { path = "crates/cache", version = "=14.0.0" }
-wasmtime-cli-flags = { path = "crates/cli-flags", version = "=14.0.0" }
-wasmtime-cranelift = { path = "crates/cranelift", version = "=14.0.0" }
-wasmtime-cranelift-shared = { path = "crates/cranelift-shared", version = "=14.0.0" }
-wasmtime-winch = { path = "crates/winch", version = "=14.0.0" }
-wasmtime-environ = { path = "crates/environ", version = "=14.0.0" }
-wasmtime-explorer = { path = "crates/explorer", version = "=14.0.0" }
-wasmtime-fiber = { path = "crates/fiber", version = "=14.0.0" }
-wasmtime-types = { path = "crates/types", version = "14.0.0" }
-wasmtime-jit = { path = "crates/jit", version = "=14.0.0" }
-wasmtime-jit-debug = { path = "crates/jit-debug", version = "=14.0.0" }
-wasmtime-runtime = { path = "crates/runtime", version = "=14.0.0" }
-wasmtime-wast = { path = "crates/wast", version = "=14.0.0" }
-wasmtime-wasi = { path = "crates/wasi", version = "14.0.0", default-features = false }
-wasmtime-wasi-http = { path = "crates/wasi-http", version = "=14.0.0", default-features = false }
-wasmtime-wasi-nn = { path = "crates/wasi-nn", version = "14.0.0" }
-wasmtime-wasi-threads = { path = "crates/wasi-threads", version = "14.0.0" }
-wasmtime-component-util = { path = "crates/component-util", version = "=14.0.0" }
-wasmtime-component-macro = { path = "crates/component-macro", version = "=14.0.0" }
-wasmtime-asm-macros = { path = "crates/asm-macros", version = "=14.0.0" }
-wasmtime-versioned-export-macros = { path = "crates/versioned-export-macros", version = "=14.0.0" }
+arbitrary = { version = "1.3.1" }
+wasmtime-wmemcheck = { path = "crates/wmemcheck", version = "=25.0.0" }
+wasmtime = { path = "crates/wasmtime", version = "25.0.0", default-features = false }
+wasmtime-c-api-macros = { path = "crates/c-api-macros", version = "=25.0.0" }
+wasmtime-cache = { path = "crates/cache", version = "=25.0.0" }
+wasmtime-cli-flags = { path = "crates/cli-flags", version = "=25.0.0" }
+wasmtime-cranelift = { path = "crates/cranelift", version = "=25.0.0" }
+wasmtime-winch = { path = "crates/winch", version = "=25.0.0" }
+wasmtime-environ = { path = "crates/environ", version = "=25.0.0" }
+wasmtime-explorer = { path = "crates/explorer", version = "=25.0.0" }
+wasmtime-fiber = { path = "crates/fiber", version = "=25.0.0" }
+wasmtime-types = { path = "crates/types", version = "25.0.0" }
+wasmtime-jit-debug = { path = "crates/jit-debug", version = "=25.0.0" }
+wasmtime-wast = { path = "crates/wast", version = "=25.0.0" }
+wasmtime-wasi = { path = "crates/wasi", version = "25.0.0", default-features = false }
+wasmtime-wasi-http = { path = "crates/wasi-http", version = "=25.0.0", default-features = false }
+wasmtime-wasi-nn = { path = "crates/wasi-nn", version = "25.0.0" }
+wasmtime-wasi-runtime-config = { path = "crates/wasi-runtime-config", version = "25.0.0" }
+wasmtime-wasi-keyvalue = { path = "crates/wasi-keyvalue", version = "25.0.0" }
+wasmtime-wasi-threads = { path = "crates/wasi-threads", version = "25.0.0" }
+wasmtime-component-util = { path = "crates/component-util", version = "=25.0.0" }
+wasmtime-component-macro = { path = "crates/component-macro", version = "=25.0.0" }
+wasmtime-asm-macros = { path = "crates/asm-macros", version = "=25.0.0" }
+wasmtime-versioned-export-macros = { path = "crates/versioned-export-macros", version = "=25.0.0" }
+wasmtime-slab = { path = "crates/slab", version = "=25.0.0" }
 component-test-util = { path = "crates/misc/component-test-util" }
 component-fuzz-util = { path = "crates/misc/component-fuzz-util" }
-wiggle = { path = "crates/wiggle", version = "=14.0.0", default-features = false }
-wiggle-macro = { path = "crates/wiggle/macro", version = "=14.0.0" }
-wiggle-generate = { path = "crates/wiggle/generate", version = "=14.0.0" }
-wasi-common = { path = "crates/wasi-common", version = "=14.0.0" }
-wasi-tokio = { path = "crates/wasi-common/tokio", version = "=14.0.0" }
-wasi-cap-std-sync = { path = "crates/wasi-common/cap-std-sync", version = "=14.0.0" }
+wiggle = { path = "crates/wiggle", version = "=25.0.0", default-features = false }
+wiggle-macro = { path = "crates/wiggle/macro", version = "=25.0.0" }
+wiggle-generate = { path = "crates/wiggle/generate", version = "=25.0.0" }
+wasi-common = { path = "crates/wasi-common", version = "=25.0.0", default-features = false }
 wasmtime-fuzzing = { path = "crates/fuzzing" }
-wasmtime-jit-icache-coherence = { path = "crates/jit-icache-coherence", version = "=14.0.0" }
-wasmtime-wit-bindgen = { path = "crates/wit-bindgen", version = "=14.0.0" }
-
-cranelift-wasm = { path = "cranelift/wasm", version = "0.101.0" }
-cranelift-codegen = { path = "cranelift/codegen", version = "0.101.0" }
-cranelift-frontend = { path = "cranelift/frontend", version = "0.101.0" }
-cranelift-entity = { path = "cranelift/entity", version = "0.101.0" }
-cranelift-native = { path = "cranelift/native", version = "0.101.0" }
-cranelift-module = { path = "cranelift/module", version = "0.101.0" }
-cranelift-interpreter = { path = "cranelift/interpreter", version = "0.101.0" }
-cranelift-reader = { path = "cranelift/reader", version = "0.101.0" }
+wasmtime-jit-icache-coherence = { path = "crates/jit-icache-coherence", version = "=25.0.0" }
+wasmtime-wit-bindgen = { path = "crates/wit-bindgen", version = "=25.0.0" }
+test-programs-artifacts = { path = 'crates/test-programs/artifacts' }
+
+pulley-interpreter = { path = 'pulley', version = "=0.1.0" }
+pulley-interpreter-fuzz = { path = 'pulley/fuzz' }
+
+cranelift-wasm = { path = "cranelift/wasm", version = "0.112.0" }
+cranelift-codegen = { path = "cranelift/codegen", version = "0.112.0", default-features = false, features = ["std", "unwind"] }
+cranelift-frontend = { path = "cranelift/frontend", version = "0.112.0" }
+cranelift-entity = { path = "cranelift/entity", version = "0.112.0" }
+cranelift-native = { path = "cranelift/native", version = "0.112.0" }
+cranelift-module = { path = "cranelift/module", version = "0.112.0" }
+cranelift-interpreter = { path = "cranelift/interpreter", version = "0.112.0" }
+cranelift-reader = { path = "cranelift/reader", version = "0.112.0" }
 cranelift-filetests = { path = "cranelift/filetests" }
-cranelift-object = { path = "cranelift/object", version = "0.101.0" }
-cranelift-jit = { path = "cranelift/jit", version = "0.101.0" }
+cranelift-object = { path = "cranelift/object", version = "0.112.0" }
+cranelift-jit = { path = "cranelift/jit", version = "0.112.0" }
 cranelift-fuzzgen = { path = "cranelift/fuzzgen" }
-cranelift-bforest = { path = "cranelift/bforest", version = "0.101.0" }
-cranelift-control = { path = "cranelift/control", version = "0.101.0" }
-cranelift = { path = "cranelift/umbrella", version = "0.101.0" }
+cranelift-bforest = { path = "cranelift/bforest", version = "0.112.0" }
+cranelift-bitset = { path = "cranelift/bitset", version = "0.112.0" }
+cranelift-control = { path = "cranelift/control", version = "0.112.0" }
+cranelift = { path = "cranelift/umbrella", version = "0.112.0" }
 
-winch-codegen = { path = "winch/codegen", version = "=0.12.0" }
-winch-filetests = { path = "winch/filetests" }
-winch-test-macros = { path = "winch/test-macros" }
+winch-codegen = { path = "winch/codegen", version = "=0.23.0" }
 
 wasi-preview1-component-adapter = { path = "crates/wasi-preview1-component-adapter" }
 byte-array-literals = { path = "crates/wasi-preview1-component-adapter/byte-array-literals" }
 
 # Bytecode Alliance maintained dependencies:
 # ---------------------------
-regalloc2 = "0.9.2"
+regalloc2 = "0.9.4"
 
 # cap-std family:
-target-lexicon = { version = "0.12.3", default-features = false, features = ["std"] }
-cap-std = "2.0.0"
-cap-rand = { version = "2.0.0", features = ["small_rng"] }
-cap-fs-ext = "2.0.0"
-cap-net-ext = "2.0.0"
-cap-time-ext = "2.0.0"
-cap-tempfile = "2.0.0"
-fs-set-times = "0.20.0"
-system-interface = { version = "0.26.0", features = ["cap_std_impls"] }
-io-lifetimes = { version = "2.0.2", default-features = false }
-io-extras = "0.18.0"
-rustix = "0.38.8"
-is-terminal = "0.4.0"
+target-lexicon = "0.12.16"
+cap-std = "3.0.0"
+cap-rand = { version = "3.0.0", features = ["small_rng"] }
+cap-fs-ext = "3.0.0"
+cap-net-ext = "3.0.0"
+cap-time-ext = "3.0.0"
+cap-tempfile = "3.0.0"
+fs-set-times = "0.20.1"
+system-interface = { version = "0.27.1", features = ["cap_std_impls"] }
+io-lifetimes = { version = "2.0.3", default-features = false }
+io-extras = "0.18.1"
+rustix = "0.38.31"
 # wit-bindgen:
-wit-bindgen = { version = "0.12.0", default-features = false }
+wit-bindgen = { version = "0.30.0", default-features = false }
+wit-bindgen-rust-macro = { version = "0.30.0", default-features = false }
 
 # wasm-tools family:
-wasmparser = "0.113.2"
-wat = "1.0.74"
-wast = "65.0.2"
-wasmprinter = "0.2.67"
-wasm-encoder = "0.33.2"
-wasm-smith = "0.12.18"
-wasm-mutate = "0.2.35"
-wit-parser = "0.11.3"
-wit-component = "0.14.4"
+wasmparser = { version = "0.216.0", default-features = false }
+wat = "1.216.0"
+wast = "216.0.0"
+wasmprinter = "0.216.0"
+wasm-encoder = "0.216.0"
+wasm-smith = "0.216.0"
+wasm-mutate = "0.216.0"
+wit-parser = "0.216.0"
+wit-component = "0.216.0"
 
 # Non-Bytecode Alliance maintained dependencies:
 # --------------------------
-object = { version = "0.32", default-features = false, features = ['read_core', 'elf', 'std'] }
-gimli = { version = "0.28.0", default-features = false, features = ['read', 'std'] }
-anyhow = "1.0.22"
-windows-sys = "0.48.0"
+cc = "1.0"
+object = { version = "0.36", default-features = false, features = ['read_core', 'elf'] }
+gimli = { version = "0.29.0", default-features = false, features = ['read'] }
+addr2line = { version = "0.22.0", default-features = false }
+anyhow = { version = "1.0.22", default-features = false }
+windows-sys = "0.52.0"
 env_logger = "0.10"
 log = { version = "0.4.8", default-features = false }
-clap = { version = "4.3.12", features = ["color", "suggestions", "derive"] }
+clap = { version = "4.3.12", default-features = false, features = ["std", "derive"] }
 hashbrown = { version = "0.14", default-features = false }
-capstone = "0.9.0"
-once_cell = "1.12.0"
+capstone = "0.12.0"
+once_cell = { version = "1.12.0", default-features = false }
 smallvec = { version = "1.6.1", features = ["union"] }
 tracing = "0.1.26"
 bitflags = "2.0"
@@ -245,9 +302,15 @@ thiserror = "1.0.43"
 async-trait = "0.1.71"
 heck = "0.4"
 similar = "2.1.0"
-toml = "0.5.9"
+toml = "0.8.10"
+mach2 = "0.4.2"
+memfd = "0.6.2"
+psm = "0.1.11"
+proptest = "1.0.0"
+rand = { version = "0.8.3", features = ["small_rng"] }
+sptr = "0.3.2"
 # serde and serde_derive must have the same version
-serde = "1.0.188"
+serde = { version = "1.0.188", default-features = false, features = ['alloc'] }
 serde_derive = "1.0.188"
 serde_json = "1.0.80"
 glob = "0.3.0"
@@ -256,58 +319,150 @@ walkdir = "2.3.3"
 cfg-if = "1.0"
 tempfile = "3.1.0"
 filecheck = "0.5.0"
-libc = "0.2.60"
+libc = { version = "0.2.112", default-features = true }
 file-per-thread-logger = "0.2.0"
-tokio = { version = "1.26.0", features = [ "rt", "time" ] }
-hyper = "=1.0.0-rc.3"
-http = "0.2.9"
-http-body = "=1.0.0-rc.2"
-http-body-util = "=0.1.0-rc.2"
+tokio = { version = "1.30.0", features = [ "rt", "time" ] }
+hyper = "1.0.1"
+http = "1.0.0"
+http-body = "1.0.0"
+http-body-util = "0.1.0"
+reqwest = "0.11"
 bytes = "1.4"
 futures = { version = "0.3.27", default-features = false }
-indexmap = "2.0.0"
+indexmap = { version = "2.0.0", default-features = false }
 pretty_env_logger = "0.5.0"
 syn = "2.0.25"
 test-log = { version = "0.2", default-features = false, features = ["trace"] }
-tracing-subscriber = { version = "0.3.1", default-features = false, features = ['fmt', 'env-filter'] }
+tracing-subscriber = { version = "0.3.1", default-features = false, features = ['fmt', 'env-filter', 'ansi', 'tracing-log'] }
 url = "2.3.1"
+humantime = "2.0.0"
+postcard = { version = "1.0.8", default-features = false, features = ['alloc'] }
+criterion = { version = "0.5.0", default-features = false, features = ["html_reports", "rayon"] }
+rustc-hash = "1.1.0"
+libtest-mimic = "0.7.0"
+semver = { version = "1.0.17", default-features = false }
 
+# =============================================================================
+#
+# Features for the Wasmtime CLI executable
+#
+#
+# Note that many of these features are inherited from Wasmtime itself or
+# otherwise configure the `wasmtime` crate's execution. Features are provided as
+# compile-time switches to disable functionality primarily if one is interested
+# in configuring binary size and or exploring the binary size implications of
+# various features. Most features are enabled by default but most embeddings
+# likely won't need all features.
+#
+# When adding or removing a feature, make sure to kepe the C API in sync by
+# modifying locations marked WASMTIME_FEATURE_LIST
 [features]
 default = [
-  "jitdump",
-  "wasmtime/wat",
-  "wasmtime/parallel-compilation",
-  "vtune",
+  # All subcommands are included by default.
+  "run",
+  "compile",
+  "explore",
+  "serve",
+  "wast",
+  "config",
+
+  # On-by-default WASI features
   "wasi-nn",
   "wasi-threads",
   "wasi-http",
+  "wasi-runtime-config",
+  "wasi-keyvalue",
+
+  # Most features of Wasmtime are enabled by default.
+  "wat",
+  "parallel-compilation",
   "pooling-allocator",
+  "cache",
+  "logging",
+  "demangle",
+  "cranelift",
+  "profiling",
+  "coredump",
+  "addr2line",
+  "debug-builtins",
+  "component-model",
+  "threads",
+  "gc",
+  "winch",
+
+  # Enable some nice features of clap by default, but they come at a binary size
+  # cost, so allow disabling this through disabling of our own `default`
+  # feature.
+  "clap/default",
+  "clap/wrap_help",
 ]
-jitdump = ["wasmtime/jitdump"]
-vtune = ["wasmtime/vtune"]
+
+# ========================================
+# Off-by-default features
+#
+# These features are off-by-default but may optionally be enabled.
+all-arch = ["wasmtime/all-arch"]
+winch = ["wasmtime/winch"]
+wmemcheck = ["wasmtime/wmemcheck"]
+memory-protection-keys = ["wasmtime-cli-flags/memory-protection-keys"]
+
+# This feature, when enabled, will statically compile out all logging statements
+# throughout Wasmtime and its dependencies.
+disable-logging = ["log/max_level_off", "tracing/max_level_off"]
+
+# ========================================
+# On-by-default features
+#
+# These features are all included in the `default` set above and this is
+# the internal mapping for what they enable in Wasmtime itself.
 wasi-nn = ["dep:wasmtime-wasi-nn"]
-wasi-threads = ["dep:wasmtime-wasi-threads"]
-wasi-http = ["component-model", "dep:wasmtime-wasi-http", "dep:tokio", "dep:hyper", "wasmtime-wasi-http?/sync"]
+wasi-threads = ["dep:wasmtime-wasi-threads", "threads"]
+wasi-http = ["component-model", "dep:wasmtime-wasi-http", "dep:tokio", "dep:hyper"]
+wasi-runtime-config = ["dep:wasmtime-wasi-runtime-config"]
+wasi-keyvalue = ["dep:wasmtime-wasi-keyvalue"]
 pooling-allocator = ["wasmtime/pooling-allocator", "wasmtime-cli-flags/pooling-allocator"]
-all-arch = ["wasmtime/all-arch"]
 component-model = [
   "wasmtime/component-model",
-  "wasmtime-wast/component-model",
+  "wasmtime-wast?/component-model",
   "wasmtime-cli-flags/component-model"
 ]
-winch = ["wasmtime/winch"]
-wmemcheck = ["wasmtime/wmemcheck"]
+wat = ["dep:wat", "wasmtime/wat"]
+cache = ["dep:wasmtime-cache", "wasmtime-cli-flags/cache"]
+parallel-compilation = ["wasmtime-cli-flags/parallel-compilation"]
+logging = ["wasmtime-cli-flags/logging"]
+demangle = ["wasmtime/demangle"]
+cranelift = ["wasmtime-cli-flags/cranelift", "dep:wasmtime-cranelift"]
+profiling = ["wasmtime/profiling", "wasmtime/call-hook"]
+coredump = ["wasmtime-cli-flags/coredump"]
+addr2line = ["wasmtime/addr2line"]
+debug-builtins = ["wasmtime/debug-builtins"]
+threads = ["wasmtime-cli-flags/threads"]
+gc = ["wasmtime-cli-flags/gc"]
 
-# Enable the `wasmtime serve` command
-serve = ["wasi-http", "component-model"]
+# CLI subcommands for the `wasmtime` executable. See `wasmtime $cmd --help`
+# for more information on each subcommand.
+serve = ["wasi-http", "component-model", "dep:http-body-util", "dep:http"]
+explore = ["dep:wasmtime-explorer", "dep:tempfile"]
+wast = ["dep:wasmtime-wast"]
+config = ["cache"]
+compile = ["cranelift"]
+run = ["dep:wasmtime-wasi", "wasmtime/runtime", "dep:listenfd", "dep:wasi-common", "dep:tokio"]
 
 [[test]]
 name = "host_segfault"
 harness = false
 
+[[test]]
+name = "disas"
+harness = false
+
+[[test]]
+name = "wast"
+harness = false
+
 [[example]]
 name = "tokio"
-required-features = ["wasmtime-wasi/tokio"]
+required-features = ["wasi-common/tokio"]
 
 [[bench]]
 name = "instantiation"
@@ -351,3 +506,8 @@ incremental = false
 debug-assertions = false
 overflow-checks = false
 opt-level = 's'
+
+[profile.fastest-runtime]
+inherits = "release"
+codegen-units = 1
+lto = true
diff --git a/README.md b/README.md
index 3b52b9d9a0af..add5f9622e5f 100644
--- a/README.md
+++ b/README.md
@@ -54,8 +54,8 @@ fn main() {
 and compile/run it with:
 
 ```sh
-$ rustup target add wasm32-wasi
-$ rustc hello.rs --target wasm32-wasi
+$ rustup target add wasm32-wasip1
+$ rustc hello.rs --target wasm32-wasip1
 $ wasmtime hello.wasm
 Hello, world!
 ```
@@ -108,7 +108,7 @@ command may not install the target for the correct copy of Rust.)
 [Secure]: https://docs.wasmtime.dev/security.html
 [Configurable]: https://docs.rs/wasmtime/latest/wasmtime/struct.Config.html
 [WASI]: https://docs.rs/wasmtime-wasi/latest/wasmtime_wasi/
-[Standards Compliant]: https://docs.wasmtime.dev/stability-wasm-proposals-support.html
+[Standards Compliant]: https://docs.wasmtime.dev/stability-tiers.html
 
 ## Language Support
 
@@ -131,7 +131,7 @@ Languages supported by the community:
 * **Perl** - the [`Wasm` Perl package's `Wasm::Wasmtime`]
 
 [Rust]: https://bytecodealliance.github.io/wasmtime/lang-rust.html
-[C]: https://bytecodealliance.github.io/wasmtime/examples-c-embed.html
+[C]: https://bytecodealliance.github.io/wasmtime/lang-c.html
 [`wasmtime` crate]: https://crates.io/crates/wasmtime
 [c-headers]: https://bytecodealliance.github.io/wasmtime/c-api/
 [Python]: https://bytecodealliance.github.io/wasmtime/lang-python.html
diff --git a/RELEASES.md b/RELEASES.md
index cc89c3f2231c..b8b5e96fe415 100644
--- a/RELEASES.md
+++ b/RELEASES.md
@@ -1,3045 +1,47 @@
---------------------------------------------------------------------------------
-
-## 14.0.0
+## 25.0.0
 
 Unreleased.
 
 ### Added
 
-* Added the `wasmtime::FrameInfo::module` method, which returns the
-  `wasmtime::Module` associated with the stack frame.
-
-### Changed
-
-* The `wasmtime::FrameInfo::module_name` has been removed, however you can now
-  get identical results by chaining `wasmtime::FrameInfo::module` and
-  `wasmtime::Module::name`: `my_frame.module().name()`.
-
---------------------------------------------------------------------------------
-
-## 13.0.0
-
-Released 2023-09-20
-
-### Added
-
-* Configuration of mach ports vs signals on macOS is now done through a `Config`
-  instead of at compile time.
-  [#6807](https://github.com/bytecodealliance/wasmtime/pull/6807)
-
-* `Engine::detect_precompiled{,_file}` can be used to to determine whether some
-  bytes or a file look like a precompiled module or a component.
-  [#6832](https://github.com/bytecodealliance/wasmtime/pull/6832)
-  [#6937](https://github.com/bytecodealliance/wasmtime/pull/6937)
-
-* A new feature "wmemcheck" has been added to enable Valgrind-like detection of
-  use-after-free within a WebAssembly guest module.
-  [#6820](https://github.com/bytecodealliance/wasmtime/pull/6820)
-  [#6856](https://github.com/bytecodealliance/wasmtime/pull/6856)
-
-* The `wasmtime` CLI now supports executing components.
-  [#6836](https://github.com/bytecodealliance/wasmtime/pull/6836)
-
-* Support for WASI preview2's TCP sockets interface has been added.
-  [#6837](https://github.com/bytecodealliance/wasmtime/pull/6837)
-
-* Wasmtime's implementation of the wasi-nn proposal now supports named models.
-  [#6854](https://github.com/bytecodealliance/wasmtime/pull/6854)
-
-* The C API now supports configuring `native_unwind_info`,
-  `dynamic_memory_reserved_for_growth`, `target`, and Cranelift settings.
-  [#6896](https://github.com/bytecodealliance/wasmtime/pull/6896)
-  [#6934](https://github.com/bytecodealliance/wasmtime/pull/6934)
-
-* The `wasmtime` crate now has initial support for component model bindings
-  generation for the WIT `resource` type.
-  [#6886](https://github.com/bytecodealliance/wasmtime/pull/6886)
-
-* Cranelift's RISC-V backend now has a complete implementation of the
-  WebAssembly SIMD proposal. Many thanks to Afonso Bordado for all their
-  contributions!
-  [#6920](https://github.com/bytecodealliance/wasmtime/pull/6920)
-  [#6924](https://github.com/bytecodealliance/wasmtime/pull/6924)
-
-* The `bindgen!` macro in the `wasmtime` crate now supports conditional
-  configuration for which imports should be `async` and which should be
-  synchronous.
-  [#6942](https://github.com/bytecodealliance/wasmtime/pull/6942)
-
-### Changed
-
-* The pooling allocator was significantly refactored and the
-  `PoolingAllocationConfig` has some minor breaking API changes that reflect
-  those changes.
-
-  Previously, the pooling allocator had `count` slots, and each slot had `N`
-  memories and `M` tables. Every allocated instance would reserve those `N`
-  memories and `M` tables regardless whether it actually needed them all or
-  not. This could lead to some waste and over-allocation when a module used less
-  memories and tables than the pooling allocator's configured maximums.
-
-  After the refactors in this release, the pooling allocator doesn't have
-  one-size-fits-all slots anymore. Instead, memories and tables are in separate
-  pools that can be allocated from independently, and we allocate exactly as
-  many memories and tables as are necessary for the instance being allocated.
-
-  To preserve your old configuration with the new methods you can do the following:
-
-  ```rust
-  let mut config = PoolingAllocationConfig::default();
-
-  // If you used to have this old, no-longer-compiling configuration:
-  config.count(count);
-  config.instance_memories(n);
-  config.instance_tables(m);
-
-  // You can use these equivalent settings for the new config methods:
-  config.total_core_instances(count);
-  config.total_stacks(count); // If using the `async` feature.
-  config.total_memories(count * n);
-  config.max_memories_per_module(n);
-  config.total_tables(count * m);
-  config.max_tables_per_module(m);
-  ```
-
-  There are additionally a variety of methods to limit the maximum amount of
-  resources a single core Wasm or component instance can take from the pool:
-
-  * `PoolingAllocationConfig::max_memories_per_module`
-  * `PoolingAllocationConfig::max_tables_per_module`
-  * `PoolingAllocationConfig::max_memories_per_component`
-  * `PoolingAllocationConfig::max_tables_per_component`
-  * `PoolingAllocationConfig::max_core_instances_per_component`
-
-  These methods do not affect the size of the pre-allocated pool.
-  [#6835](https://github.com/bytecodealliance/wasmtime/pull/6835)
-
-* Builder methods for WASI contexts now use `&mut self` instead of `self`.
-  [#6770](https://github.com/bytecodealliance/wasmtime/pull/6770)
-
-* Native unwinding information is now properly disabled when it is configured to
-  be turned off.
-  [#6547](https://github.com/bytecodealliance/wasmtime/pull/6547)
-
-* Wasmtime's minimum supported Rust version (MSRV) is now 1.70.0. Wasmtime's
-  MSRV policy of supporting the last three releases of Rust (N-2) is now
-  additionally documented. More discussion can additionally be found on the PR
-  itself.
-  [#6900](https://github.com/bytecodealliance/wasmtime/pull/6900)
-
-* Wasmtime's support for DWARF debugging information has seen some fixes for
-  previously reported crashes.
-  [#6931](https://github.com/bytecodealliance/wasmtime/pull/6931)
-
-### Removed
-
-* Wasmtime's experimental implementation of wasi-crypto has been removed. More
-  discussion of this change can be found on
-  [#6732](https://github.com/bytecodealliance/wasmtime/pull/6732)
-  and
-  [#6816](https://github.com/bytecodealliance/wasmtime/pull/6816)
-
-* Support for `union` types in the component model has been removed.
-  [#6913](https://github.com/bytecodealliance/wasmtime/pull/6913)
-
---------------------------------------------------------------------------------
-
-## 12.0.2
-
-Released 2023-09-14.
-
-### Fixed
-
-* [CVE-2023-41880] - Miscompilation of wasm `i64x2.shr_s` instruction with
-  constant input on x86\_64
-
-[CVE-2023-41880]: https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-gw5p-q8mj-p7gh
-
---------------------------------------------------------------------------------
-
-## 12.0.1
-
-Released 2023-08-24
-
-### Fixed
-
-* Optimized the cranelift compilation on aarch64 for large wasm modules.
-  [#6804](https://github.com/bytecodealliance/wasmtime/pull/6804)
-
---------------------------------------------------------------------------------
-
-## 12.0.0
-
-Released 2023-08-21
-
-### Added
-
-* Wasmtime now supports having multiple different versions of itself being
-  linked into the same final executable by mangling some C symbols used by
-  Wasmtime.
-  [#6673](https://github.com/bytecodealliance/wasmtime/pull/6673)
-
-* The `perfmap` profiling option is now supported on any Unix platform instead
-  of just Linux.
-  [#6701](https://github.com/bytecodealliance/wasmtime/pull/6701)
-
-* The `wasmtime` CLI now supports `--env FOO` to inherit the value of the
-  environment variable `FOO` which avoids needing to do `--env FOO=$FOO` for
-  example.
-  [#6746](https://github.com/bytecodealliance/wasmtime/pull/6746)
-
-* Wasmtime now supports component model resources, although support has not yet
-  been added to `bindgen!`.
-  [#6691](https://github.com/bytecodealliance/wasmtime/pull/6691)
-
-* Wasmtime now supports configuration to enable the tail calls proposal.
-  Platform support now also includes AArch64 and RISC-V in addition to the
-  previous x86\_64 support.
-  [#6723](https://github.com/bytecodealliance/wasmtime/pull/6723)
-  [#6749](https://github.com/bytecodealliance/wasmtime/pull/6749)
-  [#6774](https://github.com/bytecodealliance/wasmtime/pull/6774)
-
-* Wasmtime's implementation of WASI Preview 2 now supports streams/pollables
-  with host objects that are all backed by Rust `async`.
-  [#6556](https://github.com/bytecodealliance/wasmtime/pull/6556)
-
-* Support for core dumps has now been added to the `wasmtime` crate.
-  [#6513](https://github.com/bytecodealliance/wasmtime/pull/6513)
-
-* New `{Module,Component}::resources_required` APIs allow inspecting what will
-  be required when instantiating the module or component.
-  [#6789](https://github.com/bytecodealliance/wasmtime/pull/6789)
-
-### Fixed
-
-* Functions on instances defined through `component::Linker::func_new` are now
-  defined correctly.
-  [#6637](https://github.com/bytecodealliance/wasmtime/pull/6637)
-
-* The `async_stack_size` configuration option is no longer inspected when
-  `async_support` is disabled at runtime.
-  [#6771](https://github.com/bytecodealliance/wasmtime/pull/6771)
-
-* WASI Preview 1 APIs will now trap on misaligned or out-of-bounds pointers
-  instead of returning an error.
-  [#6776](https://github.com/bytecodealliance/wasmtime/pull/6776)
-
-### Changed
-
-* Empty types are no longer allowed in the component model.
-  [#6777](https://github.com/bytecodealliance/wasmtime/pull/6777)
-
---------------------------------------------------------------------------------
-
-## 11.0.2
-
-Released 2023-09-14.
-
-### Fixed
-
-* [CVE-2023-41880] - Miscompilation of wasm `i64x2.shr_s` instruction with
-  constant input on x86\_64
-
-[CVE-2023-41880]: https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-gw5p-q8mj-p7gh
-
---------------------------------------------------------------------------------
-
-## 11.0.1
-
-Released 2023-07-24.
-
-### Fixed
-
-* Update some minimum version requirements for Wasmtime's dependencies to fix
-  building Wasmtime with historical versions of these dependencies.
-  [#6758](https://github.com/bytecodealliance/wasmtime/pull/6758)
-
---------------------------------------------------------------------------------
-
-## 11.0.0
-
-Released 2023-07-20
-
-### Changed
-
-* The WASI Preview 2 `WasiCtxBuilder` type has been refactored, and `WasiCtx` now has private
-  fields.
-  [#6652](https://github.com/bytecodealliance/wasmtime/pull/6652)
-
-* Component `bindgen!` now generates owned types by default instead of based on
-  how they're used
-  [#6648](https://github.com/bytecodealliance/wasmtime/pull/6648)
-
-* Wasmtime/Cranelift on x86-64 can now execute Wasm-SIMD on baseline SSE2, which
-  all x86-64 processors support (as part of the base x86-64 spec). Previously,
-  SSE4.2 extensions were required. This new work allows Wasm with SIMD
-  extensions to execute on processors produced back to 2003.
-  [#6625](https://github.com/bytecodealliance/wasmtime/pull/6625)
-
-
-### Fixed
-
-* Only export the top-level preview2 module from wasmtime-wasi when the
-  `preview2` feature is enabled.
-  [#6615](https://github.com/bytecodealliance/wasmtime/pull/6615)
-
-
-### Cranelift changes
-
-* Tail call implementation has begun in Cranelift
-  [#6641](https://github.com/bytecodealliance/wasmtime/pull/6641)
-  [#6666](https://github.com/bytecodealliance/wasmtime/pull/6666)
-  [#6650](https://github.com/bytecodealliance/wasmtime/pull/6650)
-  [#6635](https://github.com/bytecodealliance/wasmtime/pull/6635)
-  [#6608](https://github.com/bytecodealliance/wasmtime/pull/6608)
-  [#6586](https://github.com/bytecodealliance/wasmtime/pull/6586)
-
-* Work continues on SIMD support for the riscv64 backend
-  [#6657](https://github.com/bytecodealliance/wasmtime/pull/6657)
-  [#6643](https://github.com/bytecodealliance/wasmtime/pull/6643)
-  [#6601](https://github.com/bytecodealliance/wasmtime/pull/6601)
-  [#6609](https://github.com/bytecodealliance/wasmtime/pull/6609)
-  [#6602](https://github.com/bytecodealliance/wasmtime/pull/6602)
-  [#6598](https://github.com/bytecodealliance/wasmtime/pull/6598)
-  [#6599](https://github.com/bytecodealliance/wasmtime/pull/6599)
-  [#6587](https://github.com/bytecodealliance/wasmtime/pull/6587)
-  [#6568](https://github.com/bytecodealliance/wasmtime/pull/6568)
-  [#6515](https://github.com/bytecodealliance/wasmtime/pull/6515)
-
-* Fix `AuthenticatedRet` when stack bytes are popped in the aarch64 backend
-  [#6634](https://github.com/bytecodealliance/wasmtime/pull/6634)
-
-* The `fcvt_low_from_sint` instruction has been removed, as it its current
-  behavior can be recovered through a combination of `swiden_low` and
-  `fcvt_from_sint`
-  [#6565](https://github.com/bytecodealliance/wasmtime/pull/6565)
-
---------------------------------------------------------------------------------
-
-## 10.0.2
-
-Released 2023-09-14.
-
-### Fixed
-
-* [CVE-2023-41880] - Miscompilation of wasm `i64x2.shr_s` instruction with
-  constant input on x86\_64
-
-[CVE-2023-41880]: https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-gw5p-q8mj-p7gh
-
---------------------------------------------------------------------------------
-
-## 10.0.1
-
-Released 2023-06-21
-
-### Fixed
-
-* Only export the top-level preview2 module from wasmtime-wasi when the
-  `preview2` feature is enabled.
-  [#6615](https://github.com/bytecodealliance/wasmtime/pull/6615)
-
---------------------------------------------------------------------------------
-
-## 10.0.0
-
-Released 2023-06-20
-
-### Added
-
-* Expose the `Config::static_memory_forced` option through the C api
-  [#6413](https://github.com/bytecodealliance/wasmtime/pull/6413)
-
-* Basic guest-profiler documentation for the book
-  [#6394](https://github.com/bytecodealliance/wasmtime/pull/6394)
-
-* Merge the initial wasi-preview2 implementation
-  [#6391](https://github.com/bytecodealliance/wasmtime/pull/6391)
-
-* The wasi-preview2 component adapter has been pulled into the main wasmtime
-  repository. It is available for the first time as part of this release, but should be
-  treated as as a beta at this time. Patch releases will not be made for bug fixes.
-  [#6374](https://github.com/bytecodealliance/wasmtime/pull/6374)
-
-* A callback invoked when an epoch deadline is reached can now be configured via
-  the C API.
-  [#6359](https://github.com/bytecodealliance/wasmtime/pull/6359)
-
-* PR auto-assignment policies have been documented, to clarify the expectations of
-  reviewers.
-  [#6346](https://github.com/bytecodealliance/wasmtime/pull/6346)
-
-* Support for the function references has been added
-  [#5288](https://github.com/bytecodealliance/wasmtime/pull/5288)
-
-### Changed
-
-* An `epoch_deadline_callback` now returns an `UpdateDeadline` enum to allow
-  optionally yielding to the async executor after the callback runs.
-  [#6464](https://github.com/bytecodealliance/wasmtime/pull/6464)
-
-* The `--profile-guest` flag has now been folded into `--profile=guest`
-  [#6352](https://github.com/bytecodealliance/wasmtime/pull/6352)
-
-* Initializers are no longer tracked in the type information for globals, and
-  instead are provided when creating the global.
-  [#6349](https://github.com/bytecodealliance/wasmtime/pull/6349)
-
-* The "raw" representation of `funcref` and `externref` in the embedding API has
-  been updated from a `usize` to a `*mut u8` to be compatible with Rust's
-  proposed strict provenance rules. This change is additionally reflected into
-  the C API as well.
-  [#6338](https://github.com/bytecodealliance/wasmtime/pull/6338)
-
-### Fixed
-
-* Fixed a soundness issue with the component model and async
-  [#6509](https://github.com/bytecodealliance/wasmtime/pull/6509)
-
-* Opening directories with WASI on Windows with `NONBLOCK` in flags has been
-  fixed.
-  [#6348](https://github.com/bytecodealliance/wasmtime/pull/6348)
-
-### Cranelift changes
-
-* Performance improvements in regalloc2 have landed, and compilation time has
-  improved
-  [#6483](https://github.com/bytecodealliance/wasmtime/pull/6483)
-  [#6398](https://github.com/bytecodealliance/wasmtime/pull/6398)
-
-* Renamed `abi::Caller` to `abi::CallSite`
-  [#6414](https://github.com/bytecodealliance/wasmtime/pull/6414)
-
-* Work has begun on SIMD support for the riscv64 backend
-  [#6324](https://github.com/bytecodealliance/wasmtime/pull/6324)
-  [#6366](https://github.com/bytecodealliance/wasmtime/pull/6366)
-  [#6367](https://github.com/bytecodealliance/wasmtime/pull/6367)
-  [#6392](https://github.com/bytecodealliance/wasmtime/pull/6392)
-  [#6397](https://github.com/bytecodealliance/wasmtime/pull/6397)
-  [#6403](https://github.com/bytecodealliance/wasmtime/pull/6403)
-  [#6408](https://github.com/bytecodealliance/wasmtime/pull/6408)
-  [#6419](https://github.com/bytecodealliance/wasmtime/pull/6419)
-  [#6430](https://github.com/bytecodealliance/wasmtime/pull/6430)
-  [#6507](https://github.com/bytecodealliance/wasmtime/pull/6507)
-
---------------------------------------------------------------------------------
-
-## 9.0.3
-
-Released 2023-05-31.
-
-### Fixed
-
-* Fix Wasi rights system to work with wasi-testsuite, which exposed a corner case
-  that was missed by the fixes in the 9.0.2 release.
-  [#6479](https://github.com/bytecodealliance/wasmtime/pull/6479)
-
---------------------------------------------------------------------------------
-
-## 9.0.2
-
-Released 2023-05-26.
-
-### Fixed
-
-* Fix Wasi rights system to work with wasi-libc. This regression was
-  introduced in the 9.0.0 release.
-  [#6462](https://github.com/bytecodealliance/wasmtime/pull/6462)
-  [#6471](https://github.com/bytecodealliance/wasmtime/pull/6471)
-
---------------------------------------------------------------------------------
-
-## 9.0.1
-
-Released 2023-05-22.
-
-### Fixed
-
-* A panic which happened when enabling support for native platform profilers was
-  fixed.
-  [#6435](https://github.com/bytecodealliance/wasmtime/pull/6435)
-
---------------------------------------------------------------------------------
-
-## 9.0.0
-
-Released 2023-05-22.
-
-### Added
-
-* Initial integration of the Winch baseline compiler into Wasmtime is
-  implemented. Note that Winch still does not support much of WebAssembly, but
-  intrepid explorers may have an easier time playing around with it now.
-  [#6119](https://github.com/bytecodealliance/wasmtime/pull/6119)
-
-* The `wasmtime` CLI now has flags to limit memory, instances, and tables. For
-  example `--max-memory-size` or `--max-tables`. Additionally it has a new
-  `--trap-on-grow-failure` option to force a trap whenever a `memory.grow` would
-  otherwise fail which can be useful for debugging modules which may be
-  encountering OOM.
-  [#6149](https://github.com/bytecodealliance/wasmtime/pull/6149)
-
-* An initial implementation of the wasi-http proposal was added to Wasmtime in
-  the shape of a new `wasmtime-wasi-http` crate and a
-  `--wasi-modules=experimental-wasi-http` CLI flag.  Note that this is not
-  on-by-default and still in an experimental status at this time.
-  [#5929](https://github.com/bytecodealliance/wasmtime/pull/5929)
-
-* Wasmtime's `bindgen!` macro for components now has `interfaces` and
-  `with` options to configure use of interfaces defined externally in separate
-  crates.
-  [#6160](https://github.com/bytecodealliance/wasmtime/pull/6160)
-  [#6210](https://github.com/bytecodealliance/wasmtime/pull/6210)
-
-* Wasmtime's `bindgen!` macro emits trace events for arguments and results
-  when enabled.
-  [#6209](https://github.com/bytecodealliance/wasmtime/pull/6209)
-
-* A new `Engine::precompile_compatibility_hash` method has been added to assist
-  with hashing artifacts to be compatible with versions of Wasmtime.
-  [#5826](https://github.com/bytecodealliance/wasmtime/pull/5826)
-
-* Wasmtime's C API now has functions for enabling the WebAssembly relaxed-simd
-  proposal.
-  [#6292](https://github.com/bytecodealliance/wasmtime/pull/6292)
-
-* A new `--emit-clif` flag has been added to `wasmtime compile` to see the CLIF
-  corresponding to a WebAssembly module to be used for debugging.
-  [#6307](https://github.com/bytecodealliance/wasmtime/pull/6307)
-
-* Support for an in-process sampling-based profiler has been added to Wasmtime.
-  This is intended to be used in conjunction with epochs to enable relatively
-  simple implementations of profiling a guest module.
-  [#6282](https://github.com/bytecodealliance/wasmtime/pull/6282)
-
-### Changed
-
-* Overhauled the way that Wasmtime calls into Wasm and Wasm calls back out to
-  the host. Instead of chaining together trampolines to convert between calling
-  conventions, we now represent `funcref`s with multiple function pointers, one
-  per calling convention. This paves the way for supporting Wasm tail calls and
-  also results in ~10% speed ups to a variety of function call benchmarks,
-  however there are some slight compiled Wasm module code size regressions
-  (which can be alleviated by disabling optional `.eh_frame`
-  generation). Additionally, in the C API the `wasmtime_func_call_unchecked`
-  function gained one more parameter, which is the capacity of the
-  args-and-results
-  buffer.
-  [#6262](https://github.com/bytecodealliance/wasmtime/pull/6262)
-
-* The `wasmtime compile` command will now default to producing executables for
-  the native host and its CPU features instead of the baseline feature set of
-  the host's architecture.
-  [#6152](https://github.com/bytecodealliance/wasmtime/pull/6152)
-
-* The `ResourceLimiter` trait and its `async` equivalent now support returning
-  errors from growth to force a trap in the wasm module rather than reporting
-  -1 to the wasm module. Note that this is primarily intended for debugging.
-  [#6149](https://github.com/bytecodealliance/wasmtime/pull/6149)
-
-* The non-egraph-based optimization pipeline has been removed from Cranelift,
-  and the corresponding `Config::use_egraphs` option is also removed.
-  [#6167](https://github.com/bytecodealliance/wasmtime/pull/6167)
-
-* Generated types for WIT files now always generates owned types by default.
-  [#6189](https://github.com/bytecodealliance/wasmtime/pull/6189)
-
-* Wasmtime's baseline x86\_64 CPU features required for SIMD support has been
-  lowered from SSE 4.2 to SSE 4.1.
-  [#6206](https://github.com/bytecodealliance/wasmtime/pull/6206)
-
-* The `fd_allocate` implementation in Wasmtime will now always fail with
-  `ENOTSUP`.
-  [#6217](https://github.com/bytecodealliance/wasmtime/pull/6217)
-
-* The "rights" system in WASI has been removed and rights are no longer
-  inspected in the implementation of any WASI functions.
-  [#6265](https://github.com/bytecodealliance/wasmtime/pull/6265)
-
-### Fixed
-
-* WASI can now open directories without `O_DIRECTORY`.
-  [#6163](https://github.com/bytecodealliance/wasmtime/pull/6163)
-
-* The `poll_oneoff` function has been fixed when handling non-regular files.
-  [#6258](https://github.com/bytecodealliance/wasmtime/pull/6258)
-
-* The behavior of `path_readlink` on too-small buffers has been fixed to
-  truncate.
-  [#6225](https://github.com/bytecodealliance/wasmtime/pull/6225)
-
-### Cranelift changes
-
-> Note: this section documents changes to Cranelift, a code generator backend
-> that Wasmtime uses. These changes are not always applicable to Wasmtime as a
-> WebAssembly runtime but may be interesting to other projects which embed or
-> use Cranelift.
-
-* New `{u,s}{add,sub,mul}_overflow` instructions have been added.
-  [#5784](https://github.com/bytecodealliance/wasmtime/pull/5784)
-
-* The `iadd_cout` and `isub_bout` instructions have been removed.
-  [#6198](https://github.com/bytecodealliance/wasmtime/pull/6198)
-
-* ISLE now supports binary and octal integer literals.
-  [#6234](https://github.com/bytecodealliance/wasmtime/pull/6234)
-
-* An implementation of SIMD for RISC-V has started.
-  [#6240](https://github.com/bytecodealliance/wasmtime/pull/6240)
-  [#6266](https://github.com/bytecodealliance/wasmtime/pull/6266)
-  [#6268](https://github.com/bytecodealliance/wasmtime/pull/6268)
-
---------------------------------------------------------------------------------
-
-## 8.0.1
-
-Released 2023-04-27.
-
-### Changed
-
-* Breaking: Files opened using Wasmtime's implementation of WASI on Windows now
-  cannot be deleted until the file handle is closed. This was already true for
-  open directories. The change was necessary for the bug fix in
-  [#6163](https://github.com/bytecodealliance/wasmtime/pull/6163).
-
-### Fixed
-
-* Fixed wasi-common's implementation of the `O_DIRECTORY` flag to match POSIX.
-  [#6163](https://github.com/bytecodealliance/wasmtime/pull/6163)
-
-* Undefined Behavior in Rust runtime functions
-  [GHSA-ch89-5g45-qwc7](https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-ch89-5g45-qwc7)
-
---------------------------------------------------------------------------------
-
-## 8.0.0
-
-Released 2023-04-20
-
-### Added
-
-* Allow the MPL-2.0 and OpenSSL licenses in dependencies of wasmtime.
-  [#6136](https://github.com/bytecodealliance/wasmtime/pull/6136)
-
-* Add a bounds-checking optimization for dynamic memories and guard pages.
-  [#6031](https://github.com/bytecodealliance/wasmtime/pull/6031)
-
-* Add support for generating perf maps for simple perf profiling. Additionally,
-  the `--jitdump` and `--vtune` flags have been replaced with a single
-  `--profile` flags that accepts `perfmap`, `jitdump`, and `vtune` arguments.
-  [#6030](https://github.com/bytecodealliance/wasmtime/pull/6030)
-
-* Validate faulting addresses are valid to fault on. As a mitigation to CVEs
-  like `GHSA-ff4p-7xrq-q5r8`, check that the address involved in a fault is one
-  that could be contained in a `Store`, or print a scary message and abort
-  immediately.
-  [#6028](https://github.com/bytecodealliance/wasmtime/pull/6028)
-
-* Add the `--default-values-unknown-imports` option to define unknown function
-  imports as functions that return the default value for their result type.
-  [#6010](https://github.com/bytecodealliance/wasmtime/pull/6010)
-
-* Add `Clone` for `component::InstancePre`.
-  [#5996](https://github.com/bytecodealliance/wasmtime/issues/5996)
-
-* Add `--dynamic-memory-reserved-for-growth` cli flag.
-  [#5980](https://github.com/bytecodealliance/wasmtime/issues/5980)
-
-* Introduce the `wasmtime-explorer` crate for investigating the compilation of
-  wasm modules. This functionality is also exposed via the `wasmtime explore`
-  command.
-  [#5975](https://github.com/bytecodealliance/wasmtime/pull/5975)
-
-* Added support for the Relaxed SIMD proposal.
-  [#5892](https://github.com/bytecodealliance/wasmtime/pull/5892)
-
-* Cranelift gained many new machine-independent optimizations.
-  [#5909](https://github.com/bytecodealliance/wasmtime/pull/5909)
-  [#6032](https://github.com/bytecodealliance/wasmtime/pull/6032)
-  [#6033](https://github.com/bytecodealliance/wasmtime/pull/6033)
-  [#6034](https://github.com/bytecodealliance/wasmtime/pull/6034)
-  [#6037](https://github.com/bytecodealliance/wasmtime/pull/6037)
-  [#6052](https://github.com/bytecodealliance/wasmtime/pull/6052)
-  [#6053](https://github.com/bytecodealliance/wasmtime/pull/6053)
-  [#6072](https://github.com/bytecodealliance/wasmtime/pull/6072)
-  [#6095](https://github.com/bytecodealliance/wasmtime/pull/6095)
-  [#6130](https://github.com/bytecodealliance/wasmtime/pull/6130)
-
 ### Changed
 
-* Derive `Copy` on `wasmtime::ValType`.
-  [#6138](https://github.com/bytecodealliance/wasmtime/pull/6138)
-
-* Make `StoreContextMut` accessible in the epoch deadline callback.
-  [#6075](https://github.com/bytecodealliance/wasmtime/pull/6075)
-
-* Take SIGFPE signals for divide traps on `x86_64`.
-  [#6026](https://github.com/bytecodealliance/wasmtime/pull/6026)
-
-* Use more specialized AVX instructions in the `x86_64` backend.
-  [#5924](https://github.com/bytecodealliance/wasmtime/pull/5924)
-  [#5930](https://github.com/bytecodealliance/wasmtime/pull/5930)
-  [#5931](https://github.com/bytecodealliance/wasmtime/pull/5931)
-  [#5982](https://github.com/bytecodealliance/wasmtime/pull/5982)
-  [#5986](https://github.com/bytecodealliance/wasmtime/pull/5986)
-  [#5999](https://github.com/bytecodealliance/wasmtime/pull/5999)
-  [#6023](https://github.com/bytecodealliance/wasmtime/pull/6023)
-  [#6025](https://github.com/bytecodealliance/wasmtime/pull/6025)
-  [#6060](https://github.com/bytecodealliance/wasmtime/pull/6060)
-  [#6086](https://github.com/bytecodealliance/wasmtime/pull/6086)
-  [#6092](https://github.com/bytecodealliance/wasmtime/pull/6092)
-
-* Generate more cache-friendly code for traps.
-  [#6011](https://github.com/bytecodealliance/wasmtime/pull/6011)
-
-### Fixed
-
-* Fixed suboptimal code generation in the `aarch64` backend.
-  [#5976](https://github.com/bytecodealliance/wasmtime/pull/5976)
-  [#5977](https://github.com/bytecodealliance/wasmtime/pull/5977)
-  [#5987](https://github.com/bytecodealliance/wasmtime/pull/5987)
-  [#5997](https://github.com/bytecodealliance/wasmtime/pull/5997)
-  [#6078](https://github.com/bytecodealliance/wasmtime/pull/6078)
-
-* Fixed suboptimal code generation in the `riscv64` backend.
-  [#5854](https://github.com/bytecodealliance/wasmtime/pull/5854)
-  [#5857](https://github.com/bytecodealliance/wasmtime/pull/5857)
-  [#5919](https://github.com/bytecodealliance/wasmtime/pull/5919)
-  [#5951](https://github.com/bytecodealliance/wasmtime/pull/5951)
-  [#5964](https://github.com/bytecodealliance/wasmtime/pull/5964)
-  [#6087](https://github.com/bytecodealliance/wasmtime/pull/6087)
-
-
---------------------------------------------------------------------------------
-
-## 7.0.1
-
-Released 2023-04-27.
-
-### Fixed
-
-* Undefined Behavior in Rust runtime functions
-  [GHSA-ch89-5g45-qwc7](https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-ch89-5g45-qwc7)
-
 --------------------------------------------------------------------------------
 
-## 7.0.0
-
-Released 2023-03-20
-
-### Added
-
-* An initial implementation of the wasi-threads proposal has been implemented
-  and landed in the Wasmtime CLI. This is available behind a
-  `--wasi-modules experimental-wasi-threads` flag.
-  [#5484](https://github.com/bytecodealliance/wasmtime/pull/5484)
-
-* Support for WASI sockets has been added to the C API.
-  [#5624](https://github.com/bytecodealliance/wasmtime/pull/5624)
-
-* Support for limiting `Store`-based resource usage, such as memory, tables,
-  etc, has been added to the C API.
-  [#5761](https://github.com/bytecodealliance/wasmtime/pull/5761)
-
-* A top level alias of `anyhow::Result` as `wasmtime::Result` has been added to
-  avoid the need to explicitly depend on `anyhow`.
-  [#5853](https://github.com/bytecodealliance/wasmtime/pull/5853)
-
-* Initial support for the WebAssembly core dump format has been added to the CLI
-  with a `--coredump-on-trap` flag.
-  [#5868](https://github.com/bytecodealliance/wasmtime/pull/5868)
-
-### Changed
-
-* The `S` type parameter on component-related methods has been removed.
-  [#5722](https://github.com/bytecodealliance/wasmtime/pull/5722)
-
-* Selection of a `world` to bindgen has been updated to select any `default
-  world` in a WIT package if there is only one.
-  [#5779](https://github.com/bytecodealliance/wasmtime/pull/5779)
-
-* WASI preopened file descriptors can now be closed.
-  [#5828](https://github.com/bytecodealliance/wasmtime/pull/5828)
-
-* The host traits generated by the `bindgen!` macro are now always named `Host`,
-  but are still scoped to each individual module.
-  [#5890](https://github.com/bytecodealliance/wasmtime/pull/5890)
-
-### Fixed
-
-* Components which have `type` imports are now supported better and error/panic
-  in fewer cases.
-  [#5777](https://github.com/bytecodealliance/wasmtime/pull/5777)
-
-* Types referred to by `wasmtime::component::Val` are now reexported under
-  `wasmtime::component`.
-  [#5790](https://github.com/bytecodealliance/wasmtime/pull/5790)
-
-* A panic due to a race between `memory.atomic.{wait32,wait64,notify}`
-  instructions has been fixed.
-  [#5871](https://github.com/bytecodealliance/wasmtime/pull/5871)
-
-* Guest-controlled out-of-bounds read/write on x86\_64
-  [GHSA-ff4p-7xrq-q5r8](https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-ff4p-7xrq-q5r8)
-
-*  Miscompilation of `i8x16.select` with the same inputs on x86\_64
-  [GHSA-xm67-587q-r2vw](https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-xm67-587q-r2vw)
-
---------------------------------------------------------------------------------
-
-## 6.0.2
-
-Released 2023-04-27.
-
-### Fixed
-
-* Undefined Behavior in Rust runtime functions
-  [GHSA-ch89-5g45-qwc7](https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-ch89-5g45-qwc7)
-
---------------------------------------------------------------------------------
-
-## 6.0.1
-
-Released 2023-03-08.
-
-### Fixed
-
-* Guest-controlled out-of-bounds read/write on x86\_64
-  [GHSA-ff4p-7xrq-q5r8](https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-ff4p-7xrq-q5r8)
-
-*  Miscompilation of `i8x16.select` with the same inputs on x86\_64
-  [GHSA-xm67-587q-r2vw](https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-xm67-587q-r2vw)
-
---------------------------------------------------------------------------------
-
-## 6.0.0
-
-Released 2023-02-20
-
-### Added
-
-* Wasmtime's built-in cache can now be disabled after being enabled previously.
-  [#5542](https://github.com/bytecodealliance/wasmtime/pull/5542)
-
-* Older x86\_64 CPUs, without SSE4.1 for example, are now supported when the
-  wasm SIMD proposal is disabled.
-  [#5567](https://github.com/bytecodealliance/wasmtime/pull/5567)
-
-* The Wasmtime C API now has `WASMTIME_VERSION_*` macros defined in its header
-  files.
-  [#5651](https://github.com/bytecodealliance/wasmtime/pull/5651)
-
-* The `wasmtime` CLI executable as part of Wasmtime's precompiled release
-  artifacts now has the `all-arch` feature enabled.
-  [#5657](https://github.com/bytecodealliance/wasmtime/pull/5657)
-
-### Changed
-
-* Equality of `wasmtime::component::Val::Float{32,64}` now considers NaNs as
-  equal for assistance when fuzzing.
-  [#5535](https://github.com/bytecodealliance/wasmtime/pull/5535)
-
-* WIT syntax supported by `wasmtime::component::bindgen!` has been updated in
-  addition to the generated code being updated.
-  [#5565](https://github.com/bytecodealliance/wasmtime/pull/5565)
-  [#5692](https://github.com/bytecodealliance/wasmtime/pull/5692)
-  [#5694](https://github.com/bytecodealliance/wasmtime/pull/5694)
-
-* Cranelift's egraph-based optimization framework is now enabled by default.
-  [#5587](https://github.com/bytecodealliance/wasmtime/pull/5587)
-
-* The old `PoolingAllocationStrategy` type has been removed in favor of a more
-  flexible configuration via a new option
-  `PoolingAllocationConfig::max_unused_warm_slots` which is more flexible and
-  subsumes the previous use cases for each strategy.
-  [#5661](https://github.com/bytecodealliance/wasmtime/pull/5661)
-
-* Creation of `InstancePre` through `Linker::instantiate_pre` no longer requires
-  a `Store` to be provided. Instead a `Store`-related argument is now required
-  on `Linker::define`-style APIs instead.
-  [#5683](https://github.com/bytecodealliance/wasmtime/pull/5683)
-
-### Fixed
-
-* Compilation for FreeBSD on x86\_64 and AArch64 has been fixed.
-  [#5606](https://github.com/bytecodealliance/wasmtime/pull/5606)
-
---------------------------------------------------------------------------------
-
-## 5.0.1
-
-Released 2023-03-08.
-
-### Fixed
-
-* Guest-controlled out-of-bounds read/write on x86\_64
-  [GHSA-ff4p-7xrq-q5r8](https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-ff4p-7xrq-q5r8)
-
-*  Miscompilation of `i8x16.select` with the same inputs on x86\_64
-  [GHSA-xm67-587q-r2vw](https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-xm67-587q-r2vw)
-
---------------------------------------------------------------------------------
-
-## 5.0.0
-
-Released 2023-01-20
-
-### Added
-
-* A `wasmtime::component::bingen!` macro has been added for generating bindings
-  from `*.wit` files. Note that WIT is still heavily in development so this is
-  more of a preview of what will be as opposed to a finished feature.
-  [#5317](https://github.com/bytecodealliance/wasmtime/pull/5317)
-  [#5397](https://github.com/bytecodealliance/wasmtime/pull/5397)
-
-* The `wasmtime settings` CLI command now has a `--json` option for
-  machine-readable output.
-  [#5411](https://github.com/bytecodealliance/wasmtime/pull/5411)
-
-* Wiggle-generated bindings can now generate the trait for either `&mut self` or
-  `&self`.
-  [#5428](https://github.com/bytecodealliance/wasmtime/pull/5428)
-
-* The `wiggle` crate has more convenience APIs for working with guest data
-  that resides in shared memory.
-  [#5471](https://github.com/bytecodealliance/wasmtime/pull/5471)
-  [#5475](https://github.com/bytecodealliance/wasmtime/pull/5475)
-
-### Changed
-
-* Cranelift's egraph support has been rewritten and updated. This functionality
-  is still gated behind a flag and may become the default in the next release.
-  [#5382](https://github.com/bytecodealliance/wasmtime/pull/5382)
-
-* The implementation of codegen for WebAssembly linear memory has changed
-  significantly internally in Cranelift, moving more responsibility to the
-  Wasmtime embedding rather than Cranelift itself. This should have no
-  user-visible change, however.
-  [#5386](https://github.com/bytecodealliance/wasmtime/pull/5386)
-
-* The `Val::Float32` and `Val::Float64` variants for components now store `f32`
-  and `f64` instead of the bit representation.
-  [#5510](https://github.com/bytecodealliance/wasmtime/pull/5510)
-
-### Fixed
-
-* Handling of DWARF debugging information in components with multiple modules
-  has been fixed to ensure the right info is used for each module.
-  [#5358](https://github.com/bytecodealliance/wasmtime/pull/5358)
-
---------------------------------------------------------------------------------
-
-## 4.0.1
-
-Released 2023-03-08.
-
-### Fixed
-
-* Guest-controlled out-of-bounds read/write on x86\_64
-  [GHSA-ff4p-7xrq-q5r8](https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-ff4p-7xrq-q5r8)
-
-*  Miscompilation of `i8x16.select` with the same inputs on x86\_64
-  [GHSA-xm67-587q-r2vw](https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-xm67-587q-r2vw)
-
---------------------------------------------------------------------------------
-
-## 4.0.0
-
-Released 2022-12-20
-
-### Added
-
-* Dynamic memories are now supported with the pooling instance allocator which
-  can possibly reduce the number of page faults throughout execution at the cost
-  of slower to run code. Page faults are primarily reduced by avoiding
-  releasing memory back to the system, relying on bounds checks to keep the
-  memory inaccessible.
-  [#5208](https://github.com/bytecodealliance/wasmtime/pull/5208)
-
-* The `wiggle` generator now supports function-level control over `tracing`
-  calls.
-  [#5194](https://github.com/bytecodealliance/wasmtime/pull/5194)
-
-* Support has been added to `wiggle` to be compatible with shared memories.
-  [#5225](https://github.com/bytecodealliance/wasmtime/pull/5225)
-  [#5229](https://github.com/bytecodealliance/wasmtime/pull/5229)
-  [#5264](https://github.com/bytecodealliance/wasmtime/pull/5264)
-  [#5268](https://github.com/bytecodealliance/wasmtime/pull/5268)
-  [#5054](https://github.com/bytecodealliance/wasmtime/pull/5054)
-
-* The `wiggle` generator now supports a "trappable error" configuration to
-  improve error conversions to guest errors and ensure that no host errors are
-  forgotten or accidentally become traps. The `wasi-common` crate has been
-  updated to use this.
-  [#5276](https://github.com/bytecodealliance/wasmtime/pull/5276)
-  [#5279](https://github.com/bytecodealliance/wasmtime/pull/5279)
-
-* The `memory.atomic.{notify,wait32,wait64}` instructions are now all
-  implemented in Wasmtime.
-  [#5255](https://github.com/bytecodealliance/wasmtime/pull/5255)
-  [#5311](https://github.com/bytecodealliance/wasmtime/pull/5311)
-
-* A `wasm_config_parallel_compilation_set` configuration function has been added
-  to the C API.
-  [#5298](https://github.com/bytecodealliance/wasmtime/pull/5298)
-
-* The `wasmtime` CLI can have its input module piped into it from stdin now.
-  [#5342](https://github.com/bytecodealliance/wasmtime/pull/5342)
-
-* `WasmBacktrace::{capture,force_capture}` methods have been added to
-  programmatically capture a backtrace outside of a trapping context.
-  [#5341](https://github.com/bytecodealliance/wasmtime/pull/5341)
-
-### Changed
-
-* The `S` type parameter on `Func::typed` and `Instance::get_typed_func` has
-  been removed and no longer needs to be specified.
-  [#5275](https://github.com/bytecodealliance/wasmtime/pull/5275)
-
-* The `SharedMemory::data` method now returns `&[UnsafeCell<u8>]` instead of the
-  prior raw slice return.
-  [#5240](https://github.com/bytecodealliance/wasmtime/pull/5240)
-
-* Creation of a `WasiCtx` will no longer unconditionally acquire randomness from
-  the OS, instead using the `rand::thread_rng()` function in Rust which is only
-  periodically reseeded with randomness from the OS.
-  [#5244](https://github.com/bytecodealliance/wasmtime/pull/5244)
-
-* Codegen of dynamically-bounds-checked wasm memory accesses has been improved.
-  [#5190](https://github.com/bytecodealliance/wasmtime/pull/5190)
-
-* Wasmtime will now emit inline stack probes in generated functions for x86\_64,
-  aarch64, and riscv64 architectures. This guarantees a process abort if an
-  engine was misconfigured to give wasm too much stack instead of optionally
-  allowing wasm to skip the guard page.
-  [#5350](https://github.com/bytecodealliance/wasmtime/pull/5350)
-  [#5353](https://github.com/bytecodealliance/wasmtime/pull/5353)
-
-### Fixed
-
-* Dropping a `Module` will now release kernel resources in-use by the pooling
-  allocator when enabled instead of waiting for a new instance to be
-  re-instantiated into prior slots.
-  [#5321](https://github.com/bytecodealliance/wasmtime/pull/5321)
-
---------------------------------------------------------------------------------
-
-## 3.0.1
-
-Released 2022-12-01.
-
-### Fixed
-
-* The instruction cache is now flushed for AArch64 Android.
-  [#5331](https://github.com/bytecodealliance/wasmtime/pull/5331)
-
-* Building for FreeBSD and Android has been fixed.
-  [#5323](https://github.com/bytecodealliance/wasmtime/pull/5323)
-
---------------------------------------------------------------------------------
-
-## 3.0.0
-
-Released 2022-11-21
-
-### Added
-
-* New `WasiCtx::{push_file, push_dir}` methods exist for embedders to add their
-  own objects.
-  [#5027](https://github.com/bytecodealliance/wasmtime/pull/5027)
-
-* Wasmtime's `component-model` support now supports `async` host functions and
-  embedding in the same manner as core wasm.
-  [#5055](https://github.com/bytecodealliance/wasmtime/pull/5055)
-
-* The `wasmtime` CLI executable now supports a `--max-wasm-stack` flag.
-  [#5156](https://github.com/bytecodealliance/wasmtime/pull/5156)
-
-* AOT compilation support has been implemented for components (aka the
-  `component-model` feature of the Wasmtime crate).
-  [#5160](https://github.com/bytecodealliance/wasmtime/pull/5160)
-
-* A new `wasi_config_set_stdin_bytes` function is available in the C API to set
-  the stdin of a WASI-using module from an in-memory slice.
-  [#5179](https://github.com/bytecodealliance/wasmtime/pull/5179)
-
-* When using the pooling allocator there are now options to reset memory with
-  `memset` instead of `madvisev` on Linux to keep pages resident in memory to
-  reduce page faults when reusing linear memory slots.
-  [#5207](https://github.com/bytecodealliance/wasmtime/pull/5207)
-
-### Changed
-
-* Consuming 0 fuel with 0 fuel left is now considered to succeed. Additionally a
-  store may not consume its last unit of fuel.
-  [#5013](https://github.com/bytecodealliance/wasmtime/pull/5013)
-
-* A number of variants in the `wasi_common::ErrorKind` enum have been removed.
-  [#5015](https://github.com/bytecodealliance/wasmtime/pull/5015)
-
-* Methods on `WasiDir` now error-by-default instead of requiring a definition by
-  default.
-  [#5019](https://github.com/bytecodealliance/wasmtime/pull/5019)
-
-* Bindings generated by the `wiggle` crate now always depend on the `wasmtime`
-  crate meaning crates like `wasi-common` no longer compile for platforms such
-  as `wasm32-unknown-emscripten`.
-  [#5137](https://github.com/bytecodealliance/wasmtime/pull/5137)
-
-* Error handling in the `wasmtime` crate's API has been changed to primarily
-  work with `anyhow::Error` for custom errors. The `Trap` type has been replaced
-  with a simple `enum Trap { ... }` and backtrace information is now stored as a
-  `WasmBacktrace` type inserted as context into an `anyhow::Error`.
-  Host-functions are expected to return `anyhow::Result<T>` instead of the prior
-  `Trap` error return from before. Additionally the old `Trap::i32_exit`
-  constructor is now a concrete `wasi_commont::I32Exit` type which can be tested
-  for with a `downcast_ref` on the error returned from Wasmtime.
-  [#5149](https://github.com/bytecodealliance/wasmtime/pull/5149)
-
-* Configuration of the pooling allocator is now done through a builder-style
-  `PoolingAllocationConfig` API instead of the prior enum-variant API.
-  [#5205](https://github.com/bytecodealliance/wasmtime/pull/5205)
-
-### Fixed
-
-* The instruction cache is now properly flushed for AArch64 on Windows.
-  [#4997](https://github.com/bytecodealliance/wasmtime/pull/4997)
-
-* Backtrace capturing with many sequences of wasm->host calls on the stack no
-  longer exhibit quadratic capturing behavior.
-  [#5049](https://github.com/bytecodealliance/wasmtime/pull/5049)
-
---------------------------------------------------------------------------------
-
-## 2.0.2
-
-Released 2022-11-10.
-
-### Fixed
-
-* [CVE-2022-39392] - modules may perform out-of-bounds reads/writes when the
-  pooling allocator was configured with `memory_pages: 0`.
-
-* [CVE-2022-39393] - data can be leaked between instances when using the pooling
-  allocator.
-
-* [CVE-2022-39394] - An incorrect Rust signature for the C API
-  `wasmtime_trap_code` function could lead to an out-of-bounds write of three
-  zero bytes.
-
-[CVE-2022-39392]: https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-44mr-8vmm-wjhg
-[CVE-2022-39393]: https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-wh6w-3828-g9qf
-[CVE-2022-39394]: https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-h84q-m8rr-3v9q
-
---------------------------------------------------------------------------------
-
-## 2.0.1
-
-Released 2022-10-27.
-
-### Fixed
-
-* A compilation error when building only the `wasmtime` crate on Windows with
-  only the default features enabled has been fixed.
-  [#5134](https://github.com/bytecodealliance/wasmtime/pull/5134)
-
-### Changed
-
-* The `rayon` dependency added to `cranelift-isle` in 2.0.0 has been removed to
-  improve the compile time of the `cranelift-codegen` crate.
-  [#5101](https://github.com/bytecodealliance/wasmtime/pull/5101)
-
---------------------------------------------------------------------------------
-
-## 2.0.0
-
-Released 2022-10-20
-
-### Added
-
-* Cranelift has gained support for forward-edge CFI on the AArch64 backend.
-  [#3693](https://github.com/bytecodealliance/wasmtime/pull/3693)
-
-* A `--disable-parallel-compilation` CLI flag is now implemented for `wasmtime`.
-  [#4911](https://github.com/bytecodealliance/wasmtime/pull/4911)
-
-* [Tier 3] support has been added for for RISC-V 64 with a new backend in
-  Cranelift for this architecture.
-  [#4271](https://github.com/bytecodealliance/wasmtime/pull/4271)
-
-* Basic [tier 3] support for Windows ARM64 has been added but features such as
-  traps don't work at this time.
-  [#4990](https://github.com/bytecodealliance/wasmtime/pull/4990)
-
-### Changed
-
-* The implementation of the `random_get` function in `wasi-common` is now faster
-  by using a userspace CSPRNG rather than the OS for randomness.
-  [#4917](https://github.com/bytecodealliance/wasmtime/pull/4917)
-
-* The AArch64 backend has completed its transition to ISLE.
-  [#4851](https://github.com/bytecodealliance/wasmtime/pull/4851)
-  [#4866](https://github.com/bytecodealliance/wasmtime/pull/4866)
-  [#4898](https://github.com/bytecodealliance/wasmtime/pull/4898)
-  [#4884](https://github.com/bytecodealliance/wasmtime/pull/4884)
-  [#4820](https://github.com/bytecodealliance/wasmtime/pull/4820)
-  [#4913](https://github.com/bytecodealliance/wasmtime/pull/4913)
-  [#4942](https://github.com/bytecodealliance/wasmtime/pull/4942)
-  [#4943](https://github.com/bytecodealliance/wasmtime/pull/4943)
-
-* The size of the `sigaltstack` allocated per-thread for signal handling has
-  been increased from 16k to 64k.
-  [#4964](https://github.com/bytecodealliance/wasmtime/pull/4964)
-
-
-[Tier 3]: https://docs.wasmtime.dev/stability-tiers.html
-
---------------------------------------------------------------------------------
-
-## 1.0.2
-
-Released 2022-11-10.
-
-### Fixed
-
-* [CVE-2022-39392] - modules may perform out-of-bounds reads/writes when the
-  pooling allocator was configured with `memory_pages: 0`.
-
-* [CVE-2022-39393] - data can be leaked between instances when using the pooling
-  allocator.
-
-* [CVE-2022-39394] - An incorrect Rust signature for the C API
-  `wasmtime_trap_code` function could lead to an out-of-bounds write of three
-  zero bytes.
-
---------------------------------------------------------------------------------
-
-## 1.0.1
-
-Released 2022-09-26
-
-This is a patch release that incorporates a fix for a miscompilation of an
-atomic-CAS operator on aarch64. The instruction is not usable from Wasmtime
-with default settings, but may be used if the Wasm atomics extension is
-enabled. The bug may also be reachable via other uses of Cranelift. Thanks to
-@bjorn3 for reporting and debugging this issue!
-
-### Fixed
-
-* Fixed a miscompilation of `atomic_cas` on aarch64. The output register was
-  swapped with a temporary register in the register-allocator constraints.
-  [#4959](https://github.com/bytecodealliance/wasmtime/pull/4959)
-  [#4960](https://github.com/bytecodealliance/wasmtime/pull/4960)
-
---------------------------------------------------------------------------------
-
-## 1.0.0
-
-Released 2022-09-20
-
-This release marks the official 1.0 release of Wasmtime and represents the
-culmination of the work amongst over 300 contributors. Wasmtime has been
-battle-tested in production through multiple embeddings for quite some time now
-and we're confident in releasing a 1.0 version to signify the stability and
-quality of the Wasmtime engine.
-
-More information about Wasmtime's 1.0 release is on the [Bytecode Alliance's
-blog][ba-blog] with separate posts on [Wasmtime's performance
-features][ba-perf], [Wasmtime's security story][ba-security], and [the 1.0
-release announcement][ba-1.0].
-
-As a reminder the 2.0 release of Wasmtime is scheduled for one month from now on
-October 20th. For more information see the [RFC on Wasmtime's 1.0
-release][rfc-1.0].
-
-[ba-blog]: https://bytecodealliance.org/articles/
-[ba-perf]: https://bytecodealliance.org/articles/wasmtime-10-performance
-[ba-security]: https://bytecodealliance.org/articles/security-and-correctness-in-wasmtime
-[ba-1.0]: https://bytecodealliance.org/articles/wasmtime-1-0-fast-safe-and-now-production-ready.md
-[rfc-1.0]: https://github.com/bytecodealliance/rfcs/blob/main/accepted/wasmtime-one-dot-oh.md
-
-### Added
-
-* An incremental compilation cache for Cranelift has been added which can be
-  enabled with `Config::enable_incremental_compilation`, and this option is
-  disabled by default for now. The incremental compilation cache has been
-  measured to improve compile times for cold uncached modules as well due to
-  some wasm modules having similar-enough functions internally.
-  [#4551](https://github.com/bytecodealliance/wasmtime/pull/4551)
-
-* Source tarballs are now available as part of Wasmtime's release artifacts.
-  [#4294](https://github.com/bytecodealliance/wasmtime/pull/4294)
-
-* WASI APIs that specify the REALTIME clock are now supported.
-  [#4777](https://github.com/bytecodealliance/wasmtime/pull/4777)
-
-* WASI's socket functions are now fully implemented.
-  [#4776](https://github.com/bytecodealliance/wasmtime/pull/4776)
-
-* The native call stack for async-executed wasm functions are no longer
-  automatically reset to zero after the stack is returned to the pool when using
-  the pooling allocator. A `Config::async_stack_zeroing` option has been added
-  to restore the old behavior of zero-on-return-to-pool.
-  [#4813](https://github.com/bytecodealliance/wasmtime/pull/4813)
-
-* Inline stack probing has been implemented for the Cranelift x64 backend.
-  [#4747](https://github.com/bytecodealliance/wasmtime/pull/4747)
-
-### Changed
-
-* Generating of native unwind information has moved from a
-  `Config::wasm_backtrace` option to a new `Config::native_unwind_info` option
-  and is enabled by default.
-  [#4643](https://github.com/bytecodealliance/wasmtime/pull/4643)
-
-* The `memory-init-cow` feature is now enabled by default in the C API.
-  [#4690](https://github.com/bytecodealliance/wasmtime/pull/4690)
-
-* Back-edge CFI is now enabled by default on AArch64 macOS.
-  [#4720](https://github.com/bytecodealliance/wasmtime/pull/4720)
-
-* WASI calls will no longer return NOTCAPABLE in preparation for the removal of
-  the rights system from WASI.
-  [#4666](https://github.com/bytecodealliance/wasmtime/pull/4666)
-
-### Internal
-
-This section of the release notes shouldn't affect external users since no
-public-facing APIs are affected, but serves as a place to document larger
-changes internally within Wasmtime.
-
-* Differential fuzzing has been refactored and improved into one fuzzing target
-  which can execute against any of Wasmtime itself (configured differently),
-  wasmi, V8, or the spec interpreter. Fuzzing now executes each exported
-  function with fuzz-generated inputs and the contents of all of memory and each
-  exported global is compared after each execution. Additionally more
-  interesting shapes of modules are also possible to generate.
-  [#4515](https://github.com/bytecodealliance/wasmtime/pull/4515)
-  [#4735](https://github.com/bytecodealliance/wasmtime/pull/4735)
-  [#4737](https://github.com/bytecodealliance/wasmtime/pull/4737)
-  [#4739](https://github.com/bytecodealliance/wasmtime/pull/4739)
-  [#4774](https://github.com/bytecodealliance/wasmtime/pull/4774)
-  [#4773](https://github.com/bytecodealliance/wasmtime/pull/4773)
-  [#4845](https://github.com/bytecodealliance/wasmtime/pull/4845)
-  [#4672](https://github.com/bytecodealliance/wasmtime/pull/4672)
-  [#4674](https://github.com/bytecodealliance/wasmtime/pull/4674)
-
-* The x64 backend for Cranelift has been fully migrated to ISLE.
-  [#4619](https://github.com/bytecodealliance/wasmtime/pull/4619)
-  [#4625](https://github.com/bytecodealliance/wasmtime/pull/4625)
-  [#4645](https://github.com/bytecodealliance/wasmtime/pull/4645)
-  [#4650](https://github.com/bytecodealliance/wasmtime/pull/4650)
-  [#4684](https://github.com/bytecodealliance/wasmtime/pull/4684)
-  [#4704](https://github.com/bytecodealliance/wasmtime/pull/4704)
-  [#4718](https://github.com/bytecodealliance/wasmtime/pull/4718)
-  [#4726](https://github.com/bytecodealliance/wasmtime/pull/4726)
-  [#4722](https://github.com/bytecodealliance/wasmtime/pull/4722)
-  [#4729](https://github.com/bytecodealliance/wasmtime/pull/4729)
-  [#4730](https://github.com/bytecodealliance/wasmtime/pull/4730)
-  [#4741](https://github.com/bytecodealliance/wasmtime/pull/4741)
-  [#4763](https://github.com/bytecodealliance/wasmtime/pull/4763)
-  [#4772](https://github.com/bytecodealliance/wasmtime/pull/4772)
-  [#4780](https://github.com/bytecodealliance/wasmtime/pull/4780)
-  [#4787](https://github.com/bytecodealliance/wasmtime/pull/4787)
-  [#4793](https://github.com/bytecodealliance/wasmtime/pull/4793)
-  [#4809](https://github.com/bytecodealliance/wasmtime/pull/4809)
-
-* The AArch64 backend for Cranelift has seen significant progress in being
-  ported to ISLE.
-  [#4608](https://github.com/bytecodealliance/wasmtime/pull/4608)
-  [#4639](https://github.com/bytecodealliance/wasmtime/pull/4639)
-  [#4634](https://github.com/bytecodealliance/wasmtime/pull/4634)
-  [#4748](https://github.com/bytecodealliance/wasmtime/pull/4748)
-  [#4750](https://github.com/bytecodealliance/wasmtime/pull/4750)
-  [#4751](https://github.com/bytecodealliance/wasmtime/pull/4751)
-  [#4753](https://github.com/bytecodealliance/wasmtime/pull/4753)
-  [#4788](https://github.com/bytecodealliance/wasmtime/pull/4788)
-  [#4796](https://github.com/bytecodealliance/wasmtime/pull/4796)
-  [#4785](https://github.com/bytecodealliance/wasmtime/pull/4785)
-  [#4819](https://github.com/bytecodealliance/wasmtime/pull/4819)
-  [#4821](https://github.com/bytecodealliance/wasmtime/pull/4821)
-  [#4832](https://github.com/bytecodealliance/wasmtime/pull/4832)
-
-* The s390x backend has seen improvements and additions to fully support the
-  Cranelift backend for rustc.
-  [#4682](https://github.com/bytecodealliance/wasmtime/pull/4682)
-  [#4702](https://github.com/bytecodealliance/wasmtime/pull/4702)
-  [#4616](https://github.com/bytecodealliance/wasmtime/pull/4616)
-  [#4680](https://github.com/bytecodealliance/wasmtime/pull/4680)
-
-* Significant improvements have been made to Cranelift-based fuzzing with more
-  supported features and more instructions being fuzzed.
-  [#4589](https://github.com/bytecodealliance/wasmtime/pull/4589)
-  [#4591](https://github.com/bytecodealliance/wasmtime/pull/4591)
-  [#4665](https://github.com/bytecodealliance/wasmtime/pull/4665)
-  [#4670](https://github.com/bytecodealliance/wasmtime/pull/4670)
-  [#4590](https://github.com/bytecodealliance/wasmtime/pull/4590)
-  [#4375](https://github.com/bytecodealliance/wasmtime/pull/4375)
-  [#4519](https://github.com/bytecodealliance/wasmtime/pull/4519)
-  [#4696](https://github.com/bytecodealliance/wasmtime/pull/4696)
-  [#4700](https://github.com/bytecodealliance/wasmtime/pull/4700)
-  [#4703](https://github.com/bytecodealliance/wasmtime/pull/4703)
-  [#4602](https://github.com/bytecodealliance/wasmtime/pull/4602)
-  [#4713](https://github.com/bytecodealliance/wasmtime/pull/4713)
-  [#4738](https://github.com/bytecodealliance/wasmtime/pull/4738)
-  [#4667](https://github.com/bytecodealliance/wasmtime/pull/4667)
-  [#4782](https://github.com/bytecodealliance/wasmtime/pull/4782)
-  [#4783](https://github.com/bytecodealliance/wasmtime/pull/4783)
-  [#4800](https://github.com/bytecodealliance/wasmtime/pull/4800)
-
-* Optimization work on cranelift has continued across various dimensions for
-  some modest compile-time improvements.
-  [#4621](https://github.com/bytecodealliance/wasmtime/pull/4621)
-  [#4701](https://github.com/bytecodealliance/wasmtime/pull/4701)
-  [#4697](https://github.com/bytecodealliance/wasmtime/pull/4697)
-  [#4711](https://github.com/bytecodealliance/wasmtime/pull/4711)
-  [#4710](https://github.com/bytecodealliance/wasmtime/pull/4710)
-  [#4829](https://github.com/bytecodealliance/wasmtime/pull/4829)
-
---------------------------------------------------------------------------------
-
-## 0.40.0
-
-Released 2022-08-20
-
-This was a relatively quiet release in terms of user-facing features where most
-of the work was around the internals of Wasmtime and Cranelift. Improvements
-internally have been made along the lines of:
-
-* Many more instructions are now implemented with ISLE instead of handwritten
-  lowerings.
-* Many improvements to the cranelift-based fuzzing.
-* Many platform improvements for s390x including full SIMD support, running
-  `rustc_codegen_cranelift` with features like `i128`, supporting more
-  ABIs, etc.
-* Much more of the component model has been implemented and is now fuzzed.
-
-Finally this release is currently scheduled to be the last `0.*` release of
-Wasmtime. The upcoming release of Wasmtime on September 20 is planned to be
-Wasmtime's 1.0 release. More information about what 1.0 means for Wasmtime is
-available in the [1.0 RFC]
-
-[1.0 RFC]: https://github.com/bytecodealliance/rfcs/blob/main/accepted/wasmtime-one-dot-oh.md
-
-### Added
-
-* Stack walking has been reimplemented with frame pointers rather than with
-  native unwind information. This means that backtraces are feasible to capture
-  in performance-critical environments and in general stack walking is much
-  faster than before.
-  [#4431](https://github.com/bytecodealliance/wasmtime/pull/4431)
-
-* The WebAssembly `simd` proposal is now fully implemented for the s390x
-  backend.
-  [#4427](https://github.com/bytecodealliance/wasmtime/pull/4427)
-
-* Support for AArch64 has been added in the experimental native debuginfo
-  support that Wasmtime has.
-  [#4468](https://github.com/bytecodealliance/wasmtime/pull/4468)
-
-* Support building the C API of Wasmtime with CMake has been added.
-  [#4369](https://github.com/bytecodealliance/wasmtime/pull/4369)
-
-* Clarification was added to Wasmtime's documentation about "tiers of support"
-  for various features.
-  [#4479](https://github.com/bytecodealliance/wasmtime/pull/4479)
-
-### Fixed
-
-* Support for `filestat_get` has been improved for stdio streams in WASI.
-  [#4531](https://github.com/bytecodealliance/wasmtime/pull/4531)
-
-* Enabling the `vtune` feature no longer breaks builds on AArch64.
-  [#4533](https://github.com/bytecodealliance/wasmtime/pull/4533)
-
---------------------------------------------------------------------------------
-
-## 0.39.1
-
-Released 2022-07-20.
-
-### Fixed
-
-* An s390x-specific codegen bug in addition to a mistake introduced in the fix
-  of CVE-2022-31146 were fixed.
-  [#4490](https://github.com/bytecodealliance/wasmtime/pull/4490)
-
---------------------------------------------------------------------------------
-
-## 0.39.0
-
-Released 2022-07-20
-
-### Added
-
-* Initial support for shared memories and the `threads` WebAssembly proposal
-  has been added. Note that this feature is still experimental and not ready
-  for production use yet.
-  [#4187](https://github.com/bytecodealliance/wasmtime/pull/4187)
-
-* A new `Linker::define_unknown_imports_as_traps` method and
-  `--trap-unknown-imports` CLI flag have been added to conveniently support
-  running modules with imports that aren't dynamically called at runtime.
-  [#4312](https://github.com/bytecodealliance/wasmtime/pull/4312)
-
-* The VTune profiling strategy can now be selected through the C API.
-  [#4316](https://github.com/bytecodealliance/wasmtime/pull/4316)
-
-### Changed
-
-* Some methods on the `Config` structure now return `&mut Self` instead of
-  `Result<&mut Self>` since the validation is deferred until `Engine::new`:
-  `profiler`, `cranelift_flag_enable`, `cranelift_flag_set`, `max_wasm_stack`,
-  `async_stack_size`, and `strategy`.
-  [#4252](https://github.com/bytecodealliance/wasmtime/pull/4252)
-  [#4262](https://github.com/bytecodealliance/wasmtime/pull/4262)
-
-* Parallel compilation of WebAssembly modules is now enabled in the C API by
-  default.
-  [#4270](https://github.com/bytecodealliance/wasmtime/pull/4270)
-
-* Implicit Cargo features of the `wasmtime` introduced through `optional`
-  dependencies may have been removed since namespaced features are now used.
-  It's recommended to only used the set of named `[features]` for Wasmtime.
-  [#4293](https://github.com/bytecodealliance/wasmtime/pull/4293)
-
-* Register allocation has fixed a few issues related to excessive memory usage
-  at compile time.
-  [#4324](https://github.com/bytecodealliance/wasmtime/pull/4324)
-
-### Fixed
-
-* A refactor of `Config` was made to fix an issue that the order of calls to `Config`
-  matters now, which may lead to unexpected behavior.
-  [#4252](https://github.com/bytecodealliance/wasmtime/pull/4252)
-  [#4262](https://github.com/bytecodealliance/wasmtime/pull/4262)
-
-* Wasmtime has been fixed to work on SSE2-only x86\_64 platforms when the
-  `simd` feature is disabled in `Config`.
-  [#4231](https://github.com/bytecodealliance/wasmtime/pull/4231)
-
-* Generation of platform-specific unwinding information is disabled if
-  `wasm_backtrace` and `wasm_reference_types` are both disabled.
-  [#4351](https://github.com/bytecodealliance/wasmtime/pull/4351)
-
---------------------------------------------------------------------------------
-
-## 0.38.3
-
-Released 2022-07-20.
-
-### Fixed.
-
-* An s390x-specific codegen bug in addition to a mistake introduced in the fix
-  of CVE-2022-31146 were fixed.
-  [#4491](https://github.com/bytecodealliance/wasmtime/pull/4491)
-
---------------------------------------------------------------------------------
-
-## 0.38.2
-
-Released 2022-07-20.
-
-### Fixed.
-
-* A miscompilation when handling constant divisors on AArch64 has been fixed.
-  [CVE-2022-31169](https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-7f6x-jwh5-m9r4)
-
-* A use-after-free possible with accidentally missing stack maps has been fixed.
-  [CVE-2022-31146](https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-5fhj-g3p3-pq9g)
-
---------------------------------------------------------------------------------
-
-## 0.38.1
-
-Released 2022-06-27.
-
-### Fixed.
-
-* A register allocator bug was fixed that could affect direct users of
-  Cranelift who use struct-return (`sret`) arguments. The bug had to do with
-  the handling of physical register constraints in the function prologue. No
-  impact should be possible for users of Cranelift via the Wasm frontend,
-  including Wasmtime.
-  [regalloc2#60](https://github.com/bytecodealliance/regalloc2/pull/60)
-  [#4333](https://github.com/bytecodealliance/wasmtime/pull/4333)
-
-* Lowering bugs for the `i8x16.swizzle` and `select`-with-`v128`-inputs
-  instructions were fixed for the x86\_64 code generator. Note that aarch64 and
-  s390x are unaffected.
-  [#4334](https://github.com/bytecodealliance/wasmtime/pull/4334)
-
-* A bug in the 8-bit lowering of integer division on x86-64 was fixed in
-  Cranelift that could cause a register allocator panic due to an undefined
-  value in a register. (The divide instruction does not take a register `rdx`
-  as a source when 8 bits but the metadata incorrectly claimed it did.) No
-  impact on Wasm/Wasmtime users, and impact on direct Cranelift embedders
-  limited to compilation panics.
-  [#4332](https://github.com/bytecodealliance/wasmtime/pull/4332)
-
---------------------------------------------------------------------------------
-
-## 0.38.0
-
-Released 2022-06-21
-
-### Added
-
-* Enabling or disabling NaN canonicalization in generated code is now exposed
-  through the C API.
-  [#4154](https://github.com/bytecodealliance/wasmtime/pull/4154)
-
-* A user-defined callback can now be invoked when an epoch interruption happens
-  via the `Store::epoch_deadline_callback` API.
-  [#4152](https://github.com/bytecodealliance/wasmtime/pull/4152)
-
-* Basic alias analysis with redundant-load elimintation and store-to-load
-  forwarding optimizations has been added to Cranelift.
-  [#4163](https://github.com/bytecodealliance/wasmtime/pull/4163)
-
-### Changed
-
-* Traps originating from epoch-based interruption are now exposed as
-  `TrapCode::Interrupt`.
-  [#4105](https://github.com/bytecodealliance/wasmtime/pull/4105)
-
-* Binary builds for AArch64 now require glibc 2.17 and for s390x require glibc
-  2.16. Previously glibc 2.28 was required.
-  [#4171](https://github.com/bytecodealliance/wasmtime/pull/4171)
-
-* The `wasmtime::ValRaw` now has all of its fields listed as private and instead
-  constructors/accessors are provided for getting at the internal data.
-  [#4186](https://github.com/bytecodealliance/wasmtime/pull/4186)
-
-* The `wasm-backtrace` Cargo feature has been removed in favor of a
-  `Config::wasm_backtrace` runtime configuration option. Additionally backtraces
-  are now only captured when an embedder-generated trap actually reaches a
-  WebAssembly call stack.
-  [#4183](https://github.com/bytecodealliance/wasmtime/pull/4183)
-
-* Usage of `*_unchecked` APIs for `Func` in the `wasmtime` crate and C API now
-  take a `usize` parameter indicating the number of `ValRaw` values behind
-  the associated pointer.
-  [#4192](https://github.com/bytecodealliance/wasmtime/pull/4192)
-
-### Fixed
-
-* An improvement was made to the spill-slot allocation in code generation to fix
-  an issue where some stack slots accidentally weren't reused. This issue was
-  introduced with the landing of regalloc2 in 0.37.0 and may have resulted in
-  larger-than-intended increases in stack frame sizes.
-  [#4222](https://github.com/bytecodealliance/wasmtime/pull/4222)
-
---------------------------------------------------------------------------------
-
-## 0.37.0
-
-Released 2022-05-20
-
-### Added
-
-* Updated Cranelift to use regalloc2, a new register allocator. This should
-  result in ~20% faster compile times, and for programs that suffered from
-  register-allocation pressure before, up to ~20% faster generated code.
-  [#3989](https://github.com/bytecodealliance/wasmtime/pull/3989)
-
-* Pre-built binaries for macOS M1 machines are now available as release
-  artifacts.
-  [#3983](https://github.com/bytecodealliance/wasmtime/pull/3983)
-
-* Copy-on-write images of memory can now be manually initialized for a `Module`
-  with an explicit method call, but it is still not required to call this method
-  and will automatically otherwise happen on the first instantiation.
-  [#3964](https://github.com/bytecodealliance/wasmtime/pull/3964)
-
-### Fixed
-
-* Using `InstancePre::instantiate` or `Linker::instantiate` will now panic as
-  intended when used with an async-configured `Store`.
-  [#3972](https://github.com/bytecodealliance/wasmtime/pull/3972)
-
-### Changed
-
-* The unsafe `ValRaw` type in the `wasmtime` crate now always stores its values
-  in little-endian format instead of the prior native-endian format. Users of
-  `ValRaw` are recommended to audit their existing code for usage to continue
-  working on big-endian platforms.
-  [#4035](https://github.com/bytecodealliance/wasmtime/pull/4035)
-
-### Removed
-
-* Support for `Config::paged_memory_initialization` and the `uffd` crate feature
-  have been removed from the `wasmtime` crate. Users should migrate to using
-  `Config::memory_init_cow` which is more portable and faster at this point.
-  [#4040](https://github.com/bytecodealliance/wasmtime/pull/4040)
-
---------------------------------------------------------------------------------
-
-## 0.36.0
-
-Released 2022-04-20
-
-### Added
-
-* Support for epoch-based interruption has been added to the C API.
-  [#3925](https://github.com/bytecodealliance/wasmtime/pull/3925)
-
-* Support for disabling libunwind-based backtraces of WebAssembly code at
-  compile time has been added.
-  [#3932](https://github.com/bytecodealliance/wasmtime/pull/3932)
-
-* Async support for call hooks has been added to optionally execute "blocking"
-  work whenever a wasm module is entered or exited relative to the host.
-  [#3876](https://github.com/bytecodealliance/wasmtime/pull/3876)
-
-### Fixed
-
-* Loading a `Module` will now check, at runtime, that the compilation settings
-  enabled in a `Config` are compatible with the native host. For example this
-  ensures that if avx2 is enabled that the host actually has avx2 support.
-  [#3899](https://github.com/bytecodealliance/wasmtime/pull/3899)
-
-### Removed
-
-* Support for `Config::interruptable` and `InterruptHandle` has been removed
-  from the `wasmtime` crate. Users should migrate to using epoch-based
-  interruption instead.
-  [#3925](https://github.com/bytecodealliance/wasmtime/pull/3925)
-
-* The module linking implementation of Wasmtime has been removed to make room
-  for the upcoming support for the component model.
-  [#3958](https://github.com/bytecodealliance/wasmtime/pull/3958)
-
---------------------------------------------------------------------------------
-
-## 0.35.3
-
-Released 2022-04-11.
-
-### Fixed
-
-* Backported a bugfix for an instruction lowering issue that could cause a
-  regalloc panic due to an undefined register in some cases. No miscompilation
-  was ever possible, but panics would result in a compilation failure.
-  [#4012](https://github.com/bytecodealliance/wasmtime/pull/4012)
-
---------------------------------------------------------------------------------
-
-## 0.35.2
-
-Released 2022-03-31.
-
-### Security Fixes
-
-* [CVE-2022-24791](https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-gwc9-348x-qwv2):
-  Fixed a use after free with `externref`s and epoch interruption.
-
-## 0.35.1
-
-Released 2022-03-09.
-
-### Fixed
-
-* Fixed a bug in the x86-64 lowering of the `uextend` opcode for narrow (`i8`,
-  `i16`) integer sources when the value is produced by one of several
-  arithmetic instructions.
-  [#3906](https://github.com/bytecodealliance/wasmtime/pull/3906)
-
-## 0.35.0
-
-Released 2022-03-07.
-
-### Added
-
-* The `wasmtime_wasi::add_to_linker` function now allows providing
-  a context object of a custom type instead of `wasmtime_wasi::WasiCtx`,
-  as long as that type implements the required WASI snapshot traits.
-  This allows, for example, wrapping `WasiCtx` into a struct and providing
-  custom implementations for those traits to override the default behaviour.
-
-### Changed
-
-* WebAssembly tables of `funcref` values are now lazily initialized which can,
-  in some cases, greatly speed up instantiation of a module.
-  [#3733](https://github.com/bytecodealliance/wasmtime/pull/3733)
-
-* The `memfd` feature in 0.34.0, now renamed to `memory-init-cow`, has been
-  enabled by default. This means that, where applicable, WebAssembly linear
-  memories are now initialized with copy-on-write mappings. Support from this
-  has been expanded from Linux-only to include macOS and other Unix systems when
-  modules are loaded from precompiled `*.cwasm` files on disk.
-  [#3777](https://github.com/bytecodealliance/wasmtime/pull/3777)
-  [#3778](https://github.com/bytecodealliance/wasmtime/pull/3778)
-  [#3787](https://github.com/bytecodealliance/wasmtime/pull/3787)
-  [#3819](https://github.com/bytecodealliance/wasmtime/pull/3819)
-  [#3831](https://github.com/bytecodealliance/wasmtime/pull/3831)
-
-* Clarify that SSE 4.2 (and prior) is required for running WebAssembly code with
-  simd support enabled on x86\_64.
-  [#3816](https://github.com/bytecodealliance/wasmtime/pull/3816)
-  [#3817](https://github.com/bytecodealliance/wasmtime/pull/3817)
-  [#3833](https://github.com/bytecodealliance/wasmtime/pull/3833)
-  [#3825](https://github.com/bytecodealliance/wasmtime/pull/3825)
-
-* Support for profiling with VTune is now enabled at compile time by default,
-  but it remains disabled at runtime by default.
-  [#3821](https://github.com/bytecodealliance/wasmtime/pull/3821)
-
-* The `ModuleLimits` type has been removed from the configuration of the pooling
-  allocator in favor of configuring the total size of an instance allocation
-  rather than each individual field.
-  [#3837](https://github.com/bytecodealliance/wasmtime/pull/3837)
-
-* The native stack size allowed for WebAssembly has been decreased from 1 MiB to
-  512 KiB on all platforms to better accomodate running wasm on the main thread
-  on Windows.
-  [#3861](https://github.com/bytecodealliance/wasmtime/pull/3861)
-
-* The `wasi-common` crate now supports doing polls for both read and write
-  interest on a file descriptor at the same time.
-  [#3866](https://github.com/bytecodealliance/wasmtime/pull/3866)
-
-### Fixed
-
-* The `Store::call_hook` callback is now invoked when entering host functions
-  defined with `*_unchecked` variants.
-  [#3881](https://github.com/bytecodealliance/wasmtime/pull/3881)
-
-### Removed
-
-* The incomplete and unmaintained ARM32 backend has been removed from Cranelift.
-  [#3799](https://github.com/bytecodealliance/wasmtime/pull/3799)
-
---------------------------------------------------------------------------------
-
-## 0.34.2
-
-Released 2022-03-31.
-
-### Security Fixes
-
-* [CVE-2022-24791](https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-gwc9-348x-qwv2):
-  Fixed a use after free with `externref`s and epoch interruption.
-
-## 0.34.1
-
-Released 2022-02-16.
-
-### Security Fixes
-
-* [CVE-2022-23636](https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-88xq-w8cq-xfg7):
-  Fixed an invalid drop of a partially-initialized instance in the pooling instance
-  allocator.
-
-## 0.33.1
-
-Released 2022-02-16.
-
-### Security Fixes
-
-* [CVE-2022-23636](https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-88xq-w8cq-xfg7):
-  Fixed an invalid drop of a partially-initialized instance in the pooling instance
-  allocator.
-
-## 0.34.0
-
-Released 2022-02-07.
-
-### Fixed
-
-* The `wasi-common` default implementation of some attributes of files has been
-  updated to ensure that `wasi-libc`'s `isatty` function works as intended.
-  [#3696](https://github.com/bytecodealliance/wasmtime/pull/3696)
-
-* A benign debug assertion related to `externref` and garbage-collection has
-  been fixed.
-  [#3734](https://github.com/bytecodealliance/wasmtime/pull/3734)
-
-### Added
-
-* Function names are now automatically demangled when informing profilers of
-  regions of JIT code to apply Rust-specific demangling rules if applicable.
-  [#3683](https://github.com/bytecodealliance/wasmtime/pull/3683)
-
-* Support for profiling JIT-generated trampolines with VTune has been added.
-  [#3687](https://github.com/bytecodealliance/wasmtime/pull/3687)
-
-* Wasmtime now supports a new method of async preemption dubbed "epoch-based
-  interruption" which is intended to be much more efficient than the current
-  fuel-based method of preemption.
-  [#3699](https://github.com/bytecodealliance/wasmtime/pull/3699)
-
-* On Linux Wasmtime will now by default use copy-on-write mappings to initialize
-  memories of wasm modules where possible, accelerating instantiation by
-  avoiding costly memory copies. When combined with the pooling allocator this
-  can also be used to speed up instance-reuse cases due to fewer syscalls to
-  change memory mappings being necessary.
-  [#3697](https://github.com/bytecodealliance/wasmtime/pull/3697)
-  [#3738](https://github.com/bytecodealliance/wasmtime/pull/3738)
-  [#3760](https://github.com/bytecodealliance/wasmtime/pull/3760)
-
-* Wasmtime now supports the recently-added `sock_accept` WASI function.
-  [#3711](https://github.com/bytecodealliance/wasmtime/pull/3711)
-
-* Cranelift now has support for specifying blocks as cold.
-  [#3698](https://github.com/bytecodealliance/wasmtime/pull/3698)
-
-### Changed
-
-* Many more instructions for the x64 backend have been migrated to ISLE,
-  additionally with refactorings to make incorrect lowerings harder to
-  accidentally write.
-  [#3653](https://github.com/bytecodealliance/wasmtime/pull/3653)
-  [#3659](https://github.com/bytecodealliance/wasmtime/pull/3659)
-  [#3681](https://github.com/bytecodealliance/wasmtime/pull/3681)
-  [#3686](https://github.com/bytecodealliance/wasmtime/pull/3686)
-  [#3688](https://github.com/bytecodealliance/wasmtime/pull/3688)
-  [#3690](https://github.com/bytecodealliance/wasmtime/pull/3690)
-  [#3752](https://github.com/bytecodealliance/wasmtime/pull/3752)
-
-* More instructions in the aarch64 backend are now lowered with ISLE.
-  [#3658](https://github.com/bytecodealliance/wasmtime/pull/3658)
-  [#3662](https://github.com/bytecodealliance/wasmtime/pull/3662)
-
-* The s390x backend's lowering rules are now almost entirely defined with ISLE.
-  [#3702](https://github.com/bytecodealliance/wasmtime/pull/3702)
-  [#3703](https://github.com/bytecodealliance/wasmtime/pull/3703)
-  [#3706](https://github.com/bytecodealliance/wasmtime/pull/3706)
-  [#3717](https://github.com/bytecodealliance/wasmtime/pull/3717)
-  [#3723](https://github.com/bytecodealliance/wasmtime/pull/3723)
-  [#3724](https://github.com/bytecodealliance/wasmtime/pull/3724)
-
-* Instantiation of modules in Wasmtime has been further optimized now that the
-  copy-on-write memory initialization removed the previously most-expensive part
-  of instantiating a module.
-  [#3727](https://github.com/bytecodealliance/wasmtime/pull/3727)
-  [#3739](https://github.com/bytecodealliance/wasmtime/pull/3739)
-  [#3741](https://github.com/bytecodealliance/wasmtime/pull/3741)
-  [#3742](https://github.com/bytecodealliance/wasmtime/pull/3742)
-
---------------------------------------------------------------------------------
-
-## 0.33.0
-
-Released 2022-01-05.
-
-### Added
-
-* Compiled wasm modules may now optionally omit debugging information about
-  mapping addresses to source locations, resulting in smaller binaries.
-  [#3598](https://github.com/bytecodealliance/wasmtime/pull/3598)
-
-* The WebAssembly SIMD proposal is now enabled by default.
-  [#3601](https://github.com/bytecodealliance/wasmtime/pull/3601)
-
---------------------------------------------------------------------------------
-
-## 0.32.1
-
-Released 2022-01-04.
-
-### Fixed
-
-* Cranelift: remove recently-added build dependency on `sha2` to allow usage in
-  some dependency-sensitive environments, by computing ISLE manifest hashes
-  with a different hash function.
-  [#3619](https://github.com/bytecodealliance/wasmtime/pull/3619)
-
-* Cranelift: fixed 8- and 16-bit behavior of popcount (bit population count)
-  instruction. Does not affect Wasm frontend.
-  [#3617](https://github.com/bytecodealliance/wasmtime/pull/3617)
-
-* Cranelift: fixed miscompilation of 8- and 16-bit bit-rotate instructions.
-  Does not affect Wasm frontend.
-  [#3610](https://github.com/bytecodealliance/wasmtime/pull/3610)
-
---------------------------------------------------------------------------------
-
-## 0.32.0
-
-Released 2021-12-13.
-
-### Added
-
-* A new configuration option has been added to force using a "static" memory
-  style to automatically limit growth of memories in some configurations.
-  [#3503](https://github.com/bytecodealliance/wasmtime/pull/3503)
-
-* The `InstancePre<T>` type now implements `Clone`.
-  [#3510](https://github.com/bytecodealliance/wasmtime/pull/3510)
-
-* Cranelift's instruction selection process has begun to be migrated towards the
-  ISLE compiler and definition language.
-  [#3506](https://github.com/bytecodealliance/wasmtime/pull/3506)
-
-* A `pooling-allocator` feature has been added, which is on-by-default, to
-  disable the pooling allocator at compile time.
-  [#3514](https://github.com/bytecodealliance/wasmtime/pull/3514)
-
-### Fixed
-
-* A possible panic when parsing a WebAssembly `name` section has been fixed.
-  [#3509](https://github.com/bytecodealliance/wasmtime/pull/3509)
-
-* Generating native DWARF information for some C-produced modules has been
-  fixed, notably those where there may be DWARF about dead code.
-  [#3498](https://github.com/bytecodealliance/wasmtime/pull/3498)
-
-* A number of SIMD code generation bugs have been fixed in the x64 backend
-  by migrating their lowerings to ISLE.
-
---------------------------------------------------------------------------------
-
-## 0.31.0
-
-Released 2021-10-29.
-
-### Added
-
-* New `Func::new_unchecked` and `Func::call_unchecked` APIs have been added with
-  accompanying functions in the C API to improve the performance of calls into
-  wasm and the host in the C API.
-  [#3350](https://github.com/bytecodealliance/wasmtime/pull/3350)
-
-* Release binaries are now available for the s390x-unknown-linux-gnu
-  architecture.
-  [#3372](https://github.com/bytecodealliance/wasmtime/pull/3372)
-
-* A new `ResourceLimiterAsync` trait is added which allows asynchronous blocking
-  of WebAssembly on instructions such as `memory.grow`.
-  [#3393](https://github.com/bytecodealliance/wasmtime/pull/3393)
-
-### Changed
-
-* The `Func::call` method now takes a slice to write the results into rather
-  than returning a boxed slice.
-  [#3319](https://github.com/bytecodealliance/wasmtime/pull/3319)
-
-* Trampolines are now covered when jitdump profiling is enabled.
-  [#3344](https://github.com/bytecodealliance/wasmtime/pull/3344)
-
-### Fixed
-
-* Debugging with GDB has been fixed on Windows.
-  [#3373](https://github.com/bytecodealliance/wasmtime/pull/3373)
-
-* Some quadradic behavior in Wasmtime's compilation of modules has been fixed.
-  [#3469](https://github.com/bytecodealliance/wasmtime/pull/3469)
-  [#3466](https://github.com/bytecodealliance/wasmtime/pull/3466)
-
-* Bounds-checks for wasm memory accesses in certain non-default configurations
-  have been fixed to correctly allow loads at the end of the address space.
-  [#3462](https://github.com/bytecodealliance/wasmtime/pull/3462)
-
-* When type-checking memories and tables for satisfying instance imports the
-  runtime size of the table/memory is now consulted instead of the object's
-  original type.
-  [#3450](https://github.com/bytecodealliance/wasmtime/pull/3450)
-
-### Removed
-
-* The Lightbeam backend has been removed, as per [RFC 14].
-  [#3390](https://github.com/bytecodealliance/wasmtime/pull/3390)
-
-[RFC 14]: https://github.com/bytecodealliance/rfcs/pull/14
-
-* Cranelift's old x86 backend has been removed, as per [RFC 12].
-  [#3309](https://github.com/bytecodealliance/wasmtime/pull/3009)
-
-[RFC 12]: https://github.com/bytecodealliance/rfcs/pull/12
-
-## 0.30.0
-
-Released 2021-09-17.
-
-### Security Fixes
-
-* [CVE-2021-39216](https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-v4cp-h94r-m7xf):
-  Fixed a use after free passing `externref`s to Wasm in Wasmtime.
-
-* [CVE-2021-39218](https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-4873-36h9-wv49):
-  Fixed an out-of-bounds read/write and invalid free with `externref`s and GC
-  safepoints in Wasmtime.
-
-* [CVE-2021-39219](https://github.com/bytecodealliance/wasmtime/security/advisories/GHSA-q879-9g95-56mx):
-  Fixed a bug where using two different `Engine`s with the same `Linker`-define
-  functions caused unsafety without `unsafe` blocks.
-
-### Added
-
-* Added experimental support for the in-progress 64-bit memories Wasm proposal.
-
-* Added support to build Wasmtime without the compiler. This lets you run
-  pre-compiled Wasm modules, without the ability (or potential attack surface)
-  of compiling new Wasm modules. The compilation functionality is gated by the
-  on-by-default `cranelift` cargo feature.
-
-* Added support for NaN canonicalization with SIMD vectors.
-
-* Added support for differential fuzzing against V8's Wasm engine.
-
-* Added support for fuzzing against the Wasm spec interpreter.
-
-* Enabled SIMD fuzzing on oss-fuzz.
-
-### Changed
-
-* A variety of performance improvements to loading pre-compiled modules.
-
-* A variety of performance improvements to function calls, both through Rust and
-  the C API.
-
-* Leaf functions that do not use the stack no longer bump the frame pointer on
-  aarch64 and s390x.
-
-* Many updates and expanded instruction support to the in-progress CLIF
-  interpreter.
-
-* Expanded fuzzing of reference types and GC.
-
-### Fixed
-
-* A number of fixes to both aarch64 and x86_64 support for the Wasm SIMD
-  proposal and the underlying CLIF vector instructions.
-
-* Fixed a potential infinite loop in the SSA computation for
-  `cranelift-frontend`. This was not reachable from `cranelift-wasm` or
-  Wasmtime, but might have affected general Cranelift users.
-
-### Removed
-
-* The `wasmtime wasm2obj` subcommand has been removed. Generating raw object
-  files for linking natively is no longer supported. Use the `wasmtime compile`
-  subcommand to pre-compile a Wasm module and `wasmtime run` to run pre-compiled
-  Wasm modules.
-
-## 0.29.0
-
-Released 2021-08-02.
-
-### Changed
-
-* Instance exports are now loaded lazily from instances instead of eagerly as
-  they were before. This is an internal-only change and is not a breaking
-  change.
-  [#2984](https://github.com/bytecodealliance/wasmtime/pull/2984)
-
-* All linear memories created by Wasmtime will now, by default, have guard pages
-  in front of them in addition to after them. This is intended to help mitigate
-  future bugs in Cranelift, should they arise.
-  [#2977](https://github.com/bytecodealliance/wasmtime/pull/2977)
-
-* Linear memories now correctly support a maximum size of 4GB. Previously, the
-  limit field was 32 bits, which did not properly support a full 4GB memory.
-  This update is also a necessary change in preparation for future memory64
-  support.
-  [#3013](https://github.com/bytecodealliance/wasmtime/pull/3013)
-  [#3134](https://github.com/bytecodealliance/wasmtime/pull/3134)
-
-* Injection counts of fuel into a `wasmtime::Store` now uses a u64 instead of a
-  u32.
-  [#3048](https://github.com/bytecodealliance/wasmtime/pull/3048)
-
-### Added
-
-* Support for `i128` has improved in the AArch64 backend.
-  [#2959](https://github.com/bytecodealliance/wasmtime/pull/2959)
-  [#2975](https://github.com/bytecodealliance/wasmtime/pull/2975)
-  [#2985](https://github.com/bytecodealliance/wasmtime/pull/2985)
-  [#2990](https://github.com/bytecodealliance/wasmtime/pull/2990)
-  [#3002](https://github.com/bytecodealliance/wasmtime/pull/3002)
-  [#3004](https://github.com/bytecodealliance/wasmtime/pull/3004)
-  [#3005](https://github.com/bytecodealliance/wasmtime/pull/3005)
-  [#3008](https://github.com/bytecodealliance/wasmtime/pull/3008)
-  [#3027](https://github.com/bytecodealliance/wasmtime/pull/3027)
-
-* The s390x backend now supports z14 and atomics.
-  [#2988](https://github.com/bytecodealliance/wasmtime/pull/2988)
-  [#2991](https://github.com/bytecodealliance/wasmtime/pull/2991)
-
-* The `wasmtime::Linker` type now implements `Clone`.
-  [#2993](https://github.com/bytecodealliance/wasmtime/pull/2993)
-
-* Support for the SIMD proposal on both x86\_64 and AArch64 has improved. On
-  x86\_64, all SIMD opcodes are now supported.
-  [#2997](https://github.com/bytecodealliance/wasmtime/pull/2997)
-  [#3035](https://github.com/bytecodealliance/wasmtime/pull/3035)
-  [#2982](https://github.com/bytecodealliance/wasmtime/pull/2982)
-  [#3084](https://github.com/bytecodealliance/wasmtime/pull/3084)
-  [#3082](https://github.com/bytecodealliance/wasmtime/pull/3082)
-  [#3107](https://github.com/bytecodealliance/wasmtime/pull/3107)
-  [#3105](https://github.com/bytecodealliance/wasmtime/pull/3105)
-  [#3114](https://github.com/bytecodealliance/wasmtime/pull/3114)
-  [#3070](https://github.com/bytecodealliance/wasmtime/pull/3070)
-  [#3126](https://github.com/bytecodealliance/wasmtime/pull/3126)
-
-* A `Trap` can now display its reason without also displaying the backtrace.
-  [#3033](https://github.com/bytecodealliance/wasmtime/pull/3033)
-
-* An initiall fuzzer for CLIF has been added.
-  [#3038](https://github.com/bytecodealliance/wasmtime/pull/3038)
-
-* High-level architecture documentation has been added for Wasmtime.
-  [#3019](https://github.com/bytecodealliance/wasmtime/pull/3019)
-
-* Support for multi-memory can now be configured in Wasmtime's C API.
-  [#3071](https://github.com/bytecodealliance/wasmtime/pull/3071)
-
-* The `wasmtime` crate now supports a `posix-signals-on-macos` feature to force
-  the usage of signals instead of mach ports to handle traps on macOS.
-  [#3063](https://github.com/bytecodealliance/wasmtime/pull/3063)
-
-* Wasmtime's C API now has a `wasmtime_trap_code` function to get the raw trap
-  code, if present, for a trap.
-  [#3086](https://github.com/bytecodealliance/wasmtime/pull/3086)
-
-* Wasmtime's C API now has a `wasmtime_linker_define_func` function to define a
-  store-independent function within a linker.
-  [#3122](https://github.com/bytecodealliance/wasmtime/pull/3122)
-
-* A `wasmtime::Linker::module_async` function was added as the asynchronous
-  counterpart to `wasmtime::Linker::module`.
-  [#3121](https://github.com/bytecodealliance/wasmtime/pull/3121)
-
-### Fixed
-
-* Compiling the `wasmtime` crate into a `dylib` crate type has been fixed.
-  [#3010](https://github.com/bytecodealliance/wasmtime/pull/3010)
-
-* The enter/exit hooks for WebAssembly are now executed for an instance's
-  `start` function, if present.
-  [#3001](https://github.com/bytecodealliance/wasmtime/pull/3001)
-
-* Some WASI functions in `wasi-common` have been fixed for big-endian platforms.
-  [#3016](https://github.com/bytecodealliance/wasmtime/pull/3016)
-
-* Wasmtime no longer erroneously assumes that all custom sections may contain
-  DWARF information, reducing instances of `Trap`'s `Display` implementation
-  providing misleading information to set an env var to get more information.
-  [#3083](https://github.com/bytecodealliance/wasmtime/pull/3083)
-
-* Some issues with parsing DWARF debug information have been fixed.
-  [#3116](https://github.com/bytecodealliance/wasmtime/pull/3116)
-
-## 0.28.0
-
-Released 2021-06-09.
-
-### Changed
-
-* Breaking: Wasmtime's embedding API has been redesigned, as specified in [RFC
-  11]. Rust users can now enjoy easier times with `Send` and `Sync`, and all
-  users can now more clearly manage memory, especially in the C API. Language
-  embeddings have been updated to the new API as well.
-  [#2897](https://github.com/bytecodealliance/wasmtime/pull/2897)
-
-[RFC 11]: https://github.com/bytecodealliance/rfcs/pull/11
-
-### Added
-
-* A new `InstancePre` type, created with `Linker::instantiate_pre`, has been
-  added to perform type-checking of an instance once and reduce the work done
-  for each instantiation of a module:
-  [#2962](https://github.com/bytecodealliance/wasmtime/pull/2962)
-
-* Deserialization of a module can now optionally skip checking the wasmtime
-  version string:
-  [#2945](https://github.com/bytecodealliance/wasmtime/pull/2945)
-
-* A method has been exposed to frontload per-thread initialization costs if the
-  latency of every last wasm call is important:
-  [#2946](https://github.com/bytecodealliance/wasmtime/pull/2946)
-
-* Hooks have been added for entry/exit into wasm code to allow embeddings to
-  track time and other properties about execution in a wasm environment:
-  [#2952](https://github.com/bytecodealliance/wasmtime/pull/2952)
-
-* A [C++ embedding of Wasmtime has been written][cpp].
-
-[RFC 11]: https://github.com/bytecodealliance/rfcs/pull/11
-[cpp]: https://github.com/bytecodealliance/wasmtime-cpp
-
-### Fixed
-
-* Multiple returns on macOS AArch64 have been fixed:
-  [#2956](https://github.com/bytecodealliance/wasmtime/pull/2956)
-
-## 0.27.0
-
-Released 2021-05-21.
-
-### Security Fixes
-
-* Fixed a security issue in Cranelift's x64 backend that could result in a heap
-  sandbox escape due to an incorrect sign-extension:
-  [#2913](https://github.com/bytecodealliance/wasmtime/issues/2913).
-
-### Added
-
-* Support for IBM z/Archiecture (`s390x`) machines in Cranelift and Wasmtime:
-  [#2836](https://github.com/bytecodealliance/wasmtime/pull/2836),
-  [#2837](https://github.com/bytecodealliance/wasmtime/pull/2837),
-  [#2838](https://github.com/bytecodealliance/wasmtime/pull/2838),
-  [#2843](https://github.com/bytecodealliance/wasmtime/pull/2843),
-  [#2854](https://github.com/bytecodealliance/wasmtime/pull/2854),
-  [#2870](https://github.com/bytecodealliance/wasmtime/pull/2870),
-  [#2871](https://github.com/bytecodealliance/wasmtime/pull/2871),
-  [#2872](https://github.com/bytecodealliance/wasmtime/pull/2872),
-  [#2874](https://github.com/bytecodealliance/wasmtime/pull/2874).
-
-* Improved async support in wasi-common runtime:
-  [#2832](https://github.com/bytecodealliance/wasmtime/pull/2832).
-
-* Added `Store::with_limits`, `StoreLimits`, and `ResourceLimiter` to the
-  Wasmtime API to help with enforcing resource limits at runtime. The
-  `ResourceLimiter` trait can be implemented by custom resource limiters to
-  decide if linear memories or tables can be grown.
-
-* Added `allow-unknown-exports` option for the run command:
-  [#2879](https://github.com/bytecodealliance/wasmtime/pull/2879).
-
-* Added API to notify that a `Store` has moved to a new thread:
-  [#2822](https://github.com/bytecodealliance/wasmtime/pull/2822).
-
-* Documented guidance around using Wasmtime in multithreaded contexts:
-  [#2812](https://github.com/bytecodealliance/wasmtime/pull/2812).
-  In the future, the Wasmtime API will change to allow some of its core types
-  to be Send/Sync; see the in-progress
-  [#2897](https://github.com/bytecodealliance/wasmtime/pull/2897) for details.
-
-* Support calls from native code to multiple-return-value functions:
-  [#2806](https://github.com/bytecodealliance/wasmtime/pull/2806).
-
-### Changed
-
-* Breaking: `Memory::new` has been changed to return `Result` as creating a
-  host memory object is now a fallible operation when the initial size of
-  the memory exceeds the store limits.
-
-### Fixed
-
-* Many instruction selection improvements on x64 and aarch64:
-  [#2819](https://github.com/bytecodealliance/wasmtime/pull/2819),
-  [#2828](https://github.com/bytecodealliance/wasmtime/pull/2828),
-  [#2823](https://github.com/bytecodealliance/wasmtime/pull/2823),
-  [#2862](https://github.com/bytecodealliance/wasmtime/pull/2862),
-  [#2886](https://github.com/bytecodealliance/wasmtime/pull/2886),
-  [#2889](https://github.com/bytecodealliance/wasmtime/pull/2889),
-  [#2905](https://github.com/bytecodealliance/wasmtime/pull/2905).
-
-* Improved performance of Wasmtime runtime substantially:
-  [#2811](https://github.com/bytecodealliance/wasmtime/pull/2811),
-  [#2818](https://github.com/bytecodealliance/wasmtime/pull/2818),
-  [#2821](https://github.com/bytecodealliance/wasmtime/pull/2821),
-  [#2847](https://github.com/bytecodealliance/wasmtime/pull/2847),
-  [#2900](https://github.com/bytecodealliance/wasmtime/pull/2900).
-
-* Fixed WASI issue with file metadata on Windows:
-  [#2884](https://github.com/bytecodealliance/wasmtime/pull/2884).
-
-* Fixed an issue with debug info and an underflowing (trapping) offset:
-  [#2866](https://github.com/bytecodealliance/wasmtime/pull/2866).
-
-* Fixed an issue with unwind information in the old x86 backend:
-  [#2845](https://github.com/bytecodealliance/wasmtime/pull/2845).
-
-* Fixed i32 spilling in x64 backend:
-  [#2840](https://github.com/bytecodealliance/wasmtime/pull/2840).
-
-## 0.26.0
-
-Released 2021-04-05.
-
-### Added
-
-* Added the `wasmtime compile` command to support AOT compilation of Wasm
-  modules. This adds the `Engine::precompile_module` method. Also added the
-  `Config::target` method to change the compilation target of the
-  configuration. This can be used in conjunction with
-  `Engine::precompile_module` to target a different host triple than the
-  current one.
-  [#2791](https://github.com/bytecodealliance/wasmtime/pull/2791)
-
-* Support for macOS on aarch64 (Apple M1 Silicon), including Apple-specific
-  calling convention details and unwinding/exception handling using Mach ports.
-  [#2742](https://github.com/bytecodealliance/wasmtime/pull/2742),
-  [#2723](https://github.com/bytecodealliance/wasmtime/pull/2723)
-
-* A number of SIMD instruction implementations in the new x86-64 backend.
-  [#2771](https://github.com/bytecodealliance/wasmtime/pull/2771)
-
-* Added the `Config::cranelift_flag_enable` method to enable setting Cranelift
-  boolean flags or presets in a config.
-
-* Added CLI option `--cranelift-enable` to enable boolean settings and ISA presets.
-
-* Deduplicate function signatures in Wasm modules.
-  [#2772](https://github.com/bytecodealliance/wasmtime/pull/2772)
-
-* Optimize overheads of calling into Wasm functions.
-  [#2757](https://github.com/bytecodealliance/wasmtime/pull/2757),
-  [#2759](https://github.com/bytecodealliance/wasmtime/pull/2759)
-
-* Improvements related to Module Linking: compile fewer trampolines;
-
-  [#2774](https://github.com/bytecodealliance/wasmtime/pull/2774)
-
-* Re-export sibling crates from `wasmtime-wasi` to make embedding easier
-  without needing to match crate versions.
-  [#2776](https://github.com/bytecodealliance/wasmtime/pull/2776)
-
-### Changed
-
-* Switched the default compiler backend on x86-64 to Cranelift's new backend.
-  This should not have any user-visible effects other than possibly runtime
-  performance improvements. The old backend is still available with the
-  `old-x86-backend` feature flag to the `cranelift-codegen` or `wasmtime`
-  crates, or programmatically with `BackendVariant::Legacy`. We plan to
-  maintain the old backend for at least one more release and ensure it works on
-  CI.
-  [#2718](https://github.com/bytecodealliance/wasmtime/pull/2718)
-
-* Breaking: `Module::deserialize` has been removed in favor of `Module::new`.
-
-* Breaking: `Config::cranelift_clear_cpu_flags` was removed. Use `Config::target`
-  to clear the CPU flags for the host's target.
-
-* Breaking: `Config::cranelift_other_flag` was renamed to `Config::cranelift_flag_set`.
-
-* CLI changes:
-  * Wasmtime CLI options to enable WebAssembly features have been replaced with
-    a singular `--wasm-features` option. The previous options are still
-    supported, but are not displayed in help text.
-  * Breaking: the CLI option `--cranelift-flags` was changed to
-    `--cranelift-set`.
-  * Breaking: the CLI option `--enable-reference-types=false` has been changed
-    to `--wasm-features=-reference-types`.
-  * Breaking: the CLI option `--enable-multi-value=false` has been changed to
-    `--wasm-features=-multi-value`.
-  * Breaking: the CLI option `--enable-bulk-memory=false` has been changed to
-    `--wasm-features=-bulk-memory`.
-
-* Improved error-reporting in wiggle.
-  [#2760](https://github.com/bytecodealliance/wasmtime/pull/2760)
-
-* Make WASI sleeping fallible (some systems do not support sleep).
-  [#2756](https://github.com/bytecodealliance/wasmtime/pull/2756)
-
-* WASI: Support `poll_oneoff` with a sleep.
-  [#2753](https://github.com/bytecodealliance/wasmtime/pull/2753)
-
-* Allow a `StackMapSink` to be passed when defining functions with
-  `cranelift-module`.
-  [#2739](https://github.com/bytecodealliance/wasmtime/pull/2739)
-
-* Some refactoring in new x86-64 backend to prepare for VEX/EVEX (e.g.,
-  AVX-512) instruction encodings to be supported.
-  [#2799](https://github.com/bytecodealliance/wasmtime/pull/2799)
-
-### Fixed
-
-* Fixed a corner case in `srem` (signed remainder) in the new x86-64 backend:
-  `INT_MIN % -1` should return `0`, rather than trapping. This only occurred
-  when `avoid_div_traps == false` was set by the embedding.
-  [#2763](https://github.com/bytecodealliance/wasmtime/pull/2763)
-
-* Fixed a memory leak of the `Store` when an instance traps.
-  [#2803](https://github.com/bytecodealliance/wasmtime/pull/2803)
-
-* Some fuzzing-related fixes.
-  [#2788](https://github.com/bytecodealliance/wasmtime/pull/2788),
-  [#2770](https://github.com/bytecodealliance/wasmtime/pull/2770)
-
-* Fixed memory-initialization bug in uffd allocator that could copy into the
-  wrong destination under certain conditions. Does not affect the default
-  wasmtime instance allocator.
-  [#2801](https://github.com/bytecodealliance/wasmtime/pull/2801)
-
-* Fix printing of float values from the Wasmtime CLI.
-  [#2797](https://github.com/bytecodealliance/wasmtime/pull/2797)
-
-* Remove the ability for the `Linker` to instantiate modules with duplicate
-  import strings of different types.
-  [#2789](https://github.com/bytecodealliance/wasmtime/pull/2789)
-
-## 0.25.0
-
-Released 2021-03-16.
-
-### Added
-
-* An implementation of a pooling instance allocator, optionally backed by
-  `userfaultfd` on Linux, was added to improve the performance of embeddings
-  that instantiate a large number of instances continuously.
-  [#2518](https://github.com/bytecodealliance/wasmtime/pull/2518)
-
-* Host functions can now be defined on `Config` to share the function across all
-  `Store` objects connected to an `Engine`. This can improve the time it takes
-  to instantiate instances in a short-lived `Store`.
-  [#2625](https://github.com/bytecodealliance/wasmtime/pull/2625)
-
-* The `Store` object now supports having typed values attached to it which can
-  be retrieved from host functions.
-  [#2625](https://github.com/bytecodealliance/wasmtime/pull/2625)
-
-* The `wiggle` code generator now supports `async` host functions.
-  [#2701](https://github.com/bytecodealliance/wasmtime/pull/2701)
-
-### Changed
-
-* The `Func::getN{,_async}` APIs have all been removed in favor of a new
-  `Func::typed` API which should be more compact in terms of API surface area as
-  well as more flexible in how it can be used.
-  [#2719](https://github.com/bytecodealliance/wasmtime/pull/2719)
-
-* `Engine::new` has been changed from returning `Engine` to returning
-  `anyhow::Result<Engine>`. Callers of `Engine::new` will need to be updated to
-  use the `?` operator on the return value or otherwise unwrap the result to get
-  the `Engine`.
-
-### Fixed
-
-* Interpretation of timestamps in `poll_oneoff` for WASI have been fixed to
-  correctly use nanoseconds instead of microseconds.
-  [#2717](https://github.com/bytecodealliance/wasmtime/pull/2717)
-
-## 0.24.0
-
-Released 2021-03-04.
-
-### Added
-
-* Implement support for `async` functions in Wasmtime
-  [#2434](https://github.com/bytecodealliance/wasmtime/pull/2434)
-
-### Fixed
-
-* Fix preservation of the sigaltstack on macOS
-  [#2676](https://github.com/bytecodealliance/wasmtime/pull/2676)
-* Fix incorrect semver dependencies involving fs-set-times.
-  [#2705](https://github.com/bytecodealliance/wasmtime/pull/2705)
-* Fix some `i128` shift-related bugs in x64 backend.
-  [#2682](https://github.com/bytecodealliance/wasmtime/pull/2682)
-* Fix incomplete trap metadata due to multiple traps at one address
-  [#2685](https://github.com/bytecodealliance/wasmtime/pull/2685)
-
-## 0.23.0
-
-Released 2021-02-16.
-
-### Added
-
-* Support for limiting WebAssembly execution with fuel was added, including
-  support in the C API.
-  [#2611](https://github.com/bytecodealliance/wasmtime/pull/2611)
-  [#2643](https://github.com/bytecodealliance/wasmtime/pull/2643)
-* Wasmtime now has more knobs for limiting memory and table allocations
-  [#2617](https://github.com/bytecodealliance/wasmtime/pull/2617)
-* Added a method to share `Config` across machines
-  [#2608](https://github.com/bytecodealliance/wasmtime/pull/2608)
-* Added a safe memory read/write API
-  [#2528](https://github.com/bytecodealliance/wasmtime/pull/2528)
-* Added support for the experimental wasi-crypto APIs
-  [#2597](https://github.com/bytecodealliance/wasmtime/pull/2597)
-* Added an instance limit to `Config`
-  [#2593](https://github.com/bytecodealliance/wasmtime/pull/2593)
-* Implemented module-linking's outer module aliases
-  [#2590](https://github.com/bytecodealliance/wasmtime/pull/2590)
-* Cranelift now supports 128-bit operations for the new x64 backend.
-  [#2539](https://github.com/bytecodealliance/wasmtime/pull/2539)
-* Cranelift now has detailed debug-info (DWARF) support in new backends (initially x64).
-  [#2565](https://github.com/bytecodealliance/wasmtime/pull/2565)
-* Cranelift now uses the `POPCNT`, `TZCNT`, and `LZCNT`, as well as SSE 4.1
-  rounding instructions on x64 when available.
-* Cranelift now uses the `CNT`, instruction on aarch64 when available.
-
-### Changed
-
-* A new WASI implementation built on the new
-  [`cap-std`](https://github.com/bytecodealliance/cap-std) crate was added,
-  replacing the previous implementation. This brings improved robustness,
-  portability, and performance.
-
-* `wasmtime_wasi::WasiCtxBuilder` moved to
-  `wasi_cap_std_sync::WasiCtxBuilder`.
-
-* The WebAssembly C API is updated, with a few minor API changes
-  [#2579](https://github.com/bytecodealliance/wasmtime/pull/2579)
-
-### Fixed
-
-* Fixed a panic in WASI `fd_readdir` on large directories
-  [#2620](https://github.com/bytecodealliance/wasmtime/pull/2620)
-* Fixed a memory leak with command modules
-  [#2017](https://github.com/bytecodealliance/wasmtime/pull/2017)
-
---------------------------------------------------------------------------------
-
-## 0.22.0
-
-Released 2021-01-07.
-
-### Added
-
-* Experimental support for [the module-linking
-  proposal](https://github.com/WebAssembly/module-linking) was
-  added. [#2094](https://github.com/bytecodealliance/wasmtime/pull/2094)
-
-* Added support for [the reference types
-  proposal](https://webassembly.github.io/reference-types) on the aarch64
-  architecture. [#2410](https://github.com/bytecodealliance/wasmtime/pull/2410)
-
-* Experimental support for [wasi-nn](https://github.com/WebAssembly/wasi-nn) was
-  added. [#2208](https://github.com/bytecodealliance/wasmtime/pull/2208)
-
-### Changed
-
-### Fixed
-
-* Fixed an issue where the `select` instruction didn't accept `v128` SIMD
-  operands. [#2391](https://github.com/bytecodealliance/wasmtime/pull/2391)
-
-* Fixed an issue where Wasmtime could potentially use the wrong stack map during
-  GCs, leading to a
-  panic. [#2396](https://github.com/bytecodealliance/wasmtime/pull/2396)
-
-* Fixed an issue where if a host-defined function erroneously returned a value
-  from a different store, that value would be
-  leaked. [#2424](https://github.com/bytecodealliance/wasmtime/pull/2424)
-
-* Fixed a bug where in certain cases if a module's instantiation failed, it
-  could leave trampolines in the store that referenced the no-longer-valid
-  instance. These trampolines could be reused in future instantiations, leading
-  to use after free bugs.
-  [#2408](https://github.com/bytecodealliance/wasmtime/pull/2408)
-
-* Fixed a miscompilation on aarch64 where certain instructions would read `SP`
-  instead of the zero register. This could only affect you if you explicitly
-  enabled the Wasm SIMD
-  proposal. [#2548](https://github.com/bytecodealliance/wasmtime/pull/2548)
-
---------------------------------------------------------------------------------
-
-## 0.21.0
-
-Released 2020-11-05.
-
-### Added
-
-* Experimental support for the multi-memory proposal was added.
-  [#2263](https://github.com/bytecodealliance/wasmtime/pull/2263)
-
-* The `Trap::trap_code` API enables learning what kind of trap was raised.
-  [#2309](https://github.com/bytecodealliance/wasmtime/pull/2309)
-
-### Changed
-
-* WebAssembly module validation is now parallelized.
-  [#2059](https://github.com/bytecodealliance/wasmtime/pull/2059)
-
-* Documentation is now available at docs.wasmtime.dev.
-  [#2317](https://github.com/bytecodealliance/wasmtime/pull/2317)
-
-* Windows now compiles like other platforms with a huge guard page instead of
-  having its own custom limit which made modules compile and run more slowly.
-  [#2326](https://github.com/bytecodealliance/wasmtime/pull/2326)
-
-* The size of the cache entry for serialized modules has been greatly reduced.
-  [#2321](https://github.com/bytecodealliance/wasmtime/pull/2321)
-  [#2322](https://github.com/bytecodealliance/wasmtime/pull/2322)
-  [#2324](https://github.com/bytecodealliance/wasmtime/pull/2324)
-  [#2325](https://github.com/bytecodealliance/wasmtime/pull/2325)
-
-* The `FuncType` API constructor and accessors are now iterator-based.
-  [#2365](https://github.com/bytecodealliance/wasmtime/pull/2365)
-
-### Fixed
-
-* A panic in compiling reference-types-using modules has been fixed.
-  [#2350](https://github.com/bytecodealliance/wasmtime/pull/2350)
-
---------------------------------------------------------------------------------
-
-## 0.20.0
-
-Released 2020-09-23.
-
-### Added
-
-* Support for explicitly serializing and deserializing compiled wasm modules has
-  been added.
-  [#2020](https://github.com/bytecodealliance/wasmtime/pull/2020)
-
-* A `wasmtime_store_gc` C API was added to run GC for `externref`.
-  [#2052](https://github.com/bytecodealliance/wasmtime/pull/2052)
-
-* Support for atomics in Cranelift has been added. Support is not fully
-  implemented in Wasmtime at this time, however.
-  [#2077](https://github.com/bytecodealliance/wasmtime/pull/2077)
-
-* The `Caller::get_export` function is now implemented for `Func` references as
-  well.
-  [#2108](https://github.com/bytecodealliance/wasmtime/pull/2108)
-
-### Fixed
-
-* Leaks in the C API have been fixed.
-  [#2040](https://github.com/bytecodealliance/wasmtime/pull/2040)
-
-* The `wasm_val_copy` C API has been fixed for reference types.
-  [#2041](https://github.com/bytecodealliance/wasmtime/pull/2041)
-
-* Fix a panic with `Func::new` and reference types when the store doesn't have
-  reference types enabled.
-  [#2039](https://github.com/bytecodealliance/wasmtime/pull/2039)
-
---------------------------------------------------------------------------------
-
-## 0.19.0
-
-Released 2020-07-14.
-
-### Added
-
-* The [WebAssembly reference-types proposal][reftypes] is now supported in
-  Wasmtime and the C API.
-  [#1832](https://github.com/bytecodealliance/wasmtime/pull/1832),
-  [#1882](https://github.com/bytecodealliance/wasmtime/pull/1882),
-  [#1894](https://github.com/bytecodealliance/wasmtime/pull/1894),
-  [#1901](https://github.com/bytecodealliance/wasmtime/pull/1901),
-  [#1923](https://github.com/bytecodealliance/wasmtime/pull/1923),
-  [#1969](https://github.com/bytecodealliance/wasmtime/pull/1969),
-  [#1973](https://github.com/bytecodealliance/wasmtime/pull/1973),
-  [#1982](https://github.com/bytecodealliance/wasmtime/pull/1982),
-  [#1984](https://github.com/bytecodealliance/wasmtime/pull/1984),
-  [#1991](https://github.com/bytecodealliance/wasmtime/pull/1991),
-  [#1996](https://github.com/bytecodealliance/wasmtime/pull/1996)
-
-* The [WebAssembly simd proposal's][simd] spec tests now pass in Wasmtime.
-  [#1765](https://github.com/bytecodealliance/wasmtime/pull/1765),
-  [#1876](https://github.com/bytecodealliance/wasmtime/pull/1876),
-  [#1941](https://github.com/bytecodealliance/wasmtime/pull/1941),
-  [#1957](https://github.com/bytecodealliance/wasmtime/pull/1957),
-  [#1990](https://github.com/bytecodealliance/wasmtime/pull/1990),
-  [#1994](https://github.com/bytecodealliance/wasmtime/pull/1994)
-
-* Wasmtime can now be compiled without the usage of threads for parallel
-  compilation, although this is still enabled by default.
-  [#1903](https://github.com/bytecodealliance/wasmtime/pull/1903)
-
-* The C API is [now
-  documented](https://bytecodealliance.github.io/wasmtime/c-api/).
-  [#1928](https://github.com/bytecodealliance/wasmtime/pull/1928),
-  [#1959](https://github.com/bytecodealliance/wasmtime/pull/1959),
-  [#1968](https://github.com/bytecodealliance/wasmtime/pull/1968)
-
-* A `wasmtime_linker_get_one_by_name` function was added to the C API.
-  [#1897](https://github.com/bytecodealliance/wasmtime/pull/1897)
-
-* A `wasmtime_trap_exit_status` function was added to the C API.
-  [#1912](https://github.com/bytecodealliance/wasmtime/pull/1912)
-
-* Compilation for the `aarch64-linux-android` target should now work, although
-  keep in mind this platform is not fully tested still.
-  [#2002](https://github.com/bytecodealliance/wasmtime/pull/2002)
-
-[reftypes]: https://github.com/WebAssembly/reference-types
-
-### Fixed
-
-* Runtime warnings when using Wasmtime on musl have been fixed.
-  [#1914](https://github.com/bytecodealliance/wasmtime/pull/1914)
-
-* A bug affecting Windows unwind information with functions that have spilled
-  floating point registers has been fixed.
-  [#1983](https://github.com/bytecodealliance/wasmtime/pull/1983)
-
-### Changed
-
-* Wasmtime's default branch and development now happens on the `main` branch
-  instead of `master`.
-  [#1924](https://github.com/bytecodealliance/wasmtime/pull/1924)
-
-### Removed
-
-* The "host info" support in the C API has been removed since it was never fully
-  or correctly implemented.
-  [#1922](https://github.com/bytecodealliance/wasmtime/pull/1922)
-
-* Support for the `*_same` functions in the C API has been removed in the same
-  vein as the host info APIs.
-  [#1926](https://github.com/bytecodealliance/wasmtime/pull/1926)
-
---------------------------------------------------------------------------------
-
-## 0.18.0
-
-Release 2020-06-09.
-
-### Added
-
-The `WasmTy` trait is now implemented for `u32` and `u64`.
-
-  [#1808](https://github.com/bytecodealliance/wasmtime/pull/1808)
-
---------------------------------------------------------------------------------
-
-## 0.17.0
-
-Released 2020-06-01.
-
-### Added
-
-* The [Commands and Reactors ABI] is now supported in the Rust API. `Linker::module`
-  loads a module and automatically handles Commands and Reactors semantics.
-
-  [#1565](https://github.com/bytecodealliance/wasmtime/pull/1565)
-
-[Commands and Reactors ABI]: https://github.com/WebAssembly/WASI/blob/master/design/application-abi.md#current-unstable-abi
-
-The `Table::grow` function now returns the previous table size, making it consistent
-with the `table.grow` instruction.
-
-  [#1653](https://github.com/bytecodealliance/wasmtime/pull/1653)
-
-New Wasmtime-specific C APIs for working with tables were added which provide more
-detailed error information and which make growing a table more consistent with the
-`table.grow` instruction as well.
-
-  [#1654](https://github.com/bytecodealliance/wasmtime/pull/1654)
-
-The C API now includes support for enabling logging in Wasmtime.
-
-  [#1737](https://github.com/bytecodealliance/wasmtime/pull/1737)
-
-### Changed
-
-The WASI `proc_exit` function no longer exits the host process. It now unwinds the
-callstack back to the wasm entrypoint, and the exit value is available from the
-`Trap::i32_exit_status` method.
-
-  [#1646](https://github.com/bytecodealliance/wasmtime/pull/1646)
-
-The WebAssembly [multi-value](https://github.com/WebAssembly/multi-value/) proposal
-is now enabled by default.
-
-  [#1667](https://github.com/bytecodealliance/wasmtime/pull/1667)
-
-The Rust API does not require a store provided during `Module::new` operation. The `Module` can be send accross threads and instantiate for a specific store. The `Instance::new` now requires the store.
-
-  [#1761](https://github.com/bytecodealliance/wasmtime/pull/1761)
-
---------------------------------------------------------------------------------
-
-## 0.16.0
-
-Released 2020-04-29.
-
-### Added
-
-* The `Instance` struct has new accessors, `get_func`, `get_table`,
-  `get_memory`, and `get_global` for quickly looking up exported
-  functions, tables, memories, and globals by name.
-  [#1524](https://github.com/bytecodealliance/wasmtime/pull/1524)
-
-* The C API has a number of new `wasmtime_*` functions which return error
-  objects to get detailed error information when an API fails.
-  [#1467](https://github.com/bytecodealliance/wasmtime/pull/1467)
-
-* Users now have fine-grained control over creation of instances of `Memory`
-  with a new `MemoryCreator` trait.
-  [#1400](https://github.com/bytecodealliance/wasmtime/pull/1400)
-
-* Go bindings for Wasmtime are [now available][go-bindings].
-  [#1481](https://github.com/bytecodealliance/wasmtime/pull/1481)
-
-* APIs for looking up values in a `Linker` have been added.
-  [#1480](https://github.com/bytecodealliance/wasmtime/pull/1480)
-
-* Preliminary support for AArch64, also known as ARM64.
-  [#1581](https://github.com/bytecodealliance/wasmtime/pull/1581)
-
-[go-bindings]: https://github.com/bytecodealliance/wasmtime-go
-
-### Changed
-
-* `Instance::exports` now returns `Export` objects which contain
-  the `name`s of the exports in addition to their `Extern` definitions,
-  so it's no longer necessary to use `Module::exports` to obtain the
-  export names.
-  [#1524](https://github.com/bytecodealliance/wasmtime/pull/1524)
-
-* The `Func::call` API has changed its error type from `Trap` to `anyhow::Error`
-  to distinguish between wasm traps and runtime violations (like the wrong
-  number of parameters).
-  [#1467](https://github.com/bytecodealliance/wasmtime/pull/1467)
-
-* A number of `wasmtime_linker_*` and `wasmtime_config_*` C APIs have new type
-  signatures which reflect returning errors.
-  [#1467](https://github.com/bytecodealliance/wasmtime/pull/1467)
-
-* Bindings for .NET have moved to
-  https://github.com/bytecodealliance/wasmtime-dotnet.
-  [#1477](https://github.com/bytecodealliance/wasmtime/pull/1477)
-
-* Passing too many imports to `Instance::new` is now considered an error.
-  [#1478](https://github.com/bytecodealliance/wasmtime/pull/1478)
-
-### Fixed
-
-* Spurious segfaults due to out-of-stack conditions when handling signals have
-  been fixed.
-  [#1315](https://github.com/bytecodealliance/wasmtime/pull/1315)
-
---------------------------------------------------------------------------------
-
-## 0.15.0
-
-Released 2020-03-31.
-
-### Fixed
-
-Full release produced for all artifacts to account for hiccups in 0.13.0 and
-0.14.0.
-
---------------------------------------------------------------------------------
-
-## 0.14.0
-
-*This version ended up not getting a full release*
-
-### Fixed
-
-Fix build errors in wasi-common on Windows.
-
---------------------------------------------------------------------------------
-
-## 0.13.0
-
-Released 2020-03-24.
-
-### Added
-
-* Lots of documentation of `wasmtime` has been updated. Be sure to check out the
-  [book](https://bytecodealliance.github.io/wasmtime/) and [API
-  documentation](https://bytecodealliance.github.io/wasmtime/api/wasmtime/)!
-
-* All wasmtime example programs are now in a top-level `examples` directory and
-  are available in both C and Rust.
-  [#1286](https://github.com/bytecodealliance/wasmtime/pull/1286)
-
-* A `wasmtime::Linker` type was added to conveniently link link wasm modules
-  together and create instances that reference one another.
-  [#1384](https://github.com/bytecodealliance/wasmtime/pull/1384)
-
-* Wasmtime now has "jitdump" support enabled by default which allows [profiling
-  wasm code on linux][jitdump].
-  [#1310](https://github.com/bytecodealliance/wasmtime/pull/1310)
-
-* The `wasmtime::Caller` type now exists as a first-class way to access the
-  caller's exports, namely memory, when implementing host APIs. This can be the
-  first argument of functions defined with `Func::new` or `Func::wrap` which
-  allows easily implementing methods which take a pointer into wasm memory. Note
-  that this only works for accessing the caller's `Memory` for now and it must
-  be exported. This will eventually be replaced with a more general-purpose
-  mechanism like interface types.
-  [#1290](https://github.com/bytecodealliance/wasmtime/pull/1290)
-
-* The bulk memory proposal has been fully implemented.
-  [#1264](https://github.com/bytecodealliance/wasmtime/pull/1264)
-  [#976](https://github.com/bytecodealliance/wasmtime/pull/976)
-
-* Virtual file support has been added to `wasi-common`.
-  [#701](https://github.com/bytecodealliance/wasmtime/pull/701)
-
-* The C API has been enhanced with a Wasmtime-specific `wasmtime_wat2wasm` to
-  parse `*.wat` files via the C API.
-  [#1206](https://github.com/bytecodealliance/wasmtime/pull/1206)
-
-[jitdump]: https://bytecodealliance.github.io/wasmtime/examples-profiling.html
-
-### Changed
-
-* The `wast` and `wasm2obj` standalone binaries have been removed. They're
-  available via the `wasmtime wast` and `wasmtime wasm2obj` subcommands.
-  [#1372](https://github.com/bytecodealliance/wasmtime/pull/1372)
-
-* The `wasi-common` crate now uses the new `wiggle` crate to auto-generate a
-  trait which is implemented for the current wasi snapshot.
-  [#1202](https://github.com/bytecodealliance/wasmtime/pull/1202)
-
-* Wasmtime no longer has a dependency on a C++ compiler.
-  [#1365](https://github.com/bytecodealliance/wasmtime/pull/1365)
-
-* The `Func::wrapN` APIs have been consolidated into one `Func::wrap` API.
-  [#1363](https://github.com/bytecodealliance/wasmtime/pull/1363)
-
-* The `Callable` trait has been removed and now `Func::new` takes a closure
-  directly.
-  [#1363](https://github.com/bytecodealliance/wasmtime/pull/1363)
-
-* The Cranelift repository has been merged into the Wasmtime repository.
-
-* Support for interface types has been temporarily removed.
-  [#1292](https://github.com/bytecodealliance/wasmtime/pull/1292)
-
-* The exit code of the `wasmtime` CLI has changed if the program traps.
-  [#1274](https://github.com/bytecodealliance/wasmtime/pull/1274)
-
-* The `wasmtime` CLI now logs to stderr by default and the `-d` flag has been
-  renamed to `--log-to-file`.
-  [#1266](https://github.com/bytecodealliance/wasmtime/pull/1266)
-
-* Values cannot cross `Store` objects, meaning you can't instantiate a module
-  with values from different stores nor pass values from different stores into
-  methods.
-  [#1016](https://github.com/bytecodealliance/wasmtime/pull/1016)
-
---------------------------------------------------------------------------------
-
-## 0.12.0
-
-Released 2020-02-26.
-
-### Added
-
-* Support for the [WebAssembly text annotations proposal][annotations-proposal]
-  has been added.
-  [#998](https://github.com/bytecodealliance/wasmtime/pull/998)
-
-* An initial C API for instantiating WASI modules has been added.
-  [#977](https://github.com/bytecodealliance/wasmtime/pull/977)
-
-* A new suite of `Func::getN` functions have been added to the `wasmtime` API to
-  call statically-known function signatures in a highly optimized fashion.
-  [#955](https://github.com/bytecodealliance/wasmtime/pull/955)
-
-* Initial support for profiling JIT code through perf jitdump has been added.
-  [#360](https://github.com/bytecodealliance/wasmtime/pull/360)
-
-* More CLI flags corresponding to proposed WebAssembly features have been added.
-  [#917](https://github.com/bytecodealliance/wasmtime/pull/917)
-
-[annotations-proposal]: https://github.com/webassembly/annotations
-
-### Changed
-
-* The `wasmtime` CLI as well as embedding API will optimize WebAssembly code by
-  default now.
-  [#973](https://github.com/bytecodealliance/wasmtime/pull/973)
-  [#988](https://github.com/bytecodealliance/wasmtime/pull/988)
-
-* The `verifier` pass in Cranelift is now no longer run by default when using
-  the embedding API.
-  [#882](https://github.com/bytecodealliance/wasmtime/pull/882)
-
-### Fixed
-
-* Code caching now accurately accounts for optimization levels, ensuring that if
-  you ask for optimized code you're not accidentally handed unoptimized code
-  from the cache.
-  [#974](https://github.com/bytecodealliance/wasmtime/pull/974)
-
-* Automated releases for tags should be up and running again, along with
-  automatic publication of the `wasmtime` Python package.
-  [#971](https://github.com/bytecodealliance/wasmtime/pull/971)
+Release notes for previous releases of Wasmtime can be found on the respective
+release branches of the Wasmtime repository.
+
+<!-- ARCHIVE_START -->
+* [24.0.x](https://github.com/bytecodealliance/wasmtime/blob/release-24.0.0/RELEASES.md)
+* [23.0.x](https://github.com/bytecodealliance/wasmtime/blob/release-23.0.0/RELEASES.md)
+* [22.0.x](https://github.com/bytecodealliance/wasmtime/blob/release-22.0.0/RELEASES.md)
+* [21.0.x](https://github.com/bytecodealliance/wasmtime/blob/release-21.0.0/RELEASES.md)
+* [20.0.x](https://github.com/bytecodealliance/wasmtime/blob/release-20.0.0/RELEASES.md)
+* [19.0.x](https://github.com/bytecodealliance/wasmtime/blob/release-19.0.0/RELEASES.md)
+* [18.0.x](https://github.com/bytecodealliance/wasmtime/blob/release-18.0.0/RELEASES.md)
+* [17.0.x](https://github.com/bytecodealliance/wasmtime/blob/release-17.0.0/RELEASES.md)
+* [16.0.x](https://github.com/bytecodealliance/wasmtime/blob/release-16.0.0/RELEASES.md)
+* [15.0.x](https://github.com/bytecodealliance/wasmtime/blob/release-15.0.0/RELEASES.md)
+* [14.0.x](https://github.com/bytecodealliance/wasmtime/blob/release-14.0.0/RELEASES.md)
+* [13.0.x](https://github.com/bytecodealliance/wasmtime/blob/release-13.0.0/RELEASES.md)
+* [12.0.x](https://github.com/bytecodealliance/wasmtime/blob/release-12.0.0/RELEASES.md)
+* [11.0.x](https://github.com/bytecodealliance/wasmtime/blob/release-11.0.0/RELEASES.md)
+* [10.0.x](https://github.com/bytecodealliance/wasmtime/blob/release-10.0.0/RELEASES.md)
+* [9.0.x](https://github.com/bytecodealliance/wasmtime/blob/release-9.0.0/RELEASES.md)
+* [8.0.x](https://github.com/bytecodealliance/wasmtime/blob/release-8.0.0/RELEASES.md)
+* [7.0.x](https://github.com/bytecodealliance/wasmtime/blob/release-7.0.0/RELEASES.md)
+* [6.0.x](https://github.com/bytecodealliance/wasmtime/blob/release-6.0.0/RELEASES.md)
+* [5.0.x](https://github.com/bytecodealliance/wasmtime/blob/release-5.0.0/RELEASES.md)
+* [4.0.x](https://github.com/bytecodealliance/wasmtime/blob/release-4.0.0/RELEASES.md)
+* [3.0.x](https://github.com/bytecodealliance/wasmtime/blob/release-3.0.0/RELEASES.md)
+* [2.0.x](https://github.com/bytecodealliance/wasmtime/blob/release-2.0.0/RELEASES.md)
+* [1.0.x](https://github.com/bytecodealliance/wasmtime/blob/release-1.0.0/RELEASES.md)
+* [0.40.x](https://github.com/bytecodealliance/wasmtime/blob/release-0.40.0/RELEASES.md)
+* [0.39.x](https://github.com/bytecodealliance/wasmtime/blob/release-0.39.0/RELEASES.md)
+* [0.38.x](https://github.com/bytecodealliance/wasmtime/blob/release-0.38.0/RELEASES.md)
+* [0.37.x](https://github.com/bytecodealliance/wasmtime/blob/release-0.37.0/RELEASES.md)
+* [0.36.x](https://github.com/bytecodealliance/wasmtime/blob/release-0.36.0/RELEASES.md)
+* [0.35.x](https://github.com/bytecodealliance/wasmtime/blob/release-0.35.0/RELEASES.md)
+* [0.34.x](https://github.com/bytecodealliance/wasmtime/blob/release-0.34.0/RELEASES.md)
+* [0.33.x](https://github.com/bytecodealliance/wasmtime/blob/release-0.33.0/RELEASES.md)
+* [0.32.x (and prior)](https://github.com/bytecodealliance/wasmtime/blob/release-0.32.0/RELEASES.md)
diff --git a/SECURITY.md b/SECURITY.md
index a1991e90af64..c1aca31e57e6 100644
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -1,3 +1,11 @@
 # Security Policy
 
-Please refer to the [Bytecode Alliance security policy](https://bytecodealliance.org/security) for details on how to report security issues in Wasmtime, our disclosure policy, and how to receive notifications about security issues.
+Please refer to the [Bytecode Alliance security
+policy](https://bytecodealliance.org/security) for details on how to report
+security issues in Wasmtime, our disclosure policy, and how to receive
+notifications about security issues.
+
+For classification of what is and what isn't a security issue please see our
+[online
+documentation](https://docs.wasmtime.dev/security-what-is-considered-a-security-vulnerability.html)
+on the subject.
diff --git a/benches/call.rs b/benches/call.rs
index 90f9beca60b2..ac6880c5119f 100644
--- a/benches/call.rs
+++ b/benches/call.rs
@@ -23,6 +23,7 @@ enum IsAsync {
     Yes,
     YesPooling,
     No,
+    NoPooling,
 }
 
 impl IsAsync {
@@ -31,12 +32,13 @@ impl IsAsync {
             IsAsync::Yes => "async",
             IsAsync::YesPooling => "async-pool",
             IsAsync::No => "sync",
+            IsAsync::NoPooling => "sync-pool",
         }
     }
     fn use_async(&self) -> bool {
         match self {
             IsAsync::Yes | IsAsync::YesPooling => true,
-            IsAsync::No => false,
+            IsAsync::No | IsAsync::NoPooling => false,
         }
     }
 }
@@ -47,14 +49,29 @@ fn engines() -> Vec<(Engine, IsAsync)> {
     #[cfg(feature = "component-model")]
     config.wasm_component_model(true);
 
+    let mut pool = PoolingAllocationConfig::default();
+    if std::env::var("WASMTIME_TEST_FORCE_MPK").is_ok() {
+        pool.memory_protection_keys(MpkEnabled::Enable);
+    }
+
     vec![
         (Engine::new(&config).unwrap(), IsAsync::No),
+        (
+            Engine::new(
+                config
+                    .clone()
+                    .allocation_strategy(InstanceAllocationStrategy::Pooling(pool.clone())),
+            )
+            .unwrap(),
+            IsAsync::NoPooling,
+        ),
         (
             Engine::new(config.async_support(true)).unwrap(),
             IsAsync::Yes,
         ),
         (
-            Engine::new(config.allocation_strategy(InstanceAllocationStrategy::pooling())).unwrap(),
+            Engine::new(config.allocation_strategy(InstanceAllocationStrategy::Pooling(pool)))
+                .unwrap(),
             IsAsync::YesPooling,
         ),
     ]
@@ -122,7 +139,7 @@ fn bench_host_to_wasm<Params, Results>(
 {
     // Benchmark the "typed" version, which should be faster than the versions
     // below.
-    c.bench_function(&format!("core - host-to-wasm - typed - {}", name), |b| {
+    c.bench_function(&format!("core - host-to-wasm - typed - {name}"), |b| {
         let typed = instance
             .get_typed_func::<Params, Results>(&mut *store, name)
             .unwrap();
@@ -138,7 +155,7 @@ fn bench_host_to_wasm<Params, Results>(
 
     // Benchmark the "untyped" version which should be the slowest of the three
     // here, but not unduly slow.
-    c.bench_function(&format!("core - host-to-wasm - untyped - {}", name), |b| {
+    c.bench_function(&format!("core - host-to-wasm - untyped - {name}"), |b| {
         let untyped = instance.get_func(&mut *store, name).unwrap();
         let params = typed_params.to_vals();
         let expected_results = typed_results.to_vals();
@@ -163,29 +180,25 @@ fn bench_host_to_wasm<Params, Results>(
 
     // Benchmark the "unchecked" version which should be between the above two,
     // but is unsafe.
-    c.bench_function(
-        &format!("core - host-to-wasm - unchecked - {}", name),
-        |b| {
-            let untyped = instance.get_func(&mut *store, name).unwrap();
-            let params = typed_params.to_vals();
-            let results = typed_results.to_vals();
-            let mut space = vec![ValRaw::i32(0); params.len().max(results.len())];
-            b.iter(|| unsafe {
-                for (i, param) in params.iter().enumerate() {
-                    space[i] = param.to_raw(&mut *store);
-                }
-                untyped
-                    .call_unchecked(&mut *store, space.as_mut_ptr(), space.len())
-                    .unwrap();
-                for (i, expected) in results.iter().enumerate() {
-                    assert_vals_eq(
-                        expected,
-                        &Val::from_raw(&mut *store, space[i], expected.ty()),
-                    );
-                }
-            })
-        },
-    );
+    c.bench_function(&format!("core - host-to-wasm - unchecked - {name}"), |b| {
+        let untyped = instance.get_func(&mut *store, name).unwrap();
+        let params = typed_params.to_vals();
+        let results = typed_results.to_vals();
+        let mut space = vec![ValRaw::i32(0); params.len().max(results.len())];
+        b.iter(|| unsafe {
+            for (i, param) in params.iter().enumerate() {
+                space[i] = param.to_raw(&mut *store).unwrap();
+            }
+            untyped
+                .call_unchecked(&mut *store, space.as_mut_ptr(), space.len())
+                .unwrap();
+            for (i, expected) in results.iter().enumerate() {
+                let ty = expected.ty(&store).unwrap();
+                let actual = Val::from_raw(&mut *store, space[i], ty);
+                assert_vals_eq(expected, &actual);
+            }
+        })
+    });
 }
 
 /// Benchmarks the overhead of calling the host from WebAssembly itself
@@ -285,9 +298,9 @@ fn wasm_to_host(c: &mut Criterion) {
 
         let mut untyped = Linker::new(&engine);
         untyped
-            .func_new("", "nop", FuncType::new([], []), |_, _, _| Ok(()))
+            .func_new("", "nop", FuncType::new(&engine, [], []), |_, _, _| Ok(()))
             .unwrap();
-        let ty = FuncType::new([ValType::I32, ValType::I64], [ValType::F32]);
+        let ty = FuncType::new(&engine, [ValType::I32, ValType::I64], [ValType::F32]);
         untyped
             .func_new(
                 "",
@@ -319,9 +332,9 @@ fn wasm_to_host(c: &mut Criterion) {
         unsafe {
             let mut unchecked = Linker::new(&engine);
             unchecked
-                .func_new_unchecked("", "nop", FuncType::new([], []), |_, _| Ok(()))
+                .func_new_unchecked("", "nop", FuncType::new(&engine, [], []), |_, _| Ok(()))
                 .unwrap();
-            let ty = FuncType::new([ValType::I32, ValType::I64], [ValType::F32]);
+            let ty = FuncType::new(&engine, [ValType::I32, ValType::I64], [ValType::F32]);
             unchecked
                 .func_new_unchecked("", "nop-params-and-results", ty, |mut caller, space| {
                     match Val::from_raw(&mut caller, space[0], ValType::I32) {
@@ -332,7 +345,7 @@ fn wasm_to_host(c: &mut Criterion) {
                         Val::I64(0) => {}
                         _ => unreachable!(),
                     }
-                    space[0] = Val::F32(0).to_raw(&mut caller);
+                    space[0] = Val::F32(0).to_raw(&mut caller).unwrap();
                     Ok(())
                 })
                 .unwrap();
@@ -351,20 +364,24 @@ fn wasm_to_host(c: &mut Criterion) {
 
         let mut typed = Linker::new(&engine);
         typed
-            .func_wrap0_async("", "nop", |caller| {
+            .func_wrap_async("", "nop", |caller, _: ()| {
                 Box::new(async {
                     drop(caller);
                 })
             })
             .unwrap();
         typed
-            .func_wrap2_async("", "nop-params-and-results", |_caller, x: i32, y: i64| {
-                Box::new(async move {
-                    assert_eq!(x, 0);
-                    assert_eq!(y, 0);
-                    0.0f32
-                })
-            })
+            .func_wrap_async(
+                "",
+                "nop-params-and-results",
+                |_caller, (x, y): (i32, i64)| {
+                    Box::new(async move {
+                        assert_eq!(x, 0);
+                        assert_eq!(y, 0);
+                        0.0f32
+                    })
+                },
+            )
             .unwrap();
         let instance = run_await(typed.instantiate_async(&mut *store, &module)).unwrap();
         bench_instance(group, store, &instance, "async-typed", is_async);
@@ -378,7 +395,7 @@ fn wasm_to_host(c: &mut Criterion) {
         desc: &str,
         is_async: IsAsync,
     ) {
-        group.bench_function(&format!("core - wasm-to-host - {} - nop", desc), |b| {
+        group.bench_function(&format!("core - wasm-to-host - {desc} - nop"), |b| {
             let run = instance
                 .get_typed_func::<u64, ()>(&mut *store, "run-nop")
                 .unwrap();
@@ -393,7 +410,7 @@ fn wasm_to_host(c: &mut Criterion) {
             })
         });
         group.bench_function(
-            &format!("core - wasm-to-host - {} - nop-params-and-results", desc),
+            &format!("core - wasm-to-host - {desc} - nop-params-and-results"),
             |b| {
                 let run = instance
                     .get_typed_func::<u64, ()>(&mut *store, "run-nop-params-and-results")
@@ -616,31 +633,28 @@ mod component {
             + Sync,
     {
         // Benchmark the "typed" version.
-        c.bench_function(
-            &format!("component - host-to-wasm - typed - {}", name),
-            |b| {
-                let typed = instance
-                    .get_typed_func::<Params, Results>(&mut *store, name)
-                    .unwrap();
-                b.iter(|| {
-                    let results = if is_async.use_async() {
-                        run_await(typed.call_async(&mut *store, typed_params)).unwrap()
-                    } else {
-                        typed.call(&mut *store, typed_params).unwrap()
-                    };
-                    assert_eq!(results, typed_results);
-                    if is_async.use_async() {
-                        run_await(typed.post_return_async(&mut *store)).unwrap()
-                    } else {
-                        typed.post_return(&mut *store).unwrap()
-                    }
-                })
-            },
-        );
+        c.bench_function(&format!("component - host-to-wasm - typed - {name}"), |b| {
+            let typed = instance
+                .get_typed_func::<Params, Results>(&mut *store, name)
+                .unwrap();
+            b.iter(|| {
+                let results = if is_async.use_async() {
+                    run_await(typed.call_async(&mut *store, typed_params)).unwrap()
+                } else {
+                    typed.call(&mut *store, typed_params).unwrap()
+                };
+                assert_eq!(results, typed_results);
+                if is_async.use_async() {
+                    run_await(typed.post_return_async(&mut *store)).unwrap()
+                } else {
+                    typed.post_return(&mut *store).unwrap()
+                }
+            })
+        });
 
         // Benchmark the "untyped" version.
         c.bench_function(
-            &format!("component - host-to-wasm - untyped - {}", name),
+            &format!("component - host-to-wasm - untyped - {name}"),
             |b| {
                 let untyped = instance.get_func(&mut *store, name).unwrap();
                 let params = typed_params.to_component_vals();
@@ -782,30 +796,23 @@ mod component {
             bench_instance(group, store, &instance, "typed", is_async);
 
             let mut untyped = component::Linker::new(&engine);
+            untyped.root().func_new("nop", |_, _, _| Ok(())).unwrap();
             untyped
                 .root()
-                .func_new(&component, "nop", |_, _, _| Ok(()))
-                .unwrap();
-            untyped
-                .root()
-                .func_new(
-                    &component,
-                    "nop-params-and-results",
-                    |_caller, params, results| {
-                        assert_eq!(params.len(), 2);
-                        match params[0] {
-                            component::Val::U32(0) => {}
-                            _ => unreachable!(),
-                        }
-                        match params[1] {
-                            component::Val::U64(0) => {}
-                            _ => unreachable!(),
-                        }
-                        assert_eq!(results.len(), 1);
-                        results[0] = component::Val::Float32(0.0);
-                        Ok(())
-                    },
-                )
+                .func_new("nop-params-and-results", |_caller, params, results| {
+                    assert_eq!(params.len(), 2);
+                    match params[0] {
+                        component::Val::U32(0) => {}
+                        _ => unreachable!(),
+                    }
+                    match params[1] {
+                        component::Val::U64(0) => {}
+                        _ => unreachable!(),
+                    }
+                    assert_eq!(results.len(), 1);
+                    results[0] = component::Val::Float32(0.0);
+                    Ok(())
+                })
                 .unwrap();
             let instance = if is_async.use_async() {
                 run_await(untyped.instantiate_async(&mut *store, &component)).unwrap()
@@ -851,7 +858,7 @@ mod component {
             desc: &str,
             is_async: IsAsync,
         ) {
-            group.bench_function(&format!("component - wasm-to-host - {} - nop", desc), |b| {
+            group.bench_function(&format!("component - wasm-to-host - {desc} - nop"), |b| {
                 let run = instance
                     .get_typed_func::<(u64,), ()>(&mut *store, "run-nop")
                     .unwrap();
@@ -868,10 +875,7 @@ mod component {
                 })
             });
             group.bench_function(
-                &format!(
-                    "component - wasm-to-host - {} - nop-params-and-results",
-                    desc
-                ),
+                &format!("component - wasm-to-host - {desc} - nop-params-and-results"),
                 |b| {
                     let run = instance
                         .get_typed_func::<(u64,), ()>(&mut *store, "run-nop-params-and-results")
diff --git a/benches/instantiation.rs b/benches/instantiation.rs
index e43bd650545e..5020478ad8f9 100644
--- a/benches/instantiation.rs
+++ b/benches/instantiation.rs
@@ -6,8 +6,8 @@ use std::process::Command;
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst};
 use std::sync::Arc;
 use std::thread;
+use wasi_common::{sync::WasiCtxBuilder, WasiCtx};
 use wasmtime::*;
-use wasmtime_wasi::{sync::WasiCtxBuilder, WasiCtx};
 
 fn store(engine: &Engine) -> Store<WasiCtx> {
     let wasi = WasiCtxBuilder::new().build();
@@ -20,7 +20,7 @@ fn instantiate(pre: &InstancePre<WasiCtx>, engine: &Engine) -> Result<()> {
     Ok(())
 }
 
-fn benchmark_name<'a>(strategy: &InstanceAllocationStrategy) -> &'static str {
+fn benchmark_name(strategy: &InstanceAllocationStrategy) -> &'static str {
     match strategy {
         InstanceAllocationStrategy::OnDemand => "default",
         InstanceAllocationStrategy::Pooling { .. } => "pooling",
@@ -48,7 +48,7 @@ fn bench_sequential(c: &mut Criterion, path: &Path) {
             // benchmark programs.
             linker.func_wrap("bench", "start", || {}).unwrap();
             linker.func_wrap("bench", "end", || {}).unwrap();
-            wasmtime_wasi::add_to_linker(&mut linker, |cx| cx).unwrap();
+            wasi_common::sync::add_to_linker(&mut linker, |cx| cx).unwrap();
             let pre = linker
                 .instantiate_pre(&module)
                 .expect("failed to pre-instantiate");
@@ -82,7 +82,7 @@ fn bench_parallel(c: &mut Criterion, path: &Path) {
             // benchmark programs.
             linker.func_wrap("bench", "start", || {}).unwrap();
             linker.func_wrap("bench", "end", || {}).unwrap();
-            wasmtime_wasi::add_to_linker(&mut linker, |cx| cx).unwrap();
+            wasi_common::sync::add_to_linker(&mut linker, |cx| cx).unwrap();
             let pre = Arc::new(
                 linker
                     .instantiate_pre(&module)
@@ -185,7 +185,7 @@ fn build_wasi_example() {
             "-p",
             "example-wasi-wasm",
             "--target",
-            "wasm32-wasi",
+            "wasm32-wasip1",
         ])
         .spawn()
         .expect("failed to run cargo to build WASI example")
@@ -193,11 +193,11 @@ fn build_wasi_example() {
         .expect("failed to wait for cargo to build")
         .success()
     {
-        panic!("failed to build WASI example for target `wasm32-wasi`");
+        panic!("failed to build WASI example for target `wasm32-wasip1`");
     }
 
     std::fs::copy(
-        "target/wasm32-wasi/release/wasi.wasm",
+        "target/wasm32-wasip1/release/wasi.wasm",
         "benches/instantiation/wasi.wasm",
     )
     .expect("failed to copy WASI example module");
@@ -219,7 +219,7 @@ fn strategies() -> impl Iterator<Item = InstanceAllocationStrategy> {
         InstanceAllocationStrategy::OnDemand,
         InstanceAllocationStrategy::Pooling({
             let mut config = PoolingAllocationConfig::default();
-            config.memory_pages(10_000);
+            config.max_memory_size(10_000 << 16);
             config
         }),
     ]
diff --git a/benches/trap.rs b/benches/trap.rs
index 979f30676445..a006c871b9bc 100644
--- a/benches/trap.rs
+++ b/benches/trap.rs
@@ -187,7 +187,7 @@ fn bench_host_wasm_frames_traps(c: &mut Criterion) {
                     let mut store = Store::new(&engine, ());
                     let host_func = Func::new(
                         &mut store,
-                        FuncType::new(vec![ValType::I32], vec![]),
+                        FuncType::new(&engine, vec![ValType::I32], vec![]),
                         |mut caller, args, _results| {
                             let f = caller.get_export("f").unwrap();
                             let f = f.into_func().unwrap();
diff --git a/benches/wasi.rs b/benches/wasi.rs
index 41dc25e3bd8a..77944071ba9e 100644
--- a/benches/wasi.rs
+++ b/benches/wasi.rs
@@ -2,8 +2,8 @@
 
 use criterion::{criterion_group, criterion_main, Criterion};
 use std::{fs::File, path::Path, time::Instant};
+use wasi_common::{sync::WasiCtxBuilder, WasiCtx};
 use wasmtime::{Engine, Linker, Module, Store, TypedFunc};
-use wasmtime_wasi::{sync::WasiCtxBuilder, WasiCtx};
 
 criterion_group!(benches, bench_wasi);
 criterion_main!(benches);
@@ -53,7 +53,7 @@ fn instantiate(wat: &[u8]) -> (Store<WasiCtx>, TypedFunc<u64, u64>) {
     let mut store = Store::new(&engine, wasi);
     let module = Module::new(&engine, wat).unwrap();
     let mut linker = Linker::new(&engine);
-    wasmtime_wasi::add_to_linker(&mut linker, |cx| cx).unwrap();
+    wasi_common::sync::add_to_linker(&mut linker, |cx| cx).unwrap();
     let instance = linker.instantiate(&mut store, &module).unwrap();
     let run = instance.get_typed_func(&mut store, "run").unwrap();
     (store, run)
@@ -77,9 +77,9 @@ fn wasi_context() -> WasiCtx {
         ])
         .unwrap()
         .preopened_dir(
-            wasmtime_wasi::Dir::open_ambient_dir(
+            wasi_common::sync::Dir::open_ambient_dir(
                 "benches/wasi",
-                wasmtime_wasi::ambient_authority(),
+                wasi_common::sync::ambient_authority(),
             )
             .unwrap(),
             "/",
diff --git a/benches/wasmtime-serve-rps.sh b/benches/wasmtime-serve-rps.sh
new file mode 100755
index 000000000000..33d83a74ab15
--- /dev/null
+++ b/benches/wasmtime-serve-rps.sh
@@ -0,0 +1,40 @@
+#!/usr/bin/env bash
+
+# Usage:
+#
+#     wasmtime-serve-rps.sh [WASMTIME-FLAGS] path/to/wasi-http-component.wasm
+#
+# For a basic WASI HTTP component, check out
+# https://github.com/sunfishcode/hello-wasi-http
+#
+# You must have the `hey` tool installed on your `$PATH`. It is available in at
+# least the `apt` and `brew` package managers, as well as a binary download via
+# its github page: https://github.com/rakyll/hey
+
+set -e
+
+repo_dir="$(dirname $0)/.."
+cargo_toml="$repo_dir/Cargo.toml"
+target_dir="$CARGO_TARGET_DIR"
+if [[ "$target_dir" == "" ]]; then
+    target_dir="$repo_dir/target"
+fi
+
+# Build Wasmtime.
+cargo build --manifest-path "$cargo_toml" --release -p wasmtime-cli
+
+# Spawn `wasmtime serve` in the background.
+"$target_dir/release/wasmtime" serve "$@" &
+pid=$!
+
+# Give it a second to print its diagnostic information and get the server up and
+# running.
+sleep 1
+
+echo 'Running `wasmtime serve` in background as pid '"$pid"
+
+# Benchmark the server!
+echo "Benchmarking for 10 seconds..."
+hey -z 10s http://0.0.0.0:8080/
+
+kill "$pid"
diff --git a/build.rs b/build.rs
index 041373eba0c3..2057d27f34c6 100644
--- a/build.rs
+++ b/build.rs
@@ -1,268 +1,36 @@
-//! Build program to generate a program which runs all the testsuites.
-//!
-//! By generating a separate `#[test]` test for each file, we allow cargo test
-//! to automatically run the files in parallel.
-
-use anyhow::Context;
 use std::env;
-use std::fmt::Write;
-use std::fs;
-use std::path::{Path, PathBuf};
+use std::path::Path;
 use std::process::Command;
 
-fn main() -> anyhow::Result<()> {
+fn main() {
     println!("cargo:rerun-if-changed=build.rs");
 
-    let out_dir = PathBuf::from(
-        env::var_os("OUT_DIR").expect("The OUT_DIR environment variable must be set"),
-    );
-    let mut out = String::new();
-
-    for strategy in &["Cranelift", "Winch"] {
-        writeln!(out, "#[cfg(test)]")?;
-        writeln!(out, "#[allow(non_snake_case)]")?;
-        if *strategy == "Winch" {
-            // We only test Winch on x86_64, for now.
-            writeln!(out, "{}", "#[cfg(all(target_arch = \"x86_64\"))]")?;
-        }
-        writeln!(out, "mod {} {{", strategy)?;
-
-        with_test_module(&mut out, "misc", |out| {
-            test_directory(out, "tests/misc_testsuite", strategy)?;
-            test_directory_module(out, "tests/misc_testsuite/multi-memory", strategy)?;
-            test_directory_module(out, "tests/misc_testsuite/simd", strategy)?;
-            test_directory_module(out, "tests/misc_testsuite/tail-call", strategy)?;
-            test_directory_module(out, "tests/misc_testsuite/threads", strategy)?;
-            test_directory_module(out, "tests/misc_testsuite/memory64", strategy)?;
-            test_directory_module(out, "tests/misc_testsuite/component-model", strategy)?;
-            test_directory_module(out, "tests/misc_testsuite/function-references", strategy)?;
-            // The testsuite of Winch is a subset of the official
-            // WebAssembly test suite, until parity is reached. This
-            // check is in place to prevent Cranelift from duplicating
-            // tests.
-            if *strategy == "Winch" {
-                test_directory_module(out, "tests/misc_testsuite/winch", strategy)?;
-            }
-            Ok(())
-        })?;
-
-        with_test_module(&mut out, "spec", |out| {
-            let spec_tests = test_directory(out, "tests/spec_testsuite", strategy)?;
-            // Skip running spec_testsuite tests if the submodule isn't checked
-            // out.
-            if spec_tests > 0 {
-                test_directory_module(out, "tests/spec_testsuite/proposals/memory64", strategy)?;
-                test_directory_module(
-                    out,
-                    "tests/spec_testsuite/proposals/function-references",
-                    strategy,
-                )?;
-                test_directory_module(
-                    out,
-                    "tests/spec_testsuite/proposals/multi-memory",
-                    strategy,
-                )?;
-                test_directory_module(out, "tests/spec_testsuite/proposals/threads", strategy)?;
-                test_directory_module(
-                    out,
-                    "tests/spec_testsuite/proposals/relaxed-simd",
-                    strategy,
-                )?;
-                test_directory_module(out, "tests/spec_testsuite/proposals/tail-call", strategy)?;
-            } else {
-                println!(
-                    "cargo:warning=The spec testsuite is disabled. To enable, run `git submodule \
-                     update --remote`."
-                );
-            }
-            Ok(())
-        })?;
-
-        writeln!(out, "}}")?;
-    }
-
-    // Write out our auto-generated tests and opportunistically format them with
-    // `rustfmt` if it's installed.
-    let output = out_dir.join("wast_testsuite_tests.rs");
-    fs::write(&output, out)?;
-    drop(Command::new("rustfmt").arg(&output).status());
-    Ok(())
-}
-
-fn test_directory_module(
-    out: &mut String,
-    path: impl AsRef<Path>,
-    strategy: &str,
-) -> anyhow::Result<usize> {
-    let path = path.as_ref();
-    let testsuite = &extract_name(path);
-    with_test_module(out, testsuite, |out| test_directory(out, path, strategy))
+    set_commit_info_for_rustc();
 }
 
-fn test_directory(
-    out: &mut String,
-    path: impl AsRef<Path>,
-    strategy: &str,
-) -> anyhow::Result<usize> {
-    let path = path.as_ref();
-    let mut dir_entries: Vec<_> = path
-        .read_dir()
-        .context(format!("failed to read {:?}", path))?
-        .map(|r| r.expect("reading testsuite directory entry"))
-        .filter_map(|dir_entry| {
-            let p = dir_entry.path();
-            let ext = p.extension()?;
-            // Only look at wast files.
-            if ext != "wast" {
-                return None;
-            }
-            // Ignore files starting with `.`, which could be editor temporary files
-            if p.file_stem()?.to_str()?.starts_with('.') {
-                return None;
-            }
-            Some(p)
-        })
-        .collect();
-
-    dir_entries.sort();
-
-    let testsuite = &extract_name(path);
-    for entry in dir_entries.iter() {
-        write_testsuite_tests(out, entry, testsuite, strategy, false)?;
-        write_testsuite_tests(out, entry, testsuite, strategy, true)?;
-    }
-
-    Ok(dir_entries.len())
-}
-
-/// Extract a valid Rust identifier from the stem of a path.
-fn extract_name(path: impl AsRef<Path>) -> String {
-    path.as_ref()
-        .file_stem()
-        .expect("filename should have a stem")
-        .to_str()
-        .expect("filename should be representable as a string")
-        .replace(['-', '/'], "_")
-}
-
-fn with_test_module<T>(
-    out: &mut String,
-    testsuite: &str,
-    f: impl FnOnce(&mut String) -> anyhow::Result<T>,
-) -> anyhow::Result<T> {
-    out.push_str("mod ");
-    out.push_str(testsuite);
-    out.push_str(" {\n");
-
-    let result = f(out)?;
-
-    out.push_str("}\n");
-    Ok(result)
-}
-
-fn write_testsuite_tests(
-    out: &mut String,
-    path: impl AsRef<Path>,
-    testsuite: &str,
-    strategy: &str,
-    pooling: bool,
-) -> anyhow::Result<()> {
-    let path = path.as_ref();
-    let testname = extract_name(path);
-
-    writeln!(out, "#[test]")?;
-    // Ignore when using QEMU for running tests (limited memory).
-    if ignore(testsuite, &testname, strategy) {
-        writeln!(out, "#[ignore]")?;
-    } else {
-        writeln!(out, "#[cfg_attr(miri, ignore)]")?;
-    }
-
-    writeln!(
-        out,
-        "fn r#{}{}() {{",
-        &testname,
-        if pooling { "_pooling" } else { "" }
-    )?;
-    writeln!(out, "    let _ = env_logger::try_init();")?;
-    writeln!(
-        out,
-        "    crate::wast::run_wast(r#\"{}\"#, crate::wast::Strategy::{}, {}).unwrap();",
-        path.display(),
-        strategy,
-        pooling,
-    )?;
-    writeln!(out, "}}")?;
-    writeln!(out)?;
-    Ok(())
-}
-
-/// Ignore tests that aren't supported yet.
-fn ignore(testsuite: &str, testname: &str, strategy: &str) -> bool {
-    assert!(strategy == "Cranelift" || strategy == "Winch");
-
-    // Ignore everything except the winch misc test suite.
-    // We ignore tests that assert for traps on windows, given
-    // that Winch doesn't encode unwind information for Windows, yet.
-    if strategy == "Winch" {
-        if testsuite == "misc_testsuite" {
-            // The misc/call_indirect is fully supported by Winch.
-            if testname == "call_indirect" {
-                return false;
-            }
-        }
-        if testsuite != "winch" {
-            return true;
-        }
-
-        let assert_trap = ["i32", "i64", "call_indirect"].contains(&testname);
-
-        if assert_trap && env::var("CARGO_CFG_TARGET_OS").unwrap().as_str() == "windows" {
-            return true;
-        }
-    }
-
-    // This is an empty file right now which the `wast` crate doesn't parse
-    if testname.contains("memory_copy1") {
-        return true;
-    }
-
-    if testsuite == "function_references" {
-        // The following tests fail due to function references not yet
-        // being exposed in the public API.
-        if testname == "ref_null" || testname == "local_init" {
-            return true;
-        }
-        // This test fails due to incomplete support for the various
-        // table/elem syntactic sugar in wasm-tools/wast.
-        if testname == "br_table" {
-            return true;
-        }
-        // This test fails due to the current implementation of type
-        // canonicalisation being broken as a result of
-        // #[derive(hash)] on WasmHeapType.
-        if testname == "type_equivalence" {
-            return true;
-        }
-    }
-
-    match env::var("CARGO_CFG_TARGET_ARCH").unwrap().as_str() {
-        "s390x" => {
-            // TODO(#6530): These tests require tail calls, but s390x
-            // doesn't support them yet.
-            testsuite == "function_references" || testsuite == "tail_call"
-        }
-
-        "riscv64" => {
-            // This test case is disabled because it relies on `fvpromote_low`
-            // not flipping the sign bit of the input when it is a NaN. This
-            // is allowed by the spec. It's worth keeping the testcase as is
-            // since it is stressing a specific codegen bug in another arch.
-            //
-            // See #6961 for more details
-            testname == "issue_3327_bnot_lowering"
-        }
-
-        _ => false,
+fn set_commit_info_for_rustc() {
+    if !Path::new(".git").exists() {
+        return;
     }
+    let output = match Command::new("git")
+        .arg("log")
+        .arg("-1")
+        .arg("--date=short")
+        .arg("--format=%H %h %cd")
+        .arg("--abbrev=9")
+        .output()
+    {
+        Ok(output) if output.status.success() => output,
+        _ => return,
+    };
+    let stdout = String::from_utf8(output.stdout).unwrap();
+    let mut parts = stdout.split_whitespace();
+    let mut next = || parts.next().unwrap();
+    println!("cargo:rustc-env=WASMTIME_GIT_HASH={}", next());
+    println!(
+        "cargo:rustc-env=WASMTIME_VERSION_INFO={} ({} {})",
+        env!("CARGO_PKG_VERSION"),
+        next(),
+        next()
+    );
 }
diff --git a/ci/RELEASES-template.md b/ci/RELEASES-template.md
index f4c86db8478c..70b0e3b3424a 100644
--- a/ci/RELEASES-template.md
+++ b/ci/RELEASES-template.md
@@ -1,5 +1,3 @@
---------------------------------------------------------------------------------
-
 ## VERSION
 
 Unreleased.
@@ -8,3 +6,4 @@ Unreleased.
 
 ### Changed
 
+--------------------------------------------------------------------------------
diff --git a/ci/build-build-matrix.js b/ci/build-build-matrix.js
new file mode 100644
index 000000000000..321eca46d9a2
--- /dev/null
+++ b/ci/build-build-matrix.js
@@ -0,0 +1,83 @@
+// Small script used to calculate the matrix of builds that are going to be
+// done if CI decides to do a release build.
+//
+// This is a separate script primarily to write out all the release
+// targets/platforms once and then duplicate them all with a "min" build.
+
+const array = [
+  {
+    // The name of the build which shows up in the name of the artifact for
+    // Wasmtime's github releases.
+    "build": "x86_64-linux",
+    // The GitHub Actions platform that this build runs on
+    "os": "ubuntu-latest",
+    // The Rust target that will be used for the build.
+    "target": "x86_64-unknown-linux-gnu",
+  },
+  {
+    "build": "aarch64-linux",
+    "os": "ubuntu-latest",
+    "target": "aarch64-unknown-linux-gnu",
+  },
+  {
+    "build": "s390x-linux",
+    "os": "ubuntu-latest",
+    "target": "s390x-unknown-linux-gnu",
+  },
+  {
+    "build": "riscv64gc-linux",
+    "os": "ubuntu-latest",
+    "target": "riscv64gc-unknown-linux-gnu",
+  },
+  {
+    "build": "x86_64-macos",
+    "os": "macos-latest",
+    "target": "x86_64-apple-darwin",
+  },
+  {
+    "build": "aarch64-macos",
+    "os": "macos-latest",
+    "target": "aarch64-apple-darwin",
+  },
+  {
+    "build": "x86_64-windows",
+    "os": "windows-latest",
+    "target": "x86_64-pc-windows-msvc",
+  },
+  {
+    "build": "x86_64-mingw",
+    "os": "windows-latest",
+    "target": "x86_64-pc-windows-gnu",
+  },
+  {
+    "build": "aarch64-android",
+    "os": "ubuntu-latest",
+    "target": "aarch64-linux-android",
+  },
+  {
+    "build": "x86_64-android",
+    "os": "ubuntu-latest",
+    "target": "x86_64-linux-android",
+  },
+  {
+    "build": "x86_64-musl",
+    "os": "ubuntu-latest",
+    "target": "x86_64-unknown-linux-musl",
+  },
+];
+
+const builds = [];
+for (let build of array) {
+  // Perform a "deep clone" roundtripping through JSON for a copy of the build
+  // that's normal
+  build.rust = 'default';
+  builds.push(JSON.parse(JSON.stringify(build)));
+
+  // Next generate a "min" build and add it to the builds list. Min builds
+  // require Nightly rust due to some nightly build options that are configured.
+  build.build += '-min';
+  build.rust = 'wasmtime-ci-pinned-nightly';
+  builds.push(build);
+}
+
+console.log(JSON.stringify(builds));
diff --git a/ci/build-release-artifacts.sh b/ci/build-release-artifacts.sh
new file mode 100755
index 000000000000..cd91e430032b
--- /dev/null
+++ b/ci/build-release-artifacts.sh
@@ -0,0 +1,54 @@
+#!/bin/bash
+
+# A script to build the release artifacts of Wasmtime into the `target`
+# directory. For now this is the CLI and the C API. Note that this script only
+# produces the artifacts through Cargo and doesn't package things up. That's
+# intended for the `build-tarballs.sh` script.
+#
+# This script takes a Rust target as its first input and optionally a parameter
+# afterwards which can be "-min" to indicate that a minimal build should be
+# produced with as many features as possible stripped out.
+
+set -ex
+
+build=$1
+target=$2
+
+# Default build flags for release artifacts. Leave debugging for
+# builds-from-source which have richer information anyway, and additionally the
+# CLI won't benefit from catching unwinds and neither will the C API so use
+# panic=abort in both situations.
+export CARGO_PROFILE_RELEASE_STRIP=debuginfo
+export CARGO_PROFILE_RELEASE_PANIC=abort
+
+if [[ "$build" = *-min ]]; then
+  # Configure a whole bunch of compile-time options which help reduce the size
+  # of the binary artifact produced.
+  export CARGO_PROFILE_RELEASE_OPT_LEVEL=s
+  export RUSTFLAGS="-Zlocation-detail=none $RUSTFLAGS"
+  export CARGO_PROFILE_RELEASE_CODEGEN_UNITS=1
+  export CARGO_PROFILE_RELEASE_LTO=true
+  build_std=-Zbuild-std=std,panic_abort
+  build_std_features=-Zbuild-std-features=std_detect_dlsym_getauxval
+  flags="$build_std $build_std_features --no-default-features --features disable-logging"
+  cmake_flags="-DWASMTIME_DISABLE_ALL_FEATURES=ON"
+  cmake_flags="$cmake_flags -DWASMTIME_FEATURE_DISABLE_LOGGING=ON"
+  cmake_flags="$cmake_flags -DWASMTIME_USER_CARGO_BUILD_OPTIONS:LIST=$build_std;$build_std_features"
+else
+  # For release builds the CLI is built a bit more feature-ful than the Cargo
+  # defaults to provide artifacts that can do as much as possible.
+  bin_flags="--features all-arch,component-model"
+fi
+
+cargo build --release $flags --target $target -p wasmtime-cli $bin_flags --features run
+
+mkdir -p target/c-api-build
+cd target/c-api-build
+cmake \
+  ../../crates/c-api \
+  $cmake_flags \
+  -DCMAKE_BUILD_TYPE=Release \
+  -DWASMTIME_TARGET=$target \
+  -DCMAKE_INSTALL_PREFIX=../c-api-install \
+  -DCMAKE_INSTALL_LIBDIR=../c-api-install/lib
+cmake --build . --target install
diff --git a/ci/build-src-tarball.sh b/ci/build-src-tarball.sh
index 571fcc47a3a7..c5d3c10fa9b7 100755
--- a/ci/build-src-tarball.sh
+++ b/ci/build-src-tarball.sh
@@ -18,3 +18,5 @@ cargo vendor > .cargo/config.toml
 tar -czf /tmp/$pkgname.tar.gz --transform "s/^\./$pkgname/S" --exclude=.git .
 mkdir -p dist
 mv /tmp/$pkgname.tar.gz dist/
+
+rm .cargo/config.toml
diff --git a/ci/build-tarballs.sh b/ci/build-tarballs.sh
index eb6197c2a5ac..b8e1684c0a13 100755
--- a/ci/build-tarballs.sh
+++ b/ci/build-tarballs.sh
@@ -1,19 +1,18 @@
 #!/bin/bash
 
 # A small script used for assembling release tarballs for both the `wasmtime`
-# binary and the C API. This is executed with two arguments, mostly coming from
-# the CI matrix.
+# binary and the C API. This is executed with two arguments, mostly coming
+# from the CI matrix.
 #
-# * The first argument is the name of the platform, used to name the release
-# * The second argument is the "target", if present, currently only for
-#   cross-compiles
+# * The first argument is the name of the "build", used to name the release.
+# * The second argument is the Rust target that the build was performed for.
 #
 # This expects the build to already be done and will assemble release artifacts
 # in `dist/`
 
 set -ex
 
-platform=$1
+build=$1
 target=$2
 
 rm -rf tmp
@@ -25,59 +24,69 @@ if [[ $GITHUB_REF == refs/heads/release-* ]]; then
   tag=v$(./ci/print-current-version.sh)
 fi
 
-bin_pkgname=wasmtime-$tag-$platform
-api_pkgname=wasmtime-$tag-$platform-c-api
+# For *-min builds produce the same named artifacts as the normal build and
+# they'll get unioned together in a later step in the CI.
+build_pkgname=$build
+if [[ $build == *-min ]]; then
+  build_pkgname=${build%-min}
+fi
+
+bin_pkgname=wasmtime-$tag-$build_pkgname
+api_pkgname=wasmtime-$tag-$build_pkgname-c-api
 
+api_install=target/c-api-install
 mkdir tmp/$api_pkgname
-mkdir tmp/$api_pkgname/lib
-mkdir tmp/$api_pkgname/include
 mkdir tmp/$bin_pkgname
 cp LICENSE README.md tmp/$api_pkgname
 cp LICENSE README.md tmp/$bin_pkgname
-cp -r crates/c-api/include tmp/$api_pkgname
-cp crates/c-api/wasm-c-api/include/wasm.h tmp/$api_pkgname/include
 
-fmt=tar
-if [ "$platform" = "x86_64-windows" ]; then
-  cp target/release/wasmtime.exe tmp/$bin_pkgname
-  cp target/release/{wasmtime.dll,wasmtime.lib,wasmtime.dll.lib} tmp/$api_pkgname/lib
-  fmt=zip
-
-  # Generate a `*.msi` installer for Windows as well
-  export WT_VERSION=`cat Cargo.toml | sed -n 's/^version = "\([^"]*\)".*/\1/p'`
-  "$WIX/bin/candle" -arch x64 -out target/wasmtime.wixobj ci/wasmtime.wxs
-  "$WIX/bin/light" -out dist/$bin_pkgname.msi target/wasmtime.wixobj -ext WixUtilExtension
-  rm dist/$bin_pkgname.wixpdb
-elif [ "$platform" = "x86_64-mingw" ]; then
-  cp target/x86_64-pc-windows-gnu/release/wasmtime.exe tmp/$bin_pkgname
-  cp target/x86_64-pc-windows-gnu/release/{wasmtime.dll,libwasmtime.a,libwasmtime.dll.a} tmp/$api_pkgname/lib
-  fmt=zip
-elif [ "$platform" = "x86_64-macos" ]; then
-  # Postprocess the macOS dylib a bit to have a more reasonable `LC_ID_DYLIB`
-  # directive than the default one that comes out of the linker when typically
-  # doing `cargo build`. For more info see #984
-  install_name_tool -id "@rpath/libwasmtime.dylib" target/release/libwasmtime.dylib
-  cp target/release/wasmtime tmp/$bin_pkgname
-  cp target/release/libwasmtime.{a,dylib} tmp/$api_pkgname/lib
-elif [ "$platform" = "aarch64-macos" ]; then
-  install_name_tool -id "@rpath/libwasmtime.dylib" target/aarch64-apple-darwin/release/libwasmtime.dylib
-  cp target/aarch64-apple-darwin/release/wasmtime tmp/$bin_pkgname
-  cp target/aarch64-apple-darwin/release/libwasmtime.{a,dylib} tmp/$api_pkgname/lib
-elif [ "$target" = "" ]; then
-  cp target/release/wasmtime tmp/$bin_pkgname
-  cp target/release/libwasmtime.{a,so} tmp/$api_pkgname/lib
+# For *-min builds rename artifacts with a `-min` suffix to avoid eventual
+# clashes with the normal builds when the tarballs are unioned together.
+if [[ $build == *-min ]]; then
+  min="-min"
+  cp -r $api_install/include tmp/$api_pkgname/min
+  cp -r $api_install/lib tmp/$api_pkgname/min
 else
-  cp target/$target/release/wasmtime tmp/$bin_pkgname
-  cp target/$target/release/libwasmtime.{a,so} tmp/$api_pkgname/lib
+  cp -r $api_install/include tmp/$api_pkgname
+  cp -r $api_install/lib tmp/$api_pkgname
 fi
 
 
+fmt=tar
+
+case $build in
+  x86_64-windows*)
+    cp target/$target/release/wasmtime.exe tmp/$bin_pkgname/wasmtime$min.exe
+    fmt=zip
+
+    if [ "$min" = "" ]; then
+      # Generate a `*.msi` installer for Windows as well
+      export WT_VERSION=`cat Cargo.toml | sed -n 's/^version = "\([^"]*\)".*/\1/p'`
+      "$WIX/bin/candle" -arch x64 -out target/wasmtime.wixobj ci/wasmtime.wxs
+      "$WIX/bin/light" -out dist/$bin_pkgname.msi target/wasmtime.wixobj -ext WixUtilExtension
+      rm dist/$bin_pkgname.wixpdb
+    fi
+    ;;
+
+  x86_64-mingw*)
+    cp target/$target/release/wasmtime.exe tmp/$bin_pkgname/wasmtime$min.exe
+    fmt=zip
+    ;;
+
+  *-macos*)
+    cp target/$target/release/wasmtime tmp/$bin_pkgname/wasmtime$min
+    ;;
+
+  *)
+    cp target/$target/release/wasmtime tmp/$bin_pkgname/wasmtime$min
+    ;;
+esac
+
+
 mktarball() {
   dir=$1
   if [ "$fmt" = "tar" ]; then
-    # this is a bit wonky, but the goal is to use `xz` with threaded compression
-    # to ideally get better performance with the `-T0` flag.
-    tar -cvf - -C tmp $dir | xz -9 -T0 > dist/$dir.tar.xz
+    tar -czvf dist/$dir.tar.gz -C tmp $dir
   else
     # Note that this runs on Windows, and it looks like GitHub Actions doesn't
     # have a `zip` tool there, so we use something else
diff --git a/ci/build-test-matrix.js b/ci/build-test-matrix.js
index 298203f5d4de..b1c0b73c7fd7 100644
--- a/ci/build-test-matrix.js
+++ b/ci/build-test-matrix.js
@@ -5,58 +5,92 @@
 // couldn't figure out how to write it in bash.
 
 const fs = require('fs');
+const { spawn } = require('node:child_process');
 
-// Our first argument is a file that is a giant json blob which contains at
-// least all the messages for all of the commits that were a part of this PR.
-// This is used to test if any commit message includes a string.
-const commits = fs.readFileSync(process.argv[2]).toString();
+// Number of generic buckets to shard crates into. Note that we additionally add
+// single-crate buckets for our biggest crates.
+const GENERIC_BUCKETS = 3;
 
-// The second argument is a file that contains the names of all files modified
-// for a PR, used for file-based filters.
-const names = fs.readFileSync(process.argv[3]).toString();
+// Crates which are their own buckets. These are the very slowest to
+// compile-and-test crates.
+const SINGLE_CRATE_BUCKETS = ["wasmtime", "wasmtime-cli", "wasmtime-wasi"];
 
-// This is the full matrix of what we test on CI. This includes a number of
-// platforms and a number of cross-compiled targets that are emulated with QEMU.
-// This must be kept tightly in sync with the `test` step in `main.yml`.
+// This is the small, fast-to-execute matrix we use for PRs before they enter
+// the merge queue. Same schema as `FULL_MATRIX`.
+const FAST_MATRIX = [
+  {
+    "os": "ubuntu-latest",
+    "name": "Test Linux x86_64",
+    "filter": "linux-x64",
+    "isa": "x64",
+  },
+];
+
+// Returns whether the given package supports a 32-bit architecture, used when
+// testing on i686 and armv7 below.
+function supports32Bit(pkg) {
+  if (pkg.indexOf("pulley") !== -1)
+    return true;
+
+  return pkg == 'wasmtime-fiber';
+}
+
+// This is the full, unsharded, and unfiltered matrix of what we test on
+// CI. This includes a number of platforms and a number of cross-compiled
+// targets that are emulated with QEMU. This must be kept tightly in sync with
+// the `test` step in `main.yml`.
 //
 // The supported keys here are:
 //
 // * `os` - the github-actions name of the runner os
+//
 // * `name` - the human-readable name of the job
+//
 // * `filter` - a string which if `prtest:$filter` is in the commit messages
 //   it'll force running this test suite on PR CI.
+//
+// * `isa` - changes to `cranelift/codegen/src/$isa` will automatically run this
+//   test suite.
+//
 // * `target` - used for cross-compiles if present. Effectively Cargo's
 //   `--target` option for all its operations.
+//
 // * `gcc_package`, `gcc`, `qemu`, `qemu_target` - configuration for building
 //   QEMU and installing cross compilers to execute a cross-compiled test suite
 //   on CI.
-// * `isa` - changes to `cranelift/codegen/src/$isa` will automatically run this
-//   test suite.
+//
 // * `rust` - the Rust version to install, and if unset this'll be set to
 //   `default`
-const array = [
+const FULL_MATRIX = [
+  ...FAST_MATRIX,
   {
     "os": "ubuntu-latest",
-    "name": "Test Linux x86_64",
+    "name": "Test MSRV on Linux x86_64",
     "filter": "linux-x64",
-    "isa": "x64"
+    "isa": "x64",
+    "rust": "msrv",
   },
   {
     "os": "ubuntu-latest",
-    "name": "Test MSRV on Linux x86_64",
+    "name": "Test Linux x86_64 with MPK",
     "filter": "linux-x64",
-    "isa": "x64",
-    "rust": "msrv",
+    "isa": "x64"
   },
   {
-    "os": "macos-latest",
+    "os": "macos-13",
     "name": "Test macOS x86_64",
-    "filter": "macos-x64"
+    "filter": "macos-x64",
+  },
+  {
+    "os": "macos-14",
+    "name": "Test macOS arm64",
+    "filter": "macos-arm64",
+    "target": "aarch64-apple-darwin",
   },
   {
     "os": "windows-latest",
     "name": "Test Windows MSVC x86_64",
-    "filter": "windows-x64"
+    "filter": "windows-x64",
   },
   {
     "os": "windows-latest",
@@ -73,7 +107,7 @@ const array = [
     "qemu_target": "aarch64-linux-user",
     "name": "Test Linux arm64",
     "filter": "linux-arm64",
-    "isa": "aarch64"
+    "isa": "aarch64",
   },
   {
     "os": "ubuntu-latest",
@@ -91,58 +125,206 @@ const array = [
     "target": "riscv64gc-unknown-linux-gnu",
     "gcc_package": "gcc-riscv64-linux-gnu",
     "gcc": "riscv64-linux-gnu-gcc",
-    "qemu": "qemu-riscv64 -cpu rv64,v=true,vlen=256,vext_spec=v1.0,zba=true,zbb=true,zbc=true,zbs=true,zbkb=true,zcb=true -L /usr/riscv64-linux-gnu",
+    "qemu": "qemu-riscv64 -cpu rv64,v=true,vlen=256,vext_spec=v1.0,Zfa=true,Zfh=true,zba=true,zbb=true,zbc=true,zbs=true,zbkb=true,zcb=true,x-zicond=true -L /usr/riscv64-linux-gnu",
     "qemu_target": "riscv64-linux-user",
     "name": "Test Linux riscv64",
     "filter": "linux-riscv64",
     "isa": "riscv64",
-    // There appears to be a miscompile in Rust 1.72 for riscv64 where
-    // wasmtime-wasi tests are segfaulting in CI with the stack pointing in
-    // Tokio. Updating rustc seems to do the trick, so without doing a full
-    // rigorous investigation this uses beta for now but Rust 1.73 should be
-    // good to go for this.
-    "rust": "beta-2023-09-10",
-  }
+  },
+  {
+    "name": "Tests on i686-unknown-linux-gnu",
+    "32-bit": true,
+    "os": "ubuntu-latest",
+    "target": "i686-unknown-linux-gnu",
+    "gcc_package": "gcc-i686-linux-gnu",
+    "gcc": "i686-linux-gnu-gcc",
+  },
+  {
+    "name": "Tests on armv7-unknown-linux-gnueabihf",
+    "32-bit": true,
+    "os": "ubuntu-latest",
+    "target": "armv7-unknown-linux-gnueabihf",
+    "gcc_package": "gcc-arm-linux-gnueabihf",
+    "gcc": "arm-linux-gnueabihf-gcc",
+    "qemu": "qemu-arm -L /usr/arm-linux-gnueabihf -E LD_LIBRARY_PATH=/usr/arm-linux-gnueabihf/lib",
+    "qemu_target": "arm-linux-user",
+  },
 ];
 
-for (let config of array) {
-  if (config.rust === undefined) {
-    config.rust = 'default';
+/// Get the workspace's full list of member crates.
+async function getWorkspaceMembers() {
+  // Spawn a `cargo metadata` subprocess, accumulate its JSON output from
+  // `stdout`, and wait for it to exit.
+  const child = spawn("cargo", ["metadata"], { encoding: "utf8" });
+  let data = "";
+  child.stdout.on("data", chunk => data += chunk);
+  await new Promise((resolve, reject) => {
+    child.on("close", resolve);
+    child.on("error", reject);
+  });
+
+  // Get the names of the crates in the workspace from the JSON metadata by
+  // building a package-id to name map and then translating the package-ids
+  // listed as workspace members.
+  const metadata = JSON.parse(data);
+  const id_to_name = {};
+  for (const pkg of metadata.packages) {
+    id_to_name[pkg.id] = pkg.name;
   }
+  return metadata.workspace_members.map(m => id_to_name[m]);
 }
 
-function myFilter(item) {
-  if (item.isa && names.includes(`cranelift/codegen/src/isa/${item.isa}`)) {
-    return true;
+/// For each given target configuration, shard the workspace's crates into
+/// buckets across that config.
+///
+/// This is essentially a `flat_map` where each config that logically tests all
+/// crates in the workspace is mapped to N sharded configs that each test only a
+/// subset of crates in the workspace. Each sharded config's subset of crates to
+/// test are disjoint from all its siblings, and the union of all these siblings'
+/// crates to test is the full workspace members set.
+///
+/// With some poetic license around a `crates_to_test` key that doesn't actually
+/// exist, logically each element of the input `configs` list gets transformed
+/// like this:
+///
+///     { os: "ubuntu-latest", isa: "x64", ..., crates: "all" }
+///
+///     ==>
+///
+///     [
+///       { os: "ubuntu-latest", isa: "x64", ..., crates: ["wasmtime"] },
+///       { os: "ubuntu-latest", isa: "x64", ..., crates: ["wasmtime-cli"] },
+///       { os: "ubuntu-latest", isa: "x64", ..., crates: ["wasmtime-wasi"] },
+///       { os: "ubuntu-latest", isa: "x64", ..., crates: ["cranelift", "cranelift-codegen", ...] },
+///       { os: "ubuntu-latest", isa: "x64", ..., crates: ["wasmtime-slab", "cranelift-entity", ...] },
+///       { os: "ubuntu-latest", isa: "x64", ..., crates: ["cranelift-environ", "wasmtime-cli-flags", ...] },
+///       ...
+///     ]
+///
+/// Note that `crates: "all"` is implicit in the input and omitted. Similarly,
+/// `crates: [...]` in each output config is actually implemented via adding a
+/// `bucket` key, which contains the CLI flags we must pass to `cargo` to run
+/// tests for just this config's subset of crates.
+async function shard(configs) {
+  const members = await getWorkspaceMembers();
+
+  // Divide the workspace crates into N disjoint subsets. Crates that are
+  // particularly expensive to compile and test form their own singleton subset.
+  const buckets = Array.from({ length: GENERIC_BUCKETS }, _ => new Set());
+  let i = 0;
+  for (const crate of members) {
+    if (SINGLE_CRATE_BUCKETS.indexOf(crate) != -1) continue;
+    buckets[i].add(crate);
+    i = (i + 1) % GENERIC_BUCKETS;
   }
-  if (item.filter && commits.includes(`prtest:${item.filter}`)) {
-    return true;
+  for (crate of SINGLE_CRATE_BUCKETS) {
+    buckets.push(new Set([crate]));
   }
 
-  // If any runtest was modified, re-run the whole test suite as those can
-  // target any backend.
-  if (names.includes(`cranelift/filetests/filetests/runtests`)) {
-    return true;
-  }
+  // For each config, expand it into N configs, one for each disjoint set we
+  // created above.
+  const sharded = [];
+  for (const config of configs) {
+    // Special case 32-bit configs. Only some crates, according to
+    // `supports32Bit`, run on this target. At this time the set of supported
+    // crates is small enough that they're not sharded.
+    if (config["32-bit"] === true) {
+      sharded.push(Object.assign(
+        {},
+        config,
+        {
+          bucket: members
+            .map(c => supports32Bit(c) ? `--package ${c}` : `--exclude ${c}`)
+            .join(" "),
+        }
+      ));
+      continue;
+    }
 
-  return false;
+    for (const bucket of buckets) {
+      sharded.push(Object.assign(
+        {},
+        config,
+        {
+          name: `${config.name} (${Array.from(bucket).join(', ')})`,
+          // We run tests via `cargo test --workspace`, so exclude crates that
+          // aren't in this bucket, rather than naming only the crates that are
+          // in this bucket.
+          bucket: members
+            .map(c => bucket.has(c) ? `--package ${c}` : `--exclude ${c}`)
+            .join(" "),
+        }
+      ));
+    }
+  }
+  return sharded;
 }
 
-const filtered = array.filter(myFilter);
+async function main() {
+  // Our first argument is a file that is a giant json blob which contains at
+  // least all the messages for all of the commits that were a part of this PR.
+  // This is used to test if any commit message includes a string.
+  const commits = fs.readFileSync(process.argv[2]).toString();
 
-// If the optional third argument to this script is `true` then that means all
-// tests are being run and no filtering should happen.
-if (process.argv[4] == 'true') {
-  console.log(JSON.stringify(array));
-  return;
-}
+  // The second argument is a file that contains the names of all files modified
+  // for a PR, used for file-based filters.
+  const names = fs.readFileSync(process.argv[3]).toString();
+
+  for (let config of FULL_MATRIX) {
+    if (config.rust === undefined) {
+      config.rust = 'default';
+    }
+  }
+
+  // If the optional third argument to this script is `true` then that means all
+  // tests are being run and no filtering should happen.
+  if (process.argv[4] == 'true') {
+    console.log(JSON.stringify(await shard(FULL_MATRIX), undefined, 2));
+    return;
+  }
+
+  // When we aren't running the full CI matrix, filter configs down to just the
+  // relevant bits based on files changed in this commit or if the commit asks
+  // for a certain config to run.
+  const filtered = FULL_MATRIX.filter(config => {
+    // If an ISA-specific test was modified, then include that ISA config.
+    if (config.isa && names.includes(`cranelift/codegen/src/isa/${config.isa}`)) {
+      return true;
+    }
+
+    // If any runtest was modified, include all ISA configs as runtests can
+    // target any backend.
+    if (names.includes(`cranelift/filetests/filetests/runtests`)) {
+      if (config.isa !== undefined)
+        return true;
+    }
+
+    // For matrix entries that represent 32-bit only some crates support that,
+    // so whenever the crates are changed be sure to run 32-bit tests on PRs
+    // too.
+    if (config["32-bit"] === true) {
+      if (names.includes("pulley"))
+        return true;
+      if (names.includes("fiber"))
+        return true;
+    }
+
+    // If the commit explicitly asks for this test config, then include it.
+    if (config.filter && commits.includes(`prtest:${config.filter}`)) {
+      return true;
+    }
+
+    return false;
+  });
+
+  // If at least one test is being run via our filters then run those tests.
+  if (filtered.length > 0) {
+    console.log(JSON.stringify(await shard(filtered), undefined, 2));
+    return;
+  }
 
-// If at least one test is being run via our filters then run those tests.
-if (filtered.length > 0) {
-  console.log(JSON.stringify(filtered));
-  return;
+  // Otherwise if nothing else is being run, run the fast subset of the matrix.
+  console.log(JSON.stringify(await shard(FAST_MATRIX), undefined, 2));
 }
 
-// Otherwise if nothing else is being run, run the first one which is Ubuntu
-// Linux which should be the fastest for now.
-console.log(JSON.stringify([array[0]]));
+main()
diff --git a/ci/build-wasi-preview1-component-adapter-provider.sh b/ci/build-wasi-preview1-component-adapter-provider.sh
new file mode 100755
index 000000000000..c8c2bf4d2086
--- /dev/null
+++ b/ci/build-wasi-preview1-component-adapter-provider.sh
@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+set -ex
+
+# Manifest the adapter provider into the workspace
+cp crates/wasi-preview1-component-adapter/provider/Cargo.toml.in crates/wasi-preview1-component-adapter/provider/Cargo.toml
+sed -i '/"crates\/wasi-preview1-component-adapter",/a\ \ "crates\/wasi-preview1-component-adapter\/provider",' Cargo.toml
+
+# Check the adapter provider's code formatting and style
+cargo fmt -p wasi-preview1-component-adapter-provider -- --check
+cargo check -p wasi-preview1-component-adapter-provider
+cargo clippy -p wasi-preview1-component-adapter-provider
+
+# Check that publishing the adapter provider should work
+cargo publish -p wasi-preview1-component-adapter-provider --dry-run --allow-dirty
diff --git a/ci/build-wasi-preview1-component-adapter.sh b/ci/build-wasi-preview1-component-adapter.sh
index ba1380d3bcd8..545a4e06f389 100755
--- a/ci/build-wasi-preview1-component-adapter.sh
+++ b/ci/build-wasi-preview1-component-adapter.sh
@@ -1,6 +1,10 @@
 #!/usr/bin/env bash
 set -ex
 
+# These flags reduce binary size by a combined 4.6k
+export CARGO_PROFILE_RELEASE_LTO=fat
+export CARGO_TARGET_WASM32_UNKNOWN_UNKNOWN_RUSTFLAGS="$RUSTFLAGS -Ctarget-feature=+bulk-memory"
+
 build_adapter="cargo build -p wasi-preview1-component-adapter --target wasm32-unknown-unknown"
 verify="cargo run -p verify-component-adapter --"
 
@@ -11,18 +15,28 @@ release="target/wasm32-unknown-unknown/release/wasi_snapshot_preview1.wasm"
 $build_adapter
 $verify $debug
 
+build() {
+  input=$1
+  flavor=$2
+  $verify $input
+  name=wasi_snapshot_preview1.$flavor.wasm
+  dst=$(dirname $input)/$name
+  wasm-tools metadata add --name "wasi_preview1_component_adapter.$flavor.adapter" $input \
+    -o $dst
+}
+
 # Debug build, command
 $build_adapter --no-default-features --features command
 $verify $debug
 
 # Release build, command
 $build_adapter --release --no-default-features --features command
-$verify $release
-wasm-tools metadata add --name "wasi_preview1_component_adapter.command.adapter:${VERSION}" $release \
-  -o target/wasm32-unknown-unknown/release/wasi_snapshot_preview1.command.wasm
+build $release command
 
 # Release build, default features (reactor)
 $build_adapter --release
-$verify $release
-wasm-tools metadata add --name "wasi_preview1_component_adapter.reactor.adapter:${VERSION}" $release \
-  -o target/wasm32-unknown-unknown/release/wasi_snapshot_preview1.reactor.wasm
+build $release reactor
+
+# Release build, proxy
+$build_adapter --release --no-default-features --features proxy
+build $release proxy
diff --git a/ci/docker/aarch64-linux/Dockerfile b/ci/docker/aarch64-linux/Dockerfile
index 06c7cefc8d6a..4573e830e435 100644
--- a/ci/docker/aarch64-linux/Dockerfile
+++ b/ci/docker/aarch64-linux/Dockerfile
@@ -1,7 +1,11 @@
 FROM ubuntu:16.04
 
-RUN apt-get update -y && apt-get install -y gcc gcc-aarch64-linux-gnu ca-certificates
+RUN apt-get update -y && apt-get install -y gcc gcc-aarch64-linux-gnu ca-certificates curl make git
+RUN git config --global --add safe.directory '*'
+
+# The CMake in Ubuntu 16.04 was a bit too old for us to use so download one from
+# CMake's own releases and use that instead.
+RUN curl -L https://github.com/Kitware/CMake/releases/download/v3.29.3/cmake-3.29.3-linux-x86_64.tar.gz | tar xzf -
+ENV PATH=$PATH:/cmake-3.29.3-linux-x86_64/bin
 
-ENV PATH=$PATH:/rust/bin
-ENV CARGO_BUILD_TARGET=aarch64-unknown-linux-gnu
 ENV CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc
diff --git a/ci/docker/riscv64gc-linux/Dockerfile b/ci/docker/riscv64gc-linux/Dockerfile
index 522867a67cb7..c10524d862b0 100644
--- a/ci/docker/riscv64gc-linux/Dockerfile
+++ b/ci/docker/riscv64gc-linux/Dockerfile
@@ -1,7 +1,6 @@
 FROM ubuntu:22.04
 
-RUN apt-get update -y && apt-get install -y gcc gcc-riscv64-linux-gnu ca-certificates
+RUN apt-get update -y && apt-get install -y gcc gcc-riscv64-linux-gnu ca-certificates cmake git
+RUN git config --global --add safe.directory '*'
 
-ENV PATH=$PATH:/rust/bin
-ENV CARGO_BUILD_TARGET=riscv64gc-unknown-linux-gnu
 ENV CARGO_TARGET_RISCV64GC_UNKNOWN_LINUX_GNU_LINKER=riscv64-linux-gnu-gcc
diff --git a/ci/docker/s390x-linux/Dockerfile b/ci/docker/s390x-linux/Dockerfile
index 19acf1d8255b..6c97b174dea2 100644
--- a/ci/docker/s390x-linux/Dockerfile
+++ b/ci/docker/s390x-linux/Dockerfile
@@ -1,7 +1,11 @@
 FROM ubuntu:16.04
 
-RUN apt-get update -y && apt-get install -y gcc gcc-s390x-linux-gnu ca-certificates
+RUN apt-get update -y && apt-get install -y gcc gcc-s390x-linux-gnu ca-certificates curl make git
+RUN git config --global --add safe.directory '*'
+
+# The CMake in Ubuntu 16.04 was a bit too old for us to use so download one from
+# CMake's own releases and use that instead.
+RUN curl -L https://github.com/Kitware/CMake/releases/download/v3.29.3/cmake-3.29.3-linux-x86_64.tar.gz | tar xzf -
+ENV PATH=$PATH:/cmake-3.29.3-linux-x86_64/bin
 
-ENV PATH=$PATH:/rust/bin
-ENV CARGO_BUILD_TARGET=s390x-unknown-linux-gnu
 ENV CARGO_TARGET_S390X_UNKNOWN_LINUX_GNU_LINKER=s390x-linux-gnu-gcc
diff --git a/ci/docker/x86_64-linux/Dockerfile b/ci/docker/x86_64-linux/Dockerfile
index 89ddc2b2820b..add422150508 100644
--- a/ci/docker/x86_64-linux/Dockerfile
+++ b/ci/docker/x86_64-linux/Dockerfile
@@ -1,5 +1,4 @@
-FROM centos:7
+FROM almalinux:8
 
-RUN yum install -y git gcc
-
-ENV PATH=$PATH:/rust/bin
+RUN dnf install -y git gcc make cmake git
+RUN git config --global --add safe.directory '*'
diff --git a/ci/docker/x86_64-musl/Dockerfile b/ci/docker/x86_64-musl/Dockerfile
new file mode 100644
index 000000000000..acd6dd88d981
--- /dev/null
+++ b/ci/docker/x86_64-musl/Dockerfile
@@ -0,0 +1,16 @@
+# Rust binaries need `libgcc_s.so` but ubuntu's musl toolchain does not have it.
+# Get it from alpine instead.
+FROM alpine:3.16 as libgcc_s_src
+RUN apk add libgcc
+
+# Use something glibc-based for the actual compile because the Rust toolchain
+# we're using is glibc-based in CI.
+FROM ubuntu:24.04
+RUN apt-get update -y && apt-get install -y cmake musl-tools git
+COPY --from=libgcc_s_src /usr/lib/libgcc_s.so.1 /usr/lib/x86_64-linux-musl
+RUN git config --global --add safe.directory '*'
+
+# Note that `-crt-feature` is passed here to specifically disable static linking
+# with musl. We want a `*.so` to pop out so static linking isn't what we want.
+ENV EXTRA_RUSTFLAGS=-Ctarget-feature=-crt-static
+ENV CARGO_TARGET_X86_64_UNKNOWN_LINUX_MUSL_LINKER=musl-gcc
diff --git a/ci/merge-artifacts.sh b/ci/merge-artifacts.sh
new file mode 100755
index 000000000000..57200c0f6af1
--- /dev/null
+++ b/ci/merge-artifacts.sh
@@ -0,0 +1,54 @@
+#!/bin/bash
+
+# Script to merge the outputs of a run on github actions to github releases.
+# This is invoked from `.github/workflows/publish-artifacts.yml`. All previous
+# artifacts from builds are located in `bins-*` folders. The main purpose of
+# this script is to take the "min" build and merge it into the "normal" build to
+# produce one final tarball. This means that the final artifacts will have both
+# a normal and a min build in them for comparison and usage.
+
+set -ex
+
+# Prepare the upload folder and move all artifacts that aren't being merged into
+# this folder, e.g. the MSI installer and adapter wasm files.
+rm -rf dist
+mkdir dist
+mv -t dist bins-*/*.{msi,wasm}
+mv wasmtime-platform-header/* dist
+
+# Merge tarballs and zips by searching for `*-min` builds, unpacking the
+# min/normal builds, into the same destination, and then repacking into a
+# tarball.
+#
+# Note that for now xz compression is used for the final artifact to try to get
+# small artifacts, but it's left at the default level since a lot of artifacts
+# are processed here and turning it up to the max 9 compression might take
+# quite awhile on CI for this one builder to process.
+for min in bins-*-min/*.tar.*; do
+ normal=${min/-min\//\/}
+ filename=$(basename $normal)
+ dir=${filename%.tar.gz}
+
+ rm -rf tmp
+ mkdir tmp
+ tar xf $min -C tmp
+ tar xf $normal -C tmp
+ tar -cf - -C tmp $dir | xz -T0 > dist/$dir.tar.xz
+ rm $min $normal
+done
+
+for min in bins-*-min/*.zip; do
+  normal=${min/-min\//\/}
+  filename=$(basename $normal)
+  dir=${filename%.zip}
+
+  rm -rf tmp
+  mkdir tmp
+  (cd tmp && unzip -o ../$min)
+  (cd tmp && unzip -o ../$normal)
+  (cd tmp && 7z a ../dist/$dir.zip $dir/)
+  rm $min $normal
+done
+
+# Copy over remaining source tarball into the dist folder
+mv -t dist bins-*/*.tar.*
diff --git a/ci/run-tests.sh b/ci/run-tests.sh
index 568ff4405413..274d35232177 100755
--- a/ci/run-tests.sh
+++ b/ci/run-tests.sh
@@ -1,15 +1,23 @@
-#!/bin/bash
+#!/usr/bin/env bash
+
+# Excludes:
+#
+# - test-programs: just programs used in tests.
+#
+# - wasmtime-wasi-nn: mutually-exclusive features that aren't available for all
+#   targets, needs its own CI job.
+#
+# - wasmtime-fuzzing: enabling all features brings in OCaml which is a pain to
+#   configure for all targets, so it has its own CI job.
+#
+# - wasm-spec-interpreter: brings in OCaml which is a pain to configure for all
+#   targets, tested as part of the wastime-fuzzing CI job.
 
 cargo test \
-    --features "test-programs/test_programs" \
-    --features wasi-threads \
-    --features wasi-http \
-    --features component-model \
-    --features serve \
-    --workspace \
-    --exclude 'wasmtime-wasi-*' \
-    --exclude wasi-tests \
-    --exclude wasi-http-tests \
-    --exclude command-tests \
-    --exclude reactor-tests \
-    $@
+      --workspace \
+      --all-features \
+      --exclude test-programs \
+      --exclude wasmtime-wasi-nn \
+      --exclude wasmtime-fuzzing \
+      --exclude wasm-spec-interpreter \
+      $@
diff --git a/ci/run-wasi-nn-example.sh b/ci/run-wasi-nn-example.sh
deleted file mode 100755
index 74bab3bd30fc..000000000000
--- a/ci/run-wasi-nn-example.sh
+++ /dev/null
@@ -1,57 +0,0 @@
-#!/bin/bash
-
-# The following script demonstrates how to execute a machine learning inference
-# using the wasi-nn module optionally compiled into Wasmtime. Calling it will
-# download the necessary model and tensor files stored separately in $FIXTURE
-# into $TMP_DIR (optionally pass a directory with existing files as the first
-# argument to re-try the script). Then, it will compile and run several examples
-# in the Wasmtime CLI.
-set -e
-WASMTIME_DIR=$(dirname "$0" | xargs dirname)
-FIXTURE=https://github.com/intel/openvino-rs/raw/main/crates/openvino/tests/fixtures/mobilenet
-if [ -z "${1+x}" ]; then
-    # If no temporary directory is specified, create one.
-    TMP_DIR=$(mktemp -d -t ci-XXXXXXXXXX)
-    REMOVE_TMP_DIR=1
-else
-    # If a directory was specified, use it and avoid removing it.
-    TMP_DIR=$(realpath $1)
-    REMOVE_TMP_DIR=0
-fi
-
-# One of the examples expects to be in a specifically-named directory.
-mkdir -p $TMP_DIR/mobilenet
-TMP_DIR=$TMP_DIR/mobilenet
-
-# Build Wasmtime with wasi-nn enabled; we attempt this first to avoid extra work
-# if the build fails.
-cargo build -p wasmtime-cli --features wasi-nn
-
-# Download all necessary test fixtures to the temporary directory.
-wget --no-clobber $FIXTURE/mobilenet.bin --output-document=$TMP_DIR/model.bin
-wget --no-clobber $FIXTURE/mobilenet.xml --output-document=$TMP_DIR/model.xml
-wget --no-clobber $FIXTURE/tensor-1x224x224x3-f32.bgr --output-document=$TMP_DIR/tensor.bgr
-
-# Now build an example that uses the wasi-nn API. Run the example in Wasmtime
-# (note that the example uses `fixture` as the expected location of the
-# model/tensor files).
-pushd $WASMTIME_DIR/crates/wasi-nn/examples/classification-example
-cargo build --release --target=wasm32-wasi
-cp target/wasm32-wasi/release/wasi-nn-example.wasm $TMP_DIR
-popd
-cargo run -- run --dir fixture::$TMP_DIR -S nn $TMP_DIR/wasi-nn-example.wasm
-
-# Build and run another example, this time using Wasmtime's graph flag to
-# preload the model.
-pushd $WASMTIME_DIR/crates/wasi-nn/examples/classification-example-named
-cargo build --release --target=wasm32-wasi
-cp target/wasm32-wasi/release/wasi-nn-example-named.wasm $TMP_DIR
-popd
-cargo run -- run --dir fixture::$TMP_DIR -S nn,nn-graph=openvino::$TMP_DIR \
-    $TMP_DIR/wasi-nn-example-named.wasm
-
-# Clean up the temporary directory only if it was not specified (users may want
-# to keep the directory around).
-if [[ $REMOVE_TMP_DIR -eq 1 ]]; then
-    rm -rf $TMP_DIR
-fi
diff --git a/ci/update-release-date.rs b/ci/update-release-date.rs
deleted file mode 100644
index 72509bd245bb..000000000000
--- a/ci/update-release-date.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-fn main() {
-    let date = std::env::args().nth(1).unwrap();
-    let relnotes = std::fs::read_to_string("RELEASES.md").unwrap();
-    let mut new_relnotes = String::new();
-    let mut counter = 0;
-    for line in relnotes.lines() {
-        if line.starts_with("Unreleased") {
-            counter += 1;
-            if counter == 2 {
-                new_relnotes.push_str(&format!("Released {}\n", date));
-                continue;
-            }
-        }
-        new_relnotes.push_str(line);
-        new_relnotes.push_str("\n");
-    }
-    std::fs::write("RELEASES.md", new_relnotes).unwrap();
-}
diff --git a/ci/vendor-c-api-headers.sh b/ci/vendor-c-api-headers.sh
new file mode 100755
index 000000000000..fa0b417927d7
--- /dev/null
+++ b/ci/vendor-c-api-headers.sh
@@ -0,0 +1,23 @@
+#!/bin/sh
+
+# Script to re-vendor the headers from the `wasm-c-api` proposal.
+
+rev="2ce1367c9d1271c83fb63bef26d896a2f290cd23"
+files="wasm.h wasm.hh"
+
+set -ex
+
+for file in $files; do
+  dst=crates/c-api/include/$file
+  pretty_url=https://github.com/WebAssembly/wasm-c-api/blob/$rev/include/$file
+  url=https://raw.githubusercontent.com/WebAssembly/wasm-c-api/$rev/include/$file
+  cat >$dst <<-EOF
+// Wasmtime-vendored copy of this header file as present in upstream:
+// <$pretty_url>
+//
+// Wasmtime maintainers can update this vendored copy in-tree with the
+// ./ci/vendor-c-api-headers.sh shell script.
+//
+EOF
+  curl $url >> $dst
+done
diff --git a/ci/vendor-wit.sh b/ci/vendor-wit.sh
new file mode 100755
index 000000000000..55ffdf2a4072
--- /dev/null
+++ b/ci/vendor-wit.sh
@@ -0,0 +1,69 @@
+#!/usr/bin/env bash
+
+# Script to re-vendor the WIT files that Wasmtime uses as defined by a
+# particular tag in upstream repositories.
+#
+# This script is executed on CI to ensure that everything is up-to-date.
+set -ex
+
+# The make_vendor function takes a base path (e.g., "wasi") and a list
+# of packages in the format "name@tag". It constructs the full destination
+# path, downloads the tarballs from GitHub, extracts the relevant files, and
+# removes any unwanted directories.
+make_vendor() {
+  local name=$1
+  local packages=$2
+  local path="crates/$name/wit/deps"
+
+  rm -rf $path
+  mkdir -p $path
+
+  for package in $packages; do
+    IFS='@' read -r repo tag <<< "$package"
+    mkdir -p $path/$repo
+    cached_extracted_dir="$cache_dir/$repo-$tag"
+
+    if [[ ! -d $cached_extracted_dir ]]; then
+      mkdir -p $cached_extracted_dir
+      curl -sL https://github.com/WebAssembly/wasi-$repo/archive/$tag.tar.gz | \
+        tar xzf - --strip-components=1 -C $cached_extracted_dir
+      rm -rf $cached_extracted_dir/wit/deps*
+    fi
+
+    cp -r $cached_extracted_dir/wit/* $path/$repo
+  done
+}
+
+cache_dir=$(mktemp -d)
+
+make_vendor "wasi" "
+  cli@v0.2.1
+  clocks@v0.2.1
+  filesystem@v0.2.1
+  io@v0.2.1
+  random@v0.2.1
+  sockets@v0.2.1
+"
+
+make_vendor "wasi-http" "
+  cli@v0.2.1
+  clocks@v0.2.1
+  filesystem@v0.2.1
+  io@v0.2.1
+  random@v0.2.1
+  sockets@v0.2.1
+  http@v0.2.1
+"
+
+make_vendor "wasi-runtime-config" "runtime-config@c667fe6"
+
+make_vendor "wasi-keyvalue" "keyvalue@219ea36"
+
+rm -rf $cache_dir
+
+# Separately (for now), vendor the `wasi-nn` WIT files since their retrieval is
+# slightly different than above.
+repo=https://raw.githubusercontent.com/WebAssembly/wasi-nn
+revision=0.2.0-rc-2024-08-19
+curl -L $repo/$revision/wasi-nn.witx -o crates/wasi-nn/witx/wasi-nn.witx
+curl -L $repo/$revision/wit/wasi-nn.wit -o crates/wasi-nn/wit/wasi-nn.wit
diff --git a/ci/wasmtime.wxs b/ci/wasmtime.wxs
index ec3a58f9aa13..0e947135d555 100644
--- a/ci/wasmtime.wxs
+++ b/ci/wasmtime.wxs
@@ -62,7 +62,7 @@
 
         <DirectoryRef Id="BINDIR">
             <Component Id="wasmtime.exe" Guid="*">
-                <File Id="wasmtime.exe" Source="target\release\wasmtime.exe" KeyPath="yes" Checksum="yes"/>
+                <File Id="wasmtime.exe" Source="target\x86_64-pc-windows-msvc\release\wasmtime.exe" KeyPath="yes" Checksum="yes"/>
             </Component>
         </DirectoryRef>
 
diff --git a/cranelift/Cargo.toml b/cranelift/Cargo.toml
index f6b271112dbb..74cff6db2e09 100644
--- a/cranelift/Cargo.toml
+++ b/cranelift/Cargo.toml
@@ -8,24 +8,22 @@ documentation = "https://github.com/bytecodealliance/wasmtime/blob/main/cranelif
 repository = "https://github.com/bytecodealliance/wasmtime"
 publish = false
 edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
 
 [[bin]]
 name = "clif-util"
 path = "src/clif-util.rs"
 
-[[test]]
-name = "filetests"
-path = "tests/filetests.rs"
-harness = false
-
 [dependencies]
 cfg-if = { workspace = true }
-cranelift-codegen = { workspace = true, features = ["disas", "trace-log"] }
+cranelift-codegen = { workspace = true, features = ["disas", "trace-log", "timing"] }
 cranelift-entity = { workspace = true }
 cranelift-interpreter = { workspace = true }
 cranelift-reader = { workspace = true }
 cranelift-frontend = { workspace = true }
-cranelift-wasm = { workspace = true, optional = true }
 cranelift-native = { workspace = true }
 cranelift-filetests = { workspace = true }
 cranelift-module = { workspace = true }
@@ -34,9 +32,7 @@ cranelift-jit = { workspace = true }
 cranelift = { workspace = true }
 filecheck = { workspace = true }
 log = { workspace = true }
-termcolor = "1.1.2"
 capstone = { workspace = true, optional = true }
-wat = { workspace = true, optional = true }
 target-lexicon = { workspace = true, features = ["std"] }
 pretty_env_logger = { workspace = true }
 rayon = { version = "1", optional = true }
@@ -44,18 +40,17 @@ indicatif = "0.13.0"
 thiserror = { workspace = true }
 walkdir = { workspace = true }
 anyhow = { workspace = true }
-clap = { workspace = true }
+clap = { workspace = true, features = ['default'] }
 similar = { workspace = true }
 toml = { workspace = true }
 serde = { workspace = true }
-fxhash = "0.2.1"
+rustc-hash  = { workspace = true }
 # Note that this just enables `trace-log` for `clif-util` and doesn't turn it on
 # for all of Cranelift, which would be bad.
 regalloc2 = { workspace = true, features = ["trace-log"] }
 
 [features]
-default = ["disas", "wasm", "cranelift-codegen/all-arch", "cranelift-codegen/trace-log", "souper-harvest"]
+default = ["disas", "cranelift-codegen/all-arch", "cranelift-codegen/trace-log", "souper-harvest"]
 disas = ["capstone"]
-wasm = ["wat", "cranelift-wasm"]
 souper-harvest = ["cranelift-codegen/souper-harvest", "rayon"]
 all-arch = ["cranelift-codegen/all-arch"]
diff --git a/cranelift/bforest/Cargo.toml b/cranelift/bforest/Cargo.toml
index d55fdad495ee..41192317b9a2 100644
--- a/cranelift/bforest/Cargo.toml
+++ b/cranelift/bforest/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 authors = ["The Cranelift Project Developers"]
 name = "cranelift-bforest"
-version = "0.101.0"
+version = "0.112.0"
 description = "A forest of B+-trees"
 license = "Apache-2.0 WITH LLVM-exception"
 documentation = "https://docs.rs/cranelift-bforest"
@@ -10,6 +10,10 @@ categories = ["no-std"]
 readme = "README.md"
 keywords = ["btree", "forest", "set", "map"]
 edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
 
 [dependencies]
 cranelift-entity = { workspace = true }
diff --git a/cranelift/bforest/src/lib.rs b/cranelift/bforest/src/lib.rs
index b0145d63d6a8..90eda03d85f6 100644
--- a/cranelift/bforest/src/lib.rs
+++ b/cranelift/bforest/src/lib.rs
@@ -13,8 +13,7 @@
 //! - Empty trees have a very small 32-bit footprint.
 //! - All the trees in a forest can be cleared in constant time.
 
-#![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)]
-#![warn(unused_import_braces)]
+#![deny(missing_docs)]
 #![no_std]
 
 #[cfg(test)]
diff --git a/cranelift/bforest/src/map.rs b/cranelift/bforest/src/map.rs
index 05732b61cc13..d539e1d8cc4e 100644
--- a/cranelift/bforest/src/map.rs
+++ b/cranelift/bforest/src/map.rs
@@ -426,7 +426,6 @@ where
 
 #[cfg(test)]
 mod tests {
-    use super::super::NodeData;
     use super::*;
     use alloc::vec::Vec;
     use core::mem;
diff --git a/cranelift/bforest/src/node.rs b/cranelift/bforest/src/node.rs
index 53a0dca38615..443c112ed888 100644
--- a/cranelift/bforest/src/node.rs
+++ b/cranelift/bforest/src/node.rs
@@ -174,7 +174,7 @@ impl<F: Forest> NodeData<F> {
             } => {
                 let sz = usize::from(*size);
                 debug_assert!(sz <= keys.len());
-                debug_assert!(index <= sz, "Can't insert at {} with {} keys", index, sz);
+                debug_assert!(index <= sz, "Can't insert at {index} with {sz} keys");
 
                 if let Some(ks) = keys.get_mut(0..=sz) {
                     *size = (sz + 1) as u8;
@@ -547,7 +547,7 @@ impl ValDisp for SetValue {
 
 impl<T: fmt::Display> ValDisp for T {
     fn valfmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, ":{}", self)
+        write!(f, ":{self}")
     }
 }
 
@@ -576,7 +576,7 @@ where
                 }
                 write!(f, " ]")
             }
-            Self::Free { next: Some(n) } => write!(f, "[ free -> {} ]", n),
+            Self::Free { next: Some(n) } => write!(f, "[ free -> {n} ]"),
             Self::Free { next: None } => write!(f, "[ free ]"),
         }
     }
@@ -641,7 +641,7 @@ mod tests {
 
         // Splitting should be independent of the hint because we have an even number of node
         // references.
-        let saved = inner.clone();
+        let saved = inner;
         let sp = inner.split(1);
         assert_eq!(sp.lhs_entries, 4);
         assert_eq!(sp.rhs_entries, 4);
@@ -691,7 +691,7 @@ mod tests {
         assert!(!leaf.try_leaf_insert(15, 'x', SetValue()));
 
         // The index given to `split` is not the split position, it's a hint for balancing the node.
-        let saved = leaf.clone();
+        let saved = leaf;
         let sp = leaf.split(12);
         assert_eq!(sp.lhs_entries, 8);
         assert_eq!(sp.rhs_entries, 7);
diff --git a/cranelift/bforest/src/path.rs b/cranelift/bforest/src/path.rs
index a55de6b2ae2b..896bd0e23db2 100644
--- a/cranelift/bforest/src/path.rs
+++ b/cranelift/bforest/src/path.rs
@@ -651,11 +651,7 @@ impl<F: Forest> Path<F> {
         for level in 0..self.size {
             match pool[self.node[level]] {
                 NodeData::Inner { size, tree, .. } => {
-                    assert!(
-                        level < self.size - 1,
-                        "Expected leaf node at level {}",
-                        level
-                    );
+                    assert!(level < self.size - 1, "Expected leaf node at level {level}");
                     assert!(
                         self.entry[level] <= size,
                         "OOB inner entry {}/{} at level {}",
@@ -666,8 +662,7 @@ impl<F: Forest> Path<F> {
                     assert_eq!(
                         self.node[level + 1],
                         tree[usize::from(self.entry[level])],
-                        "Node mismatch at level {}",
-                        level
+                        "Node mismatch at level {level}"
                     );
                 }
                 NodeData::Leaf { size, .. } => {
@@ -704,7 +699,6 @@ impl<F: Forest> fmt::Display for Path<F> {
 
 #[cfg(test)]
 mod tests {
-    use super::super::{Forest, NodeData, NodePool};
     use super::*;
     use core::cmp::Ordering;
 
diff --git a/cranelift/bforest/src/pool.rs b/cranelift/bforest/src/pool.rs
index a2e416ad57f7..9e3f57fccedd 100644
--- a/cranelift/bforest/src/pool.rs
+++ b/cranelift/bforest/src/pool.rs
@@ -52,7 +52,7 @@ impl<F: Forest> NodePool<F> {
     /// Free a node.
     pub fn free_node(&mut self, node: Node) {
         // Quick check for a double free.
-        debug_assert!(!self.nodes[node].is_free(), "{} is already free", node);
+        debug_assert!(!self.nodes[node].is_free(), "{node} is already free");
         self.nodes[node] = NodeData::Free {
             next: self.freelist,
         };
@@ -162,7 +162,7 @@ impl<F: Forest> NodePool<F> {
 
                     // Verify occupancy.
                     // Right-most nodes can be small, but others must be at least half full.
-                    assert!(size > 0, "Leaf {} is empty", node);
+                    assert!(size > 0, "Leaf {node} is empty");
                     assert!(
                         rkey.is_none() || size * 2 >= capacity,
                         "Only {}/{} entries in {}:{}, upper={}",
diff --git a/cranelift/bforest/src/set.rs b/cranelift/bforest/src/set.rs
index 543c4a414587..34a3063c2f3d 100644
--- a/cranelift/bforest/src/set.rs
+++ b/cranelift/bforest/src/set.rs
@@ -354,7 +354,6 @@ where
 
 #[cfg(test)]
 mod tests {
-    use super::super::NodeData;
     use super::*;
     use alloc::vec::Vec;
     use core::mem;
diff --git a/cranelift/bitset/Cargo.toml b/cranelift/bitset/Cargo.toml
new file mode 100644
index 000000000000..2e6d2dd06112
--- /dev/null
+++ b/cranelift/bitset/Cargo.toml
@@ -0,0 +1,22 @@
+[package]
+authors = ["The Cranelift Project Developers"]
+name = "cranelift-bitset"
+version = "0.112.0"
+description = "Various bitset stuff for use inside Cranelift"
+license = "Apache-2.0 WITH LLVM-exception"
+documentation = "https://docs.rs/cranelift-bitset"
+repository = "https://github.com/bytecodealliance/wasmtime"
+edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
+
+[dependencies]
+arbitrary = { workspace = true, optional = true }
+serde = { workspace = true, optional = true }
+serde_derive = { workspace = true, optional = true }
+
+[features]
+enable-serde = ["dep:serde", "dep:serde_derive"]
+arbitrary = ["dep:arbitrary"]
diff --git a/cranelift/bitset/src/compound.rs b/cranelift/bitset/src/compound.rs
new file mode 100644
index 000000000000..ebb9b4e7d703
--- /dev/null
+++ b/cranelift/bitset/src/compound.rs
@@ -0,0 +1,508 @@
+//! Compound bit sets.
+
+use crate::scalar::{self, ScalarBitSet};
+use alloc::boxed::Box;
+use core::{cmp, iter, mem};
+
+/// A large bit set backed by dynamically-sized storage.
+///
+/// # Example
+///
+/// ```
+/// use cranelift_bitset::CompoundBitSet;
+///
+/// // Create a new bitset.
+/// let mut bitset = CompoundBitSet::new();
+///
+/// // Bitsets are initially empty.
+/// assert!(bitset.is_empty());
+/// assert_eq!(bitset.len(), 0);
+///
+/// // Insert into the bitset.
+/// bitset.insert(444);
+/// bitset.insert(555);
+/// bitset.insert(666);
+///
+/// // Now the bitset is not empty.
+/// assert_eq!(bitset.len(), 3);
+/// assert!(!bitset.is_empty());
+/// assert!(bitset.contains(444));
+/// assert!(bitset.contains(555));
+/// assert!(bitset.contains(666));
+///
+/// // Remove an element from the bitset.
+/// let was_present = bitset.remove(666);
+/// assert!(was_present);
+/// assert!(!bitset.contains(666));
+/// assert_eq!(bitset.len(), 2);
+///
+/// // Can iterate over the elements in the set.
+/// let elems: Vec<_> = bitset.iter().collect();
+/// assert_eq!(elems, [444, 555]);
+/// ```
+#[derive(Clone, Default, PartialEq, Eq)]
+#[cfg_attr(
+    feature = "enable-serde",
+    derive(serde_derive::Serialize, serde_derive::Deserialize)
+)]
+pub struct CompoundBitSet {
+    elems: Box<[ScalarBitSet<usize>]>,
+    max: Option<u32>,
+}
+
+impl core::fmt::Debug for CompoundBitSet {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "CompoundBitSet ")?;
+        f.debug_set().entries(self.iter()).finish()
+    }
+}
+
+const BITS_PER_WORD: usize = mem::size_of::<usize>() * 8;
+
+impl CompoundBitSet {
+    /// Construct a new, empty bit set.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cranelift_bitset::CompoundBitSet;
+    ///
+    /// let bitset = CompoundBitSet::new();
+    ///
+    /// assert!(bitset.is_empty());
+    /// ```
+    #[inline]
+    pub fn new() -> Self {
+        CompoundBitSet::default()
+    }
+
+    /// Construct a new, empty bit set with space reserved to store any element
+    /// `x` such that `x < capacity`.
+    ///
+    /// The actual capacity reserved may be greater than that requested.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cranelift_bitset::CompoundBitSet;
+    ///
+    /// let bitset = CompoundBitSet::with_capacity(4096);
+    ///
+    /// assert!(bitset.is_empty());
+    /// assert!(bitset.capacity() >= 4096);
+    /// ```
+    #[inline]
+    pub fn with_capacity(capacity: usize) -> Self {
+        let mut bitset = Self::new();
+        bitset.ensure_capacity(capacity);
+        bitset
+    }
+
+    /// Get the number of elements in this bitset.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cranelift_bitset::CompoundBitSet;
+    ///
+    /// let mut bitset = CompoundBitSet::new();
+    ///
+    /// assert_eq!(bitset.len(), 0);
+    ///
+    /// bitset.insert(24);
+    /// bitset.insert(130);
+    /// bitset.insert(3600);
+    ///
+    /// assert_eq!(bitset.len(), 3);
+    /// ```
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.elems.iter().map(|sub| usize::from(sub.len())).sum()
+    }
+
+    /// Get `n + 1` where `n` is the largest value that can be stored inside
+    /// this set without growing the backing storage.
+    ///
+    /// That is, this set can store any value `x` such that `x <
+    /// bitset.capacity()` without growing the backing storage.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cranelift_bitset::CompoundBitSet;
+    ///
+    /// let mut bitset = CompoundBitSet::new();
+    ///
+    /// // New bitsets have zero capacity -- they allocate lazily.
+    /// assert_eq!(bitset.capacity(), 0);
+    ///
+    /// // Insert into the bitset, growing its capacity.
+    /// bitset.insert(999);
+    ///
+    /// // The bitset must now have capacity for at least `999` elements,
+    /// // perhaps more.
+    /// assert!(bitset.capacity() >= 999);
+    ///```
+    pub fn capacity(&self) -> usize {
+        self.elems.len() * BITS_PER_WORD
+    }
+
+    /// Is this bitset empty?
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cranelift_bitset::CompoundBitSet;
+    ///
+    /// let mut bitset = CompoundBitSet::new();
+    ///
+    /// assert!(bitset.is_empty());
+    ///
+    /// bitset.insert(1234);
+    ///
+    /// assert!(!bitset.is_empty());
+    /// ```
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Convert an element `i` into the `word` that can be used to index into
+    /// `self.elems` and the `bit` that can be tested in the
+    /// `ScalarBitSet<usize>` at `self.elems[word]`.
+    #[inline]
+    fn word_and_bit(i: usize) -> (usize, u8) {
+        let word = i / BITS_PER_WORD;
+        let bit = i % BITS_PER_WORD;
+        let bit = u8::try_from(bit).unwrap();
+        (word, bit)
+    }
+
+    /// The opposite of `word_and_bit`: convert the pair of an index into
+    /// `self.elems` and associated bit index into a set element.
+    #[inline]
+    fn elem(word: usize, bit: u8) -> usize {
+        let bit = usize::from(bit);
+        debug_assert!(bit < BITS_PER_WORD);
+        word * BITS_PER_WORD + bit
+    }
+
+    /// Is `i` contained in this bitset?
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cranelift_bitset::CompoundBitSet;
+    ///
+    /// let mut bitset = CompoundBitSet::new();
+    ///
+    /// assert!(!bitset.contains(666));
+    ///
+    /// bitset.insert(666);
+    ///
+    /// assert!(bitset.contains(666));
+    /// ```
+    #[inline]
+    pub fn contains(&self, i: usize) -> bool {
+        let (word, bit) = Self::word_and_bit(i);
+        if word < self.elems.len() {
+            self.elems[word].contains(bit)
+        } else {
+            false
+        }
+    }
+
+    /// Ensure there is space in this bitset for the values `0..n`, growing the
+    /// backing storage if necessary.
+    ///
+    /// After calling `bitset.ensure_capacity(n)`, inserting any element `i`
+    /// where `i < n` is guaranteed to succeed without growing the bitset's
+    /// backing storage.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use cranelift_bitset::CompoundBitSet;
+    /// # let mut bitset = CompoundBitSet::new();
+    /// // We are going to do a series of inserts where `1000` will be the
+    /// // maximum value inserted. Make sure that our bitset has capacity for
+    /// // these elements once up front, to avoid growing the backing storage
+    /// // multiple times incrementally.
+    /// bitset.ensure_capacity(1001);
+    ///
+    /// for i in 0..=1000 {
+    ///     if i % 2 == 0 {
+    ///         // Inserting this value should not require growing the backing
+    ///         // storage.
+    ///         assert!(bitset.capacity() > i);
+    ///         bitset.insert(i);
+    ///     }
+    /// }
+    /// ```
+    #[inline]
+    pub fn ensure_capacity(&mut self, n: usize) {
+        let (word, _bit) = Self::word_and_bit(n);
+        if word >= self.elems.len() {
+            assert!(word < usize::try_from(isize::MAX).unwrap());
+
+            let delta = word - self.elems.len();
+            let to_grow = delta + 1;
+
+            // Amortize the cost of growing.
+            let to_grow = cmp::max(to_grow, self.elems.len() * 2);
+            // Don't make ridiculously small allocations.
+            let to_grow = cmp::max(to_grow, 4);
+
+            let new_elems = self
+                .elems
+                .iter()
+                .copied()
+                .chain(iter::repeat(ScalarBitSet::new()).take(to_grow))
+                .collect::<Box<[_]>>();
+            self.elems = new_elems;
+        }
+    }
+
+    /// Insert `i` into this bitset.
+    ///
+    /// Returns whether the value was newly inserted. That is:
+    ///
+    /// * If the set did not previously contain `i` then `true` is returned.
+    ///
+    /// * If the set already contained `i` then `false` is returned.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cranelift_bitset::CompoundBitSet;
+    ///
+    /// let mut bitset = CompoundBitSet::new();
+    ///
+    /// // When an element is inserted that was not already present in the set,
+    /// // then `true` is returned.
+    /// let is_new = bitset.insert(1234);
+    /// assert!(is_new);
+    ///
+    /// // The element is now present in the set.
+    /// assert!(bitset.contains(1234));
+    ///
+    /// // And when the element is already in the set, `false` is returned from
+    /// // `insert`.
+    /// let is_new = bitset.insert(1234);
+    /// assert!(!is_new);
+    /// ```
+    #[inline]
+    pub fn insert(&mut self, i: usize) -> bool {
+        self.ensure_capacity(i + 1);
+
+        let (word, bit) = Self::word_and_bit(i);
+        let is_new = self.elems[word].insert(bit);
+
+        let i = u32::try_from(i).unwrap();
+        self.max = self.max.map(|max| cmp::max(max, i)).or(Some(i));
+
+        is_new
+    }
+
+    /// Remove `i` from this bitset.
+    ///
+    /// Returns whether `i` was previously in this set or not.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cranelift_bitset::CompoundBitSet;
+    ///
+    /// let mut bitset = CompoundBitSet::new();
+    ///
+    /// // Removing an element that was not present in the set returns `false`.
+    /// let was_present = bitset.remove(456);
+    /// assert!(!was_present);
+    ///
+    /// // And when the element was in the set, `true` is returned.
+    /// bitset.insert(456);
+    /// let was_present = bitset.remove(456);
+    /// assert!(was_present);
+    /// ```
+    #[inline]
+    pub fn remove(&mut self, i: usize) -> bool {
+        let (word, bit) = Self::word_and_bit(i);
+        if word < self.elems.len() {
+            let sub = &mut self.elems[word];
+            let was_present = sub.remove(bit);
+            if was_present && self.max() == Some(i) {
+                self.update_max(word);
+            }
+            was_present
+        } else {
+            false
+        }
+    }
+
+    /// Update the `self.max` field, based on the old word index of `self.max`.
+    fn update_max(&mut self, word_of_old_max: usize) {
+        self.max = self.elems[0..word_of_old_max + 1]
+            .iter()
+            .enumerate()
+            .rev()
+            .filter_map(|(word, sub)| {
+                let bit = sub.max()?;
+                Some(u32::try_from(Self::elem(word, bit)).unwrap())
+            })
+            .next();
+    }
+
+    /// Get the largest value in this set, or `None` if this set is empty.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cranelift_bitset::CompoundBitSet;
+    ///
+    /// let mut bitset = CompoundBitSet::new();
+    ///
+    /// // Returns `None` if the bitset is empty.
+    /// assert!(bitset.max().is_none());
+    ///
+    /// bitset.insert(123);
+    /// bitset.insert(987);
+    /// bitset.insert(999);
+    ///
+    /// // Otherwise, it returns the largest value in the set.
+    /// assert_eq!(bitset.max(), Some(999));
+    /// ```
+    #[inline]
+    pub fn max(&self) -> Option<usize> {
+        self.max.map(|m| usize::try_from(m).unwrap())
+    }
+
+    /// Removes and returns the largest value in this set.
+    ///
+    /// Returns `None` if this set is empty.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cranelift_bitset::CompoundBitSet;
+    ///
+    /// let mut bitset = CompoundBitSet::new();
+    ///
+    /// bitset.insert(111);
+    /// bitset.insert(222);
+    /// bitset.insert(333);
+    /// bitset.insert(444);
+    /// bitset.insert(555);
+    ///
+    /// assert_eq!(bitset.pop(), Some(555));
+    /// assert_eq!(bitset.pop(), Some(444));
+    /// assert_eq!(bitset.pop(), Some(333));
+    /// assert_eq!(bitset.pop(), Some(222));
+    /// assert_eq!(bitset.pop(), Some(111));
+    /// assert_eq!(bitset.pop(), None);
+    /// ```
+    #[inline]
+    pub fn pop(&mut self) -> Option<usize> {
+        let max = self.max()?;
+        self.remove(max);
+        Some(max)
+    }
+
+    /// Remove all elements from this bitset.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cranelift_bitset::CompoundBitSet;
+    ///
+    /// let mut bitset = CompoundBitSet::new();
+    ///
+    /// bitset.insert(100);
+    /// bitset.insert(200);
+    /// bitset.insert(300);
+    ///
+    /// bitset.clear();
+    ///
+    /// assert!(bitset.is_empty());
+    /// ```
+    #[inline]
+    pub fn clear(&mut self) {
+        let max = match self.max() {
+            Some(max) => max,
+            None => return,
+        };
+        let (word, _bit) = Self::word_and_bit(max);
+        debug_assert!(self.elems[word + 1..].iter().all(|sub| sub.is_empty()));
+        for sub in &mut self.elems[..=word] {
+            *sub = ScalarBitSet::new();
+        }
+        self.max = None;
+    }
+
+    /// Iterate over the elements in this bitset.
+    ///
+    /// The elements are always yielded in sorted order.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cranelift_bitset::CompoundBitSet;
+    ///
+    /// let mut bitset = CompoundBitSet::new();
+    ///
+    /// bitset.insert(0);
+    /// bitset.insert(4096);
+    /// bitset.insert(123);
+    /// bitset.insert(456);
+    /// bitset.insert(789);
+    ///
+    /// assert_eq!(
+    ///     bitset.iter().collect::<Vec<_>>(),
+    ///     [0, 123, 456, 789, 4096],
+    /// );
+    /// ```
+    #[inline]
+    pub fn iter(&self) -> Iter<'_> {
+        Iter {
+            bitset: self,
+            word: 0,
+            sub: None,
+        }
+    }
+}
+
+impl<'a> IntoIterator for &'a CompoundBitSet {
+    type Item = usize;
+
+    type IntoIter = Iter<'a>;
+
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+/// An iterator over the elements in a [`CompoundBitSet`].
+pub struct Iter<'a> {
+    bitset: &'a CompoundBitSet,
+    word: usize,
+    sub: Option<scalar::Iter<usize>>,
+}
+
+impl Iterator for Iter<'_> {
+    type Item = usize;
+
+    #[inline]
+    fn next(&mut self) -> Option<usize> {
+        loop {
+            if let Some(sub) = &mut self.sub {
+                if let Some(bit) = sub.next() {
+                    return Some(CompoundBitSet::elem(self.word, bit));
+                } else {
+                    self.word += 1;
+                }
+            }
+
+            self.sub = Some(self.bitset.elems.get(self.word)?.iter());
+        }
+    }
+}
diff --git a/cranelift/bitset/src/lib.rs b/cranelift/bitset/src/lib.rs
new file mode 100644
index 000000000000..5a9fd354aa15
--- /dev/null
+++ b/cranelift/bitset/src/lib.rs
@@ -0,0 +1,19 @@
+//! Bitsets for Cranelift.
+//!
+//! This module provides two bitset implementations:
+//!
+//! 1. [`ScalarBitSet`]: A small bitset built on top of a single integer.
+//!
+//! 2. [`CompoundBitSet`]: A bitset that can store more bits than fit in a
+//!    single integer, but which internally has heap allocations.
+
+#![deny(missing_docs)]
+#![no_std]
+
+extern crate alloc;
+
+pub mod compound;
+pub mod scalar;
+
+pub use compound::CompoundBitSet;
+pub use scalar::ScalarBitSet;
diff --git a/cranelift/bitset/src/scalar.rs b/cranelift/bitset/src/scalar.rs
new file mode 100644
index 000000000000..07649c297efe
--- /dev/null
+++ b/cranelift/bitset/src/scalar.rs
@@ -0,0 +1,626 @@
+//! Scalar bitsets.
+
+use core::mem::size_of;
+use core::ops::{Add, BitAnd, BitOr, Not, Shl, Shr, Sub};
+
+/// A small bitset built on top of a single primitive integer type.
+///
+/// # Example
+///
+/// ```
+/// use cranelift_bitset::ScalarBitSet;
+///
+/// // Create a new bitset backed with a `u32`.
+/// let mut bitset = ScalarBitSet::<u32>::new();
+///
+/// // Bitsets are initially empty.
+/// assert!(bitset.is_empty());
+/// assert_eq!(bitset.len(), 0);
+///
+/// // Insert into the bitset.
+/// bitset.insert(4);
+/// bitset.insert(5);
+/// bitset.insert(6);
+///
+/// // Now the bitset is not empty.
+/// assert_eq!(bitset.len(), 3);
+/// assert!(!bitset.is_empty());
+/// assert!(bitset.contains(4));
+/// assert!(bitset.contains(5));
+/// assert!(bitset.contains(6));
+///
+/// // Remove an element from the bitset.
+/// let was_present = bitset.remove(6);
+/// assert!(was_present);
+/// assert!(!bitset.contains(6));
+/// assert_eq!(bitset.len(), 2);
+///
+/// // Can iterate over the elements in the set.
+/// let elems: Vec<_> = bitset.iter().collect();
+/// assert_eq!(elems, [4, 5]);
+/// ```
+#[derive(Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(
+    feature = "enable-serde",
+    derive(serde_derive::Serialize, serde_derive::Deserialize)
+)]
+pub struct ScalarBitSet<T>(pub T);
+
+impl<T> core::fmt::Debug for ScalarBitSet<T>
+where
+    T: ScalarBitSetStorage,
+{
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        let mut s = f.debug_struct(core::any::type_name::<Self>());
+        for i in 0..Self::capacity() {
+            use alloc::string::ToString;
+            let i = u8::try_from(i).unwrap();
+            s.field(&i.to_string(), &self.contains(i));
+        }
+        s.finish()
+    }
+}
+
+impl<T> Default for ScalarBitSet<T>
+where
+    T: ScalarBitSetStorage,
+{
+    #[inline]
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<T> ScalarBitSet<T>
+where
+    T: ScalarBitSetStorage,
+{
+    /// Create a new, empty bitset.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cranelift_bitset::ScalarBitSet;
+    ///
+    /// let bitset = ScalarBitSet::<u64>::new();
+    ///
+    /// assert!(bitset.is_empty());
+    /// ```
+    #[inline]
+    pub fn new() -> Self {
+        Self(T::from(0))
+    }
+
+    /// Construct a bitset with the half-open range `[lo, hi)` inserted.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cranelift_bitset::ScalarBitSet;
+    ///
+    /// let bitset = ScalarBitSet::<u64>::from_range(3, 6);
+    ///
+    /// assert_eq!(bitset.len(), 3);
+    ///
+    /// assert!(bitset.contains(3));
+    /// assert!(bitset.contains(4));
+    /// assert!(bitset.contains(5));
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// Panics if `lo > hi` or if `hi > Self::capacity()`.
+    ///
+    /// ```should_panic
+    /// use cranelift_bitset::ScalarBitSet;
+    ///
+    /// // The lower bound may not be larger than the upper bound.
+    /// let bitset = ScalarBitSet::<u64>::from_range(6, 3);
+    /// ```
+    ///
+    /// ```should_panic
+    /// use cranelift_bitset::ScalarBitSet;
+    ///
+    /// // The bounds must fit within the backing scalar type.
+    /// let bitset = ScalarBitSet::<u64>::from_range(3, 69);
+    /// ```
+    #[inline]
+    pub fn from_range(lo: u8, hi: u8) -> Self {
+        assert!(lo <= hi);
+        assert!(hi <= Self::capacity());
+
+        let one = T::from(1);
+
+        // We can't just do (one << hi) - one here as the shift may overflow
+        let hi_rng = if hi >= 1 {
+            (one << (hi - 1)) + ((one << (hi - 1)) - one)
+        } else {
+            T::from(0)
+        };
+
+        let lo_rng = (one << lo) - one;
+
+        Self(hi_rng - lo_rng)
+    }
+
+    /// The maximum number of bits that can be stored in this bitset.
+    ///
+    /// If you need more bits than this, use a
+    /// [`CompoundBitSet`][crate::CompoundBitSet] instead of a `ScalarBitSet`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cranelift_bitset::ScalarBitSet;
+    ///
+    /// assert_eq!(ScalarBitSet::<u8>::capacity(), 8);
+    /// assert_eq!(ScalarBitSet::<u64>::capacity(), 64);
+    /// ```
+    #[inline]
+    pub fn capacity() -> u8 {
+        u8::try_from(size_of::<T>()).unwrap() * 8
+    }
+
+    /// Get the number of elements in this set.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cranelift_bitset::ScalarBitSet;
+    ///
+    /// let mut bitset = ScalarBitSet::<u64>::new();
+    ///
+    /// assert_eq!(bitset.len(), 0);
+    ///
+    /// bitset.insert(24);
+    /// bitset.insert(13);
+    /// bitset.insert(36);
+    ///
+    /// assert_eq!(bitset.len(), 3);
+    /// ```
+    #[inline]
+    pub fn len(&self) -> u8 {
+        self.0.count_ones()
+    }
+
+    /// Is this bitset empty?
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cranelift_bitset::ScalarBitSet;
+    ///
+    /// let mut bitset = ScalarBitSet::<u16>::new();
+    ///
+    /// assert!(bitset.is_empty());
+    ///
+    /// bitset.insert(10);
+    ///
+    /// assert!(!bitset.is_empty());
+    /// ```
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.0 == T::from(0)
+    }
+
+    /// Check whether this bitset contains `i`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cranelift_bitset::ScalarBitSet;
+    ///
+    /// let mut bitset = ScalarBitSet::<u8>::new();
+    ///
+    /// assert!(!bitset.contains(7));
+    ///
+    /// bitset.insert(7);
+    ///
+    /// assert!(bitset.contains(7));
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// Panics if `i` is greater than or equal to [`Self::capacity()`][Self::capacity].
+    ///
+    /// ```should_panic
+    /// use cranelift_bitset::ScalarBitSet;
+    ///
+    /// let mut bitset = ScalarBitSet::<u8>::new();
+    ///
+    /// // A `ScalarBitSet<u8>` can only hold the elements `0..=7`, so `8` is
+    /// // out of bounds and will trigger a panic.
+    /// bitset.contains(8);
+    /// ```
+    #[inline]
+    pub fn contains(&self, i: u8) -> bool {
+        assert!(i < Self::capacity());
+        self.0 & (T::from(1) << i) != T::from(0)
+    }
+
+    /// Insert `i` into this bitset.
+    ///
+    /// Returns whether the value was newly inserted. That is:
+    ///
+    /// * If the set did not previously contain `i` then `true` is returned.
+    ///
+    /// * If the set already contained `i` then `false` is returned.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cranelift_bitset::ScalarBitSet;
+    ///
+    /// let mut bitset = ScalarBitSet::<u8>::new();
+    ///
+    /// // When an element is inserted that was not already present in the set,
+    /// // then `true` is returned.
+    /// let is_new = bitset.insert(7);
+    /// assert!(is_new);
+    ///
+    /// // The element is now present in the set.
+    /// assert!(bitset.contains(7));
+    ///
+    /// // And when the element is already in the set, `false` is returned from
+    /// // `insert`.
+    /// let is_new = bitset.insert(7);
+    /// assert!(!is_new);
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// Panics if `i` is greater than or equal to [`Self::capacity()`][Self::capacity].
+    ///
+    /// ```should_panic
+    /// use cranelift_bitset::ScalarBitSet;
+    ///
+    /// let mut bitset = ScalarBitSet::<u32>::new();
+    ///
+    /// // A `ScalarBitSet<u32>` can only hold the elements `0..=31`, so `42` is
+    /// // out of bounds and will trigger a panic.
+    /// bitset.insert(42);
+    /// ```
+    #[inline]
+    pub fn insert(&mut self, i: u8) -> bool {
+        let is_new = !self.contains(i);
+        self.0 = self.0 | (T::from(1) << i);
+        is_new
+    }
+
+    /// Remove `i` from this bitset.
+    ///
+    /// Returns whether `i` was previously in this set or not.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cranelift_bitset::ScalarBitSet;
+    ///
+    /// let mut bitset = ScalarBitSet::<u128>::new();
+    ///
+    /// // Removing an element that was not present in the set returns `false`.
+    /// let was_present = bitset.remove(100);
+    /// assert!(!was_present);
+    ///
+    /// // And when the element was in the set, `true` is returned.
+    /// bitset.insert(100);
+    /// let was_present = bitset.remove(100);
+    /// assert!(was_present);
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// Panics if `i` is greater than or equal to [`Self::capacity()`][Self::capacity].
+    ///
+    /// ```should_panic
+    /// use cranelift_bitset::ScalarBitSet;
+    ///
+    /// let mut bitset = ScalarBitSet::<u16>::new();
+    ///
+    /// // A `ScalarBitSet<u16>` can only hold the elements `0..=15`, so `20` is
+    /// // out of bounds and will trigger a panic.
+    /// bitset.remove(20);
+    /// ```
+    #[inline]
+    pub fn remove(&mut self, i: u8) -> bool {
+        let was_present = self.contains(i);
+        self.0 = self.0 & !(T::from(1) << i);
+        was_present
+    }
+
+    /// Remove all entries from this bitset.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cranelift_bitset::ScalarBitSet;
+    ///
+    /// let mut bitset = ScalarBitSet::<u32>::new();
+    ///
+    /// bitset.insert(10);
+    /// bitset.insert(20);
+    /// bitset.insert(30);
+    ///
+    /// bitset.clear();
+    ///
+    /// assert!(bitset.is_empty());
+    /// ```
+    #[inline]
+    pub fn clear(&mut self) {
+        self.0 = T::from(0);
+    }
+
+    /// Remove and return the smallest value in the bitset.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cranelift_bitset::ScalarBitSet;
+    ///
+    /// let mut bitset = ScalarBitSet::<u64>::new();
+    ///
+    /// bitset.insert(0);
+    /// bitset.insert(24);
+    /// bitset.insert(13);
+    /// bitset.insert(36);
+    ///
+    /// assert_eq!(bitset.pop_min(), Some(0));
+    /// assert_eq!(bitset.pop_min(), Some(13));
+    /// assert_eq!(bitset.pop_min(), Some(24));
+    /// assert_eq!(bitset.pop_min(), Some(36));
+    /// assert_eq!(bitset.pop_min(), None);
+    /// ```
+    #[inline]
+    pub fn pop_min(&mut self) -> Option<u8> {
+        let min = self.min()?;
+        self.remove(min);
+        Some(min)
+    }
+
+    /// Remove and return the largest value in the bitset.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cranelift_bitset::ScalarBitSet;
+    ///
+    /// let mut bitset = ScalarBitSet::<u64>::new();
+    ///
+    /// bitset.insert(0);
+    /// bitset.insert(24);
+    /// bitset.insert(13);
+    /// bitset.insert(36);
+    ///
+    /// assert_eq!(bitset.pop_max(), Some(36));
+    /// assert_eq!(bitset.pop_max(), Some(24));
+    /// assert_eq!(bitset.pop_max(), Some(13));
+    /// assert_eq!(bitset.pop_max(), Some(0));
+    /// assert_eq!(bitset.pop_max(), None);
+    /// ```
+    #[inline]
+    pub fn pop_max(&mut self) -> Option<u8> {
+        let max = self.max()?;
+        self.remove(max);
+        Some(max)
+    }
+
+    /// Return the smallest number contained in this bitset or `None` if this
+    /// bitset is empty.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cranelift_bitset::ScalarBitSet;
+    ///
+    /// let mut bitset = ScalarBitSet::<u64>::new();
+    ///
+    /// // When the bitset is empty, `min` returns `None`.
+    /// assert_eq!(bitset.min(), None);
+    ///
+    /// bitset.insert(28);
+    /// bitset.insert(1);
+    /// bitset.insert(63);
+    ///
+    /// // When the bitset is not empty, it returns the smallest element.
+    /// assert_eq!(bitset.min(), Some(1));
+    /// ```
+    #[inline]
+    pub fn min(&self) -> Option<u8> {
+        if self.0 == T::from(0) {
+            None
+        } else {
+            Some(self.0.trailing_zeros())
+        }
+    }
+
+    /// Return the largest number contained in the bitset or None if this bitset
+    /// is empty
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cranelift_bitset::ScalarBitSet;
+    ///
+    /// let mut bitset = ScalarBitSet::<u64>::new();
+    ///
+    /// // When the bitset is empty, `max` returns `None`.
+    /// assert_eq!(bitset.max(), None);
+    ///
+    /// bitset.insert(0);
+    /// bitset.insert(36);
+    /// bitset.insert(49);
+    ///
+    /// // When the bitset is not empty, it returns the smallest element.
+    /// assert_eq!(bitset.max(), Some(49));
+    /// ```
+    #[inline]
+    pub fn max(&self) -> Option<u8> {
+        if self.0 == T::from(0) {
+            None
+        } else {
+            let leading_zeroes = self.0.leading_zeros();
+            Some(Self::capacity() - leading_zeroes - 1)
+        }
+    }
+
+    /// Iterate over the items in this set.
+    ///
+    /// Items are always yielded in sorted order.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cranelift_bitset::ScalarBitSet;
+    ///
+    /// let mut bitset = ScalarBitSet::<u64>::new();
+    ///
+    /// bitset.insert(19);
+    /// bitset.insert(3);
+    /// bitset.insert(63);
+    /// bitset.insert(0);
+    ///
+    /// assert_eq!(
+    ///     bitset.iter().collect::<Vec<_>>(),
+    ///     [0, 3, 19, 63],
+    /// );
+    /// ```
+    #[inline]
+    pub fn iter(self) -> Iter<T> {
+        Iter { bitset: self }
+    }
+}
+
+impl<T> IntoIterator for ScalarBitSet<T>
+where
+    T: ScalarBitSetStorage,
+{
+    type Item = u8;
+
+    type IntoIter = Iter<T>;
+
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+impl<'a, T> IntoIterator for &'a ScalarBitSet<T>
+where
+    T: ScalarBitSetStorage,
+{
+    type Item = u8;
+
+    type IntoIter = Iter<T>;
+
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter {
+        self.iter()
+    }
+}
+
+impl<T: ScalarBitSetStorage> From<T> for ScalarBitSet<T> {
+    fn from(bits: T) -> Self {
+        Self(bits)
+    }
+}
+
+/// A trait implemented by all integers that can be used as the backing storage
+/// for a [`ScalarBitSet`].
+///
+/// You shouldn't have to implement this yourself, it is already implemented for
+/// `u{8,16,32,64,128}` and if you need more bits than that, then use
+/// [`CompoundBitSet`][crate::CompoundBitSet] instead.
+pub trait ScalarBitSetStorage:
+    Default
+    + From<u8>
+    + Shl<u8, Output = Self>
+    + Shr<u8, Output = Self>
+    + BitAnd<Output = Self>
+    + BitOr<Output = Self>
+    + Not<Output = Self>
+    + Sub<Output = Self>
+    + Add<Output = Self>
+    + PartialEq
+    + Copy
+{
+    /// Count the number of leading zeros.
+    fn leading_zeros(self) -> u8;
+
+    /// Count the number of trailing zeros.
+    fn trailing_zeros(self) -> u8;
+
+    /// Count the number of bits set in this integer.
+    fn count_ones(self) -> u8;
+}
+
+macro_rules! impl_storage {
+    ( $int:ty ) => {
+        impl ScalarBitSetStorage for $int {
+            fn leading_zeros(self) -> u8 {
+                u8::try_from(self.leading_zeros()).unwrap()
+            }
+
+            fn trailing_zeros(self) -> u8 {
+                u8::try_from(self.trailing_zeros()).unwrap()
+            }
+
+            fn count_ones(self) -> u8 {
+                u8::try_from(self.count_ones()).unwrap()
+            }
+        }
+    };
+}
+
+impl_storage!(u8);
+impl_storage!(u16);
+impl_storage!(u32);
+impl_storage!(u64);
+impl_storage!(u128);
+impl_storage!(usize);
+
+/// An iterator over the elements in a [`ScalarBitSet`].
+pub struct Iter<T> {
+    bitset: ScalarBitSet<T>,
+}
+
+impl<T> Iterator for Iter<T>
+where
+    T: ScalarBitSetStorage,
+{
+    type Item = u8;
+
+    #[inline]
+    fn next(&mut self) -> Option<u8> {
+        self.bitset.pop_min()
+    }
+}
+
+impl<T> DoubleEndedIterator for Iter<T>
+where
+    T: ScalarBitSetStorage,
+{
+    #[inline]
+    fn next_back(&mut self) -> Option<Self::Item> {
+        self.bitset.pop_max()
+    }
+}
+
+impl<T> ExactSizeIterator for Iter<T>
+where
+    T: ScalarBitSetStorage,
+{
+    #[inline]
+    fn len(&self) -> usize {
+        usize::from(self.bitset.len())
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a, T> arbitrary::Arbitrary<'a> for ScalarBitSet<T>
+where
+    T: ScalarBitSetStorage + arbitrary::Arbitrary<'a>,
+{
+    fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
+        T::arbitrary(u).map(Self)
+    }
+}
diff --git a/cranelift/bitset/tests/bitset.rs b/cranelift/bitset/tests/bitset.rs
new file mode 100644
index 000000000000..d0f5aedd6428
--- /dev/null
+++ b/cranelift/bitset/tests/bitset.rs
@@ -0,0 +1,78 @@
+use cranelift_bitset::*;
+
+#[test]
+fn contains() {
+    let s = ScalarBitSet::<u8>(255);
+    for i in 0..7 {
+        assert!(s.contains(i));
+    }
+
+    let s1 = ScalarBitSet::<u8>(0);
+    for i in 0..7 {
+        assert!(!s1.contains(i));
+    }
+
+    let s2 = ScalarBitSet::<u8>(127);
+    for i in 0..6 {
+        assert!(s2.contains(i));
+    }
+    assert!(!s2.contains(7));
+
+    let s3 = ScalarBitSet::<u8>(2 | 4 | 64);
+    assert!(!s3.contains(0) && !s3.contains(3) && !s3.contains(4));
+    assert!(!s3.contains(5) && !s3.contains(7));
+    assert!(s3.contains(1) && s3.contains(2) && s3.contains(6));
+
+    let s4 = ScalarBitSet::<u16>(4 | 8 | 256 | 1024);
+    assert!(
+        !s4.contains(0)
+            && !s4.contains(1)
+            && !s4.contains(4)
+            && !s4.contains(5)
+            && !s4.contains(6)
+            && !s4.contains(7)
+            && !s4.contains(9)
+            && !s4.contains(11)
+    );
+    assert!(s4.contains(2) && s4.contains(3) && s4.contains(8) && s4.contains(10));
+}
+
+#[test]
+fn minmax() {
+    let s = ScalarBitSet::<u8>(255);
+    assert_eq!(s.min(), Some(0));
+    assert_eq!(s.max(), Some(7));
+    assert!(s.min() == Some(0) && s.max() == Some(7));
+    let s1 = ScalarBitSet::<u8>(0);
+    assert!(s1.min() == None && s1.max() == None);
+    let s2 = ScalarBitSet::<u8>(127);
+    assert!(s2.min() == Some(0) && s2.max() == Some(6));
+    let s3 = ScalarBitSet::<u8>(2 | 4 | 64);
+    assert!(s3.min() == Some(1) && s3.max() == Some(6));
+    let s4 = ScalarBitSet::<u16>(4 | 8 | 256 | 1024);
+    assert!(s4.min() == Some(2) && s4.max() == Some(10));
+}
+
+#[test]
+fn from_range() {
+    let s = ScalarBitSet::<u8>::from_range(5, 5);
+    assert!(s.0 == 0);
+
+    let s = ScalarBitSet::<u8>::from_range(0, 8);
+    assert!(s.0 == 255);
+
+    let s = ScalarBitSet::<u16>::from_range(0, 8);
+    assert!(s.0 == 255u16);
+
+    let s = ScalarBitSet::<u16>::from_range(0, 16);
+    assert!(s.0 == 65535u16);
+
+    let s = ScalarBitSet::<u8>::from_range(5, 6);
+    assert!(s.0 == 32u8);
+
+    let s = ScalarBitSet::<u8>::from_range(3, 7);
+    assert!(s.0 == 8 | 16 | 32 | 64);
+
+    let s = ScalarBitSet::<u16>::from_range(5, 11);
+    assert!(s.0 == 32 | 64 | 128 | 256 | 512 | 1024);
+}
diff --git a/cranelift/codegen/Cargo.toml b/cranelift/codegen/Cargo.toml
index 640444c9c959..1126c2233631 100644
--- a/cranelift/codegen/Cargo.toml
+++ b/cranelift/codegen/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 authors = ["The Cranelift Project Developers"]
 name = "cranelift-codegen"
-version = "0.101.0"
+version = "0.112.0"
 description = "Low-level code generator library"
 license = "Apache-2.0 WITH LLVM-exception"
 documentation = "https://docs.rs/cranelift-codegen"
@@ -11,41 +11,49 @@ readme = "README.md"
 keywords = ["compile", "compiler", "jit"]
 build = "build.rs"
 edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
 
 [dependencies]
-anyhow = { workspace = true, optional = true }
+anyhow = { workspace = true, optional = true, features = ['std'] }
 bumpalo = "3"
 capstone = { workspace = true, optional = true }
-cranelift-codegen-shared = { path = "./shared", version = "0.101.0" }
+cranelift-codegen-shared = { path = "./shared", version = "0.112.0" }
 cranelift-entity = { workspace = true }
 cranelift-bforest = { workspace = true }
+cranelift-bitset = { workspace = true }
 cranelift-control = { workspace = true }
 hashbrown = { workspace = true, features = ["raw"] }
 target-lexicon = { workspace = true }
 log = { workspace = true }
-serde = { version = "1.0.188", optional = true }
-serde_derive = { version = "1.0.188", optional = true }
-bincode = { version = "1.2.1", optional = true }
-gimli = { workspace = true, features = ["write"], optional = true }
+serde = { workspace = true, optional = true }
+serde_derive = { workspace = true, optional = true }
+pulley-interpreter = { workspace = true, optional = true }
+postcard = { workspace = true, optional = true }
+gimli = { workspace = true, features = ["write", "std"], optional = true }
 smallvec = { workspace = true }
 regalloc2 = { workspace = true, features = ["checker"] }
 souper-ir = { version = "2.1.0", optional = true }
 sha2 = { version = "0.10.2", optional = true }
+rustc-hash  = { workspace = true }
 # It is a goal of the cranelift-codegen crate to have minimal external dependencies.
 # Please don't add any unless they are essential to the task of creating binary
 # machine code. Integration tests that need external dependencies can be
-# accomodated in `tests`.
+# accommodated in `tests`.
 
 [dev-dependencies]
-criterion = { version = "0.5.0", features = ["html_reports"] }
+criterion = { workspace = true }
 similar = "2.1.0"
+env_logger = { workspace = true }
 
 [build-dependencies]
-cranelift-codegen-meta = { path = "meta", version = "0.101.0" }
-cranelift-isle = { path = "../isle/isle", version = "=0.101.0" }
+cranelift-codegen-meta = { path = "meta", version = "0.112.0" }
+cranelift-isle = { path = "../isle/isle", version = "=0.112.0" }
 
 [features]
-default = ["std", "unwind", "host-arch"]
+default = ["std", "unwind", "host-arch", "timing"]
 
 # The "std" feature enables use of libstd. The "core" feature enables use
 # of some minimal std-like replacement libraries. At least one of these two
@@ -63,7 +71,7 @@ core = []
 disas = ["anyhow", "capstone"]
 
 # Enables detailed logging which can be somewhat expensive.
-trace-log = []
+trace-log = ["regalloc2/trace-log"]
 
 # This enables unwind info generation functionality.
 unwind = ["gimli"]
@@ -74,6 +82,7 @@ x86 = []
 arm64 = []
 s390x = []
 riscv64 = []
+pulley = ["dep:pulley-interpreter", "pulley-interpreter/encode", "pulley-interpreter/disas"]
 # Enable the ISA target for the host machine
 host-arch = []
 
@@ -82,7 +91,8 @@ all-arch = [
     "x86",
     "arm64",
     "s390x",
-    "riscv64"
+    "riscv64",
+    "pulley",
 ]
 
 # For dependent crates that want to serialize some parts of cranelift
@@ -90,6 +100,7 @@ enable-serde = [
     "serde",
     "serde_derive",
     "cranelift-entity/enable-serde",
+    "cranelift-bitset/enable-serde",
     "regalloc2/enable-serde",
     "smallvec/serde"
 ]
@@ -97,7 +108,7 @@ enable-serde = [
 # Enable the incremental compilation cache for hot-reload use cases.
 incremental-cache = [
     "enable-serde",
-    "bincode",
+    "postcard",
     "sha2"
 ]
 
@@ -111,6 +122,11 @@ isle-errors = ["cranelift-isle/fancy-errors"]
 # inspection, rather than inside of target/.
 isle-in-source-tree = []
 
+# Enable tracking how long passes take in Cranelift.
+#
+# Enabled by default.
+timing = []
+
 [[bench]]
 name = "x64-evex-encoding"
 harness = false
diff --git a/cranelift/codegen/build.rs b/cranelift/codegen/build.rs
index 211b62177dd2..7a879b9d1168 100644
--- a/cranelift/codegen/build.rs
+++ b/cranelift/codegen/build.rs
@@ -16,6 +16,7 @@
 
 use cranelift_codegen_meta as meta;
 use cranelift_isle::error::Errors;
+use meta::isle::IsleCompilation;
 
 use std::env;
 use std::io::Read;
@@ -26,24 +27,33 @@ fn main() {
     let start_time = Instant::now();
 
     let out_dir = env::var("OUT_DIR").expect("The OUT_DIR environment variable must be set");
+    let out_dir = std::path::Path::new(&out_dir);
     let target_triple = env::var("TARGET").expect("The TARGET environment variable must be set");
 
+    let all_arch = env::var("CARGO_FEATURE_ALL_ARCH").is_ok();
+
     let mut isas = meta::isa::Isa::all()
         .iter()
         .cloned()
         .filter(|isa| {
-            let env_key = format!("CARGO_FEATURE_{}", isa.to_string().to_uppercase());
-            env::var(env_key).is_ok()
+            let env_key = match isa {
+                meta::isa::Isa::Pulley32 | meta::isa::Isa::Pulley64 => {
+                    "CARGO_FEATURE_PULLEY".to_string()
+                }
+                _ => format!("CARGO_FEATURE_{}", isa.to_string().to_uppercase()),
+            };
+            all_arch || env::var(env_key).is_ok()
         })
         .collect::<Vec<_>>();
 
-    let host_isa = env::var("CARGO_FEATURE_HOST_ARCH").is_ok();
+    // Don't require host isa if under 'all-arch' feature.
+    let host_isa = env::var("CARGO_FEATURE_HOST_ARCH").is_ok() && !all_arch;
 
     if isas.is_empty() || host_isa {
         // Try to match native target.
         let target_name = target_triple.split('-').next().unwrap();
         let isa = meta::isa_from_arch(&target_name).expect("error when identifying target");
-        println!("cargo:rustc-cfg=feature=\"{}\"", isa);
+        println!("cargo:rustc-cfg=feature=\"{isa}\"");
         isas.push(isa);
     }
 
@@ -56,7 +66,7 @@ fn main() {
     #[cfg(feature = "isle-in-source-tree")]
     let isle_dir = explicit_isle_dir;
     #[cfg(not(feature = "isle-in-source-tree"))]
-    let isle_dir = std::path::Path::new(&out_dir);
+    let isle_dir = &out_dir;
 
     #[cfg(feature = "isle-in-source-tree")]
     {
@@ -76,14 +86,14 @@ fn main() {
         }
     }
 
-    if let Err(err) = meta::generate(&isas, &out_dir, isle_dir.to_str().unwrap()) {
-        eprintln!("Error: {}", err);
+    if let Err(err) = meta::generate(&isas, &out_dir, isle_dir) {
+        eprintln!("Error: {err}");
         process::exit(1);
     }
 
     if &std::env::var("SKIP_ISLE").unwrap_or("0".to_string()) != "1" {
         if let Err(err) = build_isle(crate_dir, isle_dir) {
-            eprintln!("Error: {}", err);
+            eprintln!("Error: {err}");
             process::exit(1);
         }
     }
@@ -96,7 +106,7 @@ fn main() {
             "cargo:warning=Build step took {:?}.",
             Instant::now() - start_time
         );
-        println!("cargo:warning=Generated files are in {}", out_dir);
+        println!("cargo:warning=Generated files are in {}", out_dir.display());
     }
 
     let pkg_version = env::var("CARGO_PKG_VERSION").unwrap();
@@ -116,7 +126,7 @@ fn main() {
         let status = child.wait().unwrap();
         if status.success() {
             let git_rev = git_rev.trim().chars().take(9).collect::<String>();
-            format!("{}-{}", pkg_version, git_rev)
+            format!("{pkg_version}-{git_rev}")
         } else {
             // not a git repo
             pkg_version
@@ -129,8 +139,7 @@ fn main() {
         std::path::Path::new(&out_dir).join("version.rs"),
         format!(
             "/// Version number of this crate. \n\
-            pub const VERSION: &str = \"{}\";",
-            version
+            pub const VERSION: &str = \"{version}\";"
         ),
     )
     .unwrap();
@@ -140,166 +149,36 @@ fn main() {
 /// includes them in the generated source, and this helps us maintain
 /// deterministic builds that don't include those local file paths.
 fn make_isle_source_path_relative(
-    cur_dir: &std::path::PathBuf,
-    filename: std::path::PathBuf,
+    cur_dir: &std::path::Path,
+    filename: &std::path::Path,
 ) -> std::path::PathBuf {
     if let Ok(suffix) = filename.strip_prefix(&cur_dir) {
         suffix.to_path_buf()
     } else {
-        filename
+        filename.to_path_buf()
     }
 }
 
-/// A list of compilations (transformations from ISLE source to
-/// generated Rust source) that exist in the repository.
-///
-/// This list is used either to regenerate the Rust source in-tree (if
-/// the `rebuild-isle` feature is enabled), or to verify that the ISLE
-/// source in-tree corresponds to the ISLE source that was last used
-/// to rebuild the Rust source (if the `rebuild-isle` feature is not
-/// enabled).
-#[derive(Clone, Debug)]
-struct IsleCompilations {
-    items: Vec<IsleCompilation>,
-}
-
-#[derive(Clone, Debug)]
-struct IsleCompilation {
-    output: std::path::PathBuf,
-    inputs: Vec<std::path::PathBuf>,
-    untracked_inputs: Vec<std::path::PathBuf>,
-}
-
-/// Construct the list of compilations (transformations from ISLE
-/// source to generated Rust source) that exist in the repository.
-fn get_isle_compilations(
-    crate_dir: &std::path::Path,
-    out_dir: &std::path::Path,
-) -> Result<IsleCompilations, std::io::Error> {
-    let cur_dir = std::env::current_dir()?;
-
-    // Preludes.
-    let clif_lower_isle = out_dir.join("clif_lower.isle");
-    let clif_opt_isle = out_dir.join("clif_opt.isle");
-    let prelude_isle =
-        make_isle_source_path_relative(&cur_dir, crate_dir.join("src").join("prelude.isle"));
-    let prelude_opt_isle =
-        make_isle_source_path_relative(&cur_dir, crate_dir.join("src").join("prelude_opt.isle"));
-    let prelude_lower_isle =
-        make_isle_source_path_relative(&cur_dir, crate_dir.join("src").join("prelude_lower.isle"));
-
-    // Directory for mid-end optimizations.
-    let src_opts = make_isle_source_path_relative(&cur_dir, crate_dir.join("src").join("opts"));
-    // Directories for lowering backends.
-    let src_isa_x64 =
-        make_isle_source_path_relative(&cur_dir, crate_dir.join("src").join("isa").join("x64"));
-    let src_isa_aarch64 =
-        make_isle_source_path_relative(&cur_dir, crate_dir.join("src").join("isa").join("aarch64"));
-    let src_isa_s390x =
-        make_isle_source_path_relative(&cur_dir, crate_dir.join("src").join("isa").join("s390x"));
-
-    let src_isa_risc_v =
-        make_isle_source_path_relative(&cur_dir, crate_dir.join("src").join("isa").join("riscv64"));
-    // This is a set of ISLE compilation units.
-    //
-    // The format of each entry is:
-    //
-    //     (output Rust code file, input ISLE source files)
-    //
-    // There should be one entry for each backend that uses ISLE for lowering,
-    // and if/when we replace our peephole optimization passes with ISLE, there
-    // should be an entry for each of those as well.
-    //
-    // N.B.: add any new compilation outputs to
-    // `scripts/force-rebuild-isle.sh` if they do not fit the pattern
-    // `cranelift/codegen/src/isa/*/lower/isle/generated_code.rs`!
-    Ok(IsleCompilations {
-        items: vec![
-            // The mid-end optimization rules.
-            IsleCompilation {
-                output: out_dir.join("isle_opt.rs"),
-                inputs: vec![
-                    prelude_isle.clone(),
-                    prelude_opt_isle,
-                    src_opts.join("arithmetic.isle"),
-                    src_opts.join("bitops.isle"),
-                    src_opts.join("cprop.isle"),
-                    src_opts.join("extends.isle"),
-                    src_opts.join("icmp.isle"),
-                    src_opts.join("remat.isle"),
-                    src_opts.join("selects.isle"),
-                    src_opts.join("shifts.isle"),
-                    src_opts.join("vector.isle"),
-                ],
-                untracked_inputs: vec![clif_opt_isle],
-            },
-            // The x86-64 instruction selector.
-            IsleCompilation {
-                output: out_dir.join("isle_x64.rs"),
-                inputs: vec![
-                    prelude_isle.clone(),
-                    prelude_lower_isle.clone(),
-                    src_isa_x64.join("inst.isle"),
-                    src_isa_x64.join("lower.isle"),
-                ],
-                untracked_inputs: vec![clif_lower_isle.clone()],
-            },
-            // The aarch64 instruction selector.
-            IsleCompilation {
-                output: out_dir.join("isle_aarch64.rs"),
-                inputs: vec![
-                    prelude_isle.clone(),
-                    prelude_lower_isle.clone(),
-                    src_isa_aarch64.join("inst.isle"),
-                    src_isa_aarch64.join("inst_neon.isle"),
-                    src_isa_aarch64.join("lower.isle"),
-                    src_isa_aarch64.join("lower_dynamic_neon.isle"),
-                ],
-                untracked_inputs: vec![clif_lower_isle.clone()],
-            },
-            // The s390x instruction selector.
-            IsleCompilation {
-                output: out_dir.join("isle_s390x.rs"),
-                inputs: vec![
-                    prelude_isle.clone(),
-                    prelude_lower_isle.clone(),
-                    src_isa_s390x.join("inst.isle"),
-                    src_isa_s390x.join("lower.isle"),
-                ],
-                untracked_inputs: vec![clif_lower_isle.clone()],
-            },
-            // The risc-v instruction selector.
-            IsleCompilation {
-                output: out_dir.join("isle_riscv64.rs"),
-                inputs: vec![
-                    prelude_isle.clone(),
-                    prelude_lower_isle.clone(),
-                    src_isa_risc_v.join("inst.isle"),
-                    src_isa_risc_v.join("inst_vector.isle"),
-                    src_isa_risc_v.join("lower.isle"),
-                ],
-                untracked_inputs: vec![clif_lower_isle.clone()],
-            },
-        ],
-    })
-}
-
 fn build_isle(
     crate_dir: &std::path::Path,
     isle_dir: &std::path::Path,
 ) -> Result<(), Box<dyn std::error::Error + 'static>> {
-    let isle_compilations = get_isle_compilations(crate_dir, isle_dir)?;
+    let cur_dir = std::env::current_dir()?;
+    let isle_compilations = meta::isle::get_isle_compilations(
+        &make_isle_source_path_relative(&cur_dir, &crate_dir),
+        &make_isle_source_path_relative(&cur_dir, &isle_dir),
+    );
 
     let mut had_error = false;
     for compilation in &isle_compilations.items {
-        for file in &compilation.inputs {
+        for file in &compilation.tracked_inputs {
             println!("cargo:rerun-if-changed={}", file.display());
         }
 
         if let Err(e) = run_compilation(compilation) {
             had_error = true;
             eprintln!("Error building ISLE files:");
-            eprintln!("{:?}", e);
+            eprintln!("{e}");
             #[cfg(not(feature = "isle-errors"))]
             {
                 eprintln!("To see a more detailed error report, run: ");
@@ -330,11 +209,11 @@ fn run_compilation(compilation: &IsleCompilation) -> Result<(), Errors> {
 
     let code = {
         let file_paths = compilation
-            .inputs
-            .iter()
-            .chain(compilation.untracked_inputs.iter());
+            .paths()
+            .map_err(|e| Errors::from_io(e, "list isle compilation file paths"))?;
 
         let mut options = isle::codegen::CodegenOptions::default();
+        options.rule_trace = compilation.rule_trace;
         // Because we include!() the generated ISLE source, we cannot
         // put the global pragmas (`#![allow(...)]`) in the ISLE
         // source itself; we have to put them in the source that
@@ -346,10 +225,7 @@ fn run_compilation(compilation: &IsleCompilation) -> Result<(), Errors> {
     };
 
     let code = rustfmt(&code).unwrap_or_else(|e| {
-        println!(
-            "cargo:warning=Failed to run `rustfmt` on ISLE-generated code: {:?}",
-            e
-        );
+        println!("cargo:warning=Failed to run `rustfmt` on ISLE-generated code: {e:?}");
         code
     });
 
@@ -383,7 +259,7 @@ fn rustfmt(code: &str) -> std::io::Result<String> {
     if !status.success() {
         return Err(std::io::Error::new(
             std::io::ErrorKind::Other,
-            format!("`rustfmt` exited with status {}", status),
+            format!("`rustfmt` exited with status {status}"),
         ));
     }
 
diff --git a/cranelift/codegen/meta/Cargo.toml b/cranelift/codegen/meta/Cargo.toml
index 4b930571018d..f6f039c08286 100644
--- a/cranelift/codegen/meta/Cargo.toml
+++ b/cranelift/codegen/meta/Cargo.toml
@@ -1,15 +1,19 @@
 [package]
 name = "cranelift-codegen-meta"
 authors = ["The Cranelift Project Developers"]
-version = "0.101.0"
+version = "0.112.0"
 description = "Metaprogram for cranelift-codegen code generator library"
 license = "Apache-2.0 WITH LLVM-exception"
 repository = "https://github.com/bytecodealliance/wasmtime"
 readme = "README.md"
 edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
 
 [package.metadata.docs.rs]
 rustdoc-args = [ "--document-private-items" ]
 
 [dependencies]
-cranelift-codegen-shared = { path = "../shared", version = "0.101.0" }
+cranelift-codegen-shared = { path = "../shared", version = "0.112.0" }
diff --git a/cranelift/codegen/meta/src/cdsl/settings.rs b/cranelift/codegen/meta/src/cdsl/settings.rs
index ce209dba8c28..6ed68d24a2aa 100644
--- a/cranelift/codegen/meta/src/cdsl/settings.rs
+++ b/cranelift/codegen/meta/src/cdsl/settings.rs
@@ -189,7 +189,7 @@ impl PredicateNode {
                 group.name, group.settings[bool_setting_index.0].name
             ),
             PredicateNode::SharedBool(ref group_name, ref bool_name) => {
-                format!("{}.{}()", group_name, bool_name)
+                format!("{group_name}.{bool_name}()")
             }
             PredicateNode::And(ref lhs, ref rhs) => {
                 format!("{} && {}", lhs.render(group), rhs.render(group))
diff --git a/cranelift/codegen/meta/src/cdsl/types.rs b/cranelift/codegen/meta/src/cdsl/types.rs
index 3eb32ebee67a..ce3c2e582553 100644
--- a/cranelift/codegen/meta/src/cdsl/types.rs
+++ b/cranelift/codegen/meta/src/cdsl/types.rs
@@ -17,7 +17,6 @@ static RUST_NAME_PREFIX: &str = "ir::types::";
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub(crate) enum ValueType {
     Lane(LaneType),
-    Reference(ReferenceType),
     Vector(VectorType),
     DynamicVector(DynamicVectorType),
 }
@@ -28,15 +27,10 @@ impl ValueType {
         LaneTypeIterator::new()
     }
 
-    pub fn all_reference_types() -> ReferenceTypeIterator {
-        ReferenceTypeIterator::new()
-    }
-
     /// Return a string containing the documentation comment for this type.
     pub fn doc(&self) -> String {
         match *self {
             ValueType::Lane(l) => l.doc(),
-            ValueType::Reference(r) => r.doc(),
             ValueType::Vector(ref v) => v.doc(),
             ValueType::DynamicVector(ref v) => v.doc(),
         }
@@ -46,7 +40,6 @@ impl ValueType {
     pub fn lane_bits(&self) -> u64 {
         match *self {
             ValueType::Lane(l) => l.lane_bits(),
-            ValueType::Reference(r) => r.lane_bits(),
             ValueType::Vector(ref v) => v.lane_bits(),
             ValueType::DynamicVector(ref v) => v.lane_bits(),
         }
@@ -69,7 +62,6 @@ impl ValueType {
     pub fn number(&self) -> u16 {
         match *self {
             ValueType::Lane(l) => l.number(),
-            ValueType::Reference(r) => r.number(),
             ValueType::Vector(ref v) => v.number(),
             ValueType::DynamicVector(ref v) => v.number(),
         }
@@ -90,7 +82,6 @@ impl fmt::Display for ValueType {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             ValueType::Lane(l) => l.fmt(f),
-            ValueType::Reference(r) => r.fmt(f),
             ValueType::Vector(ref v) => v.fmt(f),
             ValueType::DynamicVector(ref v) => v.fmt(f),
         }
@@ -104,13 +95,6 @@ impl From<LaneType> for ValueType {
     }
 }
 
-/// Create a ValueType from a given reference type.
-impl From<ReferenceType> for ValueType {
-    fn from(reference: ReferenceType) -> Self {
-        ValueType::Reference(reference)
-    }
-}
-
 /// Create a ValueType from a given vector type.
 impl From<VectorType> for ValueType {
     fn from(vector: VectorType) -> Self {
@@ -136,6 +120,12 @@ impl LaneType {
     /// Return a string containing the documentation comment for this lane type.
     pub fn doc(self) -> String {
         match self {
+            LaneType::Float(shared_types::Float::F16) => String::from(
+                "A 16-bit floating point type represented in the IEEE 754-2008
+                *binary16* interchange format. This corresponds to the :c:type:`_Float16`
+                type in most C implementations.
+                WARNING: f16 support is a work-in-progress and is incomplete",
+            ),
             LaneType::Float(shared_types::Float::F32) => String::from(
                 "A 32-bit floating point type represented in the IEEE 754-2008
                 *binary32* interchange format. This corresponds to the :c:type:`float`
@@ -146,6 +136,12 @@ impl LaneType {
                 *binary64* interchange format. This corresponds to the :c:type:`double`
                 type in most C implementations.",
             ),
+            LaneType::Float(shared_types::Float::F128) => String::from(
+                "A 128-bit floating point type represented in the IEEE 754-2008
+                *binary128* interchange format. This corresponds to the :c:type:`_Float128`
+                type in most C implementations.
+                WARNING: f128 support is a work-in-progress and is incomplete",
+            ),
             LaneType::Int(_) if self.lane_bits() < 32 => format!(
                 "An integer type with {} bits.
                 WARNING: arithmetic on {}bit integers is incomplete",
@@ -168,13 +164,15 @@ impl LaneType {
     pub fn number(self) -> u16 {
         constants::LANE_BASE
             + match self {
-                LaneType::Int(shared_types::Int::I8) => 6,
-                LaneType::Int(shared_types::Int::I16) => 7,
-                LaneType::Int(shared_types::Int::I32) => 8,
-                LaneType::Int(shared_types::Int::I64) => 9,
-                LaneType::Int(shared_types::Int::I128) => 10,
-                LaneType::Float(shared_types::Float::F32) => 11,
-                LaneType::Float(shared_types::Float::F64) => 12,
+                LaneType::Int(shared_types::Int::I8) => 4,
+                LaneType::Int(shared_types::Int::I16) => 5,
+                LaneType::Int(shared_types::Int::I32) => 6,
+                LaneType::Int(shared_types::Int::I64) => 7,
+                LaneType::Int(shared_types::Int::I128) => 8,
+                LaneType::Float(shared_types::Float::F16) => 9,
+                LaneType::Float(shared_types::Float::F32) => 10,
+                LaneType::Float(shared_types::Float::F64) => 11,
+                LaneType::Float(shared_types::Float::F128) => 12,
             }
     }
 
@@ -185,15 +183,17 @@ impl LaneType {
             32 => shared_types::Int::I32,
             64 => shared_types::Int::I64,
             128 => shared_types::Int::I128,
-            _ => unreachable!("unxpected num bits for int"),
+            _ => unreachable!("unexpected num bits for int"),
         })
     }
 
     pub fn float_from_bits(num_bits: u16) -> LaneType {
         LaneType::Float(match num_bits {
+            16 => shared_types::Float::F16,
             32 => shared_types::Float::F32,
             64 => shared_types::Float::F64,
-            _ => unreachable!("unxpected num bits for float"),
+            128 => shared_types::Float::F128,
+            _ => unreachable!("unexpected num bits for float"),
         })
     }
 
@@ -226,8 +226,8 @@ impl fmt::Debug for LaneType {
             f,
             "{}",
             match *self {
-                LaneType::Float(_) => format!("FloatType({})", inner_msg),
-                LaneType::Int(_) => format!("IntType({})", inner_msg),
+                LaneType::Float(_) => format!("FloatType({inner_msg})"),
+                LaneType::Int(_) => format!("IntType({inner_msg})"),
             }
         )
     }
@@ -418,79 +418,3 @@ impl fmt::Debug for DynamicVectorType {
         )
     }
 }
-
-/// Reference type is scalar type, but not lane type.
-#[derive(Clone, Copy, PartialEq, Eq, Hash)]
-pub(crate) struct ReferenceType(pub shared_types::Reference);
-
-impl ReferenceType {
-    /// Return a string containing the documentation comment for this reference type.
-    pub fn doc(self) -> String {
-        format!("An opaque reference type with {} bits.", self.lane_bits())
-    }
-
-    /// Return the number of bits in a lane.
-    pub fn lane_bits(self) -> u64 {
-        match self.0 {
-            shared_types::Reference::R32 => 32,
-            shared_types::Reference::R64 => 64,
-        }
-    }
-
-    /// Find the unique number associated with this reference type.
-    pub fn number(self) -> u16 {
-        constants::REFERENCE_BASE
-            + match self {
-                ReferenceType(shared_types::Reference::R32) => 0,
-                ReferenceType(shared_types::Reference::R64) => 1,
-            }
-    }
-
-    pub fn ref_from_bits(num_bits: u16) -> ReferenceType {
-        ReferenceType(match num_bits {
-            32 => shared_types::Reference::R32,
-            64 => shared_types::Reference::R64,
-            _ => unreachable!("unexpected number of bits for a reference type"),
-        })
-    }
-}
-
-impl fmt::Display for ReferenceType {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "r{}", self.lane_bits())
-    }
-}
-
-impl fmt::Debug for ReferenceType {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "ReferenceType(bits={})", self.lane_bits())
-    }
-}
-
-/// Create a ReferenceType from a given reference variant.
-impl From<shared_types::Reference> for ReferenceType {
-    fn from(r: shared_types::Reference) -> Self {
-        ReferenceType(r)
-    }
-}
-
-/// An iterator for different reference types.
-pub(crate) struct ReferenceTypeIterator {
-    reference_iter: shared_types::ReferenceIterator,
-}
-
-impl ReferenceTypeIterator {
-    /// Create a new reference type iterator.
-    fn new() -> Self {
-        Self {
-            reference_iter: shared_types::ReferenceIterator::new(),
-        }
-    }
-}
-
-impl Iterator for ReferenceTypeIterator {
-    type Item = ReferenceType;
-    fn next(&mut self) -> Option<Self::Item> {
-        self.reference_iter.next().map(ReferenceType::from)
-    }
-}
diff --git a/cranelift/codegen/meta/src/cdsl/typevar.rs b/cranelift/codegen/meta/src/cdsl/typevar.rs
index fc42f55a36da..61f31d9dbf50 100644
--- a/cranelift/codegen/meta/src/cdsl/typevar.rs
+++ b/cranelift/codegen/meta/src/cdsl/typevar.rs
@@ -2,15 +2,14 @@ use std::cell::RefCell;
 use std::collections::BTreeSet;
 use std::fmt;
 use std::hash;
-use std::iter::FromIterator;
 use std::ops;
 use std::rc::Rc;
 
-use crate::cdsl::types::{LaneType, ReferenceType, ValueType};
+use crate::cdsl::types::{LaneType, ValueType};
 
 const MAX_LANES: u16 = 256;
 const MAX_BITS: u16 = 128;
-const MAX_FLOAT_BITS: u16 = 64;
+const MAX_FLOAT_BITS: u16 = 128;
 
 /// Type variables can be used in place of concrete types when defining
 /// instructions. This makes the instructions *polymorphic*.
@@ -57,10 +56,6 @@ impl TypeVar {
         let mut builder = TypeSetBuilder::new();
 
         let (scalar_type, num_lanes) = match value_type {
-            ValueType::Reference(ReferenceType(reference_type)) => {
-                let bits = reference_type as RangeBound;
-                return TypeVar::new(name, doc, builder.refs(bits..bits).build());
-            }
             ValueType::Lane(lane_type) => (lane_type, 1),
             ValueType::Vector(vec_type) => {
                 (vec_type.lane_type(), vec_type.lane_count() as RangeBound)
@@ -160,7 +155,7 @@ impl TypeVar {
                     "can't halve all integer types"
                 );
                 assert!(
-                    ts.floats.is_empty() || *ts.floats.iter().min().unwrap() > 32,
+                    ts.floats.is_empty() || *ts.floats.iter().min().unwrap() > 16,
                     "can't halve all float types"
                 );
             }
@@ -180,7 +175,7 @@ impl TypeVar {
                     "can't halve all integer types"
                 );
                 assert!(
-                    ts.floats.is_empty() || *ts.floats.iter().min().unwrap() > 32,
+                    ts.floats.is_empty() || *ts.floats.iter().min().unwrap() > 16,
                     "can't halve all float types"
                 );
                 assert!(
@@ -209,9 +204,7 @@ impl TypeVar {
                     "The `narrower` constraint does not apply to vectors"
                 );
                 assert!(
-                    (!ts.ints.is_empty() || !ts.floats.is_empty())
-                        && ts.refs.is_empty()
-                        && ts.dynamic_lanes.is_empty(),
+                    (!ts.ints.is_empty() || !ts.floats.is_empty()) && ts.dynamic_lanes.is_empty(),
                     "The `narrower` constraint only applies to scalar ints or floats"
                 );
             }
@@ -222,9 +215,7 @@ impl TypeVar {
                     "The `wider` constraint does not apply to vectors"
                 );
                 assert!(
-                    (!ts.ints.is_empty() || !ts.floats.is_empty())
-                        && ts.refs.is_empty()
-                        && ts.dynamic_lanes.is_empty(),
+                    (!ts.ints.is_empty() || !ts.floats.is_empty()) && ts.dynamic_lanes.is_empty(),
                     "The `wider` constraint only applies to scalar ints or floats"
                 );
             }
@@ -395,30 +386,22 @@ pub(crate) struct TypeSet {
     pub dynamic_lanes: NumSet,
     pub ints: NumSet,
     pub floats: NumSet,
-    pub refs: NumSet,
 }
 
 impl TypeSet {
-    fn new(
-        lanes: NumSet,
-        dynamic_lanes: NumSet,
-        ints: NumSet,
-        floats: NumSet,
-        refs: NumSet,
-    ) -> Self {
+    fn new(lanes: NumSet, dynamic_lanes: NumSet, ints: NumSet, floats: NumSet) -> Self {
         Self {
             lanes,
             dynamic_lanes,
             ints,
             floats,
-            refs,
         }
     }
 
     /// Return the number of concrete types represented by this typeset.
     pub fn size(&self) -> usize {
-        self.lanes.len() * (self.ints.len() + self.floats.len() + self.refs.len())
-            + self.dynamic_lanes.len() * (self.ints.len() + self.floats.len() + self.refs.len())
+        self.lanes.len() * (self.ints.len() + self.floats.len())
+            + self.dynamic_lanes.len() * (self.ints.len() + self.floats.len())
     }
 
     /// Return the image of self across the derived function func.
@@ -457,7 +440,6 @@ impl TypeSet {
         }
 
         copy.floats = NumSet::new();
-        copy.refs = NumSet::new();
         copy
     }
 
@@ -465,7 +447,7 @@ impl TypeSet {
     fn half_width(&self) -> TypeSet {
         let mut copy = self.clone();
         copy.ints = NumSet::from_iter(self.ints.iter().filter(|&&x| x > 8).map(|&x| x / 2));
-        copy.floats = NumSet::from_iter(self.floats.iter().filter(|&&x| x > 32).map(|&x| x / 2));
+        copy.floats = NumSet::from_iter(self.floats.iter().filter(|&&x| x > 16).map(|&x| x / 2));
         copy
     }
 
@@ -522,9 +504,6 @@ impl TypeSet {
             for &bits in &self.floats {
                 ret.push(LaneType::float_from_bits(bits).by(num_lanes));
             }
-            for &bits in &self.refs {
-                ret.push(ReferenceType::ref_from_bits(bits).into());
-            }
         }
         for &num_lanes in &self.dynamic_lanes {
             for &bits in &self.ints {
@@ -574,12 +553,6 @@ impl fmt::Debug for TypeSet {
                 Vec::from_iter(self.floats.iter().map(|x| x.to_string())).join(", ")
             ));
         }
-        if !self.refs.is_empty() {
-            subsets.push(format!(
-                "refs={{{}}}",
-                Vec::from_iter(self.refs.iter().map(|x| x.to_string())).join(", ")
-            ));
-        }
 
         write!(fmt, "{})", subsets.join(", "))?;
         Ok(())
@@ -589,7 +562,6 @@ impl fmt::Debug for TypeSet {
 pub(crate) struct TypeSetBuilder {
     ints: Interval,
     floats: Interval,
-    refs: Interval,
     includes_scalars: bool,
     simd_lanes: Interval,
     dynamic_simd_lanes: Interval,
@@ -600,7 +572,6 @@ impl TypeSetBuilder {
         Self {
             ints: Interval::None,
             floats: Interval::None,
-            refs: Interval::None,
             includes_scalars: true,
             simd_lanes: Interval::None,
             dynamic_simd_lanes: Interval::None,
@@ -617,11 +588,6 @@ impl TypeSetBuilder {
         self.floats = interval.into();
         self
     }
-    pub fn refs(mut self, interval: impl Into<Interval>) -> Self {
-        assert!(self.refs == Interval::None);
-        self.refs = interval.into();
-        self
-    }
     pub fn includes_scalars(mut self, includes_scalars: bool) -> Self {
         self.includes_scalars = includes_scalars;
         self
@@ -644,8 +610,7 @@ impl TypeSetBuilder {
             range_to_set(self.simd_lanes.to_range(min_lanes..MAX_LANES, Some(1))),
             range_to_set(self.dynamic_simd_lanes.to_range(2..MAX_LANES, None)),
             range_to_set(self.ints.to_range(8..MAX_BITS, None)),
-            range_to_set(self.floats.to_range(32..64, None)),
-            range_to_set(self.refs.to_range(32..64, None)),
+            range_to_set(self.floats.to_range(16..MAX_FLOAT_BITS, None)),
         )
     }
 }
@@ -712,7 +677,7 @@ fn test_typevar_builder() {
 
     let type_set = TypeSetBuilder::new().floats(Interval::All).build();
     assert_eq!(type_set.lanes, num_set![1]);
-    assert_eq!(type_set.floats, num_set![32, 64]);
+    assert_eq!(type_set.floats, num_set![16, 32, 64, 128]);
     assert!(type_set.ints.is_empty());
 
     let type_set = TypeSetBuilder::new()
@@ -721,7 +686,7 @@ fn test_typevar_builder() {
         .includes_scalars(false)
         .build();
     assert_eq!(type_set.lanes, num_set![2, 4, 8, 16, 32, 64, 128, 256]);
-    assert_eq!(type_set.floats, num_set![32, 64]);
+    assert_eq!(type_set.floats, num_set![16, 32, 64, 128]);
     assert!(type_set.ints.is_empty());
 
     let type_set = TypeSetBuilder::new()
@@ -730,7 +695,7 @@ fn test_typevar_builder() {
         .includes_scalars(true)
         .build();
     assert_eq!(type_set.lanes, num_set![1, 2, 4, 8, 16, 32, 64, 128, 256]);
-    assert_eq!(type_set.floats, num_set![32, 64]);
+    assert_eq!(type_set.floats, num_set![16, 32, 64, 128]);
     assert!(type_set.ints.is_empty());
 
     let type_set = TypeSetBuilder::new()
@@ -739,7 +704,7 @@ fn test_typevar_builder() {
         .includes_scalars(false)
         .build();
     assert_eq!(type_set.lanes, num_set![2, 4, 8, 16, 32, 64, 128, 256]);
-    assert_eq!(type_set.floats, num_set![32, 64]);
+    assert_eq!(type_set.floats, num_set![16, 32, 64, 128]);
     assert!(type_set.dynamic_lanes.is_empty());
     assert!(type_set.ints.is_empty());
 
@@ -754,7 +719,7 @@ fn test_typevar_builder() {
         num_set![2, 4, 8, 16, 32, 64, 128, 256]
     );
     assert_eq!(type_set.ints, num_set![8, 16, 32, 64, 128]);
-    assert_eq!(type_set.floats, num_set![32, 64]);
+    assert_eq!(type_set.floats, num_set![16, 32, 64, 128]);
     assert_eq!(type_set.lanes, num_set![1]);
 
     let type_set = TypeSetBuilder::new()
@@ -766,7 +731,7 @@ fn test_typevar_builder() {
         type_set.dynamic_lanes,
         num_set![2, 4, 8, 16, 32, 64, 128, 256]
     );
-    assert_eq!(type_set.floats, num_set![32, 64]);
+    assert_eq!(type_set.floats, num_set![16, 32, 64, 128]);
     assert_eq!(type_set.lanes, num_set![1]);
     assert!(type_set.ints.is_empty());
 
@@ -872,12 +837,12 @@ fn test_forward_images() {
         TypeSetBuilder::new().ints(8..16).build()
     );
     assert_eq!(
-        TypeSetBuilder::new().floats(32..32).build().half_width(),
+        TypeSetBuilder::new().floats(16..16).build().half_width(),
         empty_set
     );
     assert_eq!(
-        TypeSetBuilder::new().floats(32..64).build().half_width(),
-        TypeSetBuilder::new().floats(32..32).build()
+        TypeSetBuilder::new().floats(32..128).build().half_width(),
+        TypeSetBuilder::new().floats(16..64).build()
     );
 
     // Double width.
@@ -894,8 +859,8 @@ fn test_forward_images() {
         TypeSetBuilder::new().floats(64..64).build()
     );
     assert_eq!(
-        TypeSetBuilder::new().floats(32..64).build().double_width(),
-        TypeSetBuilder::new().floats(64..64).build()
+        TypeSetBuilder::new().floats(16..64).build().double_width(),
+        TypeSetBuilder::new().floats(32..128).build()
     );
 }
 
diff --git a/cranelift/codegen/meta/src/error.rs b/cranelift/codegen/meta/src/error.rs
index 4cbf3d82851c..e898dea4e296 100644
--- a/cranelift/codegen/meta/src/error.rs
+++ b/cranelift/codegen/meta/src/error.rs
@@ -18,6 +18,8 @@ impl Error {
     }
 }
 
+impl std::error::Error for Error {}
+
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}", self.inner)
@@ -41,8 +43,8 @@ enum ErrorInner {
 impl fmt::Display for ErrorInner {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            ErrorInner::Msg(ref s) => write!(f, "{}", s),
-            ErrorInner::IoError(ref e) => write!(f, "{}", e),
+            ErrorInner::Msg(ref s) => write!(f, "{s}"),
+            ErrorInner::IoError(ref e) => write!(f, "{e}"),
         }
     }
 }
diff --git a/cranelift/codegen/meta/src/gen_inst.rs b/cranelift/codegen/meta/src/gen_inst.rs
index e43ebf79f1fe..7609d060d671 100644
--- a/cranelift/codegen/meta/src/gen_inst.rs
+++ b/cranelift/codegen/meta/src/gen_inst.rs
@@ -92,7 +92,7 @@ fn gen_instruction_data(formats: &[Rc<InstructionFormat>], fmt: &mut Formatter)
                         "blocks: [ir::BlockCall; {}],",
                         format.num_block_operands
                     ),
-                    n => panic!("Too many block operands in instruction: {}", n),
+                    n => panic!("Too many block operands in instruction: {n}"),
                 }
 
                 for field in &format.imm_fields {
@@ -137,7 +137,7 @@ fn gen_arguments_method(formats: &[Rc<InstructionFormat>], fmt: &mut Formatter,
                 m.arm(
                     name,
                     vec![format!("ref {}args", mut_), "..".to_string()],
-                    format!("args.{}(pool)", as_slice),
+                    format!("args.{as_slice}(pool)"),
                 );
                 continue;
             }
@@ -145,13 +145,13 @@ fn gen_arguments_method(formats: &[Rc<InstructionFormat>], fmt: &mut Formatter,
             // Fixed args.
             let mut fields = Vec::new();
             let arg = if format.num_value_operands == 0 {
-                format!("&{}[]", mut_)
+                format!("&{mut_}[]")
             } else if format.num_value_operands == 1 {
-                fields.push(format!("ref {}arg", mut_));
-                format!("{}(arg)", rslice)
+                fields.push(format!("ref {mut_}arg"));
+                format!("{rslice}(arg)")
             } else {
                 let arg = format!("args_arity{}", format.num_value_operands);
-                fields.push(format!("args: ref {}{}", mut_, arg));
+                fields.push(format!("args: ref {mut_}{arg}"));
                 arg
             };
             fields.push("..".into());
@@ -277,8 +277,8 @@ fn gen_instruction_data_impl(formats: &[Rc<InstructionFormat>], fmt: &mut Format
                         members.push(field.member);
                     }
 
-                    let pat1 = members.iter().map(|x| format!("{}: ref {}1", x, x)).collect::<Vec<_>>().join(", ");
-                    let pat2 = members.iter().map(|x| format!("{}: ref {}2", x, x)).collect::<Vec<_>>().join(", ");
+                    let pat1 = members.iter().map(|x| format!("{x}: ref {x}1")).collect::<Vec<_>>().join(", ");
+                    let pat2 = members.iter().map(|x| format!("{x}: ref {x}2")).collect::<Vec<_>>().join(", ");
                     fmtln!(fmt, "({} {{ {} }}, {} {{ {} }}) => {{", name, pat1, name, pat2);
                     fmt.indent(|fmt| {
                         fmt.line("opcode1 == opcode2");
@@ -725,7 +725,7 @@ fn gen_bitset<'a, T: IntoIterator<Item = &'a u16>>(
         assert!(u32::from(*x) < (1 << u32::from(field_size)));
         acc | x
     });
-    fmtln!(fmt, "{}: BitSet::<u{}>({}),", name, field_size, bits);
+    fmtln!(fmt, "{}: ScalarBitSet::<u{}>({}),", name, field_size, bits);
 }
 
 fn iterable_to_string<I: fmt::Display, T: IntoIterator<Item = I>>(iterable: T) -> String {
@@ -734,7 +734,7 @@ fn iterable_to_string<I: fmt::Display, T: IntoIterator<Item = I>>(iterable: T) -
         .map(|x| x.to_string())
         .collect::<Vec<_>>()
         .join(", ");
-    format!("{{{}}}", elems)
+    format!("{{{elems}}}")
 }
 
 fn typeset_to_string(ts: &TypeSet) -> String {
@@ -745,9 +745,6 @@ fn typeset_to_string(ts: &TypeSet) -> String {
     if !ts.floats.is_empty() {
         result += &format!(", floats={}", iterable_to_string(&ts.floats));
     }
-    if !ts.refs.is_empty() {
-        result += &format!(", refs={}", iterable_to_string(&ts.refs));
-    }
     result += ")";
     result
 }
@@ -774,7 +771,6 @@ pub(crate) fn gen_typesets_table(type_sets: &UniqueTable<TypeSet>, fmt: &mut For
                 gen_bitset(&ts.dynamic_lanes, "dynamic_lanes", 16, fmt);
                 gen_bitset(&ts.ints, "ints", 8, fmt);
                 gen_bitset(&ts.floats, "floats", 8, fmt);
-                gen_bitset(&ts.refs, "refs", 8, fmt);
             });
             fmt.line("},");
         }
@@ -853,7 +849,7 @@ fn gen_type_constraints(all_inst: &AllInstructions, fmt: &mut Formatter) {
             );
             fmt.comment(format!("Constraints=[{}]", constraints
                 .iter()
-                .map(|x| format!("'{}'", x))
+                .map(|x| format!("'{x}'"))
                 .collect::<Vec<_>>()
                 .join(", ")));
             if let Some(poly) = &inst.polymorphic_info {
@@ -916,7 +912,7 @@ fn gen_member_inits(format: &InstructionFormat, fmt: &mut Formatter) {
     } else if format.num_value_operands > 1 {
         let mut args = Vec::new();
         for i in 0..format.num_value_operands {
-            args.push(format!("arg{}", i));
+            args.push(format!("arg{i}"));
         }
         fmtln!(fmt, "args: [{}],", args.join(", "));
     }
@@ -928,7 +924,7 @@ fn gen_member_inits(format: &InstructionFormat, fmt: &mut Formatter) {
         n => {
             let mut blocks = Vec::new();
             for i in 0..n {
-                blocks.push(format!("block{}", i));
+                blocks.push(format!("block{i}"));
             }
             fmtln!(fmt, "blocks: [{}],", blocks.join(", "));
         }
@@ -953,7 +949,7 @@ fn gen_format_constructor(format: &InstructionFormat, fmt: &mut Formatter) {
     }
 
     // Then the block operands.
-    args.extend((0..format.num_block_operands).map(|i| format!("block{}: ir::BlockCall", i)));
+    args.extend((0..format.num_block_operands).map(|i| format!("block{i}: ir::BlockCall")));
 
     // Then the value operands.
     if format.has_value_list {
@@ -963,7 +959,7 @@ fn gen_format_constructor(format: &InstructionFormat, fmt: &mut Formatter) {
     } else {
         // Take a fixed number of value operands.
         for i in 0..format.num_value_operands {
-            args.push(format!("arg{}: Value", i));
+            args.push(format!("arg{i}: Value"));
         }
     }
 
@@ -973,7 +969,7 @@ fn gen_format_constructor(format: &InstructionFormat, fmt: &mut Formatter) {
         args.join(", ")
     );
 
-    let imms_need_sign_extension = format
+    let imms_need_masking = format
         .imm_fields
         .iter()
         .any(|f| f.kind.rust_type == "ir::immediates::Imm64");
@@ -986,7 +982,7 @@ fn gen_format_constructor(format: &InstructionFormat, fmt: &mut Formatter) {
         fmtln!(
             fmt,
             "let{} data = ir::InstructionData::{} {{",
-            if imms_need_sign_extension { " mut" } else { "" },
+            if imms_need_masking { " mut" } else { "" },
             format.name
         );
         fmt.indent(|fmt| {
@@ -995,12 +991,12 @@ fn gen_format_constructor(format: &InstructionFormat, fmt: &mut Formatter) {
         });
         fmtln!(fmt, "};");
 
-        if imms_need_sign_extension {
-            fmtln!(fmt, "data.sign_extend_immediates(ctrl_typevar);");
+        if imms_need_masking {
+            fmtln!(fmt, "data.mask_immediates(ctrl_typevar);");
         }
 
         // Assert that this opcode belongs to this format
-        fmtln!(fmt, "debug_assert_eq!(opcode.format(), InstructionFormat::from(&data), \"Wrong InstructionFormat for Opcode: {}\", opcode);");
+        fmtln!(fmt, "debug_assert_eq!(opcode.format(), InstructionFormat::from(&data), \"Wrong InstructionFormat for Opcode: {opcode}\");");
 
         fmt.line("self.build(data, ctrl_typevar)");
     });
@@ -1202,7 +1198,7 @@ fn gen_inst_builder(inst: &Instruction, format: &InstructionFormat, fmt: &mut Fo
                 inst.value_results
                     .iter()
                     .enumerate()
-                    .map(|(i, _)| format!("results[{}]", i))
+                    .map(|(i, _)| format!("results[{i}]"))
                     .collect::<Vec<_>>()
                     .join(", ")
             );
@@ -1211,499 +1207,6 @@ fn gen_inst_builder(inst: &Instruction, format: &InstructionFormat, fmt: &mut Fo
     fmtln!(fmt, "}")
 }
 
-/// Which ISLE target are we generating code for?
-#[derive(Clone, Copy, PartialEq, Eq)]
-enum IsleTarget {
-    /// Generating code for instruction selection and lowering.
-    Lower,
-    /// Generating code for CLIF to CLIF optimizations.
-    Opt,
-}
-
-fn gen_common_isle(
-    formats: &[Rc<InstructionFormat>],
-    instructions: &AllInstructions,
-    fmt: &mut Formatter,
-    isle_target: IsleTarget,
-) {
-    use std::collections::{BTreeMap, BTreeSet};
-    use std::fmt::Write;
-
-    use crate::cdsl::formats::FormatField;
-
-    fmt.multi_line(
-        r#"
-;; GENERATED BY `gen_isle`. DO NOT EDIT!!!
-;;
-;; This ISLE file defines all the external type declarations for Cranelift's
-;; data structures that ISLE will process, such as `InstructionData` and
-;; `Opcode`.
-        "#,
-    );
-    fmt.empty_line();
-
-    // Collect and deduplicate the immediate types from the instruction fields.
-    let rust_name = |f: &FormatField| f.kind.rust_type.rsplit("::").next().unwrap();
-    let fields = |f: &FormatField| f.kind.fields.clone();
-    let immediate_types: BTreeMap<_, _> = formats
-        .iter()
-        .flat_map(|f| {
-            f.imm_fields
-                .iter()
-                .map(|i| (rust_name(i), fields(i)))
-                .collect::<Vec<_>>()
-        })
-        .collect();
-
-    // Separate the `enum` immediates (e.g., `FloatCC`) from other kinds of
-    // immediates.
-    let (enums, others): (BTreeMap<_, _>, BTreeMap<_, _>) = immediate_types
-        .iter()
-        .partition(|(_, field)| field.enum_values().is_some());
-
-    // Generate all the extern type declarations we need for the non-`enum`
-    // immediates.
-    fmt.line(";;;; Extern type declarations for immediates ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;");
-    fmt.empty_line();
-    for ty in others.keys() {
-        fmtln!(fmt, "(type {} (primitive {}))", ty, ty);
-    }
-    fmt.empty_line();
-
-    // Generate the `enum` immediates, expanding all of the available variants
-    // into ISLE.
-    for (name, field) in enums {
-        let field = field.enum_values().expect("only enums considered here");
-        let variants = field.values().cloned().collect();
-        gen_isle_enum(name, variants, fmt)
-    }
-
-    // Generate all of the value arrays we need for `InstructionData` as well as
-    // the constructors and extractors for them.
-    fmt.line(";;;; Value Arrays ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;");
-    fmt.empty_line();
-    let value_array_arities: BTreeSet<_> = formats
-        .iter()
-        .filter(|f| f.typevar_operand.is_some() && !f.has_value_list && f.num_value_operands != 1)
-        .map(|f| f.num_value_operands)
-        .collect();
-    for n in value_array_arities {
-        fmtln!(fmt, ";; ISLE representation of `[Value; {}]`.", n);
-        fmtln!(fmt, "(type ValueArray{} extern (enum))", n);
-        fmt.empty_line();
-
-        fmtln!(
-            fmt,
-            "(decl value_array_{} ({}) ValueArray{})",
-            n,
-            (0..n).map(|_| "Value").collect::<Vec<_>>().join(" "),
-            n
-        );
-        fmtln!(
-            fmt,
-            "(extern constructor value_array_{} pack_value_array_{})",
-            n,
-            n
-        );
-        fmtln!(
-            fmt,
-            "(extern extractor infallible value_array_{} unpack_value_array_{})",
-            n,
-            n
-        );
-        fmt.empty_line();
-    }
-
-    // Generate all of the block arrays we need for `InstructionData` as well as
-    // the constructors and extractors for them.
-    fmt.line(";;;; Block Arrays ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;");
-    fmt.empty_line();
-    let block_array_arities: BTreeSet<_> = formats
-        .iter()
-        .filter(|f| f.num_block_operands > 1)
-        .map(|f| f.num_block_operands)
-        .collect();
-    for n in block_array_arities {
-        fmtln!(fmt, ";; ISLE representation of `[BlockCall; {}]`.", n);
-        fmtln!(fmt, "(type BlockArray{} extern (enum))", n);
-        fmt.empty_line();
-
-        fmtln!(
-            fmt,
-            "(decl block_array_{0} ({1}) BlockArray{0})",
-            n,
-            (0..n).map(|_| "BlockCall").collect::<Vec<_>>().join(" ")
-        );
-
-        fmtln!(
-            fmt,
-            "(extern constructor block_array_{0} pack_block_array_{0})",
-            n
-        );
-
-        fmtln!(
-            fmt,
-            "(extern extractor infallible block_array_{0} unpack_block_array_{0})",
-            n
-        );
-        fmt.empty_line();
-    }
-
-    // Generate the extern type declaration for `Opcode`.
-    fmt.line(";;;; `Opcode` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;");
-    fmt.empty_line();
-    fmt.line("(type Opcode extern");
-    fmt.indent(|fmt| {
-        fmt.line("(enum");
-        fmt.indent(|fmt| {
-            for inst in instructions {
-                fmtln!(fmt, "{}", inst.camel_name);
-            }
-        });
-        fmt.line(")");
-    });
-    fmt.line(")");
-    fmt.empty_line();
-
-    // Generate the extern type declaration for `InstructionData`.
-    fmtln!(
-        fmt,
-        ";;;; `InstructionData` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;",
-    );
-    fmt.empty_line();
-    fmtln!(fmt, "(type InstructionData extern");
-    fmt.indent(|fmt| {
-        fmt.line("(enum");
-        fmt.indent(|fmt| {
-            for format in formats {
-                let mut s = format!("({} (opcode Opcode)", format.name);
-                if format.has_value_list {
-                    s.push_str(" (args ValueList)");
-                } else if format.num_value_operands == 1 {
-                    s.push_str(" (arg Value)");
-                } else if format.num_value_operands > 1 {
-                    write!(&mut s, " (args ValueArray{})", format.num_value_operands).unwrap();
-                }
-
-                match format.num_block_operands {
-                    0 => (),
-                    1 => write!(&mut s, " (destination BlockCall)").unwrap(),
-                    n => write!(&mut s, " (blocks BlockArray{})", n).unwrap(),
-                }
-
-                for field in &format.imm_fields {
-                    write!(
-                        &mut s,
-                        " ({} {})",
-                        field.member,
-                        field.kind.rust_type.rsplit("::").next().unwrap()
-                    )
-                    .unwrap();
-                }
-                s.push(')');
-                fmt.line(&s);
-            }
-        });
-        fmt.line(")");
-    });
-    fmt.line(")");
-    fmt.empty_line();
-
-    // Generate the helper extractors for each opcode's full instruction.
-    fmtln!(
-        fmt,
-        ";;;; Extracting Opcode, Operands, and Immediates from `InstructionData` ;;;;;;;;",
-    );
-    fmt.empty_line();
-    let ret_ty = match isle_target {
-        IsleTarget::Lower => "Inst",
-        IsleTarget::Opt => "Value",
-    };
-    for inst in instructions {
-        if isle_target == IsleTarget::Opt
-            && (inst.format.has_value_list || inst.value_results.len() != 1)
-        {
-            continue;
-        }
-
-        fmtln!(
-            fmt,
-            "(decl {} ({}{}) {})",
-            inst.name,
-            match isle_target {
-                IsleTarget::Lower => "",
-                IsleTarget::Opt => "Type ",
-            },
-            inst.operands_in
-                .iter()
-                .map(|o| {
-                    let ty = o.kind.rust_type;
-                    if ty == "&[Value]" {
-                        "ValueSlice"
-                    } else {
-                        ty.rsplit("::").next().unwrap()
-                    }
-                })
-                .collect::<Vec<_>>()
-                .join(" "),
-            ret_ty
-        );
-        fmtln!(fmt, "(extractor");
-        fmt.indent(|fmt| {
-            fmtln!(
-                fmt,
-                "({} {}{})",
-                inst.name,
-                match isle_target {
-                    IsleTarget::Lower => "",
-                    IsleTarget::Opt => "ty ",
-                },
-                inst.operands_in
-                    .iter()
-                    .map(|o| { o.name })
-                    .collect::<Vec<_>>()
-                    .join(" ")
-            );
-
-            let mut s = format!(
-                "(inst_data{} (InstructionData.{} (Opcode.{})",
-                match isle_target {
-                    IsleTarget::Lower => "",
-                    IsleTarget::Opt => " ty",
-                },
-                inst.format.name,
-                inst.camel_name
-            );
-
-            // Value and varargs operands.
-            if inst.format.has_value_list {
-                // The instruction format uses a value list, but the
-                // instruction itself might have not only a `&[Value]`
-                // varargs operand, but also one or more `Value` operands as
-                // well. If this is the case, then we need to read them off
-                // the front of the `ValueList`.
-                let values: Vec<_> = inst
-                    .operands_in
-                    .iter()
-                    .filter(|o| o.is_value())
-                    .map(|o| o.name)
-                    .collect();
-                let varargs = inst
-                    .operands_in
-                    .iter()
-                    .find(|o| o.is_varargs())
-                    .unwrap()
-                    .name;
-                if values.is_empty() {
-                    write!(&mut s, " (value_list_slice {})", varargs).unwrap();
-                } else {
-                    write!(
-                        &mut s,
-                        " (unwrap_head_value_list_{} {} {})",
-                        values.len(),
-                        values.join(" "),
-                        varargs
-                    )
-                    .unwrap();
-                }
-            } else if inst.format.num_value_operands == 1 {
-                write!(
-                    &mut s,
-                    " {}",
-                    inst.operands_in.iter().find(|o| o.is_value()).unwrap().name
-                )
-                .unwrap();
-            } else if inst.format.num_value_operands > 1 {
-                let values = inst
-                    .operands_in
-                    .iter()
-                    .filter(|o| o.is_value())
-                    .map(|o| o.name)
-                    .collect::<Vec<_>>();
-                assert_eq!(values.len(), inst.format.num_value_operands);
-                let values = values.join(" ");
-                write!(
-                    &mut s,
-                    " (value_array_{} {})",
-                    inst.format.num_value_operands, values,
-                )
-                .unwrap();
-            }
-
-            // Immediates.
-            let imm_operands: Vec<_> = inst
-                .operands_in
-                .iter()
-                .filter(|o| !o.is_value() && !o.is_varargs() && !o.kind.is_block())
-                .collect();
-            assert_eq!(imm_operands.len(), inst.format.imm_fields.len(),);
-            for op in imm_operands {
-                write!(&mut s, " {}", op.name).unwrap();
-            }
-
-            // Blocks.
-            let block_operands: Vec<_> = inst
-                .operands_in
-                .iter()
-                .filter(|o| o.kind.is_block())
-                .collect();
-            assert_eq!(block_operands.len(), inst.format.num_block_operands);
-            assert!(block_operands.len() <= 2);
-
-            if !block_operands.is_empty() {
-                if block_operands.len() == 1 {
-                    write!(&mut s, " {}", block_operands[0].name).unwrap();
-                } else {
-                    let blocks: Vec<_> = block_operands.iter().map(|o| o.name).collect();
-                    let blocks = blocks.join(" ");
-                    write!(
-                        &mut s,
-                        " (block_array_{} {})",
-                        inst.format.num_block_operands, blocks,
-                    )
-                    .unwrap();
-                }
-            }
-
-            s.push_str("))");
-            fmt.line(&s);
-        });
-        fmt.line(")");
-
-        // Generate a constructor if this is the mid-end prelude.
-        if isle_target == IsleTarget::Opt {
-            fmtln!(
-                fmt,
-                "(rule ({} ty {})",
-                inst.name,
-                inst.operands_in
-                    .iter()
-                    .map(|o| o.name)
-                    .collect::<Vec<_>>()
-                    .join(" ")
-            );
-            fmt.indent(|fmt| {
-                let mut s = format!(
-                    "(make_inst ty (InstructionData.{} (Opcode.{})",
-                    inst.format.name, inst.camel_name
-                );
-
-                // Handle values. Note that we skip generating
-                // constructors for any instructions with variadic
-                // value lists. This is fine for the mid-end because
-                // in practice only calls and branches (for branch
-                // args) use this functionality, and neither can
-                // really be optimized or rewritten in the mid-end
-                // (currently).
-                //
-                // As a consequence, we only have to handle the
-                // one-`Value` case, in which the `Value` is directly
-                // in the `InstructionData`, and the multiple-`Value`
-                // case, in which the `Value`s are in a
-                // statically-sized array (e.g. `[Value; 2]` for a
-                // binary op).
-                assert!(!inst.format.has_value_list);
-                if inst.format.num_value_operands == 1 {
-                    write!(
-                        &mut s,
-                        " {}",
-                        inst.operands_in.iter().find(|o| o.is_value()).unwrap().name
-                    )
-                    .unwrap();
-                } else if inst.format.num_value_operands > 1 {
-                    // As above, get all bindings together, and pass
-                    // to a sub-term; here we use a constructor to
-                    // build the value array.
-                    let values = inst
-                        .operands_in
-                        .iter()
-                        .filter(|o| o.is_value())
-                        .map(|o| o.name)
-                        .collect::<Vec<_>>();
-                    assert_eq!(values.len(), inst.format.num_value_operands);
-                    let values = values.join(" ");
-                    write!(
-                        &mut s,
-                        " (value_array_{}_ctor {})",
-                        inst.format.num_value_operands, values
-                    )
-                    .unwrap();
-                }
-
-                if inst.format.num_block_operands > 0 {
-                    let blocks: Vec<_> = inst
-                        .operands_in
-                        .iter()
-                        .filter(|o| o.kind.is_block())
-                        .map(|o| o.name)
-                        .collect();
-                    if inst.format.num_block_operands == 1 {
-                        write!(&mut s, " {}", blocks.first().unwrap(),).unwrap();
-                    } else {
-                        write!(
-                            &mut s,
-                            " (block_array_{} {})",
-                            inst.format.num_block_operands,
-                            blocks.join(" ")
-                        )
-                        .unwrap();
-                    }
-                }
-
-                // Immediates (non-value args).
-                for o in inst
-                    .operands_in
-                    .iter()
-                    .filter(|o| !o.is_value() && !o.is_varargs() && !o.kind.is_block())
-                {
-                    write!(&mut s, " {}", o.name).unwrap();
-                }
-                s.push_str("))");
-                fmt.line(&s);
-            });
-            fmt.line(")");
-        }
-
-        fmt.empty_line();
-    }
-}
-
-fn gen_opt_isle(
-    formats: &[Rc<InstructionFormat>],
-    instructions: &AllInstructions,
-    fmt: &mut Formatter,
-) {
-    gen_common_isle(formats, instructions, fmt, IsleTarget::Opt);
-}
-
-fn gen_lower_isle(
-    formats: &[Rc<InstructionFormat>],
-    instructions: &AllInstructions,
-    fmt: &mut Formatter,
-) {
-    gen_common_isle(formats, instructions, fmt, IsleTarget::Lower);
-}
-
-/// Generate an `enum` immediate in ISLE.
-fn gen_isle_enum(name: &str, mut variants: Vec<&str>, fmt: &mut Formatter) {
-    variants.sort();
-    let prefix = format!(";;;; Enumerated Immediate: {} ", name);
-    fmtln!(fmt, "{:;<80}", prefix);
-    fmt.empty_line();
-    fmtln!(fmt, "(type {} extern", name);
-    fmt.indent(|fmt| {
-        fmt.line("(enum");
-        fmt.indent(|fmt| {
-            for variant in variants {
-                fmtln!(fmt, "{}", variant);
-            }
-        });
-        fmt.line(")");
-    });
-    fmt.line(")");
-    fmt.empty_line();
-}
-
 /// Generate a Builder trait with methods for all instructions.
 fn gen_builder(
     instructions: &AllInstructions,
@@ -1748,10 +1251,7 @@ pub(crate) fn generate(
     all_inst: &AllInstructions,
     opcode_filename: &str,
     inst_builder_filename: &str,
-    isle_opt_filename: &str,
-    isle_lower_filename: &str,
-    out_dir: &str,
-    isle_dir: &str,
+    out_dir: &std::path::Path,
 ) -> Result<(), error::Error> {
     // Opcodes.
     let mut fmt = Formatter::new();
@@ -1765,16 +1265,6 @@ pub(crate) fn generate(
     gen_type_constraints(all_inst, &mut fmt);
     fmt.update_file(opcode_filename, out_dir)?;
 
-    // ISLE DSL: mid-end ("opt") generated bindings.
-    let mut fmt = Formatter::new();
-    gen_opt_isle(&formats, all_inst, &mut fmt);
-    fmt.update_file(isle_opt_filename, isle_dir)?;
-
-    // ISLE DSL: lowering generated bindings.
-    let mut fmt = Formatter::new();
-    gen_lower_isle(&formats, all_inst, &mut fmt);
-    fmt.update_file(isle_lower_filename, isle_dir)?;
-
     // Instruction builder.
     let mut fmt = Formatter::new();
     gen_builder(all_inst, &formats, &mut fmt);
diff --git a/cranelift/codegen/meta/src/gen_isle.rs b/cranelift/codegen/meta/src/gen_isle.rs
new file mode 100644
index 000000000000..e07ef89881eb
--- /dev/null
+++ b/cranelift/codegen/meta/src/gen_isle.rs
@@ -0,0 +1,513 @@
+use std::rc::Rc;
+
+use crate::cdsl::formats::InstructionFormat;
+use crate::cdsl::instructions::AllInstructions;
+use crate::error;
+use crate::srcgen::Formatter;
+
+/// Which ISLE target are we generating code for?
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum IsleTarget {
+    /// Generating code for instruction selection and lowering.
+    Lower,
+    /// Generating code for CLIF to CLIF optimizations.
+    Opt,
+}
+
+fn gen_common_isle(
+    formats: &[Rc<InstructionFormat>],
+    instructions: &AllInstructions,
+    fmt: &mut Formatter,
+    isle_target: IsleTarget,
+) {
+    use std::collections::{BTreeMap, BTreeSet};
+    use std::fmt::Write;
+
+    use crate::cdsl::formats::FormatField;
+
+    fmt.multi_line(
+        r#"
+;; GENERATED BY `gen_isle`. DO NOT EDIT!!!
+;;
+;; This ISLE file defines all the external type declarations for Cranelift's
+;; data structures that ISLE will process, such as `InstructionData` and
+;; `Opcode`.
+        "#,
+    );
+    fmt.empty_line();
+
+    // Collect and deduplicate the immediate types from the instruction fields.
+    let rust_name = |f: &FormatField| f.kind.rust_type.rsplit("::").next().unwrap();
+    let fields = |f: &FormatField| f.kind.fields.clone();
+    let immediate_types: BTreeMap<_, _> = formats
+        .iter()
+        .flat_map(|f| {
+            f.imm_fields
+                .iter()
+                .map(|i| (rust_name(i), fields(i)))
+                .collect::<Vec<_>>()
+        })
+        .collect();
+
+    // Separate the `enum` immediates (e.g., `FloatCC`) from other kinds of
+    // immediates.
+    let (enums, others): (BTreeMap<_, _>, BTreeMap<_, _>) = immediate_types
+        .iter()
+        .partition(|(_, field)| field.enum_values().is_some());
+
+    // Generate all the extern type declarations we need for the non-`enum`
+    // immediates.
+    fmt.line(";;;; Extern type declarations for immediates ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;");
+    fmt.empty_line();
+    for ty in others.keys() {
+        fmtln!(fmt, "(type {} (primitive {}))", ty, ty);
+    }
+    fmt.empty_line();
+
+    // Generate the `enum` immediates, expanding all of the available variants
+    // into ISLE.
+    for (name, field) in enums {
+        let field = field.enum_values().expect("only enums considered here");
+        let variants = field.values().cloned().collect();
+        gen_isle_enum(name, variants, fmt)
+    }
+
+    // Generate all of the value arrays we need for `InstructionData` as well as
+    // the constructors and extractors for them.
+    fmt.line(";;;; Value Arrays ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;");
+    fmt.empty_line();
+    let value_array_arities: BTreeSet<_> = formats
+        .iter()
+        .filter(|f| f.typevar_operand.is_some() && !f.has_value_list && f.num_value_operands != 1)
+        .map(|f| f.num_value_operands)
+        .collect();
+    for n in value_array_arities {
+        fmtln!(fmt, ";; ISLE representation of `[Value; {}]`.", n);
+        fmtln!(fmt, "(type ValueArray{} extern (enum))", n);
+        fmt.empty_line();
+
+        fmtln!(
+            fmt,
+            "(decl value_array_{} ({}) ValueArray{})",
+            n,
+            (0..n).map(|_| "Value").collect::<Vec<_>>().join(" "),
+            n
+        );
+        fmtln!(
+            fmt,
+            "(extern constructor value_array_{} pack_value_array_{})",
+            n,
+            n
+        );
+        fmtln!(
+            fmt,
+            "(extern extractor infallible value_array_{} unpack_value_array_{})",
+            n,
+            n
+        );
+        fmt.empty_line();
+    }
+
+    // Generate all of the block arrays we need for `InstructionData` as well as
+    // the constructors and extractors for them.
+    fmt.line(";;;; Block Arrays ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;");
+    fmt.empty_line();
+    let block_array_arities: BTreeSet<_> = formats
+        .iter()
+        .filter(|f| f.num_block_operands > 1)
+        .map(|f| f.num_block_operands)
+        .collect();
+    for n in block_array_arities {
+        fmtln!(fmt, ";; ISLE representation of `[BlockCall; {}]`.", n);
+        fmtln!(fmt, "(type BlockArray{} extern (enum))", n);
+        fmt.empty_line();
+
+        fmtln!(
+            fmt,
+            "(decl block_array_{0} ({1}) BlockArray{0})",
+            n,
+            (0..n).map(|_| "BlockCall").collect::<Vec<_>>().join(" ")
+        );
+
+        fmtln!(
+            fmt,
+            "(extern constructor block_array_{0} pack_block_array_{0})",
+            n
+        );
+
+        fmtln!(
+            fmt,
+            "(extern extractor infallible block_array_{0} unpack_block_array_{0})",
+            n
+        );
+        fmt.empty_line();
+    }
+
+    // Generate the extern type declaration for `Opcode`.
+    fmt.line(";;;; `Opcode` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;");
+    fmt.empty_line();
+    fmt.line("(type Opcode extern");
+    fmt.indent(|fmt| {
+        fmt.line("(enum");
+        fmt.indent(|fmt| {
+            for inst in instructions {
+                fmtln!(fmt, "{}", inst.camel_name);
+            }
+        });
+        fmt.line(")");
+    });
+    fmt.line(")");
+    fmt.empty_line();
+
+    // Generate the extern type declaration for `InstructionData`.
+    fmtln!(
+        fmt,
+        ";;;; `InstructionData` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;",
+    );
+    fmt.empty_line();
+    fmtln!(fmt, "(type InstructionData extern");
+    fmt.indent(|fmt| {
+        fmt.line("(enum");
+        fmt.indent(|fmt| {
+            for format in formats {
+                let mut s = format!("({} (opcode Opcode)", format.name);
+                if format.has_value_list {
+                    s.push_str(" (args ValueList)");
+                } else if format.num_value_operands == 1 {
+                    s.push_str(" (arg Value)");
+                } else if format.num_value_operands > 1 {
+                    write!(&mut s, " (args ValueArray{})", format.num_value_operands).unwrap();
+                }
+
+                match format.num_block_operands {
+                    0 => (),
+                    1 => write!(&mut s, " (destination BlockCall)").unwrap(),
+                    n => write!(&mut s, " (blocks BlockArray{n})").unwrap(),
+                }
+
+                for field in &format.imm_fields {
+                    write!(
+                        &mut s,
+                        " ({} {})",
+                        field.member,
+                        field.kind.rust_type.rsplit("::").next().unwrap()
+                    )
+                    .unwrap();
+                }
+                s.push(')');
+                fmt.line(&s);
+            }
+        });
+        fmt.line(")");
+    });
+    fmt.line(")");
+    fmt.empty_line();
+
+    // Generate the helper extractors for each opcode's full instruction.
+    fmtln!(
+        fmt,
+        ";;;; Extracting Opcode, Operands, and Immediates from `InstructionData` ;;;;;;;;",
+    );
+    fmt.empty_line();
+    let ret_ty = match isle_target {
+        IsleTarget::Lower => "Inst",
+        IsleTarget::Opt => "Value",
+    };
+    for inst in instructions {
+        if isle_target == IsleTarget::Opt
+            && (inst.format.has_value_list || inst.value_results.len() != 1)
+        {
+            continue;
+        }
+
+        let has_ty_param = !inst.format.has_value_list && inst.value_results.len() >= 1;
+
+        fmtln!(
+            fmt,
+            "(decl {} ({}{}) {})",
+            inst.name,
+            if has_ty_param { "Type " } else { "" },
+            inst.operands_in
+                .iter()
+                .map(|o| {
+                    let ty = o.kind.rust_type;
+                    if ty == "&[Value]" {
+                        "ValueSlice"
+                    } else {
+                        ty.rsplit("::").next().unwrap()
+                    }
+                })
+                .collect::<Vec<_>>()
+                .join(" "),
+            ret_ty
+        );
+        fmtln!(fmt, "(attr {} (tag clif_{}))", inst.name, inst.name);
+        fmtln!(fmt, "(extractor");
+        fmt.indent(|fmt| {
+            fmtln!(
+                fmt,
+                "({} {}{})",
+                inst.name,
+                if has_ty_param { "ty " } else { "" },
+                inst.operands_in
+                    .iter()
+                    .map(|o| { o.name })
+                    .collect::<Vec<_>>()
+                    .join(" ")
+            );
+
+            let mut s = format!(
+                "(inst_data {} (InstructionData.{} (Opcode.{})",
+                if has_ty_param { "ty" } else { "_" },
+                inst.format.name,
+                inst.camel_name
+            );
+
+            // Value and varargs operands.
+            if inst.format.has_value_list {
+                // The instruction format uses a value list, but the
+                // instruction itself might have not only a `&[Value]`
+                // varargs operand, but also one or more `Value` operands as
+                // well. If this is the case, then we need to read them off
+                // the front of the `ValueList`.
+                let values: Vec<_> = inst
+                    .operands_in
+                    .iter()
+                    .filter(|o| o.is_value())
+                    .map(|o| o.name)
+                    .collect();
+                let varargs = inst
+                    .operands_in
+                    .iter()
+                    .find(|o| o.is_varargs())
+                    .unwrap()
+                    .name;
+                if values.is_empty() {
+                    write!(&mut s, " (value_list_slice {varargs})").unwrap();
+                } else {
+                    write!(
+                        &mut s,
+                        " (unwrap_head_value_list_{} {} {})",
+                        values.len(),
+                        values.join(" "),
+                        varargs
+                    )
+                    .unwrap();
+                }
+            } else if inst.format.num_value_operands == 1 {
+                write!(
+                    &mut s,
+                    " {}",
+                    inst.operands_in.iter().find(|o| o.is_value()).unwrap().name
+                )
+                .unwrap();
+            } else if inst.format.num_value_operands > 1 {
+                let values = inst
+                    .operands_in
+                    .iter()
+                    .filter(|o| o.is_value())
+                    .map(|o| o.name)
+                    .collect::<Vec<_>>();
+                assert_eq!(values.len(), inst.format.num_value_operands);
+                let values = values.join(" ");
+                write!(
+                    &mut s,
+                    " (value_array_{} {})",
+                    inst.format.num_value_operands, values,
+                )
+                .unwrap();
+            }
+
+            // Immediates.
+            let imm_operands: Vec<_> = inst
+                .operands_in
+                .iter()
+                .filter(|o| !o.is_value() && !o.is_varargs() && !o.kind.is_block())
+                .collect();
+            assert_eq!(imm_operands.len(), inst.format.imm_fields.len(),);
+            for op in imm_operands {
+                write!(&mut s, " {}", op.name).unwrap();
+            }
+
+            // Blocks.
+            let block_operands: Vec<_> = inst
+                .operands_in
+                .iter()
+                .filter(|o| o.kind.is_block())
+                .collect();
+            assert_eq!(block_operands.len(), inst.format.num_block_operands);
+            assert!(block_operands.len() <= 2);
+
+            if !block_operands.is_empty() {
+                if block_operands.len() == 1 {
+                    write!(&mut s, " {}", block_operands[0].name).unwrap();
+                } else {
+                    let blocks: Vec<_> = block_operands.iter().map(|o| o.name).collect();
+                    let blocks = blocks.join(" ");
+                    write!(
+                        &mut s,
+                        " (block_array_{} {})",
+                        inst.format.num_block_operands, blocks,
+                    )
+                    .unwrap();
+                }
+            }
+
+            s.push_str("))");
+            fmt.line(&s);
+        });
+        fmt.line(")");
+
+        // Generate a constructor if this is the mid-end prelude.
+        if isle_target == IsleTarget::Opt {
+            fmtln!(
+                fmt,
+                "(rule ({} ty {})",
+                inst.name,
+                inst.operands_in
+                    .iter()
+                    .map(|o| o.name)
+                    .collect::<Vec<_>>()
+                    .join(" ")
+            );
+            fmt.indent(|fmt| {
+                let mut s = format!(
+                    "(make_inst ty (InstructionData.{} (Opcode.{})",
+                    inst.format.name, inst.camel_name
+                );
+
+                // Handle values. Note that we skip generating
+                // constructors for any instructions with variadic
+                // value lists. This is fine for the mid-end because
+                // in practice only calls and branches (for branch
+                // args) use this functionality, and neither can
+                // really be optimized or rewritten in the mid-end
+                // (currently).
+                //
+                // As a consequence, we only have to handle the
+                // one-`Value` case, in which the `Value` is directly
+                // in the `InstructionData`, and the multiple-`Value`
+                // case, in which the `Value`s are in a
+                // statically-sized array (e.g. `[Value; 2]` for a
+                // binary op).
+                assert!(!inst.format.has_value_list);
+                if inst.format.num_value_operands == 1 {
+                    write!(
+                        &mut s,
+                        " {}",
+                        inst.operands_in.iter().find(|o| o.is_value()).unwrap().name
+                    )
+                    .unwrap();
+                } else if inst.format.num_value_operands > 1 {
+                    // As above, get all bindings together, and pass
+                    // to a sub-term; here we use a constructor to
+                    // build the value array.
+                    let values = inst
+                        .operands_in
+                        .iter()
+                        .filter(|o| o.is_value())
+                        .map(|o| o.name)
+                        .collect::<Vec<_>>();
+                    assert_eq!(values.len(), inst.format.num_value_operands);
+                    let values = values.join(" ");
+                    write!(
+                        &mut s,
+                        " (value_array_{}_ctor {})",
+                        inst.format.num_value_operands, values
+                    )
+                    .unwrap();
+                }
+
+                if inst.format.num_block_operands > 0 {
+                    let blocks: Vec<_> = inst
+                        .operands_in
+                        .iter()
+                        .filter(|o| o.kind.is_block())
+                        .map(|o| o.name)
+                        .collect();
+                    if inst.format.num_block_operands == 1 {
+                        write!(&mut s, " {}", blocks.first().unwrap(),).unwrap();
+                    } else {
+                        write!(
+                            &mut s,
+                            " (block_array_{} {})",
+                            inst.format.num_block_operands,
+                            blocks.join(" ")
+                        )
+                        .unwrap();
+                    }
+                }
+
+                // Immediates (non-value args).
+                for o in inst
+                    .operands_in
+                    .iter()
+                    .filter(|o| !o.is_value() && !o.is_varargs() && !o.kind.is_block())
+                {
+                    write!(&mut s, " {}", o.name).unwrap();
+                }
+                s.push_str("))");
+                fmt.line(&s);
+            });
+            fmt.line(")");
+        }
+
+        fmt.empty_line();
+    }
+}
+
+fn gen_opt_isle(
+    formats: &[Rc<InstructionFormat>],
+    instructions: &AllInstructions,
+    fmt: &mut Formatter,
+) {
+    gen_common_isle(formats, instructions, fmt, IsleTarget::Opt);
+}
+
+fn gen_lower_isle(
+    formats: &[Rc<InstructionFormat>],
+    instructions: &AllInstructions,
+    fmt: &mut Formatter,
+) {
+    gen_common_isle(formats, instructions, fmt, IsleTarget::Lower);
+}
+
+/// Generate an `enum` immediate in ISLE.
+fn gen_isle_enum(name: &str, mut variants: Vec<&str>, fmt: &mut Formatter) {
+    variants.sort();
+    let prefix = format!(";;;; Enumerated Immediate: {name} ");
+    fmtln!(fmt, "{:;<80}", prefix);
+    fmt.empty_line();
+    fmtln!(fmt, "(type {} extern", name);
+    fmt.indent(|fmt| {
+        fmt.line("(enum");
+        fmt.indent(|fmt| {
+            for variant in variants {
+                fmtln!(fmt, "{}", variant);
+            }
+        });
+        fmt.line(")");
+    });
+    fmt.line(")");
+    fmt.empty_line();
+}
+
+pub(crate) fn generate(
+    formats: &[Rc<InstructionFormat>],
+    all_inst: &AllInstructions,
+    isle_opt_filename: &str,
+    isle_lower_filename: &str,
+    isle_dir: &std::path::Path,
+) -> Result<(), error::Error> {
+    // ISLE DSL: mid-end ("opt") generated bindings.
+    let mut fmt = Formatter::new();
+    gen_opt_isle(&formats, all_inst, &mut fmt);
+    fmt.update_file(isle_opt_filename, isle_dir)?;
+
+    // ISLE DSL: lowering generated bindings.
+    let mut fmt = Formatter::new();
+    gen_lower_isle(&formats, all_inst, &mut fmt);
+    fmt.update_file(isle_lower_filename, isle_dir)?;
+
+    Ok(())
+}
diff --git a/cranelift/codegen/meta/src/gen_settings.rs b/cranelift/codegen/meta/src/gen_settings.rs
index 097581bef6d8..3d9a4e00cff5 100644
--- a/cranelift/codegen/meta/src/gen_settings.rs
+++ b/cranelift/codegen/meta/src/gen_settings.rs
@@ -172,7 +172,7 @@ fn gen_enum_types(group: &SettingGroup, fmt: &mut Formatter) {
         fmtln!(fmt, "pub enum {} {{", name);
         fmt.indent(|fmt| {
             for v in values.iter() {
-                fmt.doc_comment(format!("`{}`.", v));
+                fmt.doc_comment(format!("`{v}`."));
                 fmtln!(fmt, "{},", camel_case(v));
             }
         });
@@ -207,7 +207,7 @@ fn gen_getter(setting: &Setting, fmt: &mut Formatter) {
             fmt.indent(|fmt| {
                 let mut m = Match::new(format!("self.bytes[{}]", setting.byte_offset));
                 for (i, v) in values.iter().enumerate() {
-                    m.arm_no_fields(format!("{}", i), format!("{}::{}", ty, camel_case(v)));
+                    m.arm_no_fields(format!("{i}"), format!("{}::{}", ty, camel_case(v)));
                 }
                 m.arm_no_fields("_", "panic!(\"Invalid enum value\")");
                 fmt.add_match(m);
@@ -415,10 +415,7 @@ fn gen_template(group: &SettingGroup, fmt: &mut Formatter) {
         *default_bytes.get_mut(setting.byte_offset as usize).unwrap() |= setting.default_byte();
     }
 
-    let default_bytes: Vec<String> = default_bytes
-        .iter()
-        .map(|x| format!("{:#04x}", x))
-        .collect();
+    let default_bytes: Vec<String> = default_bytes.iter().map(|x| format!("{x:#04x}")).collect();
     let default_bytes_str = default_bytes.join(", ");
 
     fmtln!(
@@ -499,7 +496,7 @@ pub(crate) fn generate(
     settings: &SettingGroup,
     parent_group: ParentGroup,
     filename: &str,
-    out_dir: &str,
+    out_dir: &std::path::Path,
 ) -> Result<(), error::Error> {
     let mut fmt = Formatter::new();
     gen_group(settings, parent_group, &mut fmt);
diff --git a/cranelift/codegen/meta/src/gen_types.rs b/cranelift/codegen/meta/src/gen_types.rs
index 7c7cacda31b0..e0e66a3de9be 100644
--- a/cranelift/codegen/meta/src/gen_types.rs
+++ b/cranelift/codegen/meta/src/gen_types.rs
@@ -53,11 +53,6 @@ fn emit_types(fmt: &mut srcgen::Formatter) {
         emit_type(&ty, fmt);
     }
 
-    // Emit all reference types.
-    for ty in cdsl_types::ValueType::all_reference_types().map(cdsl_types::ValueType::from) {
-        emit_type(&ty, fmt);
-    }
-
     // Emit vector definitions for common SIMD sizes.
     // Emit dynamic vector definitions.
     for vec_size in &[16_u64, 32, 64, 128, 256, 512] {
@@ -67,7 +62,7 @@ fn emit_types(fmt: &mut srcgen::Formatter) {
 }
 
 /// Generate the types file.
-pub(crate) fn generate(filename: &str, out_dir: &str) -> Result<(), error::Error> {
+pub(crate) fn generate(filename: &str, out_dir: &std::path::Path) -> Result<(), error::Error> {
     let mut fmt = srcgen::Formatter::new();
     emit_types(&mut fmt);
     fmt.update_file(filename, out_dir)?;
diff --git a/cranelift/codegen/meta/src/isa/arm64.rs b/cranelift/codegen/meta/src/isa/arm64.rs
index 34d82b8a5520..afad7d15468f 100644
--- a/cranelift/codegen/meta/src/isa/arm64.rs
+++ b/cranelift/codegen/meta/src/isa/arm64.rs
@@ -18,6 +18,12 @@ pub(crate) fn define() -> TargetIsa {
         "",
         false,
     );
+    settings.add_bool(
+        "has_fp16",
+        "Use half-precision floating point (FEAT_FP16) instructions.",
+        "",
+        false,
+    );
     settings.add_bool(
         "sign_return_address_all",
         "If function return address signing is enabled, then apply it to all \
diff --git a/cranelift/codegen/meta/src/isa/mod.rs b/cranelift/codegen/meta/src/isa/mod.rs
index ecda9b83d054..655b14a9c5a1 100644
--- a/cranelift/codegen/meta/src/isa/mod.rs
+++ b/cranelift/codegen/meta/src/isa/mod.rs
@@ -3,6 +3,7 @@ use crate::cdsl::isa::TargetIsa;
 use std::fmt;
 
 mod arm64;
+mod pulley;
 mod riscv64;
 mod s390x;
 pub(crate) mod x86;
@@ -14,6 +15,8 @@ pub enum Isa {
     Arm64,
     S390x,
     Riscv64,
+    Pulley32,
+    Pulley64,
 }
 
 impl Isa {
@@ -32,13 +35,22 @@ impl Isa {
             "s390x" => Some(Isa::S390x),
             x if ["x86_64", "i386", "i586", "i686"].contains(&x) => Some(Isa::X86),
             "riscv64" | "riscv64gc" | "riscv64imac" => Some(Isa::Riscv64),
+            "pulley32" => Some(Isa::Pulley32),
+            "pulley64" => Some(Isa::Pulley64),
             _ => None,
         }
     }
 
     /// Returns all supported isa targets.
     pub fn all() -> &'static [Isa] {
-        &[Isa::X86, Isa::Arm64, Isa::S390x, Isa::Riscv64]
+        &[
+            Isa::X86,
+            Isa::Arm64,
+            Isa::S390x,
+            Isa::Riscv64,
+            Isa::Pulley32,
+            Isa::Pulley64,
+        ]
     }
 }
 
@@ -50,6 +62,8 @@ impl fmt::Display for Isa {
             Isa::Arm64 => write!(f, "arm64"),
             Isa::S390x => write!(f, "s390x"),
             Isa::Riscv64 => write!(f, "riscv64"),
+            Isa::Pulley32 => write!(f, "pulley32"),
+            Isa::Pulley64 => write!(f, "pulley64"),
         }
     }
 }
@@ -61,6 +75,7 @@ pub(crate) fn define(isas: &[Isa]) -> Vec<TargetIsa> {
             Isa::Arm64 => arm64::define(),
             Isa::S390x => s390x::define(),
             Isa::Riscv64 => riscv64::define(),
+            Isa::Pulley32 | Isa::Pulley64 => pulley::define(),
         })
         .collect()
 }
diff --git a/cranelift/codegen/meta/src/isa/pulley.rs b/cranelift/codegen/meta/src/isa/pulley.rs
new file mode 100644
index 000000000000..7ae14ae682a2
--- /dev/null
+++ b/cranelift/codegen/meta/src/isa/pulley.rs
@@ -0,0 +1,14 @@
+use crate::cdsl::{isa::TargetIsa, settings::SettingGroupBuilder};
+
+pub(crate) fn define() -> TargetIsa {
+    let mut settings = SettingGroupBuilder::new("pulley");
+    settings.add_enum(
+        "pointer_width",
+        "The width of pointers for this Pulley target",
+        "Supported values:\n\
+         * 'pointer32'\n\
+         * 'pointer64'\n",
+        vec!["pointer32", "pointer64"],
+    );
+    TargetIsa::new("pulley", settings.build())
+}
diff --git a/cranelift/codegen/meta/src/isa/riscv64.rs b/cranelift/codegen/meta/src/isa/riscv64.rs
index 9a24efd916c4..355a9125abfb 100644
--- a/cranelift/codegen/meta/src/isa/riscv64.rs
+++ b/cranelift/codegen/meta/src/isa/riscv64.rs
@@ -56,6 +56,21 @@ pub(crate) fn define() -> TargetIsa {
         "Double-precision floating point",
         true,
     );
+
+    let _has_zfa = setting.add_bool(
+        "has_zfa",
+        "has extension Zfa?",
+        "Zfa: Extension for Additional Floating-Point Instructions",
+        false,
+    );
+
+    let _has_zfh = setting.add_bool(
+        "has_zfh",
+        "has extension Zfh?",
+        "Zfh: Half-Precision Floating-Point Instructions",
+        false,
+    );
+
     let _has_v = setting.add_bool(
         "has_v",
         "has extension V?",
@@ -118,6 +133,12 @@ pub(crate) fn define() -> TargetIsa {
         "Zbs: Single-bit instructions",
         false,
     );
+    let _has_zicond = setting.add_bool(
+        "has_zicond",
+        "has extension zicond?",
+        "ZiCond: Integer Conditional Operations",
+        false,
+    );
 
     let has_zicsr = setting.add_bool(
         "has_zicsr",
@@ -133,7 +154,7 @@ pub(crate) fn define() -> TargetIsa {
     );
 
     // Zvl*: Minimum Vector Length Standard Extensions
-    // These extension specifiy the minimum number of bits in a vector register.
+    // These extension specify the minimum number of bits in a vector register.
     // Since it is a minimum, Zvl64b implies Zvl32b, Zvl128b implies Zvl64b, etc.
     // The V extension supports a maximum of 64K bits in a single register.
     //
diff --git a/cranelift/codegen/meta/src/isa/x86.rs b/cranelift/codegen/meta/src/isa/x86.rs
index 5b59f87a5e64..18f80b067394 100644
--- a/cranelift/codegen/meta/src/isa/x86.rs
+++ b/cranelift/codegen/meta/src/isa/x86.rs
@@ -284,7 +284,7 @@ pub(crate) fn define() -> TargetIsa {
     );
     let sapphire_rapids = settings.add_preset(
         "sapphirerapids",
-        "Saphire Rapids microarchitecture.",
+        "Sapphire Rapids microarchitecture.",
         preset!(icelake_server),
     );
     settings.add_preset(
@@ -373,11 +373,23 @@ pub(crate) fn define() -> TargetIsa {
         "Zen (second generation) microarchitecture.",
         preset!(znver1),
     );
-    settings.add_preset(
+    let znver3 = settings.add_preset(
         "znver3",
         "Zen (third generation) microarchitecture.",
         preset!(znver2),
     );
+    settings.add_preset(
+        "znver4",
+        "Zen (fourth generation) microarchitecture.",
+        preset!(
+            znver3
+                && has_avx512bitalg
+                && has_avx512dq
+                && has_avx512f
+                && has_avx512vbmi
+                && has_avx512vl
+        ),
+    );
 
     // Generic
 
diff --git a/cranelift/codegen/meta/src/isle.rs b/cranelift/codegen/meta/src/isle.rs
new file mode 100644
index 000000000000..84706f4a9401
--- /dev/null
+++ b/cranelift/codegen/meta/src/isle.rs
@@ -0,0 +1,230 @@
+use std::io::Result;
+
+/// A list of compilations (transformations from ISLE source to
+/// generated Rust source) that exist in the repository.
+///
+/// This list is used either to regenerate the Rust source in-tree (if
+/// the `rebuild-isle` feature is enabled), or to verify that the ISLE
+/// source in-tree corresponds to the ISLE source that was last used
+/// to rebuild the Rust source (if the `rebuild-isle` feature is not
+/// enabled).
+#[derive(Clone, Debug)]
+pub struct IsleCompilations {
+    pub items: Vec<IsleCompilation>,
+}
+
+impl IsleCompilations {
+    pub fn lookup(&self, name: &str) -> Option<&IsleCompilation> {
+        for compilation in &self.items {
+            if compilation.name == name {
+                return Some(compilation);
+            }
+        }
+        None
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct IsleCompilation {
+    pub name: String,
+    pub output: std::path::PathBuf,
+    pub tracked_inputs: Vec<std::path::PathBuf>,
+    pub untracked_inputs: Vec<std::path::PathBuf>,
+    pub rule_trace: bool,
+}
+
+impl IsleCompilation {
+    /// All inputs to the computation, tracked or untracked. May contain directories.
+    pub fn inputs(&self) -> Vec<std::path::PathBuf> {
+        self.tracked_inputs
+            .iter()
+            .chain(self.untracked_inputs.iter())
+            .cloned()
+            .collect()
+    }
+
+    /// All path inputs to the compilation. Directory inputs are expanded to the
+    /// list of all ISLE files in the directory.
+    pub fn paths(&self) -> Result<Vec<std::path::PathBuf>> {
+        let mut paths = Vec::new();
+        for input in self.inputs() {
+            paths.extend(Self::expand_paths(&input)?);
+        }
+        Ok(paths)
+    }
+
+    fn expand_paths(input: &std::path::PathBuf) -> Result<Vec<std::path::PathBuf>> {
+        if input.is_file() {
+            return Ok(vec![input.clone()]);
+        }
+
+        let mut paths = Vec::new();
+        for entry in std::fs::read_dir(input)? {
+            let path = entry?.path();
+            if let Some(ext) = path.extension() {
+                if ext == "isle" {
+                    paths.push(path);
+                }
+            }
+        }
+        Ok(paths)
+    }
+}
+
+/// Construct the list of compilations (transformations from ISLE
+/// source to generated Rust source) that exist in the repository.
+pub fn get_isle_compilations(
+    codegen_crate_dir: &std::path::Path,
+    gen_dir: &std::path::Path,
+) -> IsleCompilations {
+    // Preludes.
+    let clif_lower_isle = gen_dir.join("clif_lower.isle");
+    let clif_opt_isle = gen_dir.join("clif_opt.isle");
+    let prelude_isle = codegen_crate_dir.join("src").join("prelude.isle");
+    let prelude_opt_isle = codegen_crate_dir.join("src").join("prelude_opt.isle");
+    let prelude_lower_isle = codegen_crate_dir.join("src").join("prelude_lower.isle");
+    let prelude_spec_isle = codegen_crate_dir.join("src").join("prelude_spec.isle");
+    let inst_specs_isle = codegen_crate_dir.join("src").join("inst_specs.isle");
+    let inst_tags_isle = codegen_crate_dir.join("src").join("inst_tags.isle");
+    let fpconst_isle = codegen_crate_dir.join("src").join("fpconst.isle");
+    let state_isle = codegen_crate_dir.join("src").join("state.isle");
+
+    // Directory for mid-end optimizations.
+    let src_opts = codegen_crate_dir.join("src").join("opts");
+
+    // Directories for lowering backends.
+    let src_isa_x64 = codegen_crate_dir.join("src").join("isa").join("x64");
+    let src_isa_aarch64 = codegen_crate_dir.join("src").join("isa").join("aarch64");
+    let src_isa_s390x = codegen_crate_dir.join("src").join("isa").join("s390x");
+    let src_isa_risc_v = codegen_crate_dir.join("src").join("isa").join("riscv64");
+    let src_isa_pulley_shared = codegen_crate_dir
+        .join("src")
+        .join("isa")
+        .join("pulley_shared");
+
+    // This is a set of ISLE compilation units.
+    //
+    // The format of each entry is:
+    //
+    //     (output Rust code file, input ISLE source files)
+    //
+    // There should be one entry for each backend that uses ISLE for lowering,
+    // and if/when we replace our peephole optimization passes with ISLE, there
+    // should be an entry for each of those as well.
+    //
+    // N.B.: add any new compilation outputs to
+    // `scripts/force-rebuild-isle.sh` if they do not fit the pattern
+    // `cranelift/codegen/src/isa/*/lower/isle/generated_code.rs`!
+    IsleCompilations {
+        items: vec![
+            // The mid-end optimization rules.
+            IsleCompilation {
+                name: "opt".to_string(),
+                output: gen_dir.join("isle_opt.rs"),
+                tracked_inputs: vec![
+                    prelude_isle.clone(),
+                    prelude_opt_isle,
+                    prelude_spec_isle.clone(),
+                    inst_specs_isle.clone(),
+                    inst_tags_isle.clone(),
+                    src_opts.join("arithmetic.isle"),
+                    src_opts.join("bitops.isle"),
+                    src_opts.join("cprop.isle"),
+                    src_opts.join("extends.isle"),
+                    src_opts.join("icmp.isle"),
+                    src_opts.join("remat.isle"),
+                    src_opts.join("selects.isle"),
+                    src_opts.join("shifts.isle"),
+                    src_opts.join("spaceship.isle"),
+                    src_opts.join("spectre.isle"),
+                    src_opts.join("vector.isle"),
+                ],
+                untracked_inputs: vec![clif_opt_isle],
+                rule_trace: false,
+            },
+            // The x86-64 instruction selector.
+            IsleCompilation {
+                name: "x64".to_string(),
+                output: gen_dir.join("isle_x64.rs"),
+                tracked_inputs: vec![
+                    prelude_isle.clone(),
+                    prelude_lower_isle.clone(),
+                    prelude_spec_isle.clone(),
+                    inst_specs_isle.clone(),
+                    inst_tags_isle.clone(),
+                    src_isa_x64.join("inst.isle"),
+                    src_isa_x64.join("lower.isle"),
+                ],
+                untracked_inputs: vec![clif_lower_isle.clone()],
+                rule_trace: false,
+            },
+            // The aarch64 instruction selector.
+            IsleCompilation {
+                name: "aarch64".to_string(),
+                output: gen_dir.join("isle_aarch64.rs"),
+                tracked_inputs: vec![
+                    prelude_isle.clone(),
+                    prelude_lower_isle.clone(),
+                    prelude_spec_isle.clone(),
+                    inst_specs_isle.clone(),
+                    inst_tags_isle.clone(),
+                    fpconst_isle.clone(),
+                    state_isle.clone(),
+                    src_isa_aarch64.join("inst.isle"),
+                    src_isa_aarch64.join("inst_neon.isle"),
+                    src_isa_aarch64.join("spec"),
+                    src_isa_aarch64.join("lower.isle"),
+                    src_isa_aarch64.join("lower_dynamic_neon.isle"),
+                ],
+                untracked_inputs: vec![clif_lower_isle.clone()],
+                rule_trace: true,
+            },
+            // The s390x instruction selector.
+            IsleCompilation {
+                name: "s390x".to_string(),
+                output: gen_dir.join("isle_s390x.rs"),
+                tracked_inputs: vec![
+                    prelude_isle.clone(),
+                    prelude_lower_isle.clone(),
+                    prelude_spec_isle.clone(),
+                    inst_specs_isle.clone(),
+                    inst_tags_isle.clone(),
+                    src_isa_s390x.join("inst.isle"),
+                    src_isa_s390x.join("lower.isle"),
+                ],
+                untracked_inputs: vec![clif_lower_isle.clone()],
+                rule_trace: false,
+            },
+            // The risc-v instruction selector.
+            IsleCompilation {
+                name: "riscv64".to_string(),
+                output: gen_dir.join("isle_riscv64.rs"),
+                tracked_inputs: vec![
+                    prelude_isle.clone(),
+                    prelude_lower_isle.clone(),
+                    prelude_spec_isle.clone(),
+                    inst_specs_isle.clone(),
+                    inst_tags_isle.clone(),
+                    src_isa_risc_v.join("inst.isle"),
+                    src_isa_risc_v.join("inst_vector.isle"),
+                    src_isa_risc_v.join("lower.isle"),
+                ],
+                untracked_inputs: vec![clif_lower_isle.clone()],
+                rule_trace: false,
+            },
+            // The Pulley instruction selector.
+            IsleCompilation {
+                name: "pulley".to_string(),
+                output: gen_dir.join("isle_pulley_shared.rs"),
+                tracked_inputs: vec![
+                    prelude_isle.clone(),
+                    prelude_lower_isle.clone(),
+                    src_isa_pulley_shared.join("inst.isle"),
+                    src_isa_pulley_shared.join("lower.isle"),
+                ],
+                untracked_inputs: vec![clif_lower_isle.clone()],
+                rule_trace: false,
+            },
+        ],
+    }
+}
diff --git a/cranelift/codegen/meta/src/lib.rs b/cranelift/codegen/meta/src/lib.rs
index 689d3508b06c..480719d045d1 100644
--- a/cranelift/codegen/meta/src/lib.rs
+++ b/cranelift/codegen/meta/src/lib.rs
@@ -1,14 +1,18 @@
 //! This crate generates Rust sources for use by
 //! [`cranelift_codegen`](../cranelift_codegen/index.html).
 
+use shared::Definitions;
+
 #[macro_use]
 mod cdsl;
 mod srcgen;
 
 pub mod error;
 pub mod isa;
+pub mod isle;
 
 mod gen_inst;
+mod gen_isle;
 mod gen_settings;
 mod gen_types;
 
@@ -18,20 +22,27 @@ mod unique_table;
 
 /// Generate an ISA from an architecture string (e.g. "x86_64").
 pub fn isa_from_arch(arch: &str) -> Result<isa::Isa, String> {
-    isa::Isa::from_arch(arch).ok_or_else(|| format!("no supported isa found for arch `{}`", arch))
+    isa::Isa::from_arch(arch).ok_or_else(|| format!("no supported isa found for arch `{arch}`"))
 }
 
 /// Generates all the Rust source files used in Cranelift from the meta-language.
-pub fn generate(isas: &[isa::Isa], out_dir: &str, isle_dir: &str) -> Result<(), error::Error> {
-    // Common definitions.
+pub fn generate_rust(isas: &[isa::Isa], out_dir: &std::path::Path) -> Result<(), error::Error> {
     let shared_defs = shared::define();
+    generate_rust_for_shared_defs(&shared_defs, isas, out_dir)
+}
 
+fn generate_rust_for_shared_defs(
+    shared_defs: &Definitions,
+    isas: &[isa::Isa],
+    out_dir: &std::path::Path,
+) -> Result<(), error::Error> {
     gen_settings::generate(
         &shared_defs.settings,
         gen_settings::ParentGroup::None,
         "settings.rs",
         out_dir,
     )?;
+
     gen_types::generate("types.rs", out_dir)?;
 
     gen_inst::generate(
@@ -39,10 +50,7 @@ pub fn generate(isas: &[isa::Isa], out_dir: &str, isle_dir: &str) -> Result<(),
         &shared_defs.all_instructions,
         "opcodes.rs",
         "inst_builder.rs",
-        "clif_opt.isle",
-        "clif_lower.isle",
         out_dir,
-        isle_dir,
     )?;
 
     // Per ISA definitions.
@@ -57,3 +65,34 @@ pub fn generate(isas: &[isa::Isa], out_dir: &str, isle_dir: &str) -> Result<(),
 
     Ok(())
 }
+
+/// Generates all the ISLE source files used in Cranelift from the meta-language.
+pub fn generate_isle(isle_dir: &std::path::Path) -> Result<(), error::Error> {
+    let shared_defs = shared::define();
+    generate_isle_for_shared_defs(&shared_defs, isle_dir)
+}
+
+fn generate_isle_for_shared_defs(
+    shared_defs: &Definitions,
+    isle_dir: &std::path::Path,
+) -> Result<(), error::Error> {
+    gen_isle::generate(
+        &shared_defs.all_formats,
+        &shared_defs.all_instructions,
+        "clif_opt.isle",
+        "clif_lower.isle",
+        isle_dir,
+    )
+}
+
+/// Generates all the source files used in Cranelift from the meta-language.
+pub fn generate(
+    isas: &[isa::Isa],
+    out_dir: &std::path::Path,
+    isle_dir: &std::path::Path,
+) -> Result<(), error::Error> {
+    let shared_defs = shared::define();
+    generate_rust_for_shared_defs(&shared_defs, isas, out_dir)?;
+    generate_isle_for_shared_defs(&shared_defs, isle_dir)?;
+    Ok(())
+}
diff --git a/cranelift/codegen/meta/src/shared/entities.rs b/cranelift/codegen/meta/src/shared/entities.rs
index 374e61f4167b..3df9ecaa171f 100644
--- a/cranelift/codegen/meta/src/shared/entities.rs
+++ b/cranelift/codegen/meta/src/shared/entities.rs
@@ -43,9 +43,6 @@ pub(crate) struct EntityRefs {
     /// A reference to a jump table declared in the function preamble.
     pub(crate) jump_table: OperandKind,
 
-    /// A reference to a table declared in the function preamble.
-    pub(crate) table: OperandKind,
-
     /// A variable-sized list of value operands. Use for Block and function call arguments.
     pub(crate) varargs: OperandKind,
 }
@@ -87,8 +84,6 @@ impl EntityRefs {
 
             jump_table: new("table", "ir::JumpTable", "A jump table."),
 
-            table: new("table", "ir::Table", "A table."),
-
             varargs: OperandKind::new(
                 "",
                 "&[Value]",
diff --git a/cranelift/codegen/meta/src/shared/formats.rs b/cranelift/codegen/meta/src/shared/formats.rs
index 35ea2e7f8ff4..86d54338d63d 100644
--- a/cranelift/codegen/meta/src/shared/formats.rs
+++ b/cranelift/codegen/meta/src/shared/formats.rs
@@ -30,13 +30,13 @@ pub(crate) struct Formats {
     pub(crate) dynamic_stack_store: Rc<InstructionFormat>,
     pub(crate) store: Rc<InstructionFormat>,
     pub(crate) store_no_offset: Rc<InstructionFormat>,
-    pub(crate) table_addr: Rc<InstructionFormat>,
     pub(crate) ternary: Rc<InstructionFormat>,
     pub(crate) ternary_imm8: Rc<InstructionFormat>,
     pub(crate) trap: Rc<InstructionFormat>,
     pub(crate) unary: Rc<InstructionFormat>,
     pub(crate) unary_const: Rc<InstructionFormat>,
     pub(crate) unary_global_value: Rc<InstructionFormat>,
+    pub(crate) unary_ieee16: Rc<InstructionFormat>,
     pub(crate) unary_ieee32: Rc<InstructionFormat>,
     pub(crate) unary_ieee64: Rc<InstructionFormat>,
     pub(crate) unary_imm: Rc<InstructionFormat>,
@@ -49,6 +49,8 @@ impl Formats {
 
             unary_imm: Builder::new("UnaryImm").imm(&imm.imm64).build(),
 
+            unary_ieee16: Builder::new("UnaryIeee16").imm(&imm.ieee16).build(),
+
             unary_ieee32: Builder::new("UnaryIeee32").imm(&imm.ieee32).build(),
 
             unary_ieee64: Builder::new("UnaryIeee64").imm(&imm.ieee64).build(),
@@ -192,13 +194,6 @@ impl Formats {
                 .imm(&entities.dynamic_stack_slot)
                 .build(),
 
-            // Accessing a WebAssembly table.
-            table_addr: Builder::new("TableAddr")
-                .imm(&entities.table)
-                .value()
-                .imm(&imm.offset32)
-                .build(),
-
             trap: Builder::new("Trap").imm(&imm.trapcode).build(),
 
             cond_trap: Builder::new("CondTrap").value().imm(&imm.trapcode).build(),
diff --git a/cranelift/codegen/meta/src/shared/immediates.rs b/cranelift/codegen/meta/src/shared/immediates.rs
index 9f908c93da48..8e30c6b5f87d 100644
--- a/cranelift/codegen/meta/src/shared/immediates.rs
+++ b/cranelift/codegen/meta/src/shared/immediates.rs
@@ -31,6 +31,11 @@ pub(crate) struct Immediates {
     /// This is used to represent an immediate address offset in load/store instructions.
     pub offset32: OperandKind,
 
+    /// A 16-bit immediate floating point operand.
+    ///
+    /// IEEE 754-2008 binary16 interchange format.
+    pub ieee16: OperandKind,
+
     /// A 32-bit immediate floating point operand.
     ///
     /// IEEE 754-2008 binary32 interchange format.
@@ -119,6 +124,11 @@ impl Immediates {
                 "ir::immediates::Offset32",
                 "A 32-bit immediate signed offset.",
             ),
+            ieee16: new_imm(
+                "imm",
+                "ir::immediates::Ieee16",
+                "A 16-bit immediate floating point number.",
+            ),
             ieee32: new_imm(
                 "imm",
                 "ir::immediates::Ieee32",
@@ -181,6 +191,7 @@ impl Immediates {
                 trapcode_values.insert("heap_oob", "HeapOutOfBounds");
                 trapcode_values.insert("int_ovf", "IntegerOverflow");
                 trapcode_values.insert("int_divz", "IntegerDivisionByZero");
+                trapcode_values.insert("bad_toint", "BadConversionToInteger");
                 new_enum(
                     "code",
                     "ir::TrapCode",
diff --git a/cranelift/codegen/meta/src/shared/instructions.rs b/cranelift/codegen/meta/src/shared/instructions.rs
index 6727d9c8c345..4348a7b7168c 100644
--- a/cranelift/codegen/meta/src/shared/instructions.rs
+++ b/cranelift/codegen/meta/src/shared/instructions.rs
@@ -98,7 +98,7 @@ fn define_control_flow(
     let iAddr = &TypeVar::new(
         "iAddr",
         "An integer address type",
-        TypeSetBuilder::new().ints(32..64).refs(32..64).build(),
+        TypeSetBuilder::new().ints(32..64).build(),
     );
 
     ig.push(
@@ -144,20 +144,6 @@ fn define_control_flow(
         .can_trap(),
     );
 
-    ig.push(
-        Inst::new(
-            "resumable_trap",
-            r#"
-        A resumable trap.
-
-        This instruction allows non-conditional traps to be used as non-terminal instructions.
-        "#,
-            &formats.trap,
-        )
-        .operands_in(vec![Operand::new("code", &imm.trapcode)])
-        .can_trap(),
-    );
-
     ig.push(
         Inst::new(
             "trapnz",
@@ -175,23 +161,6 @@ fn define_control_flow(
         .can_trap(),
     );
 
-    ig.push(
-        Inst::new(
-            "resumable_trapnz",
-            r#"
-        A resumable trap to be called when the passed condition is non-zero.
-
-        If ``c`` is zero, execution continues at the following instruction.
-        "#,
-            &formats.cond_trap,
-        )
-        .operands_in(vec![
-            Operand::new("c", ScalarTruthy).with_doc("Controlling value to test"),
-            Operand::new("code", &imm.trapcode),
-        ])
-        .can_trap(),
-    );
-
     ig.push(
         Inst::new(
             "return",
@@ -630,8 +599,10 @@ pub(crate) fn define(
 
     // Operand kind shorthands.
     let i8: &TypeVar = &ValueType::from(LaneType::from(types::Int::I8)).into();
+    let f16_: &TypeVar = &ValueType::from(LaneType::from(types::Float::F16)).into();
     let f32_: &TypeVar = &ValueType::from(LaneType::from(types::Float::F32)).into();
     let f64_: &TypeVar = &ValueType::from(LaneType::from(types::Float::F64)).into();
+    let f128_: &TypeVar = &ValueType::from(LaneType::from(types::Float::F128)).into();
 
     // Starting definitions.
     let Int = &TypeVar::new(
@@ -671,13 +642,7 @@ pub(crate) fn define(
     let iAddr = &TypeVar::new(
         "iAddr",
         "An integer address type",
-        TypeSetBuilder::new().ints(32..64).refs(32..64).build(),
-    );
-
-    let Ref = &TypeVar::new(
-        "Ref",
-        "A scalar reference type",
-        TypeSetBuilder::new().refs(Interval::All).build(),
+        TypeSetBuilder::new().ints(32..64).build(),
     );
 
     let TxN = &TypeVar::new(
@@ -696,7 +661,6 @@ pub(crate) fn define(
         TypeSetBuilder::new()
             .ints(Interval::All)
             .floats(Interval::All)
-            .refs(Interval::All)
             .simd_lanes(Interval::All)
             .includes_scalars(true)
             .build(),
@@ -709,7 +673,6 @@ pub(crate) fn define(
             .ints(Interval::All)
             .floats(Interval::All)
             .simd_lanes(Interval::All)
-            .refs(Interval::All)
             .dynamic_simd_lanes(Interval::All)
             .build(),
     );
@@ -944,6 +907,66 @@ pub(crate) fn define(
         ])
         .can_store(),
     );
+    ig.push(
+        Inst::new(
+            "stack_switch",
+            r#"
+        Suspends execution of the current stack and resumes execution of another
+        one.
+
+        The target stack to switch to is identified by the data stored at
+        ``load_context_ptr``. Before switching, this instruction stores
+        analogous information about the
+        current (i.e., original) stack at ``store_context_ptr``, to
+        enabled switching back to the original stack at a later point.
+
+        The size, alignment and layout of the information stored at
+        ``load_context_ptr`` and ``store_context_ptr`` is platform-dependent.
+        The instruction assumes that ``load_context_ptr`` and
+        ``store_context_ptr`` are valid pointers to memory with said layout and
+        alignment, and does not perform any checks on these pointers or the data
+        stored there.
+
+        The instruction is experimental and only supported on x64 Linux at the
+        moment.
+
+        When switching from a stack A to a stack B, one of the following cases
+        must apply:
+        1. Stack B was previously suspended using a ``stack_switch`` instruction.
+        2. Stack B is a newly initialized stack. The necessary initialization is
+        platform-dependent and will generally involve running some kind of
+        trampoline to start execution of a function on the new stack.
+
+        In both cases, the ``in_payload`` argument of the ``stack_switch``
+        instruction executed on A is passed to stack B. In the first case above,
+        it will be the result value of the earlier ``stack_switch`` instruction
+        executed on stack B. In the second case, the value will be accessible to
+        the trampoline in a platform-dependent register.
+
+        The pointers ``load_context_ptr`` and ``store_context_ptr`` are allowed
+        to be equal; the instruction ensures that all data is loaded from the
+        former before writing to the latter.
+
+        Stack switching is one-shot in the sense that each ``stack_switch``
+        operation effectively consumes the context identified by
+        ``load_context_ptr``. In other words, performing two ``stack_switches``
+        using the same ``load_context_ptr`` causes undefined behavior, unless
+        the context at ``load_context_ptr`` is overwritten by another
+        `stack_switch` in between.
+        "#,
+            &formats.ternary,
+        )
+        .operands_in(vec![
+            Operand::new("store_context_ptr", iAddr),
+            Operand::new("load_context_ptr", iAddr),
+            Operand::new("in_payload0", iAddr),
+        ])
+        .operands_out(vec![Operand::new("out_payload0", iAddr)])
+        .other_side_effects()
+        .can_load()
+        .can_store()
+        .call(),
+    );
 
     let I16x8 = &TypeVar::new(
         "I16x8",
@@ -1299,52 +1322,36 @@ pub(crate) fn define(
         .operands_out(vec![Operand::new("addr", iAddr)]),
     );
 
-    let TableOffset = &TypeVar::new(
-        "TableOffset",
-        "An unsigned table offset",
-        TypeSetBuilder::new().ints(32..64).build(),
-    );
-
     ig.push(
         Inst::new(
-            "table_addr",
+            "iconst",
             r#"
-        Bounds check and compute absolute address of a table entry.
-
-        Verify that the offset ``p`` is in bounds for the table T, and generate
-        an absolute address that is safe to dereference.
-
-        ``Offset`` must be less than the size of a table element.
+        Integer constant.
 
-        1. If ``p`` is not greater than the table bound, return an absolute
-           address corresponding to a byte offset of ``p`` from the table's
-           base address.
-        2. If ``p`` is greater than the table bound, generate a trap.
+        Create a scalar integer SSA value with an immediate constant value, or
+        an integer vector where all the lanes have the same value.
         "#,
-            &formats.table_addr,
+            &formats.unary_imm,
         )
-        .operands_in(vec![
-            Operand::new("T", &entities.table),
-            Operand::new("p", TableOffset),
-            Operand::new("Offset", &imm.offset32).with_doc("Byte offset from element address"),
-        ])
-        .operands_out(vec![Operand::new("addr", iAddr)]),
+        .operands_in(vec![Operand::new("N", &imm.imm64)])
+        .operands_out(vec![
+            Operand::new("a", NarrowInt).with_doc("A constant integer scalar or vector value")
+        ]),
     );
 
     ig.push(
         Inst::new(
-            "iconst",
+            "f16const",
             r#"
-        Integer constant.
+        Floating point constant.
 
-        Create a scalar integer SSA value with an immediate constant value, or
-        an integer vector where all the lanes have the same value.
+        Create a `f16` SSA value with an immediate constant value.
         "#,
-            &formats.unary_imm,
+            &formats.unary_ieee16,
         )
-        .operands_in(vec![Operand::new("N", &imm.imm64)])
+        .operands_in(vec![Operand::new("N", &imm.ieee16)])
         .operands_out(vec![
-            Operand::new("a", NarrowInt).with_doc("A constant integer scalar or vector value")
+            Operand::new("a", f16_).with_doc("A constant f16 scalar value")
         ]),
     );
 
@@ -1380,6 +1387,22 @@ pub(crate) fn define(
         ]),
     );
 
+    ig.push(
+        Inst::new(
+            "f128const",
+            r#"
+        Floating point constant.
+
+        Create a `f128` SSA value with an immediate constant value.
+        "#,
+            &formats.unary_const,
+        )
+        .operands_in(vec![Operand::new("N", &imm.pool_constant)])
+        .operands_out(vec![
+            Operand::new("a", f128_).with_doc("A constant f128 scalar value")
+        ]),
+    );
+
     ig.push(
         Inst::new(
             "vconst",
@@ -1430,21 +1453,6 @@ pub(crate) fn define(
         .operands_out(vec![Operand::new("a", Tx16).with_doc("A vector value")]),
     );
 
-    ig.push(
-        Inst::new(
-            "null",
-            r#"
-        Null constant value for reference types.
-
-        Create a scalar reference SSA value with a constant null value.
-        "#,
-            &formats.nullary,
-        )
-        .operands_out(vec![
-            Operand::new("a", Ref).with_doc("A constant reference null value")
-        ]),
-    );
-
     ig.push(Inst::new(
         "nop",
         r#"
@@ -1481,19 +1489,36 @@ pub(crate) fn define(
             Conditional select intended for Spectre guards.
 
             This operation is semantically equivalent to a select instruction.
-            However, it is guaranteed to not be removed or otherwise altered by any
-            optimization pass, and is guaranteed to result in a conditional-move
-            instruction, not a branch-based lowering.  As such, it is suitable
-            for use when producing Spectre guards. For example, a bounds-check
-            may guard against unsafe speculation past a bounds-check conditional
-            branch by passing the address or index to be accessed through a
-            conditional move, also gated on the same condition. Because no
-            Spectre-vulnerable processors are known to perform speculation on
-            conditional move instructions, this is guaranteed to pick the
-            correct input. If the selected input in case of overflow is a "safe"
-            value, for example a null pointer that causes an exception in the
-            speculative path, this ensures that no Spectre vulnerability will
-            exist.
+            However, this instruction prohibits all speculation on the
+            controlling value when determining which input to use as the result.
+            As such, it is suitable for use in Spectre guards.
+
+            For example, on a target which may speculatively execute branches,
+            the lowering of this instruction is guaranteed to not conditionally
+            branch. Instead it will typically lower to a conditional move
+            instruction. (No Spectre-vulnerable processors are known to perform
+            value speculation on conditional move instructions.)
+
+            Ensure that the instruction you're trying to protect from Spectre
+            attacks has a data dependency on the result of this instruction.
+            That prevents an out-of-order CPU from evaluating that instruction
+            until the result of this one is known, which in turn will be blocked
+            until the controlling value is known.
+
+            Typical usage is to use a bounds-check as the controlling value,
+            and select between either a null pointer if the bounds-check
+            fails, or an in-bounds address otherwise, so that dereferencing
+            the resulting address with a load or store instruction will trap if
+            the bounds-check failed. When this instruction is used in this way,
+            any microarchitectural side effects of the memory access will only
+            occur after the bounds-check finishes, which ensures that no Spectre
+            vulnerability will exist.
+
+            Optimization opportunities for this instruction are limited compared
+            to a normal select instruction, but it is allowed to be replaced
+            by other values which are functionally equivalent as long as doing
+            so does not introduce any new opportunities to speculate on the
+            controlling value.
             "#,
             &formats.ternary,
         )
@@ -1502,11 +1527,7 @@ pub(crate) fn define(
             Operand::new("x", Any).with_doc("Value to use when `c` is true"),
             Operand::new("y", Any).with_doc("Value to use when `c` is false"),
         ])
-        .operands_out(vec![Operand::new("a", Any)])
-        .other_side_effects()
-        // We can de-duplicate spectre selects since the side effect is
-        // idempotent.
-        .side_effects_idempotent(),
+        .operands_out(vec![Operand::new("a", Any)]),
     );
 
     ig.push(
@@ -3006,36 +3027,6 @@ pub(crate) fn define(
         ]),
     );
 
-    ig.push(
-        Inst::new(
-            "is_null",
-            r#"
-        Reference verification.
-
-        The condition code determines if the reference type in question is
-        null or not.
-        "#,
-            &formats.unary,
-        )
-        .operands_in(vec![Operand::new("x", Ref)])
-        .operands_out(vec![Operand::new("a", i8)]),
-    );
-
-    ig.push(
-        Inst::new(
-            "is_invalid",
-            r#"
-        Reference verification.
-
-        The condition code determines if the reference type in question is
-        invalid or not.
-        "#,
-            &formats.unary,
-        )
-        .operands_in(vec![Operand::new("x", Ref)])
-        .operands_out(vec![Operand::new("a", i8)]),
-    );
-
     ig.push(
         Inst::new(
             "bitcast",
diff --git a/cranelift/codegen/meta/src/shared/mod.rs b/cranelift/codegen/meta/src/shared/mod.rs
index 4c1f7763071d..77b248ec55f9 100644
--- a/cranelift/codegen/meta/src/shared/mod.rs
+++ b/cranelift/codegen/meta/src/shared/mod.rs
@@ -16,7 +16,6 @@ use crate::shared::formats::Formats;
 use crate::shared::immediates::Immediates;
 
 use std::collections::HashMap;
-use std::iter::FromIterator;
 use std::rc::Rc;
 
 pub(crate) struct Definitions {
@@ -44,9 +43,9 @@ pub(crate) fn define() -> Definitions {
 /// Verifies certain properties of formats.
 ///
 /// - Formats must be uniquely named: if two formats have the same name, they must refer to the
-/// same data. Otherwise, two format variants in the codegen crate would have the same name.
+///   same data. Otherwise, two format variants in the codegen crate would have the same name.
 /// - Formats must be structurally different from each other. Otherwise, this would lead to
-/// code duplicate in the codegen crate.
+///   code duplicate in the codegen crate.
 ///
 /// Returns a list of all the instruction formats effectively used.
 fn verify_instruction_formats(all_instructions: &AllInstructions) -> Vec<Rc<InstructionFormat>> {
diff --git a/cranelift/codegen/meta/src/shared/settings.rs b/cranelift/codegen/meta/src/shared/settings.rs
index e4e511b5e8cb..b6aa2c02d2ab 100644
--- a/cranelift/codegen/meta/src/shared/settings.rs
+++ b/cranelift/codegen/meta/src/shared/settings.rs
@@ -63,6 +63,20 @@ pub(crate) fn define() -> SettingGroup {
         true,
     );
 
+    settings.add_bool(
+        "enable_pcc",
+        "Enable proof-carrying code translation validation.",
+        r#"
+            This adds a proof-carrying-code mode. Proof-carrying code (PCC) is a strategy to verify
+            that the compiler preserves certain properties or invariants in the compiled code.
+            For example, a frontend that translates WebAssembly to CLIF can embed PCC facts in
+            the CLIF, and Cranelift will verify that the final machine code satisfies the stated
+            facts at each intermediate computed value. Loads and stores can be marked as "checked"
+            and their memory effects can be verified as safe.
+        "#,
+        false,
+    );
+
     // Note that Cranelift doesn't currently need an is_pie flag, because PIE is
     // just PIC where symbols can't be pre-empted, which can be expressed with the
     // `colocated` flag on external functions and global values.
@@ -140,6 +154,19 @@ pub(crate) fn define() -> SettingGroup {
         vec!["none", "elf_gd", "macho", "coff"],
     );
 
+    settings.add_enum(
+        "stack_switch_model",
+        "Defines the model used to performing stack switching.",
+        r#"
+           This determines the compilation of `stack_switch` instructions. If
+           set to `basic`, we simply save all registers, update stack pointer
+           and frame pointer (if needed), and jump to the target IP.
+           If set to `update_windows_tib`, we *additionally* update information
+           about the active stack in Windows' Thread Information Block.
+        "#,
+        vec!["none", "basic", "update_windows_tib"],
+    );
+
     settings.add_enum(
         "libcall_call_conv",
         "Defines the calling convention to use for LibCalls call expansion.",
@@ -230,13 +257,6 @@ pub(crate) fn define() -> SettingGroup {
         false,
     );
 
-    settings.add_bool(
-        "probestack_func_adjusts_sp",
-        "Enable if the stack probe adjusts the stack pointer.",
-        "",
-        false,
-    );
-
     settings.add_num(
         "probestack_size_log2",
         "The log2 of the size of the stack guard region.",
diff --git a/cranelift/codegen/meta/src/shared/types.rs b/cranelift/codegen/meta/src/shared/types.rs
index 33efd108014b..d09abe179dde 100644
--- a/cranelift/codegen/meta/src/shared/types.rs
+++ b/cranelift/codegen/meta/src/shared/types.rs
@@ -43,8 +43,10 @@ impl Iterator for IntIterator {
 
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
 pub(crate) enum Float {
+    F16 = 16,
     F32 = 32,
     F64 = 64,
+    F128 = 128,
 }
 
 /// Iterator through the variants of the Float enum.
@@ -63,40 +65,10 @@ impl Iterator for FloatIterator {
     type Item = Float;
     fn next(&mut self) -> Option<Self::Item> {
         let res = match self.index {
-            0 => Some(Float::F32),
-            1 => Some(Float::F64),
-            _ => return None,
-        };
-        self.index += 1;
-        res
-    }
-}
-
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
-pub(crate) enum Reference {
-    /// 32-bit reference.
-    R32 = 32,
-    /// 64-bit reference.
-    R64 = 64,
-}
-
-/// This provides an iterator through all of the supported reference variants.
-pub(crate) struct ReferenceIterator {
-    index: u8,
-}
-
-impl ReferenceIterator {
-    pub fn new() -> Self {
-        Self { index: 0 }
-    }
-}
-
-impl Iterator for ReferenceIterator {
-    type Item = Reference;
-    fn next(&mut self) -> Option<Self::Item> {
-        let res = match self.index {
-            0 => Some(Reference::R32),
-            1 => Some(Reference::R64),
+            0 => Some(Float::F16),
+            1 => Some(Float::F32),
+            2 => Some(Float::F64),
+            3 => Some(Float::F128),
             _ => return None,
         };
         self.index += 1;
@@ -122,16 +94,10 @@ mod iter_tests {
     #[test]
     fn float_iter_works() {
         let mut float_iter = FloatIterator::new();
+        assert_eq!(float_iter.next(), Some(Float::F16));
         assert_eq!(float_iter.next(), Some(Float::F32));
         assert_eq!(float_iter.next(), Some(Float::F64));
+        assert_eq!(float_iter.next(), Some(Float::F128));
         assert_eq!(float_iter.next(), None);
     }
-
-    #[test]
-    fn reference_iter_works() {
-        let mut reference_iter = ReferenceIterator::new();
-        assert_eq!(reference_iter.next(), Some(Reference::R32));
-        assert_eq!(reference_iter.next(), Some(Reference::R64));
-        assert_eq!(reference_iter.next(), None);
-    }
 }
diff --git a/cranelift/codegen/meta/src/srcgen.rs b/cranelift/codegen/meta/src/srcgen.rs
index b1be70240746..d3c321e5bc51 100644
--- a/cranelift/codegen/meta/src/srcgen.rs
+++ b/cranelift/codegen/meta/src/srcgen.rs
@@ -9,7 +9,6 @@ use std::cmp;
 use std::collections::{BTreeMap, BTreeSet};
 use std::fs;
 use std::io::Write;
-use std::path;
 
 use crate::error;
 
@@ -91,15 +90,10 @@ impl Formatter {
     /// Write `self.lines` to a file.
     pub fn update_file(
         &self,
-        filename: impl AsRef<str>,
-        directory: &str,
+        filename: impl AsRef<std::path::Path>,
+        directory: &std::path::Path,
     ) -> Result<(), error::Error> {
-        #[cfg(target_family = "windows")]
-        let path_str = format!("{}\\{}", directory, filename.as_ref());
-        #[cfg(not(target_family = "windows"))]
-        let path_str = format!("{}/{}", directory, filename.as_ref());
-
-        let path = path::Path::new(&path_str);
+        let path = directory.join(&filename);
         eprintln!("Writing generated file: {}", path.display());
         let mut f = fs::File::create(path)?;
 
@@ -128,7 +122,7 @@ impl Formatter {
                 if l.is_empty() {
                     "///".into()
                 } else {
-                    format!("/// {}", l)
+                    format!("/// {l}")
                 }
             })
             .for_each(|s| self.line(s.as_str()));
@@ -314,7 +308,7 @@ mod srcgen_tests {
             .trim()
             .split("\n")
             .into_iter()
-            .map(|x| format!("{}\n", x))
+            .map(|x| format!("{x}\n"))
             .collect()
     }
 
diff --git a/cranelift/codegen/shared/Cargo.toml b/cranelift/codegen/shared/Cargo.toml
index 3575420fa117..7628ba46abb1 100644
--- a/cranelift/codegen/shared/Cargo.toml
+++ b/cranelift/codegen/shared/Cargo.toml
@@ -1,12 +1,13 @@
 [package]
 authors = ["The Cranelift Project Developers"]
 name = "cranelift-codegen-shared"
-version = "0.101.0"
+version = "0.112.0"
 description = "For code shared between cranelift-codegen-meta and cranelift-codegen"
 license = "Apache-2.0 WITH LLVM-exception"
 repository = "https://github.com/bytecodealliance/wasmtime"
 readme = "README.md"
 edition.workspace = true
+rust-version.workspace = true
 
 [dependencies]
 # Since this is a shared dependency of several packages, please strive to keep this dependency-free
diff --git a/cranelift/codegen/shared/src/constants.rs b/cranelift/codegen/shared/src/constants.rs
index d9aa3916ca7f..4fa5897dca96 100644
--- a/cranelift/codegen/shared/src/constants.rs
+++ b/cranelift/codegen/shared/src/constants.rs
@@ -13,7 +13,7 @@
 // Vector types are encoded with the lane type in the low 4 bits and log2(lanes)
 // in the next highest 4 bits, giving a range of 2-256 lanes.
 
-// Dynamic vector types are encoded similarily.
+// Dynamic vector types are encoded similarly.
 
 /// Start of the lane types.
 pub const LANE_BASE: u16 = 0x70;
diff --git a/cranelift/codegen/shared/src/lib.rs b/cranelift/codegen/shared/src/lib.rs
index 76504f77f136..2a03a8323439 100644
--- a/cranelift/codegen/shared/src/lib.rs
+++ b/cranelift/codegen/shared/src/lib.rs
@@ -1,9 +1,7 @@
 //! This library contains code that is common to both the `cranelift-codegen` and
 //! `cranelift-codegen-meta` libraries.
 
-#![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)]
-#![warn(unused_import_braces)]
-#![cfg_attr(feature = "std", deny(unstable_features))]
+#![deny(missing_docs)]
 
 pub mod constant_hash;
 pub mod constants;
diff --git a/cranelift/codegen/src/alias_analysis.rs b/cranelift/codegen/src/alias_analysis.rs
index f3b6339f9938..6a6e9f2748ba 100644
--- a/cranelift/codegen/src/alias_analysis.rs
+++ b/cranelift/codegen/src/alias_analysis.rs
@@ -64,14 +64,14 @@
 use crate::{
     cursor::{Cursor, FuncCursor},
     dominator_tree::DominatorTree,
-    fx::{FxHashMap, FxHashSet},
     inst_predicates::{
         has_memory_fence_semantics, inst_addr_offset_type, inst_store_data, visit_block_succs,
     },
-    ir::{immediates::Offset32, Block, Function, Inst, Opcode, Type, Value},
+    ir::{immediates::Offset32, AliasRegion, Block, Function, Inst, Opcode, Type, Value},
     trace,
 };
 use cranelift_entity::{packed_option::PackedOption, EntityRef};
+use rustc_hash::{FxHashMap, FxHashSet};
 
 /// For a given program point, the vector of last-store instruction
 /// indices for each disjoint category of abstract state.
@@ -93,14 +93,11 @@ impl LastStores {
             self.other = inst.into();
         } else if opcode.can_store() {
             if let Some(memflags) = func.dfg.insts[inst].memflags() {
-                if memflags.heap() {
-                    self.heap = inst.into();
-                } else if memflags.table() {
-                    self.table = inst.into();
-                } else if memflags.vmctx() {
-                    self.vmctx = inst.into();
-                } else {
-                    self.other = inst.into();
+                match memflags.alias_region() {
+                    None => self.other = inst.into(),
+                    Some(AliasRegion::Heap) => self.heap = inst.into(),
+                    Some(AliasRegion::Table) => self.table = inst.into(),
+                    Some(AliasRegion::Vmctx) => self.vmctx = inst.into(),
                 }
             } else {
                 self.heap = inst.into();
@@ -113,14 +110,11 @@ impl LastStores {
 
     fn get_last_store(&self, func: &Function, inst: Inst) -> PackedOption<Inst> {
         if let Some(memflags) = func.dfg.insts[inst].memflags() {
-            if memflags.heap() {
-                self.heap
-            } else if memflags.table() {
-                self.table
-            } else if memflags.vmctx() {
-                self.vmctx
-            } else {
-                self.other
+            match memflags.alias_region() {
+                None => self.other,
+                Some(AliasRegion::Heap) => self.heap,
+                Some(AliasRegion::Table) => self.table,
+                Some(AliasRegion::Vmctx) => self.vmctx,
             }
         } else if func.dfg.insts[inst].opcode().can_load()
             || func.dfg.insts[inst].opcode().can_store()
@@ -218,11 +212,10 @@ impl<'a> AliasAnalysis<'a> {
 
         while let Some(block) = queue.pop() {
             queue_set.remove(&block);
-            let mut state = self
+            let mut state = *self
                 .block_input
                 .entry(block)
-                .or_insert_with(|| LastStores::default())
-                .clone();
+                .or_insert_with(|| LastStores::default());
 
             trace!(
                 "alias analysis: input to block{} is {:?}",
@@ -239,12 +232,12 @@ impl<'a> AliasAnalysis<'a> {
                 let succ_first_inst = func.layout.block_insts(succ).into_iter().next().unwrap();
                 let updated = match self.block_input.get_mut(&succ) {
                     Some(succ_state) => {
-                        let old = succ_state.clone();
+                        let old = *succ_state;
                         succ_state.meet_from(&state, succ_first_inst);
                         *succ_state != old
                     }
                     None => {
-                        self.block_input.insert(succ, state.clone());
+                        self.block_input.insert(succ, state);
                         true
                     }
                 };
@@ -391,7 +384,7 @@ impl<'a> AliasAnalysis<'a> {
             while let Some(inst) = pos.next_inst() {
                 if let Some(replaced_result) = self.process_inst(pos.func, &mut state, inst) {
                     let result = pos.func.dfg.inst_results(inst)[0];
-                    pos.func.dfg.detach_results(inst);
+                    pos.func.dfg.clear_results(inst);
                     pos.func.dfg.change_to_alias(result, replaced_result);
                     pos.remove_inst_and_step_back();
                 }
diff --git a/cranelift/codegen/src/binemit/mod.rs b/cranelift/codegen/src/binemit/mod.rs
index d5582d87f3be..edd4d7d7c904 100644
--- a/cranelift/codegen/src/binemit/mod.rs
+++ b/cranelift/codegen/src/binemit/mod.rs
@@ -3,9 +3,6 @@
 //! The `binemit` module contains code for translating Cranelift's intermediate representation into
 //! binary machine code.
 
-mod stack_map;
-
-pub use self::stack_map::StackMap;
 use core::fmt;
 #[cfg(feature = "enable-serde")]
 use serde_derive::{Deserialize, Serialize};
@@ -64,18 +61,24 @@ pub enum Reloc {
     /// Offset within page of TLVP slot.
     MachOAarch64TlsAdrPageOff12,
 
-    /// Aarch64 TLS GD
-    /// Set an ADRP immediate field to the top 21 bits of the final address. Checks for overflow.
-    /// This is equivalent to `R_AARCH64_TLSGD_ADR_PAGE21` in the [aaelf64](https://github.com/ARM-software/abi-aa/blob/2bcab1e3b22d55170c563c3c7940134089176746/aaelf64/aaelf64.rst#relocations-for-thread-local-storage)
-    Aarch64TlsGdAdrPage21,
+    /// Aarch64 TLSDESC Adr Page21
+    /// This is equivalent to `R_AARCH64_TLSDESC_ADR_PAGE21` in the [aaelf64](https://github.com/ARM-software/abi-aa/blob/2bcab1e3b22d55170c563c3c7940134089176746/aaelf64/aaelf64.rst#57105thread-local-storage-descriptors)
+    Aarch64TlsDescAdrPage21,
+
+    /// Aarch64 TLSDESC Ld64 Lo12
+    /// This is equivalent to `R_AARCH64_TLSDESC_LD64_LO12` in the [aaelf64](https://github.com/ARM-software/abi-aa/blob/2bcab1e3b22d55170c563c3c7940134089176746/aaelf64/aaelf64.rst#57105thread-local-storage-descriptors)
+    Aarch64TlsDescLd64Lo12,
 
-    /// Aarch64 TLS GD
-    /// Set the add immediate field to the low 12 bits of the final address. Does not check for overflow.
-    /// This is equivalent to `R_AARCH64_TLSGD_ADD_LO12_NC` in the [aaelf64](https://github.com/ARM-software/abi-aa/blob/2bcab1e3b22d55170c563c3c7940134089176746/aaelf64/aaelf64.rst#relocations-for-thread-local-storage)
-    Aarch64TlsGdAddLo12Nc,
+    /// Aarch64 TLSDESC Add Lo12
+    /// This is equivalent to `R_AARCH64_TLSGD_ADD_LO12` in the [aaelf64](https://github.com/ARM-software/abi-aa/blob/2bcab1e3b22d55170c563c3c7940134089176746/aaelf64/aaelf64.rst#57105thread-local-storage-descriptors)
+    Aarch64TlsDescAddLo12,
+
+    /// Aarch64 TLSDESC Call
+    /// This is equivalent to `R_AARCH64_TLSDESC_CALL` in the [aaelf64](https://github.com/ARM-software/abi-aa/blob/2bcab1e3b22d55170c563c3c7940134089176746/aaelf64/aaelf64.rst#57105thread-local-storage-descriptors)
+    Aarch64TlsDescCall,
 
     /// AArch64 GOT Page
-    /// Set the immediate value of an ADRP to bits 32:12 of X; check that –232 <= X < 232
+    /// Set the immediate value of an ADRP to bits 32:12 of X; check that –2^32 <= X < 2^32
     /// This is equivalent to `R_AARCH64_ADR_GOT_PAGE` (311) in the  [aaelf64](https://github.com/ARM-software/abi-aa/blob/2bcab1e3b22d55170c563c3c7940134089176746/aaelf64/aaelf64.rst#static-aarch64-relocations)
     Aarch64AdrGotPage21,
 
@@ -85,25 +88,33 @@ pub enum Reloc {
     /// This is equivalent to `R_AARCH64_LD64_GOT_LO12_NC` (312) in the  [aaelf64](https://github.com/ARM-software/abi-aa/blob/2bcab1e3b22d55170c563c3c7940134089176746/aaelf64/aaelf64.rst#static-aarch64-relocations)
     Aarch64Ld64GotLo12Nc,
 
-    /// procedure call.
-    /// call symbol
-    /// expands to the following assembly and relocation:
-    /// auipc ra, 0
-    /// jalr ra, ra, 0
-    RiscvCall,
+    /// RISC-V Call PLT: 32-bit PC-relative function call, macros call, tail (PIC)
+    ///
+    /// Despite having PLT in the name, this relocation is also used for normal calls.
+    /// The non-PLT version of this relocation has been deprecated.
+    ///
+    /// This is the `R_RISCV_CALL_PLT` relocation from the RISC-V ELF psABI document.
+    /// <https://github.com/riscv-non-isa/riscv-elf-psabi-doc/blob/master/riscv-elf.adoc#procedure-calls>
+    RiscvCallPlt,
 
     /// RISC-V TLS GD: High 20 bits of 32-bit PC-relative TLS GD GOT reference,
     ///
     /// This is the `R_RISCV_TLS_GD_HI20` relocation from the RISC-V ELF psABI document.
-    /// https://github.com/riscv-non-isa/riscv-elf-psabi-doc/blob/master/riscv-elf.adoc#global-dynamic
+    /// <https://github.com/riscv-non-isa/riscv-elf-psabi-doc/blob/master/riscv-elf.adoc#global-dynamic>
     RiscvTlsGdHi20,
 
     /// Low 12 bits of a 32-bit PC-relative relocation (I-Type instruction)
     ///
     /// This is the `R_RISCV_PCREL_LO12_I` relocation from the RISC-V ELF psABI document.
-    /// https://github.com/riscv-non-isa/riscv-elf-psabi-doc/blob/master/riscv-elf.adoc#pc-relative-symbol-addresses
+    /// <https://github.com/riscv-non-isa/riscv-elf-psabi-doc/blob/master/riscv-elf.adoc#pc-relative-symbol-addresses>
     RiscvPCRelLo12I,
 
+    /// High 20 bits of a 32-bit PC-relative GOT offset relocation
+    ///
+    /// This is the `R_RISCV_GOT_HI20` relocation from the RISC-V ELF psABI document.
+    /// <https://github.com/riscv-non-isa/riscv-elf-psabi-doc/blob/master/riscv-elf.adoc#pc-relative-symbol-addresses>
+    RiscvGotHi20,
+
     /// s390x TLS GD64 - 64-bit offset of tls_index for GD symbol in GOT
     S390xTlsGd64,
     /// s390x TLS GDCall - marker to enable optimization of TLS calls
@@ -125,15 +136,18 @@ impl fmt::Display for Reloc {
             Self::X86GOTPCRel4 => write!(f, "GOTPCRel4"),
             Self::X86SecRel => write!(f, "SecRel"),
             Self::Arm32Call | Self::Arm64Call => write!(f, "Call"),
-            Self::RiscvCall => write!(f, "RiscvCall"),
+            Self::RiscvCallPlt => write!(f, "RiscvCallPlt"),
             Self::RiscvTlsGdHi20 => write!(f, "RiscvTlsGdHi20"),
+            Self::RiscvGotHi20 => write!(f, "RiscvGotHi20"),
             Self::RiscvPCRelLo12I => write!(f, "RiscvPCRelLo12I"),
             Self::ElfX86_64TlsGd => write!(f, "ElfX86_64TlsGd"),
             Self::MachOX86_64Tlv => write!(f, "MachOX86_64Tlv"),
             Self::MachOAarch64TlsAdrPage21 => write!(f, "MachOAarch64TlsAdrPage21"),
             Self::MachOAarch64TlsAdrPageOff12 => write!(f, "MachOAarch64TlsAdrPageOff12"),
-            Self::Aarch64TlsGdAdrPage21 => write!(f, "Aarch64TlsGdAdrPage21"),
-            Self::Aarch64TlsGdAddLo12Nc => write!(f, "Aarch64TlsGdAddLo12Nc"),
+            Self::Aarch64TlsDescAdrPage21 => write!(f, "Aarch64TlsDescAdrPage21"),
+            Self::Aarch64TlsDescLd64Lo12 => write!(f, "Aarch64TlsDescLd64Lo12"),
+            Self::Aarch64TlsDescAddLo12 => write!(f, "Aarch64TlsDescAddLo12"),
+            Self::Aarch64TlsDescCall => write!(f, "Aarch64TlsDescCall"),
             Self::Aarch64AdrGotPage21 => write!(f, "Aarch64AdrGotPage21"),
             Self::Aarch64Ld64GotLo12Nc => write!(f, "Aarch64AdrGotLo12Nc"),
             Self::S390xTlsGd64 => write!(f, "TlsGd64"),
diff --git a/cranelift/codegen/src/binemit/stack_map.rs b/cranelift/codegen/src/binemit/stack_map.rs
deleted file mode 100644
index 037611e6ea9f..000000000000
--- a/cranelift/codegen/src/binemit/stack_map.rs
+++ /dev/null
@@ -1,155 +0,0 @@
-use crate::bitset::BitSet;
-use alloc::vec::Vec;
-
-type Num = u32;
-const NUM_BITS: usize = core::mem::size_of::<Num>() * 8;
-
-/// Stack maps record which words in a stack frame contain live GC references at
-/// a given instruction pointer.
-///
-/// Logically, a set of stack maps for a function record a table of the form:
-///
-/// ```text
-/// +---------------------+-------------------------------------------+
-/// | Instruction Pointer | SP-Relative Offsets of Live GC References |
-/// +---------------------+-------------------------------------------+
-/// | 0x12345678          | 2, 6, 12                                  |
-/// | 0x1234abcd          | 2, 6                                      |
-/// | ...                 | ...                                       |
-/// +---------------------+-------------------------------------------+
-/// ```
-///
-/// Where "instruction pointer" is an instruction pointer within the function,
-/// and "offsets of live GC references" contains the offsets (in units of words)
-/// from the frame's stack pointer where live GC references are stored on the
-/// stack. Instruction pointers within the function that do not have an entry in
-/// this table are not GC safepoints.
-///
-/// Because
-///
-/// * offsets of live GC references are relative from the stack pointer, and
-/// * stack frames grow down from higher addresses to lower addresses,
-///
-/// to get a pointer to a live reference at offset `x` within a stack frame, you
-/// add `x` from the frame's stack pointer.
-///
-/// For example, to calculate the pointer to the live GC reference inside "frame
-/// 1" below, you would do `frame_1_sp + x`:
-///
-/// ```text
-///           Stack
-///         +-------------------+
-///         | Frame 0           |
-///         |                   |
-///    |    |                   |
-///    |    +-------------------+ <--- Frame 0's SP
-///    |    | Frame 1           |
-///  Grows  |                   |
-///  down   |                   |
-///    |    | Live GC reference | --+--
-///    |    |                   |   |
-///    |    |                   |   |
-///    V    |                   |   x = offset of live GC reference
-///         |                   |   |
-///         |                   |   |
-///         +-------------------+ --+--  <--- Frame 1's SP
-///         | Frame 2           |
-///         | ...               |
-/// ```
-///
-/// An individual `StackMap` is associated with just one instruction pointer
-/// within the function, contains the size of the stack frame, and represents
-/// the stack frame as a bitmap. There is one bit per word in the stack frame,
-/// and if the bit is set, then the word contains a live GC reference.
-///
-/// Note that a caller's `OutgoingArg` stack slots and callee's `IncomingArg`
-/// stack slots overlap, so we must choose which function's stack maps record
-/// live GC references in these slots. We record the `IncomingArg`s in the
-/// callee's stack map.
-#[derive(Clone, Debug, PartialEq, Eq)]
-#[cfg_attr(
-    feature = "enable-serde",
-    derive(serde_derive::Deserialize, serde_derive::Serialize)
-)]
-pub struct StackMap {
-    bitmap: Vec<BitSet<Num>>,
-    mapped_words: u32,
-}
-
-impl StackMap {
-    /// Create a vec of Bitsets from a slice of bools.
-    pub fn from_slice(vec: &[bool]) -> Self {
-        let len = vec.len();
-        let num_word = len / NUM_BITS + (len % NUM_BITS != 0) as usize;
-        let mut bitmap = Vec::with_capacity(num_word);
-
-        for segment in vec.chunks(NUM_BITS) {
-            let mut curr_word = 0;
-            for (i, set) in segment.iter().enumerate() {
-                if *set {
-                    curr_word |= 1 << i;
-                }
-            }
-            bitmap.push(BitSet(curr_word));
-        }
-        Self {
-            mapped_words: len as u32,
-            bitmap,
-        }
-    }
-
-    /// Returns a specified bit.
-    pub fn get_bit(&self, bit_index: usize) -> bool {
-        assert!(bit_index < NUM_BITS * self.bitmap.len());
-        let word_index = bit_index / NUM_BITS;
-        let word_offset = bit_index % NUM_BITS;
-        self.bitmap[word_index].contains(word_offset as u32)
-    }
-
-    /// Returns the raw bitmap that represents this stack map.
-    pub fn as_slice(&self) -> &[BitSet<u32>] {
-        &self.bitmap
-    }
-
-    /// Returns the number of words represented by this stack map.
-    pub fn mapped_words(&self) -> u32 {
-        self.mapped_words
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn stack_maps() {
-        let vec: Vec<bool> = Vec::new();
-        assert!(StackMap::from_slice(&vec).bitmap.is_empty());
-
-        let mut vec: [bool; NUM_BITS] = Default::default();
-        let set_true_idx = [5, 7, 24, 31];
-
-        for &idx in &set_true_idx {
-            vec[idx] = true;
-        }
-
-        let mut vec = vec.to_vec();
-        assert_eq!(
-            vec![BitSet::<Num>(2164261024)],
-            StackMap::from_slice(&vec).bitmap
-        );
-
-        vec.push(false);
-        vec.push(true);
-        let res = StackMap::from_slice(&vec);
-        assert_eq!(
-            vec![BitSet::<Num>(2164261024), BitSet::<Num>(2)],
-            res.bitmap
-        );
-
-        assert!(res.get_bit(5));
-        assert!(res.get_bit(31));
-        assert!(res.get_bit(33));
-        assert!(!res.get_bit(1));
-    }
-}
diff --git a/cranelift/codegen/src/bitset.rs b/cranelift/codegen/src/bitset.rs
deleted file mode 100644
index 855d585d7c61..000000000000
--- a/cranelift/codegen/src/bitset.rs
+++ /dev/null
@@ -1,166 +0,0 @@
-//! Small Bitset
-//!
-//! This module defines a struct `BitSet<T>` encapsulating a bitset built over the type T.
-//! T is intended to be a primitive unsigned type. Currently it can be any type between u8 and u32
-//!
-//! If you would like to add support for larger bitsets in the future, you need to change the trait
-//! bound `Into<u32>` and the `u32` in the implementation of `max_bits()`.
-
-use core::convert::{From, Into};
-use core::mem::size_of;
-use core::ops::{Add, BitOr, Shl, Sub};
-
-/// A small bitset built on a single primitive integer type
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
-#[cfg_attr(
-    feature = "enable-serde",
-    derive(serde_derive::Serialize, serde_derive::Deserialize)
-)]
-pub struct BitSet<T>(pub T);
-
-impl<T> BitSet<T>
-where
-    T: Into<u32>
-        + From<u8>
-        + BitOr<T, Output = T>
-        + Shl<u8, Output = T>
-        + Sub<T, Output = T>
-        + Add<T, Output = T>
-        + PartialEq
-        + Copy,
-{
-    /// Maximum number of bits supported by this BitSet instance
-    pub fn bits() -> usize {
-        size_of::<T>() * 8
-    }
-
-    /// Maximum number of bits supported by any bitset instance atm.
-    pub fn max_bits() -> usize {
-        size_of::<u32>() * 8
-    }
-
-    /// Check if this BitSet contains the number num
-    pub fn contains(&self, num: u32) -> bool {
-        debug_assert!((num as usize) < Self::bits());
-        debug_assert!((num as usize) < Self::max_bits());
-        self.0.into() & (1 << num) != 0
-    }
-
-    /// Return the smallest number contained in the bitset or None if empty
-    pub fn min(&self) -> Option<u8> {
-        if self.0.into() == 0 {
-            None
-        } else {
-            Some(self.0.into().trailing_zeros() as u8)
-        }
-    }
-
-    /// Return the largest number contained in the bitset or None if empty
-    pub fn max(&self) -> Option<u8> {
-        if self.0.into() == 0 {
-            None
-        } else {
-            let leading_zeroes = self.0.into().leading_zeros() as usize;
-            Some((Self::max_bits() - leading_zeroes - 1) as u8)
-        }
-    }
-
-    /// Construct a BitSet with the half-open range [lo,hi) filled in
-    pub fn from_range(lo: u8, hi: u8) -> Self {
-        debug_assert!(lo <= hi);
-        debug_assert!((hi as usize) <= Self::bits());
-        let one: T = T::from(1);
-        // I can't just do (one << hi) - one here as the shift may overflow
-        let hi_rng = if hi >= 1 {
-            (one << (hi - 1)) + ((one << (hi - 1)) - one)
-        } else {
-            T::from(0)
-        };
-
-        let lo_rng = (one << lo) - one;
-
-        Self(hi_rng - lo_rng)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn contains() {
-        let s = BitSet::<u8>(255);
-        for i in 0..7 {
-            assert!(s.contains(i));
-        }
-
-        let s1 = BitSet::<u8>(0);
-        for i in 0..7 {
-            assert!(!s1.contains(i));
-        }
-
-        let s2 = BitSet::<u8>(127);
-        for i in 0..6 {
-            assert!(s2.contains(i));
-        }
-        assert!(!s2.contains(7));
-
-        let s3 = BitSet::<u8>(2 | 4 | 64);
-        assert!(!s3.contains(0) && !s3.contains(3) && !s3.contains(4));
-        assert!(!s3.contains(5) && !s3.contains(7));
-        assert!(s3.contains(1) && s3.contains(2) && s3.contains(6));
-
-        let s4 = BitSet::<u16>(4 | 8 | 256 | 1024);
-        assert!(
-            !s4.contains(0)
-                && !s4.contains(1)
-                && !s4.contains(4)
-                && !s4.contains(5)
-                && !s4.contains(6)
-                && !s4.contains(7)
-                && !s4.contains(9)
-                && !s4.contains(11)
-        );
-        assert!(s4.contains(2) && s4.contains(3) && s4.contains(8) && s4.contains(10));
-    }
-
-    #[test]
-    fn minmax() {
-        let s = BitSet::<u8>(255);
-        assert_eq!(s.min(), Some(0));
-        assert_eq!(s.max(), Some(7));
-        assert!(s.min() == Some(0) && s.max() == Some(7));
-        let s1 = BitSet::<u8>(0);
-        assert!(s1.min() == None && s1.max() == None);
-        let s2 = BitSet::<u8>(127);
-        assert!(s2.min() == Some(0) && s2.max() == Some(6));
-        let s3 = BitSet::<u8>(2 | 4 | 64);
-        assert!(s3.min() == Some(1) && s3.max() == Some(6));
-        let s4 = BitSet::<u16>(4 | 8 | 256 | 1024);
-        assert!(s4.min() == Some(2) && s4.max() == Some(10));
-    }
-
-    #[test]
-    fn from_range() {
-        let s = BitSet::<u8>::from_range(5, 5);
-        assert!(s.0 == 0);
-
-        let s = BitSet::<u8>::from_range(0, 8);
-        assert!(s.0 == 255);
-
-        let s = BitSet::<u16>::from_range(0, 8);
-        assert!(s.0 == 255u16);
-
-        let s = BitSet::<u16>::from_range(0, 16);
-        assert!(s.0 == 65535u16);
-
-        let s = BitSet::<u8>::from_range(5, 6);
-        assert!(s.0 == 32u8);
-
-        let s = BitSet::<u8>::from_range(3, 7);
-        assert!(s.0 == 8 | 16 | 32 | 64);
-
-        let s = BitSet::<u16>::from_range(5, 11);
-        assert!(s.0 == 32 | 64 | 128 | 256 | 512 | 1024);
-    }
-}
diff --git a/cranelift/codegen/src/cfg_printer.rs b/cranelift/codegen/src/cfg_printer.rs
index 7b906d19e78c..ef71b63ca712 100644
--- a/cranelift/codegen/src/cfg_printer.rs
+++ b/cranelift/codegen/src/cfg_printer.rs
@@ -35,7 +35,7 @@ impl<'a> CFGPrinter<'a> {
     fn header(&self, w: &mut dyn Write) -> Result {
         writeln!(w, "digraph \"{}\" {{", self.func.name)?;
         if let Some(entry) = self.func.layout.entry_block() {
-            writeln!(w, "    {{rank=min; {}}}", entry)?;
+            writeln!(w, "    {{rank=min; {entry}}}")?;
         }
         Ok(())
     }
@@ -50,11 +50,11 @@ impl<'a> CFGPrinter<'a> {
         }
 
         for block in &self.func.layout {
-            write!(w, "    {} [shape=record, label=\"{{", block)?;
+            write!(w, "    {block} [shape=record, label=\"{{")?;
             crate::write::write_block_header(w, self.func, block, 4)?;
             // Add all outgoing branch instructions to the label.
             if let Some(inst) = self.func.layout.last_inst(block) {
-                write!(w, " | <{}>", inst)?;
+                write!(w, " | <{inst}>")?;
                 PlainWriter.write_instruction(w, self.func, &aliases, inst, 0)?;
             }
             writeln!(w, "}}\"]")?
@@ -69,7 +69,7 @@ impl<'a> CFGPrinter<'a> {
                 inst,
             } in self.cfg.pred_iter(block)
             {
-                writeln!(w, "    {}:{} -> {}", parent, inst, block)?;
+                writeln!(w, "    {parent}:{inst} -> {block}")?;
             }
         }
         Ok(())
diff --git a/cranelift/codegen/src/context.rs b/cranelift/codegen/src/context.rs
index 2dc62ee77fd5..d95e985a4854 100644
--- a/cranelift/codegen/src/context.rs
+++ b/cranelift/codegen/src/context.rs
@@ -10,7 +10,6 @@
 //! single ISA instance.
 
 use crate::alias_analysis::AliasAnalysis;
-use crate::dce::do_dce;
 use crate::dominator_tree::DominatorTree;
 use crate::egraph::EgraphPass;
 use crate::flowgraph::ControlFlowGraph;
@@ -31,6 +30,7 @@ use crate::{timing, CompileError};
 use alloc::string::String;
 use alloc::vec::Vec;
 use cranelift_control::ControlPlane;
+use target_lexicon::Architecture;
 
 #[cfg(feature = "souper-harvest")]
 use crate::souper_harvest::do_souper_harvest;
@@ -96,6 +96,12 @@ impl Context {
         self.compiled_code.as_ref()
     }
 
+    /// Returns the compilation result for this function, available after any `compile` function
+    /// has been called.
+    pub fn take_compiled_code(&mut self) -> Option<CompiledCode> {
+        self.compiled_code.take()
+    }
+
     /// Set the flag to request a disassembly when compiling with a
     /// `MachBackend` backend.
     pub fn set_disasm(&mut self, val: bool) {
@@ -141,7 +147,7 @@ impl Context {
 
         self.verify_if(isa)?;
 
-        self.optimize(isa)?;
+        self.optimize(isa, ctrl_plane)?;
 
         isa.compile_function(&self.func, &self.domtree, self.want_disasm, ctrl_plane)
     }
@@ -151,7 +157,11 @@ impl Context {
     /// allocation.
     ///
     /// Public only for testing purposes.
-    pub fn optimize(&mut self, isa: &dyn TargetIsa) -> CodegenResult<()> {
+    pub fn optimize(
+        &mut self,
+        isa: &dyn TargetIsa,
+        ctrl_plane: &mut ControlPlane,
+    ) -> CodegenResult<()> {
         log::debug!(
             "Number of CLIF instructions to optimize: {}",
             self.func.dfg.num_insts()
@@ -177,15 +187,12 @@ impl Context {
 
         self.compute_domtree();
         self.eliminate_unreachable_code(isa)?;
-
-        if opt_level != OptLevel::None {
-            self.dce(isa)?;
-        }
-
         self.remove_constant_phis(isa)?;
 
+        self.func.dfg.resolve_all_aliases();
+
         if opt_level != OptLevel::None {
-            self.egraph_pass(isa)?;
+            self.egraph_pass(isa, ctrl_plane)?;
         }
 
         Ok(())
@@ -237,6 +244,8 @@ impl Context {
     /// Run the verifier on the function.
     ///
     /// Also check that the dominator tree and control flow graph are consistent with the function.
+    ///
+    /// TODO: rename to "CLIF validate" or similar.
     pub fn verify<'a, FOI: Into<FlagsOrIsa<'a>>>(&self, fisa: FOI) -> VerifierResult<()> {
         let mut errors = VerifierErrors::default();
         let _ = verify_context(&self.func, &self.cfg, &self.domtree, fisa, &mut errors);
@@ -257,13 +266,6 @@ impl Context {
         Ok(())
     }
 
-    /// Perform dead-code elimination on the function.
-    pub fn dce<'a, FOI: Into<FlagsOrIsa<'a>>>(&mut self, fisa: FOI) -> CodegenResult<()> {
-        do_dce(&mut self.func, &mut self.domtree);
-        self.verify_if(fisa)?;
-        Ok(())
-    }
-
     /// Perform constant-phi removal on the function.
     pub fn remove_constant_phis<'a, FOI: Into<FlagsOrIsa<'a>>>(
         &mut self,
@@ -276,7 +278,15 @@ impl Context {
 
     /// Perform NaN canonicalizing rewrites on the function.
     pub fn canonicalize_nans(&mut self, isa: &dyn TargetIsa) -> CodegenResult<()> {
-        do_nan_canonicalization(&mut self.func);
+        // Currently only RiscV64 is the only arch that may not have vector support.
+        let has_vector_support = match isa.triple().architecture {
+            Architecture::Riscv64(_) => match isa.isa_flags().iter().find(|f| f.name == "has_v") {
+                Some(value) => value.as_bool().unwrap_or(false),
+                None => false,
+            },
+            _ => true,
+        };
+        do_nan_canonicalization(&mut self.func, has_vector_support);
         self.verify_if(isa)
     }
 
@@ -345,7 +355,11 @@ impl Context {
     }
 
     /// Run optimizations via the egraph infrastructure.
-    pub fn egraph_pass<'a, FOI>(&mut self, fisa: FOI) -> CodegenResult<()>
+    pub fn egraph_pass<'a, FOI>(
+        &mut self,
+        fisa: FOI,
+        ctrl_plane: &mut ControlPlane,
+    ) -> CodegenResult<()>
     where
         FOI: Into<FlagsOrIsa<'a>>,
     {
@@ -355,6 +369,7 @@ impl Context {
             "About to optimize with egraph phase:\n{}",
             self.func.display()
         );
+        let fisa = fisa.into();
         self.compute_loop_analysis();
         let mut alias_analysis = AliasAnalysis::new(&self.func, &self.domtree);
         let mut pass = EgraphPass::new(
@@ -362,9 +377,12 @@ impl Context {
             &self.domtree,
             &self.loop_analysis,
             &mut alias_analysis,
+            &fisa.flags,
+            ctrl_plane,
         );
         pass.run();
         log::debug!("egraph stats: {:?}", pass.stats);
+        trace!("pinned_union_count: {}", pass.eclasses.pinned_union_count);
         trace!("After egraph optimization:\n{}", self.func.display());
 
         self.verify_if(fisa)
diff --git a/cranelift/codegen/src/ctxhash.rs b/cranelift/codegen/src/ctxhash.rs
index e172d46c127a..74290877bbcf 100644
--- a/cranelift/codegen/src/ctxhash.rs
+++ b/cranelift/codegen/src/ctxhash.rs
@@ -76,7 +76,7 @@ fn compute_hash<Ctx, K>(ctx: &Ctx, k: &K) -> u32
 where
     Ctx: CtxHash<K>,
 {
-    let mut hasher = crate::fx::FxHasher::default();
+    let mut hasher = rustc_hash::FxHasher::default();
     ctx.ctx_hash(&mut hasher, k);
     hasher.finish() as u32
 }
@@ -125,7 +125,6 @@ impl<K, V> CtxHashMap<K, V> {
 #[cfg(test)]
 mod test {
     use super::*;
-    use std::hash::Hash;
 
     #[derive(Clone, Copy, Debug)]
     struct Key {
diff --git a/cranelift/codegen/src/data_value.rs b/cranelift/codegen/src/data_value.rs
index af067b367128..523182f07d9e 100644
--- a/cranelift/codegen/src/data_value.rs
+++ b/cranelift/codegen/src/data_value.rs
@@ -1,8 +1,8 @@
 //! This module gives users to instantiate values that Cranelift understands. These values are used,
 //! for example, during interpretation and for wrapping immediates.
-use crate::ir::immediates::{Ieee32, Ieee64, Offset32};
+use crate::ir::immediates::{Ieee128, Ieee16, Ieee32, Ieee64, Offset32};
 use crate::ir::{types, ConstantData, Type};
-use core::convert::TryInto;
+use core::cmp::Ordering;
 use core::fmt::{self, Display, Formatter};
 
 /// Represent a data value. Where [Value] is an SSA reference, [DataValue] is the type + value
@@ -17,8 +17,10 @@ pub enum DataValue {
     I32(i32),
     I64(i64),
     I128(i128),
+    F16(Ieee16),
     F32(Ieee32),
     F64(Ieee64),
+    F128(Ieee128),
     V128([u8; 16]),
     V64([u8; 8]),
 }
@@ -37,10 +39,14 @@ impl PartialEq for DataValue {
             (I64(_), _) => false,
             (I128(l), I128(r)) => l == r,
             (I128(_), _) => false,
+            (F16(l), F16(r)) => l.partial_cmp(&r) == Some(Ordering::Equal),
+            (F16(_), _) => false,
             (F32(l), F32(r)) => l.as_f32() == r.as_f32(),
             (F32(_), _) => false,
             (F64(l), F64(r)) => l.as_f64() == r.as_f64(),
             (F64(_), _) => false,
+            (F128(l), F128(r)) => l.partial_cmp(&r) == Some(Ordering::Equal),
+            (F128(_), _) => false,
             (V128(l), V128(r)) => l == r,
             (V128(_), _) => false,
             (V64(l), V64(r)) => l == r,
@@ -71,8 +77,10 @@ impl DataValue {
             DataValue::I32(_) => types::I32,
             DataValue::I64(_) => types::I64,
             DataValue::I128(_) => types::I128,
+            DataValue::F16(_) => types::F16,
             DataValue::F32(_) => types::F32,
             DataValue::F64(_) => types::F64,
+            DataValue::F128(_) => types::F128,
             DataValue::V128(_) => types::I8X16, // A default type.
             DataValue::V64(_) => types::I8X8,   // A default type.
         }
@@ -93,8 +101,10 @@ impl DataValue {
             DataValue::I32(i) => DataValue::I32(i.swap_bytes()),
             DataValue::I64(i) => DataValue::I64(i.swap_bytes()),
             DataValue::I128(i) => DataValue::I128(i.swap_bytes()),
+            DataValue::F16(f) => DataValue::F16(Ieee16::with_bits(f.bits().swap_bytes())),
             DataValue::F32(f) => DataValue::F32(Ieee32::with_bits(f.bits().swap_bytes())),
             DataValue::F64(f) => DataValue::F64(Ieee64::with_bits(f.bits().swap_bytes())),
+            DataValue::F128(f) => DataValue::F128(Ieee128::with_bits(f.bits().swap_bytes())),
             DataValue::V128(mut v) => {
                 v.reverse();
                 DataValue::V128(v)
@@ -136,8 +146,10 @@ impl DataValue {
             DataValue::I32(i) => dst[..4].copy_from_slice(&i.to_ne_bytes()[..]),
             DataValue::I64(i) => dst[..8].copy_from_slice(&i.to_ne_bytes()[..]),
             DataValue::I128(i) => dst[..16].copy_from_slice(&i.to_ne_bytes()[..]),
+            DataValue::F16(f) => dst[..2].copy_from_slice(&f.bits().to_ne_bytes()[..]),
             DataValue::F32(f) => dst[..4].copy_from_slice(&f.bits().to_ne_bytes()[..]),
             DataValue::F64(f) => dst[..8].copy_from_slice(&f.bits().to_ne_bytes()[..]),
+            DataValue::F128(f) => dst[..16].copy_from_slice(&f.bits().to_ne_bytes()[..]),
             DataValue::V128(v) => dst[..16].copy_from_slice(&v[..]),
             DataValue::V64(v) => dst[..8].copy_from_slice(&v[..]),
         };
@@ -173,12 +185,18 @@ impl DataValue {
             types::I32 => DataValue::I32(i32::from_ne_bytes(src[..4].try_into().unwrap())),
             types::I64 => DataValue::I64(i64::from_ne_bytes(src[..8].try_into().unwrap())),
             types::I128 => DataValue::I128(i128::from_ne_bytes(src[..16].try_into().unwrap())),
+            types::F16 => DataValue::F16(Ieee16::with_bits(u16::from_ne_bytes(
+                src[..2].try_into().unwrap(),
+            ))),
             types::F32 => DataValue::F32(Ieee32::with_bits(u32::from_ne_bytes(
                 src[..4].try_into().unwrap(),
             ))),
             types::F64 => DataValue::F64(Ieee64::with_bits(u64::from_ne_bytes(
                 src[..8].try_into().unwrap(),
             ))),
+            types::F128 => DataValue::F128(Ieee128::with_bits(u128::from_ne_bytes(
+                src[..16].try_into().unwrap(),
+            ))),
             _ if ty.is_vector() => {
                 if ty.bytes() == 16 {
                     DataValue::V128(src[..16].try_into().unwrap())
@@ -234,8 +252,10 @@ impl DataValue {
             // We need to bit compare the floats to ensure that we produce the correct values
             // on NaN's. The test suite expects to assert the precise bit pattern on NaN's or
             // works around it in the tests themselves.
+            (DataValue::F16(a), DataValue::F16(b)) => a.bits() == b.bits(),
             (DataValue::F32(a), DataValue::F32(b)) => a.bits() == b.bits(),
             (DataValue::F64(a), DataValue::F64(b)) => a.bits() == b.bits(),
+            (DataValue::F128(a), DataValue::F128(b)) => a.bits() == b.bits(),
 
             // We don't need to worry about F32x4 / F64x2 Since we compare V128 which is already the
             // raw bytes anyway
@@ -260,18 +280,10 @@ impl Display for DataValueCastFailure {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         match self {
             DataValueCastFailure::TryInto(from, to) => {
-                write!(
-                    f,
-                    "unable to cast data value of type {} to type {}",
-                    from, to
-                )
+                write!(f, "unable to cast data value of type {from} to type {to}")
             }
             DataValueCastFailure::FromInteger(val, to) => {
-                write!(
-                    f,
-                    "unable to cast i64({}) to a data value of type {}",
-                    val, to
-                )
+                write!(f, "unable to cast i64({val}) to a data value of type {to}")
             }
         }
     }
@@ -306,8 +318,10 @@ build_conversion_impl!(i16, I16, I16);
 build_conversion_impl!(i32, I32, I32);
 build_conversion_impl!(i64, I64, I64);
 build_conversion_impl!(i128, I128, I128);
+build_conversion_impl!(Ieee16, F16, F16);
 build_conversion_impl!(Ieee32, F32, F32);
 build_conversion_impl!(Ieee64, F64, F64);
+build_conversion_impl!(Ieee128, F128, F128);
 build_conversion_impl!([u8; 16], V128, I8X16);
 build_conversion_impl!([u8; 8], V64, I8X8);
 impl From<Offset32> for DataValue {
@@ -319,14 +333,16 @@ impl From<Offset32> for DataValue {
 impl Display for DataValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match self {
-            DataValue::I8(dv) => write!(f, "{}", dv),
-            DataValue::I16(dv) => write!(f, "{}", dv),
-            DataValue::I32(dv) => write!(f, "{}", dv),
-            DataValue::I64(dv) => write!(f, "{}", dv),
-            DataValue::I128(dv) => write!(f, "{}", dv),
+            DataValue::I8(dv) => write!(f, "{dv}"),
+            DataValue::I16(dv) => write!(f, "{dv}"),
+            DataValue::I32(dv) => write!(f, "{dv}"),
+            DataValue::I64(dv) => write!(f, "{dv}"),
+            DataValue::I128(dv) => write!(f, "{dv}"),
             // The Ieee* wrappers here print the expected syntax.
-            DataValue::F32(dv) => write!(f, "{}", dv),
-            DataValue::F64(dv) => write!(f, "{}", dv),
+            DataValue::F16(dv) => write!(f, "{dv}"),
+            DataValue::F32(dv) => write!(f, "{dv}"),
+            DataValue::F64(dv) => write!(f, "{dv}"),
+            DataValue::F128(dv) => write!(f, "{dv}"),
             // Again, for syntax consistency, use ConstantData, which in this case displays as hex.
             DataValue::V128(dv) => write!(f, "{}", ConstantData::from(&dv[..])),
             DataValue::V64(dv) => write!(f, "{}", ConstantData::from(&dv[..])),
@@ -360,7 +376,7 @@ pub fn write_data_value_list(f: &mut Formatter<'_>, list: &[DataValue]) -> fmt::
         _ => {
             write!(f, "{}", list[0])?;
             for dv in list.iter().skip(1) {
-                write!(f, ", {}", dv)?;
+                write!(f, ", {dv}")?;
             }
             Ok(())
         }
diff --git a/cranelift/codegen/src/dbg.rs b/cranelift/codegen/src/dbg.rs
index 1d814ceedb40..4796f3967b91 100644
--- a/cranelift/codegen/src/dbg.rs
+++ b/cranelift/codegen/src/dbg.rs
@@ -17,9 +17,9 @@ where
         match self.0.split_first() {
             None => write!(f, "[]"),
             Some((first, rest)) => {
-                write!(f, "[{}", first)?;
+                write!(f, "[{first}")?;
                 for x in rest {
-                    write!(f, ", {}", x)?;
+                    write!(f, ", {x}")?;
                 }
                 write!(f, "]")
             }
diff --git a/cranelift/codegen/src/dce.rs b/cranelift/codegen/src/dce.rs
deleted file mode 100644
index 2b52f92bcf3a..000000000000
--- a/cranelift/codegen/src/dce.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-//! A Dead-Code Elimination (DCE) pass.
-//!
-//! Dead code here means instructions that have no side effects and have no
-//! result values used by other instructions.
-
-use crate::cursor::{Cursor, FuncCursor};
-use crate::dominator_tree::DominatorTree;
-use crate::entity::EntityRef;
-use crate::inst_predicates::{any_inst_results_used, has_side_effect};
-use crate::ir::Function;
-use crate::timing;
-
-/// Perform DCE on `func`.
-pub fn do_dce(func: &mut Function, domtree: &DominatorTree) {
-    let _tt = timing::dce();
-    debug_assert!(domtree.is_valid());
-
-    let mut live = vec![false; func.dfg.num_values()];
-    for &block in domtree.cfg_postorder() {
-        let mut pos = FuncCursor::new(func).at_bottom(block);
-        while let Some(inst) = pos.prev_inst() {
-            {
-                if has_side_effect(pos.func, inst)
-                    || any_inst_results_used(inst, &live, &pos.func.dfg)
-                {
-                    for arg in pos.func.dfg.inst_values(inst) {
-                        let v = pos.func.dfg.resolve_aliases(arg);
-                        live[v.index()] = true;
-                    }
-
-                    continue;
-                }
-            }
-            pos.remove_inst();
-        }
-    }
-}
diff --git a/cranelift/codegen/src/dominator_tree.rs b/cranelift/codegen/src/dominator_tree.rs
index c549e6ab0874..12288362b48b 100644
--- a/cranelift/codegen/src/dominator_tree.rs
+++ b/cranelift/codegen/src/dominator_tree.rs
@@ -5,6 +5,7 @@ use crate::flowgraph::{BlockPredecessor, ControlFlowGraph};
 use crate::ir::{Block, Function, Inst, Layout, ProgramPoint};
 use crate::packed_option::PackedOption;
 use crate::timing;
+use crate::traversals::Dfs;
 use alloc::vec::Vec;
 use core::cmp;
 use core::cmp::Ordering;
@@ -14,9 +15,6 @@ use core::mem;
 /// room for modifications of the dominator tree.
 const STRIDE: u32 = 4;
 
-/// Special RPO numbers used during `compute_postorder`.
-const SEEN: u32 = 1;
-
 /// Dominator tree node. We keep one of these per block.
 #[derive(Clone, Default)]
 struct DomNode {
@@ -34,12 +32,6 @@ struct DomNode {
     idom: PackedOption<Inst>,
 }
 
-/// DFT stack state marker for computing the cfg postorder.
-enum Visit {
-    First,
-    Last,
-}
-
 /// The dominator tree for a single function.
 pub struct DominatorTree {
     nodes: SecondaryMap<Block, DomNode>,
@@ -47,8 +39,8 @@ pub struct DominatorTree {
     /// CFG post-order of all reachable blocks.
     postorder: Vec<Block>,
 
-    /// Scratch memory used by `compute_postorder()`.
-    stack: Vec<(Visit, Block)>,
+    /// Scratch traversal state used by `compute_postorder()`.
+    dfs: Dfs,
 
     valid: bool,
 }
@@ -225,7 +217,7 @@ impl DominatorTree {
         Self {
             nodes: SecondaryMap::new(),
             postorder: Vec::new(),
-            stack: Vec::new(),
+            dfs: Dfs::new(),
             valid: false,
         }
     }
@@ -236,7 +228,7 @@ impl DominatorTree {
         let mut domtree = Self {
             nodes: SecondaryMap::with_capacity(block_capacity),
             postorder: Vec::with_capacity(block_capacity),
-            stack: Vec::new(),
+            dfs: Dfs::new(),
             valid: false,
         };
         domtree.compute(func, cfg);
@@ -257,7 +249,6 @@ impl DominatorTree {
     pub fn clear(&mut self) {
         self.nodes.clear();
         self.postorder.clear();
-        debug_assert!(self.stack.is_empty());
         self.valid = false;
     }
 
@@ -276,73 +267,7 @@ impl DominatorTree {
     fn compute_postorder(&mut self, func: &Function) {
         self.clear();
         self.nodes.resize(func.dfg.num_blocks());
-
-        // This algorithm is a depth first traversal (DFT) of the control flow graph, computing a
-        // post-order of the blocks that are reachable form the entry block. A DFT post-order is not
-        // unique. The specific order we get is controlled by the order each node's children are
-        // visited.
-        //
-        // We view the CFG as a graph where each `BlockCall` value of a terminating branch
-        // instruction is an edge. A consequence of this is that we visit successor nodes in the
-        // reverse order specified by the branch instruction that terminates the basic block.
-        // (Reversed because we are using a stack to control traversal, and push the successors in
-        // the order the branch instruction specifies -- there's no good reason for this particular
-        // order.)
-        //
-        // During this algorithm only, use `rpo_number` to hold the following state:
-        //
-        //   0:    block has not yet had its first visit
-        //   SEEN: block has been visited at least once, implying that all of its successors are on
-        //         the stack
-
-        match func.layout.entry_block() {
-            Some(block) => {
-                self.stack.push((Visit::First, block));
-            }
-            None => return,
-        }
-
-        while let Some((visit, block)) = self.stack.pop() {
-            match visit {
-                Visit::First => {
-                    if self.nodes[block].rpo_number == 0 {
-                        // This is the first time we pop the block, so we need to scan its
-                        // successors and then revisit it.
-                        self.nodes[block].rpo_number = SEEN;
-                        self.stack.push((Visit::Last, block));
-                        if let Some(inst) = func.stencil.layout.last_inst(block) {
-                            // Heuristic: chase the children in reverse. This puts the first
-                            // successor block first in the postorder, all other things being
-                            // equal, which tends to prioritize loop backedges over out-edges,
-                            // putting the edge-block closer to the loop body and minimizing
-                            // live-ranges in linear instruction space. This heuristic doesn't have
-                            // any effect on the computation of dominators, and is purely for other
-                            // consumers of the postorder we cache here.
-                            for block in func.stencil.dfg.insts[inst]
-                                .branch_destination(&func.stencil.dfg.jump_tables)
-                                .iter()
-                                .rev()
-                            {
-                                let succ = block.block(&func.stencil.dfg.value_lists);
-
-                                // This is purely an optimization to avoid additional iterations of
-                                // the loop, and is not required; it's merely inlining the check
-                                // from the outer conditional of this case to avoid the extra loop
-                                // iteration.
-                                if self.nodes[succ].rpo_number == 0 {
-                                    self.stack.push((Visit::First, succ))
-                                }
-                            }
-                        }
-                    }
-                }
-
-                Visit::Last => {
-                    // We've finished all this node's successors.
-                    self.postorder.push(block);
-                }
-            }
-        }
+        self.postorder.extend(self.dfs.post_order_iter(func));
     }
 
     /// Build a dominator tree from a control flow graph using Keith D. Cooper's
@@ -467,7 +392,6 @@ impl DominatorTreePreorder {
     /// Recompute this data structure to match `domtree`.
     pub fn compute(&mut self, domtree: &DominatorTree, layout: &Layout) {
         self.nodes.clear();
-        debug_assert_eq!(self.stack.len(), 0);
 
         // Step 1: Populate the child and sibling links.
         //
@@ -586,9 +510,8 @@ impl DominatorTreePreorder {
 mod tests {
     use super::*;
     use crate::cursor::{Cursor, FuncCursor};
-    use crate::flowgraph::ControlFlowGraph;
     use crate::ir::types::*;
-    use crate::ir::{Function, InstBuilder, TrapCode};
+    use crate::ir::{InstBuilder, TrapCode};
 
     #[test]
     fn empty() {
diff --git a/cranelift/codegen/src/egraph.rs b/cranelift/codegen/src/egraph.rs
index e12b6fed39f2..5d4d7c22fd1d 100644
--- a/cranelift/codegen/src/egraph.rs
+++ b/cranelift/codegen/src/egraph.rs
@@ -3,26 +3,29 @@
 use crate::alias_analysis::{AliasAnalysis, LastStores};
 use crate::ctxhash::{CtxEq, CtxHash, CtxHashMap};
 use crate::cursor::{Cursor, CursorPosition, FuncCursor};
-use crate::dominator_tree::DominatorTree;
-use crate::egraph::domtree::DomTreeWithChildren;
+use crate::dominator_tree::{DominatorTree, DominatorTreePreorder};
 use crate::egraph::elaborate::Elaborator;
-use crate::fx::FxHashSet;
 use crate::inst_predicates::{is_mergeable_for_egraph, is_pure_for_egraph};
+use crate::ir::pcc::Fact;
 use crate::ir::{
-    Block, DataFlowGraph, Function, Inst, InstructionData, Type, Value, ValueDef, ValueListPool,
+    Block, DataFlowGraph, Function, Inst, InstructionData, Opcode, Type, Value, ValueDef,
+    ValueListPool,
 };
 use crate::loop_analysis::LoopAnalysis;
-use crate::opts::generated_code::ContextIter;
 use crate::opts::IsleContext;
 use crate::scoped_hash_map::{Entry as ScopedEntry, ScopedHashMap};
+use crate::settings::Flags;
 use crate::trace;
 use crate::unionfind::UnionFind;
+use core::cmp::Ordering;
+use cranelift_control::ControlPlane;
 use cranelift_entity::packed_option::ReservedValue;
 use cranelift_entity::SecondaryMap;
+use rustc_hash::FxHashSet;
+use smallvec::SmallVec;
 use std::hash::Hasher;
 
 mod cost;
-mod domtree;
 mod elaborate;
 
 /// Pass over a Function that does the whole aegraph thing.
@@ -46,16 +49,20 @@ mod elaborate;
 pub struct EgraphPass<'a> {
     /// The function we're operating on.
     func: &'a mut Function,
-    /// Dominator tree, used for elaboration pass.
-    domtree: &'a DominatorTree,
+    /// Dominator tree for the CFG, used to visit blocks in pre-order
+    /// so we see value definitions before their uses, and also used for
+    /// O(1) dominance checks.
+    domtree: DominatorTreePreorder,
     /// Alias analysis, used during optimization.
     alias_analysis: &'a mut AliasAnalysis<'a>,
-    /// "Domtree with children": like `domtree`, but with an explicit
-    /// list of children, rather than just parent pointers.
-    domtree_children: DomTreeWithChildren,
     /// Loop analysis results, used for built-in LICM during
     /// elaboration.
     loop_analysis: &'a LoopAnalysis,
+    /// Compiler flags.
+    flags: &'a Flags,
+    /// Chaos-mode control-plane so we can test that we still get
+    /// correct results when our heuristics make bad decisions.
+    ctrl_plane: &'a mut ControlPlane,
     /// Which canonical Values do we want to rematerialize in each
     /// block where they're used?
     ///
@@ -66,9 +73,12 @@ pub struct EgraphPass<'a> {
     pub(crate) stats: Stats,
     /// Union-find that maps all members of a Union tree (eclass) back
     /// to the *oldest* (lowest-numbered) `Value`.
-    eclasses: UnionFind<Value>,
+    pub(crate) eclasses: UnionFind<Value>,
 }
 
+// The maximum number of rewrites we will take from a single call into ISLE.
+const MATCHES_LIMIT: usize = 5;
+
 /// Context passed through node insertion and optimization.
 pub(crate) struct OptimizeCtx<'opt, 'analysis>
 where
@@ -79,14 +89,19 @@ where
     pub(crate) value_to_opt_value: &'opt mut SecondaryMap<Value, Value>,
     pub(crate) gvn_map: &'opt mut CtxHashMap<(Type, InstructionData), Value>,
     pub(crate) effectful_gvn_map: &'opt mut ScopedHashMap<(Type, InstructionData), Value>,
+    available_block: &'opt mut SecondaryMap<Value, Block>,
     pub(crate) eclasses: &'opt mut UnionFind<Value>,
     pub(crate) remat_values: &'opt mut FxHashSet<Value>,
     pub(crate) stats: &'opt mut Stats,
+    domtree: &'opt DominatorTreePreorder,
     pub(crate) alias_analysis: &'opt mut AliasAnalysis<'analysis>,
     pub(crate) alias_analysis_state: &'opt mut LastStores,
+    flags: &'opt Flags,
+    ctrl_plane: &'opt mut ControlPlane,
     // Held locally during optimization of one node (recursively):
     pub(crate) rewrite_depth: usize,
     pub(crate) subsume_values: FxHashSet<Value>,
+    optimized_values: SmallVec<[Value; MATCHES_LIMIT]>,
 }
 
 /// For passing to `insert_pure_enode`. Sometimes the enode already
@@ -104,7 +119,7 @@ impl NewOrExistingInst {
             NewOrExistingInst::New(data, ty) => (*ty, *data),
             NewOrExistingInst::Existing(inst) => {
                 let ty = dfg.ctrl_typevar(*inst);
-                (ty, dfg.insts[*inst].clone())
+                (ty, dfg.insts[*inst])
             }
         }
     }
@@ -160,13 +175,19 @@ where
             if let NewOrExistingInst::Existing(inst) = inst {
                 debug_assert_eq!(self.func.dfg.inst_results(inst).len(), 1);
                 let result = self.func.dfg.first_result(inst);
+                debug_assert!(
+                    self.domtree.dominates(
+                        self.available_block[orig_result],
+                        self.get_available_block(inst)
+                    ),
+                    "GVN shouldn't replace {result} (available in {}) with non-dominating {orig_result} (available in {})",
+                    self.get_available_block(inst),
+                    self.available_block[orig_result],
+                );
                 self.value_to_opt_value[result] = orig_result;
-                self.eclasses.union(result, orig_result);
-                self.stats.union += 1;
-                result
-            } else {
-                orig_result
+                self.func.dfg.merge_facts(result, orig_result);
             }
+            orig_result
         } else {
             // Now actually insert the InstructionData and attach
             // result value (exactly one).
@@ -188,21 +209,65 @@ where
                 }
             };
 
+            self.attach_constant_fact(inst, result, ty);
+
+            self.available_block[result] = self.get_available_block(inst);
             let opt_value = self.optimize_pure_enode(inst);
+
+            for &argument in self.func.dfg.inst_args(inst) {
+                self.eclasses.pin_index(argument);
+            }
+
             let gvn_context = GVNContext {
                 union_find: self.eclasses,
                 value_lists: &self.func.dfg.value_lists,
             };
-            self.gvn_map.insert(
-                (ty, self.func.dfg.insts[inst].clone()),
-                opt_value,
-                &gvn_context,
-            );
+            self.gvn_map
+                .insert((ty, self.func.dfg.insts[inst]), opt_value, &gvn_context);
             self.value_to_opt_value[result] = opt_value;
             opt_value
         }
     }
 
+    /// Find the block where a pure instruction first becomes available,
+    /// defined as the block that is closest to the root where all of
+    /// its arguments are available. In the unusual case where a pure
+    /// instruction has no arguments (e.g. get_return_address), we can
+    /// place it anywhere, so it is available in the entry block.
+    ///
+    /// This function does not compute available blocks recursively.
+    /// All of the instruction's arguments must have had their available
+    /// blocks assigned already.
+    fn get_available_block(&self, inst: Inst) -> Block {
+        // Side-effecting instructions have different rules for where
+        // they become available, so this function does not apply.
+        debug_assert!(is_pure_for_egraph(self.func, inst));
+
+        // Note that the def-point of all arguments to an instruction
+        // in SSA lie on a line of direct ancestors in the domtree, and
+        // so do their available-blocks. This means that for any pair of
+        // arguments, their available blocks are either the same or one
+        // strictly dominates the other. We just need to find any argument
+        // whose available block is deepest in the domtree.
+        self.func.dfg.insts[inst]
+            .arguments(&self.func.dfg.value_lists)
+            .iter()
+            .map(|&v| {
+                let block = self.available_block[v];
+                debug_assert!(!block.is_reserved_value());
+                block
+            })
+            .max_by(|&x, &y| {
+                if self.domtree.dominates(x, y) {
+                    Ordering::Less
+                } else {
+                    debug_assert!(self.domtree.dominates(y, x));
+                    Ordering::Greater
+                }
+            })
+            .unwrap_or(self.func.layout.entry_block().unwrap())
+    }
+
     /// Optimizes an enode by applying any matching mid-end rewrite
     /// rules (or store-to-load forwarding, which is a special case),
     /// unioning together all possible optimized (or rewritten) forms
@@ -212,7 +277,7 @@ where
         // A pure node always has exactly one result.
         let orig_value = self.func.dfg.first_result(inst);
 
-        let mut isle_ctx = IsleContext { ctx: self };
+        let mut optimized_values = std::mem::take(&mut self.optimized_values);
 
         // Limit rewrite depth. When we apply optimization rules, they
         // may create new nodes (values) and those are, recursively,
@@ -224,24 +289,80 @@ where
         // infinite or problematic recursion, we bound the rewrite
         // depth to a small constant here.
         const REWRITE_LIMIT: usize = 5;
-        if isle_ctx.ctx.rewrite_depth > REWRITE_LIMIT {
-            isle_ctx.ctx.stats.rewrite_depth_limit += 1;
+        if self.rewrite_depth > REWRITE_LIMIT {
+            self.stats.rewrite_depth_limit += 1;
             return orig_value;
         }
-        isle_ctx.ctx.rewrite_depth += 1;
+        self.rewrite_depth += 1;
+        trace!("Incrementing rewrite depth; now {}", self.rewrite_depth);
 
         // Invoke the ISLE toplevel constructor, getting all new
         // values produced as equivalents to this value.
         trace!("Calling into ISLE with original value {}", orig_value);
-        isle_ctx.ctx.stats.rewrite_rule_invoked += 1;
-        let mut optimized_values =
-            crate::opts::generated_code::constructor_simplify(&mut isle_ctx, orig_value);
+        self.stats.rewrite_rule_invoked += 1;
+        debug_assert!(optimized_values.is_empty());
+        crate::opts::generated_code::constructor_simplify(
+            &mut IsleContext { ctx: self },
+            orig_value,
+            &mut optimized_values,
+        );
+
+        optimized_values.push(orig_value);
+
+        // Remove any values from optimized_values that do not have
+        // the highest possible available block in the domtree, in
+        // O(n) time. This loop scans in reverse, establishing the
+        // loop invariant that all values at indices >= idx have the
+        // same available block, which is the best available block
+        // seen so far. Note that orig_value must also be removed if
+        // it isn't in the best block, so we push it above, which means
+        // optimized_values is never empty: there's always at least one
+        // value in best_block.
+        let mut best_block = self.available_block[*optimized_values.last().unwrap()];
+        for idx in (0..optimized_values.len() - 1).rev() {
+            // At the beginning of each iteration, there is a non-empty
+            // collection of values after idx, which are all available
+            // at best_block.
+            let this_block = self.available_block[optimized_values[idx]];
+            if this_block != best_block {
+                if self.domtree.dominates(this_block, best_block) {
+                    // If the available block for this value dominates
+                    // the best block we've seen so far, discard all
+                    // the values we already checked and leave only this
+                    // value in the tail of the vector.
+                    optimized_values.truncate(idx + 1);
+                    best_block = this_block;
+                } else {
+                    // Otherwise the tail of the vector contains values
+                    // which are all better than this value, so we can
+                    // swap any of them in place of this value to delete
+                    // this one in O(1) time.
+                    debug_assert!(self.domtree.dominates(best_block, this_block));
+                    optimized_values.swap_remove(idx);
+                    debug_assert!(optimized_values.len() > idx);
+                }
+            }
+        }
+
+        // It's not supposed to matter what order `simplify` returns values in.
+        self.ctrl_plane.shuffle(&mut optimized_values);
+
+        let num_matches = optimized_values.len();
+        if num_matches > MATCHES_LIMIT {
+            trace!(
+                "Reached maximum matches limit; too many optimized values \
+                 ({num_matches} > {MATCHES_LIMIT}); ignoring rest.",
+            );
+            optimized_values.truncate(MATCHES_LIMIT);
+        }
+
+        trace!("  -> returned from ISLE: {orig_value} -> {optimized_values:?}");
 
         // Create a union of all new values with the original (or
         // maybe just one new value marked as "subsuming" the
         // original, if present.)
-        let mut union_value = orig_value;
-        while let Some(optimized_value) = optimized_values.next(&mut isle_ctx) {
+        let mut union_value = optimized_values.pop().unwrap();
+        for optimized_value in optimized_values.drain(..) {
             trace!(
                 "Returned from ISLE for {}, got {:?}",
                 orig_value,
@@ -251,32 +372,32 @@ where
                 trace!(" -> same as orig value; skipping");
                 continue;
             }
-            if isle_ctx.ctx.subsume_values.contains(&optimized_value) {
+            if self.subsume_values.contains(&optimized_value) {
                 // Merge in the unionfind so canonicalization
                 // still works, but take *only* the subsuming
                 // value, and break now.
-                isle_ctx.ctx.eclasses.union(optimized_value, union_value);
+                self.eclasses.union(optimized_value, union_value);
+                self.func.dfg.merge_facts(optimized_value, union_value);
                 union_value = optimized_value;
                 break;
             }
 
             let old_union_value = union_value;
-            union_value = isle_ctx
-                .ctx
-                .func
-                .dfg
-                .union(old_union_value, optimized_value);
-            isle_ctx.ctx.stats.union += 1;
+            union_value = self.func.dfg.union(old_union_value, optimized_value);
+            self.available_block[union_value] = best_block;
+            self.stats.union += 1;
             trace!(" -> union: now {}", union_value);
-            isle_ctx.ctx.eclasses.add(union_value);
-            isle_ctx
-                .ctx
-                .eclasses
-                .union(old_union_value, optimized_value);
-            isle_ctx.ctx.eclasses.union(old_union_value, union_value);
+            self.eclasses.add(union_value);
+            self.eclasses.union(old_union_value, optimized_value);
+            self.func.dfg.merge_facts(old_union_value, optimized_value);
+            self.eclasses.union(old_union_value, union_value);
         }
 
-        isle_ctx.ctx.rewrite_depth -= 1;
+        self.rewrite_depth -= 1;
+        trace!("Decrementing rewrite depth; now {}", self.rewrite_depth);
+
+        debug_assert!(self.optimized_values.is_empty());
+        self.optimized_values = optimized_values;
 
         union_value
     }
@@ -287,6 +408,10 @@ where
     fn optimize_skeleton_inst(&mut self, inst: Inst) -> bool {
         self.stats.skeleton_inst += 1;
 
+        for &result in self.func.dfg.inst_results(inst) {
+            self.available_block[result] = self.func.layout.inst_block(inst).unwrap();
+        }
+
         // First, can we try to deduplicate? We need to keep some copy
         // of the instruction around because it's side-effecting, but
         // we may be able to reuse an earlier instance of it.
@@ -307,13 +432,12 @@ where
             let ty = self.func.dfg.ctrl_typevar(inst);
             match self
                 .effectful_gvn_map
-                .entry((ty, self.func.dfg.insts[inst].clone()))
+                .entry((ty, self.func.dfg.insts[inst]))
             {
                 ScopedEntry::Occupied(o) => {
                     let orig_result = *o.get();
                     // Hit in GVN map -- reuse value.
                     self.value_to_opt_value[result] = orig_result;
-                    self.eclasses.union(orig_result, result);
                     trace!(" -> merges result {} to {}", result, orig_result);
                     true
                 }
@@ -342,6 +466,7 @@ where
                 new_result
             );
             self.value_to_opt_value[result] = new_result;
+            self.func.dfg.merge_facts(result, new_result);
             true
         }
         // Otherwise, generic side-effecting op -- always keep it, and
@@ -356,24 +481,45 @@ where
             false
         }
     }
+
+    /// Helper to propagate facts on constant values: if PCC is
+    /// enabled, then unconditionally add a fact attesting to the
+    /// Value's concrete value.
+    fn attach_constant_fact(&mut self, inst: Inst, value: Value, ty: Type) {
+        if self.flags.enable_pcc() {
+            if let InstructionData::UnaryImm {
+                opcode: Opcode::Iconst,
+                imm,
+            } = self.func.dfg.insts[inst]
+            {
+                let imm: i64 = imm.into();
+                self.func.dfg.facts[value] =
+                    Some(Fact::constant(ty.bits().try_into().unwrap(), imm as u64));
+            }
+        }
+    }
 }
 
 impl<'a> EgraphPass<'a> {
     /// Create a new EgraphPass.
     pub fn new(
         func: &'a mut Function,
-        domtree: &'a DominatorTree,
+        raw_domtree: &'a DominatorTree,
         loop_analysis: &'a LoopAnalysis,
         alias_analysis: &'a mut AliasAnalysis<'a>,
+        flags: &'a Flags,
+        ctrl_plane: &'a mut ControlPlane,
     ) -> Self {
         let num_values = func.dfg.num_values();
-        let domtree_children = DomTreeWithChildren::new(func, domtree);
+        let mut domtree = DominatorTreePreorder::new();
+        domtree.compute(raw_domtree, &func.layout);
         Self {
             func,
             domtree,
-            domtree_children,
             loop_analysis,
             alias_analysis,
+            flags,
+            ctrl_plane,
             stats: Stats::default(),
             eclasses: UnionFind::with_capacity(num_values),
             remat_values: FxHashSet::default(),
@@ -396,7 +542,8 @@ impl<'a> EgraphPass<'a> {
                 }
             }
         }
-        trace!("stats: {:?}", self.stats);
+        trace!("stats: {:#?}", self.stats);
+        trace!("pinned_union_count: {}", self.eclasses.pinned_union_count);
         self.elaborate();
     }
 
@@ -455,9 +602,23 @@ impl<'a> EgraphPass<'a> {
         let mut effectful_gvn_map: ScopedHashMap<(Type, InstructionData), Value> =
             ScopedHashMap::new();
 
+        // We assign an "available block" to every value. Values tied to
+        // the side-effecting skeleton are available in the block where
+        // they're defined. Results from pure instructions could legally
+        // float up the domtree so they are available as soon as all
+        // their arguments are available. Values which identify union
+        // nodes are available in the same block as all values in the
+        // eclass, enforced by optimize_pure_enode.
+        let mut available_block: SecondaryMap<Value, Block> =
+            SecondaryMap::with_default(Block::reserved_value());
+        // This is an initial guess at the size we'll need, but we add
+        // more values as we build simplified alternative expressions so
+        // this is likely to realloc again later.
+        available_block.resize(cursor.func.dfg.num_values());
+
         // In domtree preorder, visit blocks. (TODO: factor out an
         // iterator from this and elaborator.)
-        let root = self.domtree_children.root();
+        let root = cursor.layout().entry_block().unwrap();
         enum StackEntry {
             Visit(Block),
             Pop,
@@ -469,8 +630,11 @@ impl<'a> EgraphPass<'a> {
                     // We popped this block; push children
                     // immediately, then process this block.
                     block_stack.push(StackEntry::Pop);
-                    block_stack
-                        .extend(self.domtree_children.children(block).map(StackEntry::Visit));
+                    block_stack.extend(
+                        self.ctrl_plane
+                            .shuffled(self.domtree.children(block))
+                            .map(StackEntry::Visit),
+                    );
                     effectful_gvn_map.increment_depth();
 
                     trace!("Processing block {}", block);
@@ -482,6 +646,7 @@ impl<'a> EgraphPass<'a> {
                         trace!("creating initial singleton eclass for blockparam {}", param);
                         self.eclasses.add(param);
                         value_to_opt_value[param] = param;
+                        available_block[param] = block;
                     }
                     while let Some(inst) = cursor.next_inst() {
                         trace!("Processing inst {}", inst);
@@ -497,8 +662,7 @@ impl<'a> EgraphPass<'a> {
 
                         // Rewrite args of *all* instructions using the
                         // value-to-opt-value map.
-                        cursor.func.dfg.resolve_aliases_in_arguments(inst);
-                        cursor.func.dfg.map_inst_values(inst, |_, arg| {
+                        cursor.func.dfg.map_inst_values(inst, |arg| {
                             let new_value = value_to_opt_value[arg];
                             trace!("rewriting arg {} of inst {} to {}", arg, inst, new_value);
                             debug_assert_ne!(new_value, Value::reserved_value());
@@ -515,13 +679,18 @@ impl<'a> EgraphPass<'a> {
                             value_to_opt_value: &mut value_to_opt_value,
                             gvn_map: &mut gvn_map,
                             effectful_gvn_map: &mut effectful_gvn_map,
+                            available_block: &mut available_block,
                             eclasses: &mut self.eclasses,
                             rewrite_depth: 0,
                             subsume_values: FxHashSet::default(),
                             remat_values: &mut self.remat_values,
                             stats: &mut self.stats,
+                            domtree: &self.domtree,
                             alias_analysis: self.alias_analysis,
                             alias_analysis_state: &mut alias_analysis_state,
+                            flags: self.flags,
+                            ctrl_plane: self.ctrl_plane,
+                            optimized_values: Default::default(),
                         };
 
                         if is_pure_for_egraph(ctx.func, inst) {
@@ -574,12 +743,11 @@ impl<'a> EgraphPass<'a> {
     fn elaborate(&mut self) {
         let mut elaborator = Elaborator::new(
             self.func,
-            self.domtree,
-            &self.domtree_children,
+            &self.domtree,
             self.loop_analysis,
             &mut self.remat_values,
-            &mut self.eclasses,
             &mut self.stats,
+            self.ctrl_plane,
         );
         elaborator.elaborate();
 
@@ -601,7 +769,7 @@ impl<'a> EgraphPass<'a> {
                             debug_assert!(self.func.layout.inst_block(i).is_some());
                         }
                         ValueDef::Union(..) => {
-                            panic!("egraph union node {} still reachable at {}!", arg, inst);
+                            panic!("egraph union node {arg} still reachable at {inst}!");
                         }
                         _ => {}
                     })
@@ -658,9 +826,10 @@ pub(crate) struct Stats {
     pub(crate) elaborate_visit_node: u64,
     pub(crate) elaborate_memoize_hit: u64,
     pub(crate) elaborate_memoize_miss: u64,
-    pub(crate) elaborate_memoize_miss_remat: u64,
+    pub(crate) elaborate_remat: u64,
     pub(crate) elaborate_licm_hoist: u64,
     pub(crate) elaborate_func: u64,
     pub(crate) elaborate_func_pre_insts: u64,
     pub(crate) elaborate_func_post_insts: u64,
+    pub(crate) elaborate_best_cost_fixpoint_iters: u64,
 }
diff --git a/cranelift/codegen/src/egraph/cost.rs b/cranelift/codegen/src/egraph/cost.rs
index 9cfb0894ca74..28aab40e9740 100644
--- a/cranelift/codegen/src/egraph/cost.rs
+++ b/cranelift/codegen/src/egraph/cost.rs
@@ -30,14 +30,51 @@ use crate::ir::Opcode;
 /// `finite()` method.) An infinite cost is used to represent a value
 /// that cannot be computed, or otherwise serve as a sentinel when
 /// performing search for the lowest-cost representation of a value.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 pub(crate) struct Cost(u32);
-impl Cost {
-    pub(crate) fn at_level(&self, loop_level: usize) -> Cost {
-        let loop_level = std::cmp::min(2, loop_level);
-        let multiplier = 1u32 << ((10 * loop_level) as u32);
-        Cost(self.0.saturating_mul(multiplier)).finite()
+
+impl core::fmt::Debug for Cost {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        if *self == Cost::infinity() {
+            write!(f, "Cost::Infinite")
+        } else {
+            f.debug_struct("Cost::Finite")
+                .field("op_cost", &self.op_cost())
+                .field("depth", &self.depth())
+                .finish()
+        }
+    }
+}
+
+impl Ord for Cost {
+    #[inline]
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        // We make sure that the high bits are the op cost and the low bits are
+        // the depth. This means that we can use normal integer comparison to
+        // order by op cost and then depth.
+        //
+        // We want to break op cost ties with depth (rather than the other way
+        // around). When the op cost is the same, we prefer shallow and wide
+        // expressions to narrow and deep expressions and breaking ties with
+        // `depth` gives us that. For example, `(a + b) + (c + d)` is preferred
+        // to `((a + b) + c) + d`. This is beneficial because it exposes more
+        // instruction-level parallelism and shortens live ranges.
+        self.0.cmp(&other.0)
     }
+}
+
+impl PartialOrd for Cost {
+    #[inline]
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Cost {
+    const DEPTH_BITS: u8 = 8;
+    const DEPTH_MASK: u32 = (1 << Self::DEPTH_BITS) - 1;
+    const OP_COST_MASK: u32 = !Self::DEPTH_MASK;
+    const MAX_OP_COST: u32 = Self::OP_COST_MASK >> Self::DEPTH_BITS;
 
     pub(crate) fn infinity() -> Cost {
         // 2^32 - 1 is, uh, pretty close to infinite... (we use `Cost`
@@ -49,11 +86,40 @@ impl Cost {
         Cost(0)
     }
 
-    /// Clamp this cost at a "finite" value. Can be used in
-    /// conjunction with saturating ops to avoid saturating into
-    /// `infinity()`.
-    fn finite(self) -> Cost {
-        Cost(std::cmp::min(u32::MAX - 1, self.0))
+    /// Construct a new `Cost` from the given parts.
+    ///
+    /// If the opcode cost is greater than or equal to the maximum representable
+    /// opcode cost, then the resulting `Cost` saturates to infinity.
+    fn new(opcode_cost: u32, depth: u8) -> Cost {
+        if opcode_cost >= Self::MAX_OP_COST {
+            Self::infinity()
+        } else {
+            Cost(opcode_cost << Self::DEPTH_BITS | u32::from(depth))
+        }
+    }
+
+    fn depth(&self) -> u8 {
+        let depth = self.0 & Self::DEPTH_MASK;
+        u8::try_from(depth).unwrap()
+    }
+
+    fn op_cost(&self) -> u32 {
+        (self.0 & Self::OP_COST_MASK) >> Self::DEPTH_BITS
+    }
+
+    /// Compute the cost of the operation and its given operands.
+    ///
+    /// Caller is responsible for checking that the opcode came from an instruction
+    /// that satisfies `inst_predicates::is_pure_for_egraph()`.
+    pub(crate) fn of_pure_op(op: Opcode, operand_costs: impl IntoIterator<Item = Self>) -> Self {
+        let c = pure_op_cost(op) + operand_costs.into_iter().sum();
+        Cost::new(c.op_cost(), c.depth().saturating_add(1))
+    }
+}
+
+impl std::iter::Sum<Cost> for Cost {
+    fn sum<I: Iterator<Item = Cost>>(iter: I) -> Self {
+        iter.fold(Self::zero(), |a, b| a + b)
     }
 }
 
@@ -65,22 +131,28 @@ impl std::default::Default for Cost {
 
 impl std::ops::Add<Cost> for Cost {
     type Output = Cost;
+
     fn add(self, other: Cost) -> Cost {
-        Cost(self.0.saturating_add(other.0)).finite()
+        let op_cost = self.op_cost().saturating_add(other.op_cost());
+        let depth = std::cmp::max(self.depth(), other.depth());
+        Cost::new(op_cost, depth)
     }
 }
 
-/// Return the cost of a *pure* opcode. Caller is responsible for
-/// checking that the opcode came from an instruction that satisfies
-/// `inst_predicates::is_pure_for_egraph()`.
-pub(crate) fn pure_op_cost(op: Opcode) -> Cost {
+/// Return the cost of a *pure* opcode.
+///
+/// Caller is responsible for checking that the opcode came from an instruction
+/// that satisfies `inst_predicates::is_pure_for_egraph()`.
+fn pure_op_cost(op: Opcode) -> Cost {
     match op {
         // Constants.
-        Opcode::Iconst | Opcode::F32const | Opcode::F64const => Cost(0),
+        Opcode::Iconst | Opcode::F32const | Opcode::F64const => Cost::new(1, 0),
+
         // Extends/reduces.
         Opcode::Uextend | Opcode::Sextend | Opcode::Ireduce | Opcode::Iconcat | Opcode::Isplit => {
-            Cost(1)
+            Cost::new(2, 0)
         }
+
         // "Simple" arithmetic.
         Opcode::Iadd
         | Opcode::Isub
@@ -90,8 +162,52 @@ pub(crate) fn pure_op_cost(op: Opcode) -> Cost {
         | Opcode::Bnot
         | Opcode::Ishl
         | Opcode::Ushr
-        | Opcode::Sshr => Cost(2),
+        | Opcode::Sshr => Cost::new(3, 0),
+
         // Everything else (pure.)
-        _ => Cost(3),
+        _ => Cost::new(4, 0),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn add_cost() {
+        let a = Cost::new(5, 2);
+        let b = Cost::new(37, 3);
+        assert_eq!(a + b, Cost::new(42, 3));
+        assert_eq!(b + a, Cost::new(42, 3));
+    }
+
+    #[test]
+    fn add_infinity() {
+        let a = Cost::new(5, 2);
+        let b = Cost::infinity();
+        assert_eq!(a + b, Cost::infinity());
+        assert_eq!(b + a, Cost::infinity());
+    }
+
+    #[test]
+    fn op_cost_saturates_to_infinity() {
+        let a = Cost::new(Cost::MAX_OP_COST - 10, 2);
+        let b = Cost::new(11, 2);
+        assert_eq!(a + b, Cost::infinity());
+        assert_eq!(b + a, Cost::infinity());
+    }
+
+    #[test]
+    fn depth_saturates_to_max_depth() {
+        let a = Cost::new(10, u8::MAX);
+        let b = Cost::new(10, 1);
+        assert_eq!(
+            Cost::of_pure_op(Opcode::Iconst, [a, b]),
+            Cost::new(21, u8::MAX)
+        );
+        assert_eq!(
+            Cost::of_pure_op(Opcode::Iconst, [b, a]),
+            Cost::new(21, u8::MAX)
+        );
     }
 }
diff --git a/cranelift/codegen/src/egraph/domtree.rs b/cranelift/codegen/src/egraph/domtree.rs
deleted file mode 100644
index f0af89e2a244..000000000000
--- a/cranelift/codegen/src/egraph/domtree.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-//! Extended domtree with various traversal support.
-
-use crate::dominator_tree::DominatorTree;
-use crate::ir::{Block, Function};
-use cranelift_entity::{packed_option::PackedOption, SecondaryMap};
-
-#[derive(Clone, Debug)]
-pub(crate) struct DomTreeWithChildren {
-    nodes: SecondaryMap<Block, DomTreeNode>,
-    root: Block,
-}
-
-#[derive(Clone, Copy, Debug, Default)]
-struct DomTreeNode {
-    children: PackedOption<Block>,
-    next: PackedOption<Block>,
-}
-
-impl DomTreeWithChildren {
-    pub(crate) fn new(func: &Function, domtree: &DominatorTree) -> DomTreeWithChildren {
-        let mut nodes: SecondaryMap<Block, DomTreeNode> =
-            SecondaryMap::with_capacity(func.dfg.num_blocks());
-
-        for block in func.layout.blocks() {
-            let idom_inst = match domtree.idom(block) {
-                Some(idom_inst) => idom_inst,
-                None => continue,
-            };
-            let idom = func
-                .layout
-                .inst_block(idom_inst)
-                .expect("Dominating instruction should be part of a block");
-
-            nodes[block].next = nodes[idom].children;
-            nodes[idom].children = block.into();
-        }
-
-        let root = func.layout.entry_block().unwrap();
-
-        Self { nodes, root }
-    }
-
-    pub(crate) fn root(&self) -> Block {
-        self.root
-    }
-
-    pub(crate) fn children<'a>(&'a self, block: Block) -> DomTreeChildIter<'a> {
-        let block = self.nodes[block].children;
-        DomTreeChildIter {
-            domtree: self,
-            block,
-        }
-    }
-}
-
-pub(crate) struct DomTreeChildIter<'a> {
-    domtree: &'a DomTreeWithChildren,
-    block: PackedOption<Block>,
-}
-
-impl<'a> Iterator for DomTreeChildIter<'a> {
-    type Item = Block;
-    fn next(&mut self) -> Option<Block> {
-        self.block.expand().map(|block| {
-            self.block = self.domtree.nodes[block].next;
-            block
-        })
-    }
-}
diff --git a/cranelift/codegen/src/egraph/elaborate.rs b/cranelift/codegen/src/egraph/elaborate.rs
index 6acf83cba9ae..a35c2ac25734 100644
--- a/cranelift/codegen/src/egraph/elaborate.rs
+++ b/cranelift/codegen/src/egraph/elaborate.rs
@@ -1,26 +1,25 @@
 //! Elaboration phase: lowers EGraph back to sequences of operations
 //! in CFG nodes.
 
-use super::cost::{pure_op_cost, Cost};
-use super::domtree::DomTreeWithChildren;
+use super::cost::Cost;
 use super::Stats;
-use crate::dominator_tree::DominatorTree;
-use crate::fx::FxHashSet;
+use crate::dominator_tree::DominatorTreePreorder;
+use crate::hash_map::Entry as HashEntry;
+use crate::inst_predicates::is_pure_for_egraph;
 use crate::ir::{Block, Function, Inst, Value, ValueDef};
-use crate::loop_analysis::{Loop, LoopAnalysis, LoopLevel};
+use crate::loop_analysis::{Loop, LoopAnalysis};
 use crate::scoped_hash_map::ScopedHashMap;
 use crate::trace;
-use crate::unionfind::UnionFind;
 use alloc::vec::Vec;
+use cranelift_control::ControlPlane;
 use cranelift_entity::{packed_option::ReservedValue, SecondaryMap};
+use rustc_hash::{FxHashMap, FxHashSet};
 use smallvec::{smallvec, SmallVec};
 
 pub(crate) struct Elaborator<'a> {
     func: &'a mut Function,
-    domtree: &'a DominatorTree,
-    domtree_children: &'a DomTreeWithChildren,
+    domtree: &'a DominatorTreePreorder,
     loop_analysis: &'a LoopAnalysis,
-    eclasses: &'a mut UnionFind<Value>,
     /// Map from Value that is produced by a pure Inst (and was thus
     /// not in the side-effecting skeleton) to the value produced by
     /// an elaborated inst (placed in the layout) to whose results we
@@ -38,10 +37,15 @@ pub(crate) struct Elaborator<'a> {
     /// is already placed in the Layout. If so, we duplicate, and
     /// insert non-identity mappings from the original inst's results
     /// to the cloned inst's results.
+    ///
+    /// Note that as values may refer to unions that represent a subset
+    /// of a larger eclass, it's not valid to walk towards the root of a
+    /// union tree: doing so would potentially equate values that fall
+    /// on different branches of the dominator tree.
     value_to_elaborated_value: ScopedHashMap<Value, ElaboratedValue>,
     /// Map from Value to the best (lowest-cost) Value in its eclass
     /// (tree of union value-nodes).
-    value_to_best_value: SecondaryMap<Value, (Cost, Value)>,
+    value_to_best_value: SecondaryMap<Value, BestEntry>,
     /// Stack of blocks and loops in current elaboration path.
     loop_stack: SmallVec<[LoopStackEntry; 8]>,
     /// The current block into which we are elaborating.
@@ -56,9 +60,36 @@ pub(crate) struct Elaborator<'a> {
     elab_result_stack: Vec<ElaboratedValue>,
     /// Explicitly-unrolled block elaboration stack.
     block_stack: Vec<BlockStackEntry>,
+    /// Copies of values that have been rematerialized.
+    remat_copies: FxHashMap<(Block, Value), Value>,
     /// Stats for various events during egraph processing, to help
     /// with optimization of this infrastructure.
     stats: &'a mut Stats,
+    /// Chaos-mode control-plane so we can test that we still get
+    /// correct results when our heuristics make bad decisions.
+    ctrl_plane: &'a mut ControlPlane,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+struct BestEntry(Cost, Value);
+
+impl PartialOrd for BestEntry {
+    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for BestEntry {
+    #[inline]
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.0.cmp(&other.0).then_with(|| {
+            // Note that this comparison is reversed. When costs are equal,
+            // prefer the value with the bigger index. This is a heuristic that
+            // prefers results of rewrites to the original value, since we
+            // expect that our rewrites are generally improvements.
+            self.1.cmp(&other.1).reverse()
+        })
+    }
 }
 
 #[derive(Clone, Copy, Debug)]
@@ -95,7 +126,6 @@ enum ElabStackEntry {
         inst: Inst,
         result_idx: usize,
         num_args: usize,
-        remat: bool,
         before: Inst,
     },
 }
@@ -109,23 +139,20 @@ enum BlockStackEntry {
 impl<'a> Elaborator<'a> {
     pub(crate) fn new(
         func: &'a mut Function,
-        domtree: &'a DominatorTree,
-        domtree_children: &'a DomTreeWithChildren,
+        domtree: &'a DominatorTreePreorder,
         loop_analysis: &'a LoopAnalysis,
         remat_values: &'a FxHashSet<Value>,
-        eclasses: &'a mut UnionFind<Value>,
         stats: &'a mut Stats,
+        ctrl_plane: &'a mut ControlPlane,
     ) -> Self {
         let num_values = func.dfg.num_values();
         let mut value_to_best_value =
-            SecondaryMap::with_default((Cost::infinity(), Value::reserved_value()));
+            SecondaryMap::with_default(BestEntry(Cost::infinity(), Value::reserved_value()));
         value_to_best_value.resize(num_values);
         Self {
             func,
             domtree,
-            domtree_children,
             loop_analysis,
-            eclasses,
             value_to_elaborated_value: ScopedHashMap::with_capacity(num_values),
             value_to_best_value,
             loop_stack: smallvec![],
@@ -134,7 +161,9 @@ impl<'a> Elaborator<'a> {
             elab_stack: vec![],
             elab_result_stack: vec![],
             block_stack: vec![],
+            remat_copies: FxHashMap::default(),
             stats,
+            ctrl_plane,
         }
     }
 
@@ -191,51 +220,137 @@ impl<'a> Elaborator<'a> {
 
     fn compute_best_values(&mut self) {
         let best = &mut self.value_to_best_value;
-        for (value, def) in self.func.dfg.values_and_defs() {
-            trace!("computing best for value {:?} def {:?}", value, def);
-            match def {
-                ValueDef::Union(x, y) => {
-                    // Pick the best of the two options based on
-                    // min-cost. This works because each element of `best`
-                    // is a `(cost, value)` tuple; `cost` comes first so
-                    // the natural comparison works based on cost, and
-                    // breaks ties based on value number.
-                    trace!(" -> best of {:?} and {:?}", best[x], best[y]);
-                    best[value] = std::cmp::min(best[x], best[y]);
-                    trace!(" -> {:?}", best[value]);
-                }
-                ValueDef::Param(_, _) => {
-                    best[value] = (Cost::zero(), value);
-                }
-                // If the Inst is inserted into the layout (which is,
-                // at this point, only the side-effecting skeleton),
-                // then it must be computed and thus we give it zero
-                // cost.
-                ValueDef::Result(inst, _) if self.func.layout.inst_block(inst).is_some() => {
-                    best[value] = (Cost::zero(), value);
-                }
-                ValueDef::Result(inst, _) => {
-                    trace!(" -> value {}: result, computing cost", value);
-                    let inst_data = &self.func.dfg.insts[inst];
-                    let loop_level = self
-                        .func
-                        .layout
-                        .inst_block(inst)
-                        .map(|block| self.loop_analysis.loop_level(block))
-                        .unwrap_or(LoopLevel::root());
-                    // N.B.: at this point we know that the opcode is
-                    // pure, so `pure_op_cost`'s precondition is
-                    // satisfied.
-                    let cost = self.func.dfg.inst_values(inst).fold(
-                        pure_op_cost(inst_data.opcode()).at_level(loop_level.level()),
-                        |cost, value| cost + best[value].0,
-                    );
-                    best[value] = (cost, value);
-                }
-            };
-            debug_assert_ne!(best[value].0, Cost::infinity());
-            debug_assert_ne!(best[value].1, Value::reserved_value());
-            trace!("best for eclass {:?}: {:?}", value, best[value]);
+
+        // We can't make random decisions inside the fixpoint loop below because
+        // that could cause values to change on every iteration of the loop,
+        // which would make the loop never terminate. So in chaos testing
+        // mode we need a form of making suboptimal decisions that is fully
+        // deterministic. We choose to simply make the worst decision we know
+        // how to do instead of the best.
+        let use_worst = self.ctrl_plane.get_decision();
+
+        // Do a fixpoint loop to compute the best value for each eclass.
+        //
+        // The maximum number of iterations is the length of the longest chain
+        // of `vNN -> vMM` edges in the dataflow graph where `NN < MM`, so this
+        // is *technically* quadratic, but `cranelift-frontend` won't construct
+        // any such edges. NaN canonicalization will introduce some of these
+        // edges, but they are chains of only two or three edges. So in
+        // practice, we *never* do more than a handful of iterations here unless
+        // (a) we parsed the CLIF from text and the text was funkily numbered,
+        // which we don't really care about, or (b) the CLIF producer did
+        // something weird, in which case it is their responsibility to stop
+        // doing that.
+        trace!(
+            "Entering fixpoint loop to compute the {} values for each eclass",
+            if use_worst {
+                "worst (chaos mode)"
+            } else {
+                "best"
+            }
+        );
+        let mut keep_going = true;
+        while keep_going {
+            keep_going = false;
+            trace!(
+                "fixpoint iteration {}",
+                self.stats.elaborate_best_cost_fixpoint_iters
+            );
+            self.stats.elaborate_best_cost_fixpoint_iters += 1;
+
+            for (value, def) in self.func.dfg.values_and_defs() {
+                trace!("computing best for value {:?} def {:?}", value, def);
+                let orig_best_value = best[value];
+
+                match def {
+                    ValueDef::Union(x, y) => {
+                        // Pick the best of the two options based on
+                        // min-cost. This works because each element of `best`
+                        // is a `(cost, value)` tuple; `cost` comes first so
+                        // the natural comparison works based on cost, and
+                        // breaks ties based on value number.
+                        best[value] = if use_worst {
+                            if best[x].1.is_reserved_value() {
+                                best[y]
+                            } else if best[y].1.is_reserved_value() {
+                                best[x]
+                            } else {
+                                std::cmp::max(best[x], best[y])
+                            }
+                        } else {
+                            std::cmp::min(best[x], best[y])
+                        };
+                        trace!(
+                            " -> best of union({:?}, {:?}) = {:?}",
+                            best[x],
+                            best[y],
+                            best[value]
+                        );
+                    }
+                    ValueDef::Param(_, _) => {
+                        best[value] = BestEntry(Cost::zero(), value);
+                    }
+                    // If the Inst is inserted into the layout (which is,
+                    // at this point, only the side-effecting skeleton),
+                    // then it must be computed and thus we give it zero
+                    // cost.
+                    ValueDef::Result(inst, _) => {
+                        if let Some(_) = self.func.layout.inst_block(inst) {
+                            best[value] = BestEntry(Cost::zero(), value);
+                        } else {
+                            let inst_data = &self.func.dfg.insts[inst];
+                            // N.B.: at this point we know that the opcode is
+                            // pure, so `pure_op_cost`'s precondition is
+                            // satisfied.
+                            let cost = Cost::of_pure_op(
+                                inst_data.opcode(),
+                                self.func.dfg.inst_values(inst).map(|value| best[value].0),
+                            );
+                            best[value] = BestEntry(cost, value);
+                            trace!(" -> cost of value {} = {:?}", value, cost);
+                        }
+                    }
+                };
+
+                // Keep on iterating the fixpoint loop while we are finding new
+                // best values.
+                keep_going |= orig_best_value != best[value];
+            }
+        }
+
+        if cfg!(any(feature = "trace-log", debug_assertions)) {
+            trace!("finished fixpoint loop to compute best value for each eclass");
+            for value in self.func.dfg.values() {
+                trace!("-> best for eclass {:?}: {:?}", value, best[value]);
+                debug_assert_ne!(best[value].1, Value::reserved_value());
+                // You might additionally be expecting an assert that the best
+                // cost is not infinity, however infinite cost *can* happen in
+                // practice. First, note that our cost function doesn't know
+                // about any shared structure in the dataflow graph, it only
+                // sums operand costs. (And trying to avoid that by deduping a
+                // single operation's operands is a losing game because you can
+                // always just add one indirection and go from `add(x, x)` to
+                // `add(foo(x), bar(x))` to hide the shared structure.) Given
+                // that blindness to sharing, we can make cost grow
+                // exponentially with a linear sequence of operations:
+                //
+                //     v0 = iconst.i32 1    ;; cost = 1
+                //     v1 = iadd v0, v0     ;; cost = 3 + 1 + 1
+                //     v2 = iadd v1, v1     ;; cost = 3 + 5 + 5
+                //     v3 = iadd v2, v2     ;; cost = 3 + 13 + 13
+                //     v4 = iadd v3, v3     ;; cost = 3 + 29 + 29
+                //     v5 = iadd v4, v4     ;; cost = 3 + 61 + 61
+                //     v6 = iadd v5, v5     ;; cost = 3 + 125 + 125
+                //     ;; etc...
+                //
+                // Such a chain can cause cost to saturate to infinity. How do
+                // we choose which e-node is best when there are multiple that
+                // have saturated to infinity? It doesn't matter. As long as
+                // invariant (2) for optimization rules is upheld by our rule
+                // set (see `cranelift/codegen/src/opts/README.md`) it is safe
+                // to choose *any* e-node in the e-class. At worst we will
+                // produce suboptimal code, but never an incorrectness.
+            }
         }
     }
 
@@ -258,64 +373,69 @@ impl<'a> Elaborator<'a> {
         self.elab_result_stack.pop().unwrap()
     }
 
+    /// Possibly rematerialize the instruction producing the value in
+    /// `arg` and rewrite `arg` to refer to it, if needed. Returns
+    /// `true` if a rewrite occurred.
+    fn maybe_remat_arg(
+        remat_values: &FxHashSet<Value>,
+        func: &mut Function,
+        remat_copies: &mut FxHashMap<(Block, Value), Value>,
+        insert_block: Block,
+        before: Inst,
+        arg: &mut ElaboratedValue,
+        stats: &mut Stats,
+    ) -> bool {
+        // TODO (#7313): we may want to consider recursive
+        // rematerialization as well. We could process the arguments of
+        // the rematerialized instruction up to a certain depth. This
+        // would affect, e.g., adds-with-one-constant-arg, which are
+        // currently rematerialized. Right now we don't do this, to
+        // avoid the need for another fixpoint loop here.
+        if arg.in_block != insert_block && remat_values.contains(&arg.value) {
+            let new_value = match remat_copies.entry((insert_block, arg.value)) {
+                HashEntry::Occupied(o) => *o.get(),
+                HashEntry::Vacant(v) => {
+                    let inst = func.dfg.value_def(arg.value).inst().unwrap();
+                    debug_assert_eq!(func.dfg.inst_results(inst).len(), 1);
+                    let new_inst = func.dfg.clone_inst(inst);
+                    func.layout.insert_inst(new_inst, before);
+                    let new_result = func.dfg.inst_results(new_inst)[0];
+                    *v.insert(new_result)
+                }
+            };
+            trace!("rematerialized {} as {}", arg.value, new_value);
+            arg.value = new_value;
+            stats.elaborate_remat += 1;
+            true
+        } else {
+            false
+        }
+    }
+
     fn process_elab_stack(&mut self) {
-        while let Some(entry) = self.elab_stack.last() {
+        while let Some(entry) = self.elab_stack.pop() {
             match entry {
-                &ElabStackEntry::Start { value, before } => {
-                    // We always replace the Start entry, so pop it now.
-                    self.elab_stack.pop();
-
-                    debug_assert_ne!(value, Value::reserved_value());
-                    let value = self.func.dfg.resolve_aliases(value);
+                ElabStackEntry::Start { value, before } => {
+                    debug_assert!(self.func.dfg.value_is_real(value));
 
                     self.stats.elaborate_visit_node += 1;
-                    let canonical_value = self.eclasses.find_and_update(value);
-                    debug_assert_ne!(canonical_value, Value::reserved_value());
-                    trace!(
-                        "elaborate: value {} canonical {} before {}",
-                        value,
-                        canonical_value,
-                        before
-                    );
 
                     // Get the best option; we use `value` (latest
                     // value) here so we have a full view of the
                     // eclass.
                     trace!("looking up best value for {}", value);
-                    let (_, best_value) = self.value_to_best_value[value];
-                    debug_assert_ne!(best_value, Value::reserved_value());
+                    let BestEntry(_, best_value) = self.value_to_best_value[value];
                     trace!("elaborate: value {} -> best {}", value, best_value);
+                    debug_assert_ne!(best_value, Value::reserved_value());
+
+                    if let Some(elab_val) = self.value_to_elaborated_value.get(&best_value) {
+                        // Value is available; use it.
+                        trace!("elaborate: value {} -> {:?}", value, elab_val);
+                        self.stats.elaborate_memoize_hit += 1;
+                        self.elab_result_stack.push(*elab_val);
+                        continue;
+                    }
 
-                    let remat = if let Some(elab_val) =
-                        self.value_to_elaborated_value.get(&canonical_value)
-                    {
-                        // Value is available. Look at the defined
-                        // block, and determine whether this node kind
-                        // allows rematerialization if the value comes
-                        // from another block. If so, ignore the hit
-                        // and recompute below.
-                        let remat = elab_val.in_block != self.cur_block
-                            && self.remat_values.contains(&best_value);
-                        if !remat {
-                            trace!("elaborate: value {} -> {:?}", value, elab_val);
-                            self.stats.elaborate_memoize_hit += 1;
-                            self.elab_result_stack.push(*elab_val);
-                            continue;
-                        }
-                        trace!("elaborate: value {} -> remat", canonical_value);
-                        self.stats.elaborate_memoize_miss_remat += 1;
-                        // The op is pure at this point, so it is always valid to
-                        // remove from this map.
-                        self.value_to_elaborated_value.remove(&canonical_value);
-                        true
-                    } else {
-                        // Value not available; but still look up
-                        // whether it's been flagged for remat because
-                        // this affects placement.
-                        let remat = self.remat_values.contains(&best_value);
-                        trace!(" -> not present in map; remat = {}", remat);
-                        remat
-                    };
                     self.stats.elaborate_memoize_miss += 1;
 
                     // Now resolve the value to its definition to see
@@ -363,7 +483,6 @@ impl<'a> Elaborator<'a> {
                         inst,
                         result_idx,
                         num_args,
-                        remat,
                         before,
                     });
 
@@ -376,21 +495,17 @@ impl<'a> Elaborator<'a> {
                     }
                 }
 
-                &ElabStackEntry::PendingInst {
+                ElabStackEntry::PendingInst {
                     inst,
                     result_idx,
                     num_args,
-                    remat,
                     before,
                 } => {
-                    self.elab_stack.pop();
-
                     trace!(
-                        "PendingInst: {} result {} args {} remat {} before {}",
+                        "PendingInst: {} result {} args {} before {}",
                         inst,
                         result_idx,
                         num_args,
-                        remat,
                         before
                     );
 
@@ -398,7 +513,7 @@ impl<'a> Elaborator<'a> {
                     // point. Grab them and drain them out, removing
                     // them.
                     let arg_idx = self.elab_result_stack.len() - num_args;
-                    let arg_values = &self.elab_result_stack[arg_idx..];
+                    let arg_values = &mut self.elab_result_stack[arg_idx..];
 
                     // Compute max loop depth.
                     //
@@ -444,16 +559,15 @@ impl<'a> Elaborator<'a> {
 
                     // We know that this is a pure inst, because
                     // non-pure roots have already been placed in the
-                    // value-to-elab'd-value map and are never subject
-                    // to remat, so they will not reach this stage of
-                    // processing.
+                    // value-to-elab'd-value map, so they will not
+                    // reach this stage of processing.
                     //
                     // We now must determine the location at which we
                     // place the instruction. This is the current
                     // block *unless* we hoist above a loop when all
                     // args are loop-invariant (and this op is pure).
                     let (scope_depth, before, insert_block) =
-                        if loop_hoist_level == self.loop_stack.len() || remat {
+                        if loop_hoist_level == self.loop_stack.len() {
                             // Depends on some value at the current
                             // loop depth, or remat forces it here:
                             // place it at the current location.
@@ -469,11 +583,7 @@ impl<'a> Elaborator<'a> {
                             let data = &self.loop_stack[loop_hoist_level];
                             // `data.hoist_block` should dominate `before`'s block.
                             let before_block = self.func.layout.inst_block(before).unwrap();
-                            debug_assert!(self.domtree.dominates(
-                                data.hoist_block,
-                                before_block,
-                                &self.func.layout
-                            ));
+                            debug_assert!(self.domtree.dominates(data.hoist_block, before_block));
                             // Determine the instruction at which we
                             // insert in `data.hoist_block`.
                             let before = self.func.layout.last_inst(data.hoist_block).unwrap();
@@ -486,16 +596,39 @@ impl<'a> Elaborator<'a> {
                         insert_block
                     );
 
-                    //  Now we need to place `inst` at the computed
-                    //  location (just before `before`). Note that
-                    //  `inst` may already have been placed somewhere
-                    //  else, because a pure node may be elaborated at
-                    //  more than one place. In this case, we need to
-                    //  duplicate the instruction (and return the
-                    //  `Value`s for that duplicated instance
-                    //  instead).
+                    // Now that we have the location for the
+                    // instruction, check if any of its args are remat
+                    // values. If so, and if we don't have a copy of
+                    // the rematerializing instruction for this block
+                    // yet, create one.
+                    let mut remat_arg = false;
+                    for arg_value in arg_values.iter_mut() {
+                        if Self::maybe_remat_arg(
+                            &self.remat_values,
+                            &mut self.func,
+                            &mut self.remat_copies,
+                            insert_block,
+                            before,
+                            arg_value,
+                            &mut self.stats,
+                        ) {
+                            remat_arg = true;
+                        }
+                    }
+
+                    // Now we need to place `inst` at the computed
+                    // location (just before `before`). Note that
+                    // `inst` may already have been placed somewhere
+                    // else, because a pure node may be elaborated at
+                    // more than one place. In this case, we need to
+                    // duplicate the instruction (and return the
+                    // `Value`s for that duplicated instance instead).
+                    //
+                    // Also clone if we rematerialized, because we
+                    // don't want to rewrite the args in the original
+                    // copy.
                     trace!("need inst {} before {}", inst, before);
-                    let inst = if self.func.layout.inst_block(inst).is_some() {
+                    let inst = if self.func.layout.inst_block(inst).is_some() || remat_arg {
                         // Clone the inst!
                         let new_inst = self.func.dfg.clone_inst(inst);
                         trace!(
@@ -517,16 +650,14 @@ impl<'a> Elaborator<'a> {
                                 value: new_result,
                                 in_block: insert_block,
                             };
-                            let canonical_result = self.eclasses.find_and_update(result);
+                            let best_result = self.value_to_best_value[result];
                             self.value_to_elaborated_value.insert_if_absent_with_depth(
-                                canonical_result,
+                                best_result.1,
                                 elab_value,
                                 scope_depth,
                             );
 
-                            self.eclasses.add(new_result);
-                            self.eclasses.union(result, new_result);
-                            self.value_to_best_value[new_result] = self.value_to_best_value[result];
+                            self.value_to_best_value[new_result] = best_result;
 
                             trace!(
                                 " -> cloned inst has new result {} for orig {}",
@@ -545,9 +676,9 @@ impl<'a> Elaborator<'a> {
                                 value: result,
                                 in_block: insert_block,
                             };
-                            let canonical_result = self.eclasses.find_and_update(result);
+                            let best_result = self.value_to_best_value[result];
                             self.value_to_elaborated_value.insert_if_absent_with_depth(
-                                canonical_result,
+                                best_result.1,
                                 elab_value,
                                 scope_depth,
                             );
@@ -555,7 +686,13 @@ impl<'a> Elaborator<'a> {
                         }
                         inst
                     };
+
                     // Place the inst just before `before`.
+                    assert!(
+                        is_pure_for_egraph(self.func, inst),
+                        "something has gone very wrong if we are elaborating effectful \
+                         instructions, they should have remained in the skeleton"
+                    );
                     self.func.layout.insert_inst(inst, before);
 
                     // Update the inst's arguments.
@@ -612,7 +749,16 @@ impl<'a> Elaborator<'a> {
                 // Elaborate the arg, placing any newly-inserted insts
                 // before `before`. Get the updated value, which may
                 // be different than the original.
-                let new_arg = self.elaborate_eclass_use(*arg, before);
+                let mut new_arg = self.elaborate_eclass_use(*arg, before);
+                Self::maybe_remat_arg(
+                    &self.remat_values,
+                    &mut self.func,
+                    &mut self.remat_copies,
+                    block,
+                    inst,
+                    &mut new_arg,
+                    &mut self.stats,
+                );
                 trace!("   -> rewrote arg to {:?}", new_arg);
                 *arg = new_arg.value;
             }
@@ -624,9 +770,9 @@ impl<'a> Elaborator<'a> {
             // map now.
             for &result in self.func.dfg.inst_results(inst) {
                 trace!(" -> result {}", result);
-                let canonical_result = self.eclasses.find_and_update(result);
+                let best_result = self.value_to_best_value[result];
                 self.value_to_elaborated_value.insert_if_absent(
-                    canonical_result,
+                    best_result.1,
                     ElaboratedValue {
                         in_block: block,
                         value: result,
@@ -638,10 +784,9 @@ impl<'a> Elaborator<'a> {
         }
     }
 
-    fn elaborate_domtree(&mut self, domtree: &DomTreeWithChildren) {
-        let root = domtree.root();
+    fn elaborate_domtree(&mut self, domtree: &DominatorTreePreorder) {
         self.block_stack.push(BlockStackEntry::Elaborate {
-            block: root,
+            block: self.func.layout.entry_block().unwrap(),
             idom: None,
         });
 
@@ -661,7 +806,7 @@ impl<'a> Elaborator<'a> {
                     // traversal so we do this after processing this
                     // block above.
                     let block_stack_end = self.block_stack.len();
-                    for child in domtree.children(block) {
+                    for child in self.ctrl_plane.shuffled(domtree.children(block)) {
                         self.block_stack.push(BlockStackEntry::Elaborate {
                             block: child,
                             idom: Some(block),
@@ -684,7 +829,7 @@ impl<'a> Elaborator<'a> {
         self.stats.elaborate_func += 1;
         self.stats.elaborate_func_pre_insts += self.func.dfg.num_insts() as u64;
         self.compute_best_values();
-        self.elaborate_domtree(&self.domtree_children);
+        self.elaborate_domtree(&self.domtree);
         self.stats.elaborate_func_post_insts += self.func.dfg.num_insts() as u64;
     }
 }
diff --git a/cranelift/codegen/src/flowgraph.rs b/cranelift/codegen/src/flowgraph.rs
index fa62d3caebda..b8bc848ad0c6 100644
--- a/cranelift/codegen/src/flowgraph.rs
+++ b/cranelift/codegen/src/flowgraph.rs
@@ -197,7 +197,7 @@ pub type SuccIter<'a> = bforest::SetIter<'a, Block>;
 mod tests {
     use super::*;
     use crate::cursor::{Cursor, FuncCursor};
-    use crate::ir::{types, Function, InstBuilder};
+    use crate::ir::{types, InstBuilder};
     use alloc::vec::Vec;
 
     #[test]
diff --git a/cranelift/codegen/src/fpconst.isle b/cranelift/codegen/src/fpconst.isle
new file mode 100644
index 000000000000..799951b7d3f9
--- /dev/null
+++ b/cranelift/codegen/src/fpconst.isle
@@ -0,0 +1,81 @@
+;; GENERATED BY `fpconst`. DO NOT EDIT!!!
+
+; Build one as a floating-point of the given width.
+(macro (fp_one w)
+    (conv_to w
+        (switch w
+            (32 #x000000003f800000)
+            (64 #x3ff0000000000000)
+       )
+    )
+)
+
+; Build negative one as a floating-point of the given width.
+(macro (fp_minus_one w)
+    (conv_to w
+        (switch w
+            (32 #x00000000bf800000)
+            (64 #xbff0000000000000)
+       )
+    )
+)
+
+; Build half as a floating-point of the given width.
+(macro (fp_half w)
+    (conv_to w
+        (switch w
+            (32 #x000000003f000000)
+            (64 #x3fe0000000000000)
+       )
+    )
+)
+
+; Build negative half as a floating-point of the given width.
+(macro (fp_minus_half w)
+    (conv_to w
+        (switch w
+            (32 #x00000000bf000000)
+            (64 #xbfe0000000000000)
+       )
+    )
+)
+
+; Build 32-bit integer minimum as a floating-point of the given width.
+(macro (fp_i32_min w)
+    (conv_to w
+        (switch w
+            (32 #x00000000cf000000)
+            (64 #xc1e0000000000000)
+       )
+    )
+)
+
+; Build negative 32-bit integer minimum as a floating-point of the given width.
+(macro (fp_minus_i32_min w)
+    (conv_to w
+        (switch w
+            (32 #x000000004f000000)
+            (64 #x41e0000000000000)
+       )
+    )
+)
+
+; Build 64-bit integer minimum as a floating-point of the given width.
+(macro (fp_i64_min w)
+    (conv_to w
+        (switch w
+            (32 #x00000000df000000)
+            (64 #xc3e0000000000000)
+       )
+    )
+)
+
+; Build negative 64-bit integer minimum as a floating-point of the given width.
+(macro (fp_minus_i64_min w)
+    (conv_to w
+        (switch w
+            (32 #x000000005f000000)
+            (64 #x43e0000000000000)
+       )
+    )
+)
diff --git a/cranelift/codegen/src/fx.rs b/cranelift/codegen/src/fx.rs
deleted file mode 100644
index bb1a9e59e6c6..000000000000
--- a/cranelift/codegen/src/fx.rs
+++ /dev/null
@@ -1,106 +0,0 @@
-// This file is taken from the Rust compiler: src/librustc_data_structures/fx.rs
-
-// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use super::{HashMap, HashSet};
-use core::default::Default;
-use core::hash::{BuildHasherDefault, Hash, Hasher};
-use core::ops::BitXor;
-
-pub type FxHashMap<K, V> = HashMap<K, V, BuildHasherDefault<FxHasher>>;
-pub type FxHashSet<V> = HashSet<V, BuildHasherDefault<FxHasher>>;
-
-#[allow(non_snake_case)]
-pub fn FxHashMap<K: Hash + Eq, V>() -> FxHashMap<K, V> {
-    HashMap::default()
-}
-
-/// A speedy hash algorithm for use within rustc. The hashmap in liballoc
-/// by default uses SipHash which isn't quite as speedy as we want. In the
-/// compiler we're not really worried about DOS attempts, so we use a fast
-/// non-cryptographic hash.
-///
-/// This is the same as the algorithm used by Firefox -- which is a homespun
-/// one not based on any widely-known algorithm -- though modified to produce
-/// 64-bit hash values instead of 32-bit hash values. It consistently
-/// out-performs an FNV-based hash within rustc itself -- the collision rate is
-/// similar or slightly worse than FNV, but the speed of the hash function
-/// itself is much higher because it works on up to 8 bytes at a time.
-pub struct FxHasher {
-    hash: usize,
-}
-
-#[cfg(target_pointer_width = "32")]
-const K: usize = 0x9e3779b9;
-#[cfg(target_pointer_width = "64")]
-const K: usize = 0x517cc1b727220a95;
-
-impl Default for FxHasher {
-    #[inline]
-    fn default() -> Self {
-        Self { hash: 0 }
-    }
-}
-
-impl FxHasher {
-    #[inline]
-    fn add_to_hash(&mut self, i: usize) {
-        self.hash = self.hash.rotate_left(5).bitxor(i).wrapping_mul(K);
-    }
-}
-
-impl Hasher for FxHasher {
-    #[inline]
-    fn write(&mut self, bytes: &[u8]) {
-        for byte in bytes {
-            let i = *byte;
-            self.add_to_hash(i as usize);
-        }
-    }
-
-    #[inline]
-    fn write_u8(&mut self, i: u8) {
-        self.add_to_hash(i as usize);
-    }
-
-    #[inline]
-    fn write_u16(&mut self, i: u16) {
-        self.add_to_hash(i as usize);
-    }
-
-    #[inline]
-    fn write_u32(&mut self, i: u32) {
-        self.add_to_hash(i as usize);
-    }
-
-    #[cfg(target_pointer_width = "32")]
-    #[inline]
-    fn write_u64(&mut self, i: u64) {
-        self.add_to_hash(i as usize);
-        self.add_to_hash((i >> 32) as usize);
-    }
-
-    #[cfg(target_pointer_width = "64")]
-    #[inline]
-    fn write_u64(&mut self, i: u64) {
-        self.add_to_hash(i as usize);
-    }
-
-    #[inline]
-    fn write_usize(&mut self, i: usize) {
-        self.add_to_hash(i);
-    }
-
-    #[inline]
-    fn finish(&self) -> u64 {
-        self.hash as u64
-    }
-}
diff --git a/cranelift/codegen/src/incremental_cache.rs b/cranelift/codegen/src/incremental_cache.rs
index 6290e55f84b1..89e42cf242a0 100644
--- a/cranelift/codegen/src/incremental_cache.rs
+++ b/cranelift/codegen/src/incremental_cache.rs
@@ -10,11 +10,11 @@
 //!
 //! The three main primitives are the following:
 //! - `compute_cache_key` is used to compute the cache key associated to a `Function`. This is
-//! basically the content of the function, modulo a few things the caching system is resilient to.
+//!   basically the content of the function, modulo a few things the caching system is resilient to.
 //! - `serialize_compiled` is used to serialize the result of a compilation, so it can be reused
-//! later on by...
+//!   later on by...
 //! - `try_finish_recompile`, which reads binary blobs serialized with `serialize_compiled`,
-//! re-creating the compilation artifact from those.
+//!   re-creating the compilation artifact from those.
 //!
 //! The `CacheStore` trait and `Context::compile_with_cache` method are provided as
 //! high-level, easy-to-use facilities to make use of that cache, and show an example of how to use
@@ -208,12 +208,12 @@ pub fn compute_cache_key(isa: &dyn TargetIsa, func: &Function) -> CacheKeyHash {
 /// of the function call. The value is left untouched.
 pub fn serialize_compiled(
     result: CompiledCodeStencil,
-) -> (CompiledCodeStencil, Result<Vec<u8>, bincode::Error>) {
+) -> (CompiledCodeStencil, Result<Vec<u8>, postcard::Error>) {
     let cached = CachedFunc {
         version_marker: VersionMarker,
         stencil: result,
     };
-    let result = bincode::serialize(&cached);
+    let result = postcard::to_allocvec(&cached);
     (cached.stencil, result)
 }
 
@@ -223,7 +223,7 @@ pub enum RecompileError {
     /// The version embedded in the cache entry isn't the same as cranelift's current version.
     VersionMismatch,
     /// An error occurred while deserializing the cache entry.
-    Deserialize(bincode::Error),
+    Deserialize(postcard::Error),
 }
 
 impl fmt::Display for RecompileError {
@@ -231,7 +231,7 @@ impl fmt::Display for RecompileError {
         match self {
             RecompileError::VersionMismatch => write!(f, "cranelift version mismatch",),
             RecompileError::Deserialize(err) => {
-                write!(f, "bincode failed during deserialization: {err}")
+                write!(f, "postcard failed during deserialization: {err}")
             }
         }
     }
@@ -243,7 +243,7 @@ impl fmt::Display for RecompileError {
 /// Precondition: the bytes must have retrieved from a cache store entry which hash value
 /// is strictly the same as the `Function`'s computed hash retrieved from `compute_cache_key`.
 pub fn try_finish_recompile(func: &Function, bytes: &[u8]) -> Result<CompiledCode, RecompileError> {
-    match bincode::deserialize::<CachedFunc>(bytes) {
+    match postcard::from_bytes::<CachedFunc>(bytes) {
         Ok(result) => {
             if result.version_marker != func.stencil.version_marker {
                 Err(RecompileError::VersionMismatch)
diff --git a/cranelift/codegen/src/inst_predicates.rs b/cranelift/codegen/src/inst_predicates.rs
index 707a01c1a5eb..e0000b726ee5 100644
--- a/cranelift/codegen/src/inst_predicates.rs
+++ b/cranelift/codegen/src/inst_predicates.rs
@@ -1,12 +1,6 @@
 //! Instruction predicates/properties, shared by various analyses.
 use crate::ir::immediates::Offset32;
-use crate::ir::{self, Block, DataFlowGraph, Function, Inst, InstructionData, Opcode, Type, Value};
-use cranelift_entity::EntityRef;
-
-/// Preserve instructions with used result values.
-pub fn any_inst_results_used(inst: Inst, live: &[bool], dfg: &DataFlowGraph) -> bool {
-    dfg.inst_results(inst).iter().any(|v| live[v.index()])
-}
+use crate::ir::{self, Block, Function, Inst, InstructionData, Opcode, Type, Value};
 
 /// Test whether the given opcode is unsafe to even consider as side-effect-free.
 #[inline(always)]
@@ -38,7 +32,7 @@ fn is_load_with_defined_trapping(opcode: Opcode, data: &InstructionData) -> bool
 /// Does the given instruction have any side-effect that would preclude it from being removed when
 /// its value is unused?
 #[inline(always)]
-pub fn has_side_effect(func: &Function, inst: Inst) -> bool {
+fn has_side_effect(func: &Function, inst: Inst) -> bool {
     let data = &func.dfg.insts[inst];
     let opcode = data.opcode();
     trivially_has_side_effects(opcode) || is_load_with_defined_trapping(opcode, data)
@@ -58,6 +52,7 @@ pub fn is_pure_for_egraph(func: &Function, inst: Inst) -> bool {
         } => flags.readonly() && flags.notrap(),
         _ => false,
     };
+
     // Multi-value results do not play nicely with much of the egraph
     // infrastructure. They are in practice used only for multi-return
     // calls and some other odd instructions (e.g. uadd_overflow) which,
@@ -102,12 +97,9 @@ pub fn has_lowering_side_effect(func: &Function, inst: Inst) -> bool {
 /// Is the given instruction a constant value (`iconst`, `fconst`) that can be
 /// represented in 64 bits?
 pub fn is_constant_64bit(func: &Function, inst: Inst) -> Option<u64> {
-    let data = &func.dfg.insts[inst];
-    if data.opcode() == Opcode::Null {
-        return Some(0);
-    }
-    match data {
+    match &func.dfg.insts[inst] {
         &InstructionData::UnaryImm { imm, .. } => Some(imm.bits() as u64),
+        &InstructionData::UnaryIeee16 { imm, .. } => Some(imm.bits() as u64),
         &InstructionData::UnaryIeee32 { imm, .. } => Some(imm.bits() as u64),
         &InstructionData::UnaryIeee64 { imm, .. } => Some(imm.bits()),
         _ => None,
@@ -116,8 +108,7 @@ pub fn is_constant_64bit(func: &Function, inst: Inst) -> Option<u64> {
 
 /// Get the address, offset, and access type from the given instruction, if any.
 pub fn inst_addr_offset_type(func: &Function, inst: Inst) -> Option<(Value, Offset32, Type)> {
-    let data = &func.dfg.insts[inst];
-    match data {
+    match &func.dfg.insts[inst] {
         InstructionData::Load { arg, offset, .. } => {
             let ty = func.dfg.value_type(func.dfg.inst_results(inst)[0]);
             Some((*arg, *offset, ty))
@@ -140,8 +131,7 @@ pub fn inst_addr_offset_type(func: &Function, inst: Inst) -> Option<(Value, Offs
 
 /// Get the store data, if any, from an instruction.
 pub fn inst_store_data(func: &Function, inst: Inst) -> Option<Value> {
-    let data = &func.dfg.insts[inst];
-    match data {
+    match &func.dfg.insts[inst] {
         InstructionData::Store { args, .. } | InstructionData::StoreNoOffset { args, .. } => {
             Some(args[0])
         }
diff --git a/cranelift/codegen/src/inst_specs.isle b/cranelift/codegen/src/inst_specs.isle
new file mode 100644
index 000000000000..7fac40d5e3cc
--- /dev/null
+++ b/cranelift/codegen/src/inst_specs.isle
@@ -0,0 +1,1404 @@
+;;;; Verification Type Models ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(model Imm64 (type (bv 64)))
+
+(model Ieee32 (type (bv 32)))
+(model Ieee64 (type (bv 64)))
+
+; REVIEW(mbm): do we need to model MemFlags?
+(model MemFlags (type
+    (struct
+        (aligned Bool)
+        (trapcode (bv 4))
+    )
+))
+
+(model Offset32 (type (bv 32)))
+
+;;;; State Definitions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; Value loaded from memory.
+;
+; We deliberately do not attempt to model the entire state of memory. Modeling a
+; loaded value this way allows us to express the fact that loaded values on CLIF
+; and ISA side will be equivalent (combined with an assertion on address
+; equality).
+(state loaded_value
+    (type (bv 64))
+    (default true)
+)
+
+; Parameters of a CLIF load operation.
+(state clif_load
+    (type
+        (struct
+            (active Bool)
+            (size_bits Int)
+            (addr (bv 64))
+        )
+    )
+    (default
+        (not (:active clif_load))
+    )
+)
+
+; Parameters of a CLIF store operation.
+(state clif_store
+    (type
+        (struct
+            (active Bool)
+            (size_bits Int)
+            (addr (bv 64))
+            (value (bv 64))
+        )
+    )
+    (default
+        (and
+            ; Store is not active.
+            (not (:active clif_store))
+
+            ; Must provide a fixed size in the default case, otherwise type
+            ; inference is underconstrained.
+            (= (:size_bits clif_store) 1)
+        )
+    )
+)
+
+; Whether a trap is expected according to CLIF semantics.
+(state clif_trap
+    (type Bool)
+    (default (not clif_trap))
+)
+
+;;;; Common Term Forms ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(form
+    bv_unary_8_to_64
+    ((args (named Type) (bv  8)) (ret (bv  8)))
+    ((args (named Type) (bv 16)) (ret (bv 16)))
+    ((args (named Type) (bv 32)) (ret (bv 32)))
+    ((args (named Type) (bv 64)) (ret (bv 64)))
+)
+
+(form
+    bv_binary_8_to_64
+    ((args (named Type) (bv  8) (bv  8)) (ret (bv  8)))
+    ((args (named Type) (bv 16) (bv 16)) (ret (bv 16)))
+    ((args (named Type) (bv 32) (bv 32)) (ret (bv 32)))
+    ((args (named Type) (bv 64) (bv 64)) (ret (bv 64)))
+)
+
+(form
+    bv_ternary_8_to_64
+    ((args (named Type) (bv  8) (bv  8) (bv  8)) (ret (bv  8)))
+    ((args (named Type) (bv 16) (bv 16) (bv 16)) (ret (bv 16)))
+    ((args (named Type) (bv 32) (bv 32) (bv 32)) (ret (bv 32)))
+    ((args (named Type) (bv 64) (bv 64) (bv 64)) (ret (bv 64)))
+)
+
+;;;; i128 bit cases ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(form
+    bv_binary_8_to_128
+    ((args (named Type) (bv  8) (bv  8)) (ret (bv  8)))
+    ((args (named Type) (bv 16) (bv 16)) (ret (bv 16)))
+    ((args (named Type) (bv 32) (bv 32)) (ret (bv 32)))
+    ((args (named Type) (bv 64) (bv 64)) (ret (bv 64)))
+    ((args (named Type) (bv 128) (bv 128)) (ret (bv 128)))
+)
+
+;;;; CLIF Instruction Specifications ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Integer Instructions
+
+(spec (iadd ty x y)
+    (provide (= result (bvadd x y))))
+(instantiate iadd
+    ((args (named Type) (bv 8) (bv 8)) (ret (bv 8)))
+    ((args (named Type) (bv 16) (bv 16)) (ret (bv 16)))
+    ((args (named Type) (bv 32) (bv 32)) (ret (bv 32)))
+    ((args (named Type) (bv 64) (bv 64)) (ret (bv 64)))
+    ((args (named Type) (bv 128) (bv 128)) (ret (bv 128)))
+)
+
+(spec (isub ty x y)
+    (provide (= result (bvsub x y))))
+(instantiate isub bv_binary_8_to_64)
+
+(spec (ineg ty x)
+    (provide (= result (bvneg x))))
+(instantiate ineg bv_unary_8_to_64)
+
+(spec (iabs ty x)
+    (provide (= result (if (bvsge x (zero_ext (widthof x) #b0)) x (bvneg x)))))
+(instantiate iabs bv_unary_8_to_64)
+
+(spec (imul ty x y)
+    (provide (= result (bvmul x y))))
+(instantiate imul bv_binary_8_to_64)
+
+(spec (smulhi ty x y)
+    (provide
+        (let
+            (
+                (double (concat x x))
+                (double_width (widthof double))
+                (xwide (sign_ext double_width x))
+                (ywide (sign_ext double_width y))
+            )
+            (with (low)
+                (= (concat result low) (bvmul xwide ywide))
+            )
+        )
+    )
+)
+(instantiate smulhi bv_binary_8_to_64)
+
+(spec (umulhi ty x y)
+    (provide
+        (let
+            (
+                (double (concat x x))
+                (double_width (widthof double))
+                (xwide (zero_ext double_width x))
+                (ywide (zero_ext double_width y))
+            )
+            (with (low)
+                (= (concat result low) (bvmul xwide ywide))
+            )
+        )
+    )
+)
+(instantiate umulhi bv_binary_8_to_64)
+
+(spec (udiv ty x y)
+    (modifies clif_trap)
+    (provide
+        (= result (bvudiv x y))
+        (= clif_trap (bv_is_zero! y))
+    )
+)
+(instantiate udiv bv_binary_8_to_64)
+
+(spec (sdiv ty x y)
+    (modifies clif_trap)
+    (provide
+        ; If j2 is 0, then the result is undefined.
+        (if (bv_is_zero! y)
+            clif_trap
+        ; Else if j1 divided by j2 is 2^{N−1}, then the result is undefined.
+        ;
+        ; Note: the only way this can happen is the case (−2^{N−1})/(−1).
+        (if (and
+                ; x is -2^{N-1}
+                (= x (bv_top_bit_set! (widthof x)))
+                ; y is -1
+                (bv_is_zero! (bvnot y))
+            )
+            clif_trap
+        ; Else, return the result of dividing j1 by j2, truncated toward zero.
+            (and
+                (not clif_trap)
+                (= result (bvsdiv x y))
+            )
+        ))
+    )
+)
+
+(instantiate sdiv bv_binary_8_to_64)
+(spec (urem ty x y)
+    (modifies clif_trap)
+    (provide
+        ; If i2 is 0, then the result is undefined.
+        (if (bv_is_zero! y)
+            clif_trap
+        ; Else, return the remainder of dividing i1 by i2.
+            (and
+                (not clif_trap)
+                (= result (bvurem x y))
+            )
+        )
+    )
+)
+(instantiate urem bv_binary_8_to_64)
+
+(spec (srem ty x y)
+    (modifies clif_trap)
+    (provide
+        ; Let j1 be the signed interpretation of i1.
+        ; Let j2 be the signed interpretation of i2.
+        ; If i2 is 0, then the result is undefined.
+        (if (bv_is_zero! y)
+            clif_trap
+        ; Else, return the remainder of dividing j1 by j2, with the sign of the dividend j1.
+            (and
+                (not clif_trap)
+                ; REVIEW(mbm): does bvsrem have the same semantics as wasm?
+                (= result (bvsrem x y))
+
+            )
+        )
+    )
+)
+(instantiate srem bv_binary_8_to_64)
+
+;; "Unsigned addition of x and y, trapping if the result overflows."
+;; "Accepts 32 or 64-bit integers, and does not support vector types."
+(spec (uadd_overflow_trap ty x y trap_code)
+    (modifies clif_trap)
+    (provide
+        (let
+            (
+                (N (widthof x))
+                ;; Use at least 1 extra bit for unsigned overflow
+                (sum (bvadd (zero_ext 65 x) (zero_ext 65 y)))
+                ;; Unsigned overflow if some carry out.
+                (carry
+                    (switch N
+                        (32 (extract 32 32 sum))
+                        (64 (extract 64 64 sum))))
+            )
+            (if (= carry #b1)
+                clif_trap
+                (and
+                    (not clif_trap)
+                    (= result (conv_to N sum))
+                )
+            )
+        )
+    )
+)
+
+(instantiate uadd_overflow_trap
+    ((args (named Type) (bv 32) (bv 32) (named TrapCode)) (ret (bv 32)))
+    ((args (named Type) (bv 64) (bv 64) (named TrapCode)) (ret (bv 64)))
+)
+
+
+(spec (iconst ty arg)
+    (provide (= arg (zero_ext 64 result))))
+(instantiate iconst
+    ((args (named Type) (bv 64)) (ret (bv 8)))
+    ((args (named Type) (bv 64)) (ret (bv 16)))
+    ((args (named Type) (bv 64)) (ret (bv 32)))
+    ((args (named Type) (bv 64)) (ret (bv 64)))
+ )
+
+(spec (ishl ty x y)
+    (provide
+        (= result
+            (bvshl
+                x
+                (bvand y (conv_to (widthof y) (bvsub (int2bv 64 (widthof y)) #x0000000000000001)))
+            )
+        )
+    )
+)
+(instantiate ishl bv_binary_8_to_64)
+
+(spec (ushr ty x y)
+    (provide
+        (= result
+            (bvlshr
+                x
+                (bvand y (conv_to (widthof y) (bvsub (int2bv 64 (widthof y)) #x0000000000000001)))
+            )
+        )
+    )
+)
+(instantiate ushr bv_binary_8_to_64)
+
+(spec (sshr ty x y)
+    (provide
+        (= result
+            (bvashr
+                x
+                (bvand y (conv_to (widthof y) (bvsub (int2bv 64 (widthof y)) #x0000000000000001)))
+            )
+        )
+    )
+)
+(instantiate sshr bv_binary_8_to_64)
+
+(spec (band ty x y)
+    (provide (= result (bvand x y))))
+(instantiate band bv_binary_8_to_64)
+
+(spec (bxor ty x y)
+    (provide (= result (bvxor x y))))
+(instantiate bxor bv_binary_8_to_64)
+
+(spec (bor ty x y)
+    (provide (= result (bvor x y))))
+(instantiate bor bv_binary_8_to_64)
+
+(spec (bnot ty x)
+    (provide (= result (bvnot x))))
+(instantiate bnot bv_unary_8_to_64)
+
+(spec (rotl ty x y)
+    (provide (= result (rotl x y))))
+(instantiate rotl bv_binary_8_to_64)
+
+(spec (rotr ty x y)
+    (provide (= result (rotr x y))))
+(instantiate rotr bv_binary_8_to_64)
+
+(spec (bitselect ty c x y)
+    (provide (= result (bvor (bvand c x) (bvand (bvnot c) y)))))
+(instantiate bitselect bv_ternary_8_to_64)
+
+(spec (cls ty x) (provide (= result (cls x))))
+(instantiate cls bv_unary_8_to_64)
+
+(spec (clz ty x)
+    (provide (= result (clz x))))
+(instantiate clz bv_unary_8_to_64)
+
+(spec (ctz ty x)
+    (provide (= result (clz (rev x)))))
+(instantiate ctz bv_unary_8_to_64)
+
+(spec (popcnt ty x)
+    (provide (= result (popcnt x))))
+(instantiate popcnt bv_unary_8_to_64)
+
+(spec (ireduce ty x)
+    (provide (= result (conv_to (widthof result) x))))
+(instantiate ireduce
+    ((args (named Type) (bv 16)) (ret (bv  8)))
+    ((args (named Type) (bv 32)) (ret (bv  8)))
+    ((args (named Type) (bv 64)) (ret (bv  8)))
+    ((args (named Type) (bv 32)) (ret (bv 16)))
+    ((args (named Type) (bv 64)) (ret (bv 16)))
+    ((args (named Type) (bv 64)) (ret (bv 32)))
+)
+
+
+
+(form extend
+    ((args (named Type) (bv  8)) (ret (bv  8)))
+    ((args (named Type) (bv  8)) (ret (bv 16)))
+    ((args (named Type) (bv  8)) (ret (bv 32)))
+    ((args (named Type) (bv  8)) (ret (bv 64)))
+    ((args (named Type) (bv 16)) (ret (bv 16)))
+    ((args (named Type) (bv 16)) (ret (bv 32)))
+    ((args (named Type) (bv 16)) (ret (bv 64)))
+    ((args (named Type) (bv 32)) (ret (bv 32)))
+    ((args (named Type) (bv 32)) (ret (bv 64)))
+    ;; Note: (bv 64) -> (bv 64) not accepted in clif
+)
+
+(spec (uextend ty x)
+    (provide (= result (zero_ext (widthof result) x))))
+(instantiate uextend extend)
+
+(spec (sextend ty x)
+    (provide (= result (sign_ext (widthof result) x))))
+(instantiate sextend extend)
+
+(spec (smin ty x y)
+    (provide (= result (if (bvsle x y) x y))))
+(instantiate smin bv_binary_8_to_64)
+
+(spec (umin ty x y)
+    (provide (= result (if (bvule x y) x y))))
+(instantiate umin bv_binary_8_to_64)
+
+(spec (smax ty x y)
+    (provide (= result (if (bvsge x y) x y))))
+(instantiate smax bv_binary_8_to_64)
+
+(spec (umax ty x y)
+    (provide (= result (if (bvuge x y) x y))))
+(instantiate umax bv_binary_8_to_64)
+
+(spec (icmp ty cc x y)
+    (provide
+        (= result
+            (if
+                (match cc
+                    ((Equal) (= x y))
+                    ((NotEqual) (not (= x y)))
+                    ((SignedGreaterThan) (bvsgt x y))
+                    ((SignedGreaterThanOrEqual) (bvsge x y))
+                    ((SignedLessThan) (bvslt x y))
+                    ((SignedLessThanOrEqual) (bvsle x y))
+                    ((UnsignedGreaterThan) (bvugt x y))
+                    ((UnsignedGreaterThanOrEqual) (bvuge x y))
+                    ((UnsignedLessThan) (bvult x y))
+                    ((UnsignedLessThanOrEqual) (bvule x y))
+                )
+                #x01
+                #x00
+            )
+        )
+    )
+)
+(instantiate icmp
+    ((args (named Type) (named IntCC) (bv  8) (bv  8)) (ret (bv 8)))
+    ((args (named Type) (named IntCC) (bv 16) (bv 16)) (ret (bv 8)))
+    ((args (named Type) (named IntCC) (bv 32) (bv 32)) (ret (bv 8)))
+    ((args (named Type) (named IntCC) (bv 64) (bv 64)) (ret (bv 8)))
+)
+
+;; Load Instructions
+
+; Compute the effective address of a base pointer p and fixed offset.
+(macro (effective_address p offset)
+    (bvadd p (sign_ext 64 offset))
+)
+
+; Activate and set parameters of a CLIF load effect.
+(macro (clif_load_activate clif_load size_bits p offset)
+    (and
+        (:active clif_load)
+        (= (:size_bits clif_load) size_bits)
+        (= (:addr clif_load) (effective_address! p offset))
+    )
+)
+
+; Load from memory
+(spec (load ty flags p offset)
+    (modifies clif_load)
+    (modifies loaded_value)
+    (provide
+        ; Activate the CLIF load effect.
+        (clif_load_activate! clif_load (widthof result) p offset)
+
+        ; Result of the load is represented by low bits of the loaded value state register.
+        (= result (conv_to (widthof result) loaded_value))
+    )
+)
+(instantiate load
+    ((args (named Type) (named MemFlags) (named Value) (named Offset32)) (ret (bv  8)))
+    ((args (named Type) (named MemFlags) (named Value) (named Offset32)) (ret (bv 16)))
+    ((args (named Type) (named MemFlags) (named Value) (named Offset32)) (ret (bv 32)))
+    ((args (named Type) (named MemFlags) (named Value) (named Offset32)) (ret (bv 64)))
+)
+
+; Unsigned N-bit load
+(macro (uloadN clif_load size_bits p offset loaded_value result)
+    (and
+        ; Activate the CLIF load effect.
+        (clif_load_activate! clif_load size_bits p offset)
+
+        ; Loaded value is zero-extended.
+        (= result (zero_ext (widthof result) (conv_to size_bits loaded_value)))
+    )
+)
+
+; Unsigned 8-bit load
+(spec (uload8 ty flags p offset)
+    (modifies clif_load)
+    (modifies loaded_value)
+    (provide (uloadN! clif_load 8 p offset loaded_value result))
+)
+(instantiate uload8
+    ((args (named Type) (named MemFlags) (named Value) (named Offset32)) (ret (bv 16)))
+    ((args (named Type) (named MemFlags) (named Value) (named Offset32)) (ret (bv 32)))
+    ((args (named Type) (named MemFlags) (named Value) (named Offset32)) (ret (bv 64)))
+)
+
+; Unsigned 16-bit load
+(spec (uload16 ty flags p offset)
+    (modifies clif_load)
+    (modifies loaded_value)
+    (provide (uloadN! clif_load 16 p offset loaded_value result))
+)
+(instantiate uload16
+    ((args (named Type) (named MemFlags) (named Value) (named Offset32)) (ret (bv 32)))
+    ((args (named Type) (named MemFlags) (named Value) (named Offset32)) (ret (bv 64)))
+)
+
+; Unsigned 32-bit load
+(spec (uload32 ty flags p offset)
+    (modifies clif_load)
+    (modifies loaded_value)
+    (provide (uloadN! clif_load 32 p offset loaded_value result))
+)
+(instantiate uload32
+    ((args (named Type) (named MemFlags) (named Value) (named Offset32)) (ret (bv 64)))
+)
+
+; Signed N-bit load
+(macro (sloadN clif_load size_bits p offset loaded_value result)
+    (and
+        ; Activate the CLIF load effect.
+        (clif_load_activate! clif_load size_bits p offset)
+
+        ; Loaded value is sign-extended.
+        (= result (sign_ext (widthof result) (conv_to size_bits loaded_value)))
+    )
+)
+
+; Signed 8-bit load
+(spec (sload8 ty flags p offset)
+    (modifies clif_load)
+    (modifies loaded_value)
+    (provide (sloadN! clif_load 8 p offset loaded_value result))
+)
+(instantiate sload8
+    ((args (named Type) (named MemFlags) (named Value) (named Offset32)) (ret (bv 16)))
+    ((args (named Type) (named MemFlags) (named Value) (named Offset32)) (ret (bv 32)))
+    ((args (named Type) (named MemFlags) (named Value) (named Offset32)) (ret (bv 64)))
+)
+
+; Signed 16-bit load
+(spec (sload16 ty flags p offset)
+    (modifies clif_load)
+    (modifies loaded_value)
+    (provide (sloadN! clif_load 16 p offset loaded_value result))
+)
+(instantiate sload16
+    ((args (named Type) (named MemFlags) (named Value) (named Offset32)) (ret (bv 32)))
+    ((args (named Type) (named MemFlags) (named Value) (named Offset32)) (ret (bv 64)))
+)
+
+; Signed 32-bit load
+(spec (sload32 ty flags p offset)
+    (modifies clif_load)
+    (modifies loaded_value)
+    (provide (sloadN! clif_load 32 p offset loaded_value result))
+)
+(instantiate sload32
+    ((args (named Type) (named MemFlags) (named Value) (named Offset32)) (ret (bv 64)))
+)
+
+; Loads have a large number of expansions and instantiations.
+(attr load (tag slow))
+(attr uload8 (tag slow))
+(attr uload16 (tag slow))
+(attr uload32 (tag slow))
+(attr sload8 (tag slow))
+(attr sload16 (tag slow))
+(attr sload32 (tag slow))
+
+;; Store Instructions
+
+; Activate and set parameters of a CLIF store effect.
+(macro (clif_store_activate clif_store value p offset)
+    (and
+        ; Activate the CLIF store effect
+        (:active clif_store)
+
+        ; TODO(mbm): store flags
+
+        ; Store size is the width of the stored value.
+        (= (:size_bits clif_store) (widthof value))
+
+        ; Address calculation.
+        (= (:addr clif_store) (effective_address! p offset))
+
+        ; Stored value is set to the low bits of the CLIF store value.
+        (= (conv_to (widthof value) (:value clif_store)) value)
+    )
+)
+
+; Store instruction specification.
+(macro (store clif_store flags value p offset result)
+    (and
+        ; Activate the CLIF store effect
+        (clif_store_activate! clif_store value p offset)
+
+        ; HACK: Result of the store is a 1-bit vector.
+        (= result #b1)
+    )
+)
+
+; Store to memory
+(spec (store flags value p offset)
+    (modifies clif_store)
+    (provide (store! clif_store flags value p offset result))
+)
+(instantiate store
+    ((args (named MemFlags) (bv  8) (named Value) (named Offset32)) (ret (bv 1)))
+    ((args (named MemFlags) (bv 16) (named Value) (named Offset32)) (ret (bv 1)))
+    ((args (named MemFlags) (bv 32) (named Value) (named Offset32)) (ret (bv 1)))
+    ((args (named MemFlags) (bv 64) (named Value) (named Offset32)) (ret (bv 1)))
+)
+
+; 8-bit store
+(spec (istore8 flags value p offset)
+    (modifies clif_store)
+    (provide (store! clif_store flags (extract 7 0 value) p offset result))
+)
+(instantiate istore8
+    ((args (named MemFlags) (bv 16) (named Value) (named Offset32)) (ret (bv 1)))
+    ((args (named MemFlags) (bv 32) (named Value) (named Offset32)) (ret (bv 1)))
+    ((args (named MemFlags) (bv 64) (named Value) (named Offset32)) (ret (bv 1)))
+)
+
+; 16-bit store
+(spec (istore16 flags value p offset)
+    (modifies clif_store)
+    (provide (store! clif_store flags (extract 15 0 value) p offset result))
+)
+(instantiate istore16
+    ((args (named MemFlags) (bv 32) (named Value) (named Offset32)) (ret (bv 1)))
+    ((args (named MemFlags) (bv 64) (named Value) (named Offset32)) (ret (bv 1)))
+)
+
+; 32-bit store
+(spec (istore32 flags value p offset)
+    (modifies clif_store)
+    (provide (store! clif_store flags (extract 31 0 value) p offset result))
+)
+(instantiate istore32
+    ((args (named MemFlags) (bv 64) (named Value) (named Offset32)) (ret (bv 1)))
+)
+
+; Stores have a large number of expansions and instantiations.
+(attr store (tag slow))
+(attr istore8 (tag slow))
+(attr istore16 (tag slow))
+(attr istore32 (tag slow))
+
+;; Floating Point Instructions
+
+; NaN Propagation: see WebAssembly Specification 2.0, section 4.3.3
+
+; Evaluates the positive WebAssembly canonical NaN of the given width.
+(macro (nan_canon w)
+    (conv_to w
+        (switch w
+            (32 #x000000007fc00000)
+            (64 #x7ff8000000000000)
+        )
+    )
+)
+
+; NaN propagation with zero inputs.
+;
+; The CLIF semantics (inherited from WebAssembly) only requires a NaN payload
+; with the top bit set. Our specification is a refinement, selecting the
+; positive canonical NaN.
+(macro (nans0 w) (nan_canon! w))
+
+; NaN propagation with one input.
+;
+; The CLIF semantics (inherited from WebAssembly) requires that a canonical NaN
+; input is preserved, while any other NaN is mapped to any arithmetic NaN (which
+; has the top fraction bit set).  Our chosen refinement is to return the NaN
+; input with the top fraction bit or-ed in: this both preserves the canonical
+; NaN and turns any other NaN into an arithmetic NaN.
+(macro (nans1 x) (if (fp.isNaN x) (bvor x (fp_topfrac_bit_set! (widthof x))) (nans0! (widthof x))))
+
+; NaN propagation with two inputs.
+;
+; The CLIF semantics (inherited from WebAssembly) requires that if both inputs
+; are canonical then the output must be. Otherwise the output must be an
+; arithmetic NaN. Our chosen refinement is to apply single-input NaN propagation
+; to the first input if it's a NaN, otherwise to the second input if it's a NaN,
+; and fallback to returning the canonical NaN.
+(macro (nans2 x y) (if (fp.isNaN x) (nans1! x) (if (fp.isNaN y) (nans1! y) (nans0! (widthof x)))))
+
+; NaN negation.
+;
+; The CLIF semantics (inherited from WebAssembly) requires that negating a NaN
+; flips the sign bit (rather than returning a nondeterministic NaN).
+(macro (nan_neg x)
+    (conv_to (widthof x)
+        (bvxor x (fp_sign_bit_set! (widthof x)))))
+
+; f32const: single-precision floating-point constant.
+(spec (f32const ty x) (provide (= result x)))
+(instantiate f32const ((args (named Type) (bv 32)) (ret (bv 32))))
+
+; f64const: double-precision floating-point constant.
+(spec (f64const ty x) (provide (= result x)))
+(instantiate f64const ((args (named Type) (bv 64)) (ret (bv 64))))
+
+; fcmp: floating-point compare.
+(spec (fcmp ty c x y)
+    (provide
+        ;; Restrict to operations used from Wasm for now
+        (or (= c (FloatCC.Equal))
+            (= c (FloatCC.NotEqual))
+            (= c (FloatCC.LessThan))
+            (= c (FloatCC.GreaterThan))
+            (= c (FloatCC.LessThanOrEqual))
+            (= c (FloatCC.GreaterThanOrEqual)))
+        (= result
+            (if
+                (match c
+                    ((Equal) (fp.eq x y))
+                    ((NotEqual) (fp.ne x y))
+                    ((LessThan) (fp.lt x y))
+                    ((GreaterThan) (fp.gt x y))
+                    ((LessThanOrEqual) (fp.le x y))
+                    ((GreaterThanOrEqual) (fp.ge x y))
+                )
+                #x01
+                #x00
+            )
+        )
+    )
+)
+(instantiate fcmp
+    ((args (named Type) (named FloatCC) (bv 32) (bv 32)) (ret (bv 8)))
+    ((args (named Type) (named FloatCC) (bv 64) (bv 64)) (ret (bv 8)))
+)
+
+; fadd: floating-point addition.
+;
+; Specification derived from WebAssembly Specification prose (Floating Point Numerics, section 4.3.3).
+(spec (fadd ty x y)
+    (provide
+        (= result
+            ; If either z1 or z2 is a NaN, then return an element of nans{z1,z2}.
+            (if (or (fp.isNaN x) (fp.isNaN y))
+                (nans2! x y)
+            ; Else if both z1 and z2 are infinities of opposite signs, then return an element of nans{}.
+            (if (and (fp.isInfinite x) (fp.isInfinite y) (fp_opposite_sign! x y))
+                (nans0! (widthof x))
+            ; Else if both z1 and z2 are infinities of equal sign, then return that infinity.
+            (if (and (fp.isInfinite x) (fp.isInfinite y) (fp_equal_sign! x y))
+                x
+            ; Else if either z1 or z2 is an infinity, then return that infinity.
+            (if (fp.isInfinite x)
+                x
+            (if (fp.isInfinite y)
+                y
+            ; Else if both z1 and z2 are zeroes of opposite sign, then return positive zero.
+            (if (and (fp.isZero x) (fp.isZero y) (fp_opposite_sign! x y))
+                (fp.+zero (widthof x))
+            ; Else if both z1 and z2 are zeroes of equal sign, then return that zero.
+            (if (and (fp.isZero x) (fp.isZero y) (fp_equal_sign! x y))
+                x
+            ; Else if either z1 or z2 is a zero, then return the other operand.
+            (if (fp.isZero x)
+                y
+            (if (fp.isZero y)
+                x
+            ; Else if both z1 and z2 are values with the same magnitude but opposite signs, then return positive zero.
+            (if (and (= (fp_magnitude! x) (fp_magnitude! y)) (fp_opposite_sign! x y))
+                (fp.+zero (widthof x))
+            ; Else return the result of adding z1 and z2, rounded to the nearest representable value.
+                (fp.add x y)
+            ))))))))))
+        )
+    )
+)
+(instantiate fadd
+    ((args (named Type) (bv 32) (bv 32)) (ret (bv 32)))
+    ((args (named Type) (bv 64) (bv 64)) (ret (bv 64)))
+)
+
+; fsub: floating-point subtraction.
+;
+; Specification derived from WebAssembly Specification prose (Floating Point Numerics, section 4.3.3).
+(spec (fsub ty x y)
+    (provide
+        (= result
+            ; If either z1 or z2 is a NaN, then return an element of nans{z1,z2}.
+            (if (or (fp.isNaN x) (fp.isNaN y))
+                (nans2! x y)
+            ; Else if both z1 and z2 are infinities of equal sign, then return an element of nans{}.
+            (if (and (fp.isInfinite x) (fp.isInfinite y) (fp_equal_sign! x y))
+                (nans0! (widthof x))
+            ; Else if both z1 and z2 are infinities of opposite signs, then return z1.
+            (if (and (fp.isInfinite x) (fp.isInfinite y) (fp_opposite_sign! x y))
+                x
+            ; Else if z1 is an infinity, then return that infinity.
+            (if (fp.isInfinite x)
+                x
+            ; Else if z2 is an infinity, then return that infinity negated.
+            (if (fp.isInfinite y)
+                (fp.neg y)
+            ; Else if both z1 and z2 are zeroes of equal sign, then return positive zero.
+            (if (and (fp.isZero x) (fp.isZero y) (fp_equal_sign! x y))
+                (fp.+zero (widthof x))
+            ; Else if both z1 and z2 are zeroes of opposite sign, then return z1.
+            (if (and (fp.isZero x) (fp.isZero y) (fp_opposite_sign! x y))
+                x
+            ; Else if z2 is a zero, then return z1.
+            (if (fp.isZero y)
+                x
+            ; Else if z1 is a zero, then return z2 negated.
+            (if (fp.isZero x)
+                (fp.neg y)
+            ; Else if both z1 and z2 are the same value, then return positive zero.
+            (if (and (= (fp_magnitude! x) (fp_magnitude! y)) (fp_equal_sign! x y))
+                (fp.+zero (widthof x))
+            ; Else return the result of subtracting z2 from z1, rounded to the nearest representable value.
+                (fp.sub x y)
+            ))))))))))
+        )
+    )
+)
+(instantiate fsub
+    ((args (named Type) (bv 32) (bv 32)) (ret (bv 32)))
+    ((args (named Type) (bv 64) (bv 64)) (ret (bv 64)))
+)
+
+; fmul: floating-point multiplication.
+;
+; Specification derived from WebAssembly Specification prose (Floating Point Numerics, section 4.3.3).
+(spec (fmul ty x y)
+    (provide
+        (= result
+            ; If either z1 or z2 is a NaN, then return an element of nans{z1,z2}.
+            (if (or (fp.isNaN x) (fp.isNaN y))
+                (nans2! x y)
+            ; Else if one of z1 and z2 is a zero and the other an infinity, then return an element of nans{}.
+            (if (and (fp.isZero x) (fp.isInfinite y))
+                (nans0! (widthof x))
+            (if (and (fp.isInfinite x) (fp.isZero y))
+                (nans0! (widthof x))
+            ; Else if both z1 and z2 are infinities of equal sign, then return an element of nans{}.
+            (if (and (fp.isInfinite x) (fp.isInfinite y) (fp_equal_sign! x y))
+                (fp.+oo (widthof x))
+            ; Else if both z1 and z2 are infinities of opposite signs, then return z1.
+            (if (and (fp.isInfinite x) (fp.isInfinite y) (fp_opposite_sign! x y))
+                (fp.-oo (widthof x))
+            ; Else if either z1 or z2 is an infinity and the other a value with equal sign, then return positive infinity.
+            (if (and (fp.isInfinite x) (fp_equal_sign! x y))
+                (fp.+oo (widthof x))
+            (if (and (fp.isInfinite y) (fp_equal_sign! x y))
+                (fp.+oo (widthof x))
+            ; Else if either z1 or z2 is an infinity and the other a value with opposite sign, then return negative infinity.
+            (if (and (fp.isInfinite x) (fp_opposite_sign! x y))
+                (fp.-oo (widthof x))
+            (if (and (fp.isInfinite y) (fp_opposite_sign! x y))
+                (fp.-oo (widthof x))
+            ; Else if both z1 and z2 are zeroes of equal sign, then return positive zero.
+            (if (and (fp.isZero x) (fp.isZero y) (fp_equal_sign! x y))
+                (fp.+zero (widthof x))
+            ; Else if both z1 and z2 are zeroes of opposite sign, then return negative zero.
+            (if (and (fp.isZero x) (fp.isZero y) (fp_opposite_sign! x y))
+                (fp.-zero (widthof x))
+            ; Else return the result of multiplying z1 and z2, rounded to the nearest representable value.
+                (fp.mul x y)
+            )))))))))))
+        )
+    )
+)
+(instantiate fmul
+    ((args (named Type) (bv 32) (bv 32)) (ret (bv 32)))
+    ((args (named Type) (bv 64) (bv 64)) (ret (bv 64)))
+)
+
+; fdiv: floating-point division.
+;
+; Specification derived from WebAssembly Specification prose (Floating Point Numerics, section 4.3.3).
+(spec (fdiv ty x y)
+    (provide
+        (= result
+            ; If either z1 or z2 is a NaN, then return an element of nans{z1,z2}.
+            (if (or (fp.isNaN x) (fp.isNaN y))
+                (nans2! x y)
+            ; Else if both z1 and z2 are infinities, then return an element of nans{}.
+            (if (and (fp.isInfinite x) (fp.isInfinite y))
+                (nans0! (widthof x))
+            ; Else if both z1 and z2 are zeroes, then return an element of nans{z1,z2}.
+            (if (and (fp.isZero x) (fp.isZero y))
+                (nans2! x y)
+            ; Else if z1 is an infinity and z2 a value with equal sign, then return positive infinity.
+            (if (and (fp.isInfinite x) (fp_equal_sign! x y))
+                (fp.+oo (widthof x))
+            ; Else if z1 is an infinity and z2 a value with opposite sign, then return negative infinity.
+            (if (and (fp.isInfinite x) (fp_opposite_sign! x y))
+                (fp.-oo (widthof x))
+            ; Else if z2 is an infinity and z1 a value with equal sign, then return positive zero.
+            (if (and (fp.isInfinite y) (fp_equal_sign! x y))
+                (fp.+zero (widthof x))
+            ; Else if z2 is an infinity and z1 a value with opposite sign, then return negative zero.
+            (if (and (fp.isInfinite y) (fp_opposite_sign! x y))
+                (fp.-zero (widthof x))
+            ; Else if z1 is a zero and z2 a value with equal sign, then return positive zero.
+            (if (and (fp.isZero x) (fp_equal_sign! x y))
+                (fp.+zero (widthof x))
+            ; Else if z1 is a zero and z2 a value with opposite sign, then return negative zero.
+            (if (and (fp.isZero x) (fp_opposite_sign! x y))
+                (fp.-zero (widthof x))
+            ; Else if z2 is a zero and z1 a value with equal sign, then return positive infinity.
+            (if (and (fp.isZero y) (fp_equal_sign! x y))
+                (fp.+oo (widthof x))
+            ; Else if z2 is a zero and z1 a value with opposite sign, then return negative infinity.
+            (if (and (fp.isZero y) (fp_opposite_sign! x y))
+                (fp.-oo (widthof x))
+            ; Else return the result of dividing z1 by z2, rounded to the nearest representable value.
+                (fp.div x y)
+            )))))))))))
+        )
+    )
+)
+(instantiate fdiv
+    ((args (named Type) (bv 32) (bv 32)) (ret (bv 32)))
+    ((args (named Type) (bv 64) (bv 64)) (ret (bv 64)))
+)
+
+
+; fmin: floating-point minimum.
+;
+; Specification derived from WebAssembly Specification prose (Floating Point Numerics, section 4.3.3).
+(spec (fmin ty x y)
+    (provide
+        (= result
+            ; If either z1 or z2 is a NaN, then return an element of nans{z1,z2}.
+            (if (or (fp.isNaN x) (fp.isNaN y))
+                (nans2! x y)
+            ; Else if either z1 or z2 is a negative infinity, then return negative infinity.
+            (if (or (and (fp.isInfinite x) (fp.isNegative x)) (and (fp.isInfinite y) (fp.isNegative y)))
+                (fp.-oo (widthof x))
+            ; Else if either z1 or z2 is a positive infinity, then return the other value.
+            (if (and (fp.isInfinite x) (fp.isPositive x))
+                y
+            (if (and (fp.isInfinite y) (fp.isPositive y))
+                x
+            ; Else if both z1 and z2 are zeroes of opposite signs, then return negative zero.
+            (if (and (fp.isZero x) (fp.isZero y) (fp_opposite_sign! x y))
+                (fp.-zero (widthof x))
+            ; Else return the smaller value of z1 and z2.
+                (fp.min x y)
+            )))))
+        )
+    )
+)
+(instantiate fmin
+    ((args (named Type) (bv 32) (bv 32)) (ret (bv 32)))
+    ((args (named Type) (bv 64) (bv 64)) (ret (bv 64)))
+)
+
+; fmax: floating-point minimum.
+;
+; Specification derived from WebAssembly Specification prose (Floating Point Numerics, section 4.3.3).
+(spec (fmax ty x y)
+    (provide
+        (= result
+            ; If either z1 or z2 is a NaN, then return an element of nans{z1,z2}.
+            (if (or (fp.isNaN x) (fp.isNaN y))
+                (nans2! x y)
+            ; Else if either z1 or z2 is a positive infinity, then return positive infinity.
+            (if (or (and (fp.isInfinite x) (fp.isPositive x)) (and (fp.isInfinite y) (fp.isPositive y)))
+                (fp.+oo (widthof x))
+            ; Else if either z1 or z2 is a negative infinity, then return the other value.
+            (if (and (fp.isInfinite x) (fp.isNegative x))
+                y
+            (if (and (fp.isInfinite y) (fp.isNegative y))
+                x
+            ; Else if both z1 and z2 are zeroes of opposite signs, then return positive zero.
+            (if (and (fp.isZero x) (fp.isZero y) (fp_opposite_sign! x y))
+                (fp.+zero (widthof x))
+            ; Else return the smaller value of z1 and z2.
+                (fp.max x y)
+            )))))
+        )
+    )
+)
+(instantiate fmax
+    ((args (named Type) (bv 32) (bv 32)) (ret (bv 32)))
+    ((args (named Type) (bv 64) (bv 64)) (ret (bv 64)))
+)
+
+
+; fabs: floating-point absolute value.
+;
+; Specification derived from WebAssembly Specification prose (Floating Point Numerics, section 4.3.3).
+(spec (fabs ty x)
+    (provide
+        (= result
+            ; If z is a NaN, then return z with positive sign.
+            (if (fp.isNaN x)
+                (bvand x (bvnot (fp_sign_bit_set! (widthof x))))
+            ; Else if z is an infinity, then return positive infinity.
+            (if (fp.isInfinite x)
+                (fp.+oo (widthof x))
+            ; Else if z is a zero, then return positive zero.
+            (if (fp.isZero x)
+                (fp.+zero (widthof x))
+            ; Else if z is a positive value, then return z.
+            (if (fp.isPositive x)
+                x
+            ; Else return z negated.
+                (fp.neg x)
+            ))))
+        )
+    )
+)
+(instantiate fabs
+    ((args (named Type) (bv 32)) (ret (bv 32)))
+    ((args (named Type) (bv 64)) (ret (bv 64)))
+)
+
+
+; fneg: floating-point negation.
+;
+; Specification derived from WebAssembly Specification prose (Floating Point Numerics, section 4.3.3).
+(spec (fneg ty x)
+    (provide
+        (= result
+            ; If z is a NaN, then return z with negated sign.
+            (if (fp.isNaN x)
+                (nan_neg! x)
+            ; Else if z is an infinity, then return that infinity negated.
+            ; Else if z is a zero, then return that zero negated.
+            ; Else return z negated.
+                (fp.neg x)) ; Remaining cases of the spec handled by SMT fp.neg
+        )
+    )
+)
+(instantiate fneg
+    ((args (named Type) (bv 32)) (ret (bv 32)))
+    ((args (named Type) (bv 64)) (ret (bv 64)))
+)
+
+
+; sqrt: floating-point square root.
+;
+; Specification derived from WebAssembly Specification prose (Floating Point Numerics, section 4.3.3).
+(spec (sqrt ty x)
+    (provide
+        (= result
+            ; If z is a NaN, then return an element of nans{z}.
+            (if (fp.isNaN x)
+                (nans1! x)
+            ; Else if z is negative infinity, then return an element of nans{}.
+            (if (and (fp.isInfinite x) (fp.isNegative x))
+                (nans0! (widthof x))
+            ; Else if z is positive infinity, then return positive infinity.
+            (if (and (fp.isInfinite x) (fp.isPositive x))
+                (fp.+oo (widthof x))
+            ; Else if z is a zero, then return that zero.
+            (if (fp.isZero x)
+                x
+            ; Else if z has a negative sign, then return an element of nans{}.
+            (if (fp.isNegative x)
+                (nans0! (widthof x))
+            ; Else return the square root of z.
+                (fp.sqrt x)
+            )))))
+        )
+    )
+)
+(instantiate sqrt
+    ((args (named Type) (bv 32)) (ret (bv 32)))
+    ((args (named Type) (bv 64)) (ret (bv 64)))
+)
+
+; ceil: floating-point ceiling.
+;
+; Specification derived from WebAssembly Specification prose (Floating Point Numerics, section 4.3.3).
+(spec (ceil ty x)
+    (provide
+        (= result
+            ; If z is a NaN, then return an element of nans{z}.
+            (if (fp.isNaN x)
+                (nans1! x)
+            ; Else if z is infinity, then return z.
+            (if (fp.isInfinite x)
+                x
+            ; Else if z is zero, then return z.
+            (if (fp.isZero x)
+                x
+            ; Else if z is smaller than 0 but greater than −1, then return negative zero.
+            (if (and (fp.lt x (fp.-zero (widthof x))) (fp.gt x (fp_minus_one! (widthof x))))
+                (fp.-zero (widthof x))
+            ; Else return the smallest integral value that is not smaller than z.
+                (fp.ceil x)
+            ))))
+        )
+    )
+)
+(instantiate ceil
+    ((args (named Type) (bv 32)) (ret (bv 32)))
+    ((args (named Type) (bv 64)) (ret (bv 64)))
+)
+
+; floor: floating-point floor.
+;
+; Specification derived from WebAssembly Specification prose (Floating Point Numerics, section 4.3.3).
+(spec (floor ty x)
+    (provide
+        (= result
+            ; If z is a NaN, then return an element of nans{z}.
+            (if (fp.isNaN x)
+                (nans1! x)
+            ; Else if z is infinity, then return z.
+            (if (fp.isInfinite x)
+                x
+            ; Else if z is zero, then return z.
+            (if (fp.isZero x)
+                x
+            ; Else if z is greater than 0 but smaller than 1, then return positive zero.
+            (if (and (fp.gt x (fp.-zero (widthof x))) (fp.lt x (fp_one! (widthof x))))
+                (fp.+zero (widthof x))
+            ; Else return the smallest integral value that is not smaller than z.
+                (fp.floor x)
+            ))))
+        )
+    )
+)
+(instantiate floor
+    ((args (named Type) (bv 32)) (ret (bv 32)))
+    ((args (named Type) (bv 64)) (ret (bv 64)))
+)
+
+; trunc: floating-point truncate.
+;
+; Specification derived from WebAssembly Specification prose (Floating Point Numerics, section 4.3.3).
+(spec (trunc ty x)
+    (provide
+        (= result
+            ; If z is a NaN, then return an element of nans{z}.
+            (if (fp.isNaN x)
+                (nans1! x)
+            ; Else if z is infinity, then return z.
+            (if (fp.isInfinite x)
+                x
+            ; Else if z is a zero, then return z.
+            (if (fp.isZero x)
+                x
+            ; Else if z is greater than 0 but smaller than 1, then return positive zero.
+            (if (and (fp.gt x (fp.+zero (widthof x))) (fp.lt x (fp_one! (widthof x))))
+                (fp.+zero (widthof x))
+            ; Else if z is smaller than 0 but greater than −1, then return negative zero.
+            (if (and (fp.lt x (fp.-zero (widthof x))) (fp.gt x (fp_minus_one! (widthof x))))
+                (fp.-zero (widthof x))
+            ; Else return the integral value with the same sign as z and the largest magnitude that is not larger than the magnitude of z.
+                (fp.trunc x)
+            )))))
+        )
+    )
+)
+(instantiate trunc
+    ((args (named Type) (bv 32)) (ret (bv 32)))
+    ((args (named Type) (bv 64)) (ret (bv 64)))
+)
+; nearest: floating-point nearest.
+;
+; Specification derived from WebAssembly Specification prose (Floating Point Numerics, section 4.3.3).
+(spec (nearest ty x)
+    (provide
+        (= result
+            ; If z is a NaN, then return an element of nans{z}.
+            (if (fp.isNaN x)
+                (nans1! x)
+            ; Else if z is infinity, then return z.
+            (if (fp.isInfinite x)
+                x
+            ; Else if z is zero, then return z.
+            (if (fp.isZero x)
+                x
+            ; Else if z is greater than 0 but smaller than or equal to 0.5, then return positive zero.
+            (if (and (fp.gt x (fp.+zero (widthof x))) (fp.le x (fp_half! (widthof x))))
+                (fp.+zero (widthof x))
+            ; Else if z is smaller than 0 but greater than or equal to −0.5, then return negative zero.
+            (if (and (fp.lt x (fp.-zero (widthof x))) (fp.ge x (fp_minus_half! (widthof x))))
+                (fp.-zero (widthof x))
+            ; Else return the integral value that is nearest to z; if two values are equally near, return the even one.
+                (fp.nearest x)
+            )))))
+        )
+    )
+)
+(instantiate nearest
+    ((args (named Type) (bv 32)) (ret (bv 32)))
+    ((args (named Type) (bv 64)) (ret (bv 64)))
+)
+
+; fcopysign: floating-point copysign.
+;
+; Specification derived from WebAssembly Specification prose (Floating Point Numerics, section 4.3.3).
+(spec (fcopysign ty x y)
+    (provide
+        (= result
+            ; If z1 and z2 have the same sign, then return z1.
+            (if (fp_equal_sign_inc_nan! x y)
+                x
+            ; Else return z1 with negated sign.
+            (if (fp.isNaN x)
+                (nan_neg! x)
+                (fp.neg x)
+            ))
+        )
+    )
+)
+(instantiate fcopysign
+    ((args (named Type) (bv 32) (bv 32)) (ret (bv 32)))
+    ((args (named Type) (bv 64) (bv 64)) (ret (bv 64)))
+)
+
+(spec (bitcast ty flags x)
+    (provide (= result x))
+)
+; I32ReinterpretF32
+; I64ReinterpretF64
+; F32ReinterpretI32
+; F64ReinterpretI64
+(instantiate bitcast
+    ((args (named Type) (named MemFlags) (bv 32)) (ret (bv 32)))
+    ((args (named Type) (named MemFlags) (bv 64)) (ret (bv 64)))
+)
+
+(form fcvt
+    ((args (named Type) (bv 32)) (ret (bv 32)))
+    ((args (named Type) (bv 32)) (ret (bv 64)))
+    ((args (named Type) (bv 64)) (ret (bv 32)))
+    ((args (named Type) (bv 64)) (ret (bv 64))))
+
+(spec (fcvt_from_uint ty x)
+    (provide
+        (let ((N (widthof result)))
+            (= result (to_fp_unsigned N (conv_to N (zero_ext 64 x))))))
+)
+(instantiate fcvt_from_uint fcvt)
+
+(spec (fcvt_from_sint ty x)
+    (provide
+        (let ((N (widthof result)))
+            (= result (to_fp N (conv_to N (sign_ext 64 x))))))
+)
+(instantiate fcvt_from_sint fcvt)
+
+;; Can trap if invalid conversion
+;; Derived from Wasm reference interpreter
+;; https://github.com/WebAssembly/spec/blob/5d12bd74c49932deb7ab4bae3d29bf106f19d10b/interpreter/exec/i32_convert.ml#L5
+(macro (neg_min_int_times_two_as_fp w)
+    (switch w
+        (32 #x000000004f800000)
+        (64 #x43f0000000000000)
+    )
+)
+(spec (fcvt_to_uint ty x)
+    (modifies clif_trap)
+    (provide
+        (let (
+            (s (widthof x))
+            (d (widthof result))
+        )
+        (and
+            (=> (not clif_trap) (= result (fp.to_ubv d (to_fp_from_fp d x))))
+
+            ;; Trap if input is NaN or does not fit in the integer type
+            ;; if xf >= -.Int32.(to_float min_int) *. 2.0 || xf <= -1.0 then
+            (= clif_trap (or
+                (fp.isNaN x)
+                (fp.ge x (to_fp_from_fp s (conv_to d (neg_min_int_times_two_as_fp! d))))
+                (fp.le x (to_fp_from_fp s (conv_to d (fp_minus_one! d)))))))))
+)
+(instantiate fcvt_to_uint fcvt)
+
+(macro (min_int_as_fp w n)
+    (switch n
+        (32 (fp_i32_min! w))
+        (64 (fp_i64_min! w))
+    )
+)
+(macro (neg_min_int_as_fp w n)
+    (switch n
+        (32 (fp_minus_i32_min! w))
+        (64 (fp_minus_i64_min! w))
+    )
+)
+(spec (fcvt_to_sint ty x)
+    (modifies clif_trap)
+    (provide
+        (let (
+            (s (widthof x))
+            (d (widthof result))
+        )
+        (and
+            (=> (not clif_trap) (= result (fp.to_sbv d (to_fp_from_fp d x))))
+
+            ;; Trap if input is NaN or does not fit in the integer type
+            ;;
+            ;; Note f64 to i32 case takes a different form according to the reference interpreter.
+            ;;
+            ;; Reference interpreter i32_convert `trunc_f32_s`:
+            ;;      if xf >= -.Int32.(to_float min_int) || xf < Int32.(to_float min_int) then
+            ;; Reference interpreter i32_convert `trunc_f64_s`:
+            ;;      if xf >= -.Int32.(to_float min_int) || xf <= Int32.(to_float min_int) -. 1.0 then
+            ;; Reference interpreter i64_convert `trunc_f32_s`:
+            ;;      if xf >= -.Int64.(to_float min_int) || xf < Int64.(to_float min_int) then
+            ;; Reference interpreter i64_convert `trunc_f64_s`:
+            ;;      if xf >= -.Int64.(to_float min_int) || xf < Int64.(to_float min_int) then
+            (= clif_trap (or
+                (fp.isNaN x)
+                (fp.ge x (neg_min_int_as_fp! s d))
+                (if (and (= s 64) (= d 32))
+                    (fp.le x (fp.sub (min_int_as_fp! s d) (fp_one! s)))
+                    (fp.lt x (min_int_as_fp! s d))
+                ))))))
+)
+(instantiate fcvt_to_sint fcvt)
+
+
+; Specification derived from WebAssembly Specification prose (Conversions, section 4.3.4).
+(spec (fdemote ty z)
+    (match
+        ;; Demote only can return bv-32 as written
+        (= (widthof result) 32))
+    (provide
+        (= result
+            ; If z is a canonical NaN, then return an element of nans{} (i.e., a canonical NaN of size N).
+            ; Else if z is a NaN, then return an element of nans{±nan(1)} (i.e., any NaN of size N).
+            (if (fp.isNaN z)
+                ;; Note: derived from Wasm reference interpreter:
+                ;; https://github.com/WebAssembly/spec/blob/268a03da8576cc491d708777e69676724938aec9/interpreter/exec/f32_convert.ml#L4
+                (bvor #x7fc00000
+                     (extract 31 0
+                         (bvor
+                             (bvshl_int! (bvlshr_int! z 63) 31)
+                             (bvlshr_int! (bvshl_int! z 12) 41)
+                         )
+                     )
+                 )
+            ; Else if z is an infinity, then return that infinity.
+            (if (fp.isInfinite z)
+                (if (fp.isNegative z) (fp.-oo 32) (fp.+oo 32))
+            ; Else if z is a zero, then return that zero.
+            (if (fp.isZero z)
+                (if (fp.isNegative z) (fp.-zero 32) (fp.+zero 32))
+            ; Else,return float(z)
+                (to_fp_from_fp 32 z)
+            )))
+        )
+    )
+)
+(instantiate fdemote
+    ((args (named Type) (bv 64)) (ret (bv 32)))
+)
+
+; Specification derived from WebAssembly Specification prose (Conversions, section 4.3.4).
+(spec (fpromote ty z)
+    (match
+        ;; Promote only can return bv-32 as written
+        (= (widthof result) 64))
+    (provide
+        (= result
+            ; If z is a canonical NaN, then return an element of nans{} (i.e., a canonical NaN of size N).
+            ; Else if z is a NaN, then return an element of nans{±nan(1)} (i.e., any arithmetic NaN of size N).
+            (if (fp.isNaN z)
+                ;; Note: derived from Wasm reference interpreter:
+                ;; https://github.com/WebAssembly/spec/blob/5d12bd74c49932deb7ab4bae3d29bf106f19d10b/interpreter/exec/f64_convert.ml#L4
+                (bvor #x7ff8000000000000
+                    (bvor
+                        (bvshl_int! (bvlshr_int! (zero_ext 64 z) 31) 63)
+                        (bvlshr_int! (bvshl_int! (zero_ext 64 z) 41) 12)
+                    )
+                )
+            ; Else, return z.
+                (to_fp_from_fp 64 z)
+            )
+        )
+    )
+)
+(instantiate fpromote
+    ((args (named Type) (bv 32)) (ret (bv 64)))
+)
+
+;;;; CLIF Instruction Tags ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(attr select_spectre_guard (tag spectre))
+
+; Use Z3 solver for the following instructions.
+(attr fadd (tag solver_z3))
+(attr fmul (tag solver_z3))
+(attr fdiv (tag solver_z3))
+(attr sqrt (tag solver_z3))
+
+(attr cls (tag solver_z3))
+(attr clz (tag solver_z3))
+(attr ctz (tag solver_z3))
+(attr popcnt (tag solver_z3))
diff --git a/cranelift/codegen/src/inst_tags.isle b/cranelift/codegen/src/inst_tags.isle
new file mode 100644
index 000000000000..ef5e9da6d310
--- /dev/null
+++ b/cranelift/codegen/src/inst_tags.isle
@@ -0,0 +1,314 @@
+;; GENERATED BY `isletags`. DO NOT EDIT!!!
+
+(attr select
+    (tag wasm_category_stack)
+    (tag wasm_proposal_mvp)
+)
+
+(attr icmp
+    (tag wasm_category_comparison)
+    (tag wasm_category_loads)
+    (tag wasm_category_stores)
+    (tag wasm_proposal_mvp)
+)
+
+(attr iconst
+    (tag wasm_category_const)
+    (tag wasm_category_loads)
+    (tag wasm_category_stores)
+    (tag wasm_proposal_mvp)
+)
+
+(attr isub
+    (tag wasm_category_binary)
+    (tag wasm_category_loads)
+    (tag wasm_category_stores)
+    (tag wasm_proposal_mvp)
+)
+
+(attr uadd_overflow_trap
+    (tag wasm_category_loads)
+    (tag wasm_category_stores)
+    (tag wasm_proposal_mvp)
+)
+
+(attr uload8
+    (tag wasm_category_loads)
+    (tag wasm_proposal_mvp)
+)
+
+(attr uload16
+    (tag wasm_category_loads)
+    (tag wasm_proposal_mvp)
+)
+
+(attr sload8
+    (tag wasm_category_loads)
+    (tag wasm_proposal_mvp)
+)
+
+(attr sload16
+    (tag wasm_category_loads)
+    (tag wasm_proposal_mvp)
+)
+
+(attr sload32
+    (tag wasm_category_loads)
+    (tag wasm_proposal_mvp)
+)
+
+(attr uload32
+    (tag wasm_category_loads)
+    (tag wasm_proposal_mvp)
+)
+
+(attr load
+    (tag wasm_category_loads)
+    (tag wasm_proposal_mvp)
+)
+
+(attr store
+    (tag wasm_category_stores)
+    (tag wasm_proposal_mvp)
+)
+
+(attr istore8
+    (tag wasm_category_stores)
+    (tag wasm_proposal_mvp)
+)
+
+(attr istore16
+    (tag wasm_category_stores)
+    (tag wasm_proposal_mvp)
+)
+
+(attr istore32
+    (tag wasm_category_stores)
+    (tag wasm_proposal_mvp)
+)
+
+(attr f32const
+    (tag wasm_category_const)
+    (tag wasm_proposal_mvp)
+)
+
+(attr f64const
+    (tag wasm_category_const)
+    (tag wasm_proposal_mvp)
+)
+
+(attr clz
+    (tag wasm_category_unary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr ctz
+    (tag wasm_category_unary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr popcnt
+    (tag wasm_category_unary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr sextend
+    (tag wasm_category_unary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr uextend
+    (tag wasm_category_comparison)
+    (tag wasm_category_unary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr ireduce
+    (tag wasm_category_unary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr sqrt
+    (tag wasm_category_unary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr ceil
+    (tag wasm_category_unary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr floor
+    (tag wasm_category_unary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr trunc
+    (tag wasm_category_unary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr nearest
+    (tag wasm_category_unary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr fabs
+    (tag wasm_category_unary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr fneg
+    (tag wasm_category_unary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr fcvt_from_uint
+    (tag wasm_category_unary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr fcvt_from_sint
+    (tag wasm_category_unary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr fpromote
+    (tag wasm_category_unary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr fdemote
+    (tag wasm_category_unary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr fcvt_to_sint
+    (tag wasm_category_unary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr fcvt_to_uint
+    (tag wasm_category_unary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr bitcast
+    (tag wasm_category_unary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr iadd
+    (tag wasm_category_binary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr band
+    (tag wasm_category_binary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr bor
+    (tag wasm_category_binary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr bxor
+    (tag wasm_category_binary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr ishl
+    (tag wasm_category_binary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr sshr
+    (tag wasm_category_binary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr ushr
+    (tag wasm_category_binary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr rotl
+    (tag wasm_category_binary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr rotr
+    (tag wasm_category_binary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr fadd
+    (tag wasm_category_binary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr fsub
+    (tag wasm_category_binary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr imul
+    (tag wasm_category_binary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr fmul
+    (tag wasm_category_binary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr fdiv
+    (tag wasm_category_binary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr sdiv
+    (tag wasm_category_binary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr udiv
+    (tag wasm_category_binary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr srem
+    (tag wasm_category_binary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr urem
+    (tag wasm_category_binary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr fmin
+    (tag wasm_category_binary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr fmax
+    (tag wasm_category_binary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr fcopysign
+    (tag wasm_category_binary)
+    (tag wasm_proposal_mvp)
+)
+
+(attr icmp_imm
+    (tag wasm_category_comparison)
+    (tag wasm_proposal_mvp)
+)
+
+(attr fcmp
+    (tag wasm_category_comparison)
+    (tag wasm_proposal_mvp)
+)
diff --git a/cranelift/codegen/src/ir/constant.rs b/cranelift/codegen/src/ir/constant.rs
index 637784a27a88..0db31628cca2 100644
--- a/cranelift/codegen/src/ir/constant.rs
+++ b/cranelift/codegen/src/ir/constant.rs
@@ -8,12 +8,11 @@
 //! - ensuring alignment of constants within the pool,
 //! - bucketing constants by size.
 
-use crate::ir::immediates::{IntoBytes, V128Imm};
+use crate::ir::immediates::{Ieee128, IntoBytes, V128Imm};
 use crate::ir::Constant;
 use alloc::collections::BTreeMap;
 use alloc::vec::Vec;
 use core::fmt;
-use core::iter::FromIterator;
 use core::slice::Iter;
 use core::str::{from_utf8, FromStr};
 use cranelift_entity::EntityRef;
@@ -55,6 +54,22 @@ impl From<V128Imm> for ConstantData {
     }
 }
 
+impl From<Ieee128> for ConstantData {
+    fn from(v: Ieee128) -> Self {
+        Self(v.into_bytes())
+    }
+}
+
+impl TryFrom<&ConstantData> for Ieee128 {
+    type Error = <[u8; 16] as TryFrom<&'static [u8]>>::Error;
+
+    fn try_from(value: &ConstantData) -> Result<Self, Self::Error> {
+        Ok(Ieee128::with_bits(u128::from_le_bytes(
+            value.as_slice().try_into()?,
+        )))
+    }
+}
+
 impl ConstantData {
     /// Return the number of bytes in the constant.
     pub fn len(&self) -> usize {
@@ -92,10 +107,7 @@ impl ConstantData {
     /// in the high-order byte slots.
     pub fn expand_to(mut self, expected_size: usize) -> Self {
         if self.len() > expected_size {
-            panic!(
-                "The constant data is already expanded beyond {} bytes",
-                expected_size
-            )
+            panic!("The constant data is already expanded beyond {expected_size} bytes")
         }
         self.0.resize(expected_size, 0);
         self
@@ -116,7 +128,7 @@ impl fmt::Display for ConstantData {
         if !self.is_empty() {
             write!(f, "0x")?;
             for b in self.0.iter().rev() {
-                write!(f, "{:02x}", b)?;
+                write!(f, "{b:02x}")?;
             }
         }
         Ok(())
@@ -166,8 +178,8 @@ impl FromStr for ConstantData {
     }
 }
 
-/// Maintains the mapping between a constant handle (i.e.  [`Constant`](crate::ir::Constant)) and
-/// its constant data (i.e.  [`ConstantData`](crate::ir::ConstantData)).
+/// Maintains the mapping between a constant handle (i.e.  [`Constant`]) and
+/// its constant data (i.e.  [`ConstantData`]).
 #[derive(Clone, PartialEq, Hash)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct ConstantPool {
@@ -399,8 +411,7 @@ mod tests {
             let parsed = from.parse::<ConstantData>();
             assert!(
                 parsed.is_err(),
-                "Expected a parse error but parsing succeeded: {}",
-                from
+                "Expected a parse error but parsing succeeded: {from}"
             );
             assert_eq!(parsed.err().unwrap(), error_msg);
         }
@@ -460,4 +471,15 @@ mod tests {
             [0x78, 0x56, 0x34, 0x12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
         );
     }
+
+    #[test]
+    fn constant_ieee128() {
+        let value = Ieee128::with_bits(0x000102030405060708090a0b0c0d0e0f);
+        let constant = ConstantData::from(value);
+        assert_eq!(
+            constant.as_slice(),
+            &[0xf, 0xe, 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1, 0x0]
+        );
+        assert_eq!(Ieee128::try_from(&constant).unwrap().bits(), value.bits());
+    }
 }
diff --git a/cranelift/codegen/src/ir/dfg.rs b/cranelift/codegen/src/ir/dfg.rs
index 76b1b08cbeea..c26c3d591e21 100644
--- a/cranelift/codegen/src/ir/dfg.rs
+++ b/cranelift/codegen/src/ir/dfg.rs
@@ -5,6 +5,8 @@ use crate::ir;
 use crate::ir::builder::ReplaceBuilder;
 use crate::ir::dynamic_type::{DynamicTypeData, DynamicTypes};
 use crate::ir::instructions::{CallInfo, InstructionData};
+use crate::ir::pcc::Fact;
+use crate::ir::user_stack_maps::{UserStackMapEntry, UserStackMapEntryVec};
 use crate::ir::{
     types, Block, BlockCall, ConstantData, ConstantPool, DynamicType, ExtFuncData, FuncRef,
     Immediate, Inst, JumpTables, RelSourceLoc, SigRef, Signature, Type, Value,
@@ -104,6 +106,16 @@ pub struct DataFlowGraph {
     /// primary `insts` map.
     results: SecondaryMap<Inst, ValueList>,
 
+    /// User-defined stack maps.
+    ///
+    /// Not to be confused with the stack maps that `regalloc2` produces. These
+    /// are defined by the user in `cranelift-frontend`. These will eventually
+    /// replace the stack maps support in `regalloc2`, but in the name of
+    /// incrementalism and avoiding gigantic PRs that completely overhaul
+    /// Cranelift and Wasmtime at the same time, we are allowing them to live in
+    /// parallel for the time being.
+    user_stack_maps: alloc::collections::BTreeMap<Inst, UserStackMapEntryVec>,
+
     /// basic blocks in the function and their parameters.
     ///
     /// This map is not in program order. That is handled by `Layout`, and so is the sequence of
@@ -125,13 +137,13 @@ pub struct DataFlowGraph {
     /// Primary value table with entries for all values.
     values: PrimaryMap<Value, ValueDataPacked>,
 
+    /// Facts: proof-carrying-code assertions about values.
+    pub facts: SecondaryMap<Value, Option<Fact>>,
+
     /// Function signature table. These signatures are referenced by indirect call instructions as
     /// well as the external function references.
     pub signatures: PrimaryMap<SigRef, Signature>,
 
-    /// The pre-legalization signature for each entry in `signatures`, if any.
-    pub old_signatures: SecondaryMap<SigRef, Option<Signature>>,
-
     /// External function references. These are functions that can be called directly.
     pub ext_funcs: PrimaryMap<FuncRef, ExtFuncData>,
 
@@ -154,12 +166,13 @@ impl DataFlowGraph {
         Self {
             insts: Insts(PrimaryMap::new()),
             results: SecondaryMap::new(),
+            user_stack_maps: alloc::collections::BTreeMap::new(),
             blocks: Blocks(PrimaryMap::new()),
             dynamic_types: DynamicTypes::new(),
             value_lists: ValueListPool::new(),
             values: PrimaryMap::new(),
+            facts: SecondaryMap::new(),
             signatures: PrimaryMap::new(),
-            old_signatures: SecondaryMap::new(),
             ext_funcs: PrimaryMap::new(),
             values_labels: None,
             constants: ConstantPool::new(),
@@ -172,17 +185,18 @@ impl DataFlowGraph {
     pub fn clear(&mut self) {
         self.insts.0.clear();
         self.results.clear();
+        self.user_stack_maps.clear();
         self.blocks.0.clear();
         self.dynamic_types.clear();
         self.value_lists.clear();
         self.values.clear();
         self.signatures.clear();
-        self.old_signatures.clear();
         self.ext_funcs.clear();
         self.values_labels = None;
         self.constants.clear();
         self.immediates.clear();
         self.jump_tables.clear();
+        self.facts.clear();
     }
 
     /// Get the total number of instructions created in this function, whether they are currently
@@ -271,7 +285,7 @@ fn resolve_aliases(values: &PrimaryMap<Value, ValueDataPacked>, value: Value) ->
     if let Some(v) = maybe_resolve_aliases(values, value) {
         v
     } else {
-        panic!("Value alias loop detected for {}", value);
+        panic!("Value alias loop detected for {value}");
     }
 }
 
@@ -327,6 +341,13 @@ impl DataFlowGraph {
         self.values.is_valid(v)
     }
 
+    /// Check whether a value is valid and not an alias.
+    pub fn value_is_real(&self, value: Value) -> bool {
+        // Deleted or unused values are also stored as aliases so this excludes
+        // those as well.
+        self.value_is_valid(value) && !matches!(self.values[value].into(), ValueData::Alias { .. })
+    }
+
     /// Get the type of a value.
     pub fn value_type(&self, v: Value) -> Type {
         self.values[v].ty()
@@ -372,12 +393,109 @@ impl DataFlowGraph {
         resolve_aliases(&self.values, value)
     }
 
-    /// Resolve all aliases among inst's arguments.
-    ///
-    /// For each argument of inst which is defined by an alias, replace the
-    /// alias with the aliased value.
-    pub fn resolve_aliases_in_arguments(&mut self, inst: Inst) {
-        self.map_inst_values(inst, |dfg, arg| resolve_aliases(&dfg.values, arg));
+    /// Replace all uses of value aliases with their resolved values, and delete
+    /// the aliases.
+    pub fn resolve_all_aliases(&mut self) {
+        let invalid_value = ValueDataPacked::from(ValueData::Alias {
+            ty: types::INVALID,
+            original: Value::reserved_value(),
+        });
+
+        // Rewrite each chain of aliases. Update every alias along the chain
+        // into an alias directly to the final value. Due to updating every
+        // alias that it looks at, this loop runs in time linear in the number
+        // of values.
+        for mut src in self.values.keys() {
+            let value_data = self.values[src];
+            if value_data == invalid_value {
+                continue;
+            }
+            if let ValueData::Alias { mut original, .. } = value_data.into() {
+                // We don't use the type after this, we just need some place to
+                // store the resolved aliases temporarily.
+                let resolved = ValueDataPacked::from(ValueData::Alias {
+                    ty: types::INVALID,
+                    original: resolve_aliases(&self.values, original),
+                });
+                // Walk the chain again, splatting the new alias everywhere.
+                // resolve_aliases panics if there's an alias cycle, so we don't
+                // need to guard against cycles here.
+                loop {
+                    self.values[src] = resolved;
+                    src = original;
+                    if let ValueData::Alias { original: next, .. } = self.values[src].into() {
+                        original = next;
+                    } else {
+                        break;
+                    }
+                }
+            }
+        }
+
+        // Now aliases don't point to other aliases, so we can replace any use
+        // of an alias with the final value in constant time.
+
+        // Rewrite InstructionData in `self.insts`.
+        for inst in self.insts.0.values_mut() {
+            inst.map_values(&mut self.value_lists, &mut self.jump_tables, |arg| {
+                if let ValueData::Alias { original, .. } = self.values[arg].into() {
+                    original
+                } else {
+                    arg
+                }
+            });
+        }
+
+        // - `results` and block-params in `blocks` are not aliases, by
+        //   definition.
+        // - `dynamic_types` has no values.
+        // - `value_lists` can only be accessed via references from elsewhere.
+        // - `values` only has value references in aliases (which we've
+        //   removed), and unions (but the egraph pass ensures there are no
+        //   aliases before creating unions).
+
+        // Merge `facts` from any alias onto the aliased value. Note that if
+        // there was a chain of aliases, at this point every alias that was in
+        // the chain points to the same final value, so their facts will all be
+        // merged together.
+        for value in self.facts.keys() {
+            if let ValueData::Alias { original, .. } = self.values[value].into() {
+                if let Some(new_fact) = self.facts[value].take() {
+                    match &mut self.facts[original] {
+                        Some(old_fact) => *old_fact = Fact::intersect(old_fact, &new_fact),
+                        old_fact => *old_fact = Some(new_fact),
+                    }
+                }
+            }
+        }
+
+        // - `signatures` and `ext_funcs` have no values.
+
+        if let Some(values_labels) = &mut self.values_labels {
+            // Debug info is best-effort. If any is attached to value aliases,
+            // just discard it.
+            values_labels.retain(|&k, _| !matches!(self.values[k].into(), ValueData::Alias { .. }));
+
+            // If debug-info says a value should have the same labels as another
+            // value, then make sure that target is not a value alias.
+            for value_label in values_labels.values_mut() {
+                if let ValueLabelAssignments::Alias { value, .. } = value_label {
+                    if let ValueData::Alias { original, .. } = self.values[*value].into() {
+                        *value = original;
+                    }
+                }
+            }
+        }
+
+        // - `constants` and `immediates` have no values.
+        // - `jump_tables` is updated together with instruction-data above.
+
+        // Delete all aliases now that there are no uses left.
+        for value in self.values.values_mut() {
+            if let ValueData::Alias { .. } = ValueData::from(*value) {
+                *value = invalid_value;
+            }
+        }
     }
 
     /// Turn a value into an alias of another.
@@ -393,8 +511,7 @@ impl DataFlowGraph {
         let original = self.resolve_aliases(src);
         debug_assert_ne!(
             dest, original,
-            "Aliasing {} to {} would create a loop",
-            dest, src
+            "Aliasing {dest} to {src} would create a loop"
         );
         let ty = self.value_type(original);
         debug_assert_eq!(
@@ -420,33 +537,29 @@ impl DataFlowGraph {
     /// After calling this instruction, `dest_inst` will have had its results
     /// cleared, so it likely needs to be removed from the graph.
     ///
-    pub fn replace_with_aliases(&mut self, dest_inst: Inst, src_inst: Inst) {
+    pub fn replace_with_aliases(&mut self, dest_inst: Inst, original_inst: Inst) {
         debug_assert_ne!(
-            dest_inst, src_inst,
-            "Replacing {} with itself would create a loop",
-            dest_inst
+            dest_inst, original_inst,
+            "Replacing {dest_inst} with itself would create a loop"
         );
+
+        let dest_results = self.results[dest_inst].as_slice(&self.value_lists);
+        let original_results = self.results[original_inst].as_slice(&self.value_lists);
+
         debug_assert_eq!(
-            self.results[dest_inst].len(&self.value_lists),
-            self.results[src_inst].len(&self.value_lists),
-            "Replacing {} with {} would produce a different number of results.",
-            dest_inst,
-            src_inst
+            dest_results.len(),
+            original_results.len(),
+            "Replacing {dest_inst} with {original_inst} would produce a different number of results."
         );
 
-        for (&dest, &src) in self.results[dest_inst]
-            .as_slice(&self.value_lists)
-            .iter()
-            .zip(self.results[src_inst].as_slice(&self.value_lists))
-        {
-            let original = src;
+        for (&dest, &original) in dest_results.iter().zip(original_results) {
             let ty = self.value_type(original);
             debug_assert_eq!(
                 self.value_type(dest),
                 ty,
                 "Aliasing {} to {} would change its type {} to {}",
                 dest,
-                src,
+                original,
                 self.value_type(dest),
                 ty
             );
@@ -457,6 +570,22 @@ impl DataFlowGraph {
 
         self.clear_results(dest_inst);
     }
+
+    /// Get the stack map entries associated with the given instruction.
+    pub fn user_stack_map_entries(&self, inst: Inst) -> Option<&[UserStackMapEntry]> {
+        self.user_stack_maps.get(&inst).map(|es| &**es)
+    }
+
+    /// Append a new stack map entry for the given call instruction.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the given instruction is not a (non-tail) call instruction.
+    pub fn append_user_stack_map_entry(&mut self, inst: Inst, entry: UserStackMapEntry) {
+        let opcode = self.insts[inst].opcode();
+        assert!(opcode.is_safepoint());
+        self.user_stack_maps.entry(inst).or_default().push(entry);
+    }
 }
 
 /// Where did a value come from?
@@ -545,10 +674,15 @@ struct ValueDataPacked(u64);
 /// (and is implied by `mask`), by translating 2^32-1 (0xffffffff)
 /// into 2^n-1 and panic'ing on 2^n..2^32-1.
 fn encode_narrow_field(x: u32, bits: u8) -> u32 {
+    let max = (1 << bits) - 1;
     if x == 0xffff_ffff {
-        (1 << bits) - 1
+        max
     } else {
-        debug_assert!(x < (1 << bits));
+        debug_assert!(
+            x < max,
+            "{x} does not fit into {bits} bits (must be less than {max} to \
+             allow for a 0xffffffff sentinel)"
+        );
         x
     }
 }
@@ -624,7 +758,7 @@ impl From<ValueData> for ValueDataPacked {
                 Self::make(Self::TAG_ALIAS, ty, 0, original.as_bits())
             }
             ValueData::Union { ty, x, y } => {
-                Self::make(Self::TAG_ALIAS, ty, x.as_bits(), y.as_bits())
+                Self::make(Self::TAG_UNION, ty, x.as_bits(), y.as_bits())
             }
         }
     }
@@ -721,24 +855,11 @@ impl DataFlowGraph {
     }
 
     /// Map a function over the values of the instruction.
-    pub fn map_inst_values<F>(&mut self, inst: Inst, mut body: F)
+    pub fn map_inst_values<F>(&mut self, inst: Inst, body: F)
     where
-        F: FnMut(&mut DataFlowGraph, Value) -> Value,
+        F: FnMut(Value) -> Value,
     {
-        for i in 0..self.inst_args(inst).len() {
-            let arg = self.inst_args(inst)[i];
-            self.inst_args_mut(inst)[i] = body(self, arg);
-        }
-
-        for block_ix in 0..self.insts[inst].branch_destination(&self.jump_tables).len() {
-            // We aren't changing the size of the args list, so we won't need to write the branch
-            // back to the instruction.
-            let mut block = self.insts[inst].branch_destination(&self.jump_tables)[block_ix];
-            for i in 0..block.args_slice(&self.value_lists).len() {
-                let arg = block.args_slice(&self.value_lists)[i];
-                block.args_slice_mut(&mut self.value_lists)[i] = body(self, arg);
-            }
-        }
+        self.insts[inst].map_values(&mut self.value_lists, &mut self.jump_tables, body);
     }
 
     /// Overwrite the instruction's value references with values from the iterator.
@@ -748,16 +869,9 @@ impl DataFlowGraph {
     where
         I: Iterator<Item = Value>,
     {
-        for arg in self.inst_args_mut(inst) {
-            *arg = values.next().unwrap();
-        }
-
-        for block_ix in 0..self.insts[inst].branch_destination(&self.jump_tables).len() {
-            let mut block = self.insts[inst].branch_destination(&self.jump_tables)[block_ix];
-            for arg in block.args_slice_mut(&mut self.value_lists) {
-                *arg = values.next().unwrap();
-            }
-        }
+        self.insts[inst].map_values(&mut self.value_lists, &mut self.jump_tables, |_| {
+            values.next().unwrap()
+        });
     }
 
     /// Get all value arguments on `inst` as a slice.
@@ -836,22 +950,27 @@ impl DataFlowGraph {
     where
         I: Iterator<Item = Option<Value>>,
     {
-        self.results[inst].clear(&mut self.value_lists);
+        self.clear_results(inst);
 
         let mut reuse = reuse.fuse();
         let result_tys: SmallVec<[_; 16]> = self.inst_result_types(inst, ctrl_typevar).collect();
-        let num_results = result_tys.len();
 
-        for ty in result_tys {
-            if let Some(Some(v)) = reuse.next() {
-                debug_assert_eq!(self.value_type(v), ty, "Reused {} is wrong type", ty);
-                self.attach_result(inst, v);
+        for (expected, &ty) in result_tys.iter().enumerate() {
+            let num = u16::try_from(expected).expect("Result value index should fit in u16");
+            let value_data = ValueData::Inst { ty, num, inst };
+            let v = if let Some(Some(v)) = reuse.next() {
+                debug_assert_eq!(self.value_type(v), ty, "Reused {ty} is wrong type");
+                debug_assert!(!self.value_is_attached(v));
+                self.values[v] = value_data.into();
+                v
             } else {
-                self.append_result(inst, ty);
-            }
+                self.make_value(value_data)
+            };
+            let actual = self.results[inst].push(v, &mut self.value_lists);
+            debug_assert_eq!(expected, actual);
         }
 
-        num_results
+        result_tys.len()
     }
 
     /// Create a `ReplaceBuilder` that will replace `inst` with a new instruction in place.
@@ -859,14 +978,6 @@ impl DataFlowGraph {
         ReplaceBuilder::new(self, inst)
     }
 
-    /// Detach the list of result values from `inst` and return it.
-    ///
-    /// This leaves `inst` without any result values. New result values can be created by calling
-    /// `make_inst_results` or by using a `replace(inst)` builder.
-    pub fn detach_results(&mut self, inst: Inst) -> ValueList {
-        self.results[inst].take()
-    }
-
     /// Clear the list of result values from `inst`.
     ///
     /// This leaves `inst` without any result values. New result values can be created by calling
@@ -875,25 +986,6 @@ impl DataFlowGraph {
         self.results[inst].clear(&mut self.value_lists)
     }
 
-    /// Attach an existing value to the result value list for `inst`.
-    ///
-    /// The `res` value is appended to the end of the result list.
-    ///
-    /// This is a very low-level operation. Usually, instruction results with the correct types are
-    /// created automatically. The `res` value must not be attached to anything else.
-    pub fn attach_result(&mut self, inst: Inst, res: Value) {
-        debug_assert!(!self.value_is_attached(res));
-        let num = self.results[inst].push(res, &mut self.value_lists);
-        debug_assert!(num <= u16::MAX as usize, "Too many result values");
-        let ty = self.value_type(res);
-        self.values[res] = ValueData::Inst {
-            ty,
-            num: num as u16,
-            inst,
-        }
-        .into();
-    }
-
     /// Replace an instruction result with a new value of type `new_type`.
     ///
     /// The `old_value` must be an attached instruction result.
@@ -904,7 +996,7 @@ impl DataFlowGraph {
     pub fn replace_result(&mut self, old_value: Value, new_type: Type) -> Value {
         let (num, inst) = match ValueData::from(self.values[old_value]) {
             ValueData::Inst { num, inst, .. } => (num, inst),
-            _ => panic!("{} is not an instruction result value", old_value),
+            _ => panic!("{old_value} is not an instruction result value"),
         };
         let new_value = self.make_value(ValueData::Inst {
             ty: new_type,
@@ -928,23 +1020,11 @@ impl DataFlowGraph {
         new_value
     }
 
-    /// Append a new instruction result value to `inst`.
-    pub fn append_result(&mut self, inst: Inst, ty: Type) -> Value {
-        let res = self.values.next_key();
-        let num = self.results[inst].push(res, &mut self.value_lists);
-        debug_assert!(num <= u16::MAX as usize, "Too many result values");
-        self.make_value(ValueData::Inst {
-            ty,
-            inst,
-            num: num as u16,
-        })
-    }
-
     /// Clone an instruction, attaching new result `Value`s and
     /// returning them.
     pub fn clone_inst(&mut self, inst: Inst) -> Inst {
         // First, add a clone of the InstructionData.
-        let inst_data = self.insts[inst].clone();
+        let inst_data = self.insts[inst];
         // If the `inst_data` has a reference to a ValueList, clone it
         // as well, because we can't share these (otherwise mutating
         // one would affect the other).
@@ -953,7 +1033,13 @@ impl DataFlowGraph {
         // Get the controlling type variable.
         let ctrl_typevar = self.ctrl_typevar(inst);
         // Create new result values.
-        self.make_inst_results(new_inst, ctrl_typevar);
+        let num_results = self.make_inst_results(new_inst, ctrl_typevar);
+        // Copy over PCC facts, if any.
+        for i in 0..num_results {
+            let old_result = self.inst_results(inst)[i];
+            let new_result = self.inst_results(new_inst)[i];
+            self.facts[new_result] = self.facts[old_result].clone();
+        }
         new_inst
     }
 
@@ -1165,7 +1251,7 @@ impl DataFlowGraph {
             if let ValueData::Param { num, block, .. } = ValueData::from(self.values[val]) {
                 (block, num)
             } else {
-                panic!("{} must be a block parameter", val);
+                panic!("{val} must be a block parameter");
             };
         self.blocks[block]
             .params
@@ -1184,7 +1270,7 @@ impl DataFlowGraph {
                 *old_num = num;
                 self.values[last_arg_val] = last_arg_data.into();
             } else {
-                panic!("{} should be a Block parameter", last_arg_val);
+                panic!("{last_arg_val} should be a Block parameter");
             }
         }
         num as usize
@@ -1197,7 +1283,7 @@ impl DataFlowGraph {
             if let ValueData::Param { num, block, .. } = ValueData::from(self.values[val]) {
                 (block, num)
             } else {
-                panic!("{} must be a block parameter", val);
+                panic!("{val} must be a block parameter");
             };
         self.blocks[block]
             .params
@@ -1257,7 +1343,7 @@ impl DataFlowGraph {
             if let ValueData::Param { num, block, .. } = ValueData::from(self.values[old_value]) {
                 (block, num)
             } else {
-                panic!("{} must be a block parameter", old_value);
+                panic!("{old_value} must be a block parameter");
             };
         let new_arg = self.make_value(ValueData::Param {
             ty: new_type,
@@ -1279,6 +1365,38 @@ impl DataFlowGraph {
     pub fn detach_block_params(&mut self, block: Block) -> ValueList {
         self.blocks[block].params.take()
     }
+
+    /// Merge the facts for two values. If both values have facts and
+    /// they differ, both values get a special "conflict" fact that is
+    /// never satisfied.
+    pub fn merge_facts(&mut self, a: Value, b: Value) {
+        let a = self.resolve_aliases(a);
+        let b = self.resolve_aliases(b);
+        match (&self.facts[a], &self.facts[b]) {
+            (Some(a), Some(b)) if a == b => { /* nothing */ }
+            (None, None) => { /* nothing */ }
+            (Some(a), None) => {
+                self.facts[b] = Some(a.clone());
+            }
+            (None, Some(b)) => {
+                self.facts[a] = Some(b.clone());
+            }
+            (Some(a_fact), Some(b_fact)) => {
+                assert_eq!(self.value_type(a), self.value_type(b));
+                let merged = Fact::intersect(a_fact, b_fact);
+                crate::trace!(
+                    "facts merge on {} and {}: {:?}, {:?} -> {:?}",
+                    a,
+                    b,
+                    a_fact,
+                    b_fact,
+                    merged,
+                );
+                self.facts[a] = Some(merged.clone());
+                self.facts[b] = Some(merged);
+            }
+        }
+    }
 }
 
 /// Contents of a basic block.
@@ -1315,9 +1433,9 @@ impl<'a> fmt::Display for DisplayInst<'a> {
         let inst = self.1;
 
         if let Some((first, rest)) = dfg.inst_results(inst).split_first() {
-            write!(f, "{}", first)?;
+            write!(f, "{first}")?;
             for v in rest {
-                write!(f, ", {}", v)?;
+                write!(f, ", {v}")?;
             }
             write!(f, " = ")?;
         }
@@ -1375,7 +1493,7 @@ impl DataFlowGraph {
         for ty in result_tys {
             if ty.is_dynamic_vector() {
                 self.check_dynamic_type(ty)
-                    .unwrap_or_else(|| panic!("Use of undeclared dynamic type: {}", ty));
+                    .unwrap_or_else(|| panic!("Use of undeclared dynamic type: {ty}"));
             }
             if let Some(v) = reuse_iter.next() {
                 self.set_value_type_for_parser(v, ty);
@@ -1478,8 +1596,7 @@ impl DataFlowGraph {
 mod tests {
     use super::*;
     use crate::cursor::{Cursor, FuncCursor};
-    use crate::ir::types;
-    use crate::ir::{Function, InstructionData, Opcode, TrapCode};
+    use crate::ir::{Function, Opcode, TrapCode};
     use alloc::string::ToString;
 
     #[test]
@@ -1651,8 +1768,7 @@ mod tests {
         };
 
         // Remove `c` from the result list.
-        pos.func.dfg.clear_results(iadd);
-        pos.func.dfg.attach_result(iadd, s);
+        pos.func.stencil.dfg.results[iadd].remove(1, &mut pos.func.stencil.dfg.value_lists);
 
         // Replace `uadd_overflow` with a normal `iadd` and an `icmp`.
         pos.func.dfg.replace(iadd).iadd(v1, arg0);
diff --git a/cranelift/codegen/src/ir/dynamic_type.rs b/cranelift/codegen/src/ir/dynamic_type.rs
index ef802f90e9ac..d98ced809ef6 100644
--- a/cranelift/codegen/src/ir/dynamic_type.rs
+++ b/cranelift/codegen/src/ir/dynamic_type.rs
@@ -4,7 +4,6 @@ use crate::ir::entities::DynamicType;
 use crate::ir::types::*;
 use crate::ir::GlobalValue;
 use crate::ir::PrimaryMap;
-use crate::ir::Type;
 
 #[cfg(feature = "enable-serde")]
 use serde_derive::{Deserialize, Serialize};
diff --git a/cranelift/codegen/src/ir/entities.rs b/cranelift/codegen/src/ir/entities.rs
index f33e198c0936..e4ed6d55a030 100644
--- a/cranelift/codegen/src/ir/entities.rs
+++ b/cranelift/codegen/src/ir/entities.rs
@@ -56,8 +56,10 @@ impl Block {
 /// [`InstBuilder`](super::InstBuilder) instructions:
 ///
 /// - [`iconst`](super::InstBuilder::iconst) for integer constants
+/// - [`f16const`](super::InstBuilder::f16const) for 16-bit float constants
 /// - [`f32const`](super::InstBuilder::f32const) for 32-bit float constants
 /// - [`f64const`](super::InstBuilder::f64const) for 64-bit float constants
+/// - [`f128const`](super::InstBuilder::f128const) for 128-bit float constants
 /// - [`vconst`](super::InstBuilder::vconst) for vector constants
 /// - [`null`](super::InstBuilder::null) for null reference constants
 ///
@@ -174,18 +176,18 @@ impl DynamicType {
 
 /// An opaque reference to a global value.
 ///
-/// A `GlobalValue` is a [`Value`](Value) that will be live across the entire
+/// A `GlobalValue` is a [`Value`] that will be live across the entire
 /// function lifetime. It can be preloaded from other global values.
 ///
 /// You can create a `GlobalValue` in the following ways:
 ///
 /// - When compiling to WASM, you can use it to load values from a
-/// [`VmContext`](super::GlobalValueData::VMContext) using
-/// [`FuncEnvironment::make_global`](https://docs.rs/cranelift-wasm/*/cranelift_wasm/trait.FuncEnvironment.html#tymethod.make_global).
+///   [`VmContext`](super::GlobalValueData::VMContext) using
+///   [`FuncEnvironment::make_global`](https://docs.rs/cranelift-wasm/*/cranelift_wasm/trait.FuncEnvironment.html#tymethod.make_global).
 /// - When compiling to native code, you can use it for objects in static memory with
-/// [`Module::declare_data_in_func`](https://docs.rs/cranelift-module/*/cranelift_module/trait.Module.html#method.declare_data_in_func).
+///   [`Module::declare_data_in_func`](https://docs.rs/cranelift-module/*/cranelift_module/trait.Module.html#method.declare_data_in_func).
 /// - For any compilation target, it can be registered with
-/// [`FunctionBuilder::create_global_value`](https://docs.rs/cranelift-frontend/*/cranelift_frontend/struct.FunctionBuilder.html#method.create_global_value).
+///   [`FunctionBuilder::create_global_value`](https://docs.rs/cranelift-frontend/*/cranelift_frontend/struct.FunctionBuilder.html#method.create_global_value).
 ///
 /// `GlobalValue`s can be retrieved with
 /// [`InstBuilder:global_value`](super::InstBuilder::global_value).
@@ -209,6 +211,29 @@ impl GlobalValue {
     }
 }
 
+/// An opaque reference to a memory type.
+///
+/// A `MemoryType` is a descriptor of a struct layout in memory, with
+/// types and proof-carrying-code facts optionally attached to the
+/// fields.
+#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct MemoryType(u32);
+entity_impl!(MemoryType, "mt");
+
+impl MemoryType {
+    /// Create a new memory type reference from its number.
+    ///
+    /// This method is for use by the parser.
+    pub fn with_number(n: u32) -> Option<Self> {
+        if n < u32::MAX {
+            Some(Self(n))
+        } else {
+            None
+        }
+    }
+}
+
 /// An opaque reference to a constant.
 ///
 /// You can store [`ConstantData`](super::ConstantData) in a
@@ -300,13 +325,13 @@ impl JumpTable {
 /// `FuncRef`s can be created with
 ///
 /// - [`FunctionBuilder::import_function`](https://docs.rs/cranelift-frontend/*/cranelift_frontend/struct.FunctionBuilder.html#method.import_function)
-/// for external functions
+///   for external functions
 /// - [`Module::declare_func_in_func`](https://docs.rs/cranelift-module/*/cranelift_module/trait.Module.html#method.declare_func_in_func)
-/// for functions declared elsewhere in the same native
-/// [`Module`](https://docs.rs/cranelift-module/*/cranelift_module/trait.Module.html)
+///   for functions declared elsewhere in the same native
+///   [`Module`](https://docs.rs/cranelift-module/*/cranelift_module/trait.Module.html)
 /// - [`FuncEnvironment::make_direct_func`](https://docs.rs/cranelift-wasm/*/cranelift_wasm/trait.FuncEnvironment.html#tymethod.make_direct_func)
-/// for functions declared in the same WebAssembly
-/// [`FuncEnvironment`](https://docs.rs/cranelift-wasm/*/cranelift_wasm/trait.FuncEnvironment.html#tymethod.make_direct_func)
+///   for functions declared in the same WebAssembly
+///   [`FuncEnvironment`](https://docs.rs/cranelift-wasm/*/cranelift_wasm/trait.FuncEnvironment.html#tymethod.make_direct_func)
 ///
 /// While the order is stable, it is arbitrary.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
@@ -365,33 +390,6 @@ impl SigRef {
     }
 }
 
-/// An opaque reference to a [WebAssembly
-/// table](https://developer.mozilla.org/en-US/docs/WebAssembly/Understanding_the_text_format#WebAssembly_tables).
-///
-/// `Table`s are used to store a list of function references.
-/// They can be created with [`FuncEnvironment::make_table`](https://docs.rs/cranelift-wasm/*/cranelift_wasm/trait.FuncEnvironment.html#tymethod.make_table).
-/// They can be used with
-/// [`FuncEnvironment::translate_call_indirect`](https://docs.rs/cranelift-wasm/*/cranelift_wasm/trait.FuncEnvironment.html#tymethod.translate_call_indirect).
-///
-/// While the order is stable, it is arbitrary.
-#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-pub struct Table(u32);
-entity_impl!(Table, "table");
-
-impl Table {
-    /// Create a new table reference from its number.
-    ///
-    /// This method is for use by the parser.
-    pub fn with_number(n: u32) -> Option<Self> {
-        if n < u32::MAX {
-            Some(Self(n))
-        } else {
-            None
-        }
-    }
-}
-
 /// An opaque reference to any of the entities defined in this module that can appear in CLIF IR.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
@@ -412,6 +410,8 @@ pub enum AnyEntity {
     DynamicType(DynamicType),
     /// A Global value.
     GlobalValue(GlobalValue),
+    /// A memory type.
+    MemoryType(MemoryType),
     /// A jump table.
     JumpTable(JumpTable),
     /// A constant.
@@ -420,8 +420,6 @@ pub enum AnyEntity {
     FuncRef(FuncRef),
     /// A function call signature.
     SigRef(SigRef),
-    /// A table.
-    Table(Table),
     /// A function's stack limit
     StackLimit,
 }
@@ -437,11 +435,11 @@ impl fmt::Display for AnyEntity {
             Self::DynamicStackSlot(r) => r.fmt(f),
             Self::DynamicType(r) => r.fmt(f),
             Self::GlobalValue(r) => r.fmt(f),
+            Self::MemoryType(r) => r.fmt(f),
             Self::JumpTable(r) => r.fmt(f),
             Self::Constant(r) => r.fmt(f),
             Self::FuncRef(r) => r.fmt(f),
             Self::SigRef(r) => r.fmt(f),
-            Self::Table(r) => r.fmt(f),
             Self::StackLimit => write!(f, "stack_limit"),
         }
     }
@@ -495,6 +493,12 @@ impl From<GlobalValue> for AnyEntity {
     }
 }
 
+impl From<MemoryType> for AnyEntity {
+    fn from(r: MemoryType) -> Self {
+        Self::MemoryType(r)
+    }
+}
+
 impl From<JumpTable> for AnyEntity {
     fn from(r: JumpTable) -> Self {
         Self::JumpTable(r)
@@ -519,17 +523,10 @@ impl From<SigRef> for AnyEntity {
     }
 }
 
-impl From<Table> for AnyEntity {
-    fn from(r: Table) -> Self {
-        Self::Table(r)
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
     use alloc::string::ToString;
-    use core::u32;
 
     #[test]
     fn value_with_number() {
diff --git a/cranelift/codegen/src/ir/extfunc.rs b/cranelift/codegen/src/ir/extfunc.rs
index cafdb11dc995..319ec4038243 100644
--- a/cranelift/codegen/src/ir/extfunc.rs
+++ b/cranelift/codegen/src/ir/extfunc.rs
@@ -108,9 +108,9 @@ fn write_list(f: &mut fmt::Formatter, args: &[AbiParam]) -> fmt::Result {
     match args.split_first() {
         None => {}
         Some((first, rest)) => {
-            write!(f, "{}", first)?;
+            write!(f, "{first}")?;
             for arg in rest {
-                write!(f, ", {}", arg)?;
+                write!(f, ", {arg}")?;
             }
         }
     }
@@ -233,7 +233,13 @@ pub enum ArgumentPurpose {
     Normal,
 
     /// A C struct passed as argument.
-    StructArgument(u32),
+    ///
+    /// Note that this should only be used when interacting with code following
+    /// a C ABI which is expecting a struct passed *by value*.
+    StructArgument(
+        /// The size, in bytes, of the struct.
+        u32,
+    ),
 
     /// Struct return pointer.
     ///
@@ -250,22 +256,15 @@ pub enum ArgumentPurpose {
     /// This is a pointer to a context struct containing details about the current sandbox. It is
     /// used as a base pointer for `vmctx` global values.
     VMContext,
-
-    /// A stack limit pointer.
-    ///
-    /// This is a pointer to a stack limit. It is used to check the current stack pointer
-    /// against. Can only appear once in a signature.
-    StackLimit,
 }
 
 impl fmt::Display for ArgumentPurpose {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.write_str(match self {
             Self::Normal => "normal",
-            Self::StructArgument(size) => return write!(f, "sarg({})", size),
+            Self::StructArgument(size) => return write!(f, "sarg({size})"),
             Self::StructReturn => "sret",
             Self::VMContext => "vmctx",
-            Self::StackLimit => "stack_limit",
         })
     }
 }
@@ -277,7 +276,6 @@ impl FromStr for ArgumentPurpose {
             "normal" => Ok(Self::Normal),
             "sret" => Ok(Self::StructReturn),
             "vmctx" => Ok(Self::VMContext),
-            "stack_limit" => Ok(Self::StackLimit),
             _ if s.starts_with("sarg(") => {
                 if !s.ends_with(")") {
                     return Err(());
@@ -374,7 +372,6 @@ mod tests {
             (ArgumentPurpose::Normal, "normal"),
             (ArgumentPurpose::StructReturn, "sret"),
             (ArgumentPurpose::VMContext, "vmctx"),
-            (ArgumentPurpose::StackLimit, "stack_limit"),
             (ArgumentPurpose::StructArgument(42), "sarg(42)"),
         ];
         for &(e, n) in &all_purpose {
diff --git a/cranelift/codegen/src/ir/extname.rs b/cranelift/codegen/src/ir/extname.rs
index b06eb843f536..8484376b5a87 100644
--- a/cranelift/codegen/src/ir/extname.rs
+++ b/cranelift/codegen/src/ir/extname.rs
@@ -105,7 +105,7 @@ impl fmt::Display for TestcaseName {
 
 impl fmt::Debug for TestcaseName {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self)
+        write!(f, "{self}")
     }
 }
 
@@ -204,8 +204,8 @@ impl<'a> fmt::Display for DisplayableExternalName<'a> {
                 }
             }
             ExternalName::TestCase(testcase) => testcase.fmt(f),
-            ExternalName::LibCall(lc) => write!(f, "%{}", lc),
-            ExternalName::KnownSymbol(ks) => write!(f, "%{}", ks),
+            ExternalName::LibCall(lc) => write!(f, "%{lc}"),
+            ExternalName::KnownSymbol(ks) => write!(f, "%{ks}"),
         }
     }
 }
diff --git a/cranelift/codegen/src/ir/function.rs b/cranelift/codegen/src/ir/function.rs
index f5b85c50af80..39dfbbf6435d 100644
--- a/cranelift/codegen/src/ir/function.rs
+++ b/cranelift/codegen/src/ir/function.rs
@@ -5,10 +5,10 @@
 
 use crate::entity::{PrimaryMap, SecondaryMap};
 use crate::ir::{
-    self, Block, DataFlowGraph, DynamicStackSlot, DynamicStackSlotData, DynamicStackSlots,
-    DynamicType, ExtFuncData, FuncRef, GlobalValue, GlobalValueData, Inst, JumpTable,
-    JumpTableData, Layout, Opcode, SigRef, Signature, SourceLocs, StackSlot, StackSlotData,
-    StackSlots, Table, TableData, Type,
+    self, pcc::Fact, Block, DataFlowGraph, DynamicStackSlot, DynamicStackSlotData,
+    DynamicStackSlots, DynamicType, ExtFuncData, FuncRef, GlobalValue, GlobalValueData, Inst,
+    JumpTable, JumpTableData, Layout, MemoryType, MemoryTypeData, Opcode, SigRef, Signature,
+    SourceLocs, StackSlot, StackSlotData, StackSlots, Type,
 };
 use crate::isa::CallConv;
 use crate::write::write_function;
@@ -172,8 +172,11 @@ pub struct FunctionStencil {
     /// Global values referenced.
     pub global_values: PrimaryMap<ir::GlobalValue, ir::GlobalValueData>,
 
-    /// Tables referenced.
-    pub tables: PrimaryMap<ir::Table, ir::TableData>,
+    /// Global value proof-carrying-code facts.
+    pub global_value_facts: SecondaryMap<ir::GlobalValue, Option<Fact>>,
+
+    /// Memory types for proof-carrying code.
+    pub memory_types: PrimaryMap<ir::MemoryType, ir::MemoryTypeData>,
 
     /// Data flow graph containing the primary definition of all instructions, blocks and values.
     pub dfg: DataFlowGraph,
@@ -201,7 +204,8 @@ impl FunctionStencil {
         self.sized_stack_slots.clear();
         self.dynamic_stack_slots.clear();
         self.global_values.clear();
-        self.tables.clear();
+        self.global_value_facts.clear();
+        self.memory_types.clear();
         self.dfg.clear();
         self.layout.clear();
         self.srclocs.clear();
@@ -235,6 +239,11 @@ impl FunctionStencil {
         self.global_values.push(data)
     }
 
+    /// Declares a memory type for use by the function.
+    pub fn create_memory_type(&mut self, data: MemoryTypeData) -> MemoryType {
+        self.memory_types.push(data)
+    }
+
     /// Find the global dyn_scale value associated with given DynamicType.
     pub fn get_dyn_scale(&self, ty: DynamicType) -> GlobalValue {
         self.dfg.dynamic_types.get(ty).unwrap().dynamic_scale
@@ -251,15 +260,10 @@ impl FunctionStencil {
         self.dfg
             .dynamic_types
             .get(ty)
-            .unwrap_or_else(|| panic!("Undeclared dynamic vector type: {}", ty))
+            .unwrap_or_else(|| panic!("Undeclared dynamic vector type: {ty}"))
             .concrete()
     }
 
-    /// Declares a table accessible to the function.
-    pub fn create_table(&mut self, data: TableData) -> Table {
-        self.tables.push(data)
-    }
-
     /// Find a presumed unique special-purpose function parameter value.
     ///
     /// Returns the value of the last `purpose` parameter, or `None` if no such parameter exists.
@@ -309,12 +313,32 @@ impl FunctionStencil {
         Ok(())
     }
 
+    /// Returns an iterator over the blocks succeeding the given block.
+    pub fn block_successors(&self, block: Block) -> impl DoubleEndedIterator<Item = Block> + '_ {
+        self.layout.last_inst(block).into_iter().flat_map(|inst| {
+            self.dfg.insts[inst]
+                .branch_destination(&self.dfg.jump_tables)
+                .iter()
+                .map(|block| block.block(&self.dfg.value_lists))
+        })
+    }
+
     /// Returns true if the function is function that doesn't call any other functions. This is not
     /// to be confused with a "leaf function" in Windows terminology.
     pub fn is_leaf(&self) -> bool {
         // Conservative result: if there's at least one function signature referenced in this
         // function, assume it is not a leaf.
-        self.dfg.signatures.is_empty()
+        let has_signatures = !self.dfg.signatures.is_empty();
+
+        // Under some TLS models, retrieving the address of a TLS variable requires calling a
+        // function. Conservatively assume that any function that references a tls global value
+        // is not a leaf.
+        let has_tls = self.global_values.values().any(|gv| match gv {
+            GlobalValueData::Symbol { tls, .. } => *tls,
+            _ => false,
+        });
+
+        !has_signatures && !has_tls
     }
 
     /// Replace the `dst` instruction's data with the `src` instruction's data
@@ -398,7 +422,8 @@ impl Function {
                 sized_stack_slots: StackSlots::new(),
                 dynamic_stack_slots: DynamicStackSlots::new(),
                 global_values: PrimaryMap::new(),
-                tables: PrimaryMap::new(),
+                global_value_facts: SecondaryMap::new(),
+                memory_types: PrimaryMap::new(),
                 dfg: DataFlowGraph::new(),
                 layout: Layout::new(),
                 srclocs: SecondaryMap::new(),
diff --git a/cranelift/codegen/src/ir/globalvalue.rs b/cranelift/codegen/src/ir/globalvalue.rs
index 530875641e43..89120c8b8364 100644
--- a/cranelift/codegen/src/ir/globalvalue.rs
+++ b/cranelift/codegen/src/ir/globalvalue.rs
@@ -1,7 +1,7 @@
 //! Global values.
 
 use crate::ir::immediates::{Imm64, Offset32};
-use crate::ir::{ExternalName, GlobalValue, Type};
+use crate::ir::{ExternalName, GlobalValue, MemFlags, Type};
 use crate::isa::TargetIsa;
 use core::fmt;
 
@@ -9,7 +9,7 @@ use core::fmt;
 use serde_derive::{Deserialize, Serialize};
 
 /// Information about a global value declaration.
-#[derive(Clone, PartialEq, Hash)]
+#[derive(Debug, Clone, PartialEq, Hash)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub enum GlobalValueData {
     /// Value is the address of the VM context struct.
@@ -31,9 +31,8 @@ pub enum GlobalValueData {
         /// Type of the loaded value.
         global_type: Type,
 
-        /// Specifies whether the memory that this refers to is readonly, allowing for the
-        /// elimination of redundant loads.
-        readonly: bool,
+        /// Specifies the memory flags to be used by the load. Guaranteed to be notrap and aligned.
+        flags: MemFlags,
     },
 
     /// Value is an offset from another global value.
@@ -111,20 +110,13 @@ impl fmt::Display for GlobalValueData {
                 base,
                 offset,
                 global_type,
-                readonly,
-            } => write!(
-                f,
-                "load.{} notrap aligned {}{}{}",
-                global_type,
-                if readonly { "readonly " } else { "" },
-                base,
-                offset
-            ),
+                flags,
+            } => write!(f, "load.{global_type}{flags} {base}{offset}"),
             Self::IAddImm {
                 global_type,
                 base,
                 offset,
-            } => write!(f, "iadd_imm.{} {}, {}", global_type, base, offset),
+            } => write!(f, "iadd_imm.{global_type} {base}, {offset}"),
             Self::Symbol {
                 ref name,
                 offset,
@@ -143,12 +135,12 @@ impl fmt::Display for GlobalValueData {
                     write!(f, "+")?;
                 }
                 if offset_val != 0 {
-                    write!(f, "{}", offset)?;
+                    write!(f, "{offset}")?;
                 }
                 Ok(())
             }
             Self::DynScaleTargetConst { vector_type } => {
-                write!(f, "dyn_scale_target_const.{}", vector_type)
+                write!(f, "dyn_scale_target_const.{vector_type}")
             }
         }
     }
diff --git a/cranelift/codegen/src/ir/immediates.rs b/cranelift/codegen/src/ir/immediates.rs
index 9900cb8064e7..7ec7ab8efad1 100644
--- a/cranelift/codegen/src/ir/immediates.rs
+++ b/cranelift/codegen/src/ir/immediates.rs
@@ -6,7 +6,6 @@
 
 use alloc::vec::Vec;
 use core::cmp::Ordering;
-use core::convert::TryFrom;
 use core::fmt::{self, Display, Formatter};
 use core::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Neg, Not, Sub};
 use core::str::FromStr;
@@ -75,19 +74,38 @@ impl Imm64 {
         self.0
     }
 
+    /// Mask this immediate to the given power-of-two bit width.
+    #[must_use]
+    pub(crate) fn mask_to_width(&self, bit_width: u32) -> Self {
+        debug_assert!(bit_width.is_power_of_two());
+
+        if bit_width >= 64 {
+            return *self;
+        }
+
+        let bit_width = i64::from(bit_width);
+        let mask = (1 << bit_width) - 1;
+        let masked = self.0 & mask;
+        Imm64(masked)
+    }
+
     /// Sign extend this immediate as if it were a signed integer of the given
     /// power-of-two width.
-    pub fn sign_extend_from_width(&mut self, bit_width: u32) {
-        debug_assert!(bit_width.is_power_of_two());
+    #[must_use]
+    pub(crate) fn sign_extend_from_width(&self, bit_width: u32) -> Self {
+        debug_assert!(
+            bit_width.is_power_of_two(),
+            "{bit_width} is not a power of two"
+        );
 
         if bit_width >= 64 {
-            return;
+            return *self;
         }
 
         let bit_width = i64::from(bit_width);
         let delta = 64 - bit_width;
         let sign_extended = (self.0 << delta) >> delta;
-        *self = Imm64(sign_extended);
+        Imm64(sign_extended)
     }
 }
 
@@ -112,9 +130,9 @@ impl From<i64> for Imm64 {
 impl Display for Imm64 {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         let x = self.0;
-        if -10_000 < x && x < 10_000 {
-            // Use decimal for small numbers.
-            write!(f, "{}", x)
+        if x < 10_000 {
+            // Use decimal for small and negative numbers.
+            write!(f, "{x}")
         } else {
             write_hex(x as u64, f)
         }
@@ -205,7 +223,7 @@ impl Display for Uimm64 {
         let x = self.0;
         if x < 10_000 {
             // Use decimal for small numbers.
-            write!(f, "{}", x)
+            write!(f, "{x}")
         } else {
             write_hex(x, f)
         }
@@ -219,9 +237,9 @@ fn parse_u64(s: &str) -> Result<u64, &'static str> {
 
     if s.starts_with("-0x") {
         return Err("Invalid character in hexadecimal number");
-    } else if s.starts_with("0x") {
+    } else if let Some(num) = s.strip_prefix("0x") {
         // Hexadecimal.
-        for ch in s[2..].chars() {
+        for ch in num.chars() {
             match ch.to_digit(16) {
                 Some(digit) => {
                     digits += 1;
@@ -242,7 +260,7 @@ fn parse_u64(s: &str) -> Result<u64, &'static str> {
     } else {
         // Decimal number, possibly negative.
         for ch in s.chars() {
-            match ch.to_digit(16) {
+            match ch.to_digit(10) {
                 Some(digit) => {
                     digits += 1;
                     match value.checked_mul(10) {
@@ -444,7 +462,7 @@ impl Display for Offset32 {
 
         let val = i64::from(self.0).abs();
         if val < 10_000 {
-            write!(f, "{}", val)
+            write!(f, "{val}")
         } else {
             write_hex(val as u64, f)
         }
@@ -469,35 +487,381 @@ impl FromStr for Offset32 {
     }
 }
 
-/// An IEEE binary32 immediate floating point value, represented as a u32
-/// containing the bit pattern.
-///
-/// We specifically avoid using a f32 here since some architectures may silently alter floats.
-/// See: <https://github.com/bytecodealliance/wasmtime/pull/2251#discussion_r498508646>
-///
-/// The [PartialEq] and [Hash] implementations are over the underlying bit pattern, but
-/// [PartialOrd] respects IEEE754 semantics.
-///
-/// All bit patterns are allowed.
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
-#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[repr(C)]
-pub struct Ieee32(u32);
+// FIXME(rust-lang/rust#83527): Replace with `${ignore()}` once it is stabilised.
+macro_rules! ignore {
+    ($($t:tt)*) => {};
+}
+
+macro_rules! ieee_float {
+    (
+        name = $name:ident,
+        bits = $bits:literal,
+        significand_bits = $significand_bits:literal,
+        bits_ty = $bits_ty:ident,
+        float_ty = $float_ty:ident,
+        $(as_float = $as_float:ident,)?
+        $(rust_type_not_stable = $rust_type_not_stable:ident,)?
+    ) => {
+        /// An IEEE
+        #[doc = concat!("binary", stringify!($bits))]
+        /// immediate floating point value, represented as a
+        #[doc = stringify!($bits_ty)]
+        /// containing the bit pattern.
+        ///
+        /// We specifically avoid using a
+        #[doc = stringify!($float_ty)]
+        /// here since some architectures may silently alter floats.
+        /// See: <https://github.com/bytecodealliance/wasmtime/pull/2251#discussion_r498508646>
+        ///
+        /// The [PartialEq] and [Hash] implementations are over the underlying bit pattern, but
+        /// [PartialOrd] respects IEEE754 semantics.
+        ///
+        /// All bit patterns are allowed.
+        #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
+        #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+        #[repr(C)]
+        pub struct $name {
+            bits: $bits_ty
+        }
 
-/// An IEEE binary64 immediate floating point value, represented as a u64
-/// containing the bit pattern.
-///
-/// We specifically avoid using a f64 here since some architectures may silently alter floats.
-/// See: <https://github.com/bytecodealliance/wasmtime/pull/2251#discussion_r498508646>
-///
-/// The [PartialEq] and [Hash] implementations are over the underlying bit pattern, but
-/// [PartialOrd] respects IEEE754 semantics.
-///
-/// All bit patterns are allowed.
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
-#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-#[repr(C)]
-pub struct Ieee64(u64);
+        impl $name {
+            const BITS: u8 = $bits;
+            const SIGNIFICAND_BITS: u8 = $significand_bits;
+            const EXPONENT_BITS: u8 = Self::BITS - Self::SIGNIFICAND_BITS - 1;
+            const SIGN_MASK: $bits_ty = 1 << (Self::EXPONENT_BITS + Self::SIGNIFICAND_BITS);
+            const SIGNIFICAND_MASK: $bits_ty = $bits_ty::MAX >> (Self::EXPONENT_BITS + 1);
+            const EXPONENT_MASK: $bits_ty = !Self::SIGN_MASK & !Self::SIGNIFICAND_MASK;
+            /// The positive WebAssembly canonical NaN.
+            pub const NAN: Self = Self::with_bits(Self::EXPONENT_MASK | (1 << (Self::SIGNIFICAND_BITS - 1)));
+
+            /// Create a new
+            #[doc = concat!("`", stringify!($name), "`")]
+            /// containing the bits of `bits`.
+            pub const fn with_bits(bits: $bits_ty) -> Self {
+                Self { bits }
+            }
+
+            /// Get the bitwise representation.
+            pub fn bits(self) -> $bits_ty {
+                self.bits
+            }
+
+            $(
+                /// Create a new
+                #[doc = concat!("`", stringify!($name), "`")]
+                /// representing the number `x`.
+                pub fn with_float(x: $float_ty) -> Self {
+                    Self::with_bits(x.to_bits())
+                }
+
+                /// Converts `self` to a Rust
+                #[doc = concat!("`", stringify!($float_ty), "`.")]
+                pub fn $as_float(self) -> $float_ty {
+                    $float_ty::from_bits(self.bits())
+                }
+            )?
+
+            /// Computes the absolute value of `self`.
+            pub fn abs(self) -> Self {
+                Self::with_bits(self.bits() & !Self::SIGN_MASK)
+            }
+
+            /// Returns a number composed of the magnitude of `self` and the sign of `sign`.
+            pub fn copysign(self, sign: Self) -> Self {
+                Self::with_bits((self.bits() & !Self::SIGN_MASK) | (sign.bits() & Self::SIGN_MASK))
+            }
+
+            /// Returns the minimum of `self` and `other`, following the WebAssembly/IEEE 754-2019 definition.
+            pub fn minimum(self, other: Self) -> Self {
+                // FIXME: Replace with Rust float method once it is stabilised.
+                if self.is_nan() || other.is_nan() {
+                    Self::NAN
+                } else if self.is_zero() && other.is_zero() {
+                    if self.is_negative() {
+                        self
+                    } else {
+                        other
+                    }
+                } else if self <= other {
+                    self
+                } else {
+                    other
+                }
+            }
+
+            /// Returns the maximum of `self` and `other`, following the WebAssembly/IEEE 754-2019 definition.
+            pub fn maximum(self, other: Self) -> Self {
+                // FIXME: Replace with Rust float method once it is stabilised.
+                if self.is_nan() || other.is_nan() {
+                    Self::NAN
+                } else if self.is_zero() && other.is_zero() {
+                    if self.is_positive() {
+                        self
+                    } else {
+                        other
+                    }
+                } else if self >= other {
+                    self
+                } else {
+                    other
+                }
+            }
+
+            /// Create an
+            #[doc = concat!("`", stringify!($name), "`")]
+            /// number representing `2.0^n`.
+            pub fn pow2<I: Into<i32>>(n: I) -> Self {
+                let n = n.into();
+                let w = Self::EXPONENT_BITS;
+                let t = Self::SIGNIFICAND_BITS;
+                let bias = (1 << (w - 1)) - 1;
+                let exponent = n + bias;
+                assert!(exponent > 0, "Underflow n={}", n);
+                assert!(exponent < (1 << w) + 1, "Overflow n={}", n);
+                Self::with_bits((exponent as $bits_ty) << t)
+            }
+
+            /// Create an
+            #[doc = concat!("`", stringify!($name), "`")]
+            /// number representing the greatest negative value not convertible from
+            #[doc = concat!("`", stringify!($float_ty), "`")]
+            /// to a signed integer with width n.
+            pub fn fcvt_to_sint_negative_overflow<I: Into<i32>>(n: I) -> Self {
+                let n = n.into();
+                debug_assert!(n < i32::from(Self::BITS));
+                debug_assert!(i32::from(Self::SIGNIFICAND_BITS) + 1 - n < i32::from(Self::BITS));
+                Self::with_bits((1 << (Self::BITS - 1)) | Self::pow2(n - 1).bits() | (1 << (i32::from(Self::SIGNIFICAND_BITS) + 1 - n)))
+            }
+
+            /// Check if the value is a NaN. For
+            #[doc = concat!("`", stringify!($name), "`,")]
+            /// this means checking that all the exponent bits are set and the significand is non-zero.
+            pub fn is_nan(self) -> bool {
+                self.abs().bits() > Self::EXPONENT_MASK
+            }
+
+            /// Returns true if `self` has a negative sign, including 0.0, NaNs with positive sign bit and positive infinity.
+            pub fn is_positive(self) -> bool {
+                !self.is_negative()
+            }
+
+            /// Returns true if `self` has a negative sign, including -0.0, NaNs with negative sign bit and negative infinity.
+            pub fn is_negative(self) -> bool {
+                self.bits() & Self::SIGN_MASK == Self::SIGN_MASK
+            }
+
+            /// Returns `true` if `self` is positive or negative zero.
+            pub fn is_zero(self) -> bool {
+                self.abs().bits() == 0
+            }
+
+            /// Returns `None` if `self` is a NaN and `Some(self)` otherwise.
+            pub fn non_nan(self) -> Option<Self> {
+                Some(self).filter(|f| !f.is_nan())
+            }
+
+            $(
+                /// Returns the square root of `self`.
+                pub fn sqrt(self) -> Self {
+                    Self::with_float(self.$as_float().sqrt())
+                }
+
+                /// Returns the smallest integer greater than or equal to `self`.
+                pub fn ceil(self) -> Self {
+                    Self::with_float(self.$as_float().ceil())
+                }
+
+                /// Returns the largest integer less than or equal to `self`.
+                pub fn floor(self) -> Self {
+                    Self::with_float(self.$as_float().floor())
+                }
+
+                /// Returns the integer part of `self`. This means that non-integer numbers are always truncated towards zero.
+                pub fn trunc(self) -> Self {
+                    Self::with_float(self.$as_float().trunc())
+                }
+
+                /// Returns the nearest integer to `self`. Rounds half-way cases to the number
+                /// with an even least significant digit.
+                pub fn round_ties_even(self) -> Self {
+                    Self::with_float(self.$as_float().round_ties_even())
+                }
+            )?
+        }
+
+        impl PartialOrd for $name {
+            fn partial_cmp(&self, rhs: &Self) -> Option<Ordering> {
+                $(self.$as_float().partial_cmp(&rhs.$as_float()))?
+                $(
+                    ignore!($rust_type_not_stable);
+                    // FIXME(#8312): Use builtin Rust comparisons once `f16` and `f128` support is stabalised.
+                    if self.is_nan() || rhs.is_nan() {
+                        // One of the floats is a NaN.
+                        return None;
+                    }
+                    if self.is_zero() || rhs.is_zero() {
+                        // Zeros are always equal regardless of sign.
+                        return Some(Ordering::Equal);
+                    }
+                    let lhs_positive = self.is_positive();
+                    let rhs_positive = rhs.is_positive();
+                    if lhs_positive != rhs_positive {
+                        // Different signs: negative < positive
+                        return lhs_positive.partial_cmp(&rhs_positive);
+                    }
+                    // Finite or infinity will order correctly with an integer comparison of the bits.
+                    if lhs_positive {
+                        self.bits().partial_cmp(&rhs.bits())
+                    } else {
+                        // Reverse the comparison when both floats are negative.
+                        rhs.bits().partial_cmp(&self.bits())
+                    }
+                )?
+            }
+        }
+
+        impl Display for $name {
+            fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+                format_float(u128::from(self.bits()), Self::EXPONENT_BITS, Self::SIGNIFICAND_BITS, f)
+            }
+        }
+
+        impl FromStr for $name {
+            type Err = &'static str;
+
+            fn from_str(s: &str) -> Result<Self, &'static str> {
+                match parse_float(s, Self::EXPONENT_BITS, Self::SIGNIFICAND_BITS) {
+                    Ok(b) => Ok(Self::with_bits(b.try_into().unwrap())),
+                    Err(s) => Err(s),
+                }
+            }
+        }
+
+        impl IntoBytes for $name {
+            fn into_bytes(self) -> Vec<u8> {
+                self.bits().to_le_bytes().to_vec()
+            }
+        }
+
+        impl Neg for $name {
+            type Output = Self;
+
+            fn neg(self) -> Self {
+                Self::with_bits(self.bits() ^ Self::SIGN_MASK)
+            }
+        }
+
+
+
+        $(
+            impl From<$float_ty> for $name {
+                fn from(x: $float_ty) -> Self {
+                    Self::with_float(x)
+                }
+            }
+
+            impl Add for $name {
+                type Output = Self;
+
+                fn add(self, rhs: Self) -> Self {
+                    Self::with_float(self.$as_float() + rhs.$as_float())
+                }
+            }
+
+            impl Sub for $name {
+                type Output = Self;
+
+                fn sub(self, rhs: Self) -> Self {
+                    Self::with_float(self.$as_float() - rhs.$as_float())
+                }
+            }
+
+            impl Mul for $name {
+                type Output = Self;
+
+                fn mul(self, rhs: Self) -> Self {
+                    Self::with_float(self.$as_float() * rhs.$as_float())
+                }
+            }
+
+            impl Div for $name {
+                type Output = Self;
+
+                fn div(self, rhs: Self) -> Self::Output {
+                    Self::with_float(self.$as_float() / rhs.$as_float())
+                }
+            }
+        )?
+
+        impl BitAnd for $name {
+            type Output = Self;
+
+            fn bitand(self, rhs: Self) -> Self {
+                Self::with_bits(self.bits() & rhs.bits())
+            }
+        }
+
+        impl BitOr for $name {
+            type Output = Self;
+
+            fn bitor(self, rhs: Self) -> Self {
+                Self::with_bits(self.bits() | rhs.bits())
+            }
+        }
+
+        impl BitXor for $name {
+            type Output = Self;
+
+            fn bitxor(self, rhs: Self) -> Self {
+                Self::with_bits(self.bits() ^ rhs.bits())
+            }
+        }
+
+        impl Not for $name {
+            type Output = Self;
+
+            fn not(self) -> Self {
+                Self::with_bits(!self.bits())
+            }
+        }
+    };
+}
+
+ieee_float! {
+    name = Ieee16,
+    bits = 16,
+    significand_bits = 10,
+    bits_ty = u16,
+    float_ty = f16,
+    rust_type_not_stable = rust_type_not_stable,
+}
+
+ieee_float! {
+    name = Ieee32,
+    bits = 32,
+    significand_bits = 23,
+    bits_ty = u32,
+    float_ty = f32,
+    as_float = as_f32,
+}
+
+ieee_float! {
+    name = Ieee64,
+    bits = 64,
+    significand_bits = 52,
+    bits_ty = u64,
+    float_ty = f64,
+    as_float = as_f64,
+}
+
+ieee_float! {
+    name = Ieee128,
+    bits = 128,
+    significand_bits = 112,
+    bits_ty = u128,
+    float_ty = f128,
+    rust_type_not_stable = rust_type_not_stable,
+}
 
 /// Format a floating point number in a way that is reasonably human-readable, and that can be
 /// converted back to binary without any rounding issues. The hexadecimal formatting of normal and
@@ -509,13 +873,13 @@ pub struct Ieee64(u64);
 /// w - exponent field width in bits
 /// t - trailing significand field width in bits
 ///
-fn format_float(bits: u64, w: u8, t: u8, f: &mut Formatter) -> fmt::Result {
+fn format_float(bits: u128, w: u8, t: u8, f: &mut Formatter) -> fmt::Result {
     debug_assert!(w > 0 && w <= 16, "Invalid exponent range");
-    debug_assert!(1 + w + t <= 64, "Too large IEEE format for u64");
+    debug_assert!(1 + w + t <= 128, "Too large IEEE format for u128");
     debug_assert!((t + w + 1).is_power_of_two(), "Unexpected IEEE format size");
 
-    let max_e_bits = (1u64 << w) - 1;
-    let t_bits = bits & ((1u64 << t) - 1); // Trailing significand.
+    let max_e_bits = (1u128 << w) - 1;
+    let t_bits = bits & ((1u128 << t) - 1); // Trailing significand.
     let e_bits = (bits >> t) & max_e_bits; // Biased exponent.
     let sign_bit = (bits >> (w + t)) & 1;
 
@@ -562,13 +926,13 @@ fn format_float(bits: u64, w: u8, t: u8, f: &mut Formatter) -> fmt::Result {
             if t_bits & (1 << (t - 1)) != 0 {
                 // Quiet NaN.
                 if payload != 0 {
-                    write!(f, "NaN:0x{:x}", payload)
+                    write!(f, "NaN:0x{payload:x}")
                 } else {
                     write!(f, "NaN")
                 }
             } else {
                 // Signaling NaN.
-                write!(f, "sNaN:0x{:x}", payload)
+                write!(f, "sNaN:0x{payload:x}")
             }
         }
     } else {
@@ -584,22 +948,22 @@ fn format_float(bits: u64, w: u8, t: u8, f: &mut Formatter) -> fmt::Result {
 /// w - exponent field width in bits
 /// t - trailing significand field width in bits
 ///
-fn parse_float(s: &str, w: u8, t: u8) -> Result<u64, &'static str> {
+fn parse_float(s: &str, w: u8, t: u8) -> Result<u128, &'static str> {
     debug_assert!(w > 0 && w <= 16, "Invalid exponent range");
-    debug_assert!(1 + w + t <= 64, "Too large IEEE format for u64");
+    debug_assert!(1 + w + t <= 128, "Too large IEEE format for u128");
     debug_assert!((t + w + 1).is_power_of_two(), "Unexpected IEEE format size");
 
-    let (sign_bit, s2) = if s.starts_with('-') {
-        (1u64 << (t + w), &s[1..])
-    } else if s.starts_with('+') {
-        (0, &s[1..])
+    let (sign_bit, s2) = if let Some(num) = s.strip_prefix('-') {
+        (1u128 << (t + w), num)
+    } else if let Some(num) = s.strip_prefix('+') {
+        (0, num)
     } else {
         (0, s)
     };
 
     if !s2.starts_with("0x") {
-        let max_e_bits = ((1u64 << w) - 1) << t;
-        let quiet_bit = 1u64 << (t - 1);
+        let max_e_bits = ((1u128 << w) - 1) << t;
+        let quiet_bit = 1u128 << (t - 1);
 
         // The only decimal encoding allowed is 0.
         if s2 == "0.0" {
@@ -614,18 +978,18 @@ fn parse_float(s: &str, w: u8, t: u8) -> Result<u64, &'static str> {
             // Canonical quiet NaN: e = max, t = quiet.
             return Ok(sign_bit | max_e_bits | quiet_bit);
         }
-        if s2.starts_with("NaN:0x") {
+        if let Some(nan) = s2.strip_prefix("NaN:0x") {
             // Quiet NaN with payload.
-            return match u64::from_str_radix(&s2[6..], 16) {
+            return match u128::from_str_radix(nan, 16) {
                 Ok(payload) if payload < quiet_bit => {
                     Ok(sign_bit | max_e_bits | quiet_bit | payload)
                 }
                 _ => Err("Invalid NaN payload"),
             };
         }
-        if s2.starts_with("sNaN:0x") {
+        if let Some(nan) = s2.strip_prefix("sNaN:0x") {
             // Signaling NaN with payload.
-            return match u64::from_str_radix(&s2[7..], 16) {
+            return match u128::from_str_radix(nan, 16) {
                 Ok(payload) if 0 < payload && payload < quiet_bit => {
                     Ok(sign_bit | max_e_bits | payload)
                 }
@@ -639,7 +1003,7 @@ fn parse_float(s: &str, w: u8, t: u8) -> Result<u64, &'static str> {
 
     let mut digits = 0u8;
     let mut digits_before_period: Option<u8> = None;
-    let mut significand = 0u64;
+    let mut significand = 0u128;
     let mut exponent = 0i32;
 
     for (idx, ch) in s3.char_indices() {
@@ -666,10 +1030,10 @@ fn parse_float(s: &str, w: u8, t: u8) -> Result<u64, &'static str> {
             _ => match ch.to_digit(16) {
                 Some(digit) => {
                     digits += 1;
-                    if digits > 16 {
+                    if digits > 32 {
                         return Err("Too many digits");
                     }
-                    significand = (significand << 4) | u64::from(digit);
+                    significand = (significand << 4) | u128::from(digit);
                 }
                 None => return Err("Invalid character"),
             },
@@ -692,10 +1056,10 @@ fn parse_float(s: &str, w: u8, t: u8) -> Result<u64, &'static str> {
     };
 
     // Normalize the significand and exponent.
-    let significant_bits = (64 - significand.leading_zeros()) as u8;
+    let significant_bits = (128 - significand.leading_zeros()) as u8;
     if significant_bits > t + 1 {
         let adjust = significant_bits - (t + 1);
-        if significand & ((1u64 << adjust) - 1) != 0 {
+        if significand & ((1u128 << adjust) - 1) != 0 {
             return Err("Too many significant bits");
         }
         // Adjust significand down.
@@ -719,13 +1083,13 @@ fn parse_float(s: &str, w: u8, t: u8) -> Result<u64, &'static str> {
         Err("Magnitude too large")
     } else if exponent > 0 {
         // This is a normal number.
-        let e_bits = (exponent as u64) << t;
+        let e_bits = (exponent as u128) << t;
         Ok(sign_bit | e_bits | t_bits)
     } else if 1 - exponent <= i32::from(t) {
         // This is a subnormal number: e = 0, t = significand bits.
         // Renormalize significand for exponent = 1.
         let adjust = 1 - exponent;
-        if significand & ((1u64 << adjust) - 1) != 0 {
+        if significand & ((1u128 << adjust) - 1) != 0 {
             Err("Subnormal underflow")
         } else {
             significand >>= adjust;
@@ -736,454 +1100,10 @@ fn parse_float(s: &str, w: u8, t: u8) -> Result<u64, &'static str> {
     }
 }
 
-impl Ieee32 {
-    /// Create a new `Ieee32` containing the bits of `x`.
-    pub fn with_bits(x: u32) -> Self {
-        Self(x)
-    }
-
-    /// Create an `Ieee32` number representing `2.0^n`.
-    pub fn pow2<I: Into<i32>>(n: I) -> Self {
-        let n = n.into();
-        let w = 8;
-        let t = 23;
-        let bias = (1 << (w - 1)) - 1;
-        let exponent = (n + bias) as u32;
-        assert!(exponent > 0, "Underflow n={}", n);
-        assert!(exponent < (1 << w) + 1, "Overflow n={}", n);
-        Self(exponent << t)
-    }
-
-    /// Create an `Ieee32` number representing the greatest negative value
-    /// not convertable from f32 to a signed integer with width n.
-    pub fn fcvt_to_sint_negative_overflow<I: Into<i32>>(n: I) -> Self {
-        let n = n.into();
-        debug_assert!(n < 32);
-        debug_assert!(23 + 1 - n < 32);
-        Self::with_bits((1u32 << (32 - 1)) | Self::pow2(n - 1).0 | (1u32 << (23 + 1 - n)))
-    }
-
-    /// Return self negated.
-    pub fn neg(self) -> Self {
-        Self(self.0 ^ (1 << 31))
-    }
-
-    /// Create a new `Ieee32` representing the number `x`.
-    pub fn with_float(x: f32) -> Self {
-        Self(x.to_bits())
-    }
-
-    /// Get the bitwise representation.
-    pub fn bits(self) -> u32 {
-        self.0
-    }
-
-    /// Check if the value is a NaN.
-    pub fn is_nan(&self) -> bool {
-        self.as_f32().is_nan()
-    }
-
-    /// Converts Self to a rust f32
-    pub fn as_f32(self) -> f32 {
-        f32::from_bits(self.0)
-    }
-
-    /// Returns the square root of self.
-    pub fn sqrt(self) -> Self {
-        Self::with_float(self.as_f32().sqrt())
-    }
-
-    /// Computes the absolute value of self.
-    pub fn abs(self) -> Self {
-        Self::with_float(self.as_f32().abs())
-    }
-
-    /// Returns a number composed of the magnitude of self and the sign of sign.
-    pub fn copysign(self, sign: Self) -> Self {
-        Self::with_float(self.as_f32().copysign(sign.as_f32()))
-    }
-
-    /// Returns true if self has a negative sign, including -0.0, NaNs with negative sign bit and negative infinity.
-    pub fn is_negative(&self) -> bool {
-        self.as_f32().is_sign_negative()
-    }
-
-    /// Returns true if self is positive or negative zero
-    pub fn is_zero(&self) -> bool {
-        self.as_f32() == 0.0
-    }
-
-    /// Returns the smallest integer greater than or equal to `self`.
-    pub fn ceil(self) -> Self {
-        Self::with_float(self.as_f32().ceil())
-    }
-
-    /// Returns the largest integer less than or equal to `self`.
-    pub fn floor(self) -> Self {
-        Self::with_float(self.as_f32().floor())
-    }
-
-    /// Returns the integer part of `self`. This means that non-integer numbers are always truncated towards zero.
-    pub fn trunc(self) -> Self {
-        Self::with_float(self.as_f32().trunc())
-    }
-
-    /// Returns the nearest integer to `self`. Rounds half-way cases to the number
-    /// with an even least significant digit.
-    pub fn round_ties_even(self) -> Self {
-        // TODO: Replace with the native implementation once
-        // https://github.com/rust-lang/rust/issues/96710 is stabilized
-        let toint_32: f32 = 1.0 / f32::EPSILON;
-
-        let f = self.as_f32();
-        let e = self.0 >> 23 & 0xff;
-        if e >= 0x7f_u32 + 23 {
-            self
-        } else {
-            Self::with_float((f.abs() + toint_32 - toint_32).copysign(f))
-        }
-    }
-}
-
-impl PartialOrd for Ieee32 {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        self.as_f32().partial_cmp(&other.as_f32())
-    }
-}
-
-impl Display for Ieee32 {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        let bits: u32 = self.0;
-        format_float(u64::from(bits), 8, 23, f)
-    }
-}
-
-impl FromStr for Ieee32 {
-    type Err = &'static str;
-
-    fn from_str(s: &str) -> Result<Self, &'static str> {
-        match parse_float(s, 8, 23) {
-            Ok(b) => Ok(Self(b as u32)),
-            Err(s) => Err(s),
-        }
-    }
-}
-
-impl From<f32> for Ieee32 {
-    fn from(x: f32) -> Self {
-        Self::with_float(x)
-    }
-}
-
-impl IntoBytes for Ieee32 {
-    fn into_bytes(self) -> Vec<u8> {
-        self.0.to_le_bytes().to_vec()
-    }
-}
-
-impl Neg for Ieee32 {
-    type Output = Ieee32;
-
-    fn neg(self) -> Self::Output {
-        Self::with_float(self.as_f32().neg())
-    }
-}
-
-impl Add for Ieee32 {
-    type Output = Ieee32;
-
-    fn add(self, rhs: Self) -> Self::Output {
-        Self::with_float(self.as_f32() + rhs.as_f32())
-    }
-}
-
-impl Sub for Ieee32 {
-    type Output = Ieee32;
-
-    fn sub(self, rhs: Self) -> Self::Output {
-        Self::with_float(self.as_f32() - rhs.as_f32())
-    }
-}
-
-impl Mul for Ieee32 {
-    type Output = Ieee32;
-
-    fn mul(self, rhs: Self) -> Self::Output {
-        Self::with_float(self.as_f32() * rhs.as_f32())
-    }
-}
-
-impl Div for Ieee32 {
-    type Output = Ieee32;
-
-    fn div(self, rhs: Self) -> Self::Output {
-        Self::with_float(self.as_f32() / rhs.as_f32())
-    }
-}
-
-impl BitAnd for Ieee32 {
-    type Output = Ieee32;
-
-    fn bitand(self, rhs: Self) -> Self::Output {
-        Self::with_bits(self.bits() & rhs.bits())
-    }
-}
-
-impl BitOr for Ieee32 {
-    type Output = Ieee32;
-
-    fn bitor(self, rhs: Self) -> Self::Output {
-        Self::with_bits(self.bits() | rhs.bits())
-    }
-}
-
-impl BitXor for Ieee32 {
-    type Output = Ieee32;
-
-    fn bitxor(self, rhs: Self) -> Self::Output {
-        Self::with_bits(self.bits() ^ rhs.bits())
-    }
-}
-
-impl Not for Ieee32 {
-    type Output = Ieee32;
-
-    fn not(self) -> Self::Output {
-        Self::with_bits(!self.bits())
-    }
-}
-
-impl Ieee64 {
-    /// Create a new `Ieee64` containing the bits of `x`.
-    pub fn with_bits(x: u64) -> Self {
-        Self(x)
-    }
-
-    /// Create an `Ieee64` number representing `2.0^n`.
-    pub fn pow2<I: Into<i64>>(n: I) -> Self {
-        let n = n.into();
-        let w = 11;
-        let t = 52;
-        let bias = (1 << (w - 1)) - 1;
-        let exponent = (n + bias) as u64;
-        assert!(exponent > 0, "Underflow n={}", n);
-        assert!(exponent < (1 << w) + 1, "Overflow n={}", n);
-        Self(exponent << t)
-    }
-
-    /// Create an `Ieee64` number representing the greatest negative value
-    /// not convertable from f64 to a signed integer with width n.
-    pub fn fcvt_to_sint_negative_overflow<I: Into<i64>>(n: I) -> Self {
-        let n = n.into();
-        debug_assert!(n < 64);
-        debug_assert!(52 + 1 - n < 64);
-        Self::with_bits((1u64 << (64 - 1)) | Self::pow2(n - 1).0 | (1u64 << (52 + 1 - n)))
-    }
-
-    /// Return self negated.
-    pub fn neg(self) -> Self {
-        Self(self.0 ^ (1 << 63))
-    }
-
-    /// Create a new `Ieee64` representing the number `x`.
-    pub fn with_float(x: f64) -> Self {
-        Self(x.to_bits())
-    }
-
-    /// Get the bitwise representation.
-    pub fn bits(self) -> u64 {
-        self.0
-    }
-
-    /// Check if the value is a NaN. For [Ieee64], this means checking that the 11 exponent bits are
-    /// all set.
-    pub fn is_nan(&self) -> bool {
-        self.as_f64().is_nan()
-    }
-
-    /// Converts Self to a rust f64
-    pub fn as_f64(self) -> f64 {
-        f64::from_bits(self.0)
-    }
-
-    /// Returns the square root of self.
-    pub fn sqrt(self) -> Self {
-        Self::with_float(self.as_f64().sqrt())
-    }
-
-    /// Computes the absolute value of self.
-    pub fn abs(self) -> Self {
-        Self::with_float(self.as_f64().abs())
-    }
-
-    /// Returns a number composed of the magnitude of self and the sign of sign.
-    pub fn copysign(self, sign: Self) -> Self {
-        Self::with_float(self.as_f64().copysign(sign.as_f64()))
-    }
-
-    /// Returns true if self has a negative sign, including -0.0, NaNs with negative sign bit and negative infinity.
-    pub fn is_negative(&self) -> bool {
-        self.as_f64().is_sign_negative()
-    }
-
-    /// Returns true if self is positive or negative zero
-    pub fn is_zero(&self) -> bool {
-        self.as_f64() == 0.0
-    }
-
-    /// Returns the smallest integer greater than or equal to `self`.
-    pub fn ceil(self) -> Self {
-        Self::with_float(self.as_f64().ceil())
-    }
-
-    /// Returns the largest integer less than or equal to `self`.
-    pub fn floor(self) -> Self {
-        Self::with_float(self.as_f64().floor())
-    }
-
-    /// Returns the integer part of `self`. This means that non-integer numbers are always truncated towards zero.
-    pub fn trunc(self) -> Self {
-        Self::with_float(self.as_f64().trunc())
-    }
-
-    /// Returns the nearest integer to `self`. Rounds half-way cases to the number
-    /// with an even least significant digit.
-    pub fn round_ties_even(self) -> Self {
-        // TODO: Replace with the native implementation once
-        // https://github.com/rust-lang/rust/issues/96710 is stabilized
-        let toint_64: f64 = 1.0 / f64::EPSILON;
-
-        let f = self.as_f64();
-        let e = self.0 >> 52 & 0x7ff_u64;
-        if e >= 0x3ff_u64 + 52 {
-            self
-        } else {
-            Self::with_float((f.abs() + toint_64 - toint_64).copysign(f))
-        }
-    }
-}
-
-impl PartialOrd for Ieee64 {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        self.as_f64().partial_cmp(&other.as_f64())
-    }
-}
-
-impl Display for Ieee64 {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        let bits: u64 = self.0;
-        format_float(bits, 11, 52, f)
-    }
-}
-
-impl FromStr for Ieee64 {
-    type Err = &'static str;
-
-    fn from_str(s: &str) -> Result<Self, &'static str> {
-        match parse_float(s, 11, 52) {
-            Ok(b) => Ok(Self(b)),
-            Err(s) => Err(s),
-        }
-    }
-}
-
-impl From<f64> for Ieee64 {
-    fn from(x: f64) -> Self {
-        Self::with_float(x)
-    }
-}
-
-impl From<u64> for Ieee64 {
-    fn from(x: u64) -> Self {
-        Self::with_float(f64::from_bits(x))
-    }
-}
-
-impl IntoBytes for Ieee64 {
-    fn into_bytes(self) -> Vec<u8> {
-        self.0.to_le_bytes().to_vec()
-    }
-}
-
-impl Neg for Ieee64 {
-    type Output = Ieee64;
-
-    fn neg(self) -> Self::Output {
-        Self::with_float(self.as_f64().neg())
-    }
-}
-
-impl Add for Ieee64 {
-    type Output = Ieee64;
-
-    fn add(self, rhs: Self) -> Self::Output {
-        Self::with_float(self.as_f64() + rhs.as_f64())
-    }
-}
-
-impl Sub for Ieee64 {
-    type Output = Ieee64;
-
-    fn sub(self, rhs: Self) -> Self::Output {
-        Self::with_float(self.as_f64() - rhs.as_f64())
-    }
-}
-
-impl Mul for Ieee64 {
-    type Output = Ieee64;
-
-    fn mul(self, rhs: Self) -> Self::Output {
-        Self::with_float(self.as_f64() * rhs.as_f64())
-    }
-}
-
-impl Div for Ieee64 {
-    type Output = Ieee64;
-
-    fn div(self, rhs: Self) -> Self::Output {
-        Self::with_float(self.as_f64() / rhs.as_f64())
-    }
-}
-
-impl BitAnd for Ieee64 {
-    type Output = Ieee64;
-
-    fn bitand(self, rhs: Self) -> Self::Output {
-        Self::with_bits(self.bits() & rhs.bits())
-    }
-}
-
-impl BitOr for Ieee64 {
-    type Output = Ieee64;
-
-    fn bitor(self, rhs: Self) -> Self::Output {
-        Self::with_bits(self.bits() | rhs.bits())
-    }
-}
-
-impl BitXor for Ieee64 {
-    type Output = Ieee64;
-
-    fn bitxor(self, rhs: Self) -> Self::Output {
-        Self::with_bits(self.bits() ^ rhs.bits())
-    }
-}
-
-impl Not for Ieee64 {
-    type Output = Ieee64;
-
-    fn not(self) -> Self::Output {
-        Self::with_bits(!self.bits())
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
     use alloc::string::ToString;
-    use core::fmt::Display;
-    use core::mem;
-    use core::str::FromStr;
     use core::{f32, f64};
 
     #[test]
@@ -1192,7 +1112,7 @@ mod tests {
         assert_eq!(Imm64(9999).to_string(), "9999");
         assert_eq!(Imm64(10000).to_string(), "0x2710");
         assert_eq!(Imm64(-9999).to_string(), "-9999");
-        assert_eq!(Imm64(-10000).to_string(), "0xffff_ffff_ffff_d8f0");
+        assert_eq!(Imm64(-10000).to_string(), "-10000");
         assert_eq!(Imm64(0xffff).to_string(), "0xffff");
         assert_eq!(Imm64(0x10000).to_string(), "0x0001_0000");
     }
@@ -1212,12 +1132,13 @@ mod tests {
     }
 
     // Verify that `text` can be parsed as a `T` into a value that displays as `want`.
+    #[track_caller]
     fn parse_ok<T: FromStr + Display>(text: &str, want: &str)
     where
         <T as FromStr>::Err: Display,
     {
         match text.parse::<T>() {
-            Err(s) => panic!("\"{}\".parse() error: {}", text, s),
+            Err(s) => panic!("\"{text}\".parse() error: {s}"),
             Ok(x) => assert_eq!(x.to_string(), want),
         }
     }
@@ -1229,7 +1150,7 @@ mod tests {
     {
         match text.parse::<T>() {
             Err(s) => assert_eq!(s.to_string(), msg),
-            Ok(x) => panic!("Wanted Err({}), but got {}", msg, x),
+            Ok(x) => panic!("Wanted Err({msg}), but got {x}"),
         }
     }
 
@@ -1245,11 +1166,11 @@ mod tests {
 
         // Probe limits.
         parse_ok::<Imm64>("0xffffffff_ffffffff", "-1");
-        parse_ok::<Imm64>("0x80000000_00000000", "0x8000_0000_0000_0000");
-        parse_ok::<Imm64>("-0x80000000_00000000", "0x8000_0000_0000_0000");
+        parse_ok::<Imm64>("0x80000000_00000000", "-9223372036854775808");
+        parse_ok::<Imm64>("-0x80000000_00000000", "-9223372036854775808");
         parse_err::<Imm64>("-0x80000000_00000001", "Negative number too small");
         parse_ok::<Imm64>("18446744073709551615", "-1");
-        parse_ok::<Imm64>("-9223372036854775808", "0x8000_0000_0000_0000");
+        parse_ok::<Imm64>("-9223372036854775808", "-9223372036854775808");
         // Overflow both the `checked_add` and `checked_mul`.
         parse_err::<Imm64>("18446744073709551616", "Too large decimal number");
         parse_err::<Imm64>("184467440737095516100", "Too large decimal number");
@@ -1273,6 +1194,8 @@ mod tests {
         parse_err::<Imm64>(" 0", "Invalid character in decimal number");
         parse_err::<Imm64>("--", "Invalid character in decimal number");
         parse_err::<Imm64>("-0x-", "Invalid character in hexadecimal number");
+        parse_err::<Imm64>("abc", "Invalid character in decimal number");
+        parse_err::<Imm64>("-abc", "Invalid character in decimal number");
 
         // Hex count overflow.
         parse_err::<Imm64>("0x0_0000_0000_0000_0000", "Too many hexadecimal digits");
@@ -1313,6 +1236,8 @@ mod tests {
         parse_err::<Uimm64>("-0x-", "Invalid character in hexadecimal number");
         parse_err::<Uimm64>("-0", "Invalid character in decimal number");
         parse_err::<Uimm64>("-1", "Invalid character in decimal number");
+        parse_err::<Uimm64>("abc", "Invalid character in decimal number");
+        parse_err::<Uimm64>("-abc", "Invalid character in decimal number");
 
         // Hex count overflow.
         parse_err::<Uimm64>("0x0_0000_0000_0000_0000", "Too many hexadecimal digits");
@@ -1345,6 +1270,160 @@ mod tests {
         parse_err::<Offset32>("+0x8000_0000", "Offset out of range");
     }
 
+    #[test]
+    fn format_ieee16() {
+        assert_eq!(Ieee16::with_bits(0).to_string(), "0.0"); // 0.0
+        assert_eq!(Ieee16::with_bits(0x8000).to_string(), "-0.0"); // -0.0
+        assert_eq!(Ieee16::with_bits(0x3c00).to_string(), "0x1.000p0"); // 1.0
+        assert_eq!(Ieee16::with_bits(0x3e00).to_string(), "0x1.800p0"); // 1.5
+        assert_eq!(Ieee16::with_bits(0x3800).to_string(), "0x1.000p-1"); // 0.5
+        assert_eq!(
+            Ieee16::with_bits(0x1400).to_string(), // `f16::EPSILON`
+            "0x1.000p-10"
+        );
+        assert_eq!(
+            Ieee16::with_bits(0xfbff).to_string(), // `f16::MIN`
+            "-0x1.ffcp15"
+        );
+        assert_eq!(
+            Ieee16::with_bits(0x7bff).to_string(), // `f16::MAX`
+            "0x1.ffcp15"
+        );
+        // Smallest positive normal number.
+        assert_eq!(
+            Ieee16::with_bits(0x0400).to_string(), // `f16::MIN_POSITIVE`
+            "0x1.000p-14"
+        );
+        // Subnormals.
+        assert_eq!(
+            Ieee16::with_bits(0x0200).to_string(), // `f16::MIN_POSITIVE / 2.0`
+            "0x0.800p-14"
+        );
+        assert_eq!(
+            Ieee16::with_bits(0x0001).to_string(), // `f16::MIN_POSITIVE * f16::EPSILON`
+            "0x0.004p-14"
+        );
+        assert_eq!(
+            Ieee16::with_bits(0x7c00).to_string(), // `f16::INFINITY`
+            "+Inf"
+        );
+        assert_eq!(
+            Ieee16::with_bits(0xfc00).to_string(), // `f16::NEG_INFINITY`
+            "-Inf"
+        );
+        assert_eq!(
+            Ieee16::with_bits(0x7e00).to_string(), // `f16::NAN`
+            "+NaN"
+        );
+        assert_eq!(
+            Ieee16::with_bits(0xfe00).to_string(), // `-f16::NAN`
+            "-NaN"
+        );
+        // Construct some qNaNs with payloads.
+        assert_eq!(Ieee16::with_bits(0x7e01).to_string(), "+NaN:0x1");
+        assert_eq!(Ieee16::with_bits(0x7f01).to_string(), "+NaN:0x101");
+        // Signaling NaNs.
+        assert_eq!(Ieee16::with_bits(0x7c01).to_string(), "+sNaN:0x1");
+        assert_eq!(Ieee16::with_bits(0x7d01).to_string(), "+sNaN:0x101");
+    }
+
+    #[test]
+    fn parse_ieee16() {
+        parse_ok::<Ieee16>("0.0", "0.0");
+        parse_ok::<Ieee16>("+0.0", "0.0");
+        parse_ok::<Ieee16>("-0.0", "-0.0");
+        parse_ok::<Ieee16>("0x0", "0.0");
+        parse_ok::<Ieee16>("0x0.0", "0.0");
+        parse_ok::<Ieee16>("0x.0", "0.0");
+        parse_ok::<Ieee16>("0x0.", "0.0");
+        parse_ok::<Ieee16>("0x1", "0x1.000p0");
+        parse_ok::<Ieee16>("+0x1", "0x1.000p0");
+        parse_ok::<Ieee16>("-0x1", "-0x1.000p0");
+        parse_ok::<Ieee16>("0x10", "0x1.000p4");
+        parse_ok::<Ieee16>("0x10.0", "0x1.000p4");
+        parse_err::<Ieee16>("0.", "Float must be hexadecimal");
+        parse_err::<Ieee16>(".0", "Float must be hexadecimal");
+        parse_err::<Ieee16>("0", "Float must be hexadecimal");
+        parse_err::<Ieee16>("-0", "Float must be hexadecimal");
+        parse_err::<Ieee16>(".", "Float must be hexadecimal");
+        parse_err::<Ieee16>("", "Float must be hexadecimal");
+        parse_err::<Ieee16>("-", "Float must be hexadecimal");
+        parse_err::<Ieee16>("0x", "No digits");
+        parse_err::<Ieee16>("0x..", "Multiple radix points");
+
+        // Check significant bits.
+        parse_ok::<Ieee16>("0x0.ffe", "0x1.ffcp-1");
+        parse_ok::<Ieee16>("0x1.ffc", "0x1.ffcp0");
+        parse_ok::<Ieee16>("0x3.ff8", "0x1.ffcp1");
+        parse_ok::<Ieee16>("0x7.ff", "0x1.ffcp2");
+        parse_ok::<Ieee16>("0xf.fe", "0x1.ffcp3");
+        parse_err::<Ieee16>("0x1.ffe", "Too many significant bits");
+        parse_err::<Ieee16>("0x1.ffc00000000000000000000000000000", "Too many digits");
+
+        // Exponents.
+        parse_ok::<Ieee16>("0x1p3", "0x1.000p3");
+        parse_ok::<Ieee16>("0x1p-3", "0x1.000p-3");
+        parse_ok::<Ieee16>("0x1.0p3", "0x1.000p3");
+        parse_ok::<Ieee16>("0x2.0p3", "0x1.000p4");
+        parse_ok::<Ieee16>("0x1.0p15", "0x1.000p15");
+        parse_ok::<Ieee16>("0x1.0p-14", "0x1.000p-14");
+        parse_ok::<Ieee16>("0x0.1p-10", "0x1.000p-14");
+        parse_err::<Ieee16>("0x2.0p15", "Magnitude too large");
+
+        // Subnormals.
+        parse_ok::<Ieee16>("0x1.0p-15", "0x0.800p-14");
+        parse_ok::<Ieee16>("0x1.0p-24", "0x0.004p-14");
+        parse_ok::<Ieee16>("0x0.004p-14", "0x0.004p-14");
+        parse_err::<Ieee16>("0x0.102p-14", "Subnormal underflow");
+        parse_err::<Ieee16>("0x1.8p-24", "Subnormal underflow");
+        parse_err::<Ieee16>("0x1.0p-25", "Magnitude too small");
+
+        // NaNs and Infs.
+        parse_ok::<Ieee16>("Inf", "+Inf");
+        parse_ok::<Ieee16>("+Inf", "+Inf");
+        parse_ok::<Ieee16>("-Inf", "-Inf");
+        parse_ok::<Ieee16>("NaN", "+NaN");
+        parse_ok::<Ieee16>("+NaN", "+NaN");
+        parse_ok::<Ieee16>("-NaN", "-NaN");
+        parse_ok::<Ieee16>("NaN:0x0", "+NaN");
+        parse_err::<Ieee16>("NaN:", "Float must be hexadecimal");
+        parse_err::<Ieee16>("NaN:0", "Float must be hexadecimal");
+        parse_err::<Ieee16>("NaN:0x", "Invalid NaN payload");
+        parse_ok::<Ieee16>("NaN:0x001", "+NaN:0x1");
+        parse_ok::<Ieee16>("NaN:0x101", "+NaN:0x101");
+        parse_err::<Ieee16>("NaN:0x301", "Invalid NaN payload");
+        parse_ok::<Ieee16>("sNaN:0x1", "+sNaN:0x1");
+        parse_err::<Ieee16>("sNaN:0x0", "Invalid sNaN payload");
+        parse_ok::<Ieee16>("sNaN:0x101", "+sNaN:0x101");
+        parse_err::<Ieee16>("sNaN:0x301", "Invalid sNaN payload");
+    }
+
+    #[test]
+    fn pow2_ieee16() {
+        assert_eq!(Ieee16::pow2(0).to_string(), "0x1.000p0");
+        assert_eq!(Ieee16::pow2(1).to_string(), "0x1.000p1");
+        assert_eq!(Ieee16::pow2(-1).to_string(), "0x1.000p-1");
+        assert_eq!(Ieee16::pow2(15).to_string(), "0x1.000p15");
+        assert_eq!(Ieee16::pow2(-14).to_string(), "0x1.000p-14");
+
+        assert_eq!((-Ieee16::pow2(1)).to_string(), "-0x1.000p1");
+    }
+
+    #[test]
+    fn fcvt_to_sint_negative_overflow_ieee16() {
+        // FIXME(#8312): Replace with commented out version once Rust f16 support is stabilised.
+        // let n = 8;
+        // assert_eq!(
+        //     -((1u16 << (n - 1)) as f16) - 1.0,
+        //     Ieee16::fcvt_to_sint_negative_overflow(n).as_f16()
+        // );
+        let n = 8;
+        assert_eq!(
+            "-0x1.020p7",
+            Ieee16::fcvt_to_sint_negative_overflow(n).to_string()
+        );
+    }
+
     #[test]
     fn format_ieee32() {
         assert_eq!(Ieee32::with_float(0.0).to_string(), "0.0");
@@ -1377,11 +1456,11 @@ mod tests {
         assert_eq!(Ieee32::with_float(f32::NAN).to_string(), "+NaN");
         assert_eq!(Ieee32::with_float(-f32::NAN).to_string(), "-NaN");
         // Construct some qNaNs with payloads.
-        assert_eq!(Ieee32(0x7fc00001).to_string(), "+NaN:0x1");
-        assert_eq!(Ieee32(0x7ff00001).to_string(), "+NaN:0x300001");
+        assert_eq!(Ieee32::with_bits(0x7fc00001).to_string(), "+NaN:0x1");
+        assert_eq!(Ieee32::with_bits(0x7ff00001).to_string(), "+NaN:0x300001");
         // Signaling NaNs.
-        assert_eq!(Ieee32(0x7f800001).to_string(), "+sNaN:0x1");
-        assert_eq!(Ieee32(0x7fa00001).to_string(), "+sNaN:0x200001");
+        assert_eq!(Ieee32::with_bits(0x7f800001).to_string(), "+sNaN:0x1");
+        assert_eq!(Ieee32::with_bits(0x7fa00001).to_string(), "+sNaN:0x200001");
     }
 
     #[test]
@@ -1415,7 +1494,7 @@ mod tests {
         parse_ok::<Ieee32>("0x7.fffff8", "0x1.fffffep2");
         parse_ok::<Ieee32>("0xf.fffff0", "0x1.fffffep3");
         parse_err::<Ieee32>("0x1.ffffff", "Too many significant bits");
-        parse_err::<Ieee32>("0x1.fffffe0000000000", "Too many digits");
+        parse_err::<Ieee32>("0x1.fffffe00000000000000000000000000", "Too many digits");
 
         // Exponents.
         parse_ok::<Ieee32>("0x1p3", "0x1.000000p3");
@@ -1463,15 +1542,17 @@ mod tests {
         assert_eq!(Ieee32::pow2(127).to_string(), "0x1.000000p127");
         assert_eq!(Ieee32::pow2(-126).to_string(), "0x1.000000p-126");
 
-        assert_eq!(Ieee32::pow2(1).neg().to_string(), "-0x1.000000p1");
+        assert_eq!((-Ieee32::pow2(1)).to_string(), "-0x1.000000p1");
     }
 
     #[test]
     fn fcvt_to_sint_negative_overflow_ieee32() {
-        for n in &[8, 16] {
-            assert_eq!(-((1u32 << (n - 1)) as f32) - 1.0, unsafe {
-                mem::transmute(Ieee32::fcvt_to_sint_negative_overflow(*n))
-            });
+        for n in [8, 16] {
+            assert_eq!(
+                -((1u32 << (n - 1)) as f32) - 1.0,
+                Ieee32::fcvt_to_sint_negative_overflow(n).as_f32(),
+                "n = {n}"
+            );
         }
     }
 
@@ -1513,15 +1594,21 @@ mod tests {
         assert_eq!(Ieee64::with_float(f64::NAN).to_string(), "+NaN");
         assert_eq!(Ieee64::with_float(-f64::NAN).to_string(), "-NaN");
         // Construct some qNaNs with payloads.
-        assert_eq!(Ieee64(0x7ff8000000000001).to_string(), "+NaN:0x1");
         assert_eq!(
-            Ieee64(0x7ffc000000000001).to_string(),
+            Ieee64::with_bits(0x7ff8000000000001).to_string(),
+            "+NaN:0x1"
+        );
+        assert_eq!(
+            Ieee64::with_bits(0x7ffc000000000001).to_string(),
             "+NaN:0x4000000000001"
         );
         // Signaling NaNs.
-        assert_eq!(Ieee64(0x7ff0000000000001).to_string(), "+sNaN:0x1");
         assert_eq!(
-            Ieee64(0x7ff4000000000001).to_string(),
+            Ieee64::with_bits(0x7ff0000000000001).to_string(),
+            "+sNaN:0x1"
+        );
+        assert_eq!(
+            Ieee64::with_bits(0x7ff4000000000001).to_string(),
             "+sNaN:0x4000000000001"
         );
     }
@@ -1555,7 +1642,7 @@ mod tests {
         parse_ok::<Ieee64>("0x7.ffffffffffffc", "0x1.fffffffffffffp2");
         parse_ok::<Ieee64>("0xf.ffffffffffff8", "0x1.fffffffffffffp3");
         parse_err::<Ieee64>("0x3.fffffffffffff", "Too many significant bits");
-        parse_err::<Ieee64>("0x001.fffffe00000000", "Too many digits");
+        parse_err::<Ieee64>("0x001.fffffe000000000000000000000000", "Too many digits");
 
         // Exponents.
         parse_ok::<Ieee64>("0x1p3", "0x1.0000000000000p3");
@@ -1601,15 +1688,254 @@ mod tests {
         assert_eq!(Ieee64::pow2(1023).to_string(), "0x1.0000000000000p1023");
         assert_eq!(Ieee64::pow2(-1022).to_string(), "0x1.0000000000000p-1022");
 
-        assert_eq!(Ieee64::pow2(1).neg().to_string(), "-0x1.0000000000000p1");
+        assert_eq!((-Ieee64::pow2(1)).to_string(), "-0x1.0000000000000p1");
     }
 
     #[test]
     fn fcvt_to_sint_negative_overflow_ieee64() {
-        for n in &[8, 16, 32] {
-            assert_eq!(-((1u64 << (n - 1)) as f64) - 1.0, unsafe {
-                mem::transmute(Ieee64::fcvt_to_sint_negative_overflow(*n))
-            });
+        for n in [8, 16, 32] {
+            assert_eq!(
+                -((1u64 << (n - 1)) as f64) - 1.0,
+                Ieee64::fcvt_to_sint_negative_overflow(n).as_f64(),
+                "n = {n}"
+            );
+        }
+    }
+
+    #[test]
+    fn format_ieee128() {
+        assert_eq!(
+            Ieee128::with_bits(0x00000000000000000000000000000000).to_string(), // 0.0
+            "0.0"
+        );
+        assert_eq!(
+            Ieee128::with_bits(0x80000000000000000000000000000000).to_string(), // -0.0
+            "-0.0"
+        );
+        assert_eq!(
+            Ieee128::with_bits(0x3fff0000000000000000000000000000).to_string(), // 1.0
+            "0x1.0000000000000000000000000000p0"
+        );
+        assert_eq!(
+            Ieee128::with_bits(0x3fff8000000000000000000000000000).to_string(), // 1.5
+            "0x1.8000000000000000000000000000p0"
+        );
+        assert_eq!(
+            Ieee128::with_bits(0x3ffe0000000000000000000000000000).to_string(), // 0.5
+            "0x1.0000000000000000000000000000p-1"
+        );
+        assert_eq!(
+            Ieee128::with_bits(0x3f8f0000000000000000000000000000).to_string(), // `f128::EPSILON`
+            "0x1.0000000000000000000000000000p-112"
+        );
+        assert_eq!(
+            Ieee128::with_bits(0xfffeffffffffffffffffffffffffffff).to_string(), // `f128::MIN`
+            "-0x1.ffffffffffffffffffffffffffffp16383"
+        );
+        assert_eq!(
+            Ieee128::with_bits(0x7ffeffffffffffffffffffffffffffff).to_string(), // `f128::MAX`
+            "0x1.ffffffffffffffffffffffffffffp16383"
+        );
+        // Smallest positive normal number.
+        assert_eq!(
+            Ieee128::with_bits(0x00010000000000000000000000000000).to_string(), // `f128::MIN_POSITIVE`
+            "0x1.0000000000000000000000000000p-16382"
+        );
+        // Subnormals.
+        assert_eq!(
+            Ieee128::with_bits(0x00008000000000000000000000000000).to_string(), // `f128::MIN_POSITIVE / 2.0`
+            "0x0.8000000000000000000000000000p-16382"
+        );
+        assert_eq!(
+            Ieee128::with_bits(0x00000000000000000000000000000001).to_string(), // `f128::MIN_POSITIVE * f128::EPSILON`
+            "0x0.0000000000000000000000000001p-16382"
+        );
+        assert_eq!(
+            Ieee128::with_bits(0x7fff0000000000000000000000000000).to_string(), // `f128::INFINITY`
+            "+Inf"
+        );
+        assert_eq!(
+            Ieee128::with_bits(0xffff0000000000000000000000000000).to_string(), // `f128::NEG_INFINITY`
+            "-Inf"
+        );
+        assert_eq!(
+            Ieee128::with_bits(0x7fff8000000000000000000000000000).to_string(), // `f128::NAN`
+            "+NaN"
+        );
+        assert_eq!(
+            Ieee128::with_bits(0xffff8000000000000000000000000000).to_string(), // `-f128::NAN`
+            "-NaN"
+        );
+        // Construct some qNaNs with payloads.
+        assert_eq!(
+            Ieee128::with_bits(0x7fff8000000000000000000000000001).to_string(),
+            "+NaN:0x1"
+        );
+        assert_eq!(
+            Ieee128::with_bits(0x7fffc000000000000000000000000001).to_string(),
+            "+NaN:0x4000000000000000000000000001"
+        );
+        // Signaling NaNs.
+        assert_eq!(
+            Ieee128::with_bits(0x7fff0000000000000000000000000001).to_string(),
+            "+sNaN:0x1"
+        );
+        assert_eq!(
+            Ieee128::with_bits(0x7fff4000000000000000000000000001).to_string(),
+            "+sNaN:0x4000000000000000000000000001"
+        );
+    }
+
+    #[test]
+    fn parse_ieee128() {
+        parse_ok::<Ieee128>("0.0", "0.0");
+        parse_ok::<Ieee128>("-0.0", "-0.0");
+        parse_ok::<Ieee128>("0x0", "0.0");
+        parse_ok::<Ieee128>("0x0.0", "0.0");
+        parse_ok::<Ieee128>("0x.0", "0.0");
+        parse_ok::<Ieee128>("0x0.", "0.0");
+        parse_ok::<Ieee128>("0x1", "0x1.0000000000000000000000000000p0");
+        parse_ok::<Ieee128>("-0x1", "-0x1.0000000000000000000000000000p0");
+        parse_ok::<Ieee128>("0x10", "0x1.0000000000000000000000000000p4");
+        parse_ok::<Ieee128>("0x10.0", "0x1.0000000000000000000000000000p4");
+        parse_err::<Ieee128>("0.", "Float must be hexadecimal");
+        parse_err::<Ieee128>(".0", "Float must be hexadecimal");
+        parse_err::<Ieee128>("0", "Float must be hexadecimal");
+        parse_err::<Ieee128>("-0", "Float must be hexadecimal");
+        parse_err::<Ieee128>(".", "Float must be hexadecimal");
+        parse_err::<Ieee128>("", "Float must be hexadecimal");
+        parse_err::<Ieee128>("-", "Float must be hexadecimal");
+        parse_err::<Ieee128>("0x", "No digits");
+        parse_err::<Ieee128>("0x..", "Multiple radix points");
+
+        // Check significant bits.
+        parse_ok::<Ieee128>(
+            "0x0.ffffffffffffffffffffffffffff8",
+            "0x1.ffffffffffffffffffffffffffffp-1",
+        );
+        parse_ok::<Ieee128>(
+            "0x1.ffffffffffffffffffffffffffff",
+            "0x1.ffffffffffffffffffffffffffffp0",
+        );
+        parse_ok::<Ieee128>(
+            "0x3.fffffffffffffffffffffffffffe",
+            "0x1.ffffffffffffffffffffffffffffp1",
+        );
+        parse_ok::<Ieee128>(
+            "0x7.fffffffffffffffffffffffffffc",
+            "0x1.ffffffffffffffffffffffffffffp2",
+        );
+        parse_ok::<Ieee128>(
+            "0xf.fffffffffffffffffffffffffff8",
+            "0x1.ffffffffffffffffffffffffffffp3",
+        );
+        parse_err::<Ieee128>(
+            "0x3.ffffffffffffffffffffffffffff",
+            "Too many significant bits",
+        );
+        parse_err::<Ieee128>("0x001.fffffe000000000000000000000000", "Too many digits");
+
+        // Exponents.
+        parse_ok::<Ieee128>("0x1p3", "0x1.0000000000000000000000000000p3");
+        parse_ok::<Ieee128>("0x1p-3", "0x1.0000000000000000000000000000p-3");
+        parse_ok::<Ieee128>("0x1.0p3", "0x1.0000000000000000000000000000p3");
+        parse_ok::<Ieee128>("0x2.0p3", "0x1.0000000000000000000000000000p4");
+        parse_ok::<Ieee128>("0x1.0p16383", "0x1.0000000000000000000000000000p16383");
+        parse_ok::<Ieee128>("0x1.0p-16382", "0x1.0000000000000000000000000000p-16382");
+        parse_ok::<Ieee128>("0x0.1p-16378", "0x1.0000000000000000000000000000p-16382");
+        parse_err::<Ieee128>("0x2.0p16383", "Magnitude too large");
+
+        // Subnormals.
+        parse_ok::<Ieee128>("0x1.0p-16383", "0x0.8000000000000000000000000000p-16382");
+        parse_ok::<Ieee128>("0x1.0p-16494", "0x0.0000000000000000000000000001p-16382");
+        parse_ok::<Ieee128>(
+            "0x0.0000000000000000000000000001p-16382",
+            "0x0.0000000000000000000000000001p-16382",
+        );
+        parse_err::<Ieee128>(
+            "0x0.10000000000000000000000000008p-16382",
+            "Subnormal underflow",
+        );
+        parse_err::<Ieee128>("0x1.8p-16494", "Subnormal underflow");
+        parse_err::<Ieee128>("0x1.0p-16495", "Magnitude too small");
+
+        // NaNs and Infs.
+        parse_ok::<Ieee128>("Inf", "+Inf");
+        parse_ok::<Ieee128>("-Inf", "-Inf");
+        parse_ok::<Ieee128>("NaN", "+NaN");
+        parse_ok::<Ieee128>("-NaN", "-NaN");
+        parse_ok::<Ieee128>("NaN:0x0", "+NaN");
+        parse_err::<Ieee128>("NaN:", "Float must be hexadecimal");
+        parse_err::<Ieee128>("NaN:0", "Float must be hexadecimal");
+        parse_err::<Ieee128>("NaN:0x", "Invalid NaN payload");
+        parse_ok::<Ieee128>("NaN:0x000001", "+NaN:0x1");
+        parse_ok::<Ieee128>(
+            "NaN:0x4000000000000000000000000001",
+            "+NaN:0x4000000000000000000000000001",
+        );
+        parse_err::<Ieee128>("NaN:0x8000000000000000000000000001", "Invalid NaN payload");
+        parse_ok::<Ieee128>("sNaN:0x1", "+sNaN:0x1");
+        parse_err::<Ieee128>("sNaN:0x0", "Invalid sNaN payload");
+        parse_ok::<Ieee128>(
+            "sNaN:0x4000000000000000000000000001",
+            "+sNaN:0x4000000000000000000000000001",
+        );
+        parse_err::<Ieee128>(
+            "sNaN:0x8000000000000000000000000001",
+            "Invalid sNaN payload",
+        );
+    }
+
+    #[test]
+    fn pow2_ieee128() {
+        assert_eq!(
+            Ieee128::pow2(0).to_string(),
+            "0x1.0000000000000000000000000000p0"
+        );
+        assert_eq!(
+            Ieee128::pow2(1).to_string(),
+            "0x1.0000000000000000000000000000p1"
+        );
+        assert_eq!(
+            Ieee128::pow2(-1).to_string(),
+            "0x1.0000000000000000000000000000p-1"
+        );
+        assert_eq!(
+            Ieee128::pow2(16383).to_string(),
+            "0x1.0000000000000000000000000000p16383"
+        );
+        assert_eq!(
+            Ieee128::pow2(-16382).to_string(),
+            "0x1.0000000000000000000000000000p-16382"
+        );
+
+        assert_eq!(
+            (-Ieee128::pow2(1)).to_string(),
+            "-0x1.0000000000000000000000000000p1"
+        );
+    }
+
+    #[test]
+    fn fcvt_to_sint_negative_overflow_ieee128() {
+        // FIXME(#8312): Replace with commented out version once Rust f128 support is stabilised.
+        // for n in [8, 16, 32, 64] {
+        //     assert_eq!(
+        //         -((1u128 << (n - 1)) as f128) - 1.0,
+        //         Ieee128::fcvt_to_sint_negative_overflow(n).as_f128(),
+        //         "n = {n}"
+        //     );
+        // }
+        for (n, expected) in [
+            (8, "-0x1.0200000000000000000000000000p7"),
+            (16, "-0x1.0002000000000000000000000000p15"),
+            (32, "-0x1.0000000200000000000000000000p31"),
+            (64, "-0x1.0000000000000002000000000000p63"),
+        ] {
+            assert_eq!(
+                expected,
+                Ieee128::fcvt_to_sint_negative_overflow(n).to_string(),
+                "n = {n}"
+            );
         }
     }
 }
diff --git a/cranelift/codegen/src/ir/instructions.rs b/cranelift/codegen/src/ir/instructions.rs
index 35607e73ea1c..ab97327e4c69 100644
--- a/cranelift/codegen/src/ir/instructions.rs
+++ b/cranelift/codegen/src/ir/instructions.rs
@@ -6,6 +6,7 @@
 //! A large part of this module is auto-generated from the instruction descriptions in the meta
 //! directory.
 
+use crate::constant_hash::Table;
 use alloc::vec::Vec;
 use core::fmt::{self, Display, Formatter};
 use core::ops::{Deref, DerefMut};
@@ -14,7 +15,7 @@ use core::str::FromStr;
 #[cfg(feature = "enable-serde")]
 use serde_derive::{Deserialize, Serialize};
 
-use crate::bitset::BitSet;
+use crate::bitset::ScalarBitSet;
 use crate::entity;
 use crate::ir::{
     self,
@@ -150,7 +151,7 @@ impl<'a> Display for DisplayBlockCall<'a> {
                 if ix > 0 {
                     write!(f, ", ")?;
                 }
-                write!(f, "{}", arg)?;
+                write!(f, "{arg}")?;
             }
             write!(f, ")")?;
         }
@@ -193,12 +194,12 @@ impl Opcode {
         OPCODE_CONSTRAINTS[self as usize - 1]
     }
 
-    /// Returns true if the instruction is a resumable trap.
-    pub fn is_resumable_trap(&self) -> bool {
-        match self {
-            Opcode::ResumableTrap | Opcode::ResumableTrapnz => true,
-            _ => false,
-        }
+    /// Is this instruction a GC safepoint?
+    ///
+    /// Safepoints are all kinds of calls, except for tail calls.
+    #[inline]
+    pub fn is_safepoint(self) -> bool {
+        self.is_call() && !self.is_return()
     }
 }
 
@@ -211,17 +212,7 @@ impl FromStr for Opcode {
 
     /// Parse an Opcode name from a string.
     fn from_str(s: &str) -> Result<Self, &'static str> {
-        use crate::constant_hash::{probe, simple_hash, Table};
-
-        impl<'a> Table<&'a str> for [Option<Opcode>] {
-            fn len(&self) -> usize {
-                self.len()
-            }
-
-            fn key(&self, idx: usize) -> Option<&'a str> {
-                self[idx].map(opcode_name)
-            }
-        }
+        use crate::constant_hash::{probe, simple_hash};
 
         match probe::<&str, [Option<Self>]>(&OPCODE_HASH_TABLE, s, simple_hash(s)) {
             Err(_) => Err("Unknown opcode"),
@@ -232,6 +223,16 @@ impl FromStr for Opcode {
     }
 }
 
+impl<'a> Table<&'a str> for [Option<Opcode>] {
+    fn len(&self) -> usize {
+        self.len()
+    }
+
+    fn key(&self, idx: usize) -> Option<&'a str> {
+        self[idx].map(opcode_name)
+    }
+}
+
 /// A variable list of `Value` operands used for function call arguments and passing arguments to
 /// basic blocks.
 #[derive(Clone, Debug)]
@@ -281,9 +282,9 @@ impl Display for VariableArgs {
     fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
         for (i, val) in self.0.iter().enumerate() {
             if i == 0 {
-                write!(fmt, "{}", val)?;
+                write!(fmt, "{val}")?;
             } else {
-                write!(fmt, ", {}", val)?;
+                write!(fmt, ", {val}")?;
             }
         }
         Ok(())
@@ -341,6 +342,25 @@ impl InstructionData {
         }
     }
 
+    /// Replace the values used in this instruction according to the given
+    /// function.
+    pub fn map_values(
+        &mut self,
+        pool: &mut ValueListPool,
+        jump_tables: &mut ir::JumpTables,
+        mut f: impl FnMut(Value) -> Value,
+    ) {
+        for arg in self.arguments_mut(pool) {
+            *arg = f(*arg);
+        }
+
+        for block in self.branch_destination_mut(jump_tables) {
+            for arg in block.args_slice_mut(pool) {
+                *arg = f(*arg);
+            }
+        }
+    }
+
     /// If this is a trapping instruction, get its trap code. Otherwise, return
     /// `None`.
     pub fn trap_code(&self) -> Option<TrapCode> {
@@ -430,6 +450,14 @@ impl InstructionData {
             Self::CallIndirect {
                 sig_ref, ref args, ..
             } => CallInfo::Indirect(sig_ref, &args.as_slice(pool)[1..]),
+            Self::Ternary {
+                opcode: Opcode::StackSwitch,
+                ..
+            } => {
+                // `StackSwitch` is not actually a call, but has the .call() side
+                // effect as it continues execution elsewhere.
+                CallInfo::NotACall
+            }
             _ => {
                 debug_assert!(!self.opcode().is_call());
                 CallInfo::NotACall
@@ -438,7 +466,7 @@ impl InstructionData {
     }
 
     #[inline]
-    pub(crate) fn sign_extend_immediates(&mut self, ctrl_typevar: Type) {
+    pub(crate) fn mask_immediates(&mut self, ctrl_typevar: Type) {
         if ctrl_typevar.is_invalid() {
             return;
         }
@@ -446,13 +474,16 @@ impl InstructionData {
         let bit_width = ctrl_typevar.bits();
 
         match self {
+            Self::UnaryImm { opcode: _, imm } => {
+                *imm = imm.mask_to_width(bit_width);
+            }
             Self::BinaryImm64 {
                 opcode,
                 arg: _,
                 imm,
             } => {
                 if *opcode == Opcode::SdivImm || *opcode == Opcode::SremImm {
-                    imm.sign_extend_from_width(bit_width);
+                    *imm = imm.mask_to_width(bit_width);
                 }
             }
             Self::IntCompareImm {
@@ -463,7 +494,7 @@ impl InstructionData {
             } => {
                 debug_assert_eq!(*opcode, Opcode::IcmpImm);
                 if cond.unsigned() != *cond {
-                    imm.sign_extend_from_width(bit_width);
+                    *imm = imm.mask_to_width(bit_width);
                 }
             }
             _ => {}
@@ -577,7 +608,7 @@ impl OpcodeConstraints {
         debug_assert!(n < self.num_fixed_results(), "Invalid result index");
         match OPERAND_CONSTRAINTS[self.constraint_offset() + n].resolve(ctrl_type) {
             ResolvedConstraint::Bound(t) => t,
-            ResolvedConstraint::Free(ts) => panic!("Result constraints can't be free: {:?}", ts),
+            ResolvedConstraint::Free(ts) => panic!("Result constraints can't be free: {ts:?}"),
         }
     }
 
@@ -607,8 +638,8 @@ impl OpcodeConstraints {
     }
 }
 
-type BitSet8 = BitSet<u8>;
-type BitSet16 = BitSet<u16>;
+type BitSet8 = ScalarBitSet<u8>;
+type BitSet16 = ScalarBitSet<u16>;
 
 /// A value type set describes the permitted set of types for a type variable.
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
@@ -619,8 +650,6 @@ pub struct ValueTypeSet {
     pub ints: BitSet8,
     /// Allowed float widths
     pub floats: BitSet8,
-    /// Allowed ref widths
-    pub refs: BitSet8,
     /// Allowed dynamic vectors minimum lane sizes
     pub dynamic_lanes: BitSet16,
 }
@@ -630,13 +659,11 @@ impl ValueTypeSet {
     ///
     /// Note that the base type set does not have to be included in the type set proper.
     fn is_base_type(self, scalar: Type) -> bool {
-        let l2b = scalar.log2_lane_bits();
+        let l2b = u8::try_from(scalar.log2_lane_bits()).unwrap();
         if scalar.is_int() {
             self.ints.contains(l2b)
         } else if scalar.is_float() {
             self.floats.contains(l2b)
-        } else if scalar.is_ref() {
-            self.refs.contains(l2b)
         } else {
             false
         }
@@ -645,10 +672,10 @@ impl ValueTypeSet {
     /// Does `typ` belong to this set?
     pub fn contains(self, typ: Type) -> bool {
         if typ.is_dynamic_vector() {
-            let l2l = typ.log2_min_lane_count();
+            let l2l = u8::try_from(typ.log2_min_lane_count()).unwrap();
             self.dynamic_lanes.contains(l2l) && self.is_base_type(typ.lane_type())
         } else {
-            let l2l = typ.log2_lane_count();
+            let l2l = u8::try_from(typ.log2_lane_count()).unwrap();
             self.lanes.contains(l2l) && self.is_base_type(typ.lane_type())
         }
     }
@@ -774,7 +801,7 @@ impl OperandConstraint {
                 let mut tys = ValueTypeSet::default();
 
                 // We're testing scalar values, only.
-                tys.lanes = BitSet::from_range(0, 1);
+                tys.lanes = ScalarBitSet::from_range(0, 1);
 
                 if ctrl_type.is_int() {
                     // The upper bound in from_range is exclusive, and we want to exclude the
@@ -782,8 +809,8 @@ impl OperandConstraint {
                     tys.ints = BitSet8::from_range(3, ctrl_type_bits as u8);
                 } else if ctrl_type.is_float() {
                     // The upper bound in from_range is exclusive, and we want to exclude the
-                    // control type to construct the interval of [F32, ctrl_type).
-                    tys.floats = BitSet8::from_range(5, ctrl_type_bits as u8);
+                    // control type to construct the interval of [F16, ctrl_type).
+                    tys.floats = BitSet8::from_range(4, ctrl_type_bits as u8);
                 } else {
                     panic!("The Narrower constraint only operates on floats or ints");
                 }
@@ -794,7 +821,7 @@ impl OperandConstraint {
                 let mut tys = ValueTypeSet::default();
 
                 // We're testing scalar values, only.
-                tys.lanes = BitSet::from_range(0, 1);
+                tys.lanes = ScalarBitSet::from_range(0, 1);
 
                 if ctrl_type.is_int() {
                     let lower_bound = ctrl_type_bits as u8 + 1;
@@ -803,17 +830,18 @@ impl OperandConstraint {
                     // lower bound would overflow as 2^8 doesn't fit in a u8, but this would
                     // already describe the empty set so instead we leave `ints` in its default
                     // empty state.
-                    if lower_bound < BitSet8::bits() as u8 {
+                    if lower_bound < BitSet8::capacity() {
                         // The interval should include all types wider than `ctrl_type`, so we use
                         // `2^8` as the upper bound, and add one to the bits of `ctrl_type` to define
                         // the interval `(ctrl_type, I128]`.
                         tys.ints = BitSet8::from_range(lower_bound, 8);
                     }
                 } else if ctrl_type.is_float() {
-                    // The interval should include all float types wider than `ctrl_type`, so we
-                    // use `2^7` as the upper bound, and add one to the bits of `ctrl_type` to
-                    // define the interval `(ctrl_type, F64]`.
-                    tys.floats = BitSet8::from_range(ctrl_type_bits as u8 + 1, 7);
+                    // Same as above but for `tys.floats`, as the largest float type is F128.
+                    let lower_bound = ctrl_type_bits as u8 + 1;
+                    if lower_bound < BitSet8::capacity() {
+                        tys.floats = BitSet8::from_range(lower_bound, 8);
+                    }
                 } else {
                     panic!("The Wider constraint only operates on floats or ints");
                 }
@@ -944,7 +972,6 @@ mod tests {
             lanes: BitSet16::from_range(0, 8),
             ints: BitSet8::from_range(4, 7),
             floats: BitSet8::from_range(0, 0),
-            refs: BitSet8::from_range(5, 7),
             dynamic_lanes: BitSet16::from_range(0, 4),
         };
         assert!(!vts.contains(I8));
@@ -952,16 +979,15 @@ mod tests {
         assert!(vts.contains(I64));
         assert!(vts.contains(I32X4));
         assert!(vts.contains(I32X4XN));
+        assert!(!vts.contains(F16));
         assert!(!vts.contains(F32));
-        assert!(vts.contains(R32));
-        assert!(vts.contains(R64));
+        assert!(!vts.contains(F128));
         assert_eq!(vts.example().to_string(), "i32");
 
         let vts = ValueTypeSet {
             lanes: BitSet16::from_range(0, 8),
             ints: BitSet8::from_range(0, 0),
             floats: BitSet8::from_range(5, 7),
-            refs: BitSet8::from_range(0, 0),
             dynamic_lanes: BitSet16::from_range(0, 8),
         };
         assert_eq!(vts.example().to_string(), "f32");
@@ -970,7 +996,6 @@ mod tests {
             lanes: BitSet16::from_range(1, 8),
             ints: BitSet8::from_range(0, 0),
             floats: BitSet8::from_range(5, 7),
-            refs: BitSet8::from_range(0, 0),
             dynamic_lanes: BitSet16::from_range(0, 8),
         };
         assert_eq!(vts.example().to_string(), "f32x2");
@@ -979,7 +1004,6 @@ mod tests {
             lanes: BitSet16::from_range(2, 8),
             ints: BitSet8::from_range(3, 7),
             floats: BitSet8::from_range(0, 0),
-            refs: BitSet8::from_range(0, 0),
             dynamic_lanes: BitSet16::from_range(0, 8),
         };
         assert_eq!(vts.example().to_string(), "i32x4");
@@ -989,12 +1013,9 @@ mod tests {
             lanes: BitSet16::from_range(0, 9),
             ints: BitSet8::from_range(3, 7),
             floats: BitSet8::from_range(0, 0),
-            refs: BitSet8::from_range(0, 0),
             dynamic_lanes: BitSet16::from_range(0, 8),
         };
         assert!(vts.contains(I32));
         assert!(vts.contains(I32X4));
-        assert!(!vts.contains(R32));
-        assert!(!vts.contains(R64));
     }
 }
diff --git a/cranelift/codegen/src/ir/jumptable.rs b/cranelift/codegen/src/ir/jumptable.rs
index dce3470483b3..8e1e15c7d621 100644
--- a/cranelift/codegen/src/ir/jumptable.rs
+++ b/cranelift/codegen/src/ir/jumptable.rs
@@ -20,7 +20,7 @@ use serde_derive::{Deserialize, Serialize};
 /// It can be accessed through the `default_block` and `default_block_mut` functions. All blocks
 /// may be iterated using the `all_branches` and `all_branches_mut` functions, which will both
 /// iterate over the default block first.
-#[derive(Clone, PartialEq, Hash)]
+#[derive(Debug, Clone, PartialEq, Hash)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct JumpTableData {
     // Table entries.
diff --git a/cranelift/codegen/src/ir/layout.rs b/cranelift/codegen/src/ir/layout.rs
index 2f6788fbe763..8d8b577e2874 100644
--- a/cranelift/codegen/src/ir/layout.rs
+++ b/cranelift/codegen/src/ir/layout.rs
@@ -9,7 +9,6 @@ use crate::ir::{Block, Inst};
 use crate::packed_option::PackedOption;
 use crate::{timing, trace};
 use core::cmp;
-use core::iter::{IntoIterator, Iterator};
 
 /// The `Layout` struct determines the layout of blocks and instructions in a function. It does not
 /// contain definitions of instructions or blocks, but depends on `Inst` and `Block` entity references
@@ -681,7 +680,6 @@ mod serde {
     use ::serde::de::{Deserializer, Error, SeqAccess, Visitor};
     use ::serde::ser::{SerializeSeq, Serializer};
     use ::serde::{Deserialize, Serialize};
-    use core::convert::TryFrom;
     use core::fmt;
     use core::marker::PhantomData;
 
diff --git a/cranelift/codegen/src/ir/memflags.rs b/cranelift/codegen/src/ir/memflags.rs
index 87165ba69117..9b706bd56d2e 100644
--- a/cranelift/codegen/src/ir/memflags.rs
+++ b/cranelift/codegen/src/ir/memflags.rs
@@ -1,31 +1,12 @@
 //! Memory operation flags.
 
+use super::TrapCode;
 use core::fmt;
+use core::str::FromStr;
 
 #[cfg(feature = "enable-serde")]
 use serde_derive::{Deserialize, Serialize};
 
-enum FlagBit {
-    Notrap,
-    Aligned,
-    Readonly,
-    LittleEndian,
-    BigEndian,
-    /// Accesses only the "heap" part of abstract state. Used for
-    /// alias analysis. Mutually exclusive with "table" and "vmctx".
-    Heap,
-    /// Accesses only the "table" part of abstract state. Used for
-    /// alias analysis. Mutually exclusive with "heap" and "vmctx".
-    Table,
-    /// Accesses only the "vmctx" part of abstract state. Used for
-    /// alias analysis. Mutually exclusive with "heap" and "table".
-    Vmctx,
-}
-
-const NAMES: [&str; 8] = [
-    "notrap", "aligned", "readonly", "little", "big", "heap", "table", "vmctx",
-];
-
 /// Endianness of a memory access.
 #[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
 pub enum Endianness {
@@ -35,6 +16,38 @@ pub enum Endianness {
     Big,
 }
 
+/// Which disjoint region of aliasing memory is accessed in this memory
+/// operation.
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
+#[repr(u8)]
+#[allow(missing_docs)]
+#[rustfmt::skip]
+pub enum AliasRegion {
+    // None = 0b00;
+    Heap    = 0b01,
+    Table   = 0b10,
+    Vmctx   = 0b11,
+}
+
+impl AliasRegion {
+    const fn from_bits(bits: u8) -> Option<Self> {
+        match bits {
+            0b00 => None,
+            0b01 => Some(Self::Heap),
+            0b10 => Some(Self::Table),
+            0b11 => Some(Self::Vmctx),
+            _ => panic!("invalid alias region bits"),
+        }
+    }
+
+    const fn to_bits(region: Option<Self>) -> u8 {
+        match region {
+            None => 0b00,
+            Some(r) => r as u8,
+        }
+    }
+}
+
 /// Flags for memory operations like load/store.
 ///
 /// Each of these flags introduce a limited form of undefined behavior. The flags each enable
@@ -48,53 +61,150 @@ pub enum Endianness {
 #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
 pub struct MemFlags {
-    bits: u8,
+    // Initialized to all zeros to have all flags have their default value.
+    // This is interpreted through various methods below. Currently the bits of
+    // this are defined as:
+    //
+    // * 0 - aligned flag
+    // * 1 - readonly flag
+    // * 2 - little endian flag
+    // * 3 - big endian flag
+    // * 4 - checked flag
+    // * 5/6 - alias region
+    // * 7/8/9/10 - trap code
+    // * 11/12/13/14/15 - unallocated
+    //
+    // Current properties upheld are:
+    //
+    // * only one of little/big endian is set
+    // * only one alias region can be set - once set it cannot be changed
+    bits: u16,
 }
 
+/// Guaranteed to use "natural alignment" for the given type. This
+/// may enable better instruction selection.
+const BIT_ALIGNED: u16 = 1 << 0;
+
+/// A load that reads data in memory that does not change for the
+/// duration of the function's execution. This may enable
+/// additional optimizations to be performed.
+const BIT_READONLY: u16 = 1 << 1;
+
+/// Load multi-byte values from memory in a little-endian format.
+const BIT_LITTLE_ENDIAN: u16 = 1 << 2;
+
+/// Load multi-byte values from memory in a big-endian format.
+const BIT_BIG_ENDIAN: u16 = 1 << 3;
+
+/// Check this load or store for safety when using the
+/// proof-carrying-code framework. The address must have a
+/// `PointsTo` fact attached with a sufficiently large valid range
+/// for the accessed size.
+const BIT_CHECKED: u16 = 1 << 4;
+
+/// Used for alias analysis, indicates which disjoint part of the abstract state
+/// is being accessed.
+const MASK_ALIAS_REGION: u16 = 0b11 << ALIAS_REGION_OFFSET;
+const ALIAS_REGION_OFFSET: u16 = 5;
+
+/// Trap code, if any, for this memory operation.
+const MASK_TRAP_CODE: u16 = 0b1111 << TRAP_CODE_OFFSET;
+const TRAP_CODE_OFFSET: u16 = 7;
+
 impl MemFlags {
     /// Create a new empty set of flags.
-    pub fn new() -> Self {
+    pub const fn new() -> Self {
         Self { bits: 0 }
     }
 
     /// Create a set of flags representing an access from a "trusted" address, meaning it's
     /// known to be aligned and non-trapping.
-    pub fn trusted() -> Self {
-        let mut result = Self::new();
-        result.set_notrap();
-        result.set_aligned();
-        result
+    pub const fn trusted() -> Self {
+        Self::new().with_notrap().with_aligned()
     }
 
     /// Read a flag bit.
-    fn read(self, bit: FlagBit) -> bool {
-        self.bits & (1 << bit as usize) != 0
+    const fn read_bit(self, bit: u16) -> bool {
+        self.bits & bit != 0
     }
 
-    /// Set a flag bit.
-    fn set(&mut self, bit: FlagBit) {
-        self.bits |= 1 << bit as usize
+    /// Return a new `MemFlags` with this flag bit set.
+    const fn with_bit(mut self, bit: u16) -> Self {
+        self.bits |= bit;
+        self
+    }
+
+    /// Reads the alias region that this memory operation works with.
+    pub const fn alias_region(self) -> Option<AliasRegion> {
+        AliasRegion::from_bits(((self.bits & MASK_ALIAS_REGION) >> ALIAS_REGION_OFFSET) as u8)
+    }
+
+    /// Sets the alias region that this works on to the specified `region`.
+    pub const fn with_alias_region(mut self, region: Option<AliasRegion>) -> Self {
+        let bits = AliasRegion::to_bits(region);
+        self.bits &= !MASK_ALIAS_REGION;
+        self.bits |= (bits as u16) << ALIAS_REGION_OFFSET;
+        self
+    }
+
+    /// Sets the alias region that this works on to the specified `region`.
+    pub fn set_alias_region(&mut self, region: Option<AliasRegion>) {
+        *self = self.with_alias_region(region);
     }
 
     /// Set a flag bit by name.
     ///
-    /// Returns true if the flag was found and set, false for an unknown flag name.
-    /// Will also return false when trying to set inconsistent endianness flags.
-    pub fn set_by_name(&mut self, name: &str) -> bool {
-        match NAMES.iter().position(|&s| s == name) {
-            Some(bit) => {
-                let bits = self.bits | 1 << bit;
-                if (bits & (1 << FlagBit::LittleEndian as usize)) != 0
-                    && (bits & (1 << FlagBit::BigEndian as usize)) != 0
-                {
-                    false
-                } else {
-                    self.bits = bits;
-                    true
+    /// Returns true if the flag was found and set, false for an unknown flag
+    /// name.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error message if the `name` is known but couldn't be applied
+    /// due to it being a semantic error.
+    pub fn set_by_name(&mut self, name: &str) -> Result<bool, &'static str> {
+        *self = match name {
+            "notrap" => self.with_trap_code(None),
+            "aligned" => self.with_aligned(),
+            "readonly" => self.with_readonly(),
+            "little" => {
+                if self.read_bit(BIT_BIG_ENDIAN) {
+                    return Err("cannot set both big and little endian bits");
                 }
+                self.with_endianness(Endianness::Little)
             }
-            None => false,
-        }
+            "big" => {
+                if self.read_bit(BIT_LITTLE_ENDIAN) {
+                    return Err("cannot set both big and little endian bits");
+                }
+                self.with_endianness(Endianness::Big)
+            }
+            "heap" => {
+                if self.alias_region().is_some() {
+                    return Err("cannot set more than one alias region");
+                }
+                self.with_alias_region(Some(AliasRegion::Heap))
+            }
+            "table" => {
+                if self.alias_region().is_some() {
+                    return Err("cannot set more than one alias region");
+                }
+                self.with_alias_region(Some(AliasRegion::Table))
+            }
+            "vmctx" => {
+                if self.alias_region().is_some() {
+                    return Err("cannot set more than one alias region");
+                }
+                self.with_alias_region(Some(AliasRegion::Vmctx))
+            }
+            "checked" => self.with_checked(),
+
+            other => match TrapCode::from_str(other) {
+                Ok(TrapCode::User(_)) => return Err("cannot set user trap code on mem flags"),
+                Ok(code) => self.with_trap_code(Some(code)),
+                Err(()) => return Ok(false),
+            },
+        };
+        Ok(true)
     }
 
     /// Return endianness of the memory access.  This will return the endianness
@@ -102,10 +212,10 @@ impl MemFlags {
     /// endianness otherwise.  The native endianness has to be provided by the
     /// caller since it is not explicitly encoded in CLIF IR -- this allows a
     /// front end to create IR without having to know the target endianness.
-    pub fn endianness(self, native_endianness: Endianness) -> Endianness {
-        if self.read(FlagBit::LittleEndian) {
+    pub const fn endianness(self, native_endianness: Endianness) -> Endianness {
+        if self.read_bit(BIT_LITTLE_ENDIAN) {
             Endianness::Little
-        } else if self.read(FlagBit::BigEndian) {
+        } else if self.read_bit(BIT_BIG_ENDIAN) {
             Endianness::Big
         } else {
             native_endianness
@@ -114,41 +224,42 @@ impl MemFlags {
 
     /// Set endianness of the memory access.
     pub fn set_endianness(&mut self, endianness: Endianness) {
-        match endianness {
-            Endianness::Little => self.set(FlagBit::LittleEndian),
-            Endianness::Big => self.set(FlagBit::BigEndian),
-        };
-        assert!(!(self.read(FlagBit::LittleEndian) && self.read(FlagBit::BigEndian)));
+        *self = self.with_endianness(endianness);
     }
 
     /// Set endianness of the memory access, returning new flags.
-    pub fn with_endianness(mut self, endianness: Endianness) -> Self {
-        self.set_endianness(endianness);
-        self
+    pub const fn with_endianness(self, endianness: Endianness) -> Self {
+        let res = match endianness {
+            Endianness::Little => self.with_bit(BIT_LITTLE_ENDIAN),
+            Endianness::Big => self.with_bit(BIT_BIG_ENDIAN),
+        };
+        assert!(!(res.read_bit(BIT_LITTLE_ENDIAN) && res.read_bit(BIT_BIG_ENDIAN)));
+        res
     }
 
-    /// Test if the `notrap` flag is set.
+    /// Test if this memory operation cannot trap.
     ///
-    /// Normally, trapping is part of the semantics of a load/store operation. If the platform
-    /// would cause a trap when accessing the effective address, the Cranelift memory operation is
-    /// also required to trap.
+    /// By default `MemFlags` will assume that any load/store can trap and is
+    /// associated with a `TrapCode::HeapOutOfBounds` code. If the trap code is
+    /// configured to `None` though then this method will return `true` and
+    /// indicates that the memory operation will not trap.
     ///
-    /// The `notrap` flag tells Cranelift that the memory is *accessible*, which means that
-    /// accesses will not trap. This makes it possible to delete an unused load or a dead store
-    /// instruction.
-    pub fn notrap(self) -> bool {
-        self.read(FlagBit::Notrap)
+    /// If this returns `true` then the memory is *accessible*, which means
+    /// that accesses will not trap. This makes it possible to delete an unused
+    /// load or a dead store instruction.
+    pub const fn notrap(self) -> bool {
+        self.trap_code().is_none()
     }
 
-    /// Set the `notrap` flag.
+    /// Sets the trap code for this `MemFlags` to `None`.
     pub fn set_notrap(&mut self) {
-        self.set(FlagBit::Notrap)
+        *self = self.with_notrap();
     }
 
-    /// Set the `notrap` flag, returning new flags.
-    pub fn with_notrap(mut self) -> Self {
-        self.set_notrap();
-        self
+    /// Sets the trap code for this `MemFlags` to `None`, returning the new
+    /// flags.
+    pub const fn with_notrap(self) -> Self {
+        self.with_trap_code(None)
     }
 
     /// Test if the `aligned` flag is set.
@@ -156,19 +267,18 @@ impl MemFlags {
     /// By default, Cranelift memory instructions work with any unaligned effective address. If the
     /// `aligned` flag is set, the instruction is permitted to trap or return a wrong result if the
     /// effective address is misaligned.
-    pub fn aligned(self) -> bool {
-        self.read(FlagBit::Aligned)
+    pub const fn aligned(self) -> bool {
+        self.read_bit(BIT_ALIGNED)
     }
 
     /// Set the `aligned` flag.
     pub fn set_aligned(&mut self) {
-        self.set(FlagBit::Aligned)
+        *self = self.with_aligned();
     }
 
     /// Set the `aligned` flag, returning new flags.
-    pub fn with_aligned(mut self) -> Self {
-        self.set_aligned();
-        self
+    pub const fn with_aligned(self) -> Self {
+        self.with_bit(BIT_ALIGNED)
     }
 
     /// Test if the `readonly` flag is set.
@@ -176,104 +286,176 @@ impl MemFlags {
     /// Loads with this flag have no memory dependencies.
     /// This results in undefined behavior if the dereferenced memory is mutated at any time
     /// between when the function is called and when it is exited.
-    pub fn readonly(self) -> bool {
-        self.read(FlagBit::Readonly)
+    pub const fn readonly(self) -> bool {
+        self.read_bit(BIT_READONLY)
     }
 
     /// Set the `readonly` flag.
     pub fn set_readonly(&mut self) {
-        self.set(FlagBit::Readonly)
+        *self = self.with_readonly();
     }
 
     /// Set the `readonly` flag, returning new flags.
-    pub fn with_readonly(mut self) -> Self {
-        self.set_readonly();
-        self
+    pub const fn with_readonly(self) -> Self {
+        self.with_bit(BIT_READONLY)
     }
 
-    /// Test if the `heap` bit is set.
+    /// Test if the `checked` bit is set.
     ///
-    /// Loads and stores with this flag accesses the "heap" part of
-    /// abstract state. This is disjoint from the "table", "vmctx",
-    /// and "other" parts of abstract state. In concrete terms, this
-    /// means that behavior is undefined if the same memory is also
-    /// accessed by another load/store with one of the other
-    /// alias-analysis bits (`table`, `vmctx`) set, or `heap` not set.
-    pub fn heap(self) -> bool {
-        self.read(FlagBit::Heap)
+    /// Loads and stores with this flag are verified to access
+    /// pointers only with a validated `PointsTo` fact attached, and
+    /// with that fact validated, when using the proof-carrying-code
+    /// framework. If initial facts on program inputs are correct
+    /// (i.e., correctly denote the shape and types of data structures
+    /// in memory), and if PCC validates the compiled output, then all
+    /// `checked`-marked memory accesses are guaranteed (up to the
+    /// checker's correctness) to access valid memory. This can be
+    /// used to ensure memory safety and sandboxing.
+    pub const fn checked(self) -> bool {
+        self.read_bit(BIT_CHECKED)
     }
 
-    /// Set the `heap` bit. See the notes about mutual exclusion with
-    /// other bits in `heap()`.
-    pub fn set_heap(&mut self) {
-        assert!(!self.table() && !self.vmctx());
-        self.set(FlagBit::Heap);
+    /// Set the `checked` bit.
+    pub fn set_checked(&mut self) {
+        *self = self.with_checked();
     }
 
-    /// Set the `heap` bit, returning new flags.
-    pub fn with_heap(mut self) -> Self {
-        self.set_heap();
-        self
+    /// Set the `checked` bit, returning new flags.
+    pub const fn with_checked(self) -> Self {
+        self.with_bit(BIT_CHECKED)
     }
 
-    /// Test if the `table` bit is set.
+    /// Get the trap code to report if this memory access traps.
     ///
-    /// Loads and stores with this flag accesses the "table" part of
-    /// abstract state. This is disjoint from the "heap", "vmctx",
-    /// and "other" parts of abstract state. In concrete terms, this
-    /// means that behavior is undefined if the same memory is also
-    /// accessed by another load/store with one of the other
-    /// alias-analysis bits (`heap`, `vmctx`) set, or `table` not set.
-    pub fn table(self) -> bool {
-        self.read(FlagBit::Table)
-    }
-
-    /// Set the `table` bit. See the notes about mutual exclusion with
-    /// other bits in `table()`.
-    pub fn set_table(&mut self) {
-        assert!(!self.heap() && !self.vmctx());
-        self.set(FlagBit::Table);
-    }
-
-    /// Set the `table` bit, returning new flags.
-    pub fn with_table(mut self) -> Self {
-        self.set_table();
-        self
+    /// A `None` trap code indicates that this memory access does not trap.
+    pub const fn trap_code(self) -> Option<TrapCode> {
+        // NB: keep this encoding in sync with `with_trap_code` below.
+        //
+        // Also note that the default, all zeros, is `HeapOutOfBounds`. It is
+        // intentionally not `None` so memory operations are all considered
+        // effect-ful by default.
+        match (self.bits & MASK_TRAP_CODE) >> TRAP_CODE_OFFSET {
+            0b0000 => Some(TrapCode::HeapOutOfBounds),
+            0b0001 => Some(TrapCode::StackOverflow),
+            0b0010 => Some(TrapCode::HeapMisaligned),
+            0b0011 => Some(TrapCode::TableOutOfBounds),
+            0b0100 => Some(TrapCode::IndirectCallToNull),
+            0b0101 => Some(TrapCode::BadSignature),
+            0b0110 => Some(TrapCode::IntegerOverflow),
+            0b0111 => Some(TrapCode::IntegerDivisionByZero),
+            0b1000 => Some(TrapCode::BadConversionToInteger),
+            0b1001 => Some(TrapCode::UnreachableCodeReached),
+            0b1010 => Some(TrapCode::Interrupt),
+            0b1011 => Some(TrapCode::NullReference),
+            0b1100 => Some(TrapCode::NullI31Ref),
+            // 0b1101 => {} not allocated
+            // 0b1110 => {} not allocated
+            0b1111 => None,
+            _ => unreachable!(),
+        }
     }
 
-    /// Test if the `vmctx` bit is set.
+    /// Configures these flags with the specified trap code `code`.
     ///
-    /// Loads and stores with this flag accesses the "vmctx" part of
-    /// abstract state. This is disjoint from the "heap", "table",
-    /// and "other" parts of abstract state. In concrete terms, this
-    /// means that behavior is undefined if the same memory is also
-    /// accessed by another load/store with one of the other
-    /// alias-analysis bits (`heap`, `table`) set, or `vmctx` not set.
-    pub fn vmctx(self) -> bool {
-        self.read(FlagBit::Vmctx)
-    }
-
-    /// Set the `vmctx` bit. See the notes about mutual exclusion with
-    /// other bits in `vmctx()`.
-    pub fn set_vmctx(&mut self) {
-        assert!(!self.heap() && !self.table());
-        self.set(FlagBit::Vmctx);
-    }
-
-    /// Set the `vmctx` bit, returning new flags.
-    pub fn with_vmctx(mut self) -> Self {
-        self.set_vmctx();
+    /// Note that `TrapCode::User(_)` cannot be set in `MemFlags`. A trap code
+    /// indicates that this memory operation cannot be optimized away and it
+    /// must "stay where it is" in the programs. Traps are considered side
+    /// effects, for example, and have meaning through the trap code that is
+    /// communicated and which instruction trapped.
+    pub const fn with_trap_code(mut self, code: Option<TrapCode>) -> Self {
+        let bits = match code {
+            Some(TrapCode::HeapOutOfBounds) => 0b0000,
+            Some(TrapCode::StackOverflow) => 0b0001,
+            Some(TrapCode::HeapMisaligned) => 0b0010,
+            Some(TrapCode::TableOutOfBounds) => 0b0011,
+            Some(TrapCode::IndirectCallToNull) => 0b0100,
+            Some(TrapCode::BadSignature) => 0b0101,
+            Some(TrapCode::IntegerOverflow) => 0b0110,
+            Some(TrapCode::IntegerDivisionByZero) => 0b0111,
+            Some(TrapCode::BadConversionToInteger) => 0b1000,
+            Some(TrapCode::UnreachableCodeReached) => 0b1001,
+            Some(TrapCode::Interrupt) => 0b1010,
+            Some(TrapCode::NullReference) => 0b1011,
+            Some(TrapCode::NullI31Ref) => 0b1100,
+            None => 0b1111,
+
+            Some(TrapCode::User(_)) => panic!("cannot set user trap code in mem flags"),
+        };
+        self.bits &= !MASK_TRAP_CODE;
+        self.bits |= bits << TRAP_CODE_OFFSET;
         self
     }
 }
 
 impl fmt::Display for MemFlags {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        for (i, n) in NAMES.iter().enumerate() {
-            if self.bits & (1 << i) != 0 {
-                write!(f, " {}", n)?;
-            }
+        match self.trap_code() {
+            None => write!(f, " notrap")?,
+            // This is the default trap code, so don't print anything extra
+            // for this.
+            Some(TrapCode::HeapOutOfBounds) => {}
+            Some(t) => write!(f, " {t}")?,
+        }
+        if self.aligned() {
+            write!(f, " aligned")?;
+        }
+        if self.readonly() {
+            write!(f, " readonly")?;
+        }
+        if self.read_bit(BIT_BIG_ENDIAN) {
+            write!(f, " big")?;
+        }
+        if self.read_bit(BIT_LITTLE_ENDIAN) {
+            write!(f, " little")?;
+        }
+        if self.checked() {
+            write!(f, " checked")?;
+        }
+        match self.alias_region() {
+            None => {}
+            Some(AliasRegion::Heap) => write!(f, " heap")?,
+            Some(AliasRegion::Table) => write!(f, " table")?,
+            Some(AliasRegion::Vmctx) => write!(f, " vmctx")?,
         }
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn roundtrip_traps() {
+        for trap in TrapCode::non_user_traps().iter().copied() {
+            let flags = MemFlags::new().with_trap_code(Some(trap));
+            assert_eq!(flags.trap_code(), Some(trap));
+        }
+        let flags = MemFlags::new().with_trap_code(None);
+        assert_eq!(flags.trap_code(), None);
+    }
+
+    #[test]
+    fn cannot_set_big_and_little() {
+        let mut big = MemFlags::new().with_endianness(Endianness::Big);
+        assert!(big.set_by_name("little").is_err());
+
+        let mut little = MemFlags::new().with_endianness(Endianness::Little);
+        assert!(little.set_by_name("big").is_err());
+    }
+
+    #[test]
+    fn only_one_region() {
+        let mut big = MemFlags::new().with_alias_region(Some(AliasRegion::Heap));
+        assert!(big.set_by_name("table").is_err());
+        assert!(big.set_by_name("vmctx").is_err());
+
+        let mut big = MemFlags::new().with_alias_region(Some(AliasRegion::Table));
+        assert!(big.set_by_name("heap").is_err());
+        assert!(big.set_by_name("vmctx").is_err());
+
+        let mut big = MemFlags::new().with_alias_region(Some(AliasRegion::Vmctx));
+        assert!(big.set_by_name("heap").is_err());
+        assert!(big.set_by_name("table").is_err());
+    }
+}
diff --git a/cranelift/codegen/src/ir/memtype.rs b/cranelift/codegen/src/ir/memtype.rs
new file mode 100644
index 000000000000..4df26f1647e5
--- /dev/null
+++ b/cranelift/codegen/src/ir/memtype.rs
@@ -0,0 +1,190 @@
+//! Definitions for "memory types" in CLIF.
+//!
+//! A memory type is a struct-like definition -- fields with offsets,
+//! each field having a type and possibly an attached fact -- that we
+//! can use in proof-carrying code to validate accesses to structs and
+//! propagate facts onto the loaded values as well.
+//!
+//! Memory types are meant to be rich enough to describe the *layout*
+//! of values in memory, but do not necessarily need to embody
+//! higher-level features such as subtyping directly. Rather, they
+//! should encode an implementation of a type or object system.
+//!
+//! Note also that it is a non-goal for now for this type system to be
+//! "complete" or fully orthogonal: we have some restrictions now
+//! (e.g., struct fields are only primitives) because this is all we
+//! need for existing PCC applications, and it keeps the
+//! implementation simpler.
+//!
+//! There are a few basic kinds of types:
+//!
+//! - A struct is an aggregate of fields and an overall size. Each
+//!   field has a *primitive Cranelift type*. This is for simplicity's
+//!   sake: we do not allow nested memory types because to do so
+//!   invites cycles, requires recursive computation of sizes, creates
+//!   complicated questions when field types are dynamically-sized,
+//!   and in general is more complexity than we need.
+//!
+//!   The expectation (validated by PCC) is that when a checked load
+//!   or store accesses memory typed by a memory type, accesses will
+//!   only be to fields at offsets named in the type, and will be via
+//!   the given Cranelift type -- i.e., no type-punning occurs in
+//!   memory.
+//!
+//!   The overall size of the struct may be larger than that implied
+//!   by the fields because (i) we may not want or need to name all
+//!   the actually-existing fields in the memory type, and (ii) there
+//!   may be alignment padding that we also don't want or need to
+//!   represent explicitly.
+//!
+//! - A static memory is an untyped blob of storage with a static
+//!   size. This is memory that can be accessed with any type of load
+//!   or store at any valid offset.
+//!
+//!   Note that this is *distinct* from an "array of u8" kind of
+//!   representation of memory, if/when we can represent such a thing,
+//!   because the expectation with memory types' fields (including
+//!   array elements) is that they are strongly typed, only accessed
+//!   via that type, and not type-punned. We don't want to imply any
+//!   restriction on load/store size, or any actual structure, with
+//!   untyped memory; it's just a blob.
+//!
+//! Eventually we plan to also have:
+//!
+//! - A dynamic array is a sequence of struct memory types, with a
+//!   length given by a global value (GV). This is useful to model,
+//!   e.g., tables.
+//!
+//! - A discriminated union is a union of several memory types
+//!   together with a tag field. This will be useful to model and
+//!   verify subtyping/downcasting for Wasm GC, among other uses.
+//!
+//! - Nullability on pointer fields: the fact will hold only if the
+//!   field is not null (all zero bits).
+
+use crate::ir::pcc::Fact;
+use crate::ir::{GlobalValue, Type};
+use alloc::vec::Vec;
+
+#[cfg(feature = "enable-serde")]
+use serde_derive::{Deserialize, Serialize};
+
+/// Data defining a memory type.
+///
+/// A memory type corresponds to a layout of data in memory. It may
+/// have a statically-known or dynamically-known size.
+#[derive(Clone, PartialEq, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub enum MemoryTypeData {
+    /// An aggregate consisting of certain fields at certain offsets.
+    ///
+    /// Fields must be sorted by offset, must be within the struct's
+    /// overall size, and must not overlap. These conditions are
+    /// checked by the CLIF verifier.
+    Struct {
+        /// Size of this type.
+        size: u64,
+
+        /// Fields in this type. Sorted by offset.
+        fields: Vec<MemoryTypeField>,
+    },
+
+    /// A statically-sized untyped blob of memory.
+    Memory {
+        /// Accessible size.
+        size: u64,
+    },
+
+    /// A dynamically-sized untyped blob of memory, with bound given
+    /// by a global value plus some static amount.
+    DynamicMemory {
+        /// Static part of size.
+        size: u64,
+        /// Dynamic part of size.
+        gv: GlobalValue,
+    },
+
+    /// A type with no size.
+    Empty,
+}
+
+impl std::default::Default for MemoryTypeData {
+    fn default() -> Self {
+        Self::Empty
+    }
+}
+
+impl std::fmt::Display for MemoryTypeData {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            Self::Struct { size, fields } => {
+                write!(f, "struct {size} {{")?;
+                let mut first = true;
+                for field in fields {
+                    if first {
+                        first = false;
+                    } else {
+                        write!(f, ",")?;
+                    }
+                    write!(f, " {}: {}", field.offset, field.ty)?;
+                    if field.readonly {
+                        write!(f, " readonly")?;
+                    }
+                    if let Some(fact) = &field.fact {
+                        write!(f, " ! {fact}")?;
+                    }
+                }
+                write!(f, " }}")?;
+                Ok(())
+            }
+            Self::Memory { size } => {
+                write!(f, "memory {size:#x}")
+            }
+            Self::DynamicMemory { size, gv } => {
+                write!(f, "dynamic_memory {gv}+{size:#x}")
+            }
+            Self::Empty => {
+                write!(f, "empty")
+            }
+        }
+    }
+}
+
+/// One field in a memory type.
+#[derive(Clone, PartialEq, Hash)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct MemoryTypeField {
+    /// The offset of this field in the memory type.
+    pub offset: u64,
+    /// The primitive type of the value in this field. Accesses to the
+    /// field must use this type (i.e., cannot bitcast/type-pun in
+    /// memory).
+    pub ty: Type,
+    /// A proof-carrying-code fact about this value, if any.
+    pub fact: Option<Fact>,
+    /// Whether this field is read-only, i.e., stores should be
+    /// disallowed.
+    pub readonly: bool,
+}
+
+impl MemoryTypeField {
+    /// Get the fact, if any, on a field.
+    pub fn fact(&self) -> Option<&Fact> {
+        self.fact.as_ref()
+    }
+}
+
+impl MemoryTypeData {
+    /// Provide the static size of this type, if known.
+    ///
+    /// (The size may not be known for dynamically-sized arrays or
+    /// memories, when those memtype kinds are added.)
+    pub fn static_size(&self) -> Option<u64> {
+        match self {
+            Self::Struct { size, .. } => Some(*size),
+            Self::Memory { size } => Some(*size),
+            Self::DynamicMemory { .. } => None,
+            Self::Empty => Some(0),
+        }
+    }
+}
diff --git a/cranelift/codegen/src/ir/mod.rs b/cranelift/codegen/src/ir/mod.rs
index 986f8003722c..e6f082d70a8d 100644
--- a/cranelift/codegen/src/ir/mod.rs
+++ b/cranelift/codegen/src/ir/mod.rs
@@ -18,12 +18,14 @@ pub(crate) mod known_symbol;
 pub mod layout;
 pub(crate) mod libcall;
 mod memflags;
+mod memtype;
+pub mod pcc;
 mod progpoint;
 mod sourceloc;
 pub mod stackslot;
-mod table;
 mod trapcode;
 pub mod types;
+mod user_stack_maps;
 
 #[cfg(feature = "enable-serde")]
 use serde_derive::{Deserialize, Serialize};
@@ -37,7 +39,7 @@ pub use crate::ir::dfg::{BlockData, DataFlowGraph, ValueDef};
 pub use crate::ir::dynamic_type::{dynamic_to_fixed, DynamicTypeData, DynamicTypes};
 pub use crate::ir::entities::{
     Block, Constant, DynamicStackSlot, DynamicType, FuncRef, GlobalValue, Immediate, Inst,
-    JumpTable, SigRef, StackSlot, Table, UserExternalNameRef, Value,
+    JumpTable, MemoryType, SigRef, StackSlot, UserExternalNameRef, Value,
 };
 pub use crate::ir::extfunc::{
     AbiParam, ArgumentExtension, ArgumentPurpose, ExtFuncData, Signature,
@@ -52,16 +54,18 @@ pub use crate::ir::jumptable::JumpTableData;
 pub use crate::ir::known_symbol::KnownSymbol;
 pub use crate::ir::layout::Layout;
 pub use crate::ir::libcall::{get_probestack_funcref, LibCall};
-pub use crate::ir::memflags::{Endianness, MemFlags};
+pub use crate::ir::memflags::{AliasRegion, Endianness, MemFlags};
+pub use crate::ir::memtype::{MemoryTypeData, MemoryTypeField};
+pub use crate::ir::pcc::{BaseExpr, Expr, Fact, FactContext, PccError, PccResult};
 pub use crate::ir::progpoint::ProgramPoint;
 pub use crate::ir::sourceloc::RelSourceLoc;
 pub use crate::ir::sourceloc::SourceLoc;
 pub use crate::ir::stackslot::{
     DynamicStackSlotData, DynamicStackSlots, StackSlotData, StackSlotKind, StackSlots,
 };
-pub use crate::ir::table::TableData;
 pub use crate::ir::trapcode::TrapCode;
 pub use crate::ir::types::Type;
+pub use crate::ir::user_stack_maps::{UserStackMap, UserStackMapEntry};
 
 use crate::entity::{entity_impl, PrimaryMap, SecondaryMap};
 
diff --git a/cranelift/codegen/src/ir/pcc.rs b/cranelift/codegen/src/ir/pcc.rs
new file mode 100644
index 000000000000..33a515cac670
--- /dev/null
+++ b/cranelift/codegen/src/ir/pcc.rs
@@ -0,0 +1,1682 @@
+//! Proof-carrying code. We attach "facts" to values and then check
+//! that they remain true after compilation.
+//!
+//! A few key design principle of this approach are:
+//!
+//! - The producer of the IR provides the axioms. All "ground truth",
+//!   such as what memory is accessible -- is meant to come by way of
+//!   facts on the function arguments and global values. In some
+//!   sense, all we are doing here is validating the "internal
+//!   consistency" of the facts that are provided on values, and the
+//!   actions performed on those values.
+//!
+//! - We do not derive and forward-propagate facts eagerly. Rather,
+//!   the producer needs to provide breadcrumbs -- a "proof witness"
+//!   of sorts -- to allow the checking to complete. That means that
+//!   as an address is computed, or pointer chains are dereferenced,
+//!   each intermediate value will likely have some fact attached.
+//!
+//!   This does create more verbose IR, but a significant positive
+//!   benefit is that it avoids unnecessary work: we do not build up a
+//!   knowledge base that effectively encodes the integer ranges of
+//!   many or most values in the program. Rather, we only check
+//!   specifically the memory-access sequences. In practice, each such
+//!   sequence is likely to be a carefully-controlled sequence of IR
+//!   operations from, e.g., a sandboxing compiler (such as
+//!   `cranelift-wasm`) so adding annotations here to communicate
+//!   intent (ranges, bounds-checks, and the like) is no problem.
+//!
+//! Facts are attached to SSA values in CLIF, and are maintained
+//! through optimizations and through lowering. They are thus also
+//! present on VRegs in the VCode. In theory, facts could be checked
+//! at either level, though in practice it is most useful to check
+//! them at the VCode level if the goal is an end-to-end verification
+//! of certain properties (e.g., memory sandboxing).
+//!
+//! Checking facts entails visiting each instruction that defines a
+//! value with a fact, and checking the result's fact against the
+//! facts on arguments and the operand. For VCode, this is
+//! fundamentally a question of the target ISA's semantics, so we call
+//! into the `LowerBackend` for this. Note that during checking there
+//! is also limited forward propagation / inference, but only within
+//! an instruction: for example, an addressing mode commonly can
+//! include an addition, multiplication/shift, or extend operation,
+//! and there is no way to attach facts to the intermediate values
+//! "inside" the instruction, so instead the backend can use
+//! `FactContext::add()` and friends to forward-propagate facts.
+//!
+//! TODO:
+//!
+//! Deployment:
+//! - Add to fuzzing
+//! - Turn on during wasm spec-tests
+//!
+//! More checks:
+//! - Check that facts on `vmctx` GVs are subsumed by the actual facts
+//!   on the vmctx arg in block0 (function arg).
+//!
+//! Generality:
+//! - facts on outputs (in func signature)?
+//! - Implement checking at the CLIF level as well.
+//! - Check instructions that can trap as well?
+//!
+//! Nicer errors:
+//! - attach instruction index or some other identifier to errors
+//!
+//! Text format cleanup:
+//! - make the bitwidth on `max` facts optional in the CLIF text
+//!   format?
+//! - make offset in `mem` fact optional in the text format?
+//!
+//! Bikeshed colors (syntax):
+//! - Put fact bang-annotations after types?
+//!   `v0: i64 ! fact(..)` vs. `v0 ! fact(..): i64`
+
+use crate::ir;
+use crate::ir::types::*;
+use crate::isa::TargetIsa;
+use crate::machinst::{BlockIndex, LowerBackend, VCode};
+use crate::trace;
+use regalloc2::Function as _;
+use std::fmt;
+
+#[cfg(feature = "enable-serde")]
+use serde_derive::{Deserialize, Serialize};
+
+/// The result of checking proof-carrying-code facts.
+pub type PccResult<T> = std::result::Result<T, PccError>;
+
+/// An error or inconsistency discovered when checking proof-carrying
+/// code.
+#[derive(Debug, Clone)]
+pub enum PccError {
+    /// An operation wraps around, invalidating the stated value
+    /// range.
+    Overflow,
+    /// An input to an operator that produces a fact-annotated value
+    /// does not have a fact describing it, and one is needed.
+    MissingFact,
+    /// A derivation of an output fact is unsupported (incorrect or
+    /// not derivable).
+    UnsupportedFact,
+    /// A block parameter claims a fact that one of its predecessors
+    /// does not support.
+    UnsupportedBlockparam,
+    /// A memory access is out of bounds.
+    OutOfBounds,
+    /// Proof-carrying-code checking is not implemented for a
+    /// particular compiler backend.
+    UnimplementedBackend,
+    /// Proof-carrying-code checking is not implemented for a
+    /// particular instruction that instruction-selection chose. This
+    /// is an internal compiler error.
+    UnimplementedInst,
+    /// Access to an invalid or undefined field offset in a struct.
+    InvalidFieldOffset,
+    /// Access to a field via the wrong type.
+    BadFieldType,
+    /// Store to a read-only field.
+    WriteToReadOnlyField,
+    /// Store of data to a field with a fact that does not subsume the
+    /// field's fact.
+    InvalidStoredFact,
+}
+
+/// A fact on a value.
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub enum Fact {
+    /// A bitslice of a value (up to a bitwidth) is within the given
+    /// integer range.
+    ///
+    /// The slicing behavior is needed because this fact can describe
+    /// both an SSA `Value`, whose entire value is well-defined, and a
+    /// `VReg` in VCode, whose bits beyond the type stored in that
+    /// register are don't-care (undefined).
+    Range {
+        /// The bitwidth of bits we care about, from the LSB upward.
+        bit_width: u16,
+        /// The minimum value that the bitslice can take
+        /// (inclusive). The range is unsigned: the specified bits of
+        /// the actual value will be greater than or equal to this
+        /// value, as evaluated by an unsigned integer comparison.
+        min: u64,
+        /// The maximum value that the bitslice can take
+        /// (inclusive). The range is unsigned: the specified bits of
+        /// the actual value will be less than or equal to this value,
+        /// as evaluated by an unsigned integer comparison.
+        max: u64,
+    },
+
+    /// A value bounded by a global value.
+    ///
+    /// The range is in `(min_GV + min_offset)..(max_GV +
+    /// max_offset)`, inclusive on the lower and upper bound.
+    DynamicRange {
+        /// The bitwidth of bits we care about, from the LSB upward.
+        bit_width: u16,
+        /// The lower bound, inclusive.
+        min: Expr,
+        /// The upper bound, inclusive.
+        max: Expr,
+    },
+
+    /// A pointer to a memory type.
+    Mem {
+        /// The memory type.
+        ty: ir::MemoryType,
+        /// The minimum offset into the memory type, inclusive.
+        min_offset: u64,
+        /// The maximum offset into the memory type, inclusive.
+        max_offset: u64,
+        /// This pointer can also be null.
+        nullable: bool,
+    },
+
+    /// A pointer to a memory type, dynamically bounded. The pointer
+    /// is within `(GV_min+offset_min)..(GV_max+offset_max)`
+    /// (inclusive on both ends) in the memory type.
+    DynamicMem {
+        /// The memory type.
+        ty: ir::MemoryType,
+        /// The lower bound, inclusive.
+        min: Expr,
+        /// The upper bound, inclusive.
+        max: Expr,
+        /// This pointer can also be null.
+        nullable: bool,
+    },
+
+    /// A definition of a value to be used as a symbol in
+    /// BaseExprs. There can only be one of these per value number.
+    ///
+    /// Note that this differs from a `DynamicRange` specifying that
+    /// some value in the program is the same as `value`. A `def(v1)`
+    /// fact is propagated to machine code and serves as a source of
+    /// truth: the value or location labeled with this fact *defines*
+    /// what `v1` is, and any `dynamic_range(64, v1, v1)`-labeled
+    /// values elsewhere are claiming to be equal to this value.
+    ///
+    /// This is necessary because we don't propagate SSA value labels
+    /// down to machine code otherwise; so when referring symbolically
+    /// to addresses and expressions derived from addresses, we need
+    /// to introduce the symbol first.
+    Def {
+        /// The SSA value this value defines.
+        value: ir::Value,
+    },
+
+    /// A comparison result between two dynamic values with a
+    /// comparison of a certain kind.
+    Compare {
+        /// The kind of comparison.
+        kind: ir::condcodes::IntCC,
+        /// The left-hand side of the comparison.
+        lhs: Expr,
+        /// The right-hand side of the comparison.
+        rhs: Expr,
+    },
+
+    /// A "conflict fact": this fact results from merging two other
+    /// facts, and it can never be satisfied -- checking any value
+    /// against this fact will fail.
+    Conflict,
+}
+
+/// A bound expression.
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub struct Expr {
+    /// The dynamic (base) part.
+    pub base: BaseExpr,
+    /// The static (offset) part.
+    pub offset: i64,
+}
+
+/// The base part of a bound expression.
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
+pub enum BaseExpr {
+    /// No dynamic part (i.e., zero).
+    None,
+    /// A global value.
+    GlobalValue(ir::GlobalValue),
+    /// An SSA Value as a symbolic value. This can be referenced in
+    /// facts even after we've lowered out of SSA: it becomes simply
+    /// some symbolic value.
+    Value(ir::Value),
+    /// Top of the address space. This is "saturating": the offset
+    /// doesn't matter.
+    Max,
+}
+
+impl BaseExpr {
+    /// Is one base less than or equal to another? (We can't always
+    /// know; in such cases, returns `false`.)
+    fn le(lhs: &BaseExpr, rhs: &BaseExpr) -> bool {
+        // (i) reflexivity; (ii) 0 <= x for all (unsigned) x; (iii) x <= max for all x.
+        lhs == rhs || *lhs == BaseExpr::None || *rhs == BaseExpr::Max
+    }
+
+    /// Compute some BaseExpr that will be less than or equal to both
+    /// inputs. This is a generalization of `min` (but looser).
+    fn min(lhs: &BaseExpr, rhs: &BaseExpr) -> BaseExpr {
+        if lhs == rhs {
+            lhs.clone()
+        } else if *lhs == BaseExpr::Max {
+            rhs.clone()
+        } else if *rhs == BaseExpr::Max {
+            lhs.clone()
+        } else {
+            BaseExpr::None // zero is <= x for all (unsigned) x.
+        }
+    }
+
+    /// Compute some BaseExpr that will be greater than or equal to
+    /// both inputs.
+    fn max(lhs: &BaseExpr, rhs: &BaseExpr) -> BaseExpr {
+        if lhs == rhs {
+            lhs.clone()
+        } else if *lhs == BaseExpr::None {
+            rhs.clone()
+        } else if *rhs == BaseExpr::None {
+            lhs.clone()
+        } else {
+            BaseExpr::Max
+        }
+    }
+}
+
+impl Expr {
+    /// Constant value.
+    pub fn constant(offset: i64) -> Self {
+        Expr {
+            base: BaseExpr::None,
+            offset,
+        }
+    }
+
+    /// The value of an SSA value.
+    pub fn value(value: ir::Value) -> Self {
+        Expr {
+            base: BaseExpr::Value(value),
+            offset: 0,
+        }
+    }
+
+    /// The value of a global value.
+    pub fn global_value(gv: ir::GlobalValue) -> Self {
+        Expr {
+            base: BaseExpr::GlobalValue(gv),
+            offset: 0,
+        }
+    }
+
+    /// Is one expression definitely less than or equal to another?
+    /// (We can't always know; in such cases, returns `false`.)
+    fn le(lhs: &Expr, rhs: &Expr) -> bool {
+        if rhs.base == BaseExpr::Max {
+            true
+        } else {
+            BaseExpr::le(&lhs.base, &rhs.base) && lhs.offset <= rhs.offset
+        }
+    }
+
+    /// Generalization of `min`: compute some Expr that is less than
+    /// or equal to both inputs.
+    fn min(lhs: &Expr, rhs: &Expr) -> Expr {
+        if lhs.base == BaseExpr::None && lhs.offset == 0 {
+            lhs.clone()
+        } else if rhs.base == BaseExpr::None && rhs.offset == 0 {
+            rhs.clone()
+        } else {
+            Expr {
+                base: BaseExpr::min(&lhs.base, &rhs.base),
+                offset: std::cmp::min(lhs.offset, rhs.offset),
+            }
+        }
+    }
+
+    /// Generalization of `max`: compute some Expr that is greater
+    /// than or equal to both inputs.
+    fn max(lhs: &Expr, rhs: &Expr) -> Expr {
+        if lhs.base == BaseExpr::None && lhs.offset == 0 {
+            rhs.clone()
+        } else if rhs.base == BaseExpr::None && rhs.offset == 0 {
+            lhs.clone()
+        } else {
+            Expr {
+                base: BaseExpr::max(&lhs.base, &rhs.base),
+                offset: std::cmp::max(lhs.offset, rhs.offset),
+            }
+        }
+    }
+
+    /// Add one expression to another.
+    fn add(lhs: &Expr, rhs: &Expr) -> Option<Expr> {
+        if lhs.base == rhs.base {
+            Some(Expr {
+                base: lhs.base.clone(),
+                offset: lhs.offset.checked_add(rhs.offset)?,
+            })
+        } else if lhs.base == BaseExpr::None {
+            Some(Expr {
+                base: rhs.base.clone(),
+                offset: lhs.offset.checked_add(rhs.offset)?,
+            })
+        } else if rhs.base == BaseExpr::None {
+            Some(Expr {
+                base: lhs.base.clone(),
+                offset: lhs.offset.checked_add(rhs.offset)?,
+            })
+        } else {
+            Some(Expr {
+                base: BaseExpr::Max,
+                offset: 0,
+            })
+        }
+    }
+
+    /// Add a static offset to an expression.
+    pub fn offset(lhs: &Expr, rhs: i64) -> Option<Expr> {
+        let offset = lhs.offset.checked_add(rhs)?;
+        Some(Expr {
+            base: lhs.base.clone(),
+            offset,
+        })
+    }
+
+    /// Is this Expr a BaseExpr with no offset? Return it if so.
+    pub fn without_offset(&self) -> Option<&BaseExpr> {
+        if self.offset == 0 {
+            Some(&self.base)
+        } else {
+            None
+        }
+    }
+}
+
+impl fmt::Display for BaseExpr {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            BaseExpr::None => Ok(()),
+            BaseExpr::Max => write!(f, "max"),
+            BaseExpr::GlobalValue(gv) => write!(f, "{gv}"),
+            BaseExpr::Value(value) => write!(f, "{value}"),
+        }
+    }
+}
+
+impl BaseExpr {
+    /// Does this dynamic_expression take an offset?
+    pub fn is_some(&self) -> bool {
+        match self {
+            BaseExpr::None => false,
+            _ => true,
+        }
+    }
+}
+
+impl fmt::Display for Expr {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.base)?;
+        match self.offset {
+            offset if offset > 0 && self.base.is_some() => write!(f, "+{offset:#x}"),
+            offset if offset > 0 => write!(f, "{offset:#x}"),
+            offset if offset < 0 => {
+                let negative_offset = -i128::from(offset); // upcast to support i64::MIN.
+                write!(f, "-{negative_offset:#x}")
+            }
+            0 if self.base.is_some() => Ok(()),
+            0 => write!(f, "0"),
+            _ => unreachable!(),
+        }
+    }
+}
+
+impl fmt::Display for Fact {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Fact::Range {
+                bit_width,
+                min,
+                max,
+            } => write!(f, "range({bit_width}, {min:#x}, {max:#x})"),
+            Fact::DynamicRange {
+                bit_width,
+                min,
+                max,
+            } => {
+                write!(f, "dynamic_range({bit_width}, {min}, {max})")
+            }
+            Fact::Mem {
+                ty,
+                min_offset,
+                max_offset,
+                nullable,
+            } => {
+                let nullable_flag = if *nullable { ", nullable" } else { "" };
+                write!(
+                    f,
+                    "mem({ty}, {min_offset:#x}, {max_offset:#x}{nullable_flag})"
+                )
+            }
+            Fact::DynamicMem {
+                ty,
+                min,
+                max,
+                nullable,
+            } => {
+                let nullable_flag = if *nullable { ", nullable" } else { "" };
+                write!(f, "dynamic_mem({ty}, {min}, {max}{nullable_flag})")
+            }
+            Fact::Def { value } => write!(f, "def({value})"),
+            Fact::Compare { kind, lhs, rhs } => {
+                write!(f, "compare({kind}, {lhs}, {rhs})")
+            }
+            Fact::Conflict => write!(f, "conflict"),
+        }
+    }
+}
+
+impl Fact {
+    /// Create a range fact that specifies a single known constant value.
+    pub fn constant(bit_width: u16, value: u64) -> Self {
+        debug_assert!(value <= max_value_for_width(bit_width));
+        // `min` and `max` are inclusive, so this specifies a range of
+        // exactly one value.
+        Fact::Range {
+            bit_width,
+            min: value,
+            max: value,
+        }
+    }
+
+    /// Create a dynamic range fact that points to the base of a dynamic memory.
+    pub fn dynamic_base_ptr(ty: ir::MemoryType) -> Self {
+        Fact::DynamicMem {
+            ty,
+            min: Expr::constant(0),
+            max: Expr::constant(0),
+            nullable: false,
+        }
+    }
+
+    /// Create a fact that specifies the value is exactly an SSA value.
+    ///
+    /// Note that this differs from a `def` fact: it is not *defining*
+    /// a symbol to have the value that this fact is attached to;
+    /// rather it is claiming that this value is the same as whatever
+    /// that symbol is. (In other words, the def should be elsewhere,
+    /// and we are tying ourselves to it.)
+    pub fn value(bit_width: u16, value: ir::Value) -> Self {
+        Fact::DynamicRange {
+            bit_width,
+            min: Expr::value(value),
+            max: Expr::value(value),
+        }
+    }
+
+    /// Create a fact that specifies the value is exactly an SSA value plus some offset.
+    pub fn value_offset(bit_width: u16, value: ir::Value, offset: i64) -> Self {
+        Fact::DynamicRange {
+            bit_width,
+            min: Expr::offset(&Expr::value(value), offset).unwrap(),
+            max: Expr::offset(&Expr::value(value), offset).unwrap(),
+        }
+    }
+
+    /// Create a fact that specifies the value is exactly the value of a GV.
+    pub fn global_value(bit_width: u16, gv: ir::GlobalValue) -> Self {
+        Fact::DynamicRange {
+            bit_width,
+            min: Expr::global_value(gv),
+            max: Expr::global_value(gv),
+        }
+    }
+
+    /// Create a fact that specifies the value is exactly the value of a GV plus some offset.
+    pub fn global_value_offset(bit_width: u16, gv: ir::GlobalValue, offset: i64) -> Self {
+        Fact::DynamicRange {
+            bit_width,
+            min: Expr::offset(&Expr::global_value(gv), offset).unwrap(),
+            max: Expr::offset(&Expr::global_value(gv), offset).unwrap(),
+        }
+    }
+
+    /// Create a range fact that specifies the maximum range for a
+    /// value of the given bit-width.
+    pub const fn max_range_for_width(bit_width: u16) -> Self {
+        match bit_width {
+            bit_width if bit_width < 64 => Fact::Range {
+                bit_width,
+                min: 0,
+                max: (1u64 << bit_width) - 1,
+            },
+            64 => Fact::Range {
+                bit_width: 64,
+                min: 0,
+                max: u64::MAX,
+            },
+            _ => panic!("bit width too large!"),
+        }
+    }
+
+    /// Create a range fact that specifies the maximum range for a
+    /// value of the given bit-width, zero-extended into a wider
+    /// width.
+    pub const fn max_range_for_width_extended(from_width: u16, to_width: u16) -> Self {
+        debug_assert!(from_width <= to_width);
+        match from_width {
+            from_width if from_width < 64 => Fact::Range {
+                bit_width: to_width,
+                min: 0,
+                max: (1u64 << from_width) - 1,
+            },
+            64 => Fact::Range {
+                bit_width: to_width,
+                min: 0,
+                max: u64::MAX,
+            },
+            _ => panic!("bit width too large!"),
+        }
+    }
+
+    /// Try to infer a minimal fact for a value of the given IR type.
+    pub fn infer_from_type(ty: ir::Type) -> Option<&'static Self> {
+        static FACTS: [Fact; 4] = [
+            Fact::max_range_for_width(8),
+            Fact::max_range_for_width(16),
+            Fact::max_range_for_width(32),
+            Fact::max_range_for_width(64),
+        ];
+        match ty {
+            I8 => Some(&FACTS[0]),
+            I16 => Some(&FACTS[1]),
+            I32 => Some(&FACTS[2]),
+            I64 => Some(&FACTS[3]),
+            _ => None,
+        }
+    }
+
+    /// Does this fact "propagate" automatically, i.e., cause
+    /// instructions that process it to infer their own output facts?
+    /// Not all facts propagate automatically; otherwise, verification
+    /// would be much slower.
+    pub fn propagates(&self) -> bool {
+        match self {
+            Fact::Mem { .. } => true,
+            _ => false,
+        }
+    }
+
+    /// Is this a constant value of the given bitwidth? Return it as a
+    /// `Some(value)` if so.
+    pub fn as_const(&self, bits: u16) -> Option<u64> {
+        match self {
+            Fact::Range {
+                bit_width,
+                min,
+                max,
+            } if *bit_width == bits && min == max => Some(*min),
+            _ => None,
+        }
+    }
+
+    /// Is this fact a single-value range with a symbolic Expr?
+    pub fn as_symbol(&self) -> Option<&Expr> {
+        match self {
+            Fact::DynamicRange { min, max, .. } if min == max => Some(min),
+            _ => None,
+        }
+    }
+
+    /// Merge two facts. We take the *intersection*: that is, we know
+    /// both facts to be true, so we can intersect ranges. (This
+    /// differs from the usual static analysis approach, where we are
+    /// merging multiple possibilities into a generalized / widened
+    /// fact. We want to narrow here.)
+    pub fn intersect(a: &Fact, b: &Fact) -> Fact {
+        match (a, b) {
+            (
+                Fact::Range {
+                    bit_width: bw_lhs,
+                    min: min_lhs,
+                    max: max_lhs,
+                },
+                Fact::Range {
+                    bit_width: bw_rhs,
+                    min: min_rhs,
+                    max: max_rhs,
+                },
+            ) if bw_lhs == bw_rhs && max_lhs >= min_rhs && max_rhs >= min_lhs => Fact::Range {
+                bit_width: *bw_lhs,
+                min: std::cmp::max(*min_lhs, *min_rhs),
+                max: std::cmp::min(*max_lhs, *max_rhs),
+            },
+
+            (
+                Fact::DynamicRange {
+                    bit_width: bw_lhs,
+                    min: min_lhs,
+                    max: max_lhs,
+                },
+                Fact::DynamicRange {
+                    bit_width: bw_rhs,
+                    min: min_rhs,
+                    max: max_rhs,
+                },
+            ) if bw_lhs == bw_rhs && Expr::le(min_rhs, max_lhs) && Expr::le(min_lhs, max_rhs) => {
+                Fact::DynamicRange {
+                    bit_width: *bw_lhs,
+                    min: Expr::max(min_lhs, min_rhs),
+                    max: Expr::min(max_lhs, max_rhs),
+                }
+            }
+
+            (
+                Fact::Mem {
+                    ty: ty_lhs,
+                    min_offset: min_offset_lhs,
+                    max_offset: max_offset_lhs,
+                    nullable: nullable_lhs,
+                },
+                Fact::Mem {
+                    ty: ty_rhs,
+                    min_offset: min_offset_rhs,
+                    max_offset: max_offset_rhs,
+                    nullable: nullable_rhs,
+                },
+            ) if ty_lhs == ty_rhs
+                && max_offset_lhs >= min_offset_rhs
+                && max_offset_rhs >= min_offset_lhs =>
+            {
+                Fact::Mem {
+                    ty: *ty_lhs,
+                    min_offset: std::cmp::max(*min_offset_lhs, *min_offset_rhs),
+                    max_offset: std::cmp::min(*max_offset_lhs, *max_offset_rhs),
+                    nullable: *nullable_lhs && *nullable_rhs,
+                }
+            }
+
+            (
+                Fact::DynamicMem {
+                    ty: ty_lhs,
+                    min: min_lhs,
+                    max: max_lhs,
+                    nullable: null_lhs,
+                },
+                Fact::DynamicMem {
+                    ty: ty_rhs,
+                    min: min_rhs,
+                    max: max_rhs,
+                    nullable: null_rhs,
+                },
+            ) if ty_lhs == ty_rhs && Expr::le(min_rhs, max_lhs) && Expr::le(min_lhs, max_rhs) => {
+                Fact::DynamicMem {
+                    ty: *ty_lhs,
+                    min: Expr::max(min_lhs, min_rhs),
+                    max: Expr::min(max_lhs, max_rhs),
+                    nullable: *null_lhs && *null_rhs,
+                }
+            }
+
+            _ => Fact::Conflict,
+        }
+    }
+}
+
+macro_rules! ensure {
+    ( $condition:expr, $err:tt $(,)? ) => {
+        if !$condition {
+            return Err(PccError::$err);
+        }
+    };
+}
+
+macro_rules! bail {
+    ( $err:tt ) => {{
+        return Err(PccError::$err);
+    }};
+}
+
+/// The two kinds of inequalities: "strict" (`<`, `>`) and "loose"
+/// (`<=`, `>=`), the latter of which admit equality.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum InequalityKind {
+    /// Strict inequality: {less,greater}-than.
+    Strict,
+    /// Loose inequality: {less,greater}-than-or-equal.
+    Loose,
+}
+
+/// A "context" in which we can evaluate and derive facts. This
+/// context carries environment/global properties, such as the machine
+/// pointer width.
+pub struct FactContext<'a> {
+    function: &'a ir::Function,
+    pointer_width: u16,
+}
+
+impl<'a> FactContext<'a> {
+    /// Create a new "fact context" in which to evaluate facts.
+    pub fn new(function: &'a ir::Function, pointer_width: u16) -> Self {
+        FactContext {
+            function,
+            pointer_width,
+        }
+    }
+
+    /// Computes whether `lhs` "subsumes" (implies) `rhs`.
+    pub fn subsumes(&self, lhs: &Fact, rhs: &Fact) -> bool {
+        match (lhs, rhs) {
+            // Reflexivity.
+            (l, r) if l == r => true,
+
+            (
+                Fact::Range {
+                    bit_width: bw_lhs,
+                    min: min_lhs,
+                    max: max_lhs,
+                },
+                Fact::Range {
+                    bit_width: bw_rhs,
+                    min: min_rhs,
+                    max: max_rhs,
+                },
+            ) => {
+                // If the bitwidths we're claiming facts about are the
+                // same, or the left-hand-side makes a claim about a
+                // wider bitwidth, and if the right-hand-side range is
+                // larger than the left-hand-side range, than the LHS
+                // subsumes the RHS.
+                //
+                // In other words, we can always expand the claimed
+                // possible value range.
+                bw_lhs >= bw_rhs && max_lhs <= max_rhs && min_lhs >= min_rhs
+            }
+
+            (
+                Fact::DynamicRange {
+                    bit_width: bw_lhs,
+                    min: min_lhs,
+                    max: max_lhs,
+                },
+                Fact::DynamicRange {
+                    bit_width: bw_rhs,
+                    min: min_rhs,
+                    max: max_rhs,
+                },
+            ) => {
+                // Nearly same as above, but with dynamic-expression
+                // comparisons. Note that we require equal bitwidths
+                // here: unlike in the static case, we don't have
+                // fixed values for min and max, so we can't lean on
+                // the well-formedness requirements of the static
+                // ranges fitting within the bit-width max.
+                bw_lhs == bw_rhs && Expr::le(max_lhs, max_rhs) && Expr::le(min_rhs, min_lhs)
+            }
+
+            (
+                Fact::Mem {
+                    ty: ty_lhs,
+                    min_offset: min_offset_lhs,
+                    max_offset: max_offset_lhs,
+                    nullable: nullable_lhs,
+                },
+                Fact::Mem {
+                    ty: ty_rhs,
+                    min_offset: min_offset_rhs,
+                    max_offset: max_offset_rhs,
+                    nullable: nullable_rhs,
+                },
+            ) => {
+                ty_lhs == ty_rhs
+                    && max_offset_lhs <= max_offset_rhs
+                    && min_offset_lhs >= min_offset_rhs
+                    && (*nullable_lhs || !*nullable_rhs)
+            }
+
+            (
+                Fact::DynamicMem {
+                    ty: ty_lhs,
+                    min: min_lhs,
+                    max: max_lhs,
+                    nullable: nullable_lhs,
+                },
+                Fact::DynamicMem {
+                    ty: ty_rhs,
+                    min: min_rhs,
+                    max: max_rhs,
+                    nullable: nullable_rhs,
+                },
+            ) => {
+                ty_lhs == ty_rhs
+                    && Expr::le(max_lhs, max_rhs)
+                    && Expr::le(min_rhs, min_lhs)
+                    && (*nullable_lhs || !*nullable_rhs)
+            }
+
+            // Constant zero subsumes nullable DynamicMem pointers.
+            (
+                Fact::Range {
+                    bit_width,
+                    min: 0,
+                    max: 0,
+                },
+                Fact::DynamicMem { nullable: true, .. },
+            ) if *bit_width == self.pointer_width => true,
+
+            // Any fact subsumes a Def, because the Def makes no
+            // claims about the actual value (it ties a symbol to that
+            // value, but the value is fed to the symbol, not the
+            // other way around).
+            (_, Fact::Def { .. }) => true,
+
+            _ => false,
+        }
+    }
+
+    /// Computes whether the optional fact `lhs` subsumes (implies)
+    /// the optional fact `lhs`. A `None` never subsumes any fact, and
+    /// is always subsumed by any fact at all (or no fact).
+    pub fn subsumes_fact_optionals(&self, lhs: Option<&Fact>, rhs: Option<&Fact>) -> bool {
+        match (lhs, rhs) {
+            (None, None) => true,
+            (Some(_), None) => true,
+            (None, Some(_)) => false,
+            (Some(lhs), Some(rhs)) => self.subsumes(lhs, rhs),
+        }
+    }
+
+    /// Computes whatever fact can be known about the sum of two
+    /// values with attached facts. The add is performed to the given
+    /// bit-width. Note that this is distinct from the machine or
+    /// pointer width: e.g., many 64-bit machines can still do 32-bit
+    /// adds that wrap at 2^32.
+    pub fn add(&self, lhs: &Fact, rhs: &Fact, add_width: u16) -> Option<Fact> {
+        let result = match (lhs, rhs) {
+            (
+                Fact::Range {
+                    bit_width: bw_lhs,
+                    min: min_lhs,
+                    max: max_lhs,
+                },
+                Fact::Range {
+                    bit_width: bw_rhs,
+                    min: min_rhs,
+                    max: max_rhs,
+                },
+            ) if bw_lhs == bw_rhs && add_width >= *bw_lhs => {
+                let computed_min = min_lhs.checked_add(*min_rhs)?;
+                let computed_max = max_lhs.checked_add(*max_rhs)?;
+                let computed_max = std::cmp::min(max_value_for_width(add_width), computed_max);
+                Some(Fact::Range {
+                    bit_width: *bw_lhs,
+                    min: computed_min,
+                    max: computed_max,
+                })
+            }
+
+            (
+                Fact::Range {
+                    bit_width: bw_max,
+                    min,
+                    max,
+                },
+                Fact::Mem {
+                    ty,
+                    min_offset,
+                    max_offset,
+                    nullable,
+                },
+            )
+            | (
+                Fact::Mem {
+                    ty,
+                    min_offset,
+                    max_offset,
+                    nullable,
+                },
+                Fact::Range {
+                    bit_width: bw_max,
+                    min,
+                    max,
+                },
+            ) if *bw_max >= self.pointer_width
+                && add_width >= *bw_max
+                && (!*nullable || *max == 0) =>
+            {
+                let min_offset = min_offset.checked_add(*min)?;
+                let max_offset = max_offset.checked_add(*max)?;
+                Some(Fact::Mem {
+                    ty: *ty,
+                    min_offset,
+                    max_offset,
+                    nullable: false,
+                })
+            }
+
+            (
+                Fact::Range {
+                    bit_width: bw_static,
+                    min: min_static,
+                    max: max_static,
+                },
+                Fact::DynamicRange {
+                    bit_width: bw_dynamic,
+                    min: ref min_dynamic,
+                    max: ref max_dynamic,
+                },
+            )
+            | (
+                Fact::DynamicRange {
+                    bit_width: bw_dynamic,
+                    min: ref min_dynamic,
+                    max: ref max_dynamic,
+                },
+                Fact::Range {
+                    bit_width: bw_static,
+                    min: min_static,
+                    max: max_static,
+                },
+            ) if bw_static == bw_dynamic => {
+                let min = Expr::offset(min_dynamic, i64::try_from(*min_static).ok()?)?;
+                let max = Expr::offset(max_dynamic, i64::try_from(*max_static).ok()?)?;
+                Some(Fact::DynamicRange {
+                    bit_width: *bw_dynamic,
+                    min,
+                    max,
+                })
+            }
+
+            (
+                Fact::DynamicMem {
+                    ty,
+                    min: min_mem,
+                    max: max_mem,
+                    nullable: false,
+                },
+                Fact::DynamicRange {
+                    bit_width,
+                    min: min_range,
+                    max: max_range,
+                },
+            )
+            | (
+                Fact::DynamicRange {
+                    bit_width,
+                    min: min_range,
+                    max: max_range,
+                },
+                Fact::DynamicMem {
+                    ty,
+                    min: min_mem,
+                    max: max_mem,
+                    nullable: false,
+                },
+            ) if *bit_width == self.pointer_width => {
+                let min = Expr::add(min_mem, min_range)?;
+                let max = Expr::add(max_mem, max_range)?;
+                Some(Fact::DynamicMem {
+                    ty: *ty,
+                    min,
+                    max,
+                    nullable: false,
+                })
+            }
+
+            (
+                Fact::Mem {
+                    ty,
+                    min_offset,
+                    max_offset,
+                    nullable: false,
+                },
+                Fact::DynamicRange {
+                    bit_width,
+                    min: min_range,
+                    max: max_range,
+                },
+            )
+            | (
+                Fact::DynamicRange {
+                    bit_width,
+                    min: min_range,
+                    max: max_range,
+                },
+                Fact::Mem {
+                    ty,
+                    min_offset,
+                    max_offset,
+                    nullable: false,
+                },
+            ) if *bit_width == self.pointer_width => {
+                let min = Expr::offset(min_range, i64::try_from(*min_offset).ok()?)?;
+                let max = Expr::offset(max_range, i64::try_from(*max_offset).ok()?)?;
+                Some(Fact::DynamicMem {
+                    ty: *ty,
+                    min,
+                    max,
+                    nullable: false,
+                })
+            }
+
+            (
+                Fact::Range {
+                    bit_width: bw_static,
+                    min: min_static,
+                    max: max_static,
+                },
+                Fact::DynamicMem {
+                    ty,
+                    min: ref min_dynamic,
+                    max: ref max_dynamic,
+                    nullable,
+                },
+            )
+            | (
+                Fact::DynamicMem {
+                    ty,
+                    min: ref min_dynamic,
+                    max: ref max_dynamic,
+                    nullable,
+                },
+                Fact::Range {
+                    bit_width: bw_static,
+                    min: min_static,
+                    max: max_static,
+                },
+            ) if *bw_static == self.pointer_width && (!*nullable || *max_static == 0) => {
+                let min = Expr::offset(min_dynamic, i64::try_from(*min_static).ok()?)?;
+                let max = Expr::offset(max_dynamic, i64::try_from(*max_static).ok()?)?;
+                Some(Fact::DynamicMem {
+                    ty: *ty,
+                    min,
+                    max,
+                    nullable: false,
+                })
+            }
+
+            _ => None,
+        };
+
+        trace!("add: {lhs:?} + {rhs:?} -> {result:?}");
+        result
+    }
+
+    /// Computes the `uextend` of a value with the given facts.
+    pub fn uextend(&self, fact: &Fact, from_width: u16, to_width: u16) -> Option<Fact> {
+        if from_width == to_width {
+            return Some(fact.clone());
+        }
+
+        let result = match fact {
+            // If the claim is already for a same-or-wider value and the min
+            // and max are within range of the narrower value, we can
+            // claim the same range.
+            Fact::Range {
+                bit_width,
+                min,
+                max,
+            } if *bit_width >= from_width
+                && *min <= max_value_for_width(from_width)
+                && *max <= max_value_for_width(from_width) =>
+            {
+                Some(Fact::Range {
+                    bit_width: to_width,
+                    min: *min,
+                    max: *max,
+                })
+            }
+
+            // If the claim is a dynamic range for the from-width, we
+            // can extend to the to-width.
+            Fact::DynamicRange {
+                bit_width,
+                min,
+                max,
+            } if *bit_width == from_width => Some(Fact::DynamicRange {
+                bit_width: to_width,
+                min: min.clone(),
+                max: max.clone(),
+            }),
+
+            // If the claim is a definition of a value, we can say
+            // that the output has a range of exactly that value.
+            Fact::Def { value } => Some(Fact::value(to_width, *value)),
+
+            // Otherwise, we can at least claim that the value is
+            // within the range of `from_width`.
+            Fact::Range { .. } => Some(Fact::max_range_for_width_extended(from_width, to_width)),
+
+            _ => None,
+        };
+        trace!("uextend: fact {fact:?} from {from_width} to {to_width} -> {result:?}");
+        result
+    }
+
+    /// Computes the `sextend` of a value with the given facts.
+    pub fn sextend(&self, fact: &Fact, from_width: u16, to_width: u16) -> Option<Fact> {
+        match fact {
+            // If we have a defined value in bits 0..bit_width, and
+            // the MSB w.r.t. `from_width` is *not* set, then we can
+            // do the same as `uextend`.
+            Fact::Range {
+                bit_width,
+                // We can ignore `min`: it is always <= max in
+                // unsigned terms, and we check max's LSB below.
+                min: _,
+                max,
+            } if *bit_width == from_width && (*max & (1 << (*bit_width - 1)) == 0) => {
+                self.uextend(fact, from_width, to_width)
+            }
+            _ => None,
+        }
+    }
+
+    /// Computes the bit-truncation of a value with the given fact.
+    pub fn truncate(&self, fact: &Fact, from_width: u16, to_width: u16) -> Option<Fact> {
+        if from_width == to_width {
+            return Some(fact.clone());
+        }
+
+        trace!(
+            "truncate: fact {:?} from {} to {}",
+            fact,
+            from_width,
+            to_width
+        );
+
+        match fact {
+            Fact::Range {
+                bit_width,
+                min,
+                max,
+            } if *bit_width == from_width => {
+                let max_val = (1u64 << to_width) - 1;
+                if *min <= max_val && *max <= max_val {
+                    Some(Fact::Range {
+                        bit_width: to_width,
+                        min: *min,
+                        max: *max,
+                    })
+                } else {
+                    Some(Fact::Range {
+                        bit_width: to_width,
+                        min: 0,
+                        max: max_val,
+                    })
+                }
+            }
+            _ => None,
+        }
+    }
+
+    /// Scales a value with a fact by a known constant.
+    pub fn scale(&self, fact: &Fact, width: u16, factor: u32) -> Option<Fact> {
+        let result = match fact {
+            x if factor == 1 => Some(x.clone()),
+
+            Fact::Range {
+                bit_width,
+                min,
+                max,
+            } if *bit_width == width => {
+                let min = min.checked_mul(u64::from(factor))?;
+                let max = max.checked_mul(u64::from(factor))?;
+                if *bit_width < 64 && max > max_value_for_width(width) {
+                    return None;
+                }
+                Some(Fact::Range {
+                    bit_width: *bit_width,
+                    min,
+                    max,
+                })
+            }
+            _ => None,
+        };
+        trace!("scale: {fact:?} * {factor} at width {width} -> {result:?}");
+        result
+    }
+
+    /// Left-shifts a value with a fact by a known constant.
+    pub fn shl(&self, fact: &Fact, width: u16, amount: u16) -> Option<Fact> {
+        if amount >= 32 {
+            return None;
+        }
+        let factor: u32 = 1 << amount;
+        self.scale(fact, width, factor)
+    }
+
+    /// Offsets a value with a fact by a known amount.
+    pub fn offset(&self, fact: &Fact, width: u16, offset: i64) -> Option<Fact> {
+        if offset == 0 {
+            return Some(fact.clone());
+        }
+
+        let compute_offset = |base: u64| -> Option<u64> {
+            if offset >= 0 {
+                base.checked_add(u64::try_from(offset).unwrap())
+            } else {
+                base.checked_sub(u64::try_from(-offset).unwrap())
+            }
+        };
+
+        let result = match fact {
+            Fact::Range {
+                bit_width,
+                min,
+                max,
+            } if *bit_width == width => {
+                let min = compute_offset(*min)?;
+                let max = compute_offset(*max)?;
+                Some(Fact::Range {
+                    bit_width: *bit_width,
+                    min,
+                    max,
+                })
+            }
+            Fact::DynamicRange {
+                bit_width,
+                min,
+                max,
+            } if *bit_width == width => {
+                let min = Expr::offset(min, offset)?;
+                let max = Expr::offset(max, offset)?;
+                Some(Fact::DynamicRange {
+                    bit_width: *bit_width,
+                    min,
+                    max,
+                })
+            }
+            Fact::Mem {
+                ty,
+                min_offset: mem_min_offset,
+                max_offset: mem_max_offset,
+                nullable: false,
+            } => {
+                let min_offset = compute_offset(*mem_min_offset)?;
+                let max_offset = compute_offset(*mem_max_offset)?;
+                Some(Fact::Mem {
+                    ty: *ty,
+                    min_offset,
+                    max_offset,
+                    nullable: false,
+                })
+            }
+            Fact::DynamicMem {
+                ty,
+                min,
+                max,
+                nullable: false,
+            } => {
+                let min = Expr::offset(min, offset)?;
+                let max = Expr::offset(max, offset)?;
+                Some(Fact::DynamicMem {
+                    ty: *ty,
+                    min,
+                    max,
+                    nullable: false,
+                })
+            }
+            _ => None,
+        };
+        trace!("offset: {fact:?} + {offset} in width {width} -> {result:?}");
+        result
+    }
+
+    /// Check that accessing memory via a pointer with this fact, with
+    /// a memory access of the given size, is valid.
+    ///
+    /// If valid, returns the memory type and offset into that type
+    /// that this address accesses, if known, or `None` if the range
+    /// doesn't constrain the access to exactly one location.
+    fn check_address(&self, fact: &Fact, size: u32) -> PccResult<Option<(ir::MemoryType, u64)>> {
+        trace!("check_address: fact {:?} size {}", fact, size);
+        match fact {
+            Fact::Mem {
+                ty,
+                min_offset,
+                max_offset,
+                nullable: _,
+            } => {
+                let end_offset: u64 = max_offset
+                    .checked_add(u64::from(size))
+                    .ok_or(PccError::Overflow)?;
+                match &self.function.memory_types[*ty] {
+                    ir::MemoryTypeData::Struct { size, .. }
+                    | ir::MemoryTypeData::Memory { size } => {
+                        ensure!(end_offset <= *size, OutOfBounds)
+                    }
+                    ir::MemoryTypeData::DynamicMemory { .. } => bail!(OutOfBounds),
+                    ir::MemoryTypeData::Empty => bail!(OutOfBounds),
+                }
+                let specific_ty_and_offset = if min_offset == max_offset {
+                    Some((*ty, *min_offset))
+                } else {
+                    None
+                };
+                Ok(specific_ty_and_offset)
+            }
+            Fact::DynamicMem {
+                ty,
+                min: _,
+                max:
+                    Expr {
+                        base: BaseExpr::GlobalValue(max_gv),
+                        offset: max_offset,
+                    },
+                nullable: _,
+            } => match &self.function.memory_types[*ty] {
+                ir::MemoryTypeData::DynamicMemory {
+                    gv,
+                    size: mem_static_size,
+                } if gv == max_gv => {
+                    let end_offset = max_offset
+                        .checked_add(i64::from(size))
+                        .ok_or(PccError::Overflow)?;
+                    let mem_static_size =
+                        i64::try_from(*mem_static_size).map_err(|_| PccError::Overflow)?;
+                    ensure!(end_offset <= mem_static_size, OutOfBounds);
+                    Ok(None)
+                }
+                _ => bail!(OutOfBounds),
+            },
+            _ => bail!(OutOfBounds),
+        }
+    }
+
+    /// Get the access struct field, if any, by a pointer with the
+    /// given fact and an access of the given type.
+    pub fn struct_field<'b>(
+        &'b self,
+        fact: &Fact,
+        access_ty: ir::Type,
+    ) -> PccResult<Option<&'b ir::MemoryTypeField>> {
+        let (ty, offset) = match self.check_address(fact, access_ty.bytes())? {
+            Some((ty, offset)) => (ty, offset),
+            None => return Ok(None),
+        };
+
+        if let ir::MemoryTypeData::Struct { fields, .. } = &self.function.memory_types[ty] {
+            let field = fields
+                .iter()
+                .find(|field| field.offset == offset)
+                .ok_or(PccError::InvalidFieldOffset)?;
+            if field.ty != access_ty {
+                bail!(BadFieldType);
+            }
+            Ok(Some(field))
+        } else {
+            // Access to valid memory, but not a struct: no facts can be attached to the result.
+            Ok(None)
+        }
+    }
+
+    /// Check a load, and determine what fact, if any, the result of the load might have.
+    pub fn load<'b>(&'b self, fact: &Fact, access_ty: ir::Type) -> PccResult<Option<&'b Fact>> {
+        Ok(self
+            .struct_field(fact, access_ty)?
+            .and_then(|field| field.fact()))
+    }
+
+    /// Check a store.
+    pub fn store(
+        &self,
+        fact: &Fact,
+        access_ty: ir::Type,
+        data_fact: Option<&Fact>,
+    ) -> PccResult<()> {
+        if let Some(field) = self.struct_field(fact, access_ty)? {
+            // If it's a read-only field, disallow.
+            if field.readonly {
+                bail!(WriteToReadOnlyField);
+            }
+            // Check that the fact on the stored data subsumes the field's fact.
+            if !self.subsumes_fact_optionals(data_fact, field.fact()) {
+                bail!(InvalidStoredFact);
+            }
+        }
+        Ok(())
+    }
+
+    /// Apply a known inequality to rewrite dynamic bounds using transitivity, if possible.
+    ///
+    /// Given that `lhs >= rhs` (if not `strict`) or `lhs > rhs` (if
+    /// `strict`), update `fact`.
+    pub fn apply_inequality(
+        &self,
+        fact: &Fact,
+        lhs: &Fact,
+        rhs: &Fact,
+        kind: InequalityKind,
+    ) -> Fact {
+        let result = match (
+            lhs.as_symbol(),
+            lhs.as_const(self.pointer_width)
+                .and_then(|k| i64::try_from(k).ok()),
+            rhs.as_symbol(),
+            fact,
+        ) {
+            (
+                Some(lhs),
+                None,
+                Some(rhs),
+                Fact::DynamicMem {
+                    ty,
+                    min,
+                    max,
+                    nullable,
+                },
+            ) if rhs.base == max.base => {
+                let strict_offset = match kind {
+                    InequalityKind::Strict => 1,
+                    InequalityKind::Loose => 0,
+                };
+                if let Some(offset) = max
+                    .offset
+                    .checked_add(lhs.offset)
+                    .and_then(|x| x.checked_sub(rhs.offset))
+                    .and_then(|x| x.checked_sub(strict_offset))
+                {
+                    let new_max = Expr {
+                        base: lhs.base.clone(),
+                        offset,
+                    };
+                    Fact::DynamicMem {
+                        ty: *ty,
+                        min: min.clone(),
+                        max: new_max,
+                        nullable: *nullable,
+                    }
+                } else {
+                    fact.clone()
+                }
+            }
+
+            (
+                None,
+                Some(lhs_const),
+                Some(rhs),
+                Fact::DynamicMem {
+                    ty,
+                    min: _,
+                    max,
+                    nullable,
+                },
+            ) if rhs.base == max.base => {
+                let strict_offset = match kind {
+                    InequalityKind::Strict => 1,
+                    InequalityKind::Loose => 0,
+                };
+                if let Some(offset) = max
+                    .offset
+                    .checked_add(lhs_const)
+                    .and_then(|x| x.checked_sub(rhs.offset))
+                    .and_then(|x| x.checked_sub(strict_offset))
+                {
+                    Fact::Mem {
+                        ty: *ty,
+                        min_offset: 0,
+                        max_offset: u64::try_from(offset).unwrap_or(0),
+                        nullable: *nullable,
+                    }
+                } else {
+                    fact.clone()
+                }
+            }
+
+            _ => fact.clone(),
+        };
+        trace!("apply_inequality({fact:?}, {lhs:?}, {rhs:?}, {kind:?} -> {result:?}");
+        result
+    }
+
+    /// Compute the union of two facts, if possible.
+    pub fn union(&self, lhs: &Fact, rhs: &Fact) -> Option<Fact> {
+        let result = match (lhs, rhs) {
+            (lhs, rhs) if lhs == rhs => Some(lhs.clone()),
+
+            (
+                Fact::DynamicMem {
+                    ty: ty_lhs,
+                    min: min_lhs,
+                    max: max_lhs,
+                    nullable: nullable_lhs,
+                },
+                Fact::DynamicMem {
+                    ty: ty_rhs,
+                    min: min_rhs,
+                    max: max_rhs,
+                    nullable: nullable_rhs,
+                },
+            ) if ty_lhs == ty_rhs => Some(Fact::DynamicMem {
+                ty: *ty_lhs,
+                min: Expr::min(min_lhs, min_rhs),
+                max: Expr::max(max_lhs, max_rhs),
+                nullable: *nullable_lhs || *nullable_rhs,
+            }),
+
+            (
+                Fact::Range {
+                    bit_width: bw_const,
+                    min: 0,
+                    max: 0,
+                },
+                Fact::DynamicMem {
+                    ty,
+                    min,
+                    max,
+                    nullable: _,
+                },
+            )
+            | (
+                Fact::DynamicMem {
+                    ty,
+                    min,
+                    max,
+                    nullable: _,
+                },
+                Fact::Range {
+                    bit_width: bw_const,
+                    min: 0,
+                    max: 0,
+                },
+            ) if *bw_const == self.pointer_width => Some(Fact::DynamicMem {
+                ty: *ty,
+                min: min.clone(),
+                max: max.clone(),
+                nullable: true,
+            }),
+
+            (
+                Fact::Range {
+                    bit_width: bw_const,
+                    min: 0,
+                    max: 0,
+                },
+                Fact::Mem {
+                    ty,
+                    min_offset,
+                    max_offset,
+                    nullable: _,
+                },
+            )
+            | (
+                Fact::Mem {
+                    ty,
+                    min_offset,
+                    max_offset,
+                    nullable: _,
+                },
+                Fact::Range {
+                    bit_width: bw_const,
+                    min: 0,
+                    max: 0,
+                },
+            ) if *bw_const == self.pointer_width => Some(Fact::Mem {
+                ty: *ty,
+                min_offset: *min_offset,
+                max_offset: *max_offset,
+                nullable: true,
+            }),
+
+            _ => None,
+        };
+        trace!("union({lhs:?}, {rhs:?}) -> {result:?}");
+        result
+    }
+}
+
+fn max_value_for_width(bits: u16) -> u64 {
+    assert!(bits <= 64);
+    if bits == 64 {
+        u64::MAX
+    } else {
+        (1u64 << bits) - 1
+    }
+}
+
+/// Top-level entry point after compilation: this checks the facts in
+/// VCode.
+pub fn check_vcode_facts<B: LowerBackend + TargetIsa>(
+    f: &ir::Function,
+    vcode: &mut VCode<B::MInst>,
+    backend: &B,
+) -> PccResult<()> {
+    let ctx = FactContext::new(f, backend.triple().pointer_width().unwrap().bits().into());
+
+    // Check that individual instructions are valid according to input
+    // facts, and support the stated output facts.
+    for block in 0..vcode.num_blocks() {
+        let block = BlockIndex::new(block);
+        let mut flow_state = B::FactFlowState::default();
+        for inst in vcode.block_insns(block).iter() {
+            // Check any output facts on this inst.
+            if let Err(e) = backend.check_fact(&ctx, vcode, inst, &mut flow_state) {
+                log::info!("Error checking instruction: {:?}", vcode[inst]);
+                return Err(e);
+            }
+
+            // If this is a branch, check that all block arguments subsume
+            // the assumed facts on the blockparams of successors.
+            if vcode.is_branch(inst) {
+                for (succ_idx, succ) in vcode.block_succs(block).iter().enumerate() {
+                    for (arg, param) in vcode
+                        .branch_blockparams(block, inst, succ_idx)
+                        .iter()
+                        .zip(vcode.block_params(*succ).iter())
+                    {
+                        let arg_fact = vcode.vreg_fact(*arg);
+                        let param_fact = vcode.vreg_fact(*param);
+                        if !ctx.subsumes_fact_optionals(arg_fact, param_fact) {
+                            return Err(PccError::UnsupportedBlockparam);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    Ok(())
+}
diff --git a/cranelift/codegen/src/ir/progpoint.rs b/cranelift/codegen/src/ir/progpoint.rs
index 780054776714..84d394276f67 100644
--- a/cranelift/codegen/src/ir/progpoint.rs
+++ b/cranelift/codegen/src/ir/progpoint.rs
@@ -23,7 +23,7 @@ impl ProgramPoint {
     pub fn unwrap_inst(self) -> Inst {
         match self {
             Self::Inst(x) => x,
-            Self::Block(x) => panic!("expected inst: {}", x),
+            Self::Block(x) => panic!("expected inst: {x}"),
         }
     }
 }
@@ -43,15 +43,15 @@ impl From<Block> for ProgramPoint {
 impl fmt::Display for ProgramPoint {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            Self::Inst(x) => write!(f, "{}", x),
-            Self::Block(x) => write!(f, "{}", x),
+            Self::Inst(x) => write!(f, "{x}"),
+            Self::Block(x) => write!(f, "{x}"),
         }
     }
 }
 
 impl fmt::Debug for ProgramPoint {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "ProgramPoint({})", self)
+        write!(f, "ProgramPoint({self})")
     }
 }
 
@@ -59,7 +59,6 @@ impl fmt::Debug for ProgramPoint {
 mod tests {
     use super::*;
     use crate::entity::EntityRef;
-    use crate::ir::{Block, Inst};
     use alloc::string::ToString;
 
     #[test]
diff --git a/cranelift/codegen/src/ir/stackslot.rs b/cranelift/codegen/src/ir/stackslot.rs
index dfe0109e90c5..d906fb291324 100644
--- a/cranelift/codegen/src/ir/stackslot.rs
+++ b/cranelift/codegen/src/ir/stackslot.rs
@@ -70,32 +70,38 @@ pub struct StackSlotData {
 
     /// Size of stack slot in bytes.
     pub size: StackSize,
+
+    /// Alignment of stack slot as a power-of-two exponent (log2
+    /// value). The stack slot will be at least this aligned; it may
+    /// be aligned according to other considerations, such as minimum
+    /// stack slot size or machine word size, as well.
+    pub align_shift: u8,
 }
 
 impl StackSlotData {
-    /// Create a stack slot with the specified byte size.
-    pub fn new(kind: StackSlotKind, size: StackSize) -> Self {
-        Self { kind, size }
-    }
-
-    /// Get the alignment in bytes of this stack slot given the stack pointer alignment.
-    pub fn alignment(&self, max_align: StackSize) -> StackSize {
-        debug_assert!(max_align.is_power_of_two());
-        if self.kind == StackSlotKind::ExplicitDynamicSlot {
-            max_align
-        } else {
-            // We want to find the largest power of two that divides both `self.size` and `max_align`.
-            // That is the same as isolating the rightmost bit in `x`.
-            let x = self.size | max_align;
-            // C.f. Hacker's delight.
-            x & x.wrapping_neg()
+    /// Create a stack slot with the specified byte size and alignment.
+    pub fn new(kind: StackSlotKind, size: StackSize, align_shift: u8) -> Self {
+        Self {
+            kind,
+            size,
+            align_shift,
         }
     }
 }
 
 impl fmt::Display for StackSlotData {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{} {}", self.kind, self.size)
+        if self.align_shift != 0 {
+            write!(
+                f,
+                "{} {}, align = {}",
+                self.kind,
+                self.size,
+                1u32 << self.align_shift
+            )
+        } else {
+            write!(f, "{} {}", self.kind, self.size)
+        }
     }
 }
 
@@ -146,8 +152,10 @@ mod tests {
     fn stack_slot() {
         let mut func = Function::new();
 
-        let ss0 = func.create_sized_stack_slot(StackSlotData::new(StackSlotKind::ExplicitSlot, 4));
-        let ss1 = func.create_sized_stack_slot(StackSlotData::new(StackSlotKind::ExplicitSlot, 8));
+        let ss0 =
+            func.create_sized_stack_slot(StackSlotData::new(StackSlotKind::ExplicitSlot, 4, 0));
+        let ss1 =
+            func.create_sized_stack_slot(StackSlotData::new(StackSlotKind::ExplicitSlot, 8, 0));
         assert_eq!(ss0.to_string(), "ss0");
         assert_eq!(ss1.to_string(), "ss1");
 
@@ -197,20 +205,4 @@ mod tests {
             "explicit_dynamic_slot dt1"
         );
     }
-
-    #[test]
-    fn alignment() {
-        let slot = StackSlotData::new(StackSlotKind::ExplicitSlot, 8);
-
-        assert_eq!(slot.alignment(4), 4);
-        assert_eq!(slot.alignment(8), 8);
-        assert_eq!(slot.alignment(16), 8);
-
-        let slot2 = StackSlotData::new(StackSlotKind::ExplicitSlot, 24);
-
-        assert_eq!(slot2.alignment(4), 4);
-        assert_eq!(slot2.alignment(8), 8);
-        assert_eq!(slot2.alignment(16), 8);
-        assert_eq!(slot2.alignment(32), 8);
-    }
 }
diff --git a/cranelift/codegen/src/ir/table.rs b/cranelift/codegen/src/ir/table.rs
deleted file mode 100644
index 6c6b32a147b9..000000000000
--- a/cranelift/codegen/src/ir/table.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-//! Tables.
-
-use crate::ir::immediates::Uimm64;
-use crate::ir::{GlobalValue, Type};
-use core::fmt;
-
-#[cfg(feature = "enable-serde")]
-use serde_derive::{Deserialize, Serialize};
-
-/// Information about a table declaration.
-#[derive(Clone, PartialEq, Hash)]
-#[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-pub struct TableData {
-    /// Global value giving the address of the start of the table.
-    pub base_gv: GlobalValue,
-
-    /// Guaranteed minimum table size in elements. Table accesses before `min_size` don't need
-    /// bounds checking.
-    pub min_size: Uimm64,
-
-    /// Global value giving the current bound of the table, in elements.
-    pub bound_gv: GlobalValue,
-
-    /// The size of a table element, in bytes.
-    pub element_size: Uimm64,
-
-    /// The index type for the table.
-    pub index_type: Type,
-}
-
-impl fmt::Display for TableData {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str("dynamic")?;
-        write!(
-            f,
-            " {}, min {}, bound {}, element_size {}, index_type {}",
-            self.base_gv, self.min_size, self.bound_gv, self.element_size, self.index_type
-        )
-    }
-}
diff --git a/cranelift/codegen/src/ir/trapcode.rs b/cranelift/codegen/src/ir/trapcode.rs
index 339c331ea529..e33a655456a3 100644
--- a/cranelift/codegen/src/ir/trapcode.rs
+++ b/cranelift/codegen/src/ir/trapcode.rs
@@ -46,7 +46,6 @@ pub enum TrapCode {
     UnreachableCodeReached,
 
     /// Execution has potentially run too long and may be interrupted.
-    /// This trap is resumable.
     Interrupt,
 
     /// A user-defined trap code.
@@ -54,6 +53,9 @@ pub enum TrapCode {
 
     /// A null reference was encountered which was required to be non-null.
     NullReference,
+
+    /// A null `i31ref` was encountered which was required to be non-null.
+    NullI31Ref,
 }
 
 impl TrapCode {
@@ -91,8 +93,9 @@ impl Display for TrapCode {
             BadConversionToInteger => "bad_toint",
             UnreachableCodeReached => "unreachable",
             Interrupt => "interrupt",
-            User(x) => return write!(f, "user{}", x),
+            User(x) => return write!(f, "user{x}"),
             NullReference => "null_reference",
+            NullI31Ref => "null_i31ref",
         };
         f.write_str(identifier)
     }
@@ -116,6 +119,7 @@ impl FromStr for TrapCode {
             "unreachable" => Ok(UnreachableCodeReached),
             "interrupt" => Ok(Interrupt),
             "null_reference" => Ok(NullReference),
+            "null_i31ref" => Ok(NullI31Ref),
             _ if s.starts_with("user") => s[4..].parse().map(User).map_err(|_| ()),
             _ => Err(()),
         }
diff --git a/cranelift/codegen/src/ir/types.rs b/cranelift/codegen/src/ir/types.rs
index b1a58c5a2091..bc7704cf0662 100644
--- a/cranelift/codegen/src/ir/types.rs
+++ b/cranelift/codegen/src/ir/types.rs
@@ -1,6 +1,5 @@
 //! Common types for the Cranelift code generator.
 
-use core::default::Default;
 use core::fmt::{self, Debug, Display, Formatter};
 use cranelift_codegen_shared::constants;
 #[cfg(feature = "enable-serde")]
@@ -15,7 +14,7 @@ use target_lexicon::{PointerWidth, Triple};
 ///
 /// Basic integer types: `I8`, `I16`, `I32`, `I64`, and `I128`. These types are sign-agnostic.
 ///
-/// Basic floating point types: `F32` and `F64`. IEEE single and double precision.
+/// Basic floating point types: `F16`, `F32`, `F64`, and `F128`. IEEE half, single, double, and quadruple precision.
 ///
 /// SIMD vector types have power-of-two lanes, up to 256. Lanes can be any int/float type.
 ///
@@ -57,10 +56,10 @@ impl Type {
     pub fn log2_lane_bits(self) -> u32 {
         match self.lane_type() {
             I8 => 3,
-            I16 => 4,
-            I32 | F32 | R32 => 5,
-            I64 | F64 | R64 => 6,
-            I128 => 7,
+            I16 | F16 => 4,
+            I32 | F32 => 5,
+            I64 | F64 => 6,
+            I128 | F128 => 7,
             _ => 0,
         }
     }
@@ -69,10 +68,10 @@ impl Type {
     pub fn lane_bits(self) -> u32 {
         match self.lane_type() {
             I8 => 8,
-            I16 => 16,
-            I32 | F32 | R32 => 32,
-            I64 | F64 | R64 => 64,
-            I128 => 128,
+            I16 | F16 => 16,
+            I32 | F32 => 32,
+            I64 | F64 => 64,
+            I128 | F128 => 128,
             _ => 0,
         }
     }
@@ -137,11 +136,10 @@ impl Type {
         // Replace the low 4 bits with the boolean version, preserve the high 4 bits.
         self.replace_lanes(match self.lane_type() {
             I8 => I8,
-            I16 => I16,
+            I16 | F16 => I16,
             I32 | F32 => I32,
             I64 | F64 => I64,
-            R32 | R64 => panic!("Reference types are not truthy"),
-            I128 => I128,
+            I128 | F128 => I128,
             _ => I8,
         })
     }
@@ -159,15 +157,13 @@ impl Type {
 
     /// Get a type with the same number of lanes as this type, but with the lanes replaced by
     /// integers of the same size.
-    ///
-    /// Scalar types follow this same rule, but `b1` is converted into `i8`
     pub fn as_int(self) -> Self {
         self.replace_lanes(match self.lane_type() {
             I8 => I8,
-            I16 => I16,
+            I16 | F16 => I16,
             I32 | F32 => I32,
             I64 | F64 => I64,
-            I128 => I128,
+            I128 | F128 => I128,
             _ => unimplemented!(),
         })
     }
@@ -180,7 +176,9 @@ impl Type {
             I32 => I16,
             I64 => I32,
             I128 => I64,
+            F32 => F16,
             F64 => F32,
+            F128 => F64,
             _ => return None,
         }))
     }
@@ -193,7 +191,9 @@ impl Type {
             I16 => I32,
             I32 => I64,
             I64 => I128,
+            F16 => F32,
             F32 => F64,
+            F64 => F128,
             _ => return None,
         }))
     }
@@ -238,15 +238,7 @@ impl Type {
     /// Is this a scalar floating point type?
     pub fn is_float(self) -> bool {
         match self {
-            F32 | F64 => true,
-            _ => false,
-        }
-    }
-
-    /// Is this a ref type?
-    pub fn is_ref(self) -> bool {
-        match self {
-            R32 | R64 => true,
+            F16 | F32 | F64 | F128 => true,
             _ => false,
         }
     }
@@ -436,8 +428,6 @@ impl Display for Type {
             write!(f, "{}x{}", self.lane_type(), self.lane_count())
         } else if self.is_dynamic_vector() {
             write!(f, "{:?}x{}xN", self.lane_type(), self.min_lane_count())
-        } else if self.is_ref() {
-            write!(f, "r{}", self.lane_bits())
         } else {
             match *self {
                 INVALID => panic!("INVALID encountered"),
@@ -457,8 +447,6 @@ impl Debug for Type {
             write!(f, "{:?}X{}", self.lane_type(), self.lane_count())
         } else if self.is_dynamic_vector() {
             write!(f, "{:?}X{}XN", self.lane_type(), self.min_lane_count())
-        } else if self.is_ref() {
-            write!(f, "types::R{}", self.lane_bits())
         } else {
             match *self {
                 INVALID => write!(f, "types::INVALID"),
@@ -489,11 +477,11 @@ mod tests {
         assert_eq!(I64, I64.lane_type());
         assert_eq!(I128, I128.lane_type());
         assert_eq!(F32, F32.lane_type());
+        assert_eq!(F16, F16.lane_type());
         assert_eq!(F64, F64.lane_type());
+        assert_eq!(F128, F128.lane_type());
         assert_eq!(I32, I32X4.lane_type());
         assert_eq!(F64, F64X2.lane_type());
-        assert_eq!(R32, R32.lane_type());
-        assert_eq!(R64, R64.lane_type());
 
         assert_eq!(INVALID.lane_bits(), 0);
         assert_eq!(I8.lane_bits(), 8);
@@ -501,10 +489,10 @@ mod tests {
         assert_eq!(I32.lane_bits(), 32);
         assert_eq!(I64.lane_bits(), 64);
         assert_eq!(I128.lane_bits(), 128);
+        assert_eq!(F16.lane_bits(), 16);
         assert_eq!(F32.lane_bits(), 32);
         assert_eq!(F64.lane_bits(), 64);
-        assert_eq!(R32.lane_bits(), 32);
-        assert_eq!(R64.lane_bits(), 64);
+        assert_eq!(F128.lane_bits(), 128);
     }
 
     #[test]
@@ -517,8 +505,10 @@ mod tests {
         assert_eq!(I32X4.half_width(), Some(I16X4));
         assert_eq!(I64.half_width(), Some(I32));
         assert_eq!(I128.half_width(), Some(I64));
-        assert_eq!(F32.half_width(), None);
+        assert_eq!(F16.half_width(), None);
+        assert_eq!(F32.half_width(), Some(F16));
         assert_eq!(F64.half_width(), Some(F32));
+        assert_eq!(F128.half_width(), Some(F64));
 
         assert_eq!(INVALID.double_width(), None);
         assert_eq!(I8.double_width(), Some(I16));
@@ -527,8 +517,10 @@ mod tests {
         assert_eq!(I32X4.double_width(), Some(I64X4));
         assert_eq!(I64.double_width(), Some(I128));
         assert_eq!(I128.double_width(), None);
+        assert_eq!(F16.double_width(), Some(F32));
         assert_eq!(F32.double_width(), Some(F64));
-        assert_eq!(F64.double_width(), None);
+        assert_eq!(F64.double_width(), Some(F128));
+        assert_eq!(F128.double_width(), None);
     }
 
     #[test]
@@ -561,14 +553,18 @@ mod tests {
         // Conversions to and from vectors.
         assert_eq!(I8.by(16).unwrap().vector_to_dynamic(), Some(I8X16XN));
         assert_eq!(I16.by(8).unwrap().vector_to_dynamic(), Some(I16X8XN));
+        assert_eq!(F16.by(8).unwrap().vector_to_dynamic(), Some(F16X8XN));
         assert_eq!(I32.by(4).unwrap().vector_to_dynamic(), Some(I32X4XN));
         assert_eq!(F32.by(4).unwrap().vector_to_dynamic(), Some(F32X4XN));
         assert_eq!(F64.by(2).unwrap().vector_to_dynamic(), Some(F64X2XN));
         assert_eq!(I128.by(2).unwrap().vector_to_dynamic(), Some(I128X2XN));
+        assert_eq!(F128.by(2).unwrap().vector_to_dynamic(), Some(F128X2XN));
 
         assert_eq!(I128X2XN.dynamic_to_vector(), Some(I128X2));
+        assert_eq!(F16X4XN.dynamic_to_vector(), Some(F16X4));
         assert_eq!(F32X4XN.dynamic_to_vector(), Some(F32X4));
         assert_eq!(F64X4XN.dynamic_to_vector(), Some(F64X4));
+        assert_eq!(F128X4XN.dynamic_to_vector(), Some(F128X4));
         assert_eq!(I32X2XN.dynamic_to_vector(), Some(I32X2));
         assert_eq!(I32X8XN.dynamic_to_vector(), Some(I32X8));
         assert_eq!(I16X16XN.dynamic_to_vector(), Some(I16X16));
@@ -589,8 +585,6 @@ mod tests {
         assert_eq!(I128.to_string(), "i128");
         assert_eq!(F32.to_string(), "f32");
         assert_eq!(F64.to_string(), "f64");
-        assert_eq!(R32.to_string(), "r32");
-        assert_eq!(R64.to_string(), "r64");
     }
 
     #[test]
diff --git a/cranelift/codegen/src/ir/user_stack_maps.rs b/cranelift/codegen/src/ir/user_stack_maps.rs
new file mode 100644
index 000000000000..6ad9b697cd02
--- /dev/null
+++ b/cranelift/codegen/src/ir/user_stack_maps.rs
@@ -0,0 +1,199 @@
+//! User-defined stack maps.
+//!
+//! This module provides types allowing users to define stack maps and associate
+//! them with safepoints.
+//!
+//! A **safepoint** is a program point (i.e. CLIF instruction) where it must be
+//! safe to run GC. Currently all non-tail call instructions are considered
+//! safepoints. (This does *not* allow, for example, skipping safepoints for
+//! calls that are statically known not to trigger collections, or to have a
+//! safepoint on a volatile load to a page that gets protected when it is time
+//! to GC, triggering a fault that pauses the mutator and lets the collector do
+//! its work before resuming the mutator. We can lift this restriction in the
+//! future, if necessary.)
+//!
+//! A **stack map** is a description of where to find all the GC-managed values
+//! that are live at a particular safepoint. Stack maps let the collector find
+//! on-stack roots. Each stack map is logically a set of offsets into the stack
+//! frame and the type of value at that associated offset. However, because the
+//! stack layout isn't defined until much later in the compiler's pipeline, each
+//! stack map entry instead includes both an `ir::StackSlot` and an offset
+//! within that slot.
+//!
+//! These stack maps are **user-defined** in that it is the CLIF producer's
+//! responsibility to identify and spill the live GC-managed values and attach
+//! the associated stack map entries to each safepoint themselves (see
+//! `cranelift_frontend::Function::declare_needs_stack_map` and
+//! `cranelift_codegen::ir::DataFlowGraph::append_user_stack_map_entry`). Cranelift
+//! will not insert spills and record these stack map entries automatically.
+//!
+//! Logically, a set of stack maps for a function record a table of the form:
+//!
+//! ```text
+//! +---------------------+-------------------------------------------+
+//! | Instruction Pointer | SP-Relative Offsets of Live GC References |
+//! +---------------------+-------------------------------------------+
+//! | 0x12345678          | 2, 6, 12                                  |
+//! | 0x1234abcd          | 2, 6                                      |
+//! | ...                 | ...                                       |
+//! +---------------------+-------------------------------------------+
+//! ```
+//!
+//! Where "instruction pointer" is an instruction pointer within the function,
+//! and "offsets of live GC references" contains the offsets (in units of words)
+//! from the frame's stack pointer where live GC references are stored on the
+//! stack. Instruction pointers within the function that do not have an entry in
+//! this table are not GC safepoints.
+//!
+//! Because
+//!
+//! * offsets of live GC references are relative from the stack pointer, and
+//! * stack frames grow down from higher addresses to lower addresses,
+//!
+//! to get a pointer to a live reference at offset `x` within a stack frame, you
+//! add `x` to the frame's stack pointer.
+//!
+//! For example, to calculate the pointer to the live GC reference inside "frame
+//! 1" below, you would do `frame_1_sp + x`:
+//!
+//! ```text
+//!           Stack
+//!         +-------------------+
+//!         | Frame 0           |
+//!         |                   |
+//!    |    |                   |
+//!    |    +-------------------+ <--- Frame 0's SP
+//!    |    | Frame 1           |
+//!  Grows  |                   |
+//!  down   |                   |
+//!    |    | Live GC reference | --+--
+//!    |    |                   |   |
+//!    |    |                   |   |
+//!    V    |                   |   x = offset of live GC reference
+//!         |                   |   |
+//!         |                   |   |
+//!         +-------------------+ --+--  <--- Frame 1's SP
+//!         | Frame 2           |
+//!         | ...               |
+//! ```
+//!
+//! An individual `UserStackMap` is associated with just one instruction pointer
+//! within the function, contains the size of the stack frame, and represents
+//! the stack frame as a bitmap. There is one bit per word in the stack frame,
+//! and if the bit is set, then the word contains a live GC reference.
+//!
+//! Note that a caller's outgoing argument stack slots (if any) and callee's
+//! incoming argument stack slots (if any) overlap, so we must choose which
+//! function's stack maps record live GC references in these slots. We record
+//! the incoming arguments in the callee's stack map. This choice plays nice
+//! with tail calls, where by the time we transfer control to the callee, the
+//! caller no longer exists.
+
+use crate::ir;
+use cranelift_bitset::CompoundBitSet;
+use cranelift_entity::PrimaryMap;
+use smallvec::SmallVec;
+
+pub(crate) type UserStackMapEntryVec = SmallVec<[UserStackMapEntry; 4]>;
+
+/// A stack map entry describes a single GC-managed value and its location on
+/// the stack.
+///
+/// A stack map entry is associated with a particular instruction, and that
+/// instruction must be a safepoint. The GC-managed value must be stored in the
+/// described location across this entry's instruction.
+#[derive(Clone, Debug, PartialEq, Hash)]
+#[cfg_attr(
+    feature = "enable-serde",
+    derive(serde_derive::Serialize, serde_derive::Deserialize)
+)]
+pub struct UserStackMapEntry {
+    /// The type of the value stored in this stack map entry.
+    pub ty: ir::Type,
+
+    /// The stack slot that this stack map entry is within.
+    pub slot: ir::StackSlot,
+
+    /// The offset within the stack slot where this entry's value can be found.
+    pub offset: u32,
+}
+
+/// A compiled stack map, describing the location of many GC-managed values.
+///
+/// A stack map is associated with a particular instruction, and that
+/// instruction is a safepoint.
+#[derive(Clone, Debug, PartialEq)]
+#[cfg_attr(
+    feature = "enable-serde",
+    derive(serde_derive::Deserialize, serde_derive::Serialize)
+)]
+pub struct UserStackMap {
+    // Offsets into the frame's sized stack slots that are GC references, by type.
+    by_type: SmallVec<[(ir::Type, CompoundBitSet); 1]>,
+
+    // The offset of the sized stack slots, from SP, for this stack map's
+    // associated PC.
+    //
+    // This is initially `None` upon construction during lowering, but filled in
+    // after regalloc during emission when we have the precise frame layout.
+    sp_to_sized_stack_slots: Option<u32>,
+}
+
+impl UserStackMap {
+    /// Coalesce the given entries into a new `UserStackMap`.
+    pub(crate) fn new(
+        entries: &[UserStackMapEntry],
+        stack_slot_offsets: &PrimaryMap<ir::StackSlot, u32>,
+    ) -> Self {
+        let mut by_type = SmallVec::<[(ir::Type, CompoundBitSet); 1]>::default();
+
+        for entry in entries {
+            let offset = stack_slot_offsets[entry.slot] + entry.offset;
+            let offset = usize::try_from(offset).unwrap();
+
+            // Don't bother trying to avoid an `O(n)` search here: `n` is
+            // basically always one in practice; even if it isn't, there aren't
+            // that many different CLIF types.
+            let index = by_type
+                .iter()
+                .position(|(ty, _)| *ty == entry.ty)
+                .unwrap_or_else(|| {
+                    by_type.push((entry.ty, CompoundBitSet::with_capacity(offset + 1)));
+                    by_type.len() - 1
+                });
+
+            by_type[index].1.insert(offset);
+        }
+
+        UserStackMap {
+            by_type,
+            sp_to_sized_stack_slots: None,
+        }
+    }
+
+    /// Finalize this stack map by filling in the SP-to-stack-slots offset.
+    pub(crate) fn finalize(&mut self, sp_to_sized_stack_slots: u32) {
+        debug_assert!(self.sp_to_sized_stack_slots.is_none());
+        self.sp_to_sized_stack_slots = Some(sp_to_sized_stack_slots);
+    }
+
+    /// Iterate over the entries in this stack map.
+    ///
+    /// Yields pairs of the type of GC reference that is at the offset, and the
+    /// offset from SP. If a pair `(i64, 0x42)` is yielded, for example, then
+    /// when execution is at this stack map's associated PC, `SP + 0x42` is a
+    /// pointer to an `i64`, and that `i64` is a live GC reference.
+    pub fn entries(&self) -> impl Iterator<Item = (ir::Type, u32)> + '_ {
+        let sp_to_sized_stack_slots = self.sp_to_sized_stack_slots.expect(
+            "`sp_to_sized_stack_slots` should have been filled in before this stack map was used",
+        );
+        self.by_type.iter().flat_map(move |(ty, bitset)| {
+            bitset.iter().map(move |slot_offset| {
+                (
+                    *ty,
+                    sp_to_sized_stack_slots + u32::try_from(slot_offset).unwrap(),
+                )
+            })
+        })
+    }
+}
diff --git a/cranelift/codegen/src/isa/aarch64/abi.rs b/cranelift/codegen/src/isa/aarch64/abi.rs
index bcf865d2603f..59a493ea2b41 100644
--- a/cranelift/codegen/src/isa/aarch64/abi.rs
+++ b/cranelift/codegen/src/isa/aarch64/abi.rs
@@ -4,17 +4,16 @@ use crate::ir;
 use crate::ir::types;
 use crate::ir::types::*;
 use crate::ir::MemFlags;
-use crate::ir::Opcode;
 use crate::ir::{dynamic_to_fixed, ExternalName, LibCall, Signature};
 use crate::isa;
-use crate::isa::aarch64::{inst::EmitState, inst::*, settings as aarch64_settings};
+use crate::isa::aarch64::{inst::*, settings as aarch64_settings};
 use crate::isa::unwind::UnwindInst;
 use crate::machinst::*;
 use crate::settings;
 use crate::{CodegenError, CodegenResult};
 use alloc::boxed::Box;
 use alloc::vec::Vec;
-use regalloc2::{MachineEnv, PReg, PRegSet, VReg};
+use regalloc2::{MachineEnv, PReg, PRegSet};
 use smallvec::{smallvec, SmallVec};
 use std::sync::OnceLock;
 
@@ -35,9 +34,11 @@ static STACK_ARG_RET_SIZE_LIMIT: u32 = 128 * 1024 * 1024;
 impl Into<AMode> for StackAMode {
     fn into(self) -> AMode {
         match self {
-            StackAMode::FPOffset(off, ty) => AMode::FPOffset { off, ty },
-            StackAMode::NominalSPOffset(off, ty) => AMode::NominalSPOffset { off, ty },
-            StackAMode::SPOffset(off, ty) => AMode::SPOffset { off, ty },
+            StackAMode::IncomingArg(off, stack_args_size) => AMode::IncomingArg {
+                off: i64::from(stack_args_size) - off,
+            },
+            StackAMode::Slot(off) => AMode::SlotOffset { off },
+            StackAMode::OutgoingArg(off) => AMode::SPOffset { off },
         }
     }
 }
@@ -99,21 +100,14 @@ impl ABIMachineSpec for AArch64MachineDeps {
         16
     }
 
-    fn compute_arg_locs<'a, I>(
+    fn compute_arg_locs(
         call_conv: isa::CallConv,
-        _flags: &settings::Flags,
-        params: I,
+        flags: &settings::Flags,
+        params: &[ir::AbiParam],
         args_or_rets: ArgsOrRets,
         add_ret_area_ptr: bool,
-        mut args: ArgsAccumulator<'_>,
-    ) -> CodegenResult<(u32, Option<usize>)>
-    where
-        I: IntoIterator<Item = &'a ir::AbiParam>,
-    {
-        if call_conv == isa::CallConv::Tail {
-            return compute_arg_locs_tail(params, add_ret_area_ptr, args);
-        }
-
+        mut args: ArgsAccumulator,
+    ) -> CodegenResult<(u32, Option<usize>)> {
         let is_apple_cc = call_conv.extends_apple_aarch64();
 
         // See AArch64 ABI (https://github.com/ARM-software/abi-aa/blob/2021Q1/aapcs64/aapcs64.rst#64parameter-passing), sections 6.4.
@@ -130,7 +124,20 @@ impl ABIMachineSpec for AArch64MachineDeps {
         // break our other invariants that the stack is always allocated in
         // 16-bytes chunks.
 
-        let mut next_xreg = 0;
+        let mut next_xreg = if call_conv == isa::CallConv::Tail {
+            // We reserve `x0` for the return area pointer. For simplicity, we
+            // reserve it even when there is no return area pointer needed. This
+            // also means that identity functions don't have to shuffle arguments to
+            // different return registers because we shifted all argument register
+            // numbers down by one to make space for the return area pointer.
+            //
+            // Also, we cannot use all allocatable GPRs as arguments because we need
+            // at least one allocatable register for holding the callee address in
+            // indirect calls. So skip `x1` also, reserving it for that role.
+            2
+        } else {
+            0
+        };
         let mut next_vreg = 0;
         let mut next_stack: u32 = 0;
 
@@ -148,14 +155,27 @@ impl ABIMachineSpec for AArch64MachineDeps {
         };
 
         for param in params {
-            assert!(
-                legal_type_for_machine(param.value_type),
-                "Invalid type for AArch64: {:?}",
-                param.value_type
-            );
+            if is_apple_cc && param.value_type == types::F128 && !flags.enable_llvm_abi_extensions()
+            {
+                panic!(
+                    "f128 args/return values not supported for apple_aarch64 unless LLVM ABI extensions are enabled"
+                );
+            }
 
             let (rcs, reg_types) = Inst::rc_for_type(param.value_type)?;
 
+            if matches!(
+                param.purpose,
+                ir::ArgumentPurpose::StructArgument(_) | ir::ArgumentPurpose::StructReturn
+            ) {
+                assert!(
+                    call_conv != isa::CallConv::Tail,
+                    "support for {:?} parameters is not implemented for the `tail` calling \
+                    convention yet",
+                    param.purpose,
+                );
+            }
+
             if let ir::ArgumentPurpose::StructArgument(size) = param.purpose {
                 assert_eq!(args_or_rets, ArgsOrRets::Args);
                 let offset = next_stack as i64;
@@ -193,7 +213,7 @@ impl ABIMachineSpec for AArch64MachineDeps {
             //
             // See AArch64 ABI (https://github.com/ARM-software/abi-aa/blob/2021Q1/aapcs64/aapcs64.rst#642parameter-passing-rules), (Section 6.4.2 Stage C).
             //
-            // For arguments with alignment of 16 we round up the the register number
+            // For arguments with alignment of 16 we round up the register number
             // to the next even value. So we can never allocate for example an i128
             // to X1 and X2, we have to skip one register and do X2, X3
             // (Stage C.8)
@@ -336,21 +356,30 @@ impl ABIMachineSpec for AArch64MachineDeps {
 
         let extra_arg = if add_ret_area_ptr {
             debug_assert!(args_or_rets == ArgsOrRets::Args);
-            if next_xreg < max_per_class_reg_vals && remaining_reg_vals > 0 {
+            if call_conv == isa::CallConv::Tail {
                 args.push_non_formal(ABIArg::reg(
-                    xreg(next_xreg).to_real_reg().unwrap(),
+                    xreg_preg(0).into(),
                     I64,
                     ir::ArgumentExtension::None,
                     ir::ArgumentPurpose::Normal,
                 ));
             } else {
-                args.push_non_formal(ABIArg::stack(
-                    next_stack as i64,
-                    I64,
-                    ir::ArgumentExtension::None,
-                    ir::ArgumentPurpose::Normal,
-                ));
-                next_stack += 8;
+                if next_xreg < max_per_class_reg_vals && remaining_reg_vals > 0 {
+                    args.push_non_formal(ABIArg::reg(
+                        xreg(next_xreg).to_real_reg().unwrap(),
+                        I64,
+                        ir::ArgumentExtension::None,
+                        ir::ArgumentPurpose::Normal,
+                    ));
+                } else {
+                    args.push_non_formal(ABIArg::stack(
+                        next_stack as i64,
+                        I64,
+                        ir::ArgumentExtension::None,
+                        ir::ArgumentPurpose::Normal,
+                    ));
+                    next_stack += 8;
+                }
             }
             Some(args.args().len() - 1)
         } else {
@@ -368,10 +397,6 @@ impl ABIMachineSpec for AArch64MachineDeps {
         Ok((next_stack, extra_arg))
     }
 
-    fn fp_to_arg_offset(_call_conv: isa::CallConv, _flags: &settings::Flags) -> i64 {
-        16 // frame pointer + return address.
-    }
-
     fn gen_load_stack(mem: StackAMode, into_reg: Writable<Reg>, ty: Type) -> Inst {
         Inst::gen_load(into_reg, mem.into(), ty, MemFlags::trusted())
     }
@@ -463,7 +488,7 @@ impl ABIMachineSpec for AArch64MachineDeps {
         insts
     }
 
-    fn gen_get_stack_addr(mem: StackAMode, into_reg: Writable<Reg>, _ty: Type) -> Inst {
+    fn gen_get_stack_addr(mem: StackAMode, into_reg: Writable<Reg>) -> Inst {
         // FIXME: Do something different for dynamic types?
         let mem = mem.into();
         Inst::LoadAddr { rd: into_reg, mem }
@@ -477,7 +502,6 @@ impl ABIMachineSpec for AArch64MachineDeps {
         let mem = AMode::RegOffset {
             rn: base,
             off: offset as i64,
-            ty,
         };
         Inst::gen_load(into_reg, mem, ty, MemFlags::trusted())
     }
@@ -486,7 +510,6 @@ impl ABIMachineSpec for AArch64MachineDeps {
         let mem = AMode::RegOffset {
             rn: base,
             off: offset as i64,
-            ty,
         };
         Inst::gen_store(mem, from_reg, ty, MemFlags::trusted())
     }
@@ -533,12 +556,6 @@ impl ABIMachineSpec for AArch64MachineDeps {
         ret
     }
 
-    fn gen_nominal_sp_adj(offset: i32) -> Inst {
-        Inst::VirtualSPOffsetAdj {
-            offset: offset as i64,
-        }
-    }
-
     fn gen_prologue_frame_setup(
         call_conv: isa::CallConv,
         flags: &settings::Flags,
@@ -616,7 +633,7 @@ impl ABIMachineSpec for AArch64MachineDeps {
     fn gen_epilogue_frame_restore(
         call_conv: isa::CallConv,
         _flags: &settings::Flags,
-        isa_flags: &aarch64_settings::Flags,
+        _isa_flags: &aarch64_settings::Flags,
         frame_layout: &FrameLayout,
     ) -> SmallInstVec<Inst> {
         let setup_frame = frame_layout.setup_area_size > 0;
@@ -638,24 +655,33 @@ impl ABIMachineSpec for AArch64MachineDeps {
             });
         }
 
-        if call_conv == isa::CallConv::Tail && frame_layout.stack_args_size > 0 {
+        if call_conv == isa::CallConv::Tail && frame_layout.tail_args_size > 0 {
             insts.extend(Self::gen_sp_reg_adjust(
-                frame_layout.stack_args_size.try_into().unwrap(),
+                frame_layout.tail_args_size.try_into().unwrap(),
             ));
         }
+
+        insts
+    }
+
+    fn gen_return(
+        call_conv: isa::CallConv,
+        isa_flags: &aarch64_settings::Flags,
+        frame_layout: &FrameLayout,
+    ) -> SmallInstVec<Inst> {
+        let setup_frame = frame_layout.setup_area_size > 0;
+
         match select_api_key(isa_flags, call_conv, setup_frame) {
             Some(key) => {
-                insts.push(Inst::AuthenticatedRet {
+                smallvec![Inst::AuthenticatedRet {
                     key,
                     is_hint: !isa_flags.has_pauth(),
-                });
+                }]
             }
             None => {
-                insts.push(Inst::Ret {});
+                smallvec![Inst::Ret {}]
             }
         }
-
-        insts
     }
 
     fn gen_probestack(_insts: &mut SmallInstVec<Self::I>, _: u32) {
@@ -677,43 +703,9 @@ impl ABIMachineSpec for AArch64MachineDeps {
 
         let probe_count = align_to(frame_size, guard_size) / guard_size;
         if probe_count <= PROBE_MAX_UNROLL {
-            // When manually unrolling stick an instruction that stores 0 at a
-            // constant offset relative to the stack pointer. This will
-            // turn into something like `movn tmp, #n ; stur xzr [sp, tmp]`.
-            //
-            // Note that this may actually store beyond the stack size for the
-            // last item but that's ok since it's unused stack space and if
-            // that faults accidentally we're so close to faulting it shouldn't
-            // make too much difference to fault there.
-            insts.reserve(probe_count as usize);
-            for i in 0..probe_count {
-                let offset = (guard_size * (i + 1)) as i64;
-                insts.push(Self::gen_store_stack(
-                    StackAMode::SPOffset(-offset, I8),
-                    zero_reg(),
-                    I32,
-                ));
-            }
+            Self::gen_probestack_unroll(insts, guard_size, probe_count)
         } else {
-            // The non-unrolled version uses two temporary registers. The
-            // `start` contains the current offset from sp and counts downwards
-            // during the loop by increments of `guard_size`. The `end` is
-            // the size of the frame and where we stop.
-            //
-            // Note that this emission is all post-regalloc so it should be ok
-            // to use the temporary registers here as input/output as the loop
-            // itself is not allowed to use the registers.
-            let start = writable_spilltmp_reg();
-            let end = writable_tmp2_reg();
-            // `gen_inline_probestack` is called after regalloc2, so it's acceptable to reuse
-            // `start` and `end` as temporaries in load_constant.
-            insts.extend(Inst::load_constant(start, 0, &mut |_| start));
-            insts.extend(Inst::load_constant(end, frame_size.into(), &mut |_| end));
-            insts.push(Inst::StackProbeLoop {
-                start,
-                end: end.to_reg(),
-                step: Imm12::maybe_from_u64(guard_size.into()).unwrap(),
-            });
+            Self::gen_probestack_loop(insts, frame_size, guard_size)
         }
     }
 
@@ -722,20 +714,50 @@ impl ABIMachineSpec for AArch64MachineDeps {
         flags: &settings::Flags,
         frame_layout: &FrameLayout,
     ) -> SmallVec<[Inst; 16]> {
-        let mut clobbered_int = vec![];
-        let mut clobbered_vec = vec![];
-
-        for &reg in frame_layout.clobbered_callee_saves.iter() {
-            match reg.to_reg().class() {
-                RegClass::Int => clobbered_int.push(reg),
-                RegClass::Float => clobbered_vec.push(reg),
-                RegClass::Vector => unreachable!(),
-            }
-        }
+        let (clobbered_int, clobbered_vec) = frame_layout.clobbered_callee_saves_by_class();
 
         let mut insts = SmallVec::new();
+        let setup_frame = frame_layout.setup_area_size > 0;
+
+        // When a return_call within this function required more stack arguments than we have
+        // present, resize the incoming argument area of the frame to accommodate those arguments.
+        let incoming_args_diff = frame_layout.tail_args_size - frame_layout.incoming_args_size;
+        if incoming_args_diff > 0 {
+            // Decrement SP to account for the additional space required by a tail call.
+            insts.extend(Self::gen_sp_reg_adjust(-(incoming_args_diff as i32)));
+
+            // Move fp and lr down.
+            if setup_frame {
+                // Reload the frame pointer from the stack.
+                insts.push(Inst::ULoad64 {
+                    rd: regs::writable_fp_reg(),
+                    mem: AMode::SPOffset {
+                        off: i64::from(incoming_args_diff),
+                    },
+                    flags: MemFlags::trusted(),
+                });
 
-        if flags.unwind_info() && frame_layout.setup_area_size > 0 {
+                // Store the frame pointer and link register again at the new SP
+                insts.push(Inst::StoreP64 {
+                    rt: fp_reg(),
+                    rt2: link_reg(),
+                    mem: PairAMode::SignedOffset {
+                        reg: regs::stack_reg(),
+                        simm7: SImm7Scaled::maybe_from_i64(0, types::I64).unwrap(),
+                    },
+                    flags: MemFlags::trusted(),
+                });
+
+                // Keep the frame pointer in sync
+                insts.push(Self::gen_move(
+                    regs::writable_fp_reg(),
+                    regs::stack_reg(),
+                    types::I64,
+                ));
+            }
+        }
+
+        if flags.unwind_info() && setup_frame {
             // The *unwind* frame (but not the actual frame) starts at the
             // clobbers, just below the saved FP/LR pair.
             insts.push(Inst::Unwind {
@@ -896,10 +918,9 @@ impl ABIMachineSpec for AArch64MachineDeps {
         }
 
         // Allocate the fixed frame below the clobbers if necessary.
-        if frame_layout.fixed_frame_storage_size > 0 {
-            insts.extend(Self::gen_sp_reg_adjust(
-                -(frame_layout.fixed_frame_storage_size as i32),
-            ));
+        let stack_size = frame_layout.fixed_frame_storage_size + frame_layout.outgoing_args_size;
+        if stack_size > 0 {
+            insts.extend(Self::gen_sp_reg_adjust(-(stack_size as i32)));
         }
 
         insts
@@ -911,22 +932,12 @@ impl ABIMachineSpec for AArch64MachineDeps {
         frame_layout: &FrameLayout,
     ) -> SmallVec<[Inst; 16]> {
         let mut insts = SmallVec::new();
-        let mut clobbered_int = vec![];
-        let mut clobbered_vec = vec![];
-
-        for &reg in frame_layout.clobbered_callee_saves.iter() {
-            match reg.to_reg().class() {
-                RegClass::Int => clobbered_int.push(reg),
-                RegClass::Float => clobbered_vec.push(reg),
-                RegClass::Vector => unreachable!(),
-            }
-        }
+        let (clobbered_int, clobbered_vec) = frame_layout.clobbered_callee_saves_by_class();
 
         // Free the fixed frame if necessary.
-        if frame_layout.fixed_frame_storage_size > 0 {
-            insts.extend(Self::gen_sp_reg_adjust(
-                frame_layout.fixed_frame_storage_size as i32,
-            ));
+        let stack_size = frame_layout.fixed_frame_storage_size + frame_layout.outgoing_args_size;
+        if stack_size > 0 {
+            insts.extend(Self::gen_sp_reg_adjust(stack_size as i32));
         }
 
         let load_vec_reg = |rd| Inst::FpuLoad64 {
@@ -1008,7 +1019,6 @@ impl ABIMachineSpec for AArch64MachineDeps {
         uses: CallArgList,
         defs: CallRetList,
         clobbers: PRegSet,
-        opcode: ir::Opcode,
         tmp: Writable<Reg>,
         callee_conv: isa::CallConv,
         caller_conv: isa::CallConv,
@@ -1022,7 +1032,6 @@ impl ABIMachineSpec for AArch64MachineDeps {
                     uses,
                     defs,
                     clobbers,
-                    opcode,
                     caller_callconv: caller_conv,
                     callee_callconv: callee_conv,
                     callee_pop_size,
@@ -1040,7 +1049,6 @@ impl ABIMachineSpec for AArch64MachineDeps {
                         uses,
                         defs,
                         clobbers,
-                        opcode,
                         caller_callconv: caller_conv,
                         callee_callconv: callee_conv,
                         callee_pop_size,
@@ -1053,7 +1061,6 @@ impl ABIMachineSpec for AArch64MachineDeps {
                     uses,
                     defs,
                     clobbers,
-                    opcode,
                     caller_callconv: caller_conv,
                     callee_callconv: callee_conv,
                     callee_pop_size,
@@ -1096,7 +1103,6 @@ impl ABIMachineSpec for AArch64MachineDeps {
                 ],
                 defs: smallvec![],
                 clobbers: Self::get_regs_clobbered_by_call(call_conv),
-                opcode: Opcode::Call,
                 caller_callconv: call_conv,
                 callee_callconv: call_conv,
                 callee_pop_size: 0,
@@ -1119,16 +1125,6 @@ impl ABIMachineSpec for AArch64MachineDeps {
         }
     }
 
-    /// Get the current virtual-SP offset from an instruction-emission state.
-    fn get_virtual_sp_offset_from_state(s: &EmitState) -> i64 {
-        s.virtual_sp_offset
-    }
-
-    /// Get the nominal-SP-to-FP offset from an instruction-emission state.
-    fn get_nominal_sp_to_fp(s: &EmitState) -> i64 {
-        s.nominal_sp_to_fp
-    }
-
     fn get_machine_env(flags: &settings::Flags, _call_conv: isa::CallConv) -> &MachineEnv {
         if flags.enable_pinned_reg() {
             static MACHINE_ENV: OnceLock<MachineEnv> = OnceLock::new();
@@ -1139,19 +1135,19 @@ impl ABIMachineSpec for AArch64MachineDeps {
         }
     }
 
-    fn get_regs_clobbered_by_call(call_conv_of_callee: isa::CallConv) -> PRegSet {
-        if call_conv_of_callee == isa::CallConv::Tail {
-            TAIL_CLOBBERS
-        } else {
-            DEFAULT_AAPCS_CLOBBERS
-        }
+    fn get_regs_clobbered_by_call(_call_conv: isa::CallConv) -> PRegSet {
+        DEFAULT_AAPCS_CLOBBERS
     }
 
     fn get_ext_mode(
-        _call_conv: isa::CallConv,
-        _specified: ir::ArgumentExtension,
+        call_conv: isa::CallConv,
+        specified: ir::ArgumentExtension,
     ) -> ir::ArgumentExtension {
-        ir::ArgumentExtension::None
+        if call_conv == isa::CallConv::AppleAarch64 {
+            specified
+        } else {
+            ir::ArgumentExtension::None
+        }
     }
 
     fn compute_frame_layout(
@@ -1160,7 +1156,8 @@ impl ABIMachineSpec for AArch64MachineDeps {
         sig: &Signature,
         regs: &[Writable<RealReg>],
         is_leaf: bool,
-        stack_args_size: u32,
+        incoming_args_size: u32,
+        tail_args_size: u32,
         fixed_frame_storage_size: u32,
         outgoing_args_size: u32,
     ) -> FrameLayout {
@@ -1174,7 +1171,7 @@ impl ABIMachineSpec for AArch64MachineDeps {
 
         // Sort registers for deterministic code output. We can do an unstable
         // sort because the registers will be unique (there are no dups).
-        regs.sort_unstable_by_key(|r| VReg::from(r.to_reg()).vreg());
+        regs.sort_unstable();
 
         // Compute clobber size.
         let clobber_size = compute_clobber_size(&regs);
@@ -1184,7 +1181,7 @@ impl ABIMachineSpec for AArch64MachineDeps {
             || !is_leaf
             // The function arguments that are passed on the stack are addressed
             // relative to the Frame Pointer.
-            || stack_args_size > 0
+            || incoming_args_size > 0
             || clobber_size > 0
             || fixed_frame_storage_size > 0
         {
@@ -1194,9 +1191,9 @@ impl ABIMachineSpec for AArch64MachineDeps {
         };
 
         // Return FrameLayout structure.
-        debug_assert!(outgoing_args_size == 0);
         FrameLayout {
-            stack_args_size,
+            incoming_args_size,
+            tail_args_size,
             setup_area_size,
             clobber_size,
             fixed_frame_storage_size,
@@ -1206,6 +1203,53 @@ impl ABIMachineSpec for AArch64MachineDeps {
     }
 }
 
+impl AArch64MachineDeps {
+    fn gen_probestack_unroll(insts: &mut SmallInstVec<Inst>, guard_size: u32, probe_count: u32) {
+        // When manually unrolling adjust the stack pointer and then write a zero
+        // to the stack at that offset. This generates something like
+        // `sub sp, sp, #1, lsl #12` followed by `stur wzr, [sp]`.
+        //
+        // We do this because valgrind expects us to never write beyond the stack
+        // pointer and associated redzone.
+        // See: https://github.com/bytecodealliance/wasmtime/issues/7454
+        for _ in 0..probe_count {
+            insts.extend(Self::gen_sp_reg_adjust(-(guard_size as i32)));
+
+            insts.push(Inst::gen_store(
+                AMode::SPOffset { off: 0 },
+                zero_reg(),
+                I32,
+                MemFlags::trusted(),
+            ));
+        }
+
+        // Restore the stack pointer to its original value
+        insts.extend(Self::gen_sp_reg_adjust((guard_size * probe_count) as i32));
+    }
+
+    fn gen_probestack_loop(insts: &mut SmallInstVec<Inst>, frame_size: u32, guard_size: u32) {
+        // The non-unrolled version uses two temporary registers. The
+        // `start` contains the current offset from sp and counts downwards
+        // during the loop by increments of `guard_size`. The `end` is
+        // the size of the frame and where we stop.
+        //
+        // Note that this emission is all post-regalloc so it should be ok
+        // to use the temporary registers here as input/output as the loop
+        // itself is not allowed to use the registers.
+        let start = writable_spilltmp_reg();
+        let end = writable_tmp2_reg();
+        // `gen_inline_probestack` is called after regalloc2, so it's acceptable to reuse
+        // `start` and `end` as temporaries in load_constant.
+        insts.extend(Inst::load_constant(start, 0, &mut |_| start));
+        insts.extend(Inst::load_constant(end, frame_size.into(), &mut |_| end));
+        insts.push(Inst::StackProbeLoop {
+            start,
+            end: end.to_reg(),
+            step: Imm12::maybe_from_u64(guard_size.into()).unwrap(),
+        });
+    }
+}
+
 fn select_api_key(
     isa_flags: &aarch64_settings::Flags,
     call_conv: isa::CallConv,
@@ -1239,16 +1283,20 @@ impl AArch64CallSite {
         args: isle::ValueSlice,
         isa_flags: &aarch64_settings::Flags,
     ) {
-        let (new_stack_arg_size, old_stack_arg_size) =
-            self.emit_temporary_tail_call_frame(ctx, args);
+        let new_stack_arg_size =
+            u32::try_from(self.sig(ctx.sigs()).sized_stack_arg_space()).unwrap();
+
+        ctx.abi_mut().accumulate_tail_args_size(new_stack_arg_size);
+
+        // Put all arguments in registers and stack slots (within that newly
+        // allocated stack space).
+        self.emit_args(ctx, args);
+        self.emit_stack_ret_arg_for_tail_call(ctx);
 
         let dest = self.dest().clone();
-        let opcode = self.opcode();
         let uses = self.take_uses();
         let info = Box::new(ReturnCallInfo {
             uses,
-            opcode,
-            old_stack_arg_size,
             new_stack_arg_size,
             key: select_api_key(isa_flags, isa::CallConv::Tail, true),
         });
@@ -1275,148 +1323,14 @@ impl AArch64CallSite {
     }
 }
 
-fn compute_arg_locs_tail<'a, I>(
-    params: I,
-    add_ret_area_ptr: bool,
-    mut args: ArgsAccumulator<'_>,
-) -> CodegenResult<(u32, Option<usize>)>
-where
-    I: IntoIterator<Item = &'a ir::AbiParam>,
-{
-    let mut xregs = TAIL_CLOBBERS
-        .into_iter()
-        .filter(|r| r.class() == RegClass::Int)
-        // We reserve `x0` for the return area pointer. For simplicity, we
-        // reserve it even when there is no return area pointer needed. This
-        // also means that identity functions don't have to shuffle arguments to
-        // different return registers because we shifted all argument register
-        // numbers down by one to make space for the return area pointer.
-        //
-        // Also, we cannot use all allocatable GPRs as arguments because we need
-        // at least one allocatable register for holding the callee address in
-        // indirect calls. So skip `x1` also, reserving it for that role.
-        .skip(2);
-
-    let mut vregs = TAIL_CLOBBERS
-        .into_iter()
-        .filter(|r| r.class() == RegClass::Float);
-
-    let mut next_stack: u32 = 0;
-
-    // Get the next stack slot for the given type.
-    let stack = |next_stack: &mut u32, ty: ir::Type| {
-        *next_stack = align_to(*next_stack, ty.bytes());
-        let offset = i64::from(*next_stack);
-        *next_stack += ty.bytes();
-        ABIArgSlot::Stack {
-            offset,
-            ty,
-            extension: ir::ArgumentExtension::None,
-        }
-    };
-
-    // Get the next `x` register available, or a stack slot if all are in use.
-    let mut xreg = |next_stack: &mut u32, ty| {
-        xregs
-            .next()
-            .map(|reg| ABIArgSlot::Reg {
-                reg: reg.into(),
-                ty,
-                extension: ir::ArgumentExtension::None,
-            })
-            .unwrap_or_else(|| stack(next_stack, ty))
-    };
-
-    // Get the next `v` register available, or a stack slot if all are in use.
-    let mut vreg = |next_stack: &mut u32, ty| {
-        vregs
-            .next()
-            .map(|reg| ABIArgSlot::Reg {
-                reg: reg.into(),
-                ty,
-                extension: ir::ArgumentExtension::None,
-            })
-            .unwrap_or_else(|| stack(next_stack, ty))
-    };
-
-    for param in params {
-        assert!(
-            legal_type_for_machine(param.value_type),
-            "Invalid type for AArch64: {:?}",
-            param.value_type
-        );
-
-        match param.purpose {
-            ir::ArgumentPurpose::Normal | ir::ArgumentPurpose::VMContext => {}
-            ir::ArgumentPurpose::StructArgument(_)
-            | ir::ArgumentPurpose::StructReturn
-            | ir::ArgumentPurpose::StackLimit => unimplemented!(
-                "support for {:?} parameters is not implemented for the `tail` \
-                 calling convention yet",
-                param.purpose,
-            ),
-        }
-
-        let (reg_classes, reg_types) = Inst::rc_for_type(param.value_type)?;
-        args.push(ABIArg::Slots {
-            slots: reg_classes
-                .iter()
-                .zip(reg_types)
-                .map(|(cls, ty)| match cls {
-                    RegClass::Int => xreg(&mut next_stack, *ty),
-                    RegClass::Float => vreg(&mut next_stack, *ty),
-                    RegClass::Vector => unreachable!(),
-                })
-                .collect(),
-            purpose: param.purpose,
-        });
-    }
-
-    let ret_ptr = if add_ret_area_ptr {
-        let idx = args.args().len();
-        args.push(ABIArg::reg(
-            xreg_preg(0).into(),
-            types::I64,
-            ir::ArgumentExtension::None,
-            ir::ArgumentPurpose::Normal,
-        ));
-        Some(idx)
-    } else {
-        None
-    };
-
-    next_stack = align_to(next_stack, 16);
-
-    // To avoid overflow issues, limit the arg/return size to something
-    // reasonable -- here, 128 MB.
-    if next_stack > STACK_ARG_RET_SIZE_LIMIT {
-        return Err(CodegenError::ImplLimitExceeded);
-    }
-
-    Ok((next_stack, ret_ptr))
-}
-
-/// Is this type supposed to be seen on this machine? E.g. references of the
-/// wrong width are invalid.
-fn legal_type_for_machine(ty: Type) -> bool {
-    match ty {
-        R32 => false,
-        _ => true,
-    }
-}
-
 /// Is the given register saved in the prologue if clobbered, i.e., is it a
 /// callee-save?
 fn is_reg_saved_in_prologue(
-    call_conv: isa::CallConv,
+    _call_conv: isa::CallConv,
     enable_pinned_reg: bool,
     sig: &Signature,
     r: RealReg,
 ) -> bool {
-    if call_conv == isa::CallConv::Tail {
-        return false;
-    }
-
     // FIXME: We need to inspect whether a function is returning Z or P regs too.
     let save_z_regs = sig
         .params
@@ -1526,72 +1440,6 @@ const fn default_aapcs_clobbers() -> PRegSet {
 
 const DEFAULT_AAPCS_CLOBBERS: PRegSet = default_aapcs_clobbers();
 
-// NB: The `tail` calling convention clobbers all allocatable registers.
-const TAIL_CLOBBERS: PRegSet = PRegSet::empty()
-    .with(xreg_preg(0))
-    .with(xreg_preg(1))
-    .with(xreg_preg(2))
-    .with(xreg_preg(3))
-    .with(xreg_preg(4))
-    .with(xreg_preg(5))
-    .with(xreg_preg(6))
-    .with(xreg_preg(7))
-    .with(xreg_preg(8))
-    .with(xreg_preg(9))
-    .with(xreg_preg(10))
-    .with(xreg_preg(11))
-    .with(xreg_preg(12))
-    .with(xreg_preg(13))
-    .with(xreg_preg(14))
-    .with(xreg_preg(15))
-    // Cranelift reserves x16 and x17 as unallocatable scratch registers.
-    //
-    // x18 can be used by the platform and therefore is not allocatable.
-    .with(xreg_preg(19))
-    .with(xreg_preg(20))
-    .with(xreg_preg(21))
-    .with(xreg_preg(22))
-    .with(xreg_preg(23))
-    .with(xreg_preg(24))
-    .with(xreg_preg(25))
-    .with(xreg_preg(26))
-    .with(xreg_preg(27))
-    .with(xreg_preg(28))
-    // NB: x29 is the FP, x30 is the link register, and x31 is the SP. None of
-    // these are allocatable.
-    .with(vreg_preg(0))
-    .with(vreg_preg(1))
-    .with(vreg_preg(2))
-    .with(vreg_preg(3))
-    .with(vreg_preg(4))
-    .with(vreg_preg(5))
-    .with(vreg_preg(6))
-    .with(vreg_preg(7))
-    .with(vreg_preg(8))
-    .with(vreg_preg(9))
-    .with(vreg_preg(10))
-    .with(vreg_preg(11))
-    .with(vreg_preg(12))
-    .with(vreg_preg(13))
-    .with(vreg_preg(14))
-    .with(vreg_preg(15))
-    .with(vreg_preg(16))
-    .with(vreg_preg(17))
-    .with(vreg_preg(18))
-    .with(vreg_preg(19))
-    .with(vreg_preg(20))
-    .with(vreg_preg(21))
-    .with(vreg_preg(22))
-    .with(vreg_preg(23))
-    .with(vreg_preg(24))
-    .with(vreg_preg(25))
-    .with(vreg_preg(26))
-    .with(vreg_preg(27))
-    .with(vreg_preg(28))
-    .with(vreg_preg(29))
-    .with(vreg_preg(30))
-    .with(vreg_preg(31));
-
 fn create_reg_env(enable_pinned_reg: bool) -> MachineEnv {
     fn preg(r: Reg) -> PReg {
         r.to_real_reg().unwrap().into()
diff --git a/cranelift/codegen/src/isa/aarch64/inst.isle b/cranelift/codegen/src/isa/aarch64/inst.isle
index 0e1d03334ffa..396510dc6118 100644
--- a/cranelift/codegen/src/isa/aarch64/inst.isle
+++ b/cranelift/codegen/src/isa/aarch64/inst.isle
@@ -185,7 +185,7 @@
         (size OperandSize))
 
        ;; A MOVK with a 16-bit immediate. Modifies its register; we
-       ;; model this with a seprate input `rn` and output `rd` virtual
+       ;; model this with a separate input `rn` and output `rd` virtual
        ;; register, with a regalloc constraint to tie them together.
        (MovK
         (rd WritableReg)
@@ -331,6 +331,11 @@
        ;; Consumption of speculative data barrier.
        (Csdb)
 
+       ;; FPU 32-bit move.
+       (FpuMove32
+         (rd WritableReg)
+         (rn Reg))
+
        ;; FPU move. Note that this is distinct from a vector-register
        ;; move; moving just 64 bits seems to be significantly faster.
        (FpuMove64
@@ -402,6 +407,18 @@
         (rn Reg)
         (rm Reg))
 
+       ;; Floating-point load, half-precision (16 bit).
+       (FpuLoad16
+        (rd WritableReg)
+        (mem AMode)
+        (flags MemFlags))
+
+       ;; Floating-point store, half-precision (16 bit).
+       (FpuStore16
+        (rd Reg)
+        (mem AMode)
+        (flags MemFlags))
+
        ;; Floating-point load, single-precision (32 bit).
        (FpuLoad32
         (rd WritableReg)
@@ -478,6 +495,14 @@
         (rd WritableReg)
         (rn Reg))
 
+       ;; FP conditional select, 16 bit.
+       ;; Requires FEAT_FP16.
+       (FpuCSel16
+        (rd WritableReg)
+        (rn Reg)
+        (rm Reg)
+        (cond Cond))
+
        ;; FP conditional select, 32 bit.
        (FpuCSel32
         (rd WritableReg)
@@ -499,8 +524,8 @@
         (rn Reg))
 
        ;; Move from a GPR to a vector register.  The scalar value is parked in the lowest lane
-       ;; of the destination, and all other lanes are zeroed out.  Currently only 32- and 64-bit
-       ;; transactions are supported.
+       ;; of the destination, and all other lanes are zeroed out. Currently 16-, 32- and 64-bit
+       ;; transactions are supported. 16-bit moves require FEAT_FP16.
        (MovToFpu
         (rd WritableReg)
         (rn Reg)
@@ -833,6 +858,15 @@
         (not_taken BranchTarget)
         (kind CondBrKind))
 
+       ;; A conditional branch which tests the `bit` of `rn` and branches
+       ;; depending on `kind`.
+       (TestBitAndBranch
+        (kind TestBitAndBranchKind)
+        (taken BranchTarget)
+        (not_taken BranchTarget)
+        (rn Reg)
+        (bit u8))
+
        ;; A conditional trap: execute a `udf` if the condition is true. This is
        ;; one VCode instruction because it uses embedded control flow; it is
        ;; logically a single-in, single-out region, but needs to appear as one
@@ -916,11 +950,6 @@
        (Bti
         (targets BranchTargetType))
 
-       ;; Marker, no-op in generated code: SP "virtual offset" is adjusted. This
-       ;; controls how AMode::NominalSPOffset args are lowered.
-       (VirtualSPOffsetAdj
-        (offset i64))
-
        ;; Meta-insn, no-op in generated code: emit constant/branch veneer island
        ;; at this point (with a guard jump around it) if less than the needed
        ;; space is available before the next branch deadline. See the `MachBuffer`
@@ -947,8 +976,9 @@
 
        ;; A call to the `ElfTlsGetAddr` libcall. Returns address of TLS symbol in x0.
        (ElfTlsGetAddr
-        (symbol ExternalName)
-        (rd WritableReg))
+        (symbol BoxExternalName)
+        (rd WritableReg)
+        (tmp WritableReg))
 
        (MachOTlsGetAddr
         (symbol ExternalName)
@@ -971,6 +1001,263 @@
                        (end Reg)
                        (step Imm12))))
 
+(attr MInst.FpuMove32 (tag float))
+(attr MInst.FpuMove64 (tag float))
+(attr MInst.FpuMove128 (tag float))
+(attr MInst.FpuMoveFromVec (tag float))
+(attr MInst.FpuExtend (tag float))
+(attr MInst.FpuRR (tag float))
+(attr MInst.FpuRRR (tag float))
+(attr MInst.FpuRRI (tag float))
+(attr MInst.FpuRRIMod (tag float))
+(attr MInst.FpuRRRR (tag float))
+(attr MInst.FpuCmp (tag float))
+(attr MInst.FpuLoad16 (tag float))
+(attr MInst.FpuLoad16 (tag narrowfloat))
+(attr MInst.FpuStore16 (tag float))
+(attr MInst.FpuStore16 (tag narrowfloat))
+(attr MInst.FpuLoad32 (tag float))
+(attr MInst.FpuStore32 (tag float))
+(attr MInst.FpuLoad64 (tag float))
+(attr MInst.FpuStore64 (tag float))
+(attr MInst.FpuLoad128 (tag float))
+(attr MInst.FpuLoad128 (tag i128))
+(attr MInst.FpuStore128 (tag float))
+(attr MInst.FpuStore128 (tag i128))
+(attr MInst.FpuLoadP64 (tag float))
+(attr MInst.FpuStoreP64 (tag float))
+(attr MInst.FpuLoadP128 (tag float))
+(attr MInst.FpuLoadP128 (tag i128))
+(attr MInst.FpuStoreP128 (tag float))
+(attr MInst.FpuStoreP128 (tag i128))
+(attr MInst.FpuToInt (tag float))
+(attr MInst.IntToFpu (tag float))
+(attr MInst.FpuCSel16 (tag float))
+(attr MInst.FpuCSel32 (tag float))
+(attr MInst.FpuCSel64 (tag float))
+(attr MInst.FpuRound (tag float))
+(attr MInst.MovToFpu (tag float))
+(attr MInst.FpuMoveFPImm (tag float))
+
+(attr MInst.VecDup (tag vector))
+(attr MInst.VecDupFromFpu (tag vector))
+(attr MInst.VecDupFPImm (tag vector))
+(attr MInst.VecDupImm (tag vector))
+(attr MInst.VecExtend (tag vector))
+(attr MInst.VecMovElement (tag vector))
+(attr MInst.VecRRLong (tag vector))
+(attr MInst.VecRRNarrowLow (tag vector))
+(attr MInst.VecRRNarrowHigh (tag vector))
+(attr MInst.VecRRPair (tag vector))
+(attr MInst.VecRRRLong (tag vector))
+(attr MInst.VecRRRLongMod (tag vector))
+(attr MInst.VecRRPairLong (tag vector))
+(attr MInst.VecRRR (tag vector))
+(attr MInst.VecRRRMod (tag vector))
+(attr MInst.VecFmlaElem (tag vector))
+(attr MInst.VecMisc (tag vector))
+(attr MInst.VecLanes (tag vector))
+(attr MInst.VecShiftImm (tag vector))
+(attr MInst.VecShiftImmMod (tag vector))
+(attr MInst.VecExtract (tag vector))
+(attr MInst.VecTbl (tag vector))
+(attr MInst.VecTblExt (tag vector))
+(attr MInst.VecTbl2 (tag vector))
+(attr MInst.VecTbl2Ext (tag vector))
+(attr MInst.VecLoadReplicate (tag vector))
+(attr MInst.VecCSel (tag vector))
+
+(attr MInst.LoadAcquire (tag atomics))
+
+(model MInst
+      (type
+            (struct
+                  (flags_in  (named NZCV))
+                  (flags_out (named NZCV))
+            )
+      )
+)
+
+(spec (MInst.AluRRImmLogic alu_op size rd rn imml)
+      (provide
+            (=>
+                  (and (= alu_op (ALUOp.Orr)) (= size (OperandSize.Size64)))
+                        (= rd (bvor rn imml))
+            )
+            (=>
+                  (and (= alu_op (ALUOp.Orr)) (= size (OperandSize.Size32)))
+                        (= rd (zero_ext 64 (bvor (extract 31 0 rn) (extract 31 0 imml))))
+            )
+
+            (=>
+                  (and (= alu_op (ALUOp.OrrNot)) (= size (OperandSize.Size64)))
+                        (= rd (bvor rn (bvnot imml)))
+            )
+            (=>
+                  (and (= alu_op (ALUOp.OrrNot)) (= size (OperandSize.Size32)))
+                        (= rd (zero_ext 64 (bvor (extract 31 0 rn) (bvnot (extract 31 0 imml)))))
+            )
+
+            (=>
+                  (and (= alu_op (ALUOp.And)) (= size (OperandSize.Size64)))
+                        (= rd (bvand rn imml))
+            )
+            (=>
+                  (and (= alu_op (ALUOp.And)) (= size (OperandSize.Size32)))
+                        (= rd (zero_ext 64 (bvand (extract 31 0 rn) (extract 31 0 imml))))
+            )
+
+            (=>
+                  (and (= alu_op (ALUOp.AndNot)) (= size (OperandSize.Size64)))
+                        (= rd (bvand rn (bvnot imml)))
+            )
+            (=>
+                  (and (= alu_op (ALUOp.AndNot)) (= size (OperandSize.Size32)))
+                        (= rd (zero_ext 64 (bvand (extract 31 0 rn) (bvnot (extract 31 0 imml)))))
+            )
+
+            (=>
+                  (and (= alu_op (ALUOp.Eor)) (= size (OperandSize.Size64)))
+                        (= rd (bvxor rn imml))
+            )
+            (=>
+                  (and (= alu_op (ALUOp.Eor)) (= size (OperandSize.Size32)))
+                        (= rd (zero_ext 64 (bvxor (extract 31 0 rn) (extract 31 0 imml))))
+            )
+
+            (=>
+                  (and (= alu_op (ALUOp.EorNot)) (= size (OperandSize.Size64)))
+                        (= rd (bvxor rn (bvnot imml)))
+            )
+            (=>
+                  (and (= alu_op (ALUOp.EorNot)) (= size (OperandSize.Size32)))
+                        (= rd (zero_ext 64 (bvxor (extract 31 0 rn) (bvnot (extract 31 0 imml)))))
+            )
+      )
+      (require
+            ; Implemented (opcode, size) combinations.
+            (or
+                  (and (= alu_op (ALUOp.Orr)) (= size (OperandSize.Size64)))
+                  (and (= alu_op (ALUOp.Orr)) (= size (OperandSize.Size32)))
+
+                  (and (= alu_op (ALUOp.OrrNot)) (= size (OperandSize.Size64)))
+                  (and (= alu_op (ALUOp.OrrNot)) (= size (OperandSize.Size32)))
+
+                  (and (= alu_op (ALUOp.And)) (= size (OperandSize.Size64)))
+                  (and (= alu_op (ALUOp.And)) (= size (OperandSize.Size32)))
+
+                  (and (= alu_op (ALUOp.AndNot)) (= size (OperandSize.Size64)))
+                  (and (= alu_op (ALUOp.AndNot)) (= size (OperandSize.Size32)))
+
+                  (and (= alu_op (ALUOp.Eor)) (= size (OperandSize.Size64)))
+                  (and (= alu_op (ALUOp.Eor)) (= size (OperandSize.Size32)))
+
+                  (and (= alu_op (ALUOp.EorNot)) (= size (OperandSize.Size64)))
+                  (and (= alu_op (ALUOp.EorNot)) (= size (OperandSize.Size32)))
+            )
+            ; REVIEW(mbm): require properties for logical immediates?
+      )
+)
+
+
+(spec (MInst.AluRRImmShift alu_op size rd rn immshift)
+      (provide
+            (=> (and (= alu_op (ALUOp.Lsr)) (= size (OperandSize.Size64)))
+                  (= rd (bvlshr rn (zero_ext 64 immshift)))
+            )
+            (=> (and (= alu_op (ALUOp.Lsr)) (= size (OperandSize.Size32)))
+                  (= rd (zero_ext 64 (bvlshr (extract 31 0 rn) (zero_ext 32 immshift))))
+            )
+
+            (=> (and (= alu_op (ALUOp.Asr)) (= size (OperandSize.Size64)))
+                  (= rd (bvashr rn (zero_ext 64 immshift)))
+            )
+            (=> (and (= alu_op (ALUOp.Asr)) (= size (OperandSize.Size32)))
+                  (= rd (zero_ext 64 (bvashr (extract 31 0 rn) (zero_ext 32 immshift))))
+            )
+
+            (=> (and (= alu_op (ALUOp.Lsl)) (= size (OperandSize.Size64)))
+                  (= rd (bvshl rn (zero_ext 64 immshift)))
+            )
+            (=> (and (= alu_op (ALUOp.Lsl)) (= size (OperandSize.Size32)))
+                  (= rd (zero_ext 64 (bvshl (extract 31 0 rn) (zero_ext 32 immshift))))
+            )
+
+            (=> (and (= alu_op (ALUOp.RotR)) (= size (OperandSize.Size32)))
+                (with
+                            (t1 t3 t4 t5)
+                            (and
+                                (= t1 (= (extract 4 0 immshift) #b00000))
+                                (if
+                                    t1
+                                    (= t3 (extract 31 0 rn))
+                                    (and
+                                        (not (= (extract 4 0 immshift) #b00000))
+                                        (=
+                                            t4
+                                            (bvor
+                                                (bvlshr (extract 31 0 rn) (zero_ext 32 (extract 4 0 immshift)))
+                                                (bvshl
+                                                    (extract 31 0 rn)
+                                                    (zero_ext 32 (bvsub #x20 (zero_ext 8 (extract 4 0 immshift)))))))))
+                                (= t5 (if t1 t3 t4))
+                                (= rd (zero_ext 64 t5))))
+            )
+            (=> (and (= alu_op (ALUOp.RotR)) (= size (OperandSize.Size64)))
+            (with
+                            (t1 t3 t4 t5)
+                            (and
+                                (= t1 (= (extract 5 0 immshift) #b000000))
+                                (if
+                                    t1
+                                    (= t3 rn)
+                                    (and
+                                        (not (= (extract 5 0 immshift) #b000000))
+                                        (=
+                                            t4
+                                            (bvor
+                                                (bvlshr rn (zero_ext 64 (extract 5 0 immshift)))
+                                                (bvshl rn (zero_ext 64 (bvsub #x40 (zero_ext 8 (extract 5 0 immshift)))))))))
+                                (= t5 (if t1 t3 t4))
+                                (= rd t5))))
+      )
+      (require
+            (or
+                  (and (= alu_op (ALUOp.Lsr)) (= size (OperandSize.Size64)))
+                  (and (= alu_op (ALUOp.Lsr)) (= size (OperandSize.Size32)))
+
+                  (and (= alu_op (ALUOp.Asr)) (= size (OperandSize.Size64)))
+                  (and (= alu_op (ALUOp.Asr)) (= size (OperandSize.Size32)))
+
+                  (and (= alu_op (ALUOp.Lsl)) (= size (OperandSize.Size64)))
+                  (and (= alu_op (ALUOp.Lsl)) (= size (OperandSize.Size32)))
+
+                  (and (= alu_op (ALUOp.RotR)) (= size (OperandSize.Size64)))
+                  (and (= alu_op (ALUOp.RotR)) (= size (OperandSize.Size32)))
+            )
+      )
+)
+
+(spec (MInst.TrapIf kind trap_code)
+      (modifies exec_trap trap_cond)
+      (provide
+            ; Conditions under which this instruction traps.
+            (= trap_cond
+                  (match kind
+                        ((Zero r) (bv_is_zero! r))
+                        ((NotZero r) (not (bv_is_zero! r)))
+                        ((Cond cc) (cond_holds! cc (:flags_in result)))
+                  )
+            )
+
+            ; If this instruction traps, set the global trap state.
+            (=> trap_cond exec_trap)
+      )
+)
+
+;; Registers.
+(model Reg (type (bv)))
+
 ;; An ALU operation. This can be paired with several instruction formats
 ;; below (see `Inst`) in any combination.
 (type ALUOp
@@ -1010,6 +1297,31 @@
     (SbcS)
 ))
 
+(spec (ALUOp.AndS)
+  (provide
+    (= result (ALUOp.AndS))))
+
+(spec (ALUOp.Orr)
+  (provide
+    (= result (ALUOp.Orr))))
+
+
+(spec (ALUOp.Sub)
+  (provide
+    (= result (ALUOp.Sub))))
+
+(spec (ALUOp.Lsr)
+  (provide
+    (= result (ALUOp.Lsr))))
+
+(spec (ALUOp.OrrNot)
+  (provide
+    (= result (ALUOp.OrrNot))))
+
+(spec (ALUOp.Lsl)
+  (provide
+    (= result (ALUOp.Lsl))))
+
 ;; An ALU operation with three arguments.
 (type ALUOp3
   (enum
@@ -1029,25 +1341,117 @@
     (MovN)
 ))
 
+(spec (MoveWideOp.MovZ)
+  (provide
+    (= result (MoveWideOp.MovZ))))
+
+(spec (MoveWideOp.MovN)
+  (provide
+    (= result (MoveWideOp.MovN))))
+
 (type UImm5 (primitive UImm5))
+(model UImm5 (type (bv 5)))
+
 (type Imm12 (primitive Imm12))
+(model Imm12
+      (type
+            (struct
+                  (bits (bv 12))
+                  (shift12 Bool)
+            )
+      )
+)
+
 (type ImmLogic (primitive ImmLogic))
+(model ImmLogic (type (bv 64)))
 (type ImmShift (primitive ImmShift))
+(model ImmShift (type (bv 6)))
+
 (type ShiftOpAndAmt (primitive ShiftOpAndAmt))
+(model ShiftOpAndAmt
+      (type
+            (struct
+                  (op (named ALUOp))
+                  (amt (bv 8))
+            )
+      )
+)
+
 (type MoveWideConst (primitive MoveWideConst))
+(model MoveWideConst
+      (type
+            (struct
+                  (shift (bv 2))
+                  (bits (bv 16))
+            )
+      )
+)
+
 (type NZCV (primitive NZCV))
+(model NZCV
+      (type
+            (struct
+                  (N (bv 1))
+                  (Z (bv 1))
+                  (C (bv 1))
+                  (V (bv 1))
+            )
+      )
+)
+
+(macro (n_set nzcv) (= (:N nzcv) #b1))
+(macro (n_clear nzcv) (= (:N nzcv) #b0))
+(macro (z_set nzcv) (= (:Z nzcv) #b1))
+(macro (z_clear nzcv) (= (:Z nzcv) #b0))
+(macro (c_set nzcv) (= (:C nzcv) #b1))
+(macro (c_clear nzcv) (= (:C nzcv) #b0))
+(macro (v_set nzcv) (= (:V nzcv) #b1))
+(macro (v_clear nzcv) (= (:V nzcv) #b0))
+
 (type ASIMDFPModImm (primitive ASIMDFPModImm))
+(model ASIMDFPModImm (type
+      (struct
+            (imm (bv 8))
+            (size (named ScalarSize))
+      )
+))
+
 (type ASIMDMovModImm (primitive ASIMDMovModImm))
-(type SImm7Scaled (primitive SImm7Scaled))
+(model ASIMDMovModImm (type
+      (struct
+            (imm (bv 8))
+            ; TODO: shift: u8,
+            ; TODO: is_64bit: bool,
+            ; TODO: shift_ones: bool,
+      )
+))
 
+(type SImm7Scaled (primitive SImm7Scaled))
+(model SImm7Scaled (type (bv)))
 (type BoxCallInfo (primitive BoxCallInfo))
+(model BoxCallInfo (type (bv)))
 (type BoxCallIndInfo (primitive BoxCallIndInfo))
+(model BoxCallIndInfo (type (bv)))
 (type BoxReturnCallInfo (primitive BoxReturnCallInfo))
-(type CondBrKind (primitive CondBrKind))
+(model BoxReturnCallInfo (type (bv)))
 (type BranchTarget (primitive BranchTarget))
+(model BranchTarget (type (bv)))
 (type BoxJTSequenceInfo (primitive BoxJTSequenceInfo))
 (type CodeOffset (primitive CodeOffset))
+(model CodeOffset (type (bv)))
 (type VecMachLabel extern (enum))
+(model VecMachLabel (type !))
+
+(type CondBrKind extern
+  (enum
+    (Zero (r Reg))
+    (NotZero (r Reg))
+    (Cond (cc Cond))
+))
+
+; Expect that branched on registers will be general-purpose registers.
+(instantiate CondBrKind.Zero ((args (bv 64)) (ret (named CondBrKind))))
+(instantiate CondBrKind.NotZero ((args (bv 64)) (ret (named CondBrKind))))
 
 (type ExtendOp extern
   (enum
@@ -1076,8 +1480,11 @@
 ))
 
 (type MemLabel extern (enum))
+(model MemLabel (type !))
 (type SImm9 extern (enum))
+(model SImm9 (type (bv 9)))
 (type UImm12Scaled extern (enum))
+(model UImm12Scaled (type (bv 12)))
 
 ;; An addressing mode specified for a load/store operation.
 (type AMode
@@ -1109,15 +1516,13 @@
         ;; Register plus register offset, scaled by type's size.
         (RegScaled
          (rn Reg)
-         (rm Reg)
-         (ty Type))
+         (rm Reg))
 
         ;; Register plus register offset, scaled by type's size, with index
         ;; sign- or zero-extended first.
         (RegScaledExtended
          (rn Reg)
          (rm Reg)
-         (ty Type)
          (extendop ExtendOp))
 
         ;; Register plus register offset, with index sign- or zero-extended
@@ -1147,39 +1552,60 @@
         ;; offsets with multiple instructions as necessary during code emission.
         (RegOffset
          (rn Reg)
-         (off i64)
-         (ty Type))
+         (off i64))
 
         ;; Offset from the stack pointer.
         (SPOffset
-         (off i64)
-         (ty Type))
+         (off i64))
 
         ;; Offset from the frame pointer.
         (FPOffset
-         (off i64)
-         (ty Type))
+         (off i64))
 
         ;; A reference to a constant which is placed outside of the function's
         ;; body, typically at the end.
         (Const
           (addr VCodeConstant))
 
-        ;; Offset from the "nominal stack pointer", which is where the real SP is
-        ;; just after stack and spill slots are allocated in the function prologue.
+        ;; Offset from the beginning of the argument area to the argument
+        ;; referenced. This can only be determined when the function has been
+        ;; processed fully, as the size of the argument area after the prologue
+        ;; is only known once all return_call instructions in the function body
+        ;; have been processed.
+        (IncomingArg
+          (off i64))
+
+        ;; Offset into the slot area of the stack, which lies just above the
+        ;; outgoing argument area that's setup by the function prologue.
         ;; At emission time, this is converted to `SPOffset` with a fixup added to
         ;; the offset constant. The fixup is a running value that is tracked as
         ;; emission iterates through instructions in linear order, and can be
         ;; adjusted up and down with [Inst::VirtualSPOffsetAdj].
         ;;
         ;; The standard ABI is in charge of handling this (by emitting the
-        ;; adjustment meta-instructions). It maintains the invariant that "nominal
-        ;; SP" is where the actual SP is after the function prologue and before
-        ;; clobber pushes. See the diagram in the documentation for
-        ;; [crate::isa::aarch64::abi](the ABI module) for more details.
-        (NominalSPOffset
-         (off i64)
-         (ty Type))))
+        ;; adjustment meta-instructions). See the diagram in the documentation
+        ;; for [crate::isa::aarch64::abi](the ABI module) for more details.
+        (SlotOffset
+         (off i64))))
+
+; TODO: handle loads from function's constant pool
+(attr AMode.Const (tag amode_const))
+
+; Type instantiations for register addressing modes.
+;
+; Register type is an unspecified bit-vector to support both general-purpose and
+; vector register types. When the `Reg` type is used as an addressing mode we
+; face two problems.  Firstly, acted on in a way that type inference cannot
+; always deduce the width. For example, some addressing registers only have bits
+; extracted.  Secondly, some variants such as `RegOffset` are only ever used
+; from Rust. Type inference has no information to use to deduce the width of
+; `Reg` fields in these cases.  For these reasons we specify explicitly that
+; addressing modes are general purpose registers, therefore 64-bit.
+(instantiate AMode.RegReg                 ((args (bv 64) (bv 64)) (ret (named AMode))))
+(instantiate AMode.RegScaled              ((args (bv 64) (bv 64)) (ret (named AMode))))
+(instantiate AMode.RegScaledExtended      ((args (bv 64) (bv 64) (named ExtendOp)) (ret (named AMode))))
+(instantiate AMode.RegExtended            ((args (bv 64) (bv 64) (named ExtendOp)) (ret (named AMode))))
+(instantiate AMode.RegOffset              ((args (bv 64) (named i64)) (ret (named AMode))))
 
 ;; A memory argument to a load/store-pair.
 (type PairAMode (enum
@@ -1196,16 +1622,43 @@
 ))
 
 (type FPUOpRI extern (enum))
+(model FPUOpRI (type
+      (struct
+            (size (bv 8))
+            (amount (bv 8))
+            (lane_size_in_bits (bv 8))
+      )
+))
 (type FPUOpRIMod extern (enum))
+(model FPUOpRIMod (type
+      (struct
+            (size (bv 8))
+            (amount (bv 8))
+            (lane_size_in_bits (bv 8))
+      )
+))
 
 (type OperandSize extern
       (enum Size32
             Size64))
 
+(type TestBitAndBranchKind (enum (Z) (NZ)))
+
 ;; Helper for calculating the `OperandSize` corresponding to a type
 (decl operand_size (Type) OperandSize)
-(rule 1 (operand_size (fits_in_32 _ty)) (OperandSize.Size32))
-(rule (operand_size (fits_in_64 _ty)) (OperandSize.Size64))
+(spec (operand_size ty)
+      (provide
+            (= result (if (<= (:bits ty) 32) (OperandSize.Size32) (OperandSize.Size64))))
+      (require
+            (or (= (:bits ty) 8) (= (:bits ty) 16) (= (:bits ty) 32) (= (:bits ty) 64))))
+(attr rule operand_size_32 (veri priority))
+(rule operand_size_32 1 (operand_size (fits_in_32 _ty)) (OperandSize.Size32))
+(rule operand_size_64 (operand_size (fits_in_64 _ty)) (OperandSize.Size64))
+
+(decl diff_from_32 (Type) u8)
+(attr diff_from_32 (veri chain))
+(rule (diff_from_32 $I8) 24)
+(rule (diff_from_32 $I16) 16)
 
 (type ScalarSize extern
       (enum Size8
@@ -1216,17 +1669,29 @@
 
 ;; Helper for calculating the `ScalarSize` corresponding to a type
 (decl scalar_size (Type) ScalarSize)
-
-(rule (scalar_size $I8) (ScalarSize.Size8))
-(rule (scalar_size $I16) (ScalarSize.Size16))
-(rule (scalar_size $I32) (ScalarSize.Size32))
-(rule (scalar_size $I64) (ScalarSize.Size64))
-(rule (scalar_size $I128) (ScalarSize.Size128))
-
-(rule (scalar_size $F32) (ScalarSize.Size32))
-(rule (scalar_size $F64) (ScalarSize.Size64))
+(spec (scalar_size ty)
+      (provide (= result
+            (switch (:bits ty)
+                  (8   (ScalarSize.Size8))
+                  (16  (ScalarSize.Size16))
+                  (32  (ScalarSize.Size32))
+                  (64  (ScalarSize.Size64))
+                  (128 (ScalarSize.Size128))
+            )
+      ))
+)
+
+(rule scalar_size_i8 (scalar_size $I8) (ScalarSize.Size8))
+(rule scalar_size_i16 (scalar_size $I16) (ScalarSize.Size16))
+(rule scalar_size_i32 (scalar_size $I32) (ScalarSize.Size32))
+(rule scalar_size_i64 (scalar_size $I64) (ScalarSize.Size64))
+(rule scalar_size_i128 (scalar_size $I128) (ScalarSize.Size128))
+
+(rule scalar_size_f32 (scalar_size $F32) (ScalarSize.Size32))
+(rule scalar_size_f64 (scalar_size $F64) (ScalarSize.Size64))
 
 ;; Helper for calculating the `ScalarSize` lane type from vector type
+(attr lane_size (tag vector))
 (decl lane_size (Type) ScalarSize)
 (rule 1 (lane_size (multi_lane 8 _)) (ScalarSize.Size8))
 (rule 1 (lane_size (multi_lane 16 _)) (ScalarSize.Size16))
@@ -1267,6 +1732,46 @@
     (Nv)
 ))
 
+(spec (Cond.Ne)
+      (provide 
+            ( = result (Cond.Ne))))
+
+(macro (cond_holds cc nzcv)
+      (match cc
+            ; EQ	Equal.	Z==1
+            ((Eq) (z_set! nzcv))
+            ; NE	Not equal.	Z==0
+            ((Ne) (z_clear! nzcv))
+            ; HS	Unsigned higher or same (or carry set).	C==1
+            ((Hs) (c_set! nzcv))
+            ; LO	Unsigned lower (or carry clear).	C==0
+            ((Lo) (c_clear! nzcv))
+            ; MI	Negative. The mnemonic stands for "minus".	N==1
+            ((Mi) (n_set! nzcv))
+            ; PL	Positive or zero. The mnemonic stands for "plus".	N==0
+            ((Pl) (n_clear! nzcv))
+            ; VS	Signed overflow. The mnemonic stands for "V set".	V==1
+            ((Vs) (v_set! nzcv))
+            ; VC	No signed overflow. The mnemonic stands for "V clear".	V==0
+            ((Vc) (v_clear! nzcv))
+            ; HI	Unsigned higher.	(C==1) && (Z==0)
+            ((Hi) (and (c_set! nzcv) (z_clear! nzcv)))
+            ; LS	Unsigned lower or same.	(C==0) || (Z==1)
+            ((Ls) (or (c_clear! nzcv) (z_set! nzcv)))
+            ; GE	Signed greater than or equal.	N==V
+            ((Ge) (= (:N nzcv) (:V nzcv)))
+            ; LT	Signed less than.	N!=V
+            ((Lt) (not (= (:N nzcv) (:V nzcv))))
+            ; GT	Signed greater than.	(Z==0) && (N==V)
+            ((Gt) (and (z_clear! nzcv) (= (:N nzcv) (:V nzcv))))
+            ; LE	Signed less than or equal.	(Z==1) || (N!=V)
+            ((Le) (or (z_set! nzcv) (not (= (:N nzcv) (:V nzcv)))))
+            ; AL (or omitted)	Always executed.	None tested.
+            ((Al) true)
+            ((Nv) false)
+      )
+)
+
 (type VectorSize extern
   (enum
     (Size8x8)
@@ -1279,6 +1784,7 @@
 ))
 
 ;; Helper for calculating the `VectorSize` corresponding to a type
+(attr vector_size (tag vector))
 (decl vector_size (Type) VectorSize)
 (rule 1 (vector_size (multi_lane 8 8)) (VectorSize.Size8x8))
 (rule 1 (vector_size (multi_lane 8 16)) (VectorSize.Size8x16))
@@ -1319,7 +1825,14 @@
 ;; A floating-point unit (FPU) operation with three args.
 (type FPUOp3
   (enum
+    ;; Multiply-add
     (MAdd)
+    ;; Multiply-sub
+    (MSub)
+    ;; Negated fused Multiply-add
+    (NMAdd)
+    ;; Negated fused Multiply-sub
+    (NMSub)
 ))
 
 ;; A conversion from an FP to an integer value.
@@ -1686,35 +2199,171 @@
 (decl use_lse () Inst)
 (extern extractor use_lse use_lse)
 
-;; Extractor helpers for various immmediate constants ;;;;;;;;;;;;;;;;;;;;;;;;;;
+(decl pure use_fp16 () bool)
+(extern constructor use_fp16 use_fp16)
+(spec (use_fp16) (provide (not result)))
+
+;; Extractor helpers for various immediate constants ;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; equals_move_wide_value expresses the property that the value n equals the
+; computed value of the move wide immediate.
+(macro (equals_move_wide_value n mov_wide_const)
+      (and
+            ; n equals the computed value
+            (= n
+                  ; bits << (16 * shift)
+                  (bvshl
+                        (zero_ext 64 (:bits mov_wide_const))
+                        (bvmul (int2bv 64 16) (zero_ext 64 (:shift mov_wide_const)))
+                  )
+            )
+
+            ; The zero case can be expressed in multiple ways. Assert that it
+            ; must be the zero shift value, matching the Rust implementation.
+            (=> (bv_is_zero! n) (= (:shift mov_wide_const) #b00))
+      )
+)
 
 (decl pure partial move_wide_const_from_u64 (Type u64) MoveWideConst)
 (extern constructor move_wide_const_from_u64 move_wide_const_from_u64)
+(spec (move_wide_const_from_u64 ty n)
+      (provide
+            (let
+                  (
+                        (nlow (bvand n (low_bits_mask! 64 (:bits ty))))
+                  )
+                  (equals_move_wide_value! nlow result)
+            )
+      )
+      (match
+            (let
+                  (
+                        (nlow (bvand n (low_bits_mask! 64 (:bits ty))))
+                  )
+                  (or
+                        (= nlow (bvand nlow #x000000000000ffff))
+                        (= nlow (bvand nlow #x00000000ffff0000))
+                        (= nlow (bvand nlow #x0000ffff00000000))
+                        (= nlow (bvand nlow #xffff000000000000))
+                  )
+            )
+      )
+)
 
 (decl pure partial move_wide_const_from_inverted_u64 (Type u64) MoveWideConst)
 (extern constructor move_wide_const_from_inverted_u64 move_wide_const_from_inverted_u64)
+(spec (move_wide_const_from_inverted_u64 ty n_inverted)
+      (provide
+            (let
+                  (
+                        (n (bvnot n_inverted))
+                        (nlow (bvand n (low_bits_mask! 64 (:bits ty))))
+                  )
+                  (equals_move_wide_value! nlow result)
+            )
+      )
+      (match
+            (let
+                  (
+                        (n (bvnot n_inverted))
+                        (nlow (bvand n (low_bits_mask! 64 (:bits ty))))
+                  )
+                  (or
+                        (= nlow (bvand nlow #x000000000000ffff))
+                        (= nlow (bvand nlow #x00000000ffff0000))
+                        (= nlow (bvand nlow #x0000ffff00000000))
+                        (= nlow (bvand nlow #xffff000000000000))
+                  )
+            )
+      )
+)
 
 (decl pure partial imm_logic_from_u64 (Type u64) ImmLogic)
 (extern constructor imm_logic_from_u64 imm_logic_from_u64)
+; REVIEW(mbm): actually specify the requirements of logical immediates?
+(spec (imm_logic_from_u64 ty n)
+      (provide (= result n))
+      (match (or (= (:bits ty) 32) (= (:bits ty) 64)))
+)
+
+(decl pure partial imm_size_from_type (Type) u16)
+(extern constructor imm_size_from_type imm_size_from_type)
+(spec (imm_size_from_type ty)
+      (match (or (= (:bits ty) 32) (= (:bits ty) 64)))
+      (provide (= result (int2bv 16 (:bits ty))))
+)
 
 (decl pure partial imm_logic_from_imm64 (Type Imm64) ImmLogic)
 (extern constructor imm_logic_from_imm64 imm_logic_from_imm64)
+; REVIEW(mbm): actually specify the requirements of logical immediates?
+(spec (imm_logic_from_imm64 ty imm64)
+      (provide (= result imm64))
+      (match (or (= (:bits ty) 32) (= (:bits ty) 64))))
 
 (decl pure partial imm_shift_from_imm64 (Type Imm64) ImmShift)
 (extern constructor imm_shift_from_imm64 imm_shift_from_imm64)
+(spec (imm_shift_from_imm64 ty v)
+      (provide
+            (let
+                  ((imm_value (bvand v (shift_mask! 64 (:bits ty)))))
+                  (= result (extract 5 0 imm_value))
+            )
+      )
+      (match
+            (let
+                  ((imm_value (bvand v (shift_mask! 64 (:bits ty)))))
+                  (bvult imm_value (int2bv 64 64))
+            )
+      )
+)
 
 (decl imm_shift_from_u8 (u8) ImmShift)
 (extern constructor imm_shift_from_u8 imm_shift_from_u8)
+(spec (imm_shift_from_u8 n)
+      (provide (= result (extract 5 0 n)))
+      (require (bvult n #x40))
+)
 
 (decl imm12_from_u64 (Imm12) u64)
 (extern extractor imm12_from_u64 imm12_from_u64)
+(spec (imm12_from_u64 imm12)
+      (provide
+            (= result
+                  (zero_ext 64
+                        (if (:shift12 imm12)
+                              (concat (:bits imm12) #x000)
+                              (concat #x000 (:bits imm12))
+                        )
+                  )
+            )
+      )
+      (match
+            (or
+                  (= result (bvand result (zero_ext 64 #x000fff)))
+                  (= result (bvand result (zero_ext 64 #xfff000)))
+            )
+      )
+)
 
 (decl u8_into_uimm5 (u8) UImm5)
 (extern constructor u8_into_uimm5 u8_into_uimm5)
+(spec (u8_into_uimm5 n)
+      (provide (= result (extract 4 0 n)))
+      (require (bvult n #x20))
+)
 
 (decl u8_into_imm12 (u8) Imm12)
 (extern constructor u8_into_imm12 u8_into_imm12)
-
+(spec (u8_into_imm12 n)
+      (provide
+            (not (:shift12 result))
+            (= (:bits result) (zero_ext 12 n))
+      )
+)
+
+(spec (u64_into_imm_logic ty a)
+      (provide (= result a))
+      (require (or (= (:bits ty) 32) (= (:bits ty) 64))))
 (decl u64_into_imm_logic (Type u64) ImmLogic)
 (extern constructor u64_into_imm_logic u64_into_imm_logic)
 
@@ -1745,16 +2394,48 @@
 ;; and the amount to shift by.
 (decl fpu_op_ri_ushr (u8 u8) FPUOpRI)
 (extern constructor fpu_op_ri_ushr fpu_op_ri_ushr)
+(spec (fpu_op_ri_ushr ty_bits shift)
+      (provide
+            (= (:size result) ty_bits)
+            (= (:amount result) shift)
+            (= (:lane_size_in_bits result) ty_bits)
+      )
+)
 
 ;; Constructs an FPUOpRIMod.Sli* given the size in bits of the value (or lane)
 ;; and the amount to shift by.
 (decl fpu_op_ri_sli (u8 u8) FPUOpRIMod)
 (extern constructor fpu_op_ri_sli fpu_op_ri_sli)
+(spec (fpu_op_ri_sli ty_bits shift)
+      (provide
+            (= (:size result) ty_bits)
+            (= (:amount result) shift)
+            (= (:lane_size_in_bits result) ty_bits)
+      )
+)
 
 (decl pure partial lshr_from_u64 (Type u64) ShiftOpAndAmt)
 (extern constructor lshr_from_u64 lshr_from_u64)
 
 (decl pure partial lshl_from_imm64 (Type Imm64) ShiftOpAndAmt)
+(spec (lshl_from_imm64 ty imm)
+      (provide
+            (= (:op result) (ALUOp.Lsl))
+            (= (:amt result)
+                  ; imm & (ty - 1)
+                  (bvand
+                        (extract 7 0 imm)
+                        (bvsub (int2bv 8 (:bits ty)) #x01)
+                  )
+            )
+      )
+      (match
+            ; imm < 64
+            (bvult imm #x0000000000000040)
+            ; ty <= 255
+            (<= (:bits ty) 255)
+      )
+)
 (extern constructor lshl_from_imm64 lshl_from_imm64)
 
 (decl pure partial lshl_from_u64 (Type u64) ShiftOpAndAmt)
@@ -1765,6 +2446,13 @@
 
 (decl integral_ty (Type) Type)
 (extern extractor integral_ty integral_ty)
+(spec (integral_ty ty)
+      (provide (= result ty))
+      (match (or
+            (= (:bits result) 8)
+            (= (:bits result) 16)
+            (= (:bits result) 32)
+            (= (:bits result) 64))))
 
 (decl valid_atomic_transaction (Type) Type)
 (extern extractor valid_atomic_transaction valid_atomic_transaction)
@@ -1776,45 +2464,165 @@
 (extern constructor is_zero_uimm12 is_zero_uimm12)
 
 ;; Helper to go directly from a `Value`, when it's an `iconst`, to an `Imm12`.
+(spec (imm12_from_value imm12)
+      (provide
+            (=
+                  (zero_ext 128 result)
+                  (zero_ext 128
+                        (if (:shift12 imm12)
+                              (concat (:bits imm12) #x000)
+                              (concat #x000 (:bits imm12))
+                        )
+                  )
+            )
+      )
+      (match
+            (let
+                  (
+                        (width 128)
+                        (r (zero_ext width result))
+                  )
+                  (or
+                        (= r (bvand r (zero_ext width #x000fff)))
+                        (= r (bvand r (zero_ext width #xfff000)))
+                  )
+            )
+      )
+)
 (decl imm12_from_value (Imm12) Value)
 (extractor
   (imm12_from_value n)
-  (iconst (u64_from_imm64 (imm12_from_u64 n))))
+  (iconst _ (u64_from_imm64 (imm12_from_u64 n))))
 
 ;; Conceptually the same as `imm12_from_value`, but tries negating the constant
 ;; value (first sign-extending to handle narrow widths).
 (decl pure partial imm12_from_negated_value (Value) Imm12)
-(rule
-  (imm12_from_negated_value (has_type ty (iconst n)))
+(rule imm12_from_negated_value
+  (imm12_from_negated_value (has_type ty (iconst _ n)))
   (if-let (imm12_from_u64 imm) (i64_as_u64 (i64_neg (i64_sextend_imm64 ty n))))
   imm)
+(attr imm12_from_negated_value (veri chain))
 
 ;; Helper type to represent a value and an extend operation fused together.
 (type ExtendedValue extern (enum))
+(model ExtendedValue (type
+      (struct
+            (val (named Value))
+            (extend (named ExtendOp))
+      )
+))
+
+(macro (extend_op_src_width extend)
+      (match extend
+            ((UXTB) 8)
+            ((UXTH) 16)
+            ((UXTW) 32)
+            ((UXTX) 64)
+            ((SXTB) 8)
+            ((SXTH) 16)
+            ((SXTW) 32)
+            ((SXTX) 64)
+      )
+)
+
+(macro (extend_op_signed extend)
+      (match extend
+            ((UXTB) false)
+            ((UXTH) false)
+            ((UXTW) false)
+            ((UXTX) false)
+            ((SXTB) true)
+            ((SXTH) true)
+            ((SXTW) true)
+            ((SXTX) true)
+      )
+)
+
+(macro (is_zero_ext dst src)
+      (and
+            (>= (widthof dst) (widthof src))
+            (= dst (conv_to (widthof dst) (zero_ext 64 src)))
+      )
+)
+
+(macro (is_sign_ext dst src)
+      (and
+            (>= (widthof dst) (widthof src))
+            (= dst (conv_to (widthof dst) (sign_ext 64 src)))
+      )
+)
+
+(macro (is_ext dst src) (or (is_zero_ext! dst src) (is_sign_ext! dst src)))
+
 (decl extended_value_from_value (ExtendedValue) Value)
 (extern extractor extended_value_from_value extended_value_from_value)
+(spec (extended_value_from_value x)
+      ; Match when the result can be represented as an extend.
+      (match
+            (or
+                  (with (b) (is_ext! result (as b (bv 8))))
+                  (with (h) (is_ext! result (as h (bv 16))))
+                  (with (w) (is_ext! result (as w (bv 32))))
+                  (with (x) (is_ext! result (as x (bv 64))))
+            )
+      )
+
+      ; Determine the ExtendedValue parameters.
+      (provide
+            ; Width of the input.
+            (= (widthof (:val x)) (extend_op_src_width! (:extend x)))
+
+            ; Result equals the extension.
+            (if (extend_op_signed! (:extend x))
+                  (is_sign_ext! result (:val x))
+                  (is_zero_ext! result (:val x))
+            )
+      )
+)
+(instantiate extended_value_from_value
+      ((args (struct (val (bv  8)) (extend (named ExtendOp)))) (ret (named Value)))
+      ((args (struct (val (bv 16)) (extend (named ExtendOp)))) (ret (named Value)))
+      ((args (struct (val (bv 32)) (extend (named ExtendOp)))) (ret (named Value)))
+      ((args (struct (val (bv 64)) (extend (named ExtendOp)))) (ret (named Value)))
+)
 
 ;; Constructors used to poke at the fields of an `ExtendedValue`.
 (decl put_extended_in_reg (ExtendedValue) Reg)
 (extern constructor put_extended_in_reg put_extended_in_reg)
+(spec (put_extended_in_reg x)
+      (provide (= result (conv_to (widthof result) (:val x))))
+)
+
 (decl get_extended_op (ExtendedValue) ExtendOp)
 (extern constructor get_extended_op get_extended_op)
+(spec (get_extended_op x) (provide (= result (:extend x))))
 
 (decl nzcv (bool bool bool bool) NZCV)
 (extern constructor nzcv nzcv)
+(spec (nzcv n z c v)
+      (provide
+            (= (:N result) (bool2bit! n))
+            (= (:Z result) (bool2bit! z))
+            (= (:C result) (bool2bit! c))
+            (= (:V result) (bool2bit! v))
+      )
+)
 
 (decl cond_br_zero (Reg) CondBrKind)
 (extern constructor cond_br_zero cond_br_zero)
+(spec (cond_br_zero r) (provide (= result (CondBrKind.Zero r))))
 
 (decl cond_br_not_zero (Reg) CondBrKind)
 (extern constructor cond_br_not_zero cond_br_not_zero)
 
 (decl cond_br_cond (Cond) CondBrKind)
 (extern constructor cond_br_cond cond_br_cond)
+(spec (cond_br_cond cc) (provide (= result (CondBrKind.Cond cc))))
 
 ;; Instruction creation helpers ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Helper for creating the zero register.
+(spec (zero_reg) (provide (= (zero_ext (widthof result) #b0) result)))
 (decl zero_reg () Reg)
 (extern constructor zero_reg zero_reg)
 
@@ -1828,6 +2636,7 @@
 (extern constructor writable_link_reg writable_link_reg)
 
 (decl writable_zero_reg () WritableReg)
+(spec (writable_zero_reg) (provide true)) ; zero register is just a write sink
 (extern constructor writable_zero_reg writable_zero_reg)
 
 (decl value_regs_zero () ValueRegs)
@@ -1874,7 +2683,7 @@
 
 ;; Helper for emitting `MInst.AluRRR` instructions.
 (decl alu_rrr (ALUOp Type Reg Reg) Reg)
-(rule (alu_rrr op ty src1 src2)
+(rule alu_rrr_to_emit (alu_rrr op ty src1 src2)
       (let ((dst WritableReg (temp_writable_reg $I64))
             (_ Unit (emit (MInst.AluRRR op (operand_size ty) dst src1 src2))))
         dst))
@@ -1978,7 +2787,7 @@
 
 ;; Helper for emitting `MInst.AluRRImm12` instructions.
 (decl alu_rr_imm12 (ALUOp Type Reg Imm12) Reg)
-(rule (alu_rr_imm12 op ty src imm)
+(rule alu_rr_imm12_to_emit (alu_rr_imm12 op ty src imm)
       (let ((dst WritableReg (temp_writable_reg $I64))
             (_ Unit (emit (MInst.AluRRImm12 op (operand_size ty) dst src imm))))
         dst))
@@ -1998,10 +2807,12 @@
       (ProducesFlags.ProducesFlagsSideEffect
        (MInst.AluRRRShift (ALUOp.SubS) size (writable_zero_reg)
         src1 src2 shift)))
+(attr cmp_rr_shift (veri chain))
 
 ;; Helper for emitting `cmp` instructions, setting flags, with an arithmetic right-shifted
 ;; second operand register.
 (decl cmp_rr_shift_asr (OperandSize Reg Reg u64) ProducesFlags)
+(attr cmp_rr_shift_asr (veri chain))
 (rule (cmp_rr_shift_asr size src1 src2 shift_amount)
       (if-let shift (ashr_from_u64 $I64 shift_amount))
       (ProducesFlags.ProducesFlagsSideEffect
@@ -2203,9 +3014,20 @@
             (_ Unit (emit (MInst.VecRRLong op dst src high_half))))
         dst))
 
-;; Helper for emitting `MInst.FpuCSel32` / `MInst.FpuCSel64`
+;; Helper for emitting `MInst.FpuCSel16` / `MInst.FpuCSel32` / `MInst.FpuCSel64`
 ;; instructions.
 (decl fpu_csel (Type Cond Reg Reg) ConsumesFlags)
+(rule (fpu_csel $F16 cond if_true if_false)
+        (fpu_csel $F32 cond if_true if_false))
+
+(attr rule fpu_csel_f16 (tag narrowfloat))
+(rule fpu_csel_f16 1 (fpu_csel $F16 cond if_true if_false)
+        (if-let $true (use_fp16))
+        (let ((dst WritableReg (temp_writable_reg $F16)))
+          (ConsumesFlags.ConsumesFlagsReturnsReg
+           (MInst.FpuCSel16 dst if_true if_false cond)
+           dst)))
+
 (rule (fpu_csel $F32 cond if_true if_false)
       (let ((dst WritableReg (temp_writable_reg $F32)))
         (ConsumesFlags.ConsumesFlagsReturnsReg
@@ -2246,10 +3068,17 @@
 
 ;; Helper for emitting `MInst.MovToFpu` instructions.
 (decl mov_to_fpu (Reg ScalarSize) Reg)
-(rule (mov_to_fpu x size)
+(attr mov_to_fpu (veri chain))
+(rule mov_to_fpu_base_case (mov_to_fpu x size)
       (let ((dst WritableReg (temp_writable_reg $I8X16))
             (_ Unit (emit (MInst.MovToFpu dst x size))))
         dst))
+(attr rule mov_to_fpu_16 (tag narrowfloat))
+(rule mov_to_fpu_16 1 (mov_to_fpu x (ScalarSize.Size16))
+        (if-let $false (use_fp16))
+        (let ((dst WritableReg (temp_writable_reg $I8X16))
+             (_ Unit (emit (MInst.MovToFpu dst x (ScalarSize.Size32)))))
+         dst))
 
 ;; Helper for emitting `MInst.FpuMoveFPImm` instructions.
 (decl fpu_move_fp_imm (ASIMDFPModImm ScalarSize) Reg)
@@ -2407,10 +3236,10 @@
 ;; Helpers for generating `add` instructions.
 
 (decl add (Type Reg Reg) Reg)
-(rule (add ty x y) (alu_rrr (ALUOp.Add) ty x y))
+(rule add_to_alu_rrr (add ty x y) (alu_rrr (ALUOp.Add) ty x y))
 
 (decl add_imm (Type Reg Imm12) Reg)
-(rule (add_imm ty x y) (alu_rr_imm12 (ALUOp.Add) ty x y))
+(rule add_imm_to_alu_rr_imm12 (add_imm ty x y) (alu_rr_imm12 (ALUOp.Add) ty x y))
 
 (decl add_extend (Type Reg ExtendedValue) Reg)
 (rule (add_extend ty x y) (alu_rr_extend_reg (ALUOp.Add) ty x y))
@@ -2704,6 +3533,9 @@
 (rule (and_vec x y size) (vec_rrr (VecALUOp.And) x y size))
 
 ;; Helpers for generating `eor` instructions.
+(decl eor (Type Reg Reg) Reg)
+(rule (eor ty x y) (alu_rrr (ALUOp.Eor) ty x y))
+
 (decl eor_vec (Reg Reg VectorSize) Reg)
 (rule (eor_vec x y size) (vec_rrr (VecALUOp.Eor) x y size))
 
@@ -2736,7 +3568,6 @@
 (rule (sshr_vec_imm x amt size) (vec_shift_imm (VecShiftImmOp.Sshr) amt x size))
 
 ;; Helpers for generating `rotr` instructions.
-
 (decl a64_rotr (Type Reg Reg) Reg)
 (rule (a64_rotr ty x y) (alu_rrr (ALUOp.RotR) ty x y))
 
@@ -2828,6 +3659,11 @@
       (let ((dst WritableReg (temp_writable_reg $I64))
             (_ Unit (emit (MInst.ULoad64 dst amode flags))))
         dst))
+(decl aarch64_fpuload16 (AMode MemFlags) Reg)
+(rule (aarch64_fpuload16 amode flags)
+      (let ((dst WritableReg (temp_writable_reg $F64))
+            (_ Unit (emit (MInst.FpuLoad16 dst amode flags))))
+        dst))
 (decl aarch64_fpuload32 (AMode MemFlags) Reg)
 (rule (aarch64_fpuload32 amode flags)
       (let ((dst WritableReg (temp_writable_reg $F64))
@@ -2864,6 +3700,9 @@
 (decl aarch64_store64 (AMode MemFlags Reg) SideEffectNoResult)
 (rule (aarch64_store64 amode flags val)
       (SideEffectNoResult.Inst (MInst.Store64 val amode flags)))
+(decl aarch64_fpustore16 (AMode MemFlags Reg) SideEffectNoResult)
+(rule (aarch64_fpustore16 amode flags val)
+      (SideEffectNoResult.Inst (MInst.FpuStore16 val amode flags)))
 (decl aarch64_fpustore32 (AMode MemFlags Reg) SideEffectNoResult)
 (rule (aarch64_fpustore32 amode flags val)
       (SideEffectNoResult.Inst (MInst.FpuStore32 val amode flags)))
@@ -2894,6 +3733,10 @@
     (Sign)
     (Zero)))
 
+(spec (ImmExtend.Zero)
+  (provide
+    (= result (ImmExtend.Zero))))
+
 ;; Arguments:
 ;; * Immediate type
 ;; * Way to extend the immediate value to the full width of the destination
@@ -2905,64 +3748,90 @@
 ;; all bits in the destination register in a defined state, i.e. smaller types
 ;; such as `I8` are either sign- or zero-extended.
 (decl imm (Type ImmExtend u64) Reg)
+(attr imm (veri chain))
 
 ;; Move wide immediate instructions; to simplify, we only match when we
 ;; are zero-extending the value.
-(rule 3 (imm (integral_ty ty) (ImmExtend.Zero) k)
+(rule imm_move_wide
+      3 (imm (integral_ty ty) (ImmExtend.Zero) k)
       (if-let n (move_wide_const_from_u64 ty k))
-      (movz n (operand_size ty)))
-(rule 2 (imm (integral_ty (ty_32_or_64 ty)) (ImmExtend.Zero) k)
+      (add_range_fact
+       (movz n (operand_size ty))
+       64 k k))
+(rule imm_move_wide_inverted
+      2 (imm (integral_ty (ty_32_or_64 ty)) (ImmExtend.Zero) k)
       (if-let n (move_wide_const_from_inverted_u64 ty k))
-      (movn n (operand_size ty)))
+      (add_range_fact
+       (movn n (operand_size ty))
+       64 k k))
 
 ;; Weird logical-instruction immediate in ORI using zero register; to simplify,
 ;; we only match when we are zero-extending the value.
-(rule 1 (imm (integral_ty ty) (ImmExtend.Zero) k)
+(rule imm_zero_extend_imm_logic
+      1 (imm (integral_ty ty) (ImmExtend.Zero) k)
       (if-let n (imm_logic_from_u64 ty k))
-      (orr_imm ty (zero_reg) n))
+      (if-let m (imm_size_from_type ty))
+      (add_range_fact
+       (orr_imm ty (zero_reg) n)
+       m k k))
 
 (decl load_constant64_full (Type ImmExtend u64) Reg)
 (extern constructor load_constant64_full load_constant64_full)
+(spec (load_constant64_full ty extend value)
+      (provide
+            (= result (match extend
+                  ((Sign) (sign_ext 64 (conv_to (:bits ty) value)))
+                  ((Zero) (zero_ext 64 (conv_to (:bits ty) value)))
+            ))
+      )
+)
 
 ;; Fallback for integral 64-bit constants
-(rule (imm (integral_ty ty) extend n)
+(rule imm_load_constant64_full (imm (integral_ty ty) extend n)
       (load_constant64_full ty extend n))
 
 ;; Sign extension helpers ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Place a `Value` into a register, sign extending it to 32-bits
+(attr put_in_reg_sext32 (veri chain))
 (decl put_in_reg_sext32 (Value) Reg)
-(rule -1 (put_in_reg_sext32 val @ (value_type (fits_in_32 ty)))
+(attr put_in_reg_sext32 (veri chain))
+(rule put_in_reg_sext32_extend
+      -1 (put_in_reg_sext32 val @ (value_type (fits_in_32 ty)))
       (extend val $true (ty_bits ty) 32))
 
 ;; 32/64-bit passthrough.
-(rule (put_in_reg_sext32 val @ (value_type $I32)) val)
-(rule (put_in_reg_sext32 val @ (value_type $I64)) val)
+(rule put_in_reg_sext32_passthrough32 (put_in_reg_sext32 val @ (value_type $I32)) val)
+(rule put_in_reg_sext32_passthrough64 (put_in_reg_sext32 val @ (value_type $I64)) val)
 
 ;; Place a `Value` into a register, zero extending it to 32-bits
 (decl put_in_reg_zext32 (Value) Reg)
-(rule -1 (put_in_reg_zext32 val @ (value_type (fits_in_32 ty)))
+(attr put_in_reg_zext32 (veri chain))
+(rule put_in_reg_zext32_extend
+      -1 (put_in_reg_zext32 val @ (value_type (fits_in_32 ty)))
       (extend val $false (ty_bits ty) 32))
 
 ;; 32/64-bit passthrough.
-(rule (put_in_reg_zext32 val @ (value_type $I32)) val)
-(rule (put_in_reg_zext32 val @ (value_type $I64)) val)
+(rule put_in_reg_zext32_passthrough32 (put_in_reg_zext32 val @ (value_type $I32)) val)
+(rule put_in_reg_zext32_passthrough64 (put_in_reg_zext32 val @ (value_type $I64)) val)
 
 ;; Place a `Value` into a register, sign extending it to 64-bits
 (decl put_in_reg_sext64 (Value) Reg)
-(rule 1 (put_in_reg_sext64 val @ (value_type (fits_in_32 ty)))
+(attr put_in_reg_sext64 (veri chain))
+(rule put_in_reg_sext64_extend 1 (put_in_reg_sext64 val @ (value_type (fits_in_32 ty)))
       (extend val $true (ty_bits ty) 64))
 
 ;; 64-bit passthrough.
-(rule (put_in_reg_sext64 val @ (value_type $I64)) val)
+(rule put_in_reg_sext64_passthrough (put_in_reg_sext64 val @ (value_type $I64)) val)
 
 ;; Place a `Value` into a register, zero extending it to 64-bits
 (decl put_in_reg_zext64 (Value) Reg)
-(rule 1 (put_in_reg_zext64 val @ (value_type (fits_in_32 ty)))
+(attr put_in_reg_zext64 (veri chain))
+(rule put_in_reg_zext64_extend 1 (put_in_reg_zext64 val @ (value_type (fits_in_32 ty)))
       (extend val $false (ty_bits ty) 64))
 
 ;; 64-bit passthrough.
-(rule (put_in_reg_zext64 val @ (value_type $I64)) val)
+(rule put_in_reg_zext64_passthrough (put_in_reg_zext64 val @ (value_type $I64)) val)
 
 ;; Misc instruction helpers ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
@@ -2972,29 +3841,58 @@
         reg))
 
 (decl size_from_ty (Type) OperandSize)
-(rule 1 (size_from_ty (fits_in_32 _ty)) (OperandSize.Size32))
-(rule (size_from_ty $I64) (OperandSize.Size64))
+(spec (size_from_ty ty)
+      (provide
+            (= result (if (<= (:bits ty) 32) (OperandSize.Size32) (OperandSize.Size64))))
+      (require
+            (or
+                  (= (:bits ty) 8)
+                  (= (:bits ty) 16)
+                  (= (:bits ty) 32)
+                  (= (:bits ty) 64))))
+(rule size_from_ty_32 1 (size_from_ty (fits_in_32 _ty)) (OperandSize.Size32))
+(rule size_from_ty_64 (size_from_ty $I64) (OperandSize.Size64))
 
 ;; Check for signed overflow. The only case is min_value / -1.
 ;; The following checks must be done in 32-bit or 64-bit, depending
 ;; on the input type.
-(decl trap_if_div_overflow (Type Reg Reg) Reg)
-(rule (trap_if_div_overflow ty x y)
+(decl trap_if_div_overflow (Type Reg Reg Reg) Reg)
+(attr trap_if_div_overflow (veri chain))
+(rule (trap_if_div_overflow ty xcheck x y)
       (let (
           ;; Check RHS is -1.
-          (_ Unit (emit (MInst.AluRRImm12 (ALUOp.AddS) (operand_size ty) (writable_zero_reg) y (u8_into_imm12 1))))
+          (check_rhs MInst (MInst.AluRRImm12 (ALUOp.AddS) (operand_size ty) (writable_zero_reg) y (u8_into_imm12 1)))
 
           ;; Check LHS is min_value, by subtracting 1 and branching if
           ;; there is overflow.
-          (_ Unit (emit (MInst.CCmpImm (size_from_ty ty)
-                                       x
-                                       (u8_into_uimm5 1)
-                                       (nzcv $false $false $false $false)
-                                       (Cond.Eq))))
-          (_ Unit (emit (MInst.TrapIf (cond_br_cond (Cond.Vs))
-                                      (trap_code_integer_overflow))))
+          (check_lhs MInst (MInst.CCmpImm (size_from_ty ty)
+                                    xcheck
+                                    (u8_into_uimm5 1)
+                                    (nzcv $false $false $false $false)
+                                    (Cond.Eq)))
+          (trap_if MInst (MInst.TrapIf (cond_br_cond (Cond.Vs))
+                                 (trap_code_integer_overflow)))
         )
-        x))
+        (with_flags_reg
+            (ProducesFlags.ProducesFlagsTwiceSideEffect check_rhs check_lhs)
+            (ConsumesFlags.ConsumesFlagsReturnsReg trap_if x)
+        )))
+
+;; In the cases narrower than a register width, subtracting 1 from the
+;; min_value will not cause overflow (e.g., I8's min_value of -128 stored in
+;; a 32-bit register produces -129 with no overflow). However, if we left shift
+;; x by (32 - ty), we then produce the 32-bit min_value for the respective min
+;; values of I8 and I16.
+;; E.g., I8's 0x00000080 left-shifted by 24 is 0x80000000, which overflows.
+(decl intmin_check (Type Reg) Reg)
+(attr intmin_check (veri chain))
+
+(attr rule intmin_check_fits_in_16 (veri priority))
+(rule intmin_check_fits_in_16 (intmin_check (fits_in_16 ty) x)
+      (alu_rr_imm_shift (ALUOp.Lsl) ty x (imm_shift_from_u8 (diff_from_32 ty))))
+
+;; In the I32 or I64 case, checking x itself against the min_value is fine.
+(rule -1 (intmin_check ty x) x)
 
 ;; Check for unsigned overflow.
 (decl trap_if_overflow (ProducesFlags TrapCode) Reg)
@@ -3005,47 +3903,51 @@
           (MInst.TrapIf (cond_br_cond (Cond.Hs)) tc))))
 
 (decl sink_atomic_load (Inst) Reg)
-(rule (sink_atomic_load x @ (atomic_load _ addr))
+(rule (sink_atomic_load x @ (atomic_load _ _ addr))
       (let ((_ Unit (sink_inst x)))
            (put_in_reg addr)))
+(attr sink_atomic_load (veri chain))
 
 ;; Helper for generating either an `AluRRR`, `AluRRRShift`, or `AluRRImmLogic`
 ;; instruction depending on the input. Note that this requires that the `ALUOp`
 ;; specified is commutative.
 (decl alu_rs_imm_logic_commutative (ALUOp Type Value Value) Reg)
+(attr alu_rs_imm_logic_commutative (veri chain))
 
 ;; Base case of operating on registers.
 (rule -1 (alu_rs_imm_logic_commutative op ty x y)
       (alu_rrr op ty x y))
 
 ;; Special cases for when one operand is a constant.
-(rule (alu_rs_imm_logic_commutative op ty x (iconst k))
+(rule (alu_rs_imm_logic_commutative op ty x (iconst _ k))
       (if-let imm (imm_logic_from_imm64 ty k))
       (alu_rr_imm_logic op ty x imm))
-(rule 1 (alu_rs_imm_logic_commutative op ty (iconst k) x)
+(rule 1 (alu_rs_imm_logic_commutative op ty (iconst _ k) x)
       (if-let imm (imm_logic_from_imm64 ty k))
       (alu_rr_imm_logic op ty x imm))
 
 ;; Special cases for when one operand is shifted left by a constant.
-(rule (alu_rs_imm_logic_commutative op ty x (ishl y (iconst k)))
+(rule (alu_rs_imm_logic_commutative op ty x (ishl _ y (iconst _ k)))
       (if-let amt (lshl_from_imm64 ty k))
       (alu_rrr_shift op ty x y amt))
-(rule 1 (alu_rs_imm_logic_commutative op ty (ishl x (iconst k)) y)
+(rule 1 (alu_rs_imm_logic_commutative op ty (ishl _ x (iconst _ k)) y)
       (if-let amt (lshl_from_imm64 ty k))
       (alu_rrr_shift op ty y x amt))
 
 ;; Same as `alu_rs_imm_logic_commutative` above, except that it doesn't require
 ;; that the operation is commutative.
 (decl alu_rs_imm_logic (ALUOp Type Value Value) Reg)
+(attr alu_rs_imm_logic (veri chain))
 (rule -1 (alu_rs_imm_logic op ty x y)
       (alu_rrr op ty x y))
-(rule (alu_rs_imm_logic op ty x (iconst k))
+(rule (alu_rs_imm_logic op ty x (iconst _ k))
       (if-let imm (imm_logic_from_imm64 ty k))
       (alu_rr_imm_logic op ty x imm))
-(rule (alu_rs_imm_logic op ty x (ishl y (iconst k)))
+(rule (alu_rs_imm_logic op ty x (ishl _ y (iconst _ k)))
       (if-let amt (lshl_from_imm64 ty k))
       (alu_rrr_shift op ty x y amt))
 
+
 ;; Helper for generating i128 bitops which simply do the same operation to the
 ;; hi/lo registers.
 ;;
@@ -3063,6 +3965,7 @@
         (value_regs
           (alu_rrr op ty x_lo y_lo)
           (alu_rrr op ty x_hi y_hi))))
+(attr rule i128_alu_bitop (tag i128))
 
 ;; Helper for emitting `MInst.VecLoadReplicate` instructions.
 (decl ld1r (Reg VectorSize MemFlags) Reg)
@@ -3093,16 +3996,21 @@
 ;; mid-end optimizations that fold constants into load/store immediate offsets
 ;; instead, but for now each backend needs to do this.
 (decl amode (Type Value i32) AMode)
-(rule 0 (amode ty val offset)
+(attr amode (veri chain))
+(rule amode_base_case
+      0 (amode ty val offset)
         (amode_no_more_iconst ty val offset))
-(rule 1 (amode ty (iadd x (iconst (simm32 y))) offset)
+(rule amode_iadd_const_right
+      1 (amode ty (iadd _ x (i32_from_iconst y)) offset)
         (if-let new_offset (s32_add_fallible y offset))
         (amode_no_more_iconst ty x new_offset))
-(rule 2 (amode ty (iadd (iconst (simm32 x)) y) offset)
+(rule amode_iadd_const_left
+      2 (amode ty (iadd _ (i32_from_iconst x) y) offset)
         (if-let new_offset (s32_add_fallible x offset))
         (amode_no_more_iconst ty y new_offset))
 
 (decl amode_no_more_iconst (Type Value i32) AMode)
+(attr amode_no_more_iconst (veri chain))
 ;; Base case: move the `offset` into a register and add it to `val` via the
 ;; amode
 (rule 0 (amode_no_more_iconst ty val offset)
@@ -3110,10 +4018,12 @@
 
 ;; Optimize cases where the `offset` provided fits into a immediates of
 ;; various kinds of addressing modes.
-(rule 1 (amode_no_more_iconst ty val offset)
+(rule amode_no_more_iconst_unscaled
+      1 (amode_no_more_iconst ty val offset)
         (if-let simm9 (simm9_from_i64 offset))
         (AMode.Unscaled val simm9))
-(rule 2 (amode_no_more_iconst ty val offset)
+(rule amode_no_more_iconst_unsigned_offset
+      2 (amode_no_more_iconst ty val offset)
         (if-let uimm12 (uimm12_scaled_from_i64 offset ty))
         (AMode.UnsignedOffset val uimm12))
 
@@ -3124,15 +4034,20 @@
 ;; instructions. Constants on the other hand added to the amode represent only
 ;; a single instruction folded in, so fewer instructions should be generated
 ;; with these higher priority than the rules above.
-(rule 3 (amode_no_more_iconst ty (iadd x y) offset)
+(rule amode_no_more_iconst_iadd
+      3 (amode_no_more_iconst ty (iadd _ x y) offset)
         (AMode.RegReg (amode_add x offset) y))
-(rule 4 (amode_no_more_iconst ty (iadd x (uextend y @ (value_type $I32))) offset)
+(rule amode_no_more_iconst_iadd_uextend_right
+      4 (amode_no_more_iconst ty (iadd _ x (uextend _ y @ (value_type $I32))) offset)
         (AMode.RegExtended (amode_add x offset) y (ExtendOp.UXTW)))
-(rule 4 (amode_no_more_iconst ty (iadd x (sextend y @ (value_type $I32))) offset)
+(rule amode_no_more_iconst_iadd_sextend_right
+      4 (amode_no_more_iconst ty (iadd _ x (sextend _ y @ (value_type $I32))) offset)
         (AMode.RegExtended (amode_add x offset) y (ExtendOp.SXTW)))
-(rule 5 (amode_no_more_iconst ty (iadd (uextend x @ (value_type $I32)) y) offset)
+(rule amode_no_more_iconst_iadd_uextend_left
+      5 (amode_no_more_iconst ty (iadd _ (uextend _ x @ (value_type $I32)) y) offset)
         (AMode.RegExtended (amode_add y offset) x (ExtendOp.UXTW)))
-(rule 5 (amode_no_more_iconst ty (iadd (sextend x @ (value_type $I32)) y) offset)
+(rule amode_no_more_iconst_iadd_sextend_left
+      5 (amode_no_more_iconst ty (iadd _ (sextend _ x @ (value_type $I32)) y) offset)
         (AMode.RegExtended (amode_add y offset) x (ExtendOp.SXTW)))
 
 ;; `RegScaled*` rules where this matches an addition of an "index register" to a
@@ -3142,30 +4057,40 @@
 ;; Note that this can additionally bundle an extending operation but the
 ;; extension must happen before the shift. This will pattern-match the shift
 ;; first and then if that succeeds afterwards try to find an extend.
-(rule 6 (amode_no_more_iconst ty (iadd x (ishl y (iconst (u64_from_imm64 n)))) offset)
+(rule amode_no_more_iconst_reg_scaled_right
+      6 (amode_no_more_iconst ty (iadd _ x (ishl _ y (iconst _ (u64_from_imm64 n)))) offset)
         (if-let $true (u64_eq (ty_bytes ty) (u64_shl 1 n)))
-        (amode_reg_scaled (amode_add x offset) y ty))
-(rule 7 (amode_no_more_iconst ty (iadd (ishl y (iconst (u64_from_imm64 n))) x) offset)
+        (amode_reg_scaled (amode_add x offset) y))
+(rule amode_no_more_iconst_reg_scaled_left
+      7 (amode_no_more_iconst ty (iadd _ (ishl _ y (iconst _ (u64_from_imm64 n))) x) offset)
         (if-let $true (u64_eq (ty_bytes ty) (u64_shl 1 n)))
-        (amode_reg_scaled (amode_add x offset) y ty))
-
-(decl amode_reg_scaled (Reg Value Type) AMode)
-(rule 0 (amode_reg_scaled base index ty)
-        (AMode.RegScaled base index ty))
-(rule 1 (amode_reg_scaled base (uextend index @ (value_type $I32)) ty)
-        (AMode.RegScaledExtended base index ty (ExtendOp.UXTW)))
-(rule 2 (amode_reg_scaled base (sextend index @ (value_type $I32)) ty)
-        (AMode.RegScaledExtended base index ty (ExtendOp.SXTW)))
+        (amode_reg_scaled (amode_add x offset) y))
+
+(decl amode_reg_scaled (Reg Value) AMode)
+(attr amode_reg_scaled (veri chain))
+(rule amode_reg_scaled_base
+      0 (amode_reg_scaled base index)
+        (AMode.RegScaled base index))
+(rule amode_reg_scaled_uextend
+      1 (amode_reg_scaled base (uextend _ index @ (value_type $I32)))
+        (AMode.RegScaledExtended base index (ExtendOp.UXTW)))
+(rule amode_reg_scaled_sextend
+      1 (amode_reg_scaled base (sextend _ index @ (value_type $I32)))
+        (AMode.RegScaledExtended base index (ExtendOp.SXTW)))
 
 ;; Helper to add a 32-bit signed immediate to the register provided. This will
 ;; select an appropriate `add` instruction to use.
 (decl amode_add (Reg i32) Reg)
-(rule 0 (amode_add x y)
+(attr amode_add (veri chain))
+(rule amode_add_base
+      0 (amode_add x y)
         (add $I64 x (imm $I64 (ImmExtend.Zero) (i64_as_u64 y))))
-(rule 1 (amode_add x y)
+(rule amode_add_imm12
+      1 (amode_add x y)
         (if-let (imm12_from_u64 imm12) (i64_as_u64 y))
         (add_imm $I64 x imm12))
-(rule 2 (amode_add x 0) x)
+(rule amode_add_zero
+      2 (amode_add x 0) x)
 
 ;; Creates a `PairAMode` for the `Value` provided plus the `i32` constant
 ;; offset provided.
@@ -3186,13 +4111,40 @@
 
 (decl pure partial uimm12_scaled_from_i64 (i64 Type) UImm12Scaled)
 (extern constructor uimm12_scaled_from_i64 uimm12_scaled_from_i64)
+(spec (uimm12_scaled_from_i64 value ty)
+      (match
+            (let
+                  (
+                        (scale (bits2bytes! (int2bv 64 (:bits ty))))
+                        (limit (bvmul (int2bv 64 4095) scale))
+                  )
+                  (and
+                        (bvsge value (bvzero! 64))
+                        (bvsle value limit)
+                        (bv_is_zero! (bvand value (bvsub scale (bvone! 64))))
+                  )
+            )
+      )
+      (provide
+            (= result (extract 11 0 (bvudiv value (bits2bytes! (int2bv 64 (:bits ty))))))
+      )
+)
 
 (decl pure partial simm9_from_i64 (i64) SImm9)
 (extern constructor simm9_from_i64 simm9_from_i64)
-
+(spec (simm9_from_i64 value)
+      (provide (= value (sign_ext 64 result)))
+      (match
+            ; value >= -256
+            (bvsge value (bvneg (int2bv 64 256)))
+            ; value <= 255
+            (bvsle value (int2bv 64 255))
+      )
+)
 
 (decl sink_load_into_addr (Type Inst) Reg)
-(rule (sink_load_into_addr ty x @ (load _ addr (offset32 offset)))
+(attr sink_load_into_addr (veri chain))
+(rule (sink_load_into_addr ty x @ (load _ _ addr (offset32 offset)))
       (let ((_ Unit (sink_inst x)))
         (add_imm_to_addr addr (i64_as_u64 offset))))
 
@@ -3201,20 +4153,51 @@
 (rule 1 (add_imm_to_addr val (imm12_from_u64 imm)) (add_imm $I64 val imm))
 (rule 0 (add_imm_to_addr val offset) (add $I64 val (imm $I64 (ImmExtend.Zero) offset)))
 
+;; Lower a constant f16.
+;;
+;; Note that we must make sure that all bits outside the lowest 16 are set to 0
+;; because this function is also used to load wider constants (that have zeros
+;; in their most significant bits).
+(decl constant_f16 (u16) Reg)
+(rule 3 (constant_f16 n)
+        (if-let $false (use_fp16))
+        (lower_constant_f32 n))
+(rule 0 (constant_f16 n) (lower_constant_f16 n))
+
+(decl lower_constant_f16 (u16) Reg)
+(attr lower_constant_f16 (veri chain))
+(rule 2 (lower_constant_f16 0)
+        (vec_dup_imm (asimd_mov_mod_imm_zero (ScalarSize.Size32))
+                     $false
+                     (VectorSize.Size32x2)))
+(rule lower_constant_f16_fpu_move_fp_imm 1 (lower_constant_f16 n)
+        (if-let imm (asimd_fp_mod_imm_from_u64 n (ScalarSize.Size16)))
+        (fpu_move_fp_imm imm (ScalarSize.Size16)))
+(rule lower_constant_f16_mov_to_fpu (lower_constant_f16 n)
+      (mov_to_fpu (imm $I16 (ImmExtend.Zero) n) (ScalarSize.Size16)))
+
 ;; Lower a constant f32.
 ;;
 ;; Note that we must make sure that all bits outside the lowest 32 are set to 0
 ;; because this function is also used to load wider constants (that have zeros
 ;; in their most significant bits).
 (decl constant_f32 (u32) Reg)
-(rule 2 (constant_f32 0)
+(attr constant_f32 (veri chain))
+(rule constant_f32_lower_constant_f16 1 (constant_f32 (u32_as_u16 n))
+        (if-let $true (use_fp16))
+        (lower_constant_f16 n))
+(rule constant_f32_base_case 0 (constant_f32 n) (lower_constant_f32 n))
+
+(decl lower_constant_f32 (u32) Reg)
+(attr lower_constant_f32 (veri chain))
+(rule 3 (lower_constant_f32 0)
         (vec_dup_imm (asimd_mov_mod_imm_zero (ScalarSize.Size32))
                      $false
                      (VectorSize.Size32x2)))
-(rule 1 (constant_f32 n)
+(rule lower_constant_f32_fpu_move_fp_imm 2 (lower_constant_f32 n)
         (if-let imm (asimd_fp_mod_imm_from_u64 n (ScalarSize.Size32)))
         (fpu_move_fp_imm imm (ScalarSize.Size32)))
-(rule (constant_f32 n)
+(rule (lower_constant_f32 n)
       (mov_to_fpu (imm $I32 (ImmExtend.Zero) n) (ScalarSize.Size32)))
 
 ;; Lower a constant f64.
@@ -3225,6 +4208,7 @@
 ;; TODO: Treat as half of a 128 bit vector and consider replicated patterns.
 ;; Scalar MOVI might also be an option.
 (decl constant_f64 (u64) Reg)
+(attr constant_f64 (veri chain))
 (rule 4 (constant_f64 0)
         (vec_dup_imm (asimd_mov_mod_imm_zero (ScalarSize.Size32))
                      $false
@@ -3242,6 +4226,10 @@
 ;; Tests whether the low 32 bits in the input are all zero.
 (decl u64_low32_bits_unset (u64) u64)
 (extern extractor u64_low32_bits_unset u64_low32_bits_unset)
+(spec (u64_low32_bits_unset n)
+      (match (bv_is_zero! (bvand result #x00000000ffffffff)))
+      (provide (= n result))
+)
 
 ;; Lower a constant f128.
 (decl constant_f128 (u128) Reg)
@@ -3313,11 +4301,46 @@
 ;; TODO: Port lower_fp_condcode() to ISLE.
 (extern constructor fp_cond_code fp_cond_code)
 
+;; Ported from lower_fp_condcode. Note nontrivial mapping for lt and lte.
+(spec (fp_cond_code cc)
+      (provide
+            (= result
+                  (match cc
+                        ((Equal) (Cond.Eq))
+                        ((NotEqual) (Cond.Ne))
+                        ((GreaterThanOrEqual) (Cond.Ge))
+                        ((GreaterThan) (Cond.Gt))
+                        ((LessThanOrEqual) (Cond.Ls))
+                        ((LessThan) (Cond.Mi))
+                  )
+            )
+      )
+)
+
 ;; Lower an integer cond code.
 (decl cond_code (IntCC) Cond)
 ;; TODO: Port lower_condcode() to ISLE.
 (extern constructor cond_code cond_code)
 
+(spec (cond_code cc)
+      (provide
+            (= result
+                  (match cc
+                        ((Equal) (Cond.Eq))
+                        ((NotEqual) (Cond.Ne))
+                        ((SignedGreaterThanOrEqual) (Cond.Ge))
+                        ((SignedGreaterThan) (Cond.Gt))
+                        ((SignedLessThanOrEqual) (Cond.Le))
+                        ((SignedLessThan) (Cond.Lt))
+                        ((UnsignedGreaterThanOrEqual) (Cond.Hs))
+                        ((UnsignedGreaterThan) (Cond.Hi))
+                        ((UnsignedLessThanOrEqual) (Cond.Ls))
+                        ((UnsignedLessThan) (Cond.Lo))
+                  )
+            )
+      )
+)
+
 ;; Invert a condition code.
 (decl invert_cond (Cond) Cond)
 ;; TODO: Port cond.invert() to ISLE.
@@ -3473,7 +4496,7 @@
             ;; the frame record that corresponds to the current subroutine on
             ;; the stack; the presence of the record is guaranteed by the
             ;; `preserve_frame_pointers` setting.
-            (addr AMode (AMode.FPOffset 8 $I64))
+            (addr AMode (AMode.FPOffset 8))
             (_ Unit (emit (MInst.ULoad64 dst addr (mem_flags_trusted)))))
            dst))
 
@@ -3483,7 +4506,7 @@
       ;; the frame record. Furthermore, we can use LR as a scratch register
       ;; because the function will set it to the return address immediately
       ;; before returning.
-      (let ((addr AMode (AMode.FPOffset 8 $I64))
+      (let ((addr AMode (AMode.FPOffset 8))
             (lr WritableReg (writable_link_reg))
             (_ Unit (emit (MInst.ULoad64 lr addr (mem_flags_trusted))))
             (_ Unit (emit (MInst.Xpaclri))))
@@ -3494,20 +4517,22 @@
 (decl max_shift (Type) u8)
 (rule (max_shift $F64) 63)
 (rule (max_shift $F32) 31)
+(attr max_shift (veri chain))
 
 ;; Helper for generating `fcopysign` instruction sequences.
-
 (decl fcopy_sign (Reg Reg Type) Reg)
 (rule 1 (fcopy_sign x y (ty_scalar_float ty))
       (let ((dst WritableReg (temp_writable_reg $F64))
             (tmp Reg (fpu_rri (fpu_op_ri_ushr (ty_bits ty) (max_shift ty)) y))
             (_ Unit (emit (MInst.FpuRRIMod (fpu_op_ri_sli (ty_bits ty) (max_shift ty)) dst x tmp))))
        dst))
-(rule (fcopy_sign x y ty @ (multi_lane _ _))
+(rule fcopy_sign_vec (fcopy_sign x y ty @ (multi_lane _ _))
       (let ((dst WritableReg (temp_writable_reg $I8X16))
             (tmp Reg (ushr_vec_imm y (max_shift (lane_type ty)) (vector_size ty)))
             (_ Unit (emit (MInst.VecShiftImmMod (VecShiftImmModOp.Sli) dst x tmp (vector_size ty) (max_shift (lane_type ty))))))
        dst))
+(attr fcopy_sign (veri chain))
+(attr rule fcopy_sign_vec (tag vector))
 
 ;; Helpers for generating `MInst.FpuToInt` instructions.
 
@@ -3524,6 +4549,7 @@
 ;; Checks that the value is not less than the minimum bound,
 ;; accepting a boolean (whether the type is signed), input type,
 ;; output type, and registers containing the source and minimum bound.
+(attr fpu_to_int_underflow_check (veri chain))
 (decl fpu_to_int_underflow_check (bool Type Type Reg Reg) Reg)
 (rule (fpu_to_int_underflow_check $true $F32 (fits_in_16 out_ty) src min)
       (let ((r ValueRegs
@@ -3533,7 +4559,8 @@
                         (trap_code_integer_overflow))
                     src))))
        (value_regs_get r 0)))
-(rule (fpu_to_int_underflow_check $true $F64 (fits_in_32 out_ty) src min)
+(rule fpu_to_int_underflow_check_signed_f64_fits_in_32
+      (fpu_to_int_underflow_check $true $F64 (fits_in_32 out_ty) src min)
       (let ((r ValueRegs
                   (with_flags (fpu_cmp (ScalarSize.Size64) src min)
                    (ConsumesFlags.ConsumesFlagsReturnsReg
@@ -3541,6 +4568,7 @@
                         (trap_code_integer_overflow))
                     src))))
        (value_regs_get r 0)))
+(attr rule fpu_to_int_underflow_check_signed_f64_fits_in_32 (veri priority))
 (rule -1 (fpu_to_int_underflow_check $true in_ty _out_ty src min)
       (let ((r ValueRegs
                   (with_flags (fpu_cmp (scalar_size in_ty) src min)
@@ -3668,6 +4696,7 @@
        dst))
 
 (decl vec_cmp (Reg Reg Type Cond) Reg)
+(attr vec_cmp (tag vector))
 
 ;; Floating point Vs / Vc
 (rule (vec_cmp rn rm ty (Cond.Vc))
@@ -3761,7 +4790,8 @@
 (decl elf_tls_get_addr (ExternalName) Reg)
 (rule (elf_tls_get_addr name)
       (let ((dst WritableReg (temp_writable_reg $I64))
-            (_ Unit (emit (MInst.ElfTlsGetAddr name dst))))
+            (tmp WritableReg (temp_writable_reg $I64))
+            (_ Unit (emit (MInst.ElfTlsGetAddr (box_external_name name) dst tmp))))
         dst))
 
 (decl macho_tls_get_addr (ExternalName) Reg)
@@ -3780,31 +4810,38 @@
 
 ;; Materialize a `FlagsAndCC` into a boolean `ValueRegs`.
 (decl flags_and_cc_to_bool (FlagsAndCC) ValueRegs)
+(attr flags_and_cc_to_bool (veri chain))
 (rule (flags_and_cc_to_bool (FlagsAndCC.FlagsAndCC flags cc))
       (with_flags flags (materialize_bool_result (cond_code cc))))
 
 ;; Get the `ProducesFlags` out of a `FlagsAndCC`.
 (decl flags_and_cc_flags (FlagsAndCC) ProducesFlags)
+(attr flags_and_cc_flags (veri chain))
 (rule (flags_and_cc_flags (FlagsAndCC.FlagsAndCC flags _cc)) flags)
 
 ;; Get the `IntCC` out of a `FlagsAndCC`.
 (decl flags_and_cc_cc (FlagsAndCC) IntCC)
+(attr flags_and_cc_cc (veri chain))
 (rule (flags_and_cc_cc (FlagsAndCC.FlagsAndCC _flags cc)) cc)
 
 ;; Helpers for lowering `icmp` sequences.
 ;; `lower_icmp` contains shared functionality for lowering `icmp`
 ;; sequences, which `lower_icmp_into_{reg,flags}` extend from.
 (decl lower_icmp (IntCC Value Value Type) FlagsAndCC)
+(attr lower_icmp (veri chain))
 (decl lower_icmp_into_reg (IntCC Value Value Type Type) ValueRegs)
+(attr lower_icmp_into_reg (veri chain))
 (decl lower_icmp_into_flags (IntCC Value Value Type) FlagsAndCC)
 (decl lower_icmp_const (IntCC Value u64 Type) FlagsAndCC)
+(attr lower_icmp_const (veri chain))
 ;; For most cases, `lower_icmp_into_flags` is the same as `lower_icmp`,
 ;; except for some I128 cases (see below).
 (rule -1 (lower_icmp_into_flags cond x y ty) (lower_icmp cond x y ty))
 
 ;; Vectors.
 ;; `icmp` into flags for vectors is invalid.
-(rule 1 (lower_icmp_into_reg cond x y in_ty @ (multi_lane _ _) _out_ty)
+(rule lower_icmp_into_reg_vec
+      1 (lower_icmp_into_reg cond x y in_ty @ (multi_lane _ _) _out_ty)
       (let ((cond Cond (cond_code cond))
             (rn Reg (put_in_reg x))
             (rm Reg (put_in_reg y)))
@@ -3812,31 +4849,44 @@
 
 ;; Determines the appropriate extend op given the value type and the given ArgumentExtension.
 (decl lower_extend_op (Type ArgumentExtension) ExtendOp)
-(rule (lower_extend_op $I8 (ArgumentExtension.Sext)) (ExtendOp.SXTB))
-(rule (lower_extend_op $I16 (ArgumentExtension.Sext)) (ExtendOp.SXTH))
-(rule (lower_extend_op $I8 (ArgumentExtension.Uext)) (ExtendOp.UXTB))
-(rule (lower_extend_op $I16 (ArgumentExtension.Uext)) (ExtendOp.UXTH))
+(attr lower_extend_op (veri chain))
+(rule lower_extend_op_8s (lower_extend_op $I8 (ArgumentExtension.Sext)) (ExtendOp.SXTB))
+(rule lower_extend_op_16s (lower_extend_op $I16 (ArgumentExtension.Sext)) (ExtendOp.SXTH))
+(rule lower_extend_op_8u (lower_extend_op $I8 (ArgumentExtension.Uext)) (ExtendOp.UXTB))
+(rule lower_extend_op_16u (lower_extend_op $I16 (ArgumentExtension.Uext)) (ExtendOp.UXTH))
 
 ;; Integers <= 64-bits.
-(rule -2 (lower_icmp_into_reg cond rn rm in_ty out_ty)
+(rule lower_icmp_into_reg_int_to_64
+      -2 (lower_icmp_into_reg cond rn rm in_ty out_ty)
       (if (ty_int_ref_scalar_64 in_ty))
       (let ((cc Cond (cond_code cond)))
         (flags_and_cc_to_bool (lower_icmp cond rn rm in_ty))))
 
-(rule 1 (lower_icmp cond rn rm (fits_in_16 ty))
+(rule lower_icmp_16_signed
+      1 (lower_icmp cond rn rm (fits_in_16 ty))
       (if (signed_cond_code cond))
       (let ((rn Reg (put_in_reg_sext32 rn)))
       (flags_and_cc (cmp_extend (operand_size ty) rn rm (lower_extend_op ty (ArgumentExtension.Sext))) cond)))
-(rule -1 (lower_icmp cond rn (imm12_from_value rm) (fits_in_16 ty))
+(attr rule lower_icmp_16_signed (veri priority))
+
+(rule lower_icmp_16_imm12
+      -1 (lower_icmp cond rn (imm12_from_value rm) (fits_in_16 ty))
       (let ((rn Reg (put_in_reg_zext32 rn)))
       (flags_and_cc (cmp_imm (operand_size ty) rn rm) cond)))
-(rule -2 (lower_icmp cond rn rm (fits_in_16 ty))
+
+(rule lower_icmp_16_extend
+      -2 (lower_icmp cond rn rm (fits_in_16 ty))
       (let ((rn Reg (put_in_reg_zext32 rn)))
       (flags_and_cc (cmp_extend (operand_size ty) rn rm (lower_extend_op ty (ArgumentExtension.Uext))) cond)))
-(rule -3 (lower_icmp cond rn (u64_from_iconst c) ty)
+(attr rule lower_icmp_16_extend (veri priority))
+
+(rule lower_icmp_const
+      -3 (lower_icmp cond rn (u64_from_iconst c) ty)
       (if (ty_int_ref_scalar_64 ty))
       (lower_icmp_const cond rn c ty))
-(rule -4 (lower_icmp cond rn rm ty)
+
+(rule lower_icmp_base
+      -4 (lower_icmp cond rn rm ty)
       (if (ty_int_ref_scalar_64 ty))
       (flags_and_cc (cmp (operand_size ty) rn rm) cond))
 
@@ -3846,21 +4896,25 @@
 ;;         A >= B + 1
 ;;     ==> A - 1 >= B
 ;;     ==> A > B
-(rule (lower_icmp_const (IntCC.UnsignedGreaterThanOrEqual) a b ty)
+(rule lower_icmp_const_uge_odd
+      (lower_icmp_const (IntCC.UnsignedGreaterThanOrEqual) a b ty)
       (if (ty_int_ref_scalar_64 ty))
       (if-let $true (u64_is_odd b))
       (if-let (imm12_from_u64 imm) (u64_sub b 1))
   (flags_and_cc (cmp_imm (operand_size ty) a imm) (IntCC.UnsignedGreaterThan)))
-(rule (lower_icmp_const (IntCC.SignedGreaterThanOrEqual) a b ty)
+(rule lower_icmp_const_sge_odd
+      (lower_icmp_const (IntCC.SignedGreaterThanOrEqual) a b ty)
       (if (ty_int_ref_scalar_64 ty))
       (if-let $true (u64_is_odd b))
       (if-let (imm12_from_u64 imm) (u64_sub b 1))
   (flags_and_cc (cmp_imm (operand_size ty) a imm) (IntCC.SignedGreaterThan)))
 
-(rule -1 (lower_icmp_const cond rn (imm12_from_u64 c) ty)
+(rule lower_icmp_const_imm12
+      -1 (lower_icmp_const cond rn (imm12_from_u64 c) ty)
       (if (ty_int_ref_scalar_64 ty))
   (flags_and_cc (cmp_imm (operand_size ty) rn c) cond))
-(rule -2 (lower_icmp_const cond rn c ty)
+(rule lower_icmp_const_base
+      -2 (lower_icmp_const cond rn c ty)
       (if (ty_int_ref_scalar_64 ty))
   (flags_and_cc (cmp (operand_size ty) rn (imm ty (ImmExtend.Zero) c)) cond))
 
@@ -3889,10 +4943,14 @@
        (ccmp (OperandSize.Size64) lhs_hi rhs_hi
         (nzcv $false $false $false $false) (Cond.Eq) cmp_inst)))
 
-(rule (lower_icmp (IntCC.Equal) lhs rhs $I128)
+(rule lower_icmp_eq_i128
+      (lower_icmp (IntCC.Equal) lhs rhs $I128)
       (flags_and_cc (lower_icmp_i128_eq_ne lhs rhs) (IntCC.Equal)))
-(rule (lower_icmp (IntCC.NotEqual) lhs rhs $I128)
+(attr rule lower_icmp_eq_i128 (tag i128))
+(rule lower_icmp_ne_i128
+      (lower_icmp (IntCC.NotEqual) lhs rhs $I128)
       (flags_and_cc (lower_icmp_i128_eq_ne lhs rhs) (IntCC.NotEqual)))
+(attr rule lower_icmp_ne_i128 (tag i128))
 
 ;; cmp      lhs_lo, rhs_lo
 ;; cset     tmp1, unsigned_cond
@@ -3921,6 +4979,7 @@
         (MInst.CSet tmp2 cond)
         (MInst.CSel dst (Cond.Eq) tmp1 tmp2)
         (value_reg dst))))
+(attr rule lower_icmp_i128_consumer (tag i128))
 
 (decl lower_bmask (Type Type ValueRegs) ValueRegs)
 
@@ -4013,8 +5072,10 @@
 
 ;; Helpers for generating select instruction sequences.
 (decl lower_select (ProducesFlags Cond Type Value Value) ValueRegs)
-(rule 2 (lower_select flags cond (ty_scalar_float ty) rn rm)
+(rule 2 (lower_select flags cond (ty_scalar_float (fits_in_64 ty)) rn rm)
       (with_flags flags (fpu_csel ty cond rn rm)))
+(rule 4 (lower_select flags cond $F128 rn rm)
+      (with_flags flags (vec_csel cond rn rm)))
 (rule 3 (lower_select flags cond (ty_vec128 ty) rn rm)
       (with_flags flags (vec_csel cond rn rm)))
 (rule (lower_select flags cond ty rn rm)
@@ -4074,6 +5135,21 @@
       (ConsumesFlags.ConsumesFlagsSideEffect
        (MInst.CondBr taken not_taken kind)))
 
+;; Helper for emitting `MInst.TestBitAndBranch` instructions.
+(decl test_branch (TestBitAndBranchKind BranchTarget BranchTarget Reg u8) SideEffectNoResult)
+(rule (test_branch kind taken not_taken rn bit)
+      (SideEffectNoResult.Inst (MInst.TestBitAndBranch kind taken not_taken rn bit)))
+
+;; Helper for emitting `tbnz` instructions.
+(decl tbnz (BranchTarget BranchTarget Reg u8) SideEffectNoResult)
+(rule (tbnz taken not_taken rn bit)
+      (test_branch (TestBitAndBranchKind.NZ) taken not_taken rn bit))
+
+;; Helper for emitting `tbz` instructions.
+(decl tbz (BranchTarget BranchTarget Reg u8) SideEffectNoResult)
+(rule (tbz taken not_taken rn bit)
+      (test_branch (TestBitAndBranchKind.Z) taken not_taken rn bit))
+
 ;; Helper for emitting `MInst.MovToNZCV` instructions.
 (decl mov_to_nzcv (Reg) ProducesFlags)
 (rule (mov_to_nzcv rn)
@@ -4125,6 +5201,7 @@
 ;; Helper for creating a zero value `ASIMDMovModImm` immediate.
 (decl asimd_mov_mod_imm_zero (ScalarSize) ASIMDMovModImm)
 (extern constructor asimd_mov_mod_imm_zero asimd_mov_mod_imm_zero)
+(spec (asimd_mov_mod_imm_zero size) (provide (= (:imm result) #x00)))
 
 ;; Helper for fallibly creating an `ASIMDMovModImm` immediate from its parts.
 (decl pure partial asimd_mov_mod_imm_from_u64 (u64 ScalarSize) ASIMDMovModImm)
@@ -4134,6 +5211,88 @@
 (decl pure partial asimd_fp_mod_imm_from_u64 (u64 ScalarSize) ASIMDFPModImm)
 (extern constructor asimd_fp_mod_imm_from_u64 asimd_fp_mod_imm_from_u64)
 
+; Compute the 32-bit value that corresponds to an 8-bit ASIMDFPModImm encoding.
+(macro (asimd_fp_mod_imm_value32 imm)
+      (let (
+            ;  let imm = imm as u32;
+            (v       (zero_ext 32 imm))
+            ;  let b0_5 = imm & 0b111111;
+            (b0_5    (bvand v #x0000003f))
+            ;  let b6 = (imm >> 6) & 1;
+            (b6      (bvand (bvlshr_int! v 6) #x00000001))
+            ;  let b6_inv = b6 ^ 1;
+            (b6_inv  (bvxor b6 #x00000001))
+            ;  let b7 = (imm >> 7) & 1;
+            (b7      (bvand (bvlshr_int! v 7) #x00000001))
+      )
+      ;  b0_5 << 19 | (b6 * 0b11111) << 25 | b6_inv << 30 | b7 << 31
+      (bvor (bvshl_int! b0_5 19)
+      (bvor (bvshl_int! (bvmul b6 #x0000001f) 25)
+      (bvor (bvshl_int! b6_inv 30)
+            (bvshl_int! b7 31))))))
+
+; Compute the 64-bit value that corresponds to an 8-bit ASIMDFPModImm encoding.
+(macro (asimd_fp_mod_imm_value64 imm)
+      (let (
+            ; let imm = imm as u64;
+            (v       (zero_ext 64 imm))
+            ; let b0_5 = imm & 0b111111;
+            (b0_5    (bvand v #x000000000000003f))
+            ; let b6 = (imm >> 6) & 1;
+            (b6      (bvand (bvlshr_int! v 6) #x0000000000000001))
+            ; let b6_inv = b6 ^ 1;
+            (b6_inv  (bvxor b6 #x0000000000000001))
+            ; let b7 = (imm >> 7) & 1;
+            (b7      (bvand (bvlshr_int! v 7) #x0000000000000001))
+      )
+      ; b0_5 << 48 | (b6 * 0b11111111) << 54 | b6_inv << 62 | b7 << 63
+      (bvor (bvshl_int! b0_5 48)
+      (bvor (bvshl_int! (bvmul b6 #x00000000000000ff) 54)
+      (bvor (bvshl_int! b6_inv 62)
+            (bvshl_int! b7 63))))))
+
+(spec (asimd_fp_mod_imm_from_u64 value size)
+      (provide
+            (= (:size result) size)
+            (= (:imm result)
+                  (switch size
+                  ((ScalarSize.Size32)
+                        (let (
+                              (v    (extract 31 0 value))
+                              (b0_5 (bvand (bvlshr_int! v 19) #x0000003f))
+                              (b6   (bvand (bvlshr_int! v 19) #x00000040))
+                              (b7   (bvand (bvlshr_int! v 24) #x00000080))
+                              (imm  (extract 7 0 (bvor b0_5 (bvor b6 b7))))
+                        )
+                        imm))
+                  ((ScalarSize.Size64)
+                        (let (
+                              (b0_5 (bvand (bvlshr_int! value 48) #x000000000000003f))
+                              (b6   (bvand (bvlshr_int! value 48) #x0000000000000040))
+                              (b7   (bvand (bvlshr_int! value 56) #x0000000000000080))
+                              (imm  (extract 7 0 (bvor b0_5 (bvor b6 b7))))
+                        )
+                        imm)))))
+      (match
+            (switch size
+            ((ScalarSize.Size32)
+                  (let (
+                        (v    (extract 31 0 value))
+                        (b0_5 (bvand (bvlshr_int! v 19) #x0000003f))
+                        (b6   (bvand (bvlshr_int! v 19) #x00000040))
+                        (b7   (bvand (bvlshr_int! v 24) #x00000080))
+                        (imm  (extract 7 0 (bvor b0_5 (bvor b6 b7))))
+                  )
+                  (= v (asimd_fp_mod_imm_value32! imm))))
+            ((ScalarSize.Size64)
+                  (let (
+                        (b0_5 (bvand (bvlshr_int! value 48) #x000000000000003f))
+                        (b6   (bvand (bvlshr_int! value 48) #x0000000000000040))
+                        (b7   (bvand (bvlshr_int! value 56) #x0000000000000080))
+                        (imm  (extract 7 0 (bvor b0_5 (bvor b6 b7))))
+                  )
+                  (= value (asimd_fp_mod_imm_value64! imm)))))))
+
 ;; Helper for creating a `VecDupFPImm` instruction
 (decl vec_dup_fp_imm (ASIMDFPModImm VectorSize) Reg)
 (rule (vec_dup_fp_imm imm size)
diff --git a/cranelift/codegen/src/isa/aarch64/inst/args.rs b/cranelift/codegen/src/isa/aarch64/inst/args.rs
index cf1d6d05a671..575ed00fa07d 100644
--- a/cranelift/codegen/src/isa/aarch64/inst/args.rs
+++ b/cranelift/codegen/src/isa/aarch64/inst/args.rs
@@ -1,24 +1,20 @@
 //! AArch64 ISA definitions: instruction arguments.
 
 use crate::ir::types::*;
-use crate::ir::Type;
 use crate::isa::aarch64::inst::*;
-use crate::machinst::{ty_bits, MachLabel, PrettyPrint, Reg};
-use core::convert::Into;
-use std::string::String;
 
 //=============================================================================
 // Instruction sub-components: shift and extend descriptors
 
 /// A shift operator for a register or immediate.
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 #[repr(u8)]
 pub enum ShiftOp {
     /// Logical shift left.
     LSL = 0b00,
     /// Logical shift right.
     LSR = 0b01,
-    /// Arithmentic shift right.
+    /// Arithmetic shift right.
     ASR = 0b10,
     /// Rotate right.
     ROR = 0b11,
@@ -142,82 +138,17 @@ impl AMode {
 
     /// Memory reference using `reg1 + sizeof(ty) * reg2` as an address, with `reg2` sign- or
     /// zero-extended as per `op`.
-    pub fn reg_plus_reg_scaled_extended(reg1: Reg, reg2: Reg, ty: Type, op: ExtendOp) -> AMode {
+    pub fn reg_plus_reg_scaled_extended(reg1: Reg, reg2: Reg, op: ExtendOp) -> AMode {
         AMode::RegScaledExtended {
             rn: reg1,
             rm: reg2,
-            ty,
             extendop: op,
         }
     }
-
-    pub(crate) fn with_allocs(&self, allocs: &mut AllocationConsumer<'_>) -> Self {
-        // This should match `memarg_operands()`.
-        match self {
-            &AMode::Unscaled { rn, simm9 } => AMode::Unscaled {
-                rn: allocs.next(rn),
-                simm9,
-            },
-            &AMode::UnsignedOffset { rn, uimm12 } => AMode::UnsignedOffset {
-                rn: allocs.next(rn),
-                uimm12,
-            },
-            &AMode::RegReg { rn, rm } => AMode::RegReg {
-                rn: allocs.next(rn),
-                rm: allocs.next(rm),
-            },
-            &AMode::RegScaled { rn, rm, ty } => AMode::RegScaled {
-                rn: allocs.next(rn),
-                rm: allocs.next(rm),
-                ty,
-            },
-            &AMode::RegScaledExtended {
-                rn,
-                rm,
-                ty,
-                extendop,
-            } => AMode::RegScaledExtended {
-                rn: allocs.next(rn),
-                rm: allocs.next(rm),
-                ty,
-                extendop,
-            },
-            &AMode::RegExtended { rn, rm, extendop } => AMode::RegExtended {
-                rn: allocs.next(rn),
-                rm: allocs.next(rm),
-                extendop,
-            },
-            &AMode::RegOffset { rn, off, ty } => AMode::RegOffset {
-                rn: allocs.next(rn),
-                off,
-                ty,
-            },
-            &AMode::SPPreIndexed { .. }
-            | &AMode::SPPostIndexed { .. }
-            | &AMode::FPOffset { .. }
-            | &AMode::SPOffset { .. }
-            | &AMode::NominalSPOffset { .. }
-            | &AMode::Const { .. }
-            | AMode::Label { .. } => self.clone(),
-        }
-    }
 }
 
 pub use crate::isa::aarch64::lower::isle::generated_code::PairAMode;
 
-impl PairAMode {
-    pub(crate) fn with_allocs(&self, allocs: &mut AllocationConsumer<'_>) -> Self {
-        // Should match `pairmemarg_operands()`.
-        match self {
-            &PairAMode::SignedOffset { reg, simm7 } => PairAMode::SignedOffset {
-                reg: allocs.next(reg),
-                simm7,
-            },
-            &PairAMode::SPPreIndexed { .. } | &PairAMode::SPPostIndexed { .. } => self.clone(),
-        }
-    }
-}
-
 //=============================================================================
 // Instruction sub-components (conditions, branches and branch targets):
 // definitions
@@ -340,178 +271,180 @@ impl BranchTarget {
         }
     }
 
+    /// Return the target's offset, if specified, or zero if label-based.
+    pub fn as_offset14_or_zero(self) -> u32 {
+        self.as_offset_bounded(14)
+    }
+
     /// Return the target's offset, if specified, or zero if label-based.
     pub fn as_offset19_or_zero(self) -> u32 {
-        let off = match self {
-            BranchTarget::ResolvedOffset(off) => off >> 2,
-            _ => 0,
-        };
-        assert!(off <= 0x3ffff);
-        assert!(off >= -0x40000);
-        (off as u32) & 0x7ffff
+        self.as_offset_bounded(19)
     }
 
     /// Return the target's offset, if specified, or zero if label-based.
     pub fn as_offset26_or_zero(self) -> u32 {
+        self.as_offset_bounded(26)
+    }
+
+    fn as_offset_bounded(self, bits: u32) -> u32 {
         let off = match self {
             BranchTarget::ResolvedOffset(off) => off >> 2,
             _ => 0,
         };
-        assert!(off <= 0x1ffffff);
-        assert!(off >= -0x2000000);
-        (off as u32) & 0x3ffffff
+        let hi = (1 << (bits - 1)) - 1;
+        let lo = -(1 << bits - 1);
+        assert!(off <= hi);
+        assert!(off >= lo);
+        (off as u32) & ((1 << bits) - 1)
     }
 }
 
 impl PrettyPrint for ShiftOpAndAmt {
-    fn pretty_print(&self, _: u8, _: &mut AllocationConsumer<'_>) -> String {
+    fn pretty_print(&self, _: u8) -> String {
         format!("{:?} {}", self.op(), self.amt().value())
     }
 }
 
 impl PrettyPrint for ExtendOp {
-    fn pretty_print(&self, _: u8, _: &mut AllocationConsumer<'_>) -> String {
-        format!("{:?}", self)
+    fn pretty_print(&self, _: u8) -> String {
+        format!("{self:?}")
     }
 }
 
 impl PrettyPrint for MemLabel {
-    fn pretty_print(&self, _: u8, _: &mut AllocationConsumer<'_>) -> String {
+    fn pretty_print(&self, _: u8) -> String {
         match self {
-            MemLabel::PCRel(off) => format!("pc+{}", off),
+            MemLabel::PCRel(off) => format!("pc+{off}"),
             MemLabel::Mach(off) => format!("label({})", off.get()),
         }
     }
 }
 
-fn shift_for_type(ty: Type) -> usize {
-    match ty.bytes() {
+fn shift_for_type(size_bytes: u8) -> usize {
+    match size_bytes {
         1 => 0,
         2 => 1,
         4 => 2,
         8 => 3,
         16 => 4,
-        _ => panic!("unknown type: {}", ty),
+        _ => panic!("unknown type size: {size_bytes}"),
     }
 }
 
 impl PrettyPrint for AMode {
-    fn pretty_print(&self, _: u8, allocs: &mut AllocationConsumer<'_>) -> String {
+    fn pretty_print(&self, size_bytes: u8) -> String {
+        debug_assert!(size_bytes != 0);
         match self {
             &AMode::Unscaled { rn, simm9 } => {
-                let reg = pretty_print_reg(rn, allocs);
+                let reg = pretty_print_reg(rn);
                 if simm9.value != 0 {
-                    let simm9 = simm9.pretty_print(8, allocs);
-                    format!("[{}, {}]", reg, simm9)
+                    let simm9 = simm9.pretty_print(8);
+                    format!("[{reg}, {simm9}]")
                 } else {
-                    format!("[{}]", reg)
+                    format!("[{reg}]")
                 }
             }
             &AMode::UnsignedOffset { rn, uimm12 } => {
-                let reg = pretty_print_reg(rn, allocs);
-                if uimm12.value != 0 {
-                    let uimm12 = uimm12.pretty_print(8, allocs);
-                    format!("[{}, {}]", reg, uimm12)
+                let reg = pretty_print_reg(rn);
+                if uimm12.value() != 0 {
+                    let uimm12 = uimm12.pretty_print(8);
+                    format!("[{reg}, {uimm12}]")
                 } else {
-                    format!("[{}]", reg)
+                    format!("[{reg}]")
                 }
             }
             &AMode::RegReg { rn, rm } => {
-                let r1 = pretty_print_reg(rn, allocs);
-                let r2 = pretty_print_reg(rm, allocs);
-                format!("[{}, {}]", r1, r2)
+                let r1 = pretty_print_reg(rn);
+                let r2 = pretty_print_reg(rm);
+                format!("[{r1}, {r2}]")
             }
-            &AMode::RegScaled { rn, rm, ty } => {
-                let r1 = pretty_print_reg(rn, allocs);
-                let r2 = pretty_print_reg(rm, allocs);
-                let shift = shift_for_type(ty);
-                format!("[{}, {}, LSL #{}]", r1, r2, shift)
+            &AMode::RegScaled { rn, rm } => {
+                let r1 = pretty_print_reg(rn);
+                let r2 = pretty_print_reg(rm);
+                let shift = shift_for_type(size_bytes);
+                format!("[{r1}, {r2}, LSL #{shift}]")
             }
-            &AMode::RegScaledExtended {
-                rn,
-                rm,
-                ty,
-                extendop,
-            } => {
-                let shift = shift_for_type(ty);
+            &AMode::RegScaledExtended { rn, rm, extendop } => {
+                let shift = shift_for_type(size_bytes);
                 let size = match extendop {
                     ExtendOp::SXTW | ExtendOp::UXTW => OperandSize::Size32,
                     _ => OperandSize::Size64,
                 };
-                let r1 = pretty_print_reg(rn, allocs);
-                let r2 = pretty_print_ireg(rm, size, allocs);
-                let op = extendop.pretty_print(0, allocs);
-                format!("[{}, {}, {} #{}]", r1, r2, op, shift)
+                let r1 = pretty_print_reg(rn);
+                let r2 = pretty_print_ireg(rm, size);
+                let op = extendop.pretty_print(0);
+                format!("[{r1}, {r2}, {op} #{shift}]")
             }
             &AMode::RegExtended { rn, rm, extendop } => {
                 let size = match extendop {
                     ExtendOp::SXTW | ExtendOp::UXTW => OperandSize::Size32,
                     _ => OperandSize::Size64,
                 };
-                let r1 = pretty_print_reg(rn, allocs);
-                let r2 = pretty_print_ireg(rm, size, allocs);
-                let op = extendop.pretty_print(0, allocs);
-                format!("[{}, {}, {}]", r1, r2, op)
+                let r1 = pretty_print_reg(rn);
+                let r2 = pretty_print_ireg(rm, size);
+                let op = extendop.pretty_print(0);
+                format!("[{r1}, {r2}, {op}]")
             }
-            &AMode::Label { ref label } => label.pretty_print(0, allocs),
+            &AMode::Label { ref label } => label.pretty_print(0),
             &AMode::SPPreIndexed { simm9 } => {
-                let simm9 = simm9.pretty_print(8, allocs);
-                format!("[sp, {}]!", simm9)
+                let simm9 = simm9.pretty_print(8);
+                format!("[sp, {simm9}]!")
             }
             &AMode::SPPostIndexed { simm9 } => {
-                let simm9 = simm9.pretty_print(8, allocs);
-                format!("[sp], {}", simm9)
+                let simm9 = simm9.pretty_print(8);
+                format!("[sp], {simm9}")
             }
             AMode::Const { addr } => format!("[const({})]", addr.as_u32()),
 
             // Eliminated by `mem_finalize()`.
             &AMode::SPOffset { .. }
             | &AMode::FPOffset { .. }
-            | &AMode::NominalSPOffset { .. }
+            | &AMode::IncomingArg { .. }
+            | &AMode::SlotOffset { .. }
             | &AMode::RegOffset { .. } => {
-                panic!("Unexpected pseudo mem-arg mode: {:?}", self)
+                panic!("Unexpected pseudo mem-arg mode: {self:?}")
             }
         }
     }
 }
 
 impl PrettyPrint for PairAMode {
-    fn pretty_print(&self, _: u8, allocs: &mut AllocationConsumer<'_>) -> String {
+    fn pretty_print(&self, _: u8) -> String {
         match self {
             &PairAMode::SignedOffset { reg, simm7 } => {
-                let reg = pretty_print_reg(reg, allocs);
+                let reg = pretty_print_reg(reg);
                 if simm7.value != 0 {
-                    let simm7 = simm7.pretty_print(8, allocs);
-                    format!("[{}, {}]", reg, simm7)
+                    let simm7 = simm7.pretty_print(8);
+                    format!("[{reg}, {simm7}]")
                 } else {
-                    format!("[{}]", reg)
+                    format!("[{reg}]")
                 }
             }
             &PairAMode::SPPreIndexed { simm7 } => {
-                let simm7 = simm7.pretty_print(8, allocs);
-                format!("[sp, {}]!", simm7)
+                let simm7 = simm7.pretty_print(8);
+                format!("[sp, {simm7}]!")
             }
             &PairAMode::SPPostIndexed { simm7 } => {
-                let simm7 = simm7.pretty_print(8, allocs);
-                format!("[sp], {}", simm7)
+                let simm7 = simm7.pretty_print(8);
+                format!("[sp], {simm7}")
             }
         }
     }
 }
 
 impl PrettyPrint for Cond {
-    fn pretty_print(&self, _: u8, _: &mut AllocationConsumer<'_>) -> String {
-        let mut s = format!("{:?}", self);
+    fn pretty_print(&self, _: u8) -> String {
+        let mut s = format!("{self:?}");
         s.make_ascii_lowercase();
         s
     }
 }
 
 impl PrettyPrint for BranchTarget {
-    fn pretty_print(&self, _: u8, _: &mut AllocationConsumer<'_>) -> String {
+    fn pretty_print(&self, _: u8) -> String {
         match self {
             &BranchTarget::Label(label) => format!("label{:?}", label.get()),
-            &BranchTarget::ResolvedOffset(off) => format!("{}", off),
+            &BranchTarget::ResolvedOffset(off) => format!("{off}"),
         }
     }
 }
@@ -580,6 +513,14 @@ impl OperandSize {
             OperandSize::Size64 => 1,
         }
     }
+
+    /// The maximum unsigned value representable in a value of this size.
+    pub fn max_value(&self) -> u64 {
+        match self {
+            OperandSize::Size32 => u32::MAX as u64,
+            OperandSize::Size64 => u64::MAX,
+        }
+    }
 }
 
 /// Type used to communicate the size of a scalar SIMD & FP operand.
@@ -603,7 +544,7 @@ impl ScalarSize {
         match self {
             ScalarSize::Size8 | ScalarSize::Size16 | ScalarSize::Size32 => OperandSize::Size32,
             ScalarSize::Size64 => OperandSize::Size64,
-            _ => panic!("Unexpected operand_size request for: {:?}", self),
+            _ => panic!("Unexpected operand_size request for: {self:?}"),
         }
     }
 
@@ -614,7 +555,7 @@ impl ScalarSize {
             ScalarSize::Size16 => 0b11,
             ScalarSize::Size32 => 0b00,
             ScalarSize::Size64 => 0b01,
-            _ => panic!("Unexpected scalar FP operand size: {:?}", self),
+            _ => panic!("Unexpected scalar FP operand size: {self:?}"),
         }
     }
 
@@ -639,6 +580,17 @@ impl ScalarSize {
             ScalarSize::Size128 => ScalarSize::Size64,
         }
     }
+
+    /// Return a type with the same size as this scalar.
+    pub fn ty(&self) -> Type {
+        match self {
+            ScalarSize::Size8 => I8,
+            ScalarSize::Size16 => I16,
+            ScalarSize::Size32 => I32,
+            ScalarSize::Size64 => I64,
+            ScalarSize::Size128 => I128,
+        }
+    }
 }
 
 /// Type used to communicate the size of a vector operand.
@@ -671,7 +623,7 @@ impl VectorSize {
             (ScalarSize::Size32, false) => VectorSize::Size32x2,
             (ScalarSize::Size32, true) => VectorSize::Size32x4,
             (ScalarSize::Size64, true) => VectorSize::Size64x2,
-            _ => panic!("Unexpected scalar FP operand size: {:?}", size),
+            _ => panic!("Unexpected scalar FP operand size: {size:?}"),
         }
     }
 
@@ -727,7 +679,7 @@ impl VectorSize {
         match self.lane_size() {
             ScalarSize::Size32 => 0b0,
             ScalarSize::Size64 => 0b1,
-            size => panic!("Unsupported floating-point size for vector op: {:?}", size),
+            size => panic!("Unsupported floating-point size for vector op: {size:?}"),
         }
     }
 }
@@ -745,3 +697,15 @@ impl APIKey {
         0xd503201f | (crm << 8) | (op2 << 5)
     }
 }
+
+pub use crate::isa::aarch64::lower::isle::generated_code::TestBitAndBranchKind;
+
+impl TestBitAndBranchKind {
+    /// Complements this branch condition to act on the opposite result.
+    pub fn complement(&self) -> TestBitAndBranchKind {
+        match self {
+            TestBitAndBranchKind::Z => TestBitAndBranchKind::NZ,
+            TestBitAndBranchKind::NZ => TestBitAndBranchKind::Z,
+        }
+    }
+}
diff --git a/cranelift/codegen/src/isa/aarch64/inst/emit.rs b/cranelift/codegen/src/isa/aarch64/inst/emit.rs
index 2742134d1f0f..8f76dd56a9f4 100644
--- a/cranelift/codegen/src/isa/aarch64/inst/emit.rs
+++ b/cranelift/codegen/src/isa/aarch64/inst/emit.rs
@@ -1,14 +1,10 @@
 //! AArch64 ISA: binary code emission.
 
 use cranelift_control::ControlPlane;
-use regalloc2::Allocation;
 
-use crate::binemit::{Reloc, StackMap};
-use crate::ir::{self, types::*, LibCall, MemFlags, RelSourceLoc, TrapCode};
+use crate::ir::{self, types::*};
 use crate::isa::aarch64::inst::*;
-use crate::machinst::{ty_bits, Reg, RegClass, Writable};
 use crate::trace;
-use core::convert::TryFrom;
 
 /// Memory addressing mode finalization: convert "special" modes (e.g.,
 /// generic arbitrary stack offset) into real addressing modes, possibly by
@@ -17,37 +13,51 @@ use core::convert::TryFrom;
 pub fn mem_finalize(
     sink: Option<&mut MachBuffer<Inst>>,
     mem: &AMode,
+    access_ty: Type,
     state: &EmitState,
 ) -> (SmallVec<[Inst; 4]>, AMode) {
     match mem {
-        &AMode::RegOffset { off, ty, .. }
-        | &AMode::SPOffset { off, ty }
-        | &AMode::FPOffset { off, ty }
-        | &AMode::NominalSPOffset { off, ty } => {
+        &AMode::RegOffset { off, .. }
+        | &AMode::SPOffset { off }
+        | &AMode::FPOffset { off }
+        | &AMode::IncomingArg { off }
+        | &AMode::SlotOffset { off } => {
             let basereg = match mem {
                 &AMode::RegOffset { rn, .. } => rn,
-                &AMode::SPOffset { .. } | &AMode::NominalSPOffset { .. } => stack_reg(),
+                &AMode::SPOffset { .. }
+                | &AMode::SlotOffset { .. }
+                | &AMode::IncomingArg { .. } => stack_reg(),
                 &AMode::FPOffset { .. } => fp_reg(),
                 _ => unreachable!(),
             };
-            let adj = match mem {
-                &AMode::NominalSPOffset { .. } => {
+            let off = match mem {
+                &AMode::IncomingArg { .. } => {
+                    let frame_layout = state.frame_layout();
+                    i64::from(
+                        frame_layout.setup_area_size
+                            + frame_layout.tail_args_size
+                            + frame_layout.clobber_size
+                            + frame_layout.fixed_frame_storage_size
+                            + frame_layout.outgoing_args_size,
+                    ) - off
+                }
+                &AMode::SlotOffset { .. } => {
+                    let adj = i64::from(state.frame_layout().outgoing_args_size);
                     trace!(
-                        "mem_finalize: nominal SP offset {} + adj {} -> {}",
+                        "mem_finalize: slot offset {} + adj {} -> {}",
                         off,
-                        state.virtual_sp_offset,
-                        off + state.virtual_sp_offset
+                        adj,
+                        off + adj
                     );
-                    state.virtual_sp_offset
+                    off + adj
                 }
-                _ => 0,
+                _ => off,
             };
-            let off = off + adj;
 
             if let Some(simm9) = SImm9::maybe_from_i64(off) {
                 let mem = AMode::Unscaled { rn: basereg, simm9 };
                 (smallvec![], mem)
-            } else if let Some(uimm12) = UImm12Scaled::maybe_from_i64(off, ty) {
+            } else if let Some(uimm12) = UImm12Scaled::maybe_from_i64(off, access_ty) {
                 let mem = AMode::UnsignedOffset {
                     rn: basereg,
                     uimm12,
@@ -154,24 +164,35 @@ fn enc_cbr(op_31_24: u32, off_18_0: u32, op_4: u32, cond: u32) -> u32 {
     (op_31_24 << 24) | (off_18_0 << 5) | (op_4 << 4) | cond
 }
 
-fn enc_conditional_br(
-    taken: BranchTarget,
-    kind: CondBrKind,
-    allocs: &mut AllocationConsumer<'_>,
-) -> u32 {
+fn enc_conditional_br(taken: BranchTarget, kind: CondBrKind) -> u32 {
     match kind {
-        CondBrKind::Zero(reg) => {
-            let reg = allocs.next(reg);
-            enc_cmpbr(0b1_011010_0, taken.as_offset19_or_zero(), reg)
-        }
-        CondBrKind::NotZero(reg) => {
-            let reg = allocs.next(reg);
-            enc_cmpbr(0b1_011010_1, taken.as_offset19_or_zero(), reg)
-        }
+        CondBrKind::Zero(reg) => enc_cmpbr(0b1_011010_0, taken.as_offset19_or_zero(), reg),
+        CondBrKind::NotZero(reg) => enc_cmpbr(0b1_011010_1, taken.as_offset19_or_zero(), reg),
         CondBrKind::Cond(c) => enc_cbr(0b01010100, taken.as_offset19_or_zero(), 0b0, c.bits()),
     }
 }
 
+fn enc_test_bit_and_branch(
+    kind: TestBitAndBranchKind,
+    taken: BranchTarget,
+    reg: Reg,
+    bit: u8,
+) -> u32 {
+    assert!(bit < 64);
+    let op_31 = u32::from(bit >> 5);
+    let op_23_19 = u32::from(bit & 0b11111);
+    let op_30_24 = 0b0110110
+        | match kind {
+            TestBitAndBranchKind::Z => 0,
+            TestBitAndBranchKind::NZ => 1,
+        };
+    (op_31 << 31)
+        | (op_30_24 << 24)
+        | (op_23_19 << 19)
+        | (taken.as_offset14_or_zero() << 5)
+        | machreg_to_gpr(reg)
+}
+
 fn enc_move_wide(op: MoveWideOp, rd: Writable<Reg>, imm: MoveWideConst, size: OperandSize) -> u32 {
     assert!(imm.shift <= 0b11);
     let op = match op {
@@ -629,37 +650,28 @@ fn enc_asimd_mod_imm(rd: Writable<Reg>, q_op: u32, cmode: u32, imm: u8) -> u32 {
 /// State carried between emissions of a sequence of instructions.
 #[derive(Default, Clone, Debug)]
 pub struct EmitState {
-    /// Addend to convert nominal-SP offsets to real-SP offsets at the current
-    /// program point.
-    pub(crate) virtual_sp_offset: i64,
-    /// Offset of FP from nominal-SP.
-    pub(crate) nominal_sp_to_fp: i64,
-    /// Safepoint stack map for upcoming instruction, as provided to `pre_safepoint()`.
-    stack_map: Option<StackMap>,
-    /// Current source-code location corresponding to instruction to be emitted.
-    cur_srcloc: RelSourceLoc,
+    /// The user stack map for the upcoming instruction, as provided to
+    /// `pre_safepoint()`.
+    user_stack_map: Option<ir::UserStackMap>,
+
     /// Only used during fuzz-testing. Otherwise, it is a zero-sized struct and
     /// optimized away at compiletime. See [cranelift_control].
     ctrl_plane: ControlPlane,
+
+    frame_layout: FrameLayout,
 }
 
 impl MachInstEmitState<Inst> for EmitState {
     fn new(abi: &Callee<AArch64MachineDeps>, ctrl_plane: ControlPlane) -> Self {
         EmitState {
-            virtual_sp_offset: 0,
-            nominal_sp_to_fp: abi.frame_size() as i64,
-            stack_map: None,
-            cur_srcloc: Default::default(),
+            user_stack_map: None,
             ctrl_plane,
+            frame_layout: abi.frame_layout().clone(),
         }
     }
 
-    fn pre_safepoint(&mut self, stack_map: StackMap) {
-        self.stack_map = Some(stack_map);
-    }
-
-    fn pre_sourceloc(&mut self, srcloc: RelSourceLoc) {
-        self.cur_srcloc = srcloc;
+    fn pre_safepoint(&mut self, user_stack_map: Option<ir::UserStackMap>) {
+        self.user_stack_map = user_stack_map;
     }
 
     fn ctrl_plane_mut(&mut self) -> &mut ControlPlane {
@@ -669,19 +681,19 @@ impl MachInstEmitState<Inst> for EmitState {
     fn take_ctrl_plane(self) -> ControlPlane {
         self.ctrl_plane
     }
+
+    fn frame_layout(&self) -> &FrameLayout {
+        &self.frame_layout
+    }
 }
 
 impl EmitState {
-    fn take_stack_map(&mut self) -> Option<StackMap> {
-        self.stack_map.take()
+    fn take_stack_map(&mut self) -> Option<ir::UserStackMap> {
+        self.user_stack_map.take()
     }
 
     fn clear_post_insn(&mut self) {
-        self.stack_map = None;
-    }
-
-    fn cur_srcloc(&self) -> RelSourceLoc {
-        self.cur_srcloc
+        self.user_stack_map = None;
     }
 }
 
@@ -699,15 +711,7 @@ impl MachInstEmit for Inst {
     type State = EmitState;
     type Info = EmitInfo;
 
-    fn emit(
-        &self,
-        allocs: &[Allocation],
-        sink: &mut MachBuffer<Inst>,
-        emit_info: &Self::Info,
-        state: &mut EmitState,
-    ) {
-        let mut allocs = AllocationConsumer::new(allocs);
-
+    fn emit(&self, sink: &mut MachBuffer<Inst>, emit_info: &Self::Info, state: &mut EmitState) {
         // N.B.: we *must* not exceed the "worst-case size" used to compute
         // where to insert islands, except when islands are explicitly triggered
         // (with an `EmitIsland`). We check this in debug builds. This is `mut`
@@ -723,10 +727,6 @@ impl MachInstEmit for Inst {
                 rn,
                 rm,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
-
                 debug_assert!(match alu_op {
                     ALUOp::SDiv | ALUOp::UDiv | ALUOp::SMulH | ALUOp::UMulH =>
                         size == OperandSize::Size64,
@@ -780,11 +780,6 @@ impl MachInstEmit for Inst {
                 rn,
                 ra,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
-                let ra = allocs.next(ra);
-
                 let (top11, bit15) = match alu_op {
                     ALUOp3::MAdd => (0b0_00_11011_000, 0),
                     ALUOp3::MSub => (0b0_00_11011_000, 1),
@@ -807,8 +802,6 @@ impl MachInstEmit for Inst {
                 rn,
                 ref imm12,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
                 let top8 = match alu_op {
                     ALUOp::Add => 0b000_10001,
                     ALUOp::Sub => 0b010_10001,
@@ -832,8 +825,6 @@ impl MachInstEmit for Inst {
                 rn,
                 ref imml,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
                 let (top9, inv) = match alu_op {
                     ALUOp::Orr => (0b001_100100, false),
                     ALUOp::And => (0b000_100100, false),
@@ -845,7 +836,7 @@ impl MachInstEmit for Inst {
                     _ => unimplemented!("{:?}", alu_op),
                 };
                 let top9 = top9 | size.sf_bit() << 8;
-                let imml = if inv { imml.invert() } else { imml.clone() };
+                let imml = if inv { imml.invert() } else { *imml };
                 sink.put4(enc_arith_rr_imml(top9, imml.enc_bits(), rn, rd));
             }
 
@@ -856,8 +847,6 @@ impl MachInstEmit for Inst {
                 rn,
                 ref immshift,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
                 let amt = immshift.value();
                 let (top10, immr, imms) = match alu_op {
                     ALUOp::RotR => (0b0001001110, machreg_to_gpr(rn), u32::from(amt)),
@@ -895,9 +884,6 @@ impl MachInstEmit for Inst {
                 rm,
                 ref shiftop,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
                 let top11: u32 = match alu_op {
                     ALUOp::Add => 0b000_01011000,
                     ALUOp::AddS => 0b001_01011000,
@@ -926,9 +912,6 @@ impl MachInstEmit for Inst {
                 rm,
                 extendop,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
                 let top11: u32 = match alu_op {
                     ALUOp::Add => 0b00001011001,
                     ALUOp::Sub => 0b01001011001,
@@ -944,8 +927,6 @@ impl MachInstEmit for Inst {
             &Inst::BitRR {
                 op, size, rd, rn, ..
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
                 let (op1, op2) = match op {
                     BitOp::RBit => (0b00000, 0b000000),
                     BitOp::Clz => (0b00000, 0b000100),
@@ -966,15 +947,16 @@ impl MachInstEmit for Inst {
             | &Inst::ULoad64 {
                 rd, ref mem, flags, ..
             }
+            | &Inst::FpuLoad16 { rd, ref mem, flags }
             | &Inst::FpuLoad32 { rd, ref mem, flags }
             | &Inst::FpuLoad64 { rd, ref mem, flags }
             | &Inst::FpuLoad128 { rd, ref mem, flags } => {
-                let rd = allocs.next_writable(rd);
-                let mem = mem.with_allocs(&mut allocs);
-                let (mem_insts, mem) = mem_finalize(Some(sink), &mem, state);
+                let mem = mem.clone();
+                let access_ty = self.mem_type().unwrap();
+                let (mem_insts, mem) = mem_finalize(Some(sink), &mem, access_ty, state);
 
                 for inst in mem_insts.into_iter() {
-                    inst.emit(&[], sink, emit_info, state);
+                    inst.emit(sink, emit_info, state);
                 }
 
                 // ldst encoding helpers take Reg, not Writable<Reg>.
@@ -983,50 +965,45 @@ impl MachInstEmit for Inst {
                 // This is the base opcode (top 10 bits) for the "unscaled
                 // immediate" form (Unscaled). Other addressing modes will OR in
                 // other values for bits 24/25 (bits 1/2 of this constant).
-                let (op, bits) = match self {
-                    &Inst::ULoad8 { .. } => (0b0011100001, 8),
-                    &Inst::SLoad8 { .. } => (0b0011100010, 8),
-                    &Inst::ULoad16 { .. } => (0b0111100001, 16),
-                    &Inst::SLoad16 { .. } => (0b0111100010, 16),
-                    &Inst::ULoad32 { .. } => (0b1011100001, 32),
-                    &Inst::SLoad32 { .. } => (0b1011100010, 32),
-                    &Inst::ULoad64 { .. } => (0b1111100001, 64),
-                    &Inst::FpuLoad32 { .. } => (0b1011110001, 32),
-                    &Inst::FpuLoad64 { .. } => (0b1111110001, 64),
-                    &Inst::FpuLoad128 { .. } => (0b0011110011, 128),
+                let op = match self {
+                    Inst::ULoad8 { .. } => 0b0011100001,
+                    Inst::SLoad8 { .. } => 0b0011100010,
+                    Inst::ULoad16 { .. } => 0b0111100001,
+                    Inst::SLoad16 { .. } => 0b0111100010,
+                    Inst::ULoad32 { .. } => 0b1011100001,
+                    Inst::SLoad32 { .. } => 0b1011100010,
+                    Inst::ULoad64 { .. } => 0b1111100001,
+                    Inst::FpuLoad16 { .. } => 0b0111110001,
+                    Inst::FpuLoad32 { .. } => 0b1011110001,
+                    Inst::FpuLoad64 { .. } => 0b1111110001,
+                    Inst::FpuLoad128 { .. } => 0b0011110011,
                     _ => unreachable!(),
                 };
 
-                let srcloc = state.cur_srcloc();
-                if !srcloc.is_default() && !flags.notrap() {
+                if let Some(trap_code) = flags.trap_code() {
                     // Register the offset at which the actual load instruction starts.
-                    sink.add_trap(TrapCode::HeapOutOfBounds);
+                    sink.add_trap(trap_code);
                 }
 
                 match &mem {
                     &AMode::Unscaled { rn, simm9 } => {
-                        let reg = allocs.next(rn);
+                        let reg = rn;
                         sink.put4(enc_ldst_simm9(op, simm9, 0b00, reg, rd));
                     }
                     &AMode::UnsignedOffset { rn, uimm12 } => {
-                        let reg = allocs.next(rn);
-                        if uimm12.value() != 0 {
-                            assert_eq!(bits, ty_bits(uimm12.scale_ty()));
-                        }
+                        let reg = rn;
                         sink.put4(enc_ldst_uimm12(op, uimm12, reg, rd));
                     }
                     &AMode::RegReg { rn, rm } => {
-                        let r1 = allocs.next(rn);
-                        let r2 = allocs.next(rm);
+                        let r1 = rn;
+                        let r2 = rm;
                         sink.put4(enc_ldst_reg(
                             op, r1, r2, /* scaled = */ false, /* extendop = */ None, rd,
                         ));
                     }
-                    &AMode::RegScaled { rn, rm, ty }
-                    | &AMode::RegScaledExtended { rn, rm, ty, .. } => {
-                        let r1 = allocs.next(rn);
-                        let r2 = allocs.next(rm);
-                        assert_eq!(bits, ty_bits(ty));
+                    &AMode::RegScaled { rn, rm } | &AMode::RegScaledExtended { rn, rm, .. } => {
+                        let r1 = rn;
+                        let r2 = rm;
                         let extendop = match &mem {
                             &AMode::RegScaled { .. } => None,
                             &AMode::RegScaledExtended { extendop, .. } => Some(extendop),
@@ -1037,8 +1014,8 @@ impl MachInstEmit for Inst {
                         ));
                     }
                     &AMode::RegExtended { rn, rm, extendop } => {
-                        let r1 = allocs.next(rn);
-                        let r2 = allocs.next(rm);
+                        let r1 = rn;
+                        let r2 = rm;
                         sink.put4(enc_ldst_reg(
                             op,
                             r1,
@@ -1085,7 +1062,7 @@ impl MachInstEmit for Inst {
                             &Inst::FpuLoad128 { .. } => {
                                 sink.put4(enc_ldst_imm19(0b10011100, offset, rd));
                             }
-                            _ => panic!("Unspported size for LDR from constant pool!"),
+                            _ => panic!("Unsupported size for LDR from constant pool!"),
                         }
                     }
                     &AMode::SPPreIndexed { simm9 } => {
@@ -1099,10 +1076,11 @@ impl MachInstEmit for Inst {
                     // Eliminated by `mem_finalize()` above.
                     &AMode::SPOffset { .. }
                     | &AMode::FPOffset { .. }
-                    | &AMode::NominalSPOffset { .. }
+                    | &AMode::IncomingArg { .. }
+                    | &AMode::SlotOffset { .. }
                     | &AMode::Const { .. }
                     | &AMode::RegOffset { .. } => {
-                        panic!("Should not see {:?} here!", mem)
+                        panic!("Should not see {mem:?} here!")
                     }
                 }
             }
@@ -1111,56 +1089,54 @@ impl MachInstEmit for Inst {
             | &Inst::Store16 { rd, ref mem, flags }
             | &Inst::Store32 { rd, ref mem, flags }
             | &Inst::Store64 { rd, ref mem, flags }
+            | &Inst::FpuStore16 { rd, ref mem, flags }
             | &Inst::FpuStore32 { rd, ref mem, flags }
             | &Inst::FpuStore64 { rd, ref mem, flags }
             | &Inst::FpuStore128 { rd, ref mem, flags } => {
-                let rd = allocs.next(rd);
-                let mem = mem.with_allocs(&mut allocs);
-                let (mem_insts, mem) = mem_finalize(Some(sink), &mem, state);
+                let mem = mem.clone();
+                let access_ty = self.mem_type().unwrap();
+                let (mem_insts, mem) = mem_finalize(Some(sink), &mem, access_ty, state);
 
                 for inst in mem_insts.into_iter() {
-                    inst.emit(&[], sink, emit_info, state);
+                    inst.emit(sink, emit_info, state);
                 }
 
-                let (op, bits) = match self {
-                    &Inst::Store8 { .. } => (0b0011100000, 8),
-                    &Inst::Store16 { .. } => (0b0111100000, 16),
-                    &Inst::Store32 { .. } => (0b1011100000, 32),
-                    &Inst::Store64 { .. } => (0b1111100000, 64),
-                    &Inst::FpuStore32 { .. } => (0b1011110000, 32),
-                    &Inst::FpuStore64 { .. } => (0b1111110000, 64),
-                    &Inst::FpuStore128 { .. } => (0b0011110010, 128),
+                let op = match self {
+                    Inst::Store8 { .. } => 0b0011100000,
+                    Inst::Store16 { .. } => 0b0111100000,
+                    Inst::Store32 { .. } => 0b1011100000,
+                    Inst::Store64 { .. } => 0b1111100000,
+                    Inst::FpuStore16 { .. } => 0b0111110000,
+                    Inst::FpuStore32 { .. } => 0b1011110000,
+                    Inst::FpuStore64 { .. } => 0b1111110000,
+                    Inst::FpuStore128 { .. } => 0b0011110010,
                     _ => unreachable!(),
                 };
 
-                let srcloc = state.cur_srcloc();
-                if !srcloc.is_default() && !flags.notrap() {
+                if let Some(trap_code) = flags.trap_code() {
                     // Register the offset at which the actual store instruction starts.
-                    sink.add_trap(TrapCode::HeapOutOfBounds);
+                    sink.add_trap(trap_code);
                 }
 
                 match &mem {
                     &AMode::Unscaled { rn, simm9 } => {
-                        let reg = allocs.next(rn);
+                        let reg = rn;
                         sink.put4(enc_ldst_simm9(op, simm9, 0b00, reg, rd));
                     }
                     &AMode::UnsignedOffset { rn, uimm12 } => {
-                        let reg = allocs.next(rn);
-                        if uimm12.value() != 0 {
-                            assert_eq!(bits, ty_bits(uimm12.scale_ty()));
-                        }
+                        let reg = rn;
                         sink.put4(enc_ldst_uimm12(op, uimm12, reg, rd));
                     }
                     &AMode::RegReg { rn, rm } => {
-                        let r1 = allocs.next(rn);
-                        let r2 = allocs.next(rm);
+                        let r1 = rn;
+                        let r2 = rm;
                         sink.put4(enc_ldst_reg(
                             op, r1, r2, /* scaled = */ false, /* extendop = */ None, rd,
                         ));
                     }
-                    &AMode::RegScaled { rn, rm, .. } | &AMode::RegScaledExtended { rn, rm, .. } => {
-                        let r1 = allocs.next(rn);
-                        let r2 = allocs.next(rm);
+                    &AMode::RegScaled { rn, rm } | &AMode::RegScaledExtended { rn, rm, .. } => {
+                        let r1 = rn;
+                        let r2 = rm;
                         let extendop = match &mem {
                             &AMode::RegScaled { .. } => None,
                             &AMode::RegScaledExtended { extendop, .. } => Some(extendop),
@@ -1171,8 +1147,8 @@ impl MachInstEmit for Inst {
                         ));
                     }
                     &AMode::RegExtended { rn, rm, extendop } => {
-                        let r1 = allocs.next(rn);
-                        let r2 = allocs.next(rm);
+                        let r1 = rn;
+                        let r2 = rm;
                         sink.put4(enc_ldst_reg(
                             op,
                             r1,
@@ -1196,10 +1172,11 @@ impl MachInstEmit for Inst {
                     // Eliminated by `mem_finalize()` above.
                     &AMode::SPOffset { .. }
                     | &AMode::FPOffset { .. }
-                    | &AMode::NominalSPOffset { .. }
+                    | &AMode::IncomingArg { .. }
+                    | &AMode::SlotOffset { .. }
                     | &AMode::Const { .. }
                     | &AMode::RegOffset { .. } => {
-                        panic!("Should not see {:?} here!", mem)
+                        panic!("Should not see {mem:?} here!")
                     }
                 }
             }
@@ -1210,18 +1187,14 @@ impl MachInstEmit for Inst {
                 ref mem,
                 flags,
             } => {
-                let rt = allocs.next(rt);
-                let rt2 = allocs.next(rt2);
-                let mem = mem.with_allocs(&mut allocs);
-                let srcloc = state.cur_srcloc();
-                if !srcloc.is_default() && !flags.notrap() {
+                let mem = mem.clone();
+                if let Some(trap_code) = flags.trap_code() {
                     // Register the offset at which the actual store instruction starts.
-                    sink.add_trap(TrapCode::HeapOutOfBounds);
+                    sink.add_trap(trap_code);
                 }
                 match &mem {
                     &PairAMode::SignedOffset { reg, simm7 } => {
                         assert_eq!(simm7.scale_ty, I64);
-                        let reg = allocs.next(reg);
                         sink.put4(enc_ldst_pair(0b1010100100, simm7, reg, rt, rt2));
                     }
                     &PairAMode::SPPreIndexed { simm7 } => {
@@ -1242,19 +1215,17 @@ impl MachInstEmit for Inst {
                 ref mem,
                 flags,
             } => {
-                let rt = allocs.next(rt.to_reg());
-                let rt2 = allocs.next(rt2.to_reg());
-                let mem = mem.with_allocs(&mut allocs);
-                let srcloc = state.cur_srcloc();
-                if !srcloc.is_default() && !flags.notrap() {
+                let rt = rt.to_reg();
+                let rt2 = rt2.to_reg();
+                let mem = mem.clone();
+                if let Some(trap_code) = flags.trap_code() {
                     // Register the offset at which the actual load instruction starts.
-                    sink.add_trap(TrapCode::HeapOutOfBounds);
+                    sink.add_trap(trap_code);
                 }
 
                 match &mem {
                     &PairAMode::SignedOffset { reg, simm7 } => {
                         assert_eq!(simm7.scale_ty, I64);
-                        let reg = allocs.next(reg);
                         sink.put4(enc_ldst_pair(0b1010100101, simm7, reg, rt, rt2));
                     }
                     &PairAMode::SPPreIndexed { simm7 } => {
@@ -1281,14 +1252,13 @@ impl MachInstEmit for Inst {
                 ref mem,
                 flags,
             } => {
-                let rt = allocs.next(rt.to_reg());
-                let rt2 = allocs.next(rt2.to_reg());
-                let mem = mem.with_allocs(&mut allocs);
-                let srcloc = state.cur_srcloc();
+                let rt = rt.to_reg();
+                let rt2 = rt2.to_reg();
+                let mem = mem.clone();
 
-                if !srcloc.is_default() && !flags.notrap() {
+                if let Some(trap_code) = flags.trap_code() {
                     // Register the offset at which the actual load instruction starts.
-                    sink.add_trap(TrapCode::HeapOutOfBounds);
+                    sink.add_trap(trap_code);
                 }
 
                 let opc = match self {
@@ -1300,7 +1270,6 @@ impl MachInstEmit for Inst {
                 match &mem {
                     &PairAMode::SignedOffset { reg, simm7 } => {
                         assert!(simm7.scale_ty == F64 || simm7.scale_ty == I8X16);
-                        let reg = allocs.next(reg);
                         sink.put4(enc_ldst_vec_pair(opc, 0b10, true, simm7, reg, rt, rt2));
                     }
                     &PairAMode::SPPreIndexed { simm7 } => {
@@ -1327,14 +1296,11 @@ impl MachInstEmit for Inst {
                 ref mem,
                 flags,
             } => {
-                let rt = allocs.next(rt);
-                let rt2 = allocs.next(rt2);
-                let mem = mem.with_allocs(&mut allocs);
-                let srcloc = state.cur_srcloc();
+                let mem = mem.clone();
 
-                if !srcloc.is_default() && !flags.notrap() {
+                if let Some(trap_code) = flags.trap_code() {
                     // Register the offset at which the actual store instruction starts.
-                    sink.add_trap(TrapCode::HeapOutOfBounds);
+                    sink.add_trap(trap_code);
                 }
 
                 let opc = match self {
@@ -1346,7 +1312,6 @@ impl MachInstEmit for Inst {
                 match &mem {
                     &PairAMode::SignedOffset { reg, simm7 } => {
                         assert!(simm7.scale_ty == F64 || simm7.scale_ty == I8X16);
-                        let reg = allocs.next(reg);
                         sink.put4(enc_ldst_vec_pair(opc, 0b10, false, simm7, reg, rt, rt2));
                     }
                     &PairAMode::SPPreIndexed { simm7 } => {
@@ -1362,8 +1327,6 @@ impl MachInstEmit for Inst {
                 }
             }
             &Inst::Mov { size, rd, rm } => {
-                let rd = allocs.next_writable(rd);
-                let rm = allocs.next(rm);
                 assert!(rd.to_reg().class() == rm.class());
                 assert!(rm.class() == RegClass::Int);
 
@@ -1398,8 +1361,6 @@ impl MachInstEmit for Inst {
                 }
             }
             &Inst::MovFromPReg { rd, rm } => {
-                let rd = allocs.next_writable(rd);
-                allocs.next_fixed_nonallocatable(rm);
                 let rm: Reg = rm.into();
                 debug_assert!([
                     regs::fp_reg(),
@@ -1411,12 +1372,10 @@ impl MachInstEmit for Inst {
                 assert!(rm.class() == RegClass::Int);
                 assert!(rd.to_reg().class() == rm.class());
                 let size = OperandSize::Size64;
-                Inst::Mov { size, rd, rm }.emit(&[], sink, emit_info, state);
+                Inst::Mov { size, rd, rm }.emit(sink, emit_info, state);
             }
             &Inst::MovToPReg { rd, rm } => {
-                allocs.next_fixed_nonallocatable(rd);
                 let rd: Writable<Reg> = Writable::from_reg(rd.into());
-                let rm = allocs.next(rm);
                 debug_assert!([
                     regs::fp_reg(),
                     regs::stack_reg(),
@@ -1427,36 +1386,25 @@ impl MachInstEmit for Inst {
                 assert!(rd.to_reg().class() == RegClass::Int);
                 assert!(rm.class() == rd.to_reg().class());
                 let size = OperandSize::Size64;
-                Inst::Mov { size, rd, rm }.emit(&[], sink, emit_info, state);
+                Inst::Mov { size, rd, rm }.emit(sink, emit_info, state);
             }
             &Inst::MovWide { op, rd, imm, size } => {
-                let rd = allocs.next_writable(rd);
                 sink.put4(enc_move_wide(op, rd, imm, size));
             }
             &Inst::MovK { rd, rn, imm, size } => {
-                let rn = allocs.next(rn);
-                let rd = allocs.next_writable(rd);
                 debug_assert_eq!(rn, rd.to_reg());
                 sink.put4(enc_movk(rd, imm, size));
             }
             &Inst::CSel { rd, rn, rm, cond } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
                 sink.put4(enc_csel(rd, rn, rm, cond, 0, 0));
             }
             &Inst::CSNeg { rd, rn, rm, cond } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
                 sink.put4(enc_csel(rd, rn, rm, cond, 1, 1));
             }
             &Inst::CSet { rd, cond } => {
-                let rd = allocs.next_writable(rd);
                 sink.put4(enc_csel(rd, zero_reg(), zero_reg(), cond.invert(), 0, 1));
             }
             &Inst::CSetm { rd, cond } => {
-                let rd = allocs.next_writable(rd);
                 sink.put4(enc_csel(rd, zero_reg(), zero_reg(), cond.invert(), 1, 0));
             }
             &Inst::CCmp {
@@ -1466,8 +1414,6 @@ impl MachInstEmit for Inst {
                 nzcv,
                 cond,
             } => {
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
                 sink.put4(enc_ccmp(size, rn, rm, nzcv, cond));
             }
             &Inst::CCmpImm {
@@ -1477,7 +1423,6 @@ impl MachInstEmit for Inst {
                 nzcv,
                 cond,
             } => {
-                let rn = allocs.next(rn);
                 sink.put4(enc_ccmp_imm(size, rn, imm, nzcv, cond));
             }
             &Inst::AtomicRMW {
@@ -1488,13 +1433,8 @@ impl MachInstEmit for Inst {
                 rn,
                 flags,
             } => {
-                let rs = allocs.next(rs);
-                let rt = allocs.next_writable(rt);
-                let rn = allocs.next(rn);
-
-                let srcloc = state.cur_srcloc();
-                if !srcloc.is_default() && !flags.notrap() {
-                    sink.add_trap(TrapCode::HeapOutOfBounds);
+                if let Some(trap_code) = flags.trap_code() {
+                    sink.add_trap(trap_code);
                 }
 
                 sink.put4(enc_acq_rel(ty, op, rs, rt, rn));
@@ -1533,9 +1473,8 @@ impl MachInstEmit for Inst {
                 // again:
                 sink.bind_label(again_label, &mut state.ctrl_plane);
 
-                let srcloc = state.cur_srcloc();
-                if !srcloc.is_default() && !flags.notrap() {
-                    sink.add_trap(TrapCode::HeapOutOfBounds);
+                if let Some(trap_code) = flags.trap_code() {
+                    sink.add_trap(trap_code);
                 }
 
                 sink.put4(enc_ldaxr(ty, x27wr, x25)); // ldaxr x27, [x25]
@@ -1559,7 +1498,7 @@ impl MachInstEmit for Inst {
                         from_bits,
                         to_bits: size.bits(),
                     }
-                    .emit(&[], sink, emit_info, state);
+                    .emit(sink, emit_info, state);
                 }
 
                 match op {
@@ -1575,7 +1514,7 @@ impl MachInstEmit for Inst {
                             rn: x27,
                             rm: x26,
                         }
-                        .emit(&[], sink, emit_info, state);
+                        .emit(sink, emit_info, state);
 
                         Inst::AluRRR {
                             alu_op: ALUOp::OrrNot,
@@ -1584,7 +1523,7 @@ impl MachInstEmit for Inst {
                             rn: xzr,
                             rm: x28,
                         }
-                        .emit(&[], sink, emit_info, state);
+                        .emit(sink, emit_info, state);
                     }
                     AtomicRMWLoopOp::Umin
                     | AtomicRMWLoopOp::Umax
@@ -1611,7 +1550,7 @@ impl MachInstEmit for Inst {
                                 rm: x26,
                                 extendop,
                             }
-                            .emit(&[], sink, emit_info, state);
+                            .emit(sink, emit_info, state);
                         } else {
                             Inst::AluRRR {
                                 alu_op: ALUOp::SubS,
@@ -1620,7 +1559,7 @@ impl MachInstEmit for Inst {
                                 rn: x27,
                                 rm: x26,
                             }
-                            .emit(&[], sink, emit_info, state);
+                            .emit(sink, emit_info, state);
                         }
 
                         Inst::CSel {
@@ -1629,7 +1568,7 @@ impl MachInstEmit for Inst {
                             rn: x27,
                             rm: x26,
                         }
-                        .emit(&[], sink, emit_info, state);
+                        .emit(sink, emit_info, state);
                     }
                     _ => {
                         // add/sub/and/orr/eor x28, x27, x26
@@ -1654,13 +1593,12 @@ impl MachInstEmit for Inst {
                             rn: x27,
                             rm: x26,
                         }
-                        .emit(&[], sink, emit_info, state);
+                        .emit(sink, emit_info, state);
                     }
                 }
 
-                let srcloc = state.cur_srcloc();
-                if !srcloc.is_default() && !flags.notrap() {
-                    sink.add_trap(TrapCode::HeapOutOfBounds);
+                if let Some(trap_code) = flags.trap_code() {
+                    sink.add_trap(trap_code);
                 }
                 if op == AtomicRMWLoopOp::Xchg {
                     sink.put4(enc_stlxr(ty, x24wr, x26, x25)); // stlxr w24, x26, [x25]
@@ -1675,7 +1613,6 @@ impl MachInstEmit for Inst {
                 sink.put4(enc_conditional_br(
                     BranchTarget::Label(again_label),
                     CondBrKind::NotZero(x24),
-                    &mut AllocationConsumer::default(),
                 ));
                 sink.use_label_at_offset(br_offset, again_label, LabelUse::Branch19);
             }
@@ -1687,22 +1624,17 @@ impl MachInstEmit for Inst {
                 ty,
                 flags,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rs = allocs.next(rs);
                 debug_assert_eq!(rd.to_reg(), rs);
-                let rt = allocs.next(rt);
-                let rn = allocs.next(rn);
                 let size = match ty {
                     I8 => 0b00,
                     I16 => 0b01,
                     I32 => 0b10,
                     I64 => 0b11,
-                    _ => panic!("Unsupported type: {}", ty),
+                    _ => panic!("Unsupported type: {ty}"),
                 };
 
-                let srcloc = state.cur_srcloc();
-                if !srcloc.is_default() && !flags.notrap() {
-                    sink.add_trap(TrapCode::HeapOutOfBounds);
+                if let Some(trap_code) = flags.trap_code() {
+                    sink.add_trap(trap_code);
                 }
 
                 sink.put4(enc_cas(size, rd, rt, rn));
@@ -1735,9 +1667,8 @@ impl MachInstEmit for Inst {
                 // again:
                 sink.bind_label(again_label, &mut state.ctrl_plane);
 
-                let srcloc = state.cur_srcloc();
-                if !srcloc.is_default() && !flags.notrap() {
-                    sink.add_trap(TrapCode::HeapOutOfBounds);
+                if let Some(trap_code) = flags.trap_code() {
+                    sink.add_trap(trap_code);
                 }
 
                 // ldaxr x27, [x25]
@@ -1759,13 +1690,11 @@ impl MachInstEmit for Inst {
                 sink.put4(enc_conditional_br(
                     BranchTarget::Label(out_label),
                     CondBrKind::Cond(Cond::Ne),
-                    &mut AllocationConsumer::default(),
                 ));
                 sink.use_label_at_offset(br_out_offset, out_label, LabelUse::Branch19);
 
-                let srcloc = state.cur_srcloc();
-                if !srcloc.is_default() && !flags.notrap() {
-                    sink.add_trap(TrapCode::HeapOutOfBounds);
+                if let Some(trap_code) = flags.trap_code() {
+                    sink.add_trap(trap_code);
                 }
 
                 sink.put4(enc_stlxr(ty, x24wr, x28, x25)); // stlxr w24, x28, [x25]
@@ -1777,7 +1706,6 @@ impl MachInstEmit for Inst {
                 sink.put4(enc_conditional_br(
                     BranchTarget::Label(again_label),
                     CondBrKind::NotZero(x24),
-                    &mut AllocationConsumer::default(),
                 ));
                 sink.use_label_at_offset(br_again_offset, again_label, LabelUse::Branch19);
 
@@ -1790,12 +1718,8 @@ impl MachInstEmit for Inst {
                 rn,
                 flags,
             } => {
-                let rn = allocs.next(rn);
-                let rt = allocs.next_writable(rt);
-
-                let srcloc = state.cur_srcloc();
-                if !srcloc.is_default() && !flags.notrap() {
-                    sink.add_trap(TrapCode::HeapOutOfBounds);
+                if let Some(trap_code) = flags.trap_code() {
+                    sink.add_trap(trap_code);
                 }
 
                 sink.put4(enc_ldar(access_ty, rt, rn));
@@ -1806,12 +1730,8 @@ impl MachInstEmit for Inst {
                 rn,
                 flags,
             } => {
-                let rn = allocs.next(rn);
-                let rt = allocs.next(rt);
-
-                let srcloc = state.cur_srcloc();
-                if !srcloc.is_default() && !flags.notrap() {
-                    sink.add_trap(TrapCode::HeapOutOfBounds);
+                if let Some(trap_code) = flags.trap_code() {
+                    sink.add_trap(trap_code);
                 }
 
                 sink.put4(enc_stlr(access_ty, rt, rn));
@@ -1822,19 +1742,16 @@ impl MachInstEmit for Inst {
             &Inst::Csdb {} => {
                 sink.put4(0xd503229f);
             }
+            &Inst::FpuMove32 { rd, rn } => {
+                sink.put4(enc_fpurr(0b000_11110_00_1_000000_10000, rd, rn));
+            }
             &Inst::FpuMove64 { rd, rn } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
                 sink.put4(enc_fpurr(0b000_11110_01_1_000000_10000, rd, rn));
             }
             &Inst::FpuMove128 { rd, rn } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
                 sink.put4(enc_vecmov(/* 16b = */ true, rd, rn));
             }
             &Inst::FpuMoveFromVec { rd, rn, idx, size } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
                 let (imm5, shift, mask) = match size.lane_size() {
                     ScalarSize::Size32 => (0b00100, 3, 0b011),
                     ScalarSize::Size64 => (0b01000, 4, 0b001),
@@ -1850,8 +1767,6 @@ impl MachInstEmit for Inst {
                 );
             }
             &Inst::FpuExtend { rd, rn, size } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
                 sink.put4(enc_fpurr(
                     0b000_11110_00_1_000000_10000 | (size.ftype() << 12),
                     rd,
@@ -1864,8 +1779,6 @@ impl MachInstEmit for Inst {
                 rd,
                 rn,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
                 let top22 = match fpu_op {
                     FPUOp1::Abs => 0b000_11110_00_1_000001_10000,
                     FPUOp1::Neg => 0b000_11110_00_1_000010_10000,
@@ -1889,9 +1802,6 @@ impl MachInstEmit for Inst {
                 rn,
                 rm,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
                 let top22 = match fpu_op {
                     FPUOp2::Add => 0b000_11110_00_1_00000_001010,
                     FPUOp2::Sub => 0b000_11110_00_1_00000_001110,
@@ -1903,34 +1813,27 @@ impl MachInstEmit for Inst {
                 let top22 = top22 | size.ftype() << 12;
                 sink.put4(enc_fpurrr(top22, rd, rn, rm));
             }
-            &Inst::FpuRRI { fpu_op, rd, rn } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                match fpu_op {
-                    FPUOpRI::UShr32(imm) => {
-                        debug_assert_eq!(32, imm.lane_size_in_bits);
-                        sink.put4(
-                            0b0_0_1_011110_0000000_00_0_0_0_1_00000_00000
-                                | imm.enc() << 16
-                                | machreg_to_vec(rn) << 5
-                                | machreg_to_vec(rd.to_reg()),
-                        )
-                    }
-                    FPUOpRI::UShr64(imm) => {
-                        debug_assert_eq!(64, imm.lane_size_in_bits);
-                        sink.put4(
-                            0b01_1_111110_0000000_00_0_0_0_1_00000_00000
-                                | imm.enc() << 16
-                                | machreg_to_vec(rn) << 5
-                                | machreg_to_vec(rd.to_reg()),
-                        )
-                    }
+            &Inst::FpuRRI { fpu_op, rd, rn } => match fpu_op {
+                FPUOpRI::UShr32(imm) => {
+                    debug_assert_eq!(32, imm.lane_size_in_bits);
+                    sink.put4(
+                        0b0_0_1_011110_0000000_00_0_0_0_1_00000_00000
+                            | imm.enc() << 16
+                            | machreg_to_vec(rn) << 5
+                            | machreg_to_vec(rd.to_reg()),
+                    )
                 }
-            }
+                FPUOpRI::UShr64(imm) => {
+                    debug_assert_eq!(64, imm.lane_size_in_bits);
+                    sink.put4(
+                        0b01_1_111110_0000000_00_0_0_0_1_00000_00000
+                            | imm.enc() << 16
+                            | machreg_to_vec(rn) << 5
+                            | machreg_to_vec(rd.to_reg()),
+                    )
+                }
+            },
             &Inst::FpuRRIMod { fpu_op, rd, ri, rn } => {
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
-                let rn = allocs.next(rn);
                 debug_assert_eq!(rd.to_reg(), ri);
                 match fpu_op {
                     FPUOpRIMod::Sli64(imm) => {
@@ -1961,19 +1864,16 @@ impl MachInstEmit for Inst {
                 rm,
                 ra,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
-                let ra = allocs.next(ra);
                 let top17 = match fpu_op {
                     FPUOp3::MAdd => 0b000_11111_00_0_00000_0,
+                    FPUOp3::MSub => 0b000_11111_00_0_00000_1,
+                    FPUOp3::NMAdd => 0b000_11111_00_1_00000_0,
+                    FPUOp3::NMSub => 0b000_11111_00_1_00000_1,
                 };
                 let top17 = top17 | size.ftype() << 7;
                 sink.put4(enc_fpurrrr(top17, rd, rn, rm, ra));
             }
             &Inst::VecMisc { op, rd, rn, size } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
                 let (q, enc_size) = size.enc_size();
                 let (u, bits_12_16, size) = match op {
                     VecMisc2::Not => (0b1, 0b00101, 0b00),
@@ -2128,8 +2028,6 @@ impl MachInstEmit for Inst {
                 sink.put4(enc_vec_rr_misc((q << 1) | u, size, bits_12_16, rd, rn));
             }
             &Inst::VecLanes { op, rd, rn, size } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
                 let (q, size) = match size {
                     VectorSize::Size8x8 => (0b0, 0b00),
                     VectorSize::Size8x16 => (0b1, 0b00),
@@ -2151,8 +2049,6 @@ impl MachInstEmit for Inst {
                 size,
                 imm,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
                 let (is_shr, mut template) = match op {
                     VecShiftImmOp::Ushr => (true, 0b_001_011110_0000_000_000001_00000_00000_u32),
                     VecShiftImmOp::Sshr => (true, 0b_000_011110_0000_000_000001_00000_00000_u32),
@@ -2182,8 +2078,7 @@ impl MachInstEmit for Inst {
                     (ScalarSize::Size16, false) if imm <= 15 => 0b_0010_000_u32 | imm,
                     (ScalarSize::Size8, false) if imm <= 7 => 0b_0001_000_u32 | imm,
                     _ => panic!(
-                        "aarch64: Inst::VecShiftImm: emit: invalid op/size/imm {:?}, {:?}, {:?}",
-                        op, size, imm
+                        "aarch64: Inst::VecShiftImm: emit: invalid op/size/imm {op:?}, {size:?}, {imm:?}"
                     ),
                 };
                 let rn_enc = machreg_to_vec(rn);
@@ -2198,10 +2093,7 @@ impl MachInstEmit for Inst {
                 size,
                 imm,
             } => {
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
-                let rn = allocs.next(rn);
                 let (is_shr, mut template) = match op {
                     VecShiftImmModOp::Sli => (false, 0b_001_011110_0000_000_010101_00000_00000_u32),
                 };
@@ -2229,8 +2121,7 @@ impl MachInstEmit for Inst {
                     (ScalarSize::Size16, false) if imm <= 15 => 0b_0010_000_u32 | imm,
                     (ScalarSize::Size8, false) if imm <= 7 => 0b_0001_000_u32 | imm,
                     _ => panic!(
-                        "aarch64: Inst::VecShiftImmMod: emit: invalid op/size/imm {:?}, {:?}, {:?}",
-                        op, size, imm
+                        "aarch64: Inst::VecShiftImmMod: emit: invalid op/size/imm {op:?}, {size:?}, {imm:?}"
                     ),
                 };
                 let rn_enc = machreg_to_vec(rn);
@@ -2238,9 +2129,6 @@ impl MachInstEmit for Inst {
                 sink.put4(template | (immh_immb << 16) | (rn_enc << 5) | rd_enc);
             }
             &Inst::VecExtract { rd, rn, rm, imm4 } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
                 if imm4 < 16 {
                     let template = 0b_01_101110_000_00000_0_0000_0_00000_00000_u32;
                     let rm_enc = machreg_to_vec(rm);
@@ -2250,31 +2138,17 @@ impl MachInstEmit for Inst {
                         template | (rm_enc << 16) | ((imm4 as u32) << 11) | (rn_enc << 5) | rd_enc,
                     );
                 } else {
-                    panic!(
-                        "aarch64: Inst::VecExtract: emit: invalid extract index {}",
-                        imm4
-                    );
+                    panic!("aarch64: Inst::VecExtract: emit: invalid extract index {imm4}");
                 }
             }
             &Inst::VecTbl { rd, rn, rm } => {
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
-                let rd = allocs.next_writable(rd);
                 sink.put4(enc_tbl(/* is_extension = */ false, 0b00, rd, rn, rm));
             }
             &Inst::VecTblExt { rd, ri, rn, rm } => {
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
                 sink.put4(enc_tbl(/* is_extension = */ true, 0b00, rd, rn, rm));
             }
             &Inst::VecTbl2 { rd, rn, rn2, rm } => {
-                let rn = allocs.next(rn);
-                let rn2 = allocs.next(rn2);
-                let rm = allocs.next(rm);
-                let rd = allocs.next_writable(rd);
                 assert_eq!(machreg_to_vec(rn2), (machreg_to_vec(rn) + 1) % 32);
                 sink.put4(enc_tbl(/* is_extension = */ false, 0b01, rd, rn, rm));
             }
@@ -2285,23 +2159,14 @@ impl MachInstEmit for Inst {
                 rn2,
                 rm,
             } => {
-                let rn = allocs.next(rn);
-                let rn2 = allocs.next(rn2);
-                let rm = allocs.next(rm);
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
                 assert_eq!(machreg_to_vec(rn2), (machreg_to_vec(rn) + 1) % 32);
                 sink.put4(enc_tbl(/* is_extension = */ true, 0b01, rd, rn, rm));
             }
             &Inst::FpuCmp { size, rn, rm } => {
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
                 sink.put4(enc_fcmp(size, rn, rm));
             }
             &Inst::FpuToInt { op, rd, rn } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
                 let top16 = match op {
                     // FCVTZS (32/32-bit)
                     FpuToIntOp::F32ToI32 => 0b000_11110_00_1_11_000,
@@ -2323,8 +2188,6 @@ impl MachInstEmit for Inst {
                 sink.put4(enc_fputoint(top16, rd, rn));
             }
             &Inst::IntToFpu { op, rd, rn } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
                 let top16 = match op {
                     // SCVTF (32/32-bit)
                     IntToFpuOp::I32ToF32 => 0b000_11110_00_1_00_010,
@@ -2345,21 +2208,16 @@ impl MachInstEmit for Inst {
                 };
                 sink.put4(enc_inttofpu(top16, rd, rn));
             }
+            &Inst::FpuCSel16 { rd, rn, rm, cond } => {
+                sink.put4(enc_fcsel(rd, rn, rm, cond, ScalarSize::Size16));
+            }
             &Inst::FpuCSel32 { rd, rn, rm, cond } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
                 sink.put4(enc_fcsel(rd, rn, rm, cond, ScalarSize::Size32));
             }
             &Inst::FpuCSel64 { rd, rn, rm, cond } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
                 sink.put4(enc_fcsel(rd, rn, rm, cond, ScalarSize::Size64));
             }
             &Inst::FpuRound { op, rd, rn } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
                 let top22 = match op {
                     FpuRoundMode::Minus32 => 0b000_11110_00_1_001_010_10000,
                     FpuRoundMode::Minus64 => 0b000_11110_01_1_001_010_10000,
@@ -2373,9 +2231,8 @@ impl MachInstEmit for Inst {
                 sink.put4(enc_fround(top22, rd, rn));
             }
             &Inst::MovToFpu { rd, rn, size } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
                 let template = match size {
+                    ScalarSize::Size16 => 0b000_11110_11_1_00_111_000000_00000_00000,
                     ScalarSize::Size32 => 0b000_11110_00_1_00_111_000000_00000_00000,
                     ScalarSize::Size64 => 0b100_11110_01_1_00_111_000000_00000_00000,
                     _ => unreachable!(),
@@ -2383,15 +2240,9 @@ impl MachInstEmit for Inst {
                 sink.put4(template | (machreg_to_gpr(rn) << 5) | machreg_to_vec(rd.to_reg()));
             }
             &Inst::FpuMoveFPImm { rd, imm, size } => {
-                let rd = allocs.next_writable(rd);
-                let size_code = match size {
-                    ScalarSize::Size32 => 0b00,
-                    ScalarSize::Size64 => 0b01,
-                    _ => unimplemented!(),
-                };
                 sink.put4(
                     0b000_11110_00_1_00_000_000100_00000_00000
-                        | size_code << 22
+                        | size.ftype() << 22
                         | ((imm.enc_bits() as u32) << 13)
                         | machreg_to_vec(rd.to_reg()),
                 );
@@ -2403,10 +2254,7 @@ impl MachInstEmit for Inst {
                 idx,
                 size,
             } => {
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
-                let rn = allocs.next(rn);
                 let (imm5, shift) = match size.lane_size() {
                     ScalarSize::Size8 => (0b00001, 1),
                     ScalarSize::Size16 => (0b00010, 2),
@@ -2424,14 +2272,12 @@ impl MachInstEmit for Inst {
                 );
             }
             &Inst::MovFromVec { rd, rn, idx, size } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
                 let (q, imm5, shift, mask) = match size {
                     ScalarSize::Size8 => (0b0, 0b00001, 1, 0b1111),
                     ScalarSize::Size16 => (0b0, 0b00010, 2, 0b0111),
                     ScalarSize::Size32 => (0b0, 0b00100, 3, 0b0011),
                     ScalarSize::Size64 => (0b1, 0b01000, 4, 0b0001),
-                    _ => panic!("Unexpected scalar FP operand size: {:?}", size),
+                    _ => panic!("Unexpected scalar FP operand size: {size:?}"),
                 };
                 debug_assert_eq!(idx & mask, idx);
                 let imm5 = imm5 | ((idx as u32) << shift);
@@ -2450,8 +2296,6 @@ impl MachInstEmit for Inst {
                 size,
                 scalar_size,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
                 let (imm5, shift, half) = match size {
                     VectorSize::Size8x8 => (0b00001, 1, true),
                     VectorSize::Size8x16 => (0b00001, 1, false),
@@ -2478,8 +2322,6 @@ impl MachInstEmit for Inst {
                 );
             }
             &Inst::VecDup { rd, rn, size } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
                 let q = size.is_128bits() as u32;
                 let imm5 = match size.lane_size() {
                     ScalarSize::Size8 => 0b00001,
@@ -2497,8 +2339,6 @@ impl MachInstEmit for Inst {
                 );
             }
             &Inst::VecDupFromFpu { rd, rn, size, lane } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
                 let q = size.is_128bits() as u32;
                 let imm5 = match size.lane_size() {
                     ScalarSize::Size8 => {
@@ -2528,7 +2368,6 @@ impl MachInstEmit for Inst {
                 );
             }
             &Inst::VecDupFPImm { rd, imm, size } => {
-                let rd = allocs.next_writable(rd);
                 let imm = imm.enc_bits();
                 let op = match size.lane_size() {
                     ScalarSize::Size32 => 0,
@@ -2545,7 +2384,6 @@ impl MachInstEmit for Inst {
                 invert,
                 size,
             } => {
-                let rd = allocs.next_writable(rd);
                 let (imm, shift, shift_ones) = imm.value();
                 let (op, cmode) = match size.lane_size() {
                     ScalarSize::Size8 => {
@@ -2594,13 +2432,11 @@ impl MachInstEmit for Inst {
                 high_half,
                 lane_size,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
                 let immh = match lane_size {
                     ScalarSize::Size16 => 0b001,
                     ScalarSize::Size32 => 0b010,
                     ScalarSize::Size64 => 0b100,
-                    _ => panic!("Unexpected VecExtend to lane size of {:?}", lane_size),
+                    _ => panic!("Unexpected VecExtend to lane size of {lane_size:?}"),
                 };
                 let u = match t {
                     VecExtendOp::Sxtl => 0b0,
@@ -2621,8 +2457,6 @@ impl MachInstEmit for Inst {
                 rn,
                 high_half,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
                 let (u, size, bits_12_16) = match op {
                     VecRRLongOp::Fcvtl16 => (0b0, 0b00, 0b10111),
                     VecRRLongOp::Fcvtl32 => (0b0, 0b01, 0b10111),
@@ -2652,8 +2486,6 @@ impl MachInstEmit for Inst {
                 lane_size,
                 ..
             } => {
-                let rn = allocs.next(rn);
-                let rd = allocs.next_writable(rd);
                 let high_half = match self {
                     &Inst::VecRRNarrowLow { .. } => false,
                     &Inst::VecRRNarrowHigh { .. } => true,
@@ -2664,7 +2496,7 @@ impl MachInstEmit for Inst {
                     ScalarSize::Size8 => 0b00,
                     ScalarSize::Size16 => 0b01,
                     ScalarSize::Size32 => 0b10,
-                    _ => panic!("unsupported size: {:?}", lane_size),
+                    _ => panic!("unsupported size: {lane_size:?}"),
                 };
 
                 // Floats use a single bit, to encode either half or single.
@@ -2697,10 +2529,7 @@ impl MachInstEmit for Inst {
                 src_idx,
                 size,
             } => {
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
-                let rn = allocs.next(rn);
                 let (imm5, shift) = match size.lane_size() {
                     ScalarSize::Size8 => (0b00001, 1),
                     ScalarSize::Size16 => (0b00010, 2),
@@ -2722,8 +2551,6 @@ impl MachInstEmit for Inst {
                 );
             }
             &Inst::VecRRPair { op, rd, rn } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
                 let bits_12_16 = match op {
                     VecPairOp::Addp => 0b11011,
                 };
@@ -2737,9 +2564,6 @@ impl MachInstEmit for Inst {
                 alu_op,
                 high_half,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
                 let (u, size, bit14) = match alu_op {
                     VecRRRLongOp::Smull8 => (0b0, 0b00, 0b1),
                     VecRRRLongOp::Smull16 => (0b0, 0b01, 0b1),
@@ -2766,11 +2590,7 @@ impl MachInstEmit for Inst {
                 alu_op,
                 high_half,
             } => {
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
                 let (u, size, bit14) = match alu_op {
                     VecRRRLongModOp::Umlal8 => (0b1, 0b00, 0b0),
                     VecRRRLongModOp::Umlal16 => (0b1, 0b01, 0b0),
@@ -2787,8 +2607,6 @@ impl MachInstEmit for Inst {
                 ));
             }
             &Inst::VecRRPairLong { op, rd, rn } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
                 let (u, size) = match op {
                     VecRRPairLongOp::Saddlp8 => (0b0, 0b0),
                     VecRRPairLongOp::Uaddlp8 => (0b1, 0b0),
@@ -2805,9 +2623,6 @@ impl MachInstEmit for Inst {
                 alu_op,
                 size,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
                 let (q, enc_size) = size.enc_size();
                 let is_float = match alu_op {
                     VecALUOp::Fcmeq
@@ -2916,11 +2731,7 @@ impl MachInstEmit for Inst {
                 alu_op,
                 size,
             } => {
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
                 let (q, _enc_size) = size.enc_size();
 
                 let (top11, bit15_10) = match alu_op {
@@ -2943,11 +2754,7 @@ impl MachInstEmit for Inst {
                 size,
                 idx,
             } => {
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
                 let idx = u32::from(idx);
 
                 let (q, _size) = size.enc_size();
@@ -2979,22 +2786,16 @@ impl MachInstEmit for Inst {
                 size,
                 flags,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
                 let (q, size) = size.enc_size();
 
-                let srcloc = state.cur_srcloc();
-                if !srcloc.is_default() && !flags.notrap() {
+                if let Some(trap_code) = flags.trap_code() {
                     // Register the offset at which the actual load instruction starts.
-                    sink.add_trap(TrapCode::HeapOutOfBounds);
+                    sink.add_trap(trap_code);
                 }
 
                 sink.put4(enc_ldst_vec(q, size, rn, rd));
             }
             &Inst::VecCSel { rd, rn, rm, cond } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
                 /* Emit this:
                       b.cond  else
                       mov     rd, rm
@@ -3013,7 +2814,6 @@ impl MachInstEmit for Inst {
                 sink.put4(enc_conditional_br(
                     BranchTarget::Label(else_label),
                     CondBrKind::Cond(cond),
-                    &mut AllocationConsumer::default(),
                 ));
                 sink.use_label_at_offset(br_else_offset, else_label, LabelUse::Branch19);
 
@@ -3036,11 +2836,9 @@ impl MachInstEmit for Inst {
                 sink.bind_label(out_label, &mut state.ctrl_plane);
             }
             &Inst::MovToNZCV { rn } => {
-                let rn = allocs.next(rn);
                 sink.put4(0xd51b4200 | machreg_to_gpr(rn));
             }
             &Inst::MovFromNZCV { rd } => {
-                let rd = allocs.next_writable(rd);
                 sink.put4(0xd53b4200 | machreg_to_gpr(rd.to_reg()));
             }
             &Inst::Extend {
@@ -3050,8 +2848,6 @@ impl MachInstEmit for Inst {
                 from_bits: 1,
                 to_bits,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
                 assert!(to_bits <= 64);
                 // Reduce zero-extend-from-1-bit to:
                 // - and rd, rn, #1
@@ -3065,7 +2861,7 @@ impl MachInstEmit for Inst {
                     rn,
                     imml,
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
             }
             &Inst::Extend {
                 rd,
@@ -3074,14 +2870,12 @@ impl MachInstEmit for Inst {
                 from_bits: 32,
                 to_bits: 64,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
                 let mov = Inst::Mov {
                     size: OperandSize::Size32,
                     rd,
                     rm: rn,
                 };
-                mov.emit(&[], sink, emit_info, state);
+                mov.emit(sink, emit_info, state);
             }
             &Inst::Extend {
                 rd,
@@ -3090,8 +2884,6 @@ impl MachInstEmit for Inst {
                 from_bits,
                 to_bits,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
                 let (opc, size) = if signed {
                     (0b00, OperandSize::from_bits(to_bits))
                 } else {
@@ -3126,57 +2918,59 @@ impl MachInstEmit for Inst {
 
                 if is_hint {
                     sink.put4(key.enc_auti_hint());
-                    Inst::Ret {}.emit(&[], sink, emit_info, state);
+                    Inst::Ret {}.emit(sink, emit_info, state);
                 } else {
                     sink.put4(0xd65f0bff | (op2 << 9)); // reta{key}
                 }
             }
             &Inst::Call { ref info } => {
-                if let Some(s) = state.take_stack_map() {
-                    sink.add_stack_map(StackMapExtent::UpcomingBytes(4), s);
-                }
+                let user_stack_map = state.take_stack_map();
                 sink.add_reloc(Reloc::Arm64Call, &info.dest, 0);
                 sink.put4(enc_jump26(0b100101, 0));
-                if info.opcode.is_call() {
-                    sink.add_call_site(info.opcode);
+                if let Some(s) = user_stack_map {
+                    let offset = sink.cur_offset();
+                    sink.push_user_stack_map(state, offset, s);
                 }
+                sink.add_call_site();
 
-                let callee_pop_size = i64::from(info.callee_pop_size);
-                state.virtual_sp_offset -= callee_pop_size;
-                trace!(
-                    "call adjusts virtual sp offset by {callee_pop_size} -> {}",
-                    state.virtual_sp_offset
-                );
+                if info.callee_pop_size > 0 {
+                    let callee_pop_size =
+                        i32::try_from(info.callee_pop_size).expect("callee popped more than 2GB");
+                    for inst in AArch64MachineDeps::gen_sp_reg_adjust(-callee_pop_size) {
+                        inst.emit(sink, emit_info, state);
+                    }
+                }
             }
             &Inst::CallInd { ref info } => {
-                if let Some(s) = state.take_stack_map() {
-                    sink.add_stack_map(StackMapExtent::UpcomingBytes(4), s);
-                }
-                let rn = allocs.next(info.rn);
+                let user_stack_map = state.take_stack_map();
+                let rn = info.rn;
                 sink.put4(0b1101011_0001_11111_000000_00000_00000 | (machreg_to_gpr(rn) << 5));
-                if info.opcode.is_call() {
-                    sink.add_call_site(info.opcode);
+                if let Some(s) = user_stack_map {
+                    let offset = sink.cur_offset();
+                    sink.push_user_stack_map(state, offset, s);
                 }
+                sink.add_call_site();
 
-                let callee_pop_size = i64::from(info.callee_pop_size);
-                state.virtual_sp_offset -= callee_pop_size;
-                trace!(
-                    "call adjusts virtual sp offset by {callee_pop_size} -> {}",
-                    state.virtual_sp_offset
-                );
+                if info.callee_pop_size > 0 {
+                    let callee_pop_size =
+                        i32::try_from(info.callee_pop_size).expect("callee popped more than 2GB");
+                    for inst in AArch64MachineDeps::gen_sp_reg_adjust(-callee_pop_size) {
+                        inst.emit(sink, emit_info, state);
+                    }
+                }
             }
             &Inst::ReturnCall {
                 ref callee,
                 ref info,
             } => {
-                emit_return_call_common_sequence(&mut allocs, sink, emit_info, state, info);
+                emit_return_call_common_sequence(sink, emit_info, state, info);
 
                 // Note: this is not `Inst::Jump { .. }.emit(..)` because we
                 // have different metadata in this case: we don't have a label
                 // for the target, but rather a function relocation.
                 sink.add_reloc(Reloc::Arm64Call, &**callee, 0);
                 sink.put4(enc_jump26(0b000101, 0));
-                sink.add_call_site(ir::Opcode::ReturnCall);
+                sink.add_call_site();
 
                 // `emit_return_call_common_sequence` emits an island if
                 // necessary, so we can safely disable the worst-case-size check
@@ -3184,16 +2978,14 @@ impl MachInstEmit for Inst {
                 start_off = sink.cur_offset();
             }
             &Inst::ReturnCallInd { callee, ref info } => {
-                let callee = allocs.next(callee);
-
-                emit_return_call_common_sequence(&mut allocs, sink, emit_info, state, info);
+                emit_return_call_common_sequence(sink, emit_info, state, info);
 
                 Inst::IndirectBr {
                     rn: callee,
                     targets: vec![],
                 }
-                .emit(&[], sink, emit_info, state);
-                sink.add_call_site(ir::Opcode::ReturnCallIndirect);
+                .emit(sink, emit_info, state);
+                sink.add_call_site();
 
                 // `emit_return_call_common_sequence` emits an island if
                 // necessary, so we can safely disable the worst-case-size check
@@ -3209,12 +3001,35 @@ impl MachInstEmit for Inst {
                 let cond_off = sink.cur_offset();
                 if let Some(l) = taken.as_label() {
                     sink.use_label_at_offset(cond_off, l, LabelUse::Branch19);
-                    let mut allocs_inv = allocs.clone();
+                    let inverted = enc_conditional_br(taken, kind.invert()).to_le_bytes();
+                    sink.add_cond_branch(cond_off, cond_off + 4, l, &inverted[..]);
+                }
+                sink.put4(enc_conditional_br(taken, kind));
+
+                // Unconditional part next.
+                let uncond_off = sink.cur_offset();
+                if let Some(l) = not_taken.as_label() {
+                    sink.use_label_at_offset(uncond_off, l, LabelUse::Branch26);
+                    sink.add_uncond_branch(uncond_off, uncond_off + 4, l);
+                }
+                sink.put4(enc_jump26(0b000101, not_taken.as_offset26_or_zero()));
+            }
+            &Inst::TestBitAndBranch {
+                taken,
+                not_taken,
+                kind,
+                rn,
+                bit,
+            } => {
+                // Emit the conditional branch first
+                let cond_off = sink.cur_offset();
+                if let Some(l) = taken.as_label() {
+                    sink.use_label_at_offset(cond_off, l, LabelUse::Branch14);
                     let inverted =
-                        enc_conditional_br(taken, kind.invert(), &mut allocs_inv).to_le_bytes();
+                        enc_test_bit_and_branch(kind.complement(), taken, rn, bit).to_le_bytes();
                     sink.add_cond_branch(cond_off, cond_off + 4, l, &inverted[..]);
                 }
-                sink.put4(enc_conditional_br(taken, kind, &mut allocs));
+                sink.put4(enc_test_bit_and_branch(kind, taken, rn, bit));
 
                 // Unconditional part next.
                 let uncond_off = sink.cur_offset();
@@ -3225,18 +3040,13 @@ impl MachInstEmit for Inst {
                 sink.put4(enc_jump26(0b000101, not_taken.as_offset26_or_zero()));
             }
             &Inst::TrapIf { kind, trap_code } => {
-                let label = sink.defer_trap(trap_code, state.take_stack_map());
+                let label = sink.defer_trap(trap_code);
                 // condbr KIND, LABEL
                 let off = sink.cur_offset();
-                sink.put4(enc_conditional_br(
-                    BranchTarget::Label(label),
-                    kind,
-                    &mut allocs,
-                ));
+                sink.put4(enc_conditional_br(BranchTarget::Label(label), kind));
                 sink.use_label_at_offset(off, label, LabelUse::Branch19);
             }
             &Inst::IndirectBr { rn, .. } => {
-                let rn = allocs.next(rn);
                 sink.put4(enc_br(rn));
             }
             &Inst::Nop0 => {}
@@ -3248,19 +3058,14 @@ impl MachInstEmit for Inst {
             }
             &Inst::Udf { trap_code } => {
                 sink.add_trap(trap_code);
-                if let Some(s) = state.take_stack_map() {
-                    sink.add_stack_map(StackMapExtent::UpcomingBytes(4), s);
-                }
                 sink.put_data(Inst::TRAP_OPCODE);
             }
             &Inst::Adr { rd, off } => {
-                let rd = allocs.next_writable(rd);
                 assert!(off > -(1 << 20));
                 assert!(off < (1 << 20));
                 sink.put4(enc_adr(off, rd));
             }
             &Inst::Adrp { rd, off } => {
-                let rd = allocs.next_writable(rd);
                 assert!(off > -(1 << 20));
                 assert!(off < (1 << 20));
                 sink.put4(enc_adrp(off, rd));
@@ -3279,19 +3084,13 @@ impl MachInstEmit for Inst {
                 ref targets,
                 ..
             } => {
-                let ridx = allocs.next(ridx);
-                let rtmp1 = allocs.next_writable(rtmp1);
-                let rtmp2 = allocs.next_writable(rtmp2);
                 // This sequence is *one* instruction in the vcode, and is expanded only here at
                 // emission time, because we cannot allow the regalloc to insert spills/reloads in
                 // the middle; we depend on hardcoded PC-rel addressing below.
 
                 // Branch to default when condition code from prior comparison indicates.
-                let br = enc_conditional_br(
-                    BranchTarget::Label(default),
-                    CondBrKind::Cond(Cond::Hs),
-                    &mut AllocationConsumer::default(),
-                );
+                let br =
+                    enc_conditional_br(BranchTarget::Label(default), CondBrKind::Cond(Cond::Hs));
 
                 // No need to inform the sink's branch folding logic about this branch, because it
                 // will not be merged with any other branch, flipped, or elided (it is not preceded
@@ -3309,25 +3108,24 @@ impl MachInstEmit for Inst {
                     rn: zero_reg(),
                     rm: ridx,
                 };
-                inst.emit(&[], sink, emit_info, state);
+                inst.emit(sink, emit_info, state);
                 // Prevent any data value speculation.
-                Inst::Csdb.emit(&[], sink, emit_info, state);
+                Inst::Csdb.emit(sink, emit_info, state);
 
                 // Load address of jump table
                 let inst = Inst::Adr { rd: rtmp1, off: 16 };
-                inst.emit(&[], sink, emit_info, state);
+                inst.emit(sink, emit_info, state);
                 // Load value out of jump table
                 let inst = Inst::SLoad32 {
                     rd: rtmp2,
                     mem: AMode::reg_plus_reg_scaled_extended(
                         rtmp1.to_reg(),
                         rtmp2.to_reg(),
-                        I32,
                         ExtendOp::UXTW,
                     ),
                     flags: MemFlags::trusted(),
                 };
-                inst.emit(&[], sink, emit_info, state);
+                inst.emit(sink, emit_info, state);
                 // Add base of jump table to jump-table-sourced block offset
                 let inst = Inst::AluRRR {
                     alu_op: ALUOp::Add,
@@ -3336,14 +3134,14 @@ impl MachInstEmit for Inst {
                     rn: rtmp1.to_reg(),
                     rm: rtmp2.to_reg(),
                 };
-                inst.emit(&[], sink, emit_info, state);
+                inst.emit(sink, emit_info, state);
                 // Branch to computed address. (`targets` here is only used for successor queries
                 // and is not needed for emission.)
                 let inst = Inst::IndirectBr {
                     rn: rtmp1.to_reg(),
                     targets: vec![],
                 };
-                inst.emit(&[], sink, emit_info, state);
+                inst.emit(sink, emit_info, state);
                 // Emit jump table (table of 32-bit offsets).
                 let jt_off = sink.cur_offset();
                 for &target in targets.iter() {
@@ -3366,8 +3164,6 @@ impl MachInstEmit for Inst {
                 ref name,
                 offset,
             } => {
-                let rd = allocs.next_writable(rd);
-
                 if emit_info.0.is_pic() {
                     // See this CE Example for the variations of this with and without BTI & PAUTH
                     // https://godbolt.org/z/ncqjbbvvn
@@ -3379,7 +3175,7 @@ impl MachInstEmit for Inst {
                     // adrp rd, symbol
                     sink.add_reloc(Reloc::Aarch64AdrGotPage21, &**name, 0);
                     let inst = Inst::Adrp { rd, off: 0 };
-                    inst.emit(&[], sink, emit_info, state);
+                    inst.emit(sink, emit_info, state);
 
                     // ldr rd, [rd, :got_lo12:X]
                     sink.add_reloc(Reloc::Aarch64Ld64GotLo12Nc, &**name, 0);
@@ -3388,7 +3184,7 @@ impl MachInstEmit for Inst {
                         mem: AMode::reg(rd.to_reg()),
                         flags: MemFlags::trusted(),
                     };
-                    inst.emit(&[], sink, emit_info, state);
+                    inst.emit(sink, emit_info, state);
                 } else {
                     // With absolute offsets we set up a load from a preallocated space, and then jump
                     // over it.
@@ -3405,37 +3201,36 @@ impl MachInstEmit for Inst {
                         },
                         flags: MemFlags::trusted(),
                     };
-                    inst.emit(&[], sink, emit_info, state);
+                    inst.emit(sink, emit_info, state);
                     let inst = Inst::Jump {
                         dest: BranchTarget::ResolvedOffset(12),
                     };
-                    inst.emit(&[], sink, emit_info, state);
+                    inst.emit(sink, emit_info, state);
                     sink.add_reloc(Reloc::Abs8, &**name, offset);
                     sink.put8(0);
                 }
             }
             &Inst::LoadAddr { rd, ref mem } => {
-                let rd = allocs.next_writable(rd);
-                let mem = mem.with_allocs(&mut allocs);
-                let (mem_insts, mem) = mem_finalize(Some(sink), &mem, state);
+                let mem = mem.clone();
+                let (mem_insts, mem) = mem_finalize(Some(sink), &mem, I8, state);
                 for inst in mem_insts.into_iter() {
-                    inst.emit(&[], sink, emit_info, state);
+                    inst.emit(sink, emit_info, state);
                 }
 
                 let (reg, index_reg, offset) = match mem {
                     AMode::RegExtended { rn, rm, extendop } => {
-                        let r = allocs.next(rn);
+                        let r = rn;
                         (r, Some((rm, extendop)), 0)
                     }
                     AMode::Unscaled { rn, simm9 } => {
-                        let r = allocs.next(rn);
+                        let r = rn;
                         (r, None, simm9.value())
                     }
                     AMode::UnsignedOffset { rn, uimm12 } => {
-                        let r = allocs.next(rn);
+                        let r = rn;
                         (r, None, uimm12.value() as i32)
                     }
-                    _ => panic!("Unsupported case for LoadAddr: {:?}", mem),
+                    _ => panic!("Unsupported case for LoadAddr: {mem:?}"),
                 };
                 let abs_offset = if offset < 0 {
                     -offset as u64
@@ -3454,7 +3249,7 @@ impl MachInstEmit for Inst {
                         extendop,
                     };
 
-                    add.emit(&[], sink, emit_info, state);
+                    add.emit(sink, emit_info, state);
                 } else if offset == 0 {
                     if reg != rd.to_reg() {
                         let mov = Inst::Mov {
@@ -3463,7 +3258,7 @@ impl MachInstEmit for Inst {
                             rm: reg,
                         };
 
-                        mov.emit(&[], sink, emit_info, state);
+                        mov.emit(sink, emit_info, state);
                     }
                 } else if let Some(imm12) = Imm12::maybe_from_u64(abs_offset) {
                     let add = Inst::AluRRImm12 {
@@ -3473,7 +3268,7 @@ impl MachInstEmit for Inst {
                         rn: reg,
                         imm12,
                     };
-                    add.emit(&[], sink, emit_info, state);
+                    add.emit(sink, emit_info, state);
                 } else {
                     // Use `tmp2` here: `reg` may be `spilltmp` if the `AMode` on this instruction
                     // was initially an `SPOffset`. Assert that `tmp2` is truly free to use. Note
@@ -3484,7 +3279,7 @@ impl MachInstEmit for Inst {
                     debug_assert!(reg != tmp2_reg());
                     let tmp = writable_tmp2_reg();
                     for insn in Inst::load_constant(tmp, abs_offset, &mut |_| tmp).into_iter() {
-                        insn.emit(&[], sink, emit_info, state);
+                        insn.emit(sink, emit_info, state);
                     }
                     let add = Inst::AluRRR {
                         alu_op,
@@ -3493,7 +3288,7 @@ impl MachInstEmit for Inst {
                         rn: reg,
                         rm: tmp.to_reg(),
                     };
-                    add.emit(&[], sink, emit_info, state);
+                    add.emit(sink, emit_info, state);
                 }
             }
             &Inst::Paci { key } => {
@@ -3517,52 +3312,90 @@ impl MachInstEmit for Inst {
 
                 sink.put4(0xd503241f | targets << 6);
             }
-            &Inst::VirtualSPOffsetAdj { offset } => {
-                trace!(
-                    "virtual sp offset adjusted by {} -> {}",
-                    offset,
-                    state.virtual_sp_offset + offset,
-                );
-                state.virtual_sp_offset += offset;
-            }
             &Inst::EmitIsland { needed_space } => {
                 if sink.island_needed(needed_space + 4) {
                     let jump_around_label = sink.get_label();
                     let jmp = Inst::Jump {
                         dest: BranchTarget::Label(jump_around_label),
                     };
-                    jmp.emit(&[], sink, emit_info, state);
+                    jmp.emit(sink, emit_info, state);
                     sink.emit_island(needed_space + 4, &mut state.ctrl_plane);
                     sink.bind_label(jump_around_label, &mut state.ctrl_plane);
                 }
             }
 
-            &Inst::ElfTlsGetAddr { ref symbol, rd } => {
-                let rd = allocs.next_writable(rd);
+            &Inst::ElfTlsGetAddr {
+                ref symbol,
+                rd,
+                tmp,
+            } => {
                 assert_eq!(xreg(0), rd.to_reg());
 
+                // See the original proposal for TLSDESC.
+                // http://www.fsfla.org/~lxoliva/writeups/TLS/paper-lk2006.pdf
+                //
+                // Implement the TLSDESC instruction sequence:
+                //   adrp x0, :tlsdesc:tlsvar
+                //   ldr  tmp, [x0, :tlsdesc_lo12:tlsvar]
+                //   add  x0, x0, :tlsdesc_lo12:tlsvar
+                //   blr  tmp
+                //   mrs  tmp, tpidr_el0
+                //   add  x0, x0, tmp
+                //
                 // This is the instruction sequence that GCC emits for ELF GD TLS Relocations in aarch64
-                // See: https://gcc.godbolt.org/z/KhMh5Gvra
-
-                // adrp x0, <label>
-                sink.add_reloc(Reloc::Aarch64TlsGdAdrPage21, symbol, 0);
-                let inst = Inst::Adrp { rd, off: 0 };
-                inst.emit(&[], sink, emit_info, state);
-
-                // add x0, x0, <label>
-                sink.add_reloc(Reloc::Aarch64TlsGdAddLo12Nc, symbol, 0);
-                sink.put4(0x91000000);
-
-                // bl __tls_get_addr
-                sink.add_reloc(
-                    Reloc::Arm64Call,
-                    &ExternalName::LibCall(LibCall::ElfTlsGetAddr),
-                    0,
-                );
-                sink.put4(0x94000000);
+                // See: https://gcc.godbolt.org/z/e4j7MdErh
 
-                // nop
-                sink.put4(0xd503201f);
+                // adrp x0, :tlsdesc:tlsvar
+                sink.add_reloc(Reloc::Aarch64TlsDescAdrPage21, &**symbol, 0);
+                Inst::Adrp { rd, off: 0 }.emit(sink, emit_info, state);
+
+                // ldr  tmp, [x0, :tlsdesc_lo12:tlsvar]
+                sink.add_reloc(Reloc::Aarch64TlsDescLd64Lo12, &**symbol, 0);
+                Inst::ULoad64 {
+                    rd: tmp,
+                    mem: AMode::reg(rd.to_reg()),
+                    flags: MemFlags::trusted(),
+                }
+                .emit(sink, emit_info, state);
+
+                // add x0, x0, :tlsdesc_lo12:tlsvar
+                sink.add_reloc(Reloc::Aarch64TlsDescAddLo12, &**symbol, 0);
+                Inst::AluRRImm12 {
+                    alu_op: ALUOp::Add,
+                    size: OperandSize::Size64,
+                    rd,
+                    rn: rd.to_reg(),
+                    imm12: Imm12::maybe_from_u64(0).unwrap(),
+                }
+                .emit(sink, emit_info, state);
+
+                // blr tmp
+                sink.add_reloc(Reloc::Aarch64TlsDescCall, &**symbol, 0);
+                Inst::CallInd {
+                    info: crate::isa::Box::new(CallIndInfo {
+                        rn: tmp.to_reg(),
+                        uses: smallvec![],
+                        defs: smallvec![],
+                        clobbers: PRegSet::empty(),
+                        caller_callconv: CallConv::SystemV,
+                        callee_callconv: CallConv::SystemV,
+                        callee_pop_size: 0,
+                    }),
+                }
+                .emit(sink, emit_info, state);
+
+                // mrs tmp, tpidr_el0
+                sink.put4(0xd53bd040 | machreg_to_gpr(tmp.to_reg()));
+
+                // add x0, x0, tmp
+                Inst::AluRRR {
+                    alu_op: ALUOp::Add,
+                    size: OperandSize::Size64,
+                    rd,
+                    rn: rd.to_reg(),
+                    rm: tmp.to_reg(),
+                }
+                .emit(sink, emit_info, state);
             }
 
             &Inst::MachOTlsGetAddr { ref symbol, rd } => {
@@ -3578,7 +3411,6 @@ impl MachInstEmit for Inst {
                 // blr x1 ; Call the function pointer with the descriptor address in x0
                 // ; x0 now contains the TLV address
 
-                let rd = allocs.next_writable(rd);
                 assert_eq!(xreg(0), rd.to_reg());
                 let rtmp = writable_xreg(1);
 
@@ -3596,7 +3428,7 @@ impl MachInstEmit for Inst {
                     mem: AMode::reg(rd.to_reg()),
                     flags: MemFlags::trusted(),
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
 
                 // call function pointer in temp register
                 Inst::CallInd {
@@ -3605,13 +3437,12 @@ impl MachInstEmit for Inst {
                         uses: smallvec![],
                         defs: smallvec![],
                         clobbers: PRegSet::empty(),
-                        opcode: Opcode::CallIndirect,
                         caller_callconv: CallConv::AppleAarch64,
                         callee_callconv: CallConv::AppleAarch64,
                         callee_pop_size: 0,
                     }),
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
             }
 
             &Inst::Unwind { ref inst } => {
@@ -3622,8 +3453,6 @@ impl MachInstEmit for Inst {
 
             &Inst::StackProbeLoop { start, end, step } => {
                 assert!(emit_info.0.enable_probestack());
-                let start = allocs.next_writable(start);
-                let end = allocs.next(end);
 
                 // The loop generated here uses `start` as a counter register to
                 // count backwards until negating it exceeds `end`. In other
@@ -3657,7 +3486,7 @@ impl MachInstEmit for Inst {
                     rn: start.to_reg(),
                     imm12: step,
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
                 Inst::Store32 {
                     rd: regs::zero_reg(),
                     mem: AMode::RegReg {
@@ -3666,7 +3495,7 @@ impl MachInstEmit for Inst {
                     },
                     flags: MemFlags::trusted(),
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
                 Inst::AluRRR {
                     alu_op: ALUOp::AddS,
                     size: OperandSize::Size64,
@@ -3674,7 +3503,7 @@ impl MachInstEmit for Inst {
                     rn: start.to_reg(),
                     rm: end,
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
 
                 let loop_end = sink.get_label();
                 Inst::CondBr {
@@ -3682,7 +3511,7 @@ impl MachInstEmit for Inst {
                     not_taken: BranchTarget::Label(loop_end),
                     kind: CondBrKind::Cond(Cond::Gt),
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
                 sink.bind_label(loop_end, &mut state.ctrl_plane);
             }
         }
@@ -3699,164 +3528,53 @@ impl MachInstEmit for Inst {
         state.clear_post_insn();
     }
 
-    fn pretty_print_inst(&self, allocs: &[Allocation], state: &mut Self::State) -> String {
-        let mut allocs = AllocationConsumer::new(allocs);
-        self.print_with_state(state, &mut allocs)
+    fn pretty_print_inst(&self, state: &mut Self::State) -> String {
+        self.print_with_state(state)
     }
 }
 
 fn emit_return_call_common_sequence(
-    allocs: &mut AllocationConsumer<'_>,
     sink: &mut MachBuffer<Inst>,
     emit_info: &EmitInfo,
     state: &mut EmitState,
     info: &ReturnCallInfo,
 ) {
-    for u in info.uses.iter() {
-        let _ = allocs.next(u.vreg);
-    }
-
-    // We are emitting a dynamic number of instructions and might need an
-    // island. We emit four instructions regardless of how many stack arguments
-    // we have, and then two instructions per word of stack argument space.
-    let new_stack_words = info.new_stack_arg_size / 8;
-    let insts = 4 + 2 * new_stack_words;
-    let size_of_inst = 4;
-    let space_needed = insts * size_of_inst;
-    if sink.island_needed(space_needed) {
-        let jump_around_label = sink.get_label();
-        let jmp = Inst::Jump {
-            dest: BranchTarget::Label(jump_around_label),
-        };
-        jmp.emit(&[], sink, emit_info, state);
-        sink.emit_island(space_needed + 4, &mut state.ctrl_plane);
-        sink.bind_label(jump_around_label, &mut state.ctrl_plane);
+    for inst in
+        AArch64MachineDeps::gen_clobber_restore(CallConv::Tail, &emit_info.0, state.frame_layout())
+    {
+        inst.emit(sink, emit_info, state);
     }
 
-    // Copy the new frame on top of our current frame.
-    //
-    // The current stack layout is the following:
-    //
-    //            | ...                 |
-    //            +---------------------+
-    //            | ...                 |
-    //            | stack arguments     |
-    //            | ...                 |
-    //    current | return address      |
-    //    frame   | old FP              | <-- FP
-    //            | ...                 |
-    //            | old stack slots     |
-    //            | ...                 |
-    //            +---------------------+
-    //            | ...                 |
-    //    new     | new stack arguments |
-    //    frame   | ...                 | <-- SP
-    //            +---------------------+
-    //
-    // We need to restore the old FP, restore the return address from the stack
-    // to the link register, copy the new stack arguments over the old stack
-    // arguments, adjust SP to point to the new stack arguments, and then jump
-    // to the callee (which will push the old FP and RA again). Note that the
-    // actual jump happens outside this helper function.
-
-    assert_eq!(
-        info.new_stack_arg_size % 8,
-        0,
-        "size of new stack arguments must be 8-byte aligned"
-    );
-
-    // The delta from our frame pointer to the (eventual) stack pointer value
-    // when we jump to the tail callee. This is the difference in size of stack
-    // arguments as well as accounting for the two words we pushed onto the
-    // stack upon entry to this function (the return address and old frame
-    // pointer).
-    let fp_to_callee_sp =
-        i64::from(info.old_stack_arg_size) - i64::from(info.new_stack_arg_size) + 16;
-
-    let tmp1 = regs::writable_spilltmp_reg();
-    let tmp2 = regs::writable_tmp2_reg();
-
-    // Restore the return address to the link register, and load the old FP into
-    // a temporary register.
-    //
-    // We can't put the old FP into the FP register until after we copy the
-    // stack arguments into place, since that uses address modes that are
-    // relative to our current FP.
-    //
-    // Note that the FP is saved in the function prologue for all non-leaf
-    // functions, even when `preserve_frame_pointers=false`. Note also that
-    // `return_call` instructions make it so that a function is considered
-    // non-leaf. Therefore we always have an FP to restore here.
-    Inst::LoadP64 {
-        rt: tmp1,
-        rt2: writable_link_reg(),
-        mem: PairAMode::SignedOffset {
-            reg: regs::fp_reg(),
-            simm7: SImm7Scaled::maybe_from_i64(0, types::I64).unwrap(),
-        },
-        flags: MemFlags::trusted(),
-    }
-    .emit(&[], sink, emit_info, state);
-
-    // Copy the new stack arguments over the old stack arguments.
-    for i in (0..new_stack_words).rev() {
-        // Load the `i`th new stack argument word from the temporary stack
-        // space.
-        Inst::ULoad64 {
-            rd: tmp2,
-            mem: AMode::SPOffset {
-                off: i64::from(i * 8),
-                ty: types::I64,
-            },
-            flags: ir::MemFlags::trusted(),
-        }
-        .emit(&[], sink, emit_info, state);
-
-        // Store it to its final destination on the stack, overwriting our
-        // current frame.
-        Inst::Store64 {
-            rd: tmp2.to_reg(),
-            mem: AMode::FPOffset {
-                off: fp_to_callee_sp + i64::from(i * 8),
-                ty: types::I64,
+    let setup_area_size = state.frame_layout().setup_area_size;
+    if setup_area_size > 0 {
+        // N.B.: sp is already adjusted to the appropriate place by the
+        // clobber-restore code (which also frees the fixed frame). Hence, there
+        // is no need for the usual `mov sp, fp` here.
+
+        // `ldp fp, lr, [sp], #16`
+        Inst::LoadP64 {
+            rt: writable_fp_reg(),
+            rt2: writable_link_reg(),
+            mem: PairAMode::SPPostIndexed {
+                // TODO: we could fold the increment for incoming_args_diff here, as long as that
+                // value is less than 502*8, by adding it to `setup_area_size`.
+                // https://developer.arm.com/documentation/ddi0596/2020-12/Base-Instructions/LDP--Load-Pair-of-Registers-
+                simm7: SImm7Scaled::maybe_from_i64(i64::from(setup_area_size), types::I64).unwrap(),
             },
-            flags: ir::MemFlags::trusted(),
+            flags: MemFlags::trusted(),
         }
-        .emit(&[], sink, emit_info, state);
+        .emit(sink, emit_info, state);
     }
 
-    // Initialize the SP for the tail callee, deallocating the temporary stack
-    // argument space and our current frame at the same time.
-    let (off, alu_op) = if let Ok(off) = u64::try_from(fp_to_callee_sp) {
-        (off, ALUOp::Add)
-    } else {
-        let abs = fp_to_callee_sp.abs();
-        let off = u64::try_from(abs).unwrap();
-        (off, ALUOp::Sub)
-    };
-    Inst::AluRRImm12 {
-        alu_op,
-        size: OperandSize::Size64,
-        rd: regs::writable_stack_reg(),
-        rn: regs::fp_reg(),
-        imm12: Imm12::maybe_from_u64(off).unwrap(),
-    }
-    .emit(&[], sink, emit_info, state);
-
-    // Move the old FP value from the temporary into the FP register.
-    Inst::Mov {
-        size: OperandSize::Size64,
-        rd: regs::writable_fp_reg(),
-        rm: tmp1.to_reg(),
+    // Adjust SP to account for the possible over-allocation in the prologue.
+    let incoming_args_diff = state.frame_layout().tail_args_size - info.new_stack_arg_size;
+    if incoming_args_diff > 0 {
+        for inst in
+            AArch64MachineDeps::gen_sp_reg_adjust(i32::try_from(incoming_args_diff).unwrap())
+        {
+            inst.emit(sink, emit_info, state);
+        }
     }
-    .emit(&[], sink, emit_info, state);
-
-    state.virtual_sp_offset -= i64::from(info.new_stack_arg_size);
-    trace!(
-        "return_call[_ind] adjusts virtual sp offset by {} -> {}",
-        info.new_stack_arg_size,
-        state.virtual_sp_offset
-    );
 
     if let Some(key) = info.key {
         sink.put4(key.enc_auti_hint());
diff --git a/cranelift/codegen/src/isa/aarch64/inst/emit_tests.rs b/cranelift/codegen/src/isa/aarch64/inst/emit_tests.rs
index 2b572882be42..0b50795ec39a 100644
--- a/cranelift/codegen/src/isa/aarch64/inst/emit_tests.rs
+++ b/cranelift/codegen/src/isa/aarch64/inst/emit_tests.rs
@@ -1,11 +1,8 @@
 use crate::ir::types::*;
 use crate::ir::TrapCode;
 use crate::isa::aarch64::inst::*;
-use crate::isa::CallConv;
-use crate::settings;
 
 use alloc::boxed::Box;
-use alloc::vec::Vec;
 
 #[cfg(test)]
 fn simm9_zero() -> SImm9 {
@@ -1554,7 +1551,6 @@ fn test_aarch64_binemit() {
             mem: AMode::RegScaled {
                 rn: xreg(2),
                 rm: xreg(3),
-                ty: I16,
             },
             flags: MemFlags::trusted(),
         },
@@ -1591,7 +1587,6 @@ fn test_aarch64_binemit() {
             mem: AMode::RegScaled {
                 rn: xreg(20),
                 rm: xreg(20),
-                ty: I16,
             },
             flags: MemFlags::trusted(),
         },
@@ -1628,7 +1623,6 @@ fn test_aarch64_binemit() {
             mem: AMode::RegScaled {
                 rn: xreg(2),
                 rm: xreg(12),
-                ty: I32,
             },
             flags: MemFlags::trusted(),
         },
@@ -1665,7 +1659,6 @@ fn test_aarch64_binemit() {
             mem: AMode::RegScaled {
                 rn: xreg(5),
                 rm: xreg(1),
-                ty: I32,
             },
             flags: MemFlags::trusted(),
         },
@@ -1738,7 +1731,6 @@ fn test_aarch64_binemit() {
             mem: AMode::RegScaled {
                 rn: xreg(2),
                 rm: xreg(3),
-                ty: I64,
             },
             flags: MemFlags::trusted(),
         },
@@ -1751,7 +1743,6 @@ fn test_aarch64_binemit() {
             mem: AMode::RegScaledExtended {
                 rn: xreg(2),
                 rm: xreg(3),
-                ty: I64,
                 extendop: ExtendOp::SXTW,
             },
             flags: MemFlags::trusted(),
@@ -1808,7 +1799,7 @@ fn test_aarch64_binemit() {
     insns.push((
         Inst::ULoad64 {
             rd: writable_xreg(1),
-            mem: AMode::FPOffset { off: 32768, ty: I8 },
+            mem: AMode::FPOffset { off: 32768 },
             flags: MemFlags::trusted(),
         },
         "100090D2A1EB70F8",
@@ -1817,10 +1808,7 @@ fn test_aarch64_binemit() {
     insns.push((
         Inst::ULoad64 {
             rd: writable_xreg(1),
-            mem: AMode::FPOffset {
-                off: -32768,
-                ty: I8,
-            },
+            mem: AMode::FPOffset { off: -32768 },
             flags: MemFlags::trusted(),
         },
         "F0FF8F92A1EB70F8",
@@ -1829,10 +1817,7 @@ fn test_aarch64_binemit() {
     insns.push((
         Inst::ULoad64 {
             rd: writable_xreg(1),
-            mem: AMode::FPOffset {
-                off: 1048576,
-                ty: I8,
-            }, // 2^20
+            mem: AMode::FPOffset { off: 1048576 }, // 2^20
             flags: MemFlags::trusted(),
         },
         "1002A0D2A1EB70F8",
@@ -1841,10 +1826,7 @@ fn test_aarch64_binemit() {
     insns.push((
         Inst::ULoad64 {
             rd: writable_xreg(1),
-            mem: AMode::FPOffset {
-                off: 1048576 + 1,
-                ty: I8,
-            }, // 2^20 + 1
+            mem: AMode::FPOffset { off: 1048576 + 1 }, // 2^20 + 1
             flags: MemFlags::trusted(),
         },
         "300080521002A072A1EB70F8",
@@ -1857,7 +1839,6 @@ fn test_aarch64_binemit() {
             mem: AMode::RegOffset {
                 rn: xreg(7),
                 off: 8,
-                ty: I64,
             },
             flags: MemFlags::trusted(),
         },
@@ -1871,7 +1852,6 @@ fn test_aarch64_binemit() {
             mem: AMode::RegOffset {
                 rn: xreg(7),
                 off: 1024,
-                ty: I64,
             },
             flags: MemFlags::trusted(),
         },
@@ -1885,7 +1865,6 @@ fn test_aarch64_binemit() {
             mem: AMode::RegOffset {
                 rn: xreg(7),
                 off: 1048576,
-                ty: I64,
             },
             flags: MemFlags::trusted(),
         },
@@ -2007,7 +1986,6 @@ fn test_aarch64_binemit() {
             mem: AMode::RegScaled {
                 rn: xreg(2),
                 rm: xreg(3),
-                ty: I64,
             },
             flags: MemFlags::trusted(),
         },
@@ -2020,7 +1998,6 @@ fn test_aarch64_binemit() {
             mem: AMode::RegScaledExtended {
                 rn: xreg(2),
                 rm: xreg(3),
-                ty: I64,
                 extendop: ExtendOp::UXTW,
             },
             flags: MemFlags::trusted(),
@@ -6084,7 +6061,6 @@ fn test_aarch64_binemit() {
                 uses: smallvec![],
                 defs: smallvec![],
                 clobbers: PRegSet::empty(),
-                opcode: Opcode::Call,
                 caller_callconv: CallConv::SystemV,
                 callee_callconv: CallConv::SystemV,
                 callee_pop_size: 0,
@@ -6101,7 +6077,6 @@ fn test_aarch64_binemit() {
                 uses: smallvec![],
                 defs: smallvec![],
                 clobbers: PRegSet::empty(),
-                opcode: Opcode::CallIndirect,
                 caller_callconv: CallConv::SystemV,
                 callee_callconv: CallConv::SystemV,
                 callee_pop_size: 0,
@@ -6158,6 +6133,15 @@ fn test_aarch64_binemit() {
         "fmov d8, d4",
     ));
 
+    insns.push((
+        Inst::FpuMove32 {
+            rd: writable_vreg(8),
+            rn: vreg(4),
+        },
+        "8840201E",
+        "fmov s8, s4",
+    ));
+
     insns.push((
         Inst::FpuMove128 {
             rd: writable_vreg(17),
@@ -6454,6 +6438,19 @@ fn test_aarch64_binemit() {
         "fmadd s15, s30, s31, s1",
     ));
 
+    insns.push((
+        Inst::FpuRRRR {
+            fpu_op: FPUOp3::MSub,
+            size: ScalarSize::Size32,
+            rd: writable_vreg(15),
+            rn: vreg(30),
+            rm: vreg(31),
+            ra: vreg(1),
+        },
+        "CF871F1F",
+        "fmsub s15, s30, s31, s1",
+    ));
+
     insns.push((
         Inst::FpuRRRR {
             fpu_op: FPUOp3::MAdd,
@@ -6467,6 +6464,45 @@ fn test_aarch64_binemit() {
         "fmadd d15, d30, d31, d1",
     ));
 
+    insns.push((
+        Inst::FpuRRRR {
+            fpu_op: FPUOp3::MSub,
+            size: ScalarSize::Size64,
+            rd: writable_vreg(15),
+            rn: vreg(30),
+            rm: vreg(31),
+            ra: vreg(1),
+        },
+        "CF875F1F",
+        "fmsub d15, d30, d31, d1",
+    ));
+
+    insns.push((
+        Inst::FpuRRRR {
+            fpu_op: FPUOp3::NMAdd,
+            size: ScalarSize::Size64,
+            rd: writable_vreg(15),
+            rn: vreg(30),
+            rm: vreg(31),
+            ra: vreg(1),
+        },
+        "CF077F1F",
+        "fnmadd d15, d30, d31, d1",
+    ));
+
+    insns.push((
+        Inst::FpuRRRR {
+            fpu_op: FPUOp3::NMSub,
+            size: ScalarSize::Size64,
+            rd: writable_vreg(15),
+            rn: vreg(30),
+            rm: vreg(31),
+            ra: vreg(1),
+        },
+        "CF877F1F",
+        "fnmsub d15, d30, d31, d1",
+    ));
+
     insns.push((
         Inst::FpuRRI {
             fpu_op: FPUOpRI::UShr32(FPURightShiftImm::maybe_from_u8(32, 32).unwrap()),
@@ -6689,13 +6725,25 @@ fn test_aarch64_binemit() {
         "fcmp d23, d24",
     ));
 
+    insns.push((
+        Inst::FpuLoad16 {
+            rd: writable_vreg(16),
+            mem: AMode::RegScaled {
+                rn: xreg(8),
+                rm: xreg(9),
+            },
+            flags: MemFlags::trusted(),
+        },
+        "1079697C",
+        "ldr h16, [x8, x9, LSL #1]",
+    ));
+
     insns.push((
         Inst::FpuLoad32 {
             rd: writable_vreg(16),
             mem: AMode::RegScaled {
                 rn: xreg(8),
                 rm: xreg(9),
-                ty: F32,
             },
             flags: MemFlags::trusted(),
         },
@@ -6709,7 +6757,6 @@ fn test_aarch64_binemit() {
             mem: AMode::RegScaled {
                 rn: xreg(8),
                 rm: xreg(9),
-                ty: F64,
             },
             flags: MemFlags::trusted(),
         },
@@ -6723,7 +6770,6 @@ fn test_aarch64_binemit() {
             mem: AMode::RegScaled {
                 rn: xreg(8),
                 rm: xreg(9),
-                ty: I128,
             },
             flags: MemFlags::trusted(),
         },
@@ -6767,13 +6813,25 @@ fn test_aarch64_binemit() {
         "ldr q16, pc+8",
     ));
 
+    insns.push((
+        Inst::FpuStore16 {
+            rd: vreg(16),
+            mem: AMode::RegScaled {
+                rn: xreg(8),
+                rm: xreg(9),
+            },
+            flags: MemFlags::trusted(),
+        },
+        "1079297C",
+        "str h16, [x8, x9, LSL #1]",
+    ));
+
     insns.push((
         Inst::FpuStore32 {
             rd: vreg(16),
             mem: AMode::RegScaled {
                 rn: xreg(8),
                 rm: xreg(9),
-                ty: F32,
             },
             flags: MemFlags::trusted(),
         },
@@ -6787,7 +6845,6 @@ fn test_aarch64_binemit() {
             mem: AMode::RegScaled {
                 rn: xreg(8),
                 rm: xreg(9),
-                ty: F64,
             },
             flags: MemFlags::trusted(),
         },
@@ -6801,7 +6858,6 @@ fn test_aarch64_binemit() {
             mem: AMode::RegScaled {
                 rn: xreg(8),
                 rm: xreg(9),
-                ty: I128,
             },
             flags: MemFlags::trusted(),
         },
@@ -6969,6 +7025,17 @@ fn test_aarch64_binemit() {
         "stp q18, q22, [sp], #304",
     ));
 
+    insns.push((
+        Inst::FpuCSel16 {
+            rd: writable_vreg(1),
+            rn: vreg(2),
+            rm: vreg(3),
+            cond: Cond::Hi,
+        },
+        "418CE31E",
+        "fcsel h1, h2, h3, hi",
+    ));
+
     insns.push((
         Inst::FpuCSel32 {
             rd: writable_vreg(1),
@@ -7877,18 +7944,14 @@ fn test_aarch64_binemit() {
     let flags = settings::Flags::new(settings::builder());
     let emit_info = EmitInfo::new(flags);
     for (insn, expected_encoding, expected_printing) in insns {
-        println!(
-            "AArch64: {:?}, {}, {}",
-            insn, expected_encoding, expected_printing
-        );
+        println!("AArch64: {insn:?}, {expected_encoding}, {expected_printing}");
 
         // Check the printed text is as expected.
-        let actual_printing =
-            insn.print_with_state(&mut EmitState::default(), &mut AllocationConsumer::new(&[]));
+        let actual_printing = insn.print_with_state(&mut EmitState::default());
         assert_eq!(expected_printing, actual_printing);
 
         let mut buffer = MachBuffer::new();
-        insn.emit(&[], &mut buffer, &emit_info, &mut Default::default());
+        insn.emit(&mut buffer, &emit_info, &mut Default::default());
         let buffer = buffer.finish(&Default::default(), &mut Default::default());
         let actual_encoding = &buffer.stringify_code_bytes();
         assert_eq!(expected_encoding, actual_encoding);
diff --git a/cranelift/codegen/src/isa/aarch64/inst/imms.rs b/cranelift/codegen/src/isa/aarch64/inst/imms.rs
index 7617d1be3258..8fb9b97855c3 100644
--- a/cranelift/codegen/src/isa/aarch64/inst/imms.rs
+++ b/cranelift/codegen/src/isa/aarch64/inst/imms.rs
@@ -1,11 +1,9 @@
 //! AArch64 ISA definitions: immediate constants.
 
 use crate::ir::types::*;
-use crate::ir::Type;
 use crate::isa::aarch64::inst::{OperandSize, ScalarSize};
-use crate::machinst::{AllocationConsumer, PrettyPrint};
+use crate::machinst::PrettyPrint;
 
-use core::convert::TryFrom;
 use std::string::String;
 
 /// An immediate that represents the NZCV flags.
@@ -180,7 +178,7 @@ impl FPURightShiftImm {
         // | 32                | 01xxxxx  |
         // | 64                | 1xxxxxx  |
         //
-        // The shift amount is negated such that a shift ammount
+        // The shift amount is negated such that a shift amount
         // of 1 (in 64-bit) is encoded as 0b111111 and a shift
         // amount of 64 is encoded as 0b000000,
         // in the bottom 6 bits.
@@ -222,9 +220,9 @@ impl SImm9 {
 #[derive(Clone, Copy, Debug)]
 pub struct UImm12Scaled {
     /// The value.
-    pub value: u16,
+    value: u16,
     /// multiplied by the size of this type
-    pub scale_ty: Type,
+    scale_ty: Type,
 }
 
 impl UImm12Scaled {
@@ -259,11 +257,6 @@ impl UImm12Scaled {
     pub fn value(&self) -> u32 {
         self.value as u32
     }
-
-    /// The value type which is the scaling base.
-    pub fn scale_ty(&self) -> Type {
-        self.scale_ty
-    }
 }
 
 /// A shifted immediate value in 'imm12' format: supports 12 bits, shifted
@@ -307,6 +300,16 @@ impl Imm12 {
     pub fn imm_bits(&self) -> u32 {
         self.bits as u32
     }
+
+    /// Get the actual value that this immediate corresponds to.
+    pub fn value(&self) -> u32 {
+        let base = self.bits as u32;
+        if self.shift12 {
+            base << 12
+        } else {
+            base
+        }
+    }
 }
 
 /// An immediate for logical instructions.
@@ -623,10 +626,10 @@ impl MoveWideConst {
 /// Advanced SIMD modified immediate as used by MOVI/MVNI.
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub struct ASIMDMovModImm {
-    imm: u8,
-    shift: u8,
-    is_64bit: bool,
-    shift_ones: bool,
+    pub imm: u8,
+    pub shift: u8,
+    pub is_64bit: bool,
+    pub shift_ones: bool,
 }
 
 impl ASIMDMovModImm {
@@ -746,8 +749,8 @@ impl ASIMDMovModImm {
 /// Advanced SIMD modified immediate as used by the vector variant of FMOV.
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub struct ASIMDFPModImm {
-    imm: u8,
-    is_64bit: bool,
+    pub imm: u8,
+    pub size: ScalarSize,
 }
 
 impl ASIMDFPModImm {
@@ -756,6 +759,21 @@ impl ASIMDFPModImm {
         // In all cases immediates are encoded as an 8-bit number 0b_abcdefgh;
         // let `D` be the inverse of the digit `d`.
         match size {
+            ScalarSize::Size16 => {
+                // In this case the representable immediates are 16-bit numbers of the form
+                // 0b_aBbb_cdef_gh00_0000.
+                let value = value as u16;
+                let b0_5 = (value >> 6) & 0b111111;
+                let b6 = (value >> 6) & (1 << 6);
+                let b7 = (value >> 8) & (1 << 7);
+                let imm = (b0_5 | b6 | b7) as u8;
+
+                if value == Self::value16(imm) {
+                    Some(ASIMDFPModImm { imm, size })
+                } else {
+                    None
+                }
+            }
             ScalarSize::Size32 => {
                 // In this case the representable immediates are 32-bit numbers of the form
                 // 0b_aBbb_bbbc_defg_h000 shifted to the left by 16.
@@ -766,10 +784,7 @@ impl ASIMDFPModImm {
                 let imm = (b0_5 | b6 | b7) as u8;
 
                 if value == Self::value32(imm) {
-                    Some(ASIMDFPModImm {
-                        imm,
-                        is_64bit: false,
-                    })
+                    Some(ASIMDFPModImm { imm, size })
                 } else {
                     None
                 }
@@ -783,10 +798,7 @@ impl ASIMDFPModImm {
                 let imm = (b0_5 | b6 | b7) as u8;
 
                 if value == Self::value64(imm) {
-                    Some(ASIMDFPModImm {
-                        imm,
-                        is_64bit: true,
-                    })
+                    Some(ASIMDFPModImm { imm, size })
                 } else {
                     None
                 }
@@ -800,6 +812,17 @@ impl ASIMDFPModImm {
         self.imm
     }
 
+    /// Returns the 16-bit value that corresponds to an 8-bit encoding.
+    fn value16(imm: u8) -> u16 {
+        let imm = imm as u16;
+        let b0_5 = imm & 0b111111;
+        let b6 = (imm >> 6) & 1;
+        let b6_inv = b6 ^ 1;
+        let b7 = (imm >> 7) & 1;
+
+        b0_5 << 6 | (b6 * 0b11) << 12 | b6_inv << 14 | b7 << 15
+    }
+
     /// Returns the 32-bit value that corresponds to an 8-bit encoding.
     fn value32(imm: u8) -> u32 {
         let imm = imm as u32;
@@ -824,7 +847,7 @@ impl ASIMDFPModImm {
 }
 
 impl PrettyPrint for NZCV {
-    fn pretty_print(&self, _: u8, _: &mut AllocationConsumer<'_>) -> String {
+    fn pretty_print(&self, _: u8) -> String {
         let fmt = |c: char, v| if v { c.to_ascii_uppercase() } else { c };
         format!(
             "#{}{}{}{}",
@@ -837,63 +860,63 @@ impl PrettyPrint for NZCV {
 }
 
 impl PrettyPrint for UImm5 {
-    fn pretty_print(&self, _: u8, _: &mut AllocationConsumer<'_>) -> String {
+    fn pretty_print(&self, _: u8) -> String {
         format!("#{}", self.value)
     }
 }
 
 impl PrettyPrint for Imm12 {
-    fn pretty_print(&self, _: u8, _: &mut AllocationConsumer<'_>) -> String {
+    fn pretty_print(&self, _: u8) -> String {
         let shift = if self.shift12 { 12 } else { 0 };
         let value = u32::from(self.bits) << shift;
-        format!("#{}", value)
+        format!("#{value}")
     }
 }
 
 impl PrettyPrint for SImm7Scaled {
-    fn pretty_print(&self, _: u8, _: &mut AllocationConsumer<'_>) -> String {
+    fn pretty_print(&self, _: u8) -> String {
         format!("#{}", self.value)
     }
 }
 
 impl PrettyPrint for FPULeftShiftImm {
-    fn pretty_print(&self, _: u8, _: &mut AllocationConsumer<'_>) -> String {
+    fn pretty_print(&self, _: u8) -> String {
         format!("#{}", self.amount)
     }
 }
 
 impl PrettyPrint for FPURightShiftImm {
-    fn pretty_print(&self, _: u8, _: &mut AllocationConsumer<'_>) -> String {
+    fn pretty_print(&self, _: u8) -> String {
         format!("#{}", self.amount)
     }
 }
 
 impl PrettyPrint for SImm9 {
-    fn pretty_print(&self, _: u8, _: &mut AllocationConsumer<'_>) -> String {
+    fn pretty_print(&self, _: u8) -> String {
         format!("#{}", self.value)
     }
 }
 
 impl PrettyPrint for UImm12Scaled {
-    fn pretty_print(&self, _: u8, _: &mut AllocationConsumer<'_>) -> String {
+    fn pretty_print(&self, _: u8) -> String {
         format!("#{}", self.value)
     }
 }
 
 impl PrettyPrint for ImmLogic {
-    fn pretty_print(&self, _: u8, _: &mut AllocationConsumer<'_>) -> String {
+    fn pretty_print(&self, _: u8) -> String {
         format!("#{}", self.value())
     }
 }
 
 impl PrettyPrint for ImmShift {
-    fn pretty_print(&self, _: u8, _: &mut AllocationConsumer<'_>) -> String {
+    fn pretty_print(&self, _: u8) -> String {
         format!("#{}", self.imm)
     }
 }
 
 impl PrettyPrint for MoveWideConst {
-    fn pretty_print(&self, _: u8, _: &mut AllocationConsumer<'_>) -> String {
+    fn pretty_print(&self, _: u8) -> String {
         if self.shift == 0 {
             format!("#{}", self.bits)
         } else {
@@ -903,7 +926,7 @@ impl PrettyPrint for MoveWideConst {
 }
 
 impl PrettyPrint for ASIMDMovModImm {
-    fn pretty_print(&self, _: u8, _: &mut AllocationConsumer<'_>) -> String {
+    fn pretty_print(&self, _: u8) -> String {
         if self.is_64bit {
             debug_assert_eq!(self.shift, 0);
 
@@ -916,7 +939,7 @@ impl PrettyPrint for ASIMDMovModImm {
                 imm |= (-b as u8 as u64) << (i * 8);
             }
 
-            format!("#{}", imm)
+            format!("#{imm}")
         } else if self.shift == 0 {
             format!("#{}", self.imm)
         } else {
@@ -927,11 +950,22 @@ impl PrettyPrint for ASIMDMovModImm {
 }
 
 impl PrettyPrint for ASIMDFPModImm {
-    fn pretty_print(&self, _: u8, _: &mut AllocationConsumer<'_>) -> String {
-        if self.is_64bit {
-            format!("#{}", f64::from_bits(Self::value64(self.imm)))
-        } else {
-            format!("#{}", f32::from_bits(Self::value32(self.imm)))
+    fn pretty_print(&self, _: u8) -> String {
+        match self.size {
+            ScalarSize::Size16 => {
+                // FIXME(#8312): Use `f16` once it is stable.
+                // `value` will always be a normal number. Convert it to a `f32`.
+                let value: u32 = Self::value16(self.imm).into();
+                let sign = (value & 0x8000) << 16;
+                // Adjust the exponent for the difference between the `f16` exponent bias and the
+                // `f32` exponent bias.
+                let exponent = ((value & 0x7c00) + ((127 - 15) << 10)) << 13;
+                let significand = (value & 0x3ff) << 13;
+                format!("#{}", f32::from_bits(sign | exponent | significand))
+            }
+            ScalarSize::Size32 => format!("#{}", f32::from_bits(Self::value32(self.imm))),
+            ScalarSize::Size64 => format!("#{}", f64::from_bits(Self::value64(self.imm))),
+            _ => unreachable!(),
         }
     }
 }
diff --git a/cranelift/codegen/src/isa/aarch64/inst/mod.rs b/cranelift/codegen/src/isa/aarch64/inst/mod.rs
index e916d9e72359..d5a588244e91 100644
--- a/cranelift/codegen/src/isa/aarch64/inst/mod.rs
+++ b/cranelift/codegen/src/isa/aarch64/inst/mod.rs
@@ -1,8 +1,8 @@
 //! This module defines aarch64-specific machine instruction types.
 
 use crate::binemit::{Addend, CodeOffset, Reloc};
-use crate::ir::types::{F32, F64, I128, I16, I32, I64, I8, I8X16, R32, R64};
-use crate::ir::{types, ExternalName, MemFlags, Opcode, Type};
+use crate::ir::types::{F128, F16, F32, F64, I128, I16, I32, I64, I8, I8X16};
+use crate::ir::{types, ExternalName, MemFlags, Type};
 use crate::isa::{CallConv, FunctionAlignment};
 use crate::machinst::*;
 use crate::{settings, CodegenError, CodegenResult};
@@ -10,13 +10,13 @@ use crate::{settings, CodegenError, CodegenResult};
 use crate::machinst::{PrettyPrint, Reg, RegClass, Writable};
 
 use alloc::vec::Vec;
-use regalloc2::{PRegSet, VReg};
+use regalloc2::PRegSet;
 use smallvec::{smallvec, SmallVec};
 use std::fmt::Write;
 use std::string::{String, ToString};
 
 pub(crate) mod regs;
-pub(crate) use self::regs::*;
+pub use self::regs::*;
 pub mod imms;
 pub use self::imms::*;
 pub mod args;
@@ -86,8 +86,6 @@ pub struct CallInfo {
     pub defs: CallRetList,
     /// Clobbers register set.
     pub clobbers: PRegSet,
-    /// Instruction opcode.
-    pub opcode: Opcode,
     /// Caller calling convention.
     pub caller_callconv: CallConv,
     /// Callee calling convention.
@@ -110,8 +108,6 @@ pub struct CallIndInfo {
     pub defs: SmallVec<[CallRetPair; 8]>,
     /// Clobbers register set.
     pub clobbers: PRegSet,
-    /// Instruction opcode.
-    pub opcode: Opcode,
     /// Caller calling convention.
     pub caller_callconv: CallConv,
     /// Callee calling convention.
@@ -128,10 +124,6 @@ pub struct CallIndInfo {
 pub struct ReturnCallInfo {
     /// Arguments to the call instruction.
     pub uses: CallArgList,
-    /// Instruction opcode.
-    pub opcode: Opcode,
-    /// The size of the current/old stack frame's stack arguments.
-    pub old_stack_arg_size: u32,
     /// The size of the new stack frame's stack arguments. This is necessary
     /// for copying the frame over our current frame. It must already be
     /// allocated on the stack.
@@ -160,7 +152,7 @@ fn inst_size_test() {
 }
 
 impl Inst {
-    /// Create an instruction that loads a constant, using one of serveral options (MOVZ, MOVN,
+    /// Create an instruction that loads a constant, using one of several options (MOVZ, MOVN,
     /// logical immediate, or constant pool).
     pub fn load_constant<F: FnMut(Type) -> Writable<Reg>>(
         rd: Writable<Reg>,
@@ -279,12 +271,17 @@ impl Inst {
                 mem,
                 flags,
             },
-            I32 | R32 => Inst::ULoad32 {
+            I32 => Inst::ULoad32 {
                 rd: into_reg,
                 mem,
                 flags,
             },
-            I64 | R64 => Inst::ULoad64 {
+            I64 => Inst::ULoad64 {
+                rd: into_reg,
+                mem,
+                flags,
+            },
+            F16 => Inst::FpuLoad16 {
                 rd: into_reg,
                 mem,
                 flags,
@@ -300,7 +297,7 @@ impl Inst {
                 flags,
             },
             _ => {
-                if ty.is_vector() {
+                if ty.is_vector() || ty.is_float() {
                     let bits = ty_bits(ty);
                     let rd = into_reg;
 
@@ -330,12 +327,17 @@ impl Inst {
                 mem,
                 flags,
             },
-            I32 | R32 => Inst::Store32 {
+            I32 => Inst::Store32 {
                 rd: from_reg,
                 mem,
                 flags,
             },
-            I64 | R64 => Inst::Store64 {
+            I64 => Inst::Store64 {
+                rd: from_reg,
+                mem,
+                flags,
+            },
+            F16 => Inst::FpuStore16 {
                 rd: from_reg,
                 mem,
                 flags,
@@ -351,7 +353,7 @@ impl Inst {
                 flags,
             },
             _ => {
-                if ty.is_vector() {
+                if ty.is_vector() || ty.is_float() {
                     let bits = ty_bits(ty);
                     let rd = from_reg;
 
@@ -367,160 +369,179 @@ impl Inst {
             }
         }
     }
+
+    /// What type does this load or store instruction access in memory? When
+    /// uimm12 encoding is used, the size of this type is the amount that
+    /// immediate offsets are scaled by.
+    pub fn mem_type(&self) -> Option<Type> {
+        match self {
+            Inst::ULoad8 { .. } => Some(I8),
+            Inst::SLoad8 { .. } => Some(I8),
+            Inst::ULoad16 { .. } => Some(I16),
+            Inst::SLoad16 { .. } => Some(I16),
+            Inst::ULoad32 { .. } => Some(I32),
+            Inst::SLoad32 { .. } => Some(I32),
+            Inst::ULoad64 { .. } => Some(I64),
+            Inst::FpuLoad16 { .. } => Some(F16),
+            Inst::FpuLoad32 { .. } => Some(F32),
+            Inst::FpuLoad64 { .. } => Some(F64),
+            Inst::FpuLoad128 { .. } => Some(I8X16),
+            Inst::Store8 { .. } => Some(I8),
+            Inst::Store16 { .. } => Some(I16),
+            Inst::Store32 { .. } => Some(I32),
+            Inst::Store64 { .. } => Some(I64),
+            Inst::FpuStore16 { .. } => Some(F16),
+            Inst::FpuStore32 { .. } => Some(F32),
+            Inst::FpuStore64 { .. } => Some(F64),
+            Inst::FpuStore128 { .. } => Some(I8X16),
+            _ => None,
+        }
+    }
 }
 
 //=============================================================================
 // Instructions: get_regs
 
-fn memarg_operands<F: Fn(VReg) -> VReg>(memarg: &AMode, collector: &mut OperandCollector<'_, F>) {
-    // This should match `AMode::with_allocs()`.
+fn memarg_operands(memarg: &mut AMode, collector: &mut impl OperandVisitor) {
     match memarg {
-        &AMode::Unscaled { rn, .. } | &AMode::UnsignedOffset { rn, .. } => {
+        AMode::Unscaled { rn, .. } | AMode::UnsignedOffset { rn, .. } => {
             collector.reg_use(rn);
         }
-        &AMode::RegReg { rn, rm, .. }
-        | &AMode::RegScaled { rn, rm, .. }
-        | &AMode::RegScaledExtended { rn, rm, .. }
-        | &AMode::RegExtended { rn, rm, .. } => {
+        AMode::RegReg { rn, rm, .. }
+        | AMode::RegScaled { rn, rm, .. }
+        | AMode::RegScaledExtended { rn, rm, .. }
+        | AMode::RegExtended { rn, rm, .. } => {
             collector.reg_use(rn);
             collector.reg_use(rm);
         }
-        &AMode::Label { .. } => {}
-        &AMode::SPPreIndexed { .. } | &AMode::SPPostIndexed { .. } => {}
-        &AMode::FPOffset { .. } => {}
-        &AMode::SPOffset { .. } | &AMode::NominalSPOffset { .. } => {}
-        &AMode::RegOffset { rn, .. } => {
+        AMode::Label { .. } => {}
+        AMode::SPPreIndexed { .. } | AMode::SPPostIndexed { .. } => {}
+        AMode::FPOffset { .. } | AMode::IncomingArg { .. } => {}
+        AMode::SPOffset { .. } | AMode::SlotOffset { .. } => {}
+        AMode::RegOffset { rn, .. } => {
             collector.reg_use(rn);
         }
-        &AMode::Const { .. } => {}
+        AMode::Const { .. } => {}
     }
 }
 
-fn pairmemarg_operands<F: Fn(VReg) -> VReg>(
-    pairmemarg: &PairAMode,
-    collector: &mut OperandCollector<'_, F>,
-) {
-    // This should match `PairAMode::with_allocs()`.
+fn pairmemarg_operands(pairmemarg: &mut PairAMode, collector: &mut impl OperandVisitor) {
     match pairmemarg {
-        &PairAMode::SignedOffset { reg, .. } => {
+        PairAMode::SignedOffset { reg, .. } => {
             collector.reg_use(reg);
         }
-        &PairAMode::SPPreIndexed { .. } | &PairAMode::SPPostIndexed { .. } => {}
+        PairAMode::SPPreIndexed { .. } | PairAMode::SPPostIndexed { .. } => {}
     }
 }
 
-fn aarch64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut OperandCollector<'_, F>) {
+fn aarch64_get_operands(inst: &mut Inst, collector: &mut impl OperandVisitor) {
     match inst {
-        &Inst::AluRRR { rd, rn, rm, .. } => {
+        Inst::AluRRR { rd, rn, rm, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
             collector.reg_use(rm);
         }
-        &Inst::AluRRRR { rd, rn, rm, ra, .. } => {
+        Inst::AluRRRR { rd, rn, rm, ra, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
             collector.reg_use(rm);
             collector.reg_use(ra);
         }
-        &Inst::AluRRImm12 { rd, rn, .. } => {
+        Inst::AluRRImm12 { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::AluRRImmLogic { rd, rn, .. } => {
+        Inst::AluRRImmLogic { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::AluRRImmShift { rd, rn, .. } => {
+        Inst::AluRRImmShift { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::AluRRRShift { rd, rn, rm, .. } => {
+        Inst::AluRRRShift { rd, rn, rm, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
             collector.reg_use(rm);
         }
-        &Inst::AluRRRExtend { rd, rn, rm, .. } => {
+        Inst::AluRRRExtend { rd, rn, rm, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
             collector.reg_use(rm);
         }
-        &Inst::BitRR { rd, rn, .. } => {
+        Inst::BitRR { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::ULoad8 { rd, ref mem, .. }
-        | &Inst::SLoad8 { rd, ref mem, .. }
-        | &Inst::ULoad16 { rd, ref mem, .. }
-        | &Inst::SLoad16 { rd, ref mem, .. }
-        | &Inst::ULoad32 { rd, ref mem, .. }
-        | &Inst::SLoad32 { rd, ref mem, .. }
-        | &Inst::ULoad64 { rd, ref mem, .. } => {
+        Inst::ULoad8 { rd, mem, .. }
+        | Inst::SLoad8 { rd, mem, .. }
+        | Inst::ULoad16 { rd, mem, .. }
+        | Inst::SLoad16 { rd, mem, .. }
+        | Inst::ULoad32 { rd, mem, .. }
+        | Inst::SLoad32 { rd, mem, .. }
+        | Inst::ULoad64 { rd, mem, .. } => {
             collector.reg_def(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::Store8 { rd, ref mem, .. }
-        | &Inst::Store16 { rd, ref mem, .. }
-        | &Inst::Store32 { rd, ref mem, .. }
-        | &Inst::Store64 { rd, ref mem, .. } => {
+        Inst::Store8 { rd, mem, .. }
+        | Inst::Store16 { rd, mem, .. }
+        | Inst::Store32 { rd, mem, .. }
+        | Inst::Store64 { rd, mem, .. } => {
             collector.reg_use(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::StoreP64 {
-            rt, rt2, ref mem, ..
-        } => {
+        Inst::StoreP64 { rt, rt2, mem, .. } => {
             collector.reg_use(rt);
             collector.reg_use(rt2);
             pairmemarg_operands(mem, collector);
         }
-        &Inst::LoadP64 {
-            rt, rt2, ref mem, ..
-        } => {
+        Inst::LoadP64 { rt, rt2, mem, .. } => {
             collector.reg_def(rt);
             collector.reg_def(rt2);
             pairmemarg_operands(mem, collector);
         }
-        &Inst::Mov { rd, rm, .. } => {
+        Inst::Mov { rd, rm, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rm);
         }
-        &Inst::MovFromPReg { rd, rm } => {
+        Inst::MovFromPReg { rd, rm } => {
             debug_assert!(rd.to_reg().is_virtual());
             collector.reg_def(rd);
-            collector.reg_fixed_nonallocatable(rm);
+            collector.reg_fixed_nonallocatable(*rm);
         }
-        &Inst::MovToPReg { rd, rm } => {
+        Inst::MovToPReg { rd, rm } => {
             debug_assert!(rm.is_virtual());
-            collector.reg_fixed_nonallocatable(rd);
+            collector.reg_fixed_nonallocatable(*rd);
             collector.reg_use(rm);
         }
-        &Inst::MovK { rd, rn, .. } => {
+        Inst::MovK { rd, rn, .. } => {
             collector.reg_use(rn);
             collector.reg_reuse_def(rd, 0); // `rn` == `rd`.
         }
-        &Inst::MovWide { rd, .. } => {
+        Inst::MovWide { rd, .. } => {
             collector.reg_def(rd);
         }
-        &Inst::CSel { rd, rn, rm, .. } => {
+        Inst::CSel { rd, rn, rm, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
             collector.reg_use(rm);
         }
-        &Inst::CSNeg { rd, rn, rm, .. } => {
+        Inst::CSNeg { rd, rn, rm, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
             collector.reg_use(rm);
         }
-        &Inst::CSet { rd, .. } | &Inst::CSetm { rd, .. } => {
+        Inst::CSet { rd, .. } | Inst::CSetm { rd, .. } => {
             collector.reg_def(rd);
         }
-        &Inst::CCmp { rn, rm, .. } => {
+        Inst::CCmp { rn, rm, .. } => {
             collector.reg_use(rn);
             collector.reg_use(rm);
         }
-        &Inst::CCmpImm { rn, .. } => {
+        Inst::CCmpImm { rn, .. } => {
             collector.reg_use(rn);
         }
-        &Inst::AtomicRMWLoop {
+        Inst::AtomicRMWLoop {
             op,
             addr,
             operand,
@@ -533,22 +554,22 @@ fn aarch64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut Operan
             collector.reg_fixed_use(operand, xreg(26));
             collector.reg_fixed_def(oldval, xreg(27));
             collector.reg_fixed_def(scratch1, xreg(24));
-            if op != AtomicRMWLoopOp::Xchg {
+            if *op != AtomicRMWLoopOp::Xchg {
                 collector.reg_fixed_def(scratch2, xreg(28));
             }
         }
-        &Inst::AtomicRMW { rs, rt, rn, .. } => {
+        Inst::AtomicRMW { rs, rt, rn, .. } => {
             collector.reg_use(rs);
             collector.reg_def(rt);
             collector.reg_use(rn);
         }
-        &Inst::AtomicCAS { rd, rs, rt, rn, .. } => {
+        Inst::AtomicCAS { rd, rs, rt, rn, .. } => {
             collector.reg_reuse_def(rd, 1); // reuse `rs`.
             collector.reg_use(rs);
             collector.reg_use(rt);
             collector.reg_use(rn);
         }
-        &Inst::AtomicCASLoop {
+        Inst::AtomicCASLoop {
             addr,
             expected,
             replacement,
@@ -562,91 +583,95 @@ fn aarch64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut Operan
             collector.reg_fixed_def(oldval, xreg(27));
             collector.reg_fixed_def(scratch, xreg(24));
         }
-        &Inst::LoadAcquire { rt, rn, .. } => {
+        Inst::LoadAcquire { rt, rn, .. } => {
             collector.reg_use(rn);
             collector.reg_def(rt);
         }
-        &Inst::StoreRelease { rt, rn, .. } => {
+        Inst::StoreRelease { rt, rn, .. } => {
             collector.reg_use(rn);
             collector.reg_use(rt);
         }
-        &Inst::Fence {} | &Inst::Csdb {} => {}
-        &Inst::FpuMove64 { rd, rn } => {
+        Inst::Fence {} | Inst::Csdb {} => {}
+        Inst::FpuMove32 { rd, rn } => {
+            collector.reg_def(rd);
+            collector.reg_use(rn);
+        }
+        Inst::FpuMove64 { rd, rn } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::FpuMove128 { rd, rn } => {
+        Inst::FpuMove128 { rd, rn } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::FpuMoveFromVec { rd, rn, .. } => {
+        Inst::FpuMoveFromVec { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::FpuExtend { rd, rn, .. } => {
+        Inst::FpuExtend { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::FpuRR { rd, rn, .. } => {
+        Inst::FpuRR { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::FpuRRR { rd, rn, rm, .. } => {
+        Inst::FpuRRR { rd, rn, rm, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
             collector.reg_use(rm);
         }
-        &Inst::FpuRRI { rd, rn, .. } => {
+        Inst::FpuRRI { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::FpuRRIMod { rd, ri, rn, .. } => {
+        Inst::FpuRRIMod { rd, ri, rn, .. } => {
             collector.reg_reuse_def(rd, 1); // reuse `ri`.
             collector.reg_use(ri);
             collector.reg_use(rn);
         }
-        &Inst::FpuRRRR { rd, rn, rm, ra, .. } => {
+        Inst::FpuRRRR { rd, rn, rm, ra, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
             collector.reg_use(rm);
             collector.reg_use(ra);
         }
-        &Inst::VecMisc { rd, rn, .. } => {
+        Inst::VecMisc { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
 
-        &Inst::VecLanes { rd, rn, .. } => {
+        Inst::VecLanes { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::VecShiftImm { rd, rn, .. } => {
+        Inst::VecShiftImm { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::VecShiftImmMod { rd, ri, rn, .. } => {
+        Inst::VecShiftImmMod { rd, ri, rn, .. } => {
             collector.reg_reuse_def(rd, 1); // `rd` == `ri`.
             collector.reg_use(ri);
             collector.reg_use(rn);
         }
-        &Inst::VecExtract { rd, rn, rm, .. } => {
+        Inst::VecExtract { rd, rn, rm, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
             collector.reg_use(rm);
         }
-        &Inst::VecTbl { rd, rn, rm } => {
+        Inst::VecTbl { rd, rn, rm } => {
             collector.reg_use(rn);
             collector.reg_use(rm);
             collector.reg_def(rd);
         }
-        &Inst::VecTblExt { rd, ri, rn, rm } => {
+        Inst::VecTblExt { rd, ri, rn, rm } => {
             collector.reg_use(rn);
             collector.reg_use(rm);
             collector.reg_reuse_def(rd, 3); // `rd` == `ri`.
             collector.reg_use(ri);
         }
 
-        &Inst::VecTbl2 { rd, rn, rn2, rm } => {
+        Inst::VecTbl2 { rd, rn, rn2, rm } => {
             // Constrain to v30 / v31 so that we satisfy the "adjacent
             // registers" constraint without use of pinned vregs in
             // lowering.
@@ -655,7 +680,7 @@ fn aarch64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut Operan
             collector.reg_use(rm);
             collector.reg_def(rd);
         }
-        &Inst::VecTbl2Ext {
+        Inst::VecTbl2Ext {
             rd,
             ri,
             rn,
@@ -671,293 +696,294 @@ fn aarch64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut Operan
             collector.reg_reuse_def(rd, 4); // `rd` == `ri`.
             collector.reg_use(ri);
         }
-        &Inst::VecLoadReplicate { rd, rn, .. } => {
+        Inst::VecLoadReplicate { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::VecCSel { rd, rn, rm, .. } => {
+        Inst::VecCSel { rd, rn, rm, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
             collector.reg_use(rm);
         }
-        &Inst::FpuCmp { rn, rm, .. } => {
+        Inst::FpuCmp { rn, rm, .. } => {
             collector.reg_use(rn);
             collector.reg_use(rm);
         }
-        &Inst::FpuLoad32 { rd, ref mem, .. } => {
+        Inst::FpuLoad16 { rd, mem, .. } => {
             collector.reg_def(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::FpuLoad64 { rd, ref mem, .. } => {
+        Inst::FpuLoad32 { rd, mem, .. } => {
             collector.reg_def(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::FpuLoad128 { rd, ref mem, .. } => {
+        Inst::FpuLoad64 { rd, mem, .. } => {
             collector.reg_def(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::FpuStore32 { rd, ref mem, .. } => {
+        Inst::FpuLoad128 { rd, mem, .. } => {
+            collector.reg_def(rd);
+            memarg_operands(mem, collector);
+        }
+        Inst::FpuStore16 { rd, mem, .. } => {
             collector.reg_use(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::FpuStore64 { rd, ref mem, .. } => {
+        Inst::FpuStore32 { rd, mem, .. } => {
             collector.reg_use(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::FpuStore128 { rd, ref mem, .. } => {
+        Inst::FpuStore64 { rd, mem, .. } => {
             collector.reg_use(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::FpuLoadP64 {
-            rt, rt2, ref mem, ..
-        } => {
+        Inst::FpuStore128 { rd, mem, .. } => {
+            collector.reg_use(rd);
+            memarg_operands(mem, collector);
+        }
+        Inst::FpuLoadP64 { rt, rt2, mem, .. } => {
             collector.reg_def(rt);
             collector.reg_def(rt2);
             pairmemarg_operands(mem, collector);
         }
-        &Inst::FpuStoreP64 {
-            rt, rt2, ref mem, ..
-        } => {
+        Inst::FpuStoreP64 { rt, rt2, mem, .. } => {
             collector.reg_use(rt);
             collector.reg_use(rt2);
             pairmemarg_operands(mem, collector);
         }
-        &Inst::FpuLoadP128 {
-            rt, rt2, ref mem, ..
-        } => {
+        Inst::FpuLoadP128 { rt, rt2, mem, .. } => {
             collector.reg_def(rt);
             collector.reg_def(rt2);
             pairmemarg_operands(mem, collector);
         }
-        &Inst::FpuStoreP128 {
-            rt, rt2, ref mem, ..
-        } => {
+        Inst::FpuStoreP128 { rt, rt2, mem, .. } => {
             collector.reg_use(rt);
             collector.reg_use(rt2);
             pairmemarg_operands(mem, collector);
         }
-        &Inst::FpuToInt { rd, rn, .. } => {
+        Inst::FpuToInt { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::IntToFpu { rd, rn, .. } => {
+        Inst::IntToFpu { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::FpuCSel32 { rd, rn, rm, .. } | &Inst::FpuCSel64 { rd, rn, rm, .. } => {
+        Inst::FpuCSel16 { rd, rn, rm, .. }
+        | Inst::FpuCSel32 { rd, rn, rm, .. }
+        | Inst::FpuCSel64 { rd, rn, rm, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
             collector.reg_use(rm);
         }
-        &Inst::FpuRound { rd, rn, .. } => {
+        Inst::FpuRound { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::MovToFpu { rd, rn, .. } => {
+        Inst::MovToFpu { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::FpuMoveFPImm { rd, .. } => {
+        Inst::FpuMoveFPImm { rd, .. } => {
             collector.reg_def(rd);
         }
-        &Inst::MovToVec { rd, ri, rn, .. } => {
+        Inst::MovToVec { rd, ri, rn, .. } => {
             collector.reg_reuse_def(rd, 1); // `rd` == `ri`.
             collector.reg_use(ri);
             collector.reg_use(rn);
         }
-        &Inst::MovFromVec { rd, rn, .. } | &Inst::MovFromVecSigned { rd, rn, .. } => {
+        Inst::MovFromVec { rd, rn, .. } | Inst::MovFromVecSigned { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::VecDup { rd, rn, .. } => {
+        Inst::VecDup { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::VecDupFromFpu { rd, rn, .. } => {
+        Inst::VecDupFromFpu { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::VecDupFPImm { rd, .. } => {
+        Inst::VecDupFPImm { rd, .. } => {
             collector.reg_def(rd);
         }
-        &Inst::VecDupImm { rd, .. } => {
+        Inst::VecDupImm { rd, .. } => {
             collector.reg_def(rd);
         }
-        &Inst::VecExtend { rd, rn, .. } => {
+        Inst::VecExtend { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::VecMovElement { rd, ri, rn, .. } => {
+        Inst::VecMovElement { rd, ri, rn, .. } => {
             collector.reg_reuse_def(rd, 1); // `rd` == `ri`.
             collector.reg_use(ri);
             collector.reg_use(rn);
         }
-        &Inst::VecRRLong { rd, rn, .. } => {
+        Inst::VecRRLong { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::VecRRNarrowLow { rd, rn, .. } => {
+        Inst::VecRRNarrowLow { rd, rn, .. } => {
             collector.reg_use(rn);
             collector.reg_def(rd);
         }
-        &Inst::VecRRNarrowHigh { rd, ri, rn, .. } => {
+        Inst::VecRRNarrowHigh { rd, ri, rn, .. } => {
             collector.reg_use(rn);
             collector.reg_reuse_def(rd, 2); // `rd` == `ri`.
             collector.reg_use(ri);
         }
-        &Inst::VecRRPair { rd, rn, .. } => {
+        Inst::VecRRPair { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::VecRRRLong { rd, rn, rm, .. } => {
+        Inst::VecRRRLong { rd, rn, rm, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
             collector.reg_use(rm);
         }
-        &Inst::VecRRRLongMod { rd, ri, rn, rm, .. } => {
+        Inst::VecRRRLongMod { rd, ri, rn, rm, .. } => {
             collector.reg_reuse_def(rd, 1); // `rd` == `ri`.
             collector.reg_use(ri);
             collector.reg_use(rn);
             collector.reg_use(rm);
         }
-        &Inst::VecRRPairLong { rd, rn, .. } => {
+        Inst::VecRRPairLong { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::VecRRR { rd, rn, rm, .. } => {
+        Inst::VecRRR { rd, rn, rm, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
             collector.reg_use(rm);
         }
-        &Inst::VecRRRMod { rd, ri, rn, rm, .. } | &Inst::VecFmlaElem { rd, ri, rn, rm, .. } => {
+        Inst::VecRRRMod { rd, ri, rn, rm, .. } | Inst::VecFmlaElem { rd, ri, rn, rm, .. } => {
             collector.reg_reuse_def(rd, 1); // `rd` == `ri`.
             collector.reg_use(ri);
             collector.reg_use(rn);
             collector.reg_use(rm);
         }
-        &Inst::MovToNZCV { rn } => {
+        Inst::MovToNZCV { rn } => {
             collector.reg_use(rn);
         }
-        &Inst::MovFromNZCV { rd } => {
+        Inst::MovFromNZCV { rd } => {
             collector.reg_def(rd);
         }
-        &Inst::Extend { rd, rn, .. } => {
+        Inst::Extend { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::Args { ref args } => {
-            for arg in args {
-                collector.reg_fixed_def(arg.vreg, arg.preg);
+        Inst::Args { args } => {
+            for ArgPair { vreg, preg } in args {
+                collector.reg_fixed_def(vreg, *preg);
             }
         }
-        &Inst::Rets { ref rets } => {
-            for ret in rets {
-                collector.reg_fixed_use(ret.vreg, ret.preg);
+        Inst::Rets { rets } => {
+            for RetPair { vreg, preg } in rets {
+                collector.reg_fixed_use(vreg, *preg);
             }
         }
-        &Inst::Ret { .. } | &Inst::AuthenticatedRet { .. } => {}
-        &Inst::Jump { .. } => {}
-        &Inst::Call { ref info, .. } => {
-            for u in &info.uses {
-                collector.reg_fixed_use(u.vreg, u.preg);
+        Inst::Ret { .. } | Inst::AuthenticatedRet { .. } => {}
+        Inst::Jump { .. } => {}
+        Inst::Call { info, .. } => {
+            let CallInfo { uses, defs, .. } = &mut **info;
+            for CallArgPair { vreg, preg } in uses {
+                collector.reg_fixed_use(vreg, *preg);
             }
-            for d in &info.defs {
-                collector.reg_fixed_def(d.vreg, d.preg);
+            for CallRetPair { vreg, preg } in defs {
+                collector.reg_fixed_def(vreg, *preg);
             }
             collector.reg_clobbers(info.clobbers);
         }
-        &Inst::CallInd { ref info, .. } => {
-            if info.callee_callconv == CallConv::Tail {
-                // TODO(https://github.com/bytecodealliance/regalloc2/issues/145):
-                // This shouldn't be a fixed register constraint.
-                collector.reg_fixed_use(info.rn, xreg(1));
-            } else {
-                collector.reg_use(info.rn);
-            }
-            for u in &info.uses {
-                collector.reg_fixed_use(u.vreg, u.preg);
+        Inst::CallInd { info, .. } => {
+            let CallIndInfo { rn, uses, defs, .. } = &mut **info;
+            collector.reg_use(rn);
+            for CallArgPair { vreg, preg } in uses {
+                collector.reg_fixed_use(vreg, *preg);
             }
-            for d in &info.defs {
-                collector.reg_fixed_def(d.vreg, d.preg);
+            for CallRetPair { vreg, preg } in defs {
+                collector.reg_fixed_def(vreg, *preg);
             }
             collector.reg_clobbers(info.clobbers);
         }
-        &Inst::ReturnCall {
-            ref info,
-            callee: _,
-        } => {
-            for u in &info.uses {
-                collector.reg_fixed_use(u.vreg, u.preg);
+        Inst::ReturnCall { info, callee: _ } => {
+            for CallArgPair { vreg, preg } in &mut info.uses {
+                collector.reg_fixed_use(vreg, *preg);
             }
         }
-        &Inst::ReturnCallInd { ref info, callee } => {
-            collector.reg_use(callee);
-            for u in &info.uses {
-                collector.reg_fixed_use(u.vreg, u.preg);
+        Inst::ReturnCallInd { info, callee } => {
+            // TODO(https://github.com/bytecodealliance/regalloc2/issues/145):
+            // This shouldn't be a fixed register constraint, but it's not clear how to pick a
+            // register that won't be clobbered by the callee-save restore code emitted with a
+            // return_call_indirect.
+            collector.reg_fixed_use(callee, xreg(1));
+            for CallArgPair { vreg, preg } in &mut info.uses {
+                collector.reg_fixed_use(vreg, *preg);
             }
         }
-        &Inst::CondBr { ref kind, .. } => match kind {
-            CondBrKind::Zero(rt) | CondBrKind::NotZero(rt) => {
-                collector.reg_use(*rt);
-            }
+        Inst::CondBr { kind, .. } => match kind {
+            CondBrKind::Zero(rt) | CondBrKind::NotZero(rt) => collector.reg_use(rt),
             CondBrKind::Cond(_) => {}
         },
-        &Inst::IndirectBr { rn, .. } => {
+        Inst::TestBitAndBranch { rn, .. } => {
             collector.reg_use(rn);
         }
-        &Inst::Nop0 | Inst::Nop4 => {}
-        &Inst::Brk => {}
-        &Inst::Udf { .. } => {}
-        &Inst::TrapIf { ref kind, .. } => match kind {
-            CondBrKind::Zero(rt) | CondBrKind::NotZero(rt) => {
-                collector.reg_use(*rt);
-            }
+        Inst::IndirectBr { rn, .. } => {
+            collector.reg_use(rn);
+        }
+        Inst::Nop0 | Inst::Nop4 => {}
+        Inst::Brk => {}
+        Inst::Udf { .. } => {}
+        Inst::TrapIf { kind, .. } => match kind {
+            CondBrKind::Zero(rt) | CondBrKind::NotZero(rt) => collector.reg_use(rt),
             CondBrKind::Cond(_) => {}
         },
-        &Inst::Adr { rd, .. } | &Inst::Adrp { rd, .. } => {
+        Inst::Adr { rd, .. } | Inst::Adrp { rd, .. } => {
             collector.reg_def(rd);
         }
-        &Inst::Word4 { .. } | &Inst::Word8 { .. } => {}
-        &Inst::JTSequence {
+        Inst::Word4 { .. } | Inst::Word8 { .. } => {}
+        Inst::JTSequence {
             ridx, rtmp1, rtmp2, ..
         } => {
             collector.reg_use(ridx);
             collector.reg_early_def(rtmp1);
             collector.reg_early_def(rtmp2);
         }
-        &Inst::LoadExtName { rd, .. } => {
+        Inst::LoadExtName { rd, .. } => {
             collector.reg_def(rd);
         }
-        &Inst::LoadAddr { rd, ref mem } => {
+        Inst::LoadAddr { rd, mem } => {
             collector.reg_def(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::Paci { .. } | &Inst::Xpaclri => {
+        Inst::Paci { .. } | Inst::Xpaclri => {
             // Neither LR nor SP is an allocatable register, so there is no need
             // to do anything.
         }
-        &Inst::Bti { .. } => {}
-        &Inst::VirtualSPOffsetAdj { .. } => {}
+        Inst::Bti { .. } => {}
 
-        &Inst::ElfTlsGetAddr { rd, .. } => {
+        Inst::ElfTlsGetAddr { rd, tmp, .. } => {
+            // TLSDESC has a very neat calling convention. It is required to preserve
+            // all registers except x0 and x30. X30 is non allocatable in cranelift since
+            // its the link register.
+            //
+            // Additionally we need a second register as a temporary register for the
+            // TLSDESC sequence. This register can be any register other than x0 (and x30).
             collector.reg_fixed_def(rd, regs::xreg(0));
-            let mut clobbers = AArch64MachineDeps::get_regs_clobbered_by_call(CallConv::SystemV);
-            clobbers.remove(regs::xreg_preg(0));
-            collector.reg_clobbers(clobbers);
+            collector.reg_early_def(tmp);
         }
-        &Inst::MachOTlsGetAddr { rd, .. } => {
+        Inst::MachOTlsGetAddr { rd, .. } => {
             collector.reg_fixed_def(rd, regs::xreg(0));
             let mut clobbers =
                 AArch64MachineDeps::get_regs_clobbered_by_call(CallConv::AppleAarch64);
             clobbers.remove(regs::xreg_preg(0));
             collector.reg_clobbers(clobbers);
         }
-        &Inst::Unwind { .. } => {}
-        &Inst::EmitIsland { .. } => {}
-        &Inst::DummyUse { reg } => {
+        Inst::Unwind { .. } => {}
+        Inst::EmitIsland { .. } => {}
+        Inst::DummyUse { reg } => {
             collector.reg_use(reg);
         }
-        &Inst::StackProbeLoop { start, end, .. } => {
+        Inst::StackProbeLoop { start, end, .. } => {
             collector.reg_early_def(start);
             collector.reg_use(end);
         }
@@ -975,7 +1001,7 @@ impl MachInst for Inst {
     // debugging.
     const TRAP_OPCODE: &'static [u8] = &0xc11f_u32.to_le_bytes();
 
-    fn get_operands<F: Fn(VReg) -> VReg>(&self, collector: &mut OperandCollector<'_, F>) {
+    fn get_operands(&mut self, collector: &mut impl OperandVisitor) {
         aarch64_get_operands(self, collector);
     }
 
@@ -1039,12 +1065,43 @@ impl MachInst for Inst {
             &Inst::ReturnCall { .. } | &Inst::ReturnCallInd { .. } => MachTerminator::RetCall,
             &Inst::Jump { .. } => MachTerminator::Uncond,
             &Inst::CondBr { .. } => MachTerminator::Cond,
+            &Inst::TestBitAndBranch { .. } => MachTerminator::Cond,
             &Inst::IndirectBr { .. } => MachTerminator::Indirect,
             &Inst::JTSequence { .. } => MachTerminator::Indirect,
             _ => MachTerminator::None,
         }
     }
 
+    fn is_mem_access(&self) -> bool {
+        match self {
+            &Inst::ULoad8 { .. }
+            | &Inst::SLoad8 { .. }
+            | &Inst::ULoad16 { .. }
+            | &Inst::SLoad16 { .. }
+            | &Inst::ULoad32 { .. }
+            | &Inst::SLoad32 { .. }
+            | &Inst::ULoad64 { .. }
+            | &Inst::LoadP64 { .. }
+            | &Inst::FpuLoad16 { .. }
+            | &Inst::FpuLoad32 { .. }
+            | &Inst::FpuLoad64 { .. }
+            | &Inst::FpuLoad128 { .. }
+            | &Inst::FpuLoadP64 { .. }
+            | &Inst::FpuLoadP128 { .. }
+            | &Inst::Store8 { .. }
+            | &Inst::Store16 { .. }
+            | &Inst::Store32 { .. }
+            | &Inst::Store64 { .. }
+            | &Inst::StoreP64 { .. }
+            | &Inst::FpuStore16 { .. }
+            | &Inst::FpuStore32 { .. }
+            | &Inst::FpuStore64 { .. }
+            | &Inst::FpuStore128 { .. } => true,
+            // TODO: verify this carefully
+            _ => false,
+        }
+    }
+
     fn gen_move(to_reg: Writable<Reg>, from_reg: Reg, ty: Type) -> Inst {
         let bits = ty.bits();
 
@@ -1075,10 +1132,7 @@ impl MachInst for Inst {
 
     fn is_safepoint(&self) -> bool {
         match self {
-            &Inst::Call { .. }
-            | &Inst::CallInd { .. }
-            | &Inst::TrapIf { .. }
-            | &Inst::Udf { .. } => true,
+            Inst::Call { .. } | Inst::CallInd { .. } => true,
             _ => false,
         }
     }
@@ -1102,10 +1156,10 @@ impl MachInst for Inst {
             I16 => Ok((&[RegClass::Int], &[I16])),
             I32 => Ok((&[RegClass::Int], &[I32])),
             I64 => Ok((&[RegClass::Int], &[I64])),
-            R32 => panic!("32-bit reftype pointer should never be seen on AArch64"),
-            R64 => Ok((&[RegClass::Int], &[R64])),
+            F16 => Ok((&[RegClass::Float], &[F16])),
             F32 => Ok((&[RegClass::Float], &[F32])),
             F64 => Ok((&[RegClass::Float], &[F64])),
+            F128 => Ok((&[RegClass::Float], &[F128])),
             I128 => Ok((&[RegClass::Int, RegClass::Int], &[I64, I64])),
             _ if ty.is_vector() => {
                 assert!(ty.bits() <= 128);
@@ -1113,8 +1167,7 @@ impl MachInst for Inst {
             }
             _ if ty.is_dynamic_vector() => Ok((&[RegClass::Float], &[I8X16])),
             _ => Err(CodegenError::Unsupported(format!(
-                "Unexpected SSA-value type: {}",
-                ty
+                "Unexpected SSA-value type: {ty}"
             ))),
         }
     }
@@ -1174,26 +1227,23 @@ impl MachInst for Inst {
 //=============================================================================
 // Pretty-printing of instructions.
 
-fn mem_finalize_for_show(mem: &AMode, state: &EmitState) -> (String, AMode) {
-    let (mem_insts, mem) = mem_finalize(None, mem, state);
+fn mem_finalize_for_show(mem: &AMode, access_ty: Type, state: &EmitState) -> (String, String) {
+    let (mem_insts, mem) = mem_finalize(None, mem, access_ty, state);
     let mut mem_str = mem_insts
         .into_iter()
-        .map(|inst| {
-            inst.print_with_state(&mut EmitState::default(), &mut AllocationConsumer::new(&[]))
-        })
+        .map(|inst| inst.print_with_state(&mut EmitState::default()))
         .collect::<Vec<_>>()
         .join(" ; ");
     if !mem_str.is_empty() {
         mem_str += " ; ";
     }
 
+    let mem = mem.pretty_print(access_ty.bytes() as u8);
     (mem_str, mem)
 }
 
 impl Inst {
-    fn print_with_state(&self, state: &mut EmitState, allocs: &mut AllocationConsumer) -> String {
-        let mut empty_allocs = AllocationConsumer::default();
-
+    pub fn print_with_state(&self, state: &mut EmitState) -> String {
         fn op_name(alu_op: ALUOp) -> &'static str {
             match alu_op {
                 ALUOp::Add => "add",
@@ -1222,9 +1272,6 @@ impl Inst {
             }
         }
 
-        // N.B.: order of `allocs` consumption (via register
-        // pretty-printing or memarg.with_allocs()) needs to match the
-        // order in `aarch64_get_operands` above.
         match self {
             &Inst::Nop0 => "nop-zero-len".to_string(),
             &Inst::Nop4 => "nop".to_string(),
@@ -1236,10 +1283,10 @@ impl Inst {
                 rm,
             } => {
                 let op = op_name(alu_op);
-                let rd = pretty_print_ireg(rd.to_reg(), size, allocs);
-                let rn = pretty_print_ireg(rn, size, allocs);
-                let rm = pretty_print_ireg(rm, size, allocs);
-                format!("{} {}, {}, {}", op, rd, rn, rm)
+                let rd = pretty_print_ireg(rd.to_reg(), size);
+                let rn = pretty_print_ireg(rn, size);
+                let rm = pretty_print_ireg(rm, size);
+                format!("{op} {rd}, {rn}, {rm}")
             }
             &Inst::AluRRRR {
                 alu_op,
@@ -1255,12 +1302,12 @@ impl Inst {
                     ALUOp3::UMAddL => ("umaddl", OperandSize::Size64),
                     ALUOp3::SMAddL => ("smaddl", OperandSize::Size64),
                 };
-                let rd = pretty_print_ireg(rd.to_reg(), da_size, allocs);
-                let rn = pretty_print_ireg(rn, size, allocs);
-                let rm = pretty_print_ireg(rm, size, allocs);
-                let ra = pretty_print_ireg(ra, da_size, allocs);
+                let rd = pretty_print_ireg(rd.to_reg(), da_size);
+                let rn = pretty_print_ireg(rn, size);
+                let rm = pretty_print_ireg(rm, size);
+                let ra = pretty_print_ireg(ra, da_size);
 
-                format!("{} {}, {}, {}, {}", op, rd, rn, rm, ra)
+                format!("{op} {rd}, {rn}, {rm}, {ra}")
             }
             &Inst::AluRRImm12 {
                 alu_op,
@@ -1270,15 +1317,15 @@ impl Inst {
                 ref imm12,
             } => {
                 let op = op_name(alu_op);
-                let rd = pretty_print_ireg(rd.to_reg(), size, allocs);
-                let rn = pretty_print_ireg(rn, size, allocs);
+                let rd = pretty_print_ireg(rd.to_reg(), size);
+                let rn = pretty_print_ireg(rn, size);
 
                 if imm12.bits == 0 && alu_op == ALUOp::Add && size.is64() {
                     // special-case MOV (used for moving into SP).
-                    format!("mov {}, {}", rd, rn)
+                    format!("mov {rd}, {rn}")
                 } else {
-                    let imm12 = imm12.pretty_print(0, allocs);
-                    format!("{} {}, {}, {}", op, rd, rn, imm12)
+                    let imm12 = imm12.pretty_print(0);
+                    format!("{op} {rd}, {rn}, {imm12}")
                 }
             }
             &Inst::AluRRImmLogic {
@@ -1289,10 +1336,10 @@ impl Inst {
                 ref imml,
             } => {
                 let op = op_name(alu_op);
-                let rd = pretty_print_ireg(rd.to_reg(), size, allocs);
-                let rn = pretty_print_ireg(rn, size, allocs);
-                let imml = imml.pretty_print(0, allocs);
-                format!("{} {}, {}, {}", op, rd, rn, imml)
+                let rd = pretty_print_ireg(rd.to_reg(), size);
+                let rn = pretty_print_ireg(rn, size);
+                let imml = imml.pretty_print(0);
+                format!("{op} {rd}, {rn}, {imml}")
             }
             &Inst::AluRRImmShift {
                 alu_op,
@@ -1302,10 +1349,10 @@ impl Inst {
                 ref immshift,
             } => {
                 let op = op_name(alu_op);
-                let rd = pretty_print_ireg(rd.to_reg(), size, allocs);
-                let rn = pretty_print_ireg(rn, size, allocs);
-                let immshift = immshift.pretty_print(0, allocs);
-                format!("{} {}, {}, {}", op, rd, rn, immshift)
+                let rd = pretty_print_ireg(rd.to_reg(), size);
+                let rn = pretty_print_ireg(rn, size);
+                let immshift = immshift.pretty_print(0);
+                format!("{op} {rd}, {rn}, {immshift}")
             }
             &Inst::AluRRRShift {
                 alu_op,
@@ -1316,11 +1363,11 @@ impl Inst {
                 ref shiftop,
             } => {
                 let op = op_name(alu_op);
-                let rd = pretty_print_ireg(rd.to_reg(), size, allocs);
-                let rn = pretty_print_ireg(rn, size, allocs);
-                let rm = pretty_print_ireg(rm, size, allocs);
-                let shiftop = shiftop.pretty_print(0, allocs);
-                format!("{} {}, {}, {}, {}", op, rd, rn, rm, shiftop)
+                let rd = pretty_print_ireg(rd.to_reg(), size);
+                let rn = pretty_print_ireg(rn, size);
+                let rm = pretty_print_ireg(rm, size);
+                let shiftop = shiftop.pretty_print(0);
+                format!("{op} {rd}, {rn}, {rm}, {shiftop}")
             }
             &Inst::AluRRRExtend {
                 alu_op,
@@ -1331,17 +1378,17 @@ impl Inst {
                 ref extendop,
             } => {
                 let op = op_name(alu_op);
-                let rd = pretty_print_ireg(rd.to_reg(), size, allocs);
-                let rn = pretty_print_ireg(rn, size, allocs);
-                let rm = pretty_print_ireg(rm, size, allocs);
-                let extendop = extendop.pretty_print(0, allocs);
-                format!("{} {}, {}, {}, {}", op, rd, rn, rm, extendop)
+                let rd = pretty_print_ireg(rd.to_reg(), size);
+                let rn = pretty_print_ireg(rn, size);
+                let rm = pretty_print_ireg(rm, size);
+                let extendop = extendop.pretty_print(0);
+                format!("{op} {rd}, {rn}, {rm}, {extendop}")
             }
             &Inst::BitRR { op, size, rd, rn } => {
                 let op = op.op_str();
-                let rd = pretty_print_ireg(rd.to_reg(), size, allocs);
-                let rn = pretty_print_ireg(rn, size, allocs);
-                format!("{} {}, {}", op, rd, rn)
+                let rd = pretty_print_ireg(rd.to_reg(), size);
+                let rn = pretty_print_ireg(rn, size);
+                format!("{op} {rd}, {rn}")
             }
             &Inst::ULoad8 { rd, ref mem, .. }
             | &Inst::SLoad8 { rd, ref mem, .. }
@@ -1372,12 +1419,12 @@ impl Inst {
                     _ => unreachable!(),
                 };
 
-                let rd = pretty_print_ireg(rd.to_reg(), size, allocs);
-                let mem = mem.with_allocs(allocs);
-                let (mem_str, mem) = mem_finalize_for_show(&mem, state);
-                let mem = mem.pretty_print_default();
+                let rd = pretty_print_ireg(rd.to_reg(), size);
+                let mem = mem.clone();
+                let access_ty = self.mem_type().unwrap();
+                let (mem_str, mem) = mem_finalize_for_show(&mem, access_ty, state);
 
-                format!("{}{} {}, {}", mem_str, op, rd, mem)
+                format!("{mem_str}{op} {rd}, {mem}")
             }
             &Inst::Store8 { rd, ref mem, .. }
             | &Inst::Store16 { rd, ref mem, .. }
@@ -1399,47 +1446,45 @@ impl Inst {
                     _ => unreachable!(),
                 };
 
-                let rd = pretty_print_ireg(rd, size, allocs);
-                let mem = mem.with_allocs(allocs);
-                let (mem_str, mem) = mem_finalize_for_show(&mem, state);
-                let mem = mem.pretty_print_default();
+                let rd = pretty_print_ireg(rd, size);
+                let mem = mem.clone();
+                let access_ty = self.mem_type().unwrap();
+                let (mem_str, mem) = mem_finalize_for_show(&mem, access_ty, state);
 
-                format!("{}{} {}, {}", mem_str, op, rd, mem)
+                format!("{mem_str}{op} {rd}, {mem}")
             }
             &Inst::StoreP64 {
                 rt, rt2, ref mem, ..
             } => {
-                let rt = pretty_print_ireg(rt, OperandSize::Size64, allocs);
-                let rt2 = pretty_print_ireg(rt2, OperandSize::Size64, allocs);
-                let mem = mem.with_allocs(allocs);
+                let rt = pretty_print_ireg(rt, OperandSize::Size64);
+                let rt2 = pretty_print_ireg(rt2, OperandSize::Size64);
+                let mem = mem.clone();
                 let mem = mem.pretty_print_default();
-                format!("stp {}, {}, {}", rt, rt2, mem)
+                format!("stp {rt}, {rt2}, {mem}")
             }
             &Inst::LoadP64 {
                 rt, rt2, ref mem, ..
             } => {
-                let rt = pretty_print_ireg(rt.to_reg(), OperandSize::Size64, allocs);
-                let rt2 = pretty_print_ireg(rt2.to_reg(), OperandSize::Size64, allocs);
-                let mem = mem.with_allocs(allocs);
+                let rt = pretty_print_ireg(rt.to_reg(), OperandSize::Size64);
+                let rt2 = pretty_print_ireg(rt2.to_reg(), OperandSize::Size64);
+                let mem = mem.clone();
                 let mem = mem.pretty_print_default();
-                format!("ldp {}, {}, {}", rt, rt2, mem)
+                format!("ldp {rt}, {rt2}, {mem}")
             }
             &Inst::Mov { size, rd, rm } => {
-                let rd = pretty_print_ireg(rd.to_reg(), size, allocs);
-                let rm = pretty_print_ireg(rm, size, allocs);
-                format!("mov {}, {}", rd, rm)
+                let rd = pretty_print_ireg(rd.to_reg(), size);
+                let rm = pretty_print_ireg(rm, size);
+                format!("mov {rd}, {rm}")
             }
             &Inst::MovFromPReg { rd, rm } => {
-                let rd = pretty_print_ireg(rd.to_reg(), OperandSize::Size64, allocs);
-                allocs.next_fixed_nonallocatable(rm);
+                let rd = pretty_print_ireg(rd.to_reg(), OperandSize::Size64);
                 let rm = show_ireg_sized(rm.into(), OperandSize::Size64);
-                format!("mov {}, {}", rd, rm)
+                format!("mov {rd}, {rm}")
             }
             &Inst::MovToPReg { rd, rm } => {
-                allocs.next_fixed_nonallocatable(rd);
                 let rd = show_ireg_sized(rd.into(), OperandSize::Size64);
-                let rm = pretty_print_ireg(rm, OperandSize::Size64, allocs);
-                format!("mov {}, {}", rd, rm)
+                let rm = pretty_print_ireg(rm, OperandSize::Size64);
+                format!("mov {rd}, {rm}")
             }
             &Inst::MovWide {
                 op,
@@ -1451,9 +1496,9 @@ impl Inst {
                     MoveWideOp::MovZ => "movz",
                     MoveWideOp::MovN => "movn",
                 };
-                let rd = pretty_print_ireg(rd.to_reg(), size, allocs);
-                let imm = imm.pretty_print(0, allocs);
-                format!("{} {}, {}", op_str, rd, imm)
+                let rd = pretty_print_ireg(rd.to_reg(), size);
+                let imm = imm.pretty_print(0);
+                format!("{op_str} {rd}, {imm}")
             }
             &Inst::MovK {
                 rd,
@@ -1461,34 +1506,34 @@ impl Inst {
                 ref imm,
                 size,
             } => {
-                let rn = pretty_print_ireg(rn, size, allocs);
-                let rd = pretty_print_ireg(rd.to_reg(), size, allocs);
-                let imm = imm.pretty_print(0, allocs);
-                format!("movk {}, {}, {}", rd, rn, imm)
+                let rn = pretty_print_ireg(rn, size);
+                let rd = pretty_print_ireg(rd.to_reg(), size);
+                let imm = imm.pretty_print(0);
+                format!("movk {rd}, {rn}, {imm}")
             }
             &Inst::CSel { rd, rn, rm, cond } => {
-                let rd = pretty_print_ireg(rd.to_reg(), OperandSize::Size64, allocs);
-                let rn = pretty_print_ireg(rn, OperandSize::Size64, allocs);
-                let rm = pretty_print_ireg(rm, OperandSize::Size64, allocs);
-                let cond = cond.pretty_print(0, allocs);
-                format!("csel {}, {}, {}, {}", rd, rn, rm, cond)
+                let rd = pretty_print_ireg(rd.to_reg(), OperandSize::Size64);
+                let rn = pretty_print_ireg(rn, OperandSize::Size64);
+                let rm = pretty_print_ireg(rm, OperandSize::Size64);
+                let cond = cond.pretty_print(0);
+                format!("csel {rd}, {rn}, {rm}, {cond}")
             }
             &Inst::CSNeg { rd, rn, rm, cond } => {
-                let rd = pretty_print_ireg(rd.to_reg(), OperandSize::Size64, allocs);
-                let rn = pretty_print_ireg(rn, OperandSize::Size64, allocs);
-                let rm = pretty_print_ireg(rm, OperandSize::Size64, allocs);
-                let cond = cond.pretty_print(0, allocs);
-                format!("csneg {}, {}, {}, {}", rd, rn, rm, cond)
+                let rd = pretty_print_ireg(rd.to_reg(), OperandSize::Size64);
+                let rn = pretty_print_ireg(rn, OperandSize::Size64);
+                let rm = pretty_print_ireg(rm, OperandSize::Size64);
+                let cond = cond.pretty_print(0);
+                format!("csneg {rd}, {rn}, {rm}, {cond}")
             }
             &Inst::CSet { rd, cond } => {
-                let rd = pretty_print_ireg(rd.to_reg(), OperandSize::Size64, allocs);
-                let cond = cond.pretty_print(0, allocs);
-                format!("cset {}, {}", rd, cond)
+                let rd = pretty_print_ireg(rd.to_reg(), OperandSize::Size64);
+                let cond = cond.pretty_print(0);
+                format!("cset {rd}, {cond}")
             }
             &Inst::CSetm { rd, cond } => {
-                let rd = pretty_print_ireg(rd.to_reg(), OperandSize::Size64, allocs);
-                let cond = cond.pretty_print(0, allocs);
-                format!("csetm {}, {}", rd, cond)
+                let rd = pretty_print_ireg(rd.to_reg(), OperandSize::Size64);
+                let cond = cond.pretty_print(0);
+                format!("csetm {rd}, {cond}")
             }
             &Inst::CCmp {
                 size,
@@ -1497,11 +1542,11 @@ impl Inst {
                 nzcv,
                 cond,
             } => {
-                let rn = pretty_print_ireg(rn, size, allocs);
-                let rm = pretty_print_ireg(rm, size, allocs);
-                let nzcv = nzcv.pretty_print(0, allocs);
-                let cond = cond.pretty_print(0, allocs);
-                format!("ccmp {}, {}, {}, {}", rn, rm, nzcv, cond)
+                let rn = pretty_print_ireg(rn, size);
+                let rm = pretty_print_ireg(rm, size);
+                let nzcv = nzcv.pretty_print(0);
+                let cond = cond.pretty_print(0);
+                format!("ccmp {rn}, {rm}, {nzcv}, {cond}")
             }
             &Inst::CCmpImm {
                 size,
@@ -1510,11 +1555,11 @@ impl Inst {
                 nzcv,
                 cond,
             } => {
-                let rn = pretty_print_ireg(rn, size, allocs);
-                let imm = imm.pretty_print(0, allocs);
-                let nzcv = nzcv.pretty_print(0, allocs);
-                let cond = cond.pretty_print(0, allocs);
-                format!("ccmp {}, {}, {}, {}", rn, imm, nzcv, cond)
+                let rn = pretty_print_ireg(rn, size);
+                let imm = imm.pretty_print(0);
+                let nzcv = nzcv.pretty_print(0);
+                let cond = cond.pretty_print(0);
+                format!("ccmp {rn}, {imm}, {nzcv}, {cond}")
             }
             &Inst::AtomicRMW {
                 rs, rt, rn, ty, op, ..
@@ -1532,16 +1577,16 @@ impl Inst {
                 };
 
                 let size = OperandSize::from_ty(ty);
-                let rs = pretty_print_ireg(rs, size, allocs);
-                let rt = pretty_print_ireg(rt.to_reg(), size, allocs);
-                let rn = pretty_print_ireg(rn, OperandSize::Size64, allocs);
+                let rs = pretty_print_ireg(rs, size);
+                let rt = pretty_print_ireg(rt.to_reg(), size);
+                let rn = pretty_print_ireg(rn, OperandSize::Size64);
 
                 let ty_suffix = match ty {
                     I8 => "b",
                     I16 => "h",
                     _ => "",
                 };
-                format!("{}{} {}, {}, [{}]", op, ty_suffix, rs, rt, rn)
+                format!("{op}{ty_suffix} {rs}, {rt}, [{rn}]")
             }
             &Inst::AtomicRMWLoop {
                 ty,
@@ -1566,11 +1611,11 @@ impl Inst {
                     AtomicRMWLoopOp::Umax => "umax",
                     AtomicRMWLoopOp::Xchg => "xchg",
                 };
-                let addr = pretty_print_ireg(addr, OperandSize::Size64, allocs);
-                let operand = pretty_print_ireg(operand, OperandSize::Size64, allocs);
-                let oldval = pretty_print_ireg(oldval.to_reg(), OperandSize::Size64, allocs);
-                let scratch1 = pretty_print_ireg(scratch1.to_reg(), OperandSize::Size64, allocs);
-                let scratch2 = pretty_print_ireg(scratch2.to_reg(), OperandSize::Size64, allocs);
+                let addr = pretty_print_ireg(addr, OperandSize::Size64);
+                let operand = pretty_print_ireg(operand, OperandSize::Size64);
+                let oldval = pretty_print_ireg(oldval.to_reg(), OperandSize::Size64);
+                let scratch1 = pretty_print_ireg(scratch1.to_reg(), OperandSize::Size64);
+                let scratch2 = pretty_print_ireg(scratch2.to_reg(), OperandSize::Size64);
                 format!(
                     "atomic_rmw_loop_{}_{} addr={} operand={} oldval={} scratch1={} scratch2={}",
                     op,
@@ -1589,15 +1634,15 @@ impl Inst {
                     I8 => "casalb",
                     I16 => "casalh",
                     I32 | I64 => "casal",
-                    _ => panic!("Unsupported type: {}", ty),
+                    _ => panic!("Unsupported type: {ty}"),
                 };
                 let size = OperandSize::from_ty(ty);
-                let rd = pretty_print_ireg(rd.to_reg(), size, allocs);
-                let rs = pretty_print_ireg(rs, size, allocs);
-                let rt = pretty_print_ireg(rt, size, allocs);
-                let rn = pretty_print_ireg(rn, OperandSize::Size64, allocs);
+                let rd = pretty_print_ireg(rd.to_reg(), size);
+                let rs = pretty_print_ireg(rs, size);
+                let rt = pretty_print_ireg(rt, size);
+                let rn = pretty_print_ireg(rn, OperandSize::Size64);
 
-                format!("{} {}, {}, {}, [{}]", op, rd, rs, rt, rn)
+                format!("{op} {rd}, {rs}, {rt}, [{rn}]")
             }
             &Inst::AtomicCASLoop {
                 ty,
@@ -1608,11 +1653,11 @@ impl Inst {
                 scratch,
                 ..
             } => {
-                let addr = pretty_print_ireg(addr, OperandSize::Size64, allocs);
-                let expected = pretty_print_ireg(expected, OperandSize::Size64, allocs);
-                let replacement = pretty_print_ireg(replacement, OperandSize::Size64, allocs);
-                let oldval = pretty_print_ireg(oldval.to_reg(), OperandSize::Size64, allocs);
-                let scratch = pretty_print_ireg(scratch.to_reg(), OperandSize::Size64, allocs);
+                let addr = pretty_print_ireg(addr, OperandSize::Size64);
+                let expected = pretty_print_ireg(expected, OperandSize::Size64);
+                let replacement = pretty_print_ireg(replacement, OperandSize::Size64);
+                let oldval = pretty_print_ireg(oldval.to_reg(), OperandSize::Size64);
+                let scratch = pretty_print_ireg(scratch.to_reg(), OperandSize::Size64);
                 format!(
                     "atomic_cas_loop_{} addr={}, expect={}, replacement={}, oldval={}, scratch={}",
                     ty.bits(),
@@ -1631,12 +1676,12 @@ impl Inst {
                     I16 => ("ldarh", I32),
                     I32 => ("ldar", I32),
                     I64 => ("ldar", I64),
-                    _ => panic!("Unsupported type: {}", access_ty),
+                    _ => panic!("Unsupported type: {access_ty}"),
                 };
                 let size = OperandSize::from_ty(ty);
-                let rn = pretty_print_ireg(rn, OperandSize::Size64, allocs);
-                let rt = pretty_print_ireg(rt.to_reg(), size, allocs);
-                format!("{} {}, [{}]", op, rt, rn)
+                let rn = pretty_print_ireg(rn, OperandSize::Size64);
+                let rt = pretty_print_ireg(rt.to_reg(), size);
+                format!("{op} {rt}, [{rn}]")
             }
             &Inst::StoreRelease {
                 access_ty, rt, rn, ..
@@ -1646,12 +1691,12 @@ impl Inst {
                     I16 => ("stlrh", I32),
                     I32 => ("stlr", I32),
                     I64 => ("stlr", I64),
-                    _ => panic!("Unsupported type: {}", access_ty),
+                    _ => panic!("Unsupported type: {access_ty}"),
                 };
                 let size = OperandSize::from_ty(ty);
-                let rn = pretty_print_ireg(rn, OperandSize::Size64, allocs);
-                let rt = pretty_print_ireg(rt, size, allocs);
-                format!("{} {}, [{}]", op, rt, rn)
+                let rn = pretty_print_ireg(rn, OperandSize::Size64);
+                let rt = pretty_print_ireg(rt, size);
+                format!("{op} {rt}, [{rn}]")
             }
             &Inst::Fence {} => {
                 format!("dmb ish")
@@ -1659,25 +1704,30 @@ impl Inst {
             &Inst::Csdb {} => {
                 format!("csdb")
             }
+            &Inst::FpuMove32 { rd, rn } => {
+                let rd = pretty_print_vreg_scalar(rd.to_reg(), ScalarSize::Size32);
+                let rn = pretty_print_vreg_scalar(rn, ScalarSize::Size32);
+                format!("fmov {rd}, {rn}")
+            }
             &Inst::FpuMove64 { rd, rn } => {
-                let rd = pretty_print_vreg_scalar(rd.to_reg(), ScalarSize::Size64, allocs);
-                let rn = pretty_print_vreg_scalar(rn, ScalarSize::Size64, allocs);
-                format!("fmov {}, {}", rd, rn)
+                let rd = pretty_print_vreg_scalar(rd.to_reg(), ScalarSize::Size64);
+                let rn = pretty_print_vreg_scalar(rn, ScalarSize::Size64);
+                format!("fmov {rd}, {rn}")
             }
             &Inst::FpuMove128 { rd, rn } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                let rn = pretty_print_reg(rn, allocs);
-                format!("mov {}.16b, {}.16b", rd, rn)
+                let rd = pretty_print_reg(rd.to_reg());
+                let rn = pretty_print_reg(rn);
+                format!("mov {rd}.16b, {rn}.16b")
             }
             &Inst::FpuMoveFromVec { rd, rn, idx, size } => {
-                let rd = pretty_print_vreg_scalar(rd.to_reg(), size.lane_size(), allocs);
-                let rn = pretty_print_vreg_element(rn, idx as usize, size.lane_size(), allocs);
-                format!("mov {}, {}", rd, rn)
+                let rd = pretty_print_vreg_scalar(rd.to_reg(), size.lane_size());
+                let rn = pretty_print_vreg_element(rn, idx as usize, size.lane_size());
+                format!("mov {rd}, {rn}")
             }
             &Inst::FpuExtend { rd, rn, size } => {
-                let rd = pretty_print_vreg_scalar(rd.to_reg(), size, allocs);
-                let rn = pretty_print_vreg_scalar(rn, size, allocs);
-                format!("fmov {}, {}", rd, rn)
+                let rd = pretty_print_vreg_scalar(rd.to_reg(), size);
+                let rn = pretty_print_vreg_scalar(rn, size);
+                format!("fmov {rd}, {rn}")
             }
             &Inst::FpuRR {
                 fpu_op,
@@ -1696,9 +1746,9 @@ impl Inst {
                     FPUOp1::Cvt64To32 => ScalarSize::Size32,
                     _ => size,
                 };
-                let rd = pretty_print_vreg_scalar(rd.to_reg(), dst_size, allocs);
-                let rn = pretty_print_vreg_scalar(rn, size, allocs);
-                format!("{} {}, {}", op, rd, rn)
+                let rd = pretty_print_vreg_scalar(rd.to_reg(), dst_size);
+                let rn = pretty_print_vreg_scalar(rn, size);
+                format!("{op} {rd}, {rn}")
             }
             &Inst::FpuRRR {
                 fpu_op,
@@ -1715,50 +1765,50 @@ impl Inst {
                     FPUOp2::Max => "fmax",
                     FPUOp2::Min => "fmin",
                 };
-                let rd = pretty_print_vreg_scalar(rd.to_reg(), size, allocs);
-                let rn = pretty_print_vreg_scalar(rn, size, allocs);
-                let rm = pretty_print_vreg_scalar(rm, size, allocs);
-                format!("{} {}, {}, {}", op, rd, rn, rm)
+                let rd = pretty_print_vreg_scalar(rd.to_reg(), size);
+                let rn = pretty_print_vreg_scalar(rn, size);
+                let rm = pretty_print_vreg_scalar(rm, size);
+                format!("{op} {rd}, {rn}, {rm}")
             }
             &Inst::FpuRRI { fpu_op, rd, rn } => {
                 let (op, imm, vector) = match fpu_op {
-                    FPUOpRI::UShr32(imm) => ("ushr", imm.pretty_print(0, allocs), true),
-                    FPUOpRI::UShr64(imm) => ("ushr", imm.pretty_print(0, allocs), false),
+                    FPUOpRI::UShr32(imm) => ("ushr", imm.pretty_print(0), true),
+                    FPUOpRI::UShr64(imm) => ("ushr", imm.pretty_print(0), false),
                 };
 
                 let (rd, rn) = if vector {
                     (
-                        pretty_print_vreg_vector(rd.to_reg(), VectorSize::Size32x2, allocs),
-                        pretty_print_vreg_vector(rn, VectorSize::Size32x2, allocs),
+                        pretty_print_vreg_vector(rd.to_reg(), VectorSize::Size32x2),
+                        pretty_print_vreg_vector(rn, VectorSize::Size32x2),
                     )
                 } else {
                     (
-                        pretty_print_vreg_scalar(rd.to_reg(), ScalarSize::Size64, allocs),
-                        pretty_print_vreg_scalar(rn, ScalarSize::Size64, allocs),
+                        pretty_print_vreg_scalar(rd.to_reg(), ScalarSize::Size64),
+                        pretty_print_vreg_scalar(rn, ScalarSize::Size64),
                     )
                 };
-                format!("{} {}, {}, {}", op, rd, rn, imm)
+                format!("{op} {rd}, {rn}, {imm}")
             }
             &Inst::FpuRRIMod { fpu_op, rd, ri, rn } => {
                 let (op, imm, vector) = match fpu_op {
-                    FPUOpRIMod::Sli32(imm) => ("sli", imm.pretty_print(0, allocs), true),
-                    FPUOpRIMod::Sli64(imm) => ("sli", imm.pretty_print(0, allocs), false),
+                    FPUOpRIMod::Sli32(imm) => ("sli", imm.pretty_print(0), true),
+                    FPUOpRIMod::Sli64(imm) => ("sli", imm.pretty_print(0), false),
                 };
 
                 let (rd, ri, rn) = if vector {
                     (
-                        pretty_print_vreg_vector(rd.to_reg(), VectorSize::Size32x2, allocs),
-                        pretty_print_vreg_vector(ri, VectorSize::Size32x2, allocs),
-                        pretty_print_vreg_vector(rn, VectorSize::Size32x2, allocs),
+                        pretty_print_vreg_vector(rd.to_reg(), VectorSize::Size32x2),
+                        pretty_print_vreg_vector(ri, VectorSize::Size32x2),
+                        pretty_print_vreg_vector(rn, VectorSize::Size32x2),
                     )
                 } else {
                     (
-                        pretty_print_vreg_scalar(rd.to_reg(), ScalarSize::Size64, allocs),
-                        pretty_print_vreg_scalar(ri, ScalarSize::Size64, allocs),
-                        pretty_print_vreg_scalar(rn, ScalarSize::Size64, allocs),
+                        pretty_print_vreg_scalar(rd.to_reg(), ScalarSize::Size64),
+                        pretty_print_vreg_scalar(ri, ScalarSize::Size64),
+                        pretty_print_vreg_scalar(rn, ScalarSize::Size64),
                     )
                 };
-                format!("{} {}, {}, {}, {}", op, rd, ri, rn, imm)
+                format!("{op} {rd}, {ri}, {rn}, {imm}")
             }
             &Inst::FpuRRRR {
                 fpu_op,
@@ -1770,101 +1820,118 @@ impl Inst {
             } => {
                 let op = match fpu_op {
                     FPUOp3::MAdd => "fmadd",
+                    FPUOp3::MSub => "fmsub",
+                    FPUOp3::NMAdd => "fnmadd",
+                    FPUOp3::NMSub => "fnmsub",
                 };
-                let rd = pretty_print_vreg_scalar(rd.to_reg(), size, allocs);
-                let rn = pretty_print_vreg_scalar(rn, size, allocs);
-                let rm = pretty_print_vreg_scalar(rm, size, allocs);
-                let ra = pretty_print_vreg_scalar(ra, size, allocs);
-                format!("{} {}, {}, {}, {}", op, rd, rn, rm, ra)
+                let rd = pretty_print_vreg_scalar(rd.to_reg(), size);
+                let rn = pretty_print_vreg_scalar(rn, size);
+                let rm = pretty_print_vreg_scalar(rm, size);
+                let ra = pretty_print_vreg_scalar(ra, size);
+                format!("{op} {rd}, {rn}, {rm}, {ra}")
             }
             &Inst::FpuCmp { size, rn, rm } => {
-                let rn = pretty_print_vreg_scalar(rn, size, allocs);
-                let rm = pretty_print_vreg_scalar(rm, size, allocs);
-                format!("fcmp {}, {}", rn, rm)
+                let rn = pretty_print_vreg_scalar(rn, size);
+                let rm = pretty_print_vreg_scalar(rm, size);
+                format!("fcmp {rn}, {rm}")
+            }
+            &Inst::FpuLoad16 { rd, ref mem, .. } => {
+                let rd = pretty_print_vreg_scalar(rd.to_reg(), ScalarSize::Size16);
+                let mem = mem.clone();
+                let access_ty = self.mem_type().unwrap();
+                let (mem_str, mem) = mem_finalize_for_show(&mem, access_ty, state);
+                format!("{mem_str}ldr {rd}, {mem}")
             }
             &Inst::FpuLoad32 { rd, ref mem, .. } => {
-                let rd = pretty_print_vreg_scalar(rd.to_reg(), ScalarSize::Size32, allocs);
-                let mem = mem.with_allocs(allocs);
-                let (mem_str, mem) = mem_finalize_for_show(&mem, state);
-                let mem = mem.pretty_print_default();
-                format!("{}ldr {}, {}", mem_str, rd, mem)
+                let rd = pretty_print_vreg_scalar(rd.to_reg(), ScalarSize::Size32);
+                let mem = mem.clone();
+                let access_ty = self.mem_type().unwrap();
+                let (mem_str, mem) = mem_finalize_for_show(&mem, access_ty, state);
+                format!("{mem_str}ldr {rd}, {mem}")
             }
             &Inst::FpuLoad64 { rd, ref mem, .. } => {
-                let rd = pretty_print_vreg_scalar(rd.to_reg(), ScalarSize::Size64, allocs);
-                let mem = mem.with_allocs(allocs);
-                let (mem_str, mem) = mem_finalize_for_show(&mem, state);
-                let mem = mem.pretty_print_default();
-                format!("{}ldr {}, {}", mem_str, rd, mem)
+                let rd = pretty_print_vreg_scalar(rd.to_reg(), ScalarSize::Size64);
+                let mem = mem.clone();
+                let access_ty = self.mem_type().unwrap();
+                let (mem_str, mem) = mem_finalize_for_show(&mem, access_ty, state);
+                format!("{mem_str}ldr {rd}, {mem}")
             }
             &Inst::FpuLoad128 { rd, ref mem, .. } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
+                let rd = pretty_print_reg(rd.to_reg());
                 let rd = "q".to_string() + &rd[1..];
-                let mem = mem.with_allocs(allocs);
-                let (mem_str, mem) = mem_finalize_for_show(&mem, state);
-                let mem = mem.pretty_print_default();
-                format!("{}ldr {}, {}", mem_str, rd, mem)
+                let mem = mem.clone();
+                let access_ty = self.mem_type().unwrap();
+                let (mem_str, mem) = mem_finalize_for_show(&mem, access_ty, state);
+                format!("{mem_str}ldr {rd}, {mem}")
+            }
+            &Inst::FpuStore16 { rd, ref mem, .. } => {
+                let rd = pretty_print_vreg_scalar(rd, ScalarSize::Size16);
+                let mem = mem.clone();
+                let access_ty = self.mem_type().unwrap();
+                let (mem_str, mem) = mem_finalize_for_show(&mem, access_ty, state);
+                format!("{mem_str}str {rd}, {mem}")
             }
             &Inst::FpuStore32 { rd, ref mem, .. } => {
-                let rd = pretty_print_vreg_scalar(rd, ScalarSize::Size32, allocs);
-                let mem = mem.with_allocs(allocs);
-                let (mem_str, mem) = mem_finalize_for_show(&mem, state);
-                let mem = mem.pretty_print_default();
-                format!("{}str {}, {}", mem_str, rd, mem)
+                let rd = pretty_print_vreg_scalar(rd, ScalarSize::Size32);
+                let mem = mem.clone();
+                let access_ty = self.mem_type().unwrap();
+                let (mem_str, mem) = mem_finalize_for_show(&mem, access_ty, state);
+                format!("{mem_str}str {rd}, {mem}")
             }
             &Inst::FpuStore64 { rd, ref mem, .. } => {
-                let rd = pretty_print_vreg_scalar(rd, ScalarSize::Size64, allocs);
-                let mem = mem.with_allocs(allocs);
-                let (mem_str, mem) = mem_finalize_for_show(&mem, state);
-                let mem = mem.pretty_print_default();
-                format!("{}str {}, {}", mem_str, rd, mem)
+                let rd = pretty_print_vreg_scalar(rd, ScalarSize::Size64);
+                let mem = mem.clone();
+                let access_ty = self.mem_type().unwrap();
+                let (mem_str, mem) = mem_finalize_for_show(&mem, access_ty, state);
+                format!("{mem_str}str {rd}, {mem}")
             }
             &Inst::FpuStore128 { rd, ref mem, .. } => {
-                let rd = pretty_print_reg(rd, allocs);
+                let rd = pretty_print_reg(rd);
                 let rd = "q".to_string() + &rd[1..];
-                let mem = mem.with_allocs(allocs);
-                let (mem_str, mem) = mem_finalize_for_show(&mem, state);
-                let mem = mem.pretty_print_default();
-                format!("{}str {}, {}", mem_str, rd, mem)
+                let mem = mem.clone();
+                let access_ty = self.mem_type().unwrap();
+                let (mem_str, mem) = mem_finalize_for_show(&mem, access_ty, state);
+                format!("{mem_str}str {rd}, {mem}")
             }
             &Inst::FpuLoadP64 {
                 rt, rt2, ref mem, ..
             } => {
-                let rt = pretty_print_vreg_scalar(rt.to_reg(), ScalarSize::Size64, allocs);
-                let rt2 = pretty_print_vreg_scalar(rt2.to_reg(), ScalarSize::Size64, allocs);
-                let mem = mem.with_allocs(allocs);
+                let rt = pretty_print_vreg_scalar(rt.to_reg(), ScalarSize::Size64);
+                let rt2 = pretty_print_vreg_scalar(rt2.to_reg(), ScalarSize::Size64);
+                let mem = mem.clone();
                 let mem = mem.pretty_print_default();
 
-                format!("ldp {}, {}, {}", rt, rt2, mem)
+                format!("ldp {rt}, {rt2}, {mem}")
             }
             &Inst::FpuStoreP64 {
                 rt, rt2, ref mem, ..
             } => {
-                let rt = pretty_print_vreg_scalar(rt, ScalarSize::Size64, allocs);
-                let rt2 = pretty_print_vreg_scalar(rt2, ScalarSize::Size64, allocs);
-                let mem = mem.with_allocs(allocs);
+                let rt = pretty_print_vreg_scalar(rt, ScalarSize::Size64);
+                let rt2 = pretty_print_vreg_scalar(rt2, ScalarSize::Size64);
+                let mem = mem.clone();
                 let mem = mem.pretty_print_default();
 
-                format!("stp {}, {}, {}", rt, rt2, mem)
+                format!("stp {rt}, {rt2}, {mem}")
             }
             &Inst::FpuLoadP128 {
                 rt, rt2, ref mem, ..
             } => {
-                let rt = pretty_print_vreg_scalar(rt.to_reg(), ScalarSize::Size128, allocs);
-                let rt2 = pretty_print_vreg_scalar(rt2.to_reg(), ScalarSize::Size128, allocs);
-                let mem = mem.with_allocs(allocs);
+                let rt = pretty_print_vreg_scalar(rt.to_reg(), ScalarSize::Size128);
+                let rt2 = pretty_print_vreg_scalar(rt2.to_reg(), ScalarSize::Size128);
+                let mem = mem.clone();
                 let mem = mem.pretty_print_default();
 
-                format!("ldp {}, {}, {}", rt, rt2, mem)
+                format!("ldp {rt}, {rt2}, {mem}")
             }
             &Inst::FpuStoreP128 {
                 rt, rt2, ref mem, ..
             } => {
-                let rt = pretty_print_vreg_scalar(rt, ScalarSize::Size128, allocs);
-                let rt2 = pretty_print_vreg_scalar(rt2, ScalarSize::Size128, allocs);
-                let mem = mem.with_allocs(allocs);
+                let rt = pretty_print_vreg_scalar(rt, ScalarSize::Size128);
+                let rt2 = pretty_print_vreg_scalar(rt2, ScalarSize::Size128);
+                let mem = mem.clone();
                 let mem = mem.pretty_print_default();
 
-                format!("stp {}, {}, {}", rt, rt2, mem)
+                format!("stp {rt}, {rt2}, {mem}")
             }
             &Inst::FpuToInt { op, rd, rn } => {
                 let (op, sizesrc, sizedest) = match op {
@@ -1877,9 +1944,9 @@ impl Inst {
                     FpuToIntOp::F64ToI64 => ("fcvtzs", ScalarSize::Size64, OperandSize::Size64),
                     FpuToIntOp::F64ToU64 => ("fcvtzu", ScalarSize::Size64, OperandSize::Size64),
                 };
-                let rd = pretty_print_ireg(rd.to_reg(), sizedest, allocs);
-                let rn = pretty_print_vreg_scalar(rn, sizesrc, allocs);
-                format!("{} {}, {}", op, rd, rn)
+                let rd = pretty_print_ireg(rd.to_reg(), sizedest);
+                let rn = pretty_print_vreg_scalar(rn, sizesrc);
+                format!("{op} {rd}, {rn}")
             }
             &Inst::IntToFpu { op, rd, rn } => {
                 let (op, sizesrc, sizedest) = match op {
@@ -1892,23 +1959,30 @@ impl Inst {
                     IntToFpuOp::I64ToF64 => ("scvtf", OperandSize::Size64, ScalarSize::Size64),
                     IntToFpuOp::U64ToF64 => ("ucvtf", OperandSize::Size64, ScalarSize::Size64),
                 };
-                let rd = pretty_print_vreg_scalar(rd.to_reg(), sizedest, allocs);
-                let rn = pretty_print_ireg(rn, sizesrc, allocs);
-                format!("{} {}, {}", op, rd, rn)
+                let rd = pretty_print_vreg_scalar(rd.to_reg(), sizedest);
+                let rn = pretty_print_ireg(rn, sizesrc);
+                format!("{op} {rd}, {rn}")
+            }
+            &Inst::FpuCSel16 { rd, rn, rm, cond } => {
+                let rd = pretty_print_vreg_scalar(rd.to_reg(), ScalarSize::Size16);
+                let rn = pretty_print_vreg_scalar(rn, ScalarSize::Size16);
+                let rm = pretty_print_vreg_scalar(rm, ScalarSize::Size16);
+                let cond = cond.pretty_print(0);
+                format!("fcsel {rd}, {rn}, {rm}, {cond}")
             }
             &Inst::FpuCSel32 { rd, rn, rm, cond } => {
-                let rd = pretty_print_vreg_scalar(rd.to_reg(), ScalarSize::Size32, allocs);
-                let rn = pretty_print_vreg_scalar(rn, ScalarSize::Size32, allocs);
-                let rm = pretty_print_vreg_scalar(rm, ScalarSize::Size32, allocs);
-                let cond = cond.pretty_print(0, allocs);
-                format!("fcsel {}, {}, {}, {}", rd, rn, rm, cond)
+                let rd = pretty_print_vreg_scalar(rd.to_reg(), ScalarSize::Size32);
+                let rn = pretty_print_vreg_scalar(rn, ScalarSize::Size32);
+                let rm = pretty_print_vreg_scalar(rm, ScalarSize::Size32);
+                let cond = cond.pretty_print(0);
+                format!("fcsel {rd}, {rn}, {rm}, {cond}")
             }
             &Inst::FpuCSel64 { rd, rn, rm, cond } => {
-                let rd = pretty_print_vreg_scalar(rd.to_reg(), ScalarSize::Size64, allocs);
-                let rn = pretty_print_vreg_scalar(rn, ScalarSize::Size64, allocs);
-                let rm = pretty_print_vreg_scalar(rm, ScalarSize::Size64, allocs);
-                let cond = cond.pretty_print(0, allocs);
-                format!("fcsel {}, {}, {}, {}", rd, rn, rm, cond)
+                let rd = pretty_print_vreg_scalar(rd.to_reg(), ScalarSize::Size64);
+                let rn = pretty_print_vreg_scalar(rn, ScalarSize::Size64);
+                let rm = pretty_print_vreg_scalar(rm, ScalarSize::Size64);
+                let cond = cond.pretty_print(0);
+                format!("fcsel {rd}, {rn}, {rm}, {cond}")
             }
             &Inst::FpuRound { op, rd, rn } => {
                 let (inst, size) = match op {
@@ -1921,21 +1995,21 @@ impl Inst {
                     FpuRoundMode::Nearest32 => ("frintn", ScalarSize::Size32),
                     FpuRoundMode::Nearest64 => ("frintn", ScalarSize::Size64),
                 };
-                let rd = pretty_print_vreg_scalar(rd.to_reg(), size, allocs);
-                let rn = pretty_print_vreg_scalar(rn, size, allocs);
-                format!("{} {}, {}", inst, rd, rn)
+                let rd = pretty_print_vreg_scalar(rd.to_reg(), size);
+                let rn = pretty_print_vreg_scalar(rn, size);
+                format!("{inst} {rd}, {rn}")
             }
             &Inst::MovToFpu { rd, rn, size } => {
                 let operand_size = size.operand_size();
-                let rd = pretty_print_vreg_scalar(rd.to_reg(), size, allocs);
-                let rn = pretty_print_ireg(rn, operand_size, allocs);
-                format!("fmov {}, {}", rd, rn)
+                let rd = pretty_print_vreg_scalar(rd.to_reg(), size);
+                let rn = pretty_print_ireg(rn, operand_size);
+                format!("fmov {rd}, {rn}")
             }
             &Inst::FpuMoveFPImm { rd, imm, size } => {
-                let imm = imm.pretty_print(0, allocs);
-                let rd = pretty_print_vreg_scalar(rd.to_reg(), size, allocs);
+                let imm = imm.pretty_print(0);
+                let rd = pretty_print_vreg_scalar(rd.to_reg(), size);
 
-                format!("fmov {}, {}", rd, imm)
+                format!("fmov {rd}, {imm}")
             }
             &Inst::MovToVec {
                 rd,
@@ -1944,11 +2018,10 @@ impl Inst {
                 idx,
                 size,
             } => {
-                let rd =
-                    pretty_print_vreg_element(rd.to_reg(), idx as usize, size.lane_size(), allocs);
-                let ri = pretty_print_vreg_element(ri, idx as usize, size.lane_size(), allocs);
-                let rn = pretty_print_ireg(rn, size.operand_size(), allocs);
-                format!("mov {}, {}, {}", rd, ri, rn)
+                let rd = pretty_print_vreg_element(rd.to_reg(), idx as usize, size.lane_size());
+                let ri = pretty_print_vreg_element(ri, idx as usize, size.lane_size());
+                let rn = pretty_print_ireg(rn, size.operand_size());
+                format!("mov {rd}, {ri}, {rn}")
             }
             &Inst::MovFromVec { rd, rn, idx, size } => {
                 let op = match size {
@@ -1958,9 +2031,9 @@ impl Inst {
                     ScalarSize::Size64 => "mov",
                     _ => unimplemented!(),
                 };
-                let rd = pretty_print_ireg(rd.to_reg(), size.operand_size(), allocs);
-                let rn = pretty_print_vreg_element(rn, idx as usize, size, allocs);
-                format!("{} {}, {}", op, rd, rn)
+                let rd = pretty_print_ireg(rd.to_reg(), size.operand_size());
+                let rn = pretty_print_vreg_element(rn, idx as usize, size);
+                format!("{op} {rd}, {rn}")
             }
             &Inst::MovFromVecSigned {
                 rd,
@@ -1969,25 +2042,25 @@ impl Inst {
                 size,
                 scalar_size,
             } => {
-                let rd = pretty_print_ireg(rd.to_reg(), scalar_size, allocs);
-                let rn = pretty_print_vreg_element(rn, idx as usize, size.lane_size(), allocs);
-                format!("smov {}, {}", rd, rn)
+                let rd = pretty_print_ireg(rd.to_reg(), scalar_size);
+                let rn = pretty_print_vreg_element(rn, idx as usize, size.lane_size());
+                format!("smov {rd}, {rn}")
             }
             &Inst::VecDup { rd, rn, size } => {
-                let rd = pretty_print_vreg_vector(rd.to_reg(), size, allocs);
-                let rn = pretty_print_ireg(rn, size.operand_size(), allocs);
-                format!("dup {}, {}", rd, rn)
+                let rd = pretty_print_vreg_vector(rd.to_reg(), size);
+                let rn = pretty_print_ireg(rn, size.operand_size());
+                format!("dup {rd}, {rn}")
             }
             &Inst::VecDupFromFpu { rd, rn, size, lane } => {
-                let rd = pretty_print_vreg_vector(rd.to_reg(), size, allocs);
-                let rn = pretty_print_vreg_element(rn, lane.into(), size.lane_size(), allocs);
-                format!("dup {}, {}", rd, rn)
+                let rd = pretty_print_vreg_vector(rd.to_reg(), size);
+                let rn = pretty_print_vreg_element(rn, lane.into(), size.lane_size());
+                format!("dup {rd}, {rn}")
             }
             &Inst::VecDupFPImm { rd, imm, size } => {
-                let imm = imm.pretty_print(0, allocs);
-                let rd = pretty_print_vreg_vector(rd.to_reg(), size, allocs);
+                let imm = imm.pretty_print(0);
+                let rd = pretty_print_vreg_vector(rd.to_reg(), size);
 
-                format!("fmov {}, {}", rd, imm)
+                format!("fmov {rd}, {imm}")
             }
             &Inst::VecDupImm {
                 rd,
@@ -1995,11 +2068,11 @@ impl Inst {
                 invert,
                 size,
             } => {
-                let imm = imm.pretty_print(0, allocs);
+                let imm = imm.pretty_print(0);
                 let op = if invert { "mvni" } else { "movi" };
-                let rd = pretty_print_vreg_vector(rd.to_reg(), size, allocs);
+                let rd = pretty_print_vreg_vector(rd.to_reg(), size);
 
-                format!("{} {}, {}", op, rd, imm)
+                format!("{op} {rd}, {imm}")
             }
             &Inst::VecExtend {
                 t,
@@ -2017,9 +2090,9 @@ impl Inst {
                     (VecExtendOp::Uxtl, false) => ("uxtl", vec64),
                     (VecExtendOp::Uxtl, true) => ("uxtl2", vec128),
                 };
-                let rd = pretty_print_vreg_vector(rd.to_reg(), rd_size, allocs);
-                let rn = pretty_print_vreg_vector(rn, rn_size, allocs);
-                format!("{} {}, {}", op, rd, rn)
+                let rd = pretty_print_vreg_vector(rd.to_reg(), rd_size);
+                let rn = pretty_print_vreg_vector(rn, rn_size);
+                format!("{op} {rd}, {rn}")
             }
             &Inst::VecMovElement {
                 rd,
@@ -2029,15 +2102,11 @@ impl Inst {
                 src_idx,
                 size,
             } => {
-                let rd = pretty_print_vreg_element(
-                    rd.to_reg(),
-                    dest_idx as usize,
-                    size.lane_size(),
-                    allocs,
-                );
-                let ri = pretty_print_vreg_element(ri, dest_idx as usize, size.lane_size(), allocs);
-                let rn = pretty_print_vreg_element(rn, src_idx as usize, size.lane_size(), allocs);
-                format!("mov {}, {}, {}", rd, ri, rn)
+                let rd =
+                    pretty_print_vreg_element(rd.to_reg(), dest_idx as usize, size.lane_size());
+                let ri = pretty_print_vreg_element(ri, dest_idx as usize, size.lane_size());
+                let rn = pretty_print_vreg_element(rn, src_idx as usize, size.lane_size());
+                format!("mov {rd}, {ri}, {rn}")
             }
             &Inst::VecRRLong {
                 op,
@@ -2077,10 +2146,10 @@ impl Inst {
                         ("shll2", VectorSize::Size64x2, VectorSize::Size32x4, ", #32")
                     }
                 };
-                let rd = pretty_print_vreg_vector(rd.to_reg(), rd_size, allocs);
-                let rn = pretty_print_vreg_vector(rn, size, allocs);
+                let rd = pretty_print_vreg_vector(rd.to_reg(), rd_size);
+                let rn = pretty_print_vreg_vector(rn, size);
 
-                format!("{} {}, {}{}", op, rd, rn, suffix)
+                format!("{op} {rd}, {rn}{suffix}")
             }
             &Inst::VecRRNarrowLow {
                 op,
@@ -2116,26 +2185,26 @@ impl Inst {
                     (VecRRNarrowOp::Fcvtn, false) => ("fcvtn", vec64),
                     (VecRRNarrowOp::Fcvtn, true) => ("fcvtn2", vec128),
                 };
-                let rn = pretty_print_vreg_vector(rn, rn_size, allocs);
-                let rd = pretty_print_vreg_vector(rd.to_reg(), rd_size, allocs);
+                let rn = pretty_print_vreg_vector(rn, rn_size);
+                let rd = pretty_print_vreg_vector(rd.to_reg(), rd_size);
                 let ri = match self {
                     &Inst::VecRRNarrowLow { .. } => "".to_string(),
                     &Inst::VecRRNarrowHigh { ri, .. } => {
-                        format!("{}, ", pretty_print_vreg_vector(ri, rd_size, allocs))
+                        format!("{}, ", pretty_print_vreg_vector(ri, rd_size))
                     }
                     _ => unreachable!(),
                 };
 
-                format!("{} {}, {}{}", op, rd, ri, rn)
+                format!("{op} {rd}, {ri}{rn}")
             }
             &Inst::VecRRPair { op, rd, rn } => {
                 let op = match op {
                     VecPairOp::Addp => "addp",
                 };
-                let rd = pretty_print_vreg_scalar(rd.to_reg(), ScalarSize::Size64, allocs);
-                let rn = pretty_print_vreg_vector(rn, VectorSize::Size64x2, allocs);
+                let rd = pretty_print_vreg_scalar(rd.to_reg(), ScalarSize::Size64);
+                let rn = pretty_print_vreg_vector(rn, VectorSize::Size64x2);
 
-                format!("{} {}, {}", op, rd, rn)
+                format!("{op} {rd}, {rn}")
             }
             &Inst::VecRRPairLong { op, rd, rn } => {
                 let (op, dest, src) = match op {
@@ -2152,10 +2221,10 @@ impl Inst {
                         ("uaddlp", VectorSize::Size32x4, VectorSize::Size16x8)
                     }
                 };
-                let rd = pretty_print_vreg_vector(rd.to_reg(), dest, allocs);
-                let rn = pretty_print_vreg_vector(rn, src, allocs);
+                let rd = pretty_print_vreg_vector(rd.to_reg(), dest);
+                let rn = pretty_print_vreg_vector(rn, src);
 
-                format!("{} {}, {}", op, rd, rn)
+                format!("{op} {rd}, {rn}")
             }
             &Inst::VecRRR {
                 rd,
@@ -2207,10 +2276,10 @@ impl Inst {
                     VecALUOp::Trn1 => ("trn1", size),
                     VecALUOp::Trn2 => ("trn2", size),
                 };
-                let rd = pretty_print_vreg_vector(rd.to_reg(), size, allocs);
-                let rn = pretty_print_vreg_vector(rn, size, allocs);
-                let rm = pretty_print_vreg_vector(rm, size, allocs);
-                format!("{} {}, {}, {}", op, rd, rn, rm)
+                let rd = pretty_print_vreg_vector(rd.to_reg(), size);
+                let rn = pretty_print_vreg_vector(rn, size);
+                let rm = pretty_print_vreg_vector(rm, size);
+                format!("{op} {rd}, {rn}, {rm}")
             }
             &Inst::VecRRRMod {
                 rd,
@@ -2225,11 +2294,11 @@ impl Inst {
                     VecALUModOp::Fmla => ("fmla", size),
                     VecALUModOp::Fmls => ("fmls", size),
                 };
-                let rd = pretty_print_vreg_vector(rd.to_reg(), size, allocs);
-                let ri = pretty_print_vreg_vector(ri, size, allocs);
-                let rn = pretty_print_vreg_vector(rn, size, allocs);
-                let rm = pretty_print_vreg_vector(rm, size, allocs);
-                format!("{} {}, {}, {}, {}", op, rd, ri, rn, rm)
+                let rd = pretty_print_vreg_vector(rd.to_reg(), size);
+                let ri = pretty_print_vreg_vector(ri, size);
+                let rn = pretty_print_vreg_vector(rn, size);
+                let rm = pretty_print_vreg_vector(rm, size);
+                format!("{op} {rd}, {ri}, {rn}, {rm}")
             }
             &Inst::VecFmlaElem {
                 rd,
@@ -2245,11 +2314,11 @@ impl Inst {
                     VecALUModOp::Fmls => ("fmls", size),
                     _ => unreachable!(),
                 };
-                let rd = pretty_print_vreg_vector(rd.to_reg(), size, allocs);
-                let ri = pretty_print_vreg_vector(ri, size, allocs);
-                let rn = pretty_print_vreg_vector(rn, size, allocs);
-                let rm = pretty_print_vreg_element(rm, idx.into(), size.lane_size(), allocs);
-                format!("{} {}, {}, {}, {}", op, rd, ri, rn, rm)
+                let rd = pretty_print_vreg_vector(rd.to_reg(), size);
+                let ri = pretty_print_vreg_vector(ri, size);
+                let rn = pretty_print_vreg_vector(rn, size);
+                let rm = pretty_print_vreg_element(rm, idx.into(), size.lane_size());
+                format!("{op} {rd}, {ri}, {rn}, {rm}")
             }
             &Inst::VecRRRLong {
                 rd,
@@ -2296,10 +2365,10 @@ impl Inst {
                         ("umull2", VectorSize::Size64x2, VectorSize::Size32x4)
                     }
                 };
-                let rd = pretty_print_vreg_vector(rd.to_reg(), dest_size, allocs);
-                let rn = pretty_print_vreg_vector(rn, src_size, allocs);
-                let rm = pretty_print_vreg_vector(rm, src_size, allocs);
-                format!("{} {}, {}, {}", op, rd, rn, rm)
+                let rd = pretty_print_vreg_vector(rd.to_reg(), dest_size);
+                let rn = pretty_print_vreg_vector(rn, src_size);
+                let rm = pretty_print_vreg_vector(rm, src_size);
+                format!("{op} {rd}, {rn}, {rm}")
             }
             &Inst::VecRRRLongMod {
                 rd,
@@ -2329,11 +2398,11 @@ impl Inst {
                         ("umlal2", VectorSize::Size64x2, VectorSize::Size32x4)
                     }
                 };
-                let rd = pretty_print_vreg_vector(rd.to_reg(), dest_size, allocs);
-                let ri = pretty_print_vreg_vector(ri, dest_size, allocs);
-                let rn = pretty_print_vreg_vector(rn, src_size, allocs);
-                let rm = pretty_print_vreg_vector(rm, src_size, allocs);
-                format!("{} {}, {}, {}, {}", op, rd, ri, rn, rm)
+                let rd = pretty_print_vreg_vector(rd.to_reg(), dest_size);
+                let ri = pretty_print_vreg_vector(ri, dest_size);
+                let rn = pretty_print_vreg_vector(rn, src_size);
+                let rm = pretty_print_vreg_vector(rm, src_size);
+                format!("{op} {rd}, {ri}, {rn}, {rm}")
             }
             &Inst::VecMisc { op, rd, rn, size } => {
                 let (op, size, suffix) = match op {
@@ -2374,18 +2443,18 @@ impl Inst {
                     VecMisc2::Fcmle0 => ("fcmle", size, ", #0.0"),
                     VecMisc2::Fcmlt0 => ("fcmlt", size, ", #0.0"),
                 };
-                let rd = pretty_print_vreg_vector(rd.to_reg(), size, allocs);
-                let rn = pretty_print_vreg_vector(rn, size, allocs);
-                format!("{} {}, {}{}", op, rd, rn, suffix)
+                let rd = pretty_print_vreg_vector(rd.to_reg(), size);
+                let rn = pretty_print_vreg_vector(rn, size);
+                format!("{op} {rd}, {rn}{suffix}")
             }
             &Inst::VecLanes { op, rd, rn, size } => {
                 let op = match op {
                     VecLanesOp::Uminv => "uminv",
                     VecLanesOp::Addv => "addv",
                 };
-                let rd = pretty_print_vreg_scalar(rd.to_reg(), size.lane_size(), allocs);
-                let rn = pretty_print_vreg_vector(rn, size, allocs);
-                format!("{} {}, {}", op, rd, rn)
+                let rd = pretty_print_vreg_scalar(rd.to_reg(), size.lane_size());
+                let rn = pretty_print_vreg_vector(rn, size);
+                format!("{op} {rd}, {rn}")
             }
             &Inst::VecShiftImm {
                 op,
@@ -2399,9 +2468,9 @@ impl Inst {
                     VecShiftImmOp::Ushr => "ushr",
                     VecShiftImmOp::Sshr => "sshr",
                 };
-                let rd = pretty_print_vreg_vector(rd.to_reg(), size, allocs);
-                let rn = pretty_print_vreg_vector(rn, size, allocs);
-                format!("{} {}, {}, #{}", op, rd, rn, imm)
+                let rd = pretty_print_vreg_vector(rd.to_reg(), size);
+                let rn = pretty_print_vreg_vector(rn, size);
+                format!("{op} {rd}, {rn}, #{imm}")
             }
             &Inst::VecShiftImmMod {
                 op,
@@ -2414,36 +2483,36 @@ impl Inst {
                 let op = match op {
                     VecShiftImmModOp::Sli => "sli",
                 };
-                let rd = pretty_print_vreg_vector(rd.to_reg(), size, allocs);
-                let ri = pretty_print_vreg_vector(ri, size, allocs);
-                let rn = pretty_print_vreg_vector(rn, size, allocs);
-                format!("{} {}, {}, {}, #{}", op, rd, ri, rn, imm)
+                let rd = pretty_print_vreg_vector(rd.to_reg(), size);
+                let ri = pretty_print_vreg_vector(ri, size);
+                let rn = pretty_print_vreg_vector(rn, size);
+                format!("{op} {rd}, {ri}, {rn}, #{imm}")
             }
             &Inst::VecExtract { rd, rn, rm, imm4 } => {
-                let rd = pretty_print_vreg_vector(rd.to_reg(), VectorSize::Size8x16, allocs);
-                let rn = pretty_print_vreg_vector(rn, VectorSize::Size8x16, allocs);
-                let rm = pretty_print_vreg_vector(rm, VectorSize::Size8x16, allocs);
-                format!("ext {}, {}, {}, #{}", rd, rn, rm, imm4)
+                let rd = pretty_print_vreg_vector(rd.to_reg(), VectorSize::Size8x16);
+                let rn = pretty_print_vreg_vector(rn, VectorSize::Size8x16);
+                let rm = pretty_print_vreg_vector(rm, VectorSize::Size8x16);
+                format!("ext {rd}, {rn}, {rm}, #{imm4}")
             }
             &Inst::VecTbl { rd, rn, rm } => {
-                let rn = pretty_print_vreg_vector(rn, VectorSize::Size8x16, allocs);
-                let rm = pretty_print_vreg_vector(rm, VectorSize::Size8x16, allocs);
-                let rd = pretty_print_vreg_vector(rd.to_reg(), VectorSize::Size8x16, allocs);
-                format!("tbl {}, {{ {} }}, {}", rd, rn, rm)
+                let rn = pretty_print_vreg_vector(rn, VectorSize::Size8x16);
+                let rm = pretty_print_vreg_vector(rm, VectorSize::Size8x16);
+                let rd = pretty_print_vreg_vector(rd.to_reg(), VectorSize::Size8x16);
+                format!("tbl {rd}, {{ {rn} }}, {rm}")
             }
             &Inst::VecTblExt { rd, ri, rn, rm } => {
-                let rn = pretty_print_vreg_vector(rn, VectorSize::Size8x16, allocs);
-                let rm = pretty_print_vreg_vector(rm, VectorSize::Size8x16, allocs);
-                let rd = pretty_print_vreg_vector(rd.to_reg(), VectorSize::Size8x16, allocs);
-                let ri = pretty_print_vreg_vector(ri, VectorSize::Size8x16, allocs);
-                format!("tbx {}, {}, {{ {} }}, {}", rd, ri, rn, rm)
+                let rn = pretty_print_vreg_vector(rn, VectorSize::Size8x16);
+                let rm = pretty_print_vreg_vector(rm, VectorSize::Size8x16);
+                let rd = pretty_print_vreg_vector(rd.to_reg(), VectorSize::Size8x16);
+                let ri = pretty_print_vreg_vector(ri, VectorSize::Size8x16);
+                format!("tbx {rd}, {ri}, {{ {rn} }}, {rm}")
             }
             &Inst::VecTbl2 { rd, rn, rn2, rm } => {
-                let rn = pretty_print_vreg_vector(rn, VectorSize::Size8x16, allocs);
-                let rn2 = pretty_print_vreg_vector(rn2, VectorSize::Size8x16, allocs);
-                let rm = pretty_print_vreg_vector(rm, VectorSize::Size8x16, allocs);
-                let rd = pretty_print_vreg_vector(rd.to_reg(), VectorSize::Size8x16, allocs);
-                format!("tbl {}, {{ {}, {} }}, {}", rd, rn, rn2, rm)
+                let rn = pretty_print_vreg_vector(rn, VectorSize::Size8x16);
+                let rn2 = pretty_print_vreg_vector(rn2, VectorSize::Size8x16);
+                let rm = pretty_print_vreg_vector(rm, VectorSize::Size8x16);
+                let rd = pretty_print_vreg_vector(rd.to_reg(), VectorSize::Size8x16);
+                format!("tbl {rd}, {{ {rn}, {rn2} }}, {rm}")
             }
             &Inst::VecTbl2Ext {
                 rd,
@@ -2452,36 +2521,33 @@ impl Inst {
                 rn2,
                 rm,
             } => {
-                let rn = pretty_print_vreg_vector(rn, VectorSize::Size8x16, allocs);
-                let rn2 = pretty_print_vreg_vector(rn2, VectorSize::Size8x16, allocs);
-                let rm = pretty_print_vreg_vector(rm, VectorSize::Size8x16, allocs);
-                let rd = pretty_print_vreg_vector(rd.to_reg(), VectorSize::Size8x16, allocs);
-                let ri = pretty_print_vreg_vector(ri, VectorSize::Size8x16, allocs);
-                format!("tbx {}, {}, {{ {}, {} }}, {}", rd, ri, rn, rn2, rm)
+                let rn = pretty_print_vreg_vector(rn, VectorSize::Size8x16);
+                let rn2 = pretty_print_vreg_vector(rn2, VectorSize::Size8x16);
+                let rm = pretty_print_vreg_vector(rm, VectorSize::Size8x16);
+                let rd = pretty_print_vreg_vector(rd.to_reg(), VectorSize::Size8x16);
+                let ri = pretty_print_vreg_vector(ri, VectorSize::Size8x16);
+                format!("tbx {rd}, {ri}, {{ {rn}, {rn2} }}, {rm}")
             }
             &Inst::VecLoadReplicate { rd, rn, size, .. } => {
-                let rd = pretty_print_vreg_vector(rd.to_reg(), size, allocs);
-                let rn = pretty_print_reg(rn, allocs);
+                let rd = pretty_print_vreg_vector(rd.to_reg(), size);
+                let rn = pretty_print_reg(rn);
 
-                format!("ld1r {{ {} }}, [{}]", rd, rn)
+                format!("ld1r {{ {rd} }}, [{rn}]")
             }
             &Inst::VecCSel { rd, rn, rm, cond } => {
-                let rd = pretty_print_vreg_vector(rd.to_reg(), VectorSize::Size8x16, allocs);
-                let rn = pretty_print_vreg_vector(rn, VectorSize::Size8x16, allocs);
-                let rm = pretty_print_vreg_vector(rm, VectorSize::Size8x16, allocs);
-                let cond = cond.pretty_print(0, allocs);
-                format!(
-                    "vcsel {}, {}, {}, {} (if-then-else diamond)",
-                    rd, rn, rm, cond
-                )
+                let rd = pretty_print_vreg_vector(rd.to_reg(), VectorSize::Size8x16);
+                let rn = pretty_print_vreg_vector(rn, VectorSize::Size8x16);
+                let rm = pretty_print_vreg_vector(rm, VectorSize::Size8x16);
+                let cond = cond.pretty_print(0);
+                format!("vcsel {rd}, {rn}, {rm}, {cond} (if-then-else diamond)")
             }
             &Inst::MovToNZCV { rn } => {
-                let rn = pretty_print_reg(rn, allocs);
-                format!("msr nzcv, {}", rn)
+                let rn = pretty_print_reg(rn);
+                format!("msr nzcv, {rn}")
             }
             &Inst::MovFromNZCV { rd } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                format!("mrs {}, nzcv", rd)
+                let rd = pretty_print_reg(rd.to_reg());
+                format!("mrs {rd}, nzcv")
             }
             &Inst::Extend {
                 rd,
@@ -2490,9 +2556,9 @@ impl Inst {
                 from_bits: 1,
                 ..
             } => {
-                let rd = pretty_print_ireg(rd.to_reg(), OperandSize::Size32, allocs);
-                let rn = pretty_print_ireg(rn, OperandSize::Size32, allocs);
-                format!("and {}, {}, #1", rd, rn)
+                let rd = pretty_print_ireg(rd.to_reg(), OperandSize::Size32);
+                let rn = pretty_print_ireg(rn, OperandSize::Size32);
+                format!("and {rd}, {rn}, #1")
             }
             &Inst::Extend {
                 rd,
@@ -2504,9 +2570,9 @@ impl Inst {
                 // The case of a zero extension from 32 to 64 bits, is implemented
                 // with a "mov" to a 32-bit (W-reg) dest, because this zeroes
                 // the top 32 bits.
-                let rd = pretty_print_ireg(rd.to_reg(), OperandSize::Size32, allocs);
-                let rn = pretty_print_ireg(rn, OperandSize::Size32, allocs);
-                format!("mov {}, {}", rd, rn)
+                let rd = pretty_print_ireg(rd.to_reg(), OperandSize::Size32);
+                let rn = pretty_print_ireg(rn, OperandSize::Size32);
+                format!("mov {rd}, {rn}")
             }
             &Inst::Extend {
                 rd,
@@ -2527,49 +2593,49 @@ impl Inst {
                 };
                 if op == "sbfx" || op == "ubfx" {
                     let dest_size = OperandSize::from_bits(to_bits);
-                    let rd = pretty_print_ireg(rd.to_reg(), dest_size, allocs);
-                    let rn = pretty_print_ireg(rn, dest_size, allocs);
-                    format!("{} {}, {}, #0, #{}", op, rd, rn, from_bits)
+                    let rd = pretty_print_ireg(rd.to_reg(), dest_size);
+                    let rn = pretty_print_ireg(rn, dest_size);
+                    format!("{op} {rd}, {rn}, #0, #{from_bits}")
                 } else {
                     let dest_size = if signed {
                         OperandSize::from_bits(to_bits)
                     } else {
                         OperandSize::Size32
                     };
-                    let rd = pretty_print_ireg(rd.to_reg(), dest_size, allocs);
-                    let rn = pretty_print_ireg(rn, OperandSize::from_bits(from_bits), allocs);
-                    format!("{} {}, {}", op, rd, rn)
+                    let rd = pretty_print_ireg(rd.to_reg(), dest_size);
+                    let rn = pretty_print_ireg(rn, OperandSize::from_bits(from_bits));
+                    format!("{op} {rd}, {rn}")
                 }
             }
             &Inst::Call { .. } => format!("bl 0"),
             &Inst::CallInd { ref info, .. } => {
-                let rn = pretty_print_reg(info.rn, allocs);
-                format!("blr {}", rn)
+                let rn = pretty_print_reg(info.rn);
+                format!("blr {rn}")
             }
             &Inst::ReturnCall {
                 ref callee,
                 ref info,
             } => {
                 let mut s = format!(
-                    "return_call {callee:?} old_stack_arg_size:{} new_stack_arg_size:{}",
-                    info.old_stack_arg_size, info.new_stack_arg_size
+                    "return_call {callee:?} new_stack_arg_size:{}",
+                    info.new_stack_arg_size
                 );
                 for ret in &info.uses {
-                    let preg = pretty_print_reg(ret.preg, &mut empty_allocs);
-                    let vreg = pretty_print_reg(ret.vreg, allocs);
+                    let preg = pretty_print_reg(ret.preg);
+                    let vreg = pretty_print_reg(ret.vreg);
                     write!(&mut s, " {vreg}={preg}").unwrap();
                 }
                 s
             }
             &Inst::ReturnCallInd { callee, ref info } => {
-                let callee = pretty_print_reg(callee, allocs);
+                let callee = pretty_print_reg(callee);
                 let mut s = format!(
-                    "return_call_ind {callee} old_stack_arg_size:{} new_stack_arg_size:{}",
-                    info.old_stack_arg_size, info.new_stack_arg_size
+                    "return_call_ind {callee} new_stack_arg_size:{}",
+                    info.new_stack_arg_size
                 );
                 for ret in &info.uses {
-                    let preg = pretty_print_reg(ret.preg, &mut empty_allocs);
-                    let vreg = pretty_print_reg(ret.vreg, allocs);
+                    let preg = pretty_print_reg(ret.preg);
+                    let vreg = pretty_print_reg(ret.vreg);
                     write!(&mut s, " {vreg}={preg}").unwrap();
                 }
                 s
@@ -2577,17 +2643,17 @@ impl Inst {
             &Inst::Args { ref args } => {
                 let mut s = "args".to_string();
                 for arg in args {
-                    let preg = pretty_print_reg(arg.preg, &mut empty_allocs);
-                    let def = pretty_print_reg(arg.vreg.to_reg(), allocs);
-                    write!(&mut s, " {}={}", def, preg).unwrap();
+                    let preg = pretty_print_reg(arg.preg);
+                    let def = pretty_print_reg(arg.vreg.to_reg());
+                    write!(&mut s, " {def}={preg}").unwrap();
                 }
                 s
             }
             &Inst::Rets { ref rets } => {
                 let mut s = "rets".to_string();
                 for ret in rets {
-                    let preg = pretty_print_reg(ret.preg, &mut empty_allocs);
-                    let vreg = pretty_print_reg(ret.vreg, allocs);
+                    let preg = pretty_print_reg(ret.preg);
+                    let vreg = pretty_print_reg(ret.vreg);
                     write!(&mut s, " {vreg}={preg}").unwrap();
                 }
                 s
@@ -2606,34 +2672,50 @@ impl Inst {
                 }
             }
             &Inst::Jump { ref dest } => {
-                let dest = dest.pretty_print(0, allocs);
-                format!("b {}", dest)
+                let dest = dest.pretty_print(0);
+                format!("b {dest}")
             }
             &Inst::CondBr {
                 ref taken,
                 ref not_taken,
                 ref kind,
             } => {
-                let taken = taken.pretty_print(0, allocs);
-                let not_taken = not_taken.pretty_print(0, allocs);
+                let taken = taken.pretty_print(0);
+                let not_taken = not_taken.pretty_print(0);
                 match kind {
                     &CondBrKind::Zero(reg) => {
-                        let reg = pretty_print_reg(reg, allocs);
-                        format!("cbz {}, {} ; b {}", reg, taken, not_taken)
+                        let reg = pretty_print_reg(reg);
+                        format!("cbz {reg}, {taken} ; b {not_taken}")
                     }
                     &CondBrKind::NotZero(reg) => {
-                        let reg = pretty_print_reg(reg, allocs);
-                        format!("cbnz {}, {} ; b {}", reg, taken, not_taken)
+                        let reg = pretty_print_reg(reg);
+                        format!("cbnz {reg}, {taken} ; b {not_taken}")
                     }
                     &CondBrKind::Cond(c) => {
-                        let c = c.pretty_print(0, allocs);
-                        format!("b.{} {} ; b {}", c, taken, not_taken)
+                        let c = c.pretty_print(0);
+                        format!("b.{c} {taken} ; b {not_taken}")
                     }
                 }
             }
+            &Inst::TestBitAndBranch {
+                kind,
+                ref taken,
+                ref not_taken,
+                rn,
+                bit,
+            } => {
+                let cond = match kind {
+                    TestBitAndBranchKind::Z => "z",
+                    TestBitAndBranchKind::NZ => "nz",
+                };
+                let taken = taken.pretty_print(0);
+                let not_taken = not_taken.pretty_print(0);
+                let rn = pretty_print_reg(rn);
+                format!("tb{cond} {rn}, #{bit}, {taken} ; b {not_taken}")
+            }
             &Inst::IndirectBr { rn, .. } => {
-                let rn = pretty_print_reg(rn, allocs);
-                format!("br {}", rn)
+                let rn = pretty_print_reg(rn);
+                format!("br {rn}")
             }
             &Inst::Brk => "brk #0".to_string(),
             &Inst::Udf { .. } => "udf #0xc11f".to_string(),
@@ -2642,30 +2724,30 @@ impl Inst {
                 trap_code,
             } => match kind {
                 &CondBrKind::Zero(reg) => {
-                    let reg = pretty_print_reg(reg, allocs);
+                    let reg = pretty_print_reg(reg);
                     format!("cbz {reg}, #trap={trap_code}")
                 }
                 &CondBrKind::NotZero(reg) => {
-                    let reg = pretty_print_reg(reg, allocs);
+                    let reg = pretty_print_reg(reg);
                     format!("cbnz {reg}, #trap={trap_code}")
                 }
                 &CondBrKind::Cond(c) => {
-                    let c = c.pretty_print(0, allocs);
+                    let c = c.pretty_print(0);
                     format!("b.{c} #trap={trap_code}")
                 }
             },
             &Inst::Adr { rd, off } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                format!("adr {}, pc+{}", rd, off)
+                let rd = pretty_print_reg(rd.to_reg());
+                format!("adr {rd}, pc+{off}")
             }
             &Inst::Adrp { rd, off } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
+                let rd = pretty_print_reg(rd.to_reg());
                 // This instruction addresses 4KiB pages, so multiply it by the page size.
                 let byte_offset = off * 4096;
-                format!("adrp {}, pc+{}", rd, byte_offset)
+                format!("adrp {rd}, pc+{byte_offset}")
             }
-            &Inst::Word4 { data } => format!("data.i32 {}", data),
-            &Inst::Word8 { data } => format!("data.i64 {}", data),
+            &Inst::Word4 { data } => format!("data.i32 {data}"),
+            &Inst::Word8 { data } => format!("data.i64 {data}"),
             &Inst::JTSequence {
                 default,
                 ref targets,
@@ -2674,10 +2756,10 @@ impl Inst {
                 rtmp2,
                 ..
             } => {
-                let ridx = pretty_print_reg(ridx, allocs);
-                let rtmp1 = pretty_print_reg(rtmp1.to_reg(), allocs);
-                let rtmp2 = pretty_print_reg(rtmp2.to_reg(), allocs);
-                let default_target = BranchTarget::Label(default).pretty_print(0, allocs);
+                let ridx = pretty_print_reg(ridx);
+                let rtmp1 = pretty_print_reg(rtmp1.to_reg());
+                let rtmp2 = pretty_print_reg(rtmp2.to_reg());
+                let default_target = BranchTarget::Label(default).pretty_print(0);
                 format!(
                     concat!(
                         "b.hs {} ; ",
@@ -2708,7 +2790,7 @@ impl Inst {
                 ref name,
                 offset,
             } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
+                let rd = pretty_print_reg(rd.to_reg());
                 format!("load_ext_name {rd}, {name:?}+{offset}")
             }
             &Inst::LoadAddr { rd, ref mem } => {
@@ -2716,20 +2798,17 @@ impl Inst {
                 // this logic between `emit()` and `show_rru()` -- a separate 1-to-N
                 // expansion stage (i.e., legalization, but without the slow edit-in-place
                 // of the existing legalization framework).
-                let rd = allocs.next_writable(rd);
-                let mem = mem.with_allocs(allocs);
-                let (mem_insts, mem) = mem_finalize(None, &mem, state);
+                let mem = mem.clone();
+                let (mem_insts, mem) = mem_finalize(None, &mem, I8, state);
                 let mut ret = String::new();
                 for inst in mem_insts.into_iter() {
-                    ret.push_str(
-                        &inst.print_with_state(&mut EmitState::default(), &mut empty_allocs),
-                    );
+                    ret.push_str(&inst.print_with_state(&mut EmitState::default()));
                 }
                 let (reg, index_reg, offset) = match mem {
                     AMode::RegExtended { rn, rm, extendop } => (rn, Some((rm, extendop)), 0),
                     AMode::Unscaled { rn, simm9 } => (rn, None, simm9.value()),
                     AMode::UnsignedOffset { rn, uimm12 } => (rn, None, uimm12.value() as i32),
-                    _ => panic!("Unsupported case for LoadAddr: {:?}", mem),
+                    _ => panic!("Unsupported case for LoadAddr: {mem:?}"),
                 };
                 let abs_offset = if offset < 0 {
                     -offset as u64
@@ -2748,14 +2827,10 @@ impl Inst {
                         extendop,
                     };
 
-                    ret.push_str(
-                        &add.print_with_state(&mut EmitState::default(), &mut empty_allocs),
-                    );
+                    ret.push_str(&add.print_with_state(&mut EmitState::default()));
                 } else if offset == 0 {
                     let mov = Inst::gen_move(rd, reg, I64);
-                    ret.push_str(
-                        &mov.print_with_state(&mut EmitState::default(), &mut empty_allocs),
-                    );
+                    ret.push_str(&mov.print_with_state(&mut EmitState::default()));
                 } else if let Some(imm12) = Imm12::maybe_from_u64(abs_offset) {
                     let add = Inst::AluRRImm12 {
                         alu_op,
@@ -2764,15 +2839,11 @@ impl Inst {
                         rn: reg,
                         imm12,
                     };
-                    ret.push_str(
-                        &add.print_with_state(&mut EmitState::default(), &mut empty_allocs),
-                    );
+                    ret.push_str(&add.print_with_state(&mut EmitState::default()));
                 } else {
                     let tmp = writable_spilltmp_reg();
                     for inst in Inst::load_constant(tmp, abs_offset, &mut |_| tmp).into_iter() {
-                        ret.push_str(
-                            &inst.print_with_state(&mut EmitState::default(), &mut empty_allocs),
-                        );
+                        ret.push_str(&inst.print_with_state(&mut EmitState::default()));
                     }
                     let add = Inst::AluRRR {
                         alu_op,
@@ -2781,9 +2852,7 @@ impl Inst {
                         rn: reg,
                         rm: tmp.to_reg(),
                     };
-                    ret.push_str(
-                        &add.print_with_state(&mut EmitState::default(), &mut empty_allocs),
-                    );
+                    ret.push_str(&add.print_with_state(&mut EmitState::default()));
                 }
                 ret
             }
@@ -2808,31 +2877,32 @@ impl Inst {
 
                 "bti".to_string() + targets
             }
-            &Inst::VirtualSPOffsetAdj { offset } => {
-                state.virtual_sp_offset += offset;
-                format!("virtual_sp_offset_adjust {}", offset)
-            }
-            &Inst::EmitIsland { needed_space } => format!("emit_island {}", needed_space),
+            &Inst::EmitIsland { needed_space } => format!("emit_island {needed_space}"),
 
-            &Inst::ElfTlsGetAddr { ref symbol, rd } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                format!("elf_tls_get_addr {}, {}", rd, symbol.display(None))
+            &Inst::ElfTlsGetAddr {
+                ref symbol,
+                rd,
+                tmp,
+            } => {
+                let rd = pretty_print_reg(rd.to_reg());
+                let tmp = pretty_print_reg(tmp.to_reg());
+                format!("elf_tls_get_addr {}, {}, {}", rd, tmp, symbol.display(None))
             }
             &Inst::MachOTlsGetAddr { ref symbol, rd } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
+                let rd = pretty_print_reg(rd.to_reg());
                 format!("macho_tls_get_addr {}, {}", rd, symbol.display(None))
             }
             &Inst::Unwind { ref inst } => {
-                format!("unwind {:?}", inst)
+                format!("unwind {inst:?}")
             }
             &Inst::DummyUse { reg } => {
-                let reg = pretty_print_reg(reg, allocs);
-                format!("dummy_use {}", reg)
+                let reg = pretty_print_reg(reg);
+                format!("dummy_use {reg}")
             }
             &Inst::StackProbeLoop { start, end, step } => {
-                let start = pretty_print_reg(start.to_reg(), allocs);
-                let end = pretty_print_reg(end, allocs);
-                let step = step.pretty_print(0, allocs);
+                let start = pretty_print_reg(start.to_reg());
+                let end = pretty_print_reg(end);
+                let step = step.pretty_print(0);
                 format!("stack_probe_loop {start}, {end}, {step}")
             }
         }
@@ -2845,6 +2915,9 @@ impl Inst {
 /// Different forms of label references for different instruction formats.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum LabelUse {
+    /// 14-bit branch offset (conditional branches). PC-rel, offset is imm <<
+    /// 2. Immediate is 14 signed bits, in bits 18:5. Used by tbz and tbnz.
+    Branch14,
     /// 19-bit branch offset (conditional branches). PC-rel, offset is imm << 2. Immediate is 19
     /// signed bits, in bits 23:5. Used by cbz, cbnz, b.cond.
     Branch19,
@@ -2871,8 +2944,10 @@ impl MachInstLabelUse for LabelUse {
     /// Maximum PC-relative range (positive), inclusive.
     fn max_pos_range(self) -> CodeOffset {
         match self {
-            // 19-bit immediate, left-shifted by 2, for 21 bits of total range. Signed, so +2^20
-            // from zero. Likewise for two other shifted cases below.
+            // N-bit immediate, left-shifted by 2, for (N+2) bits of total
+            // range. Signed, so +2^(N+1) from zero. Likewise for two other
+            // shifted cases below.
+            LabelUse::Branch14 => (1 << 15) - 1,
             LabelUse::Branch19 => (1 << 20) - 1,
             LabelUse::Branch26 => (1 << 27) - 1,
             LabelUse::Ldr19 => (1 << 20) - 1,
@@ -2904,6 +2979,7 @@ impl MachInstLabelUse for LabelUse {
         let pc_rel = pc_rel as u32;
         let insn_word = u32::from_le_bytes([buffer[0], buffer[1], buffer[2], buffer[3]]);
         let mask = match self {
+            LabelUse::Branch14 => 0x0007ffe0, // bits 18..5 inclusive
             LabelUse::Branch19 => 0x00ffffe0, // bits 23..5 inclusive
             LabelUse::Branch26 => 0x03ffffff, // bits 25..0 inclusive
             LabelUse::Ldr19 => 0x00ffffe0,    // bits 23..5 inclusive
@@ -2918,6 +2994,7 @@ impl MachInstLabelUse for LabelUse {
             }
         };
         let pc_rel_inserted = match self {
+            LabelUse::Branch14 => (pc_rel_shifted & 0x3fff) << 5,
             LabelUse::Branch19 | LabelUse::Ldr19 => (pc_rel_shifted & 0x7ffff) << 5,
             LabelUse::Branch26 => pc_rel_shifted & 0x3ffffff,
             LabelUse::Adr21 => (pc_rel_shifted & 0x7ffff) << 5 | (pc_rel_shifted & 0x180000) << 10,
@@ -2938,8 +3015,8 @@ impl MachInstLabelUse for LabelUse {
     /// Is a veneer supported for this label reference type?
     fn supports_veneer(self) -> bool {
         match self {
-            LabelUse::Branch19 => true, // veneer is a Branch26
-            LabelUse::Branch26 => true, // veneer is a PCRel32
+            LabelUse::Branch14 | LabelUse::Branch19 => true, // veneer is a Branch26
+            LabelUse::Branch26 => true,                      // veneer is a PCRel32
             _ => false,
         }
     }
@@ -2947,7 +3024,7 @@ impl MachInstLabelUse for LabelUse {
     /// How large is the veneer, if supported?
     fn veneer_size(self) -> CodeOffset {
         match self {
-            LabelUse::Branch19 => 4,
+            LabelUse::Branch14 | LabelUse::Branch19 => 4,
             LabelUse::Branch26 => 20,
             _ => unreachable!(),
         }
@@ -2965,7 +3042,7 @@ impl MachInstLabelUse for LabelUse {
         veneer_offset: CodeOffset,
     ) -> (CodeOffset, LabelUse) {
         match self {
-            LabelUse::Branch19 => {
+            LabelUse::Branch14 | LabelUse::Branch19 => {
                 // veneer is a Branch26 (unconditional branch). Just encode directly here -- don't
                 // bother with constructing an Inst.
                 let insn_word = 0b000101 << 26;
diff --git a/cranelift/codegen/src/isa/aarch64/inst/regs.rs b/cranelift/codegen/src/isa/aarch64/inst/regs.rs
index 79fdd5cc1d9f..6a0fc0971ac2 100644
--- a/cranelift/codegen/src/isa/aarch64/inst/regs.rs
+++ b/cranelift/codegen/src/isa/aarch64/inst/regs.rs
@@ -3,7 +3,6 @@
 use crate::isa::aarch64::inst::OperandSize;
 use crate::isa::aarch64::inst::ScalarSize;
 use crate::isa::aarch64::inst::VectorSize;
-use crate::machinst::AllocationConsumer;
 use crate::machinst::RealReg;
 use crate::machinst::{Reg, RegClass, Writable};
 use regalloc2::PReg;
@@ -48,7 +47,6 @@ pub(crate) const fn vreg_preg(num: u8) -> PReg {
 }
 
 /// Get a writable reference to a V-register.
-#[cfg(test)] // Used only in test code.
 pub fn writable_vreg(num: u8) -> Writable<Reg> {
     Writable::from_reg(vreg(num))
 }
@@ -155,7 +153,7 @@ fn show_ireg(reg: RealReg) -> String {
         63 => "sp".to_string(),
         x => {
             debug_assert!(x < 29);
-            format!("x{}", x)
+            format!("x{x}")
         }
     }
 }
@@ -172,12 +170,11 @@ fn show_reg(reg: Reg) -> String {
             RegClass::Vector => unreachable!(),
         }
     } else {
-        format!("%{:?}", reg)
+        format!("%{reg:?}")
     }
 }
 
-pub fn pretty_print_reg(reg: Reg, allocs: &mut AllocationConsumer<'_>) -> String {
-    let reg = allocs.next(reg);
+pub fn pretty_print_reg(reg: Reg) -> String {
     show_reg(reg)
 }
 
@@ -249,44 +246,23 @@ pub fn show_vreg_element(reg: Reg, idx: u8, size: ScalarSize) -> String {
         ScalarSize::Size16 => ".h",
         ScalarSize::Size32 => ".s",
         ScalarSize::Size64 => ".d",
-        _ => panic!("Unexpected vector element size: {:?}", size),
+        _ => panic!("Unexpected vector element size: {size:?}"),
     };
-    format!("{}{}[{}]", s, suffix, idx)
+    format!("{s}{suffix}[{idx}]")
 }
 
-pub fn pretty_print_ireg(
-    reg: Reg,
-    size: OperandSize,
-    allocs: &mut AllocationConsumer<'_>,
-) -> String {
-    let reg = allocs.next(reg);
+pub fn pretty_print_ireg(reg: Reg, size: OperandSize) -> String {
     show_ireg_sized(reg, size)
 }
 
-pub fn pretty_print_vreg_scalar(
-    reg: Reg,
-    size: ScalarSize,
-    allocs: &mut AllocationConsumer<'_>,
-) -> String {
-    let reg = allocs.next(reg);
+pub fn pretty_print_vreg_scalar(reg: Reg, size: ScalarSize) -> String {
     show_vreg_scalar(reg, size)
 }
 
-pub fn pretty_print_vreg_vector(
-    reg: Reg,
-    size: VectorSize,
-    allocs: &mut AllocationConsumer<'_>,
-) -> String {
-    let reg = allocs.next(reg);
+pub fn pretty_print_vreg_vector(reg: Reg, size: VectorSize) -> String {
     show_vreg_vector(reg, size)
 }
 
-pub fn pretty_print_vreg_element(
-    reg: Reg,
-    idx: usize,
-    size: ScalarSize,
-    allocs: &mut AllocationConsumer<'_>,
-) -> String {
-    let reg = allocs.next(reg);
+pub fn pretty_print_vreg_element(reg: Reg, idx: usize, size: ScalarSize) -> String {
     show_vreg_element(reg, idx as u8, size)
 }
diff --git a/cranelift/codegen/src/isa/aarch64/inst/unwind/systemv.rs b/cranelift/codegen/src/isa/aarch64/inst/unwind/systemv.rs
index a40e49e3dca1..2d7bb02202e0 100644
--- a/cranelift/codegen/src/isa/aarch64/inst/unwind/systemv.rs
+++ b/cranelift/codegen/src/isa/aarch64/inst/unwind/systemv.rs
@@ -53,9 +53,6 @@ impl crate::isa::unwind::systemv::RegisterMapper<Reg> for RegisterMapper {
     fn map(&self, reg: Reg) -> Result<u16, RegisterMappingError> {
         Ok(map_reg(reg)?.0)
     }
-    fn sp(&self) -> u16 {
-        (regs::stack_reg().to_real_reg().unwrap().hw_enc() & 31).into()
-    }
     fn fp(&self) -> Option<u16> {
         Some(regs::fp_reg().to_real_reg().unwrap().hw_enc().into())
     }
@@ -77,7 +74,6 @@ mod tests {
     use crate::settings::{builder, Flags};
     use crate::Context;
     use gimli::write::Address;
-    use std::str::FromStr;
     use target_lexicon::triple;
 
     #[test]
@@ -89,7 +85,7 @@ mod tests {
 
         let mut context = Context::for_function(create_function(
             CallConv::SystemV,
-            Some(StackSlotData::new(StackSlotKind::ExplicitSlot, 64)),
+            Some(StackSlotData::new(StackSlotKind::ExplicitSlot, 64, 0)),
         ));
 
         let code = context
@@ -106,7 +102,7 @@ mod tests {
             _ => panic!("expected unwind information"),
         };
 
-        assert_eq!(format!("{:?}", fde), "FrameDescriptionEntry { address: Constant(1234), length: 24, lsda: None, instructions: [(4, CfaOffset(16)), (4, Offset(Register(29), -16)), (4, Offset(Register(30), -8)), (8, CfaRegister(Register(29)))] }");
+        assert_eq!(format!("{fde:?}"), "FrameDescriptionEntry { address: Constant(1234), length: 24, lsda: None, instructions: [(4, CfaOffset(16)), (4, Offset(Register(29), -16)), (4, Offset(Register(30), -8)), (8, CfaRegister(Register(29)))] }");
     }
 
     fn create_function(call_conv: CallConv, stack_slot: Option<StackSlotData>) -> Function {
@@ -148,7 +144,7 @@ mod tests {
         };
 
         assert_eq!(
-            format!("{:?}", fde),
+            format!("{fde:?}"),
             "FrameDescriptionEntry { address: Constant(4321), length: 16, lsda: None, instructions: [] }"
         );
     }
diff --git a/cranelift/codegen/src/isa/aarch64/lower.isle b/cranelift/codegen/src/isa/aarch64/lower.isle
index bc548ce8f18b..6bcf9d8b28be 100644
--- a/cranelift/codegen/src/isa/aarch64/lower.isle
+++ b/cranelift/codegen/src/isa/aarch64/lower.isle
@@ -2,7 +2,48 @@
 
 ;; The main lowering constructor term: takes a clif `Inst` and returns the
 ;; register(s) within which the lowered instruction's result values live.
+; QUESTION(mbm): can we capture the "equality on lower bits only" constraint in the lower spec?
 (decl partial lower (Inst) InstOutput)
+(spec (lower arg)
+      (match true)
+      (provide
+            ; On successful execution, computation results match.
+            (if (not clif_trap)
+                  ; Results agree.
+                  (= result arg)
+                  ; If we expect a CLIF trap, it should happen in execution
+                  ; also.
+                  exec_trap
+            )
+
+            ; Should trap on both sides, or neither.
+            (= clif_trap exec_trap)
+
+            ; Load effects
+
+            ; Either both active, or both not.
+            (= (:active clif_load) (:active isa_load))
+
+            ; If active, their parameters must match.
+            (=> (:active clif_load) (= clif_load isa_load))
+
+            ; Store effects
+
+            ; Either both active, or both not.
+            (= (:active clif_store) (:active isa_store))
+            ; If active, their parameters must agree.
+            (=> (:active clif_store)
+                  (and
+                        (= (:size_bits clif_store) (:size_bits isa_store))
+                        (= (:addr clif_store) (:addr isa_store))
+                        (=
+                              (conv_to (:size_bits clif_store) (:value clif_store))
+                              (conv_to (:size_bits clif_store) (:value isa_store))
+                        )
+                  )
+            )
+      )
+)
 
 ;; Variant of the main lowering constructor term, which receives an
 ;; additional argument (a vector of branch targets to be used) for
@@ -16,24 +57,31 @@
 
 ;;;; Rules for `iconst` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type ty (iconst (u64_from_imm64 n))))
+(rule iconst (lower (has_type ty (iconst _ (u64_from_imm64 n))))
       (imm ty (ImmExtend.Zero) n))
 
-;;;; Rules for `null` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;; Rules for `f16const` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type ty (null)))
-      (imm ty (ImmExtend.Zero) 0))
+(rule (lower (f16const _ (u16_from_ieee16 n)))
+      (constant_f16 n))
 
 ;;;; Rules for `f32const` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (f32const (u32_from_ieee32 n)))
+(rule f32const
+      (lower (f32const _ (u32_from_ieee32 n)))
       (constant_f32 n))
 
 ;;;; Rules for `f64const` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (f64const (u64_from_ieee64 n)))
+(rule f64const
+      (lower (f64const _ (u64_from_ieee64 n)))
       (constant_f64 n))
 
+;;;; Rules for `f128const` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(rule (lower (has_type $F128 (f128const _ (u128_from_constant n))))
+      (constant_f128 n))
+
 ;;;; Rules for `nop` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (rule (lower (nop))
@@ -44,64 +92,64 @@
 ;; `i64` and smaller
 
 ;; Base case, simply adding things in registers.
-(rule -1 (lower (has_type (fits_in_64 ty) (iadd x y)))
+(rule iadd_base_case -1 (lower (has_type (fits_in_64 ty) (iadd _ x y)))
       (add ty  x y))
 
 ;; Special cases for when one operand is an immediate that fits in 12 bits.
-(rule 4 (lower (has_type (fits_in_64 ty) (iadd x (imm12_from_value y))))
+(rule iadd_imm12_right 4 (lower (has_type (fits_in_64 ty) (iadd _ x (imm12_from_value y))))
       (add_imm ty x y))
 
-(rule 5 (lower (has_type (fits_in_64 ty) (iadd (imm12_from_value x) y)))
+(rule iadd_imm12_left 5 (lower (has_type (fits_in_64 ty) (iadd _ (imm12_from_value x) y)))
       (add_imm ty y x))
 
 ;; Same as the previous special cases, except we can switch the addition to a
 ;; subtraction if the negated immediate fits in 12 bits.
-(rule 2 (lower (has_type (fits_in_64 ty) (iadd x y)))
+(rule iadd_imm12_neg_right 2 (lower (has_type (fits_in_64 ty) (iadd _ x y)))
       (if-let imm12_neg (imm12_from_negated_value y))
       (sub_imm ty x imm12_neg))
 
-(rule 3 (lower (has_type (fits_in_64 ty) (iadd x y)))
+(rule iadd_imm12_neg_left 3 (lower (has_type (fits_in_64 ty) (iadd _ x y)))
       (if-let imm12_neg (imm12_from_negated_value x))
       (sub_imm ty y imm12_neg))
 
 ;; Special cases for when we're adding an extended register where the extending
 ;; operation can get folded into the add itself.
-(rule 0 (lower (has_type (fits_in_64 ty) (iadd x (extended_value_from_value y))))
+(rule iadd_extend_right 0 (lower (has_type (fits_in_64 ty) (iadd _ x (extended_value_from_value y))))
       (add_extend ty x y))
 
-(rule 1 (lower (has_type (fits_in_64 ty) (iadd (extended_value_from_value x) y)))
+(rule iadd_extend_left 1 (lower (has_type (fits_in_64 ty) (iadd _ (extended_value_from_value x) y)))
       (add_extend ty y x))
 
 ;; Special cases for when we're adding the shift of a different
 ;; register by a constant amount and the shift can get folded into the add.
-(rule 7 (lower (has_type (fits_in_64 ty)
-                       (iadd x (ishl y (iconst k)))))
+(rule iadd_ishl_right 7 (lower (has_type (fits_in_64 ty)
+                       (iadd _ x (ishl _ y (iconst _ k)))))
       (if-let amt (lshl_from_imm64 ty k))
       (add_shift ty x y amt))
 
-(rule 6 (lower (has_type (fits_in_64 ty)
-                       (iadd (ishl x (iconst k)) y)))
+(rule iadd_ishl_left 6 (lower (has_type (fits_in_64 ty)
+                       (iadd _ (ishl _ x (iconst _ k)) y)))
       (if-let amt (lshl_from_imm64 ty k))
       (add_shift ty y x amt))
 
 ;; Fold an `iadd` and `imul` combination into a `madd` instruction.
-(rule 7 (lower (has_type (fits_in_64 ty) (iadd x (imul y z))))
+(rule iadd_imul_right 7 (lower (has_type (fits_in_64 ty) (iadd _ x (imul _ y z))))
       (madd ty y z x))
 
-(rule 6 (lower (has_type (fits_in_64 ty) (iadd (imul x y) z)))
+(rule iadd_imul_left 6 (lower (has_type (fits_in_64 ty) (iadd _ (imul _ x y) z)))
       (madd ty x y z))
 
 ;; Fold an `isub` and `imul` combination into a `msub` instruction.
-(rule (lower (has_type (fits_in_64 ty) (isub x (imul y z))))
+(rule isub_imul (lower (has_type (fits_in_64 ty) (isub _ x (imul _ y z))))
       (msub ty y z x))
 
 ;; vectors
 
-(rule -2 (lower (has_type ty @ (multi_lane _ _) (iadd x y)))
+(rule -2 (lower (has_type ty @ (multi_lane _ _) (iadd _ x y)))
       (add_vec x y (vector_size ty)))
 
 ;; `i128`
-(rule -3 (lower (has_type $I128 (iadd x y)))
+(rule iadd_i128 -3 (lower (has_type $I128 (iadd _ x y)))
       (let
           ;; Get the high/low registers for `x`.
           ((x_regs ValueRegs x)
@@ -117,6 +165,7 @@
         (with_flags
           (add_with_flags_paired $I64 x_lo y_lo)
           (adc_paired $I64 x_hi y_hi))))
+(attr rule iadd_i128 (tag i128))
 
 ;;;; Rules for `shuffle` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
@@ -124,13 +173,13 @@
 ;; lanes then the `dup` instruction can be used for this operation. Note that
 ;; for now this only matches lane selection from the first vector `a`, but
 ;; if necessary in the future rules can be added to select from `b` as well.
-(rule 6 (lower (shuffle a b (shuffle_dup8_from_imm n)))
+(rule 6 (lower (shuffle _ a b (shuffle_dup8_from_imm n)))
         (vec_dup_from_fpu a (VectorSize.Size8x16) n))
-(rule 5 (lower (shuffle a b (shuffle_dup16_from_imm n)))
+(rule 5 (lower (shuffle _ a b (shuffle_dup16_from_imm n)))
         (vec_dup_from_fpu a (VectorSize.Size16x8) n))
-(rule 4 (lower (shuffle a b (shuffle_dup32_from_imm n)))
+(rule 4 (lower (shuffle _ a b (shuffle_dup32_from_imm n)))
         (vec_dup_from_fpu a (VectorSize.Size32x4) n))
-(rule 3 (lower (shuffle a b (shuffle_dup64_from_imm n)))
+(rule 3 (lower (shuffle _ a b (shuffle_dup64_from_imm n)))
         (vec_dup_from_fpu a (VectorSize.Size64x2) n))
 
 ;; If the `Immediate` specified to the extractor looks like a duplication of the
@@ -149,7 +198,7 @@
 
 ;; When the shuffle looks like "concatenate `a` and `b` and shift right by n*8
 ;; bytes", that's an `ext` instruction.
-(rule 2 (lower (shuffle a b (vec_extract_imm4_from_immediate n)))
+(rule 2 (lower (shuffle _ a b (vec_extract_imm4_from_immediate n)))
         (vec_extract a b n))
 
 ;; Attempts to extract `n` from the specified shuffle `Immediate` where each
@@ -162,36 +211,36 @@
 
 ;; Rules for the `uzp1` and `uzp2` instructions which gather even-numbered lanes
 ;; or odd-numbered lanes
-(rule 1 (lower (shuffle a b (u128_from_immediate 0x1e1c_1a18_1614_1210_0e0c_0a08_0604_0200)))
+(rule 1 (lower (shuffle _ a b (u128_from_immediate 0x1e1c_1a18_1614_1210_0e0c_0a08_0604_0200)))
       (vec_uzp1 a b (VectorSize.Size8x16)))
-(rule 1 (lower (shuffle a b (u128_from_immediate 0x1f1d_1b19_1715_1311_0f0d_0b09_0705_0301)))
+(rule 1 (lower (shuffle _ a b (u128_from_immediate 0x1f1d_1b19_1715_1311_0f0d_0b09_0705_0301)))
       (vec_uzp2 a b (VectorSize.Size8x16)))
-(rule 1 (lower (shuffle a b (u128_from_immediate 0x1d1c_1918_1514_1110_0d0c_0908_0504_0100)))
+(rule 1 (lower (shuffle _ a b (u128_from_immediate 0x1d1c_1918_1514_1110_0d0c_0908_0504_0100)))
       (vec_uzp1 a b (VectorSize.Size16x8)))
-(rule 1 (lower (shuffle a b (u128_from_immediate 0x1f1e_1b1a_1716_1312_0f0e_0b0a_0706_0302)))
+(rule 1 (lower (shuffle _ a b (u128_from_immediate 0x1f1e_1b1a_1716_1312_0f0e_0b0a_0706_0302)))
       (vec_uzp2 a b (VectorSize.Size16x8)))
-(rule 1 (lower (shuffle a b (u128_from_immediate 0x1b1a1918_13121110_0b0a0908_03020100)))
+(rule 1 (lower (shuffle _ a b (u128_from_immediate 0x1b1a1918_13121110_0b0a0908_03020100)))
       (vec_uzp1 a b (VectorSize.Size32x4)))
-(rule 1 (lower (shuffle a b (u128_from_immediate 0x1f1e1d1c_17161514_0f0e0d0c_07060504)))
+(rule 1 (lower (shuffle _ a b (u128_from_immediate 0x1f1e1d1c_17161514_0f0e0d0c_07060504)))
       (vec_uzp2 a b (VectorSize.Size32x4)))
-(rule 1 (lower (shuffle a b (u128_from_immediate 0x1716151413121110_0706050403020100)))
+(rule 1 (lower (shuffle _ a b (u128_from_immediate 0x1716151413121110_0706050403020100)))
       (vec_uzp1 a b (VectorSize.Size64x2)))
-(rule 1 (lower (shuffle a b (u128_from_immediate 0x1f1e1d1c1b1a1918_0f0e0d0c0b0a0908)))
+(rule 1 (lower (shuffle _ a b (u128_from_immediate 0x1f1e1d1c1b1a1918_0f0e0d0c0b0a0908)))
       (vec_uzp2 a b (VectorSize.Size64x2)))
 
 ;; Rules for the `zip1` and `zip2` instructions which interleave lanes in the
 ;; low or high halves of the two input vectors.
-(rule 1 (lower (shuffle a b (u128_from_immediate 0x1707_1606_1505_1404_1303_1202_1101_1000)))
+(rule 1 (lower (shuffle _ a b (u128_from_immediate 0x1707_1606_1505_1404_1303_1202_1101_1000)))
       (vec_zip1 a b (VectorSize.Size8x16)))
-(rule 1 (lower (shuffle a b (u128_from_immediate 0x1f0f_1e0e_1d0d_1c0c_1b0b_1a0a_1909_1808)))
+(rule 1 (lower (shuffle _ a b (u128_from_immediate 0x1f0f_1e0e_1d0d_1c0c_1b0b_1a0a_1909_1808)))
       (vec_zip2 a b (VectorSize.Size8x16)))
-(rule 1 (lower (shuffle a b (u128_from_immediate 0x1716_0706_1514_0504_1312_0302_1110_0100)))
+(rule 1 (lower (shuffle _ a b (u128_from_immediate 0x1716_0706_1514_0504_1312_0302_1110_0100)))
       (vec_zip1 a b (VectorSize.Size16x8)))
-(rule 1 (lower (shuffle a b (u128_from_immediate 0x1f1e_0f0e_1d1c_0d0c_1b1a_0b0a_1918_0908)))
+(rule 1 (lower (shuffle _ a b (u128_from_immediate 0x1f1e_0f0e_1d1c_0d0c_1b1a_0b0a_1918_0908)))
       (vec_zip2 a b (VectorSize.Size16x8)))
-(rule 1 (lower (shuffle a b (u128_from_immediate 0x17161514_07060504_13121110_03020100)))
+(rule 1 (lower (shuffle _ a b (u128_from_immediate 0x17161514_07060504_13121110_03020100)))
       (vec_zip1 a b (VectorSize.Size32x4)))
-(rule 1 (lower (shuffle a b (u128_from_immediate 0x1f1e1d1c_0f0e0d0c_1b1a1918_0b0a0908)))
+(rule 1 (lower (shuffle _ a b (u128_from_immediate 0x1f1e1d1c_0f0e0d0c_1b1a1918_0b0a0908)))
       (vec_zip2 a b (VectorSize.Size32x4)))
 ;; Note that zip1/zip2 for i64x2 vectors is omitted since it's already covered
 ;; by the i64x2 cases of uzp1/uzp2 above where both zip and uzp have the same
@@ -199,17 +248,17 @@
 
 ;; Rules for the `trn1` and `trn2` instructions which interleave odd or even
 ;; lanes in the two input vectors.
-(rule 1 (lower (shuffle a b (u128_from_immediate 0x1e0e_1c0c_1a0a_1808_1606_1404_1202_1000)))
+(rule 1 (lower (shuffle _ a b (u128_from_immediate 0x1e0e_1c0c_1a0a_1808_1606_1404_1202_1000)))
       (vec_trn1 a b (VectorSize.Size8x16)))
-(rule 1 (lower (shuffle a b (u128_from_immediate 0x1f0f_1d0d_1b0b_1909_1707_1505_1303_1101)))
+(rule 1 (lower (shuffle _ a b (u128_from_immediate 0x1f0f_1d0d_1b0b_1909_1707_1505_1303_1101)))
       (vec_trn2 a b (VectorSize.Size8x16)))
-(rule 1 (lower (shuffle a b (u128_from_immediate 0x1d1c_0d0c_1918_0908_1514_0504_1110_0100)))
+(rule 1 (lower (shuffle _ a b (u128_from_immediate 0x1d1c_0d0c_1918_0908_1514_0504_1110_0100)))
       (vec_trn1 a b (VectorSize.Size16x8)))
-(rule 1 (lower (shuffle a b (u128_from_immediate 0x1f1e_0f0e_1b1a_0b0a_1716_0706_1312_0302)))
+(rule 1 (lower (shuffle _ a b (u128_from_immediate 0x1f1e_0f0e_1b1a_0b0a_1716_0706_1312_0302)))
       (vec_trn2 a b (VectorSize.Size16x8)))
-(rule 1 (lower (shuffle a b (u128_from_immediate 0x1b1a1918_0b0a0908_13121110_03020100)))
+(rule 1 (lower (shuffle _ a b (u128_from_immediate 0x1b1a1918_0b0a0908_13121110_03020100)))
       (vec_trn1 a b (VectorSize.Size32x4)))
-(rule 1 (lower (shuffle a b (u128_from_immediate 0x1f1e1d1c_0f0e0d0c_17161514_07060504)))
+(rule 1 (lower (shuffle _ a b (u128_from_immediate 0x1f1e1d1c_0f0e0d0c_17161514_07060504)))
       (vec_trn2 a b (VectorSize.Size32x4)))
 ;; Note that trn1/trn2 for i64x2 vectors is omitted since it's already covered
 ;; by the i64x2 cases of uzp1/uzp2 above where both trn and uzp have the same
@@ -219,31 +268,31 @@
 ;; the byte level, the 16-bit level, or 32-bit level. Note that all of these
 ;; patterns only match reversals in the first operand, but they can
 ;; theoretically be extended if necessary to reversals in the second operand.
-(rule 1 (lower (shuffle a b (u128_from_immediate 0x0e0f_0c0d_0a0b_0809_0607_0405_0203_0001)))
+(rule 1 (lower (shuffle _ a b (u128_from_immediate 0x0e0f_0c0d_0a0b_0809_0607_0405_0203_0001)))
       (rev16 a (VectorSize.Size8x16)))
-(rule 1 (lower (shuffle a b (u128_from_immediate 0x0c0d0e0f_08090a0b_04050607_00010203)))
+(rule 1 (lower (shuffle _ a b (u128_from_immediate 0x0c0d0e0f_08090a0b_04050607_00010203)))
       (rev32 a (VectorSize.Size8x16)))
-(rule 1 (lower (shuffle a b (u128_from_immediate 0x0d0c0f0e_09080b0a_05040706_01000302)))
+(rule 1 (lower (shuffle _ a b (u128_from_immediate 0x0d0c0f0e_09080b0a_05040706_01000302)))
       (rev32 a (VectorSize.Size16x8)))
-(rule 1 (lower (shuffle a b (u128_from_immediate 0x08090a0b0c0d0e0f_0001020304050607)))
+(rule 1 (lower (shuffle _ a b (u128_from_immediate 0x08090a0b0c0d0e0f_0001020304050607)))
       (rev64 a (VectorSize.Size8x16)))
-(rule 1 (lower (shuffle a b (u128_from_immediate 0x09080b0a0d0c0f0e_0100030205040706)))
+(rule 1 (lower (shuffle _ a b (u128_from_immediate 0x09080b0a0d0c0f0e_0100030205040706)))
       (rev64 a (VectorSize.Size16x8)))
-(rule 1 (lower (shuffle a b (u128_from_immediate 0x0b0a09080f0e0d0c_0302010007060504)))
+(rule 1 (lower (shuffle _ a b (u128_from_immediate 0x0b0a09080f0e0d0c_0302010007060504)))
       (rev64 a (VectorSize.Size32x4)))
 
-(rule (lower (has_type ty (shuffle rn rn2 (u128_from_immediate mask))))
+(rule (lower (has_type ty (shuffle _ rn rn2 (u128_from_immediate mask))))
       (let ((mask_reg Reg (constant_f128 mask)))
        (vec_tbl2 rn rn2 mask_reg ty)))
 
 ;;;; Rules for `swizzle` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type vec_i128_ty (swizzle rn rm)))
+(rule (lower (has_type vec_i128_ty (swizzle _ rn rm)))
       (vec_tbl rn rm))
 
 ;;;; Rules for `isplit` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (isplit x @ (value_type $I128)))
+(rule (lower (isplit _ x @ (value_type $I128)))
       (let
           ((x_regs ValueRegs x)
            (x_lo ValueRegs (value_regs_get x_regs 0))
@@ -251,22 +300,22 @@
         (output_pair x_lo x_hi)))
 
 ;;;; Rules for `iconcat` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(rule (lower (has_type $I128 (iconcat lo hi)))
+(attr rule iconcat_i128 (tag i128))
+(rule iconcat_i128 (lower (has_type $I128 (iconcat _ lo hi)))
       (output (value_regs lo hi)))
 
 ;;;; Rules for `scalar_to_vector` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type $F32X4 (scalar_to_vector x)))
+(rule (lower (has_type $F32X4 (scalar_to_vector _ x)))
       (fpu_extend x (ScalarSize.Size32)))
 
-(rule (lower (has_type $F64X2 (scalar_to_vector x)))
+(rule (lower (has_type $F64X2 (scalar_to_vector _ x)))
       (fpu_extend x (ScalarSize.Size64)))
 
-(rule -1 (lower (scalar_to_vector x @ (value_type $I64)))
+(rule -1 (lower (scalar_to_vector _ x @ (value_type $I64)))
       (mov_to_fpu x (ScalarSize.Size64)))
 
-(rule -2 (lower (scalar_to_vector x @ (value_type (int_fits_in_32 _))))
+(rule -2 (lower (scalar_to_vector _ x @ (value_type (int_fits_in_32 _))))
       (mov_to_fpu (put_in_reg_zext32 x) (ScalarSize.Size32)))
 
 ;;;; Rules for `vall_true` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -280,13 +329,13 @@
 ;; 0 when all input elements are true, i.e. non-zero, or a NaN otherwise
 ;; (either -1 or -2 when represented as an integer); NaNs are the only
 ;; floating-point numbers that compare unequal to themselves.
-(rule (lower (vall_true x @ (value_type (multi_lane 64 2))))
+(rule (lower (vall_true _ x @ (value_type (multi_lane 64 2))))
       (let ((x1 Reg (cmeq0 x (VectorSize.Size64x2)))
             (x2 Reg (addp x1 x1 (VectorSize.Size64x2))))
        (with_flags (fpu_cmp (ScalarSize.Size64) x2 x2)
                    (materialize_bool_result (Cond.Eq)))))
 
-(rule (lower (vall_true x @ (value_type (multi_lane 32 2))))
+(rule (lower (vall_true _ x @ (value_type (multi_lane 32 2))))
       (let ((x1 Reg (mov_from_vec x 0 (ScalarSize.Size64))))
        (with_flags (cmp_rr_shift (OperandSize.Size64) (zero_reg) x1 32)
                    (ccmp_imm
@@ -303,7 +352,7 @@
 ;; mov xm, vn.d[0]
 ;; cmp xm, #0
 ;; cset xm, ne
-(rule -1 (lower (vall_true x @ (value_type (lane_fits_in_32 ty))))
+(rule -1 (lower (vall_true _ x @ (value_type (lane_fits_in_32 ty))))
       (if (not_vec32x2 ty))
       (let ((x1 Reg (vec_lanes (VecLanesOp.Uminv) x (vector_size ty)))
             (x2 Reg (mov_from_vec x1 0 (ScalarSize.Size64))))
@@ -312,45 +361,63 @@
 
 ;;;; Rules for `vany_true` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (vany_true x @ (value_type in_ty)))
+(rule (lower (vany_true _ x @ (value_type in_ty)))
       (with_flags (vanytrue x in_ty)
                   (materialize_bool_result (Cond.Ne))))
 
 ;;;; Rules for `iadd_pairwise` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; special case for the `i16x8.extadd_pairwise_i8x16_s` wasm instruction
-(rule (lower (has_type $I16X8 (iadd_pairwise (swiden_low x) (swiden_high x))))
+(rule (lower (has_type $I16X8 (iadd_pairwise _ (swiden_low _ x) (swiden_high _ x))))
       (saddlp8 x))
 
 ;; special case for the `i32x4.extadd_pairwise_i16x8_s` wasm instruction
-(rule (lower (has_type $I32X4 (iadd_pairwise (swiden_low x) (swiden_high x))))
+(rule (lower (has_type $I32X4 (iadd_pairwise _ (swiden_low _ x) (swiden_high _ x))))
       (saddlp16 x))
 
 ;; special case for the `i16x8.extadd_pairwise_i8x16_u` wasm instruction
-(rule (lower (has_type $I16X8 (iadd_pairwise (uwiden_low x) (uwiden_high x))))
+(rule (lower (has_type $I16X8 (iadd_pairwise _ (uwiden_low _ x) (uwiden_high _ x))))
       (uaddlp8 x))
 
 ;; special case for the `i32x4.extadd_pairwise_i16x8_u` wasm instruction
-(rule (lower (has_type $I32X4 (iadd_pairwise (uwiden_low x) (uwiden_high x))))
+(rule (lower (has_type $I32X4 (iadd_pairwise _ (uwiden_low _ x) (uwiden_high _ x))))
       (uaddlp16 x))
 
-(rule -1 (lower (has_type ty (iadd_pairwise x y)))
+(rule -1 (lower (has_type ty (iadd_pairwise _ x y)))
       (addp x y (vector_size ty)))
 
 ;;;; Rules for `iabs` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type ty @ (multi_lane _ _) (iabs x)))
+(rule -1 (lower (has_type ty @ (multi_lane _ _) (iabs _ x)))
       (vec_abs x (vector_size ty)))
 
-(rule 2 (lower (has_type $I64 (iabs x)))
+(rule iabs_64 2 (lower (has_type $I64 (iabs _ x)))
       (abs (OperandSize.Size64) x))
 
-(rule 1 (lower (has_type (fits_in_32 ty) (iabs x)))
+(rule iabs_8_16_32 1 (lower (has_type (fits_in_32 ty) (iabs _ x)))
       (abs (OperandSize.Size32) (put_in_reg_sext32 x)))
 
+; `rustc` implementation.
+; - create a bitmask of all 1s if negative, or 0s if positive.
+; - xor all bits by bitmask. then subtract bitmask from xor'd values.
+; - if `x` is positive, the xor'd bits = x and the mask = 0, so we end up with
+;   `x - 0`.
+; - if `x` is negative, the xor'd bits = ~x and the mask = -1, so we end up with
+;   `~x - (-1) = ~x + 1`, which is exactly `abs(x)`.
+(rule (lower (has_type $I128 (iabs _ x)))
+      (let ((x_regs ValueRegs x)
+            (x_lo Reg (value_regs_get x_regs 0))
+            (x_hi Reg (value_regs_get x_regs 1))
+            (asr_reg Reg (asr_imm $I64 x_hi (imm_shift_from_u8 63)))
+            (eor_hi Reg (eor $I64 x_hi asr_reg))
+            (eor_lo Reg (eor $I64 x_lo asr_reg))
+            (subs_lo ProducesFlags (sub_with_flags_paired $I64 eor_lo asr_reg))
+            (sbc_hi ConsumesFlags (sbc_paired $I64 eor_hi asr_reg)))
+       (with_flags subs_lo sbc_hi)))
+
 ;;;; Rules for `avg_round` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type $I64X2 (avg_round x y)))
+(rule (lower (has_type $I64X2 (avg_round _ x y)))
       (let ((one Reg (splat_const 1 (VectorSize.Size64x2)))
             (c Reg (orr_vec x y (VectorSize.Size64x2)))
             (c Reg (and_vec c one (VectorSize.Size64x2)))
@@ -359,151 +426,181 @@
             (sum Reg (add_vec x y (VectorSize.Size64x2))))
        (add_vec c sum (VectorSize.Size64x2))))
 
-(rule -1 (lower (has_type (lane_fits_in_32 ty) (avg_round x y)))
+(rule -1 (lower (has_type (lane_fits_in_32 ty) (avg_round _ x y)))
       (vec_rrr (VecALUOp.Urhadd) x y (vector_size ty)))
 
 ;;;; Rules for `sqmul_round_sat` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type ty @ (multi_lane _ _) (sqmul_round_sat x y)))
+(rule (lower (has_type ty @ (multi_lane _ _) (sqmul_round_sat _ x y)))
       (vec_rrr (VecALUOp.Sqrdmulh) x y (vector_size ty)))
 
 ;;;; Rules for `fadd` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule -1 (lower (has_type ty @ (multi_lane _ _) (fadd rn rm)))
+(rule -1 (lower (has_type ty @ (multi_lane _ _) (fadd _ rn rm)))
       (vec_rrr (VecALUOp.Fadd) rn rm (vector_size ty)))
 
-(rule (lower (has_type (ty_scalar_float ty) (fadd rn rm)))
+(rule fadd (lower (has_type (ty_scalar_float ty) (fadd _ rn rm)))
       (fpu_rrr (FPUOp2.Add) rn rm (scalar_size ty)))
 
 ;;;; Rules for `fsub` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule -1 (lower (has_type ty @ (multi_lane _ _) (fsub rn rm)))
+(rule -1 (lower (has_type ty @ (multi_lane _ _) (fsub _ rn rm)))
       (vec_rrr (VecALUOp.Fsub) rn rm (vector_size ty)))
 
-(rule (lower (has_type (ty_scalar_float ty) (fsub rn rm)))
+(rule fsub (lower (has_type (ty_scalar_float ty) (fsub _ rn rm)))
       (fpu_rrr (FPUOp2.Sub) rn rm (scalar_size ty)))
 
 ;;;; Rules for `fmul` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule -1 (lower (has_type ty @ (multi_lane _ _) (fmul rn rm)))
+(rule -1 (lower (has_type ty @ (multi_lane _ _) (fmul _ rn rm)))
       (vec_rrr (VecALUOp.Fmul) rn rm (vector_size ty)))
 
-(rule (lower (has_type (ty_scalar_float ty) (fmul rn rm)))
+(rule fmul (lower (has_type (ty_scalar_float ty) (fmul _ rn rm)))
       (fpu_rrr (FPUOp2.Mul) rn rm (scalar_size ty)))
 
 ;;;; Rules for `fdiv` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule -1 (lower (has_type ty @ (multi_lane _ _) (fdiv rn rm)))
+(rule -1 (lower (has_type ty @ (multi_lane _ _) (fdiv _ rn rm)))
       (vec_rrr (VecALUOp.Fdiv) rn rm (vector_size ty)))
 
-(rule (lower (has_type (ty_scalar_float ty) (fdiv rn rm)))
+(rule fdiv (lower (has_type (ty_scalar_float ty) (fdiv _ rn rm)))
       (fpu_rrr (FPUOp2.Div) rn rm (scalar_size ty)))
 
 ;;;; Rules for `fmin` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule -1 (lower (has_type ty @ (multi_lane _ _) (fmin rn rm)))
+(rule -1 (lower (has_type ty @ (multi_lane _ _) (fmin _ rn rm)))
       (vec_rrr (VecALUOp.Fmin) rn rm (vector_size ty)))
 
-(rule (lower (has_type (ty_scalar_float ty) (fmin rn rm)))
+(rule fmin (lower (has_type (ty_scalar_float ty) (fmin _ rn rm)))
       (fpu_rrr (FPUOp2.Min) rn rm (scalar_size ty)))
 
 ;;;; Rules for `fmax` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule -1 (lower (has_type ty @ (multi_lane _ _) (fmax rn rm)))
+(rule -1 (lower (has_type ty @ (multi_lane _ _) (fmax _ rn rm)))
       (vec_rrr (VecALUOp.Fmax) rn rm (vector_size ty)))
 
-(rule (lower (has_type (ty_scalar_float ty) (fmax rn rm)))
+(rule fmax (lower (has_type (ty_scalar_float ty) (fmax _ rn rm)))
       (fpu_rrr (FPUOp2.Max) rn rm (scalar_size ty)))
 
 ;;;; Rules for `sqrt` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule -1 (lower (has_type ty @ (multi_lane _ _) (sqrt x)))
+(rule -1 (lower (has_type ty @ (multi_lane _ _) (sqrt _ x)))
       (vec_misc (VecMisc2.Fsqrt) x (vector_size ty)))
 
-(rule (lower (has_type (ty_scalar_float ty) (sqrt x)))
+(rule fsqrt (lower (has_type (ty_scalar_float ty) (sqrt _ x)))
       (fpu_rr (FPUOp1.Sqrt) x (scalar_size ty)))
 
 ;;;; Rules for `fneg` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule -1 (lower (has_type ty @ (multi_lane _ _) (fneg x)))
+(rule -1 (lower (has_type ty @ (multi_lane _ _) (fneg _ x)))
       (vec_misc (VecMisc2.Fneg) x (vector_size ty)))
 
-(rule (lower (has_type (ty_scalar_float ty) (fneg x)))
+(rule fneg (lower (has_type (ty_scalar_float ty) (fneg _ x)))
       (fpu_rr (FPUOp1.Neg) x (scalar_size ty)))
 
 ;;;; Rules for `fabs` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule -1 (lower (has_type ty @ (multi_lane _ _) (fabs x)))
+(rule -1 (lower (has_type ty @ (multi_lane _ _) (fabs _ x)))
       (vec_misc (VecMisc2.Fabs) x (vector_size ty)))
 
-(rule (lower (has_type (ty_scalar_float ty) (fabs x)))
+(rule fabs (lower (has_type (ty_scalar_float ty) (fabs _ x)))
       (fpu_rr (FPUOp1.Abs) x (scalar_size ty)))
 
 ;;;; Rules for `fpromote` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type $F64 (fpromote x)))
+(rule fpromote (lower (has_type $F64 (fpromote _ x)))
       (fpu_rr (FPUOp1.Cvt32To64) x (ScalarSize.Size32)))
 
 ;;;; Rules for `fdemote` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type $F32 (fdemote x)))
+(rule fdemote (lower (has_type $F32 (fdemote _ x)))
       (fpu_rr (FPUOp1.Cvt64To32) x (ScalarSize.Size64)))
 
 ;;;; Rules for `ceil` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule -1 (lower (has_type ty @ (multi_lane _ _) (ceil x)))
+(rule -1 (lower (has_type ty @ (multi_lane _ _) (ceil _ x)))
       (vec_misc (VecMisc2.Frintp) x (vector_size ty)))
 
-(rule (lower (has_type $F32 (ceil x)))
+(rule ceil_32 (lower (has_type $F32 (ceil _ x)))
       (fpu_round (FpuRoundMode.Plus32) x))
 
-(rule (lower (has_type $F64 (ceil x)))
+(rule ceil_64 (lower (has_type $F64 (ceil _ x)))
       (fpu_round (FpuRoundMode.Plus64) x))
 
 ;;;; Rules for `floor` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule -1 (lower (has_type ty @ (multi_lane _ _) (floor x)))
+(rule -1 (lower (has_type ty @ (multi_lane _ _) (floor _ x)))
       (vec_misc (VecMisc2.Frintm) x (vector_size ty)))
 
-(rule (lower (has_type $F32 (floor x)))
+(rule floor_32 (lower (has_type $F32 (floor _ x)))
       (fpu_round (FpuRoundMode.Minus32) x))
 
-(rule (lower (has_type $F64 (floor x)))
+(rule floor_64 (lower (has_type $F64 (floor _ x)))
       (fpu_round (FpuRoundMode.Minus64) x))
 
 ;;;; Rules for `trunc` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule -1 (lower (has_type ty @ (multi_lane _ _) (trunc x)))
+(rule -1 (lower (has_type ty @ (multi_lane _ _) (trunc _ x)))
       (vec_misc (VecMisc2.Frintz) x (vector_size ty)))
 
-(rule (lower (has_type $F32 (trunc x)))
+(rule trunc_32 (lower (has_type $F32 (trunc _ x)))
       (fpu_round (FpuRoundMode.Zero32) x))
 
-(rule (lower (has_type $F64 (trunc x)))
+(rule trunc_64 (lower (has_type $F64 (trunc _ x)))
       (fpu_round (FpuRoundMode.Zero64) x))
 
 ;;;; Rules for `nearest` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule -1 (lower (has_type ty @ (multi_lane _ _) (nearest x)))
+(rule -1 (lower (has_type ty @ (multi_lane _ _) (nearest _ x)))
       (vec_misc (VecMisc2.Frintn) x (vector_size ty)))
 
-(rule (lower (has_type $F32 (nearest x)))
+(rule nearest_32 (lower (has_type $F32 (nearest _ x)))
       (fpu_round (FpuRoundMode.Nearest32) x))
 
-(rule (lower (has_type $F64 (nearest x)))
+(rule nearest_64 (lower (has_type $F64 (nearest _ x)))
       (fpu_round (FpuRoundMode.Nearest64) x))
 
 ;;;; Rules for `fma` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type (ty_scalar_float ty) (fma x y z)))
-       (fpu_rrrr (FPUOp3.MAdd) (scalar_size ty) x y z))
+(type IsFneg (enum (Result (negate u64) (value Value))))
+
+(decl pure is_fneg (Value) IsFneg)
+(rule 1 (is_fneg (fneg _ n)) (IsFneg.Result 1 n))
+(rule 0 (is_fneg n) (IsFneg.Result 0 n))
+
+(decl pure is_fneg_neg (IsFneg) u64)
+(rule (is_fneg_neg (IsFneg.Result n _)) n)
+(attr is_fneg_neg (veri chain))
+
+(decl pure get_fneg_value (IsFneg) Value)
+(rule (get_fneg_value (IsFneg.Result _ v)) v)
+(attr get_fneg_value (veri chain))
+
+(decl fmadd_series (Type u64 u64 Value Value Value) InstOutput)
+;; MAdd: + x * y + z
+(rule 0 (fmadd_series (ty_scalar_float ty) 0 0 x y z) (fpu_rrrr (FPUOp3.MAdd) (scalar_size ty) x y z))
+;; MSub: - x * y + z
+(rule 0 (fmadd_series (ty_scalar_float ty) 1 0 x y z) (fpu_rrrr (FPUOp3.MSub) (scalar_size ty) x y z))
+;; NMAdd: - x * y - z
+(rule 0 (fmadd_series (ty_scalar_float ty) 1 1 x y z) (fpu_rrrr (FPUOp3.NMAdd) (scalar_size ty) x y z))
+;; NMSub: + x * y - z
+(rule 0 (fmadd_series (ty_scalar_float ty) 0 1 x y z) (fpu_rrrr (FPUOp3.NMSub) (scalar_size ty) x y z))
+
+(rule (lower (has_type (ty_scalar_float ty) (fma _ x_src y_src z_src)))
+  (let
+      ((x_res IsFneg (is_fneg x_src))
+       (y_res IsFneg (is_fneg y_src))
+       (z_res IsFneg (is_fneg z_src)))
+      (fmadd_series ty (u64_xor (is_fneg_neg x_res) (is_fneg_neg y_res)) (is_fneg_neg z_res) (get_fneg_value x_res) (get_fneg_value y_res) (get_fneg_value z_res))))
 
 ;; Delegate vector-based lowerings to helpers below
-(rule 1 (lower (has_type ty @ (multi_lane _ _) (fma x y z)))
+(attr rule fma (tag vector))
+(rule fma 1 (lower (has_type ty @ (multi_lane _ _) (fma _ x y z)))
         (lower_fmla (VecALUModOp.Fmla) x y z (vector_size ty)))
 
 ;; Lowers a fused-multiply-add operation handling various forms of the
 ;; instruction to get maximal coverage of what's available on AArch64.
+(attr lower_fmla (tag vector))
 (decl lower_fmla (VecALUModOp Value Value Value VectorSize) Reg)
 
 ;; Base case, emit the op requested.
@@ -512,9 +609,9 @@
 
 ;; Special case: if one of the multiplicands are a splat then the element-based
 ;; fma can be used instead with 0 as the element index.
-(rule 1 (lower_fmla op (splat x) y z size)
+(rule 1 (lower_fmla op (splat _ x) y z size)
         (vec_fmla_elem op z y x size 0))
-(rule 2 (lower_fmla op x (splat y) z size)
+(rule 2 (lower_fmla op x (splat _ y) z size)
         (vec_fmla_elem op z x y size 0))
 
 ;; Special case: if one of the multiplicands is a shuffle to broadcast a
@@ -524,16 +621,16 @@
 ;; Note that in Cranelift shuffle always has i8x16 inputs and outputs so
 ;; a `bitcast` is matched here explicitly since that's the main way a shuffle
 ;; output will be fed into this instruction.
-(rule 3 (lower_fmla op (bitcast _ (shuffle x x (shuffle32_from_imm n n n n))) y z size @ (VectorSize.Size32x4))
+(rule 3 (lower_fmla op (bitcast _ _ (shuffle _ x x (shuffle32_from_imm n n n n))) y z size @ (VectorSize.Size32x4))
         (if-let $true (u64_lt n 4))
         (vec_fmla_elem op z y x size n))
-(rule 4 (lower_fmla op x (bitcast _ (shuffle y y (shuffle32_from_imm n n n n))) z size @ (VectorSize.Size32x4))
+(rule 4 (lower_fmla op x (bitcast _ _ (shuffle _ y y (shuffle32_from_imm n n n n))) z size @ (VectorSize.Size32x4))
         (if-let $true (u64_lt n 4))
         (vec_fmla_elem op z x y size n))
-(rule 3 (lower_fmla op (bitcast _ (shuffle x x (shuffle64_from_imm n n))) y z size @ (VectorSize.Size64x2))
+(rule 3 (lower_fmla op (bitcast _ _ (shuffle _ x x (shuffle64_from_imm n n))) y z size @ (VectorSize.Size64x2))
         (if-let $true (u64_lt n 2))
         (vec_fmla_elem op z y x size n))
-(rule 4 (lower_fmla op x (bitcast _ (shuffle y y (shuffle64_from_imm n n))) z size @ (VectorSize.Size64x2))
+(rule 4 (lower_fmla op x (bitcast _ _ (shuffle _ y y (shuffle64_from_imm n n))) z size @ (VectorSize.Size64x2))
         (if-let $true (u64_lt n 2))
         (vec_fmla_elem op z x y size n))
 
@@ -543,9 +640,9 @@
 ;;
 ;; Note that these are the highest priority cases for `lower_fmla` to peel
 ;; away as many `fneg` operations as possible.
-(rule 5 (lower_fmla op (fneg x) y z size)
+(rule 5 (lower_fmla op (fneg _ x) y z size)
         (lower_fmla (neg_fmla op) x y z size))
-(rule 6 (lower_fmla op x (fneg y) z size)
+(rule 6 (lower_fmla op x (fneg _ y) z size)
         (lower_fmla (neg_fmla op) x y z size))
 
 (decl neg_fmla (VecALUModOp) VecALUModOp)
@@ -554,115 +651,115 @@
 
 ;;;; Rules for `fcopysign` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type ty (fcopysign x y)))
+(rule fcopysign (lower (has_type ty (fcopysign _ x y)))
       (fcopy_sign x y ty))
 
 ;;;; Rules for `fcvt_to_uint` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type (fits_in_32 out_ty) (fcvt_to_uint x @ (value_type $F32))))
+(rule fcvt_to_uint_i32_f32 (lower (has_type (fits_in_32 out_ty) (fcvt_to_uint _ x @ (value_type $F32))))
       (fpu_to_int_cvt (FpuToIntOp.F32ToU32) x $false $F32 out_ty))
 
-(rule 1 (lower (has_type $I64 (fcvt_to_uint x @ (value_type $F32))))
+(rule fcvt_to_uint_i64_f32 1 (lower (has_type $I64 (fcvt_to_uint _ x @ (value_type $F32))))
       (fpu_to_int_cvt (FpuToIntOp.F32ToU64) x $false $F32 $I64))
 
-(rule (lower (has_type (fits_in_32 out_ty) (fcvt_to_uint x @ (value_type $F64))))
+(rule fcvt_to_uint_i32_f64 (lower (has_type (fits_in_32 out_ty) (fcvt_to_uint _ x @ (value_type $F64))))
       (fpu_to_int_cvt (FpuToIntOp.F64ToU32) x $false $F64 out_ty))
 
-(rule 1 (lower (has_type $I64 (fcvt_to_uint x @ (value_type $F64))))
+(rule fcvt_to_uint_i64_f64 1 (lower (has_type $I64 (fcvt_to_uint _ x @ (value_type $F64))))
       (fpu_to_int_cvt (FpuToIntOp.F64ToU64) x $false $F64 $I64))
 
 ;;;; Rules for `fcvt_to_sint` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type (fits_in_32 out_ty) (fcvt_to_sint x @ (value_type $F32))))
+(rule fcvt_to_sint_i32_f32 (lower (has_type (fits_in_32 out_ty) (fcvt_to_sint _ x @ (value_type $F32))))
       (fpu_to_int_cvt (FpuToIntOp.F32ToI32) x $true $F32 out_ty))
 
-(rule 1 (lower (has_type $I64 (fcvt_to_sint x @ (value_type $F32))))
+(rule fcvt_to_sint_i64_f32 1 (lower (has_type $I64 (fcvt_to_sint _ x @ (value_type $F32))))
       (fpu_to_int_cvt (FpuToIntOp.F32ToI64) x $true $F32 $I64))
 
-(rule (lower (has_type (fits_in_32 out_ty) (fcvt_to_sint x @ (value_type $F64))))
+(rule fcvt_to_sint_i32_f64 (lower (has_type (fits_in_32 out_ty) (fcvt_to_sint _ x @ (value_type $F64))))
       (fpu_to_int_cvt (FpuToIntOp.F64ToI32) x $true $F64 out_ty))
 
-(rule 1 (lower (has_type $I64 (fcvt_to_sint x @ (value_type $F64))))
+(rule fcvt_to_sint_i64_f64 1 (lower (has_type $I64 (fcvt_to_sint _ x @ (value_type $F64))))
       (fpu_to_int_cvt (FpuToIntOp.F64ToI64) x $true $F64 $I64))
 
 ;;;; Rules for `fcvt_from_uint` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule -1 (lower (has_type ty @ (multi_lane 32 _) (fcvt_from_uint x @ (value_type (multi_lane 32 _)))))
+(rule -1 (lower (has_type ty @ (multi_lane 32 _) (fcvt_from_uint _ x @ (value_type (multi_lane 32 _)))))
       (vec_misc (VecMisc2.Ucvtf) x (vector_size ty)))
 
-(rule -1 (lower (has_type ty @ (multi_lane 64 _) (fcvt_from_uint x @ (value_type (multi_lane 64 _)))))
+(rule -1 (lower (has_type ty @ (multi_lane 64 _) (fcvt_from_uint _ x @ (value_type (multi_lane 64 _)))))
       (vec_misc (VecMisc2.Ucvtf) x (vector_size ty)))
 
-(rule (lower (has_type $F32 (fcvt_from_uint x @ (value_type (fits_in_32 _)))))
+(rule fcvt_from_uint_f32_u32 (lower (has_type $F32 (fcvt_from_uint _ x @ (value_type (fits_in_32 _)))))
       (int_to_fpu (IntToFpuOp.U32ToF32) (put_in_reg_zext32 x)))
 
-(rule (lower (has_type $F64 (fcvt_from_uint x @ (value_type (fits_in_32 _)))))
+(rule fcvt_from_uint_f64_u32 (lower (has_type $F64 (fcvt_from_uint _ x @ (value_type (fits_in_32 _)))))
       (int_to_fpu (IntToFpuOp.U32ToF64) (put_in_reg_zext32 x)))
 
-(rule 1 (lower (has_type $F32 (fcvt_from_uint x @ (value_type $I64))))
+(rule fcvt_from_uint_f32_u64 1 (lower (has_type $F32 (fcvt_from_uint _ x @ (value_type $I64))))
       (int_to_fpu (IntToFpuOp.U64ToF32) x))
 
-(rule 1 (lower (has_type $F64 (fcvt_from_uint x @ (value_type $I64))))
+(rule fcvt_from_uint_f64_u64 1 (lower (has_type $F64 (fcvt_from_uint _ x @ (value_type $I64))))
       (int_to_fpu (IntToFpuOp.U64ToF64) x))
 
 ;;;; Rules for `fcvt_from_sint` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule -1 (lower (has_type ty @ (multi_lane 32 _) (fcvt_from_sint x @ (value_type (multi_lane 32 _)))))
+(rule -1 (lower (has_type ty @ (multi_lane 32 _) (fcvt_from_sint _ x @ (value_type (multi_lane 32 _)))))
       (vec_misc (VecMisc2.Scvtf) x (vector_size ty)))
 
-(rule -1 (lower (has_type ty @ (multi_lane 64 _) (fcvt_from_sint x @ (value_type (multi_lane 64 _)))))
+(rule -1 (lower (has_type ty @ (multi_lane 64 _) (fcvt_from_sint _ x @ (value_type (multi_lane 64 _)))))
       (vec_misc (VecMisc2.Scvtf) x (vector_size ty)))
 
-(rule (lower (has_type $F32 (fcvt_from_sint x @ (value_type (fits_in_32 _)))))
+(rule fcvt_from_uint_f32_i32 (lower (has_type $F32 (fcvt_from_sint _ x @ (value_type (fits_in_32 _)))))
       (int_to_fpu (IntToFpuOp.I32ToF32) (put_in_reg_sext32 x)))
 
-(rule (lower (has_type $F64 (fcvt_from_sint x @ (value_type (fits_in_32 _)))))
+(rule fcvt_from_uint_f64_i32 (lower (has_type $F64 (fcvt_from_sint _ x @ (value_type (fits_in_32 _)))))
       (int_to_fpu (IntToFpuOp.I32ToF64) (put_in_reg_sext32 x)))
 
-(rule 1 (lower (has_type $F32 (fcvt_from_sint x @ (value_type $I64))))
+(rule fcvt_from_uint_f32_i64 1 (lower (has_type $F32 (fcvt_from_sint _ x @ (value_type $I64))))
       (int_to_fpu (IntToFpuOp.I64ToF32) x))
 
-(rule 1 (lower (has_type $F64 (fcvt_from_sint x @ (value_type $I64))))
+(rule fcvt_from_uint_f64_i64 1 (lower (has_type $F64 (fcvt_from_sint _ x @ (value_type $I64))))
       (int_to_fpu (IntToFpuOp.I64ToF64) x))
 
 ;;;; Rules for `fcvt_to_uint_sat` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule -1 (lower (has_type ty @ (multi_lane 32 _) (fcvt_to_uint_sat x @ (value_type (multi_lane 32 _)))))
+(rule -1 (lower (has_type ty @ (multi_lane 32 _) (fcvt_to_uint_sat _ x @ (value_type (multi_lane 32 _)))))
       (vec_misc (VecMisc2.Fcvtzu) x (vector_size ty)))
 
-(rule -1 (lower (has_type ty @ (multi_lane 64 _) (fcvt_to_uint_sat x @ (value_type (multi_lane 64 _)))))
+(rule -1 (lower (has_type ty @ (multi_lane 64 _) (fcvt_to_uint_sat _ x @ (value_type (multi_lane 64 _)))))
       (vec_misc (VecMisc2.Fcvtzu) x (vector_size ty)))
 
-(rule (lower (has_type (fits_in_32 out_ty) (fcvt_to_uint_sat x @ (value_type $F32))))
+(rule (lower (has_type (fits_in_32 out_ty) (fcvt_to_uint_sat _ x @ (value_type $F32))))
       (fpu_to_int_cvt_sat (FpuToIntOp.F32ToU32) x $false out_ty))
 
-(rule 1 (lower (has_type $I64 (fcvt_to_uint_sat x @ (value_type $F32))))
+(rule 1 (lower (has_type $I64 (fcvt_to_uint_sat _ x @ (value_type $F32))))
       (fpu_to_int_cvt_sat (FpuToIntOp.F32ToU64) x $false $I64))
 
-(rule (lower (has_type (fits_in_32 out_ty) (fcvt_to_uint_sat x @ (value_type $F64))))
+(rule (lower (has_type (fits_in_32 out_ty) (fcvt_to_uint_sat _ x @ (value_type $F64))))
       (fpu_to_int_cvt_sat (FpuToIntOp.F64ToU32) x $false out_ty))
 
-(rule 1 (lower (has_type $I64 (fcvt_to_uint_sat x @ (value_type $F64))))
+(rule 1 (lower (has_type $I64 (fcvt_to_uint_sat _ x @ (value_type $F64))))
       (fpu_to_int_cvt_sat (FpuToIntOp.F64ToU64) x $false $I64))
 
 ;;;; Rules for `fcvt_to_sint_sat` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule -1 (lower (has_type ty @ (multi_lane 32 _) (fcvt_to_sint_sat x @ (value_type (multi_lane 32 _)))))
+(rule -1 (lower (has_type ty @ (multi_lane 32 _) (fcvt_to_sint_sat _ x @ (value_type (multi_lane 32 _)))))
       (vec_misc (VecMisc2.Fcvtzs) x (vector_size ty)))
 
-(rule -1 (lower (has_type ty @ (multi_lane 64 _) (fcvt_to_sint_sat x @ (value_type (multi_lane 64 _)))))
+(rule -1 (lower (has_type ty @ (multi_lane 64 _) (fcvt_to_sint_sat _ x @ (value_type (multi_lane 64 _)))))
       (vec_misc (VecMisc2.Fcvtzs) x (vector_size ty)))
 
-(rule (lower (has_type (fits_in_32 out_ty) (fcvt_to_sint_sat x @ (value_type $F32))))
+(rule (lower (has_type (fits_in_32 out_ty) (fcvt_to_sint_sat _ x @ (value_type $F32))))
       (fpu_to_int_cvt_sat (FpuToIntOp.F32ToI32) x $true out_ty))
 
-(rule 1 (lower (has_type $I64 (fcvt_to_sint_sat x @ (value_type $F32))))
+(rule 1 (lower (has_type $I64 (fcvt_to_sint_sat _ x @ (value_type $F32))))
       (fpu_to_int_cvt_sat (FpuToIntOp.F32ToI64) x $true $I64))
 
-(rule (lower (has_type (fits_in_32 out_ty) (fcvt_to_sint_sat x @ (value_type $F64))))
+(rule (lower (has_type (fits_in_32 out_ty) (fcvt_to_sint_sat _ x @ (value_type $F64))))
       (fpu_to_int_cvt_sat (FpuToIntOp.F64ToI32) x $true out_ty))
 
-(rule 1 (lower (has_type $I64 (fcvt_to_sint_sat x @ (value_type $F64))))
+(rule 1 (lower (has_type $I64 (fcvt_to_sint_sat _ x @ (value_type $F64))))
       (fpu_to_int_cvt_sat (FpuToIntOp.F64ToI64) x $true $I64))
 
 ;;;; Rules for `isub` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -670,81 +767,84 @@
 ;; `i64` and smaller
 
 ;; Base case, simply subtracting things in registers.
-(rule -4 (lower (has_type (fits_in_64 ty) (isub x y)))
+(rule isub_base_case -4 (lower (has_type (fits_in_64 ty) (isub _ x y)))
       (sub ty x y))
 
 ;; Special case for when one operand is an immediate that fits in 12 bits.
-(rule 0 (lower (has_type (fits_in_64 ty) (isub x (imm12_from_value y))))
+(rule isub_imm12 0 (lower (has_type (fits_in_64 ty) (isub _ x (imm12_from_value y))))
       (sub_imm ty x y))
 
 ;; Same as the previous special case, except we can switch the subtraction to an
 ;; addition if the negated immediate fits in 12 bits.
-(rule 2 (lower (has_type (fits_in_64 ty) (isub x y)))
+(rule isub_imm12_neg 2 (lower (has_type (fits_in_64 ty) (isub _ x y)))
       (if-let imm12_neg (imm12_from_negated_value y))
       (add_imm ty x imm12_neg))
 
 ;; Special cases for when we're subtracting an extended register where the
 ;; extending operation can get folded into the sub itself.
-(rule 1 (lower (has_type (fits_in_64 ty) (isub x (extended_value_from_value y))))
+(rule isub_extend 1 (lower (has_type (fits_in_64 ty) (isub _ x (extended_value_from_value y))))
       (sub_extend ty x y))
 
 ;; Finally a special case for when we're subtracting the shift of a different
 ;; register by a constant amount and the shift can get folded into the sub.
-(rule -3 (lower (has_type (fits_in_64 ty)
-                       (isub x (ishl y (iconst k)))))
+(rule isub_ishl -3 (lower (has_type (fits_in_64 ty)
+                       (isub _ x (ishl _ y (iconst _ k)))))
       (if-let amt (lshl_from_imm64 ty k))
       (sub_shift ty x y amt))
 
 ;; vectors
-(rule -2 (lower (has_type ty @ (multi_lane _ _) (isub x y)))
+(rule -2 (lower (has_type ty @ (multi_lane _ _) (isub _ x y)))
       (sub_vec x y (vector_size ty)))
 
 ;; `i128`
-(rule -1 (lower (has_type $I128 (isub x y)))
+(rule isub_i128
+      -1 (lower (has_type $I128 (isub _ x y)))
       (sub_i128 x y))
+(attr rule isub_i128 (tag i128))
 
 ;;;; Rules for `uadd_sat` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type (ty_vec128 ty) (uadd_sat x y)))
+(rule (lower (has_type (ty_vec128 ty) (uadd_sat _ x y)))
       (uqadd x y (vector_size ty)))
 
 ;;;; Rules for `sadd_sat` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type (ty_vec128 ty) (sadd_sat x y)))
+(rule (lower (has_type (ty_vec128 ty) (sadd_sat _ x y)))
       (sqadd x y (vector_size ty)))
 
 ;;;; Rules for `usub_sat` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type (ty_vec128 ty) (usub_sat x y)))
+(rule (lower (has_type (ty_vec128 ty) (usub_sat _ x y)))
       (uqsub x y (vector_size ty)))
 
 ;;;; Rules for `ssub_sat` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type (ty_vec128 ty) (ssub_sat x y)))
+(rule (lower (has_type (ty_vec128 ty) (ssub_sat _ x y)))
       (sqsub x y (vector_size ty)))
 
 ;;;; Rules for `ineg` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; `i64` and smaller.
-(rule 1 (lower (has_type (fits_in_64 ty) (ineg x)))
+(rule ineg_base_case 1 (lower (has_type (fits_in_64 ty) (ineg _ x)))
       (sub ty (zero_reg) x))
 
 ;; `i128`
-(rule 2 (lower (has_type $I128 (ineg x)))
+(rule 2 (lower (has_type $I128 (ineg _ x)))
       (sub_i128 (value_regs_zero) x))
 
 ;; vectors.
-(rule (lower (has_type (ty_vec128 ty) (ineg x)))
+(rule (lower (has_type (ty_vec128 ty) (ineg _ x)))
       (neg x (vector_size ty)))
 
 ;;;; Rules for `imul` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; `i64` and smaller.
-(rule -3 (lower (has_type (fits_in_64 ty) (imul x y)))
+(rule imul -3 (lower (has_type (fits_in_64 ty) (imul _ x y)))
       (madd ty x y (zero_reg)))
 
 ;; `i128`.
-(rule -1 (lower (has_type $I128 (imul x y)))
+(rule imul_i128
+      -1 (lower (has_type $I128 (imul _ x y)))
       (let
           ;; Get the high/low registers for `x`.
           ((x_regs ValueRegs x)
@@ -770,9 +870,10 @@
            (dst_hi Reg (madd $I64 x_hi y_lo dst_hi2))
            (dst_lo Reg (madd $I64 x_lo y_lo (zero_reg))))
         (value_regs dst_lo dst_hi)))
+(attr rule imul_i128 (tag i128))
 
 ;; Case for i8x16, i16x8, and i32x4.
-(rule -2 (lower (has_type (ty_vec128 ty @ (not_i64x2)) (imul x y)))
+(rule -2 (lower (has_type (ty_vec128 ty @ (not_i64x2)) (imul _ x y)))
       (mul x y (vector_size ty)))
 
 ;; Special lowering for i64x2.
@@ -804,7 +905,7 @@
 ;;  xtn tmp2.2s, rm.2d
 ;;  shll rd.2d, rd.2s, #32
 ;;  umlal rd.2d, tmp2.2s, tmp1.2s
-(rule -1 (lower (has_type $I64X2 (imul x y)))
+(rule -1 (lower (has_type $I64X2 (imul _ x y)))
       (let ((rn Reg x)
             (rm Reg y)
             ;; Reverse the 32-bit elements in the 64-bit words.
@@ -844,82 +945,82 @@
 
 ;; Special case for `i16x8.extmul_low_i8x16_s`.
 (rule (lower (has_type $I16X8
-                       (imul (swiden_low x @ (value_type $I8X16))
-                             (swiden_low y @ (value_type $I8X16)))))
+                       (imul _ (swiden_low _ x @ (value_type $I8X16))
+                             (swiden_low _ y @ (value_type $I8X16)))))
       (smull8 x y $false))
 
 ;; Special case for `i16x8.extmul_high_i8x16_s`.
 (rule (lower (has_type $I16X8
-                       (imul (swiden_high x @ (value_type $I8X16))
-                             (swiden_high y @ (value_type $I8X16)))))
+                       (imul _ (swiden_high _ x @ (value_type $I8X16))
+                             (swiden_high _ y @ (value_type $I8X16)))))
       (smull8 x y $true))
 
 ;; Special case for `i16x8.extmul_low_i8x16_u`.
 (rule (lower (has_type $I16X8
-                       (imul (uwiden_low x @ (value_type $I8X16))
-                             (uwiden_low y @ (value_type $I8X16)))))
+                       (imul _ (uwiden_low _ x @ (value_type $I8X16))
+                             (uwiden_low _ y @ (value_type $I8X16)))))
       (umull8 x y $false))
 
 ;; Special case for `i16x8.extmul_high_i8x16_u`.
 (rule (lower (has_type $I16X8
-                       (imul (uwiden_high x @ (value_type $I8X16))
-                             (uwiden_high y @ (value_type $I8X16)))))
+                       (imul _ (uwiden_high _ x @ (value_type $I8X16))
+                             (uwiden_high _ y @ (value_type $I8X16)))))
       (umull8 x y $true))
 
 ;; Special case for `i32x4.extmul_low_i16x8_s`.
 (rule (lower (has_type $I32X4
-                       (imul (swiden_low x @ (value_type $I16X8))
-                             (swiden_low y @ (value_type $I16X8)))))
+                       (imul _ (swiden_low _ x @ (value_type $I16X8))
+                             (swiden_low _ y @ (value_type $I16X8)))))
       (smull16 x y $false))
 
 ;; Special case for `i32x4.extmul_high_i16x8_s`.
 (rule (lower (has_type $I32X4
-                       (imul (swiden_high x @ (value_type $I16X8))
-                             (swiden_high y @ (value_type $I16X8)))))
+                       (imul _ (swiden_high _ x @ (value_type $I16X8))
+                             (swiden_high _ y @ (value_type $I16X8)))))
       (smull16 x y $true))
 
 ;; Special case for `i32x4.extmul_low_i16x8_u`.
 (rule (lower (has_type $I32X4
-                       (imul (uwiden_low x @ (value_type $I16X8))
-                             (uwiden_low y @ (value_type $I16X8)))))
+                       (imul _ (uwiden_low _ x @ (value_type $I16X8))
+                             (uwiden_low _ y @ (value_type $I16X8)))))
       (umull16 x y $false))
 
 ;; Special case for `i32x4.extmul_high_i16x8_u`.
 (rule (lower (has_type $I32X4
-                       (imul (uwiden_high x @ (value_type $I16X8))
-                             (uwiden_high y @ (value_type $I16X8)))))
+                       (imul _ (uwiden_high _ x @ (value_type $I16X8))
+                             (uwiden_high _ y @ (value_type $I16X8)))))
       (umull16 x y $true))
 
 ;; Special case for `i64x2.extmul_low_i32x4_s`.
 (rule (lower (has_type $I64X2
-                       (imul (swiden_low x @ (value_type $I32X4))
-                             (swiden_low y @ (value_type $I32X4)))))
+                       (imul _ (swiden_low _ x @ (value_type $I32X4))
+                             (swiden_low _ y @ (value_type $I32X4)))))
       (smull32 x y $false))
 
 ;; Special case for `i64x2.extmul_high_i32x4_s`.
 (rule (lower (has_type $I64X2
-                       (imul (swiden_high x @ (value_type $I32X4))
-                             (swiden_high y @ (value_type $I32X4)))))
+                       (imul _ (swiden_high _ x @ (value_type $I32X4))
+                             (swiden_high _ y @ (value_type $I32X4)))))
       (smull32 x y $true))
 
 ;; Special case for `i64x2.extmul_low_i32x4_u`.
 (rule (lower (has_type $I64X2
-                       (imul (uwiden_low x @ (value_type $I32X4))
-                             (uwiden_low y @ (value_type $I32X4)))))
+                       (imul _ (uwiden_low _ x @ (value_type $I32X4))
+                             (uwiden_low _ y @ (value_type $I32X4)))))
       (umull32 x y $false))
 
 ;; Special case for `i64x2.extmul_high_i32x4_u`.
 (rule (lower (has_type $I64X2
-                       (imul (uwiden_high x @ (value_type $I32X4))
-                             (uwiden_high y @ (value_type $I32X4)))))
+                       (imul _ (uwiden_high _ x @ (value_type $I32X4))
+                             (uwiden_high _ y @ (value_type $I32X4)))))
       (umull32 x y $true))
 
 ;;;; Rules for `smulhi` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 1 (lower (has_type $I64 (smulhi x y)))
+(rule smulhi_64 1 (lower (has_type $I64 (smulhi _ x y)))
       (smulh $I64 x y))
 
-(rule (lower (has_type (fits_in_32 ty) (smulhi x y)))
+(rule smulhi_32 (lower (has_type (fits_in_32 ty) (smulhi _ x y)))
       (let ((x64 Reg (put_in_reg_sext64 x))
             (y64 Reg (put_in_reg_sext64 y))
             (mul Reg (madd $I64 x64 y64 (zero_reg)))
@@ -928,10 +1029,10 @@
 
 ;;;; Rules for `umulhi` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 1 (lower (has_type $I64 (umulhi x y)))
+(rule umulhi_64 1 (lower (has_type $I64 (umulhi _ x y)))
       (umulh $I64 x y))
 
-(rule (lower (has_type (fits_in_32 ty) (umulhi x y)))
+(rule umulhi_32 (lower (has_type (fits_in_32 ty) (umulhi _ x y)))
       (let (
           (x64 Reg (put_in_reg_zext64 x))
           (y64 Reg (put_in_reg_zext64 y))
@@ -947,18 +1048,21 @@
 ;;
 ;; Note that aarch64's `udiv` doesn't trap so to respect the semantics of
 ;; CLIF's `udiv` the check for zero needs to be manually performed.
-(rule (lower (has_type (fits_in_64 ty) (udiv x y)))
+(rule udiv (lower (has_type (fits_in_64 ty) (udiv _ x y)))
       (a64_udiv $I64 (put_in_reg_zext64 x) (put_nonzero_in_reg_zext64 y)))
 
 ;; Helper for placing a `Value` into a `Reg` and validating that it's nonzero.
 (decl put_nonzero_in_reg_zext64 (Value) Reg)
-(rule -1 (put_nonzero_in_reg_zext64 val)
+(attr put_nonzero_in_reg_zext64 (veri chain))
+(rule put_nonzero_in_reg_zext64_validate
+      -1 (put_nonzero_in_reg_zext64 val)
       (trap_if_zero_divisor (put_in_reg_zext64 val)))
 
 ;; Special case where if a `Value` is known to be nonzero we can trivially
 ;; move it into a register.
-(rule (put_nonzero_in_reg_zext64 (and (value_type ty)
-                                      (iconst (nonzero_u64_from_imm64 n))))
+(rule put_nonzero_in_reg_zext64_const
+      (put_nonzero_in_reg_zext64 (and (value_type ty)
+                                      (iconst _ (nonzero_u64_from_imm64 n))))
       (imm ty (ImmExtend.Zero) n))
 
 ;;;; Rules for `sdiv` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -980,28 +1084,32 @@
 ;;
 ;; TODO: if `y` is -1 then a check that `x` is not INT_MIN is all that's
 ;; necessary, but right now `y` is checked to not be -1 as well.
-(rule (lower (has_type (fits_in_64 ty) (sdiv x y)))
+(rule sdiv (lower (has_type (fits_in_64 ty) (sdiv _ x y)))
       (let ((x64 Reg (put_in_reg_sext64 x))
             (y64 Reg (put_nonzero_in_reg_sext64 y))
-            (valid_x64 Reg (trap_if_div_overflow ty x64 y64))
+            (intmin_check_x Reg (intmin_check ty x64))
+            (valid_x64 Reg (trap_if_div_overflow ty intmin_check_x x64 y64))
             (result Reg (a64_sdiv $I64 valid_x64 y64)))
         result))
 
 ;; Special case for `sdiv` where no checks are needed due to division by a
 ;; constant meaning the checks are always passed.
-(rule 1 (lower (has_type (fits_in_64 ty) (sdiv x (iconst imm))))
+(rule sdiv_safe_divisor 1 (lower (has_type (fits_in_64 ty) (sdiv _ x (iconst _ imm))))
       (if-let y (safe_divisor_from_imm64 ty imm))
       (a64_sdiv $I64 (put_in_reg_sext64 x) (imm ty (ImmExtend.Sign) y)))
 
 ;; Helper for placing a `Value` into a `Reg` and validating that it's nonzero.
 (decl put_nonzero_in_reg_sext64 (Value) Reg)
-(rule -1 (put_nonzero_in_reg_sext64 val)
+(attr put_nonzero_in_reg_sext64 (veri chain))
+(rule put_nonzero_in_reg_sext64_validate
+      -1 (put_nonzero_in_reg_sext64 val)
       (trap_if_zero_divisor (put_in_reg_sext64 val)))
 
 ;; Note that this has a special case where if the `Value` is a constant that's
 ;; not zero we can skip the zero check.
-(rule (put_nonzero_in_reg_sext64 (and (value_type ty)
-                                      (iconst (nonzero_u64_from_imm64 n))))
+(rule put_nonzero_in_reg_sext64_const
+      (put_nonzero_in_reg_sext64 (and (value_type ty)
+                                      (iconst _ (nonzero_u64_from_imm64 n))))
       (imm ty (ImmExtend.Sign) n))
 
 ;;;; Rules for `urem` and `srem` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -1018,14 +1126,14 @@
 ;;   div rd, x, y       ; rd = x / y
 ;;   msub rd, rd, y, x  ; rd = x - rd * y
 
-(rule (lower (has_type (fits_in_64 ty) (urem x y)))
+(rule urem (lower (has_type (fits_in_64 ty) (urem _ x y)))
       (let ((x64 Reg (put_in_reg_zext64 x))
             (y64 Reg (put_nonzero_in_reg_zext64 y))
             (div Reg (a64_udiv $I64 x64 y64))
             (result Reg (msub $I64 div y64 x64)))
         result))
 
-(rule (lower (has_type (fits_in_64 ty) (srem x y)))
+(rule srem (lower (has_type (fits_in_64 ty) (srem _ x y)))
       (let ((x64 Reg (put_in_reg_sext64 x))
             (y64 Reg (put_nonzero_in_reg_sext64 y))
             (div Reg (a64_sdiv $I64 x64 y64))
@@ -1039,99 +1147,120 @@
 ;; cmp     $x, $y
 ;; csel    .., $x, $y, $cc
 (decl cmp_and_choose (Type Cond bool Value Value) ValueRegs)
-(rule (cmp_and_choose (fits_in_64 ty) cc _ x y)
+(attr cmp_and_choose (veri chain))
+(rule cmp_and_choose_64
+      (cmp_and_choose (fits_in_64 ty) cc _ x y)
       (let ((x Reg (put_in_reg x))
             (y Reg (put_in_reg y)))
        (with_flags_reg (cmp (operand_size ty) x y)
                        (csel cc x y))))
+(attr rule cmp_and_choose_8_16 (veri priority))
 
 ;; `i16` and `i8` min/max require sign extension as
 ;; the comparison operates on (at least) 32 bits.
-(rule 1 (cmp_and_choose (fits_in_16 ty) cc signed x y)
+(rule cmp_and_choose_8_16
+      1 (cmp_and_choose (fits_in_16 ty) cc signed x y)
       (let ((x Reg (extend (put_in_reg x) signed (ty_bits ty) 32))
             (y Reg (extend (put_in_reg y) signed (ty_bits ty) 32)))
       (with_flags_reg (cmp (operand_size ty) x y)
                       (csel cc x y))))
 
-(rule 2 (lower (has_type (and (fits_in_64 ty) (ty_int _)) (umin x y)))
+(rule umin 2 (lower (has_type (and (fits_in_64 ty) (ty_int _)) (umin _ x y)))
       (cmp_and_choose ty (Cond.Lo) $false x y))
-(rule 2 (lower (has_type (and (fits_in_64 ty) (ty_int _)) (smin x y)))
+(rule smin 2 (lower (has_type (and (fits_in_64 ty) (ty_int _)) (smin _ x y)))
       (cmp_and_choose ty (Cond.Lt) $true x y))
-(rule 2 (lower (has_type (and (fits_in_64 ty) (ty_int _)) (umax x y)))
+(rule umax 2 (lower (has_type (and (fits_in_64 ty) (ty_int _)) (umax _ x y)))
       (cmp_and_choose ty (Cond.Hi) $false x y))
-(rule 2 (lower (has_type (and (fits_in_64 ty) (ty_int _)) (smax x y)))
+(rule smax 2 (lower (has_type (and (fits_in_64 ty) (ty_int _)) (smax _ x y)))
       (cmp_and_choose ty (Cond.Gt) $true x y))
 
 ;; Vector types.
 
-(rule (lower (has_type ty @ (not_i64x2) (smin x y)))
+(rule (lower (has_type ty @ (not_i64x2) (smin _ x y)))
       (vec_rrr (VecALUOp.Smin) x y (vector_size ty)))
 
-(rule 1 (lower (has_type $I64X2 (smin x y)))
+(rule 1 (lower (has_type $I64X2 (smin _ x y)))
       (bsl $I64X2 (vec_rrr (VecALUOp.Cmgt) y x (VectorSize.Size64x2)) x y))
 
-(rule (lower (has_type ty @ (not_i64x2) (umin x y)))
+(rule (lower (has_type ty @ (not_i64x2) (umin _ x y)))
       (vec_rrr (VecALUOp.Umin) x y (vector_size ty)))
 
-(rule 1 (lower (has_type $I64X2 (umin x y)))
+(rule 1 (lower (has_type $I64X2 (umin _ x y)))
       (bsl $I64X2 (vec_rrr (VecALUOp.Cmhi) y x (VectorSize.Size64x2)) x y))
 
-(rule (lower (has_type ty @ (not_i64x2) (smax x y)))
+(rule (lower (has_type ty @ (not_i64x2) (smax _ x y)))
       (vec_rrr (VecALUOp.Smax) x y (vector_size ty)))
 
-(rule 1 (lower (has_type $I64X2 (smax x y)))
+(rule 1 (lower (has_type $I64X2 (smax _ x y)))
       (bsl $I64X2 (vec_rrr (VecALUOp.Cmgt) x y (VectorSize.Size64x2)) x y))
 
-(rule (lower (has_type ty @ (not_i64x2) (umax x y)))
+(rule (lower (has_type ty @ (not_i64x2) (umax _ x y)))
       (vec_rrr (VecALUOp.Umax) x y (vector_size ty)))
 
-(rule 1 (lower (has_type $I64X2 (umax x y)))
+(rule 1 (lower (has_type $I64X2 (umax _ x y)))
       (bsl $I64X2 (vec_rrr (VecALUOp.Cmhi) x y (VectorSize.Size64x2)) x y))
 
 ;;;; Rules for `uextend` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; General rule for extending input to an output which fits in a single
 ;; register.
-(rule -2 (lower (has_type (fits_in_64 out) (uextend x @ (value_type in))))
+(rule uextend -2 (lower (has_type (fits_in_64 out) (uextend _ x @ (value_type in))))
       (extend x $false (ty_bits in) (ty_bits out)))
 
 ;; Extraction of a vector lane automatically extends as necessary, so we can
 ;; skip an explicit extending instruction.
 (rule 1 (lower (has_type (fits_in_64 out)
-                       (uextend (extractlane vec @ (value_type in)
+                       (uextend _ (extractlane _ vec @ (value_type in)
                                              (u8_from_uimm8 lane)))))
       (mov_from_vec (put_in_reg vec) lane (lane_size in)))
 
 ;; Atomic loads will also automatically zero their upper bits so the `uextend`
 ;; instruction can effectively get skipped here.
 (rule 1 (lower (has_type (fits_in_64 out)
-                       (uextend x @ (and (value_type in) (atomic_load flags _)))))
+                       (uextend _ x @ (and (value_type in) (atomic_load _ flags _)))))
       (if-let mem_op (is_sinkable_inst x))
       (load_acquire in flags (sink_atomic_load mem_op)))
 
 ;; Conversion to 128-bit needs a zero-extension of the lower bits and the upper
 ;; bits are all zero.
-(rule -1 (lower (has_type $I128 (uextend x)))
+(rule uextend_i128
+      -1 (lower (has_type $I128 (uextend _ x)))
       (value_regs (put_in_reg_zext64 x) (imm $I64 (ImmExtend.Zero) 0)))
+(attr rule uextend_i128 (tag i128))
 
 ;; Like above where vector extraction automatically zero-extends extending to
 ;; i128 only requires generating a 0 constant for the upper bits.
 (rule (lower (has_type $I128
-                       (uextend (extractlane vec @ (value_type in)
+                       (uextend _ (extractlane _ vec @ (value_type in)
                                              (u8_from_uimm8 lane)))))
       (value_regs (mov_from_vec (put_in_reg vec) lane (lane_size in)) (imm $I64 (ImmExtend.Zero) 0)))
 
+;; Zero extensions from a load can be encoded in the load itself
+(rule uextend_load (lower (has_type (fits_in_64 _) (uextend _ x @ (has_type in_ty (load _ flags address offset)))))
+      (if-let inst (is_sinkable_inst x))
+      (let ((_ Unit (sink_inst inst)))
+            (aarch64_uload in_ty (amode in_ty address offset) flags)))
+
+; Slow verification due to large number of expansions.
+(attr rule uextend_load (tag slow))
+
+(decl aarch64_uload (Type AMode MemFlags) Reg)
+(attr aarch64_uload (veri chain))
+(rule (aarch64_uload $I8 amode flags) (aarch64_uload8 amode flags))
+(rule (aarch64_uload $I16 amode flags) (aarch64_uload16 amode flags))
+(rule (aarch64_uload $I32 amode flags) (aarch64_uload32 amode flags))
+
 ;;;; Rules for `sextend` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; General rule for extending input to an output which fits in a single
 ;; register.
-(rule -4 (lower (has_type (fits_in_64 out) (sextend x @ (value_type in))))
+(rule sextend -4 (lower (has_type (fits_in_64 out) (sextend _ x @ (value_type in))))
       (extend x $true (ty_bits in) (ty_bits out)))
 
 ;; Extraction of a vector lane automatically extends as necessary, so we can
 ;; skip an explicit extending instruction.
 (rule -3 (lower (has_type (fits_in_64 out)
-                       (sextend (extractlane vec @ (value_type in)
+                       (sextend _ (extractlane _ vec @ (value_type in)
                                              (u8_from_uimm8 lane)))))
       (mov_from_vec_signed (put_in_reg vec)
                            lane
@@ -1139,10 +1268,12 @@
                            (size_from_ty out)))
 
 ;; 64-bit to 128-bit only needs to sign-extend the input to the upper bits.
-(rule -2 (lower (has_type $I128 (sextend x)))
+(rule sextend_i128
+      -2 (lower (has_type $I128 (sextend _ x)))
       (let ((lo Reg (put_in_reg_sext64 x))
             (hi Reg (asr_imm $I64 lo (imm_shift_from_u8 63))))
         (value_regs lo hi)))
+(attr rule sextend_i128 (tag i128))
 
 ;; Like above where vector extraction automatically zero-extends extending to
 ;; i128 only requires generating a 0 constant for the upper bits.
@@ -1150,7 +1281,7 @@
 ;; Note that `mov_from_vec_signed` doesn't exist for i64x2, so that's
 ;; specifically excluded here.
 (rule (lower (has_type $I128
-                       (sextend (extractlane vec @ (value_type in @ (not_i64x2))
+                       (sextend _ (extractlane _ vec @ (value_type in @ (not_i64x2))
                                              (u8_from_uimm8 lane)))))
       (let ((lo Reg (mov_from_vec_signed (put_in_reg vec)
                                          lane
@@ -1161,7 +1292,7 @@
 
 ;; Extension from an extraction of i64x2 into i128.
 (rule -1 (lower (has_type $I128
-                       (sextend (extractlane vec @ (value_type $I64X2)
+                       (sextend _ (extractlane _ vec @ (value_type $I64X2)
                                              (u8_from_uimm8 lane)))))
       (let ((lo Reg (mov_from_vec (put_in_reg vec)
                                   lane
@@ -1169,6 +1300,21 @@
             (hi Reg (asr_imm $I64 lo (imm_shift_from_u8 63))))
         (value_regs lo hi)))
 
+;; Signed extensions from a load can be encoded in the load itself
+(rule sextend_load (lower (has_type (fits_in_64 _) (sextend _ x @ (has_type in_ty (load _ flags address offset)))))
+      (if-let inst (is_sinkable_inst x))
+      (let ((_ Unit (sink_inst inst)))
+            (aarch64_sload in_ty (amode in_ty address offset) flags)))
+
+; Slow verification due to large number of expansions.
+(attr rule sextend_load (tag slow))
+
+(decl aarch64_sload (Type AMode MemFlags) Reg)
+(attr aarch64_sload (veri chain))
+(rule (aarch64_sload $I8 amode flags) (aarch64_sload8 amode flags))
+(rule (aarch64_sload $I16 amode flags) (aarch64_sload16 amode flags))
+(rule (aarch64_sload $I32 amode flags) (aarch64_sload32 amode flags))
+
 ;;;; Rules for `bnot` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Base case using `orn` between two registers.
@@ -1176,18 +1322,18 @@
 ;; Note that bitwise negation is implemented here as
 ;;
 ;;      NOT rd, rm ==> ORR_NOT rd, zero, rm
-(rule -1 (lower (has_type (fits_in_64 ty) (bnot x)))
+(rule bnot_base_case -1 (lower (has_type (fits_in_64 ty) (bnot _ x)))
       (orr_not ty (zero_reg) x))
 
 ;; Special case to use `orr_not_shift` if it's a `bnot` of a const-left-shifted
 ;; value.
-(rule 1 (lower (has_type (fits_in_64 ty)
-                       (bnot (ishl x (iconst k)))))
+(rule bnot_ishl 1 (lower (has_type (fits_in_64 ty)
+                       (bnot _ (ishl _ x (iconst _ k)))))
       (if-let amt (lshl_from_imm64 ty k))
       (orr_not_shift ty (zero_reg) x amt))
 
 ;; Implementation of `bnot` for `i128`.
-(rule (lower (has_type $I128 (bnot x)))
+(rule (lower (has_type $I128 (bnot _ x)))
       (let ((x_regs ValueRegs x)
             (x_lo Reg (value_regs_get x_regs 0))
             (x_hi Reg (value_regs_get x_regs 1))
@@ -1196,97 +1342,97 @@
         (value_regs new_lo new_hi)))
 
 ;; Implementation of `bnot` for vector types.
-(rule -2 (lower (has_type (ty_vec128 ty) (bnot x)))
+(rule -2 (lower (has_type (ty_vec128 ty) (bnot _ x)))
       (not x (vector_size ty)))
 
 ;; Special-cases for fusing a bnot with bxor
-(rule 2 (lower (has_type (fits_in_64 ty) (bnot (bxor x y))))
+(rule bnot_bxor 2 (lower (has_type (fits_in_64 ty) (bnot _ (bxor _ x y))))
       (alu_rs_imm_logic (ALUOp.EorNot) ty x y))
-(rule 3 (lower (has_type $I128 (bnot (bxor x y)))) (i128_alu_bitop (ALUOp.EorNot) $I64 x y))
+(rule 3 (lower (has_type $I128 (bnot _ (bxor _ x y)))) (i128_alu_bitop (ALUOp.EorNot) $I64 x y))
 
 ;;;; Rules for `band` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule -1 (lower (has_type (fits_in_64 ty) (band x y)))
+(rule band_fits_in_64 -1 (lower (has_type (fits_in_64 ty) (band _ x y)))
       (alu_rs_imm_logic_commutative (ALUOp.And) ty x y))
 
-(rule (lower (has_type $I128 (band x y))) (i128_alu_bitop (ALUOp.And) $I64 x y))
+(rule (lower (has_type $I128 (band _ x y))) (i128_alu_bitop (ALUOp.And) $I64 x y))
 
-(rule -2 (lower (has_type (ty_vec128 ty) (band x y)))
+(rule -2 (lower (has_type (ty_vec128 ty) (band _ x y)))
       (and_vec x y (vector_size ty)))
 
 ;; Specialized lowerings for `(band x (bnot y))` which is additionally produced
 ;; by Cranelift's `band_not` instruction that is legalized into the simpler
 ;; forms early on.
 
-(rule 1 (lower (has_type (fits_in_64 ty) (band x (bnot y))))
+(rule band_not_right 1 (lower (has_type (fits_in_64 ty) (band _ x (bnot _ y))))
       (alu_rs_imm_logic (ALUOp.AndNot) ty x y))
-(rule 2 (lower (has_type (fits_in_64 ty) (band (bnot y) x)))
+(rule band_not_left 2 (lower (has_type (fits_in_64 ty) (band _ (bnot _ y) x)))
       (alu_rs_imm_logic (ALUOp.AndNot) ty x y))
 
-(rule 3 (lower (has_type $I128 (band x (bnot y)))) (i128_alu_bitop (ALUOp.AndNot) $I64 x y))
-(rule 4 (lower (has_type $I128 (band (bnot y) x))) (i128_alu_bitop (ALUOp.AndNot) $I64 x y))
+(rule 3 (lower (has_type $I128 (band _ x (bnot _ y)))) (i128_alu_bitop (ALUOp.AndNot) $I64 x y))
+(rule 4 (lower (has_type $I128 (band _ (bnot _ y) x))) (i128_alu_bitop (ALUOp.AndNot) $I64 x y))
 
-(rule 5 (lower (has_type (ty_vec128 ty) (band x (bnot y))))
+(rule 5 (lower (has_type (ty_vec128 ty) (band _ x (bnot _ y))))
       (bic_vec x y (vector_size ty)))
-(rule 6 (lower (has_type (ty_vec128 ty) (band (bnot y) x)))
+(rule 6 (lower (has_type (ty_vec128 ty) (band _ (bnot _ y) x)))
       (bic_vec x y (vector_size ty)))
 
 ;;;; Rules for `bor` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule -1 (lower (has_type (fits_in_64 ty) (bor x y)))
+(rule bor_fits_in_64 -1 (lower (has_type (fits_in_64 ty) (bor _ x y)))
       (alu_rs_imm_logic_commutative (ALUOp.Orr) ty x y))
 
-(rule (lower (has_type $I128 (bor x y))) (i128_alu_bitop (ALUOp.Orr) $I64 x y))
+(rule (lower (has_type $I128 (bor _ x y))) (i128_alu_bitop (ALUOp.Orr) $I64 x y))
 
-(rule -2 (lower (has_type (ty_vec128 ty) (bor x y)))
+(rule -2 (lower (has_type (ty_vec128 ty) (bor _ x y)))
       (orr_vec x y (vector_size ty)))
 
 ;; Specialized lowerings for `(bor x (bnot y))` which is additionally produced
 ;; by Cranelift's `bor_not` instruction that is legalized into the simpler
 ;; forms early on.
 
-(rule 1 (lower (has_type (fits_in_64 ty) (bor x (bnot y))))
+(rule bor_not_right 1 (lower (has_type (fits_in_64 ty) (bor _ x (bnot _ y))))
       (alu_rs_imm_logic (ALUOp.OrrNot) ty x y))
-(rule 2 (lower (has_type (fits_in_64 ty) (bor (bnot y) x)))
+(rule bor_not_left 2 (lower (has_type (fits_in_64 ty) (bor _ (bnot _ y) x)))
       (alu_rs_imm_logic (ALUOp.OrrNot) ty x y))
 
-(rule 3 (lower (has_type $I128 (bor x (bnot y)))) (i128_alu_bitop (ALUOp.OrrNot) $I64 x y))
-(rule 4 (lower (has_type $I128 (bor (bnot y) x))) (i128_alu_bitop (ALUOp.OrrNot) $I64 x y))
+(rule 3 (lower (has_type $I128 (bor _ x (bnot _ y)))) (i128_alu_bitop (ALUOp.OrrNot) $I64 x y))
+(rule 4 (lower (has_type $I128 (bor _ (bnot _ y) x))) (i128_alu_bitop (ALUOp.OrrNot) $I64 x y))
 
 ;;;; Rules for `bxor` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule -1 (lower (has_type (fits_in_64 ty) (bxor x y)))
+(rule bxor -1 (lower (has_type (fits_in_64 ty) (bxor _ x y)))
       (alu_rs_imm_logic_commutative (ALUOp.Eor) ty x y))
 
-(rule (lower (has_type $I128 (bxor x y))) (i128_alu_bitop (ALUOp.Eor) $I64 x y))
+(rule (lower (has_type $I128 (bxor _ x y))) (i128_alu_bitop (ALUOp.Eor) $I64 x y))
 
-(rule -2 (lower (has_type (ty_vec128 ty) (bxor x y)))
+(rule -2 (lower (has_type (ty_vec128 ty) (bxor _ x y)))
       (eor_vec x y (vector_size ty)))
 
 ;; Specialized lowerings for `(bxor x (bnot y))` which is additionally produced
 ;; by Cranelift's `bxor_not` instruction that is legalized into the simpler
 ;; forms early on.
 
-(rule 1 (lower (has_type (fits_in_64 ty) (bxor x (bnot y))))
+(rule bxor_not_right 1 (lower (has_type (fits_in_64 ty) (bxor _ x (bnot _ y))))
       (alu_rs_imm_logic (ALUOp.EorNot) ty x y))
-(rule 2 (lower (has_type (fits_in_64 ty) (bxor (bnot y) x)))
+(rule bxor_not_left 2 (lower (has_type (fits_in_64 ty) (bxor _ (bnot _ y) x)))
       (alu_rs_imm_logic (ALUOp.EorNot) ty x y))
 
-(rule 3 (lower (has_type $I128 (bxor x (bnot y)))) (i128_alu_bitop (ALUOp.EorNot) $I64 x y))
-(rule 4 (lower (has_type $I128 (bxor (bnot y) x))) (i128_alu_bitop (ALUOp.EorNot) $I64 x y))
+(rule 3 (lower (has_type $I128 (bxor _ x (bnot _ y)))) (i128_alu_bitop (ALUOp.EorNot) $I64 x y))
+(rule 4 (lower (has_type $I128 (bxor _ (bnot _ y) x))) (i128_alu_bitop (ALUOp.EorNot) $I64 x y))
 
 ;;;; Rules for `ishl` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Shift for i8/i16/i32.
-(rule -1 (lower (has_type (fits_in_32 ty) (ishl x y)))
+(rule ishl_8_16_32 -1 (lower (has_type (fits_in_32 ty) (ishl _ x y)))
       (do_shift (ALUOp.Lsl) ty x y))
 
 ;; Shift for i64.
-(rule (lower (has_type $I64 (ishl x y)))
+(rule ishl_64 (lower (has_type $I64 (ishl _ x y)))
       (do_shift (ALUOp.Lsl) $I64 x y))
 
 ;; Shift for i128.
-(rule (lower (has_type $I128 (ishl x y)))
+(rule (lower (has_type $I128 (ishl _ x y)))
       (lower_shl128 x (value_regs_get y 0)))
 
 ;;     lsl     lo_lshift, src_lo, amt
@@ -1314,14 +1460,15 @@
          (consumes_flags_concat
           (csel (Cond.Ne) (zero_reg) lo_lshift)
           (csel (Cond.Ne) lo_lshift maybe_hi)))))
+(attr rule lower_shl128 (tag i128))
 
 ;; Shift for vector types.
-(rule -3 (lower (has_type (ty_vec128 ty) (ishl x y)))
+(rule -3 (lower (has_type (ty_vec128 ty) (ishl _ x y)))
       (let ((size VectorSize (vector_size ty))
             (masked_shift_amt Reg (and_imm $I32 y (shift_mask ty)))
             (shift Reg (vec_dup masked_shift_amt size)))
         (sshl x shift size)))
-(rule -2 (lower (has_type (ty_vec128 ty) (ishl x (iconst (u64_from_imm64 n)))))
+(rule -2 (lower (has_type (ty_vec128 ty) (ishl _ x (iconst _ (u64_from_imm64 n)))))
         (ushl_vec_imm x (shift_masked_imm ty n) (vector_size ty)))
 
 (decl pure shift_masked_imm (Type u64) u8)
@@ -1334,6 +1481,7 @@
 ;; Note that this automatically handles the clif semantics of masking the
 ;; shift amount where necessary.
 (decl do_shift (ALUOp Type Reg Value) Reg)
+(attr do_shift (veri chain))
 
 ;; 8/16-bit shift base case.
 ;;
@@ -1344,17 +1492,19 @@
 ;; On i32 and i64 types this matches what the aarch64 spec does, but on smaller
 ;; types (i16, i8) we need to do this manually, so we wrap the shift amount
 ;; with an AND instruction
-(rule -1 (do_shift op (fits_in_16 ty) x y)
+(rule do_shift_fits_in_16
+      -1 (do_shift op (fits_in_16 ty) x y)
       (let ((shift_amt Reg (value_regs_get y 0))
             (masked_shift_amt Reg (and_imm $I32 shift_amt (shift_mask ty))))
         (alu_rrr op $I32 x masked_shift_amt)))
 
 (decl shift_mask (Type) ImmLogic)
 (extern constructor shift_mask shift_mask)
+(spec (shift_mask ty) (provide (= result (shift_mask! 64 (:bits ty)))))
 
 ;; 32/64-bit shift base cases.
-(rule (do_shift op $I32 x y) (alu_rrr op $I32 x (value_regs_get y 0)))
-(rule (do_shift op $I64 x y) (alu_rrr op $I64 x (value_regs_get y 0)))
+(rule do_shift_32 (do_shift op $I32 x y) (alu_rrr op $I32 x (value_regs_get y 0)))
+(rule do_shift_64 (do_shift op $I64 x y) (alu_rrr op $I64 x (value_regs_get y 0)))
 
 ;; Special case for shifting by a constant value where the value can fit into an
 ;; `ImmShift`.
@@ -1362,22 +1512,22 @@
 ;; Note that this rule explicitly has a higher priority than the others
 ;; to ensure it's attempted first, otherwise the type-based filters on the
 ;; previous rules seem to take priority over this rule.
-(rule 1 (do_shift op ty x (iconst k))
+(rule do_shift_const 1 (do_shift op ty x (iconst _ k))
       (if-let shift (imm_shift_from_imm64 ty k))
       (alu_rr_imm_shift op ty x shift))
 
 ;;;; Rules for `ushr` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Shift for i8/i16/i32.
-(rule -1 (lower (has_type (fits_in_32 ty) (ushr x y)))
+(rule ushr_8_16_32 -1 (lower (has_type (fits_in_32 ty) (ushr _ x y)))
       (do_shift (ALUOp.Lsr) ty (put_in_reg_zext32 x) y))
 
 ;; Shift for i64.
-(rule (lower (has_type $I64 (ushr x y)))
+(rule ushr_64 (lower (has_type $I64 (ushr _ x y)))
       (do_shift (ALUOp.Lsr) $I64 (put_in_reg_zext64 x) y))
 
 ;; Shift for i128.
-(rule (lower (has_type $I128 (ushr x y)))
+(rule (lower (has_type $I128 (ushr _ x y)))
       (lower_ushr128 x (value_regs_get y 0)))
 
 ;; Vector shifts.
@@ -1385,14 +1535,14 @@
 ;; Note that for constant shifts a 0-width shift can't be emitted so it's
 ;; special cased to pass through the input as-is since a 0-shift doesn't modify
 ;; the input anyway.
-(rule -4 (lower (has_type (ty_vec128 ty) (ushr x y)))
+(rule -4 (lower (has_type (ty_vec128 ty) (ushr _ x y)))
       (let ((size VectorSize (vector_size ty))
             (masked_shift_amt Reg (and_imm $I32 y (shift_mask ty)))
             (shift Reg (vec_dup (sub $I64 (zero_reg) masked_shift_amt) size)))
         (ushl x shift size)))
-(rule -3 (lower (has_type (ty_vec128 ty) (ushr x (iconst (u64_from_imm64 n)))))
+(rule -3 (lower (has_type (ty_vec128 ty) (ushr _ x (iconst _ (u64_from_imm64 n)))))
          (ushr_vec_imm x (shift_masked_imm ty n) (vector_size ty)))
-(rule -2 (lower (has_type (ty_vec128 ty) (ushr x (iconst (u64_from_imm64 n)))))
+(rule -2 (lower (has_type (ty_vec128 ty) (ushr _ x (iconst _ (u64_from_imm64 n)))))
           (if-let 0 (shift_masked_imm ty n))
           x)
 
@@ -1422,19 +1572,20 @@
          (consumes_flags_concat
           (csel (Cond.Ne) hi_rshift maybe_lo)
           (csel (Cond.Ne) (zero_reg) hi_rshift)))))
+(attr rule lower_ushr128 (tag i128))
 
 ;;;; Rules for `sshr` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Shift for i8/i16/i32.
-(rule -4 (lower (has_type (fits_in_32 ty) (sshr x y)))
+(rule sshr_8_16_32 -4 (lower (has_type (fits_in_32 ty) (sshr _ x y)))
       (do_shift (ALUOp.Asr) ty (put_in_reg_sext32 x) y))
 
 ;; Shift for i64.
-(rule (lower (has_type $I64 (sshr x y)))
+(rule sshr_64 (lower (has_type $I64 (sshr _ x y)))
       (do_shift (ALUOp.Asr) $I64 (put_in_reg_sext64 x) y))
 
 ;; Shift for i128.
-(rule (lower (has_type $I128 (sshr x y)))
+(rule (lower (has_type $I128 (sshr _ x y)))
       (lower_sshr128 x (value_regs_get y 0)))
 
 ;; Vector shifts.
@@ -1443,14 +1594,14 @@
 ;; that for constant shifts a 0-width shift can't be emitted so it's special
 ;; cased to pass through the input as-is since a 0-shift doesn't modify the
 ;; input anyway.
-(rule -3 (lower (has_type (ty_vec128 ty) (sshr x y)))
+(rule -3 (lower (has_type (ty_vec128 ty) (sshr _ x y)))
       (let ((size VectorSize (vector_size ty))
             (masked_shift_amt Reg (and_imm $I32 y (shift_mask ty)))
             (shift Reg (vec_dup (sub $I64 (zero_reg) masked_shift_amt) size)))
         (sshl x shift size)))
-(rule -2 (lower (has_type (ty_vec128 ty) (sshr x (iconst (u64_from_imm64 n)))))
+(rule -2 (lower (has_type (ty_vec128 ty) (sshr _ x (iconst _ (u64_from_imm64 n)))))
           (sshr_vec_imm x (shift_masked_imm ty n) (vector_size ty)))
-(rule -1 (lower (has_type (ty_vec128 ty) (sshr x (iconst (u64_from_imm64 n)))))
+(rule -1 (lower (has_type (ty_vec128 ty) (sshr _ x (iconst _ (u64_from_imm64 n)))))
           (if-let 0 (shift_masked_imm ty n))
           x)
 
@@ -1482,17 +1633,18 @@
          (consumes_flags_concat
           (csel (Cond.Ne) hi_rshift maybe_lo)
           (csel (Cond.Ne) hi_sign hi_rshift)))))
+(attr rule lower_sshr128 (tag i128))
 
 ;;;; Rules for `rotl` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; General 8/16-bit case.
-(rule -2 (lower (has_type (fits_in_16 ty) (rotl x y)))
+(rule rotl_fits_in_16 -2 (lower (has_type (fits_in_16 ty) (rotl _ x y)))
       (let ((amt Reg (value_regs_get y 0))
             (neg_shift Reg (sub $I32 (zero_reg) amt)))
         (small_rotr ty (put_in_reg_zext32 x) neg_shift)))
 
 ;; Specialization for the 8/16-bit case when the rotation amount is an immediate.
-(rule -1 (lower (has_type (fits_in_16 ty) (rotl x (iconst k))))
+(rule rotl_fits_in_16_imm -1 (lower (has_type (fits_in_16 ty) (rotl _ x (iconst _ k))))
       (if-let n (imm_shift_from_imm64 ty k))
       (small_rotr_imm ty (put_in_reg_zext32 x) (negate_imm_shift ty n)))
 
@@ -1505,34 +1657,38 @@
 ;; amount.
 
 ;; General 32-bit case.
-(rule (lower (has_type $I32 (rotl x y)))
+(rule rotl_32_base_case (lower (has_type $I32 (rotl _ x y)))
       (let ((amt Reg (value_regs_get y 0))
             (neg_shift Reg (sub $I32 (zero_reg) amt)))
         (a64_rotr $I32 x neg_shift)))
 
 ;; General 64-bit case.
-(rule (lower (has_type $I64 (rotl x y)))
+(rule rotl_64_base_case (lower (has_type $I64 (rotl _ x y)))
       (let ((amt Reg (value_regs_get y 0))
             (neg_shift Reg (sub $I64 (zero_reg) amt)))
         (a64_rotr $I64 x neg_shift)))
 
 ;; Specialization for the 32-bit case when the rotation amount is an immediate.
-(rule 1 (lower (has_type $I32 (rotl x (iconst k))))
+(rule rotl_32_imm 1 (lower (has_type $I32 (rotl _ x (iconst _ k))))
       (if-let n (imm_shift_from_imm64 $I32 k))
       (a64_rotr_imm $I32 x (negate_imm_shift $I32 n)))
 
 ;; Specialization for the 64-bit case when the rotation amount is an immediate.
-(rule 1 (lower (has_type $I64 (rotl x (iconst k))))
+(rule rotl_64_imm 1 (lower (has_type $I64 (rotl _ x (iconst _ k))))
       (if-let n (imm_shift_from_imm64 $I64 k))
       (a64_rotr_imm $I64 x (negate_imm_shift $I64 n)))
 
+(spec (negate_imm_shift ty x)
+   (provide
+     (= result (bvand (bvsub (int2bv 6 (:bits ty)) x) (bvsub (int2bv 6 (:bits ty)) #b000001)))))
+
 (decl negate_imm_shift (Type ImmShift) ImmShift)
 (extern constructor negate_imm_shift negate_imm_shift)
 
 ;; General 128-bit case.
 ;;
 ;; TODO: much better codegen is possible with a constant amount.
-(rule (lower (has_type $I128 (rotl x y)))
+(rule rotl_i128 (lower (has_type $I128 (rotl _ x y)))
       (let ((val ValueRegs x)
             (amt Reg (value_regs_get y 0))
             (neg_amt Reg (sub $I64 (imm $I64 (ImmExtend.Zero) 128) amt))
@@ -1545,29 +1701,29 @@
 ;;;; Rules for `rotr` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; General 8/16-bit case.
-(rule -3 (lower (has_type (fits_in_16 ty) (rotr x y)))
+(rule rotr_fits_in_16 -3 (lower (has_type (fits_in_16 ty) (rotr _ x y)))
       (small_rotr ty (put_in_reg_zext32 x) (value_regs_get y 0)))
 
 ;; General 32-bit case.
-(rule -1 (lower (has_type $I32 (rotr x y)))
+(rule rotr_32_base_case -1 (lower (has_type $I32 (rotr _ x y)))
       (a64_rotr $I32 x (value_regs_get y 0)))
 
 ;; General 64-bit case.
-(rule -1 (lower (has_type $I64 (rotr x y)))
+(rule rotr_64_base_case -1 (lower (has_type $I64 (rotr _ x y)))
       (a64_rotr $I64 x (value_regs_get y 0)))
 
 ;; Specialization for the 8/16-bit case when the rotation amount is an immediate.
-(rule -2 (lower (has_type (fits_in_16 ty) (rotr x (iconst k))))
+(rule rotr_fits_in_16_imm -2 (lower (has_type (fits_in_16 ty) (rotr _ x (iconst _ k))))
       (if-let n (imm_shift_from_imm64 ty k))
       (small_rotr_imm ty (put_in_reg_zext32 x) n))
 
 ;; Specialization for the 32-bit case when the rotation amount is an immediate.
-(rule (lower (has_type $I32 (rotr x (iconst k))))
+(rule rotr_32_imm (lower (has_type $I32 (rotr _ x (iconst _ k))))
       (if-let n (imm_shift_from_imm64 $I32 k))
       (a64_rotr_imm $I32 x n))
 
 ;; Specialization for the 64-bit case when the rotation amount is an immediate.
-(rule (lower (has_type $I64 (rotr x (iconst k))))
+(rule rotr_64_imm (lower (has_type $I64 (rotr _ x (iconst _ k))))
       (if-let n (imm_shift_from_imm64 $I64 k))
       (a64_rotr_imm $I64 x n))
 
@@ -1592,6 +1748,7 @@
             (val_lshift Reg (lsl $I32 val neg_amt)))
         (orr $I32 val_lshift val_rshift)))
 
+(spec (rotr_mask ty) (provide (= (bvsub (int2bv 64 (:bits ty)) #x0000000000000001) result)))
 (decl rotr_mask (Type) ImmLogic)
 (extern constructor rotr_mask rotr_mask)
 
@@ -1610,13 +1767,17 @@
             (val_lshift Reg (lsl_imm $I32 val (rotr_opposite_amount ty amt))))
         (orr $I32 val_lshift val_rshift)))
 
+(spec (rotr_opposite_amount ty x)
+   (provide
+    (= (bvsub (int2bv 6 (:bits ty)) (bvand x (bvsub (int2bv 6 (:bits ty)) #b000001))) result)))
+
 (decl rotr_opposite_amount (Type ImmShift) ImmShift)
 (extern constructor rotr_opposite_amount rotr_opposite_amount)
 
 ;; General 128-bit case.
 ;;
 ;; TODO: much better codegen is possible with a constant amount.
-(rule (lower (has_type $I128 (rotr x y)))
+(rule (lower (has_type $I128 (rotr _ x y)))
       (let ((val ValueRegs x)
             (amt Reg (value_regs_get y 0))
             (neg_amt Reg (sub $I64 (imm $I64 (ImmExtend.Zero) 128) amt))
@@ -1631,37 +1792,39 @@
 ;; Reversing an 8-bit value with a 32-bit bitrev instruction will place
 ;; the reversed result in the highest 8 bits, so we need to shift them down into
 ;; place.
-(rule (lower (has_type $I8 (bitrev x)))
+(rule (lower (has_type $I8 (bitrev _ x)))
       (lsr_imm $I32 (rbit $I32 x) (imm_shift_from_u8 24)))
 
 ;; Reversing an 16-bit value with a 32-bit bitrev instruction will place
 ;; the reversed result in the highest 16 bits, so we need to shift them down into
 ;; place.
-(rule (lower (has_type $I16 (bitrev x)))
+(rule (lower (has_type $I16 (bitrev _ x)))
       (lsr_imm $I32 (rbit $I32 x) (imm_shift_from_u8 16)))
 
-(rule (lower (has_type $I128 (bitrev x)))
+(rule (lower (has_type $I128 (bitrev _ x)))
       (let ((val ValueRegs x)
             (lo_rev Reg (rbit $I64 (value_regs_get val 0)))
             (hi_rev Reg (rbit $I64 (value_regs_get val 1))))
         (value_regs hi_rev lo_rev)))
 
-(rule -1 (lower (has_type ty (bitrev x)))
+(rule -1 (lower (has_type ty (bitrev _ x)))
       (rbit ty x))
 
 
 ;;;; Rules for `clz` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type $I8 (clz x)))
+(rule clz_8 (lower (has_type $I8 (clz _ x)))
       (sub_imm $I32 (a64_clz $I32 (put_in_reg_zext32 x)) (u8_into_imm12 24)))
+(attr rule clz_8 (veri priority))
 
-(rule (lower (has_type $I16 (clz x)))
+(rule clz_16 (lower (has_type $I16 (clz _ x)))
       (sub_imm $I32 (a64_clz $I32 (put_in_reg_zext32 x)) (u8_into_imm12 16)))
+(attr rule clz_16 (veri priority))
 
-(rule (lower (has_type $I128 (clz x)))
+(rule (lower (has_type $I128 (clz _ x)))
       (lower_clz128 x))
 
-(rule -1 (lower (has_type ty (clz x)))
+(rule clz_32_64 -1 (lower (has_type ty (clz _ x)))
       (a64_clz ty x))
 
 ;; clz hi_clz, hi
@@ -1675,6 +1838,7 @@
             (lo_clz Reg (a64_clz $I64 (value_regs_get val 0)))
             (tmp Reg (lsr_imm $I64 hi_clz (imm_shift_from_u8 6))))
         (value_regs (madd $I64 lo_clz tmp hi_clz) (imm $I64 (ImmExtend.Zero) 0))))
+(attr rule lower_clz128 (tag i128))
 
 ;;;; Rules for `ctz` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
@@ -1682,28 +1846,32 @@
 ;; then using a `clz` instruction since the tail zeros are the same as the
 ;; leading zeros of the reversed value.
 
-(rule (lower (has_type $I8 (ctz x)))
+(rule ctz_8 (lower (has_type $I8 (ctz _ x)))
       (a64_clz $I32 (orr_imm $I32 (rbit $I32 x) (u64_into_imm_logic $I32 0x800000))))
+(attr rule ctz_8 (veri priority))
 
-(rule (lower (has_type $I16 (ctz x)))
+(rule ctz_16 (lower (has_type $I16 (ctz _ x)))
       (a64_clz $I32 (orr_imm $I32 (rbit $I32 x) (u64_into_imm_logic $I32 0x8000))))
+(attr rule ctz_16 (veri priority))
 
-(rule (lower (has_type $I128 (ctz x)))
+(rule (lower (has_type $I128 (ctz _ x)))
       (let ((val ValueRegs x)
             (lo Reg (rbit $I64 (value_regs_get val 0)))
             (hi Reg (rbit $I64 (value_regs_get val 1))))
         (lower_clz128 (value_regs hi lo))))
 
-(rule -1 (lower (has_type ty (ctz x)))
+(rule ctz_32_64 -1 (lower (has_type ty (ctz _ x)))
       (a64_clz ty (rbit ty x)))
 
 ;;;; Rules for `cls` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type $I8 (cls x)))
+(rule cls_8 (lower (has_type $I8 (cls _ x)))
       (sub_imm $I32 (a64_cls $I32 (put_in_reg_sext32 x)) (u8_into_imm12 24)))
+(attr rule cls_8 (veri priority))
 
-(rule (lower (has_type $I16 (cls x)))
+(rule cls_16 (lower (has_type $I16 (cls _ x)))
       (sub_imm $I32 (a64_cls $I32 (put_in_reg_sext32 x)) (u8_into_imm12 16)))
+(attr rule cls_16 (veri priority))
 
 ;; cls lo_cls, lo
 ;; cls hi_cls, hi
@@ -1714,7 +1882,7 @@
 ;; csel maybe_lo, lo_sign_bits, xzr, eq
 ;; add  out_lo, maybe_lo, hi_cls
 ;; mov  out_hi, 0
-(rule (lower (has_type $I128 (cls x)))
+(rule (lower (has_type $I128 (cls _ x)))
       (let ((val ValueRegs x)
             (lo Reg (value_regs_get val 0))
             (hi Reg (value_regs_get val 1))
@@ -1728,21 +1896,21 @@
                            (csel (Cond.Eq) lo_sign_bits (zero_reg)))))
         (value_regs (add $I64 maybe_lo hi_cls) (imm $I64 (ImmExtend.Zero) 0))))
 
-(rule -1 (lower (has_type ty (cls x)))
+(rule cls_32_64 -1 (lower (has_type ty (cls _ x)))
       (a64_cls ty x))
 
 ;;;; Rules for `bswap` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type $I16 (bswap x)))
+(rule (lower (has_type $I16 (bswap _ x)))
       (a64_rev16 $I16 x))
 
-(rule (lower (has_type $I32 (bswap x)))
+(rule (lower (has_type $I32 (bswap _ x)))
       (a64_rev32 $I32 x))
 
-(rule (lower (has_type $I64 (bswap x)))
+(rule (lower (has_type $I64 (bswap _ x)))
       (a64_rev64 $I64 x))
 
-(rule (lower (has_type $I128 (bswap x)))
+(rule (lower (has_type $I128 (bswap _ x)))
       (value_regs
        (a64_rev64 $I64 (value_regs_get x 1))
        (a64_rev64 $I64 (value_regs_get x 0))))
@@ -1750,7 +1918,7 @@
 ;;;; Rules for `bmask` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Bmask tests the value against zero, and uses `csetm` to assert the result.
-(rule (lower (has_type out_ty (bmask x @ (value_type in_ty))))
+(rule (lower (has_type out_ty (bmask _ x @ (value_type in_ty))))
       (lower_bmask out_ty in_ty x))
 
 ;;;; Rules for `popcnt` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -1772,50 +1940,52 @@
 ;;     if ty == i128:
 ;;         mov out_hi, 0
 
-(rule (lower (has_type $I8 (popcnt x)))
+(rule popcnt_8 (lower (has_type $I8 (popcnt _ x)))
       (let ((tmp Reg (mov_to_fpu x (ScalarSize.Size32)))
             (nbits Reg (vec_cnt tmp (VectorSize.Size8x8))))
         (mov_from_vec nbits 0 (ScalarSize.Size8))))
 
 ;; Note that this uses `addp` instead of `addv` as it's usually cheaper.
-(rule (lower (has_type $I16 (popcnt x)))
+(rule popcnt_16 (lower (has_type $I16 (popcnt _ x)))
       (let ((tmp Reg (mov_to_fpu x (ScalarSize.Size32)))
             (nbits Reg (vec_cnt tmp (VectorSize.Size8x8)))
             (added Reg (addp nbits nbits (VectorSize.Size8x8))))
         (mov_from_vec added 0 (ScalarSize.Size8))))
 
-(rule (lower (has_type $I32 (popcnt x)))
+(rule popcnt_32 (lower (has_type $I32 (popcnt _ x)))
       (let ((tmp Reg (mov_to_fpu x (ScalarSize.Size32)))
             (nbits Reg (vec_cnt tmp (VectorSize.Size8x8)))
             (added Reg (addv nbits (VectorSize.Size8x8))))
         (mov_from_vec added 0 (ScalarSize.Size8))))
 
-(rule (lower (has_type $I64 (popcnt x)))
+(rule popcnt_64 (lower (has_type $I64 (popcnt _ x)))
       (let ((tmp Reg (mov_to_fpu x (ScalarSize.Size64)))
             (nbits Reg (vec_cnt tmp (VectorSize.Size8x8)))
             (added Reg (addv nbits (VectorSize.Size8x8))))
         (mov_from_vec added 0 (ScalarSize.Size8))))
 
-(rule (lower (has_type $I128 (popcnt x)))
+(rule popcnt_i128 (lower (has_type $I128 (popcnt _ x)))
       (let ((val ValueRegs x)
             (tmp_half Reg (mov_to_fpu (value_regs_get val 0) (ScalarSize.Size64)))
             (tmp Reg (mov_to_vec tmp_half (value_regs_get val 1) 1 (VectorSize.Size64x2)))
             (nbits Reg (vec_cnt tmp (VectorSize.Size8x16)))
             (added Reg (addv nbits (VectorSize.Size8x16))))
         (value_regs (mov_from_vec added 0 (ScalarSize.Size8)) (imm $I64 (ImmExtend.Zero) 0))))
+(attr rule popcnt_i128 (tag i128))
 
-(rule (lower (has_type $I8X16 (popcnt x)))
+(rule popcnt_8x16 (lower (has_type $I8X16 (popcnt _ x)))
       (vec_cnt x (VectorSize.Size8x16)))
+(attr rule popcnt_8x16 (tag vector))
 
 ;;;; Rules for `bitselect` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type ty (bitselect c x y)))
+(rule bitselect (lower (has_type ty (bitselect _ c x y)))
       (if (ty_int_ref_scalar_64 ty))
       (let ((tmp1 Reg (and_reg ty x c))
             (tmp2 Reg (bic ty y c)))
         (orr ty tmp1 tmp2)))
 
-(rule 1 (lower (has_type (ty_vec128 ty) (bitselect c x y)))
+(rule 1 (lower (has_type (ty_vec128 ty) (bitselect _ c x y)))
         (bsl ty c x y))
 
 ;;;; Rules for `ireduce` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -1823,72 +1993,72 @@
 ;; T -> I{64,32,16,8}: We can simply pass through the value: values
 ;; are always stored with high bits undefined, so we can just leave
 ;; them be.
-(rule (lower (has_type ty (ireduce src)))
+(rule ireduce (lower (has_type ty (ireduce _ src)))
     (if (ty_int_ref_scalar_64 ty))
     (value_regs_get src 0))
 
 ;;;; Rules for `fcmp` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 4 (lower (has_type ty @ (multi_lane _ _) (fcmp (fcmp_zero_cond_not_eq cond) x y)))
+(rule 4 (lower (has_type ty @ (multi_lane _ _) (fcmp _ (fcmp_zero_cond_not_eq cond) x y)))
       (if (zero_value y))
       (let ((rn Reg x)
             (vec_size VectorSize (vector_size ty)))
           (value_reg (not (fcmeq0 rn vec_size) vec_size))))
 
-(rule 3 (lower (has_type ty @ (multi_lane _ _) (fcmp (fcmp_zero_cond cond) x y)))
+(rule 3 (lower (has_type ty @ (multi_lane _ _) (fcmp _ (fcmp_zero_cond cond) x y)))
       (if (zero_value y))
       (let ((rn Reg x)
             (vec_size VectorSize (vector_size ty)))
           (value_reg (float_cmp_zero cond rn vec_size))))
 
-(rule 2 (lower (has_type ty @ (multi_lane _ _) (fcmp (fcmp_zero_cond_not_eq cond) x y)))
+(rule 2 (lower (has_type ty @ (multi_lane _ _) (fcmp _ (fcmp_zero_cond_not_eq cond) x y)))
       (if (zero_value x))
       (let ((rn Reg y)
             (vec_size VectorSize (vector_size ty)))
           (value_reg (not (fcmeq0 rn vec_size) vec_size))))
 
-(rule 1 (lower (has_type ty @ (multi_lane _ _) (fcmp (fcmp_zero_cond cond) x y)))
+(rule 1 (lower (has_type ty @ (multi_lane _ _) (fcmp _ (fcmp_zero_cond cond) x y)))
       (if (zero_value x))
       (let ((rn Reg y)
             (vec_size VectorSize (vector_size ty)))
           (value_reg (float_cmp_zero_swap cond rn vec_size))))
 
-(rule 0 (lower (has_type out_ty
-              (fcmp cond x @ (value_type (ty_scalar_float in_ty)) y)))
+(rule fcmp 0 (lower (has_type out_ty
+              (fcmp _ cond x @ (value_type (ty_scalar_float in_ty)) y)))
       (with_flags (fpu_cmp (scalar_size in_ty) x y)
                   (materialize_bool_result (fp_cond_code cond))))
 
-(rule -1 (lower (has_type out_ty (fcmp cond x @ (value_type in_ty) y)))
+(rule -1 (lower (has_type out_ty (fcmp _ cond x @ (value_type in_ty) y)))
       (if (ty_vector_float in_ty))
       (vec_cmp x y in_ty (fp_cond_code cond)))
 
 ;;;; Rules for `icmp` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 3 (lower (has_type ty @ (multi_lane _ _) (icmp (icmp_zero_cond_not_eq cond) x y)))
+(rule 3 (lower (has_type ty @ (multi_lane _ _) (icmp _ (icmp_zero_cond_not_eq cond) x y)))
       (if (zero_value y))
       (let ((rn Reg x)
             (vec_size VectorSize (vector_size ty)))
           (value_reg (not (cmeq0 rn vec_size) vec_size))))
 
-(rule 2 (lower (has_type ty @ (multi_lane _ _) (icmp (icmp_zero_cond cond) x y)))
+(rule 2 (lower (has_type ty @ (multi_lane _ _) (icmp _ (icmp_zero_cond cond) x y)))
       (if (zero_value y))
       (let ((rn Reg x)
             (vec_size VectorSize (vector_size ty)))
           (value_reg (int_cmp_zero cond rn vec_size))))
 
-(rule 1 (lower (has_type ty @ (multi_lane _ _) (icmp (icmp_zero_cond_not_eq cond) x y)))
+(rule 1 (lower (has_type ty @ (multi_lane _ _) (icmp _ (icmp_zero_cond_not_eq cond) x y)))
       (if (zero_value x))
       (let ((rn Reg y)
             (vec_size VectorSize (vector_size ty)))
           (value_reg (not (cmeq0 rn vec_size) vec_size))))
 
-(rule 0 (lower (has_type ty @ (multi_lane _ _) (icmp (icmp_zero_cond cond) x y)))
+(rule 0 (lower (has_type ty @ (multi_lane _ _) (icmp _ (icmp_zero_cond cond) x y)))
       (if (zero_value x))
       (let ((rn Reg y)
             (vec_size VectorSize (vector_size ty)))
           (value_reg (int_cmp_zero_swap cond rn vec_size))))
 
-(rule -1 (lower (icmp cond x @ (value_type in_ty) y))
+(rule icmp -1 (lower (icmp _ cond x @ (value_type in_ty) y))
       (lower_icmp_into_reg cond x y in_ty $I8))
 
 ;;;; Rules for `trap` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -1896,15 +2066,10 @@
 (rule (lower (trap trap_code))
       (side_effect (udf trap_code)))
 
-;;;; Rules for `resumable_trap` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(rule (lower (resumable_trap trap_code))
-      (side_effect (udf trap_code)))
-
 ;;;; Rules for `select` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (rule (lower (has_type ty
-                       (select (maybe_uextend (icmp cc
+                       (select _ (maybe_uextend (icmp _ cc
                                                     x @ (value_type in_ty)
                                                     y))
                                rn
@@ -1917,7 +2082,7 @@
                      rm)))
 
 (rule (lower (has_type ty
-                       (select (maybe_uextend (fcmp cc x @ (value_type in_ty) y))
+                       (select _ (maybe_uextend (fcmp _ cc x @ (value_type in_ty) y))
                                rn
                                rm)))
       (let ((cond Cond (fp_cond_code cc)))
@@ -1925,25 +2090,25 @@
         (fpu_cmp (scalar_size in_ty) x y)
         cond ty rn rm)))
 
-(rule -1 (lower (has_type ty (select rcond @ (value_type $I8) rn rm)))
+(rule -1 (lower (has_type ty (select _ rcond @ (value_type $I8) rn rm)))
       (let ((rcond Reg rcond))
        (lower_select
          (tst_imm $I32 rcond (u64_into_imm_logic $I32 255))
          (Cond.Ne) ty rn rm)))
 
-(rule -2 (lower (has_type ty (select rcond @ (value_type (fits_in_32 _)) rn rm)))
+(rule -2 (lower (has_type ty (select _ rcond @ (value_type (fits_in_32 _)) rn rm)))
       (let ((rcond Reg (put_in_reg_zext32 rcond)))
        (lower_select
         (cmp (OperandSize.Size32) rcond (zero_reg))
         (Cond.Ne) ty rn rm)))
 
-(rule -3 (lower (has_type ty (select rcond @ (value_type (fits_in_64 _)) rn rm)))
+(rule -3 (lower (has_type ty (select _ rcond @ (value_type (fits_in_64 _)) rn rm)))
       (let ((rcond Reg (put_in_reg_zext64 rcond)))
        (lower_select
         (cmp (OperandSize.Size64) rcond (zero_reg))
         (Cond.Ne) ty rn rm)))
 
-(rule -4 (lower (has_type ty (select rcond @ (value_type $I128) rn rm)))
+(rule -4 (lower (has_type ty (select _ rcond @ (value_type $I128) rn rm)))
       (let ((c ValueRegs (put_in_regs rcond))
             (c_lo Reg (value_regs_get c 0))
             (c_hi Reg (value_regs_get c 1))
@@ -1955,7 +2120,7 @@
 ;;;; Rules for `select_spectre_guard` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (rule (lower (has_type ty
-                       (select_spectre_guard (maybe_uextend (icmp cc x @ (value_type in_ty) y))
+                       (select_spectre_guard _ (maybe_uextend (icmp _ cc x @ (value_type in_ty) y))
                                              if_true
                                              if_false)))
       (let ((comparison FlagsAndCC (lower_icmp_into_flags cc x y in_ty))
@@ -1968,13 +2133,13 @@
             (_ InstOutput (side_effect (csdb))))
        dst))
 
-(rule -1 (lower (has_type ty (select_spectre_guard rcond @ (value_type (fits_in_64 _)) rn rm)))
+(rule -1 (lower (has_type ty (select_spectre_guard _ rcond @ (value_type (fits_in_64 _)) rn rm)))
       (let ((rcond Reg (put_in_reg_zext64 rcond)))
        (lower_select
         (cmp (OperandSize.Size64) rcond (zero_reg))
         (Cond.Ne) ty rn rm)))
 
-(rule -2 (lower (has_type ty (select_spectre_guard rcond @ (value_type $I128) rn rm)))
+(rule -2 (lower (has_type ty (select_spectre_guard _ rcond @ (value_type $I128) rn rm)))
       (let ((c ValueRegs (put_in_regs rcond))
             (c_lo Reg (value_regs_get c 0))
             (c_hi Reg (value_regs_get c 1))
@@ -1985,41 +2150,41 @@
 
 ;;;; Rules for `vconst` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type (ty_vec128 _) (vconst (u128_from_constant x))))
+(rule (lower (has_type (ty_vec128 _) (vconst _ (u128_from_constant x))))
       (constant_f128 x))
 
-(rule 1 (lower (has_type ty (vconst (u64_from_constant x))))
+(rule 1 (lower (has_type ty (vconst _ (u64_from_constant x))))
       (if (ty_vec64 ty))
       (constant_f64 x))
 
 ;;;; Rules for `splat` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule -1 (lower (has_type ty (splat x @ (value_type in_ty))))
+(rule -1 (lower (has_type ty (splat _ x @ (value_type in_ty))))
       (if (ty_int_ref_scalar_64 in_ty))
       (vec_dup x (vector_size ty)))
 
-(rule -2 (lower (has_type ty (splat x @ (value_type (ty_scalar_float _)))))
+(rule -2 (lower (has_type ty (splat _ x @ (value_type (ty_scalar_float _)))))
       (vec_dup_from_fpu x (vector_size ty) 0))
 
-(rule (lower (has_type ty (splat (f32const (u32_from_ieee32 n)))))
+(rule (lower (has_type ty (splat _ (f32const _ (u32_from_ieee32 n)))))
       (splat_const n (vector_size ty)))
 
-(rule (lower (has_type ty (splat (f64const (u64_from_ieee64 n)))))
+(rule (lower (has_type ty (splat _ (f64const _ (u64_from_ieee64 n)))))
       (splat_const n (vector_size ty)))
 
-(rule (lower (has_type ty (splat (iconst (u64_from_imm64 n)))))
+(rule (lower (has_type ty (splat _ (iconst _ (u64_from_imm64 n)))))
       (splat_const n (vector_size ty)))
 
-(rule (lower (has_type ty (splat (ireduce (iconst (u64_from_imm64 n))))))
+(rule (lower (has_type ty (splat _ (ireduce _ (iconst _ (u64_from_imm64 n))))))
       (splat_const n (vector_size ty)))
 
-(rule (lower (has_type ty (splat x @ (load flags _ _))))
+(rule (lower (has_type ty (splat _ x @ (load _ flags _ _))))
       (if-let mem_op (is_sinkable_inst x))
       (let ((addr Reg (sink_load_into_addr (lane_type ty) mem_op)))
             (ld1r addr (vector_size ty) flags)))
 
 ;;;; Rules for `AtomicLoad` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule (lower (has_type (valid_atomic_transaction ty) (atomic_load flags addr)))
+(rule (lower (has_type (valid_atomic_transaction ty) (atomic_load _ flags addr)))
       (load_acquire ty flags addr))
 
 
@@ -2033,116 +2198,116 @@
 
 (rule 1 (lower (and (use_lse)
                   (has_type (valid_atomic_transaction ty)
-                      (atomic_rmw flags (AtomicRmwOp.Add) addr src))))
+                      (atomic_rmw _ flags (AtomicRmwOp.Add) addr src))))
       (lse_atomic_rmw (AtomicRMWOp.Add) addr src ty flags))
 (rule 1 (lower (and (use_lse)
                   (has_type (valid_atomic_transaction ty)
-                      (atomic_rmw flags (AtomicRmwOp.Xor) addr src))))
+                      (atomic_rmw _ flags (AtomicRmwOp.Xor) addr src))))
       (lse_atomic_rmw (AtomicRMWOp.Eor) addr src ty flags))
 (rule 1 (lower (and (use_lse)
                   (has_type (valid_atomic_transaction ty)
-                      (atomic_rmw flags (AtomicRmwOp.Or) addr src))))
+                      (atomic_rmw _ flags (AtomicRmwOp.Or) addr src))))
       (lse_atomic_rmw (AtomicRMWOp.Set) addr src ty flags))
 (rule 1 (lower (and (use_lse)
                   (has_type (valid_atomic_transaction ty)
-                      (atomic_rmw flags (AtomicRmwOp.Smax) addr src))))
+                      (atomic_rmw _ flags (AtomicRmwOp.Smax) addr src))))
       (lse_atomic_rmw (AtomicRMWOp.Smax) addr src ty flags))
 (rule 1 (lower (and (use_lse)
                   (has_type (valid_atomic_transaction ty)
-                      (atomic_rmw flags (AtomicRmwOp.Smin) addr src))))
+                      (atomic_rmw _ flags (AtomicRmwOp.Smin) addr src))))
       (lse_atomic_rmw (AtomicRMWOp.Smin) addr src ty flags))
 (rule 1 (lower (and (use_lse)
                   (has_type (valid_atomic_transaction ty)
-                      (atomic_rmw flags (AtomicRmwOp.Umax) addr src))))
+                      (atomic_rmw _ flags (AtomicRmwOp.Umax) addr src))))
       (lse_atomic_rmw (AtomicRMWOp.Umax) addr src ty flags))
 (rule 1 (lower (and (use_lse)
                   (has_type (valid_atomic_transaction ty)
-                      (atomic_rmw flags (AtomicRmwOp.Umin) addr src))))
+                      (atomic_rmw _ flags (AtomicRmwOp.Umin) addr src))))
       (lse_atomic_rmw (AtomicRMWOp.Umin) addr src ty flags))
 (rule 1 (lower (and (use_lse)
                   (has_type (valid_atomic_transaction ty)
-                      (atomic_rmw flags (AtomicRmwOp.Sub) addr src))))
+                      (atomic_rmw _ flags (AtomicRmwOp.Sub) addr src))))
       (lse_atomic_rmw (AtomicRMWOp.Add) addr (sub ty (zero_reg) src) ty flags))
 (rule 1 (lower (and (use_lse)
                   (has_type (valid_atomic_transaction ty)
-                      (atomic_rmw flags (AtomicRmwOp.And) addr src))))
+                      (atomic_rmw _ flags (AtomicRmwOp.And) addr src))))
       (lse_atomic_rmw (AtomicRMWOp.Clr) addr (eon ty src (zero_reg)) ty flags))
 
 
 (rule (lower (has_type (valid_atomic_transaction ty)
-             (atomic_rmw flags (AtomicRmwOp.Add) addr src)))
+             (atomic_rmw _ flags (AtomicRmwOp.Add) addr src)))
       (atomic_rmw_loop (AtomicRMWLoopOp.Add) addr src ty flags))
 (rule (lower (has_type (valid_atomic_transaction ty)
-             (atomic_rmw flags (AtomicRmwOp.Sub) addr src)))
+             (atomic_rmw _ flags (AtomicRmwOp.Sub) addr src)))
       (atomic_rmw_loop (AtomicRMWLoopOp.Sub) addr src ty flags))
 (rule (lower (has_type (valid_atomic_transaction ty)
-             (atomic_rmw flags (AtomicRmwOp.And) addr src)))
+             (atomic_rmw _ flags (AtomicRmwOp.And) addr src)))
       (atomic_rmw_loop (AtomicRMWLoopOp.And) addr src ty flags))
 (rule (lower (has_type (valid_atomic_transaction ty)
-             (atomic_rmw flags (AtomicRmwOp.Nand) addr src)))
+             (atomic_rmw _ flags (AtomicRmwOp.Nand) addr src)))
       (atomic_rmw_loop (AtomicRMWLoopOp.Nand) addr src ty flags))
 (rule (lower (has_type (valid_atomic_transaction ty)
-             (atomic_rmw flags (AtomicRmwOp.Or) addr src)))
+             (atomic_rmw _ flags (AtomicRmwOp.Or) addr src)))
       (atomic_rmw_loop (AtomicRMWLoopOp.Orr) addr src ty flags))
 (rule (lower (has_type (valid_atomic_transaction ty)
-             (atomic_rmw flags (AtomicRmwOp.Xor) addr src)))
+             (atomic_rmw _ flags (AtomicRmwOp.Xor) addr src)))
       (atomic_rmw_loop (AtomicRMWLoopOp.Eor) addr src ty flags))
 (rule (lower (has_type (valid_atomic_transaction ty)
-             (atomic_rmw flags (AtomicRmwOp.Smin) addr src)))
+             (atomic_rmw _ flags (AtomicRmwOp.Smin) addr src)))
       (atomic_rmw_loop (AtomicRMWLoopOp.Smin) addr src ty flags))
 (rule (lower (has_type (valid_atomic_transaction ty)
-             (atomic_rmw flags (AtomicRmwOp.Smax) addr src)))
+             (atomic_rmw _ flags (AtomicRmwOp.Smax) addr src)))
       (atomic_rmw_loop (AtomicRMWLoopOp.Smax) addr src ty flags))
 (rule (lower (has_type (valid_atomic_transaction ty)
-             (atomic_rmw flags (AtomicRmwOp.Umin) addr src)))
+             (atomic_rmw _ flags (AtomicRmwOp.Umin) addr src)))
       (atomic_rmw_loop (AtomicRMWLoopOp.Umin) addr src ty flags))
 (rule (lower (has_type (valid_atomic_transaction ty)
-             (atomic_rmw flags (AtomicRmwOp.Umax) addr src)))
+             (atomic_rmw _ flags (AtomicRmwOp.Umax) addr src)))
       (atomic_rmw_loop (AtomicRMWLoopOp.Umax) addr src ty flags))
 (rule (lower (has_type (valid_atomic_transaction ty)
-             (atomic_rmw flags (AtomicRmwOp.Xchg) addr src)))
+             (atomic_rmw _ flags (AtomicRmwOp.Xchg) addr src)))
       (atomic_rmw_loop (AtomicRMWLoopOp.Xchg) addr src ty flags))
 
 ;;;; Rules for `AtomicCAS` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (rule 1 (lower (and (use_lse)
                   (has_type (valid_atomic_transaction ty)
-                  (atomic_cas flags addr src1 src2))))
+                  (atomic_cas _ flags addr src1 src2))))
       (lse_atomic_cas addr src1 src2 ty flags))
 
 (rule (lower (and (has_type (valid_atomic_transaction ty)
-                  (atomic_cas flags addr src1 src2))))
+                  (atomic_cas _ flags addr src1 src2))))
       (atomic_cas_loop addr src1 src2 ty flags))
 
 ;;;; Rules for 'fvdemote' ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule (lower (fvdemote x))
+(rule (lower (fvdemote _ x))
       (fcvtn x (ScalarSize.Size32)))
 
 
 ;;;; Rules for `snarrow` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule 1 (lower (has_type (ty_vec128_int ty) (snarrow x y)))
+(rule 1 (lower (has_type (ty_vec128_int ty) (snarrow _ x y)))
       (if (zero_value y))
       (sqxtn x (lane_size ty)))
 
-(rule 2 (lower (has_type (ty_vec64_int ty) (snarrow x y)))
+(rule 2 (lower (has_type (ty_vec64_int ty) (snarrow _ x y)))
       (let ((dst Reg (mov_vec_elem x y 1 0 (VectorSize.Size64x2))))
             (sqxtn dst (lane_size ty))))
 
-(rule 0 (lower (has_type (ty_vec128_int ty) (snarrow x y)))
+(rule 0 (lower (has_type (ty_vec128_int ty) (snarrow _ x y)))
       (let ((low_half Reg (sqxtn x (lane_size ty)))
             (result Reg (sqxtn2 low_half y (lane_size ty))))
         result))
 
 
 ;;;; Rules for `unarrow` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule 1 (lower (has_type (ty_vec128_int ty) (unarrow x y)))
+(rule 1 (lower (has_type (ty_vec128_int ty) (unarrow _ x y)))
       (if (zero_value y))
       (sqxtun x (lane_size ty)))
 
-(rule 2 (lower (has_type (ty_vec64_int ty) (unarrow x y)))
+(rule 2 (lower (has_type (ty_vec64_int ty) (unarrow _ x y)))
       (let ((dst Reg (mov_vec_elem x y 1 0 (VectorSize.Size64x2))))
             (sqxtun dst (lane_size ty))))
 
-(rule 0 (lower (has_type (ty_vec128_int ty) (unarrow x y)))
+(rule 0 (lower (has_type (ty_vec128_int ty) (unarrow _ x y)))
       (let ((low_half Reg (sqxtun x (lane_size ty)))
             (result Reg (sqxtun2 low_half y (lane_size ty))))
         result))
@@ -2150,45 +2315,45 @@
 
 ;;;; Rules for `uunarrow` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 1 (lower (has_type (ty_vec128_int ty) (uunarrow x y)))
+(rule 1 (lower (has_type (ty_vec128_int ty) (uunarrow _ x y)))
       (if (zero_value y))
       (uqxtn x (lane_size ty)))
 
-(rule 2 (lower (has_type (ty_vec64_int ty) (uunarrow x y)))
+(rule 2 (lower (has_type (ty_vec64_int ty) (uunarrow _ x y)))
       (let ((dst Reg (mov_vec_elem x y 1 0 (VectorSize.Size64x2))))
             (uqxtn dst (lane_size ty))))
 
-(rule 0 (lower (has_type (ty_vec128_int ty) (uunarrow x y)))
+(rule 0 (lower (has_type (ty_vec128_int ty) (uunarrow _ x y)))
       (let ((low_half Reg (uqxtn x (lane_size ty)))
             (result Reg (uqxtn2 low_half y (lane_size ty))))
         result))
 
 ;;;; Rules for `swiden_low` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type ty (swiden_low x)))
+(rule (lower (has_type ty (swiden_low _ x)))
       (vec_extend (VecExtendOp.Sxtl) x $false (lane_size ty)))
 
 ;;;; Rules for `swiden_high` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 1 (lower (has_type (ty_vec128 ty) (swiden_high x)))
+(rule 1 (lower (has_type (ty_vec128 ty) (swiden_high _ x)))
       (vec_extend (VecExtendOp.Sxtl) x $true (lane_size ty)))
 
-(rule (lower (has_type ty (swiden_high x)))
+(rule (lower (has_type ty (swiden_high _ x)))
       (if (ty_vec64 ty))
       (let ((tmp Reg (fpu_move_from_vec x 1 (VectorSize.Size32x2))))
        (vec_extend (VecExtendOp.Sxtl) tmp $false (lane_size ty))))
 
 ;;;; Rules for `uwiden_low` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type ty (uwiden_low x)))
+(rule (lower (has_type ty (uwiden_low _ x)))
       (vec_extend (VecExtendOp.Uxtl) x $false (lane_size ty)))
 
 ;;;; Rules for `uwiden_high` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 1 (lower (has_type (ty_vec128 ty) (uwiden_high x)))
+(rule 1 (lower (has_type (ty_vec128 ty) (uwiden_high _ x)))
       (vec_extend (VecExtendOp.Uxtl) x $true (lane_size ty)))
 
-(rule (lower (has_type ty (uwiden_high x)))
+(rule (lower (has_type ty (uwiden_high _ x)))
       (if (ty_vec64 ty))
       (let ((tmp Reg (fpu_move_from_vec x 1 (VectorSize.Size32x2))))
        (vec_extend (VecExtendOp.Uxtl) tmp $false (lane_size ty))))
@@ -2198,18 +2363,6 @@
 (rule (lower (fence))
       (side_effect (aarch64_fence)))
 
-;;;; Rules for `IsNull` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(rule (lower (is_null x @ (value_type ty)))
-      (with_flags (cmp_imm (operand_size ty) x (u8_into_imm12 0))
-                  (materialize_bool_result (Cond.Eq))))
-
-;;;; Rules for `IsInvalid` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(rule (lower (is_invalid x @ (value_type ty)))
-      (with_flags (cmn_imm (operand_size ty) x (u8_into_imm12 1))
-                  (materialize_bool_result (Cond.Eq))))
-
 ;;;; Rules for `Debugtrap` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (rule (lower (debugtrap))
@@ -2217,23 +2370,23 @@
 
 ;;;; Rules for `func_addr` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (func_addr (func_ref_data _ extname _)))
+(rule (lower (func_addr _ (func_ref_data _ extname _)))
       (load_ext_name (box_external_name extname) 0))
 
 ;;;; Rules for `symbol_value` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (symbol_value (symbol_value_data extname _ offset)))
+(rule (lower (symbol_value _ (symbol_value_data extname _ offset)))
       (load_ext_name (box_external_name extname) offset))
 
 ;;; Rules for `get_{frame,stack}_pointer` and `get_return_address` ;;;;;;;;;;;;;
 
-(rule (lower (get_frame_pointer))
+(rule (lower (get_frame_pointer _))
       (aarch64_fp))
 
-(rule (lower (get_stack_pointer))
+(rule (lower (get_stack_pointer _))
       (aarch64_sp))
 
-(rule (lower (get_return_address))
+(rule (lower (get_return_address _))
       (aarch64_link))
 
 ;;;; Rules for calls ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -2260,98 +2413,107 @@
 
 ;;;; Rules for loads ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower
-       (has_type $I8 (load flags address offset)))
+(rule load_i8 (lower
+       (has_type $I8 (load _ flags address offset)))
       (aarch64_uload8 (amode $I8 address offset) flags))
-(rule (lower
-       (has_type $I16 (load flags address offset)))
+(rule load_i16 (lower
+       (has_type $I16 (load _ flags address offset)))
       (aarch64_uload16 (amode $I16 address offset) flags))
-(rule (lower
-       (has_type $I32 (load flags address offset)))
+(rule load_i32 (lower
+       (has_type $I32 (load _ flags address offset)))
       (aarch64_uload32 (amode $I32 address offset) flags))
-(rule (lower
-       (has_type $I64 (load flags address offset)))
+(rule load_i64 (lower
+       (has_type $I64 (load _ flags address offset)))
       (aarch64_uload64 (amode $I64 address offset) flags))
 (rule (lower
-       (has_type $R64 (load flags address offset)))
-      (aarch64_uload64 (amode $I64 address offset) flags))
+       (has_type $F16 (load _ flags address offset)))
+      (aarch64_fpuload16 (amode $F16 address offset) flags))
 (rule (lower
-       (has_type $F32 (load flags address offset)))
+       (has_type $F32 (load _ flags address offset)))
       (aarch64_fpuload32 (amode $F32 address offset) flags))
 (rule (lower
-       (has_type $F64 (load flags address offset)))
+       (has_type $F64 (load _ flags address offset)))
       (aarch64_fpuload64 (amode $F64 address offset) flags))
-(rule (lower
-       (has_type $I128 (load flags address offset)))
+(attr rule load_f128 (tag i128))
+(rule load_f128 (lower
+       (has_type $F128 (load _ flags address offset)))
+      (aarch64_fpuload128 (amode $F128 address offset) flags))
+(attr rule load_i128 (tag i128))
+(rule load_i128 (lower
+       (has_type $I128 (load _ flags address offset)))
       (aarch64_loadp64 (pair_amode address offset) flags))
-(rule -1 (lower
+(attr rule load_i128 (tag vector))
+(rule load_ty_vec64 -1 (lower
        (has_type (ty_vec64 _)
-                        (load flags address offset)))
+                        (load _ flags address offset)))
       (aarch64_fpuload64 (amode $F64 address offset) flags))
-(rule -3 (lower
+(attr rule load_ty_vec128 (tag vector))
+(rule load_ty_vec128 -3 (lower
        (has_type (ty_vec128 _)
-                        (load flags address offset)))
+                        (load _ flags address offset)))
       (aarch64_fpuload128 (amode $I8X16 address offset) flags))
-(rule -2 (lower
+(attr rule load_ty_dyn_vec64 (tag vector))
+(rule load_ty_dyn_vec64 -2 (lower
        (has_type (ty_dyn_vec64 _)
-                        (load flags address offset)))
+                        (load _ flags address offset)))
       (aarch64_fpuload64 (amode $F64 address offset) flags))
-(rule -4 (lower
+(attr rule load_ty_dyn_vec128 (tag vector))
+(rule load_ty_dyn_vec128 -4 (lower
        (has_type (ty_dyn_vec128 _)
-                        (load flags address offset)))
+                        (load _ flags address offset)))
       (aarch64_fpuload128 (amode $I8X16 address offset) flags))
 
 (rule (lower
-       (uload8 flags address offset))
+       (uload8 _ flags address offset))
       (aarch64_uload8 (amode $I8 address offset) flags))
 (rule (lower
-       (sload8 flags address offset))
+       (sload8 _ flags address offset))
       (aarch64_sload8 (amode $I8 address offset) flags))
 (rule (lower
-       (uload16 flags address offset))
+       (uload16 _ flags address offset))
       (aarch64_uload16 (amode $I16 address offset) flags))
 (rule (lower
-       (sload16 flags address offset))
+       (sload16 _ flags address offset))
       (aarch64_sload16 (amode $I16 address offset) flags))
-(rule (lower
-       (uload32 flags address offset))
+(rule uload32 (lower
+       (uload32 _ flags address offset))
       (aarch64_uload32 (amode $I32 address offset) flags))
-(rule (lower
-       (sload32 flags address offset))
+(rule sload32 (lower
+       (sload32 _ flags address offset))
       (aarch64_sload32 (amode $I32 address offset) flags))
 
 (rule (lower
-       (sload8x8 flags address offset))
+       (sload8x8 _ flags address offset))
       (vec_extend (VecExtendOp.Sxtl)
                   (aarch64_fpuload64 (amode $F64 address offset) flags)
                   $false
                   (ScalarSize.Size16)))
 (rule (lower
-       (uload8x8 flags address offset))
+       (uload8x8 _ flags address offset))
       (vec_extend (VecExtendOp.Uxtl)
                   (aarch64_fpuload64 (amode $F64 address offset) flags)
                   $false
                   (ScalarSize.Size16)))
 (rule (lower
-       (sload16x4 flags address offset))
+       (sload16x4 _ flags address offset))
       (vec_extend (VecExtendOp.Sxtl)
                   (aarch64_fpuload64 (amode $F64 address offset) flags)
                   $false
                   (ScalarSize.Size32)))
 (rule (lower
-       (uload16x4 flags address offset))
+       (uload16x4 _ flags address offset))
       (vec_extend (VecExtendOp.Uxtl)
                   (aarch64_fpuload64 (amode $F64 address offset) flags)
                   $false
                   (ScalarSize.Size32)))
 (rule (lower
-       (sload32x2 flags address offset))
+       (sload32x2 _ flags address offset))
       (vec_extend (VecExtendOp.Sxtl)
                   (aarch64_fpuload64 (amode $F64 address offset) flags)
                   $false
                   (ScalarSize.Size64)))
 (rule (lower
-       (uload32x2 flags address offset))
+       (uload32x2 _ flags address offset))
       (vec_extend (VecExtendOp.Uxtl)
                   (aarch64_fpuload64 (amode $F64 address offset) flags)
                   $false
@@ -2359,26 +2521,26 @@
 
 ;;;; Rules for stores ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower
+(rule store_i8
+      (lower
        (store flags value @ (value_type $I8) address offset))
       (side_effect
        (aarch64_store8 (amode $I8 address offset) flags value)))
-(rule (lower
+(rule store_i16
+      (lower
        (store flags value @ (value_type $I16) address offset))
       (side_effect
        (aarch64_store16 (amode $I16 address offset) flags value)))
-(rule (lower
+(rule store_i32
+      (lower
        (store flags value @ (value_type $I32) address offset))
       (side_effect
        (aarch64_store32 (amode $I32 address offset) flags value)))
-(rule (lower
+(rule store_i64
+      (lower
        (store flags value @ (value_type $I64) address offset))
       (side_effect
        (aarch64_store64 (amode $I64 address offset) flags value)))
-(rule (lower
-       (store flags value @ (value_type $R64) address offset))
-      (side_effect
-       (aarch64_store64 (amode $I64 address offset) flags value)))
 
 (rule (lower
        (istore8 flags value address offset))
@@ -2393,6 +2555,10 @@
       (side_effect
        (aarch64_store32 (amode $I32 address offset) flags value)))
 
+(rule (lower
+       (store flags value @ (value_type $F16) address offset))
+      (side_effect
+       (aarch64_fpustore16 (amode $F16 address offset) flags value)))
 (rule (lower
        (store flags value @ (value_type $F32) address offset))
       (side_effect
@@ -2401,8 +2567,13 @@
        (store flags value @ (value_type $F64) address offset))
       (side_effect
        (aarch64_fpustore64 (amode $F64 address offset) flags value)))
-
-(rule (lower
+(attr rule store_f128 (tag i128))
+(rule store_f128 (lower
+       (store flags value @ (value_type $F128) address offset))
+      (side_effect
+       (aarch64_fpustore128 (amode $F128 address offset) flags value)))
+(attr rule store_i128 (tag i128))
+(rule store_i128 (lower
        (store flags value @ (value_type $I128) address offset))
       (side_effect
        (aarch64_storep64 (pair_amode address offset) flags
@@ -2428,7 +2599,7 @@
 
 ;;; Rules for `{get,set}_pinned_reg` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (get_pinned_reg))
+(rule (lower (get_pinned_reg _))
       (mov_from_preg (preg_pinned)))
 
 (rule (lower (set_pinned_reg val))
@@ -2437,58 +2608,73 @@
 ;;; Rules for `bitcast` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ; SIMD&FP <=> SIMD&FP
-(rule 5 (lower (has_type (ty_float_or_vec _) (bitcast _ x @ (value_type (ty_float_or_vec _)))))
+(rule 7 (lower (has_type (ty_float_or_vec _) (bitcast _ _ x @ (value_type (ty_float_or_vec _)))))
       x)
 
+; I128 => SIMD&FP
+(rule bitcast_i128_simdfp
+      6 (lower (has_type (ty_float_or_vec _) (bitcast _ _ x @ (value_type $I128))))
+      (mov_to_vec (mov_to_fpu (value_regs_get x 0) (ScalarSize.Size64)) (value_regs_get x 1) 1 (VectorSize.Size64x2)))
+(attr rule bitcast_i128_simdfp (tag i128))
+
+; SIMD&FP => I128
+(rule bitcast_simdfp_i128
+      5 (lower (has_type $I128 (bitcast _ _ x @ (value_type (ty_float_or_vec _)))))
+      (value_regs (mov_from_vec x 0 (ScalarSize.Size64)) (mov_from_vec x 1 (ScalarSize.Size64))))
+(attr rule bitcast_simdfp_i128 (tag i128))
+
 ; GPR => SIMD&FP
-(rule 4 (lower (has_type (ty_float_or_vec _) (bitcast _ x @ (value_type in_ty))))
+(rule 4 (lower (has_type (ty_float_or_vec _) (bitcast _ _ x @ (value_type in_ty))))
       (if (ty_int_ref_scalar_64 in_ty))
       (mov_to_fpu x (scalar_size in_ty)))
 
 ; SIMD&FP => GPR
-(rule 3 (lower (has_type out_ty (bitcast _ x @ (value_type (fits_in_64 (ty_float_or_vec _))))))
+(rule 3 (lower (has_type out_ty (bitcast _ _ x @ (value_type (fits_in_64 (ty_float_or_vec _))))))
       (if (ty_int_ref_scalar_64 out_ty))
       (mov_from_vec x 0 (scalar_size out_ty)))
 
 ; GPR <=> GPR
-(rule 2 (lower (has_type out_ty (bitcast _ x @ (value_type in_ty))))
+(rule scalar_bitcast 1 (lower (has_type out_ty (bitcast _ _ x @ (value_type in_ty))))
       (if (ty_int_ref_scalar_64 out_ty))
       (if (ty_int_ref_scalar_64 in_ty))
       x)
-(rule 1 (lower (has_type $I128 (bitcast _ x @ (value_type $I128)))) x)
+
+(rule bitcast_i128 0 (lower (has_type $I128 (bitcast _ _ x @ (value_type $I128)))) x)
+(attr rule bitcast_i128 (tag i128))
 
 ;;; Rules for `extractlane` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; extractlane with lane 0 can pass through the value unchanged; upper
 ;; bits are undefined when a narrower type is in a wider register.
-(rule 2 (lower (has_type (ty_scalar_float _) (extractlane val (u8_from_uimm8 0))))
+(attr extractlane (tag vector))
+(rule 2 (lower (has_type (ty_scalar_float _) (extractlane _ val (u8_from_uimm8 0))))
       val)
 
 (rule 0 (lower (has_type (ty_int ty)
-                       (extractlane val
+                       (extractlane _ val
                                     (u8_from_uimm8 lane))))
       (mov_from_vec val lane (scalar_size ty)))
 
 (rule 1 (lower (has_type (ty_scalar_float ty)
-                       (extractlane val @ (value_type vty)
+                       (extractlane _ val @ (value_type vty)
                                     (u8_from_uimm8 lane))))
       (fpu_move_from_vec val lane (vector_size vty)))
 
 ;;; Rules for `insertlane` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 1 (lower (insertlane vec @ (value_type vty)
+(rule 1 (lower (insertlane _ vec @ (value_type vty)
                          val @ (value_type (ty_int _))
                          (u8_from_uimm8 lane)))
       (mov_to_vec vec val lane (vector_size vty)))
 
-(rule (lower (insertlane vec @ (value_type vty)
+(rule (lower (insertlane _ vec @ (value_type vty)
                          val @ (value_type (ty_scalar_float _))
                          (u8_from_uimm8 lane)))
       (mov_vec_elem vec val lane 0 (vector_size vty)))
 
 ;;; Rules for `stack_addr` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (stack_addr stack_slot offset))
+(rule (lower (stack_addr _ stack_slot offset))
       (compute_stack_addr stack_slot offset))
 
 ;;; Rules for `vhigh_bits` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -2502,7 +2688,7 @@
 ;; in https://github.com/bytecodealliance/wasmtime/issues/2296,
 ;; although they are not used here.
 
-(rule (lower (vhigh_bits vec @ (value_type $I8X16)))
+(rule (lower (vhigh_bits _ vec @ (value_type $I8X16)))
       (let (
             ;; Replicate the MSB of each of the 16 byte lanes across
             ;; the whole lane (sshr is an arithmetic right shift).
@@ -2526,7 +2712,7 @@
             (result Reg (addv zipped (VectorSize.Size16x8))))
         (mov_from_vec result 0 (ScalarSize.Size16))))
 
-(rule (lower (vhigh_bits vec @ (value_type $I16X8)))
+(rule (lower (vhigh_bits _ vec @ (value_type $I16X8)))
       (let (
             ;; Replicate the MSB of each of the 8 16-bit lanes across
             ;; the whole lane (sshr is an arithmetic right shift).
@@ -2539,7 +2725,7 @@
             (result Reg (addv anded (VectorSize.Size16x8))))
         (mov_from_vec result 0 (ScalarSize.Size16))))
 
-(rule (lower (vhigh_bits vec @ (value_type $I32X4)))
+(rule (lower (vhigh_bits _ vec @ (value_type $I32X4)))
       (let (
             ;; Replicate the MSB of each of the 4 32-bit lanes across
             ;; the whole lane (sshr is an arithmetic right shift).
@@ -2552,7 +2738,7 @@
             (result Reg (addv anded (VectorSize.Size32x4))))
         (mov_from_vec result 0 (ScalarSize.Size32))))
 
-(rule (lower (vhigh_bits vec @ (value_type $I64X2)))
+(rule (lower (vhigh_bits _ vec @ (value_type $I64X2)))
       (let (
             ;; Grab the MSB out of each of the lanes, right-shift to
             ;; LSB, and add with a left-shift of upper lane's MSB back
@@ -2566,7 +2752,7 @@
 
 ;;; Rules for `uadd_overflow_trap` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type (fits_in_64 ty) (uadd_overflow_trap a b tc)))
+(rule uadd_overflow_trap (lower (has_type (fits_in_64 ty) (uadd_overflow_trap _ a b tc)))
       (trap_if_overflow (add_with_flags_paired ty a b) tc))
 
 ;;;; Helpers for `*_overflow` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -2646,15 +2832,15 @@
 
 ;; For values smaller than a register, we do a normal `add` with both arguments
 ;; zero extended. We then check if the output is the same as itself zero extended.
-(rule 1 (lower (has_type (fits_in_16 ty) (uadd_overflow a b)))
+(rule 1 (lower (has_type (fits_in_16 ty) (uadd_overflow _ a b)))
       (overflow_op_small ty a b (ArgumentExtension.Uext) (ALUOp.Add)))
 
 ;; For register sized add's we just emit a adds+cset, without further masking.
-(rule 2 (lower (has_type (ty_32_or_64 ty) (uadd_overflow a b)))
+(rule 2 (lower (has_type (ty_32_or_64 ty) (uadd_overflow _ a b)))
       (overflow_op_normal ty a b (ALUOp.AddS) (Cond.Hs)))
 
 ;; For 128bit integers we emit add+adcs+cset
-(rule 0 (lower (has_type $I128 (uadd_overflow x y)))
+(rule 0 (lower (has_type $I128 (uadd_overflow _ x y)))
       (overflow_op_128 x y (ALUOp.AddS) (ALUOp.AdcS) (Cond.Hs)))
 
 ;;;; Rules for `sadd_overflow` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -2663,18 +2849,18 @@
 ;; add out, a_ext, b, sxt{b,h}
 ;; cmp out, out, sxt{b,h}
 ;; cset of, ne
-(rule 1 (lower (has_type (fits_in_16 ty) (sadd_overflow a b)))
+(rule 1 (lower (has_type (fits_in_16 ty) (sadd_overflow _ a b)))
       (overflow_op_small ty a b (ArgumentExtension.Sext) (ALUOp.Add)))
 
 ;; adds a, b
 ;; cset of, vs
-(rule 2 (lower (has_type (ty_32_or_64 ty) (sadd_overflow a b)))
+(rule 2 (lower (has_type (ty_32_or_64 ty) (sadd_overflow _ a b)))
       (overflow_op_normal ty a b (ALUOp.AddS) (Cond.Vs)))
 
 ;; adds x_lo, y_lo
 ;; addcs x_hi, y_hi
 ;; cset of, vs
-(rule 0 (lower (has_type $I128 (sadd_overflow x y)))
+(rule 0 (lower (has_type $I128 (sadd_overflow _ x y)))
       (overflow_op_128 x y (ALUOp.AddS) (ALUOp.AdcS) (Cond.Vs)))
 
 ;;;; Rules for `usub_overflow` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -2683,18 +2869,18 @@
 ;; sub out, a_ext, b, ext{b,h}
 ;; cmp out, out, uxt{b,h}
 ;; cset of, ne
-(rule 1 (lower (has_type (fits_in_16 ty) (usub_overflow a b)))
+(rule 1 (lower (has_type (fits_in_16 ty) (usub_overflow _ a b)))
       (overflow_op_small ty a b (ArgumentExtension.Uext) (ALUOp.Sub)))
 
 ;; subs a, b
 ;; cset of, lo
-(rule 2 (lower (has_type (ty_32_or_64 ty) (usub_overflow a b)))
+(rule 2 (lower (has_type (ty_32_or_64 ty) (usub_overflow _ a b)))
       (overflow_op_normal ty a b (ALUOp.SubS) (Cond.Lo)))
 
 ;; subs x_lo, y_lo
 ;; sbcs x_hi, y_hi
 ;; cset of, lo
-(rule 0 (lower (has_type $I128 (usub_overflow x y)))
+(rule 0 (lower (has_type $I128 (usub_overflow _ x y)))
       (overflow_op_128 x y (ALUOp.SubS) (ALUOp.SbcS) (Cond.Lo)))
 
 ;;;; Rules for `ssub_overflow` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -2703,18 +2889,18 @@
 ;; sub out, a_ext, b, sxt{b,h}
 ;; cmp out, out, sxt{b,h}
 ;; cset of, ne
-(rule 1 (lower (has_type (fits_in_16 ty) (ssub_overflow a b)))
+(rule 1 (lower (has_type (fits_in_16 ty) (ssub_overflow _ a b)))
       (overflow_op_small ty a b (ArgumentExtension.Sext) (ALUOp.Sub)))
 
 ;; subs a, b
 ;; cset of, vs
-(rule 2 (lower (has_type (ty_32_or_64 ty) (ssub_overflow a b)))
+(rule 2 (lower (has_type (ty_32_or_64 ty) (ssub_overflow _ a b)))
       (overflow_op_normal ty a b (ALUOp.SubS) (Cond.Vs)))
 
 ;; subs x_lo, y_lo
 ;; sbcs x_hi, y_hi
 ;; cset of, vs
-(rule 0 (lower (has_type $I128 (ssub_overflow x y)))
+(rule 0 (lower (has_type $I128 (ssub_overflow _ x y)))
       (overflow_op_128 x y (ALUOp.SubS) (ALUOp.SbcS) (Cond.Vs)))
 
 ;;;; Rules for `umul_overflow` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -2724,7 +2910,7 @@
 ;; mul out, a_ext, b_ext
 ;; cmp out, out, uxt{b,h}
 ;; cset of, ne
-(rule 1 (lower (has_type (fits_in_16 ty) (umul_overflow a b)))
+(rule 1 (lower (has_type (fits_in_16 ty) (umul_overflow _ a b)))
        (let ((extend ExtendOp (lower_extend_op ty (ArgumentExtension.Uext)))
 
              (a_uext Reg (put_in_reg_zext32 a))
@@ -2740,7 +2926,7 @@
 ;; umull out, a, b
 ;; cmp out, out, uxtw
 ;; cset of, ne
-(rule 2 (lower (has_type $I32 (umul_overflow a b)))
+(rule 2 (lower (has_type $I32 (umul_overflow _ a b)))
        (let (
              (out Reg (umaddl a b (zero_reg)))
              (out_of Reg (with_flags_reg
@@ -2754,7 +2940,7 @@
 ;; umulh tmp, a, b
 ;; cmp tmp, #0
 ;; cset of, ne
-(rule 2 (lower (has_type $I64 (umul_overflow a b)))
+(rule 2 (lower (has_type $I64 (umul_overflow _ a b)))
        (let (
              (out Reg (madd $I64 a b (zero_reg)))
              (tmp Reg (umulh $I64 a b))
@@ -2772,7 +2958,7 @@
 ;; mul out, a_ext, b_ext
 ;; cmp out, out, sxt{b,h}
 ;; cset of, ne
-(rule 1 (lower (has_type (fits_in_16 ty) (smul_overflow a b)))
+(rule 1 (lower (has_type (fits_in_16 ty) (smul_overflow _ a b)))
        (let ((extend ExtendOp (lower_extend_op ty (ArgumentExtension.Sext)))
 
              (a_sext Reg (put_in_reg_sext32 a))
@@ -2788,7 +2974,7 @@
 ;; smull out, a, b
 ;; cmp out, out, sxtw
 ;; cset of, ne
-(rule 2 (lower (has_type $I32 (smul_overflow a b)))
+(rule 2 (lower (has_type $I32 (smul_overflow _ a b)))
        (let (
              (out Reg (smaddl a b (zero_reg)))
              (out_of Reg (with_flags_reg
@@ -2802,7 +2988,7 @@
 ;; smulh tmp, a, b
 ;; cmp tmp, out, ASR #63
 ;; cset of, ne
-(rule 2 (lower (has_type $I64 (smul_overflow a b)))
+(rule 2 (lower (has_type $I64 (smul_overflow _ a b)))
        (let (
              (out Reg (madd $I64 a b (zero_reg)))
              (tmp Reg (smulh $I64 a b))
@@ -2815,21 +3001,21 @@
 
 ;;; Rules for `tls_value` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type (tls_model (TlsModel.ElfGd)) (tls_value (symbol_value_data name _ _))))
+(rule (lower (has_type (tls_model (TlsModel.ElfGd)) (tls_value _ (symbol_value_data name _ _))))
       (elf_tls_get_addr name))
 
-(rule (lower (has_type (tls_model (TlsModel.Macho)) (tls_value (symbol_value_data name _ _))))
+(rule (lower (has_type (tls_model (TlsModel.Macho)) (tls_value _ (symbol_value_data name _ _))))
       (macho_tls_get_addr name))
 
 ;;; Rules for `fvpromote_low` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (fvpromote_low val))
+(rule (lower (fvpromote_low _ val))
       (vec_rr_long (VecRRLongOp.Fcvtl32) val $false))
 
 ;;; Rules for `brif` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; `brif` following `icmp`
-(rule (lower_branch (brif (maybe_uextend (icmp cc x @ (value_type ty) y)) _ _) (two_targets taken not_taken))
+(rule (lower_branch (brif (maybe_uextend (icmp _ cc x @ (value_type ty) y)) _ _) (two_targets taken not_taken))
       (let ((comparison FlagsAndCC (lower_icmp_into_flags cc x y ty))
             (cond Cond (cond_code (flags_and_cc_cc comparison))))
         (emit_side_effect
@@ -2839,7 +3025,7 @@
                                           (cond_br_cond cond))))))
 
 ;; `brif` following `fcmp`
-(rule (lower_branch (brif (maybe_uextend (fcmp cc x @ (value_type (ty_scalar_float ty)) y)) _ _) (two_targets taken not_taken))
+(rule (lower_branch (brif (maybe_uextend (fcmp _ cc x @ (value_type (ty_scalar_float ty)) y)) _ _) (two_targets taken not_taken))
       (let ((cond Cond (fp_cond_code cc)))
        (emit_side_effect
         (with_flags_side_effect (fpu_cmp (scalar_size ty) x y)
@@ -2864,6 +3050,24 @@
         (with_flags_side_effect flags
          (cond_br taken not_taken (cond_br_not_zero rt))))))
 
+;; Special lowerings for `tbnz` - "Test bit and Branch if Nonzero"
+(rule 1 (lower_branch (brif (band _ x @ (value_type ty) (u64_from_iconst n)) _ _)
+                     (two_targets taken not_taken))
+  (if-let bit (test_and_compare_bit_const ty n))
+  (emit_side_effect (tbnz taken not_taken x bit)))
+
+;; Special lowering for `tbz` - "Test bit and Branch if Zero"
+(rule 1 (lower_branch (brif (icmp _ (IntCC.Equal)
+                                  (band _ x @ (value_type (fits_in_64 ty))
+                                        (u64_from_iconst n))
+                                  (u64_from_iconst 0)) _ _)
+                     (two_targets taken not_taken))
+  (if-let bit (test_and_compare_bit_const ty n))
+  (emit_side_effect (tbz taken not_taken x bit)))
+
+(decl pure partial test_and_compare_bit_const (Type u64) u8)
+(extern constructor test_and_compare_bit_const test_and_compare_bit_const)
+
 ;;; Rules for `jump` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (rule (lower_branch (jump _) (single_target label))
diff --git a/cranelift/codegen/src/isa/aarch64/lower.rs b/cranelift/codegen/src/isa/aarch64/lower.rs
index 02c841d1b2f9..5ed10a490ac4 100644
--- a/cranelift/codegen/src/isa/aarch64/lower.rs
+++ b/cranelift/codegen/src/isa/aarch64/lower.rs
@@ -8,12 +8,13 @@
 //! - Floating-point immediates (FIMM instruction).
 
 use crate::ir::condcodes::{FloatCC, IntCC};
+use crate::ir::pcc::{FactContext, PccResult};
 use crate::ir::Inst as IRInst;
 use crate::ir::{Opcode, Value};
 use crate::isa::aarch64::inst::*;
+use crate::isa::aarch64::pcc;
 use crate::isa::aarch64::AArch64Backend;
 use crate::machinst::lower::*;
-use crate::machinst::Reg;
 use crate::machinst::*;
 
 pub mod isle;
@@ -129,4 +130,16 @@ impl LowerBackend for AArch64Backend {
     fn maybe_pinned_reg(&self) -> Option<Reg> {
         Some(regs::pinned_reg())
     }
+
+    fn check_fact(
+        &self,
+        ctx: &FactContext<'_>,
+        vcode: &mut VCode<Self::MInst>,
+        inst: InsnIndex,
+        state: &mut pcc::FactFlowState,
+    ) -> PccResult<()> {
+        pcc::check(ctx, vcode, inst, state)
+    }
+
+    type FactFlowState = pcc::FactFlowState;
 }
diff --git a/cranelift/codegen/src/isa/aarch64/lower/isle.rs b/cranelift/codegen/src/isa/aarch64/lower/isle.rs
index 0c3f151c4818..29a3f1c68a4b 100644
--- a/cranelift/codegen/src/isa/aarch64/lower/isle.rs
+++ b/cranelift/codegen/src/isa/aarch64/lower/isle.rs
@@ -3,7 +3,6 @@
 // Pull in the ISLE generated code.
 pub mod generated_code;
 use generated_code::Context;
-use smallvec::SmallVec;
 
 // Types that the generated ISLE code uses via `use super::*`.
 use super::{
@@ -13,12 +12,11 @@ use super::{
     MachLabel, MemLabel, MoveWideConst, MoveWideOp, Opcode, OperandSize, Reg, SImm9, ScalarSize,
     ShiftOpAndAmt, UImm12Scaled, UImm5, VecMisc2, VectorSize, NZCV,
 };
-use crate::ir::condcodes;
+use crate::ir::{condcodes, ArgumentExtension};
 use crate::isa;
 use crate::isa::aarch64::inst::{FPULeftShiftImm, FPURightShiftImm, ReturnCallInfo};
 use crate::isa::aarch64::AArch64Backend;
-use crate::machinst::valueregs;
-use crate::machinst::{isle::*, InputSourceInst};
+use crate::machinst::isle::*;
 use crate::{
     binemit::CodeOffset,
     ir::{
@@ -28,15 +26,12 @@ use crate::{
     isa::aarch64::abi::AArch64CallSite,
     isa::aarch64::inst::args::{ShiftOp, ShiftOpShiftImm},
     isa::aarch64::inst::SImm7Scaled,
-    isa::unwind::UnwindInst,
     machinst::{
-        abi::ArgPair, ty_bits, InstOutput, Lower, MachInst, VCodeConstant, VCodeConstantData,
+        abi::ArgPair, ty_bits, InstOutput, IsTailCall, MachInst, VCodeConstant, VCodeConstantData,
     },
 };
-use crate::{isle_common_prelude_methods, isle_lower_prelude_methods};
 use regalloc2::PReg;
 use std::boxed::Box;
-use std::convert::TryFrom;
 use std::vec::Vec;
 
 type BoxCallInfo = Box<CallInfo>;
@@ -67,7 +62,7 @@ pub(crate) fn lower_branch(
     // TODO: reuse the ISLE context across lowerings so we can reuse its
     // internal heap allocations.
     let mut isle_ctx = IsleContext { lower_ctx, backend };
-    generated_code::constructor_lower_branch(&mut isle_ctx, branch, &targets.to_vec())
+    generated_code::constructor_lower_branch(&mut isle_ctx, branch, targets)
 }
 
 pub struct ExtendedValue {
@@ -75,10 +70,6 @@ pub struct ExtendedValue {
     extend: ExtendOp,
 }
 
-impl IsleContext<'_, '_, MInst, AArch64Backend> {
-    isle_prelude_method_helpers!(AArch64CallSite);
-}
-
 impl Context for IsleContext<'_, '_, MInst, AArch64Backend> {
     isle_lower_prelude_methods!();
     isle_prelude_caller_methods!(
@@ -104,6 +95,7 @@ impl Context for IsleContext<'_, '_, MInst, AArch64Backend> {
             self.lower_ctx.sigs(),
             callee_sig,
             &callee,
+            IsTailCall::Yes,
             distance,
             caller_conv,
             self.backend.flags().clone(),
@@ -132,7 +124,7 @@ impl Context for IsleContext<'_, '_, MInst, AArch64Backend> {
             self.lower_ctx.sigs(),
             callee_sig,
             callee,
-            Opcode::ReturnCallIndirect,
+            IsTailCall::Yes,
             caller_conv,
             self.backend.flags().clone(),
         );
@@ -157,6 +149,10 @@ impl Context for IsleContext<'_, '_, MInst, AArch64Backend> {
         }
     }
 
+    fn use_fp16(&mut self) -> bool {
+        self.backend.isa_flags.has_fp16()
+    }
+
     fn move_wide_const_from_u64(&mut self, ty: Type, n: u64) -> Option<MoveWideConst> {
         let bits = ty.bits();
         let n = if bits < 64 {
@@ -175,6 +171,14 @@ impl Context for IsleContext<'_, '_, MInst, AArch64Backend> {
         ImmLogic::maybe_from_u64(n, ty)
     }
 
+    fn imm_size_from_type(&mut self, ty: Type) -> Option<u16> {
+        match ty {
+            I32 => Some(32),
+            I64 => Some(64),
+            _ => None,
+        }
+    }
+
     fn imm_logic_from_imm64(&mut self, ty: Type, n: Imm64) -> Option<ImmLogic> {
         let ty = if ty.bits() < 32 { I32 } else { ty };
         self.imm_logic_from_u64(ty, n.bits() as u64)
@@ -226,7 +230,7 @@ impl Context for IsleContext<'_, '_, MInst, AArch64Backend> {
 
     fn integral_ty(&mut self, ty: Type) -> Option<Type> {
         match ty {
-            I8 | I16 | I32 | I64 | R64 => Some(ty),
+            I8 | I16 | I32 | I64 => Some(ty),
             _ => None,
         }
     }
@@ -279,120 +283,100 @@ impl Context for IsleContext<'_, '_, MInst, AArch64Backend> {
         } else {
             value
         };
-        let size = OperandSize::Size64;
-
-        // If the top 32 bits are zero, use 32-bit `mov` operations.
-        if value >> 32 == 0 {
-            let size = OperandSize::Size32;
-            let lower_halfword = value as u16;
-            let upper_halfword = (value >> 16) as u16;
-
-            let rd = self.temp_writable_reg(I64);
-            if upper_halfword == u16::MAX {
-                self.emit(&MInst::MovWide {
-                    op: MoveWideOp::MovN,
-                    rd,
-                    imm: MoveWideConst::maybe_with_shift(!lower_halfword, 0).unwrap(),
-                    size,
-                });
-            } else {
-                self.emit(&MInst::MovWide {
-                    op: MoveWideOp::MovZ,
-                    rd,
-                    imm: MoveWideConst::maybe_with_shift(lower_halfword, 0).unwrap(),
-                    size,
-                });
 
-                if upper_halfword != 0 {
-                    let tmp = self.temp_writable_reg(I64);
-                    self.emit(&MInst::MovK {
-                        rd: tmp,
-                        rn: rd.to_reg(),
-                        imm: MoveWideConst::maybe_with_shift(upper_halfword, 16).unwrap(),
-                        size,
-                    });
-                    return tmp.to_reg();
-                }
-            };
+        // Divide the value into 16-bit slices that we can manipulate using
+        // `movz`, `movn`, and `movk`.
+        fn get(value: u64, shift: u8) -> u16 {
+            (value >> (shift * 16)) as u16
+        }
+        fn replace(mut old: u64, new: u16, shift: u8) -> u64 {
+            let offset = shift * 16;
+            old &= !(0xffff << offset);
+            old |= u64::from(new) << offset;
+            old
+        }
 
-            return rd.to_reg();
-        } else if value == u64::MAX {
-            let rd = self.temp_writable_reg(I64);
-            self.emit(&MInst::MovWide {
-                op: MoveWideOp::MovN,
-                rd,
-                imm: MoveWideConst::zero(),
-                size,
-            });
-            return rd.to_reg();
+        // The 32-bit versions of `movz`/`movn`/`movk` will clear the upper 32
+        // bits, so if that's the outcome we want we might as well use them. For
+        // simplicity and ease of reading the disassembly, we use the same size
+        // for all instructions in the sequence.
+        let size = if value >> 32 == 0 {
+            OperandSize::Size32
+        } else {
+            OperandSize::Size64
         };
 
-        // If the number of 0xffff half words is greater than the number of 0x0000 half words
-        // it is more efficient to use `movn` for the first instruction.
-        let first_is_inverted = count_zero_half_words(!value) > count_zero_half_words(value);
-
-        // Either 0xffff or 0x0000 half words can be skipped, depending on the first
-        // instruction used.
-        let ignored_halfword = if first_is_inverted { 0xffff } else { 0 };
-
-        let halfwords: SmallVec<[_; 4]> = (0..4)
-            .filter_map(|i| {
-                let imm16 = (value >> (16 * i)) & 0xffff;
-                if imm16 == ignored_halfword {
-                    None
-                } else {
-                    Some((i, imm16))
-                }
-            })
-            .collect();
-
-        let mut prev_result = None;
-        for (i, imm16) in halfwords {
-            let shift = i * 16;
-            let rd = self.temp_writable_reg(I64);
-
-            if let Some(rn) = prev_result {
-                let imm = MoveWideConst::maybe_with_shift(imm16 as u16, shift).unwrap();
-                self.emit(&MInst::MovK { rd, rn, imm, size });
-            } else {
-                if first_is_inverted {
-                    let imm =
-                        MoveWideConst::maybe_with_shift(((!imm16) & 0xffff) as u16, shift).unwrap();
-                    self.emit(&MInst::MovWide {
-                        op: MoveWideOp::MovN,
-                        rd,
-                        imm,
-                        size,
-                    });
-                } else {
-                    let imm = MoveWideConst::maybe_with_shift(imm16 as u16, shift).unwrap();
-                    self.emit(&MInst::MovWide {
-                        op: MoveWideOp::MovZ,
-                        rd,
-                        imm,
-                        size,
-                    });
-                }
-            }
-
-            prev_result = Some(rd.to_reg());
+        // The `movz` instruction initially sets all bits to zero, while `movn`
+        // initially sets all bits to one. A good choice of initial value can
+        // reduce the number of `movk` instructions we need afterward, so we
+        // check both variants to determine which is closest to the constant
+        // we actually wanted. In case they're equally good, we prefer `movz`
+        // because the assembly listings are generally harder to read when the
+        // operands are negated.
+        let (mut running_value, op, first) =
+            [(MoveWideOp::MovZ, 0), (MoveWideOp::MovN, size.max_value())]
+                .into_iter()
+                .map(|(op, base)| {
+                    // Both `movz` and `movn` can overwrite one slice after setting
+                    // the initial value; we get to pick which one. 32-bit variants
+                    // can only modify the lower two slices.
+                    let first = (0..(size.bits() / 16))
+                        // Pick one slice that's different from the initial value
+                        .find(|&i| get(base ^ value, i) != 0)
+                        // If none are different, we still have to pick one
+                        .unwrap_or(0);
+                    // Compute the value we'll get from this `movz`/`movn`
+                    (replace(base, get(value, first), first), op, first)
+                })
+                // Count how many `movk` instructions we'll need.
+                .min_by_key(|(base, ..)| (0..4).filter(|&i| get(base ^ value, i) != 0).count())
+                // `variants` isn't empty so `min_by_key` always returns something.
+                .unwrap();
+
+        // Build the initial instruction we chose above, putting the result
+        // into a new temporary virtual register. Note that the encoding for the
+        // immediate operand is bitwise-inverted for `movn`.
+        let mut rd = self.temp_writable_reg(I64);
+        self.lower_ctx.emit(MInst::MovWide {
+            op,
+            rd,
+            imm: MoveWideConst {
+                bits: match op {
+                    MoveWideOp::MovZ => get(value, first),
+                    MoveWideOp::MovN => !get(value, first),
+                },
+                shift: first,
+            },
+            size,
+        });
+        if self.backend.flags.enable_pcc() {
+            self.lower_ctx
+                .add_range_fact(rd.to_reg(), 64, running_value, running_value);
         }
 
-        assert!(prev_result.is_some());
-
-        return prev_result.unwrap();
-
-        fn count_zero_half_words(mut value: u64) -> usize {
-            let mut count = 0;
-            for _ in 0..4 {
-                if value & 0xffff == 0 {
-                    count += 1;
+        // Emit a `movk` instruction for each remaining slice of the desired
+        // constant that does not match the initial value constructed above.
+        for shift in (first + 1)..(size.bits() / 16) {
+            let bits = get(value, shift);
+            if bits != get(running_value, shift) {
+                let rn = rd.to_reg();
+                rd = self.temp_writable_reg(I64);
+                self.lower_ctx.emit(MInst::MovK {
+                    rd,
+                    rn,
+                    imm: MoveWideConst { bits, shift },
+                    size,
+                });
+                running_value = replace(running_value, bits, shift);
+                if self.backend.flags.enable_pcc() {
+                    self.lower_ctx
+                        .add_range_fact(rd.to_reg(), 64, running_value, running_value);
                 }
-                value >>= 16;
             }
-
-            count
         }
+
+        debug_assert_eq!(value, running_value);
+        return rd.to_reg();
     }
 
     fn zero_reg(&mut self) -> Reg {
@@ -812,4 +796,15 @@ impl Context for IsleContext<'_, '_, MInst, AArch64Backend> {
     fn uimm12_scaled_from_i64(&mut self, val: i64, ty: Type) -> Option<UImm12Scaled> {
         UImm12Scaled::maybe_from_i64(val, ty)
     }
+
+    fn test_and_compare_bit_const(&mut self, ty: Type, n: u64) -> Option<u8> {
+        if n.count_ones() != 1 {
+            return None;
+        }
+        let bit = n.trailing_zeros();
+        if bit >= ty.bits() {
+            return None;
+        }
+        Some(bit as u8)
+    }
 }
diff --git a/cranelift/codegen/src/isa/aarch64/lower/isle/generated_code.rs b/cranelift/codegen/src/isa/aarch64/lower/isle/generated_code.rs
index f00fd2f86c16..54bfd8c27346 100644
--- a/cranelift/codegen/src/isa/aarch64/lower/isle/generated_code.rs
+++ b/cranelift/codegen/src/isa/aarch64/lower/isle/generated_code.rs
@@ -4,6 +4,11 @@
 // mod generated_code;` trick either.
 #![allow(missing_docs, dead_code, unreachable_code, unreachable_patterns)]
 #![allow(unused_imports, unused_variables, non_snake_case, unused_mut)]
-#![allow(irrefutable_let_patterns, unused_assignments, non_camel_case_types)]
+#![allow(
+    irrefutable_let_patterns,
+    unused_assignments,
+    non_camel_case_types,
+    clippy::clone_on_copy
+)]
 
 include!(concat!(env!("ISLE_DIR"), "/isle_aarch64.rs"));
diff --git a/cranelift/codegen/src/isa/aarch64/lower_dynamic_neon.isle b/cranelift/codegen/src/isa/aarch64/lower_dynamic_neon.isle
index a3cd463c9e4f..5c2c323e29d4 100644
--- a/cranelift/codegen/src/isa/aarch64/lower_dynamic_neon.isle
+++ b/cranelift/codegen/src/isa/aarch64/lower_dynamic_neon.isle
@@ -1,98 +1,98 @@
 
 ;;;; Rules for `iadd` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule -4 (lower (has_type ty @ (dynamic_lane _ _) (iadd x y)))
+(rule -4 (lower (has_type ty @ (dynamic_lane _ _) (iadd _ x y)))
       (value_reg (add_vec (put_in_reg x) (put_in_reg y) (vector_size ty))))
 
 ;;;; Rules for `isub` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule -5 (lower (has_type ty @ (dynamic_lane _ _) (isub x y)))
+(rule -5 (lower (has_type ty @ (dynamic_lane _ _) (isub _ x y)))
       (value_reg (sub_vec (put_in_reg x) (put_in_reg y) (vector_size ty))))
 
 ;;;; Rules for `imul` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule -4 (lower (has_type (lane_fits_in_32 ty @ (dynamic_lane _ _)) (imul x y)))
+(rule -4 (lower (has_type (lane_fits_in_32 ty @ (dynamic_lane _ _)) (imul _ x y)))
       (value_reg (vec_rrr (VecALUOp.Mul) (put_in_reg x) (put_in_reg y) (vector_size ty))))
 
 ;;;; Rules for `fadd` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule -2 (lower (has_type ty @ (dynamic_lane _ _) (fadd x y)))
+(rule -2 (lower (has_type ty @ (dynamic_lane _ _) (fadd _ x y)))
       (value_reg (vec_rrr (VecALUOp.Fadd) (put_in_reg x) (put_in_reg y) (vector_size ty))))
 
 ;;;; Rules for `fsub` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule -2 (lower (has_type ty @ (dynamic_lane _ _) (fsub x y)))
+(rule -2 (lower (has_type ty @ (dynamic_lane _ _) (fsub _ x y)))
       (value_reg (vec_rrr (VecALUOp.Fsub) (put_in_reg x) (put_in_reg y) (vector_size ty))))
 
 ;;;; Rules for `fmul` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule -2 (lower (has_type ty @ (dynamic_lane _ _) (fmul x y)))
+(rule -2 (lower (has_type ty @ (dynamic_lane _ _) (fmul _ x y)))
       (value_reg (vec_rrr (VecALUOp.Fmul) (put_in_reg x) (put_in_reg y) (vector_size ty))))
 
 ;;;; Rules for `fdiv` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule -2 (lower (has_type ty @ (dynamic_lane _ _) (fdiv x y)))
+(rule -2 (lower (has_type ty @ (dynamic_lane _ _) (fdiv _ x y)))
       (value_reg (vec_rrr (VecALUOp.Fdiv) (put_in_reg x) (put_in_reg y) (vector_size ty))))
 
 ;;;; Rules for `fmin` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule -2 (lower (has_type ty @ (dynamic_lane _ _) (fmin x y)))
+(rule -2 (lower (has_type ty @ (dynamic_lane _ _) (fmin _ x y)))
       (value_reg (vec_rrr (VecALUOp.Fmin) (put_in_reg x) (put_in_reg y) (vector_size ty))))
 
 ;;;; Rules for `fmax` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule -2 (lower (has_type ty @ (dynamic_lane _ _) (fmax x y)))
+(rule -2 (lower (has_type ty @ (dynamic_lane _ _) (fmax _ x y)))
       (value_reg (vec_rrr (VecALUOp.Fmax) (put_in_reg x) (put_in_reg y) (vector_size ty))))
 
 ;;;; Rules for `snarrow` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule -2 (lower (has_type (ty_dyn128_int ty) (snarrow x y)))
+(rule -2 (lower (has_type (ty_dyn128_int ty) (snarrow _ x y)))
       (if-let _ (zero_value y))
       (sqxtn x (lane_size ty)))
 
-(rule -1 (lower (has_type (ty_dyn64_int ty) (snarrow x y)))
+(rule -1 (lower (has_type (ty_dyn64_int ty) (snarrow _ x y)))
       (let ((dst Reg (mov_vec_elem x y 1 0 (VectorSize.Size64x2))))
             (sqxtn dst (lane_size ty))))
 
-(rule -3 (lower (has_type (ty_dyn128_int ty) (snarrow x y)))
+(rule -3 (lower (has_type (ty_dyn128_int ty) (snarrow _ x y)))
       (let ((low_half Reg (sqxtn x (lane_size ty)))
             (result Reg (sqxtn2 low_half y (lane_size ty))))
         result))
 
 ;;;; Rules for `unarrow` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule -2 (lower (has_type (ty_dyn128_int ty) (unarrow x y)))
+(rule -2 (lower (has_type (ty_dyn128_int ty) (unarrow _ x y)))
       (if-let _ (zero_value y))
       (sqxtun x (lane_size ty)))
 
-(rule -1 (lower (has_type (ty_dyn64_int ty) (unarrow x y)))
+(rule -1 (lower (has_type (ty_dyn64_int ty) (unarrow _ x y)))
       (let ((dst Reg (mov_vec_elem x y 1 0 (VectorSize.Size64x2))))
             (sqxtun dst (lane_size ty))))
 
-(rule -3 (lower (has_type (ty_dyn128_int ty) (unarrow x y)))
+(rule -3 (lower (has_type (ty_dyn128_int ty) (unarrow _ x y)))
       (let ((low_half Reg (sqxtun x (lane_size ty)))
             (result Reg (sqxtun2 low_half y (lane_size ty))))
         result))
 
 ;;;; Rules for `uunarrow` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule -2 (lower (has_type (ty_dyn128_int ty) (uunarrow x y)))
+(rule -2 (lower (has_type (ty_dyn128_int ty) (uunarrow _ x y)))
       (if-let _ (zero_value y))
       (uqxtn x (lane_size ty)))
 
-(rule -1 (lower (has_type (ty_dyn64_int ty) (uunarrow x y)))
+(rule -1 (lower (has_type (ty_dyn64_int ty) (uunarrow _ x y)))
       (let ((dst Reg (mov_vec_elem x y 1 0 (VectorSize.Size64x2))))
             (uqxtn dst (lane_size ty))))
 
-(rule -3 (lower (has_type (ty_dyn128_int ty) (uunarrow x y)))
+(rule -3 (lower (has_type (ty_dyn128_int ty) (uunarrow _ x y)))
       (let ((low_half Reg (uqxtn x (lane_size ty)))
             (result Reg (uqxtn2 low_half y (lane_size ty))))
         result))
 
 ;;; Rules for `dynamic_stack_addr` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule (lower (dynamic_stack_addr stack_slot))
+(rule (lower (dynamic_stack_addr _ stack_slot))
       (let ((dst WritableReg (temp_writable_reg $I64))
             (_ Unit (emit (abi_dynamic_stackslot_addr dst stack_slot))))
         (value_reg dst)))
 
 ;;; Rules for `extract_vector` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule (lower (extract_vector x 0))
+(rule (lower (extract_vector _ x 0))
       (value_reg (put_in_reg x)))
 
 ;;;; Rules for `swiden_high` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule -1 (lower (has_type ty (swiden_high x)))
+(rule -1 (lower (has_type ty (swiden_high _ x)))
       (vec_extend (VecExtendOp.Sxtl) x $true (lane_size ty)))
 
 ;;;; Rules for `uwiden_high` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule -1 (lower (has_type ty (uwiden_high x)))
+(rule -1 (lower (has_type ty (uwiden_high _ x)))
       (vec_extend (VecExtendOp.Uxtl) x $true (lane_size ty)))
diff --git a/cranelift/codegen/src/isa/aarch64/mod.rs b/cranelift/codegen/src/isa/aarch64/mod.rs
index ec724abbf444..c1da4e3f1b27 100644
--- a/cranelift/codegen/src/isa/aarch64/mod.rs
+++ b/cranelift/codegen/src/isa/aarch64/mod.rs
@@ -21,6 +21,7 @@ use target_lexicon::{Aarch64Architecture, Architecture, OperatingSystem, Triple}
 mod abi;
 pub mod inst;
 mod lower;
+mod pcc;
 pub mod settings;
 
 use self::inst::EmitInfo;
@@ -178,12 +179,30 @@ impl TargetIsa for AArch64Backend {
         inst::Inst::function_alignment()
     }
 
+    fn page_size_align_log2(&self) -> u8 {
+        use target_lexicon::*;
+        match self.triple().operating_system {
+            OperatingSystem::MacOSX { .. }
+            | OperatingSystem::Darwin
+            | OperatingSystem::Ios
+            | OperatingSystem::Tvos => {
+                debug_assert_eq!(1 << 14, 0x4000);
+                14
+            }
+            _ => {
+                debug_assert_eq!(1 << 16, 0x10000);
+                16
+            }
+        }
+    }
+
     #[cfg(feature = "disas")]
     fn to_capstone(&self) -> Result<capstone::Capstone, capstone::Error> {
         use capstone::prelude::*;
         let mut cs = Capstone::new()
             .arm64()
             .mode(arch::arm64::ArchMode::Arm)
+            .detail(true)
             .build()?;
         // AArch64 uses inline constants rather than a separate constant pool right now.
         // Without this option, Capstone will stop disassembling as soon as it sees
diff --git a/cranelift/codegen/src/isa/aarch64/pcc.rs b/cranelift/codegen/src/isa/aarch64/pcc.rs
new file mode 100644
index 000000000000..46a0a48bac03
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/pcc.rs
@@ -0,0 +1,570 @@
+//! Proof-carrying code checking for AArch64 VCode.
+
+use crate::ir::pcc::*;
+use crate::ir::types::*;
+use crate::ir::MemFlags;
+use crate::isa::aarch64::inst::args::{Cond, PairAMode, ShiftOp};
+use crate::isa::aarch64::inst::regs::zero_reg;
+use crate::isa::aarch64::inst::Inst;
+use crate::isa::aarch64::inst::{ALUOp, MoveWideOp};
+use crate::isa::aarch64::inst::{AMode, ExtendOp};
+use crate::machinst::pcc::*;
+use crate::machinst::Reg;
+use crate::machinst::{InsnIndex, VCode};
+use crate::trace;
+
+fn extend_fact(ctx: &FactContext, value: &Fact, mode: ExtendOp) -> Option<Fact> {
+    match mode {
+        ExtendOp::UXTB => ctx.uextend(value, 8, 64),
+        ExtendOp::UXTH => ctx.uextend(value, 16, 64),
+        ExtendOp::UXTW => ctx.uextend(value, 32, 64),
+        ExtendOp::UXTX => Some(value.clone()),
+        ExtendOp::SXTB => ctx.sextend(value, 8, 64),
+        ExtendOp::SXTH => ctx.sextend(value, 16, 64),
+        ExtendOp::SXTW => ctx.sextend(value, 32, 64),
+        ExtendOp::SXTX => None,
+    }
+}
+
+/// Flow-state between facts.
+#[derive(Clone, Debug, Default)]
+pub struct FactFlowState {
+    cmp_flags: Option<(Fact, Fact)>,
+}
+
+pub(crate) fn check(
+    ctx: &FactContext,
+    vcode: &mut VCode<Inst>,
+    inst_idx: InsnIndex,
+    state: &mut FactFlowState,
+) -> PccResult<()> {
+    let inst = &vcode[inst_idx];
+    trace!("Checking facts on inst: {:?}", inst);
+
+    // We only persist flag state for one instruction, because we
+    // can't exhaustively enumerate all flags-effecting ops; so take
+    // the `cmp_state` here and perhaps use it below but don't let it
+    // remain.
+    let cmp_flags = state.cmp_flags.take();
+    trace!(" * with cmp_flags = {cmp_flags:?}");
+
+    match *inst {
+        Inst::Args { .. } => {
+            // Defs on the args have "axiomatic facts": we trust the
+            // ABI code to pass through the values unharmed, so the
+            // facts given to us in the CLIF should still be true.
+            Ok(())
+        }
+        Inst::ULoad8 { rd, ref mem, flags }
+        | Inst::SLoad8 { rd, ref mem, flags }
+        | Inst::ULoad16 { rd, ref mem, flags }
+        | Inst::SLoad16 { rd, ref mem, flags }
+        | Inst::ULoad32 { rd, ref mem, flags }
+        | Inst::SLoad32 { rd, ref mem, flags }
+        | Inst::ULoad64 { rd, ref mem, flags } => {
+            let access_ty = inst.mem_type().unwrap();
+            check_load(ctx, Some(rd.to_reg()), flags, mem, vcode, access_ty)
+        }
+        Inst::FpuLoad16 { ref mem, flags, .. }
+        | Inst::FpuLoad32 { ref mem, flags, .. }
+        | Inst::FpuLoad64 { ref mem, flags, .. }
+        | Inst::FpuLoad128 { ref mem, flags, .. } => {
+            let access_ty = inst.mem_type().unwrap();
+            check_load(ctx, None, flags, mem, vcode, access_ty)
+        }
+        Inst::LoadP64 { ref mem, flags, .. } => check_load_pair(ctx, flags, mem, vcode, 16),
+        Inst::FpuLoadP64 { ref mem, flags, .. } => check_load_pair(ctx, flags, mem, vcode, 16),
+        Inst::FpuLoadP128 { ref mem, flags, .. } => check_load_pair(ctx, flags, mem, vcode, 32),
+        Inst::VecLoadReplicate {
+            rn, flags, size, ..
+        } => check_load_addr(ctx, flags, rn, vcode, size.lane_size().ty()),
+        Inst::LoadAcquire {
+            access_ty,
+            rn,
+            flags,
+            ..
+        } => check_load_addr(ctx, flags, rn, vcode, access_ty),
+
+        Inst::Store8 { rd, ref mem, flags }
+        | Inst::Store16 { rd, ref mem, flags }
+        | Inst::Store32 { rd, ref mem, flags }
+        | Inst::Store64 { rd, ref mem, flags } => {
+            let access_ty = inst.mem_type().unwrap();
+            check_store(ctx, Some(rd), flags, mem, vcode, access_ty)
+        }
+        Inst::FpuStore16 { ref mem, flags, .. }
+        | Inst::FpuStore32 { ref mem, flags, .. }
+        | Inst::FpuStore64 { ref mem, flags, .. }
+        | Inst::FpuStore128 { ref mem, flags, .. } => {
+            let access_ty = inst.mem_type().unwrap();
+            check_store(ctx, None, flags, mem, vcode, access_ty)
+        }
+        Inst::StoreP64 { ref mem, flags, .. } => check_store_pair(ctx, flags, mem, vcode, 16),
+        Inst::FpuStoreP64 { ref mem, flags, .. } => check_store_pair(ctx, flags, mem, vcode, 16),
+        Inst::FpuStoreP128 { ref mem, flags, .. } => check_store_pair(ctx, flags, mem, vcode, 32),
+        Inst::StoreRelease {
+            access_ty,
+            rn,
+            flags,
+            ..
+        } => check_store_addr(ctx, flags, rn, vcode, access_ty),
+
+        Inst::AluRRR {
+            alu_op: ALUOp::Add | ALUOp::AddS,
+            size,
+            rd,
+            rn,
+            rm,
+        } => check_binop(ctx, vcode, 64, rd, rn, rm, |rn, rm| {
+            clamp_range(
+                ctx,
+                64,
+                size.bits().into(),
+                ctx.add(rn, rm, size.bits().into()),
+            )
+        }),
+        Inst::AluRRImm12 {
+            alu_op: ALUOp::Add | ALUOp::AddS,
+            size,
+            rd,
+            rn,
+            imm12,
+        } => check_unop(ctx, vcode, 64, rd, rn, |rn| {
+            let imm12: i64 = imm12.value().into();
+            clamp_range(
+                ctx,
+                64,
+                size.bits().into(),
+                ctx.offset(&rn, size.bits().into(), imm12),
+            )
+        }),
+        Inst::AluRRImm12 {
+            alu_op: ALUOp::Sub,
+            size,
+            rd,
+            rn,
+            imm12,
+        } => check_unop(ctx, vcode, 64, rd, rn, |rn| {
+            let imm12: i64 = imm12.value().into();
+            clamp_range(
+                ctx,
+                64,
+                size.bits().into(),
+                ctx.offset(&rn, size.bits().into(), -imm12),
+            )
+        }),
+        Inst::AluRRR {
+            alu_op: ALUOp::Sub,
+            size,
+            rd,
+            rn,
+            rm,
+        } => check_binop(ctx, vcode, 64, rd, rn, rm, |rn, rm| {
+            if let Some(k) = rm.as_const(64) {
+                clamp_range(
+                    ctx,
+                    64,
+                    size.bits().into(),
+                    ctx.offset(rn, size.bits().into(), -(k as i64)),
+                )
+            } else {
+                clamp_range(ctx, 64, size.bits().into(), None)
+            }
+        }),
+        Inst::AluRRRShift {
+            alu_op: ALUOp::Add | ALUOp::AddS,
+            size,
+            rd,
+            rn,
+            rm,
+            shiftop,
+        } if shiftop.op() == ShiftOp::LSL && has_fact(vcode, rn) && has_fact(vcode, rm) => {
+            check_binop(ctx, vcode, 64, rd, rn, rm, |rn, rm| {
+                let rm_shifted = fail_if_missing(ctx.shl(
+                    &rm,
+                    size.bits().into(),
+                    shiftop.amt().value().into(),
+                ))?;
+                clamp_range(
+                    ctx,
+                    64,
+                    size.bits().into(),
+                    ctx.add(&rn, &rm_shifted, size.bits().into()),
+                )
+            })
+        }
+        Inst::AluRRRExtend {
+            alu_op: ALUOp::Add | ALUOp::AddS,
+            size,
+            rd,
+            rn,
+            rm,
+            extendop,
+        } if has_fact(vcode, rn) && has_fact(vcode, rm) => {
+            check_binop(ctx, vcode, 64, rd, rn, rm, |rn, rm| {
+                let rm_extended = fail_if_missing(extend_fact(ctx, rm, extendop))?;
+                clamp_range(
+                    ctx,
+                    64,
+                    size.bits().into(),
+                    ctx.add(&rn, &rm_extended, size.bits().into()),
+                )
+            })
+        }
+        Inst::AluRRImmShift {
+            alu_op: ALUOp::Lsl,
+            size,
+            rd,
+            rn,
+            immshift,
+        } if has_fact(vcode, rn) => check_unop(ctx, vcode, 64, rd, rn, |rn| {
+            clamp_range(
+                ctx,
+                64,
+                size.bits().into(),
+                ctx.shl(&rn, size.bits().into(), immshift.value().into()),
+            )
+        }),
+        Inst::Extend {
+            rd,
+            rn,
+            signed: false,
+            from_bits,
+            to_bits,
+        } if has_fact(vcode, rn) => check_unop(ctx, vcode, 64, rd, rn, |rn| {
+            clamp_range(
+                ctx,
+                64,
+                to_bits.into(),
+                ctx.uextend(&rn, from_bits.into(), to_bits.into()),
+            )
+        }),
+
+        Inst::AluRRR {
+            alu_op: ALUOp::SubS,
+            size,
+            rd,
+            rn,
+            rm,
+        } if rd.to_reg() == zero_reg() => {
+            // Compare.
+            let rn = get_fact_or_default(vcode, rn, size.bits().into());
+            let rm = get_fact_or_default(vcode, rm, size.bits().into());
+            state.cmp_flags = Some((rn, rm));
+            Ok(())
+        }
+
+        Inst::AluRRImmLogic {
+            alu_op: ALUOp::Orr,
+            size,
+            rd,
+            rn,
+            imml,
+        } if rn == zero_reg() => {
+            let constant = imml.value();
+            check_constant(ctx, vcode, rd, size.bits().into(), constant)
+        }
+
+        Inst::AluRRR { rd, size, .. }
+        | Inst::AluRRImm12 { rd, size, .. }
+        | Inst::AluRRRShift { rd, size, .. }
+        | Inst::AluRRRExtend { rd, size, .. }
+        | Inst::AluRRImmLogic { rd, size, .. }
+        | Inst::AluRRImmShift { rd, size, .. } => check_output(ctx, vcode, rd, &[], |_vcode| {
+            clamp_range(ctx, 64, size.bits().into(), None)
+        }),
+
+        Inst::Extend {
+            rd,
+            from_bits,
+            to_bits,
+            ..
+        } => check_output(ctx, vcode, rd, &[], |_vcode| {
+            clamp_range(ctx, to_bits.into(), from_bits.into(), None)
+        }),
+
+        Inst::MovWide {
+            op: MoveWideOp::MovZ,
+            imm,
+            size: _,
+            rd,
+        } => {
+            let constant = u64::from(imm.bits) << (imm.shift * 16);
+            check_constant(ctx, vcode, rd, 64, constant)
+        }
+
+        Inst::MovWide {
+            op: MoveWideOp::MovN,
+            imm,
+            size,
+            rd,
+        } => {
+            let constant = !(u64::from(imm.bits) << (imm.shift * 16)) & size.max_value();
+            check_constant(ctx, vcode, rd, 64, constant)
+        }
+
+        Inst::MovK { rd, rn, imm, .. } => {
+            let input = get_fact_or_default(vcode, rn, 64);
+            if let Some(input_constant) = input.as_const(64) {
+                let mask = 0xffff << (imm.shift * 16);
+                let constant = u64::from(imm.bits) << (imm.shift * 16);
+                let constant = (input_constant & !mask) | constant;
+                check_constant(ctx, vcode, rd, 64, constant)
+            } else {
+                check_output(ctx, vcode, rd, &[], |_vcode| {
+                    Ok(Some(Fact::max_range_for_width(64)))
+                })
+            }
+        }
+
+        Inst::CSel { rd, cond, rn, rm }
+            if (cond == Cond::Hs || cond == Cond::Hi) && cmp_flags.is_some() =>
+        {
+            let (cmp_lhs, cmp_rhs) = cmp_flags.unwrap();
+            trace!("CSel: cmp {cond:?} ({cmp_lhs:?}, {cmp_rhs:?})");
+
+            check_output(ctx, vcode, rd, &[], |vcode| {
+                // We support transitivity-based reasoning. If the
+                // comparison establishes that
+                //
+                //   (x+K1) <= (y+K2)
+                //
+                // then on the true-side of the select we can edit the maximum
+                // in a DynamicMem or DynamicRange by replacing x's with y's
+                // with appropriate offsets -- this widens the range.
+                //
+                // Likewise, on the false-side of the select we can
+                // replace y's with x's -- this also widens the range. On
+                // the false side we know the inequality is strict, so we
+                // can offset by one.
+
+                // True side: lhs >= rhs (Hs) or lhs > rhs (Hi).
+                let rn = get_fact_or_default(vcode, rn, 64);
+                let lhs_kind = match cond {
+                    Cond::Hs => InequalityKind::Loose,
+                    Cond::Hi => InequalityKind::Strict,
+                    _ => unreachable!(),
+                };
+                let rn = ctx.apply_inequality(&rn, &cmp_lhs, &cmp_rhs, lhs_kind);
+                // false side: rhs < lhs (Hs) or rhs <= lhs (Hi).
+                let rm = get_fact_or_default(vcode, rm, 64);
+                let rhs_kind = match cond {
+                    Cond::Hs => InequalityKind::Strict,
+                    Cond::Hi => InequalityKind::Loose,
+                    _ => unreachable!(),
+                };
+                let rm = ctx.apply_inequality(&rm, &cmp_rhs, &cmp_lhs, rhs_kind);
+                let union = ctx.union(&rn, &rm);
+                // Union the two facts.
+                clamp_range(ctx, 64, 64, union)
+            })
+        }
+
+        _ if vcode.inst_defines_facts(inst_idx) => Err(PccError::UnsupportedFact),
+
+        _ => Ok(()),
+    }
+}
+
+fn check_load(
+    ctx: &FactContext,
+    rd: Option<Reg>,
+    flags: MemFlags,
+    addr: &AMode,
+    vcode: &VCode<Inst>,
+    ty: Type,
+) -> PccResult<()> {
+    let result_fact = rd.and_then(|rd| vcode.vreg_fact(rd.into()));
+    let bits = u16::try_from(ty.bits()).unwrap();
+    check_addr(
+        ctx,
+        flags,
+        addr,
+        vcode,
+        ty,
+        LoadOrStore::Load {
+            result_fact,
+            from_bits: bits,
+            to_bits: bits,
+        },
+    )
+}
+
+fn check_store(
+    ctx: &FactContext,
+    rd: Option<Reg>,
+    flags: MemFlags,
+    addr: &AMode,
+    vcode: &VCode<Inst>,
+    ty: Type,
+) -> PccResult<()> {
+    let stored_fact = rd.and_then(|rd| vcode.vreg_fact(rd.into()));
+    check_addr(
+        ctx,
+        flags,
+        addr,
+        vcode,
+        ty,
+        LoadOrStore::Store { stored_fact },
+    )
+}
+
+fn check_addr<'a>(
+    ctx: &FactContext,
+    flags: MemFlags,
+    addr: &AMode,
+    vcode: &VCode<Inst>,
+    ty: Type,
+    op: LoadOrStore<'a>,
+) -> PccResult<()> {
+    if !flags.checked() {
+        return Ok(());
+    }
+
+    trace!("check_addr: {:?}", addr);
+
+    let check = |addr: &Fact, ty: Type| -> PccResult<()> {
+        match op {
+            LoadOrStore::Load {
+                result_fact,
+                from_bits,
+                to_bits,
+            } => {
+                let loaded_fact =
+                    clamp_range(ctx, to_bits, from_bits, ctx.load(addr, ty)?.cloned())?;
+                trace!(
+                    "checking a load: loaded_fact = {loaded_fact:?} result_fact = {result_fact:?}"
+                );
+                if ctx.subsumes_fact_optionals(loaded_fact.as_ref(), result_fact) {
+                    Ok(())
+                } else {
+                    Err(PccError::UnsupportedFact)
+                }
+            }
+            LoadOrStore::Store { stored_fact } => ctx.store(addr, ty, stored_fact),
+        }
+    };
+
+    match addr {
+        &AMode::RegReg { rn, rm } => {
+            let rn = get_fact_or_default(vcode, rn, 64);
+            let rm = get_fact_or_default(vcode, rm, 64);
+            let sum = fail_if_missing(ctx.add(&rn, &rm, 64))?;
+            trace!("rn = {rn:?} rm = {rm:?} sum = {sum:?}");
+            check(&sum, ty)
+        }
+        &AMode::RegScaled { rn, rm } => {
+            let rn = get_fact_or_default(vcode, rn, 64);
+            let rm = get_fact_or_default(vcode, rm, 64);
+            let rm_scaled = fail_if_missing(ctx.scale(&rm, 64, ty.bytes()))?;
+            let sum = fail_if_missing(ctx.add(&rn, &rm_scaled, 64))?;
+            check(&sum, ty)
+        }
+        &AMode::RegScaledExtended { rn, rm, extendop } => {
+            let rn = get_fact_or_default(vcode, rn, 64);
+            let rm = get_fact_or_default(vcode, rm, 64);
+            let rm_extended = fail_if_missing(extend_fact(ctx, &rm, extendop))?;
+            let rm_scaled = fail_if_missing(ctx.scale(&rm_extended, 64, ty.bytes()))?;
+            let sum = fail_if_missing(ctx.add(&rn, &rm_scaled, 64))?;
+            check(&sum, ty)
+        }
+        &AMode::RegExtended { rn, rm, extendop } => {
+            let rn = get_fact_or_default(vcode, rn, 64);
+            let rm = get_fact_or_default(vcode, rm, 64);
+            let rm_extended = fail_if_missing(extend_fact(ctx, &rm, extendop))?;
+            let sum = fail_if_missing(ctx.add(&rn, &rm_extended, 64))?;
+            check(&sum, ty)?;
+            Ok(())
+        }
+        &AMode::Unscaled { rn, simm9 } => {
+            let rn = get_fact_or_default(vcode, rn, 64);
+            let sum = fail_if_missing(ctx.offset(&rn, 64, simm9.value.into()))?;
+            check(&sum, ty)
+        }
+        &AMode::UnsignedOffset { rn, uimm12 } => {
+            let rn = get_fact_or_default(vcode, rn, 64);
+            // N.B.: the architecture scales the immediate in the
+            // encoded instruction by the size of the loaded type, so
+            // e.g. an offset field of 4095 can mean a load of offset
+            // 32760 (= 4095 * 8) for I64s. The `UImm12Scaled` type
+            // stores the *scaled* value, so we don't need to multiply
+            // (again) by the type's size here.
+            let offset: u64 = uimm12.value().into();
+            // This `unwrap()` will always succeed because the value
+            // will always be positive and much smaller than
+            // `i64::MAX` (see above).
+            let sum = fail_if_missing(ctx.offset(&rn, 64, i64::try_from(offset).unwrap()))?;
+            check(&sum, ty)
+        }
+        &AMode::Label { .. } | &AMode::Const { .. } => {
+            // Always accept: labels and constants must be within the
+            // generated code (else they won't be resolved).
+            Ok(())
+        }
+        &AMode::RegOffset { rn, off, .. } => {
+            let rn = get_fact_or_default(vcode, rn, 64);
+            let sum = fail_if_missing(ctx.offset(&rn, 64, off))?;
+            check(&sum, ty)
+        }
+        &AMode::SPOffset { .. }
+        | &AMode::FPOffset { .. }
+        | &AMode::IncomingArg { .. }
+        | &AMode::SlotOffset { .. }
+        | &AMode::SPPostIndexed { .. }
+        | &AMode::SPPreIndexed { .. } => {
+            // We trust ABI code (for now!) and no lowering rules
+            // lower input value accesses directly to these.
+            Ok(())
+        }
+    }
+}
+
+fn check_load_pair(
+    _ctx: &FactContext,
+    _flags: MemFlags,
+    _addr: &PairAMode,
+    _vcode: &VCode<Inst>,
+    _size: u8,
+) -> PccResult<()> {
+    Err(PccError::UnimplementedInst)
+}
+
+fn check_store_pair(
+    _ctx: &FactContext,
+    _flags: MemFlags,
+    _addr: &PairAMode,
+    _vcode: &VCode<Inst>,
+    _size: u8,
+) -> PccResult<()> {
+    Err(PccError::UnimplementedInst)
+}
+
+fn check_load_addr(
+    ctx: &FactContext,
+    flags: MemFlags,
+    reg: Reg,
+    vcode: &VCode<Inst>,
+    ty: Type,
+) -> PccResult<()> {
+    if !flags.checked() {
+        return Ok(());
+    }
+    let fact = get_fact_or_default(vcode, reg, 64);
+    let _output_fact = ctx.load(&fact, ty)?;
+    Ok(())
+}
+
+fn check_store_addr(
+    ctx: &FactContext,
+    flags: MemFlags,
+    reg: Reg,
+    vcode: &VCode<Inst>,
+    ty: Type,
+) -> PccResult<()> {
+    if !flags.checked() {
+        return Ok(());
+    }
+    let fact = get_fact_or_default(vcode, reg, 64);
+    let _output_fact = ctx.store(&fact, ty, None)?;
+    Ok(())
+}
diff --git a/cranelift/codegen/src/isa/aarch64/settings.rs b/cranelift/codegen/src/isa/aarch64/settings.rs
index 9d3898e7b57c..9a00124d4258 100644
--- a/cranelift/codegen/src/isa/aarch64/settings.rs
+++ b/cranelift/codegen/src/isa/aarch64/settings.rs
@@ -3,7 +3,7 @@
 use crate::settings::{self, detail, Builder, Value};
 use core::fmt;
 
-// Include code generated by `cranelift-codegen/meta/src/gen_settings.rs:`. This file contains a
+// Include code generated by `cranelift/codegen/meta/src/gen_settings.rs:`. This file contains a
 // public `Flags` struct with an impl for all of the settings defined in
-// `cranelift-codegen/meta/src/isa/arm64/settings.rs`.
+// `cranelift/codegen/meta/src/isa/arm64.rs`.
 include!(concat!(env!("OUT_DIR"), "/settings-arm64.rs"));
diff --git a/cranelift/codegen/src/isa/aarch64/spec/alu_rr_imm12.isle b/cranelift/codegen/src/isa/aarch64/spec/alu_rr_imm12.isle
new file mode 100644
index 000000000000..49ac36e42036
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/spec/alu_rr_imm12.isle
@@ -0,0 +1,401 @@
+;; GENERATED BY `isaspec`. DO NOT EDIT!!!
+
+(attr MInst.AluRRImm12 (tag isaspec_generated))
+
+(spec
+    (MInst.AluRRImm12 alu_op size rd rn imm12)
+    (provide
+        (match
+            size
+            ((Size64)
+                (match
+                    alu_op
+                    ((Add)
+                        (and
+                            (=> (not (:shift12 imm12)) (= rd (bvadd rn (zero_ext 64 (extract 11 0 (:bits imm12))))))
+                            (=>
+                                (:shift12 imm12)
+                                (= rd (bvadd rn (zero_ext 64 (concat (extract 11 0 (:bits imm12)) #x000)))))))
+                    ((Sub)
+                        (and
+                            (=>
+                                (not (:shift12 imm12))
+                                (=
+                                    rd
+                                    (bvadd
+                                        (bvadd rn (bvnot (zero_ext 64 (extract 11 0 (:bits imm12)))))
+                                        #x0000000000000001)))
+                            (=>
+                                (:shift12 imm12)
+                                (=
+                                    rd
+                                    (bvadd
+                                        (bvadd rn (bvnot (zero_ext 64 (concat (extract 11 0 (:bits imm12)) #x000))))
+                                        #x0000000000000001)))))
+                    ((AddS)
+                        (and
+                            (=>
+                                (not (:shift12 imm12))
+                                (with
+                                    (t1)
+                                    (and
+                                        (= t1 (zero_ext 64 (extract 11 0 (:bits imm12))))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd rn t1))
+                                                        (bvadd
+                                                            (sign_ext 128 rn)
+                                                            (zero_ext 128 (extract 11 0 (:bits imm12)))))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd rn t1))
+                                                        (bvadd (zero_ext 128 rn) (zero_ext 128 t1)))
+                                                    #b1
+                                                    #b0)))
+                                        (= (:Z (:flags_out result)) (if (= (bvadd rn t1) #x0000000000000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 63 63 (bvadd rn t1)))
+                                        (= rd (bvadd rn t1)))))
+                            (=>
+                                (:shift12 imm12)
+                                (with
+                                    (t1 t2)
+                                    (and
+                                        (= t1 (concat (extract 11 0 (:bits imm12)) #x000))
+                                        (= t2 (zero_ext 64 (concat (extract 11 0 (:bits imm12)) #x000)))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd rn t2))
+                                                        (bvadd (sign_ext 128 rn) (zero_ext 128 t1)))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd rn t2))
+                                                        (bvadd (zero_ext 128 rn) (zero_ext 128 t2)))
+                                                    #b1
+                                                    #b0)))
+                                        (= (:Z (:flags_out result)) (if (= (bvadd rn t2) #x0000000000000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 63 63 (bvadd rn t2)))
+                                        (= rd (bvadd rn t2)))))))
+                    ((SubS)
+                        (and
+                            (=>
+                                (not (:shift12 imm12))
+                                (with
+                                    (t1 t3)
+                                    (and
+                                        (= t1 (zero_ext 64 (extract 11 0 (:bits imm12))))
+                                        (= t3 (bvadd rn (bvnot (zero_ext 64 (extract 11 0 (:bits imm12))))))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:Z (:flags_out result))
+                                            (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 63 63 (bvadd t3 #x0000000000000001)))
+                                        (= rd (bvadd t3 #x0000000000000001)))))
+                            (=>
+                                (:shift12 imm12)
+                                (with
+                                    (t1 t3)
+                                    (and
+                                        (= t1 (concat (extract 11 0 (:bits imm12)) #x000))
+                                        (=
+                                            t3
+                                            (bvadd
+                                                rn
+                                                (bvnot (zero_ext 64 (concat (extract 11 0 (:bits imm12)) #x000)))))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (sign_ext 128 rn)
+                                                                (sign_ext 128 (bvnot (zero_ext 64 t1))))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (zero_ext 128 rn)
+                                                                (zero_ext 128 (bvnot (zero_ext 64 t1))))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:Z (:flags_out result))
+                                            (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 63 63 (bvadd t3 #x0000000000000001)))
+                                        (= rd (bvadd t3 #x0000000000000001)))))))))
+            ((Size32)
+                (match
+                    alu_op
+                    ((Add)
+                        (and
+                            (=>
+                                (not (:shift12 imm12))
+                                (=
+                                    rd
+                                    (zero_ext 64 (bvadd (extract 31 0 rn) (zero_ext 32 (extract 11 0 (:bits imm12)))))))
+                            (=>
+                                (:shift12 imm12)
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvadd
+                                            (extract 31 0 rn)
+                                            (zero_ext 32 (concat (extract 11 0 (:bits imm12)) #x000))))))))
+                    ((Sub)
+                        (and
+                            (=>
+                                (not (:shift12 imm12))
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvadd
+                                            (bvadd (extract 31 0 rn) (bvnot (zero_ext 32 (extract 11 0 (:bits imm12)))))
+                                            #x00000001))))
+                            (=>
+                                (:shift12 imm12)
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvadd
+                                            (bvadd
+                                                (extract 31 0 rn)
+                                                (bvnot (zero_ext 32 (concat (extract 11 0 (:bits imm12)) #x000))))
+                                            #x00000001))))))
+                    ((AddS)
+                        (and
+                            (=>
+                                (not (:shift12 imm12))
+                                (with
+                                    (t1 t3)
+                                    (and
+                                        (= t1 (zero_ext 32 (extract 11 0 (:bits imm12))))
+                                        (=
+                                            t3
+                                            (zero_ext
+                                                64
+                                                (bvadd (extract 31 0 rn) (zero_ext 32 (extract 11 0 (:bits imm12))))))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd (extract 31 0 rn) t1))
+                                                        (bvadd
+                                                            (sign_ext 64 (extract 31 0 rn))
+                                                            (zero_ext 64 (extract 11 0 (:bits imm12)))))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (= t3 (bvadd (zero_ext 64 (extract 31 0 rn)) (zero_ext 64 t1)))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:Z (:flags_out result))
+                                            (if (= (bvadd (extract 31 0 rn) t1) #x00000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 31 31 (bvadd (extract 31 0 rn) t1)))
+                                        (= rd t3))))
+                            (=>
+                                (:shift12 imm12)
+                                (with
+                                    (t1 t2 t4)
+                                    (and
+                                        (= t1 (concat (extract 11 0 (:bits imm12)) #x000))
+                                        (= t2 (zero_ext 32 (concat (extract 11 0 (:bits imm12)) #x000)))
+                                        (=
+                                            t4
+                                            (zero_ext
+                                                64
+                                                (bvadd
+                                                    (extract 31 0 rn)
+                                                    (zero_ext 32 (concat (extract 11 0 (:bits imm12)) #x000)))))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd (extract 31 0 rn) t2))
+                                                        (bvadd (sign_ext 64 (extract 31 0 rn)) (zero_ext 64 t1)))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (= t4 (bvadd (zero_ext 64 (extract 31 0 rn)) (zero_ext 64 t2)))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:Z (:flags_out result))
+                                            (if (= (bvadd (extract 31 0 rn) t2) #x00000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 31 31 (bvadd (extract 31 0 rn) t2)))
+                                        (= rd t4))))))
+                    ((SubS)
+                        (and
+                            (=>
+                                (not (:shift12 imm12))
+                                (with
+                                    (t1 t3 t4)
+                                    (and
+                                        (= t1 (zero_ext 32 (extract 11 0 (:bits imm12))))
+                                        (=
+                                            t3
+                                            (bvadd
+                                                (extract 31 0 rn)
+                                                (bvnot (zero_ext 32 (extract 11 0 (:bits imm12))))))
+                                        (=
+                                            t4
+                                            (zero_ext
+                                                64
+                                                (bvadd
+                                                    (bvadd
+                                                        (extract 31 0 rn)
+                                                        (bvnot (zero_ext 32 (extract 11 0 (:bits imm12)))))
+                                                    #x00000001)))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (sign_ext 64 (extract 31 0 rn))
+                                                                (sign_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        t4
+                                                        (bvadd
+                                                            (bvadd
+                                                                (zero_ext 64 (extract 31 0 rn))
+                                                                (zero_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= (:Z (:flags_out result)) (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 31 31 (bvadd t3 #x00000001)))
+                                        (= rd t4))))
+                            (=>
+                                (:shift12 imm12)
+                                (with
+                                    (t1 t3 t4)
+                                    (and
+                                        (= t1 (concat (extract 11 0 (:bits imm12)) #x000))
+                                        (=
+                                            t3
+                                            (bvadd
+                                                (extract 31 0 rn)
+                                                (bvnot (zero_ext 32 (concat (extract 11 0 (:bits imm12)) #x000)))))
+                                        (=
+                                            t4
+                                            (zero_ext
+                                                64
+                                                (bvadd
+                                                    (bvadd
+                                                        (extract 31 0 rn)
+                                                        (bvnot
+                                                            (zero_ext 32 (concat (extract 11 0 (:bits imm12)) #x000))))
+                                                    #x00000001)))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (sign_ext 64 (extract 31 0 rn))
+                                                                (sign_ext 64 (bvnot (zero_ext 32 t1))))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        t4
+                                                        (bvadd
+                                                            (bvadd
+                                                                (zero_ext 64 (extract 31 0 rn))
+                                                                (zero_ext 64 (bvnot (zero_ext 32 t1))))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= (:Z (:flags_out result)) (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 31 31 (bvadd t3 #x00000001)))
+                                        (= rd t4))))))))))
+    (require
+        (match
+            size
+            ((Size64)
+                (match
+                    alu_op
+                    ((Add) (or (not (:shift12 imm12)) (:shift12 imm12)))
+                    ((Sub) (or (not (:shift12 imm12)) (:shift12 imm12)))
+                    ((AddS) (or (not (:shift12 imm12)) (:shift12 imm12)))
+                    ((SubS) (or (not (:shift12 imm12)) (:shift12 imm12)))))
+            ((Size32)
+                (match
+                    alu_op
+                    ((Add) (or (not (:shift12 imm12)) (:shift12 imm12)))
+                    ((Sub) (or (not (:shift12 imm12)) (:shift12 imm12)))
+                    ((AddS) (or (not (:shift12 imm12)) (:shift12 imm12)))
+                    ((SubS) (or (not (:shift12 imm12)) (:shift12 imm12))))))))
diff --git a/cranelift/codegen/src/isa/aarch64/spec/alu_rrr.isle b/cranelift/codegen/src/isa/aarch64/spec/alu_rrr.isle
new file mode 100644
index 000000000000..f897f28d23d4
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/spec/alu_rrr.isle
@@ -0,0 +1,267 @@
+;; GENERATED BY `isaspec`. DO NOT EDIT!!!
+
+(attr MInst.AluRRR (tag isaspec_generated))
+
+(spec
+    (MInst.AluRRR alu_op size rd rn rm)
+    (provide
+        (match
+            size
+            ((Size64)
+                (match
+                    alu_op
+                    ((Add) (= rd (bvadd rn rm)))
+                    ((Sub) (= rd (bvadd (bvadd rn (bvnot rm)) #x0000000000000001)))
+                    ((Orr) (= rd (bvor rn rm)))
+                    ((OrrNot) (= rd (bvor rn (bvnot rm))))
+                    ((And) (= rd (bvand rn rm)))
+                    ((AndNot) (= rd (bvand rn (bvnot rm))))
+                    ((Eor) (= rd (bvxor rn rm)))
+                    ((EorNot) (= rd (bvxor rn (bvnot rm))))
+                    ((AddS)
+                        (with
+                            (t2)
+                            (and
+                                (= t2 (bvadd rn rm))
+                                (=
+                                    (:V (:flags_out result))
+                                    (bvnot
+                                        (if (= (sign_ext 128 t2) (bvadd (sign_ext 128 rn) (sign_ext 128 rm))) #b1 #b0)))
+                                (=
+                                    (:C (:flags_out result))
+                                    (bvnot
+                                        (if (= (zero_ext 128 t2) (bvadd (zero_ext 128 rn) (zero_ext 128 rm))) #b1 #b0)))
+                                (= (:Z (:flags_out result)) (if (= t2 #x0000000000000000) #b1 #b0))
+                                (= (:N (:flags_out result)) (extract 63 63 t2))
+                                (= rd t2))))
+                    ((SubS)
+                        (with
+                            (t1 t3)
+                            (and
+                                (= t1 (bvnot rm))
+                                (= t3 (bvadd rn (bvnot rm)))
+                                (=
+                                    (:V (:flags_out result))
+                                    (bvnot
+                                        (if
+                                            (=
+                                                (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                (bvadd
+                                                    (bvadd (sign_ext 128 rn) (sign_ext 128 t1))
+                                                    #x00000000000000000000000000000001))
+                                            #b1
+                                            #b0)))
+                                (=
+                                    (:C (:flags_out result))
+                                    (bvnot
+                                        (if
+                                            (=
+                                                (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                (bvadd
+                                                    (bvadd (zero_ext 128 rn) (zero_ext 128 t1))
+                                                    #x00000000000000000000000000000001))
+                                            #b1
+                                            #b0)))
+                                (=
+                                    (:Z (:flags_out result))
+                                    (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                (= (:N (:flags_out result)) (extract 63 63 (bvadd t3 #x0000000000000001)))
+                                (= rd (bvadd t3 #x0000000000000001)))))
+                    ((SMulH) (= rd (extract 127 64 (bvmul (sign_ext 128 rn) (sign_ext 128 rm)))))
+                    ((UMulH) (= rd (extract 127 64 (bvmul (zero_ext 128 rn) (zero_ext 128 rm)))))
+                    ((SDiv)
+                        (with
+                            (t1 t2 t4)
+                            (and
+                                (= t1 (= rm #x0000000000000000))
+                                (if
+                                    t1
+                                    (= t2 #x0000000000000000)
+                                    (=
+                                        t4
+                                        (extract
+                                            63
+                                            0
+                                            (if
+                                                (and (= rn #x8000000000000000) (= rm #xffffffffffffffff))
+                                                #x00000000000000008000000000000000
+                                                (sign_ext 128 (bvsdiv rn rm))))))
+                                (= rd (if t1 t2 t4)))))
+                    ((UDiv)
+                        (with
+                            (t1 t2 t4)
+                            (and
+                                (= t1 (= rm #x0000000000000000))
+                                (if
+                                    t1
+                                    (= t2 #x0000000000000000)
+                                    (= t4 (extract 63 0 (bvsdiv (zero_ext 128 rn) (zero_ext 128 rm)))))
+                                (= rd (if t1 t2 t4)))))
+                    ((RotR)
+                        (with
+                            (t1 t3 t4 t5)
+                            (and
+                                (= t1 (= (extract 5 0 rm) #b000000))
+                                (if
+                                    t1
+                                    (= t3 rn)
+                                    (and
+                                        (not (= (extract 5 0 rm) #b000000))
+                                        (=
+                                            t4
+                                            (bvor
+                                                (bvlshr rn (zero_ext 64 (extract 5 0 rm)))
+                                                (bvshl rn (zero_ext 64 (bvsub #x40 (zero_ext 8 (extract 5 0 rm)))))))))
+                                (= t5 (if t1 t3 t4))
+                                (= rd t5))))
+                    ((Lsr) (= rd (bvlshr rn (zero_ext 64 (extract 5 0 rm)))))
+                    ((Asr) (= rd (bvashr rn (zero_ext 64 (extract 5 0 rm)))))
+                    ((Lsl) (= rd (bvshl rn (zero_ext 64 (extract 5 0 rm)))))
+                    ((Adc) (= rd (bvadd (bvadd rn rm) (zero_ext 64 (extract 0 0 (:C (:flags_in result)))))))))
+            ((Size32)
+                (match
+                    alu_op
+                    ((Add) (= rd (zero_ext 64 (bvadd (extract 31 0 rn) (extract 31 0 rm)))))
+                    ((Sub) (= rd (zero_ext 64 (bvadd (bvadd (extract 31 0 rn) (bvnot (extract 31 0 rm))) #x00000001))))
+                    ((Orr) (= rd (zero_ext 64 (bvor (extract 31 0 rn) (extract 31 0 rm)))))
+                    ((OrrNot) (= rd (zero_ext 64 (bvor (extract 31 0 rn) (bvnot (extract 31 0 rm))))))
+                    ((And) (= rd (zero_ext 64 (bvand (extract 31 0 rn) (extract 31 0 rm)))))
+                    ((AndNot) (= rd (zero_ext 64 (bvand (extract 31 0 rn) (bvnot (extract 31 0 rm))))))
+                    ((Eor) (= rd (zero_ext 64 (bvxor (extract 31 0 rn) (extract 31 0 rm)))))
+                    ((EorNot) (= rd (zero_ext 64 (bvxor (extract 31 0 rn) (bvnot (extract 31 0 rm))))))
+                    ((AddS)
+                        (with
+                            (t2 t3)
+                            (and
+                                (= t2 (bvadd (extract 31 0 rn) (extract 31 0 rm)))
+                                (= t3 (zero_ext 64 (bvadd (extract 31 0 rn) (extract 31 0 rm))))
+                                (=
+                                    (:V (:flags_out result))
+                                    (bvnot
+                                        (if
+                                            (=
+                                                (sign_ext 64 t2)
+                                                (bvadd (sign_ext 64 (extract 31 0 rn)) (sign_ext 64 (extract 31 0 rm))))
+                                            #b1
+                                            #b0)))
+                                (=
+                                    (:C (:flags_out result))
+                                    (bvnot
+                                        (if
+                                            (=
+                                                t3
+                                                (bvadd (zero_ext 64 (extract 31 0 rn)) (zero_ext 64 (extract 31 0 rm))))
+                                            #b1
+                                            #b0)))
+                                (= (:Z (:flags_out result)) (if (= t2 #x00000000) #b1 #b0))
+                                (= (:N (:flags_out result)) (extract 31 31 t2))
+                                (= rd t3))))
+                    ((SubS)
+                        (with
+                            (t1 t3 t4)
+                            (and
+                                (= t1 (bvnot (extract 31 0 rm)))
+                                (= t3 (bvadd (extract 31 0 rn) (bvnot (extract 31 0 rm))))
+                                (=
+                                    t4
+                                    (zero_ext
+                                        64
+                                        (bvadd (bvadd (extract 31 0 rn) (bvnot (extract 31 0 rm))) #x00000001)))
+                                (=
+                                    (:V (:flags_out result))
+                                    (bvnot
+                                        (if
+                                            (=
+                                                (sign_ext 64 (bvadd t3 #x00000001))
+                                                (bvadd
+                                                    (bvadd (sign_ext 64 (extract 31 0 rn)) (sign_ext 64 t1))
+                                                    #x0000000000000001))
+                                            #b1
+                                            #b0)))
+                                (=
+                                    (:C (:flags_out result))
+                                    (bvnot
+                                        (if
+                                            (=
+                                                t4
+                                                (bvadd
+                                                    (bvadd (zero_ext 64 (extract 31 0 rn)) (zero_ext 64 t1))
+                                                    #x0000000000000001))
+                                            #b1
+                                            #b0)))
+                                (= (:Z (:flags_out result)) (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                (= (:N (:flags_out result)) (extract 31 31 (bvadd t3 #x00000001)))
+                                (= rd t4))))
+                    ((RotR)
+                        (with
+                            (t1 t3 t4 t5)
+                            (and
+                                (= t1 (= (extract 4 0 rm) #b00000))
+                                (if
+                                    t1
+                                    (= t3 (extract 31 0 rn))
+                                    (and
+                                        (not (= (extract 4 0 rm) #b00000))
+                                        (=
+                                            t4
+                                            (bvor
+                                                (bvlshr (extract 31 0 rn) (zero_ext 32 (extract 4 0 rm)))
+                                                (bvshl
+                                                    (extract 31 0 rn)
+                                                    (zero_ext 32 (bvsub #x20 (zero_ext 8 (extract 4 0 rm)))))))))
+                                (= t5 (if t1 t3 t4))
+                                (= rd (zero_ext 64 t5)))))
+                    ((Lsr) (= rd (zero_ext 64 (bvlshr (extract 31 0 rn) (zero_ext 32 (extract 4 0 rm))))))
+                    ((Asr) (= rd (zero_ext 64 (bvashr (extract 31 0 rn) (zero_ext 32 (extract 4 0 rm))))))
+                    ((Lsl) (= rd (zero_ext 64 (bvshl (extract 31 0 rn) (zero_ext 32 (extract 4 0 rm))))))
+                    ((Adc)
+                        (=
+                            rd
+                            (zero_ext
+                                64
+                                (bvadd
+                                    (bvadd (extract 31 0 rn) (extract 31 0 rm))
+                                    (zero_ext 32 (extract 0 0 (:C (:flags_in result))))))))))))
+    (require
+        (match
+            size
+            ((Size64)
+                (match
+                    alu_op
+                    ((Add) true)
+                    ((Sub) true)
+                    ((Orr) true)
+                    ((OrrNot) true)
+                    ((And) true)
+                    ((AndNot) true)
+                    ((Eor) true)
+                    ((EorNot) true)
+                    ((AddS) true)
+                    ((SubS) true)
+                    ((SMulH) true)
+                    ((UMulH) true)
+                    ((SDiv) true)
+                    ((UDiv) true)
+                    ((RotR) true)
+                    ((Lsr) true)
+                    ((Asr) true)
+                    ((Lsl) true)
+                    ((Adc) true)))
+            ((Size32)
+                (match
+                    alu_op
+                    ((Add) true)
+                    ((Sub) true)
+                    ((Orr) true)
+                    ((OrrNot) true)
+                    ((And) true)
+                    ((AndNot) true)
+                    ((Eor) true)
+                    ((EorNot) true)
+                    ((AddS) true)
+                    ((SubS) true)
+                    ((RotR) true)
+                    ((Lsr) true)
+                    ((Asr) true)
+                    ((Lsl) true)
+                    ((Adc) true))))))
diff --git a/cranelift/codegen/src/isa/aarch64/spec/alu_rrr_extend.isle b/cranelift/codegen/src/isa/aarch64/spec/alu_rrr_extend.isle
new file mode 100644
index 000000000000..2dbdfe3cea21
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/spec/alu_rrr_extend.isle
@@ -0,0 +1,1228 @@
+;; GENERATED BY `isaspec`. DO NOT EDIT!!!
+
+(attr MInst.AluRRRExtend (tag isaspec_generated))
+
+(spec
+    (MInst.AluRRRExtend alu_op size rd rn rm extendop)
+    (provide
+        (match
+            size
+            ((Size64)
+                (match
+                    alu_op
+                    ((Add)
+                        (match
+                            extendop
+                            ((UXTB) (= rd (bvadd rn (zero_ext 64 (extract 7 0 rm)))))
+                            ((UXTH) (= rd (bvadd rn (zero_ext 64 (extract 15 0 rm)))))
+                            ((UXTW) (= rd (bvadd rn (zero_ext 64 (extract 31 0 rm)))))
+                            ((UXTX) (= rd (bvadd rn rm)))
+                            ((SXTB) (= rd (bvadd rn (sign_ext 64 (extract 7 0 rm)))))
+                            ((SXTH) (= rd (bvadd rn (sign_ext 64 (extract 15 0 rm)))))
+                            ((SXTW) (= rd (bvadd rn (sign_ext 64 (extract 31 0 rm)))))
+                            ((SXTX) (= rd (bvadd rn (sign_ext 64 rm))))))
+                    ((Sub)
+                        (match
+                            extendop
+                            ((UXTB) (= rd (bvadd (bvadd rn (bvnot (zero_ext 64 (extract 7 0 rm)))) #x0000000000000001)))
+                            ((UXTH)
+                                (= rd (bvadd (bvadd rn (bvnot (zero_ext 64 (extract 15 0 rm)))) #x0000000000000001)))
+                            ((UXTW)
+                                (= rd (bvadd (bvadd rn (bvnot (zero_ext 64 (extract 31 0 rm)))) #x0000000000000001)))
+                            ((UXTX) (= rd (bvadd (bvadd rn (bvnot rm)) #x0000000000000001)))
+                            ((SXTB) (= rd (bvadd (bvadd rn (bvnot (sign_ext 64 (extract 7 0 rm)))) #x0000000000000001)))
+                            ((SXTH)
+                                (= rd (bvadd (bvadd rn (bvnot (sign_ext 64 (extract 15 0 rm)))) #x0000000000000001)))
+                            ((SXTW)
+                                (= rd (bvadd (bvadd rn (bvnot (sign_ext 64 (extract 31 0 rm)))) #x0000000000000001)))
+                            ((SXTX) (= rd (bvadd (bvadd rn (bvnot (sign_ext 64 rm))) #x0000000000000001)))))
+                    ((AddS)
+                        (match
+                            extendop
+                            ((UXTB)
+                                (with
+                                    (t1)
+                                    (and
+                                        (= t1 (zero_ext 64 (extract 7 0 rm)))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd rn t1))
+                                                        (bvadd (sign_ext 128 rn) (zero_ext 128 (extract 7 0 rm))))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd rn t1))
+                                                        (bvadd (zero_ext 128 rn) (zero_ext 128 t1)))
+                                                    #b1
+                                                    #b0)))
+                                        (= (:Z (:flags_out result)) (if (= (bvadd rn t1) #x0000000000000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 63 63 (bvadd rn t1)))
+                                        (= rd (bvadd rn t1)))))
+                            ((UXTH)
+                                (with
+                                    (t1)
+                                    (and
+                                        (= t1 (zero_ext 64 (extract 15 0 rm)))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd rn t1))
+                                                        (bvadd (sign_ext 128 rn) (zero_ext 128 (extract 15 0 rm))))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd rn t1))
+                                                        (bvadd (zero_ext 128 rn) (zero_ext 128 t1)))
+                                                    #b1
+                                                    #b0)))
+                                        (= (:Z (:flags_out result)) (if (= (bvadd rn t1) #x0000000000000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 63 63 (bvadd rn t1)))
+                                        (= rd (bvadd rn t1)))))
+                            ((UXTW)
+                                (with
+                                    (t1)
+                                    (and
+                                        (= t1 (zero_ext 64 (extract 31 0 rm)))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd rn t1))
+                                                        (bvadd (sign_ext 128 rn) (zero_ext 128 (extract 31 0 rm))))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd rn t1))
+                                                        (bvadd (zero_ext 128 rn) (zero_ext 128 t1)))
+                                                    #b1
+                                                    #b0)))
+                                        (= (:Z (:flags_out result)) (if (= (bvadd rn t1) #x0000000000000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 63 63 (bvadd rn t1)))
+                                        (= rd (bvadd rn t1)))))
+                            ((UXTX)
+                                (with
+                                    (t2)
+                                    (and
+                                        (= t2 (bvadd rn rm))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (= (sign_ext 128 t2) (bvadd (sign_ext 128 rn) (sign_ext 128 rm)))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (= (zero_ext 128 t2) (bvadd (zero_ext 128 rn) (zero_ext 128 rm)))
+                                                    #b1
+                                                    #b0)))
+                                        (= (:Z (:flags_out result)) (if (= t2 #x0000000000000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 63 63 t2))
+                                        (= rd t2))))
+                            ((SXTB)
+                                (with
+                                    (t1 t3)
+                                    (and
+                                        (= t1 (sign_ext 64 (extract 7 0 rm)))
+                                        (= t3 (bvadd rn (sign_ext 64 (extract 7 0 rm))))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (= (sign_ext 128 t3) (bvadd (sign_ext 128 rn) (sign_ext 128 t1)))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (= (zero_ext 128 t3) (bvadd (zero_ext 128 rn) (zero_ext 128 t1)))
+                                                    #b1
+                                                    #b0)))
+                                        (= (:Z (:flags_out result)) (if (= t3 #x0000000000000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 63 63 t3))
+                                        (= rd t3))))
+                            ((SXTH)
+                                (with
+                                    (t1 t3)
+                                    (and
+                                        (= t1 (sign_ext 64 (extract 15 0 rm)))
+                                        (= t3 (bvadd rn (sign_ext 64 (extract 15 0 rm))))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (= (sign_ext 128 t3) (bvadd (sign_ext 128 rn) (sign_ext 128 t1)))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (= (zero_ext 128 t3) (bvadd (zero_ext 128 rn) (zero_ext 128 t1)))
+                                                    #b1
+                                                    #b0)))
+                                        (= (:Z (:flags_out result)) (if (= t3 #x0000000000000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 63 63 t3))
+                                        (= rd t3))))
+                            ((SXTW)
+                                (with
+                                    (t1 t3)
+                                    (and
+                                        (= t1 (sign_ext 64 (extract 31 0 rm)))
+                                        (= t3 (bvadd rn (sign_ext 64 (extract 31 0 rm))))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (= (sign_ext 128 t3) (bvadd (sign_ext 128 rn) (sign_ext 128 t1)))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (= (zero_ext 128 t3) (bvadd (zero_ext 128 rn) (zero_ext 128 t1)))
+                                                    #b1
+                                                    #b0)))
+                                        (= (:Z (:flags_out result)) (if (= t3 #x0000000000000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 63 63 t3))
+                                        (= rd t3))))
+                            ((SXTX)
+                                (with
+                                    (t1 t3)
+                                    (and
+                                        (= t1 (sign_ext 64 rm))
+                                        (= t3 (bvadd rn (sign_ext 64 rm)))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (= (sign_ext 128 t3) (bvadd (sign_ext 128 rn) (sign_ext 128 t1)))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (= (zero_ext 128 t3) (bvadd (zero_ext 128 rn) (zero_ext 128 t1)))
+                                                    #b1
+                                                    #b0)))
+                                        (= (:Z (:flags_out result)) (if (= t3 #x0000000000000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 63 63 t3))
+                                        (= rd t3))))))
+                    ((SubS)
+                        (match
+                            extendop
+                            ((UXTB)
+                                (with
+                                    (t1 t3)
+                                    (and
+                                        (= t1 (zero_ext 64 (extract 7 0 rm)))
+                                        (= t3 (bvadd rn (bvnot (zero_ext 64 (extract 7 0 rm)))))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:Z (:flags_out result))
+                                            (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 63 63 (bvadd t3 #x0000000000000001)))
+                                        (= rd (bvadd t3 #x0000000000000001)))))
+                            ((UXTH)
+                                (with
+                                    (t1 t3)
+                                    (and
+                                        (= t1 (zero_ext 64 (extract 15 0 rm)))
+                                        (= t3 (bvadd rn (bvnot (zero_ext 64 (extract 15 0 rm)))))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:Z (:flags_out result))
+                                            (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 63 63 (bvadd t3 #x0000000000000001)))
+                                        (= rd (bvadd t3 #x0000000000000001)))))
+                            ((UXTW)
+                                (with
+                                    (t1 t3)
+                                    (and
+                                        (= t1 (zero_ext 64 (extract 31 0 rm)))
+                                        (= t3 (bvadd rn (bvnot (zero_ext 64 (extract 31 0 rm)))))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:Z (:flags_out result))
+                                            (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 63 63 (bvadd t3 #x0000000000000001)))
+                                        (= rd (bvadd t3 #x0000000000000001)))))
+                            ((UXTX)
+                                (with
+                                    (t1 t3)
+                                    (and
+                                        (= t1 (bvnot rm))
+                                        (= t3 (bvadd rn (bvnot rm)))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:Z (:flags_out result))
+                                            (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 63 63 (bvadd t3 #x0000000000000001)))
+                                        (= rd (bvadd t3 #x0000000000000001)))))
+                            ((SXTB)
+                                (with
+                                    (t1 t3)
+                                    (and
+                                        (= t1 (sign_ext 64 (extract 7 0 rm)))
+                                        (= t3 (bvadd rn (bvnot (sign_ext 64 (extract 7 0 rm)))))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:Z (:flags_out result))
+                                            (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 63 63 (bvadd t3 #x0000000000000001)))
+                                        (= rd (bvadd t3 #x0000000000000001)))))
+                            ((SXTH)
+                                (with
+                                    (t1 t3)
+                                    (and
+                                        (= t1 (sign_ext 64 (extract 15 0 rm)))
+                                        (= t3 (bvadd rn (bvnot (sign_ext 64 (extract 15 0 rm)))))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:Z (:flags_out result))
+                                            (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 63 63 (bvadd t3 #x0000000000000001)))
+                                        (= rd (bvadd t3 #x0000000000000001)))))
+                            ((SXTW)
+                                (with
+                                    (t1 t3)
+                                    (and
+                                        (= t1 (sign_ext 64 (extract 31 0 rm)))
+                                        (= t3 (bvadd rn (bvnot (sign_ext 64 (extract 31 0 rm)))))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:Z (:flags_out result))
+                                            (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 63 63 (bvadd t3 #x0000000000000001)))
+                                        (= rd (bvadd t3 #x0000000000000001)))))
+                            ((SXTX)
+                                (with
+                                    (t1 t3)
+                                    (and
+                                        (= t1 (sign_ext 64 rm))
+                                        (= t3 (bvadd rn (bvnot (sign_ext 64 rm))))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:Z (:flags_out result))
+                                            (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 63 63 (bvadd t3 #x0000000000000001)))
+                                        (= rd (bvadd t3 #x0000000000000001)))))))))
+            ((Size32)
+                (match
+                    alu_op
+                    ((Add)
+                        (match
+                            extendop
+                            ((UXTB) (= rd (zero_ext 64 (bvadd (extract 31 0 rn) (zero_ext 32 (extract 7 0 rm))))))
+                            ((UXTH) (= rd (zero_ext 64 (bvadd (extract 31 0 rn) (zero_ext 32 (extract 15 0 rm))))))
+                            ((UXTW) (= rd (zero_ext 64 (bvadd (extract 31 0 rn) (extract 31 0 rm)))))
+                            ((UXTX) (= rd (zero_ext 64 (bvadd (extract 31 0 rn) (extract 31 0 rm)))))
+                            ((SXTB) (= rd (zero_ext 64 (bvadd (extract 31 0 rn) (sign_ext 32 (extract 7 0 rm))))))
+                            ((SXTH) (= rd (zero_ext 64 (bvadd (extract 31 0 rn) (sign_ext 32 (extract 15 0 rm))))))
+                            ((SXTW) (= rd (zero_ext 64 (bvadd (extract 31 0 rn) (sign_ext 32 (extract 31 0 rm))))))
+                            ((SXTX) (= rd (zero_ext 64 (bvadd (extract 31 0 rn) (sign_ext 32 (extract 31 0 rm))))))))
+                    ((Sub)
+                        (match
+                            extendop
+                            ((UXTB)
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvadd
+                                            (bvadd (extract 31 0 rn) (bvnot (zero_ext 32 (extract 7 0 rm))))
+                                            #x00000001))))
+                            ((UXTH)
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvadd
+                                            (bvadd (extract 31 0 rn) (bvnot (zero_ext 32 (extract 15 0 rm))))
+                                            #x00000001))))
+                            ((UXTW)
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvadd (bvadd (extract 31 0 rn) (bvnot (extract 31 0 rm))) #x00000001))))
+                            ((UXTX)
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvadd (bvadd (extract 31 0 rn) (bvnot (extract 31 0 rm))) #x00000001))))
+                            ((SXTB)
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvadd
+                                            (bvadd (extract 31 0 rn) (bvnot (sign_ext 32 (extract 7 0 rm))))
+                                            #x00000001))))
+                            ((SXTH)
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvadd
+                                            (bvadd (extract 31 0 rn) (bvnot (sign_ext 32 (extract 15 0 rm))))
+                                            #x00000001))))
+                            ((SXTW)
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvadd
+                                            (bvadd (extract 31 0 rn) (bvnot (sign_ext 32 (extract 31 0 rm))))
+                                            #x00000001))))
+                            ((SXTX)
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvadd
+                                            (bvadd (extract 31 0 rn) (bvnot (sign_ext 32 (extract 31 0 rm))))
+                                            #x00000001))))))
+                    ((AddS)
+                        (match
+                            extendop
+                            ((UXTB)
+                                (with
+                                    (t1 t3)
+                                    (and
+                                        (= t1 (zero_ext 32 (extract 7 0 rm)))
+                                        (= t3 (zero_ext 64 (bvadd (extract 31 0 rn) (zero_ext 32 (extract 7 0 rm)))))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd (extract 31 0 rn) t1))
+                                                        (bvadd
+                                                            (sign_ext 64 (extract 31 0 rn))
+                                                            (zero_ext 64 (extract 7 0 rm))))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (= t3 (bvadd (zero_ext 64 (extract 31 0 rn)) (zero_ext 64 t1)))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:Z (:flags_out result))
+                                            (if (= (bvadd (extract 31 0 rn) t1) #x00000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 31 31 (bvadd (extract 31 0 rn) t1)))
+                                        (= rd t3))))
+                            ((UXTH)
+                                (with
+                                    (t1 t3)
+                                    (and
+                                        (= t1 (zero_ext 32 (extract 15 0 rm)))
+                                        (= t3 (zero_ext 64 (bvadd (extract 31 0 rn) (zero_ext 32 (extract 15 0 rm)))))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd (extract 31 0 rn) t1))
+                                                        (bvadd
+                                                            (sign_ext 64 (extract 31 0 rn))
+                                                            (zero_ext 64 (extract 15 0 rm))))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (= t3 (bvadd (zero_ext 64 (extract 31 0 rn)) (zero_ext 64 t1)))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:Z (:flags_out result))
+                                            (if (= (bvadd (extract 31 0 rn) t1) #x00000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 31 31 (bvadd (extract 31 0 rn) t1)))
+                                        (= rd t3))))
+                            ((UXTW)
+                                (with
+                                    (t2 t3)
+                                    (and
+                                        (= t2 (bvadd (extract 31 0 rn) (extract 31 0 rm)))
+                                        (= t3 (zero_ext 64 (bvadd (extract 31 0 rn) (extract 31 0 rm))))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 t2)
+                                                        (bvadd
+                                                            (sign_ext 64 (extract 31 0 rn))
+                                                            (sign_ext 64 (extract 31 0 rm))))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        t3
+                                                        (bvadd
+                                                            (zero_ext 64 (extract 31 0 rn))
+                                                            (zero_ext 64 (extract 31 0 rm))))
+                                                    #b1
+                                                    #b0)))
+                                        (= (:Z (:flags_out result)) (if (= t2 #x00000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 31 31 t2))
+                                        (= rd t3))))
+                            ((UXTX)
+                                (with
+                                    (t2 t3)
+                                    (and
+                                        (= t2 (bvadd (extract 31 0 rn) (extract 31 0 rm)))
+                                        (= t3 (zero_ext 64 (bvadd (extract 31 0 rn) (extract 31 0 rm))))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 t2)
+                                                        (bvadd
+                                                            (sign_ext 64 (extract 31 0 rn))
+                                                            (sign_ext 64 (extract 31 0 rm))))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        t3
+                                                        (bvadd
+                                                            (zero_ext 64 (extract 31 0 rn))
+                                                            (zero_ext 64 (extract 31 0 rm))))
+                                                    #b1
+                                                    #b0)))
+                                        (= (:Z (:flags_out result)) (if (= t2 #x00000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 31 31 t2))
+                                        (= rd t3))))
+                            ((SXTB)
+                                (with
+                                    (t1 t3 t4)
+                                    (and
+                                        (= t1 (sign_ext 32 (extract 7 0 rm)))
+                                        (= t3 (bvadd (extract 31 0 rn) (sign_ext 32 (extract 7 0 rm))))
+                                        (= t4 (zero_ext 64 (bvadd (extract 31 0 rn) (sign_ext 32 (extract 7 0 rm)))))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 t3)
+                                                        (bvadd (sign_ext 64 (extract 31 0 rn)) (sign_ext 64 t1)))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (= t4 (bvadd (zero_ext 64 (extract 31 0 rn)) (zero_ext 64 t1)))
+                                                    #b1
+                                                    #b0)))
+                                        (= (:Z (:flags_out result)) (if (= t3 #x00000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 31 31 t3))
+                                        (= rd t4))))
+                            ((SXTH)
+                                (with
+                                    (t1 t3 t4)
+                                    (and
+                                        (= t1 (sign_ext 32 (extract 15 0 rm)))
+                                        (= t3 (bvadd (extract 31 0 rn) (sign_ext 32 (extract 15 0 rm))))
+                                        (= t4 (zero_ext 64 (bvadd (extract 31 0 rn) (sign_ext 32 (extract 15 0 rm)))))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 t3)
+                                                        (bvadd (sign_ext 64 (extract 31 0 rn)) (sign_ext 64 t1)))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (= t4 (bvadd (zero_ext 64 (extract 31 0 rn)) (zero_ext 64 t1)))
+                                                    #b1
+                                                    #b0)))
+                                        (= (:Z (:flags_out result)) (if (= t3 #x00000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 31 31 t3))
+                                        (= rd t4))))
+                            ((SXTW)
+                                (with
+                                    (t1 t3 t4)
+                                    (and
+                                        (= t1 (sign_ext 32 (extract 31 0 rm)))
+                                        (= t3 (bvadd (extract 31 0 rn) (sign_ext 32 (extract 31 0 rm))))
+                                        (= t4 (zero_ext 64 (bvadd (extract 31 0 rn) (sign_ext 32 (extract 31 0 rm)))))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 t3)
+                                                        (bvadd (sign_ext 64 (extract 31 0 rn)) (sign_ext 64 t1)))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (= t4 (bvadd (zero_ext 64 (extract 31 0 rn)) (zero_ext 64 t1)))
+                                                    #b1
+                                                    #b0)))
+                                        (= (:Z (:flags_out result)) (if (= t3 #x00000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 31 31 t3))
+                                        (= rd t4))))
+                            ((SXTX)
+                                (with
+                                    (t1 t3 t4)
+                                    (and
+                                        (= t1 (sign_ext 32 (extract 31 0 rm)))
+                                        (= t3 (bvadd (extract 31 0 rn) (sign_ext 32 (extract 31 0 rm))))
+                                        (= t4 (zero_ext 64 (bvadd (extract 31 0 rn) (sign_ext 32 (extract 31 0 rm)))))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 t3)
+                                                        (bvadd (sign_ext 64 (extract 31 0 rn)) (sign_ext 64 t1)))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (= t4 (bvadd (zero_ext 64 (extract 31 0 rn)) (zero_ext 64 t1)))
+                                                    #b1
+                                                    #b0)))
+                                        (= (:Z (:flags_out result)) (if (= t3 #x00000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 31 31 t3))
+                                        (= rd t4))))))
+                    ((SubS)
+                        (match
+                            extendop
+                            ((UXTB)
+                                (with
+                                    (t1 t3 t4)
+                                    (and
+                                        (= t1 (zero_ext 32 (extract 7 0 rm)))
+                                        (= t3 (bvadd (extract 31 0 rn) (bvnot (zero_ext 32 (extract 7 0 rm)))))
+                                        (=
+                                            t4
+                                            (zero_ext
+                                                64
+                                                (bvadd
+                                                    (bvadd (extract 31 0 rn) (bvnot (zero_ext 32 (extract 7 0 rm))))
+                                                    #x00000001)))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (sign_ext 64 (extract 31 0 rn))
+                                                                (sign_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        t4
+                                                        (bvadd
+                                                            (bvadd
+                                                                (zero_ext 64 (extract 31 0 rn))
+                                                                (zero_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= (:Z (:flags_out result)) (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 31 31 (bvadd t3 #x00000001)))
+                                        (= rd t4))))
+                            ((UXTH)
+                                (with
+                                    (t1 t3 t4)
+                                    (and
+                                        (= t1 (zero_ext 32 (extract 15 0 rm)))
+                                        (= t3 (bvadd (extract 31 0 rn) (bvnot (zero_ext 32 (extract 15 0 rm)))))
+                                        (=
+                                            t4
+                                            (zero_ext
+                                                64
+                                                (bvadd
+                                                    (bvadd (extract 31 0 rn) (bvnot (zero_ext 32 (extract 15 0 rm))))
+                                                    #x00000001)))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (sign_ext 64 (extract 31 0 rn))
+                                                                (sign_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        t4
+                                                        (bvadd
+                                                            (bvadd
+                                                                (zero_ext 64 (extract 31 0 rn))
+                                                                (zero_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= (:Z (:flags_out result)) (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 31 31 (bvadd t3 #x00000001)))
+                                        (= rd t4))))
+                            ((UXTW)
+                                (with
+                                    (t1 t3 t4)
+                                    (and
+                                        (= t1 (bvnot (extract 31 0 rm)))
+                                        (= t3 (bvadd (extract 31 0 rn) (bvnot (extract 31 0 rm))))
+                                        (=
+                                            t4
+                                            (zero_ext
+                                                64
+                                                (bvadd (bvadd (extract 31 0 rn) (bvnot (extract 31 0 rm))) #x00000001)))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 64 (extract 31 0 rn)) (sign_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        t4
+                                                        (bvadd
+                                                            (bvadd (zero_ext 64 (extract 31 0 rn)) (zero_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= (:Z (:flags_out result)) (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 31 31 (bvadd t3 #x00000001)))
+                                        (= rd t4))))
+                            ((UXTX)
+                                (with
+                                    (t1 t3 t4)
+                                    (and
+                                        (= t1 (bvnot (extract 31 0 rm)))
+                                        (= t3 (bvadd (extract 31 0 rn) (bvnot (extract 31 0 rm))))
+                                        (=
+                                            t4
+                                            (zero_ext
+                                                64
+                                                (bvadd (bvadd (extract 31 0 rn) (bvnot (extract 31 0 rm))) #x00000001)))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 64 (extract 31 0 rn)) (sign_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        t4
+                                                        (bvadd
+                                                            (bvadd (zero_ext 64 (extract 31 0 rn)) (zero_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= (:Z (:flags_out result)) (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 31 31 (bvadd t3 #x00000001)))
+                                        (= rd t4))))
+                            ((SXTB)
+                                (with
+                                    (t1 t3 t4)
+                                    (and
+                                        (= t1 (sign_ext 32 (extract 7 0 rm)))
+                                        (= t3 (bvadd (extract 31 0 rn) (bvnot (sign_ext 32 (extract 7 0 rm)))))
+                                        (=
+                                            t4
+                                            (zero_ext
+                                                64
+                                                (bvadd
+                                                    (bvadd (extract 31 0 rn) (bvnot (sign_ext 32 (extract 7 0 rm))))
+                                                    #x00000001)))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (sign_ext 64 (extract 31 0 rn))
+                                                                (sign_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        t4
+                                                        (bvadd
+                                                            (bvadd
+                                                                (zero_ext 64 (extract 31 0 rn))
+                                                                (zero_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= (:Z (:flags_out result)) (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 31 31 (bvadd t3 #x00000001)))
+                                        (= rd t4))))
+                            ((SXTH)
+                                (with
+                                    (t1 t3 t4)
+                                    (and
+                                        (= t1 (sign_ext 32 (extract 15 0 rm)))
+                                        (= t3 (bvadd (extract 31 0 rn) (bvnot (sign_ext 32 (extract 15 0 rm)))))
+                                        (=
+                                            t4
+                                            (zero_ext
+                                                64
+                                                (bvadd
+                                                    (bvadd (extract 31 0 rn) (bvnot (sign_ext 32 (extract 15 0 rm))))
+                                                    #x00000001)))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (sign_ext 64 (extract 31 0 rn))
+                                                                (sign_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        t4
+                                                        (bvadd
+                                                            (bvadd
+                                                                (zero_ext 64 (extract 31 0 rn))
+                                                                (zero_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= (:Z (:flags_out result)) (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 31 31 (bvadd t3 #x00000001)))
+                                        (= rd t4))))
+                            ((SXTW)
+                                (with
+                                    (t1 t3 t4)
+                                    (and
+                                        (= t1 (sign_ext 32 (extract 31 0 rm)))
+                                        (= t3 (bvadd (extract 31 0 rn) (bvnot (sign_ext 32 (extract 31 0 rm)))))
+                                        (=
+                                            t4
+                                            (zero_ext
+                                                64
+                                                (bvadd
+                                                    (bvadd (extract 31 0 rn) (bvnot (sign_ext 32 (extract 31 0 rm))))
+                                                    #x00000001)))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (sign_ext 64 (extract 31 0 rn))
+                                                                (sign_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        t4
+                                                        (bvadd
+                                                            (bvadd
+                                                                (zero_ext 64 (extract 31 0 rn))
+                                                                (zero_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= (:Z (:flags_out result)) (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 31 31 (bvadd t3 #x00000001)))
+                                        (= rd t4))))
+                            ((SXTX)
+                                (with
+                                    (t1 t3 t4)
+                                    (and
+                                        (= t1 (sign_ext 32 (extract 31 0 rm)))
+                                        (= t3 (bvadd (extract 31 0 rn) (bvnot (sign_ext 32 (extract 31 0 rm)))))
+                                        (=
+                                            t4
+                                            (zero_ext
+                                                64
+                                                (bvadd
+                                                    (bvadd (extract 31 0 rn) (bvnot (sign_ext 32 (extract 31 0 rm))))
+                                                    #x00000001)))
+                                        (=
+                                            (:V (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (sign_ext 64 (extract 31 0 rn))
+                                                                (sign_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            (:C (:flags_out result))
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        t4
+                                                        (bvadd
+                                                            (bvadd
+                                                                (zero_ext 64 (extract 31 0 rn))
+                                                                (zero_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= (:Z (:flags_out result)) (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= (:N (:flags_out result)) (extract 31 31 (bvadd t3 #x00000001)))
+                                        (= rd t4))))))))))
+    (require
+        (match
+            size
+            ((Size64)
+                (match
+                    alu_op
+                    ((Add)
+                        (match
+                            extendop
+                            ((UXTB) true)
+                            ((UXTH) true)
+                            ((UXTW) true)
+                            ((UXTX) true)
+                            ((SXTB) true)
+                            ((SXTH) true)
+                            ((SXTW) true)
+                            ((SXTX) true)))
+                    ((Sub)
+                        (match
+                            extendop
+                            ((UXTB) true)
+                            ((UXTH) true)
+                            ((UXTW) true)
+                            ((UXTX) true)
+                            ((SXTB) true)
+                            ((SXTH) true)
+                            ((SXTW) true)
+                            ((SXTX) true)))
+                    ((AddS)
+                        (match
+                            extendop
+                            ((UXTB) true)
+                            ((UXTH) true)
+                            ((UXTW) true)
+                            ((UXTX) true)
+                            ((SXTB) true)
+                            ((SXTH) true)
+                            ((SXTW) true)
+                            ((SXTX) true)))
+                    ((SubS)
+                        (match
+                            extendop
+                            ((UXTB) true)
+                            ((UXTH) true)
+                            ((UXTW) true)
+                            ((UXTX) true)
+                            ((SXTB) true)
+                            ((SXTH) true)
+                            ((SXTW) true)
+                            ((SXTX) true)))))
+            ((Size32)
+                (match
+                    alu_op
+                    ((Add)
+                        (match
+                            extendop
+                            ((UXTB) true)
+                            ((UXTH) true)
+                            ((UXTW) true)
+                            ((UXTX) true)
+                            ((SXTB) true)
+                            ((SXTH) true)
+                            ((SXTW) true)
+                            ((SXTX) true)))
+                    ((Sub)
+                        (match
+                            extendop
+                            ((UXTB) true)
+                            ((UXTH) true)
+                            ((UXTW) true)
+                            ((UXTX) true)
+                            ((SXTB) true)
+                            ((SXTH) true)
+                            ((SXTW) true)
+                            ((SXTX) true)))
+                    ((AddS)
+                        (match
+                            extendop
+                            ((UXTB) true)
+                            ((UXTH) true)
+                            ((UXTW) true)
+                            ((UXTX) true)
+                            ((SXTB) true)
+                            ((SXTH) true)
+                            ((SXTW) true)
+                            ((SXTX) true)))
+                    ((SubS)
+                        (match
+                            extendop
+                            ((UXTB) true)
+                            ((UXTH) true)
+                            ((UXTW) true)
+                            ((UXTX) true)
+                            ((SXTB) true)
+                            ((SXTH) true)
+                            ((SXTW) true)
+                            ((SXTX) true))))))))
diff --git a/cranelift/codegen/src/isa/aarch64/spec/alu_rrr_shift.isle b/cranelift/codegen/src/isa/aarch64/spec/alu_rrr_shift.isle
new file mode 100644
index 000000000000..0595017bbb41
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/spec/alu_rrr_shift.isle
@@ -0,0 +1,614 @@
+;; GENERATED BY `isaspec`. DO NOT EDIT!!!
+
+(attr MInst.AluRRRShift (tag isaspec_generated))
+
+(spec
+    (MInst.AluRRRShift alu_op size rd rn rm shiftop)
+    (provide
+        (match
+            alu_op
+            ((Add)
+                (match
+                    (:op shiftop)
+                    ((Lsl)
+                        (and
+                            (=>
+                                (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                                (= rd (bvadd rn (bvshl rm (zero_ext 64 (extract 5 0 (extract 5 0 (:amt shiftop))))))))
+                            (=>
+                                (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvadd
+                                            (extract 31 0 rn)
+                                            (bvshl
+                                                (extract 31 0 rm)
+                                                (zero_ext 32 (extract 4 0 (extract 4 0 (:amt shiftop)))))))))))
+                    ((Lsr)
+                        (and
+                            (=>
+                                (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                                (= rd (bvadd rn (bvlshr rm (zero_ext 64 (extract 5 0 (extract 5 0 (:amt shiftop))))))))
+                            (=>
+                                (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvadd
+                                            (extract 31 0 rn)
+                                            (bvlshr
+                                                (extract 31 0 rm)
+                                                (zero_ext 32 (extract 4 0 (extract 4 0 (:amt shiftop)))))))))))
+                    ((Asr)
+                        (and
+                            (=>
+                                (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                                (= rd (bvadd rn (bvashr rm (zero_ext 64 (extract 5 0 (extract 5 0 (:amt shiftop))))))))
+                            (=>
+                                (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvadd
+                                            (extract 31 0 rn)
+                                            (bvashr
+                                                (extract 31 0 rm)
+                                                (zero_ext 32 (extract 4 0 (extract 4 0 (:amt shiftop)))))))))))))
+            ((Sub)
+                (match
+                    (:op shiftop)
+                    ((Lsl)
+                        (and
+                            (=>
+                                (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                                (=
+                                    rd
+                                    (bvadd
+                                        (bvadd
+                                            rn
+                                            (bvnot (bvshl rm (zero_ext 64 (extract 5 0 (extract 5 0 (:amt shiftop)))))))
+                                        #x0000000000000001)))
+                            (=>
+                                (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvadd
+                                            (bvadd
+                                                (extract 31 0 rn)
+                                                (bvnot
+                                                    (bvshl
+                                                        (extract 31 0 rm)
+                                                        (zero_ext 32 (extract 4 0 (extract 4 0 (:amt shiftop)))))))
+                                            #x00000001))))))
+                    ((Lsr)
+                        (and
+                            (=>
+                                (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                                (=
+                                    rd
+                                    (bvadd
+                                        (bvadd
+                                            rn
+                                            (bvnot
+                                                (bvlshr rm (zero_ext 64 (extract 5 0 (extract 5 0 (:amt shiftop)))))))
+                                        #x0000000000000001)))
+                            (=>
+                                (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvadd
+                                            (bvadd
+                                                (extract 31 0 rn)
+                                                (bvnot
+                                                    (bvlshr
+                                                        (extract 31 0 rm)
+                                                        (zero_ext 32 (extract 4 0 (extract 4 0 (:amt shiftop)))))))
+                                            #x00000001))))))
+                    ((Asr)
+                        (and
+                            (=>
+                                (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                                (=
+                                    rd
+                                    (bvadd
+                                        (bvadd
+                                            rn
+                                            (bvnot
+                                                (bvashr rm (zero_ext 64 (extract 5 0 (extract 5 0 (:amt shiftop)))))))
+                                        #x0000000000000001)))
+                            (=>
+                                (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvadd
+                                            (bvadd
+                                                (extract 31 0 rn)
+                                                (bvnot
+                                                    (bvashr
+                                                        (extract 31 0 rm)
+                                                        (zero_ext 32 (extract 4 0 (extract 4 0 (:amt shiftop)))))))
+                                            #x00000001))))))))
+            ((Orr)
+                (match
+                    (:op shiftop)
+                    ((Lsl)
+                        (and
+                            (=>
+                                (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                                (= rd (bvor rn (bvshl rm (zero_ext 64 (extract 5 0 (extract 5 0 (:amt shiftop))))))))
+                            (=>
+                                (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvor
+                                            (extract 31 0 rn)
+                                            (bvshl
+                                                (extract 31 0 rm)
+                                                (zero_ext 32 (extract 4 0 (extract 4 0 (:amt shiftop)))))))))))
+                    ((Lsr)
+                        (and
+                            (=>
+                                (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                                (= rd (bvor rn (bvlshr rm (zero_ext 64 (extract 5 0 (extract 5 0 (:amt shiftop))))))))
+                            (=>
+                                (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvor
+                                            (extract 31 0 rn)
+                                            (bvlshr
+                                                (extract 31 0 rm)
+                                                (zero_ext 32 (extract 4 0 (extract 4 0 (:amt shiftop)))))))))))
+                    ((Asr)
+                        (and
+                            (=>
+                                (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                                (= rd (bvor rn (bvashr rm (zero_ext 64 (extract 5 0 (extract 5 0 (:amt shiftop))))))))
+                            (=>
+                                (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvor
+                                            (extract 31 0 rn)
+                                            (bvashr
+                                                (extract 31 0 rm)
+                                                (zero_ext 32 (extract 4 0 (extract 4 0 (:amt shiftop)))))))))))))
+            ((And)
+                (match
+                    (:op shiftop)
+                    ((Lsl)
+                        (and
+                            (=>
+                                (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                                (= rd (bvand rn (bvshl rm (zero_ext 64 (extract 5 0 (extract 5 0 (:amt shiftop))))))))
+                            (=>
+                                (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvand
+                                            (extract 31 0 rn)
+                                            (bvshl
+                                                (extract 31 0 rm)
+                                                (zero_ext 32 (extract 4 0 (extract 4 0 (:amt shiftop)))))))))))
+                    ((Lsr)
+                        (and
+                            (=>
+                                (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                                (= rd (bvand rn (bvlshr rm (zero_ext 64 (extract 5 0 (extract 5 0 (:amt shiftop))))))))
+                            (=>
+                                (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvand
+                                            (extract 31 0 rn)
+                                            (bvlshr
+                                                (extract 31 0 rm)
+                                                (zero_ext 32 (extract 4 0 (extract 4 0 (:amt shiftop)))))))))))
+                    ((Asr)
+                        (and
+                            (=>
+                                (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                                (= rd (bvand rn (bvashr rm (zero_ext 64 (extract 5 0 (extract 5 0 (:amt shiftop))))))))
+                            (=>
+                                (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvand
+                                            (extract 31 0 rn)
+                                            (bvashr
+                                                (extract 31 0 rm)
+                                                (zero_ext 32 (extract 4 0 (extract 4 0 (:amt shiftop)))))))))))))
+            ((Eor)
+                (match
+                    (:op shiftop)
+                    ((Lsl)
+                        (and
+                            (=>
+                                (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                                (= rd (bvxor rn (bvshl rm (zero_ext 64 (extract 5 0 (extract 5 0 (:amt shiftop))))))))
+                            (=>
+                                (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvxor
+                                            (extract 31 0 rn)
+                                            (bvshl
+                                                (extract 31 0 rm)
+                                                (zero_ext 32 (extract 4 0 (extract 4 0 (:amt shiftop)))))))))))
+                    ((Lsr)
+                        (and
+                            (=>
+                                (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                                (= rd (bvxor rn (bvlshr rm (zero_ext 64 (extract 5 0 (extract 5 0 (:amt shiftop))))))))
+                            (=>
+                                (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvxor
+                                            (extract 31 0 rn)
+                                            (bvlshr
+                                                (extract 31 0 rm)
+                                                (zero_ext 32 (extract 4 0 (extract 4 0 (:amt shiftop)))))))))))
+                    ((Asr)
+                        (and
+                            (=>
+                                (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                                (= rd (bvxor rn (bvashr rm (zero_ext 64 (extract 5 0 (extract 5 0 (:amt shiftop))))))))
+                            (=>
+                                (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvxor
+                                            (extract 31 0 rn)
+                                            (bvashr
+                                                (extract 31 0 rm)
+                                                (zero_ext 32 (extract 4 0 (extract 4 0 (:amt shiftop)))))))))))))
+            ((OrrNot)
+                (match
+                    (:op shiftop)
+                    ((Lsl)
+                        (and
+                            (=>
+                                (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                                (=
+                                    rd
+                                    (bvor
+                                        rn
+                                        (bvnot (bvshl rm (zero_ext 64 (extract 5 0 (extract 5 0 (:amt shiftop)))))))))
+                            (=>
+                                (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvor
+                                            (extract 31 0 rn)
+                                            (bvnot
+                                                (bvshl
+                                                    (extract 31 0 rm)
+                                                    (zero_ext 32 (extract 4 0 (extract 4 0 (:amt shiftop))))))))))))
+                    ((Lsr)
+                        (and
+                            (=>
+                                (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                                (=
+                                    rd
+                                    (bvor
+                                        rn
+                                        (bvnot (bvlshr rm (zero_ext 64 (extract 5 0 (extract 5 0 (:amt shiftop)))))))))
+                            (=>
+                                (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvor
+                                            (extract 31 0 rn)
+                                            (bvnot
+                                                (bvlshr
+                                                    (extract 31 0 rm)
+                                                    (zero_ext 32 (extract 4 0 (extract 4 0 (:amt shiftop))))))))))))
+                    ((Asr)
+                        (and
+                            (=>
+                                (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                                (=
+                                    rd
+                                    (bvor
+                                        rn
+                                        (bvnot (bvashr rm (zero_ext 64 (extract 5 0 (extract 5 0 (:amt shiftop)))))))))
+                            (=>
+                                (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvor
+                                            (extract 31 0 rn)
+                                            (bvnot
+                                                (bvashr
+                                                    (extract 31 0 rm)
+                                                    (zero_ext 32 (extract 4 0 (extract 4 0 (:amt shiftop))))))))))))))
+            ((EorNot)
+                (match
+                    (:op shiftop)
+                    ((Lsl)
+                        (and
+                            (=>
+                                (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                                (=
+                                    rd
+                                    (bvxor
+                                        rn
+                                        (bvnot (bvshl rm (zero_ext 64 (extract 5 0 (extract 5 0 (:amt shiftop)))))))))
+                            (=>
+                                (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvxor
+                                            (extract 31 0 rn)
+                                            (bvnot
+                                                (bvshl
+                                                    (extract 31 0 rm)
+                                                    (zero_ext 32 (extract 4 0 (extract 4 0 (:amt shiftop))))))))))))
+                    ((Lsr)
+                        (and
+                            (=>
+                                (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                                (=
+                                    rd
+                                    (bvxor
+                                        rn
+                                        (bvnot (bvlshr rm (zero_ext 64 (extract 5 0 (extract 5 0 (:amt shiftop)))))))))
+                            (=>
+                                (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvxor
+                                            (extract 31 0 rn)
+                                            (bvnot
+                                                (bvlshr
+                                                    (extract 31 0 rm)
+                                                    (zero_ext 32 (extract 4 0 (extract 4 0 (:amt shiftop))))))))))))
+                    ((Asr)
+                        (and
+                            (=>
+                                (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                                (=
+                                    rd
+                                    (bvxor
+                                        rn
+                                        (bvnot (bvashr rm (zero_ext 64 (extract 5 0 (extract 5 0 (:amt shiftop)))))))))
+                            (=>
+                                (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvxor
+                                            (extract 31 0 rn)
+                                            (bvnot
+                                                (bvashr
+                                                    (extract 31 0 rm)
+                                                    (zero_ext 32 (extract 4 0 (extract 4 0 (:amt shiftop))))))))))))))
+            ((AndNot)
+                (match
+                    (:op shiftop)
+                    ((Lsl)
+                        (and
+                            (=>
+                                (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                                (=
+                                    rd
+                                    (bvand
+                                        rn
+                                        (bvnot (bvshl rm (zero_ext 64 (extract 5 0 (extract 5 0 (:amt shiftop)))))))))
+                            (=>
+                                (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvand
+                                            (extract 31 0 rn)
+                                            (bvnot
+                                                (bvshl
+                                                    (extract 31 0 rm)
+                                                    (zero_ext 32 (extract 4 0 (extract 4 0 (:amt shiftop))))))))))))
+                    ((Lsr)
+                        (and
+                            (=>
+                                (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                                (=
+                                    rd
+                                    (bvand
+                                        rn
+                                        (bvnot (bvlshr rm (zero_ext 64 (extract 5 0 (extract 5 0 (:amt shiftop)))))))))
+                            (=>
+                                (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvand
+                                            (extract 31 0 rn)
+                                            (bvnot
+                                                (bvlshr
+                                                    (extract 31 0 rm)
+                                                    (zero_ext 32 (extract 4 0 (extract 4 0 (:amt shiftop))))))))))))
+                    ((Asr)
+                        (and
+                            (=>
+                                (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                                (=
+                                    rd
+                                    (bvand
+                                        rn
+                                        (bvnot (bvashr rm (zero_ext 64 (extract 5 0 (extract 5 0 (:amt shiftop)))))))))
+                            (=>
+                                (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))
+                                (=
+                                    rd
+                                    (zero_ext
+                                        64
+                                        (bvand
+                                            (extract 31 0 rn)
+                                            (bvnot
+                                                (bvashr
+                                                    (extract 31 0 rm)
+                                                    (zero_ext 32 (extract 4 0 (extract 4 0 (:amt shiftop))))))))))))))))
+    (require
+        (match
+            alu_op
+            ((Add)
+                (match
+                    (:op shiftop)
+                    ((Lsl)
+                        (or
+                            (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                            (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))))
+                    ((Lsr)
+                        (or
+                            (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                            (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))))
+                    ((Asr)
+                        (or
+                            (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                            (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))))))
+            ((Sub)
+                (match
+                    (:op shiftop)
+                    ((Lsl)
+                        (or
+                            (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                            (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))))
+                    ((Lsr)
+                        (or
+                            (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                            (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))))
+                    ((Asr)
+                        (or
+                            (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                            (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))))))
+            ((Orr)
+                (match
+                    (:op shiftop)
+                    ((Lsl)
+                        (or
+                            (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                            (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))))
+                    ((Lsr)
+                        (or
+                            (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                            (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))))
+                    ((Asr)
+                        (or
+                            (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                            (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))))))
+            ((And)
+                (match
+                    (:op shiftop)
+                    ((Lsl)
+                        (or
+                            (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                            (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))))
+                    ((Lsr)
+                        (or
+                            (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                            (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))))
+                    ((Asr)
+                        (or
+                            (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                            (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))))))
+            ((Eor)
+                (match
+                    (:op shiftop)
+                    ((Lsl)
+                        (or
+                            (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                            (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))))
+                    ((Lsr)
+                        (or
+                            (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                            (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))))
+                    ((Asr)
+                        (or
+                            (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                            (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))))))
+            ((OrrNot)
+                (match
+                    (:op shiftop)
+                    ((Lsl)
+                        (or
+                            (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                            (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))))
+                    ((Lsr)
+                        (or
+                            (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                            (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))))
+                    ((Asr)
+                        (or
+                            (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                            (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))))))
+            ((EorNot)
+                (match
+                    (:op shiftop)
+                    ((Lsl)
+                        (or
+                            (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                            (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))))
+                    ((Lsr)
+                        (or
+                            (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                            (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))))
+                    ((Asr)
+                        (or
+                            (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                            (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))))))
+            ((AndNot)
+                (match
+                    (:op shiftop)
+                    ((Lsl)
+                        (or
+                            (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                            (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))))
+                    ((Lsr)
+                        (or
+                            (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                            (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000))))
+                    ((Asr)
+                        (or
+                            (and (Size64? size) (= (extract 7 6 (:amt shiftop)) #b00))
+                            (and (Size32? size) (= (extract 7 5 (:amt shiftop)) #b000)))))))))
diff --git a/cranelift/codegen/src/isa/aarch64/spec/alu_rrrr.isle b/cranelift/codegen/src/isa/aarch64/spec/alu_rrrr.isle
new file mode 100644
index 000000000000..f9f9ff7ace99
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/spec/alu_rrrr.isle
@@ -0,0 +1,23 @@
+;; GENERATED BY `isaspec`. DO NOT EDIT!!!
+
+(attr MInst.AluRRRR (tag isaspec_generated))
+
+(spec
+    (MInst.AluRRRR alu_op size rd rn rm ra)
+    (provide
+        (match
+            size
+            ((Size64) (match alu_op ((MAdd) (= rd (bvadd ra (bvmul rn rm)))) ((MSub) (= rd (bvsub ra (bvmul rn rm))))))
+            ((Size32)
+                (match
+                    alu_op
+                    ((MAdd) (= rd (zero_ext 64 (bvadd (extract 31 0 ra) (bvmul (extract 31 0 rn) (extract 31 0 rm))))))
+                    ((MSub) (= rd (zero_ext 64 (bvsub (extract 31 0 ra) (bvmul (extract 31 0 rn) (extract 31 0 rm))))))
+                    ((UMAddL) (= rd (bvadd ra (bvmul (zero_ext 64 (extract 31 0 rn)) (zero_ext 64 (extract 31 0 rm))))))
+                    ((SMAddL)
+                        (= rd (bvadd ra (bvmul (sign_ext 64 (extract 31 0 rn)) (sign_ext 64 (extract 31 0 rm))))))))))
+    (require
+        (match
+            size
+            ((Size64) (match alu_op ((MAdd) true) ((MSub) true)))
+            ((Size32) (match alu_op ((MAdd) true) ((MSub) true) ((UMAddL) true) ((SMAddL) true))))))
diff --git a/cranelift/codegen/src/isa/aarch64/spec/bit_rr.isle b/cranelift/codegen/src/isa/aarch64/spec/bit_rr.isle
new file mode 100644
index 000000000000..3b8f6153fbac
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/spec/bit_rr.isle
@@ -0,0 +1,5062 @@
+;; GENERATED BY `isaspec`. DO NOT EDIT!!!
+
+(attr MInst.BitRR (tag isaspec_generated))
+
+(spec
+    (MInst.BitRR op size rd rn)
+    (provide
+        (match
+            size
+            ((Size64)
+                (match
+                    op
+                    ((Cls)
+                        (with
+                            (t1
+                                t10
+                                t100
+                                t101
+                                t102
+                                t103
+                                t104
+                                t105
+                                t106
+                                t107
+                                t108
+                                t109
+                                t11
+                                t110
+                                t111
+                                t112
+                                t113
+                                t114
+                                t115
+                                t116
+                                t117
+                                t118
+                                t119
+                                t12
+                                t120
+                                t121
+                                t122
+                                t123
+                                t124
+                                t125
+                                t126
+                                t127
+                                t128
+                                t129
+                                t13
+                                t130
+                                t131
+                                t132
+                                t133
+                                t134
+                                t135
+                                t136
+                                t137
+                                t138
+                                t139
+                                t14
+                                t140
+                                t141
+                                t142
+                                t143
+                                t144
+                                t145
+                                t146
+                                t147
+                                t148
+                                t149
+                                t15
+                                t150
+                                t151
+                                t152
+                                t153
+                                t154
+                                t155
+                                t156
+                                t157
+                                t158
+                                t159
+                                t16
+                                t160
+                                t161
+                                t162
+                                t163
+                                t164
+                                t165
+                                t166
+                                t167
+                                t168
+                                t169
+                                t17
+                                t170
+                                t171
+                                t172
+                                t173
+                                t174
+                                t175
+                                t176
+                                t177
+                                t178
+                                t179
+                                t18
+                                t180
+                                t181
+                                t182
+                                t183
+                                t184
+                                t185
+                                t186
+                                t187
+                                t188
+                                t189
+                                t19
+                                t190
+                                t191
+                                t2
+                                t20
+                                t21
+                                t22
+                                t23
+                                t24
+                                t25
+                                t26
+                                t27
+                                t28
+                                t29
+                                t3
+                                t30
+                                t31
+                                t32
+                                t33
+                                t34
+                                t35
+                                t36
+                                t37
+                                t38
+                                t39
+                                t4
+                                t40
+                                t41
+                                t42
+                                t43
+                                t44
+                                t45
+                                t46
+                                t47
+                                t48
+                                t49
+                                t5
+                                t50
+                                t51
+                                t52
+                                t53
+                                t54
+                                t55
+                                t56
+                                t57
+                                t58
+                                t59
+                                t6
+                                t60
+                                t61
+                                t62
+                                t63
+                                t64
+                                t65
+                                t66
+                                t67
+                                t68
+                                t69
+                                t7
+                                t70
+                                t71
+                                t72
+                                t73
+                                t74
+                                t75
+                                t76
+                                t77
+                                t78
+                                t79
+                                t8
+                                t80
+                                t81
+                                t82
+                                t83
+                                t84
+                                t85
+                                t86
+                                t87
+                                t88
+                                t89
+                                t9
+                                t90
+                                t91
+                                t92
+                                t93
+                                t94
+                                t95
+                                t96
+                                t97
+                                t98
+                                t99)
+                            (and
+                                (= t1 (bvxor (extract 63 1 (as rn (bv 64))) (extract 62 0 (as rn (bv 64)))))
+                                (= t2 (= (extract 62 62 t1) #b1))
+                                (if
+                                    t2
+                                    (= t3 #x003e)
+                                    (and
+                                        (= t4 (= (extract 61 61 (extract 61 0 t1)) #b1))
+                                        (if
+                                            t4
+                                            (= t5 #x003d)
+                                            (and
+                                                (= t6 (= (extract 60 60 (extract 60 0 t1)) #b1))
+                                                (if
+                                                    t6
+                                                    (= t7 #x003c)
+                                                    (and
+                                                        (= t8 (= (extract 59 59 (extract 59 0 t1)) #b1))
+                                                        (if
+                                                            t8
+                                                            (= t9 #x003b)
+                                                            (and
+                                                                (= t10 (= (extract 58 58 (extract 58 0 t1)) #b1))
+                                                                (if
+                                                                    t10
+                                                                    (= t11 #x003a)
+                                                                    (and
+                                                                        (=
+                                                                            t12
+                                                                            (= (extract 57 57 (extract 57 0 t1)) #b1))
+                                                                        (if
+                                                                            t12
+                                                                            (= t13 #x0039)
+                                                                            (and
+                                                                                (=
+                                                                                    t14
+                                                                                    (=
+                                                                                        (extract
+                                                                                            56
+                                                                                            56
+                                                                                            (extract 56 0 t1))
+                                                                                        #b1))
+                                                                                (if
+                                                                                    t14
+                                                                                    (= t15 #x0038)
+                                                                                    (and
+                                                                                        (=
+                                                                                            t16
+                                                                                            (=
+                                                                                                (extract
+                                                                                                    55
+                                                                                                    55
+                                                                                                    (extract 55 0 t1))
+                                                                                                #b1))
+                                                                                        (if
+                                                                                            t16
+                                                                                            (= t17 #x0037)
+                                                                                            (and
+                                                                                                (=
+                                                                                                    t18
+                                                                                                    (=
+                                                                                                        (extract
+                                                                                                            54
+                                                                                                            54
+                                                                                                            (extract
+                                                                                                                54
+                                                                                                                0
+                                                                                                                t1))
+                                                                                                        #b1))
+                                                                                                (if
+                                                                                                    t18
+                                                                                                    (= t19 #x0036)
+                                                                                                    (and
+                                                                                                        (=
+                                                                                                            t20
+                                                                                                            (=
+                                                                                                                (extract
+                                                                                                                    53
+                                                                                                                    53
+                                                                                                                    (extract
+                                                                                                                        53
+                                                                                                                        0
+                                                                                                                        t1))
+                                                                                                                #b1))
+                                                                                                        (if
+                                                                                                            t20
+                                                                                                            (=
+                                                                                                                t21
+                                                                                                                #x0035)
+                                                                                                            (and
+                                                                                                                (=
+                                                                                                                    t22
+                                                                                                                    (=
+                                                                                                                        (extract
+                                                                                                                            52
+                                                                                                                            52
+                                                                                                                            (extract
+                                                                                                                                52
+                                                                                                                                0
+                                                                                                                                t1))
+                                                                                                                        #b1))
+                                                                                                                (if
+                                                                                                                    t22
+                                                                                                                    (=
+                                                                                                                        t23
+                                                                                                                        #x0034)
+                                                                                                                    (and
+                                                                                                                        (=
+                                                                                                                            t24
+                                                                                                                            (=
+                                                                                                                                (extract
+                                                                                                                                    51
+                                                                                                                                    51
+                                                                                                                                    (extract
+                                                                                                                                        51
+                                                                                                                                        0
+                                                                                                                                        t1))
+                                                                                                                                #b1))
+                                                                                                                        (if
+                                                                                                                            t24
+                                                                                                                            (=
+                                                                                                                                t25
+                                                                                                                                #x0033)
+                                                                                                                            (and
+                                                                                                                                (=
+                                                                                                                                    t26
+                                                                                                                                    (=
+                                                                                                                                        (extract
+                                                                                                                                            50
+                                                                                                                                            50
+                                                                                                                                            (extract
+                                                                                                                                                50
+                                                                                                                                                0
+                                                                                                                                                t1))
+                                                                                                                                        #b1))
+                                                                                                                                (if
+                                                                                                                                    t26
+                                                                                                                                    (=
+                                                                                                                                        t27
+                                                                                                                                        #x0032)
+                                                                                                                                    (and
+                                                                                                                                        (=
+                                                                                                                                            t28
+                                                                                                                                            (=
+                                                                                                                                                (extract
+                                                                                                                                                    49
+                                                                                                                                                    49
+                                                                                                                                                    (extract
+                                                                                                                                                        49
+                                                                                                                                                        0
+                                                                                                                                                        t1))
+                                                                                                                                                #b1))
+                                                                                                                                        (if
+                                                                                                                                            t28
+                                                                                                                                            (=
+                                                                                                                                                t29
+                                                                                                                                                #x0031)
+                                                                                                                                            (and
+                                                                                                                                                (=
+                                                                                                                                                    t30
+                                                                                                                                                    (=
+                                                                                                                                                        (extract
+                                                                                                                                                            48
+                                                                                                                                                            48
+                                                                                                                                                            (extract
+                                                                                                                                                                48
+                                                                                                                                                                0
+                                                                                                                                                                t1))
+                                                                                                                                                        #b1))
+                                                                                                                                                (if
+                                                                                                                                                    t30
+                                                                                                                                                    (=
+                                                                                                                                                        t31
+                                                                                                                                                        #x0030)
+                                                                                                                                                    (and
+                                                                                                                                                        (=
+                                                                                                                                                            t32
+                                                                                                                                                            (=
+                                                                                                                                                                (extract
+                                                                                                                                                                    47
+                                                                                                                                                                    47
+                                                                                                                                                                    (extract
+                                                                                                                                                                        47
+                                                                                                                                                                        0
+                                                                                                                                                                        t1))
+                                                                                                                                                                #b1))
+                                                                                                                                                        (if
+                                                                                                                                                            t32
+                                                                                                                                                            (=
+                                                                                                                                                                t33
+                                                                                                                                                                #x002f)
+                                                                                                                                                            (and
+                                                                                                                                                                (=
+                                                                                                                                                                    t34
+                                                                                                                                                                    (=
+                                                                                                                                                                        (extract
+                                                                                                                                                                            46
+                                                                                                                                                                            46
+                                                                                                                                                                            (extract
+                                                                                                                                                                                46
+                                                                                                                                                                                0
+                                                                                                                                                                                t1))
+                                                                                                                                                                        #b1))
+                                                                                                                                                                (if
+                                                                                                                                                                    t34
+                                                                                                                                                                    (=
+                                                                                                                                                                        t35
+                                                                                                                                                                        #x002e)
+                                                                                                                                                                    (and
+                                                                                                                                                                        (=
+                                                                                                                                                                            t36
+                                                                                                                                                                            (=
+                                                                                                                                                                                (extract
+                                                                                                                                                                                    45
+                                                                                                                                                                                    45
+                                                                                                                                                                                    (extract
+                                                                                                                                                                                        45
+                                                                                                                                                                                        0
+                                                                                                                                                                                        t1))
+                                                                                                                                                                                #b1))
+                                                                                                                                                                        (if
+                                                                                                                                                                            t36
+                                                                                                                                                                            (=
+                                                                                                                                                                                t37
+                                                                                                                                                                                #x002d)
+                                                                                                                                                                            (and
+                                                                                                                                                                                (=
+                                                                                                                                                                                    t38
+                                                                                                                                                                                    (=
+                                                                                                                                                                                        (extract
+                                                                                                                                                                                            44
+                                                                                                                                                                                            44
+                                                                                                                                                                                            (extract
+                                                                                                                                                                                                44
+                                                                                                                                                                                                0
+                                                                                                                                                                                                t1))
+                                                                                                                                                                                        #b1))
+                                                                                                                                                                                (if
+                                                                                                                                                                                    t38
+                                                                                                                                                                                    (=
+                                                                                                                                                                                        t39
+                                                                                                                                                                                        #x002c)
+                                                                                                                                                                                    (and
+                                                                                                                                                                                        (=
+                                                                                                                                                                                            t40
+                                                                                                                                                                                            (=
+                                                                                                                                                                                                (extract
+                                                                                                                                                                                                    43
+                                                                                                                                                                                                    43
+                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                        43
+                                                                                                                                                                                                        0
+                                                                                                                                                                                                        t1))
+                                                                                                                                                                                                #b1))
+                                                                                                                                                                                        (if
+                                                                                                                                                                                            t40
+                                                                                                                                                                                            (=
+                                                                                                                                                                                                t41
+                                                                                                                                                                                                #x002b)
+                                                                                                                                                                                            (and
+                                                                                                                                                                                                (=
+                                                                                                                                                                                                    t42
+                                                                                                                                                                                                    (=
+                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                            42
+                                                                                                                                                                                                            42
+                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                42
+                                                                                                                                                                                                                0
+                                                                                                                                                                                                                t1))
+                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                (if
+                                                                                                                                                                                                    t42
+                                                                                                                                                                                                    (=
+                                                                                                                                                                                                        t43
+                                                                                                                                                                                                        #x002a)
+                                                                                                                                                                                                    (and
+                                                                                                                                                                                                        (=
+                                                                                                                                                                                                            t44
+                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                    41
+                                                                                                                                                                                                                    41
+                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                        41
+                                                                                                                                                                                                                        0
+                                                                                                                                                                                                                        t1))
+                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                        (if
+                                                                                                                                                                                                            t44
+                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                t45
+                                                                                                                                                                                                                #x0029)
+                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                    t46
+                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                            40
+                                                                                                                                                                                                                            40
+                                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                                40
+                                                                                                                                                                                                                                0
+                                                                                                                                                                                                                                t1))
+                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                    t46
+                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                        t47
+                                                                                                                                                                                                                        #x0028)
+                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                            t48
+                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                    39
+                                                                                                                                                                                                                                    39
+                                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                                        39
+                                                                                                                                                                                                                                        0
+                                                                                                                                                                                                                                        t1))
+                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                            t48
+                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                t49
+                                                                                                                                                                                                                                #x0027)
+                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                    t50
+                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                            38
+                                                                                                                                                                                                                                            38
+                                                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                                                38
+                                                                                                                                                                                                                                                0
+                                                                                                                                                                                                                                                t1))
+                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                    t50
+                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                        t51
+                                                                                                                                                                                                                                        #x0026)
+                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                            t52
+                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                    37
+                                                                                                                                                                                                                                                    37
+                                                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                                                        37
+                                                                                                                                                                                                                                                        0
+                                                                                                                                                                                                                                                        t1))
+                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                            t52
+                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                t53
+                                                                                                                                                                                                                                                #x0025)
+                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                    t54
+                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                            36
+                                                                                                                                                                                                                                                            36
+                                                                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                                                                36
+                                                                                                                                                                                                                                                                0
+                                                                                                                                                                                                                                                                t1))
+                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                    t54
+                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                        t55
+                                                                                                                                                                                                                                                        #x0024)
+                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                            t56
+                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                    35
+                                                                                                                                                                                                                                                                    35
+                                                                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                                                                        35
+                                                                                                                                                                                                                                                                        0
+                                                                                                                                                                                                                                                                        t1))
+                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                            t56
+                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                t57
+                                                                                                                                                                                                                                                                #x0023)
+                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                    t58
+                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                            34
+                                                                                                                                                                                                                                                                            34
+                                                                                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                                                                                34
+                                                                                                                                                                                                                                                                                0
+                                                                                                                                                                                                                                                                                t1))
+                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                    t58
+                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                        t59
+                                                                                                                                                                                                                                                                        #x0022)
+                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                            t60
+                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                    33
+                                                                                                                                                                                                                                                                                    33
+                                                                                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                                                                                        33
+                                                                                                                                                                                                                                                                                        0
+                                                                                                                                                                                                                                                                                        t1))
+                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                            t60
+                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                t61
+                                                                                                                                                                                                                                                                                #x0021)
+                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                    t62
+                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                            32
+                                                                                                                                                                                                                                                                                            32
+                                                                                                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                                                                                                32
+                                                                                                                                                                                                                                                                                                0
+                                                                                                                                                                                                                                                                                                t1))
+                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                    t62
+                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                        t63
+                                                                                                                                                                                                                                                                                        #x0020)
+                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                            t64
+                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                    31
+                                                                                                                                                                                                                                                                                                    31
+                                                                                                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                                                                                                        31
+                                                                                                                                                                                                                                                                                                        0
+                                                                                                                                                                                                                                                                                                        t1))
+                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                            t64
+                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                t65
+                                                                                                                                                                                                                                                                                                #x001f)
+                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                    t66
+                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                            30
+                                                                                                                                                                                                                                                                                                            30
+                                                                                                                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                                                                                                                30
+                                                                                                                                                                                                                                                                                                                0
+                                                                                                                                                                                                                                                                                                                t1))
+                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                    t66
+                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                        t67
+                                                                                                                                                                                                                                                                                                        #x001e)
+                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                            t68
+                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                    29
+                                                                                                                                                                                                                                                                                                                    29
+                                                                                                                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                                                                                                                        29
+                                                                                                                                                                                                                                                                                                                        0
+                                                                                                                                                                                                                                                                                                                        t1))
+                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                            t68
+                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                t69
+                                                                                                                                                                                                                                                                                                                #x001d)
+                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                    t70
+                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                            28
+                                                                                                                                                                                                                                                                                                                            28
+                                                                                                                                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                                                                                                                                28
+                                                                                                                                                                                                                                                                                                                                0
+                                                                                                                                                                                                                                                                                                                                t1))
+                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                    t70
+                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                        t71
+                                                                                                                                                                                                                                                                                                                        #x001c)
+                                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                            t72
+                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                                    27
+                                                                                                                                                                                                                                                                                                                                    27
+                                                                                                                                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                                                                                                                                        27
+                                                                                                                                                                                                                                                                                                                                        0
+                                                                                                                                                                                                                                                                                                                                        t1))
+                                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                                            t72
+                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                t73
+                                                                                                                                                                                                                                                                                                                                #x001b)
+                                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                    t74
+                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                                            26
+                                                                                                                                                                                                                                                                                                                                            26
+                                                                                                                                                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                                                                                                                                                26
+                                                                                                                                                                                                                                                                                                                                                0
+                                                                                                                                                                                                                                                                                                                                                t1))
+                                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                                    t74
+                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                        t75
+                                                                                                                                                                                                                                                                                                                                        #x001a)
+                                                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                            t76
+                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                                                    25
+                                                                                                                                                                                                                                                                                                                                                    25
+                                                                                                                                                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                                                                                                                                                        25
+                                                                                                                                                                                                                                                                                                                                                        0
+                                                                                                                                                                                                                                                                                                                                                        t1))
+                                                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                                                            t76
+                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                t77
+                                                                                                                                                                                                                                                                                                                                                #x0019)
+                                                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                    t78
+                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                                                            24
+                                                                                                                                                                                                                                                                                                                                                            24
+                                                                                                                                                                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                                                                                                                                                                24
+                                                                                                                                                                                                                                                                                                                                                                0
+                                                                                                                                                                                                                                                                                                                                                                t1))
+                                                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                                                    t78
+                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                        t79
+                                                                                                                                                                                                                                                                                                                                                        #x0018)
+                                                                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                            t80
+                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                                                                    23
+                                                                                                                                                                                                                                                                                                                                                                    23
+                                                                                                                                                                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                                                                                                                                                                        23
+                                                                                                                                                                                                                                                                                                                                                                        0
+                                                                                                                                                                                                                                                                                                                                                                        t1))
+                                                                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                                                                            t80
+                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                t81
+                                                                                                                                                                                                                                                                                                                                                                #x0017)
+                                                                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                    t82
+                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                                                                            22
+                                                                                                                                                                                                                                                                                                                                                                            22
+                                                                                                                                                                                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                                                                                                                                                                                22
+                                                                                                                                                                                                                                                                                                                                                                                0
+                                                                                                                                                                                                                                                                                                                                                                                t1))
+                                                                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                                                                    t82
+                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                        t83
+                                                                                                                                                                                                                                                                                                                                                                        #x0016)
+                                                                                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                            t84
+                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                                                                                    21
+                                                                                                                                                                                                                                                                                                                                                                                    21
+                                                                                                                                                                                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                                                                                                                                                                                        21
+                                                                                                                                                                                                                                                                                                                                                                                        0
+                                                                                                                                                                                                                                                                                                                                                                                        t1))
+                                                                                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                                                                                            t84
+                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                t85
+                                                                                                                                                                                                                                                                                                                                                                                #x0015)
+                                                                                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                    t86
+                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                                                                                            20
+                                                                                                                                                                                                                                                                                                                                                                                            20
+                                                                                                                                                                                                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                                                                                                                                                                                                20
+                                                                                                                                                                                                                                                                                                                                                                                                0
+                                                                                                                                                                                                                                                                                                                                                                                                t1))
+                                                                                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                                                                                    t86
+                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                        t87
+                                                                                                                                                                                                                                                                                                                                                                                        #x0014)
+                                                                                                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                            t88
+                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                                                                                                    19
+                                                                                                                                                                                                                                                                                                                                                                                                    19
+                                                                                                                                                                                                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                                                                                                                                                                                                        19
+                                                                                                                                                                                                                                                                                                                                                                                                        0
+                                                                                                                                                                                                                                                                                                                                                                                                        t1))
+                                                                                                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                                                                                                            t88
+                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                t89
+                                                                                                                                                                                                                                                                                                                                                                                                #x0013)
+                                                                                                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                    t90
+                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                                                                                                            18
+                                                                                                                                                                                                                                                                                                                                                                                                            18
+                                                                                                                                                                                                                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                18
+                                                                                                                                                                                                                                                                                                                                                                                                                0
+                                                                                                                                                                                                                                                                                                                                                                                                                t1))
+                                                                                                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                                                                                                    t90
+                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                        t91
+                                                                                                                                                                                                                                                                                                                                                                                                        #x0012)
+                                                                                                                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                            t92
+                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                    17
+                                                                                                                                                                                                                                                                                                                                                                                                                    17
+                                                                                                                                                                                                                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                        17
+                                                                                                                                                                                                                                                                                                                                                                                                                        0
+                                                                                                                                                                                                                                                                                                                                                                                                                        t1))
+                                                                                                                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                                                                                                                            t92
+                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                t93
+                                                                                                                                                                                                                                                                                                                                                                                                                #x0011)
+                                                                                                                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                    t94
+                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                            16
+                                                                                                                                                                                                                                                                                                                                                                                                                            16
+                                                                                                                                                                                                                                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                16
+                                                                                                                                                                                                                                                                                                                                                                                                                                0
+                                                                                                                                                                                                                                                                                                                                                                                                                                t1))
+                                                                                                                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                                                                                                                    t94
+                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                        t95
+                                                                                                                                                                                                                                                                                                                                                                                                                        #x0010)
+                                                                                                                                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                            t96
+                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                    15
+                                                                                                                                                                                                                                                                                                                                                                                                                                    15
+                                                                                                                                                                                                                                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                        15
+                                                                                                                                                                                                                                                                                                                                                                                                                                        0
+                                                                                                                                                                                                                                                                                                                                                                                                                                        t1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                                                                                                                                            t96
+                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                t97
+                                                                                                                                                                                                                                                                                                                                                                                                                                #x000f)
+                                                                                                                                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                    t98
+                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                            14
+                                                                                                                                                                                                                                                                                                                                                                                                                                            14
+                                                                                                                                                                                                                                                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                14
+                                                                                                                                                                                                                                                                                                                                                                                                                                                0
+                                                                                                                                                                                                                                                                                                                                                                                                                                                t1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                    t98
+                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                        t99
+                                                                                                                                                                                                                                                                                                                                                                                                                                        #x000e)
+                                                                                                                                                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                            t100
+                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    13
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    13
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        13
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        0
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        t1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                            t100
+                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                t101
+                                                                                                                                                                                                                                                                                                                                                                                                                                                #x000d)
+                                                                                                                                                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    t102
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            12
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            12
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                12
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                0
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                t1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    t102
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        t103
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        #x000c)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            t104
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    11
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    11
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        11
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        0
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            t104
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                t105
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                #x000b)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t106
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            10
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            10
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                10
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                0
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t106
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t107
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        #x000a)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t108
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    9
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    9
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        9
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        0
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t108
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t109
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                #x0009)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t110
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            8
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            8
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                8
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                0
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t110
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t111
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        #x0008)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t112
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    7
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    7
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        7
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        0
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t112
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t113
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                #x0007)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t114
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            6
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            6
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                6
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                0
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t114
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t115
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        #x0006)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t116
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    5
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        5
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        0
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t116
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t117
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                #x0005)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t118
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            4
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            4
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                4
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                0
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t118
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t119
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        #x0004)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t120
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    3
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        3
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        0
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t120
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t121
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                #x0003)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t122
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            2
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            2
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                2
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                0
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t122
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t123
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        #x0002)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t124
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        1
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        0
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t124
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t125
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                #x0001)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t126
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            0
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            0
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t1)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t126
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t127
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        #x0000)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t128
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        #xffff))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t129
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t126
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t127
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t128))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t130
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t124
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t125
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t129))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t131
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t122
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t123
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t130))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t132
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t120
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t121
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t131))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t133
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t118
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t119
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t132))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t134
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t116
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t117
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t133))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t135
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t114
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t115
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t134))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t136
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t112
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t113
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t135))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t137
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t110
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t111
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t136))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t138
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t108
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t109
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t137))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t139
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t106
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t107
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t138))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            t140
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                t104
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                t105
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                t139))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    t141
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        t102
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        t103
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        t140))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                            t142
+                                                                                                                                                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                t100
+                                                                                                                                                                                                                                                                                                                                                                                                                                                t101
+                                                                                                                                                                                                                                                                                                                                                                                                                                                t141))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                    t143
+                                                                                                                                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                        t98
+                                                                                                                                                                                                                                                                                                                                                                                                                                        t99
+                                                                                                                                                                                                                                                                                                                                                                                                                                        t142))))
+                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                            t144
+                                                                                                                                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                t96
+                                                                                                                                                                                                                                                                                                                                                                                                                                t97
+                                                                                                                                                                                                                                                                                                                                                                                                                                t143))))
+                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                    t145
+                                                                                                                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                                                                                                                        t94
+                                                                                                                                                                                                                                                                                                                                                                                                                        t95
+                                                                                                                                                                                                                                                                                                                                                                                                                        t144))))
+                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                            t146
+                                                                                                                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                                                                                                                t92
+                                                                                                                                                                                                                                                                                                                                                                                                                t93
+                                                                                                                                                                                                                                                                                                                                                                                                                t145))))
+                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                    t147
+                                                                                                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                                                                                                        t90
+                                                                                                                                                                                                                                                                                                                                                                                                        t91
+                                                                                                                                                                                                                                                                                                                                                                                                        t146))))
+                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                            t148
+                                                                                                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                                                                                                t88
+                                                                                                                                                                                                                                                                                                                                                                                                t89
+                                                                                                                                                                                                                                                                                                                                                                                                t147))))
+                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                    t149
+                                                                                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                                                                                        t86
+                                                                                                                                                                                                                                                                                                                                                                                        t87
+                                                                                                                                                                                                                                                                                                                                                                                        t148))))
+                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                            t150
+                                                                                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                                                                                t84
+                                                                                                                                                                                                                                                                                                                                                                                t85
+                                                                                                                                                                                                                                                                                                                                                                                t149))))
+                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                    t151
+                                                                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                                                                        t82
+                                                                                                                                                                                                                                                                                                                                                                        t83
+                                                                                                                                                                                                                                                                                                                                                                        t150))))
+                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                            t152
+                                                                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                                                                t80
+                                                                                                                                                                                                                                                                                                                                                                t81
+                                                                                                                                                                                                                                                                                                                                                                t151))))
+                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                    t153
+                                                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                                                        t78
+                                                                                                                                                                                                                                                                                                                                                        t79
+                                                                                                                                                                                                                                                                                                                                                        t152))))
+                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                            t154
+                                                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                                                t76
+                                                                                                                                                                                                                                                                                                                                                t77
+                                                                                                                                                                                                                                                                                                                                                t153))))
+                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                    t155
+                                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                                        t74
+                                                                                                                                                                                                                                                                                                                                        t75
+                                                                                                                                                                                                                                                                                                                                        t154))))
+                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                            t156
+                                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                                t72
+                                                                                                                                                                                                                                                                                                                                t73
+                                                                                                                                                                                                                                                                                                                                t155))))
+                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                    t157
+                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                        t70
+                                                                                                                                                                                                                                                                                                                        t71
+                                                                                                                                                                                                                                                                                                                        t156))))
+                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                            t158
+                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                t68
+                                                                                                                                                                                                                                                                                                                t69
+                                                                                                                                                                                                                                                                                                                t157))))
+                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                    t159
+                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                        t66
+                                                                                                                                                                                                                                                                                                        t67
+                                                                                                                                                                                                                                                                                                        t158))))
+                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                            t160
+                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                t64
+                                                                                                                                                                                                                                                                                                t65
+                                                                                                                                                                                                                                                                                                t159))))
+                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                    t161
+                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                        t62
+                                                                                                                                                                                                                                                                                        t63
+                                                                                                                                                                                                                                                                                        t160))))
+                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                            t162
+                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                t60
+                                                                                                                                                                                                                                                                                t61
+                                                                                                                                                                                                                                                                                t161))))
+                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                    t163
+                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                        t58
+                                                                                                                                                                                                                                                                        t59
+                                                                                                                                                                                                                                                                        t162))))
+                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                            t164
+                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                t56
+                                                                                                                                                                                                                                                                t57
+                                                                                                                                                                                                                                                                t163))))
+                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                    t165
+                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                        t54
+                                                                                                                                                                                                                                                        t55
+                                                                                                                                                                                                                                                        t164))))
+                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                            t166
+                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                t52
+                                                                                                                                                                                                                                                t53
+                                                                                                                                                                                                                                                t165))))
+                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                    t167
+                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                        t50
+                                                                                                                                                                                                                                        t51
+                                                                                                                                                                                                                                        t166))))
+                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                            t168
+                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                t48
+                                                                                                                                                                                                                                t49
+                                                                                                                                                                                                                                t167))))
+                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                    t169
+                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                        t46
+                                                                                                                                                                                                                        t47
+                                                                                                                                                                                                                        t168))))
+                                                                                                                                                                                                        (=
+                                                                                                                                                                                                            t170
+                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                t44
+                                                                                                                                                                                                                t45
+                                                                                                                                                                                                                t169))))
+                                                                                                                                                                                                (=
+                                                                                                                                                                                                    t171
+                                                                                                                                                                                                    (if
+                                                                                                                                                                                                        t42
+                                                                                                                                                                                                        t43
+                                                                                                                                                                                                        t170))))
+                                                                                                                                                                                        (=
+                                                                                                                                                                                            t172
+                                                                                                                                                                                            (if
+                                                                                                                                                                                                t40
+                                                                                                                                                                                                t41
+                                                                                                                                                                                                t171))))
+                                                                                                                                                                                (=
+                                                                                                                                                                                    t173
+                                                                                                                                                                                    (if
+                                                                                                                                                                                        t38
+                                                                                                                                                                                        t39
+                                                                                                                                                                                        t172))))
+                                                                                                                                                                        (=
+                                                                                                                                                                            t174
+                                                                                                                                                                            (if
+                                                                                                                                                                                t36
+                                                                                                                                                                                t37
+                                                                                                                                                                                t173))))
+                                                                                                                                                                (=
+                                                                                                                                                                    t175
+                                                                                                                                                                    (if
+                                                                                                                                                                        t34
+                                                                                                                                                                        t35
+                                                                                                                                                                        t174))))
+                                                                                                                                                        (=
+                                                                                                                                                            t176
+                                                                                                                                                            (if
+                                                                                                                                                                t32
+                                                                                                                                                                t33
+                                                                                                                                                                t175))))
+                                                                                                                                                (=
+                                                                                                                                                    t177
+                                                                                                                                                    (if
+                                                                                                                                                        t30
+                                                                                                                                                        t31
+                                                                                                                                                        t176))))
+                                                                                                                                        (=
+                                                                                                                                            t178
+                                                                                                                                            (if
+                                                                                                                                                t28
+                                                                                                                                                t29
+                                                                                                                                                t177))))
+                                                                                                                                (=
+                                                                                                                                    t179
+                                                                                                                                    (if
+                                                                                                                                        t26
+                                                                                                                                        t27
+                                                                                                                                        t178))))
+                                                                                                                        (=
+                                                                                                                            t180
+                                                                                                                            (if
+                                                                                                                                t24
+                                                                                                                                t25
+                                                                                                                                t179))))
+                                                                                                                (=
+                                                                                                                    t181
+                                                                                                                    (if
+                                                                                                                        t22
+                                                                                                                        t23
+                                                                                                                        t180))))
+                                                                                                        (=
+                                                                                                            t182
+                                                                                                            (if
+                                                                                                                t20
+                                                                                                                t21
+                                                                                                                t181))))
+                                                                                                (=
+                                                                                                    t183
+                                                                                                    (if t18 t19 t182))))
+                                                                                        (= t184 (if t16 t17 t183))))
+                                                                                (= t185 (if t14 t15 t184))))
+                                                                        (= t186 (if t12 t13 t185))))
+                                                                (= t187 (if t10 t11 t186))))
+                                                        (= t188 (if t8 t9 t187))))
+                                                (= t189 (if t6 t7 t188))))
+                                        (= t190 (if t4 t5 t189))))
+                                (= t191 (if t2 t3 t190))
+                                (= rd (sign_ext 64 (bvsub #x003f (bvadd t191 #x0001)))))))
+                    ((RBit)
+                        (=
+                            rd
+                            (concat
+                                (concat
+                                    (concat
+                                        (concat
+                                            (concat
+                                                (concat
+                                                    (concat
+                                                        (concat
+                                                            (concat
+                                                                (concat
+                                                                    (concat
+                                                                        (concat
+                                                                            (concat
+                                                                                (concat
+                                                                                    (concat
+                                                                                        (concat
+                                                                                            (concat
+                                                                                                (concat
+                                                                                                    (concat
+                                                                                                        (concat
+                                                                                                            (concat
+                                                                                                                (concat
+                                                                                                                    (concat
+                                                                                                                        (concat
+                                                                                                                            (concat
+                                                                                                                                (concat
+                                                                                                                                    (concat
+                                                                                                                                        (concat
+                                                                                                                                            (concat
+                                                                                                                                                (concat
+                                                                                                                                                    (concat
+                                                                                                                                                        (concat
+                                                                                                                                                            (concat
+                                                                                                                                                                (concat
+                                                                                                                                                                    (concat
+                                                                                                                                                                        (concat
+                                                                                                                                                                            (concat
+                                                                                                                                                                                (concat
+                                                                                                                                                                                    (concat
+                                                                                                                                                                                        (concat
+                                                                                                                                                                                            (concat
+                                                                                                                                                                                                (concat
+                                                                                                                                                                                                    (concat
+                                                                                                                                                                                                        (concat
+                                                                                                                                                                                                            (concat
+                                                                                                                                                                                                                (concat
+                                                                                                                                                                                                                    (concat
+                                                                                                                                                                                                                        (concat
+                                                                                                                                                                                                                            (concat
+                                                                                                                                                                                                                                (concat
+                                                                                                                                                                                                                                    (concat
+                                                                                                                                                                                                                                        (concat
+                                                                                                                                                                                                                                            (concat
+                                                                                                                                                                                                                                                (concat
+                                                                                                                                                                                                                                                    (concat
+                                                                                                                                                                                                                                                        (concat
+                                                                                                                                                                                                                                                            (concat
+                                                                                                                                                                                                                                                                (concat
+                                                                                                                                                                                                                                                                    (concat
+                                                                                                                                                                                                                                                                        (concat
+                                                                                                                                                                                                                                                                            (concat
+                                                                                                                                                                                                                                                                                (concat
+                                                                                                                                                                                                                                                                                    (concat
+                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                            0
+                                                                                                                                                                                                                                                                                            0
+                                                                                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                                                                                    64)))
+                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                            1
+                                                                                                                                                                                                                                                                                            1
+                                                                                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                                                                                    64))))
+                                                                                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                                                                                        2
+                                                                                                                                                                                                                                                                                        2
+                                                                                                                                                                                                                                                                                        (as
+                                                                                                                                                                                                                                                                                            rn
+                                                                                                                                                                                                                                                                                            (bv
+                                                                                                                                                                                                                                                                                                64))))
+                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                    3
+                                                                                                                                                                                                                                                                                    3
+                                                                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                                                                            64))))
+                                                                                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                                                                                4
+                                                                                                                                                                                                                                                                                4
+                                                                                                                                                                                                                                                                                (as
+                                                                                                                                                                                                                                                                                    rn
+                                                                                                                                                                                                                                                                                    (bv
+                                                                                                                                                                                                                                                                                        64))))
+                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                            5
+                                                                                                                                                                                                                                                                            5
+                                                                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                                                                    64))))
+                                                                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                                                                        6
+                                                                                                                                                                                                                                                                        6
+                                                                                                                                                                                                                                                                        (as
+                                                                                                                                                                                                                                                                            rn
+                                                                                                                                                                                                                                                                            (bv
+                                                                                                                                                                                                                                                                                64))))
+                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                    7
+                                                                                                                                                                                                                                                                    7
+                                                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                                                            64))))
+                                                                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                                                                8
+                                                                                                                                                                                                                                                                8
+                                                                                                                                                                                                                                                                (as
+                                                                                                                                                                                                                                                                    rn
+                                                                                                                                                                                                                                                                    (bv
+                                                                                                                                                                                                                                                                        64))))
+                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                            9
+                                                                                                                                                                                                                                                            9
+                                                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                                                    64))))
+                                                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                                                        10
+                                                                                                                                                                                                                                                        10
+                                                                                                                                                                                                                                                        (as
+                                                                                                                                                                                                                                                            rn
+                                                                                                                                                                                                                                                            (bv
+                                                                                                                                                                                                                                                                64))))
+                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                    11
+                                                                                                                                                                                                                                                    11
+                                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                                            64))))
+                                                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                                                12
+                                                                                                                                                                                                                                                12
+                                                                                                                                                                                                                                                (as
+                                                                                                                                                                                                                                                    rn
+                                                                                                                                                                                                                                                    (bv
+                                                                                                                                                                                                                                                        64))))
+                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                            13
+                                                                                                                                                                                                                                            13
+                                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                                    64))))
+                                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                                        14
+                                                                                                                                                                                                                                        14
+                                                                                                                                                                                                                                        (as
+                                                                                                                                                                                                                                            rn
+                                                                                                                                                                                                                                            (bv
+                                                                                                                                                                                                                                                64))))
+                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                    15
+                                                                                                                                                                                                                                    15
+                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                            64))))
+                                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                                16
+                                                                                                                                                                                                                                16
+                                                                                                                                                                                                                                (as
+                                                                                                                                                                                                                                    rn
+                                                                                                                                                                                                                                    (bv
+                                                                                                                                                                                                                                        64))))
+                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                            17
+                                                                                                                                                                                                                            17
+                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                    64))))
+                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                        18
+                                                                                                                                                                                                                        18
+                                                                                                                                                                                                                        (as
+                                                                                                                                                                                                                            rn
+                                                                                                                                                                                                                            (bv
+                                                                                                                                                                                                                                64))))
+                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                    19
+                                                                                                                                                                                                                    19
+                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                            64))))
+                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                20
+                                                                                                                                                                                                                20
+                                                                                                                                                                                                                (as
+                                                                                                                                                                                                                    rn
+                                                                                                                                                                                                                    (bv
+                                                                                                                                                                                                                        64))))
+                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                            21
+                                                                                                                                                                                                            21
+                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                    64))))
+                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                        22
+                                                                                                                                                                                                        22
+                                                                                                                                                                                                        (as
+                                                                                                                                                                                                            rn
+                                                                                                                                                                                                            (bv
+                                                                                                                                                                                                                64))))
+                                                                                                                                                                                                (extract
+                                                                                                                                                                                                    23
+                                                                                                                                                                                                    23
+                                                                                                                                                                                                    (as
+                                                                                                                                                                                                        rn
+                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                            64))))
+                                                                                                                                                                                            (extract
+                                                                                                                                                                                                24
+                                                                                                                                                                                                24
+                                                                                                                                                                                                (as
+                                                                                                                                                                                                    rn
+                                                                                                                                                                                                    (bv
+                                                                                                                                                                                                        64))))
+                                                                                                                                                                                        (extract
+                                                                                                                                                                                            25
+                                                                                                                                                                                            25
+                                                                                                                                                                                            (as
+                                                                                                                                                                                                rn
+                                                                                                                                                                                                (bv
+                                                                                                                                                                                                    64))))
+                                                                                                                                                                                    (extract
+                                                                                                                                                                                        26
+                                                                                                                                                                                        26
+                                                                                                                                                                                        (as
+                                                                                                                                                                                            rn
+                                                                                                                                                                                            (bv
+                                                                                                                                                                                                64))))
+                                                                                                                                                                                (extract
+                                                                                                                                                                                    27
+                                                                                                                                                                                    27
+                                                                                                                                                                                    (as
+                                                                                                                                                                                        rn
+                                                                                                                                                                                        (bv
+                                                                                                                                                                                            64))))
+                                                                                                                                                                            (extract
+                                                                                                                                                                                28
+                                                                                                                                                                                28
+                                                                                                                                                                                (as
+                                                                                                                                                                                    rn
+                                                                                                                                                                                    (bv
+                                                                                                                                                                                        64))))
+                                                                                                                                                                        (extract
+                                                                                                                                                                            29
+                                                                                                                                                                            29
+                                                                                                                                                                            (as
+                                                                                                                                                                                rn
+                                                                                                                                                                                (bv
+                                                                                                                                                                                    64))))
+                                                                                                                                                                    (extract
+                                                                                                                                                                        30
+                                                                                                                                                                        30
+                                                                                                                                                                        (as
+                                                                                                                                                                            rn
+                                                                                                                                                                            (bv
+                                                                                                                                                                                64))))
+                                                                                                                                                                (extract
+                                                                                                                                                                    31
+                                                                                                                                                                    31
+                                                                                                                                                                    (as
+                                                                                                                                                                        rn
+                                                                                                                                                                        (bv
+                                                                                                                                                                            64))))
+                                                                                                                                                            (extract
+                                                                                                                                                                32
+                                                                                                                                                                32
+                                                                                                                                                                (as
+                                                                                                                                                                    rn
+                                                                                                                                                                    (bv
+                                                                                                                                                                        64))))
+                                                                                                                                                        (extract
+                                                                                                                                                            33
+                                                                                                                                                            33
+                                                                                                                                                            (as
+                                                                                                                                                                rn
+                                                                                                                                                                (bv
+                                                                                                                                                                    64))))
+                                                                                                                                                    (extract
+                                                                                                                                                        34
+                                                                                                                                                        34
+                                                                                                                                                        (as
+                                                                                                                                                            rn
+                                                                                                                                                            (bv
+                                                                                                                                                                64))))
+                                                                                                                                                (extract
+                                                                                                                                                    35
+                                                                                                                                                    35
+                                                                                                                                                    (as
+                                                                                                                                                        rn
+                                                                                                                                                        (bv
+                                                                                                                                                            64))))
+                                                                                                                                            (extract
+                                                                                                                                                36
+                                                                                                                                                36
+                                                                                                                                                (as
+                                                                                                                                                    rn
+                                                                                                                                                    (bv
+                                                                                                                                                        64))))
+                                                                                                                                        (extract
+                                                                                                                                            37
+                                                                                                                                            37
+                                                                                                                                            (as
+                                                                                                                                                rn
+                                                                                                                                                (bv
+                                                                                                                                                    64))))
+                                                                                                                                    (extract
+                                                                                                                                        38
+                                                                                                                                        38
+                                                                                                                                        (as
+                                                                                                                                            rn
+                                                                                                                                            (bv
+                                                                                                                                                64))))
+                                                                                                                                (extract
+                                                                                                                                    39
+                                                                                                                                    39
+                                                                                                                                    (as
+                                                                                                                                        rn
+                                                                                                                                        (bv
+                                                                                                                                            64))))
+                                                                                                                            (extract
+                                                                                                                                40
+                                                                                                                                40
+                                                                                                                                (as
+                                                                                                                                    rn
+                                                                                                                                    (bv
+                                                                                                                                        64))))
+                                                                                                                        (extract
+                                                                                                                            41
+                                                                                                                            41
+                                                                                                                            (as
+                                                                                                                                rn
+                                                                                                                                (bv
+                                                                                                                                    64))))
+                                                                                                                    (extract
+                                                                                                                        42
+                                                                                                                        42
+                                                                                                                        (as
+                                                                                                                            rn
+                                                                                                                            (bv
+                                                                                                                                64))))
+                                                                                                                (extract
+                                                                                                                    43
+                                                                                                                    43
+                                                                                                                    (as
+                                                                                                                        rn
+                                                                                                                        (bv
+                                                                                                                            64))))
+                                                                                                            (extract
+                                                                                                                44
+                                                                                                                44
+                                                                                                                (as
+                                                                                                                    rn
+                                                                                                                    (bv
+                                                                                                                        64))))
+                                                                                                        (extract
+                                                                                                            45
+                                                                                                            45
+                                                                                                            (as
+                                                                                                                rn
+                                                                                                                (bv
+                                                                                                                    64))))
+                                                                                                    (extract
+                                                                                                        46
+                                                                                                        46
+                                                                                                        (as
+                                                                                                            rn
+                                                                                                            (bv 64))))
+                                                                                                (extract
+                                                                                                    47
+                                                                                                    47
+                                                                                                    (as rn (bv 64))))
+                                                                                            (extract
+                                                                                                48
+                                                                                                48
+                                                                                                (as rn (bv 64))))
+                                                                                        (extract 49 49 (as rn (bv 64))))
+                                                                                    (extract 50 50 (as rn (bv 64))))
+                                                                                (extract 51 51 (as rn (bv 64))))
+                                                                            (extract 52 52 (as rn (bv 64))))
+                                                                        (extract 53 53 (as rn (bv 64))))
+                                                                    (extract 54 54 (as rn (bv 64))))
+                                                                (extract 55 55 (as rn (bv 64))))
+                                                            (extract 56 56 (as rn (bv 64))))
+                                                        (extract 57 57 (as rn (bv 64))))
+                                                    (extract 58 58 (as rn (bv 64))))
+                                                (extract 59 59 (as rn (bv 64))))
+                                            (extract 60 60 (as rn (bv 64))))
+                                        (extract 61 61 (as rn (bv 64))))
+                                    (extract 62 62 (as rn (bv 64))))
+                                (extract 63 63 (as rn (bv 64))))))
+                    ((Clz)
+                        (with
+                            (t1
+                                t10
+                                t100
+                                t101
+                                t102
+                                t103
+                                t104
+                                t105
+                                t106
+                                t107
+                                t108
+                                t109
+                                t11
+                                t110
+                                t111
+                                t112
+                                t113
+                                t114
+                                t115
+                                t116
+                                t117
+                                t118
+                                t119
+                                t12
+                                t120
+                                t121
+                                t122
+                                t123
+                                t124
+                                t125
+                                t126
+                                t127
+                                t128
+                                t129
+                                t13
+                                t130
+                                t131
+                                t132
+                                t133
+                                t134
+                                t135
+                                t136
+                                t137
+                                t138
+                                t139
+                                t14
+                                t140
+                                t141
+                                t142
+                                t143
+                                t144
+                                t145
+                                t146
+                                t147
+                                t148
+                                t149
+                                t15
+                                t150
+                                t151
+                                t152
+                                t153
+                                t154
+                                t155
+                                t156
+                                t157
+                                t158
+                                t159
+                                t16
+                                t160
+                                t161
+                                t162
+                                t163
+                                t164
+                                t165
+                                t166
+                                t167
+                                t168
+                                t169
+                                t17
+                                t170
+                                t171
+                                t172
+                                t173
+                                t174
+                                t175
+                                t176
+                                t177
+                                t178
+                                t179
+                                t18
+                                t180
+                                t181
+                                t182
+                                t183
+                                t184
+                                t185
+                                t186
+                                t187
+                                t188
+                                t189
+                                t19
+                                t190
+                                t191
+                                t192
+                                t193
+                                t2
+                                t20
+                                t21
+                                t22
+                                t23
+                                t24
+                                t25
+                                t26
+                                t27
+                                t28
+                                t29
+                                t3
+                                t30
+                                t31
+                                t32
+                                t33
+                                t34
+                                t35
+                                t36
+                                t37
+                                t38
+                                t39
+                                t4
+                                t40
+                                t41
+                                t42
+                                t43
+                                t44
+                                t45
+                                t46
+                                t47
+                                t48
+                                t49
+                                t5
+                                t50
+                                t51
+                                t52
+                                t53
+                                t54
+                                t55
+                                t56
+                                t57
+                                t58
+                                t59
+                                t6
+                                t60
+                                t61
+                                t62
+                                t63
+                                t64
+                                t65
+                                t66
+                                t67
+                                t68
+                                t69
+                                t7
+                                t70
+                                t71
+                                t72
+                                t73
+                                t74
+                                t75
+                                t76
+                                t77
+                                t78
+                                t79
+                                t8
+                                t80
+                                t81
+                                t82
+                                t83
+                                t84
+                                t85
+                                t86
+                                t87
+                                t88
+                                t89
+                                t9
+                                t90
+                                t91
+                                t92
+                                t93
+                                t94
+                                t95
+                                t96
+                                t97
+                                t98
+                                t99)
+                            (and
+                                (= t1 (= (extract 63 63 (as rn (bv 64))) #b1))
+                                (if
+                                    t1
+                                    (= t2 #x003f)
+                                    (and
+                                        (= t3 (= (extract 62 62 (as rn (bv 64))) #b1))
+                                        (if
+                                            t3
+                                            (= t4 #x003e)
+                                            (and
+                                                (= t5 (= (extract 61 61 (as rn (bv 64))) #b1))
+                                                (if
+                                                    t5
+                                                    (= t6 #x003d)
+                                                    (and
+                                                        (= t7 (= (extract 60 60 (as rn (bv 64))) #b1))
+                                                        (if
+                                                            t7
+                                                            (= t8 #x003c)
+                                                            (and
+                                                                (= t9 (= (extract 59 59 (as rn (bv 64))) #b1))
+                                                                (if
+                                                                    t9
+                                                                    (= t10 #x003b)
+                                                                    (and
+                                                                        (= t11 (= (extract 58 58 (as rn (bv 64))) #b1))
+                                                                        (if
+                                                                            t11
+                                                                            (= t12 #x003a)
+                                                                            (and
+                                                                                (=
+                                                                                    t13
+                                                                                    (=
+                                                                                        (extract 57 57 (as rn (bv 64)))
+                                                                                        #b1))
+                                                                                (if
+                                                                                    t13
+                                                                                    (= t14 #x0039)
+                                                                                    (and
+                                                                                        (=
+                                                                                            t15
+                                                                                            (=
+                                                                                                (extract
+                                                                                                    56
+                                                                                                    56
+                                                                                                    (as rn (bv 64)))
+                                                                                                #b1))
+                                                                                        (if
+                                                                                            t15
+                                                                                            (= t16 #x0038)
+                                                                                            (and
+                                                                                                (=
+                                                                                                    t17
+                                                                                                    (=
+                                                                                                        (extract
+                                                                                                            55
+                                                                                                            55
+                                                                                                            (as
+                                                                                                                rn
+                                                                                                                (bv
+                                                                                                                    64)))
+                                                                                                        #b1))
+                                                                                                (if
+                                                                                                    t17
+                                                                                                    (= t18 #x0037)
+                                                                                                    (and
+                                                                                                        (=
+                                                                                                            t19
+                                                                                                            (=
+                                                                                                                (extract
+                                                                                                                    54
+                                                                                                                    54
+                                                                                                                    (as
+                                                                                                                        rn
+                                                                                                                        (bv
+                                                                                                                            64)))
+                                                                                                                #b1))
+                                                                                                        (if
+                                                                                                            t19
+                                                                                                            (=
+                                                                                                                t20
+                                                                                                                #x0036)
+                                                                                                            (and
+                                                                                                                (=
+                                                                                                                    t21
+                                                                                                                    (=
+                                                                                                                        (extract
+                                                                                                                            53
+                                                                                                                            53
+                                                                                                                            (as
+                                                                                                                                rn
+                                                                                                                                (bv
+                                                                                                                                    64)))
+                                                                                                                        #b1))
+                                                                                                                (if
+                                                                                                                    t21
+                                                                                                                    (=
+                                                                                                                        t22
+                                                                                                                        #x0035)
+                                                                                                                    (and
+                                                                                                                        (=
+                                                                                                                            t23
+                                                                                                                            (=
+                                                                                                                                (extract
+                                                                                                                                    52
+                                                                                                                                    52
+                                                                                                                                    (as
+                                                                                                                                        rn
+                                                                                                                                        (bv
+                                                                                                                                            64)))
+                                                                                                                                #b1))
+                                                                                                                        (if
+                                                                                                                            t23
+                                                                                                                            (=
+                                                                                                                                t24
+                                                                                                                                #x0034)
+                                                                                                                            (and
+                                                                                                                                (=
+                                                                                                                                    t25
+                                                                                                                                    (=
+                                                                                                                                        (extract
+                                                                                                                                            51
+                                                                                                                                            51
+                                                                                                                                            (as
+                                                                                                                                                rn
+                                                                                                                                                (bv
+                                                                                                                                                    64)))
+                                                                                                                                        #b1))
+                                                                                                                                (if
+                                                                                                                                    t25
+                                                                                                                                    (=
+                                                                                                                                        t26
+                                                                                                                                        #x0033)
+                                                                                                                                    (and
+                                                                                                                                        (=
+                                                                                                                                            t27
+                                                                                                                                            (=
+                                                                                                                                                (extract
+                                                                                                                                                    50
+                                                                                                                                                    50
+                                                                                                                                                    (as
+                                                                                                                                                        rn
+                                                                                                                                                        (bv
+                                                                                                                                                            64)))
+                                                                                                                                                #b1))
+                                                                                                                                        (if
+                                                                                                                                            t27
+                                                                                                                                            (=
+                                                                                                                                                t28
+                                                                                                                                                #x0032)
+                                                                                                                                            (and
+                                                                                                                                                (=
+                                                                                                                                                    t29
+                                                                                                                                                    (=
+                                                                                                                                                        (extract
+                                                                                                                                                            49
+                                                                                                                                                            49
+                                                                                                                                                            (as
+                                                                                                                                                                rn
+                                                                                                                                                                (bv
+                                                                                                                                                                    64)))
+                                                                                                                                                        #b1))
+                                                                                                                                                (if
+                                                                                                                                                    t29
+                                                                                                                                                    (=
+                                                                                                                                                        t30
+                                                                                                                                                        #x0031)
+                                                                                                                                                    (and
+                                                                                                                                                        (=
+                                                                                                                                                            t31
+                                                                                                                                                            (=
+                                                                                                                                                                (extract
+                                                                                                                                                                    48
+                                                                                                                                                                    48
+                                                                                                                                                                    (as
+                                                                                                                                                                        rn
+                                                                                                                                                                        (bv
+                                                                                                                                                                            64)))
+                                                                                                                                                                #b1))
+                                                                                                                                                        (if
+                                                                                                                                                            t31
+                                                                                                                                                            (=
+                                                                                                                                                                t32
+                                                                                                                                                                #x0030)
+                                                                                                                                                            (and
+                                                                                                                                                                (=
+                                                                                                                                                                    t33
+                                                                                                                                                                    (=
+                                                                                                                                                                        (extract
+                                                                                                                                                                            47
+                                                                                                                                                                            47
+                                                                                                                                                                            (as
+                                                                                                                                                                                rn
+                                                                                                                                                                                (bv
+                                                                                                                                                                                    64)))
+                                                                                                                                                                        #b1))
+                                                                                                                                                                (if
+                                                                                                                                                                    t33
+                                                                                                                                                                    (=
+                                                                                                                                                                        t34
+                                                                                                                                                                        #x002f)
+                                                                                                                                                                    (and
+                                                                                                                                                                        (=
+                                                                                                                                                                            t35
+                                                                                                                                                                            (=
+                                                                                                                                                                                (extract
+                                                                                                                                                                                    46
+                                                                                                                                                                                    46
+                                                                                                                                                                                    (as
+                                                                                                                                                                                        rn
+                                                                                                                                                                                        (bv
+                                                                                                                                                                                            64)))
+                                                                                                                                                                                #b1))
+                                                                                                                                                                        (if
+                                                                                                                                                                            t35
+                                                                                                                                                                            (=
+                                                                                                                                                                                t36
+                                                                                                                                                                                #x002e)
+                                                                                                                                                                            (and
+                                                                                                                                                                                (=
+                                                                                                                                                                                    t37
+                                                                                                                                                                                    (=
+                                                                                                                                                                                        (extract
+                                                                                                                                                                                            45
+                                                                                                                                                                                            45
+                                                                                                                                                                                            (as
+                                                                                                                                                                                                rn
+                                                                                                                                                                                                (bv
+                                                                                                                                                                                                    64)))
+                                                                                                                                                                                        #b1))
+                                                                                                                                                                                (if
+                                                                                                                                                                                    t37
+                                                                                                                                                                                    (=
+                                                                                                                                                                                        t38
+                                                                                                                                                                                        #x002d)
+                                                                                                                                                                                    (and
+                                                                                                                                                                                        (=
+                                                                                                                                                                                            t39
+                                                                                                                                                                                            (=
+                                                                                                                                                                                                (extract
+                                                                                                                                                                                                    44
+                                                                                                                                                                                                    44
+                                                                                                                                                                                                    (as
+                                                                                                                                                                                                        rn
+                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                #b1))
+                                                                                                                                                                                        (if
+                                                                                                                                                                                            t39
+                                                                                                                                                                                            (=
+                                                                                                                                                                                                t40
+                                                                                                                                                                                                #x002c)
+                                                                                                                                                                                            (and
+                                                                                                                                                                                                (=
+                                                                                                                                                                                                    t41
+                                                                                                                                                                                                    (=
+                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                            43
+                                                                                                                                                                                                            43
+                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                    64)))
+                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                (if
+                                                                                                                                                                                                    t41
+                                                                                                                                                                                                    (=
+                                                                                                                                                                                                        t42
+                                                                                                                                                                                                        #x002b)
+                                                                                                                                                                                                    (and
+                                                                                                                                                                                                        (=
+                                                                                                                                                                                                            t43
+                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                    42
+                                                                                                                                                                                                                    42
+                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                        (if
+                                                                                                                                                                                                            t43
+                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                t44
+                                                                                                                                                                                                                #x002a)
+                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                    t45
+                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                            41
+                                                                                                                                                                                                                            41
+                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                    64)))
+                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                    t45
+                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                        t46
+                                                                                                                                                                                                                        #x0029)
+                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                            t47
+                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                    40
+                                                                                                                                                                                                                                    40
+                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                            t47
+                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                t48
+                                                                                                                                                                                                                                #x0028)
+                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                    t49
+                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                            39
+                                                                                                                                                                                                                                            39
+                                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                                    64)))
+                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                    t49
+                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                        t50
+                                                                                                                                                                                                                                        #x0027)
+                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                            t51
+                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                    38
+                                                                                                                                                                                                                                                    38
+                                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                            t51
+                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                t52
+                                                                                                                                                                                                                                                #x0026)
+                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                    t53
+                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                            37
+                                                                                                                                                                                                                                                            37
+                                                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                                                    64)))
+                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                    t53
+                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                        t54
+                                                                                                                                                                                                                                                        #x0025)
+                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                            t55
+                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                    36
+                                                                                                                                                                                                                                                                    36
+                                                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                            t55
+                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                t56
+                                                                                                                                                                                                                                                                #x0024)
+                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                    t57
+                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                            35
+                                                                                                                                                                                                                                                                            35
+                                                                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                                                                    64)))
+                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                    t57
+                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                        t58
+                                                                                                                                                                                                                                                                        #x0023)
+                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                            t59
+                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                    34
+                                                                                                                                                                                                                                                                                    34
+                                                                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                            t59
+                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                t60
+                                                                                                                                                                                                                                                                                #x0022)
+                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                    t61
+                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                            33
+                                                                                                                                                                                                                                                                                            33
+                                                                                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                                                                                    64)))
+                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                    t61
+                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                        t62
+                                                                                                                                                                                                                                                                                        #x0021)
+                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                            t63
+                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                    32
+                                                                                                                                                                                                                                                                                                    32
+                                                                                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                            t63
+                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                t64
+                                                                                                                                                                                                                                                                                                #x0020)
+                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                    t65
+                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                            31
+                                                                                                                                                                                                                                                                                                            31
+                                                                                                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                                                                                                    64)))
+                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                    t65
+                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                        t66
+                                                                                                                                                                                                                                                                                                        #x001f)
+                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                            t67
+                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                    30
+                                                                                                                                                                                                                                                                                                                    30
+                                                                                                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                            t67
+                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                t68
+                                                                                                                                                                                                                                                                                                                #x001e)
+                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                    t69
+                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                            29
+                                                                                                                                                                                                                                                                                                                            29
+                                                                                                                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                                                                                                                    64)))
+                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                    t69
+                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                        t70
+                                                                                                                                                                                                                                                                                                                        #x001d)
+                                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                            t71
+                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                                    28
+                                                                                                                                                                                                                                                                                                                                    28
+                                                                                                                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                                            t71
+                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                t72
+                                                                                                                                                                                                                                                                                                                                #x001c)
+                                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                    t73
+                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                                            27
+                                                                                                                                                                                                                                                                                                                                            27
+                                                                                                                                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                                                                                                                                    64)))
+                                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                                    t73
+                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                        t74
+                                                                                                                                                                                                                                                                                                                                        #x001b)
+                                                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                            t75
+                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                                                    26
+                                                                                                                                                                                                                                                                                                                                                    26
+                                                                                                                                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                                                            t75
+                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                t76
+                                                                                                                                                                                                                                                                                                                                                #x001a)
+                                                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                    t77
+                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                                                            25
+                                                                                                                                                                                                                                                                                                                                                            25
+                                                                                                                                                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                                                                                                                                                    64)))
+                                                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                                                    t77
+                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                        t78
+                                                                                                                                                                                                                                                                                                                                                        #x0019)
+                                                                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                            t79
+                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                                                                    24
+                                                                                                                                                                                                                                                                                                                                                                    24
+                                                                                                                                                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                                                                            t79
+                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                t80
+                                                                                                                                                                                                                                                                                                                                                                #x0018)
+                                                                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                    t81
+                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                                                                            23
+                                                                                                                                                                                                                                                                                                                                                                            23
+                                                                                                                                                                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                                                                                                                                                                    64)))
+                                                                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                                                                    t81
+                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                        t82
+                                                                                                                                                                                                                                                                                                                                                                        #x0017)
+                                                                                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                            t83
+                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                                                                                    22
+                                                                                                                                                                                                                                                                                                                                                                                    22
+                                                                                                                                                                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                                                                                            t83
+                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                t84
+                                                                                                                                                                                                                                                                                                                                                                                #x0016)
+                                                                                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                    t85
+                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                                                                                            21
+                                                                                                                                                                                                                                                                                                                                                                                            21
+                                                                                                                                                                                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                                                                                                                                                                                    64)))
+                                                                                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                                                                                    t85
+                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                        t86
+                                                                                                                                                                                                                                                                                                                                                                                        #x0015)
+                                                                                                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                            t87
+                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                                                                                                    20
+                                                                                                                                                                                                                                                                                                                                                                                                    20
+                                                                                                                                                                                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                                                                                                            t87
+                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                t88
+                                                                                                                                                                                                                                                                                                                                                                                                #x0014)
+                                                                                                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                    t89
+                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                                                                                                            19
+                                                                                                                                                                                                                                                                                                                                                                                                            19
+                                                                                                                                                                                                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                                                                                                                                                                                                    64)))
+                                                                                                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                                                                                                    t89
+                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                        t90
+                                                                                                                                                                                                                                                                                                                                                                                                        #x0013)
+                                                                                                                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                            t91
+                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                    18
+                                                                                                                                                                                                                                                                                                                                                                                                                    18
+                                                                                                                                                                                                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                                                                                                                            t91
+                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                t92
+                                                                                                                                                                                                                                                                                                                                                                                                                #x0012)
+                                                                                                                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                    t93
+                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                            17
+                                                                                                                                                                                                                                                                                                                                                                                                                            17
+                                                                                                                                                                                                                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                                                                                                                                                                                                                    64)))
+                                                                                                                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                                                                                                                    t93
+                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                        t94
+                                                                                                                                                                                                                                                                                                                                                                                                                        #x0011)
+                                                                                                                                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                            t95
+                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                    16
+                                                                                                                                                                                                                                                                                                                                                                                                                                    16
+                                                                                                                                                                                                                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                                                                                                                                            t95
+                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                t96
+                                                                                                                                                                                                                                                                                                                                                                                                                                #x0010)
+                                                                                                                                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                    t97
+                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                            15
+                                                                                                                                                                                                                                                                                                                                                                                                                                            15
+                                                                                                                                                                                                                                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    64)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                    t97
+                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                        t98
+                                                                                                                                                                                                                                                                                                                                                                                                                                        #x000f)
+                                                                                                                                                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                            t99
+                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    14
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    14
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                            t99
+                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                t100
+                                                                                                                                                                                                                                                                                                                                                                                                                                                #x000e)
+                                                                                                                                                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    t101
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            13
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            13
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    64)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    t101
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        t102
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        #x000d)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            t103
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    12
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    12
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            t103
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                t104
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                #x000c)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t105
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            11
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            11
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    64)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t105
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t106
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        #x000b)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t107
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    10
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    10
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t107
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t108
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                #x000a)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t109
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            9
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            9
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    64)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t109
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t110
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        #x0009)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t111
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    8
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    8
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t111
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t112
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                #x0008)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t113
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            7
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            7
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    64)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t113
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t114
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        #x0007)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t115
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    6
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    6
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t115
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t116
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                #x0006)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t117
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            5
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            5
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    64)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t117
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t118
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        #x0005)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t119
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    4
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t119
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t120
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                #x0004)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t121
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            3
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            3
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    64)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t121
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t122
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        #x0003)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t123
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    2
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t123
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t124
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                #x0002)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t125
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            1
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    64)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t125
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t126
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        #x0001)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t127
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    0
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    0
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t127
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t128
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                #x0000)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t129
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                #xffff))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t130
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t127
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t128
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t129))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t131
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t125
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t126
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t130))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t132
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t123
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t124
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t131))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t133
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t121
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t122
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t132))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t134
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t119
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t120
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t133))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t135
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t117
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t118
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t134))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t136
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t115
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t116
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t135))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t137
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t113
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t114
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t136))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t138
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t111
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t112
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t137))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t139
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t109
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t110
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t138))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            t140
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t107
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t108
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                t139))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    t141
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t105
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t106
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        t140))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            t142
+                                                                                                                                                                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                t103
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                t104
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                t141))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    t143
+                                                                                                                                                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        t101
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        t102
+                                                                                                                                                                                                                                                                                                                                                                                                                                                        t142))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                            t144
+                                                                                                                                                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                                t99
+                                                                                                                                                                                                                                                                                                                                                                                                                                                t100
+                                                                                                                                                                                                                                                                                                                                                                                                                                                t143))))
+                                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                                    t145
+                                                                                                                                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                        t97
+                                                                                                                                                                                                                                                                                                                                                                                                                                        t98
+                                                                                                                                                                                                                                                                                                                                                                                                                                        t144))))
+                                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                                            t146
+                                                                                                                                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                                                                                                                                t95
+                                                                                                                                                                                                                                                                                                                                                                                                                                t96
+                                                                                                                                                                                                                                                                                                                                                                                                                                t145))))
+                                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                                    t147
+                                                                                                                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                                                                                                                        t93
+                                                                                                                                                                                                                                                                                                                                                                                                                        t94
+                                                                                                                                                                                                                                                                                                                                                                                                                        t146))))
+                                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                                            t148
+                                                                                                                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                                                                                                                t91
+                                                                                                                                                                                                                                                                                                                                                                                                                t92
+                                                                                                                                                                                                                                                                                                                                                                                                                t147))))
+                                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                                    t149
+                                                                                                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                                                                                                        t89
+                                                                                                                                                                                                                                                                                                                                                                                                        t90
+                                                                                                                                                                                                                                                                                                                                                                                                        t148))))
+                                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                                            t150
+                                                                                                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                                                                                                t87
+                                                                                                                                                                                                                                                                                                                                                                                                t88
+                                                                                                                                                                                                                                                                                                                                                                                                t149))))
+                                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                                    t151
+                                                                                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                                                                                        t85
+                                                                                                                                                                                                                                                                                                                                                                                        t86
+                                                                                                                                                                                                                                                                                                                                                                                        t150))))
+                                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                                            t152
+                                                                                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                                                                                t83
+                                                                                                                                                                                                                                                                                                                                                                                t84
+                                                                                                                                                                                                                                                                                                                                                                                t151))))
+                                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                                    t153
+                                                                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                                                                        t81
+                                                                                                                                                                                                                                                                                                                                                                        t82
+                                                                                                                                                                                                                                                                                                                                                                        t152))))
+                                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                                            t154
+                                                                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                                                                t79
+                                                                                                                                                                                                                                                                                                                                                                t80
+                                                                                                                                                                                                                                                                                                                                                                t153))))
+                                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                                    t155
+                                                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                                                        t77
+                                                                                                                                                                                                                                                                                                                                                        t78
+                                                                                                                                                                                                                                                                                                                                                        t154))))
+                                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                                            t156
+                                                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                                                t75
+                                                                                                                                                                                                                                                                                                                                                t76
+                                                                                                                                                                                                                                                                                                                                                t155))))
+                                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                                    t157
+                                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                                        t73
+                                                                                                                                                                                                                                                                                                                                        t74
+                                                                                                                                                                                                                                                                                                                                        t156))))
+                                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                                            t158
+                                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                                t71
+                                                                                                                                                                                                                                                                                                                                t72
+                                                                                                                                                                                                                                                                                                                                t157))))
+                                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                                    t159
+                                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                                        t69
+                                                                                                                                                                                                                                                                                                                        t70
+                                                                                                                                                                                                                                                                                                                        t158))))
+                                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                                            t160
+                                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                                t67
+                                                                                                                                                                                                                                                                                                                t68
+                                                                                                                                                                                                                                                                                                                t159))))
+                                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                                    t161
+                                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                                        t65
+                                                                                                                                                                                                                                                                                                        t66
+                                                                                                                                                                                                                                                                                                        t160))))
+                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                            t162
+                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                t63
+                                                                                                                                                                                                                                                                                                t64
+                                                                                                                                                                                                                                                                                                t161))))
+                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                    t163
+                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                        t61
+                                                                                                                                                                                                                                                                                        t62
+                                                                                                                                                                                                                                                                                        t162))))
+                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                            t164
+                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                t59
+                                                                                                                                                                                                                                                                                t60
+                                                                                                                                                                                                                                                                                t163))))
+                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                    t165
+                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                        t57
+                                                                                                                                                                                                                                                                        t58
+                                                                                                                                                                                                                                                                        t164))))
+                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                            t166
+                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                t55
+                                                                                                                                                                                                                                                                t56
+                                                                                                                                                                                                                                                                t165))))
+                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                    t167
+                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                        t53
+                                                                                                                                                                                                                                                        t54
+                                                                                                                                                                                                                                                        t166))))
+                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                            t168
+                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                t51
+                                                                                                                                                                                                                                                t52
+                                                                                                                                                                                                                                                t167))))
+                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                    t169
+                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                        t49
+                                                                                                                                                                                                                                        t50
+                                                                                                                                                                                                                                        t168))))
+                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                            t170
+                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                t47
+                                                                                                                                                                                                                                t48
+                                                                                                                                                                                                                                t169))))
+                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                    t171
+                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                        t45
+                                                                                                                                                                                                                        t46
+                                                                                                                                                                                                                        t170))))
+                                                                                                                                                                                                        (=
+                                                                                                                                                                                                            t172
+                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                t43
+                                                                                                                                                                                                                t44
+                                                                                                                                                                                                                t171))))
+                                                                                                                                                                                                (=
+                                                                                                                                                                                                    t173
+                                                                                                                                                                                                    (if
+                                                                                                                                                                                                        t41
+                                                                                                                                                                                                        t42
+                                                                                                                                                                                                        t172))))
+                                                                                                                                                                                        (=
+                                                                                                                                                                                            t174
+                                                                                                                                                                                            (if
+                                                                                                                                                                                                t39
+                                                                                                                                                                                                t40
+                                                                                                                                                                                                t173))))
+                                                                                                                                                                                (=
+                                                                                                                                                                                    t175
+                                                                                                                                                                                    (if
+                                                                                                                                                                                        t37
+                                                                                                                                                                                        t38
+                                                                                                                                                                                        t174))))
+                                                                                                                                                                        (=
+                                                                                                                                                                            t176
+                                                                                                                                                                            (if
+                                                                                                                                                                                t35
+                                                                                                                                                                                t36
+                                                                                                                                                                                t175))))
+                                                                                                                                                                (=
+                                                                                                                                                                    t177
+                                                                                                                                                                    (if
+                                                                                                                                                                        t33
+                                                                                                                                                                        t34
+                                                                                                                                                                        t176))))
+                                                                                                                                                        (=
+                                                                                                                                                            t178
+                                                                                                                                                            (if
+                                                                                                                                                                t31
+                                                                                                                                                                t32
+                                                                                                                                                                t177))))
+                                                                                                                                                (=
+                                                                                                                                                    t179
+                                                                                                                                                    (if
+                                                                                                                                                        t29
+                                                                                                                                                        t30
+                                                                                                                                                        t178))))
+                                                                                                                                        (=
+                                                                                                                                            t180
+                                                                                                                                            (if
+                                                                                                                                                t27
+                                                                                                                                                t28
+                                                                                                                                                t179))))
+                                                                                                                                (=
+                                                                                                                                    t181
+                                                                                                                                    (if
+                                                                                                                                        t25
+                                                                                                                                        t26
+                                                                                                                                        t180))))
+                                                                                                                        (=
+                                                                                                                            t182
+                                                                                                                            (if
+                                                                                                                                t23
+                                                                                                                                t24
+                                                                                                                                t181))))
+                                                                                                                (=
+                                                                                                                    t183
+                                                                                                                    (if
+                                                                                                                        t21
+                                                                                                                        t22
+                                                                                                                        t182))))
+                                                                                                        (=
+                                                                                                            t184
+                                                                                                            (if
+                                                                                                                t19
+                                                                                                                t20
+                                                                                                                t183))))
+                                                                                                (=
+                                                                                                    t185
+                                                                                                    (if t17 t18 t184))))
+                                                                                        (= t186 (if t15 t16 t185))))
+                                                                                (= t187 (if t13 t14 t186))))
+                                                                        (= t188 (if t11 t12 t187))))
+                                                                (= t189 (if t9 t10 t188))))
+                                                        (= t190 (if t7 t8 t189))))
+                                                (= t191 (if t5 t6 t190))))
+                                        (= t192 (if t3 t4 t191))))
+                                (= t193 (if t1 t2 t192))
+                                (= rd (sign_ext 64 (bvsub #x0040 (bvadd t193 #x0001)))))))))
+            ((Size32)
+                (match
+                    op
+                    ((Cls)
+                        (with
+                            (t1
+                                t10
+                                t11
+                                t12
+                                t13
+                                t14
+                                t15
+                                t16
+                                t17
+                                t18
+                                t19
+                                t2
+                                t20
+                                t21
+                                t22
+                                t23
+                                t24
+                                t25
+                                t26
+                                t27
+                                t28
+                                t29
+                                t3
+                                t30
+                                t31
+                                t32
+                                t33
+                                t34
+                                t35
+                                t36
+                                t37
+                                t38
+                                t39
+                                t4
+                                t40
+                                t41
+                                t42
+                                t43
+                                t44
+                                t45
+                                t46
+                                t47
+                                t48
+                                t49
+                                t5
+                                t50
+                                t51
+                                t52
+                                t53
+                                t54
+                                t55
+                                t56
+                                t57
+                                t58
+                                t59
+                                t6
+                                t60
+                                t61
+                                t62
+                                t63
+                                t64
+                                t65
+                                t66
+                                t67
+                                t68
+                                t69
+                                t7
+                                t70
+                                t71
+                                t72
+                                t73
+                                t74
+                                t75
+                                t76
+                                t77
+                                t78
+                                t79
+                                t8
+                                t80
+                                t81
+                                t82
+                                t83
+                                t84
+                                t85
+                                t86
+                                t87
+                                t88
+                                t89
+                                t9
+                                t90
+                                t91
+                                t92
+                                t93
+                                t94
+                                t95)
+                            (and
+                                (= t1 (bvxor (extract 31 1 (as rn (bv 64))) (extract 30 0 (as rn (bv 64)))))
+                                (= t2 (= (extract 30 30 t1) #b1))
+                                (if
+                                    t2
+                                    (= t3 #x001e)
+                                    (and
+                                        (= t4 (= (extract 29 29 (extract 29 0 t1)) #b1))
+                                        (if
+                                            t4
+                                            (= t5 #x001d)
+                                            (and
+                                                (= t6 (= (extract 28 28 (extract 28 0 t1)) #b1))
+                                                (if
+                                                    t6
+                                                    (= t7 #x001c)
+                                                    (and
+                                                        (= t8 (= (extract 27 27 (extract 27 0 t1)) #b1))
+                                                        (if
+                                                            t8
+                                                            (= t9 #x001b)
+                                                            (and
+                                                                (= t10 (= (extract 26 26 (extract 26 0 t1)) #b1))
+                                                                (if
+                                                                    t10
+                                                                    (= t11 #x001a)
+                                                                    (and
+                                                                        (=
+                                                                            t12
+                                                                            (= (extract 25 25 (extract 25 0 t1)) #b1))
+                                                                        (if
+                                                                            t12
+                                                                            (= t13 #x0019)
+                                                                            (and
+                                                                                (=
+                                                                                    t14
+                                                                                    (=
+                                                                                        (extract
+                                                                                            24
+                                                                                            24
+                                                                                            (extract 24 0 t1))
+                                                                                        #b1))
+                                                                                (if
+                                                                                    t14
+                                                                                    (= t15 #x0018)
+                                                                                    (and
+                                                                                        (=
+                                                                                            t16
+                                                                                            (=
+                                                                                                (extract
+                                                                                                    23
+                                                                                                    23
+                                                                                                    (extract 23 0 t1))
+                                                                                                #b1))
+                                                                                        (if
+                                                                                            t16
+                                                                                            (= t17 #x0017)
+                                                                                            (and
+                                                                                                (=
+                                                                                                    t18
+                                                                                                    (=
+                                                                                                        (extract
+                                                                                                            22
+                                                                                                            22
+                                                                                                            (extract
+                                                                                                                22
+                                                                                                                0
+                                                                                                                t1))
+                                                                                                        #b1))
+                                                                                                (if
+                                                                                                    t18
+                                                                                                    (= t19 #x0016)
+                                                                                                    (and
+                                                                                                        (=
+                                                                                                            t20
+                                                                                                            (=
+                                                                                                                (extract
+                                                                                                                    21
+                                                                                                                    21
+                                                                                                                    (extract
+                                                                                                                        21
+                                                                                                                        0
+                                                                                                                        t1))
+                                                                                                                #b1))
+                                                                                                        (if
+                                                                                                            t20
+                                                                                                            (=
+                                                                                                                t21
+                                                                                                                #x0015)
+                                                                                                            (and
+                                                                                                                (=
+                                                                                                                    t22
+                                                                                                                    (=
+                                                                                                                        (extract
+                                                                                                                            20
+                                                                                                                            20
+                                                                                                                            (extract
+                                                                                                                                20
+                                                                                                                                0
+                                                                                                                                t1))
+                                                                                                                        #b1))
+                                                                                                                (if
+                                                                                                                    t22
+                                                                                                                    (=
+                                                                                                                        t23
+                                                                                                                        #x0014)
+                                                                                                                    (and
+                                                                                                                        (=
+                                                                                                                            t24
+                                                                                                                            (=
+                                                                                                                                (extract
+                                                                                                                                    19
+                                                                                                                                    19
+                                                                                                                                    (extract
+                                                                                                                                        19
+                                                                                                                                        0
+                                                                                                                                        t1))
+                                                                                                                                #b1))
+                                                                                                                        (if
+                                                                                                                            t24
+                                                                                                                            (=
+                                                                                                                                t25
+                                                                                                                                #x0013)
+                                                                                                                            (and
+                                                                                                                                (=
+                                                                                                                                    t26
+                                                                                                                                    (=
+                                                                                                                                        (extract
+                                                                                                                                            18
+                                                                                                                                            18
+                                                                                                                                            (extract
+                                                                                                                                                18
+                                                                                                                                                0
+                                                                                                                                                t1))
+                                                                                                                                        #b1))
+                                                                                                                                (if
+                                                                                                                                    t26
+                                                                                                                                    (=
+                                                                                                                                        t27
+                                                                                                                                        #x0012)
+                                                                                                                                    (and
+                                                                                                                                        (=
+                                                                                                                                            t28
+                                                                                                                                            (=
+                                                                                                                                                (extract
+                                                                                                                                                    17
+                                                                                                                                                    17
+                                                                                                                                                    (extract
+                                                                                                                                                        17
+                                                                                                                                                        0
+                                                                                                                                                        t1))
+                                                                                                                                                #b1))
+                                                                                                                                        (if
+                                                                                                                                            t28
+                                                                                                                                            (=
+                                                                                                                                                t29
+                                                                                                                                                #x0011)
+                                                                                                                                            (and
+                                                                                                                                                (=
+                                                                                                                                                    t30
+                                                                                                                                                    (=
+                                                                                                                                                        (extract
+                                                                                                                                                            16
+                                                                                                                                                            16
+                                                                                                                                                            (extract
+                                                                                                                                                                16
+                                                                                                                                                                0
+                                                                                                                                                                t1))
+                                                                                                                                                        #b1))
+                                                                                                                                                (if
+                                                                                                                                                    t30
+                                                                                                                                                    (=
+                                                                                                                                                        t31
+                                                                                                                                                        #x0010)
+                                                                                                                                                    (and
+                                                                                                                                                        (=
+                                                                                                                                                            t32
+                                                                                                                                                            (=
+                                                                                                                                                                (extract
+                                                                                                                                                                    15
+                                                                                                                                                                    15
+                                                                                                                                                                    (extract
+                                                                                                                                                                        15
+                                                                                                                                                                        0
+                                                                                                                                                                        t1))
+                                                                                                                                                                #b1))
+                                                                                                                                                        (if
+                                                                                                                                                            t32
+                                                                                                                                                            (=
+                                                                                                                                                                t33
+                                                                                                                                                                #x000f)
+                                                                                                                                                            (and
+                                                                                                                                                                (=
+                                                                                                                                                                    t34
+                                                                                                                                                                    (=
+                                                                                                                                                                        (extract
+                                                                                                                                                                            14
+                                                                                                                                                                            14
+                                                                                                                                                                            (extract
+                                                                                                                                                                                14
+                                                                                                                                                                                0
+                                                                                                                                                                                t1))
+                                                                                                                                                                        #b1))
+                                                                                                                                                                (if
+                                                                                                                                                                    t34
+                                                                                                                                                                    (=
+                                                                                                                                                                        t35
+                                                                                                                                                                        #x000e)
+                                                                                                                                                                    (and
+                                                                                                                                                                        (=
+                                                                                                                                                                            t36
+                                                                                                                                                                            (=
+                                                                                                                                                                                (extract
+                                                                                                                                                                                    13
+                                                                                                                                                                                    13
+                                                                                                                                                                                    (extract
+                                                                                                                                                                                        13
+                                                                                                                                                                                        0
+                                                                                                                                                                                        t1))
+                                                                                                                                                                                #b1))
+                                                                                                                                                                        (if
+                                                                                                                                                                            t36
+                                                                                                                                                                            (=
+                                                                                                                                                                                t37
+                                                                                                                                                                                #x000d)
+                                                                                                                                                                            (and
+                                                                                                                                                                                (=
+                                                                                                                                                                                    t38
+                                                                                                                                                                                    (=
+                                                                                                                                                                                        (extract
+                                                                                                                                                                                            12
+                                                                                                                                                                                            12
+                                                                                                                                                                                            (extract
+                                                                                                                                                                                                12
+                                                                                                                                                                                                0
+                                                                                                                                                                                                t1))
+                                                                                                                                                                                        #b1))
+                                                                                                                                                                                (if
+                                                                                                                                                                                    t38
+                                                                                                                                                                                    (=
+                                                                                                                                                                                        t39
+                                                                                                                                                                                        #x000c)
+                                                                                                                                                                                    (and
+                                                                                                                                                                                        (=
+                                                                                                                                                                                            t40
+                                                                                                                                                                                            (=
+                                                                                                                                                                                                (extract
+                                                                                                                                                                                                    11
+                                                                                                                                                                                                    11
+                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                        11
+                                                                                                                                                                                                        0
+                                                                                                                                                                                                        t1))
+                                                                                                                                                                                                #b1))
+                                                                                                                                                                                        (if
+                                                                                                                                                                                            t40
+                                                                                                                                                                                            (=
+                                                                                                                                                                                                t41
+                                                                                                                                                                                                #x000b)
+                                                                                                                                                                                            (and
+                                                                                                                                                                                                (=
+                                                                                                                                                                                                    t42
+                                                                                                                                                                                                    (=
+                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                            10
+                                                                                                                                                                                                            10
+                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                10
+                                                                                                                                                                                                                0
+                                                                                                                                                                                                                t1))
+                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                (if
+                                                                                                                                                                                                    t42
+                                                                                                                                                                                                    (=
+                                                                                                                                                                                                        t43
+                                                                                                                                                                                                        #x000a)
+                                                                                                                                                                                                    (and
+                                                                                                                                                                                                        (=
+                                                                                                                                                                                                            t44
+                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                    9
+                                                                                                                                                                                                                    9
+                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                        9
+                                                                                                                                                                                                                        0
+                                                                                                                                                                                                                        t1))
+                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                        (if
+                                                                                                                                                                                                            t44
+                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                t45
+                                                                                                                                                                                                                #x0009)
+                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                    t46
+                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                            8
+                                                                                                                                                                                                                            8
+                                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                                8
+                                                                                                                                                                                                                                0
+                                                                                                                                                                                                                                t1))
+                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                    t46
+                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                        t47
+                                                                                                                                                                                                                        #x0008)
+                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                            t48
+                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                    7
+                                                                                                                                                                                                                                    7
+                                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                                        7
+                                                                                                                                                                                                                                        0
+                                                                                                                                                                                                                                        t1))
+                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                            t48
+                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                t49
+                                                                                                                                                                                                                                #x0007)
+                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                    t50
+                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                            6
+                                                                                                                                                                                                                                            6
+                                                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                                                6
+                                                                                                                                                                                                                                                0
+                                                                                                                                                                                                                                                t1))
+                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                    t50
+                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                        t51
+                                                                                                                                                                                                                                        #x0006)
+                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                            t52
+                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                    5
+                                                                                                                                                                                                                                                    5
+                                                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                                                        5
+                                                                                                                                                                                                                                                        0
+                                                                                                                                                                                                                                                        t1))
+                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                            t52
+                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                t53
+                                                                                                                                                                                                                                                #x0005)
+                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                    t54
+                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                            4
+                                                                                                                                                                                                                                                            4
+                                                                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                                                                4
+                                                                                                                                                                                                                                                                0
+                                                                                                                                                                                                                                                                t1))
+                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                    t54
+                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                        t55
+                                                                                                                                                                                                                                                        #x0004)
+                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                            t56
+                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                    3
+                                                                                                                                                                                                                                                                    3
+                                                                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                                                                        3
+                                                                                                                                                                                                                                                                        0
+                                                                                                                                                                                                                                                                        t1))
+                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                            t56
+                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                t57
+                                                                                                                                                                                                                                                                #x0003)
+                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                    t58
+                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                            2
+                                                                                                                                                                                                                                                                            2
+                                                                                                                                                                                                                                                                            (extract
+                                                                                                                                                                                                                                                                                2
+                                                                                                                                                                                                                                                                                0
+                                                                                                                                                                                                                                                                                t1))
+                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                    t58
+                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                        t59
+                                                                                                                                                                                                                                                                        #x0002)
+                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                            t60
+                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                    1
+                                                                                                                                                                                                                                                                                    1
+                                                                                                                                                                                                                                                                                    (extract
+                                                                                                                                                                                                                                                                                        1
+                                                                                                                                                                                                                                                                                        0
+                                                                                                                                                                                                                                                                                        t1))
+                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                            t60
+                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                t61
+                                                                                                                                                                                                                                                                                #x0001)
+                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                    t62
+                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                            0
+                                                                                                                                                                                                                                                                                            0
+                                                                                                                                                                                                                                                                                            t1)
+                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                    t62
+                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                        t63
+                                                                                                                                                                                                                                                                                        #x0000)
+                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                        t64
+                                                                                                                                                                                                                                                                                        #xffff))
+                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                    t65
+                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                        t62
+                                                                                                                                                                                                                                                                                        t63
+                                                                                                                                                                                                                                                                                        t64))))
+                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                            t66
+                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                t60
+                                                                                                                                                                                                                                                                                t61
+                                                                                                                                                                                                                                                                                t65))))
+                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                    t67
+                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                        t58
+                                                                                                                                                                                                                                                                        t59
+                                                                                                                                                                                                                                                                        t66))))
+                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                            t68
+                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                t56
+                                                                                                                                                                                                                                                                t57
+                                                                                                                                                                                                                                                                t67))))
+                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                    t69
+                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                        t54
+                                                                                                                                                                                                                                                        t55
+                                                                                                                                                                                                                                                        t68))))
+                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                            t70
+                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                t52
+                                                                                                                                                                                                                                                t53
+                                                                                                                                                                                                                                                t69))))
+                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                    t71
+                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                        t50
+                                                                                                                                                                                                                                        t51
+                                                                                                                                                                                                                                        t70))))
+                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                            t72
+                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                t48
+                                                                                                                                                                                                                                t49
+                                                                                                                                                                                                                                t71))))
+                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                    t73
+                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                        t46
+                                                                                                                                                                                                                        t47
+                                                                                                                                                                                                                        t72))))
+                                                                                                                                                                                                        (=
+                                                                                                                                                                                                            t74
+                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                t44
+                                                                                                                                                                                                                t45
+                                                                                                                                                                                                                t73))))
+                                                                                                                                                                                                (=
+                                                                                                                                                                                                    t75
+                                                                                                                                                                                                    (if
+                                                                                                                                                                                                        t42
+                                                                                                                                                                                                        t43
+                                                                                                                                                                                                        t74))))
+                                                                                                                                                                                        (=
+                                                                                                                                                                                            t76
+                                                                                                                                                                                            (if
+                                                                                                                                                                                                t40
+                                                                                                                                                                                                t41
+                                                                                                                                                                                                t75))))
+                                                                                                                                                                                (=
+                                                                                                                                                                                    t77
+                                                                                                                                                                                    (if
+                                                                                                                                                                                        t38
+                                                                                                                                                                                        t39
+                                                                                                                                                                                        t76))))
+                                                                                                                                                                        (=
+                                                                                                                                                                            t78
+                                                                                                                                                                            (if
+                                                                                                                                                                                t36
+                                                                                                                                                                                t37
+                                                                                                                                                                                t77))))
+                                                                                                                                                                (=
+                                                                                                                                                                    t79
+                                                                                                                                                                    (if
+                                                                                                                                                                        t34
+                                                                                                                                                                        t35
+                                                                                                                                                                        t78))))
+                                                                                                                                                        (=
+                                                                                                                                                            t80
+                                                                                                                                                            (if
+                                                                                                                                                                t32
+                                                                                                                                                                t33
+                                                                                                                                                                t79))))
+                                                                                                                                                (=
+                                                                                                                                                    t81
+                                                                                                                                                    (if
+                                                                                                                                                        t30
+                                                                                                                                                        t31
+                                                                                                                                                        t80))))
+                                                                                                                                        (=
+                                                                                                                                            t82
+                                                                                                                                            (if
+                                                                                                                                                t28
+                                                                                                                                                t29
+                                                                                                                                                t81))))
+                                                                                                                                (=
+                                                                                                                                    t83
+                                                                                                                                    (if
+                                                                                                                                        t26
+                                                                                                                                        t27
+                                                                                                                                        t82))))
+                                                                                                                        (=
+                                                                                                                            t84
+                                                                                                                            (if
+                                                                                                                                t24
+                                                                                                                                t25
+                                                                                                                                t83))))
+                                                                                                                (=
+                                                                                                                    t85
+                                                                                                                    (if
+                                                                                                                        t22
+                                                                                                                        t23
+                                                                                                                        t84))))
+                                                                                                        (=
+                                                                                                            t86
+                                                                                                            (if
+                                                                                                                t20
+                                                                                                                t21
+                                                                                                                t85))))
+                                                                                                (=
+                                                                                                    t87
+                                                                                                    (if t18 t19 t86))))
+                                                                                        (= t88 (if t16 t17 t87))))
+                                                                                (= t89 (if t14 t15 t88))))
+                                                                        (= t90 (if t12 t13 t89))))
+                                                                (= t91 (if t10 t11 t90))))
+                                                        (= t92 (if t8 t9 t91))))
+                                                (= t93 (if t6 t7 t92))))
+                                        (= t94 (if t4 t5 t93))))
+                                (= t95 (if t2 t3 t94))
+                                (= rd (zero_ext 64 (sign_ext 32 (bvsub #x001f (bvadd t95 #x0001))))))))
+                    ((RBit)
+                        (=
+                            rd
+                            (zero_ext
+                                64
+                                (concat
+                                    (concat
+                                        (concat
+                                            (concat
+                                                (concat
+                                                    (concat
+                                                        (concat
+                                                            (concat
+                                                                (concat
+                                                                    (concat
+                                                                        (concat
+                                                                            (concat
+                                                                                (concat
+                                                                                    (concat
+                                                                                        (concat
+                                                                                            (concat
+                                                                                                (concat
+                                                                                                    (concat
+                                                                                                        (concat
+                                                                                                            (concat
+                                                                                                                (concat
+                                                                                                                    (concat
+                                                                                                                        (concat
+                                                                                                                            (concat
+                                                                                                                                (concat
+                                                                                                                                    (concat
+                                                                                                                                        (concat
+                                                                                                                                            (concat
+                                                                                                                                                (concat
+                                                                                                                                                    (concat
+                                                                                                                                                        (concat
+                                                                                                                                                            (extract
+                                                                                                                                                                0
+                                                                                                                                                                0
+                                                                                                                                                                (as
+                                                                                                                                                                    rn
+                                                                                                                                                                    (bv
+                                                                                                                                                                        64)))
+                                                                                                                                                            (extract
+                                                                                                                                                                1
+                                                                                                                                                                1
+                                                                                                                                                                (as
+                                                                                                                                                                    rn
+                                                                                                                                                                    (bv
+                                                                                                                                                                        64))))
+                                                                                                                                                        (extract
+                                                                                                                                                            2
+                                                                                                                                                            2
+                                                                                                                                                            (as
+                                                                                                                                                                rn
+                                                                                                                                                                (bv
+                                                                                                                                                                    64))))
+                                                                                                                                                    (extract
+                                                                                                                                                        3
+                                                                                                                                                        3
+                                                                                                                                                        (as
+                                                                                                                                                            rn
+                                                                                                                                                            (bv
+                                                                                                                                                                64))))
+                                                                                                                                                (extract
+                                                                                                                                                    4
+                                                                                                                                                    4
+                                                                                                                                                    (as
+                                                                                                                                                        rn
+                                                                                                                                                        (bv
+                                                                                                                                                            64))))
+                                                                                                                                            (extract
+                                                                                                                                                5
+                                                                                                                                                5
+                                                                                                                                                (as
+                                                                                                                                                    rn
+                                                                                                                                                    (bv
+                                                                                                                                                        64))))
+                                                                                                                                        (extract
+                                                                                                                                            6
+                                                                                                                                            6
+                                                                                                                                            (as
+                                                                                                                                                rn
+                                                                                                                                                (bv
+                                                                                                                                                    64))))
+                                                                                                                                    (extract
+                                                                                                                                        7
+                                                                                                                                        7
+                                                                                                                                        (as
+                                                                                                                                            rn
+                                                                                                                                            (bv
+                                                                                                                                                64))))
+                                                                                                                                (extract
+                                                                                                                                    8
+                                                                                                                                    8
+                                                                                                                                    (as
+                                                                                                                                        rn
+                                                                                                                                        (bv
+                                                                                                                                            64))))
+                                                                                                                            (extract
+                                                                                                                                9
+                                                                                                                                9
+                                                                                                                                (as
+                                                                                                                                    rn
+                                                                                                                                    (bv
+                                                                                                                                        64))))
+                                                                                                                        (extract
+                                                                                                                            10
+                                                                                                                            10
+                                                                                                                            (as
+                                                                                                                                rn
+                                                                                                                                (bv
+                                                                                                                                    64))))
+                                                                                                                    (extract
+                                                                                                                        11
+                                                                                                                        11
+                                                                                                                        (as
+                                                                                                                            rn
+                                                                                                                            (bv
+                                                                                                                                64))))
+                                                                                                                (extract
+                                                                                                                    12
+                                                                                                                    12
+                                                                                                                    (as
+                                                                                                                        rn
+                                                                                                                        (bv
+                                                                                                                            64))))
+                                                                                                            (extract
+                                                                                                                13
+                                                                                                                13
+                                                                                                                (as
+                                                                                                                    rn
+                                                                                                                    (bv
+                                                                                                                        64))))
+                                                                                                        (extract
+                                                                                                            14
+                                                                                                            14
+                                                                                                            (as
+                                                                                                                rn
+                                                                                                                (bv
+                                                                                                                    64))))
+                                                                                                    (extract
+                                                                                                        15
+                                                                                                        15
+                                                                                                        (as
+                                                                                                            rn
+                                                                                                            (bv 64))))
+                                                                                                (extract
+                                                                                                    16
+                                                                                                    16
+                                                                                                    (as rn (bv 64))))
+                                                                                            (extract
+                                                                                                17
+                                                                                                17
+                                                                                                (as rn (bv 64))))
+                                                                                        (extract 18 18 (as rn (bv 64))))
+                                                                                    (extract 19 19 (as rn (bv 64))))
+                                                                                (extract 20 20 (as rn (bv 64))))
+                                                                            (extract 21 21 (as rn (bv 64))))
+                                                                        (extract 22 22 (as rn (bv 64))))
+                                                                    (extract 23 23 (as rn (bv 64))))
+                                                                (extract 24 24 (as rn (bv 64))))
+                                                            (extract 25 25 (as rn (bv 64))))
+                                                        (extract 26 26 (as rn (bv 64))))
+                                                    (extract 27 27 (as rn (bv 64))))
+                                                (extract 28 28 (as rn (bv 64))))
+                                            (extract 29 29 (as rn (bv 64))))
+                                        (extract 30 30 (as rn (bv 64))))
+                                    (extract 31 31 (as rn (bv 64)))))))
+                    ((Clz)
+                        (with
+                            (t1
+                                t10
+                                t11
+                                t12
+                                t13
+                                t14
+                                t15
+                                t16
+                                t17
+                                t18
+                                t19
+                                t2
+                                t20
+                                t21
+                                t22
+                                t23
+                                t24
+                                t25
+                                t26
+                                t27
+                                t28
+                                t29
+                                t3
+                                t30
+                                t31
+                                t32
+                                t33
+                                t34
+                                t35
+                                t36
+                                t37
+                                t38
+                                t39
+                                t4
+                                t40
+                                t41
+                                t42
+                                t43
+                                t44
+                                t45
+                                t46
+                                t47
+                                t48
+                                t49
+                                t5
+                                t50
+                                t51
+                                t52
+                                t53
+                                t54
+                                t55
+                                t56
+                                t57
+                                t58
+                                t59
+                                t6
+                                t60
+                                t61
+                                t62
+                                t63
+                                t64
+                                t65
+                                t66
+                                t67
+                                t68
+                                t69
+                                t7
+                                t70
+                                t71
+                                t72
+                                t73
+                                t74
+                                t75
+                                t76
+                                t77
+                                t78
+                                t79
+                                t8
+                                t80
+                                t81
+                                t82
+                                t83
+                                t84
+                                t85
+                                t86
+                                t87
+                                t88
+                                t89
+                                t9
+                                t90
+                                t91
+                                t92
+                                t93
+                                t94
+                                t95
+                                t96
+                                t97)
+                            (and
+                                (= t1 (= (extract 31 31 (as rn (bv 64))) #b1))
+                                (if
+                                    t1
+                                    (= t2 #x001f)
+                                    (and
+                                        (= t3 (= (extract 30 30 (as rn (bv 64))) #b1))
+                                        (if
+                                            t3
+                                            (= t4 #x001e)
+                                            (and
+                                                (= t5 (= (extract 29 29 (as rn (bv 64))) #b1))
+                                                (if
+                                                    t5
+                                                    (= t6 #x001d)
+                                                    (and
+                                                        (= t7 (= (extract 28 28 (as rn (bv 64))) #b1))
+                                                        (if
+                                                            t7
+                                                            (= t8 #x001c)
+                                                            (and
+                                                                (= t9 (= (extract 27 27 (as rn (bv 64))) #b1))
+                                                                (if
+                                                                    t9
+                                                                    (= t10 #x001b)
+                                                                    (and
+                                                                        (= t11 (= (extract 26 26 (as rn (bv 64))) #b1))
+                                                                        (if
+                                                                            t11
+                                                                            (= t12 #x001a)
+                                                                            (and
+                                                                                (=
+                                                                                    t13
+                                                                                    (=
+                                                                                        (extract 25 25 (as rn (bv 64)))
+                                                                                        #b1))
+                                                                                (if
+                                                                                    t13
+                                                                                    (= t14 #x0019)
+                                                                                    (and
+                                                                                        (=
+                                                                                            t15
+                                                                                            (=
+                                                                                                (extract
+                                                                                                    24
+                                                                                                    24
+                                                                                                    (as rn (bv 64)))
+                                                                                                #b1))
+                                                                                        (if
+                                                                                            t15
+                                                                                            (= t16 #x0018)
+                                                                                            (and
+                                                                                                (=
+                                                                                                    t17
+                                                                                                    (=
+                                                                                                        (extract
+                                                                                                            23
+                                                                                                            23
+                                                                                                            (as
+                                                                                                                rn
+                                                                                                                (bv
+                                                                                                                    64)))
+                                                                                                        #b1))
+                                                                                                (if
+                                                                                                    t17
+                                                                                                    (= t18 #x0017)
+                                                                                                    (and
+                                                                                                        (=
+                                                                                                            t19
+                                                                                                            (=
+                                                                                                                (extract
+                                                                                                                    22
+                                                                                                                    22
+                                                                                                                    (as
+                                                                                                                        rn
+                                                                                                                        (bv
+                                                                                                                            64)))
+                                                                                                                #b1))
+                                                                                                        (if
+                                                                                                            t19
+                                                                                                            (=
+                                                                                                                t20
+                                                                                                                #x0016)
+                                                                                                            (and
+                                                                                                                (=
+                                                                                                                    t21
+                                                                                                                    (=
+                                                                                                                        (extract
+                                                                                                                            21
+                                                                                                                            21
+                                                                                                                            (as
+                                                                                                                                rn
+                                                                                                                                (bv
+                                                                                                                                    64)))
+                                                                                                                        #b1))
+                                                                                                                (if
+                                                                                                                    t21
+                                                                                                                    (=
+                                                                                                                        t22
+                                                                                                                        #x0015)
+                                                                                                                    (and
+                                                                                                                        (=
+                                                                                                                            t23
+                                                                                                                            (=
+                                                                                                                                (extract
+                                                                                                                                    20
+                                                                                                                                    20
+                                                                                                                                    (as
+                                                                                                                                        rn
+                                                                                                                                        (bv
+                                                                                                                                            64)))
+                                                                                                                                #b1))
+                                                                                                                        (if
+                                                                                                                            t23
+                                                                                                                            (=
+                                                                                                                                t24
+                                                                                                                                #x0014)
+                                                                                                                            (and
+                                                                                                                                (=
+                                                                                                                                    t25
+                                                                                                                                    (=
+                                                                                                                                        (extract
+                                                                                                                                            19
+                                                                                                                                            19
+                                                                                                                                            (as
+                                                                                                                                                rn
+                                                                                                                                                (bv
+                                                                                                                                                    64)))
+                                                                                                                                        #b1))
+                                                                                                                                (if
+                                                                                                                                    t25
+                                                                                                                                    (=
+                                                                                                                                        t26
+                                                                                                                                        #x0013)
+                                                                                                                                    (and
+                                                                                                                                        (=
+                                                                                                                                            t27
+                                                                                                                                            (=
+                                                                                                                                                (extract
+                                                                                                                                                    18
+                                                                                                                                                    18
+                                                                                                                                                    (as
+                                                                                                                                                        rn
+                                                                                                                                                        (bv
+                                                                                                                                                            64)))
+                                                                                                                                                #b1))
+                                                                                                                                        (if
+                                                                                                                                            t27
+                                                                                                                                            (=
+                                                                                                                                                t28
+                                                                                                                                                #x0012)
+                                                                                                                                            (and
+                                                                                                                                                (=
+                                                                                                                                                    t29
+                                                                                                                                                    (=
+                                                                                                                                                        (extract
+                                                                                                                                                            17
+                                                                                                                                                            17
+                                                                                                                                                            (as
+                                                                                                                                                                rn
+                                                                                                                                                                (bv
+                                                                                                                                                                    64)))
+                                                                                                                                                        #b1))
+                                                                                                                                                (if
+                                                                                                                                                    t29
+                                                                                                                                                    (=
+                                                                                                                                                        t30
+                                                                                                                                                        #x0011)
+                                                                                                                                                    (and
+                                                                                                                                                        (=
+                                                                                                                                                            t31
+                                                                                                                                                            (=
+                                                                                                                                                                (extract
+                                                                                                                                                                    16
+                                                                                                                                                                    16
+                                                                                                                                                                    (as
+                                                                                                                                                                        rn
+                                                                                                                                                                        (bv
+                                                                                                                                                                            64)))
+                                                                                                                                                                #b1))
+                                                                                                                                                        (if
+                                                                                                                                                            t31
+                                                                                                                                                            (=
+                                                                                                                                                                t32
+                                                                                                                                                                #x0010)
+                                                                                                                                                            (and
+                                                                                                                                                                (=
+                                                                                                                                                                    t33
+                                                                                                                                                                    (=
+                                                                                                                                                                        (extract
+                                                                                                                                                                            15
+                                                                                                                                                                            15
+                                                                                                                                                                            (as
+                                                                                                                                                                                rn
+                                                                                                                                                                                (bv
+                                                                                                                                                                                    64)))
+                                                                                                                                                                        #b1))
+                                                                                                                                                                (if
+                                                                                                                                                                    t33
+                                                                                                                                                                    (=
+                                                                                                                                                                        t34
+                                                                                                                                                                        #x000f)
+                                                                                                                                                                    (and
+                                                                                                                                                                        (=
+                                                                                                                                                                            t35
+                                                                                                                                                                            (=
+                                                                                                                                                                                (extract
+                                                                                                                                                                                    14
+                                                                                                                                                                                    14
+                                                                                                                                                                                    (as
+                                                                                                                                                                                        rn
+                                                                                                                                                                                        (bv
+                                                                                                                                                                                            64)))
+                                                                                                                                                                                #b1))
+                                                                                                                                                                        (if
+                                                                                                                                                                            t35
+                                                                                                                                                                            (=
+                                                                                                                                                                                t36
+                                                                                                                                                                                #x000e)
+                                                                                                                                                                            (and
+                                                                                                                                                                                (=
+                                                                                                                                                                                    t37
+                                                                                                                                                                                    (=
+                                                                                                                                                                                        (extract
+                                                                                                                                                                                            13
+                                                                                                                                                                                            13
+                                                                                                                                                                                            (as
+                                                                                                                                                                                                rn
+                                                                                                                                                                                                (bv
+                                                                                                                                                                                                    64)))
+                                                                                                                                                                                        #b1))
+                                                                                                                                                                                (if
+                                                                                                                                                                                    t37
+                                                                                                                                                                                    (=
+                                                                                                                                                                                        t38
+                                                                                                                                                                                        #x000d)
+                                                                                                                                                                                    (and
+                                                                                                                                                                                        (=
+                                                                                                                                                                                            t39
+                                                                                                                                                                                            (=
+                                                                                                                                                                                                (extract
+                                                                                                                                                                                                    12
+                                                                                                                                                                                                    12
+                                                                                                                                                                                                    (as
+                                                                                                                                                                                                        rn
+                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                #b1))
+                                                                                                                                                                                        (if
+                                                                                                                                                                                            t39
+                                                                                                                                                                                            (=
+                                                                                                                                                                                                t40
+                                                                                                                                                                                                #x000c)
+                                                                                                                                                                                            (and
+                                                                                                                                                                                                (=
+                                                                                                                                                                                                    t41
+                                                                                                                                                                                                    (=
+                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                            11
+                                                                                                                                                                                                            11
+                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                    64)))
+                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                (if
+                                                                                                                                                                                                    t41
+                                                                                                                                                                                                    (=
+                                                                                                                                                                                                        t42
+                                                                                                                                                                                                        #x000b)
+                                                                                                                                                                                                    (and
+                                                                                                                                                                                                        (=
+                                                                                                                                                                                                            t43
+                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                    10
+                                                                                                                                                                                                                    10
+                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                        (if
+                                                                                                                                                                                                            t43
+                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                t44
+                                                                                                                                                                                                                #x000a)
+                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                    t45
+                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                            9
+                                                                                                                                                                                                                            9
+                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                    64)))
+                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                    t45
+                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                        t46
+                                                                                                                                                                                                                        #x0009)
+                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                            t47
+                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                    8
+                                                                                                                                                                                                                                    8
+                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                            t47
+                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                t48
+                                                                                                                                                                                                                                #x0008)
+                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                    t49
+                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                            7
+                                                                                                                                                                                                                                            7
+                                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                                    64)))
+                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                    t49
+                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                        t50
+                                                                                                                                                                                                                                        #x0007)
+                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                            t51
+                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                    6
+                                                                                                                                                                                                                                                    6
+                                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                            t51
+                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                t52
+                                                                                                                                                                                                                                                #x0006)
+                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                    t53
+                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                            5
+                                                                                                                                                                                                                                                            5
+                                                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                                                    64)))
+                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                    t53
+                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                        t54
+                                                                                                                                                                                                                                                        #x0005)
+                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                            t55
+                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                    4
+                                                                                                                                                                                                                                                                    4
+                                                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                            t55
+                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                t56
+                                                                                                                                                                                                                                                                #x0004)
+                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                    t57
+                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                            3
+                                                                                                                                                                                                                                                                            3
+                                                                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                                                                    64)))
+                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                    t57
+                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                        t58
+                                                                                                                                                                                                                                                                        #x0003)
+                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                            t59
+                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                    2
+                                                                                                                                                                                                                                                                                    2
+                                                                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                            t59
+                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                t60
+                                                                                                                                                                                                                                                                                #x0002)
+                                                                                                                                                                                                                                                                            (and
+                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                    t61
+                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                        (extract
+                                                                                                                                                                                                                                                                                            1
+                                                                                                                                                                                                                                                                                            1
+                                                                                                                                                                                                                                                                                            (as
+                                                                                                                                                                                                                                                                                                rn
+                                                                                                                                                                                                                                                                                                (bv
+                                                                                                                                                                                                                                                                                                    64)))
+                                                                                                                                                                                                                                                                                        #b1))
+                                                                                                                                                                                                                                                                                (if
+                                                                                                                                                                                                                                                                                    t61
+                                                                                                                                                                                                                                                                                    (=
+                                                                                                                                                                                                                                                                                        t62
+                                                                                                                                                                                                                                                                                        #x0001)
+                                                                                                                                                                                                                                                                                    (and
+                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                            t63
+                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                (extract
+                                                                                                                                                                                                                                                                                                    0
+                                                                                                                                                                                                                                                                                                    0
+                                                                                                                                                                                                                                                                                                    (as
+                                                                                                                                                                                                                                                                                                        rn
+                                                                                                                                                                                                                                                                                                        (bv
+                                                                                                                                                                                                                                                                                                            64)))
+                                                                                                                                                                                                                                                                                                #b1))
+                                                                                                                                                                                                                                                                                        (if
+                                                                                                                                                                                                                                                                                            t63
+                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                t64
+                                                                                                                                                                                                                                                                                                #x0000)
+                                                                                                                                                                                                                                                                                            (=
+                                                                                                                                                                                                                                                                                                t65
+                                                                                                                                                                                                                                                                                                #xffff))
+                                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                                            t66
+                                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                                t63
+                                                                                                                                                                                                                                                                                                t64
+                                                                                                                                                                                                                                                                                                t65))))
+                                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                                    t67
+                                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                                        t61
+                                                                                                                                                                                                                                                                                        t62
+                                                                                                                                                                                                                                                                                        t66))))
+                                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                                            t68
+                                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                                t59
+                                                                                                                                                                                                                                                                                t60
+                                                                                                                                                                                                                                                                                t67))))
+                                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                                    t69
+                                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                                        t57
+                                                                                                                                                                                                                                                                        t58
+                                                                                                                                                                                                                                                                        t68))))
+                                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                                            t70
+                                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                                t55
+                                                                                                                                                                                                                                                                t56
+                                                                                                                                                                                                                                                                t69))))
+                                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                                    t71
+                                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                                        t53
+                                                                                                                                                                                                                                                        t54
+                                                                                                                                                                                                                                                        t70))))
+                                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                                            t72
+                                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                                t51
+                                                                                                                                                                                                                                                t52
+                                                                                                                                                                                                                                                t71))))
+                                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                                    t73
+                                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                                        t49
+                                                                                                                                                                                                                                        t50
+                                                                                                                                                                                                                                        t72))))
+                                                                                                                                                                                                                        (=
+                                                                                                                                                                                                                            t74
+                                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                                t47
+                                                                                                                                                                                                                                t48
+                                                                                                                                                                                                                                t73))))
+                                                                                                                                                                                                                (=
+                                                                                                                                                                                                                    t75
+                                                                                                                                                                                                                    (if
+                                                                                                                                                                                                                        t45
+                                                                                                                                                                                                                        t46
+                                                                                                                                                                                                                        t74))))
+                                                                                                                                                                                                        (=
+                                                                                                                                                                                                            t76
+                                                                                                                                                                                                            (if
+                                                                                                                                                                                                                t43
+                                                                                                                                                                                                                t44
+                                                                                                                                                                                                                t75))))
+                                                                                                                                                                                                (=
+                                                                                                                                                                                                    t77
+                                                                                                                                                                                                    (if
+                                                                                                                                                                                                        t41
+                                                                                                                                                                                                        t42
+                                                                                                                                                                                                        t76))))
+                                                                                                                                                                                        (=
+                                                                                                                                                                                            t78
+                                                                                                                                                                                            (if
+                                                                                                                                                                                                t39
+                                                                                                                                                                                                t40
+                                                                                                                                                                                                t77))))
+                                                                                                                                                                                (=
+                                                                                                                                                                                    t79
+                                                                                                                                                                                    (if
+                                                                                                                                                                                        t37
+                                                                                                                                                                                        t38
+                                                                                                                                                                                        t78))))
+                                                                                                                                                                        (=
+                                                                                                                                                                            t80
+                                                                                                                                                                            (if
+                                                                                                                                                                                t35
+                                                                                                                                                                                t36
+                                                                                                                                                                                t79))))
+                                                                                                                                                                (=
+                                                                                                                                                                    t81
+                                                                                                                                                                    (if
+                                                                                                                                                                        t33
+                                                                                                                                                                        t34
+                                                                                                                                                                        t80))))
+                                                                                                                                                        (=
+                                                                                                                                                            t82
+                                                                                                                                                            (if
+                                                                                                                                                                t31
+                                                                                                                                                                t32
+                                                                                                                                                                t81))))
+                                                                                                                                                (=
+                                                                                                                                                    t83
+                                                                                                                                                    (if
+                                                                                                                                                        t29
+                                                                                                                                                        t30
+                                                                                                                                                        t82))))
+                                                                                                                                        (=
+                                                                                                                                            t84
+                                                                                                                                            (if
+                                                                                                                                                t27
+                                                                                                                                                t28
+                                                                                                                                                t83))))
+                                                                                                                                (=
+                                                                                                                                    t85
+                                                                                                                                    (if
+                                                                                                                                        t25
+                                                                                                                                        t26
+                                                                                                                                        t84))))
+                                                                                                                        (=
+                                                                                                                            t86
+                                                                                                                            (if
+                                                                                                                                t23
+                                                                                                                                t24
+                                                                                                                                t85))))
+                                                                                                                (=
+                                                                                                                    t87
+                                                                                                                    (if
+                                                                                                                        t21
+                                                                                                                        t22
+                                                                                                                        t86))))
+                                                                                                        (=
+                                                                                                            t88
+                                                                                                            (if
+                                                                                                                t19
+                                                                                                                t20
+                                                                                                                t87))))
+                                                                                                (=
+                                                                                                    t89
+                                                                                                    (if t17 t18 t88))))
+                                                                                        (= t90 (if t15 t16 t89))))
+                                                                                (= t91 (if t13 t14 t90))))
+                                                                        (= t92 (if t11 t12 t91))))
+                                                                (= t93 (if t9 t10 t92))))
+                                                        (= t94 (if t7 t8 t93))))
+                                                (= t95 (if t5 t6 t94))))
+                                        (= t96 (if t3 t4 t95))))
+                                (= t97 (if t1 t2 t96))
+                                (= rd (zero_ext 64 (sign_ext 32 (bvsub #x0020 (bvadd t97 #x0001))))))))))))
+    (require
+        (match
+            size
+            ((Size64) (match op ((Cls) true) ((RBit) true) ((Clz) true)))
+            ((Size32) (match op ((Cls) true) ((RBit) true) ((Clz) true))))))
diff --git a/cranelift/codegen/src/isa/aarch64/spec/conds.isle b/cranelift/codegen/src/isa/aarch64/spec/conds.isle
new file mode 100644
index 000000000000..04b0ee6f75c0
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/spec/conds.isle
@@ -0,0 +1,3103 @@
+;; GENERATED BY `isaspec`. DO NOT EDIT!!!
+
+(attr MInst.CSel (tag isaspec_generated))
+
+(spec
+    (MInst.CSel rd cond rn rm)
+    (provide
+        (match
+            cond
+            ((Le)
+                (with
+                    (t3 t5 t7)
+                    (and
+                        (=
+                            t3
+                            (not
+                                (and
+                                    (= (:N (:flags_in result)) (:V (:flags_in result)))
+                                    (= (:Z (:flags_in result)) #b0))))
+                        (if t3 (= t5 rn) (= t7 rm))
+                        (= rd (if t3 t5 t7)))))
+            ((Gt)
+                (with
+                    (t3 t5 t7)
+                    (and
+                        (= t3 (and (= (:N (:flags_in result)) (:V (:flags_in result))) (= (:Z (:flags_in result)) #b0)))
+                        (if t3 (= t5 rn) (= t7 rm))
+                        (= rd (if t3 t5 t7)))))
+            ((Lt)
+                (with
+                    (t2 t4 t6)
+                    (and
+                        (= t2 (not (= (:N (:flags_in result)) (:V (:flags_in result)))))
+                        (if t2 (= t4 rn) (= t6 rm))
+                        (= rd (if t2 t4 t6)))))
+            ((Ge)
+                (with
+                    (t2 t4 t6)
+                    (and
+                        (= t2 (= (:N (:flags_in result)) (:V (:flags_in result))))
+                        (if t2 (= t4 rn) (= t6 rm))
+                        (= rd (if t2 t4 t6)))))
+            ((Ls)
+                (with
+                    (t2 t4 t6)
+                    (and
+                        (= t2 (not (and (= (:C (:flags_in result)) #b1) (= (:Z (:flags_in result)) #b0))))
+                        (if t2 (= t4 rn) (= t6 rm))
+                        (= rd (if t2 t4 t6)))))
+            ((Hi)
+                (with
+                    (t2 t4 t6)
+                    (and
+                        (= t2 (and (= (:C (:flags_in result)) #b1) (= (:Z (:flags_in result)) #b0)))
+                        (if t2 (= t4 rn) (= t6 rm))
+                        (= rd (if t2 t4 t6)))))
+            ((Vc)
+                (with
+                    (t1 t3 t5)
+                    (and
+                        (= t1 (not (= (:V (:flags_in result)) #b1)))
+                        (if t1 (= t3 rn) (= t5 rm))
+                        (= rd (if t1 t3 t5)))))
+            ((Vs)
+                (with
+                    (t1 t3 t5)
+                    (and (= t1 (= (:V (:flags_in result)) #b1)) (if t1 (= t3 rn) (= t5 rm)) (= rd (if t1 t3 t5)))))
+            ((Pl)
+                (with
+                    (t1 t3 t5)
+                    (and
+                        (= t1 (not (= (:N (:flags_in result)) #b1)))
+                        (if t1 (= t3 rn) (= t5 rm))
+                        (= rd (if t1 t3 t5)))))
+            ((Mi)
+                (with
+                    (t1 t3 t5)
+                    (and (= t1 (= (:N (:flags_in result)) #b1)) (if t1 (= t3 rn) (= t5 rm)) (= rd (if t1 t3 t5)))))
+            ((Lo)
+                (with
+                    (t1 t3 t5)
+                    (and
+                        (= t1 (not (= (:C (:flags_in result)) #b1)))
+                        (if t1 (= t3 rn) (= t5 rm))
+                        (= rd (if t1 t3 t5)))))
+            ((Hs)
+                (with
+                    (t1 t3 t5)
+                    (and (= t1 (= (:C (:flags_in result)) #b1)) (if t1 (= t3 rn) (= t5 rm)) (= rd (if t1 t3 t5)))))
+            ((Ne)
+                (with
+                    (t1 t3 t5)
+                    (and
+                        (= t1 (not (= (:Z (:flags_in result)) #b1)))
+                        (if t1 (= t3 rn) (= t5 rm))
+                        (= rd (if t1 t3 t5)))))
+            ((Eq)
+                (with
+                    (t1 t3 t5)
+                    (and (= t1 (= (:Z (:flags_in result)) #b1)) (if t1 (= t3 rn) (= t5 rm)) (= rd (if t1 t3 t5)))))))
+    (require
+        (match
+            cond
+            ((Le) true)
+            ((Gt) true)
+            ((Lt) true)
+            ((Ge) true)
+            ((Ls) true)
+            ((Hi) true)
+            ((Vc) true)
+            ((Vs) true)
+            ((Pl) true)
+            ((Mi) true)
+            ((Lo) true)
+            ((Hs) true)
+            ((Ne) true)
+            ((Eq) true))))
+
+(attr MInst.CSNeg (tag isaspec_generated))
+
+(spec
+    (MInst.CSNeg rd cond rn rm)
+    (provide
+        (match
+            cond
+            ((Le)
+                (with
+                    (t3 t5 t7)
+                    (and
+                        (=
+                            t3
+                            (not
+                                (and
+                                    (= (:N (:flags_in result)) (:V (:flags_in result)))
+                                    (= (:Z (:flags_in result)) #b0))))
+                        (if t3 (= t5 rn) (= t7 (bvadd (bvnot rm) #x0000000000000001)))
+                        (= rd (if t3 t5 t7)))))
+            ((Gt)
+                (with
+                    (t3 t5 t7)
+                    (and
+                        (= t3 (and (= (:N (:flags_in result)) (:V (:flags_in result))) (= (:Z (:flags_in result)) #b0)))
+                        (if t3 (= t5 rn) (= t7 (bvadd (bvnot rm) #x0000000000000001)))
+                        (= rd (if t3 t5 t7)))))
+            ((Lt)
+                (with
+                    (t2 t4 t6)
+                    (and
+                        (= t2 (not (= (:N (:flags_in result)) (:V (:flags_in result)))))
+                        (if t2 (= t4 rn) (= t6 (bvadd (bvnot rm) #x0000000000000001)))
+                        (= rd (if t2 t4 t6)))))
+            ((Ge)
+                (with
+                    (t2 t4 t6)
+                    (and
+                        (= t2 (= (:N (:flags_in result)) (:V (:flags_in result))))
+                        (if t2 (= t4 rn) (= t6 (bvadd (bvnot rm) #x0000000000000001)))
+                        (= rd (if t2 t4 t6)))))
+            ((Ls)
+                (with
+                    (t2 t4 t6)
+                    (and
+                        (= t2 (not (and (= (:C (:flags_in result)) #b1) (= (:Z (:flags_in result)) #b0))))
+                        (if t2 (= t4 rn) (= t6 (bvadd (bvnot rm) #x0000000000000001)))
+                        (= rd (if t2 t4 t6)))))
+            ((Hi)
+                (with
+                    (t2 t4 t6)
+                    (and
+                        (= t2 (and (= (:C (:flags_in result)) #b1) (= (:Z (:flags_in result)) #b0)))
+                        (if t2 (= t4 rn) (= t6 (bvadd (bvnot rm) #x0000000000000001)))
+                        (= rd (if t2 t4 t6)))))
+            ((Vc)
+                (with
+                    (t1 t3 t5)
+                    (and
+                        (= t1 (not (= (:V (:flags_in result)) #b1)))
+                        (if t1 (= t3 rn) (= t5 (bvadd (bvnot rm) #x0000000000000001)))
+                        (= rd (if t1 t3 t5)))))
+            ((Vs)
+                (with
+                    (t1 t3 t5)
+                    (and
+                        (= t1 (= (:V (:flags_in result)) #b1))
+                        (if t1 (= t3 rn) (= t5 (bvadd (bvnot rm) #x0000000000000001)))
+                        (= rd (if t1 t3 t5)))))
+            ((Pl)
+                (with
+                    (t1 t3 t5)
+                    (and
+                        (= t1 (not (= (:N (:flags_in result)) #b1)))
+                        (if t1 (= t3 rn) (= t5 (bvadd (bvnot rm) #x0000000000000001)))
+                        (= rd (if t1 t3 t5)))))
+            ((Mi)
+                (with
+                    (t1 t3 t5)
+                    (and
+                        (= t1 (= (:N (:flags_in result)) #b1))
+                        (if t1 (= t3 rn) (= t5 (bvadd (bvnot rm) #x0000000000000001)))
+                        (= rd (if t1 t3 t5)))))
+            ((Lo)
+                (with
+                    (t1 t3 t5)
+                    (and
+                        (= t1 (not (= (:C (:flags_in result)) #b1)))
+                        (if t1 (= t3 rn) (= t5 (bvadd (bvnot rm) #x0000000000000001)))
+                        (= rd (if t1 t3 t5)))))
+            ((Hs)
+                (with
+                    (t1 t3 t5)
+                    (and
+                        (= t1 (= (:C (:flags_in result)) #b1))
+                        (if t1 (= t3 rn) (= t5 (bvadd (bvnot rm) #x0000000000000001)))
+                        (= rd (if t1 t3 t5)))))
+            ((Ne)
+                (with
+                    (t1 t3 t5)
+                    (and
+                        (= t1 (not (= (:Z (:flags_in result)) #b1)))
+                        (if t1 (= t3 rn) (= t5 (bvadd (bvnot rm) #x0000000000000001)))
+                        (= rd (if t1 t3 t5)))))
+            ((Eq)
+                (with
+                    (t1 t3 t5)
+                    (and
+                        (= t1 (= (:Z (:flags_in result)) #b1))
+                        (if t1 (= t3 rn) (= t5 (bvadd (bvnot rm) #x0000000000000001)))
+                        (= rd (if t1 t3 t5)))))))
+    (require
+        (match
+            cond
+            ((Le) true)
+            ((Gt) true)
+            ((Lt) true)
+            ((Ge) true)
+            ((Ls) true)
+            ((Hi) true)
+            ((Vc) true)
+            ((Vs) true)
+            ((Pl) true)
+            ((Mi) true)
+            ((Lo) true)
+            ((Hs) true)
+            ((Ne) true)
+            ((Eq) true))))
+
+(attr MInst.CSet (tag isaspec_generated))
+
+(spec
+    (MInst.CSet rd cond)
+    (provide
+        (match
+            cond
+            ((Le)
+                (with
+                    (t3 t4 t5)
+                    (and
+                        (= t3 (and (= (:N (:flags_in result)) (:V (:flags_in result))) (= (:Z (:flags_in result)) #b0)))
+                        (if t3 (= t4 #x0000000000000000) (= t5 #x0000000000000001))
+                        (= rd (if t3 t4 t5)))))
+            ((Gt)
+                (with
+                    (t3 t4 t5)
+                    (and
+                        (=
+                            t3
+                            (not
+                                (and
+                                    (= (:N (:flags_in result)) (:V (:flags_in result)))
+                                    (= (:Z (:flags_in result)) #b0))))
+                        (if t3 (= t4 #x0000000000000000) (= t5 #x0000000000000001))
+                        (= rd (if t3 t4 t5)))))
+            ((Lt)
+                (with
+                    (t2 t3 t4)
+                    (and
+                        (= t2 (= (:N (:flags_in result)) (:V (:flags_in result))))
+                        (if t2 (= t3 #x0000000000000000) (= t4 #x0000000000000001))
+                        (= rd (if t2 t3 t4)))))
+            ((Ge)
+                (with
+                    (t2 t3 t4)
+                    (and
+                        (= t2 (not (= (:N (:flags_in result)) (:V (:flags_in result)))))
+                        (if t2 (= t3 #x0000000000000000) (= t4 #x0000000000000001))
+                        (= rd (if t2 t3 t4)))))
+            ((Ls)
+                (with
+                    (t2 t3 t4)
+                    (and
+                        (= t2 (and (= (:C (:flags_in result)) #b1) (= (:Z (:flags_in result)) #b0)))
+                        (if t2 (= t3 #x0000000000000000) (= t4 #x0000000000000001))
+                        (= rd (if t2 t3 t4)))))
+            ((Hi)
+                (with
+                    (t2 t3 t4)
+                    (and
+                        (= t2 (not (and (= (:C (:flags_in result)) #b1) (= (:Z (:flags_in result)) #b0))))
+                        (if t2 (= t3 #x0000000000000000) (= t4 #x0000000000000001))
+                        (= rd (if t2 t3 t4)))))
+            ((Vc)
+                (with
+                    (t1 t2 t3)
+                    (and
+                        (= t1 (= (:V (:flags_in result)) #b1))
+                        (if t1 (= t2 #x0000000000000000) (= t3 #x0000000000000001))
+                        (= rd (if t1 t2 t3)))))
+            ((Vs)
+                (with
+                    (t1 t2 t3)
+                    (and
+                        (= t1 (not (= (:V (:flags_in result)) #b1)))
+                        (if t1 (= t2 #x0000000000000000) (= t3 #x0000000000000001))
+                        (= rd (if t1 t2 t3)))))
+            ((Pl)
+                (with
+                    (t1 t2 t3)
+                    (and
+                        (= t1 (= (:N (:flags_in result)) #b1))
+                        (if t1 (= t2 #x0000000000000000) (= t3 #x0000000000000001))
+                        (= rd (if t1 t2 t3)))))
+            ((Mi)
+                (with
+                    (t1 t2 t3)
+                    (and
+                        (= t1 (not (= (:N (:flags_in result)) #b1)))
+                        (if t1 (= t2 #x0000000000000000) (= t3 #x0000000000000001))
+                        (= rd (if t1 t2 t3)))))
+            ((Lo)
+                (with
+                    (t1 t2 t3)
+                    (and
+                        (= t1 (= (:C (:flags_in result)) #b1))
+                        (if t1 (= t2 #x0000000000000000) (= t3 #x0000000000000001))
+                        (= rd (if t1 t2 t3)))))
+            ((Hs)
+                (with
+                    (t1 t2 t3)
+                    (and
+                        (= t1 (not (= (:C (:flags_in result)) #b1)))
+                        (if t1 (= t2 #x0000000000000000) (= t3 #x0000000000000001))
+                        (= rd (if t1 t2 t3)))))
+            ((Ne)
+                (with
+                    (t1 t2 t3)
+                    (and
+                        (= t1 (= (:Z (:flags_in result)) #b1))
+                        (if t1 (= t2 #x0000000000000000) (= t3 #x0000000000000001))
+                        (= rd (if t1 t2 t3)))))
+            ((Eq)
+                (with
+                    (t1 t2 t3)
+                    (and
+                        (= t1 (not (= (:Z (:flags_in result)) #b1)))
+                        (if t1 (= t2 #x0000000000000000) (= t3 #x0000000000000001))
+                        (= rd (if t1 t2 t3)))))))
+    (require
+        (match
+            cond
+            ((Le) true)
+            ((Gt) true)
+            ((Lt) true)
+            ((Ge) true)
+            ((Ls) true)
+            ((Hi) true)
+            ((Vc) true)
+            ((Vs) true)
+            ((Pl) true)
+            ((Mi) true)
+            ((Lo) true)
+            ((Hs) true)
+            ((Ne) true)
+            ((Eq) true))))
+
+(attr MInst.CSetm (tag isaspec_generated))
+
+(spec
+    (MInst.CSetm rd cond)
+    (provide
+        (match
+            cond
+            ((Le)
+                (with
+                    (t3 t4 t5)
+                    (and
+                        (= t3 (and (= (:N (:flags_in result)) (:V (:flags_in result))) (= (:Z (:flags_in result)) #b0)))
+                        (if t3 (= t4 #x0000000000000000) (= t5 #xffffffffffffffff))
+                        (= rd (if t3 t4 t5)))))
+            ((Gt)
+                (with
+                    (t3 t4 t5)
+                    (and
+                        (=
+                            t3
+                            (not
+                                (and
+                                    (= (:N (:flags_in result)) (:V (:flags_in result)))
+                                    (= (:Z (:flags_in result)) #b0))))
+                        (if t3 (= t4 #x0000000000000000) (= t5 #xffffffffffffffff))
+                        (= rd (if t3 t4 t5)))))
+            ((Lt)
+                (with
+                    (t2 t3 t4)
+                    (and
+                        (= t2 (= (:N (:flags_in result)) (:V (:flags_in result))))
+                        (if t2 (= t3 #x0000000000000000) (= t4 #xffffffffffffffff))
+                        (= rd (if t2 t3 t4)))))
+            ((Ge)
+                (with
+                    (t2 t3 t4)
+                    (and
+                        (= t2 (not (= (:N (:flags_in result)) (:V (:flags_in result)))))
+                        (if t2 (= t3 #x0000000000000000) (= t4 #xffffffffffffffff))
+                        (= rd (if t2 t3 t4)))))
+            ((Ls)
+                (with
+                    (t2 t3 t4)
+                    (and
+                        (= t2 (and (= (:C (:flags_in result)) #b1) (= (:Z (:flags_in result)) #b0)))
+                        (if t2 (= t3 #x0000000000000000) (= t4 #xffffffffffffffff))
+                        (= rd (if t2 t3 t4)))))
+            ((Hi)
+                (with
+                    (t2 t3 t4)
+                    (and
+                        (= t2 (not (and (= (:C (:flags_in result)) #b1) (= (:Z (:flags_in result)) #b0))))
+                        (if t2 (= t3 #x0000000000000000) (= t4 #xffffffffffffffff))
+                        (= rd (if t2 t3 t4)))))
+            ((Vc)
+                (with
+                    (t1 t2 t3)
+                    (and
+                        (= t1 (= (:V (:flags_in result)) #b1))
+                        (if t1 (= t2 #x0000000000000000) (= t3 #xffffffffffffffff))
+                        (= rd (if t1 t2 t3)))))
+            ((Vs)
+                (with
+                    (t1 t2 t3)
+                    (and
+                        (= t1 (not (= (:V (:flags_in result)) #b1)))
+                        (if t1 (= t2 #x0000000000000000) (= t3 #xffffffffffffffff))
+                        (= rd (if t1 t2 t3)))))
+            ((Pl)
+                (with
+                    (t1 t2 t3)
+                    (and
+                        (= t1 (= (:N (:flags_in result)) #b1))
+                        (if t1 (= t2 #x0000000000000000) (= t3 #xffffffffffffffff))
+                        (= rd (if t1 t2 t3)))))
+            ((Mi)
+                (with
+                    (t1 t2 t3)
+                    (and
+                        (= t1 (not (= (:N (:flags_in result)) #b1)))
+                        (if t1 (= t2 #x0000000000000000) (= t3 #xffffffffffffffff))
+                        (= rd (if t1 t2 t3)))))
+            ((Lo)
+                (with
+                    (t1 t2 t3)
+                    (and
+                        (= t1 (= (:C (:flags_in result)) #b1))
+                        (if t1 (= t2 #x0000000000000000) (= t3 #xffffffffffffffff))
+                        (= rd (if t1 t2 t3)))))
+            ((Hs)
+                (with
+                    (t1 t2 t3)
+                    (and
+                        (= t1 (not (= (:C (:flags_in result)) #b1)))
+                        (if t1 (= t2 #x0000000000000000) (= t3 #xffffffffffffffff))
+                        (= rd (if t1 t2 t3)))))
+            ((Ne)
+                (with
+                    (t1 t2 t3)
+                    (and
+                        (= t1 (= (:Z (:flags_in result)) #b1))
+                        (if t1 (= t2 #x0000000000000000) (= t3 #xffffffffffffffff))
+                        (= rd (if t1 t2 t3)))))
+            ((Eq)
+                (with
+                    (t1 t2 t3)
+                    (and
+                        (= t1 (not (= (:Z (:flags_in result)) #b1)))
+                        (if t1 (= t2 #x0000000000000000) (= t3 #xffffffffffffffff))
+                        (= rd (if t1 t2 t3)))))))
+    (require
+        (match
+            cond
+            ((Le) true)
+            ((Gt) true)
+            ((Lt) true)
+            ((Ge) true)
+            ((Ls) true)
+            ((Hi) true)
+            ((Vc) true)
+            ((Vs) true)
+            ((Pl) true)
+            ((Mi) true)
+            ((Lo) true)
+            ((Hs) true)
+            ((Ne) true)
+            ((Eq) true))))
+
+(attr MInst.CCmp (tag isaspec_generated))
+
+(spec
+    (MInst.CCmp size rn rm nzcv cond)
+    (provide
+        (match
+            size
+            ((Size64)
+                (match
+                    cond
+                    ((Le)
+                        (with
+                            (t1 t10 t11 t13 t15 t17 t19 t3 t7 t8 t9)
+                            (and
+                                (= t1 (bvnot rm))
+                                (= t3 (bvadd rn (bvnot rm)))
+                                (=
+                                    t7
+                                    (not
+                                        (and
+                                            (= (:N (:flags_in result)) (:V (:flags_in result)))
+                                            (= (:Z (:flags_in result)) #b0))))
+                                (if
+                                    t7
+                                    (and
+                                        (=
+                                            t8
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t9
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t10 (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= t11 (extract 63 63 (bvadd t3 #x0000000000000001))))
+                                    (and
+                                        (= t13 (extract 0 0 (:V nzcv)))
+                                        (= t15 (extract 0 0 (:C nzcv)))
+                                        (= t17 (extract 0 0 (:Z nzcv)))
+                                        (= t19 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t7 t9 t15))
+                                (= (:N (:flags_out result)) (if t7 t11 t19))
+                                (= (:V (:flags_out result)) (if t7 t8 t13))
+                                (= (:Z (:flags_out result)) (if t7 t10 t17)))))
+                    ((Gt)
+                        (with
+                            (t1 t10 t11 t13 t15 t17 t19 t3 t7 t8 t9)
+                            (and
+                                (= t1 (bvnot rm))
+                                (= t3 (bvadd rn (bvnot rm)))
+                                (=
+                                    t7
+                                    (and
+                                        (= (:N (:flags_in result)) (:V (:flags_in result)))
+                                        (= (:Z (:flags_in result)) #b0)))
+                                (if
+                                    t7
+                                    (and
+                                        (=
+                                            t8
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t9
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t10 (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= t11 (extract 63 63 (bvadd t3 #x0000000000000001))))
+                                    (and
+                                        (= t13 (extract 0 0 (:V nzcv)))
+                                        (= t15 (extract 0 0 (:C nzcv)))
+                                        (= t17 (extract 0 0 (:Z nzcv)))
+                                        (= t19 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t7 t9 t15))
+                                (= (:N (:flags_out result)) (if t7 t11 t19))
+                                (= (:V (:flags_out result)) (if t7 t8 t13))
+                                (= (:Z (:flags_out result)) (if t7 t10 t17)))))
+                    ((Lt)
+                        (with
+                            (t1 t10 t12 t14 t16 t18 t3 t6 t7 t8 t9)
+                            (and
+                                (= t1 (bvnot rm))
+                                (= t3 (bvadd rn (bvnot rm)))
+                                (= t6 (not (= (:N (:flags_in result)) (:V (:flags_in result)))))
+                                (if
+                                    t6
+                                    (and
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t8
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t9 (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= t10 (extract 63 63 (bvadd t3 #x0000000000000001))))
+                                    (and
+                                        (= t12 (extract 0 0 (:V nzcv)))
+                                        (= t14 (extract 0 0 (:C nzcv)))
+                                        (= t16 (extract 0 0 (:Z nzcv)))
+                                        (= t18 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t6 t8 t14))
+                                (= (:N (:flags_out result)) (if t6 t10 t18))
+                                (= (:V (:flags_out result)) (if t6 t7 t12))
+                                (= (:Z (:flags_out result)) (if t6 t9 t16)))))
+                    ((Ge)
+                        (with
+                            (t1 t10 t12 t14 t16 t18 t3 t6 t7 t8 t9)
+                            (and
+                                (= t1 (bvnot rm))
+                                (= t3 (bvadd rn (bvnot rm)))
+                                (= t6 (= (:N (:flags_in result)) (:V (:flags_in result))))
+                                (if
+                                    t6
+                                    (and
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t8
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t9 (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= t10 (extract 63 63 (bvadd t3 #x0000000000000001))))
+                                    (and
+                                        (= t12 (extract 0 0 (:V nzcv)))
+                                        (= t14 (extract 0 0 (:C nzcv)))
+                                        (= t16 (extract 0 0 (:Z nzcv)))
+                                        (= t18 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t6 t8 t14))
+                                (= (:N (:flags_out result)) (if t6 t10 t18))
+                                (= (:V (:flags_out result)) (if t6 t7 t12))
+                                (= (:Z (:flags_out result)) (if t6 t9 t16)))))
+                    ((Ls)
+                        (with
+                            (t1 t10 t12 t14 t16 t18 t3 t6 t7 t8 t9)
+                            (and
+                                (= t1 (bvnot rm))
+                                (= t3 (bvadd rn (bvnot rm)))
+                                (= t6 (not (and (= (:C (:flags_in result)) #b1) (= (:Z (:flags_in result)) #b0))))
+                                (if
+                                    t6
+                                    (and
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t8
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t9 (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= t10 (extract 63 63 (bvadd t3 #x0000000000000001))))
+                                    (and
+                                        (= t12 (extract 0 0 (:V nzcv)))
+                                        (= t14 (extract 0 0 (:C nzcv)))
+                                        (= t16 (extract 0 0 (:Z nzcv)))
+                                        (= t18 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t6 t8 t14))
+                                (= (:N (:flags_out result)) (if t6 t10 t18))
+                                (= (:V (:flags_out result)) (if t6 t7 t12))
+                                (= (:Z (:flags_out result)) (if t6 t9 t16)))))
+                    ((Hi)
+                        (with
+                            (t1 t10 t12 t14 t16 t18 t3 t6 t7 t8 t9)
+                            (and
+                                (= t1 (bvnot rm))
+                                (= t3 (bvadd rn (bvnot rm)))
+                                (= t6 (and (= (:C (:flags_in result)) #b1) (= (:Z (:flags_in result)) #b0)))
+                                (if
+                                    t6
+                                    (and
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t8
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t9 (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= t10 (extract 63 63 (bvadd t3 #x0000000000000001))))
+                                    (and
+                                        (= t12 (extract 0 0 (:V nzcv)))
+                                        (= t14 (extract 0 0 (:C nzcv)))
+                                        (= t16 (extract 0 0 (:Z nzcv)))
+                                        (= t18 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t6 t8 t14))
+                                (= (:N (:flags_out result)) (if t6 t10 t18))
+                                (= (:V (:flags_out result)) (if t6 t7 t12))
+                                (= (:Z (:flags_out result)) (if t6 t9 t16)))))
+                    ((Vc)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (bvnot rm))
+                                (= t3 (bvadd rn (bvnot rm)))
+                                (= t5 (not (= (:V (:flags_in result)) #b1)))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= t9 (extract 63 63 (bvadd t3 #x0000000000000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))
+                    ((Vs)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (bvnot rm))
+                                (= t3 (bvadd rn (bvnot rm)))
+                                (= t5 (= (:V (:flags_in result)) #b1))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= t9 (extract 63 63 (bvadd t3 #x0000000000000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))
+                    ((Pl)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (bvnot rm))
+                                (= t3 (bvadd rn (bvnot rm)))
+                                (= t5 (not (= (:N (:flags_in result)) #b1)))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= t9 (extract 63 63 (bvadd t3 #x0000000000000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))
+                    ((Mi)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (bvnot rm))
+                                (= t3 (bvadd rn (bvnot rm)))
+                                (= t5 (= (:N (:flags_in result)) #b1))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= t9 (extract 63 63 (bvadd t3 #x0000000000000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))
+                    ((Lo)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (bvnot rm))
+                                (= t3 (bvadd rn (bvnot rm)))
+                                (= t5 (not (= (:C (:flags_in result)) #b1)))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= t9 (extract 63 63 (bvadd t3 #x0000000000000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))
+                    ((Hs)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (bvnot rm))
+                                (= t3 (bvadd rn (bvnot rm)))
+                                (= t5 (= (:C (:flags_in result)) #b1))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= t9 (extract 63 63 (bvadd t3 #x0000000000000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))
+                    ((Ne)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (bvnot rm))
+                                (= t3 (bvadd rn (bvnot rm)))
+                                (= t5 (not (= (:Z (:flags_in result)) #b1)))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= t9 (extract 63 63 (bvadd t3 #x0000000000000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))
+                    ((Eq)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (bvnot rm))
+                                (= t3 (bvadd rn (bvnot rm)))
+                                (= t5 (= (:Z (:flags_in result)) #b1))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 t1))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= t9 (extract 63 63 (bvadd t3 #x0000000000000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))))
+            ((Size32)
+                (match
+                    cond
+                    ((Le)
+                        (with
+                            (t1 t10 t11 t13 t15 t17 t19 t3 t7 t8 t9)
+                            (and
+                                (= t1 (bvnot (extract 31 0 rm)))
+                                (= t3 (bvadd (extract 31 0 rn) (bvnot (extract 31 0 rm))))
+                                (=
+                                    t7
+                                    (not
+                                        (and
+                                            (= (:N (:flags_in result)) (:V (:flags_in result)))
+                                            (= (:Z (:flags_in result)) #b0))))
+                                (if
+                                    t7
+                                    (and
+                                        (=
+                                            t8
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 64 (extract 31 0 rn)) (sign_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t9
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 64 (extract 31 0 rn)) (zero_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t10 (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= t11 (extract 31 31 (bvadd t3 #x00000001))))
+                                    (and
+                                        (= t13 (extract 0 0 (:V nzcv)))
+                                        (= t15 (extract 0 0 (:C nzcv)))
+                                        (= t17 (extract 0 0 (:Z nzcv)))
+                                        (= t19 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t7 t9 t15))
+                                (= (:N (:flags_out result)) (if t7 t11 t19))
+                                (= (:V (:flags_out result)) (if t7 t8 t13))
+                                (= (:Z (:flags_out result)) (if t7 t10 t17)))))
+                    ((Gt)
+                        (with
+                            (t1 t10 t11 t13 t15 t17 t19 t3 t7 t8 t9)
+                            (and
+                                (= t1 (bvnot (extract 31 0 rm)))
+                                (= t3 (bvadd (extract 31 0 rn) (bvnot (extract 31 0 rm))))
+                                (=
+                                    t7
+                                    (and
+                                        (= (:N (:flags_in result)) (:V (:flags_in result)))
+                                        (= (:Z (:flags_in result)) #b0)))
+                                (if
+                                    t7
+                                    (and
+                                        (=
+                                            t8
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 64 (extract 31 0 rn)) (sign_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t9
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 64 (extract 31 0 rn)) (zero_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t10 (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= t11 (extract 31 31 (bvadd t3 #x00000001))))
+                                    (and
+                                        (= t13 (extract 0 0 (:V nzcv)))
+                                        (= t15 (extract 0 0 (:C nzcv)))
+                                        (= t17 (extract 0 0 (:Z nzcv)))
+                                        (= t19 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t7 t9 t15))
+                                (= (:N (:flags_out result)) (if t7 t11 t19))
+                                (= (:V (:flags_out result)) (if t7 t8 t13))
+                                (= (:Z (:flags_out result)) (if t7 t10 t17)))))
+                    ((Lt)
+                        (with
+                            (t1 t10 t12 t14 t16 t18 t3 t6 t7 t8 t9)
+                            (and
+                                (= t1 (bvnot (extract 31 0 rm)))
+                                (= t3 (bvadd (extract 31 0 rn) (bvnot (extract 31 0 rm))))
+                                (= t6 (not (= (:N (:flags_in result)) (:V (:flags_in result)))))
+                                (if
+                                    t6
+                                    (and
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 64 (extract 31 0 rn)) (sign_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t8
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 64 (extract 31 0 rn)) (zero_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t9 (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= t10 (extract 31 31 (bvadd t3 #x00000001))))
+                                    (and
+                                        (= t12 (extract 0 0 (:V nzcv)))
+                                        (= t14 (extract 0 0 (:C nzcv)))
+                                        (= t16 (extract 0 0 (:Z nzcv)))
+                                        (= t18 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t6 t8 t14))
+                                (= (:N (:flags_out result)) (if t6 t10 t18))
+                                (= (:V (:flags_out result)) (if t6 t7 t12))
+                                (= (:Z (:flags_out result)) (if t6 t9 t16)))))
+                    ((Ge)
+                        (with
+                            (t1 t10 t12 t14 t16 t18 t3 t6 t7 t8 t9)
+                            (and
+                                (= t1 (bvnot (extract 31 0 rm)))
+                                (= t3 (bvadd (extract 31 0 rn) (bvnot (extract 31 0 rm))))
+                                (= t6 (= (:N (:flags_in result)) (:V (:flags_in result))))
+                                (if
+                                    t6
+                                    (and
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 64 (extract 31 0 rn)) (sign_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t8
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 64 (extract 31 0 rn)) (zero_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t9 (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= t10 (extract 31 31 (bvadd t3 #x00000001))))
+                                    (and
+                                        (= t12 (extract 0 0 (:V nzcv)))
+                                        (= t14 (extract 0 0 (:C nzcv)))
+                                        (= t16 (extract 0 0 (:Z nzcv)))
+                                        (= t18 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t6 t8 t14))
+                                (= (:N (:flags_out result)) (if t6 t10 t18))
+                                (= (:V (:flags_out result)) (if t6 t7 t12))
+                                (= (:Z (:flags_out result)) (if t6 t9 t16)))))
+                    ((Ls)
+                        (with
+                            (t1 t10 t12 t14 t16 t18 t3 t6 t7 t8 t9)
+                            (and
+                                (= t1 (bvnot (extract 31 0 rm)))
+                                (= t3 (bvadd (extract 31 0 rn) (bvnot (extract 31 0 rm))))
+                                (= t6 (not (and (= (:C (:flags_in result)) #b1) (= (:Z (:flags_in result)) #b0))))
+                                (if
+                                    t6
+                                    (and
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 64 (extract 31 0 rn)) (sign_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t8
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 64 (extract 31 0 rn)) (zero_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t9 (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= t10 (extract 31 31 (bvadd t3 #x00000001))))
+                                    (and
+                                        (= t12 (extract 0 0 (:V nzcv)))
+                                        (= t14 (extract 0 0 (:C nzcv)))
+                                        (= t16 (extract 0 0 (:Z nzcv)))
+                                        (= t18 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t6 t8 t14))
+                                (= (:N (:flags_out result)) (if t6 t10 t18))
+                                (= (:V (:flags_out result)) (if t6 t7 t12))
+                                (= (:Z (:flags_out result)) (if t6 t9 t16)))))
+                    ((Hi)
+                        (with
+                            (t1 t10 t12 t14 t16 t18 t3 t6 t7 t8 t9)
+                            (and
+                                (= t1 (bvnot (extract 31 0 rm)))
+                                (= t3 (bvadd (extract 31 0 rn) (bvnot (extract 31 0 rm))))
+                                (= t6 (and (= (:C (:flags_in result)) #b1) (= (:Z (:flags_in result)) #b0)))
+                                (if
+                                    t6
+                                    (and
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 64 (extract 31 0 rn)) (sign_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t8
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 64 (extract 31 0 rn)) (zero_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t9 (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= t10 (extract 31 31 (bvadd t3 #x00000001))))
+                                    (and
+                                        (= t12 (extract 0 0 (:V nzcv)))
+                                        (= t14 (extract 0 0 (:C nzcv)))
+                                        (= t16 (extract 0 0 (:Z nzcv)))
+                                        (= t18 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t6 t8 t14))
+                                (= (:N (:flags_out result)) (if t6 t10 t18))
+                                (= (:V (:flags_out result)) (if t6 t7 t12))
+                                (= (:Z (:flags_out result)) (if t6 t9 t16)))))
+                    ((Vc)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (bvnot (extract 31 0 rm)))
+                                (= t3 (bvadd (extract 31 0 rn) (bvnot (extract 31 0 rm))))
+                                (= t5 (not (= (:V (:flags_in result)) #b1)))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 64 (extract 31 0 rn)) (sign_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 64 (extract 31 0 rn)) (zero_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= t9 (extract 31 31 (bvadd t3 #x00000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))
+                    ((Vs)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (bvnot (extract 31 0 rm)))
+                                (= t3 (bvadd (extract 31 0 rn) (bvnot (extract 31 0 rm))))
+                                (= t5 (= (:V (:flags_in result)) #b1))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 64 (extract 31 0 rn)) (sign_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 64 (extract 31 0 rn)) (zero_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= t9 (extract 31 31 (bvadd t3 #x00000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))
+                    ((Pl)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (bvnot (extract 31 0 rm)))
+                                (= t3 (bvadd (extract 31 0 rn) (bvnot (extract 31 0 rm))))
+                                (= t5 (not (= (:N (:flags_in result)) #b1)))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 64 (extract 31 0 rn)) (sign_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 64 (extract 31 0 rn)) (zero_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= t9 (extract 31 31 (bvadd t3 #x00000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))
+                    ((Mi)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (bvnot (extract 31 0 rm)))
+                                (= t3 (bvadd (extract 31 0 rn) (bvnot (extract 31 0 rm))))
+                                (= t5 (= (:N (:flags_in result)) #b1))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 64 (extract 31 0 rn)) (sign_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 64 (extract 31 0 rn)) (zero_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= t9 (extract 31 31 (bvadd t3 #x00000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))
+                    ((Lo)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (bvnot (extract 31 0 rm)))
+                                (= t3 (bvadd (extract 31 0 rn) (bvnot (extract 31 0 rm))))
+                                (= t5 (not (= (:C (:flags_in result)) #b1)))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 64 (extract 31 0 rn)) (sign_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 64 (extract 31 0 rn)) (zero_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= t9 (extract 31 31 (bvadd t3 #x00000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))
+                    ((Hs)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (bvnot (extract 31 0 rm)))
+                                (= t3 (bvadd (extract 31 0 rn) (bvnot (extract 31 0 rm))))
+                                (= t5 (= (:C (:flags_in result)) #b1))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 64 (extract 31 0 rn)) (sign_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 64 (extract 31 0 rn)) (zero_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= t9 (extract 31 31 (bvadd t3 #x00000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))
+                    ((Ne)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (bvnot (extract 31 0 rm)))
+                                (= t3 (bvadd (extract 31 0 rn) (bvnot (extract 31 0 rm))))
+                                (= t5 (not (= (:Z (:flags_in result)) #b1)))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 64 (extract 31 0 rn)) (sign_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 64 (extract 31 0 rn)) (zero_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= t9 (extract 31 31 (bvadd t3 #x00000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))
+                    ((Eq)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (bvnot (extract 31 0 rm)))
+                                (= t3 (bvadd (extract 31 0 rn) (bvnot (extract 31 0 rm))))
+                                (= t5 (= (:Z (:flags_in result)) #b1))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 64 (extract 31 0 rn)) (sign_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 64 (extract 31 0 rn)) (zero_ext 64 t1))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= t9 (extract 31 31 (bvadd t3 #x00000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))))))
+    (require
+        (match
+            size
+            ((Size64)
+                (match
+                    cond
+                    ((Le) true)
+                    ((Gt) true)
+                    ((Lt) true)
+                    ((Ge) true)
+                    ((Ls) true)
+                    ((Hi) true)
+                    ((Vc) true)
+                    ((Vs) true)
+                    ((Pl) true)
+                    ((Mi) true)
+                    ((Lo) true)
+                    ((Hs) true)
+                    ((Ne) true)
+                    ((Eq) true)))
+            ((Size32)
+                (match
+                    cond
+                    ((Le) true)
+                    ((Gt) true)
+                    ((Lt) true)
+                    ((Ge) true)
+                    ((Ls) true)
+                    ((Hi) true)
+                    ((Vc) true)
+                    ((Vs) true)
+                    ((Pl) true)
+                    ((Mi) true)
+                    ((Lo) true)
+                    ((Hs) true)
+                    ((Ne) true)
+                    ((Eq) true))))))
+
+(attr MInst.CCmpImm (tag isaspec_generated))
+
+(spec
+    (MInst.CCmpImm size rn imm nzcv cond)
+    (provide
+        (match
+            size
+            ((Size64)
+                (match
+                    cond
+                    ((Le)
+                        (with
+                            (t1 t10 t11 t13 t15 t17 t19 t3 t7 t8 t9)
+                            (and
+                                (= t1 (zero_ext 64 (extract 4 0 imm)))
+                                (= t3 (bvadd rn (bvnot (zero_ext 64 (extract 4 0 imm)))))
+                                (=
+                                    t7
+                                    (not
+                                        (and
+                                            (= (:N (:flags_in result)) (:V (:flags_in result)))
+                                            (= (:Z (:flags_in result)) #b0))))
+                                (if
+                                    t7
+                                    (and
+                                        (=
+                                            t8
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t9
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t10 (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= t11 (extract 63 63 (bvadd t3 #x0000000000000001))))
+                                    (and
+                                        (= t13 (extract 0 0 (:V nzcv)))
+                                        (= t15 (extract 0 0 (:C nzcv)))
+                                        (= t17 (extract 0 0 (:Z nzcv)))
+                                        (= t19 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t7 t9 t15))
+                                (= (:N (:flags_out result)) (if t7 t11 t19))
+                                (= (:V (:flags_out result)) (if t7 t8 t13))
+                                (= (:Z (:flags_out result)) (if t7 t10 t17)))))
+                    ((Gt)
+                        (with
+                            (t1 t10 t11 t13 t15 t17 t19 t3 t7 t8 t9)
+                            (and
+                                (= t1 (zero_ext 64 (extract 4 0 imm)))
+                                (= t3 (bvadd rn (bvnot (zero_ext 64 (extract 4 0 imm)))))
+                                (=
+                                    t7
+                                    (and
+                                        (= (:N (:flags_in result)) (:V (:flags_in result)))
+                                        (= (:Z (:flags_in result)) #b0)))
+                                (if
+                                    t7
+                                    (and
+                                        (=
+                                            t8
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t9
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t10 (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= t11 (extract 63 63 (bvadd t3 #x0000000000000001))))
+                                    (and
+                                        (= t13 (extract 0 0 (:V nzcv)))
+                                        (= t15 (extract 0 0 (:C nzcv)))
+                                        (= t17 (extract 0 0 (:Z nzcv)))
+                                        (= t19 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t7 t9 t15))
+                                (= (:N (:flags_out result)) (if t7 t11 t19))
+                                (= (:V (:flags_out result)) (if t7 t8 t13))
+                                (= (:Z (:flags_out result)) (if t7 t10 t17)))))
+                    ((Lt)
+                        (with
+                            (t1 t10 t12 t14 t16 t18 t3 t6 t7 t8 t9)
+                            (and
+                                (= t1 (zero_ext 64 (extract 4 0 imm)))
+                                (= t3 (bvadd rn (bvnot (zero_ext 64 (extract 4 0 imm)))))
+                                (= t6 (not (= (:N (:flags_in result)) (:V (:flags_in result)))))
+                                (if
+                                    t6
+                                    (and
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t8
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t9 (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= t10 (extract 63 63 (bvadd t3 #x0000000000000001))))
+                                    (and
+                                        (= t12 (extract 0 0 (:V nzcv)))
+                                        (= t14 (extract 0 0 (:C nzcv)))
+                                        (= t16 (extract 0 0 (:Z nzcv)))
+                                        (= t18 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t6 t8 t14))
+                                (= (:N (:flags_out result)) (if t6 t10 t18))
+                                (= (:V (:flags_out result)) (if t6 t7 t12))
+                                (= (:Z (:flags_out result)) (if t6 t9 t16)))))
+                    ((Ge)
+                        (with
+                            (t1 t10 t12 t14 t16 t18 t3 t6 t7 t8 t9)
+                            (and
+                                (= t1 (zero_ext 64 (extract 4 0 imm)))
+                                (= t3 (bvadd rn (bvnot (zero_ext 64 (extract 4 0 imm)))))
+                                (= t6 (= (:N (:flags_in result)) (:V (:flags_in result))))
+                                (if
+                                    t6
+                                    (and
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t8
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t9 (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= t10 (extract 63 63 (bvadd t3 #x0000000000000001))))
+                                    (and
+                                        (= t12 (extract 0 0 (:V nzcv)))
+                                        (= t14 (extract 0 0 (:C nzcv)))
+                                        (= t16 (extract 0 0 (:Z nzcv)))
+                                        (= t18 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t6 t8 t14))
+                                (= (:N (:flags_out result)) (if t6 t10 t18))
+                                (= (:V (:flags_out result)) (if t6 t7 t12))
+                                (= (:Z (:flags_out result)) (if t6 t9 t16)))))
+                    ((Ls)
+                        (with
+                            (t1 t10 t12 t14 t16 t18 t3 t6 t7 t8 t9)
+                            (and
+                                (= t1 (zero_ext 64 (extract 4 0 imm)))
+                                (= t3 (bvadd rn (bvnot (zero_ext 64 (extract 4 0 imm)))))
+                                (= t6 (not (and (= (:C (:flags_in result)) #b1) (= (:Z (:flags_in result)) #b0))))
+                                (if
+                                    t6
+                                    (and
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t8
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t9 (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= t10 (extract 63 63 (bvadd t3 #x0000000000000001))))
+                                    (and
+                                        (= t12 (extract 0 0 (:V nzcv)))
+                                        (= t14 (extract 0 0 (:C nzcv)))
+                                        (= t16 (extract 0 0 (:Z nzcv)))
+                                        (= t18 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t6 t8 t14))
+                                (= (:N (:flags_out result)) (if t6 t10 t18))
+                                (= (:V (:flags_out result)) (if t6 t7 t12))
+                                (= (:Z (:flags_out result)) (if t6 t9 t16)))))
+                    ((Hi)
+                        (with
+                            (t1 t10 t12 t14 t16 t18 t3 t6 t7 t8 t9)
+                            (and
+                                (= t1 (zero_ext 64 (extract 4 0 imm)))
+                                (= t3 (bvadd rn (bvnot (zero_ext 64 (extract 4 0 imm)))))
+                                (= t6 (and (= (:C (:flags_in result)) #b1) (= (:Z (:flags_in result)) #b0)))
+                                (if
+                                    t6
+                                    (and
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t8
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t9 (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= t10 (extract 63 63 (bvadd t3 #x0000000000000001))))
+                                    (and
+                                        (= t12 (extract 0 0 (:V nzcv)))
+                                        (= t14 (extract 0 0 (:C nzcv)))
+                                        (= t16 (extract 0 0 (:Z nzcv)))
+                                        (= t18 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t6 t8 t14))
+                                (= (:N (:flags_out result)) (if t6 t10 t18))
+                                (= (:V (:flags_out result)) (if t6 t7 t12))
+                                (= (:Z (:flags_out result)) (if t6 t9 t16)))))
+                    ((Vc)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (zero_ext 64 (extract 4 0 imm)))
+                                (= t3 (bvadd rn (bvnot (zero_ext 64 (extract 4 0 imm)))))
+                                (= t5 (not (= (:V (:flags_in result)) #b1)))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= t9 (extract 63 63 (bvadd t3 #x0000000000000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))
+                    ((Vs)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (zero_ext 64 (extract 4 0 imm)))
+                                (= t3 (bvadd rn (bvnot (zero_ext 64 (extract 4 0 imm)))))
+                                (= t5 (= (:V (:flags_in result)) #b1))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= t9 (extract 63 63 (bvadd t3 #x0000000000000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))
+                    ((Pl)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (zero_ext 64 (extract 4 0 imm)))
+                                (= t3 (bvadd rn (bvnot (zero_ext 64 (extract 4 0 imm)))))
+                                (= t5 (not (= (:N (:flags_in result)) #b1)))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= t9 (extract 63 63 (bvadd t3 #x0000000000000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))
+                    ((Mi)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (zero_ext 64 (extract 4 0 imm)))
+                                (= t3 (bvadd rn (bvnot (zero_ext 64 (extract 4 0 imm)))))
+                                (= t5 (= (:N (:flags_in result)) #b1))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= t9 (extract 63 63 (bvadd t3 #x0000000000000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))
+                    ((Lo)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (zero_ext 64 (extract 4 0 imm)))
+                                (= t3 (bvadd rn (bvnot (zero_ext 64 (extract 4 0 imm)))))
+                                (= t5 (not (= (:C (:flags_in result)) #b1)))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= t9 (extract 63 63 (bvadd t3 #x0000000000000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))
+                    ((Hs)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (zero_ext 64 (extract 4 0 imm)))
+                                (= t3 (bvadd rn (bvnot (zero_ext 64 (extract 4 0 imm)))))
+                                (= t5 (= (:C (:flags_in result)) #b1))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= t9 (extract 63 63 (bvadd t3 #x0000000000000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))
+                    ((Ne)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (zero_ext 64 (extract 4 0 imm)))
+                                (= t3 (bvadd rn (bvnot (zero_ext 64 (extract 4 0 imm)))))
+                                (= t5 (not (= (:Z (:flags_in result)) #b1)))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= t9 (extract 63 63 (bvadd t3 #x0000000000000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))
+                    ((Eq)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (zero_ext 64 (extract 4 0 imm)))
+                                (= t3 (bvadd rn (bvnot (zero_ext 64 (extract 4 0 imm)))))
+                                (= t5 (= (:Z (:flags_in result)) #b1))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (sign_ext 128 rn) (sign_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 128 (bvadd t3 #x0000000000000001))
+                                                        (bvadd
+                                                            (bvadd (zero_ext 128 rn) (zero_ext 128 (bvnot t1)))
+                                                            #x00000000000000000000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x0000000000000001) #x0000000000000000) #b1 #b0))
+                                        (= t9 (extract 63 63 (bvadd t3 #x0000000000000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))))
+            ((Size32)
+                (match
+                    cond
+                    ((Le)
+                        (with
+                            (t1 t10 t11 t13 t15 t17 t19 t3 t7 t8 t9)
+                            (and
+                                (= t1 (zero_ext 32 (extract 4 0 imm)))
+                                (= t3 (bvadd (extract 31 0 rn) (bvnot (zero_ext 32 (extract 4 0 imm)))))
+                                (=
+                                    t7
+                                    (not
+                                        (and
+                                            (= (:N (:flags_in result)) (:V (:flags_in result)))
+                                            (= (:Z (:flags_in result)) #b0))))
+                                (if
+                                    t7
+                                    (and
+                                        (=
+                                            t8
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (sign_ext 64 (extract 31 0 rn))
+                                                                (sign_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t9
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (zero_ext 64 (extract 31 0 rn))
+                                                                (zero_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t10 (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= t11 (extract 31 31 (bvadd t3 #x00000001))))
+                                    (and
+                                        (= t13 (extract 0 0 (:V nzcv)))
+                                        (= t15 (extract 0 0 (:C nzcv)))
+                                        (= t17 (extract 0 0 (:Z nzcv)))
+                                        (= t19 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t7 t9 t15))
+                                (= (:N (:flags_out result)) (if t7 t11 t19))
+                                (= (:V (:flags_out result)) (if t7 t8 t13))
+                                (= (:Z (:flags_out result)) (if t7 t10 t17)))))
+                    ((Gt)
+                        (with
+                            (t1 t10 t11 t13 t15 t17 t19 t3 t7 t8 t9)
+                            (and
+                                (= t1 (zero_ext 32 (extract 4 0 imm)))
+                                (= t3 (bvadd (extract 31 0 rn) (bvnot (zero_ext 32 (extract 4 0 imm)))))
+                                (=
+                                    t7
+                                    (and
+                                        (= (:N (:flags_in result)) (:V (:flags_in result)))
+                                        (= (:Z (:flags_in result)) #b0)))
+                                (if
+                                    t7
+                                    (and
+                                        (=
+                                            t8
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (sign_ext 64 (extract 31 0 rn))
+                                                                (sign_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t9
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (zero_ext 64 (extract 31 0 rn))
+                                                                (zero_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t10 (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= t11 (extract 31 31 (bvadd t3 #x00000001))))
+                                    (and
+                                        (= t13 (extract 0 0 (:V nzcv)))
+                                        (= t15 (extract 0 0 (:C nzcv)))
+                                        (= t17 (extract 0 0 (:Z nzcv)))
+                                        (= t19 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t7 t9 t15))
+                                (= (:N (:flags_out result)) (if t7 t11 t19))
+                                (= (:V (:flags_out result)) (if t7 t8 t13))
+                                (= (:Z (:flags_out result)) (if t7 t10 t17)))))
+                    ((Lt)
+                        (with
+                            (t1 t10 t12 t14 t16 t18 t3 t6 t7 t8 t9)
+                            (and
+                                (= t1 (zero_ext 32 (extract 4 0 imm)))
+                                (= t3 (bvadd (extract 31 0 rn) (bvnot (zero_ext 32 (extract 4 0 imm)))))
+                                (= t6 (not (= (:N (:flags_in result)) (:V (:flags_in result)))))
+                                (if
+                                    t6
+                                    (and
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (sign_ext 64 (extract 31 0 rn))
+                                                                (sign_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t8
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (zero_ext 64 (extract 31 0 rn))
+                                                                (zero_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t9 (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= t10 (extract 31 31 (bvadd t3 #x00000001))))
+                                    (and
+                                        (= t12 (extract 0 0 (:V nzcv)))
+                                        (= t14 (extract 0 0 (:C nzcv)))
+                                        (= t16 (extract 0 0 (:Z nzcv)))
+                                        (= t18 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t6 t8 t14))
+                                (= (:N (:flags_out result)) (if t6 t10 t18))
+                                (= (:V (:flags_out result)) (if t6 t7 t12))
+                                (= (:Z (:flags_out result)) (if t6 t9 t16)))))
+                    ((Ge)
+                        (with
+                            (t1 t10 t12 t14 t16 t18 t3 t6 t7 t8 t9)
+                            (and
+                                (= t1 (zero_ext 32 (extract 4 0 imm)))
+                                (= t3 (bvadd (extract 31 0 rn) (bvnot (zero_ext 32 (extract 4 0 imm)))))
+                                (= t6 (= (:N (:flags_in result)) (:V (:flags_in result))))
+                                (if
+                                    t6
+                                    (and
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (sign_ext 64 (extract 31 0 rn))
+                                                                (sign_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t8
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (zero_ext 64 (extract 31 0 rn))
+                                                                (zero_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t9 (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= t10 (extract 31 31 (bvadd t3 #x00000001))))
+                                    (and
+                                        (= t12 (extract 0 0 (:V nzcv)))
+                                        (= t14 (extract 0 0 (:C nzcv)))
+                                        (= t16 (extract 0 0 (:Z nzcv)))
+                                        (= t18 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t6 t8 t14))
+                                (= (:N (:flags_out result)) (if t6 t10 t18))
+                                (= (:V (:flags_out result)) (if t6 t7 t12))
+                                (= (:Z (:flags_out result)) (if t6 t9 t16)))))
+                    ((Ls)
+                        (with
+                            (t1 t10 t12 t14 t16 t18 t3 t6 t7 t8 t9)
+                            (and
+                                (= t1 (zero_ext 32 (extract 4 0 imm)))
+                                (= t3 (bvadd (extract 31 0 rn) (bvnot (zero_ext 32 (extract 4 0 imm)))))
+                                (= t6 (not (and (= (:C (:flags_in result)) #b1) (= (:Z (:flags_in result)) #b0))))
+                                (if
+                                    t6
+                                    (and
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (sign_ext 64 (extract 31 0 rn))
+                                                                (sign_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t8
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (zero_ext 64 (extract 31 0 rn))
+                                                                (zero_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t9 (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= t10 (extract 31 31 (bvadd t3 #x00000001))))
+                                    (and
+                                        (= t12 (extract 0 0 (:V nzcv)))
+                                        (= t14 (extract 0 0 (:C nzcv)))
+                                        (= t16 (extract 0 0 (:Z nzcv)))
+                                        (= t18 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t6 t8 t14))
+                                (= (:N (:flags_out result)) (if t6 t10 t18))
+                                (= (:V (:flags_out result)) (if t6 t7 t12))
+                                (= (:Z (:flags_out result)) (if t6 t9 t16)))))
+                    ((Hi)
+                        (with
+                            (t1 t10 t12 t14 t16 t18 t3 t6 t7 t8 t9)
+                            (and
+                                (= t1 (zero_ext 32 (extract 4 0 imm)))
+                                (= t3 (bvadd (extract 31 0 rn) (bvnot (zero_ext 32 (extract 4 0 imm)))))
+                                (= t6 (and (= (:C (:flags_in result)) #b1) (= (:Z (:flags_in result)) #b0)))
+                                (if
+                                    t6
+                                    (and
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (sign_ext 64 (extract 31 0 rn))
+                                                                (sign_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t8
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (zero_ext 64 (extract 31 0 rn))
+                                                                (zero_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t9 (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= t10 (extract 31 31 (bvadd t3 #x00000001))))
+                                    (and
+                                        (= t12 (extract 0 0 (:V nzcv)))
+                                        (= t14 (extract 0 0 (:C nzcv)))
+                                        (= t16 (extract 0 0 (:Z nzcv)))
+                                        (= t18 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t6 t8 t14))
+                                (= (:N (:flags_out result)) (if t6 t10 t18))
+                                (= (:V (:flags_out result)) (if t6 t7 t12))
+                                (= (:Z (:flags_out result)) (if t6 t9 t16)))))
+                    ((Vc)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (zero_ext 32 (extract 4 0 imm)))
+                                (= t3 (bvadd (extract 31 0 rn) (bvnot (zero_ext 32 (extract 4 0 imm)))))
+                                (= t5 (not (= (:V (:flags_in result)) #b1)))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (sign_ext 64 (extract 31 0 rn))
+                                                                (sign_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (zero_ext 64 (extract 31 0 rn))
+                                                                (zero_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= t9 (extract 31 31 (bvadd t3 #x00000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))
+                    ((Vs)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (zero_ext 32 (extract 4 0 imm)))
+                                (= t3 (bvadd (extract 31 0 rn) (bvnot (zero_ext 32 (extract 4 0 imm)))))
+                                (= t5 (= (:V (:flags_in result)) #b1))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (sign_ext 64 (extract 31 0 rn))
+                                                                (sign_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (zero_ext 64 (extract 31 0 rn))
+                                                                (zero_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= t9 (extract 31 31 (bvadd t3 #x00000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))
+                    ((Pl)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (zero_ext 32 (extract 4 0 imm)))
+                                (= t3 (bvadd (extract 31 0 rn) (bvnot (zero_ext 32 (extract 4 0 imm)))))
+                                (= t5 (not (= (:N (:flags_in result)) #b1)))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (sign_ext 64 (extract 31 0 rn))
+                                                                (sign_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (zero_ext 64 (extract 31 0 rn))
+                                                                (zero_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= t9 (extract 31 31 (bvadd t3 #x00000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))
+                    ((Mi)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (zero_ext 32 (extract 4 0 imm)))
+                                (= t3 (bvadd (extract 31 0 rn) (bvnot (zero_ext 32 (extract 4 0 imm)))))
+                                (= t5 (= (:N (:flags_in result)) #b1))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (sign_ext 64 (extract 31 0 rn))
+                                                                (sign_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (zero_ext 64 (extract 31 0 rn))
+                                                                (zero_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= t9 (extract 31 31 (bvadd t3 #x00000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))
+                    ((Lo)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (zero_ext 32 (extract 4 0 imm)))
+                                (= t3 (bvadd (extract 31 0 rn) (bvnot (zero_ext 32 (extract 4 0 imm)))))
+                                (= t5 (not (= (:C (:flags_in result)) #b1)))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (sign_ext 64 (extract 31 0 rn))
+                                                                (sign_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (zero_ext 64 (extract 31 0 rn))
+                                                                (zero_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= t9 (extract 31 31 (bvadd t3 #x00000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))
+                    ((Hs)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (zero_ext 32 (extract 4 0 imm)))
+                                (= t3 (bvadd (extract 31 0 rn) (bvnot (zero_ext 32 (extract 4 0 imm)))))
+                                (= t5 (= (:C (:flags_in result)) #b1))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (sign_ext 64 (extract 31 0 rn))
+                                                                (sign_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (zero_ext 64 (extract 31 0 rn))
+                                                                (zero_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= t9 (extract 31 31 (bvadd t3 #x00000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))
+                    ((Ne)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (zero_ext 32 (extract 4 0 imm)))
+                                (= t3 (bvadd (extract 31 0 rn) (bvnot (zero_ext 32 (extract 4 0 imm)))))
+                                (= t5 (not (= (:Z (:flags_in result)) #b1)))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (sign_ext 64 (extract 31 0 rn))
+                                                                (sign_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (zero_ext 64 (extract 31 0 rn))
+                                                                (zero_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= t9 (extract 31 31 (bvadd t3 #x00000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))
+                    ((Eq)
+                        (with
+                            (t1 t11 t13 t15 t17 t3 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (zero_ext 32 (extract 4 0 imm)))
+                                (= t3 (bvadd (extract 31 0 rn) (bvnot (zero_ext 32 (extract 4 0 imm)))))
+                                (= t5 (= (:Z (:flags_in result)) #b1))
+                                (if
+                                    t5
+                                    (and
+                                        (=
+                                            t6
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (sign_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (sign_ext 64 (extract 31 0 rn))
+                                                                (sign_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (=
+                                            t7
+                                            (bvnot
+                                                (if
+                                                    (=
+                                                        (zero_ext 64 (bvadd t3 #x00000001))
+                                                        (bvadd
+                                                            (bvadd
+                                                                (zero_ext 64 (extract 31 0 rn))
+                                                                (zero_ext 64 (bvnot t1)))
+                                                            #x0000000000000001))
+                                                    #b1
+                                                    #b0)))
+                                        (= t8 (if (= (bvadd t3 #x00000001) #x00000000) #b1 #b0))
+                                        (= t9 (extract 31 31 (bvadd t3 #x00000001))))
+                                    (and
+                                        (= t11 (extract 0 0 (:V nzcv)))
+                                        (= t13 (extract 0 0 (:C nzcv)))
+                                        (= t15 (extract 0 0 (:Z nzcv)))
+                                        (= t17 (extract 0 0 (:N nzcv)))))
+                                (= (:C (:flags_out result)) (if t5 t7 t13))
+                                (= (:N (:flags_out result)) (if t5 t9 t17))
+                                (= (:V (:flags_out result)) (if t5 t6 t11))
+                                (= (:Z (:flags_out result)) (if t5 t8 t15)))))))))
+    (require
+        (match
+            size
+            ((Size64)
+                (match
+                    cond
+                    ((Le) true)
+                    ((Gt) true)
+                    ((Lt) true)
+                    ((Ge) true)
+                    ((Ls) true)
+                    ((Hi) true)
+                    ((Vc) true)
+                    ((Vs) true)
+                    ((Pl) true)
+                    ((Mi) true)
+                    ((Lo) true)
+                    ((Hs) true)
+                    ((Ne) true)
+                    ((Eq) true)))
+            ((Size32)
+                (match
+                    cond
+                    ((Le) true)
+                    ((Gt) true)
+                    ((Lt) true)
+                    ((Ge) true)
+                    ((Ls) true)
+                    ((Hi) true)
+                    ((Vc) true)
+                    ((Vs) true)
+                    ((Pl) true)
+                    ((Mi) true)
+                    ((Lo) true)
+                    ((Hs) true)
+                    ((Ne) true)
+                    ((Eq) true))))))
diff --git a/cranelift/codegen/src/isa/aarch64/spec/extend.isle b/cranelift/codegen/src/isa/aarch64/spec/extend.isle
new file mode 100644
index 000000000000..4d0157f09196
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/spec/extend.isle
@@ -0,0 +1,55 @@
+;; GENERATED BY `isaspec`. DO NOT EDIT!!!
+
+(attr MInst.Extend (tag isaspec_generated))
+
+(spec
+    (MInst.Extend rd rn signed from_bits to_bits)
+    (provide
+        (=> (and (not signed) (= from_bits #x08) (= to_bits #x08)) (= rd (zero_ext 64 (extract 7 0 (as rn (bv 64))))))
+        (=>
+            (and signed (= from_bits #x08) (= to_bits #x08))
+            (= rd (zero_ext 64 (sign_ext 32 (extract 7 0 (as rn (bv 64)))))))
+        (=> (and (not signed) (= from_bits #x08) (= to_bits #x10)) (= rd (zero_ext 64 (extract 7 0 (as rn (bv 64))))))
+        (=>
+            (and signed (= from_bits #x08) (= to_bits #x10))
+            (= rd (zero_ext 64 (sign_ext 32 (extract 7 0 (as rn (bv 64)))))))
+        (=> (and (not signed) (= from_bits #x08) (= to_bits #x20)) (= rd (zero_ext 64 (extract 7 0 (as rn (bv 64))))))
+        (=>
+            (and signed (= from_bits #x08) (= to_bits #x20))
+            (= rd (zero_ext 64 (sign_ext 32 (extract 7 0 (as rn (bv 64)))))))
+        (=> (and (not signed) (= from_bits #x08) (= to_bits #x40)) (= rd (zero_ext 64 (extract 7 0 (as rn (bv 64))))))
+        (=> (and signed (= from_bits #x08) (= to_bits #x40)) (= rd (sign_ext 64 (extract 7 0 (as rn (bv 64))))))
+        (=> (and (not signed) (= from_bits #x10) (= to_bits #x10)) (= rd (zero_ext 64 (extract 15 0 (as rn (bv 64))))))
+        (=>
+            (and signed (= from_bits #x10) (= to_bits #x10))
+            (= rd (zero_ext 64 (sign_ext 32 (extract 15 0 (as rn (bv 64)))))))
+        (=> (and (not signed) (= from_bits #x10) (= to_bits #x20)) (= rd (zero_ext 64 (extract 15 0 (as rn (bv 64))))))
+        (=>
+            (and signed (= from_bits #x10) (= to_bits #x20))
+            (= rd (zero_ext 64 (sign_ext 32 (extract 15 0 (as rn (bv 64)))))))
+        (=> (and (not signed) (= from_bits #x10) (= to_bits #x40)) (= rd (zero_ext 64 (extract 15 0 (as rn (bv 64))))))
+        (=> (and signed (= from_bits #x10) (= to_bits #x40)) (= rd (sign_ext 64 (extract 15 0 (as rn (bv 64))))))
+        (=> (and (not signed) (= from_bits #x20) (= to_bits #x20)) (= rd (zero_ext 64 (extract 31 0 (as rn (bv 64))))))
+        (=> (and signed (= from_bits #x20) (= to_bits #x20)) (= rd (zero_ext 64 (extract 31 0 (as rn (bv 64))))))
+        (=> (and (not signed) (= from_bits #x20) (= to_bits #x40)) (= rd (zero_ext 64 (extract 31 0 (as rn (bv 64))))))
+        (=> (and signed (= from_bits #x20) (= to_bits #x40)) (= rd (sign_ext 64 (extract 31 0 (as rn (bv 64)))))))
+    (require
+        (or
+            (and (not signed) (= from_bits #x08) (= to_bits #x08))
+            (and signed (= from_bits #x08) (= to_bits #x08))
+            (and (not signed) (= from_bits #x08) (= to_bits #x10))
+            (and signed (= from_bits #x08) (= to_bits #x10))
+            (and (not signed) (= from_bits #x08) (= to_bits #x20))
+            (and signed (= from_bits #x08) (= to_bits #x20))
+            (and (not signed) (= from_bits #x08) (= to_bits #x40))
+            (and signed (= from_bits #x08) (= to_bits #x40))
+            (and (not signed) (= from_bits #x10) (= to_bits #x10))
+            (and signed (= from_bits #x10) (= to_bits #x10))
+            (and (not signed) (= from_bits #x10) (= to_bits #x20))
+            (and signed (= from_bits #x10) (= to_bits #x20))
+            (and (not signed) (= from_bits #x10) (= to_bits #x40))
+            (and signed (= from_bits #x10) (= to_bits #x40))
+            (and (not signed) (= from_bits #x20) (= to_bits #x20))
+            (and signed (= from_bits #x20) (= to_bits #x20))
+            (and (not signed) (= from_bits #x20) (= to_bits #x40))
+            (and signed (= from_bits #x20) (= to_bits #x40)))))
diff --git a/cranelift/codegen/src/isa/aarch64/spec/fp_const.isle b/cranelift/codegen/src/isa/aarch64/spec/fp_const.isle
new file mode 100644
index 000000000000..d98c1b80ea9c
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/spec/fp_const.isle
@@ -0,0 +1,79 @@
+;; GENERATED BY `fpconst`. DO NOT EDIT!!!
+
+(spec (min_fp_value signed in out)
+	(provide
+		(=> (and (= in #x20) (= signed true) (= out #x08)) (= result #x00000000c3010000))
+		(=> (and (= in #x20) (= signed true) (= out #x10)) (= result #x00000000c7000100))
+		(=> (and (= in #x20) (= signed true) (= out #x20)) (= result #x00000000cf000000))
+		(=> (and (= in #x20) (= signed true) (= out #x40)) (= result #x00000000df000000))
+		(=> (and (= in #x20) (= signed false) (= out #x08)) (= result #x00000000bf800000))
+		(=> (and (= in #x20) (= signed false) (= out #x10)) (= result #x00000000bf800000))
+		(=> (and (= in #x20) (= signed false) (= out #x20)) (= result #x00000000bf800000))
+		(=> (and (= in #x20) (= signed false) (= out #x40)) (= result #x00000000bf800000))
+		(=> (and (= in #x40) (= signed true) (= out #x08)) (= result #xc060200000000000))
+		(=> (and (= in #x40) (= signed true) (= out #x10)) (= result #xc0e0002000000000))
+		(=> (and (= in #x40) (= signed true) (= out #x20)) (= result #xc1e0000000200000))
+		(=> (and (= in #x40) (= signed true) (= out #x40)) (= result #xc3e0000000000000))
+		(=> (and (= in #x40) (= signed false) (= out #x08)) (= result #xbff0000000000000))
+		(=> (and (= in #x40) (= signed false) (= out #x10)) (= result #xbff0000000000000))
+		(=> (and (= in #x40) (= signed false) (= out #x20)) (= result #xbff0000000000000))
+		(=> (and (= in #x40) (= signed false) (= out #x40)) (= result #xbff0000000000000))
+	)
+	(require (or
+		(and (= in #x20) (= signed true) (= out #x08))
+		(and (= in #x20) (= signed true) (= out #x10))
+		(and (= in #x20) (= signed true) (= out #x20))
+		(and (= in #x20) (= signed true) (= out #x40))
+		(and (= in #x20) (= signed false) (= out #x08))
+		(and (= in #x20) (= signed false) (= out #x10))
+		(and (= in #x20) (= signed false) (= out #x20))
+		(and (= in #x20) (= signed false) (= out #x40))
+		(and (= in #x40) (= signed true) (= out #x08))
+		(and (= in #x40) (= signed true) (= out #x10))
+		(and (= in #x40) (= signed true) (= out #x20))
+		(and (= in #x40) (= signed true) (= out #x40))
+		(and (= in #x40) (= signed false) (= out #x08))
+		(and (= in #x40) (= signed false) (= out #x10))
+		(and (= in #x40) (= signed false) (= out #x20))
+		(and (= in #x40) (= signed false) (= out #x40))
+	))
+)
+
+(spec (max_fp_value signed in out)
+	(provide
+		(=> (and (= in #x20) (= signed true) (= out #x08)) (= result #x0000000043000000))
+		(=> (and (= in #x20) (= signed true) (= out #x10)) (= result #x0000000047000000))
+		(=> (and (= in #x20) (= signed true) (= out #x20)) (= result #x000000004f000000))
+		(=> (and (= in #x20) (= signed true) (= out #x40)) (= result #x000000005f000000))
+		(=> (and (= in #x20) (= signed false) (= out #x08)) (= result #x0000000043800000))
+		(=> (and (= in #x20) (= signed false) (= out #x10)) (= result #x0000000047800000))
+		(=> (and (= in #x20) (= signed false) (= out #x20)) (= result #x000000004f800000))
+		(=> (and (= in #x20) (= signed false) (= out #x40)) (= result #x000000005f800000))
+		(=> (and (= in #x40) (= signed true) (= out #x08)) (= result #x4060000000000000))
+		(=> (and (= in #x40) (= signed true) (= out #x10)) (= result #x40e0000000000000))
+		(=> (and (= in #x40) (= signed true) (= out #x20)) (= result #x41e0000000000000))
+		(=> (and (= in #x40) (= signed true) (= out #x40)) (= result #x43e0000000000000))
+		(=> (and (= in #x40) (= signed false) (= out #x08)) (= result #x4070000000000000))
+		(=> (and (= in #x40) (= signed false) (= out #x10)) (= result #x40f0000000000000))
+		(=> (and (= in #x40) (= signed false) (= out #x20)) (= result #x41f0000000000000))
+		(=> (and (= in #x40) (= signed false) (= out #x40)) (= result #x43f0000000000000))
+	)
+	(require (or
+		(and (= in #x20) (= signed true) (= out #x08))
+		(and (= in #x20) (= signed true) (= out #x10))
+		(and (= in #x20) (= signed true) (= out #x20))
+		(and (= in #x20) (= signed true) (= out #x40))
+		(and (= in #x20) (= signed false) (= out #x08))
+		(and (= in #x20) (= signed false) (= out #x10))
+		(and (= in #x20) (= signed false) (= out #x20))
+		(and (= in #x20) (= signed false) (= out #x40))
+		(and (= in #x40) (= signed true) (= out #x08))
+		(and (= in #x40) (= signed true) (= out #x10))
+		(and (= in #x40) (= signed true) (= out #x20))
+		(and (= in #x40) (= signed true) (= out #x40))
+		(and (= in #x40) (= signed false) (= out #x08))
+		(and (= in #x40) (= signed false) (= out #x10))
+		(and (= in #x40) (= signed false) (= out #x20))
+		(and (= in #x40) (= signed false) (= out #x40))
+	))
+)
diff --git a/cranelift/codegen/src/isa/aarch64/spec/fpu_cmp.isle b/cranelift/codegen/src/isa/aarch64/spec/fpu_cmp.isle
new file mode 100644
index 000000000000..6a777b8bffdf
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/spec/fpu_cmp.isle
@@ -0,0 +1,40 @@
+;; GENERATED BY `isaspec`. DO NOT EDIT!!!
+
+(attr MInst.FpuCmp (tag isaspec_generated))
+
+(spec
+    (MInst.FpuCmp size rn rm)
+    (provide
+        (match
+            size
+            ((Size64)
+                (with
+                    (t4)
+                    (and
+                        (=
+                            t4
+                            (FPCompare!
+                                (extract 63 0 (conv_to 128 (as rn (bv 64))))
+                                (extract 63 0 (conv_to 128 (as rm (bv 64))))
+                                false
+                                fpcr))
+                        (= (:V (:flags_out result)) (extract 0 0 t4))
+                        (= (:C (:flags_out result)) (extract 1 1 t4))
+                        (= (:Z (:flags_out result)) (extract 2 2 t4))
+                        (= (:N (:flags_out result)) (extract 3 3 t4)))))
+            ((Size32)
+                (with
+                    (t4)
+                    (and
+                        (=
+                            t4
+                            (FPCompare!
+                                (extract 31 0 (conv_to 128 (as rn (bv 64))))
+                                (extract 31 0 (conv_to 128 (as rm (bv 64))))
+                                false
+                                fpcr))
+                        (= (:V (:flags_out result)) (extract 0 0 t4))
+                        (= (:C (:flags_out result)) (extract 1 1 t4))
+                        (= (:Z (:flags_out result)) (extract 2 2 t4))
+                        (= (:N (:flags_out result)) (extract 3 3 t4)))))))
+    (require (match size ((Size64) true) ((Size32) true))))
diff --git a/cranelift/codegen/src/isa/aarch64/spec/fpu_move_imm.isle b/cranelift/codegen/src/isa/aarch64/spec/fpu_move_imm.isle
new file mode 100644
index 000000000000..23815da9adf5
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/spec/fpu_move_imm.isle
@@ -0,0 +1,34 @@
+;; GENERATED BY `isaspec`. DO NOT EDIT!!!
+
+(attr MInst.FpuMoveFPImm (tag isaspec_generated))
+
+(spec
+    (MInst.FpuMoveFPImm rd imm size)
+    (provide
+        (match
+            size
+            ((Size64)
+                (=
+                    rd
+                    (zero_ext
+                        128
+                        (concat
+                            (concat
+                                (extract 7 7 (:imm imm))
+                                (concat
+                                    (concat (bvnot (extract 6 6 (:imm imm))) (replicate (extract 6 6 (:imm imm)) 8))
+                                    (extract 5 4 (:imm imm))))
+                            (concat (extract 3 0 (:imm imm)) #x000000000000)))))
+            ((Size32)
+                (=
+                    rd
+                    (zero_ext
+                        128
+                        (concat
+                            (concat
+                                (extract 7 7 (:imm imm))
+                                (concat
+                                    (concat (bvnot (extract 6 6 (:imm imm))) (replicate (extract 6 6 (:imm imm)) 5))
+                                    (extract 5 4 (:imm imm))))
+                            (concat (extract 3 0 (:imm imm)) #b0000000000000000000)))))))
+    (require (match size ((Size64) true) ((Size32) true))))
diff --git a/cranelift/codegen/src/isa/aarch64/spec/fpu_round.isle b/cranelift/codegen/src/isa/aarch64/spec/fpu_round.isle
new file mode 100644
index 000000000000..40f525b93599
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/spec/fpu_round.isle
@@ -0,0 +1,68 @@
+;; GENERATED BY `isaspec`. DO NOT EDIT!!!
+
+(attr MInst.FpuRound (tag isaspec_generated))
+
+(spec
+    (MInst.FpuRound op rd rn)
+    (provide
+        (match
+            op
+            ((Nearest64)
+                (with
+                    (t3)
+                    (and
+                        (= t3 (FPRoundInt! (extract 63 0 (conv_to 128 (as rn (bv 64)))) fpcr 0 false))
+                        (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 t3)))))
+            ((Nearest32)
+                (with
+                    (t3)
+                    (and
+                        (= t3 (FPRoundInt! (extract 31 0 (conv_to 128 (as rn (bv 64)))) fpcr 0 false))
+                        (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 t3)))))
+            ((Zero64)
+                (with
+                    (t3)
+                    (and
+                        (= t3 (FPRoundInt! (extract 63 0 (conv_to 128 (as rn (bv 64)))) fpcr 3 false))
+                        (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 t3)))))
+            ((Zero32)
+                (with
+                    (t3)
+                    (and
+                        (= t3 (FPRoundInt! (extract 31 0 (conv_to 128 (as rn (bv 64)))) fpcr 3 false))
+                        (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 t3)))))
+            ((Plus64)
+                (with
+                    (t3)
+                    (and
+                        (= t3 (FPRoundInt! (extract 63 0 (conv_to 128 (as rn (bv 64)))) fpcr 1 false))
+                        (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 t3)))))
+            ((Plus32)
+                (with
+                    (t3)
+                    (and
+                        (= t3 (FPRoundInt! (extract 31 0 (conv_to 128 (as rn (bv 64)))) fpcr 1 false))
+                        (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 t3)))))
+            ((Minus64)
+                (with
+                    (t3)
+                    (and
+                        (= t3 (FPRoundInt! (extract 63 0 (conv_to 128 (as rn (bv 64)))) fpcr 2 false))
+                        (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 t3)))))
+            ((Minus32)
+                (with
+                    (t3)
+                    (and
+                        (= t3 (FPRoundInt! (extract 31 0 (conv_to 128 (as rn (bv 64)))) fpcr 2 false))
+                        (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 t3)))))))
+    (require
+        (match
+            op
+            ((Nearest64) true)
+            ((Nearest32) true)
+            ((Zero64) true)
+            ((Zero32) true)
+            ((Plus64) true)
+            ((Plus32) true)
+            ((Minus64) true)
+            ((Minus32) true))))
diff --git a/cranelift/codegen/src/isa/aarch64/spec/fpu_rr.isle b/cranelift/codegen/src/isa/aarch64/spec/fpu_rr.isle
new file mode 100644
index 000000000000..cb4b7f98970b
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/spec/fpu_rr.isle
@@ -0,0 +1,66 @@
+;; GENERATED BY `isaspec`. DO NOT EDIT!!!
+
+(attr MInst.FpuRR (tag isaspec_generated))
+
+(spec
+    (MInst.FpuRR fpu_op size rd rn)
+    (provide
+        (match
+            size
+            ((Size64)
+                (match
+                    fpu_op
+                    ((Neg)
+                        (=
+                            (conv_to 128 (as rd (bv 64)))
+                            (zero_ext
+                                128
+                                (concat
+                                    (bvnot (extract 63 63 (conv_to 128 (as rn (bv 64)))))
+                                    (extract 62 0 (conv_to 128 (as rn (bv 64))))))))
+                    ((Abs)
+                        (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 (extract 62 0 (conv_to 128 (as rn (bv 64)))))))
+                    ((Sqrt)
+                        (with
+                            (t2)
+                            (and
+                                (= t2 (FPSqrt! (extract 63 0 (conv_to 128 (as rn (bv 64)))) fpcr))
+                                (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 t2)))))
+                    ((Cvt64To32)
+                        (with
+                            (t1 t3)
+                            (and
+                                (= t1 (zero_ext 4 (extract 23 22 fpcr)))
+                                (= t3 (FPConvert! (extract 63 0 (conv_to 128 (as rn (bv 64)))) fpcr (bv2nat t1) 32 64))
+                                (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 t3)))))))
+            ((Size32)
+                (match
+                    fpu_op
+                    ((Neg)
+                        (=
+                            (conv_to 128 (as rd (bv 64)))
+                            (zero_ext
+                                128
+                                (concat
+                                    (bvnot (extract 31 31 (conv_to 128 (as rn (bv 64)))))
+                                    (extract 30 0 (conv_to 128 (as rn (bv 64))))))))
+                    ((Abs)
+                        (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 (extract 30 0 (conv_to 128 (as rn (bv 64)))))))
+                    ((Sqrt)
+                        (with
+                            (t2)
+                            (and
+                                (= t2 (FPSqrt! (extract 31 0 (conv_to 128 (as rn (bv 64)))) fpcr))
+                                (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 t2)))))
+                    ((Cvt32To64)
+                        (with
+                            (t1 t3)
+                            (and
+                                (= t1 (zero_ext 4 (extract 23 22 fpcr)))
+                                (= t3 (FPConvert! (extract 31 0 (conv_to 128 (as rn (bv 64)))) fpcr (bv2nat t1) 64 32))
+                                (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 t3)))))))))
+    (require
+        (match
+            size
+            ((Size64) (match fpu_op ((Neg) true) ((Abs) true) ((Sqrt) true) ((Cvt64To32) true)))
+            ((Size32) (match fpu_op ((Neg) true) ((Abs) true) ((Sqrt) true) ((Cvt32To64) true))))))
diff --git a/cranelift/codegen/src/isa/aarch64/spec/fpu_rri.isle b/cranelift/codegen/src/isa/aarch64/spec/fpu_rri.isle
new file mode 100644
index 000000000000..6c83fd216d46
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/spec/fpu_rri.isle
@@ -0,0 +1,35 @@
+;; GENERATED BY `isaspec`. DO NOT EDIT!!!
+
+(attr MInst.FpuRRI (tag isaspec_generated))
+
+(spec
+    (MInst.FpuRRI fpu_op rd rn)
+    (provide
+        (=>
+            (= (:lane_size_in_bits fpu_op) #x40)
+            (=
+                (conv_to 128 (as rd (bv 64)))
+                (zero_ext
+                    128
+                    (extract
+                        63
+                        0
+                        (bvashr (zero_ext 128 (extract 63 0 (conv_to 128 (as rn (bv 64))))) (zero_ext 128 #x003f))))))
+        (=>
+            (= (:lane_size_in_bits fpu_op) #x20)
+            (=
+                (conv_to 128 (as rd (bv 64)))
+                (zero_ext
+                    128
+                    (concat
+                        (extract
+                            31
+                            0
+                            (bvashr (zero_ext 64 (extract 63 32 (conv_to 128 (as rn (bv 64))))) (zero_ext 64 #x001f)))
+                        (extract
+                            31
+                            0
+                            (bvashr
+                                (zero_ext 64 (extract 31 0 (conv_to 128 (as rn (bv 64)))))
+                                (zero_ext 64 #x001f))))))))
+    (require (or (= (:lane_size_in_bits fpu_op) #x40) (= (:lane_size_in_bits fpu_op) #x20))))
diff --git a/cranelift/codegen/src/isa/aarch64/spec/fpu_rrimod.isle b/cranelift/codegen/src/isa/aarch64/spec/fpu_rrimod.isle
new file mode 100644
index 000000000000..ae78e44bd8d1
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/spec/fpu_rrimod.isle
@@ -0,0 +1,28 @@
+;; GENERATED BY `isaspec`. DO NOT EDIT!!!
+
+(attr MInst.FpuRRIMod (tag isaspec_generated))
+
+(spec
+    (MInst.FpuRRIMod fpu_op rd ri rn)
+    (provide
+        (=>
+            (= (:lane_size_in_bits fpu_op) #x40)
+            (=
+                (conv_to 128 (as rd (bv 64)))
+                (zero_ext
+                    128
+                    (concat (extract 0 0 (conv_to 128 (as rn (bv 64)))) (extract 62 0 (conv_to 128 (as ri (bv 64))))))))
+        (=>
+            (= (:lane_size_in_bits fpu_op) #x20)
+            (=
+                (conv_to 128 (as rd (bv 64)))
+                (zero_ext
+                    128
+                    (concat
+                        (concat
+                            (extract 32 32 (conv_to 128 (as rn (bv 64))))
+                            (extract 62 32 (conv_to 128 (as ri (bv 64)))))
+                        (concat
+                            (extract 0 0 (conv_to 128 (as rn (bv 64))))
+                            (extract 30 0 (conv_to 128 (as ri (bv 64))))))))))
+    (require (or (= (:lane_size_in_bits fpu_op) #x40) (= (:lane_size_in_bits fpu_op) #x20))))
diff --git a/cranelift/codegen/src/isa/aarch64/spec/fpu_rrr.isle b/cranelift/codegen/src/isa/aarch64/spec/fpu_rrr.isle
new file mode 100644
index 000000000000..7307014ff8de
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/spec/fpu_rrr.isle
@@ -0,0 +1,152 @@
+;; GENERATED BY `isaspec`. DO NOT EDIT!!!
+
+(attr MInst.FpuRRR (tag isaspec_generated))
+
+(spec
+    (MInst.FpuRRR fpu_op size rd rn rm)
+    (provide
+        (match
+            size
+            ((Size64)
+                (match
+                    fpu_op
+                    ((Add)
+                        (with
+                            (t3)
+                            (and
+                                (=
+                                    t3
+                                    (FPAdd!
+                                        (extract 63 0 (conv_to 128 (as rn (bv 64))))
+                                        (extract 63 0 (conv_to 128 (as rm (bv 64))))
+                                        fpcr))
+                                (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 t3)))))
+                    ((Sub)
+                        (with
+                            (t3)
+                            (and
+                                (=
+                                    t3
+                                    (FPSub!
+                                        (extract 63 0 (conv_to 128 (as rn (bv 64))))
+                                        (extract 63 0 (conv_to 128 (as rm (bv 64))))
+                                        fpcr))
+                                (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 t3)))))
+                    ((Mul)
+                        (with
+                            (t3)
+                            (and
+                                (=
+                                    t3
+                                    (FPMul!
+                                        (extract 63 0 (conv_to 128 (as rn (bv 64))))
+                                        (extract 63 0 (conv_to 128 (as rm (bv 64))))
+                                        fpcr))
+                                (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 t3)))))
+                    ((Div)
+                        (with
+                            (t3)
+                            (and
+                                (=
+                                    t3
+                                    (FPDiv!
+                                        (extract 63 0 (conv_to 128 (as rn (bv 64))))
+                                        (extract 63 0 (conv_to 128 (as rm (bv 64))))
+                                        fpcr))
+                                (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 t3)))))
+                    ((Min)
+                        (with
+                            (t3)
+                            (and
+                                (=
+                                    t3
+                                    (FPMin!
+                                        (extract 63 0 (conv_to 128 (as rn (bv 64))))
+                                        (extract 63 0 (conv_to 128 (as rm (bv 64))))
+                                        fpcr))
+                                (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 t3)))))
+                    ((Max)
+                        (with
+                            (t3)
+                            (and
+                                (=
+                                    t3
+                                    (FPMax!
+                                        (extract 63 0 (conv_to 128 (as rn (bv 64))))
+                                        (extract 63 0 (conv_to 128 (as rm (bv 64))))
+                                        fpcr))
+                                (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 t3)))))))
+            ((Size32)
+                (match
+                    fpu_op
+                    ((Add)
+                        (with
+                            (t3)
+                            (and
+                                (=
+                                    t3
+                                    (FPAdd!
+                                        (extract 31 0 (conv_to 128 (as rn (bv 64))))
+                                        (extract 31 0 (conv_to 128 (as rm (bv 64))))
+                                        fpcr))
+                                (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 t3)))))
+                    ((Sub)
+                        (with
+                            (t3)
+                            (and
+                                (=
+                                    t3
+                                    (FPSub!
+                                        (extract 31 0 (conv_to 128 (as rn (bv 64))))
+                                        (extract 31 0 (conv_to 128 (as rm (bv 64))))
+                                        fpcr))
+                                (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 t3)))))
+                    ((Mul)
+                        (with
+                            (t3)
+                            (and
+                                (=
+                                    t3
+                                    (FPMul!
+                                        (extract 31 0 (conv_to 128 (as rn (bv 64))))
+                                        (extract 31 0 (conv_to 128 (as rm (bv 64))))
+                                        fpcr))
+                                (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 t3)))))
+                    ((Div)
+                        (with
+                            (t3)
+                            (and
+                                (=
+                                    t3
+                                    (FPDiv!
+                                        (extract 31 0 (conv_to 128 (as rn (bv 64))))
+                                        (extract 31 0 (conv_to 128 (as rm (bv 64))))
+                                        fpcr))
+                                (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 t3)))))
+                    ((Min)
+                        (with
+                            (t3)
+                            (and
+                                (=
+                                    t3
+                                    (FPMin!
+                                        (extract 31 0 (conv_to 128 (as rn (bv 64))))
+                                        (extract 31 0 (conv_to 128 (as rm (bv 64))))
+                                        fpcr))
+                                (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 t3)))))
+                    ((Max)
+                        (with
+                            (t3)
+                            (and
+                                (=
+                                    t3
+                                    (FPMax!
+                                        (extract 31 0 (conv_to 128 (as rn (bv 64))))
+                                        (extract 31 0 (conv_to 128 (as rm (bv 64))))
+                                        fpcr))
+                                (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 t3)))))))))
+    (require
+        (match
+            size
+            ((Size64) (match fpu_op ((Add) true) ((Sub) true) ((Mul) true) ((Div) true) ((Min) true) ((Max) true)))
+            ((Size32) (match fpu_op ((Add) true) ((Sub) true) ((Mul) true) ((Div) true) ((Min) true) ((Max) true))))))
diff --git a/cranelift/codegen/src/isa/aarch64/spec/fpu_to_int.isle b/cranelift/codegen/src/isa/aarch64/spec/fpu_to_int.isle
new file mode 100644
index 000000000000..618974dcd3ff
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/spec/fpu_to_int.isle
@@ -0,0 +1,32 @@
+;; GENERATED BY `isaspec`. DO NOT EDIT!!!
+
+(attr MInst.FpuToInt (tag isaspec_generated))
+
+(spec
+    (MInst.FpuToInt op rd rn)
+    (provide
+        (match
+            op
+            ((F64ToI64) (with (t3) (and (= t3 (FPToFixed! (extract 63 0 rn) 0 false fpcr 3 64 64)) (= rd t3))))
+            ((F64ToU64) (with (t3) (and (= t3 (FPToFixed! (extract 63 0 rn) 0 true fpcr 3 64 64)) (= rd t3))))
+            ((F64ToI32)
+                (with (t3) (and (= t3 (FPToFixed! (extract 63 0 rn) 0 false fpcr 3 32 64)) (= rd (zero_ext 64 t3)))))
+            ((F64ToU32)
+                (with (t3) (and (= t3 (FPToFixed! (extract 63 0 rn) 0 true fpcr 3 32 64)) (= rd (zero_ext 64 t3)))))
+            ((F32ToI64) (with (t3) (and (= t3 (FPToFixed! (extract 31 0 rn) 0 false fpcr 3 64 32)) (= rd t3))))
+            ((F32ToU64) (with (t3) (and (= t3 (FPToFixed! (extract 31 0 rn) 0 true fpcr 3 64 32)) (= rd t3))))
+            ((F32ToI32)
+                (with (t3) (and (= t3 (FPToFixed! (extract 31 0 rn) 0 false fpcr 3 32 32)) (= rd (zero_ext 64 t3)))))
+            ((F32ToU32)
+                (with (t3) (and (= t3 (FPToFixed! (extract 31 0 rn) 0 true fpcr 3 32 32)) (= rd (zero_ext 64 t3)))))))
+    (require
+        (match
+            op
+            ((F64ToI64) true)
+            ((F64ToU64) true)
+            ((F64ToI32) true)
+            ((F64ToU32) true)
+            ((F32ToI64) true)
+            ((F32ToU64) true)
+            ((F32ToI32) true)
+            ((F32ToU32) true))))
diff --git a/cranelift/codegen/src/isa/aarch64/spec/int_to_fpu.isle b/cranelift/codegen/src/isa/aarch64/spec/int_to_fpu.isle
new file mode 100644
index 000000000000..f6a582f0626d
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/spec/int_to_fpu.isle
@@ -0,0 +1,76 @@
+;; GENERATED BY `isaspec`. DO NOT EDIT!!!
+
+(attr MInst.IntToFpu (tag isaspec_generated))
+
+(spec
+    (MInst.IntToFpu op rd rn)
+    (provide
+        (match
+            op
+            ((I64ToF64)
+                (with
+                    (t1 t4)
+                    (and
+                        (= t1 (zero_ext 4 (extract 23 22 fpcr)))
+                        (= t4 (FixedToFP! rn 0 false fpcr (bv2nat t1) 64 64))
+                        (= rd (zero_ext 128 t4)))))
+            ((U64ToF64)
+                (with
+                    (t1 t4)
+                    (and
+                        (= t1 (zero_ext 4 (extract 23 22 fpcr)))
+                        (= t4 (FixedToFP! rn 0 true fpcr (bv2nat t1) 64 64))
+                        (= rd (zero_ext 128 t4)))))
+            ((I64ToF32)
+                (with
+                    (t1 t4)
+                    (and
+                        (= t1 (zero_ext 4 (extract 23 22 fpcr)))
+                        (= t4 (FixedToFP! rn 0 false fpcr (bv2nat t1) 64 32))
+                        (= rd (zero_ext 128 t4)))))
+            ((U64ToF32)
+                (with
+                    (t1 t4)
+                    (and
+                        (= t1 (zero_ext 4 (extract 23 22 fpcr)))
+                        (= t4 (FixedToFP! rn 0 true fpcr (bv2nat t1) 64 32))
+                        (= rd (zero_ext 128 t4)))))
+            ((I32ToF64)
+                (with
+                    (t1 t4)
+                    (and
+                        (= t1 (zero_ext 4 (extract 23 22 fpcr)))
+                        (= t4 (FixedToFP! (extract 31 0 rn) 0 false fpcr (bv2nat t1) 32 64))
+                        (= rd (zero_ext 128 t4)))))
+            ((U32ToF64)
+                (with
+                    (t1 t4)
+                    (and
+                        (= t1 (zero_ext 4 (extract 23 22 fpcr)))
+                        (= t4 (FixedToFP! (extract 31 0 rn) 0 true fpcr (bv2nat t1) 32 64))
+                        (= rd (zero_ext 128 t4)))))
+            ((I32ToF32)
+                (with
+                    (t1 t4)
+                    (and
+                        (= t1 (zero_ext 4 (extract 23 22 fpcr)))
+                        (= t4 (FixedToFP! (extract 31 0 rn) 0 false fpcr (bv2nat t1) 32 32))
+                        (= rd (zero_ext 128 t4)))))
+            ((U32ToF32)
+                (with
+                    (t1 t4)
+                    (and
+                        (= t1 (zero_ext 4 (extract 23 22 fpcr)))
+                        (= t4 (FixedToFP! (extract 31 0 rn) 0 true fpcr (bv2nat t1) 32 32))
+                        (= rd (zero_ext 128 t4)))))))
+    (require
+        (match
+            op
+            ((I64ToF64) true)
+            ((U64ToF64) true)
+            ((I64ToF32) true)
+            ((U64ToF32) true)
+            ((I32ToF64) true)
+            ((U32ToF64) true)
+            ((I32ToF32) true)
+            ((U32ToF32) true))))
diff --git a/cranelift/codegen/src/isa/aarch64/spec/loads.isle b/cranelift/codegen/src/isa/aarch64/spec/loads.isle
new file mode 100644
index 000000000000..4b2fa2944b8f
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/spec/loads.isle
@@ -0,0 +1,757 @@
+;; GENERATED BY `isaspec`. DO NOT EDIT!!!
+
+(attr MInst.ULoad8 (tag isaspec_generated))
+
+(spec
+    (MInst.ULoad8 rd mem flags)
+    (modifies isa_load)
+    (provide
+        (match
+            mem
+            ((RegReg rn rm)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 8)
+                    (= (:addr isa_load) (bvadd rn rm))
+                    (= rd (zero_ext 64 (conv_to 8 loaded_value)))))
+            ((RegScaled rn rm)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 8)
+                    (= (:addr isa_load) (bvadd rn rm))
+                    (= rd (zero_ext 64 (conv_to 8 loaded_value)))))
+            ((RegScaledExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 8)
+                            (= (:addr isa_load) (bvadd rn (zero_ext 64 (extract 31 0 rm))))
+                            (= rd (zero_ext 64 (conv_to 8 loaded_value)))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 8)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 (extract 31 0 rm))))
+                            (= rd (zero_ext 64 (conv_to 8 loaded_value)))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 8)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 rm)))
+                            (= rd (zero_ext 64 (conv_to 8 loaded_value)))))))
+            ((RegExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 8)
+                            (= (:addr isa_load) (bvadd rn (zero_ext 64 (extract 31 0 rm))))
+                            (= rd (zero_ext 64 (conv_to 8 loaded_value)))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 8)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 (extract 31 0 rm))))
+                            (= rd (zero_ext 64 (conv_to 8 loaded_value)))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 8)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 rm)))
+                            (= rd (zero_ext 64 (conv_to 8 loaded_value)))))))
+            ((Unscaled rn simm9)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 8)
+                    (= (:addr isa_load) (bvadd rn (sign_ext 64 (extract 8 0 simm9))))
+                    (= rd (zero_ext 64 (conv_to 8 loaded_value)))))
+            ((UnsignedOffset rn uimm12)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 8)
+                    (= (:addr isa_load) (bvadd rn (zero_ext 64 (extract 11 0 uimm12))))
+                    (= rd (zero_ext 64 (conv_to 8 loaded_value)))))))
+    (require
+        (match
+            mem
+            ((RegReg rn rm) true)
+            ((RegScaled rn rm) true)
+            ((RegScaledExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((RegExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((Unscaled rn simm9) true)
+            ((UnsignedOffset rn uimm12) true))))
+
+(attr MInst.SLoad8 (tag isaspec_generated))
+
+(spec
+    (MInst.SLoad8 rd mem flags)
+    (modifies isa_load)
+    (provide
+        (match
+            mem
+            ((RegReg rn rm)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 8)
+                    (= (:addr isa_load) (bvadd rn rm))
+                    (= rd (sign_ext 64 (conv_to 8 loaded_value)))))
+            ((RegScaled rn rm)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 8)
+                    (= (:addr isa_load) (bvadd rn rm))
+                    (= rd (sign_ext 64 (conv_to 8 loaded_value)))))
+            ((RegScaledExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 8)
+                            (= (:addr isa_load) (bvadd rn (zero_ext 64 (extract 31 0 rm))))
+                            (= rd (sign_ext 64 (conv_to 8 loaded_value)))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 8)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 (extract 31 0 rm))))
+                            (= rd (sign_ext 64 (conv_to 8 loaded_value)))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 8)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 rm)))
+                            (= rd (sign_ext 64 (conv_to 8 loaded_value)))))))
+            ((RegExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 8)
+                            (= (:addr isa_load) (bvadd rn (zero_ext 64 (extract 31 0 rm))))
+                            (= rd (sign_ext 64 (conv_to 8 loaded_value)))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 8)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 (extract 31 0 rm))))
+                            (= rd (sign_ext 64 (conv_to 8 loaded_value)))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 8)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 rm)))
+                            (= rd (sign_ext 64 (conv_to 8 loaded_value)))))))
+            ((Unscaled rn simm9)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 8)
+                    (= (:addr isa_load) (bvadd rn (sign_ext 64 (extract 8 0 simm9))))
+                    (= rd (sign_ext 64 (conv_to 8 loaded_value)))))
+            ((UnsignedOffset rn uimm12)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 8)
+                    (= (:addr isa_load) (bvadd rn (zero_ext 64 (extract 11 0 uimm12))))
+                    (= rd (sign_ext 64 (conv_to 8 loaded_value)))))))
+    (require
+        (match
+            mem
+            ((RegReg rn rm) true)
+            ((RegScaled rn rm) true)
+            ((RegScaledExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((RegExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((Unscaled rn simm9) true)
+            ((UnsignedOffset rn uimm12) true))))
+
+(attr MInst.ULoad16 (tag isaspec_generated))
+
+(spec
+    (MInst.ULoad16 rd mem flags)
+    (modifies isa_load)
+    (provide
+        (match
+            mem
+            ((RegReg rn rm)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 16)
+                    (= (:addr isa_load) (bvadd rn rm))
+                    (= rd (zero_ext 64 (conv_to 16 loaded_value)))))
+            ((RegScaled rn rm)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 16)
+                    (= (:addr isa_load) (bvadd rn (concat (extract 62 0 rm) #b0)))
+                    (= rd (zero_ext 64 (conv_to 16 loaded_value)))))
+            ((RegScaledExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 16)
+                            (= (:addr isa_load) (bvadd rn (zero_ext 64 (concat (extract 31 0 rm) #b0))))
+                            (= rd (zero_ext 64 (conv_to 16 loaded_value)))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 16)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 (concat (extract 31 0 rm) #b0))))
+                            (= rd (zero_ext 64 (conv_to 16 loaded_value)))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 16)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 (concat (extract 62 0 rm) #b0))))
+                            (= rd (zero_ext 64 (conv_to 16 loaded_value)))))))
+            ((RegExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 16)
+                            (= (:addr isa_load) (bvadd rn (zero_ext 64 (extract 31 0 rm))))
+                            (= rd (zero_ext 64 (conv_to 16 loaded_value)))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 16)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 (extract 31 0 rm))))
+                            (= rd (zero_ext 64 (conv_to 16 loaded_value)))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 16)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 rm)))
+                            (= rd (zero_ext 64 (conv_to 16 loaded_value)))))))
+            ((Unscaled rn simm9)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 16)
+                    (= (:addr isa_load) (bvadd rn (sign_ext 64 (extract 8 0 simm9))))
+                    (= rd (zero_ext 64 (conv_to 16 loaded_value)))))
+            ((UnsignedOffset rn uimm12)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 16)
+                    (= (:addr isa_load) (bvadd rn (concat (zero_ext 63 (extract 11 0 uimm12)) #b0)))
+                    (= rd (zero_ext 64 (conv_to 16 loaded_value)))))))
+    (require
+        (match
+            mem
+            ((RegReg rn rm) true)
+            ((RegScaled rn rm) true)
+            ((RegScaledExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((RegExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((Unscaled rn simm9) true)
+            ((UnsignedOffset rn uimm12) true))))
+
+(attr MInst.SLoad16 (tag isaspec_generated))
+
+(spec
+    (MInst.SLoad16 rd mem flags)
+    (modifies isa_load)
+    (provide
+        (match
+            mem
+            ((RegReg rn rm)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 16)
+                    (= (:addr isa_load) (bvadd rn rm))
+                    (= rd (sign_ext 64 (conv_to 16 loaded_value)))))
+            ((RegScaled rn rm)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 16)
+                    (= (:addr isa_load) (bvadd rn (concat (extract 62 0 rm) #b0)))
+                    (= rd (sign_ext 64 (conv_to 16 loaded_value)))))
+            ((RegScaledExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 16)
+                            (= (:addr isa_load) (bvadd rn (zero_ext 64 (concat (extract 31 0 rm) #b0))))
+                            (= rd (sign_ext 64 (conv_to 16 loaded_value)))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 16)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 (concat (extract 31 0 rm) #b0))))
+                            (= rd (sign_ext 64 (conv_to 16 loaded_value)))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 16)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 (concat (extract 62 0 rm) #b0))))
+                            (= rd (sign_ext 64 (conv_to 16 loaded_value)))))))
+            ((RegExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 16)
+                            (= (:addr isa_load) (bvadd rn (zero_ext 64 (extract 31 0 rm))))
+                            (= rd (sign_ext 64 (conv_to 16 loaded_value)))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 16)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 (extract 31 0 rm))))
+                            (= rd (sign_ext 64 (conv_to 16 loaded_value)))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 16)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 rm)))
+                            (= rd (sign_ext 64 (conv_to 16 loaded_value)))))))
+            ((Unscaled rn simm9)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 16)
+                    (= (:addr isa_load) (bvadd rn (sign_ext 64 (extract 8 0 simm9))))
+                    (= rd (sign_ext 64 (conv_to 16 loaded_value)))))
+            ((UnsignedOffset rn uimm12)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 16)
+                    (= (:addr isa_load) (bvadd rn (concat (zero_ext 63 (extract 11 0 uimm12)) #b0)))
+                    (= rd (sign_ext 64 (conv_to 16 loaded_value)))))))
+    (require
+        (match
+            mem
+            ((RegReg rn rm) true)
+            ((RegScaled rn rm) true)
+            ((RegScaledExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((RegExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((Unscaled rn simm9) true)
+            ((UnsignedOffset rn uimm12) true))))
+
+(attr MInst.ULoad32 (tag isaspec_generated))
+
+(spec
+    (MInst.ULoad32 rd mem flags)
+    (modifies isa_load)
+    (provide
+        (match
+            mem
+            ((RegReg rn rm)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 32)
+                    (= (:addr isa_load) (bvadd rn rm))
+                    (= rd (zero_ext 64 (conv_to 32 loaded_value)))))
+            ((RegScaled rn rm)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 32)
+                    (= (:addr isa_load) (bvadd rn (concat (extract 61 0 rm) #b00)))
+                    (= rd (zero_ext 64 (conv_to 32 loaded_value)))))
+            ((RegScaledExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 32)
+                            (= (:addr isa_load) (bvadd rn (zero_ext 64 (concat (extract 31 0 rm) #b00))))
+                            (= rd (zero_ext 64 (conv_to 32 loaded_value)))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 32)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 (concat (extract 31 0 rm) #b00))))
+                            (= rd (zero_ext 64 (conv_to 32 loaded_value)))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 32)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 (concat (extract 61 0 rm) #b00))))
+                            (= rd (zero_ext 64 (conv_to 32 loaded_value)))))))
+            ((RegExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 32)
+                            (= (:addr isa_load) (bvadd rn (zero_ext 64 (extract 31 0 rm))))
+                            (= rd (zero_ext 64 (conv_to 32 loaded_value)))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 32)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 (extract 31 0 rm))))
+                            (= rd (zero_ext 64 (conv_to 32 loaded_value)))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 32)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 rm)))
+                            (= rd (zero_ext 64 (conv_to 32 loaded_value)))))))
+            ((Unscaled rn simm9)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 32)
+                    (= (:addr isa_load) (bvadd rn (sign_ext 64 (extract 8 0 simm9))))
+                    (= rd (zero_ext 64 (conv_to 32 loaded_value)))))
+            ((UnsignedOffset rn uimm12)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 32)
+                    (= (:addr isa_load) (bvadd rn (concat (zero_ext 62 (extract 11 0 uimm12)) #b00)))
+                    (= rd (zero_ext 64 (conv_to 32 loaded_value)))))))
+    (require
+        (match
+            mem
+            ((RegReg rn rm) true)
+            ((RegScaled rn rm) true)
+            ((RegScaledExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((RegExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((Unscaled rn simm9) true)
+            ((UnsignedOffset rn uimm12) true))))
+
+(attr MInst.SLoad32 (tag isaspec_generated))
+
+(spec
+    (MInst.SLoad32 rd mem flags)
+    (modifies isa_load)
+    (provide
+        (match
+            mem
+            ((RegReg rn rm)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 32)
+                    (= (:addr isa_load) (bvadd rn rm))
+                    (= rd (sign_ext 64 (conv_to 32 loaded_value)))))
+            ((RegScaled rn rm)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 32)
+                    (= (:addr isa_load) (bvadd rn (concat (extract 61 0 rm) #b00)))
+                    (= rd (sign_ext 64 (conv_to 32 loaded_value)))))
+            ((RegScaledExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 32)
+                            (= (:addr isa_load) (bvadd rn (zero_ext 64 (concat (extract 31 0 rm) #b00))))
+                            (= rd (sign_ext 64 (conv_to 32 loaded_value)))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 32)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 (concat (extract 31 0 rm) #b00))))
+                            (= rd (sign_ext 64 (conv_to 32 loaded_value)))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 32)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 (concat (extract 61 0 rm) #b00))))
+                            (= rd (sign_ext 64 (conv_to 32 loaded_value)))))))
+            ((RegExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 32)
+                            (= (:addr isa_load) (bvadd rn (zero_ext 64 (extract 31 0 rm))))
+                            (= rd (sign_ext 64 (conv_to 32 loaded_value)))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 32)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 (extract 31 0 rm))))
+                            (= rd (sign_ext 64 (conv_to 32 loaded_value)))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 32)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 rm)))
+                            (= rd (sign_ext 64 (conv_to 32 loaded_value)))))))
+            ((Unscaled rn simm9)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 32)
+                    (= (:addr isa_load) (bvadd rn (sign_ext 64 (extract 8 0 simm9))))
+                    (= rd (sign_ext 64 (conv_to 32 loaded_value)))))
+            ((UnsignedOffset rn uimm12)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 32)
+                    (= (:addr isa_load) (bvadd rn (concat (zero_ext 62 (extract 11 0 uimm12)) #b00)))
+                    (= rd (sign_ext 64 (conv_to 32 loaded_value)))))))
+    (require
+        (match
+            mem
+            ((RegReg rn rm) true)
+            ((RegScaled rn rm) true)
+            ((RegScaledExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((RegExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((Unscaled rn simm9) true)
+            ((UnsignedOffset rn uimm12) true))))
+
+(attr MInst.ULoad64 (tag isaspec_generated))
+
+(spec
+    (MInst.ULoad64 rd mem flags)
+    (modifies isa_load)
+    (provide
+        (match
+            mem
+            ((RegReg rn rm)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 64)
+                    (= (:addr isa_load) (bvadd rn rm))
+                    (= rd (conv_to 64 loaded_value))))
+            ((RegScaled rn rm)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 64)
+                    (= (:addr isa_load) (bvadd rn (concat (extract 60 0 rm) #b000)))
+                    (= rd (conv_to 64 loaded_value))))
+            ((RegScaledExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 64)
+                            (= (:addr isa_load) (bvadd rn (zero_ext 64 (concat (extract 31 0 rm) #b000))))
+                            (= rd (conv_to 64 loaded_value))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 64)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 (concat (extract 31 0 rm) #b000))))
+                            (= rd (conv_to 64 loaded_value))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 64)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 (concat (extract 60 0 rm) #b000))))
+                            (= rd (conv_to 64 loaded_value))))))
+            ((RegExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 64)
+                            (= (:addr isa_load) (bvadd rn (zero_ext 64 (extract 31 0 rm))))
+                            (= rd (conv_to 64 loaded_value))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 64)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 (extract 31 0 rm))))
+                            (= rd (conv_to 64 loaded_value))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 64)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 rm)))
+                            (= rd (conv_to 64 loaded_value))))))
+            ((Unscaled rn simm9)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 64)
+                    (= (:addr isa_load) (bvadd rn (sign_ext 64 (extract 8 0 simm9))))
+                    (= rd (conv_to 64 loaded_value))))
+            ((UnsignedOffset rn uimm12)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 64)
+                    (= (:addr isa_load) (bvadd rn (concat (zero_ext 61 (extract 11 0 uimm12)) #b000)))
+                    (= rd (conv_to 64 loaded_value))))))
+    (require
+        (match
+            mem
+            ((RegReg rn rm) true)
+            ((RegScaled rn rm) true)
+            ((RegScaledExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((RegExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((Unscaled rn simm9) true)
+            ((UnsignedOffset rn uimm12) true))))
+
+(attr MInst.FpuLoad32 (tag isaspec_generated))
+
+(spec
+    (MInst.FpuLoad32 rd mem flags)
+    (modifies isa_load)
+    (provide
+        (match
+            mem
+            ((RegReg rn rm)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 32)
+                    (= (:addr isa_load) (bvadd rn rm))
+                    (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 (conv_to 32 loaded_value)))))
+            ((RegScaled rn rm)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 32)
+                    (= (:addr isa_load) (bvadd rn (concat (extract 61 0 rm) #b00)))
+                    (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 (conv_to 32 loaded_value)))))
+            ((RegScaledExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 32)
+                            (= (:addr isa_load) (bvadd rn (zero_ext 64 (concat (extract 31 0 rm) #b00))))
+                            (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 (conv_to 32 loaded_value)))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 32)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 (concat (extract 31 0 rm) #b00))))
+                            (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 (conv_to 32 loaded_value)))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 32)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 (concat (extract 61 0 rm) #b00))))
+                            (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 (conv_to 32 loaded_value)))))))
+            ((RegExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 32)
+                            (= (:addr isa_load) (bvadd rn (zero_ext 64 (extract 31 0 rm))))
+                            (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 (conv_to 32 loaded_value)))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 32)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 (extract 31 0 rm))))
+                            (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 (conv_to 32 loaded_value)))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 32)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 rm)))
+                            (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 (conv_to 32 loaded_value)))))))
+            ((Unscaled rn simm9)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 32)
+                    (= (:addr isa_load) (bvadd rn (sign_ext 64 (extract 8 0 simm9))))
+                    (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 (conv_to 32 loaded_value)))))
+            ((UnsignedOffset rn uimm12)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 32)
+                    (= (:addr isa_load) (bvadd rn (concat (zero_ext 62 (extract 11 0 uimm12)) #b00)))
+                    (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 (conv_to 32 loaded_value)))))))
+    (require
+        (match
+            mem
+            ((RegReg rn rm) true)
+            ((RegScaled rn rm) true)
+            ((RegScaledExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((RegExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((Unscaled rn simm9) true)
+            ((UnsignedOffset rn uimm12) true))))
+
+(attr MInst.FpuLoad64 (tag isaspec_generated))
+
+(spec
+    (MInst.FpuLoad64 rd mem flags)
+    (modifies isa_load)
+    (provide
+        (match
+            mem
+            ((RegReg rn rm)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 64)
+                    (= (:addr isa_load) (bvadd rn rm))
+                    (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 (conv_to 64 loaded_value)))))
+            ((RegScaled rn rm)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 64)
+                    (= (:addr isa_load) (bvadd rn (concat (extract 60 0 rm) #b000)))
+                    (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 (conv_to 64 loaded_value)))))
+            ((RegScaledExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 64)
+                            (= (:addr isa_load) (bvadd rn (zero_ext 64 (concat (extract 31 0 rm) #b000))))
+                            (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 (conv_to 64 loaded_value)))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 64)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 (concat (extract 31 0 rm) #b000))))
+                            (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 (conv_to 64 loaded_value)))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 64)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 (concat (extract 60 0 rm) #b000))))
+                            (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 (conv_to 64 loaded_value)))))))
+            ((RegExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 64)
+                            (= (:addr isa_load) (bvadd rn (zero_ext 64 (extract 31 0 rm))))
+                            (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 (conv_to 64 loaded_value)))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 64)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 (extract 31 0 rm))))
+                            (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 (conv_to 64 loaded_value)))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_load) true)
+                            (= (:size_bits isa_load) 64)
+                            (= (:addr isa_load) (bvadd rn (sign_ext 64 rm)))
+                            (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 (conv_to 64 loaded_value)))))))
+            ((Unscaled rn simm9)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 64)
+                    (= (:addr isa_load) (bvadd rn (sign_ext 64 (extract 8 0 simm9))))
+                    (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 (conv_to 64 loaded_value)))))
+            ((UnsignedOffset rn uimm12)
+                (and
+                    (= (:active isa_load) true)
+                    (= (:size_bits isa_load) 64)
+                    (= (:addr isa_load) (bvadd rn (concat (zero_ext 61 (extract 11 0 uimm12)) #b000)))
+                    (= (conv_to 128 (as rd (bv 64))) (zero_ext 128 (conv_to 64 loaded_value)))))))
+    (require
+        (match
+            mem
+            ((RegReg rn rm) true)
+            ((RegScaled rn rm) true)
+            ((RegScaledExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((RegExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((Unscaled rn simm9) true)
+            ((UnsignedOffset rn uimm12) true))))
diff --git a/cranelift/codegen/src/isa/aarch64/spec/mov_from_vec.isle b/cranelift/codegen/src/isa/aarch64/spec/mov_from_vec.isle
new file mode 100644
index 000000000000..9b44e05abfc4
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/spec/mov_from_vec.isle
@@ -0,0 +1,80 @@
+;; GENERATED BY `isaspec`. DO NOT EDIT!!!
+
+(attr MInst.MovFromVec (tag isaspec_generated))
+
+(spec
+    (MInst.MovFromVec rd rn idx size)
+    (provide
+        (match
+            size
+            ((Size64)
+                (and
+                    (=> (= idx #x00) (= rd (extract 63 0 (as rn (bv 128)))))
+                    (=> (= idx #x01) (= rd (extract 127 64 (as rn (bv 128)))))))
+            ((Size32)
+                (and
+                    (=> (= idx #x00) (= rd (zero_ext 64 (extract 31 0 (as rn (bv 128))))))
+                    (=> (= idx #x01) (= rd (zero_ext 64 (extract 63 32 (as rn (bv 128))))))
+                    (=> (= idx #x02) (= rd (zero_ext 64 (extract 95 64 (as rn (bv 128))))))
+                    (=> (= idx #x03) (= rd (zero_ext 64 (extract 127 96 (as rn (bv 128))))))))
+            ((Size16)
+                (and
+                    (=> (= idx #x00) (= rd (zero_ext 64 (extract 15 0 (as rn (bv 128))))))
+                    (=> (= idx #x01) (= rd (zero_ext 64 (extract 31 16 (as rn (bv 128))))))
+                    (=> (= idx #x02) (= rd (zero_ext 64 (extract 47 32 (as rn (bv 128))))))
+                    (=> (= idx #x03) (= rd (zero_ext 64 (extract 63 48 (as rn (bv 128))))))
+                    (=> (= idx #x04) (= rd (zero_ext 64 (extract 79 64 (as rn (bv 128))))))
+                    (=> (= idx #x05) (= rd (zero_ext 64 (extract 95 80 (as rn (bv 128))))))
+                    (=> (= idx #x06) (= rd (zero_ext 64 (extract 111 96 (as rn (bv 128))))))
+                    (=> (= idx #x07) (= rd (zero_ext 64 (extract 127 112 (as rn (bv 128))))))))
+            ((Size8)
+                (and
+                    (=> (= idx #x00) (= rd (zero_ext 64 (extract 7 0 (as rn (bv 128))))))
+                    (=> (= idx #x01) (= rd (zero_ext 64 (extract 15 8 (as rn (bv 128))))))
+                    (=> (= idx #x02) (= rd (zero_ext 64 (extract 23 16 (as rn (bv 128))))))
+                    (=> (= idx #x03) (= rd (zero_ext 64 (extract 31 24 (as rn (bv 128))))))
+                    (=> (= idx #x04) (= rd (zero_ext 64 (extract 39 32 (as rn (bv 128))))))
+                    (=> (= idx #x05) (= rd (zero_ext 64 (extract 47 40 (as rn (bv 128))))))
+                    (=> (= idx #x06) (= rd (zero_ext 64 (extract 55 48 (as rn (bv 128))))))
+                    (=> (= idx #x07) (= rd (zero_ext 64 (extract 63 56 (as rn (bv 128))))))
+                    (=> (= idx #x08) (= rd (zero_ext 64 (extract 71 64 (as rn (bv 128))))))
+                    (=> (= idx #x09) (= rd (zero_ext 64 (extract 79 72 (as rn (bv 128))))))
+                    (=> (= idx #x0a) (= rd (zero_ext 64 (extract 87 80 (as rn (bv 128))))))
+                    (=> (= idx #x0b) (= rd (zero_ext 64 (extract 95 88 (as rn (bv 128))))))
+                    (=> (= idx #x0c) (= rd (zero_ext 64 (extract 103 96 (as rn (bv 128))))))
+                    (=> (= idx #x0d) (= rd (zero_ext 64 (extract 111 104 (as rn (bv 128))))))
+                    (=> (= idx #x0e) (= rd (zero_ext 64 (extract 119 112 (as rn (bv 128))))))
+                    (=> (= idx #x0f) (= rd (zero_ext 64 (extract 127 120 (as rn (bv 128))))))))))
+    (require
+        (match
+            size
+            ((Size64) (or (= idx #x00) (= idx #x01)))
+            ((Size32) (or (= idx #x00) (= idx #x01) (= idx #x02) (= idx #x03)))
+            ((Size16)
+                (or
+                    (= idx #x00)
+                    (= idx #x01)
+                    (= idx #x02)
+                    (= idx #x03)
+                    (= idx #x04)
+                    (= idx #x05)
+                    (= idx #x06)
+                    (= idx #x07)))
+            ((Size8)
+                (or
+                    (= idx #x00)
+                    (= idx #x01)
+                    (= idx #x02)
+                    (= idx #x03)
+                    (= idx #x04)
+                    (= idx #x05)
+                    (= idx #x06)
+                    (= idx #x07)
+                    (= idx #x08)
+                    (= idx #x09)
+                    (= idx #x0a)
+                    (= idx #x0b)
+                    (= idx #x0c)
+                    (= idx #x0d)
+                    (= idx #x0e)
+                    (= idx #x0f))))))
diff --git a/cranelift/codegen/src/isa/aarch64/spec/mov_to_fpu.isle b/cranelift/codegen/src/isa/aarch64/spec/mov_to_fpu.isle
new file mode 100644
index 000000000000..e0893f7462fe
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/spec/mov_to_fpu.isle
@@ -0,0 +1,13 @@
+;; GENERATED BY `isaspec`. DO NOT EDIT!!!
+
+(attr MInst.MovToFpu (tag isaspec_generated))
+
+(spec
+    (MInst.MovToFpu rd rn size)
+    (provide
+        (match
+            size
+            ((Size64) (= rd (zero_ext 128 (as rn (bv 64)))))
+            ((Size32) (= rd (zero_ext 128 (extract 31 0 (as rn (bv 64))))))
+            ((Size16) (= rd (zero_ext 128 (extract 15 0 (as rn (bv 64))))))))
+    (require (match size ((Size64) true) ((Size32) true) ((Size16) true))))
diff --git a/cranelift/codegen/src/isa/aarch64/spec/mov_wide.isle b/cranelift/codegen/src/isa/aarch64/spec/mov_wide.isle
new file mode 100644
index 000000000000..35a579778c2f
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/spec/mov_wide.isle
@@ -0,0 +1,62 @@
+;; GENERATED BY `isaspec`. DO NOT EDIT!!!
+
+(attr MInst.MovWide (tag isaspec_generated))
+
+(spec
+    (MInst.MovWide op rd imm size)
+    (provide
+        (match
+            size
+            ((Size64)
+                (match
+                    op
+                    ((MovZ)
+                        (and
+                            (=> (= (:shift imm) #b00) (= rd (zero_ext 64 (extract 15 0 (:bits imm)))))
+                            (=> (= (:shift imm) #b01) (= rd (zero_ext 64 (concat (extract 15 0 (:bits imm)) #x0000))))
+                            (=>
+                                (= (:shift imm) #b10)
+                                (= rd (zero_ext 64 (concat (extract 15 0 (:bits imm)) #x00000000))))
+                            (=> (= (:shift imm) #b11) (= rd (concat (extract 15 0 (:bits imm)) #x000000000000)))))
+                    ((MovN)
+                        (and
+                            (=> (= (:shift imm) #b00) (= rd (bvnot (zero_ext 64 (extract 15 0 (:bits imm))))))
+                            (=>
+                                (= (:shift imm) #b01)
+                                (= rd (bvnot (zero_ext 64 (concat (extract 15 0 (:bits imm)) #x0000)))))
+                            (=>
+                                (= (:shift imm) #b10)
+                                (= rd (bvnot (zero_ext 64 (concat (extract 15 0 (:bits imm)) #x00000000)))))
+                            (=>
+                                (= (:shift imm) #b11)
+                                (= rd (bvnot (concat (extract 15 0 (:bits imm)) #x000000000000))))))))
+            ((Size32)
+                (match
+                    op
+                    ((MovZ)
+                        (and
+                            (=> (= (:shift imm) #b00) (= rd (zero_ext 64 (extract 15 0 (:bits imm)))))
+                            (=> (= (:shift imm) #b01) (= rd (zero_ext 64 (concat (extract 15 0 (:bits imm)) #x0000))))))
+                    ((MovN)
+                        (and
+                            (=>
+                                (= (:shift imm) #b00)
+                                (= rd (zero_ext 64 (bvnot (zero_ext 32 (extract 15 0 (:bits imm)))))))
+                            (=>
+                                (= (:shift imm) #b01)
+                                (= rd (zero_ext 64 (bvnot (concat (extract 15 0 (:bits imm)) #x0000)))))))))))
+    (require
+        (match
+            size
+            ((Size64)
+                (match
+                    op
+                    ((MovZ)
+                        (or (= (:shift imm) #b00) (= (:shift imm) #b01) (= (:shift imm) #b10) (= (:shift imm) #b11)))
+                    ((MovN)
+                        (or (= (:shift imm) #b00) (= (:shift imm) #b01) (= (:shift imm) #b10) (= (:shift imm) #b11)))))
+            ((Size32)
+                (match
+                    op
+                    ((MovZ) (or (= (:shift imm) #b00) (= (:shift imm) #b01)))
+                    ((MovN) (or (= (:shift imm) #b00) (= (:shift imm) #b01))))))))
diff --git a/cranelift/codegen/src/isa/aarch64/spec/primitives.isle b/cranelift/codegen/src/isa/aarch64/spec/primitives.isle
new file mode 100644
index 000000000000..2d32cc4df5ea
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/spec/primitives.isle
@@ -0,0 +1,860 @@
+;; ASLp primitive function definitions.
+
+; Floating point primitives for AArch64 adapted from "Arm A-profile A64
+; Instruction Set Architecture" shared pseudocode definitions.
+;
+; See: https://developer.arm.com/documentation/ddi0602/2024-09/Shared-Pseudocode/shared-functions-float
+
+; // FPDefaultNaN()
+; // ==============
+;
+; bits(N) FPDefaultNaN(FPCR_Type fpcr, integer N)
+;     assert N IN {16,32,64};
+;     constant integer E = (if N == 16 then 5 elsif N == 32 then 8 else 11);
+;     constant integer F = N - (E + 1);
+;     constant bit sign = if IsFeatureImplemented(FEAT_AFP) && !UsingAArch32() then fpcr.AH else '0';
+;
+;     constant bits(E) exp  = Ones(E);
+;     constant bits(F) frac = '1':Zeros(F-1);
+;     return sign : exp : frac;
+(macro (FPDefaultNaN w)
+    (conv_to w
+        (switch w
+            (32 #x000000007fc00000)
+            (64 #x7ff8000000000000)
+        )
+    )
+)
+
+; // FPProcessNaN()
+; // ==============
+; // Handle NaN input operands, returning the operand or default NaN value
+; // if fpcr.DN is selected. The 'fpcr' argument supplies the FPCR control bits.
+; // The 'fpexc' argument controls the generation of exceptions, regardless of
+; // whether 'fptype' is a signalling NaN or a quiet NaN.
+;
+; bits(N) FPProcessNaN(FPType fptype, bits(N) op, FPCR_Type fpcr, boolean fpexc)
+;     assert N IN {16,32,64};
+;     assert fptype IN {FPType_QNaN, FPType_SNaN};
+;     integer topfrac;
+;
+;     case N of
+;         when 16 topfrac =  9;
+;         when 32 topfrac = 22;
+;         when 64 topfrac = 51;
+;
+;     result = op;
+;     if fptype == FPType_SNaN then
+;         result<topfrac> = '1';
+;         if fpexc then FPProcessException(FPExc_InvalidOp, fpcr);
+;     if fpcr.DN == '1' then  // DefaultNaN requested
+;         result = FPDefaultNaN(fpcr, N);
+;     return result;
+(macro (FPProcessNaN x) (bvor x (fp_topfrac_bit_set! (widthof x))))
+
+; // FPProcessNaNs()
+; // ===============
+; //
+; // The boolean part of the return value says whether a NaN has been found and
+; // processed. The bits(N) part is only relevant if it has and supplies the
+; // result of the operation.
+; //
+; // The 'fpcr' argument supplies FPCR control bits and 'altfmaxfmin' controls
+; // alternative floating-point behavior for FMAX, FMIN and variants. 'fpexc'
+; // controls the generation of floating-point exceptions. Status information
+; // is updated directly in the FPSR where appropriate.
+;
+; (boolean, bits(N)) FPProcessNaNs(FPType type1, FPType type2, bits(N) op1, bits(N) op2,
+;                                  FPCR_Type fpcr, boolean fpexc)
+;     assert N IN {16,32,64};
+;     boolean done;
+;     bits(N) result;
+;     constant boolean altfp    = IsFeatureImplemented(FEAT_AFP) && !UsingAArch32() && fpcr.AH == '1';
+;     constant boolean op1_nan  = type1 IN {FPType_SNaN, FPType_QNaN};
+;     constant boolean op2_nan  = type2 IN {FPType_SNaN, FPType_QNaN};
+;     constant boolean any_snan = type1 == FPType_SNaN || type2 == FPType_SNaN;
+;     constant FPType  type_nan = if any_snan then FPType_SNaN else FPType_QNaN;
+;
+;     if altfp && op1_nan && op2_nan then
+;         // <n> register NaN selected
+;         done = TRUE;  result = FPProcessNaN(type_nan, op1, fpcr, fpexc);
+;     elsif type1 == FPType_SNaN then
+;         done = TRUE;  result = FPProcessNaN(type1, op1, fpcr, fpexc);
+;     elsif type2 == FPType_SNaN then
+;         done = TRUE;  result = FPProcessNaN(type2, op2, fpcr, fpexc);
+;     elsif type1 == FPType_QNaN then
+;         done = TRUE;  result = FPProcessNaN(type1, op1, fpcr, fpexc);
+;     elsif type2 == FPType_QNaN then
+;         done = TRUE;  result = FPProcessNaN(type2, op2, fpcr, fpexc);
+;     else
+;         done = FALSE;  result = Zeros(N);  // 'Don't care' result
+;     return (done, result);
+;
+; Note: spec included for reference, details are inlined in FPAdd.
+
+;; FPAdd: Floating point addition
+(macro (FPAdd x y fpcr)
+    ; // FPAdd()
+    ; // =======
+    ;
+    ; bits(N) FPAdd(bits(N) op1, bits(N) op2, FPCR_Type fpcr, boolean fpexc)
+    ;
+    ;     assert N IN {16,32,64};
+    ;     rounding = FPRoundingMode(fpcr);
+    ;
+    ;     (type1,sign1,value1) = FPUnpack(op1, fpcr, fpexc);
+    ;     (type2,sign2,value2) = FPUnpack(op2, fpcr, fpexc);
+    (let
+        (
+            (sign1 (fp.isNegative x))
+            (sign2 (fp.isNegative y))
+        )
+    ;
+    ;     (done,result) = FPProcessNaNs(type1, type2, op1, op2, fpcr, fpexc);
+        (if (fp.isNaN x)
+            (FPProcessNaN! x)
+        (if (fp.isNaN y)
+            (FPProcessNaN! y)
+    ;     if !done then
+    ;         inf1  = (type1 == FPType_Infinity);  inf2  = (type2 == FPType_Infinity);
+    ;         zero1 = (type1 == FPType_Zero);      zero2 = (type2 == FPType_Zero);
+            (let
+                (
+                    (inf1 (fp.isInfinite x))
+                    (inf2 (fp.isInfinite y))
+                    (zero1 (fp.isZero x))
+                    (zero2 (fp.isZero y))
+                )
+    ;         if inf1 && inf2 && sign1 == NOT(sign2) then
+    ;             result = FPDefaultNaN(fpcr, N);
+    ;             if fpexc then FPProcessException(FPExc_InvalidOp, fpcr);
+                (if (and inf1 inf2 (= sign1 (not sign2)))
+                    (FPDefaultNaN! (widthof x))
+    ;         elsif (inf1 && sign1 == '0') || (inf2 && sign2 == '0') then
+    ;             result = FPInfinity('0', N);
+                (if (or (and inf1 (not sign1)) (and inf2 (not sign2)))
+                    (fp.+oo (widthof x))
+    ;         elsif (inf1 && sign1 == '1') || (inf2 && sign2 == '1') then
+    ;             result = FPInfinity('1', N);
+                (if (or (and inf1 sign1) (and inf2 sign2))
+                    (fp.-oo (widthof x))
+    ;         elsif zero1 && zero2 && sign1 == sign2 then
+    ;             result = FPZero(sign1, N);
+                (if (and zero1 zero2 (= sign1 sign2))
+                    (fp_signed_zero! sign1 (widthof x))
+    ;         else
+    ;             result_value = value1 + value2;
+    ;             if result_value == 0.0 then  // Sign of exact zero result depends on rounding mode
+    ;                 result_sign = if rounding == FPRounding_NEGINF then '1' else '0';
+    ;                 result = FPZero(result_sign, N);
+    ;             else
+    ;                 result = FPRound(result_value, fpcr, rounding, fpexc, N);
+                    (let ((result (fp.add x y)))
+                        (if (fp.isZero result)
+                            (fp.+zero (widthof result))
+                            result
+                        )
+                    )
+    ;
+    ;         if fpexc then FPProcessDenorms(type1, type2, N, fpcr);
+    ;     return result;
+                ))))
+            )
+        ))
+    )
+)
+
+;; FPSub: Floating point subtraction
+(macro (FPSub x y fpcr)
+    ; // FPSub()
+    ; // =======
+    ;
+    ; bits(N) FPSub(bits(N) op1, bits(N) op2, FPCR_Type fpcr, boolean fpexc)
+    ;
+    ;     assert N IN {16,32,64};
+    ;     rounding = FPRoundingMode(fpcr);
+    ;
+    ;     (type1,sign1,value1) = FPUnpack(op1, fpcr, fpexc);
+    ;     (type2,sign2,value2) = FPUnpack(op2, fpcr, fpexc);
+    (let
+        (
+            (sign1 (fp.isNegative x))
+            (sign2 (fp.isNegative y))
+        )
+    ;
+    ;     (done,result) = FPProcessNaNs(type1, type2, op1, op2, fpcr, fpexc);
+        (if (fp.isNaN x)
+            (FPProcessNaN! x)
+        (if (fp.isNaN y)
+            (FPProcessNaN! y)
+    ;     if !done then
+    ;         inf1  = (type1 == FPType_Infinity);  inf2  = (type2 == FPType_Infinity);
+    ;         zero1 = (type1 == FPType_Zero);      zero2 = (type2 == FPType_Zero);
+            (let
+                (
+                    (inf1 (fp.isInfinite x))
+                    (inf2 (fp.isInfinite y))
+                    (zero1 (fp.isZero x))
+                    (zero2 (fp.isZero y))
+                )
+    ;         if inf1 && inf2 && sign1 == sign2 then
+    ;             result = FPDefaultNaN(fpcr, N);
+    ;             if fpexc then FPProcessException(FPExc_InvalidOp, fpcr);
+                (if (and inf1 inf2 (= sign1 sign2))
+                    (FPDefaultNaN! (widthof x))
+    ;         elsif (inf1 && sign1 == '0') || (inf2 && sign2 == '1') then
+    ;             result = FPInfinity('0', N);
+                (if (or (and inf1 (not sign1)) (and inf2 sign2))
+                    (fp.+oo (widthof x))
+    ;         elsif (inf1 && sign1 == '1') || (inf2 && sign2 == '0') then
+    ;             result = FPInfinity('1', N);
+                (if (or (and inf1 sign1) (and inf2 (not sign2)))
+                    (fp.-oo (widthof x))
+    ;         elsif zero1 && zero2 && sign1 == NOT(sign2) then
+    ;             result = FPZero(sign1, N);
+                (if (and zero1 zero2 (= sign1 (not sign2)))
+                    (fp_signed_zero! sign1 (widthof x))
+    ;         else
+    ;             result_value = value1 - value2;
+    ;             if result_value == 0.0 then  // Sign of exact zero result depends on rounding mode
+    ;                 result_sign = if rounding == FPRounding_NEGINF then '1' else '0';
+    ;                 result = FPZero(result_sign, N);
+    ;             else
+    ;                 result = FPRound(result_value, fpcr, rounding, fpexc, N);
+                    (let ((result (fp.sub x y)))
+                        (if (fp.isZero result)
+                            (fp.+zero (widthof result))
+                            result
+                        )
+                    )
+    ;
+    ;         if fpexc then FPProcessDenorms(type1, type2, N, fpcr);
+    ;     return result;
+                ))))
+            )
+        ))
+    )
+)
+
+;; FPMul: Floating point multiplication
+(macro (FPMul x y fpcr)
+    ; // FPMul()
+    ; // =======
+    ;
+    ; bits(N) FPMul(bits(N) op1, bits(N) op2, FPCR_Type fpcr)
+    ;
+    ;     assert N IN {16,32,64};
+    ;
+    ;     (type1,sign1,value1) = FPUnpack(op1, fpcr);
+    ;     (type2,sign2,value2) = FPUnpack(op2, fpcr);
+    (let
+        (
+            (sign1 (fp.isNegative x))
+            (sign2 (fp.isNegative y))
+            (N (widthof x))
+        )
+    ;
+    ;     (done,result) = FPProcessNaNs(type1, type2, op1, op2, fpcr);
+        (if (fp.isNaN x)
+            (FPProcessNaN! x)
+        (if (fp.isNaN y)
+            (FPProcessNaN! y)
+    ;     if !done then
+    ;         inf1  = (type1 == FPType_Infinity);  inf2  = (type2 == FPType_Infinity);
+    ;         zero1 = (type1 == FPType_Zero);      zero2 = (type2 == FPType_Zero);
+            (let
+                (
+                    (inf1 (fp.isInfinite x))
+                    (inf2 (fp.isInfinite y))
+                    (zero1 (fp.isZero x))
+                    (zero2 (fp.isZero y))
+                )
+    ;         if (inf1 && zero2) || (zero1 && inf2) then
+    ;             result = FPDefaultNaN(fpcr, N);
+    ;             FPProcessException(FPExc_InvalidOp, fpcr);
+                (if (or (and inf1 zero2) (and zero1 inf2))
+                    (FPDefaultNaN! N)
+    ;         elsif inf1 || inf2 then
+    ;             result = FPInfinity(sign1 EOR sign2, N);
+                (if (or inf1 inf2)
+                    (fp_signed_inf! (xor! sign1 sign2) N)
+    ;          elsif zero1 || zero2 then
+    ;             result = FPZero(sign1 EOR sign2, N);
+                (if (or zero1 zero2)
+                    (fp_signed_zero! (xor! sign1 sign2) N)
+    ;       else
+    ;             result = FPRound(value1*value2, fpcr, N);
+                (fp.mul x y)
+    ;
+    ;         FPProcessDenorms(type1, type2, N, fpcr);
+    ;     return result;
+                )))
+            )
+        ))
+    )
+)
+
+;; FPDiv: Floating point division
+(macro (FPDiv x y fpcr)
+    ; // FPDiv()
+    ; // =======
+    ;
+    ; bits(N) FPDiv(bits(N) op1, bits(N) op2, FPCR_Type fpcr)
+    ;
+    ;     assert N IN {16,32,64};
+    ;
+    ;     (type1,sign1,value1) = FPUnpack(op1, fpcr);
+    ;     (type2,sign2,value2) = FPUnpack(op2, fpcr);
+    (let
+        (
+            (sign1 (fp.isNegative x))
+            (sign2 (fp.isNegative y))
+            (N (widthof x))
+        )
+    ;
+    ;     (done,result) = FPProcessNaNs(type1, type2, op1, op2, fpcr);
+        (if (fp.isNaN x)
+            (FPProcessNaN! x)
+        (if (fp.isNaN y)
+            (FPProcessNaN! y)
+    ;     if !done then
+    ;         inf1  = (type1 == FPType_Infinity);  inf2  = (type2 == FPType_Infinity);
+    ;         zero1 = (type1 == FPType_Zero);      zero2 = (type2 == FPType_Zero);
+            (let
+                (
+                    (inf1 (fp.isInfinite x))
+                    (inf2 (fp.isInfinite y))
+                    (zero1 (fp.isZero x))
+                    (zero2 (fp.isZero y))
+                )
+    ;          if (inf1 && inf2) || (zero1 && zero2) then
+    ;             result = FPDefaultNaN(fpcr, N);
+    ;             FPProcessException(FPExc_InvalidOp, fpcr);
+                (if (or (and inf1 inf2) (and zero1 zero2))
+                    (FPDefaultNaN! N)
+    ;          elsif inf1 || zero2 then
+    ;             result = FPInfinity(sign1 EOR sign2, N);
+    ;             TODO: FPExc_DivideByZero
+    ;             if !inf1 then FPProcessException(FPExc_DivideByZero, fpcr);
+                (if (or inf1 zero2)
+                    (fp_signed_inf! (xor! sign1 sign2) N)
+    ;          elsif zero1 || inf2 then
+    ;             result = FPZero(sign1 EOR sign2, N);
+                (if (or zero1 inf2)
+                    (fp_signed_zero! (xor! sign1 sign2) N)
+    ;          else
+    ;             result = FPRound(value1/value2, fpcr, N);
+                (fp.div x y)
+    ;
+    ;        if !zero2 then
+    ;            FPProcessDenorms(type1, type2, N, fpcr);
+    ;     return result;
+                )))
+            )
+        ))
+    )
+)
+
+;; FPMax: Floating point maximum
+; Note: ignoring the alternative floating point behavior for now
+(macro (FPMax value1 value2 fpcr)
+    ; bits(N) FPMax(bits(N) op1, bits(N) op2, FPCR_Type fpcr)
+    ;     boolean altfp = IsFeatureImplemented(FEAT_AFP) && !UsingAArch32() && fpcr.AH == '1';
+    ;     boolean fpexc = TRUE;
+    ;     return FPMax(op1, op2, fpcr, altfp, fpexc);
+
+    ; // FPMax()
+    ; // =======
+
+    ; bits(N) FPMax(bits(N) op1, bits(N) op2, FPCR_Type fpcr, boolean altfp)
+    ;     boolean fpexc = TRUE;
+    ;     return FPMax(op1, op2, fpcr, altfp, fpexc);
+
+    ; // FPMax()
+    ; // =======
+    ; // Compare two inputs and return the larger value after rounding. The
+    ; // 'fpcr' argument supplies the FPCR control bits and 'altfp' determines
+    ; // if the function should use alternative floating-point behavior.
+
+    ; bits(N) FPMax(bits(N) op1, bits(N) op2, FPCR_Type fpcr_in, boolean altfp, boolean fpexc)
+    ; // FPMax()
+    ; // ======
+    ;
+    ; bits(N) FPMax(bits(N) op1, bits(N) op2, FPCR_Type fpcr, boolean fpexc)
+    ;
+    ; assert N IN {16,32,64};
+    ; boolean done;
+    ; bits(N) result;
+    ; FPCR_Type fpcr = fpcr_in;
+    ; (type1,sign1,value1) = FPUnpack(op1, fpcr, fpexc);
+    ; (type2,sign2,value2) = FPUnpack(op2, fpcr, fpexc);
+
+    ; if altfp && type1 == FPType_Zero && type2 == FPType_Zero && sign1 != sign2 then
+    ;     // Alternate handling of zeros with differing sign
+    ;     return FPZero(sign2, N);
+    ; elsif altfp && (type1 IN {FPType_SNaN, FPType_QNaN} || type2 IN {FPType_SNaN, FPType_QNaN}) then
+    ;     // Alternate handling of NaN inputs
+    ;     if fpexc then FPProcessException(FPExc_InvalidOp, fpcr);
+    ;     return (if type2 == FPType_Zero then FPZero(sign2, N) else op2);
+    (let
+        (
+            (sign1 (fp.isNegative value1))
+            (sign2 (fp.isNegative value2))
+            (N (widthof value1))
+        )
+    ;
+    ;   (done,result) = FPProcessNaNs(type1, type2, op1, op2, fpcr, fpexc);
+        (if (fp.isNaN value1)
+            (FPProcessNaN! value1)
+        (if (fp.isNaN value2)
+            (FPProcessNaN! value2)
+    ;     if !done then
+    ;         if value1 > value2 then
+    ;             (fptype,sign,value) = (type1,sign1,value1);
+    ;         else
+    ;             (fptype,sign,value) = (type2,sign2,value2);
+            (let
+                (
+                    (sign   (if (fp.gt value1 value2) sign1 sign2))
+                    (value  (if (fp.gt value1 value2) value1 value2))
+                    (inf    (fp.isInfinite value))
+                    (zero   (fp.isZero value))
+                )
+    ;         if fptype == FPType_Infinity then
+    ;             result = FPInfinity(sign, N);
+                (if inf
+                    (fp_signed_inf! sign N)
+    ;         elsif fptype == FPType_Zero then
+    ;            sign = sign1 AND sign2;         // Use most positive sign
+    ;            result = FPZero(sign, N);
+                (if zero
+                    (fp_signed_zero! (and sign1 sign2) N)
+    ;          else
+    ;             // The use of FPRound() covers the case where there is a trapped underflow exception
+    ;             // for a denormalized number even though the result is exact.
+    ;             rounding = FPRoundingMode(fpcr);
+    ;             if altfp then    // Denormal output is not flushed to zero
+    ;                 fpcr.FZ = '0';
+    ;                 fpcr.FZ16 = '0';
+    ;             result = FPRound(value, fpcr, rounding, fpexc, N);
+    ;         if fpexc then FPProcessDenorms(type1, type2, N, fpcr);
+                   value
+    ;     return result;
+                ))
+            )
+        ))
+    )
+)
+
+
+;; FPMin: Floating point minimum
+; Note: ignoring the alternative floating point behavior for now
+(macro (FPMin value1 value2 fpcr)
+    ; bits(N) FPMin(bits(N) op1, bits(N) op2, FPCR_Type fpcr)
+    ;     boolean altfp = IsFeatureImplemented(FEAT_AFP) && !UsingAArch32() && fpcr.AH == '1';
+    ;     boolean fpexc = TRUE;
+    ;     return FPMin(op1, op2, fpcr, altfp, fpexc);
+
+    ; // FPMin()
+    ; // =======
+
+    ; bits(N) FPMin(bits(N) op1, bits(N) op2, FPCR_Type fpcr, boolean altfp)
+    ;     boolean fpexc = TRUE;
+    ;     return FPMin(op1, op2, fpcr, altfp, fpexc);
+
+    ; // FPMin()
+    ; // =======
+    ; // Compare two inputs and return the larger value after rounding. The
+    ; // 'fpcr' argument supplies the FPCR control bits and 'altfp' determines
+    ; // if the function should use alternative floating-point behavior.
+
+    ; bits(N) FPMin(bits(N) op1, bits(N) op2, FPCR_Type fpcr_in, boolean altfp, boolean fpexc)
+    ; // FPMin()
+    ; // ======
+    ;
+    ; bits(N) FPMin(bits(N) op1, bits(N) op2, FPCR_Type fpcr, boolean fpexc)
+    ;
+    ; assert N IN {16,32,64};
+    ; boolean done;
+    ; bits(N) result;
+    ; FPCR_Type fpcr = fpcr_in;
+    ; (type1,sign1,value1) = FPUnpack(op1, fpcr, fpexc);
+    ; (type2,sign2,value2) = FPUnpack(op2, fpcr, fpexc);
+
+    ; if altfp && type1 == FPType_Zero && type2 == FPType_Zero && sign1 != sign2 then
+    ;     // Alternate handling of zeros with differing sign
+    ;     return FPZero(sign2, N);
+    ; elsif altfp && (type1 IN {FPType_SNaN, FPType_QNaN} || type2 IN {FPType_SNaN, FPType_QNaN}) then
+    ;     // Alternate handling of NaN inputs
+    ;     if fpexc then FPProcessException(FPExc_InvalidOp, fpcr);
+    ;     return (if type2 == FPType_Zero then FPZero(sign2, N) else op2);
+    (let
+        (
+            (sign1 (fp.isNegative value1))
+            (sign2 (fp.isNegative value2))
+            (N (widthof value1))
+        )
+    ;
+    ;   (done,result) = FPProcessNaNs(type1, type2, op1, op2, fpcr, fpexc);
+        (if (fp.isNaN value1)
+            (FPProcessNaN! value1)
+        (if (fp.isNaN value2)
+            (FPProcessNaN! value2)
+    ;     if !done then
+    ;         if value1 < value2 then
+    ;             (fptype,sign,value) = (type1,sign1,value1);
+    ;         else
+    ;             (fptype,sign,value) = (type2,sign2,value2);
+            (let
+                (
+                    (sign   (if (fp.lt value1 value2) sign1 sign2))
+                    (value  (if (fp.lt value1 value2) value1 value2))
+                    (inf    (fp.isInfinite value))
+                    (zero   (fp.isZero value))
+                )
+    ;         if fptype == FPType_Infinity then
+    ;             result = FPInfinity(sign, N);
+                (if inf
+                    (fp_signed_inf! sign N)
+    ;         elsif fptype == FPType_Zero then
+    ;            sign = sign1 OR sign2;              // Use most negative sign
+    ;            result = FPZero(sign, N);
+                (if zero
+                    (fp_signed_zero! (or sign1 sign2) N)
+    ;          else
+    ;             // The use of FPRound() covers the case where there is a trapped underflow exception
+    ;             // for a denormalized number even though the result is exact.
+    ;             rounding = FPRoundingMode(fpcr);
+    ;             if altfp then    // Denormal output is not flushed to zero
+    ;                 fpcr.FZ = '0';
+    ;                 fpcr.FZ16 = '0';
+    ;             result = FPRound(value, fpcr, rounding, fpexc, N);
+    ;         if fpexc then FPProcessDenorms(type1, type2, N, fpcr);
+                   value
+    ;     return result;
+                ))
+            )
+        ))
+    )
+)
+
+;; FPCompare: Floating point comparison
+(macro (FPCompare value1 value2 signal_nans fpcr)
+    ; bits(4) FPCompare(bits(N) op1, bits(N) op2, boolean signal_nans, FPCR_Type fpcr)
+    ;     assert N IN {16,32,64};
+    ;     (type1,sign1,value1) = FPUnpack(op1, fpcr);
+    ;     (type2,sign2,value2) = FPUnpack(op2, fpcr);
+    ;     bits(4) result;
+    ;     if type1 IN {FPType_SNaN, FPType_QNaN} || type2 IN {FPType_SNaN, FPType_QNaN} then
+    ;         result = '0011';
+    ;         if type1 == FPType_SNaN || type2 == FPType_SNaN || signal_nans then
+    ;             FPProcessException(FPExc_InvalidOp, fpcr);
+    (if (or (fp.isNaN value1) (fp.isNaN value2))
+        (if signal_nans ; signal_nans is always false, but we need to read
+            #b0011
+            #b0011)
+    ;     else
+    ;         // All non-NaN cases can be evaluated on the values produced by FPUnpack()
+    ;         if value1 == value2 then
+    ;             result = '0110';
+    (if (fp.eq value1 value2)
+        #b0110
+
+    ;         elsif value1 < value2 then
+    ;             result = '1000';
+    (if (fp.lt value1 value2)
+        #b1000
+    ;         else  // value1 > value2
+    ;             result = '0010';
+        #b0010
+    ;         FPProcessDenorms(type1, type2, N, fpcr);
+    ;     return result;
+    )))
+)
+
+
+;; // Convert M-bit fixed point 'op' with FBITS fractional bits to
+;; // N-bit precision floating point, controlled by UNSIGNED and ROUNDING.
+(macro (FixedToFP op fbits unsigned fpcr rounding M N)
+; bits(N) FixedToFP(bits(M) op, integer fbits, boolean unsigned, FPCRType fpcr, FPRounding rounding)
+;     assert N IN {16,32,64};
+;     assert M IN {16,32,64};
+;     bits(N) result;
+;     assert fbits >= 0;
+;     assert rounding != FPRounding_ODD;
+;     // Correct signed-ness
+;     int_operand = Int(op, unsigned);
+;     // Scale by fractional bits and generate a real value
+;     real_operand = Real(int_operand) / 2.0^fbits;
+;     if real_operand == 0.0 then
+;         result = FPZero('0');
+;     else
+;         result = FPRound(real_operand, fpcr, rounding);
+;     return result;
+
+;; Use the SMTLIB conversion functions to accomplish the same behavior
+    (let
+        (
+            (result
+                (if unsigned
+                    (to_fp_unsigned N (conv_to N (zero_ext 64 op)))
+                    (to_fp N (conv_to N (sign_ext 64 op)))))
+        )
+        (if (and
+                ;; fbits of 0 means we can use pure integer logic
+                (= 0 fbits)
+                (= rounding rounding)
+            )
+            result
+            ;; unspecified bits if assumptions not met
+            (with (unspecified) unspecified)
+        )
+    )
+)
+
+(macro (FPToFixed op fbits unsigned fpcr rounding M N)
+    ; bits(M) FPToFixed(bits(N) op, integer fbits, boolean unsigned, FPCRType fpcr, FPRounding rounding)
+    ;     assert N IN {16,32,64};
+    ;     assert M IN {16,32,64};
+    ;     assert fbits >= 0;
+    ;     assert rounding != FPRounding_ODD;
+    ;     // Unpack using fpcr to determine if subnormals are flushed-to-zero
+    ;     (fptype,sign,value) = FPUnpack(op, fpcr);
+    ;     // If NaN, set cumulative flag or take exception
+    ;     if fptype == FPType_SNaN || fptype == FPType_QNaN then
+    ;         FPProcessException(FPExc_InvalidOp, fpcr);
+    ;     // Scale by fractional bits and produce integer rounded towards minus-infinity
+    ;     value = value * 2.0^fbits;
+    ;     int_result = RoundDown(value);
+    ;     error = value - Real(int_result);
+    ;     // Determine whether supplied rounding mode requires an increment
+    ;     case rounding of
+    ;         when FPRounding_TIEEVEN
+    ;             round_up = (error > 0.5 || (error == 0.5 && int_result[0] == '1'));
+    ;         when FPRounding_POSINF
+    ;             round_up = (error != 0.0);
+    ;         when FPRounding_NEGINF
+    ;             round_up = FALSE;
+    ;         when FPRounding_ZERO
+    ;             round_up = (error != 0.0 && int_result < 0);
+    ;         when FPRounding_TIEAWAY
+    ;             round_up = (error > 0.5 || (error == 0.5 && int_result >= 0));
+    ;     if round_up then int_result = int_result + 1;
+    ;     // Generate saturated result and exceptions
+    ;     (result, overflow) = SatQ(int_result, M, unsigned);
+    ;     if overflow then
+    ;         FPProcessException(FPExc_InvalidOp, fpcr);
+    ;     elsif error != 0.0 then
+    ;         FPProcessException(FPExc_Inexact, fpcr);
+    ;     return result;
+    (let
+        (
+            (result
+                (if unsigned
+                    (fp.to_ubv M (to_fp_from_fp M op))
+                    (fp.to_sbv M (to_fp_from_fp M op))))
+        )
+        (if (and
+                ;; fbits of 0 means we can use pure integer logic
+                (= 0 fbits)
+                (= rounding rounding)
+            )
+            result
+            ;; unspecified bits if assumptions not met
+            (with (unspecified) unspecified)
+        )
+    )
+)
+
+;; FPCompare: Floating point comparison
+(macro (FPConvert op fpcr rounding M N)
+    ; bits(M) FPConvert(bits(N) op, FPCRType fpcr, FPRounding rounding)
+    ;     assert M IN {16,32,64};
+    ;     assert N IN {16,32,64};
+    ;     bits(M) result;
+    ;     // Unpack floating-point operand optionally with flush-to-zero.
+    ;     (fptype,sign,value) = FPUnpackCV(op, fpcr);
+    (let
+        (
+            (sign (fp.isNegative op))
+        )
+    ;     alt_hp = (M == 16) && (fpcr.AHP == '1');
+    ;     if fptype == FPType_SNaN || fptype == FPType_QNaN then
+    ;         if alt_hp then
+    ;             result = FPZero(sign, M);
+    ;         elsif fpcr.DN == '1' then
+    ;             result = FPDefaultNaN(fpcr, M);
+    ;         else
+    ;             result = FPConvertNaN(op, M);
+    ;         if fptype == FPType_SNaN || alt_hp then
+    ;             FPProcessException(FPExc_InvalidOp,fpcr);
+    (if (fp.isNaN op)
+        (conv_to 64 (FPConvertNaN! op M N))
+    ;     else if fptype == FPType_Infinity then
+    ;         if alt_hp then
+    ;             result = sign:Ones(M-1);
+    ;             FPProcessException(FPExc_InvalidOp, fpcr);
+    ;         else
+    ;             result = FPInfinity(sign, M);
+    (if (fp.isInfinite op)
+        (conv_to 64 (fp_signed_inf! sign M))
+    ;     else if fptype == FPType_Zero then
+    ;         result = FPZero(sign, M);
+    (if (fp.isZero op)
+        (conv_to 64 (fp_signed_zero! sign M))
+    ;     else
+    ;         result = FPRoundCV(value, fpcr, rounding, M);
+    ;         FPProcessDenorm(fptype, N, fpcr);
+    ;     return result;
+;; NOTE: call out to the SMT-LIB conversion function for this logic
+    (if (= rounding rounding)
+        (conv_to 64 (to_fp_from_fp M op))
+        (with (unspecified) unspecified)
+    )))))
+)
+
+(macro (FPConvertNaN x M N)
+    ; bits(M) FPConvertNaN(bits(N) op, integer M)
+    ;     assert N IN {16,32,64};
+    ;     assert M IN {16,32,64};
+    ;     bits(M) result;
+    ;     bits(51) frac;
+    ;     sign = op<N-1>;
+    (let
+        (
+            (op (zero_ext 64 x))
+            (sign
+                (if (= N 64)
+                (extract 63 63 op)
+                (extract 31 31 op)
+                )
+            )
+    ;     // Unpack payload from input NaN
+    ;     case N of
+            (frac (switch N
+    ;         when 64 frac = op<50:0>;
+                (64 (extract 50 0 op))
+    ;         when 32 frac = op<21:0>:Zeros(29);
+                (32 (concat (extract 21 0 op) (bvzero! 29)))
+    ;         when 16 frac = op<8:0>:Zeros(42);
+                (16 (concat (extract 8 0 op) (bvzero! 42)))))
+        )
+    ;     // Repack payload into output NaN, while
+    ;     // converting an SNaN to a QNaN.
+    ;     case M of
+        (switch M
+    ;         when 64 result = sign:Ones(M-52):frac;
+            (64 (concat sign (bvones! 12) frac))
+    ;         when 32 result = sign:Ones(M-23):frac<50:29>;
+            (32 (conv_to 64 (concat sign (bvones! 9) (extract 50 29 frac))))
+    ;         when 16 result = sign:Ones(M-10):frac<50:42>;
+            (16 (conv_to 64 (concat sign (bvones! 6) (extract 50 42 frac))))
+        )
+    ;     return result;
+    )
+)
+
+(macro (FPRoundInt op fpcr rounding exact)
+    ;bits(N) FPRoundInt(bits(N) op, FPCR_Type fpcr, FPRounding rounding, boolean exact)
+    ;    assert rounding != FPRounding_ODD;
+    ;    assert N IN {16,32,64};
+    ;    // When alternative floating-point support is TRUE, do not generate
+    ;    // Input Denormal floating-point exceptions.
+    ;    altfp = IsFeatureImplemented(FEAT_AFP) && !UsingAArch32() && fpcr.AH == '1';
+    ;    fpexc = !altfp;
+    ;    // Unpack using FPCR to determine if subnormals are flushed-to-zero.
+    ;    (fptype,sign,value) = FPUnpack(op, fpcr, fpexc);
+    (let
+        (
+            (sign (fp.isNegative op))
+            (N (widthof op))
+        )
+    ;    bits(N) result;
+    ;    if fptype == FPType_SNaN || fptype == FPType_QNaN then
+    ;        result = FPProcessNaN(fptype, op, fpcr);
+    (if (fp.isNaN op)
+        (FPProcessNaN! op)
+    ;    elsif fptype == FPType_Infinity then
+    ;        result = FPInfinity(sign, N);
+    (if (fp.isInfinite op)
+        (fp_signed_inf! sign N)
+    ;    elsif fptype == FPType_Zero then
+    ;        result = FPZero(sign, N);
+    (if (fp.isZero op)
+        (fp_signed_zero! sign N)
+    ;    else
+
+;;  FPRounding_TIEEVEN, FPRounding_POSINF, FPRounding_NEGINF,  FPRounding_ZERO, FPRounding_TIEAWAY, FPRounding_ODD
+    ;        // Extract integer component.
+    ;        int_result = RoundDown(value);
+    ;        error = value - Real(int_result);
+    ;        // Determine whether supplied rounding mode requires an increment.
+    ;        boolean round_up;
+    (let ((result
+        (switch rounding
+    ;        case rounding of
+    ;            when FPRounding_TIEEVEN
+    ;                round_up = (error > 0.5 || (error == 0.5 && int_result<0> == '1'));
+            (0 (fp.nearest op))
+    ;            when FPRounding_POSINF
+    ;                round_up = (error != 0.0);
+            (1 (fp.ceil op))
+    ;            when FPRounding_NEGINF
+    ;                round_up = FALSE;
+            (2 (fp.floor op))
+    ;            when FPRounding_ZERO
+    ;                round_up = (error != 0.0 && int_result < 0);
+            (3 (fp.trunc op))
+    ;            when FPRounding_TIEAWAY
+    ;                round_up = (error > 0.5 || (error == 0.5 && int_result >= 0));
+        )
+    ;        if round_up then int_result = int_result + 1;
+    ;        // Convert integer value into an equivalent real value.
+    ;        real_result = Real(int_result);
+    ;        // Re-encode as a floating-point value, result is always exact.
+    ;        if real_result == 0.0 then
+    ;            result = FPZero(sign, N);
+    ;        else
+    ;            result = FPRound(real_result, fpcr, FPRounding_ZERO, N);
+    ;        // Generate inexact exceptions.
+    ;        if error != 0.0 && exact then
+    ;            FPProcessException(FPExc_Inexact, fpcr);
+    ;    return result;
+    ))
+    (if exact
+        (with (unspecified) unspecified)
+        result))
+    ))))
+)
+
+(macro (FPSqrt op fpcr)
+; bits(N) FPSqrt(bits(N) op, FPCRType fpcr)
+    ;     assert N IN {16,32,64};
+    ;     (fptype,sign,value) = FPUnpack(op, fpcr);
+    ;     if fptype == FPType_SNaN || fptype == FPType_QNaN then
+    (let
+        (
+            (sign (fp.isNegative op))
+            (N (widthof op))
+        )
+        (if (fp.isNaN op)
+            (FPProcessNaN! op)
+    ;         result = FPProcessNaN(fptype, op, fpcr);
+    ;     elsif fptype == FPType_Zero then
+    ;         result = FPZero(sign);
+        (if (fp.isZero op)
+            (fp_signed_zero! sign N)
+    ;     elsif fptype == FPType_Infinity && sign == '0' then
+    ;         result = FPInfinity(sign);
+        (if (and (fp.isInfinite op) (not sign))
+            (fp.+oo N)
+    ;     elsif sign == '1' then
+    ;         result = FPDefaultNaN();
+    ;         FPProcessException(FPExc_InvalidOp, fpcr);
+        (if sign
+        (nan_canon! N)
+    ;     else
+    ;         result = FPRound(Sqrt(value), fpcr);
+        (fp.sqrt op))))))
+    ;     return result;
+)
diff --git a/cranelift/codegen/src/isa/aarch64/spec/state.isle b/cranelift/codegen/src/isa/aarch64/spec/state.isle
new file mode 100644
index 000000000000..305f16469613
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/spec/state.isle
@@ -0,0 +1,44 @@
+; Parameters of a load operation.
+(state isa_load
+    (type
+        (struct
+            (active Bool)
+            (size_bits Int)
+            (addr (bv 64))
+        )
+    )
+    (default
+        (not (:active isa_load))
+    )
+)
+
+; Parameters of a store operation.
+(state isa_store
+    (type
+        (struct
+            (active Bool)
+            (size_bits Int)
+            (addr (bv 64))
+            (value (bv 64))
+        )
+    )
+    (default
+        (and
+            ; Store is not active.
+            (not (:active isa_store))
+
+            ; Must provide a fixed size in the default case, otherwise type
+            ; inference is underconstrained.
+            (= (:size_bits isa_store) 1)
+        )
+    )
+)
+
+; Floating point control register.
+(state fpcr
+    ; FPCR is a 64-bit register.
+    (type (bv 64))
+
+    ; Unconstrained. We currently do not model the FPCR configuration bits.
+    (default true)
+)
diff --git a/cranelift/codegen/src/isa/aarch64/spec/stores.isle b/cranelift/codegen/src/isa/aarch64/spec/stores.isle
new file mode 100644
index 000000000000..a9e4e78c194f
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/spec/stores.isle
@@ -0,0 +1,505 @@
+;; GENERATED BY `isaspec`. DO NOT EDIT!!!
+
+(attr MInst.Store8 (tag isaspec_generated))
+
+(spec
+    (MInst.Store8 rd mem flags)
+    (modifies isa_store)
+    (provide
+        (match
+            mem
+            ((RegReg rn rm)
+                (and
+                    (= (:active isa_store) true)
+                    (= (:size_bits isa_store) 8)
+                    (= (:addr isa_store) (bvadd rn rm))
+                    (= (conv_to 8 (:value isa_store)) (extract 7 0 (as rd (bv 64))))))
+            ((RegScaled rn rm)
+                (and
+                    (= (:active isa_store) true)
+                    (= (:size_bits isa_store) 8)
+                    (= (:addr isa_store) (bvadd rn rm))
+                    (= (conv_to 8 (:value isa_store)) (extract 7 0 (as rd (bv 64))))))
+            ((RegScaledExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 8)
+                            (= (:addr isa_store) (bvadd rn (zero_ext 64 (extract 31 0 rm))))
+                            (= (conv_to 8 (:value isa_store)) (extract 7 0 (as rd (bv 64))))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 8)
+                            (= (:addr isa_store) (bvadd rn (sign_ext 64 (extract 31 0 rm))))
+                            (= (conv_to 8 (:value isa_store)) (extract 7 0 (as rd (bv 64))))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 8)
+                            (= (:addr isa_store) (bvadd rn (sign_ext 64 rm)))
+                            (= (conv_to 8 (:value isa_store)) (extract 7 0 (as rd (bv 64))))))))
+            ((RegExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 8)
+                            (= (:addr isa_store) (bvadd rn (zero_ext 64 (extract 31 0 rm))))
+                            (= (conv_to 8 (:value isa_store)) (extract 7 0 (as rd (bv 64))))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 8)
+                            (= (:addr isa_store) (bvadd rn (sign_ext 64 (extract 31 0 rm))))
+                            (= (conv_to 8 (:value isa_store)) (extract 7 0 (as rd (bv 64))))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 8)
+                            (= (:addr isa_store) (bvadd rn (sign_ext 64 rm)))
+                            (= (conv_to 8 (:value isa_store)) (extract 7 0 (as rd (bv 64))))))))
+            ((Unscaled rn simm9)
+                (and
+                    (= (:active isa_store) true)
+                    (= (:size_bits isa_store) 8)
+                    (= (:addr isa_store) (bvadd rn (sign_ext 64 (extract 8 0 simm9))))
+                    (= (conv_to 8 (:value isa_store)) (extract 7 0 (as rd (bv 64))))))
+            ((UnsignedOffset rn uimm12)
+                (and
+                    (= (:active isa_store) true)
+                    (= (:size_bits isa_store) 8)
+                    (= (:addr isa_store) (bvadd rn (zero_ext 64 (extract 11 0 uimm12))))
+                    (= (conv_to 8 (:value isa_store)) (extract 7 0 (as rd (bv 64))))))))
+    (require
+        (match
+            mem
+            ((RegReg rn rm) true)
+            ((RegScaled rn rm) true)
+            ((RegScaledExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((RegExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((Unscaled rn simm9) true)
+            ((UnsignedOffset rn uimm12) true))))
+
+(attr MInst.Store16 (tag isaspec_generated))
+
+(spec
+    (MInst.Store16 rd mem flags)
+    (modifies isa_store)
+    (provide
+        (match
+            mem
+            ((RegReg rn rm)
+                (and
+                    (= (:active isa_store) true)
+                    (= (:size_bits isa_store) 16)
+                    (= (:addr isa_store) (bvadd rn rm))
+                    (= (conv_to 16 (:value isa_store)) (extract 15 0 (as rd (bv 64))))))
+            ((RegScaled rn rm)
+                (and
+                    (= (:active isa_store) true)
+                    (= (:size_bits isa_store) 16)
+                    (= (:addr isa_store) (bvadd rn (concat (extract 62 0 rm) #b0)))
+                    (= (conv_to 16 (:value isa_store)) (extract 15 0 (as rd (bv 64))))))
+            ((RegScaledExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 16)
+                            (= (:addr isa_store) (bvadd rn (zero_ext 64 (concat (extract 31 0 rm) #b0))))
+                            (= (conv_to 16 (:value isa_store)) (extract 15 0 (as rd (bv 64))))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 16)
+                            (= (:addr isa_store) (bvadd rn (sign_ext 64 (concat (extract 31 0 rm) #b0))))
+                            (= (conv_to 16 (:value isa_store)) (extract 15 0 (as rd (bv 64))))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 16)
+                            (= (:addr isa_store) (bvadd rn (sign_ext 64 (concat (extract 62 0 rm) #b0))))
+                            (= (conv_to 16 (:value isa_store)) (extract 15 0 (as rd (bv 64))))))))
+            ((RegExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 16)
+                            (= (:addr isa_store) (bvadd rn (zero_ext 64 (extract 31 0 rm))))
+                            (= (conv_to 16 (:value isa_store)) (extract 15 0 (as rd (bv 64))))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 16)
+                            (= (:addr isa_store) (bvadd rn (sign_ext 64 (extract 31 0 rm))))
+                            (= (conv_to 16 (:value isa_store)) (extract 15 0 (as rd (bv 64))))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 16)
+                            (= (:addr isa_store) (bvadd rn (sign_ext 64 rm)))
+                            (= (conv_to 16 (:value isa_store)) (extract 15 0 (as rd (bv 64))))))))
+            ((Unscaled rn simm9)
+                (and
+                    (= (:active isa_store) true)
+                    (= (:size_bits isa_store) 16)
+                    (= (:addr isa_store) (bvadd rn (sign_ext 64 (extract 8 0 simm9))))
+                    (= (conv_to 16 (:value isa_store)) (extract 15 0 (as rd (bv 64))))))
+            ((UnsignedOffset rn uimm12)
+                (and
+                    (= (:active isa_store) true)
+                    (= (:size_bits isa_store) 16)
+                    (= (:addr isa_store) (bvadd rn (concat (zero_ext 63 (extract 11 0 uimm12)) #b0)))
+                    (= (conv_to 16 (:value isa_store)) (extract 15 0 (as rd (bv 64))))))))
+    (require
+        (match
+            mem
+            ((RegReg rn rm) true)
+            ((RegScaled rn rm) true)
+            ((RegScaledExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((RegExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((Unscaled rn simm9) true)
+            ((UnsignedOffset rn uimm12) true))))
+
+(attr MInst.Store32 (tag isaspec_generated))
+
+(spec
+    (MInst.Store32 rd mem flags)
+    (modifies isa_store)
+    (provide
+        (match
+            mem
+            ((RegReg rn rm)
+                (and
+                    (= (:active isa_store) true)
+                    (= (:size_bits isa_store) 32)
+                    (= (:addr isa_store) (bvadd rn rm))
+                    (= (conv_to 32 (:value isa_store)) (extract 31 0 (as rd (bv 64))))))
+            ((RegScaled rn rm)
+                (and
+                    (= (:active isa_store) true)
+                    (= (:size_bits isa_store) 32)
+                    (= (:addr isa_store) (bvadd rn (concat (extract 61 0 rm) #b00)))
+                    (= (conv_to 32 (:value isa_store)) (extract 31 0 (as rd (bv 64))))))
+            ((RegScaledExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 32)
+                            (= (:addr isa_store) (bvadd rn (zero_ext 64 (concat (extract 31 0 rm) #b00))))
+                            (= (conv_to 32 (:value isa_store)) (extract 31 0 (as rd (bv 64))))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 32)
+                            (= (:addr isa_store) (bvadd rn (sign_ext 64 (concat (extract 31 0 rm) #b00))))
+                            (= (conv_to 32 (:value isa_store)) (extract 31 0 (as rd (bv 64))))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 32)
+                            (= (:addr isa_store) (bvadd rn (sign_ext 64 (concat (extract 61 0 rm) #b00))))
+                            (= (conv_to 32 (:value isa_store)) (extract 31 0 (as rd (bv 64))))))))
+            ((RegExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 32)
+                            (= (:addr isa_store) (bvadd rn (zero_ext 64 (extract 31 0 rm))))
+                            (= (conv_to 32 (:value isa_store)) (extract 31 0 (as rd (bv 64))))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 32)
+                            (= (:addr isa_store) (bvadd rn (sign_ext 64 (extract 31 0 rm))))
+                            (= (conv_to 32 (:value isa_store)) (extract 31 0 (as rd (bv 64))))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 32)
+                            (= (:addr isa_store) (bvadd rn (sign_ext 64 rm)))
+                            (= (conv_to 32 (:value isa_store)) (extract 31 0 (as rd (bv 64))))))))
+            ((Unscaled rn simm9)
+                (and
+                    (= (:active isa_store) true)
+                    (= (:size_bits isa_store) 32)
+                    (= (:addr isa_store) (bvadd rn (sign_ext 64 (extract 8 0 simm9))))
+                    (= (conv_to 32 (:value isa_store)) (extract 31 0 (as rd (bv 64))))))
+            ((UnsignedOffset rn uimm12)
+                (and
+                    (= (:active isa_store) true)
+                    (= (:size_bits isa_store) 32)
+                    (= (:addr isa_store) (bvadd rn (concat (zero_ext 62 (extract 11 0 uimm12)) #b00)))
+                    (= (conv_to 32 (:value isa_store)) (extract 31 0 (as rd (bv 64))))))))
+    (require
+        (match
+            mem
+            ((RegReg rn rm) true)
+            ((RegScaled rn rm) true)
+            ((RegScaledExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((RegExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((Unscaled rn simm9) true)
+            ((UnsignedOffset rn uimm12) true))))
+
+(attr MInst.Store64 (tag isaspec_generated))
+
+(spec
+    (MInst.Store64 rd mem flags)
+    (modifies isa_store)
+    (provide
+        (match
+            mem
+            ((RegReg rn rm)
+                (and
+                    (= (:active isa_store) true)
+                    (= (:size_bits isa_store) 64)
+                    (= (:addr isa_store) (bvadd rn rm))
+                    (= (conv_to 64 (:value isa_store)) (as rd (bv 64)))))
+            ((RegScaled rn rm)
+                (and
+                    (= (:active isa_store) true)
+                    (= (:size_bits isa_store) 64)
+                    (= (:addr isa_store) (bvadd rn (concat (extract 60 0 rm) #b000)))
+                    (= (conv_to 64 (:value isa_store)) (as rd (bv 64)))))
+            ((RegScaledExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 64)
+                            (= (:addr isa_store) (bvadd rn (zero_ext 64 (concat (extract 31 0 rm) #b000))))
+                            (= (conv_to 64 (:value isa_store)) (as rd (bv 64)))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 64)
+                            (= (:addr isa_store) (bvadd rn (sign_ext 64 (concat (extract 31 0 rm) #b000))))
+                            (= (conv_to 64 (:value isa_store)) (as rd (bv 64)))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 64)
+                            (= (:addr isa_store) (bvadd rn (sign_ext 64 (concat (extract 60 0 rm) #b000))))
+                            (= (conv_to 64 (:value isa_store)) (as rd (bv 64)))))))
+            ((RegExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 64)
+                            (= (:addr isa_store) (bvadd rn (zero_ext 64 (extract 31 0 rm))))
+                            (= (conv_to 64 (:value isa_store)) (as rd (bv 64)))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 64)
+                            (= (:addr isa_store) (bvadd rn (sign_ext 64 (extract 31 0 rm))))
+                            (= (conv_to 64 (:value isa_store)) (as rd (bv 64)))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 64)
+                            (= (:addr isa_store) (bvadd rn (sign_ext 64 rm)))
+                            (= (conv_to 64 (:value isa_store)) (as rd (bv 64)))))))
+            ((Unscaled rn simm9)
+                (and
+                    (= (:active isa_store) true)
+                    (= (:size_bits isa_store) 64)
+                    (= (:addr isa_store) (bvadd rn (sign_ext 64 (extract 8 0 simm9))))
+                    (= (conv_to 64 (:value isa_store)) (as rd (bv 64)))))
+            ((UnsignedOffset rn uimm12)
+                (and
+                    (= (:active isa_store) true)
+                    (= (:size_bits isa_store) 64)
+                    (= (:addr isa_store) (bvadd rn (concat (zero_ext 61 (extract 11 0 uimm12)) #b000)))
+                    (= (conv_to 64 (:value isa_store)) (as rd (bv 64)))))))
+    (require
+        (match
+            mem
+            ((RegReg rn rm) true)
+            ((RegScaled rn rm) true)
+            ((RegScaledExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((RegExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((Unscaled rn simm9) true)
+            ((UnsignedOffset rn uimm12) true))))
+
+(attr MInst.FpuStore32 (tag isaspec_generated))
+
+(spec
+    (MInst.FpuStore32 rd mem flags)
+    (modifies isa_store)
+    (provide
+        (match
+            mem
+            ((RegReg rn rm)
+                (and
+                    (= (:active isa_store) true)
+                    (= (:size_bits isa_store) 32)
+                    (= (:addr isa_store) (bvadd rn rm))
+                    (= (conv_to 32 (:value isa_store)) (extract 31 0 (conv_to 128 (as rd (bv 64)))))))
+            ((RegScaled rn rm)
+                (and
+                    (= (:active isa_store) true)
+                    (= (:size_bits isa_store) 32)
+                    (= (:addr isa_store) (bvadd rn (concat (extract 61 0 rm) #b00)))
+                    (= (conv_to 32 (:value isa_store)) (extract 31 0 (conv_to 128 (as rd (bv 64)))))))
+            ((RegScaledExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 32)
+                            (= (:addr isa_store) (bvadd rn (zero_ext 64 (concat (extract 31 0 rm) #b00))))
+                            (= (conv_to 32 (:value isa_store)) (extract 31 0 (conv_to 128 (as rd (bv 64)))))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 32)
+                            (= (:addr isa_store) (bvadd rn (sign_ext 64 (concat (extract 31 0 rm) #b00))))
+                            (= (conv_to 32 (:value isa_store)) (extract 31 0 (conv_to 128 (as rd (bv 64)))))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 32)
+                            (= (:addr isa_store) (bvadd rn (sign_ext 64 (concat (extract 61 0 rm) #b00))))
+                            (= (conv_to 32 (:value isa_store)) (extract 31 0 (conv_to 128 (as rd (bv 64)))))))))
+            ((RegExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 32)
+                            (= (:addr isa_store) (bvadd rn (zero_ext 64 (extract 31 0 rm))))
+                            (= (conv_to 32 (:value isa_store)) (extract 31 0 (conv_to 128 (as rd (bv 64)))))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 32)
+                            (= (:addr isa_store) (bvadd rn (sign_ext 64 (extract 31 0 rm))))
+                            (= (conv_to 32 (:value isa_store)) (extract 31 0 (conv_to 128 (as rd (bv 64)))))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 32)
+                            (= (:addr isa_store) (bvadd rn (sign_ext 64 rm)))
+                            (= (conv_to 32 (:value isa_store)) (extract 31 0 (conv_to 128 (as rd (bv 64)))))))))
+            ((Unscaled rn simm9)
+                (and
+                    (= (:active isa_store) true)
+                    (= (:size_bits isa_store) 32)
+                    (= (:addr isa_store) (bvadd rn (sign_ext 64 (extract 8 0 simm9))))
+                    (= (conv_to 32 (:value isa_store)) (extract 31 0 (conv_to 128 (as rd (bv 64)))))))
+            ((UnsignedOffset rn uimm12)
+                (and
+                    (= (:active isa_store) true)
+                    (= (:size_bits isa_store) 32)
+                    (= (:addr isa_store) (bvadd rn (concat (zero_ext 62 (extract 11 0 uimm12)) #b00)))
+                    (= (conv_to 32 (:value isa_store)) (extract 31 0 (conv_to 128 (as rd (bv 64)))))))))
+    (require
+        (match
+            mem
+            ((RegReg rn rm) true)
+            ((RegScaled rn rm) true)
+            ((RegScaledExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((RegExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((Unscaled rn simm9) true)
+            ((UnsignedOffset rn uimm12) true))))
+
+(attr MInst.FpuStore64 (tag isaspec_generated))
+
+(spec
+    (MInst.FpuStore64 rd mem flags)
+    (modifies isa_store)
+    (provide
+        (match
+            mem
+            ((RegReg rn rm)
+                (and
+                    (= (:active isa_store) true)
+                    (= (:size_bits isa_store) 64)
+                    (= (:addr isa_store) (bvadd rn rm))
+                    (= (conv_to 64 (:value isa_store)) (extract 63 0 (conv_to 128 (as rd (bv 64)))))))
+            ((RegScaled rn rm)
+                (and
+                    (= (:active isa_store) true)
+                    (= (:size_bits isa_store) 64)
+                    (= (:addr isa_store) (bvadd rn (concat (extract 60 0 rm) #b000)))
+                    (= (conv_to 64 (:value isa_store)) (extract 63 0 (conv_to 128 (as rd (bv 64)))))))
+            ((RegScaledExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 64)
+                            (= (:addr isa_store) (bvadd rn (zero_ext 64 (concat (extract 31 0 rm) #b000))))
+                            (= (conv_to 64 (:value isa_store)) (extract 63 0 (conv_to 128 (as rd (bv 64)))))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 64)
+                            (= (:addr isa_store) (bvadd rn (sign_ext 64 (concat (extract 31 0 rm) #b000))))
+                            (= (conv_to 64 (:value isa_store)) (extract 63 0 (conv_to 128 (as rd (bv 64)))))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 64)
+                            (= (:addr isa_store) (bvadd rn (sign_ext 64 (concat (extract 60 0 rm) #b000))))
+                            (= (conv_to 64 (:value isa_store)) (extract 63 0 (conv_to 128 (as rd (bv 64)))))))))
+            ((RegExtended rn rm extendop)
+                (match
+                    extendop
+                    ((UXTW)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 64)
+                            (= (:addr isa_store) (bvadd rn (zero_ext 64 (extract 31 0 rm))))
+                            (= (conv_to 64 (:value isa_store)) (extract 63 0 (conv_to 128 (as rd (bv 64)))))))
+                    ((SXTW)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 64)
+                            (= (:addr isa_store) (bvadd rn (sign_ext 64 (extract 31 0 rm))))
+                            (= (conv_to 64 (:value isa_store)) (extract 63 0 (conv_to 128 (as rd (bv 64)))))))
+                    ((SXTX)
+                        (and
+                            (= (:active isa_store) true)
+                            (= (:size_bits isa_store) 64)
+                            (= (:addr isa_store) (bvadd rn (sign_ext 64 rm)))
+                            (= (conv_to 64 (:value isa_store)) (extract 63 0 (conv_to 128 (as rd (bv 64)))))))))
+            ((Unscaled rn simm9)
+                (and
+                    (= (:active isa_store) true)
+                    (= (:size_bits isa_store) 64)
+                    (= (:addr isa_store) (bvadd rn (sign_ext 64 (extract 8 0 simm9))))
+                    (= (conv_to 64 (:value isa_store)) (extract 63 0 (conv_to 128 (as rd (bv 64)))))))
+            ((UnsignedOffset rn uimm12)
+                (and
+                    (= (:active isa_store) true)
+                    (= (:size_bits isa_store) 64)
+                    (= (:addr isa_store) (bvadd rn (concat (zero_ext 61 (extract 11 0 uimm12)) #b000)))
+                    (= (conv_to 64 (:value isa_store)) (extract 63 0 (conv_to 128 (as rd (bv 64)))))))))
+    (require
+        (match
+            mem
+            ((RegReg rn rm) true)
+            ((RegScaled rn rm) true)
+            ((RegScaledExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((RegExtended rn rm extendop) (match extendop ((UXTW) true) ((SXTW) true) ((SXTX) true)))
+            ((Unscaled rn simm9) true)
+            ((UnsignedOffset rn uimm12) true))))
diff --git a/cranelift/codegen/src/isa/aarch64/spec/vec_dup_imm.isle b/cranelift/codegen/src/isa/aarch64/spec/vec_dup_imm.isle
new file mode 100644
index 000000000000..8ed901219a82
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/spec/vec_dup_imm.isle
@@ -0,0 +1,67 @@
+;; GENERATED BY `isaspec`. DO NOT EDIT!!!
+
+(attr MInst.VecDupImm (tag isaspec_generated))
+
+(spec
+    (MInst.VecDupImm rd imm invert size)
+    (provide
+        (match
+            size
+            ((Size32x2)
+                (and
+                    (=>
+                        (not invert)
+                        (=
+                            rd
+                            (zero_ext
+                                128
+                                (replicate
+                                    (replicate
+                                        (zero_ext
+                                            32
+                                            (concat
+                                                (concat
+                                                    (concat
+                                                        (concat
+                                                            (concat
+                                                                (concat
+                                                                    (concat
+                                                                        (extract 2 2 (extract 7 5 (:imm imm)))
+                                                                        (extract 1 1 (extract 7 5 (:imm imm))))
+                                                                    (extract 0 0 (extract 7 5 (:imm imm))))
+                                                                (extract 4 4 (extract 4 0 (:imm imm))))
+                                                            (extract 3 3 (extract 4 0 (:imm imm))))
+                                                        (extract 2 2 (extract 4 0 (:imm imm))))
+                                                    (extract 1 1 (extract 4 0 (:imm imm))))
+                                                (extract 0 0 (extract 4 0 (:imm imm)))))
+                                        2)
+                                    1))))
+                    (=>
+                        invert
+                        (=
+                            rd
+                            (zero_ext
+                                128
+                                (bvnot
+                                    (replicate
+                                        (replicate
+                                            (zero_ext
+                                                32
+                                                (concat
+                                                    (concat
+                                                        (concat
+                                                            (concat
+                                                                (concat
+                                                                    (concat
+                                                                        (concat
+                                                                            (extract 2 2 (extract 7 5 (:imm imm)))
+                                                                            (extract 1 1 (extract 7 5 (:imm imm))))
+                                                                        (extract 0 0 (extract 7 5 (:imm imm))))
+                                                                    (extract 4 4 (extract 4 0 (:imm imm))))
+                                                                (extract 3 3 (extract 4 0 (:imm imm))))
+                                                            (extract 2 2 (extract 4 0 (:imm imm))))
+                                                        (extract 1 1 (extract 4 0 (:imm imm))))
+                                                    (extract 0 0 (extract 4 0 (:imm imm)))))
+                                            2)
+                                        1)))))))))
+    (require (match size ((Size32x2) (or (not invert) invert)))))
diff --git a/cranelift/codegen/src/isa/aarch64/spec/vec_lanes.isle b/cranelift/codegen/src/isa/aarch64/spec/vec_lanes.isle
new file mode 100644
index 000000000000..d0a47ecbf296
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/spec/vec_lanes.isle
@@ -0,0 +1,335 @@
+;; GENERATED BY `isaspec`. DO NOT EDIT!!!
+
+(attr MInst.VecLanes (tag isaspec_generated))
+
+(spec
+    (MInst.VecLanes op rd rn size)
+    (provide
+        (match
+            size
+            ((Size32x4)
+                (match
+                    op
+                    ((Uminv)
+                        (with
+                            (t1 t10 t11 t12 t2 t3 t4 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (bvsle (zero_ext 64 (extract 31 0 rn)) (zero_ext 64 (extract 63 32 rn))))
+                                (if t1 (= t2 (extract 31 0 rn)) (= t3 (extract 63 32 rn)))
+                                (= t4 (if t1 t2 t3))
+                                (= t5 (bvsle (zero_ext 64 t4) (zero_ext 64 (extract 95 64 rn))))
+                                (if t5 (= t6 t4) (= t7 (extract 95 64 rn)))
+                                (= t8 (if t5 t6 t7))
+                                (= t9 (bvsle (zero_ext 64 t8) (zero_ext 64 (extract 127 96 rn))))
+                                (if t9 (= t10 t8) (= t11 (extract 127 96 rn)))
+                                (= t12 (if t9 t10 t11))
+                                (= rd (zero_ext 128 t12)))))
+                    ((Addv)
+                        (=
+                            rd
+                            (zero_ext
+                                128
+                                (bvadd
+                                    (bvadd (extract 31 0 rn) (extract 63 32 rn))
+                                    (bvadd (extract 95 64 rn) (extract 127 96 rn))))))))
+            ((Size16x8)
+                (match
+                    op
+                    ((Uminv)
+                        (with
+                            (t1
+                                t10
+                                t11
+                                t12
+                                t13
+                                t14
+                                t15
+                                t16
+                                t17
+                                t18
+                                t19
+                                t2
+                                t20
+                                t21
+                                t22
+                                t23
+                                t24
+                                t25
+                                t26
+                                t27
+                                t28
+                                t3
+                                t4
+                                t5
+                                t6
+                                t7
+                                t8
+                                t9)
+                            (and
+                                (= t1 (bvsle (zero_ext 32 (extract 15 0 rn)) (zero_ext 32 (extract 31 16 rn))))
+                                (if t1 (= t2 (extract 15 0 rn)) (= t3 (extract 31 16 rn)))
+                                (= t4 (if t1 t2 t3))
+                                (= t5 (bvsle (zero_ext 32 t4) (zero_ext 32 (extract 47 32 rn))))
+                                (if t5 (= t6 t4) (= t7 (extract 47 32 rn)))
+                                (= t8 (if t5 t6 t7))
+                                (= t9 (bvsle (zero_ext 32 t8) (zero_ext 32 (extract 63 48 rn))))
+                                (if t9 (= t10 t8) (= t11 (extract 63 48 rn)))
+                                (= t12 (if t9 t10 t11))
+                                (= t13 (bvsle (zero_ext 32 t12) (zero_ext 32 (extract 79 64 rn))))
+                                (if t13 (= t14 t12) (= t15 (extract 79 64 rn)))
+                                (= t16 (if t13 t14 t15))
+                                (= t17 (bvsle (zero_ext 32 t16) (zero_ext 32 (extract 95 80 rn))))
+                                (if t17 (= t18 t16) (= t19 (extract 95 80 rn)))
+                                (= t20 (if t17 t18 t19))
+                                (= t21 (bvsle (zero_ext 32 t20) (zero_ext 32 (extract 111 96 rn))))
+                                (if t21 (= t22 t20) (= t23 (extract 111 96 rn)))
+                                (= t24 (if t21 t22 t23))
+                                (= t25 (bvsle (zero_ext 32 t24) (zero_ext 32 (extract 127 112 rn))))
+                                (if t25 (= t26 t24) (= t27 (extract 127 112 rn)))
+                                (= t28 (if t25 t26 t27))
+                                (= rd (zero_ext 128 t28)))))
+                    ((Addv)
+                        (=
+                            rd
+                            (zero_ext
+                                128
+                                (bvadd
+                                    (bvadd
+                                        (bvadd (extract 15 0 rn) (extract 31 16 rn))
+                                        (bvadd (extract 47 32 rn) (extract 63 48 rn)))
+                                    (bvadd
+                                        (bvadd (extract 79 64 rn) (extract 95 80 rn))
+                                        (bvadd (extract 111 96 rn) (extract 127 112 rn)))))))))
+            ((Size16x4)
+                (match
+                    op
+                    ((Uminv)
+                        (with
+                            (t1 t10 t11 t12 t2 t3 t4 t5 t6 t7 t8 t9)
+                            (and
+                                (= t1 (bvsle (zero_ext 32 (extract 15 0 rn)) (zero_ext 32 (extract 31 16 rn))))
+                                (if t1 (= t2 (extract 15 0 rn)) (= t3 (extract 31 16 rn)))
+                                (= t4 (if t1 t2 t3))
+                                (= t5 (bvsle (zero_ext 32 t4) (zero_ext 32 (extract 47 32 rn))))
+                                (if t5 (= t6 t4) (= t7 (extract 47 32 rn)))
+                                (= t8 (if t5 t6 t7))
+                                (= t9 (bvsle (zero_ext 32 t8) (zero_ext 32 (extract 63 48 rn))))
+                                (if t9 (= t10 t8) (= t11 (extract 63 48 rn)))
+                                (= t12 (if t9 t10 t11))
+                                (= rd (zero_ext 128 t12)))))
+                    ((Addv)
+                        (=
+                            rd
+                            (zero_ext
+                                128
+                                (bvadd
+                                    (bvadd (extract 15 0 rn) (extract 31 16 rn))
+                                    (bvadd (extract 47 32 rn) (extract 63 48 rn))))))))
+            ((Size8x16)
+                (match
+                    op
+                    ((Uminv)
+                        (with
+                            (t1
+                                t10
+                                t11
+                                t12
+                                t13
+                                t14
+                                t15
+                                t16
+                                t17
+                                t18
+                                t19
+                                t2
+                                t20
+                                t21
+                                t22
+                                t23
+                                t24
+                                t25
+                                t26
+                                t27
+                                t28
+                                t29
+                                t3
+                                t30
+                                t31
+                                t32
+                                t33
+                                t34
+                                t35
+                                t36
+                                t37
+                                t38
+                                t39
+                                t4
+                                t40
+                                t41
+                                t42
+                                t43
+                                t44
+                                t45
+                                t46
+                                t47
+                                t48
+                                t49
+                                t5
+                                t50
+                                t51
+                                t52
+                                t53
+                                t54
+                                t55
+                                t56
+                                t57
+                                t58
+                                t59
+                                t6
+                                t60
+                                t7
+                                t8
+                                t9)
+                            (and
+                                (= t1 (bvsle (zero_ext 16 (extract 7 0 rn)) (zero_ext 16 (extract 15 8 rn))))
+                                (if t1 (= t2 (extract 7 0 rn)) (= t3 (extract 15 8 rn)))
+                                (= t4 (if t1 t2 t3))
+                                (= t5 (bvsle (zero_ext 16 t4) (zero_ext 16 (extract 23 16 rn))))
+                                (if t5 (= t6 t4) (= t7 (extract 23 16 rn)))
+                                (= t8 (if t5 t6 t7))
+                                (= t9 (bvsle (zero_ext 16 t8) (zero_ext 16 (extract 31 24 rn))))
+                                (if t9 (= t10 t8) (= t11 (extract 31 24 rn)))
+                                (= t12 (if t9 t10 t11))
+                                (= t13 (bvsle (zero_ext 16 t12) (zero_ext 16 (extract 39 32 rn))))
+                                (if t13 (= t14 t12) (= t15 (extract 39 32 rn)))
+                                (= t16 (if t13 t14 t15))
+                                (= t17 (bvsle (zero_ext 16 t16) (zero_ext 16 (extract 47 40 rn))))
+                                (if t17 (= t18 t16) (= t19 (extract 47 40 rn)))
+                                (= t20 (if t17 t18 t19))
+                                (= t21 (bvsle (zero_ext 16 t20) (zero_ext 16 (extract 55 48 rn))))
+                                (if t21 (= t22 t20) (= t23 (extract 55 48 rn)))
+                                (= t24 (if t21 t22 t23))
+                                (= t25 (bvsle (zero_ext 16 t24) (zero_ext 16 (extract 63 56 rn))))
+                                (if t25 (= t26 t24) (= t27 (extract 63 56 rn)))
+                                (= t28 (if t25 t26 t27))
+                                (= t29 (bvsle (zero_ext 16 t28) (zero_ext 16 (extract 71 64 rn))))
+                                (if t29 (= t30 t28) (= t31 (extract 71 64 rn)))
+                                (= t32 (if t29 t30 t31))
+                                (= t33 (bvsle (zero_ext 16 t32) (zero_ext 16 (extract 79 72 rn))))
+                                (if t33 (= t34 t32) (= t35 (extract 79 72 rn)))
+                                (= t36 (if t33 t34 t35))
+                                (= t37 (bvsle (zero_ext 16 t36) (zero_ext 16 (extract 87 80 rn))))
+                                (if t37 (= t38 t36) (= t39 (extract 87 80 rn)))
+                                (= t40 (if t37 t38 t39))
+                                (= t41 (bvsle (zero_ext 16 t40) (zero_ext 16 (extract 95 88 rn))))
+                                (if t41 (= t42 t40) (= t43 (extract 95 88 rn)))
+                                (= t44 (if t41 t42 t43))
+                                (= t45 (bvsle (zero_ext 16 t44) (zero_ext 16 (extract 103 96 rn))))
+                                (if t45 (= t46 t44) (= t47 (extract 103 96 rn)))
+                                (= t48 (if t45 t46 t47))
+                                (= t49 (bvsle (zero_ext 16 t48) (zero_ext 16 (extract 111 104 rn))))
+                                (if t49 (= t50 t48) (= t51 (extract 111 104 rn)))
+                                (= t52 (if t49 t50 t51))
+                                (= t53 (bvsle (zero_ext 16 t52) (zero_ext 16 (extract 119 112 rn))))
+                                (if t53 (= t54 t52) (= t55 (extract 119 112 rn)))
+                                (= t56 (if t53 t54 t55))
+                                (= t57 (bvsle (zero_ext 16 t56) (zero_ext 16 (extract 127 120 rn))))
+                                (if t57 (= t58 t56) (= t59 (extract 127 120 rn)))
+                                (= t60 (if t57 t58 t59))
+                                (= rd (zero_ext 128 t60)))))
+                    ((Addv)
+                        (=
+                            rd
+                            (zero_ext
+                                128
+                                (bvadd
+                                    (bvadd
+                                        (bvadd
+                                            (bvadd (extract 7 0 rn) (extract 15 8 rn))
+                                            (bvadd (extract 23 16 rn) (extract 31 24 rn)))
+                                        (bvadd
+                                            (bvadd (extract 39 32 rn) (extract 47 40 rn))
+                                            (bvadd (extract 55 48 rn) (extract 63 56 rn))))
+                                    (bvadd
+                                        (bvadd
+                                            (bvadd (extract 71 64 rn) (extract 79 72 rn))
+                                            (bvadd (extract 87 80 rn) (extract 95 88 rn)))
+                                        (bvadd
+                                            (bvadd (extract 103 96 rn) (extract 111 104 rn))
+                                            (bvadd (extract 119 112 rn) (extract 127 120 rn))))))))))
+            ((Size8x8)
+                (match
+                    op
+                    ((Uminv)
+                        (with
+                            (t1
+                                t10
+                                t11
+                                t12
+                                t13
+                                t14
+                                t15
+                                t16
+                                t17
+                                t18
+                                t19
+                                t2
+                                t20
+                                t21
+                                t22
+                                t23
+                                t24
+                                t25
+                                t26
+                                t27
+                                t28
+                                t3
+                                t4
+                                t5
+                                t6
+                                t7
+                                t8
+                                t9)
+                            (and
+                                (= t1 (bvsle (zero_ext 16 (extract 7 0 rn)) (zero_ext 16 (extract 15 8 rn))))
+                                (if t1 (= t2 (extract 7 0 rn)) (= t3 (extract 15 8 rn)))
+                                (= t4 (if t1 t2 t3))
+                                (= t5 (bvsle (zero_ext 16 t4) (zero_ext 16 (extract 23 16 rn))))
+                                (if t5 (= t6 t4) (= t7 (extract 23 16 rn)))
+                                (= t8 (if t5 t6 t7))
+                                (= t9 (bvsle (zero_ext 16 t8) (zero_ext 16 (extract 31 24 rn))))
+                                (if t9 (= t10 t8) (= t11 (extract 31 24 rn)))
+                                (= t12 (if t9 t10 t11))
+                                (= t13 (bvsle (zero_ext 16 t12) (zero_ext 16 (extract 39 32 rn))))
+                                (if t13 (= t14 t12) (= t15 (extract 39 32 rn)))
+                                (= t16 (if t13 t14 t15))
+                                (= t17 (bvsle (zero_ext 16 t16) (zero_ext 16 (extract 47 40 rn))))
+                                (if t17 (= t18 t16) (= t19 (extract 47 40 rn)))
+                                (= t20 (if t17 t18 t19))
+                                (= t21 (bvsle (zero_ext 16 t20) (zero_ext 16 (extract 55 48 rn))))
+                                (if t21 (= t22 t20) (= t23 (extract 55 48 rn)))
+                                (= t24 (if t21 t22 t23))
+                                (= t25 (bvsle (zero_ext 16 t24) (zero_ext 16 (extract 63 56 rn))))
+                                (if t25 (= t26 t24) (= t27 (extract 63 56 rn)))
+                                (= t28 (if t25 t26 t27))
+                                (= rd (zero_ext 128 t28)))))
+                    ((Addv)
+                        (=
+                            rd
+                            (zero_ext
+                                128
+                                (bvadd
+                                    (bvadd
+                                        (bvadd (extract 7 0 rn) (extract 15 8 rn))
+                                        (bvadd (extract 23 16 rn) (extract 31 24 rn)))
+                                    (bvadd
+                                        (bvadd (extract 39 32 rn) (extract 47 40 rn))
+                                        (bvadd (extract 55 48 rn) (extract 63 56 rn)))))))))))
+    (require
+        (match
+            size
+            ((Size32x4) (match op ((Uminv) true) ((Addv) true)))
+            ((Size16x8) (match op ((Uminv) true) ((Addv) true)))
+            ((Size16x4) (match op ((Uminv) true) ((Addv) true)))
+            ((Size8x16) (match op ((Uminv) true) ((Addv) true)))
+            ((Size8x8) (match op ((Uminv) true) ((Addv) true))))))
diff --git a/cranelift/codegen/src/isa/aarch64/spec/vec_misc.isle b/cranelift/codegen/src/isa/aarch64/spec/vec_misc.isle
new file mode 100644
index 000000000000..b2824b4b2982
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/spec/vec_misc.isle
@@ -0,0 +1,1276 @@
+;; GENERATED BY `isaspec`. DO NOT EDIT!!!
+
+(attr MInst.VecMisc (tag isaspec_generated))
+
+(spec
+    (MInst.VecMisc op rd rn size)
+    (provide
+        (match
+            size
+            ((Size8x16)
+                (match
+                    op
+                    ((Cnt)
+                        (with
+                            (t0
+                                t10
+                                t100
+                                t101
+                                t102
+                                t103
+                                t104
+                                t105
+                                t106
+                                t107
+                                t108
+                                t109
+                                t11
+                                t110
+                                t111
+                                t112
+                                t113
+                                t114
+                                t115
+                                t116
+                                t117
+                                t118
+                                t119
+                                t12
+                                t120
+                                t121
+                                t122
+                                t123
+                                t124
+                                t125
+                                t126
+                                t127
+                                t128
+                                t129
+                                t13
+                                t130
+                                t131
+                                t132
+                                t133
+                                t134
+                                t135
+                                t136
+                                t137
+                                t138
+                                t139
+                                t14
+                                t140
+                                t141
+                                t142
+                                t143
+                                t144
+                                t145
+                                t146
+                                t147
+                                t148
+                                t149
+                                t15
+                                t150
+                                t151
+                                t152
+                                t153
+                                t154
+                                t155
+                                t156
+                                t157
+                                t158
+                                t159
+                                t16
+                                t160
+                                t161
+                                t162
+                                t163
+                                t164
+                                t165
+                                t166
+                                t167
+                                t168
+                                t169
+                                t17
+                                t170
+                                t171
+                                t172
+                                t173
+                                t174
+                                t175
+                                t176
+                                t177
+                                t178
+                                t179
+                                t18
+                                t180
+                                t181
+                                t182
+                                t183
+                                t184
+                                t185
+                                t186
+                                t187
+                                t188
+                                t189
+                                t19
+                                t190
+                                t191
+                                t192
+                                t193
+                                t194
+                                t195
+                                t196
+                                t197
+                                t198
+                                t199
+                                t2
+                                t20
+                                t200
+                                t201
+                                t202
+                                t203
+                                t204
+                                t205
+                                t206
+                                t207
+                                t208
+                                t209
+                                t21
+                                t210
+                                t211
+                                t212
+                                t213
+                                t214
+                                t215
+                                t216
+                                t217
+                                t218
+                                t219
+                                t22
+                                t220
+                                t221
+                                t222
+                                t223
+                                t224
+                                t225
+                                t226
+                                t227
+                                t228
+                                t229
+                                t23
+                                t230
+                                t231
+                                t232
+                                t233
+                                t234
+                                t235
+                                t236
+                                t237
+                                t238
+                                t239
+                                t24
+                                t240
+                                t241
+                                t242
+                                t243
+                                t244
+                                t245
+                                t246
+                                t247
+                                t248
+                                t249
+                                t25
+                                t250
+                                t251
+                                t252
+                                t253
+                                t254
+                                t255
+                                t256
+                                t257
+                                t258
+                                t259
+                                t26
+                                t260
+                                t261
+                                t262
+                                t263
+                                t264
+                                t265
+                                t266
+                                t267
+                                t268
+                                t269
+                                t27
+                                t270
+                                t271
+                                t272
+                                t273
+                                t274
+                                t275
+                                t276
+                                t277
+                                t278
+                                t279
+                                t28
+                                t280
+                                t281
+                                t282
+                                t283
+                                t284
+                                t285
+                                t286
+                                t287
+                                t288
+                                t289
+                                t29
+                                t290
+                                t291
+                                t292
+                                t293
+                                t294
+                                t295
+                                t296
+                                t297
+                                t298
+                                t299
+                                t3
+                                t30
+                                t300
+                                t301
+                                t302
+                                t303
+                                t304
+                                t305
+                                t306
+                                t307
+                                t308
+                                t309
+                                t31
+                                t310
+                                t311
+                                t312
+                                t313
+                                t314
+                                t315
+                                t316
+                                t317
+                                t318
+                                t319
+                                t32
+                                t320
+                                t321
+                                t322
+                                t323
+                                t324
+                                t325
+                                t326
+                                t327
+                                t328
+                                t329
+                                t33
+                                t330
+                                t331
+                                t332
+                                t333
+                                t334
+                                t335
+                                t336
+                                t337
+                                t338
+                                t339
+                                t34
+                                t340
+                                t341
+                                t342
+                                t343
+                                t344
+                                t345
+                                t346
+                                t347
+                                t348
+                                t349
+                                t35
+                                t350
+                                t351
+                                t352
+                                t353
+                                t354
+                                t355
+                                t356
+                                t357
+                                t358
+                                t359
+                                t36
+                                t360
+                                t361
+                                t362
+                                t363
+                                t364
+                                t365
+                                t366
+                                t367
+                                t368
+                                t369
+                                t37
+                                t370
+                                t371
+                                t372
+                                t373
+                                t374
+                                t375
+                                t376
+                                t377
+                                t378
+                                t379
+                                t38
+                                t380
+                                t381
+                                t382
+                                t383
+                                t384
+                                t385
+                                t386
+                                t387
+                                t388
+                                t389
+                                t39
+                                t390
+                                t391
+                                t392
+                                t393
+                                t394
+                                t395
+                                t396
+                                t397
+                                t398
+                                t399
+                                t4
+                                t40
+                                t400
+                                t41
+                                t42
+                                t43
+                                t44
+                                t45
+                                t46
+                                t47
+                                t48
+                                t49
+                                t5
+                                t50
+                                t51
+                                t52
+                                t53
+                                t54
+                                t55
+                                t56
+                                t57
+                                t58
+                                t59
+                                t6
+                                t60
+                                t61
+                                t62
+                                t63
+                                t64
+                                t65
+                                t66
+                                t67
+                                t68
+                                t69
+                                t7
+                                t70
+                                t71
+                                t72
+                                t73
+                                t74
+                                t75
+                                t76
+                                t77
+                                t78
+                                t79
+                                t8
+                                t80
+                                t81
+                                t82
+                                t83
+                                t84
+                                t85
+                                t86
+                                t87
+                                t88
+                                t89
+                                t9
+                                t90
+                                t91
+                                t92
+                                t93
+                                t94
+                                t95
+                                t96
+                                t97
+                                t98
+                                t99)
+                            (and
+                                (= t0 #x0)
+                                (= t2 (= (extract 0 0 rn) #b1))
+                                (if t2 (= t3 #x1) true)
+                                (= t4 (if t2 t3 t0))
+                                (= t5 (= (extract 1 1 rn) #b1))
+                                (if t5 (= t6 (bvadd t4 #x1)) true)
+                                (= t7 (if t5 t6 t4))
+                                (= t8 (= (extract 2 2 rn) #b1))
+                                (if t8 (= t9 (bvadd t7 #x1)) true)
+                                (= t10 (if t8 t9 t7))
+                                (= t11 (= (extract 3 3 rn) #b1))
+                                (if t11 (= t12 (bvadd t10 #x1)) true)
+                                (= t13 (if t11 t12 t10))
+                                (= t14 (= (extract 4 4 rn) #b1))
+                                (if t14 (= t15 (bvadd t13 #x1)) true)
+                                (= t16 (if t14 t15 t13))
+                                (= t17 (= (extract 5 5 rn) #b1))
+                                (if t17 (= t18 (bvadd t16 #x1)) true)
+                                (= t19 (if t17 t18 t16))
+                                (= t20 (= (extract 6 6 rn) #b1))
+                                (if t20 (= t21 (bvadd t19 #x1)) true)
+                                (= t22 (if t20 t21 t19))
+                                (= t23 (= (extract 7 7 rn) #b1))
+                                (if t23 (= t24 (bvadd t22 #x1)) true)
+                                (= t25 (if t23 t24 t22))
+                                (= t26 #x0)
+                                (= t27 (= (extract 8 8 rn) #b1))
+                                (if t27 (= t28 #x1) true)
+                                (= t29 (if t27 t28 t26))
+                                (= t30 (= (extract 9 9 rn) #b1))
+                                (if t30 (= t31 (bvadd t29 #x1)) true)
+                                (= t32 (if t30 t31 t29))
+                                (= t33 (= (extract 10 10 rn) #b1))
+                                (if t33 (= t34 (bvadd t32 #x1)) true)
+                                (= t35 (if t33 t34 t32))
+                                (= t36 (= (extract 11 11 rn) #b1))
+                                (if t36 (= t37 (bvadd t35 #x1)) true)
+                                (= t38 (if t36 t37 t35))
+                                (= t39 (= (extract 12 12 rn) #b1))
+                                (if t39 (= t40 (bvadd t38 #x1)) true)
+                                (= t41 (if t39 t40 t38))
+                                (= t42 (= (extract 13 13 rn) #b1))
+                                (if t42 (= t43 (bvadd t41 #x1)) true)
+                                (= t44 (if t42 t43 t41))
+                                (= t45 (= (extract 14 14 rn) #b1))
+                                (if t45 (= t46 (bvadd t44 #x1)) true)
+                                (= t47 (if t45 t46 t44))
+                                (= t48 (= (extract 15 15 rn) #b1))
+                                (if t48 (= t49 (bvadd t47 #x1)) true)
+                                (= t50 (if t48 t49 t47))
+                                (= t51 #x0)
+                                (= t52 (= (extract 16 16 rn) #b1))
+                                (if t52 (= t53 #x1) true)
+                                (= t54 (if t52 t53 t51))
+                                (= t55 (= (extract 17 17 rn) #b1))
+                                (if t55 (= t56 (bvadd t54 #x1)) true)
+                                (= t57 (if t55 t56 t54))
+                                (= t58 (= (extract 18 18 rn) #b1))
+                                (if t58 (= t59 (bvadd t57 #x1)) true)
+                                (= t60 (if t58 t59 t57))
+                                (= t61 (= (extract 19 19 rn) #b1))
+                                (if t61 (= t62 (bvadd t60 #x1)) true)
+                                (= t63 (if t61 t62 t60))
+                                (= t64 (= (extract 20 20 rn) #b1))
+                                (if t64 (= t65 (bvadd t63 #x1)) true)
+                                (= t66 (if t64 t65 t63))
+                                (= t67 (= (extract 21 21 rn) #b1))
+                                (if t67 (= t68 (bvadd t66 #x1)) true)
+                                (= t69 (if t67 t68 t66))
+                                (= t70 (= (extract 22 22 rn) #b1))
+                                (if t70 (= t71 (bvadd t69 #x1)) true)
+                                (= t72 (if t70 t71 t69))
+                                (= t73 (= (extract 23 23 rn) #b1))
+                                (if t73 (= t74 (bvadd t72 #x1)) true)
+                                (= t75 (if t73 t74 t72))
+                                (= t76 #x0)
+                                (= t77 (= (extract 24 24 rn) #b1))
+                                (if t77 (= t78 #x1) true)
+                                (= t79 (if t77 t78 t76))
+                                (= t80 (= (extract 25 25 rn) #b1))
+                                (if t80 (= t81 (bvadd t79 #x1)) true)
+                                (= t82 (if t80 t81 t79))
+                                (= t83 (= (extract 26 26 rn) #b1))
+                                (if t83 (= t84 (bvadd t82 #x1)) true)
+                                (= t85 (if t83 t84 t82))
+                                (= t86 (= (extract 27 27 rn) #b1))
+                                (if t86 (= t87 (bvadd t85 #x1)) true)
+                                (= t88 (if t86 t87 t85))
+                                (= t89 (= (extract 28 28 rn) #b1))
+                                (if t89 (= t90 (bvadd t88 #x1)) true)
+                                (= t91 (if t89 t90 t88))
+                                (= t92 (= (extract 29 29 rn) #b1))
+                                (if t92 (= t93 (bvadd t91 #x1)) true)
+                                (= t94 (if t92 t93 t91))
+                                (= t95 (= (extract 30 30 rn) #b1))
+                                (if t95 (= t96 (bvadd t94 #x1)) true)
+                                (= t97 (if t95 t96 t94))
+                                (= t98 (= (extract 31 31 rn) #b1))
+                                (if t98 (= t99 (bvadd t97 #x1)) true)
+                                (= t100 (if t98 t99 t97))
+                                (= t101 #x0)
+                                (= t102 (= (extract 32 32 rn) #b1))
+                                (if t102 (= t103 #x1) true)
+                                (= t104 (if t102 t103 t101))
+                                (= t105 (= (extract 33 33 rn) #b1))
+                                (if t105 (= t106 (bvadd t104 #x1)) true)
+                                (= t107 (if t105 t106 t104))
+                                (= t108 (= (extract 34 34 rn) #b1))
+                                (if t108 (= t109 (bvadd t107 #x1)) true)
+                                (= t110 (if t108 t109 t107))
+                                (= t111 (= (extract 35 35 rn) #b1))
+                                (if t111 (= t112 (bvadd t110 #x1)) true)
+                                (= t113 (if t111 t112 t110))
+                                (= t114 (= (extract 36 36 rn) #b1))
+                                (if t114 (= t115 (bvadd t113 #x1)) true)
+                                (= t116 (if t114 t115 t113))
+                                (= t117 (= (extract 37 37 rn) #b1))
+                                (if t117 (= t118 (bvadd t116 #x1)) true)
+                                (= t119 (if t117 t118 t116))
+                                (= t120 (= (extract 38 38 rn) #b1))
+                                (if t120 (= t121 (bvadd t119 #x1)) true)
+                                (= t122 (if t120 t121 t119))
+                                (= t123 (= (extract 39 39 rn) #b1))
+                                (if t123 (= t124 (bvadd t122 #x1)) true)
+                                (= t125 (if t123 t124 t122))
+                                (= t126 #x0)
+                                (= t127 (= (extract 40 40 rn) #b1))
+                                (if t127 (= t128 #x1) true)
+                                (= t129 (if t127 t128 t126))
+                                (= t130 (= (extract 41 41 rn) #b1))
+                                (if t130 (= t131 (bvadd t129 #x1)) true)
+                                (= t132 (if t130 t131 t129))
+                                (= t133 (= (extract 42 42 rn) #b1))
+                                (if t133 (= t134 (bvadd t132 #x1)) true)
+                                (= t135 (if t133 t134 t132))
+                                (= t136 (= (extract 43 43 rn) #b1))
+                                (if t136 (= t137 (bvadd t135 #x1)) true)
+                                (= t138 (if t136 t137 t135))
+                                (= t139 (= (extract 44 44 rn) #b1))
+                                (if t139 (= t140 (bvadd t138 #x1)) true)
+                                (= t141 (if t139 t140 t138))
+                                (= t142 (= (extract 45 45 rn) #b1))
+                                (if t142 (= t143 (bvadd t141 #x1)) true)
+                                (= t144 (if t142 t143 t141))
+                                (= t145 (= (extract 46 46 rn) #b1))
+                                (if t145 (= t146 (bvadd t144 #x1)) true)
+                                (= t147 (if t145 t146 t144))
+                                (= t148 (= (extract 47 47 rn) #b1))
+                                (if t148 (= t149 (bvadd t147 #x1)) true)
+                                (= t150 (if t148 t149 t147))
+                                (= t151 #x0)
+                                (= t152 (= (extract 48 48 rn) #b1))
+                                (if t152 (= t153 #x1) true)
+                                (= t154 (if t152 t153 t151))
+                                (= t155 (= (extract 49 49 rn) #b1))
+                                (if t155 (= t156 (bvadd t154 #x1)) true)
+                                (= t157 (if t155 t156 t154))
+                                (= t158 (= (extract 50 50 rn) #b1))
+                                (if t158 (= t159 (bvadd t157 #x1)) true)
+                                (= t160 (if t158 t159 t157))
+                                (= t161 (= (extract 51 51 rn) #b1))
+                                (if t161 (= t162 (bvadd t160 #x1)) true)
+                                (= t163 (if t161 t162 t160))
+                                (= t164 (= (extract 52 52 rn) #b1))
+                                (if t164 (= t165 (bvadd t163 #x1)) true)
+                                (= t166 (if t164 t165 t163))
+                                (= t167 (= (extract 53 53 rn) #b1))
+                                (if t167 (= t168 (bvadd t166 #x1)) true)
+                                (= t169 (if t167 t168 t166))
+                                (= t170 (= (extract 54 54 rn) #b1))
+                                (if t170 (= t171 (bvadd t169 #x1)) true)
+                                (= t172 (if t170 t171 t169))
+                                (= t173 (= (extract 55 55 rn) #b1))
+                                (if t173 (= t174 (bvadd t172 #x1)) true)
+                                (= t175 (if t173 t174 t172))
+                                (= t176 #x0)
+                                (= t177 (= (extract 56 56 rn) #b1))
+                                (if t177 (= t178 #x1) true)
+                                (= t179 (if t177 t178 t176))
+                                (= t180 (= (extract 57 57 rn) #b1))
+                                (if t180 (= t181 (bvadd t179 #x1)) true)
+                                (= t182 (if t180 t181 t179))
+                                (= t183 (= (extract 58 58 rn) #b1))
+                                (if t183 (= t184 (bvadd t182 #x1)) true)
+                                (= t185 (if t183 t184 t182))
+                                (= t186 (= (extract 59 59 rn) #b1))
+                                (if t186 (= t187 (bvadd t185 #x1)) true)
+                                (= t188 (if t186 t187 t185))
+                                (= t189 (= (extract 60 60 rn) #b1))
+                                (if t189 (= t190 (bvadd t188 #x1)) true)
+                                (= t191 (if t189 t190 t188))
+                                (= t192 (= (extract 61 61 rn) #b1))
+                                (if t192 (= t193 (bvadd t191 #x1)) true)
+                                (= t194 (if t192 t193 t191))
+                                (= t195 (= (extract 62 62 rn) #b1))
+                                (if t195 (= t196 (bvadd t194 #x1)) true)
+                                (= t197 (if t195 t196 t194))
+                                (= t198 (= (extract 63 63 rn) #b1))
+                                (if t198 (= t199 (bvadd t197 #x1)) true)
+                                (= t200 (if t198 t199 t197))
+                                (= t201 #x0)
+                                (= t202 (= (extract 64 64 rn) #b1))
+                                (if t202 (= t203 #x1) true)
+                                (= t204 (if t202 t203 t201))
+                                (= t205 (= (extract 65 65 rn) #b1))
+                                (if t205 (= t206 (bvadd t204 #x1)) true)
+                                (= t207 (if t205 t206 t204))
+                                (= t208 (= (extract 66 66 rn) #b1))
+                                (if t208 (= t209 (bvadd t207 #x1)) true)
+                                (= t210 (if t208 t209 t207))
+                                (= t211 (= (extract 67 67 rn) #b1))
+                                (if t211 (= t212 (bvadd t210 #x1)) true)
+                                (= t213 (if t211 t212 t210))
+                                (= t214 (= (extract 68 68 rn) #b1))
+                                (if t214 (= t215 (bvadd t213 #x1)) true)
+                                (= t216 (if t214 t215 t213))
+                                (= t217 (= (extract 69 69 rn) #b1))
+                                (if t217 (= t218 (bvadd t216 #x1)) true)
+                                (= t219 (if t217 t218 t216))
+                                (= t220 (= (extract 70 70 rn) #b1))
+                                (if t220 (= t221 (bvadd t219 #x1)) true)
+                                (= t222 (if t220 t221 t219))
+                                (= t223 (= (extract 71 71 rn) #b1))
+                                (if t223 (= t224 (bvadd t222 #x1)) true)
+                                (= t225 (if t223 t224 t222))
+                                (= t226 #x0)
+                                (= t227 (= (extract 72 72 rn) #b1))
+                                (if t227 (= t228 #x1) true)
+                                (= t229 (if t227 t228 t226))
+                                (= t230 (= (extract 73 73 rn) #b1))
+                                (if t230 (= t231 (bvadd t229 #x1)) true)
+                                (= t232 (if t230 t231 t229))
+                                (= t233 (= (extract 74 74 rn) #b1))
+                                (if t233 (= t234 (bvadd t232 #x1)) true)
+                                (= t235 (if t233 t234 t232))
+                                (= t236 (= (extract 75 75 rn) #b1))
+                                (if t236 (= t237 (bvadd t235 #x1)) true)
+                                (= t238 (if t236 t237 t235))
+                                (= t239 (= (extract 76 76 rn) #b1))
+                                (if t239 (= t240 (bvadd t238 #x1)) true)
+                                (= t241 (if t239 t240 t238))
+                                (= t242 (= (extract 77 77 rn) #b1))
+                                (if t242 (= t243 (bvadd t241 #x1)) true)
+                                (= t244 (if t242 t243 t241))
+                                (= t245 (= (extract 78 78 rn) #b1))
+                                (if t245 (= t246 (bvadd t244 #x1)) true)
+                                (= t247 (if t245 t246 t244))
+                                (= t248 (= (extract 79 79 rn) #b1))
+                                (if t248 (= t249 (bvadd t247 #x1)) true)
+                                (= t250 (if t248 t249 t247))
+                                (= t251 #x0)
+                                (= t252 (= (extract 80 80 rn) #b1))
+                                (if t252 (= t253 #x1) true)
+                                (= t254 (if t252 t253 t251))
+                                (= t255 (= (extract 81 81 rn) #b1))
+                                (if t255 (= t256 (bvadd t254 #x1)) true)
+                                (= t257 (if t255 t256 t254))
+                                (= t258 (= (extract 82 82 rn) #b1))
+                                (if t258 (= t259 (bvadd t257 #x1)) true)
+                                (= t260 (if t258 t259 t257))
+                                (= t261 (= (extract 83 83 rn) #b1))
+                                (if t261 (= t262 (bvadd t260 #x1)) true)
+                                (= t263 (if t261 t262 t260))
+                                (= t264 (= (extract 84 84 rn) #b1))
+                                (if t264 (= t265 (bvadd t263 #x1)) true)
+                                (= t266 (if t264 t265 t263))
+                                (= t267 (= (extract 85 85 rn) #b1))
+                                (if t267 (= t268 (bvadd t266 #x1)) true)
+                                (= t269 (if t267 t268 t266))
+                                (= t270 (= (extract 86 86 rn) #b1))
+                                (if t270 (= t271 (bvadd t269 #x1)) true)
+                                (= t272 (if t270 t271 t269))
+                                (= t273 (= (extract 87 87 rn) #b1))
+                                (if t273 (= t274 (bvadd t272 #x1)) true)
+                                (= t275 (if t273 t274 t272))
+                                (= t276 #x0)
+                                (= t277 (= (extract 88 88 rn) #b1))
+                                (if t277 (= t278 #x1) true)
+                                (= t279 (if t277 t278 t276))
+                                (= t280 (= (extract 89 89 rn) #b1))
+                                (if t280 (= t281 (bvadd t279 #x1)) true)
+                                (= t282 (if t280 t281 t279))
+                                (= t283 (= (extract 90 90 rn) #b1))
+                                (if t283 (= t284 (bvadd t282 #x1)) true)
+                                (= t285 (if t283 t284 t282))
+                                (= t286 (= (extract 91 91 rn) #b1))
+                                (if t286 (= t287 (bvadd t285 #x1)) true)
+                                (= t288 (if t286 t287 t285))
+                                (= t289 (= (extract 92 92 rn) #b1))
+                                (if t289 (= t290 (bvadd t288 #x1)) true)
+                                (= t291 (if t289 t290 t288))
+                                (= t292 (= (extract 93 93 rn) #b1))
+                                (if t292 (= t293 (bvadd t291 #x1)) true)
+                                (= t294 (if t292 t293 t291))
+                                (= t295 (= (extract 94 94 rn) #b1))
+                                (if t295 (= t296 (bvadd t294 #x1)) true)
+                                (= t297 (if t295 t296 t294))
+                                (= t298 (= (extract 95 95 rn) #b1))
+                                (if t298 (= t299 (bvadd t297 #x1)) true)
+                                (= t300 (if t298 t299 t297))
+                                (= t301 #x0)
+                                (= t302 (= (extract 96 96 rn) #b1))
+                                (if t302 (= t303 #x1) true)
+                                (= t304 (if t302 t303 t301))
+                                (= t305 (= (extract 97 97 rn) #b1))
+                                (if t305 (= t306 (bvadd t304 #x1)) true)
+                                (= t307 (if t305 t306 t304))
+                                (= t308 (= (extract 98 98 rn) #b1))
+                                (if t308 (= t309 (bvadd t307 #x1)) true)
+                                (= t310 (if t308 t309 t307))
+                                (= t311 (= (extract 99 99 rn) #b1))
+                                (if t311 (= t312 (bvadd t310 #x1)) true)
+                                (= t313 (if t311 t312 t310))
+                                (= t314 (= (extract 100 100 rn) #b1))
+                                (if t314 (= t315 (bvadd t313 #x1)) true)
+                                (= t316 (if t314 t315 t313))
+                                (= t317 (= (extract 101 101 rn) #b1))
+                                (if t317 (= t318 (bvadd t316 #x1)) true)
+                                (= t319 (if t317 t318 t316))
+                                (= t320 (= (extract 102 102 rn) #b1))
+                                (if t320 (= t321 (bvadd t319 #x1)) true)
+                                (= t322 (if t320 t321 t319))
+                                (= t323 (= (extract 103 103 rn) #b1))
+                                (if t323 (= t324 (bvadd t322 #x1)) true)
+                                (= t325 (if t323 t324 t322))
+                                (= t326 #x0)
+                                (= t327 (= (extract 104 104 rn) #b1))
+                                (if t327 (= t328 #x1) true)
+                                (= t329 (if t327 t328 t326))
+                                (= t330 (= (extract 105 105 rn) #b1))
+                                (if t330 (= t331 (bvadd t329 #x1)) true)
+                                (= t332 (if t330 t331 t329))
+                                (= t333 (= (extract 106 106 rn) #b1))
+                                (if t333 (= t334 (bvadd t332 #x1)) true)
+                                (= t335 (if t333 t334 t332))
+                                (= t336 (= (extract 107 107 rn) #b1))
+                                (if t336 (= t337 (bvadd t335 #x1)) true)
+                                (= t338 (if t336 t337 t335))
+                                (= t339 (= (extract 108 108 rn) #b1))
+                                (if t339 (= t340 (bvadd t338 #x1)) true)
+                                (= t341 (if t339 t340 t338))
+                                (= t342 (= (extract 109 109 rn) #b1))
+                                (if t342 (= t343 (bvadd t341 #x1)) true)
+                                (= t344 (if t342 t343 t341))
+                                (= t345 (= (extract 110 110 rn) #b1))
+                                (if t345 (= t346 (bvadd t344 #x1)) true)
+                                (= t347 (if t345 t346 t344))
+                                (= t348 (= (extract 111 111 rn) #b1))
+                                (if t348 (= t349 (bvadd t347 #x1)) true)
+                                (= t350 (if t348 t349 t347))
+                                (= t351 #x0)
+                                (= t352 (= (extract 112 112 rn) #b1))
+                                (if t352 (= t353 #x1) true)
+                                (= t354 (if t352 t353 t351))
+                                (= t355 (= (extract 113 113 rn) #b1))
+                                (if t355 (= t356 (bvadd t354 #x1)) true)
+                                (= t357 (if t355 t356 t354))
+                                (= t358 (= (extract 114 114 rn) #b1))
+                                (if t358 (= t359 (bvadd t357 #x1)) true)
+                                (= t360 (if t358 t359 t357))
+                                (= t361 (= (extract 115 115 rn) #b1))
+                                (if t361 (= t362 (bvadd t360 #x1)) true)
+                                (= t363 (if t361 t362 t360))
+                                (= t364 (= (extract 116 116 rn) #b1))
+                                (if t364 (= t365 (bvadd t363 #x1)) true)
+                                (= t366 (if t364 t365 t363))
+                                (= t367 (= (extract 117 117 rn) #b1))
+                                (if t367 (= t368 (bvadd t366 #x1)) true)
+                                (= t369 (if t367 t368 t366))
+                                (= t370 (= (extract 118 118 rn) #b1))
+                                (if t370 (= t371 (bvadd t369 #x1)) true)
+                                (= t372 (if t370 t371 t369))
+                                (= t373 (= (extract 119 119 rn) #b1))
+                                (if t373 (= t374 (bvadd t372 #x1)) true)
+                                (= t375 (if t373 t374 t372))
+                                (= t376 #x0)
+                                (= t377 (= (extract 120 120 rn) #b1))
+                                (if t377 (= t378 #x1) true)
+                                (= t379 (if t377 t378 t376))
+                                (= t380 (= (extract 121 121 rn) #b1))
+                                (if t380 (= t381 (bvadd t379 #x1)) true)
+                                (= t382 (if t380 t381 t379))
+                                (= t383 (= (extract 122 122 rn) #b1))
+                                (if t383 (= t384 (bvadd t382 #x1)) true)
+                                (= t385 (if t383 t384 t382))
+                                (= t386 (= (extract 123 123 rn) #b1))
+                                (if t386 (= t387 (bvadd t385 #x1)) true)
+                                (= t388 (if t386 t387 t385))
+                                (= t389 (= (extract 124 124 rn) #b1))
+                                (if t389 (= t390 (bvadd t388 #x1)) true)
+                                (= t391 (if t389 t390 t388))
+                                (= t392 (= (extract 125 125 rn) #b1))
+                                (if t392 (= t393 (bvadd t391 #x1)) true)
+                                (= t394 (if t392 t393 t391))
+                                (= t395 (= (extract 126 126 rn) #b1))
+                                (if t395 (= t396 (bvadd t394 #x1)) true)
+                                (= t397 (if t395 t396 t394))
+                                (= t398 (= (extract 127 127 rn) #b1))
+                                (if t398 (= t399 (bvadd t397 #x1)) true)
+                                (= t400 (if t398 t399 t397))
+                                (=
+                                    rd
+                                    (concat
+                                        (zero_ext 8 t400)
+                                        (concat
+                                            (zero_ext 8 t375)
+                                            (concat
+                                                (zero_ext 8 t350)
+                                                (concat
+                                                    (zero_ext 8 t325)
+                                                    (concat
+                                                        (zero_ext 8 t300)
+                                                        (concat
+                                                            (zero_ext 8 t275)
+                                                            (concat
+                                                                (zero_ext 8 t250)
+                                                                (concat
+                                                                    (zero_ext 8 t225)
+                                                                    (concat
+                                                                        (zero_ext 8 t200)
+                                                                        (concat
+                                                                            (zero_ext 8 t175)
+                                                                            (concat
+                                                                                (zero_ext 8 t150)
+                                                                                (concat
+                                                                                    (zero_ext 8 t125)
+                                                                                    (concat
+                                                                                        (zero_ext 8 t100)
+                                                                                        (concat
+                                                                                            (zero_ext 8 t75)
+                                                                                            (concat
+                                                                                                (zero_ext 8 t50)
+                                                                                                (zero_ext
+                                                                                                    8
+                                                                                                    t25))))))))))))))))))))))
+            ((Size8x8)
+                (match
+                    op
+                    ((Cnt)
+                        (with
+                            (t0
+                                t10
+                                t100
+                                t101
+                                t102
+                                t103
+                                t104
+                                t105
+                                t106
+                                t107
+                                t108
+                                t109
+                                t11
+                                t110
+                                t111
+                                t112
+                                t113
+                                t114
+                                t115
+                                t116
+                                t117
+                                t118
+                                t119
+                                t12
+                                t120
+                                t121
+                                t122
+                                t123
+                                t124
+                                t125
+                                t126
+                                t127
+                                t128
+                                t129
+                                t13
+                                t130
+                                t131
+                                t132
+                                t133
+                                t134
+                                t135
+                                t136
+                                t137
+                                t138
+                                t139
+                                t14
+                                t140
+                                t141
+                                t142
+                                t143
+                                t144
+                                t145
+                                t146
+                                t147
+                                t148
+                                t149
+                                t15
+                                t150
+                                t151
+                                t152
+                                t153
+                                t154
+                                t155
+                                t156
+                                t157
+                                t158
+                                t159
+                                t16
+                                t160
+                                t161
+                                t162
+                                t163
+                                t164
+                                t165
+                                t166
+                                t167
+                                t168
+                                t169
+                                t17
+                                t170
+                                t171
+                                t172
+                                t173
+                                t174
+                                t175
+                                t176
+                                t177
+                                t178
+                                t179
+                                t18
+                                t180
+                                t181
+                                t182
+                                t183
+                                t184
+                                t185
+                                t186
+                                t187
+                                t188
+                                t189
+                                t19
+                                t190
+                                t191
+                                t192
+                                t193
+                                t194
+                                t195
+                                t196
+                                t197
+                                t198
+                                t199
+                                t2
+                                t20
+                                t200
+                                t21
+                                t22
+                                t23
+                                t24
+                                t25
+                                t26
+                                t27
+                                t28
+                                t29
+                                t3
+                                t30
+                                t31
+                                t32
+                                t33
+                                t34
+                                t35
+                                t36
+                                t37
+                                t38
+                                t39
+                                t4
+                                t40
+                                t41
+                                t42
+                                t43
+                                t44
+                                t45
+                                t46
+                                t47
+                                t48
+                                t49
+                                t5
+                                t50
+                                t51
+                                t52
+                                t53
+                                t54
+                                t55
+                                t56
+                                t57
+                                t58
+                                t59
+                                t6
+                                t60
+                                t61
+                                t62
+                                t63
+                                t64
+                                t65
+                                t66
+                                t67
+                                t68
+                                t69
+                                t7
+                                t70
+                                t71
+                                t72
+                                t73
+                                t74
+                                t75
+                                t76
+                                t77
+                                t78
+                                t79
+                                t8
+                                t80
+                                t81
+                                t82
+                                t83
+                                t84
+                                t85
+                                t86
+                                t87
+                                t88
+                                t89
+                                t9
+                                t90
+                                t91
+                                t92
+                                t93
+                                t94
+                                t95
+                                t96
+                                t97
+                                t98
+                                t99)
+                            (and
+                                (= t0 #x0)
+                                (= t2 (= (extract 0 0 rn) #b1))
+                                (if t2 (= t3 #x1) true)
+                                (= t4 (if t2 t3 t0))
+                                (= t5 (= (extract 1 1 rn) #b1))
+                                (if t5 (= t6 (bvadd t4 #x1)) true)
+                                (= t7 (if t5 t6 t4))
+                                (= t8 (= (extract 2 2 rn) #b1))
+                                (if t8 (= t9 (bvadd t7 #x1)) true)
+                                (= t10 (if t8 t9 t7))
+                                (= t11 (= (extract 3 3 rn) #b1))
+                                (if t11 (= t12 (bvadd t10 #x1)) true)
+                                (= t13 (if t11 t12 t10))
+                                (= t14 (= (extract 4 4 rn) #b1))
+                                (if t14 (= t15 (bvadd t13 #x1)) true)
+                                (= t16 (if t14 t15 t13))
+                                (= t17 (= (extract 5 5 rn) #b1))
+                                (if t17 (= t18 (bvadd t16 #x1)) true)
+                                (= t19 (if t17 t18 t16))
+                                (= t20 (= (extract 6 6 rn) #b1))
+                                (if t20 (= t21 (bvadd t19 #x1)) true)
+                                (= t22 (if t20 t21 t19))
+                                (= t23 (= (extract 7 7 rn) #b1))
+                                (if t23 (= t24 (bvadd t22 #x1)) true)
+                                (= t25 (if t23 t24 t22))
+                                (= t26 #x0)
+                                (= t27 (= (extract 8 8 rn) #b1))
+                                (if t27 (= t28 #x1) true)
+                                (= t29 (if t27 t28 t26))
+                                (= t30 (= (extract 9 9 rn) #b1))
+                                (if t30 (= t31 (bvadd t29 #x1)) true)
+                                (= t32 (if t30 t31 t29))
+                                (= t33 (= (extract 10 10 rn) #b1))
+                                (if t33 (= t34 (bvadd t32 #x1)) true)
+                                (= t35 (if t33 t34 t32))
+                                (= t36 (= (extract 11 11 rn) #b1))
+                                (if t36 (= t37 (bvadd t35 #x1)) true)
+                                (= t38 (if t36 t37 t35))
+                                (= t39 (= (extract 12 12 rn) #b1))
+                                (if t39 (= t40 (bvadd t38 #x1)) true)
+                                (= t41 (if t39 t40 t38))
+                                (= t42 (= (extract 13 13 rn) #b1))
+                                (if t42 (= t43 (bvadd t41 #x1)) true)
+                                (= t44 (if t42 t43 t41))
+                                (= t45 (= (extract 14 14 rn) #b1))
+                                (if t45 (= t46 (bvadd t44 #x1)) true)
+                                (= t47 (if t45 t46 t44))
+                                (= t48 (= (extract 15 15 rn) #b1))
+                                (if t48 (= t49 (bvadd t47 #x1)) true)
+                                (= t50 (if t48 t49 t47))
+                                (= t51 #x0)
+                                (= t52 (= (extract 16 16 rn) #b1))
+                                (if t52 (= t53 #x1) true)
+                                (= t54 (if t52 t53 t51))
+                                (= t55 (= (extract 17 17 rn) #b1))
+                                (if t55 (= t56 (bvadd t54 #x1)) true)
+                                (= t57 (if t55 t56 t54))
+                                (= t58 (= (extract 18 18 rn) #b1))
+                                (if t58 (= t59 (bvadd t57 #x1)) true)
+                                (= t60 (if t58 t59 t57))
+                                (= t61 (= (extract 19 19 rn) #b1))
+                                (if t61 (= t62 (bvadd t60 #x1)) true)
+                                (= t63 (if t61 t62 t60))
+                                (= t64 (= (extract 20 20 rn) #b1))
+                                (if t64 (= t65 (bvadd t63 #x1)) true)
+                                (= t66 (if t64 t65 t63))
+                                (= t67 (= (extract 21 21 rn) #b1))
+                                (if t67 (= t68 (bvadd t66 #x1)) true)
+                                (= t69 (if t67 t68 t66))
+                                (= t70 (= (extract 22 22 rn) #b1))
+                                (if t70 (= t71 (bvadd t69 #x1)) true)
+                                (= t72 (if t70 t71 t69))
+                                (= t73 (= (extract 23 23 rn) #b1))
+                                (if t73 (= t74 (bvadd t72 #x1)) true)
+                                (= t75 (if t73 t74 t72))
+                                (= t76 #x0)
+                                (= t77 (= (extract 24 24 rn) #b1))
+                                (if t77 (= t78 #x1) true)
+                                (= t79 (if t77 t78 t76))
+                                (= t80 (= (extract 25 25 rn) #b1))
+                                (if t80 (= t81 (bvadd t79 #x1)) true)
+                                (= t82 (if t80 t81 t79))
+                                (= t83 (= (extract 26 26 rn) #b1))
+                                (if t83 (= t84 (bvadd t82 #x1)) true)
+                                (= t85 (if t83 t84 t82))
+                                (= t86 (= (extract 27 27 rn) #b1))
+                                (if t86 (= t87 (bvadd t85 #x1)) true)
+                                (= t88 (if t86 t87 t85))
+                                (= t89 (= (extract 28 28 rn) #b1))
+                                (if t89 (= t90 (bvadd t88 #x1)) true)
+                                (= t91 (if t89 t90 t88))
+                                (= t92 (= (extract 29 29 rn) #b1))
+                                (if t92 (= t93 (bvadd t91 #x1)) true)
+                                (= t94 (if t92 t93 t91))
+                                (= t95 (= (extract 30 30 rn) #b1))
+                                (if t95 (= t96 (bvadd t94 #x1)) true)
+                                (= t97 (if t95 t96 t94))
+                                (= t98 (= (extract 31 31 rn) #b1))
+                                (if t98 (= t99 (bvadd t97 #x1)) true)
+                                (= t100 (if t98 t99 t97))
+                                (= t101 #x0)
+                                (= t102 (= (extract 32 32 rn) #b1))
+                                (if t102 (= t103 #x1) true)
+                                (= t104 (if t102 t103 t101))
+                                (= t105 (= (extract 33 33 rn) #b1))
+                                (if t105 (= t106 (bvadd t104 #x1)) true)
+                                (= t107 (if t105 t106 t104))
+                                (= t108 (= (extract 34 34 rn) #b1))
+                                (if t108 (= t109 (bvadd t107 #x1)) true)
+                                (= t110 (if t108 t109 t107))
+                                (= t111 (= (extract 35 35 rn) #b1))
+                                (if t111 (= t112 (bvadd t110 #x1)) true)
+                                (= t113 (if t111 t112 t110))
+                                (= t114 (= (extract 36 36 rn) #b1))
+                                (if t114 (= t115 (bvadd t113 #x1)) true)
+                                (= t116 (if t114 t115 t113))
+                                (= t117 (= (extract 37 37 rn) #b1))
+                                (if t117 (= t118 (bvadd t116 #x1)) true)
+                                (= t119 (if t117 t118 t116))
+                                (= t120 (= (extract 38 38 rn) #b1))
+                                (if t120 (= t121 (bvadd t119 #x1)) true)
+                                (= t122 (if t120 t121 t119))
+                                (= t123 (= (extract 39 39 rn) #b1))
+                                (if t123 (= t124 (bvadd t122 #x1)) true)
+                                (= t125 (if t123 t124 t122))
+                                (= t126 #x0)
+                                (= t127 (= (extract 40 40 rn) #b1))
+                                (if t127 (= t128 #x1) true)
+                                (= t129 (if t127 t128 t126))
+                                (= t130 (= (extract 41 41 rn) #b1))
+                                (if t130 (= t131 (bvadd t129 #x1)) true)
+                                (= t132 (if t130 t131 t129))
+                                (= t133 (= (extract 42 42 rn) #b1))
+                                (if t133 (= t134 (bvadd t132 #x1)) true)
+                                (= t135 (if t133 t134 t132))
+                                (= t136 (= (extract 43 43 rn) #b1))
+                                (if t136 (= t137 (bvadd t135 #x1)) true)
+                                (= t138 (if t136 t137 t135))
+                                (= t139 (= (extract 44 44 rn) #b1))
+                                (if t139 (= t140 (bvadd t138 #x1)) true)
+                                (= t141 (if t139 t140 t138))
+                                (= t142 (= (extract 45 45 rn) #b1))
+                                (if t142 (= t143 (bvadd t141 #x1)) true)
+                                (= t144 (if t142 t143 t141))
+                                (= t145 (= (extract 46 46 rn) #b1))
+                                (if t145 (= t146 (bvadd t144 #x1)) true)
+                                (= t147 (if t145 t146 t144))
+                                (= t148 (= (extract 47 47 rn) #b1))
+                                (if t148 (= t149 (bvadd t147 #x1)) true)
+                                (= t150 (if t148 t149 t147))
+                                (= t151 #x0)
+                                (= t152 (= (extract 48 48 rn) #b1))
+                                (if t152 (= t153 #x1) true)
+                                (= t154 (if t152 t153 t151))
+                                (= t155 (= (extract 49 49 rn) #b1))
+                                (if t155 (= t156 (bvadd t154 #x1)) true)
+                                (= t157 (if t155 t156 t154))
+                                (= t158 (= (extract 50 50 rn) #b1))
+                                (if t158 (= t159 (bvadd t157 #x1)) true)
+                                (= t160 (if t158 t159 t157))
+                                (= t161 (= (extract 51 51 rn) #b1))
+                                (if t161 (= t162 (bvadd t160 #x1)) true)
+                                (= t163 (if t161 t162 t160))
+                                (= t164 (= (extract 52 52 rn) #b1))
+                                (if t164 (= t165 (bvadd t163 #x1)) true)
+                                (= t166 (if t164 t165 t163))
+                                (= t167 (= (extract 53 53 rn) #b1))
+                                (if t167 (= t168 (bvadd t166 #x1)) true)
+                                (= t169 (if t167 t168 t166))
+                                (= t170 (= (extract 54 54 rn) #b1))
+                                (if t170 (= t171 (bvadd t169 #x1)) true)
+                                (= t172 (if t170 t171 t169))
+                                (= t173 (= (extract 55 55 rn) #b1))
+                                (if t173 (= t174 (bvadd t172 #x1)) true)
+                                (= t175 (if t173 t174 t172))
+                                (= t176 #x0)
+                                (= t177 (= (extract 56 56 rn) #b1))
+                                (if t177 (= t178 #x1) true)
+                                (= t179 (if t177 t178 t176))
+                                (= t180 (= (extract 57 57 rn) #b1))
+                                (if t180 (= t181 (bvadd t179 #x1)) true)
+                                (= t182 (if t180 t181 t179))
+                                (= t183 (= (extract 58 58 rn) #b1))
+                                (if t183 (= t184 (bvadd t182 #x1)) true)
+                                (= t185 (if t183 t184 t182))
+                                (= t186 (= (extract 59 59 rn) #b1))
+                                (if t186 (= t187 (bvadd t185 #x1)) true)
+                                (= t188 (if t186 t187 t185))
+                                (= t189 (= (extract 60 60 rn) #b1))
+                                (if t189 (= t190 (bvadd t188 #x1)) true)
+                                (= t191 (if t189 t190 t188))
+                                (= t192 (= (extract 61 61 rn) #b1))
+                                (if t192 (= t193 (bvadd t191 #x1)) true)
+                                (= t194 (if t192 t193 t191))
+                                (= t195 (= (extract 62 62 rn) #b1))
+                                (if t195 (= t196 (bvadd t194 #x1)) true)
+                                (= t197 (if t195 t196 t194))
+                                (= t198 (= (extract 63 63 rn) #b1))
+                                (if t198 (= t199 (bvadd t197 #x1)) true)
+                                (= t200 (if t198 t199 t197))
+                                (=
+                                    rd
+                                    (zero_ext
+                                        128
+                                        (concat
+                                            (zero_ext 8 t200)
+                                            (concat
+                                                (zero_ext 8 t175)
+                                                (concat
+                                                    (zero_ext 8 t150)
+                                                    (concat
+                                                        (zero_ext 8 t125)
+                                                        (concat
+                                                            (zero_ext 8 t100)
+                                                            (concat
+                                                                (zero_ext 8 t75)
+                                                                (concat
+                                                                    (zero_ext 8 t50)
+                                                                    (zero_ext 8 t25)))))))))))))))))
+    (require (match size ((Size8x16) (match op ((Cnt) true))) ((Size8x8) (match op ((Cnt) true))))))
diff --git a/cranelift/codegen/src/isa/aarch64/spec/vec_rrr.isle b/cranelift/codegen/src/isa/aarch64/spec/vec_rrr.isle
new file mode 100644
index 000000000000..d6838506bfb2
--- /dev/null
+++ b/cranelift/codegen/src/isa/aarch64/spec/vec_rrr.isle
@@ -0,0 +1,83 @@
+;; GENERATED BY `isaspec`. DO NOT EDIT!!!
+
+(attr MInst.VecRRR (tag isaspec_generated))
+
+(spec
+    (MInst.VecRRR alu_op rd rn rm size)
+    (provide
+        (match
+            size
+            ((Size8x16)
+                (match
+                    alu_op
+                    ((Addp)
+                        (=
+                            rd
+                            (concat
+                                (bvadd (extract 119 112 rm) (extract 127 120 rm))
+                                (concat
+                                    (bvadd (extract 103 96 rm) (extract 111 104 rm))
+                                    (concat
+                                        (bvadd (extract 87 80 rm) (extract 95 88 rm))
+                                        (concat
+                                            (bvadd (extract 71 64 rm) (extract 79 72 rm))
+                                            (concat
+                                                (bvadd (extract 55 48 rm) (extract 63 56 rm))
+                                                (concat
+                                                    (bvadd (extract 39 32 rm) (extract 47 40 rm))
+                                                    (concat
+                                                        (bvadd (extract 23 16 rm) (extract 31 24 rm))
+                                                        (concat
+                                                            (bvadd (extract 7 0 rm) (extract 15 8 rm))
+                                                            (concat
+                                                                (bvadd (extract 119 112 rn) (extract 127 120 rn))
+                                                                (concat
+                                                                    (bvadd (extract 103 96 rn) (extract 111 104 rn))
+                                                                    (concat
+                                                                        (bvadd (extract 87 80 rn) (extract 95 88 rn))
+                                                                        (concat
+                                                                            (bvadd
+                                                                                (extract 71 64 rn)
+                                                                                (extract 79 72 rn))
+                                                                            (concat
+                                                                                (bvadd
+                                                                                    (extract 55 48 rn)
+                                                                                    (extract 63 56 rn))
+                                                                                (concat
+                                                                                    (bvadd
+                                                                                        (extract 39 32 rn)
+                                                                                        (extract 47 40 rn))
+                                                                                    (concat
+                                                                                        (bvadd
+                                                                                            (extract 23 16 rn)
+                                                                                            (extract 31 24 rn))
+                                                                                        (bvadd
+                                                                                            (extract 7 0 rn)
+                                                                                            (extract
+                                                                                                15
+                                                                                                8
+                                                                                                rn)))))))))))))))))))))
+            ((Size8x8)
+                (match
+                    alu_op
+                    ((Addp)
+                        (=
+                            rd
+                            (zero_ext
+                                128
+                                (concat
+                                    (bvadd (extract 55 48 rm) (extract 63 56 rm))
+                                    (concat
+                                        (bvadd (extract 39 32 rm) (extract 47 40 rm))
+                                        (concat
+                                            (bvadd (extract 23 16 rm) (extract 31 24 rm))
+                                            (concat
+                                                (bvadd (extract 7 0 rm) (extract 15 8 rm))
+                                                (concat
+                                                    (bvadd (extract 55 48 rn) (extract 63 56 rn))
+                                                    (concat
+                                                        (bvadd (extract 39 32 rn) (extract 47 40 rn))
+                                                        (concat
+                                                            (bvadd (extract 23 16 rn) (extract 31 24 rn))
+                                                            (bvadd (extract 7 0 rn) (extract 15 8 rn))))))))))))))))
+    (require (match size ((Size8x16) (match alu_op ((Addp) true))) ((Size8x8) (match alu_op ((Addp) true))))))
diff --git a/cranelift/codegen/src/isa/call_conv.rs b/cranelift/codegen/src/isa/call_conv.rs
index fea9ff0a42dc..23196242976b 100644
--- a/cranelift/codegen/src/isa/call_conv.rs
+++ b/cranelift/codegen/src/isa/call_conv.rs
@@ -33,6 +33,12 @@ pub enum CallConv {
     /// FIXME: remove this when Wasmtime uses the "tail" calling convention for
     /// all wasm functions.
     WasmtimeSystemV,
+    /// The winch calling convention, not ABI-stable.
+    ///
+    /// The main difference to WasmtimeSystemV is that the winch calling
+    /// convention defines no callee-save registers, and restricts the number
+    /// of return registers to one integer, and one floating point.
+    Winch,
 }
 
 impl CallConv {
@@ -97,6 +103,7 @@ impl fmt::Display for CallConv {
             Self::AppleAarch64 => "apple_aarch64",
             Self::Probestack => "probestack",
             Self::WasmtimeSystemV => "wasmtime_system_v",
+            Self::Winch => "winch",
         })
     }
 }
@@ -113,6 +120,7 @@ impl str::FromStr for CallConv {
             "apple_aarch64" => Ok(Self::AppleAarch64),
             "probestack" => Ok(Self::Probestack),
             "wasmtime_system_v" => Ok(Self::WasmtimeSystemV),
+            "winch" => Ok(Self::Winch),
             _ => Err(()),
         }
     }
diff --git a/cranelift/codegen/src/isa/mod.rs b/cranelift/codegen/src/isa/mod.rs
index 4508c68d7758..5ba1b8610c93 100644
--- a/cranelift/codegen/src/isa/mod.rs
+++ b/cranelift/codegen/src/isa/mod.rs
@@ -52,6 +52,7 @@ use crate::ir::{self, Function, Type};
 use crate::isa::unwind::{systemv::RegisterMappingError, UnwindInfoKind};
 use crate::machinst::{CompiledCode, CompiledCodeStencil, TextSectionBuilder};
 use crate::settings;
+use crate::settings::Configurable;
 use crate::settings::SetResult;
 use crate::CodegenResult;
 use alloc::{boxed::Box, sync::Arc, vec::Vec};
@@ -74,6 +75,13 @@ pub mod riscv64;
 #[cfg(feature = "s390x")]
 mod s390x;
 
+#[cfg(feature = "pulley")]
+mod pulley32;
+#[cfg(feature = "pulley")]
+mod pulley64;
+#[cfg(feature = "pulley")]
+mod pulley_shared;
+
 pub mod unwind;
 
 mod call_conv;
@@ -103,6 +111,8 @@ pub fn lookup(triple: Triple) -> Result<Builder, LookupError> {
         Architecture::Aarch64 { .. } => isa_builder!(aarch64, (feature = "arm64"), triple),
         Architecture::S390x { .. } => isa_builder!(s390x, (feature = "s390x"), triple),
         Architecture::Riscv64 { .. } => isa_builder!(riscv64, (feature = "riscv64"), triple),
+        Architecture::Pulley32 => isa_builder!(pulley32, (feature = "pulley"), triple),
+        Architecture::Pulley64 => isa_builder!(pulley64, (feature = "pulley"), triple),
         _ => Err(LookupError::Unsupported),
     }
 }
@@ -115,7 +125,6 @@ pub const ALL_ARCHITECTURES: &[&str] = &["x86_64", "aarch64", "s390x", "riscv64"
 /// Look for a supported ISA with the given `name`.
 /// Return a builder that can create a corresponding `TargetIsa`.
 pub fn lookup_by_name(name: &str) -> Result<Builder, LookupError> {
-    use alloc::str::FromStr;
     lookup(triple!(name))
 }
 
@@ -175,6 +184,22 @@ impl<T> IsaBuilder<T> {
         }
     }
 
+    /// Creates a new [Builder] from a [TargetIsa], copying all flags in the
+    /// process.
+    pub fn from_target_isa(target_isa: &dyn TargetIsa) -> Builder {
+        // We should always be able to find the builder for the TargetISA, since presumably we
+        // also generated the previous TargetISA at some point
+        let triple = target_isa.triple().clone();
+        let mut builder = self::lookup(triple).expect("Could not find triple for target ISA");
+
+        // Copy ISA Flags
+        for flag in target_isa.isa_flags() {
+            builder.set(&flag.name, &flag.value_string()).unwrap();
+        }
+
+        builder
+    }
+
     /// Gets the triple for the builder.
     pub fn triple(&self) -> &Triple {
         &self.triple
@@ -222,6 +247,12 @@ pub struct TargetFrontendConfig {
 
     /// The pointer width of the target.
     pub pointer_width: PointerWidth,
+
+    /// The log2 of the target's page size and alignment.
+    ///
+    /// Note that this may be an upper-bound that is larger than necessary for
+    /// some platforms since it may depend on runtime configuration.
+    pub page_size_align_log2: u8,
 }
 
 impl TargetFrontendConfig {
@@ -317,6 +348,12 @@ pub trait TargetIsa: fmt::Display + Send + Sync {
     /// alignment, for performance, required by this ISA.
     fn function_alignment(&self) -> FunctionAlignment;
 
+    /// The log2 of the target's page size and alignment.
+    ///
+    /// Note that this may be an upper-bound that is larger than necessary for
+    /// some platforms since it may depend on runtime configuration.
+    fn page_size_align_log2(&self) -> u8;
+
     /// Create a polymorphic TargetIsa from this specific implementation.
     fn wrapped(self) -> OwnedTargetIsa
     where
@@ -417,6 +454,7 @@ impl<'a> dyn TargetIsa + 'a {
         TargetFrontendConfig {
             default_call_conv: self.default_call_conv(),
             pointer_width: self.pointer_width(),
+            page_size_align_log2: self.page_size_align_log2(),
         }
     }
 }
diff --git a/cranelift/codegen/src/isa/pulley32.rs b/cranelift/codegen/src/isa/pulley32.rs
new file mode 100644
index 000000000000..b337274660d0
--- /dev/null
+++ b/cranelift/codegen/src/isa/pulley32.rs
@@ -0,0 +1,13 @@
+pub use super::pulley_shared::isa_builder;
+
+use super::pulley_shared::PulleyTargetKind;
+use crate::isa::pulley_shared::PointerWidth;
+
+#[derive(Debug, Default, Clone, Copy)]
+pub(crate) struct Pulley32;
+
+impl PulleyTargetKind for Pulley32 {
+    fn pointer_width() -> PointerWidth {
+        PointerWidth::PointerWidth32
+    }
+}
diff --git a/cranelift/codegen/src/isa/pulley64.rs b/cranelift/codegen/src/isa/pulley64.rs
new file mode 100644
index 000000000000..31b1d08a04b2
--- /dev/null
+++ b/cranelift/codegen/src/isa/pulley64.rs
@@ -0,0 +1,13 @@
+pub use super::pulley_shared::isa_builder;
+
+use super::pulley_shared::PulleyTargetKind;
+use crate::isa::pulley_shared::PointerWidth;
+
+#[derive(Debug, Default, Clone, Copy)]
+pub(crate) struct Pulley64;
+
+impl PulleyTargetKind for Pulley64 {
+    fn pointer_width() -> PointerWidth {
+        PointerWidth::PointerWidth64
+    }
+}
diff --git a/cranelift/codegen/src/isa/pulley_shared/abi.rs b/cranelift/codegen/src/isa/pulley_shared/abi.rs
new file mode 100644
index 000000000000..a88fe2ac81c5
--- /dev/null
+++ b/cranelift/codegen/src/isa/pulley_shared/abi.rs
@@ -0,0 +1,821 @@
+//! Implementation of a standard Pulley ABI.
+
+use super::{inst::*, PulleyFlags, PulleyTargetKind};
+use crate::{
+    ir::{self, types::*, MemFlags, Signature},
+    isa::{self, unwind::UnwindInst},
+    machinst::*,
+    settings, CodegenError, CodegenResult,
+};
+use alloc::{boxed::Box, vec::Vec};
+use core::marker::PhantomData;
+use regalloc2::{MachineEnv, PReg, PRegSet};
+use smallvec::{smallvec, SmallVec};
+use std::sync::OnceLock;
+
+/// Support for the Pulley ABI from the callee side (within a function body).
+pub(crate) type PulleyCallee<P> = Callee<PulleyMachineDeps<P>>;
+
+/// Support for the Pulley ABI from the caller side (at a callsite).
+pub(crate) type PulleyABICallSite<P> = CallSite<PulleyMachineDeps<P>>;
+
+/// This is the limit for the size of argument and return-value areas on the
+/// stack. We place a reasonable limit here to avoid integer overflow issues
+/// with 32-bit arithmetic: for now, 128 MB.
+static STACK_ARG_RET_SIZE_LIMIT: u32 = 128 * 1024 * 1024;
+
+/// Pulley-specific ABI behavior. This struct just serves as an implementation
+/// point for the trait; it is never actually instantiated.
+pub struct PulleyMachineDeps<P>
+where
+    P: PulleyTargetKind,
+{
+    _phantom: PhantomData<P>,
+}
+
+impl<P> ABIMachineSpec for PulleyMachineDeps<P>
+where
+    P: PulleyTargetKind,
+{
+    type I = InstAndKind<P>;
+    type F = PulleyFlags;
+
+    fn word_bits() -> u32 {
+        P::pointer_width().bits().into()
+    }
+
+    /// Return required stack alignment in bytes.
+    fn stack_align(_call_conv: isa::CallConv) -> u32 {
+        16
+    }
+
+    fn compute_arg_locs(
+        call_conv: isa::CallConv,
+        _flags: &settings::Flags,
+        params: &[ir::AbiParam],
+        args_or_rets: ArgsOrRets,
+        add_ret_area_ptr: bool,
+        mut args: ArgsAccumulator,
+    ) -> CodegenResult<(u32, Option<usize>)> {
+        // NB: make sure this method stays in sync with
+        // `cranelift_pulley::interp::Vm::call`.
+
+        let x_end = 15;
+        let f_end = 15;
+        let v_end = 15;
+
+        let mut next_x_reg = 0;
+        let mut next_f_reg = 0;
+        let mut next_v_reg = 0;
+        let mut next_stack: u32 = 0;
+
+        for param in params {
+            // Find the regclass(es) of the register(s) used to store a value of
+            // this type.
+            let (rcs, reg_tys) = Self::I::rc_for_type(param.value_type)?;
+
+            let mut slots = ABIArgSlotVec::new();
+            for (rc, reg_ty) in rcs.iter().zip(reg_tys.iter()) {
+                let next_reg = if (next_x_reg <= x_end) && *rc == RegClass::Int {
+                    let x = Some(x_reg(next_x_reg));
+                    next_x_reg += 1;
+                    x
+                } else if (next_f_reg <= f_end) && *rc == RegClass::Float {
+                    let f = Some(f_reg(next_f_reg));
+                    next_f_reg += 1;
+                    f
+                } else if (next_v_reg <= v_end) && *rc == RegClass::Vector {
+                    let v = Some(v_reg(next_v_reg));
+                    next_v_reg += 1;
+                    v
+                } else {
+                    None
+                };
+
+                if let Some(reg) = next_reg {
+                    slots.push(ABIArgSlot::Reg {
+                        reg: reg.to_real_reg().unwrap(),
+                        ty: *reg_ty,
+                        extension: param.extension,
+                    });
+                } else {
+                    // Compute size and 16-byte stack alignment happens
+                    // separately after all args.
+                    let size = reg_ty.bits() / 8;
+                    let size = std::cmp::max(size, 8);
+
+                    // Align.
+                    debug_assert!(size.is_power_of_two());
+                    next_stack = align_to(next_stack, size);
+
+                    slots.push(ABIArgSlot::Stack {
+                        offset: i64::from(next_stack),
+                        ty: *reg_ty,
+                        extension: param.extension,
+                    });
+
+                    next_stack += size;
+                }
+            }
+
+            args.push(ABIArg::Slots {
+                slots,
+                purpose: param.purpose,
+            });
+        }
+
+        let pos = if add_ret_area_ptr {
+            assert!(ArgsOrRets::Args == args_or_rets);
+            if next_x_reg <= x_end {
+                let arg = ABIArg::reg(
+                    x_reg(next_x_reg).to_real_reg().unwrap(),
+                    I64,
+                    ir::ArgumentExtension::None,
+                    ir::ArgumentPurpose::Normal,
+                );
+                args.push(arg);
+            } else {
+                let arg = ABIArg::stack(
+                    next_stack as i64,
+                    I64,
+                    ir::ArgumentExtension::None,
+                    ir::ArgumentPurpose::Normal,
+                );
+                args.push(arg);
+                next_stack += 8;
+            }
+            Some(args.args().len() - 1)
+        } else {
+            None
+        };
+
+        next_stack = align_to(next_stack, Self::stack_align(call_conv));
+
+        // To avoid overflow issues, limit the arg/return size to something
+        // reasonable -- here, 128 MB.
+        if next_stack > STACK_ARG_RET_SIZE_LIMIT {
+            return Err(CodegenError::ImplLimitExceeded);
+        }
+
+        Ok((next_stack, pos))
+    }
+
+    fn gen_load_stack(mem: StackAMode, into_reg: Writable<Reg>, ty: Type) -> Self::I {
+        Inst::gen_load(into_reg, mem.into(), ty, MemFlags::trusted()).into()
+    }
+
+    fn gen_store_stack(mem: StackAMode, from_reg: Reg, ty: Type) -> Self::I {
+        Inst::gen_store(mem.into(), from_reg, ty, MemFlags::trusted()).into()
+    }
+
+    fn gen_move(to_reg: Writable<Reg>, from_reg: Reg, ty: Type) -> Self::I {
+        Self::I::gen_move(to_reg, from_reg, ty)
+    }
+
+    fn gen_extend(
+        _to_reg: Writable<Reg>,
+        _from_reg: Reg,
+        _signed: bool,
+        from_bits: u8,
+        to_bits: u8,
+    ) -> Self::I {
+        assert!(from_bits < to_bits);
+        todo!()
+    }
+
+    fn get_ext_mode(
+        _call_conv: isa::CallConv,
+        specified: ir::ArgumentExtension,
+    ) -> ir::ArgumentExtension {
+        specified
+    }
+
+    fn gen_args(args: Vec<ArgPair>) -> Self::I {
+        Inst::Args { args }.into()
+    }
+
+    fn gen_rets(rets: Vec<RetPair>) -> Self::I {
+        Inst::Rets { rets }.into()
+    }
+
+    fn get_stacklimit_reg(_call_conv: isa::CallConv) -> Reg {
+        spilltmp_reg()
+    }
+
+    fn gen_add_imm(
+        _call_conv: isa::CallConv,
+        _into_reg: Writable<Reg>,
+        _from_reg: Reg,
+        _imm: u32,
+    ) -> SmallInstVec<Self::I> {
+        todo!()
+    }
+
+    fn gen_stack_lower_bound_trap(_limit_reg: Reg) -> SmallInstVec<Self::I> {
+        todo!()
+    }
+
+    fn gen_get_stack_addr(mem: StackAMode, dst: Writable<Reg>) -> Self::I {
+        let dst = dst.to_reg();
+        let dst = XReg::new(dst).unwrap();
+        let dst = WritableXReg::from_reg(dst);
+        let mem = mem.into();
+        Inst::LoadAddr { dst, mem }.into()
+    }
+
+    fn gen_load_base_offset(into_reg: Writable<Reg>, base: Reg, offset: i32, ty: Type) -> Self::I {
+        let offset = i64::from(offset);
+        let base = XReg::try_from(base).unwrap();
+        let mem = Amode::RegOffset { base, offset };
+        Inst::gen_load(into_reg, mem, ty, MemFlags::trusted()).into()
+    }
+
+    fn gen_store_base_offset(_base: Reg, _offset: i32, _from_reg: Reg, _ty: Type) -> Self::I {
+        todo!()
+    }
+
+    fn gen_sp_reg_adjust(amount: i32) -> SmallInstVec<Self::I> {
+        let temp = WritableXReg::try_from(writable_spilltmp_reg()).unwrap();
+
+        let imm = if let Ok(x) = i8::try_from(amount) {
+            Inst::Xconst8 { dst: temp, imm: x }.into()
+        } else if let Ok(x) = i16::try_from(amount) {
+            Inst::Xconst16 { dst: temp, imm: x }.into()
+        } else {
+            Inst::Xconst32 {
+                dst: temp,
+                imm: amount,
+            }
+            .into()
+        };
+
+        smallvec![
+            imm,
+            Inst::Xadd32 {
+                dst: WritableXReg::try_from(writable_stack_reg()).unwrap(),
+                src1: XReg::new(stack_reg()).unwrap(),
+                src2: temp.to_reg(),
+            }
+            .into()
+        ]
+    }
+
+    fn gen_prologue_frame_setup(
+        _call_conv: isa::CallConv,
+        flags: &settings::Flags,
+        _isa_flags: &PulleyFlags,
+        frame_layout: &FrameLayout,
+    ) -> SmallInstVec<Self::I> {
+        let mut insts = SmallVec::new();
+
+        if frame_layout.setup_area_size > 0 {
+            // sp = sub sp, 16 ;; alloc stack space for frame pointer and return address.
+            // store sp+8, lr  ;; save return address.
+            // store sp, fp    ;; save old fp.
+            // mov sp, fp      ;; set fp to sp.
+            insts.extend(Self::gen_sp_reg_adjust(-16));
+            insts.push(
+                Inst::gen_store(
+                    Amode::SpOffset { offset: 8 },
+                    link_reg(),
+                    I64,
+                    MemFlags::trusted(),
+                )
+                .into(),
+            );
+            insts.push(
+                Inst::gen_store(
+                    Amode::SpOffset { offset: 0 },
+                    fp_reg(),
+                    I64,
+                    MemFlags::trusted(),
+                )
+                .into(),
+            );
+            if flags.unwind_info() {
+                insts.push(
+                    Inst::Unwind {
+                        inst: UnwindInst::PushFrameRegs {
+                            offset_upward_to_caller_sp: frame_layout.setup_area_size,
+                        },
+                    }
+                    .into(),
+                );
+            }
+            insts.push(
+                Inst::Xmov {
+                    dst: Writable::from_reg(XReg::new(fp_reg()).unwrap()),
+                    src: XReg::new(stack_reg()).unwrap(),
+                }
+                .into(),
+            );
+        }
+
+        insts
+    }
+
+    /// Reverse of `gen_prologue_frame_setup`.
+    fn gen_epilogue_frame_restore(
+        _call_conv: isa::CallConv,
+        _flags: &settings::Flags,
+        _isa_flags: &PulleyFlags,
+        frame_layout: &FrameLayout,
+    ) -> SmallInstVec<Self::I> {
+        let mut insts = SmallVec::new();
+
+        if frame_layout.setup_area_size > 0 {
+            insts.push(
+                Inst::gen_load(
+                    writable_link_reg(),
+                    Amode::SpOffset { offset: 8 },
+                    I64,
+                    MemFlags::trusted(),
+                )
+                .into(),
+            );
+            insts.push(
+                Inst::gen_load(
+                    writable_fp_reg(),
+                    Amode::SpOffset { offset: 0 },
+                    I64,
+                    MemFlags::trusted(),
+                )
+                .into(),
+            );
+            insts.extend(Self::gen_sp_reg_adjust(16));
+        }
+
+        if frame_layout.tail_args_size > 0 {
+            insts.extend(Self::gen_sp_reg_adjust(
+                frame_layout.tail_args_size.try_into().unwrap(),
+            ));
+        }
+
+        insts
+    }
+
+    fn gen_return(
+        _call_conv: isa::CallConv,
+        _isa_flags: &PulleyFlags,
+        _frame_layout: &FrameLayout,
+    ) -> SmallInstVec<Self::I> {
+        smallvec![Inst::Ret {}.into()]
+    }
+
+    fn gen_probestack(_insts: &mut SmallInstVec<Self::I>, _frame_size: u32) {
+        todo!()
+    }
+
+    fn gen_clobber_save(
+        _call_conv: isa::CallConv,
+        flags: &settings::Flags,
+        frame_layout: &FrameLayout,
+    ) -> SmallVec<[Self::I; 16]> {
+        let mut insts = SmallVec::new();
+        let setup_frame = frame_layout.setup_area_size > 0;
+
+        let incoming_args_diff = frame_layout.tail_args_size - frame_layout.incoming_args_size;
+        if incoming_args_diff > 0 {
+            // Decrement SP by the amount of additional incoming argument space
+            // we need
+            insts.extend(Self::gen_sp_reg_adjust(-(incoming_args_diff as i32)));
+
+            if setup_frame {
+                // Write the lr position on the stack again, as it hasn't
+                // changed since it was pushed in `gen_prologue_frame_setup`
+                insts.push(
+                    Inst::gen_store(
+                        Amode::SpOffset { offset: 8 },
+                        link_reg(),
+                        I64,
+                        MemFlags::trusted(),
+                    )
+                    .into(),
+                );
+                insts.push(
+                    Inst::gen_load(
+                        writable_fp_reg(),
+                        Amode::SpOffset {
+                            offset: i64::from(incoming_args_diff),
+                        },
+                        I64,
+                        MemFlags::trusted(),
+                    )
+                    .into(),
+                );
+                insts.push(
+                    Inst::gen_store(
+                        Amode::SpOffset { offset: 0 },
+                        fp_reg(),
+                        I64,
+                        MemFlags::trusted(),
+                    )
+                    .into(),
+                );
+
+                // Finally, sync the frame pointer with SP.
+                insts.push(Self::I::gen_move(writable_fp_reg(), stack_reg(), I64));
+            }
+        }
+
+        if flags.unwind_info() && setup_frame {
+            // The *unwind* frame (but not the actual frame) starts at the
+            // clobbers, just below the saved FP/LR pair.
+            insts.push(
+                Inst::Unwind {
+                    inst: UnwindInst::DefineNewFrame {
+                        offset_downward_to_clobbers: frame_layout.clobber_size,
+                        offset_upward_to_caller_sp: frame_layout.setup_area_size,
+                    },
+                }
+                .into(),
+            );
+        }
+
+        // Adjust the stack pointer downward for clobbers, the function fixed
+        // frame (spillslots and storage slots), and outgoing arguments.
+        let stack_size = frame_layout.clobber_size
+            + frame_layout.fixed_frame_storage_size
+            + frame_layout.outgoing_args_size;
+
+        // Store each clobbered register in order at offsets from SP, placing
+        // them above the fixed frame slots.
+        if stack_size > 0 {
+            insts.extend(Self::gen_sp_reg_adjust(-i32::try_from(stack_size).unwrap()));
+
+            let mut cur_offset = 8;
+            for reg in &frame_layout.clobbered_callee_saves {
+                let r_reg = reg.to_reg();
+                let ty = match r_reg.class() {
+                    RegClass::Int => I64,
+                    RegClass::Float => F64,
+                    RegClass::Vector => unreachable!("no vector registers are callee-save"),
+                };
+                insts.push(
+                    Inst::gen_store(
+                        Amode::SpOffset {
+                            offset: i64::from(stack_size - cur_offset),
+                        },
+                        Reg::from(reg.to_reg()),
+                        ty,
+                        MemFlags::trusted(),
+                    )
+                    .into(),
+                );
+
+                if flags.unwind_info() {
+                    insts.push(
+                        Inst::Unwind {
+                            inst: UnwindInst::SaveReg {
+                                clobber_offset: frame_layout.clobber_size - cur_offset,
+                                reg: r_reg,
+                            },
+                        }
+                        .into(),
+                    );
+                }
+
+                cur_offset += 8
+            }
+        }
+
+        insts
+    }
+
+    fn gen_clobber_restore(
+        _call_conv: isa::CallConv,
+        _flags: &settings::Flags,
+        frame_layout: &FrameLayout,
+    ) -> SmallVec<[Self::I; 16]> {
+        let mut insts = SmallVec::new();
+
+        let stack_size = frame_layout.clobber_size
+            + frame_layout.fixed_frame_storage_size
+            + frame_layout.outgoing_args_size;
+
+        let mut cur_offset = 8;
+        for reg in &frame_layout.clobbered_callee_saves {
+            let rreg = reg.to_reg();
+            let ty = match rreg.class() {
+                RegClass::Int => I64,
+                RegClass::Float => F64,
+                RegClass::Vector => unreachable!("vector registers are never callee-saved"),
+            };
+            insts.push(
+                Inst::gen_load(
+                    reg.map(Reg::from),
+                    Amode::SpOffset {
+                        offset: i64::from(stack_size - cur_offset),
+                    },
+                    ty,
+                    MemFlags::trusted(),
+                )
+                .into(),
+            );
+            cur_offset += 8
+        }
+
+        if stack_size > 0 {
+            insts.extend(Self::gen_sp_reg_adjust(stack_size as i32));
+        }
+
+        insts
+    }
+
+    fn gen_call(
+        dest: &CallDest,
+        uses: CallArgList,
+        defs: CallRetList,
+        clobbers: PRegSet,
+        tmp: Writable<Reg>,
+        callee_conv: isa::CallConv,
+        caller_conv: isa::CallConv,
+        callee_pop_size: u32,
+    ) -> SmallVec<[Self::I; 2]> {
+        if callee_conv == isa::CallConv::Tail || callee_conv == isa::CallConv::Fast {
+            match &dest {
+                &CallDest::ExtName(ref name, RelocDistance::Near) => smallvec![Inst::Call {
+                    callee: Box::new(name.clone()),
+                    info: Box::new(CallInfo {
+                        uses,
+                        defs,
+                        clobbers,
+                        callee_pop_size,
+                    }),
+                }
+                .into()],
+                &CallDest::ExtName(ref name, RelocDistance::Far) => smallvec![
+                    Inst::LoadExtName {
+                        dst: WritableXReg::try_from(tmp).unwrap(),
+                        name: Box::new(name.clone()),
+                        offset: 0,
+                    }
+                    .into(),
+                    Inst::IndirectCall {
+                        callee: XReg::new(tmp.to_reg()).unwrap(),
+                        info: Box::new(CallInfo {
+                            uses,
+                            defs,
+                            clobbers,
+                            callee_pop_size,
+                        }),
+                    }
+                    .into(),
+                ],
+                &CallDest::Reg(reg) => smallvec![Inst::IndirectCall {
+                    callee: XReg::new(*reg).unwrap(),
+                    info: Box::new(CallInfo {
+                        uses,
+                        defs,
+                        clobbers,
+                        callee_pop_size,
+                    }),
+                }
+                .into()],
+            }
+        } else {
+            todo!("host calls? callee_conv = {callee_conv:?}; caller_conv = {caller_conv:?}")
+        }
+    }
+
+    fn gen_memcpy<F: FnMut(Type) -> Writable<Reg>>(
+        _call_conv: isa::CallConv,
+        _dst: Reg,
+        _src: Reg,
+        _size: usize,
+        _alloc_tmp: F,
+    ) -> SmallVec<[Self::I; 8]> {
+        todo!()
+    }
+
+    fn get_number_of_spillslots_for_value(
+        _rc: RegClass,
+        _target_vector_bytes: u32,
+        _isa_flags: &PulleyFlags,
+    ) -> u32 {
+        todo!()
+    }
+
+    fn get_machine_env(_flags: &settings::Flags, _call_conv: isa::CallConv) -> &MachineEnv {
+        static MACHINE_ENV: OnceLock<MachineEnv> = OnceLock::new();
+        MACHINE_ENV.get_or_init(create_reg_enviroment)
+    }
+
+    fn get_regs_clobbered_by_call(_call_conv_of_callee: isa::CallConv) -> PRegSet {
+        DEFAULT_CLOBBERS
+    }
+
+    fn compute_frame_layout(
+        _call_conv: isa::CallConv,
+        flags: &settings::Flags,
+        _sig: &Signature,
+        regs: &[Writable<RealReg>],
+        is_leaf: bool,
+        incoming_args_size: u32,
+        tail_args_size: u32,
+        fixed_frame_storage_size: u32,
+        outgoing_args_size: u32,
+    ) -> FrameLayout {
+        let mut regs: Vec<Writable<RealReg>> = regs
+            .iter()
+            .cloned()
+            .filter(|r| DEFAULT_CALLEE_SAVES.contains(r.to_reg().into()))
+            .collect();
+
+        regs.sort_unstable();
+
+        // Compute clobber size.
+        let clobber_size = compute_clobber_size(&regs);
+
+        // Compute linkage frame size.
+        let setup_area_size = if flags.preserve_frame_pointers()
+            || !is_leaf
+            // The function arguments that are passed on the stack are addressed
+            // relative to the Frame Pointer.
+            || incoming_args_size > 0
+            || clobber_size > 0
+            || fixed_frame_storage_size > 0
+        {
+            16 // FP, LR
+        } else {
+            0
+        };
+
+        FrameLayout {
+            incoming_args_size,
+            tail_args_size,
+            setup_area_size,
+            clobber_size,
+            fixed_frame_storage_size,
+            outgoing_args_size,
+            clobbered_callee_saves: regs,
+        }
+    }
+
+    fn gen_inline_probestack(
+        _insts: &mut SmallInstVec<Self::I>,
+        _call_conv: isa::CallConv,
+        _frame_size: u32,
+        _guard_size: u32,
+    ) {
+        todo!()
+    }
+}
+
+impl<P> PulleyABICallSite<P>
+where
+    P: PulleyTargetKind,
+{
+    pub fn emit_return_call(self, _ctx: &mut Lower<InstAndKind<P>>, _args: isle::ValueSlice) {
+        todo!()
+    }
+}
+
+const DEFAULT_CALLEE_SAVES: PRegSet = PRegSet::empty()
+    // Integer registers.
+    .with(px_reg(16))
+    .with(px_reg(17))
+    .with(px_reg(18))
+    .with(px_reg(19))
+    .with(px_reg(20))
+    .with(px_reg(21))
+    .with(px_reg(22))
+    .with(px_reg(23))
+    .with(px_reg(24))
+    .with(px_reg(25))
+    .with(px_reg(26))
+    .with(px_reg(27))
+    .with(px_reg(28))
+    .with(px_reg(29))
+    .with(px_reg(30))
+    .with(px_reg(31))
+    // Float registers.
+    .with(px_reg(16))
+    .with(px_reg(17))
+    .with(px_reg(18))
+    .with(px_reg(19))
+    .with(px_reg(20))
+    .with(px_reg(21))
+    .with(px_reg(22))
+    .with(px_reg(23))
+    .with(px_reg(24))
+    .with(px_reg(25))
+    .with(px_reg(26))
+    .with(px_reg(27))
+    .with(px_reg(28))
+    .with(px_reg(29))
+    .with(px_reg(30))
+    .with(px_reg(31))
+    // Note: no vector registers are callee-saved.
+;
+
+fn compute_clobber_size(clobbers: &[Writable<RealReg>]) -> u32 {
+    let mut clobbered_size = 0;
+    for reg in clobbers {
+        match reg.to_reg().class() {
+            RegClass::Int => {
+                clobbered_size += 8;
+            }
+            RegClass::Float => {
+                clobbered_size += 8;
+            }
+            RegClass::Vector => unimplemented!("Vector Size Clobbered"),
+        }
+    }
+    align_to(clobbered_size, 16)
+}
+
+const DEFAULT_CLOBBERS: PRegSet = PRegSet::empty()
+    // Integer registers: the first 16 get clobbered.
+    .with(px_reg(0))
+    .with(px_reg(1))
+    .with(px_reg(2))
+    .with(px_reg(3))
+    .with(px_reg(4))
+    .with(px_reg(5))
+    .with(px_reg(6))
+    .with(px_reg(7))
+    .with(px_reg(8))
+    .with(px_reg(9))
+    .with(px_reg(10))
+    .with(px_reg(11))
+    .with(px_reg(12))
+    .with(px_reg(13))
+    .with(px_reg(14))
+    .with(px_reg(15))
+    // Float registers: the first 16 get clobbered.
+    .with(pf_reg(0))
+    .with(pf_reg(1))
+    .with(pf_reg(2))
+    .with(pf_reg(3))
+    .with(pf_reg(4))
+    .with(pf_reg(5))
+    .with(pf_reg(6))
+    .with(pf_reg(7))
+    .with(pf_reg(9))
+    .with(pf_reg(10))
+    .with(pf_reg(11))
+    .with(pf_reg(12))
+    .with(pf_reg(13))
+    .with(pf_reg(14))
+    .with(pf_reg(15))
+    // All vector registers get clobbered.
+    .with(pv_reg(0))
+    .with(pv_reg(1))
+    .with(pv_reg(2))
+    .with(pv_reg(3))
+    .with(pv_reg(4))
+    .with(pv_reg(5))
+    .with(pv_reg(6))
+    .with(pv_reg(7))
+    .with(pv_reg(8))
+    .with(pv_reg(9))
+    .with(pv_reg(10))
+    .with(pv_reg(11))
+    .with(pv_reg(12))
+    .with(pv_reg(13))
+    .with(pv_reg(14))
+    .with(pv_reg(15))
+    .with(pv_reg(16))
+    .with(pv_reg(17))
+    .with(pv_reg(18))
+    .with(pv_reg(19))
+    .with(pv_reg(20))
+    .with(pv_reg(21))
+    .with(pv_reg(22))
+    .with(pv_reg(23))
+    .with(pv_reg(24))
+    .with(pv_reg(25))
+    .with(pv_reg(26))
+    .with(pv_reg(27))
+    .with(pv_reg(28))
+    .with(pv_reg(29))
+    .with(pv_reg(30))
+    .with(pv_reg(31));
+
+fn create_reg_enviroment() -> MachineEnv {
+    // Prefer caller-saved registers over callee-saved registers, because that
+    // way we don't need to emit code to save and restore them if we don't
+    // mutate them.
+
+    let preferred_regs_by_class: [Vec<PReg>; 3] = {
+        let x_registers: Vec<PReg> = (0..16).map(|x| px_reg(x)).collect();
+        let f_registers: Vec<PReg> = (0..16).map(|x| pf_reg(x)).collect();
+        let v_registers: Vec<PReg> = (0..32).map(|x| pv_reg(x)).collect();
+        [x_registers, f_registers, v_registers]
+    };
+
+    let non_preferred_regs_by_class: [Vec<PReg>; 3] = {
+        let x_registers: Vec<PReg> = (16..32).map(|x| px_reg(x)).collect();
+        let f_registers: Vec<PReg> = (16..32).map(|x| pf_reg(x)).collect();
+        let v_registers: Vec<PReg> = vec![];
+        [x_registers, f_registers, v_registers]
+    };
+
+    MachineEnv {
+        preferred_regs_by_class,
+        non_preferred_regs_by_class,
+        fixed_stack_slots: vec![],
+        scratch_by_class: [None, None, None],
+    }
+}
diff --git a/cranelift/codegen/src/isa/pulley_shared/inst.isle b/cranelift/codegen/src/isa/pulley_shared/inst.isle
new file mode 100644
index 000000000000..6301353a70e0
--- /dev/null
+++ b/cranelift/codegen/src/isa/pulley_shared/inst.isle
@@ -0,0 +1,544 @@
+;;;; Instruction definition ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Note: in the instructions below, we order destination registers first and
+;; then source registers afterwards.
+(type MInst
+  (enum
+    ;;;; Pseudo-Instructions ;;;;
+
+    ;; A pseudo-instruction that captures register arguments in vregs.
+    (Args (args VecArgPair))
+
+    ;; A pseudo-instruction that moves vregs to return registers.
+    (Rets (rets VecRetPair))
+
+    ;; A pseudo-instruction to update unwind info.
+    (Unwind (inst UnwindInst))
+
+    ;;;; Actual Instructions ;;;;
+
+    ;; Raise a trap.
+    (Trap (code TrapCode))
+
+    ;; Nothing.
+    (Nop)
+
+    ;; Get the stack pointer.
+    (GetSp (dst WritableXReg))
+
+    ;; Return.
+    (Ret)
+
+    ;; Load an external symbol's address into a register.
+    (LoadExtName (dst WritableXReg)
+                 (name BoxExternalName)
+                 (offset i64))
+
+    ;; A direct call to a known callee.
+    (Call (callee BoxExternalName)
+          (info BoxCallInfo))
+
+    ;; An indirect call to an unknown callee.
+    (IndirectCall (callee XReg)
+                  (info BoxCallInfo))
+
+    ;; Unconditional jumps.
+    (Jump (label MachLabel))
+
+    ;; Jump to `then` if `c` is nonzero, otherwise to `else`.
+    (BrIf (c XReg) (taken MachLabel) (not_taken MachLabel))
+
+    ;; Compare-and-branch macro ops.
+    (BrIfXeq32 (src1 XReg) (src2 XReg) (taken MachLabel) (not_taken MachLabel))
+    (BrIfXneq32 (src1 XReg) (src2 XReg) (taken MachLabel) (not_taken MachLabel))
+    (BrIfXslt32 (src1 XReg) (src2 XReg) (taken MachLabel) (not_taken MachLabel))
+    (BrIfXslteq32 (src1 XReg) (src2 XReg) (taken MachLabel) (not_taken MachLabel))
+    (BrIfXult32 (src1 XReg) (src2 XReg) (taken MachLabel) (not_taken MachLabel))
+    (BrIfXulteq32 (src1 XReg) (src2 XReg) (taken MachLabel) (not_taken MachLabel))
+
+    ;; Register-to-register moves.
+    (Xmov (dst WritableXReg) (src XReg))
+    (Fmov (dst WritableFReg) (src FReg))
+    (Vmov (dst WritableVReg) (src VReg))
+
+    ;; Integer constants, zero-extended to 64 bits.
+    (Xconst8 (dst WritableXReg) (imm i8))
+    (Xconst16 (dst WritableXReg) (imm i16))
+    (Xconst32 (dst WritableXReg) (imm i32))
+    (Xconst64 (dst WritableXReg) (imm i64))
+
+    ;; Integer arithmetic.
+    (Xadd32 (dst WritableXReg) (src1 XReg) (src2 XReg))
+    (Xadd64 (dst WritableXReg) (src1 XReg) (src2 XReg))
+
+    ;; Comparisons.
+    (Xeq64 (dst WritableXReg) (src1 XReg) (src2 XReg))
+    (Xneq64 (dst WritableXReg) (src1 XReg) (src2 XReg))
+    (Xslt64 (dst WritableXReg) (src1 XReg) (src2 XReg))
+    (Xslteq64 (dst WritableXReg) (src1 XReg) (src2 XReg))
+    (Xult64 (dst WritableXReg) (src1 XReg) (src2 XReg))
+    (Xulteq64 (dst WritableXReg) (src1 XReg) (src2 XReg))
+    (Xeq32 (dst WritableXReg) (src1 XReg) (src2 XReg))
+    (Xneq32 (dst WritableXReg) (src1 XReg) (src2 XReg))
+    (Xslt32 (dst WritableXReg) (src1 XReg) (src2 XReg))
+    (Xslteq32 (dst WritableXReg) (src1 XReg) (src2 XReg))
+    (Xult32 (dst WritableXReg) (src1 XReg) (src2 XReg))
+    (Xulteq32 (dst WritableXReg) (src1 XReg) (src2 XReg))
+
+    ;; Load the memory address referenced by `mem` into `dst`.
+    (LoadAddr (dst WritableXReg) (mem Amode))
+
+    ;; Loads.
+    (Load (dst WritableReg) (mem Amode) (ty Type) (flags MemFlags) (ext ExtKind))
+
+    ;; Stores.
+    (Store (mem Amode) (src Reg) (ty Type) (flags MemFlags))
+
+    ;; Bitcasts.
+    (BitcastIntFromFloat32 (dst WritableXReg) (src FReg))
+    (BitcastIntFromFloat64 (dst WritableXReg) (src FReg))
+    (BitcastFloatFromInt32 (dst WritableFReg) (src XReg))
+    (BitcastFloatFromInt64 (dst WritableFReg) (src XReg))
+  )
+)
+
+(type BoxCallInfo (primitive BoxCallInfo))
+
+;;;; Address Modes ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(type StackAMode extern (enum))
+
+(type Amode
+  (enum
+    (SpOffset (offset i64))
+    (RegOffset (base XReg) (offset i64))
+    (Stack (amode StackAMode))
+  )
+)
+
+(type ExtKind (enum None Sign Zero))
+
+;;;; Newtypes for Different Register Classes ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(type XReg (primitive XReg))
+(type WritableXReg (primitive WritableXReg))
+
+(type FReg (primitive FReg))
+(type WritableFReg (primitive WritableFReg))
+
+(type VReg (primitive VReg))
+(type WritableVReg (primitive WritableVReg))
+
+;; Construct a new `XReg` from a `Reg`.
+;;
+;; Asserts that the register has an integer RegClass.
+(decl xreg_new (Reg) XReg)
+(extern constructor xreg_new xreg_new)
+(convert Reg XReg xreg_new)
+
+;; Construct a new `WritableXReg` from a `WritableReg`.
+;;
+;; Asserts that the register has an integer RegClass.
+(decl writable_xreg_new (WritableReg) WritableXReg)
+(extern constructor writable_xreg_new writable_xreg_new)
+(convert WritableReg WritableXReg writable_xreg_new)
+
+;; Put a value into a XReg.
+;;
+;; Asserts that the value goes into a XReg.
+(decl put_in_xreg (Value) XReg)
+(rule (put_in_xreg val) (xreg_new (put_in_reg val)))
+(convert Value XReg put_in_xreg)
+
+;; Construct an `InstOutput` out of a single XReg register.
+(decl output_xreg (XReg) InstOutput)
+(rule (output_xreg x) (output_reg x))
+(convert XReg InstOutput output_xreg)
+
+;; Convert a `WritableXReg` to an `XReg`.
+(decl pure writable_xreg_to_xreg (WritableXReg) XReg)
+(extern constructor writable_xreg_to_xreg writable_xreg_to_xreg)
+(convert WritableXReg XReg writable_xreg_to_xreg)
+
+;; Convert a `WritableXReg` to an `WritableReg`.
+(decl pure writable_xreg_to_writable_reg (WritableXReg) WritableReg)
+(extern constructor writable_xreg_to_writable_reg writable_xreg_to_writable_reg)
+(convert WritableXReg WritableReg writable_xreg_to_writable_reg)
+
+;; Convert a `WritableXReg` to an `Reg`.
+(decl pure writable_xreg_to_reg (WritableXReg) Reg)
+(rule (writable_xreg_to_reg x) (writable_xreg_to_writable_reg x))
+(convert WritableXReg Reg writable_xreg_to_reg)
+
+;; Convert an `XReg` to a `Reg`.
+(decl pure xreg_to_reg (XReg) Reg)
+(extern constructor xreg_to_reg xreg_to_reg)
+(convert XReg Reg xreg_to_reg)
+
+;; Convert a `XReg` to a `ValueRegs`.
+(decl xreg_to_value_regs (XReg) ValueRegs)
+(rule (xreg_to_value_regs x) (value_reg x))
+(convert XReg ValueRegs xreg_to_reg)
+
+;; Convert a `WritableXReg` to a `ValueRegs`.
+(decl writable_xreg_to_value_regs (WritableXReg) ValueRegs)
+(rule (writable_xreg_to_value_regs x) (value_reg x))
+(convert WritableXReg ValueRegs writable_xreg_to_value_regs)
+
+;; Allocates a new `WritableXReg`.
+(decl temp_writable_xreg () WritableXReg)
+(rule (temp_writable_xreg) (temp_writable_reg $I64))
+
+;; Construct a new `FReg` from a `Reg`.
+;;
+;; Asserts that the register has a Float RegClass.
+(decl freg_new (Reg) FReg)
+(extern constructor freg_new freg_new)
+(convert Reg FReg freg_new)
+
+;; Construct a new `WritableFReg` from a `WritableReg`.
+;;
+;; Asserts that the register has a Float RegClass.
+(decl writable_freg_new (WritableReg) WritableFReg)
+(extern constructor writable_freg_new writable_freg_new)
+(convert WritableReg WritableFReg writable_freg_new)
+
+;; Put a value into a FReg.
+;;
+;; Asserts that the value goes into a FReg.
+(decl put_in_freg (Value) FReg)
+(rule (put_in_freg val) (freg_new (put_in_reg val)))
+(convert Value FReg put_in_freg)
+
+;; Construct an `InstOutput` out of a single FReg register.
+(decl output_freg (FReg) InstOutput)
+(rule (output_freg x) (output_reg x))
+(convert FReg InstOutput output_freg)
+
+;; Convert a `WritableFReg` to an `FReg`.
+(decl pure writable_freg_to_freg (WritableFReg) FReg)
+(extern constructor writable_freg_to_freg writable_freg_to_freg)
+(convert WritableFReg FReg writable_freg_to_freg)
+
+;; Convert a `WritableFReg` to an `WritableReg`.
+(decl pure writable_freg_to_writable_reg (WritableFReg) WritableReg)
+(extern constructor writable_freg_to_writable_reg writable_freg_to_writable_reg)
+(convert WritableFReg WritableReg writable_freg_to_writable_reg)
+
+;; Convert a `WritableFReg` to an `Reg`.
+(decl pure writable_freg_to_reg (WritableFReg) Reg)
+(rule (writable_freg_to_reg x) (writable_freg_to_writable_reg x))
+(convert WritableFReg Reg writable_freg_to_reg)
+
+;; Convert an `FReg` to a `Reg`.
+(decl pure freg_to_reg (FReg) Reg)
+(extern constructor freg_to_reg freg_to_reg)
+(convert FReg Reg freg_to_reg)
+
+;; Convert a `FReg` to a `ValueRegs`.
+(decl freg_to_value_regs (FReg) ValueRegs)
+(rule (freg_to_value_regs x) (value_reg x))
+(convert FReg ValueRegs xreg_to_reg)
+
+;; Convert a `WritableFReg` to a `ValueRegs`.
+(decl writable_freg_to_value_regs (WritableFReg) ValueRegs)
+(rule (writable_freg_to_value_regs x) (value_reg x))
+(convert WritableFReg ValueRegs writable_freg_to_value_regs)
+
+;; Allocates a new `WritableFReg`.
+(decl temp_writable_freg () WritableFReg)
+(rule (temp_writable_freg) (temp_writable_reg $F64))
+
+;; Construct a new `VReg` from a `Reg`.
+;;
+;; Asserts that the register has a Vector RegClass.
+(decl vreg_new (Reg) VReg)
+(extern constructor vreg_new vreg_new)
+(convert Reg VReg vreg_new)
+
+;; Construct a new `WritableVReg` from a `WritableReg`.
+;;
+;; Asserts that the register has a Vector RegClass.
+(decl writable_vreg_new (WritableReg) WritableVReg)
+(extern constructor writable_vreg_new writable_vreg_new)
+(convert WritableReg WritableVReg writable_vreg_new)
+
+;; Put a value into a VReg.
+;;
+;; Asserts that the value goes into a VReg.
+(decl put_in_vreg (Value) VReg)
+(rule (put_in_vreg val) (vreg_new (put_in_reg val)))
+(convert Value VReg put_in_vreg)
+
+;; Construct an `InstOutput` out of a single VReg register.
+(decl output_vreg (VReg) InstOutput)
+(rule (output_vreg x) (output_reg x))
+(convert VReg InstOutput output_vreg)
+
+;; Convert a `WritableVReg` to an `VReg`.
+(decl pure writable_vreg_to_vreg (WritableVReg) VReg)
+(extern constructor writable_vreg_to_vreg writable_vreg_to_vreg)
+(convert WritableVReg VReg writable_vreg_to_vreg)
+
+;; Convert a `WritableVReg` to an `WritableReg`.
+(decl pure writable_vreg_to_writable_reg (WritableVReg) WritableReg)
+(extern constructor writable_vreg_to_writable_reg writable_vreg_to_writable_reg)
+(convert WritableVReg WritableReg writable_vreg_to_writable_reg)
+
+;; Convert a `WritableVReg` to an `Reg`.
+(decl pure writable_vreg_to_reg (WritableVReg) Reg)
+(rule (writable_vreg_to_reg x) (writable_vreg_to_writable_reg x))
+(convert WritableVReg Reg writable_vreg_to_reg)
+
+;; Convert an `VReg` to a `Reg`.
+(decl pure vreg_to_reg (VReg) Reg)
+(extern constructor vreg_to_reg vreg_to_reg)
+(convert VReg Reg vreg_to_reg)
+
+;; Convert a `VReg` to a `ValueRegs`.
+(decl vreg_to_value_regs (VReg) ValueRegs)
+(rule (vreg_to_value_regs x) (value_reg x))
+(convert VReg ValueRegs xreg_to_reg)
+
+;; Convert a `WritableVReg` to a `ValueRegs`.
+(decl writable_vreg_to_value_regs (WritableVReg) ValueRegs)
+(rule (writable_vreg_to_value_regs x) (value_reg x))
+(convert WritableVReg ValueRegs writable_vreg_to_value_regs)
+
+;; Allocates a new `WritableVReg`.
+(decl temp_writable_vreg () WritableVReg)
+(rule (temp_writable_vreg) (temp_writable_reg $I8X16))
+
+;;;; Materializing Constants ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Lower a constant into a register.
+(decl imm (Type u64) Reg)
+
+;; If a value can fit into 8 bits, then prioritize that.
+(rule 3 (imm (ty_int _) x)
+      (if-let y (i8_try_from_u64 x))
+      (pulley_xconst8 y))
+
+;; If a value can fit into 16 bits, then prioritize that.
+(rule 2 (imm (ty_int _) x)
+      (if-let y (i16_try_from_u64 x))
+      (pulley_xconst16 y))
+
+;; If a value can fit into 32 bits, then prioritize that.
+(rule 1 (imm (ty_int _) x)
+      (if-let y (i32_try_from_u64 x))
+      (pulley_xconst32 y))
+
+;; Base cases for integers.
+(rule 0 (imm $I8 x) (pulley_xconst8 (u8_as_i8 (u64_as_u8 x))))
+(rule 0 (imm $I16 x) (pulley_xconst16 (u16_as_i16 (u64_as_u16 x))))
+(rule 0 (imm $I32 x) (pulley_xconst32 (u64_as_i32 x)))
+(rule 0 (imm $I64 x) (pulley_xconst64 (u64_as_i64 x)))
+
+;; Base cases for floats.
+(rule 0 (imm $F32 c) (gen_bitcast (imm $I32 c) $I32 $F32))
+(rule 0 (imm $F64 c) (gen_bitcast (imm $I64 c) $I64 $F64))
+
+;;;; Bitcasts ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Bitcast from the first type, into the second type.
+(decl gen_bitcast (Reg Type Type) Reg)
+(rule (gen_bitcast r $F32 $I32) (pulley_bitcast_float_from_int_32 r))
+(rule (gen_bitcast r $F64 $I64) (pulley_bitcast_float_from_int_64 r))
+(rule (gen_bitcast r $I32 $F32) (pulley_bitcast_int_from_float_32 r))
+(rule (gen_bitcast r $I64 $F64) (pulley_bitcast_int_from_float_64 r))
+(rule -1 (gen_bitcast r ty ty) r)
+
+;;;; Instruction Constructors ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(decl pulley_trap (TrapCode) SideEffectNoResult)
+(rule (pulley_trap code)
+      (SideEffectNoResult.Inst (MInst.Trap code)))
+
+(decl pulley_get_sp () XReg)
+(rule (pulley_get_sp)
+      (let ((reg WritableXReg (temp_writable_xreg))
+            (_ Unit (emit (MInst.GetSp reg))))
+        reg))
+
+(decl pulley_xconst8 (i8) XReg)
+(rule (pulley_xconst8 x)
+      (let ((reg WritableXReg (temp_writable_xreg))
+            (_ Unit (emit (MInst.Xconst8 reg x))))
+        reg))
+
+(decl pulley_xconst16 (i16) XReg)
+(rule (pulley_xconst16 x)
+      (let ((reg WritableXReg (temp_writable_xreg))
+            (_ Unit (emit (MInst.Xconst16 reg x))))
+        reg))
+
+(decl pulley_xconst32 (i32) XReg)
+(rule (pulley_xconst32 x)
+      (let ((reg WritableXReg (temp_writable_xreg))
+            (_ Unit (emit (MInst.Xconst32 reg x))))
+        reg))
+
+(decl pulley_xconst64 (i64) XReg)
+(rule (pulley_xconst64 x)
+      (let ((reg WritableXReg (temp_writable_xreg))
+            (_ Unit (emit (MInst.Xconst64 reg x))))
+        reg))
+
+(decl pulley_jump (MachLabel) SideEffectNoResult)
+(rule (pulley_jump label)
+      (SideEffectNoResult.Inst (MInst.Jump label)))
+
+(decl pulley_br_if (XReg MachLabel MachLabel) SideEffectNoResult)
+(rule (pulley_br_if c taken not_taken)
+      (SideEffectNoResult.Inst (MInst.BrIf c taken not_taken)))
+
+(decl pulley_br_if_xeq32 (XReg XReg MachLabel MachLabel) SideEffectNoResult)
+(rule (pulley_br_if_xeq32 a b taken not_taken)
+      (SideEffectNoResult.Inst (MInst.BrIfXeq32 a b taken not_taken)))
+
+(decl pulley_br_if_xneq32 (XReg XReg MachLabel MachLabel) SideEffectNoResult)
+(rule (pulley_br_if_xneq32 a b taken not_taken)
+      (SideEffectNoResult.Inst (MInst.BrIfXneq32 a b taken not_taken)))
+
+(decl pulley_br_if_xslt32 (XReg XReg MachLabel MachLabel) SideEffectNoResult)
+(rule (pulley_br_if_xslt32 a b taken not_taken)
+      (SideEffectNoResult.Inst (MInst.BrIfXslt32 a b taken not_taken)))
+
+(decl pulley_br_if_xslteq32 (XReg XReg MachLabel MachLabel) SideEffectNoResult)
+(rule (pulley_br_if_xslteq32 a b taken not_taken)
+      (SideEffectNoResult.Inst (MInst.BrIfXslteq32 a b taken not_taken)))
+
+(decl pulley_br_if_xult32 (XReg XReg MachLabel MachLabel) SideEffectNoResult)
+(rule (pulley_br_if_xult32 a b taken not_taken)
+      (SideEffectNoResult.Inst (MInst.BrIfXult32 a b taken not_taken)))
+
+(decl pulley_br_if_xulteq32 (XReg XReg MachLabel MachLabel) SideEffectNoResult)
+(rule (pulley_br_if_xulteq32 a b taken not_taken)
+      (SideEffectNoResult.Inst (MInst.BrIfXulteq32 a b taken not_taken)))
+
+(decl pulley_xadd32 (XReg XReg) XReg)
+(rule (pulley_xadd32 a b)
+      (let ((dst WritableXReg (temp_writable_xreg))
+            (_ Unit (emit (MInst.Xadd32 dst a b))))
+        dst))
+
+(decl pulley_xadd64 (XReg XReg) XReg)
+(rule (pulley_xadd64 a b)
+      (let ((dst WritableXReg (temp_writable_xreg))
+            (_ Unit (emit (MInst.Xadd64 dst a b))))
+        dst))
+
+(decl pulley_xeq64 (XReg XReg) XReg)
+(rule (pulley_xeq64 a b)
+      (let ((dst WritableXReg (temp_writable_xreg))
+            (_ Unit (emit (MInst.Xeq64 dst a b))))
+        dst))
+
+(decl pulley_xneq64 (XReg XReg) XReg)
+(rule (pulley_xneq64 a b)
+      (let ((dst WritableXReg (temp_writable_xreg))
+            (_ Unit (emit (MInst.Xneq64 dst a b))))
+        dst))
+
+(decl pulley_xslt64 (XReg XReg) XReg)
+(rule (pulley_xslt64 a b)
+      (let ((dst WritableXReg (temp_writable_xreg))
+            (_ Unit (emit (MInst.Xslt64 dst a b))))
+        dst))
+
+(decl pulley_xslteq64 (XReg XReg) XReg)
+(rule (pulley_xslteq64 a b)
+      (let ((dst WritableXReg (temp_writable_xreg))
+            (_ Unit (emit (MInst.Xslteq64 dst a b))))
+        dst))
+
+(decl pulley_xult64 (XReg XReg) XReg)
+(rule (pulley_xult64 a b)
+      (let ((dst WritableXReg (temp_writable_xreg))
+            (_ Unit (emit (MInst.Xult64 dst a b))))
+        dst))
+
+(decl pulley_xulteq64 (XReg XReg) XReg)
+(rule (pulley_xulteq64 a b)
+      (let ((dst WritableXReg (temp_writable_xreg))
+            (_ Unit (emit (MInst.Xulteq64 dst a b))))
+        dst))
+
+(decl pulley_xeq32 (XReg XReg) XReg)
+(rule (pulley_xeq32 a b)
+      (let ((dst WritableXReg (temp_writable_xreg))
+            (_ Unit (emit (MInst.Xeq32 dst a b))))
+        dst))
+
+(decl pulley_xneq32 (XReg XReg) XReg)
+(rule (pulley_xneq32 a b)
+      (let ((dst WritableXReg (temp_writable_xreg))
+            (_ Unit (emit (MInst.Xneq32 dst a b))))
+        dst))
+
+(decl pulley_xslt32 (XReg XReg) XReg)
+(rule (pulley_xslt32 a b)
+      (let ((dst WritableXReg (temp_writable_xreg))
+            (_ Unit (emit (MInst.Xslt32 dst a b))))
+        dst))
+
+(decl pulley_xslteq32 (XReg XReg) XReg)
+(rule (pulley_xslteq32 a b)
+      (let ((dst WritableXReg (temp_writable_xreg))
+            (_ Unit (emit (MInst.Xslteq32 dst a b))))
+        dst))
+
+(decl pulley_xult32 (XReg XReg) XReg)
+(rule (pulley_xult32 a b)
+      (let ((dst WritableXReg (temp_writable_xreg))
+            (_ Unit (emit (MInst.Xult32 dst a b))))
+        dst))
+
+(decl pulley_xulteq32 (XReg XReg) XReg)
+(rule (pulley_xulteq32 a b)
+      (let ((dst WritableXReg (temp_writable_xreg))
+            (_ Unit (emit (MInst.Xulteq32 dst a b))))
+        dst))
+
+(decl pulley_load (Amode Type MemFlags ExtKind) Reg)
+(rule (pulley_load amode ty flags ext)
+      (let ((dst WritableReg (temp_writable_reg ty))
+            (_ Unit (emit (MInst.Load dst amode ty flags ext))))
+        dst))
+
+(decl pulley_store (Amode Reg Type MemFlags) SideEffectNoResult)
+(rule (pulley_store amode src ty flags)
+      (SideEffectNoResult.Inst (MInst.Store amode src ty flags)))
+
+(decl pulley_bitcast_float_from_int_32 (XReg) FReg)
+(rule (pulley_bitcast_float_from_int_32 src)
+      (let ((dst WritableFReg (temp_writable_freg))
+            (_ Unit (emit (MInst.BitcastFloatFromInt32 dst src))))
+        dst))
+
+(decl pulley_bitcast_float_from_int_64 (XReg) FReg)
+(rule (pulley_bitcast_float_from_int_64 src)
+      (let ((dst WritableFReg (temp_writable_freg))
+            (_ Unit (emit (MInst.BitcastFloatFromInt64 dst src))))
+        dst))
+
+(decl pulley_bitcast_int_from_float_32 (FReg) XReg)
+(rule (pulley_bitcast_int_from_float_32 src)
+      (let ((dst WritableXReg (temp_writable_xreg))
+            (_ Unit (emit (MInst.BitcastIntFromFloat32 dst src))))
+        dst))
+
+(decl pulley_bitcast_int_from_float_64 (FReg) XReg)
+(rule (pulley_bitcast_int_from_float_64 src)
+      (let ((dst WritableXReg (temp_writable_xreg))
+            (_ Unit (emit (MInst.BitcastIntFromFloat64 dst src))))
+        dst))
+
+;;;; Helpers for Emitting Calls ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(decl gen_call (SigRef ExternalName RelocDistance ValueSlice) InstOutput)
+(extern constructor gen_call gen_call)
+
+(decl gen_call_indirect (SigRef Value ValueSlice) InstOutput)
+(extern constructor gen_call_indirect gen_call_indirect)
diff --git a/cranelift/codegen/src/isa/pulley_shared/inst/args.rs b/cranelift/codegen/src/isa/pulley_shared/inst/args.rs
new file mode 100644
index 000000000000..d74c2a7e010a
--- /dev/null
+++ b/cranelift/codegen/src/isa/pulley_shared/inst/args.rs
@@ -0,0 +1,192 @@
+//! Pulley instruction arguments.
+
+use super::*;
+use crate::machinst::abi::StackAMode;
+use pulley_interpreter::regs::Reg as _;
+
+/// A macro for defining a newtype of `Reg` that enforces some invariant about
+/// the wrapped `Reg` (such as that it is of a particular register class).
+macro_rules! newtype_of_reg {
+    (
+        $newtype_reg:ident,
+        $newtype_writable_reg:ident,
+        |$check_reg:ident| $check:expr
+    ) => {
+        /// A newtype wrapper around `Reg`.
+        #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+        pub struct $newtype_reg(Reg);
+
+        impl PartialEq<Reg> for $newtype_reg {
+            fn eq(&self, other: &Reg) -> bool {
+                self.0 == *other
+            }
+        }
+
+        impl From<$newtype_reg> for Reg {
+            fn from(r: $newtype_reg) -> Self {
+                r.0
+            }
+        }
+
+        impl TryFrom<Reg> for $newtype_reg {
+            type Error = ();
+            fn try_from(r: Reg) -> Result<Self, Self::Error> {
+                Self::new(r).ok_or(())
+            }
+        }
+
+        impl $newtype_reg {
+            /// Create this newtype from the given register, or return `None` if the register
+            /// is not a valid instance of this newtype.
+            pub fn new($check_reg: Reg) -> Option<Self> {
+                if $check {
+                    Some(Self($check_reg))
+                } else {
+                    None
+                }
+            }
+
+            /// Get this newtype's underlying `Reg`.
+            pub fn to_reg(self) -> Reg {
+                self.0
+            }
+        }
+
+        // Convenience impl so that people working with this newtype can use it
+        // "just like" a plain `Reg`.
+        //
+        // NB: We cannot implement `DerefMut` because that would let people do
+        // nasty stuff like `*my_xreg.deref_mut() = some_freg`, breaking the
+        // invariants that `XReg` provides.
+        impl std::ops::Deref for $newtype_reg {
+            type Target = Reg;
+
+            fn deref(&self) -> &Reg {
+                &self.0
+            }
+        }
+
+        /// If you know what you're doing, you can explicitly mutably borrow the
+        /// underlying `Reg`. Don't make it point to the wrong type of register
+        /// please.
+        impl AsMut<Reg> for $newtype_reg {
+            fn as_mut(&mut self) -> &mut Reg {
+                &mut self.0
+            }
+        }
+
+        /// Writable Reg.
+        pub type $newtype_writable_reg = Writable<$newtype_reg>;
+
+        impl From<$newtype_reg> for pulley_interpreter::regs::$newtype_reg {
+            fn from(r: $newtype_reg) -> Self {
+                Self::new(r.to_real_reg().unwrap().hw_enc()).unwrap()
+            }
+        }
+        impl<'a> From<&'a $newtype_reg> for pulley_interpreter::regs::$newtype_reg {
+            fn from(r: &'a $newtype_reg) -> Self {
+                Self::new(r.to_real_reg().unwrap().hw_enc()).unwrap()
+            }
+        }
+        impl From<$newtype_writable_reg> for pulley_interpreter::regs::$newtype_reg {
+            fn from(r: $newtype_writable_reg) -> Self {
+                Self::new(r.to_reg().to_real_reg().unwrap().hw_enc()).unwrap()
+            }
+        }
+        impl<'a> From<&'a $newtype_writable_reg> for pulley_interpreter::regs::$newtype_reg {
+            fn from(r: &'a $newtype_writable_reg) -> Self {
+                Self::new(r.to_reg().to_real_reg().unwrap().hw_enc()).unwrap()
+            }
+        }
+
+        impl TryFrom<Writable<Reg>> for $newtype_writable_reg {
+            type Error = ();
+            fn try_from(r: Writable<Reg>) -> Result<Self, Self::Error> {
+                let r = r.to_reg();
+                match $newtype_reg::new(r) {
+                    Some(r) => Ok(Writable::from_reg(r)),
+                    None => Err(()),
+                }
+            }
+        }
+    };
+}
+
+// Newtypes for registers classes.
+newtype_of_reg!(XReg, WritableXReg, |reg| reg.class() == RegClass::Int);
+newtype_of_reg!(FReg, WritableFReg, |reg| reg.class() == RegClass::Float);
+newtype_of_reg!(VReg, WritableVReg, |reg| reg.class() == RegClass::Vector);
+
+pub use super::super::lower::isle::generated_code::ExtKind;
+
+pub use super::super::lower::isle::generated_code::Amode;
+
+impl Amode {
+    /// Add the registers referenced by this Amode to `collector`.
+    pub(crate) fn get_operands(&mut self, collector: &mut impl OperandVisitor) {
+        match self {
+            Amode::RegOffset { base, offset: _ } => collector.reg_use(base),
+            // Registers used in these modes aren't allocatable.
+            Amode::SpOffset { .. } | Amode::Stack { .. } => {}
+        }
+    }
+
+    pub(crate) fn get_base_register(&self) -> Option<Reg> {
+        match self {
+            Amode::RegOffset { base, offset: _ } => Some((*base).into()),
+            Amode::SpOffset { .. } | Amode::Stack { .. } => Some(stack_reg()),
+        }
+    }
+
+    pub(crate) fn get_offset_with_state<P>(&self, state: &EmitState<P>) -> i64
+    where
+        P: PulleyTargetKind,
+    {
+        match self {
+            Amode::RegOffset { base: _, offset } | Amode::SpOffset { offset } => *offset,
+            Amode::Stack { amode } => match amode {
+                StackAMode::IncomingArg(offset, stack_args_size) => {
+                    let offset = i64::from(*stack_args_size) - *offset;
+                    let frame_layout = state.frame_layout();
+                    let sp_offset = frame_layout.tail_args_size
+                        + frame_layout.setup_area_size
+                        + frame_layout.clobber_size
+                        + frame_layout.fixed_frame_storage_size
+                        + frame_layout.outgoing_args_size;
+                    i64::from(sp_offset) - offset
+                }
+                StackAMode::Slot(offset) => *offset + state.virtual_sp_offset,
+                StackAMode::OutgoingArg(offset) => *offset,
+            },
+        }
+    }
+}
+
+impl core::fmt::Display for Amode {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Amode::SpOffset { offset } => {
+                if *offset >= 0 {
+                    write!(f, "sp+{offset}")
+                } else {
+                    write!(f, "sp{offset}")
+                }
+            }
+            Amode::RegOffset { base, offset } => {
+                let name = reg_name(**base);
+                if *offset >= 0 {
+                    write!(f, "{name}+{offset}")
+                } else {
+                    write!(f, "{name}{offset}")
+                }
+            }
+            Amode::Stack { amode } => core::fmt::Debug::fmt(amode, f),
+        }
+    }
+}
+
+impl From<StackAMode> for Amode {
+    fn from(amode: StackAMode) -> Self {
+        Amode::Stack { amode }
+    }
+}
diff --git a/cranelift/codegen/src/isa/pulley_shared/inst/emit.rs b/cranelift/codegen/src/isa/pulley_shared/inst/emit.rs
new file mode 100644
index 000000000000..7470bcad67e3
--- /dev/null
+++ b/cranelift/codegen/src/isa/pulley_shared/inst/emit.rs
@@ -0,0 +1,482 @@
+//! Pulley binary code emission.
+
+use super::*;
+use crate::ir;
+use crate::isa::pulley_shared::abi::PulleyMachineDeps;
+use crate::isa::pulley_shared::PointerWidth;
+use crate::trace;
+use core::marker::PhantomData;
+use cranelift_control::ControlPlane;
+use pulley_interpreter::encode as enc;
+use pulley_interpreter::regs::BinaryOperands;
+use pulley_interpreter::regs::Reg as _;
+
+pub struct EmitInfo {
+    #[allow(dead_code)] // Will get used as we fill out this backend.
+    shared_flags: settings::Flags,
+
+    #[allow(dead_code)] // Will get used as we fill out this backend.
+    isa_flags: crate::isa::pulley_shared::settings::Flags,
+}
+
+impl EmitInfo {
+    pub(crate) fn new(
+        shared_flags: settings::Flags,
+        isa_flags: crate::isa::pulley_shared::settings::Flags,
+    ) -> Self {
+        Self {
+            shared_flags,
+            isa_flags,
+        }
+    }
+}
+
+/// State carried between emissions of a sequence of instructions.
+#[derive(Default, Clone, Debug)]
+pub struct EmitState<P>
+where
+    P: PulleyTargetKind,
+{
+    _phantom: PhantomData<P>,
+    ctrl_plane: ControlPlane,
+    user_stack_map: Option<ir::UserStackMap>,
+    pub virtual_sp_offset: i64,
+    frame_layout: FrameLayout,
+}
+
+impl<P> EmitState<P>
+where
+    P: PulleyTargetKind,
+{
+    fn take_stack_map(&mut self) -> Option<ir::UserStackMap> {
+        self.user_stack_map.take()
+    }
+
+    pub(crate) fn adjust_virtual_sp_offset(&mut self, amount: i64) {
+        let old = self.virtual_sp_offset;
+        let new = self.virtual_sp_offset + amount;
+        trace!("adjust virtual sp offset by {amount:#x}: {old:#x} -> {new:#x}",);
+        self.virtual_sp_offset = new;
+    }
+}
+
+impl<P> MachInstEmitState<InstAndKind<P>> for EmitState<P>
+where
+    P: PulleyTargetKind,
+{
+    fn new(abi: &Callee<PulleyMachineDeps<P>>, ctrl_plane: ControlPlane) -> Self {
+        EmitState {
+            _phantom: PhantomData,
+            ctrl_plane,
+            user_stack_map: None,
+            virtual_sp_offset: 0,
+            frame_layout: abi.frame_layout().clone(),
+        }
+    }
+
+    fn pre_safepoint(&mut self, user_stack_map: Option<ir::UserStackMap>) {
+        self.user_stack_map = user_stack_map;
+    }
+
+    fn ctrl_plane_mut(&mut self) -> &mut ControlPlane {
+        &mut self.ctrl_plane
+    }
+
+    fn take_ctrl_plane(self) -> ControlPlane {
+        self.ctrl_plane
+    }
+
+    fn frame_layout(&self) -> &FrameLayout {
+        &self.frame_layout
+    }
+}
+
+impl<P> MachInstEmit for InstAndKind<P>
+where
+    P: PulleyTargetKind,
+{
+    type State = EmitState<P>;
+    type Info = EmitInfo;
+
+    fn emit(&self, sink: &mut MachBuffer<Self>, emit_info: &Self::Info, state: &mut Self::State) {
+        // N.B.: we *must* not exceed the "worst-case size" used to compute
+        // where to insert islands, except when islands are explicitly triggered
+        // (with an `EmitIsland`). We check this in debug builds. This is `mut`
+        // to allow disabling the check for `JTSequence`, which is always
+        // emitted following an `EmitIsland`.
+        let start = sink.cur_offset();
+        pulley_emit(self, sink, emit_info, state, start);
+
+        let end = sink.cur_offset();
+        assert!(
+            (end - start) <= InstAndKind::<P>::worst_case_size(),
+            "encoded inst {self:?} longer than worst-case size: length: {}, Inst::worst_case_size() = {}",
+            end - start,
+            InstAndKind::<P>::worst_case_size()
+        );
+    }
+
+    fn pretty_print_inst(&self, state: &mut Self::State) -> String {
+        self.print_with_state(state)
+    }
+}
+
+fn pulley_emit<P>(
+    inst: &Inst,
+    sink: &mut MachBuffer<InstAndKind<P>>,
+    _emit_info: &EmitInfo,
+    state: &mut EmitState<P>,
+    start_offset: u32,
+) where
+    P: PulleyTargetKind,
+{
+    match inst {
+        // Pseduo-instructions that don't actually encode to anything.
+        Inst::Args { .. } | Inst::Rets { .. } | Inst::Unwind { .. } => {}
+
+        Inst::Trap { code } => {
+            sink.add_trap(*code);
+            enc::trap(sink);
+        }
+
+        Inst::Nop => todo!(),
+
+        Inst::GetSp { dst } => enc::get_sp(sink, dst),
+
+        Inst::Ret => enc::ret(sink),
+
+        Inst::LoadExtName { .. } => todo!(),
+
+        Inst::Call { callee, info } => {
+            sink.put1(pulley_interpreter::Opcode::Call as u8);
+            sink.add_reloc(
+                // TODO: is it actually okay to reuse this reloc here?
+                Reloc::X86CallPCRel4,
+                &**callee,
+                // This addend adjusts for the difference between the start of
+                // the instruction and the beginning of the immediate field.
+                -1,
+            );
+            sink.put4(0);
+            if let Some(s) = state.take_stack_map() {
+                let offset = sink.cur_offset();
+                sink.push_user_stack_map(state, offset, s);
+            }
+            sink.add_call_site();
+
+            let callee_pop_size = i64::from(info.callee_pop_size);
+            state.adjust_virtual_sp_offset(-callee_pop_size);
+        }
+
+        Inst::IndirectCall { .. } => todo!(),
+
+        Inst::Jump { label } => {
+            sink.use_label_at_offset(start_offset + 1, *label, LabelUse::Jump(1));
+            sink.add_uncond_branch(start_offset, start_offset + 5, *label);
+            enc::jump(sink, 0x00000000);
+        }
+
+        Inst::BrIf {
+            c,
+            taken,
+            not_taken,
+        } => {
+            // If taken.
+            let taken_start = start_offset + 2;
+            let taken_end = taken_start + 4;
+
+            sink.use_label_at_offset(taken_start, *taken, LabelUse::Jump(2));
+            let mut inverted = SmallVec::<[u8; 16]>::new();
+            enc::br_if_not(&mut inverted, c, 0x00000000);
+            debug_assert_eq!(
+                inverted.len(),
+                usize::try_from(taken_end - start_offset).unwrap()
+            );
+
+            sink.add_cond_branch(start_offset, taken_end, *taken, &inverted);
+            enc::br_if(sink, c, 0x00000000);
+            debug_assert_eq!(sink.cur_offset(), taken_end);
+
+            // If not taken.
+            let not_taken_start = taken_end + 1;
+            let not_taken_end = not_taken_start + 4;
+
+            sink.use_label_at_offset(not_taken_start, *not_taken, LabelUse::Jump(1));
+            sink.add_uncond_branch(taken_end, not_taken_end, *not_taken);
+            enc::jump(sink, 0x00000000);
+        }
+
+        Inst::BrIfXeq32 {
+            src1,
+            src2,
+            taken,
+            not_taken,
+        } => {
+            br_if_cond_helper(
+                sink,
+                start_offset,
+                *src1,
+                *src2,
+                taken,
+                not_taken,
+                enc::br_if_xeq32,
+                enc::br_if_xneq32,
+            );
+        }
+
+        Inst::BrIfXneq32 {
+            src1,
+            src2,
+            taken,
+            not_taken,
+        } => {
+            br_if_cond_helper(
+                sink,
+                start_offset,
+                *src1,
+                *src2,
+                taken,
+                not_taken,
+                enc::br_if_xneq32,
+                enc::br_if_xeq32,
+            );
+        }
+
+        Inst::BrIfXslt32 {
+            src1,
+            src2,
+            taken,
+            not_taken,
+        } => {
+            br_if_cond_helper(
+                sink,
+                start_offset,
+                *src1,
+                *src2,
+                taken,
+                not_taken,
+                enc::br_if_xslt32,
+                |s, src1, src2, x| enc::br_if_xslteq32(s, src2, src1, x),
+            );
+        }
+
+        Inst::BrIfXslteq32 {
+            src1,
+            src2,
+            taken,
+            not_taken,
+        } => {
+            br_if_cond_helper(
+                sink,
+                start_offset,
+                *src1,
+                *src2,
+                taken,
+                not_taken,
+                enc::br_if_xslteq32,
+                |s, src1, src2, x| enc::br_if_xslt32(s, src2, src1, x),
+            );
+        }
+
+        Inst::BrIfXult32 {
+            src1,
+            src2,
+            taken,
+            not_taken,
+        } => {
+            br_if_cond_helper(
+                sink,
+                start_offset,
+                *src1,
+                *src2,
+                taken,
+                not_taken,
+                enc::br_if_xult32,
+                |s, src1, src2, x| enc::br_if_xulteq32(s, src2, src1, x),
+            );
+        }
+
+        Inst::BrIfXulteq32 {
+            src1,
+            src2,
+            taken,
+            not_taken,
+        } => {
+            br_if_cond_helper(
+                sink,
+                start_offset,
+                *src1,
+                *src2,
+                taken,
+                not_taken,
+                enc::br_if_xulteq32,
+                |s, src1, src2, x| enc::br_if_xult32(s, src2, src1, x),
+            );
+        }
+
+        Inst::Xmov { dst, src } => enc::xmov(sink, dst, src),
+        Inst::Fmov { dst, src } => enc::fmov(sink, dst, src),
+        Inst::Vmov { dst, src } => enc::vmov(sink, dst, src),
+
+        Inst::Xconst8 { dst, imm } => enc::xconst8(sink, dst, *imm),
+        Inst::Xconst16 { dst, imm } => enc::xconst16(sink, dst, *imm),
+        Inst::Xconst32 { dst, imm } => enc::xconst32(sink, dst, *imm),
+        Inst::Xconst64 { dst, imm } => enc::xconst64(sink, dst, *imm),
+
+        Inst::Xadd32 { dst, src1, src2 } => enc::xadd32(sink, BinaryOperands::new(dst, src1, src2)),
+        Inst::Xadd64 { dst, src1, src2 } => enc::xadd64(sink, BinaryOperands::new(dst, src1, src2)),
+        Inst::Xeq64 { dst, src1, src2 } => enc::xeq64(sink, BinaryOperands::new(dst, src1, src2)),
+        Inst::Xneq64 { dst, src1, src2 } => enc::xneq64(sink, BinaryOperands::new(dst, src1, src2)),
+        Inst::Xslt64 { dst, src1, src2 } => enc::xslt64(sink, BinaryOperands::new(dst, src1, src2)),
+        Inst::Xslteq64 { dst, src1, src2 } => {
+            enc::xslteq64(sink, BinaryOperands::new(dst, src1, src2))
+        }
+        Inst::Xult64 { dst, src1, src2 } => enc::xult64(sink, BinaryOperands::new(dst, src1, src2)),
+        Inst::Xulteq64 { dst, src1, src2 } => {
+            enc::xulteq64(sink, BinaryOperands::new(dst, src1, src2))
+        }
+
+        Inst::Xeq32 { dst, src1, src2 } => enc::xeq32(sink, BinaryOperands::new(dst, src1, src2)),
+        Inst::Xneq32 { dst, src1, src2 } => enc::xneq32(sink, BinaryOperands::new(dst, src1, src2)),
+        Inst::Xslt32 { dst, src1, src2 } => enc::xslt32(sink, BinaryOperands::new(dst, src1, src2)),
+        Inst::Xslteq32 { dst, src1, src2 } => {
+            enc::xslteq32(sink, BinaryOperands::new(dst, src1, src2))
+        }
+        Inst::Xult32 { dst, src1, src2 } => enc::xult32(sink, BinaryOperands::new(dst, src1, src2)),
+        Inst::Xulteq32 { dst, src1, src2 } => {
+            enc::xulteq32(sink, BinaryOperands::new(dst, src1, src2))
+        }
+
+        Inst::LoadAddr { dst, mem } => {
+            let base = mem.get_base_register();
+            let offset = mem.get_offset_with_state(state);
+
+            if let Some(base) = base {
+                let base = XReg::new(base).unwrap();
+
+                if offset == 0 {
+                    enc::xmov(sink, dst, base);
+                } else {
+                    if let Ok(offset) = i8::try_from(offset) {
+                        enc::xconst8(sink, dst, offset);
+                    } else if let Ok(offset) = i16::try_from(offset) {
+                        enc::xconst16(sink, dst, offset);
+                    } else if let Ok(offset) = i32::try_from(offset) {
+                        enc::xconst32(sink, dst, offset);
+                    } else {
+                        enc::xconst64(sink, dst, offset);
+                    }
+
+                    match P::pointer_width() {
+                        PointerWidth::PointerWidth32 => {
+                            enc::xadd32(sink, BinaryOperands::new(dst, base, dst))
+                        }
+                        PointerWidth::PointerWidth64 => {
+                            enc::xadd64(sink, BinaryOperands::new(dst, base, dst))
+                        }
+                    }
+                }
+            } else {
+                unreachable!("all pulley amodes have a base register right now")
+            }
+        }
+
+        Inst::Load {
+            dst,
+            mem,
+            ty,
+            flags: _,
+            ext,
+        } => {
+            use ExtKind as X;
+            let r = mem.get_base_register().unwrap();
+            let r = reg_to_pulley_xreg(r);
+            let dst = reg_to_pulley_xreg(dst.to_reg());
+            let x = mem.get_offset_with_state(state);
+            match (*ext, *ty, i8::try_from(x)) {
+                (X::Sign, types::I32, Ok(0)) => enc::load32_s(sink, dst, r),
+                (X::Sign, types::I32, Ok(x)) => enc::load32_s_offset8(sink, dst, r, x),
+                (X::Sign, types::I32, Err(_)) => enc::load32_s_offset64(sink, dst, r, x),
+
+                (X::Zero, types::I32, Ok(0)) => enc::load32_u(sink, dst, r),
+                (X::Zero, types::I32, Ok(x)) => enc::load32_u_offset8(sink, dst, r, x),
+                (X::Zero, types::I32, Err(_)) => enc::load32_u_offset64(sink, dst, r, x),
+
+                (_, types::I64, Ok(0)) => enc::load64(sink, dst, r),
+                (_, types::I64, Ok(x)) => enc::load64_offset8(sink, dst, r, x),
+                (_, types::I64, Err(_)) => enc::load64_offset64(sink, dst, r, x),
+
+                (..) => unimplemented!("load ext={ext:?} ty={ty}"),
+            }
+        }
+
+        Inst::Store {
+            mem,
+            src,
+            ty,
+            flags: _,
+        } => {
+            let r = mem.get_base_register().unwrap();
+            let r = reg_to_pulley_xreg(r);
+            let src = reg_to_pulley_xreg(*src);
+            let x = mem.get_offset_with_state(state);
+            match (*ty, i8::try_from(x)) {
+                (types::I32, Ok(0)) => enc::store32(sink, r, src),
+                (types::I32, Ok(x)) => enc::store32_offset8(sink, r, x, src),
+                (types::I32, Err(_)) => enc::store32_offset64(sink, r, x, src),
+
+                (types::I64, Ok(0)) => enc::store64(sink, r, src),
+                (types::I64, Ok(x)) => enc::store64_offset8(sink, r, x, src),
+                (types::I64, Err(_)) => enc::store64_offset64(sink, r, x, src),
+
+                (..) => todo!(),
+            }
+        }
+
+        Inst::BitcastIntFromFloat32 { dst, src } => enc::bitcast_int_from_float_32(sink, dst, src),
+        Inst::BitcastIntFromFloat64 { dst, src } => enc::bitcast_int_from_float_64(sink, dst, src),
+        Inst::BitcastFloatFromInt32 { dst, src } => enc::bitcast_float_from_int_32(sink, dst, src),
+        Inst::BitcastFloatFromInt64 { dst, src } => enc::bitcast_float_from_int_64(sink, dst, src),
+    }
+}
+
+fn br_if_cond_helper<P>(
+    sink: &mut MachBuffer<InstAndKind<P>>,
+    start_offset: u32,
+    src1: XReg,
+    src2: XReg,
+    taken: &MachLabel,
+    not_taken: &MachLabel,
+    mut enc: impl FnMut(&mut MachBuffer<InstAndKind<P>>, XReg, XReg, i32),
+    mut enc_inverted: impl FnMut(&mut SmallVec<[u8; 16]>, XReg, XReg, i32),
+) where
+    P: PulleyTargetKind,
+{
+    // If taken.
+    let taken_start = start_offset + 3;
+    let taken_end = taken_start + 4;
+
+    sink.use_label_at_offset(taken_start, *taken, LabelUse::Jump(3));
+    let mut inverted = SmallVec::<[u8; 16]>::new();
+    enc_inverted(&mut inverted, src1, src2, 0x00000000);
+    debug_assert_eq!(
+        inverted.len(),
+        usize::try_from(taken_end - start_offset).unwrap()
+    );
+
+    sink.add_cond_branch(start_offset, taken_end, *taken, &inverted);
+    enc(sink, src1, src2, 0x00000000);
+    debug_assert_eq!(sink.cur_offset(), taken_end);
+
+    // If not taken.
+    let not_taken_start = taken_end + 1;
+    let not_taken_end = not_taken_start + 4;
+
+    sink.use_label_at_offset(not_taken_start, *not_taken, LabelUse::Jump(1));
+    sink.add_uncond_branch(taken_end, not_taken_end, *not_taken);
+    enc::jump(sink, 0x00000000);
+}
+
+fn reg_to_pulley_xreg(r: Reg) -> pulley_interpreter::XReg {
+    pulley_interpreter::XReg::new(r.to_real_reg().unwrap().hw_enc()).unwrap()
+}
diff --git a/cranelift/codegen/src/isa/pulley_shared/inst/mod.rs b/cranelift/codegen/src/isa/pulley_shared/inst/mod.rs
new file mode 100644
index 000000000000..8051ae9f3fc0
--- /dev/null
+++ b/cranelift/codegen/src/isa/pulley_shared/inst/mod.rs
@@ -0,0 +1,916 @@
+//! This module defines Pulley-specific machine instruction types.
+
+use core::marker::PhantomData;
+
+use crate::binemit::{Addend, CodeOffset, Reloc};
+use crate::ir::types::{self, F32, F64, I128, I16, I32, I64, I8, I8X16};
+use crate::ir::{self, MemFlags, Type};
+use crate::isa::pulley_shared::abi::PulleyMachineDeps;
+use crate::isa::FunctionAlignment;
+use crate::{machinst::*, trace};
+use crate::{settings, CodegenError, CodegenResult};
+use alloc::string::{String, ToString};
+use regalloc2::{PRegSet, RegClass};
+use smallvec::SmallVec;
+
+pub mod regs;
+pub use self::regs::*;
+pub mod args;
+pub use self::args::*;
+pub mod emit;
+pub use self::emit::*;
+
+//=============================================================================
+// Instructions (top level): definition
+
+pub use crate::isa::pulley_shared::lower::isle::generated_code::MInst as Inst;
+
+use super::PulleyTargetKind;
+
+/// Additional information for direct and indirect call instructions.
+///
+/// Left out of line to lower the size of the `Inst` enum.
+#[derive(Clone, Debug)]
+pub struct CallInfo {
+    pub uses: CallArgList,
+    pub defs: CallRetList,
+    pub clobbers: PRegSet,
+    pub callee_pop_size: u32,
+}
+
+impl Inst {
+    /// Generic constructor for a load (zero-extending where appropriate).
+    pub fn gen_load(dst: Writable<Reg>, mem: Amode, ty: Type, flags: MemFlags) -> Inst {
+        Inst::Load {
+            dst,
+            mem,
+            ty,
+            flags,
+            ext: ExtKind::Zero,
+        }
+    }
+
+    /// Generic constructor for a store.
+    pub fn gen_store(mem: Amode, from_reg: Reg, ty: Type, flags: MemFlags) -> Inst {
+        Inst::Store {
+            mem,
+            src: from_reg,
+            ty,
+            flags,
+        }
+    }
+}
+
+fn pulley_get_operands(inst: &mut Inst, collector: &mut impl OperandVisitor) {
+    match inst {
+        Inst::Args { args } => {
+            for ArgPair { vreg, preg } in args {
+                collector.reg_fixed_def(vreg, *preg);
+            }
+        }
+        Inst::Rets { rets } => {
+            for RetPair { vreg, preg } in rets {
+                collector.reg_fixed_use(vreg, *preg);
+            }
+        }
+        Inst::Ret => {
+            unreachable!("`ret` is only added after regalloc")
+        }
+
+        Inst::Unwind { .. } | Inst::Trap { .. } | Inst::Nop => {}
+
+        Inst::GetSp { dst } => {
+            collector.reg_def(dst);
+        }
+
+        Inst::LoadExtName {
+            dst,
+            name: _,
+            offset: _,
+        } => {
+            collector.reg_def(dst);
+        }
+
+        Inst::Call { callee: _, info } => {
+            let CallInfo { uses, defs, .. } = &mut **info;
+            for CallArgPair { vreg, preg } in uses {
+                collector.reg_fixed_use(vreg, *preg);
+            }
+            for CallRetPair { vreg, preg } in defs {
+                collector.reg_fixed_def(vreg, *preg);
+            }
+            collector.reg_clobbers(info.clobbers);
+        }
+        Inst::IndirectCall { callee, info } => {
+            collector.reg_use(callee);
+            let CallInfo { uses, defs, .. } = &mut **info;
+            for CallArgPair { vreg, preg } in uses {
+                collector.reg_fixed_use(vreg, *preg);
+            }
+            for CallRetPair { vreg, preg } in defs {
+                collector.reg_fixed_def(vreg, *preg);
+            }
+            collector.reg_clobbers(info.clobbers);
+        }
+
+        Inst::Jump { .. } => {}
+
+        Inst::BrIf {
+            c,
+            taken: _,
+            not_taken: _,
+        } => {
+            collector.reg_use(c);
+        }
+
+        Inst::BrIfXeq32 {
+            src1,
+            src2,
+            taken: _,
+            not_taken: _,
+        }
+        | Inst::BrIfXneq32 {
+            src1,
+            src2,
+            taken: _,
+            not_taken: _,
+        }
+        | Inst::BrIfXslt32 {
+            src1,
+            src2,
+            taken: _,
+            not_taken: _,
+        }
+        | Inst::BrIfXslteq32 {
+            src1,
+            src2,
+            taken: _,
+            not_taken: _,
+        }
+        | Inst::BrIfXult32 {
+            src1,
+            src2,
+            taken: _,
+            not_taken: _,
+        }
+        | Inst::BrIfXulteq32 {
+            src1,
+            src2,
+            taken: _,
+            not_taken: _,
+        } => {
+            collector.reg_use(src1);
+            collector.reg_use(src2);
+        }
+
+        Inst::Xmov { dst, src } => {
+            collector.reg_use(src);
+            collector.reg_def(dst);
+        }
+        Inst::Fmov { dst, src } => {
+            collector.reg_use(src);
+            collector.reg_def(dst);
+        }
+        Inst::Vmov { dst, src } => {
+            collector.reg_use(src);
+            collector.reg_def(dst);
+        }
+
+        Inst::Xconst8 { dst, imm: _ }
+        | Inst::Xconst16 { dst, imm: _ }
+        | Inst::Xconst32 { dst, imm: _ }
+        | Inst::Xconst64 { dst, imm: _ } => {
+            collector.reg_def(dst);
+        }
+
+        Inst::Xadd32 { dst, src1, src2 }
+        | Inst::Xadd64 { dst, src1, src2 }
+        | Inst::Xeq64 { dst, src1, src2 }
+        | Inst::Xneq64 { dst, src1, src2 }
+        | Inst::Xslt64 { dst, src1, src2 }
+        | Inst::Xslteq64 { dst, src1, src2 }
+        | Inst::Xult64 { dst, src1, src2 }
+        | Inst::Xulteq64 { dst, src1, src2 }
+        | Inst::Xeq32 { dst, src1, src2 }
+        | Inst::Xneq32 { dst, src1, src2 }
+        | Inst::Xslt32 { dst, src1, src2 }
+        | Inst::Xslteq32 { dst, src1, src2 }
+        | Inst::Xult32 { dst, src1, src2 }
+        | Inst::Xulteq32 { dst, src1, src2 } => {
+            collector.reg_use(src1);
+            collector.reg_use(src2);
+            collector.reg_def(dst);
+        }
+
+        Inst::LoadAddr { dst, mem } => {
+            collector.reg_def(dst);
+            mem.get_operands(collector);
+        }
+
+        Inst::Load {
+            dst,
+            mem,
+            ty: _,
+            flags: _,
+            ext: _,
+        } => {
+            collector.reg_def(dst);
+            mem.get_operands(collector);
+        }
+
+        Inst::Store {
+            mem,
+            src,
+            ty: _,
+            flags: _,
+        } => {
+            mem.get_operands(collector);
+            collector.reg_use(src);
+        }
+
+        Inst::BitcastIntFromFloat32 { dst, src } => {
+            collector.reg_use(src);
+            collector.reg_def(dst);
+        }
+        Inst::BitcastIntFromFloat64 { dst, src } => {
+            collector.reg_use(src);
+            collector.reg_def(dst);
+        }
+        Inst::BitcastFloatFromInt32 { dst, src } => {
+            collector.reg_use(src);
+            collector.reg_def(dst);
+        }
+        Inst::BitcastFloatFromInt64 { dst, src } => {
+            collector.reg_use(src);
+            collector.reg_def(dst);
+        }
+    }
+}
+
+/// A newtype over a Pulley instruction that also carries a phantom type
+/// parameter describing whether we are targeting 32- or 64-bit Pulley bytecode.
+///
+/// Implements `Deref`, `DerefMut`, and `From`/`Into` for `Inst` to allow for
+/// seamless conversion between `Inst` and `InstAndKind`.
+#[derive(Clone, Debug)]
+pub struct InstAndKind<P>
+where
+    P: PulleyTargetKind,
+{
+    inst: Inst,
+    kind: PhantomData<P>,
+}
+
+impl<P> From<Inst> for InstAndKind<P>
+where
+    P: PulleyTargetKind,
+{
+    fn from(inst: Inst) -> Self {
+        Self {
+            inst,
+            kind: PhantomData,
+        }
+    }
+}
+
+impl<P> From<InstAndKind<P>> for Inst
+where
+    P: PulleyTargetKind,
+{
+    fn from(inst: InstAndKind<P>) -> Self {
+        inst.inst
+    }
+}
+
+impl<P> core::ops::Deref for InstAndKind<P>
+where
+    P: PulleyTargetKind,
+{
+    type Target = Inst;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inst
+    }
+}
+
+impl<P> core::ops::DerefMut for InstAndKind<P>
+where
+    P: PulleyTargetKind,
+{
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inst
+    }
+}
+
+impl<P> MachInst for InstAndKind<P>
+where
+    P: PulleyTargetKind,
+{
+    type LabelUse = LabelUse;
+    type ABIMachineSpec = PulleyMachineDeps<P>;
+
+    const TRAP_OPCODE: &'static [u8] = &[0];
+
+    fn gen_dummy_use(_reg: Reg) -> Self {
+        todo!()
+    }
+
+    fn canonical_type_for_rc(rc: RegClass) -> Type {
+        match rc {
+            regalloc2::RegClass::Int => I64,
+            regalloc2::RegClass::Float => F64,
+            regalloc2::RegClass::Vector => I8X16,
+        }
+    }
+
+    fn is_safepoint(&self) -> bool {
+        match self.inst {
+            Inst::Trap { .. } => true,
+            _ => false,
+        }
+    }
+
+    fn get_operands(&mut self, collector: &mut impl OperandVisitor) {
+        pulley_get_operands(self, collector);
+    }
+
+    fn is_move(&self) -> Option<(Writable<Reg>, Reg)> {
+        match self.inst {
+            Inst::Xmov { dst, src } => Some((Writable::from_reg(*dst.to_reg()), *src)),
+            _ => None,
+        }
+    }
+
+    fn is_included_in_clobbers(&self) -> bool {
+        self.is_args()
+    }
+
+    fn is_trap(&self) -> bool {
+        match self.inst {
+            Inst::Trap { .. } => true,
+            _ => false,
+        }
+    }
+
+    fn is_args(&self) -> bool {
+        match self.inst {
+            Inst::Args { .. } => true,
+            _ => false,
+        }
+    }
+
+    fn is_term(&self) -> MachTerminator {
+        match self.inst {
+            Inst::Ret { .. } | Inst::Rets { .. } => MachTerminator::Ret,
+            Inst::Jump { .. } => MachTerminator::Uncond,
+            Inst::BrIf { .. }
+            | Inst::BrIfXeq32 { .. }
+            | Inst::BrIfXneq32 { .. }
+            | Inst::BrIfXslt32 { .. }
+            | Inst::BrIfXslteq32 { .. }
+            | Inst::BrIfXult32 { .. }
+            | Inst::BrIfXulteq32 { .. } => MachTerminator::Cond,
+            _ => MachTerminator::None,
+        }
+    }
+
+    fn is_mem_access(&self) -> bool {
+        todo!()
+    }
+
+    fn gen_move(to_reg: Writable<Reg>, from_reg: Reg, ty: Type) -> Self {
+        match ty {
+            ir::types::I8 | ir::types::I16 | ir::types::I32 | ir::types::I64 => Inst::Xmov {
+                dst: WritableXReg::try_from(to_reg).unwrap(),
+                src: XReg::new(from_reg).unwrap(),
+            }
+            .into(),
+            ir::types::F32 | ir::types::F64 => Inst::Fmov {
+                dst: WritableFReg::try_from(to_reg).unwrap(),
+                src: FReg::new(from_reg).unwrap(),
+            }
+            .into(),
+            _ if ty.is_vector() => Inst::Vmov {
+                dst: WritableVReg::try_from(to_reg).unwrap(),
+                src: VReg::new(from_reg).unwrap(),
+            }
+            .into(),
+            _ => panic!("don't know how to generate a move for type {ty}"),
+        }
+    }
+
+    fn gen_nop(_preferred_size: usize) -> Self {
+        todo!()
+    }
+
+    fn rc_for_type(ty: Type) -> CodegenResult<(&'static [RegClass], &'static [Type])> {
+        match ty {
+            I8 => Ok((&[RegClass::Int], &[I8])),
+            I16 => Ok((&[RegClass::Int], &[I16])),
+            I32 => Ok((&[RegClass::Int], &[I32])),
+            I64 => Ok((&[RegClass::Int], &[I64])),
+            F32 => Ok((&[RegClass::Float], &[F32])),
+            F64 => Ok((&[RegClass::Float], &[F64])),
+            I128 => Ok((&[RegClass::Int, RegClass::Int], &[I64, I64])),
+            _ if ty.is_vector() => {
+                debug_assert!(ty.bits() <= 512);
+
+                // Here we only need to return a SIMD type with the same size as `ty`.
+                // We use these types for spills and reloads, so prefer types with lanes <= 31
+                // since that fits in the immediate field of `vsetivli`.
+                const SIMD_TYPES: [[Type; 1]; 6] = [
+                    [types::I8X2],
+                    [types::I8X4],
+                    [types::I8X8],
+                    [types::I8X16],
+                    [types::I16X16],
+                    [types::I32X16],
+                ];
+                let idx = (ty.bytes().ilog2() - 1) as usize;
+                let ty = &SIMD_TYPES[idx][..];
+
+                Ok((&[RegClass::Vector], ty))
+            }
+            _ => Err(CodegenError::Unsupported(format!(
+                "Unexpected SSA-value type: {ty}"
+            ))),
+        }
+    }
+
+    fn gen_jump(_target: MachLabel) -> Self {
+        todo!()
+    }
+
+    fn worst_case_size() -> CodeOffset {
+        // `BrIfXeq32 { a, b, taken, not_taken }` expands to `br_if_xeq32 a, b, taken; jump not_taken`.
+        //
+        // The first instruction is seven bytes long:
+        //   * 1 byte opcode
+        //   * 1 byte `a` register encoding
+        //   * 1 byte `b` register encoding
+        //   * 4 byte `taken` displacement
+        //
+        // And the second instruction is five bytes long:
+        //   * 1 byte opcode
+        //   * 4 byte `not_taken` displacement
+        12
+    }
+
+    fn ref_type_regclass(_settings: &settings::Flags) -> RegClass {
+        RegClass::Int
+    }
+
+    fn function_alignment() -> FunctionAlignment {
+        FunctionAlignment {
+            minimum: 1,
+            preferred: 1,
+        }
+    }
+}
+
+//=============================================================================
+// Pretty-printing of instructions.
+
+pub fn reg_name(reg: Reg) -> String {
+    match reg.to_real_reg() {
+        Some(real) => {
+            let n = real.hw_enc();
+            match (real.class(), n) {
+                (RegClass::Int, 63) => format!("sp"),
+                (RegClass::Int, 62) => format!("lr"),
+                (RegClass::Int, 61) => format!("fp"),
+                (RegClass::Int, 60) => format!("tmp0"),
+                (RegClass::Int, 59) => format!("tmp1"),
+
+                (RegClass::Int, _) => format!("x{n}"),
+                (RegClass::Float, _) => format!("f{n}"),
+                (RegClass::Vector, _) => format!("v{n}"),
+            }
+        }
+        None => {
+            format!("{reg:?}")
+        }
+    }
+}
+
+impl Inst {
+    fn print_with_state<P>(&self, _state: &mut EmitState<P>) -> String
+    where
+        P: PulleyTargetKind,
+    {
+        use core::fmt::Write;
+
+        let format_reg = |reg: Reg| -> String { reg_name(reg) };
+
+        let format_ext = |ext: ExtKind| -> &'static str {
+            match ext {
+                ExtKind::None => "",
+                ExtKind::Sign => "_s",
+                ExtKind::Zero => "_u",
+            }
+        };
+
+        match self {
+            Inst::Args { args } => {
+                let mut s = "args".to_string();
+                for arg in args {
+                    let preg = format_reg(arg.preg);
+                    let def = format_reg(arg.vreg.to_reg());
+                    write!(&mut s, " {def}={preg}").unwrap();
+                }
+                s
+            }
+            Inst::Rets { rets } => {
+                let mut s = "rets".to_string();
+                for ret in rets {
+                    let preg = format_reg(ret.preg);
+                    let vreg = format_reg(ret.vreg);
+                    write!(&mut s, " {vreg}={preg}").unwrap();
+                }
+                s
+            }
+
+            Inst::Unwind { inst } => format!("unwind {inst:?}"),
+
+            Inst::Trap { code } => format!("trap // code = {code:?}"),
+
+            Inst::Nop => format!("nop"),
+
+            Inst::Ret => format!("ret"),
+
+            Inst::GetSp { dst } => {
+                let dst = format_reg(*dst.to_reg());
+                format!("{dst} = get_sp")
+            }
+
+            Inst::LoadExtName { dst, name, offset } => {
+                let dst = format_reg(*dst.to_reg());
+                format!("{dst} = load_ext_name {name:?}, {offset}")
+            }
+
+            Inst::Call { callee, info } => {
+                format!("call {callee:?}, {info:?}")
+            }
+
+            Inst::IndirectCall { callee, info } => {
+                let callee = format_reg(**callee);
+                format!("indirect_call {callee}, {info:?}")
+            }
+
+            Inst::Jump { label } => format!("jump {}", label.to_string()),
+
+            Inst::BrIf {
+                c,
+                taken,
+                not_taken,
+            } => {
+                let c = format_reg(**c);
+                let taken = taken.to_string();
+                let not_taken = not_taken.to_string();
+                format!("br_if {c}, {taken}; jump {not_taken}")
+            }
+
+            Inst::BrIfXeq32 {
+                src1,
+                src2,
+                taken,
+                not_taken,
+            } => {
+                let src1 = format_reg(**src1);
+                let src2 = format_reg(**src2);
+                let taken = taken.to_string();
+                let not_taken = not_taken.to_string();
+                format!("br_if_xeq32 {src1}, {src2}, {taken}; jump {not_taken}")
+            }
+            Inst::BrIfXneq32 {
+                src1,
+                src2,
+                taken,
+                not_taken,
+            } => {
+                let src1 = format_reg(**src1);
+                let src2 = format_reg(**src2);
+                let taken = taken.to_string();
+                let not_taken = not_taken.to_string();
+                format!("br_if_xneq32 {src1}, {src2}, {taken}; jump {not_taken}")
+            }
+            Inst::BrIfXslt32 {
+                src1,
+                src2,
+                taken,
+                not_taken,
+            } => {
+                let src1 = format_reg(**src1);
+                let src2 = format_reg(**src2);
+                let taken = taken.to_string();
+                let not_taken = not_taken.to_string();
+                format!("br_if_xslt32 {src1}, {src2}, {taken}; jump {not_taken}")
+            }
+            Inst::BrIfXslteq32 {
+                src1,
+                src2,
+                taken,
+                not_taken,
+            } => {
+                let src1 = format_reg(**src1);
+                let src2 = format_reg(**src2);
+                let taken = taken.to_string();
+                let not_taken = not_taken.to_string();
+                format!("br_if_xslteq32 {src1}, {src2}, {taken}; jump {not_taken}")
+            }
+            Inst::BrIfXult32 {
+                src1,
+                src2,
+                taken,
+                not_taken,
+            } => {
+                let src1 = format_reg(**src1);
+                let src2 = format_reg(**src2);
+                let taken = taken.to_string();
+                let not_taken = not_taken.to_string();
+                format!("br_if_xult32 {src1}, {src2}, {taken}; jump {not_taken}")
+            }
+            Inst::BrIfXulteq32 {
+                src1,
+                src2,
+                taken,
+                not_taken,
+            } => {
+                let src1 = format_reg(**src1);
+                let src2 = format_reg(**src2);
+                let taken = taken.to_string();
+                let not_taken = not_taken.to_string();
+                format!("br_if_xulteq32 {src1}, {src2}, {taken}; jump {not_taken}")
+            }
+
+            Inst::Xmov { dst, src } => {
+                let dst = format_reg(*dst.to_reg());
+                let src = format_reg(**src);
+                format!("{dst} = xmov {src}")
+            }
+            Inst::Fmov { dst, src } => {
+                let dst = format_reg(*dst.to_reg());
+                let src = format_reg(**src);
+                format!("{dst} = fmov {src}")
+            }
+            Inst::Vmov { dst, src } => {
+                let dst = format_reg(*dst.to_reg());
+                let src = format_reg(**src);
+                format!("{dst} = vmov {src}")
+            }
+
+            Inst::Xconst8 { dst, imm } => {
+                let dst = format_reg(*dst.to_reg());
+                format!("{dst} = xconst8 {imm}")
+            }
+            Inst::Xconst16 { dst, imm } => {
+                let dst = format_reg(*dst.to_reg());
+                format!("{dst} = xconst16 {imm}")
+            }
+            Inst::Xconst32 { dst, imm } => {
+                let dst = format_reg(*dst.to_reg());
+                format!("{dst} = xconst32 {imm}")
+            }
+            Inst::Xconst64 { dst, imm } => {
+                let dst = format_reg(*dst.to_reg());
+                format!("{dst} = xconst64 {imm}")
+            }
+
+            Inst::Xadd32 { dst, src1, src2 } => format!(
+                "{} = xadd32 {}, {}",
+                format_reg(*dst.to_reg()),
+                format_reg(**src1),
+                format_reg(**src2)
+            ),
+            Inst::Xadd64 { dst, src1, src2 } => format!(
+                "{} = xadd64 {}, {}",
+                format_reg(*dst.to_reg()),
+                format_reg(**src1),
+                format_reg(**src2)
+            ),
+
+            Inst::Xeq64 { dst, src1, src2 } => format!(
+                "{} = xeq64 {}, {}",
+                format_reg(*dst.to_reg()),
+                format_reg(**src1),
+                format_reg(**src2)
+            ),
+            Inst::Xneq64 { dst, src1, src2 } => format!(
+                "{} = xneq64 {}, {}",
+                format_reg(*dst.to_reg()),
+                format_reg(**src1),
+                format_reg(**src2)
+            ),
+            Inst::Xslt64 { dst, src1, src2 } => format!(
+                "{} = xslt64 {}, {}",
+                format_reg(*dst.to_reg()),
+                format_reg(**src1),
+                format_reg(**src2)
+            ),
+            Inst::Xslteq64 { dst, src1, src2 } => format!(
+                "{} = xslteq64 {}, {}",
+                format_reg(*dst.to_reg()),
+                format_reg(**src1),
+                format_reg(**src2)
+            ),
+            Inst::Xult64 { dst, src1, src2 } => format!(
+                "{} = xult64 {}, {}",
+                format_reg(*dst.to_reg()),
+                format_reg(**src1),
+                format_reg(**src2)
+            ),
+            Inst::Xulteq64 { dst, src1, src2 } => format!(
+                "{} = xulteq64 {}, {}",
+                format_reg(*dst.to_reg()),
+                format_reg(**src1),
+                format_reg(**src2)
+            ),
+            Inst::Xeq32 { dst, src1, src2 } => format!(
+                "{} = xeq32 {}, {}",
+                format_reg(*dst.to_reg()),
+                format_reg(**src1),
+                format_reg(**src2)
+            ),
+            Inst::Xneq32 { dst, src1, src2 } => format!(
+                "{} = xneq32 {}, {}",
+                format_reg(*dst.to_reg()),
+                format_reg(**src1),
+                format_reg(**src2)
+            ),
+            Inst::Xslt32 { dst, src1, src2 } => format!(
+                "{} = xslt32 {}, {}",
+                format_reg(*dst.to_reg()),
+                format_reg(**src1),
+                format_reg(**src2)
+            ),
+            Inst::Xslteq32 { dst, src1, src2 } => format!(
+                "{} = xslteq32 {}, {}",
+                format_reg(*dst.to_reg()),
+                format_reg(**src1),
+                format_reg(**src2)
+            ),
+            Inst::Xult32 { dst, src1, src2 } => format!(
+                "{} = xult32 {}, {}",
+                format_reg(*dst.to_reg()),
+                format_reg(**src1),
+                format_reg(**src2)
+            ),
+            Inst::Xulteq32 { dst, src1, src2 } => format!(
+                "{} = xulteq32 {}, {}",
+                format_reg(*dst.to_reg()),
+                format_reg(**src1),
+                format_reg(**src2)
+            ),
+
+            Inst::LoadAddr { dst, mem } => {
+                let dst = format_reg(*dst.to_reg());
+                let mem = mem.to_string();
+                format!("{dst} = load_addr {mem}")
+            }
+
+            Inst::Load {
+                dst,
+                mem,
+                ty,
+                flags,
+                ext,
+            } => {
+                let dst = format_reg(dst.to_reg());
+                let ty = ty.bits();
+                let ext = format_ext(*ext);
+                let mem = mem.to_string();
+                format!("{dst} = load{ty}{ext} {mem} // flags ={flags}")
+            }
+
+            Inst::Store {
+                mem,
+                src,
+                ty,
+                flags,
+            } => {
+                let ty = ty.bits();
+                let mem = mem.to_string();
+                let src = format_reg(*src);
+                format!("store{ty} {mem}, {src} // flags = {flags}")
+            }
+
+            Inst::BitcastIntFromFloat32 { dst, src } => {
+                let dst = format_reg(*dst.to_reg());
+                let src = format_reg(**src);
+                format!("{dst} = bitcast_int_from_float32 {src}")
+            }
+            Inst::BitcastIntFromFloat64 { dst, src } => {
+                let dst = format_reg(*dst.to_reg());
+                let src = format_reg(**src);
+                format!("{dst} = bitcast_int_from_float64 {src}")
+            }
+            Inst::BitcastFloatFromInt32 { dst, src } => {
+                let dst = format_reg(*dst.to_reg());
+                let src = format_reg(**src);
+                format!("{dst} = bitcast_float_from_int32 {src}")
+            }
+            Inst::BitcastFloatFromInt64 { dst, src } => {
+                let dst = format_reg(*dst.to_reg());
+                let src = format_reg(**src);
+                format!("{dst} = bitcast_float_from_int64 {src}")
+            }
+        }
+    }
+}
+
+/// Different forms of label references for different instruction formats.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum LabelUse {
+    /// A PC-relative `jump`/`call`/etc... instruction with an `i32` relative
+    /// target. The payload value is an addend that describes the positive
+    /// offset from the start of the instruction to the offset being relocated.
+    Jump(u32),
+}
+
+impl MachInstLabelUse for LabelUse {
+    /// Alignment for veneer code. Pulley instructions don't require any
+    /// particular alignment.
+    const ALIGN: CodeOffset = 1;
+
+    /// Maximum PC-relative range (positive), inclusive.
+    fn max_pos_range(self) -> CodeOffset {
+        match self {
+            Self::Jump(_) => 0x7fff_ffff,
+        }
+    }
+
+    /// Maximum PC-relative range (negative).
+    fn max_neg_range(self) -> CodeOffset {
+        match self {
+            Self::Jump(_) => 0x8000_0000,
+        }
+    }
+
+    /// Size of window into code needed to do the patch.
+    fn patch_size(self) -> CodeOffset {
+        match self {
+            Self::Jump(_) => 4,
+        }
+    }
+
+    /// Perform the patch.
+    fn patch(self, buffer: &mut [u8], use_offset: CodeOffset, label_offset: CodeOffset) {
+        let use_relative = (label_offset as i64) - (use_offset as i64);
+        debug_assert!(use_relative <= self.max_pos_range() as i64);
+        debug_assert!(use_relative >= -(self.max_neg_range() as i64));
+        let pc_rel = i32::try_from(use_relative).unwrap() as u32;
+        match self {
+            Self::Jump(addend) => {
+                let value = pc_rel.wrapping_add(addend);
+                trace!(
+                    "patching label use @ {use_offset:#x} to label {label_offset:#x} via \
+                     PC-relative offset {pc_rel:#x}"
+                );
+                buffer.copy_from_slice(&value.to_le_bytes()[..]);
+            }
+        }
+    }
+
+    /// Is a veneer supported for this label reference type?
+    fn supports_veneer(self) -> bool {
+        match self {
+            Self::Jump(_) => false,
+        }
+    }
+
+    /// How large is the veneer, if supported?
+    fn veneer_size(self) -> CodeOffset {
+        match self {
+            Self::Jump(_) => 0,
+        }
+    }
+
+    fn worst_case_veneer_size() -> CodeOffset {
+        0
+    }
+
+    /// Generate a veneer into the buffer, given that this veneer is at `veneer_offset`, and return
+    /// an offset and label-use for the veneer's use of the original label.
+    fn generate_veneer(
+        self,
+        _buffer: &mut [u8],
+        _veneer_offset: CodeOffset,
+    ) -> (CodeOffset, LabelUse) {
+        match self {
+            Self::Jump(_) => panic!("veneer not supported for {self:?}"),
+        }
+    }
+
+    fn from_reloc(reloc: Reloc, addend: Addend) -> Option<LabelUse> {
+        match reloc {
+            Reloc::X86CallPCRel4 if addend < 0 => {
+                // We are always relocating some offset that is within an
+                // instruction, but pulley adds the offset relative to the PC
+                // pointing to the *start* of the instruction. Therefore, adjust
+                // back to the beginning of the instruction.
+                Some(LabelUse::Jump(i32::try_from(-addend).unwrap() as u32))
+            }
+            _ => None,
+        }
+    }
+}
diff --git a/cranelift/codegen/src/isa/pulley_shared/inst/regs.rs b/cranelift/codegen/src/isa/pulley_shared/inst/regs.rs
new file mode 100644
index 000000000000..16da50b582f0
--- /dev/null
+++ b/cranelift/codegen/src/isa/pulley_shared/inst/regs.rs
@@ -0,0 +1,164 @@
+//! Pulley registers.
+
+use crate::machinst::{Reg, Writable};
+use regalloc2::{PReg, RegClass, VReg};
+
+#[inline]
+pub fn x_reg(enc: usize) -> Reg {
+    let p = PReg::new(enc, RegClass::Int);
+    let v = VReg::new(p.index(), p.class());
+    Reg::from(v)
+}
+
+#[inline]
+pub const fn px_reg(enc: usize) -> PReg {
+    PReg::new(enc, RegClass::Int)
+}
+
+#[inline]
+pub fn f_reg(enc: usize) -> Reg {
+    let p = PReg::new(enc, RegClass::Float);
+    let v = VReg::new(p.index(), p.class());
+    Reg::from(v)
+}
+
+#[inline]
+pub const fn pf_reg(enc: usize) -> PReg {
+    PReg::new(enc, RegClass::Float)
+}
+
+#[inline]
+pub fn v_reg(enc: usize) -> Reg {
+    let p = PReg::new(enc, RegClass::Vector);
+    let v = VReg::new(p.index(), p.class());
+    Reg::from(v)
+}
+
+#[inline]
+pub const fn pv_reg(enc: usize) -> PReg {
+    PReg::new(enc, RegClass::Vector)
+}
+
+macro_rules! define_registers {
+    (
+        $(
+            $reg:expr => $readable:ident, $writable:ident;
+        )*
+    ) => {
+        $(
+            #[inline]
+            #[allow(dead_code)]
+            pub fn $readable() -> Reg {
+                $reg
+            }
+
+            #[inline]
+            #[allow(dead_code)]
+            pub fn $writable() -> Writable<Reg> {
+                Writable::from_reg($readable())
+            }
+        )*
+    };
+}
+
+define_registers! {
+    x_reg(0) => x0, writable_x0;
+    x_reg(1) => x1, writable_x1;
+    x_reg(2) => x2, writable_x2;
+    x_reg(3) => x3, writable_x3;
+    x_reg(4) => x4, writable_x4;
+    x_reg(5) => x5, writable_x5;
+    x_reg(6) => x6, writable_x6;
+    x_reg(7) => x7, writable_x7;
+    x_reg(8) => x8, writable_x8;
+    x_reg(9) => x9, writable_x9;
+    x_reg(10) => x10, writable_x10;
+    x_reg(11) => x11, writable_x11;
+    x_reg(12) => x12, writable_x12;
+    x_reg(13) => x13, writable_x13;
+    x_reg(14) => x14, writable_x14;
+    x_reg(15) => x15, writable_x15;
+    x_reg(16) => x16, writable_x16;
+    x_reg(17) => x17, writable_x17;
+    x_reg(18) => x18, writable_x18;
+    x_reg(19) => x19, writable_x19;
+    x_reg(20) => x20, writable_x20;
+    x_reg(21) => x21, writable_x21;
+    x_reg(22) => x22, writable_x22;
+    x_reg(23) => x23, writable_x23;
+    x_reg(24) => x24, writable_x24;
+    x_reg(25) => x25, writable_x25;
+    x_reg(26) => x26, writable_x26;
+
+    x_reg(27) => stack_reg, writable_stack_reg;
+    x_reg(28) => link_reg, writable_link_reg;
+    x_reg(29) => fp_reg, writable_fp_reg;
+    x_reg(30) => spilltmp_reg, writable_spilltmp_reg;
+    x_reg(31) => spilltmp2_reg, writable_spilltmp2_reg;
+
+    f_reg(0) => f0, writable_f0;
+    f_reg(1) => f1, writable_f1;
+    f_reg(2) => f2, writable_f2;
+    f_reg(3) => f3, writable_f3;
+    f_reg(4) => f4, writable_f4;
+    f_reg(5) => f5, writable_f5;
+    f_reg(6) => f6, writable_f6;
+    f_reg(7) => f7, writable_f7;
+    f_reg(8) => f8, writable_f8;
+    f_reg(9) => f9, writable_f9;
+    f_reg(10) => f10, writable_f10;
+    f_reg(11) => f11, writable_f11;
+    f_reg(12) => f12, writable_f12;
+    f_reg(13) => f13, writable_f13;
+    f_reg(14) => f14, writable_f14;
+    f_reg(15) => f15, writable_f15;
+    f_reg(16) => f16, writable_f16;
+    f_reg(17) => f17, writable_f17;
+    f_reg(18) => f18, writable_f18;
+    f_reg(19) => f19, writable_f19;
+    f_reg(20) => f20, writable_f20;
+    f_reg(21) => f21, writable_f21;
+    f_reg(22) => f22, writable_f22;
+    f_reg(23) => f23, writable_f23;
+    f_reg(24) => f24, writable_f24;
+    f_reg(25) => f25, writable_f25;
+    f_reg(26) => f26, writable_f26;
+    f_reg(27) => f27, writable_f27;
+    f_reg(28) => f28, writable_f28;
+    f_reg(29) => f29, writable_f29;
+    f_reg(30) => f30, writable_f30;
+    f_reg(31) => f31, writable_f31;
+
+    v_reg(0) => v0, writable_v0;
+    v_reg(1) => v1, writable_v1;
+    v_reg(2) => v2, writable_v2;
+    v_reg(3) => v3, writable_v3;
+    v_reg(4) => v4, writable_v4;
+    v_reg(5) => v5, writable_v5;
+    v_reg(6) => v6, writable_v6;
+    v_reg(7) => v7, writable_v7;
+    v_reg(8) => v8, writable_v8;
+    v_reg(9) => v9, writable_v9;
+    v_reg(10) => v10, writable_v10;
+    v_reg(11) => v11, writable_v11;
+    v_reg(12) => v12, writable_v12;
+    v_reg(13) => v13, writable_v13;
+    v_reg(14) => v14, writable_v14;
+    v_reg(15) => v15, writable_v15;
+    v_reg(16) => v16, writable_v16;
+    v_reg(17) => v17, writable_v17;
+    v_reg(18) => v18, writable_v18;
+    v_reg(19) => v19, writable_v19;
+    v_reg(20) => v20, writable_v20;
+    v_reg(21) => v21, writable_v21;
+    v_reg(22) => v22, writable_v22;
+    v_reg(23) => v23, writable_v23;
+    v_reg(24) => v24, writable_v24;
+    v_reg(25) => v25, writable_v25;
+    v_reg(26) => v26, writable_v26;
+    v_reg(27) => v27, writable_v27;
+    v_reg(28) => v28, writable_v28;
+    v_reg(29) => v29, writable_v29;
+    v_reg(30) => v30, writable_v30;
+    v_reg(31) => v31, writable_v31;
+}
diff --git a/cranelift/codegen/src/isa/pulley_shared/lower.isle b/cranelift/codegen/src/isa/pulley_shared/lower.isle
new file mode 100644
index 000000000000..dcd7ba44800c
--- /dev/null
+++ b/cranelift/codegen/src/isa/pulley_shared/lower.isle
@@ -0,0 +1,178 @@
+;; Pulley instruction selection and CLIF-to-MachInst lowering.
+
+;; The main lowering constructor term: takes a clif `Inst` and returns the
+;; register(s) within which the lowered instruction's result values live.
+(decl partial lower (Inst) InstOutput)
+
+;;;; Rules for Control Flow ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; The main control-flow-lowering term: takes a control-flow instruction and
+;; target(s) and emits the necessary instructions.
+(decl partial lower_branch (Inst MachLabelSlice) Unit)
+
+;; Unconditional jumps.
+(rule (lower_branch (jump _) (single_target label))
+      (emit_side_effect (pulley_jump label)))
+
+;; Generic case for conditional branches.
+(rule -1 (lower_branch (brif (maybe_uextend c) _ _) (two_targets then else))
+      (emit_side_effect (pulley_br_if c then else)))
+
+;; Conditional branches on `icmp`s.
+(rule (lower_branch (brif (maybe_uextend (icmp _ cc a b @ (value_type $I32))) _ _)
+                    (two_targets then else))
+      (emit_side_effect (lower_brif_of_icmp32 cc a b then else)))
+
+(decl lower_brif_of_icmp32 (IntCC Value Value MachLabel MachLabel) SideEffectNoResult)
+(rule (lower_brif_of_icmp32 (IntCC.Equal) a b then else)
+      (pulley_br_if_xeq32 a b then else))
+(rule (lower_brif_of_icmp32 (IntCC.NotEqual) a b then else)
+      (pulley_br_if_xneq32 a b then else))
+(rule (lower_brif_of_icmp32 (IntCC.SignedLessThan) a b then else)
+      (pulley_br_if_xslt32 a b then else))
+(rule (lower_brif_of_icmp32 (IntCC.SignedLessThanOrEqual) a b then else)
+      (pulley_br_if_xslteq32 a b then else))
+(rule (lower_brif_of_icmp32 (IntCC.UnsignedLessThan) a b then else)
+      (pulley_br_if_xult32 a b then else))
+(rule (lower_brif_of_icmp32 (IntCC.UnsignedLessThanOrEqual) a b then else)
+      (pulley_br_if_xulteq32 a b then else))
+
+;; Pulley doesn't have instructions for `>` and `>=`, so we have to reverse the
+;; operation.
+(rule (lower_brif_of_icmp32 (IntCC.SignedGreaterThan) a b then else)
+      (lower_brif_of_icmp32 (IntCC.SignedLessThan) b a then else))
+(rule (lower_brif_of_icmp32 (IntCC.SignedGreaterThanOrEqual) a b then else)
+      (lower_brif_of_icmp32 (IntCC.SignedLessThanOrEqual) b a then else))
+(rule (lower_brif_of_icmp32 (IntCC.UnsignedGreaterThan) a b then else)
+      (lower_brif_of_icmp32 (IntCC.UnsignedLessThan) b a then else))
+(rule (lower_brif_of_icmp32 (IntCC.UnsignedGreaterThanOrEqual) a b then else)
+      (lower_brif_of_icmp32 (IntCC.UnsignedLessThanOrEqual) b a then else))
+
+;; Branch tables.
+(decl lower_br_table (Reg MachLabelSlice) Unit)
+(extern constructor lower_br_table lower_br_table)
+(rule (lower_branch (br_table index _) targets)
+      (lower_br_table index targets))
+
+;;;; Rules for `trap` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(rule (lower (trap code))
+      (side_effect (pulley_trap code)))
+
+;;;; Rules for `get_stack_pointer` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(rule (lower (get_stack_pointer _))
+      (pulley_get_sp))
+
+;;;; Rules for `return` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; N.B.: the `ret` itself is generated by the ABI.
+(rule (lower (return args))
+      (lower_return args))
+
+;;;; Rules for calls ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(rule (lower (call (func_ref_data sig_ref extname dist) inputs))
+      (gen_call sig_ref extname dist inputs))
+
+(rule (lower (call_indirect sig_ref val inputs))
+      (gen_call_indirect sig_ref val inputs))
+
+;;;; Rules for `return_call` and `return_call_indirect` ;;;;;;;;;;;;;;;;;;;;;;;;
+
+(rule (lower (return_call (func_ref_data sig_ref extname dist) args))
+      (gen_return_call sig_ref extname dist args))
+
+(rule (lower (return_call_indirect sig_ref callee args))
+      (gen_return_call_indirect sig_ref callee args))
+
+;;;; Rules for `iconst` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(rule (lower (has_type ty (iconst _ (u64_from_imm64 n))))
+      (imm ty n))
+
+;;;; Rules for `iadd` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(rule (lower (has_type $I8 (iadd _ a b)))
+      (pulley_xadd32 a b))
+
+(rule (lower (has_type $I16 (iadd _ a b)))
+      (pulley_xadd32 a b))
+
+(rule (lower (has_type $I32 (iadd _ a b)))
+      (pulley_xadd32 a b))
+
+(rule (lower (has_type $I64 (iadd _ a b)))
+      (pulley_xadd64 a b))
+
+;;;; Rules for `icmp` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(rule 1 (lower (icmp _ cc a b @ (value_type $I64)))
+      (lower_icmp $I64 cc a b))
+(rule (lower (icmp _ cc a b @ (value_type (fits_in_32 _))))
+      (lower_icmp $I32 cc a b))
+
+(decl lower_icmp (Type IntCC Value Value) XReg)
+
+(rule (lower_icmp $I64 (IntCC.Equal) a b)
+      (pulley_xeq64 a b))
+
+(rule (lower_icmp $I64 (IntCC.NotEqual) a b)
+      (pulley_xneq64 a b))
+
+(rule (lower_icmp $I64 (IntCC.SignedLessThan) a b)
+      (pulley_xslt64 a b))
+
+(rule (lower_icmp $I64 (IntCC.SignedLessThanOrEqual) a b)
+      (pulley_xslteq64 a b))
+
+(rule (lower_icmp $I64 (IntCC.UnsignedLessThan) a b)
+      (pulley_xult64 a b))
+
+(rule (lower_icmp $I64 (IntCC.UnsignedLessThanOrEqual) a b)
+      (pulley_xulteq64 a b))
+
+(rule (lower_icmp $I32 (IntCC.Equal) a b)
+      (pulley_xeq32 a b))
+
+(rule (lower_icmp $I32 (IntCC.NotEqual) a b)
+      (pulley_xneq32 a b))
+
+(rule (lower_icmp $I32 (IntCC.SignedLessThan) a b)
+      (pulley_xslt32 a b))
+
+(rule (lower_icmp $I32 (IntCC.SignedLessThanOrEqual) a b)
+      (pulley_xslteq32 a b))
+
+(rule (lower_icmp $I32 (IntCC.UnsignedLessThan) a b)
+      (pulley_xult32 a b))
+
+(rule (lower_icmp $I32 (IntCC.UnsignedLessThanOrEqual) a b)
+      (pulley_xulteq32 a b))
+
+;; Pulley doesn't have instructions for `>` and `>=`, so we have to reverse the
+;; operation.
+(rule (lower_icmp ty (IntCC.SignedGreaterThan) a b)
+      (lower_icmp ty (IntCC.SignedLessThan) b a))
+(rule (lower_icmp ty (IntCC.SignedGreaterThanOrEqual) a b)
+      (lower_icmp ty (IntCC.SignedLessThanOrEqual) b a))
+(rule (lower_icmp ty (IntCC.UnsignedGreaterThan) a b)
+      (lower_icmp ty (IntCC.UnsignedLessThan) b a))
+(rule (lower_icmp ty (IntCC.UnsignedGreaterThanOrEqual) a b)
+      (lower_icmp ty (IntCC.UnsignedLessThanOrEqual) b a))
+
+;;;; Rules for `load` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(rule (lower (has_type ty (load _ flags addr (offset32 offset))))
+      (pulley_load (Amode.RegOffset addr (i32_as_i64 offset))
+                   ty
+                   flags
+                   (ExtKind.Zero)))
+
+;;;; Rules for `store` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(rule (lower (store flags src @ (value_type ty) addr (offset32 offset)))
+      (side_effect (pulley_store (Amode.RegOffset addr (i32_as_i64 offset))
+                                 src
+                                 ty
+                                 flags)))
diff --git a/cranelift/codegen/src/isa/pulley_shared/lower.rs b/cranelift/codegen/src/isa/pulley_shared/lower.rs
new file mode 100644
index 000000000000..9f8754d513d3
--- /dev/null
+++ b/cranelift/codegen/src/isa/pulley_shared/lower.rs
@@ -0,0 +1,36 @@
+//! Lowering backend for Pulley.
+
+pub mod isle;
+
+use super::{inst::*, PulleyBackend, PulleyTargetKind};
+use crate::{
+    ir,
+    machinst::{lower::*, *},
+};
+
+impl<P> LowerBackend for PulleyBackend<P>
+where
+    P: PulleyTargetKind,
+{
+    type MInst = InstAndKind<P>;
+
+    fn lower(&self, ctx: &mut Lower<Self::MInst>, ir_inst: ir::Inst) -> Option<InstOutput> {
+        isle::lower(ctx, self, ir_inst)
+    }
+
+    fn lower_branch(
+        &self,
+        ctx: &mut Lower<Self::MInst>,
+        ir_inst: ir::Inst,
+        targets: &[MachLabel],
+    ) -> Option<()> {
+        isle::lower_branch(ctx, self, ir_inst, targets)
+    }
+
+    fn maybe_pinned_reg(&self) -> Option<Reg> {
+        // Pulley does not support this feature right now.
+        None
+    }
+
+    type FactFlowState = ();
+}
diff --git a/cranelift/codegen/src/isa/pulley_shared/lower/isle.rs b/cranelift/codegen/src/isa/pulley_shared/lower/isle.rs
new file mode 100644
index 000000000000..51e17d29ce67
--- /dev/null
+++ b/cranelift/codegen/src/isa/pulley_shared/lower/isle.rs
@@ -0,0 +1,194 @@
+//! ISLE integration glue code for Pulley lowering.
+
+// Pull in the ISLE generated code.
+pub mod generated_code;
+use generated_code::MInst;
+use inst::InstAndKind;
+
+// Types that the generated ISLE code uses via `use super::*`.
+use crate::ir::{condcodes::*, immediates::*, types::*, *};
+use crate::isa::pulley_shared::{
+    abi::*,
+    inst::{CallInfo, FReg, VReg, WritableFReg, WritableVReg, WritableXReg, XReg},
+    *,
+};
+use crate::machinst::{
+    abi::{ArgPair, RetPair, StackAMode},
+    isle::*,
+    IsTailCall, MachInst, Reg, VCodeConstant, VCodeConstantData,
+};
+use alloc::boxed::Box;
+use regalloc2::PReg;
+type Unit = ();
+type VecArgPair = Vec<ArgPair>;
+type VecRetPair = Vec<RetPair>;
+type BoxCallInfo = Box<CallInfo>;
+type BoxExternalName = Box<ExternalName>;
+
+pub(crate) struct PulleyIsleContext<'a, 'b, I, B>
+where
+    I: VCodeInst,
+    B: LowerBackend,
+{
+    pub lower_ctx: &'a mut Lower<'b, I>,
+    pub backend: &'a B,
+}
+
+impl<'a, 'b, P> PulleyIsleContext<'a, 'b, InstAndKind<P>, PulleyBackend<P>>
+where
+    P: PulleyTargetKind,
+{
+    fn new(lower_ctx: &'a mut Lower<'b, InstAndKind<P>>, backend: &'a PulleyBackend<P>) -> Self {
+        Self { lower_ctx, backend }
+    }
+}
+
+impl<P> generated_code::Context for PulleyIsleContext<'_, '_, InstAndKind<P>, PulleyBackend<P>>
+where
+    P: PulleyTargetKind,
+{
+    crate::isle_lower_prelude_methods!(InstAndKind<P>);
+    crate::isle_prelude_caller_methods!(PulleyMachineDeps<P>, PulleyABICallSite<P>);
+
+    fn gen_return_call(
+        &mut self,
+        callee_sig: SigRef,
+        callee: ExternalName,
+        distance: RelocDistance,
+        args: ValueSlice,
+    ) -> InstOutput {
+        let caller_conv = isa::CallConv::Tail;
+        debug_assert_eq!(
+            self.lower_ctx.abi().call_conv(self.lower_ctx.sigs()),
+            caller_conv,
+            "Can only do `return_call`s from within a `tail` calling convention function"
+        );
+
+        let call_site = PulleyABICallSite::from_func(
+            self.lower_ctx.sigs(),
+            callee_sig,
+            &callee,
+            IsTailCall::Yes,
+            distance,
+            caller_conv,
+            self.backend.flags().clone(),
+        );
+        call_site.emit_return_call(self.lower_ctx, args);
+
+        InstOutput::new()
+    }
+
+    fn gen_return_call_indirect(
+        &mut self,
+        callee_sig: SigRef,
+        callee: Value,
+        args: ValueSlice,
+    ) -> InstOutput {
+        let caller_conv = isa::CallConv::Tail;
+        debug_assert_eq!(
+            self.lower_ctx.abi().call_conv(self.lower_ctx.sigs()),
+            caller_conv,
+            "Can only do `return_call`s from within a `tail` calling convention function"
+        );
+
+        let callee = self.put_in_reg(callee);
+
+        let call_site = PulleyABICallSite::from_ptr(
+            self.lower_ctx.sigs(),
+            callee_sig,
+            callee,
+            IsTailCall::Yes,
+            caller_conv,
+            self.backend.flags().clone(),
+        );
+        call_site.emit_return_call(self.lower_ctx, args);
+
+        InstOutput::new()
+    }
+
+    fn lower_br_table(&mut self, _index: Reg, _targets: &[MachLabel]) -> Unit {
+        todo!()
+    }
+
+    fn vreg_new(&mut self, r: Reg) -> VReg {
+        VReg::new(r).unwrap()
+    }
+    fn writable_vreg_new(&mut self, r: WritableReg) -> WritableVReg {
+        r.map(|wr| VReg::new(wr).unwrap())
+    }
+    fn writable_vreg_to_vreg(&mut self, arg0: WritableVReg) -> VReg {
+        arg0.to_reg()
+    }
+    fn writable_vreg_to_writable_reg(&mut self, arg0: WritableVReg) -> WritableReg {
+        arg0.map(|vr| vr.to_reg())
+    }
+    fn vreg_to_reg(&mut self, arg0: VReg) -> Reg {
+        *arg0
+    }
+    fn xreg_new(&mut self, r: Reg) -> XReg {
+        XReg::new(r).unwrap()
+    }
+    fn writable_xreg_new(&mut self, r: WritableReg) -> WritableXReg {
+        r.map(|wr| XReg::new(wr).unwrap())
+    }
+    fn writable_xreg_to_xreg(&mut self, arg0: WritableXReg) -> XReg {
+        arg0.to_reg()
+    }
+    fn writable_xreg_to_writable_reg(&mut self, arg0: WritableXReg) -> WritableReg {
+        arg0.map(|xr| xr.to_reg())
+    }
+    fn xreg_to_reg(&mut self, arg0: XReg) -> Reg {
+        *arg0
+    }
+    fn freg_new(&mut self, r: Reg) -> FReg {
+        FReg::new(r).unwrap()
+    }
+    fn writable_freg_new(&mut self, r: WritableReg) -> WritableFReg {
+        r.map(|wr| FReg::new(wr).unwrap())
+    }
+    fn writable_freg_to_freg(&mut self, arg0: WritableFReg) -> FReg {
+        arg0.to_reg()
+    }
+    fn writable_freg_to_writable_reg(&mut self, arg0: WritableFReg) -> WritableReg {
+        arg0.map(|fr| fr.to_reg())
+    }
+    fn freg_to_reg(&mut self, arg0: FReg) -> Reg {
+        *arg0
+    }
+
+    #[inline]
+    fn emit(&mut self, arg0: &MInst) -> Unit {
+        self.lower_ctx.emit(arg0.clone().into());
+    }
+}
+
+/// The main entry point for lowering with ISLE.
+pub(crate) fn lower<P>(
+    lower_ctx: &mut Lower<InstAndKind<P>>,
+    backend: &PulleyBackend<P>,
+    inst: Inst,
+) -> Option<InstOutput>
+where
+    P: PulleyTargetKind,
+{
+    // TODO: reuse the ISLE context across lowerings so we can reuse its
+    // internal heap allocations.
+    let mut isle_ctx = PulleyIsleContext::new(lower_ctx, backend);
+    generated_code::constructor_lower(&mut isle_ctx, inst)
+}
+
+/// The main entry point for branch lowering with ISLE.
+pub(crate) fn lower_branch<P>(
+    lower_ctx: &mut Lower<InstAndKind<P>>,
+    backend: &PulleyBackend<P>,
+    branch: Inst,
+    targets: &[MachLabel],
+) -> Option<()>
+where
+    P: PulleyTargetKind,
+{
+    // TODO: reuse the ISLE context across lowerings so we can reuse its
+    // internal heap allocations.
+    let mut isle_ctx = PulleyIsleContext::new(lower_ctx, backend);
+    generated_code::constructor_lower_branch(&mut isle_ctx, branch, targets)
+}
diff --git a/cranelift/codegen/src/isa/pulley_shared/lower/isle/generated_code.rs b/cranelift/codegen/src/isa/pulley_shared/lower/isle/generated_code.rs
new file mode 100644
index 000000000000..5467fc5ea636
--- /dev/null
+++ b/cranelift/codegen/src/isa/pulley_shared/lower/isle/generated_code.rs
@@ -0,0 +1,17 @@
+// See https://github.com/rust-lang/rust/issues/47995: we cannot use `#![...]` attributes inside of
+// the generated ISLE source below because we include!() it. We must include!() it because its path
+// depends on an environment variable; and also because of this, we can't do the `#[path = "..."]
+// mod generated_code;` trick either.
+#![allow(
+    dead_code,
+    unreachable_code,
+    unreachable_patterns,
+    unused_imports,
+    unused_variables,
+    non_snake_case,
+    unused_mut,
+    irrefutable_let_patterns,
+    clippy::all
+)]
+
+include!(concat!(env!("ISLE_DIR"), "/isle_pulley_shared.rs"));
diff --git a/cranelift/codegen/src/isa/pulley_shared/mod.rs b/cranelift/codegen/src/isa/pulley_shared/mod.rs
new file mode 100644
index 000000000000..84824de2f785
--- /dev/null
+++ b/cranelift/codegen/src/isa/pulley_shared/mod.rs
@@ -0,0 +1,281 @@
+//! Common support compiling to either 32- or 64-bit Pulley bytecode.
+
+mod abi;
+mod inst;
+mod lower;
+mod settings;
+
+use self::inst::EmitInfo;
+use super::{Builder as IsaBuilder, FunctionAlignment};
+use crate::{
+    dominator_tree::DominatorTree,
+    ir,
+    isa::{self, OwnedTargetIsa, TargetIsa},
+    machinst::{self, CompiledCodeStencil, MachInst, SigSet, VCode},
+    result::CodegenResult,
+    settings::{self as shared_settings, Flags},
+    MachTextSectionBuilder, TextSectionBuilder,
+};
+use alloc::boxed::Box;
+use alloc::vec::Vec;
+use core::fmt::Debug;
+use core::marker::PhantomData;
+use cranelift_control::ControlPlane;
+use target_lexicon::{Architecture, Triple};
+
+pub use settings::Flags as PulleyFlags;
+
+/// A trait to abstract over the different kinds of Pulley targets that exist
+/// (32- vs 64-bit).
+pub trait PulleyTargetKind: 'static + Clone + Debug + Default + Send + Sync {
+    // Required types and methods.
+
+    fn pointer_width() -> PointerWidth;
+
+    // Provided methods. Don't overwrite.
+
+    fn name() -> &'static str {
+        match Self::pointer_width() {
+            PointerWidth::PointerWidth32 => "pulley32",
+            PointerWidth::PointerWidth64 => "pulley64",
+        }
+    }
+}
+
+pub enum PointerWidth {
+    PointerWidth32,
+    PointerWidth64,
+}
+
+impl PointerWidth {
+    pub fn bits(self) -> u8 {
+        match self {
+            PointerWidth::PointerWidth32 => 32,
+            PointerWidth::PointerWidth64 => 64,
+        }
+    }
+}
+
+/// A Pulley backend.
+pub struct PulleyBackend<P>
+where
+    P: PulleyTargetKind,
+{
+    pulley_target: PhantomData<P>,
+    triple: Triple,
+    flags: Flags,
+    isa_flags: PulleyFlags,
+}
+
+impl<P> core::fmt::Debug for PulleyBackend<P>
+where
+    P: PulleyTargetKind,
+{
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        let PulleyBackend {
+            pulley_target: _,
+            triple,
+            flags: _,
+            isa_flags: _,
+        } = self;
+        f.debug_struct("PulleyBackend")
+            .field("triple", triple)
+            .finish_non_exhaustive()
+    }
+}
+
+impl<P> core::fmt::Display for PulleyBackend<P>
+where
+    P: PulleyTargetKind,
+{
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        core::fmt::Debug::fmt(self, f)
+    }
+}
+
+impl<P> PulleyBackend<P>
+where
+    P: PulleyTargetKind,
+{
+    /// Create a new pulley backend with the given (shared) flags.
+    pub fn new_with_flags(
+        triple: Triple,
+        flags: shared_settings::Flags,
+        isa_flags: PulleyFlags,
+    ) -> Self {
+        PulleyBackend {
+            pulley_target: PhantomData,
+            triple,
+            flags,
+            isa_flags,
+        }
+    }
+
+    /// This performs lowering to VCode, register-allocates the code, computes block layout and
+    /// finalizes branches. The result is ready for binary emission.
+    fn compile_vcode(
+        &self,
+        func: &ir::Function,
+        domtree: &DominatorTree,
+        ctrl_plane: &mut ControlPlane,
+    ) -> CodegenResult<(VCode<inst::InstAndKind<P>>, regalloc2::Output)> {
+        let emit_info = EmitInfo::new(self.flags.clone(), self.isa_flags.clone());
+        let sigs = SigSet::new::<abi::PulleyMachineDeps<P>>(func, &self.flags)?;
+        let abi = abi::PulleyCallee::new(func, self, &self.isa_flags, &sigs)?;
+        machinst::compile::<Self>(func, domtree, self, abi, emit_info, sigs, ctrl_plane)
+    }
+}
+
+impl<P> TargetIsa for PulleyBackend<P>
+where
+    P: PulleyTargetKind,
+{
+    fn name(&self) -> &'static str {
+        P::name()
+    }
+
+    fn triple(&self) -> &Triple {
+        &self.triple
+    }
+
+    fn flags(&self) -> &Flags {
+        &self.flags
+    }
+
+    fn isa_flags(&self) -> Vec<shared_settings::Value> {
+        self.isa_flags.iter().collect()
+    }
+
+    fn dynamic_vector_bytes(&self, _dynamic_ty: ir::Type) -> u32 {
+        512
+    }
+
+    fn page_size_align_log2(&self) -> u8 {
+        // Claim 64KiB pages to be conservative.
+        16
+    }
+
+    fn compile_function(
+        &self,
+        func: &ir::Function,
+        domtree: &DominatorTree,
+        want_disasm: bool,
+        ctrl_plane: &mut cranelift_control::ControlPlane,
+    ) -> CodegenResult<CompiledCodeStencil> {
+        let (vcode, regalloc_result) = self.compile_vcode(func, domtree, ctrl_plane)?;
+
+        let want_disasm =
+            want_disasm || (cfg!(feature = "trace-log") && log::log_enabled!(log::Level::Debug));
+        let emit_result = vcode.emit(&regalloc_result, want_disasm, &self.flags, ctrl_plane);
+        let frame_size = emit_result.frame_size;
+        let value_labels_ranges = emit_result.value_labels_ranges;
+        let buffer = emit_result.buffer;
+        let sized_stackslot_offsets = emit_result.sized_stackslot_offsets;
+        let dynamic_stackslot_offsets = emit_result.dynamic_stackslot_offsets;
+
+        if let Some(disasm) = emit_result.disasm.as_ref() {
+            log::debug!("disassembly:\n{}", disasm);
+        }
+
+        Ok(CompiledCodeStencil {
+            buffer,
+            frame_size,
+            vcode: emit_result.disasm,
+            value_labels_ranges,
+            sized_stackslot_offsets,
+            dynamic_stackslot_offsets,
+            bb_starts: emit_result.bb_offsets,
+            bb_edges: emit_result.bb_edges,
+        })
+    }
+
+    fn emit_unwind_info(
+        &self,
+        _result: &crate::CompiledCode,
+        _kind: super::unwind::UnwindInfoKind,
+    ) -> CodegenResult<Option<isa::unwind::UnwindInfo>> {
+        // TODO: actually support unwind info?
+        Ok(None)
+    }
+
+    fn text_section_builder(
+        &self,
+        num_labeled_funcs: usize,
+    ) -> alloc::boxed::Box<dyn TextSectionBuilder> {
+        Box::new(MachTextSectionBuilder::<inst::InstAndKind<P>>::new(
+            num_labeled_funcs,
+        ))
+    }
+
+    fn function_alignment(&self) -> FunctionAlignment {
+        inst::InstAndKind::<P>::function_alignment()
+    }
+
+    fn has_native_fma(&self) -> bool {
+        false
+    }
+
+    fn has_x86_blendv_lowering(&self, _ty: ir::Type) -> bool {
+        false
+    }
+
+    fn has_x86_pshufb_lowering(&self) -> bool {
+        false
+    }
+
+    fn has_x86_pmulhrsw_lowering(&self) -> bool {
+        false
+    }
+
+    fn has_x86_pmaddubsw_lowering(&self) -> bool {
+        false
+    }
+}
+
+/// Create a new Pulley ISA builder.
+pub fn isa_builder(triple: Triple) -> IsaBuilder {
+    assert!(matches!(
+        triple.architecture,
+        Architecture::Pulley32 | Architecture::Pulley64
+    ));
+    let constructor = match triple.architecture {
+        Architecture::Pulley32 => isa_constructor_32,
+        Architecture::Pulley64 => isa_constructor_64,
+        _ => unreachable!(),
+    };
+    IsaBuilder {
+        triple,
+        setup: self::settings::builder(),
+        constructor,
+    }
+}
+
+fn isa_constructor_32(
+    triple: Triple,
+    shared_flags: Flags,
+    builder: &shared_settings::Builder,
+) -> CodegenResult<OwnedTargetIsa> {
+    use crate::settings::Configurable;
+    let mut builder = builder.clone();
+    builder.set("pointer_width", "pointer32").unwrap();
+    let isa_flags = PulleyFlags::new(&shared_flags, &builder);
+
+    let backend =
+        PulleyBackend::<super::pulley32::Pulley32>::new_with_flags(triple, shared_flags, isa_flags);
+    Ok(backend.wrapped())
+}
+
+fn isa_constructor_64(
+    triple: Triple,
+    shared_flags: Flags,
+    builder: &shared_settings::Builder,
+) -> CodegenResult<OwnedTargetIsa> {
+    use crate::settings::Configurable;
+    let mut builder = builder.clone();
+    builder.set("pointer_width", "pointer64").unwrap();
+    let isa_flags = PulleyFlags::new(&shared_flags, &builder);
+
+    let backend =
+        PulleyBackend::<super::pulley64::Pulley64>::new_with_flags(triple, shared_flags, isa_flags);
+    Ok(backend.wrapped())
+}
diff --git a/cranelift/codegen/src/isa/pulley_shared/settings.rs b/cranelift/codegen/src/isa/pulley_shared/settings.rs
new file mode 100644
index 000000000000..937384db1468
--- /dev/null
+++ b/cranelift/codegen/src/isa/pulley_shared/settings.rs
@@ -0,0 +1,16 @@
+//! Pulley settings.
+
+// The generated settings include some dead code.
+#![allow(dead_code)]
+
+use crate::{
+    machinst::IsaFlags,
+    settings::{self, detail, Builder, Value},
+};
+use core::fmt;
+
+// Include code generated by `cranelift-codegen/meta/src/gen_settings.rs:`. This file contains a
+// public `Flags` struct with an impl for all of the settings defined in
+include!(concat!(env!("OUT_DIR"), "/settings-pulley.rs"));
+
+impl IsaFlags for Flags {}
diff --git a/cranelift/codegen/src/isa/riscv64/abi.rs b/cranelift/codegen/src/isa/riscv64/abi.rs
index 9abc85451d0e..2a6b23f3af38 100644
--- a/cranelift/codegen/src/isa/riscv64/abi.rs
+++ b/cranelift/codegen/src/isa/riscv64/abi.rs
@@ -3,15 +3,12 @@
 use crate::ir;
 use crate::ir::types::*;
 
-use crate::ir::ExternalName;
-use crate::ir::MemFlags;
 use crate::isa;
 
-use crate::isa::riscv64::{inst::EmitState, inst::*};
+use crate::isa::riscv64::inst::*;
 use crate::isa::CallConv;
 use crate::machinst::*;
 
-use crate::ir::types::I8;
 use crate::ir::LibCall;
 use crate::ir::Signature;
 use crate::isa::riscv64::settings::Flags as RiscvFlags;
@@ -22,7 +19,6 @@ use crate::CodegenResult;
 use alloc::boxed::Box;
 use alloc::vec::Vec;
 use regalloc2::{MachineEnv, PReg, PRegSet};
-use regs::x_reg;
 
 use smallvec::{smallvec, SmallVec};
 use std::sync::OnceLock;
@@ -91,23 +87,25 @@ impl ABIMachineSpec for Riscv64MachineDeps {
         16
     }
 
-    fn compute_arg_locs<'a, I>(
+    fn compute_arg_locs(
         call_conv: isa::CallConv,
         _flags: &settings::Flags,
-        params: I,
+        params: &[ir::AbiParam],
         args_or_rets: ArgsOrRets,
         add_ret_area_ptr: bool,
-        mut args: ArgsAccumulator<'_>,
-    ) -> CodegenResult<(u32, Option<usize>)>
-    where
-        I: IntoIterator<Item = &'a ir::AbiParam>,
-    {
+        mut args: ArgsAccumulator,
+    ) -> CodegenResult<(u32, Option<usize>)> {
+        assert_ne!(
+            call_conv,
+            isa::CallConv::Winch,
+            "riscv64 does not support the 'winch' calling convention yet"
+        );
+
         // All registers that can be used as parameters or rets.
         // both start and end are included.
-        let (x_start, x_end, f_start, f_end) = match (call_conv, args_or_rets) {
-            (isa::CallConv::Tail, _) => (9, 29, 0, 31),
-            (_, ArgsOrRets::Args) => (10, 17, 10, 17),
-            (_, ArgsOrRets::Rets) => (10, 11, 10, 11),
+        let (x_start, x_end, f_start, f_end) = match args_or_rets {
+            ArgsOrRets::Args => (10, 17, 10, 17),
+            ArgsOrRets::Rets => (10, 11, 10, 11),
         };
         let mut next_x_reg = x_start;
         let mut next_f_reg = f_start;
@@ -206,11 +204,6 @@ impl ABIMachineSpec for Riscv64MachineDeps {
         Ok((next_stack, pos))
     }
 
-    fn fp_to_arg_offset(_call_conv: isa::CallConv, _flags: &settings::Flags) -> i64 {
-        // lr fp.
-        16
-    }
-
     fn gen_load_stack(mem: StackAMode, into_reg: Writable<Reg>, ty: Type) -> Inst {
         Inst::gen_load(into_reg, mem.into(), ty, MemFlags::trusted())
     }
@@ -299,7 +292,7 @@ impl ABIMachineSpec for Riscv64MachineDeps {
         insts
     }
 
-    fn gen_get_stack_addr(mem: StackAMode, into_reg: Writable<Reg>, _ty: Type) -> Inst {
+    fn gen_get_stack_addr(mem: StackAMode, into_reg: Writable<Reg>) -> Inst {
         Inst::LoadAddr {
             rd: into_reg,
             mem: mem.into(),
@@ -307,30 +300,41 @@ impl ABIMachineSpec for Riscv64MachineDeps {
     }
 
     fn gen_load_base_offset(into_reg: Writable<Reg>, base: Reg, offset: i32, ty: Type) -> Inst {
-        let mem = AMode::RegOffset(base, offset as i64, ty);
+        let mem = AMode::RegOffset(base, offset as i64);
         Inst::gen_load(into_reg, mem, ty, MemFlags::trusted())
     }
 
     fn gen_store_base_offset(base: Reg, offset: i32, from_reg: Reg, ty: Type) -> Inst {
-        let mem = AMode::RegOffset(base, offset as i64, ty);
+        let mem = AMode::RegOffset(base, offset as i64);
         Inst::gen_store(mem, from_reg, ty, MemFlags::trusted())
     }
 
     fn gen_sp_reg_adjust(amount: i32) -> SmallInstVec<Inst> {
         let mut insts = SmallVec::new();
+
         if amount == 0 {
             return insts;
         }
-        insts.push(Inst::AdjustSp {
-            amount: amount as i64,
-        });
-        insts
-    }
 
-    fn gen_nominal_sp_adj(offset: i32) -> Inst {
-        Inst::VirtualSPOffsetAdj {
-            amount: offset as i64,
+        if let Some(imm) = Imm12::maybe_from_i64(amount as i64) {
+            insts.push(Inst::AluRRImm12 {
+                alu_op: AluOPRRI::Addi,
+                rd: writable_stack_reg(),
+                rs: stack_reg(),
+                imm12: imm,
+            })
+        } else {
+            let tmp = writable_spilltmp_reg();
+            insts.extend(Inst::load_constant_u64(tmp, amount as i64 as u64));
+            insts.push(Inst::AluRRR {
+                alu_op: AluOPRRR::Add,
+                rd: writable_stack_reg(),
+                rs1: stack_reg(),
+                rs2: tmp.to_reg(),
+            });
         }
+
+        insts
     }
 
     fn gen_prologue_frame_setup(
@@ -346,16 +350,18 @@ impl ABIMachineSpec for Riscv64MachineDeps {
             // sd   ra,8(sp)     ;; save ra.
             // sd   fp,0(sp)     ;; store old fp.
             // mv   fp,sp        ;; set fp to sp.
-            insts.push(Inst::AdjustSp { amount: -16 });
-            insts.push(Self::gen_store_stack(
-                StackAMode::SPOffset(8, I64),
+            insts.extend(Self::gen_sp_reg_adjust(-16));
+            insts.push(Inst::gen_store(
+                AMode::SPOffset(8),
                 link_reg(),
                 I64,
+                MemFlags::trusted(),
             ));
-            insts.push(Self::gen_store_stack(
-                StackAMode::SPOffset(0, I64),
+            insts.push(Inst::gen_store(
+                AMode::SPOffset(0),
                 fp_reg(),
                 I64,
+                MemFlags::trusted(),
             ));
 
             if flags.unwind_info() {
@@ -384,29 +390,38 @@ impl ABIMachineSpec for Riscv64MachineDeps {
         let mut insts = SmallVec::new();
 
         if frame_layout.setup_area_size > 0 {
-            insts.push(Self::gen_load_stack(
-                StackAMode::SPOffset(8, I64),
+            insts.push(Inst::gen_load(
                 writable_link_reg(),
+                AMode::SPOffset(8),
                 I64,
+                MemFlags::trusted(),
             ));
-            insts.push(Self::gen_load_stack(
-                StackAMode::SPOffset(0, I64),
+            insts.push(Inst::gen_load(
                 writable_fp_reg(),
+                AMode::SPOffset(0),
                 I64,
+                MemFlags::trusted(),
             ));
-            insts.push(Inst::AdjustSp { amount: 16 });
+            insts.extend(Self::gen_sp_reg_adjust(16));
         }
 
-        if call_conv == isa::CallConv::Tail && frame_layout.stack_args_size > 0 {
+        if call_conv == isa::CallConv::Tail && frame_layout.tail_args_size > 0 {
             insts.extend(Self::gen_sp_reg_adjust(
-                frame_layout.stack_args_size.try_into().unwrap(),
+                frame_layout.tail_args_size.try_into().unwrap(),
             ));
         }
-        insts.push(Inst::Ret {});
 
         insts
     }
 
+    fn gen_return(
+        _call_conv: isa::CallConv,
+        _isa_flags: &RiscvFlags,
+        _frame_layout: &FrameLayout,
+    ) -> SmallInstVec<Inst> {
+        smallvec![Inst::Ret {}]
+    }
+
     fn gen_probestack(insts: &mut SmallInstVec<Self::I>, frame_size: u32) {
         insts.extend(Inst::load_constant_u32(writable_a0(), frame_size as u64));
         insts.push(Inst::Call {
@@ -418,7 +433,6 @@ impl ABIMachineSpec for Riscv64MachineDeps {
                 }],
                 defs: smallvec![],
                 clobbers: PRegSet::empty(),
-                opcode: Opcode::Call,
                 callee_callconv: CallConv::SystemV,
                 caller_callconv: CallConv::SystemV,
                 callee_pop_size: 0,
@@ -432,10 +446,41 @@ impl ABIMachineSpec for Riscv64MachineDeps {
         frame_layout: &FrameLayout,
     ) -> SmallVec<[Inst; 16]> {
         let mut insts = SmallVec::new();
-        // Adjust the stack pointer downward for clobbers and the function fixed
-        // frame (spillslots and storage slots).
-        let stack_size = frame_layout.fixed_frame_storage_size + frame_layout.clobber_size;
-        if flags.unwind_info() && frame_layout.setup_area_size > 0 {
+        let setup_frame = frame_layout.setup_area_size > 0;
+
+        let incoming_args_diff = frame_layout.tail_args_size - frame_layout.incoming_args_size;
+        if incoming_args_diff > 0 {
+            // Decrement SP by the amount of additional incoming argument space we need
+            insts.extend(Self::gen_sp_reg_adjust(-(incoming_args_diff as i32)));
+
+            if setup_frame {
+                // Write the lr position on the stack again, as it hasn't changed since it was
+                // pushed in `gen_prologue_frame_setup`
+                insts.push(Inst::gen_store(
+                    AMode::SPOffset(8),
+                    link_reg(),
+                    I64,
+                    MemFlags::trusted(),
+                ));
+                insts.push(Inst::gen_load(
+                    writable_fp_reg(),
+                    AMode::SPOffset(i64::from(incoming_args_diff)),
+                    I64,
+                    MemFlags::trusted(),
+                ));
+                insts.push(Inst::gen_store(
+                    AMode::SPOffset(0),
+                    fp_reg(),
+                    I64,
+                    MemFlags::trusted(),
+                ));
+
+                // Finally, sync the frame pointer with SP
+                insts.push(Inst::gen_move(writable_fp_reg(), stack_reg(), I64));
+            }
+        }
+
+        if flags.unwind_info() && setup_frame {
             // The *unwind* frame (but not the actual frame) starts at the
             // clobbers, just below the saved FP/LR pair.
             insts.push(Inst::Unwind {
@@ -445,10 +490,18 @@ impl ABIMachineSpec for Riscv64MachineDeps {
                 },
             });
         }
+
+        // Adjust the stack pointer downward for clobbers, the function fixed
+        // frame (spillslots and storage slots), and outgoing arguments.
+        let stack_size = frame_layout.clobber_size
+            + frame_layout.fixed_frame_storage_size
+            + frame_layout.outgoing_args_size;
+
         // Store each clobbered register in order at offsets from SP,
         // placing them above the fixed frame slots.
         if stack_size > 0 {
-            // since we use fp, we didn't need use UnwindInst::StackAlloc.
+            insts.extend(Self::gen_sp_reg_adjust(-(stack_size as i32)));
+
             let mut cur_offset = 8;
             for reg in &frame_layout.clobbered_callee_saves {
                 let r_reg = reg.to_reg();
@@ -457,6 +510,13 @@ impl ABIMachineSpec for Riscv64MachineDeps {
                     RegClass::Float => F64,
                     RegClass::Vector => unimplemented!("Vector Clobber Saves"),
                 };
+                insts.push(Inst::gen_store(
+                    AMode::SPOffset((stack_size - cur_offset) as i64),
+                    Reg::from(reg.to_reg()),
+                    ty,
+                    MemFlags::trusted(),
+                ));
+
                 if flags.unwind_info() {
                     insts.push(Inst::Unwind {
                         inst: UnwindInst::SaveReg {
@@ -465,16 +525,9 @@ impl ABIMachineSpec for Riscv64MachineDeps {
                         },
                     });
                 }
-                insts.push(Self::gen_store_stack(
-                    StackAMode::SPOffset(-(cur_offset as i64), ty),
-                    real_reg_to_reg(reg.to_reg()),
-                    ty,
-                ));
+
                 cur_offset += 8
             }
-            insts.push(Inst::AdjustSp {
-                amount: -(stack_size as i64),
-            });
         }
         insts
     }
@@ -485,12 +538,11 @@ impl ABIMachineSpec for Riscv64MachineDeps {
         frame_layout: &FrameLayout,
     ) -> SmallVec<[Inst; 16]> {
         let mut insts = SmallVec::new();
-        let stack_size = frame_layout.fixed_frame_storage_size + frame_layout.clobber_size;
-        if stack_size > 0 {
-            insts.push(Inst::AdjustSp {
-                amount: stack_size as i64,
-            });
-        }
+
+        let stack_size = frame_layout.clobber_size
+            + frame_layout.fixed_frame_storage_size
+            + frame_layout.outgoing_args_size;
+
         let mut cur_offset = 8;
         for reg in &frame_layout.clobbered_callee_saves {
             let rreg = reg.to_reg();
@@ -499,13 +551,19 @@ impl ABIMachineSpec for Riscv64MachineDeps {
                 RegClass::Float => F64,
                 RegClass::Vector => unimplemented!("Vector Clobber Restores"),
             };
-            insts.push(Self::gen_load_stack(
-                StackAMode::SPOffset(-cur_offset, ty),
-                Writable::from_reg(real_reg_to_reg(reg.to_reg())),
+            insts.push(Inst::gen_load(
+                reg.map(Reg::from),
+                AMode::SPOffset(i64::from(stack_size - cur_offset)),
                 ty,
+                MemFlags::trusted(),
             ));
             cur_offset += 8
         }
+
+        if stack_size > 0 {
+            insts.extend(Self::gen_sp_reg_adjust(stack_size as i32));
+        }
+
         insts
     }
 
@@ -514,7 +572,6 @@ impl ABIMachineSpec for Riscv64MachineDeps {
         uses: CallArgList,
         defs: CallRetList,
         clobbers: PRegSet,
-        opcode: ir::Opcode,
         tmp: Writable<Reg>,
         callee_conv: isa::CallConv,
         caller_conv: isa::CallConv,
@@ -528,7 +585,6 @@ impl ABIMachineSpec for Riscv64MachineDeps {
                     uses,
                     defs,
                     clobbers,
-                    opcode,
                     caller_callconv: caller_conv,
                     callee_callconv: callee_conv,
                     callee_pop_size,
@@ -546,7 +602,6 @@ impl ABIMachineSpec for Riscv64MachineDeps {
                         uses,
                         defs,
                         clobbers,
-                        opcode,
                         caller_callconv: caller_conv,
                         callee_callconv: callee_conv,
                         callee_pop_size,
@@ -559,7 +614,6 @@ impl ABIMachineSpec for Riscv64MachineDeps {
                     uses,
                     defs,
                     clobbers,
-                    opcode,
                     caller_callconv: caller_conv,
                     callee_callconv: callee_conv,
                     callee_pop_size,
@@ -601,7 +655,6 @@ impl ABIMachineSpec for Riscv64MachineDeps {
                 ],
                 defs: smallvec![],
                 clobbers: Self::get_regs_clobbered_by_call(call_conv),
-                opcode: Opcode::Call,
                 caller_callconv: call_conv,
                 callee_callconv: call_conv,
                 callee_pop_size: 0,
@@ -623,46 +676,33 @@ impl ABIMachineSpec for Riscv64MachineDeps {
         }
     }
 
-    /// Get the current virtual-SP offset from an instruction-emission state.
-    fn get_virtual_sp_offset_from_state(s: &EmitState) -> i64 {
-        s.virtual_sp_offset
-    }
-
-    /// Get the nominal-SP-to-FP offset from an instruction-emission state.
-    fn get_nominal_sp_to_fp(s: &EmitState) -> i64 {
-        s.nominal_sp_to_fp
-    }
-
     fn get_machine_env(_flags: &settings::Flags, _call_conv: isa::CallConv) -> &MachineEnv {
         static MACHINE_ENV: OnceLock<MachineEnv> = OnceLock::new();
         MACHINE_ENV.get_or_init(create_reg_enviroment)
     }
 
-    fn get_regs_clobbered_by_call(call_conv_of_callee: isa::CallConv) -> PRegSet {
-        if call_conv_of_callee == isa::CallConv::Tail {
-            TAIL_CLOBBERS
-        } else {
-            DEFAULT_CLOBBERS
-        }
+    fn get_regs_clobbered_by_call(_call_conv_of_callee: isa::CallConv) -> PRegSet {
+        DEFAULT_CLOBBERS
     }
 
     fn compute_frame_layout(
-        call_conv: isa::CallConv,
+        _call_conv: isa::CallConv,
         flags: &settings::Flags,
         _sig: &Signature,
         regs: &[Writable<RealReg>],
         is_leaf: bool,
-        stack_args_size: u32,
+        incoming_args_size: u32,
+        tail_args_size: u32,
         fixed_frame_storage_size: u32,
         outgoing_args_size: u32,
     ) -> FrameLayout {
         let mut regs: Vec<Writable<RealReg>> = regs
             .iter()
             .cloned()
-            .filter(|r| is_reg_saved_in_prologue(call_conv, r.to_reg()))
+            .filter(|r| DEFAULT_CALLEE_SAVES.contains(r.to_reg().into()))
             .collect();
 
-        regs.sort();
+        regs.sort_unstable();
 
         // Compute clobber size.
         let clobber_size = compute_clobber_size(&regs);
@@ -672,7 +712,7 @@ impl ABIMachineSpec for Riscv64MachineDeps {
             || !is_leaf
             // The function arguments that are passed on the stack are addressed
             // relative to the Frame Pointer.
-            || stack_args_size > 0
+            || incoming_args_size > 0
             || clobber_size > 0
             || fixed_frame_storage_size > 0
         {
@@ -682,9 +722,9 @@ impl ABIMachineSpec for Riscv64MachineDeps {
         };
 
         // Return FrameLayout structure.
-        debug_assert!(outgoing_args_size == 0);
         FrameLayout {
-            stack_args_size,
+            incoming_args_size,
+            tail_args_size,
             setup_area_size,
             clobber_size,
             fixed_frame_storage_size,
@@ -695,7 +735,7 @@ impl ABIMachineSpec for Riscv64MachineDeps {
 
     fn gen_inline_probestack(
         insts: &mut SmallInstVec<Self::I>,
-        call_conv: isa::CallConv,
+        _call_conv: isa::CallConv,
         frame_size: u32,
         guard_size: u32,
     ) {
@@ -704,26 +744,37 @@ impl ABIMachineSpec for Riscv64MachineDeps {
         // Number of probes that we need to perform
         let probe_count = align_to(frame_size, guard_size) / guard_size;
 
+        // Must be a caller-saved register that is not an argument.
+        let tmp = Writable::from_reg(x_reg(28)); // t3
+
         if probe_count <= PROBE_MAX_UNROLL {
-            Self::gen_probestack_unroll(insts, guard_size, probe_count)
+            Self::gen_probestack_unroll(insts, tmp, guard_size, probe_count)
         } else {
-            Self::gen_probestack_loop(insts, call_conv, guard_size, probe_count)
+            insts.push(Inst::StackProbeLoop {
+                guard_size,
+                probe_count,
+                tmp,
+            });
         }
     }
 }
 
 impl Riscv64ABICallSite {
     pub fn emit_return_call(mut self, ctx: &mut Lower<Inst>, args: isle::ValueSlice) {
-        let (new_stack_arg_size, old_stack_arg_size) =
-            self.emit_temporary_tail_call_frame(ctx, args);
+        let new_stack_arg_size =
+            u32::try_from(self.sig(ctx.sigs()).sized_stack_arg_space()).unwrap();
+
+        ctx.abi_mut().accumulate_tail_args_size(new_stack_arg_size);
+
+        // Put all arguments in registers and stack slots (within that newly
+        // allocated stack space).
+        self.emit_args(ctx, args);
+        self.emit_stack_ret_arg_for_tail_call(ctx);
 
         let dest = self.dest().clone();
-        let opcode = self.opcode();
         let uses = self.take_uses();
         let info = Box::new(ReturnCallInfo {
             uses,
-            opcode,
-            old_stack_arg_size,
             new_stack_arg_size,
         });
 
@@ -751,33 +802,34 @@ impl Riscv64ABICallSite {
     }
 }
 
-const CALLEE_SAVE_X_REG: [bool; 32] = [
-    false, false, true, false, false, false, false, false, // 0-7
-    true, true, false, false, false, false, false, false, // 8-15
-    false, false, true, true, true, true, true, true, // 16-23
-    true, true, true, true, false, false, false, false, // 24-31
-];
-const CALLEE_SAVE_F_REG: [bool; 32] = [
-    false, false, false, false, false, false, false, false, // 0-7
-    true, false, false, false, false, false, false, false, // 8-15
-    false, false, true, true, true, true, true, true, // 16-23
-    true, true, true, true, false, false, false, false, // 24-31
-];
-
-/// This should be the registers that must be saved by callee.
-#[inline]
-fn is_reg_saved_in_prologue(conv: CallConv, reg: RealReg) -> bool {
-    if conv == CallConv::Tail {
-        return false;
-    }
-
-    match reg.class() {
-        RegClass::Int => CALLEE_SAVE_X_REG[reg.hw_enc() as usize],
-        RegClass::Float => CALLEE_SAVE_F_REG[reg.hw_enc() as usize],
-        // All vector registers are caller saved.
-        RegClass::Vector => false,
-    }
-}
+// NOTE: no V regs are callee save.
+const DEFAULT_CALLEE_SAVES: PRegSet = PRegSet::empty()
+    // X Regs
+    .with(px_reg(2))
+    .with(px_reg(8))
+    .with(px_reg(9))
+    .with(px_reg(18))
+    .with(px_reg(19))
+    .with(px_reg(20))
+    .with(px_reg(21))
+    .with(px_reg(22))
+    .with(px_reg(23))
+    .with(px_reg(24))
+    .with(px_reg(25))
+    .with(px_reg(26))
+    .with(px_reg(27))
+    // F Regs
+    .with(pf_reg(8))
+    .with(pf_reg(18))
+    .with(pf_reg(19))
+    .with(pf_reg(20))
+    .with(pf_reg(21))
+    .with(pf_reg(22))
+    .with(pf_reg(23))
+    .with(pf_reg(24))
+    .with(pf_reg(25))
+    .with(pf_reg(26))
+    .with(pf_reg(27));
 
 fn compute_clobber_size(clobbers: &[Writable<RealReg>]) -> u32 {
     let mut clobbered_size = 0;
@@ -795,188 +847,78 @@ fn compute_clobber_size(clobbers: &[Writable<RealReg>]) -> u32 {
     align_to(clobbered_size, 16)
 }
 
-const fn default_clobbers() -> PRegSet {
-    PRegSet::empty()
-        .with(px_reg(1))
-        .with(px_reg(5))
-        .with(px_reg(6))
-        .with(px_reg(7))
-        .with(px_reg(10))
-        .with(px_reg(11))
-        .with(px_reg(12))
-        .with(px_reg(13))
-        .with(px_reg(14))
-        .with(px_reg(15))
-        .with(px_reg(16))
-        .with(px_reg(17))
-        .with(px_reg(28))
-        .with(px_reg(29))
-        .with(px_reg(30))
-        .with(px_reg(31))
-        // F Regs
-        .with(pf_reg(0))
-        .with(pf_reg(1))
-        .with(pf_reg(2))
-        .with(pf_reg(3))
-        .with(pf_reg(4))
-        .with(pf_reg(5))
-        .with(pf_reg(6))
-        .with(pf_reg(7))
-        .with(pf_reg(9))
-        .with(pf_reg(10))
-        .with(pf_reg(11))
-        .with(pf_reg(12))
-        .with(pf_reg(13))
-        .with(pf_reg(14))
-        .with(pf_reg(15))
-        .with(pf_reg(16))
-        .with(pf_reg(17))
-        .with(pf_reg(28))
-        .with(pf_reg(29))
-        .with(pf_reg(30))
-        .with(pf_reg(31))
-        // V Regs - All vector regs get clobbered
-        .with(pv_reg(0))
-        .with(pv_reg(1))
-        .with(pv_reg(2))
-        .with(pv_reg(3))
-        .with(pv_reg(4))
-        .with(pv_reg(5))
-        .with(pv_reg(6))
-        .with(pv_reg(7))
-        .with(pv_reg(8))
-        .with(pv_reg(9))
-        .with(pv_reg(10))
-        .with(pv_reg(11))
-        .with(pv_reg(12))
-        .with(pv_reg(13))
-        .with(pv_reg(14))
-        .with(pv_reg(15))
-        .with(pv_reg(16))
-        .with(pv_reg(17))
-        .with(pv_reg(18))
-        .with(pv_reg(19))
-        .with(pv_reg(20))
-        .with(pv_reg(21))
-        .with(pv_reg(22))
-        .with(pv_reg(23))
-        .with(pv_reg(24))
-        .with(pv_reg(25))
-        .with(pv_reg(26))
-        .with(pv_reg(27))
-        .with(pv_reg(28))
-        .with(pv_reg(29))
-        .with(pv_reg(30))
-        .with(pv_reg(31))
-}
-
-const DEFAULT_CLOBBERS: PRegSet = default_clobbers();
-
-// All allocatable registers are clobbered by calls using the `tail` calling
-// convention.
-const fn tail_clobbers() -> PRegSet {
-    PRegSet::empty()
-        // `x0` is the zero register, and not allocatable.
-        .with(px_reg(1))
-        // `x2` is the stack pointer, `x3` is the global pointer, and `x4` is
-        // the thread pointer. None are allocatable.
-        .with(px_reg(5))
-        .with(px_reg(6))
-        .with(px_reg(7))
-        // `x8` is the frame pointer, and not allocatable.
-        .with(px_reg(9))
-        .with(px_reg(10))
-        .with(px_reg(10))
-        .with(px_reg(11))
-        .with(px_reg(12))
-        .with(px_reg(13))
-        .with(px_reg(14))
-        .with(px_reg(15))
-        .with(px_reg(16))
-        .with(px_reg(17))
-        .with(px_reg(18))
-        .with(px_reg(19))
-        .with(px_reg(20))
-        .with(px_reg(21))
-        .with(px_reg(22))
-        .with(px_reg(23))
-        .with(px_reg(24))
-        .with(px_reg(25))
-        .with(px_reg(26))
-        .with(px_reg(27))
-        .with(px_reg(28))
-        .with(px_reg(29))
-        // `x30` and `x31` are reserved as scratch registers, and are not
-        // allocatable.
-        //
-        // F Regs
-        .with(pf_reg(0))
-        .with(pf_reg(1))
-        .with(pf_reg(2))
-        .with(pf_reg(3))
-        .with(pf_reg(4))
-        .with(pf_reg(5))
-        .with(pf_reg(6))
-        .with(pf_reg(7))
-        .with(pf_reg(9))
-        .with(pf_reg(10))
-        .with(pf_reg(11))
-        .with(pf_reg(12))
-        .with(pf_reg(13))
-        .with(pf_reg(14))
-        .with(pf_reg(15))
-        .with(pf_reg(16))
-        .with(pf_reg(17))
-        .with(pf_reg(18))
-        .with(pf_reg(19))
-        .with(pf_reg(20))
-        .with(pf_reg(21))
-        .with(pf_reg(22))
-        .with(pf_reg(23))
-        .with(pf_reg(24))
-        .with(pf_reg(25))
-        .with(pf_reg(26))
-        .with(pf_reg(27))
-        .with(pf_reg(28))
-        .with(pf_reg(29))
-        .with(pf_reg(30))
-        .with(pf_reg(31))
-        // V Regs
-        .with(pv_reg(0))
-        .with(pv_reg(1))
-        .with(pv_reg(2))
-        .with(pv_reg(3))
-        .with(pv_reg(4))
-        .with(pv_reg(5))
-        .with(pv_reg(6))
-        .with(pv_reg(7))
-        .with(pv_reg(8))
-        .with(pv_reg(9))
-        .with(pv_reg(10))
-        .with(pv_reg(11))
-        .with(pv_reg(12))
-        .with(pv_reg(13))
-        .with(pv_reg(14))
-        .with(pv_reg(15))
-        .with(pv_reg(16))
-        .with(pv_reg(17))
-        .with(pv_reg(18))
-        .with(pv_reg(19))
-        .with(pv_reg(20))
-        .with(pv_reg(21))
-        .with(pv_reg(22))
-        .with(pv_reg(23))
-        .with(pv_reg(24))
-        .with(pv_reg(25))
-        .with(pv_reg(26))
-        .with(pv_reg(27))
-        .with(pv_reg(28))
-        .with(pv_reg(29))
-        .with(pv_reg(30))
-        .with(pv_reg(31))
-}
-
-const TAIL_CLOBBERS: PRegSet = tail_clobbers();
+const DEFAULT_CLOBBERS: PRegSet = PRegSet::empty()
+    .with(px_reg(1))
+    .with(px_reg(5))
+    .with(px_reg(6))
+    .with(px_reg(7))
+    .with(px_reg(10))
+    .with(px_reg(11))
+    .with(px_reg(12))
+    .with(px_reg(13))
+    .with(px_reg(14))
+    .with(px_reg(15))
+    .with(px_reg(16))
+    .with(px_reg(17))
+    .with(px_reg(28))
+    .with(px_reg(29))
+    .with(px_reg(30))
+    .with(px_reg(31))
+    // F Regs
+    .with(pf_reg(0))
+    .with(pf_reg(1))
+    .with(pf_reg(2))
+    .with(pf_reg(3))
+    .with(pf_reg(4))
+    .with(pf_reg(5))
+    .with(pf_reg(6))
+    .with(pf_reg(7))
+    .with(pf_reg(9))
+    .with(pf_reg(10))
+    .with(pf_reg(11))
+    .with(pf_reg(12))
+    .with(pf_reg(13))
+    .with(pf_reg(14))
+    .with(pf_reg(15))
+    .with(pf_reg(16))
+    .with(pf_reg(17))
+    .with(pf_reg(28))
+    .with(pf_reg(29))
+    .with(pf_reg(30))
+    .with(pf_reg(31))
+    // V Regs - All vector regs get clobbered
+    .with(pv_reg(0))
+    .with(pv_reg(1))
+    .with(pv_reg(2))
+    .with(pv_reg(3))
+    .with(pv_reg(4))
+    .with(pv_reg(5))
+    .with(pv_reg(6))
+    .with(pv_reg(7))
+    .with(pv_reg(8))
+    .with(pv_reg(9))
+    .with(pv_reg(10))
+    .with(pv_reg(11))
+    .with(pv_reg(12))
+    .with(pv_reg(13))
+    .with(pv_reg(14))
+    .with(pv_reg(15))
+    .with(pv_reg(16))
+    .with(pv_reg(17))
+    .with(pv_reg(18))
+    .with(pv_reg(19))
+    .with(pv_reg(20))
+    .with(pv_reg(21))
+    .with(pv_reg(22))
+    .with(pv_reg(23))
+    .with(pv_reg(24))
+    .with(pv_reg(25))
+    .with(pv_reg(26))
+    .with(pv_reg(27))
+    .with(pv_reg(28))
+    .with(pv_reg(29))
+    .with(pv_reg(30))
+    .with(pv_reg(31));
 
 fn create_reg_enviroment() -> MachineEnv {
     // Some C Extension instructions can only use a subset of the registers.
@@ -1038,33 +980,42 @@ fn create_reg_enviroment() -> MachineEnv {
 }
 
 impl Riscv64MachineDeps {
-    fn gen_probestack_unroll(insts: &mut SmallInstVec<Inst>, guard_size: u32, probe_count: u32) {
-        insts.reserve(probe_count as usize);
-        for i in 0..probe_count {
-            let offset = (guard_size * (i + 1)) as i64;
-            insts.push(Self::gen_store_stack(
-                StackAMode::SPOffset(-offset, I8),
+    fn gen_probestack_unroll(
+        insts: &mut SmallInstVec<Inst>,
+        tmp: Writable<Reg>,
+        guard_size: u32,
+        probe_count: u32,
+    ) {
+        // When manually unrolling adjust the stack pointer and then write a zero
+        // to the stack at that offset.
+        //
+        // We do this because valgrind expects us to never write beyond the stack
+        // pointer and associated redzone.
+        // See: https://github.com/bytecodealliance/wasmtime/issues/7454
+
+        // Store the adjust amount in a register upfront, so we don't have to
+        // reload it for each probe. It's worth loading this as a negative and
+        // using an `add` instruction since we have compressed versions of `add`
+        // but not the `sub` instruction.
+        insts.extend(Inst::load_constant_u64(tmp, (-(guard_size as i64)) as u64));
+
+        for _ in 0..probe_count {
+            insts.push(Inst::AluRRR {
+                alu_op: AluOPRRR::Add,
+                rd: writable_stack_reg(),
+                rs1: stack_reg(),
+                rs2: tmp.to_reg(),
+            });
+
+            insts.push(Inst::gen_store(
+                AMode::SPOffset(0),
                 zero_reg(),
                 I32,
+                MemFlags::trusted(),
             ));
         }
-    }
 
-    fn gen_probestack_loop(
-        insts: &mut SmallInstVec<Inst>,
-        call_conv: isa::CallConv,
-        guard_size: u32,
-        probe_count: u32,
-    ) {
-        // Must be a caller-saved register that is not an argument.
-        let tmp = match call_conv {
-            isa::CallConv::Tail => Writable::from_reg(x_reg(1)),
-            _ => Writable::from_reg(x_reg(28)), // t3
-        };
-        insts.push(Inst::StackProbeLoop {
-            guard_size,
-            probe_count,
-            tmp,
-        });
+        // Restore the stack pointer to its original value
+        insts.extend(Self::gen_sp_reg_adjust((guard_size * probe_count) as i32));
     }
 }
diff --git a/cranelift/codegen/src/isa/riscv64/inst.isle b/cranelift/codegen/src/isa/riscv64/inst.isle
index 32968393af10..76fd7f604793 100644
--- a/cranelift/codegen/src/isa/riscv64/inst.isle
+++ b/cranelift/codegen/src/isa/riscv64/inst.isle
@@ -19,10 +19,16 @@
       (rd WritableReg)
       (imm Imm20))
 
+    (Fli
+      (ty Type)
+      (imm FliConstant)
+      (rd WritableReg))
+
     ;; An ALU operation with one register sources and a register destination.
     (FpuRR
       (alu_op FpuOPRR)
-      (frm OptionFloatRoundingMode)
+      (width FpuOPWidth)
+      (frm FRM)
       (rd WritableReg)
       (rs Reg))
 
@@ -37,7 +43,8 @@
     ;; An ALU operation with two register sources and a register destination.
     (FpuRRR
       (alu_op FpuOPRRR)
-      (frm OptionFloatRoundingMode)
+      (width FpuOPWidth)
+      (frm FRM)
       (rd WritableReg)
       (rs1 Reg)
       (rs2 Reg))
@@ -45,7 +52,8 @@
     ;; An ALU operation with three register sources and a register destination.
     (FpuRRRR
       (alu_op FpuOPRRRR)
-      (frm OptionFloatRoundingMode)
+      (width FpuOPWidth)
+      (frm FRM)
       (rd WritableReg)
       (rs1 Reg)
       (rs2 Reg)
@@ -103,8 +111,6 @@
       (from_bits u8)
       (to_bits u8))
 
-    (AdjustSp
-      (amount i64))
     (Call
       (info BoxCallInfo))
 
@@ -154,11 +160,6 @@
       (rd WritableReg)
       (mem AMode))
 
-    ;; Marker, no-op in generated code: SP "virtual offset" is adjusted. This
-    ;; controls how AMode::NominalSPOffset args are lowered.
-    (VirtualSPOffsetAdj
-      (amount i64))
-
     ;; A MOV instruction. These are encoded as OrR's (AluRRR form) but we
     ;; keep them separate at the `Inst` level for better pretty-printing
     ;; and faster `is_move()` logic.
@@ -241,21 +242,6 @@
       (addr Reg)
       (v Reg)
       (ty Type))
-    ;; an integer compare.
-    (Icmp
-      (cc IntCC)
-      (rd WritableReg)
-      (a ValueRegs)
-      (b ValueRegs)
-      (ty Type))
-    (FcvtToInt
-      (is_sat bool)
-      (rd WritableReg)
-      (tmp WritableReg) ;; a float register to load bounds.
-      (rs Reg)
-      (is_signed bool)
-      (in_type Type)
-      (out_type Type))
 
     (RawData (data VecU8))
 
@@ -266,23 +252,6 @@
     ;; A dummy use, useful to keep a value alive.
        (DummyUse
         (reg Reg))
-    ;;;
-    (FloatRound
-      (op FloatRoundOP)
-      (rd WritableReg)
-      (int_tmp WritableReg)
-      (f_tmp WritableReg)
-      (rs Reg)
-      (ty Type))
-    ;;;; FMax
-    (FloatSelect
-      (op FloatSelectOP)
-      (rd WritableReg)
-      ;; a integer register
-      (tmp WritableReg)
-      (rs1 Reg)
-      (rs2 Reg)
-      (ty Type))
 
     ;; popcnt  if target doesn't support extension B
     ;; use iteration to implement.
@@ -302,13 +271,7 @@
       (tmp WritableReg)
       (rs Reg)
       (ty Type))
-    ;; Byte-reverse register
-    (Rev8
-      (rs Reg)
-      (step WritableReg)
-      (tmp WritableReg)
-      (rd WritableReg))
-    ;;
+
     (Brev8
       (rs Reg)
       (ty Type)
@@ -390,19 +353,6 @@
       (vstate VState))
 ))
 
-
-(type FloatSelectOP (enum
-  (Max)
-  (Min)
-))
-
-(type FloatRoundOP (enum
-  (Nearest)
-  (Ceil)
-  (Floor)
-  (Trunc)
-))
-
 (type AtomicOP (enum
   (LrW)
   (ScW)
@@ -429,16 +379,10 @@
 ))
 
 (type FpuOPRRRR (enum
-  ;; float32
-  (FmaddS)
-  (FmsubS)
-  (FnmsubS)
-  (FnmaddS)
-  ;; float64
-  (FmaddD)
-  (FmsubD)
-  (FnmsubD)
-  (FnmaddD)
+  (Fmadd)
+  (Fmsub)
+  (Fnmsub)
+  (Fnmadd)
 ))
 
 (type FClassResult (enum
@@ -464,44 +408,37 @@
   (QNaN)
 ))
 
-(type FpuOPRR (enum
-  ;; RV32F Standard Extension
-  (FsqrtS)
-  (FcvtWS)
-  (FcvtWuS)
-  (FmvXW)
-  (FclassS)
-  (FcvtSw)
-  (FcvtSwU)
-  (FmvWX)
-
-
-  ;; RV64F Standard Extension (in addition to RV32F)
-  (FcvtLS)
-  (FcvtLuS)
-  (FcvtSL)
-  (FcvtSLU)
-
-
-  ;; RV64D Standard Extension (in addition to RV32D)
-  (FcvtLD)
-  (FcvtLuD)
-  (FmvXD)
-  (FcvtDL)
-  (FcvtDLu)
-  (FmvDX)
-
-  ;; RV32D Standard Extension
-  (FsqrtD)
-  (FcvtSD)
-  (FcvtDS)
-  (FclassD)
-  (FcvtWD)
-  (FcvtWuD)
-  (FcvtDW)
-  (FcvtDWU)
-  ;; bitmapip
+(type FliConstant (primitive FliConstant))
+
+(type FpuOPWidth (enum
+  (S)
+  (D)
+  (H)
+  (Q)
+))
+
+(decl pure fpu_op_width_from_ty (Type) FpuOPWidth)
+(extern constructor fpu_op_width_from_ty fpu_op_width_from_ty)
+(convert Type FpuOPWidth fpu_op_width_from_ty)
 
+(type FpuOPRR (enum
+  (Fsqrt) ;; fsqrt.{fmt}
+  (Fclass) ;; fclass.{fmt}
+  (FcvtWFmt) ;; fcvt.w.{fmt}
+  (FcvtWuFmt) ;; fcvt.wu.{fmt}
+  (FcvtLFmt) ;; fcvt.l.{fmt}
+  (FcvtLuFmt) ;; fcvt.lu.{fmt}
+  (FcvtFmtW) ;; fcvt.{fmt}.w
+  (FcvtFmtWu) ;; fcvt.{fmt}.wu
+  (FcvtFmtL) ;; fcvt.{fmt}.l
+  (FcvtFmtLu) ;; fcvt.{fmt}.lu
+  (FmvXFmt) ;; fmv.x.{fmt}
+  (FmvFmtX) ;; fmv.{fmt}.x
+  (FcvtSD) ;; fcvt.s.d
+  (FcvtDS) ;; fcvt.d.s
+
+  ;; Zfa Extension
+  (Fround) ;; fround.{fmt}
 ))
 
 (type LoadOP (enum
@@ -512,6 +449,7 @@
   (Lhu)
   (Lwu)
   (Ld)
+  (Flh)
   (Flw)
   (Fld)
 ))
@@ -521,6 +459,7 @@
   (Sh)
   (Sw)
   (Sd)
+  (Fsh)
   (Fsw)
   (Fsd)
 ))
@@ -602,38 +541,30 @@
   (Pack)
   (Packw)
   (Packh)
+
+  ;; ZiCond: Integer Conditional Operations
+  (CzeroEqz)
+  (CzeroNez)
 ))
 
 
 (type FpuOPRRR (enum
-  ;; RV32F Standard Extension
-  (FaddS)
-  (FsubS)
-  (FmulS)
-  (FdivS)
-
-  (FsgnjS)
-  (FsgnjnS)
-  (FsgnjxS)
-  (FminS)
-  (FmaxS)
-  (FeqS)
-  (FltS)
-  (FleS)
-
-  ;; RV32D Standard Extension
-  (FaddD)
-  (FsubD)
-  (FmulD)
-  (FdivD)
-  (FsgnjD)
-  (FsgnjnD)
-  (FsgnjxD)
-  (FminD)
-  (FmaxD)
-  (FeqD)
-  (FltD)
-  (FleD)
+  (Fadd)
+  (Fsub)
+  (Fmul)
+  (Fdiv)
+  (Fsgnj)
+  (Fsgnjn)
+  (Fsgnjx)
+  (Fmin)
+  (Fmax)
+  (Feq)
+  (Flt)
+  (Fle)
+
+  ;; Zfa Extension
+  (Fminm)
+  (Fmaxm)
 ))
 
 
@@ -769,7 +700,7 @@
   (CSexth)
 ))
 
-;; This is a mix of all Zcb memory adressing instructions
+;; This is a mix of all Zcb memory addressing instructions
 ;;
 ;; Technically they are split across 4 different formats.
 ;; But they are all very similar, so we just group them all together.
@@ -860,7 +791,6 @@
 (type Imm20 (primitive Imm20))
 (type Imm3 (primitive Imm3))
 (type CondBrTarget (primitive CondBrTarget))
-(type OptionFloatRoundingMode (primitive OptionFloatRoundingMode))
 (type VecU8 (primitive VecU8))
 (type AMO (primitive AMO))
 (type VecMachLabel extern (enum))
@@ -1073,6 +1003,12 @@
 (decl pure has_v () bool)
 (extern constructor has_v has_v)
 
+(decl pure has_zfa () bool)
+(extern constructor has_zfa has_zfa)
+
+(decl pure has_zfh () bool)
+(extern constructor has_zfh has_zfh)
+
 (decl pure has_zbkb () bool)
 (extern constructor has_zbkb has_zbkb)
 
@@ -1088,24 +1024,24 @@
 (decl pure has_zbs () bool)
 (extern constructor has_zbs has_zbs)
 
-(decl gen_float_round (FloatRoundOP Reg Type) Reg)
-(rule
-  (gen_float_round op rs ty)
-  (let
-    ((rd WritableReg (temp_writable_reg ty))
-      (tmp WritableXReg (temp_writable_xreg))
-      (tmp2 WritableFReg (temp_writable_freg))
-      (_ Unit (emit (MInst.FloatRound op rd tmp tmp2 rs ty))))
-    (writable_reg_to_reg rd)))
+(decl pure has_zicond () bool)
+(extern constructor has_zicond has_zicond)
 
-(decl gen_float_select (FloatSelectOP Reg Reg Type) Reg)
-(rule
-  (gen_float_select op x y ty)
-  (let
-    ((rd WritableReg (temp_writable_reg ty))
-      (tmp WritableXReg (temp_writable_xreg))
-      (_ Unit (emit (MInst.FloatSelect op rd tmp x y ty))))
-    (writable_reg_to_reg rd)))
+
+;;;; Type Helpers ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Helper that matches any supported type. This extractor checks the ISA flags
+;; to determine if the type is supported.
+(decl ty_supported (Type) Type)
+(extern extractor ty_supported ty_supported)
+
+;; Helper that matches any scalar floating point type
+(decl ty_supported_float (Type) Type)
+(extern extractor ty_supported_float ty_supported_float)
+
+;; Helper that matches any supported vector type
+(decl ty_supported_vec (Type) Type)
+(extern extractor ty_supported_vec ty_supported_vec)
 
 
 ;;;; Instruction Helpers ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -1190,7 +1126,7 @@
 (rule (rv_xor rs1 rs2)
   (alu_rrr (AluOPRRR.Xor) rs1 rs2))
 
-;; Helper for emitting the `xori` ("Exlusive Or Immediate") instruction.
+;; Helper for emitting the `xori` ("Exclusive Or Immediate") instruction.
 ;; rd ← rs1 ⊕ uext(imm)
 (decl rv_xori (XReg Imm12) XReg)
 (rule (rv_xori rs1 imm)
@@ -1214,6 +1150,12 @@
 (rule (rv_andi rs1 imm)
   (alu_rr_imm12 (AluOPRRI.Andi) rs1 imm))
 
+;; Helper for emitting the `slt` ("Set Less Than") instruction.
+;; rd ← rs1 < rs2
+(decl rv_slt (XReg XReg) XReg)
+(rule (rv_slt rs1 rs2)
+  (alu_rrr (AluOPRRR.Slt) rs1 rs2))
+
 ;; Helper for emitting the `sltu` ("Set Less Than Unsigned") instruction.
 ;; rd ← rs1 < rs2
 (decl rv_sltu (XReg XReg) XReg)
@@ -1226,7 +1168,13 @@
 (rule (rv_snez rs1)
   (rv_sltu (zero_reg) rs1))
 
-;; Helper for emiting the `sltiu` ("Set Less Than Immediate Unsigned") instruction.
+;; Helper for emitting the `slti` ("Set Less Than Immediate") instruction.
+;; rd ← rs1 < imm
+(decl rv_slti (XReg Imm12) XReg)
+(rule (rv_slti rs1 imm)
+  (alu_rr_imm12 (AluOPRRI.Slti) rs1 imm))
+
+;; Helper for emitting the `sltiu` ("Set Less Than Immediate Unsigned") instruction.
 ;; rd ← rs1 < imm
 (decl rv_sltiu (XReg Imm12) XReg)
 (rule (rv_sltiu rs1 imm)
@@ -1386,104 +1334,168 @@
 ;; TODO: Enable these instructions only when we have the F or D extensions
 
 ;; Helper for emitting the `fadd` instruction.
-(decl rv_fadd (Type FReg FReg) FReg)
-(rule (rv_fadd $F32 rs1 rs2) (fpu_rrr (FpuOPRRR.FaddS) $F32 rs1 rs2))
-(rule (rv_fadd $F64 rs1 rs2) (fpu_rrr (FpuOPRRR.FaddD) $F64 rs1 rs2))
+(decl rv_fadd (Type FRM FReg FReg) FReg)
+(rule (rv_fadd ty frm rs1 rs2) (fpu_rrr (FpuOPRRR.Fadd) ty frm rs1 rs2))
 
 ;; Helper for emitting the `fsub` instruction.
-(decl rv_fsub (Type FReg FReg) FReg)
-(rule (rv_fsub $F32 rs1 rs2) (fpu_rrr (FpuOPRRR.FsubS) $F32 rs1 rs2))
-(rule (rv_fsub $F64 rs1 rs2) (fpu_rrr (FpuOPRRR.FsubD) $F64 rs1 rs2))
+(decl rv_fsub (Type FRM FReg FReg) FReg)
+(rule (rv_fsub ty frm rs1 rs2) (fpu_rrr (FpuOPRRR.Fsub) ty frm rs1 rs2))
 
 ;; Helper for emitting the `fmul` instruction.
-(decl rv_fmul (Type FReg FReg) FReg)
-(rule (rv_fmul $F32 rs1 rs2) (fpu_rrr (FpuOPRRR.FmulS) $F32 rs1 rs2))
-(rule (rv_fmul $F64 rs1 rs2) (fpu_rrr (FpuOPRRR.FmulD) $F64 rs1 rs2))
+(decl rv_fmul (Type FRM FReg FReg) FReg)
+(rule (rv_fmul ty frm rs1 rs2) (fpu_rrr (FpuOPRRR.Fmul) ty frm rs1 rs2))
 
 ;; Helper for emitting the `fdiv` instruction.
-(decl rv_fdiv (Type FReg FReg) FReg)
-(rule (rv_fdiv $F32 rs1 rs2) (fpu_rrr (FpuOPRRR.FdivS) $F32 rs1 rs2))
-(rule (rv_fdiv $F64 rs1 rs2) (fpu_rrr (FpuOPRRR.FdivD) $F64 rs1 rs2))
+(decl rv_fdiv (Type FRM FReg FReg) FReg)
+(rule (rv_fdiv ty frm rs1 rs2) (fpu_rrr (FpuOPRRR.Fdiv) ty frm rs1 rs2))
 
 ;; Helper for emitting the `fsqrt` instruction.
-(decl rv_fsqrt (Type FReg) FReg)
-(rule (rv_fsqrt $F32 rs1) (fpu_rr (FpuOPRR.FsqrtS) $F32 rs1))
-(rule (rv_fsqrt $F64 rs1) (fpu_rr (FpuOPRR.FsqrtD) $F64 rs1))
+(decl rv_fsqrt (Type FRM FReg) FReg)
+(rule (rv_fsqrt ty frm rs1) (fpu_rr (FpuOPRR.Fsqrt) ty frm rs1))
 
 ;; Helper for emitting the `fmadd` instruction.
-(decl rv_fmadd (Type FReg FReg FReg) FReg)
-(rule (rv_fmadd $F32 rs1 rs2 rs3) (fpu_rrrr (FpuOPRRRR.FmaddS) $F32 rs1 rs2 rs3))
-(rule (rv_fmadd $F64 rs1 rs2 rs3) (fpu_rrrr (FpuOPRRRR.FmaddD) $F64 rs1 rs2 rs3))
+(decl rv_fmadd (Type FRM FReg FReg FReg) FReg)
+(rule (rv_fmadd ty frm rs1 rs2 rs3) (fpu_rrrr (FpuOPRRRR.Fmadd) ty frm rs1 rs2 rs3))
+
+;; Helper for emitting the `fmsub` instruction.
+(decl rv_fmsub (Type FRM FReg FReg FReg) FReg)
+(rule (rv_fmsub ty frm rs1 rs2 rs3) (fpu_rrrr (FpuOPRRRR.Fmsub) ty frm rs1 rs2 rs3))
+
+;; Helper for emitting the `fnmadd` instruction.
+(decl rv_fnmadd (Type FRM FReg FReg FReg) FReg)
+(rule (rv_fnmadd ty frm rs1 rs2 rs3) (fpu_rrrr (FpuOPRRRR.Fnmadd) ty frm rs1 rs2 rs3))
+
+;; Helper for emitting the `fnmsub` instruction.
+(decl rv_fnmsub (Type FRM FReg FReg FReg) FReg)
+(rule (rv_fnmsub ty frm rs1 rs2 rs3) (fpu_rrrr (FpuOPRRRR.Fnmsub) ty frm rs1 rs2 rs3))
+
+;; Helper for emitting the `fmv.x.h` instruction.
+(decl rv_fmvxh (FReg) XReg)
+(rule (rv_fmvxh r) (fpu_rr_int (FpuOPRR.FmvXFmt) $F16 (FRM.RNE) r))
 
 ;; Helper for emitting the `fmv.x.w` instruction.
 (decl rv_fmvxw (FReg) XReg)
-(rule (rv_fmvxw r) (fpu_rr (FpuOPRR.FmvXW) $I32 r))
+(rule (rv_fmvxw r) (fpu_rr_int (FpuOPRR.FmvXFmt) $F32 (FRM.RNE) r))
 
 ;; Helper for emitting the `fmv.x.d` instruction.
 (decl rv_fmvxd (FReg) XReg)
-(rule (rv_fmvxd r) (fpu_rr (FpuOPRR.FmvXD) $I64 r))
+(rule (rv_fmvxd r) (fpu_rr_int (FpuOPRR.FmvXFmt) $F64 (FRM.RNE) r))
+
+;; Helper for emitting the `fmv.h.x` instruction.
+(decl rv_fmvhx (XReg) FReg)
+(rule (rv_fmvhx r) (fpu_rr (FpuOPRR.FmvFmtX) $F16 (FRM.RNE) r))
 
 ;; Helper for emitting the `fmv.w.x` instruction.
 (decl rv_fmvwx (XReg) FReg)
-(rule (rv_fmvwx r) (fpu_rr (FpuOPRR.FmvWX) $F32 r))
+(rule (rv_fmvwx r) (fpu_rr (FpuOPRR.FmvFmtX) $F32 (FRM.RNE) r))
 
 ;; Helper for emitting the `fmv.d.x` instruction.
 (decl rv_fmvdx (XReg) FReg)
-(rule (rv_fmvdx r) (fpu_rr (FpuOPRR.FmvDX) $F64 r))
+(rule (rv_fmvdx r) (fpu_rr (FpuOPRR.FmvFmtX) $F64 (FRM.RNE) r))
 
 ;; Helper for emitting the `fcvt.d.s` ("Float Convert Double to Single") instruction.
 (decl rv_fcvtds (FReg) FReg)
-(rule (rv_fcvtds rs1) (fpu_rr (FpuOPRR.FcvtDS) $F32 rs1))
+(rule (rv_fcvtds rs1) (fpu_rr (FpuOPRR.FcvtDS) $F64 (FRM.RNE) rs1))
 
 ;; Helper for emitting the `fcvt.s.d` ("Float Convert Single to Double") instruction.
-(decl rv_fcvtsd (FReg) FReg)
-(rule (rv_fcvtsd rs1) (fpu_rr (FpuOPRR.FcvtSD) $F64 rs1))
+(decl rv_fcvtsd (FRM FReg) FReg)
+(rule (rv_fcvtsd frm rs1) (fpu_rr (FpuOPRR.FcvtSD) $F32 frm rs1))
 
 ;; Helper for emitting the `fcvt.s.w` instruction.
-(decl rv_fcvtsw (XReg) FReg)
-(rule (rv_fcvtsw rs1) (fpu_rr (FpuOPRR.FcvtSw) $F32 rs1))
+(decl rv_fcvtsw (FRM XReg) FReg)
+(rule (rv_fcvtsw frm rs1) (fpu_rr (FpuOPRR.FcvtFmtW) $F32 frm rs1))
 
 ;; Helper for emitting the `fcvt.s.wu` instruction.
-(decl rv_fcvtswu (XReg) FReg)
-(rule (rv_fcvtswu rs1) (fpu_rr (FpuOPRR.FcvtSwU) $F32 rs1))
+(decl rv_fcvtswu (FRM XReg) FReg)
+(rule (rv_fcvtswu frm rs1) (fpu_rr (FpuOPRR.FcvtFmtWu) $F32 frm rs1))
 
 ;; Helper for emitting the `fcvt.d.w` instruction.
 (decl rv_fcvtdw (XReg) FReg)
-(rule (rv_fcvtdw rs1) (fpu_rr (FpuOPRR.FcvtDW) $F32 rs1))
+(rule (rv_fcvtdw rs1) (fpu_rr (FpuOPRR.FcvtFmtW) $F64 (FRM.RNE) rs1))
 
 ;; Helper for emitting the `fcvt.d.wu` instruction.
 (decl rv_fcvtdwu (XReg) FReg)
-(rule (rv_fcvtdwu rs1) (fpu_rr (FpuOPRR.FcvtDWU) $F32 rs1))
+(rule (rv_fcvtdwu rs1) (fpu_rr (FpuOPRR.FcvtFmtWu) $F64 (FRM.RNE) rs1))
 
 ;; Helper for emitting the `fcvt.s.l` instruction.
-(decl rv_fcvtsl (XReg) FReg)
-(rule (rv_fcvtsl rs1) (fpu_rr (FpuOPRR.FcvtSL) $F32 rs1))
+(decl rv_fcvtsl (FRM XReg) FReg)
+(rule (rv_fcvtsl frm rs1) (fpu_rr (FpuOPRR.FcvtFmtL) $F32 frm rs1))
 
 ;; Helper for emitting the `fcvt.s.lu` instruction.
-(decl rv_fcvtslu (XReg) FReg)
-(rule (rv_fcvtslu rs1) (fpu_rr (FpuOPRR.FcvtSLU) $F32 rs1))
+(decl rv_fcvtslu (FRM XReg) FReg)
+(rule (rv_fcvtslu frm rs1) (fpu_rr (FpuOPRR.FcvtFmtLu) $F32 frm rs1))
 
 ;; Helper for emitting the `fcvt.d.l` instruction.
-(decl rv_fcvtdl (XReg) FReg)
-(rule (rv_fcvtdl rs1) (fpu_rr (FpuOPRR.FcvtDL) $F32 rs1))
+(decl rv_fcvtdl (FRM XReg) FReg)
+(rule (rv_fcvtdl frm rs1) (fpu_rr (FpuOPRR.FcvtFmtL) $F64 frm rs1))
 
 ;; Helper for emitting the `fcvt.d.lu` instruction.
-(decl rv_fcvtdlu (XReg) FReg)
-(rule (rv_fcvtdlu rs1) (fpu_rr (FpuOPRR.FcvtDLu) $F32 rs1))
+(decl rv_fcvtdlu (FRM XReg) FReg)
+(rule (rv_fcvtdlu frm rs1) (fpu_rr (FpuOPRR.FcvtFmtLu) $F64 frm rs1))
+
+;; Helper for emitting the `fcvt.w.s` instruction.
+(decl rv_fcvtws (FRM FReg) XReg)
+(rule (rv_fcvtws frm rs1) (fpu_rr_int (FpuOPRR.FcvtWFmt) $F32 frm rs1))
+
+;; Helper for emitting the `fcvt.l.s` instruction.
+(decl rv_fcvtls (FRM FReg) XReg)
+(rule (rv_fcvtls frm rs1) (fpu_rr_int (FpuOPRR.FcvtLFmt) $F32 frm rs1))
+
+;; Helper for emitting the `fcvt.wu.s` instruction.
+(decl rv_fcvtwus (FRM FReg) XReg)
+(rule (rv_fcvtwus frm rs1) (fpu_rr_int (FpuOPRR.FcvtWuFmt) $F32 frm rs1))
+
+;; Helper for emitting the `fcvt.lu.s` instruction.
+(decl rv_fcvtlus (FRM FReg) XReg)
+(rule (rv_fcvtlus frm rs1) (fpu_rr_int (FpuOPRR.FcvtLuFmt) $F32 frm rs1))
+
+;; Helper for emitting the `fcvt.w.d` instruction.
+(decl rv_fcvtwd (FRM FReg) XReg)
+(rule (rv_fcvtwd frm rs1) (fpu_rr_int (FpuOPRR.FcvtWFmt) $F64 frm rs1))
+
+;; Helper for emitting the `fcvt.l.d` instruction.
+(decl rv_fcvtld (FRM FReg) XReg)
+(rule (rv_fcvtld frm rs1) (fpu_rr_int (FpuOPRR.FcvtLFmt) $F64 frm rs1))
+
+;; Helper for emitting the `fcvt.wu.d` instruction.
+(decl rv_fcvtwud (FRM FReg) XReg)
+(rule (rv_fcvtwud frm rs1) (fpu_rr_int (FpuOPRR.FcvtWuFmt) $F64 frm rs1))
+
+;; Helper for emitting the `fcvt.lu.d` instruction.
+(decl rv_fcvtlud (FRM FReg) XReg)
+(rule (rv_fcvtlud frm rs1) (fpu_rr_int (FpuOPRR.FcvtLuFmt) $F64 frm rs1))
+
+;; Helper for emitting the `fcvt.w.*` instructions.
+(decl rv_fcvtw (Type FRM FReg) XReg)
+(rule (rv_fcvtw $F32 frm rs1) (rv_fcvtws frm rs1))
+(rule (rv_fcvtw $F64 frm rs1) (rv_fcvtwd frm rs1))
+
+;; Helper for emitting the `fcvt.l.*` instructions.
+(decl rv_fcvtl (Type FRM FReg) XReg)
+(rule (rv_fcvtl $F32 frm rs1) (rv_fcvtls frm rs1))
+(rule (rv_fcvtl $F64 frm rs1) (rv_fcvtld frm rs1))
+
+;; Helper for emitting the `fcvt.wu.*` instructions.
+(decl rv_fcvtwu (Type FRM FReg) XReg)
+(rule (rv_fcvtwu $F32 frm rs1) (rv_fcvtwus frm rs1))
+(rule (rv_fcvtwu $F64 frm rs1) (rv_fcvtwud frm rs1))
+
+;; Helper for emitting the `fcvt.lu.*` instructions.
+(decl rv_fcvtlu (Type FRM FReg) XReg)
+(rule (rv_fcvtlu $F32 frm rs1) (rv_fcvtlus frm rs1))
+(rule (rv_fcvtlu $F64 frm rs1) (rv_fcvtlud frm rs1))
 
 ;; Helper for emitting the `fsgnj` ("Floating Point Sign Injection") instruction.
 ;; The output of this instruction is `rs1` with the sign bit from `rs2`
 ;; This implements the `copysign` operation
 (decl rv_fsgnj (Type FReg FReg) FReg)
-(rule (rv_fsgnj $F32 rs1 rs2) (fpu_rrr (FpuOPRRR.FsgnjS) $F32 rs1 rs2))
-(rule (rv_fsgnj $F64 rs1 rs2) (fpu_rrr (FpuOPRRR.FsgnjD) $F64 rs1 rs2))
+(rule (rv_fsgnj ty rs1 rs2) (fpu_rrr (FpuOPRRR.Fsgnj) ty (FRM.RNE) rs1 rs2))
 
 ;; Helper for emitting the `fsgnjn` ("Floating Point Sign Injection Negated") instruction.
 ;; The output of this instruction is `rs1` with the negated sign bit from `rs2`
 ;; When `rs1 == rs2` this implements the `neg` operation
 (decl rv_fsgnjn (Type FReg FReg) FReg)
-(rule (rv_fsgnjn $F32 rs1 rs2) (fpu_rrr (FpuOPRRR.FsgnjnS) $F32 rs1 rs2))
-(rule (rv_fsgnjn $F64 rs1 rs2) (fpu_rrr (FpuOPRRR.FsgnjnD) $F64 rs1 rs2))
+(rule (rv_fsgnjn ty rs1 rs2) (fpu_rrr (FpuOPRRR.Fsgnjn) ty (FRM.RTZ) rs1 rs2))
 
 ;; Helper for emitting the `fneg` ("Floating Point Negate") instruction.
 ;; This instruction is a mnemonic for `fsgnjn rd, rs1, rs1`
@@ -1494,8 +1506,7 @@
 ;; The output of this instruction is `rs1` with the XOR of the sign bits from `rs1` and `rs2`.
 ;; When `rs1 == rs2` this implements `fabs`
 (decl rv_fsgnjx (Type FReg FReg) FReg)
-(rule (rv_fsgnjx $F32 rs1 rs2) (fpu_rrr (FpuOPRRR.FsgnjxS) $F32 rs1 rs2))
-(rule (rv_fsgnjx $F64 rs1 rs2) (fpu_rrr (FpuOPRRR.FsgnjxD) $F64 rs1 rs2))
+(rule (rv_fsgnjx ty rs1 rs2) (fpu_rrr (FpuOPRRR.Fsgnjx) ty (FRM.RDN) rs1 rs2))
 
 ;; Helper for emitting the `fabs` ("Floating Point Absolute") instruction.
 ;; This instruction is a mnemonic for `fsgnjx rd, rs1, rs1`
@@ -1504,18 +1515,15 @@
 
 ;; Helper for emitting the `feq` ("Float Equal") instruction.
 (decl rv_feq (Type FReg FReg) XReg)
-(rule (rv_feq $F32 rs1 rs2) (fpu_rrr (FpuOPRRR.FeqS) $I64 rs1 rs2))
-(rule (rv_feq $F64 rs1 rs2) (fpu_rrr (FpuOPRRR.FeqD) $I64 rs1 rs2))
+(rule (rv_feq ty rs1 rs2) (fpu_rrr_int (FpuOPRRR.Feq) ty (FRM.RDN) rs1 rs2))
 
 ;; Helper for emitting the `flt` ("Float Less Than") instruction.
 (decl rv_flt (Type FReg FReg) XReg)
-(rule (rv_flt $F32 rs1 rs2) (fpu_rrr (FpuOPRRR.FltS) $I64 rs1 rs2))
-(rule (rv_flt $F64 rs1 rs2) (fpu_rrr (FpuOPRRR.FltD) $I64 rs1 rs2))
+(rule (rv_flt ty rs1 rs2) (fpu_rrr_int (FpuOPRRR.Flt) ty (FRM.RTZ) rs1 rs2))
 
 ;; Helper for emitting the `fle` ("Float Less Than or Equal") instruction.
 (decl rv_fle (Type FReg FReg) XReg)
-(rule (rv_fle $F32 rs1 rs2) (fpu_rrr (FpuOPRRR.FleS) $I64 rs1 rs2))
-(rule (rv_fle $F64 rs1 rs2) (fpu_rrr (FpuOPRRR.FleD) $I64 rs1 rs2))
+(rule (rv_fle ty rs1 rs2) (fpu_rrr_int (FpuOPRRR.Fle) ty (FRM.RNE) rs1 rs2))
 
 ;; Helper for emitting the `fgt` ("Float Greater Than") instruction.
 ;; Note: The arguments are reversed
@@ -1527,6 +1535,36 @@
 (decl rv_fge (Type FReg FReg) XReg)
 (rule (rv_fge ty rs1 rs2) (rv_fle ty rs2 rs1))
 
+;; Helper for emitting the `fmin` instruction.
+(decl rv_fmin (Type FReg FReg) FReg)
+(rule (rv_fmin ty rs1 rs2) (fpu_rrr (FpuOPRRR.Fmin) ty (FRM.RNE) rs1 rs2))
+
+;; Helper for emitting the `fmax` instruction.
+(decl rv_fmax (Type FReg FReg) FReg)
+(rule (rv_fmax ty rs1 rs2) (fpu_rrr (FpuOPRRR.Fmax) ty (FRM.RTZ) rs1 rs2))
+
+;; `Zfa` Extension Instructions
+
+;; Helper for emitting the `fminm` instruction.
+(decl rv_fminm (Type FReg FReg) FReg)
+(rule (rv_fminm ty rs1 rs2) (fpu_rrr (FpuOPRRR.Fminm) ty (FRM.RDN) rs1 rs2))
+
+;; Helper for emitting the `fmaxm` instruction.
+(decl rv_fmaxm (Type FReg FReg) FReg)
+(rule (rv_fmaxm ty rs1 rs2) (fpu_rrr (FpuOPRRR.Fmaxm) ty (FRM.RUP) rs1 rs2))
+
+;; Helper for emitting the `fround` instruction.
+(decl rv_fround (Type FRM FReg) FReg)
+(rule (rv_fround ty frm rs) (fpu_rr (FpuOPRR.Fround) ty frm rs))
+
+;; Helper for emitting the `fli` instruction.
+(decl rv_fli (Type FliConstant) FReg)
+(rule (rv_fli ty imm)
+      (let ((dst WritableFReg (temp_writable_freg))
+            (_ Unit (emit (MInst.Fli ty
+                                     imm
+                                     dst))))
+        dst))
 
 ;; `Zba` Extension Instructions
 
@@ -1556,7 +1594,11 @@
 ;; rd ← rs1 ∧ ~(rs2)
 (decl rv_andn (XReg XReg) XReg)
 (rule (rv_andn rs1 rs2)
+  (if-let $true (has_zbb))
   (alu_rrr (AluOPRRR.Andn) rs1 rs2))
+(rule (rv_andn rs1 rs2)
+  (if-let $false (has_zbb))
+  (rv_and rs1 (rv_not rs2)))
 
 ;; Helper for emitting the `orn` ("Or Negated") instruction.
 ;; rd ← rs1 ∨ ~(rs2)
@@ -1564,6 +1606,12 @@
 (rule (rv_orn rs1 rs2)
   (alu_rrr (AluOPRRR.Orn) rs1 rs2))
 
+;; Helper for emitting the `xnor` ("Exclusive NOR") instruction.
+;; rd ← ~(rs1 ^ rs2)
+(decl rv_xnor (XReg XReg) XReg)
+(rule (rv_xnor rs1 rs2)
+  (alu_rrr (AluOPRRR.Xnor) rs1 rs2))
+
 ;; Helper for emitting the `clz` ("Count Leading Zero Bits") instruction.
 (decl rv_clz (XReg) XReg)
 (rule (rv_clz rs1)
@@ -1599,6 +1647,21 @@
 (rule (rv_max rs1 rs2)
   (alu_rrr (AluOPRRR.Max) rs1 rs2))
 
+;; Helper for emitting the `maxu` instruction.
+(decl rv_maxu (XReg XReg) XReg)
+(rule (rv_maxu rs1 rs2)
+  (alu_rrr (AluOPRRR.Maxu) rs1 rs2))
+
+;; Helper for emitting the `min` instruction.
+(decl rv_min (XReg XReg) XReg)
+(rule (rv_min rs1 rs2)
+  (alu_rrr (AluOPRRR.Min) rs1 rs2))
+
+;; Helper for emitting the `minu` instruction.
+(decl rv_minu (XReg XReg) XReg)
+(rule (rv_minu rs1 rs2)
+  (alu_rrr (AluOPRRR.Minu) rs1 rs2))
+
 ;; Helper for emitting the `sext.b` instruction.
 (decl rv_sextb (XReg) XReg)
 (rule (rv_sextb rs1)
@@ -1634,6 +1697,16 @@
 (rule (rv_rorw rs1 rs2)
   (alu_rrr (AluOPRRR.Rorw) rs1 rs2))
 
+;; Helper for emitting the `rori` ("Rotate Right") instruction.
+(decl rv_rori (XReg Imm12) XReg)
+(rule (rv_rori rs1 rs2)
+  (alu_rr_imm12 (AluOPRRI.Rori) rs1 rs2))
+
+;; Helper for emitting the `roriw` ("Rotate Right Word") instruction.
+(decl rv_roriw (XReg Imm12) XReg)
+(rule (rv_roriw rs1 rs2)
+  (alu_rr_imm12 (AluOPRRI.Roriw) rs1 rs2))
+
 ;; Helper for emitting the `rev8` ("Byte Reverse") instruction.
 (decl rv_rev8 (XReg) XReg)
 (rule (rv_rev8 rs1)
@@ -1647,12 +1720,41 @@
 (rule (rv_brev8 rs1)
   (alu_rr_funct12 (AluOPRRI.Brev8) rs1))
 
+;; `Zbs` Extension Instructions
+
+(decl rv_bclr (XReg XReg) XReg)
+(rule (rv_bclr rs1 rs2)
+  (alu_rrr (AluOPRRR.Bclr) rs1 rs2))
+
+(decl rv_bclri (XReg Imm12) XReg)
+(rule (rv_bclri rs1 imm)
+  (alu_rr_imm12 (AluOPRRI.Bclri) rs1 imm))
+
+(decl rv_bext (XReg XReg) XReg)
+(rule (rv_bext rs1 rs2)
+  (alu_rrr (AluOPRRR.Bext) rs1 rs2))
+
+(decl rv_bexti (XReg Imm12) XReg)
+(rule (rv_bexti rs1 imm)
+  (alu_rr_imm12 (AluOPRRI.Bexti) rs1 imm))
+
+(decl rv_binv (XReg XReg) XReg)
+(rule (rv_binv rs1 rs2)
+  (alu_rrr (AluOPRRR.Binv) rs1 rs2))
+
+(decl rv_binvi (XReg Imm12) XReg)
+(rule (rv_binvi rs1 imm)
+  (alu_rr_imm12 (AluOPRRI.Binvi) rs1 imm))
+
+(decl rv_bset (XReg XReg) XReg)
+(rule (rv_bset rs1 rs2)
+  (alu_rrr (AluOPRRR.Bset) rs1 rs2))
+
 ;; Helper for emitting the `bseti` ("Single-Bit Set Immediate") instruction.
 (decl rv_bseti (XReg Imm12) XReg)
 (rule (rv_bseti rs1 imm)
   (alu_rr_imm12 (AluOPRRI.Bseti) rs1 imm))
 
-
 ;; `Zbkb` Extension Instructions
 
 ;; Helper for emitting the `pack` ("Pack low halves of registers") instruction.
@@ -1665,6 +1767,26 @@
 (rule (rv_packw rs1 rs2)
   (alu_rrr (AluOPRRR.Packw) rs1 rs2))
 
+;; `ZiCond` Extension Instructions
+
+;; Helper for emitting the `czero.eqz` ("Conditional zero, if condition is equal to zero") instruction.
+;; RS1 is the data source
+;; RS2 is the condition
+;;
+;; rd = (rs2 == 0) ? 0 : rs1
+(decl rv_czero_eqz (XReg XReg) XReg)
+(rule (rv_czero_eqz rs1 rs2)
+  (alu_rrr (AluOPRRR.CzeroEqz) rs1 rs2))
+
+;; Helper for emitting the `czero.nez` ("Conditional zero, if condition is nonzero") instruction.
+;; RS1 is the data source
+;; RS2 is the condition
+;;
+;; rd = (rs2 != 0) ? 0 : rs1
+(decl rv_czero_nez (XReg XReg) XReg)
+(rule (rv_czero_nez rs1 rs2)
+  (alu_rrr (AluOPRRR.CzeroNez) rs1 rs2))
+
 
 ;; `Zicsr` Extension Instructions
 
@@ -1692,9 +1814,14 @@
 
 
 
-;; Generate a mask for the bit-width of the given type
-(decl pure shift_mask (Type) u64)
-(rule (shift_mask ty) (u64_sub (ty_bits (lane_type ty)) 1))
+
+;; Helper for generating a FliConstant from a u64 constant
+(decl pure partial fli_constant_from_u64 (Type u64) FliConstant)
+(extern constructor fli_constant_from_u64 fli_constant_from_u64)
+
+;; Helper for generating a FliConstant from a u64 negated constant
+(decl pure partial fli_constant_from_negated_u64 (Type u64) FliConstant)
+(extern constructor fli_constant_from_negated_u64 fli_constant_from_negated_u64)
 
 ;; Helper for generating a i64 from a pair of Imm20 and Imm12 constants
 (decl i64_generate_imm (Imm20 Imm12) i64)
@@ -1713,13 +1840,32 @@
 ;; TODO: Load floats using `fld` instead of `ld`
 (decl imm (Type u64) Reg)
 
-;; Refs get loaded as integers.
-(rule 5 (imm $R32 c) (imm $I32 c))
-(rule 5 (imm $R64 c) (imm $I64 c))
+;; Special-case 0.0 for floats to use the `(zero_reg)` directly.
+;; See #7162 for why this doesn't fall out of the rules below.
+(rule 9 (imm (ty_supported_float $F16) 0) (gen_bitcast (zero_reg) $I16 $F16))
+(rule 9 (imm (ty_supported_float $F32) 0) (gen_bitcast (zero_reg) $I32 $F32))
+(rule 9 (imm (ty_supported_float $F64) 0) (gen_bitcast (zero_reg) $I64 $F64))
 
-;; Floats get loaded as integers and then moved into an F register.
-(rule 5 (imm $F32 c) (gen_bitcast (imm $I32 c) $I32 $F32))
-(rule 5 (imm $F64 c) (gen_bitcast (imm $I64 c) $I64 $F64))
+;; If Zfa is enabled, we can load certain constants with the `fli` instruction.
+(rule 8 (imm (ty_supported_float (ty_32_or_64 ty)) imm)
+  (if-let $true (has_zfa))
+  (if-let const (fli_constant_from_u64 ty imm))
+  (rv_fli ty const))
+
+;; It is beneficial to load the negated constant with `fli` and then negate it
+;; in a register.
+;;
+;; For f64's this saves one instruction, and for f32's it avoids
+;; having to allocate an integer register, reducing integer register pressure.
+(rule 7 (imm (ty_supported_float (ty_32_or_64 ty)) imm)
+  (if-let $true (has_zfa))
+  (if-let const (fli_constant_from_negated_u64 ty imm))
+  (rv_fneg ty (rv_fli ty const)))
+
+;; Otherwise floats get loaded as integers and then moved into an F register.
+(rule 6 (imm (ty_supported_float $F16) c) (gen_bitcast (imm $I16 c) $I16 $F16))
+(rule 6 (imm (ty_supported_float $F32) c) (gen_bitcast (imm $I32 c) $I32 $F32))
+(rule 6 (imm (ty_supported_float $F64) c) (gen_bitcast (imm $I64 c) $I64 $F64))
 
 ;; Try to match just an imm12
 (rule 4 (imm (ty_int ty) c)
@@ -1784,6 +1930,10 @@
 (decl imm12_const_add (i32 i32) Imm12)
 (extern constructor imm12_const_add imm12_const_add)
 
+;; Performs a fallible add of the `Imm12` value and the 32-bit value provided.
+(decl pure partial imm12_add (Imm12 i32) Imm12)
+(extern constructor imm12_add imm12_add)
+
 (decl imm12_and (Imm12 u64) Imm12)
 (extern constructor imm12_and imm12_and)
 
@@ -1793,6 +1943,14 @@
 (decl imm12_from_value (Imm12) Value)
 (extractor (imm12_from_value n) (i64_from_iconst (imm12_from_i64 n)))
 
+;; Conceptually the same as `imm12_from_value`, but tries negating the constant
+;; value (first sign-extending to handle narrow widths).
+(decl pure partial imm12_from_negated_value (Value) Imm12)
+(rule
+  (imm12_from_negated_value (has_type ty (iconst _ n)))
+  (if-let (imm12_from_u64 imm) (i64_as_u64 (i64_neg (i64_sextend_imm64 ty n))))
+  imm)
+
 (decl imm12_from_u64 (Imm12) u64)
 (extern extractor imm12_from_u64 imm12_from_u64)
 
@@ -1830,10 +1988,20 @@
 (decl pure partial i8_to_imm5 (i8) Imm5)
 (extern constructor i8_to_imm5 i8_to_imm5)
 
+;; Helper to go directly from a `Value` to an `Imm5`.
+(decl imm5_from_value (Imm5) Value)
+(extractor (imm5_from_value n) (i64_from_iconst (imm5_from_i64 n)))
+
+;; Like imm5_from_value, but first negates the `Value`.
+(decl pure partial imm5_from_negated_value (Value) Imm5)
+(rule (imm5_from_negated_value (has_type ty (iconst _ n)))
+  (if-let (imm5_from_i64 imm) (i64_neg (i64_sextend_imm64 ty n)))
+  imm)
+
 ;; Constructor that matches a `Value` equivalent to a replicated Imm5 on all lanes.
 (decl pure partial replicated_imm5 (Value) Imm5)
-(rule (replicated_imm5 (splat (i64_from_iconst (imm5_from_i64 n)))) n)
-(rule (replicated_imm5 (vconst (u128_from_constant n128)))
+(rule (replicated_imm5 (splat _ (imm5_from_value n))) n)
+(rule (replicated_imm5 (vconst _ (u128_from_constant n128)))
   (if-let (u128_replicated_u64 n64) n128)
   (if-let (u64_replicated_u32 n32) n64)
   (if-let (u32_replicated_u16 n16) n32)
@@ -1841,12 +2009,25 @@
   (if-let n (i8_to_imm5 (u8_as_i8 n8)))
   n)
 
+;; Like replicated_imm5, but first negates the `Value`.
+(decl pure partial negated_replicated_imm5 (Value) Imm5)
+(rule (negated_replicated_imm5 (splat _ n))
+  (if-let imm5 (imm5_from_negated_value n))
+  imm5)
+(rule (negated_replicated_imm5 (vconst _ (u128_from_constant n128)))
+  (if-let (u128_replicated_u64 n64) n128)
+  (if-let (u64_replicated_u32 n32) n64)
+  (if-let (u32_replicated_u16 n16) n32)
+  (if-let (u16_replicated_u8 n8) n16)
+  (if-let n (i8_to_imm5 (i8_neg (u8_as_i8 n8))))
+  n)
+
 ;; UImm5 Helpers
 
 ;; Constructor that matches a `Value` equivalent to a replicated UImm5 on all lanes.
 (decl pure partial replicated_uimm5 (Value) UImm5)
-(rule (replicated_uimm5 (splat (uimm5_from_value n))) n)
-(rule 1 (replicated_uimm5 (vconst (u128_from_constant n128)))
+(rule (replicated_uimm5 (splat _ (uimm5_from_value n))) n)
+(rule 1 (replicated_uimm5 (vconst _ (u128_from_constant n128)))
   (if-let (u128_replicated_u64 n64) n128)
   (if-let (u64_replicated_u32 n32) n64)
   (if-let (u32_replicated_u16 n16) n32)
@@ -1857,7 +2038,7 @@
 ;; Helper to go directly from a `Value`, when it's an `iconst`, to an `UImm5`.
 (decl uimm5_from_value (UImm5) Value)
 (extractor (uimm5_from_value n)
-  (iconst (u64_from_imm64 (uimm5_from_u64 n))))
+  (iconst _ (u64_from_imm64 (uimm5_from_u64 n))))
 
 ;; Extract a `UImm5` from an `u8`.
 (decl pure partial uimm5_from_u8 (UImm5) u8)
@@ -1881,14 +2062,18 @@
 (rule (canonical_nan_u64 $F32) 0x7fc00000)
 (rule (canonical_nan_u64 $F64) 0x7ff8000000000000)
 
-(decl gen_default_frm () OptionFloatRoundingMode)
-(extern constructor gen_default_frm gen_default_frm)
-
 ;; Helper for emitting `MInst.FpuRR` instructions.
-(decl fpu_rr (FpuOPRR Type Reg) Reg)
-(rule (fpu_rr op ty src)
-      (let ((dst WritableReg (temp_writable_reg ty))
-            (_ Unit (emit (MInst.FpuRR op (gen_default_frm) dst src))))
+(decl fpu_rr (FpuOPRR Type FRM Reg) FReg)
+(rule (fpu_rr op ty frm src)
+      (let ((dst WritableFReg (temp_writable_freg))
+            (_ Unit (emit (MInst.FpuRR op ty frm dst src))))
+        dst))
+
+;; Similar to fpu_rr but with an integer destination register
+(decl fpu_rr_int (FpuOPRR Type FRM Reg) XReg)
+(rule (fpu_rr_int op ty frm src)
+      (let ((dst WritableXReg (temp_writable_xreg))
+            (_ Unit (emit (MInst.FpuRR op ty frm dst src))))
         dst))
 
 ;; Helper for emitting `MInst.AluRRR` instructions.
@@ -1898,18 +2083,25 @@
             (_ Unit (emit (MInst.AluRRR op dst src1 src2))))
         dst))
 
-;; Helper for emitting `MInst.AluRRR` instructions.
-(decl fpu_rrr (FpuOPRRR Type Reg Reg) Reg)
-(rule (fpu_rrr op ty src1 src2)
-      (let ((dst WritableReg (temp_writable_reg ty))
-            (_ Unit (emit (MInst.FpuRRR op (gen_default_frm) dst src1 src2))))
+;; Helper for emitting `MInst.FpuRRR` instructions.
+(decl fpu_rrr (FpuOPRRR Type FRM Reg Reg) FReg)
+(rule (fpu_rrr op ty frm src1 src2)
+      (let ((dst WritableFReg (temp_writable_freg))
+            (_ Unit (emit (MInst.FpuRRR op ty frm dst src1 src2))))
+        dst))
+
+;; Similar to fpu_rrr but with an integer destination register
+(decl fpu_rrr_int (FpuOPRRR Type FRM Reg Reg) XReg)
+(rule (fpu_rrr_int op ty frm src1 src2)
+      (let ((dst WritableXReg (temp_writable_xreg))
+            (_ Unit (emit (MInst.FpuRRR op ty frm dst src1 src2))))
         dst))
 
 ;; Helper for emitting `MInst.FpuRRRR` instructions.
-(decl fpu_rrrr (FpuOPRRRR Type Reg Reg Reg) Reg)
-(rule (fpu_rrrr op ty src1 src2 src3)
-      (let ((dst WritableReg (temp_writable_reg ty))
-            (_ Unit (emit (MInst.FpuRRRR op (gen_default_frm) dst src1 src2 src3))))
+(decl fpu_rrrr (FpuOPRRRR Type FRM Reg Reg Reg) FReg)
+(rule (fpu_rrrr op ty frm src1 src2 src3)
+      (let ((dst WritableFReg (temp_writable_freg))
+            (_ Unit (emit (MInst.FpuRRRR op ty frm dst src1 src2 src3))))
         dst))
 
 
@@ -1921,7 +2113,7 @@
         dst))
 
 ;; some instruction use imm12 as funct12.
-;; so we don't need the imm12 paramter.
+;; so we don't need the imm12 parameter.
 (decl alu_rr_funct12 (AluOPRRI Reg) Reg)
 (rule (alu_rr_funct12 op src)
       (let ((dst WritableXReg (temp_writable_xreg))
@@ -1956,33 +2148,6 @@
 (rule (select_addi (fits_in_64 ty)) (AluOPRRI.Addi))
 
 
-(decl gen_bnot (Type ValueRegs) ValueRegs)
-(rule 2 (gen_bnot (ty_scalar_float ty) x)
-  (let ((val FReg (value_regs_get x 0))
-        (x_val XReg (move_f_to_x val ty))
-        (inverted XReg (rv_not x_val))
-        (res FReg (move_x_to_f inverted (float_int_of_same_size ty))))
-    (value_reg res)))
-
-(rule 1 (gen_bnot $I128 x)
-  (let ((lo XReg (rv_not (value_regs_get x 0)))
-        (hi XReg (rv_not (value_regs_get x 1))))
-    (value_regs lo hi)))
-
-(rule 0 (gen_bnot (ty_int_ref_scalar_64 _) x)
-  (rv_not (value_regs_get x 0)))
-
-
-(decl gen_and (Type ValueRegs ValueRegs) ValueRegs)
-(rule 1 (gen_and $I128 x y)
-  (value_regs
-    (rv_and (value_regs_get x 0) (value_regs_get y 0))
-    (rv_and (value_regs_get x 1) (value_regs_get y 1))))
-
-(rule 0 (gen_and (fits_in_64 _) x y)
-  (rv_and (value_regs_get x 0) (value_regs_get y 0)))
-
-
 (decl gen_andi (XReg u64) XReg)
 (rule 1 (gen_andi x (imm12_from_u64 y))
   (rv_andi x y))
@@ -2000,34 +2165,6 @@
 (rule 0 (gen_or (fits_in_64 _) x y)
   (rv_or (value_regs_get x 0) (value_regs_get y 0)))
 
-(decl lower_bit_reverse (Reg Type) Reg)
-
-(rule
-  (lower_bit_reverse r $I8)
-  (gen_brev8 r $I8))
-
-(rule
-  (lower_bit_reverse r $I16)
-  (let
-    ((tmp XReg (gen_brev8 r $I16))
-      (tmp2 XReg (gen_rev8 tmp))
-      (result XReg (rv_srli tmp2 (imm12_const 48))))
-    result))
-
-(rule
-  (lower_bit_reverse r $I32)
-  (let
-    ((tmp XReg (gen_brev8 r $I32))
-      (tmp2 XReg (gen_rev8 tmp))
-      (result XReg (rv_srli tmp2 (imm12_const 32))))
-    result))
-
-(rule
-  (lower_bit_reverse r $I64)
-  (let
-    ((tmp XReg (gen_rev8 r)))
-    (gen_brev8 tmp $I64)))
-
 
 (decl lower_ctz (Type Reg) Reg)
 (rule (lower_ctz ty x)
@@ -2095,7 +2232,7 @@
 ;; Ignore sign extensions for values whose representation is already the full
 ;; register width.
 (rule 3 (zext val)
-  (if (val_already_extended val))
+  (if (val_already_extended (ExtendOp.Zero) val))
   val)
 
 ;; Performs a signed extension of the given value
@@ -2124,24 +2261,36 @@
 ;; Ignore sign extensions for values whose representation is already the full
 ;; register width.
 (rule 2 (sext val)
-  (if (val_already_extended val))
+  (if (val_already_extended (ExtendOp.Signed) val))
   val)
 
 ;; Helper matcher for when a value's representation is already sign or zero
 ;; extended to the full 64-bit register representation. This is used by `zext`
 ;; and `sext` above to skip the extension instruction entirely in some
 ;; circumstances.
-(decl pure partial val_already_extended (Value) bool)
-(rule 0 (val_already_extended v @ (value_type $I64)) $true)
+(decl pure partial val_already_extended (ExtendOp Value) bool)
+(rule 0 (val_already_extended _ v @ (value_type $I64)) $true)
 
 ;; When extending our backend always extends to the full register width, so
 ;; there's no need to extend-an-extend.
-(rule 1 (val_already_extended (uextend _)) $true)
-(rule 1 (val_already_extended (sextend _)) $true)
-
-;; The result of `icmp` is zero or one, meaning that it's already sign extended
-;; to the full register width.
-(rule 1 (val_already_extended (icmp _ _ _)) $true)
+(rule 1 (val_already_extended (ExtendOp.Zero) (uextend _ _)) $true)
+(rule 1 (val_already_extended (ExtendOp.Signed) (sextend _ _)) $true)
+
+;; The result of `icmp`/`fcmp` is zero or one, meaning that it's already sign
+;; extended to the full register width.
+(rule 1 (val_already_extended _ (icmp _ _ _ _)) $true)
+(rule 1 (val_already_extended _ (fcmp _ _ _ _)) $true)
+
+;; The lowering for these operations always sign-extend their results due to the
+;; use of the `*w` instructions in RV64I. Note that this requires that the
+;; extension is from 32 to 64, 16/8-bit operations are explicitly excluded here.
+;; There are no native instructions for the 16/8 bit operations so they must
+;; fall through to actual sign extension above.
+(rule 1 (val_already_extended (ExtendOp.Signed) (has_type $I32 (ishl _ _ _))) $true)
+(rule 1 (val_already_extended (ExtendOp.Signed) (has_type $I32 (ushr _ _ _))) $true)
+(rule 1 (val_already_extended (ExtendOp.Signed) (has_type $I32 (sshr _ _ _))) $true)
+(rule 1 (val_already_extended (ExtendOp.Signed) (has_type $I32 (iadd _ _ _))) $true)
+(rule 1 (val_already_extended (ExtendOp.Signed) (has_type $I32 (isub _ _ _))) $true)
 
 (type ExtendOp
   (enum
@@ -2169,101 +2318,12 @@
     ((tmp XReg (rv_mul rs1 rs2)))
     (rv_srli tmp (imm12_const (ty_bits ty)))))
 
-
-(decl lower_rotl (Type XReg XReg) XReg)
-
-(rule 1
-  (lower_rotl $I64 rs amount)
-  (if-let $true (has_zbb))
-  (rv_rol rs amount))
-
-(rule
-  (lower_rotl $I64 rs amount)
-  (if-let $false (has_zbb))
-  (lower_rotl_shift $I64 rs amount))
-
-(rule 1
-  (lower_rotl $I32 rs amount)
-  (if-let $true (has_zbb))
-  (rv_rolw rs amount))
-
-(rule
-  (lower_rotl $I32 rs amount)
-  (if-let $false (has_zbb))
-  (lower_rotl_shift $I32 rs amount))
-
-(rule -1
-  (lower_rotl ty rs amount)
-  (lower_rotl_shift ty rs amount))
-
-;;; using shift to implement rotl.
-(decl lower_rotl_shift (Type XReg XReg) XReg)
-
-;;; for I8 and I16 ...
-(rule
-  (lower_rotl_shift ty rs amount)
-  (let
-    ((x ValueRegs (gen_shamt ty amount))
-      (shamt Reg (value_regs_get x 0))
-      (len_sub_shamt Reg (value_regs_get x 1))
-      ;;
-      (part1 Reg (rv_sll rs shamt))
-      ;;
-      (part2 Reg (rv_srl rs len_sub_shamt))
-      (part3 Reg (gen_select_xreg (cmp_eqz shamt) (zero_reg) part2)))
-    (rv_or part1 part3)))
-
-
 ;;;; construct shift amount.rotl on i128 will use shift to implement. So can call this function.
 ;;;; this will return shift amount and (ty_bits - "shift amount")
 ;;;; if ty_bits is greater than 64 like i128, then shmat will fallback to 64.because We are 64 bit platform.
 (decl gen_shamt (Type XReg) ValueRegs)
 (extern constructor gen_shamt gen_shamt)
 
-(decl lower_rotr (Type XReg XReg) XReg)
-
-(rule 1
-  (lower_rotr $I64 rs amount)
-  (if-let $true (has_zbb))
-  (rv_ror rs amount))
-(rule
-  (lower_rotr $I64 rs amount)
-  (if-let $false (has_zbb))
-  (lower_rotr_shift $I64 rs amount))
-
-(rule 1
-  (lower_rotr $I32 rs amount)
-  (if-let $true (has_zbb))
-  (rv_rorw rs amount))
-
-(rule
-  (lower_rotr $I32 rs amount)
-  (if-let $false (has_zbb))
-  (lower_rotr_shift $I32 rs amount))
-
-(rule -1
-  (lower_rotr ty rs amount)
-  (lower_rotr_shift ty rs amount))
-
-(decl lower_rotr_shift (Type XReg XReg) XReg)
-
-;;;
-(rule
-  (lower_rotr_shift ty rs amount)
-  (let
-    ((x ValueRegs (gen_shamt ty amount))
-      (shamt XReg (value_regs_get x 0))
-      (len_sub_shamt XReg (value_regs_get x 1))
-      ;;
-      (part1 XReg (rv_srl rs shamt))
-      ;;
-      (part2 XReg (rv_sll rs len_sub_shamt))
-      ;;
-      (part3 XReg (gen_select_xreg (cmp_eqz shamt) (zero_reg) part2)))
-    (rv_or part1 part3)))
-
-
-
 ;; bseti: Set a single bit in a register, indexed by a constant.
 (decl gen_bseti (Reg u64) Reg)
 (rule (gen_bseti val bit)
@@ -2291,81 +2351,20 @@
       (_ Unit (emit (MInst.Popcnt sum step tmp rs $I64))))
     (writable_reg_to_reg sum)))
 
-
-(decl lower_i128_rotl (ValueRegs ValueRegs) ValueRegs)
-(rule
-  (lower_i128_rotl x y)
-  (let
-    ((tmp ValueRegs (gen_shamt $I128 (value_regs_get y 0)))
-      (shamt XReg (value_regs_get tmp 0))
-      (len_sub_shamt XReg (value_regs_get tmp 1))
-      ;;
-      (low_part1 XReg (rv_sll (value_regs_get x 0) shamt))
-      (low_part2 XReg (rv_srl (value_regs_get x 1) len_sub_shamt))
-      ;;; if shamt == 0 low_part2 will overflow we should zero instead.
-      (low_part3 XReg (gen_select_xreg (cmp_eqz shamt) (zero_reg) low_part2))
-      (low XReg (rv_or low_part1 low_part3))
-      ;;
-      (high_part1 XReg (rv_sll (value_regs_get x 1) shamt))
-      (high_part2 XReg (rv_srl (value_regs_get x 0) len_sub_shamt))
-      (high_part3 XReg (gen_select_xreg (cmp_eqz shamt) (zero_reg) high_part2))
-      (high XReg (rv_or high_part1 high_part3))
-      ;;
-      (const64 XReg (imm $I64 64))
-      (shamt_128 XReg (rv_andi (value_regs_get y 0) (imm12_const 127))))
-    ;; right now we only rotate less than 64 bits.
-    ;; if shamt is greater than or equal 64 , we should switch low and high.
-    (gen_select_regs
-      (cmp_geu shamt_128 const64)
-      (value_regs high low)
-      (value_regs low high)
-    )))
-
-
-(decl lower_i128_rotr (ValueRegs ValueRegs) ValueRegs)
-(rule
-  (lower_i128_rotr x y)
-  (let
-    ((tmp ValueRegs (gen_shamt $I128 (value_regs_get y 0)))
-      (shamt XReg (value_regs_get tmp 0))
-      (len_sub_shamt XReg (value_regs_get tmp 1))
-      ;;
-      (low_part1 XReg (rv_srl (value_regs_get x 0) shamt))
-      (low_part2 XReg (rv_sll (value_regs_get x 1) len_sub_shamt))
-      ;;; if shamt == 0 low_part2 will overflow we should zero instead.
-      (low_part3 XReg (gen_select_xreg (cmp_eqz shamt) (zero_reg) low_part2))
-      (low XReg (rv_or low_part1 low_part3))
-      ;;
-      (high_part1 XReg (rv_srl (value_regs_get x 1) shamt))
-      (high_part2 XReg (rv_sll (value_regs_get x 0) len_sub_shamt))
-      (high_part3 XReg (gen_select_xreg (cmp_eqz shamt) (zero_reg) high_part2))
-      (high XReg (rv_or high_part1 high_part3))
-
-      ;;
-      (const64 XReg (imm $I64 64))
-      (shamt_128 XReg (rv_andi (value_regs_get y 0) (imm12_const 127))))
-    ;; right now we only rotate less than 64 bits.
-    ;; if shamt is greater than or equal 64 , we should switch low and high.
-    (gen_select_regs
-      (cmp_geu shamt_128 const64)
-      (value_regs high low)
-      (value_regs low high)
-    )))
-
 ;; Generates a AMode that points to a register plus an offset.
-(decl gen_reg_offset_amode (Reg i64 Type) AMode)
+(decl gen_reg_offset_amode (Reg i64) AMode)
 (extern constructor gen_reg_offset_amode gen_reg_offset_amode)
 
 ;; Generates a AMode that an offset from the stack pointer.
-(decl gen_sp_offset_amode (i64 Type) AMode)
+(decl gen_sp_offset_amode (i64) AMode)
 (extern constructor gen_sp_offset_amode gen_sp_offset_amode)
 
 ;; Generates a AMode that an offset from the frame pointer.
-(decl gen_fp_offset_amode (i64 Type) AMode)
+(decl gen_fp_offset_amode (i64) AMode)
 (extern constructor gen_fp_offset_amode gen_fp_offset_amode)
 
 ;; Generates an AMode that points to a stack slot + offset.
-(decl gen_stack_slot_amode (StackSlot i64 Type) AMode)
+(decl gen_stack_slot_amode (StackSlot i64) AMode)
 (extern constructor gen_stack_slot_amode gen_stack_slot_amode)
 
 ;; Generates a AMode that points to a constant in the constant pool.
@@ -2375,61 +2374,103 @@
 
 
 ;; Tries to match a Value + Offset into an AMode
-(decl amode (Value i32 Type) AMode)
-(rule 0 (amode addr offset ty) (amode_inner addr offset ty))
+(decl amode (Value i32) AMode)
+(rule 0 (amode addr offset) (amode_inner addr offset))
 
 ;; If we are adding a constant offset with an iadd we can instead make that
 ;; offset part of the amode offset.
 ;;
 ;; We can't recurse into `amode` again since that could cause stack overflows.
 ;; See: https://github.com/bytecodealliance/wasmtime/pull/6968
-(rule 1 (amode (iadd addr (iconst (simm32 y))) offset ty)
+(rule 1 (amode (iadd _ addr (i32_from_iconst y)) offset)
   (if-let new_offset (s32_add_fallible y offset))
-  (amode_inner addr new_offset ty))
-(rule 2 (amode (iadd (iconst (simm32 x)) addr) offset ty)
+  (amode_inner addr new_offset))
+(rule 2 (amode (iadd _ (i32_from_iconst x) addr) offset)
   (if-let new_offset (s32_add_fallible x offset))
-  (amode_inner addr new_offset ty))
+  (amode_inner addr new_offset))
 
 
 ;; These are the normal rules for generating an AMode.
-(decl amode_inner (Value i32 Type) AMode)
+(decl amode_inner (Value i32) AMode)
 
 ;; In the simplest case we just lower into a Reg+Offset
-(rule 0 (amode_inner r @ (value_type (ty_addr64 _)) offset ty)
-  (gen_reg_offset_amode r offset ty))
+(rule 0 (amode_inner r @ (value_type (ty_addr64 _)) offset)
+  (gen_reg_offset_amode r offset))
 
 ;; If the value is a `get_frame_pointer`, we can just use the offset from that.
-(rule 1 (amode_inner (get_frame_pointer) offset ty)
-  (gen_fp_offset_amode offset ty))
+(rule 1 (amode_inner (get_frame_pointer _) offset)
+  (gen_fp_offset_amode offset))
 
 ;; If the value is a `get_stack_pointer`, we can just use the offset from that.
-(rule 1 (amode_inner (get_stack_pointer) offset ty)
-  (gen_sp_offset_amode offset ty))
+(rule 1 (amode_inner (get_stack_pointer _) offset)
+  (gen_sp_offset_amode offset))
 
 ;; Similarly if the value is a `stack_addr` we can also turn that into an sp offset.
-(rule 1 (amode_inner (stack_addr ss ss_offset) amode_offset ty)
+(rule 1 (amode_inner (stack_addr _ ss ss_offset) amode_offset)
   (if-let combined_offset (s32_add_fallible ss_offset amode_offset))
-  (gen_stack_slot_amode ss combined_offset ty))
+  (gen_stack_slot_amode ss combined_offset))
+
+
+;; Helpers for sinkable loads ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
+;; RISC-V doesen't really have sinkable loads. But the regular load instructions
+;; sign / zero extend their results to 64 bits. So we can pretend they are
+;; an extend instruction with a sinkable load. This allows us to have better
+;; lowerings on these cases.
 
+;; Extract a sinkable instruction from a value operand.
+(decl sinkable_inst (Inst) Value)
+(extern extractor sinkable_inst sinkable_inst)
 
+;; Matches a sinkable load.
+(decl sinkable_load (Inst Type MemFlags Value Offset32) Value)
+(extractor (sinkable_load inst ty flags addr offset)
+           (and
+              (load _ flags addr offset)
+              (sinkable_inst (has_type ty inst))))
 
 ;; Returns a canonical type for a LoadOP. We only return I64 or F64.
 (decl load_op_reg_type (LoadOP) Type)
 (rule 1 (load_op_reg_type (LoadOP.Fld)) $F64)
 (rule 1 (load_op_reg_type (LoadOP.Flw)) $F64)
+(rule 1 (load_op_reg_type (LoadOP.Flh)) $F64)
 (rule 0 (load_op_reg_type _) $I64)
 
-;; helper function to load from memory.
+;; Helper constructor to build a load instruction.
 (decl gen_load (AMode LoadOP MemFlags) Reg)
 (rule (gen_load amode op flags)
   (let ((dst WritableReg (temp_writable_reg (load_op_reg_type op)))
       (_ Unit (emit (MInst.Load dst op flags amode))))
     dst))
 
-;; helper function to store to memory.
-(decl gen_store (AMode StoreOP MemFlags Reg) InstOutput)
-(rule (gen_store amode op flags src)
+;; Similar to `gen_load` but marks `Inst` as sunk at the current point.
+;;
+;; This is only useful for load op's that perform some additional computation
+;; such as extending the loaded value.
+(decl gen_sunk_load (Inst AMode LoadOP MemFlags) Reg)
+(rule (gen_sunk_load inst amode op flags)
+  (let ((_ Unit (sink_inst inst)))
+        (gen_load amode op flags)))
+
+
+;; Helper constructor to build a store instruction.
+;;
+;; This helper contains a special-case for zero constants stored to memory to
+;; directly store the `zero` register to memory. See #7162 for some discussion
+;; on why this doesn't just fall out.
+(decl gen_store (AMode MemFlags Value) InstOutput)
+(rule 1 (gen_store amode flags val @ (value_type ty))
+  (if-let (u64_from_iconst 0) val)
+  (rv_store amode (store_op ty) flags (zero_reg)))
+(rule 0 (gen_store amode flags val @ (value_type ty))
+  (rv_store amode (store_op ty) flags val))
+
+;; Emit a raw instruction to store a register into memory.
+;;
+;; Note that the `src` operand must have the correct type for the `op`
+;; specified.
+(decl rv_store (AMode StoreOP MemFlags Reg) InstOutput)
+(rule (rv_store amode op flags src)
   (side_effect (SideEffectNoResult.Inst (MInst.Store amode op flags src))))
 
 
@@ -2542,15 +2583,115 @@
 )
 
 
+;; Rounds a FReg by converting the value into an integer and back with a specified
+;; float rounding mode.
+(decl float_round_fcvt (Type FRM FReg) FReg)
+(rule (float_round_fcvt $F32 frm rs) (rv_fcvtsw frm (rv_fcvtws frm rs)))
+(rule (float_round_fcvt $F64 frm rs) (rv_fcvtdl frm (rv_fcvtld frm rs)))
+
+(decl gen_float_round (FRM FReg Type) FReg)
+(rule 0 (gen_float_round frm rs ty)
+  (let (;; if rs is NaN/+-Infinity/+-Zero or if the exponent is larger than # of bits
+        ;; in mantissa, the result is the same as src, check for these cases first.
+        (max FReg (imm ty (float_int_max ty)))
+        (abs FReg (rv_fabs ty rs))
+        (exact XReg (rv_flt ty abs max))
+
+        ;; Manually round the value using the fcvt instructions
+        ;; to move the value to an integer register and back.
+        (fcvt FReg (float_round_fcvt ty frm rs))
+        ;; Restore the sign bit from the initial value.
+        (rounded FReg (rv_fsgnj ty fcvt rs))
+
+        ;; We want to return a arithmetic nan if the input is a canonical nan.
+        ;; Convert them by adding 0.0 to the input.
+        (float_zero FReg (gen_bitcast (zero_reg) (float_int_of_same_size ty) ty))
+        (corrected_nan FReg (rv_fadd ty (FRM.RNE) rs float_zero)))
+
+    ;; Check if the value cannot be rounded exactly and return the source input if so
+    (gen_select_freg (cmp_eqz exact) corrected_nan rounded)))
+
+;; With Zfa we can use the dedicated `fround` instruction.
+(rule 1 (gen_float_round frm rs ty)
+  (if-let $true (has_zfa))
+  (rv_fround ty frm rs))
+
+
+
 (decl gen_stack_addr (StackSlot Offset32) Reg)
 (extern constructor gen_stack_addr gen_stack_addr)
 
 (decl gen_select_xreg (IntegerCompare XReg XReg) XReg)
-(rule (gen_select_xreg c x y)
+
+(rule 6 (gen_select_xreg (int_compare_decompose cc x y) x y)
+  (if-let (IntCC.UnsignedLessThan) (intcc_without_eq cc))
+  (if-let $true (has_zbb))
+  (rv_minu x y))
+
+(rule 6 (gen_select_xreg (int_compare_decompose cc x y) x y)
+  (if-let (IntCC.SignedLessThan) (intcc_without_eq cc))
+  (if-let $true (has_zbb))
+  (rv_min x y))
+
+(rule 6 (gen_select_xreg (int_compare_decompose cc x y) x y)
+  (if-let (IntCC.UnsignedGreaterThan) (intcc_without_eq cc))
+  (if-let $true (has_zbb))
+  (rv_maxu x y))
+
+(rule 6 (gen_select_xreg (int_compare_decompose cc x y) x y)
+  (if-let (IntCC.SignedGreaterThan) (intcc_without_eq cc))
+  (if-let $true (has_zbb))
+  (rv_max x y))
+
+;; Rotate Zero Reg to the right. This allows us to write fewer rules
+;; below when matching the zero register
+;;
+;; Additionally prevent this rule from recursing infinitely by only
+;; matching when one of the inputs is the zero register, but not both.
+
+(rule 5 (gen_select_xreg (int_compare_decompose cc a @ (zero_reg) b @ (non_zero_reg)) x y)
+  (if-let $true (has_zicond))
+  (gen_select_xreg (int_compare (intcc_swap_args cc) b a) x y))
+
+(rule 4 (gen_select_xreg c @ (int_compare_decompose cc a b) x @ (zero_reg) y @ (non_zero_reg))
+  (if-let $true (has_zicond))
+  (gen_select_xreg (int_compare (intcc_complement cc) a b) y x))
+
+(rule 3 (gen_select_xreg (int_compare_decompose (IntCC.Equal) c (zero_reg)) x (zero_reg))
+  (if-let $true (has_zicond))
+  (rv_czero_nez x c))
+
+(rule 3 (gen_select_xreg (int_compare_decompose (IntCC.NotEqual) c (zero_reg)) x (zero_reg))
+  (if-let $true (has_zicond))
+  (rv_czero_eqz x c))
+
+(rule 2 (gen_select_xreg (int_compare_decompose (IntCC.Equal) c (zero_reg)) x y)
+  (if-let $true (has_zicond))
+  (rv_or
+    (rv_czero_nez x c)
+    (rv_czero_eqz y c)))
+
+(rule 2 (gen_select_xreg (int_compare_decompose (IntCC.NotEqual) c (zero_reg)) x y)
+  (if-let $true (has_zicond))
+  (rv_or
+    (rv_czero_eqz x c)
+    (rv_czero_nez y c)))
+
+;; It is still beneficial to emit the full compare instruction, and then the 3 instruction
+;; select using zicond, so do that here as a last resort.
+(rule 1 (gen_select_xreg compare x y)
+  (if-let $true (has_zicond))
+  (gen_select_xreg (cmp_nez (lower_int_compare compare)) x y))
+
+;; In the base case we emit a conditional branch and a few moves.
+
+(rule 0 (gen_select_xreg c x y)
   (let
     ((dst WritableReg (temp_writable_xreg))
      (_ Unit (emit (MInst.Select dst c x y))))
     (writable_reg_to_reg dst)))
+
+
 (decl gen_select_vreg (IntegerCompare VReg VReg) VReg)
 (rule (gen_select_vreg c x y)
   (let
@@ -2593,18 +2734,8 @@
             (_ Unit (emit (MInst.ElfTlsGetAddr dst name))))
         dst))
 
-;;;;
-(decl gen_fcvt_int (bool FReg bool Type Type) XReg)
-(rule
-  (gen_fcvt_int is_sat rs is_signed in_type out_type)
-  (let
-    ((result WritableReg (temp_writable_reg out_type))
-      (tmp WritableFReg (temp_writable_freg))
-      (_ Unit (emit (MInst.FcvtToInt is_sat result tmp rs is_signed in_type out_type))))
-    (writable_reg_to_reg result)))
-
 ;;; some float binary operation
-;;; 1. need move into x reister.
+;;; 1. need move into x register.
 ;;; 2. do the operation.
 ;;; 3. move back.
 (decl lower_float_binary (AluOPRRR FReg FReg Type) FReg)
@@ -2630,10 +2761,6 @@
       (high XReg (rv_sub high_tmp borrow)))
     (value_regs low high)))
 
-;; int scalar zero regs.
-(decl int_zero_reg (Type) ValueRegs)
-(extern constructor int_zero_reg int_zero_reg)
-
 ;; Consume a CmpResult, producing a branch on its result.
 (decl cond_br (IntegerCompare CondBrTarget CondBrTarget) SideEffectNoResult)
 (rule (cond_br cmp then else)
@@ -2649,6 +2776,10 @@
 (decl int_compare (IntCC XReg XReg) IntegerCompare)
 (extern constructor int_compare int_compare)
 
+;; Extract the components of an `IntegerCompare`
+(decl int_compare_decompose (IntCC XReg XReg) IntegerCompare)
+(extern extractor infallible int_compare_decompose int_compare_decompose)
+
 (decl label_to_br_target (MachLabel) CondBrTarget)
 (extern constructor label_to_br_target label_to_br_target)
 (convert MachLabel CondBrTarget label_to_br_target)
@@ -2698,7 +2829,7 @@
 ;; This is used in `Select` and `brif` for example to generate conditional
 ;; branches. The returned comparison, when taken, represents that `Value` is
 ;; nonzero. When not taken the input `Value` is zero.
-(decl lower_int_compare (Value) IntegerCompare)
+(decl is_nonzero_cmp (Value) IntegerCompare)
 
 ;; Base case - convert to a "truthy" value and compare it against zero.
 ;;
@@ -2709,46 +2840,72 @@
 ;; Additionally the base 64-bit ISA has a single instruction for sign-extending
 ;; from 32 to 64-bits which makes that a bit cheaper if used.
 ;; of registers sign-extend the results.
-(rule 0 (lower_int_compare val @ (value_type (fits_in_64 _)))
+(rule 0 (is_nonzero_cmp val @ (value_type (fits_in_64 _)))
   (cmp_nez (sext val)))
-(rule 1 (lower_int_compare val @ (value_type $I8))
+(rule 1 (is_nonzero_cmp val @ (value_type $I8))
   (cmp_nez (zext val)))
-(rule 1 (lower_int_compare val @ (value_type $I128))
+(rule 1 (is_nonzero_cmp val @ (value_type $I128))
   (cmp_nez (rv_or (value_regs_get val 0) (value_regs_get val 1))))
 
-;; If the input value is itself an `icmp` we can avoid generating the result of
-;; the `icmp` and instead move the comparison directly into the `IntegerCompare`
-;; that's returned. Note that comparisons compare full registers so
-;; sign-extension according to the integer comparison performed here is
-;; required.
+;; If the input value is itself an `icmp` or `fcmp` we can avoid generating the
+;; result of the comparison and instead move the comparison directly into the
+;; `IntegerCompare` that's returned.
+(rule 2 (is_nonzero_cmp (maybe_uextend (icmp _ cc a b @ (value_type (fits_in_64 _)))))
+  (icmp_to_int_compare cc a b))
+(rule 2 (is_nonzero_cmp (maybe_uextend (fcmp _ cc a @ (value_type ty) b)))
+  (fcmp_to_float_compare cc ty a b))
+
+;; Creates an `IntegerCompare` from an `icmp` node's parts. This will extend
+;; values as necessary to their full register width to perform the
+;; comparison. The returned `IntegerCompare` is suitable to use in conditional
+;; branches for example.
+;;
+;; Note that this should ideally only be used when the `IntegerCompare` returned
+;; is fed into a branch. If `IntegerCompare` is materialized this will miss out
+;; on optimizations to compare against constants using some native instructions.
+(decl icmp_to_int_compare (IntCC Value Value) IntegerCompare)
+(rule 0 (icmp_to_int_compare cc a b @ (value_type (fits_in_64 in_ty)))
+  (int_compare cc (put_value_in_reg_for_icmp cc a) (put_value_in_reg_for_icmp cc b)))
+(rule 1 (icmp_to_int_compare cc a b @ (value_type $I128))
+  (cmp_nez (lower_icmp_i128 cc a b)))
+
+;; Places a `Value` into a full register width to prepare for a comparison
+;; using `IntCC`.
 ;;
-;; Also note that as a small optimization `Equal` and `NotEqual` use
-;; sign-extension for 32-bit values since the same result is produced with
-;; either zero-or-sign extension and many values are already sign-extended given
-;; the RV64 instruction set (e.g. `addw` adds 32-bit values and sign extends),
-;; theoretically resulting in more efficient codegen.
-(rule 2 (lower_int_compare (maybe_uextend (icmp cc a b @ (value_type (fits_in_64 in_ty)))))
-  (int_compare cc (zext a) (zext b)))
-(rule 3 (lower_int_compare (maybe_uextend (icmp cc a b @ (value_type (fits_in_64 in_ty)))))
+;; This is largely a glorified means of choosing sign-extension or
+;; zero-extension for the `Value` input.
+(decl put_value_in_reg_for_icmp (IntCC Value) XReg)
+
+;; Base cases, use the `cc` to determine whether to zero or sign extend.
+(rule 0 (put_value_in_reg_for_icmp cc val)
+  (zext val))
+(rule 1 (put_value_in_reg_for_icmp cc val)
   (if (signed_cond_code cc))
-  (int_compare cc (sext a) (sext b)))
-(rule 4 (lower_int_compare (maybe_uextend (icmp cc @ (IntCC.Equal) a b @ (value_type $I32))))
-  (int_compare cc (sext a) (sext b)))
-(rule 4 (lower_int_compare (maybe_uextend (icmp cc @ (IntCC.NotEqual) a b @ (value_type $I32))))
-  (int_compare cc (sext a) (sext b)))
-
-;; If the input is an `fcmp` then the `FCmp` return value is directly
-;; convertible to `IntegerCompare` which can shave off an instruction from the
-;; fallback lowering above.
-(rule 2 (lower_int_compare (maybe_uextend (fcmp cc a @ (value_type ty) b)))
-  (emit_fcmp cc ty a b))
+  (sext val))
+
+;; For equality and inequality favor sign extension since it's generally
+;; easier to perform sign extension on RV64 via native instructions. For 8-bit
+;; types though use zero-extension since that's a single instruction `and`.
+(rule 2 (put_value_in_reg_for_icmp (IntCC.Equal) val @ (value_type (fits_in_64 _)))
+  (sext val))
+(rule 2 (put_value_in_reg_for_icmp (IntCC.NotEqual) val @ (value_type (fits_in_64 _)))
+  (sext val))
+(rule 3 (put_value_in_reg_for_icmp (IntCC.Equal) val @ (value_type $I8))
+  (zext val))
+(rule 3 (put_value_in_reg_for_icmp (IntCC.NotEqual) val @ (value_type $I8))
+  (zext val))
+
+;; As a special case use `x0` directly if a constant is 0.
+(rule 4 (put_value_in_reg_for_icmp _ (i64_from_iconst 0))
+  (zero_reg))
+
 
 (decl partial lower_branch (Inst MachLabelSlice) Unit)
 (rule (lower_branch (jump _) (single_target label))
       (emit_side_effect (rv_j label)))
 
 (rule (lower_branch (brif v _ _) (two_targets then else))
-  (emit_side_effect (cond_br (lower_int_compare v) then else)))
+  (emit_side_effect (cond_br (is_nonzero_cmp v) then else)))
 
 (decl lower_br_table (Reg MachLabelSlice) Unit)
 (extern constructor lower_br_table lower_br_table)
@@ -2763,8 +2920,18 @@
 ;; Generates a bitcast instruction.
 ;; Args are: src, src_ty, dst_ty
 (decl gen_bitcast (Reg Type Type) Reg)
+
+;; To support FP16 vfmv.* we need to check for the `zvfh` isa flag, which we currently don't
+;; support, so restrict the floating point types to 32/64 bits.
+(rule 5 (gen_bitcast r (ty_supported_float (ty_32_or_64 src_ty)) (ty_supported_vec _)) (rv_vfmv_sf r src_ty))
+(rule 4 (gen_bitcast r (ty_supported_vec _) (ty_supported_float (ty_32_or_64 dst_ty))) (rv_vfmv_fs r dst_ty))
+
+(rule 3 (gen_bitcast r (ty_int_ref_scalar_64 src_ty) (ty_supported_vec _)) (rv_vmv_sx r src_ty))
+(rule 2 (gen_bitcast r (ty_supported_vec _) (ty_int_ref_scalar_64 dst_ty)) (rv_vmv_xs r dst_ty))
+(rule 1 (gen_bitcast r $F16 $I16) (rv_fmvxh r))
 (rule 1 (gen_bitcast r $F32 $I32) (rv_fmvxw r))
 (rule 1 (gen_bitcast r $F64 $I64) (rv_fmvxd r))
+(rule 1 (gen_bitcast r $I16 $F16) (rv_fmvhx r))
 (rule 1 (gen_bitcast r $I32 $F32) (rv_fmvwx r))
 (rule 1 (gen_bitcast r $I64 $F64) (rv_fmvdx r))
 (rule (gen_bitcast r _ _) r)
@@ -2782,23 +2949,6 @@
 (rule (float_int_of_same_size $F64) $I64)
 
 
-(decl gen_rev8 (XReg) XReg)
-(rule 1
-  (gen_rev8 rs)
-  (if-let $true (has_zbb))
-  (rv_rev8 rs))
-
-(rule
-  (gen_rev8 rs)
-  (if-let $false (has_zbb))
-  (let
-    ((rd WritableXReg (temp_writable_xreg))
-      (tmp WritableXReg (temp_writable_xreg))
-      (step WritableXReg (temp_writable_xreg))
-      (_ Unit (emit (MInst.Rev8 rs step tmp rd))))
-    (writable_reg_to_reg rd)))
-
-
 (decl gen_brev8 (Reg Type) Reg)
 (rule 1
   (gen_brev8 rs _)
@@ -2826,18 +2976,7 @@
   (i128_sub (value_regs_zero) val))
 
 
-;; Selects the greatest of two registers as signed values.
-(decl max (Type XReg XReg) XReg)
-(rule (max (fits_in_64 (ty_int ty)) x y)
-  (if-let $true (has_zbb))
-  (rv_max x y))
-
-(rule (max (fits_in_64 (ty_int ty)) x y)
-  (if-let $false (has_zbb))
-  (gen_select_xreg (cmp_gt x y) x y))
-
-
-;; Builds an instruction sequence that traps if the comparision succeeds.
+;; Builds an instruction sequence that traps if the comparison succeeds.
 (decl gen_trapif (IntCC XReg XReg TrapCode) InstOutput)
 (rule (gen_trapif cc a b trap_code)
   (side_effect (SideEffectNoResult.Inst (MInst.TrapIf a b cc trap_code))))
@@ -2872,6 +3011,9 @@
 
 ;; Generates either 0 if `Value` is zero or -1 otherwise.
 (decl gen_bmask (Value) XReg)
+
+;; Base cases: use `snez` after a sign extension to ensure that the entire
+;; register is defined. For i128 we test both the upper and lower half.
 (rule 0 (gen_bmask val @ (value_type (fits_in_64 _)))
   (let ((non_zero XReg (rv_snez (sext val))))
     (rv_neg non_zero)))
@@ -2879,6 +3021,13 @@
   (let ((non_zero XReg (rv_snez (rv_or (value_regs_get val 0) (value_regs_get val 1)))))
     (rv_neg non_zero)))
 
+;; If the input value is an `icmp` or an `fcmp` directly then the `snez` can
+;; be omitted because the result of the icmp or fcmp is a 0 or 1 directly. This
+;; means we can go straight to the `neg` instruction to produce the final
+;; result.
+(rule 2 (gen_bmask val @ (maybe_uextend (icmp _ _ _ _))) (rv_neg val))
+(rule 2 (gen_bmask val @ (maybe_uextend (fcmp _ _ _ _))) (rv_neg val))
+
 (decl lower_bmask (Value Type) ValueRegs)
 (rule 0 (lower_bmask val (fits_in_64 _))
   (value_reg (gen_bmask val)))
@@ -2902,9 +3051,14 @@
 (decl sp_reg () PReg)
 (extern constructor sp_reg sp_reg)
 
+;; Extractor that matches all registers, except the zero register
+(decl non_zero_reg () XReg)
+(extern extractor non_zero_reg is_non_zero_reg)
+
 ;; Helper for creating the zero register.
-(decl zero_reg () Reg)
+(decl zero_reg () XReg)
 (extern constructor zero_reg zero_reg)
+(extern extractor zero_reg is_zero_reg)
 
 (decl value_regs_zero () ValueRegs)
 (rule (value_regs_zero)
@@ -2916,67 +3070,64 @@
 
 ;;;; Helpers for floating point comparisons ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(decl is_not_nan (Type FReg) XReg)
-(rule (is_not_nan ty a) (rv_feq ty a a))
-
-(decl ordered (Type FReg FReg) XReg)
-(rule (ordered ty a b) (rv_and (is_not_nan ty a) (is_not_nan ty b)))
-
-(type FCmp (enum
+(type FloatCompare (enum
   ;; The comparison succeeded if `r` is one
   (One (r XReg))
   ;; The comparison succeeded if `r` is zero
   (Zero (r XReg))
 ))
 
-(decl fcmp_invert (FCmp) FCmp)
-(rule (fcmp_invert (FCmp.One r)) (FCmp.Zero r))
-(rule (fcmp_invert (FCmp.Zero r)) (FCmp.One r))
+(decl float_compare_invert (FloatCompare) FloatCompare)
+(rule (float_compare_invert (FloatCompare.One r)) (FloatCompare.Zero r))
+(rule (float_compare_invert (FloatCompare.Zero r)) (FloatCompare.One r))
 
-(decl fcmp_to_compare (FCmp) IntegerCompare)
-(rule (fcmp_to_compare (FCmp.One r)) (cmp_nez r))
-(rule (fcmp_to_compare (FCmp.Zero r)) (cmp_eqz r))
-(convert FCmp IntegerCompare fcmp_to_compare)
+(decl float_to_int_compare (FloatCompare) IntegerCompare)
+(rule (float_to_int_compare (FloatCompare.One r)) (cmp_nez r))
+(rule (float_to_int_compare (FloatCompare.Zero r)) (cmp_eqz r))
+(convert FloatCompare IntegerCompare float_to_int_compare)
 
 ;; Compare two floating point numbers and return a zero/non-zero result.
-(decl emit_fcmp (FloatCC Type FReg FReg) FCmp)
+(decl fcmp_to_float_compare (FloatCC Type FReg FReg) FloatCompare)
 
 ;; Direct codegen for unordered comparisons is not that efficient, so invert
 ;; the comparison to get an ordered comparison and generate that. Then invert
 ;; the result to produce the final fcmp result.
-(rule 0 (emit_fcmp cc ty a b)
+(rule 0 (fcmp_to_float_compare cc ty a b)
   (if-let $true (floatcc_unordered cc))
-  (fcmp_invert (emit_fcmp (floatcc_complement cc) ty a b)))
+  (float_compare_invert (fcmp_to_float_compare (floatcc_complement cc) ty a b)))
 
 ;; a is not nan && b is not nan
-(rule 1 (emit_fcmp (FloatCC.Ordered) ty a b)
-  (FCmp.One (ordered ty a b)))
+(rule 1 (fcmp_to_float_compare (FloatCC.Ordered) ty a b)
+  (FloatCompare.One (rv_and (is_not_nan ty a) (is_not_nan ty b))))
+
+(decl is_not_nan (Type FReg) XReg)
+(rule (is_not_nan ty a) (rv_feq ty a a))
 
 ;; a == b
-(rule 1 (emit_fcmp (FloatCC.Equal) ty a b)
-  (FCmp.One (rv_feq ty a b)))
+(rule 1 (fcmp_to_float_compare (FloatCC.Equal) ty a b)
+  (FloatCompare.One (rv_feq ty a b)))
 
 ;; a != b
 ;; == !(a == b)
-(rule 1 (emit_fcmp (FloatCC.NotEqual) ty a b)
-  (FCmp.Zero (rv_feq ty a b)))
+(rule 1 (fcmp_to_float_compare (FloatCC.NotEqual) ty a b)
+  (FloatCompare.Zero (rv_feq ty a b)))
 
 ;; a < b || a > b
-(rule 1 (emit_fcmp (FloatCC.OrderedNotEqual) ty a b)
-  (FCmp.One (rv_or (rv_flt ty a b) (rv_fgt ty a b))))
+(rule 1 (fcmp_to_float_compare (FloatCC.OrderedNotEqual) ty a b)
+  (FloatCompare.One (rv_or (rv_flt ty a b) (rv_fgt ty a b))))
 
 ;; a < b
-(rule 1 (emit_fcmp (FloatCC.LessThan) ty a b)
-  (FCmp.One (rv_flt ty a b)))
+(rule 1 (fcmp_to_float_compare (FloatCC.LessThan) ty a b)
+  (FloatCompare.One (rv_flt ty a b)))
 
 ;; a <= b
-(rule 1 (emit_fcmp (FloatCC.LessThanOrEqual) ty a b)
-  (FCmp.One (rv_fle ty a b)))
+(rule 1 (fcmp_to_float_compare (FloatCC.LessThanOrEqual) ty a b)
+  (FloatCompare.One (rv_fle ty a b)))
 
 ;; a > b
-(rule 1 (emit_fcmp (FloatCC.GreaterThan) ty a b)
-  (FCmp.One (rv_fgt ty a b)))
+(rule 1 (fcmp_to_float_compare (FloatCC.GreaterThan) ty a b)
+  (FloatCompare.One (rv_fgt ty a b)))
 
 ;; a >= b
-(rule 1 (emit_fcmp (FloatCC.GreaterThanOrEqual) ty a b)
-  (FCmp.One (rv_fge ty a b)))
+(rule 1 (fcmp_to_float_compare (FloatCC.GreaterThanOrEqual) ty a b)
+  (FloatCompare.One (rv_fge ty a b)))
diff --git a/cranelift/codegen/src/isa/riscv64/inst/args.rs b/cranelift/codegen/src/isa/riscv64/inst/args.rs
index 0ce56295f849..1d54496785d5 100644
--- a/cranelift/codegen/src/isa/riscv64/inst/args.rs
+++ b/cranelift/codegen/src/isa/riscv64/inst/args.rs
@@ -1,18 +1,14 @@
 //! Riscv64 ISA definitions: instruction arguments.
 
-// Some variants are never constructed, but we still want them as options in the future.
-#![allow(dead_code)]
 use super::*;
 use crate::ir::condcodes::CondCode;
 
-use crate::isa::riscv64::inst::{reg_name, reg_to_gpr_num};
-
 use crate::isa::riscv64::lower::isle::generated_code::{
-    COpcodeSpace, CaOp, CbOp, CiOp, CiwOp, CjOp, ClOp, CrOp, CsOp, CssOp, CsznOp, ZcbMemOp,
+    COpcodeSpace, CaOp, CbOp, CiOp, CiwOp, ClOp, CrOp, CsOp, CssOp, CsznOp, FpuOPWidth, ZcbMemOp,
 };
 use crate::machinst::isle::WritableReg;
 
-use std::fmt::{Display, Formatter, Result};
+use std::fmt::Result;
 
 /// A macro for defining a newtype of `Reg` that enforces some invariant about
 /// the wrapped `Reg` (such as that it is of a particular register class).
@@ -84,26 +80,27 @@ newtype_of_reg!(VReg, WritableVReg, |reg| reg.class() == RegClass::Vector);
 pub enum AMode {
     /// Arbitrary offset from a register. Converted to generation of large
     /// offsets with multiple instructions as necessary during code emission.
-    RegOffset(Reg, i64, Type),
+    RegOffset(Reg, i64),
     /// Offset from the stack pointer.
-    SPOffset(i64, Type),
+    SPOffset(i64),
 
     /// Offset from the frame pointer.
-    FPOffset(i64, Type),
+    FPOffset(i64),
 
-    /// Offset from the "nominal stack pointer", which is where the real SP is
-    /// just after stack and spill slots are allocated in the function prologue.
+    /// Offset into the slot area of the stack, which lies just above the
+    /// outgoing argument area that's setup by the function prologue.
     /// At emission time, this is converted to `SPOffset` with a fixup added to
     /// the offset constant. The fixup is a running value that is tracked as
     /// emission iterates through instructions in linear order, and can be
     /// adjusted up and down with [Inst::VirtualSPOffsetAdj].
     ///
     /// The standard ABI is in charge of handling this (by emitting the
-    /// adjustment meta-instructions). It maintains the invariant that "nominal
-    /// SP" is where the actual SP is after the function prologue and before
-    /// clobber pushes. See the diagram in the documentation for
-    /// [crate::isa::riscv64::abi](the ABI module) for more details.
-    NominalSPOffset(i64, Type),
+    /// adjustment meta-instructions). See the diagram in the documentation
+    /// for [crate::isa::aarch64::abi](the ABI module) for more details.
+    SlotOffset(i64),
+
+    /// Offset into the argument area.
+    IncomingArg(i64),
 
     /// A reference to a constant which is placed outside of the function's
     /// body, typically at the end.
@@ -114,27 +111,17 @@ pub enum AMode {
 }
 
 impl AMode {
-    pub(crate) fn with_allocs(self, allocs: &mut AllocationConsumer<'_>) -> Self {
-        match self {
-            AMode::RegOffset(reg, offset, ty) => AMode::RegOffset(allocs.next(reg), offset, ty),
-            AMode::SPOffset(..)
-            | AMode::FPOffset(..)
-            | AMode::NominalSPOffset(..)
-            | AMode::Const(..)
-            | AMode::Label(..) => self,
-        }
-    }
-
-    /// Returns the registers that known to the register allocator.
-    /// Keep this in sync with `with_allocs`.
-    pub(crate) fn get_allocatable_register(&self) -> Option<Reg> {
+    /// Add the registers referenced by this AMode to `collector`.
+    pub(crate) fn get_operands(&mut self, collector: &mut impl OperandVisitor) {
         match self {
-            AMode::RegOffset(reg, ..) => Some(*reg),
+            AMode::RegOffset(reg, ..) => collector.reg_use(reg),
+            // Registers used in these modes aren't allocatable.
             AMode::SPOffset(..)
             | AMode::FPOffset(..)
-            | AMode::NominalSPOffset(..)
+            | AMode::SlotOffset(..)
+            | AMode::IncomingArg(..)
             | AMode::Const(..)
-            | AMode::Label(..) => None,
+            | AMode::Label(..) => {}
         }
     }
 
@@ -143,24 +130,32 @@ impl AMode {
             &AMode::RegOffset(reg, ..) => Some(reg),
             &AMode::SPOffset(..) => Some(stack_reg()),
             &AMode::FPOffset(..) => Some(fp_reg()),
-            &AMode::NominalSPOffset(..) => Some(stack_reg()),
+            &AMode::SlotOffset(..) => Some(stack_reg()),
+            &AMode::IncomingArg(..) => Some(stack_reg()),
             &AMode::Const(..) | AMode::Label(..) => None,
         }
     }
 
     pub(crate) fn get_offset_with_state(&self, state: &EmitState) -> i64 {
         match self {
-            &AMode::NominalSPOffset(offset, _) => offset + state.virtual_sp_offset,
-            _ => self.get_offset(),
-        }
-    }
+            &AMode::SlotOffset(offset) => {
+                offset + i64::from(state.frame_layout().outgoing_args_size)
+            }
 
-    fn get_offset(&self) -> i64 {
-        match self {
-            &AMode::RegOffset(_, offset, ..) => offset,
-            &AMode::SPOffset(offset, _) => offset,
-            &AMode::FPOffset(offset, _) => offset,
-            &AMode::NominalSPOffset(offset, _) => offset,
+            // Compute the offset into the incoming argument area relative to SP
+            &AMode::IncomingArg(offset) => {
+                let frame_layout = state.frame_layout();
+                let sp_offset = frame_layout.tail_args_size
+                    + frame_layout.setup_area_size
+                    + frame_layout.clobber_size
+                    + frame_layout.fixed_frame_storage_size
+                    + frame_layout.outgoing_args_size;
+                i64::from(sp_offset) - offset
+            }
+
+            &AMode::RegOffset(_, offset) => offset,
+            &AMode::SPOffset(offset) => offset,
+            &AMode::FPOffset(offset) => offset,
             &AMode::Const(_) | &AMode::Label(_) => 0,
         }
     }
@@ -173,13 +168,10 @@ impl AMode {
             &AMode::RegOffset(..)
             | &AMode::SPOffset(..)
             | &AMode::FPOffset(..)
-            | &AMode::NominalSPOffset(..) => None,
+            | &AMode::IncomingArg(..)
+            | &AMode::SlotOffset(..) => None,
         }
     }
-
-    pub(crate) fn to_string_with_alloc(&self, allocs: &mut AllocationConsumer<'_>) -> String {
-        format!("{}", self.clone().with_allocs(allocs))
-    }
 }
 
 impl Display for AMode {
@@ -189,13 +181,16 @@ impl Display for AMode {
                 write!(f, "{}({})", offset, reg_name(r))
             }
             &AMode::SPOffset(offset, ..) => {
-                write!(f, "{}(sp)", offset)
+                write!(f, "{offset}(sp)")
             }
-            &AMode::NominalSPOffset(offset, ..) => {
-                write!(f, "{}(nominal_sp)", offset)
+            &AMode::SlotOffset(offset, ..) => {
+                write!(f, "{offset}(slot)")
+            }
+            &AMode::IncomingArg(offset) => {
+                write!(f, "-{offset}(incoming_arg)")
             }
             &AMode::FPOffset(offset, ..) => {
-                write!(f, "{}(fp)", offset)
+                write!(f, "{offset}(fp)")
             }
             &AMode::Const(addr, ..) => {
                 write!(f, "[const({})]", addr.as_u32())
@@ -210,9 +205,11 @@ impl Display for AMode {
 impl Into<AMode> for StackAMode {
     fn into(self) -> AMode {
         match self {
-            StackAMode::FPOffset(offset, ty) => AMode::FPOffset(offset, ty),
-            StackAMode::SPOffset(offset, ty) => AMode::SPOffset(offset, ty),
-            StackAMode::NominalSPOffset(offset, ty) => AMode::NominalSPOffset(offset, ty),
+            StackAMode::IncomingArg(offset, stack_args_size) => {
+                AMode::IncomingArg(i64::from(stack_args_size) - offset)
+            }
+            StackAMode::OutgoingArg(offset) => AMode::SPOffset(offset),
+            StackAMode::Slot(offset) => AMode::SlotOffset(offset),
         }
     }
 }
@@ -251,17 +248,8 @@ impl BranchFunct3 {
             BranchFunct3::Geu => 0b111,
         }
     }
-    pub(crate) fn op_name(self) -> &'static str {
-        match self {
-            BranchFunct3::Eq => "eq",
-            BranchFunct3::Ne => "ne",
-            BranchFunct3::Lt => "lt",
-            BranchFunct3::Ge => "ge",
-            BranchFunct3::Ltu => "ltu",
-            BranchFunct3::Geu => "geu",
-        }
-    }
 }
+
 impl IntegerCompare {
     pub(crate) fn op_code(self) -> u32 {
         0b1100011
@@ -322,435 +310,344 @@ impl IntegerCompare {
             ..self
         }
     }
+
+    pub(crate) fn regs(&self) -> [Reg; 2] {
+        [self.rs1, self.rs2]
+    }
 }
 
-impl FpuOPRRRR {
-    pub(crate) fn op_name(self) -> &'static str {
-        match self {
-            Self::FmaddS => "fmadd.s",
-            Self::FmsubS => "fmsub.s",
-            Self::FnmsubS => "fnmsub.s",
-            Self::FnmaddS => "fnmadd.s",
-            Self::FmaddD => "fmadd.d",
-            Self::FmsubD => "fmsub.d",
-            Self::FnmsubD => "fnmsub.d",
-            Self::FnmaddD => "fnmadd.d",
-        }
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct FliConstant(u8);
+
+impl FliConstant {
+    pub(crate) fn new(value: u8) -> Self {
+        debug_assert!(value <= 31, "Invalid FliConstant: {value}");
+        Self(value)
     }
 
-    pub(crate) fn funct2(self) -> u32 {
-        match self {
-            FpuOPRRRR::FmaddS | FpuOPRRRR::FmsubS | FpuOPRRRR::FnmsubS | FpuOPRRRR::FnmaddS => 0,
-            FpuOPRRRR::FmaddD | FpuOPRRRR::FmsubD | FpuOPRRRR::FnmsubD | FpuOPRRRR::FnmaddD => 1,
+    pub(crate) fn maybe_from_u64(ty: Type, imm: u64) -> Option<Self> {
+        // Convert the value into an F64, this allows us to represent
+        // values from both f32 and f64 in the same value.
+        let value = match ty {
+            F32 => f32::from_bits(imm as u32) as f64,
+            F64 => f64::from_bits(imm),
+            _ => unimplemented!(),
+        };
+
+        Some(match (ty, value) {
+            (_, f) if f == -1.0 => Self::new(0),
+
+            // Since f64 can represent all f32 values, f32::min_positive won't be
+            // the same as f64::min_positive, so we need to check for both indepenendtly
+            (F32, f) if f == (f32::MIN_POSITIVE as f64) => Self::new(1),
+            (F64, f) if f == f64::MIN_POSITIVE => Self::new(1),
+
+            (_, f) if f == 2.0f64.powi(-16) => Self::new(2),
+            (_, f) if f == 2.0f64.powi(-15) => Self::new(3),
+            (_, f) if f == 2.0f64.powi(-8) => Self::new(4),
+            (_, f) if f == 2.0f64.powi(-7) => Self::new(5),
+            (_, f) if f == 0.0625 => Self::new(6),
+            (_, f) if f == 0.125 => Self::new(7),
+            (_, f) if f == 0.25 => Self::new(8),
+            (_, f) if f == 0.3125 => Self::new(9),
+            (_, f) if f == 0.375 => Self::new(10),
+            (_, f) if f == 0.4375 => Self::new(11),
+            (_, f) if f == 0.5 => Self::new(12),
+            (_, f) if f == 0.625 => Self::new(13),
+            (_, f) if f == 0.75 => Self::new(14),
+            (_, f) if f == 0.875 => Self::new(15),
+            (_, f) if f == 1.0 => Self::new(16),
+            (_, f) if f == 1.25 => Self::new(17),
+            (_, f) if f == 1.5 => Self::new(18),
+            (_, f) if f == 1.75 => Self::new(19),
+            (_, f) if f == 2.0 => Self::new(20),
+            (_, f) if f == 2.5 => Self::new(21),
+            (_, f) if f == 3.0 => Self::new(22),
+            (_, f) if f == 4.0 => Self::new(23),
+            (_, f) if f == 8.0 => Self::new(24),
+            (_, f) if f == 16.0 => Self::new(25),
+            (_, f) if f == 128.0 => Self::new(26),
+            (_, f) if f == 256.0 => Self::new(27),
+            (_, f) if f == 32768.0 => Self::new(28),
+            (_, f) if f == 65536.0 => Self::new(29),
+            (_, f) if f == f64::INFINITY => Self::new(30),
+
+            // NaN's are not guaranteed to preserve the sign / payload bits, so we need to check
+            // the original bits directly.
+            (F32, f) if f.is_nan() && imm == 0x7fc0_0000 => Self::new(31), // Canonical NaN
+            (F64, f) if f.is_nan() && imm == 0x7ff8_0000_0000_0000 => Self::new(31), // Canonical NaN
+            _ => return None,
+        })
+    }
+
+    pub(crate) fn format(self) -> &'static str {
+        // The preferred assembly syntax for entries 1, 30, and 31 is min, inf, and nan, respectively.
+        // For entries 0 through 29 (including entry 1), the assembler will accept decimal constants
+        // in C-like syntax.
+        match self.0 {
+            0 => "-1.0",
+            1 => "min",
+            2 => "2^-16",
+            3 => "2^-15",
+            4 => "2^-8",
+            5 => "2^-7",
+            6 => "0.0625",
+            7 => "0.125",
+            8 => "0.25",
+            9 => "0.3125",
+            10 => "0.375",
+            11 => "0.4375",
+            12 => "0.5",
+            13 => "0.625",
+            14 => "0.75",
+            15 => "0.875",
+            16 => "1.0",
+            17 => "1.25",
+            18 => "1.5",
+            19 => "1.75",
+            20 => "2.0",
+            21 => "2.5",
+            22 => "3.0",
+            23 => "4.0",
+            24 => "8.0",
+            25 => "16.0",
+            26 => "128.0",
+            27 => "256.0",
+            28 => "32768.0",
+            29 => "65536.0",
+            30 => "inf",
+            31 => "nan",
+            _ => panic!("Invalid FliConstant"),
         }
     }
 
-    pub(crate) fn funct3(self, rounding_mode: Option<FRM>) -> u32 {
-        rounding_mode.unwrap_or_default().as_u32()
+    pub(crate) fn bits(self) -> u8 {
+        self.0
     }
+}
 
-    pub(crate) fn op_code(self) -> u32 {
+impl FpuOPRRRR {
+    pub(crate) fn op_name(self, width: FpuOPWidth) -> String {
         match self {
-            FpuOPRRRR::FmaddS => 0b1000011,
-            FpuOPRRRR::FmsubS => 0b1000111,
-            FpuOPRRRR::FnmsubS => 0b1001011,
-            FpuOPRRRR::FnmaddS => 0b1001111,
-            FpuOPRRRR::FmaddD => 0b1000011,
-            FpuOPRRRR::FmsubD => 0b1000111,
-            FpuOPRRRR::FnmsubD => 0b1001011,
-            FpuOPRRRR::FnmaddD => 0b1001111,
+            Self::Fmadd => format!("fmadd.{width}"),
+            Self::Fmsub => format!("fmsub.{width}"),
+            Self::Fnmsub => format!("fnmsub.{width}"),
+            Self::Fnmadd => format!("fnmadd.{width}"),
+        }
+    }
+
+    pub(crate) fn opcode(self) -> u32 {
+        match self {
+            Self::Fmadd => 0b1000011,
+            Self::Fmsub => 0b1000111,
+            Self::Fnmsub => 0b1001011,
+            Self::Fnmadd => 0b1001111,
         }
     }
 }
 
 impl FpuOPRR {
-    pub(crate) fn op_name(self) -> &'static str {
+    pub(crate) fn op_name(self, width: FpuOPWidth) -> String {
+        let fmv_width = match width {
+            FpuOPWidth::H => "h",
+            FpuOPWidth::S => "w",
+            FpuOPWidth::D => "d",
+            FpuOPWidth::Q => "q",
+        };
         match self {
-            Self::FsqrtS => "fsqrt.s",
-            Self::FcvtWS => "fcvt.w.s",
-            Self::FcvtWuS => "fcvt.wu.s",
-            Self::FmvXW => "fmv.x.w",
-            Self::FclassS => "fclass.s",
-            Self::FcvtSw => "fcvt.s.w",
-            Self::FcvtSwU => "fcvt.s.wu",
-            Self::FmvWX => "fmv.w.x",
-            Self::FcvtLS => "fcvt.l.s",
-            Self::FcvtLuS => "fcvt.lu.s",
-            Self::FcvtSL => "fcvt.s.l",
-            Self::FcvtSLU => "fcvt.s.lu",
-            Self::FcvtLD => "fcvt.l.d",
-            Self::FcvtLuD => "fcvt.lu.d",
-            Self::FmvXD => "fmv.x.d",
-            Self::FcvtDL => "fcvt.d.l",
-            Self::FcvtDLu => "fcvt.d.lu",
-            Self::FmvDX => "fmv.d.x",
-            Self::FsqrtD => "fsqrt.d",
-            Self::FcvtSD => "fcvt.s.d",
-            Self::FcvtDS => "fcvt.d.s",
-            Self::FclassD => "fclass.d",
-            Self::FcvtWD => "fcvt.w.d",
-            Self::FcvtWuD => "fcvt.wu.d",
-            Self::FcvtDW => "fcvt.d.w",
-            Self::FcvtDWU => "fcvt.d.wu",
+            Self::Fsqrt => format!("fsqrt.{width}"),
+            Self::Fround => format!("fround.{width}"),
+            Self::Fclass => format!("fclass.{width}"),
+            Self::FcvtWFmt => format!("fcvt.w.{width}"),
+            Self::FcvtWuFmt => format!("fcvt.wu.{width}"),
+            Self::FcvtLFmt => format!("fcvt.l.{width}"),
+            Self::FcvtLuFmt => format!("fcvt.lu.{width}"),
+            Self::FcvtFmtW => format!("fcvt.{width}.w"),
+            Self::FcvtFmtWu => format!("fcvt.{width}.wu"),
+            Self::FcvtFmtL => format!("fcvt.{width}.l"),
+            Self::FcvtFmtLu => format!("fcvt.{width}.lu"),
+
+            // fmv instructions deviate from the normal encoding and instead
+            // encode the width as "w" instead of "s". The ISA manual gives this rationale:
+            //
+            // Instructions FMV.S.X and FMV.X.S were renamed to FMV.W.X and FMV.X.W respectively
+            // to be more consistent with their semantics, which did not change. The old names will continue
+            // to be supported in the tools.
+            Self::FmvXFmt => format!("fmv.x.{fmv_width}"),
+            Self::FmvFmtX => format!("fmv.{fmv_width}.x"),
+
+            Self::FcvtSD => "fcvt.s.d".to_string(),
+            Self::FcvtDS => "fcvt.d.s".to_string(),
         }
     }
 
     pub(crate) fn is_convert_to_int(self) -> bool {
         match self {
-            Self::FcvtWS
-            | Self::FcvtWuS
-            | Self::FcvtLS
-            | Self::FcvtLuS
-            | Self::FcvtWD
-            | Self::FcvtWuD
-            | Self::FcvtLD
-            | Self::FcvtLuD => true,
+            Self::FcvtWFmt | Self::FcvtWuFmt | Self::FcvtLFmt | Self::FcvtLuFmt => true,
             _ => false,
         }
     }
-    // move from x register to float register.
-    pub(crate) fn move_x_to_f_op(ty: Type) -> Self {
-        match ty {
-            F32 => Self::FmvWX,
-            F64 => Self::FmvDX,
-            _ => unreachable!("ty:{:?}", ty),
+
+    pub(crate) fn has_frm(self) -> bool {
+        match self {
+            FpuOPRR::FmvXFmt | FpuOPRR::FmvFmtX | FpuOPRR::Fclass => false,
+            _ => true,
         }
     }
 
-    // move from f register to x register.
-    pub(crate) fn move_f_to_x_op(ty: Type) -> Self {
-        match ty {
-            F32 => Self::FmvXW,
-            F64 => Self::FmvXD,
-            _ => unreachable!("ty:{:?}", ty),
-        }
-    }
-
-    pub(crate) fn float_convert_2_int_op(from: Type, is_type_signed: bool, to: Type) -> Self {
-        let type_32 = to.bits() <= 32;
-        match from {
-            F32 => {
-                if is_type_signed {
-                    if type_32 {
-                        Self::FcvtWS
-                    } else {
-                        Self::FcvtLS
-                    }
-                } else {
-                    if type_32 {
-                        Self::FcvtWuS
-                    } else {
-                        Self::FcvtLuS
-                    }
-                }
-            }
-            F64 => {
-                if is_type_signed {
-                    if type_32 {
-                        Self::FcvtWD
-                    } else {
-                        Self::FcvtLD
-                    }
-                } else {
-                    if type_32 {
-                        Self::FcvtWuD
-                    } else {
-                        Self::FcvtLuD
-                    }
-                }
-            }
-            _ => unreachable!("from type:{}", from),
+    pub(crate) fn opcode(self) -> u32 {
+        // OP-FP Major opcode
+        0b1010011
+    }
+
+    pub(crate) fn rs2(self) -> u32 {
+        match self {
+            Self::Fsqrt => 0b00000,
+            Self::Fround => 0b00100,
+            Self::Fclass => 0b00000,
+            Self::FcvtWFmt => 0b00000,
+            Self::FcvtWuFmt => 0b00001,
+            Self::FcvtLFmt => 0b00010,
+            Self::FcvtLuFmt => 0b00011,
+            Self::FcvtFmtW => 0b00000,
+            Self::FcvtFmtWu => 0b00001,
+            Self::FcvtFmtL => 0b00010,
+            Self::FcvtFmtLu => 0b00011,
+            Self::FmvXFmt => 0b00000,
+            Self::FmvFmtX => 0b00000,
+            Self::FcvtSD => 0b00001,
+            Self::FcvtDS => 0b00000,
         }
     }
 
-    pub(crate) fn op_code(self) -> u32 {
+    pub(crate) fn funct5(self) -> u32 {
         match self {
-            FpuOPRR::FsqrtS
-            | FpuOPRR::FcvtWS
-            | FpuOPRR::FcvtWuS
-            | FpuOPRR::FmvXW
-            | FpuOPRR::FclassS
-            | FpuOPRR::FcvtSw
-            | FpuOPRR::FcvtSwU
-            | FpuOPRR::FmvWX => 0b1010011,
-
-            FpuOPRR::FcvtLS | FpuOPRR::FcvtLuS | FpuOPRR::FcvtSL | FpuOPRR::FcvtSLU => 0b1010011,
-
-            FpuOPRR::FcvtLD
-            | FpuOPRR::FcvtLuD
-            | FpuOPRR::FmvXD
-            | FpuOPRR::FcvtDL
-            | FpuOPRR::FcvtDLu
-            | FpuOPRR::FmvDX => 0b1010011,
-
-            FpuOPRR::FsqrtD
-            | FpuOPRR::FcvtSD
-            | FpuOPRR::FcvtDS
-            | FpuOPRR::FclassD
-            | FpuOPRR::FcvtWD
-            | FpuOPRR::FcvtWuD
-            | FpuOPRR::FcvtDW
-            | FpuOPRR::FcvtDWU => 0b1010011,
-        }
-    }
-
-    pub(crate) fn rs2_funct5(self) -> u32 {
-        match self {
-            FpuOPRR::FsqrtS => 0b00000,
-            FpuOPRR::FcvtWS => 0b00000,
-            FpuOPRR::FcvtWuS => 0b00001,
-            FpuOPRR::FmvXW => 0b00000,
-            FpuOPRR::FclassS => 0b00000,
-            FpuOPRR::FcvtSw => 0b00000,
-            FpuOPRR::FcvtSwU => 0b00001,
-            FpuOPRR::FmvWX => 0b00000,
-            FpuOPRR::FcvtLS => 0b00010,
-            FpuOPRR::FcvtLuS => 0b00011,
-            FpuOPRR::FcvtSL => 0b00010,
-            FpuOPRR::FcvtSLU => 0b00011,
-            FpuOPRR::FcvtLD => 0b00010,
-            FpuOPRR::FcvtLuD => 0b00011,
-            FpuOPRR::FmvXD => 0b00000,
-            FpuOPRR::FcvtDL => 0b00010,
-            FpuOPRR::FcvtDLu => 0b00011,
-            FpuOPRR::FmvDX => 0b00000,
-            FpuOPRR::FcvtSD => 0b00001,
-            FpuOPRR::FcvtDS => 0b00000,
-            FpuOPRR::FclassD => 0b00000,
-            FpuOPRR::FcvtWD => 0b00000,
-            FpuOPRR::FcvtWuD => 0b00001,
-            FpuOPRR::FcvtDW => 0b00000,
-            FpuOPRR::FcvtDWU => 0b00001,
-            FpuOPRR::FsqrtD => 0b00000,
-        }
-    }
-    pub(crate) fn funct7(self) -> u32 {
-        match self {
-            FpuOPRR::FsqrtS => 0b0101100,
-            FpuOPRR::FcvtWS => 0b1100000,
-            FpuOPRR::FcvtWuS => 0b1100000,
-            FpuOPRR::FmvXW => 0b1110000,
-            FpuOPRR::FclassS => 0b1110000,
-            FpuOPRR::FcvtSw => 0b1101000,
-            FpuOPRR::FcvtSwU => 0b1101000,
-            FpuOPRR::FmvWX => 0b1111000,
-            FpuOPRR::FcvtLS => 0b1100000,
-            FpuOPRR::FcvtLuS => 0b1100000,
-            FpuOPRR::FcvtSL => 0b1101000,
-            FpuOPRR::FcvtSLU => 0b1101000,
-            FpuOPRR::FcvtLD => 0b1100001,
-            FpuOPRR::FcvtLuD => 0b1100001,
-            FpuOPRR::FmvXD => 0b1110001,
-            FpuOPRR::FcvtDL => 0b1101001,
-            FpuOPRR::FcvtDLu => 0b1101001,
-            FpuOPRR::FmvDX => 0b1111001,
-            FpuOPRR::FcvtSD => 0b0100000,
-            FpuOPRR::FcvtDS => 0b0100001,
-            FpuOPRR::FclassD => 0b1110001,
-            FpuOPRR::FcvtWD => 0b1100001,
-            FpuOPRR::FcvtWuD => 0b1100001,
-            FpuOPRR::FcvtDW => 0b1101001,
-            FpuOPRR::FcvtDWU => 0b1101001,
-            FpuOPRR::FsqrtD => 0b0101101,
-        }
-    }
-
-    pub(crate) fn funct3(self, rounding_mode: Option<FRM>) -> u32 {
-        let rounding_mode = rounding_mode.unwrap_or_default().as_u32();
-        match self {
-            FpuOPRR::FsqrtS => rounding_mode,
-            FpuOPRR::FcvtWS => rounding_mode,
-            FpuOPRR::FcvtWuS => rounding_mode,
-            FpuOPRR::FmvXW => 0b000,
-            FpuOPRR::FclassS => 0b001,
-            FpuOPRR::FcvtSw => rounding_mode,
-            FpuOPRR::FcvtSwU => rounding_mode,
-            FpuOPRR::FmvWX => 0b000,
-            FpuOPRR::FcvtLS => rounding_mode,
-            FpuOPRR::FcvtLuS => rounding_mode,
-            FpuOPRR::FcvtSL => rounding_mode,
-            FpuOPRR::FcvtSLU => rounding_mode,
-            FpuOPRR::FcvtLD => rounding_mode,
-            FpuOPRR::FcvtLuD => rounding_mode,
-            FpuOPRR::FmvXD => 0b000,
-            FpuOPRR::FcvtDL => rounding_mode,
-            FpuOPRR::FcvtDLu => rounding_mode,
-            FpuOPRR::FmvDX => 0b000,
-            FpuOPRR::FcvtSD => rounding_mode,
-            FpuOPRR::FcvtDS => rounding_mode,
-            FpuOPRR::FclassD => 0b001,
-            FpuOPRR::FcvtWD => rounding_mode,
-            FpuOPRR::FcvtWuD => rounding_mode,
-            FpuOPRR::FcvtDW => rounding_mode,
-            FpuOPRR::FcvtDWU => 0b000,
-            FpuOPRR::FsqrtD => rounding_mode,
+            Self::Fsqrt => 0b01011,
+            Self::Fround => 0b01000,
+            Self::Fclass => 0b11100,
+            Self::FcvtWFmt => 0b11000,
+            Self::FcvtWuFmt => 0b11000,
+            Self::FcvtLFmt => 0b11000,
+            Self::FcvtLuFmt => 0b11000,
+            Self::FcvtFmtW => 0b11010,
+            Self::FcvtFmtWu => 0b11010,
+            Self::FcvtFmtL => 0b11010,
+            Self::FcvtFmtLu => 0b11010,
+            Self::FmvXFmt => 0b11100,
+            Self::FmvFmtX => 0b11110,
+            Self::FcvtSD => 0b01000,
+            Self::FcvtDS => 0b01000,
         }
     }
+
+    pub(crate) fn funct7(self, width: FpuOPWidth) -> u32 {
+        (self.funct5() << 2) | width.as_u32()
+    }
 }
 
 impl FpuOPRRR {
-    pub(crate) const fn op_name(self) -> &'static str {
+    pub(crate) fn op_name(self, width: FpuOPWidth) -> String {
         match self {
-            Self::FaddS => "fadd.s",
-            Self::FsubS => "fsub.s",
-            Self::FmulS => "fmul.s",
-            Self::FdivS => "fdiv.s",
-            Self::FsgnjS => "fsgnj.s",
-            Self::FsgnjnS => "fsgnjn.s",
-            Self::FsgnjxS => "fsgnjx.s",
-            Self::FminS => "fmin.s",
-            Self::FmaxS => "fmax.s",
-            Self::FeqS => "feq.s",
-            Self::FltS => "flt.s",
-            Self::FleS => "fle.s",
-            Self::FaddD => "fadd.d",
-            Self::FsubD => "fsub.d",
-            Self::FmulD => "fmul.d",
-            Self::FdivD => "fdiv.d",
-            Self::FsgnjD => "fsgnj.d",
-            Self::FsgnjnD => "fsgnjn.d",
-            Self::FsgnjxD => "fsgnjx.d",
-            Self::FminD => "fmin.d",
-            Self::FmaxD => "fmax.d",
-            Self::FeqD => "feq.d",
-            Self::FltD => "flt.d",
-            Self::FleD => "fle.d",
-        }
-    }
-
-    pub fn funct3(self, rounding_mode: Option<FRM>) -> u32 {
-        let rounding_mode = rounding_mode.unwrap_or_default();
-        let rounding_mode = rounding_mode.as_u32();
-        match self {
-            Self::FaddS => rounding_mode,
-            Self::FsubS => rounding_mode,
-            Self::FmulS => rounding_mode,
-            Self::FdivS => rounding_mode,
-
-            Self::FsgnjS => 0b000,
-            Self::FsgnjnS => 0b001,
-            Self::FsgnjxS => 0b010,
-            Self::FminS => 0b000,
-            Self::FmaxS => 0b001,
-
-            Self::FeqS => 0b010,
-            Self::FltS => 0b001,
-            Self::FleS => 0b000,
-
-            Self::FaddD => rounding_mode,
-            Self::FsubD => rounding_mode,
-            Self::FmulD => rounding_mode,
-            Self::FdivD => rounding_mode,
-
-            Self::FsgnjD => 0b000,
-            Self::FsgnjnD => 0b001,
-            Self::FsgnjxD => 0b010,
-            Self::FminD => 0b000,
-            Self::FmaxD => 0b001,
-            Self::FeqD => 0b010,
-            Self::FltD => 0b001,
-            Self::FleD => 0b000,
+            Self::Fadd => format!("fadd.{width}"),
+            Self::Fsub => format!("fsub.{width}"),
+            Self::Fmul => format!("fmul.{width}"),
+            Self::Fdiv => format!("fdiv.{width}"),
+            Self::Fsgnj => format!("fsgnj.{width}"),
+            Self::Fsgnjn => format!("fsgnjn.{width}"),
+            Self::Fsgnjx => format!("fsgnjx.{width}"),
+            Self::Fmin => format!("fmin.{width}"),
+            Self::Fmax => format!("fmax.{width}"),
+            Self::Feq => format!("feq.{width}"),
+            Self::Flt => format!("flt.{width}"),
+            Self::Fle => format!("fle.{width}"),
+            Self::Fminm => format!("fminm.{width}"),
+            Self::Fmaxm => format!("fmaxm.{width}"),
         }
     }
 
-    pub fn op_code(self) -> u32 {
-        match self {
-            Self::FaddS
-            | Self::FsubS
-            | Self::FmulS
-            | Self::FdivS
-            | Self::FsgnjS
-            | Self::FsgnjnS
-            | Self::FsgnjxS
-            | Self::FminS
-            | Self::FmaxS
-            | Self::FeqS
-            | Self::FltS
-            | Self::FleS => 0b1010011,
-
-            Self::FaddD
-            | Self::FsubD
-            | Self::FmulD
-            | Self::FdivD
-            | Self::FsgnjD
-            | Self::FsgnjnD
-            | Self::FsgnjxD
-            | Self::FminD
-            | Self::FmaxD
-            | Self::FeqD
-            | Self::FltD
-            | Self::FleD => 0b1010011,
-        }
+    pub(crate) fn opcode(self) -> u32 {
+        // OP-FP Major opcode
+        0b1010011
     }
 
-    pub const fn funct7(self) -> u32 {
+    pub(crate) const fn funct5(self) -> u32 {
         match self {
-            Self::FaddS => 0b0000000,
-            Self::FsubS => 0b0000100,
-            Self::FmulS => 0b0001000,
-            Self::FdivS => 0b0001100,
-
-            Self::FsgnjS => 0b0010000,
-            Self::FsgnjnS => 0b0010000,
-            Self::FsgnjxS => 0b0010000,
-            Self::FminS => 0b0010100,
-            Self::FmaxS => 0b0010100,
-            Self::FeqS => 0b1010000,
-            Self::FltS => 0b1010000,
-            Self::FleS => 0b1010000,
-
-            Self::FaddD => 0b0000001,
-            Self::FsubD => 0b0000101,
-            Self::FmulD => 0b0001001,
-            Self::FdivD => 0b0001101,
-            Self::FsgnjD => 0b0010001,
-            Self::FsgnjnD => 0b0010001,
-            Self::FsgnjxD => 0b0010001,
-            Self::FminD => 0b0010101,
-            Self::FmaxD => 0b0010101,
-            Self::FeqD => 0b1010001,
-            Self::FltD => 0b1010001,
-            Self::FleD => 0b1010001,
-        }
-    }
-    pub fn is_32(self) -> bool {
-        match self {
-            Self::FaddS
-            | Self::FsubS
-            | Self::FmulS
-            | Self::FdivS
-            | Self::FsgnjS
-            | Self::FsgnjnS
-            | Self::FsgnjxS
-            | Self::FminS
-            | Self::FmaxS
-            | Self::FeqS
-            | Self::FltS
-            | Self::FleS => true,
-            _ => false,
+            Self::Fadd => 0b00000,
+            Self::Fsub => 0b00001,
+            Self::Fmul => 0b00010,
+            Self::Fdiv => 0b00011,
+            Self::Fsgnj => 0b00100,
+            Self::Fsgnjn => 0b00100,
+            Self::Fsgnjx => 0b00100,
+            Self::Fmin => 0b00101,
+            Self::Fmax => 0b00101,
+            Self::Feq => 0b10100,
+            Self::Flt => 0b10100,
+            Self::Fle => 0b10100,
+            Self::Fminm => 0b00101,
+            Self::Fmaxm => 0b00101,
         }
     }
 
-    pub fn is_copy_sign(self) -> bool {
+    pub(crate) fn funct7(self, width: FpuOPWidth) -> u32 {
+        (self.funct5() << 2) | width.as_u32()
+    }
+
+    pub(crate) fn has_frm(self) -> bool {
         match self {
-            Self::FsgnjD | Self::FsgnjS => true,
-            _ => false,
+            FpuOPRRR::Fsgnj
+            | FpuOPRRR::Fsgnjn
+            | FpuOPRRR::Fsgnjx
+            | FpuOPRRR::Fmin
+            | FpuOPRRR::Fmax
+            | FpuOPRRR::Feq
+            | FpuOPRRR::Flt
+            | FpuOPRRR::Fle => false,
+            _ => true,
         }
     }
+}
 
-    pub fn is_copy_neg_sign(self) -> bool {
-        match self {
-            Self::FsgnjnD | Self::FsgnjnS => true,
-            _ => false,
+impl Display for FpuOPWidth {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                FpuOPWidth::H => "h",
+                FpuOPWidth::S => "s",
+                FpuOPWidth::D => "d",
+                FpuOPWidth::Q => "q",
+            }
+        )
+    }
+}
+
+impl TryFrom<Type> for FpuOPWidth {
+    type Error = &'static str;
+
+    fn try_from(value: Type) -> std::result::Result<Self, Self::Error> {
+        match value {
+            F16 => Ok(FpuOPWidth::H),
+            F32 => Ok(FpuOPWidth::S),
+            F64 => Ok(FpuOPWidth::D),
+            F128 => Ok(FpuOPWidth::Q),
+            _ => Err("Invalid type for FpuOPWidth"),
         }
     }
-    pub fn is_copy_xor_sign(self) -> bool {
+}
+
+impl FpuOPWidth {
+    pub(crate) fn as_u32(&self) -> u32 {
         match self {
-            Self::FsgnjxS | Self::FsgnjxD => true,
-            _ => false,
+            FpuOPWidth::S => 0b00,
+            FpuOPWidth::D => 0b01,
+            FpuOPWidth::H => 0b10,
+            FpuOPWidth::Q => 0b11,
         }
     }
 }
+
 impl AluOPRRR {
     pub(crate) const fn op_name(self) -> &'static str {
         match self {
@@ -812,6 +709,8 @@ impl AluOPRRR {
             Self::Pack => "pack",
             Self::Packw => "packw",
             Self::Packh => "packh",
+            Self::CzeroEqz => "czero.eqz",
+            Self::CzeroNez => "czero.nez",
         }
     }
 
@@ -882,6 +781,10 @@ impl AluOPRRR {
             AluOPRRR::Pack => 0b100,
             AluOPRRR::Packw => 0b100,
             AluOPRRR::Packh => 0b111,
+
+            // ZiCond
+            AluOPRRR::CzeroEqz => 0b101,
+            AluOPRRR::CzeroNez => 0b111,
         }
     }
 
@@ -943,7 +846,9 @@ impl AluOPRRR {
             | AluOPRRR::Sh1add
             | AluOPRRR::Sh2add
             | AluOPRRR::Sh3add
-            | AluOPRRR::Xnor => 0b0110011,
+            | AluOPRRR::Xnor
+            | AluOPRRR::CzeroEqz
+            | AluOPRRR::CzeroNez => 0b0110011,
 
             AluOPRRR::Rolw
             | AluOPRRR::Rorw
@@ -1019,6 +924,10 @@ impl AluOPRRR {
             AluOPRRR::Pack => 0b0000100,
             AluOPRRR::Packw => 0b0000100,
             AluOPRRR::Packh => 0b0000100,
+
+            // ZiCond
+            AluOPRRR::CzeroEqz => 0b0000111,
+            AluOPRRR::CzeroNez => 0b0000111,
         }
     }
 
@@ -1239,6 +1148,7 @@ impl FRM {
 
 impl FFlagsException {
     #[inline]
+    #[allow(dead_code)]
     pub(crate) fn mask(self) -> u32 {
         match self {
             FFlagsException::NV => 1 << 4,
@@ -1260,22 +1170,21 @@ impl LoadOP {
             Self::Lhu => "lhu",
             Self::Lwu => "lwu",
             Self::Ld => "ld",
+            Self::Flh => "flh",
             Self::Flw => "flw",
             Self::Fld => "fld",
         }
     }
 
-    pub(crate) fn from_type(t: Type) -> Self {
-        if t.is_float() {
-            return if t == F32 { Self::Flw } else { Self::Fld };
-        }
-        match t {
-            R32 => Self::Lwu,
-            R64 | I64 => Self::Ld,
-
+    pub(crate) fn from_type(ty: Type) -> Self {
+        match ty {
+            F16 => Self::Flh,
+            F32 => Self::Flw,
+            F64 => Self::Fld,
             I8 => Self::Lb,
             I16 => Self::Lh,
             I32 => Self::Lw,
+            I64 => Self::Ld,
             _ => unreachable!(),
         }
     }
@@ -1283,7 +1192,7 @@ impl LoadOP {
     pub(crate) fn size(&self) -> i64 {
         match self {
             Self::Lb | Self::Lbu => 1,
-            Self::Lh | Self::Lhu => 2,
+            Self::Lh | Self::Lhu | Self::Flh => 2,
             Self::Lw | Self::Lwu | Self::Flw => 4,
             Self::Ld | Self::Fld => 8,
         }
@@ -1294,7 +1203,7 @@ impl LoadOP {
             Self::Lb | Self::Lh | Self::Lw | Self::Lbu | Self::Lhu | Self::Lwu | Self::Ld => {
                 0b0000011
             }
-            Self::Flw | Self::Fld => 0b0000111,
+            Self::Flh | Self::Flw | Self::Fld => 0b0000111,
         }
     }
     pub(crate) fn funct3(self) -> u32 {
@@ -1306,6 +1215,7 @@ impl LoadOP {
             Self::Lbu => 0b100,
             Self::Lhu => 0b101,
             Self::Ld => 0b011,
+            Self::Flh => 0b001,
             Self::Flw => 0b010,
             Self::Fld => 0b011,
         }
@@ -1319,19 +1229,20 @@ impl StoreOP {
             Self::Sh => "sh",
             Self::Sw => "sw",
             Self::Sd => "sd",
+            Self::Fsh => "fsh",
             Self::Fsw => "fsw",
             Self::Fsd => "fsd",
         }
     }
-    pub(crate) fn from_type(t: Type) -> Self {
-        if t.is_float() {
-            return if t == F32 { Self::Fsw } else { Self::Fsd };
-        }
-        match t.bits() {
-            1 | 8 => Self::Sb,
-            16 => Self::Sh,
-            32 => Self::Sw,
-            64 => Self::Sd,
+    pub(crate) fn from_type(ty: Type) -> Self {
+        match ty {
+            F16 => Self::Fsh,
+            F32 => Self::Fsw,
+            F64 => Self::Fsd,
+            I8 => Self::Sb,
+            I16 => Self::Sh,
+            I32 => Self::Sw,
+            I64 => Self::Sd,
             _ => unreachable!(),
         }
     }
@@ -1339,7 +1250,7 @@ impl StoreOP {
     pub(crate) fn size(&self) -> i64 {
         match self {
             Self::Sb => 1,
-            Self::Sh => 2,
+            Self::Sh | Self::Fsh => 2,
             Self::Sw | Self::Fsw => 4,
             Self::Sd | Self::Fsd => 8,
         }
@@ -1348,7 +1259,7 @@ impl StoreOP {
     pub(crate) fn op_code(self) -> u32 {
         match self {
             Self::Sb | Self::Sh | Self::Sw | Self::Sd => 0b0100011,
-            Self::Fsw | Self::Fsd => 0b0100111,
+            Self::Fsh | Self::Fsw | Self::Fsd => 0b0100111,
         }
     }
     pub(crate) fn funct3(self) -> u32 {
@@ -1357,12 +1268,14 @@ impl StoreOP {
             Self::Sh => 0b001,
             Self::Sw => 0b010,
             Self::Sd => 0b011,
+            Self::Fsh => 0b001,
             Self::Fsw => 0b010,
             Self::Fsd => 0b011,
         }
     }
 }
 
+#[allow(dead_code)]
 impl FClassResult {
     pub(crate) const fn bit(self) -> u32 {
         match self {
@@ -1675,82 +1588,7 @@ impl Inst {
     }
 }
 
-impl FloatRoundOP {
-    pub(crate) fn op_name(self) -> &'static str {
-        match self {
-            FloatRoundOP::Nearest => "nearest",
-            FloatRoundOP::Ceil => "ceil",
-            FloatRoundOP::Floor => "floor",
-            FloatRoundOP::Trunc => "trunc",
-        }
-    }
-
-    pub(crate) fn to_frm(self) -> FRM {
-        match self {
-            FloatRoundOP::Nearest => FRM::RNE,
-            FloatRoundOP::Ceil => FRM::RUP,
-            FloatRoundOP::Floor => FRM::RDN,
-            FloatRoundOP::Trunc => FRM::RTZ,
-        }
-    }
-}
-
-impl FloatSelectOP {
-    pub(crate) fn op_name(self) -> &'static str {
-        match self {
-            FloatSelectOP::Max => "max",
-            FloatSelectOP::Min => "min",
-        }
-    }
-
-    pub(crate) fn to_fpuoprrr(self, ty: Type) -> FpuOPRRR {
-        match self {
-            FloatSelectOP::Max => {
-                if ty == F32 {
-                    FpuOPRRR::FmaxS
-                } else {
-                    FpuOPRRR::FmaxD
-                }
-            }
-            FloatSelectOP::Min => {
-                if ty == F32 {
-                    FpuOPRRR::FminS
-                } else {
-                    FpuOPRRR::FminD
-                }
-            }
-        }
-    }
-    // move qnan bits into int register.
-    pub(crate) fn snan_bits(self, rd: Writable<Reg>, ty: Type) -> SmallInstVec<Inst> {
-        let mut insts = SmallInstVec::new();
-        insts.push(Inst::load_imm12(rd, Imm12::from_i16(-1)));
-        let x = if ty == F32 { 22 } else { 51 };
-        insts.push(Inst::AluRRImm12 {
-            alu_op: AluOPRRI::Srli,
-            rd: rd,
-            rs: rd.to_reg(),
-            imm12: Imm12::from_i16(x),
-        });
-        insts.push(Inst::AluRRImm12 {
-            alu_op: AluOPRRI::Slli,
-            rd: rd,
-            rs: rd.to_reg(),
-            imm12: Imm12::from_i16(x),
-        });
-        insts
-    }
-}
-
-pub(crate) fn f32_bits(f: f32) -> u32 {
-    u32::from_le_bytes(f.to_le_bytes())
-}
-pub(crate) fn f64_bits(f: f64) -> u64 {
-    u64::from_le_bytes(f.to_le_bytes())
-}
-
-///
-pub(crate) fn f32_cvt_to_int_bounds(signed: bool, out_bits: u8) -> (f32, f32) {
+pub(crate) fn f32_cvt_to_int_bounds(signed: bool, out_bits: u32) -> (f32, f32) {
     match (signed, out_bits) {
         (true, 8) => (i8::min_value() as f32 - 1., i8::max_value() as f32 + 1.),
         (true, 16) => (i16::min_value() as f32 - 1., i16::max_value() as f32 + 1.),
@@ -1764,7 +1602,7 @@ pub(crate) fn f32_cvt_to_int_bounds(signed: bool, out_bits: u8) -> (f32, f32) {
     }
 }
 
-pub(crate) fn f64_cvt_to_int_bounds(signed: bool, out_bits: u8) -> (f64, f64) {
+pub(crate) fn f64_cvt_to_int_bounds(signed: bool, out_bits: u32) -> (f64, f64) {
     match (signed, out_bits) {
         (true, 8) => (i8::min_value() as f64 - 1., i8::max_value() as f64 + 1.),
         (true, 16) => (i16::min_value() as f64 - 1., i16::max_value() as f64 + 1.),
diff --git a/cranelift/codegen/src/isa/riscv64/inst/emit.rs b/cranelift/codegen/src/isa/riscv64/inst/emit.rs
index 130eeaa12142..bbce4ec90fdd 100644
--- a/cranelift/codegen/src/isa/riscv64/inst/emit.rs
+++ b/cranelift/codegen/src/isa/riscv64/inst/emit.rs
@@ -1,15 +1,11 @@
 //! Riscv64 ISA: binary code emission.
 
-use crate::binemit::StackMap;
-use crate::ir::{self, LibCall, RelSourceLoc, TrapCode};
+use crate::ir::{self, LibCall, TrapCode};
 use crate::isa::riscv64::inst::*;
 use crate::isa::riscv64::lower::isle::generated_code::{
-    CaOp, CbOp, CiOp, CiwOp, ClOp, CrOp, CsOp, CssOp, CsznOp, ZcbMemOp,
+    CaOp, CbOp, CiOp, CiwOp, ClOp, CrOp, CsOp, CssOp, CsznOp, FpuOPWidth, ZcbMemOp,
 };
-use crate::machinst::{AllocationConsumer, Reg, Writable};
-use crate::trace;
 use cranelift_control::ControlPlane;
-use regalloc2::Allocation;
 
 pub struct EmitInfo {
     shared_flag: settings::Flags,
@@ -49,31 +45,24 @@ pub enum EmitVState {
 /// State carried between emissions of a sequence of instructions.
 #[derive(Default, Clone, Debug)]
 pub struct EmitState {
-    pub(crate) virtual_sp_offset: i64,
-    pub(crate) nominal_sp_to_fp: i64,
-    /// Safepoint stack map for upcoming instruction, as provided to `pre_safepoint()`.
-    stack_map: Option<StackMap>,
-    /// Current source-code location corresponding to instruction to be emitted.
-    cur_srcloc: RelSourceLoc,
+    /// The user stack map for the upcoming instruction, as provided to
+    /// `pre_safepoint()`.
+    user_stack_map: Option<ir::UserStackMap>,
+
     /// Only used during fuzz-testing. Otherwise, it is a zero-sized struct and
     /// optimized away at compiletime. See [cranelift_control].
     ctrl_plane: ControlPlane,
+
     /// Vector State
     /// Controls the current state of the vector unit at the emission point.
     vstate: EmitVState,
+
+    frame_layout: FrameLayout,
 }
 
 impl EmitState {
-    fn take_stack_map(&mut self) -> Option<StackMap> {
-        self.stack_map.take()
-    }
-
-    fn clear_post_insn(&mut self) {
-        self.stack_map = None;
-    }
-
-    fn cur_srcloc(&self) -> RelSourceLoc {
-        self.cur_srcloc
+    fn take_stack_map(&mut self) -> Option<ir::UserStackMap> {
+        self.user_stack_map.take()
     }
 }
 
@@ -83,21 +72,15 @@ impl MachInstEmitState<Inst> for EmitState {
         ctrl_plane: ControlPlane,
     ) -> Self {
         EmitState {
-            virtual_sp_offset: 0,
-            nominal_sp_to_fp: abi.frame_size() as i64,
-            stack_map: None,
-            cur_srcloc: RelSourceLoc::default(),
+            user_stack_map: None,
             ctrl_plane,
             vstate: EmitVState::Unknown,
+            frame_layout: abi.frame_layout().clone(),
         }
     }
 
-    fn pre_safepoint(&mut self, stack_map: StackMap) {
-        self.stack_map = Some(stack_map);
-    }
-
-    fn pre_sourceloc(&mut self, srcloc: RelSourceLoc) {
-        self.cur_srcloc = srcloc;
+    fn pre_safepoint(&mut self, user_stack_map: Option<ir::UserStackMap>) {
+        self.user_stack_map = user_stack_map;
     }
 
     fn ctrl_plane_mut(&mut self) -> &mut ControlPlane {
@@ -112,6 +95,10 @@ impl MachInstEmitState<Inst> for EmitState {
         // Reset the vector state.
         self.vstate = EmitVState::Unknown;
     }
+
+    fn frame_layout(&self) -> &FrameLayout {
+        &self.frame_layout
+    }
 }
 
 impl Inst {
@@ -151,171 +138,7 @@ impl Inst {
         }
     }
 
-    // emit a float is not a nan.
-    pub(crate) fn emit_not_nan(rd: Writable<Reg>, rs: Reg, ty: Type) -> Inst {
-        Inst::FpuRRR {
-            alu_op: if ty == F32 {
-                FpuOPRRR::FeqS
-            } else {
-                FpuOPRRR::FeqD
-            },
-            frm: None,
-            rd: rd,
-            rs1: rs,
-            rs2: rs,
-        }
-    }
-
-    pub(crate) fn emit_fabs(rd: Writable<Reg>, rs: Reg, ty: Type) -> Inst {
-        Inst::FpuRRR {
-            alu_op: if ty == F32 {
-                FpuOPRRR::FsgnjxS
-            } else {
-                FpuOPRRR::FsgnjxD
-            },
-            frm: None,
-            rd: rd,
-            rs1: rs,
-            rs2: rs,
-        }
-    }
-    /// If a float is zero.
-    pub(crate) fn emit_if_float_not_zero(
-        tmp: Writable<Reg>,
-        rs: Reg,
-        ty: Type,
-        taken: CondBrTarget,
-        not_taken: CondBrTarget,
-    ) -> SmallInstVec<Inst> {
-        let mut insts = SmallInstVec::new();
-        let class_op = if ty == F32 {
-            FpuOPRR::FclassS
-        } else {
-            FpuOPRR::FclassD
-        };
-        insts.push(Inst::FpuRR {
-            alu_op: class_op,
-            frm: None,
-            rd: tmp,
-            rs: rs,
-        });
-        insts.push(Inst::AluRRImm12 {
-            alu_op: AluOPRRI::Andi,
-            rd: tmp,
-            rs: tmp.to_reg(),
-            imm12: Imm12::from_i16(FClassResult::is_zero_bits() as i16),
-        });
-        insts.push(Inst::CondBr {
-            taken,
-            not_taken,
-            kind: IntegerCompare {
-                kind: IntCC::Equal,
-                rs1: tmp.to_reg(),
-                rs2: zero_reg(),
-            },
-        });
-        insts
-    }
-
-    pub(crate) fn lower_br_icmp(
-        cc: IntCC,
-        a: ValueRegs<Reg>,
-        b: ValueRegs<Reg>,
-        taken: CondBrTarget,
-        not_taken: CondBrTarget,
-        ty: Type,
-    ) -> SmallInstVec<Inst> {
-        let mut insts = SmallInstVec::new();
-        if ty.bits() <= 64 {
-            let rs1 = a.only_reg().unwrap();
-            let rs2 = b.only_reg().unwrap();
-            let inst = Inst::CondBr {
-                taken,
-                not_taken,
-                kind: IntegerCompare { kind: cc, rs1, rs2 },
-            };
-            insts.push(inst);
-            return insts;
-        }
-        // compare i128
-        let low = |cc: IntCC| -> IntegerCompare {
-            IntegerCompare {
-                rs1: a.regs()[0],
-                rs2: b.regs()[0],
-                kind: cc,
-            }
-        };
-        let high = |cc: IntCC| -> IntegerCompare {
-            IntegerCompare {
-                rs1: a.regs()[1],
-                rs2: b.regs()[1],
-                kind: cc,
-            }
-        };
-        match cc {
-            IntCC::Equal => {
-                // if high part not equal,
-                // then we can go to not_taken otherwise fallthrough.
-                insts.push(Inst::CondBr {
-                    taken: not_taken,
-                    not_taken: CondBrTarget::Fallthrough,
-                    kind: high(IntCC::NotEqual),
-                });
-                // the rest part.
-                insts.push(Inst::CondBr {
-                    taken,
-                    not_taken,
-                    kind: low(IntCC::Equal),
-                });
-            }
-
-            IntCC::NotEqual => {
-                // if the high part not equal ,
-                // we know the whole must be not equal,
-                // we can goto the taken part , otherwise fallthrought.
-                insts.push(Inst::CondBr {
-                    taken,
-                    not_taken: CondBrTarget::Fallthrough, //  no branch
-                    kind: high(IntCC::NotEqual),
-                });
-
-                insts.push(Inst::CondBr {
-                    taken,
-                    not_taken,
-                    kind: low(IntCC::NotEqual),
-                });
-            }
-            IntCC::SignedGreaterThanOrEqual
-            | IntCC::SignedLessThanOrEqual
-            | IntCC::UnsignedGreaterThanOrEqual
-            | IntCC::UnsignedLessThanOrEqual
-            | IntCC::SignedGreaterThan
-            | IntCC::SignedLessThan
-            | IntCC::UnsignedLessThan
-            | IntCC::UnsignedGreaterThan => {
-                //
-                insts.push(Inst::CondBr {
-                    taken,
-                    not_taken: CondBrTarget::Fallthrough,
-                    kind: high(cc.without_equal()),
-                });
-                //
-                insts.push(Inst::CondBr {
-                    taken: not_taken,
-                    not_taken: CondBrTarget::Fallthrough,
-                    kind: high(IntCC::NotEqual),
-                });
-                insts.push(Inst::CondBr {
-                    taken,
-                    not_taken,
-                    kind: low(cc.unsigned()),
-                });
-            }
-        }
-        insts
-    }
-
-    /// Returns Some(VState) if this insturction is expecting a specific vector state
+    /// Returns Some(VState) if this instruction is expecting a specific vector state
     /// before emission.
     fn expected_vstate(&self) -> Option<&VState> {
         match self {
@@ -323,6 +146,7 @@ impl Inst {
             | Inst::Nop4
             | Inst::BrTable { .. }
             | Inst::Auipc { .. }
+            | Inst::Fli { .. }
             | Inst::Lui { .. }
             | Inst::LoadInlineConst { .. }
             | Inst::AluRRR { .. }
@@ -336,7 +160,6 @@ impl Inst {
             | Inst::Rets { .. }
             | Inst::Ret { .. }
             | Inst::Extend { .. }
-            | Inst::AdjustSp { .. }
             | Inst::Call { .. }
             | Inst::CallInd { .. }
             | Inst::ReturnCall { .. }
@@ -346,7 +169,6 @@ impl Inst {
             | Inst::LoadExtName { .. }
             | Inst::ElfTlsGetAddr { .. }
             | Inst::LoadAddr { .. }
-            | Inst::VirtualSPOffsetAdj { .. }
             | Inst::Mov { .. }
             | Inst::MovFromPReg { .. }
             | Inst::Fence { .. }
@@ -358,8 +180,6 @@ impl Inst {
             | Inst::Atomic { .. }
             | Inst::Select { .. }
             | Inst::AtomicCas { .. }
-            | Inst::Icmp { .. }
-            | Inst::FcvtToInt { .. }
             | Inst::RawData { .. }
             | Inst::AtomicStore { .. }
             | Inst::AtomicLoad { .. }
@@ -367,10 +187,7 @@ impl Inst {
             | Inst::TrapIf { .. }
             | Inst::Unwind { .. }
             | Inst::DummyUse { .. }
-            | Inst::FloatRound { .. }
-            | Inst::FloatSelect { .. }
             | Inst::Popcnt { .. }
-            | Inst::Rev8 { .. }
             | Inst::Cltz { .. }
             | Inst::Brev8 { .. }
             | Inst::StackProbeLoop { .. } => None,
@@ -401,26 +218,16 @@ impl MachInstEmit for Inst {
     type State = EmitState;
     type Info = EmitInfo;
 
-    fn emit(
-        &self,
-        allocs: &[Allocation],
-        sink: &mut MachBuffer<Inst>,
-        emit_info: &Self::Info,
-        state: &mut EmitState,
-    ) {
-        // Transform this into a instruction with all the physical regs
-        let mut allocs = AllocationConsumer::new(allocs);
-        let inst = self.clone().allocate(&mut allocs);
-
+    fn emit(&self, sink: &mut MachBuffer<Inst>, emit_info: &Self::Info, state: &mut EmitState) {
         // Check if we need to update the vector state before emitting this instruction
-        if let Some(expected) = inst.expected_vstate() {
-            if state.vstate != EmitVState::Known(expected.clone()) {
+        if let Some(expected) = self.expected_vstate() {
+            if state.vstate != EmitVState::Known(*expected) {
                 // Update the vector state.
                 Inst::VecSetState {
                     rd: writable_zero_reg(),
-                    vstate: expected.clone(),
+                    vstate: *expected,
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
             }
         }
 
@@ -432,25 +239,31 @@ impl MachInstEmit for Inst {
         let mut start_off = sink.cur_offset();
 
         // First try to emit this as a compressed instruction
-        let res = inst.try_emit_compressed(sink, emit_info, state, &mut start_off);
+        let res = self.try_emit_compressed(sink, emit_info, state, &mut start_off);
         if res.is_none() {
             // If we can't lets emit it as a normal instruction
-            inst.emit_uncompressed(sink, emit_info, state, &mut start_off);
+            self.emit_uncompressed(sink, emit_info, state, &mut start_off);
         }
 
-        let end_off = sink.cur_offset();
-        assert!(
-            (end_off - start_off) <= Inst::worst_case_size(),
-            "Inst:{:?} length:{} worst_case_size:{}",
+        // We exclude br_table and return call from these checks since they emit
+        // their own islands, and thus are allowed to exceed the worst case size.
+        if !matches!(
             self,
-            end_off - start_off,
-            Inst::worst_case_size()
-        );
+            Inst::BrTable { .. } | Inst::ReturnCall { .. } | Inst::ReturnCallInd { .. }
+        ) {
+            let end_off = sink.cur_offset();
+            assert!(
+                (end_off - start_off) <= Inst::worst_case_size(),
+                "Inst:{:?} length:{} worst_case_size:{}",
+                self,
+                end_off - start_off,
+                Inst::worst_case_size()
+            );
+        }
     }
 
-    fn pretty_print_inst(&self, allocs: &[Allocation], state: &mut Self::State) -> String {
-        let mut allocs = AllocationConsumer::new(allocs);
-        self.print_with_state(state, &mut allocs)
+    fn pretty_print_inst(&self, state: &mut Self::State) -> String {
+        self.print_with_state(state)
     }
 }
 
@@ -489,8 +302,16 @@ impl Inst {
                 rd,
                 rs1,
                 rs2,
-            } if rd.to_reg() == rs1 && rs1 != zero_reg() && rs2 != zero_reg() => {
-                sink.put2(encode_cr_type(CrOp::CAdd, rd, rs2));
+            } if (rd.to_reg() == rs1 || rd.to_reg() == rs2)
+                && rs1 != zero_reg()
+                && rs2 != zero_reg() =>
+            {
+                // Technically `c.add rd, rs` expands to `add rd, rd, rs`, but we can
+                // also swap rs1 with rs2 and we get an equivalent instruction. i.e we
+                // can also compress `add rd, rs, rd` into `c.add rd, rs`.
+                let src = if rd.to_reg() == rs1 { rs2 } else { rs1 };
+
+                sink.put2(encode_cr_type(CrOp::CAdd, rd, src));
             }
 
             // C.MV
@@ -513,31 +334,48 @@ impl Inst {
                     alu_op @ (AluOPRRR::And
                     | AluOPRRR::Or
                     | AluOPRRR::Xor
-                    | AluOPRRR::Sub
                     | AluOPRRR::Addw
-                    | AluOPRRR::Subw
                     | AluOPRRR::Mul),
                 rd,
                 rs1,
                 rs2,
-            } if rd.to_reg() == rs1 && reg_is_compressible(rs1) && reg_is_compressible(rs2) => {
+            } if (rd.to_reg() == rs1 || rd.to_reg() == rs2)
+                && reg_is_compressible(rs1)
+                && reg_is_compressible(rs2) =>
+            {
                 let op = match alu_op {
                     AluOPRRR::And => CaOp::CAnd,
                     AluOPRRR::Or => CaOp::COr,
                     AluOPRRR::Xor => CaOp::CXor,
-                    AluOPRRR::Sub => CaOp::CSub,
                     AluOPRRR::Addw => CaOp::CAddw,
-                    AluOPRRR::Subw => CaOp::CSubw,
                     AluOPRRR::Mul if has_zcb && has_m => CaOp::CMul,
                     _ => return None,
                 };
+                // The canonical expansion for these instruction has `rd == rs1`, but
+                // these are all commutative operations, so we can swap the operands.
+                let src = if rd.to_reg() == rs1 { rs2 } else { rs1 };
+
+                sink.put2(encode_ca_type(op, rd, src));
+            }
 
+            // The sub instructions are non commutative, so we can't swap the operands.
+            Inst::AluRRR {
+                alu_op: alu_op @ (AluOPRRR::Sub | AluOPRRR::Subw),
+                rd,
+                rs1,
+                rs2,
+            } if rd.to_reg() == rs1 && reg_is_compressible(rs1) && reg_is_compressible(rs2) => {
+                let op = match alu_op {
+                    AluOPRRR::Sub => CaOp::CSub,
+                    AluOPRRR::Subw => CaOp::CSubw,
+                    _ => return None,
+                };
                 sink.put2(encode_ca_type(op, rd, rs2));
             }
 
             // c.j
             //
-            // We don't have a separate JAL as that is only availabile in RV32C
+            // We don't have a separate JAL as that is only available in RV32C
             Inst::Jal { label } => {
                 sink.use_label_at_offset(*start_off, label, LabelUse::RVCJump);
                 sink.add_uncond_branch(*start_off, *start_off + 2, label);
@@ -570,12 +408,8 @@ impl Inst {
             // c.unimp
             Inst::Udf { trap_code } => {
                 sink.add_trap(trap_code);
-                if let Some(s) = state.take_stack_map() {
-                    sink.add_stack_map(StackMapExtent::UpcomingBytes(2), s);
-                }
                 sink.put2(0x0000);
             }
-
             // c.addi16sp
             //
             // c.addi16sp shares the opcode with c.lui, but has a destination field of x2.
@@ -626,7 +460,7 @@ impl Inst {
                 rd,
                 rs,
                 imm12,
-            } if rd.to_reg() != zero_reg() && rs == zero_reg() && imm12.as_i16() != 0 => {
+            } if rd.to_reg() != zero_reg() && rs == zero_reg() => {
                 let imm6 = Imm6::maybe_from_imm12(imm12)?;
                 sink.put2(encode_ci_type(CiOp::CLi, rd, imm6));
             }
@@ -761,10 +595,9 @@ impl Inst {
                     _ => return None,
                 };
 
-                let srcloc = state.cur_srcloc();
-                if !srcloc.is_default() && !flags.notrap() {
+                if let Some(trap_code) = flags.trap_code() {
                     // Register the offset at which the actual load instruction starts.
-                    sink.add_trap(TrapCode::HeapOutOfBounds);
+                    sink.add_trap(trap_code);
                 }
                 sink.put2(encode_ci_sp_load(op, rd, imm6));
             }
@@ -833,10 +666,9 @@ impl Inst {
                     encode_cl_type(op, rd, base, imm5)
                 };
 
-                let srcloc = state.cur_srcloc();
-                if !srcloc.is_default() && !flags.notrap() {
+                if let Some(trap_code) = flags.trap_code() {
                     // Register the offset at which the actual load instruction starts.
-                    sink.add_trap(TrapCode::HeapOutOfBounds);
+                    sink.add_trap(trap_code);
                 }
                 sink.put2(encoded);
             }
@@ -865,10 +697,9 @@ impl Inst {
                     _ => return None,
                 };
 
-                let srcloc = state.cur_srcloc();
-                if !srcloc.is_default() && !flags.notrap() {
+                if let Some(trap_code) = flags.trap_code() {
                     // Register the offset at which the actual load instruction starts.
-                    sink.add_trap(TrapCode::HeapOutOfBounds);
+                    sink.add_trap(trap_code);
                 }
                 sink.put2(encode_css_type(op, src, imm6));
             }
@@ -933,10 +764,9 @@ impl Inst {
                     encode_cs_type(op, src, base, imm5)
                 };
 
-                let srcloc = state.cur_srcloc();
-                if !srcloc.is_default() && !flags.notrap() {
+                if let Some(trap_code) = flags.trap_code() {
                     // Register the offset at which the actual load instruction starts.
-                    sink.add_trap(TrapCode::HeapOutOfBounds);
+                    sink.add_trap(trap_code);
                 }
                 sink.put2(encoded);
             }
@@ -1023,13 +853,13 @@ impl Inst {
                     rs: zero_reg(),
                     imm12: Imm12::ZERO,
                 };
-                x.emit(&[], sink, emit_info, state)
+                x.emit(sink, emit_info, state)
             }
             &Inst::RawData { ref data } => {
                 // Right now we only put a u32 or u64 in this instruction.
                 // It is not very long, no need to check if need `emit_island`.
-                // If data is very long , this is a bug because RawData is typecial
-                // use to load some data and rely on some positon in the code stream.
+                // If data is very long , this is a bug because RawData is typically
+                // use to load some data and rely on some position in the code stream.
                 // and we may exceed `Inst::worst_case_size`.
                 // for more information see https://github.com/bytecodealliance/wasmtime/pull/5612.
                 sink.put_data(&data[..]);
@@ -1038,6 +868,9 @@ impl Inst {
                 let x: u32 = 0b0110111 | reg_to_gpr_num(rd.to_reg()) << 7 | (imm.bits() << 12);
                 sink.put4(x);
             }
+            &Inst::Fli { rd, ty, imm } => {
+                sink.put4(encode_fli(ty, imm, rd));
+            }
             &Inst::LoadInlineConst { rd, ty, imm } => {
                 let data = &imm.to_le_bytes()[..ty.bytes() as usize];
 
@@ -1051,34 +884,28 @@ impl Inst {
                     flags: MemFlags::new(),
                     from: AMode::Label(label_data),
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
 
                 // Jump over the inline pool
-                Inst::gen_jump(label_end).emit(&[], sink, emit_info, state);
+                Inst::gen_jump(label_end).emit(sink, emit_info, state);
 
                 // Emit the inline data
                 sink.bind_label(label_data, &mut state.ctrl_plane);
-                Inst::RawData { data: data.into() }.emit(&[], sink, emit_info, state);
+                Inst::RawData { data: data.into() }.emit(sink, emit_info, state);
 
                 sink.bind_label(label_end, &mut state.ctrl_plane);
             }
             &Inst::FpuRR {
-                frm,
                 alu_op,
+                width,
+                frm,
                 rd,
                 rs,
             } => {
-                let x = alu_op.op_code()
-                    | reg_to_gpr_num(rd.to_reg()) << 7
-                    | alu_op.funct3(frm) << 12
-                    | reg_to_gpr_num(rs) << 15
-                    | alu_op.rs2_funct5() << 20
-                    | alu_op.funct7() << 25;
-                let srcloc = state.cur_srcloc();
-                if !srcloc.is_default() && alu_op.is_convert_to_int() {
+                if alu_op.is_convert_to_int() {
                     sink.add_trap(TrapCode::BadConversionToInteger);
                 }
-                sink.put4(x);
+                sink.put4(encode_fp_rr(alu_op, width, frm, rd, rs));
             }
             &Inst::FpuRRRR {
                 alu_op,
@@ -1087,31 +914,19 @@ impl Inst {
                 rs2,
                 rs3,
                 frm,
+                width,
             } => {
-                let x = alu_op.op_code()
-                    | reg_to_gpr_num(rd.to_reg()) << 7
-                    | alu_op.funct3(frm) << 12
-                    | reg_to_gpr_num(rs1) << 15
-                    | reg_to_gpr_num(rs2) << 20
-                    | alu_op.funct2() << 25
-                    | reg_to_gpr_num(rs3) << 27;
-
-                sink.put4(x);
+                sink.put4(encode_fp_rrrr(alu_op, width, frm, rd, rs1, rs2, rs3));
             }
             &Inst::FpuRRR {
                 alu_op,
+                width,
                 frm,
                 rd,
                 rs1,
                 rs2,
             } => {
-                let x: u32 = alu_op.op_code()
-                    | reg_to_gpr_num(rd.to_reg()) << 7
-                    | (alu_op.funct3(frm)) << 12
-                    | reg_to_gpr_num(rs1) << 15
-                    | reg_to_gpr_num(rs2) << 20
-                    | alu_op.funct7() << 25;
-                sink.put4(x);
+                sink.put4(encode_fp_rrr(alu_op, width, frm, rd, rs1, rs2));
             }
             &Inst::Unwind { ref inst } => {
                 sink.add_unwind(inst.clone());
@@ -1178,7 +993,7 @@ impl Inst {
                     // register and load from that.
                     (Some(_), None, None) => {
                         let tmp = writable_spilltmp_reg();
-                        Inst::LoadAddr { rd: tmp, mem: from }.emit(&[], sink, emit_info, state);
+                        Inst::LoadAddr { rd: tmp, mem: from }.emit(sink, emit_info, state);
                         (tmp.to_reg(), Imm12::ZERO)
                     }
 
@@ -1213,10 +1028,9 @@ impl Inst {
                     }
                 };
 
-                let srcloc = state.cur_srcloc();
-                if !srcloc.is_default() && !flags.notrap() {
+                if let Some(trap_code) = flags.trap_code() {
                     // Register the offset at which the actual load instruction starts.
-                    sink.add_trap(TrapCode::HeapOutOfBounds);
+                    sink.add_trap(trap_code);
                 }
 
                 sink.put4(encode_i_type(op.op_code(), rd, op.funct3(), addr, imm12));
@@ -1232,15 +1046,14 @@ impl Inst {
                     // Otherwise load the address it into a reg and load from it.
                     _ => {
                         let tmp = writable_spilltmp_reg();
-                        Inst::LoadAddr { rd: tmp, mem: to }.emit(&[], sink, emit_info, state);
+                        Inst::LoadAddr { rd: tmp, mem: to }.emit(sink, emit_info, state);
                         (tmp.to_reg(), Imm12::ZERO)
                     }
                 };
 
-                let srcloc = state.cur_srcloc();
-                if !srcloc.is_default() && !flags.notrap() {
+                if let Some(trap_code) = flags.trap_code() {
                     // Register the offset at which the actual load instruction starts.
-                    sink.add_trap(TrapCode::HeapOutOfBounds);
+                    sink.add_trap(trap_code);
                 }
 
                 sink.put4(encode_s_type(op.op_code(), op.funct3(), addr, src, imm12));
@@ -1257,7 +1070,7 @@ impl Inst {
                     base: link_reg(),
                     offset: Imm12::ZERO,
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
             }
 
             &Inst::Extend {
@@ -1298,159 +1111,74 @@ impl Inst {
                 }
                 insts
                     .into_iter()
-                    .for_each(|i| i.emit(&[], sink, emit_info, state));
-            }
-            &Inst::AdjustSp { amount } => {
-                if let Some(imm) = Imm12::maybe_from_i64(amount) {
-                    Inst::AluRRImm12 {
-                        alu_op: AluOPRRI::Addi,
-                        rd: writable_stack_reg(),
-                        rs: stack_reg(),
-                        imm12: imm,
-                    }
-                    .emit(&[], sink, emit_info, state);
-                } else {
-                    let tmp = writable_spilltmp_reg();
-                    let mut insts = Inst::load_constant_u64(tmp, amount as u64);
-                    insts.push(Inst::AluRRR {
-                        alu_op: AluOPRRR::Add,
-                        rd: writable_stack_reg(),
-                        rs1: tmp.to_reg(),
-                        rs2: stack_reg(),
-                    });
-                    insts
-                        .into_iter()
-                        .for_each(|i| i.emit(&[], sink, emit_info, state));
-                }
+                    .for_each(|i| i.emit(sink, emit_info, state));
             }
+
             &Inst::Call { ref info } => {
-                // call
-                match info.dest {
-                    ExternalName::User { .. } => {
-                        if info.opcode.is_call() {
-                            sink.add_call_site(info.opcode);
-                        }
-                        sink.add_reloc(Reloc::RiscvCall, &info.dest, 0);
-                        if let Some(s) = state.take_stack_map() {
-                            sink.add_stack_map(StackMapExtent::UpcomingBytes(8), s);
-                        }
-                        Inst::construct_auipc_and_jalr(
-                            Some(writable_link_reg()),
-                            writable_link_reg(),
-                            0,
-                        )
-                        .into_iter()
-                        .for_each(|i| i.emit_uncompressed(sink, emit_info, state, start_off));
-                    }
-                    ExternalName::LibCall(..)
-                    | ExternalName::TestCase { .. }
-                    | ExternalName::KnownSymbol(..) => {
-                        // use indirect call. it is more simple.
-                        // load ext name.
-                        Inst::LoadExtName {
-                            rd: writable_spilltmp_reg2(),
-                            name: Box::new(info.dest.clone()),
-                            offset: 0,
-                        }
-                        .emit(&[], sink, emit_info, state);
-
-                        // call
-                        Inst::CallInd {
-                            info: Box::new(CallIndInfo {
-                                rn: spilltmp_reg2(),
-                                // This doesen't really matter but we might as well send
-                                // the correct info.
-                                uses: info.uses.clone(),
-                                defs: info.defs.clone(),
-                                clobbers: info.clobbers,
-                                opcode: Opcode::CallIndirect,
-                                caller_callconv: info.caller_callconv,
-                                callee_callconv: info.callee_callconv,
-                                // Send this as 0 to avoid updating the pop size twice.
-                                callee_pop_size: 0,
-                            }),
-                        }
-                        .emit(&[], sink, emit_info, state);
-                    }
+                sink.add_call_site();
+                sink.add_reloc(Reloc::RiscvCallPlt, &info.dest, 0);
+
+                Inst::construct_auipc_and_jalr(Some(writable_link_reg()), writable_link_reg(), 0)
+                    .into_iter()
+                    .for_each(|i| i.emit_uncompressed(sink, emit_info, state, start_off));
+
+                if let Some(s) = state.take_stack_map() {
+                    let offset = sink.cur_offset();
+                    sink.push_user_stack_map(state, offset, s);
                 }
 
-                let callee_pop_size = i64::from(info.callee_pop_size);
-                state.virtual_sp_offset -= callee_pop_size;
-                trace!(
-                    "call adjusts virtual sp offset by {callee_pop_size} -> {}",
-                    state.virtual_sp_offset
-                );
+                let callee_pop_size = i32::try_from(info.callee_pop_size).unwrap();
+                if callee_pop_size > 0 {
+                    for inst in Riscv64MachineDeps::gen_sp_reg_adjust(-callee_pop_size) {
+                        inst.emit(sink, emit_info, state);
+                    }
+                }
             }
             &Inst::CallInd { ref info } => {
-                let start_offset = sink.cur_offset();
-
                 Inst::Jalr {
                     rd: writable_link_reg(),
                     base: info.rn,
                     offset: Imm12::ZERO,
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
 
                 if let Some(s) = state.take_stack_map() {
-                    sink.add_stack_map(StackMapExtent::StartedAtOffset(start_offset), s);
+                    let offset = sink.cur_offset();
+                    sink.push_user_stack_map(state, offset, s);
                 }
 
-                if info.opcode.is_call() {
-                    sink.add_call_site(info.opcode);
-                }
+                sink.add_call_site();
 
-                let callee_pop_size = i64::from(info.callee_pop_size);
-                state.virtual_sp_offset -= callee_pop_size;
-                trace!(
-                    "call adjusts virtual sp offset by {callee_pop_size} -> {}",
-                    state.virtual_sp_offset
-                );
+                let callee_pop_size = i32::try_from(info.callee_pop_size).unwrap();
+                if callee_pop_size > 0 {
+                    for inst in Riscv64MachineDeps::gen_sp_reg_adjust(-callee_pop_size) {
+                        inst.emit(sink, emit_info, state);
+                    }
+                }
             }
 
             &Inst::ReturnCall {
                 ref callee,
                 ref info,
             } => {
-                emit_return_call_common_sequence(
-                    sink,
-                    emit_info,
-                    state,
-                    info.new_stack_arg_size,
-                    info.old_stack_arg_size,
-                );
-
-                sink.add_call_site(ir::Opcode::ReturnCall);
-                sink.add_reloc(Reloc::RiscvCall, &**callee, 0);
+                emit_return_call_common_sequence(sink, emit_info, state, info);
+
+                sink.add_call_site();
+                sink.add_reloc(Reloc::RiscvCallPlt, &**callee, 0);
                 Inst::construct_auipc_and_jalr(None, writable_spilltmp_reg(), 0)
                     .into_iter()
                     .for_each(|i| i.emit_uncompressed(sink, emit_info, state, start_off));
-
-                // `emit_return_call_common_sequence` emits an island if
-                // necessary, so we can safely disable the worst-case-size check
-                // in this case.
-                *start_off = sink.cur_offset();
             }
 
             &Inst::ReturnCallInd { callee, ref info } => {
-                emit_return_call_common_sequence(
-                    sink,
-                    emit_info,
-                    state,
-                    info.new_stack_arg_size,
-                    info.old_stack_arg_size,
-                );
+                emit_return_call_common_sequence(sink, emit_info, state, &info);
 
                 Inst::Jalr {
                     rd: writable_zero_reg(),
                     base: callee,
                     offset: Imm12::ZERO,
                 }
-                .emit(&[], sink, emit_info, state);
-
-                // `emit_return_call_common_sequence` emits an island if
-                // necessary, so we can safely disable the worst-case-size check
-                // in this case.
-                *start_off = sink.cur_offset();
+                .emit(sink, emit_info, state);
             }
             &Inst::Jal { label } => {
                 sink.use_label_at_offset(*start_off, label, LabelUse::Jal20);
@@ -1475,7 +1203,7 @@ impl Inst {
 
                 match not_taken {
                     CondBrTarget::Label(label) => {
-                        Inst::gen_jump(label).emit(&[], sink, emit_info, state)
+                        Inst::gen_jump(label).emit(sink, emit_info, state)
                     }
                     CondBrTarget::Fallthrough => {}
                 };
@@ -1495,12 +1223,9 @@ impl Inst {
                         imm12: Imm12::ZERO,
                     },
                     RegClass::Float => Inst::FpuRRR {
-                        alu_op: if ty == F32 {
-                            FpuOPRRR::FsgnjS
-                        } else {
-                            FpuOPRRR::FsgnjD
-                        },
-                        frm: None,
+                        alu_op: FpuOPRRR::Fsgnj,
+                        width: FpuOPWidth::try_from(ty).unwrap(),
+                        frm: FRM::RNE,
                         rd: rd,
                         rs1: rm,
                         rs2: rm,
@@ -1516,11 +1241,11 @@ impl Inst {
                         vstate: VState::from_type(ty),
                     },
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
             }
 
             &Inst::MovFromPReg { rd, rm } => {
-                Inst::gen_move(rd, Reg::from(rm), I64).emit(&[], sink, emit_info, state);
+                Inst::gen_move(rd, Reg::from(rm), I64).emit(sink, emit_info, state);
             }
 
             &Inst::BrTable {
@@ -1547,7 +1272,7 @@ impl Inst {
                 let distance = (inst_count * Inst::UNCOMPRESSED_INSTRUCTION_SIZE as usize) as u32;
                 if sink.island_needed(distance) {
                     let jump_around_label = sink.get_label();
-                    Inst::gen_jump(jump_around_label).emit(&[], sink, emit_info, state);
+                    Inst::gen_jump(jump_around_label).emit(sink, emit_info, state);
                     sink.emit_island(distance + 4, &mut state.ctrl_plane);
                     sink.bind_label(jump_around_label, &mut state.ctrl_plane);
                 }
@@ -1588,7 +1313,7 @@ impl Inst {
                     from_bits: 32,
                     to_bits: 64,
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
 
                 // Bounds check.
                 //
@@ -1597,7 +1322,7 @@ impl Inst {
                 // default block.
                 Inst::load_constant_u32(tmp2, targets.len() as u64)
                     .iter()
-                    .for_each(|i| i.emit(&[], sink, emit_info, state));
+                    .for_each(|i| i.emit(sink, emit_info, state));
                 Inst::CondBr {
                     taken: CondBrTarget::Label(label_compute_target),
                     not_taken: CondBrTarget::Fallthrough,
@@ -1607,7 +1332,7 @@ impl Inst {
                         rs2: tmp2.to_reg(),
                     },
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
 
                 sink.use_label_at_offset(sink.cur_offset(), default_target, LabelUse::PCRel32);
                 Inst::construct_auipc_and_jalr(None, tmp2, 0)
@@ -1676,14 +1401,6 @@ impl Inst {
                 *start_off = sink.cur_offset();
             }
 
-            &Inst::VirtualSPOffsetAdj { amount } => {
-                crate::trace!(
-                    "virtual sp offset adjusted by {} -> {}",
-                    amount,
-                    state.virtual_sp_offset + amount
-                );
-                state.virtual_sp_offset += amount;
-            }
             &Inst::Atomic {
                 op,
                 rd,
@@ -1691,9 +1408,10 @@ impl Inst {
                 src,
                 amo,
             } => {
-                let srcloc = state.cur_srcloc();
-                if !srcloc.is_default() {
-                    sink.add_trap(TrapCode::HeapOutOfBounds);
+                // TODO: get flags from original CLIF atomic instruction
+                let flags = MemFlags::new();
+                if let Some(trap_code) = flags.trap_code() {
+                    sink.add_trap(trap_code);
                 }
                 let x = op.op_code()
                     | reg_to_gpr_num(rd.to_reg()) << 7
@@ -1731,7 +1449,7 @@ impl Inst {
                             rs,
                             imm12,
                         }
-                        .emit(&[], sink, emit_info, state);
+                        .emit(sink, emit_info, state);
                     }
                     (_, Some(rs), None) => {
                         let mut insts = Inst::load_constant_u64(rd, offset as u64);
@@ -1743,7 +1461,7 @@ impl Inst {
                         });
                         insts
                             .into_iter()
-                            .for_each(|inst| inst.emit(&[], sink, emit_info, state));
+                            .for_each(|inst| inst.emit(sink, emit_info, state));
                     }
                     (AMode::Const(addr), None, _) => {
                         // Get an address label for the constant and recurse.
@@ -1752,7 +1470,7 @@ impl Inst {
                             rd,
                             mem: AMode::Label(label),
                         }
-                        .emit(&[], sink, emit_info, state);
+                        .emit(sink, emit_info, state);
                     }
                     (AMode::Label(label), None, _) => {
                         // Get the current PC.
@@ -1786,26 +1504,69 @@ impl Inst {
                 ref x,
                 ref y,
             } => {
-                let label_true = sink.get_label();
-                let label_false = sink.get_label();
+                // The general form for this select is the following:
+                //
+                //     mv rd, x
+                //     b{cond} rcond, label_end
+                //     mv rd, y
+                // label_end:
+                //     ... etc
+                //
+                // This is built on the assumption that moves are cheap, but branches and jumps
+                // are not. So with this format we always avoid one jump instruction at the expense
+                // of an unconditional move.
+                //
+                // We also perform another optimization here. If the destination register is the same
+                // as one of the input registers, we can avoid emitting the first unconditional move
+                // and emit just the branch and the second move.
+                //
+                // To make sure that this happens as often as possible, we also try to invert the
+                // condition, so that if either of the input registers are the same as the destination
+                // we avoid that move.
+
                 let label_end = sink.get_label();
+
+                let xregs = x.regs();
+                let yregs = y.regs();
+                let dstregs: Vec<Reg> = dst.regs().into_iter().map(|r| r.to_reg()).collect();
+                let condregs = condition.regs();
+
+                // We are going to write to the destination register before evaluating
+                // the condition, so we need to make sure that the destination register
+                // is not one of the condition registers.
+                //
+                // This should never happen, since hopefully the regalloc constraints
+                // for this register are set up correctly.
+                debug_assert_ne!(dstregs, condregs);
+
+                // Check if we can invert the condition and avoid moving the y registers into
+                // the destination. This allows us to only emit the branch and one of the moves.
+                let (uncond_move, cond_move, condition) = if yregs == dstregs {
+                    (yregs, xregs, condition.inverse())
+                } else {
+                    (xregs, yregs, condition)
+                };
+
+                // Unconditionally move one of the values to the destination register.
+                //
+                // These moves may not end up being emitted if the source and
+                // destination registers are the same. That logic is built into
+                // the emit function for `Inst::Mov`.
+                for i in gen_moves(dst.regs(), uncond_move) {
+                    i.emit(sink, emit_info, state);
+                }
+
+                // If the condition passes we skip over the conditional move
                 Inst::CondBr {
-                    taken: CondBrTarget::Label(label_true),
-                    not_taken: CondBrTarget::Label(label_false),
+                    taken: CondBrTarget::Label(label_end),
+                    not_taken: CondBrTarget::Fallthrough,
                     kind: condition,
                 }
-                .emit(&[], sink, emit_info, state);
-                sink.bind_label(label_true, &mut state.ctrl_plane);
-                // here is the true
-                // select the first value
-                for i in gen_moves(dst.regs(), x.regs()) {
-                    i.emit(&[], sink, emit_info, state);
-                }
-                Inst::gen_jump(label_end).emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
 
-                sink.bind_label(label_false, &mut state.ctrl_plane);
-                for i in gen_moves(dst.regs(), y.regs()) {
-                    i.emit(&[], sink, emit_info, state);
+                // Move the conditional value to the destination register.
+                for i in gen_moves(dst.regs(), cond_move) {
+                    i.emit(sink, emit_info, state);
                 }
 
                 sink.bind_label(label_end, &mut state.ctrl_plane);
@@ -1816,29 +1577,6 @@ impl Inst {
             &Inst::EBreak => {
                 sink.put4(0x00100073);
             }
-            &Inst::Icmp { cc, rd, a, b, ty } => {
-                let label_true = sink.get_label();
-                let label_false = sink.get_label();
-                let label_end = sink.get_label();
-
-                Inst::lower_br_icmp(
-                    cc,
-                    a,
-                    b,
-                    CondBrTarget::Label(label_true),
-                    CondBrTarget::Label(label_false),
-                    ty,
-                )
-                .into_iter()
-                .for_each(|i| i.emit(&[], sink, emit_info, state));
-
-                sink.bind_label(label_true, &mut state.ctrl_plane);
-                Inst::load_imm12(rd, Imm12::ONE).emit(&[], sink, emit_info, state);
-                Inst::gen_jump(label_end).emit(&[], sink, emit_info, state);
-                sink.bind_label(label_false, &mut state.ctrl_plane);
-                Inst::load_imm12(rd, Imm12::ZERO).emit(&[], sink, emit_info, state);
-                sink.bind_label(label_end, &mut state.ctrl_plane);
-            }
             &Inst::AtomicCas {
                 offset,
                 t0,
@@ -1868,11 +1606,11 @@ impl Inst {
                     src: zero_reg(),
                     amo: AMO::SeqCst,
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
                 if ty.bits() < 32 {
                     AtomicOP::extract(dst, offset, dst.to_reg(), ty)
                         .iter()
-                        .for_each(|i| i.emit(&[], sink, emit_info, state));
+                        .for_each(|i| i.emit(sink, emit_info, state));
                 } else if ty.bits() == 32 {
                     Inst::Extend {
                         rd: dst,
@@ -1881,7 +1619,7 @@ impl Inst {
                         from_bits: 32,
                         to_bits: 64,
                     }
-                    .emit(&[], sink, emit_info, state);
+                    .emit(sink, emit_info, state);
                 }
                 Inst::CondBr {
                     taken: CondBrTarget::Label(fail_label),
@@ -1892,7 +1630,7 @@ impl Inst {
                         rs2: dst.to_reg(),
                     },
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
                 let store_value = if ty.bits() < 32 {
                     // reload value to t0.
                     Inst::Atomic {
@@ -1902,11 +1640,11 @@ impl Inst {
                         src: zero_reg(),
                         amo: AMO::SeqCst,
                     }
-                    .emit(&[], sink, emit_info, state);
+                    .emit(sink, emit_info, state);
                     // set reset part.
                     AtomicOP::merge(t0, writable_spilltmp_reg(), offset, v, ty)
                         .iter()
-                        .for_each(|i| i.emit(&[], sink, emit_info, state));
+                        .for_each(|i| i.emit(sink, emit_info, state));
                     t0.to_reg()
                 } else {
                     v
@@ -1918,7 +1656,7 @@ impl Inst {
                     src: store_value,
                     amo: AMO::SeqCst,
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
                 // check is our value stored.
                 Inst::CondBr {
                     taken: CondBrTarget::Label(cas_lebel),
@@ -1929,7 +1667,7 @@ impl Inst {
                         rs2: zero_reg(),
                     },
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
                 sink.bind_label(fail_label, &mut state.ctrl_plane);
             }
             &Inst::AtomicRmwLoop {
@@ -1951,7 +1689,7 @@ impl Inst {
                     src: zero_reg(),
                     amo: AMO::SeqCst,
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
                 //
 
                 let store_value: Reg = match op {
@@ -1962,7 +1700,7 @@ impl Inst {
                     | crate::ir::AtomicRmwOp::Xor => {
                         AtomicOP::extract(dst, offset, dst.to_reg(), ty)
                             .iter()
-                            .for_each(|i| i.emit(&[], sink, emit_info, state));
+                            .for_each(|i| i.emit(sink, emit_info, state));
                         Inst::AluRRR {
                             alu_op: match op {
                                 crate::ir::AtomicRmwOp::Add => AluOPRRR::Add,
@@ -1976,7 +1714,7 @@ impl Inst {
                             rs1: dst.to_reg(),
                             rs2: x,
                         }
-                        .emit(&[], sink, emit_info, state);
+                        .emit(sink, emit_info, state);
                         Inst::Atomic {
                             op: AtomicOP::load_op(ty),
                             rd: writable_spilltmp_reg2(),
@@ -1984,7 +1722,7 @@ impl Inst {
                             src: zero_reg(),
                             amo: AMO::SeqCst,
                         }
-                        .emit(&[], sink, emit_info, state);
+                        .emit(sink, emit_info, state);
                         AtomicOP::merge(
                             writable_spilltmp_reg2(),
                             writable_spilltmp_reg(),
@@ -1993,14 +1731,14 @@ impl Inst {
                             ty,
                         )
                         .iter()
-                        .for_each(|i| i.emit(&[], sink, emit_info, state));
+                        .for_each(|i| i.emit(sink, emit_info, state));
                         spilltmp_reg2()
                     }
                     crate::ir::AtomicRmwOp::Nand => {
                         if ty.bits() < 32 {
                             AtomicOP::extract(dst, offset, dst.to_reg(), ty)
                                 .iter()
-                                .for_each(|i| i.emit(&[], sink, emit_info, state));
+                                .for_each(|i| i.emit(sink, emit_info, state));
                         }
                         Inst::AluRRR {
                             alu_op: AluOPRRR::And,
@@ -2008,8 +1746,8 @@ impl Inst {
                             rs1: x,
                             rs2: dst.to_reg(),
                         }
-                        .emit(&[], sink, emit_info, state);
-                        Inst::construct_bit_not(t0, t0.to_reg()).emit(&[], sink, emit_info, state);
+                        .emit(sink, emit_info, state);
+                        Inst::construct_bit_not(t0, t0.to_reg()).emit(sink, emit_info, state);
                         if ty.bits() < 32 {
                             Inst::Atomic {
                                 op: AtomicOP::load_op(ty),
@@ -2018,7 +1756,7 @@ impl Inst {
                                 src: zero_reg(),
                                 amo: AMO::SeqCst,
                             }
-                            .emit(&[], sink, emit_info, state);
+                            .emit(sink, emit_info, state);
                             AtomicOP::merge(
                                 writable_spilltmp_reg2(),
                                 writable_spilltmp_reg(),
@@ -2027,7 +1765,7 @@ impl Inst {
                                 ty,
                             )
                             .iter()
-                            .for_each(|i| i.emit(&[], sink, emit_info, state));
+                            .for_each(|i| i.emit(sink, emit_info, state));
                             spilltmp_reg2()
                         } else {
                             t0.to_reg()
@@ -2047,28 +1785,29 @@ impl Inst {
                             AtomicOP::extract_sext(dst, offset, dst.to_reg(), ty)
                         }
                         .iter()
-                        .for_each(|i| i.emit(&[], sink, emit_info, state));
-                        Inst::lower_br_icmp(
-                            match op {
-                                crate::ir::AtomicRmwOp::Umin => IntCC::UnsignedLessThan,
-                                crate::ir::AtomicRmwOp::Umax => IntCC::UnsignedGreaterThan,
-                                crate::ir::AtomicRmwOp::Smin => IntCC::SignedLessThan,
-                                crate::ir::AtomicRmwOp::Smax => IntCC::SignedGreaterThan,
-                                _ => unreachable!(),
+                        .for_each(|i| i.emit(sink, emit_info, state));
+
+                        Inst::CondBr {
+                            taken: CondBrTarget::Label(label_select_dst),
+                            not_taken: CondBrTarget::Fallthrough,
+                            kind: IntegerCompare {
+                                kind: match op {
+                                    crate::ir::AtomicRmwOp::Umin => IntCC::UnsignedLessThan,
+                                    crate::ir::AtomicRmwOp::Umax => IntCC::UnsignedGreaterThan,
+                                    crate::ir::AtomicRmwOp::Smin => IntCC::SignedLessThan,
+                                    crate::ir::AtomicRmwOp::Smax => IntCC::SignedGreaterThan,
+                                    _ => unreachable!(),
+                                },
+                                rs1: dst.to_reg(),
+                                rs2: x,
                             },
-                            ValueRegs::one(dst.to_reg()),
-                            ValueRegs::one(x),
-                            CondBrTarget::Label(label_select_dst),
-                            CondBrTarget::Fallthrough,
-                            ty,
-                        )
-                        .iter()
-                        .for_each(|i| i.emit(&[], sink, emit_info, state));
+                        }
+                        .emit(sink, emit_info, state);
                         // here we select x.
-                        Inst::gen_move(t0, x, I64).emit(&[], sink, emit_info, state);
-                        Inst::gen_jump(label_select_done).emit(&[], sink, emit_info, state);
+                        Inst::gen_move(t0, x, I64).emit(sink, emit_info, state);
+                        Inst::gen_jump(label_select_done).emit(sink, emit_info, state);
                         sink.bind_label(label_select_dst, &mut state.ctrl_plane);
-                        Inst::gen_move(t0, dst.to_reg(), I64).emit(&[], sink, emit_info, state);
+                        Inst::gen_move(t0, dst.to_reg(), I64).emit(sink, emit_info, state);
                         sink.bind_label(label_select_done, &mut state.ctrl_plane);
                         Inst::Atomic {
                             op: AtomicOP::load_op(ty),
@@ -2077,7 +1816,7 @@ impl Inst {
                             src: zero_reg(),
                             amo: AMO::SeqCst,
                         }
-                        .emit(&[], sink, emit_info, state);
+                        .emit(sink, emit_info, state);
                         AtomicOP::merge(
                             writable_spilltmp_reg2(),
                             writable_spilltmp_reg(),
@@ -2086,13 +1825,13 @@ impl Inst {
                             ty,
                         )
                         .iter()
-                        .for_each(|i| i.emit(&[], sink, emit_info, state));
+                        .for_each(|i| i.emit(sink, emit_info, state));
                         spilltmp_reg2()
                     }
                     crate::ir::AtomicRmwOp::Xchg => {
                         AtomicOP::extract(dst, offset, dst.to_reg(), ty)
                             .iter()
-                            .for_each(|i| i.emit(&[], sink, emit_info, state));
+                            .for_each(|i| i.emit(sink, emit_info, state));
                         Inst::Atomic {
                             op: AtomicOP::load_op(ty),
                             rd: writable_spilltmp_reg2(),
@@ -2100,7 +1839,7 @@ impl Inst {
                             src: zero_reg(),
                             amo: AMO::SeqCst,
                         }
-                        .emit(&[], sink, emit_info, state);
+                        .emit(sink, emit_info, state);
                         AtomicOP::merge(
                             writable_spilltmp_reg2(),
                             writable_spilltmp_reg(),
@@ -2109,7 +1848,7 @@ impl Inst {
                             ty,
                         )
                         .iter()
-                        .for_each(|i| i.emit(&[], sink, emit_info, state));
+                        .for_each(|i| i.emit(sink, emit_info, state));
                         spilltmp_reg2()
                     }
                 };
@@ -2121,7 +1860,7 @@ impl Inst {
                     src: store_value,
                     amo: AMO::SeqCst,
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
 
                 // if store is not ok,retry.
                 Inst::CondBr {
@@ -2133,203 +1872,79 @@ impl Inst {
                         rs2: zero_reg(),
                     },
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
             }
 
-            &Inst::FcvtToInt {
-                is_sat,
+            &Inst::LoadExtName {
                 rd,
-                rs,
-                is_signed,
-                in_type,
-                out_type,
-                tmp,
+                ref name,
+                offset,
             } => {
-                let label_nan = sink.get_label();
-                let label_jump_over = sink.get_label();
-                // get if nan.
-                Inst::emit_not_nan(rd, rs, in_type).emit(&[], sink, emit_info, state);
-                // jump to nan.
-                Inst::CondBr {
-                    taken: CondBrTarget::Label(label_nan),
-                    not_taken: CondBrTarget::Fallthrough,
-                    kind: IntegerCompare {
-                        kind: IntCC::Equal,
-                        rs2: zero_reg(),
-                        rs1: rd.to_reg(),
-                    },
-                }
-                .emit(&[], sink, emit_info, state);
-
-                if !is_sat {
-                    let f32_bounds = f32_cvt_to_int_bounds(is_signed, out_type.bits() as u8);
-                    let f64_bounds = f64_cvt_to_int_bounds(is_signed, out_type.bits() as u8);
-                    if in_type == F32 {
-                        Inst::load_fp_constant32(tmp, f32_bits(f32_bounds.0), |_| {
-                            writable_spilltmp_reg()
-                        })
-                    } else {
-                        Inst::load_fp_constant64(tmp, f64_bits(f64_bounds.0), |_| {
-                            writable_spilltmp_reg()
-                        })
+                if emit_info.shared_flag.is_pic() {
+                    // Load a PC-relative address into a register.
+                    // RISC-V does this slightly differently from other arches. We emit a relocation
+                    // with a label, instead of the symbol itself.
+                    //
+                    // See: https://github.com/riscv-non-isa/riscv-elf-psabi-doc/blob/master/riscv-elf.adoc#pc-relative-symbol-addresses
+                    //
+                    // Emit the following code:
+                    // label:
+                    //   auipc rd, 0              # R_RISCV_GOT_HI20 (symbol_name)
+                    //   ld    rd, rd, 0          # R_RISCV_PCREL_LO12_I (label)
+
+                    // Create the label that is going to be published to the final binary object.
+                    let auipc_label = sink.get_label();
+                    sink.bind_label(auipc_label, &mut state.ctrl_plane);
+
+                    // Get the current PC.
+                    sink.add_reloc(Reloc::RiscvGotHi20, &**name, 0);
+                    Inst::Auipc {
+                        rd: rd,
+                        imm: Imm20::from_i32(0),
                     }
-                    .iter()
-                    .for_each(|i| i.emit(&[], sink, emit_info, state));
-
-                    let le_op = if in_type == F32 {
-                        FpuOPRRR::FleS
-                    } else {
-                        FpuOPRRR::FleD
-                    };
+                    .emit_uncompressed(sink, emit_info, state, start_off);
 
-                    // rd := rs <= tmp
-                    Inst::FpuRRR {
-                        alu_op: le_op,
-                        frm: None,
+                    // The `ld` here, points to the `auipc` label instead of directly to the symbol.
+                    sink.add_reloc(Reloc::RiscvPCRelLo12I, &auipc_label, 0);
+                    Inst::Load {
                         rd,
-                        rs1: rs,
-                        rs2: tmp.to_reg(),
+                        op: LoadOP::Ld,
+                        flags: MemFlags::trusted(),
+                        from: AMode::RegOffset(rd.to_reg(), 0),
                     }
-                    .emit(&[], sink, emit_info, state);
-                    Inst::TrapIf {
-                        cc: IntCC::NotEqual,
-                        rs1: rd.to_reg(),
-                        rs2: zero_reg(),
-                        trap_code: TrapCode::IntegerOverflow,
-                    }
-                    .emit(&[], sink, emit_info, state);
-
-                    if in_type == F32 {
-                        Inst::load_fp_constant32(tmp, f32_bits(f32_bounds.1), |_| {
-                            writable_spilltmp_reg()
-                        })
-                    } else {
-                        Inst::load_fp_constant64(tmp, f64_bits(f64_bounds.1), |_| {
-                            writable_spilltmp_reg()
-                        })
-                    }
-                    .iter()
-                    .for_each(|i| i.emit(&[], sink, emit_info, state));
-
-                    // rd := rs >= tmp
-                    Inst::FpuRRR {
-                        alu_op: le_op,
-                        frm: None,
+                    .emit_uncompressed(sink, emit_info, state, start_off);
+                } else {
+                    // In the non PIC sequence we relocate the absolute address into
+                    // a prealocatted space, load it into a register and jump over it.
+                    //
+                    // Emit the following code:
+                    //   ld rd, label_data
+                    //   j label_end
+                    // label_data:
+                    //   <8 byte space>           # ABS8
+                    // label_end:
+
+                    let label_data = sink.get_label();
+                    let label_end = sink.get_label();
+
+                    // Load the value from a label
+                    Inst::Load {
                         rd,
-                        rs1: tmp.to_reg(),
-                        rs2: rs,
-                    }
-                    .emit(&[], sink, emit_info, state);
-
-                    Inst::TrapIf {
-                        cc: IntCC::NotEqual,
-                        rs1: rd.to_reg(),
-                        rs2: zero_reg(),
-                        trap_code: TrapCode::IntegerOverflow,
-                    }
-                    .emit(&[], sink, emit_info, state);
-                }
-                // convert to int normally.
-                Inst::FpuRR {
-                    frm: Some(FRM::RTZ),
-                    alu_op: FpuOPRR::float_convert_2_int_op(in_type, is_signed, out_type),
-                    rd,
-                    rs,
-                }
-                .emit(&[], sink, emit_info, state);
-                if out_type.bits() < 32 && is_signed {
-                    // load value part mask.
-                    Inst::load_constant_u32(
-                        writable_spilltmp_reg(),
-                        if 16 == out_type.bits() {
-                            (u16::MAX >> 1) as u64
-                        } else {
-                            // I8
-                            (u8::MAX >> 1) as u64
-                        },
-                    )
-                    .into_iter()
-                    .for_each(|x| x.emit(&[], sink, emit_info, state));
-                    // keep value part.
-                    Inst::AluRRR {
-                        alu_op: AluOPRRR::And,
-                        rd: writable_spilltmp_reg(),
-                        rs1: rd.to_reg(),
-                        rs2: spilltmp_reg(),
-                    }
-                    .emit(&[], sink, emit_info, state);
-                    // extact sign bit.
-                    Inst::AluRRImm12 {
-                        alu_op: AluOPRRI::Srli,
-                        rd: rd,
-                        rs: rd.to_reg(),
-                        imm12: Imm12::from_i16(31),
-                    }
-                    .emit(&[], sink, emit_info, state);
-                    Inst::AluRRImm12 {
-                        alu_op: AluOPRRI::Slli,
-                        rd: rd,
-                        rs: rd.to_reg(),
-                        imm12: Imm12::from_i16(if 16 == out_type.bits() {
-                            15
-                        } else {
-                            // I8
-                            7
-                        }),
-                    }
-                    .emit(&[], sink, emit_info, state);
-                    // make result,sign bit and value part.
-                    Inst::AluRRR {
-                        alu_op: AluOPRRR::Or,
-                        rd: rd,
-                        rs1: rd.to_reg(),
-                        rs2: spilltmp_reg(),
+                        op: LoadOP::Ld,
+                        flags: MemFlags::trusted(),
+                        from: AMode::Label(label_data),
                     }
-                    .emit(&[], sink, emit_info, state);
-                }
+                    .emit(sink, emit_info, state);
 
-                // I already have the result,jump over.
-                Inst::gen_jump(label_jump_over).emit(&[], sink, emit_info, state);
-                // here is nan , move 0 into rd register
-                sink.bind_label(label_nan, &mut state.ctrl_plane);
-                if is_sat {
-                    Inst::load_imm12(rd, Imm12::ZERO).emit(&[], sink, emit_info, state);
-                } else {
-                    // here is ud2.
-                    Inst::Udf {
-                        trap_code: TrapCode::BadConversionToInteger,
-                    }
-                    .emit(&[], sink, emit_info, state);
-                }
-                // bind jump_over
-                sink.bind_label(label_jump_over, &mut state.ctrl_plane);
-            }
+                    // Jump over the data
+                    Inst::gen_jump(label_end).emit(sink, emit_info, state);
 
-            &Inst::LoadExtName {
-                rd,
-                ref name,
-                offset,
-            } => {
-                let label_data = sink.get_label();
-                let label_end = sink.get_label();
+                    sink.bind_label(label_data, &mut state.ctrl_plane);
+                    sink.add_reloc(Reloc::Abs8, name.as_ref(), offset);
+                    sink.put8(0);
 
-                // Load the value from a label
-                Inst::Load {
-                    rd,
-                    op: LoadOP::Ld,
-                    flags: MemFlags::trusted(),
-                    from: AMode::Label(label_data),
+                    sink.bind_label(label_end, &mut state.ctrl_plane);
                 }
-                .emit(&[], sink, emit_info, state);
-
-                // Jump over the data
-                Inst::gen_jump(label_end).emit(&[], sink, emit_info, state);
-
-                sink.bind_label(label_data, &mut state.ctrl_plane);
-                sink.add_reloc(Reloc::Abs8, name.as_ref(), offset);
-                sink.put8(0);
-
-                sink.bind_label(label_end, &mut state.ctrl_plane);
             }
 
             &Inst::ElfTlsGetAddr { rd, ref name } => {
@@ -2348,7 +1963,7 @@ impl Inst {
                 //
                 // https://github.com/riscv-non-isa/riscv-elf-psabi-doc/blob/master/riscv-elf.adoc#global-dynamic
 
-                // Create the lable that is going to be published to the final binary object.
+                // Create the label that is going to be published to the final binary object.
                 let auipc_label = sink.get_label();
                 sink.bind_label(auipc_label, &mut state.ctrl_plane);
 
@@ -2375,7 +1990,6 @@ impl Inst {
                         dest: ExternalName::LibCall(LibCall::ElfTlsGetAddr),
                         uses: smallvec![],
                         defs: smallvec![],
-                        opcode: crate::ir::Opcode::TlsValue,
                         caller_callconv: CallConv::SystemV,
                         callee_callconv: CallConv::SystemV,
                         callee_pop_size: 0,
@@ -2400,19 +2014,13 @@ impl Inst {
                     not_taken: CondBrTarget::Fallthrough,
                     kind: cond.inverse(),
                 }
-                .emit(&[], sink, emit_info, state);
-                Inst::Udf { trap_code }.emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
+                Inst::Udf { trap_code }.emit(sink, emit_info, state);
 
                 sink.bind_label(label_end, &mut state.ctrl_plane);
             }
             &Inst::Udf { trap_code } => {
                 sink.add_trap(trap_code);
-                if let Some(s) = state.take_stack_map() {
-                    sink.add_stack_map(
-                        StackMapExtent::UpcomingBytes(Inst::TRAP_OPCODE.len() as u32),
-                        s,
-                    );
-                }
                 sink.put_data(Inst::TRAP_OPCODE);
             }
             &Inst::AtomicLoad { rd, ty, p } => {
@@ -2421,322 +2029,62 @@ impl Inst {
                     pred: Inst::FENCE_REQ_R | Inst::FENCE_REQ_W,
                     succ: Inst::FENCE_REQ_R | Inst::FENCE_REQ_W,
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
                 // load.
                 Inst::Load {
                     rd: rd,
                     op: LoadOP::from_type(ty),
                     flags: MemFlags::new(),
-                    from: AMode::RegOffset(p, 0, ty),
+                    from: AMode::RegOffset(p, 0),
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
                 Inst::Fence {
                     pred: Inst::FENCE_REQ_R,
                     succ: Inst::FENCE_REQ_R | Inst::FENCE_REQ_W,
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
             }
             &Inst::AtomicStore { src, ty, p } => {
                 Inst::Fence {
                     pred: Inst::FENCE_REQ_R | Inst::FENCE_REQ_W,
                     succ: Inst::FENCE_REQ_W,
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
                 Inst::Store {
-                    to: AMode::RegOffset(p, 0, ty),
+                    to: AMode::RegOffset(p, 0),
                     op: StoreOP::from_type(ty),
                     flags: MemFlags::new(),
                     src,
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
             }
-            &Inst::FloatRound {
-                op,
-                rd,
-                int_tmp,
-                f_tmp,
+
+            &Inst::Popcnt {
+                sum,
+                tmp,
+                step,
                 rs,
                 ty,
             } => {
-                // this code is port from glibc ceil floor ... implementation.
-                let label_nan = sink.get_label();
-                let label_x = sink.get_label();
-                let label_jump_over = sink.get_label();
-                // check if is nan.
-                Inst::emit_not_nan(int_tmp, rs, ty).emit(&[], sink, emit_info, state);
+                // load 0 to sum , init.
+                Inst::gen_move(sum, zero_reg(), I64).emit(sink, emit_info, state);
+                // load
+                Inst::load_imm12(step, Imm12::from_i16(ty.bits() as i16))
+                    .emit(sink, emit_info, state);
+                //
+                Inst::load_imm12(tmp, Imm12::ONE).emit(sink, emit_info, state);
+                Inst::AluRRImm12 {
+                    alu_op: AluOPRRI::Slli,
+                    rd: tmp,
+                    rs: tmp.to_reg(),
+                    imm12: Imm12::from_i16((ty.bits() - 1) as i16),
+                }
+                .emit(sink, emit_info, state);
+                let label_done = sink.get_label();
+                let label_loop = sink.get_label();
+                sink.bind_label(label_loop, &mut state.ctrl_plane);
                 Inst::CondBr {
-                    taken: CondBrTarget::Label(label_nan),
-                    not_taken: CondBrTarget::Fallthrough,
-                    kind: IntegerCompare {
-                        kind: IntCC::Equal,
-                        rs1: int_tmp.to_reg(),
-                        rs2: zero_reg(),
-                    },
-                }
-                .emit(&[], sink, emit_info, state);
-                fn max_value_need_round(ty: Type) -> u64 {
-                    match ty {
-                        F32 => {
-                            let x: u64 = 1 << f32::MANTISSA_DIGITS;
-                            let x = x as f32;
-                            let x = u32::from_le_bytes(x.to_le_bytes());
-                            x as u64
-                        }
-                        F64 => {
-                            let x: u64 = 1 << f64::MANTISSA_DIGITS;
-                            let x = x as f64;
-                            u64::from_le_bytes(x.to_le_bytes())
-                        }
-                        _ => unreachable!(),
-                    }
-                }
-                // load max value need to round.
-                if ty == F32 {
-                    Inst::load_fp_constant32(f_tmp, max_value_need_round(ty) as u32, &mut |_| {
-                        writable_spilltmp_reg()
-                    })
-                } else {
-                    Inst::load_fp_constant64(f_tmp, max_value_need_round(ty), &mut |_| {
-                        writable_spilltmp_reg()
-                    })
-                }
-                .into_iter()
-                .for_each(|i| i.emit(&[], sink, emit_info, state));
-
-                // get abs value.
-                Inst::emit_fabs(rd, rs, ty).emit(&[], sink, emit_info, state);
-
-                // branch if f_tmp < rd
-                Inst::FpuRRR {
-                    frm: None,
-                    alu_op: if ty == F32 {
-                        FpuOPRRR::FltS
-                    } else {
-                        FpuOPRRR::FltD
-                    },
-                    rd: int_tmp,
-                    rs1: f_tmp.to_reg(),
-                    rs2: rd.to_reg(),
-                }
-                .emit(&[], sink, emit_info, state);
-
-                Inst::CondBr {
-                    taken: CondBrTarget::Label(label_x),
-                    not_taken: CondBrTarget::Fallthrough,
-                    kind: IntegerCompare {
-                        kind: IntCC::NotEqual,
-                        rs1: int_tmp.to_reg(),
-                        rs2: zero_reg(),
-                    },
-                }
-                .emit(&[], sink, emit_info, state);
-
-                //convert to int.
-                Inst::FpuRR {
-                    alu_op: FpuOPRR::float_convert_2_int_op(ty, true, I64),
-                    frm: Some(op.to_frm()),
-                    rd: int_tmp,
-                    rs: rs,
-                }
-                .emit(&[], sink, emit_info, state);
-                //convert back.
-                Inst::FpuRR {
-                    alu_op: if ty == F32 {
-                        FpuOPRR::FcvtSL
-                    } else {
-                        FpuOPRR::FcvtDL
-                    },
-                    frm: Some(op.to_frm()),
-                    rd,
-                    rs: int_tmp.to_reg(),
-                }
-                .emit(&[], sink, emit_info, state);
-                // copy sign.
-                Inst::FpuRRR {
-                    alu_op: if ty == F32 {
-                        FpuOPRRR::FsgnjS
-                    } else {
-                        FpuOPRRR::FsgnjD
-                    },
-                    frm: None,
-                    rd,
-                    rs1: rd.to_reg(),
-                    rs2: rs,
-                }
-                .emit(&[], sink, emit_info, state);
-                // jump over.
-                Inst::gen_jump(label_jump_over).emit(&[], sink, emit_info, state);
-                // here is nan.
-                sink.bind_label(label_nan, &mut state.ctrl_plane);
-                Inst::FpuRRR {
-                    alu_op: if ty == F32 {
-                        FpuOPRRR::FaddS
-                    } else {
-                        FpuOPRRR::FaddD
-                    },
-                    frm: None,
-                    rd: rd,
-                    rs1: rs,
-                    rs2: rs,
-                }
-                .emit(&[], sink, emit_info, state);
-                Inst::gen_jump(label_jump_over).emit(&[], sink, emit_info, state);
-                // here select origin x.
-                sink.bind_label(label_x, &mut state.ctrl_plane);
-                Inst::gen_move(rd, rs, ty).emit(&[], sink, emit_info, state);
-                sink.bind_label(label_jump_over, &mut state.ctrl_plane);
-            }
-
-            &Inst::FloatSelect {
-                op,
-                rd,
-                tmp,
-                rs1,
-                rs2,
-                ty,
-            } => {
-                let label_nan = sink.get_label();
-                let label_jump_over = sink.get_label();
-                // check if rs1 is nan.
-                Inst::emit_not_nan(tmp, rs1, ty).emit(&[], sink, emit_info, state);
-                Inst::CondBr {
-                    taken: CondBrTarget::Label(label_nan),
-                    not_taken: CondBrTarget::Fallthrough,
-                    kind: IntegerCompare {
-                        kind: IntCC::Equal,
-                        rs1: tmp.to_reg(),
-                        rs2: zero_reg(),
-                    },
-                }
-                .emit(&[], sink, emit_info, state);
-                // check if rs2 is nan.
-                Inst::emit_not_nan(tmp, rs2, ty).emit(&[], sink, emit_info, state);
-                Inst::CondBr {
-                    taken: CondBrTarget::Label(label_nan),
-                    not_taken: CondBrTarget::Fallthrough,
-                    kind: IntegerCompare {
-                        kind: IntCC::Equal,
-                        rs1: tmp.to_reg(),
-                        rs2: zero_reg(),
-                    },
-                }
-                .emit(&[], sink, emit_info, state);
-                // here rs1 and rs2 is not nan.
-                Inst::FpuRRR {
-                    alu_op: op.to_fpuoprrr(ty),
-                    frm: None,
-                    rd: rd,
-                    rs1: rs1,
-                    rs2: rs2,
-                }
-                .emit(&[], sink, emit_info, state);
-                // special handle for +0 or -0.
-                {
-                    // check is rs1 and rs2 all equal to zero.
-                    let label_done = sink.get_label();
-                    {
-                        // if rs1 == 0
-                        let mut insts = Inst::emit_if_float_not_zero(
-                            tmp,
-                            rs1,
-                            ty,
-                            CondBrTarget::Label(label_done),
-                            CondBrTarget::Fallthrough,
-                        );
-                        insts.extend(Inst::emit_if_float_not_zero(
-                            tmp,
-                            rs2,
-                            ty,
-                            CondBrTarget::Label(label_done),
-                            CondBrTarget::Fallthrough,
-                        ));
-                        insts
-                            .iter()
-                            .for_each(|i| i.emit(&[], sink, emit_info, state));
-                    }
-                    Inst::FpuRR {
-                        alu_op: FpuOPRR::move_f_to_x_op(ty),
-                        frm: None,
-                        rd: tmp,
-                        rs: rs1,
-                    }
-                    .emit(&[], sink, emit_info, state);
-                    Inst::FpuRR {
-                        alu_op: FpuOPRR::move_f_to_x_op(ty),
-                        frm: None,
-                        rd: writable_spilltmp_reg(),
-                        rs: rs2,
-                    }
-                    .emit(&[], sink, emit_info, state);
-                    Inst::AluRRR {
-                        alu_op: if op == FloatSelectOP::Max {
-                            AluOPRRR::And
-                        } else {
-                            AluOPRRR::Or
-                        },
-                        rd: tmp,
-                        rs1: tmp.to_reg(),
-                        rs2: spilltmp_reg(),
-                    }
-                    .emit(&[], sink, emit_info, state);
-                    // move back to rd.
-                    Inst::FpuRR {
-                        alu_op: FpuOPRR::move_x_to_f_op(ty),
-                        frm: None,
-                        rd,
-                        rs: tmp.to_reg(),
-                    }
-                    .emit(&[], sink, emit_info, state);
-                    //
-                    sink.bind_label(label_done, &mut state.ctrl_plane);
-                }
-                // we have the reuslt,jump over.
-                Inst::gen_jump(label_jump_over).emit(&[], sink, emit_info, state);
-                // here is nan.
-                sink.bind_label(label_nan, &mut state.ctrl_plane);
-                op.snan_bits(tmp, ty)
-                    .into_iter()
-                    .for_each(|i| i.emit(&[], sink, emit_info, state));
-                // move to rd.
-                Inst::FpuRR {
-                    alu_op: FpuOPRR::move_x_to_f_op(ty),
-                    frm: None,
-                    rd,
-                    rs: tmp.to_reg(),
-                }
-                .emit(&[], sink, emit_info, state);
-                sink.bind_label(label_jump_over, &mut state.ctrl_plane);
-            }
-            &Inst::Popcnt {
-                sum,
-                tmp,
-                step,
-                rs,
-                ty,
-            } => {
-                // load 0 to sum , init.
-                Inst::gen_move(sum, zero_reg(), I64).emit(&[], sink, emit_info, state);
-                // load
-                Inst::load_imm12(step, Imm12::from_i16(ty.bits() as i16)).emit(
-                    &[],
-                    sink,
-                    emit_info,
-                    state,
-                );
-                //
-                Inst::load_imm12(tmp, Imm12::ONE).emit(&[], sink, emit_info, state);
-                Inst::AluRRImm12 {
-                    alu_op: AluOPRRI::Slli,
-                    rd: tmp,
-                    rs: tmp.to_reg(),
-                    imm12: Imm12::from_i16((ty.bits() - 1) as i16),
-                }
-                .emit(&[], sink, emit_info, state);
-                let label_done = sink.get_label();
-                let label_loop = sink.get_label();
-                sink.bind_label(label_loop, &mut state.ctrl_plane);
-                Inst::CondBr {
-                    taken: CondBrTarget::Label(label_done),
+                    taken: CondBrTarget::Label(label_done),
                     not_taken: CondBrTarget::Fallthrough,
                     kind: IntegerCompare {
                         kind: IntCC::SignedLessThanOrEqual,
@@ -2744,7 +2092,7 @@ impl Inst {
                         rs2: zero_reg(),
                     },
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
                 // test and add sum.
                 {
                     Inst::AluRRR {
@@ -2753,7 +2101,7 @@ impl Inst {
                         rs1: tmp.to_reg(),
                         rs2: rs,
                     }
-                    .emit(&[], sink, emit_info, state);
+                    .emit(sink, emit_info, state);
                     let label_over = sink.get_label();
                     Inst::CondBr {
                         taken: CondBrTarget::Label(label_over),
@@ -2764,14 +2112,14 @@ impl Inst {
                             rs2: spilltmp_reg2(),
                         },
                     }
-                    .emit(&[], sink, emit_info, state);
+                    .emit(sink, emit_info, state);
                     Inst::AluRRImm12 {
                         alu_op: AluOPRRI::Addi,
                         rd: sum,
                         rs: sum.to_reg(),
                         imm12: Imm12::ONE,
                     }
-                    .emit(&[], sink, emit_info, state);
+                    .emit(sink, emit_info, state);
                     sink.bind_label(label_over, &mut state.ctrl_plane);
                 }
                 // set step and tmp.
@@ -2782,81 +2130,16 @@ impl Inst {
                         rs: step.to_reg(),
                         imm12: Imm12::from_i16(-1),
                     }
-                    .emit(&[], sink, emit_info, state);
+                    .emit(sink, emit_info, state);
                     Inst::AluRRImm12 {
                         alu_op: AluOPRRI::Srli,
                         rd: tmp,
                         rs: tmp.to_reg(),
                         imm12: Imm12::ONE,
                     }
-                    .emit(&[], sink, emit_info, state);
-                    Inst::gen_jump(label_loop).emit(&[], sink, emit_info, state);
-                }
-                sink.bind_label(label_done, &mut state.ctrl_plane);
-            }
-            &Inst::Rev8 { rs, rd, tmp, step } => {
-                // init.
-                Inst::gen_move(rd, zero_reg(), I64).emit(&[], sink, emit_info, state);
-                Inst::gen_move(tmp, rs, I64).emit(&[], sink, emit_info, state);
-                // load 56 to step.
-                Inst::load_imm12(step, Imm12::from_i16(56)).emit(&[], sink, emit_info, state);
-                let label_done = sink.get_label();
-                let label_loop = sink.get_label();
-                sink.bind_label(label_loop, &mut state.ctrl_plane);
-                Inst::CondBr {
-                    taken: CondBrTarget::Label(label_done),
-                    not_taken: CondBrTarget::Fallthrough,
-                    kind: IntegerCompare {
-                        kind: IntCC::SignedLessThan,
-                        rs1: step.to_reg(),
-                        rs2: zero_reg(),
-                    },
-                }
-                .emit(&[], sink, emit_info, state);
-                Inst::AluRRImm12 {
-                    alu_op: AluOPRRI::Andi,
-                    rd: writable_spilltmp_reg(),
-                    rs: tmp.to_reg(),
-                    imm12: Imm12::from_i16(255),
-                }
-                .emit(&[], sink, emit_info, state);
-                Inst::AluRRR {
-                    alu_op: AluOPRRR::Sll,
-                    rd: writable_spilltmp_reg(),
-                    rs1: spilltmp_reg(),
-                    rs2: step.to_reg(),
-                }
-                .emit(&[], sink, emit_info, state);
-
-                Inst::AluRRR {
-                    alu_op: AluOPRRR::Or,
-                    rd: rd,
-                    rs1: rd.to_reg(),
-                    rs2: spilltmp_reg(),
-                }
-                .emit(&[], sink, emit_info, state);
-
-                {
-                    // reset step
-                    Inst::AluRRImm12 {
-                        alu_op: AluOPRRI::Addi,
-                        rd: step,
-                        rs: step.to_reg(),
-                        imm12: Imm12::from_i16(-8),
-                    }
-                    .emit(&[], sink, emit_info, state);
-                    //reset tmp.
-                    Inst::AluRRImm12 {
-                        alu_op: AluOPRRI::Srli,
-                        rd: tmp,
-                        rs: tmp.to_reg(),
-                        imm12: Imm12::from_i16(8),
-                    }
-                    .emit(&[], sink, emit_info, state);
-                    // loop.
-                    Inst::gen_jump(label_loop).emit(&[], sink, emit_info, state);
+                    .emit(sink, emit_info, state);
+                    Inst::gen_jump(label_loop).emit(sink, emit_info, state);
                 }
-
                 sink.bind_label(label_done, &mut state.ctrl_plane);
             }
             &Inst::Cltz {
@@ -2868,16 +2151,12 @@ impl Inst {
                 ty,
             } => {
                 // load 0 to sum , init.
-                Inst::gen_move(sum, zero_reg(), I64).emit(&[], sink, emit_info, state);
+                Inst::gen_move(sum, zero_reg(), I64).emit(sink, emit_info, state);
                 // load
-                Inst::load_imm12(step, Imm12::from_i16(ty.bits() as i16)).emit(
-                    &[],
-                    sink,
-                    emit_info,
-                    state,
-                );
+                Inst::load_imm12(step, Imm12::from_i16(ty.bits() as i16))
+                    .emit(sink, emit_info, state);
                 //
-                Inst::load_imm12(tmp, Imm12::ONE).emit(&[], sink, emit_info, state);
+                Inst::load_imm12(tmp, Imm12::ONE).emit(sink, emit_info, state);
                 if leading {
                     Inst::AluRRImm12 {
                         alu_op: AluOPRRI::Slli,
@@ -2885,7 +2164,7 @@ impl Inst {
                         rs: tmp.to_reg(),
                         imm12: Imm12::from_i16((ty.bits() - 1) as i16),
                     }
-                    .emit(&[], sink, emit_info, state);
+                    .emit(sink, emit_info, state);
                 }
                 let label_done = sink.get_label();
                 let label_loop = sink.get_label();
@@ -2899,7 +2178,7 @@ impl Inst {
                         rs2: zero_reg(),
                     },
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
                 // test and add sum.
                 {
                     Inst::AluRRR {
@@ -2908,7 +2187,7 @@ impl Inst {
                         rs1: tmp.to_reg(),
                         rs2: rs,
                     }
-                    .emit(&[], sink, emit_info, state);
+                    .emit(sink, emit_info, state);
                     Inst::CondBr {
                         taken: CondBrTarget::Label(label_done),
                         not_taken: CondBrTarget::Fallthrough,
@@ -2918,14 +2197,14 @@ impl Inst {
                             rs2: spilltmp_reg2(),
                         },
                     }
-                    .emit(&[], sink, emit_info, state);
+                    .emit(sink, emit_info, state);
                     Inst::AluRRImm12 {
                         alu_op: AluOPRRI::Addi,
                         rd: sum,
                         rs: sum.to_reg(),
                         imm12: Imm12::ONE,
                     }
-                    .emit(&[], sink, emit_info, state);
+                    .emit(sink, emit_info, state);
                 }
                 // set step and tmp.
                 {
@@ -2935,7 +2214,7 @@ impl Inst {
                         rs: step.to_reg(),
                         imm12: Imm12::from_i16(-1),
                     }
-                    .emit(&[], sink, emit_info, state);
+                    .emit(sink, emit_info, state);
                     Inst::AluRRImm12 {
                         alu_op: if leading {
                             AluOPRRI::Srli
@@ -2946,8 +2225,8 @@ impl Inst {
                         rs: tmp.to_reg(),
                         imm12: Imm12::ONE,
                     }
-                    .emit(&[], sink, emit_info, state);
-                    Inst::gen_jump(label_loop).emit(&[], sink, emit_info, state);
+                    .emit(sink, emit_info, state);
+                    Inst::gen_jump(label_loop).emit(sink, emit_info, state);
                 }
                 sink.bind_label(label_done, &mut state.ctrl_plane);
             }
@@ -2959,30 +2238,26 @@ impl Inst {
                 tmp2,
                 rd,
             } => {
-                Inst::gen_move(rd, zero_reg(), I64).emit(&[], sink, emit_info, state);
-                Inst::load_imm12(step, Imm12::from_i16(ty.bits() as i16)).emit(
-                    &[],
-                    sink,
-                    emit_info,
-                    state,
-                );
+                Inst::gen_move(rd, zero_reg(), I64).emit(sink, emit_info, state);
+                Inst::load_imm12(step, Imm12::from_i16(ty.bits() as i16))
+                    .emit(sink, emit_info, state);
                 //
-                Inst::load_imm12(tmp, Imm12::ONE).emit(&[], sink, emit_info, state);
+                Inst::load_imm12(tmp, Imm12::ONE).emit(sink, emit_info, state);
                 Inst::AluRRImm12 {
                     alu_op: AluOPRRI::Slli,
                     rd: tmp,
                     rs: tmp.to_reg(),
                     imm12: Imm12::from_i16((ty.bits() - 1) as i16),
                 }
-                .emit(&[], sink, emit_info, state);
-                Inst::load_imm12(tmp2, Imm12::ONE).emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
+                Inst::load_imm12(tmp2, Imm12::ONE).emit(sink, emit_info, state);
                 Inst::AluRRImm12 {
                     alu_op: AluOPRRI::Slli,
                     rd: tmp2,
                     rs: tmp2.to_reg(),
                     imm12: Imm12::from_i16((ty.bits() - 8) as i16),
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
 
                 let label_done = sink.get_label();
                 let label_loop = sink.get_label();
@@ -2996,7 +2271,7 @@ impl Inst {
                         rs2: zero_reg(),
                     },
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
                 // test and set bit.
                 {
                     Inst::AluRRR {
@@ -3005,7 +2280,7 @@ impl Inst {
                         rs1: tmp.to_reg(),
                         rs2: rs,
                     }
-                    .emit(&[], sink, emit_info, state);
+                    .emit(sink, emit_info, state);
                     let label_over = sink.get_label();
                     Inst::CondBr {
                         taken: CondBrTarget::Label(label_over),
@@ -3016,14 +2291,14 @@ impl Inst {
                             rs2: spilltmp_reg2(),
                         },
                     }
-                    .emit(&[], sink, emit_info, state);
+                    .emit(sink, emit_info, state);
                     Inst::AluRRR {
                         alu_op: AluOPRRR::Or,
                         rd: rd,
                         rs1: rd.to_reg(),
                         rs2: tmp2.to_reg(),
                     }
-                    .emit(&[], sink, emit_info, state);
+                    .emit(sink, emit_info, state);
                     sink.bind_label(label_over, &mut state.ctrl_plane);
                 }
                 // set step and tmp.
@@ -3034,33 +2309,29 @@ impl Inst {
                         rs: step.to_reg(),
                         imm12: Imm12::from_i16(-1),
                     }
-                    .emit(&[], sink, emit_info, state);
+                    .emit(sink, emit_info, state);
                     Inst::AluRRImm12 {
                         alu_op: AluOPRRI::Srli,
                         rd: tmp,
                         rs: tmp.to_reg(),
                         imm12: Imm12::ONE,
                     }
-                    .emit(&[], sink, emit_info, state);
+                    .emit(sink, emit_info, state);
                     {
                         // reset tmp2
                         // if (step %=8 == 0) then tmp2 = tmp2 >> 15
                         // if (step %=8 != 0) then tmp2 = tmp2 << 1
                         let label_over = sink.get_label();
                         let label_sll_1 = sink.get_label();
-                        Inst::load_imm12(writable_spilltmp_reg2(), Imm12::from_i16(8)).emit(
-                            &[],
-                            sink,
-                            emit_info,
-                            state,
-                        );
+                        Inst::load_imm12(writable_spilltmp_reg2(), Imm12::from_i16(8))
+                            .emit(sink, emit_info, state);
                         Inst::AluRRR {
                             alu_op: AluOPRRR::Rem,
                             rd: writable_spilltmp_reg2(),
                             rs1: step.to_reg(),
                             rs2: spilltmp_reg2(),
                         }
-                        .emit(&[], sink, emit_info, state);
+                        .emit(sink, emit_info, state);
                         Inst::CondBr {
                             taken: CondBrTarget::Label(label_sll_1),
                             not_taken: CondBrTarget::Fallthrough,
@@ -3070,15 +2341,15 @@ impl Inst {
                                 rs2: zero_reg(),
                             },
                         }
-                        .emit(&[], sink, emit_info, state);
+                        .emit(sink, emit_info, state);
                         Inst::AluRRImm12 {
                             alu_op: AluOPRRI::Srli,
                             rd: tmp2,
                             rs: tmp2.to_reg(),
                             imm12: Imm12::from_i16(15),
                         }
-                        .emit(&[], sink, emit_info, state);
-                        Inst::gen_jump(label_over).emit(&[], sink, emit_info, state);
+                        .emit(sink, emit_info, state);
+                        Inst::gen_jump(label_over).emit(sink, emit_info, state);
                         sink.bind_label(label_sll_1, &mut state.ctrl_plane);
                         Inst::AluRRImm12 {
                             alu_op: AluOPRRI::Slli,
@@ -3086,10 +2357,10 @@ impl Inst {
                             rs: tmp2.to_reg(),
                             imm12: Imm12::ONE,
                         }
-                        .emit(&[], sink, emit_info, state);
+                        .emit(sink, emit_info, state);
                         sink.bind_label(label_over, &mut state.ctrl_plane);
                     }
-                    Inst::gen_jump(label_loop).emit(&[], sink, emit_info, state);
+                    Inst::gen_jump(label_loop).emit(sink, emit_info, state);
                 }
                 sink.bind_label(label_done, &mut state.ctrl_plane);
             }
@@ -3101,10 +2372,10 @@ impl Inst {
                 let step = writable_spilltmp_reg();
                 Inst::load_constant_u64(step, (guard_size as u64) * (probe_count as u64))
                     .iter()
-                    .for_each(|i| i.emit(&[], sink, emit_info, state));
+                    .for_each(|i| i.emit(sink, emit_info, state));
                 Inst::load_constant_u64(guard_size_tmp, guard_size as u64)
                     .iter()
-                    .for_each(|i| i.emit(&[], sink, emit_info, state));
+                    .for_each(|i| i.emit(sink, emit_info, state));
 
                 let loop_start = sink.get_label();
                 let label_done = sink.get_label();
@@ -3118,7 +2389,7 @@ impl Inst {
                         rs2: guard_size_tmp.to_reg(),
                     },
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
                 // compute address.
                 Inst::AluRRR {
                     alu_op: AluOPRRR::Sub,
@@ -3126,14 +2397,14 @@ impl Inst {
                     rs1: stack_reg(),
                     rs2: step.to_reg(),
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
                 Inst::Store {
-                    to: AMode::RegOffset(spilltmp_reg2(), 0, I8),
+                    to: AMode::RegOffset(spilltmp_reg2(), 0),
                     op: StoreOP::Sb,
                     flags: MemFlags::new(),
                     src: zero_reg(),
                 }
-                .emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
                 // reset step.
                 Inst::AluRRR {
                     alu_op: AluOPRRR::Sub,
@@ -3141,8 +2412,8 @@ impl Inst {
                     rs1: step.to_reg(),
                     rs2: guard_size_tmp.to_reg(),
                 }
-                .emit(&[], sink, emit_info, state);
-                Inst::gen_jump(loop_start).emit(&[], sink, emit_info, state);
+                .emit(sink, emit_info, state);
+                Inst::gen_jump(loop_start).emit(sink, emit_info, state);
                 sink.bind_label(label_done, &mut state.ctrl_plane);
             }
             &Inst::VecAluRRRImm5 {
@@ -3218,7 +2489,7 @@ impl Inst {
                 ));
 
                 // Update the current vector emit state.
-                state.vstate = EmitVState::Known(vstate.clone());
+                state.vstate = EmitVState::Known(*vstate);
             }
 
             &Inst::VecLoad {
@@ -3243,18 +2514,17 @@ impl Inst {
                             let tmp = writable_spilltmp_reg();
                             Inst::LoadAddr {
                                 rd: tmp,
-                                mem: base.clone(),
+                                mem: *base,
                             }
-                            .emit(&[], sink, emit_info, state);
+                            .emit(sink, emit_info, state);
                             tmp.to_reg()
                         }
                     }
                 };
 
-                let srcloc = state.cur_srcloc();
-                if !srcloc.is_default() && !flags.notrap() {
+                if let Some(trap_code) = flags.trap_code() {
                     // Register the offset at which the actual load instruction starts.
-                    sink.add_trap(TrapCode::HeapOutOfBounds);
+                    sink.add_trap(trap_code);
                 }
 
                 sink.put4(encode_vmem_load(
@@ -3291,18 +2561,17 @@ impl Inst {
                             let tmp = writable_spilltmp_reg();
                             Inst::LoadAddr {
                                 rd: tmp,
-                                mem: base.clone(),
+                                mem: *base,
                             }
-                            .emit(&[], sink, emit_info, state);
+                            .emit(sink, emit_info, state);
                             tmp.to_reg()
                         }
                     }
                 };
 
-                let srcloc = state.cur_srcloc();
-                if !srcloc.is_default() && !flags.notrap() {
+                if let Some(trap_code) = flags.trap_code() {
                     // Register the offset at which the actual load instruction starts.
-                    sink.add_trap(TrapCode::HeapOutOfBounds);
+                    sink.add_trap(trap_code);
                 }
 
                 sink.put4(encode_vmem_store(
@@ -3318,737 +2587,107 @@ impl Inst {
             }
         };
     }
+}
 
-    fn allocate(self, allocs: &mut AllocationConsumer) -> Self {
-        fn alloc_value_regs(
-            orgin: &ValueRegs<Reg>,
-            alloc: &mut AllocationConsumer,
-        ) -> ValueRegs<Reg> {
-            match orgin.regs().len() {
-                1 => ValueRegs::one(alloc.next(orgin.regs()[0])),
-                2 => ValueRegs::two(alloc.next(orgin.regs()[0]), alloc.next(orgin.regs()[1])),
-                _ => unreachable!(),
-            }
-        }
-
-        fn alloc_writable_value_regs(
-            origin: &ValueRegs<Writable<Reg>>,
-            alloc: &mut AllocationConsumer,
-        ) -> ValueRegs<Writable<Reg>> {
-            alloc_value_regs(&origin.map(|r| r.to_reg()), alloc).map(Writable::from_reg)
-        }
-
-        match self {
-            Inst::Nop0 => self,
-            Inst::Nop4 => self,
-            Inst::RawData { .. } => self,
-            Inst::Lui { rd, imm } => Inst::Lui {
-                rd: allocs.next_writable(rd),
-                imm,
-            },
-            Inst::LoadInlineConst { rd, ty, imm } => Inst::LoadInlineConst {
-                rd: allocs.next_writable(rd),
-                ty,
-                imm,
-            },
-            Inst::FpuRR {
-                frm,
-                alu_op,
-                rd,
-                rs,
-            } => Inst::FpuRR {
-                rs: allocs.next(rs),
-                rd: allocs.next_writable(rd),
-                frm,
-                alu_op,
-            },
-            Inst::FpuRRRR {
-                alu_op,
-                rd,
-                rs1,
-                rs2,
-                rs3,
-                frm,
-            } => Inst::FpuRRRR {
-                rs1: allocs.next(rs1),
-                rs2: allocs.next(rs2),
-                rs3: allocs.next(rs3),
-                rd: allocs.next_writable(rd),
-                alu_op,
-                frm,
-            },
-            Inst::FpuRRR {
-                alu_op,
-                frm,
-                rd,
-                rs1,
-                rs2,
-            } => Inst::FpuRRR {
-                alu_op,
-                frm,
-                rs1: allocs.next(rs1),
-                rs2: allocs.next(rs2),
-                rd: allocs.next_writable(rd),
-            },
-            Inst::Unwind { .. } => self,
-            Inst::DummyUse { reg } => Inst::DummyUse {
-                reg: allocs.next(reg),
-            },
-            Inst::AluRRR {
-                alu_op,
-                rd,
-                rs1,
-                rs2,
-            } => Inst::AluRRR {
-                alu_op,
-                rs1: allocs.next(rs1),
-                rs2: allocs.next(rs2),
-                rd: allocs.next_writable(rd),
-            },
-            Inst::AluRRImm12 {
-                alu_op,
-                rd,
-                rs,
-                imm12,
-            } => Inst::AluRRImm12 {
-                alu_op,
-                rs: allocs.next(rs),
-                rd: allocs.next_writable(rd),
-                imm12,
-            },
-            Inst::CsrReg { op, rd, rs, csr } => Inst::CsrReg {
-                op,
-                rs: allocs.next(rs),
-                rd: allocs.next_writable(rd),
-                csr,
-            },
-            Inst::CsrImm { op, rd, csr, imm } => Inst::CsrImm {
-                op,
-                rd: allocs.next_writable(rd),
-                csr,
-                imm,
-            },
-            Inst::Load {
-                rd,
-                op,
-                from,
-                flags,
-            } => Inst::Load {
-                from: from.clone().with_allocs(allocs),
-                rd: allocs.next_writable(rd),
-                op,
-                flags,
-            },
-            Inst::Store { op, src, flags, to } => Inst::Store {
-                op,
-                flags,
-                to: to.clone().with_allocs(allocs),
-                src: allocs.next(src),
-            },
-
-            Inst::Args { .. } => self,
-            Inst::Rets { .. } => self,
-            Inst::Ret { .. } => self,
-
-            Inst::Extend {
-                rd,
-                rn,
-                signed,
-                from_bits,
-                to_bits,
-            } => Inst::Extend {
-                rn: allocs.next(rn),
-                rd: allocs.next_writable(rd),
-                signed,
-                from_bits,
-                to_bits,
-            },
-            Inst::AdjustSp { .. } => self,
-
-            Inst::Call { .. } => self,
-            Inst::CallInd { mut info } => {
-                info.rn = allocs.next(info.rn);
-                Inst::CallInd { info }
-            }
-
-            Inst::ReturnCall { callee, info } => {
-                for u in &info.uses {
-                    let _ = allocs.next(u.vreg);
-                }
-
-                Inst::ReturnCall { callee, info }
-            }
-
-            Inst::ReturnCallInd { callee, info } => {
-                let callee = allocs.next(callee);
-
-                for u in &info.uses {
-                    let _ = allocs.next(u.vreg);
-                }
-
-                Inst::ReturnCallInd { callee, info }
-            }
-
-            Inst::Jal { .. } => self,
-
-            Inst::CondBr {
-                taken,
-                not_taken,
-                mut kind,
-            } => {
-                kind.rs1 = allocs.next(kind.rs1);
-                kind.rs2 = allocs.next(kind.rs2);
-                Inst::CondBr {
-                    taken,
-                    not_taken,
-                    kind,
-                }
-            }
-
-            Inst::Mov { rd, rm, ty } => Inst::Mov {
-                ty,
-                rm: allocs.next(rm),
-                rd: allocs.next_writable(rd),
-            },
-
-            Inst::MovFromPReg { rd, rm } => {
-                debug_assert!([px_reg(2), px_reg(8)].contains(&rm));
-                let rd = allocs.next_writable(rd);
-                Inst::MovFromPReg { rd, rm }
-            }
-
-            Inst::BrTable {
-                index,
-                tmp1,
-                tmp2,
-                targets,
-            } => Inst::BrTable {
-                index: allocs.next(index),
-                tmp1: allocs.next_writable(tmp1),
-                tmp2: allocs.next_writable(tmp2),
-                targets,
-            },
-
-            Inst::VirtualSPOffsetAdj { .. } => self,
-            Inst::Atomic {
-                op,
-                rd,
-                addr,
-                src,
-                amo,
-            } => Inst::Atomic {
-                op,
-                amo,
-                addr: allocs.next(addr),
-                src: allocs.next(src),
-                rd: allocs.next_writable(rd),
-            },
-            Inst::Fence { .. } => self,
-            Inst::Auipc { rd, imm } => Inst::Auipc {
-                rd: allocs.next_writable(rd),
-                imm,
-            },
-
-            Inst::LoadAddr { rd, mem } => Inst::LoadAddr {
-                mem: mem.with_allocs(allocs),
-                rd: allocs.next_writable(rd),
-            },
-
-            Inst::Select {
-                ref dst,
-                condition,
-                ref x,
-                ref y,
-            } => {
-                let mut condition: IntegerCompare = condition.clone();
-                condition.rs1 = allocs.next(condition.rs1);
-                condition.rs2 = allocs.next(condition.rs2);
-                let x = alloc_value_regs(x, allocs);
-                let y = alloc_value_regs(y, allocs);
-                let dst = alloc_writable_value_regs(dst, allocs);
-
-                Inst::Select {
-                    dst,
-                    condition,
-                    x,
-                    y,
-                }
-            }
-            Inst::Jalr { rd, base, offset } => {
-                // For some reason this does not use base?
-                debug_assert!(base.is_real());
-                Inst::Jalr {
-                    rd: allocs.next_writable(rd),
-                    base,
-                    offset,
-                }
-            }
-
-            Inst::EBreak => self,
-
-            Inst::Icmp {
-                cc,
-                rd,
-                ref a,
-                ref b,
-                ty,
-            } => Inst::Icmp {
-                cc,
-                a: alloc_value_regs(a, allocs),
-                b: alloc_value_regs(b, allocs),
-                rd: allocs.next_writable(rd),
-                ty,
-            },
-
-            Inst::AtomicCas {
-                offset,
-                t0,
-                dst,
-                e,
-                addr,
-                v,
-                ty,
-            } => Inst::AtomicCas {
-                ty,
-                offset: allocs.next(offset),
-                e: allocs.next(e),
-                addr: allocs.next(addr),
-                v: allocs.next(v),
-                t0: allocs.next_writable(t0),
-                dst: allocs.next_writable(dst),
-            },
-
-            Inst::AtomicRmwLoop {
-                offset,
-                op,
-                dst,
-                ty,
-                p,
-                x,
-                t0,
-            } => Inst::AtomicRmwLoop {
-                op,
-                ty,
-                offset: allocs.next(offset),
-                p: allocs.next(p),
-                x: allocs.next(x),
-                t0: allocs.next_writable(t0),
-                dst: allocs.next_writable(dst),
-            },
-
-            Inst::FcvtToInt {
-                is_sat,
-                rd,
-                rs,
-                is_signed,
-                in_type,
-                out_type,
-                tmp,
-            } => Inst::FcvtToInt {
-                is_sat,
-                is_signed,
-                in_type,
-                out_type,
-                rs: allocs.next(rs),
-                tmp: allocs.next_writable(tmp),
-                rd: allocs.next_writable(rd),
-            },
-
-            Inst::LoadExtName { rd, name, offset } => Inst::LoadExtName {
-                rd: allocs.next_writable(rd),
-                name,
-                offset,
-            },
-
-            Inst::ElfTlsGetAddr { rd, name } => {
-                let rd = allocs.next_writable(rd);
-                debug_assert_eq!(a0(), rd.to_reg());
-                Inst::ElfTlsGetAddr { rd, name }
-            }
-
-            Inst::TrapIf {
-                rs1,
-                rs2,
-                cc,
-                trap_code,
-            } => Inst::TrapIf {
-                rs1: allocs.next(rs1),
-                rs2: allocs.next(rs2),
-                cc,
-                trap_code,
-            },
-
-            Inst::Udf { .. } => self,
-
-            Inst::AtomicLoad { rd, ty, p } => Inst::AtomicLoad {
-                ty,
-                p: allocs.next(p),
-                rd: allocs.next_writable(rd),
-            },
-
-            Inst::AtomicStore { src, ty, p } => Inst::AtomicStore {
-                ty,
-                src: allocs.next(src),
-                p: allocs.next(p),
-            },
-
-            Inst::FloatRound {
-                op,
-                rd,
-                int_tmp,
-                f_tmp,
-                rs,
-                ty,
-            } => Inst::FloatRound {
-                op,
-                ty,
-                rs: allocs.next(rs),
-                int_tmp: allocs.next_writable(int_tmp),
-                f_tmp: allocs.next_writable(f_tmp),
-                rd: allocs.next_writable(rd),
-            },
-
-            Inst::FloatSelect {
-                op,
-                rd,
-                tmp,
-                rs1,
-                rs2,
-                ty,
-            } => Inst::FloatSelect {
-                op,
-                ty,
-                rs1: allocs.next(rs1),
-                rs2: allocs.next(rs2),
-                tmp: allocs.next_writable(tmp),
-                rd: allocs.next_writable(rd),
-            },
-
-            Inst::Popcnt {
-                sum,
-                tmp,
-                step,
-                rs,
-                ty,
-            } => Inst::Popcnt {
-                rs: allocs.next(rs),
-                tmp: allocs.next_writable(tmp),
-                step: allocs.next_writable(step),
-                sum: allocs.next_writable(sum),
-                ty,
-            },
-
-            Inst::Rev8 { rs, rd, tmp, step } => Inst::Rev8 {
-                rs: allocs.next(rs),
-                tmp: allocs.next_writable(tmp),
-                step: allocs.next_writable(step),
-                rd: allocs.next_writable(rd),
-            },
-
-            Inst::Cltz {
-                sum,
-                tmp,
-                step,
-                rs,
-                leading,
-                ty,
-            } => Inst::Cltz {
-                rs: allocs.next(rs),
-                tmp: allocs.next_writable(tmp),
-                step: allocs.next_writable(step),
-                sum: allocs.next_writable(sum),
-                leading,
-                ty,
-            },
-
-            Inst::Brev8 {
-                rs,
-                ty,
-                step,
-                tmp,
-                tmp2,
-                rd,
-            } => Inst::Brev8 {
-                rs: allocs.next(rs),
-                step: allocs.next_writable(step),
-                tmp: allocs.next_writable(tmp),
-                tmp2: allocs.next_writable(tmp2),
-                rd: allocs.next_writable(rd),
-                ty,
-            },
-
-            Inst::StackProbeLoop { .. } => self,
-
-            Inst::VecAluRRRImm5 {
-                op,
-                vd,
-                vd_src,
-                imm,
-                vs2,
-                mask,
-                vstate,
-            } => Inst::VecAluRRRImm5 {
-                op,
-                vs2: allocs.next(vs2),
-                vd_src: allocs.next(vd_src),
-                vd: allocs.next_writable(vd),
-                mask: mask.with_allocs(allocs),
-                imm,
-                vstate,
-            },
-
-            Inst::VecAluRRRR {
-                op,
-                vd,
-                vd_src,
-                vs1,
-                vs2,
-                mask,
-                vstate,
-            } => Inst::VecAluRRRR {
-                op,
-                vs1: allocs.next(vs1),
-                vs2: allocs.next(vs2),
-                vd_src: allocs.next(vd_src),
-                vd: allocs.next_writable(vd),
-                mask: mask.with_allocs(allocs),
-                vstate,
-            },
-
-            Inst::VecAluRRR {
-                op,
-                vd,
-                vs1,
-                vs2,
-                mask,
-                vstate,
-            } => Inst::VecAluRRR {
-                op,
-                vs1: allocs.next(vs1),
-                vs2: allocs.next(vs2),
-                vd: allocs.next_writable(vd),
-                mask: mask.with_allocs(allocs),
-                vstate,
-            },
-
-            Inst::VecAluRRImm5 {
-                op,
-                vd,
-                imm,
-                vs2,
-                mask,
-                vstate,
-            } => Inst::VecAluRRImm5 {
-                op,
-                imm,
-                vs2: allocs.next(vs2),
-                vd: allocs.next_writable(vd),
-                mask: mask.with_allocs(allocs),
-                vstate,
-            },
-
-            Inst::VecAluRR {
-                op,
-                vd,
-                vs,
-                mask,
-                vstate,
-            } => Inst::VecAluRR {
-                op,
-                vs: allocs.next(vs),
-                vd: allocs.next_writable(vd),
-                mask: mask.with_allocs(allocs),
-                vstate,
-            },
-
-            Inst::VecAluRImm5 {
-                op,
-                vd,
-                imm,
-                mask,
-                vstate,
-            } => Inst::VecAluRImm5 {
-                vd: allocs.next_writable(vd),
-                mask: mask.with_allocs(allocs),
-                op,
-                imm,
-                vstate,
-            },
+fn emit_return_call_common_sequence(
+    sink: &mut MachBuffer<Inst>,
+    emit_info: &EmitInfo,
+    state: &mut EmitState,
+    info: &ReturnCallInfo,
+) {
+    // The return call sequence can potentially emit a lot of instructions (up to 634 bytes!)
+    // So lets emit an island here if we need it.
+    //
+    // It is difficult to calculate exactly how many instructions are going to be emitted, so
+    // we calculate it by emitting it into a disposable buffer, and then checking how many instructions
+    // were actually emitted.
+    let mut buffer = MachBuffer::new();
+    let mut fake_emit_state = state.clone();
 
-            Inst::VecSetState { rd, vstate } => Inst::VecSetState {
-                rd: allocs.next_writable(rd),
-                vstate,
-            },
+    return_call_emit_impl(&mut buffer, emit_info, &mut fake_emit_state, info);
 
-            Inst::VecLoad {
-                eew,
-                to,
-                from,
-                mask,
-                flags,
-                vstate,
-            } => Inst::VecLoad {
-                eew,
-                from: from.clone().with_allocs(allocs),
-                to: allocs.next_writable(to),
-                mask: mask.with_allocs(allocs),
-                flags,
-                vstate,
-            },
+    // Finalize the buffer and get the number of bytes emitted.
+    let buffer = buffer.finish(&Default::default(), &mut Default::default());
+    let length = buffer.data().len() as u32;
 
-            Inst::VecStore {
-                eew,
-                to,
-                from,
-                mask,
-                flags,
-                vstate,
-            } => Inst::VecStore {
-                eew,
-                to: to.clone().with_allocs(allocs),
-                from: allocs.next(from),
-                mask: mask.with_allocs(allocs),
-                flags,
-                vstate,
-            },
-        }
+    // And now emit the island inline with this instruction.
+    if sink.island_needed(length) {
+        let jump_around_label = sink.get_label();
+        Inst::gen_jump(jump_around_label).emit(sink, emit_info, state);
+        sink.emit_island(length + 4, &mut state.ctrl_plane);
+        sink.bind_label(jump_around_label, &mut state.ctrl_plane);
     }
+
+    // Now that we're done, emit the *actual* return sequence.
+    return_call_emit_impl(sink, emit_info, state, info);
 }
 
-fn emit_return_call_common_sequence(
+/// This should not be called directly, Instead prefer to call [emit_return_call_common_sequence].
+fn return_call_emit_impl(
     sink: &mut MachBuffer<Inst>,
     emit_info: &EmitInfo,
     state: &mut EmitState,
-    new_stack_arg_size: u32,
-    old_stack_arg_size: u32,
+    info: &ReturnCallInfo,
 ) {
-    // We are emitting a dynamic number of instructions and might need an
-    // island. We emit four instructions regardless of how many stack arguments
-    // we have, up to two instructions for the actual call, and then two
-    // instructions per word of stack argument space.
-    let new_stack_words = new_stack_arg_size / 8;
-    let insts = 4 + 2 + 2 * new_stack_words;
-    let space_needed = insts * u32::try_from(Inst::UNCOMPRESSED_INSTRUCTION_SIZE).unwrap();
-    if sink.island_needed(space_needed) {
-        let jump_around_label = sink.get_label();
-        Inst::gen_jump(jump_around_label).emit(&[], sink, emit_info, state);
-        sink.emit_island(space_needed + 4, &mut state.ctrl_plane);
-        sink.bind_label(jump_around_label, &mut state.ctrl_plane);
+    let sp_to_fp_offset = {
+        let frame_layout = state.frame_layout();
+        i64::from(
+            frame_layout.clobber_size
+                + frame_layout.fixed_frame_storage_size
+                + frame_layout.outgoing_args_size,
+        )
+    };
+
+    let mut clobber_offset = sp_to_fp_offset - 8;
+    for reg in state.frame_layout().clobbered_callee_saves.clone() {
+        let rreg = reg.to_reg();
+        let ty = match rreg.class() {
+            RegClass::Int => I64,
+            RegClass::Float => F64,
+            RegClass::Vector => unimplemented!("Vector Clobber Restores"),
+        };
+
+        Inst::gen_load(
+            reg.map(Reg::from),
+            AMode::SPOffset(clobber_offset),
+            ty,
+            MemFlags::trusted(),
+        )
+        .emit(sink, emit_info, state);
+
+        clobber_offset -= 8
     }
 
-    // Copy the new frame on top of our current frame.
-    //
-    // The current stack layout is the following:
-    //
-    //            | ...                 |
-    //            +---------------------+
-    //            | ...                 |
-    //            | stack arguments     |
-    //            | ...                 |
-    //    current | return address      |
-    //    frame   | old FP              | <-- FP
-    //            | ...                 |
-    //            | old stack slots     |
-    //            | ...                 |
-    //            +---------------------+
-    //            | ...                 |
-    //    new     | new stack arguments |
-    //    frame   | ...                 | <-- SP
-    //            +---------------------+
-    //
-    // We need to restore the old FP, restore the return address from the stack
-    // to the link register, copy the new stack arguments over the old stack
-    // arguments, adjust SP to point to the new stack arguments, and then jump
-    // to the callee (which will push the old FP and RA again). Note that the
-    // actual jump happens outside this helper function.
-
-    assert_eq!(
-        new_stack_arg_size % 8,
-        0,
-        "size of new stack arguments must be 8-byte aligned"
-    );
-
-    // The delta from our frame pointer to the (eventual) stack pointer value
-    // when we jump to the tail callee. This is the difference in size of stack
-    // arguments as well as accounting for the two words we pushed onto the
-    // stack upon entry to this function (the return address and old frame
-    // pointer).
-    let fp_to_callee_sp = i64::from(old_stack_arg_size) - i64::from(new_stack_arg_size) + 16;
-
-    let tmp1 = regs::writable_spilltmp_reg();
-    let tmp2 = regs::writable_spilltmp_reg2();
-
-    // Restore the return address to the link register, and load the old FP into
-    // a temporary register.
-    //
-    // We can't put the old FP into the FP register until after we copy the
-    // stack arguments into place, since that uses address modes that are
-    // relative to our current FP.
-    //
-    // Note that the FP is saved in the function prologue for all non-leaf
-    // functions, even when `preserve_frame_pointers=false`. Note also that
-    // `return_call` instructions make it so that a function is considered
-    // non-leaf. Therefore we always have an FP to restore here.
-
-    Inst::gen_load(
-        writable_link_reg(),
-        AMode::FPOffset(8, I64),
-        I64,
-        MemFlags::trusted(),
-    )
-    .emit(&[], sink, emit_info, state);
-    Inst::gen_load(tmp1, AMode::FPOffset(0, I64), I64, MemFlags::trusted()).emit(
-        &[],
-        sink,
-        emit_info,
-        state,
-    );
-
-    // Copy the new stack arguments over the old stack arguments.
-    for i in (0..new_stack_words).rev() {
-        // Load the `i`th new stack argument word from the temporary stack
-        // space.
+    // Restore the link register and frame pointer
+    let setup_area_size = i64::from(state.frame_layout().setup_area_size);
+    if setup_area_size > 0 {
         Inst::gen_load(
-            tmp2,
-            AMode::SPOffset(i64::from(i * 8), types::I64),
-            types::I64,
-            ir::MemFlags::trusted(),
+            writable_link_reg(),
+            AMode::SPOffset(sp_to_fp_offset + 8),
+            I64,
+            MemFlags::trusted(),
         )
-        .emit(&[], sink, emit_info, state);
-
-        // Store it to its final destination on the stack, overwriting our
-        // current frame.
-        Inst::gen_store(
-            AMode::FPOffset(fp_to_callee_sp + i64::from(i * 8), types::I64),
-            tmp2.to_reg(),
-            types::I64,
-            ir::MemFlags::trusted(),
+        .emit(sink, emit_info, state);
+
+        Inst::gen_load(
+            writable_fp_reg(),
+            AMode::SPOffset(sp_to_fp_offset),
+            I64,
+            MemFlags::trusted(),
         )
-        .emit(&[], sink, emit_info, state);
+        .emit(sink, emit_info, state);
     }
 
-    // Initialize the SP for the tail callee, deallocating the temporary stack
-    // argument space and our current frame at the same time.
-    Inst::AluRRImm12 {
-        alu_op: AluOPRRI::Addi,
-        rd: regs::writable_stack_reg(),
-        rs: regs::fp_reg(),
-        imm12: Imm12::maybe_from_i64(fp_to_callee_sp).unwrap(),
-    }
-    .emit(&[], sink, emit_info, state);
+    // If we over-allocated the incoming args area in the prologue, resize down to what the callee
+    // is expecting.
+    let incoming_args_diff =
+        i64::from(state.frame_layout().tail_args_size - info.new_stack_arg_size);
 
-    // Move the old FP value from the temporary into the FP register.
-    Inst::Mov {
-        ty: types::I64,
-        rd: regs::writable_fp_reg(),
-        rm: tmp1.to_reg(),
+    // Increment SP all at once
+    let sp_increment = sp_to_fp_offset + setup_area_size + incoming_args_diff;
+    if sp_increment > 0 {
+        for inst in Riscv64MachineDeps::gen_sp_reg_adjust(i32::try_from(sp_increment).unwrap()) {
+            inst.emit(sink, emit_info, state);
+        }
     }
-    .emit(&[], sink, emit_info, state);
-
-    state.virtual_sp_offset -= i64::from(new_stack_arg_size);
-    trace!(
-        "return_call[_ind] adjusts virtual sp offset by {} -> {}",
-        new_stack_arg_size,
-        state.virtual_sp_offset
-    );
 }
diff --git a/cranelift/codegen/src/isa/riscv64/inst/emit_tests.rs b/cranelift/codegen/src/isa/riscv64/inst/emit_tests.rs
index 111259278469..4899109f3eb2 100644
--- a/cranelift/codegen/src/isa/riscv64/inst/emit_tests.rs
+++ b/cranelift/codegen/src/isa/riscv64/inst/emit_tests.rs
@@ -1,10 +1,13 @@
 #[allow(unused)]
 use crate::ir::LibCall;
 use crate::isa::riscv64::inst::*;
-use crate::settings;
-use alloc::vec::Vec;
+use crate::isa::riscv64::lower::isle::generated_code::FpuOPWidth;
 use std::borrow::Cow;
 
+fn fa7() -> Reg {
+    f_reg(17)
+}
+
 #[test]
 fn test_riscv64_binemit() {
     struct TestUnit {
@@ -629,7 +632,7 @@ fn test_riscv64_binemit() {
             rd: writable_a0(),
             op: LoadOP::Lb,
             flags: MemFlags::new(),
-            from: AMode::RegOffset(a1(), 100, I8),
+            from: AMode::RegOffset(a1(), 100),
         },
         "lb a0,100(a1)",
         0x6458503,
@@ -639,7 +642,7 @@ fn test_riscv64_binemit() {
             rd: writable_a0(),
             op: LoadOP::Lh,
             flags: MemFlags::new(),
-            from: AMode::RegOffset(a1(), 100, I16),
+            from: AMode::RegOffset(a1(), 100),
         },
         "lh a0,100(a1)",
         0x6459503,
@@ -650,7 +653,7 @@ fn test_riscv64_binemit() {
             rd: writable_a0(),
             op: LoadOP::Lw,
             flags: MemFlags::new(),
-            from: AMode::RegOffset(a1(), 100, I32),
+            from: AMode::RegOffset(a1(), 100),
         },
         "lw a0,100(a1)",
         0x645a503,
@@ -661,7 +664,7 @@ fn test_riscv64_binemit() {
             rd: writable_a0(),
             op: LoadOP::Ld,
             flags: MemFlags::new(),
-            from: AMode::RegOffset(a1(), 100, I64),
+            from: AMode::RegOffset(a1(), 100),
         },
         "ld a0,100(a1)",
         0x645b503,
@@ -671,7 +674,7 @@ fn test_riscv64_binemit() {
             rd: Writable::from_reg(fa0()),
             op: LoadOP::Flw,
             flags: MemFlags::new(),
-            from: AMode::RegOffset(a1(), 100, I64),
+            from: AMode::RegOffset(a1(), 100),
         },
         "flw fa0,100(a1)",
         0x645a507,
@@ -682,14 +685,14 @@ fn test_riscv64_binemit() {
             rd: Writable::from_reg(fa0()),
             op: LoadOP::Fld,
             flags: MemFlags::new(),
-            from: AMode::RegOffset(a1(), 100, I64),
+            from: AMode::RegOffset(a1(), 100),
         },
         "fld fa0,100(a1)",
         0x645b507,
     ));
     insns.push(TestUnit::new(
         Inst::Store {
-            to: AMode::SPOffset(100, I8),
+            to: AMode::SPOffset(100),
             op: StoreOP::Sb,
             flags: MemFlags::new(),
             src: a0(),
@@ -699,7 +702,7 @@ fn test_riscv64_binemit() {
     ));
     insns.push(TestUnit::new(
         Inst::Store {
-            to: AMode::SPOffset(100, I16),
+            to: AMode::SPOffset(100),
             op: StoreOP::Sh,
             flags: MemFlags::new(),
             src: a0(),
@@ -709,7 +712,7 @@ fn test_riscv64_binemit() {
     ));
     insns.push(TestUnit::new(
         Inst::Store {
-            to: AMode::SPOffset(100, I32),
+            to: AMode::SPOffset(100),
             op: StoreOP::Sw,
             flags: MemFlags::new(),
             src: a0(),
@@ -719,7 +722,7 @@ fn test_riscv64_binemit() {
     ));
     insns.push(TestUnit::new(
         Inst::Store {
-            to: AMode::SPOffset(100, I64),
+            to: AMode::SPOffset(100),
             op: StoreOP::Sd,
             flags: MemFlags::new(),
             src: a0(),
@@ -729,7 +732,7 @@ fn test_riscv64_binemit() {
     ));
     insns.push(TestUnit::new(
         Inst::Store {
-            to: AMode::SPOffset(100, I64),
+            to: AMode::SPOffset(100),
             op: StoreOP::Fsw,
             flags: MemFlags::new(),
             src: fa0(),
@@ -739,7 +742,7 @@ fn test_riscv64_binemit() {
     ));
     insns.push(TestUnit::new(
         Inst::Store {
-            to: AMode::SPOffset(100, I64),
+            to: AMode::SPOffset(100),
             op: StoreOP::Fsd,
             flags: MemFlags::new(),
             src: fa0(),
@@ -1156,8 +1159,9 @@ fn test_riscv64_binemit() {
     //
     insns.push(TestUnit::new(
         Inst::FpuRRR {
-            frm: Some(FRM::RNE),
-            alu_op: FpuOPRRR::FaddS,
+            frm: FRM::RNE,
+            width: FpuOPWidth::S,
+            alu_op: FpuOPRRR::Fadd,
             rd: writable_fa0(),
             rs1: fa0(),
             rs2: fa1(),
@@ -1167,8 +1171,9 @@ fn test_riscv64_binemit() {
     ));
     insns.push(TestUnit::new(
         Inst::FpuRRR {
-            frm: Some(FRM::RTZ),
-            alu_op: FpuOPRRR::FsubS,
+            frm: FRM::RTZ,
+            width: FpuOPWidth::S,
+            alu_op: FpuOPRRR::Fsub,
             rd: writable_fa0(),
             rs1: fa0(),
             rs2: fa1(),
@@ -1178,8 +1183,9 @@ fn test_riscv64_binemit() {
     ));
     insns.push(TestUnit::new(
         Inst::FpuRRR {
-            frm: Some(FRM::RUP),
-            alu_op: FpuOPRRR::FmulS,
+            frm: FRM::RUP,
+            width: FpuOPWidth::S,
+            alu_op: FpuOPRRR::Fmul,
             rd: writable_fa0(),
             rs1: fa0(),
             rs2: fa1(),
@@ -1189,19 +1195,21 @@ fn test_riscv64_binemit() {
     ));
     insns.push(TestUnit::new(
         Inst::FpuRRR {
-            frm: None,
-            alu_op: FpuOPRRR::FdivS,
+            frm: FRM::Fcsr,
+            width: FpuOPWidth::S,
+            alu_op: FpuOPRRR::Fdiv,
             rd: writable_fa0(),
             rs1: fa0(),
             rs2: fa1(),
         },
-        "fdiv.s fa0,fa0,fa1",
+        "fdiv.s fa0,fa0,fa1,fcsr",
         0x18b57553,
     ));
     insns.push(TestUnit::new(
         Inst::FpuRRR {
-            frm: None,
-            alu_op: FpuOPRRR::FsgnjS,
+            frm: FRM::RNE,
+            width: FpuOPWidth::S,
+            alu_op: FpuOPRRR::Fsgnj,
             rd: writable_fa0(),
             rs1: fa0(),
             rs2: fa1(),
@@ -1211,8 +1219,9 @@ fn test_riscv64_binemit() {
     ));
     insns.push(TestUnit::new(
         Inst::FpuRRR {
-            frm: None,
-            alu_op: FpuOPRRR::FsgnjnS,
+            frm: FRM::RTZ,
+            width: FpuOPWidth::S,
+            alu_op: FpuOPRRR::Fsgnjn,
             rd: writable_fa0(),
             rs1: fa0(),
             rs2: fa1(),
@@ -1223,8 +1232,9 @@ fn test_riscv64_binemit() {
 
     insns.push(TestUnit::new(
         Inst::FpuRRR {
-            frm: None,
-            alu_op: FpuOPRRR::FsgnjxS,
+            frm: FRM::RDN,
+            width: FpuOPWidth::S,
+            alu_op: FpuOPRRR::Fsgnjx,
             rd: writable_fa0(),
             rs1: fa0(),
             rs2: fa1(),
@@ -1234,8 +1244,9 @@ fn test_riscv64_binemit() {
     ));
     insns.push(TestUnit::new(
         Inst::FpuRRR {
-            frm: None,
-            alu_op: FpuOPRRR::FminS,
+            frm: FRM::RNE,
+            width: FpuOPWidth::S,
+            alu_op: FpuOPRRR::Fmin,
             rd: writable_fa0(),
             rs1: fa0(),
             rs2: fa1(),
@@ -1246,8 +1257,9 @@ fn test_riscv64_binemit() {
 
     insns.push(TestUnit::new(
         Inst::FpuRRR {
-            frm: None,
-            alu_op: FpuOPRRR::FmaxS,
+            frm: FRM::RTZ,
+            width: FpuOPWidth::S,
+            alu_op: FpuOPRRR::Fmax,
             rd: writable_fa0(),
             rs1: fa0(),
             rs2: fa1(),
@@ -1257,8 +1269,9 @@ fn test_riscv64_binemit() {
     ));
     insns.push(TestUnit::new(
         Inst::FpuRRR {
-            frm: None,
-            alu_op: FpuOPRRR::FeqS,
+            frm: FRM::RDN,
+            width: FpuOPWidth::S,
+            alu_op: FpuOPRRR::Feq,
             rd: writable_a0(),
             rs1: fa0(),
             rs2: fa1(),
@@ -1268,8 +1281,9 @@ fn test_riscv64_binemit() {
     ));
     insns.push(TestUnit::new(
         Inst::FpuRRR {
-            frm: None,
-            alu_op: FpuOPRRR::FltS,
+            frm: FRM::RTZ,
+            width: FpuOPWidth::S,
+            alu_op: FpuOPRRR::Flt,
             rd: writable_a0(),
             rs1: fa0(),
             rs2: fa1(),
@@ -1279,8 +1293,9 @@ fn test_riscv64_binemit() {
     ));
     insns.push(TestUnit::new(
         Inst::FpuRRR {
-            frm: None,
-            alu_op: FpuOPRRR::FleS,
+            frm: FRM::RNE,
+            width: FpuOPWidth::S,
+            alu_op: FpuOPRRR::Fle,
             rd: writable_a0(),
             rs1: fa0(),
             rs2: fa1(),
@@ -1292,52 +1307,57 @@ fn test_riscv64_binemit() {
     //
     insns.push(TestUnit::new(
         Inst::FpuRRR {
-            frm: None,
-            alu_op: FpuOPRRR::FaddD,
+            frm: FRM::Fcsr,
+            width: FpuOPWidth::D,
+            alu_op: FpuOPRRR::Fadd,
             rd: writable_fa0(),
             rs1: fa0(),
             rs2: fa1(),
         },
-        "fadd.d fa0,fa0,fa1",
+        "fadd.d fa0,fa0,fa1,fcsr",
         0x2b57553,
     ));
     insns.push(TestUnit::new(
         Inst::FpuRRR {
-            frm: None,
-            alu_op: FpuOPRRR::FsubD,
+            frm: FRM::Fcsr,
+            width: FpuOPWidth::D,
+            alu_op: FpuOPRRR::Fsub,
             rd: writable_fa0(),
             rs1: fa0(),
             rs2: fa1(),
         },
-        "fsub.d fa0,fa0,fa1",
+        "fsub.d fa0,fa0,fa1,fcsr",
         0xab57553,
     ));
     insns.push(TestUnit::new(
         Inst::FpuRRR {
-            frm: None,
-            alu_op: FpuOPRRR::FmulD,
+            frm: FRM::Fcsr,
+            width: FpuOPWidth::D,
+            alu_op: FpuOPRRR::Fmul,
             rd: writable_fa0(),
             rs1: fa0(),
             rs2: fa1(),
         },
-        "fmul.d fa0,fa0,fa1",
+        "fmul.d fa0,fa0,fa1,fcsr",
         0x12b57553,
     ));
     insns.push(TestUnit::new(
         Inst::FpuRRR {
-            frm: None,
-            alu_op: FpuOPRRR::FdivD,
+            frm: FRM::Fcsr,
+            width: FpuOPWidth::D,
+            alu_op: FpuOPRRR::Fdiv,
             rd: writable_fa0(),
             rs1: fa0(),
             rs2: fa1(),
         },
-        "fdiv.d fa0,fa0,fa1",
+        "fdiv.d fa0,fa0,fa1,fcsr",
         0x1ab57553,
     ));
     insns.push(TestUnit::new(
         Inst::FpuRRR {
-            frm: None,
-            alu_op: FpuOPRRR::FsgnjD,
+            frm: FRM::RNE,
+            width: FpuOPWidth::D,
+            alu_op: FpuOPRRR::Fsgnj,
             rd: writable_fa0(),
             rs1: fa0(),
             rs2: fa1(),
@@ -1347,8 +1367,9 @@ fn test_riscv64_binemit() {
     ));
     insns.push(TestUnit::new(
         Inst::FpuRRR {
-            frm: None,
-            alu_op: FpuOPRRR::FsgnjnD,
+            frm: FRM::RTZ,
+            width: FpuOPWidth::D,
+            alu_op: FpuOPRRR::Fsgnjn,
             rd: writable_fa0(),
             rs1: fa0(),
             rs2: fa1(),
@@ -1359,8 +1380,9 @@ fn test_riscv64_binemit() {
 
     insns.push(TestUnit::new(
         Inst::FpuRRR {
-            frm: None,
-            alu_op: FpuOPRRR::FsgnjxD,
+            frm: FRM::RDN,
+            width: FpuOPWidth::D,
+            alu_op: FpuOPRRR::Fsgnjx,
             rd: writable_fa0(),
             rs1: fa0(),
             rs2: fa1(),
@@ -1370,8 +1392,9 @@ fn test_riscv64_binemit() {
     ));
     insns.push(TestUnit::new(
         Inst::FpuRRR {
-            frm: None,
-            alu_op: FpuOPRRR::FminD,
+            frm: FRM::RNE,
+            width: FpuOPWidth::D,
+            alu_op: FpuOPRRR::Fmin,
             rd: writable_fa0(),
             rs1: fa0(),
             rs2: fa1(),
@@ -1382,8 +1405,9 @@ fn test_riscv64_binemit() {
 
     insns.push(TestUnit::new(
         Inst::FpuRRR {
-            frm: None,
-            alu_op: FpuOPRRR::FmaxD,
+            frm: FRM::RTZ,
+            width: FpuOPWidth::D,
+            alu_op: FpuOPRRR::Fmax,
             rd: writable_fa0(),
             rs1: fa0(),
             rs2: fa1(),
@@ -1393,8 +1417,9 @@ fn test_riscv64_binemit() {
     ));
     insns.push(TestUnit::new(
         Inst::FpuRRR {
-            frm: None,
-            alu_op: FpuOPRRR::FeqD,
+            frm: FRM::RDN,
+            width: FpuOPWidth::D,
+            alu_op: FpuOPRRR::Feq,
             rd: writable_a0(),
             rs1: fa0(),
             rs2: fa1(),
@@ -1404,8 +1429,9 @@ fn test_riscv64_binemit() {
     ));
     insns.push(TestUnit::new(
         Inst::FpuRRR {
-            frm: None,
-            alu_op: FpuOPRRR::FltD,
+            frm: FRM::RTZ,
+            width: FpuOPWidth::D,
+            alu_op: FpuOPRRR::Flt,
             rd: writable_a0(),
             rs1: fa0(),
             rs2: fa1(),
@@ -1415,8 +1441,9 @@ fn test_riscv64_binemit() {
     ));
     insns.push(TestUnit::new(
         Inst::FpuRRR {
-            frm: None,
-            alu_op: FpuOPRRR::FleD,
+            frm: FRM::RNE,
+            width: FpuOPWidth::D,
+            alu_op: FpuOPRRR::Fle,
             rd: writable_a0(),
             rs1: fa0(),
             rs2: fa1(),
@@ -1428,8 +1455,9 @@ fn test_riscv64_binemit() {
     //
     insns.push(TestUnit::new(
         Inst::FpuRR {
-            frm: Some(FRM::RNE),
-            alu_op: FpuOPRR::FsqrtS,
+            frm: FRM::RNE,
+            width: FpuOPWidth::S,
+            alu_op: FpuOPRR::Fsqrt,
             rd: writable_fa0(),
             rs: fa1(),
         },
@@ -1438,29 +1466,32 @@ fn test_riscv64_binemit() {
     ));
     insns.push(TestUnit::new(
         Inst::FpuRR {
-            frm: None,
-            alu_op: FpuOPRR::FcvtWS,
+            frm: FRM::Fcsr,
+            width: FpuOPWidth::S,
+            alu_op: FpuOPRR::FcvtWFmt,
             rd: writable_a0(),
             rs: fa1(),
         },
-        "fcvt.w.s a0,fa1",
+        "fcvt.w.s a0,fa1,fcsr",
         0xc005f553,
     ));
 
     insns.push(TestUnit::new(
         Inst::FpuRR {
-            frm: None,
-            alu_op: FpuOPRR::FcvtWuS,
+            frm: FRM::Fcsr,
+            width: FpuOPWidth::S,
+            alu_op: FpuOPRR::FcvtWuFmt,
             rd: writable_a0(),
             rs: fa1(),
         },
-        "fcvt.wu.s a0,fa1",
+        "fcvt.wu.s a0,fa1,fcsr",
         0xc015f553,
     ));
     insns.push(TestUnit::new(
         Inst::FpuRR {
-            frm: None,
-            alu_op: FpuOPRR::FmvXW,
+            frm: FRM::RNE,
+            width: FpuOPWidth::S,
+            alu_op: FpuOPRR::FmvXFmt,
             rd: writable_a0(),
             rs: fa1(),
         },
@@ -1469,8 +1500,9 @@ fn test_riscv64_binemit() {
     ));
     insns.push(TestUnit::new(
         Inst::FpuRR {
-            frm: None,
-            alu_op: FpuOPRR::FclassS,
+            frm: FRM::RTZ,
+            width: FpuOPWidth::S,
+            alu_op: FpuOPRR::Fclass,
             rd: writable_a0(),
             rs: fa1(),
         },
@@ -1480,29 +1512,32 @@ fn test_riscv64_binemit() {
 
     insns.push(TestUnit::new(
         Inst::FpuRR {
-            frm: None,
-            alu_op: FpuOPRR::FcvtSw,
+            frm: FRM::Fcsr,
+            width: FpuOPWidth::S,
+            alu_op: FpuOPRR::FcvtFmtW,
             rd: writable_fa0(),
             rs: a0(),
         },
-        "fcvt.s.w fa0,a0",
+        "fcvt.s.w fa0,a0,fcsr",
         0xd0057553,
     ));
     insns.push(TestUnit::new(
         Inst::FpuRR {
-            frm: None,
-            alu_op: FpuOPRR::FcvtSwU,
+            frm: FRM::Fcsr,
+            width: FpuOPWidth::S,
+            alu_op: FpuOPRR::FcvtFmtWu,
             rd: writable_fa0(),
             rs: a0(),
         },
-        "fcvt.s.wu fa0,a0",
+        "fcvt.s.wu fa0,a0,fcsr",
         0xd0157553,
     ));
 
     insns.push(TestUnit::new(
         Inst::FpuRR {
-            frm: None,
-            alu_op: FpuOPRR::FmvWX,
+            frm: FRM::RNE,
+            width: FpuOPWidth::S,
+            alu_op: FpuOPRR::FmvFmtX,
             rd: writable_fa0(),
             rs: a0(),
         },
@@ -1511,82 +1546,88 @@ fn test_riscv64_binemit() {
     ));
     insns.push(TestUnit::new(
         Inst::FpuRR {
-            frm: None,
-            alu_op: FpuOPRR::FcvtLS,
+            frm: FRM::Fcsr,
+            width: FpuOPWidth::S,
+            alu_op: FpuOPRR::FcvtLFmt,
             rd: writable_a0(),
             rs: fa0(),
         },
-        "fcvt.l.s a0,fa0",
+        "fcvt.l.s a0,fa0,fcsr",
         0xc0257553,
     ));
     insns.push(TestUnit::new(
         Inst::FpuRR {
-            frm: None,
-            alu_op: FpuOPRR::FcvtLuS,
+            frm: FRM::Fcsr,
+            width: FpuOPWidth::S,
+            alu_op: FpuOPRR::FcvtLuFmt,
             rd: writable_a0(),
             rs: fa0(),
         },
-        "fcvt.lu.s a0,fa0",
+        "fcvt.lu.s a0,fa0,fcsr",
         0xc0357553,
     ));
     insns.push(TestUnit::new(
         Inst::FpuRR {
-            frm: None,
-
-            alu_op: FpuOPRR::FcvtSL,
+            frm: FRM::Fcsr,
+            width: FpuOPWidth::S,
+            alu_op: FpuOPRR::FcvtFmtL,
             rd: writable_fa0(),
             rs: a0(),
         },
-        "fcvt.s.l fa0,a0",
+        "fcvt.s.l fa0,a0,fcsr",
         0xd0257553,
     ));
     insns.push(TestUnit::new(
         Inst::FpuRR {
-            frm: None,
-            alu_op: FpuOPRR::FcvtSLU,
+            frm: FRM::Fcsr,
+            width: FpuOPWidth::S,
+            alu_op: FpuOPRR::FcvtFmtLu,
             rd: writable_fa0(),
             rs: a0(),
         },
-        "fcvt.s.lu fa0,a0",
+        "fcvt.s.lu fa0,a0,fcsr",
         0xd0357553,
     ));
 
-    //
     insns.push(TestUnit::new(
         Inst::FpuRR {
-            frm: None,
-            alu_op: FpuOPRR::FsqrtD,
+            frm: FRM::Fcsr,
+            width: FpuOPWidth::D,
+            alu_op: FpuOPRR::Fsqrt,
             rd: writable_fa0(),
             rs: fa1(),
         },
-        "fsqrt.d fa0,fa1",
+        "fsqrt.d fa0,fa1,fcsr",
         0x5a05f553,
     ));
     insns.push(TestUnit::new(
         Inst::FpuRR {
-            frm: None,
-            alu_op: FpuOPRR::FcvtWD,
+            frm: FRM::Fcsr,
+            width: FpuOPWidth::D,
+            alu_op: FpuOPRR::FcvtWFmt,
             rd: writable_a0(),
             rs: fa1(),
         },
-        "fcvt.w.d a0,fa1",
+        "fcvt.w.d a0,fa1,fcsr",
         0xc205f553,
     ));
 
     insns.push(TestUnit::new(
         Inst::FpuRR {
-            frm: None,
-            alu_op: FpuOPRR::FcvtWuD,
+            frm: FRM::Fcsr,
+            width: FpuOPWidth::D,
+            alu_op: FpuOPRR::FcvtWuFmt,
             rd: writable_a0(),
             rs: fa1(),
         },
-        "fcvt.wu.d a0,fa1",
+        "fcvt.wu.d a0,fa1,fcsr",
         0xc215f553,
     ));
     insns.push(TestUnit::new(
         Inst::FpuRR {
-            frm: None,
-            alu_op: FpuOPRR::FmvXD,
+            frm: FRM::RNE,
+            width: FpuOPWidth::D,
+            alu_op: FpuOPRR::FmvXFmt,
             rd: writable_a0(),
             rs: fa1(),
         },
@@ -1595,8 +1636,9 @@ fn test_riscv64_binemit() {
     ));
     insns.push(TestUnit::new(
         Inst::FpuRR {
-            frm: None,
-            alu_op: FpuOPRR::FclassD,
+            frm: FRM::RTZ,
+            width: FpuOPWidth::D,
+            alu_op: FpuOPRR::Fclass,
             rd: writable_a0(),
             rs: fa1(),
         },
@@ -1606,29 +1648,32 @@ fn test_riscv64_binemit() {
 
     insns.push(TestUnit::new(
         Inst::FpuRR {
-            frm: None,
+            frm: FRM::Fcsr,
+            width: FpuOPWidth::S,
             alu_op: FpuOPRR::FcvtSD,
             rd: writable_fa0(),
             rs: fa0(),
         },
-        "fcvt.s.d fa0,fa0",
+        "fcvt.s.d fa0,fa0,fcsr",
         0x40157553,
     ));
     insns.push(TestUnit::new(
         Inst::FpuRR {
-            frm: None,
-            alu_op: FpuOPRR::FcvtDWU,
+            frm: FRM::RNE,
+            width: FpuOPWidth::D,
+            alu_op: FpuOPRR::FcvtFmtWu,
             rd: writable_fa0(),
             rs: a0(),
         },
-        "fcvt.d.wu fa0,a0",
+        "fcvt.d.wu fa0,a0,rne",
         0xd2150553,
     ));
 
     insns.push(TestUnit::new(
         Inst::FpuRR {
-            frm: None,
-            alu_op: FpuOPRR::FmvDX,
+            frm: FRM::RNE,
+            width: FpuOPWidth::D,
+            alu_op: FpuOPRR::FmvFmtX,
             rd: writable_fa0(),
             rs: a0(),
         },
@@ -1637,50 +1682,55 @@ fn test_riscv64_binemit() {
     ));
     insns.push(TestUnit::new(
         Inst::FpuRR {
-            frm: None,
-            alu_op: FpuOPRR::FcvtLD,
+            frm: FRM::Fcsr,
+            width: FpuOPWidth::D,
+            alu_op: FpuOPRR::FcvtLFmt,
             rd: writable_a0(),
             rs: fa0(),
         },
-        "fcvt.l.d a0,fa0",
+        "fcvt.l.d a0,fa0,fcsr",
         0xc2257553,
     ));
     insns.push(TestUnit::new(
         Inst::FpuRR {
-            frm: None,
-            alu_op: FpuOPRR::FcvtLuD,
+            frm: FRM::Fcsr,
+            width: FpuOPWidth::D,
+            alu_op: FpuOPRR::FcvtLuFmt,
             rd: writable_a0(),
             rs: fa0(),
         },
-        "fcvt.lu.d a0,fa0",
+        "fcvt.lu.d a0,fa0,fcsr",
         0xc2357553,
     ));
     insns.push(TestUnit::new(
         Inst::FpuRR {
-            frm: None,
-            alu_op: FpuOPRR::FcvtDL,
+            frm: FRM::Fcsr,
+            width: FpuOPWidth::D,
+            alu_op: FpuOPRR::FcvtFmtL,
             rd: writable_fa0(),
             rs: a0(),
         },
-        "fcvt.d.l fa0,a0",
+        "fcvt.d.l fa0,a0,fcsr",
         0xd2257553,
     ));
     insns.push(TestUnit::new(
         Inst::FpuRR {
-            frm: None,
-            alu_op: FpuOPRR::FcvtDLu,
+            frm: FRM::Fcsr,
+            width: FpuOPWidth::D,
+            alu_op: FpuOPRR::FcvtFmtLu,
             rd: writable_fa0(),
             rs: a0(),
         },
-        "fcvt.d.lu fa0,a0",
+        "fcvt.d.lu fa0,a0,fcsr",
         0xd2357553,
     ));
     //////////////////////
 
     insns.push(TestUnit::new(
         Inst::FpuRRRR {
-            frm: Some(FRM::RNE),
-            alu_op: FpuOPRRRR::FmaddS,
+            frm: FRM::RNE,
+            width: FpuOPWidth::S,
+            alu_op: FpuOPRRRR::Fmadd,
             rd: writable_fa0(),
             rs1: fa0(),
             rs2: fa1(),
@@ -1691,88 +1741,94 @@ fn test_riscv64_binemit() {
     ));
     insns.push(TestUnit::new(
         Inst::FpuRRRR {
-            frm: None,
-            alu_op: FpuOPRRRR::FmsubS,
+            frm: FRM::Fcsr,
+            width: FpuOPWidth::S,
+            alu_op: FpuOPRRRR::Fmsub,
             rd: writable_fa0(),
             rs1: fa0(),
             rs2: fa1(),
             rs3: fa7(),
         },
-        "fmsub.s fa0,fa0,fa1,fa7",
+        "fmsub.s fa0,fa0,fa1,fa7,fcsr",
         0x88b57547,
     ));
     insns.push(TestUnit::new(
         Inst::FpuRRRR {
-            frm: None,
-            alu_op: FpuOPRRRR::FnmsubS,
+            frm: FRM::Fcsr,
+            width: FpuOPWidth::S,
+            alu_op: FpuOPRRRR::Fnmsub,
             rd: writable_fa0(),
             rs1: fa0(),
             rs2: fa1(),
             rs3: fa7(),
         },
-        "fnmsub.s fa0,fa0,fa1,fa7",
+        "fnmsub.s fa0,fa0,fa1,fa7,fcsr",
         0x88b5754b,
     ));
     insns.push(TestUnit::new(
         Inst::FpuRRRR {
-            frm: None,
-            alu_op: FpuOPRRRR::FnmaddS,
+            frm: FRM::Fcsr,
+            width: FpuOPWidth::S,
+            alu_op: FpuOPRRRR::Fnmadd,
             rd: writable_fa0(),
             rs1: fa0(),
             rs2: fa1(),
             rs3: fa7(),
         },
-        "fnmadd.s fa0,fa0,fa1,fa7",
+        "fnmadd.s fa0,fa0,fa1,fa7,fcsr",
         0x88b5754f,
     ));
 
     insns.push(TestUnit::new(
         Inst::FpuRRRR {
-            frm: None,
-            alu_op: FpuOPRRRR::FmaddD,
+            frm: FRM::Fcsr,
+            width: FpuOPWidth::D,
+            alu_op: FpuOPRRRR::Fmadd,
             rd: writable_fa0(),
             rs1: fa0(),
             rs2: fa1(),
             rs3: fa7(),
         },
-        "fmadd.d fa0,fa0,fa1,fa7",
+        "fmadd.d fa0,fa0,fa1,fa7,fcsr",
         0x8ab57543,
     ));
     insns.push(TestUnit::new(
         Inst::FpuRRRR {
-            frm: None,
-
-            alu_op: FpuOPRRRR::FmsubD,
+            frm: FRM::Fcsr,
+            width: FpuOPWidth::D,
+            alu_op: FpuOPRRRR::Fmsub,
             rd: writable_fa0(),
             rs1: fa0(),
             rs2: fa1(),
             rs3: fa7(),
         },
-        "fmsub.d fa0,fa0,fa1,fa7",
+        "fmsub.d fa0,fa0,fa1,fa7,fcsr",
         0x8ab57547,
     ));
     insns.push(TestUnit::new(
         Inst::FpuRRRR {
-            frm: None,
-            alu_op: FpuOPRRRR::FnmsubD,
+            frm: FRM::Fcsr,
+            width: FpuOPWidth::D,
+            alu_op: FpuOPRRRR::Fnmsub,
             rd: writable_fa0(),
             rs1: fa0(),
             rs2: fa1(),
             rs3: fa7(),
         },
-        "fnmsub.d fa0,fa0,fa1,fa7",
+        "fnmsub.d fa0,fa0,fa1,fa7,fcsr",
         0x8ab5754b,
     ));
     insns.push(TestUnit::new(
         Inst::FpuRRRR {
-            frm: None,
-            alu_op: FpuOPRRRR::FnmaddD,
+            frm: FRM::Fcsr,
+            width: FpuOPWidth::D,
+            alu_op: FpuOPRRRR::Fnmadd,
             rd: writable_fa0(),
             rs1: fa0(),
             rs2: fa1(),
             rs3: fa7(),
         },
-        "fnmadd.d fa0,fa0,fa1,fa7",
+        "fnmadd.d fa0,fa0,fa1,fa7,fcsr",
         0x8ab5754f,
     ));
 
@@ -2038,8 +2094,9 @@ fn test_riscv64_binemit() {
 
     insns.push(TestUnit::new(
         Inst::FpuRRR {
-            alu_op: FpuOPRRR::FsgnjS,
-            frm: None,
+            alu_op: FpuOPRRR::Fsgnj,
+            width: FpuOPWidth::S,
+            frm: FRM::RNE,
             rd: writable_fa0(),
             rs1: fa1(),
             rs2: fa1(),
@@ -2049,8 +2106,9 @@ fn test_riscv64_binemit() {
     ));
     insns.push(TestUnit::new(
         Inst::FpuRRR {
-            alu_op: FpuOPRRR::FsgnjD,
-            frm: None,
+            alu_op: FpuOPRRR::Fsgnj,
+            width: FpuOPWidth::D,
+            frm: FRM::RNE,
             rd: writable_fa0(),
             rs1: fa1(),
             rs2: fa1(),
@@ -2061,8 +2119,9 @@ fn test_riscv64_binemit() {
 
     insns.push(TestUnit::new(
         Inst::FpuRRR {
-            alu_op: FpuOPRRR::FsgnjnS,
-            frm: None,
+            alu_op: FpuOPRRR::Fsgnjn,
+            width: FpuOPWidth::S,
+            frm: FRM::RTZ,
             rd: writable_fa0(),
             rs1: fa1(),
             rs2: fa1(),
@@ -2072,8 +2131,9 @@ fn test_riscv64_binemit() {
     ));
     insns.push(TestUnit::new(
         Inst::FpuRRR {
-            alu_op: FpuOPRRR::FsgnjnD,
-            frm: None,
+            alu_op: FpuOPRRR::Fsgnjn,
+            width: FpuOPWidth::D,
+            frm: FRM::RTZ,
             rd: writable_fa0(),
             rs1: fa1(),
             rs2: fa1(),
@@ -2082,19 +2142,37 @@ fn test_riscv64_binemit() {
         0x22b59553,
     ));
 
+    insns.push(TestUnit::new(
+        Inst::Fli {
+            ty: F32,
+            rd: writable_fa0(),
+            imm: FliConstant::new(0),
+        },
+        "fli.s fa0,-1.0",
+        0xf0100553,
+    ));
+
+    insns.push(TestUnit::new(
+        Inst::Fli {
+            ty: F64,
+            rd: writable_fa0(),
+            imm: FliConstant::new(13),
+        },
+        "fli.d fa0,0.625",
+        0xf2168553,
+    ));
+
     let (flags, isa_flags) = make_test_flags();
     let emit_info = EmitInfo::new(flags, isa_flags);
 
     for unit in insns.iter() {
         println!("Riscv64: {:?}, {}", unit.inst, unit.assembly);
         // Check the printed text is as expected.
-        let actual_printing = unit
-            .inst
-            .print_with_state(&mut EmitState::default(), &mut AllocationConsumer::new(&[]));
+        let actual_printing = unit.inst.print_with_state(&mut EmitState::default());
         assert_eq!(unit.assembly, actual_printing);
         let mut buffer = MachBuffer::new();
         unit.inst
-            .emit(&[], &mut buffer, &emit_info, &mut Default::default());
+            .emit(&mut buffer, &emit_info, &mut Default::default());
         let buffer = buffer.finish(&Default::default(), &mut Default::default());
         let actual_encoding = buffer.stringify_code_bytes();
 
@@ -2110,203 +2188,89 @@ fn make_test_flags() -> (settings::Flags, super::super::riscv_settings::Flags) {
     (flags, isa_flags)
 }
 
-#[derive(Debug)]
-pub(crate) struct DebugRTypeInst {
-    op_code: u32,
-    rd: u32,
-    funct3: u32,
-    rs1: u32,
-    rs2: u32,
-    funct7: u32,
-}
-
-impl DebugRTypeInst {
-    pub(crate) fn from_bs(x: &[u8]) -> Option<Self> {
-        if x.len() != 4 {
-            return None;
-        }
-        let a = [x[0], x[1], x[2], x[3]];
-        Some(Self::from_u32(u32::from_le_bytes(a)))
-    }
-
-    pub(crate) fn from_u32(x: u32) -> Self {
-        let op_code = x & 0b111_1111;
-        let x = x >> 7;
-        let rd = x & 0b1_1111;
-        let x = x >> 5;
-        let funct3 = x & 0b111;
-        let x = x >> 3;
-        let rs1 = x & 0b1_1111;
-        let x = x >> 5;
-        let rs2 = x & 0b1_1111;
-        let x = x >> 5;
-        let funct7 = x & 0b111_1111;
-        Self {
-            op_code,
-            rd,
-            funct3,
-            rs1,
-            rs2,
-            funct7,
-        }
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct DebugITypeInst {
-    op_code: u32,
-    rd: u32,
-    funct3: u32,
-    rs: u32,
-    imm12: u32,
-    shamt5: u32,
-    shamt6: u32,
-    funct7: u32,
-    funct6: u32,
-}
-
-impl DebugITypeInst {
-    pub(crate) fn from_bs(x: &[u8]) -> Self {
-        let a = [x[0], x[1], x[2], x[3]];
-        Self::from_u32(u32::from_le_bytes(a))
-    }
-    pub(crate) fn from_u32(x: u32) -> Self {
-        let op_code = x & 0b111_1111;
-        let x = x >> 7;
-        let rd = x & 0b1_1111;
-        let x = x >> 5;
-        let funct3 = x & 0b111;
-        let x = x >> 3;
-        let rs = x & 0b1_1111;
-        let x = x >> 5;
-        let imm12 = x & 0b1111_1111_1111;
-        let shamt5 = imm12 & 0b1_1111;
-        let shamt6 = imm12 & 0b11_1111;
-        let funct7 = imm12 >> 5;
-        let funct6 = funct7 >> 1;
-        Self {
-            op_code,
-            rd,
-            funct3,
-            rs,
-            imm12,
-            shamt5,
-            shamt6,
-            funct7,
-            funct6,
-        }
-    }
-    fn print_b(self) {
-        println!("opcode:{:b}", self.op_code);
-        println!("rd:{}", self.rd);
-        println!("funct3:{:b}", self.funct3);
-        println!("rs:{}", self.rs);
-        println!("shamt5:{:b}", self.shamt5);
-        println!("shamt6:{:b}", self.shamt6);
-        println!("funct6:{:b}", self.funct6);
-        println!("funct7:{:b}", self.funct7);
-    }
-}
-
-#[test]
-fn xxx() {
-    let x = 1240847763;
-    let x = DebugITypeInst::from_u32(x);
-    x.print_b();
-}
-
 #[test]
 fn riscv64_worst_case_instruction_size() {
     let (flags, isa_flags) = make_test_flags();
     let emit_info = EmitInfo::new(flags, isa_flags);
 
-    //there are all candidates potential generate a lot of bytes.
+    // These are all candidate instructions with potential to generate a lot of bytes.
     let mut candidates: Vec<MInst> = vec![];
 
-    candidates.push(Inst::FcvtToInt {
-        rd: writable_a0(),
-        rs: fa0(),
-        is_signed: true,
-        in_type: F64,
-        out_type: I8,
-        is_sat: false,
-        tmp: writable_a1(),
-    });
-    candidates.push(Inst::FcvtToInt {
-        rd: writable_a0(),
-        rs: fa0(),
-        is_signed: true,
-        in_type: F64,
-        out_type: I16,
-        is_sat: false,
-        tmp: writable_a1(),
-    });
-    candidates.push(Inst::FcvtToInt {
-        rd: writable_a0(),
-        rs: fa0(),
-        is_signed: true,
-        in_type: F32,
-        out_type: I8,
-        is_sat: false,
-        tmp: writable_a1(),
-    });
-    candidates.push(Inst::FcvtToInt {
-        rd: writable_a0(),
-        rs: fa0(),
-        is_signed: true,
-        in_type: F32,
-        out_type: I16,
-        is_sat: false,
-        tmp: writable_a1(),
+    candidates.push(Inst::Popcnt {
+        sum: writable_a0(),
+        tmp: writable_a0(),
+        step: writable_a0(),
+        rs: a0(),
+        ty: I64,
     });
-    candidates.push(Inst::FcvtToInt {
-        rd: writable_a0(),
-        rs: fa0(),
-        is_signed: true,
-        in_type: F64,
-        out_type: I8,
-        is_sat: false,
-        tmp: writable_a1(),
+
+    candidates.push(Inst::Cltz {
+        sum: writable_a0(),
+        tmp: writable_a0(),
+        step: writable_a0(),
+        rs: a0(),
+        leading: true,
+        ty: I64,
     });
-    candidates.push(Inst::FcvtToInt {
+
+    candidates.push(Inst::Brev8 {
         rd: writable_a0(),
-        rs: fa0(),
-        is_signed: true,
-        in_type: F64,
-        out_type: I16,
-        is_sat: false,
-        tmp: writable_a1(),
+        tmp: writable_a0(),
+        step: writable_a0(),
+        tmp2: writable_a0(),
+        rs: a0(),
+        ty: I64,
     });
 
-    candidates.push(Inst::FloatRound {
-        op: FloatRoundOP::Trunc,
-        int_tmp: writable_a0(),
-        f_tmp: writable_a0(),
-        rd: writable_fa0(),
-        rs: fa0(),
-        ty: F64,
+    candidates.push(Inst::AtomicCas {
+        offset: a0(),
+        t0: writable_a0(),
+        dst: writable_a0(),
+        e: a0(),
+        addr: a0(),
+        v: a0(),
+        ty: I64,
     });
 
-    candidates.push(Inst::FloatSelect {
-        op: FloatSelectOP::Max,
-        rd: writable_fa0(),
-        tmp: writable_a0(),
-        rs1: fa0(),
-        rs2: fa0(),
-        ty: F64,
+    candidates.push(Inst::AtomicCas {
+        offset: a0(),
+        t0: writable_a0(),
+        dst: writable_a0(),
+        e: a0(),
+        addr: a0(),
+        v: a0(),
+        ty: I16,
     });
 
+    candidates.extend(
+        crate::ir::AtomicRmwOp::all()
+            .iter()
+            .map(|op| Inst::AtomicRmwLoop {
+                op: *op,
+                offset: a0(),
+                dst: writable_a1(),
+                ty: I16,
+                p: a1(),
+                x: a2(),
+                t0: writable_a0(),
+            }),
+    );
+
+    // Return Call Indirect and BrTable are the largest instructions possible. However they
+    // emit their own island, so we don't account them here.
+
     let mut max: (u32, MInst) = (0, Inst::Nop0);
     for i in candidates {
         let mut buffer = MachBuffer::new();
-        i.emit(&[], &mut buffer, &emit_info, &mut Default::default());
+        let mut emit_state = Default::default();
+        i.emit(&mut buffer, &emit_info, &mut emit_state);
         let buffer = buffer.finish(&Default::default(), &mut Default::default());
         let length = buffer.data().len() as u32;
         if length > max.0 {
             let length = buffer.data().len() as u32;
             max = (length, i.clone());
         }
-        println!("insn:{:?}  length: {}", i, length);
+        println!("insn:{i:?}  length: {length}");
     }
     println!("calculate max size is {} , inst is {:?}", max.0, max.1);
     assert!(max.0 <= Inst::worst_case_size());
diff --git a/cranelift/codegen/src/isa/riscv64/inst/encode.rs b/cranelift/codegen/src/isa/riscv64/inst/encode.rs
index fae2f929c795..f2f159f87605 100644
--- a/cranelift/codegen/src/isa/riscv64/inst/encode.rs
+++ b/cranelift/codegen/src/isa/riscv64/inst/encode.rs
@@ -1,20 +1,17 @@
 //! Contains the RISC-V instruction encoding logic.
 //!
 //! These formats are specified in the RISC-V specification in section 2.2.
-//! See: https://riscv.org/wp-content/uploads/2017/05/riscv-spec-v2.2.pdf
+//! See: <https://riscv.org/wp-content/uploads/2017/05/riscv-spec-v2.2.pdf>
 //!
 //! Some instructions especially in extensions have slight variations from
 //! the base RISC-V specification.
 
 use super::*;
-use crate::isa::riscv64::inst::reg_to_gpr_num;
 use crate::isa::riscv64::lower::isle::generated_code::{
-    COpcodeSpace, CaOp, CbOp, CiOp, CiwOp, CjOp, ClOp, CrOp, CsOp, CssOp, CsznOp, VecAluOpRImm5,
-    VecAluOpRR, VecAluOpRRImm5, VecAluOpRRR, VecAluOpRRRImm5, VecAluOpRRRR, VecElementWidth,
-    VecOpCategory, VecOpMasking, ZcbMemOp,
+    COpcodeSpace, CaOp, CbOp, CiOp, CiwOp, ClOp, CrOp, CsOp, CssOp, CsznOp, FpuOPWidth,
+    VecAluOpRImm5, VecAluOpRR, VecAluOpRRRImm5, VecAluOpRRRR, VecOpCategory, ZcbMemOp,
 };
 use crate::machinst::isle::WritableReg;
-use crate::Reg;
 
 fn unsigned_field_width(value: u32, width: u8) -> u32 {
     debug_assert_eq!(value & (!0 << width), 0);
@@ -418,7 +415,7 @@ pub fn encode_ci_sp_load(op: CiOp, rd: WritableReg, imm: Uimm6) -> u16 {
     // LDSP:  [5|4:3|8:6]
     // FLDSP: [5|4:3|8:6]
     //
-    // We don't recieve the entire offset in `imm`, just a multiple of the load-size.
+    // We don't receive the entire offset in `imm`, just a multiple of the load-size.
 
     // Number of bits in the lowest position of imm. 3 for lwsp, 2 for {f,}ldsp.
     let low_bits = match op {
@@ -468,7 +465,7 @@ pub fn encode_ciw_type(op: CiwOp, rd: WritableReg, imm: u8) -> u16 {
     let mut imm_field = 0;
     imm_field |= ((imm >> 1) & 1) << 0;
     imm_field |= ((imm >> 0) & 1) << 1;
-    imm_field |= ((imm >> 4) & 7) << 2;
+    imm_field |= ((imm >> 4) & 15) << 2;
     imm_field |= ((imm >> 2) & 3) << 6;
 
     let mut bits = 0;
@@ -512,7 +509,7 @@ pub fn encode_css_type(op: CssOp, src: Reg, imm: Uimm6) -> u16 {
     // c.sdsp:  [5:3|8:6]
     // c.fsdsp: [5:3|8:6]
     //
-    // We don't recieve the entire offset in `imm`, just a multiple of the load-size.
+    // We don't receive the entire offset in `imm`, just a multiple of the load-size.
 
     // Number of bits in the lowest position of imm. 4 for c.swsp, 3 for c.{f,}sdsp.
     let low_bits = match op {
@@ -655,3 +652,70 @@ pub fn encode_zcbmem_load(op: ZcbMemOp, rd: WritableReg, base: Reg, imm: Uimm2)
 pub fn encode_zcbmem_store(op: ZcbMemOp, src: Reg, base: Reg, imm: Uimm2) -> u16 {
     encode_zcbmem_bits(op, src, base, imm)
 }
+
+pub fn encode_fli(ty: Type, imm: FliConstant, rd: WritableReg) -> u32 {
+    // FLI.{S,D} is encoded as a FMV.{W,D} instruction with rs2 set to the
+    // immediate value to be loaded.
+    let op = FpuOPRR::FmvFmtX;
+    let width = FpuOPWidth::try_from(ty).unwrap();
+    let frm = 0; // FRM is hard coded to 0 in both instructions
+    let rs2 = 1; // rs2 set to 1 is what differentiates FLI from FMV
+
+    let mut bits = 0;
+    bits |= unsigned_field_width(op.opcode(), 7);
+    bits |= reg_to_gpr_num(rd.to_reg()) << 7;
+    bits |= unsigned_field_width(frm, 3) << 12;
+    bits |= unsigned_field_width(imm.bits() as u32, 5) << 15;
+    bits |= unsigned_field_width(rs2, 6) << 20;
+    bits |= unsigned_field_width(op.funct7(width), 7) << 25;
+    bits
+}
+
+pub fn encode_fp_rr(op: FpuOPRR, width: FpuOPWidth, frm: FRM, rd: WritableReg, rs: Reg) -> u32 {
+    encode_r_type_bits(
+        op.opcode(),
+        reg_to_gpr_num(rd.to_reg()),
+        frm.as_u32(),
+        reg_to_gpr_num(rs),
+        op.rs2(),
+        op.funct7(width),
+    )
+}
+
+pub fn encode_fp_rrr(
+    op: FpuOPRRR,
+    width: FpuOPWidth,
+    frm: FRM,
+    rd: WritableReg,
+    rs1: Reg,
+    rs2: Reg,
+) -> u32 {
+    encode_r_type_bits(
+        op.opcode(),
+        reg_to_gpr_num(rd.to_reg()),
+        frm.as_u32(),
+        reg_to_gpr_num(rs1),
+        reg_to_gpr_num(rs2),
+        op.funct7(width),
+    )
+}
+
+pub fn encode_fp_rrrr(
+    op: FpuOPRRRR,
+    width: FpuOPWidth,
+    frm: FRM,
+    rd: WritableReg,
+    rs1: Reg,
+    rs2: Reg,
+    rs3: Reg,
+) -> u32 {
+    let funct7 = (reg_to_gpr_num(rs3) << 2) | width.as_u32();
+    encode_r_type_bits(
+        op.opcode(),
+        reg_to_gpr_num(rd.to_reg()),
+        frm.as_u32(),
+        reg_to_gpr_num(rs1),
+        reg_to_gpr_num(rs2),
+        funct7,
+    )
+}
diff --git a/cranelift/codegen/src/isa/riscv64/inst/imms.rs b/cranelift/codegen/src/isa/riscv64/inst/imms.rs
index f1126fd914cb..28f279154eaa 100644
--- a/cranelift/codegen/src/isa/riscv64/inst/imms.rs
+++ b/cranelift/codegen/src/isa/riscv64/inst/imms.rs
@@ -62,7 +62,7 @@ impl Display for Imm12 {
     }
 }
 
-// singed
+// signed
 #[derive(Clone, Copy, Default)]
 pub struct Imm20 {
     /// 32-bit container where the low 20 bits are the data payload.
@@ -199,10 +199,6 @@ impl Imm6 {
         value.try_into().ok().and_then(Imm6::maybe_from_i16)
     }
 
-    pub fn maybe_from_i64(value: i64) -> Option<Self> {
-        value.try_into().ok().and_then(Imm6::maybe_from_i16)
-    }
-
     pub fn maybe_from_imm12(value: Imm12) -> Option<Self> {
         Imm6::maybe_from_i16(value.as_i16())
     }
diff --git a/cranelift/codegen/src/isa/riscv64/inst/mod.rs b/cranelift/codegen/src/isa/riscv64/inst/mod.rs
index 4c10191eccfc..292892b9fe81 100644
--- a/cranelift/codegen/src/isa/riscv64/inst/mod.rs
+++ b/cranelift/codegen/src/isa/riscv64/inst/mod.rs
@@ -1,15 +1,11 @@
 //! This module defines riscv64-specific machine instruction types.
 
-// Some variants are not constructed, but we still want them as options in the future.
-#![allow(dead_code)]
-#![allow(non_camel_case_types)]
-
 use super::lower::isle::generated_code::{VecAMode, VecElementWidth, VecOpMasking};
 use crate::binemit::{Addend, CodeOffset, Reloc};
 pub use crate::ir::condcodes::IntCC;
-use crate::ir::types::{self, F32, F64, I128, I16, I32, I64, I8, I8X16, R32, R64};
+use crate::ir::types::{self, F128, F16, F32, F64, I128, I16, I32, I64, I8, I8X16};
 
-pub use crate::ir::{ExternalName, MemFlags, Opcode, SourceLoc, Type, ValueLabel};
+pub use crate::ir::{ExternalName, MemFlags, Type};
 use crate::isa::{CallConv, FunctionAlignment};
 use crate::machinst::*;
 use crate::{settings, CodegenError, CodegenResult};
@@ -17,7 +13,7 @@ use crate::{settings, CodegenError, CodegenResult};
 pub use crate::ir::condcodes::FloatCC;
 
 use alloc::vec::Vec;
-use regalloc2::{PRegSet, RegClass, VReg};
+use regalloc2::{PRegSet, RegClass};
 use smallvec::{smallvec, SmallVec};
 use std::boxed::Box;
 use std::fmt::Write;
@@ -44,25 +40,17 @@ mod emit_tests;
 
 use std::fmt::{Display, Formatter};
 
-pub(crate) type OptionReg = Option<Reg>;
-pub(crate) type OptionImm12 = Option<Imm12>;
-pub(crate) type OptionUimm5 = Option<UImm5>;
-pub(crate) type OptionFloatRoundingMode = Option<FRM>;
 pub(crate) type VecU8 = Vec<u8>;
-pub(crate) type VecWritableReg = Vec<Writable<Reg>>;
+
 //=============================================================================
 // Instructions (top level): definition
 
 pub use crate::isa::riscv64::lower::isle::generated_code::{
-    AluOPRRI, AluOPRRR, AtomicOP, CsrImmOP, CsrRegOP, FClassResult, FFlagsException, FloatRoundOP,
-    FloatSelectOP, FpuOPRR, FpuOPRRR, FpuOPRRRR, LoadOP, MInst as Inst, StoreOP, CSR, FRM,
+    AluOPRRI, AluOPRRR, AtomicOP, CsrImmOP, CsrRegOP, FClassResult, FFlagsException, FpuOPRR,
+    FpuOPRRR, FpuOPRRRR, LoadOP, MInst as Inst, StoreOP, CSR, FRM,
 };
 use crate::isa::riscv64::lower::isle::generated_code::{CjOp, MInst, VecAluOpRRImm5, VecAluOpRRR};
 
-type BoxCallInfo = Box<CallInfo>;
-type BoxCallIndInfo = Box<CallIndInfo>;
-type BoxReturnCallInfo = Box<ReturnCallInfo>;
-
 /// Additional information for (direct) Call instructions, left out of line to lower the size of
 /// the Inst enum.
 #[derive(Clone, Debug)]
@@ -70,7 +58,6 @@ pub struct CallInfo {
     pub dest: ExternalName,
     pub uses: CallArgList,
     pub defs: CallRetList,
-    pub opcode: Opcode,
     pub caller_callconv: CallConv,
     pub callee_callconv: CallConv,
     pub clobbers: PRegSet,
@@ -84,7 +71,6 @@ pub struct CallIndInfo {
     pub rn: Reg,
     pub uses: CallArgList,
     pub defs: CallRetList,
-    pub opcode: Opcode,
     pub caller_callconv: CallConv,
     pub callee_callconv: CallConv,
     pub clobbers: PRegSet,
@@ -96,8 +82,6 @@ pub struct CallIndInfo {
 #[derive(Clone, Debug)]
 pub struct ReturnCallInfo {
     pub uses: CallArgList,
-    pub opcode: Opcode,
-    pub old_stack_arg_size: u32,
     pub new_stack_arg_size: u32,
 }
 
@@ -249,42 +233,6 @@ impl Inst {
             .expect("code range is too big.")
     }
 
-    /// Create instructions that load a 32-bit floating-point constant.
-    pub fn load_fp_constant32<F: FnMut(Type) -> Writable<Reg>>(
-        rd: Writable<Reg>,
-        const_data: u32,
-        mut alloc_tmp: F,
-    ) -> SmallVec<[Inst; 4]> {
-        let mut insts = SmallVec::new();
-        let tmp = alloc_tmp(I64);
-        insts.extend(Self::load_constant_u32(tmp, const_data as u64));
-        insts.push(Inst::FpuRR {
-            frm: None,
-            alu_op: FpuOPRR::move_x_to_f_op(F32),
-            rd,
-            rs: tmp.to_reg(),
-        });
-        insts
-    }
-
-    /// Create instructions that load a 64-bit floating-point constant.
-    pub fn load_fp_constant64<F: FnMut(Type) -> Writable<Reg>>(
-        rd: Writable<Reg>,
-        const_data: u64,
-        mut alloc_tmp: F,
-    ) -> SmallVec<[Inst; 4]> {
-        let mut insts = SmallInstVec::new();
-        let tmp = alloc_tmp(I64);
-        insts.extend(Self::load_constant_u64(tmp, const_data));
-        insts.push(Inst::FpuRR {
-            frm: None,
-            alu_op: FpuOPRR::move_x_to_f_op(F64),
-            rd,
-            rs: tmp.to_reg(),
-        });
-        insts
-    }
-
     /// Generic constructor for a load (zero-extending where appropriate).
     pub fn gen_load(into_reg: Writable<Reg>, mem: AMode, ty: Type, flags: MemFlags) -> Inst {
         if ty.is_vector() {
@@ -330,202 +278,197 @@ impl Inst {
 
 //=============================================================================
 
-fn vec_mask_operands<F: Fn(VReg) -> VReg>(
-    mask: &VecOpMasking,
-    collector: &mut OperandCollector<'_, F>,
-) {
+fn vec_mask_operands(mask: &mut VecOpMasking, collector: &mut impl OperandVisitor) {
     match mask {
         VecOpMasking::Enabled { reg } => {
-            collector.reg_fixed_use(*reg, pv_reg(0).into());
+            collector.reg_fixed_use(reg, pv_reg(0).into());
         }
         VecOpMasking::Disabled => {}
     }
 }
-fn vec_mask_late_operands<F: Fn(VReg) -> VReg>(
-    mask: &VecOpMasking,
-    collector: &mut OperandCollector<'_, F>,
-) {
+fn vec_mask_late_operands(mask: &mut VecOpMasking, collector: &mut impl OperandVisitor) {
     match mask {
         VecOpMasking::Enabled { reg } => {
-            collector.reg_fixed_late_use(*reg, pv_reg(0).into());
+            collector.reg_fixed_late_use(reg, pv_reg(0).into());
         }
         VecOpMasking::Disabled => {}
     }
 }
 
-fn riscv64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut OperandCollector<'_, F>) {
+fn riscv64_get_operands(inst: &mut Inst, collector: &mut impl OperandVisitor) {
     match inst {
-        &Inst::Nop0 => {}
-        &Inst::Nop4 => {}
-        &Inst::BrTable {
+        Inst::Nop0 | Inst::Nop4 => {}
+        Inst::BrTable {
             index, tmp1, tmp2, ..
         } => {
             collector.reg_use(index);
             collector.reg_early_def(tmp1);
             collector.reg_early_def(tmp2);
         }
-        &Inst::Auipc { rd, .. } => collector.reg_def(rd),
-        &Inst::Lui { rd, .. } => collector.reg_def(rd),
-        &Inst::LoadInlineConst { rd, .. } => collector.reg_def(rd),
-        &Inst::AluRRR { rd, rs1, rs2, .. } => {
+        Inst::Auipc { rd, .. } => collector.reg_def(rd),
+        Inst::Lui { rd, .. } => collector.reg_def(rd),
+        Inst::Fli { rd, .. } => collector.reg_def(rd),
+        Inst::LoadInlineConst { rd, .. } => collector.reg_def(rd),
+        Inst::AluRRR { rd, rs1, rs2, .. } => {
             collector.reg_use(rs1);
             collector.reg_use(rs2);
             collector.reg_def(rd);
         }
-        &Inst::FpuRRR { rd, rs1, rs2, .. } => {
+        Inst::FpuRRR { rd, rs1, rs2, .. } => {
             collector.reg_use(rs1);
             collector.reg_use(rs2);
             collector.reg_def(rd);
         }
-        &Inst::AluRRImm12 { rd, rs, .. } => {
+        Inst::AluRRImm12 { rd, rs, .. } => {
             collector.reg_use(rs);
             collector.reg_def(rd);
         }
-        &Inst::CsrReg { rd, rs, .. } => {
+        Inst::CsrReg { rd, rs, .. } => {
             collector.reg_use(rs);
             collector.reg_def(rd);
         }
-        &Inst::CsrImm { rd, .. } => {
+        Inst::CsrImm { rd, .. } => {
             collector.reg_def(rd);
         }
-        &Inst::Load { rd, from, .. } => {
-            if let Some(r) = from.get_allocatable_register() {
-                collector.reg_use(r);
-            }
+        Inst::Load { rd, from, .. } => {
+            from.get_operands(collector);
             collector.reg_def(rd);
         }
-        &Inst::Store { to, src, .. } => {
-            if let Some(r) = to.get_allocatable_register() {
-                collector.reg_use(r);
-            }
+        Inst::Store { to, src, .. } => {
+            to.get_operands(collector);
             collector.reg_use(src);
         }
 
-        &Inst::Args { ref args } => {
-            for arg in args {
-                collector.reg_fixed_def(arg.vreg, arg.preg);
+        Inst::Args { args } => {
+            for ArgPair { vreg, preg } in args {
+                collector.reg_fixed_def(vreg, *preg);
             }
         }
-        &Inst::Rets { ref rets } => {
-            for ret in rets {
-                collector.reg_fixed_use(ret.vreg, ret.preg);
+        Inst::Rets { rets } => {
+            for RetPair { vreg, preg } in rets {
+                collector.reg_fixed_use(vreg, *preg);
             }
         }
-        &Inst::Ret { .. } => {}
+        Inst::Ret { .. } => {}
 
-        &Inst::Extend { rd, rn, .. } => {
+        Inst::Extend { rd, rn, .. } => {
             collector.reg_use(rn);
             collector.reg_def(rd);
         }
-        &Inst::AdjustSp { .. } => {}
-        &Inst::Call { ref info } => {
-            for u in &info.uses {
-                collector.reg_fixed_use(u.vreg, u.preg);
+        Inst::Call { info } => {
+            let CallInfo { uses, defs, .. } = &mut **info;
+            for CallArgPair { vreg, preg } in uses {
+                collector.reg_fixed_use(vreg, *preg);
             }
-            for d in &info.defs {
-                collector.reg_fixed_def(d.vreg, d.preg);
+            for CallRetPair { vreg, preg } in defs {
+                collector.reg_fixed_def(vreg, *preg);
             }
             collector.reg_clobbers(info.clobbers);
         }
-        &Inst::CallInd { ref info } => {
-            if info.callee_callconv == CallConv::Tail {
-                // TODO(https://github.com/bytecodealliance/regalloc2/issues/145):
-                // This shouldn't be a fixed register constraint.
-                collector.reg_fixed_use(info.rn, x_reg(5));
-            } else {
-                collector.reg_use(info.rn);
-            }
-
-            for u in &info.uses {
-                collector.reg_fixed_use(u.vreg, u.preg);
+        Inst::CallInd { info } => {
+            let CallIndInfo { rn, uses, defs, .. } = &mut **info;
+            collector.reg_use(rn);
+            for CallArgPair { vreg, preg } in uses {
+                collector.reg_fixed_use(vreg, *preg);
             }
-            for d in &info.defs {
-                collector.reg_fixed_def(d.vreg, d.preg);
+            for CallRetPair { vreg, preg } in defs {
+                collector.reg_fixed_def(vreg, *preg);
             }
             collector.reg_clobbers(info.clobbers);
         }
-        &Inst::ReturnCall {
-            callee: _,
-            ref info,
-        } => {
-            for u in &info.uses {
-                collector.reg_fixed_use(u.vreg, u.preg);
+        Inst::ReturnCall { info, .. } => {
+            for CallArgPair { vreg, preg } in &mut info.uses {
+                collector.reg_fixed_use(vreg, *preg);
             }
         }
-        &Inst::ReturnCallInd { ref info, callee } => {
-            collector.reg_use(callee);
-            for u in &info.uses {
-                collector.reg_fixed_use(u.vreg, u.preg);
+        Inst::ReturnCallInd { info, callee } => {
+            // TODO(https://github.com/bytecodealliance/regalloc2/issues/145):
+            // This shouldn't be a fixed register constraint.
+            collector.reg_fixed_use(callee, x_reg(5));
+
+            for CallArgPair { vreg, preg } in &mut info.uses {
+                collector.reg_fixed_use(vreg, *preg);
             }
         }
-        &Inst::Jal { .. } => {
+        Inst::Jal { .. } => {
             // JAL technically has a rd register, but we currently always
             // hardcode it to x0.
         }
-        &Inst::CondBr { kind, .. } => {
-            collector.reg_use(kind.rs1);
-            collector.reg_use(kind.rs2);
+        Inst::CondBr {
+            kind: IntegerCompare { rs1, rs2, .. },
+            ..
+        } => {
+            collector.reg_use(rs1);
+            collector.reg_use(rs2);
         }
-        &Inst::LoadExtName { rd, .. } => {
+        Inst::LoadExtName { rd, .. } => {
             collector.reg_def(rd);
         }
-        &Inst::ElfTlsGetAddr { rd, .. } => {
+        Inst::ElfTlsGetAddr { rd, .. } => {
             // x10 is a0 which is both the first argument and the first return value.
             collector.reg_fixed_def(rd, a0());
             let mut clobbers = Riscv64MachineDeps::get_regs_clobbered_by_call(CallConv::SystemV);
             clobbers.remove(px_reg(10));
             collector.reg_clobbers(clobbers);
         }
-        &Inst::LoadAddr { rd, mem } => {
-            if let Some(r) = mem.get_allocatable_register() {
-                collector.reg_use(r);
-            }
+        Inst::LoadAddr { rd, mem } => {
+            mem.get_operands(collector);
             collector.reg_early_def(rd);
         }
 
-        &Inst::VirtualSPOffsetAdj { .. } => {}
-        &Inst::Mov { rd, rm, .. } => {
+        Inst::Mov { rd, rm, .. } => {
             collector.reg_use(rm);
             collector.reg_def(rd);
         }
-        &Inst::MovFromPReg { rd, rm } => {
-            debug_assert!([px_reg(2), px_reg(8)].contains(&rm));
+        Inst::MovFromPReg { rd, rm } => {
+            debug_assert!([px_reg(2), px_reg(8)].contains(rm));
             collector.reg_def(rd);
         }
-        &Inst::Fence { .. } => {}
-        &Inst::EBreak => {}
-        &Inst::Udf { .. } => {}
-        &Inst::FpuRR { rd, rs, .. } => {
+        Inst::Fence { .. } => {}
+        Inst::EBreak => {}
+        Inst::Udf { .. } => {}
+        Inst::FpuRR { rd, rs, .. } => {
             collector.reg_use(rs);
             collector.reg_def(rd);
         }
-        &Inst::FpuRRRR {
+        Inst::FpuRRRR {
             rd, rs1, rs2, rs3, ..
         } => {
-            collector.reg_uses(&[rs1, rs2, rs3]);
+            collector.reg_use(rs1);
+            collector.reg_use(rs2);
+            collector.reg_use(rs3);
             collector.reg_def(rd);
         }
 
-        &Inst::Jalr { rd, base, .. } => {
+        Inst::Jalr { rd, base, .. } => {
             collector.reg_use(base);
             collector.reg_def(rd);
         }
-        &Inst::Atomic { rd, addr, src, .. } => {
+        Inst::Atomic { rd, addr, src, .. } => {
             collector.reg_use(addr);
             collector.reg_use(src);
             collector.reg_def(rd);
         }
-        &Inst::Select {
-            ref dst,
-            condition,
+        Inst::Select {
+            dst,
+            condition: IntegerCompare { rs1, rs2, .. },
             x,
             y,
             ..
         } => {
-            collector.reg_use(condition.rs1);
-            collector.reg_use(condition.rs2);
-            collector.reg_uses(x.regs());
-            collector.reg_uses(y.regs());
+            // Mark the condition registers as late use so that they don't overlap with the destination
+            // register. We may potentially write to the destination register before evaluating the
+            // condition.
+            collector.reg_late_use(rs1);
+            collector.reg_late_use(rs2);
+
+            for reg in x.regs_mut() {
+                collector.reg_use(reg);
+            }
+            for reg in y.regs_mut() {
+                collector.reg_use(reg);
+            }
+
             // If there's more than one destination register then use
             // `reg_early_def` to prevent destination registers from overlapping
             // with any operands. This ensures that the lowering doesn't have to
@@ -535,15 +478,18 @@ fn riscv64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut Operan
             // When there's only one destination register though don't use an
             // early def because once the register is written no other inputs
             // are read so it's ok for the destination to overlap the sources.
-            if dst.regs().len() > 1 {
-                for d in dst.regs() {
-                    collector.reg_early_def(d.clone());
+            // The condition registers are already marked as late use so they
+            // won't overlap with the destination.
+            match dst.regs_mut() {
+                [reg] => collector.reg_def(reg),
+                regs => {
+                    for d in regs {
+                        collector.reg_early_def(d);
+                    }
                 }
-            } else {
-                collector.reg_defs(dst.regs());
             }
         }
-        &Inst::AtomicCas {
+        Inst::AtomicCas {
             offset,
             t0,
             dst,
@@ -552,32 +498,24 @@ fn riscv64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut Operan
             v,
             ..
         } => {
-            collector.reg_uses(&[offset, e, addr, v]);
+            collector.reg_use(offset);
+            collector.reg_use(e);
+            collector.reg_use(addr);
+            collector.reg_use(v);
             collector.reg_early_def(t0);
             collector.reg_early_def(dst);
         }
 
-        &Inst::Icmp { rd, a, b, .. } => {
-            collector.reg_uses(a.regs());
-            collector.reg_uses(b.regs());
-            collector.reg_def(rd);
-        }
-
-        &Inst::FcvtToInt { rd, rs, tmp, .. } => {
-            collector.reg_use(rs);
-            collector.reg_early_def(tmp);
-            collector.reg_early_def(rd);
-        }
-        &Inst::RawData { .. } => {}
-        &Inst::AtomicStore { src, p, .. } => {
+        Inst::RawData { .. } => {}
+        Inst::AtomicStore { src, p, .. } => {
             collector.reg_use(src);
             collector.reg_use(p);
         }
-        &Inst::AtomicLoad { rd, p, .. } => {
+        Inst::AtomicLoad { rd, p, .. } => {
             collector.reg_use(p);
             collector.reg_def(rd);
         }
-        &Inst::AtomicRmwLoop {
+        Inst::AtomicRmwLoop {
             offset,
             dst,
             p,
@@ -585,38 +523,21 @@ fn riscv64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut Operan
             t0,
             ..
         } => {
-            collector.reg_uses(&[offset, p, x]);
+            collector.reg_use(offset);
+            collector.reg_use(p);
+            collector.reg_use(x);
             collector.reg_early_def(t0);
             collector.reg_early_def(dst);
         }
-        &Inst::TrapIf { rs1, rs2, .. } => {
+        Inst::TrapIf { rs1, rs2, .. } => {
             collector.reg_use(rs1);
             collector.reg_use(rs2);
         }
-        &Inst::Unwind { .. } => {}
-        &Inst::DummyUse { reg } => {
+        Inst::Unwind { .. } => {}
+        Inst::DummyUse { reg } => {
             collector.reg_use(reg);
         }
-        &Inst::FloatRound {
-            rd,
-            int_tmp,
-            f_tmp,
-            rs,
-            ..
-        } => {
-            collector.reg_use(rs);
-            collector.reg_early_def(int_tmp);
-            collector.reg_early_def(f_tmp);
-            collector.reg_early_def(rd);
-        }
-        &Inst::FloatSelect {
-            rd, tmp, rs1, rs2, ..
-        } => {
-            collector.reg_uses(&[rs1, rs2]);
-            collector.reg_early_def(tmp);
-            collector.reg_early_def(rd);
-        }
-        &Inst::Popcnt {
+        Inst::Popcnt {
             sum, step, rs, tmp, ..
         } => {
             collector.reg_use(rs);
@@ -624,13 +545,7 @@ fn riscv64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut Operan
             collector.reg_early_def(step);
             collector.reg_early_def(sum);
         }
-        &Inst::Rev8 { rs, rd, tmp, step } => {
-            collector.reg_use(rs);
-            collector.reg_early_def(tmp);
-            collector.reg_early_def(step);
-            collector.reg_early_def(rd);
-        }
-        &Inst::Cltz {
+        Inst::Cltz {
             sum, step, tmp, rs, ..
         } => {
             collector.reg_use(rs);
@@ -638,7 +553,7 @@ fn riscv64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut Operan
             collector.reg_early_def(step);
             collector.reg_early_def(sum);
         }
-        &Inst::Brev8 {
+        Inst::Brev8 {
             rs,
             rd,
             step,
@@ -652,19 +567,19 @@ fn riscv64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut Operan
             collector.reg_early_def(tmp2);
             collector.reg_early_def(rd);
         }
-        &Inst::StackProbeLoop { .. } => {
+        Inst::StackProbeLoop { .. } => {
             // StackProbeLoop has a tmp register and StackProbeLoop used at gen_prologue.
             // t3 will do the job. (t3 is caller-save register and not used directly by compiler like writable_spilltmp_reg)
             // gen_prologue is called at emit stage.
             // no need let reg alloc know.
         }
-        &Inst::VecAluRRRR {
+        Inst::VecAluRRRR {
             op,
             vd,
             vd_src,
             vs1,
             vs2,
-            ref mask,
+            mask,
             ..
         } => {
             debug_assert_eq!(vd_src.class(), RegClass::Vector);
@@ -678,12 +593,12 @@ fn riscv64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut Operan
             collector.reg_reuse_def(vd, 2); // `vd` == `vd_src`.
             vec_mask_late_operands(mask, collector);
         }
-        &Inst::VecAluRRRImm5 {
+        Inst::VecAluRRRImm5 {
             op,
             vd,
             vd_src,
             vs2,
-            ref mask,
+            mask,
             ..
         } => {
             debug_assert_eq!(vd_src.class(), RegClass::Vector);
@@ -704,12 +619,12 @@ fn riscv64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut Operan
                 vec_mask_operands(mask, collector);
             }
         }
-        &Inst::VecAluRRR {
+        Inst::VecAluRRR {
             op,
             vd,
             vs1,
             vs2,
-            ref mask,
+            mask,
             ..
         } => {
             debug_assert_eq!(vd.to_reg().class(), RegClass::Vector);
@@ -730,12 +645,8 @@ fn riscv64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut Operan
 
             vec_mask_operands(mask, collector);
         }
-        &Inst::VecAluRRImm5 {
-            op,
-            vd,
-            vs2,
-            ref mask,
-            ..
+        Inst::VecAluRRImm5 {
+            op, vd, vs2, mask, ..
         } => {
             debug_assert_eq!(vd.to_reg().class(), RegClass::Vector);
             debug_assert_eq!(vs2.class(), RegClass::Vector);
@@ -753,12 +664,8 @@ fn riscv64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut Operan
 
             vec_mask_operands(mask, collector);
         }
-        &Inst::VecAluRR {
-            op,
-            vd,
-            vs,
-            ref mask,
-            ..
+        Inst::VecAluRR {
+            op, vd, vs, mask, ..
         } => {
             debug_assert_eq!(vd.to_reg().class(), op.dst_regclass());
             debug_assert_eq!(vs.class(), op.src_regclass());
@@ -776,39 +683,23 @@ fn riscv64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut Operan
 
             vec_mask_operands(mask, collector);
         }
-        &Inst::VecAluRImm5 {
-            op, vd, ref mask, ..
-        } => {
+        Inst::VecAluRImm5 { op, vd, mask, .. } => {
             debug_assert_eq!(vd.to_reg().class(), RegClass::Vector);
             debug_assert!(!op.forbids_overlaps(mask));
 
             collector.reg_def(vd);
             vec_mask_operands(mask, collector);
         }
-        &Inst::VecSetState { rd, .. } => {
+        Inst::VecSetState { rd, .. } => {
             collector.reg_def(rd);
         }
-        &Inst::VecLoad {
-            to,
-            ref from,
-            ref mask,
-            ..
-        } => {
-            if let Some(r) = from.get_allocatable_register() {
-                collector.reg_use(r);
-            }
+        Inst::VecLoad { to, from, mask, .. } => {
+            from.get_operands(collector);
             collector.reg_def(to);
             vec_mask_operands(mask, collector);
         }
-        &Inst::VecStore {
-            ref to,
-            from,
-            ref mask,
-            ..
-        } => {
-            if let Some(r) = to.get_allocatable_register() {
-                collector.reg_use(r);
-            }
+        Inst::VecStore { to, from, mask, .. } => {
+            to.get_operands(collector);
             collector.reg_use(from);
             vec_mask_operands(mask, collector);
         }
@@ -837,21 +728,18 @@ impl MachInst for Inst {
 
     fn is_safepoint(&self) -> bool {
         match self {
-            &Inst::Call { .. }
-            | &Inst::CallInd { .. }
-            | &Inst::TrapIf { .. }
-            | &Inst::Udf { .. } => true,
+            Inst::Call { .. } | Inst::CallInd { .. } => true,
             _ => false,
         }
     }
 
-    fn get_operands<F: Fn(VReg) -> VReg>(&self, collector: &mut OperandCollector<'_, F>) {
+    fn get_operands(&mut self, collector: &mut impl OperandVisitor) {
         riscv64_get_operands(self, collector);
     }
 
     fn is_move(&self) -> Option<(Writable<Reg>, Reg)> {
         match self {
-            Inst::Mov { rd, rm, .. } => Some((rd.clone(), rm.clone())),
+            Inst::Mov { rd, rm, .. } => Some((*rd, *rm)),
             _ => None,
         }
     }
@@ -889,6 +777,10 @@ impl MachInst for Inst {
         }
     }
 
+    fn is_mem_access(&self) -> bool {
+        panic!("TODO FILL ME OUT")
+    }
+
     fn gen_move(to_reg: Writable<Reg>, from_reg: Reg, ty: Type) -> Inst {
         let x = Inst::Mov {
             rd: to_reg,
@@ -913,8 +805,7 @@ impl MachInst for Inst {
             I16 => Ok((&[RegClass::Int], &[I16])),
             I32 => Ok((&[RegClass::Int], &[I32])),
             I64 => Ok((&[RegClass::Int], &[I64])),
-            R32 => panic!("32-bit reftype pointer should never be seen on riscv64"),
-            R64 => Ok((&[RegClass::Int], &[R64])),
+            F16 => Ok((&[RegClass::Float], &[F16])),
             F32 => Ok((&[RegClass::Float], &[F32])),
             F64 => Ok((&[RegClass::Float], &[F64])),
             I128 => Ok((&[RegClass::Int, RegClass::Int], &[I64, I64])),
@@ -938,8 +829,7 @@ impl MachInst for Inst {
                 Ok((&[RegClass::Vector], ty))
             }
             _ => Err(CodegenError::Unsupported(format!(
-                "Unexpected SSA-value type: {}",
-                ty
+                "Unexpected SSA-value type: {ty}"
             ))),
         }
     }
@@ -949,8 +839,8 @@ impl MachInst for Inst {
     }
 
     fn worst_case_size() -> CodeOffset {
-        // calculate by test function riscv64_worst_case_instruction_size()
-        124
+        // Our worst case size is determined by the riscv64_worst_case_instruction_size test
+        84
     }
 
     fn ref_type_regclass(_settings: &settings::Flags) -> RegClass {
@@ -995,43 +885,36 @@ pub fn reg_name(reg: Reg) -> String {
             RegClass::Vector => format!("v{}", real.hw_enc()),
         },
         None => {
-            format!("{:?}", reg)
+            format!("{reg:?}")
         }
     }
 }
 
 impl Inst {
-    fn print_with_state(
-        &self,
-        _state: &mut EmitState,
-        allocs: &mut AllocationConsumer<'_>,
-    ) -> String {
-        let format_reg = |reg: Reg, allocs: &mut AllocationConsumer<'_>| -> String {
-            let reg = allocs.next(reg);
-            reg_name(reg)
-        };
+    fn print_with_state(&self, _state: &mut EmitState) -> String {
+        let format_reg = |reg: Reg| -> String { reg_name(reg) };
 
-        let format_vec_amode = |amode: &VecAMode, allocs: &mut AllocationConsumer<'_>| -> String {
+        let format_vec_amode = |amode: &VecAMode| -> String {
             match amode {
-                VecAMode::UnitStride { base } => base.to_string_with_alloc(allocs),
+                VecAMode::UnitStride { base } => base.to_string(),
             }
         };
 
-        let format_mask = |mask: &VecOpMasking, allocs: &mut AllocationConsumer<'_>| -> String {
+        let format_mask = |mask: &VecOpMasking| -> String {
             match mask {
-                VecOpMasking::Enabled { reg } => format!(",{}.t", format_reg(*reg, allocs)),
+                VecOpMasking::Enabled { reg } => format!(",{}.t", format_reg(*reg)),
                 VecOpMasking::Disabled => format!(""),
             }
         };
 
-        let format_regs = |regs: &[Reg], allocs: &mut AllocationConsumer<'_>| -> String {
+        let format_regs = |regs: &[Reg]| -> String {
             let mut x = if regs.len() > 1 {
                 String::from("[")
             } else {
                 String::default()
             };
             regs.iter().for_each(|i| {
-                x.push_str(format_reg(i.clone(), allocs).as_str());
+                x.push_str(format_reg(*i).as_str());
                 if *i != *regs.last().unwrap() {
                     x.push_str(",");
                 }
@@ -1060,15 +943,10 @@ impl Inst {
             x
         };
 
-        fn format_frm(rounding_mode: Option<FRM>) -> String {
-            if let Some(r) = rounding_mode {
-                format!(",{}", r.to_static_str(),)
-            } else {
-                "".into()
-            }
+        fn format_frm(rounding_mode: FRM) -> String {
+            format!(",{}", rounding_mode.to_static_str())
         }
 
-        let mut empty_allocs = AllocationConsumer::default();
         match self {
             &Inst::Nop0 => {
                 format!("##zero length nop")
@@ -1081,71 +959,25 @@ impl Inst {
                 probe_count,
                 tmp,
             } => {
-                let tmp = format_reg(tmp.to_reg(), allocs);
+                let tmp = format_reg(tmp.to_reg());
                 format!(
-                    "inline_stack_probe##guard_size={} probe_count={} tmp={}",
-                    guard_size, probe_count, tmp
-                )
-            }
-            &Inst::FloatRound {
-                op,
-                rd,
-                int_tmp,
-                f_tmp,
-                rs,
-                ty,
-            } => {
-                let rs = format_reg(rs, allocs);
-                let int_tmp = format_reg(int_tmp.to_reg(), allocs);
-                let f_tmp = format_reg(f_tmp.to_reg(), allocs);
-                let rd = format_reg(rd.to_reg(), allocs);
-                format!(
-                    "{} {},{}##int_tmp={} f_tmp={} ty={}",
-                    op.op_name(),
-                    rd,
-                    rs,
-                    int_tmp,
-                    f_tmp,
-                    ty
-                )
-            }
-            &Inst::FloatSelect {
-                op,
-                rd,
-                tmp,
-                rs1,
-                rs2,
-                ty,
-            } => {
-                let rs1 = format_reg(rs1, allocs);
-                let rs2 = format_reg(rs2, allocs);
-                let tmp = format_reg(tmp.to_reg(), allocs);
-                let rd = format_reg(rd.to_reg(), allocs);
-                format!(
-                    "f{}.{} {},{},{}##tmp={} ty={}",
-                    op.op_name(),
-                    if ty == F32 { "s" } else { "d" },
-                    rd,
-                    rs1,
-                    rs2,
-                    tmp,
-                    ty
+                    "inline_stack_probe##guard_size={guard_size} probe_count={probe_count} tmp={tmp}"
                 )
             }
             &Inst::AtomicStore { src, ty, p } => {
-                let src = format_reg(src, allocs);
-                let p = format_reg(p, allocs);
-                format!("atomic_store.{} {},({})", ty, src, p)
+                let src = format_reg(src);
+                let p = format_reg(p);
+                format!("atomic_store.{ty} {src},({p})")
             }
             &Inst::DummyUse { reg } => {
-                let reg = format_reg(reg, allocs);
-                format!("dummy_use {}", reg)
+                let reg = format_reg(reg);
+                format!("dummy_use {reg}")
             }
 
             &Inst::AtomicLoad { rd, ty, p } => {
-                let p = format_reg(p, allocs);
-                let rd = format_reg(rd.to_reg(), allocs);
-                format!("atomic_load.{} {},({})", ty, rd, p)
+                let p = format_reg(p);
+                let rd = format_reg(rd.to_reg());
+                format!("atomic_load.{ty} {rd},({p})")
             }
             &Inst::AtomicRmwLoop {
                 offset,
@@ -1156,15 +988,12 @@ impl Inst {
                 x,
                 t0,
             } => {
-                let offset = format_reg(offset, allocs);
-                let p = format_reg(p, allocs);
-                let x = format_reg(x, allocs);
-                let t0 = format_reg(t0.to_reg(), allocs);
-                let dst = format_reg(dst.to_reg(), allocs);
-                format!(
-                    "atomic_rmw.{} {} {},{},({})##t0={} offset={}",
-                    ty, op, dst, x, p, t0, offset
-                )
+                let offset = format_reg(offset);
+                let p = format_reg(p);
+                let x = format_reg(x);
+                let t0 = format_reg(t0.to_reg());
+                let dst = format_reg(dst.to_reg());
+                format!("atomic_rmw.{ty} {op} {dst},{x},({p})##t0={t0} offset={offset}")
             }
 
             &Inst::RawData { ref data } => match data.len() {
@@ -1183,11 +1012,11 @@ impl Inst {
                     format!(".8byte 0x{:x}", u64::from_le_bytes(bytes))
                 }
                 _ => {
-                    format!(".data {:?}", data)
+                    format!(".data {data:?}")
                 }
             },
             &Inst::Unwind { ref inst } => {
-                format!("unwind {:?}", inst)
+                format!("unwind {inst:?}")
             }
             &Inst::Brev8 {
                 rs,
@@ -1197,15 +1026,12 @@ impl Inst {
                 tmp2,
                 rd,
             } => {
-                let rs = format_reg(rs, allocs);
-                let step = format_reg(step.to_reg(), allocs);
-                let tmp = format_reg(tmp.to_reg(), allocs);
-                let tmp2 = format_reg(tmp2.to_reg(), allocs);
-                let rd = format_reg(rd.to_reg(), allocs);
-                format!(
-                    "brev8 {},{}##tmp={} tmp2={} step={} ty={}",
-                    rd, rs, tmp, tmp2, step, ty
-                )
+                let rs = format_reg(rs);
+                let step = format_reg(step.to_reg());
+                let tmp = format_reg(tmp.to_reg());
+                let tmp2 = format_reg(tmp2.to_reg());
+                let rd = format_reg(rd.to_reg());
+                format!("brev8 {rd},{rs}##tmp={tmp} tmp2={tmp2} step={step} ty={ty}")
             }
             &Inst::Popcnt {
                 sum,
@@ -1214,18 +1040,11 @@ impl Inst {
                 tmp,
                 ty,
             } => {
-                let rs = format_reg(rs, allocs);
-                let tmp = format_reg(tmp.to_reg(), allocs);
-                let step = format_reg(step.to_reg(), allocs);
-                let sum = format_reg(sum.to_reg(), allocs);
-                format!("popcnt {},{}##ty={} tmp={} step={}", sum, rs, ty, tmp, step)
-            }
-            &Inst::Rev8 { rs, rd, tmp, step } => {
-                let rs = format_reg(rs, allocs);
-                let tmp = format_reg(tmp.to_reg(), allocs);
-                let step = format_reg(step.to_reg(), allocs);
-                let rd = format_reg(rd.to_reg(), allocs);
-                format!("rev8 {},{}##step={} tmp={}", rd, rs, step, tmp)
+                let rs = format_reg(rs);
+                let tmp = format_reg(tmp.to_reg());
+                let step = format_reg(step.to_reg());
+                let sum = format_reg(sum.to_reg());
+                format!("popcnt {sum},{rs}##ty={ty} tmp={tmp} step={step}")
             }
             &Inst::Cltz {
                 sum,
@@ -1235,10 +1054,10 @@ impl Inst {
                 ty,
                 leading,
             } => {
-                let rs = format_reg(rs, allocs);
-                let tmp = format_reg(tmp.to_reg(), allocs);
-                let step = format_reg(step.to_reg(), allocs);
-                let sum = format_reg(sum.to_reg(), allocs);
+                let rs = format_reg(rs);
+                let tmp = format_reg(tmp.to_reg());
+                let step = format_reg(step.to_reg());
+                let sum = format_reg(sum.to_reg());
                 format!(
                     "{} {},{}##ty={} tmp={} step={}",
                     if leading { "clz" } else { "ctz" },
@@ -1249,29 +1068,6 @@ impl Inst {
                     step
                 )
             }
-            &Inst::FcvtToInt {
-                is_sat,
-                rd,
-                rs,
-                is_signed,
-                in_type,
-                out_type,
-                tmp,
-            } => {
-                let rs = format_reg(rs, allocs);
-                let tmp = format_reg(tmp.to_reg(), allocs);
-                let rd = format_reg(rd.to_reg(), allocs);
-                format!(
-                    "fcvt_to_{}int{}.{} {},{}##in_ty={} tmp={}",
-                    if is_signed { "s" } else { "u" },
-                    if is_sat { "_sat" } else { "" },
-                    out_type,
-                    rd,
-                    rs,
-                    in_type,
-                    tmp
-                )
-            }
             &Inst::AtomicCas {
                 offset,
                 t0,
@@ -1281,22 +1077,13 @@ impl Inst {
                 v,
                 ty,
             } => {
-                let offset = format_reg(offset, allocs);
-                let e = format_reg(e, allocs);
-                let addr = format_reg(addr, allocs);
-                let v = format_reg(v, allocs);
-                let t0 = format_reg(t0.to_reg(), allocs);
-                let dst = format_reg(dst.to_reg(), allocs);
-                format!(
-                    "atomic_cas.{} {},{},{},({})##t0={} offset={}",
-                    ty, dst, e, v, addr, t0, offset,
-                )
-            }
-            &Inst::Icmp { cc, rd, a, b, ty } => {
-                let a = format_regs(a.regs(), allocs);
-                let b = format_regs(b.regs(), allocs);
-                let rd = format_reg(rd.to_reg(), allocs);
-                format!("{} {},{},{}##ty={}", cc.to_static_str(), rd, a, b, ty)
+                let offset = format_reg(offset);
+                let e = format_reg(e);
+                let addr = format_reg(addr);
+                let v = format_reg(v);
+                let t0 = format_reg(t0.to_reg());
+                let dst = format_reg(dst.to_reg());
+                format!("atomic_cas.{ty} {dst},{e},{v},({addr})##t0={t0} offset={offset}",)
             }
             &Inst::BrTable {
                 index,
@@ -1307,40 +1094,41 @@ impl Inst {
                 format!(
                     "{} {},{}##tmp1={},tmp2={}",
                     "br_table",
-                    format_reg(index, allocs),
+                    format_reg(index),
                     format_labels(&targets[..]),
-                    format_reg(tmp1.to_reg(), allocs),
-                    format_reg(tmp2.to_reg(), allocs),
+                    format_reg(tmp1.to_reg()),
+                    format_reg(tmp2.to_reg()),
                 )
             }
             &Inst::Auipc { rd, imm } => {
-                format!(
-                    "{} {},{}",
-                    "auipc",
-                    format_reg(rd.to_reg(), allocs),
-                    imm.as_i32(),
-                )
+                format!("{} {},{}", "auipc", format_reg(rd.to_reg()), imm.as_i32(),)
             }
             &Inst::Jalr { rd, base, offset } => {
-                let base = format_reg(base, allocs);
-                let rd = format_reg(rd.to_reg(), allocs);
+                let base = format_reg(base);
+                let rd = format_reg(rd.to_reg());
                 format!("{} {},{}({})", "jalr", rd, offset.as_i16(), base)
             }
             &Inst::Lui { rd, ref imm } => {
-                format!(
-                    "{} {},{}",
-                    "lui",
-                    format_reg(rd.to_reg(), allocs),
-                    imm.as_i32()
-                )
+                format!("{} {},{}", "lui", format_reg(rd.to_reg()), imm.as_i32())
+            }
+            &Inst::Fli { rd, ty, imm } => {
+                let rd_s = format_reg(rd.to_reg());
+                let imm_s = imm.format();
+                let suffix = match ty {
+                    F32 => "s",
+                    F64 => "d",
+                    _ => unreachable!(),
+                };
+
+                format!("fli.{suffix} {rd_s},{imm_s}")
             }
             &Inst::LoadInlineConst { rd, imm, .. } => {
-                let rd = format_reg(rd.to_reg(), allocs);
+                let rd = format_reg(rd.to_reg());
                 let mut buf = String::new();
-                write!(&mut buf, "auipc {},0; ", rd).unwrap();
-                write!(&mut buf, "ld {},12({}); ", rd, rd).unwrap();
+                write!(&mut buf, "auipc {rd},0; ").unwrap();
+                write!(&mut buf, "ld {rd},12({rd}); ").unwrap();
                 write!(&mut buf, "j {}; ", Inst::UNCOMPRESSED_INSTRUCTION_SIZE + 8).unwrap();
-                write!(&mut buf, ".8byte 0x{:x}", imm).unwrap();
+                write!(&mut buf, ".8byte 0x{imm:x}").unwrap();
                 buf
             }
             &Inst::AluRRR {
@@ -1349,12 +1137,12 @@ impl Inst {
                 rs1,
                 rs2,
             } => {
-                let rs1_s = format_reg(rs1, allocs);
-                let rs2_s = format_reg(rs2, allocs);
-                let rd_s = format_reg(rd.to_reg(), allocs);
+                let rs1_s = format_reg(rs1);
+                let rs2_s = format_reg(rs2);
+                let rd_s = format_reg(rd.to_reg());
                 match alu_op {
                     AluOPRRR::Adduw if rs2 == zero_reg() => {
-                        format!("zext.w {},{}", rd_s, rs1_s)
+                        format!("zext.w {rd_s},{rs1_s}")
                     }
                     _ => {
                         format!("{} {},{},{}", alu_op.op_name(), rd_s, rs1_s, rs2_s)
@@ -1362,57 +1150,44 @@ impl Inst {
                 }
             }
             &Inst::FpuRR {
-                frm,
                 alu_op,
+                width,
+                frm,
                 rd,
                 rs,
             } => {
-                let rs = format_reg(rs, allocs);
-                let rd = format_reg(rd.to_reg(), allocs);
-                format!("{} {},{}{}", alu_op.op_name(), rd, rs, format_frm(frm))
+                let rs = format_reg(rs);
+                let rd = format_reg(rd.to_reg());
+                let frm = if alu_op.has_frm() {
+                    format_frm(frm)
+                } else {
+                    String::new()
+                };
+                format!("{} {rd},{rs}{frm}", alu_op.op_name(width))
             }
             &Inst::FpuRRR {
                 alu_op,
+                width,
                 rd,
                 rs1,
                 rs2,
                 frm,
             } => {
-                let rs1 = format_reg(rs1, allocs);
-                let rs2 = format_reg(rs2, allocs);
-                let rd = format_reg(rd.to_reg(), allocs);
-                let rs1_is_rs2 = rs1 == rs2;
-                if rs1_is_rs2 && alu_op.is_copy_sign() {
-                    // this is move instruction.
-                    format!(
-                        "fmv.{} {},{}",
-                        if alu_op.is_32() { "s" } else { "d" },
-                        rd,
-                        rs1
-                    )
-                } else if rs1_is_rs2 && alu_op.is_copy_neg_sign() {
-                    format!(
-                        "fneg.{} {},{}",
-                        if alu_op.is_32() { "s" } else { "d" },
-                        rd,
-                        rs1
-                    )
-                } else if rs1_is_rs2 && alu_op.is_copy_xor_sign() {
-                    format!(
-                        "fabs.{} {},{}",
-                        if alu_op.is_32() { "s" } else { "d" },
-                        rd,
-                        rs1
-                    )
+                let rs1 = format_reg(rs1);
+                let rs2 = format_reg(rs2);
+                let rd = format_reg(rd.to_reg());
+                let frm = if alu_op.has_frm() {
+                    format_frm(frm)
                 } else {
-                    format!(
-                        "{} {},{},{}{}",
-                        alu_op.op_name(),
-                        rd,
-                        rs1,
-                        rs2,
-                        format_frm(frm)
-                    )
+                    String::new()
+                };
+
+                let rs1_is_rs2 = rs1 == rs2;
+                match alu_op {
+                    FpuOPRRR::Fsgnj if rs1_is_rs2 => format!("fmv.{width} {rd},{rs1}"),
+                    FpuOPRRR::Fsgnjn if rs1_is_rs2 => format!("fneg.{width} {rd},{rs1}"),
+                    FpuOPRRR::Fsgnjx if rs1_is_rs2 => format!("fabs.{width} {rd},{rs1}"),
+                    _ => format!("{} {rd},{rs1},{rs2}{frm}", alu_op.op_name(width)),
                 }
             }
             &Inst::FpuRRRR {
@@ -1422,20 +1197,15 @@ impl Inst {
                 rs2,
                 rs3,
                 frm,
+                width,
             } => {
-                let rs1 = format_reg(rs1, allocs);
-                let rs2 = format_reg(rs2, allocs);
-                let rs3 = format_reg(rs3, allocs);
-                let rd = format_reg(rd.to_reg(), allocs);
-                format!(
-                    "{} {},{},{},{}{}",
-                    alu_op.op_name(),
-                    rd,
-                    rs1,
-                    rs2,
-                    rs3,
-                    format_frm(frm)
-                )
+                let rs1 = format_reg(rs1);
+                let rs2 = format_reg(rs2);
+                let rs3 = format_reg(rs3);
+                let rd = format_reg(rd.to_reg());
+                let frm = format_frm(frm);
+                let op_name = alu_op.op_name(width);
+                format!("{op_name} {rd},{rs1},{rs2},{rs3}{frm}")
             }
             &Inst::AluRRImm12 {
                 alu_op,
@@ -1443,8 +1213,8 @@ impl Inst {
                 rs,
                 ref imm12,
             } => {
-                let rs_s = format_reg(rs, allocs);
-                let rd = format_reg(rd.to_reg(), allocs);
+                let rs_s = format_reg(rs);
+                let rd = format_reg(rd.to_reg());
 
                 // Some of these special cases are better known as
                 // their pseudo-instruction version, so prefer printing those.
@@ -1453,13 +1223,13 @@ impl Inst {
                         return format!("li {},{}", rd, imm12.as_i16());
                     }
                     (AluOPRRI::Addiw, _, imm12) if imm12.as_i16() == 0 => {
-                        return format!("sext.w {},{}", rd, rs_s);
+                        return format!("sext.w {rd},{rs_s}");
                     }
                     (AluOPRRI::Xori, _, imm12) if imm12.as_i16() == -1 => {
-                        return format!("not {},{}", rd, rs_s);
+                        return format!("not {rd},{rs_s}");
                     }
                     (AluOPRRI::SltiU, _, imm12) if imm12.as_i16() == 1 => {
-                        return format!("seqz {},{}", rd, rs_s);
+                        return format!("seqz {rd},{rs_s}");
                     }
                     (alu_op, _, _) if alu_op.option_funct12().is_some() => {
                         format!("{} {},{}", alu_op.op_name(), rd, rs_s)
@@ -1470,8 +1240,8 @@ impl Inst {
                 }
             }
             &Inst::CsrReg { op, rd, rs, csr } => {
-                let rs_s = format_reg(rs, allocs);
-                let rd_s = format_reg(rd.to_reg(), allocs);
+                let rs_s = format_reg(rs);
+                let rd_s = format_reg(rd.to_reg());
 
                 match (op, csr, rd) {
                     (CsrRegOP::CsrRW, CSR::Frm, rd) if rd.to_reg() == zero_reg() => {
@@ -1483,7 +1253,7 @@ impl Inst {
                 }
             }
             &Inst::CsrImm { op, rd, csr, imm } => {
-                let rd_s = format_reg(rd.to_reg(), allocs);
+                let rd_s = format_reg(rd.to_reg());
 
                 match (op, csr, rd) {
                     (CsrImmOP::CsrRWI, CSR::Frm, rd) if rd.to_reg() != zero_reg() => {
@@ -1500,8 +1270,8 @@ impl Inst {
                 from,
                 flags: _flags,
             } => {
-                let base = from.to_string_with_alloc(allocs);
-                let rd = format_reg(rd.to_reg(), allocs);
+                let base = from.to_string();
+                let rd = format_reg(rd.to_reg());
                 format!("{} {},{}", op.op_name(), rd, base,)
             }
             &Inst::Store {
@@ -1510,26 +1280,24 @@ impl Inst {
                 op,
                 flags: _flags,
             } => {
-                let base = to.to_string_with_alloc(allocs);
-                let src = format_reg(src, allocs);
+                let base = to.to_string();
+                let src = format_reg(src);
                 format!("{} {},{}", op.op_name(), src, base,)
             }
             &Inst::Args { ref args } => {
                 let mut s = "args".to_string();
-                let mut empty_allocs = AllocationConsumer::default();
                 for arg in args {
-                    let preg = format_reg(arg.preg, &mut empty_allocs);
-                    let def = format_reg(arg.vreg.to_reg(), allocs);
-                    write!(&mut s, " {}={}", def, preg).unwrap();
+                    let preg = format_reg(arg.preg);
+                    let def = format_reg(arg.vreg.to_reg());
+                    write!(&mut s, " {def}={preg}").unwrap();
                 }
                 s
             }
             &Inst::Rets { ref rets } => {
                 let mut s = "rets".to_string();
-                let mut empty_allocs = AllocationConsumer::default();
                 for ret in rets {
-                    let preg = format_reg(ret.preg, &mut empty_allocs);
-                    let vreg = format_reg(ret.vreg, allocs);
+                    let preg = format_reg(ret.preg);
+                    let vreg = format_reg(ret.vreg);
                     write!(&mut s, " {vreg}={preg}").unwrap();
                 }
                 s
@@ -1543,8 +1311,8 @@ impl Inst {
                 from_bits,
                 ..
             } => {
-                let rn = format_reg(rn, allocs);
-                let rd = format_reg(rd.to_reg(), allocs);
+                let rn = format_reg(rn);
+                let rd = format_reg(rd.to_reg());
                 return if signed == false && from_bits == 8 {
                     format!("andi {rd},{rn}")
                 } else {
@@ -1553,38 +1321,35 @@ impl Inst {
                     format!("slli {rd},{rn},{shift_bits}; {op} {rd},{rd},{shift_bits}")
                 };
             }
-            &MInst::AdjustSp { amount } => {
-                format!("{} sp,{:+}", "add", amount)
-            }
             &MInst::Call { ref info } => format!("call {}", info.dest.display(None)),
             &MInst::CallInd { ref info } => {
-                let rd = format_reg(info.rn, allocs);
-                format!("callind {}", rd)
+                let rd = format_reg(info.rn);
+                format!("callind {rd}")
             }
             &MInst::ReturnCall {
                 ref callee,
                 ref info,
             } => {
                 let mut s = format!(
-                    "return_call {callee:?} old_stack_arg_size:{} new_stack_arg_size:{}",
-                    info.old_stack_arg_size, info.new_stack_arg_size
+                    "return_call {callee:?} new_stack_arg_size:{}",
+                    info.new_stack_arg_size
                 );
                 for ret in &info.uses {
-                    let preg = format_reg(ret.preg, &mut empty_allocs);
-                    let vreg = format_reg(ret.vreg, allocs);
+                    let preg = format_reg(ret.preg);
+                    let vreg = format_reg(ret.vreg);
                     write!(&mut s, " {vreg}={preg}").unwrap();
                 }
                 s
             }
             &MInst::ReturnCallInd { callee, ref info } => {
-                let callee = format_reg(callee, allocs);
+                let callee = format_reg(callee);
                 let mut s = format!(
-                    "return_call_ind {callee} old_stack_arg_size:{} new_stack_arg_size:{}",
-                    info.old_stack_arg_size, info.new_stack_arg_size
+                    "return_call_ind {callee} new_stack_arg_size:{}",
+                    info.new_stack_arg_size
                 );
                 for ret in &info.uses {
-                    let preg = format_reg(ret.preg, &mut empty_allocs);
-                    let vreg = format_reg(ret.vreg, allocs);
+                    let preg = format_reg(ret.preg);
+                    let vreg = format_reg(ret.vreg);
                     write!(&mut s, " {vreg}={preg}").unwrap();
                 }
                 s
@@ -1595,8 +1360,8 @@ impl Inst {
                 cc,
                 trap_code,
             } => {
-                let rs1 = format_reg(rs1, allocs);
-                let rs2 = format_reg(rs2, allocs);
+                let rs1 = format_reg(rs1);
+                let rs2 = format_reg(rs2);
                 format!("trap_if {trap_code}##({rs1} {cc} {rs2})")
             }
             &MInst::Jal { label } => {
@@ -1608,8 +1373,8 @@ impl Inst {
                 kind,
                 ..
             } => {
-                let rs1 = format_reg(kind.rs1, allocs);
-                let rs2 = format_reg(kind.rs2, allocs);
+                let rs1 = format_reg(kind.rs1);
+                let rs2 = format_reg(kind.rs2);
                 if not_taken.is_fallthrouh() && taken.as_label().is_none() {
                     format!("{} {},{},0", kind.op_name(), rs1, rs2)
                 } else {
@@ -1632,13 +1397,13 @@ impl Inst {
                 amo,
             } => {
                 let op_name = op.op_name(amo);
-                let addr = format_reg(addr, allocs);
-                let src = format_reg(src, allocs);
-                let rd = format_reg(rd.to_reg(), allocs);
+                let addr = format_reg(addr);
+                let src = format_reg(src);
+                let rd = format_reg(rd.to_reg());
                 if op.is_load() {
-                    format!("{} {},({})", op_name, rd, addr)
+                    format!("{op_name} {rd},({addr})")
                 } else {
-                    format!("{} {},{},({})", op_name, rd, src, addr)
+                    format!("{op_name} {rd},{src},({addr})")
                 }
             }
             &MInst::LoadExtName {
@@ -1646,26 +1411,24 @@ impl Inst {
                 ref name,
                 offset,
             } => {
-                let rd = format_reg(rd.to_reg(), allocs);
+                let rd = format_reg(rd.to_reg());
                 format!("load_sym {},{}{:+}", rd, name.display(None), offset)
             }
             &Inst::ElfTlsGetAddr { rd, ref name } => {
-                let rd = format_reg(rd.to_reg(), allocs);
+                let rd = format_reg(rd.to_reg());
                 format!("elf_tls_get_addr {rd},{}", name.display(None))
             }
             &MInst::LoadAddr { ref rd, ref mem } => {
-                let rs = mem.to_string_with_alloc(allocs);
-                let rd = format_reg(rd.to_reg(), allocs);
-                format!("load_addr {},{}", rd, rs)
-            }
-            &MInst::VirtualSPOffsetAdj { amount } => {
-                format!("virtual_sp_offset_adj {:+}", amount)
+                let rs = mem.to_string();
+                let rd = format_reg(rd.to_reg());
+                format!("load_addr {rd},{rs}")
             }
             &MInst::Mov { rd, rm, ty } => {
-                let rd = format_reg(rd.to_reg(), allocs);
-                let rm = format_reg(rm, allocs);
+                let rm = format_reg(rm);
+                let rd = format_reg(rd.to_reg());
 
                 let op = match ty {
+                    F16 => "fmv.h",
                     F32 => "fmv.s",
                     F64 => "fmv.d",
                     ty if ty.is_vector() => "vmv1r.v",
@@ -1675,10 +1438,10 @@ impl Inst {
                 format!("{op} {rd},{rm}")
             }
             &MInst::MovFromPReg { rd, rm } => {
-                let rd = format_reg(rd.to_reg(), allocs);
+                let rd = format_reg(rd.to_reg());
                 debug_assert!([px_reg(2), px_reg(8)].contains(&rm));
                 let rm = reg_name(Reg::from(rm));
-                format!("mv {},{}", rd, rm)
+                format!("mv {rd},{rm}")
             }
             &MInst::Fence { pred, succ } => {
                 format!(
@@ -1693,12 +1456,12 @@ impl Inst {
                 ref x,
                 ref y,
             } => {
-                let c_rs1 = format_reg(condition.rs1, allocs);
-                let c_rs2 = format_reg(condition.rs2, allocs);
-                let x = format_regs(x.regs(), allocs);
-                let y = format_regs(y.regs(), allocs);
+                let c_rs1 = format_reg(condition.rs1);
+                let c_rs2 = format_reg(condition.rs2);
+                let x = format_regs(x.regs());
+                let y = format_regs(y.regs());
                 let dst = dst.map(|r| r.to_reg());
-                let dst = format_regs(dst.regs(), allocs);
+                let dst = format_regs(dst.regs());
                 format!(
                     "select {},{},{}##condition=({} {} {})",
                     dst,
@@ -1709,7 +1472,7 @@ impl Inst {
                     c_rs2
                 )
             }
-            &MInst::Udf { trap_code } => format!("udf##trap_code={}", trap_code),
+            &MInst::Udf { trap_code } => format!("udf##trap_code={trap_code}"),
             &MInst::EBreak {} => String::from("ebreak"),
             &Inst::VecAluRRRR {
                 op,
@@ -1720,14 +1483,14 @@ impl Inst {
                 ref mask,
                 ref vstate,
             } => {
-                let vs1_s = format_reg(vs1, allocs);
-                let vs2_s = format_reg(vs2, allocs);
-                let vd_src_s = format_reg(vd_src, allocs);
-                let vd_s = format_reg(vd.to_reg(), allocs);
-                let mask = format_mask(mask, allocs);
+                let vs1_s = format_reg(vs1);
+                let vs2_s = format_reg(vs2);
+                let vd_src_s = format_reg(vd_src);
+                let vd_s = format_reg(vd.to_reg());
+                let mask = format_mask(mask);
 
                 let vd_fmt = if vd_s != vd_src_s {
-                    format!("{},{}", vd_s, vd_src_s)
+                    format!("{vd_s},{vd_src_s}")
                 } else {
                     vd_s
                 };
@@ -1745,16 +1508,16 @@ impl Inst {
                 ref vstate,
                 ..
             } => {
-                let vs2_s = format_reg(vs2, allocs);
-                let vd_s = format_reg(vd.to_reg(), allocs);
-                let mask = format_mask(mask, allocs);
+                let vs2_s = format_reg(vs2);
+                let vd_s = format_reg(vd.to_reg());
+                let mask = format_mask(mask);
 
                 // Some opcodes interpret the immediate as unsigned, lets show the
                 // correct number here.
                 let imm_s = if op.imm_is_unsigned() {
                     format!("{}", imm.bits())
                 } else {
-                    format!("{}", imm)
+                    format!("{imm}")
                 };
 
                 format!("{op} {vd_s},{vs2_s},{imm_s}{mask} {vstate}")
@@ -1767,10 +1530,10 @@ impl Inst {
                 ref mask,
                 ref vstate,
             } => {
-                let vs1_s = format_reg(vs1, allocs);
-                let vs2_s = format_reg(vs2, allocs);
-                let vd_s = format_reg(vd.to_reg(), allocs);
-                let mask = format_mask(mask, allocs);
+                let vs1_s = format_reg(vs1);
+                let vs2_s = format_reg(vs2);
+                let vd_s = format_reg(vd.to_reg());
+                let mask = format_mask(mask);
 
                 // Note: vs2 and vs1 here are opposite to the standard scalar ordering.
                 // This is noted in Section 10.1 of the RISC-V Vector spec.
@@ -1798,16 +1561,16 @@ impl Inst {
                 ref mask,
                 ref vstate,
             } => {
-                let vs2_s = format_reg(vs2, allocs);
-                let vd_s = format_reg(vd.to_reg(), allocs);
-                let mask = format_mask(mask, allocs);
+                let vs2_s = format_reg(vs2);
+                let vd_s = format_reg(vd.to_reg());
+                let mask = format_mask(mask);
 
                 // Some opcodes interpret the immediate as unsigned, lets show the
                 // correct number here.
                 let imm_s = if op.imm_is_unsigned() {
                     format!("{}", imm.bits())
                 } else {
-                    format!("{}", imm)
+                    format!("{imm}")
                 };
 
                 match (op, imm) {
@@ -1824,9 +1587,9 @@ impl Inst {
                 ref mask,
                 ref vstate,
             } => {
-                let vs_s = format_reg(vs, allocs);
-                let vd_s = format_reg(vd.to_reg(), allocs);
-                let mask = format_mask(mask, allocs);
+                let vs_s = format_reg(vs);
+                let vd_s = format_reg(vd.to_reg());
+                let mask = format_mask(mask);
 
                 format!("{op} {vd_s},{vs_s}{mask} {vstate}")
             }
@@ -1837,13 +1600,13 @@ impl Inst {
                 ref mask,
                 ref vstate,
             } => {
-                let vd_s = format_reg(vd.to_reg(), allocs);
-                let mask = format_mask(mask, allocs);
+                let vd_s = format_reg(vd.to_reg());
+                let mask = format_mask(mask);
 
                 format!("{op} {vd_s},{imm}{mask} {vstate}")
             }
             &Inst::VecSetState { rd, ref vstate } => {
-                let rd_s = format_reg(rd.to_reg(), allocs);
+                let rd_s = format_reg(rd.to_reg());
                 assert!(vstate.avl.is_static());
                 format!("vsetivli {}, {}, {}", rd_s, vstate.avl, vstate.vtype)
             }
@@ -1855,9 +1618,9 @@ impl Inst {
                 ref vstate,
                 ..
             } => {
-                let base = format_vec_amode(from, allocs);
-                let vd = format_reg(to.to_reg(), allocs);
-                let mask = format_mask(mask, allocs);
+                let base = format_vec_amode(from);
+                let vd = format_reg(to.to_reg());
+                let mask = format_mask(mask);
 
                 format!("vl{eew}.v {vd},{base}{mask} {vstate}")
             }
@@ -1869,9 +1632,9 @@ impl Inst {
                 ref vstate,
                 ..
             } => {
-                let dst = format_vec_amode(to, allocs);
-                let vs3 = format_reg(*from, allocs);
-                let mask = format_mask(mask, allocs);
+                let dst = format_vec_amode(to);
+                let vs3 = format_reg(*from);
+                let mask = format_mask(mask);
 
                 format!("vs{eew}.v {vs3},{dst}{mask} {vstate}")
             }
@@ -1961,11 +1724,7 @@ impl MachInstLabelUse for LabelUse {
         // re-check range
         assert!(
             offset >= -(self.max_neg_range() as i64) && offset <= (self.max_pos_range() as i64),
-            "{:?} offset '{}' use_offset:'{}' label_offset:'{}'  must not exceed max range.",
-            self,
-            offset,
-            use_offset,
-            label_offset,
+            "{self:?} offset '{offset}' use_offset:'{use_offset}' label_offset:'{label_offset}'  must not exceed max range.",
         );
         self.patch_raw_offset(buffer, offset);
     }
@@ -2017,13 +1776,14 @@ impl MachInstLabelUse for LabelUse {
 
     fn from_reloc(reloc: Reloc, addend: Addend) -> Option<LabelUse> {
         match (reloc, addend) {
-            (Reloc::RiscvCall, _) => Some(Self::PCRel32),
+            (Reloc::RiscvCallPlt, _) => Some(Self::PCRel32),
             _ => None,
         }
     }
 }
 
 impl LabelUse {
+    #[allow(dead_code)] // in case it's needed in the future
     fn offset_in_range(self, offset: i64) -> bool {
         let min = -(self.max_neg_range() as i64);
         let max = self.max_pos_range() as i64;
diff --git a/cranelift/codegen/src/isa/riscv64/inst/regs.rs b/cranelift/codegen/src/isa/riscv64/inst/regs.rs
index e78acee06b6c..ffdc484a00c7 100644
--- a/cranelift/codegen/src/isa/riscv64/inst/regs.rs
+++ b/cranelift/codegen/src/isa/riscv64/inst/regs.rs
@@ -3,12 +3,10 @@
 
 use crate::machinst::{Reg, Writable};
 
-use crate::machinst::RealReg;
 use alloc::vec;
 use alloc::vec::Vec;
 
-use regalloc2::VReg;
-use regalloc2::{PReg, RegClass};
+use regalloc2::{PReg, RegClass, VReg};
 
 // first argument of function call
 #[inline]
@@ -18,38 +16,46 @@ pub fn a0() -> Reg {
 
 // second argument of function call
 #[inline]
+#[allow(dead_code)]
 pub fn a1() -> Reg {
     x_reg(11)
 }
 
 // third argument of function call
 #[inline]
+#[allow(dead_code)]
 pub fn a2() -> Reg {
     x_reg(12)
 }
 
 #[inline]
+#[allow(dead_code)]
 pub fn writable_a0() -> Writable<Reg> {
     Writable::from_reg(a0())
 }
 #[inline]
+#[allow(dead_code)]
 pub fn writable_a1() -> Writable<Reg> {
     Writable::from_reg(a1())
 }
 #[inline]
+#[allow(dead_code)]
 pub fn writable_a2() -> Writable<Reg> {
     Writable::from_reg(a2())
 }
 
 #[inline]
+#[allow(dead_code)]
 pub fn fa0() -> Reg {
     f_reg(10)
 }
 #[inline]
+#[allow(dead_code)]
 pub fn writable_fa0() -> Writable<Reg> {
     Writable::from_reg(fa0())
 }
 #[inline]
+#[allow(dead_code)]
 pub fn writable_fa1() -> Writable<Reg> {
     Writable::from_reg(fa1())
 }
@@ -58,11 +64,6 @@ pub fn fa1() -> Reg {
     f_reg(11)
 }
 
-#[inline]
-pub fn fa7() -> Reg {
-    f_reg(17)
-}
-
 /// Get a reference to the zero-register.
 #[inline]
 pub fn zero_reg() -> Reg {
@@ -152,11 +153,6 @@ pub fn f_reg(enc: usize) -> Reg {
 pub const fn pf_reg(enc: usize) -> PReg {
     PReg::new(enc, RegClass::Float)
 }
-#[inline]
-pub(crate) fn real_reg_to_reg(x: RealReg) -> Reg {
-    let v_reg = VReg::new(x.hw_enc() as usize, x.class());
-    Reg::from(v_reg)
-}
 
 #[allow(dead_code)]
 pub(crate) fn x_reg_range(start: usize, end: usize) -> Vec<Writable<Reg>> {
@@ -167,12 +163,6 @@ pub(crate) fn x_reg_range(start: usize, end: usize) -> Vec<Writable<Reg>> {
     regs
 }
 
-#[inline]
-pub fn v_reg(enc: usize) -> Reg {
-    let p_reg = PReg::new(enc, RegClass::Vector);
-    let v_reg = VReg::new(p_reg.index(), p_reg.class());
-    Reg::from(v_reg)
-}
 pub const fn pv_reg(enc: usize) -> PReg {
     PReg::new(enc, RegClass::Vector)
 }
diff --git a/cranelift/codegen/src/isa/riscv64/inst/unwind/systemv.rs b/cranelift/codegen/src/isa/riscv64/inst/unwind/systemv.rs
index 75bd6cebf7ec..4bbb8401451e 100644
--- a/cranelift/codegen/src/isa/riscv64/inst/unwind/systemv.rs
+++ b/cranelift/codegen/src/isa/riscv64/inst/unwind/systemv.rs
@@ -46,9 +46,6 @@ impl crate::isa::unwind::systemv::RegisterMapper<Reg> for RegisterMapper {
     fn map(&self, reg: Reg) -> Result<u16, RegisterMappingError> {
         Ok(map_reg(reg)?.0)
     }
-    fn sp(&self) -> u16 {
-        regs::stack_reg().to_real_reg().unwrap().hw_enc() as u16
-    }
     fn fp(&self) -> Option<u16> {
         Some(regs::fp_reg().to_real_reg().unwrap().hw_enc() as u16)
     }
@@ -72,7 +69,6 @@ mod tests {
     use crate::settings::{builder, Flags};
     use crate::Context;
     use gimli::write::Address;
-    use std::str::FromStr;
     use target_lexicon::triple;
 
     #[test]
@@ -84,7 +80,7 @@ mod tests {
 
         let mut context = Context::for_function(create_function(
             CallConv::SystemV,
-            Some(StackSlotData::new(StackSlotKind::ExplicitSlot, 64)),
+            Some(StackSlotData::new(StackSlotKind::ExplicitSlot, 64, 0)),
         ));
 
         let code = context
@@ -101,7 +97,7 @@ mod tests {
             _ => panic!("expected unwind information"),
         };
 
-        assert_eq!(format!("{:?}", fde), "FrameDescriptionEntry { address: Constant(1234), length: 40, lsda: None, instructions: [(12, CfaOffset(16)), (12, Offset(Register(8), -16)), (12, Offset(Register(1), -8)), (16, CfaRegister(Register(8)))] }");
+        assert_eq!(format!("{fde:?}"), "FrameDescriptionEntry { address: Constant(1234), length: 40, lsda: None, instructions: [(12, CfaOffset(16)), (12, Offset(Register(8), -16)), (12, Offset(Register(1), -8)), (16, CfaRegister(Register(8)))] }");
     }
 
     fn create_function(call_conv: CallConv, stack_slot: Option<StackSlotData>) -> Function {
@@ -144,7 +140,7 @@ mod tests {
         };
 
         assert_eq!(
-            format!("{:?}", fde),
+            format!("{fde:?}"),
             "FrameDescriptionEntry { address: Constant(4321), length: 16, lsda: None, instructions: [] }"
         );
     }
diff --git a/cranelift/codegen/src/isa/riscv64/inst/vector.rs b/cranelift/codegen/src/isa/riscv64/inst/vector.rs
index 6ab2016f1020..d1ed3703cb6d 100644
--- a/cranelift/codegen/src/isa/riscv64/inst/vector.rs
+++ b/cranelift/codegen/src/isa/riscv64/inst/vector.rs
@@ -1,11 +1,9 @@
-use crate::isa::riscv64::inst::AllocationConsumer;
-use crate::isa::riscv64::inst::EmitState;
 use crate::isa::riscv64::lower::isle::generated_code::VecAluOpRRRR;
 use crate::isa::riscv64::lower::isle::generated_code::{
     VecAMode, VecAluOpRImm5, VecAluOpRR, VecAluOpRRImm5, VecAluOpRRR, VecAluOpRRRImm5, VecAvl,
     VecElementWidth, VecLmul, VecMaskMode, VecOpCategory, VecOpMasking, VecTailMode,
 };
-use crate::machinst::RegClass;
+use crate::machinst::{OperandVisitor, RegClass};
 use crate::Reg;
 use core::fmt;
 
@@ -46,7 +44,7 @@ impl PartialEq for VecAvl {
 impl fmt::Display for VecAvl {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            VecAvl::Static { size } => write!(f, "{}", size),
+            VecAvl::Static { size } => write!(f, "{size}"),
         }
     }
 }
@@ -62,7 +60,7 @@ impl VecElementWidth {
             16 => VecElementWidth::E16,
             32 => VecElementWidth::E32,
             64 => VecElementWidth::E64,
-            _ => panic!("Invalid number of bits for VecElementWidth: {}", bits),
+            _ => panic!("Invalid number of bits for VecElementWidth: {bits}"),
         }
     }
 
@@ -250,15 +248,6 @@ impl VecOpMasking {
             VecOpMasking::Disabled => 1,
         }
     }
-
-    pub(crate) fn with_allocs(&self, allocs: &mut AllocationConsumer<'_>) -> Self {
-        match self {
-            VecOpMasking::Enabled { reg } => VecOpMasking::Enabled {
-                reg: allocs.next(*reg),
-            },
-            VecOpMasking::Disabled => VecOpMasking::Disabled,
-        }
-    }
 }
 
 impl VecAluOpRRRR {
@@ -279,13 +268,16 @@ impl VecAluOpRRRR {
             VecAluOpRRRR::VfnmaccVV | VecAluOpRRRR::VfnmaccVF => 0b101101,
             VecAluOpRRRR::VfmsacVV | VecAluOpRRRR::VfmsacVF => 0b101110,
             VecAluOpRRRR::VfnmsacVV | VecAluOpRRRR::VfnmsacVF => 0b101111,
+            VecAluOpRRRR::Vslide1upVX => 0b001110,
         }
     }
 
     pub fn category(&self) -> VecOpCategory {
         match self {
             VecAluOpRRRR::VmaccVV | VecAluOpRRRR::VnmsacVV => VecOpCategory::OPMVV,
-            VecAluOpRRRR::VmaccVX | VecAluOpRRRR::VnmsacVX => VecOpCategory::OPMVX,
+            VecAluOpRRRR::VmaccVX | VecAluOpRRRR::VnmsacVX | VecAluOpRRRR::Vslide1upVX => {
+                VecOpCategory::OPMVX
+            }
             VecAluOpRRRR::VfmaccVV
             | VecAluOpRRRR::VfnmaccVV
             | VecAluOpRRRR::VfmsacVV
@@ -310,7 +302,10 @@ impl VecAluOpRRRR {
 
 impl VecInstOverlapInfo for VecAluOpRRRR {
     fn forbids_src_dst_overlaps(&self) -> bool {
-        false
+        match self {
+            VecAluOpRRRR::Vslide1upVX => true,
+            _ => false,
+        }
     }
 }
 
@@ -1071,23 +1066,9 @@ impl VecAMode {
         }
     }
 
-    pub fn get_allocatable_register(&self) -> Option<Reg> {
-        match self {
-            VecAMode::UnitStride { base, .. } => base.get_allocatable_register(),
-        }
-    }
-
-    pub(crate) fn with_allocs(self, allocs: &mut AllocationConsumer<'_>) -> Self {
-        match self {
-            VecAMode::UnitStride { base } => VecAMode::UnitStride {
-                base: base.with_allocs(allocs),
-            },
-        }
-    }
-
-    pub(crate) fn get_offset_with_state(&self, state: &EmitState) -> i64 {
+    pub fn get_operands(&mut self, collector: &mut impl OperandVisitor) {
         match self {
-            VecAMode::UnitStride { base, .. } => base.get_offset_with_state(state),
+            VecAMode::UnitStride { base, .. } => base.get_operands(collector),
         }
     }
 
@@ -1137,12 +1118,12 @@ pub trait VecInstOverlapInfo {
     ///  * The destination EEW equals the source EEW.
     ///
     ///  * The destination EEW is smaller than the source EEW and the overlap is
-    ///  in the lowest-numbered part of the source register group (e.g., when LMUL=1,
-    ///  vnsrl.wi v0, v0, 3 is legal, but a destination of v1 is not).
+    ///    in the lowest-numbered part of the source register group (e.g., when LMUL=1,
+    ///    vnsrl.wi v0, v0, 3 is legal, but a destination of v1 is not).
     ///
     ///  * The destination EEW is greater than the source EEW, the source EMUL is at
-    ///  least 1, and the overlap is in the highest-numbered part of the destination register
-    ///  group (e.g., when LMUL=8, vzext.vf4 v0, v6 is legal, but a source of v0, v2, or v4 is not).
+    ///    least 1, and the overlap is in the highest-numbered part of the destination register
+    ///    group (e.g., when LMUL=8, vzext.vf4 v0, v6 is legal, but a source of v0, v2, or v4 is not).
     ///
     /// For the purpose of determining register group overlap constraints, mask elements have EEW=1.
     fn forbids_src_dst_overlaps(&self) -> bool;
diff --git a/cranelift/codegen/src/isa/riscv64/inst_vector.isle b/cranelift/codegen/src/isa/riscv64/inst_vector.isle
index 8c48ec991e19..e708e0aa57bc 100644
--- a/cranelift/codegen/src/isa/riscv64/inst_vector.isle
+++ b/cranelift/codegen/src/isa/riscv64/inst_vector.isle
@@ -229,6 +229,7 @@
   (VfnmaccVF)
   (VfmsacVF)
   (VfnmsacVF)
+  (Vslide1upVX)
 ))
 
 ;; Register-Imm ALU Ops
@@ -1017,7 +1018,7 @@
 (rule (rv_vfabs_v vs mask vstate) (rv_vfsgnjx_vv vs vs mask vstate))
 
 ;; Helper for emitting the `vfsqrt.v` instruction.
-;; This instruction splats the F regsiter into all elements of the destination vector.
+;; This instruction splats the F register into all elements of the destination vector.
 (decl rv_vfsqrt_v (VReg VecOpMasking VState) VReg)
 (rule (rv_vfsqrt_v vs mask vstate)
   (vec_alu_rr (VecAluOpRR.VfsqrtV) vs mask vstate))
@@ -1095,43 +1096,50 @@
 (rule (rv_vslideup_vvi vd vs2 imm mask vstate)
   (vec_alu_rrr_uimm5 (VecAluOpRRRImm5.VslideupVI) vd vs2 imm mask vstate))
 
+;; Helper for emitting the `vslide1up.vx` instruction.
+;;
+;; # vd[0]=x[rs1], vd[i+1] = vs2[i]
+(decl rv_vslide1up_vx (VReg VReg XReg VecOpMasking VState) VReg)
+(rule (rv_vslide1up_vx vd vs2 rs1 mask vstate)
+  (vec_alu_rrrr (VecAluOpRRRR.Vslide1upVX) vd vs2 rs1 mask vstate))
+
 ;; Helper for emitting the `vmv.x.s` instruction.
 ;; This instruction copies the first element of the source vector to the destination X register.
-;; Masked versions of this instuction are not supported.
+;; Masked versions of this instruction are not supported.
 (decl rv_vmv_xs (VReg VState) XReg)
 (rule (rv_vmv_xs vs vstate)
   (vec_alu_rr (VecAluOpRR.VmvXS) vs (unmasked) vstate))
 
 ;; Helper for emitting the `vfmv.f.s` instruction.
 ;; This instruction copies the first element of the source vector to the destination F register.
-;; Masked versions of this instuction are not supported.
+;; Masked versions of this instruction are not supported.
 (decl rv_vfmv_fs (VReg VState) FReg)
 (rule (rv_vfmv_fs vs vstate)
   (vec_alu_rr (VecAluOpRR.VfmvFS) vs (unmasked) vstate))
 
 ;; Helper for emitting the `vmv.s.x` instruction.
 ;; This instruction copies the source X register into first element of the source vector.
-;; Masked versions of this instuction are not supported.
+;; Masked versions of this instruction are not supported.
 (decl rv_vmv_sx (XReg VState) VReg)
 (rule (rv_vmv_sx vs vstate)
   (vec_alu_rr (VecAluOpRR.VmvSX) vs (unmasked) vstate))
 
 ;; Helper for emitting the `vfmv.s.f` instruction.
 ;; This instruction copies the source F register into first element of the source vector.
-;; Masked versions of this instuction are not supported.
+;; Masked versions of this instruction are not supported.
 (decl rv_vfmv_sf (FReg VState) VReg)
 (rule (rv_vfmv_sf vs vstate)
   (vec_alu_rr (VecAluOpRR.VfmvSF) vs (unmasked) vstate))
 
 ;; Helper for emitting the `vmv.v.x` instruction.
-;; This instruction splats the X regsiter into all elements of the destination vector.
+;; This instruction splats the X register into all elements of the destination vector.
 ;; Masked versions of this instruction are called `vmerge`
 (decl rv_vmv_vx (XReg VState) VReg)
 (rule (rv_vmv_vx vs vstate)
   (vec_alu_rr (VecAluOpRR.VmvVX) vs (unmasked) vstate))
 
 ;; Helper for emitting the `vfmv.v.f` instruction.
-;; This instruction splats the F regsiter into all elements of the destination vector.
+;; This instruction splats the F register into all elements of the destination vector.
 ;; Masked versions of this instruction are called `vmerge`
 (decl rv_vfmv_vf (FReg VState) VReg)
 (rule (rv_vfmv_vf vs vstate)
@@ -1579,10 +1587,10 @@
 (rule 0 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.Equal) x y)
   (rv_vmseq_vv x y (unmasked) ty))
 
-(rule 1 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.Equal) x (splat y))
+(rule 1 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.Equal) x (splat _ y))
   (rv_vmseq_vx x y (unmasked) ty))
 
-(rule 2 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.Equal) (splat x) y)
+(rule 2 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.Equal) (splat _ x) y)
   (rv_vmseq_vx y x (unmasked) ty))
 
 (rule 3 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.Equal) x y)
@@ -1598,10 +1606,10 @@
 (rule 0 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.NotEqual) x y)
   (rv_vmsne_vv x y (unmasked) ty))
 
-(rule 1 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.NotEqual) x (splat y))
+(rule 1 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.NotEqual) x (splat _ y))
   (rv_vmsne_vx x y (unmasked) ty))
 
-(rule 2 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.NotEqual) (splat x) y)
+(rule 2 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.NotEqual) (splat _ x) y)
   (rv_vmsne_vx y x (unmasked) ty))
 
 (rule 3 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.NotEqual) x y)
@@ -1617,10 +1625,10 @@
 (rule 0 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.UnsignedLessThan) x y)
   (rv_vmsltu_vv x y (unmasked) ty))
 
-(rule 1 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.UnsignedLessThan) x (splat y))
+(rule 1 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.UnsignedLessThan) x (splat _ y))
   (rv_vmsltu_vx x y (unmasked) ty))
 
-(rule 2 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.UnsignedLessThan) (splat x) y)
+(rule 2 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.UnsignedLessThan) (splat _ x) y)
   (rv_vmsgtu_vx y x (unmasked) ty))
 
 (rule 4 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.UnsignedLessThan) x y)
@@ -1632,10 +1640,10 @@
 (rule 0 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.SignedLessThan) x y)
   (rv_vmslt_vv x y (unmasked) ty))
 
-(rule 1 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.SignedLessThan) x (splat y))
+(rule 1 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.SignedLessThan) x (splat _ y))
   (rv_vmslt_vx x y (unmasked) ty))
 
-(rule 2 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.SignedLessThan) (splat x) y)
+(rule 2 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.SignedLessThan) (splat _ x) y)
   (rv_vmsgt_vx y x (unmasked) ty))
 
 (rule 4 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.SignedLessThan) x y)
@@ -1647,7 +1655,7 @@
 (rule 0 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.UnsignedLessThanOrEqual) x y)
   (rv_vmsleu_vv x y (unmasked) ty))
 
-(rule 1 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.UnsignedLessThanOrEqual) x (splat y))
+(rule 1 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.UnsignedLessThanOrEqual) x (splat _ y))
   (rv_vmsleu_vx x y (unmasked) ty))
 
 (rule 3 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.UnsignedLessThanOrEqual) x y)
@@ -1659,7 +1667,7 @@
 (rule 0 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.SignedLessThanOrEqual) x y)
   (rv_vmsle_vv x y (unmasked) ty))
 
-(rule 1 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.SignedLessThanOrEqual) x (splat y))
+(rule 1 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.SignedLessThanOrEqual) x (splat _ y))
   (rv_vmsle_vx x y (unmasked) ty))
 
 (rule 3 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.SignedLessThanOrEqual) x y)
@@ -1671,10 +1679,10 @@
 (rule 0 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.UnsignedGreaterThan) x y)
   (rv_vmsgtu_vv x y (unmasked) ty))
 
-(rule 1 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.UnsignedGreaterThan) x (splat y))
+(rule 1 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.UnsignedGreaterThan) x (splat _ y))
   (rv_vmsgtu_vx x y (unmasked) ty))
 
-(rule 2 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.UnsignedGreaterThan) (splat x) y)
+(rule 2 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.UnsignedGreaterThan) (splat _ x) y)
   (rv_vmsltu_vx y x (unmasked) ty))
 
 (rule 3 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.UnsignedGreaterThan) x y)
@@ -1686,10 +1694,10 @@
 (rule 0 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.SignedGreaterThan) x y)
   (rv_vmsgt_vv x y (unmasked) ty))
 
-(rule 1 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.SignedGreaterThan) x (splat y))
+(rule 1 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.SignedGreaterThan) x (splat _ y))
   (rv_vmsgt_vx x y (unmasked) ty))
 
-(rule 2 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.SignedGreaterThan) (splat x) y)
+(rule 2 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.SignedGreaterThan) (splat _ x) y)
   (rv_vmslt_vx y x (unmasked) ty))
 
 (rule 3 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.SignedGreaterThan) x y)
@@ -1701,7 +1709,7 @@
 (rule 0 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.UnsignedGreaterThanOrEqual) x y)
   (rv_vmsgeu_vv x y (unmasked) ty))
 
-(rule 2 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.UnsignedGreaterThanOrEqual) (splat x) y)
+(rule 2 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.UnsignedGreaterThanOrEqual) (splat _ x) y)
   (rv_vmsleu_vx y x (unmasked) ty))
 
 (rule 4 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.UnsignedGreaterThanOrEqual) x y)
@@ -1713,7 +1721,7 @@
 (rule 0 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.SignedGreaterThanOrEqual) x y)
   (rv_vmsge_vv x y (unmasked) ty))
 
-(rule 2 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.SignedGreaterThanOrEqual) (splat x) y)
+(rule 2 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.SignedGreaterThanOrEqual) (splat _ x) y)
   (rv_vmsle_vx y x (unmasked) ty))
 
 (rule 4 (gen_icmp_mask (ty_vec_fits_in_register ty) (IntCC.SignedGreaterThanOrEqual) x y)
@@ -1730,22 +1738,22 @@
 (rule 0 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.Equal) x y)
   (rv_vmfeq_vv x y (unmasked) ty))
 
-(rule 1 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.Equal) x (splat y))
+(rule 1 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.Equal) x (splat _ y))
   (rv_vmfeq_vf x y (unmasked) ty))
 
-(rule 2 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.Equal) (splat x) y)
+(rule 2 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.Equal) (splat _ x) y)
   (rv_vmfeq_vf y x (unmasked) ty))
 
 ;; FloatCC.NotEqual
-;; Note: This is UnorderedNotEqual. It is the only unoredered comparison that is not named as such.
+;; Note: This is UnorderedNotEqual. It is the only unordered comparison that is not named as such.
 
 (rule 0 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.NotEqual) x y)
   (rv_vmfne_vv x y (unmasked) ty))
 
-(rule 1 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.NotEqual) x (splat y))
+(rule 1 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.NotEqual) x (splat _ y))
   (rv_vmfne_vf x y (unmasked) ty))
 
-(rule 2 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.NotEqual) (splat x) y)
+(rule 2 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.NotEqual) (splat _ x) y)
   (rv_vmfne_vf y x (unmasked) ty))
 
 ;; FloatCC.LessThan
@@ -1753,10 +1761,10 @@
 (rule 0 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.LessThan) x y)
   (rv_vmflt_vv x y (unmasked) ty))
 
-(rule 1 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.LessThan) x (splat y))
+(rule 1 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.LessThan) x (splat _ y))
   (rv_vmflt_vf x y (unmasked) ty))
 
-(rule 2 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.LessThan) (splat x) y)
+(rule 2 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.LessThan) (splat _ x) y)
   (rv_vmfgt_vf y x (unmasked) ty))
 
 ;; FloatCC.LessThanOrEqual
@@ -1764,10 +1772,10 @@
 (rule 0 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.LessThanOrEqual) x y)
   (rv_vmfle_vv x y (unmasked) ty))
 
-(rule 1 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.LessThanOrEqual) x (splat y))
+(rule 1 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.LessThanOrEqual) x (splat _ y))
   (rv_vmfle_vf x y (unmasked) ty))
 
-(rule 2 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.LessThanOrEqual) (splat x) y)
+(rule 2 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.LessThanOrEqual) (splat _ x) y)
   (rv_vmfge_vf y x (unmasked) ty))
 
 ;; FloatCC.GreaterThan
@@ -1775,10 +1783,10 @@
 (rule 0 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.GreaterThan) x y)
   (rv_vmfgt_vv x y (unmasked) ty))
 
-(rule 1 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.GreaterThan) x (splat y))
+(rule 1 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.GreaterThan) x (splat _ y))
   (rv_vmfgt_vf x y (unmasked) ty))
 
-(rule 2 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.GreaterThan) (splat x) y)
+(rule 2 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.GreaterThan) (splat _ x) y)
   (rv_vmflt_vf y x (unmasked) ty))
 
 ;; FloatCC.GreaterThanOrEqual
@@ -1786,10 +1794,10 @@
 (rule 0 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.GreaterThanOrEqual) x y)
   (rv_vmfge_vv x y (unmasked) ty))
 
-(rule 1 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.GreaterThanOrEqual) x (splat y))
+(rule 1 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.GreaterThanOrEqual) x (splat _ y))
   (rv_vmfge_vf x y (unmasked) ty))
 
-(rule 2 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.GreaterThanOrEqual) (splat x) y)
+(rule 2 (gen_fcmp_mask (ty_vec_fits_in_register ty) (FloatCC.GreaterThanOrEqual) (splat _ x) y)
   (rv_vmfle_vf y x (unmasked) ty))
 
 ;; FloatCC.Ordered
@@ -1862,7 +1870,7 @@
     res))
 
 
-;; Retruns the maximum value integer value that can be represented by a float
+;; Returns the maximum value integer value that can be represented by a float
 (decl float_int_max (Type) u64)
 (rule (float_int_max $F32) 0x4B000000)
 (rule (float_int_max $F64) 0x4330000000000000)
diff --git a/cranelift/codegen/src/isa/riscv64/lower.isle b/cranelift/codegen/src/isa/riscv64/lower.isle
index 0c6fbf248e87..eeb685329ac0 100644
--- a/cranelift/codegen/src/isa/riscv64/lower.isle
+++ b/cranelift/codegen/src/isa/riscv64/lower.isle
@@ -6,50 +6,52 @@
 
 ;;;; Rules for `iconst` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type ty (iconst (u64_from_imm64 n))))
+(rule (lower (has_type ty (iconst _ (u64_from_imm64 n))))
   (imm ty n))
 
 ;; ;;;; Rules for `vconst` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type (ty_vec_fits_in_register ty) (vconst n)))
+(rule (lower (has_type (ty_supported_vec ty) (vconst _ n)))
   (gen_constant ty (const_to_vconst n)))
 
+;;;; Rules for `f16const` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(rule (lower (f16const _ (u16_from_ieee16 n)))
+  (imm $F16 n))
+
 ;;;; Rules for `f32const` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (f32const (u32_from_ieee32 n)))
+(rule (lower (f32const _ (u32_from_ieee32 n)))
   (imm $F32 n))
 
 ;;;; Rules for `f64const` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (f64const (u64_from_ieee64 n)))
+(rule (lower (f64const _ (u64_from_ieee64 n)))
   (imm $F64 n))
 
-;;;; Rules for `null` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(rule (lower (has_type ty (null)))
-  (imm ty 0))
-
-
 ;;;; Rules for `iadd` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Base case, simply adding things in registers.
-(rule 0 (lower (has_type (ty_int_ref_scalar_64 ty) (iadd x y)))
+(rule -1 (lower (has_type (fits_in_32 (ty_int ty)) (iadd _ x y)))
+  (rv_addw x y))
+
+(rule 0 (lower (has_type $I64 (iadd _ x y)))
   (rv_add x y))
 
 ;; Special cases for when one operand is an immediate that fits in 12 bits.
-(rule 1 (lower (has_type (ty_int_ref_scalar_64 ty) (iadd x (imm12_from_value y))))
+(rule 1 (lower (has_type (ty_int_ref_scalar_64 ty) (iadd _ x (imm12_from_value y))))
   (alu_rr_imm12 (select_addi ty) x y))
 
-(rule 2 (lower (has_type (ty_int_ref_scalar_64 ty) (iadd (imm12_from_value x) y)))
+(rule 2 (lower (has_type (ty_int_ref_scalar_64 ty) (iadd _ (imm12_from_value x) y)))
   (alu_rr_imm12 (select_addi ty) y x))
 
 ;; Special case when one of the operands is uextended
 ;; Needs `Zba`
-(rule 3 (lower (has_type $I64 (iadd x (uextend y @ (value_type $I32)))))
+(rule 3 (lower (has_type $I64 (iadd _ x (uextend _ y @ (value_type $I32)))))
   (if-let $true (has_zba))
   (rv_adduw y x))
 
-(rule 4 (lower (has_type $I64 (iadd (uextend x @ (value_type $I32)) y)))
+(rule 4 (lower (has_type $I64 (iadd _ (uextend _ x @ (value_type $I32)) y)))
   (if-let $true (has_zba))
   (rv_adduw x y))
 
@@ -59,12 +61,12 @@
 (rule (match_shnadd (u64_from_imm64 2)) (AluOPRRR.Sh2add))
 (rule (match_shnadd (u64_from_imm64 3)) (AluOPRRR.Sh3add))
 
-(rule 3 (lower (has_type $I64 (iadd x (ishl y (maybe_uextend (iconst n))))))
+(rule 3 (lower (has_type $I64 (iadd _ x (ishl _ y (maybe_uextend (iconst _ n))))))
   (if-let $true (has_zba))
   (if-let shnadd (match_shnadd n))
   (alu_rrr shnadd y x))
 
-(rule 4 (lower (has_type $I64 (iadd (ishl x (maybe_uextend (iconst n))) y)))
+(rule 4 (lower (has_type $I64 (iadd _ (ishl _ x (maybe_uextend (iconst _ n))) y)))
   (if-let $true (has_zba))
   (if-let shnadd (match_shnadd n))
   (alu_rrr shnadd x y))
@@ -75,24 +77,24 @@
 ;; !!! Important !!!
 ;; These rules only work for (ishl (uextend _) _) and not for (uextend (ishl _ _))!
 ;; Getting this wrong means a potential misscalculation of the shift amount.
-;; Additionaly we can only ensure that this is correct if the uextend is 32 to 64 bits.
+;; Additionally we can only ensure that this is correct if the uextend is 32 to 64 bits.
 (decl pure partial match_shnadd_uw (Imm64) AluOPRRR)
 (rule (match_shnadd_uw (u64_from_imm64 1)) (AluOPRRR.Sh1adduw))
 (rule (match_shnadd_uw (u64_from_imm64 2)) (AluOPRRR.Sh2adduw))
 (rule (match_shnadd_uw (u64_from_imm64 3)) (AluOPRRR.Sh3adduw))
 
-(rule 5 (lower (has_type $I64 (iadd x (ishl (uextend y @ (value_type $I32)) (maybe_uextend (iconst n))))))
+(rule 5 (lower (has_type $I64 (iadd _ x (ishl _ (uextend _ y @ (value_type $I32)) (maybe_uextend (iconst _ n))))))
   (if-let $true (has_zba))
   (if-let shnadd_uw (match_shnadd_uw n))
   (alu_rrr shnadd_uw y x))
 
-(rule 6 (lower (has_type $I64 (iadd (ishl (uextend x @ (value_type $I32)) (maybe_uextend (iconst n))) y)))
+(rule 6 (lower (has_type $I64 (iadd _ (ishl _ (uextend _ x @ (value_type $I32)) (maybe_uextend (iconst _ n))) y)))
   (if-let $true (has_zba))
   (if-let shnadd_uw (match_shnadd_uw n))
   (alu_rrr shnadd_uw x y))
 
 ;; I128 cases
-(rule 7 (lower (has_type $I128 (iadd x y)))
+(rule 7 (lower (has_type $I128 (iadd _ x y)))
   (let ((low XReg (rv_add (value_regs_get x 0) (value_regs_get y 0)))
         ;; compute carry.
         (carry XReg (rv_sltu low (value_regs_get y 0)))
@@ -103,152 +105,152 @@
     (value_regs low high)))
 
 ;; SIMD Vectors
-(rule 8 (lower (has_type (ty_vec_fits_in_register ty) (iadd x y)))
+(rule 8 (lower (has_type (ty_supported_vec ty) (iadd _ x y)))
   (rv_vadd_vv x y (unmasked) ty))
 
-(rule 9 (lower (has_type (ty_vec_fits_in_register ty) (iadd x (splat y))))
+(rule 9 (lower (has_type (ty_supported_vec ty) (iadd _ x (splat _ y))))
   (rv_vadd_vx x y (unmasked) ty))
 
-(rule 10 (lower (has_type (ty_vec_fits_in_register ty) (iadd x (splat (sextend y @ (value_type sext_ty))))))
+(rule 10 (lower (has_type (ty_supported_vec ty) (iadd _ x (splat _ (sextend _ y @ (value_type sext_ty))))))
   (if-let half_ty (ty_half_width ty))
   (if-let $true (ty_equal (lane_type half_ty) sext_ty))
   (rv_vwadd_wx x y (unmasked) (vstate_mf2 half_ty)))
 
-(rule 10 (lower (has_type (ty_vec_fits_in_register ty) (iadd x (splat (uextend y @ (value_type uext_ty))))))
+(rule 10 (lower (has_type (ty_supported_vec ty) (iadd _ x (splat _ (uextend _ y @ (value_type uext_ty))))))
   (if-let half_ty (ty_half_width ty))
   (if-let $true (ty_equal (lane_type half_ty) uext_ty))
   (rv_vwaddu_wx x y (unmasked) (vstate_mf2 half_ty)))
 
-(rule 20 (lower (has_type (ty_vec_fits_in_register ty) (iadd x y)))
+(rule 20 (lower (has_type (ty_supported_vec ty) (iadd _ x y)))
   (if-let y_imm (replicated_imm5 y))
   (rv_vadd_vi x y_imm (unmasked) ty))
 
 
-(rule 12 (lower (has_type (ty_vec_fits_in_register ty) (iadd (splat x) y)))
+(rule 12 (lower (has_type (ty_supported_vec ty) (iadd _ (splat _ x) y)))
   (rv_vadd_vx y x (unmasked) ty))
 
-(rule 13 (lower (has_type (ty_vec_fits_in_register ty) (iadd (splat (sextend x @ (value_type sext_ty))) y)))
+(rule 13 (lower (has_type (ty_supported_vec ty) (iadd _ (splat _ (sextend _ x @ (value_type sext_ty))) y)))
   (if-let half_ty (ty_half_width ty))
   (if-let $true (ty_equal (lane_type half_ty) sext_ty))
   (rv_vwadd_wx y x (unmasked) (vstate_mf2 half_ty)))
 
-(rule 13 (lower (has_type (ty_vec_fits_in_register ty) (iadd (splat (uextend x @ (value_type uext_ty))) y)))
+(rule 13 (lower (has_type (ty_supported_vec ty) (iadd _ (splat _ (uextend _ x @ (value_type uext_ty))) y)))
   (if-let half_ty (ty_half_width ty))
   (if-let $true (ty_equal (lane_type half_ty) uext_ty))
   (rv_vwaddu_wx y x (unmasked) (vstate_mf2 half_ty)))
 
-(rule 21 (lower (has_type (ty_vec_fits_in_register ty) (iadd x y)))
+(rule 21 (lower (has_type (ty_supported_vec ty) (iadd _ x y)))
   (if-let x_imm (replicated_imm5 x))
   (rv_vadd_vi y x_imm (unmasked) ty))
 
 ;; Signed Widening Low Additions
 
-(rule 9 (lower (has_type (ty_vec_fits_in_register _) (iadd x (swiden_low y @ (value_type in_ty)))))
+(rule 9 (lower (has_type (ty_supported_vec _) (iadd _ x (swiden_low _ y @ (value_type in_ty)))))
   (rv_vwadd_wv x y (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
-(rule 12 (lower (has_type (ty_vec_fits_in_register _) (iadd (swiden_low x @ (value_type in_ty)) y)))
+(rule 12 (lower (has_type (ty_supported_vec _) (iadd _ (swiden_low _ x @ (value_type in_ty)) y)))
   (rv_vwadd_wv y x (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
-(rule 13 (lower (has_type (ty_vec_fits_in_register _) (iadd (swiden_low x @ (value_type in_ty))
-                                                            (swiden_low y))))
+(rule 13 (lower (has_type (ty_supported_vec _) (iadd _ (swiden_low _ x @ (value_type in_ty))
+                                                            (swiden_low _ y))))
   (rv_vwadd_vv x y (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
-(rule 13 (lower (has_type (ty_vec_fits_in_register _) (iadd (swiden_low x @ (value_type in_ty))
-                                                            (splat (sextend y @ (value_type sext_ty))))))
+(rule 13 (lower (has_type (ty_supported_vec _) (iadd _ (swiden_low _ x @ (value_type in_ty))
+                                                            (splat _ (sextend _ y @ (value_type sext_ty))))))
   (if-let $true (ty_equal (lane_type in_ty) sext_ty))
   (rv_vwadd_vx x y (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
-(rule 15 (lower (has_type (ty_vec_fits_in_register _) (iadd (splat (sextend x @ (value_type sext_ty)))
-                                                            (swiden_low y @ (value_type in_ty)))))
+(rule 15 (lower (has_type (ty_supported_vec _) (iadd _ (splat _ (sextend _ x @ (value_type sext_ty)))
+                                                            (swiden_low _ y @ (value_type in_ty)))))
   (if-let $true (ty_equal (lane_type in_ty) sext_ty))
   (rv_vwadd_vx y x (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
 ;; Signed Widening High Additions
 ;; These are the same as the low additions, but we first slide down the inputs.
 
-(rule 9 (lower (has_type (ty_vec_fits_in_register _) (iadd x (swiden_high y @ (value_type in_ty)))))
+(rule 9 (lower (has_type (ty_supported_vec _) (iadd _ x (swiden_high _ y @ (value_type in_ty)))))
   (rv_vwadd_wv x (gen_slidedown_half in_ty y) (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
-(rule 12 (lower (has_type (ty_vec_fits_in_register _) (iadd (swiden_high x @ (value_type in_ty)) y)))
+(rule 12 (lower (has_type (ty_supported_vec _) (iadd _ (swiden_high _ x @ (value_type in_ty)) y)))
   (rv_vwadd_wv y (gen_slidedown_half in_ty x) (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
-(rule 13 (lower (has_type (ty_vec_fits_in_register _) (iadd (swiden_high x @ (value_type in_ty))
-                                                            (swiden_high y))))
+(rule 13 (lower (has_type (ty_supported_vec _) (iadd _ (swiden_high _ x @ (value_type in_ty))
+                                                            (swiden_high _ y))))
   (rv_vwadd_vv (gen_slidedown_half in_ty x) (gen_slidedown_half in_ty y) (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
-(rule 13 (lower (has_type (ty_vec_fits_in_register _) (iadd (swiden_high x @ (value_type in_ty))
-                                                            (splat (sextend y @ (value_type sext_ty))))))
+(rule 13 (lower (has_type (ty_supported_vec _) (iadd _ (swiden_high _ x @ (value_type in_ty))
+                                                            (splat _ (sextend _ y @ (value_type sext_ty))))))
   (if-let $true (ty_equal (lane_type in_ty) sext_ty))
   (rv_vwadd_vx (gen_slidedown_half in_ty x) y (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
-(rule 15 (lower (has_type (ty_vec_fits_in_register _) (iadd (splat (sextend x @ (value_type sext_ty)))
-                                                            (swiden_high y @ (value_type in_ty)))))
+(rule 15 (lower (has_type (ty_supported_vec _) (iadd _ (splat _ (sextend _ x @ (value_type sext_ty)))
+                                                            (swiden_high _ y @ (value_type in_ty)))))
   (if-let $true (ty_equal (lane_type in_ty) sext_ty))
   (rv_vwadd_vx (gen_slidedown_half in_ty y) x (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
 ;; Unsigned Widening Low Additions
 
-(rule 9 (lower (has_type (ty_vec_fits_in_register _) (iadd x (uwiden_low y @ (value_type in_ty)))))
+(rule 9 (lower (has_type (ty_supported_vec _) (iadd _ x (uwiden_low _ y @ (value_type in_ty)))))
   (rv_vwaddu_wv x y (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
-(rule 12 (lower (has_type (ty_vec_fits_in_register _) (iadd (uwiden_low x @ (value_type in_ty)) y)))
+(rule 12 (lower (has_type (ty_supported_vec _) (iadd _ (uwiden_low _ x @ (value_type in_ty)) y)))
   (rv_vwaddu_wv y x (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
-(rule 13 (lower (has_type (ty_vec_fits_in_register _) (iadd (uwiden_low x @ (value_type in_ty))
-                                                            (uwiden_low y))))
+(rule 13 (lower (has_type (ty_supported_vec _) (iadd _ (uwiden_low _ x @ (value_type in_ty))
+                                                            (uwiden_low _ y))))
   (rv_vwaddu_vv x y (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
-(rule 13 (lower (has_type (ty_vec_fits_in_register _) (iadd (uwiden_low x @ (value_type in_ty))
-                                                            (splat (uextend y @ (value_type uext_ty))))))
+(rule 13 (lower (has_type (ty_supported_vec _) (iadd _ (uwiden_low _ x @ (value_type in_ty))
+                                                            (splat _ (uextend _ y @ (value_type uext_ty))))))
   (if-let $true (ty_equal (lane_type in_ty) uext_ty))
   (rv_vwaddu_vx x y (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
-(rule 15 (lower (has_type (ty_vec_fits_in_register _) (iadd (splat (uextend x @ (value_type uext_ty)))
-                                                            (uwiden_low y @ (value_type in_ty)))))
+(rule 15 (lower (has_type (ty_supported_vec _) (iadd _ (splat _ (uextend _ x @ (value_type uext_ty)))
+                                                            (uwiden_low _ y @ (value_type in_ty)))))
   (if-let $true (ty_equal (lane_type in_ty) uext_ty))
   (rv_vwaddu_vx y x (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
 ;; Unsigned Widening High Additions
 ;; These are the same as the low additions, but we first slide down the inputs.
 
-(rule 9 (lower (has_type (ty_vec_fits_in_register _) (iadd x (uwiden_high y @ (value_type in_ty)))))
+(rule 9 (lower (has_type (ty_supported_vec _) (iadd _ x (uwiden_high _ y @ (value_type in_ty)))))
   (rv_vwaddu_wv x (gen_slidedown_half in_ty y) (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
-(rule 12 (lower (has_type (ty_vec_fits_in_register _) (iadd (uwiden_high x @ (value_type in_ty)) y)))
+(rule 12 (lower (has_type (ty_supported_vec _) (iadd _ (uwiden_high _ x @ (value_type in_ty)) y)))
   (rv_vwaddu_wv y (gen_slidedown_half in_ty x) (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
-(rule 13 (lower (has_type (ty_vec_fits_in_register _) (iadd (uwiden_high x @ (value_type in_ty))
-                                                            (uwiden_high y))))
+(rule 13 (lower (has_type (ty_supported_vec _) (iadd _ (uwiden_high _ x @ (value_type in_ty))
+                                                            (uwiden_high _ y))))
   (rv_vwaddu_vv (gen_slidedown_half in_ty x) (gen_slidedown_half in_ty y) (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
-(rule 13 (lower (has_type (ty_vec_fits_in_register _) (iadd (uwiden_high x @ (value_type in_ty))
-                                                            (splat (uextend y @ (value_type uext_ty))))))
+(rule 13 (lower (has_type (ty_supported_vec _) (iadd _ (uwiden_high _ x @ (value_type in_ty))
+                                                            (splat _ (uextend _ y @ (value_type uext_ty))))))
   (if-let $true (ty_equal (lane_type in_ty) uext_ty))
   (rv_vwaddu_vx (gen_slidedown_half in_ty x) y (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
-(rule 15 (lower (has_type (ty_vec_fits_in_register _) (iadd (splat (uextend y @ (value_type uext_ty)))
-                                                            (uwiden_high x @ (value_type in_ty)))))
+(rule 15 (lower (has_type (ty_supported_vec _) (iadd _ (splat _ (uextend _ y @ (value_type uext_ty)))
+                                                            (uwiden_high _ x @ (value_type in_ty)))))
   (if-let $true (ty_equal (lane_type in_ty) uext_ty))
   (rv_vwaddu_vx (gen_slidedown_half in_ty x) y (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
 ;; Signed Widening Mixed High/Low Additions
 
-(rule 13 (lower (has_type (ty_vec_fits_in_register _) (iadd (swiden_low x @ (value_type in_ty))
-                                                            (swiden_high y))))
+(rule 13 (lower (has_type (ty_supported_vec _) (iadd _ (swiden_low _ x @ (value_type in_ty))
+                                                            (swiden_high _ y))))
   (rv_vwadd_vv x (gen_slidedown_half in_ty y) (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
-(rule 13 (lower (has_type (ty_vec_fits_in_register _) (iadd (swiden_high x @ (value_type in_ty))
-                                                            (swiden_low y))))
+(rule 13 (lower (has_type (ty_supported_vec _) (iadd _ (swiden_high _ x @ (value_type in_ty))
+                                                            (swiden_low _ y))))
   (rv_vwadd_vv (gen_slidedown_half in_ty x) y (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
 ;; Unsigned Widening Mixed High/Low Additions
 
-(rule 13 (lower (has_type (ty_vec_fits_in_register _) (iadd (uwiden_low x @ (value_type in_ty))
-                                                            (uwiden_high y))))
+(rule 13 (lower (has_type (ty_supported_vec _) (iadd _ (uwiden_low _ x @ (value_type in_ty))
+                                                            (uwiden_high _ y))))
   (rv_vwaddu_vv x (gen_slidedown_half in_ty y) (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
-(rule 13 (lower (has_type (ty_vec_fits_in_register _) (iadd (uwiden_high x @ (value_type in_ty))
-                                                            (uwiden_low y))))
+(rule 13 (lower (has_type (ty_supported_vec _) (iadd _ (uwiden_high _ x @ (value_type in_ty))
+                                                            (uwiden_low _ y))))
   (rv_vwaddu_vv (gen_slidedown_half in_ty x) y (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
 ;; Fused Multiply Accumulate Rules `vmacc`
@@ -257,46 +259,46 @@
 ;; register instead of the addition one. The actual pattern matched seems to be
 ;; exactly the same.
 
-(rule 9 (lower (has_type (ty_vec_fits_in_register ty) (iadd x (imul y z))))
+(rule 9 (lower (has_type (ty_supported_vec ty) (iadd _ x (imul _ y z))))
   (rv_vmacc_vv x y z (unmasked) ty))
 
-(rule 10 (lower (has_type (ty_vec_fits_in_register ty) (iadd x (imul y (splat z)))))
+(rule 10 (lower (has_type (ty_supported_vec ty) (iadd _ x (imul _ y (splat _ z)))))
   (rv_vmacc_vx x y z (unmasked) ty))
 
-(rule 11 (lower (has_type (ty_vec_fits_in_register ty) (iadd x (imul (splat y) z))))
+(rule 11 (lower (has_type (ty_supported_vec ty) (iadd _ x (imul _ (splat _ y) z))))
   (rv_vmacc_vx x z y (unmasked) ty))
 
-(rule 12 (lower (has_type (ty_vec_fits_in_register ty) (iadd (imul x y) z)))
+(rule 12 (lower (has_type (ty_supported_vec ty) (iadd _ (imul _ x y) z)))
   (rv_vmacc_vv z x y (unmasked) ty))
 
-(rule 13 (lower (has_type (ty_vec_fits_in_register ty) (iadd (imul x (splat y)) z)))
+(rule 13 (lower (has_type (ty_supported_vec ty) (iadd _ (imul _ x (splat _ y)) z)))
   (rv_vmacc_vx z x y (unmasked) ty))
 
-(rule 14 (lower (has_type (ty_vec_fits_in_register ty) (iadd (imul (splat x) y) z)))
+(rule 14 (lower (has_type (ty_supported_vec ty) (iadd _ (imul _ (splat _ x) y) z)))
   (rv_vmacc_vx z y x (unmasked) ty))
 
 ;; Fused Multiply Subtract Rules `vnmsac`
 
-(rule 9 (lower (has_type (ty_vec_fits_in_register ty) (iadd x (ineg (imul y z)))))
+(rule 9 (lower (has_type (ty_supported_vec ty) (iadd _ x (ineg _ (imul _ y z)))))
   (rv_vnmsac_vv x y z (unmasked) ty))
 
-(rule 10 (lower (has_type (ty_vec_fits_in_register ty) (iadd x (ineg (imul y (splat z))))))
+(rule 10 (lower (has_type (ty_supported_vec ty) (iadd _ x (ineg _ (imul _ y (splat _ z))))))
   (rv_vnmsac_vx x y z (unmasked) ty))
 
-(rule 11 (lower (has_type (ty_vec_fits_in_register ty) (iadd x (ineg (imul (splat y) z)))))
+(rule 11 (lower (has_type (ty_supported_vec ty) (iadd _ x (ineg _ (imul _ (splat _ y) z)))))
   (rv_vnmsac_vx x z y (unmasked) ty))
 
-(rule 12 (lower (has_type (ty_vec_fits_in_register ty) (iadd (ineg (imul x y)) z)))
+(rule 12 (lower (has_type (ty_supported_vec ty) (iadd _ (ineg _ (imul _ x y)) z)))
   (rv_vnmsac_vv z x y (unmasked) ty))
 
-(rule 13 (lower (has_type (ty_vec_fits_in_register ty) (iadd (ineg (imul x (splat y))) z)))
+(rule 13 (lower (has_type (ty_supported_vec ty) (iadd _ (ineg _ (imul _ x (splat _ y))) z)))
   (rv_vnmsac_vx z x y (unmasked) ty))
 
-(rule 14 (lower (has_type (ty_vec_fits_in_register ty) (iadd (ineg (imul (splat x) y)) z)))
+(rule 14 (lower (has_type (ty_supported_vec ty) (iadd _ (ineg _ (imul _ (splat _ x) y)) z)))
   (rv_vnmsac_vx z y x (unmasked) ty))
 
 ;;; Rules for `uadd_overflow_trap` ;;;;;;;;;;;;;
-(rule 0 (lower (has_type (fits_in_32 ty) (uadd_overflow_trap x y tc)))
+(rule 0 (lower (has_type (fits_in_32 ty) (uadd_overflow_trap _ x y tc)))
   (let ((tmp_x XReg (zext x))
         (tmp_y XReg (zext y))
         (sum XReg (rv_add tmp_x tmp_y))
@@ -304,7 +306,7 @@
         (_ InstOutput (gen_trapnz test tc)))
     sum))
 
-(rule 1 (lower (has_type $I64 (uadd_overflow_trap x y tc)))
+(rule 1 (lower (has_type $I64 (uadd_overflow_trap _ x y tc)))
   (let ((tmp XReg (rv_add x y))
         (_ InstOutput (gen_trapif (IntCC.UnsignedLessThan) tmp x tc)))
     tmp))
@@ -312,138 +314,147 @@
 ;;;; Rules for `isub` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Base case, simply subtracting things in registers.
 
-(rule (lower (has_type (ty_int_ref_scalar_64 ty) (isub x y)))
-  (rv_sub x y))
-
-(rule 1 (lower (has_type (fits_in_32 (ty_int ty)) (isub x y)))
+(rule 0 (lower (has_type (fits_in_32 (ty_int ty)) (isub _ x y)))
   (rv_subw x y))
 
-(rule 2 (lower (has_type $I128 (isub x y)))
+(rule 1 (lower (has_type $I64 (isub _ x y)))
+  (rv_sub x y))
+
+(rule 2 (lower (has_type $I128 (isub _ x y)))
   (i128_sub x y))
 
+;; Switch to an `addi` by a negative if we can fit the value in an `imm12`.
+(rule 3 (lower (has_type (ty_int_ref_scalar_64 ty) (isub _ x y)))
+  (if-let imm12_neg (imm12_from_negated_value y))
+  (alu_rr_imm12 (select_addi ty) x imm12_neg))
+
 ;; SIMD Vectors
-(rule 3 (lower (has_type (ty_vec_fits_in_register ty) (isub x y)))
+(rule 4 (lower (has_type (ty_supported_vec ty) (isub _ x y)))
   (rv_vsub_vv x y (unmasked) ty))
 
-(rule 4 (lower (has_type (ty_vec_fits_in_register ty) (isub x (splat y))))
+(rule 5 (lower (has_type (ty_supported_vec ty) (isub _ x (splat _ y))))
   (rv_vsub_vx x y (unmasked) ty))
 
-(rule 5 (lower (has_type (ty_vec_fits_in_register ty) (isub x (splat (sextend y @ (value_type sext_ty))))))
+(rule 6 (lower (has_type (ty_supported_vec ty) (isub _ x (splat _ (sextend _ y @ (value_type sext_ty))))))
   (if-let half_ty (ty_half_width ty))
   (if-let $true (ty_equal (lane_type half_ty) sext_ty))
   (rv_vwsub_wx x y (unmasked) (vstate_mf2 half_ty)))
 
-(rule 5 (lower (has_type (ty_vec_fits_in_register ty) (isub x (splat (uextend y @ (value_type uext_ty))))))
+(rule 6 (lower (has_type (ty_supported_vec ty) (isub _ x (splat _ (uextend _ y @ (value_type uext_ty))))))
   (if-let half_ty (ty_half_width ty))
   (if-let $true (ty_equal (lane_type half_ty) uext_ty))
   (rv_vwsubu_wx x y (unmasked) (vstate_mf2 half_ty)))
 
-(rule 6 (lower (has_type (ty_vec_fits_in_register ty) (isub (splat x) y)))
+(rule 7 (lower (has_type (ty_supported_vec ty) (isub _ (splat _ x) y)))
   (rv_vrsub_vx y x (unmasked) ty))
 
-(rule 7 (lower (has_type (ty_vec_fits_in_register ty) (isub x y)))
+(rule 8 (lower (has_type (ty_supported_vec ty) (isub _ x y)))
+  (if-let imm5_neg (negated_replicated_imm5 y))
+  (rv_vadd_vi x imm5_neg (unmasked) ty))
+
+(rule 9 (lower (has_type (ty_supported_vec ty) (isub _ x y)))
   (if-let x_imm (replicated_imm5 x))
   (rv_vrsub_vi y x_imm (unmasked) ty))
 
 
 ;; Signed Widening Low Subtractions
 
-(rule 5 (lower (has_type (ty_vec_fits_in_register _) (isub x (swiden_low y @ (value_type in_ty)))))
+(rule 6 (lower (has_type (ty_supported_vec _) (isub _ x (swiden_low _ y @ (value_type in_ty)))))
   (rv_vwsub_wv x y (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
-(rule 8 (lower (has_type (ty_vec_fits_in_register _) (isub (swiden_low x @ (value_type in_ty))
-                                                           (swiden_low y))))
+(rule 10 (lower (has_type (ty_supported_vec _) (isub _ (swiden_low _ x @ (value_type in_ty))
+                                                           (swiden_low _ y))))
   (rv_vwsub_vv x y (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
-(rule 8 (lower (has_type (ty_vec_fits_in_register _) (isub (swiden_low x @ (value_type in_ty))
-                                                           (splat (sextend y @ (value_type sext_ty))))))
+(rule 10 (lower (has_type (ty_supported_vec _) (isub _ (swiden_low _ x @ (value_type in_ty))
+                                                           (splat _ (sextend _ y @ (value_type sext_ty))))))
   (if-let $true (ty_equal (lane_type in_ty) sext_ty))
   (rv_vwsub_vx x y (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
 ;; Signed Widening High Subtractions
 ;; These are the same as the low widenings, but we first slide down the inputs.
 
-(rule 5 (lower (has_type (ty_vec_fits_in_register _) (isub x (swiden_high y @ (value_type in_ty)))))
+(rule 6 (lower (has_type (ty_supported_vec _) (isub _ x (swiden_high _ y @ (value_type in_ty)))))
   (rv_vwsub_wv x (gen_slidedown_half in_ty y) (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
-(rule 8 (lower (has_type (ty_vec_fits_in_register _) (isub (swiden_high x @ (value_type in_ty))
-                                                           (swiden_high y))))
+(rule 10 (lower (has_type (ty_supported_vec _) (isub _ (swiden_high _ x @ (value_type in_ty))
+                                                           (swiden_high _ y))))
   (rv_vwsub_vv (gen_slidedown_half in_ty x) (gen_slidedown_half in_ty y) (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
-(rule 8 (lower (has_type (ty_vec_fits_in_register _) (isub (swiden_high x @ (value_type in_ty))
-                                                           (splat (sextend y @ (value_type sext_ty))))))
+(rule 10 (lower (has_type (ty_supported_vec _) (isub _ (swiden_high _ x @ (value_type in_ty))
+                                                           (splat _ (sextend _ y @ (value_type sext_ty))))))
   (if-let $true (ty_equal (lane_type in_ty) sext_ty))
   (rv_vwsub_vx (gen_slidedown_half in_ty x) y (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
 ;; Unsigned Widening Low Subtractions
 
-(rule 5 (lower (has_type (ty_vec_fits_in_register _) (isub x (uwiden_low y @ (value_type in_ty)))))
+(rule 6 (lower (has_type (ty_supported_vec _) (isub _ x (uwiden_low _ y @ (value_type in_ty)))))
   (rv_vwsubu_wv x y (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
-(rule 8 (lower (has_type (ty_vec_fits_in_register _) (isub (uwiden_low x @ (value_type in_ty))
-                                                           (uwiden_low y))))
+(rule 10 (lower (has_type (ty_supported_vec _) (isub _ (uwiden_low _ x @ (value_type in_ty))
+                                                           (uwiden_low _ y))))
   (rv_vwsubu_vv x y (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
-(rule 8 (lower (has_type (ty_vec_fits_in_register _) (isub (uwiden_low x @ (value_type in_ty))
-                                                           (splat (uextend y @ (value_type uext_ty))))))
+(rule 10 (lower (has_type (ty_supported_vec _) (isub _ (uwiden_low _ x @ (value_type in_ty))
+                                                           (splat _ (uextend _ y @ (value_type uext_ty))))))
   (if-let $true (ty_equal (lane_type in_ty) uext_ty))
   (rv_vwsubu_vx x y (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
 ;; Unsigned Widening High Subtractions
 ;; These are the same as the low widenings, but we first slide down the inputs.
 
-(rule 5 (lower (has_type (ty_vec_fits_in_register _) (isub x (uwiden_high y @ (value_type in_ty)))))
+(rule 6 (lower (has_type (ty_supported_vec _) (isub _ x (uwiden_high _ y @ (value_type in_ty)))))
   (rv_vwsubu_wv x (gen_slidedown_half in_ty y) (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
-(rule 8 (lower (has_type (ty_vec_fits_in_register _) (isub (uwiden_high x @ (value_type in_ty))
-                                                           (uwiden_high y))))
+(rule 10 (lower (has_type (ty_supported_vec _) (isub _ (uwiden_high _ x @ (value_type in_ty))
+                                                           (uwiden_high _ y))))
   (rv_vwsubu_vv (gen_slidedown_half in_ty x) (gen_slidedown_half in_ty y) (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
-(rule 8 (lower (has_type (ty_vec_fits_in_register _) (isub (uwiden_high x @ (value_type in_ty))
-                                                           (splat (uextend y @ (value_type uext_ty))))))
+(rule 10 (lower (has_type (ty_supported_vec _) (isub _ (uwiden_high _ x @ (value_type in_ty))
+                                                           (splat _ (uextend _ y @ (value_type uext_ty))))))
   (if-let $true (ty_equal (lane_type in_ty) uext_ty))
   (rv_vwsubu_vx (gen_slidedown_half in_ty x) y (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
 ;; Signed Widening Mixed High/Low Subtractions
 
-(rule 8 (lower (has_type (ty_vec_fits_in_register _) (isub (swiden_low x @ (value_type in_ty))
-                                                           (swiden_high y))))
+(rule 10 (lower (has_type (ty_supported_vec _) (isub _ (swiden_low _ x @ (value_type in_ty))
+                                                           (swiden_high _ y))))
   (rv_vwsub_vv x (gen_slidedown_half in_ty y) (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
-(rule 8 (lower (has_type (ty_vec_fits_in_register _) (isub (swiden_high x @ (value_type in_ty))
-                                                           (swiden_low y))))
+(rule 10 (lower (has_type (ty_supported_vec _) (isub _ (swiden_high _ x @ (value_type in_ty))
+                                                           (swiden_low _ y))))
   (rv_vwsub_vv (gen_slidedown_half in_ty x) y (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
 ;; Unsigned Widening Mixed High/Low Subtractions
 
-(rule 8 (lower (has_type (ty_vec_fits_in_register _) (isub (uwiden_low x @ (value_type in_ty))
-                                                           (uwiden_high y))))
+(rule 10 (lower (has_type (ty_supported_vec _) (isub _ (uwiden_low _ x @ (value_type in_ty))
+                                                           (uwiden_high _ y))))
   (rv_vwsubu_vv x (gen_slidedown_half in_ty y) (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
-(rule 8 (lower (has_type (ty_vec_fits_in_register _) (isub (uwiden_high x @ (value_type in_ty))
-                                                           (uwiden_low y))))
+(rule 10 (lower (has_type (ty_supported_vec _) (isub _ (uwiden_high _ x @ (value_type in_ty))
+                                                           (uwiden_low _ y))))
   (rv_vwsubu_vv (gen_slidedown_half in_ty x) y (unmasked) (vstate_mf2 (ty_half_lanes in_ty))))
 
 
 ;;;; Rules for `ineg` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type (ty_int ty) (ineg val)))
+(rule (lower (has_type (ty_int ty) (ineg _ val)))
   (neg ty val))
 
-(rule 1 (lower (has_type (ty_vec_fits_in_register ty) (ineg x)))
+(rule 1 (lower (has_type (ty_supported_vec ty) (ineg _ x)))
   (rv_vneg_v x (unmasked) ty))
 
 
 ;;;; Rules for `imul` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 0 (lower (has_type (ty_int_ref_scalar_64 ty) (imul x y)))
+(rule 0 (lower (has_type (ty_int_ref_scalar_64 ty) (imul _ x y)))
   (rv_mul x y))
 
-(rule 1 (lower (has_type (fits_in_32 (ty_int ty)) (imul x y)))
+(rule 1 (lower (has_type (fits_in_32 (ty_int ty)) (imul _ x y)))
   (rv_mulw x y))
 
 ;; for I128
-(rule 2 (lower (has_type $I128 (imul x y)))
+(rule 2 (lower (has_type $I128 (imul _ x y)))
   (let
     ((x_regs ValueRegs x)
       (x_lo XReg (value_regs_get x_regs 0))
@@ -469,70 +480,70 @@
       (dst_lo XReg (madd x_lo y_lo (zero_reg))))
     (value_regs dst_lo dst_hi)))
 
-(rule 3 (lower (has_type (ty_vec_fits_in_register ty) (imul x y)))
+(rule 3 (lower (has_type (ty_supported_vec ty) (imul _ x y)))
   (rv_vmul_vv x y (unmasked) ty))
 
-(rule 4 (lower (has_type (ty_vec_fits_in_register ty) (imul (splat x) y)))
+(rule 4 (lower (has_type (ty_supported_vec ty) (imul _ (splat _ x) y)))
   (rv_vmul_vx y x (unmasked) ty))
 
-(rule 5 (lower (has_type (ty_vec_fits_in_register ty) (imul x (splat y))))
+(rule 5 (lower (has_type (ty_supported_vec ty) (imul _ x (splat _ y))))
   (rv_vmul_vx x y (unmasked) ty))
 
 ;;;; Rules for `smulhi` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule 0 (lower (has_type (ty_int_ref_scalar_64 ty) (smulhi x y)))
+(rule 0 (lower (has_type (ty_int_ref_scalar_64 ty) (smulhi _ x y)))
   (lower_smlhi ty (sext x) (sext y)))
 
-(rule 1 (lower (has_type (ty_vec_fits_in_register ty) (smulhi x y)))
+(rule 1 (lower (has_type (ty_supported_vec ty) (smulhi _ x y)))
   (rv_vmulh_vv x y (unmasked) ty))
 
-(rule 2 (lower (has_type (ty_vec_fits_in_register ty) (smulhi (splat x) y)))
+(rule 2 (lower (has_type (ty_supported_vec ty) (smulhi _ (splat _ x) y)))
   (rv_vmulh_vx y x (unmasked) ty))
 
-(rule 3 (lower (has_type (ty_vec_fits_in_register ty) (smulhi x (splat y))))
+(rule 3 (lower (has_type (ty_supported_vec ty) (smulhi _ x (splat _ y))))
   (rv_vmulh_vx x y (unmasked) ty))
 
 ;;;; Rules for `umulhi` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule 0 (lower (has_type (fits_in_32 ty) (umulhi x y)))
+(rule 0 (lower (has_type (fits_in_32 ty) (umulhi _ x y)))
   (let ((tmp XReg (rv_mul (zext x) (zext y))))
     (rv_srli tmp (imm12_const (ty_bits ty)))))
 
-(rule 1 (lower (has_type $I64 (umulhi x y)))
+(rule 1 (lower (has_type $I64 (umulhi _ x y)))
   (rv_mulhu x y))
 
-(rule 2 (lower (has_type (ty_vec_fits_in_register ty) (umulhi x y)))
+(rule 2 (lower (has_type (ty_supported_vec ty) (umulhi _ x y)))
   (rv_vmulhu_vv x y (unmasked) ty))
 
-(rule 3 (lower (has_type (ty_vec_fits_in_register ty) (umulhi (splat x) y)))
+(rule 3 (lower (has_type (ty_supported_vec ty) (umulhi _ (splat _ x) y)))
   (rv_vmulhu_vx y x (unmasked) ty))
 
-(rule 4 (lower (has_type (ty_vec_fits_in_register ty) (umulhi x (splat y))))
+(rule 4 (lower (has_type (ty_supported_vec ty) (umulhi _ x (splat _ y))))
   (rv_vmulhu_vx x y (unmasked) ty))
 
 ;;;; Rules for `udiv` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 0 (lower (has_type (fits_in_16 ty) (udiv x y)))
+(rule 0 (lower (has_type (fits_in_16 ty) (udiv _ x y)))
   (if-let $true (has_m))
   (rv_divuw (zext x) (nonzero_divisor (zext y))))
 
-(rule 1 (lower (has_type (fits_in_16 ty) (udiv x y @ (iconst imm))))
+(rule 1 (lower (has_type (fits_in_16 ty) (udiv _ x y @ (iconst _ imm))))
   (if-let $true (has_m))
   (if (safe_divisor_from_imm64 ty imm))
   (rv_divuw (zext x) (zext y)))
 
-(rule 2 (lower (has_type $I32 (udiv x y)))
+(rule 2 (lower (has_type $I32 (udiv _ x y)))
   (if-let $true (has_m))
   (rv_divuw x (nonzero_divisor (zext y))))
 
-(rule 3 (lower (has_type $I32 (udiv x y @ (iconst imm))))
+(rule 3 (lower (has_type $I32 (udiv _ x y @ (iconst _ imm))))
   (if-let $true (has_m))
   (if (safe_divisor_from_imm64 $I32 imm))
   (rv_divuw x y))
 
-(rule 2 (lower (has_type $I64 (udiv x y)))
+(rule 2 (lower (has_type $I64 (udiv _ x y)))
   (if-let $true (has_m))
   (rv_divu x (nonzero_divisor y)))
 
-(rule 3 (lower (has_type $I64 (udiv x y @ (iconst imm))))
+(rule 3 (lower (has_type $I64 (udiv _ x y @ (iconst _ imm))))
   (if-let $true (has_m))
   (if (safe_divisor_from_imm64 $I64 imm))
   (rv_divu x y))
@@ -545,31 +556,31 @@
 
 ;;;; Rules for `sdiv` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 0 (lower (has_type (fits_in_16 ty) (sdiv x y)))
+(rule 0 (lower (has_type (fits_in_16 ty) (sdiv _ x y)))
   (if-let $true (has_m))
   (let ((x XReg (sext x)))
     (rv_divw x (safe_sdiv_divisor ty x (sext y)))))
 
-(rule 1 (lower (has_type (fits_in_16 ty) (sdiv x y @ (iconst imm))))
+(rule 1 (lower (has_type (fits_in_16 ty) (sdiv _ x y @ (iconst _ imm))))
   (if-let $true (has_m))
   (if (safe_divisor_from_imm64 ty imm))
-  (rv_divw (sext x) y))
+  (rv_divw (sext x) (sext y)))
 
-(rule 2 (lower (has_type $I32 (sdiv x y)))
+(rule 2 (lower (has_type $I32 (sdiv _ x y)))
   (if-let $true (has_m))
   (let ((x XReg (sext x)))
     (rv_divw x (safe_sdiv_divisor $I32 x (sext y)))))
 
-(rule 3 (lower (has_type $I32 (sdiv x y @ (iconst imm))))
+(rule 3 (lower (has_type $I32 (sdiv _ x y @ (iconst _ imm))))
   (if-let $true (has_m))
   (if (safe_divisor_from_imm64 $I32 imm))
   (rv_divw x y))
 
-(rule 2 (lower (has_type $I64 (sdiv x y)))
+(rule 2 (lower (has_type $I64 (sdiv _ x y)))
   (if-let $true (has_m))
   (rv_div x (safe_sdiv_divisor $I64 x y)))
 
-(rule 3 (lower (has_type $I64 (sdiv x y @ (iconst imm))))
+(rule 3 (lower (has_type $I64 (sdiv _ x y @ (iconst _ imm))))
   (if-let $true (has_m))
   (if (safe_divisor_from_imm64 $I64 imm))
   (rv_div x y))
@@ -594,258 +605,400 @@
 
 ;;;; Rules for `urem` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 0 (lower (has_type (fits_in_16 ty) (urem x y)))
+(rule 0 (lower (has_type (fits_in_16 ty) (urem _ x y)))
   (if-let $true (has_m))
   (rv_remuw (zext x) (nonzero_divisor (zext y))))
 
-(rule 1 (lower (has_type (fits_in_16 ty) (urem x y @ (iconst imm))))
+(rule 1 (lower (has_type (fits_in_16 ty) (urem _ x y @ (iconst _ imm))))
   (if-let $true (has_m))
   (if (safe_divisor_from_imm64 ty imm))
-  (rv_remuw (zext x) y))
+  (rv_remuw (zext x) (zext y)))
 
-(rule 2 (lower (has_type $I32 (urem x y)))
+(rule 2 (lower (has_type $I32 (urem _ x y)))
   (if-let $true (has_m))
   (rv_remuw x (nonzero_divisor (zext y))))
 
-(rule 3 (lower (has_type $I32 (urem x y @ (iconst imm))))
+(rule 3 (lower (has_type $I32 (urem _ x y @ (iconst _ imm))))
   (if-let $true (has_m))
   (if (safe_divisor_from_imm64 $I32 imm))
   (rv_remuw x y))
 
-(rule 2 (lower (has_type $I64 (urem x y)))
+(rule 2 (lower (has_type $I64 (urem _ x y)))
   (if-let $true (has_m))
   (rv_remu x (nonzero_divisor y)))
 
-(rule 3 (lower (has_type $I64 (urem x y @ (iconst imm))))
+(rule 3 (lower (has_type $I64 (urem _ x y @ (iconst _ imm))))
   (if-let $true (has_m))
   (if (safe_divisor_from_imm64 $I64 imm))
   (rv_remu x y))
 
 ;;;; Rules for `srem` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 0 (lower (has_type (fits_in_16 ty) (srem x y)))
+(rule 0 (lower (has_type (fits_in_16 ty) (srem _ x y)))
   (if-let $true (has_m))
   (rv_remw (sext x) (nonzero_divisor (sext y))))
 
-(rule 1 (lower (has_type (fits_in_16 ty) (srem x y @ (iconst imm))))
+(rule 1 (lower (has_type (fits_in_16 ty) (srem _ x y @ (iconst _ imm))))
   (if-let $true (has_m))
   (if (safe_divisor_from_imm64 ty imm))
-  (rv_remw (sext x) y))
+  (rv_remw (sext x) (sext y)))
 
-(rule 2 (lower (has_type $I32 (srem x y)))
+(rule 2 (lower (has_type $I32 (srem _ x y)))
   (if-let $true (has_m))
   (rv_remw x (nonzero_divisor (sext y))))
 
-(rule 3 (lower (has_type $I32 (srem x y @ (iconst imm))))
+(rule 3 (lower (has_type $I32 (srem _ x y @ (iconst _ imm))))
   (if-let $true (has_m))
   (if (safe_divisor_from_imm64 $I32 imm))
   (rv_remw x y))
 
-(rule 2 (lower (has_type $I64 (srem x y)))
+(rule 2 (lower (has_type $I64 (srem _ x y)))
   (if-let $true (has_m))
   (rv_rem x (nonzero_divisor y)))
 
-(rule 3 (lower (has_type $I64 (srem x y @ (iconst imm))))
+(rule 3 (lower (has_type $I64 (srem _ x y @ (iconst _ imm))))
   (if-let $true (has_m))
   (if (safe_divisor_from_imm64 $I64 imm))
   (rv_rem x y))
 
 ;;;; Rules for `and` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule 0 (lower (has_type (ty_int ty) (band x y)))
-  (gen_and ty x y))
+(rule -1 (lower (has_type (fits_in_64 ty) (band _ x y)))
+  (rv_and x y))
+
+(rule 0 (lower (has_type $I128 (band _ x y)))
+  (value_regs
+    (rv_and (value_regs_get x 0) (value_regs_get y 0))
+    (rv_and (value_regs_get x 1) (value_regs_get y 1))))
 
 ;; Special cases for when one operand is an immediate that fits in 12 bits.
-(rule 1 (lower (has_type (fits_in_64 (ty_int ty)) (band x (imm12_from_value y))))
+(rule 1 (lower (has_type (fits_in_64 (ty_int ty)) (band _ x (imm12_from_value y))))
   (rv_andi x y))
 
-(rule 2 (lower (has_type (fits_in_64 (ty_int ty)) (band (imm12_from_value x) y)))
+(rule 2 (lower (has_type (fits_in_64 (ty_int ty)) (band _ (imm12_from_value x) y)))
   (rv_andi y x))
 
-(rule 3 (lower (has_type (ty_scalar_float ty) (band x y)))
+(rule 3 (lower (has_type (ty_supported_float ty) (band _ x y)))
   (lower_float_binary (AluOPRRR.And) x y ty))
 
 ;; Specialized lowerings for `(band x (bnot y))` which is additionally produced
 ;; by Cranelift's `band_not` instruction that is legalized into the simpler
 ;; forms early on.
 
-(rule 4 (lower (has_type (fits_in_64 (ty_int ty)) (band x (bnot y))))
+(rule 4 (lower (has_type (fits_in_64 (ty_int ty)) (band _ x (bnot _ y))))
   (if-let $true (has_zbb))
   (rv_andn x y))
 
-(rule 5 (lower (has_type (fits_in_64 (ty_int ty)) (band (bnot y) x)))
+(rule 5 (lower (has_type (fits_in_64 (ty_int ty)) (band _ (bnot _ y) x)))
   (if-let $true (has_zbb))
   (rv_andn x y))
 
-(rule 6 (lower (has_type $I128 (band x (bnot y))))
+(rule 6 (lower (has_type $I128 (band _ x (bnot _ y))))
   (if-let $true (has_zbb))
   (let ((low XReg (rv_andn (value_regs_get x 0) (value_regs_get y 0)))
         (high XReg (rv_andn (value_regs_get x 1) (value_regs_get y 1))))
     (value_regs low high)))
 
-(rule 7 (lower (has_type $I128 (band (bnot y) x)))
+(rule 7 (lower (has_type $I128 (band _ (bnot _ y) x)))
   (if-let $true (has_zbb))
   (let ((low XReg (rv_andn (value_regs_get x 0) (value_regs_get y 0)))
         (high XReg (rv_andn (value_regs_get x 1) (value_regs_get y 1))))
     (value_regs low high)))
 
-(rule 8 (lower (has_type (ty_vec_fits_in_register ty) (band x y)))
+(rule 8 (lower (has_type (ty_supported_vec ty) (band _ x y)))
   (rv_vand_vv x y (unmasked) ty))
 
-(rule 9 (lower (has_type (ty_vec_fits_in_register ty) (band x (splat y))))
+(rule 9 (lower (has_type (ty_supported_vec ty) (band _ x (splat _ y))))
   (if (ty_vector_not_float ty))
   (rv_vand_vx x y (unmasked) ty))
 
-(rule 10 (lower (has_type (ty_vec_fits_in_register ty) (band (splat x) y)))
+(rule 10 (lower (has_type (ty_supported_vec ty) (band _ (splat _ x) y)))
   (if (ty_vector_not_float ty))
   (rv_vand_vx y x (unmasked) ty))
 
-(rule 11 (lower (has_type (ty_vec_fits_in_register ty) (band x y)))
+(rule 11 (lower (has_type (ty_supported_vec ty) (band _ x y)))
   (if-let y_imm (replicated_imm5 y))
   (rv_vand_vi x y_imm (unmasked) ty))
 
-(rule 12 (lower (has_type (ty_vec_fits_in_register ty) (band x y)))
+(rule 12 (lower (has_type (ty_supported_vec ty) (band _ x y)))
   (if-let x_imm (replicated_imm5 x))
   (rv_vand_vi y x_imm (unmasked) ty))
 
+;; `bclr{,i}` specializations from `zbs`
+
+(rule 13 (lower (has_type (fits_in_32 ty) (band _ x (bnot _ (ishl _ (i64_from_iconst 1) y)))))
+  (if-let $true (has_zbs))
+  (rv_bclr x (rv_andi y (imm12_const (u8_sub (ty_bits ty) 1)))))
+(rule 14 (lower (has_type (fits_in_32 ty) (band _ (bnot _ (ishl _ (i64_from_iconst 1) y)) x)))
+  (if-let $true (has_zbs))
+  (rv_bclr x (rv_andi y (imm12_const (u8_sub (ty_bits ty) 1)))))
+
+(rule 15 (lower (has_type $I64 (band _ x (bnot _ (ishl _ (i64_from_iconst 1) y)))))
+  (if-let $true (has_zbs))
+  (rv_bclr x y))
+(rule 16 (lower (has_type $I64 (band _ (bnot _ (ishl _ (i64_from_iconst 1) y)) x)))
+  (if-let $true (has_zbs))
+  (rv_bclr x y))
+
+(rule 17 (lower (has_type (fits_in_64 ty) (band _ x (u64_from_iconst n))))
+  (if-let $true (has_zbs))
+  (if-let imm (bclr_imm ty n))
+  (rv_bclri x imm))
+(rule 18 (lower (has_type (fits_in_64 ty) (band _ (u64_from_iconst n) x)))
+  (if-let $true (has_zbs))
+  (if-let imm (bclr_imm ty n))
+  (rv_bclri x imm))
+
+(decl pure partial bclr_imm (Type u64) Imm12)
+(extern constructor bclr_imm bclr_imm)
+
+;; `bext{,i}` specializations from `zbs`
+
+(rule 19 (lower (has_type $I32 (band _ (ushr _ x y) (u64_from_iconst 1))))
+  (if-let $true (has_zbs))
+  (rv_bext x (rv_andi y (imm12_const 31))))
+(rule 19 (lower (has_type $I32 (band _ (sshr _ x y) (u64_from_iconst 1))))
+  (if-let $true (has_zbs))
+  (rv_bext x (rv_andi y (imm12_const 31))))
+(rule 19 (lower (has_type $I32 (band _ (u64_from_iconst 1) (ushr _ x y))))
+  (if-let $true (has_zbs))
+  (rv_bext x (rv_andi y (imm12_const 31))))
+(rule 19 (lower (has_type $I32 (band _ (u64_from_iconst 1) (sshr _ x y))))
+  (if-let $true (has_zbs))
+  (rv_bext x (rv_andi y (imm12_const 31))))
+
+(rule 19 (lower (has_type $I64 (band _ (ushr _ x y) (u64_from_iconst 1))))
+  (if-let $true (has_zbs))
+  (rv_bext x y))
+(rule 19 (lower (has_type $I64 (band _ (sshr _ x y) (u64_from_iconst 1))))
+  (if-let $true (has_zbs))
+  (rv_bext x y))
+(rule 19 (lower (has_type $I64 (band _ (u64_from_iconst 1) (ushr _ x y))))
+  (if-let $true (has_zbs))
+  (rv_bext x y))
+(rule 19 (lower (has_type $I64 (band _ (u64_from_iconst 1) (sshr _ x y))))
+  (if-let $true (has_zbs))
+  (rv_bext x y))
+
+(rule 20 (lower (has_type $I32 (band _ (ushr _ x (imm12_from_value y)) (u64_from_iconst 1))))
+  (if-let $true (has_zbs))
+  (rv_bexti x (imm12_and y 31)))
+(rule 20 (lower (has_type $I32 (band _ (sshr _ x (imm12_from_value y)) (u64_from_iconst 1))))
+  (if-let $true (has_zbs))
+  (rv_bexti x (imm12_and y 31)))
+(rule 20 (lower (has_type $I64 (band _ (ushr _ x (imm12_from_value y)) (u64_from_iconst 1))))
+  (if-let $true (has_zbs))
+  (rv_bexti x (imm12_and y 63)))
+(rule 20 (lower (has_type $I64 (band _ (sshr _ x (imm12_from_value y)) (u64_from_iconst 1))))
+  (if-let $true (has_zbs))
+  (rv_bexti x (imm12_and y 63)))
 
 ;;;; Rules for `or` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule 0 (lower (has_type (ty_int ty) (bor x y)))
+(rule 0 (lower (has_type (ty_int ty) (bor _ x y)))
   (gen_or ty x y))
 
 ;; Special cases for when one operand is an immediate that fits in 12 bits.
-(rule 1 (lower (has_type (fits_in_64 (ty_int ty)) (bor x (imm12_from_value y))))
+(rule 1 (lower (has_type (fits_in_64 (ty_int ty)) (bor _ x (imm12_from_value y))))
   (rv_ori x y))
 
-(rule 2 (lower (has_type (fits_in_64 (ty_int ty)) (bor (imm12_from_value x) y)))
+(rule 2 (lower (has_type (fits_in_64 (ty_int ty)) (bor _ (imm12_from_value x) y)))
   (rv_ori y x))
 
-(rule 3 (lower (has_type (ty_scalar_float ty) (bor x y)))
+(rule 3 (lower (has_type (ty_supported_float ty) (bor _ x y)))
   (lower_float_binary (AluOPRRR.Or) x y ty))
 
 ;; Specialized lowerings for `(bor x (bnot y))` which is additionally produced
 ;; by Cranelift's `bor_not` instruction that is legalized into the simpler
 ;; forms early on.
 
-(rule 4 (lower (has_type (fits_in_64 (ty_int ty)) (bor x (bnot y))))
+(rule 4 (lower (has_type (fits_in_64 (ty_int ty)) (bor _ x (bnot _ y))))
   (if-let $true (has_zbb))
   (rv_orn x y))
 
-(rule 5 (lower (has_type (fits_in_64 (ty_int ty)) (bor (bnot y) x)))
+(rule 5 (lower (has_type (fits_in_64 (ty_int ty)) (bor _ (bnot _ y) x)))
   (if-let $true (has_zbb))
   (rv_orn x y))
 
-(rule 6 (lower (has_type $I128 (bor x (bnot y))))
+(rule 6 (lower (has_type $I128 (bor _ x (bnot _ y))))
   (if-let $true (has_zbb))
   (let ((low XReg (rv_orn (value_regs_get x 0) (value_regs_get y 0)))
         (high XReg (rv_orn (value_regs_get x 1) (value_regs_get y 1))))
     (value_regs low high)))
 
-(rule 7 (lower (has_type $I128 (bor (bnot y) x)))
+(rule 7 (lower (has_type $I128 (bor _ (bnot _ y) x)))
   (if-let $true (has_zbb))
   (let ((low XReg (rv_orn (value_regs_get x 0) (value_regs_get y 0)))
         (high XReg (rv_orn (value_regs_get x 1) (value_regs_get y 1))))
     (value_regs low high)))
 
-(rule 8 (lower (has_type (ty_vec_fits_in_register ty) (bor x y)))
+(rule 8 (lower (has_type (ty_supported_vec ty) (bor _ x y)))
   (rv_vor_vv x y (unmasked) ty))
 
-(rule 9 (lower (has_type (ty_vec_fits_in_register ty) (bor x (splat y))))
+(rule 9 (lower (has_type (ty_supported_vec ty) (bor _ x (splat _ y))))
   (if (ty_vector_not_float ty))
   (rv_vor_vx x y (unmasked) ty))
 
-(rule 10 (lower (has_type (ty_vec_fits_in_register ty) (bor (splat x) y)))
+(rule 10 (lower (has_type (ty_supported_vec ty) (bor _ (splat _ x) y)))
   (if (ty_vector_not_float ty))
   (rv_vor_vx y x (unmasked) ty))
 
-(rule 11 (lower (has_type (ty_vec_fits_in_register ty) (bor x y)))
+(rule 11 (lower (has_type (ty_supported_vec ty) (bor _ x y)))
   (if-let y_imm (replicated_imm5 y))
   (rv_vor_vi x y_imm (unmasked) ty))
 
-(rule 12 (lower (has_type (ty_vec_fits_in_register ty) (bor x y)))
+(rule 12 (lower (has_type (ty_supported_vec ty) (bor _ x y)))
   (if-let x_imm (replicated_imm5 x))
   (rv_vor_vi y x_imm (unmasked) ty))
 
+;; `bset{,i}` specializations from `zbs`
+
+(rule 13 (lower (has_type $I32 (bor _ x (ishl _ (i64_from_iconst 1) y))))
+  (if-let $true (has_zbs))
+  (rv_bset x (rv_andi y (imm12_const 31))))
+(rule 14 (lower (has_type $I32 (bor _ (ishl _ (i64_from_iconst 1) y) x)))
+  (if-let $true (has_zbs))
+  (rv_bset x (rv_andi y (imm12_const 31))))
+
+(rule 13 (lower (has_type $I64 (bor _ x (ishl _ (i64_from_iconst 1) y))))
+  (if-let $true (has_zbs))
+  (rv_bset x y))
+(rule 14 (lower (has_type $I64 (bor _ (ishl _ (i64_from_iconst 1) y) x)))
+  (if-let $true (has_zbs))
+  (rv_bset x y))
+
+(rule 15 (lower (has_type (fits_in_64 _) (bor _ x (u64_from_iconst n))))
+  (if-let $true (has_zbs))
+  (if-let imm (bseti_imm n))
+  (rv_bseti x imm))
+(rule 16 (lower (has_type (fits_in_64 _) (bor _ (u64_from_iconst n) x)))
+  (if-let $true (has_zbs))
+  (if-let imm (bseti_imm n))
+  (rv_bseti x imm))
+
+(decl pure partial bseti_imm (u64) Imm12)
+(extern constructor bseti_imm bseti_imm)
 
 ;;;; Rules for `xor` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule 0 (lower (has_type (fits_in_64 (ty_int ty)) (bxor x y)))
+(rule 0 (lower (has_type (fits_in_64 (ty_int ty)) (bxor _ x y)))
   (rv_xor x y))
 
 ;; Special cases for when one operand is an immediate that fits in 12 bits.
-(rule 1 (lower (has_type (fits_in_64 (ty_int ty)) (bxor x (imm12_from_value y))))
+(rule 1 (lower (has_type (fits_in_64 (ty_int ty)) (bxor _ x (imm12_from_value y))))
   (rv_xori x y))
 
-(rule 2 (lower (has_type (fits_in_64 (ty_int ty)) (bxor (imm12_from_value x) y)))
+(rule 2 (lower (has_type (fits_in_64 (ty_int ty)) (bxor _ (imm12_from_value x) y)))
   (rv_xori y x))
 
-(rule 3 (lower (has_type $I128 (bxor x y)))
+(rule 3 (lower (has_type $I128 (bxor _ x y)))
   (lower_b128_binary (AluOPRRR.Xor) x y))
 
-(rule 4 (lower (has_type (ty_scalar_float ty) (bxor x y)))
+(rule 4 (lower (has_type (ty_supported_float ty) (bxor _ x y)))
   (lower_float_binary (AluOPRRR.Xor) x y ty))
 
-(rule 5 (lower (has_type (ty_vec_fits_in_register ty) (bxor x y)))
+(rule 5 (lower (has_type (ty_supported_vec ty) (bxor _ x y)))
   (rv_vxor_vv x y (unmasked) ty))
 
-(rule 6 (lower (has_type (ty_vec_fits_in_register ty) (bxor x (splat y))))
+(rule 6 (lower (has_type (ty_supported_vec ty) (bxor _ x (splat _ y))))
   (if (ty_vector_not_float ty))
   (rv_vxor_vx x y (unmasked) ty))
 
-(rule 7 (lower (has_type (ty_vec_fits_in_register ty) (bxor (splat x) y)))
+(rule 7 (lower (has_type (ty_supported_vec ty) (bxor _ (splat _ x) y)))
   (if (ty_vector_not_float ty))
   (rv_vxor_vx y x (unmasked) ty))
 
-(rule 8 (lower (has_type (ty_vec_fits_in_register ty) (bxor x y)))
+(rule 8 (lower (has_type (ty_supported_vec ty) (bxor _ x y)))
   (if-let y_imm (replicated_imm5 y))
   (rv_vxor_vi x y_imm (unmasked) ty))
 
-(rule 9 (lower (has_type (ty_vec_fits_in_register ty) (bxor x y)))
+(rule 9 (lower (has_type (ty_supported_vec ty) (bxor _ x y)))
   (if-let x_imm (replicated_imm5 x))
   (rv_vxor_vi y x_imm (unmasked) ty))
 
+;; `binv{,i}` specializations from `zbs`
+
+(rule 13 (lower (has_type $I32 (bxor _ x (ishl _ (i64_from_iconst 1) y))))
+  (if-let $true (has_zbs))
+  (rv_binv x (rv_andi y (imm12_const 31))))
+(rule 14 (lower (has_type $I32 (bxor _ (ishl _ (i64_from_iconst 1) y) x)))
+  (if-let $true (has_zbs))
+  (rv_binv x (rv_andi y (imm12_const 31))))
+
+(rule 13 (lower (has_type $I64 (bxor _ x (ishl _ (i64_from_iconst 1) y))))
+  (if-let $true (has_zbs))
+  (rv_binv x y))
+(rule 14 (lower (has_type $I64 (bxor _ (ishl _ (i64_from_iconst 1) y) x)))
+  (if-let $true (has_zbs))
+  (rv_binv x y))
+
+(rule 15 (lower (has_type (fits_in_64 _) (bxor _ x (u64_from_iconst n))))
+  (if-let $true (has_zbs))
+  (if-let imm (binvi_imm n))
+  (rv_binvi x imm))
+(rule 16 (lower (has_type (fits_in_64 _) (bxor _ (u64_from_iconst n) x)))
+  (if-let $true (has_zbs))
+  (if-let imm (binvi_imm n))
+  (rv_binvi x imm))
+
+(decl pure partial binvi_imm (u64) Imm12)
+(extern constructor binvi_imm binvi_imm)
 
 ;;;; Rules for `bnot` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule 0 (lower (has_type (ty_scalar ty) (bnot x)))
-  (gen_bnot ty x))
 
-(rule 1 (lower (has_type (ty_vec_fits_in_register ty) (bnot x)))
+(rule 0 (lower (has_type (ty_int_ref_scalar_64 _) (bnot _ x)))
+  (rv_not x))
+
+(rule 1 (lower (has_type (ty_supported_float ty) (bnot _ x)))
+  (move_x_to_f (rv_not (move_f_to_x x ty)) (float_int_of_same_size ty)))
+
+(rule 2 (lower (has_type $I128 (bnot _ x)))
+  (value_regs
+    (rv_not (value_regs_get x 0))
+    (rv_not (value_regs_get x 1))))
+
+(rule 3 (lower (has_type (ty_supported_vec ty) (bnot _ x)))
   (rv_vnot_v x (unmasked) ty))
 
+(rule 4 (lower (has_type (ty_int_ref_scalar_64 _) (bnot _ (bxor _ x y))))
+  (if-let $true (has_zbb))
+  (rv_xnor x y))
+
 ;;;; Rules for `bit_reverse` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule (lower (has_type (fits_in_64 (ty_int ty)) (bitrev x)))
-  (lower_bit_reverse x ty))
 
-(rule 1 (lower (has_type $I128 (bitrev x)))
-  (let ((val ValueRegs x)
-    (lo_rev XReg (lower_bit_reverse (value_regs_get val 0) $I64))
-    (hi_rev XReg (lower_bit_reverse (value_regs_get val 1) $I64)))
-    (value_regs hi_rev lo_rev)))
+(rule 0 (lower (has_type (ty_int_ref_scalar_64 ty) (bitrev _ x)))
+  (gen_bitrev ty x))
 
-;;;; Rules for `bswap` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(rule 1 (lower (has_type $I128 (bitrev _ x)))
+  (value_regs
+    (gen_bitrev $I64 (value_regs_get x 1))
+    (gen_bitrev $I64 (value_regs_get x 0))))
 
-(rule 1 (lower (has_type (fits_in_64 (ty_int ty)) (bswap x)))
-  (gen_bswap ty x))
 
-(rule 2 (lower (has_type $I128 (bswap x)))
-  (value_regs
-    (gen_bswap $I64 (value_regs_get x 1))
-    (gen_bswap $I64 (value_regs_get x 0))))
+;; Constructs a sequence of instructions that reverse all bits in `x` up to
+;; the given type width.
+(decl gen_bitrev (Type XReg) XReg)
 
-(rule 3 (lower (has_type (fits_in_32 ty) (bswap x)))
-  (if-let $true (has_zbb))
+(rule 0 (gen_bitrev (ty_16_or_32 (ty_int ty)) x)
   (if-let shift_amt (u64_to_imm12 (u64_sub 64 (ty_bits ty))))
-  (rv_srli (rv_rev8 x) shift_amt))
+  (rv_srli (gen_bitrev $I64 x) shift_amt))
 
-(rule 4 (lower (has_type $I64 (bswap x)))
-  (if-let $true (has_zbb))
-  (rv_rev8 x))
+(rule 1 (gen_bitrev $I8 x)
+  (gen_brev8 x $I8))
 
-(rule 5 (lower (has_type $I128 (bswap x)))
-  (if-let $true (has_zbb))
+(rule 1 (gen_bitrev $I64 x)
+  (gen_brev8 (gen_bswap $I64 x) $I64))
+
+
+;;;; Rules for `bswap` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(rule 1 (lower (has_type (fits_in_64 (ty_int ty)) (bswap _ x)))
+  (gen_bswap ty x))
+
+(rule 2 (lower (has_type $I128 (bswap _ x)))
   (value_regs
-    (rv_rev8 (value_regs_get x 1))
-    (rv_rev8 (value_regs_get x 0))))
+    (gen_bswap $I64 (value_regs_get x 1))
+    (gen_bswap $I64 (value_regs_get x 0))))
 
-;; Helper to generate a fallback byte-swap sequence when `zbb` isn't available.
+;; Builds a sequence of instructions that swaps the bytes in `x` up to the given
+;; type width.
 (decl gen_bswap (Type XReg) XReg)
 
 ;; This is only here to make the rule below work. bswap.i8 isn't valid
@@ -869,11 +1022,20 @@
         (bot XReg (rv_srli bot_shifted_left shift)))
     (rv_or top bot)))
 
+(rule 2 (gen_bswap (ty_16_or_32 (ty_int ty)) x)
+  (if-let $true (has_zbb))
+  (if-let shift_amt (u64_to_imm12 (u64_sub 64 (ty_bits ty))))
+  (rv_srli (rv_rev8 x) shift_amt))
+
+(rule 3 (gen_bswap $I64 x)
+  (if-let $true (has_zbb))
+  (rv_rev8 x))
+
 ;;;; Rules for `ctz` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule (lower (has_type (fits_in_64 ty) (ctz x)))
+(rule (lower (has_type (fits_in_64 ty) (ctz _ x)))
   (lower_ctz ty x))
 
-(rule 1 (lower (has_type $I128 (ctz x)))
+(rule 1 (lower (has_type $I128 (ctz _ x)))
   (let ((x_lo XReg (value_regs_get x 0))
         (x_hi XReg (value_regs_get x 1))
         ;; Count both halves
@@ -885,10 +1047,10 @@
     (value_regs result (imm $I64 0))))
 
 ;;;; Rules for `clz` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule 0 (lower (has_type (fits_in_64 ty) (clz x)))
+(rule 0 (lower (has_type (fits_in_64 ty) (clz _ x)))
   (gen_cltz $true x ty))
 
-(rule 1 (lower (has_type $I128 (clz x)))
+(rule 1 (lower (has_type $I128 (clz _ x)))
   (let ((x_lo XReg (value_regs_get x 0))
         (x_hi XReg (value_regs_get x 1))
         ;; Count both halves
@@ -898,18 +1060,18 @@
         (low XReg (gen_select_xreg (cmp_eqz x_hi) low (zero_reg))))
     (value_regs (rv_add high low) (imm $I64 0))))
 
-(rule 2 (lower (has_type (fits_in_16 ty) (clz x)))
+(rule 2 (lower (has_type (fits_in_16 ty) (clz _ x)))
   (if-let $true (has_zbb))
   (let ((tmp XReg (zext x))
         (count XReg (rv_clz tmp)))
     ;; We always do the operation on the full 64-bit register, so subtract 64 from the result.
     (rv_addi count (imm12_const_add (ty_bits ty) -64))))
 
-(rule 3 (lower (has_type $I32 (clz x)))
+(rule 3 (lower (has_type $I32 (clz _ x)))
   (if-let $true (has_zbb))
   (rv_clzw x))
 
-(rule 3 (lower (has_type $I64 (clz x)))
+(rule 3 (lower (has_type $I64 (clz _ x)))
   (if-let $true (has_zbb))
   (rv_clz x))
 
@@ -922,7 +1084,7 @@
 
 ;;;; Rules for `cls` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type (fits_in_64 ty) (cls x)))
+(rule (lower (has_type (fits_in_64 ty) (cls _ x)))
   (let ((tmp XReg (sext x))
         (tmp2 XReg (gen_select_xreg (cmp_ltz tmp) (rv_not tmp) tmp))
         (tmp3 XReg (gen_clz tmp2)))
@@ -933,7 +1095,7 @@
 ;; If the sign bit is set, we count the leading zeros of the inverted value.
 ;; Otherwise we can just count the leading zeros of the original value.
 ;; Subtract 1 since the sign bit does not count.
-(rule 1 (lower (has_type $I128 (cls x)))
+(rule 1 (lower (has_type $I128 (cls _ x)))
   (let ((low XReg (value_regs_get x 0))
         (high XReg (value_regs_get x 1))
         (low XReg (gen_select_xreg (cmp_ltz high) (rv_not low) low))
@@ -950,57 +1112,44 @@
 
 
 ;;;; Rules for `uextend` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule 0 (lower (has_type (fits_in_64 _) (uextend val)))
+(rule 0 (lower (has_type (fits_in_64 _) (uextend _ val)))
   (zext val))
-(rule 1 (lower (has_type $I128 (uextend val)))
+
+(rule 1 (lower (has_type $I128 (uextend _ val)))
   (value_regs (zext val) (imm $I64 0)))
 
+;; When the source of an `uextend` is a load, we can merge both ops
+(rule 2 (lower (has_type (fits_in_64 _) (uextend _ (sinkable_load inst ty flags addr offset))))
+  (gen_sunk_load inst (amode addr offset) (uextend_load_op ty) flags))
+
+(decl pure uextend_load_op (Type) LoadOP)
+(rule (uextend_load_op $I8) (LoadOP.Lbu))
+(rule (uextend_load_op $I16) (LoadOP.Lhu))
+(rule (uextend_load_op $I32) (LoadOP.Lwu))
+
 ;;;; Rules for `sextend` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule 0 (lower (has_type (fits_in_64 _) (sextend val @ (value_type in_ty))))
+(rule 0 (lower (has_type (fits_in_64 _) (sextend _ val @ (value_type in_ty))))
   (sext val))
-(rule 1 (lower (has_type $I128 (sextend val @ (value_type in_ty))))
+
+(rule 1 (lower (has_type $I128 (sextend _ val @ (value_type in_ty))))
   (let ((lo XReg (sext val)))
     (value_regs lo (rv_srai lo (imm12_const 63)))))
 
-;; The instructions below are present in RV64I and sign-extend the result to 64 bits.
-
-(rule 1 (lower (has_type $I64 (sextend (has_type $I32 (iadd x y)))))
-  (rv_addw x y))
-
-(rule 1 (lower (has_type $I64 (sextend (has_type $I32 (isub x y)))))
-  (rv_subw x y))
-
-(rule 1 (lower (has_type $I64 (sextend (has_type $I32 (ishl x y)))))
-  (rv_sllw x (value_regs_get y 0)))
-
-(rule 1 (lower (has_type $I64 (sextend (has_type $I32 (ushr x y)))))
-  (rv_srlw x (value_regs_get y 0)))
-
-(rule 1 (lower (has_type $I64 (sextend (has_type $I32 (sshr x y)))))
-  (rv_sraw x (value_regs_get y 0)))
+;; When the source of an `sextend` is a load, we can merge both ops
+(rule 2 (lower (has_type (fits_in_64 _) (sextend _ (sinkable_load inst ty flags addr offset))))
+  (gen_sunk_load inst (amode addr offset) (sextend_load_op ty) flags))
 
-
-(rule 2 (lower (has_type $I64 (sextend (has_type $I32 (iadd x (imm12_from_value y))))))
-  (rv_addiw x y))
-
-(rule 3 (lower (has_type $I64 (sextend (has_type $I32 (iadd (imm12_from_value x) y)))))
-  (rv_addiw y x))
-
-(rule 2 (lower (has_type $I64 (sextend (has_type $I32 (ishl x (imm12_from_value y))))))
-  (rv_slliw x y))
-
-(rule 2 (lower (has_type $I64 (sextend (has_type $I32 (ushr x (imm12_from_value y))))))
-  (rv_srliw x y))
-
-(rule 2 (lower (has_type $I64 (sextend (has_type $I32 (sshr x (imm12_from_value y))))))
-  (rv_sraiw x y))
+(decl pure sextend_load_op (Type) LoadOP)
+(rule (sextend_load_op $I8) (LoadOP.Lb))
+(rule (sextend_load_op $I16) (LoadOP.Lh))
+(rule (sextend_load_op $I32) (LoadOP.Lw))
 
 ;;;; Rules for `popcnt` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 0 (lower (has_type (fits_in_64 _) (popcnt x)))
+(rule 0 (lower (has_type (fits_in_64 _) (popcnt _ x)))
   (gen_popcnt (zext x)))
 
-(rule 1 (lower (has_type $I128 (popcnt x)))
+(rule 1 (lower (has_type $I128 (popcnt _ x)))
   (let
     ((x ValueRegs x)
      (low XReg (gen_popcnt (value_regs_get x 0)))
@@ -1008,15 +1157,15 @@
      (result XReg (rv_add low high)))
     (value_regs result (imm $I64 0))))
 
-(rule 2 (lower (has_type (fits_in_64 _) (popcnt x)))
+(rule 2 (lower (has_type (fits_in_64 _) (popcnt _ x)))
   (if-let $true (has_zbb))
   (rv_cpop (zext x)))
 
-(rule 3 (lower (has_type $I32 (popcnt x)))
+(rule 3 (lower (has_type $I32 (popcnt _ x)))
   (if-let $true (has_zbb))
   (rv_cpopw x))
 
-(rule 3 (lower (has_type $I128 (popcnt x)))
+(rule 3 (lower (has_type $I128 (popcnt _ x)))
   (if-let $true (has_zbb))
   (let
     ((x ValueRegs x)
@@ -1037,7 +1186,7 @@
 ;;
 ;; TODO: LLVM generates a much better implementation for I8X16. See: https://godbolt.org/z/qr6vf9Gr3
 ;; For the other types it seems to be largely the same.
-(rule 4 (lower (has_type (ty_vec_fits_in_register ty) (popcnt x)))
+(rule 4 (lower (has_type (ty_supported_vec ty) (popcnt _ x)))
   (if-let one (u64_to_uimm5 1))
   (if-let two (u64_to_uimm5 2))
   (if-let four (u64_to_uimm5 4))
@@ -1071,34 +1220,34 @@
 ;;;; Rules for `ishl` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; 8/16 bit types need a mask on the shift amount
-(rule 0 (lower (has_type (ty_int (ty_8_or_16 ty)) (ishl x y)))
-  (if-let mask (u64_to_imm12 (shift_mask ty)))
+(rule 0 (lower (has_type (ty_int (ty_8_or_16 ty)) (ishl _ x y)))
+  (if-let mask (u64_to_imm12 (ty_shift_mask ty)))
   (rv_sllw x (rv_andi (value_regs_get y 0) mask)))
 
 ;; Using the 32bit version of `sll` automatically masks the shift amount.
-(rule 1 (lower (has_type $I32 (ishl x y)))
+(rule 1 (lower (has_type $I32 (ishl _ x y)))
   (rv_sllw x (value_regs_get y 0)))
 
 ;; Similarly, the 64bit version does the right thing.
-(rule 1 (lower (has_type $I64 (ishl x y)))
+(rule 1 (lower (has_type $I64 (ishl _ x y)))
   (rv_sll x (value_regs_get y 0)))
 
 ;; If the shift amount is known. We can mask it and encode it in the instruction.
-(rule 2 (lower (has_type (int_fits_in_32 ty) (ishl x (maybe_uextend (imm12_from_value y)))))
-  (rv_slliw x (imm12_and y (shift_mask ty))))
+(rule 2 (lower (has_type (int_fits_in_32 ty) (ishl _ x (maybe_uextend (imm12_from_value y)))))
+  (rv_slliw x (imm12_and y (ty_shift_mask ty))))
 
 ;; We technically don't need to mask the shift amount here. The instruction
 ;; does the right thing. But it's neater when pretty printing it.
-(rule 3 (lower (has_type ty @ $I64 (ishl x (maybe_uextend (imm12_from_value y)))))
-  (rv_slli x (imm12_and y (shift_mask ty))))
+(rule 3 (lower (has_type ty @ $I64 (ishl _ x (maybe_uextend (imm12_from_value y)))))
+  (rv_slli x (imm12_and y (ty_shift_mask ty))))
 
 ;; With `Zba` we have a shift that zero extends the LHS argument.
-(rule 4 (lower (has_type $I64 (ishl (uextend x @ (value_type $I32)) (maybe_uextend (imm12_from_value y)))))
+(rule 4 (lower (has_type $I64 (ishl _ (uextend _ x @ (value_type $I32)) (maybe_uextend (imm12_from_value y)))))
   (if-let $true (has_zba))
   (rv_slliuw x y))
 
 ;; I128 cases
-(rule 4 (lower (has_type $I128 (ishl x y)))
+(rule 4 (lower (has_type $I128 (ishl _ x y)))
   (let ((tmp ValueRegs (gen_shamt $I128 (value_regs_get y 0)))
         (shamt XReg (value_regs_get tmp 0))
         (len_sub_shamt XReg (value_regs_get tmp 1))
@@ -1121,39 +1270,39 @@
 ;; SIMD Cases
 ;; We don't need to mask anything since it is done by the instruction according to SEW.
 
-(rule 5 (lower (has_type (ty_vec_fits_in_register ty) (ishl x y)))
+(rule 5 (lower (has_type (ty_supported_vec ty) (ishl _ x y)))
   (rv_vsll_vx x (value_regs_get y 0) (unmasked) ty))
 
-(rule 6 (lower (has_type (ty_vec_fits_in_register ty) (ishl x (maybe_uextend (uimm5_from_value y)))))
+(rule 6 (lower (has_type (ty_supported_vec ty) (ishl _ x (maybe_uextend (uimm5_from_value y)))))
   (rv_vsll_vi x y (unmasked) ty))
 
 ;;;; Rules for `ushr` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; 8/16 bit types need a mask on the shift amount, and the LHS needs to be
 ;; zero extended.
-(rule 0 (lower (has_type (ty_int (fits_in_16 ty)) (ushr x y)))
-  (if-let mask (u64_to_imm12 (shift_mask ty)))
+(rule 0 (lower (has_type (ty_int (fits_in_16 ty)) (ushr _ x y)))
+  (if-let mask (u64_to_imm12 (ty_shift_mask ty)))
   (rv_srlw (zext x) (rv_andi (value_regs_get y 0) mask)))
 
 ;; Using the 32bit version of `srl` automatically masks the shift amount.
-(rule 1 (lower (has_type $I32 (ushr x y)))
+(rule 1 (lower (has_type $I32 (ushr _ x y)))
   (rv_srlw x (value_regs_get y 0)))
 
 ;; Similarly, the 64bit version does the right thing.
-(rule 1 (lower (has_type $I64 (ushr x y)))
+(rule 1 (lower (has_type $I64 (ushr _ x y)))
   (rv_srl x (value_regs_get y 0)))
 
 ;; When the RHS is known we can just encode it in the instruction.
-(rule 2 (lower (has_type (ty_int (fits_in_16 ty)) (ushr x (maybe_uextend (imm12_from_value y)))))
-  (rv_srliw (zext x) (imm12_and y (shift_mask ty))))
+(rule 2 (lower (has_type (ty_int (fits_in_16 ty)) (ushr _ x (maybe_uextend (imm12_from_value y)))))
+  (rv_srliw (zext x) (imm12_and y (ty_shift_mask ty))))
 
-(rule 3 (lower (has_type $I32 (ushr x (maybe_uextend (imm12_from_value y)))))
+(rule 3 (lower (has_type $I32 (ushr _ x (maybe_uextend (imm12_from_value y)))))
   (rv_srliw x y))
 
-(rule 3 (lower (has_type $I64 (ushr x (maybe_uextend (imm12_from_value y)))))
+(rule 3 (lower (has_type $I64 (ushr _ x (maybe_uextend (imm12_from_value y)))))
   (rv_srli x y))
 
-(rule 3 (lower (has_type $I128 (ushr x y)))
+(rule 3 (lower (has_type $I128 (ushr _ x y)))
   (let ((tmp ValueRegs (gen_shamt $I128 (value_regs_get y 0)))
         (shamt XReg (value_regs_get tmp 0))
         (len_sub_shamt XReg (value_regs_get tmp 1))
@@ -1176,39 +1325,39 @@
 ;; SIMD Cases
 ;; We don't need to mask or extend anything since it is done by the instruction according to SEW.
 
-(rule 4 (lower (has_type (ty_vec_fits_in_register ty) (ushr x y)))
+(rule 4 (lower (has_type (ty_supported_vec ty) (ushr _ x y)))
   (rv_vsrl_vx x (value_regs_get y 0) (unmasked) ty))
 
-(rule 5 (lower (has_type (ty_vec_fits_in_register ty) (ushr x (maybe_uextend (uimm5_from_value y)))))
+(rule 5 (lower (has_type (ty_supported_vec ty) (ushr _ x (maybe_uextend (uimm5_from_value y)))))
   (rv_vsrl_vi x y (unmasked) ty))
 
 ;;;; Rules for `sshr` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; 8/16 bit types need a mask on the shift amount, and the LHS needs to be
 ;; zero extended.
-(rule 0 (lower (has_type (ty_int (fits_in_16 ty)) (sshr x y)))
-  (if-let mask (u64_to_imm12 (shift_mask ty)))
+(rule 0 (lower (has_type (ty_int (fits_in_16 ty)) (sshr _ x y)))
+  (if-let mask (u64_to_imm12 (ty_shift_mask ty)))
   (rv_sraw (sext x) (rv_andi (value_regs_get y 0) mask)))
 
 ;; Using the 32bit version of `sra` automatically masks the shift amount.
-(rule 1 (lower (has_type $I32 (sshr x y)))
+(rule 1 (lower (has_type $I32 (sshr _ x y)))
   (rv_sraw x (value_regs_get y 0)))
 
 ;; Similarly, the 64bit version does the right thing.
-(rule 1 (lower (has_type $I64 (sshr x y)))
+(rule 1 (lower (has_type $I64 (sshr _ x y)))
   (rv_sra x (value_regs_get y 0)))
 
 ;; When the RHS is known we can just encode it in the instruction.
-(rule 2 (lower (has_type (ty_int (fits_in_16 ty)) (sshr x (maybe_uextend (imm12_from_value y)))))
-  (rv_sraiw (sext x) (imm12_and y (shift_mask ty))))
+(rule 2 (lower (has_type (ty_int (fits_in_16 ty)) (sshr _ x (maybe_uextend (imm12_from_value y)))))
+  (rv_sraiw (sext x) (imm12_and y (ty_shift_mask ty))))
 
-(rule 3 (lower (has_type $I32 (sshr x (maybe_uextend (imm12_from_value y)))))
+(rule 3 (lower (has_type $I32 (sshr _ x (maybe_uextend (imm12_from_value y)))))
   (rv_sraiw x y))
 
-(rule 3 (lower (has_type $I64 (sshr x (maybe_uextend (imm12_from_value y)))))
+(rule 3 (lower (has_type $I64 (sshr _ x (maybe_uextend (imm12_from_value y)))))
   (rv_srai x y))
 
-(rule 3 (lower (has_type $I128 (sshr x y)))
+(rule 3 (lower (has_type $I128 (sshr _ x y)))
   (let ((tmp ValueRegs (gen_shamt $I128 (value_regs_get y 0)))
         (shamt XReg (value_regs_get tmp 0))
         (len_sub_shamt XReg (value_regs_get tmp 1))
@@ -1236,130 +1385,248 @@
 ;; SIMD Cases
 ;; We don't need to mask or extend anything since it is done by the instruction according to SEW.
 
-(rule 4 (lower (has_type (ty_vec_fits_in_register ty) (sshr x y)))
+(rule 4 (lower (has_type (ty_supported_vec ty) (sshr _ x y)))
   (rv_vsra_vx x (value_regs_get y 0) (unmasked) ty))
 
-(rule 5 (lower (has_type (ty_vec_fits_in_register ty) (sshr x (maybe_uextend (uimm5_from_value y)))))
+(rule 5 (lower (has_type (ty_supported_vec ty) (sshr _ x (maybe_uextend (uimm5_from_value y)))))
   (rv_vsra_vi x y (unmasked) ty))
 
 
 ;;;; Rules for `rotl` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule (lower (has_type (fits_in_64 ty) (rotl x y)))
-  (lower_rotl ty (zext x) (value_regs_get y 0)))
 
-(rule 1 (lower (has_type $I128 (rotl x y)))
-  (lower_i128_rotl x y))
+(rule 0 (lower (has_type (fits_in_64 ty) (rotl _ rs amount)))
+  (let
+    ((rs XReg (zext rs))
+      (amount XReg (value_regs_get amount 0))
+      (x ValueRegs (gen_shamt ty amount))
+      (shamt XReg (value_regs_get x 0))
+      (len_sub_shamt Reg (value_regs_get x 1))
+      (part1 Reg (rv_sll rs shamt))
+      (part2 Reg (rv_srl rs len_sub_shamt))
+      (part3 Reg (gen_select_xreg (cmp_eqz shamt) (zero_reg) part2)))
+    (rv_or part1 part3)))
+
+(rule 1 (lower (has_type $I32 (rotl _ rs amount)))
+  (if-let $true (has_zbb))
+  (rv_rolw rs (value_regs_get amount 0)))
+
+(rule 2 (lower (has_type $I32 (rotl _ rs (u64_from_iconst n))))
+  (if-let $true (has_zbb))
+  (if-let (imm12_from_u64 imm) (u64_sub 32 (u64_and n 31)))
+  (rv_roriw rs imm))
+
+(rule 1 (lower (has_type $I64 (rotl _ rs amount)))
+  (if-let $true (has_zbb))
+  (rv_rol rs (value_regs_get amount 0)))
+
+(rule 2 (lower (has_type $I64 (rotl _ rs (u64_from_iconst n))))
+  (if-let $true (has_zbb))
+  (if-let (imm12_from_u64 imm) (u64_sub 64 (u64_and n 63)))
+  (rv_rori rs imm))
+
+(rule 1 (lower (has_type $I128 (rotl _ x y)))
+  (let
+    ((tmp ValueRegs (gen_shamt $I128 (value_regs_get y 0)))
+      (shamt XReg (value_regs_get tmp 0))
+      (len_sub_shamt XReg (value_regs_get tmp 1))
+      (low_part1 XReg (rv_sll (value_regs_get x 0) shamt))
+      (low_part2 XReg (rv_srl (value_regs_get x 1) len_sub_shamt))
+      ;;; if shamt == 0 low_part2 will overflow we should zero instead.
+      (low_part3 XReg (gen_select_xreg (cmp_eqz shamt) (zero_reg) low_part2))
+      (low XReg (rv_or low_part1 low_part3))
+      (high_part1 XReg (rv_sll (value_regs_get x 1) shamt))
+      (high_part2 XReg (rv_srl (value_regs_get x 0) len_sub_shamt))
+      (high_part3 XReg (gen_select_xreg (cmp_eqz shamt) (zero_reg) high_part2))
+      (high XReg (rv_or high_part1 high_part3))
+      (const64 XReg (imm $I64 64))
+      (shamt_128 XReg (rv_andi (value_regs_get y 0) (imm12_const 127))))
+    ;; right now we only rotate less than 64 bits.
+    ;; if shamt is greater than or equal 64 , we should switch low and high.
+    (gen_select_regs
+      (cmp_geu shamt_128 const64)
+      (value_regs high low)
+      (value_regs low high)
+    )))
 
 ;;;; Rules for `rotr` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule (lower (has_type (fits_in_64 ty) (rotr x y)))
-  (lower_rotr ty (zext x) (value_regs_get y 0)))
 
-(rule 1 (lower (has_type $I128 (rotr x y)))
-  (lower_i128_rotr x y))
+(rule (lower (has_type (fits_in_64 ty) (rotr _ rs amount)))
+  (let
+    ((rs XReg (zext rs))
+      (amount XReg (value_regs_get amount 0))
+      (x ValueRegs (gen_shamt ty amount))
+      (shamt XReg (value_regs_get x 0))
+      (len_sub_shamt XReg (value_regs_get x 1))
+      (part1 XReg (rv_srl rs shamt))
+      (part2 XReg (rv_sll rs len_sub_shamt))
+      (part3 XReg (gen_select_xreg (cmp_eqz shamt) (zero_reg) part2)))
+    (rv_or part1 part3)))
+
+(rule 1 (lower (has_type $I32 (rotr _ rs amount)))
+  (if-let $true (has_zbb))
+  (rv_rorw rs (value_regs_get amount 0)))
+
+(rule 2 (lower (has_type $I32 (rotr _ rs (imm12_from_value n))))
+  (if-let $true (has_zbb))
+  (rv_roriw rs n))
+
+(rule 1 (lower (has_type $I64 (rotr _ rs amount)))
+  (if-let $true (has_zbb))
+  (rv_ror rs (value_regs_get amount 0)))
+
+(rule 2 (lower (has_type $I64 (rotr _ rs (imm12_from_value n))))
+  (if-let $true (has_zbb))
+  (rv_rori rs n))
 
+(rule 1 (lower (has_type $I128 (rotr _ x y)))
+  (let
+    ((tmp ValueRegs (gen_shamt $I128 (value_regs_get y 0)))
+      (shamt XReg (value_regs_get tmp 0))
+      (len_sub_shamt XReg (value_regs_get tmp 1))
+      (low_part1 XReg (rv_srl (value_regs_get x 0) shamt))
+      (low_part2 XReg (rv_sll (value_regs_get x 1) len_sub_shamt))
+      ;;; if shamt == 0 low_part2 will overflow we should zero instead.
+      (low_part3 XReg (gen_select_xreg (cmp_eqz shamt) (zero_reg) low_part2))
+      (low XReg (rv_or low_part1 low_part3))
+      (high_part1 XReg (rv_srl (value_regs_get x 1) shamt))
+      (high_part2 XReg (rv_sll (value_regs_get x 0) len_sub_shamt))
+      (high_part3 XReg (gen_select_xreg (cmp_eqz shamt) (zero_reg) high_part2))
+      (high XReg (rv_or high_part1 high_part3))
+      (const64 XReg (imm $I64 64))
+      (shamt_128 XReg (rv_andi (value_regs_get y 0) (imm12_const 127))))
+    ;; right now we only rotate less than 64 bits.
+    ;; if shamt is greater than or equal 64 , we should switch low and high.
+    (gen_select_regs
+      (cmp_geu shamt_128 const64)
+      (value_regs high low)
+      (value_regs low high)
+    )))
 
 ;;;; Rules for `fabs` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule 0 (lower (has_type (ty_scalar_float ty) (fabs x)))
+(rule 0 (lower (has_type (ty_supported_float ty) (fabs _ x)))
   (rv_fabs ty x))
 
-(rule 1 (lower (has_type (ty_vec_fits_in_register ty) (fabs x)))
+(rule 1 (lower (has_type (ty_supported_vec ty) (fabs _ x)))
   (rv_vfabs_v x (unmasked) ty))
 
 ;;;; Rules for `fneg` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule 0 (lower (has_type (ty_scalar_float ty) (fneg x)))
+(rule 0 (lower (has_type (ty_supported_float ty) (fneg _ x)))
   (rv_fneg ty x))
 
-(rule 1 (lower (has_type (ty_vec_fits_in_register ty) (fneg x)))
+(rule 1 (lower (has_type (ty_supported_vec ty) (fneg _ x)))
   (rv_vfneg_v x (unmasked) ty))
 
 ;;;; Rules for `fcopysign` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule 0 (lower (has_type (ty_scalar_float ty) (fcopysign x y)))
+(rule 0 (lower (has_type (ty_supported_float ty) (fcopysign _ x y)))
   (rv_fsgnj ty x y))
 
-(rule 1 (lower (has_type (ty_vec_fits_in_register ty) (fcopysign x y)))
+(rule 1 (lower (has_type (ty_supported_vec ty) (fcopysign _ x y)))
   (rv_vfsgnj_vv x y (unmasked) ty))
 
-(rule 2 (lower (has_type (ty_vec_fits_in_register ty) (fcopysign x (splat y))))
+(rule 2 (lower (has_type (ty_supported_vec ty) (fcopysign _ x (splat _ y))))
   (rv_vfsgnj_vf x y (unmasked) ty))
 
 ;;;; Rules for `fma` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule 0 (lower (has_type (ty_scalar_float ty) (fma x y z)))
-  (rv_fmadd ty x y z))
-
-;; (fma x y z) computes x * y + z
-;; vfmacc computes vd[i] = +(vs1[i] * vs2[i]) + vd[i]
-;; We need to reverse the order of the arguments
-
-(rule 1 (lower (has_type (ty_vec_fits_in_register ty) (fma x y z)))
-  (rv_vfmacc_vv z y x (unmasked) ty))
-
-(rule 2 (lower (has_type (ty_vec_fits_in_register ty) (fma (splat x) y z)))
-  (rv_vfmacc_vf z y x (unmasked) ty))
-
-;; vfmsac computes vd[i] = +(vs1[i] * vs2[i]) - vd[i]
 
-(rule 3 (lower (has_type (ty_vec_fits_in_register ty) (fma x y (fneg z))))
-  (rv_vfmsac_vv z y x (unmasked) ty))
-
-(rule 6 (lower (has_type (ty_vec_fits_in_register ty) (fma (splat x) y (fneg z))))
-  (rv_vfmsac_vf z y x (unmasked) ty))
-
-;; vfnmacc computes vd[i] = -(vs1[i] * vs2[i]) - vd[i]
-
-(rule 4 (lower (has_type (ty_vec_fits_in_register ty) (fma (fneg x) y (fneg z))))
-  (rv_vfnmacc_vv z y x (unmasked) ty))
+;; RISC-V has 4 FMA instructions that do a slightly different computation.
+;;
+;; fmadd:   (rs1 * rs2) + rs3
+;; fmsub:   (rs1 * rs2) - rs3
+;; fnmadd: -(rs1 * rs2) - rs3
+;; fnmsub: -(rs1 * rs2) + rs3
+;;
+;; Additionally there are vector versions of these instructions with slightly different names.
+;; The vector instructions also have two variants each. `.vv` and `.vf`, where `.vv` variants
+;; take two vector operands and the `.vf` variants take a vector operand and a scalar operand.
+;;
+;; Due to this, variation they receive the arguments in a different order. So we need to swap
+;; the arguments below.
+;;
+;; vfmacc:  vd[i] = +(vs1[i] * vs2[i]) + vd[i]
+;; vfmsac:  vd[i] = +(vs1[i] * vs2[i]) - vd[i]
+;; vfnmacc: vd[i] = -(vs1[i] * vs2[i]) - vd[i]
+;; vfnmsac: vd[i] = -(vs1[i] * vs2[i]) + vd[i]
 
-(rule 6 (lower (has_type (ty_vec_fits_in_register ty) (fma (fneg (splat x)) y (fneg z))))
-  (rv_vfnmacc_vf z y x (unmasked) ty))
+(type IsFneg (enum (Result (negate u64) (value Value))))
 
-;; vfnmsac computes vd[i] = -(vs1[i] * vs2[i]) + vd[i]
+(decl pure is_fneg (Value) IsFneg)
+(rule 1 (is_fneg (fneg _ x)) (IsFneg.Result 1 x))
+(rule 0 (is_fneg x) (IsFneg.Result 0 x))
 
-(rule 2 (lower (has_type (ty_vec_fits_in_register ty) (fma (fneg x) y z)))
-  (rv_vfnmsac_vv z y x (unmasked) ty))
+(decl pure is_fneg_neg (IsFneg) u64)
+(rule (is_fneg_neg (IsFneg.Result n _)) n)
 
-(rule 5 (lower (has_type (ty_vec_fits_in_register ty) (fma (fneg (splat x)) y z)))
-  (rv_vfnmsac_vf z y x (unmasked) ty))
+(decl pure get_fneg_value (IsFneg) Value)
+(rule (get_fneg_value (IsFneg.Result _ v)) v)
 
+(rule (lower (has_type ty (fma _ x_src y_src z_src)))
+  (let
+    ((x_res IsFneg (is_fneg x_src))
+     (y_res IsFneg (is_fneg y_src))
+     (z_res IsFneg (is_fneg z_src))
+     (x Value (get_fneg_value x_res))
+     (y Value (get_fneg_value y_res))
+     (z Value (get_fneg_value z_res)))
+    (rv_fma ty (u64_xor (is_fneg_neg x_res) (is_fneg_neg y_res)) (is_fneg_neg z_res) x y z)))
+
+; parity arguments indicate whether to negate the x*y term or the z term, respectively
+(decl rv_fma (Type u64 u64 Value Value Value) InstOutput)
+(rule 0 (rv_fma (ty_supported_float ty) 0 0 x y z) (rv_fmadd ty (FRM.RNE) x y z))
+(rule 0 (rv_fma (ty_supported_float ty) 0 1 x y z) (rv_fmsub ty (FRM.RNE) x y z))
+(rule 0 (rv_fma (ty_supported_float ty) 1 0 x y z) (rv_fnmsub ty (FRM.RNE) x y z))
+(rule 0 (rv_fma (ty_supported_float ty) 1 1 x y z) (rv_fnmadd ty (FRM.RNE) x y z))
+(rule 1 (rv_fma (ty_supported_vec ty) 0 0 x y z) (rv_vfmacc_vv z y x (unmasked) ty))
+(rule 1 (rv_fma (ty_supported_vec ty) 0 1 x y z) (rv_vfmsac_vv z y x (unmasked) ty))
+(rule 1 (rv_fma (ty_supported_vec ty) 1 0 x y z) (rv_vfnmsac_vv z y x (unmasked) ty))
+(rule 1 (rv_fma (ty_supported_vec ty) 1 1 x y z) (rv_vfnmacc_vv z y x (unmasked) ty))
+(rule 2 (rv_fma (ty_supported_vec ty) 0 0 (splat _ x) y z) (rv_vfmacc_vf z y x (unmasked) ty))
+(rule 2 (rv_fma (ty_supported_vec ty) 0 1 (splat _ x) y z) (rv_vfmsac_vf z y x (unmasked) ty))
+(rule 2 (rv_fma (ty_supported_vec ty) 1 0 (splat _ x) y z) (rv_vfnmsac_vf z y x (unmasked) ty))
+(rule 2 (rv_fma (ty_supported_vec ty) 1 1 (splat _ x) y z) (rv_vfnmacc_vf z y x (unmasked) ty))
+(rule 3 (rv_fma (ty_supported_vec ty) 0 0 x (splat _ y) z) (rv_vfmacc_vf z x y (unmasked) ty))
+(rule 3 (rv_fma (ty_supported_vec ty) 0 1 x (splat _ y) z) (rv_vfmsac_vf z x y (unmasked) ty))
+(rule 3 (rv_fma (ty_supported_vec ty) 1 0 x (splat _ y) z) (rv_vfnmsac_vf z x y (unmasked) ty))
+(rule 3 (rv_fma (ty_supported_vec ty) 1 1 x (splat _ y) z) (rv_vfnmacc_vf z x y (unmasked) ty))
 
 ;;;; Rules for `sqrt` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule 0 (lower (has_type (ty_scalar_float ty) (sqrt x)))
-  (rv_fsqrt ty x))
+(rule 0 (lower (has_type (ty_supported_float ty) (sqrt _ x)))
+  (rv_fsqrt ty (FRM.RNE) x))
 
-(rule 1 (lower (has_type (ty_vec_fits_in_register ty) (sqrt x)))
+(rule 1 (lower (has_type (ty_supported_vec ty) (sqrt _ x)))
   (rv_vfsqrt_v x (unmasked) ty))
 
 ;;;; Rules for `AtomicRMW` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 (rule -1
   ;;
   (lower
-    (has_type (valid_atomic_transaction ty) (atomic_rmw flags op addr x)))
+    (has_type (valid_atomic_transaction ty) (atomic_rmw _ flags op addr x)))
   (gen_atomic (get_atomic_rmw_op ty op) addr x (atomic_amo)))
 
 ;;; for I8 and I16
 (rule 1
   (lower
-    (has_type (valid_atomic_transaction (fits_in_16 ty)) (atomic_rmw flags op addr x)))
+    (has_type (valid_atomic_transaction (fits_in_16 ty)) (atomic_rmw _ flags op addr x)))
   (gen_atomic_rmw_loop op ty addr x))
 
 ;;;special for I8 and I16 max min etc.
 ;;;because I need uextend or sextend the value.
 (rule 2
   (lower
-    (has_type (valid_atomic_transaction (fits_in_16 ty)) (atomic_rmw flags (is_atomic_rmw_max_etc op $true) addr x)))
+    (has_type (valid_atomic_transaction (fits_in_16 ty)) (atomic_rmw _ flags (is_atomic_rmw_max_etc op $true) addr x)))
   (gen_atomic_rmw_loop op ty addr (sext x)))
 
 
 (rule 2
   ;;
   (lower
-    (has_type (valid_atomic_transaction (fits_in_16 ty)) (atomic_rmw flags (is_atomic_rmw_max_etc op $false) addr x)))
+    (has_type (valid_atomic_transaction (fits_in_16 ty)) (atomic_rmw _ flags (is_atomic_rmw_max_etc op $false) addr x)))
   ;;
   (gen_atomic_rmw_loop op ty addr (zext x)))
 
 ;;;;;  Rules for `AtomicRmwOp.Sub`
 (rule
   (lower
-    (has_type (valid_atomic_transaction ty) (atomic_rmw flags (AtomicRmwOp.Sub) addr x)))
+    (has_type (valid_atomic_transaction ty) (atomic_rmw _ flags (AtomicRmwOp.Sub) addr x)))
   (let
     ((tmp WritableReg (temp_writable_reg ty))
      (x2 Reg (rv_neg x)))
@@ -1377,7 +1644,7 @@
 ;;;;;  Rules for `AtomicRmwOp.Nand`
 (rule
   (lower
-    (has_type (valid_atomic_transaction ty) (atomic_rmw flags (AtomicRmwOp.Nand) addr x)))
+    (has_type (valid_atomic_transaction ty) (atomic_rmw _ flags (AtomicRmwOp.Nand) addr x)))
     (gen_atomic_rmw_loop (AtomicRmwOp.Nand) ty addr x))
 
 (decl is_atomic_rmw_max_etc (AtomicRmwOp bool) AtomicRmwOp)
@@ -1385,7 +1652,7 @@
 
 ;;;;;  Rules for `atomic load`;;;;;;;;;;;;;;;;;
 (rule
-  (lower (has_type (valid_atomic_transaction ty) (atomic_load flags p)))
+  (lower (has_type (valid_atomic_transaction ty) (atomic_load _ flags p)))
   (gen_atomic_load p ty))
 
 
@@ -1411,7 +1678,7 @@
 
 ;;;;;  Rules for `atomic cas`;;;;;;;;;;;;;;;;;
 (rule
-  (lower (has_type (valid_atomic_transaction ty) (atomic_cas flags p e x)))
+  (lower (has_type (valid_atomic_transaction ty) (atomic_cas _ flags p e x)))
   (let
     ((t0 WritableReg (temp_writable_reg ty))
       (dst WritableReg (temp_writable_reg ty))
@@ -1420,28 +1687,28 @@
 
 ;;;;;  Rules for `ireduce`;;;;;;;;;;;;;;;;;
 (rule
-  (lower (has_type ty (ireduce x)))
+  (lower (has_type ty (ireduce _ x)))
   (value_regs_get x 0))
 
 ;;;;;  Rules for `fpromote`;;;;;;;;;;;;;;;;;
-(rule (lower (fpromote x))
+(rule (lower (fpromote _ x))
   (rv_fcvtds x))
 
 ;;;;;  Rules for `fvpromote_low`;;;;;;;;;;;;
 
-(rule (lower (has_type (ty_vec_fits_in_register ty) (fvpromote_low x)))
+(rule (lower (has_type (ty_supported_vec ty) (fvpromote_low _ x)))
   (if-let half_ty (ty_half_width ty))
   (rv_vfwcvt_f_f_v x (unmasked) (vstate_mf2 half_ty)))
 
 ;;;;;  Rules for `fdemote`;;;;;;;;;;;;;;;;;;
-(rule (lower (fdemote x))
-  (rv_fcvtsd x))
+(rule (lower (fdemote _ x))
+  (rv_fcvtsd (FRM.RNE) x))
 
 ;;;;;  Rules for `fvdemote`;;;;;;;;;;;;;;;;;
 
 ;; `vfncvt...` leaves the upper bits of the register undefined so
 ;; we need to zero them out.
-(rule (lower (has_type (ty_vec_fits_in_register ty @ $F32X4) (fvdemote x)))
+(rule (lower (has_type (ty_supported_vec ty @ $F32X4) (fvdemote _ x)))
   (if-let zero (i8_to_imm5 0))
   (let ((narrow VReg (rv_vfncvt_f_f_w x (unmasked) (vstate_mf2 ty)))
         (mask VReg (gen_vec_mask 0xC)))
@@ -1453,63 +1720,77 @@
 
 ;;;; Rules for `fadd` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 0 (lower (has_type (ty_scalar_float ty) (fadd x y)))
-  (rv_fadd ty x y))
+(rule 0 (lower (has_type (ty_supported_float ty) (fadd _ x y)))
+  (rv_fadd ty (FRM.RNE) x y))
 
-(rule 1 (lower (has_type (ty_vec_fits_in_register ty) (fadd x y)))
+(rule 1 (lower (has_type (ty_supported_vec ty) (fadd _ x y)))
   (rv_vfadd_vv x y (unmasked) ty))
 
-(rule 2 (lower (has_type (ty_vec_fits_in_register ty) (fadd x (splat y))))
+(rule 2 (lower (has_type (ty_supported_vec ty) (fadd _ x (splat _ y))))
   (rv_vfadd_vf x y (unmasked) ty))
 
-(rule 3 (lower (has_type (ty_vec_fits_in_register ty) (fadd (splat x) y)))
+(rule 3 (lower (has_type (ty_supported_vec ty) (fadd _ (splat _ x) y)))
   (rv_vfadd_vf y x (unmasked) ty))
 
 
 ;;;; Rules for `fsub` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule 0 (lower (has_type (ty_scalar_float ty) (fsub x y)))
-  (rv_fsub ty x y))
+(rule 0 (lower (has_type (ty_supported_float ty) (fsub _ x y)))
+  (rv_fsub ty (FRM.RNE) x y))
 
-(rule 1 (lower (has_type (ty_vec_fits_in_register ty) (fsub x y)))
+(rule 1 (lower (has_type (ty_supported_vec ty) (fsub _ x y)))
   (rv_vfsub_vv x y (unmasked) ty))
 
-(rule 2 (lower (has_type (ty_vec_fits_in_register ty) (fsub x (splat y))))
+(rule 2 (lower (has_type (ty_supported_vec ty) (fsub _ x (splat _ y))))
   (rv_vfsub_vf x y (unmasked) ty))
 
-(rule 3 (lower (has_type (ty_vec_fits_in_register ty) (fsub (splat x) y)))
+(rule 3 (lower (has_type (ty_supported_vec ty) (fsub _ (splat _ x) y)))
   (rv_vfrsub_vf y x (unmasked) ty))
 
 ;;;; Rules for `fmul` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule 0 (lower (has_type (ty_scalar_float ty) (fmul x y)))
-  (rv_fmul ty x y))
+(rule 0 (lower (has_type (ty_supported_float ty) (fmul _ x y)))
+  (rv_fmul ty (FRM.RNE) x y))
 
-(rule 1 (lower (has_type (ty_vec_fits_in_register ty) (fmul x y)))
+(rule 1 (lower (has_type (ty_supported_vec ty) (fmul _ x y)))
   (rv_vfmul_vv x y (unmasked) ty))
 
-(rule 2 (lower (has_type (ty_vec_fits_in_register ty) (fmul x (splat y))))
+(rule 2 (lower (has_type (ty_supported_vec ty) (fmul _ x (splat _ y))))
   (rv_vfmul_vf x y (unmasked) ty))
 
-(rule 3 (lower (has_type (ty_vec_fits_in_register ty) (fmul (splat x) y)))
+(rule 3 (lower (has_type (ty_supported_vec ty) (fmul _ (splat _ x) y)))
   (rv_vfmul_vf y x (unmasked) ty))
 
 
 ;;;; Rules for `fdiv` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule 0 (lower (has_type (ty_scalar_float ty) (fdiv x y)))
-  (rv_fdiv ty x y))
+(rule 0 (lower (has_type (ty_supported_float ty) (fdiv _ x y)))
+  (rv_fdiv ty (FRM.RNE) x y))
 
-(rule 1 (lower (has_type (ty_vec_fits_in_register ty) (fdiv x y)))
+(rule 1 (lower (has_type (ty_supported_vec ty) (fdiv _ x y)))
   (rv_vfdiv_vv x y (unmasked) ty))
 
-(rule 2 (lower (has_type (ty_vec_fits_in_register ty) (fdiv x (splat y))))
+(rule 2 (lower (has_type (ty_supported_vec ty) (fdiv _ x (splat _ y))))
   (rv_vfdiv_vf x y (unmasked) ty))
 
-(rule 3 (lower (has_type (ty_vec_fits_in_register ty) (fdiv (splat x) y)))
+(rule 3 (lower (has_type (ty_supported_vec ty) (fdiv _ (splat _ x) y)))
   (rv_vfrdiv_vf y x (unmasked) ty))
 
 ;;;; Rules for `fmin` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 0 (lower (has_type (ty_scalar_float ty) (fmin x y)))
-  (gen_float_select (FloatSelectOP.Min) x y ty))
+;; RISC-V's `fmin` instruction returns the number input if one of inputs is a
+;; NaN. We handle this by manually checking if one of the inputs is a NaN
+;; and selecting based on that result.
+(rule 0 (lower (has_type (ty_supported_float ty) (fmin _ x y)))
+  (let (;; Check if both inputs are not nan.
+        (is_ordered FloatCompare (fcmp_to_float_compare (FloatCC.Ordered) ty x y))
+        ;; `fadd` returns a nan if any of the inputs is a NaN.
+        (nan FReg (rv_fadd ty (FRM.RNE) x y))
+        (min FReg (rv_fmin ty x y)))
+    (gen_select_freg is_ordered min nan)))
+
+;; With Zfa we can use the special `fminm` that precisely matches the expected
+;; NaN behavior.
+(rule 1 (lower (has_type (ty_supported_float ty) (fmin _ x y)))
+  (if-let $true (has_zfa))
+  (rv_fminm ty x y))
 
 ;; vfmin does almost the right thing, but it does not handle NaN's correctly.
 ;; We should return a NaN if any of the inputs is a NaN, but vfmin returns the
@@ -1517,7 +1798,7 @@
 ;;
 ;; TODO: We can improve this by using a masked `fmin` instruction that modifies
 ;; the canonical nan register. That way we could avoid the `vmerge.vv` instruction.
-(rule 1 (lower (has_type (ty_vec_fits_in_register ty) (fmin x y)))
+(rule 2 (lower (has_type (ty_supported_vec ty) (fmin _ x y)))
   (let ((is_not_nan VReg (gen_fcmp_mask ty (FloatCC.Ordered) x y))
         (nan XReg (imm $I64 (canonical_nan_u64 (lane_type ty))))
         (vec_nan VReg (rv_vmv_vx nan ty))
@@ -1526,8 +1807,22 @@
 
 ;;;; Rules for `fmax` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 0 (lower (has_type (ty_scalar_float ty) (fmax x y)))
-  (gen_float_select (FloatSelectOP.Max) x y ty))
+;; RISC-V's `fmax` instruction returns the number input if one of inputs is a
+;; NaN. We handle this by manually checking if one of the inputs is a NaN
+;; and selecting based on that result.
+(rule 0 (lower (has_type (ty_supported_float ty) (fmax _ x y)))
+  (let (;; Check if both inputs are not nan.
+        (is_ordered FloatCompare (fcmp_to_float_compare (FloatCC.Ordered) ty x y))
+        ;; `fadd` returns a NaN if any of the inputs is a NaN.
+        (nan FReg (rv_fadd ty (FRM.RNE) x y))
+        (max FReg (rv_fmax ty x y)))
+    (gen_select_freg is_ordered max nan)))
+
+;; With Zfa we can use the special `fmaxm` that precisely matches the expected
+;; NaN behavior.
+(rule 1 (lower (has_type (ty_supported_float ty) (fmax _ x y)))
+  (if-let $true (has_zfa))
+  (rv_fmaxm ty x y))
 
 ;; vfmax does almost the right thing, but it does not handle NaN's correctly.
 ;; We should return a NaN if any of the inputs is a NaN, but vfmax returns the
@@ -1535,7 +1830,7 @@
 ;;
 ;; TODO: We can improve this by using a masked `fmax` instruction that modifies
 ;; the canonical nan register. That way we could avoid the `vmerge.vv` instruction.
-(rule 1 (lower (has_type (ty_vec_fits_in_register ty) (fmax x y)))
+(rule 2 (lower (has_type (ty_supported_vec ty) (fmax _ x y)))
   (let ((is_not_nan VReg (gen_fcmp_mask ty (FloatCC.Ordered) x y))
         (nan XReg (imm $I64 (canonical_nan_u64 (lane_type ty))))
         (vec_nan VReg (rv_vmv_vx nan ty))
@@ -1544,38 +1839,37 @@
 
 ;;;;;  Rules for `stack_addr`;;;;;;;;;
 (rule
-  (lower (stack_addr ss offset))
+  (lower (stack_addr _ ss offset))
   (gen_stack_addr ss offset))
 
-;;;;;  Rules for `is_null`;;;;;;;;;
-
-;; Null references are represented by the constant value `0`.
-(rule (lower (is_null v))
-  (rv_seqz v))
+;;;;;  Rules for `select`;;;;;;;;;
 
-;;;;;  Rules for `is_invalid`;;;;;;;;;
+;; Manually matching (iconst 0) here is a bit of a hack. We can't do that as part
+;; of the iconst rule because that runs into regalloc issues. gen_select_xreg
+;; has some optimizations based on the use of the zero register so we have to
+;; manually match it here.
+(rule 5 (lower (has_type (ty_int_ref_scalar_64 _) (select _ c (i64_from_iconst 0) y)))
+  (gen_select_xreg (is_nonzero_cmp c) (zero_reg) y))
 
-;; Invalid references are represented by the constant value `-1`.
-(rule (lower (is_invalid v))
-  (rv_seqz (rv_addi v (imm12_const 1))))
+(rule 4 (lower (has_type (ty_int_ref_scalar_64 _) (select _ c x (i64_from_iconst 0))))
+  (gen_select_xreg (is_nonzero_cmp c) x (zero_reg)))
 
-;;;;;  Rules for `select`;;;;;;;;;
-(rule 0 (lower (has_type (ty_int_ref_scalar_64 _) (select c x y)))
-  (gen_select_xreg (lower_int_compare c) x y))
+(rule 3 (lower (has_type (ty_int_ref_scalar_64 _) (select _ c x y)))
+  (gen_select_xreg (is_nonzero_cmp c) x y))
 
-(rule 1 (lower (has_type $I128 (select c x y)))
-  (gen_select_regs (lower_int_compare c) x y))
+(rule 2 (lower (has_type $I128 (select _ c x y)))
+  (gen_select_regs (is_nonzero_cmp c) x y))
 
-(rule 2 (lower (has_type (ty_vec_fits_in_register _) (select c x y)))
-  (gen_select_vreg (lower_int_compare c) x y))
+(rule 1 (lower (has_type (ty_supported_vec _) (select _ c x y)))
+  (gen_select_vreg (is_nonzero_cmp c) x y))
 
-(rule 3 (lower (has_type (ty_scalar_float _) (select c x y)))
-  (gen_select_freg (lower_int_compare c) x y))
+(rule 0 (lower (has_type (ty_supported_float _) (select _ c x y)))
+  (gen_select_freg (is_nonzero_cmp c) x y))
 
 ;;;;;  Rules for `bitselect`;;;;;;;;;
 
 ;; Do a (c & x) | (~c & y) operation.
-(rule 0 (lower (has_type (ty_int_ref_scalar_64 ty) (bitselect c x y)))
+(rule 0 (lower (has_type (ty_int_ref_scalar_64 ty) (bitselect _ c x y)))
   (let ((tmp_x XReg (rv_and c x))
         (c_inverse XReg (rv_not c))
         (tmp_y XReg (rv_and c_inverse y)))
@@ -1584,9 +1878,9 @@
 ;; For vectors, we also do the same operation.
 ;; We can technically use any type in the bitwise operations, but prefer
 ;; using the type of the inputs so that we avoid emitting unnecessary
-;; `vsetvl` instructions. it's likeley that the vector unit is already
+;; `vsetvl` instructions. it's likely that the vector unit is already
 ;; configured for that type.
-(rule 1 (lower (has_type (ty_vec_fits_in_register ty) (bitselect c x y)))
+(rule 1 (lower (has_type (ty_supported_vec ty) (bitselect _ c x y)))
   (let ((tmp_x VReg (rv_vand_vv c x (unmasked) ty))
         (c_inverse VReg (rv_vnot_v c (unmasked) ty))
         (tmp_y VReg (rv_vand_vv c_inverse y (unmasked) ty)))
@@ -1596,26 +1890,34 @@
 ;;
 ;; This allows us to skip the mask expansion step and use the more efficient
 ;; vmerge.vvm instruction.
-(rule 2 (lower (has_type (ty_vec_fits_in_register ty) (bitselect (icmp cc a @ (value_type (ty_vec_fits_in_register cmp_ty)) b) x y)))
+;;
+;; We should be careful to ensure that the mask and the vmerge have the
+;; same type. So that we don't generate a mask with length 16 (i.e. for i8x16), and then
+;; only copy the first few lanes of the result to the destination register because
+;; the bitselect has a different length (i.e. i64x2).
+;;
+;; See: https://github.com/bytecodealliance/wasmtime/issues/8131
+
+(rule 2 (lower (has_type (ty_supported_vec _ty) (bitselect _ (icmp _ cc a @ (value_type (ty_supported_vec cmp_ty)) b) x y)))
   (let ((mask VReg (gen_icmp_mask cmp_ty cc a b)))
-    (rv_vmerge_vvm y x mask ty)))
+    (rv_vmerge_vvm y x mask cmp_ty)))
 
-(rule 2 (lower (has_type (ty_vec_fits_in_register ty) (bitselect (fcmp cc a @ (value_type (ty_vec_fits_in_register cmp_ty)) b) x y)))
+(rule 2 (lower (has_type (ty_supported_vec _ty) (bitselect _ (fcmp _ cc a @ (value_type (ty_supported_vec cmp_ty)) b) x y)))
   (let ((mask VReg (gen_fcmp_mask cmp_ty cc a b)))
-    (rv_vmerge_vvm y x mask ty)))
+    (rv_vmerge_vvm y x mask cmp_ty)))
 
-(rule 2 (lower (has_type (ty_vec_fits_in_register ty) (bitselect (bitcast _ (fcmp cc a @ (value_type (ty_vec_fits_in_register cmp_ty)) b)) x y)))
+(rule 2 (lower (has_type (ty_supported_vec _ty) (bitselect _ (bitcast _ _ (fcmp _ cc a @ (value_type (ty_supported_vec cmp_ty)) b)) x y)))
   (let ((mask VReg (gen_fcmp_mask cmp_ty cc a b)))
-    (rv_vmerge_vvm y x mask ty)))
+    (rv_vmerge_vvm y x mask cmp_ty)))
 
-(rule 2 (lower (has_type (ty_vec_fits_in_register ty) (bitselect (bitcast _ (icmp cc a @ (value_type (ty_vec_fits_in_register cmp_ty)) b)) x y)))
+(rule 2 (lower (has_type (ty_supported_vec _ty) (bitselect _ (bitcast _ _ (icmp _ cc a @ (value_type (ty_supported_vec cmp_ty)) b)) x y)))
   (let ((mask VReg (gen_icmp_mask cmp_ty cc a b)))
-    (rv_vmerge_vvm y x mask ty)))
+    (rv_vmerge_vvm y x mask cmp_ty)))
 
 
 ;;;;;  Rules for `isplit`;;;;;;;;;
 (rule
-  (lower (isplit x))
+  (lower (isplit _ x))
   (let
     ((t1 XReg (value_regs_get x 0))
       (t2 XReg (value_regs_get x 1)))
@@ -1623,7 +1925,7 @@
 
 ;;;;;  Rules for `iconcat`;;;;;;;;;
 (rule
-  (lower (has_type $I128 (iconcat x y)))
+  (lower (has_type $I128 (iconcat _ x y)))
   (let
     ((t1 XReg x)
       (t2 XReg y))
@@ -1632,78 +1934,78 @@
 
 ;;;;;  Rules for `smax`;;;;;;;;;
 
-(rule 0 (lower (has_type (fits_in_64 ty) (smax x y)))
+(rule 0 (lower (has_type (fits_in_64 ty) (smax _ x y)))
   (let ((x XReg (sext x))
         (y XReg (sext y)))
     (gen_select_xreg (cmp_gt x y) x y)))
 
-(rule 1 (lower (has_type $I128 (smax x y)))
-  (gen_select_regs (cmp_nez (gen_icmp (IntCC.SignedGreaterThan) x y $I128)) x y))
+(rule 1 (lower (has_type $I128 (smax _ x y)))
+  (gen_select_regs (icmp_to_int_compare (IntCC.SignedGreaterThan) x y) x y))
 
-(rule 2 (lower (has_type (ty_vec_fits_in_register ty) (smax x y)))
+(rule 2 (lower (has_type (ty_supported_vec ty) (smax _ x y)))
   (rv_vmax_vv x y (unmasked) ty))
 
-(rule 3 (lower (has_type (ty_vec_fits_in_register ty) (smax x (splat y))))
+(rule 3 (lower (has_type (ty_supported_vec ty) (smax _ x (splat _ y))))
   (rv_vmax_vx x y (unmasked) ty))
 
-(rule 4 (lower (has_type (ty_vec_fits_in_register ty) (smax (splat x) y)))
+(rule 4 (lower (has_type (ty_supported_vec ty) (smax _ (splat _ x) y)))
   (rv_vmax_vx y x (unmasked) ty))
 
 ;;;;;  Rules for `smin`;;;;;;;;;
 
-(rule 0 (lower (has_type (fits_in_64 ty) (smin x y)))
+(rule 0 (lower (has_type (fits_in_64 ty) (smin _ x y)))
   (let ((x XReg (sext x))
         (y XReg (sext y)))
     (gen_select_xreg (cmp_lt x y) x y)))
 
-(rule 1 (lower (has_type $I128 (smin x y)))
-  (gen_select_regs (cmp_nez (gen_icmp (IntCC.SignedLessThan) x y $I128)) x y))
+(rule 1 (lower (has_type $I128 (smin _ x y)))
+  (gen_select_regs (icmp_to_int_compare (IntCC.SignedLessThan) x y) x y))
 
-(rule 2 (lower (has_type (ty_vec_fits_in_register ty) (smin x y)))
+(rule 2 (lower (has_type (ty_supported_vec ty) (smin _ x y)))
   (rv_vmin_vv x y (unmasked) ty))
 
-(rule 3 (lower (has_type (ty_vec_fits_in_register ty) (smin x (splat y))))
+(rule 3 (lower (has_type (ty_supported_vec ty) (smin _ x (splat _ y))))
   (rv_vmin_vx x y (unmasked) ty))
 
-(rule 4 (lower (has_type (ty_vec_fits_in_register ty) (smin (splat x) y)))
+(rule 4 (lower (has_type (ty_supported_vec ty) (smin _ (splat _ x) y)))
   (rv_vmin_vx y x (unmasked) ty))
 
 ;;;;;  Rules for `umax`;;;;;;;;;
 
-(rule 0 (lower (has_type (fits_in_64 ty) (umax x y)))
+(rule 0 (lower (has_type (fits_in_64 ty) (umax _ x y)))
   (let ((x XReg (zext x))
         (y XReg (zext y)))
     (gen_select_xreg (cmp_gtu x y) x y)))
 
-(rule 1 (lower (has_type $I128 (umax x y)))
-  (gen_select_regs (cmp_nez (gen_icmp (IntCC.UnsignedGreaterThan) x y $I128)) x y))
+(rule 1 (lower (has_type $I128 (umax _ x y)))
+  (gen_select_regs (icmp_to_int_compare (IntCC.UnsignedGreaterThan) x y) x y))
 
-(rule 2 (lower (has_type (ty_vec_fits_in_register ty) (umax x y)))
+(rule 2 (lower (has_type (ty_supported_vec ty) (umax _ x y)))
   (rv_vmaxu_vv x y (unmasked) ty))
 
-(rule 3 (lower (has_type (ty_vec_fits_in_register ty) (umax x (splat y))))
+(rule 3 (lower (has_type (ty_supported_vec ty) (umax _ x (splat _ y))))
   (rv_vmaxu_vx x y (unmasked) ty))
 
-(rule 4 (lower (has_type (ty_vec_fits_in_register ty) (umax (splat x) y)))
+(rule 4 (lower (has_type (ty_supported_vec ty) (umax _ (splat _ x) y)))
   (rv_vmaxu_vx y x (unmasked) ty))
 
 ;;;;;  Rules for `umin`;;;;;;;;;
 
-(rule 0 (lower (has_type (fits_in_64 ty) (umin x y)))
+(rule 0 (lower (has_type (fits_in_64 ty) (umin _ x y)))
   (let ((x XReg (zext x))
         (y XReg (zext y)))
     (gen_select_xreg (cmp_ltu x y) x y)))
 
-(rule 1 (lower (has_type $I128 (umin x y)))
-  (gen_select_regs (cmp_nez (gen_icmp (IntCC.UnsignedLessThan) x y $I128)) x y))
+(rule 1 (lower (has_type $I128 (umin _ x y)))
+  (gen_select_regs (icmp_to_int_compare (IntCC.UnsignedLessThan) x y) x y))
 
-(rule 2 (lower (has_type (ty_vec_fits_in_register ty) (umin x y)))
+(rule 2 (lower (has_type (ty_supported_vec ty) (umin _ x y)))
   (rv_vminu_vv x y (unmasked) ty))
 
-(rule 3 (lower (has_type (ty_vec_fits_in_register ty) (umin x (splat y))))
+(rule 3 (lower (has_type (ty_supported_vec ty) (umin _ x (splat _ y))))
   (rv_vminu_vx x y (unmasked) ty))
 
-(rule 4 (lower (has_type (ty_vec_fits_in_register ty) (umin (splat x) y)))
+(rule 4 (lower (has_type (ty_supported_vec ty) (umin _ (splat _ x) y)))
   (rv_vminu_vx y x (unmasked) ty))
 
 
@@ -1722,48 +2024,43 @@
   (lower (trap code))
   (udf code))
 
-;;;;;  Rules for `resumable_trap`;;;;;;;;;
-(rule
-  (lower (resumable_trap code))
-  (udf code))
-
 ;;;;;  Rules for `uload8`;;;;;;;;;
-(rule (lower (uload8 flags addr offset))
-  (gen_load (amode addr offset $I8) (LoadOP.Lbu) flags))
+(rule (lower (uload8 _ flags addr offset))
+  (gen_load (amode addr offset) (LoadOP.Lbu) flags))
 
 ;;;;;  Rules for `sload8`;;;;;;;;;
-(rule (lower (sload8 flags addr offset))
-  (gen_load (amode addr offset $I8) (LoadOP.Lb) flags))
+(rule (lower (sload8 _ flags addr offset))
+  (gen_load (amode addr offset) (LoadOP.Lb) flags))
 
 ;;;;;  Rules for `uload16`;;;;;;;;;
-(rule (lower (uload16 flags addr offset))
-  (gen_load (amode addr offset $I16) (LoadOP.Lhu) flags))
+(rule (lower (uload16 _ flags addr offset))
+  (gen_load (amode addr offset) (LoadOP.Lhu) flags))
 
 ;;;;;  Rules for `iload16`;;;;;;;;;
-(rule (lower (sload16 flags addr offset))
-  (gen_load (amode addr offset $I16) (LoadOP.Lh) flags))
+(rule (lower (sload16 _ flags addr offset))
+  (gen_load (amode addr offset) (LoadOP.Lh) flags))
 
 ;;;;;  Rules for `uload32`;;;;;;;;;
-(rule (lower (uload32 flags addr offset))
-  (gen_load (amode addr offset $I32) (LoadOP.Lwu) flags))
+(rule (lower (uload32 _ flags addr offset))
+  (gen_load (amode addr offset) (LoadOP.Lwu) flags))
 
 ;;;;;  Rules for `sload32`;;;;;;;;;
-(rule (lower (sload32 flags addr offset))
-  (gen_load (amode addr offset $I32) (LoadOP.Lw) flags))
+(rule (lower (sload32 _ flags addr offset))
+  (gen_load (amode addr offset) (LoadOP.Lw) flags))
 
 ;;;;;  Rules for `load`;;;;;;;;;
-(rule (lower (has_type ty (load flags addr offset)))
-  (gen_load (amode addr offset ty) (load_op ty) flags))
+(rule (lower (has_type ty (load _ flags addr offset)))
+  (gen_load (amode addr offset) (load_op ty) flags))
 
-(rule 1 (lower (has_type $I128 (load flags addr offset)))
+(rule 1 (lower (has_type $I128 (load _ flags addr offset)))
   (if-let offset_plus_8 (s32_add_fallible offset 8))
-  (let ((lo XReg (gen_load (amode addr offset $I64) (LoadOP.Ld) flags))
-        (hi XReg (gen_load (amode addr offset_plus_8 $I64) (LoadOP.Ld) flags)))
+  (let ((lo XReg (gen_load (amode addr offset) (LoadOP.Ld) flags))
+        (hi XReg (gen_load (amode addr offset_plus_8) (LoadOP.Ld) flags)))
     (value_regs lo hi)))
 
-(rule 2 (lower (has_type (ty_vec_fits_in_register ty) (load flags addr offset)))
+(rule 2 (lower (has_type (ty_supported_vec ty) (load _ flags addr offset)))
   (let ((eew VecElementWidth (element_width_from_type ty))
-        (amode AMode (amode addr offset ty)))
+        (amode AMode (amode addr offset)))
     (vec_load eew (VecAMode.UnitStride amode) flags (unmasked) ty)))
 
 ;;;;;  Rules for Load + Extend Combos ;;;;;;;;;
@@ -1788,210 +2085,431 @@
     (rv_vzext_vf2 loaded (unmasked) ty)))
 
 ;;;;;  Rules for `uload8x8`;;;;;;;;;;
-(rule (lower (has_type (ty_vec_fits_in_register ty @ $I16X8) (uload8x8 flags addr offset)))
-  (gen_load64_extend ty (ExtendOp.Zero) flags (amode addr offset ty)))
+(rule (lower (has_type (ty_supported_vec ty @ $I16X8) (uload8x8 _ flags addr offset)))
+  (gen_load64_extend ty (ExtendOp.Zero) flags (amode addr offset)))
 
 ;;;;;  Rules for `uload16x4`;;;;;;;;;
-(rule (lower (has_type (ty_vec_fits_in_register ty @ $I32X4) (uload16x4 flags addr offset)))
-  (gen_load64_extend ty (ExtendOp.Zero) flags (amode addr offset ty)))
+(rule (lower (has_type (ty_supported_vec ty @ $I32X4) (uload16x4 _ flags addr offset)))
+  (gen_load64_extend ty (ExtendOp.Zero) flags (amode addr offset)))
 
 ;;;;;  Rules for `uload32x2`;;;;;;;;;
-(rule (lower (has_type (ty_vec_fits_in_register ty @ $I64X2) (uload32x2 flags addr offset)))
-  (gen_load64_extend ty (ExtendOp.Zero) flags (amode addr offset ty)))
+(rule (lower (has_type (ty_supported_vec ty @ $I64X2) (uload32x2 _ flags addr offset)))
+  (gen_load64_extend ty (ExtendOp.Zero) flags (amode addr offset)))
 
 ;;;;;  Rules for `sload8x8`;;;;;;;;;;
-(rule (lower (has_type (ty_vec_fits_in_register ty @ $I16X8) (sload8x8 flags addr offset)))
-  (gen_load64_extend ty (ExtendOp.Signed) flags (amode addr offset ty)))
+(rule (lower (has_type (ty_supported_vec ty @ $I16X8) (sload8x8 _ flags addr offset)))
+  (gen_load64_extend ty (ExtendOp.Signed) flags (amode addr offset)))
 
 ;;;;;  Rules for `sload16x4`;;;;;;;;;
-(rule (lower (has_type (ty_vec_fits_in_register ty @ $I32X4) (sload16x4 flags addr offset)))
-  (gen_load64_extend ty (ExtendOp.Signed) flags (amode addr offset ty)))
+(rule (lower (has_type (ty_supported_vec ty @ $I32X4) (sload16x4 _ flags addr offset)))
+  (gen_load64_extend ty (ExtendOp.Signed) flags (amode addr offset)))
 
 ;;;;;  Rules for `sload32x2`;;;;;;;;;
-(rule (lower (has_type (ty_vec_fits_in_register ty @ $I64X2) (sload32x2 flags addr offset)))
-  (gen_load64_extend ty (ExtendOp.Signed) flags (amode addr offset ty)))
+(rule (lower (has_type (ty_supported_vec ty @ $I64X2) (sload32x2 _ flags addr offset)))
+  (gen_load64_extend ty (ExtendOp.Signed) flags (amode addr offset)))
 
 ;;;;;  Rules for `istore8`;;;;;;;;;
 (rule (lower (istore8 flags src addr offset))
-  (gen_store (amode addr offset $I8) (StoreOP.Sb) flags src))
+  (rv_store (amode addr offset) (StoreOP.Sb) flags src))
 
 ;;;;;  Rules for `istore16`;;;;;;;;;
 (rule (lower (istore16 flags src addr offset))
-  (gen_store (amode addr offset $I16) (StoreOP.Sh) flags src))
+  (rv_store (amode addr offset) (StoreOP.Sh) flags src))
 
 ;;;;;  Rules for `istore32`;;;;;;;;;
 (rule (lower (istore32 flags src addr offset))
-  (gen_store (amode addr offset $I32) (StoreOP.Sw) flags src))
+  (rv_store (amode addr offset) (StoreOP.Sw) flags src))
 
 ;;;;;  Rules for `store`;;;;;;;;;
 (rule (lower (store flags src @ (value_type ty) addr offset))
-  (gen_store (amode addr offset ty) (store_op ty) flags src))
+  (gen_store (amode addr offset) flags src))
 
 (rule 1 (lower (store flags src @ (value_type $I128) addr offset))
   (if-let offset_plus_8 (s32_add_fallible offset 8))
-  (let ((_ InstOutput (gen_store (amode addr offset $I64) (StoreOP.Sd) flags (value_regs_get src 0))))
-    (gen_store (amode addr offset_plus_8 $I64) (StoreOP.Sd) flags (value_regs_get src 1))))
+  (let ((_ InstOutput (rv_store (amode addr offset) (StoreOP.Sd) flags (value_regs_get src 0))))
+    (rv_store (amode addr offset_plus_8) (StoreOP.Sd) flags (value_regs_get src 1))))
 
-(rule 2 (lower (store flags src @ (value_type (ty_vec_fits_in_register ty)) addr offset))
+(rule 2 (lower (store flags src @ (value_type (ty_supported_vec ty)) addr offset))
   (let ((eew VecElementWidth (element_width_from_type ty))
-        (amode AMode (amode addr offset ty)))
+        (amode AMode (amode addr offset)))
     (vec_store eew (VecAMode.UnitStride amode) src flags (unmasked) ty)))
 
 
 ;;;;;  Rules for `icmp`;;;;;;;;;
 
-(decl gen_icmp (IntCC ValueRegs ValueRegs Type) XReg)
-(rule
-  (gen_icmp cc x y ty)
-  (let
-    ((result WritableXReg (temp_writable_xreg))
-      (_ Unit (emit (MInst.Icmp cc result x y ty))))
-    result))
-
-(rule 0 (lower (icmp cc x @ (value_type (ty_int ty)) y))
-  (gen_icmp cc (zext x) (zext y) ty))
-
-(rule 1 (lower (icmp cc x @ (value_type (ty_int ty)) y))
-  (if (signed_cond_code cc))
-  (gen_icmp cc (sext x) (sext y) ty))
-
-(rule 2 (lower (icmp cc x @ (value_type $I128) y))
-  (gen_icmp cc x y $I128))
-
-(rule 3 (lower (icmp cc x @ (value_type (ty_vec_fits_in_register ty)) y))
+;; 8-64 bit comparisons. Mostly fall back onto `IntegerCompare` and then
+;; materializing that, but before that happens try to match some
+;; constant-related patterns
+
+(rule 0 (lower (icmp _ cc x @ (value_type (fits_in_64 ty)) y))
+  (lower_icmp cc x y))
+
+(decl lower_icmp (IntCC Value Value) XReg)
+(rule 0 (lower_icmp cc x y)
+  (lower_int_compare (icmp_to_int_compare cc x y)))
+
+;; a == $imm => seqz(xori(..))
+(rule 1 (lower_icmp (IntCC.Equal) x y)
+  (if-let (i64_from_iconst (i64_nonzero (imm12_from_i64 imm))) y)
+  (rv_seqz (rv_xori (sext x) imm)))
+(rule 2 (lower_icmp (IntCC.Equal) x y)
+  (if-let (i64_from_iconst (i64_nonzero (imm12_from_i64 imm))) x)
+  (rv_seqz (rv_xori (sext y) imm)))
+
+;; a != $imm => snez(xori(..))
+(rule 1 (lower_icmp (IntCC.NotEqual) x y)
+  (if-let (i64_from_iconst (i64_nonzero (imm12_from_i64 imm))) y)
+  (rv_snez (rv_xori (sext x) imm)))
+(rule 2 (lower_icmp (IntCC.NotEqual) x y)
+  (if-let (i64_from_iconst (i64_nonzero (imm12_from_i64 imm))) x)
+  (rv_snez (rv_xori (sext y) imm)))
+
+;; a < $imm => slti(..)
+(rule 1 (lower_icmp (IntCC.SignedLessThan) x y)
+  (if-let (i64_from_iconst (i64_nonzero (imm12_from_i64 imm))) y)
+  (rv_slti (sext x) imm))
+(rule 1 (lower_icmp (IntCC.SignedGreaterThan) x y)
+  (if-let (i64_from_iconst (i64_nonzero (imm12_from_i64 imm))) x)
+  (rv_slti (sext y) imm))
+(rule 1 (lower_icmp (IntCC.UnsignedLessThan) x y)
+  (if-let (u64_from_iconst (u64_nonzero (imm12_from_u64 imm))) y)
+  (rv_sltiu (zext x) imm))
+(rule 1 (lower_icmp (IntCC.UnsignedGreaterThan) x y)
+  (if-let (u64_from_iconst (u64_nonzero (imm12_from_u64 imm))) x)
+  (rv_sltiu (zext y) imm))
+
+;; a >= $imm => !(a < $imm)
+(rule 2 (lower_icmp cc @ (IntCC.SignedGreaterThanOrEqual) x y)
+  (if-let (i64_from_iconst (i64_nonzero (imm12_from_i64 _))) y)
+  (rv_xori (lower_icmp (intcc_complement cc) x y) (imm12_const 1)))
+(rule 2 (lower_icmp cc @ (IntCC.UnsignedGreaterThanOrEqual) x y)
+  (if-let (u64_from_iconst (u64_nonzero (imm12_from_u64 _))) y)
+  (rv_xori (lower_icmp (intcc_complement cc) x y) (imm12_const 1)))
+
+;; Materializes an `IntegerCompare` bundle directly into an `XReg` with a 0
+;; or 1 value.
+(decl lower_int_compare (IntegerCompare) XReg)
+
+;; x == y => x ^ y == 0
+(rule 0 (lower_int_compare (int_compare_decompose (IntCC.Equal) x y))
+  (rv_seqz (rv_xor x y)))
+(rule 1 (lower_int_compare (int_compare_decompose (IntCC.Equal) x (zero_reg)))
+  (rv_seqz x))
+(rule 2 (lower_int_compare (int_compare_decompose (IntCC.Equal) (zero_reg) y))
+  (rv_seqz y))
+;; x != y => x ^ y != 0
+(rule 0 (lower_int_compare (int_compare_decompose (IntCC.NotEqual) x y))
+  (rv_snez (rv_xor x y)))
+(rule 1 (lower_int_compare (int_compare_decompose (IntCC.NotEqual) x (zero_reg)))
+  (rv_snez x))
+(rule 2 (lower_int_compare (int_compare_decompose (IntCC.NotEqual) (zero_reg) x))
+  (rv_snez x))
+;; x < y => x < y
+(rule (lower_int_compare (int_compare_decompose (IntCC.SignedLessThan) x y))
+  (rv_slt x y))
+(rule (lower_int_compare (int_compare_decompose (IntCC.UnsignedLessThan) x y))
+  (rv_sltu x y))
+;; x > y => y < x
+(rule (lower_int_compare (int_compare_decompose (IntCC.SignedGreaterThan) x y))
+  (rv_slt y x))
+(rule (lower_int_compare (int_compare_decompose (IntCC.UnsignedGreaterThan) x y))
+  (rv_sltu y x))
+;; x <= y => !(y < x)
+(rule (lower_int_compare (int_compare_decompose (IntCC.SignedLessThanOrEqual) x y))
+  (rv_xori (rv_slt y x) (imm12_const 1)))
+(rule (lower_int_compare (int_compare_decompose (IntCC.UnsignedLessThanOrEqual) x y))
+  (rv_xori (rv_sltu y x) (imm12_const 1)))
+;; x >= y => !(x < y)
+(rule (lower_int_compare (int_compare_decompose (IntCC.SignedGreaterThanOrEqual) x y))
+  (rv_xori (rv_slt x y) (imm12_const 1)))
+(rule (lower_int_compare (int_compare_decompose (IntCC.UnsignedGreaterThanOrEqual) x y))
+  (rv_xori (rv_sltu x y) (imm12_const 1)))
+
+;; 128-bit comparisons.
+;;
+;; Currently only `==`, `!=`, and `<` are implemented, and everything else
+;; delegates to one of those.
+
+(rule 20 (lower (icmp _ cc x @ (value_type $I128) y))
+  (lower_icmp_i128 cc x y))
+
+(decl lower_icmp_i128 (IntCC ValueRegs ValueRegs) XReg)
+(rule 0 (lower_icmp_i128 (IntCC.Equal) x y)
+  (let ((lo XReg (rv_xor (value_regs_get x 0) (value_regs_get y 0)))
+        (hi XReg (rv_xor (value_regs_get x 1) (value_regs_get y 1))))
+    (rv_seqz (rv_or lo hi))))
+(rule 0 (lower_icmp_i128 (IntCC.NotEqual) x y)
+  (let ((lo XReg (rv_xor (value_regs_get x 0) (value_regs_get y 0)))
+        (hi XReg (rv_xor (value_regs_get x 1) (value_regs_get y 1))))
+    (rv_snez (rv_or lo hi))))
+
+;; swap args for `>` to use `<` instead
+(rule 0 (lower_icmp_i128 cc @ (IntCC.SignedGreaterThan) x y)
+  (lower_icmp_i128 (intcc_swap_args cc) y x))
+(rule 0 (lower_icmp_i128 cc @ (IntCC.UnsignedGreaterThan) x y)
+  (lower_icmp_i128 (intcc_swap_args cc) y x))
+
+;; complement `=`-related conditions to get ones that don't use `=`.
+(rule 0 (lower_icmp_i128 cc @ (IntCC.SignedLessThanOrEqual) x y)
+  (rv_xori (lower_icmp_i128 (intcc_complement cc) x y) (imm12_const 1)))
+(rule 0 (lower_icmp_i128 cc @ (IntCC.SignedGreaterThanOrEqual) x y)
+  (rv_xori (lower_icmp_i128 (intcc_complement cc) x y) (imm12_const 1)))
+(rule 0 (lower_icmp_i128 cc @ (IntCC.UnsignedLessThanOrEqual) x y)
+  (rv_xori (lower_icmp_i128 (intcc_complement cc) x y) (imm12_const 1)))
+(rule 0 (lower_icmp_i128 cc @ (IntCC.UnsignedGreaterThanOrEqual) x y)
+  (rv_xori (lower_icmp_i128 (intcc_complement cc) x y) (imm12_const 1)))
+
+;; Compare both the bottom and upper halves of the 128-bit values. If
+;; the top half is equal use the bottom comparison, otherwise use the upper
+;; comparison. Note that the lower comparison is always unsigned since if it's
+;; used the top halves are all zeros and the semantic values are positive.
+(rule 1 (lower_icmp_i128 cc x y)
+  (if-let (IntCC.UnsignedLessThan) (intcc_unsigned cc))
+  (let ((x_lo Reg (value_regs_get x 0))
+        (x_hi Reg (value_regs_get x 1))
+        (y_lo Reg (value_regs_get y 0))
+        (y_hi Reg (value_regs_get y 1))
+        (top_cmp XReg (lower_int_compare (int_compare cc x_hi y_hi)))
+        (bottom_cmp XReg (rv_sltu x_lo y_lo)))
+    (gen_select_xreg (cmp_eqz (rv_xor x_hi y_hi)) bottom_cmp top_cmp)))
+
+;; vector icmp comparisons
+
+(rule 30 (lower (icmp _ cc x @ (value_type (ty_supported_vec ty)) y))
   (gen_expand_mask ty (gen_icmp_mask ty cc x y)))
 
-
 ;;;;;  Rules for `fcmp`;;;;;;;;;
-(rule 0 (lower (fcmp cc x @ (value_type (ty_scalar_float ty)) y))
-  (lower_fcmp (emit_fcmp cc ty x y)))
+(rule 0 (lower (fcmp _ cc x @ (value_type (ty_supported_float ty)) y))
+  (lower_float_compare (fcmp_to_float_compare cc ty x y)))
 
-(decl lower_fcmp (FCmp) XReg)
-(rule (lower_fcmp (FCmp.One r)) r)
-(rule (lower_fcmp (FCmp.Zero r)) (rv_seqz r))
+(decl lower_float_compare (FloatCompare) XReg)
+(rule (lower_float_compare (FloatCompare.One r)) r)
+(rule (lower_float_compare (FloatCompare.Zero r)) (rv_seqz r))
 
-(rule 1 (lower (fcmp cc x @ (value_type (ty_vec_fits_in_register ty)) y))
+(rule 1 (lower (fcmp _ cc x @ (value_type (ty_supported_vec ty)) y))
   (gen_expand_mask ty (gen_fcmp_mask ty cc x y)))
 
 ;;;;;  Rules for `func_addr`;;;;;;;;;
 (rule
-  (lower (func_addr (func_ref_data _ name _)))
+  (lower (func_addr _ (func_ref_data _ name _)))
   (load_ext_name name 0))
 
 ;;;;;  Rules for `fcvt_to_uint`;;;;;;;;;
-(rule
-  (lower (has_type to (fcvt_to_uint v @ (value_type from))))
-  (gen_fcvt_int $false v $false from to))
+
+;; RISC-V float-to-integer conversion does not trap, but Cranelift semantics are
+;; to trap. This manually performs checks for NaN and out-of-bounds values and
+;; traps in such cases.
+;;
+;; TODO: could this perhaps be more optimal through inspection of the `fcsr`?
+;; Unsure whether that needs to be preserved across function calls and/or would
+;; cause other problems. Also unsure whether it's actually more performant.
+(rule (lower (has_type ity (fcvt_to_uint _ v @ (value_type fty))))
+  (let ((_ InstOutput (gen_trapz (rv_feq fty v v) (TrapCode.BadConversionToInteger)))
+        (min FReg (imm fty (fcvt_umin_bound fty $false)))
+        (_ InstOutput (gen_trapnz (rv_fle fty v min) (TrapCode.IntegerOverflow)))
+        (max FReg (imm fty (fcvt_umax_bound fty ity $false)))
+        (_ InstOutput (gen_trapnz (rv_fge fty v max) (TrapCode.IntegerOverflow))))
+    (lower_inbounds_fcvt_to_uint ity fty v)))
+
+(decl lower_inbounds_fcvt_to_uint (Type Type FReg) XReg)
+(rule 0 (lower_inbounds_fcvt_to_uint (fits_in_32 _) fty v)
+  (rv_fcvtwu fty (FRM.RTZ) v))
+(rule 1 (lower_inbounds_fcvt_to_uint $I64 fty v)
+  (rv_fcvtlu fty (FRM.RTZ) v))
 
 ;;;;;  Rules for `fcvt_to_sint`;;;;;;;;;
-(rule 0 (lower (has_type to (fcvt_to_sint v @ (value_type (ty_scalar_float from)))))
-  (gen_fcvt_int $false v $true from to))
+
+;; NB: see above with `fcvt_to_uint` as this is similar
+(rule (lower (has_type ity (fcvt_to_sint _ v @ (value_type fty))))
+  (let ((_ InstOutput (gen_trapz (rv_feq fty v v) (TrapCode.BadConversionToInteger)))
+        (min FReg (imm fty (fcvt_smin_bound fty ity $false)))
+        (_ InstOutput (gen_trapnz (rv_fle fty v min) (TrapCode.IntegerOverflow)))
+        (max FReg (imm fty (fcvt_smax_bound fty ity $false)))
+        (_ InstOutput (gen_trapnz (rv_fge fty v max) (TrapCode.IntegerOverflow))))
+    (lower_inbounds_fcvt_to_sint ity fty v)))
+
+(decl lower_inbounds_fcvt_to_sint (Type Type FReg) XReg)
+(rule 0 (lower_inbounds_fcvt_to_sint (fits_in_32 _) fty v)
+  (rv_fcvtw fty (FRM.RTZ) v))
+(rule 1 (lower_inbounds_fcvt_to_sint $I64 fty v)
+  (rv_fcvtl fty (FRM.RTZ) v))
 
 ;;;;;  Rules for `fcvt_to_sint_sat`;;;;;;;;;
-(rule 0 (lower (has_type to (fcvt_to_sint_sat v @ (value_type (ty_scalar_float from)))))
-  (gen_fcvt_int $true v $true from to))
 
-(rule 1 (lower (has_type (ty_vec_fits_in_register _) (fcvt_to_sint_sat v @ (value_type from_ty))))
+(rule 0 (lower (has_type to (fcvt_to_sint_sat _ v @ (value_type (ty_supported_float from)))))
+  (handle_fcvt_to_int_nan from v (lower_fcvt_to_sint_sat from to v)))
+
+;; Lowers to a `rv_fcvt*` instruction but handles 8/16-bit cases where the
+;; float is clamped before the conversion.
+(decl lower_fcvt_to_sint_sat (Type Type FReg) XReg)
+(rule 0 (lower_fcvt_to_sint_sat ty (fits_in_16 out_ty) v)
+  (let ((max FReg (imm ty (fcvt_smax_bound ty out_ty $true)))
+        (min FReg (imm ty (fcvt_smin_bound ty out_ty $true)))
+        (clamped FReg (rv_fmin ty max (rv_fmax ty min v))))
+    (rv_fcvtw ty (FRM.RTZ) clamped)))
+(rule 1 (lower_fcvt_to_sint_sat ty $I32 v) (rv_fcvtw ty (FRM.RTZ) v))
+(rule 1 (lower_fcvt_to_sint_sat ty $I64 v) (rv_fcvtl ty (FRM.RTZ) v))
+
+(decl fcvt_smax_bound (Type Type bool) u64)
+(extern constructor fcvt_smax_bound fcvt_smax_bound)
+(decl fcvt_smin_bound (Type Type bool) u64)
+(extern constructor fcvt_smin_bound fcvt_smin_bound)
+
+;; RISC-V float-to-int conversions generate the same output for NaN and +Inf,
+;; but Cranelift semantics are to produce 0 for NaN instead. This helper
+;; translates these semantics by taking the float being converted (with the type
+;; specified) and the native RISC-V output as an `XReg`. The returned `XReg`
+;; will be zeroed out if the float is NaN.
+;;
+;; This is done by comparing the float to itself, generating 0 if it's NaN. This
+;; bit is then negated to become either all-ones or all-zeros which is then
+;; and-ed against the native output. That'll produce all zeros if the input is
+;; NaN or the native output otherwise.
+(decl handle_fcvt_to_int_nan (Type FReg XReg) XReg)
+(rule (handle_fcvt_to_int_nan ty freg xreg)
+  (let ((is_not_nan XReg (rv_feq ty freg freg))
+        (not_nan_mask XReg (rv_neg is_not_nan)))
+    (rv_and xreg not_nan_mask)))
+
+(rule 1 (lower (has_type (ty_supported_vec _) (fcvt_to_sint_sat _ v @ (value_type from_ty))))
   (if-let zero (i8_to_imm5 0))
   (let ((is_nan VReg (rv_vmfne_vv v v (unmasked) from_ty))
         (cvt VReg (rv_vfcvt_rtz_x_f_v v (unmasked) from_ty)))
     (rv_vmerge_vim cvt zero is_nan from_ty)))
 
 ;;;;;  Rules for `fcvt_to_uint_sat`;;;;;;;;;
-(rule 0 (lower (has_type to (fcvt_to_uint_sat v @ (value_type (ty_scalar_float from)))))
-  (gen_fcvt_int $true v $false from to))
 
-(rule 1 (lower (has_type (ty_vec_fits_in_register _) (fcvt_to_uint_sat v @ (value_type from_ty))))
+(rule 0 (lower (has_type to (fcvt_to_uint_sat _ v @ (value_type (ty_supported_float from)))))
+  (handle_fcvt_to_int_nan from v (lower_fcvt_to_uint_sat from to v)))
+
+;; Lowers to a `rv_fcvt*` instruction but handles 8/16-bit cases where the
+;; float is clamped before the conversion.
+(decl lower_fcvt_to_uint_sat (Type Type FReg) XReg)
+(rule 0 (lower_fcvt_to_uint_sat ty (fits_in_16 out_ty) v)
+  (let ((max FReg (imm ty (fcvt_umax_bound ty out_ty $true)))
+        (min FReg (rv_fmvdx (zero_reg)))
+        (clamped FReg (rv_fmin ty max (rv_fmax ty min v))))
+    (rv_fcvtwu ty (FRM.RTZ) clamped)))
+(rule 1 (lower_fcvt_to_uint_sat ty $I32 v) (rv_fcvtwu ty (FRM.RTZ) v))
+(rule 1 (lower_fcvt_to_uint_sat ty $I64 v) (rv_fcvtlu ty (FRM.RTZ) v))
+
+(decl fcvt_umax_bound (Type Type bool) u64)
+(extern constructor fcvt_umax_bound fcvt_umax_bound)
+(decl fcvt_umin_bound (Type bool) u64)
+(extern constructor fcvt_umin_bound fcvt_umin_bound)
+
+(rule 1 (lower (has_type (ty_supported_vec _) (fcvt_to_uint_sat _ v @ (value_type from_ty))))
   (if-let zero (i8_to_imm5 0))
   (let ((is_nan VReg (rv_vmfne_vv v v (unmasked) from_ty))
         (cvt VReg (rv_vfcvt_rtz_xu_f_v v (unmasked) from_ty)))
     (rv_vmerge_vim cvt zero is_nan from_ty)))
 
 ;;;;;  Rules for `fcvt_from_sint`;;;;;;;;;
-(rule 0 (lower (has_type $F32 (fcvt_from_sint v @ (value_type (fits_in_16 ty)))))
-  (rv_fcvtsl (sext v)))
+(rule 0 (lower (has_type $F32 (fcvt_from_sint _ v @ (value_type (fits_in_16 ty)))))
+  (rv_fcvtsl (FRM.RNE) (sext v)))
 
-(rule 1 (lower (has_type $F32 (fcvt_from_sint v @ (value_type $I32))))
-  (rv_fcvtsw v))
+(rule 1 (lower (has_type $F32 (fcvt_from_sint _ v @ (value_type $I32))))
+  (rv_fcvtsw (FRM.RNE) v))
 
-(rule 1 (lower (has_type $F32 (fcvt_from_sint v @ (value_type $I64))))
-  (rv_fcvtsl v))
+(rule 1 (lower (has_type $F32 (fcvt_from_sint _ v @ (value_type $I64))))
+  (rv_fcvtsl (FRM.RNE) v))
 
-(rule 0 (lower (has_type $F64 (fcvt_from_sint v @ (value_type (fits_in_16 ty)))))
-  (rv_fcvtdl (sext v)))
+(rule 0 (lower (has_type $F64 (fcvt_from_sint _ v @ (value_type (fits_in_16 ty)))))
+  (rv_fcvtdl (FRM.RNE) (sext v)))
 
-(rule 1 (lower (has_type $F64 (fcvt_from_sint v @ (value_type $I32))))
+(rule 1 (lower (has_type $F64 (fcvt_from_sint _ v @ (value_type $I32))))
   (rv_fcvtdw v))
 
-(rule 1 (lower (has_type $F64 (fcvt_from_sint v @ (value_type $I64))))
-  (rv_fcvtdl v))
+(rule 1 (lower (has_type $F64 (fcvt_from_sint _ v @ (value_type $I64))))
+  (rv_fcvtdl (FRM.RNE) v))
 
-(rule 2 (lower (has_type (ty_vec_fits_in_register _) (fcvt_from_sint v @ (value_type from_ty))))
+(rule 2 (lower (has_type (ty_supported_vec _) (fcvt_from_sint _ v @ (value_type from_ty))))
   (rv_vfcvt_f_x_v v (unmasked) from_ty))
 
 ;;;;;  Rules for `fcvt_from_uint`;;;;;;;;;
-(rule 0 (lower (has_type $F32 (fcvt_from_uint v @ (value_type (fits_in_16 ty)))))
-  (rv_fcvtslu (zext v)))
+(rule 0 (lower (has_type $F32 (fcvt_from_uint _ v @ (value_type (fits_in_16 ty)))))
+  (rv_fcvtslu (FRM.RNE) (zext v)))
 
-(rule 1 (lower (has_type $F32 (fcvt_from_uint v @ (value_type $I32))))
-  (rv_fcvtswu v))
+(rule 1 (lower (has_type $F32 (fcvt_from_uint _ v @ (value_type $I32))))
+  (rv_fcvtswu (FRM.RNE) v))
 
-(rule 1 (lower (has_type $F32 (fcvt_from_uint v @ (value_type $I64))))
-  (rv_fcvtslu v))
+(rule 1 (lower (has_type $F32 (fcvt_from_uint _ v @ (value_type $I64))))
+  (rv_fcvtslu (FRM.RNE) v))
 
-(rule 0 (lower (has_type $F64 (fcvt_from_uint v @ (value_type (fits_in_16 ty)))))
-  (rv_fcvtdlu (zext v)))
+(rule 0 (lower (has_type $F64 (fcvt_from_uint _ v @ (value_type (fits_in_16 ty)))))
+  (rv_fcvtdlu (FRM.RNE) (zext v)))
 
-(rule 1 (lower (has_type $F64 (fcvt_from_uint v @ (value_type $I32))))
+(rule 1 (lower (has_type $F64 (fcvt_from_uint _ v @ (value_type $I32))))
   (rv_fcvtdwu v))
 
-(rule 1 (lower (has_type $F64 (fcvt_from_uint v @ (value_type $I64))))
-  (rv_fcvtdlu v))
+(rule 1 (lower (has_type $F64 (fcvt_from_uint _ v @ (value_type $I64))))
+  (rv_fcvtdlu (FRM.RNE) v))
 
-(rule 2 (lower (has_type (ty_vec_fits_in_register _) (fcvt_from_uint v @ (value_type from_ty))))
+(rule 2 (lower (has_type (ty_supported_vec _) (fcvt_from_uint _ v @ (value_type from_ty))))
   (rv_vfcvt_f_xu_v v (unmasked) from_ty))
 
 ;;;;;  Rules for `symbol_value`;;;;;;;;;
 (rule
-   (lower (symbol_value (symbol_value_data name _ offset)))
+   (lower (symbol_value _ (symbol_value_data name _ offset)))
    (load_ext_name name offset))
 
 ;;;;;  Rules for `tls_value` ;;;;;;;;;;;;;;
 
-(rule (lower (has_type (tls_model (TlsModel.ElfGd)) (tls_value (symbol_value_data name _ _))))
+(rule (lower (has_type (tls_model (TlsModel.ElfGd)) (tls_value _ (symbol_value_data name _ _))))
       (elf_tls_get_addr name))
 
 ;;;;;  Rules for `bitcast`;;;;;;;;;
-(rule
-   (lower (has_type out_ty (bitcast _ v @ (value_type in_ty))))
+
+;; These rules should probably be handled in `gen_bitcast`, but it's convenient to have that return
+;; a single register, instead of a `ValueRegs`
+(rule 3 (lower (has_type $I128 (bitcast _ _ v @ (value_type (ty_supported_vec _)))))
+    (value_regs
+      (gen_extractlane $I64X2 v 0)
+      (gen_extractlane $I64X2 v 1)))
+
+;; Move the high half into a vector register, and then use vslide1up to move it up and
+;; insert the lower half in one instruction.
+(rule 2 (lower (has_type (ty_supported_vec _) (bitcast _ _ v @ (value_type $I128))))
+    (let ((lo XReg (value_regs_get v 0))
+          (hi XReg (value_regs_get v 1))
+          (vstate VState (vstate_from_type $I64X2))
+          (vec VReg (rv_vmv_sx hi vstate)))
+      (rv_vslide1up_vx vec vec lo (unmasked) vstate)))
+
+;; `gen_bitcast` below only works with single register values, so handle I128
+;; specially here.
+(rule 1 (lower (has_type $I128 (bitcast _ _ v @ (value_type $I128))))
+   v)
+
+(rule 0 (lower (has_type out_ty (bitcast _ _ v @ (value_type in_ty))))
    (gen_bitcast v in_ty out_ty))
 
 ;;;;;  Rules for `ceil`;;;;;;;;;
-(rule 0 (lower (has_type (ty_scalar_float ty) (ceil x)))
-  (gen_float_round (FloatRoundOP.Ceil) x ty))
+(rule 0 (lower (has_type (ty_supported_float ty) (ceil _ x)))
+  (gen_float_round (FRM.RUP) x ty))
 
-(rule 1 (lower (has_type (ty_vec_fits_in_register ty) (ceil x)))
+(rule 1 (lower (has_type (ty_supported_vec ty) (ceil _ x)))
   (gen_vec_round x (FRM.RUP) ty))
 
 ;;;;;  Rules for `floor`;;;;;;;;;
-(rule 0 (lower (has_type (ty_scalar_float ty) (floor x)))
-  (gen_float_round (FloatRoundOP.Floor) x ty))
+(rule 0 (lower (has_type (ty_supported_float ty) (floor _ x)))
+  (gen_float_round (FRM.RDN) x ty))
 
-(rule 1 (lower (has_type (ty_vec_fits_in_register ty) (floor x)))
+(rule 1 (lower (has_type (ty_supported_vec ty) (floor _ x)))
   (gen_vec_round x (FRM.RDN) ty))
 
 ;;;;;  Rules for `trunc`;;;;;;;;;
-(rule 0 (lower (has_type (ty_scalar_float ty) (trunc x)))
-  (gen_float_round (FloatRoundOP.Trunc) x ty))
+(rule 0 (lower (has_type (ty_supported_float ty) (trunc _ x)))
+  (gen_float_round (FRM.RTZ) x ty))
 
-(rule 1 (lower (has_type (ty_vec_fits_in_register ty) (trunc x)))
+(rule 1 (lower (has_type (ty_supported_vec ty) (trunc _ x)))
   (gen_vec_round x (FRM.RTZ) ty))
 
 ;;;;;  Rules for `nearest`;;;;;;;;;
-(rule 0 (lower (has_type (ty_scalar_float ty) (nearest x)))
-  (gen_float_round (FloatRoundOP.Nearest) x ty))
+(rule 0 (lower (has_type (ty_supported_float ty) (nearest _ x)))
+  (gen_float_round (FRM.RNE) x ty))
 
-(rule 1 (lower (has_type (ty_vec_fits_in_register ty) (nearest x)))
+(rule 1 (lower (has_type (ty_supported_vec ty) (nearest _ x)))
   (gen_vec_round x (FRM.RNE) ty))
 
 
@@ -2002,21 +2520,28 @@
 ;;
 ;; We don't have cmov's in RISC-V either, but we can emulate those using bitwise
 ;; operations, which is what we do below.
-(rule (lower (has_type ty (select_spectre_guard cmp @ (value_type cmp_ty) x @ (value_type arg_ty) y)))
-  (let (;; Build a mask that is 0 or -1 depending on the input comparision value.
-        ;; `lower_bmask` handles normalizing the input.
-        (mask ValueRegs (lower_bmask cmp arg_ty))
-        ;; Using the mask above we can select either `x` or `y` by
-        ;; performing a bitwise `and` on both sides and then merging them
-        ;; together. We know that only the bits of one of the sides will be selected.
-        ;; TODO: We can use `andn` here if we have `Zbb`
-        (lhs ValueRegs (gen_and arg_ty x mask))
-        (rhs ValueRegs (gen_and arg_ty y (gen_bnot arg_ty mask))))
-    (gen_or arg_ty lhs rhs)))
+
+;; Base case: use `gen_bmask` to generate a 0 mask or -1 mask from the value of
+;; `cmp`. This is then used with some bit twiddling to produce the final result.
+(rule 0 (lower (has_type (fits_in_64 _) (select_spectre_guard _ cmp x y)))
+  (let ((mask XReg (gen_bmask cmp)))
+    (rv_or (rv_and mask x) (rv_andn y mask))))
+(rule 1 (lower (has_type $I128 (select_spectre_guard _ cmp x y)))
+  (let ((mask XReg (gen_bmask cmp)))
+    (value_regs
+      (rv_or (rv_and mask (value_regs_get x 0)) (rv_andn (value_regs_get y 0) mask))
+      (rv_or (rv_and mask (value_regs_get x 1)) (rv_andn (value_regs_get y 1) mask)))))
+
+;; Special case when an argument is the constant zero as some ands and ors
+;; can be folded away.
+(rule 2 (lower (has_type (fits_in_64 _) (select_spectre_guard _ cmp (i64_from_iconst 0) y)))
+  (rv_andn y (gen_bmask cmp)))
+(rule 3 (lower (has_type (fits_in_64 _) (select_spectre_guard _ cmp x (i64_from_iconst 0))))
+  (rv_and x (gen_bmask cmp)))
 
 ;;;;;  Rules for `bmask`;;;;;;;;;
 (rule
-  (lower (has_type oty (bmask x)))
+  (lower (has_type oty (bmask _ x)))
   (lower_bmask x oty))
 
 ;; N.B.: the Ret itself is generated by the ABI.
@@ -2025,13 +2550,13 @@
 
 ;;; Rules for `get_{frame,stack}_pointer` and `get_return_address` ;;;;;;;;;;;;;
 
-(rule (lower (get_frame_pointer))
+(rule (lower (get_frame_pointer _))
   (gen_mov_from_preg (fp_reg)))
 
-(rule (lower (get_stack_pointer))
+(rule (lower (get_stack_pointer _))
   (gen_mov_from_preg (sp_reg)))
 
-(rule (lower (get_return_address))
+(rule (lower (get_return_address _))
   (load_ra))
 
 ;;; Rules for `iabs` ;;;;;;;;;;;;;
@@ -2041,15 +2566,15 @@
 ;;   sext.{b,h,w} a0, a0
 ;;   neg a1, a0
 ;;   max a0, a0, a1
-(rule 0 (lower (has_type (ty_int_ref_scalar_64 ty) (iabs x)))
+(rule 0 (lower (has_type (ty_int_ref_scalar_64 ty) (iabs _ x)))
   (let ((extended XReg (sext x))
         (negated XReg (rv_neg extended)))
-    (max $I64 extended negated)))
+    (gen_select_xreg (cmp_gt extended negated) extended negated)))
 
 ;; For vectors we generate the same code, but with vector instructions
 ;; we can skip the sign extension, since the vector unit will only process
 ;; Element Sized chunks.
-(rule 1 (lower (has_type (ty_vec_fits_in_register ty) (iabs x)))
+(rule 1 (lower (has_type (ty_supported_vec ty) (iabs _ x)))
   (let ((negated VReg (rv_vneg_v x (unmasked) ty)))
     (rv_vmax_vv x negated (unmasked) ty)))
 
@@ -2072,7 +2597,7 @@
 
 ;;;; Rules for `extractlane` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (extractlane x @ (value_type ty) (u8_from_uimm8 idx)))
+(rule (lower (extractlane _ x @ (value_type ty) (u8_from_uimm8 idx)))
   (gen_extractlane ty x idx))
 
 ;;;; Rules for `insertlane` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -2080,22 +2605,22 @@
 ;; We can insert a lane by using a masked splat from an X register.
 ;; Build a mask that is only enabled in the lane we want to insert.
 ;; Then use a masked splat (vmerge) to insert the value.
-(rule 0 (lower (insertlane vec @ (value_type (ty_vec_fits_in_register ty))
+(rule 0 (lower (insertlane _ vec @ (value_type (ty_supported_vec ty))
                            val @ (value_type (ty_int _))
                            (u8_from_uimm8 lane)))
   (let ((mask VReg (gen_vec_mask (u64_shl 1 lane))))
     (rv_vmerge_vxm vec val mask ty)))
 
 ;; Similar to above, but using the float variants of the instructions.
-(rule 1 (lower (insertlane vec @ (value_type (ty_vec_fits_in_register ty))
-                           val @ (value_type (ty_scalar_float _))
+(rule 1 (lower (insertlane _ vec @ (value_type (ty_supported_vec ty))
+                           val @ (value_type (ty_supported_float _))
                            (u8_from_uimm8 lane)))
   (let ((mask VReg (gen_vec_mask (u64_shl 1 lane))))
     (rv_vfmerge_vfm vec val mask ty)))
 
 ;; If we are inserting from an Imm5 const we can use the immediate
 ;; variant of vmerge.
-(rule 2 (lower (insertlane vec @ (value_type (ty_vec_fits_in_register ty))
+(rule 2 (lower (insertlane _ vec @ (value_type (ty_supported_vec ty))
                            (i64_from_iconst (imm5_from_i64 imm))
                            (u8_from_uimm8 lane)))
   (let ((mask VReg (gen_vec_mask (u64_shl 1 lane))))
@@ -2103,13 +2628,13 @@
 
 ;;;; Rules for `splat` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 0 (lower (has_type ty (splat n @ (value_type (ty_scalar_float _)))))
+(rule 0 (lower (has_type ty (splat _ n @ (value_type (ty_supported_float _)))))
   (rv_vfmv_vf n ty))
 
-(rule 1 (lower (has_type ty (splat n @ (value_type (ty_int_ref_scalar_64 _)))))
+(rule 1 (lower (has_type ty (splat _ n @ (value_type (ty_int_ref_scalar_64 _)))))
   (rv_vmv_vx n ty))
 
-(rule 2 (lower (has_type ty (splat (iconst (u64_from_imm64 (imm5_from_u64 imm))))))
+(rule 2 (lower (has_type ty (splat _ (iconst _ (u64_from_imm64 (imm5_from_u64 imm))))))
   (rv_vmv_vi imm ty))
 
 ;; TODO: We can splat out more patterns by using for example a vmv.v.i i8x16 for
@@ -2120,56 +2645,56 @@
 
 ;;;; Rules for `uadd_sat` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 0 (lower (has_type (ty_vec_fits_in_register ty) (uadd_sat x y)))
+(rule 0 (lower (has_type (ty_supported_vec ty) (uadd_sat _ x y)))
   (rv_vsaddu_vv x y (unmasked) ty))
 
-(rule 1 (lower (has_type (ty_vec_fits_in_register ty) (uadd_sat x (splat y))))
+(rule 1 (lower (has_type (ty_supported_vec ty) (uadd_sat _ x (splat _ y))))
   (rv_vsaddu_vx x y (unmasked) ty))
 
-(rule 2 (lower (has_type (ty_vec_fits_in_register ty) (uadd_sat (splat x) y)))
+(rule 2 (lower (has_type (ty_supported_vec ty) (uadd_sat _ (splat _ x) y)))
   (rv_vsaddu_vx y x (unmasked) ty))
 
-(rule 3 (lower (has_type (ty_vec_fits_in_register ty) (uadd_sat x y)))
+(rule 3 (lower (has_type (ty_supported_vec ty) (uadd_sat _ x y)))
   (if-let y_imm (replicated_imm5 y))
   (rv_vsaddu_vi x y_imm (unmasked) ty))
 
-(rule 4 (lower (has_type (ty_vec_fits_in_register ty) (uadd_sat x y)))
+(rule 4 (lower (has_type (ty_supported_vec ty) (uadd_sat _ x y)))
   (if-let x_imm (replicated_imm5 x))
   (rv_vsaddu_vi y x_imm (unmasked) ty))
 
 ;;;; Rules for `sadd_sat` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 0 (lower (has_type (ty_vec_fits_in_register ty) (sadd_sat x y)))
+(rule 0 (lower (has_type (ty_supported_vec ty) (sadd_sat _ x y)))
   (rv_vsadd_vv x y (unmasked) ty))
 
-(rule 1 (lower (has_type (ty_vec_fits_in_register ty) (sadd_sat x (splat y))))
+(rule 1 (lower (has_type (ty_supported_vec ty) (sadd_sat _ x (splat _ y))))
   (rv_vsadd_vx x y (unmasked) ty))
 
-(rule 2 (lower (has_type (ty_vec_fits_in_register ty) (sadd_sat (splat x) y)))
+(rule 2 (lower (has_type (ty_supported_vec ty) (sadd_sat _ (splat _ x) y)))
   (rv_vsadd_vx y x (unmasked) ty))
 
-(rule 3 (lower (has_type (ty_vec_fits_in_register ty) (sadd_sat x y)))
+(rule 3 (lower (has_type (ty_supported_vec ty) (sadd_sat _ x y)))
   (if-let y_imm (replicated_imm5 y))
   (rv_vsadd_vi x y_imm (unmasked) ty))
 
-(rule 4 (lower (has_type (ty_vec_fits_in_register ty) (sadd_sat x y)))
+(rule 4 (lower (has_type (ty_supported_vec ty) (sadd_sat _ x y)))
   (if-let x_imm (replicated_imm5 x))
   (rv_vsadd_vi y x_imm (unmasked) ty))
 
 ;;;; Rules for `usub_sat` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 0 (lower (has_type (ty_vec_fits_in_register ty) (usub_sat x y)))
+(rule 0 (lower (has_type (ty_supported_vec ty) (usub_sat _ x y)))
   (rv_vssubu_vv x y (unmasked) ty))
 
-(rule 1 (lower (has_type (ty_vec_fits_in_register ty) (usub_sat x (splat y))))
+(rule 1 (lower (has_type (ty_supported_vec ty) (usub_sat _ x (splat _ y))))
   (rv_vssubu_vx x y (unmasked) ty))
 
 ;;;; Rules for `ssub_sat` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 0 (lower (has_type (ty_vec_fits_in_register ty) (ssub_sat x y)))
+(rule 0 (lower (has_type (ty_supported_vec ty) (ssub_sat _ x y)))
   (rv_vssub_vv x y (unmasked) ty))
 
-(rule 1 (lower (has_type (ty_vec_fits_in_register ty) (ssub_sat x (splat y))))
+(rule 1 (lower (has_type (ty_supported_vec ty) (ssub_sat _ x (splat _ y))))
   (rv_vssub_vx x y (unmasked) ty))
 
 ;;;; Rules for `vall_true` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -2180,7 +2705,7 @@
 ;; be a 1.
 ;; The reduce operation leaves the result in the lowest lane, we then move it
 ;; into the destination X register.
-(rule (lower (vall_true x @ (value_type (ty_vec_fits_in_register ty))))
+(rule (lower (vall_true _ x @ (value_type (ty_supported_vec ty))))
   (if-let one (i8_to_imm5 1))
   ;; We don't need to broadcast the immediate into all lanes, only into lane 0.
   ;; I did it this way since it uses one less instruction than with a vmv.s.x.
@@ -2194,7 +2719,7 @@
 ;; Here we do a Vector Reduce operation. Get the unsigned maximum value of the
 ;; input vector register. Move the max to an X register, and do a `snez` on it
 ;; to ensure its either 1 or 0.
-(rule (lower (vany_true x @ (value_type (ty_vec_fits_in_register ty))))
+(rule (lower (vany_true _ x @ (value_type (ty_supported_vec ty))))
   (let ((max VReg (rv_vredmaxu_vs x x (unmasked) ty))
         (x_max XReg (rv_vmv_xs max ty)))
     (rv_snez x_max)))
@@ -2210,7 +2735,7 @@
 ;; to hold the full mask. Additionally, in some cases (e.g. i64x2) we are going
 ;; to read some tail bits. These are undefined, so we need to further mask them
 ;; off.
-(rule (lower (vhigh_bits x @ (value_type (ty_vec_fits_in_register ty))))
+(rule (lower (vhigh_bits _ x @ (value_type (ty_supported_vec ty))))
   (let ((mask VReg (rv_vmslt_vx x (zero_reg) (unmasked) ty))
         ;; Here we only need I64X1, but emit an AVL of 2 since it
         ;; saves one vector state change in the case of I64X2.
@@ -2222,13 +2747,13 @@
 
 ;;;; Rules for `swizzle` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 0 (lower (has_type (ty_vec_fits_in_register ty) (swizzle x y)))
+(rule 0 (lower (has_type (ty_supported_vec ty) (swizzle _ x y)))
   (rv_vrgather_vv x y (unmasked) ty))
 
-(rule 1 (lower (has_type (ty_vec_fits_in_register ty) (swizzle x (splat y))))
+(rule 1 (lower (has_type (ty_supported_vec ty) (swizzle _ x (splat _ y))))
   (rv_vrgather_vx x y (unmasked) ty))
 
-(rule 2 (lower (has_type (ty_vec_fits_in_register ty) (swizzle x y)))
+(rule 2 (lower (has_type (ty_supported_vec ty) (swizzle _ x y)))
   (if-let y_imm (replicated_uimm5 y))
   (rv_vrgather_vi x y_imm (unmasked) ty))
 
@@ -2239,7 +2764,7 @@
 ;;
 ;; vrgather will insert a 0 for lanes that are out of bounds, so we can let it load
 ;; negative and out of bounds indexes.
-(rule (lower (has_type (ty_vec_fits_in_register ty @ $I8X16) (shuffle x y (vconst_from_immediate mask))))
+(rule (lower (has_type (ty_supported_vec ty @ $I8X16) (shuffle _ x y (vconst_from_immediate mask))))
   (if-let neg16 (i8_to_imm5 -16))
   (let ((x_mask VReg (gen_constant ty mask))
         (x_lanes VReg (rv_vrgather_vv x x_mask (unmasked) ty))
@@ -2250,51 +2775,51 @@
 ;;;; Rules for `swiden_high` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Slide down half the vector, and do a signed extension.
-(rule 0 (lower (has_type (ty_vec_fits_in_register out_ty) (swiden_high x @ (value_type in_ty))))
+(rule 0 (lower (has_type (ty_supported_vec out_ty) (swiden_high _ x @ (value_type in_ty))))
   (rv_vsext_vf2 (gen_slidedown_half in_ty x) (unmasked) out_ty))
 
-(rule 1 (lower (has_type (ty_vec_fits_in_register out_ty) (swiden_high (swiden_high x @ (value_type in_ty)))))
+(rule 1 (lower (has_type (ty_supported_vec out_ty) (swiden_high _ (swiden_high _ x @ (value_type in_ty)))))
   (if-let (uimm5_from_u64 amt) (u64_sub (ty_lane_count in_ty) (ty_lane_count out_ty)))
   (rv_vsext_vf4 (rv_vslidedown_vi x amt (unmasked) in_ty) (unmasked) out_ty))
 
-(rule 2 (lower (has_type (ty_vec_fits_in_register out_ty) (swiden_high (swiden_high (swiden_high x @ (value_type in_ty))))))
+(rule 2 (lower (has_type (ty_supported_vec out_ty) (swiden_high _ (swiden_high _ (swiden_high _ x @ (value_type in_ty))))))
   (if-let (uimm5_from_u64 amt) (u64_sub (ty_lane_count in_ty) (ty_lane_count out_ty)))
   (rv_vsext_vf8 (rv_vslidedown_vi x amt (unmasked) in_ty) (unmasked) out_ty))
 
 ;;;; Rules for `uwiden_high` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Slide down half the vector, and do a zero extension.
-(rule 0 (lower (has_type (ty_vec_fits_in_register out_ty) (uwiden_high x @ (value_type in_ty))))
+(rule 0 (lower (has_type (ty_supported_vec out_ty) (uwiden_high _ x @ (value_type in_ty))))
   (rv_vzext_vf2 (gen_slidedown_half in_ty x) (unmasked) out_ty))
 
-(rule 1 (lower (has_type (ty_vec_fits_in_register out_ty) (uwiden_high (uwiden_high x @ (value_type in_ty)))))
+(rule 1 (lower (has_type (ty_supported_vec out_ty) (uwiden_high _ (uwiden_high _ x @ (value_type in_ty)))))
   (if-let (uimm5_from_u64 amt) (u64_sub (ty_lane_count in_ty) (ty_lane_count out_ty)))
   (rv_vzext_vf4 (rv_vslidedown_vi x amt (unmasked) in_ty) (unmasked) out_ty))
 
-(rule 2 (lower (has_type (ty_vec_fits_in_register out_ty) (uwiden_high (uwiden_high (uwiden_high x @ (value_type in_ty))))))
+(rule 2 (lower (has_type (ty_supported_vec out_ty) (uwiden_high _ (uwiden_high _ (uwiden_high _ x @ (value_type in_ty))))))
   (if-let (uimm5_from_u64 amt) (u64_sub (ty_lane_count in_ty) (ty_lane_count out_ty)))
   (rv_vzext_vf8 (rv_vslidedown_vi x amt (unmasked) in_ty) (unmasked) out_ty))
 
 ;;;; Rules for `swiden_low` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 0 (lower (has_type (ty_vec_fits_in_register out_ty) (swiden_low x)))
+(rule 0 (lower (has_type (ty_supported_vec out_ty) (swiden_low _ x)))
   (rv_vsext_vf2 x (unmasked) out_ty))
 
-(rule 1 (lower (has_type (ty_vec_fits_in_register out_ty) (swiden_low (swiden_low x))))
+(rule 1 (lower (has_type (ty_supported_vec out_ty) (swiden_low _ (swiden_low _ x))))
   (rv_vsext_vf4 x (unmasked) out_ty))
 
-(rule 2 (lower (has_type (ty_vec_fits_in_register out_ty) (swiden_low (swiden_low (swiden_low x)))))
+(rule 2 (lower (has_type (ty_supported_vec out_ty) (swiden_low _ (swiden_low _ (swiden_low _ x)))))
   (rv_vsext_vf8 x (unmasked) out_ty))
 
 ;;;; Rules for `uwiden_low` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 0 (lower (has_type (ty_vec_fits_in_register out_ty) (uwiden_low x)))
+(rule 0 (lower (has_type (ty_supported_vec out_ty) (uwiden_low _ x)))
   (rv_vzext_vf2 x (unmasked) out_ty))
 
-(rule 1 (lower (has_type (ty_vec_fits_in_register out_ty) (uwiden_low (uwiden_low x))))
+(rule 1 (lower (has_type (ty_supported_vec out_ty) (uwiden_low _ (uwiden_low _ x))))
   (rv_vzext_vf4 x (unmasked) out_ty))
 
-(rule 2 (lower (has_type (ty_vec_fits_in_register out_ty) (uwiden_low (uwiden_low (uwiden_low x)))))
+(rule 2 (lower (has_type (ty_supported_vec out_ty) (uwiden_low _ (uwiden_low _ (uwiden_low _ x)))))
   (rv_vzext_vf8 x (unmasked) out_ty))
 
 ;;;; Rules for `iadd_pairwise` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -2306,13 +2831,13 @@
 ;; elements. Using vcompress we can extract the elements and group them together.
 ;;
 ;; This is likely not the optimal way of doing this. LLVM does this using a bunch
-;; of vrgathers (See: https://godbolt.org/z/jq8Wj8WG4), that doesen't seem to be
+;; of vrgathers (See: https://godbolt.org/z/jq8Wj8WG4), that doesn't seem to be
 ;; too much better than this.
 ;;
 ;; However V8 does something better. They use 2 vcompresses using LMUL2, that means
 ;; that they can do the whole thing in 3 instructions (2 vcompress + vadd). We don't
 ;; support LMUL > 1, so we can't do that.
-(rule (lower (has_type (ty_vec_fits_in_register ty) (iadd_pairwise x y)))
+(rule (lower (has_type (ty_supported_vec ty) (iadd_pairwise _ x y)))
   (if-let half_size (u64_to_uimm5 (u64_udiv (ty_lane_count ty) 2)))
   (let ((odd_mask  VReg (gen_vec_mask 0x5555555555555555))
         (lhs_lo VReg (rv_vcompress_vm x odd_mask ty))
@@ -2340,10 +2865,10 @@
 ;; we use a special rounding mode in the right shift instruction.
 ;;
 ;; For the right shift instruction we use `vssrl` which is a Scaling Shift
-;; Right Logical instruction using the `vxrm` fixed-point rouding mode. The
+;; Right Logical instruction using the `vxrm` fixed-point rounding mode. The
 ;; default rounding mode is `rnu` (round-to-nearest-up (add +0.5 LSB)).
 ;; Which is coincidentally the rounding mode we want for `avg_round`.
-(rule (lower (has_type (ty_vec_fits_in_register ty) (avg_round x y)))
+(rule (lower (has_type (ty_supported_vec ty) (avg_round _ x y)))
   (if-let one (u64_to_uimm5 1))
   (let ((lhs VReg (rv_vand_vv x y (unmasked) ty))
         (xor  VReg (rv_vxor_vv x y (unmasked) ty))
@@ -2352,33 +2877,38 @@
 
 ;;;; Rules for `scalar_to_vector` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 1 (lower (has_type (ty_vec_fits_in_register ty) (scalar_to_vector x)))
+(rule 0 (lower (has_type (ty_supported_vec ty) (scalar_to_vector _ x)))
+  (if (ty_vector_float ty))
+  (let ((zero VReg (rv_vmv_vx (zero_reg) ty))
+        (elem VReg (rv_vfmv_sf x ty))
+        (mask VReg (gen_vec_mask 1)))
+    (rv_vmerge_vvm zero elem mask ty)))
+
+(rule 1 (lower (has_type (ty_supported_vec ty) (scalar_to_vector _ x)))
   (if (ty_vector_not_float ty))
   (let ((zero VReg (rv_vmv_vx (zero_reg) ty))
         (mask VReg (gen_vec_mask 1)))
     (rv_vmerge_vxm zero x mask ty)))
 
-(rule 0 (lower (has_type (ty_vec_fits_in_register ty) (scalar_to_vector x)))
-  (if (ty_vector_float ty))
+(rule 2 (lower (has_type (ty_supported_vec ty) (scalar_to_vector _ (imm5_from_value x))))
   (let ((zero VReg (rv_vmv_vx (zero_reg) ty))
-        (elem VReg (rv_vfmv_sf x ty))
         (mask VReg (gen_vec_mask 1)))
-    (rv_vmerge_vvm zero elem mask ty)))
+    (rv_vmerge_vim zero x mask ty)))
 
 ;;;; Rules for `sqmul_round_sat` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 0 (lower (has_type (ty_vec_fits_in_register ty) (sqmul_round_sat x y)))
+(rule 0 (lower (has_type (ty_supported_vec ty) (sqmul_round_sat _ x y)))
   (rv_vsmul_vv x y (unmasked) ty))
 
-(rule 1 (lower (has_type (ty_vec_fits_in_register ty) (sqmul_round_sat x (splat y))))
+(rule 1 (lower (has_type (ty_supported_vec ty) (sqmul_round_sat _ x (splat _ y))))
   (rv_vsmul_vx x y (unmasked) ty))
 
-(rule 2 (lower (has_type (ty_vec_fits_in_register ty) (sqmul_round_sat (splat x) y)))
+(rule 2 (lower (has_type (ty_supported_vec ty) (sqmul_round_sat _ (splat _ x) y)))
   (rv_vsmul_vx y x (unmasked) ty))
 
 ;;;; Rules for `snarrow` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type (ty_vec_fits_in_register out_ty) (snarrow x @ (value_type in_ty) y)))
+(rule (lower (has_type (ty_supported_vec out_ty) (snarrow _ x @ (value_type in_ty) y)))
   (if-let lane_diff (u64_to_uimm5 (u64_udiv (ty_lane_count out_ty) 2)))
   (if-let zero (u64_to_uimm5 0))
   (let ((x_clip VReg (rv_vnclip_wi x zero (unmasked) (vstate_mf2 (ty_half_lanes out_ty))))
@@ -2387,7 +2917,7 @@
 
 ;;;; Rules for `uunarrow` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type (ty_vec_fits_in_register out_ty) (uunarrow x @ (value_type in_ty) y)))
+(rule (lower (has_type (ty_supported_vec out_ty) (uunarrow _ x @ (value_type in_ty) y)))
   (if-let lane_diff (u64_to_uimm5 (u64_udiv (ty_lane_count out_ty) 2)))
   (if-let zero (u64_to_uimm5 0))
   (let ((x_clip VReg (rv_vnclipu_wi x zero (unmasked) (vstate_mf2 (ty_half_lanes out_ty))))
@@ -2400,7 +2930,7 @@
 ;; To correct for this we just remove negative values using `vmax` and then use the normal
 ;; unsigned to unsigned narrowing instruction.
 
-(rule (lower (has_type (ty_vec_fits_in_register out_ty) (unarrow x @ (value_type in_ty) y)))
+(rule (lower (has_type (ty_supported_vec out_ty) (unarrow _ x @ (value_type in_ty) y)))
   (if-let lane_diff (u64_to_uimm5 (u64_udiv (ty_lane_count out_ty) 2)))
   (if-let zero (u64_to_uimm5 0))
   (let ((x_pos VReg (rv_vmax_vx x (zero_reg) (unmasked) in_ty))
diff --git a/cranelift/codegen/src/isa/riscv64/lower.rs b/cranelift/codegen/src/isa/riscv64/lower.rs
index 1477509f39ce..41b114441052 100644
--- a/cranelift/codegen/src/isa/riscv64/lower.rs
+++ b/cranelift/codegen/src/isa/riscv64/lower.rs
@@ -30,4 +30,6 @@ impl LowerBackend for Riscv64Backend {
         // right now riscv64 not support this feature.
         None
     }
+
+    type FactFlowState = ();
 }
diff --git a/cranelift/codegen/src/isa/riscv64/lower/isle.rs b/cranelift/codegen/src/isa/riscv64/lower/isle.rs
index 699ed57b0cec..3c0090d0b2d2 100644
--- a/cranelift/codegen/src/isa/riscv64/lower/isle.rs
+++ b/cranelift/codegen/src/isa/riscv64/lower/isle.rs
@@ -3,11 +3,11 @@
 // Pull in the ISLE generated code.
 #[allow(unused)]
 pub mod generated_code;
-use generated_code::{Context, MInst};
+use generated_code::MInst;
 
 // Types that the generated ISLE code uses via `use super::*`.
-use self::generated_code::{VecAluOpRR, VecLmul};
-use super::{writable_zero_reg, zero_reg};
+use self::generated_code::{FpuOPWidth, VecAluOpRR, VecLmul};
+use crate::isa;
 use crate::isa::riscv64::abi::Riscv64ABICallSite;
 use crate::isa::riscv64::lower::args::{
     FReg, VReg, WritableFReg, WritableVReg, WritableXReg, XReg,
@@ -19,15 +19,13 @@ use crate::machinst::{VCodeConstant, VCodeConstantData};
 use crate::{
     ir::{
         immediates::*, types::*, AtomicRmwOp, BlockCall, ExternalName, Inst, InstructionData,
-        MemFlags, StackSlot, TrapCode, Value, ValueList,
+        MemFlags, Opcode, TrapCode, Value, ValueList,
     },
     isa::riscv64::inst::*,
-    machinst::{ArgPair, InstOutput, Lower},
+    machinst::{ArgPair, InstOutput, IsTailCall},
 };
-use crate::{isa, isle_common_prelude_methods, isle_lower_prelude_methods};
 use regalloc2::PReg;
 use std::boxed::Box;
-use std::convert::TryFrom;
 use std::vec::Vec;
 
 type BoxCallInfo = Box<CallInfo>;
@@ -36,7 +34,6 @@ type BoxReturnCallInfo = Box<ReturnCallInfo>;
 type BoxExternalName = Box<ExternalName>;
 type VecMachLabel = Vec<MachLabel>;
 type VecArgPair = Vec<ArgPair>;
-use crate::machinst::valueregs;
 
 pub(crate) struct RV64IsleContext<'a, 'b, I, B>
 where
@@ -51,8 +48,6 @@ where
 }
 
 impl<'a, 'b> RV64IsleContext<'a, 'b, MInst, Riscv64Backend> {
-    isle_prelude_method_helpers!(Riscv64ABICallSite);
-
     fn new(lower_ctx: &'a mut Lower<'b, MInst>, backend: &'a Riscv64Backend) -> Self {
         Self {
             lower_ctx,
@@ -84,6 +79,7 @@ impl generated_code::Context for RV64IsleContext<'_, '_, MInst, Riscv64Backend>
             self.lower_ctx.sigs(),
             callee_sig,
             &callee,
+            IsTailCall::Yes,
             distance,
             caller_conv,
             self.backend.flags().clone(),
@@ -112,7 +108,7 @@ impl generated_code::Context for RV64IsleContext<'_, '_, MInst, Riscv64Backend>
             self.lower_ctx.sigs(),
             callee_sig,
             callee,
-            Opcode::ReturnCallIndirect,
+            IsTailCall::Yes,
             caller_conv,
             self.backend.flags().clone(),
         );
@@ -121,6 +117,16 @@ impl generated_code::Context for RV64IsleContext<'_, '_, MInst, Riscv64Backend>
         InstOutput::new()
     }
 
+    fn fpu_op_width_from_ty(&mut self, ty: Type) -> FpuOPWidth {
+        match ty {
+            F16 => FpuOPWidth::H,
+            F32 => FpuOPWidth::S,
+            F64 => FpuOPWidth::D,
+            F128 => FpuOPWidth::Q,
+            _ => unimplemented!("Unimplemented FPU Op Width: {ty}"),
+        }
+    }
+
     fn vreg_new(&mut self, r: Reg) -> VReg {
         VReg::new(r).unwrap()
     }
@@ -167,6 +173,74 @@ impl generated_code::Context for RV64IsleContext<'_, '_, MInst, Riscv64Backend>
         *arg0
     }
 
+    fn min_vec_reg_size(&mut self) -> u64 {
+        self.min_vec_reg_size
+    }
+
+    #[inline]
+    fn ty_vec_fits_in_register(&mut self, ty: Type) -> Option<Type> {
+        if ty.is_vector() && (ty.bits() as u64) <= self.min_vec_reg_size() {
+            Some(ty)
+        } else {
+            None
+        }
+    }
+
+    fn ty_supported(&mut self, ty: Type) -> Option<Type> {
+        let lane_type = ty.lane_type();
+        let supported = match ty {
+            // Scalar integers are always supported
+            ty if ty.is_int() => true,
+            // Floating point types depend on certain extensions
+            F16 => self.backend.isa_flags.has_zfh(),
+            // F32 depends on the F extension
+            F32 => self.backend.isa_flags.has_f(),
+            // F64 depends on the D extension
+            F64 => self.backend.isa_flags.has_d(),
+
+            // The base vector extension supports all integer types, up to 64 bits
+            // as long as they fit in a register
+            ty if self.ty_vec_fits_in_register(ty).is_some()
+                && lane_type.is_int()
+                && lane_type.bits() <= 64 =>
+            {
+                true
+            }
+
+            // If the vector type has floating point lanes then the spec states:
+            //
+            // Vector instructions where any floating-point vector operand’s EEW is not a
+            // supported floating-point type width (which includes when FLEN < SEW) are reserved.
+            //
+            // So we also have to check if we support the scalar version of the type.
+            ty if self.ty_vec_fits_in_register(ty).is_some()
+                && lane_type.is_float()
+                && self.ty_supported(lane_type).is_some()
+                // Additionally the base V spec only supports 32 and 64 bit floating point types.
+                && (lane_type.bits() == 32 || lane_type.bits() == 64) =>
+            {
+                true
+            }
+
+            // Otherwise do not match
+            _ => false,
+        };
+
+        if supported {
+            Some(ty)
+        } else {
+            None
+        }
+    }
+
+    fn ty_supported_float(&mut self, ty: Type) -> Option<Type> {
+        self.ty_supported(ty).filter(|ty| ty.is_float())
+    }
+
+    fn ty_supported_vec(&mut self, ty: Type) -> Option<Type> {
+        self.ty_supported(ty).filter(|ty| ty.is_vector())
+    }
+
     fn load_ra(&mut self) -> Reg {
         if self.backend.flags.preserve_frame_pointers() {
             let tmp = self.temp_writable_reg(I64);
@@ -174,21 +248,13 @@ impl generated_code::Context for RV64IsleContext<'_, '_, MInst, Riscv64Backend>
                 rd: tmp,
                 op: LoadOP::Ld,
                 flags: MemFlags::trusted(),
-                from: AMode::FPOffset(8, I64),
+                from: AMode::FPOffset(8),
             });
             tmp.to_reg()
         } else {
             link_reg()
         }
     }
-    fn int_zero_reg(&mut self, ty: Type) -> ValueRegs {
-        assert!(ty.is_int(), "{:?}", ty);
-        if ty.bits() == 128 {
-            ValueRegs::two(self.zero_reg(), self.zero_reg())
-        } else {
-            ValueRegs::one(self.zero_reg())
-        }
-    }
 
     fn label_to_br_target(&mut self, label: MachLabel) -> CondBrTarget {
         CondBrTarget::Label(label)
@@ -198,6 +264,20 @@ impl generated_code::Context for RV64IsleContext<'_, '_, MInst, Riscv64Backend>
         Imm12::from_i16(imm.as_i16() & (x as i16))
     }
 
+    fn fli_constant_from_u64(&mut self, ty: Type, imm: u64) -> Option<FliConstant> {
+        FliConstant::maybe_from_u64(ty, imm)
+    }
+
+    fn fli_constant_from_negated_u64(&mut self, ty: Type, imm: u64) -> Option<FliConstant> {
+        let negated_imm = match ty {
+            F64 => imm ^ 0x8000000000000000,
+            F32 => imm ^ 0x80000000,
+            _ => unimplemented!(),
+        };
+
+        FliConstant::maybe_from_u64(ty, negated_imm)
+    }
+
     fn i64_generate_imm(&mut self, imm: i64) -> Option<(Imm20, Imm12)> {
         MInst::generate_imm(imm as u64)
     }
@@ -292,8 +372,22 @@ impl generated_code::Context for RV64IsleContext<'_, '_, MInst, Riscv64Backend>
         writable_zero_reg()
     }
     #[inline]
-    fn zero_reg(&mut self) -> Reg {
-        zero_reg()
+    fn zero_reg(&mut self) -> XReg {
+        XReg::new(zero_reg()).unwrap()
+    }
+    fn is_non_zero_reg(&mut self, reg: XReg) -> Option<()> {
+        if reg != self.zero_reg() {
+            Some(())
+        } else {
+            None
+        }
+    }
+    fn is_zero_reg(&mut self, reg: XReg) -> Option<()> {
+        if reg == self.zero_reg() {
+            Some(())
+        } else {
+            None
+        }
     }
     #[inline]
     fn imm_from_bits(&mut self, val: u64) -> Imm12 {
@@ -304,10 +398,6 @@ impl generated_code::Context for RV64IsleContext<'_, '_, MInst, Riscv64Backend>
         Imm12::maybe_from_i64(val).unwrap()
     }
 
-    fn gen_default_frm(&mut self) -> OptionFloatRoundingMode {
-        None
-    }
-
     fn frm_bits(&mut self, frm: &FRM) -> UImm5 {
         UImm5::maybe_from_u8(frm.bits()).unwrap()
     }
@@ -320,12 +410,15 @@ impl generated_code::Context for RV64IsleContext<'_, '_, MInst, Riscv64Backend>
         if let Some(res) = Imm12::maybe_from_i64(val as i64) {
             res
         } else {
-            panic!("Unable to make an Imm12 value from {}", val)
+            panic!("Unable to make an Imm12 value from {val}")
         }
     }
     fn imm12_const_add(&mut self, val: i32, add: i32) -> Imm12 {
         Imm12::maybe_from_i64((val + add) as i64).unwrap()
     }
+    fn imm12_add(&mut self, val: Imm12, add: i32) -> Option<Imm12> {
+        Imm12::maybe_from_i64((i32::from(val.as_i16()) + add).into())
+    }
 
     //
     fn gen_shamt(&mut self, ty: Type, shamt: XReg) -> ValueRegs {
@@ -364,6 +457,14 @@ impl generated_code::Context for RV64IsleContext<'_, '_, MInst, Riscv64Backend>
         self.backend.isa_flags.has_m()
     }
 
+    fn has_zfa(&mut self) -> bool {
+        self.backend.isa_flags.has_zfa()
+    }
+
+    fn has_zfh(&mut self) -> bool {
+        self.backend.isa_flags.has_zfh()
+    }
+
     fn has_zbkb(&mut self) -> bool {
         self.backend.isa_flags.has_zbkb()
     }
@@ -384,24 +485,27 @@ impl generated_code::Context for RV64IsleContext<'_, '_, MInst, Riscv64Backend>
         self.backend.isa_flags.has_zbs()
     }
 
-    fn gen_reg_offset_amode(&mut self, base: Reg, offset: i64, ty: Type) -> AMode {
-        AMode::RegOffset(base, offset, ty)
+    fn has_zicond(&mut self) -> bool {
+        self.backend.isa_flags.has_zicond()
+    }
+
+    fn gen_reg_offset_amode(&mut self, base: Reg, offset: i64) -> AMode {
+        AMode::RegOffset(base, offset)
     }
 
-    fn gen_sp_offset_amode(&mut self, offset: i64, ty: Type) -> AMode {
-        AMode::SPOffset(offset, ty)
+    fn gen_sp_offset_amode(&mut self, offset: i64) -> AMode {
+        AMode::SPOffset(offset)
     }
 
-    fn gen_fp_offset_amode(&mut self, offset: i64, ty: Type) -> AMode {
-        AMode::FPOffset(offset, ty)
+    fn gen_fp_offset_amode(&mut self, offset: i64) -> AMode {
+        AMode::FPOffset(offset)
     }
 
-    fn gen_stack_slot_amode(&mut self, ss: StackSlot, offset: i64, ty: Type) -> AMode {
-        // Offset from beginning of stackslot area, which is at nominal SP (see
-        // [MemArg::NominalSPOffset] for more details on nominal SP tracking).
+    fn gen_stack_slot_amode(&mut self, ss: StackSlot, offset: i64) -> AMode {
+        // Offset from beginning of stackslot area.
         let stack_off = self.lower_ctx.abi().sized_stackslot_offsets()[ss] as i64;
         let sp_off: i64 = stack_off + offset;
-        AMode::NominalSPOffset(sp_off, ty)
+        AMode::SlotOffset(sp_off)
     }
 
     fn gen_const_amode(&mut self, c: VCodeConstant) -> AMode {
@@ -425,6 +529,11 @@ impl generated_code::Context for RV64IsleContext<'_, '_, MInst, Riscv64Backend>
             _ => None,
         }
     }
+
+    fn sinkable_inst(&mut self, val: Value) -> Option<Inst> {
+        self.is_sinkable_inst(val)
+    }
+
     fn load_op(&mut self, ty: Type) -> LoadOP {
         LoadOP::from_type(ty)
     }
@@ -482,6 +591,11 @@ impl generated_code::Context for RV64IsleContext<'_, '_, MInst, Riscv64Backend>
         }
     }
 
+    #[inline]
+    fn int_compare_decompose(&mut self, cmp: IntegerCompare) -> (IntCC, XReg, XReg) {
+        (cmp.kind, self.xreg_new(cmp.rs1), self.xreg_new(cmp.rs2))
+    }
+
     #[inline]
     fn vstate_from_type(&mut self, ty: Type) -> VState {
         VState::from_type(ty)
@@ -498,21 +612,85 @@ impl generated_code::Context for RV64IsleContext<'_, '_, MInst, Riscv64Backend>
         }
     }
 
-    fn min_vec_reg_size(&mut self) -> u64 {
-        self.min_vec_reg_size
+    fn vec_alu_rr_dst_type(&mut self, op: &VecAluOpRR) -> Type {
+        MInst::canonical_type_for_rc(op.dst_regclass())
     }
 
-    #[inline]
-    fn ty_vec_fits_in_register(&mut self, ty: Type) -> Option<Type> {
-        if ty.is_vector() && (ty.bits() as u64) <= self.min_vec_reg_size() {
-            Some(ty)
-        } else {
-            None
+    fn bclr_imm(&mut self, ty: Type, i: u64) -> Option<Imm12> {
+        // Only consider those bits in the immediate which are up to the width
+        // of `ty`.
+        let neg = !i & (u64::MAX >> (64 - ty.bits()));
+        if neg.count_ones() != 1 {
+            return None;
         }
+        Imm12::maybe_from_u64(neg.trailing_zeros().into())
     }
 
-    fn vec_alu_rr_dst_type(&mut self, op: &VecAluOpRR) -> Type {
-        MInst::canonical_type_for_rc(op.dst_regclass())
+    fn binvi_imm(&mut self, i: u64) -> Option<Imm12> {
+        if i.count_ones() != 1 {
+            return None;
+        }
+        Imm12::maybe_from_u64(i.trailing_zeros().into())
+    }
+    fn bseti_imm(&mut self, i: u64) -> Option<Imm12> {
+        self.binvi_imm(i)
+    }
+
+    fn fcvt_smin_bound(&mut self, float: Type, int: Type, saturating: bool) -> u64 {
+        match (int, float) {
+            // Saturating cases for larger integers are handled using the
+            // `fcvt.{w,d}.{s,d}` instruction directly, that automatically
+            // saturates up/down to the correct limit.
+            //
+            // NB: i32/i64 don't use this function because the native RISC-V
+            // instruction does everything we already need, so only cases for
+            // i8/i16 are listed here.
+            (I8, F32) if saturating => f32::from(i8::MIN).to_bits().into(),
+            (I8, F64) if saturating => f64::from(i8::MIN).to_bits(),
+            (I16, F32) if saturating => f32::from(i16::MIN).to_bits().into(),
+            (I16, F64) if saturating => f64::from(i16::MIN).to_bits(),
+
+            (_, F32) if !saturating => f32_cvt_to_int_bounds(true, int.bits()).0.to_bits().into(),
+            (_, F64) if !saturating => f64_cvt_to_int_bounds(true, int.bits()).0.to_bits(),
+            _ => unimplemented!(),
+        }
+    }
+
+    fn fcvt_smax_bound(&mut self, float: Type, int: Type, saturating: bool) -> u64 {
+        // NB: see `fcvt_smin_bound` for some more comments
+        match (int, float) {
+            (I8, F32) if saturating => f32::from(i8::MAX).to_bits().into(),
+            (I8, F64) if saturating => f64::from(i8::MAX).to_bits(),
+            (I16, F32) if saturating => f32::from(i16::MAX).to_bits().into(),
+            (I16, F64) if saturating => f64::from(i16::MAX).to_bits(),
+
+            (_, F32) if !saturating => f32_cvt_to_int_bounds(true, int.bits()).1.to_bits().into(),
+            (_, F64) if !saturating => f64_cvt_to_int_bounds(true, int.bits()).1.to_bits(),
+            _ => unimplemented!(),
+        }
+    }
+
+    fn fcvt_umax_bound(&mut self, float: Type, int: Type, saturating: bool) -> u64 {
+        // NB: see `fcvt_smin_bound` for some more comments
+        match (int, float) {
+            (I8, F32) if saturating => f32::from(u8::MAX).to_bits().into(),
+            (I8, F64) if saturating => f64::from(u8::MAX).to_bits(),
+            (I16, F32) if saturating => f32::from(u16::MAX).to_bits().into(),
+            (I16, F64) if saturating => f64::from(u16::MAX).to_bits(),
+
+            (_, F32) if !saturating => f32_cvt_to_int_bounds(false, int.bits()).1.to_bits().into(),
+            (_, F64) if !saturating => f64_cvt_to_int_bounds(false, int.bits()).1.to_bits(),
+            _ => unimplemented!(),
+        }
+    }
+
+    fn fcvt_umin_bound(&mut self, float: Type, saturating: bool) -> u64 {
+        assert!(!saturating);
+        match float {
+            F32 => (-1.0f32).to_bits().into(),
+            F64 => (-1.0f64).to_bits(),
+            _ => unimplemented!(),
+        }
     }
 }
 
@@ -538,5 +716,5 @@ pub(crate) fn lower_branch(
     // TODO: reuse the ISLE context across lowerings so we can reuse its
     // internal heap allocations.
     let mut isle_ctx = RV64IsleContext::new(lower_ctx, backend);
-    generated_code::constructor_lower_branch(&mut isle_ctx, branch, &targets.to_vec())
+    generated_code::constructor_lower_branch(&mut isle_ctx, branch, targets)
 }
diff --git a/cranelift/codegen/src/isa/riscv64/lower/isle/generated_code.rs b/cranelift/codegen/src/isa/riscv64/lower/isle/generated_code.rs
index c595c311d05a..d5d1feae93bb 100644
--- a/cranelift/codegen/src/isa/riscv64/lower/isle/generated_code.rs
+++ b/cranelift/codegen/src/isa/riscv64/lower/isle/generated_code.rs
@@ -4,6 +4,6 @@
 // mod generated_code;` trick either.
 #![allow(dead_code, unreachable_code, unreachable_patterns)]
 #![allow(unused_imports, unused_variables, non_snake_case, unused_mut)]
-#![allow(irrefutable_let_patterns)]
+#![allow(irrefutable_let_patterns, clippy::clone_on_copy)]
 
 include!(concat!(env!("ISLE_DIR"), "/isle_riscv64.rs"));
diff --git a/cranelift/codegen/src/isa/riscv64/mod.rs b/cranelift/codegen/src/isa/riscv64/mod.rs
index 6d727bbc6267..0035a721048c 100644
--- a/cranelift/codegen/src/isa/riscv64/mod.rs
+++ b/cranelift/codegen/src/isa/riscv64/mod.rs
@@ -155,6 +155,11 @@ impl TargetIsa for Riscv64Backend {
         inst::Inst::function_alignment()
     }
 
+    fn page_size_align_log2(&self) -> u8 {
+        debug_assert_eq!(1 << 12, 0x1000);
+        12
+    }
+
     #[cfg(feature = "disas")]
     fn to_capstone(&self) -> Result<capstone::Capstone, capstone::Error> {
         use capstone::prelude::*;
@@ -180,7 +185,7 @@ impl TargetIsa for Riscv64Backend {
         let mut cs = cs_builder.build()?;
 
         // Similar to AArch64, RISC-V uses inline constants rather than a separate
-        // constant pool. We want to skip dissasembly over inline constants instead
+        // constant pool. We want to skip disassembly over inline constants instead
         // of stopping on invalid bytes.
         cs.set_skipdata(true)?;
         Ok(cs)
diff --git a/cranelift/codegen/src/isa/s390x/abi.rs b/cranelift/codegen/src/isa/s390x/abi.rs
index 736254f3e4c8..20082a80b758 100644
--- a/cranelift/codegen/src/isa/s390x/abi.rs
+++ b/cranelift/codegen/src/isa/s390x/abi.rs
@@ -50,11 +50,11 @@
 //!                              +---------------------------+
 //!                              |          ...              |
 //!                              | spill slots               |
-//!                              | (accessed via nominal SP) |
+//!                              | (accessed via SP)         |
 //!                              |          ...              |
 //!                              | stack slots               |
-//!                              | (accessed via nominal SP) |
-//! nominal SP --------------->  | (alloc'd by prologue)     |
+//!                              | (accessed via SP)         |
+//!                              | (alloc'd by prologue)     |
 //!                              +---------------------------+
 //!                              |          ...              |
 //!                              | args for call             |
@@ -65,6 +65,72 @@
 //!
 //!   (low address)
 //! ```
+//!
+//!
+//! The tail-call ABI has the following changes to the system ABI:
+//!
+//! - %r6 and %r7 are both non-callee-saved argument registers.
+//!
+//! - The argument save area for outgoing (non-tail) calls to
+//!   a tail-call ABI function is placed *below* the caller's
+//!   stack frame.  This means the caller temporarily allocates
+//!   a part of the callee's frame, including temporary space
+//!   for a register save area holding a copy of the backchain.
+//!
+//! - For tail calls, the caller puts outgoing arguments at the
+//!   very top of its stack frame, overlapping the incoming
+//!   argument area.  This is extended by the prolog if needed.
+//!
+//! Overall, the tail-call stack frame layout on s390x is as follows:
+//!
+//! ```plain
+//!   (high address)
+//!
+//!                              +---------------------------+
+//!                              |          ...              |
+//! CFA                  ----->  | (caller's frame)          |
+//!                              +---------------------------+
+//!                              |          ...              |
+//!                              | 160 bytes reg save area   |
+//!                              | (used to save GPRs)       |
+//! SP at function return----->  | (incl. caller's backchain)|
+//!                              +---------------------------+
+//!                              |          ...              |
+//!                              | incoming stack args       |
+//! SP at function entry ----->  | (incl. backchain copy)    |
+//!                              +---------------------------+
+//!                              |          ...              |
+//!                              | outgoing tail call args   |
+//!                              | (overlaps incoming args)  |
+//!                              | (incl. backchain copy)    |
+//! SP at tail cail       ---->  | (alloc'd by prologue)     |
+//!                              +---------------------------+
+//!                              |          ...              |
+//!                              | clobbered callee-saves    |
+//!                              | (used to save FPRs)       |
+//! unwind-frame base     ---->  | (alloc'd by prologue)     |
+//!                              +---------------------------+
+//!                              |          ...              |
+//!                              | spill slots               |
+//!                              | (accessed via SP)         |
+//!                              |          ...              |
+//!                              | stack slots               |
+//!                              | (accessed via SP)         |
+//!                              | (alloc'd by prologue)     |
+//!                              +---------------------------+
+//!                              |          ...              |
+//!                              | outgoing calls return buf |
+//!                              | outgoing reg save area    |
+//!                              | (alloc'd by prologue)     |
+//! SP during function  ------>  | (incl. callee's backchain)|
+//!                              +---------------------------+
+//!                              |          ...              |
+//!                              | outgoing stack args       |
+//!                              | (alloc'd by call sequence)|
+//! SP at non-tail call  ----->  | (incl. backchain copy)    |
+//!                              +---------------------------+
+//!   (low address)
+//! ```
 
 use crate::ir;
 use crate::ir::condcodes::IntCC;
@@ -76,13 +142,11 @@ use crate::isa;
 use crate::isa::s390x::{inst::*, settings as s390x_settings};
 use crate::isa::unwind::UnwindInst;
 use crate::machinst::*;
-use crate::machinst::{RealReg, Reg, RegClass, Writable};
 use crate::settings;
 use crate::{CodegenError, CodegenResult};
 use alloc::vec::Vec;
-use regalloc2::{MachineEnv, PReg, PRegSet};
+use regalloc2::{MachineEnv, PRegSet};
 use smallvec::{smallvec, SmallVec};
-use std::convert::TryFrom;
 use std::sync::OnceLock;
 
 // We use a generic implementation that factors out ABI commonalities.
@@ -94,7 +158,7 @@ pub type S390xCallee = Callee<S390xMachineDeps>;
 
 fn in_int_reg(ty: Type) -> bool {
     match ty {
-        types::I8 | types::I16 | types::I32 | types::I64 | types::R64 => true,
+        types::I8 | types::I16 | types::I32 | types::I64 => true,
         _ => false,
     }
 }
@@ -110,13 +174,14 @@ fn in_vec_reg(ty: Type) -> bool {
     ty.is_vector() && ty.bits() == 128
 }
 
-fn get_intreg_for_arg(idx: usize) -> Option<Reg> {
+fn get_intreg_for_arg(call_conv: isa::CallConv, idx: usize) -> Option<Reg> {
     match idx {
         0 => Some(regs::gpr(2)),
         1 => Some(regs::gpr(3)),
         2 => Some(regs::gpr(4)),
         3 => Some(regs::gpr(5)),
         4 => Some(regs::gpr(6)),
+        5 if call_conv == isa::CallConv::Tail => Some(regs::gpr(7)),
         _ => None,
     }
 }
@@ -145,13 +210,15 @@ fn get_vecreg_for_arg(idx: usize) -> Option<Reg> {
     }
 }
 
-fn get_intreg_for_ret(idx: usize) -> Option<Reg> {
+fn get_intreg_for_ret(call_conv: isa::CallConv, idx: usize) -> Option<Reg> {
     match idx {
         0 => Some(regs::gpr(2)),
         // ABI extension to support multi-value returns:
         1 => Some(regs::gpr(3)),
         2 => Some(regs::gpr(4)),
         3 => Some(regs::gpr(5)),
+        4 if call_conv == isa::CallConv::Tail => Some(regs::gpr(6)),
+        5 if call_conv == isa::CallConv::Tail => Some(regs::gpr(7)),
         _ => None,
     }
 }
@@ -193,11 +260,10 @@ pub static REG_SAVE_AREA_SIZE: u32 = 160;
 impl Into<MemArg> for StackAMode {
     fn into(self) -> MemArg {
         match self {
-            StackAMode::FPOffset(off, _ty) => MemArg::InitialSPOffset { off },
-            StackAMode::NominalSPOffset(off, _ty) => MemArg::NominalSPOffset { off },
-            StackAMode::SPOffset(off, _ty) => {
-                MemArg::reg_plus_off(stack_reg(), off, MemFlags::trusted())
-            }
+            // Argument area always begins at the initial SP.
+            StackAMode::IncomingArg(off, _) => MemArg::InitialSPOffset { off },
+            StackAMode::Slot(off) => MemArg::SlotOffset { off },
+            StackAMode::OutgoingArg(off) => MemArg::NominalSPOffset { off },
         }
     }
 }
@@ -222,21 +288,18 @@ impl ABIMachineSpec for S390xMachineDeps {
         8
     }
 
-    fn compute_arg_locs<'a, I>(
+    fn compute_arg_locs(
         call_conv: isa::CallConv,
         _flags: &settings::Flags,
-        params: I,
+        params: &[ir::AbiParam],
         args_or_rets: ArgsOrRets,
         add_ret_area_ptr: bool,
-        mut args: ArgsAccumulator<'_>,
-    ) -> CodegenResult<(u32, Option<usize>)>
-    where
-        I: IntoIterator<Item = &'a ir::AbiParam>,
-    {
+        mut args: ArgsAccumulator,
+    ) -> CodegenResult<(u32, Option<usize>)> {
         assert_ne!(
             call_conv,
-            isa::CallConv::Tail,
-            "s390x does not support the 'tail' calling convention yet"
+            isa::CallConv::Winch,
+            "s390x does not support the 'winch' calling convention yet"
         );
 
         let mut next_gpr = 0;
@@ -244,7 +307,11 @@ impl ABIMachineSpec for S390xMachineDeps {
         let mut next_vr = 0;
         let mut next_stack: u32 = 0;
 
-        if args_or_rets == ArgsOrRets::Args {
+        // The bottom of the stack frame holds the register save area.  To simplify
+        // offset computation, include this area as part of the argument area;
+        // however, this does not apply to the tail-call convention, which uses the
+        // callee frame instead to pass arguments.
+        if call_conv != isa::CallConv::Tail && args_or_rets == ArgsOrRets::Args {
             next_stack = REG_SAVE_AREA_SIZE;
         }
 
@@ -262,8 +329,8 @@ impl ABIMachineSpec for S390xMachineDeps {
 
             let (next_reg, candidate, implicit_ref) = if intreg {
                 let candidate = match args_or_rets {
-                    ArgsOrRets::Args => get_intreg_for_arg(next_gpr),
-                    ArgsOrRets::Rets => get_intreg_for_ret(next_gpr),
+                    ArgsOrRets::Args => get_intreg_for_arg(call_conv, next_gpr),
+                    ArgsOrRets::Rets => get_intreg_for_ret(call_conv, next_gpr),
                 };
                 (&mut next_gpr, candidate, None)
             } else if fltreg {
@@ -287,7 +354,7 @@ impl ABIMachineSpec for S390xMachineDeps {
                     // For arguments, implicitly convert to pointer type.
                     let implicit_ref = Some(param.value_type);
                     param = ir::AbiParam::new(types::I64);
-                    let candidate = get_intreg_for_arg(next_gpr);
+                    let candidate = get_intreg_for_arg(call_conv, next_gpr);
                     (&mut next_gpr, candidate, implicit_ref)
                 }
             };
@@ -358,7 +425,7 @@ impl ABIMachineSpec for S390xMachineDeps {
         let extra_arg = if add_ret_area_ptr {
             debug_assert!(args_or_rets == ArgsOrRets::Args);
             // The return pointer is passed as first argument.
-            if let Some(reg) = get_intreg_for_arg(0) {
+            if let Some(reg) = get_intreg_for_arg(call_conv, 0) {
                 args.push(ABIArg::reg(
                     reg.to_real_reg().unwrap(),
                     types::I64,
@@ -401,11 +468,37 @@ impl ABIMachineSpec for S390xMachineDeps {
             return Err(CodegenError::ImplLimitExceeded);
         }
 
-        Ok((next_stack, extra_arg))
-    }
+        // With the tail-call convention, arguments are passed in the *callee*'s
+        // frame instead of the caller's frame.  Update all offsets accordingly
+        // (note that resulting offsets will all be negative).
+        if call_conv == isa::CallConv::Tail && args_or_rets == ArgsOrRets::Args && next_stack != 0 {
+            for arg in args.args_mut() {
+                match arg {
+                    ABIArg::Slots { slots, .. } => {
+                        for slot in slots {
+                            match slot {
+                                ABIArgSlot::Reg { .. } => {}
+                                ABIArgSlot::Stack { offset, .. } => {
+                                    *offset -= next_stack as i64;
+                                }
+                            }
+                        }
+                    }
+                    ABIArg::StructArg { offset, .. } => {
+                        *offset -= next_stack as i64;
+                    }
+                    ABIArg::ImplicitPtrArg { offset, .. } => {
+                        *offset -= next_stack as i64;
+                    }
+                }
+            }
+            // If we have any stack arguments, also allow for a temporary copy
+            // of the register save area.  This is only used until the callee
+            // has finished setting up its own frame.
+            next_stack += REG_SAVE_AREA_SIZE;
+        }
 
-    fn fp_to_arg_offset(_call_conv: isa::CallConv, _flags: &settings::Flags) -> i64 {
-        0
+        Ok((next_stack, extra_arg))
     }
 
     fn gen_load_stack(mem: StackAMode, into_reg: Writable<Reg>, ty: Type) -> Inst {
@@ -498,7 +591,7 @@ impl ABIMachineSpec for S390xMachineDeps {
         insts
     }
 
-    fn gen_get_stack_addr(mem: StackAMode, into_reg: Writable<Reg>, _ty: Type) -> Inst {
+    fn gen_get_stack_addr(mem: StackAMode, into_reg: Writable<Reg>) -> Inst {
         let mem = mem.into();
         Inst::LoadAddr { rd: into_reg, mem }
     }
@@ -541,12 +634,6 @@ impl ABIMachineSpec for S390xMachineDeps {
         insts
     }
 
-    fn gen_nominal_sp_adj(offset: i32) -> Inst {
-        Inst::VirtualSPOffsetAdj {
-            offset: offset.into(),
-        }
-    }
-
     fn gen_prologue_frame_setup(
         _call_conv: isa::CallConv,
         _flags: &settings::Flags,
@@ -557,19 +644,20 @@ impl ABIMachineSpec for S390xMachineDeps {
     }
 
     fn gen_epilogue_frame_restore(
-        call_conv: isa::CallConv,
+        _call_conv: isa::CallConv,
         _flags: &settings::Flags,
         _isa_flags: &s390x_settings::Flags,
-        frame_layout: &FrameLayout,
+        _frame_layout: &FrameLayout,
     ) -> SmallInstVec<Inst> {
-        let mut insts = SmallVec::new();
-        if call_conv == isa::CallConv::Tail && frame_layout.stack_args_size > 0 {
-            insts.extend(Self::gen_sp_reg_adjust(
-                frame_layout.stack_args_size.try_into().unwrap(),
-            ));
-        }
-        insts.push(Inst::Ret { link: gpr(14) });
-        insts
+        SmallVec::new()
+    }
+
+    fn gen_return(
+        _call_conv: isa::CallConv,
+        _isa_flags: &s390x_settings::Flags,
+        _frame_layout: &FrameLayout,
+    ) -> SmallInstVec<Inst> {
+        smallvec![Inst::Ret { link: gpr(14) }]
     }
 
     fn gen_probestack(_insts: &mut SmallInstVec<Self::I>, _: u32) {
@@ -588,53 +676,71 @@ impl ABIMachineSpec for S390xMachineDeps {
     }
 
     fn gen_clobber_save(
-        _call_conv: isa::CallConv,
+        call_conv: isa::CallConv,
         flags: &settings::Flags,
         frame_layout: &FrameLayout,
     ) -> SmallVec<[Inst; 16]> {
         let mut insts = SmallVec::new();
 
-        // Collect clobbered registers.
-        let (first_clobbered_gpr, clobbered_fpr) =
-            get_clobbered_gpr_fpr(&frame_layout.clobbered_callee_saves);
+        // With the tail call convention, the caller already allocated the
+        // part of our stack frame that contains incoming arguments.
+        let incoming_tail_args_size = if call_conv == isa::CallConv::Tail {
+            frame_layout.incoming_args_size
+        } else {
+            0
+        };
+
+        // Define unwind stack frame.
         if flags.unwind_info() {
             insts.push(Inst::Unwind {
                 inst: UnwindInst::DefineNewFrame {
-                    offset_upward_to_caller_sp: REG_SAVE_AREA_SIZE,
-                    offset_downward_to_clobbers: frame_layout.clobber_size,
+                    offset_upward_to_caller_sp: REG_SAVE_AREA_SIZE + incoming_tail_args_size,
+                    offset_downward_to_clobbers: frame_layout.clobber_size
+                        - incoming_tail_args_size,
                 },
             });
         }
 
         // Use STMG to save clobbered GPRs into save area.
-        if first_clobbered_gpr < 16 {
-            let offset = 8 * first_clobbered_gpr as i64;
+        // Note that we always save SP (%r15) here if anything is saved.
+        if let Some((first_clobbered_gpr, _)) = get_clobbered_gprs(frame_layout) {
+            let offset = 8 * first_clobbered_gpr as i64 + incoming_tail_args_size as i64;
             insts.push(Inst::StoreMultiple64 {
                 rt: gpr(first_clobbered_gpr),
                 rt2: gpr(15),
                 mem: MemArg::reg_plus_off(stack_reg(), offset, MemFlags::trusted()),
             });
-        }
-        if flags.unwind_info() {
-            for i in first_clobbered_gpr..16 {
-                insts.push(Inst::Unwind {
-                    inst: UnwindInst::SaveReg {
-                        clobber_offset: frame_layout.clobber_size + (i * 8) as u32,
-                        reg: gpr(i).to_real_reg().unwrap(),
-                    },
-                });
+            if flags.unwind_info() {
+                for i in first_clobbered_gpr..16 {
+                    insts.push(Inst::Unwind {
+                        inst: UnwindInst::SaveReg {
+                            clobber_offset: frame_layout.clobber_size + (i * 8) as u32,
+                            reg: gpr(i).to_real_reg().unwrap(),
+                        },
+                    });
+                }
             }
         }
 
         // Save current stack pointer value if we need to write the backchain.
         if flags.preserve_frame_pointers() {
-            insts.push(Inst::mov64(writable_gpr(1), stack_reg()));
+            if incoming_tail_args_size == 0 {
+                insts.push(Inst::mov64(writable_gpr(1), stack_reg()));
+            } else {
+                insts.extend(Self::gen_add_imm(
+                    call_conv,
+                    writable_gpr(1),
+                    stack_reg(),
+                    incoming_tail_args_size,
+                ));
+            }
         }
 
         // Decrement stack pointer.
         let stack_size = frame_layout.outgoing_args_size as i32
             + frame_layout.clobber_size as i32
-            + frame_layout.fixed_frame_storage_size as i32;
+            + frame_layout.fixed_frame_storage_size as i32
+            - incoming_tail_args_size as i32;
         insts.extend(Self::gen_sp_reg_adjust(-stack_size));
         if flags.unwind_info() {
             insts.push(Inst::Unwind {
@@ -644,11 +750,6 @@ impl ABIMachineSpec for S390xMachineDeps {
             });
         }
 
-        let sp_adj = frame_layout.outgoing_args_size as i32;
-        if sp_adj > 0 {
-            insts.push(Self::gen_nominal_sp_adj(sp_adj));
-        }
-
         // Write the stack backchain if requested, using the value saved above.
         if flags.preserve_frame_pointers() {
             insts.push(Inst::Store64 {
@@ -658,7 +759,7 @@ impl ABIMachineSpec for S390xMachineDeps {
         }
 
         // Save FPRs.
-        for (i, reg) in clobbered_fpr.iter().enumerate() {
+        for (i, reg) in get_clobbered_fprs(frame_layout).iter().enumerate() {
             insts.push(Inst::VecStoreLane {
                 size: 64,
                 rd: reg.to_reg().into(),
@@ -685,54 +786,17 @@ impl ABIMachineSpec for S390xMachineDeps {
     }
 
     fn gen_clobber_restore(
-        _call_conv: isa::CallConv,
+        call_conv: isa::CallConv,
         _flags: &settings::Flags,
         frame_layout: &FrameLayout,
     ) -> SmallVec<[Inst; 16]> {
         let mut insts = SmallVec::new();
 
-        // Collect clobbered registers.
-        let (first_clobbered_gpr, clobbered_fpr) =
-            get_clobbered_gpr_fpr(&frame_layout.clobbered_callee_saves);
-
         // Restore FPRs.
-        for (i, reg) in clobbered_fpr.iter().enumerate() {
-            insts.push(Inst::VecLoadLaneUndef {
-                size: 64,
-                rd: Writable::from_reg(reg.to_reg().into()),
-                mem: MemArg::reg_plus_off(
-                    stack_reg(),
-                    (i * 8) as i64
-                        + frame_layout.outgoing_args_size as i64
-                        + frame_layout.fixed_frame_storage_size as i64,
-                    MemFlags::trusted(),
-                ),
-                lane_imm: 0,
-            });
-        }
-
-        // Increment stack pointer unless it will be restored implicitly.
-        let stack_size = frame_layout.outgoing_args_size as i32
-            + frame_layout.clobber_size as i32
-            + frame_layout.fixed_frame_storage_size as i32;
-        let implicit_sp_restore = first_clobbered_gpr < 16
-            && SImm20::maybe_from_i64(8 * first_clobbered_gpr as i64 + stack_size as i64).is_some();
-        if !implicit_sp_restore {
-            insts.extend(Self::gen_sp_reg_adjust(stack_size));
-        }
+        insts.extend(gen_restore_fprs(frame_layout));
 
-        // Use LMG to restore clobbered GPRs from save area.
-        if first_clobbered_gpr < 16 {
-            let mut offset = 8 * first_clobbered_gpr as i64;
-            if implicit_sp_restore {
-                offset += stack_size as i64;
-            }
-            insts.push(Inst::LoadMultiple64 {
-                rt: writable_gpr(first_clobbered_gpr),
-                rt2: writable_gpr(15),
-                mem: MemArg::reg_plus_off(stack_reg(), offset, MemFlags::trusted()),
-            });
-        }
+        // Restore GPRs (including SP).
+        insts.extend(gen_restore_gprs(call_conv, frame_layout, 0));
 
         insts
     }
@@ -742,7 +806,6 @@ impl ABIMachineSpec for S390xMachineDeps {
         _uses: CallArgList,
         _defs: CallRetList,
         _clobbers: PRegSet,
-        _opcode: ir::Opcode,
         _tmp: Writable<Reg>,
         _callee_conv: isa::CallConv,
         _caller_conv: isa::CallConv,
@@ -774,23 +837,24 @@ impl ABIMachineSpec for S390xMachineDeps {
         }
     }
 
-    /// Get the current virtual-SP offset from an instruction-emission state.
-    fn get_virtual_sp_offset_from_state(s: &EmitState) -> i64 {
-        s.virtual_sp_offset
-    }
-
-    /// Get the nominal-SP-to-FP offset from an instruction-emission state.
-    fn get_nominal_sp_to_fp(s: &EmitState) -> i64 {
-        s.initial_sp_offset
-    }
-
-    fn get_machine_env(_flags: &settings::Flags, _call_conv: isa::CallConv) -> &MachineEnv {
-        static MACHINE_ENV: OnceLock<MachineEnv> = OnceLock::new();
-        MACHINE_ENV.get_or_init(create_machine_env)
+    fn get_machine_env(_flags: &settings::Flags, call_conv: isa::CallConv) -> &MachineEnv {
+        match call_conv {
+            isa::CallConv::Tail => {
+                static TAIL_MACHINE_ENV: OnceLock<MachineEnv> = OnceLock::new();
+                TAIL_MACHINE_ENV.get_or_init(tail_create_machine_env)
+            }
+            _ => {
+                static SYSV_MACHINE_ENV: OnceLock<MachineEnv> = OnceLock::new();
+                SYSV_MACHINE_ENV.get_or_init(sysv_create_machine_env)
+            }
+        }
     }
 
-    fn get_regs_clobbered_by_call(_call_conv_of_callee: isa::CallConv) -> PRegSet {
-        CLOBBERS
+    fn get_regs_clobbered_by_call(call_conv_of_callee: isa::CallConv) -> PRegSet {
+        match call_conv_of_callee {
+            isa::CallConv::Tail => TAIL_CLOBBERS,
+            _ => SYSV_CLOBBERS,
+        }
     }
 
     fn get_ext_mode(
@@ -806,7 +870,8 @@ impl ABIMachineSpec for S390xMachineDeps {
         _sig: &Signature,
         regs: &[Writable<RealReg>],
         _is_leaf: bool,
-        stack_args_size: u32,
+        incoming_args_size: u32,
+        tail_args_size: u32,
         fixed_frame_storage_size: u32,
         mut outgoing_args_size: u32,
     ) -> FrameLayout {
@@ -846,7 +911,7 @@ impl ABIMachineSpec for S390xMachineDeps {
 
         // Sort registers for deterministic code output. We can do an unstable
         // sort because the registers will be unique (there are no dups).
-        regs.sort_unstable_by_key(|r| PReg::from(r.to_reg()).index());
+        regs.sort_unstable();
 
         // Compute clobber size.  We only need to count FPR save slots.
         let mut clobber_size = 0;
@@ -860,9 +925,21 @@ impl ABIMachineSpec for S390xMachineDeps {
             }
         }
 
+        // Common code assumes that tail-call arguments are part of the caller's
+        // frame.  This is not correct for our tail-call convention.  To ensure
+        // common code still gets the total size of this stack frame correct,
+        // we add the (incoming and outgoing) taill-call argument size to the
+        // "clobber" size.
+        if call_conv == isa::CallConv::Tail {
+            clobber_size += tail_args_size;
+        }
+
         // Return FrameLayout structure.
         FrameLayout {
-            stack_args_size,
+            incoming_args_size,
+            // We already accounted for tail-call arguments above, so reset
+            // this value to its default.
+            tail_args_size: incoming_args_size,
             setup_area_size: 0,
             clobber_size,
             fixed_frame_storage_size,
@@ -872,47 +949,167 @@ impl ABIMachineSpec for S390xMachineDeps {
     }
 }
 
-fn is_reg_saved_in_prologue(_call_conv: isa::CallConv, r: RealReg) -> bool {
-    match r.class() {
-        RegClass::Int => {
+impl S390xMachineDeps {
+    pub fn gen_tail_epilogue(
+        frame_layout: &FrameLayout,
+        callee_pop_size: u32,
+        target_reg: Option<&mut Reg>,
+    ) -> SmallVec<[Inst; 16]> {
+        let mut insts = SmallVec::new();
+        let call_conv = isa::CallConv::Tail;
+
+        // Restore FPRs.
+        insts.extend(gen_restore_fprs(frame_layout));
+
+        // If the tail call target is in a callee-saved GPR, we need to move it
+        // to %r1 (as the only available temp register) before restoring GPRs
+        // (but after restoring FPRs, which might clobber %r1).
+        if let Some(reg) = target_reg {
+            if is_reg_saved_in_prologue(call_conv, reg.to_real_reg().unwrap()) {
+                insts.push(Inst::Mov64 {
+                    rd: writable_gpr(1),
+                    rm: *reg,
+                });
+                *reg = gpr(1);
+            }
+        }
+
+        // Restore GPRs (including SP).
+        insts.extend(gen_restore_gprs(call_conv, frame_layout, callee_pop_size));
+
+        insts
+    }
+}
+
+fn is_reg_saved_in_prologue(call_conv: isa::CallConv, r: RealReg) -> bool {
+    match (call_conv, r.class()) {
+        (isa::CallConv::Tail, RegClass::Int) => {
+            // r8 - r15 inclusive are callee-saves.
+            r.hw_enc() >= 8 && r.hw_enc() <= 15
+        }
+        (_, RegClass::Int) => {
             // r6 - r15 inclusive are callee-saves.
             r.hw_enc() >= 6 && r.hw_enc() <= 15
         }
-        RegClass::Float => {
+        (_, RegClass::Float) => {
             // f8 - f15 inclusive are callee-saves.
             r.hw_enc() >= 8 && r.hw_enc() <= 15
         }
-        RegClass::Vector => unreachable!(),
+        (_, RegClass::Vector) => unreachable!(),
     }
 }
 
-fn get_clobbered_gpr_fpr(
-    clobbered_callee_saves: &[Writable<RealReg>],
-) -> (u8, SmallVec<[Writable<RealReg>; 8]>) {
-    // Collect clobbered registers.  Note we save/restore GPR always as
+fn get_clobbered_gprs(frame_layout: &FrameLayout) -> Option<(u8, u8)> {
+    // Collect clobbered GPRs.  Note we save/restore GPR always as
     // a block of registers using LOAD MULTIPLE / STORE MULTIPLE, starting
-    // with the clobbered GPR with the lowest number up to %r15.  We
-    // return the number of that first GPR (or 16 if none is to be saved).
-    let mut clobbered_fpr = SmallVec::new();
-    let mut first_clobbered_gpr = 16;
-
-    for &reg in clobbered_callee_saves.iter() {
-        match reg.to_reg().class() {
-            RegClass::Int => {
-                let enc = reg.to_reg().hw_enc();
-                if enc < first_clobbered_gpr {
-                    first_clobbered_gpr = enc;
-                }
-            }
-            RegClass::Float => clobbered_fpr.push(reg),
-            RegClass::Vector => unreachable!(),
+    // with the clobbered GPR with the lowest number up to the clobbered GPR
+    // with the highest number.
+    let (clobbered_gpr, _) = frame_layout.clobbered_callee_saves_by_class();
+    if clobbered_gpr.is_empty() {
+        return None;
+    }
+
+    let first = clobbered_gpr.first().unwrap().to_reg().hw_enc();
+    let last = clobbered_gpr.last().unwrap().to_reg().hw_enc();
+    debug_assert!(clobbered_gpr.iter().all(|r| r.to_reg().hw_enc() >= first));
+    debug_assert!(clobbered_gpr.iter().all(|r| r.to_reg().hw_enc() <= last));
+    Some((first, last))
+}
+
+fn get_clobbered_fprs(frame_layout: &FrameLayout) -> &[Writable<RealReg>] {
+    // Collect clobbered floating-point registers.
+    let (_, clobbered_fpr) = frame_layout.clobbered_callee_saves_by_class();
+    clobbered_fpr
+}
+
+// Restore GPRs (including SP) from the register save area.
+// This must not clobber any register, specifically including %r1.
+fn gen_restore_gprs(
+    call_conv: isa::CallConv,
+    frame_layout: &FrameLayout,
+    callee_pop_size: u32,
+) -> SmallVec<[Inst; 16]> {
+    let mut insts = SmallVec::new();
+
+    // Determine GPRs to be restored.
+    let clobbered_gpr = get_clobbered_gprs(frame_layout);
+
+    // Increment stack pointer unless it will be restored implicitly.
+    // Note that implicit stack pointer restoration cannot be done in the
+    // presence of either incoming or outgoing tail call arguments.
+    let stack_size = frame_layout.outgoing_args_size as i32
+        + frame_layout.clobber_size as i32
+        + frame_layout.fixed_frame_storage_size as i32;
+    let implicit_sp_restore = callee_pop_size == 0
+        && (call_conv != isa::CallConv::Tail || frame_layout.incoming_args_size == 0)
+        && clobbered_gpr.map_or(false, |(first, _)| {
+            SImm20::maybe_from_i64(8 * first as i64 + stack_size as i64).is_some()
+        });
+    if !implicit_sp_restore {
+        insts.extend(S390xMachineDeps::gen_sp_reg_adjust(
+            stack_size - callee_pop_size as i32,
+        ));
+    }
+
+    // Use LMG to restore clobbered GPRs from save area.
+    if let Some((first, mut last)) = clobbered_gpr {
+        // Attempt to restore via SP, taking implicit restoration into account.
+        let mut reg = stack_reg();
+        let mut offset = callee_pop_size as i64 + 8 * first as i64;
+        if implicit_sp_restore {
+            offset += stack_size as i64 - callee_pop_size as i64;
+            last = 15;
+        }
+        // If the offset still overflows, use the first restored GPR
+        // as temporary holding the address, as we cannot use %r1.
+        if SImm20::maybe_from_i64(offset).is_none() {
+            insts.extend(S390xMachineDeps::gen_add_imm(
+                call_conv,
+                writable_gpr(first),
+                stack_reg(),
+                offset as u32,
+            ));
+            reg = gpr(first);
+            offset = 0;
         }
+        // Now this LMG will always have an in-range offset.
+        insts.push(Inst::LoadMultiple64 {
+            rt: writable_gpr(first),
+            rt2: writable_gpr(last),
+            mem: MemArg::reg_plus_off(reg, offset, MemFlags::trusted()),
+        });
     }
 
-    (first_clobbered_gpr, clobbered_fpr)
+    insts
 }
 
-const fn clobbers() -> PRegSet {
+// Restore FPRs from the clobber area.
+fn gen_restore_fprs(frame_layout: &FrameLayout) -> SmallVec<[Inst; 16]> {
+    let mut insts = SmallVec::new();
+
+    // Determine FPRs to be restored.
+    let clobbered_fpr = get_clobbered_fprs(frame_layout);
+
+    // Restore FPRs.
+    for (i, reg) in clobbered_fpr.iter().enumerate() {
+        insts.push(Inst::VecLoadLaneUndef {
+            size: 64,
+            rd: Writable::from_reg(reg.to_reg().into()),
+            mem: MemArg::reg_plus_off(
+                stack_reg(),
+                (i * 8) as i64
+                    + frame_layout.outgoing_args_size as i64
+                    + frame_layout.fixed_frame_storage_size as i64,
+                MemFlags::trusted(),
+            ),
+            lane_imm: 0,
+        });
+    }
+
+    insts
+}
+
+const fn sysv_clobbers() -> PRegSet {
     PRegSet::empty()
         .with(gpr_preg(0))
         .with(gpr_preg(1))
@@ -968,10 +1165,55 @@ const fn clobbers() -> PRegSet {
         .with(vr_preg(30))
         .with(vr_preg(31))
 }
+const SYSV_CLOBBERS: PRegSet = sysv_clobbers();
 
-const CLOBBERS: PRegSet = clobbers();
+const fn tail_clobbers() -> PRegSet {
+    // Same as the SystemV ABI, except that %r6 and %r7 are clobbered.
+    PRegSet::empty()
+        .with(gpr_preg(0))
+        .with(gpr_preg(1))
+        .with(gpr_preg(2))
+        .with(gpr_preg(3))
+        .with(gpr_preg(4))
+        .with(gpr_preg(5))
+        .with(gpr_preg(6))
+        .with(gpr_preg(7))
+        .with(vr_preg(0))
+        .with(vr_preg(1))
+        .with(vr_preg(2))
+        .with(vr_preg(3))
+        .with(vr_preg(4))
+        .with(vr_preg(5))
+        .with(vr_preg(6))
+        .with(vr_preg(7))
+        .with(vr_preg(8))
+        .with(vr_preg(9))
+        .with(vr_preg(10))
+        .with(vr_preg(11))
+        .with(vr_preg(12))
+        .with(vr_preg(13))
+        .with(vr_preg(14))
+        .with(vr_preg(15))
+        .with(vr_preg(16))
+        .with(vr_preg(17))
+        .with(vr_preg(18))
+        .with(vr_preg(19))
+        .with(vr_preg(20))
+        .with(vr_preg(21))
+        .with(vr_preg(22))
+        .with(vr_preg(23))
+        .with(vr_preg(24))
+        .with(vr_preg(25))
+        .with(vr_preg(26))
+        .with(vr_preg(27))
+        .with(vr_preg(28))
+        .with(vr_preg(29))
+        .with(vr_preg(30))
+        .with(vr_preg(31))
+}
+const TAIL_CLOBBERS: PRegSet = tail_clobbers();
 
-fn create_machine_env() -> MachineEnv {
+fn sysv_create_machine_env() -> MachineEnv {
     MachineEnv {
         preferred_regs_by_class: [
             vec![
@@ -1041,3 +1283,75 @@ fn create_machine_env() -> MachineEnv {
         scratch_by_class: [None, None, None],
     }
 }
+
+fn tail_create_machine_env() -> MachineEnv {
+    // Same as the SystemV ABI, except that %r6 and %r7 are preferred.
+    MachineEnv {
+        preferred_regs_by_class: [
+            vec![
+                // no r0; can't use for addressing?
+                // no r1; it is our spilltmp.
+                gpr_preg(2),
+                gpr_preg(3),
+                gpr_preg(4),
+                gpr_preg(5),
+                gpr_preg(6),
+                gpr_preg(7),
+            ],
+            vec![
+                vr_preg(0),
+                vr_preg(1),
+                vr_preg(2),
+                vr_preg(3),
+                vr_preg(4),
+                vr_preg(5),
+                vr_preg(6),
+                vr_preg(7),
+                vr_preg(16),
+                vr_preg(17),
+                vr_preg(18),
+                vr_preg(19),
+                vr_preg(20),
+                vr_preg(21),
+                vr_preg(22),
+                vr_preg(23),
+                vr_preg(24),
+                vr_preg(25),
+                vr_preg(26),
+                vr_preg(27),
+                vr_preg(28),
+                vr_preg(29),
+                vr_preg(30),
+                vr_preg(31),
+            ],
+            // Vector Regclass is unused
+            vec![],
+        ],
+        non_preferred_regs_by_class: [
+            vec![
+                gpr_preg(8),
+                gpr_preg(9),
+                gpr_preg(10),
+                gpr_preg(11),
+                gpr_preg(12),
+                gpr_preg(13),
+                gpr_preg(14),
+                // no r15; it is the stack pointer.
+            ],
+            vec![
+                vr_preg(8),
+                vr_preg(9),
+                vr_preg(10),
+                vr_preg(11),
+                vr_preg(12),
+                vr_preg(13),
+                vr_preg(14),
+                vr_preg(15),
+            ],
+            // Vector Regclass is unused
+            vec![],
+        ],
+        fixed_stack_slots: vec![],
+        scratch_by_class: [None, None, None],
+    }
+}
diff --git a/cranelift/codegen/src/isa/s390x/inst.isle b/cranelift/codegen/src/isa/s390x/inst.isle
index f6a5bde756c9..ca297aec6945 100644
--- a/cranelift/codegen/src/isa/s390x/inst.isle
+++ b/cranelift/codegen/src/isa/s390x/inst.isle
@@ -887,6 +887,10 @@
       (rn Reg)
       (lane_imm u8))
 
+    ;; Allocate stack space for outgoing tail-call arguments.
+    (AllocateArgs
+      (size u32))
+
     ;; A machine call instruction.
     (Call
       (link WritableReg)
@@ -897,6 +901,14 @@
       (link WritableReg)
       (info BoxCallIndInfo))
 
+    ;; A machine tail call instruction.
+    (ReturnCall
+      (info BoxReturnCallInfo))
+
+    ;; A machine indirect tail call instruction.
+    (ReturnCallInd
+      (info BoxReturnCallIndInfo))
+
     ;; A pseudo-instruction that captures register arguments in vregs.
     (Args
       (args VecArgPair))
@@ -994,11 +1006,6 @@
     (CondBreak
       (cond Cond))
 
-    ;; Marker, no-op in generated code SP "virtual offset" is adjusted. This
-    ;; controls how MemArg::NominalSPOffset args are lowered.
-    (VirtualSPOffsetAdj
-      (offset i64))
-
     ;; Pseudoinstruction to keep a value alive.
     (DummyUse
      (reg Reg))
@@ -1013,6 +1020,8 @@
 
 (type BoxCallInfo (primitive BoxCallInfo))
 (type BoxCallIndInfo (primitive BoxCallIndInfo))
+(type BoxReturnCallInfo (primitive BoxReturnCallInfo))
+(type BoxReturnCallIndInfo (primitive BoxReturnCallIndInfo))
 (type BoxJTSequenceInfo (primitive BoxJTSequenceInfo))
 (type VecMachLabel extern (enum))
 
@@ -1522,7 +1531,7 @@
 (extern extractor vr128_ty vr128_ty)
 
 
-;; Helpers for various immmediate constants ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Helpers for various immediate constants ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Special integer types and their constructors
 
@@ -1539,11 +1548,6 @@
 (decl pure partial i64_nonequal (i64 i64) i64)
 (extern constructor i64_nonequal i64_nonequal)
 
-(decl pure partial i64_nonzero (i64) i64)
-(rule (i64_nonzero x)
-      (if (i64_nonequal x 0))
-      x)
-
 (decl pure partial i64_not_neg1 (i64) i64)
 (rule (i64_not_neg1 x)
       (if (i64_nonequal x -1))
@@ -1778,14 +1782,9 @@
 (decl memarg_got () MemArg)
 (extern constructor memarg_got memarg_got)
 
-;; Create a MemArg refering to a stack address formed by
-;; adding a base (relative to SP) and an offset.
-(decl memarg_stack_off (i64 i64) MemArg)
-(extern constructor memarg_stack_off memarg_stack_off)
-
-;; Create a `MemArg` referring to an offset from the initial SP.
-(decl memarg_initial_sp_offset (i64) MemArg)
-(extern constructor memarg_initial_sp_offset memarg_initial_sp_offset)
+;; Add an offset to a virtual MemArg.
+(decl memarg_offset (MemArg i64) MemArg)
+(extern constructor memarg_offset memarg_offset)
 
 ;; Form the sum of two offset values, and check that the result is
 ;; a valid `MemArg::Symbol` offset (i.e. is even and fits into i32).
@@ -1797,6 +1796,14 @@
 (rule (memarg_symbol_offset x)
       (memarg_symbol_offset_sum x 0))
 
+;; Create a MemArg referring to the saved frame pointer location.
+(decl memarg_frame_pointer_offset () MemArg)
+(extern constructor memarg_frame_pointer_offset memarg_frame_pointer_offset)
+
+;; Create a MemArg referring to the saved return address location.
+(decl memarg_return_address_offset () MemArg)
+(extern constructor memarg_return_address_offset memarg_return_address_offset)
+
 ;; Lower an address into a `MemArg`.
 
 (decl lower_address (MemFlags Value Offset32) MemArg)
@@ -1804,11 +1811,11 @@
 (rule (lower_address flags addr @ (value_type (ty_addr64 _)) (i64_from_offset offset))
       (memarg_reg_plus_off addr offset 0 flags))
 
-(rule 1 (lower_address flags (has_type (ty_addr64 _) (iadd x y)) (i64_from_offset 0))
+(rule 1 (lower_address flags (has_type (ty_addr64 _) (iadd _ x y)) (i64_from_offset 0))
       (memarg_reg_plus_reg x y 0 flags))
 
 (rule 1 (lower_address flags
-                     (symbol_value (symbol_value_data name (reloc_distance_near) sym_offset))
+                     (symbol_value _ (symbol_value_data name (reloc_distance_near) sym_offset))
                      (i64_from_offset offset))
       (if-let final_offset (memarg_symbol_offset_sum offset sym_offset))
       (memarg_symbol name final_offset flags))
@@ -1821,7 +1828,7 @@
 (rule (lower_address_bias flags addr @ (value_type $I64) (i64_from_offset offset) bias)
       (memarg_reg_plus_off addr offset bias flags))
 
-(rule 1 (lower_address_bias flags (has_type $I64 (iadd x y)) (i64_from_offset 0) bias)
+(rule 1 (lower_address_bias flags (has_type $I64 (iadd _ x y)) (i64_from_offset 0) bias)
       (memarg_reg_plus_reg x y bias flags))
 
 
@@ -1829,7 +1836,7 @@
 
 (decl pure partial load_sym (Inst) Inst)
 (rule (load_sym inst)
-      (if-let (load _ (symbol_value (symbol_value_data _ (reloc_distance_near) sym_offset))
+      (if-let (load _ _ (symbol_value _ (symbol_value_data _ (reloc_distance_near) sym_offset))
                     (i64_from_offset load_offset))
           inst)
       (if (memarg_symbol_offset_sum sym_offset load_offset))
@@ -1837,7 +1844,7 @@
 
 (decl pure partial uload16_sym (Inst) Inst)
 (rule (uload16_sym inst)
-      (if-let (uload16 _ (symbol_value (symbol_value_data _ (reloc_distance_near) sym_offset))
+      (if-let (uload16 _ _ (symbol_value _ (symbol_value_data _ (reloc_distance_near) sym_offset))
                        (i64_from_offset load_offset))
           inst)
       (if (memarg_symbol_offset_sum sym_offset load_offset))
@@ -1876,11 +1883,11 @@
 
 ;; A value that is the result of a sign-extend from a 32-bit value.
 (decl sext32_value (Value) Value)
-(extractor (sext32_value x) (sextend (and x (value_type $I32))))
+(extractor (sext32_value x) (sextend _ (and x (value_type $I32))))
 
 ;; A value that is the result of a zero-extend from a 32-bit value.
 (decl zext32_value (Value) Value)
-(extractor (zext32_value x) (uextend (and x (value_type $I32))))
+(extractor (zext32_value x) (uextend _ (and x (value_type $I32))))
 
 
 ;; Helpers for sinkable loads ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -1892,7 +1899,7 @@
 ;; Sinkable big-endian load instruction.
 (decl sinkable_load (Inst) Value)
 (extractor (sinkable_load inst)
-           (sinkable_inst (and inst (load (bigendian) _addr _offset))))
+           (sinkable_inst (and inst (load _ (bigendian) _addr _offset))))
 
 ;; Sinkable big-endian load instruction (32/64-bit types only).
 (decl sinkable_load_32_64 (Inst) Value)
@@ -1907,60 +1914,60 @@
 ;; Sinkable little-endian load instruction.
 (decl sinkable_load_little (Inst) Value)
 (extractor (sinkable_load_little inst)
-           (sinkable_inst (and inst (load (littleendian) _addr _offset))))
+           (sinkable_inst (and inst (load _ (littleendian) _addr _offset))))
 
 ;; Sinkable big-endian sload16 instruction.
 (decl sinkable_sload16 (Inst) Value)
 (extractor (sinkable_sload16 inst)
-           (sinkable_inst (and inst (sload16 (bigendian) _addr _offset))))
+           (sinkable_inst (and inst (sload16 _ (bigendian) _addr _offset))))
 
 ;; Sinkable big-endian sload32 instruction.
 (decl sinkable_sload32 (Inst) Value)
 (extractor (sinkable_sload32 inst)
-           (sinkable_inst (and inst (sload32 (bigendian) _addr _offset))))
+           (sinkable_inst (and inst (sload32 _ (bigendian) _addr _offset))))
 
 ;; Sinkable big-endian uload16 instruction.
 (decl sinkable_uload16 (Inst) Value)
 (extractor (sinkable_uload16 inst)
-           (sinkable_inst (and inst (uload16 (bigendian) _addr _offset))))
+           (sinkable_inst (and inst (uload16 _ (bigendian) _addr _offset))))
 
 ;; Sinkable big-endian uload32 instruction.
 (decl sinkable_uload32 (Inst) Value)
 (extractor (sinkable_uload32 inst)
-           (sinkable_inst (and inst (uload32 (bigendian) _addr _offset))))
+           (sinkable_inst (and inst (uload32 _ (bigendian) _addr _offset))))
 
 ;; Sink a load instruction, returning its address as `MemArg`.
 ;; This is a side-effectful operation, see `sink_inst`.
 (decl sink_load (Inst) MemArg)
-(rule (sink_load inst @ (load flags addr offset))
+(rule (sink_load inst @ (load _ flags addr offset))
       (let ((_ Unit (sink_inst inst)))
         (lower_address flags addr offset)))
 
 ;; Sink a sload16 instruction, returning its address as `MemArg`.
 ;; This is a side-effectful operation, see `sink_inst`.
 (decl sink_sload16 (Inst) MemArg)
-(rule (sink_sload16 inst @ (sload16 flags addr offset))
+(rule (sink_sload16 inst @ (sload16 _ flags addr offset))
       (let ((_ Unit (sink_inst inst)))
         (lower_address flags addr offset)))
 
 ;; Sink a sload32 instruction, returning its address as `MemArg`.
 ;; This is a side-effectful operation, see `sink_inst`.
 (decl sink_sload32 (Inst) MemArg)
-(rule (sink_sload32 inst @ (sload32 flags addr offset))
+(rule (sink_sload32 inst @ (sload32 _ flags addr offset))
       (let ((_ Unit (sink_inst inst)))
         (lower_address flags addr offset)))
 
 ;; Sink a uload16 instruction, returning its address as `MemArg`.
 ;; This is a side-effectful operation, see `sink_inst`.
 (decl sink_uload16 (Inst) MemArg)
-(rule (sink_uload16 inst @ (uload16 flags addr offset))
+(rule (sink_uload16 inst @ (uload16 _ flags addr offset))
       (let ((_ Unit (sink_inst inst)))
         (lower_address flags addr offset)))
 
 ;; Sink a uload32 instruction, returning its address as `MemArg`.
 ;; This is a side-effectful operation, see `sink_inst`.
 (decl sink_uload32 (Inst) MemArg)
-(rule (sink_uload32 inst @ (uload32 flags addr offset))
+(rule (sink_uload32 inst @ (uload32 _ flags addr offset))
       (let ((_ Unit (sink_inst inst)))
         (lower_address flags addr offset)))
 
@@ -2692,6 +2699,16 @@
 (rule (call_ind_impl reg info)
       (SideEffectNoResult.Inst (MInst.CallInd reg info)))
 
+;; Helper for emitting `MInst.ReturnCall` instructions.
+(decl return_call_impl (BoxReturnCallInfo) SideEffectNoResult)
+(rule (return_call_impl info)
+      (SideEffectNoResult.Inst (MInst.ReturnCall info)))
+
+;; Helper for emitting `MInst.ReturnCallInd` instructions.
+(decl return_call_ind_impl (BoxReturnCallIndInfo) SideEffectNoResult)
+(rule (return_call_ind_impl info)
+      (SideEffectNoResult.Inst (MInst.ReturnCallInd info)))
+
 ;; Helper for emitting `MInst.Jump` instructions.
 (decl jump_impl (MachLabel) SideEffectNoResult)
 (rule (jump_impl target)
@@ -2848,7 +2865,6 @@
 (rule (arg_store $I16 reg mem) (store16 reg mem))
 (rule (arg_store $I32 reg mem) (store32 reg mem))
 (rule (arg_store $I64 reg mem) (store64 reg mem))
-(rule (arg_store $R64 reg mem) (store64 reg mem))
 (rule (arg_store $F32 reg mem) (vec_store_lane $F32X4 reg mem 0))
 (rule (arg_store $F64 reg mem) (vec_store_lane $F64X2 reg mem 0))
 (rule -1 (arg_store (vr128_ty ty) reg mem) (vec_store reg mem))
@@ -2858,7 +2874,6 @@
 (rule (arg_load $I16 mem) (zext32_mem $I16 mem))
 (rule (arg_load $I32 mem) (load32 mem))
 (rule (arg_load $I64 mem) (load64 mem))
-(rule (arg_load $R64 mem) (load64 mem))
 (rule (arg_load $F32 mem) (vec_load_lane_undef $F32X4 mem 0))
 (rule (arg_load $F64 mem) (vec_load_lane_undef $F64X2 mem 0))
 (rule -1 (arg_load (vr128_ty ty) mem) (vec_load ty mem))
@@ -2877,17 +2892,18 @@
       (let ((rev Reg (vec_permute_dw_imm $I64X2 reg 1 reg 0)))
         (vec_rot_imm $I16X8 (vec_rot_imm $I32X4 (vec_rot_imm $I64X2 rev 32) 16) 8)))
 
-;; When passing a vector value in register to a function whose ABI uses
-;; a different lane order than the current function, we need to swap lanes.
+;; When passing a vector value to a function whose ABI uses a different
+;; lane order than the current function, we need to swap lanes.
 ;; The first operand is the lane order used by the callee.
 (decl abi_vec_elt_rev (LaneOrder Type Reg) Reg)
-(rule 4 (abi_vec_elt_rev _ (gpr32_ty ty) reg) reg)
-(rule 3 (abi_vec_elt_rev _ (gpr64_ty ty) reg) reg)
+(rule 5 (abi_vec_elt_rev _ (gpr32_ty ty) reg) reg)
+(rule 4 (abi_vec_elt_rev _ (gpr64_ty ty) reg) reg)
+(rule 3 (abi_vec_elt_rev _ $I128 reg) reg)
 (rule 2 (abi_vec_elt_rev _ (ty_scalar_float ty) reg) reg)
 (rule 0 (abi_vec_elt_rev callee_lane_order _ reg)
       (if-let $true (lane_order_equal callee_lane_order (lane_order)))
       reg)
-(rule 1 (abi_vec_elt_rev callee_lane_order (vr128_ty ty) reg)
+(rule 1 (abi_vec_elt_rev callee_lane_order (ty_vec128 ty) reg)
       (if-let $false (lane_order_equal callee_lane_order (lane_order)))
       (vec_elt_rev ty reg))
 
@@ -2896,35 +2912,33 @@
 (rule 1 (memcpy dst src (len_minus_one len))
       (mvc (memarg_pair dst) (memarg_pair src) len))
 (rule (memcpy dst src len)
-      (let ((libcall LibCallInfo (lib_call_info_memcpy (load_addr dst) (load_addr src) (imm $I64 len)))
-            (_ Unit (lib_accumulate_outgoing_args_size libcall)))
-        (lib_call libcall)))
+      (lib_call (lib_call_info_memcpy (load_addr dst) (load_addr src) (imm $I64 len))))
 
 ;; Prepare a stack copy of a single (oversized) argument.
-(decl copy_to_buffer (i64 ABIArg Value) InstOutput)
+(decl copy_to_buffer (MemArg ABIArg Value) InstOutput)
 (rule 2 (copy_to_buffer base (abi_arg_only_slot slot) _) (output_none))
 (rule 1 (copy_to_buffer base (abi_arg_struct_pointer _ offset size) val)
-      (let ((dst MemArg (memarg_stack_off base offset))
+      (let ((dst MemArg (memarg_offset base offset))
             (src MemArg (memarg_reg_plus_off val 0 0 (memflags_trusted))))
         (side_effect (memcpy dst src size))))
 (rule 0 (copy_to_buffer base (abi_arg_implicit_pointer _ offset ty)
                       val @ (value_type ty))
-      (side_effect (arg_store ty val (memarg_stack_off base offset))))
+      (side_effect (arg_store ty val (memarg_offset base offset))))
 
 ;; Copy a single argument/return value to its slots.
 ;; For oversized arguments, set the slot to the buffer address.
-(decl copy_to_arg (CallArgListBuilder LaneOrder i64 ABIArg Value) InstOutput)
+(decl copy_to_arg (CallArgListBuilder LaneOrder MemArg ABIArg Value) InstOutput)
 (rule 2 (copy_to_arg uses lo base (abi_arg_only_slot slot) val)
       (copy_reg_to_arg_slot uses lo base slot (prepare_arg_val slot val)))
 (rule 1 (copy_to_arg uses lo base (abi_arg_struct_pointer slot offset _) _)
-      (let ((ptr Reg (load_addr (memarg_stack_off base offset))))
+      (let ((ptr Reg (load_addr (memarg_offset base offset))))
         (copy_reg_to_arg_slot uses lo base slot ptr)))
 (rule 0 (copy_to_arg uses lo base (abi_arg_implicit_pointer slot offset _) _)
-      (let ((ptr Reg (load_addr (memarg_stack_off base offset))))
+      (let ((ptr Reg (load_addr (memarg_offset base offset))))
         (copy_reg_to_arg_slot uses lo base slot ptr)))
 
 ;; Copy a single argument/return value from its slots.
-(decl copy_from_arg (CallRetList LaneOrder i64 ABIArg) ValueRegs)
+(decl copy_from_arg (CallRetList LaneOrder MemArg ABIArg) ValueRegs)
 (rule (copy_from_arg defs lo base (abi_arg_only_slot slot))
       (value_reg (copy_reg_from_arg_slot defs lo base slot)))
 
@@ -2932,8 +2946,6 @@
 ;; Copy reference values into registers of integer type.
 ;; Zero- or sign-extend as required by the ABI.
 (decl prepare_arg_val (ABIArgSlot Value) Reg)
-(rule 1 (prepare_arg_val (ABIArgSlot.Reg _ $R64 (ArgumentExtension.None)) val)
-        (copy_reg $I64 val))
 (rule (prepare_arg_val (ABIArgSlot.Reg _ _ (ArgumentExtension.None)) val)
       val)
 (rule (prepare_arg_val (ABIArgSlot.Reg _ _ (ArgumentExtension.Uext)) val)
@@ -2949,19 +2961,21 @@
 
 ;; Copy one component of an argument/return value to its slot, where the
 ;; value is already extended and present in a register.
-(decl copy_reg_to_arg_slot (CallArgListBuilder LaneOrder i64 ABIArgSlot Reg) InstOutput)
+(decl copy_reg_to_arg_slot (CallArgListBuilder LaneOrder MemArg ABIArgSlot Reg) InstOutput)
 (rule (copy_reg_to_arg_slot uses lo _ (ABIArgSlot.Reg reg ty ext) src)
       (let ((_ Unit (args_builder_push uses (abi_vec_elt_rev lo ty src) reg)))
         (output_none)))
-(rule (copy_reg_to_arg_slot _ _ base (ABIArgSlot.Stack offset ty ext) src)
-      (side_effect (arg_store (abi_ext_ty ext ty) src (memarg_stack_off base offset))))
+(rule (copy_reg_to_arg_slot _ lo base (ABIArgSlot.Stack offset ty ext) src)
+      (side_effect (arg_store (abi_ext_ty ext ty) (abi_vec_elt_rev lo ty src)
+                              (memarg_offset base offset))))
 
 ;; Copy one component of an argument/return value from its slot.
-(decl copy_reg_from_arg_slot (CallRetList LaneOrder i64 ABIArgSlot) Reg)
+(decl copy_reg_from_arg_slot (CallRetList LaneOrder MemArg ABIArgSlot) Reg)
 (rule (copy_reg_from_arg_slot defs lo _ (ABIArgSlot.Reg reg ty ext))
       (abi_vec_elt_rev lo ty (defs_lookup defs reg)))
-(rule (copy_reg_from_arg_slot _ _ base (ABIArgSlot.Stack offset ty ext))
-      (arg_load (abi_ext_ty ext ty) (memarg_stack_off base offset)))
+(rule (copy_reg_from_arg_slot _ lo base (ABIArgSlot.Stack offset ty ext))
+      (abi_vec_elt_rev lo ty (arg_load (abi_ext_ty ext ty)
+                                       (memarg_offset base offset))))
 
 ;; Helper to compute the type of an implicitly extended argument/return value.
 (decl abi_ext_ty (ArgumentExtension Type) Type)
@@ -3463,7 +3477,7 @@
 ;; Push an instruction sequence to rotate a value loaded from memory
 ;; to the well-defined location: the high bytes in case of a big-endian
 ;; memory operation, and the low bytes in the little-endian case.
-;; (This is somewhat arbitary but chosen to allow the most efficient
+;; (This is somewhat arbitrary but chosen to allow the most efficient
 ;; sequences to compute the various atomic operations.)
 ;; Note that $I8 accesses always use the big-endian case.
 (decl casloop_rotate_in (VecMInstBuilder Type MemFlags Reg Reg) Reg)
@@ -3543,25 +3557,45 @@
 (decl abi_first_ret (SigRef Sig) usize)
 (extern constructor abi_first_ret abi_first_ret)
 
-(decl abi_call_info (Sig ExternalName CallArgList CallRetList Opcode) BoxCallInfo)
+(decl abi_call_info (Sig ExternalName CallArgList CallRetList) BoxCallInfo)
 (extern constructor abi_call_info abi_call_info)
 
-(decl abi_call_ind_info (Sig Reg CallArgList CallRetList Opcode) BoxCallIndInfo)
+(decl abi_call_ind_info (Sig Reg CallArgList CallRetList) BoxCallIndInfo)
 (extern constructor abi_call_ind_info abi_call_ind_info)
 
+(decl abi_return_call_info (Sig ExternalName CallArgList) BoxReturnCallInfo)
+(extern constructor abi_return_call_info abi_return_call_info)
+
+(decl abi_return_call_ind_info (Sig Reg CallArgList) BoxReturnCallIndInfo)
+(extern constructor abi_return_call_ind_info abi_return_call_ind_info)
+
+(decl abi_call_stack_args (Sig) MemArg)
+(extern constructor abi_call_stack_args abi_call_stack_args)
+
+(decl abi_call_stack_rets (Sig) MemArg)
+(extern constructor abi_call_stack_rets abi_call_stack_rets)
+
+(decl abi_return_call_stack_args (Sig) MemArg)
+(extern constructor abi_return_call_stack_args abi_return_call_stack_args)
+
 (decl writable_link_reg () WritableReg)
 (rule (writable_link_reg) (writable_gpr 14))
 
-(decl abi_call (Sig ExternalName CallArgList CallRetList Opcode) SideEffectNoResult)
-(rule (abi_call abi name uses defs opcode)
-      (call_impl (writable_link_reg) (abi_call_info abi name uses defs opcode)))
+(decl abi_call (Sig ExternalName CallArgList CallRetList) SideEffectNoResult)
+(rule (abi_call abi name uses defs)
+      (call_impl (writable_link_reg) (abi_call_info abi name uses defs)))
 
-(decl abi_call_ind (Sig Reg CallArgList CallRetList Opcode) SideEffectNoResult)
-(rule (abi_call_ind abi target uses defs opcode)
-      (call_ind_impl (writable_link_reg) (abi_call_ind_info abi target uses defs opcode)))
+(decl abi_call_ind (Sig Reg CallArgList CallRetList) SideEffectNoResult)
+(rule (abi_call_ind abi target uses defs)
+      (call_ind_impl (writable_link_reg) (abi_call_ind_info abi target uses defs)))
 
-(decl abi_accumulate_outgoing_args_size (Sig) Unit)
-(extern constructor abi_accumulate_outgoing_args_size abi_accumulate_outgoing_args_size)
+(decl abi_return_call (Sig ExternalName CallArgList) SideEffectNoResult)
+(rule (abi_return_call abi name uses)
+      (return_call_impl (abi_return_call_info abi name uses)))
+
+(decl abi_return_call_ind (Sig Reg CallArgList) SideEffectNoResult)
+(rule (abi_return_call_ind abi target uses)
+      (return_call_ind_impl (abi_return_call_ind_info abi target uses)))
 
 (decl abi_lane_order (Sig) LaneOrder)
 (extern constructor abi_lane_order abi_lane_order)
@@ -3584,9 +3618,6 @@
 (rule (lib_call libcall)
       (call_impl (writable_link_reg) (lib_call_info libcall)))
 
-(decl lib_accumulate_outgoing_args_size (LibCallInfo) Unit)
-(extern constructor lib_accumulate_outgoing_args_size lib_accumulate_outgoing_args_size)
-
 
 ;; Helpers for generating vector pack and unpack instructions ;;;;;;;;;;;;;;;;;;
 
diff --git a/cranelift/codegen/src/isa/s390x/inst/args.rs b/cranelift/codegen/src/isa/s390x/inst/args.rs
index fdd223025f87..0aa96bf5853b 100644
--- a/cranelift/codegen/src/isa/s390x/inst/args.rs
+++ b/cranelift/codegen/src/isa/s390x/inst/args.rs
@@ -3,10 +3,6 @@
 use crate::ir::condcodes::{FloatCC, IntCC};
 use crate::ir::MemFlags;
 use crate::isa::s390x::inst::*;
-use crate::machinst::MachLabel;
-use crate::machinst::{PrettyPrint, Reg};
-
-use std::string::String;
 
 //=============================================================================
 // Instruction sub-components (memory addresses): definitions
@@ -53,19 +49,20 @@ pub enum MemArg {
     /// Offset from the stack pointer at function entry.
     InitialSPOffset { off: i64 },
 
-    /// Offset from the "nominal stack pointer", which is where the real SP is
-    /// just after stack and spill slots are allocated in the function prologue.
+    /// Offset from the (nominal) stack pointer during this function.
+    NominalSPOffset { off: i64 },
+
+    /// Offset into the slot area of the stack, which lies just above the
+    /// outgoing argument area that's setup by the function prologue.
     /// At emission time, this is converted to `SPOffset` with a fixup added to
     /// the offset constant. The fixup is a running value that is tracked as
     /// emission iterates through instructions in linear order, and can be
     /// adjusted up and down with [Inst::VirtualSPOffsetAdj].
     ///
     /// The standard ABI is in charge of handling this (by emitting the
-    /// adjustment meta-instructions). It maintains the invariant that "nominal
-    /// SP" is where the actual SP is after the function prologue and before
-    /// clobber pushes. See the diagram in the documentation for
-    /// [crate::isa::s390x::abi](the ABI module) for more details.
-    NominalSPOffset { off: i64 },
+    /// adjustment meta-instructions). See the diagram in the documentation
+    /// for [crate::isa::aarch64::abi](the ABI module) for more details.
+    SlotOffset { off: i64 },
 }
 
 impl MemArg {
@@ -94,6 +91,25 @@ impl MemArg {
         MemArg::RegOffset { reg, off, flags }
     }
 
+    /// Add an offset to a virtual addressing mode.
+    pub fn offset(base: &MemArg, offset: i64) -> MemArg {
+        match base {
+            &MemArg::RegOffset { reg, off, flags } => MemArg::RegOffset {
+                reg,
+                off: off + offset,
+                flags,
+            },
+            &MemArg::InitialSPOffset { off } => MemArg::InitialSPOffset { off: off + offset },
+            &MemArg::NominalSPOffset { off } => MemArg::NominalSPOffset { off: off + offset },
+            &MemArg::SlotOffset { off } => MemArg::SlotOffset { off: off + offset },
+            // This routine is only defined for virtual addressing modes.
+            &MemArg::BXD12 { .. }
+            | &MemArg::BXD20 { .. }
+            | &MemArg::Label { .. }
+            | &MemArg::Symbol { .. } => unreachable!(),
+        }
+    }
+
     pub(crate) fn get_flags(&self) -> MemFlags {
         match self {
             MemArg::BXD12 { flags, .. } => *flags,
@@ -103,44 +119,7 @@ impl MemArg {
             MemArg::Symbol { flags, .. } => *flags,
             MemArg::InitialSPOffset { .. } => MemFlags::trusted(),
             MemArg::NominalSPOffset { .. } => MemFlags::trusted(),
-        }
-    }
-
-    pub(crate) fn can_trap(&self) -> bool {
-        !self.get_flags().notrap()
-    }
-
-    /// Edit registers with allocations.
-    pub fn with_allocs(&self, allocs: &mut AllocationConsumer<'_>) -> Self {
-        match self {
-            &MemArg::BXD12 {
-                base,
-                index,
-                disp,
-                flags,
-            } => MemArg::BXD12 {
-                base: allocs.next(base),
-                index: allocs.next(index),
-                disp,
-                flags,
-            },
-            &MemArg::BXD20 {
-                base,
-                index,
-                disp,
-                flags,
-            } => MemArg::BXD20 {
-                base: allocs.next(base),
-                index: allocs.next(index),
-                disp,
-                flags,
-            },
-            &MemArg::RegOffset { reg, off, flags } => MemArg::RegOffset {
-                reg: allocs.next(reg),
-                off,
-                flags,
-            },
-            x => x.clone(),
+            MemArg::SlotOffset { .. } => MemFlags::trusted(),
         }
     }
 }
@@ -190,19 +169,6 @@ impl MemArgPair {
             _ => None,
         }
     }
-
-    pub(crate) fn can_trap(&self) -> bool {
-        !self.flags.notrap()
-    }
-
-    /// Edit registers with allocations.
-    pub fn with_allocs(&self, allocs: &mut AllocationConsumer<'_>) -> Self {
-        MemArgPair {
-            base: allocs.next(self.base),
-            disp: self.disp,
-            flags: self.flags,
-        }
-    }
 }
 
 //=============================================================================
@@ -271,13 +237,11 @@ impl Cond {
 }
 
 impl PrettyPrint for MemArg {
-    fn pretty_print(&self, _: u8, allocs: &mut AllocationConsumer<'_>) -> String {
+    fn pretty_print(&self, _: u8) -> String {
         match self {
             &MemArg::BXD12 {
                 base, index, disp, ..
             } => {
-                let base = allocs.next(base);
-                let index = allocs.next(index);
                 if base != zero_reg() {
                     if index != zero_reg() {
                         format!(
@@ -300,8 +264,6 @@ impl PrettyPrint for MemArg {
             &MemArg::BXD20 {
                 base, index, disp, ..
             } => {
-                let base = allocs.next(base);
-                let index = allocs.next(index);
                 if base != zero_reg() {
                     if index != zero_reg() {
                         format!(
@@ -328,6 +290,7 @@ impl PrettyPrint for MemArg {
             // Eliminated by `mem_finalize()`.
             &MemArg::InitialSPOffset { .. }
             | &MemArg::NominalSPOffset { .. }
+            | &MemArg::SlotOffset { .. }
             | &MemArg::RegOffset { .. } => {
                 panic!("Unexpected pseudo mem-arg mode (stack-offset or generic reg-offset)!")
             }
@@ -336,7 +299,7 @@ impl PrettyPrint for MemArg {
 }
 
 impl PrettyPrint for Cond {
-    fn pretty_print(&self, _: u8, _: &mut AllocationConsumer<'_>) -> String {
+    fn pretty_print(&self, _: u8) -> String {
         let s = match self.mask {
             1 => "o",
             2 => "h",
diff --git a/cranelift/codegen/src/isa/s390x/inst/emit.rs b/cranelift/codegen/src/isa/s390x/inst/emit.rs
index 7efb8b4dfc72..7d9fcc3e7e02 100644
--- a/cranelift/codegen/src/isa/s390x/inst/emit.rs
+++ b/cranelift/codegen/src/isa/s390x/inst/emit.rs
@@ -1,15 +1,9 @@
 //! S390x ISA: binary code emission.
 
-use crate::binemit::{Reloc, StackMap};
-use crate::ir::{MemFlags, RelSourceLoc, TrapCode};
-use crate::isa::s390x::abi::S390xMachineDeps;
+use crate::ir::{self, MemFlags, TrapCode};
 use crate::isa::s390x::inst::*;
 use crate::isa::s390x::settings as s390x_settings;
-use crate::machinst::{Reg, RegClass};
-use crate::trace;
-use core::convert::TryFrom;
 use cranelift_control::ControlPlane;
-use regalloc2::Allocation;
 
 /// Debug macro for testing that a regpair is valid: that the high register is even, and the low
 /// register is one higher than the high register.
@@ -73,17 +67,26 @@ pub fn mem_finalize(
     let mem = match mem {
         &MemArg::RegOffset { off, .. }
         | &MemArg::InitialSPOffset { off }
-        | &MemArg::NominalSPOffset { off } => {
+        | &MemArg::NominalSPOffset { off }
+        | &MemArg::SlotOffset { off } => {
             let base = match mem {
                 &MemArg::RegOffset { reg, .. } => reg,
-                &MemArg::InitialSPOffset { .. } | &MemArg::NominalSPOffset { .. } => stack_reg(),
+                &MemArg::InitialSPOffset { .. }
+                | &MemArg::NominalSPOffset { .. }
+                | &MemArg::SlotOffset { .. } => stack_reg(),
                 _ => unreachable!(),
             };
             let adj = match mem {
-                &MemArg::InitialSPOffset { .. } => {
-                    state.initial_sp_offset + state.virtual_sp_offset
+                &MemArg::InitialSPOffset { .. } => i64::from(
+                    state.frame_layout().clobber_size
+                        + state.frame_layout().fixed_frame_storage_size
+                        + state.frame_layout().outgoing_args_size
+                        + state.nominal_sp_offset,
+                ),
+                &MemArg::SlotOffset { .. } => {
+                    i64::from(state.frame_layout().outgoing_args_size + state.nominal_sp_offset)
                 }
-                &MemArg::NominalSPOffset { .. } => state.virtual_sp_offset,
+                &MemArg::NominalSPOffset { .. } => i64::from(state.nominal_sp_offset),
                 _ => 0,
             };
             let off = off + adj;
@@ -184,13 +187,12 @@ pub fn mem_emit(
         },
     );
     for inst in mem_insts.into_iter() {
-        inst.emit(&[], sink, emit_info, state);
+        inst.emit(sink, emit_info, state);
     }
 
-    if add_trap && mem.can_trap() {
-        let srcloc = state.cur_srcloc();
-        if !srcloc.is_default() {
-            sink.add_trap(TrapCode::HeapOutOfBounds);
+    if add_trap {
+        if let Some(trap_code) = mem.get_flags().trap_code() {
+            sink.add_trap(trap_code);
         }
     }
 
@@ -218,15 +220,8 @@ pub fn mem_emit(
         &MemArg::Symbol {
             ref name, offset, ..
         } => {
-            let reloc = Reloc::S390xPCRel32Dbl;
-            put_with_reloc(
-                sink,
-                &enc_ril_b(opcode_ril.unwrap(), rd, 0),
-                2,
-                reloc,
-                name,
-                offset.into(),
-            );
+            sink.add_reloc_at_offset(2, Reloc::S390xPCRel32Dbl, &**name, (offset + 2).into());
+            put(sink, &enc_ril_b(opcode_ril.unwrap(), rd, 0));
         }
         _ => unreachable!(),
     }
@@ -255,13 +250,12 @@ pub fn mem_rs_emit(
         },
     );
     for inst in mem_insts.into_iter() {
-        inst.emit(&[], sink, emit_info, state);
+        inst.emit(sink, emit_info, state);
     }
 
-    if add_trap && mem.can_trap() {
-        let srcloc = state.cur_srcloc();
-        if !srcloc.is_default() {
-            sink.add_trap(TrapCode::HeapOutOfBounds);
+    if add_trap {
+        if let Some(trap_code) = mem.get_flags().trap_code() {
+            sink.add_trap(trap_code);
         }
     }
 
@@ -307,13 +301,12 @@ pub fn mem_imm8_emit(
         },
     );
     for inst in mem_insts.into_iter() {
-        inst.emit(&[], sink, emit_info, state);
+        inst.emit(sink, emit_info, state);
     }
 
-    if add_trap && mem.can_trap() {
-        let srcloc = state.cur_srcloc();
-        if !srcloc.is_default() {
-            sink.add_trap(TrapCode::HeapOutOfBounds);
+    if add_trap {
+        if let Some(trap_code) = mem.get_flags().trap_code() {
+            sink.add_trap(trap_code);
         }
     }
 
@@ -355,13 +348,12 @@ pub fn mem_imm16_emit(
         },
     );
     for inst in mem_insts.into_iter() {
-        inst.emit(&[], sink, emit_info, state);
+        inst.emit(sink, emit_info, state);
     }
 
-    if add_trap && mem.can_trap() {
-        let srcloc = state.cur_srcloc();
-        if !srcloc.is_default() {
-            sink.add_trap(TrapCode::HeapOutOfBounds);
+    if add_trap {
+        if let Some(trap_code) = mem.get_flags().trap_code() {
+            sink.add_trap(trap_code);
         }
     }
 
@@ -383,12 +375,11 @@ pub fn mem_mem_emit(
     opcode_ss: u8,
     add_trap: bool,
     sink: &mut MachBuffer<Inst>,
-    state: &mut EmitState,
+    _state: &mut EmitState,
 ) {
-    if add_trap && (dst.can_trap() || src.can_trap()) {
-        let srcloc = state.cur_srcloc();
-        if srcloc != Default::default() {
-            sink.add_trap(TrapCode::HeapOutOfBounds);
+    if add_trap {
+        if let Some(trap_code) = dst.flags.trap_code().or(src.flags.trap_code()) {
+            sink.add_trap(trap_code);
         }
     }
 
@@ -427,13 +418,12 @@ pub fn mem_vrx_emit(
         },
     );
     for inst in mem_insts.into_iter() {
-        inst.emit(&[], sink, emit_info, state);
+        inst.emit(sink, emit_info, state);
     }
 
-    if add_trap && mem.can_trap() {
-        let srcloc = state.cur_srcloc();
-        if !srcloc.is_default() {
-            sink.add_trap(TrapCode::HeapOutOfBounds);
+    if add_trap {
+        if let Some(trap_code) = mem.get_flags().trap_code() {
+            sink.add_trap(trap_code);
         }
     }
 
@@ -1320,56 +1310,38 @@ fn put_with_trap(sink: &mut MachBuffer<Inst>, enc: &[u8], trap_code: TrapCode) {
     sink.put1(enc[len - 1]);
 }
 
-/// Emit encoding to sink, adding a relocation at byte offset.
-fn put_with_reloc(
-    sink: &mut MachBuffer<Inst>,
-    enc: &[u8],
-    offset: usize,
-    ri2_reloc: Reloc,
-    ri2_name: &ExternalName,
-    ri2_offset: i64,
-) {
-    let len = enc.len();
-    for i in 0..offset {
-        sink.put1(enc[i]);
-    }
-    sink.add_reloc(ri2_reloc, ri2_name, ri2_offset + offset as i64);
-    for i in offset..len {
-        sink.put1(enc[i]);
-    }
-}
-
 /// State carried between emissions of a sequence of instructions.
 #[derive(Default, Clone, Debug)]
 pub struct EmitState {
-    pub(crate) initial_sp_offset: i64,
-    pub(crate) virtual_sp_offset: i64,
-    /// Safepoint stack map for upcoming instruction, as provided to `pre_safepoint()`.
-    stack_map: Option<StackMap>,
-    /// Current source-code location corresponding to instruction to be emitted.
-    cur_srcloc: RelSourceLoc,
+    /// Offset from the actual SP to the "nominal SP".  The latter is defined
+    /// as the value the stack pointer has after the prolog.  This offset is
+    /// normally always zero, except during a call sequence using the tail-call
+    /// ABI, between the AllocateArgs and the actual call instruction.
+    pub(crate) nominal_sp_offset: u32,
+
+    /// The user stack map for the upcoming instruction, as provided to
+    /// `pre_safepoint()`.
+    user_stack_map: Option<ir::UserStackMap>,
+
     /// Only used during fuzz-testing. Otherwise, it is a zero-sized struct and
     /// optimized away at compiletime. See [cranelift_control].
     ctrl_plane: ControlPlane,
+
+    frame_layout: FrameLayout,
 }
 
 impl MachInstEmitState<Inst> for EmitState {
     fn new(abi: &Callee<S390xMachineDeps>, ctrl_plane: ControlPlane) -> Self {
         EmitState {
-            virtual_sp_offset: 0,
-            initial_sp_offset: abi.frame_size() as i64,
-            stack_map: None,
-            cur_srcloc: Default::default(),
+            nominal_sp_offset: 0,
+            user_stack_map: None,
             ctrl_plane,
+            frame_layout: abi.frame_layout().clone(),
         }
     }
 
-    fn pre_safepoint(&mut self, stack_map: StackMap) {
-        self.stack_map = Some(stack_map);
-    }
-
-    fn pre_sourceloc(&mut self, srcloc: RelSourceLoc) {
-        self.cur_srcloc = srcloc;
+    fn pre_safepoint(&mut self, user_stack_map: Option<ir::UserStackMap>) {
+        self.user_stack_map = user_stack_map;
     }
 
     fn ctrl_plane_mut(&mut self) -> &mut ControlPlane {
@@ -1379,19 +1351,19 @@ impl MachInstEmitState<Inst> for EmitState {
     fn take_ctrl_plane(self) -> ControlPlane {
         self.ctrl_plane
     }
+
+    fn frame_layout(&self) -> &FrameLayout {
+        &self.frame_layout
+    }
 }
 
 impl EmitState {
-    fn take_stack_map(&mut self) -> Option<StackMap> {
-        self.stack_map.take()
+    fn take_stack_map(&mut self) -> Option<ir::UserStackMap> {
+        self.user_stack_map.take()
     }
 
     fn clear_post_insn(&mut self) {
-        self.stack_map = None;
-    }
-
-    fn cur_srcloc(&self) -> RelSourceLoc {
-        self.cur_srcloc
+        self.user_stack_map = None;
     }
 }
 
@@ -1410,27 +1382,18 @@ impl MachInstEmit for Inst {
     type State = EmitState;
     type Info = EmitInfo;
 
-    fn emit(
-        &self,
-        allocs: &[Allocation],
-        sink: &mut MachBuffer<Inst>,
-        emit_info: &Self::Info,
-        state: &mut EmitState,
-    ) {
-        let mut allocs = AllocationConsumer::new(allocs);
-        self.emit_with_alloc_consumer(&mut allocs, sink, emit_info, state)
+    fn emit(&self, sink: &mut MachBuffer<Inst>, emit_info: &Self::Info, state: &mut EmitState) {
+        self.emit_with_alloc_consumer(sink, emit_info, state)
     }
 
-    fn pretty_print_inst(&self, allocs: &[Allocation], state: &mut EmitState) -> String {
-        let mut allocs = AllocationConsumer::new(allocs);
-        self.print_with_state(state, &mut allocs)
+    fn pretty_print_inst(&self, state: &mut EmitState) -> String {
+        self.print_with_state(state)
     }
 }
 
 impl Inst {
     fn emit_with_alloc_consumer(
         &self,
-        allocs: &mut AllocationConsumer<'_>,
         sink: &mut MachBuffer<Inst>,
         emit_info: &EmitInfo,
         state: &mut EmitState,
@@ -1449,8 +1412,7 @@ impl Inst {
         let isa_requirements = self.available_in_isa();
         if !matches_isa_flags(&isa_requirements) {
             panic!(
-                "Cannot emit inst '{:?}' for target; failed to match ISA requirements: {:?}",
-                self, isa_requirements
+                "Cannot emit inst '{self:?}' for target; failed to match ISA requirements: {isa_requirements:?}"
             )
         }
 
@@ -1463,10 +1425,6 @@ impl Inst {
 
         match self {
             &Inst::AluRRR { alu_op, rd, rn, rm } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
-
                 let (opcode, have_rr) = match alu_op {
                     ALUOp::Add32 => (0xb9f8, true),        // ARK
                     ALUOp::Add64 => (0xb9e8, true),        // AGRK
@@ -1503,7 +1461,7 @@ impl Inst {
                         ri: rn,
                         rm,
                     };
-                    inst.emit(&[], sink, emit_info, state);
+                    inst.emit(sink, emit_info, state);
                 } else {
                     put(sink, &enc_rrf_ab(opcode, rd.to_reg(), rn, rm, 0));
                 }
@@ -1514,9 +1472,6 @@ impl Inst {
                 rn,
                 imm,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-
                 if rd.to_reg() == rn {
                     let inst = Inst::AluRSImm16 {
                         alu_op,
@@ -1524,7 +1479,7 @@ impl Inst {
                         ri: rn,
                         imm,
                     };
-                    inst.emit(&[], sink, emit_info, state);
+                    inst.emit(sink, emit_info, state);
                 } else {
                     let opcode = match alu_op {
                         ALUOp::Add32 => 0xecd8, // AHIK
@@ -1535,10 +1490,7 @@ impl Inst {
                 }
             }
             &Inst::AluRR { alu_op, rd, ri, rm } => {
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
-                let rm = allocs.next(rm);
 
                 let (opcode, is_rre) = match alu_op {
                     ALUOp::Add32 => (0x1a, false),              // AR
@@ -1576,10 +1528,8 @@ impl Inst {
                 ri,
                 ref mem,
             } => {
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
-                let mem = mem.with_allocs(allocs);
+                let mem = mem.clone();
 
                 let (opcode_rx, opcode_rxy) = match alu_op {
                     ALUOp::Add32 => (Some(0x5a), Some(0xe35a)),        // A(Y)
@@ -1622,8 +1572,6 @@ impl Inst {
                 ri,
                 imm,
             } => {
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
 
                 let opcode = match alu_op {
@@ -1641,8 +1589,6 @@ impl Inst {
                 ri,
                 imm,
             } => {
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
 
                 let opcode = match alu_op {
@@ -1660,8 +1606,6 @@ impl Inst {
                 ri,
                 imm,
             } => {
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
 
                 let opcode = match alu_op {
@@ -1679,8 +1623,6 @@ impl Inst {
                 ri,
                 imm,
             } => {
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
 
                 let opcode = match (alu_op, imm.shift) {
@@ -1706,8 +1648,6 @@ impl Inst {
                 ri,
                 imm,
             } => {
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
 
                 let opcode = match (alu_op, imm.shift) {
@@ -1726,32 +1666,26 @@ impl Inst {
             }
 
             &Inst::SMulWide { rd, rn, rm } => {
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
-                let rd1 = allocs.next_writable(rd.hi);
-                let rd2 = allocs.next_writable(rd.lo);
+                let rd1 = rd.hi;
+                let rd2 = rd.lo;
                 debug_assert_valid_regpair!(rd1.to_reg(), rd2.to_reg());
 
                 let opcode = 0xb9ec; // MGRK
                 put(sink, &enc_rrf_ab(opcode, rd1.to_reg(), rn, rm, 0));
             }
             &Inst::UMulWide { rd, ri, rn } => {
-                let rn = allocs.next(rn);
-                let rd1 = allocs.next_writable(rd.hi);
-                let rd2 = allocs.next_writable(rd.lo);
+                let rd1 = rd.hi;
+                let rd2 = rd.lo;
                 debug_assert_valid_regpair!(rd1.to_reg(), rd2.to_reg());
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd2.to_reg(), ri);
 
                 let opcode = 0xb986; // MLGR
                 put(sink, &enc_rre(opcode, rd1.to_reg(), rn));
             }
             &Inst::SDivMod32 { rd, ri, rn } => {
-                let rn = allocs.next(rn);
-                let rd1 = allocs.next_writable(rd.hi);
-                let rd2 = allocs.next_writable(rd.lo);
+                let rd1 = rd.hi;
+                let rd2 = rd.lo;
                 debug_assert_valid_regpair!(rd1.to_reg(), rd2.to_reg());
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd2.to_reg(), ri);
 
                 let opcode = 0xb91d; // DSGFR
@@ -1759,11 +1693,9 @@ impl Inst {
                 put_with_trap(sink, &enc_rre(opcode, rd1.to_reg(), rn), trap_code);
             }
             &Inst::SDivMod64 { rd, ri, rn } => {
-                let rn = allocs.next(rn);
-                let rd1 = allocs.next_writable(rd.hi);
-                let rd2 = allocs.next_writable(rd.lo);
+                let rd1 = rd.hi;
+                let rd2 = rd.lo;
                 debug_assert_valid_regpair!(rd1.to_reg(), rd2.to_reg());
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd2.to_reg(), ri);
 
                 let opcode = 0xb90d; // DSGR
@@ -1771,12 +1703,11 @@ impl Inst {
                 put_with_trap(sink, &enc_rre(opcode, rd1.to_reg(), rn), trap_code);
             }
             &Inst::UDivMod32 { rd, ri, rn } => {
-                let rn = allocs.next(rn);
-                let rd1 = allocs.next_writable(rd.hi);
-                let rd2 = allocs.next_writable(rd.lo);
+                let rd1 = rd.hi;
+                let rd2 = rd.lo;
                 debug_assert_valid_regpair!(rd1.to_reg(), rd2.to_reg());
-                let ri1 = allocs.next(ri.hi);
-                let ri2 = allocs.next(ri.lo);
+                let ri1 = ri.hi;
+                let ri2 = ri.lo;
                 debug_assert_eq!(rd1.to_reg(), ri1);
                 debug_assert_eq!(rd2.to_reg(), ri2);
 
@@ -1785,12 +1716,11 @@ impl Inst {
                 put_with_trap(sink, &enc_rre(opcode, rd1.to_reg(), rn), trap_code);
             }
             &Inst::UDivMod64 { rd, ri, rn } => {
-                let rn = allocs.next(rn);
-                let rd1 = allocs.next_writable(rd.hi);
-                let rd2 = allocs.next_writable(rd.lo);
+                let rd1 = rd.hi;
+                let rd2 = rd.lo;
                 debug_assert_valid_regpair!(rd1.to_reg(), rd2.to_reg());
-                let ri1 = allocs.next(ri.hi);
-                let ri2 = allocs.next(ri.lo);
+                let ri1 = ri.hi;
+                let ri2 = ri.lo;
                 debug_assert_eq!(rd1.to_reg(), ri1);
                 debug_assert_eq!(rd2.to_reg(), ri2);
 
@@ -1799,9 +1729,8 @@ impl Inst {
                 put_with_trap(sink, &enc_rre(opcode, rd1.to_reg(), rn), trap_code);
             }
             &Inst::Flogr { rd, rn } => {
-                let rn = allocs.next(rn);
-                let rd1 = allocs.next_writable(rd.hi);
-                let rd2 = allocs.next_writable(rd.lo);
+                let rd1 = rd.hi;
+                let rd2 = rd.lo;
                 debug_assert_valid_regpair!(rd1.to_reg(), rd2.to_reg());
 
                 let opcode = 0xb983; // FLOGR
@@ -1815,10 +1744,6 @@ impl Inst {
                 shift_imm,
                 shift_reg,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let shift_reg = allocs.next(shift_reg);
-
                 let opcode = match shift_op {
                     ShiftOp::RotL32 => 0xeb1d, // RLL
                     ShiftOp::RotL64 => 0xeb1c, // RLLG
@@ -1844,10 +1769,7 @@ impl Inst {
                 end_bit,
                 rotate_amt,
             } => {
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
-                let rn = allocs.next(rn);
 
                 let opcode = match op {
                     RxSBGOp::Insert => 0xec59, // RISBGN
@@ -1876,9 +1798,6 @@ impl Inst {
                 end_bit,
                 rotate_amt,
             } => {
-                let rd = allocs.next(rd);
-                let rn = allocs.next(rn);
-
                 let opcode = match op {
                     RxSBGOp::And => 0xec54, // RNSBG
                     RxSBGOp::Or => 0xec56,  // ROSBG
@@ -1899,9 +1818,6 @@ impl Inst {
             }
 
             &Inst::UnaryRR { op, rd, rn } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-
                 match op {
                     UnaryOp::Abs32 => {
                         let opcode = 0x10; // LPR
@@ -1953,9 +1869,6 @@ impl Inst {
                 from_bits,
                 to_bits,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-
                 let opcode = match (signed, from_bits, to_bits) {
                     (_, 1, 32) => 0xb926,      // LBR
                     (_, 1, 64) => 0xb906,      // LGBR
@@ -1970,17 +1883,13 @@ impl Inst {
                     (false, 32, 64) => 0xb916, // LLGFR
                     (true, 32, 64) => 0xb914,  // LGFR
                     _ => panic!(
-                        "Unsupported extend combination: signed = {}, from_bits = {}, to_bits = {}",
-                        signed, from_bits, to_bits
+                        "Unsupported extend combination: signed = {signed}, from_bits = {from_bits}, to_bits = {to_bits}"
                     ),
                 };
                 put(sink, &enc_rre(opcode, rd.to_reg(), rn));
             }
 
             &Inst::CmpRR { op, rn, rm } => {
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
-
                 let (opcode, is_rre) = match op {
                     CmpOp::CmpS32 => (0x19, false),       // CR
                     CmpOp::CmpS64 => (0xb920, true),      // CGR
@@ -1997,8 +1906,7 @@ impl Inst {
                 }
             }
             &Inst::CmpRX { op, rn, ref mem } => {
-                let rn = allocs.next(rn);
-                let mem = mem.with_allocs(allocs);
+                let mem = mem.clone();
 
                 let (opcode_rx, opcode_rxy, opcode_ril) = match op {
                     CmpOp::CmpS32 => (Some(0x59), Some(0xe359), Some(0xc6d)), // C(Y), CRL
@@ -2017,8 +1925,6 @@ impl Inst {
                 );
             }
             &Inst::CmpRSImm16 { op, rn, imm } => {
-                let rn = allocs.next(rn);
-
                 let opcode = match op {
                     CmpOp::CmpS32 => 0xa7e, // CHI
                     CmpOp::CmpS64 => 0xa7f, // CGHI
@@ -2027,8 +1933,6 @@ impl Inst {
                 put(sink, &enc_ri_a(opcode, rn, imm as u16));
             }
             &Inst::CmpRSImm32 { op, rn, imm } => {
-                let rn = allocs.next(rn);
-
                 let opcode = match op {
                     CmpOp::CmpS32 => 0xc2d, // CFI
                     CmpOp::CmpS64 => 0xc2c, // CGFI
@@ -2037,8 +1941,6 @@ impl Inst {
                 put(sink, &enc_ril_a(opcode, rn, imm as u32));
             }
             &Inst::CmpRUImm32 { op, rn, imm } => {
-                let rn = allocs.next(rn);
-
                 let opcode = match op {
                     CmpOp::CmpL32 => 0xc2f, // CLFI
                     CmpOp::CmpL64 => 0xc2e, // CLGFI
@@ -2053,9 +1955,6 @@ impl Inst {
                 cond,
                 trap_code,
             } => {
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
-
                 let opcode = match op {
                     CmpOp::CmpS32 => 0xb972, // CRT
                     CmpOp::CmpS64 => 0xb960, // CGRT
@@ -2076,8 +1975,6 @@ impl Inst {
                 cond,
                 trap_code,
             } => {
-                let rn = allocs.next(rn);
-
                 let opcode = match op {
                     CmpOp::CmpS32 => 0xec72, // CIT
                     CmpOp::CmpS64 => 0xec70, // CGIT
@@ -2096,8 +1993,6 @@ impl Inst {
                 cond,
                 trap_code,
             } => {
-                let rn = allocs.next(rn);
-
                 let opcode = match op {
                     CmpOp::CmpL32 => 0xec73, // CLFIT
                     CmpOp::CmpL64 => 0xec71, // CLGIT
@@ -2112,9 +2007,7 @@ impl Inst {
                 rn,
                 ref mem,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let mem = mem.with_allocs(allocs);
+                let mem = mem.clone();
 
                 let opcode = match alu_op {
                     ALUOp::Add32 => 0xebf8,        // LAA
@@ -2160,9 +2053,9 @@ impl Inst {
                                 target: done_label,
                                 cond: *cond,
                             };
-                            inst.emit_with_alloc_consumer(allocs, sink, emit_info, state);
+                            inst.emit_with_alloc_consumer(sink, emit_info, state);
                         }
-                        _ => inst.emit_with_alloc_consumer(allocs, sink, emit_info, state),
+                        _ => inst.emit_with_alloc_consumer(sink, emit_info, state),
                     };
                 }
 
@@ -2170,7 +2063,7 @@ impl Inst {
                     target: loop_label,
                     cond,
                 };
-                inst.emit(&[], sink, emit_info, state);
+                inst.emit(sink, emit_info, state);
 
                 // Emit label at the end of the loop.
                 sink.bind_label(done_label, &mut state.ctrl_plane);
@@ -2188,11 +2081,8 @@ impl Inst {
                 rn,
                 ref mem,
             } => {
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
-                let rn = allocs.next(rn);
-                let mem = mem.with_allocs(allocs);
+                let mem = mem.clone();
 
                 let (opcode_rs, opcode_rsy) = match self {
                     &Inst::AtomicCas32 { .. } => (Some(0xba), Some(0xeb14)), // CS(Y)
@@ -2224,8 +2114,7 @@ impl Inst {
             | &Inst::LoadRev16 { rd, ref mem }
             | &Inst::LoadRev32 { rd, ref mem }
             | &Inst::LoadRev64 { rd, ref mem } => {
-                let rd = allocs.next_writable(rd);
-                let mem = mem.with_allocs(allocs);
+                let mem = mem.clone();
 
                 let (opcode_rx, opcode_rxy, opcode_ril) = match self {
                     &Inst::Load32 { .. } => (Some(0x58), Some(0xe358), Some(0xc4d)), // L(Y), LRL
@@ -2258,8 +2147,7 @@ impl Inst {
             | &Inst::StoreRev16 { rd, ref mem }
             | &Inst::StoreRev32 { rd, ref mem }
             | &Inst::StoreRev64 { rd, ref mem } => {
-                let rd = allocs.next(rd);
-                let mem = mem.with_allocs(allocs);
+                let mem = mem.clone();
 
                 let (opcode_rx, opcode_rxy, opcode_ril) = match self {
                     &Inst::Store8 { .. } => (Some(0x42), Some(0xe372), None), // STC(Y)
@@ -2276,7 +2164,7 @@ impl Inst {
                 );
             }
             &Inst::StoreImm8 { imm, ref mem } => {
-                let mem = mem.with_allocs(allocs);
+                let mem = mem.clone();
 
                 let opcode_si = 0x92; // MVI
                 let opcode_siy = 0xeb52; // MVIY
@@ -2287,7 +2175,7 @@ impl Inst {
             &Inst::StoreImm16 { imm, ref mem }
             | &Inst::StoreImm32SExt16 { imm, ref mem }
             | &Inst::StoreImm64SExt16 { imm, ref mem } => {
-                let mem = mem.with_allocs(allocs);
+                let mem = mem.clone();
 
                 let opcode = match self {
                     &Inst::StoreImm16 { .. } => 0xe544,       // MVHHI
@@ -2302,14 +2190,14 @@ impl Inst {
                 ref src,
                 len_minus_one,
             } => {
-                let dst = dst.with_allocs(allocs);
-                let src = src.with_allocs(allocs);
+                let dst = dst.clone();
+                let src = src.clone();
                 let opcode = 0xd2; // MVC
                 mem_mem_emit(&dst, &src, len_minus_one, opcode, true, sink, state);
             }
 
             &Inst::LoadMultiple64 { rt, rt2, ref mem } => {
-                let mem = mem.with_allocs(allocs);
+                let mem = mem.clone();
 
                 let opcode = 0xeb04; // LMG
                 let rt = rt.to_reg();
@@ -2327,7 +2215,7 @@ impl Inst {
                 );
             }
             &Inst::StoreMultiple64 { rt, rt2, ref mem } => {
-                let mem = mem.with_allocs(allocs);
+                let mem = mem.clone();
 
                 let opcode = 0xeb24; // STMG
                 mem_rs_emit(
@@ -2344,8 +2232,7 @@ impl Inst {
             }
 
             &Inst::LoadAddr { rd, ref mem } => {
-                let rd = allocs.next_writable(rd);
-                let mem = mem.with_allocs(allocs);
+                let mem = mem.clone();
 
                 let opcode_rx = Some(0x41); // LA
                 let opcode_rxy = Some(0xe371); // LAY
@@ -2357,70 +2244,47 @@ impl Inst {
             }
 
             &Inst::Mov64 { rd, rm } => {
-                let rd = allocs.next_writable(rd);
-                let rm = allocs.next(rm);
-
                 let opcode = 0xb904; // LGR
                 put(sink, &enc_rre(opcode, rd.to_reg(), rm));
             }
             &Inst::MovPReg { rd, rm } => {
                 let rm: Reg = rm.into();
                 debug_assert!([regs::gpr(0), regs::gpr(14), regs::gpr(15)].contains(&rm));
-                let rd = allocs.next_writable(rd);
-                Inst::Mov64 { rd, rm }.emit(&[], sink, emit_info, state);
+                Inst::Mov64 { rd, rm }.emit(sink, emit_info, state);
             }
             &Inst::Mov32 { rd, rm } => {
-                let rd = allocs.next_writable(rd);
-                let rm = allocs.next(rm);
-
                 let opcode = 0x18; // LR
                 put(sink, &enc_rr(opcode, rd.to_reg(), rm));
             }
             &Inst::Mov32Imm { rd, imm } => {
-                let rd = allocs.next_writable(rd);
-
                 let opcode = 0xc09; // IILF
                 put(sink, &enc_ril_a(opcode, rd.to_reg(), imm));
             }
             &Inst::Mov32SImm16 { rd, imm } => {
-                let rd = allocs.next_writable(rd);
-
                 let opcode = 0xa78; // LHI
                 put(sink, &enc_ri_a(opcode, rd.to_reg(), imm as u16));
             }
             &Inst::Mov64SImm16 { rd, imm } => {
-                let rd = allocs.next_writable(rd);
-
                 let opcode = 0xa79; // LGHI
                 put(sink, &enc_ri_a(opcode, rd.to_reg(), imm as u16));
             }
             &Inst::Mov64SImm32 { rd, imm } => {
-                let rd = allocs.next_writable(rd);
-
                 let opcode = 0xc01; // LGFI
                 put(sink, &enc_ril_a(opcode, rd.to_reg(), imm as u32));
             }
             &Inst::CMov32 { rd, cond, ri, rm } => {
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
-                let rm = allocs.next(rm);
 
                 let opcode = 0xb9f2; // LOCR
                 put(sink, &enc_rrf_cde(opcode, rd.to_reg(), rm, cond.bits(), 0));
             }
             &Inst::CMov64 { rd, cond, ri, rm } => {
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
-                let rm = allocs.next(rm);
 
                 let opcode = 0xb9e2; // LOCGR
                 put(sink, &enc_rrf_cde(opcode, rd.to_reg(), rm, cond.bits(), 0));
             }
             &Inst::CMov32SImm16 { rd, cond, ri, imm } => {
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
 
                 let opcode = 0xec42; // LOCHI
@@ -2430,8 +2294,6 @@ impl Inst {
                 );
             }
             &Inst::CMov64SImm16 { rd, cond, ri, imm } => {
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
 
                 let opcode = 0xec46; // LOCGHI
@@ -2441,8 +2303,6 @@ impl Inst {
                 );
             }
             &Inst::Mov64UImm16Shifted { rd, imm } => {
-                let rd = allocs.next_writable(rd);
-
                 let opcode = match imm.shift {
                     0 => 0xa5f, // LLILL
                     1 => 0xa5e, // LLILH
@@ -2453,8 +2313,6 @@ impl Inst {
                 put(sink, &enc_ri_a(opcode, rd.to_reg(), imm.bits));
             }
             &Inst::Mov64UImm32Shifted { rd, imm } => {
-                let rd = allocs.next_writable(rd);
-
                 let opcode = match imm.shift {
                     0 => 0xc0f, // LLILF
                     1 => 0xc0e, // LLIHF
@@ -2463,8 +2321,6 @@ impl Inst {
                 put(sink, &enc_ril_a(opcode, rd.to_reg(), imm.bits));
             }
             &Inst::Insert64UImm16Shifted { rd, ri, imm } => {
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
 
                 let opcode = match imm.shift {
@@ -2477,8 +2333,6 @@ impl Inst {
                 put(sink, &enc_ri_a(opcode, rd.to_reg(), imm.bits));
             }
             &Inst::Insert64UImm32Shifted { rd, ri, imm } => {
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
 
                 let opcode = match imm.shift {
@@ -2489,14 +2343,11 @@ impl Inst {
                 put(sink, &enc_ril_a(opcode, rd.to_reg(), imm.bits));
             }
             &Inst::LoadAR { rd, ar } => {
-                let rd = allocs.next_writable(rd);
                 let opcode = 0xb24f; // EAR
                 put(sink, &enc_rre(opcode, rd.to_reg(), gpr(ar)));
             }
 
             &Inst::InsertAR { rd, ri, ar } => {
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
 
                 let opcode = 0xb24f; // EAR
@@ -2506,8 +2357,6 @@ impl Inst {
                 rd,
                 ref symbol_reloc,
             } => {
-                let rd = allocs.next_writable(rd);
-
                 let opcode = 0xa75; // BRAS
                 let reg = writable_spilltmp_reg().to_reg();
                 put(sink, &enc_ri_b(opcode, reg, 12));
@@ -2521,13 +2370,10 @@ impl Inst {
                     rd,
                     mem: MemArg::reg(reg, MemFlags::trusted()),
                 };
-                inst.emit(&[], sink, emit_info, state);
+                inst.emit(sink, emit_info, state);
             }
 
             &Inst::FpuMove32 { rd, rn } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-
                 if is_fpr(rd.to_reg()) && is_fpr(rn) {
                     let opcode = 0x38; // LER
                     put(sink, &enc_rr(opcode, rd.to_reg(), rn));
@@ -2537,9 +2383,6 @@ impl Inst {
                 }
             }
             &Inst::FpuMove64 { rd, rn } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-
                 if is_fpr(rd.to_reg()) && is_fpr(rn) {
                     let opcode = 0x28; // LDR
                     put(sink, &enc_rr(opcode, rd.to_reg(), rn));
@@ -2549,10 +2392,7 @@ impl Inst {
                 }
             }
             &Inst::FpuCMov32 { rd, cond, ri, rm } => {
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
-                let rm = allocs.next(rm);
 
                 if is_fpr(rd.to_reg()) && is_fpr(rm) {
                     let opcode = 0xa74; // BCR
@@ -2567,10 +2407,7 @@ impl Inst {
                 }
             }
             &Inst::FpuCMov64 { rd, cond, ri, rm } => {
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
-                let rm = allocs.next(rm);
 
                 if is_fpr(rd.to_reg()) && is_fpr(rm) {
                     let opcode = 0xa74; // BCR
@@ -2585,8 +2422,6 @@ impl Inst {
                 }
             }
             &Inst::LoadFpuConst32 { rd, const_data } => {
-                let rd = allocs.next_writable(rd);
-
                 let opcode = 0xa75; // BRAS
                 let reg = writable_spilltmp_reg().to_reg();
                 put(sink, &enc_ri_b(opcode, reg, 8));
@@ -2597,11 +2432,9 @@ impl Inst {
                     mem: MemArg::reg(reg, MemFlags::trusted()),
                     lane_imm: 0,
                 };
-                inst.emit(&[], sink, emit_info, state);
+                inst.emit(sink, emit_info, state);
             }
             &Inst::LoadFpuConst64 { rd, const_data } => {
-                let rd = allocs.next_writable(rd);
-
                 let opcode = 0xa75; // BRAS
                 let reg = writable_spilltmp_reg().to_reg();
                 put(sink, &enc_ri_b(opcode, reg, 12));
@@ -2612,12 +2445,9 @@ impl Inst {
                     mem: MemArg::reg(reg, MemFlags::trusted()),
                     lane_imm: 0,
                 };
-                inst.emit(&[], sink, emit_info, state);
+                inst.emit(sink, emit_info, state);
             }
             &Inst::FpuRR { fpu_op, rd, rn } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-
                 let (opcode, m3, m4, m5, opcode_fpr) = match fpu_op {
                     FPUOp1::Abs32 => (0xe7cc, 2, 8, 2, Some(0xb300)), // WFPSO, LPEBR
                     FPUOp1::Abs64 => (0xe7cc, 3, 8, 2, Some(0xb310)), // WFPSO, LPDBR
@@ -2645,10 +2475,6 @@ impl Inst {
                 }
             }
             &Inst::FpuRRR { fpu_op, rd, rn, rm } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
-
                 let (opcode, m4, m5, m6, opcode_fpr) = match fpu_op {
                     FPUOp2::Add32 => (0xe7e3, 2, 8, 0, Some(0xb30a)), // WFA, AEBR
                     FPUOp2::Add64 => (0xe7e3, 3, 8, 0, Some(0xb31a)), // WFA, ADBR
@@ -2697,11 +2523,6 @@ impl Inst {
                 rm,
                 ra,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
-                let ra = allocs.next(ra);
-
                 let (opcode, m5, m6, opcode_fpr) = match fpu_op {
                     FPUOp3::MAdd32 => (0xe78f, 8, 2, Some(0xb30e)), // WFMA, MAEBR
                     FPUOp3::MAdd64 => (0xe78f, 8, 3, Some(0xb31e)), // WFMA, MADBR
@@ -2719,9 +2540,6 @@ impl Inst {
                 }
             }
             &Inst::FpuRound { op, mode, rd, rn } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-
                 let mode = match mode {
                     FpuRoundMode::Current => 0,
                     FpuRoundMode::ToNearest => 1,
@@ -2765,9 +2583,6 @@ impl Inst {
                 }
             }
             &Inst::FpuCmp32 { rn, rm } => {
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
-
                 if is_fpr(rn) && is_fpr(rm) {
                     let opcode = 0xb309; // CEBR
                     put(sink, &enc_rre(opcode, rn, rm));
@@ -2777,9 +2592,6 @@ impl Inst {
                 }
             }
             &Inst::FpuCmp64 { rn, rm } => {
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
-
                 if is_fpr(rn) && is_fpr(rm) {
                     let opcode = 0xb319; // CDBR
                     put(sink, &enc_rre(opcode, rn, rm));
@@ -2790,10 +2602,6 @@ impl Inst {
             }
 
             &Inst::VecRRR { op, rd, rn, rm } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
-
                 let (opcode, m4) = match op {
                     VecBinaryOp::Add8x16 => (0xe7f3, 0),       // VAB
                     VecBinaryOp::Add16x8 => (0xe7f3, 1),       // VAH
@@ -2887,9 +2695,6 @@ impl Inst {
                 put(sink, &enc_vrr_c(opcode, rd.to_reg(), rn, rm, m4, 0, 0));
             }
             &Inst::VecRR { op, rd, rn } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-
                 let (opcode, m3) = match op {
                     VecUnaryOp::Abs8x16 => (0xe7df, 0),         // VLPB
                     VecUnaryOp::Abs16x8 => (0xe7df, 1),         // VLPH
@@ -2934,10 +2739,6 @@ impl Inst {
                 shift_imm,
                 shift_reg,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let shift_reg = allocs.next(shift_reg);
-
                 let (opcode, m4) = match shift_op {
                     VecShiftOp::RotL8x16 => (0xe733, 0), // VERLLB
                     VecShiftOp::RotL16x8 => (0xe733, 1), // VERLLH
@@ -2962,20 +2763,10 @@ impl Inst {
                 );
             }
             &Inst::VecSelect { rd, rn, rm, ra } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
-                let ra = allocs.next(ra);
-
                 let opcode = 0xe78d; // VSEL
                 put(sink, &enc_vrr_e(opcode, rd.to_reg(), rn, rm, ra, 0, 0));
             }
             &Inst::VecPermute { rd, rn, rm, ra } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
-                let ra = allocs.next(ra);
-
                 let opcode = 0xe78c; // VPERM
                 put(sink, &enc_vrr_e(opcode, rd.to_reg(), rn, rm, ra, 0, 0));
             }
@@ -2986,19 +2777,12 @@ impl Inst {
                 idx1,
                 idx2,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
                 let m4 = (idx1 & 1) * 4 + (idx2 & 1);
 
                 let opcode = 0xe784; // VPDI
                 put(sink, &enc_vrr_c(opcode, rd.to_reg(), rn, rm, m4, 0, 0));
             }
             &Inst::VecIntCmp { op, rd, rn, rm } | &Inst::VecIntCmpS { op, rd, rn, rm } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
-
                 let (opcode, m4) = match op {
                     VecIntCmpOp::CmpEq8x16 => (0xe7f8, 0),  // VCEQB
                     VecIntCmpOp::CmpEq16x8 => (0xe7f8, 1),  // VCEQH
@@ -3022,10 +2806,6 @@ impl Inst {
                 put(sink, &enc_vrr_b(opcode, rd.to_reg(), rn, rm, m4, m5));
             }
             &Inst::VecFloatCmp { op, rd, rn, rm } | &Inst::VecFloatCmpS { op, rd, rn, rm } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
-
                 let (opcode, m4) = match op {
                     VecFloatCmpOp::CmpEq32x4 => (0xe7e8, 2),   // VFCESB
                     VecFloatCmpOp::CmpEq64x2 => (0xe7e8, 3),   // VFCEDB
@@ -3045,9 +2825,6 @@ impl Inst {
             &Inst::VecInt128SCmpHi { tmp, rn, rm } | &Inst::VecInt128UCmpHi { tmp, rn, rm } => {
                 // Synthetic instruction to compare 128-bit values.
                 // Sets CC 1 if rn > rm, sets a different CC otherwise.
-                let tmp = allocs.next_writable(tmp);
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
 
                 // Use VECTOR ELEMENT COMPARE to compare the high parts.
                 // Swap the inputs to get:
@@ -3079,7 +2856,7 @@ impl Inst {
                     rn,
                     rm,
                 };
-                inst.emit(&[], sink, emit_info, state);
+                inst.emit(sink, emit_info, state);
             }
 
             &Inst::VecLoad { rd, ref mem }
@@ -3090,8 +2867,7 @@ impl Inst {
             | &Inst::VecLoadElt16Rev { rd, ref mem }
             | &Inst::VecLoadElt32Rev { rd, ref mem }
             | &Inst::VecLoadElt64Rev { rd, ref mem } => {
-                let rd = allocs.next_writable(rd);
-                let mem = mem.with_allocs(allocs);
+                let mem = mem.clone();
 
                 let (opcode, m3) = match self {
                     &Inst::VecLoad { .. } => (0xe706, 0),          // VL
@@ -3114,8 +2890,7 @@ impl Inst {
             | &Inst::VecStoreElt16Rev { rd, ref mem }
             | &Inst::VecStoreElt32Rev { rd, ref mem }
             | &Inst::VecStoreElt64Rev { rd, ref mem } => {
-                let rd = allocs.next(rd);
-                let mem = mem.with_allocs(allocs);
+                let mem = mem.clone();
 
                 let (opcode, m3) = match self {
                     &Inst::VecStore { .. } => (0xe70e, 0),          // VST
@@ -3132,8 +2907,7 @@ impl Inst {
             }
             &Inst::VecLoadReplicate { size, rd, ref mem }
             | &Inst::VecLoadReplicateRev { size, rd, ref mem } => {
-                let rd = allocs.next_writable(rd);
-                let mem = mem.with_allocs(allocs);
+                let mem = mem.clone();
 
                 let (opcode, m3) = match (self, size) {
                     (&Inst::VecLoadReplicate { .. }, 8) => (0xe705, 0), // VLREPB
@@ -3149,17 +2923,11 @@ impl Inst {
             }
 
             &Inst::VecMov { rd, rn } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-
                 let opcode = 0xe756; // VLR
                 put(sink, &enc_vrr_a(opcode, rd.to_reg(), rn, 0, 0, 0));
             }
             &Inst::VecCMov { rd, cond, ri, rm } => {
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
-                let rm = allocs.next(rm);
 
                 let opcode = 0xa74; // BCR
                 put(sink, &enc_ri_c(opcode, cond.invert().bits(), 4 + 6));
@@ -3167,16 +2935,10 @@ impl Inst {
                 put(sink, &enc_vrr_a(opcode, rd.to_reg(), rm, 0, 0, 0));
             }
             &Inst::MovToVec128 { rd, rn, rm } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
-
                 let opcode = 0xe762; // VLVGP
                 put(sink, &enc_vrr_f(opcode, rd.to_reg(), rn, rm));
             }
             &Inst::VecLoadConst { rd, const_data } => {
-                let rd = allocs.next_writable(rd);
-
                 let opcode = 0xa75; // BRAS
                 let reg = writable_spilltmp_reg().to_reg();
                 put(sink, &enc_ri_b(opcode, reg, 20));
@@ -3187,15 +2949,13 @@ impl Inst {
                     rd,
                     mem: MemArg::reg(reg, MemFlags::trusted()),
                 };
-                inst.emit(&[], sink, emit_info, state);
+                inst.emit(sink, emit_info, state);
             }
             &Inst::VecLoadConstReplicate {
                 size,
                 rd,
                 const_data,
             } => {
-                let rd = allocs.next_writable(rd);
-
                 let opcode = 0xa75; // BRAS
                 let reg = writable_spilltmp_reg().to_reg();
                 put(sink, &enc_ri_b(opcode, reg, (4 + size / 8) as i32));
@@ -3207,10 +2967,9 @@ impl Inst {
                     rd,
                     mem: MemArg::reg(reg, MemFlags::trusted()),
                 };
-                inst.emit(&[], sink, emit_info, state);
+                inst.emit(sink, emit_info, state);
             }
             &Inst::VecImmByteMask { rd, mask } => {
-                let rd = allocs.next_writable(rd);
                 let opcode = 0xe744; // VGBM
                 put(sink, &enc_vri_a(opcode, rd.to_reg(), mask, 0));
             }
@@ -3220,7 +2979,6 @@ impl Inst {
                 start_bit,
                 end_bit,
             } => {
-                let rd = allocs.next_writable(rd);
                 let (opcode, m4) = match size {
                     8 => (0xe746, 0),  // VGMB
                     16 => (0xe746, 1), // VGMH
@@ -3234,7 +2992,6 @@ impl Inst {
                 );
             }
             &Inst::VecImmReplicate { size, rd, imm } => {
-                let rd = allocs.next_writable(rd);
                 let (opcode, m3) = match size {
                     8 => (0xe745, 0),  // VREPIB
                     16 => (0xe745, 1), // VREPIH
@@ -3258,10 +3015,8 @@ impl Inst {
                 ref mem,
                 lane_imm,
             } => {
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
-                let mem = mem.with_allocs(allocs);
+                let mem = mem.clone();
 
                 let opcode_vrx = match (self, size) {
                     (&Inst::VecLoadLane { .. }, 8) => 0xe700,     // VLEB
@@ -3298,8 +3053,7 @@ impl Inst {
                 ref mem,
                 lane_imm,
             } => {
-                let rd = allocs.next_writable(rd);
-                let mem = mem.with_allocs(allocs);
+                let mem = mem.clone();
 
                 let (opcode_vrx, opcode_rx, opcode_rxy) = match (self, size) {
                     (&Inst::VecLoadLaneUndef { .. }, 8) => (0xe700, None, None), // VLEB
@@ -3342,8 +3096,7 @@ impl Inst {
                 ref mem,
                 lane_imm,
             } => {
-                let rd = allocs.next(rd);
-                let mem = mem.with_allocs(allocs);
+                let mem = mem.clone();
 
                 let (opcode_vrx, opcode_rx, opcode_rxy) = match (self, size) {
                     (&Inst::VecStoreLane { .. }, 8) => (0xe708, None, None), // VSTEB
@@ -3381,11 +3134,7 @@ impl Inst {
                 lane_imm,
                 lane_reg,
             } => {
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
-                let rn = allocs.next(rn);
-                let lane_reg = allocs.next(lane_reg);
 
                 let (opcode_vrs, m4) = match size {
                     8 => (0xe722, 0),  // VLVGB
@@ -3406,10 +3155,6 @@ impl Inst {
                 lane_imm,
                 lane_reg,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let lane_reg = allocs.next(lane_reg);
-
                 let (opcode_vrs, m4, opcode_rre) = match size {
                     8 => (0xe722, 0, None),          // VLVGB
                     16 => (0xe722, 1, None),         // VLVGH
@@ -3437,10 +3182,6 @@ impl Inst {
                 lane_imm,
                 lane_reg,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let lane_reg = allocs.next(lane_reg);
-
                 let (opcode_vrs, m4, opcode_rre) = match size {
                     8 => (0xe721, 0, None),          // VLGVB
                     16 => (0xe721, 1, None),         // VLGVH
@@ -3464,8 +3205,6 @@ impl Inst {
                 imm,
                 lane_imm,
             } => {
-                let rd = allocs.next_writable(rd);
-                let ri = allocs.next(ri);
                 debug_assert_eq!(rd.to_reg(), ri);
 
                 let opcode = match size {
@@ -3486,9 +3225,6 @@ impl Inst {
                 rn,
                 lane_imm,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-
                 let (opcode, m4) = match size {
                     8 => (0xe74d, 0),  // VREPB
                     16 => (0xe74d, 1), // VREPH
@@ -3502,9 +3238,35 @@ impl Inst {
                 );
             }
 
+            &Inst::AllocateArgs { size } => {
+                let inst = if let Ok(size) = i16::try_from(size) {
+                    Inst::AluRSImm16 {
+                        alu_op: ALUOp::Add64,
+                        rd: writable_stack_reg(),
+                        ri: stack_reg(),
+                        imm: -size,
+                    }
+                } else {
+                    Inst::AluRUImm32 {
+                        alu_op: ALUOp::SubLogical64,
+                        rd: writable_stack_reg(),
+                        ri: stack_reg(),
+                        imm: size,
+                    }
+                };
+                inst.emit(sink, emit_info, state);
+                state.nominal_sp_offset += size;
+            }
             &Inst::Call { link, ref info } => {
                 debug_assert_eq!(link.to_reg(), gpr(14));
 
+                let opcode = 0xc05; // BRASL
+
+                // Add relocation for target function.  This has to be done *before*
+                // the S390xTlsGdCall relocation if any, to ensure linker relaxation
+                // works correctly.
+                sink.add_reloc_at_offset(2, Reloc::S390xPLTRel32Dbl, &info.dest, 2);
+
                 // Add relocation for TLS libcalls to enable linker optimizations.
                 match &info.tls_symbol {
                     None => {}
@@ -3514,35 +3276,58 @@ impl Inst {
                     _ => unreachable!(),
                 }
 
-                let opcode = 0xc05; // BRASL
-                let reloc = Reloc::S390xPLTRel32Dbl;
                 if let Some(s) = state.take_stack_map() {
-                    sink.add_stack_map(StackMapExtent::UpcomingBytes(6), s);
-                }
-                put_with_reloc(
-                    sink,
-                    &enc_ril_b(opcode, link.to_reg(), 0),
-                    2,
-                    reloc,
-                    &info.dest,
-                    0,
-                );
-                if info.opcode.is_call() {
-                    sink.add_call_site(info.opcode);
+                    let offset = sink.cur_offset() + 6;
+                    sink.push_user_stack_map(state, offset, s);
                 }
+
+                put(sink, &enc_ril_b(opcode, link.to_reg(), 0));
+                sink.add_call_site();
+
+                state.nominal_sp_offset -= info.callee_pop_size;
             }
             &Inst::CallInd { link, ref info } => {
                 debug_assert_eq!(link.to_reg(), gpr(14));
-                let rn = allocs.next(info.rn);
+                let rn = info.rn;
 
-                let opcode = 0x0d; // BASR
                 if let Some(s) = state.take_stack_map() {
-                    sink.add_stack_map(StackMapExtent::UpcomingBytes(2), s);
+                    let offset = sink.cur_offset() + 2;
+                    sink.push_user_stack_map(state, offset, s);
                 }
+
+                let opcode = 0x0d; // BASR
                 put(sink, &enc_rr(opcode, link.to_reg(), rn));
-                if info.opcode.is_call() {
-                    sink.add_call_site(info.opcode);
+                sink.add_call_site();
+
+                state.nominal_sp_offset -= info.callee_pop_size;
+            }
+            &Inst::ReturnCall { ref info } => {
+                for inst in S390xMachineDeps::gen_tail_epilogue(
+                    state.frame_layout(),
+                    info.callee_pop_size,
+                    None,
+                ) {
+                    inst.emit(sink, emit_info, state);
                 }
+
+                let opcode = 0xc04; // BCRL
+                sink.add_reloc_at_offset(2, Reloc::S390xPLTRel32Dbl, &info.dest, 2);
+                put(sink, &enc_ril_c(opcode, 15, 0));
+                sink.add_call_site();
+            }
+            &Inst::ReturnCallInd { ref info } => {
+                let mut rn = info.rn;
+                for inst in S390xMachineDeps::gen_tail_epilogue(
+                    state.frame_layout(),
+                    info.callee_pop_size,
+                    Some(&mut rn),
+                ) {
+                    inst.emit(sink, emit_info, state);
+                }
+
+                let opcode = 0x07; // BCR
+                put(sink, &enc_rr(opcode, gpr(15), rn));
+                sink.add_call_site();
             }
             &Inst::Args { .. } => {}
             &Inst::Rets { .. } => {}
@@ -3561,8 +3346,6 @@ impl Inst {
                 put(sink, &enc_ril_c(opcode, 15, 0));
             }
             &Inst::IndirectBr { rn, .. } => {
-                let rn = allocs.next(rn);
-
                 let opcode = 0x07; // BCR
                 put(sink, &enc_rr(opcode, gpr(15), rn));
             }
@@ -3599,15 +3382,9 @@ impl Inst {
                 put(sink, &enc_e(0x0001));
             }
             &Inst::Trap { trap_code } => {
-                if let Some(s) = state.take_stack_map() {
-                    sink.add_stack_map(StackMapExtent::UpcomingBytes(2), s);
-                }
                 put_with_trap(sink, &enc_e(0x0000), trap_code);
             }
             &Inst::TrapIf { cond, trap_code } => {
-                if let Some(s) = state.take_stack_map() {
-                    sink.add_stack_map(StackMapExtent::UpcomingBytes(6), s);
-                }
                 // We implement a TrapIf as a conditional branch into the middle
                 // of the branch (BRCL) instruction itself - those middle two bytes
                 // are zero, which matches the trap instruction itself.
@@ -3620,8 +3397,6 @@ impl Inst {
                 put(sink, &enc[4..6]);
             }
             &Inst::JTSequence { ridx, ref targets } => {
-                let ridx = allocs.next(ridx);
-
                 let table_label = sink.get_label();
 
                 // This sequence is *one* instruction in the vcode, and is expanded only here at
@@ -3636,7 +3411,7 @@ impl Inst {
                         target: table_label,
                     },
                 };
-                inst.emit(&[], sink, emit_info, state);
+                inst.emit(sink, emit_info, state);
 
                 // Set temp to target address by adding the value of the jump table entry.
                 let inst = Inst::AluRX {
@@ -3645,7 +3420,7 @@ impl Inst {
                     ri: rtmp.to_reg(),
                     mem: MemArg::reg_plus_reg(rtmp.to_reg(), ridx, MemFlags::trusted()),
                 };
-                inst.emit(&[], sink, emit_info, state);
+                inst.emit(sink, emit_info, state);
 
                 // Branch to computed address. (`targets` here is only used for successor queries
                 // and is not needed for emission.)
@@ -3653,7 +3428,7 @@ impl Inst {
                     rn: rtmp.to_reg(),
                     targets: vec![],
                 };
-                inst.emit(&[], sink, emit_info, state);
+                inst.emit(sink, emit_info, state);
 
                 // Emit jump table (table of 32-bit offsets).
                 sink.bind_label(table_label, &mut state.ctrl_plane);
@@ -3670,15 +3445,6 @@ impl Inst {
                 start_off = sink.cur_offset();
             }
 
-            &Inst::VirtualSPOffsetAdj { offset } => {
-                trace!(
-                    "virtual sp offset adjusted by {} -> {}",
-                    offset,
-                    state.virtual_sp_offset + offset
-                );
-                state.virtual_sp_offset += offset;
-            }
-
             &Inst::Unwind { ref inst } => {
                 sink.add_unwind(inst.clone());
             }
diff --git a/cranelift/codegen/src/isa/s390x/inst/emit_tests.rs b/cranelift/codegen/src/isa/s390x/inst/emit_tests.rs
index 34ad9eb1e05e..9108b1fc0e7c 100644
--- a/cranelift/codegen/src/isa/s390x/inst/emit_tests.rs
+++ b/cranelift/codegen/src/isa/s390x/inst/emit_tests.rs
@@ -1,8 +1,6 @@
 use crate::ir::{MemFlags, TrapCode};
 use crate::isa::s390x::inst::*;
 use crate::isa::s390x::settings as s390x_settings;
-use crate::settings;
-use alloc::vec::Vec;
 use smallvec::smallvec;
 
 #[cfg(test)]
@@ -6991,7 +6989,7 @@ fn test_s390x_binemit() {
                 uses: smallvec![],
                 defs: smallvec![],
                 clobbers: PRegSet::empty(),
-                opcode: Opcode::Call,
+                callee_pop_size: 0,
                 caller_callconv: CallConv::SystemV,
                 callee_callconv: CallConv::SystemV,
                 tls_symbol: None,
@@ -7009,7 +7007,7 @@ fn test_s390x_binemit() {
                 uses: smallvec![],
                 defs: smallvec![],
                 clobbers: PRegSet::empty(),
-                opcode: Opcode::CallIndirect,
+                callee_pop_size: 0,
                 caller_callconv: CallConv::SystemV,
                 callee_callconv: CallConv::SystemV,
             }),
@@ -13361,14 +13359,10 @@ fn test_s390x_binemit() {
 
     let emit_info = EmitInfo::new(isa_flags);
     for (insn, expected_encoding, expected_printing) in insns {
-        println!(
-            "S390x: {:?}, {}, {}",
-            insn, expected_encoding, expected_printing
-        );
+        println!("S390x: {insn:?}, {expected_encoding}, {expected_printing}");
 
         // Check the printed text is as expected.
-        let actual_printing =
-            insn.print_with_state(&mut EmitState::default(), &mut AllocationConsumer::new(&[]));
+        let actual_printing = insn.print_with_state(&mut EmitState::default());
         assert_eq!(expected_printing, actual_printing);
 
         let mut buffer = MachBuffer::new();
@@ -13378,7 +13372,7 @@ fn test_s390x_binemit() {
         buffer.bind_label(label0, ctrl_plane);
 
         // Emit the instruction.
-        insn.emit(&[], &mut buffer, &emit_info, &mut Default::default());
+        insn.emit(&mut buffer, &emit_info, &mut Default::default());
 
         // Label 1 after the instruction.
         let label1 = buffer.get_label();
diff --git a/cranelift/codegen/src/isa/s390x/inst/imms.rs b/cranelift/codegen/src/isa/s390x/inst/imms.rs
index ff76c2200731..8ceebbcdac15 100644
--- a/cranelift/codegen/src/isa/s390x/inst/imms.rs
+++ b/cranelift/codegen/src/isa/s390x/inst/imms.rs
@@ -1,6 +1,6 @@
 //! S390x ISA definitions: immediate constants.
 
-use crate::machinst::{AllocationConsumer, PrettyPrint};
+use crate::machinst::PrettyPrint;
 use std::string::String;
 
 /// An unsigned 12-bit immediate.
@@ -178,25 +178,25 @@ impl UImm32Shifted {
 }
 
 impl PrettyPrint for UImm12 {
-    fn pretty_print(&self, _: u8, _: &mut AllocationConsumer<'_>) -> String {
+    fn pretty_print(&self, _: u8) -> String {
         format!("{}", self.value)
     }
 }
 
 impl PrettyPrint for SImm20 {
-    fn pretty_print(&self, _: u8, _: &mut AllocationConsumer<'_>) -> String {
+    fn pretty_print(&self, _: u8) -> String {
         format!("{}", self.value)
     }
 }
 
 impl PrettyPrint for UImm16Shifted {
-    fn pretty_print(&self, _: u8, _: &mut AllocationConsumer<'_>) -> String {
+    fn pretty_print(&self, _: u8) -> String {
         format!("{}", self.bits)
     }
 }
 
 impl PrettyPrint for UImm32Shifted {
-    fn pretty_print(&self, _: u8, _: &mut AllocationConsumer<'_>) -> String {
+    fn pretty_print(&self, _: u8) -> String {
         format!("{}", self.bits)
     }
 }
diff --git a/cranelift/codegen/src/isa/s390x/inst/mod.rs b/cranelift/codegen/src/isa/s390x/inst/mod.rs
index 0ece48c7b664..763c35a51ece 100644
--- a/cranelift/codegen/src/isa/s390x/inst/mod.rs
+++ b/cranelift/codegen/src/isa/s390x/inst/mod.rs
@@ -1,14 +1,14 @@
 //! This module defines s390x-specific machine instruction types.
 
 use crate::binemit::{Addend, CodeOffset, Reloc};
-use crate::ir::{types, ExternalName, Opcode, Type};
+use crate::ir::{types, ExternalName, Type};
 use crate::isa::s390x::abi::S390xMachineDeps;
 use crate::isa::{CallConv, FunctionAlignment};
 use crate::machinst::*;
 use crate::{settings, CodegenError, CodegenResult};
 use alloc::boxed::Box;
 use alloc::vec::Vec;
-use regalloc2::{PRegSet, VReg};
+use regalloc2::{PReg, PRegSet};
 use smallvec::SmallVec;
 use std::fmt::Write;
 use std::string::{String, ToString};
@@ -42,7 +42,7 @@ pub struct CallInfo {
     pub uses: CallArgList,
     pub defs: CallRetList,
     pub clobbers: PRegSet,
-    pub opcode: Opcode,
+    pub callee_pop_size: u32,
     pub caller_callconv: CallConv,
     pub callee_callconv: CallConv,
     pub tls_symbol: Option<SymbolReloc>,
@@ -56,11 +56,29 @@ pub struct CallIndInfo {
     pub uses: CallArgList,
     pub defs: CallRetList,
     pub clobbers: PRegSet,
-    pub opcode: Opcode,
+    pub callee_pop_size: u32,
     pub caller_callconv: CallConv,
     pub callee_callconv: CallConv,
 }
 
+/// Additional information for (direct) ReturnCall instructions, left out of line to lower the size of
+/// the Inst enum.
+#[derive(Clone, Debug)]
+pub struct ReturnCallInfo {
+    pub dest: ExternalName,
+    pub uses: CallArgList,
+    pub callee_pop_size: u32,
+}
+
+/// Additional information for ReturnCallInd instructions, left out of line to lower the size of the Inst
+/// enum.
+#[derive(Clone, Debug)]
+pub struct ReturnCallIndInfo {
+    pub rn: Reg,
+    pub uses: CallArgList,
+    pub callee_pop_size: u32,
+}
+
 #[test]
 fn inst_size_test() {
     // This test will help with unintentionally growing the size
@@ -229,8 +247,11 @@ impl Inst {
             | Inst::VecExtractLane { .. }
             | Inst::VecInsertLaneImm { .. }
             | Inst::VecReplicateLane { .. }
+            | Inst::AllocateArgs { .. }
             | Inst::Call { .. }
             | Inst::CallInd { .. }
+            | Inst::ReturnCall { .. }
+            | Inst::ReturnCallInd { .. }
             | Inst::Args { .. }
             | Inst::Rets { .. }
             | Inst::Ret { .. }
@@ -246,7 +267,6 @@ impl Inst {
             | Inst::LoadAddr { .. }
             | Inst::Loop { .. }
             | Inst::CondBreak { .. }
-            | Inst::VirtualSPOffsetAdj { .. }
             | Inst::Unwind { .. } => InstructionSet::Base,
 
             // These depend on the opcode
@@ -341,7 +361,7 @@ impl Inst {
             types::I8 => Inst::Load64ZExt8 { rd: into_reg, mem },
             types::I16 => Inst::Load64ZExt16 { rd: into_reg, mem },
             types::I32 => Inst::Load64ZExt32 { rd: into_reg, mem },
-            types::I64 | types::R64 => Inst::Load64 { rd: into_reg, mem },
+            types::I64 => Inst::Load64 { rd: into_reg, mem },
             types::F32 => Inst::VecLoadLaneUndef {
                 size: 32,
                 rd: into_reg,
@@ -366,7 +386,7 @@ impl Inst {
             types::I8 => Inst::Store8 { rd: from_reg, mem },
             types::I16 => Inst::Store16 { rd: from_reg, mem },
             types::I32 => Inst::Store32 { rd: from_reg, mem },
-            types::I64 | types::R64 => Inst::Store64 { rd: from_reg, mem },
+            types::I64 => Inst::Store64 { rd: from_reg, mem },
             types::F32 => Inst::VecStoreLane {
                 size: 32,
                 rd: from_reg,
@@ -389,492 +409,467 @@ impl Inst {
 //=============================================================================
 // Instructions: get_regs
 
-fn memarg_operands<F: Fn(VReg) -> VReg>(memarg: &MemArg, collector: &mut OperandCollector<'_, F>) {
+fn memarg_operands(memarg: &mut MemArg, collector: &mut impl OperandVisitor) {
     match memarg {
-        &MemArg::BXD12 { base, index, .. } | &MemArg::BXD20 { base, index, .. } => {
+        MemArg::BXD12 { base, index, .. } | MemArg::BXD20 { base, index, .. } => {
             collector.reg_use(base);
             collector.reg_use(index);
         }
-        &MemArg::Label { .. } | &MemArg::Symbol { .. } => {}
-        &MemArg::RegOffset { reg, .. } => {
+        MemArg::Label { .. } | MemArg::Symbol { .. } => {}
+        MemArg::RegOffset { reg, .. } => {
             collector.reg_use(reg);
         }
-        &MemArg::InitialSPOffset { .. } | &MemArg::NominalSPOffset { .. } => {}
+        MemArg::InitialSPOffset { .. }
+        | MemArg::NominalSPOffset { .. }
+        | MemArg::SlotOffset { .. } => {}
     }
     // mem_finalize might require %r1 to hold (part of) the address.
     // Conservatively assume this will always be necessary here.
-    collector.reg_early_def(writable_gpr(1));
+    collector.reg_fixed_nonallocatable(gpr_preg(1));
 }
 
-fn s390x_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut OperandCollector<'_, F>) {
+fn s390x_get_operands(inst: &mut Inst, collector: &mut DenyReuseVisitor<impl OperandVisitor>) {
     match inst {
-        &Inst::AluRRR { rd, rn, rm, .. } => {
+        Inst::AluRRR { rd, rn, rm, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
             collector.reg_use(rm);
         }
-        &Inst::AluRRSImm16 { rd, rn, .. } => {
+        Inst::AluRRSImm16 { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::AluRR { rd, ri, rm, .. } => {
+        Inst::AluRR { rd, ri, rm, .. } => {
             collector.reg_reuse_def(rd, 1);
             collector.reg_use(ri);
             collector.reg_use(rm);
         }
-        &Inst::AluRX {
-            rd, ri, ref mem, ..
-        } => {
+        Inst::AluRX { rd, ri, mem, .. } => {
             collector.reg_reuse_def(rd, 1);
             collector.reg_use(ri);
             memarg_operands(mem, collector);
         }
-        &Inst::AluRSImm16 { rd, ri, .. } => {
+        Inst::AluRSImm16 { rd, ri, .. } => {
             collector.reg_reuse_def(rd, 1);
             collector.reg_use(ri);
         }
-        &Inst::AluRSImm32 { rd, ri, .. } => {
+        Inst::AluRSImm32 { rd, ri, .. } => {
             collector.reg_reuse_def(rd, 1);
             collector.reg_use(ri);
         }
-        &Inst::AluRUImm32 { rd, ri, .. } => {
+        Inst::AluRUImm32 { rd, ri, .. } => {
             collector.reg_reuse_def(rd, 1);
             collector.reg_use(ri);
         }
-        &Inst::AluRUImm16Shifted { rd, ri, .. } => {
+        Inst::AluRUImm16Shifted { rd, ri, .. } => {
             collector.reg_reuse_def(rd, 1);
             collector.reg_use(ri);
         }
-        &Inst::AluRUImm32Shifted { rd, ri, .. } => {
+        Inst::AluRUImm32Shifted { rd, ri, .. } => {
             collector.reg_reuse_def(rd, 1);
             collector.reg_use(ri);
         }
-        &Inst::SMulWide { rd, rn, rm } => {
+        Inst::SMulWide { rd, rn, rm } => {
             collector.reg_use(rn);
             collector.reg_use(rm);
             // FIXME: The pair is hard-coded as %r2/%r3 because regalloc cannot handle pairs. If
             // that changes, all the hard-coded uses of %r2/%r3 can be changed.
-            collector.reg_fixed_def(rd.hi, gpr(2));
-            collector.reg_fixed_def(rd.lo, gpr(3));
+            collector.reg_fixed_def(&mut rd.hi, gpr(2));
+            collector.reg_fixed_def(&mut rd.lo, gpr(3));
         }
-        &Inst::UMulWide { rd, ri, rn } => {
+        Inst::UMulWide { rd, ri, rn } => {
             collector.reg_use(rn);
-            collector.reg_fixed_def(rd.hi, gpr(2));
-            collector.reg_fixed_def(rd.lo, gpr(3));
+            collector.reg_fixed_def(&mut rd.hi, gpr(2));
+            collector.reg_fixed_def(&mut rd.lo, gpr(3));
             collector.reg_fixed_use(ri, gpr(3));
         }
-        &Inst::SDivMod32 { rd, ri, rn } | &Inst::SDivMod64 { rd, ri, rn } => {
+        Inst::SDivMod32 { rd, ri, rn } | Inst::SDivMod64 { rd, ri, rn } => {
             collector.reg_use(rn);
-            collector.reg_fixed_def(rd.hi, gpr(2));
-            collector.reg_fixed_def(rd.lo, gpr(3));
+            collector.reg_fixed_def(&mut rd.hi, gpr(2));
+            collector.reg_fixed_def(&mut rd.lo, gpr(3));
             collector.reg_fixed_use(ri, gpr(3));
         }
-        &Inst::UDivMod32 { rd, ri, rn } | &Inst::UDivMod64 { rd, ri, rn } => {
+        Inst::UDivMod32 { rd, ri, rn } | Inst::UDivMod64 { rd, ri, rn } => {
             collector.reg_use(rn);
-            collector.reg_fixed_def(rd.hi, gpr(2));
-            collector.reg_fixed_def(rd.lo, gpr(3));
-            collector.reg_fixed_use(ri.hi, gpr(2));
-            collector.reg_fixed_use(ri.lo, gpr(3));
+            collector.reg_fixed_def(&mut rd.hi, gpr(2));
+            collector.reg_fixed_def(&mut rd.lo, gpr(3));
+            collector.reg_fixed_use(&mut ri.hi, gpr(2));
+            collector.reg_fixed_use(&mut ri.lo, gpr(3));
         }
-        &Inst::Flogr { rd, rn } => {
+        Inst::Flogr { rd, rn } => {
             collector.reg_use(rn);
-            collector.reg_fixed_def(rd.hi, gpr(2));
-            collector.reg_fixed_def(rd.lo, gpr(3));
+            collector.reg_fixed_def(&mut rd.hi, gpr(2));
+            collector.reg_fixed_def(&mut rd.lo, gpr(3));
         }
-        &Inst::ShiftRR {
+        Inst::ShiftRR {
             rd, rn, shift_reg, ..
         } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
-            if shift_reg != zero_reg() {
-                collector.reg_use(shift_reg);
-            }
+            collector.reg_use(shift_reg);
         }
-        &Inst::RxSBG { rd, ri, rn, .. } => {
+        Inst::RxSBG { rd, ri, rn, .. } => {
             collector.reg_reuse_def(rd, 1);
             collector.reg_use(ri);
             collector.reg_use(rn);
         }
-        &Inst::RxSBGTest { rd, rn, .. } => {
+        Inst::RxSBGTest { rd, rn, .. } => {
             collector.reg_use(rd);
             collector.reg_use(rn);
         }
-        &Inst::UnaryRR { rd, rn, .. } => {
+        Inst::UnaryRR { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::CmpRR { rn, rm, .. } => {
+        Inst::CmpRR { rn, rm, .. } => {
             collector.reg_use(rn);
             collector.reg_use(rm);
         }
-        &Inst::CmpRX { rn, ref mem, .. } => {
+        Inst::CmpRX { rn, mem, .. } => {
             collector.reg_use(rn);
             memarg_operands(mem, collector);
         }
-        &Inst::CmpRSImm16 { rn, .. } => {
+        Inst::CmpRSImm16 { rn, .. } => {
             collector.reg_use(rn);
         }
-        &Inst::CmpRSImm32 { rn, .. } => {
+        Inst::CmpRSImm32 { rn, .. } => {
             collector.reg_use(rn);
         }
-        &Inst::CmpRUImm32 { rn, .. } => {
+        Inst::CmpRUImm32 { rn, .. } => {
             collector.reg_use(rn);
         }
-        &Inst::CmpTrapRR { rn, rm, .. } => {
+        Inst::CmpTrapRR { rn, rm, .. } => {
             collector.reg_use(rn);
             collector.reg_use(rm);
         }
-        &Inst::CmpTrapRSImm16 { rn, .. } => {
+        Inst::CmpTrapRSImm16 { rn, .. } => {
             collector.reg_use(rn);
         }
-        &Inst::CmpTrapRUImm16 { rn, .. } => {
+        Inst::CmpTrapRUImm16 { rn, .. } => {
             collector.reg_use(rn);
         }
-        &Inst::AtomicRmw {
-            rd, rn, ref mem, ..
-        } => {
+        Inst::AtomicRmw { rd, rn, mem, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
             memarg_operands(mem, collector);
         }
-        &Inst::AtomicCas32 {
-            rd,
-            ri,
-            rn,
-            ref mem,
-            ..
+        Inst::AtomicCas32 {
+            rd, ri, rn, mem, ..
         }
-        | &Inst::AtomicCas64 {
-            rd,
-            ri,
-            rn,
-            ref mem,
-            ..
+        | Inst::AtomicCas64 {
+            rd, ri, rn, mem, ..
         } => {
             collector.reg_reuse_def(rd, 1);
             collector.reg_use(ri);
             collector.reg_use(rn);
             memarg_operands(mem, collector);
         }
-        &Inst::Fence => {}
-        &Inst::Load32 { rd, ref mem, .. }
-        | &Inst::Load32ZExt8 { rd, ref mem, .. }
-        | &Inst::Load32SExt8 { rd, ref mem, .. }
-        | &Inst::Load32ZExt16 { rd, ref mem, .. }
-        | &Inst::Load32SExt16 { rd, ref mem, .. }
-        | &Inst::Load64 { rd, ref mem, .. }
-        | &Inst::Load64ZExt8 { rd, ref mem, .. }
-        | &Inst::Load64SExt8 { rd, ref mem, .. }
-        | &Inst::Load64ZExt16 { rd, ref mem, .. }
-        | &Inst::Load64SExt16 { rd, ref mem, .. }
-        | &Inst::Load64ZExt32 { rd, ref mem, .. }
-        | &Inst::Load64SExt32 { rd, ref mem, .. }
-        | &Inst::LoadRev16 { rd, ref mem, .. }
-        | &Inst::LoadRev32 { rd, ref mem, .. }
-        | &Inst::LoadRev64 { rd, ref mem, .. } => {
+        Inst::Fence => {}
+        Inst::Load32 { rd, mem, .. }
+        | Inst::Load32ZExt8 { rd, mem, .. }
+        | Inst::Load32SExt8 { rd, mem, .. }
+        | Inst::Load32ZExt16 { rd, mem, .. }
+        | Inst::Load32SExt16 { rd, mem, .. }
+        | Inst::Load64 { rd, mem, .. }
+        | Inst::Load64ZExt8 { rd, mem, .. }
+        | Inst::Load64SExt8 { rd, mem, .. }
+        | Inst::Load64ZExt16 { rd, mem, .. }
+        | Inst::Load64SExt16 { rd, mem, .. }
+        | Inst::Load64ZExt32 { rd, mem, .. }
+        | Inst::Load64SExt32 { rd, mem, .. }
+        | Inst::LoadRev16 { rd, mem, .. }
+        | Inst::LoadRev32 { rd, mem, .. }
+        | Inst::LoadRev64 { rd, mem, .. } => {
             collector.reg_def(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::Store8 { rd, ref mem, .. }
-        | &Inst::Store16 { rd, ref mem, .. }
-        | &Inst::Store32 { rd, ref mem, .. }
-        | &Inst::Store64 { rd, ref mem, .. }
-        | &Inst::StoreRev16 { rd, ref mem, .. }
-        | &Inst::StoreRev32 { rd, ref mem, .. }
-        | &Inst::StoreRev64 { rd, ref mem, .. } => {
+        Inst::Store8 { rd, mem, .. }
+        | Inst::Store16 { rd, mem, .. }
+        | Inst::Store32 { rd, mem, .. }
+        | Inst::Store64 { rd, mem, .. }
+        | Inst::StoreRev16 { rd, mem, .. }
+        | Inst::StoreRev32 { rd, mem, .. }
+        | Inst::StoreRev64 { rd, mem, .. } => {
             collector.reg_use(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::StoreImm8 { ref mem, .. }
-        | &Inst::StoreImm16 { ref mem, .. }
-        | &Inst::StoreImm32SExt16 { ref mem, .. }
-        | &Inst::StoreImm64SExt16 { ref mem, .. } => {
+        Inst::StoreImm8 { mem, .. }
+        | Inst::StoreImm16 { mem, .. }
+        | Inst::StoreImm32SExt16 { mem, .. }
+        | Inst::StoreImm64SExt16 { mem, .. } => {
             memarg_operands(mem, collector);
         }
-        &Inst::Mvc {
-            ref dst, ref src, ..
-        } => {
-            collector.reg_use(dst.base);
-            collector.reg_use(src.base);
+        Inst::Mvc { dst, src, .. } => {
+            collector.reg_use(&mut dst.base);
+            collector.reg_use(&mut src.base);
         }
-        &Inst::LoadMultiple64 {
-            rt, rt2, ref mem, ..
-        } => {
+        Inst::LoadMultiple64 { rt, rt2, mem, .. } => {
             memarg_operands(mem, collector);
             let first_regnum = rt.to_reg().to_real_reg().unwrap().hw_enc();
             let last_regnum = rt2.to_reg().to_real_reg().unwrap().hw_enc();
             for regnum in first_regnum..last_regnum + 1 {
-                collector.reg_def(writable_gpr(regnum));
+                collector.reg_fixed_nonallocatable(gpr_preg(regnum));
             }
         }
-        &Inst::StoreMultiple64 {
-            rt, rt2, ref mem, ..
-        } => {
+        Inst::StoreMultiple64 { rt, rt2, mem, .. } => {
             memarg_operands(mem, collector);
             let first_regnum = rt.to_real_reg().unwrap().hw_enc();
             let last_regnum = rt2.to_real_reg().unwrap().hw_enc();
             for regnum in first_regnum..last_regnum + 1 {
-                collector.reg_use(gpr(regnum));
+                collector.reg_fixed_nonallocatable(gpr_preg(regnum));
             }
         }
-        &Inst::Mov64 { rd, rm } => {
+        Inst::Mov64 { rd, rm } => {
             collector.reg_def(rd);
             collector.reg_use(rm);
         }
-        &Inst::MovPReg { rd, rm } => {
-            debug_assert!([regs::gpr(0), regs::gpr(14), regs::gpr(15)].contains(&rm.into()));
+        Inst::MovPReg { rd, rm } => {
+            debug_assert!([gpr_preg(0), gpr_preg(14), gpr_preg(15)].contains(rm));
             debug_assert!(rd.to_reg().is_virtual());
             collector.reg_def(rd);
         }
-        &Inst::Mov32 { rd, rm } => {
+        Inst::Mov32 { rd, rm } => {
             collector.reg_def(rd);
             collector.reg_use(rm);
         }
-        &Inst::Mov32Imm { rd, .. }
-        | &Inst::Mov32SImm16 { rd, .. }
-        | &Inst::Mov64SImm16 { rd, .. }
-        | &Inst::Mov64SImm32 { rd, .. }
-        | &Inst::Mov64UImm16Shifted { rd, .. }
-        | &Inst::Mov64UImm32Shifted { rd, .. } => {
+        Inst::Mov32Imm { rd, .. }
+        | Inst::Mov32SImm16 { rd, .. }
+        | Inst::Mov64SImm16 { rd, .. }
+        | Inst::Mov64SImm32 { rd, .. }
+        | Inst::Mov64UImm16Shifted { rd, .. }
+        | Inst::Mov64UImm32Shifted { rd, .. } => {
             collector.reg_def(rd);
         }
-        &Inst::CMov32 { rd, ri, rm, .. } | &Inst::CMov64 { rd, ri, rm, .. } => {
+        Inst::CMov32 { rd, ri, rm, .. } | Inst::CMov64 { rd, ri, rm, .. } => {
             collector.reg_reuse_def(rd, 1);
             collector.reg_use(ri);
             collector.reg_use(rm);
         }
-        &Inst::CMov32SImm16 { rd, ri, .. } | &Inst::CMov64SImm16 { rd, ri, .. } => {
+        Inst::CMov32SImm16 { rd, ri, .. } | Inst::CMov64SImm16 { rd, ri, .. } => {
             collector.reg_reuse_def(rd, 1);
             collector.reg_use(ri);
         }
-        &Inst::Insert64UImm16Shifted { rd, ri, .. }
-        | &Inst::Insert64UImm32Shifted { rd, ri, .. } => {
+        Inst::Insert64UImm16Shifted { rd, ri, .. } | Inst::Insert64UImm32Shifted { rd, ri, .. } => {
             collector.reg_reuse_def(rd, 1);
             collector.reg_use(ri);
         }
-        &Inst::LoadAR { rd, .. } => {
+        Inst::LoadAR { rd, .. } => {
             collector.reg_def(rd);
         }
-        &Inst::InsertAR { rd, ri, .. } => {
+        Inst::InsertAR { rd, ri, .. } => {
             collector.reg_reuse_def(rd, 1);
             collector.reg_use(ri);
         }
-        &Inst::FpuMove32 { rd, rn } | &Inst::FpuMove64 { rd, rn } => {
+        Inst::FpuMove32 { rd, rn } | Inst::FpuMove64 { rd, rn } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::FpuCMov32 { rd, ri, rm, .. } | &Inst::FpuCMov64 { rd, ri, rm, .. } => {
+        Inst::FpuCMov32 { rd, ri, rm, .. } | Inst::FpuCMov64 { rd, ri, rm, .. } => {
             collector.reg_reuse_def(rd, 1);
             collector.reg_use(ri);
             collector.reg_use(rm);
         }
-        &Inst::FpuRR { rd, rn, .. } => {
+        Inst::FpuRR { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::FpuRRR { rd, rn, rm, .. } => {
+        Inst::FpuRRR { rd, rn, rm, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
             collector.reg_use(rm);
         }
-        &Inst::FpuRRRR { rd, rn, rm, ra, .. } => {
+        Inst::FpuRRRR { rd, rn, rm, ra, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
             collector.reg_use(rm);
             collector.reg_use(ra);
         }
-        &Inst::FpuCmp32 { rn, rm } | &Inst::FpuCmp64 { rn, rm } => {
+        Inst::FpuCmp32 { rn, rm } | Inst::FpuCmp64 { rn, rm } => {
             collector.reg_use(rn);
             collector.reg_use(rm);
         }
-        &Inst::LoadFpuConst32 { rd, .. } | &Inst::LoadFpuConst64 { rd, .. } => {
+        Inst::LoadFpuConst32 { rd, .. } | Inst::LoadFpuConst64 { rd, .. } => {
             collector.reg_def(rd);
-            collector.reg_def(writable_gpr(1));
+            collector.reg_fixed_nonallocatable(gpr_preg(1));
         }
-        &Inst::FpuRound { rd, rn, .. } => {
+        Inst::FpuRound { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::VecRRR { rd, rn, rm, .. } => {
+        Inst::VecRRR { rd, rn, rm, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
             collector.reg_use(rm);
         }
-        &Inst::VecRR { rd, rn, .. } => {
+        Inst::VecRR { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::VecShiftRR {
+        Inst::VecShiftRR {
             rd, rn, shift_reg, ..
         } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
-            if shift_reg != zero_reg() {
-                collector.reg_use(shift_reg);
-            }
+            collector.reg_use(shift_reg);
         }
-        &Inst::VecSelect { rd, rn, rm, ra, .. } => {
+        Inst::VecSelect { rd, rn, rm, ra, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
             collector.reg_use(rm);
             collector.reg_use(ra);
         }
-        &Inst::VecPermute { rd, rn, rm, ra, .. } => {
+        Inst::VecPermute { rd, rn, rm, ra, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
             collector.reg_use(rm);
             collector.reg_use(ra);
         }
-        &Inst::VecPermuteDWImm { rd, rn, rm, .. } => {
+        Inst::VecPermuteDWImm { rd, rn, rm, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
             collector.reg_use(rm);
         }
-        &Inst::VecIntCmp { rd, rn, rm, .. } | &Inst::VecIntCmpS { rd, rn, rm, .. } => {
+        Inst::VecIntCmp { rd, rn, rm, .. } | Inst::VecIntCmpS { rd, rn, rm, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
             collector.reg_use(rm);
         }
-        &Inst::VecFloatCmp { rd, rn, rm, .. } | &Inst::VecFloatCmpS { rd, rn, rm, .. } => {
+        Inst::VecFloatCmp { rd, rn, rm, .. } | Inst::VecFloatCmpS { rd, rn, rm, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
             collector.reg_use(rm);
         }
-        &Inst::VecInt128SCmpHi { tmp, rn, rm, .. } | &Inst::VecInt128UCmpHi { tmp, rn, rm, .. } => {
+        Inst::VecInt128SCmpHi { tmp, rn, rm, .. } | Inst::VecInt128UCmpHi { tmp, rn, rm, .. } => {
             collector.reg_def(tmp);
             collector.reg_use(rn);
             collector.reg_use(rm);
         }
-        &Inst::VecLoad { rd, ref mem, .. } => {
+        Inst::VecLoad { rd, mem, .. } => {
             collector.reg_def(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::VecLoadRev { rd, ref mem, .. } => {
+        Inst::VecLoadRev { rd, mem, .. } => {
             collector.reg_def(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::VecLoadByte16Rev { rd, ref mem, .. } => {
+        Inst::VecLoadByte16Rev { rd, mem, .. } => {
             collector.reg_def(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::VecLoadByte32Rev { rd, ref mem, .. } => {
+        Inst::VecLoadByte32Rev { rd, mem, .. } => {
             collector.reg_def(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::VecLoadByte64Rev { rd, ref mem, .. } => {
+        Inst::VecLoadByte64Rev { rd, mem, .. } => {
             collector.reg_def(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::VecLoadElt16Rev { rd, ref mem, .. } => {
+        Inst::VecLoadElt16Rev { rd, mem, .. } => {
             collector.reg_def(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::VecLoadElt32Rev { rd, ref mem, .. } => {
+        Inst::VecLoadElt32Rev { rd, mem, .. } => {
             collector.reg_def(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::VecLoadElt64Rev { rd, ref mem, .. } => {
+        Inst::VecLoadElt64Rev { rd, mem, .. } => {
             collector.reg_def(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::VecStore { rd, ref mem, .. } => {
+        Inst::VecStore { rd, mem, .. } => {
             collector.reg_use(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::VecStoreRev { rd, ref mem, .. } => {
+        Inst::VecStoreRev { rd, mem, .. } => {
             collector.reg_use(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::VecStoreByte16Rev { rd, ref mem, .. } => {
+        Inst::VecStoreByte16Rev { rd, mem, .. } => {
             collector.reg_use(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::VecStoreByte32Rev { rd, ref mem, .. } => {
+        Inst::VecStoreByte32Rev { rd, mem, .. } => {
             collector.reg_use(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::VecStoreByte64Rev { rd, ref mem, .. } => {
+        Inst::VecStoreByte64Rev { rd, mem, .. } => {
             collector.reg_use(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::VecStoreElt16Rev { rd, ref mem, .. } => {
+        Inst::VecStoreElt16Rev { rd, mem, .. } => {
             collector.reg_use(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::VecStoreElt32Rev { rd, ref mem, .. } => {
+        Inst::VecStoreElt32Rev { rd, mem, .. } => {
             collector.reg_use(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::VecStoreElt64Rev { rd, ref mem, .. } => {
+        Inst::VecStoreElt64Rev { rd, mem, .. } => {
             collector.reg_use(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::VecLoadReplicate { rd, ref mem, .. } => {
+        Inst::VecLoadReplicate { rd, mem, .. } => {
             collector.reg_def(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::VecLoadReplicateRev { rd, ref mem, .. } => {
+        Inst::VecLoadReplicateRev { rd, mem, .. } => {
             collector.reg_def(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::VecMov { rd, rn } => {
+        Inst::VecMov { rd, rn } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::VecCMov { rd, ri, rm, .. } => {
+        Inst::VecCMov { rd, ri, rm, .. } => {
             collector.reg_reuse_def(rd, 1);
             collector.reg_use(ri);
             collector.reg_use(rm);
         }
-        &Inst::MovToVec128 { rd, rn, rm } => {
+        Inst::MovToVec128 { rd, rn, rm } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
             collector.reg_use(rm);
         }
-        &Inst::VecLoadConst { rd, .. } | &Inst::VecLoadConstReplicate { rd, .. } => {
+        Inst::VecLoadConst { rd, .. } | Inst::VecLoadConstReplicate { rd, .. } => {
             collector.reg_def(rd);
-            collector.reg_def(writable_gpr(1));
+            collector.reg_fixed_nonallocatable(gpr_preg(1));
         }
-        &Inst::VecImmByteMask { rd, .. } => {
+        Inst::VecImmByteMask { rd, .. } => {
             collector.reg_def(rd);
         }
-        &Inst::VecImmBitMask { rd, .. } => {
+        Inst::VecImmBitMask { rd, .. } => {
             collector.reg_def(rd);
         }
-        &Inst::VecImmReplicate { rd, .. } => {
+        Inst::VecImmReplicate { rd, .. } => {
             collector.reg_def(rd);
         }
-        &Inst::VecLoadLane {
-            rd, ri, ref mem, ..
-        } => {
+        Inst::VecLoadLane { rd, ri, mem, .. } => {
             collector.reg_reuse_def(rd, 1);
             collector.reg_use(ri);
             memarg_operands(mem, collector);
         }
-        &Inst::VecLoadLaneUndef { rd, ref mem, .. } => {
+        Inst::VecLoadLaneUndef { rd, mem, .. } => {
             collector.reg_def(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::VecStoreLaneRev { rd, ref mem, .. } => {
+        Inst::VecStoreLaneRev { rd, mem, .. } => {
             collector.reg_use(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::VecLoadLaneRevUndef { rd, ref mem, .. } => {
+        Inst::VecLoadLaneRevUndef { rd, mem, .. } => {
             collector.reg_def(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::VecStoreLane { rd, ref mem, .. } => {
+        Inst::VecStoreLane { rd, mem, .. } => {
             collector.reg_use(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::VecLoadLaneRev {
-            rd, ri, ref mem, ..
-        } => {
+        Inst::VecLoadLaneRev { rd, ri, mem, .. } => {
             collector.reg_reuse_def(rd, 1);
             collector.reg_use(ri);
             memarg_operands(mem, collector);
         }
-        &Inst::VecInsertLane {
+        Inst::VecInsertLane {
             rd,
             ri,
             rn,
@@ -884,118 +879,170 @@ fn s390x_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut OperandC
             collector.reg_reuse_def(rd, 1);
             collector.reg_use(ri);
             collector.reg_use(rn);
-            if lane_reg != zero_reg() {
-                collector.reg_use(lane_reg);
-            }
+            collector.reg_use(lane_reg);
         }
-        &Inst::VecInsertLaneUndef {
+        Inst::VecInsertLaneUndef {
             rd, rn, lane_reg, ..
         } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
-            if lane_reg != zero_reg() {
-                collector.reg_use(lane_reg);
-            }
+            collector.reg_use(lane_reg);
         }
-        &Inst::VecExtractLane {
+        Inst::VecExtractLane {
             rd, rn, lane_reg, ..
         } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
-            if lane_reg != zero_reg() {
-                collector.reg_use(lane_reg);
-            }
+            collector.reg_use(lane_reg);
         }
-        &Inst::VecInsertLaneImm { rd, ri, .. } => {
+        Inst::VecInsertLaneImm { rd, ri, .. } => {
             collector.reg_reuse_def(rd, 1);
             collector.reg_use(ri);
         }
-        &Inst::VecReplicateLane { rd, rn, .. } => {
+        Inst::VecReplicateLane { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::Extend { rd, rn, .. } => {
+        Inst::Extend { rd, rn, .. } => {
             collector.reg_def(rd);
             collector.reg_use(rn);
         }
-        &Inst::Call { link, ref info } => {
-            for u in &info.uses {
-                collector.reg_fixed_use(u.vreg, u.preg);
+        Inst::AllocateArgs { .. } => {}
+        Inst::Call { link, info } => {
+            let CallInfo {
+                uses,
+                defs,
+                clobbers,
+                ..
+            } = &mut **info;
+            for CallArgPair { vreg, preg } in uses {
+                collector.reg_fixed_use(vreg, *preg);
+            }
+            let mut clobbers = *clobbers;
+            clobbers.add(link.to_reg().to_real_reg().unwrap().into());
+            for CallRetPair { vreg, preg } in defs {
+                clobbers.remove(PReg::from(preg.to_real_reg().unwrap()));
+                collector.reg_fixed_def(vreg, *preg);
             }
-            for d in &info.defs {
-                collector.reg_fixed_def(d.vreg, d.preg);
+            collector.reg_clobbers(clobbers);
+        }
+        Inst::CallInd { link, info } => {
+            let CallIndInfo {
+                rn,
+                uses,
+                defs,
+                clobbers,
+                ..
+            } = &mut **info;
+            collector.reg_use(rn);
+            for CallArgPair { vreg, preg } in uses {
+                collector.reg_fixed_use(vreg, *preg);
             }
-            let mut clobbers = info.clobbers.clone();
+            let mut clobbers = *clobbers;
             clobbers.add(link.to_reg().to_real_reg().unwrap().into());
+            for CallRetPair { vreg, preg } in defs {
+                clobbers.remove(PReg::from(preg.to_real_reg().unwrap()));
+                collector.reg_fixed_def(vreg, *preg);
+            }
             collector.reg_clobbers(clobbers);
         }
-        &Inst::CallInd { link, ref info } => {
-            collector.reg_use(info.rn);
-            for u in &info.uses {
-                collector.reg_fixed_use(u.vreg, u.preg);
+        Inst::ReturnCall { info } => {
+            let ReturnCallInfo { uses, .. } = &mut **info;
+            for CallArgPair { vreg, preg } in uses {
+                collector.reg_fixed_use(vreg, *preg);
             }
-            for d in &info.defs {
-                collector.reg_fixed_def(d.vreg, d.preg);
+        }
+        Inst::ReturnCallInd { info } => {
+            let ReturnCallIndInfo { rn, uses, .. } = &mut **info;
+            collector.reg_use(rn);
+            for CallArgPair { vreg, preg } in uses {
+                collector.reg_fixed_use(vreg, *preg);
             }
-            let mut clobbers = info.clobbers.clone();
-            clobbers.add(link.to_reg().to_real_reg().unwrap().into());
-            collector.reg_clobbers(clobbers);
         }
-        &Inst::Args { ref args } => {
-            for arg in args {
-                collector.reg_fixed_def(arg.vreg, arg.preg);
+        Inst::Args { args } => {
+            for ArgPair { vreg, preg } in args {
+                collector.reg_fixed_def(vreg, *preg);
             }
         }
-        &Inst::Rets { ref rets } => {
-            for ret in rets {
-                collector.reg_fixed_use(ret.vreg, ret.preg);
+        Inst::Rets { rets } => {
+            for RetPair { vreg, preg } in rets {
+                collector.reg_fixed_use(vreg, *preg);
             }
         }
-        &Inst::Ret { .. } => {
+        Inst::Ret { .. } => {
             // NOTE: we explicitly don't mark the link register as used here, as the use is only in
             // the epilog where callee-save registers are restored.
         }
-        &Inst::Jump { .. } => {}
-        &Inst::IndirectBr { rn, .. } => {
+        Inst::Jump { .. } => {}
+        Inst::IndirectBr { rn, .. } => {
             collector.reg_use(rn);
         }
-        &Inst::CondBr { .. } | &Inst::OneWayCondBr { .. } => {}
-        &Inst::Nop0 | Inst::Nop2 => {}
-        &Inst::Debugtrap => {}
-        &Inst::Trap { .. } => {}
-        &Inst::TrapIf { .. } => {}
-        &Inst::JTSequence { ridx, .. } => {
+        Inst::CondBr { .. } | Inst::OneWayCondBr { .. } => {}
+        Inst::Nop0 | Inst::Nop2 => {}
+        Inst::Debugtrap => {}
+        Inst::Trap { .. } => {}
+        Inst::TrapIf { .. } => {}
+        Inst::JTSequence { ridx, .. } => {
             collector.reg_use(ridx);
-            collector.reg_early_def(writable_gpr(1));
+            collector.reg_fixed_nonallocatable(gpr_preg(1));
         }
-        &Inst::LoadSymbolReloc { rd, .. } => {
+        Inst::LoadSymbolReloc { rd, .. } => {
             collector.reg_def(rd);
-            collector.reg_def(writable_gpr(1));
+            collector.reg_fixed_nonallocatable(gpr_preg(1));
         }
-        &Inst::LoadAddr { rd, ref mem } => {
+        Inst::LoadAddr { rd, mem } => {
             collector.reg_def(rd);
             memarg_operands(mem, collector);
         }
-        &Inst::Loop { ref body, .. } => {
-            for inst in body.iter() {
-                s390x_get_operands(inst, collector);
-            }
-
+        Inst::Loop { body, .. } => {
             // `reuse_def` constraints can't be permitted in a Loop instruction because the operand
             // index will always be relative to the Loop instruction, not the individual
             // instruction in the loop body. However, fixed-nonallocatable registers used with
             // instructions that would have emitted `reuse_def` constraints are fine.
-            debug_assert!(collector.no_reuse_def());
+            let mut collector = DenyReuseVisitor {
+                inner: collector.inner,
+                deny_reuse: true,
+            };
+            for inst in body {
+                s390x_get_operands(inst, &mut collector);
+            }
         }
-        &Inst::CondBreak { .. } => {}
-        &Inst::VirtualSPOffsetAdj { .. } => {}
-        &Inst::Unwind { .. } => {}
-        &Inst::DummyUse { reg } => {
+        Inst::CondBreak { .. } => {}
+        Inst::Unwind { .. } => {}
+        Inst::DummyUse { reg } => {
             collector.reg_use(reg);
         }
     }
 }
 
+struct DenyReuseVisitor<'a, T> {
+    inner: &'a mut T,
+    deny_reuse: bool,
+}
+
+impl<T: OperandVisitor> OperandVisitor for DenyReuseVisitor<'_, T> {
+    fn add_operand(
+        &mut self,
+        reg: &mut Reg,
+        constraint: regalloc2::OperandConstraint,
+        kind: regalloc2::OperandKind,
+        pos: regalloc2::OperandPos,
+    ) {
+        debug_assert!(
+            !self.deny_reuse || !matches!(constraint, regalloc2::OperandConstraint::Reuse(_))
+        );
+        self.inner.add_operand(reg, constraint, kind, pos);
+    }
+
+    fn debug_assert_is_allocatable_preg(&self, reg: regalloc2::PReg, expected: bool) {
+        self.inner.debug_assert_is_allocatable_preg(reg, expected);
+    }
+
+    fn reg_clobbers(&mut self, regs: PRegSet) {
+        self.inner.reg_clobbers(regs);
+    }
+}
+
 //=============================================================================
 // Instructions: misc functions and external interface
 
@@ -1004,8 +1051,14 @@ impl MachInst for Inst {
     type LabelUse = LabelUse;
     const TRAP_OPCODE: &'static [u8] = &[0, 0];
 
-    fn get_operands<F: Fn(VReg) -> VReg>(&self, collector: &mut OperandCollector<'_, F>) {
-        s390x_get_operands(self, collector);
+    fn get_operands(&mut self, collector: &mut impl OperandVisitor) {
+        s390x_get_operands(
+            self,
+            &mut DenyReuseVisitor {
+                inner: collector,
+                deny_reuse: false,
+            },
+        );
     }
 
     fn is_move(&self) -> Option<(Writable<Reg>, Reg)> {
@@ -1052,6 +1105,7 @@ impl MachInst for Inst {
     fn is_term(&self) -> MachTerminator {
         match self {
             &Inst::Rets { .. } => MachTerminator::Ret,
+            &Inst::ReturnCall { .. } | &Inst::ReturnCallInd { .. } => MachTerminator::RetCall,
             &Inst::Jump { .. } => MachTerminator::Uncond,
             &Inst::CondBr { .. } => MachTerminator::Cond,
             &Inst::OneWayCondBr { .. } => {
@@ -1064,15 +1118,13 @@ impl MachInst for Inst {
         }
     }
 
+    fn is_mem_access(&self) -> bool {
+        panic!("TODO FILL ME OUT")
+    }
+
     fn is_safepoint(&self) -> bool {
         match self {
-            &Inst::Call { .. }
-            | &Inst::CallInd { .. }
-            | &Inst::Trap { .. }
-            | Inst::TrapIf { .. }
-            | &Inst::CmpTrapRR { .. }
-            | &Inst::CmpTrapRSImm16 { .. }
-            | &Inst::CmpTrapRUImm16 { .. } => true,
+            Inst::Call { .. } | Inst::CallInd { .. } => true,
             _ => false,
         }
     }
@@ -1104,15 +1156,12 @@ impl MachInst for Inst {
             types::I16 => Ok((&[RegClass::Int], &[types::I16])),
             types::I32 => Ok((&[RegClass::Int], &[types::I32])),
             types::I64 => Ok((&[RegClass::Int], &[types::I64])),
-            types::R32 => panic!("32-bit reftype pointer should never be seen on s390x"),
-            types::R64 => Ok((&[RegClass::Int], &[types::R64])),
             types::F32 => Ok((&[RegClass::Float], &[types::F32])),
             types::F64 => Ok((&[RegClass::Float], &[types::F64])),
             types::I128 => Ok((&[RegClass::Float], &[types::I128])),
             _ if ty.is_vector() && ty.bits() == 128 => Ok((&[RegClass::Float], &[types::I8X16])),
             _ => Err(CodegenError::Unsupported(format!(
-                "Unexpected SSA-value type: {}",
-                ty
+                "Unexpected SSA-value type: {ty}"
             ))),
         }
     }
@@ -1163,9 +1212,7 @@ fn mem_finalize_for_show(mem: &MemArg, state: &EmitState, mi: MemInstType) -> (S
     let (mem_insts, mem) = mem_finalize(mem, state, mi);
     let mut mem_str = mem_insts
         .into_iter()
-        .map(|inst| {
-            inst.print_with_state(&mut EmitState::default(), &mut AllocationConsumer::new(&[]))
-        })
+        .map(|inst| inst.print_with_state(&mut EmitState::default()))
         .collect::<Vec<_>>()
         .join(" ; ");
     if !mem_str.is_empty() {
@@ -1176,24 +1223,11 @@ fn mem_finalize_for_show(mem: &MemArg, state: &EmitState, mi: MemInstType) -> (S
 }
 
 impl Inst {
-    fn print_with_state(
-        &self,
-        state: &mut EmitState,
-        allocs: &mut AllocationConsumer<'_>,
-    ) -> String {
-        // N.B.: order of consumption of `allocs` must match the order
-        // in `s390x_get_operands()`.
-
-        let mut empty_allocs = AllocationConsumer::new(&[]);
-
+    fn print_with_state(&self, state: &mut EmitState) -> String {
         match self {
             &Inst::Nop0 => "nop-zero-len".to_string(),
             &Inst::Nop2 => "nop".to_string(),
             &Inst::AluRRR { alu_op, rd, rn, rm } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-                let rm = allocs.next(rm);
-
                 let (op, have_rr) = match alu_op {
                     ALUOp::Add32 => ("ark", true),
                     ALUOp::Add64 => ("agrk", true),
@@ -1230,12 +1264,12 @@ impl Inst {
                         ri: rd.to_reg(),
                         rm,
                     };
-                    return inst.print_with_state(state, &mut empty_allocs);
+                    return inst.print_with_state(state);
                 }
-                let rd = pretty_print_reg(rd.to_reg(), &mut empty_allocs);
-                let rn = pretty_print_reg(rn, &mut empty_allocs);
-                let rm = pretty_print_reg(rm, &mut empty_allocs);
-                format!("{} {}, {}, {}", op, rd, rn, rm)
+                let rd = pretty_print_reg(rd.to_reg());
+                let rn = pretty_print_reg(rn);
+                let rm = pretty_print_reg(rm);
+                format!("{op} {rd}, {rn}, {rm}")
             }
             &Inst::AluRRSImm16 {
                 alu_op,
@@ -1243,9 +1277,6 @@ impl Inst {
                 rn,
                 imm,
             } => {
-                let rd = allocs.next_writable(rd);
-                let rn = allocs.next(rn);
-
                 if rd.to_reg() == rn {
                     let inst = Inst::AluRSImm16 {
                         alu_op,
@@ -1253,16 +1284,16 @@ impl Inst {
                         ri: rd.to_reg(),
                         imm,
                     };
-                    return inst.print_with_state(state, &mut empty_allocs);
+                    return inst.print_with_state(state);
                 }
                 let op = match alu_op {
                     ALUOp::Add32 => "ahik",
                     ALUOp::Add64 => "aghik",
                     _ => unreachable!(),
                 };
-                let rd = pretty_print_reg(rd.to_reg(), &mut empty_allocs);
-                let rn = pretty_print_reg(rn, &mut empty_allocs);
-                format!("{} {}, {}, {}", op, rd, rn, imm)
+                let rd = pretty_print_reg(rd.to_reg());
+                let rn = pretty_print_reg(rn);
+                format!("{op} {rd}, {rn}, {imm}")
             }
             &Inst::AluRR { alu_op, rd, ri, rm } => {
                 let op = match alu_op {
@@ -1289,9 +1320,9 @@ impl Inst {
                     ALUOp::Xor64 => "xgr",
                     _ => unreachable!(),
                 };
-                let rd = pretty_print_reg_mod(rd, ri, allocs);
-                let rm = pretty_print_reg(rm, allocs);
-                format!("{} {}, {}", op, rd, rm)
+                let rd = pretty_print_reg_mod(rd, ri);
+                let rm = pretty_print_reg(rm);
+                format!("{op} {rd}, {rm}")
             }
             &Inst::AluRX {
                 alu_op,
@@ -1330,8 +1361,8 @@ impl Inst {
                     _ => unreachable!(),
                 };
 
-                let rd = pretty_print_reg_mod(rd, ri, allocs);
-                let mem = mem.with_allocs(allocs);
+                let rd = pretty_print_reg_mod(rd, ri);
+                let mem = mem.clone();
                 let (mem_str, mem) = mem_finalize_for_show(
                     &mem,
                     state,
@@ -1365,8 +1396,8 @@ impl Inst {
                     ALUOp::Mul64 => "mghi",
                     _ => unreachable!(),
                 };
-                let rd = pretty_print_reg_mod(rd, ri, allocs);
-                format!("{} {}, {}", op, rd, imm)
+                let rd = pretty_print_reg_mod(rd, ri);
+                format!("{op} {rd}, {imm}")
             }
             &Inst::AluRSImm32 {
                 alu_op,
@@ -1381,8 +1412,8 @@ impl Inst {
                     ALUOp::Mul64 => "msgfi",
                     _ => unreachable!(),
                 };
-                let rd = pretty_print_reg_mod(rd, ri, allocs);
-                format!("{} {}, {}", op, rd, imm)
+                let rd = pretty_print_reg_mod(rd, ri);
+                format!("{op} {rd}, {imm}")
             }
             &Inst::AluRUImm32 {
                 alu_op,
@@ -1397,8 +1428,8 @@ impl Inst {
                     ALUOp::SubLogical64 => "slgfi",
                     _ => unreachable!(),
                 };
-                let rd = pretty_print_reg_mod(rd, ri, allocs);
-                format!("{} {}, {}", op, rd, imm)
+                let rd = pretty_print_reg_mod(rd, ri);
+                format!("{op} {rd}, {imm}")
             }
             &Inst::AluRUImm16Shifted {
                 alu_op,
@@ -1421,7 +1452,7 @@ impl Inst {
                     (ALUOp::Orr64, 3) => "oihh",
                     _ => unreachable!(),
                 };
-                let rd = pretty_print_reg_mod(rd, ri, allocs);
+                let rd = pretty_print_reg_mod(rd, ri);
                 format!("{} {}, {}", op, rd, imm.bits)
             }
             &Inst::AluRUImm32Shifted {
@@ -1442,51 +1473,51 @@ impl Inst {
                     (ALUOp::Xor64, 1) => "xihf",
                     _ => unreachable!(),
                 };
-                let rd = pretty_print_reg_mod(rd, ri, allocs);
+                let rd = pretty_print_reg_mod(rd, ri);
                 format!("{} {}, {}", op, rd, imm.bits)
             }
             &Inst::SMulWide { rd, rn, rm } => {
                 let op = "mgrk";
-                let rn = pretty_print_reg(rn, allocs);
-                let rm = pretty_print_reg(rm, allocs);
-                let rd = pretty_print_regpair(rd.to_regpair(), allocs);
-                format!("{} {}, {}, {}", op, rd, rn, rm)
+                let rn = pretty_print_reg(rn);
+                let rm = pretty_print_reg(rm);
+                let rd = pretty_print_regpair(rd.to_regpair());
+                format!("{op} {rd}, {rn}, {rm}")
             }
             &Inst::UMulWide { rd, ri, rn } => {
                 let op = "mlgr";
-                let rn = pretty_print_reg(rn, allocs);
-                let rd = pretty_print_regpair_mod_lo(rd, ri, allocs);
-                format!("{} {}, {}", op, rd, rn)
+                let rn = pretty_print_reg(rn);
+                let rd = pretty_print_regpair_mod_lo(rd, ri);
+                format!("{op} {rd}, {rn}")
             }
             &Inst::SDivMod32 { rd, ri, rn } => {
                 let op = "dsgfr";
-                let rn = pretty_print_reg(rn, allocs);
-                let rd = pretty_print_regpair_mod_lo(rd, ri, allocs);
-                format!("{} {}, {}", op, rd, rn)
+                let rn = pretty_print_reg(rn);
+                let rd = pretty_print_regpair_mod_lo(rd, ri);
+                format!("{op} {rd}, {rn}")
             }
             &Inst::SDivMod64 { rd, ri, rn } => {
                 let op = "dsgr";
-                let rn = pretty_print_reg(rn, allocs);
-                let rd = pretty_print_regpair_mod_lo(rd, ri, allocs);
-                format!("{} {}, {}", op, rd, rn)
+                let rn = pretty_print_reg(rn);
+                let rd = pretty_print_regpair_mod_lo(rd, ri);
+                format!("{op} {rd}, {rn}")
             }
             &Inst::UDivMod32 { rd, ri, rn } => {
                 let op = "dlr";
-                let rn = pretty_print_reg(rn, allocs);
-                let rd = pretty_print_regpair_mod(rd, ri, allocs);
-                format!("{} {}, {}", op, rd, rn)
+                let rn = pretty_print_reg(rn);
+                let rd = pretty_print_regpair_mod(rd, ri);
+                format!("{op} {rd}, {rn}")
             }
             &Inst::UDivMod64 { rd, ri, rn } => {
                 let op = "dlgr";
-                let rn = pretty_print_reg(rn, allocs);
-                let rd = pretty_print_regpair_mod(rd, ri, allocs);
-                format!("{} {}, {}", op, rd, rn)
+                let rn = pretty_print_reg(rn);
+                let rd = pretty_print_regpair_mod(rd, ri);
+                format!("{op} {rd}, {rn}")
             }
             &Inst::Flogr { rd, rn } => {
                 let op = "flogr";
-                let rn = pretty_print_reg(rn, allocs);
-                let rd = pretty_print_regpair(rd.to_regpair(), allocs);
-                format!("{} {}, {}", op, rd, rn)
+                let rn = pretty_print_reg(rn);
+                let rd = pretty_print_regpair(rd.to_regpair());
+                format!("{op} {rd}, {rn}")
             }
             &Inst::ShiftRR {
                 shift_op,
@@ -1505,14 +1536,14 @@ impl Inst {
                     ShiftOp::AShR32 => "srak",
                     ShiftOp::AShR64 => "srag",
                 };
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                let rn = pretty_print_reg(rn, allocs);
+                let rd = pretty_print_reg(rd.to_reg());
+                let rn = pretty_print_reg(rn);
                 let shift_reg = if shift_reg != zero_reg() {
-                    format!("({})", pretty_print_reg(shift_reg, allocs))
+                    format!("({})", pretty_print_reg(shift_reg))
                 } else {
                     "".to_string()
                 };
-                format!("{} {}, {}, {}{}", op, rd, rn, shift_imm, shift_reg)
+                format!("{op} {rd}, {rn}, {shift_imm}{shift_reg}")
             }
             &Inst::RxSBG {
                 op,
@@ -1529,8 +1560,8 @@ impl Inst {
                     RxSBGOp::Or => "rosbg",
                     RxSBGOp::Xor => "rxsbg",
                 };
-                let rd = pretty_print_reg_mod(rd, ri, allocs);
-                let rn = pretty_print_reg(rn, allocs);
+                let rd = pretty_print_reg_mod(rd, ri);
+                let rn = pretty_print_reg(rn);
                 format!(
                     "{} {}, {}, {}, {}, {}",
                     op,
@@ -1555,8 +1586,8 @@ impl Inst {
                     RxSBGOp::Xor => "rxsbg",
                     _ => unreachable!(),
                 };
-                let rd = pretty_print_reg(rd, allocs);
-                let rn = pretty_print_reg(rn, allocs);
+                let rd = pretty_print_reg(rd);
+                let rn = pretty_print_reg(rn);
                 format!(
                     "{} {}, {}, {}, {}, {}",
                     op,
@@ -1580,9 +1611,9 @@ impl Inst {
                     UnaryOp::BSwap32 => ("lrvr", ""),
                     UnaryOp::BSwap64 => ("lrvgr", ""),
                 };
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                let rn = pretty_print_reg(rn, allocs);
-                format!("{} {}, {}{}", op, rd, rn, extra)
+                let rd = pretty_print_reg(rd.to_reg());
+                let rn = pretty_print_reg(rn);
+                format!("{op} {rd}, {rn}{extra}")
             }
             &Inst::CmpRR { op, rn, rm } => {
                 let op = match op {
@@ -1594,9 +1625,9 @@ impl Inst {
                     CmpOp::CmpL64Ext32 => "clgfr",
                     _ => unreachable!(),
                 };
-                let rn = pretty_print_reg(rn, allocs);
-                let rm = pretty_print_reg(rm, allocs);
-                format!("{} {}, {}", op, rn, rm)
+                let rn = pretty_print_reg(rn);
+                let rm = pretty_print_reg(rm);
+                format!("{op} {rn}, {rm}")
             }
             &Inst::CmpRX { op, rn, ref mem } => {
                 let (opcode_rx, opcode_rxy, opcode_ril) = match op {
@@ -1612,8 +1643,8 @@ impl Inst {
                     CmpOp::CmpL64Ext32 => (None, Some("clgf"), Some("clgfrl")),
                 };
 
-                let rn = pretty_print_reg(rn, allocs);
-                let mem = mem.with_allocs(allocs);
+                let rn = pretty_print_reg(rn);
+                let mem = mem.clone();
                 let (mem_str, mem) = mem_finalize_for_show(
                     &mem,
                     state,
@@ -1641,8 +1672,8 @@ impl Inst {
                     CmpOp::CmpS64 => "cghi",
                     _ => unreachable!(),
                 };
-                let rn = pretty_print_reg(rn, allocs);
-                format!("{} {}, {}", op, rn, imm)
+                let rn = pretty_print_reg(rn);
+                format!("{op} {rn}, {imm}")
             }
             &Inst::CmpRSImm32 { op, rn, imm } => {
                 let op = match op {
@@ -1650,8 +1681,8 @@ impl Inst {
                     CmpOp::CmpS64 => "cgfi",
                     _ => unreachable!(),
                 };
-                let rn = pretty_print_reg(rn, allocs);
-                format!("{} {}, {}", op, rn, imm)
+                let rn = pretty_print_reg(rn);
+                format!("{op} {rn}, {imm}")
             }
             &Inst::CmpRUImm32 { op, rn, imm } => {
                 let op = match op {
@@ -1659,8 +1690,8 @@ impl Inst {
                     CmpOp::CmpL64 => "clgfi",
                     _ => unreachable!(),
                 };
-                let rn = pretty_print_reg(rn, allocs);
-                format!("{} {}, {}", op, rn, imm)
+                let rn = pretty_print_reg(rn);
+                format!("{op} {rn}, {imm}")
             }
             &Inst::CmpTrapRR {
                 op, rn, rm, cond, ..
@@ -1672,10 +1703,10 @@ impl Inst {
                     CmpOp::CmpL64 => "clgrt",
                     _ => unreachable!(),
                 };
-                let rn = pretty_print_reg(rn, allocs);
-                let rm = pretty_print_reg(rm, allocs);
+                let rn = pretty_print_reg(rn);
+                let rm = pretty_print_reg(rm);
                 let cond = cond.pretty_print_default();
-                format!("{}{} {}, {}", op, cond, rn, rm)
+                format!("{op}{cond} {rn}, {rm}")
             }
             &Inst::CmpTrapRSImm16 {
                 op, rn, imm, cond, ..
@@ -1685,9 +1716,9 @@ impl Inst {
                     CmpOp::CmpS64 => "cgit",
                     _ => unreachable!(),
                 };
-                let rn = pretty_print_reg(rn, allocs);
+                let rn = pretty_print_reg(rn);
                 let cond = cond.pretty_print_default();
-                format!("{}{} {}, {}", op, cond, rn, imm)
+                format!("{op}{cond} {rn}, {imm}")
             }
             &Inst::CmpTrapRUImm16 {
                 op, rn, imm, cond, ..
@@ -1697,9 +1728,9 @@ impl Inst {
                     CmpOp::CmpL64 => "clgit",
                     _ => unreachable!(),
                 };
-                let rn = pretty_print_reg(rn, allocs);
+                let rn = pretty_print_reg(rn);
                 let cond = cond.pretty_print_default();
-                format!("{}{} {}, {}", op, cond, rn, imm)
+                format!("{op}{cond} {rn}, {imm}")
             }
             &Inst::AtomicRmw {
                 alu_op,
@@ -1721,9 +1752,9 @@ impl Inst {
                     _ => unreachable!(),
                 };
 
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                let rn = pretty_print_reg(rn, allocs);
-                let mem = mem.with_allocs(allocs);
+                let rd = pretty_print_reg(rd.to_reg());
+                let rn = pretty_print_reg(rn);
+                let mem = mem.clone();
                 let (mem_str, mem) = mem_finalize_for_show(
                     &mem,
                     state,
@@ -1736,7 +1767,7 @@ impl Inst {
                     },
                 );
                 let mem = mem.pretty_print_default();
-                format!("{}{} {}, {}, {}", mem_str, op, rd, rn, mem)
+                format!("{mem_str}{op} {rd}, {rn}, {mem}")
             }
             &Inst::AtomicCas32 {
                 rd,
@@ -1756,9 +1787,9 @@ impl Inst {
                     _ => unreachable!(),
                 };
 
-                let rd = pretty_print_reg_mod(rd, ri, allocs);
-                let rn = pretty_print_reg(rn, allocs);
-                let mem = mem.with_allocs(allocs);
+                let rd = pretty_print_reg_mod(rd, ri);
+                let rn = pretty_print_reg(rn);
+                let mem = mem.clone();
                 let (mem_str, mem) = mem_finalize_for_show(
                     &mem,
                     state,
@@ -1814,8 +1845,8 @@ impl Inst {
                     _ => unreachable!(),
                 };
 
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                let mem = mem.with_allocs(allocs);
+                let rd = pretty_print_reg(rd.to_reg());
+                let mem = mem.clone();
                 let (mem_str, mem) = mem_finalize_for_show(
                     &mem,
                     state,
@@ -1854,8 +1885,8 @@ impl Inst {
                     _ => unreachable!(),
                 };
 
-                let rd = pretty_print_reg(rd, allocs);
-                let mem = mem.with_allocs(allocs);
+                let rd = pretty_print_reg(rd);
+                let mem = mem.clone();
                 let (mem_str, mem) = mem_finalize_for_show(
                     &mem,
                     state,
@@ -1878,7 +1909,7 @@ impl Inst {
                 format!("{}{} {}, {}", mem_str, op.unwrap(), rd, mem)
             }
             &Inst::StoreImm8 { imm, ref mem } => {
-                let mem = mem.with_allocs(allocs);
+                let mem = mem.clone();
                 let (mem_str, mem) = mem_finalize_for_show(
                     &mem,
                     state,
@@ -1897,12 +1928,12 @@ impl Inst {
                 };
                 let mem = mem.pretty_print_default();
 
-                format!("{}{} {}, {}", mem_str, op, mem, imm)
+                format!("{mem_str}{op} {mem}, {imm}")
             }
             &Inst::StoreImm16 { imm, ref mem }
             | &Inst::StoreImm32SExt16 { imm, ref mem }
             | &Inst::StoreImm64SExt16 { imm, ref mem } => {
-                let mem = mem.with_allocs(allocs);
+                let mem = mem.clone();
                 let (mem_str, mem) = mem_finalize_for_show(
                     &mem,
                     state,
@@ -1922,15 +1953,15 @@ impl Inst {
                 };
                 let mem = mem.pretty_print_default();
 
-                format!("{}{} {}, {}", mem_str, op, mem, imm)
+                format!("{mem_str}{op} {mem}, {imm}")
             }
             &Inst::Mvc {
                 ref dst,
                 ref src,
                 len_minus_one,
             } => {
-                let dst = dst.with_allocs(allocs);
-                let src = src.with_allocs(allocs);
+                let dst = dst.clone();
+                let src = src.clone();
                 format!(
                     "mvc {}({},{}), {}({})",
                     dst.disp.pretty_print_default(),
@@ -1941,7 +1972,7 @@ impl Inst {
                 )
             }
             &Inst::LoadMultiple64 { rt, rt2, ref mem } => {
-                let mem = mem.with_allocs(allocs);
+                let mem = mem.clone();
                 let (mem_str, mem) = mem_finalize_for_show(
                     &mem,
                     state,
@@ -1953,13 +1984,13 @@ impl Inst {
                         have_index: false,
                     },
                 );
-                let rt = pretty_print_reg(rt.to_reg(), &mut empty_allocs);
-                let rt2 = pretty_print_reg(rt2.to_reg(), &mut empty_allocs);
+                let rt = pretty_print_reg(rt.to_reg());
+                let rt2 = pretty_print_reg(rt2.to_reg());
                 let mem = mem.pretty_print_default();
-                format!("{}lmg {}, {}, {}", mem_str, rt, rt2, mem)
+                format!("{mem_str}lmg {rt}, {rt2}, {mem}")
             }
             &Inst::StoreMultiple64 { rt, rt2, ref mem } => {
-                let mem = mem.with_allocs(allocs);
+                let mem = mem.clone();
                 let (mem_str, mem) = mem_finalize_for_show(
                     &mem,
                     state,
@@ -1971,44 +2002,44 @@ impl Inst {
                         have_index: false,
                     },
                 );
-                let rt = pretty_print_reg(rt, &mut empty_allocs);
-                let rt2 = pretty_print_reg(rt2, &mut empty_allocs);
+                let rt = pretty_print_reg(rt);
+                let rt2 = pretty_print_reg(rt2);
                 let mem = mem.pretty_print_default();
-                format!("{}stmg {}, {}, {}", mem_str, rt, rt2, mem)
+                format!("{mem_str}stmg {rt}, {rt2}, {mem}")
             }
             &Inst::Mov64 { rd, rm } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                let rm = pretty_print_reg(rm, allocs);
-                format!("lgr {}, {}", rd, rm)
+                let rd = pretty_print_reg(rd.to_reg());
+                let rm = pretty_print_reg(rm);
+                format!("lgr {rd}, {rm}")
             }
             &Inst::MovPReg { rd, rm } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
+                let rd = pretty_print_reg(rd.to_reg());
                 let rm = show_reg(rm.into());
-                format!("lgr {}, {}", rd, rm)
+                format!("lgr {rd}, {rm}")
             }
             &Inst::Mov32 { rd, rm } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                let rm = pretty_print_reg(rm, allocs);
-                format!("lr {}, {}", rd, rm)
+                let rd = pretty_print_reg(rd.to_reg());
+                let rm = pretty_print_reg(rm);
+                format!("lr {rd}, {rm}")
             }
             &Inst::Mov32Imm { rd, ref imm } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                format!("iilf {}, {}", rd, imm)
+                let rd = pretty_print_reg(rd.to_reg());
+                format!("iilf {rd}, {imm}")
             }
             &Inst::Mov32SImm16 { rd, ref imm } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                format!("lhi {}, {}", rd, imm)
+                let rd = pretty_print_reg(rd.to_reg());
+                format!("lhi {rd}, {imm}")
             }
             &Inst::Mov64SImm16 { rd, ref imm } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                format!("lghi {}, {}", rd, imm)
+                let rd = pretty_print_reg(rd.to_reg());
+                format!("lghi {rd}, {imm}")
             }
             &Inst::Mov64SImm32 { rd, ref imm } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                format!("lgfi {}, {}", rd, imm)
+                let rd = pretty_print_reg(rd.to_reg());
+                format!("lgfi {rd}, {imm}")
             }
             &Inst::Mov64UImm16Shifted { rd, ref imm } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
+                let rd = pretty_print_reg(rd.to_reg());
                 let op = match imm.shift {
                     0 => "llill",
                     1 => "llilh",
@@ -2019,7 +2050,7 @@ impl Inst {
                 format!("{} {}, {}", op, rd, imm.bits)
             }
             &Inst::Mov64UImm32Shifted { rd, ref imm } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
+                let rd = pretty_print_reg(rd.to_reg());
                 let op = match imm.shift {
                     0 => "llilf",
                     1 => "llihf",
@@ -2028,7 +2059,7 @@ impl Inst {
                 format!("{} {}, {}", op, rd, imm.bits)
             }
             &Inst::Insert64UImm16Shifted { rd, ri, ref imm } => {
-                let rd = pretty_print_reg_mod(rd, ri, allocs);
+                let rd = pretty_print_reg_mod(rd, ri);
                 let op = match imm.shift {
                     0 => "iill",
                     1 => "iilh",
@@ -2039,7 +2070,7 @@ impl Inst {
                 format!("{} {}, {}", op, rd, imm.bits)
             }
             &Inst::Insert64UImm32Shifted { rd, ri, ref imm } => {
-                let rd = pretty_print_reg_mod(rd, ri, allocs);
+                let rd = pretty_print_reg_mod(rd, ri);
                 let op = match imm.shift {
                     0 => "iilf",
                     1 => "iihf",
@@ -2048,24 +2079,24 @@ impl Inst {
                 format!("{} {}, {}", op, rd, imm.bits)
             }
             &Inst::LoadAR { rd, ar } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                format!("ear {}, %a{}", rd, ar)
+                let rd = pretty_print_reg(rd.to_reg());
+                format!("ear {rd}, %a{ar}")
             }
             &Inst::InsertAR { rd, ri, ar } => {
-                let rd = pretty_print_reg_mod(rd, ri, allocs);
-                format!("ear {}, %a{}", rd, ar)
+                let rd = pretty_print_reg_mod(rd, ri);
+                format!("ear {rd}, %a{ar}")
             }
             &Inst::CMov32 { rd, cond, ri, rm } => {
-                let rd = pretty_print_reg_mod(rd, ri, allocs);
-                let rm = pretty_print_reg(rm, allocs);
+                let rd = pretty_print_reg_mod(rd, ri);
+                let rm = pretty_print_reg(rm);
                 let cond = cond.pretty_print_default();
-                format!("locr{} {}, {}", cond, rd, rm)
+                format!("locr{cond} {rd}, {rm}")
             }
             &Inst::CMov64 { rd, cond, ri, rm } => {
-                let rd = pretty_print_reg_mod(rd, ri, allocs);
-                let rm = pretty_print_reg(rm, allocs);
+                let rd = pretty_print_reg_mod(rd, ri);
+                let rm = pretty_print_reg(rm);
                 let cond = cond.pretty_print_default();
-                format!("locgr{} {}, {}", cond, rd, rm)
+                format!("locgr{cond} {rd}, {rm}")
             }
             &Inst::CMov32SImm16 {
                 rd,
@@ -2073,9 +2104,9 @@ impl Inst {
                 ri,
                 ref imm,
             } => {
-                let rd = pretty_print_reg_mod(rd, ri, allocs);
+                let rd = pretty_print_reg_mod(rd, ri);
                 let cond = cond.pretty_print_default();
-                format!("lochi{} {}, {}", cond, rd, imm)
+                format!("lochi{cond} {rd}, {imm}")
             }
             &Inst::CMov64SImm16 {
                 rd,
@@ -2083,50 +2114,48 @@ impl Inst {
                 ri,
                 ref imm,
             } => {
-                let rd = pretty_print_reg_mod(rd, ri, allocs);
+                let rd = pretty_print_reg_mod(rd, ri);
                 let cond = cond.pretty_print_default();
-                format!("locghi{} {}, {}", cond, rd, imm)
+                format!("locghi{cond} {rd}, {imm}")
             }
             &Inst::FpuMove32 { rd, rn } => {
-                let (rd, rd_fpr) = pretty_print_fpr(rd.to_reg(), allocs);
-                let (rn, rn_fpr) = pretty_print_fpr(rn, allocs);
+                let (rd, rd_fpr) = pretty_print_fpr(rd.to_reg());
+                let (rn, rn_fpr) = pretty_print_fpr(rn);
                 if rd_fpr.is_some() && rn_fpr.is_some() {
                     format!("ler {}, {}", rd_fpr.unwrap(), rn_fpr.unwrap())
                 } else {
-                    format!("vlr {}, {}", rd, rn)
+                    format!("vlr {rd}, {rn}")
                 }
             }
             &Inst::FpuMove64 { rd, rn } => {
-                let (rd, rd_fpr) = pretty_print_fpr(rd.to_reg(), allocs);
-                let (rn, rn_fpr) = pretty_print_fpr(rn, allocs);
+                let (rd, rd_fpr) = pretty_print_fpr(rd.to_reg());
+                let (rn, rn_fpr) = pretty_print_fpr(rn);
                 if rd_fpr.is_some() && rn_fpr.is_some() {
                     format!("ldr {}, {}", rd_fpr.unwrap(), rn_fpr.unwrap())
                 } else {
-                    format!("vlr {}, {}", rd, rn)
+                    format!("vlr {rd}, {rn}")
                 }
             }
-            &Inst::FpuCMov32 { rd, cond, ri, rm } => {
-                let (rd, rd_fpr) = pretty_print_fpr(rd.to_reg(), allocs);
-                let _ri = allocs.next(ri);
-                let (rm, rm_fpr) = pretty_print_fpr(rm, allocs);
+            &Inst::FpuCMov32 { rd, cond, rm, .. } => {
+                let (rd, rd_fpr) = pretty_print_fpr(rd.to_reg());
+                let (rm, rm_fpr) = pretty_print_fpr(rm);
                 if rd_fpr.is_some() && rm_fpr.is_some() {
                     let cond = cond.invert().pretty_print_default();
                     format!("j{} 6 ; ler {}, {}", cond, rd_fpr.unwrap(), rm_fpr.unwrap())
                 } else {
                     let cond = cond.invert().pretty_print_default();
-                    format!("j{} 10 ; vlr {}, {}", cond, rd, rm)
+                    format!("j{cond} 10 ; vlr {rd}, {rm}")
                 }
             }
-            &Inst::FpuCMov64 { rd, cond, ri, rm } => {
-                let (rd, rd_fpr) = pretty_print_fpr(rd.to_reg(), allocs);
-                let _ri = allocs.next(ri);
-                let (rm, rm_fpr) = pretty_print_fpr(rm, allocs);
+            &Inst::FpuCMov64 { rd, cond, rm, .. } => {
+                let (rd, rd_fpr) = pretty_print_fpr(rd.to_reg());
+                let (rm, rm_fpr) = pretty_print_fpr(rm);
                 if rd_fpr.is_some() && rm_fpr.is_some() {
                     let cond = cond.invert().pretty_print_default();
                     format!("j{} 6 ; ldr {}, {}", cond, rd_fpr.unwrap(), rm_fpr.unwrap())
                 } else {
                     let cond = cond.invert().pretty_print_default();
-                    format!("j{} 10 ; vlr {}, {}", cond, rd, rm)
+                    format!("j{cond} 10 ; vlr {rd}, {rm}")
                 }
             }
             &Inst::FpuRR { fpu_op, rd, rn } => {
@@ -2151,8 +2180,8 @@ impl Inst {
                     FPUOp1::Cvt32x4To64x2 => ("vldeb", None),
                 };
 
-                let (rd, rd_fpr) = pretty_print_fpr(rd.to_reg(), allocs);
-                let (rn, rn_fpr) = pretty_print_fpr(rn, allocs);
+                let (rd, rd_fpr) = pretty_print_fpr(rd.to_reg());
+                let (rn, rn_fpr) = pretty_print_fpr(rn);
                 if op_fpr.is_some() && rd_fpr.is_some() && rn_fpr.is_some() {
                     format!(
                         "{} {}, {}",
@@ -2163,7 +2192,7 @@ impl Inst {
                 } else if op.starts_with('w') {
                     format!("{} {}, {}", op, rd_fpr.unwrap_or(rd), rn_fpr.unwrap_or(rn))
                 } else {
-                    format!("{} {}, {}", op, rd, rn)
+                    format!("{op} {rd}, {rn}")
                 }
             }
             &Inst::FpuRRR { fpu_op, rd, rn, rm } => {
@@ -2202,9 +2231,9 @@ impl Inst {
                     FPUOp2::MinPseudo64x2 => ("vfmindb", ", 3", None),
                 };
 
-                let (rd, rd_fpr) = pretty_print_fpr(rd.to_reg(), allocs);
-                let (rn, rn_fpr) = pretty_print_fpr(rn, allocs);
-                let (rm, rm_fpr) = pretty_print_fpr(rm, allocs);
+                let (rd, rd_fpr) = pretty_print_fpr(rd.to_reg());
+                let (rn, rn_fpr) = pretty_print_fpr(rn);
+                let (rm, rm_fpr) = pretty_print_fpr(rm);
                 if op_fpr.is_some() && rd == rn && rd_fpr.is_some() && rm_fpr.is_some() {
                     format!(
                         "{} {}, {}",
@@ -2222,7 +2251,7 @@ impl Inst {
                         opt_m6
                     )
                 } else {
-                    format!("{} {}, {}, {}{}", op, rd, rn, rm, opt_m6)
+                    format!("{op} {rd}, {rn}, {rm}{opt_m6}")
                 }
             }
             &Inst::FpuRRRR {
@@ -2243,10 +2272,10 @@ impl Inst {
                     FPUOp3::MSub64x2 => ("vfmsdb", None),
                 };
 
-                let (rd, rd_fpr) = pretty_print_fpr(rd.to_reg(), allocs);
-                let (rn, rn_fpr) = pretty_print_fpr(rn, allocs);
-                let (rm, rm_fpr) = pretty_print_fpr(rm, allocs);
-                let (ra, ra_fpr) = pretty_print_fpr(ra, allocs);
+                let (rd, rd_fpr) = pretty_print_fpr(rd.to_reg());
+                let (rn, rn_fpr) = pretty_print_fpr(rn);
+                let (rm, rm_fpr) = pretty_print_fpr(rm);
+                let (ra, ra_fpr) = pretty_print_fpr(ra);
                 if op_fpr.is_some()
                     && rd == ra
                     && rd_fpr.is_some()
@@ -2270,12 +2299,12 @@ impl Inst {
                         ra_fpr.unwrap_or(ra)
                     )
                 } else {
-                    format!("{} {}, {}, {}, {}", op, rd, rn, rm, ra)
+                    format!("{op} {rd}, {rn}, {rm}, {ra}")
                 }
             }
             &Inst::FpuCmp32 { rn, rm } => {
-                let (rn, rn_fpr) = pretty_print_fpr(rn, allocs);
-                let (rm, rm_fpr) = pretty_print_fpr(rm, allocs);
+                let (rn, rn_fpr) = pretty_print_fpr(rn);
+                let (rm, rm_fpr) = pretty_print_fpr(rm);
                 if rn_fpr.is_some() && rm_fpr.is_some() {
                     format!("cebr {}, {}", rn_fpr.unwrap(), rm_fpr.unwrap())
                 } else {
@@ -2283,8 +2312,8 @@ impl Inst {
                 }
             }
             &Inst::FpuCmp64 { rn, rm } => {
-                let (rn, rn_fpr) = pretty_print_fpr(rn, allocs);
-                let (rm, rm_fpr) = pretty_print_fpr(rm, allocs);
+                let (rn, rn_fpr) = pretty_print_fpr(rn);
+                let (rm, rm_fpr) = pretty_print_fpr(rm);
                 if rn_fpr.is_some() && rm_fpr.is_some() {
                     format!("cdbr {}, {}", rn_fpr.unwrap(), rm_fpr.unwrap())
                 } else {
@@ -2292,8 +2321,8 @@ impl Inst {
                 }
             }
             &Inst::LoadFpuConst32 { rd, const_data } => {
-                let (rd, rd_fpr) = pretty_print_fpr(rd.to_reg(), allocs);
-                let tmp = pretty_print_reg(writable_spilltmp_reg().to_reg(), &mut empty_allocs);
+                let (rd, rd_fpr) = pretty_print_fpr(rd.to_reg());
+                let tmp = pretty_print_reg(writable_spilltmp_reg().to_reg());
                 if rd_fpr.is_some() {
                     format!(
                         "bras {}, 8 ; data.f32 {} ; le {}, 0({})",
@@ -2313,8 +2342,8 @@ impl Inst {
                 }
             }
             &Inst::LoadFpuConst64 { rd, const_data } => {
-                let (rd, rd_fpr) = pretty_print_fpr(rd.to_reg(), allocs);
-                let tmp = pretty_print_reg(writable_spilltmp_reg().to_reg(), &mut empty_allocs);
+                let (rd, rd_fpr) = pretty_print_fpr(rd.to_reg());
+                let tmp = pretty_print_reg(writable_spilltmp_reg().to_reg());
                 if rd_fpr.is_some() {
                     format!(
                         "bras {}, 12 ; data.f64 {} ; ld {}, 0({})",
@@ -2368,8 +2397,8 @@ impl Inst {
                     FpuRoundOp::FromUInt64x2 => ("vcdlgb", None),
                 };
 
-                let (rd, rd_fpr) = pretty_print_fpr(rd.to_reg(), allocs);
-                let (rn, rn_fpr) = pretty_print_fpr(rn, allocs);
+                let (rd, rd_fpr) = pretty_print_fpr(rd.to_reg());
+                let (rn, rn_fpr) = pretty_print_fpr(rn);
                 if opcode_fpr.is_some() && rd_fpr.is_some() && rn_fpr.is_some() {
                     format!(
                         "{} {}, {}, {}{}",
@@ -2392,7 +2421,7 @@ impl Inst {
                         mode
                     )
                 } else {
-                    format!("{} {}, {}, 0, {}", opcode, rd, rn, mode)
+                    format!("{opcode} {rd}, {rn}, 0, {mode}")
                 }
             }
             &Inst::VecRRR { op, rd, rn, rm } => {
@@ -2485,10 +2514,10 @@ impl Inst {
                     VecBinaryOp::MergeHigh32x4 => "vmrhf",
                     VecBinaryOp::MergeHigh64x2 => "vmrhg",
                 };
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                let rn = pretty_print_reg(rn, allocs);
-                let rm = pretty_print_reg(rm, allocs);
-                format!("{} {}, {}, {}", op, rd, rn, rm)
+                let rd = pretty_print_reg(rd.to_reg());
+                let rn = pretty_print_reg(rn);
+                let rm = pretty_print_reg(rm);
+                format!("{op} {rd}, {rn}, {rm}")
             }
             &Inst::VecRR { op, rd, rn } => {
                 let op = match op {
@@ -2525,9 +2554,9 @@ impl Inst {
                     VecUnaryOp::UnpackSHigh16x8 => "vuphh",
                     VecUnaryOp::UnpackSHigh32x4 => "vuphf",
                 };
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                let rn = pretty_print_reg(rn, allocs);
-                format!("{} {}, {}", op, rd, rn)
+                let rd = pretty_print_reg(rd.to_reg());
+                let rn = pretty_print_reg(rn);
+                format!("{op} {rd}, {rn}")
             }
             &Inst::VecShiftRR {
                 shift_op,
@@ -2554,28 +2583,28 @@ impl Inst {
                     VecShiftOp::AShR32x4 => "vesraf",
                     VecShiftOp::AShR64x2 => "vesrag",
                 };
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                let rn = pretty_print_reg(rn, allocs);
+                let rd = pretty_print_reg(rd.to_reg());
+                let rn = pretty_print_reg(rn);
                 let shift_reg = if shift_reg != zero_reg() {
-                    format!("({})", pretty_print_reg(shift_reg, allocs))
+                    format!("({})", pretty_print_reg(shift_reg))
                 } else {
                     "".to_string()
                 };
-                format!("{} {}, {}, {}{}", op, rd, rn, shift_imm, shift_reg)
+                format!("{op} {rd}, {rn}, {shift_imm}{shift_reg}")
             }
             &Inst::VecSelect { rd, rn, rm, ra } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                let rn = pretty_print_reg(rn, allocs);
-                let rm = pretty_print_reg(rm, allocs);
-                let ra = pretty_print_reg(ra, allocs);
-                format!("vsel {}, {}, {}, {}", rd, rn, rm, ra)
+                let rd = pretty_print_reg(rd.to_reg());
+                let rn = pretty_print_reg(rn);
+                let rm = pretty_print_reg(rm);
+                let ra = pretty_print_reg(ra);
+                format!("vsel {rd}, {rn}, {rm}, {ra}")
             }
             &Inst::VecPermute { rd, rn, rm, ra } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                let rn = pretty_print_reg(rn, allocs);
-                let rm = pretty_print_reg(rm, allocs);
-                let ra = pretty_print_reg(ra, allocs);
-                format!("vperm {}, {}, {}, {}", rd, rn, rm, ra)
+                let rd = pretty_print_reg(rd.to_reg());
+                let rn = pretty_print_reg(rn);
+                let rm = pretty_print_reg(rm);
+                let ra = pretty_print_reg(ra);
+                format!("vperm {rd}, {rn}, {rm}, {ra}")
             }
             &Inst::VecPermuteDWImm {
                 rd,
@@ -2584,11 +2613,11 @@ impl Inst {
                 idx1,
                 idx2,
             } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                let rn = pretty_print_reg(rn, allocs);
-                let rm = pretty_print_reg(rm, allocs);
+                let rd = pretty_print_reg(rd.to_reg());
+                let rn = pretty_print_reg(rn);
+                let rm = pretty_print_reg(rm);
                 let m4 = (idx1 & 1) * 4 + (idx2 & 1);
-                format!("vpdi {}, {}, {}, {}", rd, rn, rm, m4)
+                format!("vpdi {rd}, {rn}, {rm}, {m4}")
             }
             &Inst::VecIntCmp { op, rd, rn, rm } | &Inst::VecIntCmpS { op, rd, rn, rm } => {
                 let op = match op {
@@ -2610,10 +2639,10 @@ impl Inst {
                     &Inst::VecIntCmpS { .. } => "s",
                     _ => unreachable!(),
                 };
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                let rn = pretty_print_reg(rn, allocs);
-                let rm = pretty_print_reg(rm, allocs);
-                format!("{}{} {}, {}, {}", op, s, rd, rn, rm)
+                let rd = pretty_print_reg(rd.to_reg());
+                let rn = pretty_print_reg(rn);
+                let rm = pretty_print_reg(rm);
+                format!("{op}{s} {rd}, {rn}, {rm}")
             }
             &Inst::VecFloatCmp { op, rd, rn, rm } | &Inst::VecFloatCmpS { op, rd, rn, rm } => {
                 let op = match op {
@@ -2629,10 +2658,10 @@ impl Inst {
                     &Inst::VecFloatCmpS { .. } => "s",
                     _ => unreachable!(),
                 };
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                let rn = pretty_print_reg(rn, allocs);
-                let rm = pretty_print_reg(rm, allocs);
-                format!("{}{} {}, {}, {}", op, s, rd, rn, rm)
+                let rd = pretty_print_reg(rd.to_reg());
+                let rn = pretty_print_reg(rn);
+                let rm = pretty_print_reg(rm);
+                format!("{op}{s} {rd}, {rn}, {rm}")
             }
             &Inst::VecInt128SCmpHi { tmp, rn, rm } | &Inst::VecInt128UCmpHi { tmp, rn, rm } => {
                 let op = match self {
@@ -2640,13 +2669,10 @@ impl Inst {
                     &Inst::VecInt128UCmpHi { .. } => "veclg",
                     _ => unreachable!(),
                 };
-                let tmp = pretty_print_reg(tmp.to_reg(), allocs);
-                let rn = pretty_print_reg(rn, allocs);
-                let rm = pretty_print_reg(rm, allocs);
-                format!(
-                    "{} {}, {} ; jne 10 ; vchlgs {}, {}, {}",
-                    op, rm, rn, tmp, rn, rm
-                )
+                let tmp = pretty_print_reg(tmp.to_reg());
+                let rn = pretty_print_reg(rn);
+                let rm = pretty_print_reg(rm);
+                format!("{op} {rm}, {rn} ; jne 10 ; vchlgs {tmp}, {rn}, {rm}")
             }
             &Inst::VecLoad { rd, ref mem }
             | &Inst::VecLoadRev { rd, ref mem }
@@ -2668,8 +2694,8 @@ impl Inst {
                     _ => unreachable!(),
                 };
 
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                let mem = mem.with_allocs(allocs);
+                let rd = pretty_print_reg(rd.to_reg());
+                let mem = mem.clone();
                 let (mem_str, mem) = mem_finalize_for_show(
                     &mem,
                     state,
@@ -2682,7 +2708,7 @@ impl Inst {
                     },
                 );
                 let mem = mem.pretty_print_default();
-                format!("{}{} {}, {}", mem_str, opcode, rd, mem)
+                format!("{mem_str}{opcode} {rd}, {mem}")
             }
             &Inst::VecStore { rd, ref mem }
             | &Inst::VecStoreRev { rd, ref mem }
@@ -2704,8 +2730,8 @@ impl Inst {
                     _ => unreachable!(),
                 };
 
-                let rd = pretty_print_reg(rd, allocs);
-                let mem = mem.with_allocs(allocs);
+                let rd = pretty_print_reg(rd);
+                let mem = mem.clone();
                 let (mem_str, mem) = mem_finalize_for_show(
                     &mem,
                     state,
@@ -2718,7 +2744,7 @@ impl Inst {
                     },
                 );
                 let mem = mem.pretty_print_default();
-                format!("{}{} {}, {}", mem_str, opcode, rd, mem)
+                format!("{mem_str}{opcode} {rd}, {mem}")
             }
             &Inst::VecLoadReplicate { size, rd, ref mem }
             | &Inst::VecLoadReplicateRev { size, rd, ref mem } => {
@@ -2733,8 +2759,8 @@ impl Inst {
                     _ => unreachable!(),
                 };
 
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                let mem = mem.with_allocs(allocs);
+                let rd = pretty_print_reg(rd.to_reg());
+                let mem = mem.clone();
                 let (mem_str, mem) = mem_finalize_for_show(
                     &mem,
                     state,
@@ -2747,43 +2773,40 @@ impl Inst {
                     },
                 );
                 let mem = mem.pretty_print_default();
-                format!("{}{} {}, {}", mem_str, opcode, rd, mem)
+                format!("{mem_str}{opcode} {rd}, {mem}")
             }
             &Inst::VecMov { rd, rn } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                let rn = pretty_print_reg(rn, allocs);
-                format!("vlr {}, {}", rd, rn)
+                let rd = pretty_print_reg(rd.to_reg());
+                let rn = pretty_print_reg(rn);
+                format!("vlr {rd}, {rn}")
             }
             &Inst::VecCMov { rd, cond, ri, rm } => {
-                let rd = pretty_print_reg_mod(rd, ri, allocs);
-                let rm = pretty_print_reg(rm, allocs);
+                let rd = pretty_print_reg_mod(rd, ri);
+                let rm = pretty_print_reg(rm);
                 let cond = cond.invert().pretty_print_default();
-                format!("j{} 10 ; vlr {}, {}", cond, rd, rm)
+                format!("j{cond} 10 ; vlr {rd}, {rm}")
             }
             &Inst::MovToVec128 { rd, rn, rm } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                let rn = pretty_print_reg(rn, allocs);
-                let rm = pretty_print_reg(rm, allocs);
-                format!("vlvgp {}, {}, {}", rd, rn, rm)
+                let rd = pretty_print_reg(rd.to_reg());
+                let rn = pretty_print_reg(rn);
+                let rm = pretty_print_reg(rm);
+                format!("vlvgp {rd}, {rn}, {rm}")
             }
             &Inst::VecLoadConst { rd, const_data } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                let tmp = pretty_print_reg(writable_spilltmp_reg().to_reg(), &mut empty_allocs);
-                format!(
-                    "bras {}, 20 ; data.u128 0x{:032x} ; vl {}, 0({})",
-                    tmp, const_data, rd, tmp
-                )
+                let rd = pretty_print_reg(rd.to_reg());
+                let tmp = pretty_print_reg(writable_spilltmp_reg().to_reg());
+                format!("bras {tmp}, 20 ; data.u128 0x{const_data:032x} ; vl {rd}, 0({tmp})")
             }
             &Inst::VecLoadConstReplicate {
                 size,
                 rd,
                 const_data,
             } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                let tmp = pretty_print_reg(writable_spilltmp_reg().to_reg(), &mut empty_allocs);
+                let rd = pretty_print_reg(rd.to_reg());
+                let tmp = pretty_print_reg(writable_spilltmp_reg().to_reg());
                 let (opcode, data) = match size {
                     32 => ("vlrepf", format!("0x{:08x}", const_data as u32)),
-                    64 => ("vlrepg", format!("0x{:016x}", const_data)),
+                    64 => ("vlrepg", format!("0x{const_data:016x}")),
                     _ => unreachable!(),
                 };
                 format!(
@@ -2798,8 +2821,8 @@ impl Inst {
                 )
             }
             &Inst::VecImmByteMask { rd, mask } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                format!("vgbm {}, {}", rd, mask)
+                let rd = pretty_print_reg(rd.to_reg());
+                format!("vgbm {rd}, {mask}")
             }
             &Inst::VecImmBitMask {
                 size,
@@ -2807,7 +2830,7 @@ impl Inst {
                 start_bit,
                 end_bit,
             } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
+                let rd = pretty_print_reg(rd.to_reg());
                 let op = match size {
                     8 => "vgmb",
                     16 => "vgmh",
@@ -2815,10 +2838,10 @@ impl Inst {
                     64 => "vgmg",
                     _ => unreachable!(),
                 };
-                format!("{} {}, {}, {}", op, rd, start_bit, end_bit)
+                format!("{op} {rd}, {start_bit}, {end_bit}")
             }
             &Inst::VecImmReplicate { size, rd, imm } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
+                let rd = pretty_print_reg(rd.to_reg());
                 let op = match size {
                     8 => "vrepib",
                     16 => "vrepih",
@@ -2826,21 +2849,21 @@ impl Inst {
                     64 => "vrepig",
                     _ => unreachable!(),
                 };
-                format!("{} {}, {}", op, rd, imm)
+                format!("{op} {rd}, {imm}")
             }
             &Inst::VecLoadLane {
                 size,
                 rd,
-                ri,
                 ref mem,
                 lane_imm,
+                ..
             }
             | &Inst::VecLoadLaneRev {
                 size,
                 rd,
-                ri,
                 ref mem,
                 lane_imm,
+                ..
             } => {
                 let opcode_vrx = match (self, size) {
                     (&Inst::VecLoadLane { .. }, 8) => "vleb",
@@ -2853,9 +2876,8 @@ impl Inst {
                     _ => unreachable!(),
                 };
 
-                let (rd, _) = pretty_print_fpr(rd.to_reg(), allocs);
-                let _ri = allocs.next(ri);
-                let mem = mem.with_allocs(allocs);
+                let (rd, _) = pretty_print_fpr(rd.to_reg());
+                let mem = mem.clone();
                 let (mem_str, mem) = mem_finalize_for_show(
                     &mem,
                     state,
@@ -2868,7 +2890,7 @@ impl Inst {
                     },
                 );
                 let mem = mem.pretty_print_default();
-                format!("{}{} {}, {}, {}", mem_str, opcode_vrx, rd, mem, lane_imm)
+                format!("{mem_str}{opcode_vrx} {rd}, {mem}, {lane_imm}")
             }
             &Inst::VecLoadLaneUndef {
                 size,
@@ -2893,8 +2915,8 @@ impl Inst {
                     _ => unreachable!(),
                 };
 
-                let (rd, rd_fpr) = pretty_print_fpr(rd.to_reg(), allocs);
-                let mem = mem.with_allocs(allocs);
+                let (rd, rd_fpr) = pretty_print_fpr(rd.to_reg());
+                let mem = mem.clone();
                 if lane_imm == 0 && rd_fpr.is_some() && opcode_rx.is_some() {
                     let (mem_str, mem) = mem_finalize_for_show(
                         &mem,
@@ -2927,7 +2949,7 @@ impl Inst {
                         },
                     );
                     let mem = mem.pretty_print_default();
-                    format!("{}{} {}, {}, {}", mem_str, opcode_vrx, rd, mem, lane_imm)
+                    format!("{mem_str}{opcode_vrx} {rd}, {mem}, {lane_imm}")
                 }
             }
             &Inst::VecStoreLane {
@@ -2953,8 +2975,8 @@ impl Inst {
                     _ => unreachable!(),
                 };
 
-                let (rd, rd_fpr) = pretty_print_fpr(rd, allocs);
-                let mem = mem.with_allocs(allocs);
+                let (rd, rd_fpr) = pretty_print_fpr(rd);
+                let mem = mem.clone();
                 if lane_imm == 0 && rd_fpr.is_some() && opcode_rx.is_some() {
                     let (mem_str, mem) = mem_finalize_for_show(
                         &mem,
@@ -2987,7 +3009,7 @@ impl Inst {
                         },
                     );
                     let mem = mem.pretty_print_default();
-                    format!("{}{} {}, {}, {}", mem_str, opcode_vrx, rd, mem, lane_imm,)
+                    format!("{mem_str}{opcode_vrx} {rd}, {mem}, {lane_imm}",)
                 }
             }
             &Inst::VecInsertLane {
@@ -3005,14 +3027,14 @@ impl Inst {
                     64 => "vlvgg",
                     _ => unreachable!(),
                 };
-                let rd = pretty_print_reg_mod(rd, ri, allocs);
-                let rn = pretty_print_reg(rn, allocs);
+                let rd = pretty_print_reg_mod(rd, ri);
+                let rn = pretty_print_reg(rn);
                 let lane_reg = if lane_reg != zero_reg() {
-                    format!("({})", pretty_print_reg(lane_reg, allocs))
+                    format!("({})", pretty_print_reg(lane_reg))
                 } else {
                     "".to_string()
                 };
-                format!("{} {}, {}, {}{}", op, rd, rn, lane_imm, lane_reg)
+                format!("{op} {rd}, {rn}, {lane_imm}{lane_reg}")
             }
             &Inst::VecInsertLaneUndef {
                 size,
@@ -3028,10 +3050,10 @@ impl Inst {
                     64 => ("vlvgg", Some("ldgr")),
                     _ => unreachable!(),
                 };
-                let (rd, rd_fpr) = pretty_print_fpr(rd.to_reg(), allocs);
-                let rn = pretty_print_reg(rn, allocs);
+                let (rd, rd_fpr) = pretty_print_fpr(rd.to_reg());
+                let rn = pretty_print_reg(rn);
                 let lane_reg = if lane_reg != zero_reg() {
-                    format!("({})", pretty_print_reg(lane_reg, allocs))
+                    format!("({})", pretty_print_reg(lane_reg))
                 } else {
                     "".to_string()
                 };
@@ -3039,7 +3061,7 @@ impl Inst {
                 {
                     format!("{} {}, {}", opcode_rre.unwrap(), rd_fpr.unwrap(), rn)
                 } else {
-                    format!("{} {}, {}, {}{}", opcode_vrs, rd, rn, lane_imm, lane_reg)
+                    format!("{opcode_vrs} {rd}, {rn}, {lane_imm}{lane_reg}")
                 }
             }
             &Inst::VecExtractLane {
@@ -3056,10 +3078,10 @@ impl Inst {
                     64 => ("vlgvg", Some("lgdr")),
                     _ => unreachable!(),
                 };
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                let (rn, rn_fpr) = pretty_print_fpr(rn, allocs);
+                let rd = pretty_print_reg(rd.to_reg());
+                let (rn, rn_fpr) = pretty_print_fpr(rn);
                 let lane_reg = if lane_reg != zero_reg() {
-                    format!("({})", pretty_print_reg(lane_reg, allocs))
+                    format!("({})", pretty_print_reg(lane_reg))
                 } else {
                     "".to_string()
                 };
@@ -3067,7 +3089,7 @@ impl Inst {
                 {
                     format!("{} {}, {}", opcode_rre.unwrap(), rd, rn_fpr.unwrap())
                 } else {
-                    format!("{} {}, {}, {}{}", opcode_vrs, rd, rn, lane_imm, lane_reg)
+                    format!("{opcode_vrs} {rd}, {rn}, {lane_imm}{lane_reg}")
                 }
             }
             &Inst::VecInsertLaneImm {
@@ -3084,8 +3106,8 @@ impl Inst {
                     64 => "vleig",
                     _ => unreachable!(),
                 };
-                let rd = pretty_print_reg_mod(rd, ri, allocs);
-                format!("{} {}, {}, {}", op, rd, imm, lane_imm)
+                let rd = pretty_print_reg_mod(rd, ri);
+                format!("{op} {rd}, {imm}, {lane_imm}")
             }
             &Inst::VecReplicateLane {
                 size,
@@ -3100,9 +3122,9 @@ impl Inst {
                     64 => "vrepg",
                     _ => unreachable!(),
                 };
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                let rn = pretty_print_reg(rn, allocs);
-                format!("{} {}, {}, {}", op, rd, rn, lane_imm)
+                let rd = pretty_print_reg(rd.to_reg());
+                let rn = pretty_print_reg(rn);
+                format!("{op} {rd}, {rn}, {lane_imm}")
             }
             &Inst::Extend {
                 rd,
@@ -3111,8 +3133,8 @@ impl Inst {
                 from_bits,
                 to_bits,
             } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                let rn = pretty_print_reg(rn, allocs);
+                let rd = pretty_print_reg(rd.to_reg());
+                let rn = pretty_print_reg(rn);
                 let op = match (signed, from_bits, to_bits) {
                     (_, 1, 32) => "llcr",
                     (_, 1, 64) => "llgcr",
@@ -3126,9 +3148,16 @@ impl Inst {
                     (true, 16, 64) => "lghr",
                     (false, 32, 64) => "llgfr",
                     (true, 32, 64) => "lgfr",
-                    _ => panic!("Unsupported Extend case: {:?}", self),
+                    _ => panic!("Unsupported Extend case: {self:?}"),
                 };
-                format!("{} {}, {}", op, rd, rn)
+                format!("{op} {rd}, {rn}")
+            }
+            &Inst::AllocateArgs { size } => {
+                if let Ok(size) = i16::try_from(size) {
+                    format!("aghi {}, {}", show_reg(stack_reg()), -size)
+                } else {
+                    format!("slgfi {}, {}", show_reg(stack_reg()), size)
+                }
             }
             &Inst::Call { link, ref info, .. } => {
                 let link = link.to_reg();
@@ -3139,35 +3168,63 @@ impl Inst {
                     }
                     _ => unreachable!(),
                 };
+                let callee_pop_size = if info.callee_pop_size > 0 {
+                    format!(" ; callee_pop_size {}", info.callee_pop_size)
+                } else {
+                    "".to_string()
+                };
                 debug_assert_eq!(link, gpr(14));
                 format!(
-                    "brasl {}, {}{}",
+                    "brasl {}, {}{}{}",
                     show_reg(link),
                     info.dest.display(None),
-                    tls_symbol
+                    tls_symbol,
+                    callee_pop_size
                 )
             }
             &Inst::CallInd { link, ref info, .. } => {
                 let link = link.to_reg();
-                let rn = pretty_print_reg(info.rn, allocs);
+                let rn = pretty_print_reg(info.rn);
+                let callee_pop_size = if info.callee_pop_size > 0 {
+                    format!(" ; callee_pop_size {}", info.callee_pop_size)
+                } else {
+                    "".to_string()
+                };
                 debug_assert_eq!(link, gpr(14));
-                format!("basr {}, {}", show_reg(link), rn)
+                format!("basr {}, {}{}", show_reg(link), rn, callee_pop_size)
+            }
+            &Inst::ReturnCall { ref info, .. } => {
+                let callee_pop_size = if info.callee_pop_size > 0 {
+                    format!(" ; callee_pop_size {}", info.callee_pop_size)
+                } else {
+                    "".to_string()
+                };
+                format!("return_call {}{}", info.dest.display(None), callee_pop_size)
+            }
+            &Inst::ReturnCallInd { ref info, .. } => {
+                let rn = pretty_print_reg(info.rn);
+                let callee_pop_size = if info.callee_pop_size > 0 {
+                    format!(" ; callee_pop_size {}", info.callee_pop_size)
+                } else {
+                    "".to_string()
+                };
+                format!("return_call_ind {rn}{callee_pop_size}")
             }
             &Inst::Args { ref args } => {
                 let mut s = "args".to_string();
                 for arg in args {
-                    let preg = pretty_print_reg(arg.preg, &mut empty_allocs);
-                    let def = pretty_print_reg(arg.vreg.to_reg(), allocs);
-                    write!(&mut s, " {}={}", def, preg).unwrap();
+                    let preg = pretty_print_reg(arg.preg);
+                    let def = pretty_print_reg(arg.vreg.to_reg());
+                    write!(&mut s, " {def}={preg}").unwrap();
                 }
                 s
             }
             &Inst::Rets { ref rets } => {
                 let mut s = "rets".to_string();
                 for ret in rets {
-                    let preg = pretty_print_reg(ret.preg, &mut empty_allocs);
-                    let vreg = pretty_print_reg(ret.vreg, allocs);
-                    write!(&mut s, " {}={}", vreg, preg).unwrap();
+                    let preg = pretty_print_reg(ret.preg);
+                    let vreg = pretty_print_reg(ret.vreg);
+                    write!(&mut s, " {vreg}={preg}").unwrap();
                 }
                 s
             }
@@ -3178,11 +3235,11 @@ impl Inst {
             }
             &Inst::Jump { dest } => {
                 let dest = dest.to_string();
-                format!("jg {}", dest)
+                format!("jg {dest}")
             }
             &Inst::IndirectBr { rn, .. } => {
-                let rn = pretty_print_reg(rn, allocs);
-                format!("br {}", rn)
+                let rn = pretty_print_reg(rn);
+                format!("br {rn}")
             }
             &Inst::CondBr {
                 taken,
@@ -3192,24 +3249,24 @@ impl Inst {
                 let taken = taken.to_string();
                 let not_taken = not_taken.to_string();
                 let cond = cond.pretty_print_default();
-                format!("jg{} {} ; jg {}", cond, taken, not_taken)
+                format!("jg{cond} {taken} ; jg {not_taken}")
             }
             &Inst::OneWayCondBr { target, cond } => {
                 let target = target.to_string();
                 let cond = cond.pretty_print_default();
-                format!("jg{} {}", cond, target)
+                format!("jg{cond} {target}")
             }
             &Inst::Debugtrap => ".word 0x0001 # debugtrap".to_string(),
             &Inst::Trap { trap_code } => {
-                format!(".word 0x0000 # trap={}", trap_code)
+                format!(".word 0x0000 # trap={trap_code}")
             }
             &Inst::TrapIf { cond, trap_code } => {
                 let cond = cond.pretty_print_default();
-                format!("jg{} .+2 # trap={}", cond, trap_code)
+                format!("jg{cond} .+2 # trap={trap_code}")
             }
             &Inst::JTSequence { ridx, ref targets } => {
-                let ridx = pretty_print_reg(ridx, allocs);
-                let rtmp = pretty_print_reg(writable_spilltmp_reg().to_reg(), &mut empty_allocs);
+                let ridx = pretty_print_reg(ridx);
+                let rtmp = pretty_print_reg(writable_spilltmp_reg().to_reg());
                 // The first entry is the default target, which is not emitted
                 // into the jump table, so we skip it here.  It is only in the
                 // list so MachTerminator will see the potential target.
@@ -3232,19 +3289,19 @@ impl Inst {
                 rd,
                 ref symbol_reloc,
             } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                let tmp = pretty_print_reg(writable_spilltmp_reg().to_reg(), &mut empty_allocs);
+                let rd = pretty_print_reg(rd.to_reg());
+                let tmp = pretty_print_reg(writable_spilltmp_reg().to_reg());
                 let symbol = match &**symbol_reloc {
                     SymbolReloc::Absolute { name, offset } => {
                         format!("{} + {}", name.display(None), offset)
                     }
                     SymbolReloc::TlsGd { name } => format!("{}@tlsgd", name.display(None)),
                 };
-                format!("bras {}, 12 ; data {} ; lg {}, 0({})", tmp, symbol, rd, tmp)
+                format!("bras {tmp}, 12 ; data {symbol} ; lg {rd}, 0({tmp})")
             }
             &Inst::LoadAddr { rd, ref mem } => {
-                let rd = pretty_print_reg(rd.to_reg(), allocs);
-                let mem = mem.with_allocs(allocs);
+                let rd = pretty_print_reg(rd.to_reg());
+                let mem = mem.clone();
                 let (mem_str, mem) = mem_finalize_for_show(
                     &mem,
                     state,
@@ -3264,31 +3321,27 @@ impl Inst {
                 };
                 let mem = mem.pretty_print_default();
 
-                format!("{}{} {}, {}", mem_str, op, rd, mem)
+                format!("{mem_str}{op} {rd}, {mem}")
             }
             &Inst::Loop { ref body, cond } => {
                 let body = body
                     .into_iter()
-                    .map(|inst| inst.print_with_state(state, allocs))
+                    .map(|inst| inst.print_with_state(state))
                     .collect::<Vec<_>>()
                     .join(" ; ");
                 let cond = cond.pretty_print_default();
-                format!("0: {} ; jg{} 0b ; 1:", body, cond)
+                format!("0: {body} ; jg{cond} 0b ; 1:")
             }
             &Inst::CondBreak { cond } => {
                 let cond = cond.pretty_print_default();
-                format!("jg{} 1f", cond)
-            }
-            &Inst::VirtualSPOffsetAdj { offset } => {
-                state.virtual_sp_offset += offset;
-                format!("virtual_sp_offset_adjust {}", offset)
+                format!("jg{cond} 1f")
             }
             &Inst::Unwind { ref inst } => {
-                format!("unwind {:?}", inst)
+                format!("unwind {inst:?}")
             }
             &Inst::DummyUse { reg } => {
-                let reg = pretty_print_reg(reg, allocs);
-                format!("dummy_use {}", reg)
+                let reg = pretty_print_reg(reg);
+                format!("dummy_use {reg}")
             }
         }
     }
diff --git a/cranelift/codegen/src/isa/s390x/inst/regs.rs b/cranelift/codegen/src/isa/s390x/inst/regs.rs
index 2a18f029e0cf..cbdc628cc555 100644
--- a/cranelift/codegen/src/isa/s390x/inst/regs.rs
+++ b/cranelift/codegen/src/isa/s390x/inst/regs.rs
@@ -2,7 +2,6 @@
 
 use alloc::string::String;
 use regalloc2::PReg;
-use regalloc2::VReg;
 
 use crate::isa::s390x::inst::{RegPair, WritableRegPair};
 use crate::machinst::*;
@@ -12,8 +11,7 @@ use crate::machinst::*;
 
 /// Get a reference to a GPR (integer register).
 pub fn gpr(num: u8) -> Reg {
-    let preg = gpr_preg(num);
-    Reg::from(VReg::new(preg.index(), RegClass::Int))
+    Reg::from(gpr_preg(num))
 }
 
 pub(crate) const fn gpr_preg(num: u8) -> PReg {
@@ -28,8 +26,7 @@ pub fn writable_gpr(num: u8) -> Writable<Reg> {
 
 /// Get a reference to a VR (vector register).
 pub fn vr(num: u8) -> Reg {
-    let preg = vr_preg(num);
-    Reg::from(VReg::new(preg.index(), RegClass::Float))
+    Reg::from(vr_preg(num))
 }
 
 pub(crate) const fn vr_preg(num: u8) -> PReg {
@@ -89,7 +86,7 @@ pub fn show_reg(reg: Reg) -> String {
             RegClass::Vector => unreachable!(),
         }
     } else {
-        format!("%{:?}", reg)
+        format!("%{reg:?}")
     }
 }
 
@@ -102,14 +99,13 @@ pub fn maybe_show_fpr(reg: Reg) -> Option<String> {
     None
 }
 
-pub fn pretty_print_reg(reg: Reg, allocs: &mut AllocationConsumer<'_>) -> String {
-    let reg = allocs.next(reg);
+pub fn pretty_print_reg(reg: Reg) -> String {
     show_reg(reg)
 }
 
-pub fn pretty_print_regpair(pair: RegPair, allocs: &mut AllocationConsumer<'_>) -> String {
-    let hi = allocs.next(pair.hi);
-    let lo = allocs.next(pair.lo);
+pub fn pretty_print_regpair(pair: RegPair) -> String {
+    let hi = pair.hi;
+    let lo = pair.lo;
     if let Some(hi_reg) = hi.to_real_reg() {
         if let Some(lo_reg) = lo.to_real_reg() {
             assert!(
@@ -125,13 +121,9 @@ pub fn pretty_print_regpair(pair: RegPair, allocs: &mut AllocationConsumer<'_>)
     format!("{}/{}", show_reg(hi), show_reg(lo))
 }
 
-pub fn pretty_print_reg_mod(
-    rd: Writable<Reg>,
-    ri: Reg,
-    allocs: &mut AllocationConsumer<'_>,
-) -> String {
-    let output = allocs.next_writable(rd).to_reg();
-    let input = allocs.next(ri);
+pub fn pretty_print_reg_mod(rd: Writable<Reg>, ri: Reg) -> String {
+    let output = rd.to_reg();
+    let input = ri;
     if output == input {
         show_reg(output)
     } else {
@@ -139,15 +131,11 @@ pub fn pretty_print_reg_mod(
     }
 }
 
-pub fn pretty_print_regpair_mod(
-    rd: WritableRegPair,
-    ri: RegPair,
-    allocs: &mut AllocationConsumer<'_>,
-) -> String {
-    let rd_hi = allocs.next(rd.hi.to_reg());
-    let rd_lo = allocs.next(rd.lo.to_reg());
-    let ri_hi = allocs.next(ri.hi);
-    let ri_lo = allocs.next(ri.lo);
+pub fn pretty_print_regpair_mod(rd: WritableRegPair, ri: RegPair) -> String {
+    let rd_hi = rd.hi.to_reg();
+    let rd_lo = rd.lo.to_reg();
+    let ri_hi = ri.hi;
+    let ri_lo = ri.lo;
     if rd_hi == ri_hi {
         show_reg(rd_hi)
     } else {
@@ -161,14 +149,9 @@ pub fn pretty_print_regpair_mod(
     }
 }
 
-pub fn pretty_print_regpair_mod_lo(
-    rd: WritableRegPair,
-    ri: Reg,
-    allocs: &mut AllocationConsumer<'_>,
-) -> String {
-    let rd_hi = allocs.next(rd.hi.to_reg());
-    let rd_lo = allocs.next(rd.lo.to_reg());
-    let ri = allocs.next(ri);
+pub fn pretty_print_regpair_mod_lo(rd: WritableRegPair, ri: Reg) -> String {
+    let rd_hi = rd.hi.to_reg();
+    let rd_lo = rd.lo.to_reg();
     if rd_lo == ri {
         show_reg(rd_hi)
     } else {
@@ -181,7 +164,6 @@ pub fn pretty_print_regpair_mod_lo(
     }
 }
 
-pub fn pretty_print_fpr(reg: Reg, allocs: &mut AllocationConsumer<'_>) -> (String, Option<String>) {
-    let reg = allocs.next(reg);
+pub fn pretty_print_fpr(reg: Reg) -> (String, Option<String>) {
     (show_reg(reg), maybe_show_fpr(reg))
 }
diff --git a/cranelift/codegen/src/isa/s390x/inst/unwind/systemv.rs b/cranelift/codegen/src/isa/s390x/inst/unwind/systemv.rs
index 5f0a657c7212..203fbc759133 100644
--- a/cranelift/codegen/src/isa/s390x/inst/unwind/systemv.rs
+++ b/cranelift/codegen/src/isa/s390x/inst/unwind/systemv.rs
@@ -93,9 +93,6 @@ impl crate::isa::unwind::systemv::RegisterMapper<Reg> for RegisterMapper {
     fn map(&self, reg: Reg) -> Result<u16, RegisterMappingError> {
         Ok(map_reg(reg)?.0)
     }
-    fn sp(&self) -> u16 {
-        Register(15).0
-    }
 }
 
 #[cfg(test)]
@@ -108,7 +105,6 @@ mod tests {
     use crate::settings::{builder, Flags};
     use crate::Context;
     use gimli::write::Address;
-    use std::str::FromStr;
     use target_lexicon::triple;
 
     #[test]
@@ -120,7 +116,7 @@ mod tests {
 
         let mut context = Context::for_function(create_function(
             CallConv::SystemV,
-            Some(StackSlotData::new(StackSlotKind::ExplicitSlot, 64)),
+            Some(StackSlotData::new(StackSlotKind::ExplicitSlot, 64, 0)),
         ));
 
         let code = context
@@ -137,7 +133,7 @@ mod tests {
             _ => panic!("expected unwind information"),
         };
 
-        assert_eq!(format!("{:?}", fde), "FrameDescriptionEntry { address: Constant(1234), length: 10, lsda: None, instructions: [(4, CfaOffset(224))] }");
+        assert_eq!(format!("{fde:?}"), "FrameDescriptionEntry { address: Constant(1234), length: 10, lsda: None, instructions: [(4, CfaOffset(224))] }");
     }
 
     fn create_function(call_conv: CallConv, stack_slot: Option<StackSlotData>) -> Function {
@@ -164,7 +160,7 @@ mod tests {
 
         let mut context = Context::for_function(create_multi_return_function(
             CallConv::SystemV,
-            Some(StackSlotData::new(StackSlotKind::ExplicitSlot, 64)),
+            Some(StackSlotData::new(StackSlotKind::ExplicitSlot, 64, 0)),
         ));
 
         let code = context
@@ -181,7 +177,7 @@ mod tests {
             _ => panic!("expected unwind information"),
         };
 
-        assert_eq!(format!("{:?}", fde), "FrameDescriptionEntry { address: Constant(4321), length: 26, lsda: None, instructions: [(4, CfaOffset(224))] }");
+        assert_eq!(format!("{fde:?}"), "FrameDescriptionEntry { address: Constant(4321), length: 26, lsda: None, instructions: [(4, CfaOffset(224))] }");
     }
 
     fn create_multi_return_function(
diff --git a/cranelift/codegen/src/isa/s390x/lower.isle b/cranelift/codegen/src/isa/s390x/lower.isle
index 6d6aa1e724e4..49fcfe12105e 100644
--- a/cranelift/codegen/src/isa/s390x/lower.isle
+++ b/cranelift/codegen/src/isa/s390x/lower.isle
@@ -12,34 +12,28 @@
 
 ;;;; Rules for `iconst` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type ty (iconst (u64_from_imm64 n))))
+(rule (lower (has_type ty (iconst _ (u64_from_imm64 n))))
       (imm ty n))
 
 
 ;;;; Rules for `f32const` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (f32const (u32_from_ieee32 x)))
+(rule (lower (f32const _ (u32_from_ieee32 x)))
       (imm $F32 x))
 
 
 ;;;; Rules for `f64const` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (f64const (u64_from_ieee64 x)))
+(rule (lower (f64const _ (u64_from_ieee64 x)))
       (imm $F64 x))
 
 
 ;;;; Rules for `vconst` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type ty (vconst (u128_from_constant x))))
+(rule (lower (has_type ty (vconst _ (u128_from_constant x))))
       (vec_imm ty (be_vec_const ty x)))
 
 
-;;;; Rules for `null` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(rule (lower (has_type ty (null)))
-      (imm ty 0))
-
-
 ;;;; Rules for `nop` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (rule (lower (nop))
@@ -48,13 +42,13 @@
 
 ;;;; Rules for `iconcat` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type (vr128_ty ty) (iconcat x y)))
+(rule (lower (has_type (vr128_ty ty) (iconcat _ x y)))
       (mov_to_vec128 ty y x))
 
 
 ;;;; Rules for `isplit` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (isplit x @ (value_type $I128)))
+(rule (lower (isplit _ x @ (value_type $I128)))
       (let ((x_reg Reg x)
             (x_hi Reg (vec_extract_lane $I64X2 x_reg 0 (zero_reg)))
             (x_lo Reg (vec_extract_lane $I64X2 x_reg 1 (zero_reg))))
@@ -64,56 +58,56 @@
 ;;;; Rules for `iadd` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Add two registers.
-(rule 0 (lower (has_type (fits_in_64 ty) (iadd x y)))
+(rule 0 (lower (has_type (fits_in_64 ty) (iadd _ x y)))
       (add_reg ty x y))
 
 ;; Add a register and a sign-extended register.
-(rule 8 (lower (has_type (fits_in_64 ty) (iadd x (sext32_value y))))
+(rule 8 (lower (has_type (fits_in_64 ty) (iadd _ x (sext32_value y))))
       (add_reg_sext32 ty x y))
-(rule 15 (lower (has_type (fits_in_64 ty) (iadd (sext32_value x) y)))
+(rule 15 (lower (has_type (fits_in_64 ty) (iadd _ (sext32_value x) y)))
       (add_reg_sext32 ty y x))
 
 ;; Add a register and an immediate.
-(rule 7 (lower (has_type (fits_in_64 ty) (iadd x (i16_from_value y))))
+(rule 7 (lower (has_type (fits_in_64 ty) (iadd _ x (i16_from_value y))))
       (add_simm16 ty x y))
-(rule 14 (lower (has_type (fits_in_64 ty) (iadd (i16_from_value x) y)))
+(rule 14 (lower (has_type (fits_in_64 ty) (iadd _ (i16_from_value x) y)))
       (add_simm16 ty y x))
-(rule 6 (lower (has_type (fits_in_64 ty) (iadd x (i32_from_value y))))
+(rule 6 (lower (has_type (fits_in_64 ty) (iadd _ x (i32_from_value y))))
       (add_simm32 ty x y))
-(rule 13 (lower (has_type (fits_in_64 ty) (iadd (i32_from_value x) y)))
+(rule 13 (lower (has_type (fits_in_64 ty) (iadd _ (i32_from_value x) y)))
       (add_simm32 ty y x))
 
 ;; Add a register and memory (32/64-bit types).
-(rule 5 (lower (has_type (fits_in_64 ty) (iadd x (sinkable_load_32_64 y))))
+(rule 5 (lower (has_type (fits_in_64 ty) (iadd _ x (sinkable_load_32_64 y))))
       (add_mem ty x (sink_load y)))
-(rule 12 (lower (has_type (fits_in_64 ty) (iadd (sinkable_load_32_64 x) y)))
+(rule 12 (lower (has_type (fits_in_64 ty) (iadd _ (sinkable_load_32_64 x) y)))
       (add_mem ty y (sink_load x)))
 
 ;; Add a register and memory (16-bit types).
-(rule 4 (lower (has_type (fits_in_64 ty) (iadd x (sinkable_load_16 y))))
+(rule 4 (lower (has_type (fits_in_64 ty) (iadd _ x (sinkable_load_16 y))))
       (add_mem_sext16 ty x (sink_load y)))
-(rule 11 (lower (has_type (fits_in_64 ty) (iadd (sinkable_load_16 x) y)))
+(rule 11 (lower (has_type (fits_in_64 ty) (iadd _ (sinkable_load_16 x) y)))
       (add_mem_sext16 ty y (sink_load x)))
 
 ;; Add a register and sign-extended memory.
-(rule 3 (lower (has_type (fits_in_64 ty) (iadd x (sinkable_sload16 y))))
+(rule 3 (lower (has_type (fits_in_64 ty) (iadd _ x (sinkable_sload16 y))))
       (add_mem_sext16 ty x (sink_sload16 y)))
-(rule 10 (lower (has_type (fits_in_64 ty) (iadd (sinkable_sload16 x) y)))
+(rule 10 (lower (has_type (fits_in_64 ty) (iadd _ (sinkable_sload16 x) y)))
       (add_mem_sext16 ty y (sink_sload16 x)))
-(rule 2 (lower (has_type (fits_in_64 ty) (iadd x (sinkable_sload32 y))))
+(rule 2 (lower (has_type (fits_in_64 ty) (iadd _ x (sinkable_sload32 y))))
       (add_mem_sext32 ty x (sink_sload32 y)))
-(rule 9 (lower (has_type (fits_in_64 ty) (iadd (sinkable_sload32 x) y)))
+(rule 9 (lower (has_type (fits_in_64 ty) (iadd _ (sinkable_sload32 x) y)))
       (add_mem_sext32 ty y (sink_sload32 x)))
 
 ;; Add two vector registers.
-(rule 1 (lower (has_type (vr128_ty ty) (iadd x y)))
+(rule 1 (lower (has_type (vr128_ty ty) (iadd _ x y)))
       (vec_add ty x y))
 
 
 ;;;; Rules for `uadd_sat` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Add (saturate unsigned) two vector registers.
-(rule (lower (has_type (ty_vec128 ty) (uadd_sat x y)))
+(rule (lower (has_type (ty_vec128 ty) (uadd_sat _ x y)))
       (let ((sum Reg (vec_add ty x y)))
         (vec_or ty sum (vec_cmphl ty x sum))))
 
@@ -121,7 +115,7 @@
 ;;;; Rules for `sadd_sat` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Add (saturate signed) two vector registers.  $I64X2 not supported.
-(rule (lower (has_type (ty_vec128 ty) (sadd_sat x y)))
+(rule (lower (has_type (ty_vec128 ty) (sadd_sat _ x y)))
       (vec_pack_ssat (vec_widen_type ty)
                      (vec_add (vec_widen_type ty) (vec_unpacks_high ty x)
                                                   (vec_unpacks_high ty y))
@@ -132,7 +126,7 @@
 ;;;; Rules for `iadd_pairwise` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Lane-wise integer pairwise addition for 8-/16/32-bit vector registers.
-(rule (lower (has_type ty @ (multi_lane bits _) (iadd_pairwise x y)))
+(rule (lower (has_type ty @ (multi_lane bits _) (iadd_pairwise _ x y)))
       (let ((size Reg (vec_imm_splat $I8X16 (u32_as_u64 bits))))
         (vec_pack_lane_order (vec_widen_type ty)
                              (vec_add ty x (vec_lshr_by_byte x size))
@@ -140,9 +134,9 @@
 
 ;; special case for the `i32x4.dot_i16x8_s` wasm instruction
 (rule 1 (lower
-        (has_type dst_ty (iadd_pairwise
-                           (imul (swiden_low x @ (value_type src_ty)) (swiden_low y))
-                           (imul (swiden_high x) (swiden_high y)))))
+        (has_type dst_ty (iadd_pairwise _
+                           (imul _ (swiden_low _ x @ (value_type src_ty)) (swiden_low _ y))
+                           (imul _ (swiden_high _ x) (swiden_high _ y)))))
       (vec_add dst_ty (vec_smul_even src_ty x y)
                       (vec_smul_odd src_ty x y)))
 
@@ -150,49 +144,49 @@
 ;;;; Rules for `isub` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Sub two registers.
-(rule 0 (lower (has_type (fits_in_64 ty) (isub x y)))
+(rule 0 (lower (has_type (fits_in_64 ty) (isub _ x y)))
       (sub_reg ty x y))
 
 ;; Sub a register and a sign-extended register.
-(rule 8 (lower (has_type (fits_in_64 ty) (isub x (sext32_value y))))
+(rule 8 (lower (has_type (fits_in_64 ty) (isub _ x (sext32_value y))))
       (sub_reg_sext32 ty x y))
 
 ;; Sub a register and an immediate (using add of the negated value).
-(rule 7 (lower (has_type (fits_in_64 ty) (isub x (i16_from_negated_value y))))
+(rule 7 (lower (has_type (fits_in_64 ty) (isub _ x (i16_from_negated_value y))))
       (add_simm16 ty x y))
-(rule 6 (lower (has_type (fits_in_64 ty) (isub x (i32_from_negated_value y))))
+(rule 6 (lower (has_type (fits_in_64 ty) (isub _ x (i32_from_negated_value y))))
       (add_simm32 ty x y))
 
 ;; Sub a register and memory (32/64-bit types).
-(rule 5 (lower (has_type (fits_in_64 ty) (isub x (sinkable_load_32_64 y))))
+(rule 5 (lower (has_type (fits_in_64 ty) (isub _ x (sinkable_load_32_64 y))))
       (sub_mem ty x (sink_load y)))
 
 ;; Sub a register and memory (16-bit types).
-(rule 4 (lower (has_type (fits_in_64 ty) (isub x (sinkable_load_16 y))))
+(rule 4 (lower (has_type (fits_in_64 ty) (isub _ x (sinkable_load_16 y))))
       (sub_mem_sext16 ty x (sink_load y)))
 
 ;; Sub a register and sign-extended memory.
-(rule 3 (lower (has_type (fits_in_64 ty) (isub x (sinkable_sload16 y))))
+(rule 3 (lower (has_type (fits_in_64 ty) (isub _ x (sinkable_sload16 y))))
       (sub_mem_sext16 ty x (sink_sload16 y)))
-(rule 2 (lower (has_type (fits_in_64 ty) (isub x (sinkable_sload32 y))))
+(rule 2 (lower (has_type (fits_in_64 ty) (isub _ x (sinkable_sload32 y))))
       (sub_mem_sext32 ty x (sink_sload32 y)))
 
 ;; Sub two vector registers.
-(rule 1 (lower (has_type (vr128_ty ty) (isub x y)))
+(rule 1 (lower (has_type (vr128_ty ty) (isub _ x y)))
       (vec_sub ty x y))
 
 
 ;;;; Rules for `usub_sat` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Add (saturate unsigned) two vector registers.
-(rule (lower (has_type (ty_vec128 ty) (usub_sat x y)))
+(rule (lower (has_type (ty_vec128 ty) (usub_sat _ x y)))
       (vec_and ty (vec_sub ty x y) (vec_cmphl ty x y)))
 
 
 ;;;; Rules for `ssub_sat` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Add (saturate signed) two vector registers.  $I64X2 not supported.
-(rule (lower (has_type (ty_vec128 ty) (ssub_sat x y)))
+(rule (lower (has_type (ty_vec128 ty) (ssub_sat _ x y)))
       (vec_pack_ssat (vec_widen_type ty)
                      (vec_sub (vec_widen_type ty) (vec_unpacks_high ty x)
                                                   (vec_unpacks_high ty y))
@@ -204,19 +198,19 @@
 
 ;; Absolute value of a register.
 ;; For types smaller than 32-bit, the input value must be sign-extended.
-(rule 2 (lower (has_type (fits_in_64 ty) (iabs x)))
+(rule 2 (lower (has_type (fits_in_64 ty) (iabs _ x)))
       (abs_reg (ty_ext32 ty) (put_in_reg_sext32 x)))
 
 ;; Absolute value of a sign-extended register.
-(rule 3 (lower (has_type (fits_in_64 ty) (iabs (sext32_value x))))
+(rule 3 (lower (has_type (fits_in_64 ty) (iabs _ (sext32_value x))))
       (abs_reg_sext32 ty x))
 
 ;; Absolute value of a vector register.
-(rule 1 (lower (has_type (ty_vec128 ty) (iabs x)))
+(rule 1 (lower (has_type (ty_vec128 ty) (iabs _ x)))
       (vec_abs ty x))
 
 ;; Absolute value of a 128-bit integer.
-(rule 0 (lower (has_type $I128 (iabs x)))
+(rule 0 (lower (has_type $I128 (iabs _ x)))
       (let ((zero Reg (vec_imm $I128 0))
             (pos Reg x)
             (neg Reg (vec_sub $I128 zero pos))
@@ -228,26 +222,26 @@
 ;;;; Rules for `ineg` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Negate a register.
-(rule 2 (lower (has_type (fits_in_64 ty) (ineg x)))
+(rule 2 (lower (has_type (fits_in_64 ty) (ineg _ x)))
       (neg_reg ty x))
 
 ;; Negate a sign-extended register.
-(rule 3 (lower (has_type (fits_in_64 ty) (ineg (sext32_value x))))
+(rule 3 (lower (has_type (fits_in_64 ty) (ineg _ (sext32_value x))))
       (neg_reg_sext32 ty x))
 
 ;; Negate a vector register.
-(rule 1 (lower (has_type (ty_vec128 ty) (ineg x)))
+(rule 1 (lower (has_type (ty_vec128 ty) (ineg _ x)))
       (vec_neg ty x))
 
 ;; Negate a 128-bit integer.
-(rule 0 (lower (has_type $I128 (ineg x)))
+(rule 0 (lower (has_type $I128 (ineg _ x)))
       (vec_sub $I128 (vec_imm $I128 0) x))
 
 
 ;;;; Rules for `umax` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Unsigned maximum of two scalar integers - expand to icmp + select.
-(rule 2 (lower (has_type (fits_in_64 ty) (umax x y)))
+(rule 2 (lower (has_type (fits_in_64 ty) (umax _ x y)))
       (let ((x_ext Reg (put_in_reg_zext32 x))
             (y_ext Reg (put_in_reg_zext32 y))
             (cond ProducesBool (bool (icmpu_reg (ty_ext32 ty) x_ext y_ext)
@@ -255,21 +249,21 @@
         (select_bool_reg ty cond y_ext x_ext)))
 
 ;; Unsigned maximum of two 128-bit integers - expand to icmp + select.
-(rule 1 (lower (has_type $I128 (umax x y)))
+(rule 1 (lower (has_type $I128 (umax _ x y)))
       (let ((x_reg Reg (put_in_reg x))
             (y_reg Reg (put_in_reg y))
             (cond ProducesBool (vec_int128_ucmphi y_reg x_reg)))
         (select_bool_reg $I128 cond y_reg x_reg)))
 
 ;; Unsigned maximum of two vector registers.
-(rule 0 (lower (has_type (ty_vec128 ty) (umax x y)))
+(rule 0 (lower (has_type (ty_vec128 ty) (umax _ x y)))
       (vec_umax ty x y))
 
 
 ;;;; Rules for `umin` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Unsigned minimum of two scalar integers - expand to icmp + select.
-(rule 2 (lower (has_type (fits_in_64 ty) (umin x y)))
+(rule 2 (lower (has_type (fits_in_64 ty) (umin _ x y)))
       (let ((x_ext Reg (put_in_reg_zext32 x))
             (y_ext Reg (put_in_reg_zext32 y))
             (cond ProducesBool (bool (icmpu_reg (ty_ext32 ty) x_ext y_ext)
@@ -277,21 +271,21 @@
         (select_bool_reg ty cond y_ext x_ext)))
 
 ;; Unsigned maximum of two 128-bit integers - expand to icmp + select.
-(rule 1 (lower (has_type $I128 (umin x y)))
+(rule 1 (lower (has_type $I128 (umin _ x y)))
       (let ((x_reg Reg (put_in_reg x))
             (y_reg Reg (put_in_reg y))
             (cond ProducesBool (vec_int128_ucmphi x_reg y_reg)))
         (select_bool_reg $I128 cond y_reg x_reg)))
 
 ;; Unsigned minimum of two vector registers.
-(rule 0 (lower (has_type (ty_vec128 ty) (umin x y)))
+(rule 0 (lower (has_type (ty_vec128 ty) (umin _ x y)))
       (vec_umin ty x y))
 
 
 ;;;; Rules for `smax` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Signed maximum of two scalar integers - expand to icmp + select.
-(rule 2 (lower (has_type (fits_in_64 ty) (smax x y)))
+(rule 2 (lower (has_type (fits_in_64 ty) (smax _ x y)))
       (let ((x_ext Reg (put_in_reg_sext32 x))
             (y_ext Reg (put_in_reg_sext32 y))
             (cond ProducesBool (bool (icmps_reg (ty_ext32 ty) x_ext y_ext)
@@ -299,21 +293,21 @@
         (select_bool_reg ty cond y_ext x_ext)))
 
 ;; Signed maximum of two 128-bit integers - expand to icmp + select.
-(rule 1 (lower (has_type $I128 (smax x y)))
+(rule 1 (lower (has_type $I128 (smax _ x y)))
       (let ((x_reg Reg (put_in_reg x))
             (y_reg Reg (put_in_reg y))
             (cond ProducesBool (vec_int128_scmphi y_reg x_reg)))
         (select_bool_reg $I128 cond y_reg x_reg)))
 
 ;; Signed maximum of two vector registers.
-(rule (lower (has_type (ty_vec128 ty) (smax x y)))
+(rule (lower (has_type (ty_vec128 ty) (smax _ x y)))
       (vec_smax ty x y))
 
 
 ;;;; Rules for `smin` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Signed minimum of two scalar integers - expand to icmp + select.
-(rule 2 (lower (has_type (fits_in_64 ty) (smin x y)))
+(rule 2 (lower (has_type (fits_in_64 ty) (smin _ x y)))
       (let ((x_ext Reg (put_in_reg_sext32 x))
             (y_ext Reg (put_in_reg_sext32 y))
             (cond ProducesBool (bool (icmps_reg (ty_ext32 ty) x_ext y_ext)
@@ -321,71 +315,71 @@
         (select_bool_reg ty cond y_ext x_ext)))
 
 ;; Signed maximum of two 128-bit integers - expand to icmp + select.
-(rule 1 (lower (has_type $I128 (smin x y)))
+(rule 1 (lower (has_type $I128 (smin _ x y)))
       (let ((x_reg Reg (put_in_reg x))
             (y_reg Reg (put_in_reg y))
             (cond ProducesBool (vec_int128_scmphi x_reg y_reg)))
         (select_bool_reg $I128 cond y_reg x_reg)))
 
 ;; Signed minimum of two vector registers.
-(rule (lower (has_type (ty_vec128 ty) (smin x y)))
+(rule (lower (has_type (ty_vec128 ty) (smin _ x y)))
       (vec_smin ty x y))
 
 
 ;;;; Rules for `avg_round` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Unsigned average of two vector registers.
-(rule (lower (has_type (ty_vec128 ty) (avg_round x y)))
+(rule (lower (has_type (ty_vec128 ty) (avg_round _ x y)))
       (vec_uavg ty x y))
 
 
 ;;;; Rules for `imul` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Multiply two registers.
-(rule 0 (lower (has_type (fits_in_64 ty) (imul x y)))
+(rule 0 (lower (has_type (fits_in_64 ty) (imul _ x y)))
       (mul_reg ty x y))
 
 ;; Multiply a register and a sign-extended register.
-(rule 8 (lower (has_type (fits_in_64 ty) (imul x (sext32_value y))))
+(rule 8 (lower (has_type (fits_in_64 ty) (imul _ x (sext32_value y))))
       (mul_reg_sext32 ty x y))
-(rule 15 (lower (has_type (fits_in_64 ty) (imul (sext32_value x) y)))
+(rule 15 (lower (has_type (fits_in_64 ty) (imul _ (sext32_value x) y)))
       (mul_reg_sext32 ty y x))
 
 ;; Multiply a register and an immediate.
-(rule 7 (lower (has_type (fits_in_64 ty) (imul x (i16_from_value y))))
+(rule 7 (lower (has_type (fits_in_64 ty) (imul _ x (i16_from_value y))))
       (mul_simm16 ty x y))
-(rule 14 (lower (has_type (fits_in_64 ty) (imul (i16_from_value x) y)))
+(rule 14 (lower (has_type (fits_in_64 ty) (imul _ (i16_from_value x) y)))
       (mul_simm16 ty y x))
-(rule 6 (lower (has_type (fits_in_64 ty) (imul x (i32_from_value y))))
+(rule 6 (lower (has_type (fits_in_64 ty) (imul _ x (i32_from_value y))))
       (mul_simm32 ty x y))
-(rule 13 (lower (has_type (fits_in_64 ty) (imul (i32_from_value x) y)))
+(rule 13 (lower (has_type (fits_in_64 ty) (imul _ (i32_from_value x) y)))
       (mul_simm32 ty y x))
 
 ;; Multiply a register and memory (32/64-bit types).
-(rule 5 (lower (has_type (fits_in_64 ty) (imul x (sinkable_load_32_64 y))))
+(rule 5 (lower (has_type (fits_in_64 ty) (imul _ x (sinkable_load_32_64 y))))
       (mul_mem ty x (sink_load y)))
-(rule 12 (lower (has_type (fits_in_64 ty) (imul (sinkable_load_32_64 x) y)))
+(rule 12 (lower (has_type (fits_in_64 ty) (imul _ (sinkable_load_32_64 x) y)))
       (mul_mem ty y (sink_load x)))
 
 ;; Multiply a register and memory (16-bit types).
-(rule 4 (lower (has_type (fits_in_64 ty) (imul x (sinkable_load_16 y))))
+(rule 4 (lower (has_type (fits_in_64 ty) (imul _ x (sinkable_load_16 y))))
       (mul_mem_sext16 ty x (sink_load y)))
-(rule 11 (lower (has_type (fits_in_64 ty) (imul (sinkable_load_16 x) y)))
+(rule 11 (lower (has_type (fits_in_64 ty) (imul _ (sinkable_load_16 x) y)))
       (mul_mem_sext16 ty y (sink_load x)))
 
 ;; Multiply a register and sign-extended memory.
-(rule 3 (lower (has_type (fits_in_64 ty) (imul x (sinkable_sload16 y))))
+(rule 3 (lower (has_type (fits_in_64 ty) (imul _ x (sinkable_sload16 y))))
       (mul_mem_sext16 ty x (sink_sload16 y)))
-(rule 10 (lower (has_type (fits_in_64 ty) (imul (sinkable_sload16 x) y)))
+(rule 10 (lower (has_type (fits_in_64 ty) (imul _ (sinkable_sload16 x) y)))
       (mul_mem_sext16 ty y (sink_sload16 x)))
-(rule 2 (lower (has_type (fits_in_64 ty) (imul x (sinkable_sload32 y))))
+(rule 2 (lower (has_type (fits_in_64 ty) (imul _ x (sinkable_sload32 y))))
       (mul_mem_sext32 ty x (sink_sload32 y)))
-(rule 9 (lower (has_type (fits_in_64 ty) (imul (sinkable_sload32 x) y)))
+(rule 9 (lower (has_type (fits_in_64 ty) (imul _ (sinkable_sload32 x) y)))
       (mul_mem_sext32 ty y (sink_sload32 x)))
 
 ;; Multiply two vector registers, using a helper.
 (decl vec_mul_impl (Type Reg Reg) Reg)
-(rule 1 (lower (has_type (vr128_ty ty) (imul x y)))
+(rule 1 (lower (has_type (vr128_ty ty) (imul _ x y)))
       (vec_mul_impl ty x y))
 
 ;; Multiply two vector registers - byte, halfword, and word.
@@ -419,32 +413,32 @@
 ;;;; Rules for `umulhi` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Multiply high part unsigned, 8-bit or 16-bit types.  (Uses 32-bit multiply.)
-(rule -1 (lower (has_type (ty_8_or_16 ty) (umulhi x y)))
+(rule -1 (lower (has_type (ty_8_or_16 ty) (umulhi _ x y)))
       (let ((ext_reg_x Reg (put_in_reg_zext32 x))
             (ext_reg_y Reg (put_in_reg_zext32 y))
             (ext_mul Reg (mul_reg $I32 ext_reg_x ext_reg_y)))
         (lshr_imm $I32 ext_mul (ty_bits ty))))
 
 ;; Multiply high part unsigned, 32-bit types.  (Uses 64-bit multiply.)
-(rule (lower (has_type $I32 (umulhi x y)))
+(rule (lower (has_type $I32 (umulhi _ x y)))
       (let ((ext_reg_x Reg (put_in_reg_zext64 x))
             (ext_reg_y Reg (put_in_reg_zext64 y))
             (ext_mul Reg (mul_reg $I64 ext_reg_x ext_reg_y)))
         (lshr_imm $I64 ext_mul 32)))
 
 ;; Multiply high part unsigned, 64-bit types.  (Uses umul_wide.)
-(rule (lower (has_type $I64 (umulhi x y)))
+(rule (lower (has_type $I64 (umulhi _ x y)))
       (let ((pair RegPair (umul_wide x y)))
         (regpair_hi pair)))
 
 ;; Multiply high part unsigned, vector types with 8-, 16-, or 32-bit elements.
-(rule (lower (has_type $I8X16 (umulhi x y))) (vec_umulhi $I8X16 x y))
-(rule (lower (has_type $I16X8 (umulhi x y))) (vec_umulhi $I16X8 x y))
-(rule (lower (has_type $I32X4 (umulhi x y))) (vec_umulhi $I32X4 x y))
+(rule (lower (has_type $I8X16 (umulhi _ x y))) (vec_umulhi $I8X16 x y))
+(rule (lower (has_type $I16X8 (umulhi _ x y))) (vec_umulhi $I16X8 x y))
+(rule (lower (has_type $I32X4 (umulhi _ x y))) (vec_umulhi $I32X4 x y))
 
 ;; Multiply high part unsigned, vector types with 64-bit elements.
 ;; Has to be scalarized.
-(rule (lower (has_type $I64X2 (umulhi x y)))
+(rule (lower (has_type $I64X2 (umulhi _ x y)))
       (let ((pair_0 RegPair (umul_wide (vec_extract_lane $I64X2 x 0 (zero_reg))
                                        (vec_extract_lane $I64X2 y 0 (zero_reg))))
             (res_0 Reg (regpair_hi pair_0))
@@ -457,32 +451,32 @@
 ;;;; Rules for `smulhi` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Multiply high part signed, 8-bit or 16-bit types.  (Uses 32-bit multiply.)
-(rule -1 (lower (has_type (ty_8_or_16 ty) (smulhi x y)))
+(rule -1 (lower (has_type (ty_8_or_16 ty) (smulhi _ x y)))
       (let ((ext_reg_x Reg (put_in_reg_sext32 x))
             (ext_reg_y Reg (put_in_reg_sext32 y))
             (ext_mul Reg (mul_reg $I32 ext_reg_x ext_reg_y)))
         (ashr_imm $I32 ext_mul (ty_bits ty))))
 
 ;; Multiply high part signed, 32-bit types.  (Uses 64-bit multiply.)
-(rule (lower (has_type $I32 (smulhi x y)))
+(rule (lower (has_type $I32 (smulhi _ x y)))
       (let ((ext_reg_x Reg (put_in_reg_sext64 x))
             (ext_reg_y Reg (put_in_reg_sext64 y))
             (ext_mul Reg (mul_reg $I64 ext_reg_x ext_reg_y)))
         (ashr_imm $I64 ext_mul 32)))
 
 ;; Multiply high part signed, 64-bit types.  (Uses smul_wide.)
-(rule (lower (has_type $I64 (smulhi x y)))
+(rule (lower (has_type $I64 (smulhi _ x y)))
       (let ((pair RegPair (smul_wide x y)))
         (regpair_hi pair)))
 
 ;; Multiply high part signed, vector types with 8-, 16-, or 32-bit elements.
-(rule (lower (has_type $I8X16 (smulhi x y))) (vec_smulhi $I8X16 x y))
-(rule (lower (has_type $I16X8 (smulhi x y))) (vec_smulhi $I16X8 x y))
-(rule (lower (has_type $I32X4 (smulhi x y))) (vec_smulhi $I32X4 x y))
+(rule (lower (has_type $I8X16 (smulhi _ x y))) (vec_smulhi $I8X16 x y))
+(rule (lower (has_type $I16X8 (smulhi _ x y))) (vec_smulhi $I16X8 x y))
+(rule (lower (has_type $I32X4 (smulhi _ x y))) (vec_smulhi $I32X4 x y))
 
 ;; Multiply high part unsigned, vector types with 64-bit elements.
 ;; Has to be scalarized.
-(rule (lower (has_type $I64X2 (smulhi x y)))
+(rule (lower (has_type $I64X2 (smulhi _ x y)))
       (let ((pair_0 RegPair (smul_wide (vec_extract_lane $I64X2 x 0 (zero_reg))
                                        (vec_extract_lane $I64X2 y 0 (zero_reg))))
             (res_0 Reg (copy_reg $I64 (regpair_hi pair_0)))
@@ -495,7 +489,7 @@
 ;;;; Rules for `sqmul_round_sat` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Fixed-point multiplication of two vector registers.
-(rule (lower (has_type (ty_vec128 ty) (sqmul_round_sat x y)))
+(rule (lower (has_type (ty_vec128 ty) (sqmul_round_sat _ x y)))
       (vec_pack_ssat (vec_widen_type ty)
                      (sqmul_impl (vec_widen_type ty)
                                  (vec_unpacks_high ty x)
@@ -533,7 +527,7 @@
 ;; and the second variant for 64-bit input types.
 
 ;; Implement `udiv`.
-(rule (lower (has_type (fits_in_64 ty) (udiv x y)))
+(rule (lower (has_type (fits_in_64 ty) (udiv _ x y)))
       (let (;; Look at the divisor to determine whether we need to generate
             ;; an explicit division-by zero check.
             ;; Load up the dividend, by loading the input (possibly zero-
@@ -551,7 +545,7 @@
 
 ;; Implement `urem`.  Same as `udiv`, but finds the remainder in
 ;; the high half of the result register pair instead.
-(rule (lower (has_type (fits_in_64 ty) (urem x y)))
+(rule (lower (has_type (fits_in_64 ty) (urem _ x y)))
       (let ((ext_x RegPair (regpair (imm (ty_ext32 ty) 0)
                                     (put_in_reg_zext32 x)))
             (ext_y Reg (put_in_reg_zext32 y))
@@ -577,7 +571,7 @@
 ;; and the second variant for 64-bit input types.
 
 ;; Implement `sdiv`.
-(rule (lower (has_type (fits_in_64 ty) (sdiv x y)))
+(rule (lower (has_type (fits_in_64 ty) (sdiv _ x y)))
       (let (;; Look at the divisor to determine whether we need to generate
             ;; explicit division-by-zero and/or integer-overflow checks.
             (OFcheck bool (div_overflow_check_needed y))
@@ -596,7 +590,7 @@
 ;; Implement `srem`.  Same as `sdiv`, but finds the remainder in
 ;; the high half of the result register pair instead.  Also, handle
 ;; the integer overflow case differently, see below.
-(rule (lower (has_type (fits_in_64 ty) (srem x y)))
+(rule (lower (has_type (fits_in_64 ty) (srem _ x y)))
       (let ((OFcheck bool (div_overflow_check_needed y))
             (ext_x Reg (put_in_reg_sext64 x))
             (ext_y Reg (put_in_reg_sext32 y))
@@ -609,9 +603,9 @@
 ;;
 ;; We never rely on the divide instruction itself to trap; while that trap
 ;; would indeed happen, we have no way of signalling two different trap
-;; conditions from the same instruction.  By explicity checking for the
+;; conditions from the same instruction.  By explicitly checking for the
 ;; integer-overflow case ahead of time, any hardware trap in the divide
-;; instruction is guaranteed to indicate divison-by-zero.
+;; instruction is guaranteed to indicate division-by-zero.
 ;;
 ;; In addition, for types smaller than 64 bits we would have to perform
 ;; the check explicitly anyway, since the instruction provides a 64-bit
@@ -674,26 +668,26 @@
 ;;;; Rules for `ishl` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Shift left, shift amount in register.
-(rule 0 (lower (has_type (fits_in_64 ty) (ishl x y)))
+(rule 0 (lower (has_type (fits_in_64 ty) (ishl _ x y)))
       (let ((masked_amt Reg (mask_amt_reg ty (amt_reg y))))
         (lshl_reg ty x masked_amt)))
 
 ;; Shift left, immediate shift amount.
-(rule 1 (lower (has_type (fits_in_64 ty) (ishl x (i64_from_value y))))
+(rule 1 (lower (has_type (fits_in_64 ty) (ishl _ x (i64_from_value y))))
       (let ((masked_amt u8 (mask_amt_imm ty y)))
         (lshl_imm ty x masked_amt)))
 
 ;; Vector shift left, shift amount in register.
-(rule 2 (lower (has_type (ty_vec128 ty) (ishl x y)))
+(rule 2 (lower (has_type (ty_vec128 ty) (ishl _ x y)))
       (vec_lshl_reg ty x (amt_reg y)))
 
 ;; Vector shift left, immediate shift amount.
-(rule 3 (lower (has_type (ty_vec128 ty) (ishl x (i64_from_value y))))
+(rule 3 (lower (has_type (ty_vec128 ty) (ishl _ x (i64_from_value y))))
       (let ((masked_amt u8 (mask_amt_imm ty y)))
         (vec_lshl_imm ty x masked_amt)))
 
 ;; 128-bit vector shift left.
-(rule 4 (lower (has_type $I128 (ishl x y)))
+(rule 4 (lower (has_type $I128 (ishl _ x y)))
       (let ((amt Reg (amt_vr y)))
         (vec_lshl_by_bit (vec_lshl_by_byte x amt) amt)))
 
@@ -702,29 +696,29 @@
 
 ;; Shift right logical, shift amount in register.
 ;; For types smaller than 32-bit, the input value must be zero-extended.
-(rule 0 (lower (has_type (fits_in_64 ty) (ushr x y)))
+(rule 0 (lower (has_type (fits_in_64 ty) (ushr _ x y)))
       (let ((ext_reg Reg (put_in_reg_zext32 x))
             (masked_amt Reg (mask_amt_reg ty (amt_reg y))))
         (lshr_reg (ty_ext32 ty) ext_reg masked_amt)))
 
 ;; Shift right logical, immediate shift amount.
 ;; For types smaller than 32-bit, the input value must be zero-extended.
-(rule 1 (lower (has_type (fits_in_64 ty) (ushr x (i64_from_value y))))
+(rule 1 (lower (has_type (fits_in_64 ty) (ushr _ x (i64_from_value y))))
       (let ((ext_reg Reg (put_in_reg_zext32 x))
             (masked_amt u8 (mask_amt_imm ty y)))
         (lshr_imm (ty_ext32 ty) ext_reg masked_amt)))
 
 ;; Vector shift right logical, shift amount in register.
-(rule 2 (lower (has_type (ty_vec128 ty) (ushr x y)))
+(rule 2 (lower (has_type (ty_vec128 ty) (ushr _ x y)))
       (vec_lshr_reg ty x (amt_reg y)))
 
 ;; Vector shift right logical, immediate shift amount.
-(rule 3 (lower (has_type (ty_vec128 ty) (ushr x (i64_from_value y))))
+(rule 3 (lower (has_type (ty_vec128 ty) (ushr _ x (i64_from_value y))))
       (let ((masked_amt u8 (mask_amt_imm ty y)))
         (vec_lshr_imm ty x masked_amt)))
 
 ;; 128-bit vector shift right logical.
-(rule 4 (lower (has_type $I128 (ushr x y)))
+(rule 4 (lower (has_type $I128 (ushr _ x y)))
       (let ((amt Reg (amt_vr y)))
         (vec_lshr_by_bit (vec_lshr_by_byte x amt) amt)))
 
@@ -733,29 +727,29 @@
 
 ;; Shift right arithmetic, shift amount in register.
 ;; For types smaller than 32-bit, the input value must be sign-extended.
-(rule 0 (lower (has_type (fits_in_64 ty) (sshr x y)))
+(rule 0 (lower (has_type (fits_in_64 ty) (sshr _ x y)))
       (let ((ext_reg Reg (put_in_reg_sext32 x))
             (masked_amt Reg (mask_amt_reg ty (amt_reg y))))
         (ashr_reg (ty_ext32 ty) ext_reg masked_amt)))
 
 ;; Shift right arithmetic, immediate shift amount.
 ;; For types smaller than 32-bit, the input value must be sign-extended.
-(rule 1 (lower (has_type (fits_in_64 ty) (sshr x (i64_from_value y))))
+(rule 1 (lower (has_type (fits_in_64 ty) (sshr _ x (i64_from_value y))))
       (let ((ext_reg Reg (put_in_reg_sext32 x))
             (masked_amt u8 (mask_amt_imm ty y)))
         (ashr_imm (ty_ext32 ty) ext_reg masked_amt)))
 
 ;; Vector shift right arithmetic, shift amount in register.
-(rule 2 (lower (has_type (ty_vec128 ty) (sshr x y)))
+(rule 2 (lower (has_type (ty_vec128 ty) (sshr _ x y)))
       (vec_ashr_reg ty x (amt_reg y)))
 
 ;; Vector shift right arithmetic, immediate shift amount.
-(rule 3 (lower (has_type (ty_vec128 ty) (sshr x (i64_from_value y))))
+(rule 3 (lower (has_type (ty_vec128 ty) (sshr _ x (i64_from_value y))))
       (let ((masked_amt u8 (mask_amt_imm ty y)))
         (vec_ashr_imm ty x masked_amt)))
 
 ;; 128-bit vector shift right arithmetic.
-(rule 4 (lower (has_type $I128 (sshr x y)))
+(rule 4 (lower (has_type $I128 (sshr _ x y)))
       (let ((amt Reg (amt_vr y)))
         (vec_ashr_by_bit (vec_ashr_by_byte x amt) amt)))
 
@@ -763,17 +757,17 @@
 ;;;; Rules for `rotl` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Rotate left, shift amount in register.  32-bit or 64-bit types.
-(rule 0 (lower (has_type (ty_32_or_64 ty) (rotl x y)))
+(rule 0 (lower (has_type (ty_32_or_64 ty) (rotl _ x y)))
       (rot_reg ty x (amt_reg y)))
 
 ;; Rotate left arithmetic, immediate shift amount.  32-bit or 64-bit types.
-(rule 1 (lower (has_type (ty_32_or_64 ty) (rotl x (i64_from_value y))))
+(rule 1 (lower (has_type (ty_32_or_64 ty) (rotl _ x (i64_from_value y))))
       (let ((masked_amt u8 (mask_amt_imm ty y)))
         (rot_imm ty x masked_amt)))
 
 ;; Rotate left, shift amount in register.  8-bit or 16-bit types.
 ;; Implemented via a pair of 32-bit shifts on the zero-extended input.
-(rule 2 (lower (has_type (ty_8_or_16 ty) (rotl x y)))
+(rule 2 (lower (has_type (ty_8_or_16 ty) (rotl _ x y)))
       (let ((ext_reg Reg (put_in_reg_zext32 x))
             (ext_ty Type (ty_ext32 ty))
             (pos_amt Reg (amt_reg y))
@@ -785,7 +779,7 @@
 
 ;; Rotate left, immediate shift amount.  8-bit or 16-bit types.
 ;; Implemented via a pair of 32-bit shifts on the zero-extended input.
-(rule 3 (lower (has_type (ty_8_or_16 ty) (rotl x (and (i64_from_value pos_amt)
+(rule 3 (lower (has_type (ty_8_or_16 ty) (rotl _ x (and (i64_from_value pos_amt)
                                                     (i64_from_negated_value neg_amt)))))
       (let ((ext_reg Reg (put_in_reg_zext32 x))
             (ext_ty Type (ty_ext32 ty))
@@ -795,17 +789,17 @@
                 (lshr_imm ext_ty ext_reg masked_neg_amt))))
 
 ;; Vector rotate left, shift amount in register.
-(rule 4 (lower (has_type (ty_vec128 ty) (rotl x y)))
+(rule 4 (lower (has_type (ty_vec128 ty) (rotl _ x y)))
       (vec_rot_reg ty x (amt_reg y)))
 
 ;; Vector rotate left, immediate shift amount.
-(rule 5 (lower (has_type (ty_vec128 ty) (rotl x (i64_from_value y))))
+(rule 5 (lower (has_type (ty_vec128 ty) (rotl _ x (i64_from_value y))))
       (let ((masked_amt u8 (mask_amt_imm ty y)))
         (vec_rot_imm ty x masked_amt)))
 
 ;; 128-bit full vector rotate left.
 ;; Implemented via a pair of 128-bit full vector shifts.
-(rule 6 (lower (has_type $I128 (rotl x y)))
+(rule 6 (lower (has_type $I128 (rotl _ x y)))
       (let ((x_reg Reg x)
             (pos_amt Reg (amt_vr y))
             (neg_amt Reg (vec_neg $I8X16 pos_amt)))
@@ -818,19 +812,19 @@
 
 ;; Rotate right, shift amount in register.  32-bit or 64-bit types.
 ;; Implemented as rotate left with negated rotate amount.
-(rule 0 (lower (has_type (ty_32_or_64 ty) (rotr x y)))
+(rule 0 (lower (has_type (ty_32_or_64 ty) (rotr _ x y)))
       (let ((negated_amt Reg (neg_reg $I32 (amt_reg y))))
         (rot_reg ty x negated_amt)))
 
 ;; Rotate right arithmetic, immediate shift amount.  32-bit or 64-bit types.
 ;; Implemented as rotate left with negated rotate amount.
-(rule 1 (lower (has_type (ty_32_or_64 ty) (rotr x (i64_from_negated_value y))))
+(rule 1 (lower (has_type (ty_32_or_64 ty) (rotr _ x (i64_from_negated_value y))))
       (let ((negated_amt u8 (mask_amt_imm ty y)))
         (rot_imm ty x negated_amt)))
 
 ;; Rotate right, shift amount in register.  8-bit or 16-bit types.
 ;; Implemented as rotate left with negated rotate amount.
-(rule 2 (lower (has_type (ty_8_or_16 ty) (rotr x y)))
+(rule 2 (lower (has_type (ty_8_or_16 ty) (rotr _ x y)))
       (let ((ext_reg Reg (put_in_reg_zext32 x))
             (ext_ty Type (ty_ext32 ty))
             (pos_amt Reg (amt_reg y))
@@ -842,7 +836,7 @@
 
 ;; Rotate right, immediate shift amount.  8-bit or 16-bit types.
 ;; Implemented as rotate left with negated rotate amount.
-(rule 3 (lower (has_type (ty_8_or_16 ty) (rotr x (and (i64_from_value pos_amt)
+(rule 3 (lower (has_type (ty_8_or_16 ty) (rotr _ x (and (i64_from_value pos_amt)
                                                     (i64_from_negated_value neg_amt)))))
       (let ((ext_reg Reg (put_in_reg_zext32 x))
             (ext_ty Type (ty_ext32 ty))
@@ -853,19 +847,19 @@
 
 ;; Vector rotate right, shift amount in register.
 ;; Implemented as rotate left with negated rotate amount.
-(rule 4 (lower (has_type (ty_vec128 ty) (rotr x y)))
+(rule 4 (lower (has_type (ty_vec128 ty) (rotr _ x y)))
       (let ((negated_amt Reg (neg_reg $I32 (amt_reg y))))
         (vec_rot_reg ty x negated_amt)))
 
 ;; Vector rotate right, immediate shift amount.
 ;; Implemented as rotate left with negated rotate amount.
-(rule 5 (lower (has_type (ty_vec128 ty) (rotr x (i64_from_negated_value y))))
+(rule 5 (lower (has_type (ty_vec128 ty) (rotr _ x (i64_from_negated_value y))))
       (let ((negated_amt u8 (mask_amt_imm ty y)))
         (vec_rot_imm ty x negated_amt)))
 
 ;; 128-bit full vector rotate right.
 ;; Implemented via a pair of 128-bit full vector shifts.
-(rule 6 (lower (has_type $I128 (rotr x y)))
+(rule 6 (lower (has_type $I128 (rotr _ x y)))
       (let ((x_reg Reg x)
             (pos_amt Reg (amt_vr y))
             (neg_amt Reg (vec_neg $I8X16 pos_amt)))
@@ -877,143 +871,143 @@
 ;;;; Rules for `ireduce` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Up to 64-bit source type: Always a no-op.
-(rule 1 (lower (ireduce x @ (value_type (fits_in_64 _ty))))
+(rule 1 (lower (ireduce _ x @ (value_type (fits_in_64 _ty))))
       x)
 
 ;; 128-bit source type: Extract the low half.
-(rule (lower (ireduce x @ (value_type (vr128_ty _ty))))
+(rule (lower (ireduce _ x @ (value_type (vr128_ty _ty))))
       (vec_extract_lane $I64X2 x 1 (zero_reg)))
 
 
 ;;;; Rules for `uextend` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; 16- or 32-bit target types.
-(rule 1 (lower (has_type (gpr32_ty _ty) (uextend x)))
+(rule 1 (lower (has_type (gpr32_ty _ty) (uextend _ x)))
       (put_in_reg_zext32 x))
 
 ;; 64-bit target types.
-(rule 2 (lower (has_type (gpr64_ty _ty) (uextend x)))
+(rule 2 (lower (has_type (gpr64_ty _ty) (uextend _ x)))
       (put_in_reg_zext64 x))
 
 ;; 128-bit target types.
-(rule (lower (has_type $I128 (uextend x @ (value_type $I8))))
+(rule (lower (has_type $I128 (uextend _ x @ (value_type $I8))))
       (vec_insert_lane $I8X16 (vec_imm $I128 0) x 15 (zero_reg)))
-(rule (lower (has_type $I128 (uextend x @ (value_type $I16))))
+(rule (lower (has_type $I128 (uextend _ x @ (value_type $I16))))
       (vec_insert_lane $I16X8 (vec_imm $I128 0) x 7 (zero_reg)))
-(rule (lower (has_type $I128 (uextend x @ (value_type $I32))))
+(rule (lower (has_type $I128 (uextend _ x @ (value_type $I32))))
       (vec_insert_lane $I32X4 (vec_imm $I128 0) x 3 (zero_reg)))
-(rule (lower (has_type $I128 (uextend x @ (value_type $I64))))
+(rule (lower (has_type $I128 (uextend _ x @ (value_type $I64))))
       (vec_insert_lane $I64X2 (vec_imm $I128 0) x 1 (zero_reg)))
 
 
 ;;;; Rules for `sextend` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; 16- or 32-bit target types.
-(rule 1 (lower (has_type (gpr32_ty _ty) (sextend x)))
+(rule 1 (lower (has_type (gpr32_ty _ty) (sextend _ x)))
       (put_in_reg_sext32 x))
 
 ;; 64-bit target types.
-(rule 2 (lower (has_type (gpr64_ty _ty) (sextend x)))
+(rule 2 (lower (has_type (gpr64_ty _ty) (sextend _ x)))
       (put_in_reg_sext64 x))
 
 ;; 128-bit target types.
-(rule (lower (has_type $I128 (sextend x)))
+(rule (lower (has_type $I128 (sextend _ x)))
       (let ((x_ext Reg (put_in_reg_sext64 x)))
         (mov_to_vec128 $I128 (ashr_imm $I64 x_ext 63) x_ext)))
 
 
 ;;;; Rules for `snarrow` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (snarrow x @ (value_type (ty_vec128 ty)) y))
+(rule (lower (snarrow _ x @ (value_type (ty_vec128 ty)) y))
       (vec_pack_ssat_lane_order ty x y))
 
 
 ;;;; Rules for `uunarrow` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (uunarrow x @ (value_type (ty_vec128 ty)) y))
+(rule (lower (uunarrow _ x @ (value_type (ty_vec128 ty)) y))
       (vec_pack_usat_lane_order ty x y))
 
 
 ;;;; Rules for `unarrow` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (unarrow x @ (value_type (ty_vec128 ty)) y))
+(rule (lower (unarrow _ x @ (value_type (ty_vec128 ty)) y))
       (let ((zero Reg (vec_imm ty 0)))
         (vec_pack_usat_lane_order ty (vec_smax ty x zero) (vec_smax ty y zero))))
 
 
 ;;;; Rules for `swiden_low` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (swiden_low x @ (value_type (ty_vec128 ty))))
+(rule (lower (swiden_low _ x @ (value_type (ty_vec128 ty))))
       (vec_unpacks_low_lane_order ty x))
 
 
 ;;;; Rules for `swiden_high` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (swiden_high x @ (value_type (ty_vec128 ty))))
+(rule (lower (swiden_high _ x @ (value_type (ty_vec128 ty))))
       (vec_unpacks_high_lane_order ty x))
 
 
 ;;;; Rules for `uwiden_low` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (uwiden_low x @ (value_type (ty_vec128 ty))))
+(rule (lower (uwiden_low _ x @ (value_type (ty_vec128 ty))))
       (vec_unpacku_low_lane_order ty x))
 
 
 ;;;; Rules for `uwiden_high` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (uwiden_high x @ (value_type (ty_vec128 ty))))
+(rule (lower (uwiden_high _ x @ (value_type (ty_vec128 ty))))
       (vec_unpacku_high_lane_order ty x))
 
 
 ;;;; Rules for `bnot` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; z15 version using a single instruction (NOR).
-(rule 2 (lower (has_type (and (mie2_enabled) (fits_in_64 ty)) (bnot x)))
+(rule 2 (lower (has_type (and (mie2_enabled) (fits_in_64 ty)) (bnot _ x)))
       (let ((rx Reg x))
         (not_or_reg ty rx rx)))
 
 ;; z14 version using XOR with -1.
-(rule 1 (lower (has_type (and (mie2_disabled) (fits_in_64 ty)) (bnot x)))
+(rule 1 (lower (has_type (and (mie2_disabled) (fits_in_64 ty)) (bnot _ x)))
       (not_reg ty x))
 
 ;; Vector version using vector NOR.
-(rule (lower (has_type (vr128_ty ty) (bnot x)))
+(rule (lower (has_type (vr128_ty ty) (bnot _ x)))
       (vec_not ty x))
 
 ;; With z15 (bnot (bxor ...)) can be a single instruction, similar to the
 ;; (bxor _ (bnot _)) lowering.
-(rule 3 (lower (has_type (and (mie2_enabled) (fits_in_64 ty)) (bnot (bxor x y))))
+(rule 3 (lower (has_type (and (mie2_enabled) (fits_in_64 ty)) (bnot _ (bxor _ x y))))
       (not_xor_reg ty x y))
 
 ;; Combine a not/xor operation of vector types into one.
-(rule 4 (lower (has_type (vr128_ty ty) (bnot (bxor x y))))
+(rule 4 (lower (has_type (vr128_ty ty) (bnot _ (bxor _ x y))))
       (vec_not_xor ty x y))
 
 
 ;;;; Rules for `band` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; And two registers.
-(rule -1 (lower (has_type (fits_in_64 ty) (band x y)))
+(rule -1 (lower (has_type (fits_in_64 ty) (band _ x y)))
       (and_reg ty x y))
 
 ;; And a register and an immediate.
-(rule 5 (lower (has_type (fits_in_64 ty) (band x (uimm16shifted_from_inverted_value y))))
+(rule 5 (lower (has_type (fits_in_64 ty) (band _ x (uimm16shifted_from_inverted_value y))))
       (and_uimm16shifted ty x y))
-(rule 6 (lower (has_type (fits_in_64 ty) (band (uimm16shifted_from_inverted_value x) y)))
+(rule 6 (lower (has_type (fits_in_64 ty) (band _ (uimm16shifted_from_inverted_value x) y)))
       (and_uimm16shifted ty y x))
-(rule 3 (lower (has_type (fits_in_64 ty) (band x (uimm32shifted_from_inverted_value y))))
+(rule 3 (lower (has_type (fits_in_64 ty) (band _ x (uimm32shifted_from_inverted_value y))))
       (and_uimm32shifted ty x y))
-(rule 4 (lower (has_type (fits_in_64 ty) (band (uimm32shifted_from_inverted_value x) y)))
+(rule 4 (lower (has_type (fits_in_64 ty) (band _ (uimm32shifted_from_inverted_value x) y)))
       (and_uimm32shifted ty y x))
 
 ;; And a register and memory (32/64-bit types).
-(rule 1 (lower (has_type (fits_in_64 ty) (band x (sinkable_load_32_64 y))))
+(rule 1 (lower (has_type (fits_in_64 ty) (band _ x (sinkable_load_32_64 y))))
       (and_mem ty x (sink_load y)))
-(rule 2 (lower (has_type (fits_in_64 ty) (band (sinkable_load_32_64 x) y)))
+(rule 2 (lower (has_type (fits_in_64 ty) (band _ (sinkable_load_32_64 x) y)))
       (and_mem ty y (sink_load x)))
 
 ;; And two vector registers.
-(rule 0 (lower (has_type (vr128_ty ty) (band x y)))
+(rule 0 (lower (has_type (vr128_ty ty) (band _ x y)))
       (vec_and ty x y))
 
 ;; Specialized lowerings for `(band x (bnot y))` which is additionally produced
@@ -1021,41 +1015,41 @@
 ;; forms early on.
 
 ;; z15 version using a single instruction.
-(rule 7 (lower (has_type (and (mie2_enabled) (fits_in_64 ty)) (band x (bnot y))))
+(rule 7 (lower (has_type (and (mie2_enabled) (fits_in_64 ty)) (band _ x (bnot _ y))))
       (and_not_reg ty x y))
-(rule 8 (lower (has_type (and (mie2_enabled) (fits_in_64 ty)) (band (bnot y) x)))
+(rule 8 (lower (has_type (and (mie2_enabled) (fits_in_64 ty)) (band _ (bnot _ y) x)))
       (and_not_reg ty x y))
 
 ;; And-not two vector registers.
-(rule 9 (lower (has_type (vr128_ty ty) (band x (bnot y))))
+(rule 9 (lower (has_type (vr128_ty ty) (band _ x (bnot _ y))))
       (vec_and_not ty x y))
-(rule 10 (lower (has_type (vr128_ty ty) (band (bnot y) x)))
+(rule 10 (lower (has_type (vr128_ty ty) (band _ (bnot _ y) x)))
       (vec_and_not ty x y))
 
 ;;;; Rules for `bor` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Or two registers.
-(rule -1 (lower (has_type (fits_in_64 ty) (bor x y)))
+(rule -1 (lower (has_type (fits_in_64 ty) (bor _ x y)))
       (or_reg ty x y))
 
 ;; Or a register and an immediate.
-(rule 5 (lower (has_type (fits_in_64 ty) (bor x (uimm16shifted_from_value y))))
+(rule 5 (lower (has_type (fits_in_64 ty) (bor _ x (uimm16shifted_from_value y))))
       (or_uimm16shifted ty x y))
-(rule 6 (lower (has_type (fits_in_64 ty) (bor (uimm16shifted_from_value x) y)))
+(rule 6 (lower (has_type (fits_in_64 ty) (bor _ (uimm16shifted_from_value x) y)))
       (or_uimm16shifted ty y x))
-(rule 3 (lower (has_type (fits_in_64 ty) (bor x (uimm32shifted_from_value y))))
+(rule 3 (lower (has_type (fits_in_64 ty) (bor _ x (uimm32shifted_from_value y))))
       (or_uimm32shifted ty x y))
-(rule 4 (lower (has_type (fits_in_64 ty) (bor (uimm32shifted_from_value x) y)))
+(rule 4 (lower (has_type (fits_in_64 ty) (bor _ (uimm32shifted_from_value x) y)))
       (or_uimm32shifted ty y x))
 
 ;; Or a register and memory (32/64-bit types).
-(rule 1 (lower (has_type (fits_in_64 ty) (bor x (sinkable_load_32_64 y))))
+(rule 1 (lower (has_type (fits_in_64 ty) (bor _ x (sinkable_load_32_64 y))))
       (or_mem ty x (sink_load y)))
-(rule 2 (lower (has_type (fits_in_64 ty) (bor (sinkable_load_32_64 x) y)))
+(rule 2 (lower (has_type (fits_in_64 ty) (bor _ (sinkable_load_32_64 x) y)))
       (or_mem ty y (sink_load x)))
 
 ;; Or two vector registers.
-(rule 0 (lower (has_type (vr128_ty ty) (bor x y)))
+(rule 0 (lower (has_type (vr128_ty ty) (bor _ x y)))
       (vec_or ty x y))
 
 ;; Specialized lowerings for `(bor x (bnot y))` which is additionally produced
@@ -1063,38 +1057,38 @@
 ;; forms early on.
 
 ;; z15 version using a single instruction.
-(rule 7 (lower (has_type (and (mie2_enabled) (fits_in_64 ty)) (bor x (bnot y))))
+(rule 7 (lower (has_type (and (mie2_enabled) (fits_in_64 ty)) (bor _ x (bnot _ y))))
       (or_not_reg ty x y))
-(rule 8 (lower (has_type (and (mie2_enabled) (fits_in_64 ty)) (bor (bnot y) x)))
+(rule 8 (lower (has_type (and (mie2_enabled) (fits_in_64 ty)) (bor _ (bnot _ y) x)))
       (or_not_reg ty x y))
 
 ;; Or-not two vector registers.
-(rule 9 (lower (has_type (vr128_ty ty) (bor x (bnot y))))
+(rule 9 (lower (has_type (vr128_ty ty) (bor _ x (bnot _ y))))
       (vec_or_not ty x y))
-(rule 10 (lower (has_type (vr128_ty ty) (bor (bnot y) x)))
+(rule 10 (lower (has_type (vr128_ty ty) (bor _ (bnot _ y) x)))
       (vec_or_not ty x y))
 
 
 ;;;; Rules for `bxor` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Xor two registers.
-(rule -1 (lower (has_type (fits_in_64 ty) (bxor x y)))
+(rule -1 (lower (has_type (fits_in_64 ty) (bxor _ x y)))
       (xor_reg ty x y))
 
 ;; Xor a register and an immediate.
-(rule 3 (lower (has_type (fits_in_64 ty) (bxor x (uimm32shifted_from_value y))))
+(rule 3 (lower (has_type (fits_in_64 ty) (bxor _ x (uimm32shifted_from_value y))))
       (xor_uimm32shifted ty x y))
-(rule 4 (lower (has_type (fits_in_64 ty) (bxor (uimm32shifted_from_value x) y)))
+(rule 4 (lower (has_type (fits_in_64 ty) (bxor _ (uimm32shifted_from_value x) y)))
       (xor_uimm32shifted ty y x))
 
 ;; Xor a register and memory (32/64-bit types).
-(rule 1 (lower (has_type (fits_in_64 ty) (bxor x (sinkable_load_32_64 y))))
+(rule 1 (lower (has_type (fits_in_64 ty) (bxor _ x (sinkable_load_32_64 y))))
       (xor_mem ty x (sink_load y)))
-(rule 2 (lower (has_type (fits_in_64 ty) (bxor (sinkable_load_32_64 x) y)))
+(rule 2 (lower (has_type (fits_in_64 ty) (bxor _ (sinkable_load_32_64 x) y)))
       (xor_mem ty y (sink_load x)))
 
 ;; Xor two vector registers.
-(rule 0 (lower (has_type (vr128_ty ty) (bxor x y)))
+(rule 0 (lower (has_type (vr128_ty ty) (bxor _ x y)))
       (vec_xor ty x y))
 
 ;; Specialized lowerings for `(bxor x (bnot y))` which is additionally produced
@@ -1102,55 +1096,55 @@
 ;; forms early on.
 
 ;; z15 version using a single instruction.
-(rule 5 (lower (has_type (and (mie2_enabled) (fits_in_64 ty)) (bxor x (bnot y))))
+(rule 5 (lower (has_type (and (mie2_enabled) (fits_in_64 ty)) (bxor _ x (bnot _ y))))
       (not_xor_reg ty x y))
-(rule 6 (lower (has_type (and (mie2_enabled) (fits_in_64 ty)) (bxor (bnot y) x)))
+(rule 6 (lower (has_type (and (mie2_enabled) (fits_in_64 ty)) (bxor _ (bnot _ y) x)))
       (not_xor_reg ty x y))
 
 ;; Xor-not two vector registers.
-(rule 7 (lower (has_type (vr128_ty ty) (bxor x (bnot y))))
+(rule 7 (lower (has_type (vr128_ty ty) (bxor _ x (bnot _ y))))
       (vec_not_xor ty x y))
-(rule 8 (lower (has_type (vr128_ty ty) (bxor (bnot y) x)))
+(rule 8 (lower (has_type (vr128_ty ty) (bxor _ (bnot _ y) x)))
       (vec_not_xor ty x y))
 
 
 ;;;; Rules for `bitselect` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; z15 version using a NAND instruction.
-(rule 2 (lower (has_type (and (mie2_enabled) (fits_in_64 ty)) (bitselect x y z)))
+(rule 2 (lower (has_type (and (mie2_enabled) (fits_in_64 ty)) (bitselect _ x y z)))
       (let ((rx Reg x)
             (if_true Reg (and_reg ty y rx))
             (if_false Reg (and_not_reg ty z rx)))
         (or_reg ty if_false if_true)))
 
 ;; z14 version using XOR with -1.
-(rule 1 (lower (has_type (and (mie2_disabled) (fits_in_64 ty)) (bitselect x y z)))
+(rule 1 (lower (has_type (and (mie2_disabled) (fits_in_64 ty)) (bitselect _ x y z)))
       (let ((rx Reg x)
             (if_true Reg (and_reg ty y rx))
             (if_false Reg (and_reg ty z (not_reg ty rx))))
         (or_reg ty if_false if_true)))
 
 ;; Bitselect vector registers.
-(rule (lower (has_type (vr128_ty ty) (bitselect x y z)))
+(rule (lower (has_type (vr128_ty ty) (bitselect _ x y z)))
       (vec_select ty y z x))
 
 ;; Special-case some float-selection instructions for min/max
-(rule 3 (lower (has_type (ty_vec128 ty) (bitselect (bitcast _ (fcmp (FloatCC.LessThan) x y)) x y)))
+(rule 3 (lower (has_type (ty_vec128 ty) (bitselect _ (bitcast _ _ (fcmp _ (FloatCC.LessThan) x y)) x y)))
         (fmin_pseudo_reg ty y x))
-(rule 4 (lower (has_type (ty_vec128 ty) (bitselect (bitcast _ (fcmp (FloatCC.LessThan) y x)) x y)))
+(rule 4 (lower (has_type (ty_vec128 ty) (bitselect _ (bitcast _ _ (fcmp _ (FloatCC.LessThan) y x)) x y)))
         (fmax_pseudo_reg ty y x))
 
 
 
 ;;;; Rules for `bmask` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type ty (bmask x)))
+(rule (lower (has_type ty (bmask _ x)))
       (lower_bool_to_mask ty (value_nonzero x)))
 
 
 ;;;; Rules for `bitrev` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type ty (bitrev x)))
+(rule (lower (has_type ty (bitrev _ x)))
       (bitrev_bytes ty
         (bitrev_bits 4 0xf0f0_f0f0_f0f0_f0f0 ty
           (bitrev_bits 2 0xcccc_cccc_cccc_cccc ty
@@ -1185,7 +1179,7 @@
 
 ;;;; Rules for `bswap` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type ty (bswap x)))
+(rule (lower (has_type ty (bswap _ x)))
       (bitrev_bytes ty x))
 
 ;;;; Rules for `clz` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -1201,7 +1195,7 @@
 
 ;; Count leading zeros, via FLOGR on an input zero-extended to 64 bits,
 ;; with the result compensated for the extra bits.
-(rule 1 (lower (has_type (fits_in_64 ty) (clz x)))
+(rule 1 (lower (has_type (fits_in_64 ty) (clz _ x)))
       (let ((ext_reg Reg (put_in_reg_zext64 x))
             ;; Ask for a value of 64 in the all-zero 64-bit input case.
             ;; After compensation this will match the expected semantics.
@@ -1209,7 +1203,7 @@
         (clz_offset ty clz)))
 
 ;; Count leading zeros, 128-bit full vector.
-(rule (lower (has_type $I128 (clz x)))
+(rule (lower (has_type $I128 (clz _ x)))
       (let ((clz_vec Reg (vec_clz $I64X2 x))
             (zero Reg (vec_imm $I64X2 0))
             (clz_hi Reg (vec_permute_dw_imm $I64X2 zero 0 clz_vec 0))
@@ -1235,7 +1229,7 @@
 ;; i.e. computing
 ;;        cls(x) == clz(x ^ (x >> 63)) - 1
 ;; where x is the sign-extended input.
-(rule 1 (lower (has_type (fits_in_64 ty) (cls x)))
+(rule 1 (lower (has_type (fits_in_64 ty) (cls _ x)))
       (let ((ext_reg Reg (put_in_reg_sext64 x))
             (signbit_copies Reg (ashr_imm $I64 ext_reg 63))
             (inv_reg Reg (xor_reg $I64 ext_reg signbit_copies))
@@ -1243,7 +1237,7 @@
         (cls_offset ty clz)))
 
 ;; Count leading sign-bit copies, 128-bit full vector.
-(rule (lower (has_type $I128 (cls x)))
+(rule (lower (has_type $I128 (cls _ x)))
       (let ((x_reg Reg x)
             (ones Reg (vec_imm_splat $I8X16 255))
             (signbit_copies Reg (vec_ashr_by_bit (vec_ashr_by_byte x_reg ones) ones))
@@ -1272,7 +1266,7 @@
 ;; never zero by setting a "guard bit" in the position corresponding to
 ;; the input type size.  This way the 64-bit algorithm above will handle
 ;; that case correctly automatically.
-(rule 2 (lower (has_type (gpr32_ty ty) (ctz x)))
+(rule 2 (lower (has_type (gpr32_ty ty) (ctz _ x)))
       (let ((rx Reg (or_uimm16shifted $I64 x (ctz_guardbit ty)))
             (lastbit Reg (and_reg $I64 rx (neg_reg $I64 rx)))
             (clz Reg (clz_reg 64 lastbit)))
@@ -1287,14 +1281,14 @@
 ;; via its condition code.  We check for that and replace the instruction
 ;; result with the value -1 via a conditional move, which will then lead to
 ;; the correct result after the final subtraction from 63.
-(rule 1 (lower (has_type (gpr64_ty _ty) (ctz x)))
+(rule 1 (lower (has_type (gpr64_ty _ty) (ctz _ x)))
       (let ((rx Reg x)
             (lastbit Reg (and_reg $I64 rx (neg_reg $I64 rx)))
             (clz Reg (clz_reg -1 lastbit)))
         (sub_reg $I64 (imm $I64 63) clz)))
 
 ;; Count trailing zeros, 128-bit full vector.
-(rule 0 (lower (has_type $I128 (ctz x)))
+(rule 0 (lower (has_type $I128 (ctz _ x)))
       (let ((ctz_vec Reg (vec_ctz $I64X2 x))
             (zero Reg (vec_imm $I64X2 0))
             (ctz_hi Reg (vec_permute_dw_imm $I64X2 zero 0 ctz_vec 0))
@@ -1307,12 +1301,12 @@
 ;;;; Rules for `popcnt` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Population count for 8-bit types is supported by the POPCNT instruction.
-(rule (lower (has_type $I8 (popcnt x)))
+(rule (lower (has_type $I8 (popcnt _ x)))
       (popcnt_byte x))
 
 ;; On z15, the POPCNT instruction has a variant to compute a full 64-bit
 ;; population count, which we also use for 16- and 32-bit types.
-(rule -1 (lower (has_type (and (mie2_enabled) (fits_in_64 ty)) (popcnt x)))
+(rule -1 (lower (has_type (and (mie2_enabled) (fits_in_64 ty)) (popcnt _ x)))
       (popcnt_reg (put_in_reg_zext64 x)))
 
 ;; On z14, we use the regular POPCNT, which computes the population count
@@ -1323,18 +1317,18 @@
 ;; $I16, where we instead accumulate in the low byte and clear high bits
 ;; via an explicit and operation.)
 
-(rule (lower (has_type (and (mie2_disabled) $I16) (popcnt x)))
+(rule (lower (has_type (and (mie2_disabled) $I16) (popcnt _ x)))
       (let ((cnt2 Reg (popcnt_byte x))
             (cnt1 Reg (add_reg $I32 cnt2 (lshr_imm $I32 cnt2 8))))
         (and_uimm16shifted $I32 cnt1 (uimm16shifted 255 0))))
 
-(rule (lower (has_type (and (mie2_disabled) $I32) (popcnt x)))
+(rule (lower (has_type (and (mie2_disabled) $I32) (popcnt _ x)))
       (let ((cnt4 Reg (popcnt_byte x))
             (cnt2 Reg (add_reg $I32 cnt4 (lshl_imm $I32 cnt4 16)))
             (cnt1 Reg (add_reg $I32 cnt2 (lshl_imm $I32 cnt2 8))))
         (lshr_imm $I32 cnt1 24)))
 
-(rule (lower (has_type (and (mie2_disabled) $I64) (popcnt x)))
+(rule (lower (has_type (and (mie2_disabled) $I64) (popcnt _ x)))
       (let ((cnt8 Reg (popcnt_byte x))
             (cnt4 Reg (add_reg $I64 cnt8 (lshl_imm $I64 cnt8 32)))
             (cnt2 Reg (add_reg $I64 cnt4 (lshl_imm $I64 cnt4 16)))
@@ -1342,11 +1336,11 @@
         (lshr_imm $I64 cnt1 56)))
 
 ;; Population count for vector types.
-(rule 1 (lower (has_type (ty_vec128 ty) (popcnt x)))
+(rule 1 (lower (has_type (ty_vec128 ty) (popcnt _ x)))
       (vec_popcnt ty x))
 
 ;; Population count, 128-bit full vector.
-(rule (lower (has_type $I128 (popcnt x)))
+(rule (lower (has_type $I128 (popcnt _ x)))
       (let ((popcnt_vec Reg (vec_popcnt $I64X2 x))
             (zero Reg (vec_imm $I64X2 0))
             (popcnt_hi Reg (vec_permute_dw_imm $I64X2 zero 0 popcnt_vec 0))
@@ -1357,139 +1351,139 @@
 ;;;; Rules for `fadd` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Add two registers.
-(rule (lower (has_type ty (fadd x y)))
+(rule (lower (has_type ty (fadd _ x y)))
       (fadd_reg ty x y))
 
 
 ;;;; Rules for `fsub` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Subtract two registers.
-(rule (lower (has_type ty (fsub x y)))
+(rule (lower (has_type ty (fsub _ x y)))
       (fsub_reg ty x y))
 
 
 ;;;; Rules for `fmul` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Multiply two registers.
-(rule (lower (has_type ty (fmul x y)))
+(rule (lower (has_type ty (fmul _ x y)))
       (fmul_reg ty x y))
 
 
 ;;;; Rules for `fdiv` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Divide two registers.
-(rule (lower (has_type ty (fdiv x y)))
+(rule (lower (has_type ty (fdiv _ x y)))
       (fdiv_reg ty x y))
 
 
 ;;;; Rules for `fmin` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Minimum of two registers.
-(rule (lower (has_type ty (fmin x y)))
+(rule (lower (has_type ty (fmin _ x y)))
       (fmin_reg ty x y))
 
 
 ;;;; Rules for `fmax` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Maximum of two registers.
-(rule (lower (has_type ty (fmax x y)))
+(rule (lower (has_type ty (fmax _ x y)))
       (fmax_reg ty x y))
 
 
 ;;;; Rules for `fcopysign` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Copysign of two registers.
-(rule (lower (has_type $F32 (fcopysign x y)))
+(rule (lower (has_type $F32 (fcopysign _ x y)))
       (vec_select $F32 x y (imm $F32 2147483647)))
-(rule (lower (has_type $F64 (fcopysign x y)))
+(rule (lower (has_type $F64 (fcopysign _ x y)))
       (vec_select $F64 x y (imm $F64 9223372036854775807)))
-(rule (lower (has_type $F32X4 (fcopysign x y)))
+(rule (lower (has_type $F32X4 (fcopysign _ x y)))
       (vec_select $F32X4 x y (vec_imm_bit_mask $F32X4 1 31)))
-(rule (lower (has_type $F64X2 (fcopysign x y)))
+(rule (lower (has_type $F64X2 (fcopysign _ x y)))
       (vec_select $F64X2 x y (vec_imm_bit_mask $F64X2 1 63)))
 
 
 ;;;; Rules for `fma` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Multiply-and-add of three registers.
-(rule (lower (has_type ty (fma x y z)))
+(rule (lower (has_type ty (fma _ x y z)))
       (fma_reg ty x y z))
 
 
 ;;;; Rules for `sqrt` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Square root of a register.
-(rule (lower (has_type ty (sqrt x)))
+(rule (lower (has_type ty (sqrt _ x)))
       (sqrt_reg ty x))
 
 
 ;;;; Rules for `fneg` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Negated value of a register.
-(rule (lower (has_type ty (fneg x)))
+(rule (lower (has_type ty (fneg _ x)))
       (fneg_reg ty x))
 
 
 ;;;; Rules for `fabs` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Absolute value of a register.
-(rule (lower (has_type ty (fabs x)))
+(rule (lower (has_type ty (fabs _ x)))
       (fabs_reg ty x))
 
 
 ;;;; Rules for `ceil` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Round value in a register towards positive infinity.
-(rule (lower (has_type ty (ceil x)))
+(rule (lower (has_type ty (ceil _ x)))
       (ceil_reg ty x))
 
 
 ;;;; Rules for `floor` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Round value in a register towards negative infinity.
-(rule (lower (has_type ty (floor x)))
+(rule (lower (has_type ty (floor _ x)))
       (floor_reg ty x))
 
 
 ;;;; Rules for `trunc` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Round value in a register towards zero.
-(rule (lower (has_type ty (trunc x)))
+(rule (lower (has_type ty (trunc _ x)))
       (trunc_reg ty x))
 
 
 ;;;; Rules for `nearest` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Round value in a register towards nearest.
-(rule (lower (has_type ty (nearest x)))
+(rule (lower (has_type ty (nearest _ x)))
       (nearest_reg ty x))
 
 
 ;;;; Rules for `fpromote` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Promote a register.
-(rule (lower (has_type (fits_in_64 dst_ty) (fpromote x @ (value_type src_ty))))
+(rule (lower (has_type (fits_in_64 dst_ty) (fpromote _ x @ (value_type src_ty))))
       (fpromote_reg dst_ty src_ty x))
 
 
 ;;;; Rules for `fvpromote_low` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Promote a register.
-(rule (lower (has_type $F64X2 (fvpromote_low x @ (value_type $F32X4))))
+(rule (lower (has_type $F64X2 (fvpromote_low _ x @ (value_type $F32X4))))
       (fpromote_reg $F64X2 $F32X4 (vec_merge_low_lane_order $I32X4 x x)))
 
 
 ;;;; Rules for `fdemote` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Demote a register.
-(rule (lower (has_type (fits_in_64 dst_ty) (fdemote x @ (value_type src_ty))))
+(rule (lower (has_type (fits_in_64 dst_ty) (fdemote _ x @ (value_type src_ty))))
       (fdemote_reg dst_ty src_ty (FpuRoundMode.Current) x))
 
 
 ;;;; Rules for `fvdemote` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Demote a register.
-(rule (lower (has_type $F32X4 (fvdemote x @ (value_type $F64X2))))
+(rule (lower (has_type $F32X4 (fvdemote _ x @ (value_type $F64X2))))
       (let ((dst Reg (fdemote_reg $F32X4 $F64X2 (FpuRoundMode.Current) x)))
         (vec_pack_lane_order $I64X2 (vec_lshr_imm $I64X2 dst 32)
                                     (vec_imm $I64X2 0))))
@@ -1499,29 +1493,29 @@
 
 ;; Convert a 32-bit or smaller unsigned integer to $F32 (z15 instruction).
 (rule 1 (lower (has_type $F32
-        (fcvt_from_uint x @ (value_type (and (vxrs_ext2_enabled) (fits_in_32 ty))))))
+        (fcvt_from_uint _ x @ (value_type (and (vxrs_ext2_enabled) (fits_in_32 ty))))))
       (fcvt_from_uint_reg $F32 (FpuRoundMode.ToNearestTiesToEven)
                           (put_in_reg_zext32 x)))
 
 ;; Convert a 64-bit or smaller unsigned integer to $F32, via an intermediate $F64.
-(rule (lower (has_type $F32 (fcvt_from_uint x @ (value_type (fits_in_64 ty)))))
+(rule (lower (has_type $F32 (fcvt_from_uint _ x @ (value_type (fits_in_64 ty)))))
       (fdemote_reg $F32 $F64 (FpuRoundMode.ToNearestTiesToEven)
                    (fcvt_from_uint_reg $F64 (FpuRoundMode.ShorterPrecision)
                                        (put_in_reg_zext64 x))))
 
 ;; Convert a 64-bit or smaller unsigned integer to $F64.
-(rule (lower (has_type $F64 (fcvt_from_uint x @ (value_type (fits_in_64 ty)))))
+(rule (lower (has_type $F64 (fcvt_from_uint _ x @ (value_type (fits_in_64 ty)))))
       (fcvt_from_uint_reg $F64 (FpuRoundMode.ToNearestTiesToEven)
                           (put_in_reg_zext64 x)))
 
 ;; Convert $I32X4 to $F32X4 (z15 instruction).
 (rule 1 (lower (has_type (and (vxrs_ext2_enabled) $F32X4)
-                       (fcvt_from_uint x @ (value_type $I32X4))))
+                       (fcvt_from_uint _ x @ (value_type $I32X4))))
       (fcvt_from_uint_reg $F32X4 (FpuRoundMode.ToNearestTiesToEven) x))
 
 ;; Convert $I32X4 to $F32X4 (via two $F64X2 on z14).
 (rule (lower (has_type (and (vxrs_ext2_disabled) $F32X4)
-                       (fcvt_from_uint x @ (value_type $I32X4))))
+                       (fcvt_from_uint _ x @ (value_type $I32X4))))
       (vec_permute $F32X4
         (fdemote_reg $F32X4 $F64X2 (FpuRoundMode.ToNearestTiesToEven)
           (fcvt_from_uint_reg $F64X2 (FpuRoundMode.ShorterPrecision)
@@ -1532,7 +1526,7 @@
         (vec_imm $I8X16 (imm8x16 0 1 2 3 8 9 10 11 16 17 18 19 24 25 26 27))))
 
 ;; Convert $I64X2 to $F64X2.
-(rule (lower (has_type $F64X2 (fcvt_from_uint x @ (value_type $I64X2))))
+(rule (lower (has_type $F64X2 (fcvt_from_uint _ x @ (value_type $I64X2))))
       (fcvt_from_uint_reg $F64X2 (FpuRoundMode.ToNearestTiesToEven) x))
 
 
@@ -1540,29 +1534,29 @@
 
 ;; Convert a 32-bit or smaller signed integer to $F32 (z15 instruction).
 (rule 1 (lower (has_type $F32
-        (fcvt_from_sint x @ (value_type (and (vxrs_ext2_enabled) (fits_in_32 ty))))))
+        (fcvt_from_sint _ x @ (value_type (and (vxrs_ext2_enabled) (fits_in_32 ty))))))
       (fcvt_from_sint_reg $F32 (FpuRoundMode.ToNearestTiesToEven)
                           (put_in_reg_sext32 x)))
 
 ;; Convert a 64-bit or smaller signed integer to $F32, via an intermediate $F64.
-(rule (lower (has_type $F32 (fcvt_from_sint x @ (value_type (fits_in_64 ty)))))
+(rule (lower (has_type $F32 (fcvt_from_sint _ x @ (value_type (fits_in_64 ty)))))
       (fdemote_reg $F32 $F64 (FpuRoundMode.ToNearestTiesToEven)
                    (fcvt_from_sint_reg $F64 (FpuRoundMode.ShorterPrecision)
                                        (put_in_reg_sext64 x))))
 
 ;; Convert a 64-bit or smaller signed integer to $F64.
-(rule (lower (has_type $F64 (fcvt_from_sint x @ (value_type (fits_in_64 ty)))))
+(rule (lower (has_type $F64 (fcvt_from_sint _ x @ (value_type (fits_in_64 ty)))))
       (fcvt_from_sint_reg $F64 (FpuRoundMode.ToNearestTiesToEven)
                           (put_in_reg_sext64 x)))
 
 ;; Convert $I32X4 to $F32X4 (z15 instruction).
 (rule 1 (lower (has_type (and (vxrs_ext2_enabled) $F32X4)
-                       (fcvt_from_sint x @ (value_type $I32X4))))
+                       (fcvt_from_sint _ x @ (value_type $I32X4))))
       (fcvt_from_sint_reg $F32X4 (FpuRoundMode.ToNearestTiesToEven) x))
 
 ;; Convert $I32X4 to $F32X4 (via two $F64X2 on z14).
 (rule (lower (has_type (and (vxrs_ext2_disabled) $F32X4)
-                       (fcvt_from_sint x @ (value_type $I32X4))))
+                       (fcvt_from_sint _ x @ (value_type $I32X4))))
       (vec_permute $F32X4
         (fdemote_reg $F32X4 $F64X2 (FpuRoundMode.ToNearestTiesToEven)
           (fcvt_from_sint_reg $F64X2 (FpuRoundMode.ShorterPrecision)
@@ -1573,7 +1567,7 @@
         (vec_imm $I8X16 (imm8x16 0 1 2 3 8 9 10 11 16 17 18 19 24 25 26 27))))
 
 ;; Convert $I64X2 to $F64X2.
-(rule (lower (has_type $F64X2 (fcvt_from_sint x @ (value_type $I64X2))))
+(rule (lower (has_type $F64X2 (fcvt_from_sint _ x @ (value_type $I64X2))))
       (fcvt_from_sint_reg $F64X2 (FpuRoundMode.ToNearestTiesToEven) x))
 
 
@@ -1582,7 +1576,7 @@
 ;; Convert a scalar floating-point value in a register to an unsigned integer.
 ;; Traps if the input cannot be represented in the output type.
 (rule (lower (has_type (fits_in_64 dst_ty)
-                       (fcvt_to_uint x @ (value_type src_ty))))
+                       (fcvt_to_uint _ x @ (value_type src_ty))))
       (let ((src Reg (put_in_reg x))
             ;; First, check whether the input is a NaN, and trap if so.
             (_ Reg (trap_if (fcmp_reg src_ty src src)
@@ -1606,7 +1600,7 @@
 ;; Convert a scalar floating-point value in a register to a signed integer.
 ;; Traps if the input cannot be represented in the output type.
 (rule (lower (has_type (fits_in_64 dst_ty)
-                       (fcvt_to_sint x @ (value_type src_ty))))
+                       (fcvt_to_sint _ x @ (value_type src_ty))))
       (let ((src Reg (put_in_reg x))
             ;; First, check whether the input is a NaN, and trap if so.
             (_ Reg (trap_if (fcmp_reg src_ty src src)
@@ -1630,7 +1624,7 @@
 
 ;; Convert a scalar floating-point value in a register to an unsigned integer.
 (rule -1 (lower (has_type (fits_in_64 dst_ty)
-                       (fcvt_to_uint_sat x @ (value_type src_ty))))
+                       (fcvt_to_uint_sat _ x @ (value_type src_ty))))
       (let ((src Reg (put_in_reg x))
             ;; Perform the conversion using the larger type size.
             (flt_ty Type (fcvt_flt_ty dst_ty src_ty))
@@ -1642,12 +1636,12 @@
 
 ;; Convert $F32X4 to $I32X4 (z15 instruction).
 (rule 1 (lower (has_type (and (vxrs_ext2_enabled) $I32X4)
-                       (fcvt_to_uint_sat x @ (value_type $F32X4))))
+                       (fcvt_to_uint_sat _ x @ (value_type $F32X4))))
       (fcvt_to_uint_reg $F32X4 (FpuRoundMode.ToZero) x))
 
 ;; Convert $F32X4 to $I32X4 (via two $F64X2 on z14).
 (rule (lower (has_type (and (vxrs_ext2_disabled) $I32X4)
-                       (fcvt_to_uint_sat x @ (value_type $F32X4))))
+                       (fcvt_to_uint_sat _ x @ (value_type $F32X4))))
       (vec_pack_usat $I64X2
         (fcvt_to_uint_reg $F64X2 (FpuRoundMode.ToZero)
           (fpromote_reg $F64X2 $F32X4 (vec_merge_high $I32X4 x x)))
@@ -1655,7 +1649,7 @@
           (fpromote_reg $F64X2 $F32X4 (vec_merge_low $I32X4 x x)))))
 
 ;; Convert $F64X2 to $I64X2.
-(rule (lower (has_type $I64X2 (fcvt_to_uint_sat x @ (value_type $F64X2))))
+(rule (lower (has_type $I64X2 (fcvt_to_uint_sat _ x @ (value_type $F64X2))))
       (fcvt_to_uint_reg $F64X2 (FpuRoundMode.ToZero) x))
 
 
@@ -1663,7 +1657,7 @@
 
 ;; Convert a scalar floating-point value in a register to a signed integer.
 (rule -1 (lower (has_type (fits_in_64 dst_ty)
-                       (fcvt_to_sint_sat x @ (value_type src_ty))))
+                       (fcvt_to_sint_sat _ x @ (value_type src_ty))))
       (let ((src Reg (put_in_reg x))
             ;; Perform the conversion using the larger type size.
             (flt_ty Type (fcvt_flt_ty dst_ty src_ty))
@@ -1682,7 +1676,7 @@
 
 ;; Convert $F32X4 to $I32X4 (z15 instruction).
 (rule 1 (lower (has_type (and (vxrs_ext2_enabled) $I32X4)
-                       (fcvt_to_sint_sat src @ (value_type $F32X4))))
+                       (fcvt_to_sint_sat _ src @ (value_type $F32X4))))
       ;; See above for why we need to handle NaNs specially.
       (vec_select $I32X4
         (fcvt_to_sint_reg $F32X4 (FpuRoundMode.ToZero) src)
@@ -1690,7 +1684,7 @@
 
 ;; Convert $F32X4 to $I32X4 (via two $F64X2 on z14).
 (rule (lower (has_type (and (vxrs_ext2_disabled) $I32X4)
-                       (fcvt_to_sint_sat src @ (value_type $F32X4))))
+                       (fcvt_to_sint_sat _ src @ (value_type $F32X4))))
       ;; See above for why we need to handle NaNs specially.
       (vec_select $I32X4
         (vec_pack_ssat $I64X2
@@ -1701,7 +1695,7 @@
         (vec_imm $I32X4 0) (vec_fcmpeq $F32X4 src src)))
 
 ;; Convert $F64X2 to $I64X2.
-(rule (lower (has_type $I64X2 (fcvt_to_sint_sat src @ (value_type $F64X2))))
+(rule (lower (has_type $I64X2 (fcvt_to_sint_sat _ src @ (value_type $F64X2))))
       ;; See above for why we need to handle NaNs specially.
       (vec_select $I64X2
         (fcvt_to_sint_reg $F64X2 (FpuRoundMode.ToZero) src)
@@ -1711,34 +1705,38 @@
 ;;;; Rules for `bitcast` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Reinterpret a 64-bit integer value as floating-point.
-(rule (lower (has_type $F64 (bitcast _ x @ (value_type $I64))))
+(rule (lower (has_type $F64 (bitcast _ _ x @ (value_type $I64))))
       (vec_insert_lane_undef $F64X2 x 0 (zero_reg)))
 
 ;; Reinterpret a 64-bit floating-point value as integer.
-(rule (lower (has_type $I64 (bitcast _ x @ (value_type $F64))))
+(rule (lower (has_type $I64 (bitcast _ _ x @ (value_type $F64))))
       (vec_extract_lane $F64X2 x 0 (zero_reg)))
 
 ;; Reinterpret a 32-bit integer value as floating-point.
-(rule (lower (has_type $F32 (bitcast _ x @ (value_type $I32))))
+(rule (lower (has_type $F32 (bitcast _ _ x @ (value_type $I32))))
       (vec_insert_lane_undef $F32X4 x 0 (zero_reg)))
 
 ;; Reinterpret a 32-bit floating-point value as integer.
-(rule (lower (has_type $I32 (bitcast _ x @ (value_type $F32))))
+(rule (lower (has_type $I32 (bitcast _ _ x @ (value_type $F32))))
       (vec_extract_lane $F32X4 x 0 (zero_reg)))
 
 ;; Bitcast between types residing in GPRs is a no-op.
 (rule 1 (lower (has_type (gpr32_ty _)
-                         (bitcast _ x @ (value_type (gpr32_ty _))))) x)
+                         (bitcast _ _ x @ (value_type (gpr32_ty _)))))
+      x)
 (rule 2 (lower (has_type (gpr64_ty _)
-                         (bitcast _ x @ (value_type (gpr64_ty _))))) x)
+                         (bitcast _ _ x @ (value_type (gpr64_ty _)))))
+      x)
 
 ;; Bitcast between types residing in FPRs is a no-op.
 (rule 3 (lower (has_type (ty_scalar_float _)
-                         (bitcast _ x @ (value_type (ty_scalar_float _))))) x)
+                         (bitcast _ _ x @ (value_type (ty_scalar_float _)))))
+      x)
 
 ;; Bitcast between types residing in VRs is a no-op if lane count is unchanged.
 (rule 5 (lower (has_type (multi_lane bits count)
-                         (bitcast _ x @ (value_type (multi_lane bits count))))) x)
+                         (bitcast _ _ x @ (value_type (multi_lane bits count)))))
+      x)
 
 ;; Bitcast between types residing in VRs with different lane counts is a
 ;; no-op if the operation's MemFlags indicate a byte order compatible with
@@ -1748,7 +1746,7 @@
 ;; choice of lane order depending on the current function ABI, this case will
 ;; currently never arise in practice.
 (rule 4 (lower (has_type (vr128_ty out_ty)
-                         (bitcast flags x @ (value_type (vr128_ty in_ty)))))
+                         (bitcast _ flags x @ (value_type (vr128_ty in_ty)))))
       (abi_vec_elt_rev (lane_order_from_memflags flags) out_ty
         (abi_vec_elt_rev (lane_order_from_memflags flags) in_ty x)))
 
@@ -1756,37 +1754,37 @@
 ;;;; Rules for `insertlane` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Insert vector lane from general-purpose register.
-(rule 1 (lower (insertlane x @ (value_type ty)
+(rule 1 (lower (insertlane _ x @ (value_type ty)
                          y @ (value_type in_ty)
                          (u8_from_uimm8 idx)))
       (if (ty_int_ref_scalar_64 in_ty))
       (vec_insert_lane ty x y (be_lane_idx ty idx) (zero_reg)))
 
 ;; Insert vector lane from floating-point register.
-(rule 0 (lower (insertlane x @ (value_type ty)
+(rule 0 (lower (insertlane _ x @ (value_type ty)
                          y @ (value_type (ty_scalar_float _))
                          (u8_from_uimm8 idx)))
       (vec_move_lane_and_insert ty x (be_lane_idx ty idx) y 0))
 
 ;; Insert vector lane from another vector lane.
-(rule 2 (lower (insertlane x @ (value_type ty)
-                         (extractlane y (u8_from_uimm8 src_idx))
+(rule 2 (lower (insertlane _ x @ (value_type ty)
+                         (extractlane _ y (u8_from_uimm8 src_idx))
                          (u8_from_uimm8 dst_idx)))
       (vec_move_lane_and_insert ty x (be_lane_idx ty dst_idx)
                                    y (be_lane_idx ty src_idx)))
 
 ;; Insert vector lane from signed 16-bit immediate.
-(rule 3 (lower (insertlane x @ (value_type ty) (i16_from_value y)
+(rule 3 (lower (insertlane _ x @ (value_type ty) (i16_from_value y)
                          (u8_from_uimm8 idx)))
       (vec_insert_lane_imm ty x y (be_lane_idx ty idx)))
 
 ;; Insert vector lane from big-endian memory.
-(rule 4 (lower (insertlane x @ (value_type ty) (sinkable_load y)
+(rule 4 (lower (insertlane _ x @ (value_type ty) (sinkable_load y)
                          (u8_from_uimm8 idx)))
       (vec_load_lane ty x (sink_load y) (be_lane_idx ty idx)))
 
 ;; Insert vector lane from little-endian memory.
-(rule 5 (lower (insertlane x @ (value_type ty) (sinkable_load_little y)
+(rule 5 (lower (insertlane _ x @ (value_type ty) (sinkable_load_little y)
                          (u8_from_uimm8 idx)))
       (vec_load_lane_little ty x (sink_load y) (be_lane_idx ty idx)))
 
@@ -1874,25 +1872,25 @@
 
 ;; Extract vector lane to general-purpose register.
 (rule 1 (lower (has_type out_ty
-                       (extractlane x @ (value_type ty) (u8_from_uimm8 idx))))
+                       (extractlane _ x @ (value_type ty) (u8_from_uimm8 idx))))
       (if (ty_int_ref_scalar_64 out_ty))
       (vec_extract_lane ty x (be_lane_idx ty idx) (zero_reg)))
 
 ;; Extract vector lane to floating-point register.
 (rule 0 (lower (has_type (ty_scalar_float _)
-                       (extractlane x @ (value_type ty) (u8_from_uimm8 idx))))
+                       (extractlane _ x @ (value_type ty) (u8_from_uimm8 idx))))
       (vec_replicate_lane ty x (be_lane_idx ty idx)))
 
 ;; Extract vector lane and store to big-endian memory.
 (rule 6 (lower (store flags @ (bigendian)
-                    (extractlane x @ (value_type ty) (u8_from_uimm8 idx))
+                    (extractlane _ x @ (value_type ty) (u8_from_uimm8 idx))
                     addr offset))
       (side_effect (vec_store_lane ty x
                      (lower_address flags addr offset) (be_lane_idx ty idx))))
 
 ;; Extract vector lane and store to little-endian memory.
 (rule 5 (lower (store flags @ (littleendian)
-                    (extractlane x @ (value_type ty) (u8_from_uimm8 idx))
+                    (extractlane _ x @ (value_type ty) (u8_from_uimm8 idx))
                     addr offset))
       (side_effect (vec_store_lane_little ty x
                      (lower_address flags addr offset) (be_lane_idx ty idx))))
@@ -1931,29 +1929,29 @@
 ;;;; Rules for `splat` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Load replicated value from general-purpose register.
-(rule 1 (lower (has_type ty (splat x @ (value_type in_ty))))
+(rule 1 (lower (has_type ty (splat _ x @ (value_type in_ty))))
       (if (ty_int_ref_scalar_64 in_ty))
       (vec_replicate_lane ty (vec_insert_lane_undef ty x 0 (zero_reg)) 0))
 
 ;; Load replicated value from floating-point register.
-(rule 0 (lower (has_type ty (splat
+(rule 0 (lower (has_type ty (splat _
                              x @ (value_type (ty_scalar_float _)))))
       (vec_replicate_lane ty x 0))
 
 ;; Load replicated value from vector lane.
-(rule 2 (lower (has_type ty (splat (extractlane x (u8_from_uimm8 idx)))))
+(rule 2 (lower (has_type ty (splat _ (extractlane _ x (u8_from_uimm8 idx)))))
       (vec_replicate_lane ty x (be_lane_idx ty idx)))
 
 ;; Load replicated 16-bit immediate value.
-(rule 3 (lower (has_type ty (splat (i16_from_value x))))
+(rule 3 (lower (has_type ty (splat _ (i16_from_value x))))
       (vec_imm_replicate ty x))
 
 ;; Load replicated value from big-endian memory.
-(rule 4 (lower (has_type ty (splat (sinkable_load x))))
+(rule 4 (lower (has_type ty (splat _ (sinkable_load x))))
       (vec_load_replicate ty (sink_load x)))
 
 ;; Load replicated value from little-endian memory.
-(rule 5 (lower (has_type ty (splat (sinkable_load_little x))))
+(rule 5 (lower (has_type ty (splat _ (sinkable_load_little x))))
       (vec_load_replicate_little ty (sink_load x)))
 
 
@@ -1990,31 +1988,31 @@
 ;;;; Rules for `scalar_to_vector` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Load scalar value from general-purpose register.
-(rule 1 (lower (has_type ty (scalar_to_vector
+(rule 1 (lower (has_type ty (scalar_to_vector _
                              x @ (value_type in_ty))))
       (if (ty_int_ref_scalar_64 in_ty))
       (vec_insert_lane ty (vec_imm ty 0) x (be_lane_idx ty 0) (zero_reg)))
 
 ;; Load scalar value from floating-point register.
-(rule 0 (lower (has_type ty (scalar_to_vector
+(rule 0 (lower (has_type ty (scalar_to_vector _
                              x @ (value_type (ty_scalar_float _)))))
       (vec_move_lane_and_zero ty (be_lane_idx ty 0) x 0))
 
 ;; Load scalar value from vector lane.
-(rule 2 (lower (has_type ty (scalar_to_vector
-                            (extractlane x (u8_from_uimm8 idx)))))
+(rule 2 (lower (has_type ty (scalar_to_vector _
+                            (extractlane _ x (u8_from_uimm8 idx)))))
       (vec_move_lane_and_zero ty (be_lane_idx ty 0) x (be_lane_idx ty idx)))
 
 ;; Load scalar 16-bit immediate value.
-(rule 3 (lower (has_type ty (scalar_to_vector (i16_from_value x))))
+(rule 3 (lower (has_type ty (scalar_to_vector _ (i16_from_value x))))
       (vec_insert_lane_imm ty (vec_imm ty 0) x (be_lane_idx ty 0)))
 
 ;; Load scalar value from big-endian memory.
-(rule 4 (lower (has_type ty (scalar_to_vector (sinkable_load x))))
+(rule 4 (lower (has_type ty (scalar_to_vector _ (sinkable_load x))))
       (vec_load_lane ty (vec_imm ty 0) (sink_load x) (be_lane_idx ty 0)))
 
 ;; Load scalar value lane from little-endian memory.
-(rule 5 (lower (has_type ty (scalar_to_vector (sinkable_load_little x))))
+(rule 5 (lower (has_type ty (scalar_to_vector _ (sinkable_load_little x))))
       (vec_load_lane_little ty (vec_imm ty 0) (sink_load x) (be_lane_idx ty 0)))
 
 
@@ -2041,152 +2039,152 @@
 ;;;; Rules for `shuffle` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; General case: use vec_permute and then mask off zero lanes.
-(rule -2 (lower (shuffle x y (shuffle_mask permute_mask and_mask)))
+(rule -2 (lower (shuffle _ x y (shuffle_mask permute_mask and_mask)))
       (vec_and $I8X16 (vec_imm_byte_mask $I8X16 and_mask)
                (vec_permute $I8X16 x y (vec_imm $I8X16 permute_mask))))
 
 ;; If the pattern has no zero lanes, just a vec_permute suffices.
-(rule -1 (lower (shuffle x y (shuffle_mask permute_mask 65535)))
+(rule -1 (lower (shuffle _ x y (shuffle_mask permute_mask 65535)))
       (vec_permute $I8X16 x y (vec_imm $I8X16 permute_mask)))
 
 ;; Special patterns that can be implemented via MERGE HIGH.
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 0 1 2 3 4 5 6 7 16 17 18 19 20 21 22 23) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 0 1 2 3 4 5 6 7 16 17 18 19 20 21 22 23) 65535)))
       (vec_merge_high $I64X2 x y))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 0 1 2 3 16 17 18 19 4 5 6 7 20 21 22 23) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 0 1 2 3 16 17 18 19 4 5 6 7 20 21 22 23) 65535)))
       (vec_merge_high $I32X4 x y))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 0 1 16 17 2 3 18 19 4 5 20 21 6 7 22 23) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 0 1 16 17 2 3 18 19 4 5 20 21 6 7 22 23) 65535)))
       (vec_merge_high $I16X8 x y))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 0 16 1 17 2 18 3 19 4 20 5 21 6 22 7 23) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 0 16 1 17 2 18 3 19 4 20 5 21 6 22 7 23) 65535)))
       (vec_merge_high $I8X16 x y))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 16 17 18 19 20 21 22 23 0 1 2 3 4 5 6 7) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 16 17 18 19 20 21 22 23 0 1 2 3 4 5 6 7) 65535)))
       (vec_merge_high $I64X2 y x))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 16 17 18 19 0 1 2 3 20 21 22 23 4 5 6 7) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 16 17 18 19 0 1 2 3 20 21 22 23 4 5 6 7) 65535)))
       (vec_merge_high $I32X4 y x))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 16 17 0 1 18 19 2 3 20 21 4 5 22 23 6 7) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 16 17 0 1 18 19 2 3 20 21 4 5 22 23 6 7) 65535)))
       (vec_merge_high $I16X8 y x))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 16 0 17 1 18 2 19 3 20 4 21 5 22 6 23 7) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 16 0 17 1 18 2 19 3 20 4 21 5 22 6 23 7) 65535)))
       (vec_merge_high $I8X16 y x))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7) 65535)))
       (vec_merge_high $I64X2 x x))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 0 1 2 3 0 1 2 3 4 5 6 7 4 5 6 7) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 0 1 2 3 0 1 2 3 4 5 6 7 4 5 6 7) 65535)))
       (vec_merge_high $I32X4 x x))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 0 1 0 1 2 3 2 3 4 5 4 5 6 7 6 7) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 0 1 0 1 2 3 2 3 4 5 4 5 6 7 6 7) 65535)))
       (vec_merge_high $I16X8 x x))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7) 65535)))
       (vec_merge_high $I8X16 x x))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 16 17 18 19 20 21 22 23 16 17 18 19 20 21 22 23) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 16 17 18 19 20 21 22 23 16 17 18 19 20 21 22 23) 65535)))
       (vec_merge_high $I64X2 y y))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 16 17 18 19 16 17 18 19 20 21 22 23 20 21 22 23) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 16 17 18 19 16 17 18 19 20 21 22 23 20 21 22 23) 65535)))
       (vec_merge_high $I32X4 y y))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 16 17 16 17 18 19 18 19 20 21 20 21 22 23 22 23) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 16 17 16 17 18 19 18 19 20 21 20 21 22 23 22 23) 65535)))
       (vec_merge_high $I16X8 y y))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 16 16 17 17 18 18 19 19 20 20 21 21 22 22 23 23) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 16 16 17 17 18 18 19 19 20 20 21 21 22 22 23 23) 65535)))
       (vec_merge_high $I8X16 y y))
 
 ;; Special patterns that can be implemented via MERGE LOW.
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 8 9 10 11 12 13 14 15 24 25 26 27 28 29 30 31) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 8 9 10 11 12 13 14 15 24 25 26 27 28 29 30 31) 65535)))
       (vec_merge_low $I64X2 x y))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 8 9 10 11 24 25 26 27 12 13 14 15 28 29 30 31) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 8 9 10 11 24 25 26 27 12 13 14 15 28 29 30 31) 65535)))
       (vec_merge_low $I32X4 x y))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 8 9 24 25 10 11 26 27 12 13 28 29 14 15 30 31) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 8 9 24 25 10 11 26 27 12 13 28 29 14 15 30 31) 65535)))
       (vec_merge_low $I16X8 x y))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 8 24 9 25 10 26 11 27 12 28 13 29 14 30 15 31) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 8 24 9 25 10 26 11 27 12 28 13 29 14 30 15 31) 65535)))
       (vec_merge_low $I8X16 x y))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 24 25 26 27 28 29 30 31 8 9 10 11 12 13 14 15) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 24 25 26 27 28 29 30 31 8 9 10 11 12 13 14 15) 65535)))
       (vec_merge_low $I64X2 y x))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 24 25 26 27 8 9 10 11 28 29 30 31 12 13 14 15) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 24 25 26 27 8 9 10 11 28 29 30 31 12 13 14 15) 65535)))
       (vec_merge_low $I32X4 y x))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 24 25 8 9 26 27 10 11 28 29 12 13 30 31 14 15) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 24 25 8 9 26 27 10 11 28 29 12 13 30 31 14 15) 65535)))
       (vec_merge_low $I16X8 y x))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 24 8 25 9 26 10 27 11 28 12 29 13 30 14 31 15) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 24 8 25 9 26 10 27 11 28 12 29 13 30 14 31 15) 65535)))
       (vec_merge_low $I8X16 y x))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 8 9 10 11 12 13 14 15 8 9 10 11 12 13 14 15) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 8 9 10 11 12 13 14 15 8 9 10 11 12 13 14 15) 65535)))
       (vec_merge_low $I64X2 x x))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 8 9 10 11 8 9 10 11 12 13 14 15 12 13 14 15) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 8 9 10 11 8 9 10 11 12 13 14 15 12 13 14 15) 65535)))
       (vec_merge_low $I32X4 x x))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 8 9 8 9 10 11 10 11 12 13 12 13 14 15 14 15) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 8 9 8 9 10 11 10 11 12 13 12 13 14 15 14 15) 65535)))
       (vec_merge_low $I16X8 x x))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 8 8 9 9 10 10 11 11 12 12 13 13 14 14 15 15) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 8 8 9 9 10 10 11 11 12 12 13 13 14 14 15 15) 65535)))
       (vec_merge_low $I8X16 x x))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 24 25 26 27 28 29 30 31 24 25 26 27 28 29 30 31) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 24 25 26 27 28 29 30 31 24 25 26 27 28 29 30 31) 65535)))
       (vec_merge_low $I64X2 y y))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 24 25 26 27 24 25 26 27 28 29 30 31 28 29 30 31) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 24 25 26 27 24 25 26 27 28 29 30 31 28 29 30 31) 65535)))
       (vec_merge_low $I32X4 y y))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 24 25 24 25 26 27 26 27 28 29 28 29 30 31 30 31) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 24 25 24 25 26 27 26 27 28 29 28 29 30 31 30 31) 65535)))
       (vec_merge_low $I16X8 y y))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 24 24 25 25 26 26 27 27 28 28 29 29 30 30 31 31) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 24 24 25 25 26 26 27 27 28 28 29 29 30 30 31 31) 65535)))
       (vec_merge_low $I8X16 y y))
 
 ;; Special patterns that can be implemented via PACK.
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 4 5 6 7 12 13 14 15 20 21 22 23 28 29 30 31) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 4 5 6 7 12 13 14 15 20 21 22 23 28 29 30 31) 65535)))
       (vec_pack $I64X2 x y))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 2 3 6 7 10 11 14 15 18 19 22 23 26 27 30 31) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 2 3 6 7 10 11 14 15 18 19 22 23 26 27 30 31) 65535)))
       (vec_pack $I32X4 x y))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31) 65535)))
       (vec_pack $I16X8 x y))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 20 21 22 23 28 29 30 31 4 5 6 7 12 13 14 15) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 20 21 22 23 28 29 30 31 4 5 6 7 12 13 14 15) 65535)))
       (vec_pack $I64X2 y x))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 18 19 22 23 26 27 30 31 2 3 6 7 10 11 14 15) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 18 19 22 23 26 27 30 31 2 3 6 7 10 11 14 15) 65535)))
       (vec_pack $I32X4 y x))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 17 19 21 23 25 27 29 31 1 3 5 7 9 11 13 15) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 17 19 21 23 25 27 29 31 1 3 5 7 9 11 13 15) 65535)))
       (vec_pack $I16X8 y x))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 4 5 6 7 12 13 14 15 4 5 6 7 12 13 14 15) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 4 5 6 7 12 13 14 15 4 5 6 7 12 13 14 15) 65535)))
       (vec_pack $I64X2 x x))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 2 3 6 7 10 11 14 15 2 3 6 7 10 11 14 15) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 2 3 6 7 10 11 14 15 2 3 6 7 10 11 14 15) 65535)))
       (vec_pack $I32X4 x x))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 1 3 5 7 9 11 13 15 1 3 5 7 9 11 13 15) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 1 3 5 7 9 11 13 15 1 3 5 7 9 11 13 15) 65535)))
       (vec_pack $I16X8 x x))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 20 21 22 23 28 29 30 31 20 21 22 23 28 29 30 31) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 20 21 22 23 28 29 30 31 20 21 22 23 28 29 30 31) 65535)))
       (vec_pack $I64X2 y y))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 18 19 22 23 26 27 30 31 18 19 22 23 26 27 30 31) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 18 19 22 23 26 27 30 31 18 19 22 23 26 27 30 31) 65535)))
       (vec_pack $I32X4 y y))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 17 19 21 23 25 27 29 31 17 19 21 23 25 27 29 31) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 17 19 21 23 25 27 29 31 17 19 21 23 25 27 29 31) 65535)))
       (vec_pack $I16X8 y y))
 
 ;; Special patterns that can be implemented via UNPACK HIGH.
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 _ _ _ _ 0 1 2 3 _ _ _ _ 4 5 6 7) 3855)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 _ _ _ _ 0 1 2 3 _ _ _ _ 4 5 6 7) 3855)))
       (vec_unpacku_high $I32X4 x))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 _ _ 0 1 _ _ 2 3 _ _ 4 5 _ _ 6 7) 13107)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 _ _ 0 1 _ _ 2 3 _ _ 4 5 _ _ 6 7) 13107)))
       (vec_unpacku_high $I16X8 x))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 _ 0 _ 1 _ 2 _ 3 _ 4 _ 5 _ 6 _ 7) 21845)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 _ 0 _ 1 _ 2 _ 3 _ 4 _ 5 _ 6 _ 7) 21845)))
       (vec_unpacku_high $I8X16 x))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 _ _ _ _ 16 17 18 19 _ _ _ _ 20 21 22 23) 3855)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 _ _ _ _ 16 17 18 19 _ _ _ _ 20 21 22 23) 3855)))
       (vec_unpacku_high $I32X4 y))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 _ _ 16 17 _ _ 18 19 _ _ 20 21 _ _ 22 23) 13107)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 _ _ 16 17 _ _ 18 19 _ _ 20 21 _ _ 22 23) 13107)))
       (vec_unpacku_high $I16X8 y))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 _ 16 _ 17 _ 18 _ 19 _ 20 _ 21 _ 22 _ 23) 21845)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 _ 16 _ 17 _ 18 _ 19 _ 20 _ 21 _ 22 _ 23) 21845)))
       (vec_unpacku_high $I8X16 y))
 
 ;; Special patterns that can be implemented via UNPACK LOW.
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 _ _ _ _ 8 9 10 11 _ _ _ _ 12 13 14 15) 3855)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 _ _ _ _ 8 9 10 11 _ _ _ _ 12 13 14 15) 3855)))
       (vec_unpacku_low $I32X4 x))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 _ _ 8 9 _ _ 10 11 _ _ 12 13 _ _ 14 15) 13107)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 _ _ 8 9 _ _ 10 11 _ _ 12 13 _ _ 14 15) 13107)))
       (vec_unpacku_low $I16X8 x))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 _ 8 _ 9 _ 10 _ 11 _ 12 _ 13 _ 14 _ 15) 21845)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 _ 8 _ 9 _ 10 _ 11 _ 12 _ 13 _ 14 _ 15) 21845)))
       (vec_unpacku_low $I8X16 x))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 _ _ _ _ 24 25 26 27 _ _ _ _ 28 29 30 31) 3855)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 _ _ _ _ 24 25 26 27 _ _ _ _ 28 29 30 31) 3855)))
       (vec_unpacku_low $I32X4 y))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 _ _ 24 25 _ _ 26 27 _ _ 28 29 _ _ 30 31) 13107)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 _ _ 24 25 _ _ 26 27 _ _ 28 29 _ _ 30 31) 13107)))
       (vec_unpacku_low $I16X8 y))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 _ 24 _ 25 _ 26 _ 27 _ 28 _ 29 _ 30 _ 31) 21845)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 _ 24 _ 25 _ 26 _ 27 _ 28 _ 29 _ 30 _ 31) 21845)))
       (vec_unpacku_low $I8X16 y))
 
 ;; Special patterns that can be implemented via PERMUTE DOUBLEWORD IMMEDIATE.
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 0 1 2 3 4 5 6 7 24 25 26 27 28 29 30 31) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 0 1 2 3 4 5 6 7 24 25 26 27 28 29 30 31) 65535)))
       (vec_permute_dw_imm $I8X16 x 0 y 1))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23) 65535)))
       (vec_permute_dw_imm $I8X16 x 1 y 0))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 16 17 18 19 20 21 22 23 8 9 10 11 12 13 14 15) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 16 17 18 19 20 21 22 23 8 9 10 11 12 13 14 15) 65535)))
       (vec_permute_dw_imm $I8X16 y 0 x 1))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 24 25 26 27 28 29 30 31 0 1 2 3 4 5 6 7) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 24 25 26 27 28 29 30 31 0 1 2 3 4 5 6 7) 65535)))
       (vec_permute_dw_imm $I8X16 y 1 x 0))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15) 65535)))
       (vec_permute_dw_imm $I8X16 x 0 x 1))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 8 9 10 11 12 13 14 15 0 1 2 3 4 5 6 7) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 8 9 10 11 12 13 14 15 0 1 2 3 4 5 6 7) 65535)))
       (vec_permute_dw_imm $I8X16 x 1 x 0))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31) 65535)))
       (vec_permute_dw_imm $I8X16 y 0 y 1))
-(rule (lower (shuffle x y (shuffle_mask (imm8x16 24 25 26 27 28 29 30 31 16 17 18 19 20 21 22 23) 65535)))
+(rule (lower (shuffle _ x y (shuffle_mask (imm8x16 24 25 26 27 28 29 30 31 16 17 18 19 20 21 22 23) 65535)))
       (vec_permute_dw_imm $I8X16 y 1 y 0))
 
 
@@ -2199,7 +2197,7 @@
 ;;     permute-lane-element := umin (16, swizzle-lane-element)
 ;; and pass a zero vector as second operand to the permute instruction.
 
-(rule 1 (lower (has_type (ty_vec128 ty) (swizzle x y)))
+(rule 1 (lower (has_type (ty_vec128 ty) (swizzle _ x y)))
       (if-let (LaneOrder.BigEndian) (lane_order))
       (vec_permute ty x (vec_imm ty 0)
          (vec_umin $I8X16 (vec_imm_splat $I8X16 16) y)))
@@ -2218,7 +2216,7 @@
 ;;     the input vector as second operand (covering lanes 16 .. 31)
 ;; to implement the required swizzle semantics.
 
-(rule (lower (has_type (ty_vec128 ty) (swizzle x y)))
+(rule (lower (has_type (ty_vec128 ty) (swizzle _ x y)))
       (if-let (LaneOrder.LittleEndian) (lane_order))
       (vec_permute ty (vec_imm ty 0) x
          (vec_umax $I8X16 (vec_imm_splat $I8X16 239)
@@ -2228,38 +2226,38 @@
 ;;;; Rules for `stack_addr` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Load the address of a stack slot.
-(rule (lower (has_type ty (stack_addr stack_slot offset)))
+(rule (lower (has_type ty (stack_addr _ stack_slot offset)))
       (stack_addr_impl ty stack_slot offset))
 
 
 ;;;; Rules for `func_addr` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Load the address of a function, target reachable via PC-relative instruction.
-(rule 1 (lower (func_addr (func_ref_data _ name (reloc_distance_near))))
+(rule 1 (lower (func_addr _ (func_ref_data _ name (reloc_distance_near))))
       (load_addr (memarg_symbol name 0 (memflags_trusted))))
 
 ;; Load the address of a function, general case.
-(rule (lower (func_addr (func_ref_data _ name _)))
+(rule (lower (func_addr _ (func_ref_data _ name _)))
       (load_symbol_reloc (SymbolReloc.Absolute name 0)))
 
 
 ;;;; Rules for `symbol_value` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Load the address of a symbol, target reachable via PC-relative instruction.
-(rule 1 (lower (symbol_value (symbol_value_data name (reloc_distance_near)
+(rule 1 (lower (symbol_value _ (symbol_value_data name (reloc_distance_near)
                                               off)))
       (if-let offset (memarg_symbol_offset off))
       (load_addr (memarg_symbol name offset (memflags_trusted))))
 
 ;; Load the address of a symbol, general case.
-(rule (lower (symbol_value (symbol_value_data name _ offset)))
+(rule (lower (symbol_value _ (symbol_value_data name _ offset)))
       (load_symbol_reloc (SymbolReloc.Absolute name offset)))
 
 
 ;;;; Rules for `tls_value` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Load the address of a TLS symbol (ELF general-dynamic model).
-(rule (lower (tls_value (symbol_value_data name _ 0)))
+(rule (lower (tls_value _ (symbol_value_data name _ 0)))
       (if (tls_model_is_elf_gd))
       (let ((symbol SymbolReloc (SymbolReloc.TlsGd name))
             (got Reg (load_addr (memarg_got)))
@@ -2272,7 +2270,6 @@
 (rule (lib_call_tls_get_offset got got_offset symbol)
       (let ((tls_offset WritableReg (temp_writable_reg $I64))
             (libcall LibCallInfo (lib_call_info_tls_get_offset tls_offset got got_offset symbol))
-            (_ Unit (lib_accumulate_outgoing_args_size libcall))
             (_ InstOutput (side_effect (lib_call libcall))))
         tls_offset))
 
@@ -2285,74 +2282,66 @@
 ;;;; Rules for `load` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Load 8-bit integers.
-(rule (lower (has_type $I8 (load flags addr offset)))
+(rule (lower (has_type $I8 (load _ flags addr offset)))
       (zext32_mem $I8 (lower_address flags addr offset)))
 
 ;; Load 16-bit big-endian integers.
-(rule (lower (has_type $I16 (load flags @ (bigendian) addr offset)))
+(rule (lower (has_type $I16 (load _ flags @ (bigendian) addr offset)))
       (zext32_mem $I16 (lower_address flags addr offset)))
 
 ;; Load 16-bit little-endian integers.
-(rule -1 (lower (has_type $I16 (load flags @ (littleendian) addr offset)))
+(rule -1 (lower (has_type $I16 (load _ flags @ (littleendian) addr offset)))
       (loadrev16 (lower_address flags addr offset)))
 
 ;; Load 32-bit big-endian integers.
-(rule (lower (has_type $I32 (load flags @ (bigendian) addr offset)))
+(rule (lower (has_type $I32 (load _ flags @ (bigendian) addr offset)))
       (load32 (lower_address flags addr offset)))
 
 ;; Load 32-bit little-endian integers.
-(rule -1 (lower (has_type $I32 (load flags @ (littleendian) addr offset)))
+(rule -1 (lower (has_type $I32 (load _ flags @ (littleendian) addr offset)))
       (loadrev32 (lower_address flags addr offset)))
 
 ;; Load 64-bit big-endian integers.
-(rule (lower (has_type $I64 (load flags @ (bigendian) addr offset)))
+(rule (lower (has_type $I64 (load _ flags @ (bigendian) addr offset)))
       (load64 (lower_address flags addr offset)))
 
 ;; Load 64-bit little-endian integers.
-(rule -1 (lower (has_type $I64 (load flags @ (littleendian) addr offset)))
-      (loadrev64 (lower_address flags addr offset)))
-
-;; Load 64-bit big-endian references.
-(rule (lower (has_type $R64 (load flags @ (bigendian) addr offset)))
-      (load64 (lower_address flags addr offset)))
-
-;; Load 64-bit little-endian references.
-(rule -1 (lower (has_type $R64 (load flags @ (littleendian) addr offset)))
+(rule -1 (lower (has_type $I64 (load _ flags @ (littleendian) addr offset)))
       (loadrev64 (lower_address flags addr offset)))
 
 ;; Load 32-bit big-endian floating-point values (as vector lane).
-(rule (lower (has_type $F32 (load flags @ (bigendian) addr offset)))
+(rule (lower (has_type $F32 (load _ flags @ (bigendian) addr offset)))
       (vec_load_lane_undef $F32X4 (lower_address flags addr offset) 0))
 
 ;; Load 32-bit little-endian floating-point values (as vector lane).
-(rule -1 (lower (has_type $F32 (load flags @ (littleendian) addr offset)))
+(rule -1 (lower (has_type $F32 (load _ flags @ (littleendian) addr offset)))
       (vec_load_lane_little_undef $F32X4 (lower_address flags addr offset) 0))
 
 ;; Load 64-bit big-endian floating-point values (as vector lane).
-(rule (lower (has_type $F64 (load flags @ (bigendian) addr offset)))
+(rule (lower (has_type $F64 (load _ flags @ (bigendian) addr offset)))
       (vec_load_lane_undef $F64X2 (lower_address flags addr offset) 0))
 
 ;; Load 64-bit little-endian floating-point values (as vector lane).
-(rule -1 (lower (has_type $F64 (load flags @ (littleendian) addr offset)))
+(rule -1 (lower (has_type $F64 (load _ flags @ (littleendian) addr offset)))
       (vec_load_lane_little_undef $F64X2 (lower_address flags addr offset) 0))
 
 ;; Load 128-bit big-endian vector values, BE lane order - direct load.
-(rule 4 (lower (has_type (vr128_ty ty) (load flags @ (bigendian) addr offset)))
+(rule 4 (lower (has_type (vr128_ty ty) (load _ flags @ (bigendian) addr offset)))
       (if-let (LaneOrder.BigEndian) (lane_order))
       (vec_load ty (lower_address flags addr offset)))
 
 ;; Load 128-bit little-endian vector values, BE lane order - byte-reversed load.
-(rule 3 (lower (has_type (vr128_ty ty) (load flags @ (littleendian) addr offset)))
+(rule 3 (lower (has_type (vr128_ty ty) (load _ flags @ (littleendian) addr offset)))
       (if-let (LaneOrder.BigEndian) (lane_order))
       (vec_load_byte_rev ty flags addr offset))
 
 ;; Load 128-bit big-endian vector values, LE lane order - element-reversed load.
-(rule 2 (lower (has_type (vr128_ty ty) (load flags @ (bigendian) addr offset)))
+(rule 2 (lower (has_type (vr128_ty ty) (load _ flags @ (bigendian) addr offset)))
       (if-let (LaneOrder.LittleEndian) (lane_order))
       (vec_load_elt_rev ty flags addr offset))
 
 ;; Load 128-bit little-endian vector values, LE lane order - fully-reversed load.
-(rule 1 (lower (has_type (vr128_ty ty) (load flags @ (littleendian) addr offset)))
+(rule 1 (lower (has_type (vr128_ty ty) (load _ flags @ (littleendian) addr offset)))
       (if-let (LaneOrder.LittleEndian) (lane_order))
       (vec_load_full_rev ty flags addr offset))
 
@@ -2445,22 +2434,22 @@
 ;;;; Rules for `uload8` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; 16- or 32-bit target types.
-(rule (lower (has_type (gpr32_ty _ty) (uload8 flags addr offset)))
+(rule (lower (has_type (gpr32_ty _ty) (uload8 _ flags addr offset)))
       (zext32_mem $I8 (lower_address flags addr offset)))
 
 ;; 64-bit target types.
-(rule 1 (lower (has_type (gpr64_ty _ty) (uload8 flags addr offset)))
+(rule 1 (lower (has_type (gpr64_ty _ty) (uload8 _ flags addr offset)))
       (zext64_mem $I8 (lower_address flags addr offset)))
 
 
 ;;;; Rules for `sload8` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; 16- or 32-bit target types.
-(rule (lower (has_type (gpr32_ty _ty) (sload8 flags addr offset)))
+(rule (lower (has_type (gpr32_ty _ty) (sload8 _ flags addr offset)))
       (sext32_mem $I8 (lower_address flags addr offset)))
 
 ;; 64-bit target types.
-(rule 1 (lower (has_type (gpr64_ty _ty) (sload8 flags addr offset)))
+(rule 1 (lower (has_type (gpr64_ty _ty) (sload8 _ flags addr offset)))
       (sext64_mem $I8 (lower_address flags addr offset)))
 
 
@@ -2468,23 +2457,23 @@
 
 ;; 32-bit target type, big-endian source value.
 (rule 3 (lower (has_type (gpr32_ty _ty)
-                       (uload16 flags @ (bigendian) addr offset)))
+                       (uload16 _ flags @ (bigendian) addr offset)))
       (zext32_mem $I16 (lower_address flags addr offset)))
 
 ;; 32-bit target type, little-endian source value (via explicit extension).
 (rule 1 (lower (has_type (gpr32_ty _ty)
-                       (uload16 flags @ (littleendian) addr offset)))
+                       (uload16 _ flags @ (littleendian) addr offset)))
       (let ((reg16 Reg (loadrev16 (lower_address flags addr offset))))
         (zext32_reg $I16 reg16)))
 
 ;; 64-bit target type, big-endian source value.
 (rule 4 (lower (has_type (gpr64_ty _ty)
-                       (uload16 flags @ (bigendian) addr offset)))
+                       (uload16 _ flags @ (bigendian) addr offset)))
       (zext64_mem $I16 (lower_address flags addr offset)))
 
 ;; 64-bit target type, little-endian source value (via explicit extension).
 (rule 2 (lower (has_type (gpr64_ty _ty)
-                       (uload16 flags @ (littleendian) addr offset)))
+                       (uload16 _ flags @ (littleendian) addr offset)))
       (let ((reg16 Reg (loadrev16 (lower_address flags addr offset))))
         (zext64_reg $I16 reg16)))
 
@@ -2493,23 +2482,23 @@
 
 ;; 32-bit target type, big-endian source value.
 (rule 2 (lower (has_type (gpr32_ty _ty)
-                       (sload16 flags @ (bigendian) addr offset)))
+                       (sload16 _ flags @ (bigendian) addr offset)))
       (sext32_mem $I16 (lower_address flags addr offset)))
 
 ;; 32-bit target type, little-endian source value (via explicit extension).
 (rule 0 (lower (has_type (gpr32_ty _ty)
-                       (sload16 flags @ (littleendian) addr offset)))
+                       (sload16 _ flags @ (littleendian) addr offset)))
       (let ((reg16 Reg (loadrev16 (lower_address flags addr offset))))
         (sext32_reg $I16 reg16)))
 
 ;; 64-bit target type, big-endian source value.
 (rule 3 (lower (has_type (gpr64_ty _ty)
-                       (sload16 flags @ (bigendian) addr offset)))
+                       (sload16 _ flags @ (bigendian) addr offset)))
       (sext64_mem $I16 (lower_address flags addr offset)))
 
 ;; 64-bit target type, little-endian source value (via explicit extension).
 (rule 1 (lower (has_type (gpr64_ty _ty)
-                       (sload16 flags @ (littleendian) addr offset)))
+                       (sload16 _ flags @ (littleendian) addr offset)))
       (let ((reg16 Reg (loadrev16 (lower_address flags addr offset))))
         (sext64_reg $I16 reg16)))
 
@@ -2518,12 +2507,12 @@
 
 ;; 64-bit target type, big-endian source value.
 (rule 1 (lower (has_type (gpr64_ty _ty)
-                       (uload32 flags @ (bigendian) addr offset)))
+                       (uload32 _ flags @ (bigendian) addr offset)))
       (zext64_mem $I32 (lower_address flags addr offset)))
 
 ;; 64-bit target type, little-endian source value (via explicit extension).
 (rule (lower (has_type (gpr64_ty _ty)
-                       (uload32 flags @ (littleendian) addr offset)))
+                       (uload32 _ flags @ (littleendian) addr offset)))
       (let ((reg32 Reg (loadrev32 (lower_address flags addr offset))))
         (zext64_reg $I32 reg32)))
 
@@ -2532,12 +2521,12 @@
 
 ;; 64-bit target type, big-endian source value.
 (rule 1 (lower (has_type (gpr64_ty _ty)
-                       (sload32 flags @ (bigendian) addr offset)))
+                       (sload32 _ flags @ (bigendian) addr offset)))
       (sext64_mem $I32 (lower_address flags addr offset)))
 
 ;; 64-bit target type, little-endian source value (via explicit extension).
 (rule (lower (has_type (gpr64_ty _ty)
-                       (sload32 flags @ (littleendian) addr offset)))
+                       (sload32 _ flags @ (littleendian) addr offset)))
       (let ((reg32 Reg (loadrev32 (lower_address flags addr offset))))
         (sext64_reg $I32 reg32)))
 
@@ -2545,27 +2534,27 @@
 ;;;; Rules for `uloadNxM` and `sloadNxM` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Unsigned 8->16 bit extension.
-(rule (lower (has_type $I16X8 (uload8x8 flags addr offset)))
+(rule (lower (has_type $I16X8 (uload8x8 _ flags addr offset)))
       (vec_unpacku_high $I8X16 (load_v64 $I8X16 flags addr offset)))
 
 ;; Signed 8->16 bit extension.
-(rule (lower (has_type $I16X8 (sload8x8 flags addr offset)))
+(rule (lower (has_type $I16X8 (sload8x8 _ flags addr offset)))
       (vec_unpacks_high $I8X16 (load_v64 $I8X16 flags addr offset)))
 
 ;; Unsigned 16->32 bit extension.
-(rule (lower (has_type $I32X4 (uload16x4 flags addr offset)))
+(rule (lower (has_type $I32X4 (uload16x4 _ flags addr offset)))
       (vec_unpacku_high $I16X8 (load_v64 $I16X8 flags addr offset)))
 
 ;; Signed 16->32 bit extension.
-(rule (lower (has_type $I32X4 (sload16x4 flags addr offset)))
+(rule (lower (has_type $I32X4 (sload16x4 _ flags addr offset)))
       (vec_unpacks_high $I16X8 (load_v64 $I16X8 flags addr offset)))
 
 ;; Unsigned 32->64 bit extension.
-(rule (lower (has_type $I64X2 (uload32x2 flags addr offset)))
+(rule (lower (has_type $I64X2 (uload32x2 _ flags addr offset)))
       (vec_unpacku_high $I32X4 (load_v64 $I32X4 flags addr offset)))
 
 ;; Signed 32->64 bit extension.
-(rule (lower (has_type $I64X2 (sload32x2 flags addr offset)))
+(rule (lower (has_type $I64X2 (sload32x2 _ flags addr offset)))
       (vec_unpacks_high $I32X4 (load_v64 $I32X4 flags addr offset)))
 
 
@@ -2638,10 +2627,6 @@
 (rule (lower (store flags val @ (value_type $I64) addr offset))
       (side_effect (istore64_impl flags val addr offset)))
 
-;; Store 64-bit reference type, main lowering entry point.
-(rule (lower (store flags val @ (value_type $R64) addr offset))
-      (side_effect (istore64_impl flags val addr offset)))
-
 ;; Store 32-bit big-endian floating-point type (as vector lane).
 (rule -1 (lower (store flags @ (bigendian)
                     val @ (value_type $F32) addr offset))
@@ -2866,49 +2851,49 @@
 
 ;; Atomic AND for 32/64-bit big-endian types, using a single instruction.
 (rule 1 (lower (has_type (ty_32_or_64 ty)
-                (atomic_rmw flags @ (bigendian) (AtomicRmwOp.And) addr src)))
+                (atomic_rmw _ flags @ (bigendian) (AtomicRmwOp.And) addr src)))
       (atomic_rmw_and ty (put_in_reg src)
                       (lower_address flags addr (zero_offset))))
 
 ;; Atomic AND for 32/64-bit big-endian types, using byte-swapped input/output.
 (rule (lower (has_type (ty_32_or_64 ty)
-               (atomic_rmw flags @ (littleendian) (AtomicRmwOp.And) addr src)))
+               (atomic_rmw _ flags @ (littleendian) (AtomicRmwOp.And) addr src)))
       (bswap_reg ty (atomic_rmw_and ty (bswap_reg ty (put_in_reg src))
                                     (lower_address flags addr (zero_offset)))))
 
 ;; Atomic OR for 32/64-bit big-endian types, using a single instruction.
 (rule 1 (lower (has_type (ty_32_or_64 ty)
-               (atomic_rmw flags @ (bigendian) (AtomicRmwOp.Or) addr src)))
+               (atomic_rmw _ flags @ (bigendian) (AtomicRmwOp.Or) addr src)))
       (atomic_rmw_or ty (put_in_reg src)
                      (lower_address flags addr (zero_offset))))
 
 ;; Atomic OR for 32/64-bit little-endian types, using byte-swapped input/output.
 (rule (lower (has_type (ty_32_or_64 ty)
-               (atomic_rmw flags @ (littleendian) (AtomicRmwOp.Or) addr src)))
+               (atomic_rmw _ flags @ (littleendian) (AtomicRmwOp.Or) addr src)))
       (bswap_reg ty (atomic_rmw_or ty (bswap_reg ty (put_in_reg src))
                                    (lower_address flags addr (zero_offset)))))
 
 ;; Atomic XOR for 32/64-bit big-endian types, using a single instruction.
 (rule 1 (lower (has_type (ty_32_or_64 ty)
-               (atomic_rmw flags @ (bigendian) (AtomicRmwOp.Xor) addr src)))
+               (atomic_rmw _ flags @ (bigendian) (AtomicRmwOp.Xor) addr src)))
       (atomic_rmw_xor ty (put_in_reg src)
                       (lower_address flags addr (zero_offset))))
 
 ;; Atomic XOR for 32/64-bit little-endian types, using byte-swapped input/output.
 (rule (lower (has_type (ty_32_or_64 ty)
-               (atomic_rmw flags @ (littleendian) (AtomicRmwOp.Xor) addr src)))
+               (atomic_rmw _ flags @ (littleendian) (AtomicRmwOp.Xor) addr src)))
       (bswap_reg ty (atomic_rmw_xor ty (bswap_reg ty (put_in_reg src))
                                     (lower_address flags addr (zero_offset)))))
 
 ;; Atomic ADD for 32/64-bit big-endian types, using a single instruction.
 (rule (lower (has_type (ty_32_or_64 ty)
-               (atomic_rmw flags @ (bigendian) (AtomicRmwOp.Add) addr src)))
+               (atomic_rmw _ flags @ (bigendian) (AtomicRmwOp.Add) addr src)))
       (atomic_rmw_add ty (put_in_reg src)
                       (lower_address flags addr (zero_offset))))
 
 ;; Atomic SUB for 32/64-bit big-endian types, using atomic ADD with negated input.
 (rule (lower (has_type (ty_32_or_64 ty)
-               (atomic_rmw flags @ (bigendian) (AtomicRmwOp.Sub) addr src)))
+               (atomic_rmw _ flags @ (bigendian) (AtomicRmwOp.Sub) addr src)))
       (atomic_rmw_add ty (neg_reg ty (put_in_reg src))
                       (lower_address flags addr (zero_offset))))
 
@@ -2916,7 +2901,7 @@
 ;; Atomic operations that require a compare-and-swap loop.
 
 ;; Operations for 32/64-bit types can use a fullword compare-and-swap loop.
-(rule -1 (lower (has_type (ty_32_or_64 ty) (atomic_rmw flags op addr src)))
+(rule -1 (lower (has_type (ty_32_or_64 ty) (atomic_rmw _ flags op addr src)))
       (let ((src_reg Reg (put_in_reg src))
             (addr_reg Reg (put_in_reg addr))
             ;; Create body of compare-and-swap loop.
@@ -2928,7 +2913,7 @@
         (casloop ib ty flags addr_reg val1)))
 
 ;; Operations for 8/16-bit types must operate on the surrounding aligned word.
-(rule -2 (lower (has_type (ty_8_or_16 ty) (atomic_rmw flags op addr src)))
+(rule -2 (lower (has_type (ty_8_or_16 ty) (atomic_rmw _ flags op addr src)))
       (let ((src_reg Reg (put_in_reg src))
             (addr_reg Reg (put_in_reg addr))
             ;; Prepare access to surrounding aligned word.
@@ -3122,20 +3107,20 @@
 
 ;; 32/64-bit big-endian atomic compare-and-swap instruction.
 (rule 2 (lower (has_type (ty_32_or_64 ty)
-               (atomic_cas flags @ (bigendian) addr src1 src2)))
+               (atomic_cas _ flags @ (bigendian) addr src1 src2)))
       (atomic_cas_impl ty (put_in_reg src1) (put_in_reg src2)
                        (lower_address flags addr (zero_offset))))
 
 ;; 32/64-bit little-endian atomic compare-and-swap instruction.
 ;; Implemented by byte-swapping old/new inputs and the output.
 (rule 1 (lower (has_type (ty_32_or_64 ty)
-               (atomic_cas flags @ (littleendian) addr src1 src2)))
+               (atomic_cas _ flags @ (littleendian) addr src1 src2)))
       (bswap_reg ty (atomic_cas_impl ty (bswap_reg ty (put_in_reg src1))
                                      (bswap_reg ty (put_in_reg src2))
                                      (lower_address flags addr (zero_offset)))))
 
 ;; 8/16-bit atomic compare-and-swap implemented via loop.
-(rule (lower (has_type (ty_8_or_16 ty) (atomic_cas flags addr src1 src2)))
+(rule (lower (has_type (ty_8_or_16 ty) (atomic_cas _ flags addr src1 src2)))
       (let ((src1_reg Reg (put_in_reg src1))
             (src2_reg Reg (put_in_reg src2))
             (addr_reg Reg (put_in_reg addr))
@@ -3192,31 +3177,31 @@
 ;; Atomic loads can be implemented via regular loads on this platform.
 
 ;; 8-bit atomic load.
-(rule (lower (has_type $I8 (atomic_load flags addr)))
+(rule (lower (has_type $I8 (atomic_load _ flags addr)))
       (zext32_mem $I8 (lower_address flags addr (zero_offset))))
 
 ;; 16-bit big-endian atomic load.
-(rule 1 (lower (has_type $I16 (atomic_load flags @ (bigendian) addr)))
+(rule 1 (lower (has_type $I16 (atomic_load _ flags @ (bigendian) addr)))
       (zext32_mem $I16 (lower_address flags addr (zero_offset))))
 
 ;; 16-bit little-endian atomic load.
-(rule (lower (has_type $I16 (atomic_load flags @ (littleendian) addr)))
+(rule (lower (has_type $I16 (atomic_load _ flags @ (littleendian) addr)))
       (loadrev16 (lower_address flags addr (zero_offset))))
 
 ;; 32-bit big-endian atomic load.
-(rule 1 (lower (has_type $I32 (atomic_load flags @ (bigendian) addr)))
+(rule 1 (lower (has_type $I32 (atomic_load _ flags @ (bigendian) addr)))
       (load32 (lower_address flags addr (zero_offset))))
 
 ;; 32-bit little-endian atomic load.
-(rule (lower (has_type $I32 (atomic_load flags @ (littleendian) addr)))
+(rule (lower (has_type $I32 (atomic_load _ flags @ (littleendian) addr)))
       (loadrev32 (lower_address flags addr (zero_offset))))
 
 ;; 64-bit big-endian atomic load.
-(rule 1 (lower (has_type $I64 (atomic_load flags @ (bigendian) addr)))
+(rule 1 (lower (has_type $I64 (atomic_load _ flags @ (bigendian) addr)))
       (load64 (lower_address flags addr (zero_offset))))
 
 ;; 64-bit little-endian atomic load.
-(rule (lower (has_type $I64 (atomic_load flags @ (littleendian) addr)))
+(rule (lower (has_type $I64 (atomic_load _ flags @ (littleendian) addr)))
       (loadrev64 (lower_address flags addr (zero_offset))))
 
 
@@ -3281,7 +3266,7 @@
 ;; Main `icmp` entry point.  Generate a `ProducesBool` capturing the
 ;; integer comparison and immediately lower it to a 0/1 integer result.
 ;; In this case, it is safe to sink memory loads.
-(rule -1 (lower (has_type (fits_in_64 ty) (icmp int_cc x y)))
+(rule -1 (lower (has_type (fits_in_64 ty) (icmp _ int_cc x y)))
       (lower_bool ty (icmp_val $true int_cc x y)))
 
 
@@ -3403,25 +3388,25 @@
 ;; Vector `icmp` produces a boolean vector.
 ;; We need to handle the various IntCC flags separately here.
 
-(rule (lower (has_type (ty_vec128 ty) (icmp (IntCC.Equal) x y)))
+(rule (lower (has_type (ty_vec128 ty) (icmp _ (IntCC.Equal) x y)))
       (vec_cmpeq ty x y))
-(rule (lower (has_type (ty_vec128 ty) (icmp (IntCC.NotEqual) x y)))
+(rule (lower (has_type (ty_vec128 ty) (icmp _ (IntCC.NotEqual) x y)))
       (vec_not ty (vec_cmpeq ty x y)))
-(rule (lower (has_type (ty_vec128 ty) (icmp (IntCC.SignedGreaterThan) x y)))
+(rule (lower (has_type (ty_vec128 ty) (icmp _ (IntCC.SignedGreaterThan) x y)))
       (vec_cmph ty x y))
-(rule (lower (has_type (ty_vec128 ty) (icmp (IntCC.SignedLessThanOrEqual) x y)))
+(rule (lower (has_type (ty_vec128 ty) (icmp _ (IntCC.SignedLessThanOrEqual) x y)))
       (vec_not ty (vec_cmph ty x y)))
-(rule (lower (has_type (ty_vec128 ty) (icmp (IntCC.SignedLessThan) x y)))
+(rule (lower (has_type (ty_vec128 ty) (icmp _ (IntCC.SignedLessThan) x y)))
       (vec_cmph ty y x))
-(rule (lower (has_type (ty_vec128 ty) (icmp (IntCC.SignedGreaterThanOrEqual) x y)))
+(rule (lower (has_type (ty_vec128 ty) (icmp _ (IntCC.SignedGreaterThanOrEqual) x y)))
       (vec_not ty (vec_cmph ty y x)))
-(rule (lower (has_type (ty_vec128 ty) (icmp (IntCC.UnsignedGreaterThan) x y)))
+(rule (lower (has_type (ty_vec128 ty) (icmp _ (IntCC.UnsignedGreaterThan) x y)))
       (vec_cmphl ty x y))
-(rule (lower (has_type (ty_vec128 ty) (icmp (IntCC.UnsignedLessThanOrEqual) x y)))
+(rule (lower (has_type (ty_vec128 ty) (icmp _ (IntCC.UnsignedLessThanOrEqual) x y)))
       (vec_not ty (vec_cmphl ty x y)))
-(rule (lower (has_type (ty_vec128 ty) (icmp (IntCC.UnsignedLessThan) x y)))
+(rule (lower (has_type (ty_vec128 ty) (icmp _ (IntCC.UnsignedLessThan) x y)))
       (vec_cmphl ty y x))
-(rule (lower (has_type (ty_vec128 ty) (icmp (IntCC.UnsignedGreaterThanOrEqual) x y)))
+(rule (lower (has_type (ty_vec128 ty) (icmp _ (IntCC.UnsignedGreaterThanOrEqual) x y)))
       (vec_not ty (vec_cmphl ty y x)))
 
 
@@ -3429,7 +3414,7 @@
 
 ;; Main `fcmp` entry point.  Generate a `ProducesBool` capturing the
 ;; integer comparison and immediately lower it to a 0/1 integer result.
-(rule -1 (lower (has_type (fits_in_64 ty) (fcmp float_cc x y)))
+(rule -1 (lower (has_type (fits_in_64 ty) (fcmp _ float_cc x y)))
       (lower_bool ty (fcmp_val float_cc x y)))
 
 ;; Return a `ProducesBool` to implement any floating-point comparison.
@@ -3441,33 +3426,33 @@
 ;; Vector `fcmp` produces a boolean vector.
 ;; We need to handle the various FloatCC flags separately here.
 
-(rule (lower (has_type (ty_vec128 ty) (fcmp (FloatCC.Equal) x y)))
+(rule (lower (has_type (ty_vec128 ty) (fcmp _ (FloatCC.Equal) x y)))
       (vec_fcmpeq ty x y))
-(rule (lower (has_type (ty_vec128 ty) (fcmp (FloatCC.NotEqual) x y)))
+(rule (lower (has_type (ty_vec128 ty) (fcmp _ (FloatCC.NotEqual) x y)))
       (vec_not ty (vec_fcmpeq ty x y)))
-(rule (lower (has_type (ty_vec128 ty) (fcmp (FloatCC.GreaterThan) x y)))
+(rule (lower (has_type (ty_vec128 ty) (fcmp _ (FloatCC.GreaterThan) x y)))
       (vec_fcmph ty x y))
-(rule (lower (has_type (ty_vec128 ty) (fcmp (FloatCC.UnorderedOrLessThanOrEqual) x y)))
+(rule (lower (has_type (ty_vec128 ty) (fcmp _ (FloatCC.UnorderedOrLessThanOrEqual) x y)))
       (vec_not ty (vec_fcmph ty x y)))
-(rule (lower (has_type (ty_vec128 ty) (fcmp (FloatCC.GreaterThanOrEqual) x y)))
+(rule (lower (has_type (ty_vec128 ty) (fcmp _ (FloatCC.GreaterThanOrEqual) x y)))
       (vec_fcmphe ty x y))
-(rule (lower (has_type (ty_vec128 ty) (fcmp (FloatCC.UnorderedOrLessThan) x y)))
+(rule (lower (has_type (ty_vec128 ty) (fcmp _ (FloatCC.UnorderedOrLessThan) x y)))
       (vec_not ty (vec_fcmphe ty x y)))
-(rule (lower (has_type (ty_vec128 ty) (fcmp (FloatCC.LessThan) x y)))
+(rule (lower (has_type (ty_vec128 ty) (fcmp _ (FloatCC.LessThan) x y)))
       (vec_fcmph ty y x))
-(rule (lower (has_type (ty_vec128 ty) (fcmp (FloatCC.UnorderedOrGreaterThanOrEqual) x y)))
+(rule (lower (has_type (ty_vec128 ty) (fcmp _ (FloatCC.UnorderedOrGreaterThanOrEqual) x y)))
       (vec_not ty (vec_fcmph ty y x)))
-(rule (lower (has_type (ty_vec128 ty) (fcmp (FloatCC.LessThanOrEqual) x y)))
+(rule (lower (has_type (ty_vec128 ty) (fcmp _ (FloatCC.LessThanOrEqual) x y)))
       (vec_fcmphe ty y x))
-(rule (lower (has_type (ty_vec128 ty) (fcmp (FloatCC.UnorderedOrGreaterThan) x y)))
+(rule (lower (has_type (ty_vec128 ty) (fcmp _ (FloatCC.UnorderedOrGreaterThan) x y)))
       (vec_not ty (vec_fcmphe ty y x)))
-(rule (lower (has_type (ty_vec128 ty) (fcmp (FloatCC.Ordered) x y)))
+(rule (lower (has_type (ty_vec128 ty) (fcmp _ (FloatCC.Ordered) x y)))
       (vec_or ty (vec_fcmphe ty x y) (vec_fcmphe ty y x)))
-(rule (lower (has_type (ty_vec128 ty) (fcmp (FloatCC.Unordered) x y)))
+(rule (lower (has_type (ty_vec128 ty) (fcmp _ (FloatCC.Unordered) x y)))
       (vec_not_or ty (vec_fcmphe ty x y) (vec_fcmphe ty y x)))
-(rule (lower (has_type (ty_vec128 ty) (fcmp (FloatCC.OrderedNotEqual) x y)))
+(rule (lower (has_type (ty_vec128 ty) (fcmp _ (FloatCC.OrderedNotEqual) x y)))
       (vec_or ty (vec_fcmph ty x y) (vec_fcmph ty y x)))
-(rule (lower (has_type (ty_vec128 ty) (fcmp (FloatCC.UnorderedOrEqual) x y)))
+(rule (lower (has_type (ty_vec128 ty) (fcmp _ (FloatCC.UnorderedOrEqual) x y)))
       (vec_not_or ty (vec_fcmph ty x y) (vec_fcmph ty y x)))
 
 
@@ -3475,7 +3460,7 @@
 
 ;; Main `vall_true` entry point.  Generate a `ProducesBool` capturing the
 ;; comparison and immediately lower it to a 0/1 integer result.
-(rule (lower (has_type (fits_in_64 ty) (vall_true x)))
+(rule (lower (has_type (fits_in_64 ty) (vall_true _ x)))
       (lower_bool ty (vall_true_val x)))
 
 ;; Return a `ProducesBool` to implement `vall_true`.
@@ -3485,66 +3470,66 @@
             (floatcc_as_cond (FloatCC.Unordered))))
 
 ;; Short-circuit `vall_true` on the result of a `icmp`.
-(rule (vall_true_val (has_type ty (icmp (IntCC.Equal) x y)))
+(rule (vall_true_val (has_type ty (icmp _ (IntCC.Equal) x y)))
       (bool (vec_cmpeqs ty x y)
             (floatcc_as_cond (FloatCC.Equal))))
-(rule (vall_true_val (has_type ty (icmp (IntCC.NotEqual) x y)))
+(rule (vall_true_val (has_type ty (icmp _ (IntCC.NotEqual) x y)))
       (bool (vec_cmpeqs ty x y)
             (floatcc_as_cond (FloatCC.Unordered))))
-(rule (vall_true_val (has_type ty (icmp (IntCC.SignedGreaterThan) x y)))
+(rule (vall_true_val (has_type ty (icmp _ (IntCC.SignedGreaterThan) x y)))
       (bool (vec_cmphs ty x y)
             (floatcc_as_cond (FloatCC.Equal))))
-(rule (vall_true_val (has_type ty (icmp (IntCC.SignedLessThanOrEqual) x y)))
+(rule (vall_true_val (has_type ty (icmp _ (IntCC.SignedLessThanOrEqual) x y)))
       (bool (vec_cmphs ty x y)
             (floatcc_as_cond (FloatCC.Unordered))))
-(rule (vall_true_val (has_type ty (icmp (IntCC.SignedLessThan) x y)))
+(rule (vall_true_val (has_type ty (icmp _ (IntCC.SignedLessThan) x y)))
       (bool (vec_cmphs ty y x)
             (floatcc_as_cond (FloatCC.Equal))))
-(rule (vall_true_val (has_type ty (icmp (IntCC.SignedGreaterThanOrEqual) x y)))
+(rule (vall_true_val (has_type ty (icmp _ (IntCC.SignedGreaterThanOrEqual) x y)))
       (bool (vec_cmphs ty y x)
             (floatcc_as_cond (FloatCC.Unordered))))
-(rule (vall_true_val (has_type ty (icmp (IntCC.UnsignedGreaterThan) x y)))
+(rule (vall_true_val (has_type ty (icmp _ (IntCC.UnsignedGreaterThan) x y)))
       (bool (vec_cmphls ty x y)
             (floatcc_as_cond (FloatCC.Equal))))
-(rule (vall_true_val (has_type ty (icmp (IntCC.UnsignedLessThanOrEqual) x y)))
+(rule (vall_true_val (has_type ty (icmp _ (IntCC.UnsignedLessThanOrEqual) x y)))
       (bool (vec_cmphls ty x y)
             (floatcc_as_cond (FloatCC.Unordered))))
-(rule (vall_true_val (has_type ty (icmp (IntCC.UnsignedLessThan) x y)))
+(rule (vall_true_val (has_type ty (icmp _ (IntCC.UnsignedLessThan) x y)))
       (bool (vec_cmphls ty y x)
             (floatcc_as_cond (FloatCC.Equal))))
-(rule (vall_true_val (has_type ty (icmp (IntCC.UnsignedGreaterThanOrEqual) x y)))
+(rule (vall_true_val (has_type ty (icmp _ (IntCC.UnsignedGreaterThanOrEqual) x y)))
       (bool (vec_cmphls ty y x)
             (floatcc_as_cond (FloatCC.Unordered))))
 
 ;; Short-circuit `vall_true` on the result of a `fcmp` where possible.
-(rule (vall_true_val (has_type ty (fcmp (FloatCC.Equal) x y)))
+(rule (vall_true_val (has_type ty (fcmp _ (FloatCC.Equal) x y)))
       (bool (vec_fcmpeqs ty x y)
             (floatcc_as_cond (FloatCC.Equal))))
-(rule (vall_true_val (has_type ty (fcmp (FloatCC.NotEqual) x y)))
+(rule (vall_true_val (has_type ty (fcmp _ (FloatCC.NotEqual) x y)))
       (bool (vec_fcmpeqs ty x y)
             (floatcc_as_cond (FloatCC.Unordered))))
-(rule (vall_true_val (has_type ty (fcmp (FloatCC.GreaterThan) x y)))
+(rule (vall_true_val (has_type ty (fcmp _ (FloatCC.GreaterThan) x y)))
       (bool (vec_fcmphs ty x y)
             (floatcc_as_cond (FloatCC.Equal))))
-(rule (vall_true_val (has_type ty (fcmp (FloatCC.UnorderedOrLessThanOrEqual) x y)))
+(rule (vall_true_val (has_type ty (fcmp _ (FloatCC.UnorderedOrLessThanOrEqual) x y)))
       (bool (vec_fcmphs ty x y)
             (floatcc_as_cond (FloatCC.Unordered))))
-(rule (vall_true_val (has_type ty (fcmp (FloatCC.GreaterThanOrEqual) x y)))
+(rule (vall_true_val (has_type ty (fcmp _ (FloatCC.GreaterThanOrEqual) x y)))
       (bool (vec_fcmphes ty x y)
             (floatcc_as_cond (FloatCC.Equal))))
-(rule (vall_true_val (has_type ty (fcmp (FloatCC.UnorderedOrLessThan) x y)))
+(rule (vall_true_val (has_type ty (fcmp _ (FloatCC.UnorderedOrLessThan) x y)))
       (bool (vec_fcmphes ty x y)
             (floatcc_as_cond (FloatCC.Unordered))))
-(rule (vall_true_val (has_type ty (fcmp (FloatCC.LessThan) x y)))
+(rule (vall_true_val (has_type ty (fcmp _ (FloatCC.LessThan) x y)))
       (bool (vec_fcmphs ty y x)
             (floatcc_as_cond (FloatCC.Equal))))
-(rule (vall_true_val (has_type ty (fcmp (FloatCC.UnorderedOrGreaterThanOrEqual) x y)))
+(rule (vall_true_val (has_type ty (fcmp _ (FloatCC.UnorderedOrGreaterThanOrEqual) x y)))
       (bool (vec_fcmphs ty y x)
             (floatcc_as_cond (FloatCC.Unordered))))
-(rule (vall_true_val (has_type ty (fcmp (FloatCC.LessThanOrEqual) x y)))
+(rule (vall_true_val (has_type ty (fcmp _ (FloatCC.LessThanOrEqual) x y)))
       (bool (vec_fcmphes ty y x)
             (floatcc_as_cond (FloatCC.Equal))))
-(rule (vall_true_val (has_type ty (fcmp (FloatCC.UnorderedOrGreaterThan) x y)))
+(rule (vall_true_val (has_type ty (fcmp _ (FloatCC.UnorderedOrGreaterThan) x y)))
       (bool (vec_fcmphes ty y x)
             (floatcc_as_cond (FloatCC.Unordered))))
 
@@ -3553,7 +3538,7 @@
 
 ;; Main `vany_true` entry point.  Generate a `ProducesBool` capturing the
 ;; comparison and immediately lower it to a 0/1 integer result.
-(rule (lower (has_type (fits_in_64 ty) (vany_true x)))
+(rule (lower (has_type (fits_in_64 ty) (vany_true _ x)))
       (lower_bool ty (vany_true_val x)))
 
 ;; Return a `ProducesBool` to implement `vany_true`.
@@ -3563,131 +3548,117 @@
             (floatcc_as_cond (FloatCC.NotEqual))))
 
 ;; Short-circuit `vany_true` on the result of a `icmp`.
-(rule (vany_true_val (has_type ty (icmp (IntCC.Equal) x y)))
+(rule (vany_true_val (has_type ty (icmp _ (IntCC.Equal) x y)))
       (bool (vec_cmpeqs ty x y)
             (floatcc_as_cond (FloatCC.Ordered))))
-(rule (vany_true_val (has_type ty (icmp (IntCC.NotEqual) x y)))
+(rule (vany_true_val (has_type ty (icmp _ (IntCC.NotEqual) x y)))
       (bool (vec_cmpeqs ty x y)
             (floatcc_as_cond (FloatCC.NotEqual))))
-(rule (vany_true_val (has_type ty (icmp (IntCC.SignedGreaterThan) x y)))
+(rule (vany_true_val (has_type ty (icmp _ (IntCC.SignedGreaterThan) x y)))
       (bool (vec_cmphs ty x y)
             (floatcc_as_cond (FloatCC.Ordered))))
-(rule (vany_true_val (has_type ty (icmp (IntCC.SignedLessThanOrEqual) x y)))
+(rule (vany_true_val (has_type ty (icmp _ (IntCC.SignedLessThanOrEqual) x y)))
       (bool (vec_cmphs ty x y)
             (floatcc_as_cond (FloatCC.NotEqual))))
-(rule (vany_true_val (has_type ty (icmp (IntCC.SignedLessThan) x y)))
+(rule (vany_true_val (has_type ty (icmp _ (IntCC.SignedLessThan) x y)))
       (bool (vec_cmphs ty y x)
             (floatcc_as_cond (FloatCC.Ordered))))
-(rule (vany_true_val (has_type ty (icmp (IntCC.SignedGreaterThanOrEqual) x y)))
+(rule (vany_true_val (has_type ty (icmp _ (IntCC.SignedGreaterThanOrEqual) x y)))
       (bool (vec_cmphs ty y x)
             (floatcc_as_cond (FloatCC.NotEqual))))
-(rule (vany_true_val (has_type ty (icmp (IntCC.UnsignedGreaterThan) x y)))
+(rule (vany_true_val (has_type ty (icmp _ (IntCC.UnsignedGreaterThan) x y)))
       (bool (vec_cmphls ty x y)
             (floatcc_as_cond (FloatCC.Ordered))))
-(rule (vany_true_val (has_type ty (icmp (IntCC.UnsignedLessThanOrEqual) x y)))
+(rule (vany_true_val (has_type ty (icmp _ (IntCC.UnsignedLessThanOrEqual) x y)))
       (bool (vec_cmphls ty x y)
             (floatcc_as_cond (FloatCC.NotEqual))))
-(rule (vany_true_val (has_type ty (icmp (IntCC.UnsignedLessThan) x y)))
+(rule (vany_true_val (has_type ty (icmp _ (IntCC.UnsignedLessThan) x y)))
       (bool (vec_cmphls ty y x)
             (floatcc_as_cond (FloatCC.Ordered))))
-(rule (vany_true_val (has_type ty (icmp (IntCC.UnsignedGreaterThanOrEqual) x y)))
+(rule (vany_true_val (has_type ty (icmp _ (IntCC.UnsignedGreaterThanOrEqual) x y)))
       (bool (vec_cmphls ty y x)
             (floatcc_as_cond (FloatCC.NotEqual))))
 
 ;; Short-circuit `vany_true` on the result of a `fcmp` where possible.
-(rule (vany_true_val (has_type ty (fcmp (FloatCC.Equal) x y)))
+(rule (vany_true_val (has_type ty (fcmp _ (FloatCC.Equal) x y)))
       (bool (vec_fcmpeqs ty x y)
             (floatcc_as_cond (FloatCC.Ordered))))
-(rule (vany_true_val (has_type ty (fcmp (FloatCC.NotEqual) x y)))
+(rule (vany_true_val (has_type ty (fcmp _ (FloatCC.NotEqual) x y)))
       (bool (vec_fcmpeqs ty x y)
             (floatcc_as_cond (FloatCC.NotEqual))))
-(rule (vany_true_val (has_type ty (fcmp (FloatCC.GreaterThan) x y)))
+(rule (vany_true_val (has_type ty (fcmp _ (FloatCC.GreaterThan) x y)))
       (bool (vec_fcmphs ty x y)
             (floatcc_as_cond (FloatCC.Ordered))))
-(rule (vany_true_val (has_type ty (fcmp (FloatCC.UnorderedOrLessThanOrEqual) x y)))
+(rule (vany_true_val (has_type ty (fcmp _ (FloatCC.UnorderedOrLessThanOrEqual) x y)))
       (bool (vec_fcmphs ty x y)
             (floatcc_as_cond (FloatCC.NotEqual))))
-(rule (vany_true_val (has_type ty (fcmp (FloatCC.GreaterThanOrEqual) x y)))
+(rule (vany_true_val (has_type ty (fcmp _ (FloatCC.GreaterThanOrEqual) x y)))
       (bool (vec_fcmphes ty x y)
             (floatcc_as_cond (FloatCC.Ordered))))
-(rule (vany_true_val (has_type ty (fcmp (FloatCC.UnorderedOrLessThan) x y)))
+(rule (vany_true_val (has_type ty (fcmp _ (FloatCC.UnorderedOrLessThan) x y)))
       (bool (vec_fcmphes ty x y)
             (floatcc_as_cond (FloatCC.NotEqual))))
-(rule (vany_true_val (has_type ty (fcmp (FloatCC.LessThan) x y)))
+(rule (vany_true_val (has_type ty (fcmp _ (FloatCC.LessThan) x y)))
       (bool (vec_fcmphs ty y x)
             (floatcc_as_cond (FloatCC.Ordered))))
-(rule (vany_true_val (has_type ty (fcmp (FloatCC.UnorderedOrGreaterThanOrEqual) x y)))
+(rule (vany_true_val (has_type ty (fcmp _ (FloatCC.UnorderedOrGreaterThanOrEqual) x y)))
       (bool (vec_fcmphs ty y x)
             (floatcc_as_cond (FloatCC.NotEqual))))
-(rule (vany_true_val (has_type ty (fcmp (FloatCC.LessThanOrEqual) x y)))
+(rule (vany_true_val (has_type ty (fcmp _ (FloatCC.LessThanOrEqual) x y)))
       (bool (vec_fcmphes ty y x)
             (floatcc_as_cond (FloatCC.Ordered))))
-(rule (vany_true_val (has_type ty (fcmp (FloatCC.UnorderedOrGreaterThan) x y)))
+(rule (vany_true_val (has_type ty (fcmp _ (FloatCC.UnorderedOrGreaterThan) x y)))
       (bool (vec_fcmphes ty y x)
             (floatcc_as_cond (FloatCC.NotEqual))))
 
 
 ;;;; Rules for `vhigh_bits` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (vhigh_bits x @ (value_type (multi_lane 8 16))))
+(rule (lower (vhigh_bits _ x @ (value_type (multi_lane 8 16))))
       (if-let (LaneOrder.LittleEndian) (lane_order))
       (let ((mask Reg (vec_imm $I8X16 (imm8x16 0 8 16 24 32 40 48 56
                                                64 72 80 88 96 104 112 120))))
         (vec_extract_lane $I64X2 (vec_bitpermute x mask) 0 (zero_reg))))
-(rule 1 (lower (vhigh_bits x @ (value_type (multi_lane 8 16))))
+(rule 1 (lower (vhigh_bits _ x @ (value_type (multi_lane 8 16))))
       (if-let (LaneOrder.BigEndian) (lane_order))
       (let ((mask Reg (vec_imm $I8X16 (imm8x16 120 112 104 96 88 80 72 64
                                                56 48 40 32 24 16 8 0))))
         (vec_extract_lane $I64X2 (vec_bitpermute x mask) 0 (zero_reg))))
 
-(rule (lower (vhigh_bits x @ (value_type (multi_lane 16 8))))
+(rule (lower (vhigh_bits _ x @ (value_type (multi_lane 16 8))))
       (if-let (LaneOrder.LittleEndian) (lane_order))
       (let ((mask Reg (vec_imm $I8X16 (imm8x16 128 128 128 128 128 128 128 128
                                                0 16 32 48 64 80 96 112))))
         (vec_extract_lane $I64X2 (vec_bitpermute x mask) 0 (zero_reg))))
-(rule 1 (lower (vhigh_bits x @ (value_type (multi_lane 16 8))))
+(rule 1 (lower (vhigh_bits _ x @ (value_type (multi_lane 16 8))))
       (if-let (LaneOrder.BigEndian) (lane_order))
       (let ((mask Reg (vec_imm $I8X16 (imm8x16 128 128 128 128 128 128 128 128
                                                112 96 80 64 48 32 16 0))))
         (vec_extract_lane $I64X2 (vec_bitpermute x mask) 0 (zero_reg))))
 
-(rule (lower (vhigh_bits x @ (value_type (multi_lane 32 4))))
+(rule (lower (vhigh_bits _ x @ (value_type (multi_lane 32 4))))
       (if-let (LaneOrder.LittleEndian) (lane_order))
       (let ((mask Reg (vec_imm $I8X16 (imm8x16 128 128 128 128 128 128 128 128
                                                128 128 128 128 0 32 64 96))))
         (vec_extract_lane $I64X2 (vec_bitpermute x mask) 0 (zero_reg))))
-(rule 1 (lower (vhigh_bits x @ (value_type (multi_lane 32 4))))
+(rule 1 (lower (vhigh_bits _ x @ (value_type (multi_lane 32 4))))
       (if-let (LaneOrder.BigEndian) (lane_order))
       (let ((mask Reg (vec_imm $I8X16 (imm8x16 128 128 128 128 128 128 128 128
                                                128 128 128 128 96 64 32 0))))
         (vec_extract_lane $I64X2 (vec_bitpermute x mask) 0 (zero_reg))))
 
-(rule (lower (vhigh_bits x @ (value_type (multi_lane 64 2))))
+(rule (lower (vhigh_bits _ x @ (value_type (multi_lane 64 2))))
       (if-let (LaneOrder.LittleEndian) (lane_order))
       (let ((mask Reg (vec_imm $I8X16 (imm8x16 128 128 128 128 128 128 128 128
                                                128 128 128 128 128 128 0 64))))
         (vec_extract_lane $I64X2 (vec_bitpermute x mask) 0 (zero_reg))))
-(rule 1 (lower (vhigh_bits x @ (value_type (multi_lane 64 2))))
+(rule 1 (lower (vhigh_bits _ x @ (value_type (multi_lane 64 2))))
       (if-let (LaneOrder.BigEndian) (lane_order))
       (let ((mask Reg (vec_imm $I8X16 (imm8x16 128 128 128 128 128 128 128 128
                                                128 128 128 128 128 128 64 0))))
         (vec_extract_lane $I64X2 (vec_bitpermute x mask) 0 (zero_reg))))
 
 
-;;;; Rules for `is_null` and `is_invalid`  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-;; Null references are represented by the constant value 0.
-(rule (lower (has_type $I8 (is_null x @ (value_type $R64))))
-      (lower_bool $I8 (bool (icmps_simm16 $I64 x 0)
-                            (intcc_as_cond (IntCC.Equal)))))
-
-
-;; Invalid references are represented by the constant value -1.
-(rule (lower (has_type $I8 (is_invalid x @ (value_type $R64))))
-      (lower_bool $I8 (bool (icmps_simm16 $I64 x -1)
-                            (intcc_as_cond (IntCC.Equal)))))
-
-
 ;;;; Rules for `select` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Return a `ProducesBool` to capture the fact that the input value is nonzero.
@@ -3695,8 +3666,8 @@
 ;; instruction, directly use that compare. Note that it is not safe to sink
 ;; memory loads here, see the `icmp` comment.
 (decl value_nonzero (Value) ProducesBool)
-(rule (value_nonzero (icmp int_cc x y)) (icmp_val $false int_cc x y))
-(rule (value_nonzero (fcmp float_cc x y)) (fcmp_val float_cc x y))
+(rule (value_nonzero (icmp _ int_cc x y)) (icmp_val $false int_cc x y))
+(rule (value_nonzero (fcmp _ float_cc x y)) (fcmp_val float_cc x y))
 (rule -1 (value_nonzero val @ (value_type (gpr32_ty ty)))
       (bool (icmps_simm16 $I32 (put_in_reg_sext32 val) 0)
                           (intcc_as_cond (IntCC.NotEqual))))
@@ -3708,14 +3679,14 @@
             (floatcc_as_cond (FloatCC.NotEqual))))
 
 ;; Main `select` entry point.  Lower the `value_nonzero` result.
-(rule (lower (has_type ty (select val_cond val_true val_false)))
+(rule (lower (has_type ty (select _ val_cond val_true val_false)))
       (select_bool_reg ty (value_nonzero val_cond)
                        (put_in_reg val_true) (put_in_reg val_false)))
 
 ;; Special-case some float-selection instructions for min/max
-(rule 1 (lower (has_type (ty_scalar_float ty) (select (maybe_uextend (fcmp (FloatCC.LessThan) x y)) x y)))
+(rule 1 (lower (has_type (ty_scalar_float ty) (select _ (maybe_uextend (fcmp _ (FloatCC.LessThan) x y)) x y)))
         (fmin_pseudo_reg ty y x))
-(rule 2 (lower (has_type (ty_scalar_float ty) (select (maybe_uextend (fcmp (FloatCC.LessThan) y x)) x y)))
+(rule 2 (lower (has_type (ty_scalar_float ty) (select _ (maybe_uextend (fcmp _ (FloatCC.LessThan) y x)) x y)))
         (fmax_pseudo_reg ty y x))
 
 
@@ -3724,7 +3695,7 @@
 ;; We need to guarantee a conditional move instruction.  But on this platform
 ;; this is already the best way to implement select in general, so the
 ;; implementation of `select_spectre_guard` is identical to `select`.
-(rule (lower (has_type ty (select_spectre_guard
+(rule (lower (has_type ty (select_spectre_guard _
                              val_cond val_true val_false)))
       (select_bool_reg ty (value_nonzero val_cond)
                        (put_in_reg val_true) (put_in_reg val_false)))
@@ -3784,12 +3755,6 @@
       (side_effect (trap_impl trap_code)))
 
 
-;;;; Rules for `resumable_trap` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(rule (lower (resumable_trap trap_code))
-      (side_effect (trap_impl trap_code)))
-
-
 ;;;; Rules for `trapz` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (rule (lower (trapz val trap_code))
@@ -3802,12 +3767,6 @@
       (side_effect (trap_if_bool (value_nonzero val) trap_code)))
 
 
-;;;; Rules for `resumable_trapnz` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(rule (lower (resumable_trapnz val trap_code))
-      (side_effect (trap_if_bool (value_nonzero val) trap_code)))
-
-
 ;;;; Rules for `debugtrap` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (rule (lower (debugtrap))
@@ -3825,59 +3784,59 @@
 ;; a condition mask of 2 | 1.
 ;;
 ;; As this does not match any of the encodings used with a normal integer
-;; comparsion, this cannot be represented by any IntCC value.  We need to
+;; comparison, this cannot be represented by any IntCC value.  We need to
 ;; remap the IntCC::UnsignedGreaterThan value that we have here as result
 ;; of the unsigned_add_overflow_condition call to the correct mask.
 
-(rule 0 (lower (has_type (fits_in_64 ty) (uadd_overflow_trap x y tc)))
+(rule 0 (lower (has_type (fits_in_64 ty) (uadd_overflow_trap _ x y tc)))
       (with_flags
         (add_logical_reg_with_flags_paired ty x y)
         (trap_if_impl (mask_as_cond 3) tc)))
 
 ;; Add a register an a zero-extended register.
 (rule 4 (lower (has_type (fits_in_64 ty)
-                         (uadd_overflow_trap x (zext32_value y) tc)))
+                         (uadd_overflow_trap _ x (zext32_value y) tc)))
       (with_flags
         (add_logical_reg_zext32_with_flags_paired ty x y)
         (trap_if_impl (mask_as_cond 3) tc)))
 (rule 8 (lower (has_type (fits_in_64 ty)
-                         (uadd_overflow_trap (zext32_value x) y tc)))
+                         (uadd_overflow_trap _ (zext32_value x) y tc)))
       (with_flags
         (add_logical_reg_zext32_with_flags_paired ty y x)
         (trap_if_impl (mask_as_cond 3) tc)))
 
 ;; Add a register and an immediate
 (rule 3 (lower (has_type (fits_in_64 ty)
-                         (uadd_overflow_trap x (u32_from_value y) tc)))
+                         (uadd_overflow_trap _ x (u32_from_value y) tc)))
       (with_flags
         (add_logical_zimm32_with_flags_paired ty x y)
         (trap_if_impl (mask_as_cond 3) tc)))
 (rule 7 (lower (has_type (fits_in_64 ty)
-                         (uadd_overflow_trap (u32_from_value x) y tc)))
+                         (uadd_overflow_trap _ (u32_from_value x) y tc)))
       (with_flags
         (add_logical_zimm32_with_flags_paired ty y x)
         (trap_if_impl (mask_as_cond 3) tc)))
 
 ;; Add a register and memory (32/64-bit types).
 (rule 2 (lower (has_type (fits_in_64 ty)
-                         (uadd_overflow_trap x (sinkable_load_32_64 y) tc)))
+                         (uadd_overflow_trap _ x (sinkable_load_32_64 y) tc)))
       (with_flags
         (add_logical_mem_with_flags_paired ty x (sink_load y))
         (trap_if_impl (mask_as_cond 3) tc)))
 (rule 6 (lower (has_type (fits_in_64 ty)
-                         (uadd_overflow_trap (sinkable_load_32_64 x) y tc)))
+                         (uadd_overflow_trap _ (sinkable_load_32_64 x) y tc)))
       (with_flags
         (add_logical_mem_with_flags_paired ty y (sink_load x))
         (trap_if_impl (mask_as_cond 3) tc)))
 
 ;; Add a register and zero-extended memory.
 (rule 1 (lower (has_type (fits_in_64 ty)
-                         (uadd_overflow_trap x (sinkable_uload32 y) tc)))
+                         (uadd_overflow_trap _ x (sinkable_uload32 y) tc)))
       (with_flags
         (add_logical_mem_zext32_with_flags_paired ty x (sink_uload32 y))
         (trap_if_impl (mask_as_cond 3) tc)))
 (rule 5 (lower (has_type (fits_in_64 ty)
-                         (uadd_overflow_trap (sinkable_uload32 x) y tc)))
+                         (uadd_overflow_trap _ (sinkable_uload32 x) y tc)))
       (with_flags
         (add_logical_mem_zext32_with_flags_paired ty y (sink_uload32 x))
         (trap_if_impl (mask_as_cond 3) tc)))
@@ -3893,21 +3852,19 @@
 ;; Direct call to an in-range function.
 (rule 1 (lower (call (func_ref_data sig_ref name (reloc_distance_near)) args))
       (let ((abi Sig (abi_sig sig_ref))
-            (_ Unit (abi_accumulate_outgoing_args_size abi))
             (uses CallArgList (lower_call_args abi (range 0 (abi_num_args abi)) args))
             (defs CallRetList (defs_init abi))
-            (_ InstOutput (side_effect (abi_call abi name uses defs (Opcode.Call)))))
+            (_ InstOutput (side_effect (abi_call abi name uses defs))))
         (lower_call_rets abi defs (range (abi_first_ret sig_ref abi)
                                          (abi_num_rets abi)) (output_builder_new))))
 
 ;; Direct call to an out-of-range function (implicitly via pointer).
 (rule (lower (call (func_ref_data sig_ref name _) args))
       (let ((abi Sig (abi_sig sig_ref))
-            (_ Unit (abi_accumulate_outgoing_args_size abi))
             (uses CallArgList (lower_call_args abi (range 0 (abi_num_args abi)) args))
             (defs CallRetList (defs_init abi))
             (target Reg (load_symbol_reloc (SymbolReloc.Absolute name 0)))
-            (_ InstOutput (side_effect (abi_call_ind abi target uses defs (Opcode.Call)))))
+            (_ InstOutput (side_effect (abi_call_ind abi target uses defs))))
         (lower_call_rets abi defs (range (abi_first_ret sig_ref abi)
                                          (abi_num_rets abi)) (output_builder_new))))
 
@@ -3915,10 +3872,9 @@
 (rule (lower (call_indirect sig_ref ptr args))
       (let ((abi Sig (abi_sig sig_ref))
             (target Reg (put_in_reg ptr))
-            (_ Unit (abi_accumulate_outgoing_args_size abi))
             (uses CallArgList (lower_call_args abi (range 0 (abi_num_args abi)) args))
             (defs CallRetList (defs_init abi))
-            (_ InstOutput (side_effect (abi_call_ind abi target uses defs (Opcode.CallIndirect)))))
+            (_ InstOutput (side_effect (abi_call_ind abi target uses defs))))
         (lower_call_rets abi defs (range (abi_first_ret sig_ref abi)
                                          (abi_num_rets abi)) (output_builder_new))))
 
@@ -3926,54 +3882,97 @@
 (decl lower_call_args (Sig Range ValueSlice) CallArgList)
 (rule (lower_call_args abi range args)
       (let ((uses CallArgListBuilder (args_builder_new))
-            (_ InstOutput (lower_call_args_buffer abi range args))
-            (_ InstOutput (lower_call_args_slots abi uses range args))
-            (_ InstOutput (lower_call_ret_arg abi uses)))
+            (stack MemArg (abi_call_stack_args abi))
+            (_ InstOutput (lower_call_args_buffer abi stack range args))
+            (_ InstOutput (lower_call_args_slots abi uses stack range args))
+            (_ InstOutput (lower_call_ret_arg abi uses stack)))
         (args_builder_finish uses)))
 
-;; Lower function arguments (part 1): prepare buffer copies.
-(decl lower_call_args_buffer (Sig Range ValueSlice) InstOutput)
-(rule (lower_call_args_buffer abi (range_empty) _) (output_none))
-(rule (lower_call_args_buffer abi (range_unwrap head tail) args)
-      (let ((_ InstOutput (copy_to_buffer 0 (abi_get_arg abi head)
-                                          (value_slice_get args head))))
-        (lower_call_args_buffer abi tail args)))
-
-;; Lower function arguments (part 2): set up registers / stack slots.
-(decl lower_call_args_slots (Sig CallArgListBuilder Range ValueSlice) InstOutput)
-(rule (lower_call_args_slots abi _ (range_empty) _) (output_none))
-(rule (lower_call_args_slots abi uses (range_unwrap head tail) args)
-      (let ((_ InstOutput (copy_to_arg uses (abi_lane_order abi)
-                                       0 (abi_get_arg abi head)
-                                       (value_slice_get args head))))
-        (lower_call_args_slots abi uses tail args)))
-
-;; Lower function arguments (part 3): implicit return-area pointer.
-(decl lower_call_ret_arg (Sig CallArgListBuilder) InstOutput)
-(rule (lower_call_ret_arg (abi_no_ret_arg) _) (output_none))
-(rule 1 (lower_call_ret_arg abi @ (abi_ret_arg (abi_arg_only_slot slot)) uses)
-      (let ((mem MemArg (memarg_stack_off (abi_sized_stack_arg_space abi) 0)))
-        (copy_reg_to_arg_slot uses (abi_lane_order abi) 0 slot (load_addr mem))))
-
 ;; Lower function return values by collecting them from registers / stack slots.
 (decl lower_call_rets (Sig CallRetList Range InstOutputBuilder) InstOutput)
 (rule (lower_call_rets abi _ (range_empty) builder) (output_builder_finish builder))
 (rule (lower_call_rets abi defs (range_unwrap head tail) builder)
       (let ((ret ValueRegs (copy_from_arg defs (abi_lane_order abi)
-                                          (abi_sized_stack_arg_space abi)
+                                          (abi_call_stack_rets abi)
                                           (abi_get_ret abi head)))
             (_ Unit (output_builder_push builder ret)))
         (lower_call_rets abi defs tail builder)))
 
+
+;;;; Rules for `return_call` and `return_call_indirect` ;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Direct tail call to an in-range function.
+(rule 1 (lower (return_call (func_ref_data sig_ref name (reloc_distance_near)) args))
+      (let ((abi Sig (abi_sig sig_ref))
+            (uses CallArgList (lower_return_call_args abi (range 0 (abi_num_args abi)) args)))
+        (side_effect (abi_return_call abi name uses))))
+
+;; Direct tail call to an out-of-range function (implicitly via pointer).
+(rule (lower (return_call (func_ref_data sig_ref name _) args))
+      (let ((abi Sig (abi_sig sig_ref))
+            (uses CallArgList (lower_return_call_args abi (range 0 (abi_num_args abi)) args))
+            (target Reg (load_symbol_reloc (SymbolReloc.Absolute name 0))))
+        (side_effect (abi_return_call_ind abi target uses))))
+
+;; Indirect tail call.
+(rule (lower (return_call_indirect sig_ref ptr args))
+      (let ((abi Sig (abi_sig sig_ref))
+            (target Reg (put_in_reg ptr))
+            (uses CallArgList (lower_return_call_args abi (range 0 (abi_num_args abi)) args)))
+        (side_effect (abi_return_call_ind abi target uses))))
+
+;; Lower tail call function arguments.
+(decl lower_return_call_args (Sig Range ValueSlice) CallArgList)
+(rule (lower_return_call_args abi range args)
+      (let ((uses CallArgListBuilder (args_builder_new))
+            (stack MemArg (abi_return_call_stack_args abi))
+            (_ InstOutput (lower_call_args_buffer abi stack range args))
+            (_ InstOutput (lower_call_args_slots abi uses stack range args))
+            (_ InstOutput (lower_return_call_ret_arg abi uses stack)))
+        (args_builder_finish uses)))
+
+
+;;;; Common helpers for argument lowering ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Lower function arguments (part 1): prepare buffer copies.
+(decl lower_call_args_buffer (Sig MemArg Range ValueSlice) InstOutput)
+(rule (lower_call_args_buffer abi _ (range_empty) _) (output_none))
+(rule (lower_call_args_buffer abi stack (range_unwrap head tail) args)
+      (let ((_ InstOutput (copy_to_buffer stack (abi_get_arg abi head)
+                                          (value_slice_get args head))))
+        (lower_call_args_buffer abi stack tail args)))
+
+;; Lower function arguments (part 2): set up registers / stack slots.
+(decl lower_call_args_slots (Sig CallArgListBuilder MemArg Range ValueSlice) InstOutput)
+(rule (lower_call_args_slots abi _ _ (range_empty) _) (output_none))
+(rule (lower_call_args_slots abi uses stack (range_unwrap head tail) args)
+      (let ((_ InstOutput (copy_to_arg uses (abi_lane_order abi)
+                                       stack (abi_get_arg abi head)
+                                       (value_slice_get args head))))
+        (lower_call_args_slots abi uses stack tail args)))
+
+;; Lower function arguments (part 3): implicit return-area pointer (call).
+(decl lower_call_ret_arg (Sig CallArgListBuilder MemArg) InstOutput)
+(rule (lower_call_ret_arg (abi_no_ret_arg) _ _) (output_none))
+(rule 1 (lower_call_ret_arg abi @ (abi_ret_arg (abi_arg_only_slot slot)) uses stack)
+      (copy_reg_to_arg_slot uses (abi_lane_order abi)
+                            stack slot (load_addr (abi_call_stack_rets abi))))
+
+;; Lower function arguments (part 3): implicit return-area pointer (return call).
+(decl lower_return_call_ret_arg (Sig CallArgListBuilder MemArg) InstOutput)
+(rule (lower_return_call_ret_arg (abi_no_ret_arg) _ _) (output_none))
+(rule 1 (lower_return_call_ret_arg abi @ (abi_ret_arg (abi_arg_only_slot slot)) uses stack)
+      (copy_reg_to_arg_slot uses (abi_lane_order abi)
+                            stack slot (abi_unwrap_ret_area_ptr)))
+
+
 ;;;; Rules for `get_{frame,stack}_pointer` and `get_return_address` ;;;;;;;;;;;;
 
-(rule (lower (get_stack_pointer))
+(rule (lower (get_stack_pointer _))
       (sp))
 
-(rule (lower (get_frame_pointer))
-      (load64 (memarg_stack_off 0 0)))
+(rule (lower (get_frame_pointer _))
+      (load64 (memarg_frame_pointer_offset)))
 
-(rule (lower (get_return_address))
-      ;; The return address is 14 pointer-sized slots above the initial SP. So
-      ;; our offset is `14 * 8 = 112`.
-      (load64 (memarg_initial_sp_offset 112)))
+(rule (lower (get_return_address _))
+      (load64 (memarg_return_address_offset)))
diff --git a/cranelift/codegen/src/isa/s390x/lower.rs b/cranelift/codegen/src/isa/s390x/lower.rs
index f4db0a459d20..eea3c1fdc985 100644
--- a/cranelift/codegen/src/isa/s390x/lower.rs
+++ b/cranelift/codegen/src/isa/s390x/lower.rs
@@ -25,4 +25,6 @@ impl LowerBackend for S390xBackend {
     ) -> Option<()> {
         isle::lower_branch(ctx, self, ir_inst, targets)
     }
+
+    type FactFlowState = ();
 }
diff --git a/cranelift/codegen/src/isa/s390x/lower/isle.rs b/cranelift/codegen/src/isa/s390x/lower/isle.rs
index cec975d06a15..42c769536ca6 100644
--- a/cranelift/codegen/src/isa/s390x/lower/isle.rs
+++ b/cranelift/codegen/src/isa/s390x/lower/isle.rs
@@ -8,31 +8,29 @@ use crate::ir::ExternalName;
 use crate::isa::s390x::abi::{S390xMachineDeps, REG_SAVE_AREA_SIZE};
 use crate::isa::s390x::inst::{
     gpr, stack_reg, writable_gpr, zero_reg, CallIndInfo, CallInfo, Cond, Inst as MInst, LaneOrder,
-    MemArg, MemArgPair, RegPair, SymbolReloc, UImm12, UImm16Shifted, UImm32Shifted,
-    WritableRegPair,
+    MemArg, MemArgPair, RegPair, ReturnCallIndInfo, ReturnCallInfo, SymbolReloc, UImm12,
+    UImm16Shifted, UImm32Shifted, WritableRegPair,
 };
 use crate::isa::s390x::S390xBackend;
 use crate::machinst::isle::*;
 use crate::machinst::{MachLabel, Reg};
 use crate::{
     ir::{
-        condcodes::*, immediates::*, types::*, ArgumentPurpose, AtomicRmwOp, BlockCall, Endianness,
-        Inst, InstructionData, KnownSymbol, LibCall, MemFlags, Opcode, TrapCode, Value, ValueList,
+        condcodes::*, immediates::*, types::*, ArgumentExtension, ArgumentPurpose, AtomicRmwOp,
+        BlockCall, Endianness, Inst, InstructionData, KnownSymbol, LibCall, MemFlags, Opcode,
+        TrapCode, Value, ValueList,
     },
-    isa::unwind::UnwindInst,
     isa::CallConv,
     machinst::abi::ABIMachineSpec,
     machinst::{
-        ArgPair, CallArgList, CallArgPair, CallRetList, CallRetPair, InstOutput, Lower, MachInst,
+        ArgPair, CallArgList, CallArgPair, CallRetList, CallRetPair, InstOutput, MachInst,
         VCodeConstant, VCodeConstantData,
     },
 };
-use crate::{isle_common_prelude_methods, isle_lower_prelude_methods};
 use regalloc2::PReg;
 use smallvec::smallvec;
 use std::boxed::Box;
 use std::cell::Cell;
-use std::convert::TryFrom;
 use std::vec::Vec;
 
 /// Information describing a library call to be emitted.
@@ -45,6 +43,8 @@ pub struct LibCallInfo {
 
 type BoxCallInfo = Box<CallInfo>;
 type BoxCallIndInfo = Box<CallIndInfo>;
+type BoxReturnCallInfo = Box<ReturnCallInfo>;
+type BoxReturnCallIndInfo = Box<ReturnCallIndInfo>;
 type VecMachLabel = Vec<MachLabel>;
 type BoxExternalName = Box<ExternalName>;
 type BoxSymbolReloc = Box<SymbolReloc>;
@@ -75,7 +75,7 @@ pub(crate) fn lower_branch(
     // TODO: reuse the ISLE context across lowerings so we can reuse its
     // internal heap allocations.
     let mut isle_ctx = IsleContext { lower_ctx, backend };
-    generated_code::constructor_lower_branch(&mut isle_ctx, branch, &targets.to_vec())
+    generated_code::constructor_lower_branch(&mut isle_ctx, branch, targets)
 }
 
 impl generated_code::Context for IsleContext<'_, '_, MInst, S390xBackend> {
@@ -180,12 +180,92 @@ impl generated_code::Context for IsleContext<'_, '_, MInst, S390xBackend> {
         lane_order_for_call_conv(self.lower_ctx.sigs()[abi].call_conv())
     }
 
-    fn abi_accumulate_outgoing_args_size(&mut self, abi: Sig) -> Unit {
-        let off = self.lower_ctx.sigs()[abi].sized_stack_arg_space()
-            + self.lower_ctx.sigs()[abi].sized_stack_ret_space();
+    fn abi_call_stack_args(&mut self, abi: Sig) -> MemArg {
+        let sig_data = &self.lower_ctx.sigs()[abi];
+        if sig_data.call_conv() != CallConv::Tail {
+            // System ABI: outgoing arguments are at the bottom of the
+            // caller's frame (register save area included in offsets).
+            let arg_space = sig_data.sized_stack_arg_space() as u32;
+            self.lower_ctx
+                .abi_mut()
+                .accumulate_outgoing_args_size(arg_space);
+            MemArg::reg_plus_off(stack_reg(), 0, MemFlags::trusted())
+        } else {
+            // Tail-call ABI: outgoing arguments are at the top of the
+            // callee's frame; so we need to allocate that bit of this
+            // frame here, including a backchain copy if needed.
+            let arg_space = sig_data.sized_stack_arg_space() as u32;
+            if arg_space > 0 {
+                if self.backend.flags.preserve_frame_pointers() {
+                    let tmp = self.lower_ctx.alloc_tmp(I64).only_reg().unwrap();
+                    let src_mem = MemArg::reg(stack_reg(), MemFlags::trusted());
+                    let dst_mem = MemArg::reg(stack_reg(), MemFlags::trusted());
+                    self.emit(&MInst::Load64 {
+                        rd: tmp,
+                        mem: src_mem,
+                    });
+                    self.emit(&MInst::AllocateArgs { size: arg_space });
+                    self.emit(&MInst::Store64 {
+                        rd: tmp.to_reg(),
+                        mem: dst_mem,
+                    });
+                } else {
+                    self.emit(&MInst::AllocateArgs { size: arg_space });
+                }
+            }
+            MemArg::reg_plus_off(stack_reg(), arg_space.into(), MemFlags::trusted())
+        }
+    }
+
+    fn abi_call_stack_rets(&mut self, abi: Sig) -> MemArg {
+        let sig_data = &self.lower_ctx.sigs()[abi];
+        if sig_data.call_conv() != CallConv::Tail {
+            // System ABI: buffer for outgoing return values is just above
+            // the outgoing arguments.
+            let arg_space = sig_data.sized_stack_arg_space() as u32;
+            let ret_space = sig_data.sized_stack_ret_space() as u32;
+            self.lower_ctx
+                .abi_mut()
+                .accumulate_outgoing_args_size(arg_space + ret_space);
+            MemArg::reg_plus_off(stack_reg(), arg_space.into(), MemFlags::trusted())
+        } else {
+            // Tail-call ABI: buffer for outgoing return values is at the
+            // bottom of the caller's frame (above the register save area).
+            let ret_space = sig_data.sized_stack_ret_space() as u32;
+            self.lower_ctx
+                .abi_mut()
+                .accumulate_outgoing_args_size(REG_SAVE_AREA_SIZE + ret_space);
+            MemArg::NominalSPOffset {
+                off: REG_SAVE_AREA_SIZE as i64,
+            }
+        }
+    }
+
+    fn abi_return_call_stack_args(&mut self, abi: Sig) -> MemArg {
+        // Tail calls: outgoing arguments at the top of the caller's frame.
+        // Create a backchain copy if needed to ensure correct stack unwinding
+        // during the tail-call sequence.
+        let sig_data = &self.lower_ctx.sigs()[abi];
+        let arg_space = sig_data.sized_stack_arg_space() as u32;
         self.lower_ctx
             .abi_mut()
-            .accumulate_outgoing_args_size(off as u32);
+            .accumulate_tail_args_size(arg_space);
+        if arg_space > 0 {
+            let tmp = self.lower_ctx.alloc_tmp(I64).only_reg().unwrap();
+            let src_mem = MemArg::InitialSPOffset { off: 0 };
+            let dst_mem = MemArg::InitialSPOffset {
+                off: -(arg_space as i64),
+            };
+            self.emit(&MInst::Load64 {
+                rd: tmp,
+                mem: src_mem,
+            });
+            self.emit(&MInst::Store64 {
+                rd: tmp.to_reg(),
+                mem: dst_mem,
+            });
+        }
+        MemArg::InitialSPOffset { off: 0 }
     }
 
     fn abi_call_info(
@@ -194,15 +274,22 @@ impl generated_code::Context for IsleContext<'_, '_, MInst, S390xBackend> {
         name: ExternalName,
         uses: &CallArgList,
         defs: &CallRetList,
-        opcode: &Opcode,
     ) -> BoxCallInfo {
-        let clobbers = self.lower_ctx.sigs().call_clobbers::<S390xMachineDeps>(abi);
+        let sig_data = &self.lower_ctx.sigs()[abi];
+        // Get clobbers: all caller-saves. These may include return value
+        // regs, which we will remove from the clobber set later.
+        let clobbers = S390xMachineDeps::get_regs_clobbered_by_call(sig_data.call_conv());
+        let callee_pop_size = if sig_data.call_conv() == CallConv::Tail {
+            sig_data.sized_stack_arg_space() as u32
+        } else {
+            0
+        };
         Box::new(CallInfo {
             dest: name.clone(),
             uses: uses.clone(),
             defs: defs.clone(),
             clobbers,
-            opcode: *opcode,
+            callee_pop_size,
             caller_callconv: self.lower_ctx.abi().call_conv(self.lower_ctx.sigs()),
             callee_callconv: self.lower_ctx.sigs()[abi].call_conv(),
             tls_symbol: None,
@@ -215,20 +302,57 @@ impl generated_code::Context for IsleContext<'_, '_, MInst, S390xBackend> {
         target: Reg,
         uses: &CallArgList,
         defs: &CallRetList,
-        opcode: &Opcode,
     ) -> BoxCallIndInfo {
-        let clobbers = self.lower_ctx.sigs().call_clobbers::<S390xMachineDeps>(abi);
+        let sig_data = &self.lower_ctx.sigs()[abi];
+        // Get clobbers: all caller-saves. These may include return value
+        // regs, which we will remove from the clobber set later.
+        let clobbers = S390xMachineDeps::get_regs_clobbered_by_call(sig_data.call_conv());
+        let callee_pop_size = if sig_data.call_conv() == CallConv::Tail {
+            sig_data.sized_stack_arg_space() as u32
+        } else {
+            0
+        };
         Box::new(CallIndInfo {
             rn: target,
             uses: uses.clone(),
             defs: defs.clone(),
             clobbers,
-            opcode: *opcode,
+            callee_pop_size,
             caller_callconv: self.lower_ctx.abi().call_conv(self.lower_ctx.sigs()),
             callee_callconv: self.lower_ctx.sigs()[abi].call_conv(),
         })
     }
 
+    fn abi_return_call_info(
+        &mut self,
+        abi: Sig,
+        name: ExternalName,
+        uses: &CallArgList,
+    ) -> BoxReturnCallInfo {
+        let sig_data = &self.lower_ctx.sigs()[abi];
+        let callee_pop_size = sig_data.sized_stack_arg_space() as u32;
+        Box::new(ReturnCallInfo {
+            dest: name.clone(),
+            uses: uses.clone(),
+            callee_pop_size,
+        })
+    }
+
+    fn abi_return_call_ind_info(
+        &mut self,
+        abi: Sig,
+        target: Reg,
+        uses: &CallArgList,
+    ) -> BoxReturnCallIndInfo {
+        let sig_data = &self.lower_ctx.sigs()[abi];
+        let callee_pop_size = sig_data.sized_stack_arg_space() as u32;
+        Box::new(ReturnCallIndInfo {
+            rn: target,
+            uses: uses.clone(),
+            callee_pop_size,
+        })
+    }
+
     fn lib_call_info_memcpy(&mut self, dst: Reg, src: Reg, len: Reg) -> LibCallInfo {
         LibCallInfo {
             libcall: LibCall::Memcpy,
@@ -278,29 +402,24 @@ impl generated_code::Context for IsleContext<'_, '_, MInst, S390xBackend> {
         }
     }
 
-    fn lib_accumulate_outgoing_args_size(&mut self, _: &LibCallInfo) -> Unit {
-        // Libcalls only require the register save area.
-        self.lower_ctx
-            .abi_mut()
-            .accumulate_outgoing_args_size(REG_SAVE_AREA_SIZE);
-    }
-
     fn lib_call_info(&mut self, info: &LibCallInfo) -> BoxCallInfo {
         let caller_callconv = self.lower_ctx.abi().call_conv(self.lower_ctx.sigs());
         let callee_callconv = CallConv::for_libcall(&self.backend.flags, caller_callconv);
 
-        // Clobbers are defined by the calling convention.  Remove defs from clobbers.
-        let mut clobbers = S390xMachineDeps::get_regs_clobbered_by_call(callee_callconv);
-        for reg in &info.defs {
-            clobbers.remove(PReg::from(reg.preg.to_real_reg().unwrap()));
-        }
+        // Clobbers are defined by the calling convention. We will remove return value regs later.
+        let clobbers = S390xMachineDeps::get_regs_clobbered_by_call(callee_callconv);
+
+        // Libcalls only require the register save area.
+        self.lower_ctx
+            .abi_mut()
+            .accumulate_outgoing_args_size(REG_SAVE_AREA_SIZE);
 
         Box::new(CallInfo {
             dest: ExternalName::LibCall(info.libcall),
             uses: info.uses.clone(),
             defs: info.defs.clone(),
             clobbers,
-            opcode: Opcode::Call,
+            callee_pop_size: 0,
             caller_callconv,
             callee_callconv,
             tls_symbol: info.tls_symbol.clone(),
@@ -369,7 +488,7 @@ impl generated_code::Context for IsleContext<'_, '_, MInst, S390xBackend> {
     #[inline]
     fn gpr64_ty(&mut self, ty: Type) -> Option<Type> {
         match ty {
-            I64 | R64 => Some(ty),
+            I64 => Some(ty),
             _ => None,
         }
     }
@@ -819,6 +938,11 @@ impl generated_code::Context for IsleContext<'_, '_, MInst, S390xBackend> {
         mem.get_flags()
     }
 
+    #[inline]
+    fn memarg_offset(&mut self, base: &MemArg, offset: i64) -> MemArg {
+        MemArg::offset(base, offset)
+    }
+
     #[inline]
     fn memarg_reg_plus_reg(&mut self, x: Reg, y: Reg, bias: u8, flags: MemFlags) -> MemArg {
         MemArg::BXD12 {
@@ -834,16 +958,6 @@ impl generated_code::Context for IsleContext<'_, '_, MInst, S390xBackend> {
         MemArg::reg_plus_off(reg, off + (bias as i64), flags)
     }
 
-    #[inline]
-    fn memarg_stack_off(&mut self, base: i64, off: i64) -> MemArg {
-        MemArg::reg_plus_off(stack_reg(), base + off, MemFlags::trusted())
-    }
-
-    #[inline]
-    fn memarg_initial_sp_offset(&mut self, off: i64) -> MemArg {
-        MemArg::InitialSPOffset { off }
-    }
-
     #[inline]
     fn memarg_symbol(&mut self, name: ExternalName, offset: i32, flags: MemFlags) -> MemArg {
         MemArg::Symbol {
@@ -886,6 +1000,18 @@ impl generated_code::Context for IsleContext<'_, '_, MInst, S390xBackend> {
         }
     }
 
+    #[inline]
+    fn memarg_frame_pointer_offset(&mut self) -> MemArg {
+        // The frame pointer (back chain) is stored directly at SP.
+        MemArg::NominalSPOffset { off: 0 }
+    }
+
+    #[inline]
+    fn memarg_return_address_offset(&mut self) -> MemArg {
+        // The return address is stored 14 pointer-sized slots above the initial SP.
+        MemArg::InitialSPOffset { off: 14 * 8 }
+    }
+
     #[inline]
     fn inst_builder_new(&mut self) -> VecMInstBuilder {
         Cell::new(Vec::<MInst>::new())
@@ -923,11 +1049,7 @@ impl generated_code::Context for IsleContext<'_, '_, MInst, S390xBackend> {
 
     #[inline]
     fn sinkable_inst(&mut self, val: Value) -> Option<Inst> {
-        let input = self.lower_ctx.get_value_as_source_or_const(val);
-        if let Some((inst, 0)) = input.inst.as_inst() {
-            return Some(inst);
-        }
-        None
+        self.is_sinkable_inst(val)
     }
 
     #[inline]
@@ -979,10 +1101,10 @@ impl generated_code::Context for IsleContext<'_, '_, MInst, S390xBackend> {
 /// Lane order to be used for a given calling convention.
 #[inline]
 fn lane_order_for_call_conv(call_conv: CallConv) -> LaneOrder {
-    if call_conv == CallConv::WasmtimeSystemV {
-        LaneOrder::LittleEndian
-    } else {
-        LaneOrder::BigEndian
+    match call_conv {
+        CallConv::WasmtimeSystemV => LaneOrder::LittleEndian,
+        CallConv::Tail => LaneOrder::LittleEndian,
+        _ => LaneOrder::BigEndian,
     }
 }
 
diff --git a/cranelift/codegen/src/isa/s390x/lower/isle/generated_code.rs b/cranelift/codegen/src/isa/s390x/lower/isle/generated_code.rs
index d1f8767e9dba..c470bfdad4c6 100644
--- a/cranelift/codegen/src/isa/s390x/lower/isle/generated_code.rs
+++ b/cranelift/codegen/src/isa/s390x/lower/isle/generated_code.rs
@@ -4,6 +4,11 @@
 // mod generated_code;` trick either.
 #![allow(dead_code, unreachable_code, unreachable_patterns)]
 #![allow(unused_imports, unused_variables, non_snake_case, unused_mut)]
-#![allow(irrefutable_let_patterns, unused_assignments, non_camel_case_types)]
+#![allow(
+    irrefutable_let_patterns,
+    unused_assignments,
+    non_camel_case_types,
+    clippy::clone_on_copy
+)]
 
 include!(concat!(env!("ISLE_DIR"), "/isle_s390x.rs"));
diff --git a/cranelift/codegen/src/isa/s390x/mod.rs b/cranelift/codegen/src/isa/s390x/mod.rs
index 5840450dd7ed..842cc4cdf11e 100644
--- a/cranelift/codegen/src/isa/s390x/mod.rs
+++ b/cranelift/codegen/src/isa/s390x/mod.rs
@@ -156,6 +156,11 @@ impl TargetIsa for S390xBackend {
         inst::Inst::function_alignment()
     }
 
+    fn page_size_align_log2(&self) -> u8 {
+        debug_assert_eq!(1 << 12, 0x1000);
+        12
+    }
+
     #[cfg(feature = "disas")]
     fn to_capstone(&self) -> Result<capstone::Capstone, capstone::Error> {
         use capstone::prelude::*;
diff --git a/cranelift/codegen/src/isa/unwind/systemv.rs b/cranelift/codegen/src/isa/unwind/systemv.rs
index 06e8633ef30e..ba77103394c5 100644
--- a/cranelift/codegen/src/isa/unwind/systemv.rs
+++ b/cranelift/codegen/src/isa/unwind/systemv.rs
@@ -34,7 +34,7 @@ impl std::fmt::Display for RegisterMappingError {
                 "register mapping is currently only implemented for x86_64"
             ),
             RegisterMappingError::UnsupportedRegisterBank(bank) => {
-                write!(f, "unsupported register bank: {}", bank)
+                write!(f, "unsupported register bank: {bank}")
             }
         }
     }
@@ -135,8 +135,6 @@ impl Into<gimli::write::CallFrameInstruction> for CallFrameInstruction {
 pub(crate) trait RegisterMapper<Reg> {
     /// Maps Reg.
     fn map(&self, reg: Reg) -> Result<Register, RegisterMappingError>;
-    /// Gets stack pointer register.
-    fn sp(&self) -> Register;
     /// Gets the frame pointer register, if any.
     fn fp(&self) -> Option<Register> {
         None
diff --git a/cranelift/codegen/src/isa/x64/abi.rs b/cranelift/codegen/src/isa/x64/abi.rs
index be005e102243..9d3c9fd55b92 100644
--- a/cranelift/codegen/src/isa/x64/abi.rs
+++ b/cranelift/codegen/src/isa/x64/abi.rs
@@ -1,6 +1,6 @@
 //! Implementation of the standard x64 ABI.
 
-use crate::ir::{self, types, LibCall, MemFlags, Opcode, Signature, TrapCode, Type};
+use crate::ir::{self, types, LibCall, MemFlags, Signature, TrapCode};
 use crate::ir::{types::*, ExternalName};
 use crate::isa;
 use crate::isa::{unwind::UnwindInst, x64::inst::*, x64::settings as x64_settings, CallConv};
@@ -11,9 +11,8 @@ use crate::{CodegenError, CodegenResult};
 use alloc::boxed::Box;
 use alloc::vec::Vec;
 use args::*;
-use regalloc2::{MachineEnv, PReg, PRegSet, VReg};
+use regalloc2::{MachineEnv, PReg, PRegSet};
 use smallvec::{smallvec, SmallVec};
-use std::convert::TryFrom;
 use std::sync::OnceLock;
 
 /// This is the limit for the size of argument and return-value areas on the
@@ -33,44 +32,41 @@ pub struct X64ABIMachineSpec;
 impl X64ABIMachineSpec {
     fn gen_probestack_unroll(insts: &mut SmallInstVec<Inst>, guard_size: u32, probe_count: u32) {
         insts.reserve(probe_count as usize);
-        for i in 0..probe_count {
-            let offset = (guard_size * (i + 1)) as i64;
+        for _ in 0..probe_count {
+            // "Allocate" stack space for the probe by decrementing the stack pointer before
+            // the write. This is required to make valgrind happy.
+            // See: https://github.com/bytecodealliance/wasmtime/issues/7454
+            insts.extend(Self::gen_sp_reg_adjust(-(guard_size as i32)));
 
             // TODO: It would be nice if we could store the imm 0, but we don't have insts for those
             // so store the stack pointer. Any register will do, since the stack is undefined at this point
-            insts.push(Self::gen_store_stack(
-                StackAMode::SPOffset(-offset, I8),
-                regs::rsp(),
+            insts.push(Inst::store(
                 I32,
+                regs::rsp(),
+                Amode::imm_reg(0, regs::rsp()),
             ));
         }
+
+        // Restore the stack pointer to its original value
+        insts.extend(Self::gen_sp_reg_adjust((guard_size * probe_count) as i32));
     }
 
     fn gen_probestack_loop(
         insts: &mut SmallInstVec<Inst>,
-        call_conv: isa::CallConv,
+        _call_conv: isa::CallConv,
         frame_size: u32,
         guard_size: u32,
     ) {
         // We have to use a caller-saved register since clobbering only
         // happens after stack probing.
-        let tmp = match call_conv {
-            // All registers are caller-saved on the `tail` calling convention,
-            // and `r15` is not used to pass arguments.
-            isa::CallConv::Tail => regs::r15(),
-            // `r11` is caller saved on both Fastcall and SystemV, and not used
-            // for argument passing, so it's pretty much free. It is also not
-            // used by the stacklimit mechanism.
-            _ => {
-                let tmp = regs::r11();
-                debug_assert!({
-                    let real_reg = tmp.to_real_reg().unwrap();
-                    !is_callee_save_systemv(real_reg, false)
-                        && !is_callee_save_fastcall(real_reg, false)
-                });
-                tmp
-            }
-        };
+        // `r11` is caller saved on both Fastcall and SystemV, and not used
+        // for argument passing, so it's pretty much free. It is also not
+        // used by the stacklimit mechanism.
+        let tmp = regs::r11();
+        debug_assert!({
+            let real_reg = tmp.to_real_reg().unwrap();
+            !is_callee_save_systemv(real_reg, false) && !is_callee_save_fastcall(real_reg, false)
+        });
 
         insts.push(Inst::StackProbeLoop {
             tmp: Writable::from_reg(tmp),
@@ -96,17 +92,14 @@ impl ABIMachineSpec for X64ABIMachineSpec {
         16
     }
 
-    fn compute_arg_locs<'a, I>(
+    fn compute_arg_locs(
         call_conv: isa::CallConv,
         flags: &settings::Flags,
-        params: I,
+        params: &[ir::AbiParam],
         args_or_rets: ArgsOrRets,
         add_ret_area_ptr: bool,
-        mut args: ArgsAccumulator<'_>,
-    ) -> CodegenResult<(u32, Option<usize>)>
-    where
-        I: IntoIterator<Item = &'a ir::AbiParam>,
-    {
+        mut args: ArgsAccumulator,
+    ) -> CodegenResult<(u32, Option<usize>)> {
         let is_fastcall = call_conv.extends_windows_fastcall();
 
         let mut next_gpr = 0;
@@ -123,7 +116,23 @@ impl ABIMachineSpec for X64ABIMachineSpec {
             next_stack = 32;
         }
 
-        for param in params {
+        // If any param uses extension, the winch calling convention will not pack its results
+        // on the stack and will instead align them to 8-byte boundaries the same way that all the
+        // other calling conventions do. This isn't consistent with Winch itself, but is fine as
+        // Winch only uses this calling convention via trampolines, and those trampolines don't add
+        // extension annotations. Additionally, handling extension attributes this way allows clif
+        // functions that use them with the Winch calling convention to interact successfully with
+        // testing infrastructure.
+        // The results are also not packed if any of the types are `f16`. This is to simplify the
+        // implementation of `Inst::load`/`Inst::store` (which would otherwise require multiple
+        // instructions), and doesn't affect Winch itself as Winch doesn't support `f16` at all.
+        let uses_extension = params
+            .iter()
+            .any(|p| p.extension != ir::ArgumentExtension::None || p.value_type == types::F16);
+
+        for (ix, param) in params.iter().enumerate() {
+            let last_param = ix == params.len() - 1;
+
             if let ir::ArgumentPurpose::StructArgument(size) = param.purpose {
                 let offset = next_stack as i64;
                 let size = size;
@@ -147,9 +156,10 @@ impl ABIMachineSpec for X64ABIMachineSpec {
             //
             // - If `enable_llvm_abi_extensions` is set in the flags, each
             //   `i128` is split into two `i64`s and assigned exactly as if it
-            //   were two consecutive 64-bit args. This is consistent with LLVM's
-            //   behavior, and is needed for some uses of Cranelift (e.g., the
-            //   rustc backend).
+            //   were two consecutive 64-bit args, except that if one of the
+            //   two halves is forced onto the stack, the other half is too.
+            //   This is consistent with LLVM's behavior, and is needed for
+            //   some uses of Cranelift (e.g., the rustc backend).
             //
             // - Otherwise, both SysV and Fastcall specify behavior (use of
             //   vector register, a register pair, or passing by reference
@@ -162,15 +172,25 @@ impl ABIMachineSpec for X64ABIMachineSpec {
             // https://godbolt.org/z/PhG3ob
 
             if param.value_type.bits() > 64
-                && !param.value_type.is_vector()
+                && !(param.value_type.is_vector() || param.value_type.is_float())
                 && !flags.enable_llvm_abi_extensions()
             {
                 panic!(
                     "i128 args/return values not supported unless LLVM ABI extensions are enabled"
                 );
             }
+            // As MSVC doesn't support f16/f128 there is no standard way to pass/return them with
+            // the Windows ABI. LLVM passes/returns them in XMM registers.
+            if matches!(param.value_type, types::F16 | types::F128)
+                && is_fastcall
+                && !flags.enable_llvm_abi_extensions()
+            {
+                panic!(
+                    "f16/f128 args/return values not supported for windows_fastcall unless LLVM ABI extensions are enabled"
+                );
+            }
 
-            // Windows fastcall dictates that `__m128i` paramters to a function
+            // Windows fastcall dictates that `__m128i` parameters to a function
             // are passed indirectly as pointers, so handle that as a special
             // case before the loop below.
             if param.value_type.is_vector()
@@ -208,22 +228,82 @@ impl ABIMachineSpec for X64ABIMachineSpec {
                 continue;
             }
 
+            // SystemV dictates that 128bit int parameters are always either
+            // passed in two registers or on the stack, so handle that as a
+            // special case before the loop below.
+            if param.value_type == types::I128
+                && args_or_rets == ArgsOrRets::Args
+                && call_conv == CallConv::SystemV
+            {
+                let mut slots = ABIArgSlotVec::new();
+                match (
+                    get_intreg_for_arg(&CallConv::SystemV, next_gpr, next_param_idx),
+                    get_intreg_for_arg(&CallConv::SystemV, next_gpr + 1, next_param_idx + 1),
+                ) {
+                    (Some(reg1), Some(reg2)) => {
+                        slots.push(ABIArgSlot::Reg {
+                            reg: reg1.to_real_reg().unwrap(),
+                            ty: ir::types::I64,
+                            extension: ir::ArgumentExtension::None,
+                        });
+                        slots.push(ABIArgSlot::Reg {
+                            reg: reg2.to_real_reg().unwrap(),
+                            ty: ir::types::I64,
+                            extension: ir::ArgumentExtension::None,
+                        });
+                    }
+                    _ => {
+                        let size = 16;
+
+                        // Align.
+                        next_stack = align_to(next_stack, size);
+
+                        slots.push(ABIArgSlot::Stack {
+                            offset: next_stack as i64,
+                            ty: ir::types::I64,
+                            extension: param.extension,
+                        });
+                        slots.push(ABIArgSlot::Stack {
+                            offset: next_stack as i64 + 8,
+                            ty: ir::types::I64,
+                            extension: param.extension,
+                        });
+                        next_stack += size;
+                    }
+                };
+                // Unconditionally increment next_gpr even when storing the
+                // argument on the stack to prevent reusing a possibly
+                // remaining register for the next argument.
+                next_gpr += 2;
+                next_param_idx += 2;
+
+                args.push(ABIArg::Slots {
+                    slots,
+                    purpose: param.purpose,
+                });
+                continue;
+            }
+
             let mut slots = ABIArgSlotVec::new();
-            for (rc, reg_ty) in rcs.iter().zip(reg_tys.iter()) {
+            for (ix, (rc, reg_ty)) in rcs.iter().zip(reg_tys.iter()).enumerate() {
+                let last_slot = last_param && ix == rcs.len() - 1;
+
                 let intreg = *rc == RegClass::Int;
                 let nextreg = if intreg {
                     match args_or_rets {
                         ArgsOrRets::Args => {
                             get_intreg_for_arg(&call_conv, next_gpr, next_param_idx)
                         }
-                        ArgsOrRets::Rets => get_intreg_for_retval(&call_conv, next_gpr),
+                        ArgsOrRets::Rets => {
+                            get_intreg_for_retval(&call_conv, flags, next_gpr, last_slot)
+                        }
                     }
                 } else {
                     match args_or_rets {
                         ArgsOrRets::Args => {
                             get_fltreg_for_arg(&call_conv, next_vreg, next_param_idx)
                         }
-                        ArgsOrRets::Rets => get_fltreg_for_retval(&call_conv, next_vreg),
+                        ArgsOrRets::Rets => get_fltreg_for_retval(&call_conv, next_vreg, last_slot),
                     }
                 };
                 next_param_idx += 1;
@@ -239,11 +319,21 @@ impl ABIMachineSpec for X64ABIMachineSpec {
                         extension: param.extension,
                     });
                 } else {
-                    let size = reg_ty.bits() / 8;
-                    let size = std::cmp::max(size, 8);
-                    // Align.
-                    debug_assert!(size.is_power_of_two());
-                    next_stack = align_to(next_stack, size);
+                    let size = reg_ty.bytes();
+                    let size = if call_conv == CallConv::Winch
+                        && args_or_rets == ArgsOrRets::Rets
+                        && !uses_extension
+                    {
+                        size
+                    } else {
+                        let size = std::cmp::max(size, 8);
+
+                        // Align.
+                        debug_assert!(size.is_power_of_two());
+                        next_stack = align_to(next_stack, size);
+                        size
+                    };
+
                     slots.push(ABIArgSlot::Stack {
                         offset: next_stack as i64,
                         ty: *reg_ty,
@@ -260,7 +350,7 @@ impl ABIMachineSpec for X64ABIMachineSpec {
         }
 
         // Fastcall's indirect 128+ bit vector arguments are all located on the
-        // stack, and stack space is reserved after all paramters are passed,
+        // stack, and stack space is reserved after all parameters are passed,
         // so allocate from the space now.
         if args_or_rets == ArgsOrRets::Args && is_fastcall {
             for arg in args.args_mut() {
@@ -296,6 +386,28 @@ impl ABIMachineSpec for X64ABIMachineSpec {
             None
         };
 
+        // Winch writes the first result to the highest offset, so we need to iterate through the
+        // args and adjust the offsets down.
+        if call_conv == CallConv::Winch && args_or_rets == ArgsOrRets::Rets {
+            for arg in args.args_mut() {
+                if let ABIArg::Slots { slots, .. } = arg {
+                    for slot in slots.iter_mut() {
+                        if let ABIArgSlot::Stack { offset, ty, .. } = slot {
+                            let size = if uses_extension {
+                                i64::from(std::cmp::max(ty.bytes(), 8))
+                            } else {
+                                i64::from(ty.bytes())
+                            };
+
+                            *offset = i64::from(next_stack) - *offset - size;
+                        }
+                    }
+                } else {
+                    unreachable!("Winch cannot handle {arg:?}");
+                }
+            }
+        }
+
         next_stack = align_to(next_stack, 16);
 
         // To avoid overflow issues, limit the arg/return size to something reasonable.
@@ -306,21 +418,25 @@ impl ABIMachineSpec for X64ABIMachineSpec {
         Ok((next_stack, extra_arg))
     }
 
-    fn fp_to_arg_offset(_call_conv: isa::CallConv, _flags: &settings::Flags) -> i64 {
-        16 // frame pointer + return address.
-    }
-
     fn gen_load_stack(mem: StackAMode, into_reg: Writable<Reg>, ty: Type) -> Self::I {
         // For integer-typed values, we always load a full 64 bits (and we always spill a full 64
         // bits as well -- see `Inst::store()`).
         let ty = match ty {
             types::I8 | types::I16 | types::I32 => types::I64,
+            // Stack slots are always at least 8 bytes, so it's fine to load 4 bytes instead of only
+            // two.
+            types::F16 => types::F32,
             _ => ty,
         };
         Inst::load(ty, mem, into_reg, ExtKind::None)
     }
 
     fn gen_store_stack(mem: StackAMode, from_reg: Reg, ty: Type) -> Self::I {
+        let ty = match ty {
+            // See `gen_load_stack`.
+            types::F16 => types::F32,
+            _ => ty,
+        };
         Inst::store(ty, from_reg, mem)
     }
 
@@ -337,7 +453,7 @@ impl ABIMachineSpec for X64ABIMachineSpec {
         to_bits: u8,
     ) -> Self::I {
         let ext_mode = ExtMode::new(from_bits as u16, to_bits as u16)
-            .unwrap_or_else(|| panic!("invalid extension: {} -> {}", from_bits, to_bits));
+            .unwrap_or_else(|| panic!("invalid extension: {from_bits} -> {to_bits}"));
         if is_signed {
             Inst::movsx_rm_r(ext_mode, RegMem::reg(from_reg), to_reg)
         } else {
@@ -374,7 +490,7 @@ impl ABIMachineSpec for X64ABIMachineSpec {
 
     fn gen_stack_lower_bound_trap(limit_reg: Reg) -> SmallInstVec<Self::I> {
         smallvec![
-            Inst::cmp_rmi_r(OperandSize::Size64, RegMemImm::reg(regs::rsp()), limit_reg),
+            Inst::cmp_rmi_r(OperandSize::Size64, limit_reg, RegMemImm::reg(regs::rsp())),
             Inst::TrapIf {
                 // NBE == "> unsigned"; args above are reversed; this tests limit_reg > rsp.
                 cc: CC::NBE,
@@ -383,24 +499,19 @@ impl ABIMachineSpec for X64ABIMachineSpec {
         ]
     }
 
-    fn gen_get_stack_addr(mem: StackAMode, into_reg: Writable<Reg>, _ty: Type) -> Self::I {
+    fn gen_get_stack_addr(mem: StackAMode, into_reg: Writable<Reg>) -> Self::I {
         let mem: SyntheticAmode = mem.into();
         Inst::lea(mem, into_reg)
     }
 
-    fn get_stacklimit_reg(call_conv: isa::CallConv) -> Reg {
+    fn get_stacklimit_reg(_call_conv: isa::CallConv) -> Reg {
         // As per comment on trait definition, we must return a caller-save
         // register that is not used as an argument here.
-        match call_conv {
-            isa::CallConv::Tail => regs::r14(),
-            _ => {
-                debug_assert!(!is_callee_save_systemv(
-                    regs::r10().to_real_reg().unwrap(),
-                    false
-                ));
-                regs::r10()
-            }
-        }
+        debug_assert!(!is_callee_save_systemv(
+            regs::r10().to_real_reg().unwrap(),
+            false
+        ));
+        regs::r10()
     }
 
     fn gen_load_base_offset(into_reg: Writable<Reg>, base: Reg, offset: i32, ty: Type) -> Self::I {
@@ -412,6 +523,11 @@ impl ABIMachineSpec for X64ABIMachineSpec {
     }
 
     fn gen_store_base_offset(base: Reg, offset: i32, from_reg: Reg, ty: Type) -> Self::I {
+        let ty = match ty {
+            // See `gen_load_stack`.
+            types::F16 => types::F32,
+            _ => ty,
+        };
         let mem = Amode::imm_reg(offset, base);
         Inst::store(ty, from_reg, mem)
     }
@@ -433,12 +549,6 @@ impl ABIMachineSpec for X64ABIMachineSpec {
         )]
     }
 
-    fn gen_nominal_sp_adj(offset: i32) -> Self::I {
-        Inst::VirtualSPOffsetAdj {
-            offset: offset as i64,
-        }
-    }
-
     fn gen_prologue_frame_setup(
         _call_conv: isa::CallConv,
         flags: &settings::Flags,
@@ -469,10 +579,10 @@ impl ABIMachineSpec for X64ABIMachineSpec {
     }
 
     fn gen_epilogue_frame_restore(
-        call_conv: isa::CallConv,
+        _call_conv: isa::CallConv,
         _flags: &settings::Flags,
         _isa_flags: &x64_settings::Flags,
-        frame_layout: &FrameLayout,
+        _frame_layout: &FrameLayout,
     ) -> SmallInstVec<Self::I> {
         let mut insts = SmallVec::new();
         // `mov %rbp, %rsp`
@@ -483,14 +593,21 @@ impl ABIMachineSpec for X64ABIMachineSpec {
         ));
         // `pop %rbp`
         insts.push(Inst::pop64(Writable::from_reg(regs::rbp())));
+        insts
+    }
+
+    fn gen_return(
+        call_conv: isa::CallConv,
+        _isa_flags: &x64_settings::Flags,
+        frame_layout: &FrameLayout,
+    ) -> SmallInstVec<Self::I> {
         // Emit return instruction.
         let stack_bytes_to_pop = if call_conv == isa::CallConv::Tail {
-            frame_layout.stack_args_size
+            frame_layout.tail_args_size
         } else {
             0
         };
-        insts.push(Inst::ret(stack_bytes_to_pop));
-        insts
+        smallvec![Inst::ret(stack_bytes_to_pop)]
     }
 
     fn gen_probestack(insts: &mut SmallInstVec<Self::I>, frame_size: u32) {
@@ -501,16 +618,15 @@ impl ABIMachineSpec for X64ABIMachineSpec {
         ));
         insts.push(Inst::CallKnown {
             dest: ExternalName::LibCall(LibCall::Probestack),
-            info: Box::new(CallInfo {
+            info: Some(Box::new(CallInfo {
                 // No need to include arg here: we are post-regalloc
                 // so no constraints will be seen anyway.
                 uses: smallvec![],
                 defs: smallvec![],
                 clobbers: PRegSet::empty(),
-                opcode: Opcode::Call,
                 callee_pop_size: 0,
                 callee_conv: CallConv::Probestack,
-            }),
+            })),
         });
     }
 
@@ -523,8 +639,8 @@ impl ABIMachineSpec for X64ABIMachineSpec {
         // Unroll at most n consecutive probes, before falling back to using a loop
         //
         // This was number was picked because the loop version is 38 bytes long. We can fit
-        // 5 inline probes in that space, so unroll if its beneficial in terms of code size.
-        const PROBE_MAX_UNROLL: u32 = 5;
+        // 4 inline probes in that space, so unroll if its beneficial in terms of code size.
+        const PROBE_MAX_UNROLL: u32 = 4;
 
         // Number of probes that we need to perform
         let probe_count = align_to(frame_size, guard_size) / guard_size;
@@ -537,17 +653,61 @@ impl ABIMachineSpec for X64ABIMachineSpec {
     }
 
     fn gen_clobber_save(
-        call_conv: isa::CallConv,
+        _call_conv: isa::CallConv,
         flags: &settings::Flags,
         frame_layout: &FrameLayout,
     ) -> SmallVec<[Self::I; 16]> {
-        if call_conv == isa::CallConv::Tail {
-            assert!(frame_layout.clobbered_callee_saves.is_empty());
-        }
-
         let mut insts = SmallVec::new();
 
-        if flags.unwind_info() && frame_layout.setup_area_size > 0 {
+        // When a return_call within this function required more stack arguments than we have
+        // present, resize the incoming argument area of the frame to accommodate those arguments.
+        let incoming_args_diff = frame_layout.tail_args_size - frame_layout.incoming_args_size;
+        if incoming_args_diff > 0 {
+            // Decrement the stack pointer to make space for the new arguments
+            insts.push(Inst::alu_rmi_r(
+                OperandSize::Size64,
+                AluRmiROpcode::Sub,
+                RegMemImm::imm(incoming_args_diff),
+                Writable::from_reg(regs::rsp()),
+            ));
+
+            // Make sure to keep the frame pointer and stack pointer in sync at this point
+            insts.push(Inst::mov_r_r(
+                OperandSize::Size64,
+                regs::rsp(),
+                Writable::from_reg(regs::rbp()),
+            ));
+
+            let incoming_args_diff = i32::try_from(incoming_args_diff).unwrap();
+
+            // Move the saved frame pointer down by `incoming_args_diff`
+            insts.push(Inst::mov64_m_r(
+                Amode::imm_reg(incoming_args_diff, regs::rsp()),
+                Writable::from_reg(regs::r11()),
+            ));
+            insts.push(Inst::mov_r_m(
+                OperandSize::Size64,
+                regs::r11(),
+                Amode::imm_reg(0, regs::rsp()),
+            ));
+
+            // Move the saved return address down by `incoming_args_diff`
+            insts.push(Inst::mov64_m_r(
+                Amode::imm_reg(incoming_args_diff + 8, regs::rsp()),
+                Writable::from_reg(regs::r11()),
+            ));
+            insts.push(Inst::mov_r_m(
+                OperandSize::Size64,
+                regs::r11(),
+                Amode::imm_reg(8, regs::rsp()),
+            ));
+        }
+
+        // We need to factor `incoming_args_diff` into the offset upward here, as we have grown
+        // the argument area -- `setup_area_size` alone will not be the correct offset up to the
+        // original caller's SP.
+        let offset_upward_to_caller_sp = frame_layout.setup_area_size + incoming_args_diff;
+        if flags.unwind_info() && offset_upward_to_caller_sp > 0 {
             // Emit unwind info: start the frame. The frame (from unwind
             // consumers' point of view) starts at clobbbers, just below
             // the FP and return address. Spill slots and stack slots are
@@ -555,14 +715,16 @@ impl ABIMachineSpec for X64ABIMachineSpec {
             insts.push(Inst::Unwind {
                 inst: UnwindInst::DefineNewFrame {
                     offset_downward_to_clobbers: frame_layout.clobber_size,
-                    offset_upward_to_caller_sp: frame_layout.setup_area_size,
+                    offset_upward_to_caller_sp,
                 },
             });
         }
 
         // Adjust the stack pointer downward for clobbers and the function fixed
-        // frame (spillslots and storage slots).
-        let stack_size = frame_layout.fixed_frame_storage_size + frame_layout.clobber_size;
+        // frame (spillslots, storage slots, and argument area).
+        let stack_size = frame_layout.fixed_frame_storage_size
+            + frame_layout.clobber_size
+            + frame_layout.outgoing_args_size;
         if stack_size > 0 {
             insts.push(Inst::alu_rmi_r(
                 OperandSize::Size64,
@@ -571,36 +733,35 @@ impl ABIMachineSpec for X64ABIMachineSpec {
                 Writable::from_reg(regs::rsp()),
             ));
         }
+
         // Store each clobbered register in order at offsets from RSP,
         // placing them above the fixed frame slots.
-        let mut cur_offset = frame_layout.fixed_frame_storage_size;
+        let clobber_offset =
+            frame_layout.fixed_frame_storage_size + frame_layout.outgoing_args_size;
+        let mut cur_offset = 0;
         for reg in &frame_layout.clobbered_callee_saves {
             let r_reg = reg.to_reg();
-            let off = cur_offset;
-            match r_reg.class() {
-                RegClass::Int => {
-                    insts.push(Inst::store(
-                        types::I64,
-                        r_reg.into(),
-                        Amode::imm_reg(cur_offset.try_into().unwrap(), regs::rsp()),
-                    ));
-                    cur_offset += 8;
-                }
-                RegClass::Float => {
-                    cur_offset = align_to(cur_offset, 16);
-                    insts.push(Inst::store(
-                        types::I8X16,
-                        r_reg.into(),
-                        Amode::imm_reg(cur_offset.try_into().unwrap(), regs::rsp()),
-                    ));
-                    cur_offset += 16;
-                }
+            let ty = match r_reg.class() {
+                RegClass::Int => types::I64,
+                RegClass::Float => types::I8X16,
                 RegClass::Vector => unreachable!(),
             };
+
+            // Align to 8 or 16 bytes as required by the storage type of the clobber.
+            cur_offset = align_to(cur_offset, ty.bytes());
+            let off = cur_offset;
+            cur_offset += ty.bytes();
+
+            insts.push(Inst::store(
+                ty,
+                r_reg.into(),
+                Amode::imm_reg(i32::try_from(off + clobber_offset).unwrap(), regs::rsp()),
+            ));
+
             if flags.unwind_info() {
                 insts.push(Inst::Unwind {
                     inst: UnwindInst::SaveReg {
-                        clobber_offset: off - frame_layout.fixed_frame_storage_size,
+                        clobber_offset: off,
                         reg: r_reg,
                     },
                 });
@@ -617,35 +778,36 @@ impl ABIMachineSpec for X64ABIMachineSpec {
     ) -> SmallVec<[Self::I; 16]> {
         let mut insts = SmallVec::new();
 
-        let stack_size = frame_layout.fixed_frame_storage_size + frame_layout.clobber_size;
-
-        // Restore regs by loading from offsets of RSP. RSP will be
-        // returned to nominal-RSP at this point, so we can use the
-        // same offsets that we used when saving clobbers above.
-        let mut cur_offset = frame_layout.fixed_frame_storage_size;
+        // Restore regs by loading from offsets of RSP. We compute the offset from
+        // the same base as above in clobber_save, as RSP won't change between the
+        // prologue and epilogue.
+        let mut cur_offset =
+            frame_layout.fixed_frame_storage_size + frame_layout.outgoing_args_size;
         for reg in &frame_layout.clobbered_callee_saves {
             let rreg = reg.to_reg();
-            match rreg.class() {
-                RegClass::Int => {
-                    insts.push(Inst::mov64_m_r(
-                        Amode::imm_reg(cur_offset.try_into().unwrap(), regs::rsp()),
-                        Writable::from_reg(rreg.into()),
-                    ));
-                    cur_offset += 8;
-                }
-                RegClass::Float => {
-                    cur_offset = align_to(cur_offset, 16);
-                    insts.push(Inst::load(
-                        types::I8X16,
-                        Amode::imm_reg(cur_offset.try_into().unwrap(), regs::rsp()),
-                        Writable::from_reg(rreg.into()),
-                        ExtKind::None,
-                    ));
-                    cur_offset += 16;
-                }
+            let ty = match rreg.class() {
+                RegClass::Int => types::I64,
+                RegClass::Float => types::I8X16,
                 RegClass::Vector => unreachable!(),
-            }
+            };
+
+            // Align to 8 or 16 bytes as required by the storage type of the clobber.
+            cur_offset = align_to(cur_offset, ty.bytes());
+
+            insts.push(Inst::load(
+                ty,
+                Amode::imm_reg(cur_offset.try_into().unwrap(), regs::rsp()),
+                Writable::from_reg(rreg.into()),
+                ExtKind::None,
+            ));
+
+            cur_offset += ty.bytes();
         }
+
+        let stack_size = frame_layout.fixed_frame_storage_size
+            + frame_layout.clobber_size
+            + frame_layout.outgoing_args_size;
+
         // Adjust RSP back upward.
         if stack_size > 0 {
             insts.push(Inst::alu_rmi_r(
@@ -665,7 +827,6 @@ impl ABIMachineSpec for X64ABIMachineSpec {
         uses: CallArgList,
         defs: CallRetList,
         clobbers: PRegSet,
-        opcode: ir::Opcode,
         tmp: Writable<Reg>,
         callee_conv: isa::CallConv,
         _caller_conv: isa::CallConv,
@@ -679,7 +840,6 @@ impl ABIMachineSpec for X64ABIMachineSpec {
                     uses,
                     defs,
                     clobbers,
-                    opcode,
                     callee_pop_size,
                     callee_conv,
                 ));
@@ -696,7 +856,6 @@ impl ABIMachineSpec for X64ABIMachineSpec {
                     uses,
                     defs,
                     clobbers,
-                    opcode,
                     callee_pop_size,
                     callee_conv,
                 ));
@@ -707,7 +866,6 @@ impl ABIMachineSpec for X64ABIMachineSpec {
                     uses,
                     defs,
                     clobbers,
-                    opcode,
                     callee_pop_size,
                     callee_conv,
                 ));
@@ -759,7 +917,6 @@ impl ABIMachineSpec for X64ABIMachineSpec {
             ],
             /* defs = */ smallvec![],
             /* clobbers = */ Self::get_regs_clobbered_by_call(call_conv),
-            Opcode::Call,
             callee_pop_size,
             call_conv,
         ));
@@ -779,14 +936,6 @@ impl ABIMachineSpec for X64ABIMachineSpec {
         }
     }
 
-    fn get_virtual_sp_offset_from_state(s: &<Self::I as MachInstEmit>::State) -> i64 {
-        s.virtual_sp_offset()
-    }
-
-    fn get_nominal_sp_to_fp(s: &<Self::I as MachInstEmit>::State) -> i64 {
-        s.nominal_sp_to_fp()
-    }
-
     fn get_machine_env(flags: &settings::Flags, _call_conv: isa::CallConv) -> &MachineEnv {
         if flags.enable_pinned_reg() {
             static MACHINE_ENV: OnceLock<MachineEnv> = OnceLock::new();
@@ -798,20 +947,18 @@ impl ABIMachineSpec for X64ABIMachineSpec {
     }
 
     fn get_regs_clobbered_by_call(call_conv_of_callee: isa::CallConv) -> PRegSet {
-        if call_conv_of_callee == isa::CallConv::Tail {
-            TAIL_CLOBBERS
-        } else if call_conv_of_callee.extends_windows_fastcall() {
-            WINDOWS_CLOBBERS
-        } else {
-            SYSV_CLOBBERS
+        match call_conv_of_callee {
+            isa::CallConv::Winch => ALL_CLOBBERS,
+            _ if call_conv_of_callee.extends_windows_fastcall() => WINDOWS_CLOBBERS,
+            _ => SYSV_CLOBBERS,
         }
     }
 
     fn get_ext_mode(
         _call_conv: isa::CallConv,
-        _specified: ir::ArgumentExtension,
+        specified: ir::ArgumentExtension,
     ) -> ir::ArgumentExtension {
-        ir::ArgumentExtension::None
+        specified
     }
 
     fn compute_frame_layout(
@@ -820,15 +967,18 @@ impl ABIMachineSpec for X64ABIMachineSpec {
         _sig: &Signature,
         regs: &[Writable<RealReg>],
         _is_leaf: bool,
-        stack_args_size: u32,
+        incoming_args_size: u32,
+        tail_args_size: u32,
         fixed_frame_storage_size: u32,
         outgoing_args_size: u32,
     ) -> FrameLayout {
+        debug_assert!(tail_args_size >= incoming_args_size);
+
         let mut regs: Vec<Writable<RealReg>> = match call_conv {
-            // The `tail` calling convention doesn't have any callee-save
+            // The `winch` calling convention doesn't have any callee-save
             // registers.
-            CallConv::Tail => vec![],
-            CallConv::Fast | CallConv::Cold | CallConv::SystemV => regs
+            CallConv::Winch => vec![],
+            CallConv::Fast | CallConv::Cold | CallConv::SystemV | CallConv::Tail => regs
                 .iter()
                 .cloned()
                 .filter(|r| is_callee_save_systemv(r.to_reg(), flags.enable_pinned_reg()))
@@ -843,7 +993,7 @@ impl ABIMachineSpec for X64ABIMachineSpec {
         };
         // Sort registers for deterministic code output. We can do an unstable sort because the
         // registers will be unique (there are no dups).
-        regs.sort_unstable_by_key(|r| VReg::from(r.to_reg()).vreg());
+        regs.sort_unstable();
 
         // Compute clobber size.
         let clobber_size = compute_clobber_size(&regs);
@@ -852,9 +1002,9 @@ impl ABIMachineSpec for X64ABIMachineSpec {
         let setup_area_size = 16; // RBP, return address
 
         // Return FrameLayout structure.
-        debug_assert!(outgoing_args_size == 0);
         FrameLayout {
-            stack_args_size,
+            incoming_args_size,
+            tail_args_size: align_to(tail_args_size, 16),
             setup_area_size,
             clobber_size,
             fixed_frame_storage_size,
@@ -866,47 +1016,22 @@ impl ABIMachineSpec for X64ABIMachineSpec {
 
 impl X64CallSite {
     pub fn emit_return_call(mut self, ctx: &mut Lower<Inst>, args: isle::ValueSlice) {
-        let (new_stack_arg_size, old_stack_arg_size) =
-            self.emit_temporary_tail_call_frame(ctx, args);
-
-        // Make a copy of the frame pointer, since we use it when copying down
-        // the new stack frame.
-        let fp = ctx.temp_writable_gpr();
-        let rbp = PReg::from(regs::rbp().to_real_reg().unwrap());
-        ctx.emit(Inst::MovFromPReg { src: rbp, dst: fp });
-
-        // Load the return address, because copying our new stack frame
-        // over our current stack frame might overwrite it, and we'll need to
-        // place it in the correct location after we do that copy.
-        //
-        // But we only need to actually move the return address if the size of
-        // stack arguments changes.
-        let ret_addr = if new_stack_arg_size != old_stack_arg_size {
-            let ret_addr = ctx.temp_writable_gpr();
-            ctx.emit(Inst::Mov64MR {
-                src: SyntheticAmode::Real(Amode::ImmReg {
-                    simm32: 8,
-                    base: *fp.to_reg(),
-                    flags: MemFlags::trusted(),
-                }),
-                dst: ret_addr,
-            });
-            Some(ret_addr.to_reg())
-        } else {
-            None
-        };
+        let new_stack_arg_size =
+            u32::try_from(self.sig(ctx.sigs()).sized_stack_arg_space()).unwrap();
 
-        // Finally, emit the macro instruction to copy the new stack frame over
-        // our current one and do the actual tail call!
+        ctx.abi_mut().accumulate_tail_args_size(new_stack_arg_size);
 
+        // Put all arguments in registers and stack slots (within that newly
+        // allocated stack space).
+        self.emit_args(ctx, args);
+        self.emit_stack_ret_arg_for_tail_call(ctx);
+
+        // Finally, do the actual tail call!
         let dest = self.dest().clone();
         let info = Box::new(ReturnCallInfo {
             new_stack_arg_size,
-            old_stack_arg_size,
-            ret_addr,
-            fp: fp.to_reg(),
-            tmp: ctx.temp_writable_gpr(),
             uses: self.take_uses(),
+            tmp: ctx.temp_writable_gpr(),
         });
         match dest {
             CallDest::ExtName(callee, RelocDistance::Near) => {
@@ -921,7 +1046,7 @@ impl X64CallSite {
                     distance: RelocDistance::Far,
                 });
                 ctx.emit(Inst::ReturnCallUnknown {
-                    callee: tmp2.to_writable_reg().into(),
+                    callee: tmp2.to_reg().to_reg(),
                     info,
                 });
             }
@@ -938,24 +1063,23 @@ impl From<StackAMode> for SyntheticAmode {
         // We enforce a 128 MB stack-frame size limit above, so these
         // `expect()`s should never fail.
         match amode {
-            StackAMode::FPOffset(off, _ty) => {
+            StackAMode::IncomingArg(off, stack_args_size) => {
+                let offset = u32::try_from(off).expect(
+                    "Offset in IncomingArg is greater than 4GB; should hit impl limit first",
+                );
+                SyntheticAmode::IncomingArg {
+                    offset: stack_args_size - offset,
+                }
+            }
+            StackAMode::Slot(off) => {
                 let off = i32::try_from(off)
-                    .expect("Offset in FPOffset is greater than 2GB; should hit impl limit first");
-                SyntheticAmode::Real(Amode::ImmReg {
-                    simm32: off,
-                    base: regs::rbp(),
-                    flags: MemFlags::trusted(),
-                })
+                    .expect("Offset in Slot is greater than 2GB; should hit impl limit first");
+                SyntheticAmode::slot_offset(off)
             }
-            StackAMode::NominalSPOffset(off, _ty) => {
+            StackAMode::OutgoingArg(off) => {
                 let off = i32::try_from(off).expect(
-                    "Offset in NominalSPOffset is greater than 2GB; should hit impl limit first",
+                    "Offset in OutgoingArg is greater than 2GB; should hit impl limit first",
                 );
-                SyntheticAmode::nominal_sp_offset(off)
-            }
-            StackAMode::SPOffset(off, _ty) => {
-                let off = i32::try_from(off)
-                    .expect("Offset in SPOffset is greater than 2GB; should hit impl limit first");
                 SyntheticAmode::Real(Amode::ImmReg {
                     simm32: off,
                     base: regs::rsp(),
@@ -969,25 +1093,6 @@ impl From<StackAMode> for SyntheticAmode {
 fn get_intreg_for_arg(call_conv: &CallConv, idx: usize, arg_idx: usize) -> Option<Reg> {
     let is_fastcall = call_conv.extends_windows_fastcall();
 
-    if *call_conv == isa::CallConv::Tail {
-        return match idx {
-            0 => Some(regs::rax()),
-            1 => Some(regs::rcx()),
-            2 => Some(regs::rdx()),
-            3 => Some(regs::rbx()),
-            4 => Some(regs::rsi()),
-            5 => Some(regs::rdi()),
-            6 => Some(regs::r8()),
-            7 => Some(regs::r9()),
-            8 => Some(regs::r10()),
-            9 => Some(regs::r11()),
-            // NB: `r12`, `r13`, `r14` and `r15` are reserved for indirect
-            // callee addresses and temporaries required for our tail call
-            // sequence (fp, ret_addr, tmp).
-            _ => None,
-        };
-    }
-
     // Fastcall counts by absolute argument number; SysV counts by argument of
     // this (integer) class.
     let i = if is_fastcall { arg_idx } else { idx };
@@ -1029,28 +1134,30 @@ fn get_fltreg_for_arg(call_conv: &CallConv, idx: usize, arg_idx: usize) -> Optio
     }
 }
 
-fn get_intreg_for_retval(call_conv: &CallConv, intreg_idx: usize) -> Option<Reg> {
+fn get_intreg_for_retval(
+    call_conv: &CallConv,
+    flags: &settings::Flags,
+    intreg_idx: usize,
+    is_last: bool,
+) -> Option<Reg> {
     match call_conv {
         CallConv::Tail => match intreg_idx {
             0 => Some(regs::rax()),
             1 => Some(regs::rcx()),
             2 => Some(regs::rdx()),
-            3 => Some(regs::rbx()),
-            4 => Some(regs::rsi()),
-            5 => Some(regs::rdi()),
-            6 => Some(regs::r8()),
-            7 => Some(regs::r9()),
-            8 => Some(regs::r10()),
-            9 => Some(regs::r11()),
-            10 => Some(regs::r12()),
-            11 => Some(regs::r13()),
-            12 => Some(regs::r14()),
+            3 => Some(regs::rsi()),
+            4 => Some(regs::rdi()),
+            5 => Some(regs::r8()),
+            6 => Some(regs::r9()),
+            7 => Some(regs::r10()),
+            8 => Some(regs::r11()),
             // NB: `r15` is reserved as a scratch register.
             _ => None,
         },
         CallConv::Fast | CallConv::Cold | CallConv::SystemV => match intreg_idx {
             0 => Some(regs::rax()),
             1 => Some(regs::rdx()),
+            2 if flags.enable_llvm_abi_extensions() => Some(regs::rcx()),
             _ => None,
         },
         CallConv::WindowsFastcall => match intreg_idx {
@@ -1058,12 +1165,19 @@ fn get_intreg_for_retval(call_conv: &CallConv, intreg_idx: usize) -> Option<Reg>
             1 => Some(regs::rdx()), // The Rust ABI for i128s needs this.
             _ => None,
         },
+
+        CallConv::Winch => {
+            // TODO: Once Winch supports SIMD, this will need to be updated to support values
+            // returned in more than one register.
+            // https://github.com/bytecodealliance/wasmtime/issues/8093
+            is_last.then(|| regs::rax())
+        }
         CallConv::Probestack => todo!(),
         CallConv::WasmtimeSystemV | CallConv::AppleAarch64 => unreachable!(),
     }
 }
 
-fn get_fltreg_for_retval(call_conv: &CallConv, fltreg_idx: usize) -> Option<Reg> {
+fn get_fltreg_for_retval(call_conv: &CallConv, fltreg_idx: usize, is_last: bool) -> Option<Reg> {
     match call_conv {
         CallConv::Tail => match fltreg_idx {
             0 => Some(regs::xmm0()),
@@ -1085,6 +1199,7 @@ fn get_fltreg_for_retval(call_conv: &CallConv, fltreg_idx: usize) -> Option<Reg>
             0 => Some(regs::xmm0()),
             _ => None,
         },
+        CallConv::Winch => is_last.then(|| regs::xmm0()),
         CallConv::Probestack => todo!(),
         CallConv::WasmtimeSystemV | CallConv::AppleAarch64 => unreachable!(),
     }
@@ -1142,7 +1257,7 @@ fn compute_clobber_size(clobbers: &[Writable<RealReg>]) -> u32 {
 
 const WINDOWS_CLOBBERS: PRegSet = windows_clobbers();
 const SYSV_CLOBBERS: PRegSet = sysv_clobbers();
-const TAIL_CLOBBERS: PRegSet = tail_clobbers();
+pub(crate) const ALL_CLOBBERS: PRegSet = all_clobbers();
 
 const fn windows_clobbers() -> PRegSet {
     PRegSet::empty()
@@ -1190,7 +1305,8 @@ const fn sysv_clobbers() -> PRegSet {
         .with(regs::fpr_preg(15))
 }
 
-const fn tail_clobbers() -> PRegSet {
+/// For calling conventions that clobber all registers.
+const fn all_clobbers() -> PRegSet {
     PRegSet::empty()
         .with(regs::gpr_preg(regs::ENC_RAX))
         .with(regs::gpr_preg(regs::ENC_RCX))
diff --git a/cranelift/codegen/src/isa/x64/encoding/evex.rs b/cranelift/codegen/src/isa/x64/encoding/evex.rs
index 03a3ac6c7b0e..bacbf841643b 100644
--- a/cranelift/codegen/src/isa/x64/encoding/evex.rs
+++ b/cranelift/codegen/src/isa/x64/encoding/evex.rs
@@ -15,7 +15,6 @@
 //! Software Development Manual, volume 2A).
 
 use super::rex::{self, LegacyPrefixes, OpcodeMap};
-use crate::ir::TrapCode;
 use crate::isa::x64::args::{Amode, Avx512TupleType};
 use crate::isa::x64::inst::Inst;
 use crate::MachBuffer;
@@ -202,8 +201,8 @@ impl EvexInstruction {
     /// - an optional immediate, if necessary (not currently implemented)
     pub fn encode(&self, sink: &mut MachBuffer<Inst>) {
         if let RegisterOrAmode::Amode(amode) = &self.rm {
-            if amode.can_trap() {
-                sink.add_trap(TrapCode::HeapOutOfBounds);
+            if let Some(trap_code) = amode.get_flags().trap_code() {
+                sink.add_trap(trap_code);
             }
         }
         sink.put4(self.bits);
@@ -266,8 +265,7 @@ impl EvexInstruction {
         let mask: u32 = (1 << size) - 1; // Generate a bit mask.
         debug_assert!(
             value <= mask,
-            "The written value should have fewer than {} bits.",
-            size
+            "The written value should have fewer than {size} bits."
         );
         let mask_complement = !(mask << *range.start()); // Create the bitwise complement for the clear mask.
         self.bits &= mask_complement; // Clear the bits in `range`; otherwise the OR below may allow previously-set bits to slip through.
@@ -553,8 +551,8 @@ mod tests {
                 regs::xmm9(),
                 Amode::ImmRegRegShift {
                     simm32: 0,
-                    base: Gpr::new(regs::rbx()).unwrap(),
-                    index: Gpr::new(regs::rsi()).unwrap(),
+                    base: Gpr::unwrap_new(regs::rbx()),
+                    index: Gpr::unwrap_new(regs::rsi()),
                     shift: 3,
                     flags: MemFlags::trusted(),
                 }
@@ -566,8 +564,8 @@ mod tests {
                 regs::xmm13(),
                 Amode::ImmRegRegShift {
                     simm32: 1,
-                    base: Gpr::new(regs::r11()).unwrap(),
-                    index: Gpr::new(regs::rdi()).unwrap(),
+                    base: Gpr::unwrap_new(regs::r11()),
+                    index: Gpr::unwrap_new(regs::rdi()),
                     shift: 2,
                     flags: MemFlags::trusted(),
                 }
@@ -581,8 +579,8 @@ mod tests {
                 regs::xmm5(),
                 Amode::ImmRegRegShift {
                     simm32: 128,
-                    base: Gpr::new(regs::rsp()).unwrap(),
-                    index: Gpr::new(regs::r10()).unwrap(),
+                    base: Gpr::unwrap_new(regs::rsp()),
+                    index: Gpr::unwrap_new(regs::r10()),
                     shift: 1,
                     flags: MemFlags::trusted(),
                 }
@@ -594,8 +592,8 @@ mod tests {
                 regs::xmm6(),
                 Amode::ImmRegRegShift {
                     simm32: 112,
-                    base: Gpr::new(regs::rbp()).unwrap(),
-                    index: Gpr::new(regs::r13()).unwrap(),
+                    base: Gpr::unwrap_new(regs::rbp()),
+                    index: Gpr::unwrap_new(regs::r13()),
                     shift: 0,
                     flags: MemFlags::trusted(),
                 }
@@ -607,8 +605,8 @@ mod tests {
                 regs::xmm7(),
                 Amode::ImmRegRegShift {
                     simm32: 0,
-                    base: Gpr::new(regs::rbp()).unwrap(),
-                    index: Gpr::new(regs::r13()).unwrap(),
+                    base: Gpr::unwrap_new(regs::rbp()),
+                    index: Gpr::unwrap_new(regs::r13()),
                     shift: 0,
                     flags: MemFlags::trusted(),
                 }
diff --git a/cranelift/codegen/src/isa/x64/encoding/rex.rs b/cranelift/codegen/src/isa/x64/encoding/rex.rs
index ab989a5f261d..ba7b3b19d74c 100644
--- a/cranelift/codegen/src/isa/x64/encoding/rex.rs
+++ b/cranelift/codegen/src/isa/x64/encoding/rex.rs
@@ -10,7 +10,6 @@
 
 use crate::machinst::{Reg, RegClass};
 use crate::{
-    ir::TrapCode,
     isa::x64::inst::{
         args::{Amode, OperandSize},
         regs, Inst, LabelUse,
@@ -67,28 +66,31 @@ pub(crate) fn reg_enc(reg: impl Into<Reg>) -> u8 {
 /// - bit 1 set to 1 indicates the REX prefix must always be emitted.
 #[repr(transparent)]
 #[derive(Clone, Copy)]
-pub(crate) struct RexFlags(u8);
+pub struct RexFlags(u8);
 
 impl RexFlags {
     /// By default, set the W field, and don't always emit.
     #[inline(always)]
-    pub(crate) fn set_w() -> Self {
+    pub fn set_w() -> Self {
         Self(0)
     }
+
     /// Creates a new RexPrefix for which the REX.W bit will be cleared.
     #[inline(always)]
-    pub(crate) fn clear_w() -> Self {
+    pub fn clear_w() -> Self {
         Self(1)
     }
 
+    /// Require that the REX prefix is emitted.
     #[inline(always)]
-    pub(crate) fn always_emit(&mut self) -> &mut Self {
+    pub fn always_emit(&mut self) -> &mut Self {
         self.0 = self.0 | 2;
         self
     }
 
+    /// Emit the rex prefix if the referenced register would require it for 8-bit operations.
     #[inline(always)]
-    pub(crate) fn always_emit_if_8bit_needed(&mut self, reg: Reg) -> &mut Self {
+    pub fn always_emit_if_8bit_needed(&mut self, reg: Reg) -> &mut Self {
         let enc_reg = int_reg_enc(reg);
         if enc_reg >= 4 && enc_reg <= 7 {
             self.always_emit();
@@ -96,17 +98,21 @@ impl RexFlags {
         self
     }
 
+    /// True if 64-bit operands are used.
     #[inline(always)]
-    pub(crate) fn must_clear_w(&self) -> bool {
+    pub fn must_clear_w(&self) -> bool {
         (self.0 & 1) != 0
     }
+
+    /// True if the REX prefix must always be emitted.
     #[inline(always)]
-    pub(crate) fn must_always_emit(&self) -> bool {
+    pub fn must_always_emit(&self) -> bool {
         (self.0 & 2) != 0
     }
 
+    /// Emit a unary instruction.
     #[inline(always)]
-    pub(crate) fn emit_one_op(&self, sink: &mut MachBuffer<Inst>, enc_e: u8) {
+    pub fn emit_one_op(&self, sink: &mut MachBuffer<Inst>, enc_e: u8) {
         // Register Operand coded in Opcode Byte
         // REX.R and REX.X unused
         // REX.B == 1 accesses r8-r15
@@ -120,8 +126,9 @@ impl RexFlags {
         }
     }
 
+    /// Emit a binary instruction.
     #[inline(always)]
-    pub(crate) fn emit_two_op(&self, sink: &mut MachBuffer<Inst>, enc_g: u8, enc_e: u8) {
+    pub fn emit_two_op(&self, sink: &mut MachBuffer<Inst>, enc_g: u8, enc_e: u8) {
         let w = if self.must_clear_w() { 0 } else { 1 };
         let r = (enc_g >> 3) & 1;
         let x = 0;
@@ -132,6 +139,7 @@ impl RexFlags {
         }
     }
 
+    /// Emit a ternary instruction.
     #[inline(always)]
     pub fn emit_three_op(
         &self,
@@ -305,9 +313,8 @@ pub(crate) fn emit_std_enc_mem(
     // 64-bit integer registers, because they are part of an address
     // expression.  But `enc_g` can be derived from a register of any class.
 
-    let can_trap = mem_e.can_trap();
-    if can_trap {
-        sink.add_trap(TrapCode::HeapOutOfBounds);
+    if let Some(trap_code) = mem_e.get_flags().trap_code() {
+        sink.add_trap(trap_code);
     }
 
     prefixes.emit(sink);
diff --git a/cranelift/codegen/src/isa/x64/encoding/vex.rs b/cranelift/codegen/src/isa/x64/encoding/vex.rs
index 7e853c3361ce..44942570b679 100644
--- a/cranelift/codegen/src/isa/x64/encoding/vex.rs
+++ b/cranelift/codegen/src/isa/x64/encoding/vex.rs
@@ -4,7 +4,6 @@
 use super::evex::{Register, RegisterOrAmode};
 use super::rex::{LegacyPrefixes, OpcodeMap};
 use super::ByteSink;
-use crate::ir::TrapCode;
 use crate::isa::x64::args::Amode;
 use crate::isa::x64::encoding::rex;
 use crate::isa::x64::inst::Inst;
@@ -251,8 +250,8 @@ impl VexInstruction {
     /// Emit the VEX-encoded instruction to the provided buffer.
     pub fn encode(&self, sink: &mut MachBuffer<Inst>) {
         if let RegisterOrAmode::Amode(amode) = &self.rm {
-            if amode.can_trap() {
-                sink.add_trap(TrapCode::HeapOutOfBounds);
+            if let Some(trap_code) = amode.get_flags().trap_code() {
+                sink.add_trap(trap_code);
             }
         }
 
@@ -466,8 +465,8 @@ mod tests {
         let dst = regs::xmm2().to_real_reg().unwrap().hw_enc();
         let src1 = regs::xmm1().to_real_reg().unwrap().hw_enc();
         let src2 = Amode::ImmRegRegShift {
-            base: Gpr::new(regs::rax()).unwrap(),
-            index: Gpr::new(regs::r13()).unwrap(),
+            base: Gpr::unwrap_new(regs::rax()),
+            index: Gpr::unwrap_new(regs::r13()),
             flags: MemFlags::trusted(),
             simm32: 100,
             shift: 2,
diff --git a/cranelift/codegen/src/isa/x64/inst.isle b/cranelift/codegen/src/isa/x64/inst.isle
index 281b665c7eec..32601df26813 100644
--- a/cranelift/codegen/src/isa/x64/inst.isle
+++ b/cranelift/codegen/src/isa/x64/inst.isle
@@ -90,20 +90,34 @@
              (dividend Gpr)
              (dst WritableGpr))
 
-       ;; The high (and low) bits of a (un)signed multiply: `RDX:RAX := RAX *
-       ;; rhs`.
-       (MulHi (size OperandSize)
-              (signed bool)
-              (src1 Gpr)
-              (src2 GprMem)
-              (dst_lo WritableGpr)
-              (dst_hi WritableGpr))
-
-       ;; x64 'mul' instruction but it only outputs the low half
-       (UMulLo    (size OperandSize)
-                  (src1 Gpr)
-                  (src2 GprMem)
-                  (dst WritableGpr))
+       ;; Unsigned multiplication producing the high bits of the result in one
+       ;; register and the low bits in another register.
+       (Mul (size OperandSize)
+            (signed bool)
+            (src1 Gpr)
+            (src2 GprMem)
+            (dst_lo WritableGpr)
+            (dst_hi WritableGpr))
+
+       ;; Same as `Mul` but the 16-bit multiplication result is stored in `AX`.
+       (Mul8 (signed bool)
+             (src1 Gpr)
+             (src2 GprMem)
+             (dst WritableGpr))
+
+       ;; The two-operand form of `imul` which produces a truncated same-size
+       ;; result as the operands.
+       (IMul (size OperandSize)
+             (src1 Gpr)
+             (src2 GprMem)
+             (dst WritableGpr))
+
+       ;; The three-operand form of `imul` where the third operand must be
+       ;; a constant.
+       (IMulImm (size OperandSize)
+                (src1 GprMem)
+                (src2 i32)
+                (dst WritableGpr))
 
        ;; A synthetic instruction sequence used as part of the lowering of the
        ;; `srem` instruction which returns 0 if the divisor is -1 and
@@ -191,7 +205,7 @@
                (kind ShiftKind)
                (src Gpr)
                ;; shift count: `Imm8Gpr::Imm8(0 .. #bits-in-type - 1)` or
-               ;; `Imm8Reg::Gpr(r)` where `r` get's move mitosis'd into `%cl`.
+               ;; `Imm8Reg::Gpr(r)` where `r` gets move mitosis'd into `%cl`.
                (num_bits Imm8Gpr)
                (dst WritableGpr))
 
@@ -204,8 +218,8 @@
        ;; Integer comparisons/tests: cmp or test (b w l q) (reg addr imm) reg.
        (CmpRmiR (size OperandSize) ;; 1, 2, 4, or 8
                 (opcode CmpOpcode)
-                (src GprMemImm)
-                (dst Gpr))
+                (src1 Gpr)
+                (src2 GprMemImm))
 
        ;; Materializes the requested condition code in the destinaton reg.
        (Setcc (cc CC)
@@ -229,7 +243,7 @@
        ;; XMM conditional move; overwrites the destination register.
        (XmmCmove (ty Type)
                  (cc CC)
-                 (consequent XmmMemAligned)
+                 (consequent Xmm)
                  (alternative Xmm)
                  (dst WritableXmm))
 
@@ -289,7 +303,7 @@
                      (dst WritableXmm)
                      (imm u8))
 
-       ;; XMM instruction for `vpinsr{b,w,d,q}` which is separte from
+       ;; XMM instruction for `vpinsr{b,w,d,q}` which is separate from
        ;; `XmmRmRImmVex` because `src2` is a gpr, not xmm register.
        (XmmVexPinsr (op AvxOpcode)
                    (src1 Xmm)
@@ -353,6 +367,10 @@
                     (dst WritableGpr)
                     (dst_size OperandSize))
 
+       ;; Float comparisons/tests: cmp (b w l q) (reg addr imm) reg.
+       (XmmCmpRmRVex (op AvxOpcode)
+                     (src1 Xmm)
+                     (src2 XmmMem))
 
        ;; XMM (scalar or vector) binary op that relies on the EVEX
        ;; prefix. Takes two inputs.
@@ -488,10 +506,13 @@
                      (rhs Xmm)
                      (dst WritableXmm))
 
-       ;; Float comparisons/tests: cmp (b w l q) (reg addr imm) reg.
+       ;; Float comparisons/tests
+       ;;
+       ;; Compares `src1` against `src2` with `op`. Note that if you're testing
+       ;; `a < b` then `src1 == a` and `src2 == b`.
        (XmmCmpRmR (op SseOpcode)
-                  (src XmmMemAligned)
-                  (dst Xmm))
+                  (src1 Xmm)
+                  (src2 XmmMemAligned))
 
        ;; A binary XMM instruction with an 8-bit immediate: e.g. cmp (ps pd) imm
        ;; (reg addr) reg
@@ -522,7 +543,7 @@
                         (info BoxReturnCallInfo))
 
        ;; Tail call to an indirect destination.
-       (ReturnCallUnknown (callee RegMem)
+       (ReturnCallUnknown (callee Reg)
                           (info BoxReturnCallInfo))
 
        ;; A pseudo-instruction that captures register arguments in vregs.
@@ -536,6 +557,12 @@
        ;; Return.
        (Ret (stack_bytes_to_pop u32))
 
+       ;; Stack switching
+       (StackSwitchBasic (store_context_ptr Gpr)
+                         (load_context_ptr Gpr)
+                         (in_payload0 Gpr)
+                         (out_payload0 WritableGpr))
+
        ;; Jump to a known target: jmp simm32.
        (JmpKnown (dst MachLabel))
 
@@ -664,11 +691,6 @@
        ;; =========================================
        ;; Meta-instructions generating no code.
 
-       ;; Marker, no-op in generated code: SP "virtual offset" is adjusted.
-       ;;
-       ;; This controls how `MemArg::NominalSPOffset` args are lowered.
-       (VirtualSPOffsetAdj (offset i64))
-
        ;; Provides a way to tell the register allocator that the upcoming
        ;; sequence of instructions will overwrite `dst` so it should be
        ;; considered as a `def`; use this with care.
@@ -710,6 +732,184 @@
        ;; A pseudoinstruction that just keeps a value alive.
        (DummyUse (reg Reg))))
 
+(model MInst (type (bv 1)))
+
+;; MovzxRmR
+;; Zero-extended loads, except for 64 bits: movz (bl bq wl wq lq) addr reg.
+;; Note that the lq variant doesn't really exist since the default
+;; zero-extend rule makes it unnecessary. For that case we emit the
+;; equivalent "movl AM, reg32".
+
+; Parameters of a load operation.
+(state isa_load
+    (type
+        (struct
+            (active Bool)
+            (size_bits Int)
+            (addr (bv 64))
+        )
+    )
+    (default
+        (not (:active isa_load))
+    )
+)
+
+(spec
+  (MInst.MovzxRmR ext_mode src dst)
+  (modifies isa_load)
+
+  (provide
+    (=> (not (:isMem src))
+            (= dst (:data src)))
+    ;; Only handle the “memory” case; require that isMem=1
+    ;; TODO: handle more cases https://github.com/wellesley-prog-sys/wasmtime/issues/31
+    (=>
+      ( :isMem src )    
+      (and ;; isMem true 
+      ;; mark that we did a load 
+      (= (:active isa_load) true)
+      ;; record how many bits we loaded
+      (= (:size_bits isa_load)
+         (switch ext_mode
+           ((ExtMode.BL)  8) ((ExtMode.BQ)  8)
+           ((ExtMode.WL) 16) ((ExtMode.WQ) 16)
+           ((ExtMode.LQ) 32)))
+      ;; compute effective address from the raw 64‑bit data field
+      (= (:addr isa_load) (:data src))
+      ;; zero‑extend the loaded value into dst
+      (= dst
+         (switch ext_mode
+           ((ExtMode.BL) (zero_ext 64 (conv_to 8  loaded_value)))
+           ((ExtMode.BQ) (zero_ext 64 (conv_to 8  loaded_value)))
+           ((ExtMode.WL) (zero_ext 64 (conv_to 16 loaded_value)))
+           ((ExtMode.WQ) (zero_ext 64 (conv_to 16 loaded_value)))
+           ((ExtMode.LQ) (zero_ext 64 (conv_to 32 loaded_value)))))))
+  )
+)
+
+
+; Parameters of a store operation.
+(state isa_store
+    (type
+        (struct
+            (active Bool)
+            (size_bits Int)
+            (addr (bv 64))
+            (value (bv 64))
+        )
+    )
+    (default
+        (and
+            ; Store is not active.
+            (not (:active isa_store))
+
+            ; Must provide a fixed size in the default case, otherwise type
+            ; inference is underconstrained.
+            (= (:size_bits isa_store) 1)
+        )
+    )
+)
+
+;;MovRM - integer stores, i.e. mov (b w l q) reg addr. 
+;; MovRm (size OperandSize) ;; 1, 2, 4, or 8
+;;       (src Gpr)
+;;       (dst SyntheticAmode)
+(spec (MInst.MovRM size src dst)
+      ;; marks store active
+      (modifies isa_store)
+      ;; provide block
+      (provide 
+            ;; we are doing a store
+            (= (:active isa_store) true)
+            ;; size in bit = size * 8 
+            (= (:size_bits isa_store)
+                  (switch size
+                        ((OperandSize.Size8) 8)
+                        ((OperandSize.Size16) 16)
+                        ((OperandSize.Size32) 32)
+                        ((OperandSize.Size64) 64)
+                  )
+            )
+            ;; address 
+            (= (:addr isa_store) dst)
+            ;; value to store
+            (= (:value isa_store) src)))
+
+;; Integer arithmetic read-modify-write on memory.
+      ;; (AluRM (size OperandSize) ;; 1, 2, 4 or 8
+            ;; (op AluRmiROpcode)
+            ;; (src1_dst SyntheticAmode)
+            ;; (src2 Gpr))
+;; add [rdi], rax 
+      ;; read @ (rdi); add rax into it; write @ (rdi). 
+(spec (MInst.AluRM size op src1 src2)
+      ;; active load and store
+      (modifies isa_load)
+      (modifies isa_store)
+      ;; provide block
+      (provide 
+            ;; load from memory 
+            (= (:active isa_load) true)
+            (= (:addr isa_load) src1)
+            (= (:size_bits isa_load)
+                  (switch size
+                        ((OperandSize.Size32) 32)
+                        ((OperandSize.Size8) 8)
+                        ((OperandSize.Size16) 16)
+                        ((OperandSize.Size64) 64)))
+            ;; compute new value
+            (= (:value isa_store) 
+                  (bvxor loaded_value src2
+                  ))
+            ;; store back to memory 
+            (= (:active isa_store) true)
+            (= (:addr isa_store) src1)
+            (= (:size_bits isa_store) (:size_bits isa_load))
+      )
+)
+
+
+; TODO(mbm): AluRmiR must handle memory and immediate forms of src2 operand
+(spec (MInst.AluRmiR size op src1 src2 dst)
+      (provide
+            ; Execute opcode.
+            (=
+                  dst
+                  (switch size
+                        ; 64-bit forms operate on full register
+                        ((OperandSize.Size64)
+                              (switch op
+                                    ((AluRmiROpcode.Add) (bvadd src1 src2))
+                              )
+                        )
+                        ; 32-bit forms zero-extend to full general purpose register.
+                        ((OperandSize.Size32)
+                              (switch op
+                                    ((AluRmiROpcode.Add) (zero_ext 64 (bvadd (extract 31 0 src1) (extract 31 0 src2))))
+                              )
+                        )
+                  )
+            )
+      )
+)
+
+(spec
+      (MInst.LoadEffectiveAddress
+            addr ; SyntheticAmode
+            dst  ; WritableGpr
+            size ; OperandSize
+      )
+      (provide
+            (=
+                  dst
+                  (switch size
+                        ((OperandSize.Size64) addr)
+                        ((OperandSize.Size32) (zero_ext 64 (extract 31 0 addr)))
+                  )
+            )
+      )
+)
+
 (type OperandSize extern
       (enum Size8
             Size16
@@ -730,10 +930,23 @@
 
 ;; Get the `OperandSize` for a given `Type`, rounding smaller types up to 32 bits.
 (decl operand_size_of_type_32_64 (Type) OperandSize)
+(spec (operand_size_of_type_32_64 ty)
+      (provide
+            (= result (if (= (:bits ty) 64) (OperandSize.Size64) (OperandSize.Size32)))
+      )
+)
 (extern constructor operand_size_of_type_32_64 operand_size_of_type_32_64)
 
 ;; Get the true `OperandSize` for a given `Type`, with no rounding.
 (decl raw_operand_size_of_type (Type) OperandSize)
+(spec (raw_operand_size_of_type ty)
+  (provide
+    (= result
+       (switch (:bits ty)
+         (8  (OperandSize.Size8))
+         (16 (OperandSize.Size16))
+         (32 (OperandSize.Size32))
+         (64 (OperandSize.Size64))))))
 (extern constructor raw_operand_size_of_type raw_operand_size_of_type)
 
 ;; Get the bit width of an `OperandSize`.
@@ -750,8 +963,7 @@
             Sbb
             And
             Or
-            Xor
-            Mul))
+            Xor))
 
 (type AluRmROpcode
       (enum Andn
@@ -951,6 +1163,7 @@
             Ucomiss
             Ucomisd
             Unpcklps
+            Unpcklpd
             Unpckhps
             Xorps
             Xorpd
@@ -970,12 +1183,29 @@
       (enum Cmp
             Test))
 
+;; Registers.
+(model Reg (type (bv)))
+
 (type RegMemImm extern
       (enum
        (Reg (reg Reg))
        (Mem (addr SyntheticAmode))
        (Imm (simm32 u32))))
 
+(model RegMemImm (type (bv)))
+
+(spec (RegMemImm.Imm simm32) (provide
+      (= result
+            (bvor (bvshl #b10 62)(zero_ext 64 simm32)))
+))
+
+(spec (RegMemImm.Mem addr) (provide 
+      (= result 
+            (bvor
+                  #x4000000000000000 addr
+            ))
+))
+
 ;; Put the given clif value into a `RegMemImm` operand.
 ;;
 ;; Asserts that the value fits into a single register, and doesn't require
@@ -983,8 +1213,12 @@
 ;;
 ;; As a side effect, this marks the value as used.
 (decl put_in_reg_mem_imm (Value) RegMemImm)
+(spec (put_in_reg_mem_imm arg)
+      (provide (= result (conv_to (widthof result) arg)))
+)
 (extern constructor put_in_reg_mem_imm put_in_reg_mem_imm)
 
+(model RegMem (type (bv)))
 (type RegMem extern
       (enum
        (Reg (reg Reg))
@@ -1009,11 +1243,14 @@
 ;; Addressing modes.
 
 (type SyntheticAmode extern (enum))
+(model SyntheticAmode (type (bv 64)))
 
 (decl synthetic_amode_to_reg_mem (SyntheticAmode) RegMem)
+(spec (synthetic_amode_to_reg_mem am) (provide(= result am)))
 (extern constructor synthetic_amode_to_reg_mem synthetic_amode_to_reg_mem)
 
 (decl amode_to_synthetic_amode (Amode) SyntheticAmode)
+(spec (amode_to_synthetic_amode amode) (provide (= result (:addr amode))))
 (extern constructor amode_to_synthetic_amode amode_to_synthetic_amode)
 
 ;; An `Amode` represents a possible addressing mode that can be used
@@ -1037,6 +1274,42 @@
              ;; the given MachLabel.
              (RipRelative (target MachLabel))))
 
+; Model `Amode` as a computed address with flags.
+(model Amode (type
+      (struct
+            (addr  (bv 64))
+            (flags (named MemFlags))
+      )
+))
+
+; ImmReg addressing mode.
+(spec (Amode.ImmReg simm32 base flags)
+      (provide
+            ; Address calculation.
+            (= (:addr result) (bvadd base (sign_ext 64 simm32)))
+
+            ; Flags passthrough.
+            (= (:flags result) flags)
+      )
+)
+
+; ImmRegRegShift addressing mode.
+(spec (Amode.ImmRegRegShift simm32 base index shift flags)
+      (provide
+            ; Address calculation.
+            (=
+                  (:addr result)
+                  (bvadd
+                        (bvadd base (sign_ext 64 simm32))
+                        (bvshl index (zero_ext 64 shift))
+                  )
+            )
+
+            ; Flags passthrough.
+            (= (:flags result) flags)
+      )
+)
+
 ;; A helper to both check that the `Imm64` and `Offset32` values sum to less
 ;; than 32-bits AND return this summed `u32` value. Also, the `Imm64` will be
 ;; zero-extended from `Type` up to 64 bits. This is useful for `to_amode`.
@@ -1080,8 +1353,9 @@
 (decl to_amode (MemFlags Value Offset32) Amode)
 (rule 0 (to_amode flags base offset)
         (amode_imm_reg flags base offset))
-(rule 1 (to_amode flags (iadd x y) offset)
+(rule 1 (to_amode flags (iadd _ x y) offset)
         (to_amode_add flags x y offset))
+(attr to_amode (veri chain))
 
 ;; Same as `to_amode`, except that the base address is computed via the addition
 ;; of the two `Value` arguments provided.
@@ -1095,25 +1369,25 @@
 ;; In other words this function's job is to find constants and then defer to
 ;; `amode_imm_reg*`.
 (decl to_amode_add (MemFlags Value Value Offset32) Amode)
-
+(attr to_amode_add (veri chain))
 (rule 0 (to_amode_add flags x y offset)
         (amode_imm_reg_reg_shift flags x y offset))
-(rule 1 (to_amode_add flags x (iconst (simm32 c)) offset)
+(rule 1 (to_amode_add flags x (i32_from_iconst c) offset)
         (if-let sum (s32_add_fallible offset c))
         (amode_imm_reg flags x sum))
-(rule 2 (to_amode_add flags (iconst (simm32 c)) x offset)
+(rule 2 (to_amode_add flags (i32_from_iconst c) x offset)
         (if-let sum (s32_add_fallible offset c))
         (amode_imm_reg flags x sum))
-(rule 3 (to_amode_add flags (iadd x (iconst (simm32 c))) y offset)
+(rule 3 (to_amode_add flags (iadd _ x (i32_from_iconst c)) y offset)
         (if-let sum (s32_add_fallible offset c))
         (amode_imm_reg_reg_shift flags x y sum))
-(rule 4 (to_amode_add flags (iadd (iconst (simm32 c)) x) y offset)
+(rule 4 (to_amode_add flags (iadd _ (i32_from_iconst c) x) y offset)
         (if-let sum (s32_add_fallible offset c))
         (amode_imm_reg_reg_shift flags x y sum))
-(rule 5 (to_amode_add flags x (iadd y (iconst (simm32 c))) offset)
+(rule 5 (to_amode_add flags x (iadd _ y (i32_from_iconst c)) offset)
         (if-let sum (s32_add_fallible offset c))
         (amode_imm_reg_reg_shift flags x y sum))
-(rule 6 (to_amode_add flags x (iadd (iconst (simm32 c)) y) offset)
+(rule 6 (to_amode_add flags x (iadd _ (i32_from_iconst c) y) offset)
         (if-let sum (s32_add_fallible offset c))
         (amode_imm_reg_reg_shift flags x y sum))
 
@@ -1121,18 +1395,20 @@
 ;; to pattern match add-of-shifts to generate fancier `ImmRegRegShift` modes,
 ;; otherwise falls back on `ImmReg`.
 (decl amode_imm_reg (MemFlags Value Offset32) Amode)
+(attr amode_imm_reg (veri chain))
 (rule 0 (amode_imm_reg flags base offset)
         (Amode.ImmReg offset base flags))
-(rule 1 (amode_imm_reg flags (iadd x y) offset)
+(rule 1 (amode_imm_reg flags (iadd _ x y) offset)
         (amode_imm_reg_reg_shift flags x y offset))
 
 (decl amode_imm_reg_reg_shift (MemFlags Value Value Offset32) Amode)
+(attr amode_imm_reg_reg_shift (veri chain))
 (rule 0 (amode_imm_reg_reg_shift flags x y offset)
         (Amode.ImmRegRegShift offset x y 0 flags)) ;; 0 == y<<0 == "no shift"
-(rule 1 (amode_imm_reg_reg_shift flags x (ishl y (iconst (uimm8 shift))) offset)
+(rule 1 (amode_imm_reg_reg_shift flags x (ishl _ y (iconst _ (uimm8 shift))) offset)
         (if (u32_lteq (u8_as_u32 shift) 3))
         (Amode.ImmRegRegShift offset x y shift flags))
-(rule 2 (amode_imm_reg_reg_shift flags (ishl y (iconst (uimm8 shift))) x offset)
+(rule 2 (amode_imm_reg_reg_shift flags (ishl _ y (iconst _ (uimm8 shift))) x offset)
         (if (u32_lteq (u8_as_u32 shift) 3))
         (Amode.ImmRegRegShift offset x y shift flags))
 
@@ -1143,6 +1419,7 @@
 
 ;; Return a zero offset as an `Offset32`.
 (decl zero_offset () Offset32)
+(spec (zero_offset) (provide (= result #x00000000)))
 (extern constructor zero_offset zero_offset)
 
 ;; Shift kinds.
@@ -1168,6 +1445,21 @@
 ;;
 ;; This is used when lowering various shifts and rotates.
 (decl put_masked_in_imm8_gpr (Value Type) Imm8Gpr)
+(spec (put_masked_in_imm8_gpr amt ty) (provide 
+            (= (:Imm8 result)
+                  (bvand 
+                        (conv_to 8 amt)
+                        (switch (:bits ty)
+                              (8 #x07)
+                              (16 #x0f)
+                              (32 #x1f)
+                              (64 #x3f)
+                        )
+                  )
+            )
+            (= (:isReg result) false)
+            (= (:reg result) #x0000000000000000)
+      ))
 (rule 2 (put_masked_in_imm8_gpr (u64_from_iconst amt) ty)
       (const_to_type_masked_imm8 amt ty))
 (rule 1 (put_masked_in_imm8_gpr amt (fits_in_16 ty))
@@ -1221,6 +1513,22 @@
             Vfnmadd132sd
             Vfnmadd132ps
             Vfnmadd132pd
+            Vfmsub213ss
+            Vfmsub213sd
+            Vfmsub213ps
+            Vfmsub213pd
+            Vfmsub132ss
+            Vfmsub132sd
+            Vfmsub132ps
+            Vfmsub132pd
+            Vfnmsub213ss
+            Vfnmsub213sd
+            Vfnmsub213ps
+            Vfnmsub213pd
+            Vfnmsub132ss
+            Vfnmsub132sd
+            Vfnmsub132ps
+            Vfnmsub132pd
             Vcmpps
             Vcmppd
             Vpsrlw
@@ -1264,6 +1572,7 @@
             Vpunpckhwd
             Vpunpcklwd
             Vunpcklps
+            Vunpcklpd
             Vunpckhps
             Vandnps
             Vandnpd
@@ -1393,6 +1702,9 @@
             Vsqrtsd
             Vroundss
             Vroundsd
+            Vucomiss
+            Vucomisd
+            Vptest
           ))
 
 (type Avx512Opcode
@@ -1429,11 +1741,23 @@
 ;;;; Newtypes for Different Register Classes ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (type Gpr (primitive Gpr))
+(model Gpr (type (bv 64)))
 (type WritableGpr (primitive WritableGpr))
+(model WritableGpr (type (bv)))
 (type OptionWritableGpr (primitive OptionWritableGpr))
 (type GprMem extern (enum))
+(model GprMem (type
+  (struct (data (bv 64))
+          (isMem Bool)))
+)
 (type GprMemImm extern (enum))
+(model GprMemImm (type (bv)))
 (type Imm8Gpr extern (enum))
+(model Imm8Gpr (type 
+      (struct (Imm8 (bv 8))
+              (isReg Bool)
+              (reg (bv 64))
+      )))
 
 (type Xmm (primitive Xmm))
 (type WritableXmm (primitive WritableXmm))
@@ -1473,10 +1797,12 @@
 
 ;; Convert a `WritableGpr` to an `Gpr`.
 (decl writable_gpr_to_gpr (WritableGpr) Gpr)
+(spec (writable_gpr_to_gpr arg) (provide (= result arg)))
 (extern constructor writable_gpr_to_gpr writable_gpr_to_gpr)
 
 ;; Convert an `Gpr` to a `Reg`.
 (decl gpr_to_reg (Gpr) Reg)
+(spec (gpr_to_reg arg) (provide (= result arg)))
 (extern constructor gpr_to_reg gpr_to_reg)
 
 ;; Convert an `Gpr` to a `GprMem`.
@@ -1520,6 +1846,7 @@
 
 ;; Allocate a new temporary GPR register.
 (decl temp_writable_gpr () WritableGpr)
+(spec (temp_writable_gpr) (provide true))
 (extern constructor temp_writable_gpr temp_writable_gpr)
 
 ;; Allocate a new temporary XMM register.
@@ -1540,6 +1867,7 @@
 ;;
 ;; Asserts that the `RegMemImm`'s register, if any, is an GPR register.
 (decl gpr_mem_imm_new (RegMemImm) GprMemImm)
+(spec (gpr_mem_imm_new arg) (provide (= result arg)))
 (extern constructor gpr_mem_imm_new gpr_mem_imm_new)
 
 ;; Construct a new `XmmMemImm` from the given `RegMemImm`.
@@ -1553,7 +1881,7 @@
 (extern constructor xmm_to_xmm_mem xmm_to_xmm_mem)
 
 ;; Construct a new `XmmMem` from an `RegMem`.
-(decl xmm_mem_to_reg_mem (XmmMem) RegMem)
+(decl pure xmm_mem_to_reg_mem (XmmMem) RegMem)
 (extern constructor xmm_mem_to_reg_mem xmm_mem_to_reg_mem)
 
 ;; Convert a `GprMem` to a `RegMem`.
@@ -1570,12 +1898,17 @@
 ;;
 ;; Asserts that the register is a GPR.
 (decl gpr_new (Reg) Gpr)
+(spec (gpr_new arg) (provide (= result arg)))
 (extern constructor gpr_new gpr_new)
 
 ;; Construct a new `GprMem` from a `RegMem`.
 ;;
 ;; Asserts that the `RegMem`'s register, if any, is a GPR.
 (decl reg_mem_to_gpr_mem (RegMem) GprMem)
+(spec (reg_mem_to_gpr_mem rm)
+  (provide
+    (= (:data result) rm)
+    (= (:isMem result) true))) 
 (extern constructor reg_mem_to_gpr_mem reg_mem_to_gpr_mem)
 
 ;; Construct a `GprMem` from a `Reg`.
@@ -1593,11 +1926,27 @@
 
 ;; Put a value into a GPR.
 ;;
-;; Asserts that the value goes into a GPR.
+;; Moves the value into a GPR if it is a type that would naturally go into an
+;; XMM register.
 (decl put_in_gpr (Value) Gpr)
+
+; REVIEW(mbm): should apply chaining to put_in_gpr, but rules require enum modeling
+; TODO(mbm): modeling extractor matches on non-trivial enum like RegisterClass
+(spec (put_in_gpr arg) (provide (= result (conv_to 64 arg))))
+
+;; Case for when the value naturally lives in a GPR.
 (rule (put_in_gpr val)
+      (if-let (value_type ty) val)
+      (if-let (type_register_class (RegisterClass.Gpr _)) ty)
       (gpr_new (put_in_reg val)))
 
+;; Case for when the value naturally lives in an XMM register and we must
+;; bitcast it from an XMM into a GPR.
+(rule (put_in_gpr val)
+      (if-let (value_type ty) val)
+      (if-let (type_register_class (RegisterClass.Xmm)) ty)
+      (bitcast_xmm_to_gpr (ty_bits ty) (xmm_new (put_in_reg val))))
+
 ;; Put a value into a `GprMem`.
 ;;
 ;; Asserts that the value goes into a GPR.
@@ -1655,6 +2004,11 @@
 
 ;; Convert a `Gpr` to an `Imm8Gpr`.
 (decl gpr_to_imm8_gpr (Gpr) Imm8Gpr)
+(spec (gpr_to_imm8_gpr gpr) (provide 
+      (= (:reg result) gpr)
+      (= (:isReg result) true)
+      (= (:Imm8 result) #x00)
+))
 (extern constructor gpr_to_imm8_gpr gpr_to_imm8_gpr)
 
 ;; Convert an 8-bit immediate into an `Imm8Gpr`.
@@ -1669,15 +2023,6 @@
 (decl xmi_imm (u32) XmmMemImm)
 (extern constructor xmi_imm xmi_imm)
 
-;;;; Helpers for Working With Integer Comparison Codes ;;;;;;;;;;;;;;;;;;;;;;;;;
-;;
-
-;; This is a direct import of `IntCC::without_equal`.
-;; Get the corresponding IntCC with the equal component removed.
-;; For conditions without a zero component, this is a no-op.
-(decl intcc_without_eq (IntCC) IntCC)
-(extern constructor intcc_without_eq intcc_without_eq)
-
 ;;;; Helpers for determining the register class of a value type ;;;;;;;;;;;;;;;;
 
 (type RegisterClass
@@ -1692,6 +2037,7 @@
 (extractor (is_xmm_type ty) (and (type_register_class (RegisterClass.Xmm)) ty))
 
 (decl is_gpr_type (Type) Type)
+(spec (is_gpr_type arg) (provide (= result arg)))
 (extractor (is_gpr_type ty) (and (type_register_class (RegisterClass.Gpr _)) ty))
 
 (decl is_single_register_gpr_type (Type) Type)
@@ -1760,10 +2106,37 @@
 ;; shift/rotate more bits than the type has available, per Cranelift's
 ;; semantics.
 (decl const_to_type_masked_imm8 (u64 Type) Imm8Gpr)
+;; turn a 64-bit constant into a legal 8-bit Gpr immediate by
+;; masking off lal but the low shift-count bits for 'ty'
+(spec
+  (const_to_type_masked_imm8 u ty)
+  (provide 
+      (= (:Imm8 result)
+         (bvand
+            (zero_ext 8 u)
+            (switch (:bits ty)
+                  (8   #x07)  ;; 3‑bit mask for  8‑bit shifts
+                  (16  #x0f)  ;; 4‑bit mask for 16‑bit shifts
+                  (32  #x1f)  ;; 5‑bit mask for 32‑bit shifts
+                  (64  #x3f)  ;; 6‑bit mask for 64‑bit shifts
+            ) 
+         )
+      )
+      (= (:isReg result) false)
+))
+
 (extern constructor const_to_type_masked_imm8 const_to_type_masked_imm8)
 
 ;; Generate a mask for the bit-width of the given type
 (decl shift_mask (Type) u8)
+(spec (shift_mask ty)
+  (provide
+    (= result
+       (switch (:bits ty)
+         (8  #x07)   ;; 3‑bit mask for 8‑bit shifts
+         (16 #x0f)   ;; 4‑bit mask for 16‑bit shifts
+         (32 #x1f)   ;; 5‑bit mask for 32‑bit shifts
+         (64 #x3f))))) ;; 6‑bit mask for 64‑bit shifts
 (extern constructor shift_mask shift_mask)
 
 ;; Mask a constant with the type's shift mask
@@ -1774,12 +2147,9 @@
 (decl simm32_from_value (GprMemImm) Value)
 (extern extractor simm32_from_value simm32_from_value)
 
-;; Extract a constant `RegMemImm.Imm` from an `Imm64` immediate.
-(decl simm32_from_imm64 (GprMemImm) Imm64)
-(extern extractor simm32_from_imm64 simm32_from_imm64)
-
 ;; A load that can be sunk into another operation.
 (type SinkableLoad extern (enum))
+(model SinkableLoad (type (bv)))
 
 ;; Extract a `SinkableLoad` that works with `RegMemImm.Mem` from a value
 ;; operand.
@@ -1789,6 +2159,7 @@
 ;; instructions which load exactly the type width necessary use
 ;; `sinkable_load_exact`.
 (decl sinkable_load (SinkableLoad) Value)
+(spec (sinkable_load sl) (provide (= result sl)))
 (extern extractor sinkable_load sinkable_load)
 
 ;; Same as `sinkable_load` except that all type widths of loads are supported.
@@ -1804,6 +2175,7 @@
 ;; instruction that produced the `SinkableImm` has been sunk into another
 ;; instruction, and no longer needs to be lowered.
 (decl sink_load (SinkableLoad) SyntheticAmode)
+(spec (sink_load sl) (provide (= result sl)))
 (extern constructor sink_load sink_load)
 
 (decl sink_load_to_gpr_mem_imm (SinkableLoad) GprMemImm)
@@ -1827,7 +2199,7 @@
 ;;
 ;; These helpers are intended to assist in emitting instructions by taking
 ;; source operands and automatically creating output operands which are then
-;; returned. These are additionally deisgned to assist with SSA-like
+;; returned. These are additionally designed to assist with SSA-like
 ;; construction where the writable version of a register is only present in
 ;; an `MInst` and every other reference to it is a readonly version.
 
@@ -2055,22 +2427,6 @@
             (_ Unit (emit (MInst.XmmRmRVex3 op src1 src2 src3 dst))))
         dst))
 
-;; Helper for creating `MInst.MulHi` instructions.
-;;
-;; Returns the (lo, hi) register halves of the multiplication.
-(decl mul_hi (Type bool Gpr GprMem) ValueRegs)
-(rule (mul_hi ty signed src1 src2)
-      (let ((dst_lo WritableGpr (temp_writable_gpr))
-            (dst_hi WritableGpr (temp_writable_gpr))
-            (size OperandSize (raw_operand_size_of_type ty))
-            (_ Unit (emit (MInst.MulHi size
-                                       signed
-                                       src1
-                                       src2
-                                       dst_lo
-                                       dst_hi))))
-        (value_gprs dst_lo dst_hi)))
-
 ;; Helper for creating `MInst.UnaryRmR` instructions.
 (decl unary_rm_r (UnaryRmROpcode Gpr OperandSize) Gpr)
 (rule (unary_rm_r op src size)
@@ -2157,12 +2513,28 @@
 ;; `ExtMode::new`
 (decl ext_mode (u16 u16) ExtMode)
 (extern constructor ext_mode ext_mode)
+(spec (ext_mode src_bits dst_bits)
+  ;; only extend from shorter to longer bits 
+  (require (bvule src_bits dst_bits))
+  (provide
+    ;; mirror Rust’s ExtMode::new match:
+    (= result
+       (if (= src_bits #x0008)
+           (if (= dst_bits #x0020)
+               (ExtMode.BL)
+               (ExtMode.BQ))
+         (if (= src_bits #x0010)
+             (if (= dst_bits #x0020)
+                 (ExtMode.WL)
+                 (ExtMode.WQ))
+             (ExtMode.LQ)))))
+)
 
 ;; Put the given value into a register, but extended as the given type.
 (decl extend_to_gpr (Value Type ExtendKind) Gpr)
 
 ;; If the value is already of the requested type, no extending is necessary.
-(rule 2 (extend_to_gpr val @ (value_type ty) ty _kind)
+(rule 3 (extend_to_gpr val @ (value_type ty) ty _kind)
       val)
 
 ;; I32 -> I64 with op that produces a zero-extended value in a register.
@@ -2170,13 +2542,22 @@
 ;; As a particular x64 extra-pattern matching opportunity, all the ALU
 ;; opcodes on 32-bits will zero-extend the upper 32-bits, so we can
 ;; even not generate a zero-extended move in this case.
-(rule 1 (extend_to_gpr src @ (value_type $I32) $I64 (ExtendKind.Zero))
+(rule 2 (extend_to_gpr src @ (value_type $I32) $I64 (ExtendKind.Zero))
         (if-let $true (value32_zeros_upper32 src))
-        src)
+        (add_range_fact src 64 0 0xffff_ffff))
+
+;; Both extend instructions are guaranteed to load exactly the source type's size.
+;; So we can use `sinkable_load_exact` here to sink loads for small types (<= 16 bits).
+(rule 1 (extend_to_gpr (and (sinkable_load_exact val) (value_type from_ty)) to_ty kind)
+      (extend_to_gpr_types val from_ty to_ty kind))
 
-(rule (extend_to_gpr (and val (value_type from_ty))
-                     to_ty
-                     kind)
+;; Otherwise emit the extend from a Gpr to a Gpr.
+(rule (extend_to_gpr (and val (value_type from_ty)) to_ty kind)
+      (extend_to_gpr_types val from_ty to_ty kind))
+
+;; Calculates the correct extension mode for an extend between `from_ty` and `to_ty`.
+(decl extend_to_gpr_types (GprMem Type Type ExtendKind) Gpr)
+(rule (extend_to_gpr_types val from_ty to_ty kind)
       (let ((from_bits u16 (ty_bits_u16 from_ty))
             ;; Use `operand_size_of_type` so that the we clamp the output to 32-
             ;; or 64-bit width types.
@@ -2184,7 +2565,8 @@
         (extend kind
                 to_ty
                 (ext_mode from_bits to_bits)
-                (put_in_gpr_mem val))))
+                val)))
+
 
 ;; Do a sign or zero extension of the given `GprMem`.
 (decl extend (ExtendKind Type ExtMode GprMem) Gpr)
@@ -2201,15 +2583,15 @@
 ;; be a 32-bit operation, will automatically zero the upper 32-bits of the
 ;; destination register that `Value` is placed in.
 (decl pure value32_zeros_upper32 (Value) bool)
-(rule (value32_zeros_upper32 (iadd _ _)) $true)
-(rule (value32_zeros_upper32 (isub _ _)) $true)
-(rule (value32_zeros_upper32 (imul _ _)) $true)
-(rule (value32_zeros_upper32 (band _ _)) $true)
-(rule (value32_zeros_upper32 (bor _ _)) $true)
-(rule (value32_zeros_upper32 (bxor _ _)) $true)
-(rule (value32_zeros_upper32 (ishl _ _)) $true)
-(rule (value32_zeros_upper32 (ushr _ _)) $true)
-(rule (value32_zeros_upper32 (uload32 _ _ _)) $true)
+(rule (value32_zeros_upper32 (iadd _ _ _)) $true)
+(rule (value32_zeros_upper32 (isub _ _ _)) $true)
+(rule (value32_zeros_upper32 (imul _ _ _)) $true)
+(rule (value32_zeros_upper32 (band _ _ _)) $true)
+(rule (value32_zeros_upper32 (bor _ _ _)) $true)
+(rule (value32_zeros_upper32 (bxor _ _ _)) $true)
+(rule (value32_zeros_upper32 (ishl _ _ _)) $true)
+(rule (value32_zeros_upper32 (ushr _ _ _)) $true)
+(rule (value32_zeros_upper32 (uload32 _ _ _ _)) $true)
 (rule -1 (value32_zeros_upper32 _) $false)
 
 ;;;; Helpers for Working SSE tidbits ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -2223,8 +2605,10 @@
 
 ;; Performs an xor operation of the two operands specified.
 (decl x64_xor_vector (Type Xmm XmmMem) Xmm)
+(rule 1 (x64_xor_vector $F16 x y) (x64_xorps x y))
 (rule 1 (x64_xor_vector $F32 x y) (x64_xorps x y))
 (rule 1 (x64_xor_vector $F64 x y) (x64_xorpd x y))
+(rule 1 (x64_xor_vector $F128 x y) (x64_xorps x y))
 (rule 1 (x64_xor_vector $F32X4 x y) (x64_xorps x y))
 (rule 1 (x64_xor_vector $F64X2 x y) (x64_xorpd x y))
 (rule 0 (x64_xor_vector (multi_lane _ _) x y) (x64_pxor x y))
@@ -2236,7 +2620,7 @@
 ;; done for integers. This is because we're comparing a fresh register to itself
 ;; and we don't know the previous contents of the register. If a floating-point
 ;; comparison is used then it runs the risk of comparing NaN against NaN and not
-;; actually producing an all-ones mask. By using integer comparision operations
+;; actually producing an all-ones mask. By using integer comparison operations
 ;; we're guaranteeed that everything is equal to itself.
 (decl vector_all_ones () Xmm)
 (rule (vector_all_ones)
@@ -2257,6 +2641,17 @@
 (decl gen_call_indirect (SigRef Value ValueSlice) InstOutput)
 (extern constructor gen_call_indirect gen_call_indirect)
 
+;;;; Helpers for emitting stack switches ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(decl x64_stack_switch_basic (Gpr Gpr Gpr) Gpr)
+(rule (x64_stack_switch_basic store_context_ptr load_context_ptr in_payload0)
+      (let ((out_payload0 WritableGpr (temp_writable_gpr))
+            (_ Unit (emit (MInst.StackSwitchBasic store_context_ptr
+                                                  load_context_ptr
+                                                  in_payload0
+                                                  out_payload0))))
+        out_payload0))
+
 ;;;; Helpers for Emitting Loads ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Load a value into a register.
@@ -2275,6 +2670,9 @@
 (rule 2 (x64_load $F64 addr _ext_kind)
       (x64_movsd_load addr))
 
+(rule 2 (x64_load $F128 addr _ext_kind)
+      (x64_movdqu_load addr))
+
 (rule 2 (x64_load $F32X4 addr _ext_kind)
       (x64_movups_load addr))
 
@@ -2502,6 +2900,7 @@
          dst)))
 
 (decl x64_alurmi_with_flags_paired (AluRmiROpcode Type Gpr GprMemImm) ProducesFlags)
+(attr x64_alurmi_with_flags_paired (veri chain))
 (rule (x64_alurmi_with_flags_paired opc (fits_in_64 ty) src1 src2)
       (let ((dst WritableGpr (temp_writable_gpr)))
         (ProducesFlags.ProducesFlagsReturnsResultWithConsumer
@@ -2512,8 +2911,19 @@
                         dst)
          dst)))
 
+(decl x64_alurmi_flags_side_effect (AluRmiROpcode Type Gpr GprMemImm) ProducesFlags)
+(attr x64_alurmi_flags_side_effect (veri chain))
+(rule (x64_alurmi_flags_side_effect opc (fits_in_64 ty) src1 src2)
+      (ProducesFlags.ProducesFlagsSideEffect
+       (MInst.AluRmiR (raw_operand_size_of_type ty)
+                      opc
+                      src1
+                      src2
+                      (temp_writable_gpr))))
+
 ;; Should only be used for Adc and Sbb
 (decl x64_alurmi_with_flags_chained (AluRmiROpcode Type Gpr GprMemImm) ConsumesAndProducesFlags)
+(attr x64_alurmi_with_flags_chained (veri chain))
 (rule (x64_alurmi_with_flags_chained opc (fits_in_64 ty) src1 src2)
       (let ((dst WritableGpr (temp_writable_gpr)))
         (ConsumesAndProducesFlags.ReturnsReg
@@ -2568,31 +2978,55 @@
                         dst)
          dst)))
 
-;; Helper for creating `mul` instructions.
-(decl x64_mul (Type Gpr GprMemImm) Gpr)
-(rule (x64_mul ty src1 src2)
-      (alu_rmi_r ty
-                 (AluRmiROpcode.Mul)
-                 src1
-                 src2))
+;; Helper for creating `mul` instructions or `imul` instructions (depending
+;; on `signed`)
+(decl x64_mul (Type bool Gpr GprMem) ValueRegs)
+(rule (x64_mul ty signed src1 src2)
+      (let ((dst_lo WritableGpr (temp_writable_gpr))
+            (dst_hi WritableGpr (temp_writable_gpr))
+            (size OperandSize (raw_operand_size_of_type ty))
+            (_ Unit (emit (MInst.Mul size signed src1 src2 dst_lo dst_hi))))
+        (value_gprs dst_lo dst_hi)))
 
-;; Helper for creating `umullo` instructions.
-(decl x64_umullo (Type Gpr GprMem) Gpr)
-(rule (x64_umullo ty src1 src2)
+;; Helper for creating `mul` instructions or `imul` instructions (depending
+;; on `signed`) for 8-bit operands.
+(decl x64_mul8 (bool Gpr GprMem) Gpr)
+(rule (x64_mul8 signed src1 src2)
+      (let ((dst WritableGpr (temp_writable_gpr))
+            (_ Unit (emit (MInst.Mul8 signed src1 src2 dst))))
+        dst))
+
+;; Helper for creating `imul` instructions.
+(decl x64_imul (Type Gpr GprMem) Gpr)
+(rule (x64_imul ty src1 src2)
       (let ((dst WritableGpr (temp_writable_gpr))
             (size OperandSize (raw_operand_size_of_type ty))
-            (_ Unit (emit (MInst.UMulLo size src1 src2 dst))))
+            (_ Unit (emit (MInst.IMul size src1 src2 dst))))
         dst))
 
-(decl x64_umullo_with_flags_paired (Type Gpr GprMem) ProducesFlags)
-(rule (x64_umullo_with_flags_paired ty src1 src2)
+;; Helper for creating `imul` instructions with an immediate operand.
+(decl x64_imul_imm (Type GprMem i32) Gpr)
+(rule (x64_imul_imm ty src1 src2)
+      (let ((dst WritableGpr (temp_writable_gpr))
+            (size OperandSize (raw_operand_size_of_type ty))
+            (_ Unit (emit (MInst.IMulImm size src1 src2 dst))))
+        dst))
+
+(decl x64_mul8_with_flags_paired (bool Gpr GprMem) ProducesFlags)
+(rule (x64_mul8_with_flags_paired signed src1 src2)
       (let ((dst WritableGpr (temp_writable_gpr)))
            (ProducesFlags.ProducesFlagsReturnsResultWithConsumer
-                 (MInst.UMulLo (raw_operand_size_of_type ty)
-                               src1
-                               src2
-                               dst)
-                  dst)))
+                 (MInst.Mul8 signed src1 src2 dst)
+                 dst)))
+
+(decl x64_mul_lo_with_flags_paired (Type bool Gpr GprMem) ProducesFlags)
+(rule (x64_mul_lo_with_flags_paired ty signed src1 src2)
+      (let ((dst_lo WritableGpr (temp_writable_gpr))
+            (dst_hi WritableGpr (temp_writable_gpr))
+            (size OperandSize (raw_operand_size_of_type ty)))
+           (ProducesFlags.ProducesFlagsReturnsResultWithConsumer
+                 (MInst.Mul size signed src1 src2 dst_lo dst_hi)
+                 dst_lo)))
 
 ;; Helper for emitting `and` instructions.
 (decl x64_and (Type Gpr GprMemImm) Gpr)
@@ -2657,6 +3091,10 @@
             (_ Unit (emit (MInst.Imm size simm64 dst))))
         dst))
 
+;; `f16` immediates.
+(rule 2 (imm $F16 (u64_nonzero bits))
+        (bitcast_gpr_to_xmm 16 (imm $I16 bits)))
+
 ;; `f32` immediates.
 (rule 2 (imm $F32 (u64_nonzero bits))
         (x64_movd_to_xmm (imm $I32 bits)))
@@ -2684,6 +3122,9 @@
 (rule 0 (imm ty @ (multi_lane _bits _lanes) 0)
       (xmm_to_reg (xmm_zero ty)))
 
+;; Special case for `f16` zero immediates
+(rule 2 (imm ty @ $F16 (u64_zero)) (xmm_zero ty))
+
 ;; Special case for `f32` zero immediates
 (rule 2 (imm ty @ $F32 (u64_zero)) (xmm_zero ty))
 
@@ -2727,6 +3168,35 @@
 
 ;; Helper for creating `shl` instructions.
 (decl x64_shl (Type Gpr Imm8Gpr) Gpr)
+(spec (x64_shl ty src amt)
+      (require 
+            (= (:isReg amt) false))
+      (provide
+            (= result
+                  (switch (:bits ty)
+                        (8
+                              ;; for 8‑bit ops, extract the low‑8, shift, then zero‐extend back to 64
+                              (zero_ext 64
+                              (bvshl
+                                    (conv_to 8 src)
+                                    (:Imm8 amt))))
+                        (16
+                              (zero_ext 64
+                              (bvshl
+                                    (conv_to 16 src)
+                                    (zero_ext 16 (:Imm8 amt)))))
+                        (32
+                              (zero_ext 64
+                              (bvshl
+                                    (conv_to 32 src)
+                                    (zero_ext 32 (:Imm8 amt)))))
+                        (64
+                              ;; for 64‑bit ops we just shift the full 64
+                              (bvshl 
+                                    src 
+                                    (zero_ext 64 (:Imm8 amt))))))
+      )
+)
 (rule (x64_shl ty src1 src2)
       (shift_r ty (ShiftKind.ShiftLeft) src1 src2))
 ;; With BMI2 the `shlx` instruction is also available, and it's unconditionally
@@ -2774,7 +3244,7 @@
         dst))
 
 ;; Helper for creating `MInst.CmpRmiR` instructions.
-(decl cmp_rmi_r (OperandSize CmpOpcode GprMemImm Gpr) ProducesFlags)
+(decl cmp_rmi_r (OperandSize CmpOpcode Gpr GprMemImm) ProducesFlags)
 (rule (cmp_rmi_r size opcode src1 src2)
       (ProducesFlags.ProducesFlagsSideEffect
        (MInst.CmpRmiR size
@@ -2783,39 +3253,52 @@
                       src2)))
 
 ;; Helper for creating `cmp` instructions.
-(decl x64_cmp (OperandSize GprMemImm Gpr) ProducesFlags)
+(decl x64_cmp (OperandSize Gpr GprMemImm) ProducesFlags)
 (rule (x64_cmp size src1 src2)
       (cmp_rmi_r size (CmpOpcode.Cmp) src1 src2))
 
 ;; Helper for creating `cmp` instructions with an immediate.
-(decl x64_cmp_imm (OperandSize u32 Gpr) ProducesFlags)
+(decl x64_cmp_imm (OperandSize Gpr u32) ProducesFlags)
 (rule (x64_cmp_imm size src1 src2)
-      (cmp_rmi_r size (CmpOpcode.Cmp) (RegMemImm.Imm src1) src2))
+      (x64_cmp size src1 (RegMemImm.Imm src2)))
 
 ;; Helper for creating `MInst.XmmCmpRmR` instructions.
-(decl xmm_cmp_rm_r (SseOpcode XmmMemAligned Xmm) ProducesFlags)
+(decl xmm_cmp_rm_r (SseOpcode Xmm XmmMem) ProducesFlags)
 (rule (xmm_cmp_rm_r opcode src1 src2)
       (ProducesFlags.ProducesFlagsSideEffect
        (MInst.XmmCmpRmR opcode src1 src2)))
 
+;; Helper for creating `MInst.XmmCmpRmRVex` instructions.
+(decl xmm_cmp_rm_r_vex (AvxOpcode Xmm XmmMem) ProducesFlags)
+(rule (xmm_cmp_rm_r_vex opcode src1 src2)
+      (ProducesFlags.ProducesFlagsSideEffect
+       (MInst.XmmCmpRmRVex opcode src1 src2)))
+
 ;; Helper for creating floating-point comparison instructions (`UCOMIS[S|D]`).
-(decl x64_ucomis (Value Value) ProducesFlags)
-(rule (x64_ucomis src1 @ (value_type $F32) src2)
-      ;; N.B.: cmp can be generated more than once, so cannot do a
-      ;; load-op merge. So `put_in_xmm` for src1, not `put_in_xmm_mem`.
-      (xmm_cmp_rm_r (SseOpcode.Ucomiss) (put_in_xmm src1) (put_in_xmm src2)))
-(rule (x64_ucomis src1 @ (value_type $F64) src2)
-      (xmm_cmp_rm_r (SseOpcode.Ucomisd) (put_in_xmm src1) (put_in_xmm src2)))
+(decl x64_ucomis (Type Xmm XmmMem) ProducesFlags)
+(rule (x64_ucomis $F32 src1 src2)
+      (xmm_cmp_rm_r (SseOpcode.Ucomiss) src1 src2))
+(rule (x64_ucomis $F64 src1 src2)
+      (xmm_cmp_rm_r (SseOpcode.Ucomisd) src1 src2))
+(rule 1 (x64_ucomis $F32 src1 src2)
+        (if-let $true (use_avx))
+        (xmm_cmp_rm_r_vex (AvxOpcode.Vucomiss) src1 src2))
+(rule 1 (x64_ucomis $F64 src1 src2)
+        (if-let $true (use_avx))
+        (xmm_cmp_rm_r_vex (AvxOpcode.Vucomisd) src1 src2))
 
 ;; Helper for creating `test` instructions.
-(decl x64_test (OperandSize GprMemImm Gpr) ProducesFlags)
+(decl x64_test (OperandSize Gpr GprMemImm) ProducesFlags)
 (rule (x64_test size src1 src2)
       (cmp_rmi_r size (CmpOpcode.Test) src1 src2))
 
 ;; Helper for creating `ptest` instructions.
-(decl x64_ptest (XmmMem Xmm) ProducesFlags)
+(decl x64_ptest (Xmm XmmMem) ProducesFlags)
 (rule (x64_ptest src1 src2)
       (xmm_cmp_rm_r (SseOpcode.Ptest) src1 src2))
+(rule 1 (x64_ptest src1 src2)
+        (if-let $true (use_avx))
+        (xmm_cmp_rm_r_vex (AvxOpcode.Vptest) src1 src2))
 
 ;; Helper for creating `cmove` instructions. Note that these instructions do not
 ;; always result in a single emitted x86 instruction; e.g., XmmCmove uses jumps
@@ -2828,7 +3311,7 @@
          (MInst.Cmove size cc consequent alternative dst)
          dst)))
 
-(decl cmove_xmm (Type CC XmmMemAligned Xmm) ConsumesFlags)
+(decl cmove_xmm (Type CC Xmm Xmm) ConsumesFlags)
 (rule (cmove_xmm ty cc consequent alternative)
       (let ((dst WritableXmm (temp_writable_xmm)))
         (ConsumesFlags.ConsumesFlagsReturnsReg
@@ -2881,7 +3364,7 @@
          cmove2
          dst)))
 
-(decl cmove_or_xmm (Type CC CC XmmMemAligned Xmm) ConsumesFlags)
+(decl cmove_or_xmm (Type CC CC Xmm Xmm) ConsumesFlags)
 (rule (cmove_or_xmm ty cc1 cc2 consequent alternative)
       (let ((dst WritableXmm (temp_writable_xmm))
             (tmp WritableXmm (temp_writable_xmm))
@@ -3282,6 +3765,14 @@
       (if-let $true (use_avx))
       (xmm_rmir_vex (AvxOpcode.Vunpcklps) src1 src2))
 
+;; Helper for creating `unpcklpd` instructions.
+(decl x64_unpcklpd (Xmm XmmMem) Xmm)
+(rule 0 (x64_unpcklpd src1 src2)
+      (xmm_rm_r (SseOpcode.Unpcklpd) src1 src2))
+(rule 1 (x64_unpcklpd src1 src2)
+      (if-let $true (use_avx))
+      (xmm_rmir_vex (AvxOpcode.Vunpcklpd) src1 src2))
+
 ;; Helper for creating `unpckhps` instructions.
 (decl x64_unpckhps (Xmm XmmMem) Xmm)
 (rule 0 (x64_unpckhps src1 src2)
@@ -3737,21 +4228,52 @@
       (xmm_vex_pinsr (AvxOpcode.Vpinsrq) src1 src2 lane))
 
 ;; Helper for creating `roundss` instructions.
+;;
+;; NB: the non-AVX variant of this instruction does not require that the operand
+;; is aligned, but the instruction variant used here requires it to be aligned.
+;; This means that if the operand here points to memory then we'll eagerly load
+;; it, but the eager load will load too much (the full register width of 16
+;; bytes). To fix this a `put_xmm_mem_in_xmm` helper is used to force the
+;; operand to be a register where the load is done with the appropriate type if
+;; it's in memory.
+;;
+;; Some more discussion of this can be found on #8112. Ideally this would use
+;; a variant that allows an unaligned `XmmMem` in the instruction variant.
+;; Either that or the auto-conversion to aligned memory is removed and/or starts
+;; to require a type.
+;;
+;; Also note that the argument here isn't changed to `Xmm` instead of `XmmMem`
+;; because the AVX variant, when available, doesn't need alignment and can
+;; pass through the `src1` argument as-is.
 (decl x64_roundss (XmmMem RoundImm) Xmm)
 (rule (x64_roundss src1 round)
-      (xmm_unary_rm_r_imm (SseOpcode.Roundss) src1 (encode_round_imm round)))
+      (xmm_unary_rm_r_imm (SseOpcode.Roundss) (put_xmm_mem_in_xmm $F32 src1) (encode_round_imm round)))
 (rule 1 (x64_roundss src1 round)
         (if-let $true (use_avx))
         (xmm_unary_rm_r_imm_vex (AvxOpcode.Vroundss) src1 (encode_round_imm round)))
 
 ;; Helper for creating `roundsd` instructions.
+;;
+;; NB: see `x64_roundss` above for `put_xmm_mem_in_xmm` in call.
 (decl x64_roundsd (XmmMem RoundImm) Xmm)
 (rule (x64_roundsd src1 round)
-      (xmm_unary_rm_r_imm (SseOpcode.Roundsd) src1 (encode_round_imm round)))
+      (xmm_unary_rm_r_imm (SseOpcode.Roundsd) (put_xmm_mem_in_xmm $F64 src1) (encode_round_imm round)))
 (rule 1 (x64_roundsd src1 round)
         (if-let $true (use_avx))
         (xmm_unary_rm_r_imm_vex (AvxOpcode.Vroundsd) src1 (encode_round_imm round)))
 
+;; Helper for forcing an `XmmMem` to be placed into an `Xmm` register.
+;;
+;; If it's already in a register it stays there, otherwise it turns into a
+;; load instruction with the destination register as output.
+(decl put_xmm_mem_in_xmm (Type XmmMem) Xmm)
+(rule (put_xmm_mem_in_xmm ty xmm_mem)
+      (if-let (RegMem.Reg r) (xmm_mem_to_reg_mem xmm_mem))
+      (xmm_new r))
+(rule (put_xmm_mem_in_xmm ty xmm_mem)
+      (if-let (RegMem.Mem amode) (xmm_mem_to_reg_mem xmm_mem))
+      (x64_load ty amode (ExtKind.None)))
+
 ;; Helper for creating `roundps` instructions.
 (decl x64_roundps (XmmMem RoundImm) Xmm)
 (rule (x64_roundps src1 round)
@@ -3900,12 +4422,6 @@
                                              dst))))
         dst))
 
-;; Helper for creating `mul` instructions that return both the lower and
-;; (unsigned) higher halves of the result.
-(decl mulhi_u (Type Gpr GprMem) ValueRegs)
-(rule (mulhi_u ty src1 src2)
-      (mul_hi ty $false src1 src2))
-
 ;; Helper for creating `psllw` instructions.
 (decl x64_psllw (Xmm XmmMemImm) Xmm)
 (rule 0 (x64_psllw src1 src2)
@@ -4289,19 +4805,60 @@
 (rule (x64_vfnmadd132 $F32X4 a b c) (xmm_rmr_vex3 (AvxOpcode.Vfnmadd132ps) a b c))
 (rule (x64_vfnmadd132 $F64X2 a b c) (xmm_rmr_vex3 (AvxOpcode.Vfnmadd132pd) a b c))
 
+;; Helper for creating `vfmsub213*` instructions
+(decl x64_vfmsub213 (Type Xmm Xmm XmmMem) Xmm)
+(rule (x64_vfmsub213 $F32 a b c) (xmm_rmr_vex3 (AvxOpcode.Vfmsub213ss) a b c))
+(rule (x64_vfmsub213 $F64 a b c) (xmm_rmr_vex3 (AvxOpcode.Vfmsub213sd) a b c))
+(rule (x64_vfmsub213 $F32X4 a b c) (xmm_rmr_vex3 (AvxOpcode.Vfmsub213ps) a b c))
+(rule (x64_vfmsub213 $F64X2 a b c) (xmm_rmr_vex3 (AvxOpcode.Vfmsub213pd) a b c))
+
+;; Helper for creating `vfmsub132*` instructions
+(decl x64_vfmsub132 (Type Xmm Xmm XmmMem) Xmm)
+(rule (x64_vfmsub132 $F32 a b c) (xmm_rmr_vex3 (AvxOpcode.Vfmsub132ss) a b c))
+(rule (x64_vfmsub132 $F64 a b c) (xmm_rmr_vex3 (AvxOpcode.Vfmsub132sd) a b c))
+(rule (x64_vfmsub132 $F32X4 a b c) (xmm_rmr_vex3 (AvxOpcode.Vfmsub132ps) a b c))
+(rule (x64_vfmsub132 $F64X2 a b c) (xmm_rmr_vex3 (AvxOpcode.Vfmsub132pd) a b c))
+
+;; Helper for creating `vfnmsub213*` instructions
+(decl x64_vfnmsub213 (Type Xmm Xmm XmmMem) Xmm)
+(rule (x64_vfnmsub213 $F32 a b c) (xmm_rmr_vex3 (AvxOpcode.Vfnmsub213ss) a b c))
+(rule (x64_vfnmsub213 $F64 a b c) (xmm_rmr_vex3 (AvxOpcode.Vfnmsub213sd) a b c))
+(rule (x64_vfnmsub213 $F32X4 a b c) (xmm_rmr_vex3 (AvxOpcode.Vfnmsub213ps) a b c))
+(rule (x64_vfnmsub213 $F64X2 a b c) (xmm_rmr_vex3 (AvxOpcode.Vfnmsub213pd) a b c))
+
+;; Helper for creating `vfnmsub132*` instructions
+(decl x64_vfnmsub132 (Type Xmm Xmm XmmMem) Xmm)
+(rule (x64_vfnmsub132 $F32 a b c) (xmm_rmr_vex3 (AvxOpcode.Vfnmsub132ss) a b c))
+(rule (x64_vfnmsub132 $F64 a b c) (xmm_rmr_vex3 (AvxOpcode.Vfnmsub132sd) a b c))
+(rule (x64_vfnmsub132 $F32X4 a b c) (xmm_rmr_vex3 (AvxOpcode.Vfnmsub132ps) a b c))
+(rule (x64_vfnmsub132 $F64X2 a b c) (xmm_rmr_vex3 (AvxOpcode.Vfnmsub132pd) a b c))
+
+;; Note, the `vfmsub231` and `vfnmsub231*` instructions are omitted, because
+;; instruction selection happens before register allocation and therefore there
+;; is no benefit to a a third permutation
+
 ;; Helper for creating `sqrtss` instructions.
-(decl x64_sqrtss (XmmMem) Xmm)
-(rule (x64_sqrtss x) (xmm_unary_rm_r_unaligned (SseOpcode.Sqrtss) x))
-(rule 1 (x64_sqrtss x)
+;;
+;; NB: the square-root operation technically only has one operand but this
+;; instruction has two. This is to reflect how the square root operation copies
+;; the upper bits of the first register and only performs the square root
+;; operation on the low bits of the second register. This introduces
+;; a data-dependency on the contents of the first register which is modeled
+;; here.
+(decl x64_sqrtss (Xmm XmmMem) Xmm)
+(rule (x64_sqrtss x y) (xmm_rm_r_unaligned (SseOpcode.Sqrtss) x y))
+(rule 1 (x64_sqrtss x y)
         (if-let $true (use_avx))
-        (xmm_unary_rm_r_vex (AvxOpcode.Vsqrtss) x))
+        (xmm_rmir_vex (AvxOpcode.Vsqrtss) x y))
 
 ;; Helper for creating `sqrtsd` instructions.
-(decl x64_sqrtsd (XmmMem) Xmm)
-(rule (x64_sqrtsd x) (xmm_unary_rm_r_unaligned (SseOpcode.Sqrtsd) x))
-(rule 1 (x64_sqrtsd x)
+;;
+;; NB: see `x64_sqrtss` for explanation of why this has two args.
+(decl x64_sqrtsd (Xmm XmmMem) Xmm)
+(rule (x64_sqrtsd x y) (xmm_rm_r_unaligned (SseOpcode.Sqrtsd) x y))
+(rule 1 (x64_sqrtsd x y)
         (if-let $true (use_avx))
-        (xmm_unary_rm_r_vex (AvxOpcode.Vsqrtsd) x))
+        (xmm_rmir_vex (AvxOpcode.Vsqrtsd) x y))
 
 ;; Helper for creating `sqrtps` instructions.
 (decl x64_sqrtps (XmmMem) Xmm)
@@ -4318,18 +4875,22 @@
         (xmm_unary_rm_r_vex (AvxOpcode.Vsqrtpd) x))
 
 ;; Helper for creating `cvtss2sd` instructions.
-(decl x64_cvtss2sd (XmmMem) Xmm)
-(rule (x64_cvtss2sd x) (xmm_unary_rm_r_unaligned (SseOpcode.Cvtss2sd) x))
-(rule 1 (x64_cvtss2sd x)
+;;
+;; NB: see `x64_sqrtss` for why this has two args (same reasoning, different op)
+(decl x64_cvtss2sd (Xmm XmmMem) Xmm)
+(rule (x64_cvtss2sd x y) (xmm_rm_r_unaligned (SseOpcode.Cvtss2sd) x y))
+(rule 1 (x64_cvtss2sd x y)
         (if-let $true (use_avx))
-        (xmm_unary_rm_r_vex (AvxOpcode.Vcvtss2sd) x))
+        (xmm_rmir_vex (AvxOpcode.Vcvtss2sd) x y))
 
 ;; Helper for creating `cvtsd2ss` instructions.
-(decl x64_cvtsd2ss (XmmMem) Xmm)
-(rule (x64_cvtsd2ss x) (xmm_unary_rm_r_unaligned (SseOpcode.Cvtsd2ss) x))
-(rule 1 (x64_cvtsd2ss x)
+;;
+;; NB: see `x64_sqrtss` for why this has two args (same reasoning, different op)
+(decl x64_cvtsd2ss (Xmm XmmMem) Xmm)
+(rule (x64_cvtsd2ss x y) (xmm_rm_r_unaligned (SseOpcode.Cvtsd2ss) x y))
+(rule 1 (x64_cvtsd2ss x y)
         (if-let $true (use_avx))
-        (xmm_unary_rm_r_vex (AvxOpcode.Vcvtsd2ss) x))
+        (xmm_rmir_vex (AvxOpcode.Vcvtsd2ss) x y))
 
 ;; Helper for creating `cvtdq2ps` instructions.
 (decl x64_cvtdq2ps (XmmMem) Xmm)
@@ -4661,6 +5222,7 @@
 
 ;; Lower an Icmp result into a boolean value in a register.
 (decl lower_icmp_bool (IcmpCondResult) ValueRegs)
+(attr lower_icmp_bool (veri chain))
 (rule (lower_icmp_bool (IcmpCondResult.Condition producer cc))
       (with_flags producer (x64_setcc cc)))
 
@@ -4681,17 +5243,16 @@
 
 ;; For GPR-held values we only need to emit `CMP + SETCC`. We rely here on
 ;; Cranelift's verification that `a` and `b` are of the same type.
-;; Unfortunately for clarity, the registers are flipped here (TODO).
 (rule 0 (emit_cmp cc a @ (value_type ty) b)
       (let ((size OperandSize (raw_operand_size_of_type ty)))
-        (icmp_cond_result (x64_cmp size b a) cc)))
+        (icmp_cond_result (x64_cmp size a b) cc)))
 
 ;; As a special case, swap the arguments to the comparison when the LHS is a
 ;; constant. This ensures that we avoid moving the constant into a register when
 ;; performing the comparison.
 (rule 1 (emit_cmp cc (and (simm32_from_value a) (value_type ty)) b)
       (let ((size OperandSize (raw_operand_size_of_type ty)))
-        (icmp_cond_result (x64_cmp size a b) (intcc_swap_args cc))))
+        (icmp_cond_result (x64_cmp size b a) (intcc_swap_args cc))))
 
 ;; Special case: use the test instruction for comparisons with 0.
 (rule 2 (emit_cmp cc a @ (value_type ty) (u64_from_iconst 0))
@@ -4706,62 +5267,42 @@
 
 ;; For I128 values (held in two GPRs), the instruction sequences depend on what
 ;; kind of condition is tested.
-(rule 5 (emit_cmp (IntCC.Equal) a @ (value_type $I128) b)
-      (let ((a_lo Gpr (value_regs_get_gpr a 0))
-            (a_hi Gpr (value_regs_get_gpr a 1))
-            (b_lo Gpr (value_regs_get_gpr b 0))
-            (b_hi Gpr (value_regs_get_gpr b 1))
-            (cmp_lo Reg (with_flags_reg (x64_cmp (OperandSize.Size64) b_lo a_lo) (x64_setcc (CC.Z))))
-            (cmp_hi Reg (with_flags_reg (x64_cmp (OperandSize.Size64) b_hi a_hi) (x64_setcc (CC.Z))))
-            ;; At this point, `cmp_lo` and `cmp_hi` contain either 0 or 1 in the
-            ;; lowest 8 bits--`SETcc` guarantees this. The upper bits may be
-            ;; unchanged so we must compare against 1 below; this instruction
-            ;; combines `cmp_lo` and `cmp_hi` for that final comparison.
-            (cmp Reg (x64_and $I64 cmp_lo cmp_hi)))
-        ;; We must compare one more time against the immediate value 1 to
-        ;; check if both `cmp_lo` and `cmp_hi` are true. If `cmp AND 1 == 0`
-        ;; then the `ZF` will be set (see `TEST` definition); if either of
-        ;; the halves `AND`s to 0, they were not equal, therefore we `SETcc`
-        ;; with `NZ`.
-        (icmp_cond_result
-          (x64_test (OperandSize.Size64) (RegMemImm.Imm 1) cmp)
-          (CC.NZ))))
-
-(rule 5 (emit_cmp (IntCC.NotEqual) a @ (value_type $I128) b)
-      (let ((a_lo Gpr (value_regs_get_gpr a 0))
-            (a_hi Gpr (value_regs_get_gpr a 1))
-            (b_lo Gpr (value_regs_get_gpr b 0))
-            (b_hi Gpr (value_regs_get_gpr b 1))
-            (cmp_lo Reg (with_flags_reg (x64_cmp (OperandSize.Size64) b_lo a_lo) (x64_setcc (CC.NZ))))
-            (cmp_hi Reg (with_flags_reg (x64_cmp (OperandSize.Size64) b_hi a_hi) (x64_setcc (CC.NZ))))
-            ;; See comments for `IntCC.Equal`.
-            (cmp Reg (x64_or $I64 cmp_lo cmp_hi)))
-           (icmp_cond_result
-             (x64_test (OperandSize.Size64) (RegMemImm.Imm 1) cmp)
-             (CC.NZ))))
-
-;; Result = (a_hi <> b_hi) ||
-;;          (a_hi == b_hi && a_lo <> b_lo)
 (rule 4 (emit_cmp cc a @ (value_type $I128) b)
       (let ((a_lo Gpr (value_regs_get_gpr a 0))
             (a_hi Gpr (value_regs_get_gpr a 1))
             (b_lo Gpr (value_regs_get_gpr b 0))
-            (b_hi Gpr (value_regs_get_gpr b 1))
-            (cmp_hi ValueRegs (with_flags (x64_cmp (OperandSize.Size64) b_hi a_hi)
-                                       (consumes_flags_concat
-                                                 (x64_setcc (intcc_without_eq cc))
-                                                 (x64_setcc (CC.Z)))))
-            (cc_hi Reg (value_regs_get cmp_hi 0))
-            (eq_hi Reg (value_regs_get cmp_hi 1))
-
-            (cmp_lo Reg (with_flags_reg (x64_cmp (OperandSize.Size64) b_lo a_lo)
-                                        (x64_setcc (intcc_unsigned cc))))
-
-            (res_lo Reg (x64_and $I64 eq_hi cmp_lo))
-            (res Reg (x64_or $I64 cc_hi res_lo)))
+            (b_hi Gpr (value_regs_get_gpr b 1)))
+      (emit_cmp_i128 cc a_hi a_lo b_hi b_lo)))
+
+(decl emit_cmp_i128 (CC Gpr Gpr Gpr Gpr) IcmpCondResult)
+;; Eliminate cases which compare something "or equal" by swapping arguments.
+(rule 2 (emit_cmp_i128 (CC.NLE) a_hi a_lo b_hi b_lo)
+        (emit_cmp_i128 (CC.L)   b_hi b_lo a_hi a_lo))
+(rule 2 (emit_cmp_i128 (CC.LE)  a_hi a_lo b_hi b_lo)
+        (emit_cmp_i128 (CC.NL)  b_hi b_lo a_hi a_lo))
+(rule 2 (emit_cmp_i128 (CC.NBE) a_hi a_lo b_hi b_lo)
+        (emit_cmp_i128 (CC.B)   b_hi b_lo a_hi a_lo))
+(rule 2 (emit_cmp_i128 (CC.BE)  a_hi a_lo b_hi b_lo)
+        (emit_cmp_i128 (CC.NB)  b_hi b_lo a_hi a_lo))
+
+;; 128-bit strict equality/inequality can't be easily tested using subtraction
+;; but we can quickly determine whether any bits are different instead.
+(rule 1 (emit_cmp_i128 (cc_nz_or_z cc) a_hi a_lo b_hi b_lo)
+        (let ((same_lo Reg (x64_xor $I64 a_lo b_lo))
+              (same_hi Reg (x64_xor $I64 a_hi b_hi)))
+          (icmp_cond_result
+            (x64_alurmi_flags_side_effect (AluRmiROpcode.Or) $I64 same_lo same_hi)
+            cc)))
+
+;; The only cases left are L/NL/B/NB which we can implement with a sub/sbb
+;; sequence. But since we don't care about anything but the flags we can
+;; replace the sub with cmp, which avoids clobbering one of the registers.
+(rule 0 (emit_cmp_i128 cc a_hi a_lo b_hi b_lo)
         (icmp_cond_result
-          (x64_test (OperandSize.Size64) (RegMemImm.Imm 1) res)
-          (CC.NZ))))
+          (produces_flags_concat
+            (x64_cmp (OperandSize.Size64) a_lo b_lo)
+            (x64_alurmi_flags_side_effect (AluRmiROpcode.Sbb) $I64 a_hi b_hi))
+          cc))
 
 (type FcmpCondResult
       (enum
@@ -4816,46 +5357,46 @@
 ;;  - equal assigns        Z = 1, P = 0, C = 0
 (decl emit_fcmp (FloatCC Value Value) FcmpCondResult)
 
-(rule (emit_fcmp (FloatCC.Equal) a @ (value_type (ty_scalar_float _)) b)
-      (FcmpCondResult.AndCondition (x64_ucomis b a) (CC.NP) (CC.Z)))
+(rule (emit_fcmp (FloatCC.Equal) a @ (value_type (ty_scalar_float ty)) b)
+      (FcmpCondResult.AndCondition (x64_ucomis ty a b) (CC.NP) (CC.Z)))
 
-(rule (emit_fcmp (FloatCC.NotEqual) a @ (value_type (ty_scalar_float _)) b)
-      (FcmpCondResult.OrCondition (x64_ucomis b a) (CC.P) (CC.NZ)))
+(rule (emit_fcmp (FloatCC.NotEqual) a @ (value_type (ty_scalar_float ty)) b)
+      (FcmpCondResult.OrCondition (x64_ucomis ty a b) (CC.P) (CC.NZ)))
 
 ;; Some scalar lowerings correspond to one condition code.
 
 (rule (emit_fcmp (FloatCC.Ordered) a @ (value_type (ty_scalar_float ty)) b)
-      (FcmpCondResult.Condition (x64_ucomis b a) (CC.NP)))
+      (FcmpCondResult.Condition (x64_ucomis ty a b) (CC.NP)))
 (rule (emit_fcmp (FloatCC.Unordered) a @ (value_type (ty_scalar_float ty)) b)
-      (FcmpCondResult.Condition (x64_ucomis b a) (CC.P)))
+      (FcmpCondResult.Condition (x64_ucomis ty a b) (CC.P)))
 (rule (emit_fcmp (FloatCC.OrderedNotEqual) a @ (value_type (ty_scalar_float ty)) b)
-      (FcmpCondResult.Condition (x64_ucomis b a) (CC.NZ)))
+      (FcmpCondResult.Condition (x64_ucomis ty a b) (CC.NZ)))
 (rule (emit_fcmp (FloatCC.UnorderedOrEqual) a @ (value_type (ty_scalar_float ty)) b)
-      (FcmpCondResult.Condition (x64_ucomis b a) (CC.Z)))
+      (FcmpCondResult.Condition (x64_ucomis ty a b) (CC.Z)))
 (rule (emit_fcmp (FloatCC.GreaterThan) a @ (value_type (ty_scalar_float ty)) b)
-      (FcmpCondResult.Condition (x64_ucomis b a) (CC.NBE)))
+      (FcmpCondResult.Condition (x64_ucomis ty a b) (CC.NBE)))
 (rule (emit_fcmp (FloatCC.GreaterThanOrEqual) a @ (value_type (ty_scalar_float ty)) b)
-      (FcmpCondResult.Condition (x64_ucomis b a) (CC.NB)))
+      (FcmpCondResult.Condition (x64_ucomis ty a b) (CC.NB)))
 (rule (emit_fcmp (FloatCC.UnorderedOrLessThan) a @ (value_type (ty_scalar_float ty)) b)
-      (FcmpCondResult.Condition (x64_ucomis b a) (CC.B)))
+      (FcmpCondResult.Condition (x64_ucomis ty a b) (CC.B)))
 (rule (emit_fcmp (FloatCC.UnorderedOrLessThanOrEqual) a @ (value_type (ty_scalar_float ty)) b)
-      (FcmpCondResult.Condition (x64_ucomis b a) (CC.BE)))
+      (FcmpCondResult.Condition (x64_ucomis ty a b) (CC.BE)))
 
 ;; Other scalar lowerings are made possible by flipping the operands and
 ;; reversing the condition code.
 
 (rule (emit_fcmp (FloatCC.LessThan) a @ (value_type (ty_scalar_float ty)) b)
       ;; Same flags as `GreaterThan`.
-      (FcmpCondResult.Condition (x64_ucomis a b) (CC.NBE)))
+      (FcmpCondResult.Condition (x64_ucomis ty b a) (CC.NBE)))
 (rule (emit_fcmp (FloatCC.LessThanOrEqual) a @ (value_type (ty_scalar_float ty)) b)
       ;; Same flags as `GreaterThanOrEqual`.
-      (FcmpCondResult.Condition (x64_ucomis a b) (CC.NB)))
+      (FcmpCondResult.Condition (x64_ucomis ty b a) (CC.NB)))
 (rule (emit_fcmp (FloatCC.UnorderedOrGreaterThan) a @ (value_type (ty_scalar_float ty)) b)
       ;; Same flags as `UnorderedOrLessThan`.
-      (FcmpCondResult.Condition (x64_ucomis a b) (CC.B)))
+      (FcmpCondResult.Condition (x64_ucomis ty b a) (CC.B)))
 (rule (emit_fcmp (FloatCC.UnorderedOrGreaterThanOrEqual) a @ (value_type (ty_scalar_float ty)) b)
       ;; Same flags as `UnorderedOrLessThanOrEqual`.
-      (FcmpCondResult.Condition (x64_ucomis a b) (CC.BE)))
+      (FcmpCondResult.Condition (x64_ucomis ty b a) (CC.BE)))
 
 ;;;; Type Guards ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
@@ -4890,18 +5431,30 @@
 
 ;;;; Casting ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(decl bitcast_xmm_to_gpr (Type Xmm) Gpr)
-(rule (bitcast_xmm_to_gpr $F32 src)
+(decl bitcast_xmm_to_gpr (u8 Xmm) Gpr)
+(rule (bitcast_xmm_to_gpr 16 src)
+      (x64_pextrw src 0))
+(rule (bitcast_xmm_to_gpr 32 src)
       (x64_movd_to_gpr src))
-(rule (bitcast_xmm_to_gpr $F64 src)
+(rule (bitcast_xmm_to_gpr 64 src)
       (x64_movq_to_gpr src))
 
-(decl bitcast_gpr_to_xmm (Type Gpr) Xmm)
-(rule (bitcast_gpr_to_xmm $I32 src)
+(decl bitcast_xmm_to_gprs (Xmm) ValueRegs)
+(rule (bitcast_xmm_to_gprs src)
+      (value_regs (x64_movq_to_gpr src) (x64_movq_to_gpr (x64_pshufd src 0b11101110))))
+
+(decl bitcast_gpr_to_xmm (u8 Gpr) Xmm)
+(rule (bitcast_gpr_to_xmm 16 src)
+      (x64_pinsrw (xmm_uninit_value) src 0))
+(rule (bitcast_gpr_to_xmm 32 src)
       (x64_movd_to_xmm src))
-(rule (bitcast_gpr_to_xmm $I64 src)
+(rule (bitcast_gpr_to_xmm 64 src)
       (x64_movq_to_xmm src))
 
+(decl bitcast_gprs_to_xmm (ValueRegs) Xmm)
+(rule (bitcast_gprs_to_xmm src)
+      (x64_punpcklqdq (x64_movq_to_xmm (value_regs_get_gpr src 0)) (x64_movq_to_xmm (value_regs_get_gpr src 1))))
+
 ;;;; Stack Addresses ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (decl stack_addr_impl (StackSlot Offset32) Gpr)
diff --git a/cranelift/codegen/src/isa/x64/inst/args.rs b/cranelift/codegen/src/isa/x64/inst/args.rs
index a9a393be1693..a6923e400ff8 100644
--- a/cranelift/codegen/src/isa/x64/inst/args.rs
+++ b/cranelift/codegen/src/isa/x64/inst/args.rs
@@ -3,18 +3,18 @@
 use super::regs::{self};
 use super::EmitState;
 use crate::ir::condcodes::{FloatCC, IntCC};
-use crate::ir::{MemFlags, Type};
+use crate::ir::types::*;
+use crate::ir::MemFlags;
 use crate::isa::x64::inst::regs::pretty_print_reg;
 use crate::isa::x64::inst::Inst;
 use crate::machinst::*;
-use regalloc2::VReg;
 use smallvec::{smallvec, SmallVec};
 use std::fmt;
 use std::string::String;
 
 pub use crate::isa::x64::lower::isle::generated_code::DivSignedness;
 
-/// An extenstion trait for converting `Writable{Xmm,Gpr}` to `Writable<Reg>`.
+/// An extension trait for converting `Writable{Xmm,Gpr}` to `Writable<Reg>`.
 pub trait ToWritableReg {
     /// Convert `Writable{Xmm,Gpr}` to `Writable<Reg>`.
     fn to_writable_reg(&self) -> Writable<Reg>;
@@ -65,6 +65,21 @@ macro_rules! newtype_of_reg {
                 }
             }
 
+            /// Like `Self::new(r).unwrap()` but with a better panic message on
+            /// failure.
+            pub fn unwrap_new($check_reg: Reg) -> Self {
+                if $check {
+                    Self($check_reg)
+                } else {
+                    panic!(
+                        "cannot construct {} from register {:?} with register class {:?}",
+                        stringify!($newtype_reg),
+                        $check_reg,
+                        $check_reg.class(),
+                    )
+                }
+            }
+
             /// Get this newtype's underlying `Reg`.
             pub fn to_reg(self) -> Reg {
                 self.0
@@ -85,6 +100,15 @@ macro_rules! newtype_of_reg {
             }
         }
 
+        /// If you know what you're doing, you can explicitly mutably borrow the
+        /// underlying `Reg`. Don't make it point to the wrong type of register
+        /// please.
+        impl AsMut<Reg> for $newtype_reg {
+            fn as_mut(&mut self) -> &mut Reg {
+                &mut self.0
+            }
+        }
+
         /// Writable Gpr.
         pub type $newtype_writable_reg = Writable<$newtype_reg>;
 
@@ -114,6 +138,11 @@ macro_rules! newtype_of_reg {
                     rm.0
                 }
             }
+            impl<'a> From<&'a $newtype_reg_mem> for &'a RegMem {
+                fn from(rm: &'a $newtype_reg_mem) -> &'a RegMem {
+                    &rm.0
+                }
+            }
 
             impl From<$newtype_reg> for $newtype_reg_mem {
                 fn from(r: $newtype_reg) -> Self {
@@ -140,8 +169,26 @@ macro_rules! newtype_of_reg {
                                 None
                             }
                         }
-                        RegMem::Reg { reg: $check_reg } if $check => Some(Self(rm)),
-                        RegMem::Reg { reg: _ } => None,
+                        RegMem::Reg { reg } => Some($newtype_reg::new(reg)?.into()),
+                    }
+                }
+
+                /// Like `Self::new(rm).unwrap()` but with better panic messages
+                /// in case of failure.
+                pub fn unwrap_new(rm: RegMem) -> Self {
+                    match rm {
+                        RegMem::Mem { addr } => {
+                            $(
+                                if $aligned && !addr.aligned() {
+                                    panic!(
+                                        "cannot create {} from an unaligned memory address: {addr:?}",
+                                        stringify!($newtype_reg_mem),
+                                    );
+                                }
+                            )?
+                            Self(RegMem::Mem { addr })
+                        }
+                        RegMem::Reg { reg } => $newtype_reg::unwrap_new(reg).into(),
                     }
                 }
 
@@ -151,16 +198,13 @@ macro_rules! newtype_of_reg {
                 }
 
                 #[allow(dead_code)] // Used by some newtypes and not others.
-                pub(crate) fn get_operands<F: Fn(VReg) -> VReg>(
-                    &self,
-                    collector: &mut OperandCollector<'_, F>,
-                ) {
+                pub(crate) fn get_operands(&mut self, collector: &mut impl OperandVisitor) {
                     self.0.get_operands(collector);
                 }
             }
             impl PrettyPrint for $newtype_reg_mem {
-                fn pretty_print(&self, size: u8, allocs: &mut AllocationConsumer<'_>) -> String {
-                    self.0.pretty_print(size, allocs)
+                fn pretty_print(&self, size: u8) -> String {
+                    self.0.pretty_print(size)
                 }
             }
         )*
@@ -175,6 +219,11 @@ macro_rules! newtype_of_reg {
                     rmi.0
                 }
             }
+            impl<'a> From<&'a $newtype_reg_mem_imm> for &'a RegMemImm {
+                fn from(rmi: &'a $newtype_reg_mem_imm) -> &'a RegMemImm {
+                    &rmi.0
+                }
+            }
 
             impl From<$newtype_reg> for $newtype_reg_mem_imm {
                 fn from(r: $newtype_reg) -> Self {
@@ -202,8 +251,29 @@ macro_rules! newtype_of_reg {
                                 None
                             }
                         }
-                        RegMemImm::Reg { reg: $check_reg } if $check => Some(Self(rmi)),
-                        RegMemImm::Reg { reg: _ } => None,
+                        RegMemImm::Reg { reg } => Some($newtype_reg::new(reg)?.into()),
+                    }
+                }
+
+                /// Like `Self::new(rmi).unwrap()` but with better panic
+                /// messages in case of failure.
+                pub fn unwrap_new(rmi: RegMemImm) -> Self {
+                    match rmi {
+                        RegMemImm::Imm { .. } => Self(rmi),
+                        RegMemImm::Mem { addr } => {
+                            $(
+                                if $aligned_imm && !addr.aligned() {
+                                    panic!(
+                                        "cannot construct {} from unaligned memory address: {:?}",
+                                        stringify!($newtype_reg_mem_imm),
+                                        addr,
+                                    );
+                                }
+                            )?
+                            Self(RegMemImm::Mem { addr })
+
+                        }
+                        RegMemImm::Reg { reg } => $newtype_reg::unwrap_new(reg).into(),
                     }
                 }
 
@@ -214,17 +284,14 @@ macro_rules! newtype_of_reg {
                 }
 
                 #[allow(dead_code)] // Used by some newtypes and not others.
-                pub(crate) fn get_operands<F: Fn(VReg) -> VReg>(
-                    &self,
-                    collector: &mut OperandCollector<'_, F>,
-                ) {
+                pub(crate) fn get_operands(&mut self, collector: &mut impl OperandVisitor) {
                     self.0.get_operands(collector);
                 }
             }
 
             impl PrettyPrint for $newtype_reg_mem_imm {
-                fn pretty_print(&self, size: u8, allocs: &mut AllocationConsumer<'_>) -> String {
-                    self.0.pretty_print(size, allocs)
+                fn pretty_print(&self, size: u8) -> String {
+                    self.0.pretty_print(size)
                 }
             }
         )*
@@ -247,15 +314,29 @@ macro_rules! newtype_of_reg {
             pub fn new(imm8_reg: Imm8Reg) -> Option<Self> {
                 match imm8_reg {
                     Imm8Reg::Imm8 { .. } => Some(Self(imm8_reg)),
-                    Imm8Reg::Reg { reg: $check_reg } if $check => Some(Self(imm8_reg)),
-                    Imm8Reg::Reg { reg: _ } => None,
+                    Imm8Reg::Reg { reg } => Some($newtype_reg::new(reg)?.into()),
                 }
             }
 
-            /// Convert this newtype into its underlying `Imm8Reg`.
+            /// Like `Self::new(imm8_reg).unwrap()` but with better panic
+            /// messages on failure.
+            pub fn unwrap_new(imm8_reg: Imm8Reg) -> Self {
+                match imm8_reg {
+                    Imm8Reg::Imm8 { .. } => Self(imm8_reg),
+                    Imm8Reg::Reg { reg } => $newtype_reg::unwrap_new(reg).into(),
+                }
+            }
+
+            /// Borrow this newtype as its underlying `Imm8Reg`.
             #[allow(dead_code)] // Used by some newtypes and not others.
-            pub fn to_imm8_reg(self) -> Imm8Reg {
-                self.0
+            pub fn as_imm8_reg(&self) -> &Imm8Reg {
+                &self.0
+            }
+
+            /// Borrow this newtype as its underlying `Imm8Reg`.
+            #[allow(dead_code)] // Used by some newtypes and not others.
+            pub fn as_imm8_reg_mut(&mut self) -> &mut Imm8Reg {
+                &mut self.0
             }
         }
     };
@@ -318,7 +399,8 @@ impl Amode {
         Self::RipRelative { target }
     }
 
-    pub(crate) fn with_flags(&self, flags: MemFlags) -> Self {
+    /// Set the specified [MemFlags] to the [Amode].
+    pub fn with_flags(&self, flags: MemFlags) -> Self {
         match self {
             &Self::ImmReg { simm32, base, .. } => Self::ImmReg {
                 simm32,
@@ -338,28 +420,25 @@ impl Amode {
                 shift,
                 flags,
             },
-            _ => panic!("Amode {:?} cannot take memflags", self),
+            _ => panic!("Amode {self:?} cannot take memflags"),
         }
     }
 
     /// Add the registers mentioned by `self` to `collector`.
-    pub(crate) fn get_operands<F: Fn(VReg) -> VReg>(
-        &self,
-        collector: &mut OperandCollector<'_, F>,
-    ) {
+    pub(crate) fn get_operands(&mut self, collector: &mut impl OperandVisitor) {
         match self {
             Amode::ImmReg { base, .. } => {
                 if *base != regs::rbp() && *base != regs::rsp() {
-                    collector.reg_use(*base);
+                    collector.reg_use(base);
                 }
             }
             Amode::ImmRegRegShift { base, index, .. } => {
                 debug_assert_ne!(base.to_reg(), regs::rbp());
                 debug_assert_ne!(base.to_reg(), regs::rsp());
-                collector.reg_use(base.to_reg());
+                collector.reg_use(base);
                 debug_assert_ne!(index.to_reg(), regs::rbp());
                 debug_assert_ne!(index.to_reg(), regs::rsp());
-                collector.reg_use(index.to_reg());
+                collector.reg_use(index);
             }
             Amode::RipRelative { .. } => {
                 // RIP isn't involved in regalloc.
@@ -368,17 +447,14 @@ impl Amode {
     }
 
     /// Same as `get_operands`, but add the registers in the "late" phase.
-    pub(crate) fn get_operands_late<F: Fn(VReg) -> VReg>(
-        &self,
-        collector: &mut OperandCollector<'_, F>,
-    ) {
+    pub(crate) fn get_operands_late(&mut self, collector: &mut impl OperandVisitor) {
         match self {
             Amode::ImmReg { base, .. } => {
-                collector.reg_late_use(*base);
+                collector.reg_late_use(base);
             }
             Amode::ImmRegRegShift { base, index, .. } => {
-                collector.reg_late_use(base.to_reg());
-                collector.reg_late_use(index.to_reg());
+                collector.reg_late_use(base);
+                collector.reg_late_use(index);
             }
             Amode::RipRelative { .. } => {
                 // RIP isn't involved in regalloc.
@@ -393,54 +469,13 @@ impl Amode {
         }
     }
 
-    pub(crate) fn can_trap(&self) -> bool {
-        !self.get_flags().notrap()
-    }
-
-    pub(crate) fn with_allocs(&self, allocs: &mut AllocationConsumer<'_>) -> Self {
-        // The order in which we consume allocs here must match the
-        // order in which we produce operands in get_operands() above.
-        match self {
-            &Amode::ImmReg {
-                simm32,
-                base,
-                flags,
-            } => {
-                let base = if base == regs::rsp() || base == regs::rbp() {
-                    base
-                } else {
-                    allocs.next(base)
-                };
-                Amode::ImmReg {
-                    simm32,
-                    flags,
-                    base,
-                }
-            }
-            &Amode::ImmRegRegShift {
-                simm32,
-                base,
-                index,
-                shift,
-                flags,
-            } => Amode::ImmRegRegShift {
-                simm32,
-                shift,
-                flags,
-                base: Gpr::new(allocs.next(*base)).unwrap(),
-                index: Gpr::new(allocs.next(*index)).unwrap(),
-            },
-            &Amode::RipRelative { target } => Amode::RipRelative { target },
-        }
-    }
-
     /// Offset the amode by a fixed offset.
     pub(crate) fn offset(&self, offset: i32) -> Self {
         let mut ret = self.clone();
         match &mut ret {
             &mut Amode::ImmReg { ref mut simm32, .. } => *simm32 += offset,
             &mut Amode::ImmRegRegShift { ref mut simm32, .. } => *simm32 += offset,
-            _ => panic!("Cannot offset amode: {:?}", self),
+            _ => panic!("Cannot offset amode: {self:?}"),
         }
         ret
     }
@@ -451,12 +486,12 @@ impl Amode {
 }
 
 impl PrettyPrint for Amode {
-    fn pretty_print(&self, _size: u8, allocs: &mut AllocationConsumer<'_>) -> String {
+    fn pretty_print(&self, _size: u8) -> String {
         match self {
             Amode::ImmReg { simm32, base, .. } => {
                 // Note: size is always 8; the address is 64 bits,
                 // even if the addressed operand is smaller.
-                format!("{}({})", *simm32, pretty_print_reg(*base, 8, allocs))
+                format!("{}({})", *simm32, pretty_print_reg(*base, 8))
             }
             Amode::ImmRegRegShift {
                 simm32,
@@ -467,8 +502,8 @@ impl PrettyPrint for Amode {
             } => format!(
                 "{}({},{},{})",
                 *simm32,
-                pretty_print_reg(base.to_reg(), 8, allocs),
-                pretty_print_reg(index.to_reg(), 8, allocs),
+                pretty_print_reg(base.to_reg(), 8),
+                pretty_print_reg(index.to_reg(), 8),
                 1 << shift
             ),
             Amode::RipRelative { ref target } => format!("label{}(%rip)", target.get()),
@@ -484,10 +519,16 @@ pub enum SyntheticAmode {
     /// A real amode.
     Real(Amode),
 
-    /// A (virtual) offset to the "nominal SP" value, which will be recomputed as we push and pop
-    /// within the function.
-    NominalSPOffset {
-        /// The nominal stack pointer value.
+    /// A (virtual) offset into the incoming argument area.
+    IncomingArg {
+        /// The downward offset from the start of the incoming argument area.
+        offset: u32,
+    },
+
+    /// A (virtual) offset to the slot area of the function frame, which lies just above the
+    /// outgoing arguments.
+    SlotOffset {
+        /// The offset into the slot area.
         simm32: i32,
     },
 
@@ -501,18 +542,18 @@ impl SyntheticAmode {
         Self::Real(amode)
     }
 
-    pub(crate) fn nominal_sp_offset(simm32: i32) -> Self {
-        SyntheticAmode::NominalSPOffset { simm32 }
+    pub(crate) fn slot_offset(simm32: i32) -> Self {
+        SyntheticAmode::SlotOffset { simm32 }
     }
 
     /// Add the registers mentioned by `self` to `collector`.
-    pub(crate) fn get_operands<F: Fn(VReg) -> VReg>(
-        &self,
-        collector: &mut OperandCollector<'_, F>,
-    ) {
+    pub(crate) fn get_operands(&mut self, collector: &mut impl OperandVisitor) {
         match self {
             SyntheticAmode::Real(addr) => addr.get_operands(collector),
-            SyntheticAmode::NominalSPOffset { .. } => {
+            SyntheticAmode::IncomingArg { .. } => {
+                // Nothing to do; the base is known and isn't involved in regalloc.
+            }
+            SyntheticAmode::SlotOffset { .. } => {
                 // Nothing to do; the base is SP and isn't involved in regalloc.
             }
             SyntheticAmode::ConstantOffset(_) => {}
@@ -520,13 +561,13 @@ impl SyntheticAmode {
     }
 
     /// Same as `get_operands`, but add the register in the "late" phase.
-    pub(crate) fn get_operands_late<F: Fn(VReg) -> VReg>(
-        &self,
-        collector: &mut OperandCollector<'_, F>,
-    ) {
+    pub(crate) fn get_operands_late(&mut self, collector: &mut impl OperandVisitor) {
         match self {
             SyntheticAmode::Real(addr) => addr.get_operands_late(collector),
-            SyntheticAmode::NominalSPOffset { .. } => {
+            SyntheticAmode::IncomingArg { .. } => {
+                // Nothing to do; the base is known and isn't involved in regalloc.
+            }
+            SyntheticAmode::SlotOffset { .. } => {
                 // Nothing to do; the base is SP and isn't involved in regalloc.
             }
             SyntheticAmode::ConstantOffset(_) => {}
@@ -536,8 +577,18 @@ impl SyntheticAmode {
     pub(crate) fn finalize(&self, state: &mut EmitState, buffer: &mut MachBuffer<Inst>) -> Amode {
         match self {
             SyntheticAmode::Real(addr) => addr.clone(),
-            SyntheticAmode::NominalSPOffset { simm32 } => {
-                let off = *simm32 as i64 + state.virtual_sp_offset();
+            SyntheticAmode::IncomingArg { offset } => {
+                // NOTE: this could be made relative to RSP by adding additional offsets from the
+                // frame_layout.
+                let args_max_fp_offset =
+                    state.frame_layout().tail_args_size + state.frame_layout().setup_area_size;
+                Amode::imm_reg(
+                    i32::try_from(args_max_fp_offset - offset).unwrap(),
+                    regs::rbp(),
+                )
+            }
+            SyntheticAmode::SlotOffset { simm32 } => {
+                let off = *simm32 as i64 + i64::from(state.frame_layout().outgoing_args_size);
                 Amode::imm_reg(off.try_into().expect("invalid sp offset"), regs::rsp())
             }
             SyntheticAmode::ConstantOffset(c) => {
@@ -546,19 +597,12 @@ impl SyntheticAmode {
         }
     }
 
-    pub(crate) fn with_allocs(&self, allocs: &mut AllocationConsumer<'_>) -> Self {
-        match self {
-            SyntheticAmode::Real(addr) => SyntheticAmode::Real(addr.with_allocs(allocs)),
-            &SyntheticAmode::NominalSPOffset { .. } | &SyntheticAmode::ConstantOffset { .. } => {
-                self.clone()
-            }
-        }
-    }
-
     pub(crate) fn aligned(&self) -> bool {
         match self {
             SyntheticAmode::Real(addr) => addr.aligned(),
-            SyntheticAmode::NominalSPOffset { .. } | SyntheticAmode::ConstantOffset { .. } => true,
+            &SyntheticAmode::IncomingArg { .. }
+            | SyntheticAmode::SlotOffset { .. }
+            | SyntheticAmode::ConstantOffset { .. } => true,
         }
     }
 }
@@ -576,11 +620,14 @@ impl Into<SyntheticAmode> for VCodeConstant {
 }
 
 impl PrettyPrint for SyntheticAmode {
-    fn pretty_print(&self, _size: u8, allocs: &mut AllocationConsumer<'_>) -> String {
+    fn pretty_print(&self, _size: u8) -> String {
         match self {
             // See note in `Amode` regarding constant size of `8`.
-            SyntheticAmode::Real(addr) => addr.pretty_print(8, allocs),
-            SyntheticAmode::NominalSPOffset { simm32 } => {
+            SyntheticAmode::Real(addr) => addr.pretty_print(8),
+            &SyntheticAmode::IncomingArg { offset } => {
+                format!("rbp(stack args max - {offset})")
+            }
+            SyntheticAmode::SlotOffset { simm32 } => {
                 format!("rsp({} + virtual offset)", *simm32)
             }
             SyntheticAmode::ConstantOffset(c) => format!("const({})", c.as_u32()),
@@ -636,28 +683,13 @@ impl RegMemImm {
     }
 
     /// Add the regs mentioned by `self` to `collector`.
-    pub(crate) fn get_operands<F: Fn(VReg) -> VReg>(
-        &self,
-        collector: &mut OperandCollector<'_, F>,
-    ) {
+    pub(crate) fn get_operands(&mut self, collector: &mut impl OperandVisitor) {
         match self {
-            Self::Reg { reg } => collector.reg_use(*reg),
+            Self::Reg { reg } => collector.reg_use(reg),
             Self::Mem { addr } => addr.get_operands(collector),
             Self::Imm { .. } => {}
         }
     }
-
-    pub(crate) fn with_allocs(&self, allocs: &mut AllocationConsumer<'_>) -> Self {
-        match self {
-            Self::Reg { reg } => Self::Reg {
-                reg: allocs.next(*reg),
-            },
-            Self::Mem { addr } => Self::Mem {
-                addr: addr.with_allocs(allocs),
-            },
-            Self::Imm { .. } => self.clone(),
-        }
-    }
 }
 
 impl From<RegMem> for RegMemImm {
@@ -676,10 +708,10 @@ impl From<Reg> for RegMemImm {
 }
 
 impl PrettyPrint for RegMemImm {
-    fn pretty_print(&self, size: u8, allocs: &mut AllocationConsumer<'_>) -> String {
+    fn pretty_print(&self, size: u8) -> String {
         match self {
-            Self::Reg { reg } => pretty_print_reg(*reg, size, allocs),
-            Self::Mem { addr } => addr.pretty_print(size, allocs),
+            Self::Reg { reg } => pretty_print_reg(*reg, size),
+            Self::Mem { addr } => addr.pretty_print(size),
             Self::Imm { simm32 } => format!("${}", *simm32 as i32),
         }
     }
@@ -746,26 +778,12 @@ impl RegMem {
         }
     }
     /// Add the regs mentioned by `self` to `collector`.
-    pub(crate) fn get_operands<F: Fn(VReg) -> VReg>(
-        &self,
-        collector: &mut OperandCollector<'_, F>,
-    ) {
+    pub(crate) fn get_operands(&mut self, collector: &mut impl OperandVisitor) {
         match self {
-            RegMem::Reg { reg } => collector.reg_use(*reg),
+            RegMem::Reg { reg } => collector.reg_use(reg),
             RegMem::Mem { addr, .. } => addr.get_operands(collector),
         }
     }
-
-    pub(crate) fn with_allocs(&self, allocs: &mut AllocationConsumer<'_>) -> Self {
-        match self {
-            RegMem::Reg { reg } => RegMem::Reg {
-                reg: allocs.next(*reg),
-            },
-            RegMem::Mem { addr } => RegMem::Mem {
-                addr: addr.with_allocs(allocs),
-            },
-        }
-    }
 }
 
 impl From<Reg> for RegMem {
@@ -781,10 +799,10 @@ impl From<Writable<Reg>> for RegMem {
 }
 
 impl PrettyPrint for RegMem {
-    fn pretty_print(&self, size: u8, allocs: &mut AllocationConsumer<'_>) -> String {
+    fn pretty_print(&self, size: u8) -> String {
         match self {
-            RegMem::Reg { reg } => pretty_print_reg(*reg, size, allocs),
-            RegMem::Mem { addr, .. } => addr.pretty_print(size, allocs),
+            RegMem::Reg { reg } => pretty_print_reg(*reg, size),
+            RegMem::Mem { addr, .. } => addr.pretty_print(size),
         }
     }
 }
@@ -806,8 +824,6 @@ pub enum AluRmiROpcode {
     Or,
     /// Bitwise exclusive OR.
     Xor,
-    /// The signless, non-extending (N x N -> N, for N in {32,64}) variant.
-    Mul,
 }
 
 impl fmt::Debug for AluRmiROpcode {
@@ -820,9 +836,8 @@ impl fmt::Debug for AluRmiROpcode {
             AluRmiROpcode::And => "and",
             AluRmiROpcode::Or => "or",
             AluRmiROpcode::Xor => "xor",
-            AluRmiROpcode::Mul => "imul",
         };
-        write!(fmt, "{}", name)
+        write!(fmt, "{name}")
     }
 }
 
@@ -1142,6 +1157,7 @@ pub enum SseOpcode {
     Ucomiss,
     Ucomisd,
     Unpcklps,
+    Unpcklpd,
     Unpckhps,
     Xorps,
     Xorpd,
@@ -1300,7 +1316,8 @@ impl SseOpcode {
             | SseOpcode::Punpcklqdq
             | SseOpcode::Punpckhqdq
             | SseOpcode::Pshuflw
-            | SseOpcode::Pshufhw => SSE2,
+            | SseOpcode::Pshufhw
+            | SseOpcode::Unpcklpd => SSE2,
 
             SseOpcode::Pabsb
             | SseOpcode::Pabsw
@@ -1364,6 +1381,26 @@ impl SseOpcode {
             _ => 8,
         }
     }
+
+    /// Is `src2` with this opcode a scalar, as for lane insertions?
+    pub(crate) fn has_scalar_src2(self) -> bool {
+        match self {
+            SseOpcode::Pinsrb | SseOpcode::Pinsrw | SseOpcode::Pinsrd => true,
+            SseOpcode::Pmovsxbw
+            | SseOpcode::Pmovsxbd
+            | SseOpcode::Pmovsxbq
+            | SseOpcode::Pmovsxwd
+            | SseOpcode::Pmovsxwq
+            | SseOpcode::Pmovsxdq => true,
+            SseOpcode::Pmovzxbw
+            | SseOpcode::Pmovzxbd
+            | SseOpcode::Pmovzxbq
+            | SseOpcode::Pmovzxwd
+            | SseOpcode::Pmovzxwq
+            | SseOpcode::Pmovzxdq => true,
+            _ => false,
+        }
+    }
 }
 
 impl fmt::Debug for SseOpcode {
@@ -1557,8 +1594,9 @@ impl fmt::Debug for SseOpcode {
             SseOpcode::Pshufhw => "pshufhw",
             SseOpcode::Pblendw => "pblendw",
             SseOpcode::Movddup => "movddup",
+            SseOpcode::Unpcklpd => "unpcklpd",
         };
-        write!(fmt, "{}", name)
+        write!(fmt, "{name}")
     }
 }
 
@@ -1589,7 +1627,23 @@ impl AvxOpcode {
             | AvxOpcode::Vfnmadd132ss
             | AvxOpcode::Vfnmadd132sd
             | AvxOpcode::Vfnmadd132ps
-            | AvxOpcode::Vfnmadd132pd => smallvec![InstructionSet::FMA],
+            | AvxOpcode::Vfnmadd132pd
+            | AvxOpcode::Vfmsub213ss
+            | AvxOpcode::Vfmsub213sd
+            | AvxOpcode::Vfmsub213ps
+            | AvxOpcode::Vfmsub213pd
+            | AvxOpcode::Vfmsub132ss
+            | AvxOpcode::Vfmsub132sd
+            | AvxOpcode::Vfmsub132ps
+            | AvxOpcode::Vfmsub132pd
+            | AvxOpcode::Vfnmsub213ss
+            | AvxOpcode::Vfnmsub213sd
+            | AvxOpcode::Vfnmsub213ps
+            | AvxOpcode::Vfnmsub213pd
+            | AvxOpcode::Vfnmsub132ss
+            | AvxOpcode::Vfnmsub132sd
+            | AvxOpcode::Vfnmsub132ps
+            | AvxOpcode::Vfnmsub132pd => smallvec![InstructionSet::FMA],
             AvxOpcode::Vminps
             | AvxOpcode::Vminpd
             | AvxOpcode::Vmaxps
@@ -1758,7 +1812,11 @@ impl AvxOpcode {
             | AvxOpcode::Vsqrtss
             | AvxOpcode::Vsqrtsd
             | AvxOpcode::Vroundss
-            | AvxOpcode::Vroundsd => {
+            | AvxOpcode::Vroundsd
+            | AvxOpcode::Vunpcklpd
+            | AvxOpcode::Vptest
+            | AvxOpcode::Vucomiss
+            | AvxOpcode::Vucomisd => {
                 smallvec![InstructionSet::AVX]
             }
 
@@ -1930,6 +1988,15 @@ impl ExtMode {
             ExtMode::BQ | ExtMode::WQ | ExtMode::LQ => 8,
         }
     }
+
+    /// Source size, as an integer type.
+    pub(crate) fn src_type(&self) -> Type {
+        match self {
+            ExtMode::BL | ExtMode::BQ => I8,
+            ExtMode::WL | ExtMode::WQ => I16,
+            ExtMode::LQ => I32,
+        }
+    }
 }
 
 impl fmt::Debug for ExtMode {
@@ -1941,7 +2008,7 @@ impl fmt::Debug for ExtMode {
             ExtMode::WQ => "wq",
             ExtMode::LQ => "lq",
         };
-        write!(fmt, "{}", name)
+        write!(fmt, "{name}")
     }
 }
 
@@ -1975,7 +2042,7 @@ impl fmt::Debug for ShiftKind {
             ShiftKind::RotateLeft => "rol",
             ShiftKind::RotateRight => "ror",
         };
-        write!(fmt, "{}", name)
+        write!(fmt, "{name}")
     }
 }
 
@@ -1987,7 +2054,7 @@ impl fmt::Display for ShiftKind {
 
 /// These indicate condition code tests.  Not all are represented since not all are useful in
 /// compiler-generated code.
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 #[repr(u8)]
 pub enum CC {
     ///  overflow
@@ -2101,7 +2168,7 @@ impl fmt::Debug for CC {
             CC::P => "p",
             CC::NP => "np",
         };
-        write!(fmt, "{}", name)
+        write!(fmt, "{name}")
     }
 }
 
@@ -2151,7 +2218,7 @@ impl From<FloatCC> for FcmpImm {
             FloatCC::UnorderedOrGreaterThanOrEqual => FcmpImm::UnorderedOrGreaterThanOrEqual,
             FloatCC::UnorderedOrGreaterThan => FcmpImm::UnorderedOrGreaterThan,
             FloatCC::Ordered => FcmpImm::Ordered,
-            _ => panic!("unable to create comparison predicate for {}", cond),
+            _ => panic!("unable to create comparison predicate for {cond}"),
         }
     }
 }
@@ -2161,7 +2228,7 @@ impl From<FloatCC> for FcmpImm {
 /// (i.e. the rounding mode) which only take up the first two bits when encoded.
 /// However the rounding immediate which this field helps make up, also includes
 /// bits 3 and 4 which define the rounding select and precision mask respectively.
-/// These two bits are not defined here and are implictly set to zero when encoded.
+/// These two bits are not defined here and are implicitly set to zero when encoded.
 #[derive(Clone, Copy)]
 pub enum RoundImm {
     /// Round to nearest mode.
@@ -2227,6 +2294,15 @@ impl OperandSize {
     pub(crate) fn to_bits(&self) -> u8 {
         self.to_bytes() * 8
     }
+
+    pub(crate) fn to_type(&self) -> Type {
+        match self {
+            Self::Size8 => I8,
+            Self::Size16 => I16,
+            Self::Size32 => I32,
+            Self::Size64 => I64,
+        }
+    }
 }
 
 /// An x64 memory fence kind.
diff --git a/cranelift/codegen/src/isa/x64/inst/emit.rs b/cranelift/codegen/src/isa/x64/inst/emit.rs
index 6bd65154eb23..9bc374ce507c 100644
--- a/cranelift/codegen/src/isa/x64/inst/emit.rs
+++ b/cranelift/codegen/src/isa/x64/inst/emit.rs
@@ -1,8 +1,5 @@
-use crate::binemit::{Addend, Reloc};
-use crate::ir;
 use crate::ir::immediates::{Ieee32, Ieee64};
-use crate::ir::TrapCode;
-use crate::ir::{KnownSymbol, LibCall, MemFlags};
+use crate::ir::KnownSymbol;
 use crate::isa::x64::encoding::evex::{EvexInstruction, EvexVectorLength, RegisterOrAmode};
 use crate::isa::x64::encoding::rex::{
     emit_simm, emit_std_enc_enc, emit_std_enc_mem, emit_std_reg_mem, emit_std_reg_reg, int_reg_enc,
@@ -12,8 +9,6 @@ use crate::isa::x64::encoding::rex::{
 use crate::isa::x64::encoding::vex::{VexInstruction, VexVectorLength};
 use crate::isa::x64::inst::args::*;
 use crate::isa::x64::inst::*;
-use crate::machinst::{inst_common, MachBuffer, MachInstEmit, MachLabel, Reg, Writable};
-use core::convert::TryInto;
 
 /// A small helper to generate a signed conversion instruction.
 fn emit_signed_cvt(
@@ -32,14 +27,15 @@ fn emit_signed_cvt(
     } else {
         SseOpcode::Cvtsi2ss
     };
+    let dst = WritableXmm::from_writable_reg(dst).unwrap();
     Inst::CvtIntToFloat {
         op,
-        dst: Writable::from_reg(Xmm::new(dst.to_reg()).unwrap()),
-        src1: Xmm::new(dst.to_reg()).unwrap(),
-        src2: GprMem::new(RegMem::reg(src)).unwrap(),
+        dst,
+        src1: dst.to_reg(),
+        src2: GprMem::unwrap_new(RegMem::reg(src)),
         src2_size: OperandSize::Size64,
     }
-    .emit(&[], sink, info, state);
+    .emit(sink, info, state);
 }
 
 /// Emits a one way conditional jump if CC is set (true).
@@ -111,7 +107,6 @@ fn emit_reloc(sink: &mut MachBuffer<Inst>, kind: Reloc, name: &ExternalName, add
 ///   care?)
 pub(crate) fn emit(
     inst: &Inst,
-    allocs: &mut AllocationConsumer<'_>,
     sink: &mut MachBuffer<Inst>,
     info: &EmitInfo,
     state: &mut EmitState,
@@ -143,8 +138,7 @@ pub(crate) fn emit(
     let isa_requirements = inst.available_in_any_isa();
     if !isa_requirements.is_empty() && !isa_requirements.iter().all(matches_isa_flags) {
         panic!(
-            "Cannot emit inst '{:?}' for target; failed to match ISA requirements: {:?}",
-            inst, isa_requirements
+            "Cannot emit inst '{inst:?}' for target; failed to match ISA requirements: {isa_requirements:?}"
         )
     }
 
@@ -156,10 +150,10 @@ pub(crate) fn emit(
             src2,
             dst: reg_g,
         } => {
-            let src1 = allocs.next(src1.to_reg());
-            let reg_g = allocs.next(reg_g.to_reg().to_reg());
+            let src1 = src1.to_reg();
+            let reg_g = reg_g.to_reg().to_reg();
             debug_assert_eq!(src1, reg_g);
-            let src2 = src2.clone().to_reg_mem_imm().with_allocs(allocs);
+            let src2 = src2.clone().to_reg_mem_imm().clone();
 
             let prefix = if *size == OperandSize::Size16 {
                 LegacyPrefixes::_66
@@ -168,149 +162,87 @@ pub(crate) fn emit(
             };
 
             let mut rex = RexFlags::from(*size);
-            if *op == AluRmiROpcode::Mul {
-                // We kinda freeloaded Mul into RMI_R_Op, but it doesn't fit the usual pattern, so
-                // we have to special-case it.
-                if *size == OperandSize::Size8 {
-                    match src2 {
-                        RegMemImm::Reg { reg: reg_e } => {
-                            debug_assert!(reg_e.is_real());
-                            rex.always_emit_if_8bit_needed(reg_e);
-                            let enc_e = int_reg_enc(reg_e);
-                            emit_std_enc_enc(sink, LegacyPrefixes::None, 0xF6, 1, 5, enc_e, rex);
-                        }
-
-                        RegMemImm::Mem { addr } => {
-                            let amode = addr.finalize(state, sink);
-                            emit_std_enc_mem(
-                                sink,
-                                LegacyPrefixes::None,
-                                0xF6,
-                                1,
-                                5,
-                                &amode,
-                                rex,
-                                0,
-                            );
-                        }
+            let (opcode_r, opcode_m, subopcode_i) = match op {
+                AluRmiROpcode::Add => (0x01, 0x03, 0),
+                AluRmiROpcode::Adc => (0x11, 0x13, 2),
+                AluRmiROpcode::Sub => (0x29, 0x2B, 5),
+                AluRmiROpcode::Sbb => (0x19, 0x1B, 3),
+                AluRmiROpcode::And => (0x21, 0x23, 4),
+                AluRmiROpcode::Or => (0x09, 0x0B, 1),
+                AluRmiROpcode::Xor => (0x31, 0x33, 6),
+            };
 
-                        RegMemImm::Imm { .. } => {
-                            panic!("Cannot emit 8bit imul with 8bit immediate");
-                        }
-                    }
-                } else {
-                    match src2 {
-                        RegMemImm::Reg { reg: reg_e } => {
-                            emit_std_reg_reg(sink, prefix, 0x0FAF, 2, reg_g, reg_e, rex);
-                        }
+            let (opcode_r, opcode_m) = if *size == OperandSize::Size8 {
+                (opcode_r - 1, opcode_m - 1)
+            } else {
+                (opcode_r, opcode_m)
+            };
 
-                        RegMemImm::Mem { addr } => {
-                            let amode = addr.finalize(state, sink);
-                            emit_std_reg_mem(sink, prefix, 0x0FAF, 2, reg_g, &amode, rex, 0);
-                        }
+            if *size == OperandSize::Size8 {
+                debug_assert!(reg_g.is_real());
+                rex.always_emit_if_8bit_needed(reg_g);
+            }
 
-                        RegMemImm::Imm { simm32 } => {
-                            let imm_size = if low8_will_sign_extend_to_32(simm32) {
-                                1
-                            } else {
-                                if *size == OperandSize::Size16 {
-                                    2
-                                } else {
-                                    4
-                                }
-                            };
-                            let opcode = if imm_size == 1 { 0x6B } else { 0x69 };
-                            // Yes, really, reg_g twice.
-                            emit_std_reg_reg(sink, prefix, opcode, 1, reg_g, reg_g, rex);
-                            emit_simm(sink, imm_size, simm32);
-                        }
+            match src2 {
+                RegMemImm::Reg { reg: reg_e } => {
+                    if *size == OperandSize::Size8 {
+                        debug_assert!(reg_e.is_real());
+                        rex.always_emit_if_8bit_needed(reg_e);
                     }
-                }
-            } else {
-                let (opcode_r, opcode_m, subopcode_i) = match op {
-                    AluRmiROpcode::Add => (0x01, 0x03, 0),
-                    AluRmiROpcode::Adc => (0x11, 0x03, 0),
-                    AluRmiROpcode::Sub => (0x29, 0x2B, 5),
-                    AluRmiROpcode::Sbb => (0x19, 0x2B, 5),
-                    AluRmiROpcode::And => (0x21, 0x23, 4),
-                    AluRmiROpcode::Or => (0x09, 0x0B, 1),
-                    AluRmiROpcode::Xor => (0x31, 0x33, 6),
-                    AluRmiROpcode::Mul => panic!("unreachable"),
-                };
 
-                let (opcode_r, opcode_m) = if *size == OperandSize::Size8 {
-                    (opcode_r - 1, opcode_m - 1)
-                } else {
-                    (opcode_r, opcode_m)
-                };
-
-                if *size == OperandSize::Size8 {
-                    debug_assert!(reg_g.is_real());
-                    rex.always_emit_if_8bit_needed(reg_g);
+                    // GCC/llvm use the swapped operand encoding (viz., the R/RM vs RM/R
+                    // duality). Do this too, so as to be able to compare generated machine
+                    // code easily.
+                    emit_std_reg_reg(sink, prefix, opcode_r, 1, reg_e, reg_g, rex);
                 }
 
-                match src2 {
-                    RegMemImm::Reg { reg: reg_e } => {
-                        if *size == OperandSize::Size8 {
-                            debug_assert!(reg_e.is_real());
-                            rex.always_emit_if_8bit_needed(reg_e);
-                        }
-
-                        // GCC/llvm use the swapped operand encoding (viz., the R/RM vs RM/R
-                        // duality). Do this too, so as to be able to compare generated machine
-                        // code easily.
-                        emit_std_reg_reg(sink, prefix, opcode_r, 1, reg_e, reg_g, rex);
-                    }
-
-                    RegMemImm::Mem { addr } => {
-                        let amode = addr.finalize(state, sink);
-                        // Here we revert to the "normal" G-E ordering.
-                        emit_std_reg_mem(sink, prefix, opcode_m, 1, reg_g, &amode, rex, 0);
-                    }
+                RegMemImm::Mem { addr } => {
+                    let amode = addr.finalize(state, sink);
+                    // Here we revert to the "normal" G-E ordering.
+                    emit_std_reg_mem(sink, prefix, opcode_m, 1, reg_g, &amode, rex, 0);
+                }
 
-                    RegMemImm::Imm { simm32 } => {
-                        let imm_size = if *size == OperandSize::Size8 {
+                RegMemImm::Imm { simm32 } => {
+                    let imm_size = if *size == OperandSize::Size8 {
+                        1
+                    } else {
+                        if low8_will_sign_extend_to_32(simm32) {
                             1
                         } else {
-                            if low8_will_sign_extend_to_32(simm32) {
-                                1
+                            if *size == OperandSize::Size16 {
+                                2
                             } else {
-                                if *size == OperandSize::Size16 {
-                                    2
-                                } else {
-                                    4
-                                }
+                                4
                             }
-                        };
+                        }
+                    };
 
-                        let opcode = if *size == OperandSize::Size8 {
-                            0x80
-                        } else if low8_will_sign_extend_to_32(simm32) {
-                            0x83
-                        } else {
-                            0x81
-                        };
+                    let opcode = if *size == OperandSize::Size8 {
+                        0x80
+                    } else if low8_will_sign_extend_to_32(simm32) {
+                        0x83
+                    } else {
+                        0x81
+                    };
 
-                        // And also here we use the "normal" G-E ordering.
-                        let enc_g = int_reg_enc(reg_g);
-                        emit_std_enc_enc(sink, prefix, opcode, 1, subopcode_i, enc_g, rex);
-                        emit_simm(sink, imm_size, simm32);
-                    }
+                    // And also here we use the "normal" G-E ordering.
+                    let enc_g = int_reg_enc(reg_g);
+                    emit_std_enc_enc(sink, prefix, opcode, 1, subopcode_i, enc_g, rex);
+                    emit_simm(sink, imm_size, simm32);
                 }
             }
         }
 
-        Inst::AluConstOp { op, size, dst } => {
-            let dst = allocs.next(dst.to_reg().to_reg());
+        &Inst::AluConstOp { op, size, dst } => {
+            let dst = WritableGpr::from_writable_reg(dst.to_writable_reg()).unwrap();
             emit(
                 &Inst::AluRmiR {
-                    size: *size,
-                    op: *op,
-                    dst: Writable::from_reg(Gpr::new(dst).unwrap()),
-                    src1: Gpr::new(dst).unwrap(),
-                    src2: Gpr::new(dst).unwrap().into(),
+                    size,
+                    op,
+                    dst,
+                    src1: dst.to_reg(),
+                    src2: dst.to_reg().into(),
                 },
-                allocs,
                 sink,
                 info,
                 state,
@@ -323,8 +255,8 @@ pub(crate) fn emit(
             src2,
             op,
         } => {
-            let src2 = allocs.next(src2.to_reg());
-            let src1_dst = src1_dst.finalize(state, sink).with_allocs(allocs);
+            let src2 = src2.to_reg();
+            let src1_dst = src1_dst.finalize(state, sink).clone();
 
             let opcode = match op {
                 AluRmiROpcode::Add => 0x01,
@@ -366,9 +298,9 @@ pub(crate) fn emit(
             use AluRmROpcode::*;
             use LegacyPrefixes as LP;
 
-            let dst = allocs.next(dst.to_reg().to_reg());
-            let src1 = allocs.next(src1.to_reg());
-            let src2 = match src2.clone().to_reg_mem().with_allocs(allocs) {
+            let dst = dst.to_reg().to_reg();
+            let src1 = src1.to_reg();
+            let src2 = match src2.clone().to_reg_mem().clone() {
                 RegMem::Reg { reg } => {
                     RegisterOrAmode::Register(reg.to_real_reg().unwrap().hw_enc().into())
                 }
@@ -403,7 +335,7 @@ pub(crate) fn emit(
         }
 
         Inst::UnaryRmR { size, op, src, dst } => {
-            let dst = allocs.next(dst.to_reg().to_reg());
+            let dst = dst.to_reg().to_reg();
             let rex_flags = RexFlags::from(*size);
             use UnaryRmROpcode::*;
             let prefix = match size {
@@ -428,19 +360,18 @@ pub(crate) fn emit(
 
             match src.clone().into() {
                 RegMem::Reg { reg: src } => {
-                    let src = allocs.next(src);
                     emit_std_reg_reg(sink, prefix, opcode, num_opcodes, dst, src, rex_flags);
                 }
                 RegMem::Mem { addr: src } => {
-                    let amode = src.finalize(state, sink).with_allocs(allocs);
+                    let amode = src.finalize(state, sink).clone();
                     emit_std_reg_mem(sink, prefix, opcode, num_opcodes, dst, &amode, rex_flags, 0);
                 }
             }
         }
 
         Inst::UnaryRmRVex { size, op, src, dst } => {
-            let dst = allocs.next(dst.to_reg().to_reg());
-            let src = match src.clone().to_reg_mem().with_allocs(allocs) {
+            let dst = dst.to_reg().to_reg();
+            let src = match src.clone().to_reg_mem().clone() {
                 RegMem::Reg { reg } => {
                     RegisterOrAmode::Register(reg.to_real_reg().unwrap().hw_enc().into())
                 }
@@ -470,8 +401,8 @@ pub(crate) fn emit(
             dst,
             imm,
         } => {
-            let dst = allocs.next(dst.to_reg().to_reg());
-            let src = match src.clone().to_reg_mem().with_allocs(allocs) {
+            let dst = dst.to_reg().to_reg();
+            let src = match src.clone().to_reg_mem().clone() {
                 RegMem::Reg { reg } => {
                     RegisterOrAmode::Register(reg.to_real_reg().unwrap().hw_enc().into())
                 }
@@ -494,8 +425,8 @@ pub(crate) fn emit(
         }
 
         Inst::Not { size, src, dst } => {
-            let src = allocs.next(src.to_reg());
-            let dst = allocs.next(dst.to_reg().to_reg());
+            let src = src.to_reg();
+            let dst = dst.to_reg().to_reg();
             debug_assert_eq!(src, dst);
             let rex_flags = RexFlags::from((*size, dst));
             let (opcode, prefix) = match size {
@@ -511,8 +442,8 @@ pub(crate) fn emit(
         }
 
         Inst::Neg { size, src, dst } => {
-            let src = allocs.next(src.to_reg());
-            let dst = allocs.next(dst.to_reg().to_reg());
+            let src = src.to_reg();
+            let dst = dst.to_reg().to_reg();
             debug_assert_eq!(src, dst);
             let rex_flags = RexFlags::from((*size, dst));
             let (opcode, prefix) = match size {
@@ -539,7 +470,7 @@ pub(crate) fn emit(
             divisor,
             ..
         } => {
-            let divisor = divisor.clone().to_reg_mem().with_allocs(allocs);
+            let divisor = divisor.clone().to_reg_mem().clone();
             let size = match inst {
                 Inst::Div {
                     size,
@@ -549,10 +480,10 @@ pub(crate) fn emit(
                     dst_remainder,
                     ..
                 } => {
-                    let dividend_lo = allocs.next(dividend_lo.to_reg());
-                    let dividend_hi = allocs.next(dividend_hi.to_reg());
-                    let dst_quotient = allocs.next(dst_quotient.to_reg().to_reg());
-                    let dst_remainder = allocs.next(dst_remainder.to_reg().to_reg());
+                    let dividend_lo = dividend_lo.to_reg();
+                    let dividend_hi = dividend_hi.to_reg();
+                    let dst_quotient = dst_quotient.to_reg().to_reg();
+                    let dst_remainder = dst_remainder.to_reg().to_reg();
                     debug_assert_eq!(dividend_lo, regs::rax());
                     debug_assert_eq!(dividend_hi, regs::rdx());
                     debug_assert_eq!(dst_quotient, regs::rax());
@@ -560,8 +491,8 @@ pub(crate) fn emit(
                     *size
                 }
                 Inst::Div8 { dividend, dst, .. } => {
-                    let dividend = allocs.next(dividend.to_reg());
-                    let dst = allocs.next(dst.to_reg().to_reg());
+                    let dividend = dividend.to_reg();
+                    let dst = dst.to_reg().to_reg();
                     debug_assert_eq!(dividend, regs::rax());
                     debug_assert_eq!(dst, regs::rax());
                     OperandSize::Size8
@@ -611,20 +542,21 @@ pub(crate) fn emit(
             }
         }
 
-        Inst::MulHi {
-            size,
+        Inst::Mul {
             signed,
+            size,
             src1,
             src2,
             dst_lo,
             dst_hi,
         } => {
-            let src1 = allocs.next(src1.to_reg());
-            let dst_lo = allocs.next(dst_lo.to_reg().to_reg());
-            let dst_hi = allocs.next(dst_hi.to_reg().to_reg());
+            let src1 = src1.to_reg();
+            let dst_lo = dst_lo.to_reg().to_reg();
+            let dst_hi = dst_hi.to_reg().to_reg();
             debug_assert_eq!(src1, regs::rax());
             debug_assert_eq!(dst_lo, regs::rax());
             debug_assert_eq!(dst_hi, regs::rdx());
+            let src2 = src2.clone().to_reg_mem().clone();
 
             let rex_flags = RexFlags::from(*size);
             let prefix = match size {
@@ -635,61 +567,124 @@ pub(crate) fn emit(
             };
 
             let subopcode = if *signed { 5 } else { 4 };
-            match src2.clone().to_reg_mem() {
+            match src2 {
                 RegMem::Reg { reg } => {
-                    let reg = allocs.next(reg);
                     let src = int_reg_enc(reg);
                     emit_std_enc_enc(sink, prefix, 0xF7, 1, subopcode, src, rex_flags)
                 }
                 RegMem::Mem { addr: src } => {
-                    let amode = src.finalize(state, sink).with_allocs(allocs);
+                    let amode = src.finalize(state, sink);
                     emit_std_enc_mem(sink, prefix, 0xF7, 1, subopcode, &amode, rex_flags, 0);
                 }
             }
         }
-
-        Inst::UMulLo {
-            size,
+        Inst::Mul8 {
+            signed,
             src1,
             src2,
             dst,
         } => {
-            let src1 = allocs.next(src1.to_reg());
-            let dst = allocs.next(dst.to_reg().to_reg());
+            let src1 = src1.to_reg();
+            let dst = dst.to_reg().to_reg();
             debug_assert_eq!(src1, regs::rax());
             debug_assert_eq!(dst, regs::rax());
+            let src2 = src2.clone().to_reg_mem().clone();
 
-            let mut rex = RexFlags::from(*size);
+            let mut rex_flags = RexFlags::from(OperandSize::Size8);
+            let prefix = LegacyPrefixes::None;
+            let subopcode = if *signed { 5 } else { 4 };
+            match src2 {
+                RegMem::Reg { reg } => {
+                    // The intel manual states:
+                    //
+                    // > r/m8 can not be encoded to access the following byte
+                    // > registers if a REX prefix is used: AH, BH, CH, DH
+                    //
+                    // And apparently that also means that a REX prefix must be
+                    // used if it's not one of those registers.
+                    if !(reg == regs::rax()
+                        || reg == regs::rbx()
+                        || reg == regs::rcx()
+                        || reg == regs::rdx())
+                    {
+                        rex_flags.always_emit();
+                    }
+                    let src = int_reg_enc(reg);
+                    emit_std_enc_enc(sink, prefix, 0xF6, 1, subopcode, src, rex_flags)
+                }
+                RegMem::Mem { addr } => {
+                    let amode = addr.finalize(state, sink);
+                    emit_std_enc_mem(sink, prefix, 0xF6, 1, subopcode, &amode, rex_flags, 0);
+                }
+            }
+        }
+        Inst::IMul {
+            size,
+            src1,
+            src2,
+            dst,
+        } => {
+            let src1 = src1.to_reg();
+            let dst = dst.to_reg().to_reg();
+            debug_assert_eq!(src1, dst);
+            let src2 = src2.clone().to_reg_mem().clone();
+
+            let rex = RexFlags::from(*size);
+            let prefix = LegacyPrefixes::None;
+            match src2 {
+                RegMem::Reg { reg } => {
+                    emit_std_reg_reg(sink, prefix, 0x0FAF, 2, dst, reg, rex);
+                }
+
+                RegMem::Mem { addr } => {
+                    let amode = addr.finalize(state, sink);
+                    emit_std_reg_mem(sink, prefix, 0x0FAF, 2, dst, &amode, rex, 0);
+                }
+            }
+        }
+
+        Inst::IMulImm {
+            size,
+            src1,
+            src2,
+            dst,
+        } => {
+            let dst = dst.to_reg().to_reg();
+            let src1 = src1.clone().to_reg_mem().clone();
+
+            let rex = RexFlags::from(*size);
             let prefix = match size {
+                // NB: the intel manual doesn't seem to mention this prefix as
+                // being required
                 OperandSize::Size16 => LegacyPrefixes::_66,
                 _ => LegacyPrefixes::None,
             };
-
-            let opcode = if *size == OperandSize::Size8 {
-                0xF6
+            let imm_size = if i8::try_from(*src2).is_ok() {
+                1
             } else {
-                0xF7
+                if *size == OperandSize::Size16 {
+                    2
+                } else {
+                    4
+                }
             };
-
-            match src2.clone().to_reg_mem() {
+            let opcode = if imm_size == 1 { 0x6B } else { 0x69 };
+            match src1 {
                 RegMem::Reg { reg } => {
-                    let reg = allocs.next(reg);
-                    if *size == OperandSize::Size8 {
-                        rex.always_emit_if_8bit_needed(reg);
-                    }
-                    let reg_e = int_reg_enc(reg);
-                    emit_std_enc_enc(sink, prefix, opcode, 1, 4, reg_e, rex);
+                    emit_std_reg_reg(sink, prefix, opcode, 1, dst, reg, rex);
                 }
-                RegMem::Mem { addr: src } => {
-                    let amode = src.finalize(state, sink).with_allocs(allocs);
-                    emit_std_enc_mem(sink, prefix, opcode, 1, 4, &amode, rex, 0);
+
+                RegMem::Mem { addr } => {
+                    let amode = addr.finalize(state, sink);
+                    emit_std_reg_mem(sink, prefix, opcode, 1, dst, &amode, rex, imm_size);
                 }
             }
+            emit_simm(sink, imm_size, *src2 as u32);
         }
 
         Inst::SignExtendData { size, src, dst } => {
-            let src = allocs.next(src.to_reg());
-            let dst = allocs.next(dst.to_reg().to_reg());
+            let src = src.to_reg();
+            let dst = dst.to_reg().to_reg();
             debug_assert_eq!(src, regs::rax());
             if *size == OperandSize::Size8 {
                 debug_assert_eq!(dst, regs::rax());
@@ -714,7 +709,7 @@ pub(crate) fn emit(
         }
 
         Inst::CheckedSRemSeq { divisor, .. } | Inst::CheckedSRemSeq8 { divisor, .. } => {
-            let divisor = allocs.next(divisor.to_reg());
+            let divisor = divisor.to_reg();
 
             // Validate that the register constraints of the dividend and the
             // destination are all as expected.
@@ -727,10 +722,10 @@ pub(crate) fn emit(
                     size,
                     ..
                 } => {
-                    let dividend_lo = allocs.next(dividend_lo.to_reg());
-                    let dividend_hi = allocs.next(dividend_hi.to_reg());
-                    let dst_quotient = allocs.next(dst_quotient.to_reg().to_reg());
-                    let dst_remainder = allocs.next(dst_remainder.to_reg().to_reg());
+                    let dividend_lo = dividend_lo.to_reg();
+                    let dividend_hi = dividend_hi.to_reg();
+                    let dst_quotient = dst_quotient.to_reg().to_reg();
+                    let dst_remainder = dst_remainder.to_reg().to_reg();
                     debug_assert_eq!(dividend_lo, regs::rax());
                     debug_assert_eq!(dividend_hi, regs::rdx());
                     debug_assert_eq!(dst_quotient, regs::rax());
@@ -738,8 +733,8 @@ pub(crate) fn emit(
                     (regs::rdx(), *size)
                 }
                 Inst::CheckedSRemSeq8 { dividend, dst, .. } => {
-                    let dividend = allocs.next(dividend.to_reg());
-                    let dst = allocs.next(dst.to_reg().to_reg());
+                    let dividend = dividend.to_reg();
+                    let dst = dst.to_reg().to_reg();
                     debug_assert_eq!(dividend, regs::rax());
                     debug_assert_eq!(dst, regs::rax());
                     (regs::rax(), OperandSize::Size8)
@@ -766,8 +761,8 @@ pub(crate) fn emit(
 
             // Check if the divisor is -1, and if it isn't then immediately
             // go to the `idiv`.
-            let inst = Inst::cmp_rmi_r(size, RegMemImm::imm(0xffffffff), divisor);
-            inst.emit(&[], sink, info, state);
+            let inst = Inst::cmp_rmi_r(size, divisor, RegMemImm::imm(0xffffffff));
+            inst.emit(sink, info, state);
             one_way_jmp(sink, CC::NZ, do_op);
 
             // ... otherwise the divisor is -1 and the result is always 0. This
@@ -780,9 +775,9 @@ pub(crate) fn emit(
             // output but for srem only the `dst_remainder` output is used for
             // now.
             let inst = Inst::imm(OperandSize::Size64, 0, Writable::from_reg(dst));
-            inst.emit(&[], sink, info, state);
+            inst.emit(sink, info, state);
             let inst = Inst::jmp_known(done_label);
-            inst.emit(&[], sink, info, state);
+            inst.emit(sink, info, state);
 
             // Here the `idiv` is executed, which is different depending on the
             // size
@@ -792,21 +787,21 @@ pub(crate) fn emit(
                     DivSignedness::Signed,
                     TrapCode::IntegerDivisionByZero,
                     RegMem::reg(divisor),
-                    Gpr::new(regs::rax()).unwrap(),
-                    Writable::from_reg(Gpr::new(regs::rax()).unwrap()),
+                    Gpr::unwrap_new(regs::rax()),
+                    Writable::from_reg(Gpr::unwrap_new(regs::rax())),
                 ),
                 _ => Inst::div(
                     size,
                     DivSignedness::Signed,
                     TrapCode::IntegerDivisionByZero,
                     RegMem::reg(divisor),
-                    Gpr::new(regs::rax()).unwrap(),
-                    Gpr::new(regs::rdx()).unwrap(),
-                    Writable::from_reg(Gpr::new(regs::rax()).unwrap()),
-                    Writable::from_reg(Gpr::new(regs::rdx()).unwrap()),
+                    Gpr::unwrap_new(regs::rax()),
+                    Gpr::unwrap_new(regs::rdx()),
+                    Writable::from_reg(Gpr::unwrap_new(regs::rax())),
+                    Writable::from_reg(Gpr::unwrap_new(regs::rdx())),
                 ),
             };
-            inst.emit(&[], sink, info, state);
+            inst.emit(sink, info, state);
 
             sink.bind_label(done_label, state.ctrl_plane_mut());
         }
@@ -816,7 +811,7 @@ pub(crate) fn emit(
             simm64,
             dst,
         } => {
-            let dst = allocs.next(dst.to_reg().to_reg());
+            let dst = dst.to_reg().to_reg();
             let enc_dst = int_reg_enc(dst);
             if *dst_size == OperandSize::Size64 {
                 if low32_will_sign_extend_to_64(*simm64) {
@@ -846,7 +841,7 @@ pub(crate) fn emit(
         }
 
         Inst::MovImmM { size, simm32, dst } => {
-            let dst = &dst.finalize(state, sink).with_allocs(allocs);
+            let dst = &dst.finalize(state, sink).clone();
             let default_rex = RexFlags::clear_w();
             let default_opcode = 0xC7;
             let bytes = size.to_bytes();
@@ -872,8 +867,8 @@ pub(crate) fn emit(
         }
 
         Inst::MovRR { size, src, dst } => {
-            let src = allocs.next(src.to_reg());
-            let dst = allocs.next(dst.to_reg().to_reg());
+            let src = src.to_reg();
+            let dst = dst.to_reg().to_reg();
             emit_std_reg_reg(
                 sink,
                 LegacyPrefixes::None,
@@ -886,29 +881,26 @@ pub(crate) fn emit(
         }
 
         Inst::MovFromPReg { src, dst } => {
-            allocs.next_fixed_nonallocatable(*src);
             let src: Reg = (*src).into();
             debug_assert!([regs::rsp(), regs::rbp(), regs::pinned_reg()].contains(&src));
-            let src = Gpr::new(src).unwrap();
+            let src = Gpr::unwrap_new(src);
             let size = OperandSize::Size64;
-            let dst = allocs.next(dst.to_reg().to_reg());
-            let dst = WritableGpr::from_writable_reg(Writable::from_reg(dst)).unwrap();
-            Inst::MovRR { size, src, dst }.emit(&[], sink, info, state);
+            let dst = WritableGpr::from_writable_reg(dst.to_writable_reg()).unwrap();
+            Inst::MovRR { size, src, dst }.emit(sink, info, state);
         }
 
         Inst::MovToPReg { src, dst } => {
-            let src = allocs.next(src.to_reg());
-            let src = Gpr::new(src).unwrap();
-            allocs.next_fixed_nonallocatable(*dst);
+            let src = src.to_reg();
+            let src = Gpr::unwrap_new(src);
             let dst: Reg = (*dst).into();
             debug_assert!([regs::rsp(), regs::rbp(), regs::pinned_reg()].contains(&dst));
             let dst = WritableGpr::from_writable_reg(Writable::from_reg(dst)).unwrap();
             let size = OperandSize::Size64;
-            Inst::MovRR { size, src, dst }.emit(&[], sink, info, state);
+            Inst::MovRR { size, src, dst }.emit(sink, info, state);
         }
 
         Inst::MovzxRmR { ext_mode, src, dst } => {
-            let dst = allocs.next(dst.to_reg().to_reg());
+            let dst = dst.to_reg().to_reg();
             let (opcodes, num_opcodes, mut rex_flags) = match ext_mode {
                 ExtMode::BL => {
                     // MOVZBL is (REX.W==0) 0F B6 /r
@@ -942,7 +934,6 @@ pub(crate) fn emit(
 
             match src.clone().to_reg_mem() {
                 RegMem::Reg { reg: src } => {
-                    let src = allocs.next(src);
                     match ext_mode {
                         ExtMode::BL | ExtMode::BQ => {
                             // A redundant REX prefix must be emitted for certain register inputs.
@@ -962,7 +953,7 @@ pub(crate) fn emit(
                 }
 
                 RegMem::Mem { addr: src } => {
-                    let src = &src.finalize(state, sink).with_allocs(allocs);
+                    let src = &src.finalize(state, sink).clone();
 
                     emit_std_reg_mem(
                         sink,
@@ -979,8 +970,8 @@ pub(crate) fn emit(
         }
 
         Inst::Mov64MR { src, dst } => {
-            let dst = allocs.next(dst.to_reg().to_reg());
-            let src = &src.finalize(state, sink).with_allocs(allocs);
+            let dst = dst.to_reg().to_reg();
+            let src = &src.finalize(state, sink).clone();
 
             emit_std_reg_mem(
                 sink,
@@ -995,8 +986,8 @@ pub(crate) fn emit(
         }
 
         Inst::LoadEffectiveAddress { addr, dst, size } => {
-            let dst = allocs.next(dst.to_reg().to_reg());
-            let amode = addr.finalize(state, sink).with_allocs(allocs);
+            let dst = dst.to_reg().to_reg();
+            let amode = addr.finalize(state, sink).clone();
 
             // If this `lea` can actually get encoded as an `add` then do that
             // instead. Currently all candidate `iadd`s become an `lea`
@@ -1030,7 +1021,7 @@ pub(crate) fn emit(
                         RegMemImm::imm(simm32 as u32),
                         Writable::from_reg(dst),
                     );
-                    inst.emit(&[], sink, info, state);
+                    inst.emit(sink, info, state);
                 }
                 // If the offset is 0 and the shift is 0 (meaning multiplication
                 // by 1) then:
@@ -1057,7 +1048,7 @@ pub(crate) fn emit(
                         RegMemImm::reg(operand.to_reg()),
                         Writable::from_reg(dst.to_reg()),
                     );
-                    inst.emit(&[], sink, info, state);
+                    inst.emit(sink, info, state);
                 }
 
                 // If `lea`'s 3-operand mode is leveraged by regalloc, or if
@@ -1075,7 +1066,7 @@ pub(crate) fn emit(
         }
 
         Inst::MovsxRmR { ext_mode, src, dst } => {
-            let dst = allocs.next(dst.to_reg().to_reg());
+            let dst = dst.to_reg().to_reg();
             let (opcodes, num_opcodes, mut rex_flags) = match ext_mode {
                 ExtMode::BL => {
                     // MOVSBL is (REX.W==0) 0F BE /r
@@ -1101,7 +1092,6 @@ pub(crate) fn emit(
 
             match src.clone().to_reg_mem() {
                 RegMem::Reg { reg: src } => {
-                    let src = allocs.next(src);
                     match ext_mode {
                         ExtMode::BL | ExtMode::BQ => {
                             // A redundant REX prefix must be emitted for certain register inputs.
@@ -1121,7 +1111,7 @@ pub(crate) fn emit(
                 }
 
                 RegMem::Mem { addr: src } => {
-                    let src = &src.finalize(state, sink).with_allocs(allocs);
+                    let src = &src.finalize(state, sink).clone();
 
                     emit_std_reg_mem(
                         sink,
@@ -1138,8 +1128,8 @@ pub(crate) fn emit(
         }
 
         Inst::MovRM { size, src, dst } => {
-            let src = allocs.next(src.to_reg());
-            let dst = &dst.finalize(state, sink).with_allocs(allocs);
+            let src = src.to_reg();
+            let dst = &dst.finalize(state, sink).clone();
 
             let prefix = match size {
                 OperandSize::Size16 => LegacyPrefixes::_66,
@@ -1170,8 +1160,8 @@ pub(crate) fn emit(
             num_bits,
             dst,
         } => {
-            let src = allocs.next(src.to_reg());
-            let dst = allocs.next(dst.to_reg().to_reg());
+            let src = src.to_reg();
+            let dst = dst.to_reg().to_reg();
             debug_assert_eq!(src, dst);
             let subopcode = match kind {
                 ShiftKind::RotateLeft => 0,
@@ -1182,9 +1172,8 @@ pub(crate) fn emit(
             };
             let enc_dst = int_reg_enc(dst);
             let rex_flags = RexFlags::from((*size, dst));
-            match num_bits.clone().to_imm8_reg() {
-                Imm8Reg::Reg { reg } => {
-                    let reg = allocs.next(reg);
+            match num_bits.as_imm8_reg() {
+                &Imm8Reg::Reg { reg } => {
                     debug_assert_eq!(reg, regs::rcx());
                     let (opcode, prefix) = match size {
                         OperandSize::Size8 => (0xD2, LegacyPrefixes::None),
@@ -1200,7 +1189,7 @@ pub(crate) fn emit(
                     emit_std_enc_enc(sink, prefix, opcode, 1, subopcode, enc_dst, rex_flags);
                 }
 
-                Imm8Reg::Imm8 { imm: num_bits } => {
+                &Imm8Reg::Imm8 { imm: num_bits } => {
                     let (opcode, prefix) = match size {
                         OperandSize::Size8 => (0xC0, LegacyPrefixes::None),
                         OperandSize::Size16 => (0xC1, LegacyPrefixes::_66),
@@ -1226,8 +1215,8 @@ pub(crate) fn emit(
             src2,
             dst,
         } => {
-            let src1 = allocs.next(src1.to_reg());
-            let dst = allocs.next(dst.to_reg().to_reg());
+            let src1 = src1.to_reg();
+            let dst = dst.to_reg().to_reg();
             debug_assert_eq!(src1, dst);
             let rex = RexFlags::clear_w();
             let prefix = LegacyPrefixes::_66;
@@ -1242,7 +1231,7 @@ pub(crate) fn emit(
                     SseOpcode::Psrlw => (0x0F71, 2),
                     SseOpcode::Psrld => (0x0F72, 2),
                     SseOpcode::Psrlq => (0x0F73, 2),
-                    _ => panic!("invalid opcode: {}", opcode),
+                    _ => panic!("invalid opcode: {opcode}"),
                 };
                 let dst_enc = reg_enc(dst);
                 emit_std_enc_enc(sink, prefix, opcode_bytes, 2, reg_digit, dst_enc, rex);
@@ -1260,16 +1249,15 @@ pub(crate) fn emit(
                     SseOpcode::Psrlw => 0x0FD1,
                     SseOpcode::Psrld => 0x0FD2,
                     SseOpcode::Psrlq => 0x0FD3,
-                    _ => panic!("invalid opcode: {}", opcode),
+                    _ => panic!("invalid opcode: {opcode}"),
                 };
 
                 match src2 {
                     RegMemImm::Reg { reg } => {
-                        let reg = allocs.next(reg);
                         emit_std_reg_reg(sink, prefix, opcode_bytes, 2, dst, reg, rex);
                     }
                     RegMemImm::Mem { addr } => {
-                        let addr = &addr.finalize(state, sink).with_allocs(allocs);
+                        let addr = &addr.finalize(state, sink).clone();
                         emit_std_reg_mem(sink, prefix, opcode_bytes, 2, dst, addr, rex, 0);
                     }
                     RegMemImm::Imm { .. } => unreachable!(),
@@ -1279,11 +1267,11 @@ pub(crate) fn emit(
 
         Inst::CmpRmiR {
             size,
-            src: src_e,
-            dst: reg_g,
+            src1: reg_g,
+            src2: src_e,
             opcode,
         } => {
-            let reg_g = allocs.next(reg_g.to_reg());
+            let reg_g = reg_g.to_reg();
 
             let is_cmp = match opcode {
                 CmpOpcode::Cmp => true,
@@ -1299,7 +1287,6 @@ pub(crate) fn emit(
 
             match src_e.clone().to_reg_mem_imm() {
                 RegMemImm::Reg { reg: reg_e } => {
-                    let reg_e = allocs.next(reg_e);
                     if *size == OperandSize::Size8 {
                         // Check whether the E register forces the use of a redundant REX.
                         rex.always_emit_if_8bit_needed(reg_e);
@@ -1317,7 +1304,7 @@ pub(crate) fn emit(
                 }
 
                 RegMemImm::Mem { addr } => {
-                    let addr = &addr.finalize(state, sink).with_allocs(allocs);
+                    let addr = &addr.finalize(state, sink).clone();
                     // Whereas here we revert to the "normal" G-E ordering for CMP.
                     let opcode = match (*size, is_cmp) {
                         (OperandSize::Size8, true) => 0x3A,
@@ -1359,7 +1346,7 @@ pub(crate) fn emit(
         }
 
         Inst::Setcc { cc, dst } => {
-            let dst = allocs.next(dst.to_reg().to_reg());
+            let dst = dst.to_reg().to_reg();
             let opcode = 0x0f90 + cc.get_enc() as u32;
             let mut rex_flags = RexFlags::clear_w();
             rex_flags.always_emit();
@@ -1375,8 +1362,8 @@ pub(crate) fn emit(
         }
 
         Inst::Bswap { size, src, dst } => {
-            let src = allocs.next(src.to_reg());
-            let dst = allocs.next(dst.to_reg().to_reg());
+            let src = src.to_reg();
+            let dst = dst.to_reg().to_reg();
             debug_assert_eq!(src, dst);
             let enc_reg = int_reg_enc(dst);
 
@@ -1396,8 +1383,8 @@ pub(crate) fn emit(
             alternative,
             dst,
         } => {
-            let alternative = allocs.next(alternative.to_reg());
-            let dst = allocs.next(dst.to_reg().to_reg());
+            let alternative = alternative.to_reg();
+            let dst = dst.to_reg().to_reg();
             debug_assert_eq!(alternative, dst);
             let rex_flags = RexFlags::from(*size);
             let prefix = match size {
@@ -1409,11 +1396,10 @@ pub(crate) fn emit(
             let opcode = 0x0F40 + cc.get_enc() as u32;
             match consequent.clone().to_reg_mem() {
                 RegMem::Reg { reg } => {
-                    let reg = allocs.next(reg);
                     emit_std_reg_reg(sink, prefix, opcode, 2, dst, reg, rex_flags);
                 }
                 RegMem::Mem { addr } => {
-                    let addr = &addr.finalize(state, sink).with_allocs(allocs);
+                    let addr = &addr.finalize(state, sink).clone();
                     emit_std_reg_mem(sink, prefix, opcode, 2, dst, addr, rex_flags, 0);
                 }
             }
@@ -1426,10 +1412,10 @@ pub(crate) fn emit(
             alternative,
             dst,
         } => {
-            let alternative = allocs.next(alternative.to_reg());
-            let dst = allocs.next(dst.to_reg().to_reg());
-            debug_assert_eq!(alternative, dst);
-            let consequent = consequent.clone().to_reg_mem().with_allocs(allocs);
+            let alternative = alternative.to_reg();
+            let dst = dst.to_writable_reg();
+            debug_assert_eq!(alternative, dst.to_reg());
+            let consequent = consequent.to_reg();
 
             // Lowering of the Select IR opcode when the input is an fcmp relies on the fact that
             // this doesn't clobber flags. Make sure to not do so here.
@@ -1441,21 +1427,22 @@ pub(crate) fn emit(
             let op = match *ty {
                 types::F64 => SseOpcode::Movsd,
                 types::F32 => SseOpcode::Movsd,
+                types::F16 => SseOpcode::Movsd,
                 types::F32X4 => SseOpcode::Movaps,
                 types::F64X2 => SseOpcode::Movapd,
                 ty => {
-                    debug_assert!(ty.is_vector() && ty.bytes() == 16);
+                    debug_assert!((ty.is_float() || ty.is_vector()) && ty.bytes() == 16);
                     SseOpcode::Movdqa
                 }
             };
-            let inst = Inst::xmm_unary_rm_r(op, consequent, Writable::from_reg(dst));
-            inst.emit(&[], sink, info, state);
+            let inst = Inst::xmm_unary_rm_r(op, consequent.into(), dst);
+            inst.emit(sink, info, state);
 
             sink.bind_label(next, state.ctrl_plane_mut());
         }
 
         Inst::Push64 { src } => {
-            let src = src.clone().to_reg_mem_imm().with_allocs(allocs);
+            let src = src.clone().to_reg_mem_imm().clone();
 
             match src {
                 RegMemImm::Reg { reg } => {
@@ -1494,7 +1481,7 @@ pub(crate) fn emit(
         }
 
         Inst::Pop64 { dst } => {
-            let dst = allocs.next(dst.to_reg().to_reg());
+            let dst = dst.to_reg().to_reg();
             let enc_dst = int_reg_enc(dst);
             if enc_dst >= 8 {
                 // 0x41 == REX.{W=0, B=1}.  It seems that REX.W is irrelevant here.
@@ -1511,7 +1498,7 @@ pub(crate) fn emit(
             assert!(info.flags.enable_probestack());
             assert!(guard_size.is_power_of_two());
 
-            let tmp = allocs.next_writable(*tmp);
+            let tmp = *tmp;
 
             // Number of probes that we need to perform
             let probe_count = align_to(*frame_size, *guard_size) / guard_size;
@@ -1542,7 +1529,7 @@ pub(crate) fn emit(
             // Create the guard bound register
             // mov  tmp_reg, rsp
             let inst = Inst::gen_move(tmp, regs::rsp(), types::I64);
-            inst.emit(&[], sink, info, state);
+            inst.emit(sink, info, state);
 
             // sub  tmp_reg, GUARD_SIZE * probe_count
             let inst = Inst::alu_rmi_r(
@@ -1551,7 +1538,7 @@ pub(crate) fn emit(
                 RegMemImm::imm(guard_size * probe_count),
                 tmp,
             );
-            inst.emit(&[], sink, info, state);
+            inst.emit(sink, info, state);
 
             // Emit the main loop!
             let loop_start = sink.get_label();
@@ -1564,7 +1551,7 @@ pub(crate) fn emit(
                 RegMemImm::imm(*guard_size),
                 Writable::from_reg(regs::rsp()),
             );
-            inst.emit(&[], sink, info, state);
+            inst.emit(sink, info, state);
 
             // TODO: `mov [rsp], 0` would be better, but we don't have that instruction
             // Probe the stack! We don't use Inst::gen_store_stack here because we need a predictable
@@ -1575,16 +1562,16 @@ pub(crate) fn emit(
                 regs::rsp(),
                 SyntheticAmode::Real(Amode::imm_reg(0, regs::rsp())),
             );
-            inst.emit(&[], sink, info, state);
+            inst.emit(sink, info, state);
 
             // Compare and jump if we are not done yet
             // cmp  rsp, tmp_reg
             let inst = Inst::cmp_rmi_r(
                 OperandSize::Size64,
-                RegMemImm::reg(regs::rsp()),
                 tmp.to_reg(),
+                RegMemImm::reg(regs::rsp()),
             );
-            inst.emit(&[], sink, info, state);
+            inst.emit(sink, info, state);
 
             // jne  .loop_start
             // TODO: Encoding the JmpIf as a short jump saves us 4 bytes here.
@@ -1603,7 +1590,7 @@ pub(crate) fn emit(
                 RegMemImm::imm(guard_size * probe_count),
                 Writable::from_reg(regs::rsp()),
             );
-            inst.emit(&[], sink, info, state);
+            inst.emit(sink, info, state);
         }
 
         Inst::CallKnown {
@@ -1612,37 +1599,37 @@ pub(crate) fn emit(
             ..
         } => {
             if let Some(s) = state.take_stack_map() {
-                sink.add_stack_map(StackMapExtent::UpcomingBytes(5), s);
+                let offset = sink.cur_offset() + 5;
+                sink.push_user_stack_map(state, offset, s);
             }
+
             sink.put1(0xE8);
             // The addend adjusts for the difference between the end of the instruction and the
             // beginning of the immediate field.
             emit_reloc(sink, Reloc::X86CallPCRel4, &dest, -4);
             sink.put4(0);
-            if call_info.opcode.is_call() {
-                sink.add_call_site(call_info.opcode);
-            }
+            sink.add_call_site();
 
-            let callee_pop_size = i64::from(call_info.callee_pop_size);
-            state.adjust_virtual_sp_offset(-callee_pop_size);
+            // Reclaim the outgoing argument area that was released by the callee, to ensure that
+            // StackAMode values are always computed from a consistent SP.
+            if let Some(call_info) = call_info {
+                if call_info.callee_pop_size > 0 {
+                    Inst::alu_rmi_r(
+                        OperandSize::Size64,
+                        AluRmiROpcode::Sub,
+                        RegMemImm::imm(call_info.callee_pop_size),
+                        Writable::from_reg(regs::rsp()),
+                    )
+                    .emit(sink, info, state);
+                }
+            }
         }
 
         Inst::ReturnCallKnown {
             callee,
             info: call_info,
         } => {
-            emit_return_call_common_sequence(
-                allocs,
-                sink,
-                info,
-                state,
-                call_info.new_stack_arg_size,
-                call_info.old_stack_arg_size,
-                call_info.ret_addr,
-                call_info.fp,
-                call_info.tmp,
-                &call_info.uses,
-            );
+            emit_return_call_common_sequence(sink, info, state, &call_info);
 
             // Finally, jump to the callee!
             //
@@ -1654,30 +1641,22 @@ pub(crate) fn emit(
             // beginning of the immediate field.
             emit_reloc(sink, Reloc::X86CallPCRel4, &callee, -4);
             sink.put4(0);
-            sink.add_call_site(ir::Opcode::ReturnCall);
+            sink.add_call_site();
         }
 
         Inst::ReturnCallUnknown {
             callee,
             info: call_info,
         } => {
-            let callee = callee.with_allocs(allocs);
+            let callee = *callee;
 
-            emit_return_call_common_sequence(
-                allocs,
-                sink,
-                info,
-                state,
-                call_info.new_stack_arg_size,
-                call_info.old_stack_arg_size,
-                call_info.ret_addr,
-                call_info.fp,
-                call_info.tmp,
-                &call_info.uses,
-            );
+            emit_return_call_common_sequence(sink, info, state, &call_info);
 
-            Inst::JmpUnknown { target: callee }.emit(&[], sink, info, state);
-            sink.add_call_site(ir::Opcode::ReturnCallIndirect);
+            Inst::JmpUnknown {
+                target: RegMem::reg(callee),
+            }
+            .emit(sink, info, state);
+            sink.add_call_site();
         }
 
         Inst::CallUnknown {
@@ -1685,9 +1664,8 @@ pub(crate) fn emit(
             info: call_info,
             ..
         } => {
-            let dest = dest.with_allocs(allocs);
+            let dest = dest.clone();
 
-            let start_offset = sink.cur_offset();
             match dest {
                 RegMem::Reg { reg } => {
                     let reg_enc = int_reg_enc(reg);
@@ -1716,15 +1694,27 @@ pub(crate) fn emit(
                     );
                 }
             }
+
             if let Some(s) = state.take_stack_map() {
-                sink.add_stack_map(StackMapExtent::StartedAtOffset(start_offset), s);
-            }
-            if call_info.opcode.is_call() {
-                sink.add_call_site(call_info.opcode);
+                let offset = sink.cur_offset();
+                sink.push_user_stack_map(state, offset, s);
             }
 
-            let callee_pop_size = i64::from(call_info.callee_pop_size);
-            state.adjust_virtual_sp_offset(-callee_pop_size);
+            sink.add_call_site();
+
+            // Reclaim the outgoing argument area that was released by the callee, to ensure that
+            // StackAMode values are always computed from a consistent SP.
+            if let Some(call_info) = call_info {
+                if call_info.callee_pop_size > 0 {
+                    Inst::alu_rmi_r(
+                        OperandSize::Size64,
+                        AluRmiROpcode::Sub,
+                        RegMemImm::imm(call_info.callee_pop_size),
+                        Writable::from_reg(regs::rsp()),
+                    )
+                    .emit(sink, info, state);
+                }
+            }
         }
 
         Inst::Args { .. } => {}
@@ -1739,6 +1729,123 @@ pub(crate) fn emit(
             sink.put2(u16::try_from(*stack_bytes_to_pop).unwrap());
         }
 
+        Inst::StackSwitchBasic {
+            store_context_ptr,
+            load_context_ptr,
+            in_payload0,
+            out_payload0,
+        } => {
+            // Note that we do not emit anything for preserving and restoring
+            // ordinary registers here: That's taken care of by regalloc for us,
+            // since we marked this instruction as clobbering all registers.
+            //
+            // Also note that we do nothing about passing the single payload
+            // value: We've informed regalloc that it is sent and received via
+            // the fixed register given by [stack_switch::payload_register]
+
+            let (tmp1, tmp2) = {
+                // Ideally we would just ask regalloc for two temporary registers.
+                // However, adding any early defs to the constraints on StackSwitch
+                // causes TooManyLiveRegs. Fortunately, we can manually find tmp
+                // registers without regalloc: Since our instruction clobbers all
+                // registers, we can simply pick any register that is not assigned
+                // to the operands.
+
+                let all = crate::isa::x64::abi::ALL_CLOBBERS;
+
+                let used_regs = [
+                    **load_context_ptr,
+                    **store_context_ptr,
+                    **in_payload0,
+                    *out_payload0.to_reg(),
+                ];
+
+                let mut tmps = all.into_iter().filter_map(|preg| {
+                    let reg: Reg = preg.into();
+                    if !used_regs.contains(&reg) {
+                        WritableGpr::from_writable_reg(isle::WritableReg::from_reg(reg))
+                    } else {
+                        None
+                    }
+                });
+                (tmps.next().unwrap(), tmps.next().unwrap())
+            };
+
+            let layout = stack_switch::control_context_layout();
+            let rsp_offset = layout.stack_pointer_offset as i32;
+            let pc_offset = layout.ip_offset as i32;
+            let rbp_offset = layout.frame_pointer_offset as i32;
+
+            // Location to which someone switch-ing back to this stack will jump
+            // to: Right behind the `StackSwitch` instruction
+            let resume = sink.get_label();
+
+            //
+            // For RBP and RSP we do the following:
+            // - Load new value for register from `load_context_ptr` +
+            // corresponding offset.
+            // - Store previous (!) value of register at `store_context_ptr` +
+            // corresponding offset.
+            //
+            // Since `load_context_ptr` and `store_context_ptr` are allowed to be
+            // equal, we need to use a temporary register here.
+            //
+
+            let mut exchange = |offset, reg| {
+                let inst = Inst::Mov64MR {
+                    src: Amode::imm_reg(offset, **load_context_ptr).into(),
+                    dst: tmp1,
+                };
+                emit(&inst, sink, info, state);
+
+                let inst = Inst::MovRM {
+                    size: OperandSize::Size64,
+                    src: Gpr::new(reg).unwrap(),
+                    dst: Amode::imm_reg(offset, **store_context_ptr).into(),
+                };
+                emit(&inst, sink, info, state);
+
+                let dst = Writable::from_reg(reg.into());
+                let inst = Inst::MovRR {
+                    size: OperandSize::Size64,
+                    src: tmp1.to_reg(),
+                    dst: WritableGpr::from_writable_reg(dst.into()).unwrap(),
+                };
+                emit(&inst, sink, info, state);
+            };
+
+            exchange(rsp_offset, regs::rsp());
+            exchange(rbp_offset, regs::rbp());
+
+            //
+            // Load target PC, store resume PC, jump to target PC
+            //
+
+            let inst = Inst::Mov64MR {
+                src: Amode::imm_reg(pc_offset, **load_context_ptr).into(),
+                dst: tmp1,
+            };
+            emit(&inst, sink, info, state);
+
+            let amode = Amode::RipRelative { target: resume };
+            let inst = Inst::lea(amode, tmp2.map(Reg::from));
+            inst.emit(sink, info, state);
+
+            let inst = Inst::MovRM {
+                size: OperandSize::Size64,
+                src: tmp2.to_reg(),
+                dst: Amode::imm_reg(pc_offset, **store_context_ptr).into(),
+            };
+            emit(&inst, sink, info, state);
+
+            let inst = Inst::JmpUnknown {
+                target: RegMem::reg(tmp1.to_reg().into()),
+            };
+            emit(&inst, sink, info, state);
+
+            sink.bind_label(resume, state.ctrl_plane_mut());
+        }
+
         Inst::JmpKnown { dst } => {
             let br_start = sink.cur_offset();
             let br_disp_off = br_start + 1;
@@ -1798,7 +1905,7 @@ pub(crate) fn emit(
         }
 
         Inst::JmpUnknown { target } => {
-            let target = target.with_allocs(allocs);
+            let target = target.clone();
 
             match target {
                 RegMem::Reg { reg } => {
@@ -1830,18 +1937,14 @@ pub(crate) fn emit(
             }
         }
 
-        Inst::JmpTableSeq {
+        &Inst::JmpTableSeq {
             idx,
             tmp1,
             tmp2,
             ref targets,
-            default_target,
+            ref default_target,
             ..
         } => {
-            let idx = allocs.next(*idx);
-            let tmp1 = Writable::from_reg(allocs.next(tmp1.to_reg()));
-            let tmp2 = Writable::from_reg(allocs.next(tmp2.to_reg()));
-
             // This sequence is *one* instruction in the vcode, and is expanded only here at
             // emission time, because we cannot allow the regalloc to insert spills/reloads in
             // the middle; we depend on hardcoded PC-rel addressing below.
@@ -1863,7 +1966,7 @@ pub(crate) fn emit(
             // Load base address of jump table.
             let start_of_jumptable = sink.get_label();
             let inst = Inst::lea(Amode::rip_relative(start_of_jumptable), tmp1);
-            inst.emit(&[], sink, info, state);
+            inst.emit(sink, info, state);
 
             // Load value out of the jump table. It's a relative offset to the target block, so it
             // might be negative; use a sign-extension.
@@ -1871,13 +1974,13 @@ pub(crate) fn emit(
                 ExtMode::LQ,
                 RegMem::mem(Amode::imm_reg_reg_shift(
                     0,
-                    Gpr::new(tmp1.to_reg()).unwrap(),
-                    Gpr::new(idx).unwrap(),
+                    Gpr::unwrap_new(tmp1.to_reg()),
+                    Gpr::unwrap_new(idx),
                     2,
                 )),
                 tmp2,
             );
-            inst.emit(&[], sink, info, state);
+            inst.emit(sink, info, state);
 
             // Add base of jump table to jump-table-sourced block offset.
             let inst = Inst::alu_rmi_r(
@@ -1886,11 +1989,11 @@ pub(crate) fn emit(
                 RegMemImm::reg(tmp2.to_reg()),
                 tmp1,
             );
-            inst.emit(&[], sink, info, state);
+            inst.emit(sink, info, state);
 
             // Branch to computed address.
             let inst = Inst::jmp_unknown(RegMem::reg(tmp1.to_reg()));
-            inst.emit(&[], sink, info, state);
+            inst.emit(sink, info, state);
 
             // Emit jump table (table of 32-bit offsets).
             sink.bind_label(start_of_jumptable, state.ctrl_plane_mut());
@@ -1908,7 +2011,7 @@ pub(crate) fn emit(
         }
 
         Inst::TrapIf { cc, trap_code } => {
-            let trap_label = sink.defer_trap(*trap_code, state.take_stack_map());
+            let trap_label = sink.defer_trap(*trap_code);
             one_way_jmp(sink, *cc, trap_label);
         }
 
@@ -1917,7 +2020,7 @@ pub(crate) fn emit(
             cc2,
             trap_code,
         } => {
-            let trap_label = sink.defer_trap(*trap_code, state.take_stack_map());
+            let trap_label = sink.defer_trap(*trap_code);
             let else_label = sink.get_label();
 
             // Jump to the end if the first condition isn't true, and then if
@@ -1933,7 +2036,7 @@ pub(crate) fn emit(
             cc2,
             trap_code,
         } => {
-            let trap_label = sink.defer_trap(*trap_code, state.take_stack_map());
+            let trap_label = sink.defer_trap(*trap_code);
 
             // Emit two jumps to the same trap if either condition code is true.
             one_way_jmp(sink, *cc1, trap_label);
@@ -1944,10 +2047,9 @@ pub(crate) fn emit(
             emit(
                 &Inst::XmmUnaryRmRUnaligned {
                     op: *op,
-                    src: XmmMem::new(src.clone().into()).unwrap(),
+                    src: XmmMem::unwrap_new(src.clone().into()),
                     dst: *dst,
                 },
-                allocs,
                 sink,
                 info,
                 state,
@@ -1959,8 +2061,8 @@ pub(crate) fn emit(
             src: src_e,
             dst: reg_g,
         } => {
-            let reg_g = allocs.next(reg_g.to_reg().to_reg());
-            let src_e = src_e.clone().to_reg_mem().with_allocs(allocs);
+            let reg_g = reg_g.to_reg().to_reg();
+            let src_e = src_e.clone().to_reg_mem().clone();
 
             let rex = RexFlags::clear_w();
 
@@ -1969,8 +2071,6 @@ pub(crate) fn emit(
                 SseOpcode::Cvtpd2ps => (LegacyPrefixes::_66, 0x0F5A, 2),
                 SseOpcode::Cvtps2pd => (LegacyPrefixes::None, 0x0F5A, 2),
                 SseOpcode::Cvtdq2ps => (LegacyPrefixes::None, 0x0F5B, 2),
-                SseOpcode::Cvtss2sd => (LegacyPrefixes::_F3, 0x0F5A, 2),
-                SseOpcode::Cvtsd2ss => (LegacyPrefixes::_F2, 0x0F5A, 2),
                 SseOpcode::Cvttpd2dq => (LegacyPrefixes::_66, 0x0FE6, 2),
                 SseOpcode::Cvttps2dq => (LegacyPrefixes::_F3, 0x0F5B, 2),
                 SseOpcode::Movaps => (LegacyPrefixes::None, 0x0F28, 2),
@@ -1998,8 +2098,6 @@ pub(crate) fn emit(
                 SseOpcode::Pmovzxdq => (LegacyPrefixes::_66, 0x0F3835, 3),
                 SseOpcode::Sqrtps => (LegacyPrefixes::None, 0x0F51, 2),
                 SseOpcode::Sqrtpd => (LegacyPrefixes::_66, 0x0F51, 2),
-                SseOpcode::Sqrtss => (LegacyPrefixes::_F3, 0x0F51, 2),
-                SseOpcode::Sqrtsd => (LegacyPrefixes::_F2, 0x0F51, 2),
                 SseOpcode::Movddup => (LegacyPrefixes::_F2, 0x0F12, 2),
                 _ => unimplemented!("Opcode {:?} not implemented", op),
             };
@@ -2016,8 +2114,8 @@ pub(crate) fn emit(
         }
 
         Inst::XmmUnaryRmRImm { op, src, dst, imm } => {
-            let dst = allocs.next(dst.to_reg().to_reg());
-            let src = src.clone().to_reg_mem().with_allocs(allocs);
+            let dst = dst.to_reg().to_reg();
+            let src = src.clone().to_reg_mem().clone();
             let rex = RexFlags::clear_w();
 
             let (prefix, opcode, len) = match op {
@@ -2044,8 +2142,8 @@ pub(crate) fn emit(
         }
 
         Inst::XmmUnaryRmREvex { op, src, dst } => {
-            let dst = allocs.next(dst.to_reg().to_reg());
-            let src = match src.clone().to_reg_mem().with_allocs(allocs) {
+            let dst = dst.to_reg().to_reg();
+            let src = match src.clone().to_reg_mem().clone() {
                 RegMem::Reg { reg } => {
                     RegisterOrAmode::Register(reg.to_real_reg().unwrap().hw_enc().into())
                 }
@@ -2071,8 +2169,8 @@ pub(crate) fn emit(
         }
 
         Inst::XmmUnaryRmRImmEvex { op, src, dst, imm } => {
-            let dst = allocs.next(dst.to_reg().to_reg());
-            let src = match src.clone().to_reg_mem().with_allocs(allocs) {
+            let dst = dst.to_reg().to_reg();
+            let src = match src.clone().to_reg_mem().clone() {
                 RegMem::Reg { reg } => {
                     RegisterOrAmode::Register(reg.to_real_reg().unwrap().hw_enc().into())
                 }
@@ -2107,9 +2205,8 @@ pub(crate) fn emit(
                 op: *op,
                 dst: *dst,
                 src1: *src1,
-                src2: XmmMem::new(src2.clone().to_reg_mem()).unwrap(),
+                src2: XmmMem::unwrap_new(src2.clone().to_reg_mem()),
             },
-            allocs,
             sink,
             info,
             state,
@@ -2121,9 +2218,9 @@ pub(crate) fn emit(
             src2: src_e,
             dst: reg_g,
         } => {
-            let src1 = allocs.next(src1.to_reg());
-            let reg_g = allocs.next(reg_g.to_reg().to_reg());
-            let src_e = src_e.clone().to_reg_mem().with_allocs(allocs);
+            let src1 = src1.to_reg();
+            let reg_g = reg_g.to_reg().to_reg();
+            let src_e = src_e.clone().to_reg_mem().clone();
             debug_assert_eq!(src1, reg_g);
 
             let rex = RexFlags::clear_w();
@@ -2231,6 +2328,11 @@ pub(crate) fn emit(
                 SseOpcode::Phaddw => (LegacyPrefixes::_66, 0x0F3801, 3),
                 SseOpcode::Phaddd => (LegacyPrefixes::_66, 0x0F3802, 3),
                 SseOpcode::Movss => (LegacyPrefixes::_F3, 0x0F10, 2),
+                SseOpcode::Cvtss2sd => (LegacyPrefixes::_F3, 0x0F5A, 2),
+                SseOpcode::Cvtsd2ss => (LegacyPrefixes::_F2, 0x0F5A, 2),
+                SseOpcode::Sqrtss => (LegacyPrefixes::_F3, 0x0F51, 2),
+                SseOpcode::Sqrtsd => (LegacyPrefixes::_F2, 0x0F51, 2),
+                SseOpcode::Unpcklpd => (LegacyPrefixes::_66, 0x0F14, 2),
                 _ => unimplemented!("Opcode {:?} not implemented", op),
             };
 
@@ -2252,12 +2354,12 @@ pub(crate) fn emit(
             dst,
             mask,
         } => {
-            let src1 = allocs.next(src1.to_reg());
-            let mask = allocs.next(mask.to_reg());
+            let src1 = src1.to_reg();
+            let mask = mask.to_reg();
             debug_assert_eq!(mask, regs::xmm0());
-            let reg_g = allocs.next(dst.to_reg().to_reg());
+            let reg_g = dst.to_reg().to_reg();
             debug_assert_eq!(src1, reg_g);
-            let src_e = src2.clone().to_reg_mem().with_allocs(allocs);
+            let src_e = src2.clone().to_reg_mem().clone();
 
             let rex = RexFlags::clear_w();
             let (prefix, opcode, length) = match op {
@@ -2287,9 +2389,9 @@ pub(crate) fn emit(
             use LegacyPrefixes as LP;
             use OpcodeMap as OM;
 
-            let dst = allocs.next(dst.to_reg().to_reg());
-            let src1 = allocs.next(src1.to_reg());
-            let src2 = src2.clone().to_reg_mem_imm().with_allocs(allocs);
+            let dst = dst.to_reg().to_reg();
+            let src1 = src1.to_reg();
+            let src2 = src2.clone().to_reg_mem_imm().clone();
 
             // When the opcode is commutative, src1 is xmm{0..7}, and src2 is
             // xmm{8..15}, then we can swap the operands to save one byte on the
@@ -2452,6 +2554,11 @@ pub(crate) fn emit(
                 AvxOpcode::Vpunpckhqdq => (LP::_66, OM::_0F, 0x6D),
                 AvxOpcode::Vmovsd => (LP::_F2, OM::_0F, 0x10),
                 AvxOpcode::Vmovss => (LP::_F3, OM::_0F, 0x10),
+                AvxOpcode::Vcvtss2sd => (LP::_F3, OM::_0F, 0x5A),
+                AvxOpcode::Vcvtsd2ss => (LP::_F2, OM::_0F, 0x5A),
+                AvxOpcode::Vsqrtss => (LP::_F3, OM::_0F, 0x51),
+                AvxOpcode::Vsqrtsd => (LP::_F2, OM::_0F, 0x51),
+                AvxOpcode::Vunpcklpd => (LP::_66, OM::_0F, 0x14),
                 _ => panic!("unexpected rmir vex opcode {op:?}"),
             };
             VexInstruction::new()
@@ -2472,9 +2579,9 @@ pub(crate) fn emit(
             dst,
             imm,
         } => {
-            let dst = allocs.next(dst.to_reg().to_reg());
-            let src1 = allocs.next(src1.to_reg());
-            let src2 = match src2.clone().to_reg_mem().with_allocs(allocs) {
+            let dst = dst.to_reg().to_reg();
+            let src1 = src1.to_reg();
+            let src2 = match src2.clone().to_reg_mem().clone() {
                 RegMem::Reg { reg } => {
                     RegisterOrAmode::Register(reg.to_real_reg().unwrap().hw_enc().into())
                 }
@@ -2511,9 +2618,9 @@ pub(crate) fn emit(
             dst,
             imm,
         } => {
-            let dst = allocs.next(dst.to_reg().to_reg());
-            let src1 = allocs.next(src1.to_reg());
-            let src2 = match src2.clone().to_reg_mem().with_allocs(allocs) {
+            let dst = dst.to_reg().to_reg();
+            let src1 = src1.to_reg();
+            let src2 = match src2.clone().to_reg_mem().clone() {
                 RegMem::Reg { reg } => {
                     RegisterOrAmode::Register(reg.to_real_reg().unwrap().hw_enc().into())
                 }
@@ -2548,11 +2655,11 @@ pub(crate) fn emit(
             src3,
             dst,
         } => {
-            let src1 = allocs.next(src1.to_reg());
-            let dst = allocs.next(dst.to_reg().to_reg());
+            let src1 = src1.to_reg();
+            let dst = dst.to_reg().to_reg();
             debug_assert_eq!(src1, dst);
-            let src2 = allocs.next(src2.to_reg());
-            let src3 = match src3.clone().to_reg_mem().with_allocs(allocs) {
+            let src2 = src2.to_reg();
+            let src3 = match src3.clone().to_reg_mem().clone() {
                 RegMem::Reg { reg } => {
                     RegisterOrAmode::Register(reg.to_real_reg().unwrap().hw_enc().into())
                 }
@@ -2576,6 +2683,22 @@ pub(crate) fn emit(
                 AvxOpcode::Vfmadd213pd => (true, OpcodeMap::_0F38, 0xA8),
                 AvxOpcode::Vfnmadd132pd => (true, OpcodeMap::_0F38, 0x9C),
                 AvxOpcode::Vfnmadd213pd => (true, OpcodeMap::_0F38, 0xAC),
+                AvxOpcode::Vfmsub132ss => (false, OpcodeMap::_0F38, 0x9B),
+                AvxOpcode::Vfmsub213ss => (false, OpcodeMap::_0F38, 0xAB),
+                AvxOpcode::Vfnmsub132ss => (false, OpcodeMap::_0F38, 0x9F),
+                AvxOpcode::Vfnmsub213ss => (false, OpcodeMap::_0F38, 0xAF),
+                AvxOpcode::Vfmsub132sd => (true, OpcodeMap::_0F38, 0x9B),
+                AvxOpcode::Vfmsub213sd => (true, OpcodeMap::_0F38, 0xAB),
+                AvxOpcode::Vfnmsub132sd => (true, OpcodeMap::_0F38, 0x9F),
+                AvxOpcode::Vfnmsub213sd => (true, OpcodeMap::_0F38, 0xAF),
+                AvxOpcode::Vfmsub132ps => (false, OpcodeMap::_0F38, 0x9A),
+                AvxOpcode::Vfmsub213ps => (false, OpcodeMap::_0F38, 0xAA),
+                AvxOpcode::Vfnmsub132ps => (false, OpcodeMap::_0F38, 0x9E),
+                AvxOpcode::Vfnmsub213ps => (false, OpcodeMap::_0F38, 0xAE),
+                AvxOpcode::Vfmsub132pd => (true, OpcodeMap::_0F38, 0x9A),
+                AvxOpcode::Vfmsub213pd => (true, OpcodeMap::_0F38, 0xAA),
+                AvxOpcode::Vfnmsub132pd => (true, OpcodeMap::_0F38, 0x9E),
+                AvxOpcode::Vfnmsub213pd => (true, OpcodeMap::_0F38, 0xAE),
                 AvxOpcode::Vblendvps => (false, OpcodeMap::_0F3A, 0x4A),
                 AvxOpcode::Vblendvpd => (false, OpcodeMap::_0F3A, 0x4B),
                 AvxOpcode::Vpblendvb => (false, OpcodeMap::_0F3A, 0x4C),
@@ -2601,15 +2724,15 @@ pub(crate) fn emit(
             mask,
             dst,
         } => {
-            let dst = allocs.next(dst.to_reg().to_reg());
-            let src1 = allocs.next(src1.to_reg());
-            let src2 = match src2.clone().to_reg_mem().with_allocs(allocs) {
+            let dst = dst.to_reg().to_reg();
+            let src1 = src1.to_reg();
+            let src2 = match src2.clone().to_reg_mem().clone() {
                 RegMem::Reg { reg } => {
                     RegisterOrAmode::Register(reg.to_real_reg().unwrap().hw_enc().into())
                 }
                 RegMem::Mem { addr } => RegisterOrAmode::Amode(addr.finalize(state, sink)),
             };
-            let mask = allocs.next(mask.to_reg());
+            let mask = mask.to_reg();
 
             let opcode = match op {
                 AvxOpcode::Vblendvps => 0x4A,
@@ -2631,8 +2754,8 @@ pub(crate) fn emit(
         }
 
         Inst::XmmUnaryRmRVex { op, src, dst } => {
-            let dst = allocs.next(dst.to_reg().to_reg());
-            let src = match src.clone().to_reg_mem().with_allocs(allocs) {
+            let dst = dst.to_reg().to_reg();
+            let src = match src.clone().to_reg_mem().clone() {
                 RegMem::Reg { reg } => {
                     RegisterOrAmode::Register(reg.to_real_reg().unwrap().hw_enc().into())
                 }
@@ -2681,41 +2804,22 @@ pub(crate) fn emit(
                 AvxOpcode::Vbroadcastss => (LegacyPrefixes::_66, OpcodeMap::_0F38, 0x18),
                 AvxOpcode::Vmovddup => (LegacyPrefixes::_F2, OpcodeMap::_0F, 0x12),
 
-                AvxOpcode::Vcvtss2sd => (LegacyPrefixes::_F3, OpcodeMap::_0F, 0x5A),
-                AvxOpcode::Vcvtsd2ss => (LegacyPrefixes::_F2, OpcodeMap::_0F, 0x5A),
-                AvxOpcode::Vsqrtss => (LegacyPrefixes::_F3, OpcodeMap::_0F, 0x51),
-                AvxOpcode::Vsqrtsd => (LegacyPrefixes::_F2, OpcodeMap::_0F, 0x51),
-
                 _ => panic!("unexpected rmr_imm_vex opcode {op:?}"),
             };
 
-            let vex = VexInstruction::new()
+            VexInstruction::new()
                 .length(VexVectorLength::V128)
                 .prefix(prefix)
                 .map(map)
                 .opcode(opcode)
                 .reg(dst.to_real_reg().unwrap().hw_enc())
-                .rm(src);
-
-            // These opcodes take a second operand through `vvvv` which copies
-            // the upper bits into the destination register. That's not
-            // reflected in the CLIF instruction, however, since the SSE version
-            // doesn't have this functionality. Instead just copy whatever
-            // happens to already be in the destination, which at least is what
-            // LLVM seems to do.
-            let vex = match op {
-                AvxOpcode::Vcvtss2sd
-                | AvxOpcode::Vcvtsd2ss
-                | AvxOpcode::Vsqrtss
-                | AvxOpcode::Vsqrtsd => vex.vvvv(dst.to_real_reg().unwrap().hw_enc()),
-                _ => vex,
-            };
-            vex.encode(sink);
+                .rm(src)
+                .encode(sink);
         }
 
         Inst::XmmUnaryRmRImmVex { op, src, dst, imm } => {
-            let dst = allocs.next(dst.to_reg().to_reg());
-            let src = match src.clone().to_reg_mem().with_allocs(allocs) {
+            let dst = dst.to_reg().to_reg();
+            let src = match src.clone().to_reg_mem().clone() {
                 RegMem::Reg { reg } => {
                     RegisterOrAmode::Register(reg.to_real_reg().unwrap().hw_enc().into())
                 }
@@ -2754,8 +2858,8 @@ pub(crate) fn emit(
         }
 
         Inst::XmmMovRMVex { op, src, dst } => {
-            let src = allocs.next(src.to_reg());
-            let dst = dst.with_allocs(allocs).finalize(state, sink);
+            let src = src.to_reg();
+            let dst = dst.clone().finalize(state, sink);
 
             let (prefix, map, opcode) = match op {
                 AvxOpcode::Vmovdqu => (LegacyPrefixes::_F3, OpcodeMap::_0F, 0x7F),
@@ -2776,8 +2880,8 @@ pub(crate) fn emit(
         }
 
         Inst::XmmMovRMImmVex { op, src, dst, imm } => {
-            let src = allocs.next(src.to_reg());
-            let dst = dst.with_allocs(allocs).finalize(state, sink);
+            let src = src.to_reg();
+            let dst = dst.clone().finalize(state, sink);
 
             let (w, prefix, map, opcode) = match op {
                 AvxOpcode::Vpextrb => (false, LegacyPrefixes::_66, OpcodeMap::_0F3A, 0x14),
@@ -2799,8 +2903,8 @@ pub(crate) fn emit(
         }
 
         Inst::XmmToGprImmVex { op, src, dst, imm } => {
-            let src = allocs.next(src.to_reg());
-            let dst = allocs.next(dst.to_reg().to_reg());
+            let src = src.to_reg();
+            let dst = dst.to_reg().to_reg();
 
             let (w, prefix, map, opcode) = match op {
                 AvxOpcode::Vpextrb => (false, LegacyPrefixes::_66, OpcodeMap::_0F3A, 0x14),
@@ -2827,8 +2931,8 @@ pub(crate) fn emit(
             dst,
             dst_size,
         } => {
-            let src = allocs.next(src.to_reg());
-            let dst = allocs.next(dst.to_reg().to_reg());
+            let src = src.to_reg();
+            let dst = dst.to_reg().to_reg();
 
             let (prefix, map, opcode) = match op {
                 // vmovd/vmovq are differentiated by `w`
@@ -2867,8 +2971,8 @@ pub(crate) fn emit(
             dst,
             src_size,
         } => {
-            let dst = allocs.next(dst.to_reg().to_reg());
-            let src = match src.clone().to_reg_mem().with_allocs(allocs) {
+            let dst = dst.to_reg().to_reg();
+            let src = match src.clone().to_reg_mem().clone() {
                 RegMem::Reg { reg } => {
                     RegisterOrAmode::Register(reg.to_real_reg().unwrap().hw_enc().into())
                 }
@@ -2895,6 +2999,32 @@ pub(crate) fn emit(
                 .encode(sink);
         }
 
+        Inst::XmmCmpRmRVex { op, src1, src2 } => {
+            let src1 = src1.to_reg();
+            let src2 = match src2.clone().to_reg_mem().clone() {
+                RegMem::Reg { reg } => {
+                    RegisterOrAmode::Register(reg.to_real_reg().unwrap().hw_enc().into())
+                }
+                RegMem::Mem { addr } => RegisterOrAmode::Amode(addr.finalize(state, sink)),
+            };
+
+            let (prefix, map, opcode) = match op {
+                AvxOpcode::Vucomiss => (LegacyPrefixes::None, OpcodeMap::_0F, 0x2E),
+                AvxOpcode::Vucomisd => (LegacyPrefixes::_66, OpcodeMap::_0F, 0x2E),
+                AvxOpcode::Vptest => (LegacyPrefixes::_66, OpcodeMap::_0F38, 0x17),
+                _ => unimplemented!("Opcode {:?} not implemented", op),
+            };
+
+            VexInstruction::new()
+                .length(VexVectorLength::V128)
+                .prefix(prefix)
+                .map(map)
+                .opcode(opcode)
+                .rm(src2)
+                .reg(src1.to_real_reg().unwrap().hw_enc())
+                .encode(sink);
+        }
+
         Inst::XmmRmREvex {
             op,
             src1,
@@ -2909,17 +3039,17 @@ pub(crate) fn emit(
             dst,
         } => {
             let reused_src = match inst {
-                Inst::XmmRmREvex3 { src1, .. } => Some(allocs.next(src1.to_reg())),
+                Inst::XmmRmREvex3 { src1, .. } => Some(src1.to_reg()),
                 _ => None,
             };
-            let src1 = allocs.next(src1.to_reg());
-            let src2 = match src2.clone().to_reg_mem().with_allocs(allocs) {
+            let src1 = src1.to_reg();
+            let src2 = match src2.clone().to_reg_mem().clone() {
                 RegMem::Reg { reg } => {
                     RegisterOrAmode::Register(reg.to_real_reg().unwrap().hw_enc().into())
                 }
                 RegMem::Mem { addr } => RegisterOrAmode::Amode(addr.finalize(state, sink)),
             };
-            let dst = allocs.next(dst.to_reg().to_reg());
+            let dst = dst.to_reg().to_reg();
             if let Some(src1) = reused_src {
                 debug_assert_eq!(src1, dst);
             }
@@ -2950,10 +3080,10 @@ pub(crate) fn emit(
             rhs,
             dst,
         } => {
-            let rhs = allocs.next(rhs.to_reg());
-            let lhs = allocs.next(lhs.to_reg());
-            let dst = allocs.next(dst.to_reg().to_reg());
-            debug_assert_eq!(rhs, dst);
+            let rhs = rhs.to_reg();
+            let lhs = lhs.to_reg();
+            let dst = dst.to_writable_reg();
+            debug_assert_eq!(rhs, dst.to_reg());
 
             // Generates the following sequence:
             // cmpss/cmpsd %lhs, %rhs_dst
@@ -3004,8 +3134,8 @@ pub(crate) fn emit(
                 _ => unreachable!(),
             };
 
-            let inst = Inst::xmm_cmp_rm_r(cmp_op, RegMem::reg(lhs), dst);
-            inst.emit(&[], sink, info, state);
+            let inst = Inst::xmm_cmp_rm_r(cmp_op, dst.to_reg(), RegMem::reg(lhs));
+            inst.emit(sink, info, state);
 
             one_way_jmp(sink, CC::NZ, do_min_max);
             one_way_jmp(sink, CC::P, propagate_nan);
@@ -3014,25 +3144,25 @@ pub(crate) fn emit(
             // and negative zero. These instructions merge the sign bits in that
             // case, and are no-ops otherwise.
             let op = if *is_min { or_op } else { and_op };
-            let inst = Inst::xmm_rm_r(op, RegMem::reg(lhs), Writable::from_reg(dst));
-            inst.emit(&[], sink, info, state);
+            let inst = Inst::xmm_rm_r(op, RegMem::reg(lhs), dst);
+            inst.emit(sink, info, state);
 
             let inst = Inst::jmp_known(done);
-            inst.emit(&[], sink, info, state);
+            inst.emit(sink, info, state);
 
             // x86's min/max are not symmetric; if either operand is a NaN, they return the
             // read-only operand: perform an addition between the two operands, which has the
             // desired NaN propagation effects.
             sink.bind_label(propagate_nan, state.ctrl_plane_mut());
-            let inst = Inst::xmm_rm_r(add_op, RegMem::reg(lhs), Writable::from_reg(dst));
-            inst.emit(&[], sink, info, state);
+            let inst = Inst::xmm_rm_r(add_op, RegMem::reg(lhs), dst);
+            inst.emit(sink, info, state);
 
             one_way_jmp(sink, CC::P, done);
 
             sink.bind_label(do_min_max, state.ctrl_plane_mut());
 
-            let inst = Inst::xmm_rm_r(min_max_op, RegMem::reg(lhs), Writable::from_reg(dst));
-            inst.emit(&[], sink, info, state);
+            let inst = Inst::xmm_rm_r(min_max_op, RegMem::reg(lhs), dst);
+            inst.emit(sink, info, state);
 
             sink.bind_label(done, state.ctrl_plane_mut());
         }
@@ -3045,9 +3175,9 @@ pub(crate) fn emit(
             imm,
             size,
         } => {
-            let src1 = allocs.next(*src1);
-            let dst = allocs.next(dst.to_reg());
-            let src2 = src2.with_allocs(allocs);
+            let src1 = *src1;
+            let dst = dst.to_reg();
+            let src2 = src2.clone();
             debug_assert_eq!(src1, dst);
 
             let (prefix, opcode, len) = match op {
@@ -3100,8 +3230,8 @@ pub(crate) fn emit(
         }
 
         Inst::XmmMovRM { op, src, dst } => {
-            let src = allocs.next(src.to_reg());
-            let dst = dst.with_allocs(allocs);
+            let src = src.to_reg();
+            let dst = dst.clone();
 
             let (prefix, opcode) = match op {
                 SseOpcode::Movaps => (LegacyPrefixes::None, 0x0F29),
@@ -3118,8 +3248,8 @@ pub(crate) fn emit(
         }
 
         Inst::XmmMovRMImm { op, src, dst, imm } => {
-            let src = allocs.next(src.to_reg());
-            let dst = dst.with_allocs(allocs);
+            let src = src.to_reg();
+            let dst = dst.clone();
 
             let (w, prefix, opcode) = match op {
                 SseOpcode::Pextrb => (false, LegacyPrefixes::_66, 0x0F3A14),
@@ -3144,8 +3274,8 @@ pub(crate) fn emit(
             dst,
             dst_size,
         } => {
-            let src = allocs.next(src.to_reg());
-            let dst = allocs.next(dst.to_reg().to_reg());
+            let src = src.to_reg();
+            let dst = dst.to_reg().to_reg();
 
             let (prefix, opcode, dst_first) = match op {
                 SseOpcode::Cvttss2si => (LegacyPrefixes::_F3, 0x0F2C, true),
@@ -3156,7 +3286,7 @@ pub(crate) fn emit(
                 SseOpcode::Movmskps => (LegacyPrefixes::None, 0x0F50, true),
                 SseOpcode::Movmskpd => (LegacyPrefixes::_66, 0x0F50, true),
                 SseOpcode::Pmovmskb => (LegacyPrefixes::_66, 0x0FD7, true),
-                _ => panic!("unexpected opcode {:?}", op),
+                _ => panic!("unexpected opcode {op:?}"),
             };
             let rex = RexFlags::from(*dst_size);
             let (src, dst) = if dst_first { (dst, src) } else { (src, dst) };
@@ -3167,15 +3297,15 @@ pub(crate) fn emit(
         Inst::XmmToGprImm { op, src, dst, imm } => {
             use OperandSize as OS;
 
-            let src = allocs.next(src.to_reg());
-            let dst = allocs.next(dst.to_reg().to_reg());
+            let src = src.to_reg();
+            let dst = dst.to_reg().to_reg();
 
             let (prefix, opcode, opcode_bytes, dst_size, dst_first) = match op {
                 SseOpcode::Pextrb => (LegacyPrefixes::_66, 0x0F3A14, 3, OS::Size32, false),
                 SseOpcode::Pextrw => (LegacyPrefixes::_66, 0x0FC5, 2, OS::Size32, true),
                 SseOpcode::Pextrd => (LegacyPrefixes::_66, 0x0F3A16, 3, OS::Size32, false),
                 SseOpcode::Pextrq => (LegacyPrefixes::_66, 0x0F3A16, 3, OS::Size64, false),
-                _ => panic!("unexpected opcode {:?}", op),
+                _ => panic!("unexpected opcode {op:?}"),
             };
             let rex = RexFlags::from(dst_size);
             let (src, dst) = if dst_first { (dst, src) } else { (src, dst) };
@@ -3190,14 +3320,14 @@ pub(crate) fn emit(
             dst: reg_g,
             src_size,
         } => {
-            let reg_g = allocs.next(reg_g.to_reg().to_reg());
-            let src_e = src_e.clone().to_reg_mem().with_allocs(allocs);
+            let reg_g = reg_g.to_reg().to_reg();
+            let src_e = src_e.clone().to_reg_mem().clone();
 
             let (prefix, opcode) = match op {
                 // Movd and movq use the same opcode; the presence of the REX prefix (set below)
                 // actually determines which is used.
                 SseOpcode::Movd | SseOpcode::Movq => (LegacyPrefixes::_66, 0x0F6E),
-                _ => panic!("unexpected opcode {:?}", op),
+                _ => panic!("unexpected opcode {op:?}"),
             };
             let rex = RexFlags::from(*src_size);
             match src_e {
@@ -3211,9 +3341,9 @@ pub(crate) fn emit(
             }
         }
 
-        Inst::XmmCmpRmR { op, src, dst } => {
-            let dst = allocs.next(dst.to_reg());
-            let src = src.clone().to_reg_mem().with_allocs(allocs);
+        Inst::XmmCmpRmR { op, src1, src2 } => {
+            let src1 = src1.to_reg();
+            let src2 = src2.clone().to_reg_mem().clone();
 
             let rex = RexFlags::clear_w();
             let (prefix, opcode, len) = match op {
@@ -3223,13 +3353,13 @@ pub(crate) fn emit(
                 _ => unimplemented!("Emit xmm cmp rm r"),
             };
 
-            match src {
+            match src2 {
                 RegMem::Reg { reg } => {
-                    emit_std_reg_reg(sink, prefix, opcode, len, dst, reg, rex);
+                    emit_std_reg_reg(sink, prefix, opcode, len, src1, reg, rex);
                 }
                 RegMem::Mem { addr } => {
                     let addr = &addr.finalize(state, sink);
-                    emit_std_reg_mem(sink, prefix, opcode, len, dst, addr, rex, 0);
+                    emit_std_reg_mem(sink, prefix, opcode, len, src1, addr, rex, 0);
                 }
             }
         }
@@ -3241,15 +3371,15 @@ pub(crate) fn emit(
             dst,
             src2_size,
         } => {
-            let src1 = allocs.next(src1.to_reg());
-            let dst = allocs.next(dst.to_reg().to_reg());
+            let src1 = src1.to_reg();
+            let dst = dst.to_reg().to_reg();
             assert_eq!(src1, dst);
-            let src2 = src2.clone().to_reg_mem().with_allocs(allocs);
+            let src2 = src2.clone().to_reg_mem().clone();
 
             let (prefix, opcode) = match op {
                 SseOpcode::Cvtsi2ss => (LegacyPrefixes::_F3, 0x0F2A),
                 SseOpcode::Cvtsi2sd => (LegacyPrefixes::_F2, 0x0F2A),
-                _ => panic!("unexpected opcode {:?}", op),
+                _ => panic!("unexpected opcode {op:?}"),
             };
             let rex = RexFlags::from(*src2_size);
             match src2 {
@@ -3270,9 +3400,9 @@ pub(crate) fn emit(
             dst,
             src2_size,
         } => {
-            let dst = allocs.next(dst.to_reg().to_reg());
-            let src1 = allocs.next(src1.to_reg());
-            let src2 = match src2.clone().to_reg_mem().with_allocs(allocs) {
+            let dst = dst.to_reg().to_reg();
+            let src1 = src1.to_reg();
+            let src2 = match src2.clone().to_reg_mem().clone() {
                 RegMem::Reg { reg } => {
                     RegisterOrAmode::Register(reg.to_real_reg().unwrap().hw_enc().into())
                 }
@@ -3307,10 +3437,10 @@ pub(crate) fn emit(
             tmp_gpr1,
             tmp_gpr2,
         } => {
-            let src = allocs.next(src.to_reg());
-            let dst = allocs.next(dst.to_reg().to_reg());
-            let tmp_gpr1 = allocs.next(tmp_gpr1.to_reg().to_reg());
-            let tmp_gpr2 = allocs.next(tmp_gpr2.to_reg().to_reg());
+            let src = src.to_reg();
+            let dst = dst.to_writable_reg();
+            let tmp_gpr1 = tmp_gpr1.to_writable_reg();
+            let tmp_gpr2 = tmp_gpr2.to_writable_reg();
 
             // Note: this sequence is specific to 64-bit mode; a 32-bit mode would require a
             // different sequence.
@@ -3336,9 +3466,8 @@ pub(crate) fn emit(
             //
             //  done:
 
-            assert_ne!(src, tmp_gpr1);
-            assert_ne!(src, tmp_gpr2);
-            assert_ne!(tmp_gpr1, tmp_gpr2);
+            assert_ne!(src, tmp_gpr1.to_reg());
+            assert_ne!(src, tmp_gpr2.to_reg());
 
             let handle_negative = sink.get_label();
             let done = sink.get_label();
@@ -3346,8 +3475,8 @@ pub(crate) fn emit(
             // If x seen as a signed int64 is not negative, a signed-conversion will do the right
             // thing.
             // TODO use tst src, src here.
-            let inst = Inst::cmp_rmi_r(OperandSize::Size64, RegMemImm::imm(0), src);
-            inst.emit(&[], sink, info, state);
+            let inst = Inst::cmp_rmi_r(OperandSize::Size64, src, RegMemImm::imm(0));
+            inst.emit(sink, info, state);
 
             one_way_jmp(sink, CC::L, handle_negative);
 
@@ -3358,55 +3487,55 @@ pub(crate) fn emit(
                 info,
                 state,
                 src,
-                Writable::from_reg(dst),
+                dst,
                 *dst_size == OperandSize::Size64,
             );
 
             let inst = Inst::jmp_known(done);
-            inst.emit(&[], sink, info, state);
+            inst.emit(sink, info, state);
 
             sink.bind_label(handle_negative, state.ctrl_plane_mut());
 
             // Divide x by two to get it in range for the signed conversion, keep the LSB, and
             // scale it back up on the FP side.
-            let inst = Inst::gen_move(Writable::from_reg(tmp_gpr1), src, types::I64);
-            inst.emit(&[], sink, info, state);
+            let inst = Inst::gen_move(tmp_gpr1, src, types::I64);
+            inst.emit(sink, info, state);
 
             // tmp_gpr1 := src >> 1
             let inst = Inst::shift_r(
                 OperandSize::Size64,
                 ShiftKind::ShiftRightLogical,
-                Imm8Gpr::new(Imm8Reg::Imm8 { imm: 1 }).unwrap(),
+                Imm8Gpr::unwrap_new(Imm8Reg::Imm8 { imm: 1 }),
+                tmp_gpr1.to_reg(),
                 tmp_gpr1,
-                Writable::from_reg(tmp_gpr1),
             );
-            inst.emit(&[], sink, info, state);
+            inst.emit(sink, info, state);
 
-            let inst = Inst::gen_move(Writable::from_reg(tmp_gpr2), src, types::I64);
-            inst.emit(&[], sink, info, state);
+            let inst = Inst::gen_move(tmp_gpr2, src, types::I64);
+            inst.emit(sink, info, state);
 
             let inst = Inst::alu_rmi_r(
                 OperandSize::Size64,
                 AluRmiROpcode::And,
                 RegMemImm::imm(1),
-                Writable::from_reg(tmp_gpr2),
+                tmp_gpr2,
             );
-            inst.emit(&[], sink, info, state);
+            inst.emit(sink, info, state);
 
             let inst = Inst::alu_rmi_r(
                 OperandSize::Size64,
                 AluRmiROpcode::Or,
-                RegMemImm::reg(tmp_gpr1),
-                Writable::from_reg(tmp_gpr2),
+                RegMemImm::reg(tmp_gpr1.to_reg()),
+                tmp_gpr2,
             );
-            inst.emit(&[], sink, info, state);
+            inst.emit(sink, info, state);
 
             emit_signed_cvt(
                 sink,
                 info,
                 state,
-                tmp_gpr2,
-                Writable::from_reg(dst),
+                tmp_gpr2.to_reg(),
+                dst,
                 *dst_size == OperandSize::Size64,
             );
 
@@ -3415,8 +3544,8 @@ pub(crate) fn emit(
             } else {
                 SseOpcode::Addss
             };
-            let inst = Inst::xmm_rm_r(add_op, RegMem::reg(dst), Writable::from_reg(dst));
-            inst.emit(&[], sink, info, state);
+            let inst = Inst::xmm_rm_r(add_op, RegMem::reg(dst.to_reg()), dst);
+            inst.emit(sink, info, state);
 
             sink.bind_label(done, state.ctrl_plane_mut());
         }
@@ -3430,10 +3559,10 @@ pub(crate) fn emit(
             tmp_gpr,
             tmp_xmm,
         } => {
-            let src = allocs.next(src.to_reg());
-            let dst = allocs.next(dst.to_reg().to_reg());
-            let tmp_gpr = allocs.next(tmp_gpr.to_reg().to_reg());
-            let tmp_xmm = allocs.next(tmp_xmm.to_reg().to_reg());
+            let src = src.to_reg();
+            let dst = dst.to_writable_reg();
+            let tmp_gpr = tmp_gpr.to_writable_reg();
+            let tmp_xmm = tmp_xmm.to_writable_reg();
 
             // Emits the following common sequence:
             //
@@ -3490,19 +3619,19 @@ pub(crate) fn emit(
             let done = sink.get_label();
 
             // The truncation.
-            let inst = Inst::xmm_to_gpr(trunc_op, src, Writable::from_reg(dst), *dst_size);
-            inst.emit(&[], sink, info, state);
+            let inst = Inst::xmm_to_gpr(trunc_op, src, dst, *dst_size);
+            inst.emit(sink, info, state);
 
             // Compare against 1, in case of overflow the dst operand was INT_MIN.
-            let inst = Inst::cmp_rmi_r(*dst_size, RegMemImm::imm(1), dst);
-            inst.emit(&[], sink, info, state);
+            let inst = Inst::cmp_rmi_r(*dst_size, dst.to_reg(), RegMemImm::imm(1));
+            inst.emit(sink, info, state);
 
             one_way_jmp(sink, CC::NO, done); // no overflow => done
 
             // Check for NaN.
 
-            let inst = Inst::xmm_cmp_rm_r(cmp_op, RegMem::reg(src), src);
-            inst.emit(&[], sink, info, state);
+            let inst = Inst::xmm_cmp_rm_r(cmp_op, src, RegMem::reg(src));
+            inst.emit(sink, info, state);
 
             if *is_saturating {
                 let not_nan = sink.get_label();
@@ -3512,47 +3641,39 @@ pub(crate) fn emit(
                 let inst = Inst::alu_rmi_r(
                     *dst_size,
                     AluRmiROpcode::Xor,
-                    RegMemImm::reg(dst),
-                    Writable::from_reg(dst),
+                    RegMemImm::reg(dst.to_reg()),
+                    dst,
                 );
-                inst.emit(&[], sink, info, state);
+                inst.emit(sink, info, state);
 
                 let inst = Inst::jmp_known(done);
-                inst.emit(&[], sink, info, state);
+                inst.emit(sink, info, state);
 
                 sink.bind_label(not_nan, state.ctrl_plane_mut());
 
                 // If the input was positive, saturate to INT_MAX.
 
                 // Zero out tmp_xmm.
-                let inst = Inst::xmm_rm_r(
-                    SseOpcode::Xorpd,
-                    RegMem::reg(tmp_xmm),
-                    Writable::from_reg(tmp_xmm),
-                );
-                inst.emit(&[], sink, info, state);
+                let inst = Inst::xmm_rm_r(SseOpcode::Xorpd, RegMem::reg(tmp_xmm.to_reg()), tmp_xmm);
+                inst.emit(sink, info, state);
 
-                let inst = Inst::xmm_cmp_rm_r(cmp_op, RegMem::reg(src), tmp_xmm);
-                inst.emit(&[], sink, info, state);
+                let inst = Inst::xmm_cmp_rm_r(cmp_op, tmp_xmm.to_reg(), RegMem::reg(src));
+                inst.emit(sink, info, state);
 
                 // Jump if >= to done.
                 one_way_jmp(sink, CC::NB, done);
 
                 // Otherwise, put INT_MAX.
                 if *dst_size == OperandSize::Size64 {
-                    let inst = Inst::imm(
-                        OperandSize::Size64,
-                        0x7fffffffffffffff,
-                        Writable::from_reg(dst),
-                    );
-                    inst.emit(&[], sink, info, state);
+                    let inst = Inst::imm(OperandSize::Size64, 0x7fffffffffffffff, dst);
+                    inst.emit(sink, info, state);
                 } else {
-                    let inst = Inst::imm(OperandSize::Size32, 0x7fffffff, Writable::from_reg(dst));
-                    inst.emit(&[], sink, info, state);
+                    let inst = Inst::imm(OperandSize::Size32, 0x7fffffff, dst);
+                    inst.emit(sink, info, state);
                 }
             } else {
                 let inst = Inst::trap_if(CC::P, TrapCode::BadConversionToInteger);
-                inst.emit(&[], sink, info, state);
+                inst.emit(sink, info, state);
 
                 // Check if INT_MIN was the correct result: determine the smallest floating point
                 // number that would convert to INT_MIN, put it in a temporary register, and compare
@@ -3564,10 +3685,9 @@ pub(crate) fn emit(
                 let output_bits = dst_size.to_bits();
                 match *src_size {
                     OperandSize::Size32 => {
-                        let cst = Ieee32::pow2(output_bits - 1).neg().bits();
-                        let inst =
-                            Inst::imm(OperandSize::Size32, cst as u64, Writable::from_reg(tmp_gpr));
-                        inst.emit(&[], sink, info, state);
+                        let cst = (-Ieee32::pow2(output_bits - 1)).bits();
+                        let inst = Inst::imm(OperandSize::Size32, cst as u64, tmp_gpr);
+                        inst.emit(sink, info, state);
                     }
                     OperandSize::Size64 => {
                         // An f64 can represent `i32::min_value() - 1` exactly with precision to spare,
@@ -3576,46 +3696,37 @@ pub(crate) fn emit(
                             no_overflow_cc = CC::NBE; // >
                             Ieee64::fcvt_to_sint_negative_overflow(output_bits)
                         } else {
-                            Ieee64::pow2(output_bits - 1).neg()
+                            -Ieee64::pow2(output_bits - 1)
                         };
-                        let inst =
-                            Inst::imm(OperandSize::Size64, cst.bits(), Writable::from_reg(tmp_gpr));
-                        inst.emit(&[], sink, info, state);
+                        let inst = Inst::imm(OperandSize::Size64, cst.bits(), tmp_gpr);
+                        inst.emit(sink, info, state);
                     }
                     _ => unreachable!(),
                 }
 
-                let inst = Inst::gpr_to_xmm(
-                    cast_op,
-                    RegMem::reg(tmp_gpr),
-                    *src_size,
-                    Writable::from_reg(tmp_xmm),
-                );
-                inst.emit(&[], sink, info, state);
+                let inst =
+                    Inst::gpr_to_xmm(cast_op, RegMem::reg(tmp_gpr.to_reg()), *src_size, tmp_xmm);
+                inst.emit(sink, info, state);
 
-                let inst = Inst::xmm_cmp_rm_r(cmp_op, RegMem::reg(tmp_xmm), src);
-                inst.emit(&[], sink, info, state);
+                let inst = Inst::xmm_cmp_rm_r(cmp_op, src, RegMem::reg(tmp_xmm.to_reg()));
+                inst.emit(sink, info, state);
 
                 // no trap if src >= or > threshold
                 let inst = Inst::trap_if(no_overflow_cc.invert(), TrapCode::IntegerOverflow);
-                inst.emit(&[], sink, info, state);
+                inst.emit(sink, info, state);
 
                 // If positive, it was a real overflow.
 
                 // Zero out the tmp_xmm register.
-                let inst = Inst::xmm_rm_r(
-                    SseOpcode::Xorpd,
-                    RegMem::reg(tmp_xmm),
-                    Writable::from_reg(tmp_xmm),
-                );
-                inst.emit(&[], sink, info, state);
+                let inst = Inst::xmm_rm_r(SseOpcode::Xorpd, RegMem::reg(tmp_xmm.to_reg()), tmp_xmm);
+                inst.emit(sink, info, state);
 
-                let inst = Inst::xmm_cmp_rm_r(cmp_op, RegMem::reg(src), tmp_xmm);
-                inst.emit(&[], sink, info, state);
+                let inst = Inst::xmm_cmp_rm_r(cmp_op, tmp_xmm.to_reg(), RegMem::reg(src));
+                inst.emit(sink, info, state);
 
                 // no trap if 0 >= src
                 let inst = Inst::trap_if(CC::B, TrapCode::IntegerOverflow);
-                inst.emit(&[], sink, info, state);
+                inst.emit(sink, info, state);
             }
 
             sink.bind_label(done, state.ctrl_plane_mut());
@@ -3631,11 +3742,11 @@ pub(crate) fn emit(
             tmp_xmm,
             tmp_xmm2,
         } => {
-            let src = allocs.next(src.to_reg());
-            let dst = allocs.next(dst.to_reg().to_reg());
-            let tmp_gpr = allocs.next(tmp_gpr.to_reg().to_reg());
-            let tmp_xmm = allocs.next(tmp_xmm.to_reg().to_reg());
-            let tmp_xmm2 = allocs.next(tmp_xmm2.to_reg().to_reg());
+            let src = src.to_reg();
+            let dst = dst.to_writable_reg();
+            let tmp_gpr = tmp_gpr.to_writable_reg();
+            let tmp_xmm = tmp_xmm.to_writable_reg();
+            let tmp_xmm2 = tmp_xmm2.to_writable_reg();
 
             // The only difference in behavior between saturating and non-saturating is how we
             // handle errors. Emits the following sequence:
@@ -3671,7 +3782,7 @@ pub(crate) fn emit(
             //
             // done:
 
-            assert_ne!(tmp_xmm, src, "tmp_xmm clobbers src!");
+            assert_ne!(tmp_xmm.to_reg(), src, "tmp_xmm clobbers src!");
 
             let (sub_op, cast_op, cmp_op, trunc_op) = match src_size {
                 OperandSize::Size32 => (
@@ -3697,19 +3808,14 @@ pub(crate) fn emit(
                 _ => unreachable!(),
             };
 
-            let inst = Inst::imm(*src_size, cst, Writable::from_reg(tmp_gpr));
-            inst.emit(&[], sink, info, state);
+            let inst = Inst::imm(*src_size, cst, tmp_gpr);
+            inst.emit(sink, info, state);
 
-            let inst = Inst::gpr_to_xmm(
-                cast_op,
-                RegMem::reg(tmp_gpr),
-                *src_size,
-                Writable::from_reg(tmp_xmm),
-            );
-            inst.emit(&[], sink, info, state);
+            let inst = Inst::gpr_to_xmm(cast_op, RegMem::reg(tmp_gpr.to_reg()), *src_size, tmp_xmm);
+            inst.emit(sink, info, state);
 
-            let inst = Inst::xmm_cmp_rm_r(cmp_op, RegMem::reg(tmp_xmm), src);
-            inst.emit(&[], sink, info, state);
+            let inst = Inst::xmm_cmp_rm_r(cmp_op, src, RegMem::reg(tmp_xmm.to_reg()));
+            inst.emit(sink, info, state);
 
             let handle_large = sink.get_label();
             one_way_jmp(sink, CC::NB, handle_large); // jump to handle_large if src >= large_threshold
@@ -3721,28 +3827,28 @@ pub(crate) fn emit(
                 let inst = Inst::alu_rmi_r(
                     *dst_size,
                     AluRmiROpcode::Xor,
-                    RegMemImm::reg(dst),
-                    Writable::from_reg(dst),
+                    RegMemImm::reg(dst.to_reg()),
+                    dst,
                 );
-                inst.emit(&[], sink, info, state);
+                inst.emit(sink, info, state);
 
                 let inst = Inst::jmp_known(done);
-                inst.emit(&[], sink, info, state);
+                inst.emit(sink, info, state);
                 sink.bind_label(not_nan, state.ctrl_plane_mut());
             } else {
                 // Trap.
                 let inst = Inst::trap_if(CC::P, TrapCode::BadConversionToInteger);
-                inst.emit(&[], sink, info, state);
+                inst.emit(sink, info, state);
             }
 
             // Actual truncation for small inputs: if the result is not positive, then we had an
             // overflow.
 
-            let inst = Inst::xmm_to_gpr(trunc_op, src, Writable::from_reg(dst), *dst_size);
-            inst.emit(&[], sink, info, state);
+            let inst = Inst::xmm_to_gpr(trunc_op, src, dst, *dst_size);
+            inst.emit(sink, info, state);
 
-            let inst = Inst::cmp_rmi_r(*dst_size, RegMemImm::imm(0), dst);
-            inst.emit(&[], sink, info, state);
+            let inst = Inst::cmp_rmi_r(*dst_size, dst.to_reg(), RegMemImm::imm(0));
+            inst.emit(sink, info, state);
 
             one_way_jmp(sink, CC::NL, done); // if dst >= 0, jump to done
 
@@ -3752,34 +3858,34 @@ pub(crate) fn emit(
                 let inst = Inst::alu_rmi_r(
                     *dst_size,
                     AluRmiROpcode::Xor,
-                    RegMemImm::reg(dst),
-                    Writable::from_reg(dst),
+                    RegMemImm::reg(dst.to_reg()),
+                    dst,
                 );
-                inst.emit(&[], sink, info, state);
+                inst.emit(sink, info, state);
 
                 let inst = Inst::jmp_known(done);
-                inst.emit(&[], sink, info, state);
+                inst.emit(sink, info, state);
             } else {
                 // Trap.
                 let inst = Inst::trap(TrapCode::IntegerOverflow);
-                inst.emit(&[], sink, info, state);
+                inst.emit(sink, info, state);
             }
 
             // Now handle large inputs.
 
             sink.bind_label(handle_large, state.ctrl_plane_mut());
 
-            let inst = Inst::gen_move(Writable::from_reg(tmp_xmm2), src, types::F64);
-            inst.emit(&[], sink, info, state);
+            let inst = Inst::gen_move(tmp_xmm2, src, types::F64);
+            inst.emit(sink, info, state);
 
-            let inst = Inst::xmm_rm_r(sub_op, RegMem::reg(tmp_xmm), Writable::from_reg(tmp_xmm2));
-            inst.emit(&[], sink, info, state);
+            let inst = Inst::xmm_rm_r(sub_op, RegMem::reg(tmp_xmm.to_reg()), tmp_xmm2);
+            inst.emit(sink, info, state);
 
-            let inst = Inst::xmm_to_gpr(trunc_op, tmp_xmm2, Writable::from_reg(dst), *dst_size);
-            inst.emit(&[], sink, info, state);
+            let inst = Inst::xmm_to_gpr(trunc_op, tmp_xmm2.to_reg(), dst, *dst_size);
+            inst.emit(sink, info, state);
 
-            let inst = Inst::cmp_rmi_r(*dst_size, RegMemImm::imm(0), dst);
-            inst.emit(&[], sink, info, state);
+            let inst = Inst::cmp_rmi_r(*dst_size, dst.to_reg(), RegMemImm::imm(0));
+            inst.emit(sink, info, state);
 
             if *is_saturating {
                 let next_is_large = sink.get_label();
@@ -3794,37 +3900,37 @@ pub(crate) fn emit(
                     } else {
                         u32::max_value() as u64
                     },
-                    Writable::from_reg(dst),
+                    dst,
                 );
-                inst.emit(&[], sink, info, state);
+                inst.emit(sink, info, state);
 
                 let inst = Inst::jmp_known(done);
-                inst.emit(&[], sink, info, state);
+                inst.emit(sink, info, state);
                 sink.bind_label(next_is_large, state.ctrl_plane_mut());
             } else {
                 let inst = Inst::trap_if(CC::L, TrapCode::IntegerOverflow);
-                inst.emit(&[], sink, info, state);
+                inst.emit(sink, info, state);
             }
 
             if *dst_size == OperandSize::Size64 {
-                let inst = Inst::imm(OperandSize::Size64, 1 << 63, Writable::from_reg(tmp_gpr));
-                inst.emit(&[], sink, info, state);
+                let inst = Inst::imm(OperandSize::Size64, 1 << 63, tmp_gpr);
+                inst.emit(sink, info, state);
 
                 let inst = Inst::alu_rmi_r(
                     OperandSize::Size64,
                     AluRmiROpcode::Add,
-                    RegMemImm::reg(tmp_gpr),
-                    Writable::from_reg(dst),
+                    RegMemImm::reg(tmp_gpr.to_reg()),
+                    dst,
                 );
-                inst.emit(&[], sink, info, state);
+                inst.emit(sink, info, state);
             } else {
                 let inst = Inst::alu_rmi_r(
                     OperandSize::Size32,
                     AluRmiROpcode::Add,
                     RegMemImm::imm(1 << 31),
-                    Writable::from_reg(dst),
+                    dst,
                 );
-                inst.emit(&[], sink, info, state);
+                inst.emit(sink, info, state);
             }
 
             sink.bind_label(done, state.ctrl_plane_mut());
@@ -3836,7 +3942,7 @@ pub(crate) fn emit(
             offset,
             distance,
         } => {
-            let dst = allocs.next(dst.to_reg());
+            let dst = dst.to_reg();
 
             if info.flags.is_pic() {
                 // Generates: movq symbol@GOTPCREL(%rip), %dst
@@ -3889,10 +3995,10 @@ pub(crate) fn emit(
             mem,
             dst_old,
         } => {
-            let replacement = allocs.next(*replacement);
-            let expected = allocs.next(*expected);
-            let dst_old = allocs.next(dst_old.to_reg());
-            let mem = mem.with_allocs(allocs);
+            let replacement = *replacement;
+            let expected = *expected;
+            let dst_old = dst_old.to_reg();
+            let mem = mem.clone();
 
             debug_assert_eq!(expected, regs::rax());
             debug_assert_eq!(dst_old, regs::rax());
@@ -3919,11 +4025,11 @@ pub(crate) fn emit(
             temp,
             dst_old,
         } => {
-            let operand = allocs.next(*operand);
-            let temp = allocs.next_writable(*temp);
-            let dst_old = allocs.next_writable(*dst_old);
+            let operand = *operand;
+            let temp = *temp;
+            let dst_old = *dst_old;
             debug_assert_eq!(dst_old.to_reg(), regs::rax());
-            let mem = mem.finalize(state, sink).with_allocs(allocs);
+            let mem = mem.finalize(state, sink).clone();
 
             // Emit this:
             //    mov{zbq,zwq,zlq,q}     (%r_address), %rax    // rax = old value
@@ -3949,14 +4055,14 @@ pub(crate) fn emit(
             // mov{zbq,zwq,zlq,q} (%r_address), %rax
             // No need to call `add_trap` here, since the `i1` emit will do that.
             let i1 = Inst::load(*ty, mem.clone(), dst_old, ExtKind::ZeroExtend);
-            i1.emit(&[], sink, info, state);
+            i1.emit(sink, info, state);
 
             // again:
             sink.bind_label(again_label, state.ctrl_plane_mut());
 
             // movq %rax, %r_temp
             let i2 = Inst::mov_r_r(OperandSize::Size64, dst_old.to_reg(), temp);
-            i2.emit(&[], sink, info, state);
+            i2.emit(sink, info, state);
 
             let operand_rmi = RegMemImm::reg(operand);
             use inst_common::MachAtomicRmwOp as RmwOp;
@@ -3964,26 +4070,26 @@ pub(crate) fn emit(
                 RmwOp::Xchg => {
                     // movq %r_operand, %r_temp
                     let i3 = Inst::mov_r_r(OperandSize::Size64, operand, temp);
-                    i3.emit(&[], sink, info, state);
+                    i3.emit(sink, info, state);
                 }
                 RmwOp::Nand => {
                     // andq %r_operand, %r_temp
                     let i3 =
                         Inst::alu_rmi_r(OperandSize::Size64, AluRmiROpcode::And, operand_rmi, temp);
-                    i3.emit(&[], sink, info, state);
+                    i3.emit(sink, info, state);
 
                     // notq %r_temp
                     let i4 = Inst::not(OperandSize::Size64, temp);
-                    i4.emit(&[], sink, info, state);
+                    i4.emit(sink, info, state);
                 }
                 RmwOp::Umin | RmwOp::Umax | RmwOp::Smin | RmwOp::Smax => {
                     // cmp %r_temp, %r_operand
                     let i3 = Inst::cmp_rmi_r(
                         OperandSize::from_ty(*ty),
-                        RegMemImm::reg(temp.to_reg()),
                         operand,
+                        RegMemImm::reg(temp.to_reg()),
                     );
-                    i3.emit(&[], sink, info, state);
+                    i3.emit(sink, info, state);
 
                     // cmovcc %r_operand, %r_temp
                     let cc = match op {
@@ -3994,7 +4100,7 @@ pub(crate) fn emit(
                         _ => unreachable!(),
                     };
                     let i4 = Inst::cmove(OperandSize::Size64, cc, RegMem::reg(operand), temp);
-                    i4.emit(&[], sink, info, state);
+                    i4.emit(sink, info, state);
                 }
                 _ => {
                     // opq %r_operand, %r_temp
@@ -4012,7 +4118,7 @@ pub(crate) fn emit(
                         | RmwOp::Smax => unreachable!(),
                     };
                     let i3 = Inst::alu_rmi_r(OperandSize::Size64, alu_op, operand_rmi, temp);
-                    i3.emit(&[], sink, info, state);
+                    i3.emit(sink, info, state);
                 }
             }
 
@@ -4025,7 +4131,7 @@ pub(crate) fn emit(
                 mem: mem.into(),
                 dst_old,
             };
-            i4.emit(&[], sink, info, state);
+            i4.emit(sink, info, state);
 
             // jnz again
             one_way_jmp(sink, CC::NZ, again_label);
@@ -4047,16 +4153,9 @@ pub(crate) fn emit(
 
         Inst::Ud2 { trap_code } => {
             sink.add_trap(*trap_code);
-            if let Some(s) = state.take_stack_map() {
-                sink.add_stack_map(StackMapExtent::UpcomingBytes(2), s);
-            }
             sink.put_data(Inst::TRAP_OPCODE);
         }
 
-        Inst::VirtualSPOffsetAdj { offset } => {
-            state.adjust_virtual_sp_offset(*offset);
-        }
-
         Inst::Nop { len } => {
             // These encodings can all be found in Intel's architecture manual, at the NOP
             // instruction description.
@@ -4141,7 +4240,7 @@ pub(crate) fn emit(
         }
 
         Inst::ElfTlsGetAddr { ref symbol, dst } => {
-            let dst = allocs.next(dst.to_reg().to_reg());
+            let dst = dst.to_reg().to_reg();
             debug_assert_eq!(dst, regs::rax());
 
             // N.B.: Must be exactly this byte sequence; the linker requires it,
@@ -4170,7 +4269,7 @@ pub(crate) fn emit(
         }
 
         Inst::MachOTlsGetAddr { ref symbol, dst } => {
-            let dst = allocs.next(dst.to_reg().to_reg());
+            let dst = dst.to_reg().to_reg();
             debug_assert_eq!(dst, regs::rax());
 
             // movq gv@tlv(%rip), %rdi
@@ -4190,11 +4289,11 @@ pub(crate) fn emit(
             dst,
             tmp,
         } => {
-            let dst = allocs.next(dst.to_reg().to_reg());
+            let dst = dst.to_reg().to_reg();
             debug_assert_eq!(dst, regs::rax());
 
             // tmp is used below directly as %rcx
-            let tmp = allocs.next(tmp.to_reg().to_reg());
+            let tmp = tmp.to_reg().to_reg();
             debug_assert_eq!(tmp, regs::rcx());
 
             // See: https://gcc.godbolt.org/z/M8or9x6ss
@@ -4266,16 +4365,10 @@ pub(crate) fn emit(
 ///
 /// * Move the return address into its stack slot.
 fn emit_return_call_common_sequence(
-    allocs: &mut AllocationConsumer<'_>,
     sink: &mut MachBuffer<Inst>,
     info: &EmitInfo,
     state: &mut EmitState,
-    new_stack_arg_size: u32,
-    old_stack_arg_size: u32,
-    ret_addr: Option<Gpr>,
-    fp: Gpr,
-    tmp: WritableGpr,
-    uses: &CallArgList,
+    call_info: &ReturnCallInfo,
 ) {
     assert!(
         info.flags.preserve_frame_pointers(),
@@ -4283,128 +4376,41 @@ fn emit_return_call_common_sequence(
                  but the current implementation relies on them being present"
     );
 
-    for u in uses {
-        let _ = allocs.next(u.vreg);
-    }
+    let tmp = call_info.tmp.to_writable_reg();
 
-    let ret_addr = ret_addr.map(|r| Gpr::new(allocs.next(*r)).unwrap());
-
-    let fp = allocs.next(*fp);
-
-    let tmp = allocs.next(tmp.to_reg().to_reg());
-    let tmp = Gpr::new(tmp).unwrap();
-    let tmp_w = WritableGpr::from_reg(tmp);
-
-    // Copy the new frame (which is `frame_size` bytes above the SP)
-    // onto our current frame, using only volatile, non-argument
-    // registers.
-    //
-    //
-    // The current stack layout is the following:
-    //
-    //            | ...                 |
-    //            +---------------------+
-    //            | ...                 |
-    //            | stack arguments     |
-    //            | ...                 |
-    //    current | return address      |
-    //    frame   | old FP              | <-- FP
-    //            | ...                 |
-    //            | old stack slots     |
-    //            | ...                 |
-    //            +---------------------+
-    //            | ...                 |
-    //    new     | new stack arguments |
-    //    frame   | ...                 | <-- SP
-    //            +---------------------+
-    //
-    // We need to restore the old FP, copy the new stack arguments over the old
-    // stack arguments, write the return address into the correct slot just
-    // after the new stack arguments, adjust SP to point to the new return
-    // address, and then jump to the callee (which will push the old FP again).
-
-    // Restore the old FP into `rbp`.
-    Inst::Mov64MR {
-        src: SyntheticAmode::Real(Amode::ImmReg {
-            simm32: 0,
-            base: fp,
-            flags: MemFlags::trusted(),
-        }),
-        dst: Writable::from_reg(Gpr::new(regs::rbp()).unwrap()),
-    }
-    .emit(&[], sink, info, state);
-
-    // The new lowest address (top of stack) -- relative to FP -- for
-    // our tail callee. We compute this now so that we can move our
-    // stack arguments into place.
-    let callee_sp_relative_to_fp = i64::from(old_stack_arg_size) - i64::from(new_stack_arg_size);
-
-    // Copy over each word, using `tmp` as a temporary register.
-    //
-    // Note that we have to do this from stack slots with the highest
-    // address to lowest address because in the case of when the tail
-    // callee has more stack arguments than we do, we might otherwise
-    // overwrite some of our stack arguments before they've been copied
-    // into place.
-    assert_eq!(
-        new_stack_arg_size % 8,
-        0,
-        "stack argument space sizes should always be 8-byte aligned"
-    );
-    for i in (0..new_stack_arg_size / 8).rev() {
-        Inst::Mov64MR {
-            src: SyntheticAmode::Real(Amode::ImmReg {
-                simm32: (i * 8).try_into().unwrap(),
-                base: regs::rsp(),
-                flags: MemFlags::trusted(),
-            }),
-            dst: tmp_w,
-        }
-        .emit(&[], sink, info, state);
-        Inst::MovRM {
-            size: OperandSize::Size64,
-            src: tmp,
-            dst: SyntheticAmode::Real(Amode::ImmReg {
-                // Add 2 because we need to skip over the old FP and the
-                // return address.
-                simm32: (callee_sp_relative_to_fp + i64::from((i + 2) * 8))
-                    .try_into()
-                    .unwrap(),
-                base: fp,
-                flags: MemFlags::trusted(),
-            }),
-        }
-        .emit(&[], sink, info, state);
+    for inst in
+        X64ABIMachineSpec::gen_clobber_restore(CallConv::Tail, &info.flags, state.frame_layout())
+    {
+        inst.emit(sink, info, state);
     }
 
-    // Initialize SP for the tail callee, deallocating the temporary
-    // stack arguments space at the same time.
-    Inst::LoadEffectiveAddress {
-        size: OperandSize::Size64,
-        addr: SyntheticAmode::Real(Amode::ImmReg {
-            // NB: We add a word to `callee_sp_relative_to_fp` here because the
-            // callee will push FP, not us.
-            simm32: callee_sp_relative_to_fp.wrapping_add(8).try_into().unwrap(),
-            base: fp,
-            flags: MemFlags::trusted(),
-        }),
-        dst: Writable::from_reg(Gpr::new(regs::rsp()).unwrap()),
+    for inst in X64ABIMachineSpec::gen_epilogue_frame_restore(
+        CallConv::Tail,
+        &info.flags,
+        &info.isa_flags,
+        state.frame_layout(),
+    ) {
+        inst.emit(sink, info, state);
     }
-    .emit(&[], sink, info, state);
-
-    state.adjust_virtual_sp_offset(-i64::from(new_stack_arg_size));
-
-    // Write the return address into the correct stack slot.
-    if let Some(ret_addr) = ret_addr {
-        Inst::MovRM {
-            size: OperandSize::Size64,
-            src: ret_addr,
-            dst: SyntheticAmode::Real(Amode::ImmReg {
-                simm32: 0,
-                base: regs::rsp(),
-                flags: MemFlags::trusted(),
-            }),
-        }
-        .emit(&[], sink, info, state);
+
+    let incoming_args_diff = state.frame_layout().tail_args_size - call_info.new_stack_arg_size;
+    if incoming_args_diff > 0 {
+        // Move the saved return address up by `incoming_args_diff`
+        Inst::mov64_m_r(Amode::imm_reg(0, regs::rsp()), tmp).emit(sink, info, state);
+        Inst::mov_r_m(
+            OperandSize::Size64,
+            tmp.to_reg(),
+            Amode::imm_reg(i32::try_from(incoming_args_diff).unwrap(), regs::rsp()),
+        )
+        .emit(sink, info, state);
+
+        // Increment the stack pointer to shrink the argument area for the new call.
+        Inst::alu_rmi_r(
+            OperandSize::Size64,
+            AluRmiROpcode::Add,
+            RegMemImm::imm(incoming_args_diff),
+            Writable::from_reg(regs::rsp()),
+        )
+        .emit(sink, info, state);
     }
 }
diff --git a/cranelift/codegen/src/isa/x64/inst/emit_state.rs b/cranelift/codegen/src/isa/x64/inst/emit_state.rs
index 178490848a99..c28776b90473 100644
--- a/cranelift/codegen/src/isa/x64/inst/emit_state.rs
+++ b/cranelift/codegen/src/isa/x64/inst/emit_state.rs
@@ -1,40 +1,34 @@
 use super::*;
+use crate::ir;
 use cranelift_control::ControlPlane;
 
 /// State carried between emissions of a sequence of instructions.
 #[derive(Default, Clone, Debug)]
 pub struct EmitState {
-    /// Addend to convert nominal-SP offsets to real-SP offsets at the current
-    /// program point.
-    virtual_sp_offset: i64,
-    /// Offset of FP from nominal-SP.
-    nominal_sp_to_fp: i64,
-    /// Safepoint stack map for upcoming instruction, as provided to `pre_safepoint()`.
-    stack_map: Option<StackMap>,
-    /// Current source location.
-    cur_srcloc: RelSourceLoc,
+    /// The user stack map for the upcoming instruction, as provided to
+    /// `pre_safepoint()`.
+    user_stack_map: Option<ir::UserStackMap>,
+
     /// Only used during fuzz-testing. Otherwise, it is a zero-sized struct and
     /// optimized away at compiletime. See [cranelift_control].
     ctrl_plane: ControlPlane,
+
+    /// A copy of the frame layout, used during the emission of `Inst::ReturnCallKnown` and
+    /// `Inst::ReturnCallUnknown` instructions.
+    frame_layout: FrameLayout,
 }
 
 impl MachInstEmitState<Inst> for EmitState {
     fn new(abi: &Callee<X64ABIMachineSpec>, ctrl_plane: ControlPlane) -> Self {
         EmitState {
-            virtual_sp_offset: 0,
-            nominal_sp_to_fp: abi.frame_size() as i64,
-            stack_map: None,
-            cur_srcloc: Default::default(),
+            user_stack_map: None,
             ctrl_plane,
+            frame_layout: abi.frame_layout().clone(),
         }
     }
 
-    fn pre_safepoint(&mut self, stack_map: StackMap) {
-        self.stack_map = Some(stack_map);
-    }
-
-    fn pre_sourceloc(&mut self, srcloc: RelSourceLoc) {
-        self.cur_srcloc = srcloc;
+    fn pre_safepoint(&mut self, user_stack_map: Option<ir::UserStackMap>) {
+        self.user_stack_map = user_stack_map;
     }
 
     fn ctrl_plane_mut(&mut self) -> &mut ControlPlane {
@@ -44,29 +38,18 @@ impl MachInstEmitState<Inst> for EmitState {
     fn take_ctrl_plane(self) -> ControlPlane {
         self.ctrl_plane
     }
+
+    fn frame_layout(&self) -> &FrameLayout {
+        &self.frame_layout
+    }
 }
 
 impl EmitState {
-    pub(crate) fn take_stack_map(&mut self) -> Option<StackMap> {
-        self.stack_map.take()
+    pub(crate) fn take_stack_map(&mut self) -> Option<ir::UserStackMap> {
+        self.user_stack_map.take()
     }
 
     pub(crate) fn clear_post_insn(&mut self) {
-        self.stack_map = None;
-    }
-
-    pub(crate) fn virtual_sp_offset(&self) -> i64 {
-        self.virtual_sp_offset
-    }
-
-    pub(crate) fn adjust_virtual_sp_offset(&mut self, amount: i64) {
-        let old = self.virtual_sp_offset;
-        let new = self.virtual_sp_offset + amount;
-        trace!("adjust virtual sp offset by {amount:#x}: {old:#x} -> {new:#x}",);
-        self.virtual_sp_offset = new;
-    }
-
-    pub(crate) fn nominal_sp_to_fp(&self) -> i64 {
-        self.nominal_sp_to_fp
+        self.user_stack_map = None;
     }
 }
diff --git a/cranelift/codegen/src/isa/x64/inst/emit_tests.rs b/cranelift/codegen/src/isa/x64/inst/emit_tests.rs
index 147f61deb832..cf2150fc356c 100644
--- a/cranelift/codegen/src/isa/x64/inst/emit_tests.rs
+++ b/cranelift/codegen/src/isa/x64/inst/emit_tests.rs
@@ -15,7 +15,6 @@
 use super::*;
 use crate::ir::{MemFlags, UserExternalNameRef};
 use crate::isa::x64;
-use alloc::boxed::Box;
 use alloc::vec::Vec;
 use cranelift_entity::EntityRef as _;
 
@@ -24,7 +23,7 @@ impl Inst {
         debug_assert_eq!(src.to_reg().class(), RegClass::Int);
         Inst::Neg {
             size,
-            src: Gpr::new(src.to_reg()).unwrap(),
+            src: Gpr::unwrap_new(src.to_reg()),
             dst: WritableGpr::from_writable_reg(src).unwrap(),
         }
     }
@@ -34,7 +33,7 @@ impl Inst {
         debug_assert!(dst.to_reg().class() == RegClass::Float);
         Inst::XmmUnaryRmRImm {
             op,
-            src: XmmMemAligned::new(src).unwrap(),
+            src: XmmMemAligned::unwrap_new(src),
             imm,
             dst: WritableXmm::from_writable_reg(dst).unwrap(),
         }
@@ -45,7 +44,7 @@ impl Inst {
         debug_assert!(dst.to_reg().class() == RegClass::Float);
         Inst::XmmUnaryRmREvex {
             op,
-            src: XmmMem::new(src).unwrap(),
+            src: XmmMem::unwrap_new(src),
             dst: WritableXmm::from_writable_reg(dst).unwrap(),
         }
     }
@@ -55,46 +54,42 @@ impl Inst {
         debug_assert!(dst.to_reg().class() == RegClass::Float);
         Inst::XmmRmiReg {
             opcode,
-            src1: Xmm::new(dst.to_reg()).unwrap(),
-            src2: XmmMemAlignedImm::new(src).unwrap(),
+            src1: Xmm::unwrap_new(dst.to_reg()),
+            src2: XmmMemAlignedImm::unwrap_new(src),
             dst: WritableXmm::from_writable_reg(dst).unwrap(),
         }
     }
 
-    fn mul_hi(size: OperandSize, signed: bool, rhs: RegMem) -> Inst {
-        debug_assert!(size.is_one_of(&[
-            OperandSize::Size16,
-            OperandSize::Size32,
-            OperandSize::Size64
-        ]));
-        rhs.assert_regclass_is(RegClass::Int);
-        Inst::MulHi {
-            size,
-            signed,
-            src1: Gpr::new(regs::rax()).unwrap(),
-            src2: GprMem::new(rhs).unwrap(),
-            dst_lo: WritableGpr::from_reg(Gpr::new(regs::rax()).unwrap()),
-            dst_hi: WritableGpr::from_reg(Gpr::new(regs::rdx()).unwrap()),
-        }
-    }
-
-    fn umul_lo(size: OperandSize, operand: RegMem) -> Inst {
-        Inst::UMulLo {
-            size,
-            src1: Gpr::new(regs::rax()).unwrap(),
-            src2: GprMem::new(operand).unwrap(),
-            dst: WritableGpr::from_reg(Gpr::new(regs::rax()).unwrap()),
-        }
-    }
-
     fn xmm_rm_r_evex(op: Avx512Opcode, src1: Reg, src2: RegMem, dst: Writable<Reg>) -> Self {
+        debug_assert_ne!(op, Avx512Opcode::Vpermi2b);
         src2.assert_regclass_is(RegClass::Float);
         debug_assert!(src1.class() == RegClass::Float);
         debug_assert!(dst.to_reg().class() == RegClass::Float);
         Inst::XmmRmREvex {
             op,
-            src1: Xmm::new(src1).unwrap(),
-            src2: XmmMem::new(src2).unwrap(),
+            src1: Xmm::unwrap_new(src1),
+            src2: XmmMem::unwrap_new(src2),
+            dst: WritableXmm::from_writable_reg(dst).unwrap(),
+        }
+    }
+
+    fn xmm_rm_r_evex3(
+        op: Avx512Opcode,
+        src1: Reg,
+        src2: Reg,
+        src3: RegMem,
+        dst: Writable<Reg>,
+    ) -> Self {
+        debug_assert_eq!(op, Avx512Opcode::Vpermi2b);
+        src3.assert_regclass_is(RegClass::Float);
+        debug_assert!(src1.class() == RegClass::Float);
+        debug_assert!(src2.class() == RegClass::Float);
+        debug_assert!(dst.to_reg().class() == RegClass::Float);
+        Inst::XmmRmREvex3 {
+            op,
+            src1: Xmm::unwrap_new(src1),
+            src2: Xmm::unwrap_new(src2),
+            src3: XmmMem::unwrap_new(src3),
             dst: WritableXmm::from_writable_reg(dst).unwrap(),
         }
     }
@@ -105,7 +100,7 @@ impl Inst {
         debug_assert!(dst.to_reg().class() == RegClass::Float);
         Inst::XmmUnaryRmR {
             op,
-            src: XmmMemAligned::new(src).unwrap(),
+            src: XmmMemAligned::unwrap_new(src),
             dst: WritableXmm::from_writable_reg(dst).unwrap(),
         }
     }
@@ -118,7 +113,7 @@ impl Inst {
 
     fn bswap(size: OperandSize, dst: Writable<Reg>) -> Inst {
         debug_assert!(dst.to_reg().class() == RegClass::Int);
-        let src = Gpr::new(dst.to_reg()).unwrap();
+        let src = Gpr::unwrap_new(dst.to_reg());
         let dst = WritableGpr::from_writable_reg(dst).unwrap();
         Inst::Bswap { size, src, dst }
     }
@@ -144,9 +139,9 @@ impl Inst {
     fn xmm_rm_r_blend(op: SseOpcode, src2: RegMem, dst: Writable<Reg>) -> Inst {
         Inst::XmmRmRBlend {
             op,
-            src1: Xmm::new(dst.to_reg()).unwrap(),
-            src2: XmmMemAligned::new(src2).unwrap(),
-            mask: Xmm::new(regs::xmm0()).unwrap(),
+            src1: Xmm::unwrap_new(dst.to_reg()),
+            src2: XmmMemAligned::unwrap_new(src2),
+            mask: Xmm::unwrap_new(regs::xmm0()),
             dst: WritableXmm::from_writable_reg(dst).unwrap(),
         }
     }
@@ -819,7 +814,7 @@ fn test_x64_emit() {
     // Addr_IRRS, offset max simm8
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(127, Gpr::new(rax).unwrap(), Gpr::new(rax).unwrap(), 0),
+            Amode::imm_reg_reg_shift(127, Gpr::unwrap_new(rax), Gpr::unwrap_new(rax), 0),
             w_r11,
         ),
         "4C8B5C007F",
@@ -827,7 +822,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(127, Gpr::new(rdi).unwrap(), Gpr::new(rax).unwrap(), 1),
+            Amode::imm_reg_reg_shift(127, Gpr::unwrap_new(rdi), Gpr::unwrap_new(rax), 1),
             w_r11,
         ),
         "4C8B5C477F",
@@ -835,7 +830,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(127, Gpr::new(r8).unwrap(), Gpr::new(rax).unwrap(), 2),
+            Amode::imm_reg_reg_shift(127, Gpr::unwrap_new(r8), Gpr::unwrap_new(rax), 2),
             w_r11,
         ),
         "4D8B5C807F",
@@ -843,7 +838,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(127, Gpr::new(r15).unwrap(), Gpr::new(rax).unwrap(), 3),
+            Amode::imm_reg_reg_shift(127, Gpr::unwrap_new(r15), Gpr::unwrap_new(rax), 3),
             w_r11,
         ),
         "4D8B5CC77F",
@@ -851,7 +846,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(127, Gpr::new(rax).unwrap(), Gpr::new(rdi).unwrap(), 3),
+            Amode::imm_reg_reg_shift(127, Gpr::unwrap_new(rax), Gpr::unwrap_new(rdi), 3),
             w_r11,
         ),
         "4C8B5CF87F",
@@ -859,7 +854,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(127, Gpr::new(rdi).unwrap(), Gpr::new(rdi).unwrap(), 2),
+            Amode::imm_reg_reg_shift(127, Gpr::unwrap_new(rdi), Gpr::unwrap_new(rdi), 2),
             w_r11,
         ),
         "4C8B5CBF7F",
@@ -867,7 +862,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(127, Gpr::new(r8).unwrap(), Gpr::new(rdi).unwrap(), 1),
+            Amode::imm_reg_reg_shift(127, Gpr::unwrap_new(r8), Gpr::unwrap_new(rdi), 1),
             w_r11,
         ),
         "4D8B5C787F",
@@ -875,7 +870,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(127, Gpr::new(r15).unwrap(), Gpr::new(rdi).unwrap(), 0),
+            Amode::imm_reg_reg_shift(127, Gpr::unwrap_new(r15), Gpr::unwrap_new(rdi), 0),
             w_r11,
         ),
         "4D8B5C3F7F",
@@ -886,7 +881,7 @@ fn test_x64_emit() {
     // Addr_IRRS, offset min simm8
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(-128i32, Gpr::new(rax).unwrap(), Gpr::new(r8).unwrap(), 2),
+            Amode::imm_reg_reg_shift(-128i32, Gpr::unwrap_new(rax), Gpr::unwrap_new(r8), 2),
             w_r11,
         ),
         "4E8B5C8080",
@@ -894,7 +889,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(-128i32, Gpr::new(rdi).unwrap(), Gpr::new(r8).unwrap(), 3),
+            Amode::imm_reg_reg_shift(-128i32, Gpr::unwrap_new(rdi), Gpr::unwrap_new(r8), 3),
             w_r11,
         ),
         "4E8B5CC780",
@@ -902,7 +897,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(-128i32, Gpr::new(r8).unwrap(), Gpr::new(r8).unwrap(), 0),
+            Amode::imm_reg_reg_shift(-128i32, Gpr::unwrap_new(r8), Gpr::unwrap_new(r8), 0),
             w_r11,
         ),
         "4F8B5C0080",
@@ -910,7 +905,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(-128i32, Gpr::new(r15).unwrap(), Gpr::new(r8).unwrap(), 1),
+            Amode::imm_reg_reg_shift(-128i32, Gpr::unwrap_new(r15), Gpr::unwrap_new(r8), 1),
             w_r11,
         ),
         "4F8B5C4780",
@@ -918,7 +913,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(-128i32, Gpr::new(rax).unwrap(), Gpr::new(r15).unwrap(), 1),
+            Amode::imm_reg_reg_shift(-128i32, Gpr::unwrap_new(rax), Gpr::unwrap_new(r15), 1),
             w_r11,
         ),
         "4E8B5C7880",
@@ -926,7 +921,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(-128i32, Gpr::new(rdi).unwrap(), Gpr::new(r15).unwrap(), 0),
+            Amode::imm_reg_reg_shift(-128i32, Gpr::unwrap_new(rdi), Gpr::unwrap_new(r15), 0),
             w_r11,
         ),
         "4E8B5C3F80",
@@ -934,7 +929,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(-128i32, Gpr::new(r8).unwrap(), Gpr::new(r15).unwrap(), 3),
+            Amode::imm_reg_reg_shift(-128i32, Gpr::unwrap_new(r8), Gpr::unwrap_new(r15), 3),
             w_r11,
         ),
         "4F8B5CF880",
@@ -942,7 +937,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(-128i32, Gpr::new(r15).unwrap(), Gpr::new(r15).unwrap(), 2),
+            Amode::imm_reg_reg_shift(-128i32, Gpr::unwrap_new(r15), Gpr::unwrap_new(r15), 2),
             w_r11,
         ),
         "4F8B5CBF80",
@@ -953,12 +948,7 @@ fn test_x64_emit() {
     // Addr_IRRS, offset large positive simm32
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(
-                0x4f6625be,
-                Gpr::new(rax).unwrap(),
-                Gpr::new(rax).unwrap(),
-                0,
-            ),
+            Amode::imm_reg_reg_shift(0x4f6625be, Gpr::unwrap_new(rax), Gpr::unwrap_new(rax), 0),
             w_r11,
         ),
         "4C8B9C00BE25664F",
@@ -966,12 +956,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(
-                0x4f6625be,
-                Gpr::new(rdi).unwrap(),
-                Gpr::new(rax).unwrap(),
-                1,
-            ),
+            Amode::imm_reg_reg_shift(0x4f6625be, Gpr::unwrap_new(rdi), Gpr::unwrap_new(rax), 1),
             w_r11,
         ),
         "4C8B9C47BE25664F",
@@ -979,7 +964,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(0x4f6625be, Gpr::new(r8).unwrap(), Gpr::new(rax).unwrap(), 2),
+            Amode::imm_reg_reg_shift(0x4f6625be, Gpr::unwrap_new(r8), Gpr::unwrap_new(rax), 2),
             w_r11,
         ),
         "4D8B9C80BE25664F",
@@ -987,12 +972,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(
-                0x4f6625be,
-                Gpr::new(r15).unwrap(),
-                Gpr::new(rax).unwrap(),
-                3,
-            ),
+            Amode::imm_reg_reg_shift(0x4f6625be, Gpr::unwrap_new(r15), Gpr::unwrap_new(rax), 3),
             w_r11,
         ),
         "4D8B9CC7BE25664F",
@@ -1000,12 +980,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(
-                0x4f6625be,
-                Gpr::new(rax).unwrap(),
-                Gpr::new(rdi).unwrap(),
-                3,
-            ),
+            Amode::imm_reg_reg_shift(0x4f6625be, Gpr::unwrap_new(rax), Gpr::unwrap_new(rdi), 3),
             w_r11,
         ),
         "4C8B9CF8BE25664F",
@@ -1013,12 +988,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(
-                0x4f6625be,
-                Gpr::new(rdi).unwrap(),
-                Gpr::new(rdi).unwrap(),
-                2,
-            ),
+            Amode::imm_reg_reg_shift(0x4f6625be, Gpr::unwrap_new(rdi), Gpr::unwrap_new(rdi), 2),
             w_r11,
         ),
         "4C8B9CBFBE25664F",
@@ -1026,7 +996,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(0x4f6625be, Gpr::new(r8).unwrap(), Gpr::new(rdi).unwrap(), 1),
+            Amode::imm_reg_reg_shift(0x4f6625be, Gpr::unwrap_new(r8), Gpr::unwrap_new(rdi), 1),
             w_r11,
         ),
         "4D8B9C78BE25664F",
@@ -1034,12 +1004,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(
-                0x4f6625be,
-                Gpr::new(r15).unwrap(),
-                Gpr::new(rdi).unwrap(),
-                0,
-            ),
+            Amode::imm_reg_reg_shift(0x4f6625be, Gpr::unwrap_new(r15), Gpr::unwrap_new(rdi), 0),
             w_r11,
         ),
         "4D8B9C3FBE25664F",
@@ -1050,12 +1015,7 @@ fn test_x64_emit() {
     // Addr_IRRS, offset large negative simm32
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(
-                -0x264d1690i32,
-                Gpr::new(rax).unwrap(),
-                Gpr::new(r8).unwrap(),
-                2,
-            ),
+            Amode::imm_reg_reg_shift(-0x264d1690i32, Gpr::unwrap_new(rax), Gpr::unwrap_new(r8), 2),
             w_r11,
         ),
         "4E8B9C8070E9B2D9",
@@ -1063,12 +1023,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(
-                -0x264d1690i32,
-                Gpr::new(rdi).unwrap(),
-                Gpr::new(r8).unwrap(),
-                3,
-            ),
+            Amode::imm_reg_reg_shift(-0x264d1690i32, Gpr::unwrap_new(rdi), Gpr::unwrap_new(r8), 3),
             w_r11,
         ),
         "4E8B9CC770E9B2D9",
@@ -1076,12 +1031,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(
-                -0x264d1690i32,
-                Gpr::new(r8).unwrap(),
-                Gpr::new(r8).unwrap(),
-                0,
-            ),
+            Amode::imm_reg_reg_shift(-0x264d1690i32, Gpr::unwrap_new(r8), Gpr::unwrap_new(r8), 0),
             w_r11,
         ),
         "4F8B9C0070E9B2D9",
@@ -1089,12 +1039,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(
-                -0x264d1690i32,
-                Gpr::new(r15).unwrap(),
-                Gpr::new(r8).unwrap(),
-                1,
-            ),
+            Amode::imm_reg_reg_shift(-0x264d1690i32, Gpr::unwrap_new(r15), Gpr::unwrap_new(r8), 1),
             w_r11,
         ),
         "4F8B9C4770E9B2D9",
@@ -1104,8 +1049,8 @@ fn test_x64_emit() {
         Inst::mov64_m_r(
             Amode::imm_reg_reg_shift(
                 -0x264d1690i32,
-                Gpr::new(rax).unwrap(),
-                Gpr::new(r15).unwrap(),
+                Gpr::unwrap_new(rax),
+                Gpr::unwrap_new(r15),
                 1,
             ),
             w_r11,
@@ -1117,8 +1062,8 @@ fn test_x64_emit() {
         Inst::mov64_m_r(
             Amode::imm_reg_reg_shift(
                 -0x264d1690i32,
-                Gpr::new(rdi).unwrap(),
-                Gpr::new(r15).unwrap(),
+                Gpr::unwrap_new(rdi),
+                Gpr::unwrap_new(r15),
                 0,
             ),
             w_r11,
@@ -1128,12 +1073,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(
-                -0x264d1690i32,
-                Gpr::new(r8).unwrap(),
-                Gpr::new(r15).unwrap(),
-                3,
-            ),
+            Amode::imm_reg_reg_shift(-0x264d1690i32, Gpr::unwrap_new(r8), Gpr::unwrap_new(r15), 3),
             w_r11,
         ),
         "4F8B9CF870E9B2D9",
@@ -1143,8 +1083,8 @@ fn test_x64_emit() {
         Inst::mov64_m_r(
             Amode::imm_reg_reg_shift(
                 -0x264d1690i32,
-                Gpr::new(r15).unwrap(),
-                Gpr::new(r15).unwrap(),
+                Gpr::unwrap_new(r15),
+                Gpr::unwrap_new(r15),
                 2,
             ),
             w_r11,
@@ -1352,157 +1292,6 @@ fn test_x64_emit() {
         "4C31FA",
         "xorq    %rdx, %r15, %rdx",
     ));
-    // Test all mul cases, though
-    insns.push((
-        Inst::alu_rmi_r(
-            OperandSize::Size64,
-            AluRmiROpcode::Mul,
-            RegMemImm::reg(r15),
-            w_rdx,
-        ),
-        "490FAFD7",
-        "imulq   %rdx, %r15, %rdx",
-    ));
-    insns.push((
-        Inst::alu_rmi_r(
-            OperandSize::Size32,
-            AluRmiROpcode::Mul,
-            RegMemImm::reg(rcx),
-            w_r8,
-        ),
-        "440FAFC1",
-        "imull   %r8d, %ecx, %r8d",
-    ));
-    insns.push((
-        Inst::alu_rmi_r(
-            OperandSize::Size32,
-            AluRmiROpcode::Mul,
-            RegMemImm::reg(rcx),
-            w_rsi,
-        ),
-        "0FAFF1",
-        "imull   %esi, %ecx, %esi",
-    ));
-    insns.push((
-        Inst::alu_rmi_r(
-            OperandSize::Size64,
-            AluRmiROpcode::Mul,
-            RegMemImm::mem(Amode::imm_reg(99, rdi)),
-            w_rdx,
-        ),
-        "480FAF5763",
-        "imulq   %rdx, 99(%rdi), %rdx",
-    ));
-    insns.push((
-        Inst::alu_rmi_r(
-            OperandSize::Size32,
-            AluRmiROpcode::Mul,
-            RegMemImm::mem(Amode::imm_reg(99, rdi)),
-            w_r8,
-        ),
-        "440FAF4763",
-        "imull   %r8d, 99(%rdi), %r8d",
-    ));
-    insns.push((
-        Inst::alu_rmi_r(
-            OperandSize::Size32,
-            AluRmiROpcode::Mul,
-            RegMemImm::mem(Amode::imm_reg(99, rdi)),
-            w_rsi,
-        ),
-        "0FAF7763",
-        "imull   %esi, 99(%rdi), %esi",
-    ));
-    insns.push((
-        Inst::alu_rmi_r(
-            OperandSize::Size64,
-            AluRmiROpcode::Mul,
-            RegMemImm::imm(-127i32 as u32),
-            w_rdx,
-        ),
-        "486BD281",
-        "imulq   %rdx, $-127, %rdx",
-    ));
-    insns.push((
-        Inst::alu_rmi_r(
-            OperandSize::Size64,
-            AluRmiROpcode::Mul,
-            RegMemImm::imm(-129i32 as u32),
-            w_rdx,
-        ),
-        "4869D27FFFFFFF",
-        "imulq   %rdx, $-129, %rdx",
-    ));
-    insns.push((
-        Inst::alu_rmi_r(
-            OperandSize::Size64,
-            AluRmiROpcode::Mul,
-            RegMemImm::imm(76543210),
-            w_rdx,
-        ),
-        "4869D2EAF48F04",
-        "imulq   %rdx, $76543210, %rdx",
-    ));
-    insns.push((
-        Inst::alu_rmi_r(
-            OperandSize::Size32,
-            AluRmiROpcode::Mul,
-            RegMemImm::imm(-127i32 as u32),
-            w_r8,
-        ),
-        "456BC081",
-        "imull   %r8d, $-127, %r8d",
-    ));
-    insns.push((
-        Inst::alu_rmi_r(
-            OperandSize::Size32,
-            AluRmiROpcode::Mul,
-            RegMemImm::imm(-129i32 as u32),
-            w_r8,
-        ),
-        "4569C07FFFFFFF",
-        "imull   %r8d, $-129, %r8d",
-    ));
-    insns.push((
-        Inst::alu_rmi_r(
-            OperandSize::Size32,
-            AluRmiROpcode::Mul,
-            RegMemImm::imm(-76543210i32 as u32),
-            w_r8,
-        ),
-        "4569C0160B70FB",
-        "imull   %r8d, $-76543210, %r8d",
-    ));
-    insns.push((
-        Inst::alu_rmi_r(
-            OperandSize::Size32,
-            AluRmiROpcode::Mul,
-            RegMemImm::imm(-127i32 as u32),
-            w_rsi,
-        ),
-        "6BF681",
-        "imull   %esi, $-127, %esi",
-    ));
-    insns.push((
-        Inst::alu_rmi_r(
-            OperandSize::Size32,
-            AluRmiROpcode::Mul,
-            RegMemImm::imm(-129i32 as u32),
-            w_rsi,
-        ),
-        "69F67FFFFFFF",
-        "imull   %esi, $-129, %esi",
-    ));
-    insns.push((
-        Inst::alu_rmi_r(
-            OperandSize::Size32,
-            AluRmiROpcode::Mul,
-            RegMemImm::imm(76543210),
-            w_rsi,
-        ),
-        "69F6EAF48F04",
-        "imull   %esi, $76543210, %esi",
-    ));
 
     insns.push((
         Inst::alu_rmi_r(
@@ -1585,88 +1374,6 @@ fn test_x64_emit() {
         "andw    %r14w, $-512, %r14w",
     ));
 
-    insns.push((
-        Inst::alu_rmi_r(
-            OperandSize::Size16,
-            AluRmiROpcode::Mul,
-            RegMemImm::imm(10),
-            w_rax,
-        ),
-        "666BC00A",
-        "imulw   %ax, $10, %ax",
-    ));
-    insns.push((
-        Inst::alu_rmi_r(
-            OperandSize::Size16,
-            AluRmiROpcode::Mul,
-            RegMemImm::imm(-512i32 as u32),
-            w_rax,
-        ),
-        "6669C000FE",
-        "imulw   %ax, $-512, %ax",
-    ));
-    insns.push((
-        Inst::alu_rmi_r(
-            OperandSize::Size16,
-            AluRmiROpcode::Mul,
-            RegMemImm::imm(10),
-            w_r11,
-        ),
-        "66456BDB0A",
-        "imulw   %r11w, $10, %r11w",
-    ));
-    insns.push((
-        Inst::alu_rmi_r(
-            OperandSize::Size16,
-            AluRmiROpcode::Mul,
-            RegMemImm::imm(-512i32 as u32),
-            w_r11,
-        ),
-        "664569DB00FE",
-        "imulw   %r11w, $-512, %r11w",
-    ));
-
-    insns.push((
-        Inst::alu_rmi_r(
-            OperandSize::Size16,
-            AluRmiROpcode::Mul,
-            RegMemImm::reg(rdx),
-            w_rax,
-        ),
-        "660FAFC2",
-        "imulw   %ax, %dx, %ax",
-    ));
-    insns.push((
-        Inst::alu_rmi_r(
-            OperandSize::Size16,
-            AluRmiROpcode::Mul,
-            RegMemImm::reg(r12),
-            w_rax,
-        ),
-        "66410FAFC4",
-        "imulw   %ax, %r12w, %ax",
-    ));
-    insns.push((
-        Inst::alu_rmi_r(
-            OperandSize::Size16,
-            AluRmiROpcode::Mul,
-            RegMemImm::reg(rdx),
-            w_r11,
-        ),
-        "66440FAFDA",
-        "imulw   %r11w, %dx, %r11w",
-    ));
-    insns.push((
-        Inst::alu_rmi_r(
-            OperandSize::Size16,
-            AluRmiROpcode::Mul,
-            RegMemImm::reg(r12),
-            w_r11,
-        ),
-        "66450FAFDC",
-        "imulw   %r11w, %r12w, %r11w",
-    ));
-
     insns.push((
         Inst::alu_rmi_r(
             OperandSize::Size8,
@@ -1870,47 +1577,55 @@ fn test_x64_emit() {
         "4520FF",
         "andb    %r15b, %r15b, %r15b",
     ));
-
-    // the 8bit imul has rax as fixed dst
     insns.push((
         Inst::alu_rmi_r(
-            OperandSize::Size8,
-            AluRmiROpcode::Mul,
-            RegMemImm::reg(rcx),
-            w_rax,
+            OperandSize::Size32,
+            AluRmiROpcode::Sbb,
+            RegMemImm::reg(r14),
+            w_r15,
         ),
-        "F6E9",
-        "imulb   %al, %cl, %al",
+        "4519F7",
+        "sbbl    %r15d, %r14d, %r15d",
     ));
     insns.push((
         Inst::alu_rmi_r(
-            OperandSize::Size8,
-            AluRmiROpcode::Mul,
-            RegMemImm::reg(rbp),
-            w_rax,
+            OperandSize::Size64,
+            AluRmiROpcode::Sbb,
+            RegMemImm::imm(0),
+            w_r15,
         ),
-        "40F6ED",
-        "imulb   %al, %bpl, %al",
+        "4983DF00",
+        "sbbq    %r15, $0, %r15",
     ));
     insns.push((
         Inst::alu_rmi_r(
-            OperandSize::Size8,
-            AluRmiROpcode::Mul,
-            RegMemImm::reg(r10),
-            w_rax,
+            OperandSize::Size64,
+            AluRmiROpcode::Adc,
+            RegMemImm::imm(0),
+            w_r15,
         ),
-        "41F6EA",
-        "imulb   %al, %r10b, %al",
+        "4983D700",
+        "adcq    %r15, $0, %r15",
     ));
     insns.push((
         Inst::alu_rmi_r(
-            OperandSize::Size8,
-            AluRmiROpcode::Mul,
-            RegMemImm::reg(r15),
-            w_rax,
+            OperandSize::Size64,
+            AluRmiROpcode::Adc,
+            RegMemImm::mem(Amode::imm_reg(99, rdi)),
+            w_r15,
         ),
-        "41F6EF",
-        "imulb   %al, %r15b, %al",
+        "4C137F63",
+        "adcq    %r15, 99(%rdi), %r15",
+    ));
+    insns.push((
+        Inst::alu_rmi_r(
+            OperandSize::Size64,
+            AluRmiROpcode::Sbb,
+            RegMemImm::mem(Amode::imm_reg(99, rdi)),
+            w_r15,
+        ),
+        "4C1B7F63",
+        "sbbq    %r15, 99(%rdi), %r15",
     ));
 
     // ========================================================
@@ -1921,7 +1636,7 @@ fn test_x64_emit() {
             size: OperandSize::Size32,
             op: AluRmiROpcode::Add,
             src1_dst: Amode::imm_reg(99, rdi).into(),
-            src2: Gpr::new(r12).unwrap(),
+            src2: Gpr::unwrap_new(r12),
         },
         "44016763",
         "addl    %r12d, 99(%rdi)",
@@ -1931,14 +1646,9 @@ fn test_x64_emit() {
         Inst::AluRM {
             size: OperandSize::Size64,
             op: AluRmiROpcode::Add,
-            src1_dst: Amode::imm_reg_reg_shift(
-                0,
-                Gpr::new(rbp).unwrap(),
-                Gpr::new(rax).unwrap(),
-                3,
-            )
-            .into(),
-            src2: Gpr::new(rax).unwrap(),
+            src1_dst: Amode::imm_reg_reg_shift(0, Gpr::unwrap_new(rbp), Gpr::unwrap_new(rax), 3)
+                .into(),
+            src2: Gpr::unwrap_new(rax),
         },
         "480144C500",
         "addq    %rax, 0(%rbp,%rax,8)",
@@ -1949,7 +1659,7 @@ fn test_x64_emit() {
             size: OperandSize::Size32,
             op: AluRmiROpcode::Sub,
             src1_dst: Amode::imm_reg(0, rsp).into(),
-            src2: Gpr::new(rcx).unwrap(),
+            src2: Gpr::unwrap_new(rcx),
         },
         "290C24",
         "subl    %ecx, 0(%rsp)",
@@ -1960,7 +1670,7 @@ fn test_x64_emit() {
             size: OperandSize::Size64,
             op: AluRmiROpcode::Sub,
             src1_dst: Amode::imm_reg(0, rbp).into(),
-            src2: Gpr::new(rax).unwrap(),
+            src2: Gpr::unwrap_new(rax),
         },
         "48294500",
         "subq    %rax, 0(%rbp)",
@@ -1971,7 +1681,7 @@ fn test_x64_emit() {
             size: OperandSize::Size32,
             op: AluRmiROpcode::And,
             src1_dst: Amode::imm_reg(0, rsp).into(),
-            src2: Gpr::new(rcx).unwrap(),
+            src2: Gpr::unwrap_new(rcx),
         },
         "210C24",
         "andl    %ecx, 0(%rsp)",
@@ -1982,7 +1692,7 @@ fn test_x64_emit() {
             size: OperandSize::Size64,
             op: AluRmiROpcode::And,
             src1_dst: Amode::imm_reg(0, rbp).into(),
-            src2: Gpr::new(rax).unwrap(),
+            src2: Gpr::unwrap_new(rax),
         },
         "48214500",
         "andq    %rax, 0(%rbp)",
@@ -1993,7 +1703,7 @@ fn test_x64_emit() {
             size: OperandSize::Size32,
             op: AluRmiROpcode::Or,
             src1_dst: Amode::imm_reg(0, rsp).into(),
-            src2: Gpr::new(rcx).unwrap(),
+            src2: Gpr::unwrap_new(rcx),
         },
         "090C24",
         "orl     %ecx, 0(%rsp)",
@@ -2004,7 +1714,7 @@ fn test_x64_emit() {
             size: OperandSize::Size64,
             op: AluRmiROpcode::Or,
             src1_dst: Amode::imm_reg(0, rbp).into(),
-            src2: Gpr::new(rax).unwrap(),
+            src2: Gpr::unwrap_new(rax),
         },
         "48094500",
         "orq     %rax, 0(%rbp)",
@@ -2015,7 +1725,7 @@ fn test_x64_emit() {
             size: OperandSize::Size32,
             op: AluRmiROpcode::Xor,
             src1_dst: Amode::imm_reg(0, rsp).into(),
-            src2: Gpr::new(rcx).unwrap(),
+            src2: Gpr::unwrap_new(rcx),
         },
         "310C24",
         "xorl    %ecx, 0(%rsp)",
@@ -2026,7 +1736,7 @@ fn test_x64_emit() {
             size: OperandSize::Size64,
             op: AluRmiROpcode::Xor,
             src1_dst: Amode::imm_reg(0, rbp).into(),
-            src2: Gpr::new(rax).unwrap(),
+            src2: Gpr::unwrap_new(rax),
         },
         "48314500",
         "xorq    %rax, 0(%rbp)",
@@ -2037,7 +1747,7 @@ fn test_x64_emit() {
             size: OperandSize::Size16,
             op: AluRmiROpcode::Add,
             src1_dst: Amode::imm_reg(0, rbp).into(),
-            src2: Gpr::new(rax).unwrap(),
+            src2: Gpr::unwrap_new(rax),
         },
         "66014500",
         "addw    %ax, 0(%rbp)",
@@ -2047,7 +1757,7 @@ fn test_x64_emit() {
             size: OperandSize::Size16,
             op: AluRmiROpcode::Sub,
             src1_dst: Amode::imm_reg(0, rbp).into(),
-            src2: Gpr::new(r12).unwrap(),
+            src2: Gpr::unwrap_new(r12),
         },
         "6644296500",
         "subw    %r12w, 0(%rbp)",
@@ -2058,7 +1768,7 @@ fn test_x64_emit() {
             size: OperandSize::Size8,
             op: AluRmiROpcode::Add,
             src1_dst: Amode::imm_reg(0, rbp).into(),
-            src2: Gpr::new(rax).unwrap(),
+            src2: Gpr::unwrap_new(rax),
         },
         "004500",
         "addb    %al, 0(%rbp)",
@@ -2068,7 +1778,7 @@ fn test_x64_emit() {
             size: OperandSize::Size8,
             op: AluRmiROpcode::Sub,
             src1_dst: Amode::imm_reg(0, rbp).into(),
-            src2: Gpr::new(rbp).unwrap(),
+            src2: Gpr::unwrap_new(rbp),
         },
         "40286D00",
         "subb    %bpl, 0(%rbp)",
@@ -2078,7 +1788,7 @@ fn test_x64_emit() {
             size: OperandSize::Size8,
             op: AluRmiROpcode::Xor,
             src1_dst: Amode::imm_reg(0, rbp).into(),
-            src2: Gpr::new(r10).unwrap(),
+            src2: Gpr::unwrap_new(r10),
         },
         "44305500",
         "xorb    %r10b, 0(%rbp)",
@@ -2088,7 +1798,7 @@ fn test_x64_emit() {
             size: OperandSize::Size8,
             op: AluRmiROpcode::And,
             src1_dst: Amode::imm_reg(0, rbp).into(),
-            src2: Gpr::new(r15).unwrap(),
+            src2: Gpr::unwrap_new(r15),
         },
         "44207D00",
         "andb    %r15b, 0(%rbp)",
@@ -2192,10 +1902,10 @@ fn test_x64_emit() {
             DivSignedness::Signed,
             TrapCode::IntegerDivisionByZero,
             RegMem::reg(regs::rsi()),
-            Gpr::new(regs::rax()).unwrap(),
-            Gpr::new(regs::rdx()).unwrap(),
-            WritableGpr::from_reg(Gpr::new(regs::rax()).unwrap()),
-            WritableGpr::from_reg(Gpr::new(regs::rdx()).unwrap()),
+            Gpr::unwrap_new(regs::rax()),
+            Gpr::unwrap_new(regs::rdx()),
+            WritableGpr::from_reg(Gpr::unwrap_new(regs::rax())),
+            WritableGpr::from_reg(Gpr::unwrap_new(regs::rdx())),
         ),
         "F7FE",
         "idiv    %eax, %edx, %esi, %eax, %edx ; trap=int_divz",
@@ -2206,10 +1916,10 @@ fn test_x64_emit() {
             DivSignedness::Signed,
             TrapCode::IntegerDivisionByZero,
             RegMem::reg(regs::r15()),
-            Gpr::new(regs::rax()).unwrap(),
-            Gpr::new(regs::rdx()).unwrap(),
-            WritableGpr::from_reg(Gpr::new(regs::rax()).unwrap()),
-            WritableGpr::from_reg(Gpr::new(regs::rdx()).unwrap()),
+            Gpr::unwrap_new(regs::rax()),
+            Gpr::unwrap_new(regs::rdx()),
+            WritableGpr::from_reg(Gpr::unwrap_new(regs::rax())),
+            WritableGpr::from_reg(Gpr::unwrap_new(regs::rdx())),
         ),
         "49F7FF",
         "idiv    %rax, %rdx, %r15, %rax, %rdx ; trap=int_divz",
@@ -2220,10 +1930,10 @@ fn test_x64_emit() {
             DivSignedness::Unsigned,
             TrapCode::IntegerDivisionByZero,
             RegMem::reg(regs::r14()),
-            Gpr::new(regs::rax()).unwrap(),
-            Gpr::new(regs::rdx()).unwrap(),
-            WritableGpr::from_reg(Gpr::new(regs::rax()).unwrap()),
-            WritableGpr::from_reg(Gpr::new(regs::rdx()).unwrap()),
+            Gpr::unwrap_new(regs::rax()),
+            Gpr::unwrap_new(regs::rdx()),
+            WritableGpr::from_reg(Gpr::unwrap_new(regs::rax())),
+            WritableGpr::from_reg(Gpr::unwrap_new(regs::rdx())),
         ),
         "41F7F6",
         "div     %eax, %edx, %r14d, %eax, %edx ; trap=int_divz",
@@ -2234,10 +1944,10 @@ fn test_x64_emit() {
             DivSignedness::Unsigned,
             TrapCode::IntegerDivisionByZero,
             RegMem::reg(regs::rdi()),
-            Gpr::new(regs::rax()).unwrap(),
-            Gpr::new(regs::rdx()).unwrap(),
-            WritableGpr::from_reg(Gpr::new(regs::rax()).unwrap()),
-            WritableGpr::from_reg(Gpr::new(regs::rdx()).unwrap()),
+            Gpr::unwrap_new(regs::rax()),
+            Gpr::unwrap_new(regs::rdx()),
+            WritableGpr::from_reg(Gpr::unwrap_new(regs::rax())),
+            WritableGpr::from_reg(Gpr::unwrap_new(regs::rdx())),
         ),
         "48F7F7",
         "div     %rax, %rdx, %rdi, %rax, %rdx ; trap=int_divz",
@@ -2247,8 +1957,8 @@ fn test_x64_emit() {
             DivSignedness::Unsigned,
             TrapCode::IntegerDivisionByZero,
             RegMem::reg(regs::rax()),
-            Gpr::new(regs::rax()).unwrap(),
-            WritableGpr::from_reg(Gpr::new(regs::rax()).unwrap()),
+            Gpr::unwrap_new(regs::rax()),
+            WritableGpr::from_reg(Gpr::unwrap_new(regs::rax())),
         ),
         "F6F0",
         "div     %al, %al, %al ; trap=int_divz",
@@ -2258,105 +1968,13 @@ fn test_x64_emit() {
             DivSignedness::Unsigned,
             TrapCode::IntegerDivisionByZero,
             RegMem::reg(regs::rsi()),
-            Gpr::new(regs::rax()).unwrap(),
-            WritableGpr::from_reg(Gpr::new(regs::rax()).unwrap()),
+            Gpr::unwrap_new(regs::rax()),
+            WritableGpr::from_reg(Gpr::unwrap_new(regs::rax())),
         ),
         "40F6F6",
         "div     %al, %sil, %al ; trap=int_divz",
     ));
 
-    // ========================================================
-    // MulHi
-    insns.push((
-        Inst::mul_hi(
-            OperandSize::Size32,
-            true, /*signed*/
-            RegMem::reg(regs::rsi()),
-        ),
-        "F7EE",
-        "imul    %eax, %esi, %eax, %edx",
-    ));
-    insns.push((
-        Inst::mul_hi(
-            OperandSize::Size64,
-            true, /*signed*/
-            RegMem::reg(regs::r15()),
-        ),
-        "49F7EF",
-        "imul    %rax, %r15, %rax, %rdx",
-    ));
-    insns.push((
-        Inst::mul_hi(
-            OperandSize::Size32,
-            false, /*signed*/
-            RegMem::reg(regs::r14()),
-        ),
-        "41F7E6",
-        "mul     %eax, %r14d, %eax, %edx",
-    ));
-    insns.push((
-        Inst::mul_hi(
-            OperandSize::Size64,
-            false, /*signed*/
-            RegMem::reg(regs::rdi()),
-        ),
-        "48F7E7",
-        "mul     %rax, %rdi, %rax, %rdx",
-    ));
-
-    // ========================================================
-    // UMulLo
-    insns.push((
-        Inst::umul_lo(OperandSize::Size64, RegMem::reg(regs::rdx())),
-        "48F7E2",
-        "mulq    %rax, %rdx, %rax",
-    ));
-    insns.push((
-        Inst::umul_lo(OperandSize::Size64, RegMem::reg(regs::r12())),
-        "49F7E4",
-        "mulq    %rax, %r12, %rax",
-    ));
-    insns.push((
-        Inst::umul_lo(OperandSize::Size32, RegMem::reg(regs::rdx())),
-        "F7E2",
-        "mull    %eax, %edx, %eax",
-    ));
-    insns.push((
-        Inst::umul_lo(OperandSize::Size32, RegMem::reg(regs::r12())),
-        "41F7E4",
-        "mull    %eax, %r12d, %eax",
-    ));
-    insns.push((
-        Inst::umul_lo(OperandSize::Size16, RegMem::reg(regs::rdx())),
-        "66F7E2",
-        "mulw    %ax, %dx, %ax",
-    ));
-    insns.push((
-        Inst::umul_lo(OperandSize::Size16, RegMem::reg(regs::r12())),
-        "6641F7E4",
-        "mulw    %ax, %r12w, %ax",
-    ));
-    insns.push((
-        Inst::umul_lo(OperandSize::Size8, RegMem::reg(regs::rdx())),
-        "F6E2",
-        "mulb    %al, %dl, %al",
-    ));
-    insns.push((
-        Inst::umul_lo(OperandSize::Size8, RegMem::reg(regs::rdi())),
-        "40F6E7",
-        "mulb    %al, %dil, %al",
-    ));
-    insns.push((
-        Inst::umul_lo(OperandSize::Size8, RegMem::reg(regs::r9())),
-        "41F6E1",
-        "mulb    %al, %r9b, %al",
-    ));
-    insns.push((
-        Inst::umul_lo(OperandSize::Size8, RegMem::reg(regs::r12())),
-        "41F6E4",
-        "mulb    %al, %r12b, %al",
-    ));
-
     // ========================================================
     // Imm_R
     //
@@ -2601,7 +2219,7 @@ fn test_x64_emit() {
     // Mov64_M_R
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(179, Gpr::new(rax).unwrap(), Gpr::new(rbx).unwrap(), 0),
+            Amode::imm_reg_reg_shift(179, Gpr::unwrap_new(rax), Gpr::unwrap_new(rbx), 0),
             w_rcx,
         ),
         "488B8C18B3000000",
@@ -2609,7 +2227,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(179, Gpr::new(rax).unwrap(), Gpr::new(rbx).unwrap(), 0),
+            Amode::imm_reg_reg_shift(179, Gpr::unwrap_new(rax), Gpr::unwrap_new(rbx), 0),
             w_r8,
         ),
         "4C8B8418B3000000",
@@ -2617,7 +2235,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(179, Gpr::new(rax).unwrap(), Gpr::new(r9).unwrap(), 0),
+            Amode::imm_reg_reg_shift(179, Gpr::unwrap_new(rax), Gpr::unwrap_new(r9), 0),
             w_rcx,
         ),
         "4A8B8C08B3000000",
@@ -2625,7 +2243,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(179, Gpr::new(rax).unwrap(), Gpr::new(r9).unwrap(), 0),
+            Amode::imm_reg_reg_shift(179, Gpr::unwrap_new(rax), Gpr::unwrap_new(r9), 0),
             w_r8,
         ),
         "4E8B8408B3000000",
@@ -2633,7 +2251,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(179, Gpr::new(r10).unwrap(), Gpr::new(rbx).unwrap(), 0),
+            Amode::imm_reg_reg_shift(179, Gpr::unwrap_new(r10), Gpr::unwrap_new(rbx), 0),
             w_rcx,
         ),
         "498B8C1AB3000000",
@@ -2641,7 +2259,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(179, Gpr::new(r10).unwrap(), Gpr::new(rbx).unwrap(), 0),
+            Amode::imm_reg_reg_shift(179, Gpr::unwrap_new(r10), Gpr::unwrap_new(rbx), 0),
             w_r8,
         ),
         "4D8B841AB3000000",
@@ -2649,7 +2267,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(179, Gpr::new(r10).unwrap(), Gpr::new(r9).unwrap(), 0),
+            Amode::imm_reg_reg_shift(179, Gpr::unwrap_new(r10), Gpr::unwrap_new(r9), 0),
             w_rcx,
         ),
         "4B8B8C0AB3000000",
@@ -2657,7 +2275,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::mov64_m_r(
-            Amode::imm_reg_reg_shift(179, Gpr::new(r10).unwrap(), Gpr::new(r9).unwrap(), 0),
+            Amode::imm_reg_reg_shift(179, Gpr::unwrap_new(r10), Gpr::unwrap_new(r9), 0),
             w_r8,
         ),
         "4F8B840AB3000000",
@@ -2678,7 +2296,7 @@ fn test_x64_emit() {
     ));
     insns.push((
         Inst::lea(
-            Amode::imm_reg_reg_shift(179, Gpr::new(r10).unwrap(), Gpr::new(r9).unwrap(), 0),
+            Amode::imm_reg_reg_shift(179, Gpr::unwrap_new(r10), Gpr::unwrap_new(r9), 0),
             w_r8,
         ),
         "4F8D840AB3000000",
@@ -3305,7 +2923,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size32,
             ShiftKind::ShiftLeft,
-            Imm8Gpr::new(Imm8Reg::Reg { reg: regs::rcx() }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Reg { reg: regs::rcx() }),
             rdi,
             w_rdi,
         ),
@@ -3316,7 +2934,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size32,
             ShiftKind::ShiftLeft,
-            Imm8Gpr::new(Imm8Reg::Reg { reg: regs::rcx() }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Reg { reg: regs::rcx() }),
             r12,
             w_r12,
         ),
@@ -3327,7 +2945,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size32,
             ShiftKind::ShiftLeft,
-            Imm8Gpr::new(Imm8Reg::Imm8 { imm: 2 }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Imm8 { imm: 2 }),
             r8,
             w_r8,
         ),
@@ -3338,7 +2956,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size32,
             ShiftKind::ShiftLeft,
-            Imm8Gpr::new(Imm8Reg::Imm8 { imm: 31 }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Imm8 { imm: 31 }),
             r13,
             w_r13,
         ),
@@ -3349,7 +2967,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size64,
             ShiftKind::ShiftLeft,
-            Imm8Gpr::new(Imm8Reg::Reg { reg: regs::rcx() }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Reg { reg: regs::rcx() }),
             r13,
             w_r13,
         ),
@@ -3360,7 +2978,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size64,
             ShiftKind::ShiftLeft,
-            Imm8Gpr::new(Imm8Reg::Reg { reg: regs::rcx() }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Reg { reg: regs::rcx() }),
             rdi,
             w_rdi,
         ),
@@ -3371,7 +2989,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size64,
             ShiftKind::ShiftLeft,
-            Imm8Gpr::new(Imm8Reg::Imm8 { imm: 2 }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Imm8 { imm: 2 }),
             r8,
             w_r8,
         ),
@@ -3382,7 +3000,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size64,
             ShiftKind::ShiftLeft,
-            Imm8Gpr::new(Imm8Reg::Imm8 { imm: 3 }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Imm8 { imm: 3 }),
             rbx,
             w_rbx,
         ),
@@ -3393,7 +3011,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size64,
             ShiftKind::ShiftLeft,
-            Imm8Gpr::new(Imm8Reg::Imm8 { imm: 63 }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Imm8 { imm: 63 }),
             r13,
             w_r13,
         ),
@@ -3404,7 +3022,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size32,
             ShiftKind::ShiftRightLogical,
-            Imm8Gpr::new(Imm8Reg::Reg { reg: regs::rcx() }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Reg { reg: regs::rcx() }),
             rdi,
             w_rdi,
         ),
@@ -3415,7 +3033,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size32,
             ShiftKind::ShiftRightLogical,
-            Imm8Gpr::new(Imm8Reg::Imm8 { imm: 2 }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Imm8 { imm: 2 }),
             r8,
             w_r8,
         ),
@@ -3426,7 +3044,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size32,
             ShiftKind::ShiftRightLogical,
-            Imm8Gpr::new(Imm8Reg::Imm8 { imm: 31 }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Imm8 { imm: 31 }),
             r13,
             w_r13,
         ),
@@ -3437,7 +3055,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size64,
             ShiftKind::ShiftRightLogical,
-            Imm8Gpr::new(Imm8Reg::Reg { reg: regs::rcx() }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Reg { reg: regs::rcx() }),
             rdi,
             w_rdi,
         ),
@@ -3448,7 +3066,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size64,
             ShiftKind::ShiftRightLogical,
-            Imm8Gpr::new(Imm8Reg::Imm8 { imm: 2 }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Imm8 { imm: 2 }),
             r8,
             w_r8,
         ),
@@ -3459,7 +3077,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size64,
             ShiftKind::ShiftRightLogical,
-            Imm8Gpr::new(Imm8Reg::Imm8 { imm: 63 }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Imm8 { imm: 63 }),
             r13,
             w_r13,
         ),
@@ -3470,7 +3088,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size32,
             ShiftKind::ShiftRightArithmetic,
-            Imm8Gpr::new(Imm8Reg::Reg { reg: regs::rcx() }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Reg { reg: regs::rcx() }),
             rdi,
             w_rdi,
         ),
@@ -3481,7 +3099,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size32,
             ShiftKind::ShiftRightArithmetic,
-            Imm8Gpr::new(Imm8Reg::Imm8 { imm: 2 }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Imm8 { imm: 2 }),
             r8,
             w_r8,
         ),
@@ -3492,7 +3110,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size32,
             ShiftKind::ShiftRightArithmetic,
-            Imm8Gpr::new(Imm8Reg::Imm8 { imm: 31 }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Imm8 { imm: 31 }),
             r13,
             w_r13,
         ),
@@ -3503,7 +3121,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size64,
             ShiftKind::ShiftRightArithmetic,
-            Imm8Gpr::new(Imm8Reg::Reg { reg: regs::rcx() }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Reg { reg: regs::rcx() }),
             rdi,
             w_rdi,
         ),
@@ -3514,7 +3132,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size64,
             ShiftKind::ShiftRightArithmetic,
-            Imm8Gpr::new(Imm8Reg::Imm8 { imm: 2 }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Imm8 { imm: 2 }),
             r8,
             w_r8,
         ),
@@ -3525,7 +3143,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size64,
             ShiftKind::ShiftRightArithmetic,
-            Imm8Gpr::new(Imm8Reg::Imm8 { imm: 63 }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Imm8 { imm: 63 }),
             r13,
             w_r13,
         ),
@@ -3536,7 +3154,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size64,
             ShiftKind::RotateLeft,
-            Imm8Gpr::new(Imm8Reg::Reg { reg: regs::rcx() }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Reg { reg: regs::rcx() }),
             r8,
             w_r8,
         ),
@@ -3547,7 +3165,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size32,
             ShiftKind::RotateLeft,
-            Imm8Gpr::new(Imm8Reg::Imm8 { imm: 3 }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Imm8 { imm: 3 }),
             r9,
             w_r9,
         ),
@@ -3558,7 +3176,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size32,
             ShiftKind::RotateRight,
-            Imm8Gpr::new(Imm8Reg::Reg { reg: regs::rcx() }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Reg { reg: regs::rcx() }),
             rsi,
             w_rsi,
         ),
@@ -3569,7 +3187,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size64,
             ShiftKind::RotateRight,
-            Imm8Gpr::new(Imm8Reg::Imm8 { imm: 5 }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Imm8 { imm: 5 }),
             r15,
             w_r15,
         ),
@@ -3580,7 +3198,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size8,
             ShiftKind::RotateRight,
-            Imm8Gpr::new(Imm8Reg::Reg { reg: regs::rcx() }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Reg { reg: regs::rcx() }),
             rsi,
             w_rsi,
         ),
@@ -3591,7 +3209,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size8,
             ShiftKind::RotateRight,
-            Imm8Gpr::new(Imm8Reg::Reg { reg: regs::rcx() }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Reg { reg: regs::rcx() }),
             rax,
             w_rax,
         ),
@@ -3602,7 +3220,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size8,
             ShiftKind::RotateRight,
-            Imm8Gpr::new(Imm8Reg::Imm8 { imm: 5 }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Imm8 { imm: 5 }),
             r15,
             w_r15,
         ),
@@ -3613,7 +3231,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size16,
             ShiftKind::RotateRight,
-            Imm8Gpr::new(Imm8Reg::Reg { reg: regs::rcx() }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Reg { reg: regs::rcx() }),
             rsi,
             w_rsi,
         ),
@@ -3624,7 +3242,7 @@ fn test_x64_emit() {
         Inst::shift_r(
             OperandSize::Size16,
             ShiftKind::RotateRight,
-            Imm8Gpr::new(Imm8Reg::Imm8 { imm: 5 }).unwrap(),
+            Imm8Gpr::unwrap_new(Imm8Reg::Imm8 { imm: 5 }),
             r15,
             w_r15,
         ),
@@ -3635,25 +3253,25 @@ fn test_x64_emit() {
     // ========================================================
     // CmpRMIR
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size64, RegMemImm::reg(r15), rdx),
+        Inst::cmp_rmi_r(OperandSize::Size64, rdx, RegMemImm::reg(r15)),
         "4C39FA",
         "cmpq    %r15, %rdx",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size64, RegMemImm::reg(rcx), r8),
+        Inst::cmp_rmi_r(OperandSize::Size64, r8, RegMemImm::reg(rcx)),
         "4939C8",
         "cmpq    %rcx, %r8",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size64, RegMemImm::reg(rcx), rsi),
+        Inst::cmp_rmi_r(OperandSize::Size64, rsi, RegMemImm::reg(rcx)),
         "4839CE",
         "cmpq    %rcx, %rsi",
     ));
     insns.push((
         Inst::cmp_rmi_r(
             OperandSize::Size64,
-            RegMemImm::mem(Amode::imm_reg(99, rdi)),
             rdx,
+            RegMemImm::mem(Amode::imm_reg(99, rdi)),
         ),
         "483B5763",
         "cmpq    99(%rdi), %rdx",
@@ -3661,8 +3279,8 @@ fn test_x64_emit() {
     insns.push((
         Inst::cmp_rmi_r(
             OperandSize::Size64,
-            RegMemImm::mem(Amode::imm_reg(99, rdi)),
             r8,
+            RegMemImm::mem(Amode::imm_reg(99, rdi)),
         ),
         "4C3B4763",
         "cmpq    99(%rdi), %r8",
@@ -3670,48 +3288,48 @@ fn test_x64_emit() {
     insns.push((
         Inst::cmp_rmi_r(
             OperandSize::Size64,
-            RegMemImm::mem(Amode::imm_reg(99, rdi)),
             rsi,
+            RegMemImm::mem(Amode::imm_reg(99, rdi)),
         ),
         "483B7763",
         "cmpq    99(%rdi), %rsi",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size64, RegMemImm::imm(76543210), rdx),
+        Inst::cmp_rmi_r(OperandSize::Size64, rdx, RegMemImm::imm(76543210)),
         "4881FAEAF48F04",
         "cmpq    $76543210, %rdx",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size64, RegMemImm::imm(-76543210i32 as u32), r8),
+        Inst::cmp_rmi_r(OperandSize::Size64, r8, RegMemImm::imm(-76543210i32 as u32)),
         "4981F8160B70FB",
         "cmpq    $-76543210, %r8",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size64, RegMemImm::imm(76543210), rsi),
+        Inst::cmp_rmi_r(OperandSize::Size64, rsi, RegMemImm::imm(76543210)),
         "4881FEEAF48F04",
         "cmpq    $76543210, %rsi",
     ));
     //
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size32, RegMemImm::reg(r15), rdx),
+        Inst::cmp_rmi_r(OperandSize::Size32, rdx, RegMemImm::reg(r15)),
         "4439FA",
         "cmpl    %r15d, %edx",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size32, RegMemImm::reg(rcx), r8),
+        Inst::cmp_rmi_r(OperandSize::Size32, r8, RegMemImm::reg(rcx)),
         "4139C8",
         "cmpl    %ecx, %r8d",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size32, RegMemImm::reg(rcx), rsi),
+        Inst::cmp_rmi_r(OperandSize::Size32, rsi, RegMemImm::reg(rcx)),
         "39CE",
         "cmpl    %ecx, %esi",
     ));
     insns.push((
         Inst::cmp_rmi_r(
             OperandSize::Size32,
-            RegMemImm::mem(Amode::imm_reg(99, rdi)),
             rdx,
+            RegMemImm::mem(Amode::imm_reg(99, rdi)),
         ),
         "3B5763",
         "cmpl    99(%rdi), %edx",
@@ -3719,8 +3337,8 @@ fn test_x64_emit() {
     insns.push((
         Inst::cmp_rmi_r(
             OperandSize::Size32,
-            RegMemImm::mem(Amode::imm_reg(99, rdi)),
             r8,
+            RegMemImm::mem(Amode::imm_reg(99, rdi)),
         ),
         "443B4763",
         "cmpl    99(%rdi), %r8d",
@@ -3728,48 +3346,48 @@ fn test_x64_emit() {
     insns.push((
         Inst::cmp_rmi_r(
             OperandSize::Size32,
-            RegMemImm::mem(Amode::imm_reg(99, rdi)),
             rsi,
+            RegMemImm::mem(Amode::imm_reg(99, rdi)),
         ),
         "3B7763",
         "cmpl    99(%rdi), %esi",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size32, RegMemImm::imm(76543210), rdx),
+        Inst::cmp_rmi_r(OperandSize::Size32, rdx, RegMemImm::imm(76543210)),
         "81FAEAF48F04",
         "cmpl    $76543210, %edx",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size32, RegMemImm::imm(-76543210i32 as u32), r8),
+        Inst::cmp_rmi_r(OperandSize::Size32, r8, RegMemImm::imm(-76543210i32 as u32)),
         "4181F8160B70FB",
         "cmpl    $-76543210, %r8d",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size32, RegMemImm::imm(76543210), rsi),
+        Inst::cmp_rmi_r(OperandSize::Size32, rsi, RegMemImm::imm(76543210)),
         "81FEEAF48F04",
         "cmpl    $76543210, %esi",
     ));
     //
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size16, RegMemImm::reg(r15), rdx),
+        Inst::cmp_rmi_r(OperandSize::Size16, rdx, RegMemImm::reg(r15)),
         "664439FA",
         "cmpw    %r15w, %dx",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size16, RegMemImm::reg(rcx), r8),
+        Inst::cmp_rmi_r(OperandSize::Size16, r8, RegMemImm::reg(rcx)),
         "664139C8",
         "cmpw    %cx, %r8w",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size16, RegMemImm::reg(rcx), rsi),
+        Inst::cmp_rmi_r(OperandSize::Size16, rsi, RegMemImm::reg(rcx)),
         "6639CE",
         "cmpw    %cx, %si",
     ));
     insns.push((
         Inst::cmp_rmi_r(
             OperandSize::Size16,
-            RegMemImm::mem(Amode::imm_reg(99, rdi)),
             rdx,
+            RegMemImm::mem(Amode::imm_reg(99, rdi)),
         ),
         "663B5763",
         "cmpw    99(%rdi), %dx",
@@ -3777,8 +3395,8 @@ fn test_x64_emit() {
     insns.push((
         Inst::cmp_rmi_r(
             OperandSize::Size16,
-            RegMemImm::mem(Amode::imm_reg(99, rdi)),
             r8,
+            RegMemImm::mem(Amode::imm_reg(99, rdi)),
         ),
         "66443B4763",
         "cmpw    99(%rdi), %r8w",
@@ -3786,48 +3404,48 @@ fn test_x64_emit() {
     insns.push((
         Inst::cmp_rmi_r(
             OperandSize::Size16,
-            RegMemImm::mem(Amode::imm_reg(99, rdi)),
             rsi,
+            RegMemImm::mem(Amode::imm_reg(99, rdi)),
         ),
         "663B7763",
         "cmpw    99(%rdi), %si",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size16, RegMemImm::imm(23210), rdx),
+        Inst::cmp_rmi_r(OperandSize::Size16, rdx, RegMemImm::imm(23210)),
         "6681FAAA5A",
         "cmpw    $23210, %dx",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size16, RegMemImm::imm(-7654i32 as u32), r8),
+        Inst::cmp_rmi_r(OperandSize::Size16, r8, RegMemImm::imm(-7654i32 as u32)),
         "664181F81AE2",
         "cmpw    $-7654, %r8w",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size16, RegMemImm::imm(7654), rsi),
+        Inst::cmp_rmi_r(OperandSize::Size16, rsi, RegMemImm::imm(7654)),
         "6681FEE61D",
         "cmpw    $7654, %si",
     ));
     //
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(r15), rdx),
+        Inst::cmp_rmi_r(OperandSize::Size8, rdx, RegMemImm::reg(r15)),
         "4438FA",
         "cmpb    %r15b, %dl",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(rcx), r8),
+        Inst::cmp_rmi_r(OperandSize::Size8, r8, RegMemImm::reg(rcx)),
         "4138C8",
         "cmpb    %cl, %r8b",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(rcx), rsi),
+        Inst::cmp_rmi_r(OperandSize::Size8, rsi, RegMemImm::reg(rcx)),
         "4038CE",
         "cmpb    %cl, %sil",
     ));
     insns.push((
         Inst::cmp_rmi_r(
             OperandSize::Size8,
-            RegMemImm::mem(Amode::imm_reg(99, rdi)),
             rdx,
+            RegMemImm::mem(Amode::imm_reg(99, rdi)),
         ),
         "3A5763",
         "cmpb    99(%rdi), %dl",
@@ -3835,8 +3453,8 @@ fn test_x64_emit() {
     insns.push((
         Inst::cmp_rmi_r(
             OperandSize::Size8,
-            RegMemImm::mem(Amode::imm_reg(99, rdi)),
             r8,
+            RegMemImm::mem(Amode::imm_reg(99, rdi)),
         ),
         "443A4763",
         "cmpb    99(%rdi), %r8b",
@@ -3844,115 +3462,115 @@ fn test_x64_emit() {
     insns.push((
         Inst::cmp_rmi_r(
             OperandSize::Size8,
-            RegMemImm::mem(Amode::imm_reg(99, rdi)),
             rsi,
+            RegMemImm::mem(Amode::imm_reg(99, rdi)),
         ),
         "403A7763",
         "cmpb    99(%rdi), %sil",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::imm(70), rdx),
+        Inst::cmp_rmi_r(OperandSize::Size8, rdx, RegMemImm::imm(70)),
         "80FA46",
         "cmpb    $70, %dl",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::imm(-76i32 as u32), r8),
+        Inst::cmp_rmi_r(OperandSize::Size8, r8, RegMemImm::imm(-76i32 as u32)),
         "4180F8B4",
         "cmpb    $-76, %r8b",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::imm(76), rsi),
+        Inst::cmp_rmi_r(OperandSize::Size8, rsi, RegMemImm::imm(76)),
         "4080FE4C",
         "cmpb    $76, %sil",
     ));
     // Extra byte-cases (paranoia!) for cmp_rmi_r for first operand = R
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(rax), rbx),
+        Inst::cmp_rmi_r(OperandSize::Size8, rbx, RegMemImm::reg(rax)),
         "38C3",
         "cmpb    %al, %bl",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(rbx), rax),
+        Inst::cmp_rmi_r(OperandSize::Size8, rax, RegMemImm::reg(rbx)),
         "38D8",
         "cmpb    %bl, %al",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(rcx), rdx),
+        Inst::cmp_rmi_r(OperandSize::Size8, rdx, RegMemImm::reg(rcx)),
         "38CA",
         "cmpb    %cl, %dl",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(rcx), rsi),
+        Inst::cmp_rmi_r(OperandSize::Size8, rsi, RegMemImm::reg(rcx)),
         "4038CE",
         "cmpb    %cl, %sil",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(rcx), r10),
+        Inst::cmp_rmi_r(OperandSize::Size8, r10, RegMemImm::reg(rcx)),
         "4138CA",
         "cmpb    %cl, %r10b",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(rcx), r14),
+        Inst::cmp_rmi_r(OperandSize::Size8, r14, RegMemImm::reg(rcx)),
         "4138CE",
         "cmpb    %cl, %r14b",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(rbp), rdx),
+        Inst::cmp_rmi_r(OperandSize::Size8, rdx, RegMemImm::reg(rbp)),
         "4038EA",
         "cmpb    %bpl, %dl",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(rbp), rsi),
+        Inst::cmp_rmi_r(OperandSize::Size8, rsi, RegMemImm::reg(rbp)),
         "4038EE",
         "cmpb    %bpl, %sil",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(rbp), r10),
+        Inst::cmp_rmi_r(OperandSize::Size8, r10, RegMemImm::reg(rbp)),
         "4138EA",
         "cmpb    %bpl, %r10b",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(rbp), r14),
+        Inst::cmp_rmi_r(OperandSize::Size8, r14, RegMemImm::reg(rbp)),
         "4138EE",
         "cmpb    %bpl, %r14b",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(r9), rdx),
+        Inst::cmp_rmi_r(OperandSize::Size8, rdx, RegMemImm::reg(r9)),
         "4438CA",
         "cmpb    %r9b, %dl",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(r9), rsi),
+        Inst::cmp_rmi_r(OperandSize::Size8, rsi, RegMemImm::reg(r9)),
         "4438CE",
         "cmpb    %r9b, %sil",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(r9), r10),
+        Inst::cmp_rmi_r(OperandSize::Size8, r10, RegMemImm::reg(r9)),
         "4538CA",
         "cmpb    %r9b, %r10b",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(r9), r14),
+        Inst::cmp_rmi_r(OperandSize::Size8, r14, RegMemImm::reg(r9)),
         "4538CE",
         "cmpb    %r9b, %r14b",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(r13), rdx),
+        Inst::cmp_rmi_r(OperandSize::Size8, rdx, RegMemImm::reg(r13)),
         "4438EA",
         "cmpb    %r13b, %dl",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(r13), rsi),
+        Inst::cmp_rmi_r(OperandSize::Size8, rsi, RegMemImm::reg(r13)),
         "4438EE",
         "cmpb    %r13b, %sil",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(r13), r10),
+        Inst::cmp_rmi_r(OperandSize::Size8, r10, RegMemImm::reg(r13)),
         "4538EA",
         "cmpb    %r13b, %r10b",
     ));
     insns.push((
-        Inst::cmp_rmi_r(OperandSize::Size8, RegMemImm::reg(r13), r14),
+        Inst::cmp_rmi_r(OperandSize::Size8, r14, RegMemImm::reg(r13)),
         "4538EE",
         "cmpb    %r13b, %r14b",
     ));
@@ -4027,8 +3645,8 @@ fn test_x64_emit() {
             CC::NO,
             RegMem::mem(Amode::imm_reg_reg_shift(
                 37,
-                Gpr::new(rdi).unwrap(),
-                Gpr::new(rsi).unwrap(),
+                Gpr::unwrap_new(rdi),
+                Gpr::unwrap_new(rsi),
                 2,
             )),
             w_r15,
@@ -4074,8 +3692,8 @@ fn test_x64_emit() {
     insns.push((
         Inst::push64(RegMemImm::mem(Amode::imm_reg_reg_shift(
             321,
-            Gpr::new(rsi).unwrap(),
-            Gpr::new(rcx).unwrap(),
+            Gpr::unwrap_new(rsi),
+            Gpr::unwrap_new(rcx),
             3,
         ))),
         "FFB4CE41010000",
@@ -4084,8 +3702,8 @@ fn test_x64_emit() {
     insns.push((
         Inst::push64(RegMemImm::mem(Amode::imm_reg_reg_shift(
             321,
-            Gpr::new(r9).unwrap(),
-            Gpr::new(rbx).unwrap(),
+            Gpr::unwrap_new(r9),
+            Gpr::unwrap_new(rbx),
             2,
         ))),
         "41FFB49941010000",
@@ -4134,7 +3752,6 @@ fn test_x64_emit() {
             smallvec![],
             smallvec![],
             PRegSet::default(),
-            Opcode::Call,
             0,
             CallConv::SystemV,
         ),
@@ -4150,7 +3767,6 @@ fn test_x64_emit() {
             smallvec![],
             smallvec![],
             PRegSet::default(),
-            Opcode::CallIndirect,
             0,
             CallConv::SystemV,
         )
@@ -4161,8 +3777,8 @@ fn test_x64_emit() {
     insns.push((
         call_unknown(RegMem::mem(Amode::imm_reg_reg_shift(
             321,
-            Gpr::new(rsi).unwrap(),
-            Gpr::new(rcx).unwrap(),
+            Gpr::unwrap_new(rsi),
+            Gpr::unwrap_new(rcx),
             3,
         ))),
         "FF94CE41010000",
@@ -4171,8 +3787,8 @@ fn test_x64_emit() {
     insns.push((
         call_unknown(RegMem::mem(Amode::imm_reg_reg_shift(
             321,
-            Gpr::new(r10).unwrap(),
-            Gpr::new(rdx).unwrap(),
+            Gpr::unwrap_new(r10),
+            Gpr::unwrap_new(rdx),
             2,
         ))),
         "41FF949241010000",
@@ -4241,8 +3857,8 @@ fn test_x64_emit() {
     insns.push((
         Inst::jmp_unknown(RegMem::mem(Amode::imm_reg_reg_shift(
             321,
-            Gpr::new(rsi).unwrap(),
-            Gpr::new(rcx).unwrap(),
+            Gpr::unwrap_new(rsi),
+            Gpr::unwrap_new(rcx),
             3,
         ))),
         "FFA4CE41010000",
@@ -4251,8 +3867,8 @@ fn test_x64_emit() {
     insns.push((
         Inst::jmp_unknown(RegMem::mem(Amode::imm_reg_reg_shift(
             321,
-            Gpr::new(r10).unwrap(),
-            Gpr::new(rdx).unwrap(),
+            Gpr::unwrap_new(r10),
+            Gpr::unwrap_new(rdx),
             2,
         ))),
         "41FFA49241010000",
@@ -4290,25 +3906,25 @@ fn test_x64_emit() {
     // XMM_CMP_RM_R
 
     insns.push((
-        Inst::xmm_cmp_rm_r(SseOpcode::Ucomiss, RegMem::reg(xmm1), xmm2),
+        Inst::xmm_cmp_rm_r(SseOpcode::Ucomiss, xmm2, RegMem::reg(xmm1)),
         "0F2ED1",
         "ucomiss %xmm1, %xmm2",
     ));
 
     insns.push((
-        Inst::xmm_cmp_rm_r(SseOpcode::Ucomiss, RegMem::reg(xmm0), xmm9),
+        Inst::xmm_cmp_rm_r(SseOpcode::Ucomiss, xmm9, RegMem::reg(xmm0)),
         "440F2EC8",
         "ucomiss %xmm0, %xmm9",
     ));
 
     insns.push((
-        Inst::xmm_cmp_rm_r(SseOpcode::Ucomisd, RegMem::reg(xmm13), xmm4),
+        Inst::xmm_cmp_rm_r(SseOpcode::Ucomisd, xmm4, RegMem::reg(xmm13)),
         "66410F2EE5",
         "ucomisd %xmm13, %xmm4",
     ));
 
     insns.push((
-        Inst::xmm_cmp_rm_r(SseOpcode::Ucomisd, RegMem::reg(xmm11), xmm12),
+        Inst::xmm_cmp_rm_r(SseOpcode::Ucomisd, xmm12, RegMem::reg(xmm11)),
         "66450F2EE3",
         "ucomisd %xmm11, %xmm12",
     ));
@@ -4331,8 +3947,8 @@ fn test_x64_emit() {
             SseOpcode::Addss,
             RegMem::mem(Amode::imm_reg_reg_shift(
                 123,
-                Gpr::new(r10).unwrap(),
-                Gpr::new(rdx).unwrap(),
+                Gpr::unwrap_new(r10),
+                Gpr::unwrap_new(rdx),
                 2,
             )),
             w_xmm0,
@@ -4361,8 +3977,8 @@ fn test_x64_emit() {
             SseOpcode::Subss,
             RegMem::mem(Amode::imm_reg_reg_shift(
                 321,
-                Gpr::new(r10).unwrap(),
-                Gpr::new(rax).unwrap(),
+                Gpr::unwrap_new(r10),
+                Gpr::unwrap_new(rax),
                 3,
             )),
             w_xmm10,
@@ -4583,19 +4199,37 @@ fn test_x64_emit() {
     insns.push((
         Inst::xmm_rm_r_evex(Avx512Opcode::Vpmullq, xmm10, RegMem::reg(xmm14), w_xmm1),
         "62D2AD0840CE",
-        "vpmullq %xmm10, %xmm14, %xmm1",
+        "vpmullq %xmm14, %xmm10, %xmm1",
+    ));
+
+    insns.push((
+        Inst::xmm_rm_r_evex(Avx512Opcode::Vpsraq, xmm10, RegMem::reg(xmm14), w_xmm1),
+        "62D1AD08E2CE",
+        "vpsraq  %xmm14, %xmm10, %xmm1",
     ));
 
     insns.push((
-        Inst::xmm_rm_r_evex(Avx512Opcode::Vpermi2b, xmm10, RegMem::reg(xmm14), w_xmm1),
+        Inst::xmm_rm_r_evex3(
+            Avx512Opcode::Vpermi2b,
+            xmm1,
+            xmm10,
+            RegMem::reg(xmm14),
+            w_xmm1,
+        ),
         "62D22D0875CE",
-        "vpermi2b %xmm10, %xmm14, %xmm1",
+        "vpermi2b %xmm14, %xmm10, %xmm1, %xmm1",
     ));
 
     insns.push((
-        Inst::xmm_rm_r_evex(Avx512Opcode::Vpermi2b, xmm0, RegMem::reg(xmm1), w_xmm2),
+        Inst::xmm_rm_r_evex3(
+            Avx512Opcode::Vpermi2b,
+            xmm2,
+            xmm0,
+            RegMem::reg(xmm1),
+            w_xmm2,
+        ),
         "62F27D0875D1",
-        "vpermi2b %xmm0, %xmm1, %xmm2",
+        "vpermi2b %xmm1, %xmm0, %xmm2, %xmm2",
     ));
 
     insns.push((
@@ -4889,25 +4523,25 @@ fn test_x64_emit() {
     ));
 
     insns.push((
-        Inst::xmm_unary_rm_r(SseOpcode::Sqrtss, RegMem::reg(xmm7), w_xmm8),
+        Inst::xmm_rm_r(SseOpcode::Sqrtss, RegMem::reg(xmm7), w_xmm8),
         "F3440F51C7",
-        "sqrtss  %xmm7, %xmm8",
+        "sqrtss  %xmm8, %xmm7, %xmm8",
     ));
     insns.push((
-        Inst::xmm_unary_rm_r(SseOpcode::Sqrtsd, RegMem::reg(xmm1), w_xmm2),
+        Inst::xmm_rm_r(SseOpcode::Sqrtsd, RegMem::reg(xmm1), w_xmm2),
         "F20F51D1",
-        "sqrtsd  %xmm1, %xmm2",
+        "sqrtsd  %xmm2, %xmm1, %xmm2",
     ));
 
     insns.push((
-        Inst::xmm_unary_rm_r(SseOpcode::Cvtss2sd, RegMem::reg(xmm0), w_xmm1),
+        Inst::xmm_rm_r(SseOpcode::Cvtss2sd, RegMem::reg(xmm0), w_xmm1),
         "F30F5AC8",
-        "cvtss2sd %xmm0, %xmm1",
+        "cvtss2sd %xmm1, %xmm0, %xmm1",
     ));
     insns.push((
-        Inst::xmm_unary_rm_r(SseOpcode::Cvtsd2ss, RegMem::reg(xmm1), w_xmm0),
+        Inst::xmm_rm_r(SseOpcode::Cvtsd2ss, RegMem::reg(xmm1), w_xmm0),
         "F20F5AC1",
-        "cvtsd2ss %xmm1, %xmm0",
+        "cvtsd2ss %xmm0, %xmm1, %xmm0",
     ));
 
     insns.push((
@@ -5146,9 +4780,9 @@ fn test_x64_emit() {
     insns.push((
         Inst::XmmRmiRVex {
             op: AvxOpcode::Vpmaxub,
-            dst: Writable::from_reg(Xmm::new(xmm13).unwrap()),
-            src1: Xmm::new(xmm1).unwrap(),
-            src2: XmmMemImm::new(xmm12.into()).unwrap(),
+            dst: Writable::from_reg(Xmm::unwrap_new(xmm13)),
+            src1: Xmm::unwrap_new(xmm1),
+            src2: XmmMemImm::unwrap_new(xmm12.into()),
         },
         "C44171DEEC",
         "vpmaxub %xmm1, %xmm12, %xmm13",
@@ -5158,17 +4792,16 @@ fn test_x64_emit() {
     insns.push((
         Inst::XmmRmiRVex {
             op: AvxOpcode::Vpmaxub,
-            dst: Writable::from_reg(Xmm::new(xmm13).unwrap()),
-            src1: Xmm::new(xmm1).unwrap(),
-            src2: XmmMemImm::new(RegMemImm::Mem {
+            dst: Writable::from_reg(Xmm::unwrap_new(xmm13)),
+            src1: Xmm::unwrap_new(xmm1),
+            src2: XmmMemImm::unwrap_new(RegMemImm::Mem {
                 addr: Amode::ImmReg {
                     simm32: 10,
                     base: rax,
                     flags: MemFlags::trusted(),
                 }
                 .into(),
-            })
-            .unwrap(),
+            }),
         },
         "C571DE680A",
         "vpmaxub %xmm1, 10(%rax), %xmm13",
@@ -5178,9 +4811,9 @@ fn test_x64_emit() {
     insns.push((
         Inst::XmmRmiRVex {
             op: AvxOpcode::Vpsrlw,
-            dst: Writable::from_reg(Xmm::new(xmm13).unwrap()),
-            src1: Xmm::new(xmm1).unwrap(),
-            src2: XmmMemImm::new(RegMemImm::Imm { simm32: 36 }).unwrap(),
+            dst: Writable::from_reg(Xmm::unwrap_new(xmm13)),
+            src1: Xmm::unwrap_new(xmm1),
+            src2: XmmMemImm::unwrap_new(RegMemImm::Imm { simm32: 36 }),
         },
         "C59171D124",
         "vpsrlw  %xmm1, $36, %xmm13",
@@ -5192,9 +4825,9 @@ fn test_x64_emit() {
     insns.push((
         Inst::XmmRmiRVex {
             op: AvxOpcode::Vmulsd,
-            dst: Writable::from_reg(Xmm::new(xmm13).unwrap()),
-            src1: Xmm::new(xmm1).unwrap(),
-            src2: XmmMemImm::new(xmm12.into()).unwrap(),
+            dst: Writable::from_reg(Xmm::unwrap_new(xmm13)),
+            src1: Xmm::unwrap_new(xmm1),
+            src2: XmmMemImm::unwrap_new(xmm12.into()),
         },
         "C51B59E9",
         "vmulsd  %xmm1, %xmm12, %xmm13",
@@ -5202,9 +4835,9 @@ fn test_x64_emit() {
     insns.push((
         Inst::XmmRmiRVex {
             op: AvxOpcode::Vmulsd,
-            dst: Writable::from_reg(Xmm::new(xmm13).unwrap()),
-            src1: Xmm::new(xmm12).unwrap(),
-            src2: XmmMemImm::new(xmm1.into()).unwrap(),
+            dst: Writable::from_reg(Xmm::unwrap_new(xmm13)),
+            src1: Xmm::unwrap_new(xmm12),
+            src2: XmmMemImm::unwrap_new(xmm1.into()),
         },
         "C51B59E9",
         "vmulsd  %xmm12, %xmm1, %xmm13",
@@ -5215,9 +4848,9 @@ fn test_x64_emit() {
     insns.push((
         Inst::XmmVexPinsr {
             op: AvxOpcode::Vpinsrb,
-            dst: Writable::from_reg(Xmm::new(xmm13).unwrap()),
-            src1: Xmm::new(xmm14).unwrap(),
-            src2: GprMem::new(RegMem::reg(r15)).unwrap(),
+            dst: Writable::from_reg(Xmm::unwrap_new(xmm13)),
+            src1: Xmm::unwrap_new(xmm14),
+            src2: GprMem::unwrap_new(RegMem::reg(r15)),
             imm: 2,
         },
         "C4430920EF02",
@@ -5227,12 +4860,11 @@ fn test_x64_emit() {
     // ========================================================
     // Pertaining to atomics.
     let am1: SyntheticAmode =
-        Amode::imm_reg_reg_shift(321, Gpr::new(r10).unwrap(), Gpr::new(rdx).unwrap(), 2).into();
+        Amode::imm_reg_reg_shift(321, Gpr::unwrap_new(r10), Gpr::unwrap_new(rdx), 2).into();
     // `am2` doesn't contribute any 1 bits to the rex prefix, so we must use it when testing
     // for retention of the apparently-redundant rex prefix in the 8-bit case.
     let am2: SyntheticAmode =
-        Amode::imm_reg_reg_shift(-12345i32, Gpr::new(rcx).unwrap(), Gpr::new(rsi).unwrap(), 3)
-            .into();
+        Amode::imm_reg_reg_shift(-12345i32, Gpr::unwrap_new(rcx), Gpr::unwrap_new(rsi), 3).into();
     // Use `r9` with a 0 offset.
     let am3: SyntheticAmode = Amode::imm_reg(0, r9).into();
 
@@ -5508,11 +5140,11 @@ fn test_x64_emit() {
     let emit_info = EmitInfo::new(flags, isa_flags);
     for (insn, expected_encoding, expected_printing) in insns {
         // Check the printed text is as expected.
-        let actual_printing = insn.pretty_print_inst(&[], &mut Default::default());
+        let actual_printing = insn.pretty_print_inst(&mut Default::default());
         assert_eq!(expected_printing, actual_printing);
         let mut buffer = MachBuffer::new();
 
-        insn.emit(&[], &mut buffer, &emit_info, &mut Default::default());
+        insn.emit(&mut buffer, &emit_info, &mut Default::default());
 
         // Allow one label just after the instruction (so the offset is 0).
         let label = buffer.get_label();
@@ -5520,6 +5152,6 @@ fn test_x64_emit() {
 
         let buffer = buffer.finish(&constants, ctrl_plane);
         let actual_encoding = &buffer.stringify_code_bytes();
-        assert_eq!(expected_encoding, actual_encoding, "{}", expected_printing);
+        assert_eq!(expected_encoding, actual_encoding, "{expected_printing}");
     }
 }
diff --git a/cranelift/codegen/src/isa/x64/inst/mod.rs b/cranelift/codegen/src/isa/x64/inst/mod.rs
index 2a321c7f44f6..705d8151b071 100644
--- a/cranelift/codegen/src/isa/x64/inst/mod.rs
+++ b/cranelift/codegen/src/isa/x64/inst/mod.rs
@@ -2,8 +2,8 @@
 
 pub use emit_state::EmitState;
 
-use crate::binemit::{Addend, CodeOffset, Reloc, StackMap};
-use crate::ir::{types, ExternalName, LibCall, Opcode, RelSourceLoc, TrapCode, Type};
+use crate::binemit::{Addend, CodeOffset, Reloc};
+use crate::ir::{types, ExternalName, LibCall, TrapCode, Type};
 use crate::isa::x64::abi::X64ABIMachineSpec;
 use crate::isa::x64::inst::regs::{pretty_print_reg, show_ireg_sized};
 use crate::isa::x64::settings as x64_settings;
@@ -11,7 +11,7 @@ use crate::isa::{CallConv, FunctionAlignment};
 use crate::{machinst::*, trace};
 use crate::{settings, CodegenError, CodegenResult};
 use alloc::boxed::Box;
-use regalloc2::{Allocation, PRegSet, VReg};
+use regalloc2::PRegSet;
 use smallvec::{smallvec, SmallVec};
 use std::fmt::{self, Write};
 use std::string::{String, ToString};
@@ -22,6 +22,7 @@ mod emit_state;
 #[cfg(test)]
 mod emit_tests;
 pub mod regs;
+mod stack_switch;
 pub mod unwind;
 
 use args::*;
@@ -41,8 +42,6 @@ pub struct CallInfo {
     pub defs: CallRetList,
     /// Registers clobbered by this call, as per its calling convention.
     pub clobbers: PRegSet,
-    /// The opcode of this call.
-    pub opcode: Opcode,
     /// The number of bytes that the callee will pop from the stack for the
     /// caller, if any. (Used for popping stack arguments with the `tail`
     /// calling convention.)
@@ -54,22 +53,15 @@ pub struct CallInfo {
 /// Out-of-line data for return-calls, to keep the size of `Inst` down.
 #[derive(Clone, Debug)]
 pub struct ReturnCallInfo {
-    /// The size of the new stack frame's stack arguments. This is necessary
-    /// for copying the frame over our current frame. It must already be
-    /// allocated on the stack.
+    /// The size of the argument area for this return-call, potentially smaller than that of the
+    /// caller, but never larger.
     pub new_stack_arg_size: u32,
-    /// The size of the current/old stack frame's stack arguments.
-    pub old_stack_arg_size: u32,
-    /// The return address. Needs to be written into the correct stack slot
-    /// after the new stack frame is copied into place.
-    pub ret_addr: Option<Gpr>,
-    /// A copy of the frame pointer, because we will overwrite the current
-    /// `rbp`.
-    pub fp: Gpr,
-    /// A temporary register.
-    pub tmp: WritableGpr,
+
     /// The in-register arguments and their constraints.
     pub uses: CallArgList,
+
+    /// A temporary for use when moving the return address.
+    pub tmp: WritableGpr,
 }
 
 #[test]
@@ -130,8 +122,10 @@ impl Inst {
             | Inst::MovToPReg { .. }
             | Inst::MovsxRmR { .. }
             | Inst::MovzxRmR { .. }
-            | Inst::MulHi { .. }
-            | Inst::UMulLo { .. }
+            | Inst::Mul { .. }
+            | Inst::Mul8 { .. }
+            | Inst::IMul { .. }
+            | Inst::IMulImm { .. }
             | Inst::Neg { .. }
             | Inst::Not { .. }
             | Inst::Nop { .. }
@@ -144,11 +138,11 @@ impl Inst {
             | Inst::Setcc { .. }
             | Inst::ShiftR { .. }
             | Inst::SignExtendData { .. }
+            | Inst::StackSwitchBasic { .. }
             | Inst::TrapIf { .. }
             | Inst::TrapIfAnd { .. }
             | Inst::TrapIfOr { .. }
             | Inst::Ud2 { .. }
-            | Inst::VirtualSPOffsetAdj { .. }
             | Inst::XmmCmove { .. }
             | Inst::XmmCmpRmR { .. }
             | Inst::XmmMinMaxSeq { .. }
@@ -198,7 +192,8 @@ impl Inst {
             | Inst::XmmToGprImmVex { op, .. }
             | Inst::XmmToGprVex { op, .. }
             | Inst::GprToXmmVex { op, .. }
-            | Inst::CvtIntToFloatVex { op, .. } => op.available_from(),
+            | Inst::CvtIntToFloatVex { op, .. }
+            | Inst::XmmCmpRmRVex { op, .. } => op.available_from(),
         }
     }
 }
@@ -222,8 +217,8 @@ impl Inst {
         Self::AluRmiR {
             size,
             op,
-            src1: Gpr::new(dst.to_reg()).unwrap(),
-            src2: GprMemImm::new(src).unwrap(),
+            src1: Gpr::unwrap_new(dst.to_reg()),
+            src2: GprMemImm::unwrap_new(src),
             dst: WritableGpr::from_writable_reg(dst).unwrap(),
         }
     }
@@ -245,7 +240,7 @@ impl Inst {
         Self::UnaryRmR {
             size,
             op,
-            src: GprMem::new(src).unwrap(),
+            src: GprMem::unwrap_new(src),
             dst: WritableGpr::from_writable_reg(dst).unwrap(),
         }
     }
@@ -254,7 +249,7 @@ impl Inst {
         debug_assert_eq!(src.to_reg().class(), RegClass::Int);
         Inst::Not {
             size,
-            src: Gpr::new(src.to_reg()).unwrap(),
+            src: Gpr::unwrap_new(src.to_reg()),
             dst: WritableGpr::from_writable_reg(src).unwrap(),
         }
     }
@@ -274,7 +269,7 @@ impl Inst {
             size,
             sign,
             trap,
-            divisor: GprMem::new(divisor).unwrap(),
+            divisor: GprMem::unwrap_new(divisor),
             dividend_lo,
             dividend_hi,
             dst_quotient,
@@ -293,7 +288,7 @@ impl Inst {
         Inst::Div8 {
             sign,
             trap,
-            divisor: GprMem::new(divisor).unwrap(),
+            divisor: GprMem::unwrap_new(divisor),
             dividend,
             dst,
         }
@@ -319,7 +314,7 @@ impl Inst {
         debug_assert!(size.is_one_of(&[OperandSize::Size32, OperandSize::Size64]));
         debug_assert!(src.class() == RegClass::Int);
         debug_assert!(dst.to_reg().class() == RegClass::Int);
-        let src = Gpr::new(src).unwrap();
+        let src = Gpr::unwrap_new(src);
         let dst = WritableGpr::from_writable_reg(dst).unwrap();
         Inst::MovRR { size, src, dst }
     }
@@ -330,7 +325,7 @@ impl Inst {
         debug_assert!(dst.to_reg().class() == RegClass::Float);
         Inst::XmmUnaryRmR {
             op,
-            src: XmmMemAligned::new(src).unwrap(),
+            src: XmmMemAligned::unwrap_new(src),
             dst: WritableXmm::from_writable_reg(dst).unwrap(),
         }
     }
@@ -340,8 +335,8 @@ impl Inst {
         debug_assert!(dst.to_reg().class() == RegClass::Float);
         Inst::XmmRmR {
             op,
-            src1: Xmm::new(dst.to_reg()).unwrap(),
-            src2: XmmMemAligned::new(src).unwrap(),
+            src1: Xmm::unwrap_new(dst.to_reg()),
+            src2: XmmMemAligned::unwrap_new(src),
             dst: WritableXmm::from_writable_reg(dst).unwrap(),
         }
     }
@@ -353,9 +348,9 @@ impl Inst {
         debug_assert!(dst.to_reg().class() == RegClass::Float);
         Inst::XmmRmRVex3 {
             op,
-            src3: XmmMem::new(src3).unwrap(),
-            src2: Xmm::new(src2).unwrap(),
-            src1: Xmm::new(dst.to_reg()).unwrap(),
+            src3: XmmMem::unwrap_new(src3),
+            src2: Xmm::unwrap_new(src2),
+            src1: Xmm::unwrap_new(dst.to_reg()),
             dst: WritableXmm::from_writable_reg(dst).unwrap(),
         }
     }
@@ -364,7 +359,7 @@ impl Inst {
         debug_assert!(src.class() == RegClass::Float);
         Inst::XmmMovRM {
             op,
-            src: Xmm::new(src).unwrap(),
+            src: Xmm::unwrap_new(src),
             dst: dst.into(),
         }
     }
@@ -380,7 +375,7 @@ impl Inst {
         debug_assert!(dst_size.is_one_of(&[OperandSize::Size32, OperandSize::Size64]));
         Inst::XmmToGpr {
             op,
-            src: Xmm::new(src).unwrap(),
+            src: Xmm::unwrap_new(src),
             dst: WritableGpr::from_writable_reg(dst).unwrap(),
             dst_size,
         }
@@ -397,18 +392,18 @@ impl Inst {
         debug_assert!(dst.to_reg().class() == RegClass::Float);
         Inst::GprToXmm {
             op,
-            src: GprMem::new(src).unwrap(),
+            src: GprMem::unwrap_new(src),
             dst: WritableXmm::from_writable_reg(dst).unwrap(),
             src_size,
         }
     }
 
-    pub(crate) fn xmm_cmp_rm_r(op: SseOpcode, src: RegMem, dst: Reg) -> Inst {
-        src.assert_regclass_is(RegClass::Float);
-        debug_assert!(dst.class() == RegClass::Float);
-        let src = XmmMemAligned::new(src).unwrap();
-        let dst = Xmm::new(dst).unwrap();
-        Inst::XmmCmpRmR { op, src, dst }
+    pub(crate) fn xmm_cmp_rm_r(op: SseOpcode, src1: Reg, src2: RegMem) -> Inst {
+        src2.assert_regclass_is(RegClass::Float);
+        debug_assert!(src1.class() == RegClass::Float);
+        let src2 = XmmMemAligned::unwrap_new(src2);
+        let src1 = Xmm::unwrap_new(src1);
+        Inst::XmmCmpRmR { op, src1, src2 }
     }
 
     #[allow(dead_code)]
@@ -426,8 +421,8 @@ impl Inst {
         Inst::XmmMinMaxSeq {
             size,
             is_min,
-            lhs: Xmm::new(lhs).unwrap(),
-            rhs: Xmm::new(rhs).unwrap(),
+            lhs: Xmm::unwrap_new(lhs),
+            rhs: Xmm::unwrap_new(rhs),
             dst: WritableXmm::from_writable_reg(dst).unwrap(),
         }
     }
@@ -435,7 +430,7 @@ impl Inst {
     pub(crate) fn movzx_rm_r(ext_mode: ExtMode, src: RegMem, dst: Writable<Reg>) -> Inst {
         src.assert_regclass_is(RegClass::Int);
         debug_assert!(dst.to_reg().class() == RegClass::Int);
-        let src = GprMem::new(src).unwrap();
+        let src = GprMem::unwrap_new(src);
         let dst = WritableGpr::from_writable_reg(dst).unwrap();
         Inst::MovzxRmR { ext_mode, src, dst }
     }
@@ -443,7 +438,7 @@ impl Inst {
     pub(crate) fn movsx_rm_r(ext_mode: ExtMode, src: RegMem, dst: Writable<Reg>) -> Inst {
         src.assert_regclass_is(RegClass::Int);
         debug_assert!(dst.to_reg().class() == RegClass::Int);
-        let src = GprMem::new(src).unwrap();
+        let src = GprMem::unwrap_new(src);
         let dst = WritableGpr::from_writable_reg(dst).unwrap();
         Inst::MovsxRmR { ext_mode, src, dst }
     }
@@ -460,7 +455,7 @@ impl Inst {
         debug_assert!(src.class() == RegClass::Int);
         Inst::MovRM {
             size,
-            src: Gpr::new(src).unwrap(),
+            src: Gpr::unwrap_new(src),
             dst: dst.into(),
         }
     }
@@ -481,14 +476,14 @@ impl Inst {
         src: Reg,
         dst: Writable<Reg>,
     ) -> Inst {
-        if let Imm8Reg::Imm8 { imm: num_bits } = num_bits.clone().to_imm8_reg() {
+        if let &Imm8Reg::Imm8 { imm: num_bits } = num_bits.as_imm8_reg() {
             debug_assert!(num_bits < size.to_bits());
         }
         debug_assert!(dst.to_reg().class() == RegClass::Int);
         Inst::ShiftR {
             size,
             kind,
-            src: Gpr::new(src).unwrap(),
+            src: Gpr::unwrap_new(src),
             num_bits,
             dst: WritableGpr::from_writable_reg(dst).unwrap(),
         }
@@ -496,13 +491,13 @@ impl Inst {
 
     /// Does a comparison of dst - src for operands of size `size`, as stated by the machine
     /// instruction semantics. Be careful with the order of parameters!
-    pub(crate) fn cmp_rmi_r(size: OperandSize, src: RegMemImm, dst: Reg) -> Inst {
-        src.assert_regclass_is(RegClass::Int);
-        debug_assert_eq!(dst.class(), RegClass::Int);
+    pub(crate) fn cmp_rmi_r(size: OperandSize, src1: Reg, src2: RegMemImm) -> Inst {
+        src2.assert_regclass_is(RegClass::Int);
+        debug_assert_eq!(src1.class(), RegClass::Int);
         Inst::CmpRmiR {
             size,
-            src: GprMemImm::new(src).unwrap(),
-            dst: Gpr::new(dst).unwrap(),
+            src1: Gpr::unwrap_new(src1),
+            src2: GprMemImm::unwrap_new(src2),
             opcode: CmpOpcode::Cmp,
         }
     }
@@ -525,15 +520,15 @@ impl Inst {
         Inst::Cmove {
             size,
             cc,
-            consequent: GprMem::new(src).unwrap(),
-            alternative: Gpr::new(dst.to_reg()).unwrap(),
+            consequent: GprMem::unwrap_new(src),
+            alternative: Gpr::unwrap_new(dst.to_reg()),
             dst: WritableGpr::from_writable_reg(dst).unwrap(),
         }
     }
 
     pub(crate) fn push64(src: RegMemImm) -> Inst {
         src.assert_regclass_is(RegClass::Int);
-        let src = GprMemImm::new(src).unwrap();
+        let src = GprMemImm::unwrap_new(src);
         Inst::Push64 { src }
     }
 
@@ -548,20 +543,18 @@ impl Inst {
         uses: CallArgList,
         defs: CallRetList,
         clobbers: PRegSet,
-        opcode: Opcode,
         callee_pop_size: u32,
         callee_conv: CallConv,
     ) -> Inst {
         Inst::CallKnown {
             dest,
-            info: Box::new(CallInfo {
+            info: Some(Box::new(CallInfo {
                 uses,
                 defs,
                 clobbers,
-                opcode,
                 callee_pop_size,
                 callee_conv,
-            }),
+            })),
         }
     }
 
@@ -570,21 +563,19 @@ impl Inst {
         uses: CallArgList,
         defs: CallRetList,
         clobbers: PRegSet,
-        opcode: Opcode,
         callee_pop_size: u32,
         callee_conv: CallConv,
     ) -> Inst {
         dest.assert_regclass_is(RegClass::Int);
         Inst::CallUnknown {
             dest,
-            info: Box::new(CallInfo {
+            info: Some(Box::new(CallInfo {
                 uses,
                 defs,
                 clobbers,
-                opcode,
                 callee_pop_size,
                 callee_conv,
-            }),
+            })),
         }
     }
 
@@ -629,10 +620,9 @@ impl Inst {
                         ExtKind::ZeroExtend => {
                             Inst::movzx_rm_r(ext_mode, RegMem::mem(from_addr), to_reg)
                         }
-                        ExtKind::None => panic!(
-                            "expected an extension kind for extension mode: {:?}",
-                            ext_mode
-                        ),
+                        ExtKind::None => {
+                            panic!("expected an extension kind for extension mode: {ext_mode:?}")
+                        }
                     }
                 } else {
                     // 64-bit values can be moved directly.
@@ -641,11 +631,12 @@ impl Inst {
             }
             RegClass::Float => {
                 let opcode = match ty {
+                    types::F16 => panic!("loading a f16 requires multiple instructions"),
                     types::F32 => SseOpcode::Movss,
                     types::F64 => SseOpcode::Movsd,
                     types::F32X4 => SseOpcode::Movups,
                     types::F64X2 => SseOpcode::Movupd,
-                    _ if ty.is_vector() && ty.bits() == 128 => SseOpcode::Movdqu,
+                    _ if (ty.is_float() || ty.is_vector()) && ty.bits() == 128 => SseOpcode::Movdqu,
                     _ => unimplemented!("unable to load type: {}", ty),
                 };
                 Inst::xmm_unary_rm_r(opcode, RegMem::mem(from_addr), to_reg)
@@ -661,11 +652,12 @@ impl Inst {
             RegClass::Int => Inst::mov_r_m(OperandSize::from_ty(ty), from_reg, to_addr),
             RegClass::Float => {
                 let opcode = match ty {
+                    types::F16 => panic!("storing a f16 requires multiple instructions"),
                     types::F32 => SseOpcode::Movss,
                     types::F64 => SseOpcode::Movsd,
                     types::F32X4 => SseOpcode::Movups,
                     types::F64X2 => SseOpcode::Movupd,
-                    _ if ty.is_vector() && ty.bits() == 128 => SseOpcode::Movdqu,
+                    _ if (ty.is_float() || ty.is_vector()) && ty.bits() == 128 => SseOpcode::Movdqu,
                     _ => unimplemented!("unable to store type: {}", ty),
                 };
                 Inst::xmm_mov_r_m(opcode, from_reg, to_addr)
@@ -679,7 +671,7 @@ impl Inst {
 // Instructions: printing
 
 impl PrettyPrint for Inst {
-    fn pretty_print(&self, _size: u8, allocs: &mut AllocationConsumer<'_>) -> String {
+    fn pretty_print(&self, _size: u8) -> String {
         fn ljustify(s: String) -> String {
             let w = 7;
             if s.len() >= w {
@@ -733,15 +725,15 @@ impl PrettyPrint for Inst {
                 dst,
             } => {
                 let size_bytes = size.to_bytes();
-                let src1 = pretty_print_reg(src1.to_reg(), size_bytes, allocs);
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), size_bytes, allocs);
-                let src2 = src2.pretty_print(size_bytes, allocs);
+                let src1 = pretty_print_reg(src1.to_reg(), size_bytes);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), size_bytes);
+                let src2 = src2.pretty_print(size_bytes);
                 let op = ljustify2(op.to_string(), suffix_bwlq(*size));
                 format!("{op} {src1}, {src2}, {dst}")
             }
             Inst::AluConstOp { op, dst, size } => {
                 let size_bytes = size.to_bytes();
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), size_bytes, allocs);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), size_bytes);
                 let op = ljustify2(op.to_string(), suffix_lqb(*size));
                 format!("{op} {dst}, {dst}, {dst}")
             }
@@ -752,8 +744,8 @@ impl PrettyPrint for Inst {
                 src2,
             } => {
                 let size_bytes = size.to_bytes();
-                let src2 = pretty_print_reg(src2.to_reg(), size_bytes, allocs);
-                let src1_dst = src1_dst.pretty_print(size_bytes, allocs);
+                let src2 = pretty_print_reg(src2.to_reg(), size_bytes);
+                let src1_dst = src1_dst.pretty_print(size_bytes);
                 let op = ljustify2(op.to_string(), suffix_bwlq(*size));
                 format!("{op} {src2}, {src1_dst}")
             }
@@ -765,22 +757,22 @@ impl PrettyPrint for Inst {
                 dst,
             } => {
                 let size_bytes = size.to_bytes();
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), size.to_bytes(), allocs);
-                let src1 = pretty_print_reg(src1.to_reg(), size_bytes, allocs);
-                let src2 = src2.pretty_print(size_bytes, allocs);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), size.to_bytes());
+                let src1 = pretty_print_reg(src1.to_reg(), size_bytes);
+                let src2 = src2.pretty_print(size_bytes);
                 let op = ljustify2(op.to_string(), String::new());
                 format!("{op} {src2}, {src1}, {dst}")
             }
             Inst::UnaryRmR { src, dst, op, size } => {
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), size.to_bytes(), allocs);
-                let src = src.pretty_print(size.to_bytes(), allocs);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), size.to_bytes());
+                let src = src.pretty_print(size.to_bytes());
                 let op = ljustify2(op.to_string(), suffix_bwlq(*size));
                 format!("{op} {src}, {dst}")
             }
 
             Inst::UnaryRmRVex { src, dst, op, size } => {
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), size.to_bytes(), allocs);
-                let src = src.pretty_print(size.to_bytes(), allocs);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), size.to_bytes());
+                let src = src.pretty_print(size.to_bytes());
                 let op = ljustify2(op.to_string(), suffix_bwlq(*size));
                 format!("{op} {src}, {dst}")
             }
@@ -792,8 +784,8 @@ impl PrettyPrint for Inst {
                 size,
                 imm,
             } => {
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), size.to_bytes(), allocs);
-                let src = src.pretty_print(size.to_bytes(), allocs);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), size.to_bytes());
+                let src = src.pretty_print(size.to_bytes());
                 format!(
                     "{} ${imm}, {src}, {dst}",
                     ljustify2(op.to_string(), suffix_bwlq(*size))
@@ -801,15 +793,15 @@ impl PrettyPrint for Inst {
             }
 
             Inst::Not { size, src, dst } => {
-                let src = pretty_print_reg(src.to_reg(), size.to_bytes(), allocs);
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), size.to_bytes(), allocs);
+                let src = pretty_print_reg(src.to_reg(), size.to_bytes());
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), size.to_bytes());
                 let op = ljustify2("not".to_string(), suffix_bwlq(*size));
                 format!("{op} {src}, {dst}")
             }
 
             Inst::Neg { size, src, dst } => {
-                let src = pretty_print_reg(src.to_reg(), size.to_bytes(), allocs);
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), size.to_bytes(), allocs);
+                let src = pretty_print_reg(src.to_reg(), size.to_bytes());
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), size.to_bytes());
                 let op = ljustify2("neg".to_string(), suffix_bwlq(*size));
                 format!("{op} {src}, {dst}")
             }
@@ -824,13 +816,13 @@ impl PrettyPrint for Inst {
                 dst_quotient,
                 dst_remainder,
             } => {
-                let divisor = divisor.pretty_print(size.to_bytes(), allocs);
-                let dividend_lo = pretty_print_reg(dividend_lo.to_reg(), size.to_bytes(), allocs);
-                let dividend_hi = pretty_print_reg(dividend_hi.to_reg(), size.to_bytes(), allocs);
+                let divisor = divisor.pretty_print(size.to_bytes());
+                let dividend_lo = pretty_print_reg(dividend_lo.to_reg(), size.to_bytes());
+                let dividend_hi = pretty_print_reg(dividend_hi.to_reg(), size.to_bytes());
                 let dst_quotient =
-                    pretty_print_reg(dst_quotient.to_reg().to_reg(), size.to_bytes(), allocs);
+                    pretty_print_reg(dst_quotient.to_reg().to_reg(), size.to_bytes());
                 let dst_remainder =
-                    pretty_print_reg(dst_remainder.to_reg().to_reg(), size.to_bytes(), allocs);
+                    pretty_print_reg(dst_remainder.to_reg().to_reg(), size.to_bytes());
                 let op = ljustify(match sign {
                     DivSignedness::Signed => "idiv".to_string(),
                     DivSignedness::Unsigned => "div".to_string(),
@@ -847,9 +839,9 @@ impl PrettyPrint for Inst {
                 dividend,
                 dst,
             } => {
-                let divisor = divisor.pretty_print(1, allocs);
-                let dividend = pretty_print_reg(dividend.to_reg(), 1, allocs);
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 1, allocs);
+                let divisor = divisor.pretty_print(1);
+                let dividend = pretty_print_reg(dividend.to_reg(), 1);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 1);
                 let op = ljustify(match sign {
                     DivSignedness::Signed => "idiv".to_string(),
                     DivSignedness::Unsigned => "div".to_string(),
@@ -857,7 +849,7 @@ impl PrettyPrint for Inst {
                 format!("{op} {dividend}, {divisor}, {dst} ; trap={trap}")
             }
 
-            Inst::MulHi {
+            Inst::Mul {
                 size,
                 signed,
                 src1,
@@ -865,31 +857,63 @@ impl PrettyPrint for Inst {
                 dst_lo,
                 dst_hi,
             } => {
-                let src1 = pretty_print_reg(src1.to_reg(), size.to_bytes(), allocs);
-                let dst_lo = pretty_print_reg(dst_lo.to_reg().to_reg(), size.to_bytes(), allocs);
-                let dst_hi = pretty_print_reg(dst_hi.to_reg().to_reg(), size.to_bytes(), allocs);
-                let src2 = src2.pretty_print(size.to_bytes(), allocs);
+                let src1 = pretty_print_reg(src1.to_reg(), size.to_bytes());
+                let dst_lo = pretty_print_reg(dst_lo.to_reg().to_reg(), size.to_bytes());
+                let dst_hi = pretty_print_reg(dst_hi.to_reg().to_reg(), size.to_bytes());
+                let src2 = src2.pretty_print(size.to_bytes());
+                let suffix = suffix_bwlq(*size);
                 let op = ljustify(if *signed {
-                    "imul".to_string()
+                    format!("imul{suffix}")
                 } else {
-                    "mul".to_string()
+                    format!("mul{suffix}")
                 });
                 format!("{op} {src1}, {src2}, {dst_lo}, {dst_hi}")
             }
 
-            Inst::UMulLo {
+            Inst::Mul8 {
+                signed,
+                src1,
+                src2,
+                dst,
+            } => {
+                let src1 = pretty_print_reg(src1.to_reg(), 1);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 1);
+                let src2 = src2.pretty_print(1);
+                let op = ljustify(if *signed {
+                    "imulb".to_string()
+                } else {
+                    "mulb".to_string()
+                });
+                format!("{op} {src1}, {src2}, {dst}")
+            }
+
+            Inst::IMul {
                 size,
                 src1,
                 src2,
                 dst,
             } => {
-                let src1 = pretty_print_reg(src1.to_reg(), size.to_bytes(), allocs);
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), size.to_bytes(), allocs);
-                let src2 = src2.pretty_print(size.to_bytes(), allocs);
-                let op = ljustify2("mul".to_string(), suffix_bwlq(*size));
+                let src1 = pretty_print_reg(src1.to_reg(), size.to_bytes());
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), size.to_bytes());
+                let src2 = src2.pretty_print(size.to_bytes());
+                let suffix = suffix_bwlq(*size);
+                let op = ljustify(format!("imul{suffix}"));
                 format!("{op} {src1}, {src2}, {dst}")
             }
 
+            Inst::IMulImm {
+                size,
+                src1,
+                src2,
+                dst,
+            } => {
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), size.to_bytes());
+                let src1 = src1.pretty_print(size.to_bytes());
+                let suffix = suffix_bwlq(*size);
+                let op = ljustify(format!("imul{suffix}"));
+                format!("{op} {src1}, {src2:#x}, {dst}")
+            }
+
             Inst::CheckedSRemSeq {
                 size,
                 divisor,
@@ -898,13 +922,13 @@ impl PrettyPrint for Inst {
                 dst_quotient,
                 dst_remainder,
             } => {
-                let divisor = pretty_print_reg(divisor.to_reg(), size.to_bytes(), allocs);
-                let dividend_lo = pretty_print_reg(dividend_lo.to_reg(), size.to_bytes(), allocs);
-                let dividend_hi = pretty_print_reg(dividend_hi.to_reg(), size.to_bytes(), allocs);
+                let divisor = pretty_print_reg(divisor.to_reg(), size.to_bytes());
+                let dividend_lo = pretty_print_reg(dividend_lo.to_reg(), size.to_bytes());
+                let dividend_hi = pretty_print_reg(dividend_hi.to_reg(), size.to_bytes());
                 let dst_quotient =
-                    pretty_print_reg(dst_quotient.to_reg().to_reg(), size.to_bytes(), allocs);
+                    pretty_print_reg(dst_quotient.to_reg().to_reg(), size.to_bytes());
                 let dst_remainder =
-                    pretty_print_reg(dst_remainder.to_reg().to_reg(), size.to_bytes(), allocs);
+                    pretty_print_reg(dst_remainder.to_reg().to_reg(), size.to_bytes());
                 format!(
                     "checked_srem_seq {dividend_lo}, {dividend_hi}, \
                         {divisor}, {dst_quotient}, {dst_remainder}",
@@ -916,15 +940,15 @@ impl PrettyPrint for Inst {
                 dividend,
                 dst,
             } => {
-                let divisor = pretty_print_reg(divisor.to_reg(), 1, allocs);
-                let dividend = pretty_print_reg(dividend.to_reg(), 1, allocs);
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 1, allocs);
+                let divisor = pretty_print_reg(divisor.to_reg(), 1);
+                let dividend = pretty_print_reg(dividend.to_reg(), 1);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 1);
                 format!("checked_srem_seq {dividend}, {divisor}, {dst}")
             }
 
             Inst::SignExtendData { size, src, dst } => {
-                let src = pretty_print_reg(src.to_reg(), size.to_bytes(), allocs);
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), size.to_bytes(), allocs);
+                let src = pretty_print_reg(src.to_reg(), size.to_bytes());
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), size.to_bytes());
                 let op = match size {
                     OperandSize::Size8 => "cbw",
                     OperandSize::Size16 => "cwd",
@@ -935,15 +959,15 @@ impl PrettyPrint for Inst {
             }
 
             Inst::XmmUnaryRmR { op, src, dst, .. } => {
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), op.src_size(), allocs);
-                let src = src.pretty_print(op.src_size(), allocs);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), op.src_size());
+                let src = src.pretty_print(op.src_size());
                 let op = ljustify(op.to_string());
                 format!("{op} {src}, {dst}")
             }
 
             Inst::XmmUnaryRmRUnaligned { op, src, dst, .. } => {
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), op.src_size(), allocs);
-                let src = src.pretty_print(op.src_size(), allocs);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), op.src_size());
+                let src = src.pretty_print(op.src_size());
                 let op = ljustify(op.to_string());
                 format!("{op} {src}, {dst}")
             }
@@ -951,15 +975,15 @@ impl PrettyPrint for Inst {
             Inst::XmmUnaryRmRImm {
                 op, src, dst, imm, ..
             } => {
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), op.src_size(), allocs);
-                let src = src.pretty_print(op.src_size(), allocs);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), op.src_size());
+                let src = src.pretty_print(op.src_size());
                 let op = ljustify(op.to_string());
                 format!("{op} ${imm}, {src}, {dst}")
             }
 
             Inst::XmmUnaryRmRVex { op, src, dst, .. } => {
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8, allocs);
-                let src = src.pretty_print(8, allocs);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8);
+                let src = src.pretty_print(8);
                 let op = ljustify(op.to_string());
                 format!("{op} {src}, {dst}")
             }
@@ -967,15 +991,15 @@ impl PrettyPrint for Inst {
             Inst::XmmUnaryRmRImmVex {
                 op, src, dst, imm, ..
             } => {
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8, allocs);
-                let src = src.pretty_print(8, allocs);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8);
+                let src = src.pretty_print(8);
                 let op = ljustify(op.to_string());
                 format!("{op} ${imm}, {src}, {dst}")
             }
 
             Inst::XmmUnaryRmREvex { op, src, dst, .. } => {
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8, allocs);
-                let src = src.pretty_print(8, allocs);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8);
+                let src = src.pretty_print(8);
                 let op = ljustify(op.to_string());
                 format!("{op} {src}, {dst}")
             }
@@ -983,22 +1007,22 @@ impl PrettyPrint for Inst {
             Inst::XmmUnaryRmRImmEvex {
                 op, src, dst, imm, ..
             } => {
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8, allocs);
-                let src = src.pretty_print(8, allocs);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8);
+                let src = src.pretty_print(8);
                 let op = ljustify(op.to_string());
                 format!("{op} ${imm}, {src}, {dst}")
             }
 
             Inst::XmmMovRM { op, src, dst, .. } => {
-                let src = pretty_print_reg(src.to_reg(), 8, allocs);
-                let dst = dst.pretty_print(8, allocs);
+                let src = pretty_print_reg(src.to_reg(), 8);
+                let dst = dst.pretty_print(8);
                 let op = ljustify(op.to_string());
                 format!("{op} {src}, {dst}")
             }
 
             Inst::XmmMovRMVex { op, src, dst, .. } => {
-                let src = pretty_print_reg(src.to_reg(), 8, allocs);
-                let dst = dst.pretty_print(8, allocs);
+                let src = pretty_print_reg(src.to_reg(), 8);
+                let dst = dst.pretty_print(8);
                 let op = ljustify(op.to_string());
                 format!("{op} {src}, {dst}")
             }
@@ -1006,8 +1030,8 @@ impl PrettyPrint for Inst {
             Inst::XmmMovRMImm {
                 op, src, dst, imm, ..
             } => {
-                let src = pretty_print_reg(src.to_reg(), 8, allocs);
-                let dst = dst.pretty_print(8, allocs);
+                let src = pretty_print_reg(src.to_reg(), 8);
+                let dst = dst.pretty_print(8);
                 let op = ljustify(op.to_string());
                 format!("{op} ${imm}, {src}, {dst}")
             }
@@ -1015,8 +1039,8 @@ impl PrettyPrint for Inst {
             Inst::XmmMovRMImmVex {
                 op, src, dst, imm, ..
             } => {
-                let src = pretty_print_reg(src.to_reg(), 8, allocs);
-                let dst = dst.pretty_print(8, allocs);
+                let src = pretty_print_reg(src.to_reg(), 8);
+                let dst = dst.pretty_print(8);
                 let op = ljustify(op.to_string());
                 format!("{op} ${imm}, {src}, {dst}")
             }
@@ -1028,9 +1052,9 @@ impl PrettyPrint for Inst {
                 dst,
                 ..
             } => {
-                let src1 = pretty_print_reg(src1.to_reg(), 8, allocs);
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8, allocs);
-                let src2 = src2.pretty_print(8, allocs);
+                let src1 = pretty_print_reg(src1.to_reg(), 8);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8);
+                let src2 = src2.pretty_print(8);
                 let op = ljustify(op.to_string());
                 format!("{op} {src1}, {src2}, {dst}")
             }
@@ -1042,9 +1066,9 @@ impl PrettyPrint for Inst {
                 dst,
                 ..
             } => {
-                let src1 = pretty_print_reg(src1.to_reg(), 8, allocs);
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8, allocs);
-                let src2 = src2.pretty_print(8, allocs);
+                let src1 = pretty_print_reg(src1.to_reg(), 8);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8);
+                let src2 = src2.pretty_print(8);
                 let op = ljustify(op.to_string());
                 format!("{op} {src1}, {src2}, {dst}")
             }
@@ -1056,16 +1080,16 @@ impl PrettyPrint for Inst {
                 mask,
                 dst,
             } => {
-                let src1 = pretty_print_reg(src1.to_reg(), 8, allocs);
-                let mask = allocs.next(mask.to_reg());
+                let src1 = pretty_print_reg(src1.to_reg(), 8);
+                let mask = mask.to_reg();
                 let mask = if mask.is_virtual() {
                     format!(" <{}>", show_ireg_sized(mask, 8))
                 } else {
                     debug_assert_eq!(mask, regs::xmm0());
                     String::new()
                 };
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8, allocs);
-                let src2 = src2.pretty_print(8, allocs);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8);
+                let src2 = src2.pretty_print(8);
                 let op = ljustify(op.to_string());
                 format!("{op} {src1}, {src2}, {dst}{mask}")
             }
@@ -1077,9 +1101,9 @@ impl PrettyPrint for Inst {
                 dst,
                 ..
             } => {
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8, allocs);
-                let src1 = pretty_print_reg(src1.to_reg(), 8, allocs);
-                let src2 = src2.pretty_print(8, allocs);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8);
+                let src1 = pretty_print_reg(src1.to_reg(), 8);
+                let src2 = src2.pretty_print(8);
                 let op = ljustify(op.to_string());
                 format!("{op} {src1}, {src2}, {dst}")
             }
@@ -1092,9 +1116,9 @@ impl PrettyPrint for Inst {
                 imm,
                 ..
             } => {
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8, allocs);
-                let src1 = pretty_print_reg(src1.to_reg(), 8, allocs);
-                let src2 = src2.pretty_print(8, allocs);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8);
+                let src1 = pretty_print_reg(src1.to_reg(), 8);
+                let src2 = src2.pretty_print(8);
                 let op = ljustify(op.to_string());
                 format!("{op} ${imm}, {src1}, {src2}, {dst}")
             }
@@ -1107,9 +1131,9 @@ impl PrettyPrint for Inst {
                 imm,
                 ..
             } => {
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8, allocs);
-                let src1 = pretty_print_reg(src1.to_reg(), 8, allocs);
-                let src2 = src2.pretty_print(8, allocs);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8);
+                let src1 = pretty_print_reg(src1.to_reg(), 8);
+                let src2 = src2.pretty_print(8);
                 let op = ljustify(op.to_string());
                 format!("{op} ${imm}, {src1}, {src2}, {dst}")
             }
@@ -1122,10 +1146,10 @@ impl PrettyPrint for Inst {
                 dst,
                 ..
             } => {
-                let src1 = pretty_print_reg(src1.to_reg(), 8, allocs);
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8, allocs);
-                let src2 = pretty_print_reg(src2.to_reg(), 8, allocs);
-                let src3 = src3.pretty_print(8, allocs);
+                let src1 = pretty_print_reg(src1.to_reg(), 8);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8);
+                let src2 = pretty_print_reg(src2.to_reg(), 8);
+                let src3 = src3.pretty_print(8);
                 let op = ljustify(op.to_string());
                 format!("{op} {src1}, {src2}, {src3}, {dst}")
             }
@@ -1138,10 +1162,10 @@ impl PrettyPrint for Inst {
                 dst,
                 ..
             } => {
-                let src1 = pretty_print_reg(src1.to_reg(), 8, allocs);
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8, allocs);
-                let src2 = src2.pretty_print(8, allocs);
-                let mask = pretty_print_reg(mask.to_reg(), 8, allocs);
+                let src1 = pretty_print_reg(src1.to_reg(), 8);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8);
+                let src2 = src2.pretty_print(8);
+                let mask = pretty_print_reg(mask.to_reg(), 8);
                 let op = ljustify(op.to_string());
                 format!("{op} {src1}, {src2}, {mask}, {dst}")
             }
@@ -1153,11 +1177,11 @@ impl PrettyPrint for Inst {
                 dst,
                 ..
             } => {
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8, allocs);
-                let src1 = pretty_print_reg(src1.to_reg(), 8, allocs);
-                let src2 = src2.pretty_print(8, allocs);
+                let src1 = pretty_print_reg(src1.to_reg(), 8);
+                let src2 = src2.pretty_print(8);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8);
                 let op = ljustify(op.to_string());
-                format!("{op} {src1}, {src2}, {dst}")
+                format!("{op} {src2}, {src1}, {dst}")
             }
 
             Inst::XmmRmREvex3 {
@@ -1168,12 +1192,12 @@ impl PrettyPrint for Inst {
                 dst,
                 ..
             } => {
-                let src1 = pretty_print_reg(src1.to_reg(), 8, allocs);
-                let src2 = pretty_print_reg(src2.to_reg(), 8, allocs);
-                let src3 = src3.pretty_print(8, allocs);
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8, allocs);
+                let src1 = pretty_print_reg(src1.to_reg(), 8);
+                let src2 = pretty_print_reg(src2.to_reg(), 8);
+                let src3 = src3.pretty_print(8);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8);
                 let op = ljustify(op.to_string());
-                format!("{op} {src1}, {src2}, {src3}, {dst}")
+                format!("{op} {src3}, {src2}, {src1}, {dst}")
             }
 
             Inst::XmmMinMaxSeq {
@@ -1183,9 +1207,9 @@ impl PrettyPrint for Inst {
                 is_min,
                 size,
             } => {
-                let rhs = pretty_print_reg(rhs.to_reg(), 8, allocs);
-                let lhs = pretty_print_reg(lhs.to_reg(), 8, allocs);
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8, allocs);
+                let rhs = pretty_print_reg(rhs.to_reg(), 8);
+                let lhs = pretty_print_reg(lhs.to_reg(), 8);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8);
                 let op = ljustify2(
                     if *is_min {
                         "xmm min seq ".to_string()
@@ -1206,9 +1230,9 @@ impl PrettyPrint for Inst {
                 size,
                 ..
             } => {
-                let src1 = pretty_print_reg(*src1, 8, allocs);
-                let dst = pretty_print_reg(dst.to_reg(), 8, allocs);
-                let src2 = src2.pretty_print(8, allocs);
+                let src1 = pretty_print_reg(*src1, 8);
+                let dst = pretty_print_reg(dst.to_reg(), 8);
+                let src2 = src2.pretty_print(8);
                 let op = ljustify(format!(
                     "{}{}",
                     op.to_string(),
@@ -1222,7 +1246,7 @@ impl PrettyPrint for Inst {
             }
 
             Inst::XmmUninitializedValue { dst } => {
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8, allocs);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8);
                 let op = ljustify("uninit".into());
                 format!("{op} {dst}")
             }
@@ -1234,8 +1258,8 @@ impl PrettyPrint for Inst {
                 dst_size,
             } => {
                 let dst_size = dst_size.to_bytes();
-                let src = pretty_print_reg(src.to_reg(), 8, allocs);
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), dst_size, allocs);
+                let src = pretty_print_reg(src.to_reg(), 8);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), dst_size);
                 let op = ljustify(op.to_string());
                 format!("{op} {src}, {dst}")
             }
@@ -1247,22 +1271,22 @@ impl PrettyPrint for Inst {
                 dst_size,
             } => {
                 let dst_size = dst_size.to_bytes();
-                let src = pretty_print_reg(src.to_reg(), 8, allocs);
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), dst_size, allocs);
+                let src = pretty_print_reg(src.to_reg(), 8);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), dst_size);
                 let op = ljustify(op.to_string());
                 format!("{op} {src}, {dst}")
             }
 
             Inst::XmmToGprImm { op, src, dst, imm } => {
-                let src = pretty_print_reg(src.to_reg(), 8, allocs);
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8, allocs);
+                let src = pretty_print_reg(src.to_reg(), 8);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8);
                 let op = ljustify(op.to_string());
                 format!("{op} ${imm}, {src}, {dst}")
             }
 
             Inst::XmmToGprImmVex { op, src, dst, imm } => {
-                let src = pretty_print_reg(src.to_reg(), 8, allocs);
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8, allocs);
+                let src = pretty_print_reg(src.to_reg(), 8);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8);
                 let op = ljustify(op.to_string());
                 format!("{op} ${imm}, {src}, {dst}")
             }
@@ -1273,8 +1297,8 @@ impl PrettyPrint for Inst {
                 src_size,
                 dst,
             } => {
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8, allocs);
-                let src = src.pretty_print(src_size.to_bytes(), allocs);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8);
+                let src = src.pretty_print(src_size.to_bytes());
                 let op = ljustify(op.to_string());
                 format!("{op} {src}, {dst}")
             }
@@ -1285,17 +1309,17 @@ impl PrettyPrint for Inst {
                 src_size,
                 dst,
             } => {
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8, allocs);
-                let src = src.pretty_print(src_size.to_bytes(), allocs);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8);
+                let src = src.pretty_print(src_size.to_bytes());
                 let op = ljustify(op.to_string());
                 format!("{op} {src}, {dst}")
             }
 
-            Inst::XmmCmpRmR { op, src, dst } => {
-                let dst = pretty_print_reg(dst.to_reg(), 8, allocs);
-                let src = src.pretty_print(8, allocs);
+            Inst::XmmCmpRmR { op, src1, src2 } => {
+                let src1 = pretty_print_reg(src1.to_reg(), 8);
+                let src2 = src2.pretty_print(8);
                 let op = ljustify(op.to_string());
-                format!("{op} {src}, {dst}")
+                format!("{op} {src2}, {src1}")
             }
 
             Inst::CvtIntToFloat {
@@ -1305,9 +1329,9 @@ impl PrettyPrint for Inst {
                 dst,
                 src2_size,
             } => {
-                let src1 = pretty_print_reg(src1.to_reg(), 8, allocs);
-                let dst = pretty_print_reg(*dst.to_reg(), 8, allocs);
-                let src2 = src2.pretty_print(src2_size.to_bytes(), allocs);
+                let src1 = pretty_print_reg(src1.to_reg(), 8);
+                let dst = pretty_print_reg(*dst.to_reg(), 8);
+                let src2 = src2.pretty_print(src2_size.to_bytes());
                 let op = ljustify(op.to_string());
                 format!("{op} {src1}, {src2}, {dst}")
             }
@@ -1319,13 +1343,19 @@ impl PrettyPrint for Inst {
                 dst,
                 src2_size,
             } => {
-                let dst = pretty_print_reg(*dst.to_reg(), 8, allocs);
-                let src1 = pretty_print_reg(src1.to_reg(), 8, allocs);
-                let src2 = src2.pretty_print(src2_size.to_bytes(), allocs);
+                let dst = pretty_print_reg(*dst.to_reg(), 8);
+                let src1 = pretty_print_reg(src1.to_reg(), 8);
+                let src2 = src2.pretty_print(src2_size.to_bytes());
                 let op = ljustify(op.to_string());
                 format!("{op} {src1}, {src2}, {dst}")
             }
 
+            Inst::XmmCmpRmRVex { op, src1, src2 } => {
+                let src1 = pretty_print_reg(src1.to_reg(), 8);
+                let src2 = src2.pretty_print(8);
+                format!("{} {src2}, {src1}", ljustify(op.to_string()))
+            }
+
             Inst::CvtUint64ToFloatSeq {
                 src,
                 dst,
@@ -1334,10 +1364,10 @@ impl PrettyPrint for Inst {
                 tmp_gpr2,
                 ..
             } => {
-                let src = pretty_print_reg(src.to_reg(), 8, allocs);
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), dst_size.to_bytes(), allocs);
-                let tmp_gpr1 = pretty_print_reg(tmp_gpr1.to_reg().to_reg(), 8, allocs);
-                let tmp_gpr2 = pretty_print_reg(tmp_gpr2.to_reg().to_reg(), 8, allocs);
+                let src = pretty_print_reg(src.to_reg(), 8);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), dst_size.to_bytes());
+                let tmp_gpr1 = pretty_print_reg(tmp_gpr1.to_reg().to_reg(), 8);
+                let tmp_gpr2 = pretty_print_reg(tmp_gpr2.to_reg().to_reg(), 8);
                 let op = ljustify(format!(
                     "u64_to_{}_seq",
                     if *dst_size == OperandSize::Size64 {
@@ -1358,10 +1388,10 @@ impl PrettyPrint for Inst {
                 tmp_gpr,
                 is_saturating,
             } => {
-                let src = pretty_print_reg(src.to_reg(), src_size.to_bytes(), allocs);
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), dst_size.to_bytes(), allocs);
-                let tmp_gpr = pretty_print_reg(tmp_gpr.to_reg().to_reg(), 8, allocs);
-                let tmp_xmm = pretty_print_reg(tmp_xmm.to_reg().to_reg(), 8, allocs);
+                let src = pretty_print_reg(src.to_reg(), src_size.to_bytes());
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), dst_size.to_bytes());
+                let tmp_gpr = pretty_print_reg(tmp_gpr.to_reg().to_reg(), 8);
+                let tmp_xmm = pretty_print_reg(tmp_xmm.to_reg().to_reg(), 8);
                 let op = ljustify(format!(
                     "cvt_float{}_to_sint{}{}_seq",
                     src_size.to_bits(),
@@ -1381,11 +1411,11 @@ impl PrettyPrint for Inst {
                 tmp_xmm2,
                 is_saturating,
             } => {
-                let src = pretty_print_reg(src.to_reg(), src_size.to_bytes(), allocs);
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), dst_size.to_bytes(), allocs);
-                let tmp_gpr = pretty_print_reg(tmp_gpr.to_reg().to_reg(), 8, allocs);
-                let tmp_xmm = pretty_print_reg(tmp_xmm.to_reg().to_reg(), 8, allocs);
-                let tmp_xmm2 = pretty_print_reg(tmp_xmm2.to_reg().to_reg(), 8, allocs);
+                let src = pretty_print_reg(src.to_reg(), src_size.to_bytes());
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), dst_size.to_bytes());
+                let tmp_gpr = pretty_print_reg(tmp_gpr.to_reg().to_reg(), 8);
+                let tmp_xmm = pretty_print_reg(tmp_xmm.to_reg().to_reg(), 8);
+                let tmp_xmm2 = pretty_print_reg(tmp_xmm2.to_reg().to_reg(), 8);
                 let op = ljustify(format!(
                     "cvt_float{}_to_uint{}{}_seq",
                     src_size.to_bits(),
@@ -1400,7 +1430,7 @@ impl PrettyPrint for Inst {
                 simm64,
                 dst,
             } => {
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), dst_size.to_bytes(), allocs);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), dst_size.to_bytes());
                 if *dst_size == OperandSize::Size64 {
                     let op = ljustify("movabsq".to_string());
                     let imm = *simm64 as i64;
@@ -1413,7 +1443,7 @@ impl PrettyPrint for Inst {
             }
 
             Inst::MovImmM { size, simm32, dst } => {
-                let dst = dst.pretty_print(size.to_bytes(), allocs);
+                let dst = dst.pretty_print(size.to_bytes());
                 let suffix = suffix_bwlq(*size);
                 let imm = match *size {
                     OperandSize::Size8 => ((*simm32 as u8) as i8).to_string(),
@@ -1426,24 +1456,22 @@ impl PrettyPrint for Inst {
             }
 
             Inst::MovRR { size, src, dst } => {
-                let src = pretty_print_reg(src.to_reg(), size.to_bytes(), allocs);
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), size.to_bytes(), allocs);
+                let src = pretty_print_reg(src.to_reg(), size.to_bytes());
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), size.to_bytes());
                 let op = ljustify2("mov".to_string(), suffix_lq(*size));
                 format!("{op} {src}, {dst}")
             }
 
             Inst::MovFromPReg { src, dst } => {
-                allocs.next_fixed_nonallocatable(*src);
                 let src: Reg = (*src).into();
                 let src = regs::show_ireg_sized(src, 8);
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8, allocs);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8);
                 let op = ljustify("movq".to_string());
                 format!("{op} {src}, {dst}")
             }
 
             Inst::MovToPReg { src, dst } => {
-                let src = pretty_print_reg(src.to_reg(), 8, allocs);
-                allocs.next_fixed_nonallocatable(*dst);
+                let src = pretty_print_reg(src.to_reg(), 8);
                 let dst: Reg = (*dst).into();
                 let dst = regs::show_ireg_sized(dst, 8);
                 let op = ljustify("movq".to_string());
@@ -1458,8 +1486,8 @@ impl PrettyPrint for Inst {
                 } else {
                     ext_mode.dst_size()
                 };
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), dst_size, allocs);
-                let src = src.pretty_print(ext_mode.src_size(), allocs);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), dst_size);
+                let src = src.pretty_print(ext_mode.src_size());
 
                 if *ext_mode == ExtMode::LQ {
                     let op = ljustify("movl".to_string());
@@ -1471,15 +1499,15 @@ impl PrettyPrint for Inst {
             }
 
             Inst::Mov64MR { src, dst, .. } => {
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8, allocs);
-                let src = src.pretty_print(8, allocs);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8);
+                let src = src.pretty_print(8);
                 let op = ljustify("movq".to_string());
                 format!("{op} {src}, {dst}")
             }
 
             Inst::LoadEffectiveAddress { addr, dst, size } => {
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), size.to_bytes(), allocs);
-                let addr = addr.pretty_print(8, allocs);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), size.to_bytes());
+                let addr = addr.pretty_print(8);
                 let op = ljustify("lea".to_string());
                 format!("{op} {addr}, {dst}")
             }
@@ -1487,15 +1515,15 @@ impl PrettyPrint for Inst {
             Inst::MovsxRmR {
                 ext_mode, src, dst, ..
             } => {
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), ext_mode.dst_size(), allocs);
-                let src = src.pretty_print(ext_mode.src_size(), allocs);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), ext_mode.dst_size());
+                let src = src.pretty_print(ext_mode.src_size());
                 let op = ljustify2("movs".to_string(), ext_mode.to_string());
                 format!("{op} {src}, {dst}")
             }
 
             Inst::MovRM { size, src, dst, .. } => {
-                let src = pretty_print_reg(src.to_reg(), size.to_bytes(), allocs);
-                let dst = dst.pretty_print(size.to_bytes(), allocs);
+                let src = pretty_print_reg(src.to_reg(), size.to_bytes());
+                let dst = dst.pretty_print(size.to_bytes());
                 let op = ljustify2("mov".to_string(), suffix_bwlq(*size));
                 format!("{op} {src}, {dst}")
             }
@@ -1508,16 +1536,16 @@ impl PrettyPrint for Inst {
                 dst,
                 ..
             } => {
-                let src = pretty_print_reg(src.to_reg(), size.to_bytes(), allocs);
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), size.to_bytes(), allocs);
-                match num_bits.clone().to_imm8_reg() {
-                    Imm8Reg::Reg { reg } => {
-                        let reg = pretty_print_reg(reg, 1, allocs);
+                let src = pretty_print_reg(src.to_reg(), size.to_bytes());
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), size.to_bytes());
+                match num_bits.as_imm8_reg() {
+                    &Imm8Reg::Reg { reg } => {
+                        let reg = pretty_print_reg(reg, 1);
                         let op = ljustify2(kind.to_string(), suffix_bwlq(*size));
                         format!("{op} {reg}, {src}, {dst}")
                     }
 
-                    Imm8Reg::Imm8 { imm: num_bits } => {
+                    &Imm8Reg::Imm8 { imm: num_bits } => {
                         let op = ljustify2(kind.to_string(), suffix_bwlq(*size));
                         format!("{op} ${num_bits}, {src}, {dst}")
                     }
@@ -1531,38 +1559,38 @@ impl PrettyPrint for Inst {
                 dst,
                 ..
             } => {
-                let src1 = pretty_print_reg(src1.to_reg(), 8, allocs);
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8, allocs);
-                let src2 = src2.pretty_print(8, allocs);
+                let src1 = pretty_print_reg(src1.to_reg(), 8);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8);
+                let src2 = src2.pretty_print(8);
                 let op = ljustify(opcode.to_string());
                 format!("{op} {src1}, {src2}, {dst}")
             }
 
             Inst::CmpRmiR {
                 size,
-                src,
-                dst,
+                src1,
+                src2,
                 opcode,
             } => {
-                let dst = pretty_print_reg(dst.to_reg(), size.to_bytes(), allocs);
-                let src = src.pretty_print(size.to_bytes(), allocs);
+                let src1 = pretty_print_reg(src1.to_reg(), size.to_bytes());
+                let src2 = src2.pretty_print(size.to_bytes());
                 let op = match opcode {
                     CmpOpcode::Cmp => "cmp",
                     CmpOpcode::Test => "test",
                 };
                 let op = ljustify2(op.to_string(), suffix_bwlq(*size));
-                format!("{op} {src}, {dst}")
+                format!("{op} {src2}, {src1}")
             }
 
             Inst::Setcc { cc, dst } => {
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 1, allocs);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 1);
                 let op = ljustify2("set".to_string(), cc.to_string());
                 format!("{op} {dst}")
             }
 
             Inst::Bswap { size, src, dst } => {
-                let src = pretty_print_reg(src.to_reg(), size.to_bytes(), allocs);
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), size.to_bytes(), allocs);
+                let src = pretty_print_reg(src.to_reg(), size.to_bytes());
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), size.to_bytes());
                 let op = ljustify2("bswap".to_string(), suffix_bwlq(*size));
                 format!("{op} {src}, {dst}")
             }
@@ -1574,9 +1602,9 @@ impl PrettyPrint for Inst {
                 alternative,
                 dst,
             } => {
-                let alternative = pretty_print_reg(alternative.to_reg(), size.to_bytes(), allocs);
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), size.to_bytes(), allocs);
-                let consequent = consequent.pretty_print(size.to_bytes(), allocs);
+                let alternative = pretty_print_reg(alternative.to_reg(), size.to_bytes());
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), size.to_bytes());
+                let consequent = consequent.pretty_print(size.to_bytes());
                 let op = ljustify(format!("cmov{}{}", cc.to_string(), suffix_bwlq(*size)));
                 format!("{op} {consequent}, {alternative}, {dst}")
             }
@@ -1590,12 +1618,13 @@ impl PrettyPrint for Inst {
                 ..
             } => {
                 let size = u8::try_from(ty.bytes()).unwrap();
-                let alternative = pretty_print_reg(alternative.to_reg(), size, allocs);
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), size, allocs);
-                let consequent = consequent.pretty_print(size, allocs);
+                let alternative = pretty_print_reg(alternative.to_reg(), size);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), size);
+                let consequent = pretty_print_reg(consequent.to_reg(), size);
                 let suffix = match *ty {
                     types::F64 => "sd",
                     types::F32 => "ss",
+                    types::F16 => "ss",
                     types::F32X4 => "aps",
                     types::F64X2 => "apd",
                     _ => "dqa",
@@ -1610,7 +1639,7 @@ impl PrettyPrint for Inst {
             }
 
             Inst::Push64 { src } => {
-                let src = src.pretty_print(8, allocs);
+                let src = src.pretty_print(8);
                 let op = ljustify("pushq".to_string());
                 format!("{op} {src}")
             }
@@ -1620,13 +1649,13 @@ impl PrettyPrint for Inst {
                 frame_size,
                 guard_size,
             } => {
-                let tmp = pretty_print_reg(tmp.to_reg(), 8, allocs);
+                let tmp = pretty_print_reg(tmp.to_reg(), 8);
                 let op = ljustify("stack_probe_loop".to_string());
                 format!("{op} {tmp}, frame_size={frame_size}, guard_size={guard_size}")
             }
 
             Inst::Pop64 { dst } => {
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8, allocs);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8);
                 let op = ljustify("popq".to_string());
                 format!("{op} {dst}")
             }
@@ -1637,35 +1666,23 @@ impl PrettyPrint for Inst {
             }
 
             Inst::CallUnknown { dest, .. } => {
-                let dest = dest.pretty_print(8, allocs);
+                let dest = dest.pretty_print(8);
                 let op = ljustify("call".to_string());
                 format!("{op} *{dest}")
             }
 
             Inst::ReturnCallKnown { callee, info } => {
                 let ReturnCallInfo {
+                    uses,
                     new_stack_arg_size,
-                    old_stack_arg_size,
-                    ret_addr,
-                    fp,
                     tmp,
-                    uses,
                 } = &**info;
-                let ret_addr = ret_addr.map(|r| regs::show_reg(*r));
-                let fp = regs::show_reg(fp.to_reg());
-                let tmp = regs::show_reg(tmp.to_reg().to_reg());
-                let mut s = format!(
-                    "return_call_known \
-                     {callee:?} \
-                     new_stack_arg_size:{new_stack_arg_size} \
-                     old_stack_arg_size:{old_stack_arg_size} \
-                     ret_addr:{ret_addr:?} \
-                     fp:{fp} \
-                     tmp:{tmp}"
-                );
+                let tmp = pretty_print_reg(tmp.to_reg().to_reg(), 8);
+                let mut s =
+                    format!("return_call_known {callee:?} ({new_stack_arg_size}) tmp={tmp}");
                 for ret in uses {
                     let preg = regs::show_reg(ret.preg);
-                    let vreg = pretty_print_reg(ret.vreg, 8, allocs);
+                    let vreg = pretty_print_reg(ret.vreg, 8);
                     write!(&mut s, " {vreg}={preg}").unwrap();
                 }
                 s
@@ -1673,29 +1690,17 @@ impl PrettyPrint for Inst {
 
             Inst::ReturnCallUnknown { callee, info } => {
                 let ReturnCallInfo {
+                    uses,
                     new_stack_arg_size,
-                    old_stack_arg_size,
-                    ret_addr,
-                    fp,
                     tmp,
-                    uses,
                 } = &**info;
-                let callee = callee.pretty_print(8, allocs);
-                let ret_addr = ret_addr.map(|r| regs::show_reg(*r));
-                let fp = regs::show_reg(fp.to_reg());
-                let tmp = regs::show_reg(tmp.to_reg().to_reg());
-                let mut s = format!(
-                    "return_call_unknown \
-                     {callee} \
-                     new_stack_arg_size:{new_stack_arg_size} \
-                     old_stack_arg_size:{old_stack_arg_size} \
-                     ret_addr:{ret_addr:?} \
-                     fp:{fp} \
-                     tmp:{tmp}"
-                );
+                let callee = pretty_print_reg(*callee, 8);
+                let tmp = pretty_print_reg(tmp.to_reg().to_reg(), 8);
+                let mut s =
+                    format!("return_call_unknown {callee} ({new_stack_arg_size}) tmp={tmp}");
                 for ret in uses {
                     let preg = regs::show_reg(ret.preg);
-                    let vreg = pretty_print_reg(ret.vreg, 8, allocs);
+                    let vreg = pretty_print_reg(ret.vreg, 8);
                     write!(&mut s, " {vreg}={preg}").unwrap();
                 }
                 s
@@ -1705,7 +1710,7 @@ impl PrettyPrint for Inst {
                 let mut s = "args".to_string();
                 for arg in args {
                     let preg = regs::show_reg(arg.preg);
-                    let def = pretty_print_reg(arg.vreg.to_reg(), 8, allocs);
+                    let def = pretty_print_reg(arg.vreg.to_reg(), 8);
                     write!(&mut s, " {def}={preg}").unwrap();
                 }
                 s
@@ -1715,7 +1720,7 @@ impl PrettyPrint for Inst {
                 let mut s = "rets".to_string();
                 for ret in rets {
                     let preg = regs::show_reg(ret.preg);
-                    let vreg = pretty_print_reg(ret.vreg, 8, allocs);
+                    let vreg = pretty_print_reg(ret.vreg, 8);
                     write!(&mut s, " {vreg}={preg}").unwrap();
                 }
                 s
@@ -1729,6 +1734,19 @@ impl PrettyPrint for Inst {
                 s
             }
 
+            Inst::StackSwitchBasic {
+                store_context_ptr,
+                load_context_ptr,
+                in_payload0,
+                out_payload0,
+            } => {
+                let store_context_ptr = pretty_print_reg(**store_context_ptr, 8);
+                let load_context_ptr = pretty_print_reg(**load_context_ptr, 8);
+                let in_payload0 = pretty_print_reg(**in_payload0, 8);
+                let out_payload0 = pretty_print_reg(*out_payload0.to_reg(), 8);
+                format!("{out_payload0} = stack_switch_basic {store_context_ptr}, {load_context_ptr}, {in_payload0}")
+            }
+
             Inst::JmpKnown { dst } => {
                 let op = ljustify("jmp".to_string());
                 let dst = dst.to_string();
@@ -1755,15 +1773,15 @@ impl PrettyPrint for Inst {
             Inst::JmpTableSeq {
                 idx, tmp1, tmp2, ..
             } => {
-                let idx = pretty_print_reg(*idx, 8, allocs);
-                let tmp1 = pretty_print_reg(tmp1.to_reg(), 8, allocs);
-                let tmp2 = pretty_print_reg(tmp2.to_reg(), 8, allocs);
+                let idx = pretty_print_reg(*idx, 8);
+                let tmp1 = pretty_print_reg(tmp1.to_reg(), 8);
+                let tmp2 = pretty_print_reg(tmp2.to_reg(), 8);
                 let op = ljustify("br_table".into());
                 format!("{op} {idx}, {tmp1}, {tmp2}")
             }
 
             Inst::JmpUnknown { target } => {
-                let target = target.pretty_print(8, allocs);
+                let target = target.pretty_print(8);
                 let op = ljustify("jmp".to_string());
                 format!("{op} *{target}")
             }
@@ -1796,7 +1814,7 @@ impl PrettyPrint for Inst {
             Inst::LoadExtName {
                 dst, name, offset, ..
             } => {
-                let dst = pretty_print_reg(dst.to_reg(), 8, allocs);
+                let dst = pretty_print_reg(dst.to_reg(), 8);
                 let name = name.display(None);
                 let op = ljustify("load_ext_name".into());
                 format!("{op} {name}+{offset}, {dst}")
@@ -1811,10 +1829,10 @@ impl PrettyPrint for Inst {
                 ..
             } => {
                 let size = ty.bytes() as u8;
-                let replacement = pretty_print_reg(*replacement, size, allocs);
-                let expected = pretty_print_reg(*expected, size, allocs);
-                let dst_old = pretty_print_reg(dst_old.to_reg(), size, allocs);
-                let mem = mem.pretty_print(size, allocs);
+                let replacement = pretty_print_reg(*replacement, size);
+                let expected = pretty_print_reg(*expected, size);
+                let dst_old = pretty_print_reg(dst_old.to_reg(), size);
+                let mem = mem.pretty_print(size);
                 let suffix = suffix_bwlq(OperandSize::from_bytes(size as u32));
                 format!(
                     "lock cmpxchg{suffix} {replacement}, {mem}, expected={expected}, dst_old={dst_old}"
@@ -1834,19 +1852,17 @@ impl PrettyPrint for Inst {
                 FenceKind::SFence => "sfence".to_string(),
             },
 
-            Inst::VirtualSPOffsetAdj { offset } => format!("virtual_sp_offset_adjust {offset}"),
-
             Inst::Hlt => "hlt".into(),
 
             Inst::Ud2 { trap_code } => format!("ud2 {trap_code}"),
 
             Inst::ElfTlsGetAddr { ref symbol, dst } => {
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8, allocs);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8);
                 format!("{dst} = elf_tls_get_addr {symbol:?}")
             }
 
             Inst::MachOTlsGetAddr { ref symbol, dst } => {
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8, allocs);
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8);
                 format!("{dst} = macho_tls_get_addr {symbol:?}")
             }
 
@@ -1855,8 +1871,8 @@ impl PrettyPrint for Inst {
                 dst,
                 tmp,
             } => {
-                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8, allocs);
-                let tmp = allocs.next(tmp.to_reg().to_reg());
+                let dst = pretty_print_reg(dst.to_reg().to_reg(), 8);
+                let tmp = tmp.to_reg().to_reg();
 
                 let mut s = format!("{dst} = coff_tls_get_addr {symbol:?}");
                 if tmp.is_virtual() {
@@ -1870,7 +1886,7 @@ impl PrettyPrint for Inst {
             Inst::Unwind { inst } => format!("unwind {inst:?}"),
 
             Inst::DummyUse { reg } => {
-                let reg = pretty_print_reg(*reg, 8, allocs);
+                let reg = pretty_print_reg(*reg, 8);
                 format!("dummy_use {reg}")
             }
         }
@@ -1879,18 +1895,11 @@ impl PrettyPrint for Inst {
 
 impl fmt::Debug for Inst {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            fmt,
-            "{}",
-            self.pretty_print_inst(&[], &mut Default::default())
-        )
+        write!(fmt, "{}", self.pretty_print_inst(&mut Default::default()))
     }
 }
 
-fn x64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut OperandCollector<'_, F>) {
-    // FIXME: remove all remaining `mod` operands here to get to pure
-    // SSA.
-
+fn x64_get_operands(inst: &mut Inst, collector: &mut impl OperandVisitor) {
     // Note: because we need to statically know the indices of each
     // reg in the operands list in order to fetch its allocation
     // later, we put the variable-operand-count bits (the RegMem,
@@ -1902,127 +1911,134 @@ fn x64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut OperandCol
     // method above.
     match inst {
         Inst::AluRmiR {
-            size,
-            op,
-            src1,
-            src2,
-            dst,
-            ..
+            src1, src2, dst, ..
         } => {
-            if *size == OperandSize::Size8 && *op == AluRmiROpcode::Mul {
-                // 8-bit imul has RAX as a fixed input/output
-                collector.reg_fixed_use(src1.to_reg(), regs::rax());
-                collector.reg_fixed_def(dst.to_writable_reg(), regs::rax());
-                src2.get_operands(collector);
-            } else {
-                collector.reg_use(src1.to_reg());
-                collector.reg_reuse_def(dst.to_writable_reg(), 0);
-                src2.get_operands(collector);
-            }
+            collector.reg_use(src1);
+            collector.reg_reuse_def(dst, 0);
+            src2.get_operands(collector);
         }
-        Inst::AluConstOp { dst, .. } => collector.reg_def(dst.to_writable_reg()),
+        Inst::AluConstOp { dst, .. } => collector.reg_def(dst),
         Inst::AluRM { src1_dst, src2, .. } => {
-            collector.reg_use(src2.to_reg());
+            collector.reg_use(src2);
             src1_dst.get_operands(collector);
         }
         Inst::AluRmRVex {
             src1, src2, dst, ..
         } => {
-            collector.reg_def(dst.to_writable_reg());
-            collector.reg_use(src1.to_reg());
+            collector.reg_def(dst);
+            collector.reg_use(src1);
             src2.get_operands(collector);
         }
         Inst::Not { src, dst, .. } => {
-            collector.reg_use(src.to_reg());
-            collector.reg_reuse_def(dst.to_writable_reg(), 0);
+            collector.reg_use(src);
+            collector.reg_reuse_def(dst, 0);
         }
         Inst::Neg { src, dst, .. } => {
-            collector.reg_use(src.to_reg());
-            collector.reg_reuse_def(dst.to_writable_reg(), 0);
+            collector.reg_use(src);
+            collector.reg_reuse_def(dst, 0);
         }
         Inst::Div {
+            divisor,
             dividend_lo,
             dividend_hi,
             dst_quotient,
             dst_remainder,
             ..
-        }
-        | Inst::CheckedSRemSeq {
+        } => {
+            divisor.get_operands(collector);
+            collector.reg_fixed_use(dividend_lo, regs::rax());
+            collector.reg_fixed_use(dividend_hi, regs::rdx());
+            collector.reg_fixed_def(dst_quotient, regs::rax());
+            collector.reg_fixed_def(dst_remainder, regs::rdx());
+        }
+        Inst::CheckedSRemSeq {
+            divisor,
             dividend_lo,
             dividend_hi,
             dst_quotient,
             dst_remainder,
             ..
         } => {
-            match inst {
-                Inst::Div { divisor, .. } => divisor.get_operands(collector),
-                Inst::CheckedSRemSeq { divisor, .. } => collector.reg_use(divisor.to_reg()),
-                _ => {}
-            }
-            collector.reg_fixed_use(dividend_lo.to_reg(), regs::rax());
-            collector.reg_fixed_use(dividend_hi.to_reg(), regs::rdx());
-            collector.reg_fixed_def(dst_quotient.to_writable_reg(), regs::rax());
-            collector.reg_fixed_def(dst_remainder.to_writable_reg(), regs::rdx());
-        }
-        Inst::Div8 { dividend, dst, .. } | Inst::CheckedSRemSeq8 { dividend, dst, .. } => {
-            match inst {
-                Inst::Div8 { divisor, .. } => divisor.get_operands(collector),
-                Inst::CheckedSRemSeq8 { divisor, .. } => collector.reg_use(divisor.to_reg()),
-                _ => {}
-            }
-            collector.reg_fixed_use(dividend.to_reg(), regs::rax());
-            collector.reg_fixed_def(dst.to_writable_reg(), regs::rax());
-        }
-        Inst::MulHi {
+            collector.reg_use(divisor);
+            collector.reg_fixed_use(dividend_lo, regs::rax());
+            collector.reg_fixed_use(dividend_hi, regs::rdx());
+            collector.reg_fixed_def(dst_quotient, regs::rax());
+            collector.reg_fixed_def(dst_remainder, regs::rdx());
+        }
+        Inst::Div8 {
+            divisor,
+            dividend,
+            dst,
+            ..
+        } => {
+            divisor.get_operands(collector);
+            collector.reg_fixed_use(dividend, regs::rax());
+            collector.reg_fixed_def(dst, regs::rax());
+        }
+        Inst::CheckedSRemSeq8 {
+            divisor,
+            dividend,
+            dst,
+            ..
+        } => {
+            collector.reg_use(divisor);
+            collector.reg_fixed_use(dividend, regs::rax());
+            collector.reg_fixed_def(dst, regs::rax());
+        }
+        Inst::Mul {
             src1,
             src2,
             dst_lo,
             dst_hi,
             ..
         } => {
-            collector.reg_fixed_use(src1.to_reg(), regs::rax());
-            collector.reg_fixed_def(dst_lo.to_writable_reg(), regs::rax());
-            collector.reg_fixed_def(dst_hi.to_writable_reg(), regs::rdx());
+            collector.reg_fixed_use(src1, regs::rax());
+            collector.reg_fixed_def(dst_lo, regs::rax());
+            collector.reg_fixed_def(dst_hi, regs::rdx());
             src2.get_operands(collector);
         }
-        Inst::UMulLo {
-            size,
-            src1,
-            src2,
-            dst,
-            ..
+        Inst::Mul8 {
+            src1, src2, dst, ..
         } => {
-            collector.reg_fixed_use(src1.to_reg(), regs::rax());
-            collector.reg_fixed_def(dst.to_writable_reg(), regs::rax());
-            if *size != OperandSize::Size8 {
-                collector.reg_clobbers(PRegSet::empty().with(regs::gpr_preg(regs::ENC_RDX)));
-            }
+            collector.reg_fixed_use(src1, regs::rax());
+            collector.reg_fixed_def(dst, regs::rax());
+            src2.get_operands(collector);
+        }
+        Inst::IMul {
+            src1, src2, dst, ..
+        } => {
+            collector.reg_use(src1);
+            collector.reg_reuse_def(dst, 0);
             src2.get_operands(collector);
         }
+        Inst::IMulImm { src1, dst, .. } => {
+            collector.reg_def(dst);
+            src1.get_operands(collector);
+        }
         Inst::SignExtendData { size, src, dst } => {
             match size {
                 OperandSize::Size8 => {
                     // Note `rax` on both src and dest: 8->16 extend
                     // does AL -> AX.
-                    collector.reg_fixed_use(src.to_reg(), regs::rax());
-                    collector.reg_fixed_def(dst.to_writable_reg(), regs::rax());
+                    collector.reg_fixed_use(src, regs::rax());
+                    collector.reg_fixed_def(dst, regs::rax());
                 }
                 _ => {
                     // All other widths do RAX -> RDX (AX -> DX:AX,
                     // EAX -> EDX:EAX).
-                    collector.reg_fixed_use(src.to_reg(), regs::rax());
-                    collector.reg_fixed_def(dst.to_writable_reg(), regs::rdx());
+                    collector.reg_fixed_use(src, regs::rax());
+                    collector.reg_fixed_def(dst, regs::rdx());
                 }
             }
         }
         Inst::UnaryRmR { src, dst, .. }
         | Inst::UnaryRmRVex { src, dst, .. }
         | Inst::UnaryRmRImmVex { src, dst, .. } => {
-            collector.reg_def(dst.to_writable_reg());
+            collector.reg_def(dst);
             src.get_operands(collector);
         }
         Inst::XmmUnaryRmR { src, dst, .. } | Inst::XmmUnaryRmRImm { src, dst, .. } => {
-            collector.reg_def(dst.to_writable_reg());
+            collector.reg_def(dst);
             src.get_operands(collector);
         }
         Inst::XmmUnaryRmREvex { src, dst, .. }
@@ -2030,21 +2046,21 @@ fn x64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut OperandCol
         | Inst::XmmUnaryRmRUnaligned { src, dst, .. }
         | Inst::XmmUnaryRmRVex { src, dst, .. }
         | Inst::XmmUnaryRmRImmVex { src, dst, .. } => {
-            collector.reg_def(dst.to_writable_reg());
+            collector.reg_def(dst);
             src.get_operands(collector);
         }
         Inst::XmmRmR {
             src1, src2, dst, ..
         } => {
-            collector.reg_use(src1.to_reg());
-            collector.reg_reuse_def(dst.to_writable_reg(), 0);
+            collector.reg_use(src1);
+            collector.reg_reuse_def(dst, 0);
             src2.get_operands(collector);
         }
         Inst::XmmRmRUnaligned {
             src1, src2, dst, ..
         } => {
-            collector.reg_use(src1.to_reg());
-            collector.reg_reuse_def(dst.to_writable_reg(), 0);
+            collector.reg_use(src1);
+            collector.reg_reuse_def(dst, 0);
             src2.get_operands(collector);
         }
         Inst::XmmRmRBlend {
@@ -2054,35 +2070,34 @@ fn x64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut OperandCol
             dst,
             op,
         } => {
-            assert!(
-                *op == SseOpcode::Blendvpd
-                    || *op == SseOpcode::Blendvps
-                    || *op == SseOpcode::Pblendvb
-            );
-            collector.reg_use(src1.to_reg());
-            collector.reg_fixed_use(mask.to_reg(), regs::xmm0());
-            collector.reg_reuse_def(dst.to_writable_reg(), 0);
+            assert!(matches!(
+                op,
+                SseOpcode::Blendvpd | SseOpcode::Blendvps | SseOpcode::Pblendvb
+            ));
+            collector.reg_use(src1);
+            collector.reg_fixed_use(mask, regs::xmm0());
+            collector.reg_reuse_def(dst, 0);
             src2.get_operands(collector);
         }
         Inst::XmmRmiRVex {
             src1, src2, dst, ..
         } => {
-            collector.reg_def(dst.to_writable_reg());
-            collector.reg_use(src1.to_reg());
+            collector.reg_def(dst);
+            collector.reg_use(src1);
             src2.get_operands(collector);
         }
         Inst::XmmRmRImmVex {
             src1, src2, dst, ..
         } => {
-            collector.reg_def(dst.to_writable_reg());
-            collector.reg_use(src1.to_reg());
+            collector.reg_def(dst);
+            collector.reg_use(src1);
             src2.get_operands(collector);
         }
         Inst::XmmVexPinsr {
             src1, src2, dst, ..
         } => {
-            collector.reg_def(dst.to_writable_reg());
-            collector.reg_use(src1.to_reg());
+            collector.reg_def(dst);
+            collector.reg_use(src1);
             src2.get_operands(collector);
         }
         Inst::XmmRmRVex3 {
@@ -2092,9 +2107,9 @@ fn x64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut OperandCol
             dst,
             ..
         } => {
-            collector.reg_use(src1.to_reg());
-            collector.reg_reuse_def(dst.to_writable_reg(), 0);
-            collector.reg_use(src2.to_reg());
+            collector.reg_use(src1);
+            collector.reg_reuse_def(dst, 0);
+            collector.reg_use(src2);
             src3.get_operands(collector);
         }
         Inst::XmmRmRBlendVex {
@@ -2104,10 +2119,10 @@ fn x64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut OperandCol
             dst,
             ..
         } => {
-            collector.reg_def(dst.to_writable_reg());
-            collector.reg_use(src1.to_reg());
+            collector.reg_def(dst);
+            collector.reg_use(src1);
             src2.get_operands(collector);
-            collector.reg_use(mask.to_reg());
+            collector.reg_use(mask);
         }
         Inst::XmmRmREvex {
             op,
@@ -2117,9 +2132,9 @@ fn x64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut OperandCol
             ..
         } => {
             assert_ne!(*op, Avx512Opcode::Vpermi2b);
-            collector.reg_use(src1.to_reg());
+            collector.reg_use(src1);
             src2.get_operands(collector);
-            collector.reg_def(dst.to_writable_reg());
+            collector.reg_def(dst);
         }
         Inst::XmmRmREvex3 {
             op,
@@ -2130,82 +2145,86 @@ fn x64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut OperandCol
             ..
         } => {
             assert_eq!(*op, Avx512Opcode::Vpermi2b);
-            collector.reg_use(src1.to_reg());
-            collector.reg_use(src2.to_reg());
+            collector.reg_use(src1);
+            collector.reg_use(src2);
             src3.get_operands(collector);
-            collector.reg_reuse_def(dst.to_writable_reg(), 0); // Reuse `src1`.
+            collector.reg_reuse_def(dst, 0); // Reuse `src1`.
         }
         Inst::XmmRmRImm {
             src1, src2, dst, ..
         } => {
-            collector.reg_use(*src1);
-            collector.reg_reuse_def(*dst, 0);
+            collector.reg_use(src1);
+            collector.reg_reuse_def(dst, 0);
             src2.get_operands(collector);
         }
-        Inst::XmmUninitializedValue { dst } => collector.reg_def(dst.to_writable_reg()),
+        Inst::XmmUninitializedValue { dst } => collector.reg_def(dst),
         Inst::XmmMinMaxSeq { lhs, rhs, dst, .. } => {
-            collector.reg_use(rhs.to_reg());
-            collector.reg_use(lhs.to_reg());
-            collector.reg_reuse_def(dst.to_writable_reg(), 0); // Reuse RHS.
+            collector.reg_use(rhs);
+            collector.reg_use(lhs);
+            collector.reg_reuse_def(dst, 0); // Reuse RHS.
         }
         Inst::XmmRmiReg {
             src1, src2, dst, ..
         } => {
-            collector.reg_use(src1.to_reg());
-            collector.reg_reuse_def(dst.to_writable_reg(), 0); // Reuse RHS.
+            collector.reg_use(src1);
+            collector.reg_reuse_def(dst, 0); // Reuse RHS.
             src2.get_operands(collector);
         }
         Inst::XmmMovRM { src, dst, .. }
         | Inst::XmmMovRMVex { src, dst, .. }
         | Inst::XmmMovRMImm { src, dst, .. }
         | Inst::XmmMovRMImmVex { src, dst, .. } => {
-            collector.reg_use(src.to_reg());
+            collector.reg_use(src);
             dst.get_operands(collector);
         }
-        Inst::XmmCmpRmR { src, dst, .. } => {
-            collector.reg_use(dst.to_reg());
-            src.get_operands(collector);
+        Inst::XmmCmpRmR { src1, src2, .. } => {
+            collector.reg_use(src1);
+            src2.get_operands(collector);
+        }
+        Inst::XmmCmpRmRVex { src1, src2, .. } => {
+            collector.reg_use(src1);
+            src2.get_operands(collector);
         }
         Inst::Imm { dst, .. } => {
-            collector.reg_def(dst.to_writable_reg());
+            collector.reg_def(dst);
         }
         Inst::MovRR { src, dst, .. } => {
-            collector.reg_use(src.to_reg());
-            collector.reg_def(dst.to_writable_reg());
+            collector.reg_use(src);
+            collector.reg_def(dst);
         }
         Inst::MovFromPReg { dst, src } => {
             debug_assert!(dst.to_reg().to_reg().is_virtual());
             collector.reg_fixed_nonallocatable(*src);
-            collector.reg_def(dst.to_writable_reg());
+            collector.reg_def(dst);
         }
         Inst::MovToPReg { dst, src } => {
             debug_assert!(src.to_reg().is_virtual());
-            collector.reg_use(src.to_reg());
+            collector.reg_use(src);
             collector.reg_fixed_nonallocatable(*dst);
         }
         Inst::XmmToGpr { src, dst, .. }
         | Inst::XmmToGprVex { src, dst, .. }
         | Inst::XmmToGprImm { src, dst, .. }
         | Inst::XmmToGprImmVex { src, dst, .. } => {
-            collector.reg_use(src.to_reg());
-            collector.reg_def(dst.to_writable_reg());
+            collector.reg_use(src);
+            collector.reg_def(dst);
         }
         Inst::GprToXmm { src, dst, .. } | Inst::GprToXmmVex { src, dst, .. } => {
-            collector.reg_def(dst.to_writable_reg());
+            collector.reg_def(dst);
             src.get_operands(collector);
         }
         Inst::CvtIntToFloat {
             src1, src2, dst, ..
         } => {
-            collector.reg_use(src1.to_reg());
-            collector.reg_reuse_def(dst.to_writable_reg(), 0);
+            collector.reg_use(src1);
+            collector.reg_reuse_def(dst, 0);
             src2.get_operands(collector);
         }
         Inst::CvtIntToFloatVex {
             src1, src2, dst, ..
         } => {
-            collector.reg_def(dst.to_writable_reg());
-            collector.reg_use(src1.to_reg());
+            collector.reg_def(dst);
+            collector.reg_use(src1);
             src2.get_operands(collector);
         }
         Inst::CvtUint64ToFloatSeq {
@@ -2215,10 +2234,10 @@ fn x64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut OperandCol
             tmp_gpr2,
             ..
         } => {
-            collector.reg_use(src.to_reg());
-            collector.reg_early_def(dst.to_writable_reg());
-            collector.reg_early_def(tmp_gpr1.to_writable_reg());
-            collector.reg_early_def(tmp_gpr2.to_writable_reg());
+            collector.reg_use(src);
+            collector.reg_early_def(dst);
+            collector.reg_early_def(tmp_gpr1);
+            collector.reg_early_def(tmp_gpr2);
         }
         Inst::CvtFloatToSintSeq {
             src,
@@ -2227,10 +2246,10 @@ fn x64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut OperandCol
             tmp_gpr,
             ..
         } => {
-            collector.reg_use(src.to_reg());
-            collector.reg_early_def(dst.to_writable_reg());
-            collector.reg_early_def(tmp_gpr.to_writable_reg());
-            collector.reg_early_def(tmp_xmm.to_writable_reg());
+            collector.reg_use(src);
+            collector.reg_early_def(dst);
+            collector.reg_early_def(tmp_gpr);
+            collector.reg_early_def(tmp_xmm);
         }
         Inst::CvtFloatToUintSeq {
             src,
@@ -2240,11 +2259,11 @@ fn x64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut OperandCol
             tmp_xmm2,
             ..
         } => {
-            collector.reg_use(src.to_reg());
-            collector.reg_early_def(dst.to_writable_reg());
-            collector.reg_early_def(tmp_gpr.to_writable_reg());
-            collector.reg_early_def(tmp_xmm.to_writable_reg());
-            collector.reg_early_def(tmp_xmm2.to_writable_reg());
+            collector.reg_use(src);
+            collector.reg_early_def(dst);
+            collector.reg_early_def(tmp_gpr);
+            collector.reg_early_def(tmp_xmm);
+            collector.reg_early_def(tmp_xmm2);
         }
 
         Inst::MovImmM { dst, .. } => {
@@ -2252,45 +2271,44 @@ fn x64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut OperandCol
         }
 
         Inst::MovzxRmR { src, dst, .. } => {
-            collector.reg_def(dst.to_writable_reg());
+            collector.reg_def(dst);
             src.get_operands(collector);
         }
         Inst::Mov64MR { src, dst, .. } => {
-            collector.reg_def(dst.to_writable_reg());
+            collector.reg_def(dst);
             src.get_operands(collector);
         }
         Inst::LoadEffectiveAddress { addr: src, dst, .. } => {
-            collector.reg_def(dst.to_writable_reg());
+            collector.reg_def(dst);
             src.get_operands(collector);
         }
         Inst::MovsxRmR { src, dst, .. } => {
-            collector.reg_def(dst.to_writable_reg());
+            collector.reg_def(dst);
             src.get_operands(collector);
         }
         Inst::MovRM { src, dst, .. } => {
-            collector.reg_use(src.to_reg());
+            collector.reg_use(src);
             dst.get_operands(collector);
         }
         Inst::ShiftR {
             num_bits, src, dst, ..
         } => {
-            collector.reg_use(src.to_reg());
-            collector.reg_reuse_def(dst.to_writable_reg(), 0);
-            if let Imm8Reg::Reg { reg } = num_bits.clone().to_imm8_reg() {
+            collector.reg_use(src);
+            collector.reg_reuse_def(dst, 0);
+            if let Imm8Reg::Reg { reg } = num_bits.as_imm8_reg_mut() {
                 collector.reg_fixed_use(reg, regs::rcx());
             }
         }
-        Inst::CmpRmiR { src, dst, .. } => {
-            // N.B.: use, not def (cmp doesn't write its result).
-            collector.reg_use(dst.to_reg());
-            src.get_operands(collector);
+        Inst::CmpRmiR { src1, src2, .. } => {
+            collector.reg_use(src1);
+            src2.get_operands(collector);
         }
         Inst::Setcc { dst, .. } => {
-            collector.reg_def(dst.to_writable_reg());
+            collector.reg_def(dst);
         }
         Inst::Bswap { src, dst, .. } => {
-            collector.reg_use(src.to_reg());
-            collector.reg_reuse_def(dst.to_writable_reg(), 0);
+            collector.reg_use(src);
+            collector.reg_reuse_def(dst, 0);
         }
         Inst::Cmove {
             consequent,
@@ -2298,8 +2316,8 @@ fn x64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut OperandCol
             dst,
             ..
         } => {
-            collector.reg_use(alternative.to_reg());
-            collector.reg_reuse_def(dst.to_writable_reg(), 0);
+            collector.reg_use(alternative);
+            collector.reg_reuse_def(dst, 0);
             consequent.get_operands(collector);
         }
         Inst::XmmCmove {
@@ -2308,104 +2326,123 @@ fn x64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut OperandCol
             dst,
             ..
         } => {
-            collector.reg_use(alternative.to_reg());
-            collector.reg_reuse_def(dst.to_writable_reg(), 0);
-            consequent.get_operands(collector);
+            collector.reg_use(alternative);
+            collector.reg_reuse_def(dst, 0);
+            collector.reg_use(consequent);
         }
         Inst::Push64 { src } => {
             src.get_operands(collector);
         }
         Inst::Pop64 { dst } => {
-            collector.reg_def(dst.to_writable_reg());
+            collector.reg_def(dst);
         }
         Inst::StackProbeLoop { tmp, .. } => {
-            collector.reg_early_def(*tmp);
+            collector.reg_early_def(tmp);
         }
 
-        Inst::CallKnown { dest, ref info, .. } => {
+        Inst::CallKnown { dest, info, .. } => {
             // Probestack is special and is only inserted after
             // regalloc, so we do not need to represent its ABI to the
             // register allocator. Assert that we don't alter that
             // arrangement.
+            let CallInfo {
+                uses,
+                defs,
+                clobbers,
+                ..
+            } = &mut **info.as_mut().expect("CallInfo is expected in this path");
             debug_assert_ne!(*dest, ExternalName::LibCall(LibCall::Probestack));
-            for u in &info.uses {
-                collector.reg_fixed_use(u.vreg, u.preg);
+            for CallArgPair { vreg, preg } in uses {
+                collector.reg_fixed_use(vreg, *preg);
             }
-            for d in &info.defs {
-                collector.reg_fixed_def(d.vreg, d.preg);
+            for CallRetPair { vreg, preg } in defs {
+                collector.reg_fixed_def(vreg, *preg);
             }
-            collector.reg_clobbers(info.clobbers);
+            collector.reg_clobbers(*clobbers);
         }
 
-        Inst::CallUnknown { ref info, dest, .. } => {
+        Inst::CallUnknown { info, dest, .. } => {
+            let CallInfo {
+                uses,
+                defs,
+                clobbers,
+                callee_conv,
+                ..
+            } = &mut **info.as_mut().expect("CallInfo is expected in this path");
             match dest {
-                RegMem::Reg { reg } if info.callee_conv == CallConv::Tail => {
+                RegMem::Reg { reg } if *callee_conv == CallConv::Winch => {
                     // TODO(https://github.com/bytecodealliance/regalloc2/issues/145):
-                    // This shouldn't be a fixed register constraint.
-                    collector.reg_fixed_use(*reg, regs::r15())
+                    // This shouldn't be a fixed register constraint. r10 is caller-saved, so this
+                    // should be safe to use.
+                    collector.reg_fixed_use(reg, regs::r10())
                 }
                 _ => dest.get_operands(collector),
             }
-            for u in &info.uses {
-                collector.reg_fixed_use(u.vreg, u.preg);
+            for CallArgPair { vreg, preg } in uses {
+                collector.reg_fixed_use(vreg, *preg);
             }
-            for d in &info.defs {
-                collector.reg_fixed_def(d.vreg, d.preg);
+            for CallRetPair { vreg, preg } in defs {
+                collector.reg_fixed_def(vreg, *preg);
             }
-            collector.reg_clobbers(info.clobbers);
+            collector.reg_clobbers(*clobbers);
+        }
+        Inst::StackSwitchBasic {
+            store_context_ptr,
+            load_context_ptr,
+            in_payload0,
+            out_payload0,
+        } => {
+            collector.reg_use(load_context_ptr);
+            collector.reg_use(store_context_ptr);
+            collector.reg_fixed_use(in_payload0, stack_switch::payload_register());
+            collector.reg_fixed_def(out_payload0, stack_switch::payload_register());
+
+            let mut clobbers = crate::isa::x64::abi::ALL_CLOBBERS;
+            // The return/payload reg must not be included in the clobber set
+            clobbers.remove(
+                stack_switch::payload_register()
+                    .to_real_reg()
+                    .unwrap()
+                    .into(),
+            );
+            collector.reg_clobbers(clobbers);
         }
 
         Inst::ReturnCallKnown { callee, info } => {
-            let ReturnCallInfo {
-                ret_addr,
-                fp,
-                tmp,
-                uses,
-                ..
-            } = &**info;
+            let ReturnCallInfo { uses, tmp, .. } = &mut **info;
+            collector.reg_fixed_def(tmp, regs::r11());
             // Same as in the `Inst::CallKnown` branch.
             debug_assert_ne!(*callee, ExternalName::LibCall(LibCall::Probestack));
-            for u in uses {
-                collector.reg_fixed_use(u.vreg, u.preg);
-            }
-            if let Some(ret_addr) = ret_addr {
-                collector.reg_use(**ret_addr);
+            for CallArgPair { vreg, preg } in uses {
+                collector.reg_fixed_use(vreg, *preg);
             }
-            collector.reg_use(**fp);
-            collector.reg_early_def(tmp.to_writable_reg());
         }
 
         Inst::ReturnCallUnknown { callee, info } => {
-            let ReturnCallInfo {
-                ret_addr,
-                fp,
-                tmp,
-                uses,
-                ..
-            } = &**info;
-            callee.get_operands(collector);
-            for u in uses {
-                collector.reg_fixed_use(u.vreg, u.preg);
-            }
-            if let Some(ret_addr) = ret_addr {
-                collector.reg_use(**ret_addr);
+            let ReturnCallInfo { uses, tmp, .. } = &mut **info;
+
+            // TODO(https://github.com/bytecodealliance/regalloc2/issues/145):
+            // This shouldn't be a fixed register constraint, but it's not clear how to
+            // pick a register that won't be clobbered by the callee-save restore code
+            // emitted with a return_call_indirect. r10 is caller-saved, so this should be
+            // safe to use.
+            collector.reg_fixed_use(callee, regs::r10());
+
+            collector.reg_fixed_def(tmp, regs::r11());
+            for CallArgPair { vreg, preg } in uses {
+                collector.reg_fixed_use(vreg, *preg);
             }
-            collector.reg_use(**fp);
-            collector.reg_early_def(tmp.to_writable_reg());
         }
 
         Inst::JmpTableSeq {
-            ref idx,
-            ref tmp1,
-            ref tmp2,
-            ..
+            idx, tmp1, tmp2, ..
         } => {
-            collector.reg_use(*idx);
-            collector.reg_early_def(*tmp1);
+            collector.reg_use(idx);
+            collector.reg_early_def(tmp1);
             // In the sequence emitted for this pseudoinstruction in emit.rs,
             // tmp2 is only written after idx is read, so it doesn't need to be
             // an early def.
-            collector.reg_def(*tmp2);
+            collector.reg_def(tmp2);
         }
 
         Inst::JmpUnknown { target } => {
@@ -2413,7 +2450,7 @@ fn x64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut OperandCol
         }
 
         Inst::LoadExtName { dst, .. } => {
-            collector.reg_def(*dst);
+            collector.reg_def(dst);
         }
 
         Inst::LockCmpxchg {
@@ -2423,9 +2460,9 @@ fn x64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut OperandCol
             dst_old,
             ..
         } => {
-            collector.reg_use(*replacement);
-            collector.reg_fixed_use(*expected, regs::rax());
-            collector.reg_fixed_def(*dst_old, regs::rax());
+            collector.reg_use(replacement);
+            collector.reg_fixed_use(expected, regs::rax());
+            collector.reg_fixed_def(dst_old, regs::rax());
             mem.get_operands(collector);
         }
 
@@ -2436,25 +2473,25 @@ fn x64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut OperandCol
             mem,
             ..
         } => {
-            collector.reg_late_use(*operand);
-            collector.reg_early_def(*temp);
+            collector.reg_late_use(operand);
+            collector.reg_early_def(temp);
             // This `fixed_def` is needed because `CMPXCHG` always uses this
             // register implicitly.
-            collector.reg_fixed_def(*dst_old, regs::rax());
+            collector.reg_fixed_def(dst_old, regs::rax());
             mem.get_operands_late(collector)
         }
 
         Inst::Args { args } => {
-            for arg in args {
-                collector.reg_fixed_def(arg.vreg, arg.preg);
+            for ArgPair { vreg, preg } in args {
+                collector.reg_fixed_def(vreg, *preg);
             }
         }
 
         Inst::Rets { rets } => {
             // The return value(s) are live-out; we represent this
             // with register uses on the return instruction.
-            for ret in rets.iter() {
-                collector.reg_fixed_use(ret.vreg, ret.preg);
+            for RetPair { vreg, preg } in rets {
+                collector.reg_fixed_use(vreg, *preg);
             }
         }
 
@@ -2466,7 +2503,6 @@ fn x64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut OperandCol
         | Inst::TrapIf { .. }
         | Inst::TrapIfAnd { .. }
         | Inst::TrapIfOr { .. }
-        | Inst::VirtualSPOffsetAdj { .. }
         | Inst::Hlt
         | Inst::Ud2 { .. }
         | Inst::Fence { .. } => {
@@ -2474,7 +2510,7 @@ fn x64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut OperandCol
         }
 
         Inst::ElfTlsGetAddr { dst, .. } | Inst::MachOTlsGetAddr { dst, .. } => {
-            collector.reg_fixed_def(dst.to_writable_reg(), regs::rax());
+            collector.reg_fixed_def(dst, regs::rax());
             // All caller-saves are clobbered.
             //
             // We use the SysV calling convention here because the
@@ -2491,16 +2527,16 @@ fn x64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut OperandCol
             // register allocator, so we don't need to mark it as used here.
 
             // We use %rax to set the address
-            collector.reg_fixed_def(dst.to_writable_reg(), regs::rax());
+            collector.reg_fixed_def(dst, regs::rax());
 
             // We use %rcx as a temporary variable to load the _tls_index
-            collector.reg_fixed_def(tmp.to_writable_reg(), regs::rcx());
+            collector.reg_fixed_def(tmp, regs::rcx());
         }
 
         Inst::Unwind { .. } => {}
 
         Inst::DummyUse { reg } => {
-            collector.reg_use(*reg);
+            collector.reg_use(reg);
         }
     }
 }
@@ -2511,8 +2547,8 @@ fn x64_get_operands<F: Fn(VReg) -> VReg>(inst: &Inst, collector: &mut OperandCol
 impl MachInst for Inst {
     type ABIMachineSpec = X64ABIMachineSpec;
 
-    fn get_operands<F: Fn(VReg) -> VReg>(&self, collector: &mut OperandCollector<'_, F>) {
-        x64_get_operands(&self, collector)
+    fn get_operands(&mut self, collector: &mut impl OperandVisitor) {
+        x64_get_operands(self, collector)
     }
 
     fn is_move(&self) -> Option<(Writable<Reg>, Reg)> {
@@ -2584,6 +2620,10 @@ impl MachInst for Inst {
         }
     }
 
+    fn is_mem_access(&self) -> bool {
+        panic!("TODO FILL ME OUT")
+    }
+
     fn gen_move(dst_reg: Writable<Reg>, src_reg: Reg, ty: Type) -> Inst {
         trace!(
             "Inst::gen_move {:?} -> {:?} (type: {:?})",
@@ -2603,9 +2643,9 @@ impl MachInst for Inst {
                 // those, which may write more lanes that we need, but are specified to have
                 // zero-latency.
                 let opcode = match ty {
-                    types::F32 | types::F64 | types::F32X4 => SseOpcode::Movaps,
+                    types::F16 | types::F32 | types::F64 | types::F32X4 => SseOpcode::Movaps,
                     types::F64X2 => SseOpcode::Movapd,
-                    _ if ty.is_vector() && ty.bits() == 128 => SseOpcode::Movdqa,
+                    _ if (ty.is_float() || ty.is_vector()) && ty.bits() == 128 => SseOpcode::Movdqa,
                     _ => unimplemented!("unable to move type: {}", ty),
                 };
                 Inst::xmm_unary_rm_r(opcode, RegMem::reg(src_reg), dst_reg)
@@ -2624,18 +2664,17 @@ impl MachInst for Inst {
             types::I16 => Ok((&[RegClass::Int], &[types::I16])),
             types::I32 => Ok((&[RegClass::Int], &[types::I32])),
             types::I64 => Ok((&[RegClass::Int], &[types::I64])),
-            types::R32 => panic!("32-bit reftype pointer should never be seen on x86-64"),
-            types::R64 => Ok((&[RegClass::Int], &[types::R64])),
+            types::F16 => Ok((&[RegClass::Float], &[types::F16])),
             types::F32 => Ok((&[RegClass::Float], &[types::F32])),
             types::F64 => Ok((&[RegClass::Float], &[types::F64])),
+            types::F128 => Ok((&[RegClass::Float], &[types::F128])),
             types::I128 => Ok((&[RegClass::Int, RegClass::Int], &[types::I64, types::I64])),
             _ if ty.is_vector() => {
                 assert!(ty.bits() <= 128);
                 Ok((&[RegClass::Float], &[types::I8X16]))
             }
             _ => Err(CodegenError::Unsupported(format!(
-                "Unexpected SSA-value type: {}",
-                ty
+                "Unexpected SSA-value type: {ty}"
             ))),
         }
     }
@@ -2681,10 +2720,7 @@ impl MachInst for Inst {
 
     fn is_safepoint(&self) -> bool {
         match self {
-            Inst::CallKnown { .. }
-            | Inst::CallUnknown { .. }
-            | Inst::TrapIf { .. }
-            | Inst::Ud2 { .. } => true,
+            Inst::CallKnown { .. } | Inst::CallUnknown { .. } => true,
             _ => false,
         }
     }
@@ -2692,9 +2728,9 @@ impl MachInst for Inst {
     fn function_alignment() -> FunctionAlignment {
         FunctionAlignment {
             minimum: 1,
-            // Prefer an alignment of 16-bytes to hypothetically get the whole
-            // function into a minimum number of lines.
-            preferred: 16,
+            // Change the alignment from 16-bytes to 32-bytes for better performance.
+            // fix-8573: https://github.com/bytecodealliance/wasmtime/issues/8573
+            preferred: 32,
         }
     }
 
@@ -2720,19 +2756,12 @@ impl MachInstEmit for Inst {
     type State = EmitState;
     type Info = EmitInfo;
 
-    fn emit(
-        &self,
-        allocs: &[Allocation],
-        sink: &mut MachBuffer<Inst>,
-        info: &Self::Info,
-        state: &mut Self::State,
-    ) {
-        let mut allocs = AllocationConsumer::new(allocs);
-        emit::emit(self, &mut allocs, sink, info, state);
+    fn emit(&self, sink: &mut MachBuffer<Inst>, info: &Self::Info, state: &mut Self::State) {
+        emit::emit(self, sink, info, state);
     }
 
-    fn pretty_print_inst(&self, allocs: &[Allocation], _: &mut Self::State) -> String {
-        PrettyPrint::pretty_print(self, 0, &mut AllocationConsumer::new(allocs))
+    fn pretty_print_inst(&self, _: &mut Self::State) -> String {
+        PrettyPrint::pretty_print(self, 0)
     }
 }
 
diff --git a/cranelift/codegen/src/isa/x64/inst/regs.rs b/cranelift/codegen/src/isa/x64/inst/regs.rs
index ce7f1ff72a0b..d3a06da70a03 100644
--- a/cranelift/codegen/src/isa/x64/inst/regs.rs
+++ b/cranelift/codegen/src/isa/x64/inst/regs.rs
@@ -5,7 +5,7 @@
 //!
 //! Note also that we make use of pinned VRegs to refer to PRegs.
 
-use crate::machinst::{AllocationConsumer, RealReg, Reg};
+use crate::machinst::{RealReg, Reg};
 use alloc::string::ToString;
 use regalloc2::{PReg, RegClass, VReg};
 use std::string::String;
@@ -176,7 +176,7 @@ pub fn realreg_name(reg: RealReg) -> &'static str {
             ENC_R13 => "%r13",
             ENC_R14 => "%r14",
             ENC_R15 => "%r15",
-            _ => panic!("Invalid PReg: {:?}", preg),
+            _ => panic!("Invalid PReg: {preg:?}"),
         },
         RegClass::Float => match preg.hw_enc() {
             0 => "%xmm0",
@@ -195,7 +195,7 @@ pub fn realreg_name(reg: RealReg) -> &'static str {
             13 => "%xmm13",
             14 => "%xmm14",
             15 => "%xmm15",
-            _ => panic!("Invalid PReg: {:?}", preg),
+            _ => panic!("Invalid PReg: {preg:?}"),
         },
         RegClass::Vector => unreachable!(),
     }
@@ -205,7 +205,7 @@ pub fn show_reg(reg: Reg) -> String {
     if let Some(rreg) = reg.to_real_reg() {
         realreg_name(rreg).to_string()
     } else {
-        format!("%{:?}", reg)
+        format!("%{reg:?}")
     }
 }
 
@@ -270,7 +270,6 @@ pub fn show_ireg_sized(reg: Reg, size: u8) -> String {
 // words, we can't pretty-print a `Reg` all by itself in a build that
 // may have multiple backends; but we can pretty-print one as part of
 // an x64 Inst or x64 RegMemImm.)
-pub fn pretty_print_reg(reg: Reg, size: u8, allocs: &mut AllocationConsumer<'_>) -> String {
-    let reg = allocs.next(reg);
+pub fn pretty_print_reg(reg: Reg, size: u8) -> String {
     show_ireg_sized(reg, size)
 }
diff --git a/cranelift/codegen/src/isa/x64/inst/stack_switch.rs b/cranelift/codegen/src/isa/x64/inst/stack_switch.rs
new file mode 100644
index 000000000000..b96eb9362072
--- /dev/null
+++ b/cranelift/codegen/src/isa/x64/inst/stack_switch.rs
@@ -0,0 +1,52 @@
+use crate::{isa::x64::inst::regs, machinst::Reg};
+
+/// The `stack_switch` instruction loads information about the stack to switch
+/// to and stores information about the current stack by receiving pointers to
+/// memory laid out as in the struct `ControlContext` below.
+///
+/// The instruction is only supported on x64 Linux at the moment.
+///
+/// ```
+/// #[repr(C)]
+/// pub struct ControlContext {
+///     pub stack_pointer: *mut u8,
+///     pub frame_pointer: *mut u8,
+///     pub instruction_pointer: *mut u8,
+/// }
+/// ```
+///
+/// Note that this layout is deliberately chosen to make frame pointer walking
+/// possible, if desired: The layout enables stack layouts where a
+/// `ControlContext` is part of a frame pointer chain, putting the frame pointer
+/// next to the corresponding IP.
+///
+/// We never actually interact with values of that type in Cranelift, but are
+/// only interested in its layout for the purposes of generating code.
+#[allow(dead_code)]
+pub struct ControlContextLayout {
+    pub size: usize,
+    pub stack_pointer_offset: usize,
+    pub frame_pointer_offset: usize,
+    pub ip_offset: usize,
+}
+
+pub fn control_context_layout() -> ControlContextLayout {
+    ControlContextLayout {
+        size: 24,
+        stack_pointer_offset: 0,
+        frame_pointer_offset: 8,
+        ip_offset: 16,
+    }
+}
+
+/// The register used for handing over the payload when switching stacks.
+///
+/// We must use a fixed register for sending and receiving the payload: When
+/// switching from one stack to another using two matching``stack_switch``
+/// instructions, they must agree on the register where the payload is, similar
+/// to a calling convention. The same holds when `stack_switch`-ing to a newly
+/// initialized stack, where the entry trampoline must know which register the
+/// payload is in.
+pub fn payload_register() -> Reg {
+    regs::rdi()
+}
diff --git a/cranelift/codegen/src/isa/x64/inst/unwind/systemv.rs b/cranelift/codegen/src/isa/x64/inst/unwind/systemv.rs
index 68a1ecf2e5cf..948b9e4deb31 100644
--- a/cranelift/codegen/src/isa/x64/inst/unwind/systemv.rs
+++ b/cranelift/codegen/src/isa/x64/inst/unwind/systemv.rs
@@ -86,9 +86,6 @@ impl crate::isa::unwind::systemv::RegisterMapper<Reg> for RegisterMapper {
     fn map(&self, reg: Reg) -> Result<u16, RegisterMappingError> {
         Ok(map_reg(reg)?.0)
     }
-    fn sp(&self) -> u16 {
-        X86_64::RSP.0
-    }
     fn fp(&self) -> Option<u16> {
         Some(X86_64::RBP.0)
     }
@@ -104,7 +101,6 @@ mod tests {
     use crate::settings::{builder, Flags};
     use crate::Context;
     use gimli::write::Address;
-    use std::str::FromStr;
     use target_lexicon::triple;
 
     #[test]
@@ -116,7 +112,7 @@ mod tests {
 
         let mut context = Context::for_function(create_function(
             CallConv::SystemV,
-            Some(StackSlotData::new(StackSlotKind::ExplicitSlot, 64)),
+            Some(StackSlotData::new(StackSlotKind::ExplicitSlot, 64, 0)),
         ));
 
         let code = context
@@ -133,7 +129,7 @@ mod tests {
             _ => panic!("expected unwind information"),
         };
 
-        assert_eq!(format!("{:?}", fde), "FrameDescriptionEntry { address: Constant(1234), length: 17, lsda: None, instructions: [(1, CfaOffset(16)), (1, Offset(Register(6), -16)), (4, CfaRegister(Register(6)))] }");
+        assert_eq!(format!("{fde:?}"), "FrameDescriptionEntry { address: Constant(1234), length: 17, lsda: None, instructions: [(1, CfaOffset(16)), (1, Offset(Register(6), -16)), (4, CfaRegister(Register(6)))] }");
     }
 
     fn create_function(call_conv: CallConv, stack_slot: Option<StackSlotData>) -> Function {
@@ -174,7 +170,7 @@ mod tests {
             _ => panic!("expected unwind information"),
         };
 
-        assert_eq!(format!("{:?}", fde), "FrameDescriptionEntry { address: Constant(4321), length: 22, lsda: None, instructions: [(1, CfaOffset(16)), (1, Offset(Register(6), -16)), (4, CfaRegister(Register(6)))] }");
+        assert_eq!(format!("{fde:?}"), "FrameDescriptionEntry { address: Constant(4321), length: 22, lsda: None, instructions: [(1, CfaOffset(16)), (1, Offset(Register(6), -16)), (4, CfaRegister(Register(6)))] }");
     }
 
     fn create_multi_return_function(call_conv: CallConv) -> Function {
diff --git a/cranelift/codegen/src/isa/x64/lower.isle b/cranelift/codegen/src/isa/x64/lower.isle
index 9691cec469ef..6982517a59b3 100644
--- a/cranelift/codegen/src/isa/x64/lower.isle
+++ b/cranelift/codegen/src/isa/x64/lower.isle
@@ -2,6 +2,8 @@
 
 ;; The main lowering constructor term: takes a clif `Inst` and returns the
 ;; register(s) within which the lowered instruction's result values live.
+(spec (lower arg)
+      (provide (= result arg)))
 (decl partial lower (Inst) InstOutput)
 
 ;; A variant of the main lowering constructor term, used for branches.
@@ -13,37 +15,45 @@
 
 ;; `i64` and smaller.
 (rule (lower (has_type (fits_in_64 ty)
-                       (iconst (u64_from_imm64 x))))
+                       (iconst _ (u64_from_imm64 x))))
       (imm ty x))
 
 ;; `i128`
 (rule 1 (lower (has_type $I128
-                       (iconst (u64_from_imm64 x))))
+                       (iconst _ (u64_from_imm64 x))))
       (value_regs (imm $I64 x)
                   (imm $I64 0)))
 
+;;;; Rules for `f16const` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(rule (lower (f16const _ (u16_from_ieee16 x)))
+      (imm $F16 x))
+
 ;;;; Rules for `f32const` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (f32const (u32_from_ieee32 x)))
+(rule (lower (f32const _ (u32_from_ieee32 x)))
       (imm $F32 x))
 
 ;;;; Rules for `f64const` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (f64const (u64_from_ieee64 x)))
+(rule (lower (f64const _ (u64_from_ieee64 x)))
       (imm $F64 x))
 
-;;;; Rules for `null` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;; Rules for `f128const` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(rule (lower (f128const _ const))
+      ;; TODO use Inst::gen_constant() instead.
+      (x64_xmm_load_const $F128 (const_to_vconst const)))
 
-(rule (lower (has_type ty (null)))
-      (imm ty 0))
+(rule 1 (lower (f128const _ (u128_from_constant 0)))
+      (xmm_zero $F128))
 
 ;;;; Rules for `iadd` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; `i64` and smaller.
 
 ;; Base case for 8 and 16-bit types
-(rule -6 (lower (has_type (fits_in_16 ty)
-                       (iadd x y)))
+(rule iadd_base_case_8_or_16 -6 (lower (has_type (fits_in_16 ty)
+                       (iadd _ x y)))
       (x64_add ty x y))
 
 ;; Base case for 32 and 64-bit types which might end up using the `lea`
@@ -53,50 +63,62 @@
 ;; but the actual instruction emitted might be an `add` if it's equivalent.
 ;; For more details on this see the `emit.rs` logic to emit
 ;; `LoadEffectiveAddress`.
-(rule -5 (lower (has_type (ty_32_or_64 ty) (iadd x y)))
+(rule iadd_base_case_32_or_64_lea -5 (lower (has_type (ty_32_or_64 ty) (iadd _ x y)))
       (x64_lea ty (to_amode_add (mem_flags_trusted) x y (zero_offset))))
 
 ;; Higher-priority cases than the previous two where a load can be sunk into
 ;; the add instruction itself. Note that both operands are tested for
 ;; sink-ability since addition is commutative
 (rule -4 (lower (has_type (fits_in_64 ty)
-                       (iadd x (sinkable_load y))))
+                       (iadd _ x (sinkable_load y))))
       (x64_add ty x y))
 (rule -3 (lower (has_type (fits_in_64 ty)
-                       (iadd (sinkable_load x) y)))
+                       (iadd _ (sinkable_load x) y)))
       (x64_add ty y x))
 
 ;; SSE.
 
 (rule (lower (has_type (multi_lane 8 16)
-                       (iadd x y)))
+                       (iadd _ x y)))
       (x64_paddb x y))
 
 (rule (lower (has_type (multi_lane 16 8)
-                       (iadd x y)))
+                       (iadd _ x y)))
       (x64_paddw x y))
 
 (rule (lower (has_type (multi_lane 32 4)
-                       (iadd x y)))
+                       (iadd _ x y)))
       (x64_paddd x y))
 
 (rule (lower (has_type (multi_lane 64 2)
-                       (iadd x y)))
+                       (iadd _ x y)))
       (x64_paddq x y))
 
 ;; `i128`
-(rule 1 (lower (has_type $I128 (iadd x y)))
+(rule 1 (lower (has_type $I128 (iadd _ x y)))
       ;; Get the high/low registers for `x`.
       (let ((x_regs ValueRegs x)
-            (x_lo Gpr (value_regs_get_gpr x_regs 0))
-            (x_hi Gpr (value_regs_get_gpr x_regs 1)))
-        ;; Get the high/low registers for `y`.
-        (let ((y_regs ValueRegs y)
-              (y_lo Gpr (value_regs_get_gpr y_regs 0))
-              (y_hi Gpr (value_regs_get_gpr y_regs 1)))
-          ;; Do an add followed by an add-with-carry.
-          (with_flags (x64_add_with_flags_paired $I64 x_lo y_lo)
-                      (x64_adc_paired $I64 x_hi y_hi)))))
+            (y_regs ValueRegs y))
+        (iadd128
+          (value_regs_get_gpr x_regs 0)
+          (value_regs_get_gpr x_regs 1)
+          (value_regs_get_gpr y_regs 0)
+          (value_regs_get_gpr y_regs 1))))
+(rule 2 (lower (has_type $I128 (iadd _ x (iconcat _ y_lo y_hi))))
+        (let ((x_regs ValueRegs x))
+          (iadd128 (value_regs_get_gpr x 0) (value_regs_get_gpr x 1) y_lo y_hi)))
+(rule 3 (lower (has_type $I128 (iadd _ x (uextend _ y @ (value_type $I64)))))
+        (let ((x_regs ValueRegs x))
+          (iadd128 (value_regs_get_gpr x 0) (value_regs_get_gpr x 1)
+                   y (RegMemImm.Imm 0))))
+
+;; Helper for lowering 128-bit addition with the 64-bit halves of the lhs/rhs
+;; already split. The first two arguments are lo/hi for the lhs and the second
+;; two are lo/hi for the rhs.
+(decl iadd128 (Gpr Gpr GprMemImm GprMemImm) ValueRegs)
+(rule (iadd128 x_lo x_hi y_lo y_hi)
+      (with_flags (x64_add_with_flags_paired $I64 x_lo y_lo)
+                  (x64_adc_paired $I64 x_hi y_hi)))
 
 ;;;; Helpers for `*_overflow` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
@@ -134,69 +156,71 @@
 
 ;;;; Rules for `uadd_overflow` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 1 (lower (uadd_overflow x y @ (value_type (fits_in_64 ty))))
+(rule 1 (lower (uadd_overflow _ x y @ (value_type (fits_in_64 ty))))
       (construct_overflow_op_alu ty (CC.B) (AluRmiROpcode.Add) x y))
 
 ;; i128 gets lowered into adc and add
-(rule 0 (lower (uadd_overflow x y @ (value_type $I128)))
+(rule 0 (lower (uadd_overflow _ x y @ (value_type $I128)))
         (construct_overflow_op_alu_128 (CC.B) (AluRmiROpcode.Add) (AluRmiROpcode.Adc) x y))
 
 ;;;; Rules for `sadd_overflow` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 1 (lower (sadd_overflow x y @ (value_type (fits_in_64 ty))))
+(rule 1 (lower (sadd_overflow _ x y @ (value_type (fits_in_64 ty))))
       (construct_overflow_op_alu ty (CC.O) (AluRmiROpcode.Add) x y))
 
-(rule 0 (lower (sadd_overflow x y @ (value_type $I128)))
+(rule 0 (lower (sadd_overflow _ x y @ (value_type $I128)))
         (construct_overflow_op_alu_128 (CC.O) (AluRmiROpcode.Add) (AluRmiROpcode.Adc) x y))
 
 ;;;; Rules for `usub_overflow` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 1 (lower (usub_overflow x y @ (value_type (fits_in_64 ty))))
+(rule 1 (lower (usub_overflow _ x y @ (value_type (fits_in_64 ty))))
       (construct_overflow_op_alu ty (CC.B) (AluRmiROpcode.Sub) x y))
 
-(rule 0 (lower (usub_overflow x y @ (value_type $I128)))
+(rule 0 (lower (usub_overflow _ x y @ (value_type $I128)))
         (construct_overflow_op_alu_128 (CC.B) (AluRmiROpcode.Sub) (AluRmiROpcode.Sbb) x y))
 
 ;;;; Rules for `ssub_overflow` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 1 (lower (ssub_overflow x y @ (value_type (fits_in_64 ty))))
+(rule 1 (lower (ssub_overflow _ x y @ (value_type (fits_in_64 ty))))
       (construct_overflow_op_alu ty (CC.O) (AluRmiROpcode.Sub) x y))
 
-(rule 0 (lower (ssub_overflow x y @ (value_type $I128)))
+(rule 0 (lower (ssub_overflow _ x y @ (value_type $I128)))
         (construct_overflow_op_alu_128 (CC.O) (AluRmiROpcode.Sub) (AluRmiROpcode.Sbb) x y))
 
 ;;;; Rules for `umul_overflow` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 2 (lower (umul_overflow x y @ (value_type (fits_in_64 ty))))
-      (construct_overflow_op (CC.O) (x64_umullo_with_flags_paired ty x y)))
+(rule 2 (lower (umul_overflow _ x y @ (value_type $I8)))
+      (construct_overflow_op (CC.O) (x64_mul8_with_flags_paired $false x y)))
+
+(rule 3 (lower (umul_overflow _ x y @ (value_type (ty_int_ref_16_to_64 ty))))
+      (construct_overflow_op (CC.O) (x64_mul_lo_with_flags_paired ty $false x y)))
 
 ;;;; Rules for `smul_overflow` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 2 (lower (smul_overflow x y @ (value_type (ty_int_ref_16_to_64 ty))))
-      (construct_overflow_op_alu ty (CC.O) (AluRmiROpcode.Mul) x y))
+(rule 2 (lower (smul_overflow _ x y @ (value_type $I8)))
+      (construct_overflow_op (CC.O) (x64_mul8_with_flags_paired $true x y)))
 
-;; there is no 8bit imul with an immediate operand so we need to put it in a register or memory
-(rule 1 (lower (smul_overflow x y @ (value_type $I8)))
-      (construct_overflow_op (CC.O) (x64_alurmi_with_flags_paired (AluRmiROpcode.Mul) $I8 x (reg_mem_to_reg_mem_imm (put_in_reg_mem y)))))
+(rule 3 (lower (smul_overflow _ x y @ (value_type (ty_int_ref_16_to_64 ty))))
+      (construct_overflow_op (CC.O) (x64_mul_lo_with_flags_paired ty $true x y)))
 
 ;;;; Rules for `sadd_sat` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (rule (lower (has_type (multi_lane 8 16)
-                       (sadd_sat x y)))
+                       (sadd_sat _ x y)))
       (x64_paddsb x y))
 
 (rule (lower (has_type (multi_lane 16 8)
-                       (sadd_sat x y)))
+                       (sadd_sat _ x y)))
       (x64_paddsw x y))
 
 ;;;; Rules for `uadd_sat` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (rule (lower (has_type (multi_lane 8 16)
-                       (uadd_sat x y)))
+                       (uadd_sat _ x y)))
       (x64_paddusb x y))
 
 (rule (lower (has_type (multi_lane 16 8)
-                       (uadd_sat x y)))
+                       (uadd_sat _ x y)))
       (x64_paddusw x y))
 
 ;;;; Rules for `isub` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -205,59 +229,71 @@
 
 ;; Sub two registers.
 (rule -3 (lower (has_type (fits_in_64 ty)
-                       (isub x y)))
+                       (isub _ x y)))
       (x64_sub ty x y))
 
 ;; SSE.
 
 (rule (lower (has_type (multi_lane 8 16)
-                       (isub x y)))
+                       (isub _ x y)))
       (x64_psubb x y))
 
 (rule (lower (has_type (multi_lane 16 8)
-                       (isub x y)))
+                       (isub _ x y)))
       (x64_psubw x y))
 
 (rule (lower (has_type (multi_lane 32 4)
-                       (isub x y)))
+                       (isub _ x y)))
       (x64_psubd x y))
 
 (rule (lower (has_type (multi_lane 64 2)
-                       (isub x y)))
+                       (isub _ x y)))
       (x64_psubq x y))
 
 ;; `i128`
-(rule 1 (lower (has_type $I128 (isub x y)))
+(rule 1 (lower (has_type $I128 (isub _ x y)))
       ;; Get the high/low registers for `x`.
       (let ((x_regs ValueRegs x)
-            (x_lo Gpr (value_regs_get_gpr x_regs 0))
-            (x_hi Gpr (value_regs_get_gpr x_regs 1)))
-        ;; Get the high/low registers for `y`.
-        (let ((y_regs ValueRegs y)
-              (y_lo Gpr (value_regs_get_gpr y_regs 0))
-              (y_hi Gpr (value_regs_get_gpr y_regs 1)))
-          ;; Do a sub followed by an sub-with-borrow.
-          (with_flags (x64_sub_with_flags_paired $I64 x_lo y_lo)
-                      (x64_sbb_paired $I64 x_hi y_hi)))))
+            (y_regs ValueRegs y))
+        (isub128
+          (value_regs_get_gpr x_regs 0)
+          (value_regs_get_gpr x_regs 1)
+          (value_regs_get_gpr y_regs 0)
+          (value_regs_get_gpr y_regs 1))))
+(rule 2 (lower (has_type $I128 (isub _ x (iconcat _ y_lo y_hi))))
+        (let ((x_regs ValueRegs x))
+          (isub128 (value_regs_get_gpr x 0) (value_regs_get_gpr x 1) y_lo y_hi)))
+(rule 3 (lower (has_type $I128 (isub _ x (uextend _ y @ (value_type $I64)))))
+        (let ((x_regs ValueRegs x))
+          (isub128 (value_regs_get_gpr x 0) (value_regs_get_gpr x 1)
+                   y (RegMemImm.Imm 0))))
+
+;; Helper for lowering 128-bit subtraction with the 64-bit halves of the lhs/rhs
+;; already split. The first two arguments are lo/hi for the lhs and the second
+;; two are lo/hi for the rhs.
+(decl isub128 (Gpr Gpr GprMemImm GprMemImm) ValueRegs)
+(rule (isub128 x_lo x_hi y_lo y_hi)
+      (with_flags (x64_sub_with_flags_paired $I64 x_lo y_lo)
+                  (x64_sbb_paired $I64 x_hi y_hi)))
 
 ;;;; Rules for `ssub_sat` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (rule (lower (has_type (multi_lane 8 16)
-                       (ssub_sat x y)))
+                       (ssub_sat _ x y)))
       (x64_psubsb x y))
 
 (rule (lower (has_type (multi_lane 16 8)
-                       (ssub_sat x y)))
+                       (ssub_sat _ x y)))
       (x64_psubsw x y))
 
 ;;;; Rules for `usub_sat` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (rule (lower (has_type (multi_lane 8 16)
-                       (usub_sat x y)))
+                       (usub_sat _ x y)))
       (x64_psubusb x y))
 
 (rule (lower (has_type (multi_lane 16 8)
-                       (usub_sat x y)))
+                       (usub_sat _ x y)))
       (x64_psubusw x y))
 
 ;;;; Rules for `band` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -265,24 +301,24 @@
 ;; `{i,b}64` and smaller.
 
 ;; And two registers.
-(rule 0 (lower (has_type ty (band x y)))
+(rule 0 (lower (has_type ty (band _ x y)))
       (if (ty_int_ref_scalar_64 ty))
       (x64_and ty x y))
 
 ;; The above case automatically handles when the rhs is an immediate or a
 ;; sinkable load, but additionally handle the lhs here.
 
-(rule 1 (lower (has_type ty (band (sinkable_load x) y)))
+(rule 1 (lower (has_type ty (band _ (sinkable_load x) y)))
       (if (ty_int_ref_scalar_64 ty))
       (x64_and ty y x))
 
-(rule 2 (lower (has_type ty (band (simm32_from_value x) y)))
+(rule 2 (lower (has_type ty (band _ (simm32_from_value x) y)))
       (if (ty_int_ref_scalar_64 ty))
       (x64_and ty y x))
 
 ;; f32 and f64
 
-(rule 5 (lower (has_type (ty_scalar_float ty) (band x y)))
+(rule 5 (lower (has_type (ty_scalar_float ty) (band _ x y)))
       (sse_and ty x y))
 
 ;; SSE.
@@ -295,7 +331,7 @@
 (rule -1 (sse_and (multi_lane _bits _lanes) x y) (x64_pand x y))
 
 (rule 6 (lower (has_type ty @ (multi_lane _bits _lanes)
-                       (band x y)))
+                       (band _ x y)))
       (sse_and ty x y))
 
 ;; `i128`.
@@ -311,7 +347,7 @@
         (value_gprs (x64_and $I64 x_lo y_lo)
                     (x64_and $I64 x_hi y_hi))))
 
-(rule 7 (lower (has_type $I128 (band x y)))
+(rule 7 (lower (has_type $I128 (band _ x y)))
       (and_i128 x y))
 
 ;; Specialized lowerings for `(band x (bnot y))` which is additionally produced
@@ -330,17 +366,17 @@
 ;; while x86 does
 ;;
 ;;   pandn(x, y) = and(not(x), y)
-(rule 8 (lower (has_type ty @ (multi_lane _bits _lane) (band x (bnot y))))
+(rule 8 (lower (has_type ty @ (multi_lane _bits _lane) (band _ x (bnot _ y))))
       (sse_and_not ty y x))
-(rule 9 (lower (has_type ty @ (multi_lane _bits _lane) (band (bnot y) x)))
+(rule 9 (lower (has_type ty @ (multi_lane _bits _lane) (band _ (bnot _ y) x)))
       (sse_and_not ty y x))
 
-(rule 10 (lower (has_type ty (band x (bnot y))))
+(rule 10 (lower (has_type ty (band _ x (bnot _ y))))
       (if (ty_int_ref_scalar_64 ty))
       (if-let $true (use_bmi1))
       ;; the first argument is the one that gets inverted with andn
       (x64_andn ty y x))
-(rule 11 (lower (has_type ty (band (bnot y) x)))
+(rule 11 (lower (has_type ty (band _ (bnot _ y) x)))
       (if (ty_int_ref_scalar_64 ty))
       (if-let $true (use_bmi1))
       (x64_andn ty y x))
@@ -348,25 +384,25 @@
 ;; Specialization of `blsr` for BMI1
 
 (decl pure partial val_minus_one (Value) Value)
-(rule 0 (val_minus_one (isub x (u64_from_iconst 1))) x)
-(rule 0 (val_minus_one (iadd x (i64_from_iconst -1))) x)
-(rule 1 (val_minus_one (iadd (i64_from_iconst -1) x)) x)
+(rule 0 (val_minus_one (isub _ x (u64_from_iconst 1))) x)
+(rule 0 (val_minus_one (iadd _ x (i64_from_iconst -1))) x)
+(rule 1 (val_minus_one (iadd _ (i64_from_iconst -1) x)) x)
 
-(rule 12 (lower (has_type (ty_32_or_64 ty) (band x y)))
+(rule 12 (lower (has_type (ty_32_or_64 ty) (band _ x y)))
          (if-let $true (use_bmi1))
          (if-let x (val_minus_one y))
          (x64_blsr ty x))
-(rule 13 (lower (has_type (ty_32_or_64 ty) (band y x)))
+(rule 13 (lower (has_type (ty_32_or_64 ty) (band _ y x)))
          (if-let $true (use_bmi1))
          (if-let x (val_minus_one y))
          (x64_blsr ty x))
 
 ;; Specialization of `blsi` for BMI1
 
-(rule 14 (lower (has_type (ty_32_or_64 ty) (band (ineg x) x)))
+(rule 14 (lower (has_type (ty_32_or_64 ty) (band _ (ineg _ x) x)))
          (if-let $true (use_bmi1))
          (x64_blsi ty x))
-(rule 15 (lower (has_type (ty_32_or_64 ty) (band x (ineg x))))
+(rule 15 (lower (has_type (ty_32_or_64 ty) (band _ x (ineg _ x))))
          (if-let $true (use_bmi1))
          (x64_blsi ty x))
 
@@ -379,9 +415,9 @@
 ;; `ishl`, so an `and` instruction is required to mask the index to match the
 ;; semantics of Cranelift's `ishl`.
 
-(rule 16 (lower (has_type (ty_32_or_64 ty) (band x y)))
+(rule 16 (lower (has_type (ty_32_or_64 ty) (band _ x y)))
          (if-let $true (use_bmi2))
-         (if-let (ishl (u64_from_iconst 1) index) (val_minus_one y))
+         (if-let (ishl _ (u64_from_iconst 1) index) (val_minus_one y))
          (x64_bzhi ty x (x64_and ty index (RegMemImm.Imm (u32_sub (ty_bits ty) 1)))))
 
 ;;;; Rules for `bor` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -389,24 +425,24 @@
 ;; `{i,b}64` and smaller.
 
 ;; Or two registers.
-(rule 0 (lower (has_type ty (bor x y)))
+(rule 0 (lower (has_type ty (bor _ x y)))
       (if (ty_int_ref_scalar_64 ty))
       (x64_or ty x y))
 
 ;; Handle immediates/sinkable loads on the lhs in addition to the automatic
 ;; handling of the rhs above
 
-(rule 1 (lower (has_type ty (bor (sinkable_load x) y)))
+(rule 1 (lower (has_type ty (bor _ (sinkable_load x) y)))
       (if (ty_int_ref_scalar_64 ty))
       (x64_or ty y x))
 
-(rule 2 (lower (has_type ty (bor (simm32_from_value x) y)))
+(rule 2 (lower (has_type ty (bor _ (simm32_from_value x) y)))
       (if (ty_int_ref_scalar_64 ty))
       (x64_or ty y x))
 
 ;; f32 and f64
 
-(rule 5 (lower (has_type (ty_scalar_float ty) (bor x y)))
+(rule 5 (lower (has_type (ty_scalar_float ty) (bor _ x y)))
       (sse_or ty x y))
 
 ;; SSE.
@@ -419,7 +455,7 @@
 (rule -1 (sse_or (multi_lane _bits _lanes) x y) (x64_por x y))
 
 (rule 6 (lower (has_type ty @ (multi_lane _bits _lanes)
-                       (bor x y)))
+                       (bor _ x y)))
       (sse_or ty x y))
 
 ;; `{i,b}128`.
@@ -433,7 +469,7 @@
         (value_gprs (x64_or $I64 x_lo y_lo)
                     (x64_or $I64 x_hi y_hi))))
 
-(rule 7 (lower (has_type $I128 (bor x y)))
+(rule 7 (lower (has_type $I128 (bor _ x y)))
       (or_i128 x y))
 
 ;;;; Rules for `bxor` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -441,34 +477,34 @@
 ;; `{i,b}64` and smaller.
 
 ;; Xor two registers.
-(rule 0 (lower (has_type ty (bxor x y)))
+(rule 0 (lower (has_type ty (bxor _ x y)))
       (if (ty_int_ref_scalar_64 ty))
       (x64_xor ty x y))
 
 ;; Handle xor with lhs immediates/sinkable loads in addition to the automatic
 ;; handling of the rhs above.
 
-(rule 1 (lower (has_type ty (bxor (sinkable_load x) y)))
+(rule 1 (lower (has_type ty (bxor _ (sinkable_load x) y)))
       (if (ty_int_ref_scalar_64 ty))
       (x64_xor ty y x))
 
-(rule 4 (lower (has_type ty (bxor (simm32_from_value x) y)))
+(rule 4 (lower (has_type ty (bxor _ (simm32_from_value x) y)))
       (if (ty_int_ref_scalar_64 ty))
       (x64_xor ty y x))
 
 ;; f32 and f64
 
-(rule 5 (lower (has_type (ty_scalar_float ty) (bxor x y)))
+(rule 5 (lower (has_type (ty_scalar_float ty) (bxor _ x y)))
       (x64_xor_vector ty x y))
 
 ;; SSE.
 
-(rule 6 (lower (has_type ty @ (multi_lane _bits _lanes) (bxor x y)))
+(rule 6 (lower (has_type ty @ (multi_lane _bits _lanes) (bxor _ x y)))
       (x64_xor_vector ty x y))
 
 ;; `{i,b}128`.
 
-(rule 7 (lower (has_type $I128 (bxor x y)))
+(rule 7 (lower (has_type $I128 (bxor _ x y)))
       (let ((x_regs ValueRegs x)
             (x_lo Gpr (value_regs_get_gpr x_regs 0))
             (x_hi Gpr (value_regs_get_gpr x_regs 1))
@@ -480,11 +516,11 @@
 
 ;; Specialization of `blsmsk` for BMI1
 
-(rule 8 (lower (has_type (ty_32_or_64 ty) (bxor x y)))
+(rule 8 (lower (has_type (ty_32_or_64 ty) (bxor _ x y)))
         (if-let $true (use_bmi1))
         (if-let x (val_minus_one y))
         (x64_blsmsk ty x))
-(rule 9 (lower (has_type (ty_32_or_64 ty) (bxor y x)))
+(rule 9 (lower (has_type (ty_32_or_64 ty) (bxor _ y x)))
         (if-let $true (use_bmi1))
         (if-let x (val_minus_one y))
         (x64_blsmsk ty x))
@@ -493,7 +529,7 @@
 
 ;; `i64` and smaller.
 
-(rule -1 (lower (has_type (fits_in_64 ty) (ishl src amt)))
+(rule left_shift_small -1 (lower (has_type (fits_in_64 ty) (ishl _ src amt)))
       (x64_shl ty src (put_masked_in_imm8_gpr amt ty)))
 
 ;; `i128`.
@@ -516,8 +552,8 @@
             (zero Gpr (imm $I64 0))
             ;; Nullify the carry if we are shifting in by a multiple of 128.
             (carry_ Gpr (with_flags_reg (x64_test (OperandSize.Size64)
-                                              (RegMemImm.Imm 127)
-                                              amt)
+                                              amt
+                                              (RegMemImm.Imm 127))
                                         (cmove $I64
                                                (CC.Z)
                                                zero
@@ -527,12 +563,12 @@
         ;; Combine the two shifted halves. However, if we are shifting by >= 64
         ;; (modulo 128), then the low bits are zero and the high bits are our
         ;; low bits.
-        (with_flags (x64_test (OperandSize.Size64) (RegMemImm.Imm 64) amt)
+        (with_flags (x64_test (OperandSize.Size64) amt (RegMemImm.Imm 64))
                     (consumes_flags_concat
                      (cmove $I64 (CC.Z) lo_shifted zero)
                      (cmove $I64 (CC.Z) hi_shifted_ lo_shifted)))))
 
-(rule (lower (has_type $I128 (ishl src amt)))
+(rule (lower (has_type $I128 (ishl _ src amt)))
       ;; NB: Only the low bits of `amt` matter since we logically mask the shift
       ;; amount to the value's bit width.
       (let ((amt_ Gpr (lo_gpr amt)))
@@ -544,7 +580,7 @@
 ;; in higher feature sets like AVX), we lower the `ishl.i8x16` to a sequence of
 ;; instructions. The basic idea, whether the amount to shift by is an immediate
 ;; or not, is to use a 16x8 shift and then mask off the incorrect bits to 0s.
-(rule (lower (has_type ty @ $I8X16 (ishl src amt)))
+(rule (lower (has_type ty @ $I8X16 (ishl _ src amt)))
       (let (
             ;; Mask the amount to ensure wrapping behaviour
             (masked_amt RegMemImm (mask_xmm_shift ty amt))
@@ -589,20 +625,20 @@
 
 ;; 16x8, 32x4, and 64x2 shifts can each use a single instruction, once the shift amount is masked.
 
-(rule (lower (has_type ty @ $I16X8 (ishl src amt)))
+(rule (lower (has_type ty @ $I16X8 (ishl _ src amt)))
       (x64_psllw src (mov_rmi_to_xmm (mask_xmm_shift ty amt))))
 
-(rule (lower (has_type ty @ $I32X4 (ishl src amt)))
+(rule (lower (has_type ty @ $I32X4 (ishl _ src amt)))
       (x64_pslld src (mov_rmi_to_xmm (mask_xmm_shift ty amt))))
 
-(rule (lower (has_type ty @ $I64X2 (ishl src amt)))
+(rule (lower (has_type ty @ $I64X2 (ishl _ src amt)))
       (x64_psllq src (mov_rmi_to_xmm (mask_xmm_shift ty amt))))
 
 ;;;; Rules for `ushr` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; `i64` and smaller.
 
-(rule -1 (lower (has_type (fits_in_64 ty) (ushr src amt)))
+(rule -1 (lower (has_type (fits_in_64 ty) (ushr _ src amt)))
       (let ((src_ Gpr (extend_to_gpr src ty (ExtendKind.Zero))))
         (x64_shr ty src_ (put_masked_in_imm8_gpr amt ty))))
 
@@ -627,19 +663,19 @@
             (zero Gpr (imm $I64 0))
 
             ;; Nullify the carry if we are shifting by a multiple of 128.
-            (carry_ Gpr (with_flags_reg (x64_test (OperandSize.Size64) (RegMemImm.Imm 127) amt)
+            (carry_ Gpr (with_flags_reg (x64_test (OperandSize.Size64) amt (RegMemImm.Imm 127))
                                         (cmove $I64 (CC.Z) zero carry)))
             ;; Add the carry bits into the lo.
             (lo_shifted_ Gpr (x64_or $I64 carry_ lo_shifted)))
         ;; Combine the two shifted halves. However, if we are shifting by >= 64
         ;; (modulo 128), then the hi bits are zero and the lo bits are what
         ;; would otherwise be our hi bits.
-        (with_flags (x64_test (OperandSize.Size64) (RegMemImm.Imm 64) amt)
+        (with_flags (x64_test (OperandSize.Size64) amt (RegMemImm.Imm 64))
                     (consumes_flags_concat
                      (cmove $I64 (CC.Z) lo_shifted_ hi_shifted)
                      (cmove $I64 (CC.Z) hi_shifted zero)))))
 
-(rule (lower (has_type $I128 (ushr src amt)))
+(rule (lower (has_type $I128 (ushr _ src amt)))
       ;; NB: Only the low bits of `amt` matter since we logically mask the shift
       ;; amount to the value's bit width.
       (let ((amt_ Gpr (lo_gpr amt)))
@@ -649,7 +685,7 @@
 
 ;; There are no 8x16 shifts in x64. Do the same 16x8-shift-and-mask thing we do
 ;; with 8x16 `ishl`.
-(rule (lower (has_type ty @ $I8X16 (ushr src amt)))
+(rule (lower (has_type ty @ $I8X16 (ushr _ src amt)))
       (let (
             ;; Mask the amount to ensure wrapping behaviour
             (masked_amt RegMemImm (mask_xmm_shift ty amt))
@@ -695,26 +731,26 @@
 
 ;; 16x8, 32x4, and 64x2 shifts can each use a single instruction, once the shift amount is masked.
 
-(rule (lower (has_type ty @ $I16X8 (ushr src amt)))
+(rule (lower (has_type ty @ $I16X8 (ushr _ src amt)))
       (x64_psrlw src (mov_rmi_to_xmm (mask_xmm_shift ty amt))))
 
-(rule (lower (has_type ty @ $I32X4 (ushr src amt)))
+(rule (lower (has_type ty @ $I32X4 (ushr _ src amt)))
       (x64_psrld src (mov_rmi_to_xmm (mask_xmm_shift ty amt))))
 
-(rule (lower (has_type ty @ $I64X2 (ushr src amt)))
+(rule (lower (has_type ty @ $I64X2 (ushr _ src amt)))
       (x64_psrlq src (mov_rmi_to_xmm (mask_xmm_shift ty amt))))
 
 (decl mask_xmm_shift (Type Value) RegMemImm)
 (rule (mask_xmm_shift ty amt)
       (gpr_to_reg (x64_and $I64 amt (RegMemImm.Imm (shift_mask ty)))))
-(rule 1 (mask_xmm_shift ty (iconst n))
+(rule 1 (mask_xmm_shift ty (iconst _ n))
       (RegMemImm.Imm (shift_amount_masked ty n)))
 
 ;;;; Rules for `sshr` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; `i64` and smaller.
 
-(rule -1 (lower (has_type (fits_in_64 ty) (sshr src amt)))
+(rule -1 (lower (has_type (fits_in_64 ty) (sshr _ src amt)))
       (let ((src_ Gpr (extend_to_gpr src ty (ExtendKind.Sign))))
         (x64_sar ty src_ (put_masked_in_imm8_gpr amt ty))))
 
@@ -737,7 +773,7 @@
                                  (imm $I64 64)
                                  amt)))
             ;; Nullify the carry if we are shifting by a multiple of 128.
-            (carry_ Gpr (with_flags_reg (x64_test (OperandSize.Size64) (RegMemImm.Imm 127) amt)
+            (carry_ Gpr (with_flags_reg (x64_test (OperandSize.Size64) amt (RegMemImm.Imm 127))
                                         (cmove $I64 (CC.Z) (imm $I64 0) carry)))
             ;; Add the carry into the low half.
             (lo_shifted_ Gpr (x64_or $I64 lo_shifted carry_))
@@ -746,12 +782,12 @@
         ;; Combine the two shifted halves. However, if we are shifting by >= 64
         ;; (modulo 128), then the hi bits are all sign bits and the lo bits are
         ;; what would otherwise be our hi bits.
-        (with_flags (x64_test (OperandSize.Size64) (RegMemImm.Imm 64) amt)
+        (with_flags (x64_test (OperandSize.Size64) amt (RegMemImm.Imm 64))
                     (consumes_flags_concat
                      (cmove $I64 (CC.Z) lo_shifted_ hi_shifted)
                      (cmove $I64 (CC.Z) hi_shifted sign_bits)))))
 
-(rule (lower (has_type $I128 (sshr src amt)))
+(rule (lower (has_type $I128 (sshr _ src amt)))
       ;; NB: Only the low bits of `amt` matter since we logically mask the shift
       ;; amount to the value's bit width.
       (let ((amt_ Gpr (lo_gpr amt)))
@@ -772,7 +808,7 @@
 ;;   hi.i16x8 = [(s8, s8), (s9, s9), ..., (s15, s15)]
 ;;   shifted_hi.i16x8 = shift each lane of `high`
 ;;   result = [s0'', s1'', ..., s15'']
-(rule (lower (has_type ty @ $I8X16 (sshr src amt @ (value_type amt_ty))))
+(rule (lower (has_type ty @ $I8X16 (sshr _ src amt @ (value_type amt_ty))))
       (let ((src_ Xmm (put_in_xmm src))
             ;; Mask the amount to ensure wrapping behaviour
             (masked_amt RegMemImm (mask_xmm_shift ty amt))
@@ -801,30 +837,30 @@
 ;; `sshr.{i16x8,i32x4}` can be a simple `psra{w,d}`, we just have to make sure
 ;; that if the shift amount is in a register, it is in an XMM register.
 
-(rule (lower (has_type ty @ $I16X8 (sshr src amt)))
+(rule (lower (has_type ty @ $I16X8 (sshr _ src amt)))
       (x64_psraw src (mov_rmi_to_xmm (mask_xmm_shift ty amt))))
 
-(rule (lower (has_type ty @ $I32X4 (sshr src amt)))
+(rule (lower (has_type ty @ $I32X4 (sshr _ src amt)))
       (x64_psrad src (mov_rmi_to_xmm (mask_xmm_shift ty amt))))
 
 ;; The `sshr.i64x2` CLIF instruction has no single x86 instruction in the older
 ;; feature sets. To remedy this, a small dance is done with an unsigned right
 ;; shift plus some extra ops.
-(rule 3 (lower (has_type ty @ $I64X2 (sshr src (iconst n))))
+(rule 3 (lower (has_type ty @ $I64X2 (sshr _ src (iconst _ n))))
         (if-let $true (use_avx512vl))
         (if-let $true (use_avx512f))
         (x64_vpsraq_imm src (shift_amount_masked ty n)))
 
-(rule 2 (lower (has_type ty @ $I64X2 (sshr src amt)))
+(rule 2 (lower (has_type ty @ $I64X2 (sshr _ src amt)))
         (if-let $true (use_avx512vl))
         (if-let $true (use_avx512f))
         (let ((masked Gpr (x64_and $I64 amt (RegMemImm.Imm (shift_mask ty)))))
           (x64_vpsraq src (x64_movd_to_xmm masked))))
 
-(rule 1 (lower (has_type $I64X2 (sshr src (iconst (u64_from_imm64 (u64_as_u32 amt))))))
+(rule 1 (lower (has_type $I64X2 (sshr _ src (iconst _ (u64_from_imm64 (u64_as_u32 amt))))))
         (lower_i64x2_sshr_imm src (u32_and amt 63)))
 
-(rule (lower (has_type $I64X2 (sshr src amt)))
+(rule (lower (has_type $I64X2 (sshr _ src amt)))
       (lower_i64x2_sshr_gpr src (x64_and $I64 amt (RegMemImm.Imm 63))))
 
 (decl lower_i64x2_sshr_imm (Xmm u32) Xmm)
@@ -884,13 +920,13 @@
 ;; `i64` and smaller: we can rely on x86's rotate-amount masking since
 ;;  we operate on the whole register. For const's we mask the constant.
 
-(rule -1 (lower (has_type (fits_in_64 ty) (rotl src amt)))
+(rule -1 (lower (has_type (fits_in_64 ty) (rotl _ src amt)))
         (x64_rotl ty src (put_masked_in_imm8_gpr amt ty)))
 
 
 ;; `i128`.
 
-(rule (lower (has_type $I128 (rotl src amt)))
+(rule (lower (has_type $I128 (rotl _ src amt)))
       (let ((src_ ValueRegs src)
             ;; NB: Only the low bits of `amt` matter since we logically mask the
             ;; rotation amount to the value's bit width.
@@ -905,13 +941,13 @@
 ;; `i64` and smaller: we can rely on x86's rotate-amount masking since
 ;;  we operate on the whole register. For const's we mask the constant.
 
-(rule -1 (lower (has_type (fits_in_64 ty) (rotr src amt)))
+(rule -1 (lower (has_type (fits_in_64 ty) (rotr _ src amt)))
         (x64_rotr ty src (put_masked_in_imm8_gpr amt ty)))
 
 
 ;; `i128`.
 
-(rule (lower (has_type $I128 (rotr src amt)))
+(rule (lower (has_type $I128 (rotr _ src amt)))
       (let ((src_ ValueRegs src)
             ;; NB: Only the low bits of `amt` matter since we logically mask the
             ;; rotation amount to the value's bit width.
@@ -925,10 +961,10 @@
 
 ;; `i64` and smaller.
 
-(rule -1 (lower (has_type (fits_in_64 ty) (ineg x)))
+(rule -1 (lower (has_type (fits_in_64 ty) (ineg _ x)))
       (x64_neg ty x))
 
-(rule -2 (lower (has_type $I128 (ineg x)))
+(rule -2 (lower (has_type $I128 (ineg _ x)))
       ;; Get the high/low registers for `x`.
       (let ((regs ValueRegs x)
             (lo Gpr (value_regs_get_gpr regs 0))
@@ -939,48 +975,67 @@
 
 ;; SSE.
 
-(rule (lower (has_type $I8X16 (ineg x)))
+(rule (lower (has_type $I8X16 (ineg _ x)))
       (x64_psubb (imm $I8X16 0) x))
 
-(rule (lower (has_type $I16X8 (ineg x)))
+(rule (lower (has_type $I16X8 (ineg _ x)))
       (x64_psubw (imm $I16X8 0) x))
 
-(rule (lower (has_type $I32X4 (ineg x)))
+(rule (lower (has_type $I32X4 (ineg _ x)))
       (x64_psubd (imm $I32X4 0) x))
 
-(rule (lower (has_type $I64X2 (ineg x)))
+(rule (lower (has_type $I64X2 (ineg _ x)))
       (x64_psubq (imm $I64X2 0) x))
 
 ;;;; Rules for `avg_round` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (rule (lower (has_type (multi_lane 8 16)
-                       (avg_round x y)))
+                       (avg_round _ x y)))
       (x64_pavgb x y))
 
 (rule (lower (has_type (multi_lane 16 8)
-                       (avg_round x y)))
+                       (avg_round _ x y)))
       (x64_pavgw x y))
 
 ;;;; Rules for `imul` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; `i64` and smaller.
 
-;; Multiply two registers.
-(rule -5 (lower (has_type (fits_in_64 ty) (imul x y)))
-      (x64_mul ty x y))
+;; 8-bit base case, needs a special instruction encoding and additionally
+;; move sinkable loads to the right.
+(rule -7 (lower (has_type $I8 (imul _ x y))) (x64_mul8 $false x y))
+(rule -6 (lower (has_type $I8 (imul _ (sinkable_load x) y))) (x64_mul8 $false y x))
 
-;; Handle multiplication where the lhs is an immediate or sinkable load in
-;; addition to the automatic rhs handling above.
+;; 16-to-64-bit base cases, same as above by moving sinkable loads to the right.
+(rule -5 (lower (has_type (ty_int_ref_16_to_64 ty) (imul _ x y)))
+         (x64_imul ty x y))
+(rule -4 (lower (has_type (ty_int_ref_16_to_64 ty) (imul _ (sinkable_load x) y)))
+         (x64_imul ty y x))
 
-(rule -4 (lower (has_type (fits_in_64 ty)
-                       (imul (simm32_from_value x) y)))
-      (x64_mul ty y x))
-(rule -3 (lower (has_type (fits_in_64 ty)
-                       (imul (sinkable_load x) y)))
-      (x64_mul ty y x))
+;; lift out constants to use 3-operand form
+(rule -3 (lower (has_type (ty_int_ref_16_to_64 ty) (imul _ x (i32_from_iconst y))))
+         (x64_imul_imm ty x y))
+(rule -2 (lower (has_type (ty_int_ref_16_to_64 ty) (imul _ (i32_from_iconst x) y)))
+         (x64_imul_imm ty y x))
 
 ;; `i128`.
 
+(rule 2 (lower (has_type $I128 (imul _ x y)))
+      (let ((x_regs ValueRegs x)
+            (y_regs ValueRegs y))
+        (imul128
+          (value_regs_get_gpr x_regs 0)
+          (value_regs_get_gpr x_regs 1)
+          (value_regs_get_gpr y_regs 0)
+          (value_regs_get_gpr y_regs 1))))
+
+(rule 4 (lower (has_type $I128 (imul _ (iconcat _ x_lo x_hi) (iconcat _ y_lo y_hi))))
+        (imul128 x_lo x_hi y_lo y_hi))
+
+;; Helper for lowering 128-bit multiplication with the 64-bit halves of the
+;; lhs/rhs already split. The first two arguments are lo/hi for the lhs and the
+;; second two are lo/hi for the rhs.
+;;
 ;; mul:
 ;;   dst_lo = lhs_lo * rhs_lo
 ;;   dst_hi = umulhi(lhs_lo, rhs_lo) +
@@ -994,44 +1049,49 @@
 ;;   dst_lo:hi_lolo = mulhi_u x_lo, y_lo
 ;;   dst_hi = add hilo_hilo, hi_lolo
 ;;   return (dst_lo, dst_hi)
-(rule 2 (lower (has_type $I128 (imul x y)))
+(decl imul128 (Gpr Gpr GprMem GprMem) ValueRegs)
+(rule (imul128 x_lo x_hi y_lo y_hi)
       ;; Put `x` into registers and unpack its hi/lo halves.
-      (let ((x_regs ValueRegs x)
-            (x_lo Gpr (value_regs_get_gpr x_regs 0))
-            (x_hi Gpr (value_regs_get_gpr x_regs 1))
-            ;; Put `y` into registers and unpack its hi/lo halves.
-            (y_regs ValueRegs y)
-            (y_lo Gpr (value_regs_get_gpr y_regs 0))
-            (y_hi Gpr (value_regs_get_gpr y_regs 1))
-            ;; lo_hi = mul x_lo, y_hi
-            (lo_hi Gpr (x64_mul $I64 x_lo y_hi))
+      (let (;; lo_hi = mul x_lo, y_hi
+            (lo_hi Gpr (x64_imul $I64 x_lo y_hi))
             ;; hi_lo = mul x_hi, y_lo
-            (hi_lo Gpr (x64_mul $I64 x_hi y_lo))
+            (hi_lo Gpr (x64_imul $I64 x_hi y_lo))
             ;; hilo_hilo = add lo_hi, hi_lo
             (hilo_hilo Gpr (x64_add $I64 lo_hi hi_lo))
-            ;; dst_lo:hi_lolo = mulhi_u x_lo, y_lo
-            (mul_regs ValueRegs (mulhi_u $I64 x_lo y_lo))
+            ;; dst_lo:hi_lolo = x64_mul x_lo, y_lo
+            (mul_regs ValueRegs (x64_mul $I64 $false x_lo y_lo))
             (dst_lo Gpr (value_regs_get_gpr mul_regs 0))
             (hi_lolo Gpr (value_regs_get_gpr mul_regs 1))
             ;; dst_hi = add hilo_hilo, hi_lolo
             (dst_hi Gpr (x64_add $I64 hilo_hilo hi_lolo)))
         (value_gprs dst_lo dst_hi)))
 
+;; The `mul` and `imul` instructions on x64 are defined as taking 64-bit
+;; operands and producing a 128-bit result, which exactly matches the semantics
+;; of widening 64-bit inputs to 128-bit and then multiplying them. That means
+;; that these cases can get some some simpler codegen.
+(rule 5 (lower (has_type $I128 (imul _ (uextend _ x @ (value_type $I64))
+                                     (uextend _ y @ (value_type $I64)))))
+        (x64_mul $I64 $false x y))
+(rule 5 (lower (has_type $I128 (imul _ (sextend _ x @ (value_type $I64))
+                                     (sextend _ y @ (value_type $I64)))))
+        (x64_mul $I64 $true x y))
+
 ;; SSE.
 
 ;; (No i8x16 multiply.)
 
-(rule (lower (has_type (multi_lane 16 8) (imul x y)))
+(rule (lower (has_type (multi_lane 16 8) (imul _ x y)))
       (x64_pmullw x y))
 
-(rule (lower (has_type (multi_lane 32 4) (imul x y)))
+(rule (lower (has_type (multi_lane 32 4) (imul _ x y)))
       (if-let $true (use_sse41))
       (x64_pmulld x y))
 
 ;; Without `pmulld` the `pmuludq` instruction is used instead which performs
 ;; 32-bit multiplication storing the 64-bit result. The 64-bit result is
 ;; truncated to 32-bits and everything else is woven into place.
-(rule -1 (lower (has_type (multi_lane 32 4) (imul x y)))
+(rule -1 (lower (has_type (multi_lane 32 4) (imul _ x y)))
          (let (
             (x Xmm x)
             (y Xmm y)
@@ -1044,7 +1104,7 @@
 
 ;; With AVX-512 we can implement `i64x2` multiplication with a single
 ;; instruction.
-(rule 3 (lower (has_type (multi_lane 64 2) (imul x y)))
+(rule 3 (lower (has_type (multi_lane 64 2) (imul _ x y)))
       (if-let $true (use_avx512vl))
       (if-let $true (use_avx512dq))
       (x64_vpmullq x y))
@@ -1070,7 +1130,7 @@
 ;; the lower 32-bits, however, we will need to use shifts to isolate the high
 ;; 32-bits when doing calculations, i.e., `Ah == A >> 32`.
 (rule (lower (has_type (multi_lane 64 2)
-                       (imul a b)))
+                       (imul _ a b)))
       (let ((a0 Xmm a)
             (b0 Xmm b)
             ;; a_hi = A >> 32
@@ -1092,9 +1152,9 @@
 
 ;; Special case for `i32x4.extmul_high_i16x8_s`.
 (rule 1 (lower (has_type (multi_lane 32 4)
-                       (imul (swiden_high (and (value_type (multi_lane 16 8))
+                       (imul _ (swiden_high _ (and (value_type (multi_lane 16 8))
                                                x))
-                             (swiden_high (and (value_type (multi_lane 16 8))
+                             (swiden_high _ (and (value_type (multi_lane 16 8))
                                                y)))))
       (let ((x2 Xmm x)
             (y2 Xmm y)
@@ -1104,9 +1164,9 @@
 
 ;; Special case for `i64x2.extmul_high_i32x4_s`.
 (rule 1 (lower (has_type (multi_lane 64 2)
-                       (imul (swiden_high (and (value_type (multi_lane 32 4))
+                       (imul _ (swiden_high _ (and (value_type (multi_lane 32 4))
                                                x))
-                             (swiden_high (and (value_type (multi_lane 32 4))
+                             (swiden_high _ (and (value_type (multi_lane 32 4))
                                                y)))))
       (if-let $true (use_sse41))
       (let ((x2 Xmm (x64_pshufd x 0xFA))
@@ -1115,9 +1175,9 @@
 
 ;; Special case for `i32x4.extmul_low_i16x8_s`.
 (rule 1 (lower (has_type (multi_lane 32 4)
-                       (imul (swiden_low (and (value_type (multi_lane 16 8))
+                       (imul _ (swiden_low _ (and (value_type (multi_lane 16 8))
                                               x))
-                             (swiden_low (and (value_type (multi_lane 16 8))
+                             (swiden_low _ (and (value_type (multi_lane 16 8))
                                               y)))))
       (let ((x2 Xmm x)
             (y2 Xmm y)
@@ -1127,9 +1187,9 @@
 
 ;; Special case for `i64x2.extmul_low_i32x4_s`.
 (rule 1 (lower (has_type (multi_lane 64 2)
-                       (imul (swiden_low (and (value_type (multi_lane 32 4))
+                       (imul _ (swiden_low _ (and (value_type (multi_lane 32 4))
                                               x))
-                             (swiden_low (and (value_type (multi_lane 32 4))
+                             (swiden_low _ (and (value_type (multi_lane 32 4))
                                               y)))))
       (if-let $true (use_sse41))
       (let ((x2 Xmm (x64_pshufd x 0x50))
@@ -1138,9 +1198,9 @@
 
 ;; Special case for `i32x4.extmul_high_i16x8_u`.
 (rule 1 (lower (has_type (multi_lane 32 4)
-                       (imul (uwiden_high (and (value_type (multi_lane 16 8))
+                       (imul _ (uwiden_high _ (and (value_type (multi_lane 16 8))
                                                x))
-                             (uwiden_high (and (value_type (multi_lane 16 8))
+                             (uwiden_high _ (and (value_type (multi_lane 16 8))
                                                y)))))
       (let ((x2 Xmm x)
             (y2 Xmm y)
@@ -1150,9 +1210,9 @@
 
 ;; Special case for `i64x2.extmul_high_i32x4_u`.
 (rule 1 (lower (has_type (multi_lane 64 2)
-                       (imul (uwiden_high (and (value_type (multi_lane 32 4))
+                       (imul _ (uwiden_high _ (and (value_type (multi_lane 32 4))
                                                x))
-                             (uwiden_high (and (value_type (multi_lane 32 4))
+                             (uwiden_high _ (and (value_type (multi_lane 32 4))
                                                y)))))
       (let ((x2 Xmm (x64_pshufd x 0xFA))
             (y2 Xmm (x64_pshufd y 0xFA)))
@@ -1160,9 +1220,9 @@
 
 ;; Special case for `i32x4.extmul_low_i16x8_u`.
 (rule 1 (lower (has_type (multi_lane 32 4)
-                       (imul (uwiden_low (and (value_type (multi_lane 16 8))
+                       (imul _ (uwiden_low _ (and (value_type (multi_lane 16 8))
                                               x))
-                             (uwiden_low (and (value_type (multi_lane 16 8))
+                             (uwiden_low _ (and (value_type (multi_lane 16 8))
                                               y)))))
       (let ((x2 Xmm x)
             (y2 Xmm y)
@@ -1172,9 +1232,9 @@
 
 ;; Special case for `i64x2.extmul_low_i32x4_u`.
 (rule 1 (lower (has_type (multi_lane 64 2)
-                       (imul (uwiden_low (and (value_type (multi_lane 32 4))
+                       (imul _ (uwiden_low _ (and (value_type (multi_lane 32 4))
                                               x))
-                             (uwiden_low (and (value_type (multi_lane 32 4))
+                             (uwiden_low _ (and (value_type (multi_lane 32 4))
                                               y)))))
       (let ((x2 Xmm (x64_pshufd x 0x50))
             (y2 Xmm (x64_pshufd y 0x50)))
@@ -1182,32 +1242,32 @@
 
 ;;;; Rules for `iabs` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 1 (lower (has_type $I8X16 (iabs x)))
+(rule 1 (lower (has_type $I8X16 (iabs _ x)))
         (if-let $true (use_ssse3))
         (x64_pabsb x))
 
 ;; Note the use of `pminub` with signed inputs will produce the positive signed
 ;; result which is what is desired here. The `pmaxub` isn't available until
 ;; SSE4.1 in which case the single-instruction above lowering would apply.
-(rule (lower (has_type $I8X16 (iabs x)))
+(rule (lower (has_type $I8X16 (iabs _ x)))
       (let (
           (x Xmm x)
           (negated Xmm (x64_psubb (xmm_zero $I8X16) x))
         )
         (x64_pminub x negated)))
 
-(rule 1 (lower (has_type $I16X8 (iabs x)))
+(rule 1 (lower (has_type $I16X8 (iabs _ x)))
         (if-let $true (use_ssse3))
         (x64_pabsw x))
 
-(rule (lower (has_type $I16X8 (iabs x)))
+(rule (lower (has_type $I16X8 (iabs _ x)))
       (let (
           (x Xmm x)
           (negated Xmm (x64_psubw (xmm_zero $I16X8) x))
         )
         (x64_pmaxsw x negated)))
 
-(rule 1 (lower (has_type $I32X4 (iabs x)))
+(rule 1 (lower (has_type $I32X4 (iabs _ x)))
         (if-let $true (use_ssse3))
         (x64_pabsd x))
 
@@ -1217,7 +1277,7 @@
 ;; subtracting the mask this subtracts 0 for positive lanes (does nothing) or
 ;; ends up adding one for negative lanes. This means that for a negative lane
 ;; `x` the result is `!x + 1` which is the result of negating it.
-(rule (lower (has_type $I32X4 (iabs x)))
+(rule (lower (has_type $I32X4 (iabs _ x)))
       (let (
           (x Xmm x)
           (negative_mask Xmm (x64_psrad x (xmi_imm 31)))
@@ -1226,7 +1286,7 @@
         (x64_psubd flipped_if_negative negative_mask)))
 
 ;; When AVX512 is available, we can use a single `vpabsq` instruction.
-(rule 2 (lower (has_type $I64X2 (iabs x)))
+(rule 2 (lower (has_type $I64X2 (iabs _ x)))
       (if-let $true (use_avx512vl))
       (if-let $true (use_avx512f))
       (x64_vpabsq x))
@@ -1235,7 +1295,7 @@
 ;; x` and then blend in those results with `blendvpd` if the MSB of `neg` was
 ;; set to 1 (i.e. if `neg` was negative or, conversely, if `x` was originally
 ;; positive).
-(rule 1 (lower (has_type $I64X2 (iabs x)))
+(rule 1 (lower (has_type $I64X2 (iabs _ x)))
         (if-let $true (use_sse41))
         (let ((rx Xmm x)
               (neg Xmm (x64_psubq (imm $I64X2 0) rx)))
@@ -1244,7 +1304,7 @@
 ;; and if `blendvpd` isn't available then perform a shift/shuffle to generate a
 ;; mask of which lanes are negative, followed by flipping bits/sub to make both
 ;; positive.
-(rule (lower (has_type $I64X2 (iabs x)))
+(rule (lower (has_type $I64X2 (iabs _ x)))
       (let ((x Xmm x)
             (signs Xmm (x64_psrad x (RegMemImm.Imm 31)))
             (signs Xmm (x64_pshufd signs 0b11_11_01_01))
@@ -1253,7 +1313,7 @@
 
 ;; `i64` and smaller.
 
-(rule -1 (lower (has_type (fits_in_64 ty) (iabs x)))
+(rule -1 (lower (has_type (fits_in_64 ty) (iabs _ x)))
       (let ((src Gpr x)
             (neg ProducesFlags (x64_neg_paired ty src))
             ;; Manually extract the result from the neg, then ignore
@@ -1265,37 +1325,58 @@
             (cmove ConsumesFlags (cmove ty (CC.S) src neg_result)))
         (with_flags_reg (produces_flags_ignore neg) cmove)))
 
+;; `i128`. Negate the low bits, `adc` to the higher bits, then negate high bits.
+(rule (lower (has_type $I128 (iabs _ x)))
+      ;; Get the high/low registers for `x`.
+      (let ((x_regs ValueRegs x)
+            (x_lo Gpr (value_regs_get_gpr x_regs 0))
+            (x_hi Gpr (value_regs_get_gpr x_regs 1))
+            ; negate low bits, then add 0 with carry to high bits.
+            (neg_lo ProducesFlags (x64_neg_paired $I64 x_lo))
+            (adc_hi ConsumesFlags (x64_adc_paired $I64 x_hi (imm $I64 0)))
+            (neg_adc_vals ValueRegs (with_flags neg_lo adc_hi))
+            ; negate high bits.
+            (neg_hi ProducesFlags (x64_neg_paired $I64 (value_regs_get neg_adc_vals 1)))
+            (neg_hi_flag_only ProducesFlags (produces_flags_ignore neg_hi))
+            ; cmove based on sign flag from hi negation.
+            (cmove_lo ConsumesFlags (cmove $I64 (CC.S) x_lo
+                                     (value_regs_get neg_adc_vals 0)))
+            (cmove_hi ConsumesFlags (cmove $I64 (CC.S) x_hi
+                                     (produces_flags_get_reg neg_hi)))
+            (cmoves ConsumesFlags (consumes_flags_concat cmove_lo cmove_hi)))
+        (with_flags neg_hi_flag_only cmoves)))
+
 ;;;; Rules for `fabs` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type $F32 (fabs x)))
+(rule (lower (has_type $F32 (fabs _ x)))
       (x64_andps x (imm $F32 0x7fffffff)))
 
-(rule (lower (has_type $F64 (fabs x)))
+(rule (lower (has_type $F64 (fabs _ x)))
       (x64_andpd x (imm $F64 0x7fffffffffffffff)))
 
 ;; Special case for `f32x4.abs`.
-(rule (lower (has_type $F32X4 (fabs x)))
+(rule (lower (has_type $F32X4 (fabs _ x)))
       (x64_andps x
              (x64_psrld (vector_all_ones) (xmi_imm 1))))
 
 ;; Special case for `f64x2.abs`.
-(rule (lower (has_type $F64X2 (fabs x)))
+(rule (lower (has_type $F64X2 (fabs _ x)))
       (x64_andpd x
              (x64_psrlq (vector_all_ones) (xmi_imm 1))))
 
 ;;;; Rules for `fneg` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type $F32 (fneg x)))
+(rule (lower (has_type $F32 (fneg _ x)))
       (x64_xorps x (imm $F32 0x80000000)))
 
-(rule (lower (has_type $F64 (fneg x)))
+(rule (lower (has_type $F64 (fneg _ x)))
       (x64_xorpd x (imm $F64 0x8000000000000000)))
 
-(rule (lower (has_type $F32X4 (fneg x)))
+(rule (lower (has_type $F32X4 (fneg _ x)))
       (x64_xorps x
              (x64_pslld (vector_all_ones) (xmi_imm 31))))
 
-(rule (lower (has_type $F64X2 (fneg x)))
+(rule (lower (has_type $F64X2 (fneg _ x)))
       (x64_xorpd x
              (x64_psllq (vector_all_ones) (xmi_imm 63))))
 
@@ -1340,14 +1421,14 @@
 
 
 ;; Call the lower_bmask rule that does all the procssing
-(rule (lower (has_type out_ty (bmask x @ (value_type in_ty))))
+(rule (lower (has_type out_ty (bmask _ x @ (value_type in_ty))))
       (lower_bmask out_ty in_ty x))
 
 ;;;; Rules for `bnot` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; `i64` and smaller.
 
-(rule -2 (lower (has_type ty (bnot x)))
+(rule -2 (lower (has_type ty (bnot _ x)))
       (if (ty_int_ref_scalar_64 ty))
       (x64_not ty x))
 
@@ -1362,23 +1443,23 @@
         (value_gprs (x64_not $I64 x_lo)
                     (x64_not $I64 x_hi))))
 
-(rule (lower (has_type $I128 (bnot x)))
+(rule (lower (has_type $I128 (bnot _ x)))
       (i128_not x))
 
 ;; f32 and f64
 
-(rule -3 (lower (has_type (ty_scalar_float ty) (bnot x)))
+(rule -3 (lower (has_type (ty_scalar_float ty) (bnot _ x)))
       (x64_xor_vector ty x (vector_all_ones)))
 
 ;; Special case for vector-types where bit-negation is an xor against an
 ;; all-one value
-(rule -1 (lower (has_type ty @ (multi_lane _bits _lanes) (bnot x)))
+(rule -1 (lower (has_type ty @ (multi_lane _bits _lanes) (bnot _ x)))
       (x64_xor_vector ty x (vector_all_ones)))
 
 ;;;; Rules for `bitselect` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (rule (lower (has_type ty @ (multi_lane _bits _lanes)
-                       (bitselect condition
+                       (bitselect _ condition
                                   if_true
                                   if_false)))
       ;; a = and if_true, condition
@@ -1392,7 +1473,7 @@
 ;; If every byte of the condition is guaranteed to be all ones or all zeroes,
 ;; we can use x64_blend.
 (rule 1 (lower (has_type ty @ (multi_lane _bits _lanes)
-                         (bitselect condition
+                         (bitselect _ condition
                                     if_true
                                     if_false)))
       (if-let $true (use_sse41))
@@ -1400,9 +1481,10 @@
       (x64_pblendvb if_false if_true condition))
 
 (decl pure partial all_ones_or_all_zeros (Value) bool)
-(rule (all_ones_or_all_zeros (and (icmp _ _ _) (value_type (multi_lane _ _)))) $true)
-(rule (all_ones_or_all_zeros (and (fcmp _ _ _) (value_type (multi_lane _ _)))) $true)
-(rule (all_ones_or_all_zeros (vconst (vconst_all_ones_or_all_zeros))) $true)
+(rule (all_ones_or_all_zeros (and (icmp _ _ _ _) (value_type (multi_lane _ _)))) $true)
+(rule (all_ones_or_all_zeros (and (fcmp _ _ _ _) (value_type (multi_lane _ _)))) $true)
+(rule (all_ones_or_all_zeros (and (bitcast _ _ (fcmp _ _ _ _)) (value_type (multi_lane _ _)))) $true)
+(rule (all_ones_or_all_zeros (vconst _ (vconst_all_ones_or_all_zeros))) $true)
 
 (decl pure vconst_all_ones_or_all_zeros () Constant)
 (extern extractor vconst_all_ones_or_all_zeros vconst_all_ones_or_all_zeros)
@@ -1412,29 +1494,29 @@
 ;; instructions and how they're lowered into CLIF. Note the careful ordering
 ;; of all the operands here to ensure that the input CLIF matched is implemented
 ;; by the corresponding x64 instruction.
-(rule 2 (lower (has_type $F32X4 (bitselect (bitcast _ (fcmp (FloatCC.LessThan) x y)) x y)))
+(rule 2 (lower (has_type $F32X4 (bitselect _ (bitcast _ _ (fcmp _ (FloatCC.LessThan) x y)) x y)))
         (x64_minps x y))
-(rule 2 (lower (has_type $F64X2 (bitselect (bitcast _ (fcmp (FloatCC.LessThan) x y)) x y)))
+(rule 2 (lower (has_type $F64X2 (bitselect _ (bitcast _ _ (fcmp _ (FloatCC.LessThan) x y)) x y)))
         (x64_minpd x y))
 
-(rule 3 (lower (has_type $F32X4 (bitselect (bitcast _ (fcmp (FloatCC.LessThan) y x)) x y)))
+(rule 3 (lower (has_type $F32X4 (bitselect _ (bitcast _ _ (fcmp _ (FloatCC.LessThan) y x)) x y)))
         (x64_maxps x y))
-(rule 3 (lower (has_type $F64X2 (bitselect (bitcast _ (fcmp (FloatCC.LessThan) y x)) x y)))
+(rule 3 (lower (has_type $F64X2 (bitselect _ (bitcast _ _ (fcmp _ (FloatCC.LessThan) y x)) x y)))
         (x64_maxpd x y))
 
 ;; Scalar rules
 
-(rule 3 (lower (has_type $I128 (bitselect c t f)))
+(rule 3 (lower (has_type $I128 (bitselect _ c t f)))
       (let ((a ValueRegs (and_i128 c t))
             (b ValueRegs (and_i128 (i128_not c) f)))
         (or_i128 a b)))
 
-(rule 4 (lower (has_type (ty_int_ref_scalar_64 ty) (bitselect c t f)))
+(rule 4 (lower (has_type (ty_int_ref_scalar_64 ty) (bitselect _ c t f)))
       (let ((a Gpr (x64_and ty c t))
             (b Gpr (x64_and ty (x64_not ty c) f)))
         (x64_or ty a b)))
 
-(rule 5 (lower (has_type (ty_scalar_float ty) (bitselect c t f)))
+(rule 5 (lower (has_type (ty_scalar_float ty) (bitselect _ c t f)))
       (let ((a Xmm (sse_and ty c t))
             (c_neg Xmm (x64_xor_vector ty c (vector_all_ones)))
             (b Xmm (sse_and ty c_neg f)))
@@ -1443,36 +1525,28 @@
 ;;;; Rules for `x86_blendv` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (rule (lower (has_type $I8X16
-                       (x86_blendv condition if_true if_false)))
+                       (x86_blendv _ condition if_true if_false)))
       (if-let $true (use_sse41))
       (x64_pblendvb if_false if_true condition))
 
 (rule (lower (has_type $I32X4
-                       (x86_blendv condition if_true if_false)))
+                       (x86_blendv _ condition if_true if_false)))
       (if-let $true (use_sse41))
       (x64_blendvps if_false if_true condition))
 
 (rule (lower (has_type $I64X2
-                       (x86_blendv condition if_true if_false)))
+                       (x86_blendv _ condition if_true if_false)))
       (if-let $true (use_sse41))
       (x64_blendvpd if_false if_true condition))
 
 ;;;; Rules for `insertlane` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (insertlane vec @ (value_type ty) val (u8_from_uimm8 idx)))
-      (vec_insert_lane ty vec val idx))
-
-;; Helper function used below for `insertlane` but also here for other
-;; lowerings.
-;;
-;; Note that the `Type` used here is the type of vector the insertion is
-;; happening into, or the type of the first `Reg` argument.
-(decl vec_insert_lane (Type Xmm RegMem u8) Xmm)
-
-;; i8x16.replace_lane
-(rule 1 (vec_insert_lane $I8X16 vec val idx)
-        (if-let $true (use_sse41))
-        (x64_pinsrb vec val idx))
+(rule 1 (lower (insertlane _ vec @ (value_type $I8X16) val (u8_from_uimm8 idx)))
+  (if-let $true (use_sse41))
+  (x64_pinsrb vec val idx))
+(rule 2 (lower (insertlane _ vec @ (value_type $I8X16) (sinkable_load_exact val) (u8_from_uimm8 idx)))
+  (if-let $true (use_sse41))
+  (x64_pinsrb vec val idx))
 
 ;; This lowering is particularly unoptimized and is mostly just here to work
 ;; rather than here to be fast. Requiring SSE 4.1 for the above lowering isn't
@@ -1498,7 +1572,7 @@
 ;; This all, laboriously, gets the `val` into the desired lane so it's then
 ;; `por`'d with the original vec-with-a-hole to produce the final result of the
 ;; insertion.
-(rule (vec_insert_lane $I8X16 vec val n)
+(rule (lower (insertlane _ vec @ (value_type $I8X16) val (u8_from_uimm8 n)))
       (let ((vec_with_hole Xmm (x64_pand vec (insert_i8x16_lane_hole n)))
             (val Gpr (x64_movzx (ExtMode.BL) val))
             (val Gpr (x64_shl $I32 val (Imm8Reg.Imm8 (u8_shl (u8_and n 3) 3))))
@@ -1514,102 +1588,117 @@
 (rule (insert_i8x16_lane_pshufd_imm 2) 0b01_00_01_01)
 (rule (insert_i8x16_lane_pshufd_imm 3) 0b00_01_01_01)
 
+
 ;; i16x8.replace_lane
-(rule (vec_insert_lane $I16X8 vec val idx)
-      (x64_pinsrw vec val idx))
+(rule (lower (insertlane _ vec @ (value_type $I16X8) val (u8_from_uimm8 idx)))
+  (x64_pinsrw vec val idx))
+(rule 1 (lower (insertlane _ vec @ (value_type $I16X8) (sinkable_load_exact val) (u8_from_uimm8 idx)))
+  (x64_pinsrw vec val idx))
 
 ;; i32x4.replace_lane
-(rule 1 (vec_insert_lane $I32X4 vec val idx)
+(rule 1 (lower (insertlane _ vec @ (value_type $I32X4) val (u8_from_uimm8 idx)))
         (if-let $true (use_sse41))
         (x64_pinsrd vec val idx))
 
-(rule (vec_insert_lane $I32X4 vec val 0)
-      (x64_movss_regmove vec (x64_movd_to_xmm val)))
+(rule (lower (insertlane _ vec @ (value_type $I32X4) val (u8_from_uimm8 0)))
+  (x64_movss_regmove vec (x64_movd_to_xmm val)))
 
 ;; tmp    = [ vec[1] vec[0] val[1] val[0] ]
 ;; result = [ vec[3] vec[2] tmp[0] tmp[2] ]
-(rule (vec_insert_lane $I32X4 vec val 1)
+(rule (lower (insertlane _ vec @ (value_type $I32X4) val (u8_from_uimm8 1)))
       (let ((val Xmm (x64_movd_to_xmm val))
             (vec Xmm vec))
         (x64_shufps (x64_punpcklqdq val vec) vec 0b11_10_00_10)))
 
 ;; tmp    = [ vec[0] vec[3] val[0] val[0] ]
 ;; result = [ tmp[2] tmp[0] vec[1] vec[0] ]
-(rule (vec_insert_lane $I32X4 vec val 2)
+(rule (lower (insertlane _ vec @ (value_type $I32X4) val (u8_from_uimm8 2)))
       (let ((val Xmm (x64_movd_to_xmm val))
             (vec Xmm vec))
         (x64_shufps vec (x64_shufps val vec 0b00_11_00_00) 0b10_00_01_00)))
 
 ;; tmp    = [ vec[3] vec[2] val[1] val[0] ]
 ;; result = [ tmp[0] tmp[2] vec[1] vec[0] ]
-(rule (vec_insert_lane $I32X4 vec val 3)
+(rule (lower (insertlane _ vec @ (value_type $I32X4) val (u8_from_uimm8 3)))
       (let ((val Xmm (x64_movd_to_xmm val))
             (vec Xmm vec))
         (x64_shufps vec (x64_shufps val vec 0b11_10_01_00) 0b00_10_01_00)))
 
 ;; i64x2.replace_lane
-(rule 1 (vec_insert_lane $I64X2 vec val idx)
+(rule 1 (lower (insertlane _ vec @ (value_type $I64X2) val (u8_from_uimm8 idx)))
         (if-let $true (use_sse41))
         (x64_pinsrq vec val idx))
-(rule (vec_insert_lane $I64X2 vec val 0)
+(rule (lower (insertlane _ vec @ (value_type $I64X2) val (u8_from_uimm8 0)))
       (x64_movsd_regmove vec (x64_movq_to_xmm val)))
-(rule (vec_insert_lane $I64X2 vec val 1)
+(rule (lower (insertlane _ vec @ (value_type $I64X2) val (u8_from_uimm8 1)))
       (x64_punpcklqdq vec (x64_movq_to_xmm val)))
 
+;; (i64x2.replace_lane 1) with a splat as source for lane 0 -- we can elide
+;; the splat and just do a move. This turns out to be a common pattern when
+;; constructing an i64x2 out of two i64s.
+(rule 3 (lower (insertlane _ (has_type $I64X2 (splat _ lane0))
+                           lane1
+                           (u8_from_uimm8 1)))
+        (if-let $true (use_sse41))
+        (x64_pinsrq (bitcast_gpr_to_xmm 64 lane0) lane1 1))
+
+(rule 1 (lower (insertlane _ vec @ (value_type $F32X4) (sinkable_load val) (u8_from_uimm8 idx)))
+  (if-let $true (use_sse41))
+  (x64_insertps vec val (sse_insertps_lane_imm idx)))
+(rule (lower (insertlane _ vec @ (value_type $F32X4) val (u8_from_uimm8 idx)))
+  (f32x4_insertlane vec val idx))
+
+;; Helper function used below for `insertlane` but also here for other
+(decl f32x4_insertlane (Xmm Xmm u8) Xmm)
+
 ;; f32x4.replace_lane
-(rule 1 (vec_insert_lane $F32X4 vec val idx)
+(rule 1 (f32x4_insertlane vec val idx)
         (if-let $true (use_sse41))
         (x64_insertps vec val (sse_insertps_lane_imm idx)))
 
-;; f32x4.replace_lane 0 - without insertps
-(rule (vec_insert_lane $F32X4 vec (RegMem.Reg val) 0)
+;; External rust code used to calculate the immediate value to `insertps`.
+(decl sse_insertps_lane_imm (u8) u8)
+(extern constructor sse_insertps_lane_imm sse_insertps_lane_imm)
+
+;; f32x4.replace_lane 0
+(rule (f32x4_insertlane vec val 0)
       (x64_movss_regmove vec val))
 
-;; f32x4.replace_lane 1 - without insertps
+;; f32x4.replace_lane 1
 ;; tmp    = [ vec[1] vec[0] val[1] val[0] ]
 ;; result = [ vec[3] vec[2] tmp[0] tmp[2] ]
-(rule (vec_insert_lane $F32X4 vec (RegMem.Reg val) 1)
+(rule (f32x4_insertlane vec val 1)
       (let ((tmp Xmm (x64_movlhps val vec)))
         (x64_shufps tmp vec 0b11_10_00_10)))
 
-;; f32x4.replace_lane 2 - without insertps
+;; f32x4.replace_lane 2
 ;; tmp    = [ vec[0] vec[3] val[0] val[0] ]
 ;; result = [ tmp[2] tmp[0] vec[1] vec[0] ]
-(rule (vec_insert_lane $F32X4 vec (RegMem.Reg val) 2)
+(rule (f32x4_insertlane vec val 2)
       (let ((tmp Xmm (x64_shufps val vec 0b00_11_00_00)))
         (x64_shufps vec tmp 0b10_00_01_00)))
 
-;; f32x4.replace_lane 3 - without insertps
+;; f32x4.replace_lane 3
 ;; tmp    = [ vec[3] vec[2] val[1] val[0] ]
 ;; result = [ tmp[0] tmp[2] vec[1] vec[0] ]
-(rule (vec_insert_lane $F32X4 vec (RegMem.Reg val) 3)
+(rule (f32x4_insertlane vec val 3)
       (let ((tmp Xmm (x64_shufps val vec 0b11_10_01_00)))
         (x64_shufps vec tmp 0b00_10_01_00)))
 
-;; Recursively delegate to the above rules by loading from memory first.
-(rule (vec_insert_lane $F32X4 vec (RegMem.Mem addr) idx)
-      (vec_insert_lane $F32X4 vec (x64_movss_load addr) idx))
-
-;; External rust code used to calculate the immediate value to `insertps`.
-(decl sse_insertps_lane_imm (u8) u8)
-(extern constructor sse_insertps_lane_imm sse_insertps_lane_imm)
-
 ;; f64x2.replace_lane 0
 ;;
 ;; Here the `movsd` instruction is used specifically to specialize moving
 ;; into the fist lane where unlike above cases we're not using the lane
 ;; immediate as an immediate to the instruction itself.
-(rule (vec_insert_lane $F64X2 vec (RegMem.Reg val) 0)
+(rule (lower (insertlane _ vec @ (value_type $F64X2) val (u8_from_uimm8 0)))
       (x64_movsd_regmove vec val))
-(rule (vec_insert_lane $F64X2 vec (RegMem.Mem val) 0)
-      (x64_movsd_regmove vec (x64_movsd_load val)))
 
 ;; f64x2.replace_lane 1
 ;;
 ;; Here the `movlhps` instruction is used specifically to specialize moving
 ;; into the second lane where unlike above cases we're not using the lane
 ;; immediate as an immediate to the instruction itself.
-(rule (vec_insert_lane $F64X2 vec val 1)
+(rule (lower (insertlane _ vec @ (value_type $F64X2) val (u8_from_uimm8 1)))
       (x64_movlhps vec val))
 
 ;;;; Rules for `smin`, `smax`, `umin`, `umax` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -1617,6 +1706,7 @@
 ;; `i64` and smaller.
 
 (decl cmp_and_choose (Type CC Value Value) ValueRegs)
+(attr cmp_and_choose (veri chain))
 (rule (cmp_and_choose (fits_in_64 ty) cc x y)
       (let ((size OperandSize (raw_operand_size_of_type ty))
             ;; We need to put x and y in registers explicitly because
@@ -1625,19 +1715,19 @@
             ;; allow for load-op merging, here we cannot do that.
             (x_reg Reg x)
             (y_reg Reg y))
-        (with_flags_reg (x64_cmp size x_reg y_reg)
+        (with_flags_reg (x64_cmp size y_reg x_reg)
                         (cmove ty cc y_reg x_reg))))
 
-(rule -1 (lower (has_type (fits_in_64 ty) (umin x y)))
+(rule -1 (lower (has_type (fits_in_64 ty) (umin _ x y)))
       (cmp_and_choose ty (CC.B) x y))
 
-(rule -1 (lower (has_type (fits_in_64 ty) (umax x y)))
+(rule -1 (lower (has_type (fits_in_64 ty) (umax _ x y)))
       (cmp_and_choose ty (CC.NB) x y))
 
-(rule -1 (lower (has_type (fits_in_64 ty) (smin x y)))
+(rule -1 (lower (has_type (fits_in_64 ty) (smin _ x y)))
       (cmp_and_choose ty (CC.L) x y))
 
-(rule -1 (lower (has_type (fits_in_64 ty) (smax x y)))
+(rule -1 (lower (has_type (fits_in_64 ty) (smax _ x y)))
       (cmp_and_choose ty (CC.NL) x y))
 
 ;; SSE helpers for determining if single-instruction lowerings are available.
@@ -1664,7 +1754,7 @@
 
 ;; SSE `smax`.
 
-(rule (lower (has_type (ty_vec128 ty) (smax x y)))
+(rule (lower (has_type (ty_vec128 ty) (smax _ x y)))
       (lower_vec_smax ty x y))
 
 (decl lower_vec_smax (Type Xmm Xmm) Xmm)
@@ -1684,11 +1774,11 @@
 
 ;; SSE `smin`.
 
-(rule 1 (lower (has_type (ty_vec128 ty) (smin x y)))
+(rule 1 (lower (has_type (ty_vec128 ty) (smin _ x y)))
         (if-let $true (has_pmins ty))
         (x64_pmins ty x y))
 
-(rule (lower (has_type (ty_vec128 ty) (smin x y)))
+(rule (lower (has_type (ty_vec128 ty) (smin _ x y)))
       (let (
           (x Xmm x)
           (y Xmm y)
@@ -1700,20 +1790,20 @@
 
 ;; SSE `umax`.
 
-(rule 2 (lower (has_type (ty_vec128 ty) (umax x y)))
+(rule 2 (lower (has_type (ty_vec128 ty) (umax _ x y)))
         (if-let $true (has_pmaxu ty))
         (x64_pmaxu ty x y))
 
 ;; If y < x then the saturating subtraction will be zero, otherwise when added
 ;; back to x it'll return y.
-(rule 1 (lower (has_type $I16X8 (umax x y)))
+(rule 1 (lower (has_type $I16X8 (umax _ x y)))
         (let ((x Xmm x))
           (x64_paddw x (x64_psubusw y x))))
 
 ;; Flip the upper bits of each lane so the signed comparison has the same
 ;; result as a signed comparison, and then select the results with the output
 ;; mask. See `pcmpgt` lowering for info on flipping the upper bit.
-(rule (lower (has_type (ty_vec128 ty) (umax x y)))
+(rule (lower (has_type (ty_vec128 ty) (umax _ x y)))
       (let (
           (x Xmm x)
           (y Xmm y)
@@ -1736,18 +1826,18 @@
 
 ;; SSE `umin`.
 
-(rule 2 (lower (has_type (ty_vec128 ty) (umin x y)))
+(rule 2 (lower (has_type (ty_vec128 ty) (umin _ x y)))
         (if-let $true (has_pminu ty))
         (x64_pminu ty x y))
 
 ;; If x < y then the saturating subtraction will be 0. Otherwise if x > y then
 ;; the saturated result, when subtracted again, will go back to `y`.
-(rule 1 (lower (has_type $I16X8 (umin x y)))
+(rule 1 (lower (has_type $I16X8 (umin _ x y)))
         (let ((x Xmm x))
           (x64_psubw x (x64_psubusw x y))))
 
 ;; Same as `umax`, and see `pcmpgt` for docs on flipping the upper bit.
-(rule (lower (has_type (ty_vec128 ty) (umin x y)))
+(rule (lower (has_type (ty_vec128 ty) (umin _ x y)))
       (let (
           (x Xmm x)
           (y Xmm y)
@@ -1767,7 +1857,7 @@
 
 ;;;; Rules for `uadd_overflow_trap` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type (fits_in_64 ty) (uadd_overflow_trap a b tc)))
+(rule (lower (has_type (fits_in_64 ty) (uadd_overflow_trap _ a b tc)))
       (with_flags
         (x64_add_with_flags_paired ty a b)
         (trap_if (CC.B) tc)))
@@ -1776,22 +1866,17 @@
 ;; handling of above.
 
 (rule 1 (lower (has_type (fits_in_64 ty)
-                         (uadd_overflow_trap (simm32_from_value a) b tc)))
+                         (uadd_overflow_trap _ (simm32_from_value a) b tc)))
       (with_flags
         (x64_add_with_flags_paired ty b a)
         (trap_if (CC.B) tc)))
 
 (rule 2 (lower (has_type (fits_in_64 ty)
-                         (uadd_overflow_trap (sinkable_load a) b tc)))
+                         (uadd_overflow_trap _ (sinkable_load a) b tc)))
       (with_flags
         (x64_add_with_flags_paired ty b a)
         (trap_if (CC.B) tc)))
 
-;;;; Rules for `resumable_trap` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(rule (lower (resumable_trap code))
-      (side_effect (x64_ud2 code)))
-
 ;;;; Rules for `return` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; N.B.: the Ret itself is generated by the ABI.
@@ -1800,42 +1885,42 @@
 
 ;;;; Rules for `icmp` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule -2 (lower (icmp cc a @ (value_type (fits_in_64 ty)) b))
+(rule -2 (lower (icmp _ cc a @ (value_type (fits_in_64 ty)) b))
       (lower_icmp_bool (emit_cmp cc a b)))
 
-(rule -1 (lower (icmp cc a @ (value_type $I128) b))
+(rule -1 (lower (icmp _ cc a @ (value_type $I128) b))
       (lower_icmp_bool (emit_cmp cc a b)))
 
 ;; Peephole optimization for `x < 0`, when x is a signed 64 bit value
-(rule 2 (lower (has_type $I8 (icmp (IntCC.SignedLessThan) x @ (value_type $I64) (u64_from_iconst 0))))
+(rule 2 (lower (has_type $I8 (icmp _ (IntCC.SignedLessThan) x @ (value_type $I64) (u64_from_iconst 0))))
       (x64_shr $I64 x (Imm8Reg.Imm8 63)))
 
 ;; Peephole optimization for `0 > x`, when x is a signed 64 bit value
-(rule 2 (lower (has_type $I8 (icmp (IntCC.SignedGreaterThan) (u64_from_iconst 0) x @ (value_type $I64))))
+(rule 2 (lower (has_type $I8 (icmp _ (IntCC.SignedGreaterThan) (u64_from_iconst 0) x @ (value_type $I64))))
       (x64_shr $I64 x (Imm8Reg.Imm8 63)))
 
 ;; Peephole optimization for `0 <= x`, when x is a signed 64 bit value
-(rule 2 (lower (has_type $I8 (icmp (IntCC.SignedLessThanOrEqual) (u64_from_iconst 0) x @ (value_type $I64))))
+(rule 2 (lower (has_type $I8 (icmp _ (IntCC.SignedLessThanOrEqual) (u64_from_iconst 0) x @ (value_type $I64))))
       (x64_shr $I64 (x64_not $I64 x) (Imm8Reg.Imm8 63)))
 
 ;; Peephole optimization for `x >= 0`, when x is a signed 64 bit value
-(rule 2 (lower (has_type $I8 (icmp (IntCC.SignedGreaterThanOrEqual) x @ (value_type $I64) (u64_from_iconst 0))))
+(rule 2 (lower (has_type $I8 (icmp _ (IntCC.SignedGreaterThanOrEqual) x @ (value_type $I64) (u64_from_iconst 0))))
       (x64_shr $I64 (x64_not $I64 x) (Imm8Reg.Imm8 63)))
 
 ;; Peephole optimization for `x < 0`, when x is a signed 32 bit value
-(rule 2 (lower (has_type $I8 (icmp (IntCC.SignedLessThan) x @ (value_type $I32) (u64_from_iconst 0))))
+(rule 2 (lower (has_type $I8 (icmp _ (IntCC.SignedLessThan) x @ (value_type $I32) (u64_from_iconst 0))))
       (x64_shr $I32 x (Imm8Reg.Imm8 31)))
 
 ;; Peephole optimization for `0 > x`, when x is a signed 32 bit value
-(rule 2 (lower (has_type $I8 (icmp (IntCC.SignedGreaterThan) (u64_from_iconst 0) x @ (value_type $I32))))
+(rule 2 (lower (has_type $I8 (icmp _ (IntCC.SignedGreaterThan) (u64_from_iconst 0) x @ (value_type $I32))))
       (x64_shr $I32 x (Imm8Reg.Imm8 31)))
 
 ;; Peephole optimization for `0 <= x`, when x is a signed 32 bit value
-(rule 2 (lower (has_type $I8 (icmp (IntCC.SignedLessThanOrEqual) (u64_from_iconst 0) x @ (value_type $I32))))
+(rule 2 (lower (has_type $I8 (icmp _ (IntCC.SignedLessThanOrEqual) (u64_from_iconst 0) x @ (value_type $I32))))
       (x64_shr $I32 (x64_not $I64 x) (Imm8Reg.Imm8 31)))
 
 ;; Peephole optimization for `x >= 0`, when x is a signed 32 bit value
-(rule 2 (lower (has_type $I8 (icmp (IntCC.SignedGreaterThanOrEqual) x @ (value_type $I32) (u64_from_iconst 0))))
+(rule 2 (lower (has_type $I8 (icmp _ (IntCC.SignedGreaterThanOrEqual) x @ (value_type $I32) (u64_from_iconst 0))))
       (x64_shr $I32 (x64_not $I64 x) (Imm8Reg.Imm8 31)))
 
 ;; For XMM-held values, we lower to `PCMP*` instructions, sometimes more than
@@ -1843,31 +1928,31 @@
 ;; lane will be filled with all 1s or all 0s according to the comparison,
 ;; whereas for GPR-held values, the result will be simply 0 or 1 (upper bits
 ;; unset).
-(rule (lower (icmp (IntCC.Equal) a @ (value_type (ty_vec128 ty)) b))
+(rule (lower (icmp _ (IntCC.Equal) a @ (value_type (ty_vec128 ty)) b))
       (x64_pcmpeq ty a b))
 
 ;; To lower a not-equals comparison, we perform an equality comparison
 ;; (PCMPEQ*) and then invert the bits (PXOR with all 1s).
-(rule (lower (icmp (IntCC.NotEqual) a @ (value_type (ty_vec128 ty)) b))
+(rule (lower (icmp _ (IntCC.NotEqual) a @ (value_type (ty_vec128 ty)) b))
       (let ((checked Xmm (x64_pcmpeq ty a b))
             (all_ones Xmm (vector_all_ones)))
            (x64_pxor checked all_ones)))
 
 ;; SSE `sgt`
 
-(rule (lower (icmp (IntCC.SignedGreaterThan) a @ (value_type (ty_vec128 ty)) b))
+(rule (lower (icmp _ (IntCC.SignedGreaterThan) a @ (value_type (ty_vec128 ty)) b))
       (x64_pcmpgt ty a b))
 
 ;; SSE `slt`
 
-(rule (lower (icmp (IntCC.SignedLessThan) a @ (value_type (ty_vec128 ty)) b))
+(rule (lower (icmp _ (IntCC.SignedLessThan) a @ (value_type (ty_vec128 ty)) b))
       (x64_pcmpgt ty b a))
 
 ;; SSE `ugt`
 
 ;; N.B.: we must manually prevent load coalescing operands; the
 ;; register allocator gets confused otherwise.
-(rule 1 (lower (icmp (IntCC.UnsignedGreaterThan) a @ (value_type (ty_vec128 ty)) b))
+(rule 1 (lower (icmp _ (IntCC.UnsignedGreaterThan) a @ (value_type (ty_vec128 ty)) b))
         (if-let $true (has_pmaxu ty))
         (let ((a Xmm a)
               (b Xmm b)
@@ -1877,7 +1962,7 @@
 
 ;; Flip the upper bit of each lane so the result of a signed comparison is the
 ;; same as the result of an unsigned comparison (see docs on `pcmpgt` for more)
-(rule (lower (icmp (IntCC.UnsignedGreaterThan) a @ (value_type (ty_vec128 ty)) b))
+(rule (lower (icmp _ (IntCC.UnsignedGreaterThan) a @ (value_type (ty_vec128 ty)) b))
       (let ((mask Xmm (flip_high_bit_mask ty))
             (a_masked Xmm (x64_pxor a mask))
             (b_masked Xmm (x64_pxor b mask)))
@@ -1885,7 +1970,7 @@
 
 ;; SSE `ult`
 
-(rule 1 (lower (icmp (IntCC.UnsignedLessThan) a @ (value_type (ty_vec128 ty)) b))
+(rule 1 (lower (icmp _ (IntCC.UnsignedLessThan) a @ (value_type (ty_vec128 ty)) b))
         (if-let $true (has_pminu ty))
         ;; N.B.: see note above.
         (let ((a Xmm a)
@@ -1896,7 +1981,7 @@
 
 ;; Flip the upper bit of `a` and `b` so the signed comparison result will
 ;; be the same as the unsigned comparison result (see docs on `pcmpgt` for more).
-(rule (lower (icmp (IntCC.UnsignedLessThan) a @ (value_type (ty_vec128 ty)) b))
+(rule (lower (icmp _ (IntCC.UnsignedLessThan) a @ (value_type (ty_vec128 ty)) b))
       (let ((mask Xmm (flip_high_bit_mask ty))
             (a_masked Xmm (x64_pxor a mask))
             (b_masked Xmm (x64_pxor b mask)))
@@ -1905,41 +1990,41 @@
 ;; SSE `sge`
 
 ;; Use `pmaxs*` and compare the result to `a` to see if it's `>= b`.
-(rule 1 (lower (icmp (IntCC.SignedGreaterThanOrEqual) a @ (value_type (ty_vec128 ty)) b))
+(rule 1 (lower (icmp _ (IntCC.SignedGreaterThanOrEqual) a @ (value_type (ty_vec128 ty)) b))
         (if-let $true (has_pmaxs ty))
         (x64_pcmpeq ty a (x64_pmaxs ty a b)))
 
 ;; Without `pmaxs*` use a `pcmpgt*` with reversed operands and invert the
 ;; result.
-(rule (lower (icmp (IntCC.SignedGreaterThanOrEqual) a @ (value_type (ty_vec128 ty)) b))
+(rule (lower (icmp _ (IntCC.SignedGreaterThanOrEqual) a @ (value_type (ty_vec128 ty)) b))
       (x64_pxor (x64_pcmpgt ty b a) (vector_all_ones)))
 
 ;; SSE `sle`
 
 ;; With `pmins*` use that and compare the result to `a`.
-(rule 1 (lower (icmp (IntCC.SignedLessThanOrEqual) a @ (value_type (ty_vec128 ty)) b))
+(rule 1 (lower (icmp _ (IntCC.SignedLessThanOrEqual) a @ (value_type (ty_vec128 ty)) b))
         (if-let $true (has_pmins ty))
         (x64_pcmpeq ty a (x64_pmins ty a b)))
 
 ;; Without `pmins*` perform a greater-than test and invert the result.
-(rule (lower (icmp (IntCC.SignedLessThanOrEqual) a @ (value_type (ty_vec128 ty)) b))
+(rule (lower (icmp _ (IntCC.SignedLessThanOrEqual) a @ (value_type (ty_vec128 ty)) b))
       (x64_pxor (x64_pcmpgt ty a b) (vector_all_ones)))
 
 ;; SSE `uge`
 
-(rule 2 (lower (icmp (IntCC.UnsignedGreaterThanOrEqual) a @ (value_type (ty_vec128 ty)) b))
+(rule 2 (lower (icmp _ (IntCC.UnsignedGreaterThanOrEqual) a @ (value_type (ty_vec128 ty)) b))
         (if-let $true (has_pmaxu ty))
         (x64_pcmpeq ty a (x64_pmaxu ty a b)))
 
 ;; Perform a saturating subtract of `a` from `b` and if the result is zero then
 ;; `a` is greater or equal.
-(rule 1 (lower (icmp (IntCC.UnsignedGreaterThanOrEqual) a @ (value_type $I16X8) b))
+(rule 1 (lower (icmp _ (IntCC.UnsignedGreaterThanOrEqual) a @ (value_type $I16X8) b))
          (x64_pcmpeqw (x64_psubusw b a) (xmm_zero $I16X8)))
 
 ;; Flip the upper bit of each lane so the signed comparison is the same as
 ;; an unsigned one and then invert the result. See docs on `pcmpgt` for why
 ;; flipping the upper bit works.
-(rule (lower (icmp (IntCC.UnsignedGreaterThanOrEqual) a @ (value_type (ty_vec128 ty)) b))
+(rule (lower (icmp _ (IntCC.UnsignedGreaterThanOrEqual) a @ (value_type (ty_vec128 ty)) b))
       (let (
           (mask Xmm (flip_high_bit_mask ty))
           (a_masked Xmm (x64_pxor a mask))
@@ -1950,14 +2035,14 @@
 
 ;; SSE `ule`
 
-(rule 2 (lower (icmp (IntCC.UnsignedLessThanOrEqual) a @ (value_type (ty_vec128 ty)) b))
+(rule 2 (lower (icmp _ (IntCC.UnsignedLessThanOrEqual) a @ (value_type (ty_vec128 ty)) b))
         (if-let $true (has_pminu ty))
         (x64_pcmpeq ty a (x64_pminu ty a b)))
 
 ;; A saturating subtraction will produce zeros if `a` is less than `b`, so
 ;; compare that result to an all-zeros result to figure out lanes of `a` that
 ;; are <= to the lanes in `b`
-(rule 1 (lower (icmp (IntCC.UnsignedLessThanOrEqual) a @ (value_type $I16X8) b))
+(rule 1 (lower (icmp _ (IntCC.UnsignedLessThanOrEqual) a @ (value_type $I16X8) b))
         (let ((zeros_if_a_is_min Xmm (x64_psubusw a b)))
             (x64_pcmpeqw zeros_if_a_is_min (xmm_zero $I8X16))))
 
@@ -1965,7 +2050,7 @@
 ;; produces the same result as an unsigned comparison. Then test test for `gt`
 ;; and invert the result to get the `le` that is desired here. See docs on
 ;; `pcmpgt` for why flipping the upper bit works.
-(rule (lower (icmp (IntCC.UnsignedLessThanOrEqual) a @ (value_type (ty_vec128 ty)) b))
+(rule (lower (icmp _ (IntCC.UnsignedLessThanOrEqual) a @ (value_type (ty_vec128 ty)) b))
       (let (
           (mask Xmm (flip_high_bit_mask ty))
           (a_masked Xmm (x64_pxor a mask))
@@ -1993,40 +2078,40 @@
 ;;  - less than assigns    Z = 0, P = 0, C = 1
 ;;  - equal assigns        Z = 1, P = 0, C = 0
 
-(rule -1 (lower (fcmp cc a @ (value_type (ty_scalar_float ty)) b))
+(rule -1 (lower (fcmp _ cc a @ (value_type (ty_scalar_float ty)) b))
       (lower_fcmp_bool (emit_fcmp cc a b)))
 
 ;; For vector lowerings, we use `CMPP*` instructions with a 3-bit operand that
 ;; determines the comparison to make. Note that comparisons that succeed will
 ;; fill the lane with 1s; comparisons that do not will fill the lane with 0s.
 
-(rule (lower (fcmp (FloatCC.Equal) a @ (value_type (ty_vec128 ty)) b))
+(rule (lower (fcmp _ (FloatCC.Equal) a @ (value_type (ty_vec128 ty)) b))
       (x64_cmpp ty a b (FcmpImm.Equal)))
-(rule (lower (fcmp (FloatCC.NotEqual) a @ (value_type (ty_vec128 ty)) b))
+(rule (lower (fcmp _ (FloatCC.NotEqual) a @ (value_type (ty_vec128 ty)) b))
       (x64_cmpp ty a b (FcmpImm.NotEqual)))
-(rule (lower (fcmp (FloatCC.LessThan) a @ (value_type (ty_vec128 ty)) b))
+(rule (lower (fcmp _ (FloatCC.LessThan) a @ (value_type (ty_vec128 ty)) b))
       (x64_cmpp ty a b (FcmpImm.LessThan)))
-(rule (lower (fcmp (FloatCC.LessThanOrEqual) a @ (value_type (ty_vec128 ty)) b))
+(rule (lower (fcmp _ (FloatCC.LessThanOrEqual) a @ (value_type (ty_vec128 ty)) b))
       (x64_cmpp ty a b (FcmpImm.LessThanOrEqual)))
-(rule (lower (fcmp (FloatCC.Ordered) a @ (value_type (ty_vec128 ty)) b))
+(rule (lower (fcmp _ (FloatCC.Ordered) a @ (value_type (ty_vec128 ty)) b))
       (x64_cmpp ty a b (FcmpImm.Ordered)))
-(rule (lower (fcmp (FloatCC.Unordered) a @ (value_type (ty_vec128 ty)) b))
+(rule (lower (fcmp _ (FloatCC.Unordered) a @ (value_type (ty_vec128 ty)) b))
       (x64_cmpp ty a b (FcmpImm.Unordered)))
-(rule (lower (fcmp (FloatCC.UnorderedOrGreaterThan) a @ (value_type (ty_vec128 ty)) b))
+(rule (lower (fcmp _ (FloatCC.UnorderedOrGreaterThan) a @ (value_type (ty_vec128 ty)) b))
       (x64_cmpp ty a b (FcmpImm.UnorderedOrGreaterThan)))
-(rule (lower (fcmp (FloatCC.UnorderedOrGreaterThanOrEqual) a @ (value_type (ty_vec128 ty)) b))
+(rule (lower (fcmp _ (FloatCC.UnorderedOrGreaterThanOrEqual) a @ (value_type (ty_vec128 ty)) b))
       (x64_cmpp ty a b (FcmpImm.UnorderedOrGreaterThanOrEqual)))
 
 ;; Some vector lowerings rely on flipping the operands and using a reversed
 ;; comparison code.
 
-(rule (lower (fcmp (FloatCC.GreaterThan) a @ (value_type (ty_vec128 ty)) b))
+(rule (lower (fcmp _ (FloatCC.GreaterThan) a @ (value_type (ty_vec128 ty)) b))
       (x64_cmpp ty b a (FcmpImm.LessThan)))
-(rule (lower (fcmp (FloatCC.GreaterThanOrEqual) a @ (value_type (ty_vec128 ty)) b))
+(rule (lower (fcmp _ (FloatCC.GreaterThanOrEqual) a @ (value_type (ty_vec128 ty)) b))
       (x64_cmpp ty b a (FcmpImm.LessThanOrEqual)))
-(rule (lower (fcmp (FloatCC.UnorderedOrLessThan) a @ (value_type (ty_vec128 ty)) b))
+(rule (lower (fcmp _ (FloatCC.UnorderedOrLessThan) a @ (value_type (ty_vec128 ty)) b))
       (x64_cmpp ty b a (FcmpImm.UnorderedOrGreaterThan)))
-(rule (lower (fcmp (FloatCC.UnorderedOrLessThanOrEqual) a @ (value_type (ty_vec128 ty)) b))
+(rule (lower (fcmp _ (FloatCC.UnorderedOrLessThanOrEqual) a @ (value_type (ty_vec128 ty)) b))
       (x64_cmpp ty b a (FcmpImm.UnorderedOrGreaterThanOrEqual)))
 
 ;; Some vector lowerings are simply not supported for certain codes:
@@ -2044,9 +2129,9 @@
 ;; flipped around to be `select (fcmp ne ..) ..` with all operands reversed.
 ;; This will produce a `FcmpCondResult.OrCondition` which is easier to codegen
 ;; for.
-(rule (lower (has_type ty (select (maybe_uextend (fcmp cc a b)) x y)))
+(rule (lower (has_type ty (select _ (maybe_uextend (fcmp _ cc a b)) x y)))
       (lower_select_fcmp ty (emit_fcmp cc a b) x y))
-(rule 1 (lower (has_type ty (select (maybe_uextend (fcmp (FloatCC.Equal) a b)) x y)))
+(rule 1 (lower (has_type ty (select _ (maybe_uextend (fcmp _ (FloatCC.Equal) a b)) x y)))
         (lower_select_fcmp ty (emit_fcmp (FloatCC.NotEqual) a b) y x))
 
 (decl lower_select_fcmp (Type FcmpCondResult Value Value) InstOutput)
@@ -2060,119 +2145,125 @@
 ;; instruction plus a `CMOV`; recall that `cmove_from_values` here may emit more
 ;; than one instruction for certain types (e.g., XMM-held, I128).
 
-(rule (lower (has_type ty (select (maybe_uextend (icmp cc a @ (value_type (fits_in_64 a_ty)) b)) x y)))
-      (let ((size OperandSize (raw_operand_size_of_type a_ty)))
-           (with_flags (x64_cmp size b a) (cmove_from_values ty cc x y))))
+(rule (lower (has_type ty (select _ (maybe_uextend (icmp _ cc a @ (value_type (fits_in_64 a_ty)) b)) x y)))
+      (lower_select_icmp ty (emit_cmp cc a b) x y))
 
 ;; Finally, we lower `select` from a condition value `c`. These rules are meant
 ;; to be the final, default lowerings if no other patterns matched above.
 
-(rule -1 (lower (has_type ty (select c @ (value_type (fits_in_64 a_ty)) x y)))
+(rule -1 (lower (has_type ty (select _ c @ (value_type (fits_in_64 a_ty)) x y)))
       (let ((size OperandSize (raw_operand_size_of_type a_ty))
             ;; N.B.: disallow load-op fusion, see above. TODO:
             ;; https://github.com/bytecodealliance/wasmtime/issues/3953.
             (gpr_c Gpr (put_in_gpr c)))
            (with_flags (x64_test size gpr_c gpr_c) (cmove_from_values ty (CC.NZ) x y))))
 
-(rule -2 (lower (has_type ty (select c @ (value_type $I128) x y)))
+(rule -2 (lower (has_type ty (select _ c @ (value_type $I128) x y)))
       (let ((cond_result IcmpCondResult (cmp_zero_i128 (CC.Z) c)))
         (select_icmp cond_result x y)))
 
+(decl lower_select_icmp (Type IcmpCondResult Value Value) InstOutput)
+(attr lower_select_icmp (veri chain))
+(rule (lower_select_icmp ty (IcmpCondResult.Condition flags cc) x y)
+      (with_flags flags (cmove_from_values ty cc x y)))
+
 ;; Specializations for floating-point compares to generate a `mins*` or a
 ;; `maxs*` instruction. These are equivalent to the "pseudo-m{in,ax}"
 ;; specializations for vectors.
-(rule 2 (lower (has_type $F32 (select (maybe_uextend (fcmp (FloatCC.LessThan) x y)) x y)))
+(rule 2 (lower (has_type $F32 (select _ (maybe_uextend (fcmp _ (FloatCC.LessThan) x y)) x y)))
         (x64_minss x y))
-(rule 2 (lower (has_type $F64 (select (maybe_uextend (fcmp (FloatCC.LessThan) x y)) x y)))
+(rule 2 (lower (has_type $F64 (select _ (maybe_uextend (fcmp _ (FloatCC.LessThan) x y)) x y)))
         (x64_minsd x y))
-(rule 3 (lower (has_type $F32 (select (maybe_uextend (fcmp (FloatCC.LessThan) y x)) x y)))
+(rule 3 (lower (has_type $F32 (select _ (maybe_uextend (fcmp _ (FloatCC.LessThan) y x)) x y)))
         (x64_maxss x y))
-(rule 3 (lower (has_type $F64 (select (maybe_uextend (fcmp (FloatCC.LessThan) y x)) x y)))
+(rule 3 (lower (has_type $F64 (select _ (maybe_uextend (fcmp _ (FloatCC.LessThan) y x)) x y)))
         (x64_maxsd x y))
 
 ;; Rules for `clz` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; If available, we can use a plain lzcnt instruction here. Note no
-;; special handling is required for zero inputs, because the machine
-;; instruction does what the CLIF expects for zero, i.e. it returns
-;; zero.
-(rule 3 (lower (has_type (ty_32_or_64 ty) (clz src)))
-      (if-let $true (use_lzcnt))
-      (x64_lzcnt ty src))
-
-(rule 2 (lower (has_type (ty_32_or_64 ty) (clz src)))
+(rule 2 (lower (has_type (ty_32_or_64 ty) (clz _ src)))
       (do_clz ty ty src))
 
-(rule 1 (lower
-       (has_type (ty_8_or_16 ty)
-                 (clz src)))
-      (do_clz $I32 ty (extend_to_gpr src $I32 (ExtendKind.Zero))))
+(rule 1 (lower (has_type (ty_8_or_16 ty) (clz _ src)))
+      (let ((extended Gpr (extend_to_gpr src $I64 (ExtendKind.Zero)))
+            (clz Gpr (do_clz $I64 $I64 extended)))
+        (x64_sub $I64 clz (RegMemImm.Imm (u32_sub 64 (ty_bits ty))))))
+
 
 (rule 0 (lower
        (has_type $I128
-                 (clz src)))
+                 (clz _ src)))
       (let ((upper Gpr (do_clz $I64 $I64 (value_regs_get_gpr src 1)))
             (lower Gpr (x64_add $I64
                             (do_clz $I64 $I64 (value_regs_get_gpr src 0))
                             (RegMemImm.Imm 64)))
             (result_lo Gpr
               (with_flags_reg
-               (x64_cmp_imm (OperandSize.Size64) 64 upper)
+               (x64_cmp_imm (OperandSize.Size64) upper 64)
                (cmove $I64 (CC.NZ) upper lower))))
         (value_regs result_lo (imm $I64 0))))
 
 ;; Implementation helper for clz; operates on 32 or 64-bit units.
 (decl do_clz (Type Type Gpr) Gpr)
-(rule (do_clz ty orig_ty src)
+
+;; If available, we can use a plain lzcnt instruction here. Note no
+;; special handling is required for zero inputs, because the machine
+;; instruction does what the CLIF expects for zero, i.e. it returns
+;; zero.
+(rule 1 (do_clz ty orig_ty src)
+      (if-let $true (use_lzcnt))
+      (x64_lzcnt ty src))
+
+(rule 0 (do_clz ty orig_ty src)
       (let ((highest_bit_index Reg (bsr_or_else ty src (imm_i64 $I64 -1)))
             (bits_minus_1 Reg (imm ty (u64_sub (ty_bits_u64 orig_ty) 1))))
         (x64_sub ty bits_minus_1 highest_bit_index)))
 
 ;; Rules for `ctz` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-;; Analogous to `clz` cases above, but using mirror instructions
-;; (tzcnt vs lzcnt, bsf vs bsr).
-
-(rule 3 (lower (has_type (ty_32_or_64 ty) (ctz src)))
-      (if-let $true (use_bmi1))
-      (x64_tzcnt ty src))
-
-(rule 2 (lower (has_type (ty_32_or_64 ty) (ctz src)))
+(rule 2 (lower (has_type (ty_32_or_64 ty) (ctz _ src)))
       (do_ctz ty ty src))
 
-(rule 1 (lower
-       (has_type (ty_8_or_16 ty)
-                 (ctz src)))
-      (do_ctz $I32 ty (extend_to_gpr src $I32 (ExtendKind.Zero))))
+(rule 1 (lower (has_type (ty_8_or_16 ty) (ctz _ src)))
+      (let ((extended Gpr (extend_to_gpr src $I32 (ExtendKind.Zero)))
+            (stopbit Gpr (x64_or $I32 extended (RegMemImm.Imm (u32_shl 1 (ty_bits ty))))))
+        (do_ctz $I32 ty stopbit)))
 
 (rule 0 (lower
        (has_type $I128
-                 (ctz src)))
+                 (ctz _ src)))
       (let ((lower Gpr (do_ctz $I64 $I64 (value_regs_get_gpr src 0)))
             (upper Gpr (x64_add $I64
                             (do_ctz $I64 $I64 (value_regs_get_gpr src 1))
                             (RegMemImm.Imm 64)))
             (result_lo Gpr
               (with_flags_reg
-               (x64_cmp_imm (OperandSize.Size64) 64 lower)
+               (x64_cmp_imm (OperandSize.Size64) lower 64)
                (cmove $I64 (CC.Z) upper lower))))
         (value_regs result_lo (imm $I64 0))))
 
 (decl do_ctz (Type Type Gpr) Gpr)
-(rule (do_ctz ty orig_ty src)
+
+;; Analogous to `clz` cases above, but using mirror instructions
+;; (tzcnt vs lzcnt, bsf vs bsr).
+(rule 1 (do_ctz ty orig_ty src)
+      (if-let $true (use_bmi1))
+      (x64_tzcnt ty src))
+
+(rule 0 (do_ctz ty orig_ty src)
       (bsf_or_else ty src (imm $I64 (ty_bits_u64 orig_ty))))
 
 ;; Rules for `popcnt` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 4 (lower (has_type (ty_32_or_64 ty) (popcnt src)))
+(rule 4 (lower (has_type (ty_32_or_64 ty) (popcnt _ src)))
       (if-let $true (use_popcnt))
       (x64_popcnt ty src))
 
-(rule 3 (lower (has_type (ty_8_or_16 ty) (popcnt src)))
+(rule 3 (lower (has_type (ty_8_or_16 ty) (popcnt _ src)))
       (if-let $true (use_popcnt))
       (x64_popcnt $I32 (extend_to_gpr src $I32 (ExtendKind.Zero))))
 
-(rule 1 (lower (has_type $I128 (popcnt src)))
+(rule 1 (lower (has_type $I128 (popcnt _ src)))
       (if-let $true (use_popcnt))
       (let ((lo_count Gpr (x64_popcnt $I64 (value_regs_get_gpr src 0)))
             (hi_count Gpr (x64_popcnt $I64 (value_regs_get_gpr src 1))))
@@ -2180,17 +2271,17 @@
 
 (rule -1 (lower
        (has_type (ty_32_or_64 ty)
-                 (popcnt src)))
+                 (popcnt _ src)))
       (do_popcnt ty src))
 
 (rule -2 (lower
        (has_type (ty_8_or_16 ty)
-                 (popcnt src)))
+                 (popcnt _ src)))
       (do_popcnt $I32 (extend_to_gpr src $I32 (ExtendKind.Zero))))
 
 (rule (lower
        (has_type $I128
-                 (popcnt src)))
+                 (popcnt _ src)))
       (let ((lo_count Gpr (do_popcnt $I64 (value_regs_get_gpr src 0)))
             (hi_count Gpr (do_popcnt $I64 (value_regs_get_gpr src 1))))
         (value_regs (x64_add $I64 lo_count hi_count) (imm $I64 0))))
@@ -2234,7 +2325,7 @@
             ;; top byte: it is the sum of the bytes (masked4 >> 56) *
             ;; 0x01 + (masked4 >> 48) * 0x01 + (masked4 >> 40) * 0x01
             ;; + ... + (masked4 >> 0).
-            (mul Gpr (x64_mul $I64 masked4 ones))
+            (mul Gpr (x64_imul $I64 masked4 ones))
             ;; Now take that top byte and return it as the popcount.
             (final Gpr (x64_shr $I64 mul (Imm8Reg.Imm8 56))))
         final))
@@ -2256,12 +2347,12 @@
                            (x64_shr $I32 diff3 (Imm8Reg.Imm8 4))
                            diff3))
             (masked4 Gpr (x64_and $I32 sum1 (RegMemImm.Imm 0x0f0f0f0f)))
-            (mul Gpr (x64_mul $I32 masked4 (RegMemImm.Imm 0x01010101)))
+            (mul Gpr (x64_imul_imm $I32 masked4 0x01010101))
             (final Gpr (x64_shr $I32 mul (Imm8Reg.Imm8 24))))
         final))
 
 
-(rule 2 (lower (has_type $I8X16 (popcnt src)))
+(rule 2 (lower (has_type $I8X16 (popcnt _ src)))
       (if-let $true (use_avx512vl))
       (if-let $true (use_avx512bitalg))
       (x64_vpopcntb src))
@@ -2287,7 +2378,7 @@
 ;; __m128i lookup = _mm_setr_epi8(0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4);
 
 
-(rule 1 (lower (has_type $I8X16 (popcnt src)))
+(rule 1 (lower (has_type $I8X16 (popcnt _ src)))
       (if-let $true (use_ssse3))
       (let ((low_mask XmmMem (emit_u128_le_const 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f))
             (low_nibbles Xmm (sse_and $I8X16 src low_mask))
@@ -2303,7 +2394,7 @@
         (x64_paddb bit_counts_low bit_counts_high)))
 
 ;; A modified version of the popcnt method from Hacker's Delight.
-(rule (lower (has_type $I8X16 (popcnt src)))
+(rule (lower (has_type $I8X16 (popcnt _ src)))
       (let ((mask1 XmmMem (emit_u128_le_const 0x77777777777777777777777777777777))
             (src Xmm src)
             (shifted Xmm (x64_pand (x64_psrlq src (xmi_imm 1)) mask1))
@@ -2317,19 +2408,19 @@
 
 ;; Rules for `bitrev` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type $I8 (bitrev src)))
+(rule (lower (has_type $I8 (bitrev _ src)))
       (do_bitrev8 $I32 src))
 
-(rule (lower (has_type $I16 (bitrev src)))
+(rule (lower (has_type $I16 (bitrev _ src)))
       (do_bitrev16 $I32 src))
 
-(rule (lower (has_type $I32 (bitrev src)))
+(rule (lower (has_type $I32 (bitrev _ src)))
       (do_bitrev32 $I32 src))
 
-(rule (lower (has_type $I64 (bitrev src)))
+(rule (lower (has_type $I64 (bitrev _ src)))
       (do_bitrev64 $I64 src))
 
-(rule (lower (has_type $I128 (bitrev src)))
+(rule (lower (has_type $I128 (bitrev _ src)))
       (value_regs
        (do_bitrev64 $I64 (value_regs_get_gpr src 1))
        (do_bitrev64 $I64 (value_regs_get_gpr src 0))))
@@ -2382,6 +2473,7 @@
         swap16))
 
 (decl do_bitrev64 (Type Gpr) Gpr)
+(attr do_bitrev64 (veri chain))
 (rule (do_bitrev64 ty @ $I64 src)
       (let ((src_ Gpr (do_bitrev32 ty src))
             (mask32 Gpr (imm ty 0xffffffff))
@@ -2396,50 +2488,33 @@
 
 ;; x64 bswap instruction is only for 32- or 64-bit swaps
 ;; implement the 16-bit swap as a rotl by 8
-(rule (lower (has_type $I16 (bswap src)))
+(rule (lower (has_type $I16 (bswap _ src)))
       (x64_rotl $I16 src (Imm8Reg.Imm8 8)))
 
-(rule (lower (has_type $I32 (bswap src)))
+(rule (lower (has_type $I32 (bswap _ src)))
       (x64_bswap $I32 src))
 
-(rule (lower (has_type $I64 (bswap src)))
+(rule (lower (has_type $I64 (bswap _ src)))
       (x64_bswap $I64 src))
 
-(rule (lower (has_type $I128 (bswap src)))
+(rule (lower (has_type $I128 (bswap _ src)))
       (value_regs
        (x64_bswap $I64 (value_regs_get_gpr src 1))
        (x64_bswap $I64 (value_regs_get_gpr src 0))))
 
-;; Rules for `is_null` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-;; Null references are represented by the constant value `0`.
-(rule (lower (is_null src @ (value_type $R64)))
-      (with_flags
-       (x64_cmp_imm (OperandSize.Size64) 0 src)
-       (x64_setcc (CC.Z))))
-
-;; Rules for `is_invalid` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-;; Invalid references are represented by the constant value `-1`.
-(rule (lower (is_invalid src @ (value_type $R64)))
-      (with_flags
-       (x64_cmp_imm (OperandSize.Size64) 0xffffffff src)  ;; simm32 0xffff_ffff is sign-extended to -1.
-       (x64_setcc (CC.Z))))
-
-
 ;; Rules for `uextend` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; I{8,16,32,64} -> I128.
-(rule (lower (has_type $I128 (uextend src)))
+(rule (lower (has_type $I128 (uextend _ src)))
       (value_regs (extend_to_gpr src $I64 (ExtendKind.Zero)) (imm $I64 0)))
 
 ;; I{8,16,32} -> I64.
-(rule (lower (has_type $I64 (uextend src)))
+(rule (lower (has_type $I64 (uextend _ src)))
       (extend_to_gpr src $I64 (ExtendKind.Zero)))
 
 ;; I{8,16} -> I32
 ;; I8 -> I16
-(rule -1 (lower (has_type (fits_in_32 _) (uextend src)))
+(rule -1 (lower (has_type (fits_in_32 _) (uextend _ src)))
          (extend_to_gpr src $I32 (ExtendKind.Zero)))
 
 ;; Rules for `sextend` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -2448,30 +2523,30 @@
 ;;
 ;; Produce upper 64 bits sign-extended from lower 64: shift right by
 ;; 63 bits to spread the sign bit across the result.
-(rule (lower (has_type $I128 (sextend src)))
+(rule (lower (has_type $I128 (sextend _ src)))
       (let ((lo Gpr (extend_to_gpr src $I64 (ExtendKind.Sign)))
             (hi Gpr (x64_sar $I64 lo (Imm8Reg.Imm8 63))))
       (value_regs lo hi)))
 
 ;; I{8,16,32} -> I64.
-(rule (lower (has_type $I64 (sextend src)))
+(rule (lower (has_type $I64 (sextend _ src)))
       (extend_to_gpr src $I64 (ExtendKind.Sign)))
 
 ;; I{8,16} -> I32
 ;; I8 -> I16
-(rule -1 (lower (has_type (fits_in_32 _) (sextend src)))
+(rule -1 (lower (has_type (fits_in_32 _) (sextend _ src)))
          (extend_to_gpr src $I32 (ExtendKind.Sign)))
 
 ;; Rules for `ireduce` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; T -> T is always a no-op, even I128 -> I128.
-(rule (lower (has_type ty (ireduce src @ (value_type ty))))
+(rule (lower (has_type ty (ireduce _ src @ (value_type ty))))
       src)
 
 ;; T -> I{64,32,16,8}: We can simply pass through the value: values
 ;; are always stored with high bits undefined, so we can just leave
 ;; them be.
-(rule 1 (lower (has_type (fits_in_64 ty) (ireduce src)))
+(rule 1 (lower (has_type (fits_in_64 ty) (ireduce _ src)))
       (value_regs_get_gpr src 0))
 
 ;; Rules for `debugtrap` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -2481,107 +2556,107 @@
 
 ;; Rules for `x86_pmaddubsw` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type $I16X8 (x86_pmaddubsw x y)))
+(rule (lower (has_type $I16X8 (x86_pmaddubsw _ x y)))
       (if-let $true (use_ssse3))
       (x64_pmaddubsw y x))
 
 ;; Rules for `fadd` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type $F32 (fadd x y)))
+(rule (lower (has_type $F32 (fadd _ x y)))
       (x64_addss x y))
-(rule (lower (has_type $F64 (fadd x y)))
+(rule (lower (has_type $F64 (fadd _ x y)))
       (x64_addsd x y))
-(rule (lower (has_type $F32X4 (fadd x y)))
+(rule (lower (has_type $F32X4 (fadd _ x y)))
       (x64_addps x y))
-(rule (lower (has_type $F64X2 (fadd x y)))
+(rule (lower (has_type $F64X2 (fadd _ x y)))
       (x64_addpd x y))
 
 ;; The above rules automatically sink loads for rhs operands, so additionally
 ;; add rules for sinking loads with lhs operands.
-(rule 1 (lower (has_type $F32 (fadd (sinkable_load x) y)))
+(rule 1 (lower (has_type $F32 (fadd _ (sinkable_load x) y)))
       (x64_addss y x))
-(rule 1 (lower (has_type $F64 (fadd (sinkable_load x) y)))
+(rule 1 (lower (has_type $F64 (fadd _ (sinkable_load x) y)))
       (x64_addsd y x))
-(rule 1 (lower (has_type $F32X4 (fadd (sinkable_load x) y)))
+(rule 1 (lower (has_type $F32X4 (fadd _ (sinkable_load x) y)))
       (x64_addps y x))
-(rule 1 (lower (has_type $F64X2 (fadd (sinkable_load x) y)))
+(rule 1 (lower (has_type $F64X2 (fadd _ (sinkable_load x) y)))
       (x64_addpd y x))
 
 ;; Rules for `fsub` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type $F32 (fsub x y)))
+(rule (lower (has_type $F32 (fsub _ x y)))
       (x64_subss x y))
-(rule (lower (has_type $F64 (fsub x y)))
+(rule (lower (has_type $F64 (fsub _ x y)))
       (x64_subsd x y))
-(rule (lower (has_type $F32X4 (fsub x y)))
+(rule (lower (has_type $F32X4 (fsub _ x y)))
       (x64_subps x y))
-(rule (lower (has_type $F64X2 (fsub x y)))
+(rule (lower (has_type $F64X2 (fsub _ x y)))
       (x64_subpd x y))
 
 ;; Rules for `fmul` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type $F32 (fmul x y)))
+(rule (lower (has_type $F32 (fmul _ x y)))
       (x64_mulss x y))
-(rule (lower (has_type $F64 (fmul x y)))
+(rule (lower (has_type $F64 (fmul _ x y)))
       (x64_mulsd x y))
-(rule (lower (has_type $F32X4 (fmul x y)))
+(rule (lower (has_type $F32X4 (fmul _ x y)))
       (x64_mulps x y))
-(rule (lower (has_type $F64X2 (fmul x y)))
+(rule (lower (has_type $F64X2 (fmul _ x y)))
       (x64_mulpd x y))
 
 ;; The above rules automatically sink loads for rhs operands, so additionally
 ;; add rules for sinking loads with lhs operands.
-(rule 1 (lower (has_type $F32 (fmul (sinkable_load x) y)))
+(rule 1 (lower (has_type $F32 (fmul _ (sinkable_load x) y)))
       (x64_mulss y x))
-(rule 1 (lower (has_type $F64 (fmul (sinkable_load x) y)))
+(rule 1 (lower (has_type $F64 (fmul _ (sinkable_load x) y)))
       (x64_mulsd y x))
-(rule 1 (lower (has_type $F32X4 (fmul (sinkable_load x) y)))
+(rule 1 (lower (has_type $F32X4 (fmul _ (sinkable_load x) y)))
       (x64_mulps y x))
-(rule 1 (lower (has_type $F64X2 (fmul (sinkable_load x) y)))
+(rule 1 (lower (has_type $F64X2 (fmul _ (sinkable_load x) y)))
       (x64_mulpd y x))
 
 ;; Rules for `fdiv` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type $F32 (fdiv x y)))
+(rule (lower (has_type $F32 (fdiv _ x y)))
       (x64_divss x y))
-(rule (lower (has_type $F64 (fdiv x y)))
+(rule (lower (has_type $F64 (fdiv _ x y)))
       (x64_divsd x y))
-(rule (lower (has_type $F32X4 (fdiv x y)))
+(rule (lower (has_type $F32X4 (fdiv _ x y)))
       (x64_divps x y))
-(rule (lower (has_type $F64X2 (fdiv x y)))
+(rule (lower (has_type $F64X2 (fdiv _ x y)))
       (x64_divpd x y))
 
 ;; Rules for `sqrt` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule (lower (has_type $F32 (sqrt x)))
-      (x64_sqrtss x))
-(rule (lower (has_type $F64 (sqrt x)))
-      (x64_sqrtsd x))
-(rule (lower (has_type $F32X4 (sqrt x)))
+(rule (lower (has_type $F32 (sqrt _ x)))
+      (x64_sqrtss (xmm_zero $F32X4) x))
+(rule (lower (has_type $F64 (sqrt _ x)))
+      (x64_sqrtsd (xmm_zero $F64X2) x))
+(rule (lower (has_type $F32X4 (sqrt _ x)))
       (x64_sqrtps x))
-(rule (lower (has_type $F64X2 (sqrt x)))
+(rule (lower (has_type $F64X2 (sqrt _ x)))
       (x64_sqrtpd x))
 
 ;; Rules for `fpromote` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule (lower (has_type $F64 (fpromote x)))
-      (x64_cvtss2sd x))
+(rule (lower (has_type $F64 (fpromote _ x)))
+      (x64_cvtss2sd (xmm_zero $F64X2) x))
 
 ;; Rules for `fvpromote` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule (lower (has_type $F64X2 (fvpromote_low x)))
+(rule (lower (has_type $F64X2 (fvpromote_low _ x)))
       (x64_cvtps2pd (put_in_xmm x)))
 
 ;; Rules for `fdemote` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule (lower (has_type $F32 (fdemote x)))
-      (x64_cvtsd2ss x))
+(rule (lower (has_type $F32 (fdemote _ x)))
+      (x64_cvtsd2ss (xmm_zero $F32X4) x))
 
 ;; Rules for `fvdemote` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(rule (lower (has_type $F32X4 (fvdemote x)))
+(rule (lower (has_type $F32X4 (fvdemote _ x)))
       (x64_cvtpd2ps x))
 
 ;; Rules for `fmin` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type $F32 (fmin x y)))
+(rule (lower (has_type $F32 (fmin _ x y)))
       (xmm_min_max_seq $F32 $true x y))
-(rule (lower (has_type $F64 (fmin x y)))
+(rule (lower (has_type $F64 (fmin _ x y)))
       (xmm_min_max_seq $F64 $true x y))
 
 ;; Vector-typed version. We don't use single pseudoinstructions as
@@ -2596,13 +2671,15 @@
 ;; require that fmin(NaN, _) = fmin(_, NaN) = NaN, and fmin(+0, -0) =
 ;; fmin(-0, +0) = -0.
 
-(rule (lower (has_type $F32X4 (fmin x y)))
+(rule (lower (has_type $F32X4 (fmin _ x y)))
       ;; Compute min(x, y) and min(y, x) with native
       ;; instructions. These will differ in one of the edge cases
       ;; above that we have to handle properly. (Conversely, if they
       ;; don't differ, then the native instruction's answer is the
       ;; right one per CLIF semantics.)
-      (let ((min1 Xmm (x64_minps x y))
+      (let ((x Xmm x) ;; force x/y into registers and disallow load sinking
+            (y Xmm y)
+            (min1 Xmm (x64_minps x y))
             (min2 Xmm (x64_minps y x))
             ;; Compute the OR of the two. Note that NaNs have an
             ;; exponent field of all-ones (0xFF for F32), so if either
@@ -2639,8 +2716,10 @@
 
 ;; Likewise for F64 lanes, except that the right-shift is by 13 bits
 ;; (1 sign, 11 exponent, 1 QNaN bit).
-(rule (lower (has_type $F64X2 (fmin x y)))
-      (let ((min1 Xmm (x64_minpd x y))
+(rule (lower (has_type $F64X2 (fmin _ x y)))
+      (let ((x Xmm x) ;; force x/y into registers and disallow load sinking
+            (y Xmm y)
+            (min1 Xmm (x64_minpd x y))
             (min2 Xmm (x64_minpd y x))
             (min_or Xmm (x64_orpd min1 min2))
             (is_nan_mask Xmm (x64_cmppd min1 min2 (FcmpImm.Unordered)))
@@ -2651,21 +2730,23 @@
 
 ;; Rules for `fmax` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type $F32 (fmax x y)))
+(rule (lower (has_type $F32 (fmax _ x y)))
       (xmm_min_max_seq $F32 $false x y))
-(rule (lower (has_type $F64 (fmax x y)))
+(rule (lower (has_type $F64 (fmax _ x y)))
       (xmm_min_max_seq $F64 $false x y))
 
 ;; The vector version of fmax here is a dual to the fmin sequence
 ;; above, almost, with a few differences.
 
-(rule (lower (has_type $F32X4 (fmax x y)))
+(rule (lower (has_type $F32X4 (fmax _ x y)))
       ;; Compute max(x, y) and max(y, x) with native
       ;; instructions. These will differ in one of the edge cases
       ;; above that we have to handle properly. (Conversely, if they
       ;; don't differ, then the native instruction's answer is the
       ;; right one per CLIF semantics.)
-      (let ((max1 Xmm (x64_maxps x y))
+      (let ((x Xmm x) ;; force x/y into registers and disallow load sinking
+            (y Xmm y)
+            (max1 Xmm (x64_maxps x y))
             (max2 Xmm (x64_maxps y x))
             ;; Compute the XOR of the two maxima. In the case
             ;; where we don't have a +/-0 mismatch or NaNs, then
@@ -2702,13 +2783,15 @@
             (final Xmm (x64_andnps nan_fraction_mask max_blended_nan_positive)))
         final))
 
-(rule (lower (has_type $F64X2 (fmax x y)))
+(rule (lower (has_type $F64X2 (fmax _ x y)))
       ;; Compute max(x, y) and max(y, x) with native
       ;; instructions. These will differ in one of the edge cases
       ;; above that we have to handle properly. (Conversely, if they
       ;; don't differ, then the native instruction's answer is the
       ;; right one per CLIF semantics.)
-      (let ((max1 Xmm (x64_maxpd x y))
+      (let ((x Xmm x) ;; force x/y into registers and disallow load sinking
+            (y Xmm y)
+            (max1 Xmm (x64_maxpd x y))
             (max2 Xmm (x64_maxpd y x))
             ;; Compute the XOR of the two maxima. In the case
             ;; where we don't have a +/-0 mismatch or NaNs, then
@@ -2751,12 +2834,12 @@
 ;; Base case for fma is to call out to one of two libcalls. For vectors they
 ;; need to be decomposed, handle each element individually, and then recomposed.
 
-(rule (lower (has_type $F32 (fma x y z)))
+(rule (lower (has_type $F32 (fma _ x y z)))
       (libcall_3 (LibCall.FmaF32) x y z))
-(rule (lower (has_type $F64 (fma x y z)))
+(rule (lower (has_type $F64 (fma _ x y z)))
       (libcall_3 (LibCall.FmaF64) x y z))
 
-(rule (lower (has_type $F32X4 (fma x y z)))
+(rule (lower (has_type $F32X4 (fma _ x y z)))
       (let (
           (x Xmm (put_in_xmm x))
           (y Xmm (put_in_xmm y))
@@ -2775,12 +2858,12 @@
             (x64_pshufd y 3)
             (x64_pshufd z 3)))
 
-          (tmp Xmm (vec_insert_lane $F32X4 x0 x1 1))
-          (tmp Xmm (vec_insert_lane $F32X4 tmp x2 2))
-          (tmp Xmm (vec_insert_lane $F32X4 tmp x3 3))
+          (tmp Xmm (f32x4_insertlane x0 x1 1))
+          (tmp Xmm (f32x4_insertlane tmp x2 2))
+          (tmp Xmm (f32x4_insertlane tmp x3 3))
         )
         tmp))
-(rule (lower (has_type $F64X2 (fma x y z)))
+(rule (lower (has_type $F64X2 (fma _ x y z)))
       (let (
           (x Xmm (put_in_xmm x))
           (y Xmm (put_in_xmm y))
@@ -2791,12 +2874,12 @@
             (x64_pshufd y 0xee)
             (x64_pshufd z 0xee)))
         )
-        (vec_insert_lane $F64X2 x0 x1 1)))
+        (x64_movlhps x0 x1)))
 
 
 ;; Special case for when the `fma` feature is active and a native instruction
 ;; can be used.
-(rule 1 (lower (has_type ty (fma x y z)))
+(rule 1 (lower (has_type ty (fma _ x y z)))
       (if-let $true (use_fma))
       (fmadd ty x y z))
 
@@ -2815,16 +2898,48 @@
 
 ;; If one of the values being multiplied is negated then use a `vfnmadd*`
 ;; instruction instead
-(rule 3 (fmadd ty (fneg x) y z) (fnmadd ty x y z))
-(rule 4 (fmadd ty x (fneg y) z) (fnmadd ty x y z))
+(rule 3 (fmadd ty (fneg _ x) y z) (fnmadd ty x y z))
+(rule 4 (fmadd ty x (fneg _ y) z) (fnmadd ty x y z))
 
 (rule (fnmadd ty x y z) (x64_vfnmadd213 ty x y z))
 (rule 1 (fnmadd ty (sinkable_load x) y z) (x64_vfnmadd132 ty y z x))
 (rule 2 (fnmadd ty x (sinkable_load y) z) (x64_vfnmadd132 ty x z y))
 
 ;; Like `fmadd` if one argument is negated switch which one is being codegen'd
-(rule 3 (fnmadd ty (fneg x) y z) (fmadd ty x y z))
-(rule 4 (fnmadd ty x (fneg y) z) (fmadd ty x y z))
+(rule 3 (fnmadd ty (fneg _ x) y z) (fmadd ty x y z))
+(rule 4 (fnmadd ty x (fneg _ y) z) (fmadd ty x y z))
+
+
+(rule 2 (lower (has_type ty (fma _ x y (fneg _ z))))
+      (if-let $true (use_fma))
+      (fmsub ty x y z))
+
+;; fmsub and fnmsub
+(decl fmsub (Type Value Value Value) Xmm)
+(decl fnmsub (Type Value Value Value) Xmm)
+
+;; Base case, will sink a load of `z` automatically.
+(rule (fmsub ty x y z) (x64_vfmsub213 ty x y z))
+
+;; Allow sinking loads with one of the two values being multiplied in addition
+;; to the value being subtracted. Note that both x and y can be sunk here due to
+;; multiplication being commutative.
+(rule 1 (fmsub ty (sinkable_load x) y z) (x64_vfmsub132 ty y z x))
+(rule 2 (fmsub ty x (sinkable_load y) z) (x64_vfmsub132 ty x z y))
+
+;; If one of the values being multiplied is negated then use a `vfnmsub*`
+;; instruction instead
+(rule 3 (fmsub ty (fneg _ x) y z) (fnmsub ty x y z))
+(rule 4 (fmsub ty x (fneg _ y) z) (fnmsub ty x y z))
+
+(rule (fnmsub ty x y z) (x64_vfnmsub213 ty x y z))
+(rule 1 (fnmsub ty (sinkable_load x) y z) (x64_vfnmsub132 ty y z x))
+(rule 2 (fnmsub ty x (sinkable_load y) z) (x64_vfnmsub132 ty x z y))
+
+;; Like `fmsub` if one argument is negated switch which one is being codegen'd
+(rule 3 (fnmsub ty (fneg _ x) y z) (fmsub ty x y z))
+(rule 4 (fnmsub ty x (fneg _ y) z) (fmsub ty x y z))
+
 
 ;; Rules for `load*` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
@@ -2834,46 +2949,50 @@
 ;; 8-bit loads.
 ;;
 ;; By default, we zero-extend all sub-64-bit loads to a GPR.
-(rule -4 (lower (has_type (and (fits_in_32 ty) (is_gpr_type _)) (load flags address offset)))
+(rule load_narrow -4 (lower (has_type (and (fits_in_32 ty) (is_gpr_type _)) (load _ flags address offset)))
       (x64_movzx (ext_mode (ty_bits_u16 ty) 64) (to_amode flags address offset)))
 ;; But if we know that both the `from` and `to` are 64 bits, we simply load with
 ;; no extension.
-(rule -1 (lower (has_type (ty_int_ref_64 ty) (load flags address offset)))
+(rule -1 (lower (has_type (ty_int_ref_64 ty) (load _ flags address offset)))
       (x64_mov (to_amode flags address offset)))
 ;; Also, certain scalar loads have a specific `from` width and extension kind
 ;; (signed -> `sx`, zeroed -> `zx`). We overwrite the high bits of the 64-bit
 ;; GPR even if the `to` type is smaller (e.g., 16-bits).
-(rule (lower (has_type (is_gpr_type ty) (uload8 flags address offset)))
+(rule (lower (has_type (is_gpr_type ty) (uload8 _ flags address offset)))
       (x64_movzx (ExtMode.BQ) (to_amode flags address offset)))
-(rule (lower (has_type (is_gpr_type ty) (sload8 flags address offset)))
+(rule (lower (has_type (is_gpr_type ty) (sload8 _ flags address offset)))
       (x64_movsx (ExtMode.BQ) (to_amode flags address offset)))
-(rule (lower (has_type (is_gpr_type ty) (uload16 flags address offset)))
+(rule (lower (has_type (is_gpr_type ty) (uload16 _ flags address offset)))
       (x64_movzx (ExtMode.WQ) (to_amode flags address offset)))
-(rule (lower (has_type (is_gpr_type ty) (sload16 flags address offset)))
+(rule (lower (has_type (is_gpr_type ty) (sload16 _ flags address offset)))
       (x64_movsx (ExtMode.WQ) (to_amode flags address offset)))
-(rule (lower (has_type (is_gpr_type ty) (uload32 flags address offset)))
+(rule (lower (has_type (is_gpr_type ty) (uload32 _ flags address offset)))
       (x64_movzx (ExtMode.LQ) (to_amode flags address offset)))
-(rule (lower (has_type (is_gpr_type ty) (sload32 flags address offset)))
+(rule (lower (has_type (is_gpr_type ty) (sload32 _ flags address offset)))
       (x64_movsx (ExtMode.LQ) (to_amode flags address offset)))
 
 ;; To load to XMM registers, we use the x64-specific instructions for each type.
 ;; For `$F32` and `$F64` this is important--we only want to load 32 or 64 bits.
 ;; But for the 128-bit types, this is not strictly necessary for performance but
 ;; might help with clarity during disassembly.
-(rule (lower (has_type $F32 (load flags address offset)))
+(rule (lower (has_type $F16 (load _ flags address offset)))
+      (x64_pinsrw (xmm_uninit_value) (to_amode flags address offset) 0))
+(rule (lower (has_type $F32 (load _ flags address offset)))
       (x64_movss_load (to_amode flags address offset)))
-(rule (lower (has_type $F64 (load flags address offset)))
+(rule (lower (has_type $F64 (load _ flags address offset)))
       (x64_movsd_load (to_amode flags address offset)))
-(rule (lower (has_type $F32X4 (load flags address offset)))
+(rule (lower (has_type $F128 (load _ flags address offset)))
+      (x64_movdqu_load (to_amode flags address offset)))
+(rule (lower (has_type $F32X4 (load _ flags address offset)))
       (x64_movups_load (to_amode flags address offset)))
-(rule (lower (has_type $F64X2 (load flags address offset)))
+(rule (lower (has_type $F64X2 (load _ flags address offset)))
       (x64_movupd_load (to_amode flags address offset)))
-(rule -2 (lower (has_type (ty_vec128 ty) (load flags address offset)))
+(rule -2 (lower (has_type (ty_vec128 ty) (load _ flags address offset)))
       (x64_movdqu_load (to_amode flags address offset)))
 
 ;; We can load an I128 by doing two 64-bit loads.
 (rule -3 (lower (has_type $I128
-                       (load flags address offset)))
+                       (load _ flags address offset)))
       (let ((addr_lo Amode (to_amode flags address offset))
             (addr_hi Amode (amode_offset addr_lo 8))
             (value_lo Reg (x64_mov addr_lo))
@@ -2882,42 +3001,42 @@
 
 ;; We also include widening vector loads; these sign- or zero-extend each lane
 ;; to the next wider width (e.g., 16x4 -> 32x4).
-(rule 1 (lower (has_type $I16X8 (sload8x8 flags address offset)))
+(rule 1 (lower (has_type $I16X8 (sload8x8 _ flags address offset)))
         (if-let $true (use_sse41))
         (x64_pmovsxbw (to_amode flags address offset)))
-(rule 1 (lower (has_type $I16X8 (uload8x8 flags address offset)))
+(rule 1 (lower (has_type $I16X8 (uload8x8 _ flags address offset)))
         (if-let $true (use_sse41))
         (x64_pmovzxbw (to_amode flags address offset)))
-(rule 1 (lower (has_type $I32X4 (sload16x4 flags address offset)))
+(rule 1 (lower (has_type $I32X4 (sload16x4 _ flags address offset)))
         (if-let $true (use_sse41))
         (x64_pmovsxwd (to_amode flags address offset)))
-(rule 1 (lower (has_type $I32X4 (uload16x4 flags address offset)))
+(rule 1 (lower (has_type $I32X4 (uload16x4 _ flags address offset)))
         (if-let $true (use_sse41))
         (x64_pmovzxwd (to_amode flags address offset)))
-(rule 1 (lower (has_type $I64X2 (sload32x2 flags address offset)))
+(rule 1 (lower (has_type $I64X2 (sload32x2 _ flags address offset)))
         (if-let $true (use_sse41))
         (x64_pmovsxdq (to_amode flags address offset)))
-(rule 1 (lower (has_type $I64X2 (uload32x2 flags address offset)))
+(rule 1 (lower (has_type $I64X2 (uload32x2 _ flags address offset)))
         (if-let $true (use_sse41))
         (x64_pmovzxdq (to_amode flags address offset)))
 
-(rule (lower (has_type $I16X8 (sload8x8 flags address offset)))
+(rule (lower (has_type $I16X8 (sload8x8 _ flags address offset)))
       (lower_swiden_low $I16X8 (x64_movq_to_xmm (to_amode flags address offset))))
-(rule (lower (has_type $I16X8 (uload8x8 flags address offset)))
+(rule (lower (has_type $I16X8 (uload8x8 _ flags address offset)))
       (lower_uwiden_low $I16X8 (x64_movq_to_xmm (to_amode flags address offset))))
-(rule (lower (has_type $I32X4 (sload16x4 flags address offset)))
+(rule (lower (has_type $I32X4 (sload16x4 _ flags address offset)))
       (lower_swiden_low $I32X4 (x64_movq_to_xmm (to_amode flags address offset))))
-(rule (lower (has_type $I32X4 (uload16x4 flags address offset)))
+(rule (lower (has_type $I32X4 (uload16x4 _ flags address offset)))
       (lower_uwiden_low $I32X4 (x64_movq_to_xmm (to_amode flags address offset))))
-(rule (lower (has_type $I64X2 (sload32x2 flags address offset)))
+(rule (lower (has_type $I64X2 (sload32x2 _ flags address offset)))
       (lower_swiden_low $I64X2 (x64_movq_to_xmm (to_amode flags address offset))))
-(rule (lower (has_type $I64X2 (uload32x2 flags address offset)))
+(rule (lower (has_type $I64X2 (uload32x2 _ flags address offset)))
       (lower_uwiden_low $I64X2 (x64_movq_to_xmm (to_amode flags address offset))))
 
 ;; Rules for `store*` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; 8-, 16-, 32- and 64-bit GPR stores.
-(rule -2 (lower (store flags
+(rule store_narrow -2 (lower (store flags
                     value @ (value_type (is_gpr_type ty))
                     address
                     offset))
@@ -2936,9 +3055,26 @@
        (x64_movrm $I32 (to_amode flags address offset) value)))
 
 ;; IMM stores
-(rule 2 (lower (store flags (has_type (fits_in_64 ty) (iconst (simm32 value))) address offset))
+(rule 4 (lower (store flags value @ (value_type (fits_in_64 ty)) address offset))
+      (if-let (i32_from_iconst imm) value)
+      (side_effect
+       (x64_movimm_m ty (to_amode flags address offset) imm)))
+
+;; F16 stores of values in XMM registers.
+(rule 0 (lower (store flags
+                    value @ (value_type $F16)
+                    address
+                    offset))
+      (side_effect
+       (x64_movrm $I16 (to_amode flags address offset) (bitcast_xmm_to_gpr 16 value))))
+
+(rule 1 (lower (store flags
+                    value @ (value_type $F16)
+                    address
+                    offset))
+      (if-let $true (use_sse41))
       (side_effect
-       (x64_movimm_m ty (to_amode flags address offset) value)))
+       (x64_pextrw_store (to_amode flags address offset) value 0)))
 
 ;; F32 stores of values in XMM registers.
 (rule 1 (lower (store flags
@@ -2956,6 +3092,14 @@
       (side_effect
        (x64_movsd_store (to_amode flags address offset) value)))
 
+;; F128 stores of values in XMM registers.
+(rule 1 (lower (store flags
+                    value @ (value_type $F128)
+                    address
+                    offset))
+      (side_effect
+       (x64_movdqu_store (to_amode flags address offset) value)))
+
 ;; Stores of F32X4 vectors.
 (rule 1 (lower (store flags
                     value @ (value_type $F32X4)
@@ -3001,40 +3145,40 @@
 ;; f32 or f64 despite the source perhaps being an integer vector since the
 ;; result of the instruction is the same.
 (rule 2 (lower (store flags
-                    (has_type $F32 (extractlane value (u8_from_uimm8 0)))
+                    (has_type $F32 (extractlane _ value (u8_from_uimm8 0)))
                     address
                     offset))
       (side_effect
        (x64_movss_store (to_amode flags address offset) value)))
 (rule 2 (lower (store flags
-                    (has_type $F64 (extractlane value (u8_from_uimm8 0)))
+                    (has_type $F64 (extractlane _ value (u8_from_uimm8 0)))
                     address
                     offset))
       (side_effect
        (x64_movsd_store (to_amode flags address offset) value)))
 (rule 2 (lower (store flags
-                    (has_type $I8 (extractlane value (u8_from_uimm8 n)))
+                    (has_type $I8 (extractlane _ value (u8_from_uimm8 n)))
                     address
                     offset))
       (if-let $true (use_sse41))
       (side_effect
        (x64_pextrb_store (to_amode flags address offset) value n)))
 (rule 2 (lower (store flags
-                    (has_type $I16 (extractlane value (u8_from_uimm8 n)))
+                    (has_type $I16 (extractlane _ value (u8_from_uimm8 n)))
                     address
                     offset))
       (if-let $true (use_sse41))
       (side_effect
        (x64_pextrw_store (to_amode flags address offset) value n)))
 (rule 2 (lower (store flags
-                    (has_type $I32 (extractlane value (u8_from_uimm8 n)))
+                    (has_type $I32 (extractlane _ value (u8_from_uimm8 n)))
                     address
                     offset))
       (if-let $true (use_sse41))
       (side_effect
        (x64_pextrd_store (to_amode flags address offset) value n)))
 (rule 2 (lower (store flags
-                    (has_type $I64 (extractlane value (u8_from_uimm8 n)))
+                    (has_type $I64 (extractlane _ value (u8_from_uimm8 n)))
                     address
                     offset))
       (if-let $true (use_sse41))
@@ -3047,9 +3191,9 @@
 (rule 3 (lower
        (store flags
               (has_type (ty_32_or_64 ty)
-                        (iadd (and
+                        (iadd _ (and
                                (sinkable_load sink)
-                               (load flags addr offset))
+                               (load _ flags addr offset))
                               src2))
               addr
               offset))
@@ -3061,10 +3205,10 @@
 (rule 2 (lower
        (store flags
               (has_type (ty_32_or_64 ty)
-                        (iadd src2
+                        (iadd _ src2
                               (and
                                (sinkable_load sink)
-                               (load flags addr offset))))
+                               (load _ flags addr offset))))
               addr
               offset))
       (let ((_ RegMemImm sink))
@@ -3075,9 +3219,9 @@
 (rule 2 (lower
        (store flags
               (has_type (ty_32_or_64 ty)
-                        (isub (and
+                        (isub _ (and
                                (sinkable_load sink)
-                               (load flags addr offset))
+                               (load _ flags addr offset))
                               src2))
               addr
               offset))
@@ -3089,9 +3233,9 @@
 (rule 3 (lower
        (store flags
               (has_type (ty_32_or_64 ty)
-                        (band (and
+                        (band _ (and
                                (sinkable_load sink)
-                               (load flags addr offset))
+                               (load _ flags addr offset))
                               src2))
               addr
               offset))
@@ -3103,10 +3247,10 @@
 (rule 2 (lower
        (store flags
               (has_type (ty_32_or_64 ty)
-                        (band src2
+                        (band _ src2
                               (and
                                (sinkable_load sink)
-                               (load flags addr offset))))
+                               (load _ flags addr offset))))
               addr
               offset))
       (let ((_ RegMemImm sink))
@@ -3117,9 +3261,9 @@
 (rule 3 (lower
        (store flags
               (has_type (ty_32_or_64 ty)
-                        (bor (and
+                        (bor _ (and
                                (sinkable_load sink)
-                               (load flags addr offset))
+                               (load _ flags addr offset))
                               src2))
               addr
               offset))
@@ -3131,10 +3275,10 @@
 (rule 2 (lower
        (store flags
               (has_type (ty_32_or_64 ty)
-                        (bor src2
+                        (bor _ src2
                               (and
                                (sinkable_load sink)
-                               (load flags addr offset))))
+                               (load _ flags addr offset))))
               addr
               offset))
       (let ((_ RegMemImm sink))
@@ -3142,12 +3286,12 @@
          (x64_or_mem ty (to_amode flags addr offset) src2))))
 
 ;; Xor mem, reg
-(rule 3 (lower
+(rule Xor_mem_reg 3 (lower
        (store flags
               (has_type (ty_32_or_64 ty)
-                        (bxor (and
+                        (bxor _ (and
                                (sinkable_load sink)
-                               (load flags addr offset))
+                               (load _ flags addr offset))
                               src2))
               addr
               offset))
@@ -3159,10 +3303,10 @@
 (rule 2 (lower
        (store flags
               (has_type (ty_32_or_64 ty)
-                        (bxor src2
+                        (bxor _ src2
                               (and
                                (sinkable_load sink)
-                               (load flags addr offset))))
+                               (load _ flags addr offset))))
               addr
               offset))
       (let ((_ RegMemImm sink))
@@ -3176,12 +3320,12 @@
 
 ;; Rules for `func_addr` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (func_addr (func_ref_data _ extname dist)))
+(rule (lower (func_addr _ (func_ref_data _ extname dist)))
       (load_ext_name extname 0 dist))
 
 ;; Rules for `symbol_value` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (symbol_value (symbol_value_data extname dist offset)))
+(rule (lower (symbol_value _ (symbol_value_data extname dist offset)))
       (load_ext_name extname offset dist))
 
 ;; Rules for `atomic_load` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -3193,9 +3337,9 @@
 ;; As described in the `atomic_load` documentation, this lowering is only valid
 ;; for I8, I16, I32, and I64. The sub-64-bit types are zero extended, as with a
 ;; normal load.
-(rule 1 (lower (has_type $I64 (atomic_load flags address)))
+(rule 1 (lower (has_type $I64 (atomic_load _ flags address)))
       (x64_mov (to_amode flags address (zero_offset))))
-(rule (lower (has_type (and (fits_in_32 ty) (ty_int _)) (atomic_load flags address)))
+(rule (lower (has_type (and (fits_in_32 ty) (ty_int _)) (atomic_load _ flags address)))
       (x64_movzx (ext_mode (ty_bits_u16 ty) 64) (to_amode flags address (zero_offset))))
 
 ;; Rules for `atomic_store` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -3213,7 +3357,7 @@
 ;; Rules for `atomic_cas` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (rule (lower (has_type (and (fits_in_64 ty) (ty_int _))
-                  (atomic_cas flags address expected replacement)))
+                  (atomic_cas _ flags address expected replacement)))
       (x64_cmpxchg ty expected replacement (to_amode flags address (zero_offset))))
 
 ;; Rules for `atomic_rmw` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -3229,7 +3373,7 @@
 ;; https://github.com/bytecodealliance/wasmtime/issues/2153.
 
 (rule (lower (has_type (and (fits_in_64 ty) (ty_int _))
-                  (atomic_rmw flags op address input)))
+                  (atomic_rmw _ flags op address input)))
       (x64_atomic_rmw_seq ty op (to_amode flags address (zero_offset)) input))
 
 ;; Rules for `call` and `call_indirect` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -3248,15 +3392,25 @@
 (rule (lower (return_call_indirect sig_ref callee args))
       (gen_return_call_indirect sig_ref callee args))
 
+;; Rules for `stack_switch` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; currently, only the Basic model is supported
+(rule (lower (stack_switch _ store_context_ptr load_context_ptr in_payload0))
+      (if-let (StackSwitchModel.Basic) (stack_switch_model))
+      (let ((store_context_ptr Gpr (put_in_gpr store_context_ptr))
+            (load_context_ptr Gpr (put_in_gpr load_context_ptr))
+            (in_payload0 Gpr (put_in_gpr in_payload0)))
+        (x64_stack_switch_basic store_context_ptr load_context_ptr in_payload0)))
+
 ;;;; Rules for `get_{frame,stack}_pointer` and `get_return_address` ;;;;;;;;;;;;
 
-(rule (lower (get_frame_pointer))
+(rule (lower (get_frame_pointer _))
       (x64_rbp))
 
-(rule (lower (get_stack_pointer))
+(rule (lower (get_stack_pointer _))
       (x64_rsp))
 
-(rule (lower (get_return_address))
+(rule (lower (get_return_address _))
       (x64_load $I64
                 (Amode.ImmReg 8 (x64_rbp) (mem_flags_trusted))
                 (ExtKind.None)))
@@ -3268,12 +3422,18 @@
 
 ;; Rules for `brif` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 2 (lower_branch (brif (maybe_uextend (icmp cc a b)) _ _) (two_targets then else))
+(rule 2 (lower_branch (brif (maybe_uextend (icmp _ cc a b)) _ _) (two_targets then else))
         (emit_side_effect (jmp_cond_icmp (emit_cmp cc a b) then else)))
 
-(rule 2 (lower_branch (brif (maybe_uextend (fcmp cc a b)) _ _) (two_targets then else))
+(rule 2 (lower_branch (brif (maybe_uextend (fcmp _ cc a b)) _ _) (two_targets then else))
         (emit_side_effect (jmp_cond_fcmp (emit_fcmp cc a b) then else)))
 
+(rule 2 (lower_branch (brif (maybe_uextend (vany_true _ a)) _ _) (two_targets then else))
+        (emit_side_effect (jmp_cond_icmp (emit_vany_true a) then else)))
+
+(rule 2 (lower_branch (brif (maybe_uextend (vall_true _ a)) _ _) (two_targets then else))
+        (emit_side_effect (jmp_cond_icmp (emit_vall_true a) then else)))
+
 (rule 1 (lower_branch (brif val @ (value_type $I128) _ _)
                       (two_targets then else))
       (emit_side_effect (jmp_cond_icmp (cmp_zero_i128 (CC.Z) val) then else)))
@@ -3286,20 +3446,19 @@
 
 
 ;; Compare an I128 value to zero, returning a flags result suitable for making a
-;; jump decision. The comparison is implemented as `(hi == 0) && (low == 0)`,
+;; jump decision. The comparison is implemented as `(hi | low) == 0`,
 ;; and the result can be interpreted as follows
 ;; * CC.Z indicates that the value was non-zero, as one or both of the halves of
 ;;   the value were non-zero
 ;; * CC.NZ indicates that both halves of the value were 0
 (decl cmp_zero_i128 (CC ValueRegs) IcmpCondResult)
+(attr cmp_zero_i128 (veri chain))
 (rule (cmp_zero_i128 (cc_nz_or_z cc) val)
       (let ((lo Gpr (value_regs_get_gpr val 0))
-            (hi Gpr (value_regs_get_gpr val 1))
-            (lo_z Gpr (with_flags_reg (x64_cmp (OperandSize.Size64) (RegMemImm.Imm 0) lo)
-                                      (x64_setcc (CC.Z))))
-            (hi_z Gpr (with_flags_reg (x64_cmp (OperandSize.Size64) (RegMemImm.Imm 0) hi)
-                                      (x64_setcc (CC.Z)))))
-          (icmp_cond_result (x64_test (OperandSize.Size8) lo_z hi_z) cc)))
+            (hi Gpr (value_regs_get_gpr val 1)))
+          (icmp_cond_result
+            (x64_alurmi_flags_side_effect (AluRmiROpcode.Or) $I64 lo hi)
+            (cc_invert cc))))
 
 
 (decl cmp_zero_int_bool_ref (Value) ProducesFlags)
@@ -3316,21 +3475,21 @@
             (size_reg Reg (imm ty (u32_as_u64 jt_size)))
             (idx_reg Gpr (extend_to_gpr idx $I64 (ExtendKind.Zero)))
             (clamped_idx Reg (with_flags_reg
-              (x64_cmp size size_reg idx_reg)
+              (x64_cmp size idx_reg size_reg)
               (cmove ty (CC.B) idx_reg size_reg))))
       (emit_side_effect (jmp_table_seq ty clamped_idx default_target jt_targets))))
 
 ;; Rules for `select_spectre_guard` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (select_spectre_guard (icmp cc a b) x y))
+(rule (lower (select_spectre_guard _ (icmp _ cc a b) x y))
       (select_icmp (emit_cmp cc a b) x y))
 
-(rule -1 (lower (has_type ty (select_spectre_guard c @ (value_type (fits_in_64 a_ty)) x y)))
+(rule -1 (lower (has_type ty (select_spectre_guard _ c @ (value_type (fits_in_64 a_ty)) x y)))
       (let ((size OperandSize (raw_operand_size_of_type a_ty))
             (gpr_c Gpr (put_in_gpr c)))
         (with_flags (x64_test size gpr_c gpr_c) (cmove_from_values ty (CC.NZ) x y))))
 
-(rule -2 (lower (has_type ty (select_spectre_guard c @ (value_type $I128) x y)))
+(rule -2 (lower (has_type ty (select_spectre_guard _ c @ (value_type $I128) x y)))
       (let ((cond_result IcmpCondResult (cmp_zero_i128 (CC.Z) c)))
         (select_icmp cond_result x y)))
 
@@ -3353,46 +3512,97 @@
 ;; `fcvt_from_sint` to an x86-specific opcode using a zero constant which would
 ;; be subject to normal LICM, but that's not feasible today.
 
-(rule 2 (lower (has_type $F32 (fcvt_from_sint a @ (value_type $I8))))
+(rule 2 (lower (has_type $F32 (fcvt_from_sint _ a @ (value_type $I8))))
       (x64_cvtsi2ss $I32 (xmm_zero $F32X4) (extend_to_gpr a $I32 (ExtendKind.Sign))))
 
-(rule 2 (lower (has_type $F32 (fcvt_from_sint a @ (value_type $I16))))
+(rule 2 (lower (has_type $F32 (fcvt_from_sint _ a @ (value_type $I16))))
       (x64_cvtsi2ss $I32 (xmm_zero $F32X4) (extend_to_gpr a $I32 (ExtendKind.Sign))))
 
-(rule 1 (lower (has_type $F32 (fcvt_from_sint a @ (value_type (ty_int (fits_in_64 ty))))))
+(rule 1 (lower (has_type $F32 (fcvt_from_sint _ a @ (value_type (ty_int (fits_in_64 ty))))))
       (x64_cvtsi2ss ty (xmm_zero $F32X4) a))
 
-(rule 2 (lower (has_type $F64 (fcvt_from_sint a @ (value_type $I8))))
+(rule 2 (lower (has_type $F64 (fcvt_from_sint _ a @ (value_type $I8))))
       (x64_cvtsi2sd $I32 (xmm_zero $F64X2) (extend_to_gpr a $I32 (ExtendKind.Sign))))
 
-(rule 2 (lower (has_type $F64 (fcvt_from_sint a @ (value_type $I16))))
+(rule 2 (lower (has_type $F64 (fcvt_from_sint _ a @ (value_type $I16))))
       (x64_cvtsi2sd $I32 (xmm_zero $F64X2) (extend_to_gpr a $I32 (ExtendKind.Sign))))
 
-(rule 1 (lower (has_type $F64 (fcvt_from_sint a @ (value_type (ty_int (fits_in_64 ty))))))
+(rule 1 (lower (has_type $F64 (fcvt_from_sint _ a @ (value_type (ty_int (fits_in_64 ty))))))
       (x64_cvtsi2sd ty (xmm_zero $F64X2) a))
 
-(rule 0 (lower (fcvt_from_sint a @ (value_type $I32X4)))
+(rule 0 (lower (fcvt_from_sint _ a @ (value_type $I32X4)))
       (x64_cvtdq2ps a))
 
-(rule 1 (lower (has_type $F64X2 (fcvt_from_sint (swiden_low a @ (value_type $I32X4)))))
+;; Base case: decompose the i64x2 input into two scalar registers and convert
+;; each of those into a float. Afterwards re-pack the two results into the final
+;; destination.
+(rule 0 (lower (fcvt_from_sint _ a @ (value_type $I64X2)))
+      (let (
+          (a Xmm a)
+          (zero Xmm (xmm_zero $F64X2))
+          (f0 Xmm (x64_cvtsi2sd $I64 zero (x64_movq_to_gpr a)))
+          (f1 Xmm (x64_cvtsi2sd $I64 zero (x64_movq_to_gpr (x64_pshufd a 0b11_10_11_10))))
+        )
+        (x64_unpcklpd f0 f1)))
+
+(rule 1 (lower (has_type $F64X2 (fcvt_from_sint _ (swiden_low _ a @ (value_type $I32X4)))))
       (x64_cvtdq2pd a))
 
 ;; Rules for `fcvt_from_uint` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 1 (lower (has_type $F32 (fcvt_from_uint val @ (value_type (fits_in_32 (ty_int ty))))))
+(rule 1 (lower (has_type $F32 (fcvt_from_uint _ val @ (value_type (fits_in_32 (ty_int ty))))))
       (x64_cvtsi2ss $I64 (xmm_zero $F32X4) (extend_to_gpr val $I64 (ExtendKind.Zero))))
 
-(rule 1 (lower (has_type $F64 (fcvt_from_uint val @ (value_type (fits_in_32 (ty_int ty))))))
+(rule 1 (lower (has_type $F64 (fcvt_from_uint _ val @ (value_type (fits_in_32 (ty_int ty))))))
       (x64_cvtsi2sd $I64 (xmm_zero $F64X2) (extend_to_gpr val $I64 (ExtendKind.Zero))))
 
-(rule (lower (has_type ty (fcvt_from_uint val @ (value_type $I64))))
+(rule (lower (has_type ty (fcvt_from_uint _ val @ (value_type $I64))))
       (cvt_u64_to_float_seq ty val))
 
+;; Base case of u64x2 being converted to f64x2. No native instruction for this
+;; is available so it's emulated through a series of instructions that exploit
+;; the binary representation of 64-bit floats. This sequence of instructions is
+;; copied from LLVM and my understanding of the general idea is to roughly:
+;;
+;; * For each bullet below operate in parallel on the left and right lanes.
+;; * Move the low 32 bits of the input into one register and the upper
+;;   32-bits into a different register, where both have all 0s for the upper
+;;   32-bits. (e.g. split the 64-bit input into two locations)
+;; * For the low bits, create `1.<twenty-zeros><low32>p52` via bit tricks.
+;; * For the high bits, create `1.<twenty-zeros><high32>p84` via bit tricks.
+;; * Create the constant `1.0p84 + 1.0p52`
+;; * Add the two high halves and subtract the constant.
+;;
+;; Apply some math and this should produce the same result as the native
+;; conversion.
+;;
+;; As for the bit tricks a float is represented where the low 53 bits are the
+;; decimal of the float, basically:
+;;
+;;  f = 1.<fraction> ^ (<exponent> - 1023)
+;;
+;; where `<fraction>` is the low 53 bits. By placing the 32-bit halves from
+;; the original integer into the low 53 bits and setting the exponent right it
+;; means that each 32-bit half can become part of a 64-bit floating point
+;; number. The final step in combining via float arithmetic will chop off the
+;; leading `1.` at the start of the float that we constructed, one for the low
+;; half and one for the upper half.
+(rule -1 (lower (has_type $F64X2 (fcvt_from_uint _ val @ (value_type $I64X2))))
+  (let ((low32_mask XmmMem (emit_u128_le_const 0x00000000ffffffff_00000000ffffffff))
+        (float_1p52 XmmMem (emit_u128_le_const 0x4330000000000000_4330000000000000))
+        (float_1p84 XmmMem (emit_u128_le_const 0x4530000000000000_4530000000000000))
+        (float_1p84_plus_1p52 XmmMem (emit_u128_le_const 0x4530000000100000_4530000000100000))
+        (low32 Xmm (x64_pand val low32_mask))
+        (low32_as_float Xmm (x64_por low32 float_1p52))
+        (high32 Xmm (x64_psrlq val (xmi_imm 32)))
+        (high32_as_float Xmm (x64_por high32 float_1p84)))
+    (x64_addpd low32_as_float (x64_subpd high32_as_float float_1p84_plus_1p52))))
+
 ;; Algorithm uses unpcklps to help create a float that is equivalent
 ;; 0x1.0p52 + double(src). 0x1.0p52 is unique because at this exponent
 ;; every value of the mantissa represents a corresponding uint32 number.
 ;; When we subtract 0x1.0p52 we are left with double(src).
-(rule 1 (lower (has_type $F64X2 (fcvt_from_uint (uwiden_low val @ (value_type $I32X4)))))
+(rule 1 (lower (has_type $F64X2 (fcvt_from_uint _ (uwiden_low _ val @ (value_type $I32X4)))))
       (let ((uint_mask XmmMem (emit_u128_le_const 0x43300000_43300000))
             (res Xmm (x64_unpcklps val uint_mask))
             (uint_mask_high XmmMem (emit_u128_le_const 0x4330000000000000_4330000000000000)))
@@ -3400,7 +3610,7 @@
 
 ;; When AVX512VL and AVX512F are available,
 ;; `fcvt_from_uint` can be lowered to a single instruction.
-(rule 2 (lower (has_type $F32X4 (fcvt_from_uint src)))
+(rule 2 (lower (has_type $F32X4 (fcvt_from_uint _ src)))
       (if-let $true (use_avx512vl))
       (if-let $true (use_avx512f))
       (x64_vcvtudq2ps src))
@@ -3428,7 +3638,7 @@
 ;; -> Convert(Ah) // Convert .. with no loss of significant digits from previous shift
 ;; -> Ah = Ah + Ah // Double Ah to account for shift right before the conversion.
 ;; -> dst = Ah + Al // Add the two floats together
-(rule 1 (lower (has_type $F32X4 (fcvt_from_uint val)))
+(rule 1 (lower (has_type $F32X4 (fcvt_from_uint _ val)))
       (let ((a Xmm val)
 
             ;;  get the low 16 bits
@@ -3452,20 +3662,20 @@
 
 ;; Rules for `fcvt_to_uint` and `fcvt_to_sint` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type out_ty (fcvt_to_uint val @ (value_type (ty_scalar_float _)))))
+(rule (lower (has_type out_ty (fcvt_to_uint _ val @ (value_type (ty_scalar_float _)))))
       (cvt_float_to_uint_seq out_ty val $false))
 
-(rule (lower (has_type out_ty (fcvt_to_uint_sat val @ (value_type (ty_scalar_float _)))))
+(rule (lower (has_type out_ty (fcvt_to_uint_sat _ val @ (value_type (ty_scalar_float _)))))
       (cvt_float_to_uint_seq out_ty val $true))
 
-(rule (lower (has_type out_ty (fcvt_to_sint val @ (value_type (ty_scalar_float _)))))
+(rule (lower (has_type out_ty (fcvt_to_sint _ val @ (value_type (ty_scalar_float _)))))
       (cvt_float_to_sint_seq out_ty val $false))
 
-(rule (lower (has_type out_ty (fcvt_to_sint_sat val @ (value_type (ty_scalar_float _)))))
+(rule (lower (has_type out_ty (fcvt_to_sint_sat _ val @ (value_type (ty_scalar_float _)))))
       (cvt_float_to_sint_seq out_ty val $true))
 
 ;; The x64 backend currently only supports these two type combinations.
-(rule 1 (lower (has_type $I32X4 (fcvt_to_sint_sat val @ (value_type $F32X4))))
+(rule 1 (lower (has_type $I32X4 (fcvt_to_sint_sat _ val @ (value_type $F32X4))))
       (let ((src Xmm val)
 
             ;; Sets tmp to zero if float is NaN
@@ -3517,7 +3727,7 @@
 ;; Step 7 - Prep the converted second set by zeroing out negative lanes (these have already been
 ;;          converted correctly with the first set) and by setting overflow lanes to 0x7FFFFFFF
 ;;          as this will allow us to properly saturate overflow lanes when adding to 0x80000000
-;; Step 8 - Add the orginal converted src and the converted tmp1 where float values originally less
+;; Step 8 - Add the original converted src and the converted tmp1 where float values originally less
 ;;          than and equal to INT_MAX will be unchanged, float values originally between INT_MAX+1 and
 ;;          UINT_MAX will add together (INT_MAX) + (SRC - INT_MAX), and float values originally
 ;;          greater than UINT_MAX will be saturated to UINT_MAX (0xFFFFFFFF) after adding (0x8000000 + 0x7FFFFFFF).
@@ -3536,7 +3746,7 @@
 ;;
 ;; |                       Step 6                        |                 Step 7                 |
 ;; | (0-(INT_MAX+1))..(UINT_MAX-(INT_MAX+1))(w/overflow) | ((INT_MAX+1)-(INT_MAX+1))..(INT_MAX+1) |
-(rule 1 (lower (has_type $I32X4 (fcvt_to_uint_sat val @ (value_type $F32X4))))
+(rule 1 (lower (has_type $I32X4 (fcvt_to_uint_sat _ val @ (value_type $F32X4))))
       (let ((src Xmm val)
 
             ;; Converting to unsigned int so if float src is negative or NaN
@@ -3546,7 +3756,7 @@
 
             ;; Set tmp2 to INT_MAX+1. It is important to note here that after it looks
             ;; like we are only converting INT_MAX (0x7FFFFFFF) but in fact because
-            ;; single precision IEEE-754 floats can only accurately represent contingous
+            ;; single precision IEEE-754 floats can only accurately represent contiguous
             ;; integers up to 2^23 and outside of this range it rounds to the closest
             ;; integer that it can represent. In the case of INT_MAX, this value gets
             ;; represented as 0x4f000000 which is the integer value (INT_MAX+1).
@@ -3564,7 +3774,7 @@
             (tmp1 Xmm (x64_subps tmp1 tmp2))
 
             ;; Create mask for all positive lanes to saturate (i.e. greater than
-            ;; or equal to the maxmimum allowable unsigned int).
+            ;; or equal to the maximum allowable unsigned int).
             (tmp2 Xmm (x64_cmpps tmp2 tmp1 (FcmpImm.LessThanOrEqual)))
 
             ;; Convert those set of lanes that have the max_signed_int factored out.
@@ -3583,12 +3793,12 @@
 
 ;; Rules for `x86_cvtt2dq` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type $I32X4 (x86_cvtt2dq val @ (value_type $F32X4))))
+(rule (lower (has_type $I32X4 (x86_cvtt2dq _ val @ (value_type $F32X4))))
       (x64_cvttps2dq val))
 
 ;; Rules for `iadd_pairwise` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type $I8X16 (iadd_pairwise x y)))
+(rule (lower (has_type $I8X16 (iadd_pairwise _ x y)))
       (let (
           ;; Shuffle all the even lanes of `x` and `y` into one register
           (even_lane_mask Xmm (x64_movdqu_load (emit_u128_le_const 0x00ff_00ff_00ff_00ff_00ff_00ff_00ff_00ff)))
@@ -3604,11 +3814,11 @@
         (x64_paddb evens odds)))
 
 
-(rule 1 (lower (has_type $I16X8 (iadd_pairwise x y)))
+(rule 1 (lower (has_type $I16X8 (iadd_pairwise _ x y)))
         (if-let $true (use_ssse3))
         (x64_phaddw x y))
 
-(rule (lower (has_type $I16X8 (iadd_pairwise x y)))
+(rule (lower (has_type $I16X8 (iadd_pairwise _ x y)))
       (let (
           (x Xmm x)
           (y Xmm y)
@@ -3634,11 +3844,11 @@
         )
       (x64_paddw evens odds)))
 
-(rule 1 (lower (has_type $I32X4 (iadd_pairwise x y)))
+(rule 1 (lower (has_type $I32X4 (iadd_pairwise _ x y)))
         (if-let $true (use_ssse3))
         (x64_phaddd x y))
 
-(rule (lower (has_type $I32X4 (iadd_pairwise x y)))
+(rule (lower (has_type $I32X4 (iadd_pairwise _ x y)))
       (let (
           (x Xmm x)
           (y Xmm y)
@@ -3651,9 +3861,9 @@
 
 ;; special case for the `i16x8.extadd_pairwise_i8x16_s` wasm instruction
 (rule 2 (lower
-        (has_type $I16X8 (iadd_pairwise
-                           (swiden_low val @ (value_type $I8X16))
-                           (swiden_high val))))
+        (has_type $I16X8 (iadd_pairwise _
+                           (swiden_low _ val @ (value_type $I8X16))
+                           (swiden_high _ val))))
       (if-let $true (use_ssse3))
       (let ((mul_const Xmm (x64_xmm_load_const $I8X16
               (emit_u128_le_const 0x01010101010101010101010101010101))))
@@ -3661,26 +3871,26 @@
 
 ;; special case for the `i32x4.extadd_pairwise_i16x8_s` wasm instruction
 (rule 2 (lower
-        (has_type $I32X4 (iadd_pairwise
-                           (swiden_low val @ (value_type $I16X8))
-                           (swiden_high val))))
+        (has_type $I32X4 (iadd_pairwise _
+                           (swiden_low _ val @ (value_type $I16X8))
+                           (swiden_high _ val))))
       (let ((mul_const XmmMem (emit_u128_le_const 0x0001_0001_0001_0001_0001_0001_0001_0001)))
         (x64_pmaddwd val mul_const)))
 
 ;; special case for the `i16x8.extadd_pairwise_i8x16_u` wasm instruction
 (rule 2 (lower
-        (has_type $I16X8 (iadd_pairwise
-                           (uwiden_low val @ (value_type $I8X16))
-                           (uwiden_high val))))
+        (has_type $I16X8 (iadd_pairwise _
+                           (uwiden_low _ val @ (value_type $I8X16))
+                           (uwiden_high _ val))))
       (if-let $true (use_ssse3))
       (let ((mul_const XmmMem (emit_u128_le_const 0x01010101010101010101010101010101)))
         (x64_pmaddubsw val mul_const)))
 
 ;; special case for the `i32x4.extadd_pairwise_i16x8_u` wasm instruction
 (rule 2 (lower
-        (has_type $I32X4 (iadd_pairwise
-                           (uwiden_low val @ (value_type $I16X8))
-                           (uwiden_high val))))
+        (has_type $I32X4 (iadd_pairwise _
+                           (uwiden_low _ val @ (value_type $I16X8))
+                           (uwiden_high _ val))))
       (let ((xor_const XmmMem (emit_u128_le_const 0x8000_8000_8000_8000_8000_8000_8000_8000))
             (dst Xmm (x64_pxor val xor_const))
 
@@ -3692,25 +3902,25 @@
 
 ;; special case for the `i32x4.dot_i16x8_s` wasm instruction
 (rule 2 (lower
-        (has_type $I32X4 (iadd_pairwise
-                           (imul (swiden_low x) (swiden_low y))
-                           (imul (swiden_high x) (swiden_high y)))))
+        (has_type $I32X4 (iadd_pairwise _
+                           (imul _ (swiden_low _ x) (swiden_low _ y))
+                           (imul _ (swiden_high _ x) (swiden_high _ y)))))
       (x64_pmaddwd x y))
 
 ;; Rules for `swiden_low` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; With SSE4.1 use the `pmovsx*` instructions for this
-(rule 1 (lower (has_type $I16X8 (swiden_low val @ (value_type $I8X16))))
+(rule 1 (lower (has_type $I16X8 (swiden_low _ val @ (value_type $I8X16))))
         (if-let $true (use_sse41))
         (x64_pmovsxbw val))
-(rule 1 (lower (has_type $I32X4 (swiden_low val @ (value_type $I16X8))))
+(rule 1 (lower (has_type $I32X4 (swiden_low _ val @ (value_type $I16X8))))
         (if-let $true (use_sse41))
         (x64_pmovsxwd val))
-(rule 1 (lower (has_type $I64X2 (swiden_low val @ (value_type $I32X4))))
+(rule 1 (lower (has_type $I64X2 (swiden_low _ val @ (value_type $I32X4))))
         (if-let $true (use_sse41))
         (x64_pmovsxdq val))
 
-(rule (lower (has_type ty (swiden_low val))) (lower_swiden_low ty val))
+(rule (lower (has_type ty (swiden_low _ val))) (lower_swiden_low ty val))
 
 (decl lower_swiden_low (Type Xmm) Xmm)
 
@@ -3733,31 +3943,31 @@
 
 ;; Similar to `swiden_low` with SSE4.1 except that the upper lanes are moved
 ;; to the lower lanes first.
-(rule 1 (lower (has_type $I16X8 (swiden_high val @ (value_type $I8X16))))
+(rule 1 (lower (has_type $I16X8 (swiden_high _ val @ (value_type $I8X16))))
         (if-let $true (use_sse41))
         (if-let $true (use_ssse3))
         (let ((x Xmm val))
           (x64_pmovsxbw (x64_palignr x x 8))))
-(rule 1 (lower (has_type $I32X4 (swiden_high val @ (value_type $I16X8))))
+(rule 1 (lower (has_type $I32X4 (swiden_high _ val @ (value_type $I16X8))))
         (if-let $true (use_sse41))
         (if-let $true (use_ssse3))
         (let ((x Xmm val))
           (x64_pmovsxwd (x64_palignr x x 8))))
-(rule 1 (lower (has_type $I64X2 (swiden_high val @ (value_type $I32X4))))
+(rule 1 (lower (has_type $I64X2 (swiden_high _ val @ (value_type $I32X4))))
         (if-let $true (use_sse41))
         (x64_pmovsxdq (x64_pshufd val 0b11_10_11_10)))
 
 ;; Similar to `swiden_low` versions but using `punpckh*` instructions to
 ;; pair the high lanes next to each other.
-(rule (lower (has_type $I16X8 (swiden_high val @ (value_type $I8X16))))
+(rule (lower (has_type $I16X8 (swiden_high _ val @ (value_type $I8X16))))
       (let ((val Xmm val))
         (x64_psraw (x64_punpckhbw val val) (xmi_imm 8))))
-(rule (lower (has_type $I32X4 (swiden_high val @ (value_type $I16X8))))
+(rule (lower (has_type $I32X4 (swiden_high _ val @ (value_type $I16X8))))
       (let ((val Xmm val))
         (x64_psrad (x64_punpckhwd val val) (xmi_imm 16))))
 
 ;; Same as `swiden_low`, but `val` has its high lanes moved down.
-(rule (lower (has_type $I64X2 (swiden_high val @ (value_type $I32X4))))
+(rule (lower (has_type $I64X2 (swiden_high _ val @ (value_type $I32X4))))
       (let ((val Xmm (x64_pshufd val 0b00_00_11_10))
             (tmp Xmm (x64_pcmpgtd (xmm_zero $I32X4) val)))
       (x64_punpckldq val tmp)))
@@ -3765,17 +3975,17 @@
 ;; Rules for `uwiden_low` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; With SSE4.1 use the `pmovzx*` instructions for this
-(rule 1 (lower (has_type $I16X8 (uwiden_low val @ (value_type $I8X16))))
+(rule 1 (lower (has_type $I16X8 (uwiden_low _ val @ (value_type $I8X16))))
         (if-let $true (use_sse41))
         (x64_pmovzxbw val))
-(rule 1 (lower (has_type $I32X4 (uwiden_low val @ (value_type $I16X8))))
+(rule 1 (lower (has_type $I32X4 (uwiden_low _ val @ (value_type $I16X8))))
         (if-let $true (use_sse41))
         (x64_pmovzxwd val))
-(rule 1 (lower (has_type $I64X2 (uwiden_low val @ (value_type $I32X4))))
+(rule 1 (lower (has_type $I64X2 (uwiden_low _ val @ (value_type $I32X4))))
         (if-let $true (use_sse41))
         (x64_pmovzxdq val))
 
-(rule (lower (has_type ty (uwiden_low val))) (lower_uwiden_low ty val))
+(rule (lower (has_type ty (uwiden_low _ val))) (lower_uwiden_low ty val))
 
 ;; Interleave an all-zero register with the low lanes to produce zero-extended
 ;; results.
@@ -3790,19 +4000,19 @@
 ;;
 ;; Note that according to `llvm-mca` at least these instructions are faster
 ;; than using `pmovzx*` in terms of cycles, even if SSE4.1 is available.
-(rule (lower (has_type $I16X8 (uwiden_high val @ (value_type $I8X16))))
+(rule (lower (has_type $I16X8 (uwiden_high _ val @ (value_type $I8X16))))
       (x64_punpckhbw val (xmm_zero $I8X16)))
-(rule (lower (has_type $I32X4 (uwiden_high val @ (value_type $I16X8))))
+(rule (lower (has_type $I32X4 (uwiden_high _ val @ (value_type $I16X8))))
       (x64_punpckhwd val (xmm_zero $I8X16)))
-(rule (lower (has_type $I64X2 (uwiden_high val @ (value_type $I32X4))))
+(rule (lower (has_type $I64X2 (uwiden_high _ val @ (value_type $I32X4))))
       (x64_unpckhps val (xmm_zero $F32X4)))
 
 ;; Rules for `snarrow` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type $I8X16 (snarrow a @ (value_type $I16X8) b)))
+(rule (lower (has_type $I8X16 (snarrow _ a @ (value_type $I16X8) b)))
       (x64_packsswb a b))
 
-(rule (lower (has_type $I16X8 (snarrow a @ (value_type $I32X4) b)))
+(rule (lower (has_type $I16X8 (snarrow _ a @ (value_type $I32X4) b)))
       (x64_packssdw a b))
 
 ;; We're missing a `snarrow` case for $I64X2
@@ -3811,8 +4021,8 @@
 ;; This rule is a special case for handling the translation of the wasm op
 ;; `i32x4.trunc_sat_f64x2_s_zero`. It can be removed once we have an
 ;; implementation of `snarrow` for `I64X2`.
-(rule (lower (has_type $I32X4 (snarrow (has_type $I64X2 (fcvt_to_sint_sat val))
-                                       (vconst (u128_from_constant 0)))))
+(rule (lower (has_type $I32X4 (snarrow _ (has_type $I64X2 (fcvt_to_sint_sat _ val))
+                                       (vconst _ (u128_from_constant 0)))))
       (let ((a Xmm val)
 
             ;; y = i32x4.trunc_sat_f64x2_s_zero(x) is lowered to:
@@ -3835,16 +4045,16 @@
 
 ;; This rule is a special case for handling the translation of the wasm op
 ;; `i32x4.relaxed_trunc_f64x2_s_zero`.
-(rule (lower (has_type $I32X4 (snarrow (has_type $I64X2 (x86_cvtt2dq val))
-                                       (vconst (u128_from_constant 0)))))
+(rule (lower (has_type $I32X4 (snarrow _ (has_type $I64X2 (x86_cvtt2dq _ val))
+                                       (vconst _ (u128_from_constant 0)))))
         (x64_cvttpd2dq val))
 
 ;; Rules for `unarrow` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type $I8X16 (unarrow a @ (value_type $I16X8) b)))
+(rule (lower (has_type $I8X16 (unarrow _ a @ (value_type $I16X8) b)))
       (x64_packuswb a b))
 
-(rule 1 (lower (has_type $I16X8 (unarrow a @ (value_type $I32X4) b)))
+(rule 1 (lower (has_type $I16X8 (unarrow _ a @ (value_type $I32X4) b)))
         (if-let $true (use_sse41))
         (x64_packusdw a b))
 
@@ -3854,7 +4064,7 @@
 ;;
 ;; If this is performance sensitive then it's probably best to upgrade the CPU
 ;; to get the above single-instruction lowering.
-(rule (lower (has_type $I16X8 (unarrow a @ (value_type $I32X4) b)))
+(rule (lower (has_type $I16X8 (unarrow _ a @ (value_type $I32X4) b)))
       (let (
           (a Xmm (unarrow_i32x4_lanes_to_low_u16_lanes a))
           (b Xmm (unarrow_i32x4_lanes_to_low_u16_lanes b))
@@ -3891,35 +4101,37 @@
 
 ;; Rules for `bitcast` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type $I32 (bitcast _ src @ (value_type $F32))))
-      (bitcast_xmm_to_gpr $F32 src))
+(rule -3 (lower (has_type (is_gpr_type (fits_in_64 ty)) (bitcast _ _ src @ (value_type (is_xmm_type _)))))
+      (bitcast_xmm_to_gpr (ty_bits ty) src))
 
-(rule (lower (has_type $F32 (bitcast _ src @ (value_type $I32))))
-      (bitcast_gpr_to_xmm $I32 src))
+(rule -2 (lower (has_type (is_xmm_type (fits_in_64 ty)) (bitcast _ _ src @ (value_type (is_gpr_type _)))))
+      (bitcast_gpr_to_xmm (ty_bits ty) src))
 
-(rule (lower (has_type $I64 (bitcast _ src @ (value_type $F64))))
-      (bitcast_xmm_to_gpr $F64 src))
+(rule -1 (lower (has_type $I128 (bitcast _ _ src @ (value_type (is_xmm_type _)))))
+      (bitcast_xmm_to_gprs src))
 
-(rule (lower (has_type $F64 (bitcast _ src @ (value_type $I64))))
-      (bitcast_gpr_to_xmm $I64 src))
+(rule 0 (lower (has_type (is_xmm_type _) (bitcast _ _ src @ (value_type $I128))))
+      (bitcast_gprs_to_xmm src))
 
 ;; Bitcast between types residing in GPR registers is a no-op.
 (rule 1 (lower (has_type (is_gpr_type _)
-                         (bitcast _ x @ (value_type (is_gpr_type _))))) x)
+                         (bitcast _ _ x @ (value_type (is_gpr_type _)))))
+      x)
 
 ;; Bitcast between types residing in XMM registers is a no-op.
-(rule 2 (lower (has_type (is_xmm_type _)
-                         (bitcast _ x @ (value_type (is_xmm_type _))))) x)
+(rule 3 (lower (has_type (is_xmm_type _)
+                         (bitcast _ _ x @ (value_type (is_xmm_type _)))))
+      x)
 
 ;; Rules for `fcopysign` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type $F32 (fcopysign a @ (value_type $F32) b)))
+(rule (lower (has_type $F32 (fcopysign _ a @ (value_type $F32) b)))
       (let ((sign_bit Xmm (imm $F32 0x80000000)))
         (x64_orps
           (x64_andnps sign_bit a)
           (x64_andps sign_bit b))))
 
-(rule (lower (has_type $F64 (fcopysign a @ (value_type $F64) b)))
+(rule (lower (has_type $F64 (fcopysign _ a @ (value_type $F64) b)))
       (let ((sign_bit Xmm (imm $F64 0x8000000000000000)))
         (x64_orpd
           (x64_andnpd sign_bit a)
@@ -3950,11 +4162,11 @@
           (libcall LibCall (round_libcall $F32 imm))
           (result Xmm (libcall_1 libcall a))
           (a1 Xmm (libcall_1 libcall (x64_pshufd a 1)))
-          (result Xmm (vec_insert_lane $F32X4 result a1 1))
+          (result Xmm (f32x4_insertlane result a1 1))
           (a2 Xmm (libcall_1 libcall (x64_pshufd a 2)))
-          (result Xmm (vec_insert_lane $F32X4 result a2 2))
+          (result Xmm (f32x4_insertlane result a2 2))
           (a3 Xmm (libcall_1 libcall (x64_pshufd a 3)))
-          (result Xmm (vec_insert_lane $F32X4 result a3 3))
+          (result Xmm (f32x4_insertlane result a3 3))
         )
         result))
 (rule (x64_round $F64X2 (RegMem.Reg a) imm)
@@ -3962,9 +4174,8 @@
           (libcall LibCall (round_libcall $F64 imm))
           (result Xmm (libcall_1 libcall a))
           (a1 Xmm (libcall_1 libcall (x64_pshufd a 0b00_00_11_10)))
-          (result Xmm (vec_insert_lane $F64X2 result a1 1))
         )
-        result))
+        (x64_movlhps result a1)))
 (rule (x64_round ty (RegMem.Mem addr) imm)
       (x64_round ty (RegMem.Reg (x64_load ty addr (ExtKind.ZeroExtend))) imm))
 
@@ -3980,27 +4191,27 @@
 
 ;; Rules for `ceil` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (ceil a @ (value_type ty)))
+(rule (lower (ceil _ a @ (value_type ty)))
       (x64_round ty a (RoundImm.RoundUp)))
 
 ;; Rules for `floor` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (floor a @ (value_type ty)))
+(rule (lower (floor _ a @ (value_type ty)))
       (x64_round ty a (RoundImm.RoundDown)))
 
 ;; Rules for `nearest` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (nearest a @ (value_type ty)))
+(rule (lower (nearest _ a @ (value_type ty)))
       (x64_round ty a (RoundImm.RoundNearest)))
 
 ;; Rules for `trunc` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (trunc a @ (value_type ty)))
+(rule (lower (trunc _ a @ (value_type ty)))
       (x64_round ty a (RoundImm.RoundZero)))
 
 ;; Rules for `stack_addr` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (stack_addr stack_slot offset))
+(rule (lower (stack_addr _ stack_slot offset))
       (stack_addr_impl stack_slot offset))
 
 ;; Rules for `udiv` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -4014,7 +4225,7 @@
 ;; The inputs to the `div` instruction are different for 8-bit division so
 ;; it needs a special case here since the instruction being crafted has a
 ;; different shape.
-(rule 2 (lower (udiv a @ (value_type $I8) b))
+(rule 2 (lower (udiv _ a @ (value_type $I8) b))
         (x64_div8 (extend_to_gpr a $I32 (ExtendKind.Zero))
                   (put_in_gpr b)
                   (DivSignedness.Unsigned)
@@ -4023,7 +4234,7 @@
 ;; 16-to-64-bit division is all done with a similar instruction and the only
 ;; tricky requirement here is that when div traps are disallowed the divisor
 ;; must not be zero.
-(rule 1 (lower (udiv a @ (value_type (fits_in_64 ty)) b))
+(rule 1 (lower (udiv _ a @ (value_type (fits_in_64 ty)) b))
         (x64_div_quotient a
                           (imm $I64 0)
                           (put_in_gpr b)
@@ -4033,13 +4244,13 @@
 
 ;; Rules for `sdiv` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 2 (lower (sdiv a @ (value_type $I8) b))
+(rule 2 (lower (sdiv _ a @ (value_type $I8) b))
         (x64_div8 (x64_sign_extend_data a (OperandSize.Size8))
                   (nonzero_sdiv_divisor $I8 b)
                   (DivSignedness.Signed)
                   (TrapCode.IntegerOverflow)))
 
-(rule 1 (lower (sdiv a @ (value_type (fits_in_64 ty)) b))
+(rule 1 (lower (sdiv _ a @ (value_type (fits_in_64 ty)) b))
         (let (
             (a Gpr a)
             (size OperandSize (raw_operand_size_of_type ty))
@@ -4056,7 +4267,7 @@
 ;; This is required to differentiate the divide-by-zero trap from the
 ;; integer-overflow trap, the two trapping conditions of signed division.
 (decl nonzero_sdiv_divisor (Type Value) Reg)
-(rule 1 (nonzero_sdiv_divisor ty (iconst imm))
+(rule 1 (nonzero_sdiv_divisor ty (iconst _ imm))
         (if-let n (safe_divisor_from_imm64 ty imm))
         (imm ty n))
 (rule 0 (nonzero_sdiv_divisor ty val)
@@ -4072,7 +4283,7 @@
 
 ;; The remainder is in AH, so take the result of the division and right-shift
 ;; by 8.
-(rule 2 (lower (urem a @ (value_type $I8) b))
+(rule 2 (lower (urem _ a @ (value_type $I8) b))
         (let (
             (result Gpr (x64_div8 (extend_to_gpr a $I32 (ExtendKind.Zero))
                                   (put_in_gpr b) ;; see `udiv` for why not `gpr_mem`
@@ -4081,7 +4292,7 @@
           )
           (x64_shr $I64 result (Imm8Reg.Imm8 8))))
 
-(rule 1 (lower (urem a @ (value_type (fits_in_64 ty)) b))
+(rule 1 (lower (urem _ a @ (value_type (fits_in_64 ty)) b))
         (x64_div_remainder a
                            (imm $I64 0)
                            (put_in_gpr b) ;; see `udiv` for why not `gpr_mem`
@@ -4096,7 +4307,7 @@
 ;;
 ;; Note that like `urem` for i8 types the result is in AH so to get the result
 ;; it's right-shifted down.
-(rule 3 (lower (srem a @ (value_type $I8) (iconst imm)))
+(rule 3 (lower (srem _ a @ (value_type $I8) (iconst _ imm)))
         (if-let n (safe_divisor_from_imm64 $I8 imm))
         (let (
             (a Gpr (x64_sign_extend_data a (OperandSize.Size8)))
@@ -4105,7 +4316,7 @@
           (x64_shr $I64 result (Imm8Reg.Imm8 8))))
 
 ;; Same as the above rule but for 16-to-64 bit types.
-(rule 2 (lower (srem a @ (value_type ty) (iconst imm)))
+(rule 2 (lower (srem _ a @ (value_type ty) (iconst _ imm)))
         (if-let n (safe_divisor_from_imm64 ty imm))
         (let (
             (a Gpr a)
@@ -4118,13 +4329,13 @@
                              (DivSignedness.Signed)
                              (TrapCode.IntegerDivisionByZero))))
 
-(rule 1 (lower (srem a @ (value_type $I8) b))
+(rule 1 (lower (srem _ a @ (value_type $I8) b))
         (let (
             (a Gpr (x64_sign_extend_data a (OperandSize.Size8)))
           )
           (x64_shr $I64 (x64_checked_srem_seq8 a b) (Imm8Reg.Imm8 8))))
 
-(rule (lower (srem a @ (value_type ty) b))
+(rule (lower (srem _ a @ (value_type ty) b))
       (let (
           (a Gpr a)
           (size OperandSize (raw_operand_size_of_type ty))
@@ -4135,41 +4346,23 @@
 
 ;; Rules for `umulhi` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (umulhi a @ (value_type $I16) b))
-      (let ((res ValueRegs (mul_hi $I16 $false a b))
-            (hi Gpr (value_regs_get_gpr res 1)))
-        hi))
-
-(rule (lower (umulhi a @ (value_type $I32) b))
-      (let ((res ValueRegs (mul_hi $I32 $false a b))
-            (hi Gpr (value_regs_get_gpr res 1)))
-        hi))
+(rule 0 (lower (umulhi _ a @ (value_type $I8) b))
+        (x64_shr $I16 (x64_mul8 $false a b) (imm8_to_imm8_gpr 8)))
 
-(rule (lower (umulhi a @ (value_type $I64) b))
-      (let ((res ValueRegs (mul_hi $I64 $false a b))
-            (hi Gpr (value_regs_get_gpr res 1)))
-        hi))
+(rule 1 (lower (umulhi _ a @ (value_type (ty_int_ref_16_to_64 ty)) b))
+        (value_regs_get_gpr (x64_mul ty $false a b) 1))
 
 ;; Rules for `smulhi` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (smulhi a @ (value_type $I16) b))
-      (let ((res ValueRegs (mul_hi $I16 $true a b))
-            (hi Gpr (value_regs_get_gpr res 1)))
-        hi))
+(rule 0 (lower (smulhi _ a @ (value_type $I8) b))
+        (x64_sar $I16 (x64_mul8 $true a b) (imm8_to_imm8_gpr 8)))
 
-(rule (lower (smulhi a @ (value_type $I32) b))
-      (let ((res ValueRegs (mul_hi $I32 $true a b))
-            (hi Gpr (value_regs_get_gpr res 1)))
-        hi))
-
-(rule (lower (smulhi a @ (value_type $I64) b))
-      (let ((res ValueRegs (mul_hi $I64 $true a b))
-            (hi Gpr (value_regs_get_gpr res 1)))
-        hi))
+(rule 1 (lower (smulhi _ a @ (value_type (ty_int_ref_16_to_64 ty)) b))
+        (value_regs_get_gpr (x64_mul ty $true a b) 1))
 
 ;; Rules for `get_pinned_reg` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (get_pinned_reg))
+(rule (lower (get_pinned_reg _))
       (read_pinned_gpr))
 
 ;; Rules for `set_pinned_reg` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -4179,17 +4372,21 @@
 
 ;; Rules for `vconst` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type ty (vconst const)))
+(rule (lower (has_type ty (vconst _ const)))
       ;; TODO use Inst::gen_constant() instead.
       (x64_xmm_load_const ty (const_to_vconst const)))
 
+;; Special cases for known constant patterns to skip a 16-byte load.
+(rule 1 (lower (has_type ty (vconst _ (u128_from_constant 0)))) (xmm_zero ty))
+(rule 1 (lower (has_type ty (vconst _ (u128_from_constant -1)))) (vector_all_ones))
+
 ;; Rules for `shuffle` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Special case for `pblendw` which takes an 8-bit immediate where each bit
 ;; indicates which lane of the two operands is chosen for the output. A bit of
 ;; 0 chooses the corresponding 16-it lane from `a` and a bit of 1 chooses the
 ;; corresponding 16-bit lane from `b`.
-(rule 14 (lower (shuffle a b (pblendw_imm n)))
+(rule 14 (lower (shuffle _ a b (pblendw_imm n)))
          (if-let $true (use_sse41))
          (x64_pblendw a b n))
 (decl pblendw_imm (u8) Immediate)
@@ -4200,7 +4397,7 @@
 ;; swapped in the instruction here. The `palignr` instruction uses the second
 ;; operand as the low-order bytes and the first operand as high-order bytes,
 ;; so put `a` second.
-(rule 13 (lower (shuffle a b (palignr_imm_from_immediate n)))
+(rule 13 (lower (shuffle _ a b (palignr_imm_from_immediate n)))
          (if-let $true (use_ssse3))
          (x64_palignr b a n))
 (decl palignr_imm_from_immediate (u8) Immediate)
@@ -4212,13 +4409,13 @@
 ;; extractors here implemented in Rust and note that there's two cases for each
 ;; instruction here to match when either the first or second shuffle operand is
 ;; used.
-(rule 12 (lower (shuffle x y (pshuflw_lhs_imm imm)))
+(rule 12 (lower (shuffle _ x y (pshuflw_lhs_imm imm)))
       (x64_pshuflw x imm))
-(rule 11 (lower (shuffle x y (pshuflw_rhs_imm imm)))
+(rule 11 (lower (shuffle _ x y (pshuflw_rhs_imm imm)))
       (x64_pshuflw y imm))
-(rule 10 (lower (shuffle x y (pshufhw_lhs_imm imm)))
+(rule 10 (lower (shuffle _ x y (pshufhw_lhs_imm imm)))
       (x64_pshufhw x imm))
-(rule 9 (lower (shuffle x y (pshufhw_rhs_imm imm)))
+(rule 9 (lower (shuffle _ x y (pshufhw_rhs_imm imm)))
       (x64_pshufhw y imm))
 
 (decl pshuflw_lhs_imm (u8) Immediate)
@@ -4235,9 +4432,9 @@
 ;; selects 32-bit values from either `x` or `y`, but not both. This means
 ;; there's one rule for selecting from `x` and another rule for selecting from
 ;; `y`.
-(rule 8 (lower (shuffle x y (pshufd_lhs_imm imm)))
+(rule 8 (lower (shuffle _ x y (pshufd_lhs_imm imm)))
       (x64_pshufd x imm))
-(rule 7 (lower (shuffle x y (pshufd_rhs_imm imm)))
+(rule 7 (lower (shuffle _ x y (pshufd_rhs_imm imm)))
       (x64_pshufd y imm))
 
 (decl pshufd_lhs_imm (u8) Immediate)
@@ -4246,27 +4443,27 @@
 (extern extractor pshufd_rhs_imm pshufd_rhs_imm)
 
 ;; Special case for i8-level interleaving of upper/low bytes.
-(rule 6 (lower (shuffle a b (u128_from_immediate 0x1f0f_1e0e_1d0d_1c0c_1b0b_1a0a_1909_1808)))
+(rule 6 (lower (shuffle _ a b (u128_from_immediate 0x1f0f_1e0e_1d0d_1c0c_1b0b_1a0a_1909_1808)))
       (x64_punpckhbw a b))
-(rule 6 (lower (shuffle a b (u128_from_immediate 0x1707_1606_1505_1404_1303_1202_1101_1000)))
+(rule 6 (lower (shuffle _ a b (u128_from_immediate 0x1707_1606_1505_1404_1303_1202_1101_1000)))
       (x64_punpcklbw a b))
 
 ;; Special case for i16-level interleaving of upper/low bytes.
-(rule 6 (lower (shuffle a b (u128_from_immediate 0x1f1e_0f0e_1d1c_0d0c_1b1a_0b0a_1918_0908)))
+(rule 6 (lower (shuffle _ a b (u128_from_immediate 0x1f1e_0f0e_1d1c_0d0c_1b1a_0b0a_1918_0908)))
       (x64_punpckhwd a b))
-(rule 6 (lower (shuffle a b (u128_from_immediate 0x1716_0706_1514_0504_1312_0302_1110_0100)))
+(rule 6 (lower (shuffle _ a b (u128_from_immediate 0x1716_0706_1514_0504_1312_0302_1110_0100)))
       (x64_punpcklwd a b))
 
 ;; Special case for i32-level interleaving of upper/low bytes.
-(rule 6 (lower (shuffle a b (u128_from_immediate 0x1f1e1d1c_0f0e0d0c_1b1a1918_0b0a0908)))
+(rule 6 (lower (shuffle _ a b (u128_from_immediate 0x1f1e1d1c_0f0e0d0c_1b1a1918_0b0a0908)))
       (x64_punpckhdq a b))
-(rule 6 (lower (shuffle a b (u128_from_immediate 0x17161514_07060504_13121110_03020100)))
+(rule 6 (lower (shuffle _ a b (u128_from_immediate 0x17161514_07060504_13121110_03020100)))
       (x64_punpckldq a b))
 
 ;; Special case for i64-level interleaving of upper/low bytes.
-(rule 6 (lower (shuffle a b (u128_from_immediate 0x1f1e1d1c1b1a1918_0f0e0d0c0b0a0908)))
+(rule 6 (lower (shuffle _ a b (u128_from_immediate 0x1f1e1d1c1b1a1918_0f0e0d0c0b0a0908)))
       (x64_punpckhqdq a b))
-(rule 6 (lower (shuffle a b (u128_from_immediate 0x1716151413121110_0706050403020100)))
+(rule 6 (lower (shuffle _ a b (u128_from_immediate 0x1716151413121110_0706050403020100)))
       (x64_punpcklqdq a b))
 
 ;; If the vector shift mask is all 0s then that means the first byte of the
@@ -4274,7 +4471,7 @@
 ;; all-zeros constant from a rip-relative location but it should be slightly
 ;; more efficient to execute the `pshufb` here-and-now with an xor'd-to-be-zero
 ;; register.
-(rule 6 (lower (shuffle a _ (u128_from_immediate 0)))
+(rule 6 (lower (shuffle _ a _ (u128_from_immediate 0)))
         (if-let $true (use_ssse3))
         (x64_pshufb a (xmm_zero $I8X16)))
 
@@ -4288,9 +4485,9 @@
 ;; hypothesized that the dedicated instructions are better than `shufps`.
 ;; Someone with more knowledge about x86 timings should perhaps reorder the
 ;; rules here eventually though.
-(rule 5 (lower (shuffle x y (shufps_imm imm)))
+(rule 5 (lower (shuffle _ x y (shufps_imm imm)))
       (x64_shufps x y imm))
-(rule 4 (lower (shuffle x y (shufps_rev_imm imm)))
+(rule 4 (lower (shuffle _ x y (shufps_rev_imm imm)))
       (x64_shufps y x imm))
 
 (decl shufps_imm(u8) Immediate)
@@ -4303,21 +4500,21 @@
 ;; register. We statically build `constructed_mask` to zero out any unknown lane
 ;; indices (may not be completely necessary: verification could fail incorrect
 ;; mask values) and fix the indexes to all point to the `dst` vector.
-(rule 3 (lower (shuffle a a (vec_mask_from_immediate mask)))
+(rule 3 (lower (shuffle _ a a (vec_mask_from_immediate mask)))
         (if-let $true (use_ssse3))
         (x64_pshufb a (shuffle_0_31_mask mask)))
 
 ;; For the case where the shuffle mask contains out-of-bounds values (values
 ;; greater than 31) we must mask off those resulting values in the result of
 ;; `vpermi2b`.
-(rule 2 (lower (shuffle a b (vec_mask_from_immediate (perm_from_mask_with_zeros mask zeros))))
+(rule 2 (lower (shuffle _ a b (vec_mask_from_immediate (perm_from_mask_with_zeros mask zeros))))
       (if-let $true (use_avx512vl))
       (if-let $true (use_avx512vbmi))
       (x64_andps (x64_vpermi2b (x64_xmm_load_const $I8X16 mask) a b) zeros))
 
 ;; However, if the shuffle mask contains no out-of-bounds values, we can use
 ;; `vpermi2b` without any masking.
-(rule 1 (lower (shuffle a b (vec_mask_from_immediate mask)))
+(rule 1 (lower (shuffle _ a b (vec_mask_from_immediate mask)))
       (if-let $true (use_avx512vl))
       (if-let $true (use_avx512vbmi))
       (x64_vpermi2b (x64_xmm_load_const $I8X16 (perm_from_mask mask)) a b))
@@ -4325,7 +4522,7 @@
 ;; If `lhs` and `rhs` are different, we must shuffle each separately and then OR
 ;; them together. This is necessary due to PSHUFB semantics. As in the case
 ;; above, we build the `constructed_mask` for each case statically.
-(rule (lower (shuffle a b (vec_mask_from_immediate mask)))
+(rule (lower (shuffle _ a b (vec_mask_from_immediate mask)))
       (x64_por
         (lower_pshufb a (shuffle_0_15_mask mask))
         (lower_pshufb b (shuffle_16_31_mask mask))))
@@ -4338,13 +4535,13 @@
 ;; https://github.com/WebAssembly/simd/issues/93. The CLIF semantics match the
 ;; Wasm SIMD semantics for this instruction. The instruction format maps to
 ;; variables like: %dst = swizzle %src, %mask
-(rule (lower (swizzle src mask))
+(rule (lower (swizzle _ src mask))
       (let ((mask Xmm (x64_paddusb mask (emit_u128_le_const 0x70707070707070707070707070707070))))
         (lower_pshufb src mask)))
 
 ;; Rules for `x86_pshufb` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (x86_pshufb src mask))
+(rule (lower (x86_pshufb _ src mask))
       (if-let $true (use_ssse3))
       (x64_pshufb src mask))
 
@@ -4367,56 +4564,56 @@
 ;; Remove the extractlane instruction, leaving the float where it is. The upper
 ;; bits will remain unchanged; for correctness, this relies on Cranelift type
 ;; checking to avoid using those bits.
-(rule 3 (lower (has_type (ty_scalar_float _) (extractlane val 0)))
+(rule 3 (lower (has_type (ty_scalar_float _) (extractlane _ val 0)))
         val)
 
 ;; `f32x4.extract_lane N` where `N != 0`
-(rule 1 (lower (extractlane val @ (value_type $F32X4) (u8_from_uimm8 lane)))
+(rule 1 (lower (extractlane _ val @ (value_type $F32X4) (u8_from_uimm8 lane)))
         (x64_pshufd val lane))
 
 ;; `f64x2.extract_lane N` where `N != 0` (aka N == 1)
-(rule (lower (extractlane val @ (value_type $F64X2) 1))
+(rule (lower (extractlane _ val @ (value_type $F64X2) 1))
       (x64_pshufd val 0b11_10_11_10))
 
 ;; `i8x16.extract_lane N`
 ;;
 ;; Note that without SSE4.1 a 16-bit lane extraction is performed and then
 ;; the result is updated if the desired index is either odd or even.
-(rule 2 (lower (extractlane val @ (value_type ty @ $I8X16) (u8_from_uimm8 lane)))
+(rule 2 (lower (extractlane _ val @ (value_type ty @ $I8X16) (u8_from_uimm8 lane)))
         (if-let $true (use_sse41))
         (x64_pextrb val lane))
 ;; extracting an odd lane has an extra shift-right
-(rule 1 (lower (extractlane val @ (value_type ty @ $I8X16) (u8_from_uimm8 lane)))
+(rule 1 (lower (extractlane _ val @ (value_type ty @ $I8X16) (u8_from_uimm8 lane)))
         (if-let 1 (u8_and lane 1))
         (x64_shr $I16 (x64_pextrw val (u8_shr lane 1)) (Imm8Reg.Imm8 8)))
 ;; Extracting an even lane already has the desired lane in the lower bits. Note
 ;; that having arbitrary upper bits in the returned register should be ok since
 ;; all operators on the resulting `i8` type should work correctly regardless of
 ;; the bits in the rest of the register.
-(rule (lower (extractlane val @ (value_type ty @ $I8X16) (u8_from_uimm8 lane)))
+(rule (lower (extractlane _ val @ (value_type ty @ $I8X16) (u8_from_uimm8 lane)))
       (if-let 0 (u8_and lane 1))
       (x64_pextrw val (u8_shr lane 1)))
 
 ;; `i16x8.extract_lane N`
-(rule (lower (extractlane val @ (value_type ty @ $I16X8) (u8_from_uimm8 lane)))
+(rule (lower (extractlane _ val @ (value_type ty @ $I16X8) (u8_from_uimm8 lane)))
       (x64_pextrw val lane))
 
 ;; `i32x4.extract_lane N`
-(rule 2 (lower (extractlane val @ (value_type ty @ $I32X4) (u8_from_uimm8 lane)))
+(rule 2 (lower (extractlane _ val @ (value_type ty @ $I32X4) (u8_from_uimm8 lane)))
         (if-let $true (use_sse41))
         (x64_pextrd val lane))
-(rule 1 (lower (extractlane val @ (value_type $I32X4) 0))
+(rule 1 (lower (extractlane _ val @ (value_type $I32X4) 0))
         (x64_movd_to_gpr val))
-(rule (lower (extractlane val @ (value_type $I32X4) (u8_from_uimm8 n)))
+(rule (lower (extractlane _ val @ (value_type $I32X4) (u8_from_uimm8 n)))
       (x64_movd_to_gpr (x64_pshufd val n)))
 
 ;; `i64x2.extract_lane N`
-(rule 1 (lower (extractlane val @ (value_type $I64X2) (u8_from_uimm8 lane)))
+(rule 1 (lower (extractlane _ val @ (value_type $I64X2) (u8_from_uimm8 lane)))
         (if-let $true (use_sse41))
         (x64_pextrq val lane))
-(rule (lower (extractlane val @ (value_type $I64X2) 0))
+(rule (lower (extractlane _ val @ (value_type $I64X2) 0))
       (x64_movq_to_gpr val))
-(rule (lower (extractlane val @ (value_type $I64X2) 1))
+(rule (lower (extractlane _ val @ (value_type $I64X2) 1))
       (x64_movq_to_gpr (x64_pshufd val 0b00_00_11_10)))
 
 ;; Rules for `scalar_to_vector` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -4425,19 +4622,19 @@
 ;; to another, expecting the register allocator to elide this. Here we
 ;; assume that the upper bits of a scalar float have not been munged with
 ;; (the same assumption the old backend makes).
-(rule 1 (lower (scalar_to_vector src @ (value_type (ty_scalar_float _))))
+(rule 1 (lower (scalar_to_vector _ src @ (value_type (ty_scalar_float _))))
       src)
 
 ;; Case 2: when moving a scalar value of any other type, use MOVD to zero
 ;; the upper lanes.
-(rule (lower (scalar_to_vector src @ (value_type ty)))
-      (bitcast_gpr_to_xmm ty src))
+(rule (lower (scalar_to_vector _ src @ (value_type ty)))
+      (bitcast_gpr_to_xmm (ty_bits ty) src))
 
 ;; Case 3: when presented with `load + scalar_to_vector`, coalesce into a single
 ;; MOVSS/MOVSD instruction.
-(rule 2 (lower (scalar_to_vector (and (sinkable_load src) (value_type (ty_32 _)))))
+(rule 2 (lower (scalar_to_vector _ (and (sinkable_load src) (value_type (ty_32 _)))))
       (x64_movss_load src))
-(rule 3 (lower (scalar_to_vector (and (sinkable_load src) (value_type (ty_64 _)))))
+(rule 3 (lower (scalar_to_vector _ (and (sinkable_load src) (value_type (ty_64 _)))))
       (x64_movsd_load src))
 
 ;; Rules for `splat` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -4453,20 +4650,20 @@
 
 ;; i8x16 splats: use `vpbroadcastb` on AVX2 and otherwise `pshufb` broadcasts
 ;; with a mask of zero which is calculated with an xor-against-itself register.
-(rule 0 (lower (has_type $I8X16 (splat src)))
+(rule 0 (lower (has_type $I8X16 (splat _ src)))
         (let ((src Xmm (x64_movd_to_xmm src)))
           (x64_pshufd (x64_pshuflw (x64_punpcklbw src src) 0) 0)))
-(rule 1 (lower (has_type $I8X16 (splat src)))
+(rule 1 (lower (has_type $I8X16 (splat _ src)))
         (if-let $true (use_ssse3))
-        (x64_pshufb (bitcast_gpr_to_xmm $I32 src) (xmm_zero $I8X16)))
-(rule 2 (lower (has_type $I8X16 (splat src)))
+        (x64_pshufb (bitcast_gpr_to_xmm 32 src) (xmm_zero $I8X16)))
+(rule 2 (lower (has_type $I8X16 (splat _ src)))
         (if-let $true (use_avx2))
-        (x64_vpbroadcastb (bitcast_gpr_to_xmm $I32 src)))
-(rule 3 (lower (has_type $I8X16 (splat (sinkable_load_exact addr))))
+        (x64_vpbroadcastb (bitcast_gpr_to_xmm 32 src)))
+(rule 3 (lower (has_type $I8X16 (splat _ (sinkable_load_exact addr))))
         (if-let $true (use_sse41))
         (if-let $true (use_ssse3))
         (x64_pshufb (x64_pinsrb (xmm_uninit_value) addr 0) (xmm_zero $I8X16)))
-(rule 4 (lower (has_type $I8X16 (splat (sinkable_load_exact addr))))
+(rule 4 (lower (has_type $I8X16 (splat _ (sinkable_load_exact addr))))
         (if-let $true (use_avx2))
         (x64_vpbroadcastb addr))
 
@@ -4475,14 +4672,14 @@
 ;; to the low four lanes, and `pshufd` broadcasts the low 32-bit lane (which
 ;; at that point is two of the 16-bit values we want to broadcast) to all the
 ;; lanes.
-(rule 0 (lower (has_type $I16X8 (splat src)))
-        (x64_pshufd (x64_pshuflw (bitcast_gpr_to_xmm $I32 src) 0) 0))
-(rule 1 (lower (has_type $I16X8 (splat src)))
+(rule 0 (lower (has_type $I16X8 (splat _ src)))
+        (x64_pshufd (x64_pshuflw (bitcast_gpr_to_xmm 32 src) 0) 0))
+(rule 1 (lower (has_type $I16X8 (splat _ src)))
         (if-let $true (use_avx2))
-        (x64_vpbroadcastw (bitcast_gpr_to_xmm $I32 src)))
-(rule 2 (lower (has_type $I16X8 (splat (sinkable_load_exact addr))))
+        (x64_vpbroadcastw (bitcast_gpr_to_xmm 32 src)))
+(rule 2 (lower (has_type $I16X8 (splat _ (sinkable_load_exact addr))))
         (x64_pshufd (x64_pshuflw (x64_pinsrw (xmm_uninit_value) addr 0) 0) 0))
-(rule 3 (lower (has_type $I16X8 (splat (sinkable_load_exact addr))))
+(rule 3 (lower (has_type $I16X8 (splat _ (sinkable_load_exact addr))))
         (if-let $true (use_avx2))
         (x64_vpbroadcastw addr))
 
@@ -4490,19 +4687,19 @@
 ;; used to broadcast the low lane to all other lanes.
 ;;
 ;; Note that sinkable-load cases come later
-(rule 0 (lower (has_type $I32X4 (splat src)))
-        (x64_pshufd (bitcast_gpr_to_xmm $I32 src) 0))
-(rule 1 (lower (has_type $I32X4 (splat src)))
+(rule 0 (lower (has_type $I32X4 (splat _ src)))
+        (x64_pshufd (bitcast_gpr_to_xmm 32 src) 0))
+(rule 1 (lower (has_type $I32X4 (splat _ src)))
         (if-let $true (use_avx2))
-        (x64_vpbroadcastd (bitcast_gpr_to_xmm $I32 src)))
+        (x64_vpbroadcastd (bitcast_gpr_to_xmm 32 src)))
 
 ;; f32x4.splat - the source is already in an xmm register so `shufps` is all
 ;; that's necessary to complete the splat. This is specialized to `vbroadcastss`
 ;; on AVX2 to leverage that specific instruction for this operation.
-(rule 0 (lower (has_type $F32X4 (splat src)))
+(rule 0 (lower (has_type $F32X4 (splat _ src)))
         (let ((tmp Xmm src))
           (x64_shufps src src 0)))
-(rule 1 (lower (has_type $F32X4 (splat src)))
+(rule 1 (lower (has_type $F32X4 (splat _ src)))
         (if-let $true (use_avx2))
         (x64_vbroadcastss src))
 
@@ -4515,27 +4712,27 @@
 ;; the register-based encoding is only available with AVX2. With the
 ;; `sinkable_load` extractor this should be guaranteed to use the memory-based
 ;; encoding hence the `use_avx` test.
-(rule 5 (lower (has_type (multi_lane 32 4) (splat (sinkable_load addr))))
+(rule 5 (lower (has_type (multi_lane 32 4) (splat _ (sinkable_load addr))))
         (let ((tmp Xmm (x64_movss_load addr)))
           (x64_shufps tmp tmp 0)))
-(rule 6 (lower (has_type (multi_lane 32 4) (splat (sinkable_load addr))))
+(rule 6 (lower (has_type (multi_lane 32 4) (splat _ (sinkable_load addr))))
         (if-let $true (use_avx))
         (x64_vbroadcastss addr))
 
 ;; t64x2.splat - use `pshufd` to broadcast the lower 64-bit lane to the upper
 ;; lane. A minor specialization for sinkable loads to avoid going through a gpr
 ;; for i64 splats is used as well when `movddup` is available.
-(rule 0 (lower (has_type $I64X2 (splat src)))
-        (x64_pshufd (bitcast_gpr_to_xmm $I64 src) 0b01_00_01_00))
-(rule 0 (lower (has_type $F64X2 (splat src)))
+(rule 0 (lower (has_type $I64X2 (splat _ src)))
+        (x64_pshufd (bitcast_gpr_to_xmm 64 src) 0b01_00_01_00))
+(rule 0 (lower (has_type $F64X2 (splat _ src)))
         (x64_pshufd src 0b01_00_01_00))
-(rule 6 (lower (has_type (multi_lane 64 2) (splat (sinkable_load addr))))
+(rule 6 (lower (has_type (multi_lane 64 2) (splat _ (sinkable_load addr))))
         (if-let $true (use_ssse3))
         (x64_movddup addr))
 
 ;; Rules for `vany_true` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 1 (lower (vany_true val))
+(rule 1 (lower (vany_true _ val))
         (if-let $true (use_sse41))
         (let ((val Xmm val))
           (with_flags (x64_ptest val val) (x64_setcc (CC.NZ)))))
@@ -4544,31 +4741,39 @@
 ;; zeroed register and extract the high bits to a gpr mask. If the mask is
 ;; 0xffff then every byte was equal to zero, so test if the comparison is
 ;; not-equal or NZ.
-(rule (lower (vany_true val))
+(rule (lower (vany_true _ val))
+      (lower_icmp_bool (emit_vany_true val)))
+
+(decl emit_vany_true (Value) IcmpCondResult)
+(rule (emit_vany_true val)
       (let (
           (any_byte_zero Xmm (x64_pcmpeqb val (xmm_zero $I8X16)))
           (mask Gpr (x64_pmovmskb (OperandSize.Size32) any_byte_zero))
         )
-        (with_flags (x64_cmp (OperandSize.Size32) (RegMemImm.Imm 0xffff) mask)
-                    (x64_setcc (CC.NZ)))))
+        (icmp_cond_result (x64_cmp_imm (OperandSize.Size32) mask 0xffff)
+                          (CC.NZ))))
 
 ;; Rules for `vall_true` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 1 (lower (vall_true val @ (value_type ty)))
+(rule (lower (vall_true _ val))
+      (lower_icmp_bool (emit_vall_true val)))
+
+(decl emit_vall_true (Value) IcmpCondResult)
+(rule 1 (emit_vall_true val @ (value_type ty))
         (if-let $true (use_sse41))
         (let ((src Xmm val)
               (zeros Xmm (xmm_zero ty))
               (cmp Xmm (x64_pcmpeq (vec_int_type ty) src zeros)))
-          (with_flags (x64_ptest cmp cmp) (x64_setcc (CC.Z)))))
+          (icmp_cond_result (x64_ptest cmp cmp) (CC.Z))))
 
 ;; Perform an appropriately-sized lane-wise comparison with zero. If the
 ;; result is all 0s then all of them are true because nothing was equal to
 ;; zero.
-(rule (lower (vall_true val @ (value_type ty)))
+(rule (emit_vall_true val @ (value_type ty))
       (let ((lanes_with_zero Xmm (x64_pcmpeq (vec_int_type ty) val (xmm_zero ty)))
             (mask Gpr (x64_pmovmskb (OperandSize.Size32) lanes_with_zero)))
-        (with_flags (x64_test (OperandSize.Size32) mask mask)
-                    (x64_setcc (CC.Z)))))
+        (icmp_cond_result (x64_test (OperandSize.Size32) mask mask)
+                          (CC.Z))))
 
 ;; Rules for `vhigh_bits` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
@@ -4581,13 +4786,13 @@
 ;; for setting/clearing REX.W) as we need at most 16 bits of output for
 ;; `vhigh_bits`.
 
-(rule (lower (vhigh_bits val @ (value_type (multi_lane 8 16))))
+(rule (lower (vhigh_bits _ val @ (value_type (multi_lane 8 16))))
       (x64_pmovmskb (OperandSize.Size32) val))
 
-(rule (lower (vhigh_bits val @ (value_type (multi_lane 32 4))))
+(rule (lower (vhigh_bits _ val @ (value_type (multi_lane 32 4))))
       (x64_movmskps (OperandSize.Size32) val))
 
-(rule (lower (vhigh_bits val @ (value_type (multi_lane 64 2))))
+(rule (lower (vhigh_bits _ val @ (value_type (multi_lane 64 2))))
       (x64_movmskpd (OperandSize.Size32) val))
 
 ;; There is no x86 instruction for extracting the high bit of 16-bit lanes so
@@ -4596,7 +4801,7 @@
 ;;     PACKSSWB([x1, x2, ...], [x1, x2, ...]) = [x1', x2', ..., x1', x2', ...]
 ;; - use PMOVMSKB to gather the high bits; now we have duplicates, though
 ;; - shift away the bottom 8 high bits to remove the duplicates.
-(rule (lower (vhigh_bits val @ (value_type (multi_lane 16 8))))
+(rule (lower (vhigh_bits _ val @ (value_type (multi_lane 16 8))))
       (let ((src Xmm val)
             (tmp Xmm (x64_packsswb src src))
             (tmp Gpr (x64_pmovmskb (OperandSize.Size32) tmp)))
@@ -4604,12 +4809,12 @@
 
 ;; Rules for `iconcat` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (iconcat lo @ (value_type $I64) hi))
+(rule (lower (iconcat _ lo @ (value_type $I64) hi))
       (value_regs lo hi))
 
 ;; Rules for `isplit` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (isplit val @ (value_type $I128)))
+(rule (lower (isplit _ val @ (value_type $I128)))
       (let ((regs ValueRegs val)
             (lo Reg (value_regs_get regs 0))
             (hi Reg (value_regs_get regs 1)))
@@ -4617,18 +4822,18 @@
 
 ;; Rules for `tls_value` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (has_type (tls_model (TlsModel.ElfGd)) (tls_value (symbol_value_data name _ _))))
+(rule (lower (has_type (tls_model (TlsModel.ElfGd)) (tls_value _ (symbol_value_data name _ _))))
       (elf_tls_get_addr name))
 
-(rule (lower (has_type (tls_model (TlsModel.Macho)) (tls_value (symbol_value_data name _ _))))
+(rule (lower (has_type (tls_model (TlsModel.Macho)) (tls_value _ (symbol_value_data name _ _))))
       (macho_tls_get_addr name))
 
-(rule (lower (has_type (tls_model (TlsModel.Coff)) (tls_value (symbol_value_data name _ _))))
+(rule (lower (has_type (tls_model (TlsModel.Coff)) (tls_value _ (symbol_value_data name _ _))))
       (coff_tls_get_addr name))
 
 ;; Rules for `sqmul_round_sat` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule 1 (lower (sqmul_round_sat qx @ (value_type $I16X8) qy))
+(rule 1 (lower (sqmul_round_sat _ qx @ (value_type $I16X8) qy))
         (if-let $true (use_ssse3))
         (let ((src1 Xmm qx)
               (src2 Xmm qy)
@@ -4644,7 +4849,7 @@
 ;;
 ;; so perform all those operations here manually with a lack of the native
 ;; instruction.
-(rule (lower (sqmul_round_sat qx @ (value_type $I16X8) qy))
+(rule (lower (sqmul_round_sat _ qx @ (value_type $I16X8) qy))
       (let (
           (qx Xmm qx)
           (qy Xmm qy)
@@ -4670,7 +4875,7 @@
 
 ;; Rules for `x86_pmulhrsw` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(rule (lower (x86_pmulhrsw qx @ (value_type $I16X8) qy))
+(rule (lower (x86_pmulhrsw _ qx @ (value_type $I16X8) qy))
       (if-let $true (use_ssse3))
       (x64_pmulhrsw qx qy))
 
@@ -4688,8 +4893,8 @@
 ;; ROUNDPD xmm_y, xmm_y, 0x0B
 ;; ADDPD xmm_y, [wasm_f64x2_splat(0x1.0p+52)]
 ;; SHUFPS xmm_y, xmm_xmp, 0x88
-(rule (lower (uunarrow (fcvt_to_uint_sat src @ (value_type $F64X2))
-                       (vconst (u128_from_constant 0))))
+(rule (lower (uunarrow _ (fcvt_to_uint_sat _ src @ (value_type $F64X2))
+                       (vconst _ (u128_from_constant 0))))
       (let ((src Xmm src)
 
             ;; MOVAPD xmm_y, xmm_x
diff --git a/cranelift/codegen/src/isa/x64/lower.rs b/cranelift/codegen/src/isa/x64/lower.rs
index c76a57f7c3fc..ae780089d4c5 100644
--- a/cranelift/codegen/src/isa/x64/lower.rs
+++ b/cranelift/codegen/src/isa/x64/lower.rs
@@ -3,17 +3,18 @@
 // ISLE integration glue.
 pub(super) mod isle;
 
-use crate::ir::{types, ExternalName, Inst as IRInst, LibCall, Opcode, Type};
+use crate::ir::pcc::{FactContext, PccResult};
+use crate::ir::{types, ExternalName, Inst as IRInst, InstructionData, LibCall, Opcode, Type};
 use crate::isa::x64::abi::*;
 use crate::isa::x64::inst::args::*;
 use crate::isa::x64::inst::*;
+use crate::isa::x64::pcc;
 use crate::isa::{x64::X64Backend, CallConv};
-use crate::machinst::abi::SmallInstVec;
 use crate::machinst::lower::*;
 use crate::machinst::*;
 use crate::result::CodegenResult;
 use crate::settings::Flags;
-use smallvec::smallvec;
+use smallvec::{smallvec, SmallVec};
 use target_lexicon::Triple;
 
 //=============================================================================
@@ -33,8 +34,7 @@ impl Lower<'_, Inst> {
 
 fn is_int_or_ref_ty(ty: Type) -> bool {
     match ty {
-        types::I8 | types::I16 | types::I32 | types::I64 | types::R64 => true,
-        types::R32 => panic!("shouldn't have 32-bits refs on x64"),
+        types::I8 | types::I16 | types::I32 | types::I64 => true,
         _ => false,
     }
 }
@@ -60,11 +60,10 @@ fn put_input_in_regs(ctx: &mut Lower<Inst>, spec: InsnInput) -> ValueRegs<Reg> {
 
     if let Some(c) = input.constant {
         // Generate constants fresh at each use to minimize long-range register pressure.
-        let from_bits = ty_bits(ty);
-        let (size, c) = if from_bits < 64 {
-            (OperandSize::Size32, c & ((1u64 << from_bits) - 1))
+        let size = if ty_bits(ty) < 64 {
+            OperandSize::Size32
         } else {
-            (OperandSize::Size64, c)
+            OperandSize::Size64
         };
         assert!(is_int_or_ref_ty(ty)); // Only used for addresses.
         let cst_copy = ctx.alloc_tmp(ty);
@@ -123,16 +122,18 @@ fn is_mergeable_load(
     // Just testing the opcode is enough, because the width will always match if
     // the type does (and the type should match if the CLIF is properly
     // constructed).
-    if insn_data.opcode() == Opcode::Load {
-        let offset = insn_data
-            .load_store_offset()
-            .expect("load should have offset");
+    if let &InstructionData::Load {
+        opcode: Opcode::Load,
+        offset,
+        ..
+    } = insn_data
+    {
         Some((
             InsnInput {
                 insn: src_insn,
                 input: 0,
             },
-            offset,
+            offset.into(),
         ))
     } else {
         None
@@ -150,8 +151,7 @@ fn emit_vm_call(
     triple: &Triple,
     libcall: LibCall,
     inputs: &[Reg],
-    outputs: &[Writable<Reg>],
-) -> CodegenResult<()> {
+) -> CodegenResult<SmallVec<[Reg; 1]>> {
     let extname = ExternalName::LibCall(libcall);
 
     let dist = if flags.use_colocated_libcalls() {
@@ -173,27 +173,27 @@ fn emit_vm_call(
     let mut abi =
         X64CallSite::from_libcall(ctx.sigs(), &sig, &extname, dist, caller_conv, flags.clone());
 
-    abi.emit_stack_pre_adjust(ctx);
-
     assert_eq!(inputs.len(), abi.num_args(ctx.sigs()));
 
     for (i, input) in inputs.iter().enumerate() {
-        for inst in abi.gen_arg(ctx, i, ValueRegs::one(*input)) {
-            ctx.emit(inst);
-        }
+        abi.gen_arg(ctx, i, ValueRegs::one(*input));
     }
 
     let mut retval_insts: SmallInstVec<_> = smallvec![];
-    for (i, output) in outputs.iter().enumerate() {
-        retval_insts.extend(abi.gen_retval(ctx, i, ValueRegs::one(*output)).into_iter());
+    let mut outputs: SmallVec<[_; 1]> = smallvec![];
+    for i in 0..ctx.sigs().num_rets(ctx.sigs().abi_sig_for_signature(&sig)) {
+        let (retval_inst, retval_regs) = abi.gen_retval(ctx, i);
+        retval_insts.extend(retval_inst.into_iter());
+        outputs.push(retval_regs.only_reg().unwrap());
     }
+
     abi.emit_call(ctx);
+
     for inst in retval_insts {
         ctx.emit(inst);
     }
-    abi.emit_stack_post_adjust(ctx);
 
-    Ok(())
+    Ok(outputs)
 }
 
 /// Returns whether the given input is a shift by a constant value less or equal than 3.
@@ -261,35 +261,21 @@ fn lower_to_amode(ctx: &mut Lower<Inst>, spec: InsnInput, offset: i32) -> Amode
                 shift_amt,
             )
         } else {
-            for i in 0..=1 {
+            for input in 0..=1 {
                 // Try to pierce through uextend.
-                if let Some(uextend) = matches_input(
-                    ctx,
-                    InsnInput {
-                        insn: add,
-                        input: i,
-                    },
-                    Opcode::Uextend,
-                ) {
-                    if let Some(cst) = ctx.get_input_as_source_or_const(uextend, 0).constant {
-                        // Zero the upper bits.
-                        let input_size = ctx.input_ty(uextend, 0).bits() as u64;
-                        let shift: u64 = 64 - input_size;
-                        let uext_cst: u64 = (cst << shift) >> shift;
-
-                        let final_offset = (offset as i64).wrapping_add(uext_cst as i64);
-                        if let Ok(final_offset) = i32::try_from(final_offset) {
-                            let base = put_input_in_reg(ctx, add_inputs[1 - i]);
-                            return Amode::imm_reg(final_offset, base).with_flags(flags);
-                        }
-                    }
-                }
+                let (inst, inst_input) = if let Some(uextend) =
+                    matches_input(ctx, InsnInput { insn: add, input }, Opcode::Uextend)
+                {
+                    (uextend, 0)
+                } else {
+                    (add, input)
+                };
 
                 // If it's a constant, add it directly!
-                if let Some(cst) = ctx.get_input_as_source_or_const(add, i).constant {
+                if let Some(cst) = ctx.get_input_as_source_or_const(inst, inst_input).constant {
                     let final_offset = (offset as i64).wrapping_add(cst as i64);
                     if let Ok(final_offset) = i32::try_from(final_offset) {
-                        let base = put_input_in_reg(ctx, add_inputs[1 - i]);
+                        let base = put_input_in_reg(ctx, add_inputs[1 - input]);
                         return Amode::imm_reg(final_offset, base).with_flags(flags);
                     }
                 }
@@ -304,8 +290,8 @@ fn lower_to_amode(ctx: &mut Lower<Inst>, spec: InsnInput, offset: i32) -> Amode
 
         return Amode::imm_reg_reg_shift(
             offset,
-            Gpr::new(base).unwrap(),
-            Gpr::new(index).unwrap(),
+            Gpr::unwrap_new(base),
+            Gpr::unwrap_new(index),
             shift,
         )
         .with_flags(flags);
@@ -337,4 +323,16 @@ impl LowerBackend for X64Backend {
     fn maybe_pinned_reg(&self) -> Option<Reg> {
         Some(regs::pinned_reg())
     }
+
+    fn check_fact(
+        &self,
+        ctx: &FactContext<'_>,
+        vcode: &mut VCode<Self::MInst>,
+        inst: InsnIndex,
+        state: &mut pcc::FactFlowState,
+    ) -> PccResult<()> {
+        pcc::check(ctx, vcode, inst, state)
+    }
+
+    type FactFlowState = pcc::FactFlowState;
 }
diff --git a/cranelift/codegen/src/isa/x64/lower/isle.rs b/cranelift/codegen/src/isa/x64/lower/isle.rs
index 99d454a70cd6..54a5ad518519 100644
--- a/cranelift/codegen/src/isa/x64/lower/isle.rs
+++ b/cranelift/codegen/src/isa/x64/lower/isle.rs
@@ -2,12 +2,7 @@
 
 // Pull in the ISLE generated code.
 pub(crate) mod generated_code;
-use crate::{
-    ir::types,
-    ir::AtomicRmwOp,
-    isa, isle_common_prelude_methods, isle_lower_prelude_methods,
-    machinst::{InputSourceInst, Reg, Writable},
-};
+use crate::{ir::types, ir::AtomicRmwOp, isa};
 use generated_code::{Context, MInst, RegisterClass};
 
 // Types that the generated ISLE code uses via `use super::*`.
@@ -17,29 +12,29 @@ use crate::isa::x64::lower::emit_vm_call;
 use crate::isa::x64::X64Backend;
 use crate::{
     ir::{
-        condcodes::{CondCode, FloatCC, IntCC},
+        condcodes::{FloatCC, IntCC},
         immediates::*,
         types::*,
         BlockCall, Inst, InstructionData, MemFlags, Opcode, TrapCode, Value, ValueList,
     },
-    isa::{
-        unwind::UnwindInst,
-        x64::{
-            abi::X64CallSite,
-            inst::{args::*, regs, CallInfo, ReturnCallInfo},
-        },
+    isa::x64::{
+        abi::X64CallSite,
+        inst::{args::*, regs, CallInfo, ReturnCallInfo},
     },
     machinst::{
-        isle::*, valueregs, ArgPair, InsnInput, InstOutput, Lower, MachAtomicRmwOp, MachInst,
+        isle::*, ArgPair, InsnInput, InstOutput, IsTailCall, MachAtomicRmwOp, MachInst,
         VCodeConstant, VCodeConstantData,
     },
 };
 use alloc::vec::Vec;
 use regalloc2::PReg;
 use std::boxed::Box;
-use std::convert::TryFrom;
 
-type BoxCallInfo = Box<CallInfo>;
+/// Type representing out-of-line data for calls. This type optional because the
+/// call instruction is also used by Winch to emit calls, but the
+/// `Box<CallInfo>` field is not used, it's only used by Cranelift. By making it
+/// optional, we reduce the number of heap allocations in Winch.
+type BoxCallInfo = Option<Box<CallInfo>>;
 type BoxReturnCallInfo = Box<ReturnCallInfo>;
 type VecArgPair = Vec<ArgPair>;
 
@@ -70,7 +65,7 @@ pub(crate) fn lower_branch(
     // TODO: reuse the ISLE context across lowerings so we can reuse its
     // internal heap allocations.
     let mut isle_ctx = IsleContext { lower_ctx, backend };
-    generated_code::constructor_lower_branch(&mut isle_ctx, branch, &targets.to_vec())
+    generated_code::constructor_lower_branch(&mut isle_ctx, branch, &targets)
 }
 
 impl Context for IsleContext<'_, '_, MInst, X64Backend> {
@@ -96,7 +91,7 @@ impl Context for IsleContext<'_, '_, MInst, X64Backend> {
             self.lower_ctx.sigs(),
             callee_sig,
             callee,
-            Opcode::ReturnCallIndirect,
+            IsTailCall::Yes,
             caller_conv,
             self.backend.flags().clone(),
         );
@@ -123,6 +118,7 @@ impl Context for IsleContext<'_, '_, MInst, X64Backend> {
             self.lower_ctx.sigs(),
             callee_sig,
             &callee,
+            IsTailCall::Yes,
             distance,
             caller_conv,
             self.backend.flags().clone(),
@@ -150,7 +146,8 @@ impl Context for IsleContext<'_, '_, MInst, X64Backend> {
         let inputs = self.lower_ctx.get_value_as_source_or_const(val);
 
         if let Some(c) = inputs.constant {
-            if let Some(imm) = to_simm32(c as i64) {
+            let ty = self.lower_ctx.dfg().value_type(val);
+            if let Some(imm) = to_simm32(c as i64, ty) {
                 return imm.to_reg_mem_imm();
             }
         }
@@ -162,8 +159,9 @@ impl Context for IsleContext<'_, '_, MInst, X64Backend> {
         let inputs = self.lower_ctx.get_value_as_source_or_const(val);
 
         if let Some(c) = inputs.constant {
-            if let Some(imm) = to_simm32(c as i64) {
-                return XmmMemImm::new(imm.to_reg_mem_imm()).unwrap();
+            let ty = self.lower_ctx.dfg().value_type(val);
+            if let Some(imm) = to_simm32(c as i64, ty) {
+                return XmmMemImm::unwrap_new(imm.to_reg_mem_imm());
             }
         }
 
@@ -172,7 +170,7 @@ impl Context for IsleContext<'_, '_, MInst, X64Backend> {
             RegMem::Mem { addr } => RegMemImm::Mem { addr },
         };
 
-        XmmMemImm::new(res).unwrap()
+        XmmMemImm::unwrap_new(res)
     }
 
     fn put_in_xmm_mem(&mut self, val: Value) -> XmmMem {
@@ -185,11 +183,10 @@ impl Context for IsleContext<'_, '_, MInst, X64Backend> {
             // NOTE: this is where behavior differs from `put_in_reg_mem`, as we always force
             // constants to be 16 bytes when a constant will be used in place of an xmm register.
             let vcode_constant = self.emit_u128_le_const(c as u128);
-            return XmmMem::new(RegMem::mem(SyntheticAmode::ConstantOffset(vcode_constant)))
-                .unwrap();
+            return XmmMem::unwrap_new(RegMem::mem(SyntheticAmode::ConstantOffset(vcode_constant)));
         }
 
-        XmmMem::new(self.put_in_reg_mem(val)).unwrap()
+        XmmMem::unwrap_new(self.put_in_reg_mem(val))
     }
 
     fn put_in_reg_mem(&mut self, val: Value) -> RegMem {
@@ -308,10 +305,9 @@ impl Context for IsleContext<'_, '_, MInst, X64Backend> {
     #[inline]
     fn const_to_type_masked_imm8(&mut self, c: u64, ty: Type) -> Imm8Gpr {
         let mask = self.shift_mask(ty) as u64;
-        Imm8Gpr::new(Imm8Reg::Imm8 {
+        Imm8Gpr::unwrap_new(Imm8Reg::Imm8 {
             imm: (c & mask) as u8,
         })
-        .unwrap()
     }
 
     #[inline]
@@ -329,18 +325,13 @@ impl Context for IsleContext<'_, '_, MInst, X64Backend> {
     fn simm32_from_value(&mut self, val: Value) -> Option<GprMemImm> {
         let inst = self.lower_ctx.dfg().value_def(val).inst()?;
         let constant: u64 = self.lower_ctx.get_constant(inst)?;
+        let ty = self.lower_ctx.dfg().value_type(val);
         let constant = constant as i64;
-        to_simm32(constant)
-    }
-
-    #[inline]
-    fn simm32_from_imm64(&mut self, imm: Imm64) -> Option<GprMemImm> {
-        to_simm32(imm.bits())
+        to_simm32(constant, ty)
     }
 
     fn sinkable_load(&mut self, val: Value) -> Option<SinkableLoad> {
-        let input = self.lower_ctx.get_value_as_source_or_const(val);
-        if let InputSourceInst::UniqueUse(inst, 0) = input.inst {
+        if let Some(inst) = self.is_sinkable_inst(val) {
             if let Some((addr_input, offset)) =
                 is_mergeable_load(self.lower_ctx, inst, MergeableLoadSize::Min32)
             {
@@ -355,8 +346,7 @@ impl Context for IsleContext<'_, '_, MInst, X64Backend> {
     }
 
     fn sinkable_load_exact(&mut self, val: Value) -> Option<SinkableLoad> {
-        let input = self.lower_ctx.get_value_as_source_or_const(val);
-        if let InputSourceInst::UniqueUse(inst, 0) = input.inst {
+        if let Some(inst) = self.is_sinkable_inst(val) {
             if let Some((addr_input, offset)) =
                 is_mergeable_load(self.lower_ctx, inst, MergeableLoadSize::Exact)
             {
@@ -464,7 +454,7 @@ impl Context for IsleContext<'_, '_, MInst, X64Backend> {
 
     #[inline]
     fn writable_reg_to_xmm(&mut self, r: WritableReg) -> WritableXmm {
-        Writable::from_reg(Xmm::new(r.to_reg()).unwrap())
+        Writable::from_reg(Xmm::unwrap_new(r.to_reg()))
     }
 
     #[inline]
@@ -494,7 +484,7 @@ impl Context for IsleContext<'_, '_, MInst, X64Backend> {
 
     #[inline]
     fn xmm_mem_to_xmm_mem_imm(&mut self, r: &XmmMem) -> XmmMemImm {
-        XmmMemImm::new(r.clone().to_reg_mem().into()).unwrap()
+        XmmMemImm::unwrap_new(r.clone().to_reg_mem().into())
     }
 
     #[inline]
@@ -514,17 +504,17 @@ impl Context for IsleContext<'_, '_, MInst, X64Backend> {
 
     #[inline]
     fn reg_mem_to_xmm_mem(&mut self, rm: &RegMem) -> XmmMem {
-        XmmMem::new(rm.clone()).unwrap()
+        XmmMem::unwrap_new(rm.clone())
     }
 
     #[inline]
     fn gpr_mem_imm_new(&mut self, rmi: &RegMemImm) -> GprMemImm {
-        GprMemImm::new(rmi.clone()).unwrap()
+        GprMemImm::unwrap_new(rmi.clone())
     }
 
     #[inline]
     fn xmm_mem_imm_new(&mut self, rmi: &RegMemImm) -> XmmMemImm {
-        XmmMemImm::new(rmi.clone()).unwrap()
+        XmmMemImm::unwrap_new(rmi.clone())
     }
 
     #[inline]
@@ -544,27 +534,27 @@ impl Context for IsleContext<'_, '_, MInst, X64Backend> {
 
     #[inline]
     fn xmm_new(&mut self, r: Reg) -> Xmm {
-        Xmm::new(r).unwrap()
+        Xmm::unwrap_new(r)
     }
 
     #[inline]
     fn gpr_new(&mut self, r: Reg) -> Gpr {
-        Gpr::new(r).unwrap()
+        Gpr::unwrap_new(r)
     }
 
     #[inline]
     fn reg_mem_to_gpr_mem(&mut self, rm: &RegMem) -> GprMem {
-        GprMem::new(rm.clone()).unwrap()
+        GprMem::unwrap_new(rm.clone())
     }
 
     #[inline]
     fn reg_to_gpr_mem(&mut self, r: Reg) -> GprMem {
-        GprMem::new(RegMem::reg(r)).unwrap()
+        GprMem::unwrap_new(RegMem::reg(r))
     }
 
     #[inline]
     fn imm8_reg_to_imm8_gpr(&mut self, ir: &Imm8Reg) -> Imm8Gpr {
-        Imm8Gpr::new(ir.clone()).unwrap()
+        Imm8Gpr::unwrap_new(ir.clone())
     }
 
     #[inline]
@@ -584,19 +574,19 @@ impl Context for IsleContext<'_, '_, MInst, X64Backend> {
 
     #[inline]
     fn imm8_to_imm8_gpr(&mut self, imm: u8) -> Imm8Gpr {
-        Imm8Gpr::new(Imm8Reg::Imm8 { imm }).unwrap()
+        Imm8Gpr::unwrap_new(Imm8Reg::Imm8 { imm })
     }
 
     fn gpr_from_imm8_gpr(&mut self, val: &Imm8Gpr) -> Option<Gpr> {
-        match val.clone().to_imm8_reg() {
-            Imm8Reg::Reg { reg } => Some(Gpr::new(reg).unwrap()),
+        match val.as_imm8_reg() {
+            &Imm8Reg::Reg { reg } => Some(Gpr::unwrap_new(reg)),
             Imm8Reg::Imm8 { .. } => None,
         }
     }
 
     fn imm8_from_imm8_gpr(&mut self, val: &Imm8Gpr) -> Option<u8> {
-        match val.clone().to_imm8_reg() {
-            Imm8Reg::Imm8 { imm } => Some(imm),
+        match val.as_imm8_reg() {
+            &Imm8Reg::Imm8 { imm } => Some(imm),
             Imm8Reg::Reg { .. } => None,
         }
     }
@@ -607,7 +597,7 @@ impl Context for IsleContext<'_, '_, MInst, X64Backend> {
             Some(RegisterClass::Gpr {
                 single_register: ty != I128,
             })
-        } else if ty == F32 || ty == F64 || (ty.is_vector() && ty.bits() == 128) {
+        } else if ty.is_float() || (ty.is_vector() && ty.bits() == 128) {
             Some(RegisterClass::Xmm)
         } else {
             None
@@ -617,17 +607,11 @@ impl Context for IsleContext<'_, '_, MInst, X64Backend> {
     #[inline]
     fn ty_int_bool_or_ref(&mut self, ty: Type) -> Option<()> {
         match ty {
-            types::I8 | types::I16 | types::I32 | types::I64 | types::R64 => Some(()),
-            types::R32 => panic!("shouldn't have 32-bits refs on x64"),
+            types::I8 | types::I16 | types::I32 | types::I64 => Some(()),
             _ => None,
         }
     }
 
-    #[inline]
-    fn intcc_without_eq(&mut self, x: &IntCC) -> IntCC {
-        x.without_equal()
-    }
-
     #[inline]
     fn intcc_to_cc(&mut self, intcc: &IntCC) -> CC {
         CC::from_intcc(*intcc)
@@ -700,57 +684,48 @@ impl Context for IsleContext<'_, '_, MInst, X64Backend> {
     }
 
     fn libcall_1(&mut self, libcall: &LibCall, a: Reg) -> Reg {
-        let call_conv = self.lower_ctx.abi().call_conv(self.lower_ctx.sigs());
-        let ret_ty = libcall.signature(call_conv, I64).returns[0].value_type;
-        let output_reg = self.lower_ctx.alloc_tmp(ret_ty).only_reg().unwrap();
-
-        emit_vm_call(
+        let outputs = emit_vm_call(
             self.lower_ctx,
             &self.backend.flags,
             &self.backend.triple,
-            libcall.clone(),
+            *libcall,
             &[a],
-            &[output_reg],
         )
         .expect("Failed to emit LibCall");
 
-        output_reg.to_reg()
+        debug_assert_eq!(outputs.len(), 1);
+
+        outputs[0]
     }
 
     fn libcall_2(&mut self, libcall: &LibCall, a: Reg, b: Reg) -> Reg {
-        let call_conv = self.lower_ctx.abi().call_conv(self.lower_ctx.sigs());
-        let ret_ty = libcall.signature(call_conv, I64).returns[0].value_type;
-        let output_reg = self.lower_ctx.alloc_tmp(ret_ty).only_reg().unwrap();
-
-        emit_vm_call(
+        let outputs = emit_vm_call(
             self.lower_ctx,
             &self.backend.flags,
             &self.backend.triple,
-            libcall.clone(),
+            *libcall,
             &[a, b],
-            &[output_reg],
         )
         .expect("Failed to emit LibCall");
 
-        output_reg.to_reg()
+        debug_assert_eq!(outputs.len(), 1);
+
+        outputs[0]
     }
 
     fn libcall_3(&mut self, libcall: &LibCall, a: Reg, b: Reg, c: Reg) -> Reg {
-        let call_conv = self.lower_ctx.abi().call_conv(self.lower_ctx.sigs());
-        let ret_ty = libcall.signature(call_conv, I64).returns[0].value_type;
-        let output_reg = self.lower_ctx.alloc_tmp(ret_ty).only_reg().unwrap();
-
-        emit_vm_call(
+        let outputs = emit_vm_call(
             self.lower_ctx,
             &self.backend.flags,
             &self.backend.triple,
-            libcall.clone(),
+            *libcall,
             &[a, b, c],
-            &[output_reg],
         )
         .expect("Failed to emit LibCall");
 
-        output_reg.to_reg()
+        debug_assert_eq!(outputs.len(), 1);
+
+        outputs[0]
     }
 
     #[inline]
@@ -1006,7 +981,7 @@ impl Context for IsleContext<'_, '_, MInst, X64Backend> {
     }
 
     fn xmi_imm(&mut self, imm: u32) -> XmmMemImm {
-        XmmMemImm::new(RegMemImm::imm(imm)).unwrap()
+        XmmMemImm::unwrap_new(RegMemImm::imm(imm))
     }
 
     fn insert_i8x16_lane_hole(&mut self, hole_idx: u8) -> VCodeConstant {
@@ -1016,16 +991,14 @@ impl Context for IsleContext<'_, '_, MInst, X64Backend> {
 }
 
 impl IsleContext<'_, '_, MInst, X64Backend> {
-    isle_prelude_method_helpers!(X64CallSite);
-
     fn load_xmm_unaligned(&mut self, addr: SyntheticAmode) -> Xmm {
         let tmp = self.lower_ctx.alloc_tmp(types::F32X4).only_reg().unwrap();
         self.lower_ctx.emit(MInst::XmmUnaryRmRUnaligned {
             op: SseOpcode::Movdqu,
-            src: XmmMem::new(RegMem::mem(addr)).unwrap(),
-            dst: Writable::from_reg(Xmm::new(tmp.to_reg()).unwrap()),
+            src: XmmMem::unwrap_new(RegMem::mem(addr)),
+            dst: Writable::from_reg(Xmm::unwrap_new(tmp.to_reg())),
         });
-        Xmm::new(tmp.to_reg()).unwrap()
+        Xmm::unwrap_new(tmp.to_reg())
     }
 }
 
@@ -1061,14 +1034,11 @@ const I8X16_USHR_MASKS: [u8; 128] = [
 ];
 
 #[inline]
-fn to_simm32(constant: i64) -> Option<GprMemImm> {
-    if constant == ((constant << 32) >> 32) {
-        Some(
-            GprMemImm::new(RegMemImm::Imm {
-                simm32: constant as u32,
-            })
-            .unwrap(),
-        )
+fn to_simm32(constant: i64, ty: Type) -> Option<GprMemImm> {
+    if ty.bits() <= 32 || constant == ((constant << 32) >> 32) {
+        Some(GprMemImm::unwrap_new(RegMemImm::Imm {
+            simm32: constant as u32,
+        }))
     } else {
         None
     }
diff --git a/cranelift/codegen/src/isa/x64/lower/isle/generated_code.rs b/cranelift/codegen/src/isa/x64/lower/isle/generated_code.rs
index a03aed0a56b7..49ec3dc4ce8d 100644
--- a/cranelift/codegen/src/isa/x64/lower/isle/generated_code.rs
+++ b/cranelift/codegen/src/isa/x64/lower/isle/generated_code.rs
@@ -8,7 +8,8 @@
     irrefutable_let_patterns,
     unused_assignments,
     non_camel_case_types,
-    missing_docs
+    missing_docs,
+    clippy::clone_on_copy
 )]
 
 include!(concat!(env!("ISLE_DIR"), "/isle_x64.rs"));
diff --git a/cranelift/codegen/src/isa/x64/mod.rs b/cranelift/codegen/src/isa/x64/mod.rs
index 75fbe2980abb..0b6371582b43 100644
--- a/cranelift/codegen/src/isa/x64/mod.rs
+++ b/cranelift/codegen/src/isa/x64/mod.rs
@@ -15,6 +15,7 @@ use crate::machinst::{
 };
 use crate::result::CodegenResult;
 use crate::settings::{self as shared_settings, Flags};
+use crate::{Final, MachBufferFinalized};
 use alloc::{boxed::Box, vec::Vec};
 use core::fmt;
 use cranelift_control::ControlPlane;
@@ -24,8 +25,11 @@ mod abi;
 pub mod encoding;
 mod inst;
 mod lower;
+mod pcc;
 pub mod settings;
 
+pub use inst::unwind::systemv::create_cie;
+
 /// An X64 backend.
 pub(crate) struct X64Backend {
     triple: Triple,
@@ -117,26 +121,7 @@ impl TargetIsa for X64Backend {
         result: &CompiledCode,
         kind: crate::isa::unwind::UnwindInfoKind,
     ) -> CodegenResult<Option<crate::isa::unwind::UnwindInfo>> {
-        use crate::isa::unwind::UnwindInfo;
-        use crate::isa::unwind::UnwindInfoKind;
-        Ok(match kind {
-            UnwindInfoKind::SystemV => {
-                let mapper = self::inst::unwind::systemv::RegisterMapper;
-                Some(UnwindInfo::SystemV(
-                    crate::isa::unwind::systemv::create_unwind_info_from_insts(
-                        &result.buffer.unwind_info[..],
-                        result.buffer.data().len(),
-                        &mapper,
-                    )?,
-                ))
-            }
-            UnwindInfoKind::Windows => Some(UnwindInfo::WindowsX64(
-                crate::isa::unwind::winx64::create_unwind_info_from_insts::<
-                    self::inst::unwind::winx64::RegisterMapper,
-                >(&result.buffer.unwind_info[..])?,
-            )),
-            _ => None,
-        })
+        emit_unwind_info(&result.buffer, kind)
     }
 
     #[cfg(feature = "unwind")]
@@ -157,6 +142,11 @@ impl TargetIsa for X64Backend {
         Inst::function_alignment()
     }
 
+    fn page_size_align_log2(&self) -> u8 {
+        debug_assert_eq!(1 << 12, 0x1000);
+        12
+    }
+
     #[cfg(feature = "disas")]
     fn to_capstone(&self) -> Result<capstone::Capstone, capstone::Error> {
         use capstone::prelude::*;
@@ -164,6 +154,7 @@ impl TargetIsa for X64Backend {
             .x86()
             .mode(arch::x86::ArchMode::Mode64)
             .syntax(arch::x86::ArchSyntax::Att)
+            .detail(true)
             .build()
     }
 
@@ -192,6 +183,32 @@ impl TargetIsa for X64Backend {
     }
 }
 
+/// Emit unwind info for an x86 target.
+pub fn emit_unwind_info(
+    buffer: &MachBufferFinalized<Final>,
+    kind: crate::isa::unwind::UnwindInfoKind,
+) -> CodegenResult<Option<crate::isa::unwind::UnwindInfo>> {
+    use crate::isa::unwind::{UnwindInfo, UnwindInfoKind};
+    Ok(match kind {
+        UnwindInfoKind::SystemV => {
+            let mapper = self::inst::unwind::systemv::RegisterMapper;
+            Some(UnwindInfo::SystemV(
+                crate::isa::unwind::systemv::create_unwind_info_from_insts(
+                    &buffer.unwind_info[..],
+                    buffer.data().len(),
+                    &mapper,
+                )?,
+            ))
+        }
+        UnwindInfoKind::Windows => Some(UnwindInfo::WindowsX64(
+            crate::isa::unwind::winx64::create_unwind_info_from_insts::<
+                self::inst::unwind::winx64::RegisterMapper,
+            >(&buffer.unwind_info[..])?,
+        )),
+        _ => None,
+    })
+}
+
 impl fmt::Display for X64Backend {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_struct("MachBackend")
diff --git a/cranelift/codegen/src/isa/x64/pcc.rs b/cranelift/codegen/src/isa/x64/pcc.rs
new file mode 100644
index 000000000000..402c16301432
--- /dev/null
+++ b/cranelift/codegen/src/isa/x64/pcc.rs
@@ -0,0 +1,1016 @@
+//! Proof-carrying-code validation for x64 VCode.
+
+use crate::ir::pcc::*;
+use crate::ir::types::*;
+use crate::isa::x64::args::AvxOpcode;
+use crate::isa::x64::inst::args::{
+    AluRmiROpcode, Amode, Gpr, Imm8Reg, RegMem, RegMemImm, ShiftKind, SseOpcode, SyntheticAmode,
+    ToWritableReg, CC,
+};
+use crate::isa::x64::inst::Inst;
+use crate::machinst::pcc::*;
+use crate::machinst::{InsnIndex, VCode, VCodeConstantData};
+use crate::machinst::{Reg, Writable};
+use crate::trace;
+
+fn undefined_result(
+    ctx: &FactContext,
+    vcode: &mut VCode<Inst>,
+    dst: Writable<Gpr>,
+    reg_bits: u16,
+    result_bits: u16,
+) -> PccResult<()> {
+    check_output(ctx, vcode, dst.to_writable_reg(), &[], |_vcode| {
+        clamp_range(ctx, reg_bits, result_bits, None)
+    })
+}
+
+fn ensure_no_fact(vcode: &VCode<Inst>, reg: Reg) -> PccResult<()> {
+    if vcode.vreg_fact(reg.into()).is_some() {
+        Err(PccError::UnsupportedFact)
+    } else {
+        Ok(())
+    }
+}
+
+/// Flow-state between facts.
+#[derive(Clone, Debug, Default)]
+pub(crate) struct FactFlowState {
+    cmp_flags: Option<(Fact, Fact)>,
+}
+
+pub(crate) fn check(
+    ctx: &FactContext,
+    vcode: &mut VCode<Inst>,
+    inst_idx: InsnIndex,
+    state: &mut FactFlowState,
+) -> PccResult<()> {
+    trace!("Checking facts on inst: {:?}", vcode[inst_idx]);
+
+    // We only persist flag state for one instruction, because we
+    // can't exhaustively enumerate all flags-effecting ops; so take
+    // the `cmp_state` here and perhaps use it below but don't let it
+    // remain.
+    let cmp_flags = state.cmp_flags.take();
+
+    match vcode[inst_idx] {
+        Inst::Nop { .. } => Ok(()),
+
+        Inst::Args { .. } => {
+            // Defs on the args have "axiomatic facts": we trust the
+            // ABI code to pass through the values unharmed, so the
+            // facts given to us in the CLIF should still be true.
+            Ok(())
+        }
+
+        Inst::AluRmiR {
+            size,
+            op: AluRmiROpcode::Add,
+            src1,
+            ref src2,
+            dst,
+        } => match *<&RegMemImm>::from(src2) {
+            RegMemImm::Reg { reg: src2 } => {
+                let bits = size.to_bits().into();
+                check_binop(
+                    ctx,
+                    vcode,
+                    64,
+                    dst.to_writable_reg(),
+                    src1.to_reg(),
+                    src2,
+                    |src1, src2| clamp_range(ctx, 64, bits, ctx.add(src1, src2, bits)),
+                )
+            }
+            RegMemImm::Imm { simm32 } => {
+                let bits = size.to_bits().into();
+                check_unop(
+                    ctx,
+                    vcode,
+                    64,
+                    dst.to_writable_reg(),
+                    src1.to_reg(),
+                    |src1| {
+                        let simm32: i64 = simm32.into();
+                        clamp_range(ctx, 64, bits, ctx.offset(src1, bits, simm32))
+                    },
+                )
+            }
+            RegMemImm::Mem { ref addr } => {
+                let bits: u16 = size.to_bits().into();
+                let loaded = check_load(ctx, None, addr, vcode, size.to_type(), bits)?;
+                check_unop(ctx, vcode, 64, dst.to_writable_reg(), src1.into(), |src1| {
+                    let sum = loaded.and_then(|loaded| ctx.add(src1, &loaded, bits));
+                    clamp_range(ctx, 64, bits, sum)
+                })
+            }
+        },
+
+        Inst::AluRmiR {
+            size,
+            op: AluRmiROpcode::Sub,
+            src1,
+            ref src2,
+            dst,
+        } => match *<&RegMemImm>::from(src2) {
+            RegMemImm::Imm { simm32 } => {
+                let bits = size.to_bits().into();
+                check_unop(
+                    ctx,
+                    vcode,
+                    64,
+                    dst.to_writable_reg(),
+                    src1.to_reg(),
+                    |src1| {
+                        let simm32: i64 = simm32.into();
+                        clamp_range(ctx, 64, bits, ctx.offset(src1, bits, -simm32))
+                    },
+                )
+            }
+            RegMemImm::Reg { .. } => {
+                let bits: u16 = size.to_bits().into();
+                check_output(ctx, vcode, dst.to_writable_reg(), &[], |_vcode| {
+                    clamp_range(ctx, 64, bits, None)
+                })
+            }
+            RegMemImm::Mem { ref addr } => {
+                let loaded = check_load(ctx, None, addr, vcode, size.to_type(), 64)?;
+                check_output(ctx, vcode, dst.to_writable_reg(), &[], |_vcode| {
+                    clamp_range(ctx, 64, size.to_bits().into(), loaded)
+                })
+            }
+        },
+
+        Inst::AluRmiR {
+            size,
+            ref src2,
+            dst,
+            ..
+        } => match <&RegMemImm>::from(src2) {
+            RegMemImm::Mem { ref addr } => {
+                let loaded = check_load(ctx, None, addr, vcode, size.to_type(), 64)?;
+                check_output(ctx, vcode, dst.to_writable_reg(), &[], |_vcode| {
+                    clamp_range(ctx, 64, size.to_bits().into(), loaded)
+                })
+            }
+            RegMemImm::Reg { .. } | RegMemImm::Imm { .. } => {
+                undefined_result(ctx, vcode, dst, 64, size.to_bits().into())
+            }
+        },
+
+        Inst::AluRM {
+            size,
+            op: _,
+            ref src1_dst,
+            src2: _,
+        } => {
+            check_load(ctx, None, src1_dst, vcode, size.to_type(), 64)?;
+            check_store(ctx, None, src1_dst, vcode, size.to_type())
+        }
+
+        Inst::AluRmRVex {
+            size,
+            ref src2,
+            dst,
+            ..
+        } => match <&RegMem>::from(src2) {
+            RegMem::Mem { ref addr } => {
+                let loaded = check_load(ctx, None, addr, vcode, size.to_type(), 64)?;
+                check_output(ctx, vcode, dst.to_writable_reg(), &[], |_vcode| {
+                    clamp_range(ctx, 64, size.to_bits().into(), loaded)
+                })
+            }
+            RegMem::Reg { .. } => undefined_result(ctx, vcode, dst, 64, size.to_bits().into()),
+        },
+
+        Inst::AluConstOp {
+            op: AluRmiROpcode::Xor,
+            dst,
+            ..
+        } => check_output(ctx, vcode, dst.to_writable_reg(), &[], |_vcode| {
+            Ok(Some(Fact::constant(64, 0)))
+        }),
+
+        Inst::AluConstOp { dst, .. } => undefined_result(ctx, vcode, dst, 64, 64),
+
+        Inst::UnaryRmR {
+            size, ref src, dst, ..
+        }
+        | Inst::UnaryRmRVex {
+            size, ref src, dst, ..
+        }
+        | Inst::UnaryRmRImmVex {
+            size, ref src, dst, ..
+        } => match <&RegMem>::from(src) {
+            RegMem::Mem { ref addr } => {
+                check_load(ctx, None, addr, vcode, size.to_type(), 64)?;
+                check_output(ctx, vcode, dst.to_writable_reg(), &[], |_vcode| {
+                    clamp_range(ctx, 64, size.to_bits().into(), None)
+                })
+            }
+            RegMem::Reg { .. } => undefined_result(ctx, vcode, dst, 64, size.to_bits().into()),
+        },
+
+        Inst::Not { size, dst, .. } | Inst::Neg { size, dst, .. } => {
+            undefined_result(ctx, vcode, dst, 64, size.to_bits().into())
+        }
+
+        Inst::Div {
+            size,
+            ref divisor,
+            dst_quotient,
+            dst_remainder,
+            ..
+        } => {
+            match <&RegMem>::from(divisor) {
+                RegMem::Mem { ref addr } => {
+                    check_load(ctx, None, addr, vcode, size.to_type(), 64)?;
+                }
+                RegMem::Reg { .. } => {}
+            }
+            undefined_result(ctx, vcode, dst_quotient, 64, 64)?;
+            undefined_result(ctx, vcode, dst_remainder, 64, 64)?;
+            Ok(())
+        }
+        Inst::Div8 {
+            dst, ref divisor, ..
+        } => {
+            match <&RegMem>::from(divisor) {
+                RegMem::Mem { ref addr } => {
+                    check_load(ctx, None, addr, vcode, I8, 64)?;
+                }
+                RegMem::Reg { .. } => {}
+            }
+            // 64-bit result width because result may be negative
+            // hence high bits set.
+            undefined_result(ctx, vcode, dst, 64, 64)?;
+            Ok(())
+        }
+        Inst::Mul {
+            size,
+            dst_lo,
+            dst_hi,
+            ref src2,
+            ..
+        } => {
+            match <&RegMem>::from(src2) {
+                RegMem::Mem { ref addr } => {
+                    check_load(ctx, None, addr, vcode, size.to_type(), 64)?;
+                }
+                RegMem::Reg { .. } => {}
+            }
+            undefined_result(ctx, vcode, dst_lo, 64, size.to_bits().into())?;
+            undefined_result(ctx, vcode, dst_hi, 64, size.to_bits().into())?;
+            Ok(())
+        }
+        Inst::Mul8 { dst, ref src2, .. } => {
+            match <&RegMem>::from(src2) {
+                RegMem::Mem { ref addr } => {
+                    check_load(ctx, None, addr, vcode, I8, 64)?;
+                }
+                RegMem::Reg { .. } => {}
+            }
+            undefined_result(ctx, vcode, dst, 64, 16)?;
+            Ok(())
+        }
+        Inst::IMul {
+            size,
+            dst,
+            ref src2,
+            ..
+        } => {
+            match <&RegMem>::from(src2) {
+                RegMem::Mem { ref addr } => {
+                    check_load(ctx, None, addr, vcode, size.to_type(), 64)?;
+                }
+                RegMem::Reg { .. } => {}
+            }
+            undefined_result(ctx, vcode, dst, 64, size.to_bits().into())?;
+            Ok(())
+        }
+        Inst::IMulImm {
+            size,
+            dst,
+            ref src1,
+            ..
+        } => {
+            match <&RegMem>::from(src1) {
+                RegMem::Mem { ref addr } => {
+                    check_load(ctx, None, addr, vcode, size.to_type(), 64)?;
+                }
+                RegMem::Reg { .. } => {}
+            }
+            undefined_result(ctx, vcode, dst, 64, size.to_bits().into())?;
+            Ok(())
+        }
+        Inst::CheckedSRemSeq {
+            dst_quotient,
+            dst_remainder,
+            ..
+        } => {
+            undefined_result(ctx, vcode, dst_quotient, 64, 64)?;
+            undefined_result(ctx, vcode, dst_remainder, 64, 64)?;
+            Ok(())
+        }
+
+        Inst::CheckedSRemSeq8 { dst, .. } => undefined_result(ctx, vcode, dst, 64, 64),
+
+        Inst::SignExtendData { dst, .. } => undefined_result(ctx, vcode, dst, 64, 64),
+
+        Inst::Imm { simm64, dst, .. } => {
+            check_output(ctx, vcode, dst.to_writable_reg(), &[], |_vcode| {
+                Ok(Some(Fact::constant(64, simm64)))
+            })
+        }
+
+        Inst::MovRR { size, dst, .. } => {
+            undefined_result(ctx, vcode, dst, 64, size.to_bits().into())
+        }
+
+        Inst::MovFromPReg { dst, .. } => undefined_result(ctx, vcode, dst, 64, 64),
+        Inst::MovToPReg { .. } => Ok(()),
+
+        Inst::MovzxRmR {
+            ref ext_mode,
+            ref src,
+            dst,
+        } => {
+            let from_bytes: u16 = ext_mode.src_size().into();
+            let to_bytes: u16 = ext_mode.dst_size().into();
+            match <&RegMem>::from(src) {
+                RegMem::Reg { reg } => {
+                    check_unop(ctx, vcode, 64, dst.to_writable_reg(), *reg, |src| {
+                        clamp_range(ctx, 64, from_bytes * 8, Some(src.clone()))
+                    })
+                }
+                RegMem::Mem { ref addr } => {
+                    let loaded = check_load(
+                        ctx,
+                        Some(dst.to_writable_reg()),
+                        addr,
+                        vcode,
+                        ext_mode.src_type(),
+                        64,
+                    )?;
+                    check_output(ctx, vcode, dst.to_writable_reg(), &[], |_vcode| {
+                        let extended = loaded
+                            .and_then(|loaded| ctx.uextend(&loaded, from_bytes * 8, to_bytes * 8));
+                        clamp_range(ctx, 64, from_bytes * 8, extended)
+                    })
+                }
+            }
+        }
+
+        Inst::Mov64MR { ref src, dst } => {
+            check_load(ctx, Some(dst.to_writable_reg()), src, vcode, I64, 64)?;
+            Ok(())
+        }
+
+        Inst::LoadEffectiveAddress {
+            ref addr,
+            dst,
+            size,
+        } => {
+            let addr = addr.clone();
+            let bits: u16 = size.to_bits().into();
+            check_output(ctx, vcode, dst.to_writable_reg(), &[], |vcode| {
+                let fact = if let SyntheticAmode::Real(amode) = &addr {
+                    compute_addr(ctx, vcode, amode, bits)
+                } else {
+                    None
+                };
+                clamp_range(ctx, 64, bits, fact)
+            })
+        }
+
+        Inst::MovsxRmR {
+            ref ext_mode,
+            ref src,
+            dst,
+        } => {
+            match <&RegMem>::from(src) {
+                RegMem::Mem { ref addr } => {
+                    check_load(ctx, None, addr, vcode, ext_mode.src_type(), 64)?;
+                }
+                RegMem::Reg { .. } => {}
+            }
+            undefined_result(ctx, vcode, dst, 64, 64)
+        }
+
+        Inst::MovImmM { size, ref dst, .. } => check_store(ctx, None, dst, vcode, size.to_type()),
+
+        Inst::MovRM { size, src, ref dst } => {
+            check_store(ctx, Some(src.to_reg()), dst, vcode, size.to_type())
+        }
+
+        Inst::ShiftR {
+            size,
+            kind: ShiftKind::ShiftLeft,
+            src,
+            ref num_bits,
+            dst,
+        } => match num_bits.as_imm8_reg() {
+            &Imm8Reg::Imm8 { imm } => {
+                check_unop(ctx, vcode, 64, dst.to_writable_reg(), src.to_reg(), |src| {
+                    clamp_range(
+                        ctx,
+                        64,
+                        size.to_bits().into(),
+                        ctx.shl(src, size.to_bits().into(), imm.into()),
+                    )
+                })
+            }
+            Imm8Reg::Reg { .. } => undefined_result(ctx, vcode, dst, 64, size.to_bits().into()),
+        },
+
+        Inst::ShiftR { size, dst, .. } => {
+            undefined_result(ctx, vcode, dst, 64, size.to_bits().into())
+        }
+
+        Inst::XmmRmiReg { dst, ref src2, .. } => {
+            match <&RegMemImm>::from(src2) {
+                RegMemImm::Mem { ref addr } => {
+                    check_load(ctx, None, addr, vcode, I8X16, 128)?;
+                }
+                _ => {}
+            }
+            ensure_no_fact(vcode, dst.to_writable_reg().to_reg())
+        }
+
+        Inst::CmpRmiR {
+            size,
+            src1,
+            ref src2,
+            ..
+        } => match <&RegMemImm>::from(src2) {
+            RegMemImm::Mem {
+                addr: SyntheticAmode::ConstantOffset(k),
+            } => {
+                match vcode.constants.get(*k) {
+                    VCodeConstantData::U64(bytes) => {
+                        let value = u64::from_le_bytes(*bytes);
+                        let lhs = get_fact_or_default(vcode, src1.to_reg(), 64);
+                        let rhs = Fact::constant(64, value);
+                        state.cmp_flags = Some((lhs, rhs));
+                    }
+                    _ => {}
+                }
+                Ok(())
+            }
+            RegMemImm::Mem { ref addr } => {
+                if let Some(rhs) = check_load(ctx, None, addr, vcode, size.to_type(), 64)? {
+                    let lhs = get_fact_or_default(vcode, src1.to_reg(), 64);
+                    state.cmp_flags = Some((lhs, rhs));
+                }
+                Ok(())
+            }
+            RegMemImm::Reg { reg } => {
+                let rhs = get_fact_or_default(vcode, *reg, 64);
+                let lhs = get_fact_or_default(vcode, src1.to_reg(), 64);
+                state.cmp_flags = Some((lhs, rhs));
+                Ok(())
+            }
+            RegMemImm::Imm { simm32 } => {
+                let lhs = get_fact_or_default(vcode, src1.to_reg(), 64);
+                let rhs = Fact::constant(64, (*simm32 as i32) as i64 as u64);
+                state.cmp_flags = Some((lhs, rhs));
+                Ok(())
+            }
+        },
+
+        Inst::Setcc { dst, .. } => undefined_result(ctx, vcode, dst, 64, 64),
+
+        Inst::Bswap { dst, .. } => undefined_result(ctx, vcode, dst, 64, 64),
+
+        Inst::Cmove {
+            size,
+            dst,
+            ref consequent,
+            alternative,
+            cc,
+            ..
+        } => match <&RegMem>::from(consequent) {
+            RegMem::Mem { ref addr } => {
+                check_load(ctx, None, addr, vcode, size.to_type(), 64)?;
+                Ok(())
+            }
+            RegMem::Reg { reg } if (cc == CC::NB || cc == CC::NBE) && cmp_flags.is_some() => {
+                let (cmp_lhs, cmp_rhs) = cmp_flags.unwrap();
+                trace!("lhs = {:?} rhs = {:?}", cmp_lhs, cmp_rhs);
+                let reg = *reg;
+                check_output(ctx, vcode, dst.to_writable_reg(), &[], |vcode| {
+                    // See comments in aarch64::pcc CSel for more details on this.
+                    let in_true = get_fact_or_default(vcode, reg, 64);
+                    let in_true_kind = match cc {
+                        CC::NB => InequalityKind::Loose,
+                        CC::NBE => InequalityKind::Strict,
+                        _ => unreachable!(),
+                    };
+                    let in_true = ctx.apply_inequality(&in_true, &cmp_lhs, &cmp_rhs, in_true_kind);
+                    let in_false = get_fact_or_default(vcode, alternative.to_reg(), 64);
+                    let in_false_kind = match cc {
+                        CC::NB => InequalityKind::Strict,
+                        CC::NBE => InequalityKind::Loose,
+                        _ => unreachable!(),
+                    };
+                    let in_false =
+                        ctx.apply_inequality(&in_false, &cmp_rhs, &cmp_lhs, in_false_kind);
+                    let union = ctx.union(&in_true, &in_false);
+                    clamp_range(ctx, 64, 64, union)
+                })
+            }
+            _ => undefined_result(ctx, vcode, dst, 64, 64),
+        },
+
+        Inst::XmmCmove { dst, .. } => ensure_no_fact(vcode, dst.to_writable_reg().to_reg()),
+
+        Inst::Push64 { ref src } => match <&RegMemImm>::from(src) {
+            RegMemImm::Mem { ref addr } => {
+                check_load(ctx, None, addr, vcode, I64, 64)?;
+                Ok(())
+            }
+            RegMemImm::Reg { .. } | RegMemImm::Imm { .. } => Ok(()),
+        },
+
+        Inst::Pop64 { dst } => undefined_result(ctx, vcode, dst, 64, 64),
+
+        Inst::StackProbeLoop { tmp, .. } => ensure_no_fact(vcode, tmp.to_reg()),
+
+        Inst::XmmRmR { dst, ref src2, .. }
+        | Inst::XmmRmRBlend { dst, ref src2, .. }
+        | Inst::XmmUnaryRmR {
+            dst, src: ref src2, ..
+        }
+        | Inst::XmmUnaryRmRImm {
+            dst, src: ref src2, ..
+        } => {
+            match <&RegMem>::from(src2) {
+                RegMem::Mem { ref addr } => {
+                    check_load(ctx, None, addr, vcode, I8X16, 128)?;
+                }
+                RegMem::Reg { .. } => {}
+            }
+            ensure_no_fact(vcode, dst.to_writable_reg().to_reg())
+        }
+
+        Inst::XmmUnaryRmRUnaligned {
+            dst,
+            ref src,
+            op: SseOpcode::Movss,
+            ..
+        } => {
+            match <&RegMem>::from(src) {
+                RegMem::Mem { ref addr } => {
+                    check_load(ctx, None, addr, vcode, F32, 32)?;
+                }
+                RegMem::Reg { .. } => {}
+            }
+            ensure_no_fact(vcode, dst.to_writable_reg().to_reg())
+        }
+        Inst::XmmUnaryRmRUnaligned {
+            dst,
+            ref src,
+            op: SseOpcode::Movsd,
+            ..
+        } => {
+            match <&RegMem>::from(src) {
+                RegMem::Mem { ref addr } => {
+                    check_load(ctx, None, addr, vcode, F64, 64)?;
+                }
+                RegMem::Reg { .. } => {}
+            }
+            ensure_no_fact(vcode, dst.to_writable_reg().to_reg())
+        }
+
+        // NOTE: it's assumed that all of these cases perform 128-bit loads, but this hasn't been
+        // verified. The effect of this will be spurious PCC failures when these instructions are
+        // involved.
+        Inst::XmmRmRUnaligned { dst, ref src2, .. }
+        | Inst::XmmRmREvex { dst, ref src2, .. }
+        | Inst::XmmUnaryRmRImmEvex {
+            dst, src: ref src2, ..
+        }
+        | Inst::XmmUnaryRmRUnaligned {
+            dst, src: ref src2, ..
+        }
+        | Inst::XmmUnaryRmREvex {
+            dst, src: ref src2, ..
+        }
+        | Inst::XmmRmREvex3 {
+            dst,
+            src3: ref src2,
+            ..
+        } => {
+            match <&RegMem>::from(src2) {
+                RegMem::Mem { ref addr } => {
+                    check_load(ctx, None, addr, vcode, I8X16, 128)?;
+                }
+                RegMem::Reg { .. } => {}
+            }
+            ensure_no_fact(vcode, dst.to_writable_reg().to_reg())
+        }
+
+        Inst::XmmRmRImmVex {
+            op, dst, ref src2, ..
+        }
+        | Inst::XmmRmRVex3 {
+            op,
+            dst,
+            src3: ref src2,
+            ..
+        }
+        | Inst::XmmRmRBlendVex {
+            op, dst, ref src2, ..
+        }
+        | Inst::XmmUnaryRmRVex {
+            op,
+            dst,
+            src: ref src2,
+            ..
+        }
+        | Inst::XmmUnaryRmRImmVex {
+            op,
+            dst,
+            src: ref src2,
+            ..
+        } => {
+            let (ty, size) = match op {
+                AvxOpcode::Vmovss => (F32, 32),
+                AvxOpcode::Vmovsd => (F64, 64),
+                AvxOpcode::Vpinsrb => (I8, 8),
+                AvxOpcode::Vpinsrw => (I16, 16),
+                AvxOpcode::Vpinsrd => (I32, 32),
+                AvxOpcode::Vpinsrq => (I64, 64),
+
+                // We assume all other operations happen on 128-bit values.
+                _ => (I8X16, 128),
+            };
+
+            match <&RegMem>::from(src2) {
+                RegMem::Mem { ref addr } => {
+                    check_load(ctx, None, addr, vcode, ty, size)?;
+                }
+                RegMem::Reg { .. } => {}
+            }
+            ensure_no_fact(vcode, dst.to_writable_reg().to_reg())
+        }
+
+        Inst::XmmRmiRVex { dst, ref src2, .. } => {
+            match <&RegMemImm>::from(src2) {
+                RegMemImm::Mem { ref addr } => {
+                    check_load(ctx, None, addr, vcode, I8X16, 128)?;
+                }
+                RegMemImm::Reg { .. } | RegMemImm::Imm { .. } => {}
+            }
+            ensure_no_fact(vcode, dst.to_writable_reg().to_reg())
+        }
+
+        Inst::XmmVexPinsr { dst, ref src2, .. } => {
+            match <&RegMem>::from(src2) {
+                RegMem::Mem { ref addr } => {
+                    check_load(ctx, None, addr, vcode, I64, 64)?;
+                }
+                RegMem::Reg { .. } => {}
+            }
+            ensure_no_fact(vcode, dst.to_writable_reg().to_reg())
+        }
+
+        Inst::XmmMovRMVex { ref dst, .. } | Inst::XmmMovRMImmVex { ref dst, .. } => {
+            check_store(ctx, None, dst, vcode, I8X16)
+        }
+
+        Inst::XmmToGprImmVex { dst, .. } => ensure_no_fact(vcode, dst.to_writable_reg().to_reg()),
+
+        Inst::GprToXmmVex { dst, ref src, .. } | Inst::GprToXmm { dst, ref src, .. } => {
+            match <&RegMem>::from(src) {
+                RegMem::Mem { ref addr } => {
+                    check_load(ctx, None, addr, vcode, I64, 64)?;
+                }
+                RegMem::Reg { .. } => {}
+            }
+            ensure_no_fact(vcode, dst.to_writable_reg().to_reg())
+        }
+
+        Inst::XmmToGprVex { dst, .. } => undefined_result(ctx, vcode, dst, 64, 64),
+
+        Inst::XmmMovRM {
+            ref dst,
+            op: SseOpcode::Movss,
+            ..
+        } => {
+            check_store(ctx, None, dst, vcode, F32)?;
+            Ok(())
+        }
+
+        Inst::XmmMovRM {
+            ref dst,
+            op: SseOpcode::Movsd,
+            ..
+        } => {
+            check_store(ctx, None, dst, vcode, F64)?;
+            Ok(())
+        }
+
+        Inst::XmmMovRM { ref dst, .. } | Inst::XmmMovRMImm { ref dst, .. } => {
+            check_store(ctx, None, dst, vcode, I8X16)?;
+            Ok(())
+        }
+
+        Inst::XmmToGpr { dst, .. } | Inst::XmmToGprImm { dst, .. } => {
+            undefined_result(ctx, vcode, dst, 64, 64)
+        }
+
+        Inst::CvtIntToFloat { dst, ref src2, .. }
+        | Inst::CvtIntToFloatVex { dst, ref src2, .. } => {
+            match <&RegMem>::from(src2) {
+                RegMem::Mem { ref addr } => {
+                    check_load(ctx, None, addr, vcode, I64, 64)?;
+                }
+                RegMem::Reg { .. } => {}
+            }
+            ensure_no_fact(vcode, dst.to_writable_reg().to_reg())
+        }
+
+        Inst::CvtUint64ToFloatSeq {
+            dst,
+            tmp_gpr1,
+            tmp_gpr2,
+            ..
+        } => {
+            ensure_no_fact(vcode, dst.to_writable_reg().to_reg())?;
+            ensure_no_fact(vcode, tmp_gpr1.to_writable_reg().to_reg())?;
+            ensure_no_fact(vcode, tmp_gpr2.to_writable_reg().to_reg())?;
+            Ok(())
+        }
+
+        Inst::CvtFloatToSintSeq {
+            dst,
+            tmp_gpr,
+            tmp_xmm,
+            ..
+        } => {
+            undefined_result(ctx, vcode, dst, 64, 64)?;
+            ensure_no_fact(vcode, tmp_gpr.to_writable_reg().to_reg())?;
+            ensure_no_fact(vcode, tmp_xmm.to_writable_reg().to_reg())?;
+            Ok(())
+        }
+
+        Inst::CvtFloatToUintSeq {
+            dst,
+            tmp_gpr,
+            tmp_xmm,
+            tmp_xmm2,
+            ..
+        } => {
+            undefined_result(ctx, vcode, dst, 64, 64)?;
+            ensure_no_fact(vcode, tmp_gpr.to_writable_reg().to_reg())?;
+            ensure_no_fact(vcode, tmp_xmm.to_writable_reg().to_reg())?;
+            ensure_no_fact(vcode, tmp_xmm2.to_writable_reg().to_reg())?;
+            Ok(())
+        }
+
+        Inst::XmmMinMaxSeq { dst, .. } => ensure_no_fact(vcode, dst.to_writable_reg().to_reg()),
+
+        Inst::XmmCmpRmR {
+            ref src1, ref src2, ..
+        } => {
+            match <&RegMem>::from(src2) {
+                RegMem::Mem { ref addr } => {
+                    check_load(ctx, None, addr, vcode, I8X16, 128)?;
+                }
+                RegMem::Reg { .. } => {}
+            }
+            ensure_no_fact(vcode, src1.to_reg())
+        }
+
+        Inst::XmmRmRImm {
+            dst,
+            ref src2,
+            size,
+            op,
+            ..
+        } if op.has_scalar_src2() => {
+            match <&RegMem>::from(src2) {
+                RegMem::Mem { ref addr } => {
+                    check_load(
+                        ctx,
+                        None,
+                        addr,
+                        vcode,
+                        size.to_type(),
+                        size.to_bits().into(),
+                    )?;
+                }
+                RegMem::Reg { .. } => {}
+            }
+            ensure_no_fact(vcode, dst.to_reg())
+        }
+
+        Inst::XmmRmRImm { dst, ref src2, .. } => {
+            match <&RegMem>::from(src2) {
+                RegMem::Mem { ref addr } => {
+                    check_load(ctx, None, addr, vcode, I8X16, 128)?;
+                }
+                RegMem::Reg { .. } => {}
+            }
+            ensure_no_fact(vcode, dst.to_reg())
+        }
+
+        Inst::XmmCmpRmRVex {
+            ref src1, ref src2, ..
+        } => {
+            match <&RegMem>::from(src2) {
+                RegMem::Mem { ref addr } => {
+                    check_load(ctx, None, addr, vcode, F32, 32)?;
+                }
+                RegMem::Reg { .. } => {}
+            }
+            ensure_no_fact(vcode, src1.to_reg())
+        }
+
+        Inst::CallKnown { .. }
+        | Inst::ReturnCallKnown { .. }
+        | Inst::JmpKnown { .. }
+        | Inst::Ret { .. }
+        | Inst::JmpIf { .. }
+        | Inst::JmpCond { .. }
+        | Inst::TrapIf { .. }
+        | Inst::TrapIfAnd { .. }
+        | Inst::TrapIfOr { .. }
+        | Inst::Hlt {}
+        | Inst::Ud2 { .. } => Ok(()),
+        Inst::Rets { .. } => Ok(()),
+
+        Inst::ReturnCallUnknown { .. } => Ok(()),
+
+        Inst::CallUnknown { ref dest, .. }
+        | Inst::JmpUnknown {
+            target: ref dest, ..
+        } => match <&RegMem>::from(dest) {
+            RegMem::Mem { ref addr } => {
+                check_load(ctx, None, addr, vcode, I64, 64)?;
+                Ok(())
+            }
+            RegMem::Reg { .. } => Ok(()),
+        },
+
+        Inst::JmpTableSeq { tmp1, tmp2, .. } => {
+            ensure_no_fact(vcode, tmp1.to_reg())?;
+            ensure_no_fact(vcode, tmp2.to_reg())?;
+            Ok(())
+        }
+
+        Inst::LoadExtName { dst, .. } => {
+            ensure_no_fact(vcode, dst.to_reg())?;
+            Ok(())
+        }
+
+        Inst::LockCmpxchg {
+            ref mem, dst_old, ..
+        } => {
+            ensure_no_fact(vcode, dst_old.to_reg())?;
+            check_store(ctx, None, mem, vcode, I64)?;
+            Ok(())
+        }
+
+        Inst::AtomicRmwSeq {
+            ref mem,
+            temp,
+            dst_old,
+            ..
+        } => {
+            ensure_no_fact(vcode, dst_old.to_reg())?;
+            ensure_no_fact(vcode, temp.to_reg())?;
+            check_store(ctx, None, mem, vcode, I64)?;
+            Ok(())
+        }
+
+        Inst::Fence { .. } => Ok(()),
+
+        Inst::XmmUninitializedValue { dst } => {
+            ensure_no_fact(vcode, dst.to_writable_reg().to_reg())
+        }
+
+        Inst::ElfTlsGetAddr { dst, .. } | Inst::MachOTlsGetAddr { dst, .. } => {
+            ensure_no_fact(vcode, dst.to_writable_reg().to_reg())
+        }
+        Inst::CoffTlsGetAddr { dst, tmp, .. } => {
+            ensure_no_fact(vcode, dst.to_writable_reg().to_reg())?;
+            ensure_no_fact(vcode, tmp.to_writable_reg().to_reg())?;
+            Ok(())
+        }
+
+        Inst::Unwind { .. } | Inst::DummyUse { .. } => Ok(()),
+
+        Inst::StackSwitchBasic { .. } => Err(PccError::UnimplementedInst),
+    }
+}
+
+fn check_load(
+    ctx: &FactContext,
+    dst: Option<Writable<Reg>>,
+    src: &SyntheticAmode,
+    vcode: &VCode<Inst>,
+    ty: Type,
+    to_bits: u16,
+) -> PccResult<Option<Fact>> {
+    let result_fact = dst.and_then(|dst| vcode.vreg_fact(dst.to_reg().into()));
+    let from_bits = u16::try_from(ty.bits()).unwrap();
+    check_mem(
+        ctx,
+        src,
+        vcode,
+        ty,
+        LoadOrStore::Load {
+            result_fact,
+            from_bits,
+            to_bits,
+        },
+    )
+}
+
+fn check_store(
+    ctx: &FactContext,
+    data: Option<Reg>,
+    dst: &SyntheticAmode,
+    vcode: &VCode<Inst>,
+    ty: Type,
+) -> PccResult<()> {
+    let stored_fact = data.and_then(|data| vcode.vreg_fact(data.into()));
+    check_mem(ctx, dst, vcode, ty, LoadOrStore::Store { stored_fact }).map(|_| ())
+}
+
+fn check_mem<'a>(
+    ctx: &FactContext,
+    amode: &SyntheticAmode,
+    vcode: &VCode<Inst>,
+    ty: Type,
+    op: LoadOrStore<'a>,
+) -> PccResult<Option<Fact>> {
+    let addr = match amode {
+        SyntheticAmode::Real(amode) if amode.get_flags().checked() => {
+            compute_addr(ctx, vcode, amode, 64).ok_or(PccError::MissingFact)?
+        }
+        _ => return Ok(None),
+    };
+
+    match op {
+        LoadOrStore::Load {
+            result_fact,
+            from_bits,
+            to_bits,
+        } => {
+            let loaded_fact = clamp_range(ctx, to_bits, from_bits, ctx.load(&addr, ty)?.cloned())?;
+            trace!(
+                "loaded_fact = {:?} result_fact = {:?}",
+                loaded_fact,
+                result_fact
+            );
+            if ctx.subsumes_fact_optionals(loaded_fact.as_ref(), result_fact) {
+                Ok(loaded_fact.clone())
+            } else {
+                Err(PccError::UnsupportedFact)
+            }
+        }
+        LoadOrStore::Store { stored_fact } => {
+            ctx.store(&addr, ty, stored_fact)?;
+            Ok(None)
+        }
+    }
+}
+
+fn compute_addr(ctx: &FactContext, vcode: &VCode<Inst>, amode: &Amode, bits: u16) -> Option<Fact> {
+    trace!("compute_addr: {:?}", amode);
+    match *amode {
+        Amode::ImmReg { simm32, base, .. } => {
+            let base = get_fact_or_default(vcode, base, bits);
+            trace!("base = {:?}", base);
+            let simm32: i64 = simm32.into();
+            let simm32: u64 = simm32 as u64;
+            let offset = Fact::constant(bits, simm32);
+            let sum = ctx.add(&base, &offset, bits)?;
+            trace!("sum = {:?}", sum);
+            Some(sum)
+        }
+        Amode::ImmRegRegShift {
+            simm32,
+            base,
+            index,
+            shift,
+            ..
+        } => {
+            let base = get_fact_or_default(vcode, base.into(), bits);
+            let index = get_fact_or_default(vcode, index.into(), bits);
+            trace!("base = {:?} index = {:?}", base, index);
+            let shifted = ctx.shl(&index, bits, shift.into())?;
+            let sum = ctx.add(&base, &shifted, bits)?;
+            let simm32: i64 = simm32.into();
+            let simm32: u64 = simm32 as u64;
+            let offset = Fact::constant(bits, simm32);
+            let sum = ctx.add(&sum, &offset, bits)?;
+            trace!("sum = {:?}", sum);
+            Some(sum)
+        }
+        Amode::RipRelative { .. } => None,
+    }
+}
diff --git a/cranelift/codegen/src/isle_prelude.rs b/cranelift/codegen/src/isle_prelude.rs
index 26332de5a88b..79fcd24889e8 100644
--- a/cranelift/codegen/src/isle_prelude.rs
+++ b/cranelift/codegen/src/isle_prelude.rs
@@ -23,6 +23,16 @@ macro_rules! isle_common_prelude_methods {
             x.into()
         }
 
+        #[inline]
+        fn u16_as_i16(&mut self, x: u16) -> i16 {
+            x as i16
+        }
+
+        #[inline]
+        fn u16_as_u32(&mut self, x: u16) -> u32 {
+            x.into()
+        }
+
         #[inline]
         fn u16_as_u64(&mut self, x: u16) -> u64 {
             x.into()
@@ -43,6 +53,11 @@ macro_rules! isle_common_prelude_methods {
             x as i32
         }
 
+        #[inline]
+        fn u64_as_i64(&mut self, x: u64) -> i64 {
+            x as i64
+        }
+
         #[inline]
         fn i32_as_i64(&mut self, x: i32) -> i64 {
             x.into()
@@ -53,6 +68,11 @@ macro_rules! isle_common_prelude_methods {
             x.wrapping_neg()
         }
 
+        #[inline]
+        fn i8_neg(&mut self, x: i8) -> i8 {
+            x.wrapping_neg()
+        }
+
         #[inline]
         fn u64_add(&mut self, x: u64, y: u64) -> u64 {
             x.wrapping_add(y)
@@ -164,6 +184,10 @@ macro_rules! isle_common_prelude_methods {
             0 == value
         }
 
+        fn i64_is_zero(&mut self, value: i64) -> bool {
+            0 == value
+        }
+
         #[inline]
         fn u64_is_odd(&mut self, x: u64) -> bool {
             x & 1 == 1
@@ -184,9 +208,8 @@ macro_rules! isle_common_prelude_methods {
         }
 
         #[inline]
-        fn i64_sextend_imm64(&mut self, ty: Type, mut x: Imm64) -> i64 {
-            x.sign_extend_from_width(ty.bits());
-            x.bits()
+        fn i64_sextend_imm64(&mut self, ty: Type, x: Imm64) -> i64 {
+            x.sign_extend_from_width(ty.bits()).bits()
         }
 
         #[inline]
@@ -378,6 +401,15 @@ macro_rules! isle_common_prelude_methods {
             }
         }
 
+        #[inline]
+        fn ty_16_or_32(&mut self, ty: Type) -> Option<Type> {
+            if ty.bits() == 16 || ty.bits() == 32 {
+                Some(ty)
+            } else {
+                None
+            }
+        }
+
         #[inline]
         fn int_fits_in_32(&mut self, ty: Type) -> Option<Type> {
             match ty {
@@ -389,7 +421,7 @@ macro_rules! isle_common_prelude_methods {
         #[inline]
         fn ty_int_ref_64(&mut self, ty: Type) -> Option<Type> {
             match ty {
-                I64 | R64 => Some(ty),
+                I64 => Some(ty),
                 _ => None,
             }
         }
@@ -397,7 +429,7 @@ macro_rules! isle_common_prelude_methods {
         #[inline]
         fn ty_int_ref_16_to_64(&mut self, ty: Type) -> Option<Type> {
             match ty {
-                I16 | I32 | I64 | R64 => Some(ty),
+                I16 | I32 | I64 => Some(ty),
                 _ => None,
             }
         }
@@ -418,18 +450,19 @@ macro_rules! isle_common_prelude_methods {
 
         #[inline]
         fn ty_scalar_float(&mut self, ty: Type) -> Option<Type> {
-            match ty {
-                F32 | F64 => Some(ty),
-                _ => None,
+            if ty.is_float() {
+                Some(ty)
+            } else {
+                None
             }
         }
 
         #[inline]
         fn ty_float_or_vec(&mut self, ty: Type) -> Option<Type> {
-            match ty {
-                F32 | F64 => Some(ty),
-                ty if ty.is_vector() => Some(ty),
-                _ => None,
+            if ty.is_float() || ty.is_vector() {
+                Some(ty)
+            } else {
+                None
             }
         }
 
@@ -516,7 +549,7 @@ macro_rules! isle_common_prelude_methods {
         #[inline]
         fn ty_addr64(&mut self, ty: Type) -> Option<Type> {
             match ty {
-                I64 | R64 => Some(ty),
+                I64 => Some(ty),
                 _ => None,
             }
         }
@@ -564,27 +597,6 @@ macro_rules! isle_common_prelude_methods {
             }
         }
 
-        #[inline]
-        fn dynamic_int_lane(&mut self, ty: Type) -> Option<u32> {
-            if ty.is_dynamic_vector() && crate::machinst::ty_has_int_representation(ty.lane_type())
-            {
-                Some(ty.lane_bits())
-            } else {
-                None
-            }
-        }
-
-        #[inline]
-        fn dynamic_fp_lane(&mut self, ty: Type) -> Option<u32> {
-            if ty.is_dynamic_vector()
-                && crate::machinst::ty_has_float_or_vec_representation(ty.lane_type())
-            {
-                Some(ty.lane_bits())
-            } else {
-                None
-            }
-        }
-
         #[inline]
         fn ty_dyn64_int(&mut self, ty: Type) -> Option<Type> {
             if ty.is_dynamic_vector() && ty.min_bits() == 64 && ty.lane_type().is_int() {
@@ -603,6 +615,10 @@ macro_rules! isle_common_prelude_methods {
             }
         }
 
+        fn u16_from_ieee16(&mut self, val: Ieee16) -> u16 {
+            val.bits()
+        }
+
         fn u32_from_ieee32(&mut self, val: Ieee32) -> u32 {
             val.bits()
         }
@@ -665,6 +681,11 @@ macro_rules! isle_common_prelude_methods {
             a & b
         }
 
+        #[inline]
+        fn u32_shl(&mut self, x: u32, y: u32) -> u32 {
+            x << y
+        }
+
         #[inline]
         fn s32_add_fallible(&mut self, a: i32, b: i32) -> Option<i32> {
             a.checked_add(b)
@@ -716,18 +737,6 @@ macro_rules! isle_common_prelude_methods {
             Imm64::new((x & self.ty_mask(ty)) as i64)
         }
 
-        #[inline]
-        fn simm32(&mut self, x: Imm64) -> Option<i32> {
-            i64::from(x).try_into().ok()
-        }
-
-        #[inline]
-        fn uimm8(&mut self, x: Imm64) -> Option<u8> {
-            let x64: i64 = x.into();
-            let x8: u8 = x64.try_into().ok()?;
-            Some(x8)
-        }
-
         #[inline]
         fn offset32(&mut self, x: Offset32) -> i32 {
             x.into()
@@ -769,15 +778,7 @@ macro_rules! isle_common_prelude_methods {
 
         #[inline]
         fn ty_half_width(&mut self, ty: Type) -> Option<Type> {
-            let new_lane = match ty.lane_type() {
-                I16 => I8,
-                I32 => I16,
-                I64 => I32,
-                F64 => F32,
-                _ => return None,
-            };
-
-            new_lane.by(ty.lane_count())
+            ty.half_width()
         }
 
         #[inline]
@@ -821,7 +822,7 @@ macro_rules! isle_common_prelude_methods {
         }
 
         #[inline]
-        fn signed_cond_code(&mut self, cc: &condcodes::IntCC) -> Option<condcodes::IntCC> {
+        fn signed_cond_code(&mut self, cc: &IntCC) -> Option<IntCC> {
             match cc {
                 IntCC::Equal
                 | IntCC::UnsignedGreaterThanOrEqual
@@ -846,6 +847,11 @@ macro_rules! isle_common_prelude_methods {
             cc.complement()
         }
 
+        #[inline]
+        fn intcc_without_eq(&mut self, x: &IntCC) -> IntCC {
+            x.without_equal()
+        }
+
         #[inline]
         fn floatcc_swap_args(&mut self, cc: &FloatCC) -> FloatCC {
             cc.swap_args()
@@ -909,10 +915,42 @@ macro_rules! isle_common_prelude_methods {
             u32::try_from(val).ok()
         }
 
+        fn u32_as_u16(&mut self, val: u32) -> Option<u16> {
+            val.try_into().ok()
+        }
+
         fn u8_as_i8(&mut self, val: u8) -> i8 {
             val as i8
         }
 
+        fn u64_as_u8(&mut self, val: u64) -> u8 {
+            val as u8
+        }
+
+        fn u64_as_u16(&mut self, val: u64) -> u16 {
+            val as u16
+        }
+
+        fn u16_try_from_u64(&mut self, val: u64) -> Option<u16> {
+            u16::try_from(val).ok()
+        }
+
+        fn u32_try_from_u64(&mut self, val: u64) -> Option<u32> {
+            u32::try_from(val).ok()
+        }
+
+        fn i8_try_from_u64(&mut self, val: u64) -> Option<i8> {
+            i8::try_from(val).ok()
+        }
+
+        fn i16_try_from_u64(&mut self, val: u64) -> Option<i16> {
+            i16::try_from(val).ok()
+        }
+
+        fn i32_try_from_u64(&mut self, val: u64) -> Option<i32> {
+            i32::try_from(val).ok()
+        }
+
         fn u128_replicated_u64(&mut self, val: u128) -> Option<u64> {
             let low64 = val as u64 as u128;
             if (low64 | (low64 << 64)) == val {
@@ -950,5 +988,157 @@ macro_rules! isle_common_prelude_methods {
                 None
             }
         }
+
+        fn f16_min(&mut self, a: Ieee16, b: Ieee16) -> Option<Ieee16> {
+            a.minimum(b).non_nan()
+        }
+
+        fn f16_max(&mut self, a: Ieee16, b: Ieee16) -> Option<Ieee16> {
+            a.maximum(b).non_nan()
+        }
+
+        fn f16_neg(&mut self, n: Ieee16) -> Ieee16 {
+            -n
+        }
+
+        fn f16_abs(&mut self, n: Ieee16) -> Ieee16 {
+            n.abs()
+        }
+
+        fn f16_copysign(&mut self, a: Ieee16, b: Ieee16) -> Ieee16 {
+            a.copysign(b)
+        }
+
+        fn f32_add(&mut self, lhs: Ieee32, rhs: Ieee32) -> Option<Ieee32> {
+            (lhs + rhs).non_nan()
+        }
+
+        fn f32_sub(&mut self, lhs: Ieee32, rhs: Ieee32) -> Option<Ieee32> {
+            (lhs - rhs).non_nan()
+        }
+
+        fn f32_mul(&mut self, lhs: Ieee32, rhs: Ieee32) -> Option<Ieee32> {
+            (lhs * rhs).non_nan()
+        }
+
+        fn f32_div(&mut self, lhs: Ieee32, rhs: Ieee32) -> Option<Ieee32> {
+            (lhs / rhs).non_nan()
+        }
+
+        fn f32_sqrt(&mut self, n: Ieee32) -> Option<Ieee32> {
+            n.sqrt().non_nan()
+        }
+
+        fn f32_ceil(&mut self, n: Ieee32) -> Option<Ieee32> {
+            n.ceil().non_nan()
+        }
+
+        fn f32_floor(&mut self, n: Ieee32) -> Option<Ieee32> {
+            n.floor().non_nan()
+        }
+
+        fn f32_trunc(&mut self, n: Ieee32) -> Option<Ieee32> {
+            n.trunc().non_nan()
+        }
+
+        fn f32_nearest(&mut self, n: Ieee32) -> Option<Ieee32> {
+            n.round_ties_even().non_nan()
+        }
+
+        fn f32_min(&mut self, a: Ieee32, b: Ieee32) -> Option<Ieee32> {
+            a.minimum(b).non_nan()
+        }
+
+        fn f32_max(&mut self, a: Ieee32, b: Ieee32) -> Option<Ieee32> {
+            a.maximum(b).non_nan()
+        }
+
+        fn f32_neg(&mut self, n: Ieee32) -> Ieee32 {
+            -n
+        }
+
+        fn f32_abs(&mut self, n: Ieee32) -> Ieee32 {
+            n.abs()
+        }
+
+        fn f32_copysign(&mut self, a: Ieee32, b: Ieee32) -> Ieee32 {
+            a.copysign(b)
+        }
+
+        fn f64_add(&mut self, lhs: Ieee64, rhs: Ieee64) -> Option<Ieee64> {
+            (lhs + rhs).non_nan()
+        }
+
+        fn f64_sub(&mut self, lhs: Ieee64, rhs: Ieee64) -> Option<Ieee64> {
+            (lhs - rhs).non_nan()
+        }
+
+        fn f64_mul(&mut self, lhs: Ieee64, rhs: Ieee64) -> Option<Ieee64> {
+            (lhs * rhs).non_nan()
+        }
+
+        fn f64_div(&mut self, lhs: Ieee64, rhs: Ieee64) -> Option<Ieee64> {
+            (lhs / rhs).non_nan()
+        }
+
+        fn f64_sqrt(&mut self, n: Ieee64) -> Option<Ieee64> {
+            n.sqrt().non_nan()
+        }
+
+        fn f64_ceil(&mut self, n: Ieee64) -> Option<Ieee64> {
+            n.ceil().non_nan()
+        }
+
+        fn f64_floor(&mut self, n: Ieee64) -> Option<Ieee64> {
+            n.floor().non_nan()
+        }
+
+        fn f64_trunc(&mut self, n: Ieee64) -> Option<Ieee64> {
+            n.trunc().non_nan()
+        }
+
+        fn f64_nearest(&mut self, n: Ieee64) -> Option<Ieee64> {
+            n.round_ties_even().non_nan()
+        }
+
+        fn f64_min(&mut self, a: Ieee64, b: Ieee64) -> Option<Ieee64> {
+            a.minimum(b).non_nan()
+        }
+
+        fn f64_max(&mut self, a: Ieee64, b: Ieee64) -> Option<Ieee64> {
+            a.maximum(b).non_nan()
+        }
+
+        fn f64_neg(&mut self, n: Ieee64) -> Ieee64 {
+            -n
+        }
+
+        fn f64_abs(&mut self, n: Ieee64) -> Ieee64 {
+            n.abs()
+        }
+
+        fn f64_copysign(&mut self, a: Ieee64, b: Ieee64) -> Ieee64 {
+            a.copysign(b)
+        }
+
+        fn f128_min(&mut self, a: Ieee128, b: Ieee128) -> Option<Ieee128> {
+            a.minimum(b).non_nan()
+        }
+
+        fn f128_max(&mut self, a: Ieee128, b: Ieee128) -> Option<Ieee128> {
+            a.maximum(b).non_nan()
+        }
+
+        fn f128_neg(&mut self, n: Ieee128) -> Ieee128 {
+            -n
+        }
+
+        fn f128_abs(&mut self, n: Ieee128) -> Ieee128 {
+            n.abs()
+        }
+
+        fn f128_copysign(&mut self, a: Ieee128, b: Ieee128) -> Ieee128 {
+            a.copysign(b)
+        }
     };
 }
diff --git a/cranelift/codegen/src/legalizer/globalvalue.rs b/cranelift/codegen/src/legalizer/globalvalue.rs
index 57fa29e1f5ab..9837dd59278e 100644
--- a/cranelift/codegen/src/legalizer/globalvalue.rs
+++ b/cranelift/codegen/src/legalizer/globalvalue.rs
@@ -4,7 +4,7 @@
 //! instruction into code that depends on the kind of global value referenced.
 
 use crate::cursor::{Cursor, FuncCursor};
-use crate::ir::{self, InstBuilder};
+use crate::ir::{self, pcc::Fact, InstBuilder};
 use crate::isa::TargetIsa;
 
 /// Expand a `global_value` instruction according to the definition of the global value.
@@ -21,7 +21,7 @@ pub fn expand_global_value(
     );
 
     match func.global_values[global_value] {
-        ir::GlobalValueData::VMContext => vmctx_addr(inst, func),
+        ir::GlobalValueData::VMContext => vmctx_addr(global_value, inst, func),
         ir::GlobalValueData::IAddImm {
             base,
             offset,
@@ -31,8 +31,8 @@ pub fn expand_global_value(
             base,
             offset,
             global_type,
-            readonly,
-        } => load_addr(inst, func, base, offset, global_type, readonly, isa),
+            flags,
+        } => load_addr(inst, func, base, offset, global_type, flags, isa),
         ir::GlobalValueData::Symbol { tls, .. } => symbol(inst, func, global_value, isa, tls),
         ir::GlobalValueData::DynScaleTargetConst { vector_type } => {
             const_vector_scale(inst, func, vector_type, isa)
@@ -52,7 +52,7 @@ fn const_vector_scale(inst: ir::Inst, func: &mut ir::Function, ty: ir::Type, isa
 }
 
 /// Expand a `global_value` instruction for a vmctx global.
-fn vmctx_addr(inst: ir::Inst, func: &mut ir::Function) {
+fn vmctx_addr(global_value: ir::GlobalValue, inst: ir::Inst, func: &mut ir::Function) {
     // Get the value representing the `vmctx` argument.
     let vmctx = func
         .special_param(ir::ArgumentPurpose::VMContext)
@@ -63,6 +63,15 @@ fn vmctx_addr(inst: ir::Inst, func: &mut ir::Function) {
     func.dfg.clear_results(inst);
     func.dfg.change_to_alias(result, vmctx);
     func.layout.remove_inst(inst);
+
+    // If there was a fact on the GV, then copy it to the vmctx arg
+    // blockparam def.
+    if let Some(fact) = &func.global_value_facts[global_value] {
+        if func.dfg.facts[vmctx].is_none() {
+            let fact = fact.clone();
+            func.dfg.facts[vmctx] = Some(fact);
+        }
+    }
 }
 
 /// Expand a `global_value` instruction for an iadd_imm global.
@@ -75,18 +84,23 @@ fn iadd_imm_addr(
 ) {
     let mut pos = FuncCursor::new(func).at_inst(inst);
 
-    // Get the value for the lhs. For tidiness, expand VMContext here so that we avoid
-    // `vmctx_addr` which creates an otherwise unneeded value alias.
-    let lhs = if let ir::GlobalValueData::VMContext = pos.func.global_values[base] {
-        pos.func
-            .special_param(ir::ArgumentPurpose::VMContext)
-            .expect("Missing vmctx parameter")
-    } else {
-        pos.ins().global_value(global_type, base)
-    };
+    // Get the value for the lhs.
+    let lhs = pos.ins().global_value(global_type, base);
+    if let Some(fact) = &pos.func.global_value_facts[base] {
+        pos.func.dfg.facts[lhs] = Some(fact.clone());
+    }
+
+    // Generate the constant and attach a fact to the constant if
+    // there is a fact on the base.
+    let constant = pos.ins().iconst(global_type, offset);
+    if pos.func.global_value_facts[base].is_some() {
+        let bits = u16::try_from(global_type.bits()).unwrap();
+        let unsigned_offset = offset as u64; // Safety: reinterpret i64 bits as u64.
+        pos.func.dfg.facts[constant] = Some(Fact::constant(bits, unsigned_offset));
+    }
 
     // Simply replace the `global_value` instruction with an `iadd_imm`, reusing the result value.
-    pos.func.dfg.replace(inst).iadd_imm(lhs, offset);
+    pos.func.dfg.replace(inst).iadd(lhs, constant);
 }
 
 /// Expand a `global_value` instruction for a load global.
@@ -96,7 +110,7 @@ fn load_addr(
     base: ir::GlobalValue,
     offset: ir::immediates::Offset32,
     global_type: ir::Type,
-    readonly: bool,
+    flags: ir::MemFlags,
     isa: &dyn TargetIsa,
 ) {
     // We need to load a pointer from the `base` global value, so insert a new `global_value`
@@ -106,27 +120,17 @@ fn load_addr(
     let mut pos = FuncCursor::new(func).at_inst(inst);
     pos.use_srcloc(inst);
 
-    // Get the value for the base. For tidiness, expand VMContext here so that we avoid
-    // `vmctx_addr` which creates an otherwise unneeded value alias.
-    let base_addr = if let ir::GlobalValueData::VMContext = pos.func.global_values[base] {
-        pos.func
-            .special_param(ir::ArgumentPurpose::VMContext)
-            .expect("Missing vmctx parameter")
-    } else {
-        pos.ins().global_value(ptr_ty, base)
-    };
-
-    // Global-value loads are always notrap and aligned. They may be readonly.
-    let mut mflags = ir::MemFlags::trusted();
-    if readonly {
-        mflags.set_readonly();
+    // Get the value for the base.
+    let base_addr = pos.ins().global_value(ptr_ty, base);
+    if let Some(fact) = &pos.func.global_value_facts[base] {
+        pos.func.dfg.facts[base_addr] = Some(fact.clone());
     }
 
     // Perform the load.
     pos.func
         .dfg
         .replace(inst)
-        .load(global_type, mflags, base_addr, offset);
+        .load(global_type, flags, base_addr, offset);
 }
 
 /// Expand a `global_value` instruction for a symbolic name global.
diff --git a/cranelift/codegen/src/legalizer/mod.rs b/cranelift/codegen/src/legalizer/mod.rs
index e186b153091d..fb14a5d8fed1 100644
--- a/cranelift/codegen/src/legalizer/mod.rs
+++ b/cranelift/codegen/src/legalizer/mod.rs
@@ -22,10 +22,8 @@ use crate::isa::TargetIsa;
 use crate::trace;
 
 mod globalvalue;
-mod table;
 
 use self::globalvalue::expand_global_value;
-use self::table::expand_table_addr;
 
 fn imm_const(pos: &mut FuncCursor, arg: Value, imm: Imm64, is_signed: bool) -> Value {
     let ty = pos.func.dfg.value_type(arg);
@@ -66,8 +64,7 @@ pub fn simple_legalize(func: &mut ir::Function, cfg: &mut ControlFlowGraph, isa:
             match pos.func.dfg.insts[inst] {
                 // control flow
                 InstructionData::CondTrap {
-                    opcode:
-                        opcode @ (ir::Opcode::Trapnz | ir::Opcode::Trapz | ir::Opcode::ResumableTrapnz),
+                    opcode: opcode @ (ir::Opcode::Trapnz | ir::Opcode::Trapz),
                     arg,
                     code,
                 } => {
@@ -152,12 +149,6 @@ pub fn simple_legalize(func: &mut ir::Function, cfg: &mut ControlFlowGraph, isa:
                     mflags.set_aligned();
                     pos.func.dfg.replace(inst).store(mflags, arg, addr, 0);
                 }
-                InstructionData::TableAddr {
-                    opcode: ir::Opcode::TableAddr,
-                    table,
-                    arg,
-                    offset,
-                } => expand_table_addr(isa, inst, &mut pos.func, table, arg, offset),
 
                 InstructionData::BinaryImm64 { opcode, arg, imm } => {
                     let is_signed = match opcode {
@@ -291,7 +282,7 @@ fn expand_cond_trap(
     // Parse the instruction.
     let trapz = match opcode {
         ir::Opcode::Trapz => true,
-        ir::Opcode::Trapnz | ir::Opcode::ResumableTrapnz => false,
+        ir::Opcode::Trapnz => false,
         _ => panic!("Expected cond trap: {}", func.dfg.display_inst(inst)),
     };
 
@@ -339,10 +330,6 @@ fn expand_cond_trap(
         ir::Opcode::Trapz | ir::Opcode::Trapnz => {
             pos.ins().trap(code);
         }
-        ir::Opcode::ResumableTrapnz => {
-            pos.ins().resumable_trap(code);
-            pos.ins().jump(new_block_resume, &[]);
-        }
         _ => unreachable!(),
     }
 
diff --git a/cranelift/codegen/src/legalizer/table.rs b/cranelift/codegen/src/legalizer/table.rs
deleted file mode 100644
index db72508a2680..000000000000
--- a/cranelift/codegen/src/legalizer/table.rs
+++ /dev/null
@@ -1,114 +0,0 @@
-//! Legalization of tables.
-//!
-//! This module exports the `expand_table_addr` function which transforms a `table_addr`
-//! instruction into code that depends on the kind of table referenced.
-
-use crate::cursor::{Cursor, FuncCursor};
-use crate::ir::condcodes::IntCC;
-use crate::ir::immediates::Offset32;
-use crate::ir::{self, InstBuilder};
-use crate::isa::TargetIsa;
-
-/// Expand a `table_addr` instruction according to the definition of the table.
-pub fn expand_table_addr(
-    isa: &dyn TargetIsa,
-    inst: ir::Inst,
-    func: &mut ir::Function,
-    table: ir::Table,
-    index: ir::Value,
-    element_offset: Offset32,
-) {
-    let bound_gv = func.tables[table].bound_gv;
-    let index_ty = func.dfg.value_type(index);
-    let addr_ty = func.dfg.value_type(func.dfg.first_result(inst));
-    let mut pos = FuncCursor::new(func).at_inst(inst);
-    pos.use_srcloc(inst);
-
-    // Start with the bounds check. Trap if `index + 1 > bound`.
-    let bound = pos.ins().global_value(index_ty, bound_gv);
-
-    // `index > bound - 1` is the same as `index >= bound`.
-    let oob = pos
-        .ins()
-        .icmp(IntCC::UnsignedGreaterThanOrEqual, index, bound);
-    pos.ins().trapnz(oob, ir::TrapCode::TableOutOfBounds);
-
-    // If Spectre mitigations are enabled, we will use a comparison to
-    // short-circuit the computed table element address to the start
-    // of the table on the misspeculation path when out-of-bounds.
-    let spectre_oob_cmp = if isa.flags().enable_table_access_spectre_mitigation() {
-        Some((index, bound))
-    } else {
-        None
-    };
-
-    compute_addr(
-        inst,
-        table,
-        addr_ty,
-        index,
-        index_ty,
-        element_offset,
-        pos.func,
-        spectre_oob_cmp,
-    );
-}
-
-/// Emit code for the base address computation of a `table_addr` instruction.
-fn compute_addr(
-    inst: ir::Inst,
-    table: ir::Table,
-    addr_ty: ir::Type,
-    mut index: ir::Value,
-    index_ty: ir::Type,
-    element_offset: Offset32,
-    func: &mut ir::Function,
-    spectre_oob_cmp: Option<(ir::Value, ir::Value)>,
-) {
-    let mut pos = FuncCursor::new(func).at_inst(inst);
-    pos.use_srcloc(inst);
-
-    // Convert `index` to `addr_ty`.
-    if index_ty != addr_ty {
-        index = pos.ins().uextend(addr_ty, index);
-    }
-
-    // Add the table base address base
-    let base_gv = pos.func.tables[table].base_gv;
-    let base = pos.ins().global_value(addr_ty, base_gv);
-
-    let element_size = pos.func.tables[table].element_size;
-    let mut offset;
-    let element_size: u64 = element_size.into();
-    if element_size == 1 {
-        offset = index;
-    } else if element_size.is_power_of_two() {
-        offset = pos
-            .ins()
-            .ishl_imm(index, i64::from(element_size.trailing_zeros()));
-    } else {
-        offset = pos.ins().imul_imm(index, element_size as i64);
-    }
-
-    let element_addr = if element_offset == Offset32::new(0) {
-        pos.ins().iadd(base, offset)
-    } else {
-        let imm: i64 = element_offset.into();
-        offset = pos.ins().iadd(base, offset);
-        pos.ins().iadd_imm(offset, imm)
-    };
-
-    let element_addr = if let Some((index, bound)) = spectre_oob_cmp {
-        let cond = pos
-            .ins()
-            .icmp(IntCC::UnsignedGreaterThanOrEqual, index, bound);
-        // If out-of-bounds, choose the table base on the misspeculation path.
-        pos.ins().select_spectre_guard(cond, base, element_addr)
-    } else {
-        element_addr
-    };
-    let new_inst = pos.func.dfg.value_def(element_addr).inst().unwrap();
-
-    pos.func.dfg.replace_with_aliases(inst, new_inst);
-    pos.remove_inst();
-}
diff --git a/cranelift/codegen/src/lib.rs b/cranelift/codegen/src/lib.rs
index c856e1a1b645..627feeaae022 100644
--- a/cranelift/codegen/src/lib.rs
+++ b/cranelift/codegen/src/lib.rs
@@ -1,7 +1,4 @@
 //! Cranelift code generation library.
-#![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)]
-#![warn(unused_import_braces)]
-#![cfg_attr(feature = "std", deny(unstable_features))]
 #![no_std]
 // Various bits and pieces of this crate might only be used for one platform or
 // another, but it's not really too useful to learn about that all the time. On
@@ -20,9 +17,9 @@ extern crate alloc;
 extern crate std;
 
 #[cfg(not(feature = "std"))]
-use hashbrown::{hash_map, HashMap, HashSet};
+use hashbrown::{hash_map, HashMap};
 #[cfg(feature = "std")]
-use std::collections::{hash_map, HashMap, HashSet};
+use std::collections::{hash_map, HashMap};
 
 pub use crate::context::Context;
 pub use crate::value_label::{LabelValueLoc, ValueLabelsRanges, ValueLocRange};
@@ -30,6 +27,7 @@ pub use crate::verifier::verify_function;
 pub use crate::write::write_function;
 
 pub use cranelift_bforest as bforest;
+pub use cranelift_bitset as bitset;
 pub use cranelift_control as control;
 pub use cranelift_entity as entity;
 #[cfg(feature = "unwind")]
@@ -51,34 +49,33 @@ pub mod loop_analysis;
 pub mod print_errors;
 pub mod settings;
 pub mod timing;
+pub mod traversals;
 pub mod verifier;
 pub mod write;
 
 pub use crate::entity::packed_option;
 pub use crate::machinst::buffer::{
-    FinalizedMachReloc, FinalizedRelocTarget, MachCallSite, MachSrcLoc, MachStackMap,
-    MachTextSectionBuilder, MachTrap,
+    FinalizedMachReloc, FinalizedRelocTarget, MachCallSite, MachSrcLoc, MachTextSectionBuilder,
+    MachTrap, OpenPatchRegion, PatchRegion,
 };
 pub use crate::machinst::{
     CompiledCode, Final, MachBuffer, MachBufferFinalized, MachInst, MachInstEmit,
-    MachInstEmitState, MachLabel, Reg, TextSectionBuilder, VCodeConstantData, VCodeConstants,
-    Writable,
+    MachInstEmitState, MachLabel, RealReg, Reg, RegClass, RelocDistance, TextSectionBuilder,
+    VCodeConstantData, VCodeConstants, Writable,
 };
 
 mod alias_analysis;
-mod bitset;
 mod constant_hash;
 mod context;
 mod ctxhash;
-mod dce;
 mod egraph;
-mod fx;
 mod inst_predicates;
 mod isle_prelude;
 mod iterators;
 mod legalizer;
 mod nan_canonicalization;
 mod opts;
+mod ranges;
 mod remove_constant_phis;
 mod result;
 mod scoped_hash_map;
diff --git a/cranelift/codegen/src/machinst/abi.rs b/cranelift/codegen/src/machinst/abi.rs
index fd0e71add362..7760aef208dd 100644
--- a/cranelift/codegen/src/machinst/abi.rs
+++ b/cranelift/codegen/src/machinst/abi.rs
@@ -38,25 +38,20 @@
 //! We assume that a prologue first pushes the frame pointer (and
 //! return address above that, if the machine does not do that in
 //! hardware). We set FP to point to this two-word frame record. We
-//! store all other frame slots below this two-word frame record, with
-//! the stack pointer remaining at or below this fixed frame storage
-//! for the rest of the function. We can then access frame storage
-//! slots using positive offsets from SP. In order to allow codegen
-//! for the latter before knowing how SP might be adjusted around
-//! callsites, we implement a "nominal SP" tracking feature by which a
-//! fixup (distance between actual SP and a "nominal" SP) is known at
-//! each instruction.
+//! store all other frame slots below this two-word frame record, as
+//! well as enough space for arguments to the largest possible
+//! function call. The stack pointer then remains at this position
+//! for the duration of the function, allowing us to address all
+//! frame storage at positive offsets from SP.
 //!
 //! Note that if we ever support dynamic stack-space allocation (for
 //! `alloca`), we will need a way to reference spill slots and stack
-//! slots without "nominal SP", because we will no longer be able to
-//! know a static offset from SP to the slots at any particular
+//! slots relative to a dynamic SP, because we will no longer be able
+//! to know a static offset from SP to the slots at any particular
 //! program point. Probably the best solution at that point will be to
 //! revert to using the frame pointer as the reference for all slots,
-//! and creating a "nominal FP" synthetic addressing mode (analogous
-//! to "nominal SP" today) to allow generating spill/reload and
-//! stackslot accesses before we know how large the clobber-saves will
-//! be.
+//! to allow generating spill/reload and stackslot accesses before we
+//! know how large the clobber-saves will be.
 //!
 //! # Stack Layout
 //!
@@ -64,33 +59,35 @@
 //!
 //! ```plain
 //!   (high address)
-//!
-//!                              +---------------------------+
+//!                              |          ...              |
+//!                              | caller frames             |
+//!                              |          ...              |
+//!                              +===========================+
 //!                              |          ...              |
 //!                              | stack args                |
-//!                              | (accessed via FP)         |
+//! Canonical Frame Address -->  | (accessed via FP)         |
 //!                              +---------------------------+
 //! SP at function entry ----->  | return address            |
 //!                              +---------------------------+
 //! FP after prologue -------->  | FP (pushed by prologue)   |
-//!                              +---------------------------+
-//!                              |          ...              |
-//!                              | clobbered callee-saves    |
-//! unwind-frame base     ---->  | (pushed by prologue)      |
-//!                              +---------------------------+
-//!                              |          ...              |
-//!                              | spill slots               |
-//!                              | (accessed via nominal SP) |
-//!                              |          ...              |
-//!                              | stack slots               |
-//!                              | (accessed via nominal SP) |
-//! nominal SP --------------->  | (alloc'd by prologue)     |
-//! (SP at end of prologue)      +---------------------------+
-//!                              | [alignment as needed]     |
-//!                              |          ...              |
-//!                              | args for call             |
-//! SP before making a call -->  | (pushed at callsite)      |
-//!                              +---------------------------+
+//!                              +---------------------------+           -----
+//!                              |          ...              |             |
+//!                              | clobbered callee-saves    |             |
+//! unwind-frame base -------->  | (pushed by prologue)      |             |
+//!                              +---------------------------+   -----     |
+//!                              |          ...              |     |       |
+//!                              | spill slots               |     |       |
+//!                              | (accessed via SP)         |   fixed   active
+//!                              |          ...              |   frame    size
+//!                              | stack slots               |  storage    |
+//!                              | (accessed via SP)         |    size     |
+//!                              | (alloc'd by prologue)     |     |       |
+//!                              +---------------------------+   -----     |
+//!                              | [alignment as needed]     |             |
+//!                              |          ...              |             |
+//!                              | args for largest call     |             |
+//! SP ----------------------->  | (alloc'd by prologue)     |             |
+//!                              +===========================+           -----
 //!
 //!   (low address)
 //! ```
@@ -101,22 +98,18 @@
 //! registers. In some cases this is an extension of the base system
 //! ABI. See each platform's `abi.rs` implementation for details.
 
-use crate::binemit::StackMap;
-use crate::entity::{PrimaryMap, SecondaryMap};
-use crate::fx::FxHashMap;
+use crate::entity::SecondaryMap;
 use crate::ir::types::*;
-use crate::ir::{ArgumentExtension, ArgumentPurpose, DynamicStackSlot, Signature, StackSlot};
+use crate::ir::{ArgumentExtension, ArgumentPurpose, Signature};
 use crate::isa::TargetIsa;
-use crate::settings;
 use crate::settings::ProbestackStrategy;
+use crate::CodegenError;
 use crate::{ir, isa};
 use crate::{machinst::*, trace};
-use crate::{CodegenError, CodegenResult};
-use alloc::vec::Vec;
 use regalloc2::{MachineEnv, PReg, PRegSet};
-use smallvec::{smallvec, SmallVec};
+use rustc_hash::FxHashMap;
+use smallvec::smallvec;
 use std::collections::HashMap;
-use std::convert::TryFrom;
 use std::marker::PhantomData;
 use std::mem;
 
@@ -285,26 +278,12 @@ pub enum ArgsOrRets {
 /// appropriate addressing mode.
 #[derive(Clone, Copy, Debug)]
 pub enum StackAMode {
-    /// Offset from the frame pointer, possibly making use of a specific type
-    /// for a scaled indexing operation.
-    FPOffset(i64, ir::Type),
-    /// Offset from the nominal stack pointer, possibly making use of a specific
-    /// type for a scaled indexing operation.
-    NominalSPOffset(i64, ir::Type),
-    /// Offset from the real stack pointer, possibly making use of a specific
-    /// type for a scaled indexing operation.
-    SPOffset(i64, ir::Type),
-}
-
-impl StackAMode {
-    /// Offset by an addend.
-    pub fn offset(self, addend: i64) -> Self {
-        match self {
-            StackAMode::FPOffset(off, ty) => StackAMode::FPOffset(off + addend, ty),
-            StackAMode::NominalSPOffset(off, ty) => StackAMode::NominalSPOffset(off + addend, ty),
-            StackAMode::SPOffset(off, ty) => StackAMode::SPOffset(off + addend, ty),
-        }
-    }
+    /// Offset into the current frame's argument area.
+    IncomingArg(i64, u32),
+    /// Offset within the stack slots in the current frame.
+    Slot(i64),
+    /// Offset into the callee frame's argument area.
+    OutgoingArg(i64),
 }
 
 /// Trait implemented by machine-specific backend to represent ISA flags.
@@ -404,20 +383,14 @@ pub trait ABIMachineSpec {
     /// Returns the stack-space used (rounded up to as alignment requires), and
     /// if `add_ret_area_ptr` was passed, the index of the extra synthetic arg
     /// that was added.
-    fn compute_arg_locs<'a, I>(
+    fn compute_arg_locs(
         call_conv: isa::CallConv,
         flags: &settings::Flags,
-        params: I,
+        params: &[ir::AbiParam],
         args_or_rets: ArgsOrRets,
         add_ret_area_ptr: bool,
-        args: ArgsAccumulator<'_>,
-    ) -> CodegenResult<(u32, Option<usize>)>
-    where
-        I: IntoIterator<Item = &'a ir::AbiParam>;
-
-    /// Returns the offset from FP to the argument area, i.e., jumping over the saved FP, return
-    /// address, and maybe other standard elements depending on ABI (e.g. Wasm TLS reg).
-    fn fp_to_arg_offset(call_conv: isa::CallConv, flags: &settings::Flags) -> i64;
+        args: ArgsAccumulator,
+    ) -> CodegenResult<(u32, Option<usize>)>;
 
     /// Generate a load from the stack.
     fn gen_load_stack(mem: StackAMode, into_reg: Writable<Reg>, ty: Type) -> Self::I;
@@ -468,7 +441,7 @@ pub trait ABIMachineSpec {
 
     /// Generate an instruction to compute an address of a stack slot (FP- or
     /// SP-based offset).
-    fn gen_get_stack_addr(mem: StackAMode, into_reg: Writable<Reg>, ty: Type) -> Self::I;
+    fn gen_get_stack_addr(mem: StackAMode, into_reg: Writable<Reg>) -> Self::I;
 
     /// Get a fixed register to use to compute a stack limit. This is needed for
     /// certain sequences generated after the register allocator has already
@@ -493,9 +466,6 @@ pub trait ABIMachineSpec {
     /// Adjust the stack pointer up or down.
     fn gen_sp_reg_adjust(amount: i32) -> SmallInstVec<Self::I>;
 
-    /// Generate a meta-instruction that adjusts the nominal SP offset.
-    fn gen_nominal_sp_adj(amount: i32) -> Self::I;
-
     /// Compute a FrameLayout structure containing a sorted list of all clobbered
     /// registers that are callee-saved according to the ABI, as well as the sizes
     /// of all parts of the stack frame.  The result is used to emit the prologue
@@ -506,7 +476,8 @@ pub trait ABIMachineSpec {
         sig: &Signature,
         regs: &[Writable<RealReg>],
         is_leaf: bool,
-        stack_args_size: u32,
+        incoming_args_size: u32,
+        tail_args_size: u32,
         fixed_frame_storage_size: u32,
         outgoing_args_size: u32,
     ) -> FrameLayout;
@@ -522,7 +493,6 @@ pub trait ABIMachineSpec {
     ) -> SmallInstVec<Self::I>;
 
     /// Generate the usual frame-restore sequence for this architecture.
-    /// This includes generating the actual return instruction(s).
     fn gen_epilogue_frame_restore(
         call_conv: isa::CallConv,
         flags: &settings::Flags,
@@ -530,6 +500,13 @@ pub trait ABIMachineSpec {
         frame_layout: &FrameLayout,
     ) -> SmallInstVec<Self::I>;
 
+    /// Generate a return instruction.
+    fn gen_return(
+        call_conv: isa::CallConv,
+        isa_flags: &Self::F,
+        frame_layout: &FrameLayout,
+    ) -> SmallInstVec<Self::I>;
+
     /// Generate a probestack call.
     fn gen_probestack(insts: &mut SmallInstVec<Self::I>, frame_size: u32);
 
@@ -569,7 +546,6 @@ pub trait ABIMachineSpec {
         uses: CallArgList,
         defs: CallRetList,
         clobbers: PRegSet,
-        opcode: ir::Opcode,
         tmp: Writable<Reg>,
         callee_conv: isa::CallConv,
         caller_conv: isa::CallConv,
@@ -594,12 +570,6 @@ pub trait ABIMachineSpec {
         isa_flags: &Self::F,
     ) -> u32;
 
-    /// Get the current virtual-SP offset from an instruction-emission state.
-    fn get_virtual_sp_offset_from_state(s: &<Self::I as MachInstEmit>::State) -> i64;
-
-    /// Get the "nominal SP to FP" offset from an instruction-emission state.
-    fn get_nominal_sp_to_fp(s: &<Self::I as MachInstEmit>::State) -> i64;
-
     /// Get the ABI-dependent MachineEnv for managing register allocation.
     fn get_machine_env(flags: &settings::Flags, call_conv: isa::CallConv) -> &MachineEnv;
 
@@ -823,8 +793,13 @@ impl SigSet {
         sig: &ir::Signature,
         flags: &settings::Flags,
     ) -> CodegenResult<SigData> {
-        let sret = missing_struct_return(sig);
-        let returns = sret.as_ref().into_iter().chain(&sig.returns);
+        use std::borrow::Cow;
+
+        let returns = if let Some(sret) = missing_struct_return(sig) {
+            Cow::from_iter(std::iter::once(&sret).chain(&sig.returns).copied())
+        } else {
+            Cow::from(sig.returns.as_slice())
+        };
 
         // Compute args and retvals from signature. Handle retvals first,
         // because we may need to add a return-area arg to the args.
@@ -835,7 +810,7 @@ impl SigSet {
         let (sized_stack_ret_space, _) = M::compute_arg_locs(
             sig.call_conv,
             flags,
-            returns,
+            &returns,
             ArgsOrRets::Rets,
             /* extra ret-area ptr = */ false,
             ArgsAccumulator::new(&mut self.abi_args),
@@ -914,39 +889,6 @@ impl SigSet {
         self.rets(sig)[idx].clone()
     }
 
-    /// Return all clobbers for the callsite.
-    pub fn call_clobbers<M: ABIMachineSpec>(&self, sig: Sig) -> PRegSet {
-        let sig_data = &self.sigs[sig];
-        // Get clobbers: all caller-saves. These may include return value
-        // regs, which we will remove from the clobber set below.
-        let mut clobbers = M::get_regs_clobbered_by_call(sig_data.call_conv);
-
-        // Remove retval regs from clobbers. Skip StructRets: these
-        // are not, semantically, returns at the CLIF level, so we
-        // treat such a value as a clobber instead.
-        for ret in self.rets(sig) {
-            if let &ABIArg::Slots {
-                ref slots, purpose, ..
-            } = ret
-            {
-                if purpose == ir::ArgumentPurpose::StructReturn {
-                    continue;
-                }
-                for slot in slots {
-                    match slot {
-                        &ABIArgSlot::Reg { reg, .. } => {
-                            crate::trace!("call_clobbers: retval reg {:?}", reg);
-                            clobbers.remove(PReg::from(reg));
-                        }
-                        _ => {}
-                    }
-                }
-            }
-        }
-
-        clobbers
-    }
-
     /// Get the number of arguments expected.
     pub fn num_args(&self, sig: Sig) -> usize {
         let len = self.args(sig).len();
@@ -974,6 +916,7 @@ impl std::ops::Index<Sig> for SigSet {
 }
 
 /// Structure describing the layout of a function's stack frame.
+#[derive(Clone, Debug, Default)]
 pub struct FrameLayout {
     /// N.B. The areas whose sizes are given in this structure fully
     /// cover the current function's stack frame, from high to low
@@ -985,7 +928,13 @@ pub struct FrameLayout {
     /// need to access it.  Depending on the ABI, we may need to set up a
     /// frame pointer to do so; we also may need to pop this area from the
     /// stack upon return.
-    pub stack_args_size: u32,
+    pub incoming_args_size: u32,
+
+    /// The size of the incoming argument area, taking into account any
+    /// potential increase in size required for tail calls present in the
+    /// function. In the case that no tail calls are present, this value
+    /// will be the same as [`Self::incoming_args_size`].
+    pub tail_args_size: u32,
 
     /// Size of the "setup area", typically holding the return address
     /// and/or the saved frame pointer.  This may be written either during
@@ -1002,8 +951,7 @@ pub struct FrameLayout {
     pub clobber_size: u32,
 
     /// Storage allocated for the fixed part of the stack frame.
-    /// This contains stack slots and spill slots.  The "nominal SP"
-    /// during execution of the function points to the bottom of this.
+    /// This contains stack slots and spill slots.
     pub fixed_frame_storage_size: u32,
 
     /// Stack size to be reserved for outgoing arguments, if used by
@@ -1018,6 +966,33 @@ pub struct FrameLayout {
     pub clobbered_callee_saves: Vec<Writable<RealReg>>,
 }
 
+impl FrameLayout {
+    /// Split the clobbered callee-save registers into integer-class and
+    /// float-class groups.
+    ///
+    /// This method does not currently support vector-class callee-save
+    /// registers because no current backend has them.
+    pub fn clobbered_callee_saves_by_class(&self) -> (&[Writable<RealReg>], &[Writable<RealReg>]) {
+        let (ints, floats) = self.clobbered_callee_saves.split_at(
+            self.clobbered_callee_saves
+                .partition_point(|r| r.to_reg().class() == RegClass::Int),
+        );
+        debug_assert!(floats.iter().all(|r| r.to_reg().class() == RegClass::Float));
+        (ints, floats)
+    }
+
+    /// The size of FP to SP while the frame is active (not during prologue
+    /// setup or epilogue tear down).
+    pub fn active_size(&self) -> u32 {
+        self.outgoing_args_size + self.fixed_frame_storage_size + self.clobber_size
+    }
+
+    /// Get the offset from the SP to the sized stack slots area.
+    pub fn sp_to_sized_stack_slots(&self) -> u32 {
+        self.outgoing_args_size
+    }
+}
+
 /// ABI object for a function body.
 pub struct Callee<M: ABIMachineSpec> {
     /// CLIF-level signature, possibly normalized.
@@ -1034,19 +1009,17 @@ pub struct Callee<M: ABIMachineSpec> {
     stackslots_size: u32,
     /// Stack size to be reserved for outgoing arguments.
     outgoing_args_size: u32,
+    /// Initially the number of bytes originating in the callers frame where stack arguments will
+    /// live. After lowering this number may be larger than the size expected by the function being
+    /// compiled, as tail calls potentially require more space for stack arguments.
+    tail_args_size: u32,
     /// Register-argument defs, to be provided to the `args`
     /// pseudo-inst, and pregs to constrain them to.
     reg_args: Vec<ArgPair>,
-    /// Clobbered registers, from regalloc.
-    clobbered: Vec<Writable<RealReg>>,
-    /// Total number of spillslots, including for 'dynamic' types, from regalloc.
-    spillslots: Option<usize>,
     /// Finalized frame layout for this function.
     frame_layout: Option<FrameLayout>,
     /// The register holding the return-area pointer, if needed.
-    ret_area_ptr: Option<Writable<Reg>>,
-    /// Temp registers required for argument setup, if needed.
-    arg_temp_reg: Vec<Option<Writable<Reg>>>,
+    ret_area_ptr: Option<Reg>,
     /// Calling convention this function expects.
     call_conv: isa::CallConv,
     /// The settings controlling this function's compilation.
@@ -1067,9 +1040,6 @@ pub struct Callee<M: ABIMachineSpec> {
     /// manually register-allocated and carefully only use caller-saved
     /// registers and keep nothing live after this sequence of instructions.
     stack_limit: Option<(Reg, SmallInstVec<M::I>)>,
-    /// Are we to invoke the probestack function in the prologue? If so,
-    /// what is the minimum size at which we must invoke it?
-    probestack_min_frame: Option<u32>,
 
     _mach: PhantomData<M>,
 }
@@ -1096,7 +1066,7 @@ fn checked_round_up(val: u32, mask: u32) -> Option<u32> {
 
 impl<M: ABIMachineSpec> Callee<M> {
     /// Create a new body ABI instance.
-    pub fn new<'a>(
+    pub fn new(
         f: &ir::Function,
         isa: &dyn TargetIsa,
         isa_flags: &M::F,
@@ -1116,9 +1086,9 @@ impl<M: ABIMachineSpec> Callee<M> {
                 || call_conv == isa::CallConv::Cold
                 || call_conv.extends_windows_fastcall()
                 || call_conv == isa::CallConv::WasmtimeSystemV
-                || call_conv == isa::CallConv::AppleAarch64,
-            "Unsupported calling convention: {:?}",
-            call_conv
+                || call_conv == isa::CallConv::AppleAarch64
+                || call_conv == isa::CallConv::Winch,
+            "Unsupported calling convention: {call_conv:?}"
         );
 
         // Compute sized stackslot locations and total stackslot size.
@@ -1129,7 +1099,11 @@ impl<M: ABIMachineSpec> Callee<M> {
             sized_stack_offset = sized_stack_offset
                 .checked_add(data.size)
                 .ok_or(CodegenError::ImplLimitExceeded)?;
-            let mask = M::word_bytes() - 1;
+            // Always at least machine-word-align slots, but also
+            // satisfy the user's requested alignment.
+            debug_assert!(data.align_shift < 32);
+            let align = std::cmp::max(M::word_bytes(), 1u32 << data.align_shift);
+            let mask = align - 1;
             sized_stack_offset = checked_round_up(sized_stack_offset, mask)
                 .ok_or(CodegenError::ImplLimitExceeded)?;
             debug_assert_eq!(stackslot.as_u32() as usize, sized_stackslots.len());
@@ -1159,7 +1133,7 @@ impl<M: ABIMachineSpec> Callee<M> {
         for (dyn_ty, _data) in f.dfg.dynamic_types.iter() {
             let ty = f
                 .get_concrete_dynamic_ty(dyn_ty)
-                .unwrap_or_else(|| panic!("invalid dynamic vector type: {}", dyn_ty));
+                .unwrap_or_else(|| panic!("invalid dynamic vector type: {dyn_ty}"));
             let size = isa.dynamic_vector_bytes(ty);
             dynamic_type_sizes.insert(ty, size);
         }
@@ -1168,25 +1142,11 @@ impl<M: ABIMachineSpec> Callee<M> {
         // stack limit. This can either be specified as a special-purpose
         // argument or as a global value which often calculates the stack limit
         // from the arguments.
-        let stack_limit =
-            get_special_purpose_param_register(f, sigs, sig, ir::ArgumentPurpose::StackLimit)
-                .map(|reg| (reg, smallvec![]))
-                .or_else(|| {
-                    f.stack_limit
-                        .map(|gv| gen_stack_limit::<M>(f, sigs, sig, gv))
-                });
-
-        // Determine whether a probestack call is required for large enough
-        // frames (and the minimum frame size if so).
-        let probestack_min_frame = if flags.enable_probestack() {
-            assert!(
-                !flags.probestack_func_adjusts_sp(),
-                "SP-adjusting probestack not supported in new backends"
-            );
-            Some(1 << flags.probestack_size_log2())
-        } else {
-            None
-        };
+        let stack_limit = f
+            .stack_limit
+            .map(|gv| gen_stack_limit::<M>(f, sigs, sig, gv));
+
+        let tail_args_size = sigs[sig].sized_stack_arg_space;
 
         Ok(Self {
             ir_sig: ensure_struct_return_ptr_is_returned(&f.signature),
@@ -1196,18 +1156,15 @@ impl<M: ABIMachineSpec> Callee<M> {
             sized_stackslots,
             stackslots_size,
             outgoing_args_size: 0,
+            tail_args_size,
             reg_args: vec![],
-            clobbered: vec![],
-            spillslots: None,
             frame_layout: None,
             ret_area_ptr: None,
-            arg_temp_reg: vec![],
             call_conv,
             flags,
             isa_flags: isa_flags.clone(),
             is_leaf: f.is_leaf(),
             stack_limit,
-            probestack_min_frame,
             _mach: PhantomData,
         })
     }
@@ -1319,7 +1276,7 @@ fn generate_gv<M: ABIMachineSpec>(
             base,
             offset,
             global_type: _,
-            readonly: _,
+            flags: _,
         } => {
             let base = generate_gv::<M>(f, sigs, sig, base, insts);
             let into_reg = Writable::from_reg(M::get_stacklimit_reg(f.stencil.signature.call_conv));
@@ -1331,42 +1288,10 @@ fn generate_gv<M: ABIMachineSpec>(
             ));
             return into_reg.to_reg();
         }
-        ref other => panic!("global value for stack limit not supported: {}", other),
+        ref other => panic!("global value for stack limit not supported: {other}"),
     }
 }
 
-fn gen_load_stack_multi<M: ABIMachineSpec>(
-    from: StackAMode,
-    dst: ValueRegs<Writable<Reg>>,
-    ty: Type,
-) -> SmallInstVec<M::I> {
-    let mut ret = smallvec![];
-    let (_, tys) = M::I::rc_for_type(ty).unwrap();
-    let mut offset = 0;
-    // N.B.: registers are given in the `ValueRegs` in target endian order.
-    for (&dst, &ty) in dst.regs().iter().zip(tys.iter()) {
-        ret.push(M::gen_load_stack(from.offset(offset), dst, ty));
-        offset += ty.bytes() as i64;
-    }
-    ret
-}
-
-fn gen_store_stack_multi<M: ABIMachineSpec>(
-    from: StackAMode,
-    src: ValueRegs<Reg>,
-    ty: Type,
-) -> SmallInstVec<M::I> {
-    let mut ret = smallvec![];
-    let (_, tys) = M::I::rc_for_type(ty).unwrap();
-    let mut offset = 0;
-    // N.B.: registers are given in the `ValueRegs` in target endian order.
-    for (&src, &ty) in src.regs().iter().zip(tys.iter()) {
-        ret.push(M::gen_store_stack(from.offset(offset), src, ty));
-        offset += ty.bytes() as i64;
-    }
-    ret
-}
-
 /// If the signature needs to be legalized, then return the struct-return
 /// parameter that should be prepended to its returns. Otherwise, return `None`.
 fn missing_struct_return(sig: &ir::Signature) -> Option<ir::AbiParam> {
@@ -1399,45 +1324,24 @@ impl<M: ABIMachineSpec> Callee<M> {
         &self.ir_sig
     }
 
-    /// Does the ABI-body code need temp registers (and if so, of what type)?
-    /// They will be provided to `init()` as the `temps` arg if so.
-    pub fn temps_needed(&self, sigs: &SigSet) -> Vec<Type> {
-        let mut temp_tys = vec![];
-        for arg in sigs.args(self.sig) {
-            match arg {
-                &ABIArg::ImplicitPtrArg { pointer, .. } => match &pointer {
-                    &ABIArgSlot::Reg { .. } => {}
-                    &ABIArgSlot::Stack { ty, .. } => {
-                        temp_tys.push(ty);
-                    }
-                },
-                _ => {}
-            }
-        }
+    /// Initialize. This is called after the Callee is constructed because it
+    /// may allocate a temp vreg, which can only be allocated once the lowering
+    /// context exists.
+    pub fn init_retval_area(
+        &mut self,
+        sigs: &SigSet,
+        vregs: &mut VRegAllocator<M::I>,
+    ) -> CodegenResult<()> {
         if sigs[self.sig].stack_ret_arg.is_some() {
-            temp_tys.push(M::word_type());
+            let ret_area_ptr = vregs.alloc(M::word_type())?;
+            self.ret_area_ptr = Some(ret_area_ptr.only_reg().unwrap());
         }
-        temp_tys
+        Ok(())
     }
 
-    /// Initialize. This is called after the Callee is constructed because it
-    /// may be provided with a vector of temp vregs, which can only be allocated
-    /// once the lowering context exists.
-    pub fn init(&mut self, sigs: &SigSet, temps: Vec<Writable<Reg>>) {
-        let mut temps_iter = temps.into_iter();
-        for arg in sigs.args(self.sig) {
-            let temp = match arg {
-                &ABIArg::ImplicitPtrArg { pointer, .. } => match &pointer {
-                    &ABIArgSlot::Reg { .. } => None,
-                    &ABIArgSlot::Stack { .. } => Some(temps_iter.next().unwrap()),
-                },
-                _ => None,
-            };
-            self.arg_temp_reg.push(temp);
-        }
-        if sigs[self.sig].stack_ret_arg.is_some() {
-            self.ret_area_ptr = Some(temps_iter.next().unwrap());
-        }
+    /// Get the return area pointer register, if any.
+    pub fn ret_area_ptr(&self) -> Option<Reg> {
+        self.ret_area_ptr
     }
 
     /// Accumulate outgoing arguments.
@@ -1452,6 +1356,15 @@ impl<M: ABIMachineSpec> Callee<M> {
         }
     }
 
+    /// Accumulate the incoming argument area size requirements for a tail call,
+    /// as it could be larger than the incoming arguments of the function
+    /// currently being compiled.
+    pub fn accumulate_tail_args_size(&mut self, size: u32) {
+        if size > self.tail_args_size {
+            self.tail_args_size = size;
+        }
+    }
+
     pub fn is_forward_edge_cfi_enabled(&self) -> bool {
         self.isa_flags.is_forward_edge_cfi_enabled()
     }
@@ -1505,22 +1418,17 @@ impl<M: ABIMachineSpec> Callee<M> {
                     extension,
                     ..
                 } => {
-                    // However, we have to respect the extention mode for stack
+                    // However, we have to respect the extension mode for stack
                     // slots, or else we grab the wrong bytes on big-endian.
                     let ext = M::get_ext_mode(sigs[self.sig].call_conv, extension);
-                    let ty = match (ext, ty_bits(ty) as u32) {
-                        (ArgumentExtension::Uext, n) | (ArgumentExtension::Sext, n)
-                            if n < M::word_bits() =>
-                        {
+                    let ty =
+                        if ext != ArgumentExtension::None && M::word_bits() > ty_bits(ty) as u32 {
                             M::word_type()
-                        }
-                        _ => ty,
-                    };
+                        } else {
+                            ty
+                        };
                     insts.push(M::gen_load_stack(
-                        StackAMode::FPOffset(
-                            M::fp_to_arg_offset(self.call_conv, &self.flags) + offset,
-                            ty,
-                        ),
+                        StackAMode::IncomingArg(offset, sigs[self.sig].sized_stack_arg_space),
                         *into_reg,
                         ty,
                     ));
@@ -1545,12 +1453,8 @@ impl<M: ABIMachineSpec> Callee<M> {
                 } else {
                     // Buffer address is implicitly defined by the ABI.
                     insts.push(M::gen_get_stack_addr(
-                        StackAMode::FPOffset(
-                            M::fp_to_arg_offset(self.call_conv, &self.flags) + offset,
-                            I8,
-                        ),
+                        StackAMode::IncomingArg(offset, sigs[self.sig].sized_stack_arg_space),
                         into_reg,
-                        I8,
                     ));
                 }
             }
@@ -1567,14 +1471,11 @@ impl<M: ABIMachineSpec> Callee<M> {
                         tmp
                     }
                     &ABIArgSlot::Stack { offset, ty, .. } => {
-                        // In this case we need a temp register to hold the address.
-                        // This was allocated in the `init` routine.
-                        let addr_reg = self.arg_temp_reg[idx].unwrap();
+                        let addr_reg = writable_value_regs(vregs.alloc_with_deferred_error(ty))
+                            .only_reg()
+                            .unwrap();
                         insts.push(M::gen_load_stack(
-                            StackAMode::FPOffset(
-                                M::fp_to_arg_offset(self.call_conv, &self.flags) + offset,
-                                ty,
-                            ),
+                            StackAMode::IncomingArg(offset, sigs[self.sig].sized_stack_arg_space),
                             addr_reg,
                             ty,
                         ));
@@ -1587,13 +1488,6 @@ impl<M: ABIMachineSpec> Callee<M> {
         insts
     }
 
-    /// Is the given argument needed in the body (as opposed to, e.g., serving
-    /// only as a special ABI-specific placeholder)? This controls whether
-    /// lowering will copy it to a virtual reg use by CLIF instructions.
-    pub fn arg_is_needed_in_body(&self, _idx: usize) -> bool {
-        true
-    }
-
     /// Generate an instruction which copies a source register to a return value slot.
     pub fn gen_copy_regs_to_retval(
         &self,
@@ -1679,7 +1573,7 @@ impl<M: ABIMachineSpec> Callee<M> {
                                 _ => {}
                             };
                             ret.push(M::gen_store_base_offset(
-                                self.ret_area_ptr.unwrap().to_reg(),
+                                self.ret_area_ptr.unwrap(),
                                 off,
                                 from_reg,
                                 ty,
@@ -1709,17 +1603,14 @@ impl<M: ABIMachineSpec> Callee<M> {
         vregs: &mut VRegAllocator<M::I>,
     ) -> Option<M::I> {
         if let Some(i) = sigs[self.sig].stack_ret_arg {
-            let insts = self.gen_copy_arg_to_regs(
-                sigs,
-                i.into(),
-                ValueRegs::one(self.ret_area_ptr.unwrap()),
-                vregs,
-            );
+            let ret_area_ptr = Writable::from_reg(self.ret_area_ptr.unwrap());
+            let insts =
+                self.gen_copy_arg_to_regs(sigs, i.into(), ValueRegs::one(ret_area_ptr), vregs);
             insts.into_iter().next().map(|inst| {
                 trace!(
                     "gen_retval_area_setup: inst {:?}; ptr reg is {:?}",
                     inst,
-                    self.ret_area_ptr.unwrap().to_reg()
+                    ret_area_ptr.to_reg()
                 );
                 inst
             })
@@ -1741,47 +1632,16 @@ impl<M: ABIMachineSpec> Callee<M> {
         offset: u32,
         into_reg: Writable<Reg>,
     ) -> M::I {
-        // Offset from beginning of stackslot area, which is at nominal SP (see
-        // [MemArg::NominalSPOffset] for more details on nominal SP tracking).
+        // Offset from beginning of stackslot area.
         let stack_off = self.sized_stackslots[slot] as i64;
         let sp_off: i64 = stack_off + (offset as i64);
-        M::gen_get_stack_addr(StackAMode::NominalSPOffset(sp_off, I8), into_reg, I8)
+        M::gen_get_stack_addr(StackAMode::Slot(sp_off), into_reg)
     }
 
     /// Produce an instruction that computes a dynamic stackslot address.
     pub fn dynamic_stackslot_addr(&self, slot: DynamicStackSlot, into_reg: Writable<Reg>) -> M::I {
         let stack_off = self.dynamic_stackslots[slot] as i64;
-        M::gen_get_stack_addr(
-            StackAMode::NominalSPOffset(stack_off, I64X2XN),
-            into_reg,
-            I64X2XN,
-        )
-    }
-
-    /// Load from a spillslot.
-    pub fn load_spillslot(
-        &self,
-        slot: SpillSlot,
-        ty: Type,
-        into_regs: ValueRegs<Writable<Reg>>,
-    ) -> SmallInstVec<M::I> {
-        let sp_off = self.get_spillslot_offset(slot);
-        trace!("load_spillslot: slot {:?} -> sp_off {}", slot, sp_off);
-
-        gen_load_stack_multi::<M>(StackAMode::NominalSPOffset(sp_off, ty), into_regs, ty)
-    }
-
-    /// Store to a spillslot.
-    pub fn store_spillslot(
-        &self,
-        slot: SpillSlot,
-        ty: Type,
-        from_regs: ValueRegs<Reg>,
-    ) -> SmallInstVec<M::I> {
-        let sp_off = self.get_spillslot_offset(slot);
-        trace!("store_spillslot: slot {:?} -> sp_off {}", slot, sp_off);
-
-        gen_store_stack_multi::<M>(StackAMode::NominalSPOffset(sp_off, ty), from_regs, ty)
+        M::gen_get_stack_addr(StackAMode::Slot(stack_off), into_reg)
     }
 
     /// Get an `args` pseudo-inst, if any, that should appear at the
@@ -1804,64 +1664,27 @@ impl<M: ABIMachineSpec> Callee<M> {
 /// These methods of `Callee` may only be called after
 /// regalloc.
 impl<M: ABIMachineSpec> Callee<M> {
-    /// Update with the number of spillslots, post-regalloc.
-    pub fn set_num_spillslots(&mut self, slots: usize) {
-        self.spillslots = Some(slots);
-    }
-
-    /// Update with the clobbered registers, post-regalloc.
-    pub fn set_clobbered(&mut self, clobbered: Vec<Writable<RealReg>>) {
-        self.clobbered = clobbered;
-    }
-
-    /// Generate a stack map, given a list of spillslots and the emission state
-    /// at a given program point (prior to emission of the safepointing
-    /// instruction).
-    pub fn spillslots_to_stack_map(
-        &self,
-        slots: &[SpillSlot],
-        state: &<M::I as MachInstEmit>::State,
-    ) -> StackMap {
-        let virtual_sp_offset = M::get_virtual_sp_offset_from_state(state);
-        let nominal_sp_to_fp = M::get_nominal_sp_to_fp(state);
-        assert!(virtual_sp_offset >= 0);
-        trace!(
-            "spillslots_to_stackmap: slots = {:?}, state = {:?}",
-            slots,
-            state
-        );
-        let map_size = (virtual_sp_offset + nominal_sp_to_fp) as u32;
-        let bytes = M::word_bytes();
-        let map_words = (map_size + bytes - 1) / bytes;
-        let mut bits = std::iter::repeat(false)
-            .take(map_words as usize)
-            .collect::<Vec<bool>>();
-
-        let first_spillslot_word =
-            ((self.stackslots_size + virtual_sp_offset as u32) / bytes) as usize;
-        for &slot in slots {
-            let slot = slot.index();
-            bits[first_spillslot_word + slot] = true;
-        }
-
-        StackMap::from_slice(&bits[..])
-    }
-
     /// Compute the final frame layout, post-regalloc.
     ///
     /// This must be called before gen_prologue or gen_epilogue.
-    pub fn compute_frame_layout(&mut self, sigs: &SigSet) {
+    pub fn compute_frame_layout(
+        &mut self,
+        sigs: &SigSet,
+        spillslots: usize,
+        clobbered: Vec<Writable<RealReg>>,
+    ) {
         let bytes = M::word_bytes();
-        let total_stacksize = self.stackslots_size + bytes * self.spillslots.unwrap() as u32;
+        let total_stacksize = self.stackslots_size + bytes * spillslots as u32;
         let mask = M::stack_align(self.call_conv) - 1;
         let total_stacksize = (total_stacksize + mask) & !mask; // 16-align the stack.
         self.frame_layout = Some(M::compute_frame_layout(
             self.call_conv,
             &self.flags,
             self.signature(),
-            &self.clobbered,
+            &clobbered,
             self.is_leaf,
             self.stack_args_size(sigs),
+            self.tail_args_size,
             total_stacksize,
             self.outgoing_args_size,
         ));
@@ -1872,7 +1695,7 @@ impl<M: ABIMachineSpec> Callee<M> {
     /// This should include any stack frame or other setup necessary to use the
     /// other methods (`load_arg`, `store_retval`, and spillslot accesses.)
     pub fn gen_prologue(&self) -> SmallInstVec<M::I> {
-        let frame_layout = self.frame_layout.as_ref().unwrap();
+        let frame_layout = self.frame_layout();
         let mut insts = smallvec![];
 
         // Set up frame.
@@ -1883,31 +1706,46 @@ impl<M: ABIMachineSpec> Callee<M> {
             &frame_layout,
         ));
 
+        // The stack limit check needs to cover all the stack adjustments we
+        // might make, up to the next stack limit check in any function we
+        // call. Since this happens after frame setup, the current function's
+        // setup area needs to be accounted for in the caller's stack limit
+        // check, but we need to account for any setup area that our callees
+        // might need. Note that s390x may also use the outgoing args area for
+        // backtrace support even in leaf functions, so that should be accounted
+        // for unconditionally.
+        let total_stacksize = (frame_layout.tail_args_size - frame_layout.incoming_args_size)
+            + frame_layout.clobber_size
+            + frame_layout.fixed_frame_storage_size
+            + frame_layout.outgoing_args_size
+            + if self.is_leaf {
+                0
+            } else {
+                frame_layout.setup_area_size
+            };
+
         // Leaf functions with zero stack don't need a stack check if one's
         // specified, otherwise always insert the stack check.
-        let total_stacksize = frame_layout.fixed_frame_storage_size;
         if total_stacksize > 0 || !self.is_leaf {
             if let Some((reg, stack_limit_load)) = &self.stack_limit {
                 insts.extend(stack_limit_load.clone());
                 self.insert_stack_check(*reg, total_stacksize, &mut insts);
             }
 
-            let needs_probestack = self
-                .probestack_min_frame
-                .map_or(false, |min_frame| total_stacksize >= min_frame);
-
-            if needs_probestack {
-                match self.flags.probestack_strategy() {
-                    ProbestackStrategy::Inline => {
-                        let guard_size = 1 << self.flags.probestack_size_log2();
-                        M::gen_inline_probestack(
+            if self.flags.enable_probestack() {
+                let guard_size = 1 << self.flags.probestack_size_log2();
+                if total_stacksize >= guard_size {
+                    match self.flags.probestack_strategy() {
+                        ProbestackStrategy::Inline => M::gen_inline_probestack(
                             &mut insts,
                             self.call_conv,
                             total_stacksize,
                             guard_size,
-                        )
+                        ),
+                        ProbestackStrategy::Outline => {
+                            M::gen_probestack(&mut insts, total_stacksize)
+                        }
                     }
-                    ProbestackStrategy::Outline => M::gen_probestack(&mut insts, total_stacksize),
                 }
             }
         }
@@ -1919,17 +1757,6 @@ impl<M: ABIMachineSpec> Callee<M> {
             &frame_layout,
         ));
 
-        // N.B.: "nominal SP", which we use to refer to stackslots and
-        // spillslots, is defined to be equal to the stack pointer at this point
-        // in the prologue.
-        //
-        // If we push any further data onto the stack in the function
-        // body, we emit a virtual-SP adjustment meta-instruction so
-        // that the nominal SP references behave as if SP were still
-        // at this point. See documentation for
-        // [crate::machinst::abi](this module) for more details
-        // on stackframe layout and nominal SP maintenance.
-
         insts
     }
 
@@ -1939,7 +1766,7 @@ impl<M: ABIMachineSpec> Callee<M> {
     /// emitting this in the lowering logic), because the epilogue code comes
     /// before the return and the two are likely closely related.
     pub fn gen_epilogue(&self) -> SmallInstVec<M::I> {
-        let frame_layout = self.frame_layout.as_ref().unwrap();
+        let frame_layout = self.frame_layout();
         let mut insts = smallvec![];
 
         // Restore clobbered registers.
@@ -1949,13 +1776,7 @@ impl<M: ABIMachineSpec> Callee<M> {
             &frame_layout,
         ));
 
-        // N.B.: we do *not* emit a nominal SP adjustment here, because (i) there will be no
-        // references to nominal SP offsets before the return below, and (ii) the instruction
-        // emission tracks running SP offset linearly (in straight-line order), not according to
-        // the CFG, so early returns in the middle of function bodies would cause an incorrect
-        // offset for the rest of the body.
-
-        // Tear down frame and return.
+        // Tear down frame.
         insts.extend(M::gen_epilogue_frame_restore(
             self.call_conv,
             &self.flags,
@@ -1963,29 +1784,38 @@ impl<M: ABIMachineSpec> Callee<M> {
             &frame_layout,
         ));
 
+        // And return.
+        insts.extend(M::gen_return(
+            self.call_conv,
+            &self.isa_flags,
+            &frame_layout,
+        ));
+
         trace!("Epilogue: {:?}", insts);
         insts
     }
 
+    /// Return a reference to the computed frame layout information. This
+    /// function will panic if it's called before [`Self::compute_frame_layout`].
+    pub fn frame_layout(&self) -> &FrameLayout {
+        self.frame_layout
+            .as_ref()
+            .expect("frame layout not computed before prologue generation")
+    }
+
     /// Returns the full frame size for the given function, after prologue
     /// emission has run. This comprises the spill slots and stack-storage
     /// slots as well as storage for clobbered callee-save registers, but
     /// not arguments arguments pushed at callsites within this function,
     /// or other ephemeral pushes.
     pub fn frame_size(&self) -> u32 {
-        let frame_layout = self
-            .frame_layout
-            .as_ref()
-            .expect("frame size not computed before prologue generation");
+        let frame_layout = self.frame_layout();
         frame_layout.clobber_size + frame_layout.fixed_frame_storage_size
     }
 
-    /// Returns offset from the nominal SP to caller's SP.
-    pub fn nominal_sp_to_caller_sp_offset(&self) -> u32 {
-        let frame_layout = self
-            .frame_layout
-            .as_ref()
-            .expect("frame size not computed before prologue generation");
+    /// Returns offset from the slot base in the current frame to the caller's SP.
+    pub fn slot_base_to_caller_sp_offset(&self) -> u32 {
+        let frame_layout = self.frame_layout();
         frame_layout.clobber_size
             + frame_layout.fixed_frame_storage_size
             + frame_layout.setup_area_size
@@ -2011,9 +1841,9 @@ impl<M: ABIMachineSpec> Callee<M> {
         M::get_number_of_spillslots_for_value(rc, max, &self.isa_flags)
     }
 
-    /// Get the spill slot offset relative to nominal SP.
+    /// Get the spill slot offset relative to the fixed allocation area start.
     pub fn get_spillslot_offset(&self, slot: SpillSlot) -> i64 {
-        // Offset from beginning of spillslot area, which is at nominal SP + stackslots_size.
+        // Offset from beginning of spillslot area.
         let islot = slot.index() as i64;
         let spill_off = islot * M::word_bytes() as i64;
         let sp_off = self.stackslots_size as i64 + spill_off;
@@ -2023,24 +1853,26 @@ impl<M: ABIMachineSpec> Callee<M> {
 
     /// Generate a spill.
     pub fn gen_spill(&self, to_slot: SpillSlot, from_reg: RealReg) -> M::I {
-        let ty = M::I::canonical_type_for_rc(Reg::from(from_reg).class());
-        self.store_spillslot(to_slot, ty, ValueRegs::one(Reg::from(from_reg)))
-            .into_iter()
-            .next()
-            .unwrap()
+        let ty = M::I::canonical_type_for_rc(from_reg.class());
+        debug_assert_eq!(<M>::I::rc_for_type(ty).unwrap().1, &[ty]);
+
+        let sp_off = self.get_spillslot_offset(to_slot);
+        trace!("gen_spill: {from_reg:?} into slot {to_slot:?} at offset {sp_off}");
+
+        let from = StackAMode::Slot(sp_off);
+        <M>::gen_store_stack(from, Reg::from(from_reg), ty)
     }
 
     /// Generate a reload (fill).
     pub fn gen_reload(&self, to_reg: Writable<RealReg>, from_slot: SpillSlot) -> M::I {
         let ty = M::I::canonical_type_for_rc(to_reg.to_reg().class());
-        self.load_spillslot(
-            from_slot,
-            ty,
-            writable_value_regs(ValueRegs::one(Reg::from(to_reg.to_reg()))),
-        )
-        .into_iter()
-        .next()
-        .unwrap()
+        debug_assert_eq!(<M>::I::rc_for_type(ty).unwrap().1, &[ty]);
+
+        let sp_off = self.get_spillslot_offset(from_slot);
+        trace!("gen_reload: {to_reg:?} from slot {from_slot:?} at offset {sp_off}");
+
+        let from = StackAMode::Slot(sp_off);
+        <M>::gen_load_stack(from, to_reg.map(Reg::from), ty)
     }
 }
 
@@ -2067,6 +1899,11 @@ pub struct CallRetPair {
 pub type CallArgList = SmallVec<[CallArgPair; 8]>;
 pub type CallRetList = SmallVec<[CallRetPair; 8]>;
 
+pub enum IsTailCall {
+    Yes,
+    No,
+}
+
 /// ABI object for a callsite.
 pub struct CallSite<M: ABIMachineSpec> {
     /// The called function's signature.
@@ -2076,12 +1913,9 @@ pub struct CallSite<M: ABIMachineSpec> {
     uses: CallArgList,
     /// All defs for the callsite, i.e., return values.
     defs: CallRetList,
-    /// Caller-save clobbers.
-    clobbers: PRegSet,
     /// Call destination.
     dest: CallDest,
-    /// Actual call opcode; used to distinguish various types of calls.
-    opcode: ir::Opcode,
+    is_tail_call: IsTailCall,
     /// Caller's calling convention.
     caller_conv: isa::CallConv,
     /// The settings controlling this compilation.
@@ -2105,19 +1939,18 @@ impl<M: ABIMachineSpec> CallSite<M> {
         sigs: &SigSet,
         sig_ref: ir::SigRef,
         extname: &ir::ExternalName,
+        is_tail_call: IsTailCall,
         dist: RelocDistance,
         caller_conv: isa::CallConv,
         flags: settings::Flags,
     ) -> CallSite<M> {
         let sig = sigs.abi_sig_for_sig_ref(sig_ref);
-        let clobbers = sigs.call_clobbers::<M>(sig);
         CallSite {
             sig,
             uses: smallvec![],
             defs: smallvec![],
-            clobbers,
             dest: CallDest::ExtName(extname.clone(), dist),
-            opcode: ir::Opcode::Call,
+            is_tail_call,
             caller_conv,
             flags,
             _mach: PhantomData,
@@ -2135,14 +1968,12 @@ impl<M: ABIMachineSpec> CallSite<M> {
         flags: settings::Flags,
     ) -> CallSite<M> {
         let sig = sigs.abi_sig_for_signature(sig);
-        let clobbers = sigs.call_clobbers::<M>(sig);
         CallSite {
             sig,
             uses: smallvec![],
             defs: smallvec![],
-            clobbers,
             dest: CallDest::ExtName(extname.clone(), dist),
-            opcode: ir::Opcode::Call,
+            is_tail_call: IsTailCall::No,
             caller_conv,
             flags,
             _mach: PhantomData,
@@ -2155,19 +1986,17 @@ impl<M: ABIMachineSpec> CallSite<M> {
         sigs: &SigSet,
         sig_ref: ir::SigRef,
         ptr: Reg,
-        opcode: ir::Opcode,
+        is_tail_call: IsTailCall,
         caller_conv: isa::CallConv,
         flags: settings::Flags,
     ) -> CallSite<M> {
         let sig = sigs.abi_sig_for_sig_ref(sig_ref);
-        let clobbers = sigs.call_clobbers::<M>(sig);
         CallSite {
             sig,
             uses: smallvec![],
             defs: smallvec![],
-            clobbers,
             dest: CallDest::Reg(ptr),
-            opcode,
+            is_tail_call,
             caller_conv,
             flags,
             _mach: PhantomData,
@@ -2178,23 +2007,17 @@ impl<M: ABIMachineSpec> CallSite<M> {
         &self.dest
     }
 
-    pub(crate) fn opcode(&self) -> ir::Opcode {
-        self.opcode
-    }
-
     pub(crate) fn take_uses(self) -> CallArgList {
         self.uses
     }
-}
 
-fn adjust_stack_and_nominal_sp<M: ABIMachineSpec>(ctx: &mut Lower<M::I>, amount: i32) {
-    if amount == 0 {
-        return;
+    pub(crate) fn sig<'a>(&self, sigs: &'a SigSet) -> &'a SigData {
+        &sigs[self.sig]
     }
-    for inst in M::gen_sp_reg_adjust(amount) {
-        ctx.emit(inst);
+
+    pub(crate) fn is_tail_call(&self) -> bool {
+        matches!(self.is_tail_call, IsTailCall::Yes)
     }
-    ctx.emit(M::gen_nominal_sp_adj(-amount));
 }
 
 impl<M: ABIMachineSpec> CallSite<M> {
@@ -2203,50 +2026,9 @@ impl<M: ABIMachineSpec> CallSite<M> {
         sigs.num_args(self.sig)
     }
 
-    /// Allocate space for building a `return_call`'s temporary frame before we
-    /// copy it over the current frame.
-    pub fn emit_allocate_tail_call_frame(&self, ctx: &mut Lower<M::I>) -> u32 {
-        // The necessary stack space is:
-        //
-        //     sizeof(callee_sig.stack_args)
-        //
-        // Note that any stack return space conceptually belongs to our caller
-        // and the function we are tail calling to has the same return type and
-        // will reuse that stack return space.
-        //
-        // The return address is pushed later on, after the stack arguments are
-        // filled in.
-        let frame_size = ctx.sigs()[self.sig].sized_stack_arg_space;
-
-        let adjustment = -i32::try_from(frame_size).unwrap();
-        adjust_stack_and_nominal_sp::<M>(ctx, adjustment);
-
-        frame_size
-    }
-
-    /// Emit code to pre-adjust the stack, prior to argument copies and call.
-    pub fn emit_stack_pre_adjust(&self, ctx: &mut Lower<M::I>) {
-        let sig = &ctx.sigs()[self.sig];
-        let stack_space = sig.sized_stack_arg_space + sig.sized_stack_ret_space;
-        let stack_space = i32::try_from(stack_space).unwrap();
-        adjust_stack_and_nominal_sp::<M>(ctx, -stack_space);
-    }
-
-    /// Emit code to post-adjust the stack, after call return and return-value copies.
-    pub fn emit_stack_post_adjust(&self, ctx: &mut Lower<M::I>) {
-        let sig = &ctx.sigs()[self.sig];
-
-        let stack_space = if sig.call_conv() == isa::CallConv::Tail {
-            // The "tail" calling convention has callees clean up stack
-            // arguments, not callers. Callers still clean up any stack return
-            // space, however.
-            sig.sized_stack_ret_space
-        } else {
-            sig.sized_stack_arg_space + sig.sized_stack_ret_space
-        };
-        let stack_space = i32::try_from(stack_space).unwrap();
-
-        adjust_stack_and_nominal_sp::<M>(ctx, stack_space);
+    /// Get the number of return values expected.
+    pub fn num_rets(&self, sigs: &SigSet) -> usize {
+        sigs.num_rets(self.sig)
     }
 
     /// Emit a copy of a large argument into its associated stack buffer, if
@@ -2267,9 +2049,8 @@ impl<M: ABIMachineSpec> CallSite<M> {
                 let src_ptr = from_regs.only_reg().unwrap();
                 let dst_ptr = ctx.alloc_tmp(M::word_type()).only_reg().unwrap();
                 ctx.emit(M::gen_get_stack_addr(
-                    StackAMode::SPOffset(offset, I8),
+                    StackAMode::OutgoingArg(offset),
                     dst_ptr,
-                    I8,
                 ));
                 // Emit a memcpy from `src_ptr` to `dst_ptr` of `size` bytes.
                 // N.B.: because we process StructArg params *first*, this is
@@ -2296,47 +2077,18 @@ impl<M: ABIMachineSpec> CallSite<M> {
     /// For large arguments with associated stack buffer, this may
     /// load the address of the buffer into the argument register, if
     /// required by the ABI.
-    pub fn gen_arg(
-        &mut self,
-        ctx: &mut Lower<M::I>,
-        idx: usize,
-        from_regs: ValueRegs<Reg>,
-    ) -> SmallInstVec<M::I> {
-        let mut insts = smallvec![];
+    pub fn gen_arg(&mut self, ctx: &mut Lower<M::I>, idx: usize, from_regs: ValueRegs<Reg>) {
+        let stack_arg_space = ctx.sigs()[self.sig].sized_stack_arg_space;
+        let stack_arg = if self.is_tail_call() {
+            StackAMode::IncomingArg
+        } else {
+            |offset, _| StackAMode::OutgoingArg(offset)
+        };
         let word_rc = M::word_reg_class();
         let word_bits = M::word_bits() as usize;
 
-        // How many temps do we need for extends? Allocate them ahead
-        // of time, since we can't do it while we're iterating over
-        // the sig and immutably borrowing `ctx`.
-        let needed_tmps = match &ctx.sigs().args(self.sig)[idx] {
-            &ABIArg::Slots { ref slots, .. } => slots
-                .iter()
-                .map(|slot| match slot {
-                    &ABIArgSlot::Reg { extension, .. }
-                        if extension != ir::ArgumentExtension::None =>
-                    {
-                        1
-                    }
-                    &ABIArgSlot::Reg { ty, .. } if ty.is_ref() => 1,
-                    &ABIArgSlot::Reg { .. } => 0,
-                    &ABIArgSlot::Stack { extension, .. }
-                        if extension != ir::ArgumentExtension::None =>
-                    {
-                        1
-                    }
-                    &ABIArgSlot::Stack { .. } => 0,
-                })
-                .sum(),
-            ABIArg::ImplicitPtrArg { .. } => 1,
-            _ => 0,
-        };
-        let mut temps: SmallVec<[Writable<Reg>; 16]> = (0..needed_tmps)
-            .map(|_| ctx.alloc_tmp(M::word_type()).only_reg().unwrap())
-            .collect();
-
-        match &ctx.sigs().args(self.sig)[idx] {
-            &ABIArg::Slots { ref slots, .. } => {
+        match ctx.sigs().args(self.sig)[idx].clone() {
+            ABIArg::Slots { ref slots, .. } => {
                 assert_eq!(from_regs.len(), slots.len());
                 for (slot, from_reg) in slots.iter().zip(from_regs.regs().iter()) {
                     match slot {
@@ -2344,44 +2096,30 @@ impl<M: ABIMachineSpec> CallSite<M> {
                             reg, ty, extension, ..
                         } => {
                             let ext = M::get_ext_mode(ctx.sigs()[self.sig].call_conv, extension);
-                            if ext != ir::ArgumentExtension::None && ty_bits(ty) < word_bits {
-                                assert_eq!(word_rc, reg.class());
-                                let signed = match ext {
-                                    ir::ArgumentExtension::Uext => false,
-                                    ir::ArgumentExtension::Sext => true,
-                                    _ => unreachable!(),
+                            let vreg =
+                                if ext != ir::ArgumentExtension::None && ty_bits(ty) < word_bits {
+                                    assert_eq!(word_rc, reg.class());
+                                    let signed = match ext {
+                                        ir::ArgumentExtension::Uext => false,
+                                        ir::ArgumentExtension::Sext => true,
+                                        _ => unreachable!(),
+                                    };
+                                    let extend_result =
+                                        ctx.alloc_tmp(M::word_type()).only_reg().unwrap();
+                                    ctx.emit(M::gen_extend(
+                                        extend_result,
+                                        *from_reg,
+                                        signed,
+                                        ty_bits(ty) as u8,
+                                        word_bits as u8,
+                                    ));
+                                    extend_result.to_reg()
+                                } else {
+                                    *from_reg
                                 };
-                                let extend_result =
-                                    temps.pop().expect("Must have allocated enough temps");
-                                insts.push(M::gen_extend(
-                                    extend_result,
-                                    *from_reg,
-                                    signed,
-                                    ty_bits(ty) as u8,
-                                    word_bits as u8,
-                                ));
-                                self.uses.push(CallArgPair {
-                                    vreg: extend_result.to_reg(),
-                                    preg: reg.into(),
-                                });
-                            } else if ty.is_ref() {
-                                // Reference-typed args need to be
-                                // passed as a copy; the original vreg
-                                // is constrained to the stack and
-                                // this copy is in a reg.
-                                let ref_copy =
-                                    temps.pop().expect("Must have allocated enough temps");
-                                insts.push(M::gen_move(ref_copy, *from_reg, M::word_type()));
-                                self.uses.push(CallArgPair {
-                                    vreg: ref_copy.to_reg(),
-                                    preg: reg.into(),
-                                });
-                            } else {
-                                self.uses.push(CallArgPair {
-                                    vreg: *from_reg,
-                                    preg: reg.into(),
-                                });
-                            }
+
+                            let preg = reg.into();
+                            self.uses.push(CallArgPair { vreg, preg });
                         }
                         &ABIArgSlot::Stack {
                             offset,
@@ -2399,8 +2137,8 @@ impl<M: ABIMachineSpec> CallSite<M> {
                                         _ => unreachable!(),
                                     };
                                     let extend_result =
-                                        temps.pop().expect("Must have allocated enough temps");
-                                    insts.push(M::gen_extend(
+                                        ctx.alloc_tmp(M::word_type()).only_reg().unwrap();
+                                    ctx.emit(M::gen_extend(
                                         extend_result,
                                         *from_reg,
                                         signed,
@@ -2412,8 +2150,8 @@ impl<M: ABIMachineSpec> CallSite<M> {
                                 } else {
                                     (*from_reg, ty)
                                 };
-                            insts.push(M::gen_store_stack(
-                                StackAMode::SPOffset(offset, ty),
+                            ctx.emit(M::gen_store_stack(
+                                stack_arg(offset, stack_arg_space),
                                 data,
                                 ty,
                             ));
@@ -2421,10 +2159,10 @@ impl<M: ABIMachineSpec> CallSite<M> {
                     }
                 }
             }
-            &ABIArg::StructArg { pointer, .. } => {
+            ABIArg::StructArg { pointer, .. } => {
                 assert!(pointer.is_none()); // Only supported via ISLE.
             }
-            &ABIArg::ImplicitPtrArg {
+            ABIArg::ImplicitPtrArg {
                 offset,
                 pointer,
                 ty,
@@ -2432,30 +2170,24 @@ impl<M: ABIMachineSpec> CallSite<M> {
             } => {
                 assert_eq!(from_regs.len(), 1);
                 let vreg = from_regs.regs()[0];
-                let amode = StackAMode::SPOffset(offset, ty);
-                let tmp = temps[0];
-                insts.push(M::gen_get_stack_addr(amode, tmp, ty));
+                let amode = StackAMode::OutgoingArg(offset);
+                let tmp = ctx.alloc_tmp(M::word_type()).only_reg().unwrap();
+                ctx.emit(M::gen_get_stack_addr(amode, tmp));
                 let tmp = tmp.to_reg();
-                insts.push(M::gen_store_base_offset(tmp, 0, vreg, ty));
+                ctx.emit(M::gen_store_base_offset(tmp, 0, vreg, ty));
                 match pointer {
-                    ABIArgSlot::Reg { reg, .. } => {
-                        self.uses.push(CallArgPair {
-                            vreg: tmp,
-                            preg: reg.into(),
-                        });
-                    }
-                    ABIArgSlot::Stack { offset, .. } => {
-                        let ty = M::word_type();
-                        insts.push(M::gen_store_stack(
-                            StackAMode::SPOffset(offset, ty),
-                            tmp,
-                            ty,
-                        ));
-                    }
-                };
+                    ABIArgSlot::Reg { reg, .. } => self.uses.push(CallArgPair {
+                        vreg: tmp,
+                        preg: reg.into(),
+                    }),
+                    ABIArgSlot::Stack { offset, .. } => ctx.emit(M::gen_store_stack(
+                        stack_arg(offset, stack_arg_space),
+                        tmp,
+                        M::word_type(),
+                    )),
+                }
             }
         }
-        insts
     }
 
     /// Call `gen_arg` for each non-hidden argument and emit all instructions
@@ -2473,9 +2205,7 @@ impl<M: ABIMachineSpec> CallSite<M> {
             self.emit_copy_regs_to_buffer(ctx, i, *arg_regs);
         }
         for (i, value_regs) in arg_value_regs.iter().enumerate() {
-            for inst in self.gen_arg(ctx, i, *value_regs) {
-                ctx.emit(inst);
-            }
+            self.gen_arg(ctx, i, *value_regs);
         }
     }
 
@@ -2487,89 +2217,64 @@ impl<M: ABIMachineSpec> CallSite<M> {
                 "if the tail callee has a return pointer, then the tail caller \
                  must as well",
             );
-            for inst in self.gen_arg(ctx, i.into(), ValueRegs::one(ret_area_ptr.to_reg())) {
-                ctx.emit(inst);
-            }
+            self.gen_arg(ctx, i.into(), ValueRegs::one(ret_area_ptr));
         }
     }
 
-    /// Builds a new temporary callee frame for the tail call and puts arguments into
-    /// registers and stack slots (within the new temporary frame).
-    ///
-    /// It is the caller's responsibility to move the temporary callee frame on
-    /// top of the current caller frame before performing the actual tail call.
-    ///
-    /// Returns a pair of the old caller's stack argument size and the new
-    /// callee's stack argument size.
-    pub fn emit_temporary_tail_call_frame(
-        &mut self,
-        ctx: &mut Lower<M::I>,
-        args: isle::ValueSlice,
-    ) -> (u32, u32) {
-        // Allocate additional stack space for the new stack frame. We will
-        // build it in the newly allocated space, but then copy it over our
-        // current frame at the last moment.
-        let new_stack_arg_size = self.emit_allocate_tail_call_frame(ctx);
-        let old_stack_arg_size = ctx.abi().stack_args_size(ctx.sigs());
-
-        // Put all arguments in registers and stack slots (within that newly
-        // allocated stack space).
-        self.emit_args(ctx, args);
-        self.emit_stack_ret_arg_for_tail_call(ctx);
-
-        (new_stack_arg_size, old_stack_arg_size)
-    }
-
     /// Define a return value after the call returns.
     pub fn gen_retval(
         &mut self,
-        ctx: &Lower<M::I>,
+        ctx: &mut Lower<M::I>,
         idx: usize,
-        into_regs: ValueRegs<Writable<Reg>>,
-    ) -> SmallInstVec<M::I> {
+    ) -> (SmallInstVec<M::I>, ValueRegs<Reg>) {
         let mut insts = smallvec![];
-        match &ctx.sigs().rets(self.sig)[idx] {
-            &ABIArg::Slots { ref slots, .. } => {
-                assert_eq!(into_regs.len(), slots.len());
-                for (slot, into_reg) in slots.iter().zip(into_regs.regs().iter()) {
+        let mut into_regs: SmallVec<[Reg; 2]> = smallvec![];
+        let ret = ctx.sigs().rets(self.sig)[idx].clone();
+        match ret {
+            ABIArg::Slots { ref slots, .. } => {
+                for slot in slots {
                     match slot {
                         // Extension mode doesn't matter because we're copying out, not in,
                         // and we ignore high bits in our own registers by convention.
-                        &ABIArgSlot::Reg { reg, .. } => {
+                        &ABIArgSlot::Reg { reg, ty, .. } => {
+                            let into_reg = ctx.alloc_tmp(ty).only_reg().unwrap();
                             self.defs.push(CallRetPair {
-                                vreg: *into_reg,
+                                vreg: into_reg,
                                 preg: reg.into(),
                             });
+                            into_regs.push(into_reg.to_reg());
                         }
                         &ABIArgSlot::Stack { offset, ty, .. } => {
+                            let into_reg = ctx.alloc_tmp(ty).only_reg().unwrap();
                             let sig_data = &ctx.sigs()[self.sig];
-                            let ret_area_base = if sig_data.call_conv() == isa::CallConv::Tail {
-                                // The callee already popped the stack argument
-                                // space for us, so the return area is on top of
-                                // the stack.
-                                0
-                            } else {
-                                // The return area is just below the stack
-                                // argument area on the stack.
-                                sig_data.sized_stack_arg_space()
-                            };
+                            // The outgoing argument area must always be restored after a call,
+                            // ensuring that the return values will be in a consistent place after
+                            // any call.
+                            let ret_area_base = sig_data.sized_stack_arg_space();
                             insts.push(M::gen_load_stack(
-                                StackAMode::SPOffset(offset + ret_area_base, ty),
-                                *into_reg,
+                                StackAMode::OutgoingArg(offset + ret_area_base),
+                                into_reg,
                                 ty,
                             ));
+                            into_regs.push(into_reg.to_reg());
                         }
                     }
                 }
             }
-            &ABIArg::StructArg { .. } => {
+            ABIArg::StructArg { .. } => {
                 panic!("StructArg not supported in return position");
             }
-            &ABIArg::ImplicitPtrArg { .. } => {
+            ABIArg::ImplicitPtrArg { .. } => {
                 panic!("ImplicitPtrArg not supported in return position");
             }
         }
-        insts
+
+        let value_regs = match *into_regs {
+            [a] => ValueRegs::one(a),
+            [a, b] => ValueRegs::two(a, b),
+            _ => panic!("Expected to see one or two slots only from {ret:?}"),
+        };
+        (insts, value_regs)
     }
 
     /// Emit the call itself.
@@ -2591,19 +2296,26 @@ impl<M: ABIMachineSpec> CallSite<M> {
             let rd = ctx.alloc_tmp(word_type).only_reg().unwrap();
             let ret_area_base = ctx.sigs()[self.sig].sized_stack_arg_space();
             ctx.emit(M::gen_get_stack_addr(
-                StackAMode::SPOffset(ret_area_base, I8),
+                StackAMode::OutgoingArg(ret_area_base),
                 rd,
-                I8,
             ));
-            for inst in self.gen_arg(ctx, i.into(), ValueRegs::one(rd.to_reg())) {
-                ctx.emit(inst);
-            }
+            self.gen_arg(ctx, i.into(), ValueRegs::one(rd.to_reg()));
         }
 
-        let (uses, defs) = (
-            mem::replace(&mut self.uses, Default::default()),
-            mem::replace(&mut self.defs, Default::default()),
-        );
+        let uses = mem::take(&mut self.uses);
+        let defs = mem::take(&mut self.defs);
+        let clobbers = {
+            // Get clobbers: all caller-saves. These may include return value
+            // regs, which we will remove from the clobber set below.
+            let mut clobbers = <M>::get_regs_clobbered_by_call(ctx.sigs()[self.sig].call_conv);
+
+            // Remove retval regs from clobbers.
+            for def in &defs {
+                clobbers.remove(PReg::from(def.preg.to_real_reg().unwrap()));
+            }
+
+            clobbers
+        };
 
         let sig = &ctx.sigs()[self.sig];
         let callee_pop_size = if sig.call_conv() == isa::CallConv::Tail {
@@ -2613,15 +2325,31 @@ impl<M: ABIMachineSpec> CallSite<M> {
             0
         };
 
+        let call_conv = sig.call_conv;
+        let ret_space = sig.sized_stack_ret_space;
+        let arg_space = sig.sized_stack_arg_space;
+
+        ctx.abi_mut()
+            .accumulate_outgoing_args_size(ret_space + arg_space);
+
         let tmp = ctx.alloc_tmp(word_type).only_reg().unwrap();
+
+        // Any adjustment to SP to account for required outgoing arguments/stack return values must
+        // be done inside of the call pseudo-op, to ensure that SP is always in a consistent
+        // state for all other instructions. For example, if a tail-call abi function is called
+        // here, the reclamation of the outgoing argument area must be done inside of the call
+        // pseudo-op's emission to ensure that SP is consistent at all other points in the lowered
+        // function. (Except the prologue and epilogue, but those are fairly special parts of the
+        // function that establish the SP invariants that are relied on elsewhere and are generated
+        // after the register allocator has run and thus cannot have register allocator-inserted
+        // references to SP offsets.)
         for inst in M::gen_call(
             &self.dest,
             uses,
             defs,
-            self.clobbers,
-            self.opcode,
+            clobbers,
             tmp,
-            ctx.sigs()[self.sig].call_conv,
+            call_conv,
             self.caller_conv,
             callee_pop_size,
         )
diff --git a/cranelift/codegen/src/machinst/blockorder.rs b/cranelift/codegen/src/machinst/blockorder.rs
index 77bb64f37cd5..b31a5a1bade4 100644
--- a/cranelift/codegen/src/machinst/blockorder.rs
+++ b/cranelift/codegen/src/machinst/blockorder.rs
@@ -62,12 +62,10 @@
 
 use crate::dominator_tree::DominatorTree;
 use crate::entity::SecondaryMap;
-use crate::fx::{FxHashMap, FxHashSet};
 use crate::inst_predicates::visit_block_succs;
 use crate::ir::{Block, Function, Inst, Opcode};
 use crate::{machinst::*, trace};
-
-use smallvec::SmallVec;
+use rustc_hash::{FxHashMap, FxHashSet};
 
 /// Mapping from CLIF BBs to VCode BBs.
 #[derive(Debug)]
@@ -201,7 +199,7 @@ impl BlockLoweringOrder {
                 let range = block_succ_range[block].clone();
 
                 // If chaos-mode is enabled in the control plane, iterate over
-                // the successors in an arbtirary order, which should have no
+                // the successors in an arbitrary order, which should have no
                 // impact on correctness. The order of the blocks is generally
                 // relevant: Uses must be seen before defs for dead-code
                 // elimination.
@@ -308,7 +306,7 @@ impl BlockLoweringOrder {
     /// Get the successor indices for a lowered block.
     pub fn succ_indices(&self, block: BlockIndex) -> (Option<Inst>, &[BlockIndex]) {
         let (opt_inst, range) = &self.lowered_succ_ranges[block.index()];
-        (opt_inst.clone(), &self.lowered_succ_indices[range.clone()])
+        (*opt_inst, &self.lowered_succ_indices[range.clone()])
     }
 
     /// Determine whether the given lowered-block index is cold.
@@ -330,7 +328,7 @@ mod test {
     use crate::flowgraph::ControlFlowGraph;
     use crate::ir::types::*;
     use crate::ir::UserFuncName;
-    use crate::ir::{AbiParam, Function, InstBuilder, Signature};
+    use crate::ir::{AbiParam, InstBuilder, Signature};
     use crate::isa::CallConv;
 
     fn build_test_func(n_blocks: usize, edges: &[(usize, usize)]) -> BlockLoweringOrder {
diff --git a/cranelift/codegen/src/machinst/buffer.rs b/cranelift/codegen/src/machinst/buffer.rs
index aa69feef4929..67cd6c62960c 100644
--- a/cranelift/codegen/src/machinst/buffer.rs
+++ b/cranelift/codegen/src/machinst/buffer.rs
@@ -170,21 +170,21 @@
 //!   only process those which are required during island emission, deferring
 //!   all longer-range fixups to later.
 
-use crate::binemit::{Addend, CodeOffset, Reloc, StackMap};
+use crate::binemit::{Addend, CodeOffset, Reloc};
 use crate::ir::function::FunctionParameters;
-use crate::ir::{ExternalName, Opcode, RelSourceLoc, SourceLoc, TrapCode};
+use crate::ir::{ExternalName, RelSourceLoc, SourceLoc, TrapCode};
 use crate::isa::unwind::UnwindInst;
 use crate::machinst::{
     BlockIndex, MachInstLabelUse, TextSectionBuilder, VCodeConstant, VCodeConstants, VCodeInst,
 };
 use crate::trace;
+use crate::{ir, MachInstEmitState};
 use crate::{timing, VCodeConstantData};
 use cranelift_control::ControlPlane;
 use cranelift_entity::{entity_impl, PrimaryMap};
 use smallvec::SmallVec;
 use std::cmp::Ordering;
 use std::collections::BinaryHeap;
-use std::convert::TryFrom;
 use std::mem;
 use std::string::String;
 use std::vec::Vec;
@@ -249,8 +249,11 @@ pub struct MachBuffer<I: VCodeInst> {
     call_sites: SmallVec<[MachCallSite; 16]>,
     /// Any source location mappings referring to this code.
     srclocs: SmallVec<[MachSrcLoc<Stencil>; 64]>,
-    /// Any stack maps referring to this code.
-    stack_maps: SmallVec<[MachStackMap; 8]>,
+    /// Any user stack maps for this code.
+    ///
+    /// Each entry is an `(offset, span, stack_map)` triple. Entries are sorted
+    /// by code offset, and each stack map covers `span` bytes on the stack.
+    user_stack_maps: SmallVec<[(CodeOffset, u32, ir::UserStackMap); 8]>,
     /// Any unwind info at a given location.
     unwind_info: SmallVec<[(CodeOffset, UnwindInst); 8]>,
     /// The current source location in progress (after `start_srcloc()` and
@@ -311,6 +314,9 @@ pub struct MachBuffer<I: VCodeInst> {
     /// constant may appear in this array multiple times if it was emitted
     /// multiple times.
     used_constants: SmallVec<[(VCodeConstant, CodeOffset); 4]>,
+    /// Indicates when a patchable region is currently open, to guard that it's
+    /// not possible to nest patchable regions.
+    open_patchable: bool,
 }
 
 impl MachBufferFinalized<Stencil> {
@@ -326,7 +332,7 @@ impl MachBufferFinalized<Stencil> {
                 .into_iter()
                 .map(|srcloc| srcloc.apply_base_srcloc(base_srcloc))
                 .collect(),
-            stack_maps: self.stack_maps,
+            user_stack_maps: self.user_stack_maps,
             unwind_info: self.unwind_info,
             alignment: self.alignment,
         }
@@ -353,11 +359,14 @@ pub struct MachBufferFinalized<T: CompilePhase> {
     pub(crate) call_sites: SmallVec<[MachCallSite; 16]>,
     /// Any source location mappings referring to this code.
     pub(crate) srclocs: SmallVec<[T::MachSrcLocType; 64]>,
-    /// Any stack maps referring to this code.
-    pub(crate) stack_maps: SmallVec<[MachStackMap; 8]>,
+    /// Any user stack maps for this code.
+    ///
+    /// Each entry is an `(offset, span, stack_map)` triple. Entries are sorted
+    /// by code offset, and each stack map covers `span` bytes on the stack.
+    pub(crate) user_stack_maps: SmallVec<[(CodeOffset, u32, ir::UserStackMap); 8]>,
     /// Any unwind info at a given location.
     pub unwind_info: SmallVec<[(CodeOffset, UnwindInst); 8]>,
-    /// The requireed alignment of this buffer
+    /// The required alignment of this buffer.
     pub alignment: u32,
 }
 
@@ -377,7 +386,7 @@ pub struct MachLabel(u32);
 entity_impl!(MachLabel);
 
 impl MachLabel {
-    /// Get a label for a block. (The first N MachLabels are always reseved for
+    /// Get a label for a block. (The first N MachLabels are always reserved for
     /// the N blocks in the vcode.)
     pub fn from_block(bindex: BlockIndex) -> MachLabel {
         MachLabel(bindex.index() as u32)
@@ -400,15 +409,27 @@ impl Default for MachLabel {
     }
 }
 
-/// A stack map extent, when creating a stack map.
-pub enum StackMapExtent {
-    /// The stack map starts at this instruction, and ends after the number of upcoming bytes
-    /// (note: this is a code offset diff).
-    UpcomingBytes(CodeOffset),
+/// Represents the beginning of an editable region in the [`MachBuffer`], while code emission is
+/// still occurring. An [`OpenPatchRegion`] is closed by [`MachBuffer::end_patchable`], consuming
+/// the [`OpenPatchRegion`] token in the process.
+pub struct OpenPatchRegion(usize);
+
+/// A region in the [`MachBuffer`] code buffer that can be edited prior to finalization. An example
+/// of where you might want to use this is for patching instructions that mention constants that
+/// won't be known until later: [`MachBuffer::start_patchable`] can be used to begin the patchable
+/// region, instructions can be emitted with placeholder constants, and the [`PatchRegion`] token
+/// can be produced by [`MachBuffer::end_patchable`]. Once the values of those constants are known,
+/// the [`PatchRegion::patch`] function can be used to get a mutable buffer to the instruction
+/// bytes, and the constants uses can be updated directly.
+pub struct PatchRegion {
+    range: std::ops::Range<usize>,
+}
 
-    /// The stack map started at the given offset and ends at the current one. This helps
-    /// architectures where the instruction size has not a fixed length.
-    StartedAtOffset(CodeOffset),
+impl PatchRegion {
+    /// Consume the patch region to yield a mutable slice of the [`MachBuffer`] data buffer.
+    pub fn patch<I: VCodeInst>(self, buffer: &mut MachBuffer<I>) -> &mut [u8] {
+        &mut buffer.data[self.range]
+    }
 }
 
 impl<I: VCodeInst> MachBuffer<I> {
@@ -421,7 +442,7 @@ impl<I: VCodeInst> MachBuffer<I> {
             traps: SmallVec::new(),
             call_sites: SmallVec::new(),
             srclocs: SmallVec::new(),
-            stack_maps: SmallVec::new(),
+            user_stack_maps: SmallVec::new(),
             unwind_info: SmallVec::new(),
             cur_srcloc: None,
             label_offsets: SmallVec::new(),
@@ -437,6 +458,7 @@ impl<I: VCodeInst> MachBuffer<I> {
             labels_at_tail_off: 0,
             constants: Default::default(),
             used_constants: Default::default(),
+            open_patchable: false,
         }
     }
 
@@ -505,8 +527,7 @@ impl<I: VCodeInst> MachBuffer<I> {
         trace!("MachBuffer: align to {}", align_to);
         assert!(
             align_to.is_power_of_two(),
-            "{} is not a power of two",
-            align_to
+            "{align_to} is not a power of two"
         );
         while self.cur_offset() & (align_to - 1) != 0 {
             self.put1(0);
@@ -515,6 +536,29 @@ impl<I: VCodeInst> MachBuffer<I> {
         // Post-invariant: as for `put1()`.
     }
 
+    /// Begin a region of patchable code. There is one requirement for the
+    /// code that is emitted: It must not introduce any instructions that
+    /// could be chomped (branches are an example of this). In other words,
+    /// you must not call [`MachBuffer::add_cond_branch`] or
+    /// [`MachBuffer::add_uncond_branch`] between calls to this method and
+    /// [`MachBuffer::end_patchable`].
+    pub fn start_patchable(&mut self) -> OpenPatchRegion {
+        assert!(!self.open_patchable, "Patchable regions may not be nested");
+        self.open_patchable = true;
+        OpenPatchRegion(usize::try_from(self.cur_offset()).unwrap())
+    }
+
+    /// End a region of patchable code, yielding a [`PatchRegion`] value that
+    /// can be consumed later to produce a one-off mutable slice to the
+    /// associated region of the data buffer.
+    pub fn end_patchable(&mut self, open: OpenPatchRegion) -> PatchRegion {
+        // No need to assert the state of `open_patchable` here, as we take
+        // ownership of the only `OpenPatchable` value.
+        self.open_patchable = false;
+        let end = usize::try_from(self.cur_offset()).unwrap();
+        PatchRegion { range: open.0..end }
+    }
+
     /// Allocate a `Label` to refer to some offset. May not be bound to a fixed
     /// offset yet.
     pub fn get_label(&mut self) -> MachLabel {
@@ -693,7 +737,7 @@ impl<I: VCodeInst> MachBuffer<I> {
     }
 
     /// Inform the buffer of an unconditional branch at the given offset,
-    /// targetting the given label. May be used to optimize branches.
+    /// targeting the given label. May be used to optimize branches.
     /// The last added label-use must correspond to this branch.
     /// This must be called when the current offset is equal to `start`; i.e.,
     /// before actually emitting the branch. This implies that for a branch that
@@ -707,6 +751,10 @@ impl<I: VCodeInst> MachBuffer<I> {
     /// Additional requirement: no labels may be bound between `start` and `end`
     /// (exclusive on both ends).
     pub fn add_uncond_branch(&mut self, start: CodeOffset, end: CodeOffset, target: MachLabel) {
+        debug_assert!(
+            !self.open_patchable,
+            "Branch instruction inserted within a patchable region"
+        );
         assert!(self.cur_offset() == start);
         debug_assert!(end > start);
         assert!(!self.pending_fixup_records.is_empty());
@@ -726,7 +774,7 @@ impl<I: VCodeInst> MachBuffer<I> {
     }
 
     /// Inform the buffer of a conditional branch at the given offset,
-    /// targetting the given label. May be used to optimize branches.
+    /// targeting the given label. May be used to optimize branches.
     /// The last added label-use must correspond to this branch.
     ///
     /// Additional requirement: no labels may be bound between `start` and `end`
@@ -738,10 +786,19 @@ impl<I: VCodeInst> MachBuffer<I> {
         target: MachLabel,
         inverted: &[u8],
     ) {
+        debug_assert!(
+            !self.open_patchable,
+            "Branch instruction inserted within a patchable region"
+        );
         assert!(self.cur_offset() == start);
         debug_assert!(end > start);
         assert!(!self.pending_fixup_records.is_empty());
-        debug_assert!(inverted.len() == (end - start) as usize);
+        debug_assert!(
+            inverted.len() == (end - start) as usize,
+            "branch length = {}, but inverted length = {}",
+            end - start,
+            inverted.len()
+        );
         let fixup = self.pending_fixup_records.len() - 1;
         let inverted = Some(SmallVec::from(inverted));
         self.lazily_clear_labels_at_tail();
@@ -759,6 +816,11 @@ impl<I: VCodeInst> MachBuffer<I> {
     }
 
     fn truncate_last_branch(&mut self) {
+        debug_assert!(
+            !self.open_patchable,
+            "Branch instruction truncated within a patchable region"
+        );
+
         self.lazily_clear_labels_at_tail();
         // Invariants hold at this point.
 
@@ -906,7 +968,7 @@ impl<I: VCodeInst> MachBuffer<I> {
 
             // For any branch, conditional or unconditional:
             // - If the target is a label at the current offset, then remove
-            //   the conditional branch, and reset all labels that targetted
+            //   the conditional branch, and reset all labels that targeted
             //   the current offset (end of branch) to the truncated
             //   end-of-code.
             //
@@ -1157,12 +1219,11 @@ impl<I: VCodeInst> MachBuffer<I> {
     /// patched in once the address of the trap is known.
     ///
     /// This will batch all traps into the end of the function.
-    pub fn defer_trap(&mut self, code: TrapCode, stack_map: Option<StackMap>) -> MachLabel {
+    pub fn defer_trap(&mut self, code: TrapCode) -> MachLabel {
         let label = self.get_label();
         self.pending_traps.push(MachLabelTrap {
             label,
             code,
-            stack_map,
             loc: self.cur_srcloc.map(|(_start, loc)| loc),
         });
         label
@@ -1237,13 +1298,7 @@ impl<I: VCodeInst> MachBuffer<I> {
         // Note that traps are placed first since this typically happens at the
         // end of the function and for disassemblers we try to keep all the code
         // contiguously together.
-        for MachLabelTrap {
-            label,
-            code,
-            stack_map,
-            loc,
-        } in mem::take(&mut self.pending_traps)
-        {
+        for MachLabelTrap { label, code, loc } in mem::take(&mut self.pending_traps) {
             // If this trap has source information associated with it then
             // emit this information for the trap instruction going out now too.
             if let Some(loc) = loc {
@@ -1252,10 +1307,6 @@ impl<I: VCodeInst> MachBuffer<I> {
             self.align_to(I::LabelUse::ALIGN);
             self.bind_label(label, ctrl_plane);
             self.add_trap(code);
-            if let Some(map) = stack_map {
-                let extent = StackMapExtent::UpcomingBytes(I::TRAP_OPCODE.len() as u32);
-                self.add_stack_map(extent, map);
-            }
             self.put_data(I::TRAP_OPCODE);
             if loc.is_some() {
                 self.end_srcloc();
@@ -1360,7 +1411,7 @@ impl<I: VCodeInst> MachBuffer<I> {
                 self.emit_veneer(label, offset, kind);
             } else {
                 let slice = &mut self.data[start..end];
-                trace!("patching in-range!");
+                trace!("patching in-range! slice = {slice:?}; offset = {offset:#x}; label_offset = {label_offset:#x}");
                 kind.patch(slice, offset, label_offset);
             }
         } else {
@@ -1383,8 +1434,7 @@ impl<I: VCodeInst> MachBuffer<I> {
         // backend because we need to implement support for such a veneer.
         assert!(
             kind.supports_veneer(),
-            "jump beyond the range of {:?} but a veneer isn't supported",
-            kind,
+            "jump beyond the range of {kind:?} but a veneer isn't supported",
         );
 
         // Allocate space for a veneer in the island.
@@ -1480,15 +1530,16 @@ impl<I: VCodeInst> MachBuffer<I> {
             traps: self.traps,
             call_sites: self.call_sites,
             srclocs,
-            stack_maps: self.stack_maps,
+            user_stack_maps: self.user_stack_maps,
             unwind_info: self.unwind_info,
             alignment,
         }
     }
 
-    /// Add an external relocation at the current offset.
-    pub fn add_reloc<T: Into<RelocTarget> + Clone>(
+    /// Add an external relocation at the given offset from current offset.
+    pub fn add_reloc_at_offset<T: Into<RelocTarget> + Clone>(
         &mut self,
+        offset: CodeOffset,
         kind: Reloc,
         target: &T,
         addend: Addend,
@@ -1528,13 +1579,23 @@ impl<I: VCodeInst> MachBuffer<I> {
         // when a relocation can't otherwise be resolved later, so it shouldn't
         // actually result in any memory unsafety or anything like that.
         self.relocs.push(MachReloc {
-            offset: self.data.len() as CodeOffset,
+            offset: self.data.len() as CodeOffset + offset,
             kind,
             target,
             addend,
         });
     }
 
+    /// Add an external relocation at the current offset.
+    pub fn add_reloc<T: Into<RelocTarget> + Clone>(
+        &mut self,
+        kind: Reloc,
+        target: &T,
+        addend: Addend,
+    ) {
+        self.add_reloc_at_offset(0, kind, target, addend);
+    }
+
     /// Add a trap record at the current offset.
     pub fn add_trap(&mut self, code: TrapCode) {
         self.traps.push(MachTrap {
@@ -1544,14 +1605,9 @@ impl<I: VCodeInst> MachBuffer<I> {
     }
 
     /// Add a call-site record at the current offset.
-    pub fn add_call_site(&mut self, opcode: Opcode) {
-        debug_assert!(
-            opcode.is_call(),
-            "adding call site info for a non-call instruction."
-        );
+    pub fn add_call_site(&mut self) {
         self.call_sites.push(MachCallSite {
             ret_addr: self.data.len() as CodeOffset,
-            opcode,
         });
     }
 
@@ -1562,8 +1618,11 @@ impl<I: VCodeInst> MachBuffer<I> {
 
     /// Set the `SourceLoc` for code from this offset until the offset at the
     /// next call to `end_srcloc()`.
-    pub fn start_srcloc(&mut self, loc: RelSourceLoc) {
-        self.cur_srcloc = Some((self.cur_offset(), loc));
+    /// Returns the current [CodeOffset] and [RelSourceLoc].
+    pub fn start_srcloc(&mut self, loc: RelSourceLoc) -> (CodeOffset, RelSourceLoc) {
+        let cur = (self.cur_offset(), loc);
+        self.cur_srcloc = Some(cur);
+        cur
     }
 
     /// Mark the end of the `SourceLoc` segment started at the last
@@ -1581,30 +1640,43 @@ impl<I: VCodeInst> MachBuffer<I> {
         }
     }
 
-    /// Add stack map metadata for this program point: a set of stack offsets
-    /// (from SP upward) that contain live references.
+    /// Push a user stack map onto this buffer.
     ///
-    /// The `offset_to_fp` value is the offset from the nominal SP (at which the `stack_offsets`
-    /// are based) and the FP value. By subtracting `offset_to_fp` from each `stack_offsets`
-    /// element, one can obtain live-reference offsets from FP instead.
-    pub fn add_stack_map(&mut self, extent: StackMapExtent, stack_map: StackMap) {
-        let (start, end) = match extent {
-            StackMapExtent::UpcomingBytes(insn_len) => {
-                let start_offset = self.cur_offset();
-                (start_offset, start_offset + insn_len)
-            }
-            StackMapExtent::StartedAtOffset(start_offset) => {
-                let end_offset = self.cur_offset();
-                debug_assert!(end_offset >= start_offset);
-                (start_offset, end_offset)
-            }
-        };
-        trace!("Adding stack map for offsets {start:#x}..{end:#x}");
-        self.stack_maps.push(MachStackMap {
-            offset: start,
-            offset_end: end,
-            stack_map,
-        });
+    /// The stack map is associated with the given `return_addr` code
+    /// offset. This must be the PC for the instruction just *after* this stack
+    /// map's associated instruction. For example in the sequence `call $foo;
+    /// add r8, rax`, the `return_addr` must be the offset of the start of the
+    /// `add` instruction.
+    ///
+    /// Stack maps must be pushed in sorted `return_addr` order.
+    pub fn push_user_stack_map(
+        &mut self,
+        emit_state: &I::State,
+        return_addr: CodeOffset,
+        mut stack_map: ir::UserStackMap,
+    ) {
+        let span = emit_state.frame_layout().active_size();
+        trace!("Adding user stack map @ {return_addr:#x} spanning {span} bytes: {stack_map:?}");
+
+        debug_assert!(
+            self.user_stack_maps
+                .last()
+                .map_or(true, |(prev_addr, _, _)| *prev_addr < return_addr),
+            "pushed stack maps out of order: {} is not less than {}",
+            self.user_stack_maps.last().unwrap().0,
+            return_addr,
+        );
+
+        stack_map.finalize(emit_state.frame_layout().sp_to_sized_stack_slots());
+        self.user_stack_maps.push((return_addr, span, stack_map));
+    }
+}
+
+impl<I: VCodeInst> Extend<u8> for MachBuffer<I> {
+    fn extend<T: IntoIterator<Item = u8>>(&mut self, iter: T) {
+        for b in iter {
+            self.put1(b);
+        }
     }
 }
 
@@ -1625,7 +1697,7 @@ impl<T: CompilePhase> MachBufferFinalized<T> {
         use std::fmt::Write;
         let mut s = String::with_capacity(self.data.len() * 2);
         for b in &self.data {
-            write!(&mut s, "{:02X}", b).unwrap();
+            write!(&mut s, "{b:02X}").unwrap();
         }
         s
     }
@@ -1656,9 +1728,14 @@ impl<T: CompilePhase> MachBufferFinalized<T> {
         &self.traps[..]
     }
 
-    /// Get the stack map metadata for this code.
-    pub fn stack_maps(&self) -> &[MachStackMap] {
-        &self.stack_maps[..]
+    /// Get the user stack map metadata for this code.
+    pub fn user_stack_maps(&self) -> &[(CodeOffset, u32, ir::UserStackMap)] {
+        &self.user_stack_maps
+    }
+
+    /// Take this buffer's user strack map metadata.
+    pub fn take_user_stack_maps(&mut self) -> SmallVec<[(CodeOffset, u32, ir::UserStackMap); 8]> {
+        mem::take(&mut self.user_stack_maps)
     }
 
     /// Get the list of call sites for this code.
@@ -1688,8 +1765,6 @@ struct MachLabelTrap {
     label: MachLabel,
     /// The code associated with this trap.
     code: TrapCode,
-    /// An optional stack map to associate with this trap.
-    stack_map: Option<StackMap>,
     /// An optional source location to assign for this trap.
     loc: Option<RelSourceLoc>,
 }
@@ -1831,8 +1906,6 @@ pub struct MachTrap {
 pub struct MachCallSite {
     /// The offset of the call's return address, *relative to the containing section*.
     pub ret_addr: CodeOffset,
-    /// The call's opcode.
-    pub opcode: Opcode,
 }
 
 /// A source-location mapping resulting from a compilation.
@@ -1864,23 +1937,6 @@ impl MachSrcLoc<Stencil> {
     }
 }
 
-/// Record of stack map metadata: stack offsets containing references.
-#[derive(Clone, Debug, PartialEq)]
-#[cfg_attr(
-    feature = "enable-serde",
-    derive(serde_derive::Serialize, serde_derive::Deserialize)
-)]
-pub struct MachStackMap {
-    /// The code offset at which this stack map applies.
-    pub offset: CodeOffset,
-    /// The code offset just past the "end" of the instruction: that is, the
-    /// offset of the first byte of the following instruction, or equivalently,
-    /// the start offset plus the instruction length.
-    pub offset_end: CodeOffset,
-    /// The stack map itself.
-    pub stack_map: StackMap,
-}
-
 /// Record of branch instruction in the buffer, to facilitate editing.
 #[derive(Clone, Debug)]
 struct MachBranch {
@@ -2005,8 +2061,6 @@ mod test {
     use crate::isa::aarch64::inst::{BranchTarget, CondBrKind, EmitInfo, Inst};
     use crate::machinst::{MachInstEmit, MachInstEmitState};
     use crate::settings;
-    use std::default::Default;
-    use std::vec::Vec;
 
     fn label(n: u32) -> MachLabel {
         MachLabel::from_block(BlockIndex::new(n as usize))
@@ -2025,7 +2079,7 @@ mod test {
         buf.reserve_labels_for_blocks(2);
         buf.bind_label(label(0), state.ctrl_plane_mut());
         let inst = Inst::Jump { dest: target(1) };
-        inst.emit(&[], &mut buf, &info, &mut state);
+        inst.emit(&mut buf, &info, &mut state);
         buf.bind_label(label(1), state.ctrl_plane_mut());
         let buf = buf.finish(&constants, state.ctrl_plane_mut());
         assert_eq!(0, buf.total_size());
@@ -2046,15 +2100,15 @@ mod test {
             taken: target(1),
             not_taken: target(2),
         };
-        inst.emit(&[], &mut buf, &info, &mut state);
+        inst.emit(&mut buf, &info, &mut state);
 
         buf.bind_label(label(1), state.ctrl_plane_mut());
         let inst = Inst::Jump { dest: target(3) };
-        inst.emit(&[], &mut buf, &info, &mut state);
+        inst.emit(&mut buf, &info, &mut state);
 
         buf.bind_label(label(2), state.ctrl_plane_mut());
         let inst = Inst::Jump { dest: target(3) };
-        inst.emit(&[], &mut buf, &info, &mut state);
+        inst.emit(&mut buf, &info, &mut state);
 
         buf.bind_label(label(3), state.ctrl_plane_mut());
 
@@ -2077,17 +2131,17 @@ mod test {
             taken: target(1),
             not_taken: target(2),
         };
-        inst.emit(&[], &mut buf, &info, &mut state);
+        inst.emit(&mut buf, &info, &mut state);
 
         buf.bind_label(label(1), state.ctrl_plane_mut());
         let inst = Inst::Nop4;
-        inst.emit(&[], &mut buf, &info, &mut state);
+        inst.emit(&mut buf, &info, &mut state);
 
         buf.bind_label(label(2), state.ctrl_plane_mut());
         let inst = Inst::Udf {
             trap_code: TrapCode::Interrupt,
         };
-        inst.emit(&[], &mut buf, &info, &mut state);
+        inst.emit(&mut buf, &info, &mut state);
 
         buf.bind_label(label(3), state.ctrl_plane_mut());
 
@@ -2099,9 +2153,9 @@ mod test {
             kind: CondBrKind::NotZero(xreg(0)),
             trap_code: TrapCode::Interrupt,
         };
-        inst.emit(&[], &mut buf2, &info, &mut state);
+        inst.emit(&mut buf2, &info, &mut state);
         let inst = Inst::Nop4;
-        inst.emit(&[], &mut buf2, &info, &mut state);
+        inst.emit(&mut buf2, &info, &mut state);
 
         let buf2 = buf2.finish(&constants, state.ctrl_plane_mut());
 
@@ -2123,7 +2177,7 @@ mod test {
             taken: target(2),
             not_taken: target(3),
         };
-        inst.emit(&[], &mut buf, &info, &mut state);
+        inst.emit(&mut buf, &info, &mut state);
 
         buf.bind_label(label(1), state.ctrl_plane_mut());
         while buf.cur_offset() < 2000000 {
@@ -2131,16 +2185,16 @@ mod test {
                 buf.emit_island(0, state.ctrl_plane_mut());
             }
             let inst = Inst::Nop4;
-            inst.emit(&[], &mut buf, &info, &mut state);
+            inst.emit(&mut buf, &info, &mut state);
         }
 
         buf.bind_label(label(2), state.ctrl_plane_mut());
         let inst = Inst::Nop4;
-        inst.emit(&[], &mut buf, &info, &mut state);
+        inst.emit(&mut buf, &info, &mut state);
 
         buf.bind_label(label(3), state.ctrl_plane_mut());
         let inst = Inst::Nop4;
-        inst.emit(&[], &mut buf, &info, &mut state);
+        inst.emit(&mut buf, &info, &mut state);
 
         let buf = buf.finish(&constants, state.ctrl_plane_mut());
 
@@ -2170,7 +2224,7 @@ mod test {
             // go directly to the target.
             not_taken: BranchTarget::ResolvedOffset(2000000 + 4 - 4),
         };
-        inst.emit(&[], &mut buf2, &info, &mut state);
+        inst.emit(&mut buf2, &info, &mut state);
 
         let buf2 = buf2.finish(&constants, state.ctrl_plane_mut());
 
@@ -2188,16 +2242,16 @@ mod test {
 
         buf.bind_label(label(0), state.ctrl_plane_mut());
         let inst = Inst::Nop4;
-        inst.emit(&[], &mut buf, &info, &mut state);
+        inst.emit(&mut buf, &info, &mut state);
 
         buf.bind_label(label(1), state.ctrl_plane_mut());
         let inst = Inst::Nop4;
-        inst.emit(&[], &mut buf, &info, &mut state);
+        inst.emit(&mut buf, &info, &mut state);
 
         buf.bind_label(label(2), state.ctrl_plane_mut());
         while buf.cur_offset() < 2000000 {
             let inst = Inst::Nop4;
-            inst.emit(&[], &mut buf, &info, &mut state);
+            inst.emit(&mut buf, &info, &mut state);
         }
 
         buf.bind_label(label(3), state.ctrl_plane_mut());
@@ -2206,7 +2260,7 @@ mod test {
             taken: target(0),
             not_taken: target(1),
         };
-        inst.emit(&[], &mut buf, &info, &mut state);
+        inst.emit(&mut buf, &info, &mut state);
 
         let buf = buf.finish(&constants, state.ctrl_plane_mut());
 
@@ -2219,11 +2273,11 @@ mod test {
             taken: BranchTarget::ResolvedOffset(8),
             not_taken: BranchTarget::ResolvedOffset(4 - (2000000 + 4)),
         };
-        inst.emit(&[], &mut buf2, &info, &mut state);
+        inst.emit(&mut buf2, &info, &mut state);
         let inst = Inst::Jump {
             dest: BranchTarget::ResolvedOffset(-(2000000 + 8)),
         };
-        inst.emit(&[], &mut buf2, &info, &mut state);
+        inst.emit(&mut buf2, &info, &mut state);
 
         let buf2 = buf2.finish(&constants, state.ctrl_plane_mut());
 
@@ -2278,38 +2332,38 @@ mod test {
             taken: target(1),
             not_taken: target(2),
         };
-        inst.emit(&[], &mut buf, &info, &mut state);
+        inst.emit(&mut buf, &info, &mut state);
 
         buf.bind_label(label(1), state.ctrl_plane_mut());
         let inst = Inst::Jump { dest: target(3) };
-        inst.emit(&[], &mut buf, &info, &mut state);
+        inst.emit(&mut buf, &info, &mut state);
 
         buf.bind_label(label(2), state.ctrl_plane_mut());
         let inst = Inst::Nop4;
-        inst.emit(&[], &mut buf, &info, &mut state);
-        inst.emit(&[], &mut buf, &info, &mut state);
+        inst.emit(&mut buf, &info, &mut state);
+        inst.emit(&mut buf, &info, &mut state);
         let inst = Inst::Jump { dest: target(0) };
-        inst.emit(&[], &mut buf, &info, &mut state);
+        inst.emit(&mut buf, &info, &mut state);
 
         buf.bind_label(label(3), state.ctrl_plane_mut());
         let inst = Inst::Jump { dest: target(4) };
-        inst.emit(&[], &mut buf, &info, &mut state);
+        inst.emit(&mut buf, &info, &mut state);
 
         buf.bind_label(label(4), state.ctrl_plane_mut());
         let inst = Inst::Jump { dest: target(5) };
-        inst.emit(&[], &mut buf, &info, &mut state);
+        inst.emit(&mut buf, &info, &mut state);
 
         buf.bind_label(label(5), state.ctrl_plane_mut());
         let inst = Inst::Jump { dest: target(7) };
-        inst.emit(&[], &mut buf, &info, &mut state);
+        inst.emit(&mut buf, &info, &mut state);
 
         buf.bind_label(label(6), state.ctrl_plane_mut());
         let inst = Inst::Nop4;
-        inst.emit(&[], &mut buf, &info, &mut state);
+        inst.emit(&mut buf, &info, &mut state);
 
         buf.bind_label(label(7), state.ctrl_plane_mut());
         let inst = Inst::Ret {};
-        inst.emit(&[], &mut buf, &info, &mut state);
+        inst.emit(&mut buf, &info, &mut state);
 
         let buf = buf.finish(&constants, state.ctrl_plane_mut());
 
@@ -2351,23 +2405,23 @@ mod test {
 
         buf.bind_label(label(0), state.ctrl_plane_mut());
         let inst = Inst::Jump { dest: target(1) };
-        inst.emit(&[], &mut buf, &info, &mut state);
+        inst.emit(&mut buf, &info, &mut state);
 
         buf.bind_label(label(1), state.ctrl_plane_mut());
         let inst = Inst::Jump { dest: target(2) };
-        inst.emit(&[], &mut buf, &info, &mut state);
+        inst.emit(&mut buf, &info, &mut state);
 
         buf.bind_label(label(2), state.ctrl_plane_mut());
         let inst = Inst::Jump { dest: target(3) };
-        inst.emit(&[], &mut buf, &info, &mut state);
+        inst.emit(&mut buf, &info, &mut state);
 
         buf.bind_label(label(3), state.ctrl_plane_mut());
         let inst = Inst::Jump { dest: target(4) };
-        inst.emit(&[], &mut buf, &info, &mut state);
+        inst.emit(&mut buf, &info, &mut state);
 
         buf.bind_label(label(4), state.ctrl_plane_mut());
         let inst = Inst::Jump { dest: target(1) };
-        inst.emit(&[], &mut buf, &info, &mut state);
+        inst.emit(&mut buf, &info, &mut state);
 
         let buf = buf.finish(&constants, state.ctrl_plane_mut());
 
@@ -2392,7 +2446,7 @@ mod test {
         buf.put1(2);
         buf.add_trap(TrapCode::IntegerOverflow);
         buf.add_trap(TrapCode::IntegerDivisionByZero);
-        buf.add_call_site(Opcode::Call);
+        buf.add_call_site();
         buf.add_reloc(
             Reloc::Abs4,
             &ExternalName::User(UserExternalNameRef::new(0)),
@@ -2423,9 +2477,9 @@ mod test {
         assert_eq!(
             buf.call_sites()
                 .iter()
-                .map(|call_site| (call_site.ret_addr, call_site.opcode))
+                .map(|call_site| call_site.ret_addr)
                 .collect::<Vec<_>>(),
-            vec![(2, Opcode::Call)]
+            vec![2]
         );
         assert_eq!(
             buf.relocs()
diff --git a/cranelift/codegen/src/machinst/compile.rs b/cranelift/codegen/src/machinst/compile.rs
index 07440489a91c..4c42e61ca3c4 100644
--- a/cranelift/codegen/src/machinst/compile.rs
+++ b/cranelift/codegen/src/machinst/compile.rs
@@ -1,11 +1,13 @@
 //! Compilation backend pipeline: optimized IR to VCode / binemit.
 
 use crate::dominator_tree::DominatorTree;
+use crate::ir::pcc;
 use crate::ir::Function;
 use crate::isa::TargetIsa;
 use crate::machinst::*;
 use crate::timing;
 use crate::trace;
+use crate::CodegenError;
 
 use regalloc2::RegallocOptions;
 
@@ -24,10 +26,11 @@ pub fn compile<B: LowerBackend + TargetIsa>(
     let block_order = BlockLoweringOrder::new(f, domtree, ctrl_plane);
 
     // Build the lowering context.
-    let lower = crate::machinst::Lower::new(f, abi, emit_info, block_order, sigs)?;
+    let lower =
+        crate::machinst::Lower::new(f, abi, emit_info, block_order, sigs, b.flags().clone())?;
 
     // Lower the IR.
-    let vcode = {
+    let mut vcode = {
         log::debug!(
             "Number of CLIF instructions to lower: {}",
             f.dfg.num_insts()
@@ -45,6 +48,11 @@ pub fn compile<B: LowerBackend + TargetIsa>(
     log::debug!("Number of lowered vcode blocks: {}", vcode.num_blocks());
     trace!("vcode from lowering: \n{:?}", vcode);
 
+    // Perform validation of proof-carrying-code facts, if requested.
+    if b.flags().enable_pcc() {
+        pcc::check_vcode_facts(f, &mut vcode, b).map_err(CodegenError::Pcc)?;
+    }
+
     // Perform register allocation.
     let regalloc_result = {
         let _tt = timing::regalloc();
diff --git a/cranelift/codegen/src/machinst/helpers.rs b/cranelift/codegen/src/machinst/helpers.rs
index 81b314366219..411af0cdc7f9 100644
--- a/cranelift/codegen/src/machinst/helpers.rs
+++ b/cranelift/codegen/src/machinst/helpers.rs
@@ -8,16 +8,6 @@ pub fn ty_bits(ty: Type) -> usize {
     ty.bits() as usize
 }
 
-/// Is the type represented by an integer (not float) at the machine level?
-pub(crate) fn ty_has_int_representation(ty: Type) -> bool {
-    ty.is_int() || ty.is_ref()
-}
-
-/// Is the type represented by a float or vector value at the machine level?
-pub(crate) fn ty_has_float_or_vec_representation(ty: Type) -> bool {
-    ty.is_vector() || ty.is_float()
-}
-
 /// Align a size up to a power-of-two alignment.
 pub(crate) fn align_to<N>(x: N, alignment: N) -> N
 where
diff --git a/cranelift/codegen/src/machinst/inst_common.rs b/cranelift/codegen/src/machinst/inst_common.rs
index daab9dc5310b..3fa341ae9fa3 100644
--- a/cranelift/codegen/src/machinst/inst_common.rs
+++ b/cranelift/codegen/src/machinst/inst_common.rs
@@ -17,6 +17,7 @@ pub(crate) struct InsnInput {
 
 /// Identifier for a particular output of an instruction.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[allow(dead_code)]
 pub(crate) struct InsnOutput {
     pub(crate) insn: IRInst,
     pub(crate) output: usize,
diff --git a/cranelift/codegen/src/machinst/isle.rs b/cranelift/codegen/src/machinst/isle.rs
index f14d1045185e..49f22271179e 100644
--- a/cranelift/codegen/src/machinst/isle.rs
+++ b/cranelift/codegen/src/machinst/isle.rs
@@ -6,17 +6,13 @@ use std::cell::Cell;
 
 pub use super::MachLabel;
 use super::RetPair;
-pub use crate::ir::{
-    condcodes, condcodes::CondCode, dynamic_to_fixed, ArgumentExtension, ArgumentPurpose, Constant,
-    DynamicStackSlot, ExternalName, FuncRef, GlobalValue, Immediate, SigRef, StackSlot,
-};
-pub use crate::isa::unwind::UnwindInst;
-pub use crate::isa::TargetIsa;
+pub use crate::ir::{condcodes::CondCode, *};
+pub use crate::isa::{unwind::UnwindInst, TargetIsa};
 pub use crate::machinst::{
-    ABIArg, ABIArgSlot, InputSourceInst, Lower, LowerBackend, RealReg, Reg, RelocDistance, Sig,
-    VCodeInst, Writable,
+    ABIArg, ABIArgSlot, ABIMachineSpec, CallSite, InputSourceInst, Lower, LowerBackend, RealReg,
+    Reg, RelocDistance, Sig, VCodeInst, Writable,
 };
-pub use crate::settings::{OptLevel, TlsModel};
+pub use crate::settings::{StackSwitchModel, TlsModel};
 
 pub type Unit = ();
 pub type ValueSlice = (ValueList, usize);
@@ -46,7 +42,10 @@ pub enum RangeView {
 #[doc(hidden)]
 macro_rules! isle_lower_prelude_methods {
     () => {
-        isle_common_prelude_methods!();
+        crate::isle_lower_prelude_methods!(MInst);
+    };
+    ($inst:ty) => {
+        crate::isle_common_prelude_methods!();
 
         #[inline]
         fn value_type(&mut self, val: Value) -> Type {
@@ -212,8 +211,13 @@ macro_rules! isle_lower_prelude_methods {
         }
 
         #[inline]
-        fn inst_data(&mut self, inst: Inst) -> InstructionData {
-            self.lower_ctx.dfg().insts[inst]
+        fn inst_data(&mut self, inst: Inst) -> (Type, InstructionData) {
+            let ty = match self.first_result(inst) {
+                Some(v) => self.value_type(v),
+                None => types::INVALID,
+            };
+            let data = self.lower_ctx.dfg().insts[inst];
+            (ty, data)
         }
 
         #[inline]
@@ -224,12 +228,22 @@ macro_rules! isle_lower_prelude_methods {
         #[inline]
         fn i64_from_iconst(&mut self, val: Value) -> Option<i64> {
             let inst = self.def_inst(val)?;
-            let constant = self.lower_ctx.get_constant(inst)? as i64;
+            let constant = match self.lower_ctx.data(inst) {
+                InstructionData::UnaryImm {
+                    opcode: Opcode::Iconst,
+                    imm,
+                } => imm.bits(),
+                _ => return None,
+            };
             let ty = self.lower_ctx.output_ty(inst, 0);
             let shift_amt = std::cmp::max(0, 64 - self.ty_bits(ty));
             Some((constant << shift_amt) >> shift_amt)
         }
 
+        fn i32_from_iconst(&mut self, val: Value) -> Option<i32> {
+            self.i64_from_iconst(val)?.try_into().ok()
+        }
+
         fn zero_value(&mut self, value: Value) -> Option<Value> {
             let insn = self.def_inst(value);
             if insn.is_some() {
@@ -244,7 +258,7 @@ macro_rules! isle_lower_prelude_methods {
                         return self.zero_value(arg);
                     }
                     InstructionData::UnaryConst {
-                        opcode: Opcode::Vconst,
+                        opcode: Opcode::Vconst | Opcode::F128const,
                         constant_handle,
                     } => {
                         let constant_data =
@@ -262,6 +276,13 @@ macro_rules! isle_lower_prelude_methods {
                             return None;
                         }
                     }
+                    InstructionData::UnaryIeee16 { imm, .. } => {
+                        if imm.bits() == 0 {
+                            return Some(value);
+                        } else {
+                            return None;
+                        }
+                    }
                     InstructionData::UnaryIeee32 { imm, .. } => {
                         if imm.bits() == 0 {
                             return Some(value);
@@ -324,6 +345,11 @@ macro_rules! isle_lower_prelude_methods {
             }
         }
 
+        #[inline]
+        fn stack_switch_model(&mut self) -> Option<StackSwitchModel> {
+            Some(self.backend.flags().stack_switch_model())
+        }
+
         #[inline]
         fn func_ref_data(&mut self, func_ref: FuncRef) -> (SigRef, ExternalName, RelocDistance) {
             let funcdata = &self.lower_ctx.dfg().ext_funcs[func_ref];
@@ -500,6 +526,10 @@ macro_rules! isle_lower_prelude_methods {
             }
         }
 
+        fn abi_unwrap_ret_area_ptr(&mut self) -> Reg {
+            self.lower_ctx.abi().ret_area_ptr().unwrap()
+        }
+
         fn abi_stackslot_addr(
             &mut self,
             dst: WritableReg,
@@ -510,6 +540,7 @@ macro_rules! isle_lower_prelude_methods {
             self.lower_ctx
                 .abi()
                 .sized_stackslot_addr(stack_slot, offset, dst)
+                .into()
         }
 
         fn abi_dynamic_stackslot_addr(
@@ -522,7 +553,10 @@ macro_rules! isle_lower_prelude_methods {
                 .abi()
                 .dynamic_stackslot_offsets()
                 .is_valid(stack_slot));
-            self.lower_ctx.abi().dynamic_stackslot_addr(stack_slot, dst)
+            self.lower_ctx
+                .abi()
+                .dynamic_stackslot_addr(stack_slot, dst)
+                .into()
         }
 
         fn real_reg_to_reg(&mut self, reg: RealReg) -> Reg {
@@ -563,6 +597,13 @@ macro_rules! isle_lower_prelude_methods {
             Some(value)
         }
 
+        #[inline]
+        fn uimm8(&mut self, x: Imm64) -> Option<u8> {
+            let x64: i64 = x.into();
+            let x8: u8 = x64.try_into().ok()?;
+            Some(x8)
+        }
+
         #[inline]
         fn preg_to_reg(&mut self, preg: PReg) -> Reg {
             preg.into()
@@ -570,7 +611,7 @@ macro_rules! isle_lower_prelude_methods {
 
         #[inline]
         fn gen_move(&mut self, ty: Type, dst: WritableReg, src: Reg) -> MInst {
-            MInst::gen_move(dst, src, ty)
+            <$inst>::gen_move(dst, src, ty).into()
         }
 
         /// Generate the return instruction.
@@ -683,6 +724,11 @@ macro_rules! isle_lower_prelude_methods {
         fn jump_table_size(&mut self, targets: &BoxVecMachLabel) -> u32 {
             targets.len() as u32
         }
+
+        fn add_range_fact(&mut self, reg: Reg, bits: u16, min: u64, max: u64) -> Reg {
+            self.lower_ctx.add_range_fact(reg, bits, min, max);
+            reg
+        }
     };
 }
 
@@ -737,11 +783,11 @@ macro_rules! isle_prelude_caller_methods {
             let caller_conv = self.lower_ctx.abi().call_conv(self.lower_ctx.sigs());
             let sig = &self.lower_ctx.dfg().signatures[sig_ref];
             let num_rets = sig.returns.len();
-            let abi = self.lower_ctx.sigs().abi_sig_for_sig_ref(sig_ref);
             let caller = <$abicaller>::from_func(
                 self.lower_ctx.sigs(),
                 sig_ref,
                 &extname,
+                IsTailCall::No,
                 dist,
                 caller_conv,
                 self.backend.flags().clone(),
@@ -752,7 +798,7 @@ macro_rules! isle_prelude_caller_methods {
                 sig.params.len()
             );
 
-            self.gen_call_common(abi, num_rets, caller, args)
+            crate::machinst::isle::gen_call_common(&mut self.lower_ctx, num_rets, caller, args)
         }
 
         fn gen_call_indirect(
@@ -765,12 +811,11 @@ macro_rules! isle_prelude_caller_methods {
             let ptr = self.put_in_reg(val);
             let sig = &self.lower_ctx.dfg().signatures[sig_ref];
             let num_rets = sig.returns.len();
-            let abi = self.lower_ctx.sigs().abi_sig_for_sig_ref(sig_ref);
             let caller = <$abicaller>::from_ptr(
                 self.lower_ctx.sigs(),
                 sig_ref,
                 ptr,
-                Opcode::CallIndirect,
+                IsTailCall::No,
                 caller_conv,
                 self.backend.flags().clone(),
             );
@@ -780,104 +825,62 @@ macro_rules! isle_prelude_caller_methods {
                 sig.params.len()
             );
 
-            self.gen_call_common(abi, num_rets, caller, args)
+            crate::machinst::isle::gen_call_common(&mut self.lower_ctx, num_rets, caller, args)
         }
     };
 }
 
-/// Helpers for the above ISLE prelude implementations. Meant to go
-/// inside the `impl` for the context type, not the trait impl.
-#[macro_export]
-#[doc(hidden)]
-macro_rules! isle_prelude_method_helpers {
-    ($abicaller:ty) => {
-        fn gen_call_common_args(&mut self, call_site: &mut $abicaller, (inputs, off): ValueSlice) {
-            let num_args = call_site.num_args(self.lower_ctx.sigs());
-
-            assert_eq!(
-                inputs.len(&self.lower_ctx.dfg().value_lists) - off,
-                num_args
-            );
-            let mut arg_regs = vec![];
-            for i in 0..num_args {
-                let input = inputs
-                    .get(off + i, &self.lower_ctx.dfg().value_lists)
-                    .unwrap();
-                arg_regs.push(self.put_in_regs(input));
-            }
-            for (i, arg_regs) in arg_regs.iter().enumerate() {
-                call_site.emit_copy_regs_to_buffer(self.lower_ctx, i, *arg_regs);
-            }
-            for (i, arg_regs) in arg_regs.iter().enumerate() {
-                for inst in call_site.gen_arg(self.lower_ctx, i, *arg_regs) {
-                    self.lower_ctx.emit(inst);
-                }
-            }
-        }
-
-        fn gen_call_common(
-            &mut self,
-            abi: Sig,
-            num_rets: usize,
-            mut caller: $abicaller,
-            args: ValueSlice,
-        ) -> InstOutput {
-            caller.emit_stack_pre_adjust(self.lower_ctx);
-
-            self.gen_call_common_args(&mut caller, args);
-
-            // Handle retvals prior to emitting call, so the
-            // constraints are on the call instruction; but buffer the
-            // instructions till after the call.
-            let mut outputs = InstOutput::new();
-            let mut retval_insts: crate::machinst::abi::SmallInstVec<_> = smallvec::smallvec![];
-            // We take the *last* `num_rets` returns of the sig:
-            // this skips a StructReturn, if any, that is present.
-            let sigdata_num_rets = self.lower_ctx.sigs().num_rets(abi);
-            debug_assert!(num_rets <= sigdata_num_rets);
-            for i in (sigdata_num_rets - num_rets)..sigdata_num_rets {
-                // Borrow `sigdata` again so we don't hold a `self`
-                // borrow across the `&mut self` arg to
-                // `abi_arg_slot_regs()` below.
-                let ret = self.lower_ctx.sigs().get_ret(abi, i);
-                let retval_regs = self.abi_arg_slot_regs(&ret).unwrap();
-                retval_insts.extend(
-                    caller
-                        .gen_retval(self.lower_ctx, i, retval_regs.clone())
-                        .into_iter(),
-                );
-                outputs.push(valueregs::non_writable_value_regs(retval_regs));
-            }
-
-            caller.emit_call(self.lower_ctx);
+fn gen_call_common_args<M: ABIMachineSpec>(
+    ctx: &mut Lower<'_, M::I>,
+    call_site: &mut CallSite<M>,
+    (inputs, off): ValueSlice,
+) {
+    let num_args = call_site.num_args(ctx.sigs());
+
+    assert_eq!(inputs.len(&ctx.dfg().value_lists) - off, num_args);
+    let mut arg_regs = vec![];
+    for i in 0..num_args {
+        let input = inputs.get(off + i, &ctx.dfg().value_lists).unwrap();
+        arg_regs.push(ctx.put_value_in_regs(input));
+    }
+    for (i, arg_regs) in arg_regs.iter().enumerate() {
+        call_site.emit_copy_regs_to_buffer(ctx, i, *arg_regs);
+    }
+    for (i, arg_regs) in arg_regs.iter().enumerate() {
+        call_site.gen_arg(ctx, i, *arg_regs);
+    }
+}
 
-            for inst in retval_insts {
-                self.lower_ctx.emit(inst);
-            }
+pub fn gen_call_common<M: ABIMachineSpec>(
+    ctx: &mut Lower<'_, M::I>,
+    num_rets: usize,
+    mut caller: CallSite<M>,
+    args: ValueSlice,
+) -> InstOutput {
+    gen_call_common_args(ctx, &mut caller, args);
+
+    // Handle retvals prior to emitting call, so the
+    // constraints are on the call instruction; but buffer the
+    // instructions till after the call.
+    let mut outputs = InstOutput::new();
+    let mut retval_insts = crate::machinst::abi::SmallInstVec::new();
+    // We take the *last* `num_rets` returns of the sig:
+    // this skips a StructReturn, if any, that is present.
+    let sigdata_num_rets = caller.num_rets(ctx.sigs());
+    debug_assert!(num_rets <= sigdata_num_rets);
+    for i in (sigdata_num_rets - num_rets)..sigdata_num_rets {
+        let (retval_inst, retval_regs) = caller.gen_retval(ctx, i);
+        retval_insts.extend(retval_inst.into_iter());
+        outputs.push(retval_regs);
+    }
 
-            caller.emit_stack_post_adjust(self.lower_ctx);
+    caller.emit_call(ctx);
 
-            outputs
-        }
+    for inst in retval_insts {
+        ctx.emit(inst);
+    }
 
-        fn abi_arg_slot_regs(&mut self, arg: &ABIArg) -> Option<WritableValueRegs> {
-            match arg {
-                &ABIArg::Slots { ref slots, .. } => match slots.len() {
-                    1 => {
-                        let a = self.temp_writable_reg(slots[0].get_type());
-                        Some(WritableValueRegs::one(a))
-                    }
-                    2 => {
-                        let a = self.temp_writable_reg(slots[0].get_type());
-                        let b = self.temp_writable_reg(slots[1].get_type());
-                        Some(WritableValueRegs::two(a, b))
-                    }
-                    _ => panic!("Expected to see one or two slots only from {:?}", arg),
-                },
-                _ => None,
-            }
-        }
-    };
+    outputs
 }
 
 /// This structure is used to implement the ISLE-generated `Context` trait and
diff --git a/cranelift/codegen/src/machinst/lower.rs b/cranelift/codegen/src/machinst/lower.rs
index f4f02890e7de..7d284ab78c75 100644
--- a/cranelift/codegen/src/machinst/lower.rs
+++ b/cranelift/codegen/src/machinst/lower.rs
@@ -6,21 +6,23 @@
 // top of it, e.g. the side-effect/coloring analysis and the scan support.
 
 use crate::entity::SecondaryMap;
-use crate::fx::{FxHashMap, FxHashSet};
 use crate::inst_predicates::{has_lowering_side_effect, is_constant_64bit};
+use crate::ir::pcc::{Fact, FactContext, PccError, PccResult};
 use crate::ir::{
     ArgumentPurpose, Block, Constant, ConstantData, DataFlowGraph, ExternalName, Function,
     GlobalValue, GlobalValueData, Immediate, Inst, InstructionData, MemFlags, RelSourceLoc, Type,
     Value, ValueDef, ValueLabelAssignments, ValueLabelStart,
 };
 use crate::machinst::{
-    writable_value_regs, BlockIndex, BlockLoweringOrder, Callee, LoweredBlock, MachLabel, Reg,
-    SigSet, VCode, VCodeBuilder, VCodeConstant, VCodeConstantData, VCodeConstants, VCodeInst,
-    ValueRegs, Writable,
+    writable_value_regs, BackwardsInsnIndex, BlockIndex, BlockLoweringOrder, Callee, InsnIndex,
+    LoweredBlock, MachLabel, Reg, SigSet, VCode, VCodeBuilder, VCodeConstant, VCodeConstantData,
+    VCodeConstants, VCodeInst, ValueRegs, Writable,
 };
+use crate::settings::Flags;
 use crate::{trace, CodegenResult};
 use alloc::vec::Vec;
 use cranelift_control::ControlPlane;
+use rustc_hash::{FxHashMap, FxHashSet};
 use smallvec::{smallvec, SmallVec};
 use std::fmt::Debug;
 
@@ -145,6 +147,22 @@ pub trait LowerBackend {
     fn maybe_pinned_reg(&self) -> Option<Reg> {
         None
     }
+
+    /// The type of state carried between `check_fact` invocations.
+    type FactFlowState: Default + Clone + Debug;
+
+    /// Check any facts about an instruction, given VCode with facts
+    /// on VRegs. Takes mutable `VCode` so that it can propagate some
+    /// kinds of facts automatically.
+    fn check_fact(
+        &self,
+        _ctx: &FactContext<'_>,
+        _vcode: &mut VCode<Self::MInst>,
+        _inst: InsnIndex,
+        _state: &mut Self::FactFlowState,
+    ) -> PccResult<()> {
+        Err(PccError::UnimplementedBackend)
+    }
 }
 
 /// Machine-independent lowering driver / machine-instruction container. Maintains a correspondence
@@ -206,6 +224,9 @@ pub struct Lower<'func, I: VCodeInst> {
 
     /// The register to use for GetPinnedReg, if any, on this architecture.
     pinned_reg: Option<Reg>,
+
+    /// Compilation flags.
+    flags: Flags,
 }
 
 /// How is a value used in the IR?
@@ -274,15 +295,36 @@ pub struct Lower<'func, I: VCodeInst> {
 /// actually merged" point. Instead, we compute a
 /// transitive-uniqueness. That is what this enum represents.
 ///
-/// To define it plainly: a value is `Unused` if no references exist
-/// to it; `Once` if only one other op refers to it, *and* that other
-/// op is `Unused` or `Once`; and `Multiple` otherwise. In other
-/// words, `Multiple` is contagious: even if an op's result value is
-/// directly used only once in the CLIF, that value is `Multiple` if
-/// the op that uses it is itself used multiple times (hence could be
-/// codegen'd multiple times). In brief, this analysis tells us
-/// whether, if every op merged all of its operand tree, a given op
-/// could be codegen'd in more than one place.
+/// There is one final caveat as well to the result of this analysis.  Notably,
+/// we define some instructions to be "root" instructions, which means that we
+/// assume they will always be codegen'd at the root of a matching tree, and not
+/// matched. (This comes with the caveat that we actually enforce this property
+/// by making them "opaque" to subtree matching in
+/// `get_value_as_source_or_const`). Because they will always be codegen'd once,
+/// they in some sense "reset" multiplicity: these root instructions can be used
+/// many times, but because their result(s) are only computed once, they only
+/// use their inputs once.
+///
+/// We currently define all multi-result instructions to be "root" instructions,
+/// because it is too complex to reason about matching through them, and they
+/// cause too-coarse-grained approximation of multiplicity otherwise: the
+/// analysis would have to assume (as it used to!) that they are always
+/// multiply-used, simply because they have multiple outputs even if those
+/// outputs are used only once.
+///
+/// In the future we could define other instructions to be "root" instructions
+/// as well, if we make the corresponding change to get_value_as_source_or_const
+/// as well.
+///
+/// To define `ValueUseState` more plainly: a value is `Unused` if no references
+/// exist to it; `Once` if only one other op refers to it, *and* that other op
+/// is `Unused` or `Once`; and `Multiple` otherwise. In other words, `Multiple`
+/// is contagious (except through root instructions): even if an op's result
+/// value is directly used only once in the CLIF, that value is `Multiple` if
+/// the op that uses it is itself used multiple times (hence could be codegen'd
+/// multiple times). In brief, this analysis tells us whether, if every op
+/// merged all of its operand tree, a given op could be codegen'd in more than
+/// one place.
 ///
 /// To compute this, we first consider direct uses. At this point
 /// `Unused` answers are correct, `Multiple` answers are correct, but
@@ -329,6 +371,7 @@ impl<'func, I: VCodeInst> Lower<'func, I> {
         emit_info: I::Info,
         block_order: BlockLoweringOrder,
         sigs: SigSet,
+        flags: Flags,
     ) -> CodegenResult<Self> {
         let constants = VCodeConstants::with_capacity(f.dfg.constants.len());
         let vcode = VCodeBuilder::new(
@@ -340,7 +383,9 @@ impl<'func, I: VCodeInst> Lower<'func, I> {
             VCodeBuildDirection::Backward,
         );
 
-        let mut vregs = VRegAllocator::new();
+        // We usually need two VRegs per instruction result, plus extras for
+        // various temporaries, but two per Value is a good starting point.
+        let mut vregs = VRegAllocator::with_capacity(f.dfg.num_values() * 2);
 
         let mut value_regs = SecondaryMap::with_default(ValueRegs::invalid());
 
@@ -349,7 +394,7 @@ impl<'func, I: VCodeInst> Lower<'func, I> {
             for &param in f.dfg.block_params(bb) {
                 let ty = f.dfg.value_type(param);
                 if value_regs[param].is_invalid() {
-                    let regs = vregs.alloc(ty)?;
+                    let regs = vregs.alloc_with_maybe_fact(ty, f.dfg.facts[param].clone())?;
                     value_regs[param] = regs;
                     trace!("bb {} param {}: regs {:?}", bb, param, regs);
                 }
@@ -358,7 +403,7 @@ impl<'func, I: VCodeInst> Lower<'func, I> {
                 for &result in f.dfg.inst_results(inst) {
                     let ty = f.dfg.value_type(result);
                     if value_regs[result].is_invalid() && !ty.is_invalid() {
-                        let regs = vregs.alloc(ty)?;
+                        let regs = vregs.alloc_with_maybe_fact(ty, f.dfg.facts[result].clone())?;
                         value_regs[result] = regs;
                         trace!(
                             "bb {} inst {} ({:?}): result {} regs {:?}",
@@ -374,7 +419,7 @@ impl<'func, I: VCodeInst> Lower<'func, I> {
         }
 
         // Find the sret register, if it's used.
-        let mut sret_reg = None;
+        let mut sret_param = None;
         for ret in vcode.abi().signature().returns.iter() {
             if ret.purpose == ArgumentPurpose::StructReturn {
                 let entry_bb = f.stencil.layout.entry_block().unwrap();
@@ -385,18 +430,21 @@ impl<'func, I: VCodeInst> Lower<'func, I> {
                     .zip(vcode.abi().signature().params.iter())
                 {
                     if sig_param.purpose == ArgumentPurpose::StructReturn {
-                        let regs = value_regs[param];
-                        assert!(regs.len() == 1);
-
-                        assert!(sret_reg.is_none());
-                        sret_reg = Some(regs);
+                        assert!(sret_param.is_none());
+                        sret_param = Some(param);
                     }
                 }
 
-                assert!(sret_reg.is_some());
+                assert!(sret_param.is_some());
             }
         }
 
+        let sret_reg = sret_param.map(|param| {
+            let regs = value_regs[param];
+            assert!(regs.len() == 1);
+            regs
+        });
+
         // Compute instruction colors, find constant instructions, and find instructions with
         // side-effects, in one combined pass.
         let mut cur_color = 0;
@@ -425,7 +473,7 @@ impl<'func, I: VCodeInst> Lower<'func, I> {
             block_end_colors[bb] = InstColor::new(cur_color);
         }
 
-        let value_ir_uses = Self::compute_use_states(f);
+        let value_ir_uses = compute_use_states(f, sret_param);
 
         Ok(Lower {
             f,
@@ -443,6 +491,7 @@ impl<'func, I: VCodeInst> Lower<'func, I> {
             cur_inst: None,
             ir_insts: vec![],
             pinned_reg: None,
+            flags,
         })
     }
 
@@ -454,111 +503,6 @@ impl<'func, I: VCodeInst> Lower<'func, I> {
         self.vcode.sigs_mut()
     }
 
-    /// Pre-analysis: compute `value_ir_uses`. See comment on
-    /// `ValueUseState` for a description of what this analysis
-    /// computes.
-    fn compute_use_states<'a>(f: &'a Function) -> SecondaryMap<Value, ValueUseState> {
-        // We perform the analysis without recursion, so we don't
-        // overflow the stack on long chains of ops in the input.
-        //
-        // This is sort of a hybrid of a "shallow use-count" pass and
-        // a DFS. We iterate over all instructions and mark their args
-        // as used. However when we increment a use-count to
-        // "Multiple" we push its args onto the stack and do a DFS,
-        // immediately marking the whole dependency tree as
-        // Multiple. Doing both (shallow use-counting over all insts,
-        // and deep Multiple propagation) lets us trim both
-        // traversals, stopping recursion when a node is already at
-        // the appropriate state.
-        //
-        // In particular, note that the *coarsening* into {Unused,
-        // Once, Multiple} is part of what makes this pass more
-        // efficient than a full indirect-use-counting pass.
-
-        let mut value_ir_uses = SecondaryMap::with_default(ValueUseState::Unused);
-
-        // Stack of iterators over Values as we do DFS to mark
-        // Multiple-state subtrees. The iterator type is whatever is
-        // returned by `uses` below.
-        let mut stack: SmallVec<[_; 16]> = smallvec![];
-
-        // Find the args for the inst corresponding to the given value.
-        let uses = |value| {
-            trace!(" -> pushing args for {} onto stack", value);
-            if let ValueDef::Result(src_inst, _) = f.dfg.value_def(value) {
-                Some(f.dfg.inst_values(src_inst))
-            } else {
-                None
-            }
-        };
-
-        // Do a DFS through `value_ir_uses` to mark a subtree as
-        // Multiple.
-        for inst in f
-            .layout
-            .blocks()
-            .flat_map(|block| f.layout.block_insts(block))
-        {
-            // If this inst produces multiple values, we must mark all
-            // of its args as Multiple, because otherwise two uses
-            // could come in as Once on our two different results.
-            let force_multiple = f.dfg.inst_results(inst).len() > 1;
-
-            // Iterate over all values used by all instructions, noting an
-            // additional use on each operand.
-            for arg in f.dfg.inst_values(inst) {
-                let arg = f.dfg.resolve_aliases(arg);
-                let old = value_ir_uses[arg];
-                if force_multiple {
-                    trace!(
-                        "forcing arg {} to Multiple because of multiple results of user inst",
-                        arg
-                    );
-                    value_ir_uses[arg] = ValueUseState::Multiple;
-                } else {
-                    value_ir_uses[arg].inc();
-                }
-                let new = value_ir_uses[arg];
-                trace!("arg {} used, old state {:?}, new {:?}", arg, old, new);
-
-                // On transition to Multiple, do DFS.
-                if old == ValueUseState::Multiple || new != ValueUseState::Multiple {
-                    continue;
-                }
-                if let Some(iter) = uses(arg) {
-                    stack.push(iter);
-                }
-                while let Some(iter) = stack.last_mut() {
-                    if let Some(value) = iter.next() {
-                        let value = f.dfg.resolve_aliases(value);
-                        trace!(" -> DFS reaches {}", value);
-                        if value_ir_uses[value] == ValueUseState::Multiple {
-                            // Truncate DFS here: no need to go further,
-                            // as whole subtree must already be Multiple.
-                            // With debug asserts, check one level of
-                            // that invariant at least.
-                            debug_assert!(uses(value).into_iter().flatten().all(|arg| {
-                                let arg = f.dfg.resolve_aliases(arg);
-                                value_ir_uses[arg] == ValueUseState::Multiple
-                            }));
-                            continue;
-                        }
-                        value_ir_uses[value] = ValueUseState::Multiple;
-                        trace!(" -> became Multiple");
-                        if let Some(iter) = uses(value) {
-                            stack.push(iter);
-                        }
-                    } else {
-                        // Empty iterator, discard.
-                        stack.pop();
-                    }
-                }
-            }
-        }
-
-        value_ir_uses
-    }
-
     fn gen_arg_setup(&mut self) {
         if let Some(entry_bb) = self.f.layout.entry_block() {
             trace!(
@@ -567,13 +511,8 @@ impl<'func, I: VCodeInst> Lower<'func, I> {
                 self.f.dfg.block_params(entry_bb)
             );
 
-            // Make the vmctx available in debuginfo.
-            if let Some(vmctx_val) = self.f.special_param(ArgumentPurpose::VMContext) {
-                self.emit_value_label_marks_for_value(vmctx_val);
-            }
-
             for (i, param) in self.f.dfg.block_params(entry_bb).iter().enumerate() {
-                if !self.vcode.abi().arg_is_needed_in_body(i) {
+                if self.value_ir_uses[*param] == ValueUseState::Unused {
                     continue;
                 }
                 let regs = writable_value_regs(self.value_regs[*param]);
@@ -622,7 +561,7 @@ impl<'func, I: VCodeInst> Lower<'func, I> {
             .enumerate()
         {
             let regs = if ret.purpose == ArgumentPurpose::StructReturn {
-                self.sret_reg.unwrap().clone()
+                self.sret_reg.unwrap()
             } else {
                 rets.next().unwrap()
             };
@@ -644,8 +583,10 @@ impl<'func, I: VCodeInst> Lower<'func, I> {
         // for the benefit of debuginfo.
         if self.f.dfg.values_labels.is_some() {
             if let Some(vmctx_val) = self.f.special_param(ArgumentPurpose::VMContext) {
-                let vmctx_reg = self.value_regs[vmctx_val].only_reg().unwrap();
-                self.emit(I::gen_dummy_use(vmctx_reg));
+                if self.value_ir_uses[vmctx_val] != ValueUseState::Unused {
+                    let vmctx_reg = self.value_regs[vmctx_val].only_reg().unwrap();
+                    self.emit(I::gen_dummy_use(vmctx_reg));
+                }
             }
         }
 
@@ -731,9 +672,49 @@ impl<'func, I: VCodeInst> Lower<'func, I> {
             }
 
             // Normal instruction: codegen if the instruction is side-effecting
-            // or any of its outputs its used.
+            // or any of its outputs is used.
             if has_side_effect || value_needed {
-                trace!("lowering: inst {}: {:?}", inst, self.f.dfg.insts[inst]);
+                trace!("lowering: inst {}: {}", inst, self.f.dfg.display_inst(inst));
+
+                if cfg!(feature = "trace-log") {
+                    let opcode = self.f.dfg.insts[inst].opcode();
+
+                    // Features.
+                    let mut features = Vec::new();
+                    if opcode.is_terminator() {
+                        features.push("terminator");
+                    }
+                    if opcode.is_branch() {
+                        features.push("branch");
+                    }
+                    if opcode.is_call() {
+                        features.push("call");
+                    }
+                    if opcode.can_load() {
+                        features.push("load");
+                    }
+                    if opcode.can_store() {
+                        features.push("store");
+                    }
+                    if opcode.can_trap() {
+                        features.push("trap");
+                    }
+
+                    // Output types.
+                    let mut output_tys = Vec::new();
+                    for i in 0..self.num_outputs(inst) {
+                        output_tys.push(format!("{}", self.output_ty(inst, i)));
+                    }
+
+                    // Input types.
+                    let mut input_tys = Vec::new();
+                    for i in 0..self.num_inputs(inst) {
+                        input_tys.push(format!("{}", self.input_ty(inst, i)));
+                    }
+
+                    trace!(target: "isle_rule_trace", "inst: {},{},{},{}", opcode, output_tys.join(":"), input_tys.join(":"), features.join(":"));
+                }
+
                 let temp_regs = backend.lower(self, inst).unwrap_or_else(|| {
                     let ty = if self.num_outputs(inst) > 0 {
                         Some(self.output_ty(inst, 0))
@@ -757,20 +738,51 @@ impl<'func, I: VCodeInst> Lower<'func, I> {
                 // regalloc to use. These aliases effectively rewrite any use of
                 // the pre-assigned register to the register that was returned by
                 // the ISLE lowering logic.
-                debug_assert_eq!(temp_regs.len(), self.num_outputs(inst));
-                for i in 0..self.num_outputs(inst) {
-                    let regs = temp_regs[i];
-                    let dsts = self.value_regs[self.f.dfg.inst_results(inst)[i]];
+                let results = self.f.dfg.inst_results(inst);
+                debug_assert_eq!(temp_regs.len(), results.len());
+                for (regs, &result) in temp_regs.iter().zip(results) {
+                    let dsts = self.value_regs[result];
                     debug_assert_eq!(regs.len(), dsts.len());
-                    for (dst, temp) in dsts.regs().iter().zip(regs.regs().iter()) {
-                        self.set_vreg_alias(*dst, *temp);
+                    for (&dst, &temp) in dsts.regs().iter().zip(regs.regs()) {
+                        trace!("set vreg alias: {result:?} = {dst:?}, lowering = {temp:?}");
+                        self.vregs.set_vreg_alias(dst, temp);
                     }
                 }
             }
 
+            let start = self.vcode.vcode.num_insts();
             let loc = self.srcloc(inst);
             self.finish_ir_inst(loc);
 
+            // If the instruction had a user stack map, forward it from the CLIF
+            // to the vcode.
+            if let Some(entries) = self.f.dfg.user_stack_map_entries(inst) {
+                let end = self.vcode.vcode.num_insts();
+                debug_assert!(end > start);
+                debug_assert_eq!(
+                    (start..end)
+                        .filter(|i| self.vcode.vcode[InsnIndex::new(*i)].is_safepoint())
+                        .count(),
+                    1
+                );
+                for i in start..end {
+                    let iix = InsnIndex::new(i);
+                    if self.vcode.vcode[iix].is_safepoint() {
+                        trace!(
+                            "Adding user stack map from clif\n\n\
+                                 {inst:?} `{}`\n\n\
+                             to vcode\n\n\
+                                 {iix:?} `{}`",
+                            self.f.dfg.display_inst(inst),
+                            &self.vcode.vcode[iix].pretty_print_inst(&mut Default::default()),
+                        );
+                        self.vcode
+                            .add_user_stack_map(BackwardsInsnIndex::new(iix.index()), entries);
+                        break;
+                    }
+                }
+            }
+
             // maybe insert random instruction
             if ctrl_plane.get_decision() {
                 if ctrl_plane.get_decision() {
@@ -802,12 +814,8 @@ impl<'func, I: VCodeInst> Lower<'func, I> {
 
     fn add_block_params(&mut self, block: Block) -> CodegenResult<()> {
         for &param in self.f.dfg.block_params(block) {
-            let ty = self.f.dfg.value_type(param);
-            let (_reg_rcs, reg_tys) = I::rc_for_type(ty)?;
-            debug_assert_eq!(reg_tys.len(), self.value_regs[param].len());
-            for (&reg, &rty) in self.value_regs[param].regs().iter().zip(reg_tys.iter()) {
+            for &reg in self.value_regs[param].regs() {
                 let vreg = reg.to_virtual_reg().unwrap();
-                self.vregs.set_vreg_type(vreg, rty);
                 self.vcode.add_block_param(vreg);
             }
         }
@@ -816,13 +824,12 @@ impl<'func, I: VCodeInst> Lower<'func, I> {
 
     fn get_value_labels<'a>(&'a self, val: Value, depth: usize) -> Option<&'a [ValueLabelStart]> {
         if let Some(ref values_labels) = self.f.dfg.values_labels {
+            debug_assert!(self.f.dfg.value_is_real(val));
             trace!(
-                "get_value_labels: val {} -> {} -> {:?}",
+                "get_value_labels: val {} -> {:?}",
                 val,
-                self.f.dfg.resolve_aliases(val),
-                values_labels.get(&self.f.dfg.resolve_aliases(val))
+                values_labels.get(&val)
             );
-            let val = self.f.dfg.resolve_aliases(val);
             match values_labels.get(&val) {
                 Some(&ValueLabelAssignments::Starts(ref list)) => Some(&list[..]),
                 Some(&ValueLabelAssignments::Alias { value, .. }) if depth < 10 => {
@@ -887,12 +894,11 @@ impl<'func, I: VCodeInst> Lower<'func, I> {
     }
 
     fn finish_ir_inst(&mut self, loc: RelSourceLoc) {
-        self.vcode.set_srcloc(loc);
         // The VCodeBuilder builds in reverse order (and reverses at
         // the end), but `ir_insts` is in forward order, so reverse
         // it.
         for inst in self.ir_insts.drain(..).rev() {
-            self.vcode.push(inst);
+            self.vcode.push(inst, loc);
         }
     }
 
@@ -953,16 +959,12 @@ impl<'func, I: VCodeInst> Lower<'func, I> {
 
             let mut branch_arg_vregs: SmallVec<[Reg; 16]> = smallvec![];
             for &arg in branch_args {
-                let arg = self.f.dfg.resolve_aliases(arg);
+                debug_assert!(self.f.dfg.value_is_real(arg));
                 let regs = self.put_value_in_regs(arg);
-                for &vreg in regs.regs() {
-                    let vreg = self.vcode.resolve_vreg_alias(vreg.into());
-                    branch_arg_vregs.push(vreg.into());
-                }
+                branch_arg_vregs.extend_from_slice(regs.regs());
             }
             self.vcode.add_succ(succ, &branch_arg_vregs[..]);
         }
-        self.finish_ir_inst(Default::default());
     }
 
     fn collect_branches_and_targets(
@@ -985,15 +987,7 @@ impl<'func, I: VCodeInst> Lower<'func, I> {
     ) -> CodegenResult<VCode<I>> {
         trace!("about to lower function: {:?}", self.f);
 
-        // Initialize the ABI object, giving it temps if requested.
-        let temps = self
-            .vcode
-            .abi()
-            .temps_needed(self.sigs())
-            .into_iter()
-            .map(|temp_ty| self.alloc_tmp(temp_ty).only_reg().unwrap())
-            .collect::<Vec<_>>();
-        self.vcode.init_abi(temps);
+        self.vcode.init_retval_area(&mut self.vregs)?;
 
         // Get the pinned reg here (we only parameterize this function on `B`,
         // not the whole `Lower` impl).
@@ -1079,13 +1073,148 @@ impl<'func, I: VCodeInst> Lower<'func, I> {
 
         // Now that we've emitted all instructions into the
         // VCodeBuilder, let's build the VCode.
+        trace!(
+            "built vcode:\n{:?}Backwards {:?}",
+            &self.vregs,
+            &self.vcode.vcode
+        );
         let vcode = self.vcode.build(self.vregs);
-        trace!("built vcode: {:?}", vcode);
 
         Ok(vcode)
     }
 }
 
+/// Pre-analysis: compute `value_ir_uses`. See comment on
+/// `ValueUseState` for a description of what this analysis
+/// computes.
+fn compute_use_states(
+    f: &Function,
+    sret_param: Option<Value>,
+) -> SecondaryMap<Value, ValueUseState> {
+    // We perform the analysis without recursion, so we don't
+    // overflow the stack on long chains of ops in the input.
+    //
+    // This is sort of a hybrid of a "shallow use-count" pass and
+    // a DFS. We iterate over all instructions and mark their args
+    // as used. However when we increment a use-count to
+    // "Multiple" we push its args onto the stack and do a DFS,
+    // immediately marking the whole dependency tree as
+    // Multiple. Doing both (shallow use-counting over all insts,
+    // and deep Multiple propagation) lets us trim both
+    // traversals, stopping recursion when a node is already at
+    // the appropriate state.
+    //
+    // In particular, note that the *coarsening* into {Unused,
+    // Once, Multiple} is part of what makes this pass more
+    // efficient than a full indirect-use-counting pass.
+
+    let mut value_ir_uses = SecondaryMap::with_default(ValueUseState::Unused);
+
+    if let Some(sret_param) = sret_param {
+        // There's an implicit use of the struct-return parameter in each
+        // copy of the function epilogue, which we count here.
+        value_ir_uses[sret_param] = ValueUseState::Multiple;
+    }
+
+    // Stack of iterators over Values as we do DFS to mark
+    // Multiple-state subtrees. The iterator type is whatever is
+    // returned by `uses` below.
+    let mut stack: SmallVec<[_; 16]> = smallvec![];
+
+    // Find the args for the inst corresponding to the given value.
+    //
+    // Note that "root" instructions are skipped here. This means that multiple
+    // uses of any result of a multi-result instruction are not considered
+    // multiple uses of the operands of a multi-result instruction. This
+    // requires tight coupling with `get_value_as_source_or_const` above which
+    // is the consumer of the map that this function is producing.
+    let uses = |value| {
+        trace!(" -> pushing args for {} onto stack", value);
+        if let ValueDef::Result(src_inst, _) = f.dfg.value_def(value) {
+            if is_value_use_root(f, src_inst) {
+                None
+            } else {
+                Some(f.dfg.inst_values(src_inst))
+            }
+        } else {
+            None
+        }
+    };
+
+    // Do a DFS through `value_ir_uses` to mark a subtree as
+    // Multiple.
+    for inst in f
+        .layout
+        .blocks()
+        .flat_map(|block| f.layout.block_insts(block))
+    {
+        // Iterate over all values used by all instructions, noting an
+        // additional use on each operand.
+        for arg in f.dfg.inst_values(inst) {
+            debug_assert!(f.dfg.value_is_real(arg));
+            let old = value_ir_uses[arg];
+            value_ir_uses[arg].inc();
+            let new = value_ir_uses[arg];
+            trace!("arg {} used, old state {:?}, new {:?}", arg, old, new);
+
+            // On transition to Multiple, do DFS.
+            if old == ValueUseState::Multiple || new != ValueUseState::Multiple {
+                continue;
+            }
+            if let Some(iter) = uses(arg) {
+                stack.push(iter);
+            }
+            while let Some(iter) = stack.last_mut() {
+                if let Some(value) = iter.next() {
+                    debug_assert!(f.dfg.value_is_real(value));
+                    trace!(" -> DFS reaches {}", value);
+                    if value_ir_uses[value] == ValueUseState::Multiple {
+                        // Truncate DFS here: no need to go further,
+                        // as whole subtree must already be Multiple.
+                        // With debug asserts, check one level of
+                        // that invariant at least.
+                        debug_assert!(uses(value).into_iter().flatten().all(|arg| {
+                            debug_assert!(f.dfg.value_is_real(arg));
+                            value_ir_uses[arg] == ValueUseState::Multiple
+                        }));
+                        continue;
+                    }
+                    value_ir_uses[value] = ValueUseState::Multiple;
+                    trace!(" -> became Multiple");
+                    if let Some(iter) = uses(value) {
+                        stack.push(iter);
+                    }
+                } else {
+                    // Empty iterator, discard.
+                    stack.pop();
+                }
+            }
+        }
+    }
+
+    value_ir_uses
+}
+
+/// Definition of a "root" instruction for the calculation of `ValueUseState`.
+///
+/// This function calculates whether `inst` is considered a "root" for value-use
+/// information. This concept is used to forcibly prevent looking-through the
+/// instruction during `get_value_as_source_or_const` as it additionally
+/// prevents propagating `Multiple`-used results of the `inst` here to the
+/// operands of the instruction.
+///
+/// Currently this is defined as multi-result instructions. That means that
+/// lowerings are never allowed to look through a multi-result instruction to
+/// generate patterns. Note that this isn't possible in ISLE today anyway so
+/// this isn't currently much of a loss.
+///
+/// The main purpose of this function is to prevent the operands of a
+/// multi-result instruction from being forcibly considered `Multiple`-used
+/// regardless of circumstances.
+fn is_value_use_root(f: &Function, inst: Inst) -> bool {
+    f.dfg.inst_results(inst).len() > 1
+}
+
 /// Function-level queries.
 impl<'func, I: VCodeInst> Lower<'func, I> {
     pub fn dfg(&self) -> &DataFlowGraph {
@@ -1182,7 +1311,16 @@ impl<'func, I: VCodeInst> Lower<'func, I> {
     /// Get the value of a constant instruction (`iconst`, etc.) as a 64-bit
     /// value, if possible.
     pub fn get_constant(&self, ir_inst: Inst) -> Option<u64> {
-        self.inst_constants.get(&ir_inst).cloned()
+        self.inst_constants.get(&ir_inst).map(|&c| {
+            // The upper bits must be zero, enforced during legalization and by
+            // the CLIF verifier.
+            debug_assert_eq!(c, {
+                let input_size = self.output_ty(ir_inst, 0).bits() as u64;
+                let shift = 64 - input_size;
+                (c << shift) >> shift
+            });
+            c
+        })
     }
 
     /// Get the input as one of two options other than a direct register:
@@ -1203,17 +1341,35 @@ impl<'func, I: VCodeInst> Lower<'func, I> {
     /// not be codegen'd (it has been integrated into the current instruction).
     pub fn input_as_value(&self, ir_inst: Inst, idx: usize) -> Value {
         let val = self.f.dfg.inst_args(ir_inst)[idx];
-        self.f.dfg.resolve_aliases(val)
+        debug_assert!(self.f.dfg.value_is_real(val));
+        val
     }
 
-    /// Like `get_input_as_source_or_const` but with a `Value`.
+    /// Resolves a particular input of an instruction to the `Value` that it is
+    /// represented with.
+    ///
+    /// For more information see [`Lower::get_value_as_source_or_const`].
     pub fn get_input_as_source_or_const(&self, ir_inst: Inst, idx: usize) -> NonRegInput {
         let val = self.input_as_value(ir_inst, idx);
         self.get_value_as_source_or_const(val)
     }
 
-    /// Resolves a particular input of an instruction to the `Value` that it is
-    /// represented with.
+    /// Resolves a `Value` definition to the source instruction it came from
+    /// plus whether it's a unique-use of that instruction.
+    ///
+    /// This function is the workhorse of pattern-matching in ISLE which enables
+    /// combining multiple instructions together. This is used implicitly in
+    /// patterns such as `(iadd x (iconst y))` where this function is used to
+    /// extract the `(iconst y)` operand.
+    ///
+    /// At its core this function is a wrapper around
+    /// [`DataFlowGraph::value_def`]. This function applies a filter on top of
+    /// that, however, to determine when it is actually safe to "look through"
+    /// the `val` definition here and view the underlying instruction. This
+    /// protects against duplicating side effects, such as loads, for example.
+    ///
+    /// Internally this uses the data computed from `compute_use_states` along
+    /// with other instruction properties to know what to return.
     pub fn get_value_as_source_or_const(&self, val: Value) -> NonRegInput {
         trace!(
             "get_input_for_val: val {} at cur_inst {:?} cur_scan_entry_color {:?}",
@@ -1222,9 +1378,21 @@ impl<'func, I: VCodeInst> Lower<'func, I> {
             self.cur_scan_entry_color,
         );
         let inst = match self.f.dfg.value_def(val) {
-            // OK to merge source instruction if (i) we have a source
-            // instruction, and:
-            // - It has no side-effects, OR
+            // OK to merge source instruction if we have a source
+            // instruction, and one of these two conditions hold:
+            //
+            // - It has no side-effects and this instruction is not a "value-use
+            //   root" instruction. Instructions which are considered "roots"
+            //   for value-use calculations do not have accurate information
+            //   known about the `ValueUseState` of their operands. This is
+            //   currently done for multi-result instructions to prevent a use
+            //   of each result from forcing all operands of the multi-result
+            //   instruction to also be `Multiple`. This in turn means that the
+            //   `ValueUseState` for operands of a "root" instruction to be a
+            //   lie if pattern matching were to look through the multi-result
+            //   instruction. As a result the "look through this instruction"
+            //   logic only succeeds if it's not a root instruction.
+            //
             // - It has a side-effect, has one output value, that one
             //   output has only one use, directly or indirectly (so
             //   cannot be duplicated -- see comment on
@@ -1247,10 +1415,21 @@ impl<'func, I: VCodeInst> Lower<'func, I> {
                 let src_side_effect = has_lowering_side_effect(self.f, src_inst);
                 trace!(" -> src inst {}", src_inst);
                 trace!(" -> has lowering side effect: {}", src_side_effect);
-                if !src_side_effect {
-                    // Pure instruction: always possible to
-                    // sink. Let's determine whether we are the only
-                    // user or not.
+                if is_value_use_root(self.f, src_inst) {
+                    // If this instruction is a "root instruction" then it's
+                    // required that we can't look through it to see the
+                    // definition. This means that the `ValueUseState` for the
+                    // operands of this result assume that this instruction is
+                    // generated exactly once which might get violated were we
+                    // to allow looking through it.
+                    trace!(" -> is a root instruction");
+                    InputSourceInst::None
+                } else if !src_side_effect {
+                    // Otherwise if this instruction has no side effects and the
+                    // value is used only once then we can look through it with
+                    // a "unique" tag. A non-unique `Use` can be shown for other
+                    // values ensuring consumers know how it's computed but that
+                    // it's not available to omit.
                     if self.value_ir_uses[val] == ValueUseState::Once {
                         InputSourceInst::UniqueUse(src_inst, result_idx)
                     } else {
@@ -1303,7 +1482,7 @@ impl<'func, I: VCodeInst> Lower<'func, I> {
 
     /// Put the given value into register(s) and return the assigned register.
     pub fn put_value_in_regs(&mut self, val: Value) -> ValueRegs<Reg> {
-        let val = self.f.dfg.resolve_aliases(val);
+        debug_assert!(self.f.dfg.value_is_real(val));
         trace!("put_value_in_regs: val {}", val);
 
         if let Some(inst) = self.f.dfg.value_def(val).inst() {
@@ -1385,9 +1564,67 @@ impl<'func, I: VCodeInst> Lower<'func, I> {
         }
     }
 
-    /// Note that one vreg is to be treated as an alias of another.
-    pub fn set_vreg_alias(&mut self, from: Reg, to: Reg) {
-        trace!("set vreg alias: from {:?} to {:?}", from, to);
-        self.vcode.set_vreg_alias(from, to);
+    /// Add a range fact to a register, if no other fact is present.
+    pub fn add_range_fact(&mut self, reg: Reg, bit_width: u16, min: u64, max: u64) {
+        if self.flags.enable_pcc() {
+            self.vregs.set_fact_if_missing(
+                reg.to_virtual_reg().unwrap(),
+                Fact::Range {
+                    bit_width,
+                    min,
+                    max,
+                },
+            );
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ValueUseState;
+    use crate::cursor::{Cursor, FuncCursor};
+    use crate::ir::types;
+    use crate::ir::{Function, InstBuilder};
+
+    #[test]
+    fn multi_result_use_once() {
+        let mut func = Function::new();
+        let block0 = func.dfg.make_block();
+        let mut pos = FuncCursor::new(&mut func);
+        pos.insert_block(block0);
+        let v1 = pos.ins().iconst(types::I64, 0);
+        let v2 = pos.ins().iconst(types::I64, 1);
+        let v3 = pos.ins().iconcat(v1, v2);
+        let (v4, v5) = pos.ins().isplit(v3);
+        pos.ins().return_(&[v4, v5]);
+        let func = pos.func;
+
+        let uses = super::compute_use_states(&func, None);
+        assert_eq!(uses[v1], ValueUseState::Once);
+        assert_eq!(uses[v2], ValueUseState::Once);
+        assert_eq!(uses[v3], ValueUseState::Once);
+        assert_eq!(uses[v4], ValueUseState::Once);
+        assert_eq!(uses[v5], ValueUseState::Once);
+    }
+
+    #[test]
+    fn results_used_twice_but_not_operands() {
+        let mut func = Function::new();
+        let block0 = func.dfg.make_block();
+        let mut pos = FuncCursor::new(&mut func);
+        pos.insert_block(block0);
+        let v1 = pos.ins().iconst(types::I64, 0);
+        let v2 = pos.ins().iconst(types::I64, 1);
+        let v3 = pos.ins().iconcat(v1, v2);
+        let (v4, v5) = pos.ins().isplit(v3);
+        pos.ins().return_(&[v4, v4]);
+        let func = pos.func;
+
+        let uses = super::compute_use_states(&func, None);
+        assert_eq!(uses[v1], ValueUseState::Once);
+        assert_eq!(uses[v2], ValueUseState::Once);
+        assert_eq!(uses[v3], ValueUseState::Once);
+        assert_eq!(uses[v4], ValueUseState::Multiple);
+        assert_eq!(uses[v5], ValueUseState::Unused);
     }
 }
diff --git a/cranelift/codegen/src/machinst/mod.rs b/cranelift/codegen/src/machinst/mod.rs
index a8d3ce376d12..6a68728820e2 100644
--- a/cranelift/codegen/src/machinst/mod.rs
+++ b/cranelift/codegen/src/machinst/mod.rs
@@ -39,14 +39,15 @@
 //!         |                          by instruction emission code.
 //!         |                        - prologue and epilogue(s) built and emitted
 //!         |                          directly during emission.
-//!         |                        - nominal-SP-relative offsets resolved
-//!         |                          by tracking EmitState.)
+//!         |                        - SP-relative offsets resolved by tracking
+//!         |                          EmitState.)
 //!
 //! ```
 
-use crate::binemit::{Addend, CodeInfo, CodeOffset, Reloc, StackMap};
-use crate::ir::function::FunctionParameters;
-use crate::ir::{DynamicStackSlot, RelSourceLoc, StackSlot, Type};
+use crate::binemit::{Addend, CodeInfo, CodeOffset, Reloc};
+use crate::ir::{
+    self, function::FunctionParameters, DynamicStackSlot, RelSourceLoc, StackSlot, Type,
+};
 use crate::isa::FunctionAlignment;
 use crate::result::CodegenResult;
 use crate::settings;
@@ -56,7 +57,7 @@ use alloc::vec::Vec;
 use core::fmt::Debug;
 use cranelift_control::ControlPlane;
 use cranelift_entity::PrimaryMap;
-use regalloc2::{Allocation, VReg};
+use regalloc2::VReg;
 use smallvec::{smallvec, SmallVec};
 use std::string::String;
 
@@ -81,10 +82,12 @@ pub use buffer::*;
 pub mod helpers;
 pub use helpers::*;
 pub mod inst_common;
+#[allow(unused_imports)] // not used in all backends right now
 pub use inst_common::*;
 pub mod valueregs;
 pub use reg::*;
 pub use valueregs::*;
+pub mod pcc;
 pub mod reg;
 
 /// A machine instruction.
@@ -94,7 +97,7 @@ pub trait MachInst: Clone + Debug {
 
     /// Return the registers referenced by this machine instruction along with
     /// the modes of reference (use, def, modify).
-    fn get_operands<F: Fn(VReg) -> VReg>(&self, collector: &mut OperandCollector<'_, F>);
+    fn get_operands(&mut self, collector: &mut impl OperandVisitor);
 
     /// If this is a simple move, return the (source, destination) tuple of registers.
     fn is_move(&self) -> Option<(Writable<Reg>, Reg)>;
@@ -112,6 +115,9 @@ pub trait MachInst: Clone + Debug {
     /// Should this instruction be included in the clobber-set?
     fn is_included_in_clobbers(&self) -> bool;
 
+    /// Does this instruction access memory?
+    fn is_mem_access(&self) -> bool;
+
     /// Generate a move.
     fn gen_move(to_reg: Writable<Reg>, from_reg: Reg, ty: Type) -> Self;
 
@@ -279,18 +285,15 @@ pub enum MachTerminator {
 pub trait MachInstEmit: MachInst {
     /// Persistent state carried across `emit` invocations.
     type State: MachInstEmitState<Self>;
+
     /// Constant information used in `emit` invocations.
     type Info;
+
     /// Emit the instruction.
-    fn emit(
-        &self,
-        allocs: &[Allocation],
-        code: &mut MachBuffer<Self>,
-        info: &Self::Info,
-        state: &mut Self::State,
-    );
+    fn emit(&self, code: &mut MachBuffer<Self>, info: &Self::Info, state: &mut Self::State);
+
     /// Pretty-print the instruction.
-    fn pretty_print_inst(&self, allocs: &[Allocation], state: &mut Self::State) -> String;
+    fn pretty_print_inst(&self, state: &mut Self::State) -> String;
 }
 
 /// A trait describing the emission state carried between MachInsts when
@@ -298,23 +301,27 @@ pub trait MachInstEmit: MachInst {
 pub trait MachInstEmitState<I: VCodeInst>: Default + Clone + Debug {
     /// Create a new emission state given the ABI object.
     fn new(abi: &Callee<I::ABIMachineSpec>, ctrl_plane: ControlPlane) -> Self;
+
     /// Update the emission state before emitting an instruction that is a
     /// safepoint.
-    fn pre_safepoint(&mut self, _stack_map: StackMap) {}
-    /// Update the emission state to indicate instructions are associated with a
-    /// particular RelSourceLoc.
-    fn pre_sourceloc(&mut self, _srcloc: RelSourceLoc) {}
+    fn pre_safepoint(&mut self, user_stack_map: Option<ir::UserStackMap>);
+
     /// The emission state holds ownership of a control plane, so it doesn't
     /// have to be passed around explicitly too much. `ctrl_plane_mut` may
     /// be used if temporary access to the control plane is needed by some
     /// other function that doesn't have access to the emission state.
     fn ctrl_plane_mut(&mut self) -> &mut ControlPlane;
+
     /// Used to continue using a control plane after the emission state is
     /// not needed anymore.
     fn take_ctrl_plane(self) -> ControlPlane;
+
     /// A hook that triggers when first emitting a new block.
     /// It is guaranteed to be called before any instructions are emitted.
     fn on_new_block(&mut self) {}
+
+    /// The [`FrameLayout`] for the function currently being compiled.
+    fn frame_layout(&self) -> &FrameLayout;
 }
 
 /// The result of a `MachBackend::compile_function()` call. Contains machine
@@ -405,7 +412,7 @@ impl<T: CompilePhase> CompiledCodeBase<T> {
             .zip(block_starts.iter().skip(1))
             .enumerate()
         {
-            writeln!(buf, "block{}: ; offset 0x{:x}", n, start)?;
+            writeln!(buf, "block{n}: ; offset 0x{start:x}")?;
 
             let buffer = &self.buffer.data()[start as usize..end as usize];
             let insns = cs.disasm_all(buffer, start as u64).map_err(map_caperr)?;
@@ -414,18 +421,18 @@ impl<T: CompilePhase> CompiledCodeBase<T> {
 
                 let op_str = i.op_str().unwrap_or("");
                 if let Some(s) = i.mnemonic() {
-                    write!(buf, "{}", s)?;
+                    write!(buf, "{s}")?;
                     if !op_str.is_empty() {
                         write!(buf, " ")?;
                     }
                 }
 
-                write!(buf, "{}", op_str)?;
+                write!(buf, "{op_str}")?;
 
                 let end = i.address() + i.bytes().len() as u64;
                 let contains = |off| i.address() <= off && off < end;
 
-                if let Some(reloc) = relocs.iter().find(|reloc| contains(reloc.offset as u64)) {
+                for reloc in relocs.iter().filter(|reloc| contains(reloc.offset as u64)) {
                     write!(
                         buf,
                         " ; reloc_external {} {} {}",
diff --git a/cranelift/codegen/src/machinst/pcc.rs b/cranelift/codegen/src/machinst/pcc.rs
new file mode 100644
index 000000000000..0c70a023838f
--- /dev/null
+++ b/cranelift/codegen/src/machinst/pcc.rs
@@ -0,0 +1,169 @@
+//! Common helpers for ISA-specific proof-carrying-code implementations.
+
+use crate::ir::pcc::{Fact, FactContext, PccError, PccResult};
+use crate::machinst::{Reg, VCode, VCodeInst, Writable};
+use crate::trace;
+
+pub(crate) fn get_fact_or_default<I: VCodeInst>(vcode: &VCode<I>, reg: Reg, width: u16) -> Fact {
+    trace!(
+        "get_fact_or_default: reg {reg:?} -> {:?}",
+        vcode.vreg_fact(reg.into())
+    );
+    vcode
+        .vreg_fact(reg.into())
+        .cloned()
+        .unwrap_or_else(|| Fact::max_range_for_width(width))
+}
+
+pub(crate) fn has_fact<I: VCodeInst>(vcode: &VCode<I>, reg: Reg) -> bool {
+    vcode.vreg_fact(reg.into()).is_some()
+}
+
+pub(crate) fn fail_if_missing(fact: Option<Fact>) -> PccResult<Fact> {
+    fact.ok_or(PccError::UnsupportedFact)
+}
+
+pub(crate) fn clamp_range(
+    ctx: &FactContext,
+    to_bits: u16,
+    from_bits: u16,
+    fact: Option<Fact>,
+) -> PccResult<Option<Fact>> {
+    let max = if from_bits > 64 {
+        return Ok(None);
+    } else if from_bits == 64 {
+        u64::MAX
+    } else {
+        (1u64 << from_bits) - 1
+    };
+    trace!(
+        "clamp_range: fact {:?} from {} to {}",
+        fact,
+        from_bits,
+        to_bits
+    );
+    Ok(fact
+        .and_then(|f| ctx.uextend(&f, from_bits, to_bits))
+        .or_else(|| {
+            let result = Fact::Range {
+                bit_width: to_bits,
+                min: 0,
+                max,
+            };
+            trace!(" -> clamping to {:?}", result);
+            Some(result)
+        }))
+}
+
+pub(crate) fn check_subsumes(ctx: &FactContext, subsumer: &Fact, subsumee: &Fact) -> PccResult<()> {
+    check_subsumes_optionals(ctx, Some(subsumer), Some(subsumee))
+}
+
+pub(crate) fn check_subsumes_optionals(
+    ctx: &FactContext,
+    subsumer: Option<&Fact>,
+    subsumee: Option<&Fact>,
+) -> PccResult<()> {
+    trace!(
+        "checking if derived fact {:?} subsumes stated fact {:?}",
+        subsumer,
+        subsumee
+    );
+
+    if ctx.subsumes_fact_optionals(subsumer, subsumee) {
+        Ok(())
+    } else {
+        Err(PccError::UnsupportedFact)
+    }
+}
+
+pub(crate) fn check_output<I: VCodeInst, F: FnOnce(&VCode<I>) -> PccResult<Option<Fact>>>(
+    ctx: &FactContext,
+    vcode: &mut VCode<I>,
+    out: Writable<Reg>,
+    ins: &[Reg],
+    f: F,
+) -> PccResult<()> {
+    if let Some(fact) = vcode.vreg_fact(out.to_reg().into()) {
+        let result = f(vcode)?;
+        check_subsumes_optionals(ctx, result.as_ref(), Some(fact))
+    } else if ins.iter().any(|r| {
+        vcode
+            .vreg_fact(r.into())
+            .map(|fact| fact.propagates())
+            .unwrap_or(false)
+    }) {
+        if let Ok(Some(fact)) = f(vcode) {
+            trace!("setting vreg {:?} to {:?}", out, fact);
+            vcode.set_vreg_fact(out.to_reg().into(), fact);
+        }
+        Ok(())
+    } else {
+        Ok(())
+    }
+}
+
+pub(crate) fn check_unop<I: VCodeInst, F: FnOnce(&Fact) -> PccResult<Option<Fact>>>(
+    ctx: &FactContext,
+    vcode: &mut VCode<I>,
+    reg_width: u16,
+    out: Writable<Reg>,
+    ra: Reg,
+    f: F,
+) -> PccResult<()> {
+    check_output(ctx, vcode, out, &[ra], |vcode| {
+        let ra = get_fact_or_default(vcode, ra, reg_width);
+        f(&ra)
+    })
+}
+
+pub(crate) fn check_binop<I: VCodeInst, F: FnOnce(&Fact, &Fact) -> PccResult<Option<Fact>>>(
+    ctx: &FactContext,
+    vcode: &mut VCode<I>,
+    reg_width: u16,
+    out: Writable<Reg>,
+    ra: Reg,
+    rb: Reg,
+    f: F,
+) -> PccResult<()> {
+    check_output(ctx, vcode, out, &[ra, rb], |vcode| {
+        let ra = get_fact_or_default(vcode, ra, reg_width);
+        let rb = get_fact_or_default(vcode, rb, reg_width);
+        f(&ra, &rb)
+    })
+}
+
+pub(crate) fn check_constant<I: VCodeInst>(
+    ctx: &FactContext,
+    vcode: &mut VCode<I>,
+    out: Writable<Reg>,
+    bit_width: u16,
+    value: u64,
+) -> PccResult<()> {
+    let result = Fact::constant(bit_width, value);
+    if let Some(fact) = vcode.vreg_fact(out.to_reg().into()) {
+        check_subsumes(ctx, &result, fact)
+    } else {
+        trace!("setting vreg {:?} to {:?}", out, result);
+        vcode.set_vreg_fact(out.to_reg().into(), result);
+        Ok(())
+    }
+}
+
+/// The operation we're checking against an amode: either
+///
+/// - a *load*, and we need to validate that the field's fact subsumes
+///   the load result's fact, OR
+///
+/// - a *store*, and we need to validate that the stored data's fact
+///   subsumes the field's fact.
+pub(crate) enum LoadOrStore<'a> {
+    Load {
+        result_fact: Option<&'a Fact>,
+        from_bits: u16,
+        to_bits: u16,
+    },
+    Store {
+        stored_fact: Option<&'a Fact>,
+    },
+}
diff --git a/cranelift/codegen/src/machinst/reg.rs b/cranelift/codegen/src/machinst/reg.rs
index 4fd9b1e177c4..3a6b624651e5 100644
--- a/cranelift/codegen/src/machinst/reg.rs
+++ b/cranelift/codegen/src/machinst/reg.rs
@@ -4,9 +4,7 @@
 
 use alloc::{string::String, vec::Vec};
 use core::{fmt::Debug, hash::Hash};
-use regalloc2::{
-    Allocation, Operand, OperandConstraint, OperandKind, OperandPos, PReg, PRegSet, VReg,
-};
+use regalloc2::{Operand, OperandConstraint, OperandKind, OperandPos, PReg, PRegSet, VReg};
 
 #[cfg(feature = "enable-serde")]
 use serde_derive::{Deserialize, Serialize};
@@ -53,11 +51,7 @@ impl Reg {
     /// Get the physical register (`RealReg`), if this register is
     /// one.
     pub fn to_real_reg(self) -> Option<RealReg> {
-        if pinned_vreg_to_preg(self.0).is_some() {
-            Some(RealReg(self.0))
-        } else {
-            None
-        }
+        pinned_vreg_to_preg(self.0).map(RealReg)
     }
 
     /// Get the virtual (non-physical) register, if this register is
@@ -90,21 +84,27 @@ impl std::fmt::Debug for Reg {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         if let Some(rreg) = self.to_real_reg() {
             let preg: PReg = rreg.into();
-            write!(f, "{}", preg)
+            write!(f, "{preg}")
         } else if let Some(vreg) = self.to_virtual_reg() {
             let vreg: VReg = vreg.into();
-            write!(f, "{}", vreg)
+            write!(f, "{vreg}")
         } else {
             unreachable!()
         }
     }
 }
 
+impl AsMut<Reg> for Reg {
+    fn as_mut(&mut self) -> &mut Reg {
+        self
+    }
+}
+
 /// A real (physical) register. This corresponds to one of the target
 /// ISA's named registers and can be used as an instruction operand.
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-pub struct RealReg(VReg);
+pub struct RealReg(PReg);
 
 impl RealReg {
     /// Get the class of this register.
@@ -112,8 +112,9 @@ impl RealReg {
         self.0.class()
     }
 
+    /// The physical register number.
     pub fn hw_enc(self) -> u8 {
-        PReg::from(self).hw_enc() as u8
+        self.0.hw_enc() as u8
     }
 }
 
@@ -160,11 +161,11 @@ impl std::fmt::Debug for VirtualReg {
 /// temporary.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[cfg_attr(feature = "enable-serde", derive(Serialize, Deserialize))]
-pub struct Writable<T: Clone + Copy + Debug + PartialEq + Eq + PartialOrd + Ord + Hash> {
+pub struct Writable<T> {
     reg: T,
 }
 
-impl<T: Clone + Copy + Debug + PartialEq + Eq + PartialOrd + Ord + Hash> Writable<T> {
+impl<T> Writable<T> {
     /// Explicitly construct a `Writable<T>` from a `T`. As noted in
     /// the documentation for `Writable`, this is not hidden or
     /// disallowed from the outside; anyone can perform the "cast";
@@ -178,17 +179,18 @@ impl<T: Clone + Copy + Debug + PartialEq + Eq + PartialOrd + Ord + Hash> Writabl
         self.reg
     }
 
+    /// Get a mutable borrow of the underlying register.
+    pub fn reg_mut(&mut self) -> &mut T {
+        &mut self.reg
+    }
+
     /// Map the underlying register to another value or type.
-    pub fn map<U, F>(self, f: F) -> Writable<U>
-    where
-        U: Clone + Copy + Debug + PartialEq + Eq + PartialOrd + Ord + Hash,
-        F: Fn(T) -> U,
-    {
+    pub fn map<U>(self, f: impl Fn(T) -> U) -> Writable<U> {
         Writable { reg: f(self.reg) }
     }
 }
 
-// Conversions between regalloc2 types (VReg) and our types
+// Conversions between regalloc2 types (VReg, PReg) and our types
 // (VirtualReg, RealReg, Reg).
 
 impl std::convert::From<regalloc2::VReg> for Reg {
@@ -204,13 +206,6 @@ impl std::convert::From<regalloc2::VReg> for VirtualReg {
     }
 }
 
-impl std::convert::From<regalloc2::VReg> for RealReg {
-    fn from(vreg: regalloc2::VReg) -> RealReg {
-        debug_assert!(pinned_vreg_to_preg(vreg).is_some());
-        RealReg(vreg)
-    }
-}
-
 impl std::convert::From<Reg> for regalloc2::VReg {
     /// Extract the underlying `regalloc2::VReg`. Note that physical
     /// registers also map to particular (special) VRegs, so this
@@ -219,6 +214,11 @@ impl std::convert::From<Reg> for regalloc2::VReg {
         reg.0
     }
 }
+impl std::convert::From<&Reg> for regalloc2::VReg {
+    fn from(reg: &Reg) -> regalloc2::VReg {
+        reg.0
+    }
+}
 
 impl std::convert::From<VirtualReg> for regalloc2::VReg {
     fn from(reg: VirtualReg) -> regalloc2::VReg {
@@ -228,31 +228,33 @@ impl std::convert::From<VirtualReg> for regalloc2::VReg {
 
 impl std::convert::From<RealReg> for regalloc2::VReg {
     fn from(reg: RealReg) -> regalloc2::VReg {
-        reg.0
+        // This representation is redundant: the class is implied in the vreg
+        // index as well as being in the vreg class field.
+        VReg::new(reg.0.index(), reg.0.class())
     }
 }
 
 impl std::convert::From<RealReg> for regalloc2::PReg {
     fn from(reg: RealReg) -> regalloc2::PReg {
-        PReg::from_index(reg.0.vreg())
+        reg.0
     }
 }
 
 impl std::convert::From<regalloc2::PReg> for RealReg {
     fn from(preg: regalloc2::PReg) -> RealReg {
-        RealReg(VReg::new(preg.index(), preg.class()))
+        RealReg(preg)
     }
 }
 
 impl std::convert::From<regalloc2::PReg> for Reg {
     fn from(preg: regalloc2::PReg) -> Reg {
-        Reg(VReg::new(preg.index(), preg.class()))
+        RealReg(preg).into()
     }
 }
 
 impl std::convert::From<RealReg> for Reg {
     fn from(reg: RealReg) -> Reg {
-        Reg(reg.0)
+        Reg(reg.into())
     }
 }
 
@@ -289,7 +291,6 @@ pub type RegClass = regalloc2::RegClass;
 #[derive(Debug)]
 pub struct OperandCollector<'a, F: Fn(VReg) -> VReg> {
     operands: &'a mut Vec<Operand>,
-    operands_start: usize,
     clobbers: PRegSet,
 
     /// The subset of physical registers that are allocatable.
@@ -301,256 +302,183 @@ pub struct OperandCollector<'a, F: Fn(VReg) -> VReg> {
 impl<'a, F: Fn(VReg) -> VReg> OperandCollector<'a, F> {
     /// Start gathering operands into one flattened operand array.
     pub fn new(operands: &'a mut Vec<Operand>, allocatable: PRegSet, renamer: F) -> Self {
-        let operands_start = operands.len();
         Self {
             operands,
-            operands_start,
             clobbers: PRegSet::default(),
             allocatable,
             renamer,
         }
     }
 
-    /// Returns true if no reuse_def constraints have been added.
-    pub fn no_reuse_def(&self) -> bool {
-        !self.operands[self.operands_start..]
-            .iter()
-            .any(|operand| match operand.constraint() {
-                OperandConstraint::Reuse(_) => true,
-                _ => false,
-            })
-    }
-
-    fn is_allocatable_preg(&self, reg: PReg) -> bool {
-        self.allocatable.contains(reg)
-    }
-
-    /// Add an operand.
-    fn add_operand(&mut self, operand: Operand) {
-        let vreg = (self.renamer)(operand.vreg());
-        let operand = Operand::new(vreg, operand.constraint(), operand.kind(), operand.pos());
-        self.operands.push(operand);
-    }
-
     /// Finish the operand collection and return the tuple giving the
     /// range of indices in the flattened operand array, and the
     /// clobber set.
-    pub fn finish(self) -> ((u32, u32), PRegSet) {
-        let start = self.operands_start as u32;
-        let end = self.operands.len() as u32;
-        ((start, end), self.clobbers)
+    pub fn finish(self) -> (usize, PRegSet) {
+        let end = self.operands.len();
+        (end, self.clobbers)
     }
+}
+
+pub trait OperandVisitor {
+    fn add_operand(
+        &mut self,
+        reg: &mut Reg,
+        constraint: OperandConstraint,
+        kind: OperandKind,
+        pos: OperandPos,
+    );
 
+    fn debug_assert_is_allocatable_preg(&self, _reg: PReg, _expected: bool) {}
+
+    /// Add a register clobber set. This is a set of registers that
+    /// are written by the instruction, so must be reserved (not used)
+    /// for the whole instruction, but are not used afterward.
+    fn reg_clobbers(&mut self, _regs: PRegSet) {}
+}
+
+pub trait OperandVisitorImpl: OperandVisitor {
     /// Add a use of a fixed, nonallocatable physical register.
-    pub fn reg_fixed_nonallocatable(&mut self, preg: PReg) {
-        debug_assert!(!self.is_allocatable_preg(preg));
-        self.add_operand(Operand::fixed_nonallocatable(preg))
+    fn reg_fixed_nonallocatable(&mut self, preg: PReg) {
+        self.debug_assert_is_allocatable_preg(preg, false);
+        // Since this operand does not participate in register allocation,
+        // there's nothing to do here.
     }
 
     /// Add a register use, at the start of the instruction (`Before`
     /// position).
-    pub fn reg_use(&mut self, reg: Reg) {
-        if let Some(rreg) = reg.to_real_reg() {
-            self.reg_fixed_nonallocatable(rreg.into());
-        } else {
-            debug_assert!(reg.is_virtual());
-            self.add_operand(Operand::reg_use(reg.into()));
-        }
+    fn reg_use(&mut self, reg: &mut impl AsMut<Reg>) {
+        self.reg_maybe_fixed(reg.as_mut(), OperandKind::Use, OperandPos::Early);
     }
 
     /// Add a register use, at the end of the instruction (`After` position).
-    pub fn reg_late_use(&mut self, reg: Reg) {
-        if let Some(rreg) = reg.to_real_reg() {
-            self.reg_fixed_nonallocatable(rreg.into());
-        } else {
-            debug_assert!(reg.is_virtual());
-            self.add_operand(Operand::reg_use_at_end(reg.into()));
-        }
-    }
-
-    /// Add multiple register uses.
-    pub fn reg_uses(&mut self, regs: &[Reg]) {
-        for &reg in regs {
-            self.reg_use(reg);
-        }
+    fn reg_late_use(&mut self, reg: &mut impl AsMut<Reg>) {
+        self.reg_maybe_fixed(reg.as_mut(), OperandKind::Use, OperandPos::Late);
     }
 
     /// Add a register def, at the end of the instruction (`After`
     /// position). Use only when this def will be written after all
     /// uses are read.
-    pub fn reg_def(&mut self, reg: Writable<Reg>) {
-        if let Some(rreg) = reg.to_reg().to_real_reg() {
-            self.reg_fixed_nonallocatable(rreg.into());
-        } else {
-            debug_assert!(reg.to_reg().is_virtual());
-            self.add_operand(Operand::reg_def(reg.to_reg().into()));
-        }
-    }
-
-    /// Add multiple register defs.
-    pub fn reg_defs(&mut self, regs: &[Writable<Reg>]) {
-        for &reg in regs {
-            self.reg_def(reg);
-        }
+    fn reg_def(&mut self, reg: &mut Writable<impl AsMut<Reg>>) {
+        self.reg_maybe_fixed(reg.reg.as_mut(), OperandKind::Def, OperandPos::Late);
     }
 
     /// Add a register "early def", which logically occurs at the
     /// beginning of the instruction, alongside all uses. Use this
     /// when the def may be written before all uses are read; the
     /// regalloc will ensure that it does not overwrite any uses.
-    pub fn reg_early_def(&mut self, reg: Writable<Reg>) {
-        if let Some(rreg) = reg.to_reg().to_real_reg() {
-            self.reg_fixed_nonallocatable(rreg.into());
-        } else {
-            debug_assert!(reg.to_reg().is_virtual());
-            self.add_operand(Operand::reg_def_at_start(reg.to_reg().into()));
-        }
+    fn reg_early_def(&mut self, reg: &mut Writable<impl AsMut<Reg>>) {
+        self.reg_maybe_fixed(reg.reg.as_mut(), OperandKind::Def, OperandPos::Early);
     }
 
     /// Add a register "fixed use", which ties a vreg to a particular
     /// RealReg at the end of the instruction.
-    pub fn reg_fixed_late_use(&mut self, reg: Reg, rreg: Reg) {
-        debug_assert!(reg.is_virtual());
-        let rreg = rreg.to_real_reg().expect("fixed reg is not a RealReg");
-        debug_assert!(self.is_allocatable_preg(rreg.into()));
-        self.add_operand(Operand::new(
-            reg.into(),
-            OperandConstraint::FixedReg(rreg.into()),
-            OperandKind::Use,
-            OperandPos::Late,
-        ));
+    fn reg_fixed_late_use(&mut self, reg: &mut impl AsMut<Reg>, rreg: Reg) {
+        self.reg_fixed(reg.as_mut(), rreg, OperandKind::Use, OperandPos::Late);
     }
 
     /// Add a register "fixed use", which ties a vreg to a particular
     /// RealReg at this point.
-    pub fn reg_fixed_use(&mut self, reg: Reg, rreg: Reg) {
-        debug_assert!(reg.is_virtual());
-        let rreg = rreg.to_real_reg().expect("fixed reg is not a RealReg");
-        debug_assert!(self.is_allocatable_preg(rreg.into()));
-        self.add_operand(Operand::reg_fixed_use(reg.into(), rreg.into()));
+    fn reg_fixed_use(&mut self, reg: &mut impl AsMut<Reg>, rreg: Reg) {
+        self.reg_fixed(reg.as_mut(), rreg, OperandKind::Use, OperandPos::Early);
     }
 
     /// Add a register "fixed def", which ties a vreg to a particular
     /// RealReg at this point.
-    pub fn reg_fixed_def(&mut self, reg: Writable<Reg>, rreg: Reg) {
-        debug_assert!(reg.to_reg().is_virtual());
+    fn reg_fixed_def(&mut self, reg: &mut Writable<impl AsMut<Reg>>, rreg: Reg) {
+        self.reg_fixed(reg.reg.as_mut(), rreg, OperandKind::Def, OperandPos::Late);
+    }
+
+    /// Add an operand tying a virtual register to a physical register.
+    fn reg_fixed(&mut self, reg: &mut Reg, rreg: Reg, kind: OperandKind, pos: OperandPos) {
+        debug_assert!(reg.is_virtual());
         let rreg = rreg.to_real_reg().expect("fixed reg is not a RealReg");
-        debug_assert!(
-            self.is_allocatable_preg(rreg.into()),
-            "{rreg:?} is not allocatable"
-        );
-        self.add_operand(Operand::reg_fixed_def(reg.to_reg().into(), rreg.into()));
+        self.debug_assert_is_allocatable_preg(rreg.into(), true);
+        let constraint = OperandConstraint::FixedReg(rreg.into());
+        self.add_operand(reg, constraint, kind, pos);
+    }
+
+    /// Add an operand which might already be a physical register.
+    fn reg_maybe_fixed(&mut self, reg: &mut Reg, kind: OperandKind, pos: OperandPos) {
+        if let Some(rreg) = reg.to_real_reg() {
+            self.reg_fixed_nonallocatable(rreg.into());
+        } else {
+            debug_assert!(reg.is_virtual());
+            self.add_operand(reg, OperandConstraint::Reg, kind, pos);
+        }
     }
 
     /// Add a register def that reuses an earlier use-operand's
     /// allocation. The index of that earlier operand (relative to the
     /// current instruction's start of operands) must be known.
-    pub fn reg_reuse_def(&mut self, reg: Writable<Reg>, idx: usize) {
-        if let Some(rreg) = reg.to_reg().to_real_reg() {
+    fn reg_reuse_def(&mut self, reg: &mut Writable<impl AsMut<Reg>>, idx: usize) {
+        let reg = reg.reg.as_mut();
+        if let Some(rreg) = reg.to_real_reg() {
             // In some cases we see real register arguments to a reg_reuse_def
             // constraint. We assume the creator knows what they're doing
             // here, though we do also require that the real register be a
             // fixed-nonallocatable register.
             self.reg_fixed_nonallocatable(rreg.into());
         } else {
+            debug_assert!(reg.is_virtual());
             // The operand we're reusing must not be fixed-nonallocatable, as
             // that would imply that the register has been allocated to a
             // virtual register.
-            self.add_operand(Operand::reg_reuse_def(reg.to_reg().into(), idx));
+            let constraint = OperandConstraint::Reuse(idx);
+            self.add_operand(reg, constraint, OperandKind::Def, OperandPos::Late);
         }
     }
+}
 
-    /// Add a register clobber set. This is a set of registers that
-    /// are written by the instruction, so must be reserved (not used)
-    /// for the whole instruction, but are not used afterward.
-    pub fn reg_clobbers(&mut self, regs: PRegSet) {
+impl<T: OperandVisitor> OperandVisitorImpl for T {}
+
+impl<'a, F: Fn(VReg) -> VReg> OperandVisitor for OperandCollector<'a, F> {
+    fn add_operand(
+        &mut self,
+        reg: &mut Reg,
+        constraint: OperandConstraint,
+        kind: OperandKind,
+        pos: OperandPos,
+    ) {
+        reg.0 = (self.renamer)(reg.0);
+        self.operands
+            .push(Operand::new(reg.0, constraint, kind, pos));
+    }
+
+    fn debug_assert_is_allocatable_preg(&self, reg: PReg, expected: bool) {
+        debug_assert_eq!(
+            self.allocatable.contains(reg),
+            expected,
+            "{reg:?} should{} be allocatable",
+            if expected { "" } else { " not" }
+        );
+    }
+
+    fn reg_clobbers(&mut self, regs: PRegSet) {
         self.clobbers.union_from(regs);
     }
 }
 
+impl<T: FnMut(&mut Reg, OperandConstraint, OperandKind, OperandPos)> OperandVisitor for T {
+    fn add_operand(
+        &mut self,
+        reg: &mut Reg,
+        constraint: OperandConstraint,
+        kind: OperandKind,
+        pos: OperandPos,
+    ) {
+        self(reg, constraint, kind, pos)
+    }
+}
+
 /// Pretty-print part of a disassembly, with knowledge of
 /// operand/instruction size, and optionally with regalloc
 /// results. This can be used, for example, to print either `rax` or
 /// `eax` for the register by those names on x86-64, depending on a
 /// 64- or 32-bit context.
 pub trait PrettyPrint {
-    fn pretty_print(&self, size_bytes: u8, allocs: &mut AllocationConsumer<'_>) -> String;
+    fn pretty_print(&self, size_bytes: u8) -> String;
 
     fn pretty_print_default(&self) -> String {
-        self.pretty_print(0, &mut AllocationConsumer::new(&[]))
-    }
-}
-
-/// A consumer of an (optional) list of Allocations along with Regs
-/// that provides RealRegs where available.
-///
-/// This is meant to be used during code emission or
-/// pretty-printing. In at least the latter case, regalloc results may
-/// or may not be available, so we may end up printing either vregs or
-/// rregs. Even pre-regalloc, though, some registers may be RealRegs
-/// that were provided when the instruction was created.
-///
-/// This struct should be used in a specific way: when matching on an
-/// instruction, provide it the Regs in the same order as they were
-/// provided to the OperandCollector.
-#[derive(Clone)]
-pub struct AllocationConsumer<'a> {
-    allocs: std::slice::Iter<'a, Allocation>,
-}
-
-impl<'a> AllocationConsumer<'a> {
-    pub fn new(allocs: &'a [Allocation]) -> Self {
-        Self {
-            allocs: allocs.iter(),
-        }
-    }
-
-    pub fn next_fixed_nonallocatable(&mut self, preg: PReg) {
-        let alloc = self.allocs.next();
-        let alloc = alloc.map(|alloc| {
-            Reg::from(
-                alloc
-                    .as_reg()
-                    .expect("Should not have gotten a stack allocation"),
-            )
-        });
-
-        match alloc {
-            Some(alloc) => {
-                assert_eq!(preg, alloc.to_real_reg().unwrap().into());
-            }
-            None => {}
-        }
-    }
-
-    pub fn next(&mut self, pre_regalloc_reg: Reg) -> Reg {
-        let alloc = self.allocs.next();
-        let alloc = alloc.map(|alloc| {
-            Reg::from(
-                alloc
-                    .as_reg()
-                    .expect("Should not have gotten a stack allocation"),
-            )
-        });
-
-        match (pre_regalloc_reg.to_real_reg(), alloc) {
-            (Some(rreg), None) => rreg.into(),
-            (Some(rreg), Some(alloc)) => {
-                debug_assert_eq!(Reg::from(rreg), alloc);
-                alloc
-            }
-            (None, Some(alloc)) => alloc,
-            _ => pre_regalloc_reg,
-        }
-    }
-
-    pub fn next_writable(&mut self, pre_regalloc_reg: Writable<Reg>) -> Writable<Reg> {
-        Writable::from_reg(self.next(pre_regalloc_reg.to_reg()))
-    }
-}
-
-impl<'a> std::default::Default for AllocationConsumer<'a> {
-    fn default() -> Self {
-        Self { allocs: [].iter() }
+        self.pretty_print(0)
     }
 }
diff --git a/cranelift/codegen/src/machinst/valueregs.rs b/cranelift/codegen/src/machinst/valueregs.rs
index 52b3c89896e1..fbbb365c3d79 100644
--- a/cranelift/codegen/src/machinst/valueregs.rs
+++ b/cranelift/codegen/src/machinst/valueregs.rs
@@ -17,7 +17,7 @@ const VALUE_REGS_PARTS: usize = 2;
 /// By convention, the register parts are kept in machine-endian order here.
 ///
 /// N.B.: we cap the capacity of this at four (when any 32-bit target is
-/// enabled) or two (otherwise), and we use special in-band sentinal `Reg`
+/// enabled) or two (otherwise), and we use special in-band sentinel `Reg`
 /// values (`Reg::invalid()`) to avoid the need to carry a separate length. This
 /// allows the struct to be `Copy` (no heap or drop overhead) and be only 16 or
 /// 8 bytes, which is important for compiler performance.
@@ -82,10 +82,16 @@ impl<R: Clone + Copy + Debug + PartialEq + Eq + InvalidSentinel> ValueRegs<R> {
         }
     }
 
-    /// Return an iterator over the registers storing this value.
+    /// Return a slice of the registers storing this value.
     pub fn regs(&self) -> &[R] {
         &self.parts[0..self.len()]
     }
+
+    /// Return a mutable slice of the registers storing this value.
+    pub fn regs_mut(&mut self) -> &mut [R] {
+        let len = self.len();
+        &mut self.parts[0..len]
+    }
 }
 
 impl<R: Clone + Copy + Debug + PartialEq + Eq + InvalidSentinel> ValueRegs<R> {
diff --git a/cranelift/codegen/src/machinst/vcode.rs b/cranelift/codegen/src/machinst/vcode.rs
index 7e88902634d2..de49327f25bb 100644
--- a/cranelift/codegen/src/machinst/vcode.rs
+++ b/cranelift/codegen/src/machinst/vcode.rs
@@ -17,23 +17,22 @@
 //! See the main module comment in `mod.rs` for more details on the VCode-based
 //! backend pipeline.
 
-use crate::fx::FxHashMap;
-use crate::fx::FxHashSet;
-use crate::ir::RelSourceLoc;
-use crate::ir::{self, types, Constant, ConstantData, DynamicStackSlot, ValueLabel};
+use crate::ir::pcc::*;
+use crate::ir::{self, types, Constant, ConstantData, ValueLabel};
 use crate::machinst::*;
+use crate::ranges::Ranges;
 use crate::timing;
 use crate::trace;
 use crate::CodegenError;
 use crate::{LabelValueLoc, ValueLocRange};
-use cranelift_control::ControlPlane;
 use regalloc2::{
-    Edit, Function as RegallocFunction, InstOrEdit, InstRange, MachineEnv, Operand, OperandKind,
-    PRegSet, RegClass, VReg,
+    Edit, Function as RegallocFunction, InstOrEdit, InstRange, MachineEnv, Operand,
+    OperandConstraint, OperandKind, PRegSet, RegClass,
 };
+use rustc_hash::FxHashMap;
 
-use alloc::vec::Vec;
-use cranelift_entity::{entity_impl, Keys, PrimaryMap};
+use core::mem::take;
+use cranelift_entity::{entity_impl, Keys};
 use std::collections::hash_map::Entry;
 use std::collections::HashMap;
 use std::fmt;
@@ -41,6 +40,33 @@ use std::fmt;
 /// Index referring to an instruction in VCode.
 pub type InsnIndex = regalloc2::Inst;
 
+/// Extension trait for `InsnIndex` to allow conversion to a
+/// `BackwardsInsnIndex`.
+trait ToBackwardsInsnIndex {
+    fn to_backwards_insn_index(&self, num_insts: usize) -> BackwardsInsnIndex;
+}
+
+impl ToBackwardsInsnIndex for InsnIndex {
+    fn to_backwards_insn_index(&self, num_insts: usize) -> BackwardsInsnIndex {
+        BackwardsInsnIndex::new(num_insts - self.index() - 1)
+    }
+}
+
+/// An index referring to an instruction in the VCode when it is backwards,
+/// during VCode construction.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[cfg_attr(
+    feature = "enable-serde",
+    derive(::serde::Serialize, ::serde::Deserialize)
+)]
+pub struct BackwardsInsnIndex(InsnIndex);
+
+impl BackwardsInsnIndex {
+    pub fn new(i: usize) -> Self {
+        BackwardsInsnIndex(InsnIndex::new(i))
+    }
+}
+
 /// Index referring to a basic block in VCode.
 pub type BlockIndex = regalloc2::Block;
 
@@ -68,6 +94,14 @@ pub struct VCode<I: VCodeInst> {
     /// Lowered machine instructions in order corresponding to the original IR.
     insts: Vec<I>,
 
+    /// A map from backwards instruction index to the user stack map for that
+    /// instruction.
+    ///
+    /// This is a sparse side table that only has entries for instructions that
+    /// are safepoints, and only for a subset of those that have an associated
+    /// user stack map.
+    user_stack_maps: FxHashMap<BackwardsInsnIndex, ir::UserStackMap>,
+
     /// Operands: pre-regalloc references to virtual registers with
     /// constraints, in one flattened array. This allows the regalloc
     /// to efficiently access all operands without requiring expensive
@@ -77,7 +111,7 @@ pub struct VCode<I: VCodeInst> {
     /// Operand index ranges: for each instruction in `insts`, there
     /// is a tuple here providing the range in `operands` for that
     /// instruction's operands.
-    operand_ranges: Vec<(u32, u32)>,
+    operand_ranges: Ranges,
 
     /// Clobbers: a sparse map from instruction indices to clobber masks.
     clobbers: FxHashMap<InsnIndex, PRegSet>,
@@ -90,23 +124,28 @@ pub struct VCode<I: VCodeInst> {
     entry: BlockIndex,
 
     /// Block instruction indices.
-    block_ranges: Vec<(InsnIndex, InsnIndex)>,
+    block_ranges: Ranges,
+
+    /// Block successors: index range in the `block_succs` list.
+    block_succ_range: Ranges,
 
-    /// Block successors: index range in the `block_succs_preds` list.
-    block_succ_range: Vec<(u32, u32)>,
+    /// Block successor lists, concatenated into one vec. The
+    /// `block_succ_range` list of tuples above gives (start, end)
+    /// ranges within this list that correspond to each basic block's
+    /// successors.
+    block_succs: Vec<regalloc2::Block>,
 
-    /// Block predecessors: index range in the `block_succs_preds` list.
-    block_pred_range: Vec<(u32, u32)>,
+    /// Block predecessors: index range in the `block_preds` list.
+    block_pred_range: Ranges,
 
-    /// Block successor and predecessor lists, concatenated into one
-    /// Vec. The `block_succ_range` and `block_pred_range` lists of
-    /// tuples above give (start, end) ranges within this list that
-    /// correspond to each basic block's successors or predecessors,
-    /// respectively.
-    block_succs_preds: Vec<regalloc2::Block>,
+    /// Block predecessor lists, concatenated into one vec. The
+    /// `block_pred_range` list of tuples above gives (start, end)
+    /// ranges within this list that correspond to each basic block's
+    /// predecessors.
+    block_preds: Vec<regalloc2::Block>,
 
     /// Block parameters: index range in `block_params` below.
-    block_params_range: Vec<(u32, u32)>,
+    block_params_range: Ranges,
 
     /// Block parameter lists, concatenated into one vec. The
     /// `block_params_range` list of tuples above gives (start, end)
@@ -130,25 +169,11 @@ pub struct VCode<I: VCodeInst> {
     /// for each block are concatenated.
     ///
     /// Indexed by the indices in `branch_block_arg_succ_range`.
-    branch_block_arg_range: Vec<(u32, u32)>,
+    branch_block_arg_range: Ranges,
 
     /// For a given block, indices in `branch_block_arg_range`
     /// corresponding to all of its successors.
-    branch_block_arg_succ_range: Vec<(u32, u32)>,
-
-    /// VReg aliases. Each key in this table is translated to its
-    /// value when gathering Operands from instructions. Aliases are
-    /// not chased transitively (we do not further look up the
-    /// translated reg to see if it is another alias).
-    ///
-    /// We use these aliases to rename an instruction's expected
-    /// result vregs to the returned vregs from lowering, which are
-    /// usually freshly-allocated temps.
-    ///
-    /// Operands and branch arguments will already have been
-    /// translated through this alias table; but it helps to make
-    /// sense of instructions when pretty-printed, for example.
-    vreg_aliases: FxHashMap<regalloc2::VReg, regalloc2::VReg>,
+    branch_block_arg_succ_range: Ranges,
 
     /// Block-order information.
     block_order: BlockLoweringOrder,
@@ -160,18 +185,16 @@ pub struct VCode<I: VCodeInst> {
     /// immutable across function compilations within the same module.
     emit_info: I::Info,
 
-    /// Reference-typed `regalloc2::VReg`s. The regalloc requires
-    /// these in a dense slice (as opposed to querying the
-    /// reftype-status of each vreg) for efficient iteration.
-    reftyped_vregs: Vec<VReg>,
-
     /// Constants.
-    constants: VCodeConstants,
+    pub(crate) constants: VCodeConstants,
 
     /// Value labels for debuginfo attached to vregs.
     debug_value_labels: Vec<(VReg, InsnIndex, InsnIndex, u32)>,
 
     pub(crate) sigs: SigSet,
+
+    /// Facts on VRegs, for proof-carrying code verification.
+    facts: Vec<Option<Fact>>,
 }
 
 /// The result of `VCode::emit`. Contains all information computed
@@ -231,26 +254,9 @@ pub struct VCodeBuilder<I: VCodeInst> {
     /// In-progress VCode.
     pub(crate) vcode: VCode<I>,
 
-    /// In what direction is the build occuring?
+    /// In what direction is the build occurring?
     direction: VCodeBuildDirection,
 
-    /// Index of the last block-start in the vcode.
-    block_start: usize,
-
-    /// Start of succs for the current block in the concatenated succs list.
-    succ_start: usize,
-
-    /// Start of blockparams for the current block in the concatenated
-    /// blockparams list.
-    block_params_start: usize,
-
-    /// Start of successor blockparam arg list entries in
-    /// the concatenated branch_block_arg_range list.
-    branch_block_arg_succ_start: usize,
-
-    /// Current source location.
-    cur_srcloc: RelSourceLoc,
-
     /// Debug-value label in-progress map, keyed by label. For each
     /// label, we keep disjoint ranges mapping to vregs. We'll flatten
     /// this into (vreg, range, label) tuples when done.
@@ -275,23 +281,18 @@ impl<I: VCodeInst> VCodeBuilder<I> {
         block_order: BlockLoweringOrder,
         constants: VCodeConstants,
         direction: VCodeBuildDirection,
-    ) -> VCodeBuilder<I> {
+    ) -> Self {
         let vcode = VCode::new(sigs, abi, emit_info, block_order, constants);
 
         VCodeBuilder {
             vcode,
             direction,
-            block_start: 0,
-            succ_start: 0,
-            block_params_start: 0,
-            branch_block_arg_succ_start: 0,
-            cur_srcloc: Default::default(),
             debug_info: FxHashMap::default(),
         }
     }
 
-    pub fn init_abi(&mut self, temps: Vec<Writable<Reg>>) {
-        self.vcode.abi.init(&self.vcode.sigs, temps);
+    pub fn init_retval_area(&mut self, vregs: &mut VRegAllocator<I>) -> CodegenResult<()> {
+        self.vcode.abi.init_retval_area(&self.vcode.sigs, vregs)
     }
 
     /// Access the ABI object.
@@ -325,32 +326,20 @@ impl<I: VCodeInst> VCodeBuilder<I> {
     /// End the current basic block. Must be called after emitting vcode insts
     /// for IR insts and prior to ending the function (building the VCode).
     pub fn end_bb(&mut self) {
-        let start_idx = self.block_start;
         let end_idx = self.vcode.insts.len();
-        self.block_start = end_idx;
         // Add the instruction index range to the list of blocks.
-        self.vcode
-            .block_ranges
-            .push((InsnIndex::new(start_idx), InsnIndex::new(end_idx)));
+        self.vcode.block_ranges.push_end(end_idx);
         // End the successors list.
-        let succ_end = self.vcode.block_succs_preds.len();
-        self.vcode
-            .block_succ_range
-            .push((self.succ_start as u32, succ_end as u32));
-        self.succ_start = succ_end;
+        let succ_end = self.vcode.block_succs.len();
+        self.vcode.block_succ_range.push_end(succ_end);
         // End the blockparams list.
         let block_params_end = self.vcode.block_params.len();
-        self.vcode
-            .block_params_range
-            .push((self.block_params_start as u32, block_params_end as u32));
-        self.block_params_start = block_params_end;
+        self.vcode.block_params_range.push_end(block_params_end);
         // End the branch blockparam args list.
         let branch_block_arg_succ_end = self.vcode.branch_block_arg_range.len();
-        self.vcode.branch_block_arg_succ_range.push((
-            self.branch_block_arg_succ_start as u32,
-            branch_block_arg_succ_end as u32,
-        ));
-        self.branch_block_arg_succ_start = branch_block_arg_succ_end;
+        self.vcode
+            .branch_block_arg_succ_range
+            .push_end(branch_block_arg_succ_end);
     }
 
     pub fn add_block_param(&mut self, param: VirtualReg) {
@@ -358,34 +347,26 @@ impl<I: VCodeInst> VCodeBuilder<I> {
     }
 
     fn add_branch_args_for_succ(&mut self, args: &[Reg]) {
-        let start = self.vcode.branch_block_args.len();
         self.vcode
             .branch_block_args
             .extend(args.iter().map(|&arg| VReg::from(arg)));
         let end = self.vcode.branch_block_args.len();
-        self.vcode
-            .branch_block_arg_range
-            .push((start as u32, end as u32));
+        self.vcode.branch_block_arg_range.push_end(end);
     }
 
     /// Push an instruction for the current BB and current IR inst
     /// within the BB.
-    pub fn push(&mut self, insn: I) {
+    pub fn push(&mut self, insn: I, loc: RelSourceLoc) {
         self.vcode.insts.push(insn);
-        self.vcode.srclocs.push(self.cur_srcloc);
+        self.vcode.srclocs.push(loc);
     }
 
     /// Add a successor block with branch args.
     pub fn add_succ(&mut self, block: BlockIndex, args: &[Reg]) {
-        self.vcode.block_succs_preds.push(block);
+        self.vcode.block_succs.push(block);
         self.add_branch_args_for_succ(args);
     }
 
-    /// Set the current source location.
-    pub fn set_srcloc(&mut self, srcloc: RelSourceLoc) {
-        self.cur_srcloc = srcloc;
-    }
-
     /// Add a debug value label to a register.
     pub fn add_value_label(&mut self, reg: Reg, label: ValueLabel) {
         // We'll fix up labels in reverse(). Because we're generating
@@ -402,98 +383,76 @@ impl<I: VCodeInst> VCodeBuilder<I> {
         labels.push((last, inst, reg.into()));
     }
 
-    pub fn set_vreg_alias(&mut self, from: Reg, to: Reg) {
-        let from = from.into();
-        let resolved_to = self.resolve_vreg_alias(to.into());
-        // Disallow cycles (see below).
-        assert_ne!(resolved_to, from);
-        self.vcode.vreg_aliases.insert(from, resolved_to);
-    }
-
-    pub fn resolve_vreg_alias(&self, from: regalloc2::VReg) -> regalloc2::VReg {
-        Self::resolve_vreg_alias_impl(&self.vcode.vreg_aliases, from)
-    }
-
-    fn resolve_vreg_alias_impl(
-        aliases: &FxHashMap<regalloc2::VReg, regalloc2::VReg>,
-        from: regalloc2::VReg,
-    ) -> regalloc2::VReg {
-        // We prevent cycles from existing by resolving targets of
-        // aliases eagerly before setting them. If the target resolves
-        // to the origin of the alias, then a cycle would be created
-        // and the alias is disallowed. Because of the structure of
-        // SSA code (one instruction can refer to another's defs but
-        // not vice-versa, except indirectly through
-        // phis/blockparams), cycles should not occur as we use
-        // aliases to redirect vregs to the temps that actually define
-        // them.
-
-        let mut vreg = from;
-        while let Some(to) = aliases.get(&vreg) {
-            vreg = *to;
-        }
-        vreg
-    }
-
     /// Access the constants.
     pub fn constants(&mut self) -> &mut VCodeConstants {
         &mut self.vcode.constants
     }
 
     fn compute_preds_from_succs(&mut self) {
-        // Compute predecessors from successors. In order to gather
-        // all preds for a block into a contiguous sequence, we build
-        // a list of (succ, pred) tuples and then sort.
-        let mut succ_pred_edges: Vec<(BlockIndex, BlockIndex)> =
-            Vec::with_capacity(self.vcode.block_succs_preds.len());
-        for (pred, &(start, end)) in self.vcode.block_succ_range.iter().enumerate() {
-            let pred = BlockIndex::new(pred);
-            for i in start..end {
-                let succ = BlockIndex::new(self.vcode.block_succs_preds[i as usize].index());
-                succ_pred_edges.push((succ, pred));
-            }
+        // Do a linear-time counting sort: first determine how many
+        // times each block appears as a successor.
+        let mut starts = vec![0u32; self.vcode.num_blocks()];
+        for succ in &self.vcode.block_succs {
+            starts[succ.index()] += 1;
+        }
+
+        // Determine for each block the starting index where that
+        // block's predecessors should go. This is equivalent to the
+        // ranges we need to store in block_pred_range.
+        self.vcode.block_pred_range.reserve(starts.len());
+        let mut end = 0;
+        for count in starts.iter_mut() {
+            let start = end;
+            end += *count;
+            *count = start;
+            self.vcode.block_pred_range.push_end(end as usize);
         }
-        succ_pred_edges.sort_unstable();
-
-        let mut i = 0;
-        for succ in 0..self.vcode.num_blocks() {
-            let succ = BlockIndex::new(succ);
-            let start = self.vcode.block_succs_preds.len();
-            while i < succ_pred_edges.len() && succ_pred_edges[i].0 == succ {
-                let pred = succ_pred_edges[i].1;
-                self.vcode.block_succs_preds.push(pred);
-                i += 1;
+        let end = end as usize;
+        debug_assert_eq!(end, self.vcode.block_succs.len());
+
+        // Walk over the successors again, this time grouped by
+        // predecessor, and push the predecessor at the current
+        // starting position of each of its successors. We build
+        // each group of predecessors in whatever order Ranges::iter
+        // returns them; regalloc2 doesn't care.
+        self.vcode.block_preds.resize(end, BlockIndex::invalid());
+        for (pred, range) in self.vcode.block_succ_range.iter() {
+            let pred = BlockIndex::new(pred);
+            for succ in &self.vcode.block_succs[range] {
+                let pos = &mut starts[succ.index()];
+                self.vcode.block_preds[*pos as usize] = pred;
+                *pos += 1;
             }
-            let end = self.vcode.block_succs_preds.len();
-            self.vcode.block_pred_range.push((start as u32, end as u32));
         }
+        debug_assert!(self.vcode.block_preds.iter().all(|pred| pred.is_valid()));
     }
 
     /// Called once, when a build in Backward order is complete, to
     /// perform the overall reversal (into final forward order) and
     /// finalize metadata accordingly.
-    fn reverse_and_finalize(&mut self) {
+    fn reverse_and_finalize(&mut self, vregs: &VRegAllocator<I>) {
         let n_insts = self.vcode.insts.len();
         if n_insts == 0 {
             return;
         }
 
         // Reverse the per-block and per-inst sequences.
-        self.vcode.block_ranges.reverse();
+        self.vcode.block_ranges.reverse_index();
+        self.vcode.block_ranges.reverse_target(n_insts);
         // block_params_range is indexed by block (and blocks were
         // traversed in reverse) so we reverse it; but block-param
         // sequences in the concatenated vec can remain in reverse
         // order (it is effectively an arena of arbitrarily-placed
         // referenced sequences).
-        self.vcode.block_params_range.reverse();
+        self.vcode.block_params_range.reverse_index();
         // Likewise, we reverse block_succ_range, but the block_succ
         // concatenated array can remain as-is.
-        self.vcode.block_succ_range.reverse();
+        self.vcode.block_succ_range.reverse_index();
         self.vcode.insts.reverse();
         self.vcode.srclocs.reverse();
         // Likewise, branch_block_arg_succ_range is indexed by block
         // so must be reversed.
-        self.vcode.branch_block_arg_succ_range.reverse();
+        self.vcode.branch_block_arg_succ_range.reverse_index();
 
         // To translate an instruction index *endpoint* in reversed
         // order to forward order, compute `n_insts - i`.
@@ -507,16 +466,10 @@ impl<I: VCodeInst> VCodeBuilder<I> {
         // (exclusive) end of 10.
         let translate = |inst: InsnIndex| InsnIndex::new(n_insts - inst.index());
 
-        // Edit the block-range instruction indices.
-        for tuple in &mut self.vcode.block_ranges {
-            let (start, end) = *tuple;
-            *tuple = (translate(end), translate(start)); // Note reversed order.
-        }
-
         // Generate debug-value labels based on per-label maps.
         for (label, tuples) in &self.debug_info {
             for &(start, end, vreg) in tuples {
-                let vreg = self.resolve_vreg_alias(vreg);
+                let vreg = vregs.resolve_vreg_alias(vreg);
                 let fwd_start = translate(end);
                 let fwd_end = translate(start);
                 self.vcode
@@ -532,8 +485,9 @@ impl<I: VCodeInst> VCodeBuilder<I> {
             .sort_unstable_by_key(|(vreg, _, _, _)| *vreg);
     }
 
-    fn collect_operands(&mut self) {
-        for (i, insn) in self.vcode.insts.iter().enumerate() {
+    fn collect_operands(&mut self, vregs: &VRegAllocator<I>) {
+        let allocatable = PRegSet::from(self.vcode.machine_env());
+        for (i, insn) in self.vcode.insts.iter_mut().enumerate() {
             // Push operands from the instruction onto the operand list.
             //
             // We rename through the vreg alias table as we collect
@@ -545,15 +499,13 @@ impl<I: VCodeInst> VCodeBuilder<I> {
             // need to do the `match` over the instruction to visit
             // its register fields (which is slow, branchy code) once.
 
-            let vreg_aliases = &self.vcode.vreg_aliases;
-            let allocatable = PRegSet::from(self.vcode.machine_env());
             let mut op_collector =
                 OperandCollector::new(&mut self.vcode.operands, allocatable, |vreg| {
-                    Self::resolve_vreg_alias_impl(vreg_aliases, vreg)
+                    vregs.resolve_vreg_alias(vreg)
                 });
             insn.get_operands(&mut op_collector);
             let (ops, clobbers) = op_collector.finish();
-            self.vcode.operand_ranges.push(ops);
+            self.vcode.operand_ranges.push_end(ops);
 
             if clobbers != PRegSet::default() {
                 self.vcode.clobbers.insert(InsnIndex::new(i), clobbers);
@@ -564,8 +516,7 @@ impl<I: VCodeInst> VCodeBuilder<I> {
                 // instructions.
                 assert!(
                     src.is_virtual(),
-                    "the real register {:?} was used as the source of a move instruction",
-                    src
+                    "the real register {src:?} was used as the source of a move instruction"
                 );
                 assert!(
                     dst.to_reg().is_virtual(),
@@ -577,44 +528,67 @@ impl<I: VCodeInst> VCodeBuilder<I> {
 
         // Translate blockparam args via the vreg aliases table as well.
         for arg in &mut self.vcode.branch_block_args {
-            let new_arg = Self::resolve_vreg_alias_impl(&self.vcode.vreg_aliases, *arg);
+            let new_arg = vregs.resolve_vreg_alias(*arg);
             trace!("operandcollector: block arg {:?} -> {:?}", arg, new_arg);
             *arg = new_arg;
         }
     }
 
     /// Build the final VCode.
-    pub fn build(mut self, vregs: VRegAllocator<I>) -> VCode<I> {
-        self.vcode.vreg_types = vregs.vreg_types;
-        self.vcode.reftyped_vregs = vregs.reftyped_vregs;
+    pub fn build(mut self, mut vregs: VRegAllocator<I>) -> VCode<I> {
+        self.vcode.vreg_types = take(&mut vregs.vreg_types);
+        self.vcode.facts = take(&mut vregs.facts);
 
         if self.direction == VCodeBuildDirection::Backward {
-            self.reverse_and_finalize();
+            self.reverse_and_finalize(&vregs);
         }
-        self.collect_operands();
-
-        // Apply register aliases to the `reftyped_vregs` list since this list
-        // will be returned directly to `regalloc2` eventually and all
-        // operands/results of instructions will use the alias-resolved vregs
-        // from `regalloc2`'s perspective.
-        //
-        // Also note that `reftyped_vregs` can't have duplicates, so after the
-        // aliases are applied duplicates are removed.
-        for reg in self.vcode.reftyped_vregs.iter_mut() {
-            *reg = Self::resolve_vreg_alias_impl(&self.vcode.vreg_aliases, *reg);
-        }
-        self.vcode.reftyped_vregs.sort();
-        self.vcode.reftyped_vregs.dedup();
+        self.collect_operands(&vregs);
 
         self.compute_preds_from_succs();
         self.vcode.debug_value_labels.sort_unstable();
+
+        // At this point, nothing in the vcode should mention any
+        // VReg which has been aliased. All the appropriate rewriting
+        // should have happened above. Just to be sure, let's
+        // double-check each field which has vregs.
+        // Note: can't easily check vcode.insts, resolved in collect_operands.
+        // Operands are resolved in collect_operands.
+        vregs.debug_assert_no_vreg_aliases(self.vcode.operands.iter().map(|op| op.vreg()));
+        // Currently block params are never aliased to another vreg.
+        vregs.debug_assert_no_vreg_aliases(self.vcode.block_params.iter().copied());
+        // Branch block args are resolved in collect_operands.
+        vregs.debug_assert_no_vreg_aliases(self.vcode.branch_block_args.iter().copied());
+        // Debug value labels are resolved in reverse_and_finalize.
+        vregs.debug_assert_no_vreg_aliases(
+            self.vcode.debug_value_labels.iter().map(|&(vreg, ..)| vreg),
+        );
+        // Facts are resolved eagerly during set_vreg_alias.
+        vregs.debug_assert_no_vreg_aliases(
+            self.vcode
+                .facts
+                .iter()
+                .zip(&vregs.vreg_types)
+                .enumerate()
+                .filter(|(_, (fact, _))| fact.is_some())
+                .map(|(vreg, (_, &ty))| {
+                    let (regclasses, _) = I::rc_for_type(ty).unwrap();
+                    VReg::new(vreg, regclasses[0])
+                }),
+        );
+
         self.vcode
     }
-}
 
-/// Is this type a reference type?
-fn is_reftype(ty: Type) -> bool {
-    ty == types::R64 || ty == types::R32
+    /// Add a user stack map for the associated instruction.
+    pub fn add_user_stack_map(
+        &mut self,
+        inst: BackwardsInsnIndex,
+        entries: &[ir::UserStackMapEntry],
+    ) {
+        let stack_map = ir::UserStackMap::new(entries, self.vcode.abi.sized_stackslot_offsets());
+        let old_entry = self.vcode.user_stack_maps.insert(inst, stack_map);
+        debug_assert!(old_entry.is_none());
+    }
 }
 
 const NO_INST_OFFSET: CodeOffset = u32::MAX;
@@ -627,33 +601,34 @@ impl<I: VCodeInst> VCode<I> {
         emit_info: I::Info,
         block_order: BlockLoweringOrder,
         constants: VCodeConstants,
-    ) -> VCode<I> {
+    ) -> Self {
         let n_blocks = block_order.lowered_order().len();
         VCode {
             sigs,
             vreg_types: vec![],
             insts: Vec::with_capacity(10 * n_blocks),
+            user_stack_maps: FxHashMap::default(),
             operands: Vec::with_capacity(30 * n_blocks),
-            operand_ranges: Vec::with_capacity(10 * n_blocks),
+            operand_ranges: Ranges::with_capacity(10 * n_blocks),
             clobbers: FxHashMap::default(),
             srclocs: Vec::with_capacity(10 * n_blocks),
             entry: BlockIndex::new(0),
-            block_ranges: Vec::with_capacity(n_blocks),
-            block_succ_range: Vec::with_capacity(n_blocks),
-            block_succs_preds: Vec::with_capacity(2 * n_blocks),
-            block_pred_range: Vec::with_capacity(n_blocks),
-            block_params_range: Vec::with_capacity(n_blocks),
+            block_ranges: Ranges::with_capacity(n_blocks),
+            block_succ_range: Ranges::with_capacity(n_blocks),
+            block_succs: Vec::with_capacity(n_blocks),
+            block_pred_range: Ranges::default(),
+            block_preds: Vec::new(),
+            block_params_range: Ranges::with_capacity(n_blocks),
             block_params: Vec::with_capacity(5 * n_blocks),
             branch_block_args: Vec::with_capacity(10 * n_blocks),
-            branch_block_arg_range: Vec::with_capacity(2 * n_blocks),
-            branch_block_arg_succ_range: Vec::with_capacity(n_blocks),
+            branch_block_arg_range: Ranges::with_capacity(2 * n_blocks),
+            branch_block_arg_succ_range: Ranges::with_capacity(n_blocks),
             block_order,
             abi,
             emit_info,
-            reftyped_vregs: vec![],
             constants,
             debug_value_labels: vec![],
-            vreg_aliases: FxHashMap::with_capacity_and_hasher(10 * n_blocks, Default::default()),
+            facts: vec![],
         }
     }
 
@@ -673,29 +648,17 @@ impl<I: VCodeInst> VCode<I> {
         self.insts.len()
     }
 
-    /// Get the successors for a block.
-    pub fn succs(&self, block: BlockIndex) -> &[BlockIndex] {
-        let (start, end) = self.block_succ_range[block.index()];
-        &self.block_succs_preds[start as usize..end as usize]
-    }
-
     fn compute_clobbers(&self, regalloc: &regalloc2::Output) -> Vec<Writable<RealReg>> {
-        // Compute clobbered registers.
-        let mut clobbered = vec![];
-        let mut clobbered_set = FxHashSet::default();
+        let mut clobbered = PRegSet::default();
 
         // All moves are included in clobbers.
-        for edit in &regalloc.edits {
-            let Edit::Move { to, .. } = edit.1;
+        for (_, Edit::Move { to, .. }) in &regalloc.edits {
             if let Some(preg) = to.as_reg() {
-                let reg = RealReg::from(preg);
-                if clobbered_set.insert(reg) {
-                    clobbered.push(Writable::from_reg(reg));
-                }
+                clobbered.add(preg);
             }
         }
 
-        for (i, (start, end)) in self.operand_ranges.iter().enumerate() {
+        for (i, range) in self.operand_ranges.iter() {
             // Skip this instruction if not "included in clobbers" as
             // per the MachInst. (Some backends use this to implement
             // ABI specifics; e.g., excluding calls of the same ABI as
@@ -706,38 +669,26 @@ impl<I: VCodeInst> VCode<I> {
                 continue;
             }
 
-            let start = *start as usize;
-            let end = *end as usize;
-            let operands = &self.operands[start..end];
-            let allocs = &regalloc.allocs[start..end];
+            let operands = &self.operands[range.clone()];
+            let allocs = &regalloc.allocs[range];
             for (operand, alloc) in operands.iter().zip(allocs.iter()) {
-                // We're interested only in writes (Mods or Defs).
-                if operand.kind() == OperandKind::Use {
-                    continue;
-                }
-                if let Some(preg) = alloc.as_reg() {
-                    let reg = RealReg::from(preg);
-                    if clobbered_set.insert(reg) {
-                        clobbered.push(Writable::from_reg(reg));
+                if operand.kind() == OperandKind::Def {
+                    if let Some(preg) = alloc.as_reg() {
+                        clobbered.add(preg);
                     }
                 }
             }
 
             // Also add explicitly-clobbered registers.
-            for preg in self
-                .clobbers
-                .get(&InsnIndex::new(i))
-                .cloned()
-                .unwrap_or_default()
-            {
-                let reg = RealReg::from(preg);
-                if clobbered_set.insert(reg) {
-                    clobbered.push(Writable::from_reg(reg));
-                }
+            if let Some(&inst_clobbered) = self.clobbers.get(&InsnIndex::new(i)) {
+                clobbered.union_from(inst_clobbered);
             }
         }
 
         clobbered
+            .into_iter()
+            .map(|preg| Writable::from_reg(RealReg::from(preg)))
+            .collect()
     }
 
     /// Emit the instructions to a `MachBuffer`, containing fixed-up
@@ -794,9 +745,8 @@ impl<I: VCodeInst> VCode<I> {
         // setting clobbers is fairly minimal so this should be
         // relatively cheap.
         let clobbers = self.compute_clobbers(regalloc);
-        self.abi.set_num_spillslots(regalloc.num_spillslots);
-        self.abi.set_clobbered(clobbers);
-        self.abi.compute_frame_layout(&self.sigs);
+        self.abi
+            .compute_frame_layout(&self.sigs, regalloc.num_spillslots, clobbers);
 
         // Emit blocks.
         let mut cur_srcloc = None;
@@ -817,7 +767,7 @@ impl<I: VCodeInst> VCode<I> {
         let mut ra_edits_per_block: SmallVec<[u32; 64]> = smallvec![];
         let mut edit_idx = 0;
         for block in 0..self.num_blocks() {
-            let end_inst = self.block_ranges[block].1;
+            let end_inst = InsnIndex::new(self.block_ranges.get(block).end);
             let start_edit_idx = edit_idx;
             while edit_idx < regalloc.edits.len() && regalloc.edits[edit_idx].0.inst() < end_inst {
                 edit_idx += 1;
@@ -844,29 +794,27 @@ impl<I: VCodeInst> VCode<I> {
             while new_offset > buffer.cur_offset() {
                 // Pad with NOPs up to the aligned block offset.
                 let nop = I::gen_nop((new_offset - buffer.cur_offset()) as usize);
-                nop.emit(&[], &mut buffer, &self.emit_info, &mut Default::default());
+                nop.emit(&mut buffer, &self.emit_info, &mut Default::default());
             }
             assert_eq!(buffer.cur_offset(), new_offset);
 
             let do_emit = |inst: &I,
-                           allocs: &[Allocation],
                            disasm: &mut String,
                            buffer: &mut MachBuffer<I>,
                            state: &mut I::State| {
                 if want_disasm && !inst.is_args() {
                     let mut s = state.clone();
-                    writeln!(disasm, "  {}", inst.pretty_print_inst(allocs, &mut s)).unwrap();
+                    writeln!(disasm, "  {}", inst.pretty_print_inst(&mut s)).unwrap();
                 }
-                inst.emit(allocs, buffer, &self.emit_info, state);
+                inst.emit(buffer, &self.emit_info, state);
             };
 
             // Is this the first block? Emit the prologue directly if so.
             if block == self.entry {
                 trace!(" -> entry block");
                 buffer.start_srcloc(Default::default());
-                state.pre_sourceloc(Default::default());
                 for inst in &self.abi.gen_prologue() {
-                    do_emit(&inst, &[], &mut disasm, &mut buffer, &mut state);
+                    do_emit(&inst, &mut disasm, &mut buffer, &mut state);
                 }
                 buffer.end_srcloc();
             }
@@ -899,7 +847,7 @@ impl<I: VCodeInst> VCode<I> {
                 self.block_order.is_indirect_branch_target(block),
                 is_forward_edge_cfi_enabled,
             ) {
-                do_emit(&block_start, &[], &mut disasm, &mut buffer, &mut state);
+                do_emit(&block_start, &mut disasm, &mut buffer, &mut state);
             }
 
             for inst_or_edit in regalloc.block_insts_and_edits(&self, block) {
@@ -932,11 +880,10 @@ impl<I: VCodeInst> VCode<I> {
                             buffer.start_srcloc(srcloc);
                             cur_srcloc = Some(srcloc);
                         }
-                        state.pre_sourceloc(cur_srcloc.unwrap_or_default());
 
                         // If this is a safepoint, compute a stack map
                         // and pass it to the emit state.
-                        if self.insts[iix.index()].is_safepoint() {
+                        let stack_map_disasm = if self.insts[iix.index()].is_safepoint() {
                             let mut safepoint_slots: SmallVec<[SpillSlot; 8]> = smallvec![];
                             // Find the contiguous range of
                             // (progpoint, allocation) safepoint slot
@@ -960,16 +907,27 @@ impl<I: VCodeInst> VCode<I> {
                                 let slot = alloc.as_stack().unwrap();
                                 safepoint_slots.push(slot);
                             }
-                            if !safepoint_slots.is_empty() {
-                                let stack_map = self
-                                    .abi
-                                    .spillslots_to_stack_map(&safepoint_slots[..], &state);
-                                state.pre_safepoint(stack_map);
-                            }
-                        }
 
-                        // Get the allocations for this inst from the regalloc result.
-                        let allocs = regalloc.inst_allocs(iix);
+                            let (user_stack_map, user_stack_map_disasm) = {
+                                // The `user_stack_maps` is keyed by reverse
+                                // instruction index, so we must flip the
+                                // index. We can't put this into a helper method
+                                // due to borrowck issues because parts of
+                                // `self` are borrowed mutably elsewhere in this
+                                // function.
+                                let index = iix.to_backwards_insn_index(self.num_insts());
+                                let user_stack_map = self.user_stack_maps.remove(&index);
+                                let user_stack_map_disasm =
+                                    user_stack_map.as_ref().map(|m| format!("  ; {m:?}"));
+                                (user_stack_map, user_stack_map_disasm)
+                            };
+
+                            state.pre_safepoint(user_stack_map);
+
+                            user_stack_map_disasm
+                        } else {
+                            None
+                        };
 
                         // If the instruction we are about to emit is
                         // a return, place an epilogue at this point
@@ -977,17 +935,40 @@ impl<I: VCodeInst> VCode<I> {
                         // epilogue will contain it).
                         if self.insts[iix.index()].is_term() == MachTerminator::Ret {
                             for inst in self.abi.gen_epilogue() {
-                                do_emit(&inst, &[], &mut disasm, &mut buffer, &mut state);
+                                do_emit(&inst, &mut disasm, &mut buffer, &mut state);
                             }
                         } else {
+                            // Update the operands for this inst using the
+                            // allocations from the regalloc result.
+                            let mut allocs = regalloc.inst_allocs(iix).iter();
+                            self.insts[iix.index()].get_operands(
+                                &mut |reg: &mut Reg, constraint, _kind, _pos| {
+                                    let alloc = allocs
+                                        .next()
+                                        .expect("enough allocations for all operands")
+                                        .as_reg()
+                                        .expect("only register allocations, not stack allocations")
+                                        .into();
+
+                                    if let OperandConstraint::FixedReg(rreg) = constraint {
+                                        debug_assert_eq!(Reg::from(rreg), alloc);
+                                    }
+                                    *reg = alloc;
+                                },
+                            );
+                            debug_assert!(allocs.next().is_none());
+
                             // Emit the instruction!
                             do_emit(
                                 &self.insts[iix.index()],
-                                allocs,
                                 &mut disasm,
                                 &mut buffer,
                                 &mut state,
                             );
+                            if let Some(stack_map_disasm) = stack_map_disasm {
+                                disasm.push_str(&stack_map_disasm);
+                                disasm.push('\n');
+                            }
                         }
                     }
 
@@ -1002,21 +983,21 @@ impl<I: VCodeInst> VCode<I> {
                                 debug_assert_eq!(from.class(), to.class());
                                 let ty = I::canonical_type_for_rc(from.class());
                                 let mv = I::gen_move(to_rreg, from_rreg, ty);
-                                do_emit(&mv, &[], &mut disasm, &mut buffer, &mut state);
+                                do_emit(&mv, &mut disasm, &mut buffer, &mut state);
                             }
                             (Some(from), None) => {
                                 // Spill from register to spillslot.
                                 let to = to.as_stack().unwrap();
                                 let from_rreg = RealReg::from(from);
                                 let spill = self.abi.gen_spill(to, from_rreg);
-                                do_emit(&spill, &[], &mut disasm, &mut buffer, &mut state);
+                                do_emit(&spill, &mut disasm, &mut buffer, &mut state);
                             }
                             (None, Some(to)) => {
                                 // Load from spillslot to register.
                                 let from = from.as_stack().unwrap();
                                 let to_rreg = Writable::from_reg(RealReg::from(to));
                                 let reload = self.abi.gen_reload(to_rreg, from);
-                                do_emit(&reload, &[], &mut disasm, &mut buffer, &mut state);
+                                do_emit(&reload, &mut disasm, &mut buffer, &mut state);
                             }
                             (None, None) => {
                                 panic!("regalloc2 should have eliminated stack-to-stack moves!");
@@ -1036,9 +1017,8 @@ impl<I: VCodeInst> VCode<I> {
             // `MachBuffer` to determine if an island is necessary.
             let worst_case_next_bb = if block_order_idx < final_order.len() - 1 {
                 let next_block = final_order[block_order_idx + 1];
-                let next_block_range = self.block_ranges[next_block.index()];
-                let next_block_size =
-                    (next_block_range.1.index() - next_block_range.0.index()) as u32;
+                let next_block_range = self.block_ranges.get(next_block.index());
+                let next_block_size = next_block_range.len() as u32;
                 let next_block_ra_insertions = ra_edits_per_block[next_block.index()];
                 I::worst_case_size() * (next_block_size + next_block_ra_insertions)
             } else {
@@ -1071,6 +1051,12 @@ impl<I: VCodeInst> VCode<I> {
             }
         }
 
+        debug_assert!(
+            self.user_stack_maps.is_empty(),
+            "any stack maps should have been consumed by instruction emission, still have: {:#?}",
+            self.user_stack_maps,
+        );
+
         // Do any optimizations on branches at tail of buffer, as if we had
         // bound one last label.
         buffer.optimize_branches(ctrl_plane);
@@ -1194,12 +1180,14 @@ impl<I: VCodeInst> VCode<I> {
                 LabelValueLoc::Reg(Reg::from(preg))
             } else {
                 let slot = alloc.as_stack().unwrap();
-                let sp_offset = self.abi.get_spillslot_offset(slot);
-                let sp_to_caller_sp_offset = self.abi.nominal_sp_to_caller_sp_offset();
+                let slot_offset = self.abi.get_spillslot_offset(slot);
+                let slot_base_to_caller_sp_offset = self.abi.slot_base_to_caller_sp_offset();
                 let caller_sp_to_cfa_offset =
                     crate::isa::unwind::systemv::caller_sp_to_cfa_offset();
-                let cfa_to_sp_offset = -((sp_to_caller_sp_offset + caller_sp_to_cfa_offset) as i64);
-                LabelValueLoc::CFAOffset(cfa_to_sp_offset + sp_offset)
+                // NOTE: this is a negative offset because it's relative to the caller's SP
+                let cfa_to_sp_offset =
+                    -((slot_base_to_caller_sp_offset + caller_sp_to_cfa_offset) as i64);
+                LabelValueLoc::CFAOffset(cfa_to_sp_offset + slot_offset)
             };
 
             // ValueLocRanges are recorded by *instruction-end
@@ -1255,27 +1243,42 @@ impl<I: VCodeInst> VCode<I> {
         self.block_order.lowered_order()[block.index()].orig_block()
     }
 
-    #[inline]
-    fn assert_no_vreg_aliases<'a>(&self, list: &'a [VReg]) -> &'a [VReg] {
-        for vreg in list {
-            self.assert_not_vreg_alias(*vreg);
-        }
-        list
+    /// Get the type of a VReg.
+    pub fn vreg_type(&self, vreg: VReg) -> Type {
+        self.vreg_types[vreg.vreg()]
     }
 
-    #[inline]
-    fn assert_not_vreg_alias(&self, vreg: VReg) -> VReg {
-        debug_assert!(VCodeBuilder::<I>::resolve_vreg_alias_impl(&self.vreg_aliases, vreg) == vreg);
-        vreg
+    /// Get the fact, if any, for a given VReg.
+    pub fn vreg_fact(&self, vreg: VReg) -> Option<&Fact> {
+        self.facts[vreg.vreg()].as_ref()
     }
 
-    #[inline]
-    fn assert_operand_not_vreg_alias(&self, op: Operand) -> Operand {
-        // It should be true by construction that `Operand`s do not contain any
-        // aliased vregs since they're all collected and mapped when the VCode
-        // is itself constructed.
-        self.assert_not_vreg_alias(op.vreg());
-        op
+    /// Set the fact for a given VReg.
+    pub fn set_vreg_fact(&mut self, vreg: VReg, fact: Fact) {
+        trace!("set fact on {}: {:?}", vreg, fact);
+        self.facts[vreg.vreg()] = Some(fact);
+    }
+
+    /// Does a given instruction define any facts?
+    pub fn inst_defines_facts(&self, inst: InsnIndex) -> bool {
+        self.inst_operands(inst)
+            .iter()
+            .filter(|o| o.kind() == OperandKind::Def)
+            .map(|o| o.vreg())
+            .any(|vreg| self.facts[vreg.vreg()].is_some())
+    }
+
+    /// Get the user stack map associated with the given forward instruction index.
+    pub fn get_user_stack_map(&self, inst: InsnIndex) -> Option<&ir::UserStackMap> {
+        let index = inst.to_backwards_insn_index(self.num_insts());
+        self.user_stack_maps.get(&index)
+    }
+}
+
+impl<I: VCodeInst> std::ops::Index<InsnIndex> for VCode<I> {
+    type Output = I;
+    fn index(&self, idx: InsnIndex) -> &Self::Output {
+        &self.insts[idx.index()]
     }
 }
 
@@ -1293,18 +1296,18 @@ impl<I: VCodeInst> RegallocFunction for VCode<I> {
     }
 
     fn block_insns(&self, block: BlockIndex) -> InstRange {
-        let (start, end) = self.block_ranges[block.index()];
-        InstRange::forward(start, end)
+        let range = self.block_ranges.get(block.index());
+        InstRange::new(InsnIndex::new(range.start), InsnIndex::new(range.end))
     }
 
     fn block_succs(&self, block: BlockIndex) -> &[BlockIndex] {
-        let (start, end) = self.block_succ_range[block.index()];
-        &self.block_succs_preds[start as usize..end as usize]
+        let range = self.block_succ_range.get(block.index());
+        &self.block_succs[range]
     }
 
     fn block_preds(&self, block: BlockIndex) -> &[BlockIndex] {
-        let (start, end) = self.block_pred_range[block.index()];
-        &self.block_succs_preds[start as usize..end as usize]
+        let range = self.block_pred_range.get(block.index());
+        &self.block_preds[range]
     }
 
     fn block_params(&self, block: BlockIndex) -> &[VReg] {
@@ -1314,21 +1317,15 @@ impl<I: VCodeInst> RegallocFunction for VCode<I> {
             return &[];
         }
 
-        let (start, end) = self.block_params_range[block.index()];
-        let ret = &self.block_params[start as usize..end as usize];
-        // Currently block params are never aliased to another vreg, but
-        // double-check just to be sure.
-        self.assert_no_vreg_aliases(ret)
+        let range = self.block_params_range.get(block.index());
+        &self.block_params[range]
     }
 
     fn branch_blockparams(&self, block: BlockIndex, _insn: InsnIndex, succ_idx: usize) -> &[VReg] {
-        let (succ_range_start, succ_range_end) = self.branch_block_arg_succ_range[block.index()];
-        let succ_ranges =
-            &self.branch_block_arg_range[succ_range_start as usize..succ_range_end as usize];
-        let (branch_block_args_start, branch_block_args_end) = succ_ranges[succ_idx];
-        let ret = &self.branch_block_args
-            [branch_block_args_start as usize..branch_block_args_end as usize];
-        self.assert_no_vreg_aliases(ret)
+        let succ_range = self.branch_block_arg_succ_range.get(block.index());
+        debug_assert!(succ_idx < succ_range.len());
+        let branch_block_args = self.branch_block_arg_range.get(succ_range.start + succ_idx);
+        &self.branch_block_args[branch_block_args]
     }
 
     fn is_ret(&self, insn: InsnIndex) -> bool {
@@ -1347,17 +1344,13 @@ impl<I: VCodeInst> RegallocFunction for VCode<I> {
         }
     }
 
-    fn requires_refs_on_stack(&self, insn: InsnIndex) -> bool {
-        self.insts[insn.index()].is_safepoint()
+    fn requires_refs_on_stack(&self, _insn: InsnIndex) -> bool {
+        false
     }
 
     fn inst_operands(&self, insn: InsnIndex) -> &[Operand] {
-        let (start, end) = self.operand_ranges[insn.index()];
-        let ret = &self.operands[start as usize..end as usize];
-        for op in ret {
-            self.assert_operand_not_vreg_alias(*op);
-        }
-        ret
+        let range = self.operand_ranges.get(insn.index());
+        &self.operands[range]
     }
 
     fn inst_clobbers(&self, insn: InsnIndex) -> PRegSet {
@@ -1365,21 +1358,11 @@ impl<I: VCodeInst> RegallocFunction for VCode<I> {
     }
 
     fn num_vregs(&self) -> usize {
-        std::cmp::max(self.vreg_types.len(), first_user_vreg_index())
-    }
-
-    fn reftype_vregs(&self) -> &[VReg] {
-        self.assert_no_vreg_aliases(&self.reftyped_vregs[..])
+        self.vreg_types.len()
     }
 
     fn debug_value_labels(&self) -> &[(VReg, InsnIndex, InsnIndex, u32)] {
-        // VRegs here are inserted into `debug_value_labels` after code is
-        // generated and aliases are fully defined, so no double-check that
-        // aliases are not lingering.
-        for (vreg, ..) in self.debug_value_labels.iter() {
-            self.assert_not_vreg_alias(*vreg);
-        }
-        &self.debug_value_labels[..]
+        &self.debug_value_labels
     }
 
     fn spillslot_size(&self, regclass: RegClass) -> usize {
@@ -1394,12 +1377,9 @@ impl<I: VCodeInst> RegallocFunction for VCode<I> {
     }
 }
 
-impl<I: VCodeInst> fmt::Debug for VCode<I> {
+impl<I: VCodeInst> Debug for VRegAllocator<I> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln!(f, "VCode {{")?;
-        writeln!(f, "  Entry block: {}", self.entry.index())?;
-
-        let mut state = Default::default();
+        writeln!(f, "VRegAllocator {{")?;
 
         let mut alias_keys = self.vreg_aliases.keys().cloned().collect::<Vec<_>>();
         alias_keys.sort_unstable();
@@ -1408,29 +1388,61 @@ impl<I: VCodeInst> fmt::Debug for VCode<I> {
             writeln!(f, "  {:?} := {:?}", Reg::from(key), Reg::from(*dest))?;
         }
 
+        for (vreg, fact) in self.facts.iter().enumerate() {
+            if let Some(fact) = fact {
+                writeln!(f, "  v{vreg} ! {fact}")?;
+            }
+        }
+
+        writeln!(f, "}}")
+    }
+}
+
+impl<I: VCodeInst> fmt::Debug for VCode<I> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        writeln!(f, "VCode {{")?;
+        writeln!(f, "  Entry block: {}", self.entry.index())?;
+
+        let mut state = Default::default();
+
         for block in 0..self.num_blocks() {
             let block = BlockIndex::new(block);
-            writeln!(f, "Block {}:", block.index())?;
-            if let Some(bb) = self.bindex_to_bb(block) {
-                writeln!(f, "    (original IR block: {})", bb)?;
-            }
-            for succ in self.succs(block) {
-                writeln!(f, "    (successor: Block {})", succ.index())?;
-            }
-            let (start, end) = self.block_ranges[block.index()];
             writeln!(
                 f,
-                "    (instruction range: {} .. {})",
-                start.index(),
-                end.index()
+                "Block {}({:?}):",
+                block.index(),
+                self.block_params(block)
             )?;
-            for inst in start.index()..end.index() {
+            if let Some(bb) = self.bindex_to_bb(block) {
+                writeln!(f, "    (original IR block: {bb})")?;
+            }
+            for (succ_idx, succ) in self.block_succs(block).iter().enumerate() {
+                writeln!(
+                    f,
+                    "    (successor: Block {}({:?}))",
+                    succ.index(),
+                    self.branch_blockparams(block, InsnIndex::new(0) /* dummy */, succ_idx)
+                )?;
+            }
+            for inst in self.block_ranges.get(block.index()) {
                 writeln!(
                     f,
                     "  Inst {}: {}",
                     inst,
-                    self.insts[inst].pretty_print_inst(&[], &mut state)
+                    self.insts[inst].pretty_print_inst(&mut state)
                 )?;
+                if !self.operands.is_empty() {
+                    for operand in self.inst_operands(InsnIndex::new(inst)) {
+                        if operand.kind() == OperandKind::Def {
+                            if let Some(fact) = &self.facts[operand.vreg().vreg()] {
+                                writeln!(f, "    v{} ! {}", operand.vreg().vreg(), fact)?;
+                            }
+                        }
+                    }
+                }
+                if let Some(user_stack_map) = self.get_user_stack_map(InsnIndex::new(inst)) {
+                    writeln!(f, "    {user_stack_map:?}")?;
+                }
             }
         }
 
@@ -1441,20 +1453,16 @@ impl<I: VCodeInst> fmt::Debug for VCode<I> {
 
 /// This structure manages VReg allocation during the lifetime of the VCodeBuilder.
 pub struct VRegAllocator<I> {
-    /// Next virtual register number to allocate.
-    next_vreg: usize,
-
     /// VReg IR-level types.
     vreg_types: Vec<Type>,
 
-    /// A set with the same contents as `reftyped_vregs`, in order to
-    /// avoid inserting more than once.
-    reftyped_vregs_set: FxHashSet<VReg>,
-
-    /// Reference-typed `regalloc2::VReg`s. The regalloc requires
-    /// these in a dense slice (as opposed to querying the
-    /// reftype-status of each vreg) for efficient iteration.
-    reftyped_vregs: Vec<VReg>,
+    /// VReg aliases. When the final VCode is built we rewrite all
+    /// uses of the keys in this table to their replacement values.
+    ///
+    /// We use these aliases to rename an instruction's expected
+    /// result vregs to the returned vregs from lowering, which are
+    /// usually freshly-allocated temps.
+    vreg_aliases: FxHashMap<regalloc2::VReg, regalloc2::VReg>,
 
     /// A deferred error, to be bubbled up to the top level of the
     /// lowering algorithm. We take this approach because we cannot
@@ -1462,19 +1470,24 @@ pub struct VRegAllocator<I> {
     /// lowering rules) or some ABI code.
     deferred_error: Option<CodegenError>,
 
+    /// Facts on VRegs, for proof-carrying code.
+    facts: Vec<Option<Fact>>,
+
     /// The type of instruction that this allocator makes registers for.
     _inst: core::marker::PhantomData<I>,
 }
 
 impl<I: VCodeInst> VRegAllocator<I> {
     /// Make a new VRegAllocator.
-    pub fn new() -> Self {
+    pub fn with_capacity(capacity: usize) -> Self {
+        let capacity = first_user_vreg_index() + capacity;
+        let mut vreg_types = Vec::with_capacity(capacity);
+        vreg_types.resize(first_user_vreg_index(), types::INVALID);
         Self {
-            next_vreg: first_user_vreg_index(),
-            vreg_types: vec![],
-            reftyped_vregs_set: FxHashSet::default(),
-            reftyped_vregs: vec![],
+            vreg_types,
+            vreg_aliases: FxHashMap::with_capacity_and_hasher(capacity, Default::default()),
             deferred_error: None,
+            facts: Vec::with_capacity(capacity),
             _inst: core::marker::PhantomData::default(),
         }
     }
@@ -1484,10 +1497,9 @@ impl<I: VCodeInst> VRegAllocator<I> {
         if self.deferred_error.is_some() {
             return Err(CodegenError::CodeTooLarge);
         }
-        let v = self.next_vreg;
+        let v = self.vreg_types.len();
         let (regclasses, tys) = I::rc_for_type(ty)?;
-        self.next_vreg += regclasses.len();
-        if self.next_vreg >= VReg::MAX {
+        if v + regclasses.len() >= VReg::MAX {
             return Err(CodegenError::CodeTooLarge);
         }
 
@@ -1500,8 +1512,14 @@ impl<I: VCodeInst> VRegAllocator<I> {
             _ => panic!("Value must reside in 1 or 2 registers"),
         };
         for (&reg_ty, &reg) in tys.iter().zip(regs.regs().iter()) {
-            self.set_vreg_type(reg.to_virtual_reg().unwrap(), reg_ty);
+            let vreg = reg.to_virtual_reg().unwrap();
+            debug_assert_eq!(self.vreg_types.len(), vreg.index());
+            self.vreg_types.push(reg_ty);
         }
+
+        // Create empty facts for each allocated vreg.
+        self.facts.resize(self.vreg_types.len(), None);
+
         Ok(regs)
     }
 
@@ -1537,18 +1555,79 @@ impl<I: VCodeInst> VRegAllocator<I> {
         }
     }
 
-    /// Set the type of this virtual register.
-    pub fn set_vreg_type(&mut self, vreg: VirtualReg, ty: Type) {
-        if self.vreg_types.len() <= vreg.index() {
-            self.vreg_types.resize(vreg.index() + 1, ir::types::INVALID);
+    /// Rewrite any mention of `from` into `to`.
+    pub fn set_vreg_alias(&mut self, from: Reg, to: Reg) {
+        let from = from.into();
+        let resolved_to = self.resolve_vreg_alias(to.into());
+        // Disallow cycles (see below).
+        assert_ne!(resolved_to, from);
+
+        // Maintain the invariant that PCC facts only exist on vregs
+        // which aren't aliases. We want to preserve whatever was
+        // stated about the vreg before its producer was lowered.
+        if let Some(fact) = self.facts[from.vreg()].take() {
+            self.set_fact(resolved_to, fact);
         }
-        self.vreg_types[vreg.index()] = ty;
-        if is_reftype(ty) {
-            let vreg: VReg = vreg.into();
-            if self.reftyped_vregs_set.insert(vreg) {
-                self.reftyped_vregs.push(vreg);
-            }
+
+        let old_alias = self.vreg_aliases.insert(from, resolved_to);
+        debug_assert_eq!(old_alias, None);
+    }
+
+    fn resolve_vreg_alias(&self, mut vreg: regalloc2::VReg) -> regalloc2::VReg {
+        // We prevent cycles from existing by resolving targets of
+        // aliases eagerly before setting them. If the target resolves
+        // to the origin of the alias, then a cycle would be created
+        // and the alias is disallowed. Because of the structure of
+        // SSA code (one instruction can refer to another's defs but
+        // not vice-versa, except indirectly through
+        // phis/blockparams), cycles should not occur as we use
+        // aliases to redirect vregs to the temps that actually define
+        // them.
+        while let Some(to) = self.vreg_aliases.get(&vreg) {
+            vreg = *to;
         }
+        vreg
+    }
+
+    #[inline]
+    fn debug_assert_no_vreg_aliases(&self, mut list: impl Iterator<Item = VReg>) {
+        debug_assert!(list.all(|vreg| !self.vreg_aliases.contains_key(&vreg)));
+    }
+
+    /// Set the proof-carrying code fact on a given virtual register.
+    ///
+    /// Returns the old fact, if any (only one fact can be stored).
+    fn set_fact(&mut self, vreg: regalloc2::VReg, fact: Fact) -> Option<Fact> {
+        trace!("vreg {:?} has fact: {:?}", vreg, fact);
+        debug_assert!(!self.vreg_aliases.contains_key(&vreg));
+        self.facts[vreg.vreg()].replace(fact)
+    }
+
+    /// Set a fact only if one doesn't already exist.
+    pub fn set_fact_if_missing(&mut self, vreg: VirtualReg, fact: Fact) {
+        let vreg = self.resolve_vreg_alias(vreg.into());
+        if self.facts[vreg.vreg()].is_none() {
+            self.set_fact(vreg, fact);
+        }
+    }
+
+    /// Allocate a fresh ValueRegs, with a given fact to apply if
+    /// the value fits in one VReg.
+    pub fn alloc_with_maybe_fact(
+        &mut self,
+        ty: Type,
+        fact: Option<Fact>,
+    ) -> CodegenResult<ValueRegs<Reg>> {
+        let result = self.alloc(ty)?;
+
+        // Ensure that we don't lose a fact on a value that splits
+        // into multiple VRegs.
+        assert!(result.len() == 1 || fact.is_none());
+        if let Some(fact) = fact {
+            self.set_fact(result.regs()[0].into(), fact);
+        }
+
+        Ok(result)
     }
 }
 
@@ -1556,7 +1635,7 @@ impl<I: VCodeInst> VRegAllocator<I> {
 /// [MachBuffer].
 ///
 /// First, during the lowering phase, constants are inserted using
-/// [VCodeConstants.insert]; an intermediate handle, [VCodeConstant], tracks what constants are
+/// [VCodeConstants.insert]; an intermediate handle, `VCodeConstant`, tracks what constants are
 /// used in this phase. Some deduplication is performed, when possible, as constant
 /// values are inserted.
 ///
@@ -1622,12 +1701,12 @@ impl VCodeConstants {
         self.constants.len()
     }
 
-    /// Iterate over the [VCodeConstant] keys inserted in this structure.
+    /// Iterate over the `VCodeConstant` keys inserted in this structure.
     pub fn keys(&self) -> Keys<VCodeConstant> {
         self.constants.keys()
     }
 
-    /// Iterate over the [VCodeConstant] keys and the data (as a byte slice) inserted in this
+    /// Iterate over the `VCodeConstant` keys and the data (as a byte slice) inserted in this
     /// structure.
     pub fn iter(&self) -> impl Iterator<Item = (VCodeConstant, &VCodeConstantData)> {
         self.constants.iter()
@@ -1637,6 +1716,15 @@ impl VCodeConstants {
     pub fn get(&self, c: VCodeConstant) -> &VCodeConstantData {
         &self.constants[c]
     }
+
+    /// Checks if the given [VCodeConstantData] is registered as
+    /// used by the pool.
+    pub fn pool_uses(&self, constant: &VCodeConstantData) -> bool {
+        match constant {
+            VCodeConstantData::Pool(c, _) => self.pool_uses.contains_key(c),
+            _ => false,
+        }
+    }
 }
 
 /// A use of a constant by one or more VCode instructions; see [VCodeConstants].
diff --git a/cranelift/codegen/src/nan_canonicalization.rs b/cranelift/codegen/src/nan_canonicalization.rs
index 49415a86b0d6..e6a73deaf83a 100644
--- a/cranelift/codegen/src/nan_canonicalization.rs
+++ b/cranelift/codegen/src/nan_canonicalization.rs
@@ -5,23 +5,19 @@
 use crate::cursor::{Cursor, FuncCursor};
 use crate::ir::condcodes::FloatCC;
 use crate::ir::immediates::{Ieee32, Ieee64};
-use crate::ir::types;
+use crate::ir::types::{self};
 use crate::ir::{Function, Inst, InstBuilder, InstructionData, Opcode, Value};
 use crate::opts::MemFlags;
 use crate::timing;
 
-// Canonical 32-bit and 64-bit NaN values.
-static CANON_32BIT_NAN: u32 = 0b01111111110000000000000000000000;
-static CANON_64BIT_NAN: u64 = 0b0111111111111000000000000000000000000000000000000000000000000000;
-
 /// Perform the NaN canonicalization pass.
-pub fn do_nan_canonicalization(func: &mut Function) {
+pub fn do_nan_canonicalization(func: &mut Function, has_vector_support: bool) {
     let _tt = timing::canonicalize_nans();
     let mut pos = FuncCursor::new(func);
     while let Some(_block) = pos.next_block() {
         while let Some(inst) = pos.next_inst() {
             if is_fp_arith(&mut pos, inst) {
-                add_nan_canon_seq(&mut pos, inst);
+                add_nan_canon_seq(&mut pos, inst, has_vector_support);
             }
         }
     }
@@ -38,6 +34,10 @@ fn is_fp_arith(pos: &mut FuncCursor, inst: Inst) -> bool {
                 || opcode == Opcode::Nearest
                 || opcode == Opcode::Sqrt
                 || opcode == Opcode::Trunc
+                || opcode == Opcode::Fdemote
+                || opcode == Opcode::Fpromote
+                || opcode == Opcode::FvpromoteLow
+                || opcode == Opcode::Fvdemote
         }
         InstructionData::Binary { opcode, .. } => {
             opcode == Opcode::Fadd
@@ -53,7 +53,7 @@ fn is_fp_arith(pos: &mut FuncCursor, inst: Inst) -> bool {
 }
 
 /// Append a sequence of canonicalizing instructions after the given instruction.
-fn add_nan_canon_seq(pos: &mut FuncCursor, inst: Inst) {
+fn add_nan_canon_seq(pos: &mut FuncCursor, inst: Inst, has_vector_support: bool) {
     // Select the instruction result, result type. Replace the instruction
     // result and step forward before inserting the canonicalization sequence.
     let val = pos.func.dfg.first_result(inst);
@@ -61,16 +61,28 @@ fn add_nan_canon_seq(pos: &mut FuncCursor, inst: Inst) {
     let new_res = pos.func.dfg.replace_result(val, val_type);
     let _next_inst = pos.next_inst().expect("block missing terminator!");
 
-    // Insert a comparison instruction, to check if `inst_res` is NaN. Select
-    // the canonical NaN value if `val` is NaN, assign the result to `inst`.
-    let is_nan = pos.ins().fcmp(FloatCC::NotEqual, new_res, new_res);
+    // Insert a comparison instruction, to check if `inst_res` is NaN (comparing
+    // against NaN is always unordered). Select the canonical NaN value if `val`
+    // is NaN, assign the result to `inst`.
+    let comparison = FloatCC::Unordered;
 
+    let vectorized_scalar_select = |pos: &mut FuncCursor, canon_nan: Value, ty: types::Type| {
+        let canon_nan = pos.ins().scalar_to_vector(ty, canon_nan);
+        let new_res = pos.ins().scalar_to_vector(ty, new_res);
+        let is_nan = pos.ins().fcmp(comparison, new_res, new_res);
+        let is_nan = pos.ins().bitcast(ty, MemFlags::new(), is_nan);
+        let simd_result = pos.ins().bitselect(is_nan, canon_nan, new_res);
+        pos.ins().with_result(val).extractlane(simd_result, 0);
+    };
     let scalar_select = |pos: &mut FuncCursor, canon_nan: Value| {
+        let is_nan = pos.ins().fcmp(comparison, new_res, new_res);
         pos.ins()
             .with_result(val)
             .select(is_nan, canon_nan, new_res);
     };
+
     let vector_select = |pos: &mut FuncCursor, canon_nan: Value| {
+        let is_nan = pos.ins().fcmp(comparison, new_res, new_res);
         let is_nan = pos.ins().bitcast(val_type, MemFlags::new(), is_nan);
         pos.ins()
             .with_result(val)
@@ -79,20 +91,28 @@ fn add_nan_canon_seq(pos: &mut FuncCursor, inst: Inst) {
 
     match val_type {
         types::F32 => {
-            let canon_nan = pos.ins().f32const(Ieee32::with_bits(CANON_32BIT_NAN));
-            scalar_select(pos, canon_nan);
+            let canon_nan = pos.ins().f32const(Ieee32::NAN);
+            if has_vector_support {
+                vectorized_scalar_select(pos, canon_nan, types::F32X4);
+            } else {
+                scalar_select(pos, canon_nan);
+            }
         }
         types::F64 => {
-            let canon_nan = pos.ins().f64const(Ieee64::with_bits(CANON_64BIT_NAN));
-            scalar_select(pos, canon_nan);
+            let canon_nan = pos.ins().f64const(Ieee64::NAN);
+            if has_vector_support {
+                vectorized_scalar_select(pos, canon_nan, types::F64X2);
+            } else {
+                scalar_select(pos, canon_nan);
+            }
         }
         types::F32X4 => {
-            let canon_nan = pos.ins().f32const(Ieee32::with_bits(CANON_32BIT_NAN));
+            let canon_nan = pos.ins().f32const(Ieee32::NAN);
             let canon_nan = pos.ins().splat(types::F32X4, canon_nan);
             vector_select(pos, canon_nan);
         }
         types::F64X2 => {
-            let canon_nan = pos.ins().f64const(Ieee64::with_bits(CANON_64BIT_NAN));
+            let canon_nan = pos.ins().f64const(Ieee64::NAN);
             let canon_nan = pos.ins().splat(types::F64X2, canon_nan);
             vector_select(pos, canon_nan);
         }
diff --git a/cranelift/codegen/src/opts.rs b/cranelift/codegen/src/opts.rs
index 3a78cac5c5d7..c22a0ab2e0bc 100644
--- a/cranelift/codegen/src/opts.rs
+++ b/cranelift/codegen/src/opts.rs
@@ -1,15 +1,14 @@
 //! Optimization driver using ISLE rewrite rules on an egraph.
 
 use crate::egraph::{NewOrExistingInst, OptimizeCtx};
-use crate::ir::condcodes;
 pub use crate::ir::condcodes::{FloatCC, IntCC};
 use crate::ir::dfg::ValueDef;
-pub use crate::ir::immediates::{Ieee32, Ieee64, Imm64, Offset32, Uimm32, Uimm64, Uimm8, V128Imm};
+pub use crate::ir::immediates::{Ieee128, Ieee16, Ieee32, Ieee64, Imm64, Offset32, Uimm8, V128Imm};
+use crate::ir::instructions::InstructionFormat;
 pub use crate::ir::types::*;
 pub use crate::ir::{
-    dynamic_to_fixed, AtomicRmwOp, Block, BlockCall, Constant, DataFlowGraph, DynamicStackSlot,
-    FuncRef, GlobalValue, Immediate, InstructionData, JumpTable, MemFlags, Opcode, StackSlot,
-    Table, TrapCode, Type, Value,
+    AtomicRmwOp, BlockCall, Constant, DynamicStackSlot, FuncRef, GlobalValue, Immediate,
+    InstructionData, MemFlags, Opcode, StackSlot, TrapCode, Type, Value,
 };
 use crate::isle_common_prelude_methods;
 use crate::machinst::isle::*;
@@ -24,10 +23,21 @@ pub type Range = (usize, usize);
 pub type ValueArray2 = [Value; 2];
 pub type ValueArray3 = [Value; 3];
 
-pub type ConstructorVec<T> = SmallVec<[T; 8]>;
+const MAX_ISLE_RETURNS: usize = 8;
+
+pub type ConstructorVec<T> = SmallVec<[T; MAX_ISLE_RETURNS]>;
+
+type TypeAndInstructionData = (Type, InstructionData);
+
+impl<T: smallvec::Array> generated_code::Length for SmallVec<T> {
+    #[inline]
+    fn len(&self) -> usize {
+        SmallVec::len(self)
+    }
+}
 
 pub(crate) mod generated_code;
-use generated_code::ContextIter;
+use generated_code::{ContextIter, IntoContextIter};
 
 pub(crate) struct IsleContext<'a, 'b, 'c> {
     pub(crate) ctx: &'a mut OptimizeCtx<'b, 'c>,
@@ -39,6 +49,18 @@ pub(crate) struct InstDataEtorIter<'a, 'b, 'c> {
     _phantom2: PhantomData<&'b ()>,
     _phantom3: PhantomData<&'c ()>,
 }
+
+impl Default for InstDataEtorIter<'_, '_, '_> {
+    fn default() -> Self {
+        InstDataEtorIter {
+            stack: SmallVec::default(),
+            _phantom1: PhantomData,
+            _phantom2: PhantomData,
+            _phantom3: PhantomData,
+        }
+    }
+}
+
 impl<'a, 'b, 'c> InstDataEtorIter<'a, 'b, 'c> {
     fn new(root: Value) -> Self {
         debug_assert_ne!(root, Value::reserved_value());
@@ -61,8 +83,7 @@ where
 
     fn next(&mut self, ctx: &mut IsleContext<'a, 'b, 'c>) -> Option<Self::Output> {
         while let Some(value) = self.stack.pop() {
-            debug_assert_ne!(value, Value::reserved_value());
-            let value = ctx.ctx.func.dfg.resolve_aliases(value);
+            debug_assert!(ctx.ctx.func.dfg.value_is_real(value));
             trace!("iter: value {:?}", value);
             match ctx.ctx.func.dfg.value_def(value) {
                 ValueDef::Union(x, y) => {
@@ -76,7 +97,7 @@ where
                 ValueDef::Result(inst, _) if ctx.ctx.func.dfg.inst_results(inst).len() == 1 => {
                     let ty = ctx.ctx.func.dfg.value_type(value);
                     trace!(" -> value of type {}", ty);
-                    return Some((ty, ctx.ctx.func.dfg.insts[inst].clone()));
+                    return Some((ty, ctx.ctx.func.dfg.insts[inst]));
                 }
                 _ => {}
             }
@@ -85,19 +106,97 @@ where
     }
 }
 
+impl<'a, 'b, 'c> IntoContextIter for InstDataEtorIter<'a, 'b, 'c>
+where
+    'b: 'a,
+    'c: 'b,
+{
+    type Context = IsleContext<'a, 'b, 'c>;
+    type Output = (Type, InstructionData);
+    type IntoIter = Self;
+
+    fn into_context_iter(self) -> Self {
+        self
+    }
+}
+
+#[derive(Default)]
+pub(crate) struct MaybeUnaryEtorIter<'a, 'b, 'c> {
+    opcode: Option<Opcode>,
+    inner: InstDataEtorIter<'a, 'b, 'c>,
+    fallback: Option<Value>,
+}
+
+impl MaybeUnaryEtorIter<'_, '_, '_> {
+    fn new(opcode: Opcode, value: Value) -> Self {
+        debug_assert_eq!(opcode.format(), InstructionFormat::Unary);
+        Self {
+            opcode: Some(opcode),
+            inner: InstDataEtorIter::new(value),
+            fallback: Some(value),
+        }
+    }
+}
+
+impl<'a, 'b, 'c> ContextIter for MaybeUnaryEtorIter<'a, 'b, 'c>
+where
+    'b: 'a,
+    'c: 'b,
+{
+    type Context = IsleContext<'a, 'b, 'c>;
+    type Output = (Type, Value);
+
+    fn next(&mut self, ctx: &mut IsleContext<'a, 'b, 'c>) -> Option<Self::Output> {
+        debug_assert_ne!(self.opcode, None);
+        while let Some((ty, inst_def)) = self.inner.next(ctx) {
+            let InstructionData::Unary { opcode, arg } = inst_def else {
+                continue;
+            };
+            if Some(opcode) == self.opcode {
+                self.fallback = None;
+                return Some((ty, arg));
+            }
+        }
+
+        self.fallback.take().map(|value| {
+            let ty = generated_code::Context::value_type(ctx, value);
+            (ty, value)
+        })
+    }
+}
+
+impl<'a, 'b, 'c> IntoContextIter for MaybeUnaryEtorIter<'a, 'b, 'c>
+where
+    'b: 'a,
+    'c: 'b,
+{
+    type Context = IsleContext<'a, 'b, 'c>;
+    type Output = (Type, Value);
+    type IntoIter = Self;
+
+    fn into_context_iter(self) -> Self {
+        self
+    }
+}
+
 impl<'a, 'b, 'c> generated_code::Context for IsleContext<'a, 'b, 'c> {
     isle_common_prelude_methods!();
 
-    type inst_data_etor_iter = InstDataEtorIter<'a, 'b, 'c>;
+    type inst_data_etor_returns = InstDataEtorIter<'a, 'b, 'c>;
+
+    fn inst_data_etor(&mut self, eclass: Value, returns: &mut InstDataEtorIter<'a, 'b, 'c>) {
+        *returns = InstDataEtorIter::new(eclass);
+    }
+
+    type inst_data_tupled_etor_returns = InstDataEtorIter<'a, 'b, 'c>;
 
-    fn inst_data_etor(&mut self, eclass: Value) -> InstDataEtorIter<'a, 'b, 'c> {
-        InstDataEtorIter::new(eclass)
+    fn inst_data_tupled_etor(&mut self, eclass: Value, returns: &mut InstDataEtorIter<'a, 'b, 'c>) {
+        // Literally identical to `inst_data_etor`, just a different nominal type in ISLE
+        self.inst_data_etor(eclass, returns);
     }
 
     fn make_inst_ctor(&mut self, ty: Type, op: &InstructionData) -> Value {
-        let value = self
-            .ctx
-            .insert_pure_enode(NewOrExistingInst::New(op.clone(), ty));
+        let value = self.ctx.insert_pure_enode(NewOrExistingInst::New(*op, ty));
         trace!("make_inst_ctor: {:?} -> {}", op, value);
         value
     }
@@ -115,6 +214,21 @@ impl<'a, 'b, 'c> generated_code::Context for IsleContext<'a, 'b, 'c> {
         self.ctx.func.dfg.value_type(val)
     }
 
+    fn iconst_sextend_etor(
+        &mut self,
+        (ty, inst_data): (Type, InstructionData),
+    ) -> Option<(Type, i64)> {
+        if let InstructionData::UnaryImm {
+            opcode: Opcode::Iconst,
+            imm,
+        } = inst_data
+        {
+            Some((ty, self.i64_sextend_imm64(ty, imm)))
+        } else {
+            None
+        }
+    }
+
     fn remat(&mut self, value: Value) -> Value {
         trace!("remat: {}", value);
         self.ctx.remat_values.insert(value);
@@ -135,4 +249,53 @@ impl<'a, 'b, 'c> generated_code::Context for IsleContext<'a, 'b, 'c> {
         let imm = V128Imm(val.to_le_bytes());
         self.ctx.func.dfg.constants.insert(imm.into())
     }
+
+    type sextend_maybe_etor_returns = MaybeUnaryEtorIter<'a, 'b, 'c>;
+    fn sextend_maybe_etor(&mut self, value: Value, returns: &mut Self::sextend_maybe_etor_returns) {
+        *returns = MaybeUnaryEtorIter::new(Opcode::Sextend, value);
+    }
+
+    type uextend_maybe_etor_returns = MaybeUnaryEtorIter<'a, 'b, 'c>;
+    fn uextend_maybe_etor(&mut self, value: Value, returns: &mut Self::uextend_maybe_etor_returns) {
+        *returns = MaybeUnaryEtorIter::new(Opcode::Uextend, value);
+    }
+
+    // NB: Cranelift's defined semantics for `fcvt_from_{s,u}int` match Rust's
+    // own semantics for converting an integer to a float, so these are all
+    // implemented with `as` conversions in Rust.
+    fn f32_from_uint(&mut self, n: u64) -> Ieee32 {
+        Ieee32::with_float(n as f32)
+    }
+
+    fn f64_from_uint(&mut self, n: u64) -> Ieee64 {
+        Ieee64::with_float(n as f64)
+    }
+
+    fn f32_from_sint(&mut self, n: i64) -> Ieee32 {
+        Ieee32::with_float(n as f32)
+    }
+
+    fn f64_from_sint(&mut self, n: i64) -> Ieee64 {
+        Ieee64::with_float(n as f64)
+    }
+
+    fn u64_bswap16(&mut self, n: u64) -> u64 {
+        (n as u16).swap_bytes() as u64
+    }
+
+    fn u64_bswap32(&mut self, n: u64) -> u64 {
+        (n as u32).swap_bytes() as u64
+    }
+
+    fn u64_bswap64(&mut self, n: u64) -> u64 {
+        n.swap_bytes()
+    }
+
+    fn ieee128_constant_extractor(&mut self, n: Constant) -> Option<Ieee128> {
+        self.ctx.func.dfg.constants.get(n).try_into().ok()
+    }
+
+    fn ieee128_constant(&mut self, n: Ieee128) -> Constant {
+        self.ctx.func.dfg.constants.insert(n.into())
+    }
 }
diff --git a/cranelift/codegen/src/opts/README.md b/cranelift/codegen/src/opts/README.md
index b4f46420abe0..4f586a1ad491 100644
--- a/cranelift/codegen/src/opts/README.md
+++ b/cranelift/codegen/src/opts/README.md
@@ -1,5 +1,125 @@
-Rules here are allowed to rewrite pure expressions arbitrarily,
-using the same inputs as the original, or fewer. In other words, we
-cannot pull a new eclass id out of thin air and refer to it, other
-than a piece of the input or a new node that we construct; but we
-can freely rewrite e.g. `x+y-y` to `x`.
+# Rules for Writing Optimization Rules
+
+For both correctness and compile speed, we must be careful with our rules. A lot
+of it boils down to the fact that, unlike traditional e-graphs, our rules are
+*directional*.
+
+1. Rules should not rewrite to worse code: the right-hand side should be at
+   least as good as the left-hand side or better.
+
+   For example, the rule
+
+       x => (add x 0)
+
+   is disallowed, but swapping its left- and right-hand sides produces a rule
+   that is allowed.
+
+   Any kind of canonicalizing rule that intends to help subsequent rules match
+   and unlock further optimizations (e.g. floating constants to the right side
+   for our constant-propagation rules to match) must produce canonicalized
+   output that is no worse than its noncanonical input.
+
+   We assume this invariant as a heuristic to break ties between two
+   otherwise-equal-cost expressions in various places, making up for some
+   limitations of our explicit cost function.
+
+2. Any rule that removes value-uses in its right-hand side that previously
+   existed in its left-hand side MUST use `subsume`.
+
+   For example, the rule
+
+       (select 1 x y) => x
+
+   MUST use `subsume`.
+
+   This is required for correctness because, once a value-use is removed, some
+   e-nodes in the e-class are more equal than others. There might be uses of `x`
+   in a scope where `y` is not available, and so emitting `(select 1 x y)` in
+   place of `x` in such cases would introduce uses of `y` where it is not
+   defined.
+
+   An exception to this rule is discarding constants, as they can be
+   rematerialized anywhere without introducing correctness issues. For example,
+   the (admittedly silly) rule `(select 1 x (iconst_u _)) => x` would be a good
+   candidate for not using `subsume`, as it does not discard any non-constant
+   values introduced in its LHS.
+
+3. Avoid overly general rewrites like commutativity and associativity. Instead,
+   prefer targeted instances of the rewrite (for example, canonicalizing adds
+   where one operand is a constant such that the constant is always the add's
+   second operand, rather than general commutativity for adds) or even writing
+   the "same" optimization rule multiple times.
+
+   For example, the commutativity in the first rule in the following snippet is
+   bad because it will match even when the first operand is not an add:
+
+       ;; Commute to allow `(foo (add ...) x)`, when we see it, to match.
+       (foo x y) => (foo y x)
+
+       ;; Optimize.
+       (foo x (add ...)) => (bar x)
+
+   Better is to commute only when we know that canonicalizing in this way will
+   all definitely allow the subsequent optimization rule to match:
+
+       ;; Canonicalize all adds to `foo`'s second operand.
+       (foo (add ...) x) => (foo x (add ...))
+
+       ;; Optimize.
+       (foo x (add ...)) => (bar x)
+
+   But even better in this case is to write the "same" optimization multiple
+   times:
+
+       (foo (add ...) x) => (bar x)
+       (foo x (add ...)) => (bar x)
+
+   The cost of rule-matching is amortized by the ISLE compiler, where as the
+   intermediate result of each rewrite allocates new e-nodes and requires
+   storage in the dataflow graph. Therefore, additional rules are cheaper than
+   additional e-nodes.
+
+   Commutativity and associativity in particular can cause huge amounts of
+   e-graph bloat.
+
+   One day we intend to extend ISLE with built-in support for commutativity, so
+   we don't need to author the redundant commutations ourselves:
+   https://github.com/bytecodealliance/wasmtime/issues/6128
+
+4. Be careful with (ideally avoid) multiple matches on the same `Value`, as
+   they can result in surprising multi-matching behavior. Be skeptical of
+   helpers that can inadvertently create this behavior.
+
+   In our mid-end ISLE environment, a `Value` corresponds to an eclass, with
+   multiple possible representations. A rule that matches on a `Value` will
+   traverse all enodes in the eclass, looking for a match. This is usually
+   exactly what we want: it is what allows a pattern like `(iadd (iconst k) x)`
+   to find the `iconst` amongst multiple possibilities for the argument.
+
+   However, this can also result in surprising behavior. If one has a helper
+   and a simplify rule like
+
+       (decl suitable_for_rewrite (Value) Value)
+       (rule (suitable_for_rewrite x @ (iadd ...)) x)
+       (rule (suitable_for_rewrite x @ (isub ...)) x)
+
+       (rule (simplify (ireduce _ x))
+         (if-let _ (suitable_for_rewrite x))
+         x)
+
+    Then this can result in the extremely surprising behavior that `(ireduce
+    (other_op ...))` matches, if `(other_op ...)` is in the same eclass as an
+    `iadd` or `isub`. This happens because the left-hand side binds `x`, which
+    describes the entire eclass; and `suitable_for_rewrite` matches if *any*
+    representation of `x` matches.
+
+    This resulted in a real bug in #7999. The best guidance is to keep rules
+    simple and direct: rather than attempting to abstract out helpers and
+    perform multiple, separate, matches on a `Value`, write patterns directly.
+    This has the additional benefit that the rewrites are more clearly visible
+    to the casual reader. For example:
+
+        (rule (simplify (ireduce _ (iadd ...)))
+              (iadd ...))
+        (rule (simplify (ireduce _ (isub ...)))
+              (isub ...))
diff --git a/cranelift/codegen/src/opts/arithmetic.isle b/cranelift/codegen/src/opts/arithmetic.isle
index 00c56c2409c5..4c825afb1efc 100644
--- a/cranelift/codegen/src/opts/arithmetic.isle
+++ b/cranelift/codegen/src/opts/arithmetic.isle
@@ -1,26 +1,36 @@
 ;; rewrites for integer and floating-point arithmetic
 ;; eg: `iadd`, `isub`, `ineg`, `imul`, `fadd`, `fsub`, `fmul`
 
-;; x+0 == 0+x == x.
+;; For commutative instructions, we depend on cprop.isle pushing immediates to
+;; the right, and thus only simplify patterns like `x+0`, not `0+x`.
+
+;; x+0 == x.
 (rule (simplify (iadd ty
                       x
-                      (iconst ty (u64_from_imm64 0))))
-      (subsume x))
-(rule (simplify (iadd ty
-                      (iconst ty (u64_from_imm64 0))
-                      x))
+                      (iconst_u ty 0)))
       (subsume x))
 ;; x-0 == x.
 (rule (simplify (isub ty
                       x
-                      (iconst ty (u64_from_imm64 0))))
+                      (iconst_u ty 0)))
       (subsume x))
 ;; 0-x == (ineg x).
 (rule (simplify (isub ty
-                      (iconst ty (u64_from_imm64 0))
+                      (iconst_u ty 0)
                       x))
       (ineg ty x))
 
+;; x + -y == -y + x == -(y - x) == x - y
+(rule (simplify (iadd ty x (ineg ty y)))
+      (isub ty x y))
+(rule (simplify (iadd ty (ineg ty y) x))
+      (isub ty x y))
+(rule (simplify (ineg ty (isub ty y x)))
+      (isub ty x y))
+;; x - -y == x + y
+(rule (simplify (isub ty x (ineg ty y)))
+      (iadd ty x y))
+
 ;; ineg(ineg(x)) == x.
 (rule (simplify (ineg ty (ineg ty x))) (subsume x))
 
@@ -37,72 +47,49 @@
       (subsume inner))
 
 ;; x-x == 0.
-(rule (simplify (isub (fits_in_64 (ty_int ty)) x x)) (subsume (iconst ty (imm64 0))))
+(rule (simplify (isub (ty_int ty) x x)) (subsume (iconst_u ty 0)))
 
-;; x*1 == 1*x == x.
+;; x*1 == x.
 (rule (simplify (imul ty
                       x
-                      (iconst ty (u64_from_imm64 1))))
-      (subsume x))
-(rule (simplify (imul ty
-                      (iconst ty (u64_from_imm64 1))
-                      x))
+                      (iconst_u ty 1)))
       (subsume x))
 
-;; x*0 == 0*x == 0.
+;; x*0 == 0.
 (rule (simplify (imul ty
                       _
-                      zero @ (iconst ty (u64_from_imm64 0))))
-      (subsume zero))
-(rule (simplify (imul ty
-                      zero @ (iconst ty (u64_from_imm64 0))
-                      _))
+                      zero @ (iconst_u ty 0)))
       (subsume zero))
 
-;; x*-1 == -1*x == ineg(x).
-(rule (simplify (imul ty x (iconst ty c)))
-      (if-let -1 (i64_sextend_imm64 ty c))
-      (ineg ty x))
-(rule (simplify (imul ty (iconst ty c) x))
-      (if-let -1 (i64_sextend_imm64 ty c))
+;; x*-1 == ineg(x).
+(rule (simplify (imul ty x (iconst_s ty -1)))
       (ineg ty x))
 
-;; (!x) + 1 == 1 + (!x) == !(x) - (-1) == ineg(x)
-(rule (simplify (iadd ty (bnot ty x) (iconst ty (u64_from_imm64 1))))
-      (ineg ty x))
-(rule (simplify (iadd ty (iconst ty (u64_from_imm64 1)) (bnot ty x)))
-      (ineg ty x))
-(rule (simplify (isub ty (bnot ty x) (iconst ty c)))
-      (if-let -1 (i64_sextend_imm64 ty c))
+;; (!x) + 1 == ineg(x)
+(rule (simplify (iadd ty (bnot ty x) (iconst_u ty 1)))
       (ineg ty x))
 
-;; !(x - 1) == !(x + (-1)) == !((-1) + x) == ineg(x)
-(rule (simplify (bnot ty (isub ty x (iconst ty (u64_from_imm64 1)))))
-      (ineg ty x))
-(rule (simplify (bnot ty (iadd ty x (iconst ty c))))
-      (if-let -1 (i64_sextend_imm64 ty c))
+;; !(x - 1) == !(x + (-1)) == ineg(x)
+(rule (simplify (bnot ty (isub ty x (iconst_s ty 1))))
       (ineg ty x))
-(rule (simplify (bnot ty (iadd ty (iconst ty c) x)))
-      (if-let -1 (i64_sextend_imm64 ty c))
+(rule (simplify (bnot ty (iadd ty x (iconst_s ty -1))))
       (ineg ty x))
 
 ;; x/1 == x.
 (rule (simplify (sdiv ty
                       x
-                      (iconst ty (u64_from_imm64 1))))
+                      (iconst_u ty 1)))
       (subsume x))
 (rule (simplify (udiv ty
                       x
-                      (iconst ty (u64_from_imm64 1))))
+                      (iconst_u ty 1)))
       (subsume x))
 
 ;; TODO: strength reduction: div to shifts
 ;; TODO: div/rem by constants -> magic multiplications
 
-;; x*2 == 2*x == x+x.
-(rule (simplify (imul ty x (iconst _ (simm32 2))))
-      (iadd ty x x))
-(rule (simplify (imul ty (iconst _ (simm32 2)) x))
+;; x*2 == x+x.
+(rule (simplify (imul ty x (iconst_u _ 2)))
       (iadd ty x x))
 
 ;; x*c == x<<log2(c) when c is a power of two.
@@ -126,3 +113,128 @@
 ;; both of them since they cancel out.
 (rule (simplify (fmul ty (fneg ty x) (fneg ty y)))
       (fmul ty x y))
+
+;; (a op (b op (c op d))) ==> ((a op b) op (c op d))
+;;
+;; and
+;;
+;; (((a op b) op c) op d) ==> ((a op b) op (c op d))
+;;
+;; where `op` is an associative operation: `iadd`, `imul`, `band`, or `bxor`.
+;;
+;; This increases instruction-level parallelism and shrinks live ranges. It also
+;; canonicalizes into the shallow-and-wide form for reassociating constants
+;; together for cprop.
+;;
+;; NB: We subsume to avoid exponential e-node blow up due to reassociating very
+;; large chains of operations.
+;;
+;; TODO: We should add `bor` rules for this as well. Unfortunately, they
+;; conflict with our `bswap` recognizing rules when we `subsume`.
+
+(rule (simplify (iadd ty a (iadd ty b (iadd ty c d))))
+      (subsume (iadd ty (iadd ty a b) (iadd ty c d))))
+(rule (simplify (iadd ty (iadd ty (iadd ty a b) c) d))
+      (subsume (iadd ty (iadd ty a b) (iadd ty c d))))
+
+(rule (simplify (imul ty a (imul ty b (imul ty c d))))
+      (subsume (imul ty (imul ty a b) (imul ty c d))))
+(rule (simplify (imul ty (imul ty (imul ty a b) c) d))
+      (subsume (imul ty (imul ty a b) (imul ty c d))))
+
+(rule (simplify (band ty a (band ty b (band ty c d))))
+      (subsume (band ty (band ty a b) (band ty c d))))
+(rule (simplify (band ty (band ty (band ty a b) c) d))
+      (subsume (band ty (band ty a b) (band ty c d))))
+
+(rule (simplify (bxor ty a (bxor ty b (bxor ty c d))))
+      (subsume (bxor ty (bxor ty a b) (bxor ty c d))))
+(rule (simplify (bxor ty (bxor ty (bxor ty a b) c) d))
+      (subsume (bxor ty (bxor ty a b) (bxor ty c d))))
+
+
+;; Similar rules but for associating combinations of + and -
+
+;; a -(b-(c-d)) = (a-b) + (c-d)
+(rule (simplify (isub ty a (isub ty b (isub ty c d))))
+      (subsume (iadd ty (isub ty a b) (isub ty c d))))
+
+;; a -(b-(c+d)) = (a-b) + (c+d)
+(rule (simplify (isub ty a (isub ty b (iadd ty c d))))
+      (subsume (iadd ty (isub ty a b) (iadd ty c d))))
+
+;; a -(b+(c-d)) = (a-b) - (c-d)
+(rule (simplify (isub ty a (iadd ty b (isub ty c d))))
+      (subsume (isub ty (isub ty a b) (isub ty c d))))
+
+;; a -(b+(c+d)) = (a-b) - (c+d)
+(rule (simplify (isub ty a (iadd ty b (iadd ty c d))))
+      (subsume (isub ty (isub ty a b) (iadd ty c d))))
+
+;; a +(b-(c-d)) = (a+b) - (c-d)
+(rule (simplify (iadd ty a (isub ty b (isub ty c d))))
+      (subsume (isub ty (iadd ty a b) (isub ty c d))))
+
+;; a +(b-(c+d)) = (a+b) - (c+d)
+(rule (simplify (iadd ty a (isub ty b (iadd ty c d))))
+      (subsume (isub ty (iadd ty a b) (iadd ty c d))))
+
+;; a +(b+(c-d)) = (a+b) + (c-d)
+(rule (simplify (iadd ty a (iadd ty b (isub ty c d))))
+      (subsume (iadd ty (iadd ty a b) (isub ty c d))))
+
+;; and nested the other way
+
+;; ((a-b)-c)-d = (a-b) - (c+d)
+(rule (simplify (isub ty (isub ty (isub ty a b) c) d))
+      (subsume (isub ty (isub ty a b) (iadd ty c d))))
+
+;; ((a-b)-c)+d = (a-b) - (c-d)
+(rule (simplify (iadd ty (isub ty (isub ty a b) c) d))
+      (subsume (isub ty (isub ty a b) (isub ty c d))))
+
+;; ((a-b)+c)-d = (a-b) + (c-d)
+(rule (simplify (isub ty (iadd ty (isub ty a b) c) d))
+      (subsume (iadd ty (isub ty a b) (isub ty c d))))
+
+;; ((a-b)+c)+d = (a-b) + (c+d)
+(rule (simplify (iadd ty (iadd ty (isub ty a b) c) d))
+      (subsume (iadd ty (isub ty a b) (iadd ty c d))))
+
+;; ((a+b)-c)-d = (a+b) - (c+d)
+(rule (simplify (isub ty (isub ty (iadd ty a b) c) d))
+      (subsume (isub ty (iadd ty a b) (iadd ty c d))))
+
+;; ((a+b)-c)+d = (a+b) - (c-d)
+(rule (simplify (iadd ty (isub ty (iadd ty a b) c) d))
+      (subsume (isub ty (iadd ty a b) (isub ty c d))))
+
+;; ((a+b)+c)-d = (a+b) + (c-d)
+(rule (simplify (isub ty (iadd ty (iadd ty a b) c) d))
+      (subsume (iadd ty (iadd ty a b) (isub ty c d))))
+
+;; Detect people open-coding `mulhi`: (x as big * y as big) >> bits
+;; LLVM doesn't have an intrinsic for it, so you'll see it in code like
+;; <https://github.com/rust-lang/rust/blob/767453eb7ca188e991ac5568c17b984dd4893e77/library/core/src/num/mod.rs#L174-L180>
+(rule (simplify (sshr ty (imul ty (sextend _ x@(value_type half_ty))
+                                  (sextend _ y@(value_type half_ty)))
+                         (iconst_u _ k)))
+      (if-let $true (ty_equal half_ty (ty_half_width ty)))
+      (if-let $true (u64_eq k (ty_bits_u64 half_ty)))
+      (sextend ty (smulhi half_ty x y)))
+(rule (simplify (ushr ty (imul ty (uextend _ x@(value_type half_ty))
+                                  (uextend _ y@(value_type half_ty)))
+                         (iconst_u _ k)))
+      (if-let $true (ty_equal half_ty (ty_half_width ty)))
+      (if-let $true (u64_eq k (ty_bits_u64 half_ty)))
+      (uextend ty (umulhi half_ty x y)))
+
+;; Cranelift's `fcvt_from_{u,s}int` instructions are polymorphic over the input
+;; type so remove any unnecessary `uextend` or `sextend` to give backends
+;; the chance to convert from the smallest integral type to the float. This
+;; can help lowerings on x64 for example which has a less efficient u64-to-float
+;; conversion than other bit widths.
+(rule (simplify (fcvt_from_uint ty (uextend _ val)))
+      (fcvt_from_uint ty val))
+(rule (simplify (fcvt_from_sint ty (sextend _ val)))
+      (fcvt_from_sint ty val))
diff --git a/cranelift/codegen/src/opts/bitops.isle b/cranelift/codegen/src/opts/bitops.isle
index 7e454902af09..0f44ba47d2ec 100644
--- a/cranelift/codegen/src/opts/bitops.isle
+++ b/cranelift/codegen/src/opts/bitops.isle
@@ -1,53 +1,39 @@
 ;; Rewrites for `band`, `bnot`, `bor`, `bxor`
 
-;; x | 0 == 0 | x == x | x == x.
+;; x | 0 == x | x == x.
 (rule (simplify (bor ty
                      x
-                     (iconst ty (u64_from_imm64 0))))
-      (subsume x))
-(rule (simplify (bor ty
-                     (iconst ty (u64_from_imm64 0))
-                     x))
+                     (iconst_u ty 0)))
       (subsume x))
 (rule (simplify (bor ty x x))
       (subsume x))
 
-;; x ^ 0 == 0 ^ x == x.
+;; x ^ 0 == x.
 (rule (simplify (bxor ty
                      x
-                     (iconst ty (u64_from_imm64 0))))
-      (subsume x))
-(rule (simplify (bxor ty
-                     (iconst ty (u64_from_imm64 0))
-                     x))
+                     (iconst_u ty 0)))
       (subsume x))
 
 ;; x ^ x == 0.
-(rule (simplify (bxor (fits_in_64 (ty_int ty)) x x))
-      (subsume (iconst ty (imm64 0))))
+(rule (simplify (bxor (ty_int ty) x x))
+      (subsume (iconst_u ty 0)))
 
 ;; x ^ not(x) == not(x) ^ x == x | not(x) == not(x) | x == -1.
 ;; This identity also holds for non-integer types, vectors, and wider types.
-;; But `iconst` is only valid for integers up to 64 bits wide.
-(rule (simplify (bxor (fits_in_64 (ty_int ty)) x (bnot ty x))) (subsume (iconst ty (imm64 (ty_mask ty)))))
-(rule (simplify (bxor (fits_in_64 (ty_int ty)) (bnot ty x) x)) (subsume (iconst ty (imm64 (ty_mask ty)))))
-(rule (simplify (bor (fits_in_64 (ty_int ty)) x (bnot ty x))) (subsume (iconst ty (imm64 (ty_mask ty)))))
-(rule (simplify (bor (fits_in_64 (ty_int ty)) (bnot ty x) x)) (subsume (iconst ty (imm64 (ty_mask ty)))))
+(rule (simplify (bxor (ty_int ty) x (bnot ty x))) (subsume (iconst_s ty -1)))
+(rule (simplify (bxor (ty_int ty) (bnot ty x) x)) (subsume (iconst_s ty -1)))
+(rule (simplify (bor (ty_int ty) x (bnot ty x))) (subsume (iconst_s ty -1)))
+(rule (simplify (bor (ty_int ty) (bnot ty x) x)) (subsume (iconst_s ty -1)))
 
-;; x & -1 == -1 & x == x & x == x.
+;; x & x == x & -1 == x.
 (rule (simplify (band ty x x)) (subsume x))
-(rule (simplify (band ty x (iconst ty k)))
-      (if-let -1 (i64_sextend_imm64 ty k))
-      (subsume x))
-(rule (simplify (band ty (iconst ty k) x))
-      (if-let -1 (i64_sextend_imm64 ty k))
+(rule (simplify (band ty x (iconst_s ty -1)))
       (subsume x))
 
-;; x & 0 == 0 & x == x & not(x) == not(x) & x == 0.
-(rule (simplify (band ty _ zero @ (iconst ty (u64_from_imm64 0)))) (subsume zero))
-(rule (simplify (band ty zero @ (iconst ty (u64_from_imm64 0)) _)) (subsume zero))
-(rule (simplify (band (fits_in_64 (ty_int ty)) x (bnot ty x))) (subsume (iconst ty (imm64 0))))
-(rule (simplify (band (fits_in_64 (ty_int ty)) (bnot ty x) x)) (subsume (iconst ty (imm64 0))))
+;; x & 0 == x & not(x) == not(x) & x == 0.
+(rule (simplify (band ty _ zero @ (iconst_u ty 0))) (subsume zero))
+(rule (simplify (band (ty_int ty) x (bnot ty x))) (subsume (iconst_u ty 0)))
+(rule (simplify (band (ty_int ty) (bnot ty x) x)) (subsume (iconst_u ty 0)))
 
 ;; not(not(x)) == x.
 (rule (simplify (bnot ty (bnot ty x))) (subsume x))
@@ -82,29 +68,33 @@
 ;; (No need to duplicate for commutative `bor` for this constant version because
 ;; we move constants to the right.)
 (rule (simplify (bor ty
-                     (band ty x (iconst ty (u64_from_imm64 y)))
-                     z @ (iconst ty (u64_from_imm64 zk))))
+                     (band ty x (iconst_u ty y))
+                     z @ (iconst_u ty zk)))
       (if-let $true (u64_eq (u64_and (ty_mask ty) zk)
                             (u64_and (ty_mask ty) (u64_not y))))
       (bor ty x z))
 
 ;; (x ^ -1) can be replaced with the `bnot` instruction
-(rule (simplify (bxor ty x (iconst ty k)))
-  (if-let -1 (i64_sextend_imm64 ty k))
+(rule (simplify (bxor ty x (iconst_s ty -1)))
   (bnot ty x))
 
 ;; sshr((x | -x), N) == bmask(x) where N = ty_bits(ty) - 1.
 ;;
 ;; (x | -x) sets the sign bit to 1 if x is nonzero, and 0 if x is zero. sshr propagates
 ;; the sign bit to the rest of the value.
-(rule (simplify (sshr ty (bor ty x (ineg ty x)) (iconst ty (u64_from_imm64 shift_amt))))
-      (if-let $true (u64_eq shift_amt (u64_sub (ty_bits ty) 1)))
+(rule (simplify (sshr ty (bor ty x (ineg ty x)) (iconst_u ty shift_amt)))
+      (if-let $true (u64_eq shift_amt (ty_shift_mask ty)))
       (bmask ty x))
 
-(rule (simplify (sshr ty (bor ty (ineg ty x) x) (iconst ty (u64_from_imm64 shift_amt))))
-      (if-let $true (u64_eq shift_amt (u64_sub (ty_bits ty) 1)))
+(rule (simplify (sshr ty (bor ty (ineg ty x) x) (iconst_u ty shift_amt)))
+      (if-let $true (u64_eq shift_amt (ty_shift_mask ty)))
       (bmask ty x))
 
+;; Since icmp is always 0 or 1, bmask is just a negation.
+;; TODO: Explore whether this makes sense for things needing extension too.
+(rule (simplify (bmask $I8 cmp@(icmp $I8 _ _ _)))
+      (ineg $I8 cmp))
+
 ;; Matches any expressions that preserve "truthiness".
 ;; i.e. If the input is zero it remains zero, and if it is nonzero it can have
 ;; a different value as long as it is still nonzero.
@@ -118,19 +108,19 @@
 (rule (truthy (popcnt _ x)) x)
 (rule (truthy (rotl _ x _)) x)
 (rule (truthy (rotr _ x _)) x)
-(rule (truthy (select _ x (iconst _ (u64_from_imm64 (u64_nonzero _))) (iconst _ (u64_from_imm64 0)))) x)
+(rule (truthy (select _ x (iconst_u _ (u64_nonzero _)) (iconst_u _ 0))) x)
 ;; (ne ty (iconst 0) v) is also canonicalized into this form via another rule
-(rule (truthy (ne _ x (iconst _ (u64_from_imm64 0)))) x)
+(rule (truthy (ne _ x (iconst_u _ 0))) x)
 
 ;; All of these expressions don't care about their input as long as it is truthy.
 ;; so we can remove expressions that preserve that property from the input.
 (rule (simplify (bmask ty v)) (if-let x (truthy v)) (bmask ty x))
 (rule (simplify (select ty v t f)) (if-let c (truthy v)) (select ty c t f))
 ;; (ne ty (iconst 0) v) is also canonicalized into this form via another rule
-(rule (simplify (ne cty v (iconst _ (u64_from_imm64 0))))
+(rule (simplify (ne cty v (iconst_u _ 0)))
       (if-let c (truthy v))
-      (if-let (value_type ty) c)
-      (ne cty c (iconst ty (imm64 0))))
+      (if-let (value_type (ty_int_ref_scalar_64 ty)) c)
+      (ne cty c (iconst_u ty 0)))
 
 
 
@@ -145,3 +135,54 @@
 
 ;; (bitrev (bitrev x)) == x
 (rule (simplify (bitrev ty (bitrev ty x))) (subsume x))
+
+;; WebAssembly doesn't have a native byte-swapping instruction at this time so
+;; languages which have a byte-swapping operation will compile it down to bit
+;; shifting and twiddling. This attempts to pattern match what LLVM currently
+;; generates today for the Rust code `a.swap_bytes()`. This might be a bit
+;; brittle over time and/or with other possible LLVM backend optimizations, but
+;; it's at least one way to generate a byte swap.
+;;
+;; Technically this could be permuted quite a few ways and currently there's no
+;; easy way to match all of them, so only one is matched here.
+(rule (simplify (bor ty @ $I32
+    (bor ty
+      (ishl ty x (iconst_u ty 24))
+      (ishl ty
+        (band ty x (iconst_u ty 0xff00))
+        (iconst_u ty 8)))
+    (bor ty
+      (band ty
+        (ushr ty x (iconst_u ty 8))
+        (iconst_u ty 0xff00))
+      (ushr ty x (iconst_u ty 24)))))
+  (bswap ty x))
+
+(rule (simplify (bor ty @ $I64
+    (bor ty
+      (bor ty
+        (ishl ty x (iconst_u ty 56))
+        (ishl ty
+          (band ty x (iconst_u ty 0xff00))
+          (iconst_u ty 40)))
+      (bor ty
+        (ishl ty
+          (band ty x (iconst_u ty 0xff_0000))
+          (iconst_u ty 24))
+        (ishl ty
+          (band ty x (iconst_u ty 0xff00_0000))
+          (iconst_u ty 8))))
+    (bor ty
+      (bor ty
+        (band ty
+          (ushr ty x (iconst_u ty 8))
+          (iconst_u ty 0xff00_0000))
+        (band ty
+          (ushr ty x (iconst_u ty 24))
+          (iconst_u ty 0xff_0000)))
+      (bor ty
+        (band ty
+          (ushr ty x (iconst_u ty 40))
+          (iconst_u ty 0xff00))
+        (ushr ty x (iconst_u ty 56))))))
+  (bswap ty x))
diff --git a/cranelift/codegen/src/opts/cprop.isle b/cranelift/codegen/src/opts/cprop.isle
index 19f5f2aacdf9..7eee7d219c97 100644
--- a/cranelift/codegen/src/opts/cprop.isle
+++ b/cranelift/codegen/src/opts/cprop.isle
@@ -73,11 +73,12 @@
 (rule (simplify (ireduce narrow (iconst (fits_in_64 _) (u64_from_imm64 imm))))
       (subsume (iconst narrow (imm64_masked narrow imm))))
 
-(rule (simplify (uextend (fits_in_64 wide) (iconst narrow imm)))
-      (subsume (iconst wide (imm64 (u64_uextend_imm64 narrow imm)))))
-
-(rule (simplify (sextend (fits_in_64 wide) (iconst narrow imm)))
-      (subsume (iconst wide (imm64_masked wide (i64_as_u64 (i64_sextend_imm64 narrow imm))))))
+;; iconst_[su] support $I128, but do so by extending, so restricting to
+;; 64-bit or smaller keeps it from just remaking essentially the same thing.
+(rule (simplify (uextend (fits_in_64 wide) (iconst_u narrow k)))
+      (subsume (iconst_u wide k)))
+(rule (simplify (sextend (fits_in_64 wide) (iconst_s narrow k)))
+      (subsume (iconst_s wide k)))
 
 (rule (simplify
        (icmp result_ty
@@ -166,14 +167,20 @@
        (bxor ty (bxor ty x k1 @ (iconst ty _)) k2 @ (iconst ty _)))
       (bxor ty x (bxor ty k1 k2)))
 
-(rule (simplify
-       (select ty (iconst _ (u64_from_imm64 (u64_nonzero _))) x y))
-      x)
-(rule (simplify
-       (select ty (iconst _ (u64_from_imm64 0)) x y))
-      y)
+(rule (simplify (select ty (iconst_u _ (u64_nonzero _)) x _))
+      (subsume x))
+(rule (simplify (select ty (iconst_u _ 0) _ y))
+      (subsume y))
+
+;; Replace subtraction by a "negative" constant with addition.
+;; Notably, this gives `x - (-1) == x + 1`, so other patterns don't have to
+;; match the subtract-negative-one version too.
+;; TODO: it would be nice to do this for `x + (-1) == x - 1` as well, but
+;; that needs work in lowering first to avoid regressing addressing modes.
 
-;; TODO: fadd, fsub, fmul, fdiv, fneg, fabs
+(rule (simplify (isub ty x (iconst_s ty k)))
+      (if-let $true (u64_lt (i64_as_u64 (i64_neg k)) (i64_as_u64 k)))
+      (iadd ty x (iconst ty (imm64_masked ty (i64_as_u64 (i64_neg k))))))
 
 ;; A splat of a constant can become a direct `vconst` with the appropriate bit
 ;; pattern.
@@ -198,3 +205,204 @@
 (rule (splat32 n) (splat64 (u64_or n (u64_shl n 32))))
 (decl splat64 (u64) Constant)
 (extern constructor splat64 splat64)
+
+;; Reassociate nested shifts of constants to put constants together for cprop.
+;;
+;; ((A shift b) shift C) ==> ((A shift C) shift b)
+(rule (simplify (ishl ty (ishl ty a@(iconst _ _) b) c@(iconst _ _)))
+      (ishl ty (ishl ty a c) b))
+(rule (simplify (ushr ty (ushr ty a@(iconst _ _) b) c@(iconst _ _)))
+      (ushr ty (ushr ty a c) b))
+(rule (simplify (sshr ty (sshr ty a@(iconst _ _) b) c@(iconst _ _)))
+      (sshr ty (sshr ty a c) b))
+
+;; When we operations that are both commutative and associative, reassociate
+;; constants together for cprop:
+;;
+;; ((a op B) op (c op D)) ==> ((a op c) op (B op D))
+;;
+;; Where `op` is one of: `iadd`, `imul`, `band`, `bor`, or `bxor`.
+(rule (simplify (iadd ty
+                      (iadd ty a b@(iconst _ _))
+                      (iadd ty c d@(iconst _ _))))
+      (iadd ty (iadd ty a c) (iadd ty b d)))
+(rule (simplify (imul ty
+                      (imul ty a b@(iconst _ _))
+                      (imul ty c d@(iconst _ _))))
+      (imul ty (imul ty a c) (imul ty b d)))
+(rule (simplify (band ty
+                      (band ty a b@(iconst _ _))
+                      (band ty c d@(iconst _ _))))
+      (band ty (band ty a c) (band ty b d)))
+(rule (simplify (bor ty
+                      (bor ty a b@(iconst _ _))
+                      (bor ty c d@(iconst _ _))))
+      (bor ty (bor ty a c) (bor ty b d)))
+(rule (simplify (bxor ty
+                      (bxor ty a b@(iconst _ _))
+                      (bxor ty c d@(iconst _ _))))
+      (bxor ty (bxor ty a c) (bxor ty b d)))
+
+
+;; Constant fold int-to-float conversions.
+(rule (simplify (fcvt_from_uint $F32 (iconst_u _ n)))
+      (f32const $F32 (f32_from_uint n)))
+(rule (simplify (fcvt_from_uint $F64 (iconst_u _ n)))
+      (f64const $F64 (f64_from_uint n)))
+(rule (simplify (fcvt_from_sint $F32 (iconst_s _ n)))
+      (f32const $F32 (f32_from_sint n)))
+(rule (simplify (fcvt_from_sint $F64 (iconst_s _ n)))
+      (f64const $F64 (f64_from_sint n)))
+
+(decl f32_from_uint (u64) Ieee32)
+(extern constructor f32_from_uint f32_from_uint)
+(decl f64_from_uint (u64) Ieee64)
+(extern constructor f64_from_uint f64_from_uint)
+(decl f32_from_sint (i64) Ieee32)
+(extern constructor f32_from_sint f32_from_sint)
+(decl f64_from_sint (i64) Ieee64)
+(extern constructor f64_from_sint f64_from_sint)
+
+;; Constant fold bswap of a constant.
+(rule (simplify (bswap $I16 (iconst ty (u64_from_imm64 n))))
+      (subsume (iconst $I16 (imm64 (u64_bswap16 n)))))
+(rule (simplify (bswap $I32 (iconst ty (u64_from_imm64 n))))
+      (subsume (iconst $I32 (imm64 (u64_bswap32 n)))))
+(rule (simplify (bswap $I64 (iconst ty (u64_from_imm64 n))))
+      (subsume (iconst $I64 (imm64 (u64_bswap64 n)))))
+
+(decl pure u64_bswap16 (u64) u64)
+(extern constructor u64_bswap16 u64_bswap16)
+(decl pure u64_bswap32 (u64) u64)
+(extern constructor u64_bswap32 u64_bswap32)
+(decl pure u64_bswap64 (u64) u64)
+(extern constructor u64_bswap64 u64_bswap64)
+
+;; Constant fold float operations
+;; Note: With the exception of fabs, fneg and copysign,
+;; constant folding is only performed when the result of
+;; an instruction isn't NaN. We want the NaN bit patterns
+;; produced by an instruction to be consistent, and
+;; compile-time evaluation in a cross-compilation scenario
+;; risks producing different NaN bit patterns than the target
+;; would have at run-time.
+;; TODO: fcmp, fma, demote, promote, to-int ops
+(rule (simplify (fadd $F32 (f32const $F32 lhs) (f32const $F32 rhs)))
+      (if-let r (f32_add lhs rhs))
+      (subsume (f32const $F32 r)))
+(rule (simplify (fadd $F64 (f64const $F64 lhs) (f64const $F64 rhs)))
+      (if-let r (f64_add lhs rhs))
+      (subsume (f64const $F64 r)))
+
+(rule (simplify (fsub $F32 (f32const $F32 lhs) (f32const $F32 rhs)))
+      (if-let r (f32_sub lhs rhs))
+      (subsume (f32const $F32 r)))
+(rule (simplify (fsub $F64 (f64const $F64 lhs) (f64const $F64 rhs)))
+      (if-let r (f64_sub lhs rhs))
+      (subsume (f64const $F64 r)))
+
+(rule (simplify (fmul $F32 (f32const $F32 lhs) (f32const $F32 rhs)))
+      (if-let r (f32_mul lhs rhs))
+      (subsume (f32const $F32 r)))
+(rule (simplify (fmul $F64 (f64const $F64 lhs) (f64const $F64 rhs)))
+      (if-let r (f64_mul lhs rhs))
+      (subsume (f64const $F64 r)))
+
+(rule (simplify (fdiv $F32 (f32const $F32 lhs) (f32const $F32 rhs)))
+      (if-let r (f32_div lhs rhs))
+      (subsume (f32const $F32 r)))
+(rule (simplify (fdiv $F64 (f64const $F64 lhs) (f64const $F64 rhs)))
+      (if-let r (f64_div lhs rhs))
+      (subsume (f64const $F64 r)))
+
+(rule (simplify (sqrt $F32 (f32const $F32 n)))
+      (if-let r (f32_sqrt n))
+      (subsume (f32const $F32 r)))
+(rule (simplify (sqrt $F64 (f64const $F64 n)))
+      (if-let r (f64_sqrt n))
+      (subsume (f64const $F64 r)))
+
+(rule (simplify (ceil $F32 (f32const $F32 n)))
+      (if-let r (f32_ceil n))
+      (subsume (f32const $F32 r)))
+(rule (simplify (ceil $F64 (f64const $F64 n)))
+      (if-let r (f64_ceil n))
+      (subsume (f64const $F64 r)))
+
+(rule (simplify (floor $F32 (f32const $F32 n)))
+      (if-let r (f32_floor n))
+      (subsume (f32const $F32 r)))
+(rule (simplify (floor $F64 (f64const $F64 n)))
+      (if-let r (f64_floor n))
+      (subsume (f64const $F64 r)))
+
+(rule (simplify (trunc $F32 (f32const $F32 n)))
+      (if-let r (f32_trunc n))
+      (subsume (f32const $F32 r)))
+(rule (simplify (trunc $F64 (f64const $F64 n)))
+      (if-let r (f64_trunc n))
+      (subsume (f64const $F64 r)))
+
+(rule (simplify (nearest $F32 (f32const $F32 n)))
+      (if-let r (f32_nearest n))
+      (subsume (f32const $F32 r)))
+(rule (simplify (nearest $F64 (f64const $F64 n)))
+      (if-let r (f64_nearest n))
+      (subsume (f64const $F64 r)))
+
+(rule (simplify (fmin $F16 (f16const $F16 n) (f16const $F16 m)))
+      (if-let r (f16_min n m))
+      (subsume (f16const $F32 r)))
+(rule (simplify (fmin $F32 (f32const $F32 n) (f32const $F32 m)))
+      (if-let r (f32_min n m))
+      (subsume (f32const $F32 r)))
+(rule (simplify (fmin $F64 (f64const $F64 n) (f64const $F64 m)))
+      (if-let r (f64_min n m))
+      (subsume (f64const $F64 r)))
+(rule (simplify (fmin $F128 (f128const $F128 (ieee128_constant n)) (f128const $F128 (ieee128_constant m))))
+      (if-let r (f128_min n m))
+      (subsume (f128const $F128 (ieee128_constant r))))
+
+(rule (simplify (fmax $F16 (f16const $F16 n) (f16const $F16 m)))
+      (if-let r (f16_max n m))
+      (subsume (f16const $F16 r)))
+(rule (simplify (fmax $F32 (f32const $F32 n) (f32const $F32 m)))
+      (if-let r (f32_max n m))
+      (subsume (f32const $F32 r)))
+(rule (simplify (fmax $F64 (f64const $F64 n) (f64const $F64 m)))
+      (if-let r (f64_max n m))
+      (subsume (f64const $F64 r)))
+(rule (simplify (fmax $F128 (f128const $F128 (ieee128_constant n)) (f128const $F128 (ieee128_constant m))))
+      (if-let r (f128_max n m))
+      (subsume (f128const $F128 (ieee128_constant r))))
+
+(rule (simplify (fneg $F16 (f16const $F16 n)))
+      (subsume (f16const $F16 (f16_neg n))))
+(rule (simplify (fneg $F32 (f32const $F32 n)))
+      (subsume (f32const $F32 (f32_neg n))))
+(rule (simplify (fneg $F64 (f64const $F64 n)))
+      (subsume (f64const $F64 (f64_neg n))))
+(rule (simplify (fneg $F128 (f128const $F128 (ieee128_constant n))))
+      (subsume (f128const $F128 (ieee128_constant (f128_neg n)))))
+
+(rule (simplify (fabs $F16 (f16const $F16 n)))
+      (subsume (f16const $F16 (f16_abs n))))
+(rule (simplify (fabs $F32 (f32const $F32 n)))
+      (subsume (f32const $F32 (f32_abs n))))
+(rule (simplify (fabs $F64 (f64const $F64 n)))
+      (subsume (f64const $F64 (f64_abs n))))
+(rule (simplify (fabs $F128 (f128const $F128 (ieee128_constant n))))
+      (subsume (f128const $F128 (ieee128_constant (f128_abs n)))))
+
+(rule (simplify (fcopysign $F16 (f16const $F16 n) (f16const $F16 m)))
+      (subsume (f16const $F16 (f16_copysign n m))))
+(rule (simplify (fcopysign $F32 (f32const $F32 n) (f32const $F32 m)))
+      (subsume (f32const $F32 (f32_copysign n m))))
+(rule (simplify (fcopysign $F64 (f64const $F64 n) (f64const $F64 m)))
+      (subsume (f64const $F64 (f64_copysign n m))))
+(rule (simplify (fcopysign $F128 (f128const $F128 (ieee128_constant n)) (f128const $F128 (ieee128_constant m))))
+      (subsume (f128const $F128 (ieee128_constant (f128_copysign n m)))))
+
+(decl ieee128_constant (Ieee128) Constant)
+(extern constructor ieee128_constant ieee128_constant)
+(extern extractor ieee128_constant ieee128_constant_extractor)
diff --git a/cranelift/codegen/src/opts/extends.isle b/cranelift/codegen/src/opts/extends.isle
index a1a4dfda0596..44af997defc7 100644
--- a/cranelift/codegen/src/opts/extends.isle
+++ b/cranelift/codegen/src/opts/extends.isle
@@ -4,15 +4,23 @@
 (rule (simplify (sextend ty (sextend _intermediate_ty x)))
       (sextend ty x))
 
+;; Once something has be `uextend`ed, further `sextend`ing is the same as `uextend`
+(rule (simplify (sextend ty (uextend _intermediate_ty x)))
+      (uextend ty x))
+
+;; `icmp` is zero or one, so sign-extending is the same as zero-extending
+(rule (simplify (sextend ty x@(icmp _ _ _ _)))
+      (uextend ty x))
+
 ;; Masking out any of the top bits of the result of `uextend` is a no-op. (This
 ;; is like a cheap version of known-bits analysis.)
-(rule (simplify (band wide x @ (uextend _ (value_type narrow)) (iconst _ (u64_from_imm64 mask))))
+(rule (simplify (band wide x @ (uextend _ (value_type narrow)) (iconst_u _ mask)))
       ; Check that `narrow_mask` has a subset of the bits that `mask` does.
       (if-let $true (let ((narrow_mask u64 (ty_mask narrow))) (u64_eq narrow_mask (u64_and mask narrow_mask))))
       x)
 
 ;; Masking out the sign-extended bits of an `sextend` turns it into a `uextend`.
-(rule (simplify (band wide (sextend _ x @ (value_type narrow)) (iconst _ (u64_from_imm64 mask))))
+(rule (simplify (band wide (sextend _ x @ (value_type narrow)) (iconst_u _ mask)))
       (if-let $true (u64_eq mask (ty_mask narrow)))
       (uextend wide x))
 
@@ -20,15 +28,68 @@
 (rule (simplify
        (slt ty
              (uextend $I64 x @ (value_type $I32))
-             (iconst _ (u64_from_imm64 0))))
-      (iconst ty (imm64 0)))
+             (iconst_u _ 0)))
+      (subsume (iconst_u ty 0)))
 (rule (simplify
        (sge ty
              (uextend $I64 x @ (value_type $I32))
-             (iconst _ (u64_from_imm64 0))))
-      (iconst ty (imm64 1)))
+             (iconst_u _ 0)))
+      (subsume (iconst_u ty 1)))
+
+;; Sign-extending can't change whether a number is zero nor how it signed-compares to zero
+(rule (simplify (eq _ (sextend _ x@(value_type ty)) (iconst_s _ 0)))
+      (eq ty x (iconst_s ty 0)))
+(rule (simplify (ne _ (sextend _ x@(value_type ty)) (iconst_s _ 0)))
+      (ne ty x (iconst_s ty 0)))
+(rule (simplify (icmp _ cc (sextend _ x@(value_type ty)) (iconst_s _ 0)))
+      (if (signed_cond_code cc))
+      (icmp ty cc x (iconst_s ty 0)))
 
 ;; A reduction-of-an-extend back to the same original type is the same as not
 ;; actually doing the extend in the first place.
-(rule (simplify (ireduce ty (sextend _ x @ (value_type ty)))) x)
-(rule (simplify (ireduce ty (uextend _ x @ (value_type ty)))) x)
+(rule (simplify (ireduce ty (sextend _ x @ (value_type ty)))) (subsume x))
+(rule (simplify (ireduce ty (uextend _ x @ (value_type ty)))) (subsume x))
+
+;; A reduction-of-an-extend that's not just to the original type is either:
+;; a reduction of the original if the final type is smaller, or
+(rule (simplify (ireduce (ty_int ty_final) (sextend _ inner@(value_type ty_initial))))
+      (if-let $true (u64_lt (ty_bits_u64 ty_final) (ty_bits_u64 ty_initial)))
+      (ireduce ty_final inner))
+(rule (simplify (ireduce (ty_int ty_final) (uextend _ inner@(value_type ty_initial))))
+      (if-let $true (u64_lt (ty_bits_u64 ty_final) (ty_bits_u64 ty_initial)))
+      (ireduce ty_final inner))
+;; an extension of the original if the final type is larger.
+(rule (simplify (ireduce (ty_int ty_final) (sextend _ inner@(value_type ty_initial))))
+      (if-let $true (u64_lt (ty_bits_u64 ty_initial) (ty_bits_u64 ty_final)))
+      (sextend ty_final inner))
+(rule (simplify (ireduce (ty_int ty_final) (uextend _ inner@(value_type ty_initial))))
+      (if-let $true (u64_lt (ty_bits_u64 ty_initial) (ty_bits_u64 ty_final)))
+      (uextend ty_final inner))
+
+;; `band`, `bor`, and `bxor` can't affect any bits that aren't set in the one of
+;; the inputs, so they can be pushed down inside `uextend`s
+(rule (simplify (band bigty (uextend _ x@(value_type smallty)) (uextend _ y@(value_type smallty))))
+      (uextend bigty (band smallty x y)))
+(rule (simplify (bor bigty (uextend _ x@(value_type smallty)) (uextend _ y@(value_type smallty))))
+      (uextend bigty (bor smallty x y)))
+(rule (simplify (bxor bigty (uextend _ x@(value_type smallty)) (uextend _ y@(value_type smallty))))
+      (uextend bigty (bxor smallty x y)))
+
+;; Replace `(small)(x OP y)` with `(small)x OP (small)y` in cases where that's
+;; legal.
+;; Matches values where the high bits of the input don't affect lower bits of
+;; the output, and thus the inputs can be reduced before the operation rather
+;; than doing the wide operation then reducing afterwards.
+(rule (simplify (ireduce ty (ineg _ x))) (ineg ty (ireduce ty x)))
+(rule (simplify (ireduce ty (bnot _ x))) (bnot ty (ireduce ty x)))
+
+(rule (simplify (ireduce ty (iadd _ x y))) (iadd ty (ireduce ty x) (ireduce ty y)))
+(rule (simplify (ireduce ty (isub _ x y))) (isub ty (ireduce ty x) (ireduce ty y)))
+(rule (simplify (ireduce ty (imul _ x y))) (imul ty (ireduce ty x) (ireduce ty y)))
+(rule (simplify (ireduce ty (bor  _ x y))) (bor  ty (ireduce ty x) (ireduce ty y)))
+(rule (simplify (ireduce ty (bxor _ x y))) (bxor ty (ireduce ty x) (ireduce ty y)))
+(rule (simplify (ireduce ty (band _ x y))) (band ty (ireduce ty x) (ireduce ty y)))
+
+;; Try to transform an `iconcat` into an i128 into either an sextend or uextend
+(rule (simplify (iconcat $I128 x (iconst_u _ 0))) (uextend $I128 x))
+(rule (simplify (iconcat $I128 x (sshr _ x (iconst_u _ 63)))) (sextend $I128 x))
diff --git a/cranelift/codegen/src/opts/generated_code.rs b/cranelift/codegen/src/opts/generated_code.rs
index b196e1050922..cd2362988d19 100644
--- a/cranelift/codegen/src/opts/generated_code.rs
+++ b/cranelift/codegen/src/opts/generated_code.rs
@@ -6,6 +6,6 @@
 // mod generated_code;` trick either.
 #![allow(dead_code, unreachable_code, unreachable_patterns)]
 #![allow(unused_imports, unused_variables, non_snake_case, unused_mut)]
-#![allow(irrefutable_let_patterns, non_camel_case_types)]
+#![allow(irrefutable_let_patterns, non_camel_case_types, clippy::clone_on_copy)]
 
 include!(concat!(env!("ISLE_DIR"), "/isle_opt.rs"));
diff --git a/cranelift/codegen/src/opts/icmp.isle b/cranelift/codegen/src/opts/icmp.isle
index b0f57fdf1566..b838fd39720c 100644
--- a/cranelift/codegen/src/opts/icmp.isle
+++ b/cranelift/codegen/src/opts/icmp.isle
@@ -2,28 +2,46 @@
 
 ;; `x == x` is always true for integers; `x != x` is false. Strict
 ;; inequalities are false, and loose inequalities are true.
-(rule (simplify (eq  (fits_in_64 (ty_int ty)) x x)) (iconst ty (imm64 1)))
-(rule (simplify (ne  (fits_in_64 (ty_int ty)) x x)) (iconst ty (imm64 0)))
-(rule (simplify (ugt (fits_in_64 (ty_int ty)) x x)) (iconst ty (imm64 0)))
-(rule (simplify (uge (fits_in_64 (ty_int ty)) x x)) (iconst ty (imm64 1)))
-(rule (simplify (sgt (fits_in_64 (ty_int ty)) x x)) (iconst ty (imm64 0)))
-(rule (simplify (sge (fits_in_64 (ty_int ty)) x x)) (iconst ty (imm64 1)))
-(rule (simplify (ult (fits_in_64 (ty_int ty)) x x)) (iconst ty (imm64 0)))
-(rule (simplify (ule (fits_in_64 (ty_int ty)) x x)) (iconst ty (imm64 1)))
-(rule (simplify (slt (fits_in_64 (ty_int ty)) x x)) (iconst ty (imm64 0)))
-(rule (simplify (sle (fits_in_64 (ty_int ty)) x x)) (iconst ty (imm64 1)))
+(rule (simplify (eq  (ty_int ty) x x)) (subsume (iconst_u ty 1)))
+(rule (simplify (ne  (ty_int ty) x x)) (subsume (iconst_u ty 0)))
+(rule (simplify (ugt (ty_int ty) x x)) (subsume (iconst_u ty 0)))
+(rule (simplify (uge (ty_int ty) x x)) (subsume (iconst_u ty 1)))
+(rule (simplify (sgt (ty_int ty) x x)) (subsume (iconst_u ty 0)))
+(rule (simplify (sge (ty_int ty) x x)) (subsume (iconst_u ty 1)))
+(rule (simplify (ult (ty_int ty) x x)) (subsume (iconst_u ty 0)))
+(rule (simplify (ule (ty_int ty) x x)) (subsume (iconst_u ty 1)))
+(rule (simplify (slt (ty_int ty) x x)) (subsume (iconst_u ty 0)))
+(rule (simplify (sle (ty_int ty) x x)) (subsume (iconst_u ty 1)))
 
 ;; Optimize icmp-of-icmp.
+;; ne(icmp(ty, cc, x, y), 0) == icmp(ty, cc, x, y)
+;; e.g. neq(ugt(x, y), 0) == ugt(x, y)
 (rule (simplify (ne ty
-                      (uextend _ inner @ (icmp ty _ _ _))
-                      (iconst _ (u64_from_imm64 0))))
+                      (uextend_maybe _ inner @ (icmp ty _ _ _))
+                      (iconst_u _ 0)))
       (subsume inner))
 
+;; eq(icmp(ty, cc, x, y), 0) == icmp(ty, cc_complement, x, y)
+;; e.g. eq(ugt(x, y), 0) == ule(x, y)
 (rule (simplify (eq ty
-                      (uextend _ (icmp ty cc x y))
-                      (iconst _ (u64_from_imm64 0))))
+                      (uextend_maybe _ (icmp ty cc x y))
+                      (iconst_u _ 0)))
       (subsume (icmp ty (intcc_complement cc) x y)))
 
+;; ne(icmp(ty, cc, x, y), 1) == icmp(ty, cc_complement, x, y)
+;; e.g. ne(ugt(x, y), 1) == ule(x, y)
+(rule (simplify (ne ty
+                      (uextend_maybe _ (icmp ty cc x y))
+                      (iconst_u _ 1)))
+      (subsume (icmp ty (intcc_complement cc) x y)))
+
+;; eq(icmp(ty, cc, x, y), 1) == icmp(ty, cc, x, y)
+;; e.g. eq(ugt(x, y), 1) == ugt(x, y)
+(rule (simplify (eq ty
+                      (uextend_maybe _ inner @ (icmp _ _ _ _))
+                      (iconst_u _ 1)))
+      (subsume inner))
+
 ;; Optimize select-of-uextend-of-icmp to select-of-icmp, because
 ;; select can take an I8 condition too.
 (rule (simplify
@@ -39,88 +57,88 @@
 (rule (simplify
        (band (ty_int _)
              cmp @ (icmp _ _ _ _)
-             (iconst _ (u64_from_imm64 1))))
+             (iconst_u _ 1)))
       cmp)
 (rule (simplify
        (band (ty_int _)
              extend @ (uextend _ (icmp _ _ _ _))
-             (iconst _ (u64_from_imm64 1))))
+             (iconst_u _ 1)))
       extend)
 
 ;; Comparisons against largest/smallest signed/unsigned values:
 ;; ult(x, 0) == false.
-(rule (simplify (ult (fits_in_64 (ty_int bty)) x zero @ (iconst _ (u64_from_imm64 0))))
-      (subsume (iconst bty (imm64 0))))
+(rule (simplify (ult (fits_in_64 (ty_int bty)) x zero @ (iconst_u _ 0)))
+      (subsume (iconst_u bty 0)))
 
 ;; ule(x, 0) == eq(x, 0)
-(rule (simplify (ule (fits_in_64 (ty_int bty)) x zero @ (iconst _ (u64_from_imm64 0))))
+(rule (simplify (ule (fits_in_64 (ty_int bty)) x zero @ (iconst_u _ 0)))
       (eq bty x zero))
 
 ;; ugt(x, 0) == ne(x, 0).
-(rule (simplify (ugt (fits_in_64 (ty_int bty)) x zero @ (iconst _ (u64_from_imm64 0))))
+(rule (simplify (ugt (fits_in_64 (ty_int bty)) x zero @ (iconst_u _ 0)))
       (ne bty x zero))
 
 ;; uge(x, 0) == true.
-(rule (simplify (uge (fits_in_64 (ty_int bty)) x zero @ (iconst _ (u64_from_imm64 0))))
-      (subsume (iconst bty (imm64 1))))
+(rule (simplify (uge (fits_in_64 (ty_int bty)) x zero @ (iconst_u _ 0)))
+      (subsume (iconst_u bty 1)))
 
 ;; ult(x, UMAX) == ne(x, UMAX).
-(rule (simplify (ult (fits_in_64 (ty_int bty)) x umax @ (iconst cty (u64_from_imm64 y))))
+(rule (simplify (ult (fits_in_64 (ty_int bty)) x umax @ (iconst_u cty y)))
        (if-let $true (u64_eq y (ty_umax cty)))
        (ne bty x umax))
 
 ;; ule(x, UMAX) == true.
-(rule (simplify (ule (fits_in_64 (ty_int bty)) x umax @ (iconst cty (u64_from_imm64 y))))
+(rule (simplify (ule (fits_in_64 (ty_int bty)) x umax @ (iconst_u cty y)))
        (if-let $true (u64_eq y (ty_umax cty)))
-       (subsume (iconst bty (imm64 1))))
+       (subsume (iconst_u bty 1)))
 
 ;; ugt(x, UMAX) == false.
-(rule (simplify (ugt (fits_in_64 (ty_int bty)) x umax @ (iconst cty (u64_from_imm64 y))))
+(rule (simplify (ugt (fits_in_64 (ty_int bty)) x umax @ (iconst_u cty y)))
        (if-let $true (u64_eq y (ty_umax cty)))
-       (subsume (iconst bty (imm64 0))))
+       (subsume (iconst_u bty 0)))
 
 ;; uge(x, UMAX) == eq(x, UMAX).
-(rule (simplify (uge (fits_in_64 (ty_int bty)) x umax @ (iconst cty (u64_from_imm64 y))))
+(rule (simplify (uge (fits_in_64 (ty_int bty)) x umax @ (iconst_u cty y)))
        (if-let $true (u64_eq y (ty_umax cty)))
        (eq bty x umax))
 
 ;; slt(x, SMIN) == false.
-(rule (simplify (slt (fits_in_64 (ty_int bty)) x smin @ (iconst cty (u64_from_imm64 y))))
+(rule (simplify (slt (fits_in_64 (ty_int bty)) x smin @ (iconst_u cty y)))
        (if-let $true (u64_eq y (ty_smin cty)))
-       (subsume (iconst bty (imm64 0))))
+       (subsume (iconst_u bty 0)))
 
 ;; sle(x, SMIN) == eq(x, SMIN).
-(rule (simplify (sle (fits_in_64 (ty_int bty)) x smin @ (iconst cty (u64_from_imm64 y))))
+(rule (simplify (sle (fits_in_64 (ty_int bty)) x smin @ (iconst_u cty y)))
        (if-let $true (u64_eq y (ty_smin cty)))
        (eq bty x smin))
 
 ;; sgt(x, SMIN) == ne(x, SMIN).
-(rule (simplify (sgt (fits_in_64 (ty_int bty)) x smin @ (iconst cty (u64_from_imm64 y))))
+(rule (simplify (sgt (fits_in_64 (ty_int bty)) x smin @ (iconst_u cty y)))
        (if-let $true (u64_eq y (ty_smin cty)))
        (ne bty x smin))
 
 ;; sge(x, SMIN) == true.
-(rule (simplify (sge (fits_in_64 (ty_int bty)) x smin @ (iconst cty (u64_from_imm64 y))))
+(rule (simplify (sge (fits_in_64 (ty_int bty)) x smin @ (iconst_u cty y)))
        (if-let $true (u64_eq y (ty_smin cty)))
-       (subsume (iconst bty (imm64 1))))
+       (subsume (iconst_u bty 1)))
 
 ;; slt(x, SMAX) == ne(x, SMAX).
-(rule (simplify (slt (fits_in_64 (ty_int bty)) x smax @ (iconst cty (u64_from_imm64 y))))
+(rule (simplify (slt (fits_in_64 (ty_int bty)) x smax @ (iconst_u cty y)))
        (if-let $true (u64_eq y (ty_smax cty)))
        (ne bty x smax))
 
 ;; sle(x, SMAX) == true.
-(rule (simplify (sle (fits_in_64 (ty_int bty)) x smax @ (iconst cty (u64_from_imm64 y))))
+(rule (simplify (sle (fits_in_64 (ty_int bty)) x smax @ (iconst_u cty y)))
        (if-let $true (u64_eq y (ty_smax cty)))
-       (subsume (iconst bty (imm64 1))))
+       (subsume (iconst_u bty 1)))
 
 ;; sgt(x, SMAX) == false.
-(rule (simplify (sgt (fits_in_64 (ty_int bty)) x smax @ (iconst cty (u64_from_imm64 y))))
+(rule (simplify (sgt (fits_in_64 (ty_int bty)) x smax @ (iconst_u cty y)))
        (if-let $true (u64_eq y (ty_smax cty)))
-       (subsume (iconst bty (imm64 0))))
+       (subsume (iconst_u bty 0)))
 
 ;; sge(x, SMAX) == eq(x, SMAX).
-(rule (simplify (sge (fits_in_64 (ty_int bty)) x smax @ (iconst cty (u64_from_imm64 y))))
+(rule (simplify (sge (fits_in_64 (ty_int bty)) x smax @ (iconst_u cty y)))
        (if-let $true (u64_eq y (ty_smax cty)))
        (eq bty x smax))
 
@@ -133,6 +151,26 @@
   (if-let signed (intcc_comparable cc1 cc2))
   (compose_icmp ty (u64_or (decompose_intcc cc1) (decompose_intcc cc2)) signed x y))
 
+;; Prefer comparing against zero
+;; uge(x, 1) == ne(x, 0)
+(rule (simplify (uge ty x (iconst_u cty 1)))
+      (ne ty x (iconst_u cty 0)))
+;; ult(x, 1) == eq(x, 0)
+(rule (simplify (ult ty x (iconst_u cty 1)))
+      (eq ty x (iconst_u cty 0)))
+;; sge(x, 1) == sgt(x, 0)
+(rule (simplify (sge ty x (iconst_s cty 1)))
+      (sgt ty x (iconst_s cty 0)))
+;; slt(x, 1) == sle(x, 0)
+(rule (simplify (slt ty x (iconst_s cty 1)))
+      (sle ty x (iconst_s cty 0)))
+;; sgt(x, -1) == sge(x, 0)
+(rule (simplify (sgt ty x (iconst_s cty -1)))
+      (sge ty x (iconst_s cty 0)))
+;; sle(x, -1) == slt(x, 0)
+(rule (simplify (sle ty x (iconst_s cty -1)))
+      (slt ty x (iconst_s cty 0)))
+
 (decl pure partial intcc_comparable (IntCC IntCC) bool)
 (rule (intcc_comparable x y)
   (if-let (u64_nonzero class) (u64_and (intcc_class x) (intcc_class y)))
@@ -151,7 +189,7 @@
 (rule (decompose_intcc (IntCC.NotEqual)) 6)
 
 (decl compose_icmp (Type u64 bool Value Value) Value)
-(rule (compose_icmp ty 0 _ _ _) (subsume (iconst ty (imm64 0))))
+(rule (compose_icmp ty 0 _ _ _) (subsume (iconst_u ty 0)))
 (rule (compose_icmp ty 1 _ x y) (icmp ty (IntCC.Equal) x y))
 (rule (compose_icmp ty 2 $false x y) (icmp ty (IntCC.UnsignedLessThan) x y))
 (rule (compose_icmp ty 2 $true x y) (icmp ty (IntCC.SignedLessThan) x y))
@@ -162,7 +200,7 @@
 (rule (compose_icmp ty 5 $false x y) (icmp ty (IntCC.UnsignedGreaterThanOrEqual) x y))
 (rule (compose_icmp ty 5 $true x y) (icmp ty (IntCC.SignedGreaterThanOrEqual) x y))
 (rule (compose_icmp ty 6 _ x y) (icmp ty (IntCC.NotEqual) x y))
-(rule (compose_icmp ty 7 _ _ _) (subsume (iconst ty (imm64 1))))
+(rule (compose_icmp ty 7 _ _ _) (subsume (iconst_u ty 1)))
 
 (decl pure intcc_class (IntCC) u64)
 (rule (intcc_class (IntCC.UnsignedLessThan)) 1)
@@ -175,3 +213,46 @@
 (rule (intcc_class (IntCC.SignedGreaterThanOrEqual)) 2)
 (rule (intcc_class (IntCC.Equal)) 3)
 (rule (intcc_class (IntCC.NotEqual)) 3)
+
+;; Pattern-match what LLVM emits today for 128-bit comparisons into actual
+;; 128-bit comparisons. Platforms like x64 and aarch64 have more optimal
+;; lowerings for 128-bit arithmetic than the default structure.
+(rule (simplify (select ty (eq _   a_hi @ (value_type $I64) b_hi @ (value_type $I64))
+                           (uge ty a_lo @ (value_type $I64) b_lo @ (value_type $I64))
+                           (uge ty a_hi b_hi)))
+      (uge ty (iconcat $I64 a_lo a_hi) (iconcat $I64 b_lo b_hi)))
+
+(rule (simplify (select ty (eq _   a_hi @ (value_type $I64) b_hi @ (value_type $I64))
+                           (uge ty a_lo @ (value_type $I64) b_lo @ (value_type $I64))
+                           (sge ty a_hi b_hi)))
+      (sge ty (iconcat $I64 a_lo a_hi) (iconcat $I64 b_lo b_hi)))
+
+(rule (simplify (select ty (eq _   a_hi @ (value_type $I64) b_hi @ (value_type $I64))
+                           (ugt ty a_lo @ (value_type $I64) b_lo @ (value_type $I64))
+                           (ugt ty a_hi b_hi)))
+      (ugt ty (iconcat $I64 a_lo a_hi) (iconcat $I64 b_lo b_hi)))
+
+(rule (simplify (select ty (eq _   a_hi @ (value_type $I64) b_hi @ (value_type $I64))
+                           (ugt ty a_lo @ (value_type $I64) b_lo @ (value_type $I64))
+                           (sgt ty a_hi b_hi)))
+      (sgt ty (iconcat $I64 a_lo a_hi) (iconcat $I64 b_lo b_hi)))
+
+(rule (simplify (select ty (eq _   a_hi @ (value_type $I64) b_hi @ (value_type $I64))
+                           (ule ty a_lo @ (value_type $I64) b_lo @ (value_type $I64))
+                           (ule ty a_hi b_hi)))
+      (ule ty (iconcat $I64 a_lo a_hi) (iconcat $I64 b_lo b_hi)))
+
+(rule (simplify (select ty (eq _   a_hi @ (value_type $I64) b_hi @ (value_type $I64))
+                           (ule ty a_lo @ (value_type $I64) b_lo @ (value_type $I64))
+                           (sle ty a_hi b_hi)))
+      (sle ty (iconcat $I64 a_lo a_hi) (iconcat $I64 b_lo b_hi)))
+
+(rule (simplify (select ty (eq _   a_hi @ (value_type $I64) b_hi @ (value_type $I64))
+                           (ult ty a_lo @ (value_type $I64) b_lo @ (value_type $I64))
+                           (ult ty a_hi b_hi)))
+      (ult ty (iconcat $I64 a_lo a_hi) (iconcat $I64 b_lo b_hi)))
+
+(rule (simplify (select ty (eq _   a_hi @ (value_type $I64) b_hi @ (value_type $I64))
+                           (ult ty a_lo @ (value_type $I64) b_lo @ (value_type $I64))
+                           (slt ty a_hi b_hi)))
+      (slt ty (iconcat $I64 a_lo a_hi) (iconcat $I64 b_lo b_hi)))
diff --git a/cranelift/codegen/src/opts/selects.isle b/cranelift/codegen/src/opts/selects.isle
index e66250327c15..2968f05daba5 100644
--- a/cranelift/codegen/src/opts/selects.isle
+++ b/cranelift/codegen/src/opts/selects.isle
@@ -4,6 +4,24 @@
 (rule (simplify (select    ty _ x x)) x)
 (rule (simplify (bitselect ty _ x x)) x)
 
+;; Push zeroes to the right -- this makes the select `truthy`, as used elsewhere
+;; if icmp { 0 } else { nonzero } => if !icmp { nonzero } else { 0 }
+(rule (simplify (select sty (icmp cty cc x y)
+                        zero@(iconst_u _ 0)
+                        nonzero@(iconst_u _ (u64_nonzero _))))
+    (select sty (icmp cty (intcc_complement cc) x y) nonzero zero))
+
+;; if icmp(x, y) { 1 } else { 0 } => uextend(icmp(x, y))
+(rule (simplify (select ty cmp@(icmp _ cc x y)
+                        (iconst_u _ 1)
+                        (iconst_u _ 0)))
+    (uextend_maybe ty cmp))
+;; if icmp(x, y) { -1 } else { 0 } => uextend(icmp(x, y))
+(rule (simplify (select ty cmp@(icmp _ cc x y)
+                        (iconst_s _ -1)
+                        (iconst_s _ 0)))
+    (bmask ty cmp))
+
 ;; Transform select-of-icmp into {u,s}{min,max} instructions where possible.
 (rule (simplify (select ty (sgt _ x y) x y)) (smax ty x y))
 (rule (simplify (select ty (sge _ x y) x y)) (smax ty x y))
@@ -57,3 +75,14 @@
 (rule (simplify (bor (ty_vec128 ty) (band ty (bnot ty c) y) (band ty x c))) (bitselect ty c x y))
 (rule (simplify (bor (ty_vec128 ty) (band ty y (bnot ty c)) (band ty c x))) (bitselect ty c x y))
 (rule (simplify (bor (ty_vec128 ty) (band ty y (bnot ty c)) (band ty x c))) (bitselect ty c x y))
+
+;; Lift an extend operation outside of a `select` if the extend is happening
+;; on both the consequent and the alternative.
+(rule (simplify (select ty cond
+                           (uextend ty a @ (value_type small))
+                           (uextend ty b @ (value_type small))))
+      (uextend ty (select small cond a b)))
+(rule (simplify (select ty cond
+                           (sextend ty a @ (value_type small))
+                           (sextend ty b @ (value_type small))))
+      (sextend ty (select small cond a b)))
diff --git a/cranelift/codegen/src/opts/shifts.isle b/cranelift/codegen/src/opts/shifts.isle
index 8dcf153d1a98..8aafee37d4d0 100644
--- a/cranelift/codegen/src/opts/shifts.isle
+++ b/cranelift/codegen/src/opts/shifts.isle
@@ -3,23 +3,23 @@
 ;; x>>0 == x<<0 == x rotr 0 == x rotl 0 == x.
 (rule (simplify (ishl ty
                       x
-                      (iconst ty (u64_from_imm64 0))))
+                      (iconst_u ty 0)))
       (subsume x))
 (rule (simplify (ushr ty
                       x
-                      (iconst ty (u64_from_imm64 0))))
+                      (iconst_u ty 0)))
       (subsume x))
 (rule (simplify (sshr ty
                       x
-                      (iconst ty (u64_from_imm64 0))))
+                      (iconst_u ty 0)))
       (subsume x))
 (rule (simplify (rotr ty
                       x
-                      (iconst ty (u64_from_imm64 0))))
+                      (iconst_u ty 0)))
       (subsume x))
 (rule (simplify (rotl ty
                       x
-                      (iconst ty (u64_from_imm64 0))))
+                      (iconst_u ty 0)))
       (subsume x))
 
 ;; `(x >> k) << k` is the same as masking off the bottom `k` bits (regardless if
@@ -50,9 +50,8 @@
 (rule (simplify (sshr wide
                  (ishl wide
                   (uextend wide x @ (value_type narrow))
-                  (iconst _ shift))
-                 (iconst _ shift)))
-      (if-let (u64_from_imm64 shift_u64) shift)
+                  (iconst_u _ shift_u64))
+                 (iconst_u _ shift_u64)))
       (if-let $true (u64_eq shift_u64 (u64_sub (ty_bits_u64 wide) (ty_bits_u64 narrow))))
       (sextend wide x))
 
@@ -62,9 +61,8 @@
 (rule (simplify (sshr wide
                  (ishl wide
                   x @ (uextend wide (value_type narrow))
-                  (iconst _ shift))
-                 (iconst _ shift)))
-      (if-let (u64_from_imm64 shift_u64) shift)
+                  (iconst_u _ shift_u64))
+                 (iconst_u _ shift_u64)))
       (if-let $true (u64_lt shift_u64 (u64_sub (ty_bits_u64 wide) (ty_bits_u64 narrow))))
       x)
 
@@ -73,9 +71,8 @@
 (rule (simplify (sshr wide
                  (ishl wide
                   x @ (sextend wide (value_type narrow))
-                  (iconst _ shift))
-                 (iconst _ shift)))
-      (if-let (u64_from_imm64 shift_u64) shift)
+                  (iconst_u _ shift_u64))
+                 (iconst_u _ shift_u64)))
       (if-let $true (u64_le shift_u64 (u64_sub (ty_bits_u64 wide) (ty_bits_u64 narrow))))
       x)
 
@@ -99,6 +96,212 @@
 (rule (shift_amt_to_type 32) $I32)
 
 ;; ineg(ushr(x, k)) == sshr(x, k) when k == ty_bits - 1.
-(rule (simplify (ineg ty (ushr ty x sconst @ (iconst ty (u64_from_imm64 shift_amt)))))
-      (if-let $true (u64_eq shift_amt (u64_sub (ty_bits ty) 1)))
+(rule (simplify (ineg ty (ushr ty x sconst @ (iconst_u ty shift_amt))))
+      (if-let $true (u64_eq shift_amt (ty_shift_mask ty)))
       (sshr ty x sconst))
+
+;; Shifts and rotates allow a different type for the shift amount, so we
+;; can remove any extend/reduce operations on the shift amount.
+;;
+;; (op x (ireduce y)) == (op x y)
+;; (op x (uextend y)) == (op x y)
+;; (op x (sextend y)) == (op x y)
+;;
+;; where `op` is one of ishl, ushr, sshr, rotl, rotr
+;;
+;; TODO: This rule is restricted to <=64 bits for ireduce since the x86
+;; backend doesn't support SIMD shifts with 128-bit shift amounts.
+
+(rule (simplify (ishl ty x (ireduce _ y @ (value_type (fits_in_64 _))))) (ishl ty x y))
+(rule (simplify (ishl ty x (uextend _ y))) (ishl ty x y))
+(rule (simplify (ishl ty x (sextend _ y))) (ishl ty x y))
+(rule (simplify (ushr ty x (ireduce _ y @ (value_type (fits_in_64 _))))) (ushr ty x y))
+(rule (simplify (ushr ty x (uextend _ y))) (ushr ty x y))
+(rule (simplify (ushr ty x (sextend _ y))) (ushr ty x y))
+(rule (simplify (sshr ty x (ireduce _ y @ (value_type (fits_in_64 _))))) (sshr ty x y))
+(rule (simplify (sshr ty x (uextend _ y))) (sshr ty x y))
+(rule (simplify (sshr ty x (sextend _ y))) (sshr ty x y))
+(rule (simplify (rotr ty x (ireduce _ y @ (value_type (fits_in_64 _))))) (rotr ty x y))
+(rule (simplify (rotr ty x (uextend _ y))) (rotr ty x y))
+(rule (simplify (rotr ty x (sextend _ y))) (rotr ty x y))
+(rule (simplify (rotl ty x (ireduce _ y @ (value_type (fits_in_64 _))))) (rotl ty x y))
+(rule (simplify (rotl ty x (uextend _ y))) (rotl ty x y))
+(rule (simplify (rotl ty x (sextend _ y))) (rotl ty x y))
+
+;; Remove iconcat from the shift amount input. This is correct even if the
+;; the iconcat is i8 type, since it can represent the largest shift amount
+;; for i128 types.
+;;
+;; (op x (iconcat y1 y2)) == (op x y1)
+;;
+;; where `op` is one of ishl, ushr, sshr, rotl, rotr
+
+(rule (simplify (ishl ty x (iconcat _ y _))) (ishl ty x y))
+(rule (simplify (ushr ty x (iconcat _ y _))) (ushr ty x y))
+(rule (simplify (sshr ty x (iconcat _ y _))) (sshr ty x y))
+(rule (simplify (rotr ty x (iconcat _ y _))) (rotr ty x y))
+(rule (simplify (rotl ty x (iconcat _ y _))) (rotl ty x y))
+
+;; Try to combine the shift amount from multiple consecutive shifts
+;; This only works if the shift amount remains smaller than the bit
+;; width of the type.
+;;
+;; (ishl (ishl x k1) k2) == (ishl x (add k1 k2)) if shift_mask(k1) + shift_mask(k2) < ty_bits
+;; (ushr (ushr x k1) k2) == (ushr x (add k1 k2)) if shift_mask(k1) + shift_mask(k2) < ty_bits
+;; (sshr (sshr x k1) k2) == (sshr x (add k1 k2)) if shift_mask(k1) + shift_mask(k2) < ty_bits
+(rule (simplify (ishl ty
+                      (ishl ty x (iconst_u kty k1))
+                      (iconst_u _ k2)))
+      (if-let shift_amt (u64_add
+                              (u64_and k1 (ty_shift_mask ty))
+                              (u64_and k2 (ty_shift_mask ty))))
+      (if-let $true (u64_lt shift_amt (ty_bits_u64 (lane_type ty))))
+      (ishl ty x (iconst_u kty shift_amt)))
+
+(rule (simplify (ushr ty
+                      (ushr ty x (iconst_u kty k1))
+                      (iconst_u _ k2)))
+      (if-let shift_amt (u64_add
+                              (u64_and k1 (ty_shift_mask ty))
+                              (u64_and k2 (ty_shift_mask ty))))
+      (if-let $true (u64_lt shift_amt (ty_bits_u64 (lane_type ty))))
+      (ushr ty x (iconst_u kty shift_amt)))
+
+(rule (simplify (sshr ty
+                      (sshr ty x (iconst_u kty k1))
+                      (iconst_u _ k2)))
+      (if-let shift_amt (u64_add
+                              (u64_and k1 (ty_shift_mask ty))
+                              (u64_and k2 (ty_shift_mask ty))))
+      (if-let $true (u64_lt shift_amt (ty_bits_u64 (lane_type ty))))
+      (sshr ty x (iconst_u kty shift_amt)))
+
+;; Similarly, if the shift amount overflows the type, then we can turn
+;; it into a 0
+;;
+;; (ishl (ishl x k1) k2) == 0 if shift_mask(k1) + shift_mask(k2) >= ty_bits
+;; (ushr (ushr x k1) k2) == 0 if shift_mask(k1) + shift_mask(k2) >= ty_bits
+(rule (simplify (ishl ty
+                      (ishl ty x (iconst_u _ k1))
+                      (iconst_u _ k2)))
+      (if-let shift_amt (u64_add
+                              (u64_and k1 (ty_shift_mask ty))
+                              (u64_and k2 (ty_shift_mask ty))))
+      (if-let $true (u64_le (ty_bits_u64 ty) shift_amt))
+      (subsume (iconst_u ty 0)))
+
+(rule (simplify (ushr ty
+                      (ushr ty x (iconst_u _ k1))
+                      (iconst_u _ k2)))
+      (if-let shift_amt (u64_add
+                              (u64_and k1 (ty_shift_mask ty))
+                              (u64_and k2 (ty_shift_mask ty))))
+      (if-let $true (u64_le (ty_bits_u64 ty) shift_amt))
+      (subsume (iconst_u ty 0)))
+
+;; (rotl (rotr x y) y) == x
+;; (rotr (rotl x y) y) == x
+(rule (simplify (rotl ty (rotr ty x y) y)) (subsume x))
+(rule (simplify (rotr ty (rotl ty x y) y)) (subsume x))
+
+;; Emits an iadd for two values. If they have different types
+;; then the smaller type is zero extended to the larger type.
+(decl iadd_uextend (Value Value) Value)
+(rule 1 (iadd_uextend x @ (value_type ty) y @ (value_type ty))
+      (iadd ty x y))
+(rule 2 (iadd_uextend x @ (value_type x_ty) y @ (value_type y_ty))
+      (if-let $true (u64_lt (ty_bits_u64 x_ty) (ty_bits_u64 y_ty)))
+      (iadd y_ty (uextend y_ty x) y))
+(rule 3 (iadd_uextend x @ (value_type x_ty) y @ (value_type y_ty))
+      (if-let $true (u64_lt (ty_bits_u64 y_ty) (ty_bits_u64 x_ty)))
+      (iadd x_ty x (uextend x_ty y)))
+
+;; Emits an isub for two values. If they have different types
+;; then the smaller type is zero extended to the larger type.
+(decl isub_uextend (Value Value) Value)
+(rule 1 (isub_uextend x @ (value_type ty) y @ (value_type ty))
+      (isub ty x y))
+(rule 2 (isub_uextend x @ (value_type x_ty) y @ (value_type y_ty))
+      (if-let $true (u64_lt (ty_bits_u64 x_ty) (ty_bits_u64 y_ty)))
+      (isub y_ty (uextend y_ty x) y))
+(rule 3 (isub_uextend x @ (value_type x_ty) y @ (value_type y_ty))
+      (if-let $true (u64_lt (ty_bits_u64 y_ty) (ty_bits_u64 x_ty)))
+      (isub x_ty x (uextend x_ty y)))
+
+;; Try to group constants together so that other cprop rules can optimize them.
+;;
+;; (rotr (rotr x y) z) == (rotr x (iadd y z))
+;; (rotl (rotl x y) z) == (rotl x (iadd y z))
+;; (rotr (rotl x y) z) == (rotr x (isub y z))
+;; (rotl (rotr x y) z) == (rotl x (isub y z))
+;;
+;; if x or z are constants
+(rule (simplify (rotl ty (rotl ty x y @ (iconst _ _)) z)) (rotl ty x (iadd_uextend y z)))
+(rule (simplify (rotl ty (rotl ty x y) z @ (iconst _ _))) (rotl ty x (iadd_uextend y z)))
+(rule (simplify (rotr ty (rotr ty x y @ (iconst _ _)) z)) (rotr ty x (iadd_uextend y z)))
+(rule (simplify (rotr ty (rotr ty x y) z @ (iconst _ _))) (rotr ty x (iadd_uextend y z)))
+
+(rule (simplify (rotr ty (rotl ty x y @ (iconst _ _)) z)) (rotl ty x (isub_uextend y z)))
+(rule (simplify (rotr ty (rotl ty x y) z @ (iconst _ _))) (rotl ty x (isub_uextend y z)))
+(rule (simplify (rotl ty (rotr ty x y @ (iconst _ _)) z)) (rotr ty x (isub_uextend y z)))
+(rule (simplify (rotl ty (rotr ty x y) z @ (iconst _ _))) (rotr ty x (isub_uextend y z)))
+
+;; Similarly to the rules above, if y and z have the same type, we should emit
+;; an iadd or isub instead. In some backends this is cheaper than a rotate.
+;;
+;; If they have different types we end up in a situation where we have to insert
+;; and additional extend and that transformation is not universally beneficial.
+;;
+;; (rotr (rotr x y) z) == (rotr x (iadd y z))
+;; (rotl (rotl x y) z) == (rotl x (iadd y z))
+;; (rotr (rotl x y) z) == (rotl x (isub y z))
+;; (rotl (rotr x y) z) == (rotr x (isub y z))
+(rule (simplify (rotr ty (rotr ty x y @ (value_type kty)) z @ (value_type kty)))
+      (rotr ty x (iadd_uextend y z)))
+(rule (simplify (rotl ty (rotl ty x y @ (value_type kty)) z @ (value_type kty)))
+      (rotl ty x (iadd_uextend y z)))
+
+(rule (simplify (rotr ty (rotl ty x y @ (value_type kty)) z @ (value_type kty)))
+      (rotl ty x (isub_uextend y z)))
+(rule (simplify (rotl ty (rotr ty x y @ (value_type kty)) z @ (value_type kty)))
+      (rotr ty x (isub_uextend y z)))
+
+;; Convert shifts into rotates. We always normalize into a rotate left.
+;;
+;; (bor (ishl x k1) (ushr x k2)) == (rotl x k1) if k2 == ty_bits - k1
+;; (bor (ushr x k2) (ishl x k1)) == (rotl x k1) if k2 == ty_bits - k1
+;;
+;; TODO: This rule is restricted to scalars since no backend currently
+;; supports SIMD rotates.
+(rule (simplify (bor (ty_int ty)
+                      (ishl ty x k @ (iconst _ (u64_from_imm64 k1)))
+                      (ushr ty x (iconst _ (u64_from_imm64 k2)))))
+      (if-let $true (u64_eq k2 (u64_sub (ty_bits_u64 (lane_type ty)) k1)))
+      (rotl ty x k))
+(rule (simplify (bor (ty_int ty)
+                      (ushr ty x (iconst _ (u64_from_imm64 k2)))
+                      (ishl ty x k @ (iconst _ (u64_from_imm64 k1)))))
+      (if-let $true (u64_eq k2 (u64_sub (ty_bits_u64 (lane_type ty)) k1)))
+      (rotl ty x k))
+
+;; Normalize the shift amount. Some rules can't fire unless the shift amount
+;; is normalized. This also helps us materialize fewer and smaller constants.
+;;
+;; (op x k) == (op x (and k (ty_shift_mask ty)))
+;;
+;; where `op` is one of ishl, ushr, sshr, rotl, rotr
+(rule (simplify (ishl ty x (iconst_u kty k)))
+      (if-let $false (u64_eq k (u64_and k (ty_shift_mask ty))))
+      (ishl ty x (iconst_u kty (u64_and k (ty_shift_mask ty)))))
+(rule (simplify (ushr ty x (iconst_u kty k)))
+      (if-let $false (u64_eq k (u64_and k (ty_shift_mask ty))))
+      (ushr ty x (iconst_u kty (u64_and k (ty_shift_mask ty)))))
+(rule (simplify (sshr ty x (iconst_u kty k)))
+      (if-let $false (u64_eq k (u64_and k (ty_shift_mask ty))))
+      (sshr ty x (iconst_u kty (u64_and k (ty_shift_mask ty)))))
+(rule (simplify (rotr ty x (iconst_u kty k)))
+      (if-let $false (u64_eq k (u64_and k (ty_shift_mask ty))))
+      (rotr ty x (iconst_u kty (u64_and k (ty_shift_mask ty)))))
+(rule (simplify (rotl ty x (iconst_u kty k)))
+      (if-let $false (u64_eq k (u64_and k (ty_shift_mask ty))))
+      (rotl ty x (iconst_u kty (u64_and k (ty_shift_mask ty)))))
diff --git a/cranelift/codegen/src/opts/spaceship.isle b/cranelift/codegen/src/opts/spaceship.isle
new file mode 100644
index 000000000000..a834aa49e4cf
--- /dev/null
+++ b/cranelift/codegen/src/opts/spaceship.isle
@@ -0,0 +1,194 @@
+;; Simplifications for C++20's `<=>` "spaceship" operator, aka Rust's `Ord::cmp`.
+;;
+;; There's no cranelift instruction for this, nor usually a machine instruction.
+;; Inspired by <https://graphics.stanford.edu/~seander/bithacks.html#CopyIntegerSign>
+;; we canonicalize the various implementations of `x <=> y` to `(x > y) - (x < y)`.
+
+;; Unfortunately, there's at least 3!×2 reasonable ways to write this as nested
+;; selects, and no broad agreement which is the best -- notably Rust 1.74 and
+;; Clang 17 use different sequences -- so we just match all of them.
+
+;; x < y ? -1 : x == y ? 0 : +1
+;; x < y ? -1 : x != y ? +1 : 0
+(rule (simplify (select ty (ult rty x y)
+                           (iconst_s ty -1)
+                           (uextend_maybe ty (ne rty x y))))
+      (sextend_maybe ty (spaceship_u rty x y)))
+;; x < y ? -1 : x <= y ? 0 : +1
+;; x < y ? -1 : x > y ? +1 : 0
+(rule (simplify (select ty (ult rty x y)
+                           (iconst_s ty -1)
+                           (uextend_maybe ty (ugt rty x y))))
+      (sextend_maybe ty (spaceship_u rty x y)))
+
+;; x == y ? 0 : x < y ? -1 : +1
+(rule (simplify (select ty (eq rty x y)
+                           (iconst_s ty 0)
+                           (select ty (ult rty x y)
+                                      (iconst_s ty -1)
+                                      (iconst_s ty 1))))
+      (sextend_maybe ty (spaceship_u rty x y)))
+;; x == y ? 0 : x <= y ? -1 : +1
+(rule (simplify (select ty (eq rty x y)
+                           (iconst_s ty 0)
+                           (select ty (ule rty x y)
+                                      (iconst_s ty -1)
+                                      (iconst_s ty 1))))
+      (sextend_maybe ty (spaceship_u rty x y)))
+;; x == y ? 0 : x > y ? +1 : -1
+(rule (simplify (select ty (eq rty x y)
+                           (iconst_s ty 0)
+                           (select ty (ugt rty x y)
+                                      (iconst_s ty 1)
+                                      (iconst_s ty -1))))
+      (sextend_maybe ty (spaceship_u rty x y)))
+;; x == y ? 0 : x >= y ? +1 : -1
+(rule (simplify (select ty (eq rty x y)
+                           (iconst_s ty 0)
+                           (select ty (uge rty x y)
+                                      (iconst_s ty 1)
+                                      (iconst_s ty -1))))
+      (sextend_maybe ty (spaceship_u rty x y)))
+
+;; x > y ? 1 : x < y ? -1 : 0
+;; x > y ? 1 : x >= y ? 0 : -1
+(rule (simplify (select ty (ugt rty x y)
+                           (iconst_s ty 1)
+                           (ineg rty (ult rty x y))))
+      (sextend_maybe ty (spaceship_u rty x y)))
+(rule (simplify (select ty (ugt rty x y)
+                           (iconst_s ty 1)
+                           (bmask ty (ult rty x y))))
+      (sextend_maybe ty (spaceship_u rty x y)))
+;; x > y ? 1 : x != y ? -1 : 0
+;; x > y ? 1 : x == y ? 0 : -1
+(rule (simplify (select ty (ugt rty x y)
+                           (iconst_s ty 1)
+                           (ineg rty (ne rty x y))))
+      (sextend_maybe ty (spaceship_u rty x y)))
+(rule (simplify (select ty (ugt rty x y)
+                           (iconst_s ty 1)
+                           (bmask ty (ne rty x y))))
+      (sextend_maybe ty (spaceship_u rty x y)))
+
+;; Same, but for signed comparisons this time
+
+;; x < y ? -1 : x == y ? 0 : +1
+;; x < y ? -1 : x != y ? +1 : 0
+(rule (simplify (select ty (slt rty x y)
+                           (iconst_s ty -1)
+                           (uextend_maybe ty (ne rty x y))))
+      (sextend_maybe ty (spaceship_s rty x y)))
+;; x < y ? -1 : x <= y ? 0 : +1
+;; x < y ? -1 : x > y ? +1 : 0
+(rule (simplify (select ty (slt rty x y)
+                           (iconst_s ty -1)
+                           (uextend_maybe ty (sgt rty x y))))
+      (sextend_maybe ty (spaceship_s rty x y)))
+
+;; x == y ? 0 : x < y ? -1 : +1
+(rule (simplify (select ty (eq rty x y)
+                           (iconst_s ty 0)
+                           (select ty (slt rty x y)
+                                      (iconst_s ty -1)
+                                      (iconst_s ty 1))))
+      (sextend_maybe ty (spaceship_s rty x y)))
+;; x == y ? 0 : x <= y ? -1 : +1
+(rule (simplify (select ty (eq rty x y)
+                           (iconst_s ty 0)
+                           (select ty (sle rty x y)
+                                      (iconst_s ty -1)
+                                      (iconst_s ty 1))))
+      (sextend_maybe ty (spaceship_s rty x y)))
+;; x == y ? 0 : x > y ? +1 : -1
+(rule (simplify (select ty (eq rty x y)
+                           (iconst_s ty 0)
+                           (select ty (sgt rty x y)
+                                      (iconst_s ty 1)
+                                      (iconst_s ty -1))))
+      (sextend_maybe ty (spaceship_s rty x y)))
+;; x == y ? 0 : x >= y ? +1 : -1
+(rule (simplify (select ty (eq rty x y)
+                           (iconst_s ty 0)
+                           (select ty (sge rty x y)
+                                      (iconst_s ty 1)
+                                      (iconst_s ty -1))))
+      (sextend_maybe ty (spaceship_s rty x y)))
+
+;; x > y ? 1 : x < y ? -1 : 0
+;; x > y ? 1 : x >= y ? 0 : -1
+(rule (simplify (select ty (sgt rty x y)
+                           (iconst_s ty 1)
+                           (ineg rty (slt rty x y))))
+      (sextend_maybe ty (spaceship_s rty x y)))
+(rule (simplify (select ty (sgt rty x y)
+                           (iconst_s ty 1)
+                           (bmask ty (slt rty x y))))
+      (sextend_maybe ty (spaceship_s rty x y)))
+;; x > y ? 1 : x != y ? -1 : 0
+;; x > y ? 1 : x == y ? 0 : -1
+(rule (simplify (select ty (sgt rty x y)
+                           (iconst_s ty 1)
+                           (ineg rty (ne rty x y))))
+      (sextend_maybe ty (spaceship_s rty x y)))
+(rule (simplify (select ty (sgt rty x y)
+                           (iconst_s ty 1)
+                           (bmask ty (ne rty x y))))
+      (sextend_maybe ty (spaceship_s rty x y)))
+
+;; Then once we have it normalized, we can apply some basic simplifications.
+;; For example, a derived `PartialOrd::lt` on a newtype in Rust will essentially
+;; emit `(a <=> b) < 0`, and replacing that with `a < b` can really help.
+;; `icmp.isle` prefers comparing against zero so we don't need to worry about
+;; also matching things like `(a <=> b) < 1` or `(a <=> b) <= -1`.
+
+;; (a <=> b) == 0 --> a == b
+(rule (simplify (eq _ (spaceship_s ty x y) (iconst_s _ 0)))
+      (eq ty x y))
+(rule (simplify (eq _ (spaceship_u ty x y) (iconst_s _ 0)))
+      (eq ty x y))
+;; (a <=> b) != 0 --> a != b
+(rule (simplify (ne _ (spaceship_s ty x y) (iconst_s _ 0)))
+      (ne ty x y))
+(rule (simplify (ne _ (spaceship_u ty x y) (iconst_s _ 0)))
+      (ne ty x y))
+
+;; (a <=> b) < 0 --> a < b
+(rule (simplify (slt _ (spaceship_s ty x y) (iconst_s _ 0)))
+      (slt ty x y))
+(rule (simplify (slt _ (spaceship_u ty x y) (iconst_s _ 0)))
+      (ult ty x y))
+;; (a <=> b) <= 0 --> a <= b
+(rule (simplify (sle _ (spaceship_s ty x y) (iconst_s _ 0)))
+      (sle ty x y))
+(rule (simplify (sle _ (spaceship_u ty x y) (iconst_s _ 0)))
+      (ule ty x y))
+;; (a <=> b) > 0 --> a > b
+(rule (simplify (sgt _ (spaceship_s ty x y) (iconst_s _ 0)))
+      (sgt ty x y))
+(rule (simplify (sgt _ (spaceship_u ty x y) (iconst_s _ 0)))
+      (ugt ty x y))
+;; (a <=> b) >= 0 --> a >= b
+(rule (simplify (sge _ (spaceship_s ty x y) (iconst_s _ 0)))
+      (sge ty x y))
+(rule (simplify (sge _ (spaceship_u ty x y) (iconst_s _ 0)))
+      (uge ty x y))
+
+;; Rust's `sort_by` uses `compare(a, b) == Less`, which the general icmp rules
+;; can't simplify to a comparison against zero, so catch things like that too.
+(rule (simplify (eq _ (spaceship_s ty x y) (iconst_s _ -1)))
+      (slt ty x y))
+(rule (simplify (eq _ (spaceship_u ty x y) (iconst_s _ -1)))
+      (ult ty x y))
+(rule (simplify (ne _ (spaceship_s ty x y) (iconst_s _ -1)))
+      (sge ty x y))
+(rule (simplify (ne _ (spaceship_u ty x y) (iconst_s _ -1)))
+      (uge ty x y))
+(rule (simplify (eq _ (spaceship_s ty x y) (iconst_s _ 1)))
+      (sgt ty x y))
+(rule (simplify (eq _ (spaceship_u ty x y) (iconst_s _ 1)))
+      (ugt ty x y))
+(rule (simplify (ne _ (spaceship_s ty x y) (iconst_s _ 1)))
+      (sle ty x y))
+(rule (simplify (ne _ (spaceship_u ty x y) (iconst_s _ 1)))
+      (ule ty x y))
diff --git a/cranelift/codegen/src/opts/spectre.isle b/cranelift/codegen/src/opts/spectre.isle
new file mode 100644
index 000000000000..c58e29eaa9fe
--- /dev/null
+++ b/cranelift/codegen/src/opts/spectre.isle
@@ -0,0 +1,14 @@
+;; Rewrites for `select_spectre_guard`. Check these rules carefully! This
+;; instruction prohibits all speculation on the controlling value when
+;; determining which input to use as the result. Rewrites must respect that
+;; requirement.
+
+;; If we statically know which value will be the result, it's safe to just use
+;; that value. No speculation on the controlling value is possible if we simply
+;; don't depend on that value at all.
+(rule (simplify (select_spectre_guard _ _ x x))
+      (subsume x))
+(rule (simplify (select_spectre_guard _ (iconst_u _ (u64_nonzero _)) x _))
+      (subsume x))
+(rule (simplify (select_spectre_guard _ (iconst_u _ 0) _ y))
+      (subsume y))
diff --git a/cranelift/codegen/src/opts/vector.isle b/cranelift/codegen/src/opts/vector.isle
index fd47fe69c41b..5ad57d8dc604 100644
--- a/cranelift/codegen/src/opts/vector.isle
+++ b/cranelift/codegen/src/opts/vector.isle
@@ -1,8 +1,9 @@
 ;; For various ops lift a splat outside of the op to try to open up
 ;; optimization opportunities with scalars.
-;;
+
 ;; NB: for int-to-float conversion op this simplification is also
-;; required for correctness at this time due to #6562
+;; required for the x64 backend because it doesn't fully implement int-to-float
+;; conversions for 64x2 vectors, for more information see #6562
 (rule (simplify (fcvt_from_uint float_vector_ty (splat _ x)))
       (splat float_vector_ty (fcvt_from_uint (lane_type float_vector_ty) x)))
 (rule (simplify (fcvt_from_sint float_vector_ty (splat _ x)))
diff --git a/cranelift/codegen/src/prelude.isle b/cranelift/codegen/src/prelude.isle
index da37334b1d12..14f6fc201e2b 100644
--- a/cranelift/codegen/src/prelude.isle
+++ b/cranelift/codegen/src/prelude.isle
@@ -8,12 +8,17 @@
 
 ;; `()`
 (type Unit (primitive Unit))
+; TODO(mbm): support unit model
+(model Unit (type (bv 1)))
 
 (decl pure unit () Unit)
 (extern constructor unit unit)
 
+(model bool (type Bool))
 (type bool (primitive bool))
+(model true (const true))
 (extern const $true bool)
+(model false (const false))
 (extern const $false bool)
 
 (type u8 (primitive u8))
@@ -23,6 +28,12 @@
 (type u128 (primitive u128))
 (type usize (primitive usize))
 
+(model u8 (type (bv 8)))
+(model u16 (type (bv 16)))
+(model u32 (type (bv 32)))
+(model u64 (type (bv 64)))
+(model usize (type Int))
+
 (type i8 (primitive i8))
 (type i16 (primitive i16))
 (type i32 (primitive i32))
@@ -30,9 +41,17 @@
 (type i128 (primitive i128))
 (type isize (primitive isize))
 
+(model i8 (type (bv 8)))
+(model i16 (type (bv 16)))
+(model i32 (type (bv 32)))
+(model i64 (type (bv 64)))
+(model isize (type Int))
+
 ;; `cranelift-entity`-based identifiers.
 (type Type (primitive Type))
+(model Type (type (struct (bits Int))))
 (type Value (primitive Value))
+(model Value (type (bv)))
 (type ValueList (primitive ValueList))
 (type BlockCall (primitive BlockCall))
 
@@ -42,6 +61,7 @@
 ;; Extract the type of a `Value`.
 (decl value_type (Type) Value)
 (extern extractor infallible value_type value_type)
+(spec (value_type ty) (provide (= (:bits ty) (widthof result))))
 
 ;; Extractor that matches a `u32` only if non-negative.
 (decl u32_nonnegative (u32) u32)
@@ -55,6 +75,10 @@
 ;; Pure/fallible constructor that tests if one u32 is less than or
 ;; equal to another.
 (decl pure partial u32_lteq (u32 u32) Unit)
+(spec (u32_lteq a b)
+      (provide (= result #b1))
+      (match (bvule a b))
+)
 (extern constructor u32_lteq u32_lteq)
 
 ;; Pure/fallible constructor that tests if one u8 is less than or
@@ -67,20 +91,15 @@
 (decl pure partial u8_lt (u8 u8) Unit)
 (extern constructor u8_lt u8_lt)
 
-;; Get a signed 32-bit immediate in an u32 from an Imm64, if possible.
-(decl simm32 (i32) Imm64)
-(extern extractor simm32 simm32)
-
-;; Get an unsigned 8-bit immediate in a u8 from an Imm64, if possible.
-(decl uimm8 (u8) Imm64)
-(extern extractor uimm8 uimm8)
-
 ;;;; Primitive Type Conversions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (decl pure u8_as_i8 (u8) i8)
 (extern constructor u8_as_i8 u8_as_i8)
 
 (decl pure u8_as_u32 (u8) u32)
+(spec (u8_as_u32 arg)
+      (provide (= result (zero_ext 32 arg)))
+)
 (extern constructor u8_as_u32 u8_as_u32)
 (convert u8 u32 u8_as_u32)
 
@@ -88,29 +107,80 @@
 (extern constructor u8_as_u64 u8_as_u64)
 (convert u8 u64 u8_as_u64)
 
+(decl pure u16_as_i16 (u16) i16)
+(extern constructor u16_as_i16 u16_as_i16)
+
+(decl pure u16_as_u32 (u16) u32)
+(extern constructor u16_as_u32 u16_as_u32)
+(convert u16 u32 u16_as_u32)
+(spec (u16_as_u32 n) (provide (= result (zero_ext 32 n))))
+
 (decl pure u16_as_u64 (u16) u64)
 (extern constructor u16_as_u64 u16_as_u64)
 (convert u16 u64 u16_as_u64)
+(spec (u16_as_u64 n) (provide (= result (zero_ext 64 n))))
+
+(decl pure u64_as_u8 (u64) u8)
+(extern constructor u64_as_u8 u64_as_u8)
+
+(decl pure u64_as_u16 (u64) u16)
+(extern constructor u64_as_u16 u64_as_u16)
+
+(decl pure u64_as_i64 (u64) i64)
+(extern constructor u64_as_i64 u64_as_i64)
+
+(decl pure partial u16_try_from_u64 (u64) u16)
+(extern constructor u16_try_from_u64 u16_try_from_u64)
+
+(decl pure partial u32_try_from_u64 (u64) u32)
+(extern constructor u32_try_from_u64 u32_try_from_u64)
+
+(decl pure partial i8_try_from_u64 (u64) i8)
+(extern constructor i8_try_from_u64 i8_try_from_u64)
+
+(decl pure partial i16_try_from_u64 (u64) i16)
+(extern constructor i16_try_from_u64 i16_try_from_u64)
+
+(decl pure partial i32_try_from_u64 (u64) i32)
+(extern constructor i32_try_from_u64 i32_try_from_u64)
 
 (decl pure u32_as_u64 (u32) u64)
 (extern constructor u32_as_u64 u32_as_u64)
 (convert u32 u64 u32_as_u64)
+(spec (u32_as_u64 n) (provide (= result (zero_ext 64 n))))
 
 (decl pure i32_as_i64 (i32) i64)
 (extern constructor i32_as_i64 i32_as_i64)
 (convert i32 i64 i32_as_i64)
+(spec (i32_as_i64 arg) (provide (= result (sign_ext 64 arg))))
 
 (decl pure i64_as_u64 (i64) u64)
 (extern constructor i64_as_u64 i64_as_u64)
+(spec (i64_as_u64 arg) (provide (= arg result)))
 
 (decl pure i64_neg (i64) i64)
 (extern constructor i64_neg i64_neg)
+(spec (i64_neg x) (provide (= result (bvneg x))))
+
+(decl pure i8_neg (i8) i8)
+(extern constructor i8_neg i8_neg)
 
 (decl u128_as_u64 (u64) u128)
 (extern extractor u128_as_u64 u128_as_u64)
 
 (decl u64_as_u32 (u32) u64)
 (extern extractor u64_as_u32 u64_as_u32)
+(spec (u64_as_u32 arg)
+      (match (= result (bvand result #x00000000ffffffff)))
+      (provide (= result (zero_ext 64 arg)))
+)
+
+(decl u32_as_u16 (u16) u32)
+(extern extractor u32_as_u16 u32_as_u16)
+(spec (u32_as_u16 arg)
+      (match (= result (bvand result #x0000ffff)))
+      (provide (= result (zero_ext 32 arg)))
+)
 
 (decl pure u64_as_i32 (u64) i32)
 (extern constructor u64_as_i32 u64_as_i32)
@@ -138,9 +208,15 @@
 (decl pure u32_and (u32 u32) u32)
 (extern constructor u32_and u32_and)
 
+(decl pure u32_shl (u32 u32) u32)
+(extern constructor u32_shl u32_shl)
+
 ;; Pure/fallible constructor that tries to add two `u32`s, interpreted
 ;; as signed values, and fails to match on overflow.
 (decl pure partial s32_add_fallible (i32 i32) i32)
+(spec (s32_add_fallible x y)
+      (provide (= result (bvadd x y)))
+      (match (not (bvsaddo x y))))
 (extern constructor s32_add_fallible s32_add_fallible)
 
 (decl pure u64_add (u64 u64) u64)
@@ -148,6 +224,7 @@
 
 (decl pure u64_sub (u64 u64) u64)
 (extern constructor u64_sub u64_sub)
+(spec (u64_sub x y) (provide (= result (bvsub x y))))
 
 (decl pure u64_mul (u64 u64) u64)
 (extern constructor u64_mul u64_mul)
@@ -169,6 +246,7 @@
 
 (decl pure u64_shl (u64 u64) u64)
 (extern constructor u64_shl u64_shl)
+(spec (u64_shl x y) (provide (= result (bvshl x y))))
 
 (decl pure imm64_shl (Type Imm64 Imm64) Imm64)
 (extern constructor imm64_shl imm64_shl)
@@ -184,6 +262,7 @@
 
 (decl pure u64_eq (u64 u64) bool)
 (extern constructor u64_eq u64_eq)
+(spec (u64_eq x y) (provide (= result (= x y))))
 
 (decl pure u64_le (u64 u64) bool)
 (extern constructor u64_le u64_le)
@@ -203,6 +282,7 @@
 
 (decl pure i64_sextend_imm64 (Type Imm64) i64)
 (extern constructor i64_sextend_imm64 i64_sextend_imm64)
+(spec (i64_sextend_imm64 ty a) (provide (= result (sign_ext 64 (conv_to (:bits ty) a)))))
 
 (decl pure u64_uextend_imm64 (Type Imm64) u64)
 (extern constructor u64_uextend_imm64 u64_uextend_imm64)
@@ -213,14 +293,21 @@
 (decl u64_is_zero (bool) u64)
 (extern extractor infallible u64_is_zero u64_is_zero)
 
+(decl i64_is_zero (bool) i64)
+(extern extractor infallible i64_is_zero i64_is_zero)
+
 (decl u64_zero () u64)
 (extractor (u64_zero) (u64_is_zero $true))
 
 (decl u64_nonzero (u64) u64)
 (extractor (u64_nonzero x) (and (u64_is_zero $false) x))
 
+(decl i64_nonzero (i64) i64)
+(extractor (i64_nonzero x) (and (i64_is_zero $false) x))
+
 (decl pure u64_is_odd (u64) bool)
 (extern constructor u64_is_odd u64_is_odd)
+(spec (u64_is_odd x) (provide (= result (= (conv_to 1 x) #b1))))
 
 ;; Each of these extractors tests whether the upper half of the input equals the
 ;; lower half of the input
@@ -233,22 +320,109 @@
 (decl u16_replicated_u8 (u8) u64)
 (extern extractor u16_replicated_u8 u16_replicated_u8)
 
+;; Floating point operations
+
+(decl pure partial f16_min (Ieee16 Ieee16) Ieee16)
+(extern constructor f16_min f16_min)
+(decl pure partial f16_max (Ieee16 Ieee16) Ieee16)
+(extern constructor f16_max f16_max)
+(decl pure f16_neg (Ieee16) Ieee16)
+(extern constructor f16_neg f16_neg)
+(decl pure f16_abs (Ieee16) Ieee16)
+(extern constructor f16_abs f16_abs)
+(decl pure f16_copysign (Ieee16 Ieee16) Ieee16)
+(extern constructor f16_copysign f16_copysign)
+(decl pure partial f32_add (Ieee32 Ieee32) Ieee32)
+(extern constructor f32_add f32_add)
+(decl pure partial f32_sub (Ieee32 Ieee32) Ieee32)
+(extern constructor f32_sub f32_sub)
+(decl pure partial f32_mul (Ieee32 Ieee32) Ieee32)
+(extern constructor f32_mul f32_mul)
+(decl pure partial f32_div (Ieee32 Ieee32) Ieee32)
+(extern constructor f32_div f32_div)
+(decl pure partial f32_sqrt (Ieee32) Ieee32)
+(extern constructor f32_sqrt f32_sqrt)
+(decl pure partial f32_ceil (Ieee32) Ieee32)
+(extern constructor f32_ceil f32_ceil)
+(decl pure partial f32_floor (Ieee32) Ieee32)
+(extern constructor f32_floor f32_floor)
+(decl pure partial f32_trunc (Ieee32) Ieee32)
+(extern constructor f32_trunc f32_trunc)
+(decl pure partial f32_nearest (Ieee32) Ieee32)
+(extern constructor f32_nearest f32_nearest)
+(decl pure partial f32_min (Ieee32 Ieee32) Ieee32)
+(extern constructor f32_min f32_min)
+(decl pure partial f32_max (Ieee32 Ieee32) Ieee32)
+(extern constructor f32_max f32_max)
+(decl pure f32_neg (Ieee32) Ieee32)
+(extern constructor f32_neg f32_neg)
+(decl pure f32_abs (Ieee32) Ieee32)
+(extern constructor f32_abs f32_abs)
+(decl pure f32_copysign (Ieee32 Ieee32) Ieee32)
+(extern constructor f32_copysign f32_copysign)
+(decl pure partial f64_add (Ieee64 Ieee64) Ieee64)
+(extern constructor f64_add f64_add)
+(decl pure partial f64_sub (Ieee64 Ieee64) Ieee64)
+(extern constructor f64_sub f64_sub)
+(decl pure partial f64_mul (Ieee64 Ieee64) Ieee64)
+(extern constructor f64_mul f64_mul)
+(decl pure partial f64_div (Ieee64 Ieee64) Ieee64)
+(extern constructor f64_div f64_div)
+(decl pure partial f64_sqrt (Ieee64) Ieee64)
+(extern constructor f64_sqrt f64_sqrt)
+(decl pure partial f64_ceil (Ieee64) Ieee64)
+(extern constructor f64_ceil f64_ceil)
+(decl pure partial f64_floor (Ieee64) Ieee64)
+(extern constructor f64_floor f64_floor)
+(decl pure partial f64_trunc (Ieee64) Ieee64)
+(extern constructor f64_trunc f64_trunc)
+(decl pure partial f64_nearest (Ieee64) Ieee64)
+(extern constructor f64_nearest f64_nearest)
+(decl pure partial f64_min (Ieee64 Ieee64) Ieee64)
+(extern constructor f64_min f64_min)
+(decl pure partial f64_max (Ieee64 Ieee64) Ieee64)
+(extern constructor f64_max f64_max)
+(decl pure f64_neg (Ieee64) Ieee64)
+(extern constructor f64_neg f64_neg)
+(decl pure f64_abs (Ieee64) Ieee64)
+(extern constructor f64_abs f64_abs)
+(decl pure f64_copysign (Ieee64 Ieee64) Ieee64)
+(extern constructor f64_copysign f64_copysign)
+(decl pure partial f128_min (Ieee128 Ieee128) Ieee128)
+(extern constructor f128_min f128_min)
+(decl pure partial f128_max (Ieee128 Ieee128) Ieee128)
+(extern constructor f128_max f128_max)
+(decl pure f128_neg (Ieee128) Ieee128)
+(extern constructor f128_neg f128_neg)
+(decl pure f128_abs (Ieee128) Ieee128)
+(extern constructor f128_abs f128_abs)
+(decl pure f128_copysign (Ieee128 Ieee128) Ieee128)
+(extern constructor f128_copysign f128_copysign)
+(type Ieee128 (primitive Ieee128))
+
 ;;;; `cranelift_codegen::ir::Type` ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (extern const $I8 Type)
+(model I8 (const (struct (bits 8))))
 (extern const $I16 Type)
+(model I16 (const (struct (bits 16))))
 (extern const $I32 Type)
+(model I32 (const (struct (bits 32))))
 (extern const $I64 Type)
+(model I64 (const (struct (bits 64))))
 (extern const $I128 Type)
+(model I128 (const (struct (bits 128))))
 
-(extern const $R32 Type)
-(extern const $R64 Type)
-
+(extern const $F16 Type)
 (extern const $F32 Type)
+(model F32 (const (struct (bits 32))))
 (extern const $F64 Type)
+(model F64 (const (struct (bits 64))))
+(extern const $F128 Type)
 
 (extern const $I8X8 Type)
 (extern const $I8X16 Type)
+(model I8X16 (const (struct (bits 128))))
 (extern const $I16X4 Type)
 (extern const $I16X8 Type)
 (extern const $I32X2 Type)
@@ -278,10 +452,12 @@
 (extern constructor ty_smax ty_smax)
 
 ;; Get the bit width of a given type.
+(spec (ty_bits ty) (provide (= result (int2bv 8 (:bits ty)))))
 (decl pure ty_bits (Type) u8)
 (extern constructor ty_bits ty_bits)
 
 ;; Get the bit width of a given type.
+(spec (ty_bits_u16 ty) (provide (= result (int2bv 16 (:bits ty)))))
 (decl pure ty_bits_u16 (Type) u16)
 (extern constructor ty_bits_u16 ty_bits_u16)
 
@@ -304,6 +480,7 @@
 ;; Get the byte width of a given type.
 (decl pure ty_bytes (Type) u16)
 (extern constructor ty_bytes ty_bytes)
+(spec (ty_bytes ty) (provide (= result (bits2bytes! (int2bv 16 (:bits ty))))))
 
 ;; Get the type of each lane in the given type.
 (decl pure lane_type (Type) Type)
@@ -317,6 +494,10 @@
 (decl pure partial ty_half_width (Type) Type)
 (extern constructor ty_half_width ty_half_width)
 
+;; Generate a mask for the maximum shift amount for a given type. i.e 31 for I32.
+(decl pure ty_shift_mask (Type) u64)
+(rule (ty_shift_mask ty) (u64_sub (ty_bits (lane_type ty)) 1))
+
 ;; Compare two types for equality.
 (decl pure ty_equal (Type Type) bool)
 (extern constructor ty_equal ty_equal)
@@ -325,6 +506,9 @@
 
 ;; `MemFlags::trusted`
 (decl pure mem_flags_trusted () MemFlags)
+(spec (mem_flags_trusted)
+      (provide (:aligned result) (= (:trapcode result) #b1111))
+)
 (extern constructor mem_flags_trusted mem_flags_trusted)
 
 ;;;; Helpers for Working with Flags ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -337,6 +521,12 @@
 (decl intcc_complement (IntCC) IntCC)
 (extern constructor intcc_complement intcc_complement)
 
+;; This is a direct import of `IntCC::without_equal`.
+;; Get the corresponding IntCC with the equal component removed.
+;; For conditions without a zero component, this is a no-op.
+(decl pure intcc_without_eq (IntCC) IntCC)
+(extern constructor intcc_without_eq intcc_without_eq)
+
 ;; Swap args of a FloatCC flag.
 (decl floatcc_swap_args (FloatCC) FloatCC)
 (extern constructor floatcc_swap_args floatcc_swap_args)
@@ -383,11 +573,17 @@
 
 ;; An extractor that only matches types that can fit in 16 bits.
 (decl fits_in_16 (Type) Type)
+(spec (fits_in_16 ty)
+      (provide (= result ty))
+      (match (<= (:bits result) 16)))
 (extern extractor fits_in_16 fits_in_16)
 
 ;; An extractor that only matches types that can fit in 32 bits.
 (decl fits_in_32 (Type) Type)
 (extern extractor fits_in_32 fits_in_32)
+(spec (fits_in_32 ty)
+      (provide (= result ty))
+      (match (<= (:bits result) 32)))
 
 ;; An extractor that only matches types that can fit in 32 bits.
 (decl lane_fits_in_32 (Type) Type)
@@ -395,6 +591,9 @@
 
 ;; An extractor that only matches types that can fit in 64 bits.
 (decl fits_in_64 (Type) Type)
+(spec (fits_in_64 ty)
+      (provide (= result ty))
+      (match (<= (:bits result) 64)))
 (extern extractor fits_in_64 fits_in_64)
 
 ;; An extractor that only matches types that fit in exactly 32 bits.
@@ -407,23 +606,38 @@
 
 ;; A pure constructor/extractor that only matches scalar integers, and
 ;; references that can fit in 64 bits.
+(spec (ty_int_ref_scalar_64 ty)
+      (provide (= result ty))
+      (match
+            (or
+                  (= (:bits ty) 8)
+                  (= (:bits ty) 16)
+                  (= (:bits ty) 32)
+                  (= (:bits ty) 64))))
 (decl pure partial ty_int_ref_scalar_64 (Type) Type)
 (extern constructor ty_int_ref_scalar_64 ty_int_ref_scalar_64)
 (extern extractor ty_int_ref_scalar_64 ty_int_ref_scalar_64_extract)
 
 ;; An extractor that matches 32- and 64-bit types only.
 (decl ty_32_or_64 (Type) Type)
+(spec (ty_32_or_64 ty)
+      (provide (= result ty))
+      (match (or (= (:bits result) 32) (= (:bits result) 64))))
 (extern extractor ty_32_or_64 ty_32_or_64)
 
 ;; An extractor that matches 8- and 16-bit types only.
 (decl ty_8_or_16 (Type) Type)
 (extern extractor ty_8_or_16 ty_8_or_16)
 
+;; An extractor that matches 16- and 32-bit types only.
+(decl ty_16_or_32 (Type) Type)
+(extern extractor ty_16_or_32 ty_16_or_32)
+
 ;; An extractor that matches int types that fit in 32 bits.
 (decl int_fits_in_32 (Type) Type)
 (extern extractor int_fits_in_32 int_fits_in_32)
 
-;; An extractor that matches I64 or R64.
+;; An extractor that matches I64.
 (decl ty_int_ref_64 (Type) Type)
 (extern extractor ty_int_ref_64 ty_int_ref_64)
 
@@ -434,6 +648,7 @@
 ;; An extractor that only matches integers.
 (decl ty_int (Type) Type)
 (extern extractor ty_int ty_int)
+(spec (ty_int arg) (provide (= arg result)))
 
 ;; An extractor that only matches scalar types, float or int or ref's.
 (decl ty_scalar (Type) Type)
@@ -442,10 +657,16 @@
 ;; An extractor that only matches scalar floating-point types--F32 or F64.
 (decl ty_scalar_float (Type) Type)
 (extern extractor ty_scalar_float ty_scalar_float)
+(spec (ty_scalar_float ty)
+      (provide (= result ty))
+      (match (or (= (:bits result) 32) (= (:bits result) 64))))
 
 ;; An extractor that matches scalar floating-point types or vector types.
 (decl ty_float_or_vec (Type) Type)
 (extern extractor ty_float_or_vec ty_float_or_vec)
+(spec (ty_float_or_vec ty)
+      (provide (= result ty))
+      (match (or (= (:bits result) 32) (= (:bits result) 64) (= (:bits result) 128))))
 
 ;; A pure constructor that only matches vector floating-point types.
 (decl pure partial ty_vector_float (Type) Type)
@@ -460,15 +681,18 @@
 (decl pure partial ty_vec64 (Type) Type)
 (extern constructor ty_vec64 ty_vec64_ctor)
 (extern extractor ty_vec64 ty_vec64)
+(attr ty_vec64 (tag vector))
 
 ;; An extractor that only matches 128-bit vector types.
 (decl ty_vec128 (Type) Type)
 (extern extractor ty_vec128 ty_vec128)
+(attr ty_vec128 (tag vector))
 
 ;; An extractor that only matches dynamic vector types with a 64-bit
 ;; base type.
 (decl ty_dyn_vec64 (Type) Type)
 (extern extractor ty_dyn_vec64 ty_dyn_vec64)
+(attr ty_dyn_vec64 (tag vector))
 
 ;; An extractor that only matches dynamic vector types with a 128-bit
 ;; base type.
@@ -508,10 +732,15 @@
 ;; Extract a `u64` from an `Imm64`.
 (decl u64_from_imm64 (u64) Imm64)
 (extern extractor infallible u64_from_imm64 u64_from_imm64)
+(spec (u64_from_imm64 arg) (provide (= arg result)))
 
 ;; Extract a `u64` from an `Imm64` which is not zero.
 (decl nonzero_u64_from_imm64 (u64) Imm64)
 (extern extractor nonzero_u64_from_imm64 nonzero_u64_from_imm64)
+(spec (nonzero_u64_from_imm64 n)
+      (provide (= n result))
+      (match (not (bv_is_zero! result)))
+)
 
 ;; If the given `Imm64` is a power-of-two, extract its log2 value.
 (decl imm64_power_of_two (u64) Imm64)
@@ -525,13 +754,19 @@
 (decl pure imm64_masked (Type u64) Imm64)
 (extern constructor imm64_masked imm64_masked)
 
-;; Extract a `u64` from an `Ieee32`.
+;; Extract a `u16` from an `Ieee16`.
+(decl u16_from_ieee16 (u16) Ieee16)
+(extern extractor infallible u16_from_ieee16 u16_from_ieee16)
+
+;; Extract a `u32` from an `Ieee32`.
 (decl u32_from_ieee32 (u32) Ieee32)
 (extern extractor infallible u32_from_ieee32 u32_from_ieee32)
+(spec (u32_from_ieee32 arg) (provide (= result arg)))
 
 ;; Extract a `u64` from an `Ieee64`.
 (decl u64_from_ieee64 (u64) Ieee64)
 (extern extractor infallible u64_from_ieee64 u64_from_ieee64)
+(spec (u64_from_ieee64 arg) (provide (= result arg)))
 
 ;; Match a multi-lane type, extracting (# bits per lane, # lanes) from the given
 ;; type. Will only match when there is more than one lane.
@@ -543,16 +778,6 @@
 (decl dynamic_lane (u32 u32) Type)
 (extern extractor dynamic_lane dynamic_lane)
 
-;; Match a dynamic-lane integer type, extracting (# bits per lane) from the given
-;; type.
-(decl dynamic_int_lane (u32) Type)
-(extern extractor dynamic_int_lane dynamic_int_lane)
-
-;; Match a dynamic-lane floating point type, extracting (# bits per lane)
-;; from the given type.
-(decl dynamic_fp_lane (u32) Type)
-(extern extractor dynamic_fp_lane dynamic_fp_lane)
-
 ;; An extractor that only matches 64-bit dynamic vector types with integer
 ;; lanes (I8X8XN, I16X4XN, I32X2XN)
 (decl ty_dyn64_int (Type) Type)
@@ -565,10 +790,12 @@
 
 ;; Convert an `Offset32` to a primitive number.
 (decl pure offset32_to_i32 (Offset32) i32)
+(spec (offset32_to_i32 offset) (provide (= result offset)))
 (extern constructor offset32_to_i32 offset32_to_i32)
 
 ;; Convert a number to an `Offset32`
 (decl pure i32_to_offset32 (i32) Offset32)
+(spec (i32_to_offset32 x) (provide (= result x)))
 (extern constructor i32_to_offset32 i32_to_offset32)
 
 ;; This is a direct import of `IntCC::unsigned`.
@@ -576,21 +803,60 @@
 ;; For conditions without a signed component, this is a no-op.
 (decl pure intcc_unsigned (IntCC) IntCC)
 (extern constructor intcc_unsigned intcc_unsigned)
+(spec (intcc_unsigned cc)
+      (provide
+            (= result
+                  (match cc
+                        ((Equal) (IntCC.Equal))
+                        ((NotEqual) (IntCC.NotEqual))
+                        ((SignedGreaterThanOrEqual) (IntCC.UnsignedGreaterThanOrEqual))
+                        ((SignedGreaterThan) (IntCC.UnsignedGreaterThan))
+                        ((SignedLessThanOrEqual) (IntCC.UnsignedLessThanOrEqual))
+                        ((SignedLessThan) (IntCC.UnsignedLessThan))
+                        ((UnsignedGreaterThanOrEqual) (IntCC.UnsignedGreaterThanOrEqual))
+                        ((UnsignedGreaterThan) (IntCC.UnsignedGreaterThan))
+                        ((UnsignedLessThanOrEqual) (IntCC.UnsignedLessThanOrEqual))
+                        ((UnsignedLessThan) (IntCC.UnsignedLessThan))
+                  )
+            )
+      )
+)
 
 ;; Pure constructor that only matches signed integer cond codes.
 (decl pure partial signed_cond_code (IntCC) IntCC)
 (extern constructor signed_cond_code signed_cond_code)
+(spec (signed_cond_code cc)
+      (match
+            (match cc
+                  ((Equal) false)
+                  ((NotEqual) false)
+                  ((SignedGreaterThanOrEqual) true)
+                  ((SignedGreaterThan) true)
+                  ((SignedLessThanOrEqual) true)
+                  ((SignedLessThan) true)
+                  ((UnsignedGreaterThanOrEqual) false)
+                  ((UnsignedGreaterThan) false)
+                  ((UnsignedLessThanOrEqual) false)
+                  ((UnsignedLessThan) false)
+            )
+      )
+      (provide (= result cc))
+)
 
 ;;;; Helpers for Working with TrapCode ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (decl pure trap_code_division_by_zero () TrapCode)
 (extern constructor trap_code_division_by_zero trap_code_division_by_zero)
+(spec (trap_code_division_by_zero) (provide (= result (TrapCode.IntegerDivisionByZero))))
 
 (decl pure trap_code_integer_overflow () TrapCode)
 (extern constructor trap_code_integer_overflow trap_code_integer_overflow)
+(spec (trap_code_integer_overflow) (provide (= result (TrapCode.IntegerOverflow))))
 
 (decl pure trap_code_bad_conversion_to_integer () TrapCode)
 (extern constructor trap_code_bad_conversion_to_integer trap_code_bad_conversion_to_integer)
+(spec (trap_code_bad_conversion_to_integer)
+      (provide (= result (TrapCode.BadConversionToInteger))))
 
 ;;;; Helpers for tail recursion loops ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
diff --git a/cranelift/codegen/src/prelude_lower.isle b/cranelift/codegen/src/prelude_lower.isle
index 99aab0a4ea6e..0e31f731d231 100644
--- a/cranelift/codegen/src/prelude_lower.isle
+++ b/cranelift/codegen/src/prelude_lower.isle
@@ -5,15 +5,26 @@
 
 ;; `cranelift-entity`-based identifiers.
 (type Inst (primitive Inst))
+(model Inst (type (bv)))
 
 ;; ISLE representation of `Vec<u8>`
 (type VecMask extern (enum))
 
 (type ValueRegs (primitive ValueRegs))
+(model ValueRegs
+      (type
+            (struct
+                  (lo (named Reg))
+                  (hi (named Reg))
+            )
+      )
+)
+
 (type WritableValueRegs (primitive WritableValueRegs))
 
 ;; Instruction lowering result: a vector of `ValueRegs`.
 (type InstOutput (primitive InstOutput))
+(model InstOutput (type (bv)))
 ;; (Mutable) builder to incrementally construct an `InstOutput`.
 (type InstOutputBuilder extern (enum))
 
@@ -30,14 +41,19 @@
 ;;;; Registers ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (type Reg (primitive Reg))
+
 (type WritableReg (primitive WritableReg))
+(model WritableReg (type (bv)))
 (type OptionWritableReg (primitive OptionWritableReg))
 (type VecReg extern (enum))
 (type VecWritableReg extern (enum))
 (type PReg (primitive PReg))
+(model PReg (type (bv)))
 
 ;; Construct a `ValueRegs` of one register.
 (decl value_reg (Reg) ValueRegs)
+(spec (value_reg arg)
+    (provide (= (:lo result) arg)))
 (extern constructor value_reg value_reg)
 
 ;; Construct a `WritableValueRegs` of one register.
@@ -46,6 +62,11 @@
 
 ;; Construct a `ValueRegs` of two registers.
 (decl value_regs (Reg Reg) ValueRegs)
+(spec (value_regs arg1 arg2)
+  (provide
+    (= (:lo result) arg1)
+    (= (:hi result) arg2)))
+
 (extern constructor value_regs value_regs)
 
 ;; Construct a `WritableValueRegs` of two registers.
@@ -59,9 +80,22 @@
 ;; Construct an empty `InstOutput`.
 (decl output_none () InstOutput)
 (extern constructor output_none output_none)
+(spec (output_none) (provide (= result #b1)))
 
 ;; Construct a single-element `InstOutput`.
 (decl output (ValueRegs) InstOutput)
+(spec (output arg)
+      (provide
+            ; Two input registers are the same width.
+            (= (widthof (:lo arg)) (widthof (:hi arg)))
+
+            ; Output is the concatenation of the two registers.
+            (let
+                  ((cat (concat (:hi arg) (:lo arg))))
+                  (= cat (conv_to (widthof cat) result))
+            )
+      )
+)
 (extern constructor output output)
 
 ;; Construct a two-element `InstOutput`.
@@ -70,7 +104,7 @@
 
 ;; Construct a single-element `InstOutput` from a single register.
 (decl output_reg (Reg) InstOutput)
-(rule (output_reg reg) (output (value_reg reg)))
+(rule output_reg (output_reg reg) (output (value_reg reg)))
 
 ;; Construct a single-element `InstOutput` from a value.
 (decl output_value (Value) InstOutput)
@@ -90,6 +124,7 @@
 
 ;; Get a temporary register for writing.
 (decl temp_writable_reg (Type) WritableReg)
+(spec (temp_writable_reg ty) (provide (= (:bits ty) (widthof result))))
 (extern constructor temp_writable_reg temp_writable_reg)
 
 ;; Get a temporary register for reading.
@@ -120,6 +155,10 @@
 ;;
 ;; As a side effect, this marks the value as used.
 (decl put_in_reg (Value) Reg)
+(spec (put_in_reg arg)
+      (provide (= result (conv_to 64 arg)))
+      (require (<= (widthof arg) 64))
+)
 (extern constructor put_in_reg put_in_reg)
 
 ;; Put the given value into one or more registers.
@@ -127,6 +166,12 @@
 ;; As a side effect, this marks the value as used.
 (decl put_in_regs (Value) ValueRegs)
 (extern constructor put_in_regs put_in_regs)
+(spec (put_in_regs arg)
+      (provide
+            (= (:lo result) (extract  63  0 (conv_to 128 arg)))
+            (= (:hi result) (extract 127 64 (conv_to 128 arg)))
+      )
+)
 
 ;; If the given reg is a real register, cause the value in reg to be in a virtual
 ;; reg, by copying it into a new virtual reg.
@@ -135,6 +180,14 @@
 
 ;; Get the `n`th register inside a `ValueRegs`.
 (decl value_regs_get (ValueRegs usize) Reg)
+(spec (value_regs_get regs index)
+      (provide
+            (= result (switch index
+                  (0 (:lo regs))
+                  (1 (:hi regs))
+            ))
+      )
+)
 (extern constructor value_regs_get value_regs_get)
 
 ;; Get the number of registers in a `ValueRegs`.
@@ -152,7 +205,7 @@
 ;; the shift amount to the bit width of the value being shifted, and so the high
 ;; half of the `i128` won't ever be used.
 ;;
-;; As a side efect, this marks that value as used.
+;; As a side effect, this marks that value as used.
 (decl lo_reg (Value) Reg)
 (rule (lo_reg val)
       (let ((regs ValueRegs (put_in_regs val)))
@@ -165,6 +218,7 @@
 ;; Convert a MultiReg with three registers into an InstOutput containing
 ;; one ValueRegs containing the first two regs and one containing the third reg
 (decl multi_reg_to_pair_and_single (MultiReg) InstOutput)
+(attr multi_reg_to_pair_and_single (veri chain))
 (rule (multi_reg_to_pair_and_single (MultiReg.Three a b c))
       (output_pair (value_regs a b) c))
 
@@ -178,19 +232,32 @@
 (rule (multi_reg_to_single (MultiReg.One a))
       (value_reg a))
 
+;; Add a range fact to a register, when compiling with
+;; proof-carrying-code enabled.
+(decl add_range_fact (Reg u16 u64 u64) Reg)
+(spec (add_range_fact reg bit_width min max) (provide (= result reg)))
+(extern constructor add_range_fact add_range_fact)
+
 ;;;; Common Mach Types ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (type MachLabel (primitive MachLabel))
+(model MachLabel (type !))
 (type ValueLabel (primitive ValueLabel))
 (type UnwindInst (primitive UnwindInst))
+(model UnwindInst (type (bv)))
 (type ExternalName (primitive ExternalName))
+(model ExternalName (type !))
 (type BoxExternalName (primitive BoxExternalName))
+(model BoxExternalName (type (bv)))
 (type RelocDistance (primitive RelocDistance))
 (type VecArgPair extern (enum))
+(model VecArgPair (type !))
 (type VecRetPair extern (enum))
+(model VecRetPair (type !))
 (type CallArgList extern (enum))
 (type MachLabelSlice extern (enum))
 (type BoxVecMachLabel extern (enum))
+(model BoxVecMachLabel (type !))
 
 ;; Extract a the target from a MachLabelSlice with exactly one target.
 (decl single_target (MachLabel) MachLabelSlice)
@@ -244,6 +311,7 @@
 
 ;; Turn a `Writable<Reg>` into a `Reg` via `Writable::to_reg`.
 (decl pure writable_reg_to_reg (WritableReg) Reg)
+(spec (writable_reg_to_reg reg) (provide (= result reg)))
 (extern constructor writable_reg_to_reg writable_reg_to_reg)
 
 ;; Extract the result values for the given instruction.
@@ -254,8 +322,9 @@
 (decl first_result (Value) Inst)
 (extern extractor first_result first_result)
 
-;; Extract the `InstructionData` for an `Inst`.
-(decl inst_data (InstructionData) Inst)
+;; Extract the `InstructionData` and `Type` for an `Inst`. The extracted type is
+;; the value type of the first result when present, or the invalid type otherwise.
+(decl inst_data (Type InstructionData) Inst)
 (extern extractor infallible inst_data inst_data)
 
 ;; Extract the type of the instruction's first result.
@@ -266,18 +335,51 @@
 ;; Extract the type of the instruction's first result and pass along the
 ;; instruction as well.
 (decl has_type (Type Inst) Inst)
+(spec (has_type ty arg)
+      (provide
+            (= result arg)
+            (= (:bits ty) (widthof arg))
+      )
+)
 (extractor (has_type ty inst)
            (and (result_type ty)
                 inst))
 
 ;; Match the instruction that defines the given value, if any.
 (decl def_inst (Inst) Value)
+(spec (def_inst arg)
+      (provide (= result arg))
+)
 (extern extractor def_inst def_inst)
 
 ;; Extract a constant `u64` from a value defined by an `iconst`.
 (decl u64_from_iconst (u64) Value)
 (extractor (u64_from_iconst x)
-           (def_inst (iconst (u64_from_imm64 x))))
+           (def_inst (iconst _ (u64_from_imm64 x))))
+(spec (u64_from_iconst arg) (provide (= arg (zero_ext 64 result))))
+
+;; Extract a constant `i32` from a value defined by an `iconst`.
+;; The value is sign extended to 32 bits.
+(decl i32_from_iconst (i32) Value)
+(spec (i32_from_iconst arg)
+      (provide (= arg (extract 31 0 (sign_ext 64 result))))
+      (match
+            ; result <= i32::MAX
+            (bvsle (sign_ext 64 result) #x000000007fffffff)
+            ; i32::MIN <= result
+            (bvsle (bvneg #x0000000080000000) (sign_ext 64 result))
+      )
+)
+(extern extractor i32_from_iconst i32_from_iconst)
+
+; Rust code for i32_from_iconst does not allow for constant values larger than 64 bits.
+; REVIEW(mbm): is an instantiation for i32_from_iconst appropriate?
+(instantiate i32_from_iconst
+    ((args (bv 32)) (ret (bv 8)))
+    ((args (bv 32)) (ret (bv 16)))
+    ((args (bv 32)) (ret (bv 32)))
+    ((args (bv 32)) (ret (bv 64)))
+)
 
 ;; Extract a constant `i64` from a value defined by an `iconst`.
 ;; The value is sign extended to 64 bits.
@@ -289,22 +391,37 @@
 (extern constructor zero_value zero_value)
 
 ;; Match a sinkable instruction from a value operand.
+;;
+;; We do not model sinking in the verification domain.
 (decl pure partial is_sinkable_inst (Value) Inst)
 (extern constructor is_sinkable_inst is_sinkable_inst)
+(spec (is_sinkable_inst value) (match true) (provide (= result value)))
 
 ;; Match a uextend or any other instruction, "seeing through" the uextend if
 ;; present.
 (decl maybe_uextend (Value) Value)
 (extern extractor maybe_uextend maybe_uextend)
 
+;; Get an unsigned 8-bit immediate in a u8 from an Imm64, if possible.
+(decl uimm8 (u8) Imm64)
+(spec (uimm8 arg)
+      (provide (= result (zero_ext 64 arg)))
+      (match
+            (bvsge result #x0000000000000000) ; >= 0
+            (bvslt result #x0000000000000100) ; < 256
+      )
+)
+(extern extractor uimm8 uimm8)
+
 ;; Instruction creation helpers ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Emit an instruction.
 ;;
 ;; This is low-level and side-effectful; it should only be used as an
 ;; implementation detail by helpers that preserve the SSA facade themselves.
-
+; TODO(mbm): what is the right spec for emit?
 (decl emit (MInst) Unit)
+(spec (emit inst) (provide (= result #b1)))
 (extern constructor emit emit)
 
 ;; Sink an instruction.
@@ -312,12 +429,16 @@
 ;; This is a side-effectful operation that notifies the context that the
 ;; instruction has been sunk into another instruction, and no longer needs to
 ;; be lowered.
+;;
+;; We do not model sinking in the verification domain.
 (decl sink_inst (Inst) Unit)
 (extern constructor sink_inst sink_inst)
+(spec (sink_inst inst) (provide true))
 
 ;; Constant pool emission.
 
 (type VCodeConstant (primitive VCodeConstant))
+(model VCodeConstant (type !))
 
 ;; Add a u64 little-endian constant to the in-memory constant pool and
 ;; return a VCodeConstant index that refers to it. This is
@@ -347,6 +468,7 @@
 
 ;; Emit given side-effectful instruction.
 (decl emit_side_effect (SideEffectNoResult) Unit)
+(spec (emit_side_effect arg) (provide true))
 (rule (emit_side_effect (SideEffectNoResult.Inst inst))
       (emit inst))
 (rule (emit_side_effect (SideEffectNoResult.Inst2 inst1 inst2))
@@ -392,8 +514,48 @@
                      (ProducesFlagsReturnsReg (inst MInst) (result Reg))
                      (ProducesFlagsReturnsResultWithConsumer (inst MInst) (result Reg))))
 
+(model ProducesFlags
+      (type-ext-enum
+            (struct
+                  (flags  (named NZCV))
+                  (result (named Reg))
+                  (has_result Bool)
+            )
+      )
+)
+
+(spec (ProducesFlags.ProducesFlagsReturnsResultWithConsumer inst reg)
+      (provide
+            (= (:flags result) (:flags_out inst))
+            (= (:result result) reg)
+            (:has_result result)
+      )
+)
+
+(spec (ProducesFlags.ProducesFlagsSideEffect inst)
+      (provide
+            (= (:flags result) (:flags_out inst))
+            (not (:has_result result))
+      )
+)
+
+(spec (ProducesFlags.ProducesFlagsTwiceSideEffect inst1 inst2)
+      (provide
+            ; Flags output from the first instruction pass to the second's input.
+            (= (:flags_out inst1) (:flags_in inst2))
+
+            ; Result flags of the ProducesFlags wrapper are from the second
+            ; instruction's output.
+            (= (:flags result) (:flags_out inst2))
+
+            ; No value is produced.
+            (not (:has_result result))
+      )
+)
+
 ;; Chain another producer to a `ProducesFlags`.
 (decl produces_flags_concat (ProducesFlags ProducesFlags) ProducesFlags)
+(attr produces_flags_concat (tag TODO))
 (rule (produces_flags_concat (ProducesFlags.ProducesFlagsSideEffect inst1) (ProducesFlags.ProducesFlagsSideEffect inst2))
       (ProducesFlags.ProducesFlagsTwiceSideEffect inst1 inst2))
 
@@ -420,7 +582,45 @@
                                                              (inst4 MInst)
                                                              (result ValueRegs))))
 
-
+(model ConsumesFlags
+      (type-ext-enum
+            (struct
+                  (flags  (named NZCV))
+                  (result (named Reg))
+                  (has_result Bool)
+            )
+      )
+)
+
+(spec (ConsumesFlags.ConsumesFlagsReturnsResultWithProducer inst reg)
+      (provide
+            (= (:flags result) (:flags_in inst))
+            (= (:result result) reg)
+            (:has_result result)
+      )
+)
+
+(spec (ConsumesFlags.ConsumesFlagsReturnsReg inst reg)
+      (provide
+            (= (:flags result) (:flags_in inst))
+            (= (:result result) reg)
+            (:has_result result)
+      )
+)
+
+(spec (ConsumesFlags.ConsumesFlagsTwiceReturnsValueRegs inst1 inst2 res)
+  (provide
+        (= (:flags result) (:flags_in inst1))
+        (:has_result result)
+  )
+)
+
+(spec (ConsumesFlags.ConsumesFlagsSideEffect inst)
+      (provide
+            (= (:flags result) (:flags_in inst))
+            (not (:has_result result))
+      )
+)
 
 ;; Get the produced register out of a ProducesFlags.
 (decl produces_flags_get_reg (ProducesFlags) Reg)
@@ -438,6 +638,7 @@
 ;; Helper for combining two flags-consumer instructions that return a
 ;; single Reg, giving a ConsumesFlags that returns both values in a
 ;; ValueRegs.
+(attr consumes_flags_concat (veri chain))
 (decl consumes_flags_concat (ConsumesFlags ConsumesFlags) ConsumesFlags)
 (rule (consumes_flags_concat (ConsumesFlags.ConsumesFlagsReturnsReg inst1 reg1)
                              (ConsumesFlags.ConsumesFlagsReturnsReg inst2 reg2))
@@ -461,6 +662,25 @@
 ;;
 ;; See `with_flags_reg` below for a variant that extracts out just the lower Reg.
 (decl with_flags (ProducesFlags ConsumesFlags) ValueRegs)
+(spec (with_flags producer consumer)
+      (provide
+            ; Transfer flags from producer to consumer.
+            (= (:flags producer) (:flags consumer))
+            ; Construct resulting value registers.
+            (=> (and (:has_result producer) (:has_result consumer))
+                  (and
+                        (= (:lo result) (:result producer))
+                        (= (:hi result) (:result consumer))
+                  )
+            )
+            (=> (and (not (:has_result producer)) (:has_result consumer))
+                  (= (:lo result) (:result consumer))
+            )
+            (=> (and (:has_result producer) (not (:has_result consumer)))
+                  (= (:lo result) (:result producer))
+            )
+      )
+)
 
 (rule (with_flags (ProducesFlags.ProducesFlagsReturnsResultWithConsumer producer_inst producer_result)
                   (ConsumesFlags.ConsumesFlagsReturnsResultWithProducer consumer_inst consumer_result))
@@ -856,6 +1076,13 @@
 (decl pure partial preserve_frame_pointers () Unit)
 (extern constructor preserve_frame_pointers preserve_frame_pointers)
 
+;; This definition should be kept up to date with the values defined in
+;; cranelift/codegen/meta/src/shared/settings.rs
+(type StackSwitchModel extern (enum (None) (Basic) (UpdateWindowsTib)))
+
+(decl pure partial stack_switch_model () StackSwitchModel)
+(extern constructor stack_switch_model stack_switch_model)
+
 ;;;; Helpers for accessing instruction data ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (decl box_external_name (ExternalName) BoxExternalName)
@@ -987,6 +1214,10 @@
 (decl abi_sized_stack_ret_space (Sig) i64)
 (extern constructor abi_sized_stack_ret_space abi_sized_stack_ret_space)
 
+;; Incoming return area pointer (must be present).
+(decl abi_unwrap_ret_area_ptr () Reg)
+(extern constructor abi_unwrap_ret_area_ptr abi_unwrap_ret_area_ptr)
+
 ;; StackSlot addr
 (decl abi_stackslot_addr (WritableReg StackSlot Offset32) MInst)
 (extern constructor abi_stackslot_addr abi_stackslot_addr)
@@ -1040,6 +1271,23 @@
 ;; Helper for extracting an immediate that's not 0 and not -1 from an imm64.
 (decl pure partial safe_divisor_from_imm64 (Type Imm64) u64)
 (extern constructor safe_divisor_from_imm64 safe_divisor_from_imm64)
+;; Implemented in the same style as the Rust implementation
+(spec (safe_divisor_from_imm64 ty arg)
+      (match
+            (let (
+                  (minus1 (zero_ext 64 (bvones! (:bits ty))))
+                  (zero (bvzero! 64))
+                  (bits (bvand arg minus1))
+            )
+            (and
+                  (not (= bits minus1))
+                  (not (= bits zero)))))
+      (provide
+            (let (
+                  (minus1 (zero_ext 64 (bvones! (:bits ty))))
+                  (bits (bvand arg minus1))
+            )
+            (= result bits))))
 
 ;;;; Automatic conversions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
diff --git a/cranelift/codegen/src/prelude_opt.isle b/cranelift/codegen/src/prelude_opt.isle
index 099930f5b3f1..e0cd14860e88 100644
--- a/cranelift/codegen/src/prelude_opt.isle
+++ b/cranelift/codegen/src/prelude_opt.isle
@@ -1,11 +1,21 @@
 ;; Prelude definitions specific to the mid-end.
 
+;; Any `extern` definitions here are generally implemented in `src/opts.rs`.
+
 ;;;;; eclass and enode access ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Extract any node(s) for the given eclass ID.
 (decl multi inst_data (Type InstructionData) Value)
 (extern extractor inst_data inst_data_etor)
 
+;; Identical to `inst_data`, just with a different ISLE type.
+;; This is basically a manual version of `curry`/`uncurry` in Haskell:
+;; to compose extractors the outer one needs to be single-parameter,
+;; so this combines the two parameters of `inst_data` into one.
+(type TypeAndInstructionData (primitive TypeAndInstructionData))
+(decl multi inst_data_tupled (TypeAndInstructionData) Value)
+(extern extractor inst_data_tupled inst_data_tupled_etor)
+
 ;; Construct a pure node, returning a new (or deduplicated
 ;; already-existing) eclass ID.
 (decl make_inst (Type InstructionData) Value)
@@ -28,6 +38,14 @@
 (rule (sgt ty x y) (icmp ty (IntCC.SignedGreaterThan) x y))
 (rule (sge ty x y) (icmp ty (IntCC.SignedGreaterThanOrEqual) x y))
 
+;; 3-way comparison, returning -1/0/+1 in I8
+(decl spaceship_s (Type Value Value) Value)
+(rule (spaceship_s ty x y) (isub $I8 (sgt ty x y) (slt ty x y)))
+(extractor (spaceship_s ty x y) (isub $I8 (sgt ty x y) (slt ty x y)))
+(decl spaceship_u (Type Value Value) Value)
+(rule (spaceship_u ty x y) (isub $I8 (ugt ty x y) (ult ty x y)))
+(extractor (spaceship_u ty x y) (isub $I8 (ugt ty x y) (ult ty x y)))
+
 ;;;;; optimization toplevel ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; The main matcher rule invoked by the toplevel driver.
@@ -43,3 +61,62 @@
 ;; answer".
 (decl subsume (Value) Value)
 (extern constructor subsume subsume)
+
+;;;;; constructors ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(decl iconst_sextend_etor (Type i64) TypeAndInstructionData)
+(extern extractor iconst_sextend_etor iconst_sextend_etor)
+
+;; Construct an `iconst` from an `i64` or Extract an `i64` from an `iconst`
+;; by treating the constant as signed.
+;; When extracting, smaller types get their value sign-extended to 64-bits,
+;; so that `iconst.i8 255` will give you a `-1_i64`.
+;; When constructing, the rule will fail if the value cannot be represented in
+;; the target type.  If it fits, it'll be masked accordingly in the constant.
+(decl iconst_s (Type i64) Value)
+(extractor (iconst_s ty c) (inst_data_tupled (iconst_sextend_etor ty c)))
+(rule 0 (iconst_s ty c)
+	(if-let c_masked (u64_and (i64_as_u64 c) (ty_umax ty)))
+	(if-let c_reextended (i64_sextend_u64 ty c_masked))
+	(if-let $true (u64_eq (i64_as_u64 c) (i64_as_u64 c_reextended)))
+	(iconst ty (imm64 c_masked)))
+(rule 1 (iconst_s $I128 c) (sextend $I128 (iconst_s $I64 c)))
+
+;; Construct an `iconst` from a `u64` or Extract a `u64` from an `iconst`
+;; by treating the constant as unsigned.
+;; When extracting, smaller types get their value zero-extended to 64-bits,
+;; so that `iconst.i8 255` will give you a `255_u64`.
+;; When constructing, the rule will fail if the value cannot be represented in
+;; the target type.
+(decl iconst_u (Type u64) Value)
+(extractor (iconst_u ty c) (iconst ty (u64_from_imm64 c)))
+(rule 0 (iconst_u ty c)
+	(if-let $true (u64_le c (ty_umax ty)))
+    (iconst ty (imm64 c)))
+(rule 1 (iconst_u $I128 c) (uextend $I128 (iconst_u $I64 c)))
+
+;; These take `Value`, rather than going through `inst_data_tupled`, because
+;; most of the time they want to return the original `Value`, and it would be
+;; a waste to need to re-GVN the instruction data in those cases.
+(decl multi sextend_maybe_etor (Type Value) Value)
+(extern extractor infallible sextend_maybe_etor sextend_maybe_etor)
+(decl multi uextend_maybe_etor (Type Value) Value)
+(extern extractor infallible uextend_maybe_etor uextend_maybe_etor)
+
+;; Match or Construct a possibly-`uextend`ed value.
+;; Gives the extended-to type and inner value when matching something that was
+;; extended, or the input value and its type when the value isn't an extension.
+;; Useful to write a single pattern that can match things that may or may not
+;; have undergone C's "usual arithmetic conversions".
+;; When generating values, extending to the same type is invalid CLIF,
+;; so this avoids doing that where there's no extension actually needed.
+(decl uextend_maybe (Type Value) Value)
+(extractor (uextend_maybe ty val) (uextend_maybe_etor ty val))
+(rule 0 (uextend_maybe ty val) (uextend ty val))
+(rule 1 (uextend_maybe ty val@(value_type ty)) val)
+
+;; Same as `uextend_maybe` above, just for `sextend`.
+(decl sextend_maybe (Type Value) Value)
+(extractor (sextend_maybe ty val) (sextend_maybe_etor ty val))
+(rule 0 (sextend_maybe ty val) (sextend ty val))
+(rule 1 (sextend_maybe ty val@(value_type ty)) val)
diff --git a/cranelift/codegen/src/prelude_spec.isle b/cranelift/codegen/src/prelude_spec.isle
new file mode 100644
index 000000000000..93368f5ac329
--- /dev/null
+++ b/cranelift/codegen/src/prelude_spec.isle
@@ -0,0 +1,85 @@
+;;;; Common spec macros ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Generic helpers
+
+; unspecified value.
+(macro (unspecified) (with (x) x))
+
+;; Boolean helpers
+
+; Exclusive or
+(macro (xor a b) (and (or a b) (not (and a b))))
+
+;; Bit-vector helpers
+
+; n-bit bitvector with value zero.
+(macro (bvzero n) (zero_ext n #b0))
+
+; n-bit bitvector with value one.
+(macro (bvone n) (zero_ext n #b1))
+
+; n-bit bitvector with value all ones.
+(macro (bvones n) (bvnot (bvzero! n)))
+
+; bit-vector shift left by an integer amount.
+(macro (bvshl_int x s) (bvshl x (int2bv (widthof x) s)))
+
+; bit-vector logical right shift by an integer amount.
+(macro (bvlshr_int x s) (bvlshr x (int2bv (widthof x) s)))
+
+; n-bit bitvector with low m bits set.
+(macro (low_bits_mask n m) (bvsub (bvshl (bvone! n) (int2bv n m)) (bvone! n)))
+
+; Shift mask for m bits (power of two), as an n-bit bitvector.
+(macro (shift_mask n m) (bvsub (int2bv n m) (bvone! n)))
+
+; bitvector zero test
+(macro (bv_is_zero x) (= x (bvzero! (widthof x))))
+
+; n-bit bitvector with the top bit set.
+(macro (bv_top_bit_set n) (bvnot (bvlshr_int! (bvones! n) 1)))
+
+; Convert a boolean to a single bit.
+(macro (bool2bit b) (if b #b1 #b0))
+
+; Convert number of bits to number of bytes.
+(macro (bits2bytes bits) (bvlshr_int! bits 3))
+
+;; Floating-point helpers
+
+; Whether two floating-point values have the same sign.
+(macro (fp_equal_sign x y) (= (fp.isPositive x) (fp.isPositive y)))
+
+; Whether two floating-point values have the opposite signs, without
+; using SMT function that are nondeterministic for NaN.
+(macro (fp_equal_sign_inc_nan x y)
+    (=
+        (bvand (bv_top_bit_set! (widthof x)) x)
+        (bvand (bv_top_bit_set! (widthof y)) y)
+    )
+)
+
+; Whether two floating-point values have the opposite signs.
+(macro (fp_opposite_sign x y) (not (fp_equal_sign! x y)))
+
+
+; Build a floating-point zero with the given sign and width.
+(macro (fp_signed_zero negative w) (if negative (fp.-zero w) (fp.+zero w)))
+
+; Build a floating-point infinity with the given sign and width.
+(macro (fp_signed_inf negative w) (if negative (fp.-oo w) (fp.+oo w)))
+
+; Magnitude of a floating-point value. (Clear the top sign bit.)
+(macro (fp_magnitude x) (bvlshr_int! (bvshl_int! x 1) 1))
+
+; Bit position of the top fraction bit in a floating-point value.
+(macro (fp_topfrac_bit w) (switch w (32 22) (64 51)))
+
+; Bit-vector with the top fraction bit set.
+(macro (fp_topfrac_bit_set w) (bvshl_int! (bvone! w) (fp_topfrac_bit! w)))
+
+; Bit position of the sign bit in a floating-point value.
+(macro (fp_sign_bit w) (switch w (32 31) (64 63)))
+
+; Bit-vector with the sign bit set.
+(macro (fp_sign_bit_set w) (bvshl_int! (bvone! w) (fp_sign_bit! w)))
diff --git a/cranelift/codegen/src/print_errors.rs b/cranelift/codegen/src/print_errors.rs
index e3fe7366165f..23195bf88f7a 100644
--- a/cranelift/codegen/src/print_errors.rs
+++ b/cranelift/codegen/src/print_errors.rs
@@ -4,6 +4,7 @@ use crate::entity::SecondaryMap;
 use crate::ir;
 use crate::ir::entities::{AnyEntity, Block, Inst, Value};
 use crate::ir::function::Function;
+use crate::ir::pcc::Fact;
 use crate::result::CodegenError;
 use crate::verifier::{VerifierError, VerifierErrors};
 use crate::write::{decorate_function, FuncWriter, PlainWriter};
@@ -71,8 +72,9 @@ impl<'a> FuncWriter for PrettyVerifierError<'a> {
         func: &Function,
         entity: AnyEntity,
         value: &dyn fmt::Display,
+        maybe_fact: Option<&Fact>,
     ) -> fmt::Result {
-        pretty_preamble_error(w, func, entity, value, &mut *self.0, self.1)
+        pretty_preamble_error(w, func, entity, value, maybe_fact, &mut *self.0, self.1)
     }
 }
 
@@ -87,7 +89,7 @@ fn pretty_block_header_error(
 ) -> fmt::Result {
     let mut s = String::new();
     func_w.write_block_header(&mut s, func, cur_block, indent)?;
-    write!(w, "{}", s)?;
+    write!(w, "{s}")?;
 
     // TODO: Use drain_filter here when it gets stabilized
     let mut i = 0;
@@ -125,7 +127,7 @@ fn pretty_instruction_error(
 ) -> fmt::Result {
     let mut s = String::new();
     func_w.write_instruction(&mut s, func, aliases, cur_inst, indent)?;
-    write!(w, "{}", s)?;
+    write!(w, "{s}")?;
 
     // TODO: Use drain_filter here when it gets stabilized
     let mut i = 0;
@@ -156,12 +158,13 @@ fn pretty_preamble_error(
     func: &Function,
     entity: AnyEntity,
     value: &dyn fmt::Display,
+    maybe_fact: Option<&Fact>,
     func_w: &mut dyn FuncWriter,
     errors: &mut Vec<VerifierError>,
 ) -> fmt::Result {
     let mut s = String::new();
-    func_w.write_entity_definition(&mut s, func, entity, value)?;
-    write!(w, "{}", s)?;
+    func_w.write_entity_definition(&mut s, func, entity, value, maybe_fact)?;
+    write!(w, "{s}")?;
 
     // TODO: Use drain_filter here when it gets stabilized
     let mut i = 0;
diff --git a/cranelift/codegen/src/ranges.rs b/cranelift/codegen/src/ranges.rs
new file mode 100644
index 000000000000..419dee83c08f
--- /dev/null
+++ b/cranelift/codegen/src/ranges.rs
@@ -0,0 +1,131 @@
+//! The [`Ranges`] type stores a list of contiguous index ranges that
+//! span some other list's full length.
+
+use alloc::vec::Vec;
+use core::ops::Range;
+
+/// A list of contiguous index ranges.
+#[derive(Default)]
+pub struct Ranges {
+    ranges: Vec<u32>,
+    reverse: bool,
+}
+
+impl Ranges {
+    /// Constructs a new, empty, list of ranges with at least the
+    /// specified capacity.
+    pub fn with_capacity(capacity: usize) -> Self {
+        let mut new = Ranges::default();
+        new.reserve(capacity);
+        new
+    }
+
+    /// Add a new range which begins at the end of the previous range
+    /// and ends at the specified offset, exclusive.
+    pub fn push_end(&mut self, end: usize) {
+        debug_assert!(!self.reverse);
+        // To keep this implementation simple we explicitly store the
+        // starting index, which is always 0, so that all ranges are
+        // represented by adjacent pairs in the list. But we add it
+        // lazily so that an empty list doesn't have to allocate.
+        if self.ranges.is_empty() {
+            self.ranges.push(0);
+        }
+        self.ranges.push(u32::try_from(end).unwrap());
+    }
+
+    /// Number of ranges in this list.
+    pub fn len(&self) -> usize {
+        self.ranges.len().saturating_sub(1)
+    }
+
+    /// Reserves capacity for at least `additional` more ranges to be
+    /// added to this list.
+    pub fn reserve(&mut self, mut additional: usize) {
+        if additional > 0 && self.ranges.is_empty() {
+            additional = additional.saturating_add(1);
+        }
+        self.ranges.reserve(additional);
+    }
+
+    /// Get the range at the specified index.
+    pub fn get(&self, index: usize) -> Range<usize> {
+        let len = self.len();
+        assert!(index < len, "index {index} is too big for length {len}");
+        let index = self.map_index(index);
+        self.ranges[index] as usize..self.ranges[index + 1] as usize
+    }
+
+    /// Visit ranges in unspecified order, paired with the index each
+    /// range occurs at.
+    pub fn iter(
+        &self,
+    ) -> impl DoubleEndedIterator<Item = (usize, Range<usize>)> + ExactSizeIterator + '_ {
+        self.ranges
+            .windows(2)
+            .enumerate()
+            .map(|(index, range)| (self.map_index(index), range[0] as usize..range[1] as usize))
+    }
+
+    /// Reverse this list of ranges, so that the first range is at the
+    /// last index and the last range is at the first index.
+    ///
+    /// ```ignore
+    /// use cranelift_codegen::ranges::Ranges;
+    /// let mut ranges = Ranges::default();
+    /// ranges.push_end(4);
+    /// ranges.push_end(6);
+    /// ranges.reverse_index();
+    /// assert_eq!(ranges.get(0), 4..6);
+    /// assert_eq!(ranges.get(1), 0..4);
+    /// ```
+    pub fn reverse_index(&mut self) {
+        // We can't easily change the order of the endpoints in
+        // self.ranges: they need to be in ascending order or our
+        // compressed representation gets complicated. So instead we
+        // change our interpretation of indexes using map_index below,
+        // controlled by a simple flag. As a bonus, reversing the list
+        // is constant-time!
+        self.reverse = !self.reverse;
+    }
+
+    fn map_index(&self, index: usize) -> usize {
+        if self.reverse {
+            // These subtractions can't overflow because callers
+            // enforce that 0 <= index < self.len()
+            self.len() - 1 - index
+        } else {
+            index
+        }
+    }
+
+    /// Update these ranges to reflect that the list they refer to has
+    /// been reversed. Afterwards, the ranges will still be indexed
+    /// in the same order, but the first range will refer to the
+    /// same-length range at the end of the target list instead of at
+    /// the beginning, and subsequent ranges will proceed backwards
+    /// from there.
+    ///
+    /// ```ignore
+    /// use cranelift_codegen::ranges::Ranges;
+    /// let mut ranges = Ranges::default();
+    /// ranges.push_end(4);
+    /// ranges.push_end(6);
+    /// ranges.reverse_target(6);
+    /// assert_eq!(ranges.get(0), 2..6);
+    /// assert_eq!(ranges.get(1), 0..2);
+    /// ```
+    pub fn reverse_target(&mut self, target_len: usize) {
+        let target_len = u32::try_from(target_len).unwrap();
+        // The last endpoint added should be the same as the current
+        // length of the target list.
+        debug_assert_eq!(target_len, *self.ranges.last().unwrap_or(&0));
+        for end in self.ranges.iter_mut() {
+            *end = target_len - *end;
+        }
+        // Put the endpoints back in ascending order, but that means
+        // now our indexes are backwards.
+        self.ranges.reverse();
+        self.reverse_index();
+    }
+}
diff --git a/cranelift/codegen/src/remove_constant_phis.rs b/cranelift/codegen/src/remove_constant_phis.rs
index 5a8ab0235aaf..4b73b2c24f29 100644
--- a/cranelift/codegen/src/remove_constant_phis.rs
+++ b/cranelift/codegen/src/remove_constant_phis.rs
@@ -1,14 +1,13 @@
 //! A Constant-Phi-Node removal pass.
 
 use crate::dominator_tree::DominatorTree;
-use crate::fx::FxHashMap;
-use crate::fx::FxHashSet;
 use crate::ir;
 use crate::ir::Function;
 use crate::ir::{Block, BlockCall, Inst, Value};
 use crate::timing;
 use bumpalo::Bump;
 use cranelift_entity::SecondaryMap;
+use rustc_hash::{FxHashMap, FxHashSet};
 use smallvec::SmallVec;
 
 // A note on notation.  For the sake of clarity, this file uses the phrase
@@ -204,7 +203,7 @@ impl SolverState {
         *self
             .absvals
             .get(&actual)
-            .unwrap_or_else(|| panic!("SolverState::get: formal param {:?} is untracked?!", actual))
+            .unwrap_or_else(|| panic!("SolverState::get: formal param {actual:?} is untracked?!"))
     }
 
     fn maybe_get(&self, actual: Value) -> Option<&AbstractValue> {
@@ -214,7 +213,7 @@ impl SolverState {
     fn set(&mut self, actual: Value, lp: AbstractValue) {
         match self.absvals.insert(actual, lp) {
             Some(_old_lp) => {}
-            None => panic!("SolverState::set: formal param {:?} is untracked?!", actual),
+            None => panic!("SolverState::set: formal param {actual:?} is untracked?!"),
         }
     }
 }
diff --git a/cranelift/codegen/src/result.rs b/cranelift/codegen/src/result.rs
index d14049c0b6b9..5e4a490073c7 100644
--- a/cranelift/codegen/src/result.rs
+++ b/cranelift/codegen/src/result.rs
@@ -2,6 +2,7 @@
 
 use regalloc2::checker::CheckerErrors;
 
+use crate::ir::pcc::PccError;
 use crate::{ir::Function, verifier::VerifierErrors};
 use std::string::String;
 
@@ -41,6 +42,9 @@ pub enum CodegenError {
 
     /// Register allocator internal error discovered by the symbolic checker.
     Regalloc(CheckerErrors),
+
+    /// Proof-carrying-code validation error.
+    Pcc(PccError),
 }
 
 /// A convenient alias for a `Result` that uses `CodegenError` as the error type.
@@ -58,6 +62,7 @@ impl std::error::Error for CodegenError {
             #[cfg(feature = "unwind")]
             CodegenError::RegisterMappingError { .. } => None,
             CodegenError::Regalloc(..) => None,
+            CodegenError::Pcc(..) => None,
         }
     }
 }
@@ -68,10 +73,14 @@ impl std::fmt::Display for CodegenError {
             CodegenError::Verifier(_) => write!(f, "Verifier errors"),
             CodegenError::ImplLimitExceeded => write!(f, "Implementation limit exceeded"),
             CodegenError::CodeTooLarge => write!(f, "Code for function is too large"),
-            CodegenError::Unsupported(feature) => write!(f, "Unsupported feature: {}", feature),
+            CodegenError::Unsupported(feature) => write!(f, "Unsupported feature: {feature}"),
             #[cfg(feature = "unwind")]
             CodegenError::RegisterMappingError(_0) => write!(f, "Register mapping error"),
-            CodegenError::Regalloc(errors) => write!(f, "Regalloc validation errors: {:?}", errors),
+            CodegenError::Regalloc(errors) => write!(f, "Regalloc validation errors: {errors:?}"),
+
+            // NOTE: if this is changed, please update the `is_pcc_error` function defined in
+            // `wasmtime/crates/fuzzing/src/oracles.rs`
+            CodegenError::Pcc(e) => write!(f, "Proof-carrying-code validation error: {e:?}"),
         }
     }
 }
diff --git a/cranelift/codegen/src/scoped_hash_map.rs b/cranelift/codegen/src/scoped_hash_map.rs
index 1b8fde1a544e..170a6140d259 100644
--- a/cranelift/codegen/src/scoped_hash_map.rs
+++ b/cranelift/codegen/src/scoped_hash_map.rs
@@ -4,8 +4,8 @@
 //! container that has a concept of scopes that can be entered and exited, such that
 //! values inserted while inside a scope aren't visible outside the scope.
 
-use crate::fx::FxHashMap;
 use core::hash::Hash;
+use rustc_hash::FxHashMap;
 use smallvec::{smallvec, SmallVec};
 
 #[cfg(not(feature = "std"))]
@@ -90,7 +90,7 @@ where
     /// Creates an empty `ScopedHashMap`.
     pub fn new() -> Self {
         Self {
-            map: FxHashMap(),
+            map: FxHashMap::default(),
             generation: 0,
             generation_by_depth: smallvec![0],
         }
@@ -188,19 +188,6 @@ where
             .checked_sub(1)
             .expect("generation_by_depth cannot be empty")
     }
-
-    /// Remote an entry.
-    pub fn remove(&mut self, key: &K) -> Option<V> {
-        self.map.remove(key).and_then(|val| {
-            let entry_generation = val.generation;
-            let entry_depth = val.level as usize;
-            if self.generation_by_depth.get(entry_depth).cloned() == Some(entry_generation) {
-                Some(val.value)
-            } else {
-                None
-            }
-        })
-    }
 }
 
 #[cfg(test)]
diff --git a/cranelift/codegen/src/settings.rs b/cranelift/codegen/src/settings.rs
index bb4af16d1fb6..39446528dbdf 100644
--- a/cranelift/codegen/src/settings.rs
+++ b/cranelift/codegen/src/settings.rs
@@ -231,21 +231,10 @@ fn parse_bool_value(value: &str) -> SetResult<bool> {
 fn parse_enum_value(value: &str, choices: &[&str]) -> SetResult<u8> {
     match choices.iter().position(|&tag| tag == value) {
         Some(idx) => Ok(idx as u8),
-        None => {
-            // TODO: Use `join` instead of this code, once
-            // https://github.com/rust-lang/rust/issues/27747 is resolved.
-            let mut all_choices = String::new();
-            let mut first = true;
-            for choice in choices {
-                if first {
-                    first = false
-                } else {
-                    all_choices += ", ";
-                }
-                all_choices += choice;
-            }
-            Err(SetError::BadValue(format!("any among {}", all_choices)))
-        }
+        None => Err(SetError::BadValue(format!(
+            "any among {}",
+            choices.join(", ")
+        ))),
     }
 }
 
@@ -306,12 +295,12 @@ impl std::error::Error for SetError {}
 impl fmt::Display for SetError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            SetError::BadName(name) => write!(f, "No existing setting named '{}'", name),
+            SetError::BadName(name) => write!(f, "No existing setting named '{name}'"),
             SetError::BadType => {
                 write!(f, "Trying to set a setting with the wrong type")
             }
             SetError::BadValue(value) => {
-                write!(f, "Unexpected value for a setting, expected {}", value)
+                write!(f, "Unexpected value for a setting, expected {value}")
             }
         }
     }
@@ -386,13 +375,13 @@ pub mod detail {
         ) -> fmt::Result {
             match detail {
                 Detail::Bool { bit } => write!(f, "{}", (byte & (1 << bit)) != 0),
-                Detail::Num => write!(f, "{}", byte),
+                Detail::Num => write!(f, "{byte}"),
                 Detail::Enum { last, enumerators } => {
                     if byte <= last {
                         let tags = self.enums(last, enumerators);
                         write!(f, "\"{}\"", tags[usize::from(byte)])
                     } else {
-                        write!(f, "{}", byte)
+                        write!(f, "{byte}")
                     }
                 }
                 // Presets aren't printed. They are reflected in the other settings.
@@ -522,6 +511,7 @@ mod tests {
         let expected = r#"[shared]
 opt_level = "none"
 tls_model = "none"
+stack_switch_model = "none"
 libcall_call_conv = "isa_default"
 probestack_size_log2 = 12
 probestack_strategy = "outline"
@@ -530,6 +520,7 @@ regalloc_checker = false
 regalloc_verbose_logs = false
 enable_alias_analysis = true
 enable_verifier = true
+enable_pcc = false
 is_pic = false
 use_colocated_libcalls = false
 enable_float = true
@@ -542,7 +533,6 @@ unwind_info = true
 preserve_frame_pointers = false
 machine_code_cfg_info = false
 enable_probestack = false
-probestack_func_adjusts_sp = false
 enable_jump_tables = true
 enable_heap_access_spectre_mitigation = true
 enable_table_access_spectre_mitigation = true
diff --git a/cranelift/codegen/src/state.isle b/cranelift/codegen/src/state.isle
new file mode 100644
index 000000000000..a1968635dd3c
--- /dev/null
+++ b/cranelift/codegen/src/state.isle
@@ -0,0 +1,7 @@
+;; Execution state common shared by all backends.
+
+; Whether a trap has occurred.
+(state exec_trap
+    (type Bool)
+    (default (not exec_trap))
+)
diff --git a/cranelift/codegen/src/timing.rs b/cranelift/codegen/src/timing.rs
index 573b82c0cd96..c634b5d90748 100644
--- a/cranelift/codegen/src/timing.rs
+++ b/cranelift/codegen/src/timing.rs
@@ -5,9 +5,9 @@
 use core::fmt;
 use std::any::Any;
 use std::boxed::Box;
-use std::cell::{Cell, RefCell};
+use std::cell::RefCell;
 use std::mem;
-use std::time::{Duration, Instant};
+use std::time::Duration;
 
 // Each pass that can be timed is predefined with the `define_passes!` macro. Each pass has a
 // snake_case name and a plain text description used when printing out the timing report.
@@ -62,7 +62,6 @@ define_passes! {
     domtree: "Dominator tree",
     loop_analysis: "Loop analysis",
     preopt: "Pre-legalization rewriting",
-    dce: "Dead code elimination",
     egraph: "Egraph based optimizations",
     gvn: "Global value numbering",
     licm: "Loop invariant code motion",
@@ -130,22 +129,6 @@ fn start_pass(pass: Pass) -> Box<dyn Any> {
     PROFILER.with(|profiler| profiler.borrow().start_pass(pass))
 }
 
-/// A timing token is responsible for timing the currently running pass. Timing starts when it
-/// is created and ends when it is dropped.
-///
-/// Multiple passes can be active at the same time, but they must be started and stopped in a
-/// LIFO fashion.
-struct DefaultTimingToken {
-    /// Start time for this pass.
-    start: Instant,
-
-    // Pass being timed by this token.
-    pass: Pass,
-
-    // The previously active pass which will be restored when this token is dropped.
-    prev: Pass,
-}
-
 /// Accumulated timing information for a single pass.
 #[derive(Default, Copy, Clone)]
 struct PassTime {
@@ -207,7 +190,7 @@ impl fmt::Display for PassTimes {
             if let Some(s) = time.total.checked_sub(time.child) {
                 fmtdur(s, f)?;
             }
-            writeln!(f, " {}", desc)?;
+            writeln!(f, " {desc}")?;
         }
         writeln!(f, "======== ========  ==================================")
     }
@@ -215,42 +198,12 @@ impl fmt::Display for PassTimes {
 
 // Information about passes in a single thread.
 thread_local! {
-    static CURRENT_PASS: Cell<Pass> = const { Cell::new(Pass::None) };
     static PASS_TIME: RefCell<PassTimes> = RefCell::new(Default::default());
 }
 
 /// The default profiler. You can get the results using [`take_current`].
 pub struct DefaultProfiler;
 
-impl Profiler for DefaultProfiler {
-    fn start_pass(&self, pass: Pass) -> Box<dyn Any> {
-        let prev = CURRENT_PASS.with(|p| p.replace(pass));
-        log::debug!("timing: Starting {}, (during {})", pass, prev);
-        Box::new(DefaultTimingToken {
-            start: Instant::now(),
-            pass,
-            prev,
-        })
-    }
-}
-
-/// Dropping a timing token indicated the end of the pass.
-impl Drop for DefaultTimingToken {
-    fn drop(&mut self) {
-        let duration = self.start.elapsed();
-        log::debug!("timing: Ending {}: {}ms", self.pass, duration.as_millis());
-        let old_cur = CURRENT_PASS.with(|p| p.replace(self.prev));
-        debug_assert_eq!(self.pass, old_cur, "Timing tokens dropped out of order");
-        PASS_TIME.with(|rc| {
-            let mut table = rc.borrow_mut();
-            table.pass[self.pass.idx()].total += duration;
-            if let Some(parent) = table.pass.get_mut(self.prev.idx()) {
-                parent.child += duration;
-            }
-        })
-    }
-}
-
 /// Take the current accumulated pass timings and reset the timings for the current thread.
 ///
 /// Only applies when [`DefaultProfiler`] is used.
@@ -258,6 +211,78 @@ pub fn take_current() -> PassTimes {
     PASS_TIME.with(|rc| mem::take(&mut *rc.borrow_mut()))
 }
 
+#[cfg(feature = "timing")]
+mod enabled {
+    use super::{DefaultProfiler, Pass, Profiler, PASS_TIME};
+    use std::any::Any;
+    use std::boxed::Box;
+    use std::cell::Cell;
+    use std::time::Instant;
+
+    // Information about passes in a single thread.
+    thread_local! {
+        static CURRENT_PASS: Cell<Pass> = const { Cell::new(Pass::None) };
+    }
+
+    impl Profiler for DefaultProfiler {
+        fn start_pass(&self, pass: Pass) -> Box<dyn Any> {
+            let prev = CURRENT_PASS.with(|p| p.replace(pass));
+            log::debug!("timing: Starting {}, (during {})", pass, prev);
+            Box::new(DefaultTimingToken {
+                start: Instant::now(),
+                pass,
+                prev,
+            })
+        }
+    }
+
+    /// A timing token is responsible for timing the currently running pass. Timing starts when it
+    /// is created and ends when it is dropped.
+    ///
+    /// Multiple passes can be active at the same time, but they must be started and stopped in a
+    /// LIFO fashion.
+    struct DefaultTimingToken {
+        /// Start time for this pass.
+        start: Instant,
+
+        // Pass being timed by this token.
+        pass: Pass,
+
+        // The previously active pass which will be restored when this token is dropped.
+        prev: Pass,
+    }
+
+    /// Dropping a timing token indicated the end of the pass.
+    impl Drop for DefaultTimingToken {
+        fn drop(&mut self) {
+            let duration = self.start.elapsed();
+            log::debug!("timing: Ending {}: {}ms", self.pass, duration.as_millis());
+            let old_cur = CURRENT_PASS.with(|p| p.replace(self.prev));
+            debug_assert_eq!(self.pass, old_cur, "Timing tokens dropped out of order");
+            PASS_TIME.with(|rc| {
+                let mut table = rc.borrow_mut();
+                table.pass[self.pass.idx()].total += duration;
+                if let Some(parent) = table.pass.get_mut(self.prev.idx()) {
+                    parent.child += duration;
+                }
+            })
+        }
+    }
+}
+
+#[cfg(not(feature = "timing"))]
+mod disabled {
+    use super::{DefaultProfiler, Pass, Profiler};
+    use std::any::Any;
+    use std::boxed::Box;
+
+    impl Profiler for DefaultProfiler {
+        fn start_pass(&self, _pass: Pass) -> Box<dyn Any> {
+            Box::new(())
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/cranelift/codegen/src/traversals.rs b/cranelift/codegen/src/traversals.rs
new file mode 100644
index 000000000000..5efb703e8a13
--- /dev/null
+++ b/cranelift/codegen/src/traversals.rs
@@ -0,0 +1,218 @@
+//! Traversals over the IR.
+
+use crate::ir;
+use alloc::vec::Vec;
+use core::fmt::Debug;
+use core::hash::Hash;
+use cranelift_entity::EntitySet;
+
+/// A low-level DFS traversal event: either entering or exiting the traversal of
+/// a block.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum Event {
+    /// Entering traversal of a block.
+    ///
+    /// Processing a block upon this event corresponds to a pre-order,
+    /// depth-first traversal.
+    Enter,
+
+    /// Exiting traversal of a block.
+    ///
+    /// Processing a block upon this event corresponds to a post-order,
+    /// depth-first traversal.
+    Exit,
+}
+
+/// A depth-first traversal.
+///
+/// This is a fairly low-level traversal type, and is generally intended to be
+/// used as a building block for making specific pre-order or post-order
+/// traversals for whatever problem is at hand.
+///
+/// This type may be reused multiple times across different passes or functions
+/// and will internally reuse any heap allocations its already made.
+///
+/// Traversal is not recursive.
+#[derive(Debug, Default, Clone)]
+pub struct Dfs {
+    stack: Vec<(Event, ir::Block)>,
+    seen: EntitySet<ir::Block>,
+}
+
+impl Dfs {
+    /// Construct a new depth-first traversal.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Perform a depth-first traversal over the given function.
+    ///
+    /// Yields pairs of `(Event, ir::Block)`.
+    ///
+    /// This iterator can be used to perform either pre- or post-order
+    /// traversals, or a combination of the two.
+    pub fn iter<'a>(&'a mut self, func: &'a ir::Function) -> DfsIter<'a> {
+        self.clear();
+        if let Some(e) = func.layout.entry_block() {
+            self.stack.push((Event::Enter, e));
+        }
+        DfsIter { dfs: self, func }
+    }
+
+    /// Perform a pre-order traversal over the given function.
+    ///
+    /// Yields `ir::Block` items.
+    pub fn pre_order_iter<'a>(&'a mut self, func: &'a ir::Function) -> DfsPreOrderIter<'a> {
+        DfsPreOrderIter(self.iter(func))
+    }
+
+    /// Perform a post-order traversal over the given function.
+    ///
+    /// Yields `ir::Block` items.
+    pub fn post_order_iter<'a>(&'a mut self, func: &'a ir::Function) -> DfsPostOrderIter<'a> {
+        DfsPostOrderIter(self.iter(func))
+    }
+
+    /// Clear this DFS, but keep its allocations for future reuse.
+    pub fn clear(&mut self) {
+        let Dfs { stack, seen } = self;
+        stack.clear();
+        seen.clear();
+    }
+}
+
+/// An iterator that yields pairs of `(Event, ir::Block)` items as it performs a
+/// depth-first traversal over its associated function.
+pub struct DfsIter<'a> {
+    dfs: &'a mut Dfs,
+    func: &'a ir::Function,
+}
+
+impl Iterator for DfsIter<'_> {
+    type Item = (Event, ir::Block);
+
+    fn next(&mut self) -> Option<(Event, ir::Block)> {
+        let (event, block) = self.dfs.stack.pop()?;
+
+        if event == Event::Enter && self.dfs.seen.insert(block) {
+            self.dfs.stack.push((Event::Exit, block));
+            self.dfs.stack.extend(
+                self.func
+                    .block_successors(block)
+                    // Heuristic: chase the children in reverse. This puts
+                    // the first successor block first in the postorder, all
+                    // other things being equal, which tends to prioritize
+                    // loop backedges over out-edges, putting the edge-block
+                    // closer to the loop body and minimizing live-ranges in
+                    // linear instruction space. This heuristic doesn't have
+                    // any effect on the computation of dominators, and is
+                    // purely for other consumers of the postorder we cache
+                    // here.
+                    .rev()
+                    // This is purely an optimization to avoid additional
+                    // iterations of the loop, and is not required; it's
+                    // merely inlining the check from the outer conditional
+                    // of this case to avoid the extra loop iteration. This
+                    // also avoids potential excess stack growth.
+                    .filter(|block| !self.dfs.seen.contains(*block))
+                    .map(|block| (Event::Enter, block)),
+            );
+        }
+
+        Some((event, block))
+    }
+}
+
+/// An iterator that yields `ir::Block` items during a depth-first, pre-order
+/// traversal over its associated function.
+pub struct DfsPreOrderIter<'a>(DfsIter<'a>);
+
+impl Iterator for DfsPreOrderIter<'_> {
+    type Item = ir::Block;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            match self.0.next()? {
+                (Event::Enter, b) => return Some(b),
+                (Event::Exit, _) => continue,
+            }
+        }
+    }
+}
+
+/// An iterator that yields `ir::Block` items during a depth-first, post-order
+/// traversal over its associated function.
+pub struct DfsPostOrderIter<'a>(DfsIter<'a>);
+
+impl Iterator for DfsPostOrderIter<'_> {
+    type Item = ir::Block;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            match self.0.next()? {
+                (Event::Exit, b) => return Some(b),
+                (Event::Enter, _) => continue,
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::cursor::{Cursor, FuncCursor};
+    use crate::ir::{types::I32, Function, InstBuilder, TrapCode};
+
+    #[test]
+    fn test_dfs_traversal() {
+        let _ = env_logger::try_init();
+
+        let mut func = Function::new();
+
+        let block0 = func.dfg.make_block();
+        let v0 = func.dfg.append_block_param(block0, I32);
+        let block1 = func.dfg.make_block();
+        let block2 = func.dfg.make_block();
+        let block3 = func.dfg.make_block();
+
+        let mut cur = FuncCursor::new(&mut func);
+
+        // block0(v0):
+        //   br_if v0, block2, trap_block
+        cur.insert_block(block0);
+        cur.ins().brif(v0, block2, &[], block3, &[]);
+
+        // block3:
+        //   trap user0
+        cur.insert_block(block3);
+        cur.ins().trap(TrapCode::User(0));
+
+        // block1:
+        //   v1 = iconst.i32 1
+        //   v2 = iadd v0, v1
+        //   jump block0(v2)
+        cur.insert_block(block1);
+        let v1 = cur.ins().iconst(I32, 1);
+        let v2 = cur.ins().iadd(v0, v1);
+        cur.ins().jump(block0, &[v2]);
+
+        // block2:
+        //   return v0
+        cur.insert_block(block2);
+        cur.ins().return_(&[v0]);
+
+        let mut dfs = Dfs::new();
+
+        assert_eq!(
+            dfs.iter(&func).collect::<Vec<_>>(),
+            vec![
+                (Event::Enter, block0),
+                (Event::Enter, block2),
+                (Event::Exit, block2),
+                (Event::Enter, block3),
+                (Event::Exit, block3),
+                (Event::Exit, block0)
+            ],
+        );
+    }
+}
diff --git a/cranelift/codegen/src/unionfind.rs b/cranelift/codegen/src/unionfind.rs
index a51f305c27a4..da96611ec366 100644
--- a/cranelift/codegen/src/unionfind.rs
+++ b/cranelift/codegen/src/unionfind.rs
@@ -3,16 +3,48 @@
 use crate::trace;
 use cranelift_entity::{packed_option::ReservedValue, EntityRef, SecondaryMap};
 use std::hash::Hash;
+use std::mem::swap;
 
 /// A union-find data structure. The data structure can allocate
-/// `Id`s, indicating eclasses, and can merge eclasses together.
+/// `Idx`s, indicating eclasses, and can merge eclasses together.
+///
+/// Running `union(a, b)` will change the canonical `Idx` of `a` or `b`.
+/// Usually, this is chosen based on what will minimize path lengths,
+/// but it is also possible to _pin_ an eclass, such that its canonical `Idx`
+/// won't change unless it gets unioned with another pinned eclass.
+///
+/// In the context of the egraph pass, merging two pinned eclasses
+/// is very unlikely to happen – we do not know a single concrete test case
+/// where it does. The only situation where it might happen looks as follows:
+///
+/// 1. We encounter terms `A` and `B`, and the optimizer does not find any
+///    reason to union them together.
+/// 2. We encounter a term `C`, and we rewrite `C -> A`, and separately, `C -> B`.
+///
+/// Unless `C` somehow includes some crucial hint without which it is hard to
+/// notice that `A = B`, there's probably a rewrite rule that we should add.
+///
+/// Worst case, if we do merge two pinned eclasses, some nodes will essentially
+/// disappear from the GVN map, which only affects the quality of the generated
+/// code.
 #[derive(Clone, Debug, PartialEq)]
 pub struct UnionFind<Idx: EntityRef> {
     parent: SecondaryMap<Idx, Val<Idx>>,
+    /// The `rank` table is used to perform the union operations optimally,
+    /// without creating unnecessarily long paths. Pins are represented by
+    /// eclasses with a rank of `u8::MAX`.
+    ///
+    /// `rank[x]` is the upper bound on the height of the subtree rooted at `x`.
+    /// The subtree is guaranteed to have at least `2**rank[x]` elements,
+    /// unless `rank` has been artificially inflated by pinning.
+    rank: SecondaryMap<Idx, u8>,
+
+    pub(crate) pinned_union_count: u64,
 }
 
 #[derive(Clone, Debug, PartialEq)]
 struct Val<Idx>(Idx);
+
 impl<Idx: EntityRef + ReservedValue> Default for Val<Idx> {
     fn default() -> Self {
         Self(Idx::reserved_value())
@@ -24,6 +56,8 @@ impl<Idx: EntityRef + Hash + std::fmt::Display + Ord + ReservedValue> UnionFind<
     pub fn with_capacity(cap: usize) -> Self {
         UnionFind {
             parent: SecondaryMap::with_capacity(cap),
+            rank: SecondaryMap::with_capacity(cap),
+            pinned_union_count: 0,
         }
     }
 
@@ -60,15 +94,50 @@ impl<Idx: EntityRef + Hash + std::fmt::Display + Ord + ReservedValue> UnionFind<
         node
     }
 
+    /// Request a stable identifier for `node`.
+    ///
+    /// After an `union` operation, the canonical representative of one
+    /// of the eclasses being merged together necessarily changes. If a pinned
+    /// eclass is merged with a non-pinned eclass, it'll be the other eclass
+    /// whose representative will change.
+    ///
+    /// If two pinned eclasses are unioned, one of the pins gets broken,
+    /// which is reported in the statistics for the pass. No concrete test case
+    /// which triggers this is known.
+    pub fn pin_index(&mut self, mut node: Idx) -> Idx {
+        node = self.find_and_update(node);
+        self.rank[node] = u8::MAX;
+        node
+    }
+
     /// Merge the equivalence classes of the two `Idx`s.
     pub fn union(&mut self, a: Idx, b: Idx) {
-        let a = self.find_and_update(a);
-        let b = self.find_and_update(b);
-        let (a, b) = (std::cmp::min(a, b), std::cmp::max(a, b));
-        if a != b {
-            // Always canonicalize toward lower IDs.
-            self.parent[b] = Val(a);
-            trace!("union: {}, {}", a, b);
+        let mut a = self.find_and_update(a);
+        let mut b = self.find_and_update(b);
+
+        if a == b {
+            return;
+        }
+
+        if self.rank[a] < self.rank[b] {
+            swap(&mut a, &mut b);
+        } else if self.rank[a] == self.rank[b] {
+            self.rank[a] = self.rank[a].checked_add(1).unwrap_or_else(
+                #[cold]
+                || {
+                    // Both `a` and `b` are pinned.
+                    //
+                    // This should only occur if we rewrite X -> Y and X -> Z,
+                    // yet neither Y -> Z nor Z -> Y can be established without
+                    // the "hint" provided by X. This probably means we're
+                    // missing an optimization rule.
+                    self.pinned_union_count += 1;
+                    u8::MAX
+                },
+            );
         }
+
+        self.parent[b] = Val(a);
+        trace!("union: {}, {}", a, b);
     }
 }
diff --git a/cranelift/codegen/src/verifier/mod.rs b/cranelift/codegen/src/verifier/mod.rs
index 5eaecaa190fa..d0a5efced6c7 100644
--- a/cranelift/codegen/src/verifier/mod.rs
+++ b/cranelift/codegen/src/verifier/mod.rs
@@ -47,6 +47,12 @@
 //! - Detect cycles in global values.
 //! - Detect use of 'vmctx' global value when no corresponding parameter is defined.
 //!
+//! Memory types
+//!
+//! - Ensure that struct fields are in offset order.
+//! - Ensure that struct fields are completely within the overall
+//!   struct size, and do not overlap.
+//!
 //! TODO:
 //! Ad hoc checking
 //!
@@ -66,7 +72,8 @@ use crate::ir::instructions::{CallInfo, InstructionFormat, ResolvedConstraint};
 use crate::ir::{self, ArgumentExtension};
 use crate::ir::{
     types, ArgumentPurpose, Block, Constant, DynamicStackSlot, FuncRef, Function, GlobalValue,
-    Inst, JumpTable, MemFlags, Opcode, SigRef, StackSlot, Type, Value, ValueDef, ValueList,
+    Inst, JumpTable, MemFlags, MemoryTypeData, Opcode, SigRef, StackSlot, Type, Value, ValueDef,
+    ValueList,
 };
 use crate::isa::TargetIsa;
 use crate::iterators::IteratorExtras;
@@ -150,7 +157,7 @@ where
 
 /// Result of a step in the verification process.
 ///
-/// Functions that return `VerifierStepResult<()>` should also take a
+/// Functions that return `VerifierStepResult` should also take a
 /// mutable reference to `VerifierErrors` as argument in order to report
 /// errors.
 ///
@@ -158,11 +165,11 @@ where
 /// meaning that the verification process may continue. However, other (non-fatal)
 /// errors might have been reported through the previously mentioned `VerifierErrors`
 /// argument.
-pub type VerifierStepResult<T> = Result<T, ()>;
+pub type VerifierStepResult = Result<(), ()>;
 
 /// Result of a verification operation.
 ///
-/// Unlike `VerifierStepResult<()>` which may be `Ok` while still having reported
+/// Unlike `VerifierStepResult` which may be `Ok` while still having reported
 /// errors, this type always returns `Err` if an error (fatal or not) was reported.
 pub type VerifierResult<T> = Result<T, VerifierErrors>;
 
@@ -196,7 +203,7 @@ impl VerifierErrors {
     /// Return a `VerifierStepResult` that is fatal if at least one error was reported,
     /// and non-fatal otherwise.
     #[inline]
-    pub fn as_result(&self) -> VerifierStepResult<()> {
+    pub fn as_result(&self) -> VerifierStepResult {
         if self.is_empty() {
             Ok(())
         } else {
@@ -210,13 +217,13 @@ impl VerifierErrors {
     }
 
     /// Report a fatal error and return `Err`.
-    pub fn fatal(&mut self, error: impl Into<VerifierError>) -> VerifierStepResult<()> {
+    pub fn fatal(&mut self, error: impl Into<VerifierError>) -> VerifierStepResult {
         self.report(error);
         Err(())
     }
 
     /// Report a non-fatal error and return `Ok`.
-    pub fn nonfatal(&mut self, error: impl Into<VerifierError>) -> VerifierStepResult<()> {
+    pub fn nonfatal(&mut self, error: impl Into<VerifierError>) -> VerifierStepResult {
         self.report(error);
         Ok(())
     }
@@ -247,7 +254,7 @@ impl Into<VerifierResult<()>> for VerifierErrors {
 impl Display for VerifierErrors {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         for err in &self.0 {
-            writeln!(f, "- {}", err)?;
+            writeln!(f, "- {err}")?;
         }
         Ok(())
     }
@@ -278,7 +285,7 @@ pub fn verify_context<'a, FOI: Into<FlagsOrIsa<'a>>>(
     domtree: &DominatorTree,
     fisa: FOI,
     errors: &mut VerifierErrors,
-) -> VerifierStepResult<()> {
+) -> VerifierStepResult {
     let _tt = timing::verifier();
     let verifier = Verifier::new(func, fisa.into());
     if cfg.is_valid() {
@@ -318,7 +325,7 @@ impl<'a> Verifier<'a> {
     // Check for:
     //  - cycles in the global value declarations.
     //  - use of 'vmctx' when no special parameter declares it.
-    fn verify_global_values(&self, errors: &mut VerifierErrors) -> VerifierStepResult<()> {
+    fn verify_global_values(&self, errors: &mut VerifierErrors) -> VerifierStepResult {
         let mut cycle_seen = false;
         let mut seen = SparseSet::new();
 
@@ -356,7 +363,7 @@ impl<'a> Verifier<'a> {
                         .special_param(ir::ArgumentPurpose::VMContext)
                         .is_none()
                     {
-                        errors.report((gv, format!("undeclared vmctx reference {}", gv)));
+                        errors.report((gv, format!("undeclared vmctx reference {gv}")));
                     }
                 }
                 ir::GlobalValueData::IAddImm {
@@ -365,7 +372,7 @@ impl<'a> Verifier<'a> {
                     if !global_type.is_int() {
                         errors.report((
                             gv,
-                            format!("iadd_imm global value with non-int type {}", global_type),
+                            format!("iadd_imm global value with non-int type {global_type}"),
                         ));
                     } else if let Some(isa) = self.isa {
                         let base_type = self.func.global_values[base].global_type(isa);
@@ -373,8 +380,7 @@ impl<'a> Verifier<'a> {
                             errors.report((
                                 gv,
                                 format!(
-                                    "iadd_imm type {} differs from operand type {}",
-                                    global_type, base_type
+                                    "iadd_imm type {global_type} differs from operand type {base_type}"
                                 ),
                             ));
                         }
@@ -388,8 +394,7 @@ impl<'a> Verifier<'a> {
                             errors.report((
                                 gv,
                                 format!(
-                                    "base {} has type {}, which is not the pointer type {}",
-                                    base, base_type, pointer_type
+                                    "base {base} has type {base_type}, which is not the pointer type {pointer_type}"
                                 ),
                             ));
                         }
@@ -403,43 +408,47 @@ impl<'a> Verifier<'a> {
         Ok(())
     }
 
-    fn verify_tables(&self, errors: &mut VerifierErrors) -> VerifierStepResult<()> {
-        if let Some(isa) = self.isa {
-            for (table, table_data) in &self.func.tables {
-                let base = table_data.base_gv;
-                if !self.func.global_values.is_valid(base) {
-                    return errors.nonfatal((table, format!("invalid base global value {}", base)));
-                }
-
-                let pointer_type = isa.pointer_type();
-                let base_type = self.func.global_values[base].global_type(isa);
-                if base_type != pointer_type {
-                    errors.report((
-                        table,
-                        format!(
-                            "table base has type {}, which is not the pointer type {}",
-                            base_type, pointer_type
-                        ),
-                    ));
-                }
-
-                let bound_gv = table_data.bound_gv;
-                if !self.func.global_values.is_valid(bound_gv) {
-                    return errors
-                        .nonfatal((table, format!("invalid bound global value {}", bound_gv)));
-                }
+    fn verify_memory_types(&self, errors: &mut VerifierErrors) -> VerifierStepResult {
+        // Verify that all fields are statically-sized and lie within
+        // the struct, do not overlap, and are in offset order
+        for (mt, mt_data) in &self.func.memory_types {
+            match mt_data {
+                MemoryTypeData::Struct { size, fields } => {
+                    let mut last_offset = 0;
+                    for field in fields {
+                        if field.offset < last_offset {
+                            errors.report((
+                                mt,
+                                format!(
+                                    "memory type {} has a field at offset {}, which is out-of-order",
+                                    mt, field.offset
+                                ),
+                            ));
+                        }
+                        last_offset = match field.offset.checked_add(u64::from(field.ty.bytes())) {
+                            Some(o) => o,
+                            None => {
+                                errors.report((
+                                        mt,
+                                        format!(
+                                            "memory type {} has a field at offset {} of size {}; offset plus size overflows a u64",
+                                            mt, field.offset, field.ty.bytes()),
+                                ));
+                                break;
+                            }
+                        };
 
-                let index_type = table_data.index_type;
-                let bound_type = self.func.global_values[bound_gv].global_type(isa);
-                if index_type != bound_type {
-                    errors.report((
-                        table,
-                        format!(
-                            "table index type {} differs from the type of its bound, {}",
-                            index_type, bound_type
-                        ),
-                    ));
+                        if last_offset > *size {
+                            errors.report((
+                                        mt,
+                                        format!(
+                                            "memory type {} has a field at offset {} of size {} that overflows the struct size {}",
+                                            mt, field.offset, field.ty.bytes(), *size),
+                                          ));
+                        }
+                    }
                 }
+                _ => {}
             }
         }
 
@@ -448,7 +457,7 @@ impl<'a> Verifier<'a> {
 
     /// Check that the given block can be encoded as a BB, by checking that only
     /// branching instructions are ending the block.
-    fn encodable_as_bb(&self, block: Block, errors: &mut VerifierErrors) -> VerifierStepResult<()> {
+    fn encodable_as_bb(&self, block: Block, errors: &mut VerifierErrors) -> VerifierStepResult {
         match self.func.is_block_basic(block) {
             Ok(()) => Ok(()),
             Err((inst, message)) => errors.fatal((inst, self.context(inst), message)),
@@ -460,7 +469,7 @@ impl<'a> Verifier<'a> {
         block: Block,
         inst: Inst,
         errors: &mut VerifierErrors,
-    ) -> VerifierStepResult<()> {
+    ) -> VerifierStepResult {
         let is_terminator = self.func.dfg.insts[inst].opcode().is_terminator();
         let is_last_inst = self.func.layout.last_inst(block) == Some(inst);
 
@@ -469,10 +478,7 @@ impl<'a> Verifier<'a> {
             return errors.fatal((
                 inst,
                 self.context(inst),
-                format!(
-                    "a terminator instruction was encountered before the end of {}",
-                    block
-                ),
+                format!("a terminator instruction was encountered before the end of {block}"),
             ));
         }
         if is_last_inst && !is_terminator {
@@ -485,7 +491,7 @@ impl<'a> Verifier<'a> {
             return errors.fatal((
                 inst,
                 self.context(inst),
-                format!("should belong to {} not {:?}", block, inst_block),
+                format!("should belong to {block} not {inst_block:?}"),
             ));
         }
 
@@ -494,7 +500,7 @@ impl<'a> Verifier<'a> {
             match self.func.dfg.value_def(arg) {
                 ValueDef::Param(arg_block, _) => {
                     if block != arg_block {
-                        return errors.fatal((arg, format!("does not belong to {}", block)));
+                        return errors.fatal((arg, format!("does not belong to {block}")));
                     }
                 }
                 _ => {
@@ -506,11 +512,7 @@ impl<'a> Verifier<'a> {
         Ok(())
     }
 
-    fn instruction_integrity(
-        &self,
-        inst: Inst,
-        errors: &mut VerifierErrors,
-    ) -> VerifierStepResult<()> {
+    fn instruction_integrity(&self, inst: Inst, errors: &mut VerifierErrors) -> VerifierStepResult {
         let inst_data = &self.func.dfg.insts[inst];
         let dfg = &self.func.dfg;
 
@@ -542,7 +544,7 @@ impl<'a> Verifier<'a> {
         &self,
         inst: Inst,
         errors: &mut VerifierErrors,
-    ) -> VerifierStepResult<()> {
+    ) -> VerifierStepResult {
         use crate::ir::instructions::InstructionData::*;
 
         for arg in self.func.dfg.inst_values(inst) {
@@ -554,7 +556,7 @@ impl<'a> Verifier<'a> {
                 errors.report((
                     inst,
                     self.context(inst),
-                    format!("argument {} -> {} is not attached", arg, original),
+                    format!("argument {arg} -> {original} is not attached"),
                 ));
             }
         }
@@ -611,9 +613,6 @@ impl<'a> Verifier<'a> {
             UnaryGlobalValue { global_value, .. } => {
                 self.verify_global_value(inst, global_value, errors)?;
             }
-            TableAddr { table, .. } => {
-                self.verify_table(inst, table, errors)?;
-            }
             NullAry {
                 opcode: Opcode::GetPinnedReg,
             }
@@ -667,11 +666,11 @@ impl<'a> Verifier<'a> {
                 self.verify_bitcast(inst, flags, arg, errors)?;
             }
             UnaryConst {
-                opcode: Opcode::Vconst,
+                opcode: opcode @ (Opcode::Vconst | Opcode::F128const),
                 constant_handle,
                 ..
             } => {
-                self.verify_constant_size(inst, constant_handle, errors)?;
+                self.verify_constant_size(inst, opcode, constant_handle, errors)?;
             }
 
             // Exhaustive list so we can't forget to add new formats
@@ -682,6 +681,7 @@ impl<'a> Verifier<'a> {
             | Unary { .. }
             | UnaryConst { .. }
             | UnaryImm { .. }
+            | UnaryIeee16 { .. }
             | UnaryIeee32 { .. }
             | UnaryIeee64 { .. }
             | Binary { .. }
@@ -709,13 +709,13 @@ impl<'a> Verifier<'a> {
         loc: impl Into<AnyEntity>,
         e: Block,
         errors: &mut VerifierErrors,
-    ) -> VerifierStepResult<()> {
+    ) -> VerifierStepResult {
         if !self.func.dfg.block_is_valid(e) || !self.func.layout.is_block_inserted(e) {
-            return errors.fatal((loc, format!("invalid block reference {}", e)));
+            return errors.fatal((loc, format!("invalid block reference {e}")));
         }
         if let Some(entry_block) = self.func.layout.entry_block() {
             if e == entry_block {
-                return errors.fatal((loc, format!("invalid reference to entry block {}", e)));
+                return errors.fatal((loc, format!("invalid reference to entry block {e}")));
             }
         }
         Ok(())
@@ -726,12 +726,12 @@ impl<'a> Verifier<'a> {
         inst: Inst,
         s: SigRef,
         errors: &mut VerifierErrors,
-    ) -> VerifierStepResult<()> {
+    ) -> VerifierStepResult {
         if !self.func.dfg.signatures.is_valid(s) {
             errors.fatal((
                 inst,
                 self.context(inst),
-                format!("invalid signature reference {}", s),
+                format!("invalid signature reference {s}"),
             ))
         } else {
             Ok(())
@@ -743,12 +743,12 @@ impl<'a> Verifier<'a> {
         inst: Inst,
         f: FuncRef,
         errors: &mut VerifierErrors,
-    ) -> VerifierStepResult<()> {
+    ) -> VerifierStepResult {
         if !self.func.dfg.ext_funcs.is_valid(f) {
             errors.nonfatal((
                 inst,
                 self.context(inst),
-                format!("invalid function reference {}", f),
+                format!("invalid function reference {f}"),
             ))
         } else {
             Ok(())
@@ -760,13 +760,9 @@ impl<'a> Verifier<'a> {
         inst: Inst,
         ss: StackSlot,
         errors: &mut VerifierErrors,
-    ) -> VerifierStepResult<()> {
+    ) -> VerifierStepResult {
         if !self.func.sized_stack_slots.is_valid(ss) {
-            errors.nonfatal((
-                inst,
-                self.context(inst),
-                format!("invalid stack slot {}", ss),
-            ))
+            errors.nonfatal((inst, self.context(inst), format!("invalid stack slot {ss}")))
         } else {
             Ok(())
         }
@@ -777,12 +773,12 @@ impl<'a> Verifier<'a> {
         inst: Inst,
         ss: DynamicStackSlot,
         errors: &mut VerifierErrors,
-    ) -> VerifierStepResult<()> {
+    ) -> VerifierStepResult {
         if !self.func.dynamic_stack_slots.is_valid(ss) {
             errors.nonfatal((
                 inst,
                 self.context(inst),
-                format!("invalid dynamic stack slot {}", ss),
+                format!("invalid dynamic stack slot {ss}"),
             ))
         } else {
             Ok(())
@@ -794,42 +790,29 @@ impl<'a> Verifier<'a> {
         inst: Inst,
         gv: GlobalValue,
         errors: &mut VerifierErrors,
-    ) -> VerifierStepResult<()> {
+    ) -> VerifierStepResult {
         if !self.func.global_values.is_valid(gv) {
             errors.nonfatal((
                 inst,
                 self.context(inst),
-                format!("invalid global value {}", gv),
+                format!("invalid global value {gv}"),
             ))
         } else {
             Ok(())
         }
     }
 
-    fn verify_table(
-        &self,
-        inst: Inst,
-        table: ir::Table,
-        errors: &mut VerifierErrors,
-    ) -> VerifierStepResult<()> {
-        if !self.func.tables.is_valid(table) {
-            errors.nonfatal((inst, self.context(inst), format!("invalid table {}", table)))
-        } else {
-            Ok(())
-        }
-    }
-
     fn verify_value_list(
         &self,
         inst: Inst,
         l: &ValueList,
         errors: &mut VerifierErrors,
-    ) -> VerifierStepResult<()> {
+    ) -> VerifierStepResult {
         if !l.is_valid(&self.func.dfg.value_lists) {
             errors.nonfatal((
                 inst,
                 self.context(inst),
-                format!("invalid value list reference {:?}", l),
+                format!("invalid value list reference {l:?}"),
             ))
         } else {
             Ok(())
@@ -841,12 +824,12 @@ impl<'a> Verifier<'a> {
         inst: Inst,
         j: JumpTable,
         errors: &mut VerifierErrors,
-    ) -> VerifierStepResult<()> {
+    ) -> VerifierStepResult {
         if !self.func.stencil.dfg.jump_tables.is_valid(j) {
             errors.nonfatal((
                 inst,
                 self.context(inst),
-                format!("invalid jump table reference {}", j),
+                format!("invalid jump table reference {j}"),
             ))
         } else {
             let pool = &self.func.stencil.dfg.value_lists;
@@ -862,13 +845,13 @@ impl<'a> Verifier<'a> {
         loc_inst: Inst,
         v: Value,
         errors: &mut VerifierErrors,
-    ) -> VerifierStepResult<()> {
+    ) -> VerifierStepResult {
         let dfg = &self.func.dfg;
         if !dfg.value_is_valid(v) {
             errors.nonfatal((
                 loc_inst,
                 self.context(loc_inst),
-                format!("invalid value reference {}", v),
+                format!("invalid value reference {v}"),
             ))
         } else {
             Ok(())
@@ -880,7 +863,7 @@ impl<'a> Verifier<'a> {
         loc_inst: Inst,
         v: Value,
         errors: &mut VerifierErrors,
-    ) -> VerifierStepResult<()> {
+    ) -> VerifierStepResult {
         self.verify_value(loc_inst, v, errors)?;
 
         let dfg = &self.func.dfg;
@@ -899,7 +882,7 @@ impl<'a> Verifier<'a> {
                     return errors.fatal((
                         loc_inst,
                         self.context(loc_inst),
-                        format!("{} is defined by invalid instruction {}", v, def_inst),
+                        format!("{v} is defined by invalid instruction {def_inst}"),
                     ));
                 }
                 // Defining instruction is inserted in a block.
@@ -907,7 +890,7 @@ impl<'a> Verifier<'a> {
                     return errors.fatal((
                         loc_inst,
                         self.context(loc_inst),
-                        format!("{} is defined by {} which has no block", v, def_inst),
+                        format!("{v} is defined by {def_inst} which has no block"),
                     ));
                 }
                 // Defining instruction dominates the instruction that uses the value.
@@ -919,14 +902,14 @@ impl<'a> Verifier<'a> {
                         return errors.fatal((
                             loc_inst,
                             self.context(loc_inst),
-                            format!("uses value {} from non-dominating {}", v, def_inst),
+                            format!("uses value {v} from non-dominating {def_inst}"),
                         ));
                     }
                     if def_inst == loc_inst {
                         return errors.fatal((
                             loc_inst,
                             self.context(loc_inst),
-                            format!("uses value {} from itself", v),
+                            format!("uses value {v} from itself"),
                         ));
                     }
                 }
@@ -937,7 +920,7 @@ impl<'a> Verifier<'a> {
                     return errors.fatal((
                         loc_inst,
                         self.context(loc_inst),
-                        format!("{} is defined by invalid block {}", v, block),
+                        format!("{v} is defined by invalid block {block}"),
                     ));
                 }
                 // Defining block is inserted in the layout
@@ -945,7 +928,7 @@ impl<'a> Verifier<'a> {
                     return errors.fatal((
                         loc_inst,
                         self.context(loc_inst),
-                        format!("{} is defined by {} which is not in the layout", v, block),
+                        format!("{v} is defined by {block} which is not in the layout"),
                     ));
                 }
                 // The defining block dominates the instruction using this value.
@@ -957,7 +940,7 @@ impl<'a> Verifier<'a> {
                     return errors.fatal((
                         loc_inst,
                         self.context(loc_inst),
-                        format!("uses value arg from non-dominating {}", block),
+                        format!("uses value arg from non-dominating {block}"),
                     ));
                 }
             }
@@ -974,7 +957,7 @@ impl<'a> Verifier<'a> {
         loc_inst: Inst,
         v: Value,
         errors: &mut VerifierErrors,
-    ) -> VerifierStepResult<()> {
+    ) -> VerifierStepResult {
         self.verify_value(loc_inst, v, errors)?;
 
         match self.func.dfg.value_def(v) {
@@ -983,7 +966,7 @@ impl<'a> Verifier<'a> {
                     errors.fatal((
                         loc_inst,
                         self.context(loc_inst),
-                        format!("instruction result {} is not defined by the instruction", v),
+                        format!("instruction result {v} is not defined by the instruction"),
                     ))
                 } else {
                     Ok(())
@@ -992,12 +975,12 @@ impl<'a> Verifier<'a> {
             ValueDef::Param(_, _) => errors.fatal((
                 loc_inst,
                 self.context(loc_inst),
-                format!("instruction result {} is not defined by the instruction", v),
+                format!("instruction result {v} is not defined by the instruction"),
             )),
             ValueDef::Union(_, _) => errors.fatal((
                 loc_inst,
                 self.context(loc_inst),
-                format!("instruction result {} is a union node", v),
+                format!("instruction result {v} is a union node"),
             )),
         }
     }
@@ -1008,7 +991,7 @@ impl<'a> Verifier<'a> {
         flags: MemFlags,
         arg: Value,
         errors: &mut VerifierErrors,
-    ) -> VerifierStepResult<()> {
+    ) -> VerifierStepResult {
         let typ = self.func.dfg.ctrl_typevar(inst);
         let value_type = self.func.dfg.value_type(arg);
 
@@ -1043,17 +1026,21 @@ impl<'a> Verifier<'a> {
     fn verify_constant_size(
         &self,
         inst: Inst,
+        opcode: Opcode,
         constant: Constant,
         errors: &mut VerifierErrors,
-    ) -> VerifierStepResult<()> {
-        let type_size = self.func.dfg.ctrl_typevar(inst).bytes() as usize;
+    ) -> VerifierStepResult {
+        let type_size = match opcode {
+            Opcode::F128const => types::F128.bytes(),
+            Opcode::Vconst => self.func.dfg.ctrl_typevar(inst).bytes(),
+            _ => unreachable!("unexpected opcode {opcode:?}"),
+        } as usize;
         let constant_size = self.func.dfg.constants.get(constant).len();
         if type_size != constant_size {
             errors.fatal((
                 inst,
                 format!(
-                    "The instruction expects {} to have a size of {} bytes but it has {}",
-                    constant, type_size, constant_size
+                    "The instruction expects {constant} to have a size of {type_size} bytes but it has {constant_size}"
                 ),
             ))
         } else {
@@ -1065,7 +1052,7 @@ impl<'a> Verifier<'a> {
         &self,
         domtree: &DominatorTree,
         errors: &mut VerifierErrors,
-    ) -> VerifierStepResult<()> {
+    ) -> VerifierStepResult {
         // We consider two `DominatorTree`s to be equal if they return the same immediate
         // dominator for each block. Therefore the current domtree is valid if it matches the freshly
         // computed one.
@@ -1075,10 +1062,7 @@ impl<'a> Verifier<'a> {
             if got != expected {
                 return errors.fatal((
                     block,
-                    format!(
-                        "invalid domtree, expected idom({}) = {:?}, got {:?}",
-                        block, expected, got
-                    ),
+                    format!("invalid domtree, expected idom({block}) = {expected:?}, got {got:?}"),
                 ));
             }
         }
@@ -1099,8 +1083,7 @@ impl<'a> Verifier<'a> {
                 return errors.fatal((
                     test_block,
                     format!(
-                        "invalid domtree, postorder block number {} should be {}, got {}",
-                        index, true_block, test_block
+                        "invalid domtree, postorder block number {index} should be {true_block}, got {test_block}"
                     ),
                 ));
             }
@@ -1111,8 +1094,8 @@ impl<'a> Verifier<'a> {
                 return errors.fatal((
                     next_block,
                     format!(
-                        "invalid domtree, rpo_cmp_block does not says {} is greater than {}",
-                        prev_block, next_block
+                        "invalid domtree, rpo_cmp_block does not say {} is greater than {}; rpo = {:#?}",
+                        prev_block, next_block, domtree.cfg_postorder()
                     ),
                 ));
             }
@@ -1120,7 +1103,7 @@ impl<'a> Verifier<'a> {
         Ok(())
     }
 
-    fn typecheck_entry_block_params(&self, errors: &mut VerifierErrors) -> VerifierStepResult<()> {
+    fn typecheck_entry_block_params(&self, errors: &mut VerifierErrors) -> VerifierStepResult {
         if let Some(block) = self.func.layout.entry_block() {
             let expected_types = &self.func.signature.params;
             let block_param_count = self.func.dfg.num_block_params(block);
@@ -1153,7 +1136,7 @@ impl<'a> Verifier<'a> {
         errors.as_result()
     }
 
-    fn check_entry_not_cold(&self, errors: &mut VerifierErrors) -> VerifierStepResult<()> {
+    fn check_entry_not_cold(&self, errors: &mut VerifierErrors) -> VerifierStepResult {
         if let Some(entry_block) = self.func.layout.entry_block() {
             if self.func.layout.is_cold(entry_block) {
                 return errors
@@ -1163,7 +1146,7 @@ impl<'a> Verifier<'a> {
         errors.as_result()
     }
 
-    fn typecheck(&self, inst: Inst, errors: &mut VerifierErrors) -> VerifierStepResult<()> {
+    fn typecheck(&self, inst: Inst, errors: &mut VerifierErrors) -> VerifierStepResult {
         let inst_data = &self.func.dfg.insts[inst];
         let constraints = inst_data.opcode().constraints();
 
@@ -1176,8 +1159,7 @@ impl<'a> Verifier<'a> {
                     inst,
                     self.context(inst),
                     format!(
-                        "has an invalid controlling type {} (allowed set is {:?})",
-                        ctrl_type, value_typeset
+                        "has an invalid controlling type {ctrl_type} (allowed set is {value_typeset:?})"
                     ),
                 ));
             }
@@ -1204,7 +1186,7 @@ impl<'a> Verifier<'a> {
         inst: Inst,
         ctrl_type: Type,
         errors: &mut VerifierErrors,
-    ) -> VerifierStepResult<()> {
+    ) -> VerifierStepResult {
         let mut i = 0;
         for &result in self.func.dfg.inst_results(inst) {
             let result_type = self.func.dfg.value_type(result);
@@ -1215,8 +1197,7 @@ impl<'a> Verifier<'a> {
                         inst,
                         self.context(inst),
                         format!(
-                            "expected result {} ({}) to have type {}, found {}",
-                            i, result, expected_type, result_type
+                            "expected result {i} ({result}) to have type {expected_type}, found {result_type}"
                         ),
                     ));
                 }
@@ -1246,7 +1227,7 @@ impl<'a> Verifier<'a> {
         inst: Inst,
         ctrl_type: Type,
         errors: &mut VerifierErrors,
-    ) -> VerifierStepResult<()> {
+    ) -> VerifierStepResult {
         let constraints = self.func.dfg.insts[inst].opcode().constraints();
 
         for (i, &arg) in self.func.dfg.inst_fixed_args(inst).iter().enumerate() {
@@ -1258,8 +1239,7 @@ impl<'a> Verifier<'a> {
                             inst,
                             self.context(inst),
                             format!(
-                                "arg {} ({}) has type {}, expected {}",
-                                i, arg, arg_type, expected_type
+                                "arg {i} ({arg}) has type {arg_type}, expected {expected_type}"
                             ),
                         ));
                     }
@@ -1270,8 +1250,7 @@ impl<'a> Verifier<'a> {
                             inst,
                             self.context(inst),
                             format!(
-                                "arg {} ({}) with type {} failed to satisfy type set {:?}",
-                                i, arg, arg_type, type_set
+                                "arg {i} ({arg}) with type {arg_type} failed to satisfy type set {type_set:?}"
                             ),
                         ));
                     }
@@ -1287,7 +1266,7 @@ impl<'a> Verifier<'a> {
         &self,
         inst: Inst,
         errors: &mut VerifierErrors,
-    ) -> VerifierStepResult<()> {
+    ) -> VerifierStepResult {
         match &self.func.dfg.insts[inst] {
             ir::InstructionData::Jump { destination, .. } => {
                 self.typecheck_block_call(inst, destination, errors)?;
@@ -1333,7 +1312,7 @@ impl<'a> Verifier<'a> {
         inst: Inst,
         block: &ir::BlockCall,
         errors: &mut VerifierErrors,
-    ) -> VerifierStepResult<()> {
+    ) -> VerifierStepResult {
         let pool = &self.func.dfg.value_lists;
         let iter = self
             .func
@@ -1351,7 +1330,7 @@ impl<'a> Verifier<'a> {
         iter: I,
         variable_args: &[Value],
         errors: &mut VerifierErrors,
-    ) -> VerifierStepResult<()> {
+    ) -> VerifierStepResult {
         let mut i = 0;
 
         for expected_type in iter {
@@ -1389,7 +1368,7 @@ impl<'a> Verifier<'a> {
         Ok(())
     }
 
-    fn typecheck_return(&self, inst: Inst, errors: &mut VerifierErrors) -> VerifierStepResult<()> {
+    fn typecheck_return(&self, inst: Inst, errors: &mut VerifierErrors) -> VerifierStepResult {
         match self.func.dfg.insts[inst] {
             ir::InstructionData::MultiAry {
                 opcode: Opcode::Return,
@@ -1431,7 +1410,7 @@ impl<'a> Verifier<'a> {
         inst: Inst,
         sig_ref: SigRef,
         errors: &mut VerifierErrors,
-    ) -> VerifierStepResult<()> {
+    ) -> VerifierStepResult {
         let signature = &self.func.dfg.signatures[sig_ref];
         let cc = signature.call_conv;
         if !cc.supports_tail_calls() {
@@ -1459,7 +1438,7 @@ impl<'a> Verifier<'a> {
         actual_types: impl ExactSizeIterator<Item = Type>,
         errors: &mut VerifierErrors,
         message: &str,
-    ) -> VerifierStepResult<()> {
+    ) -> VerifierStepResult {
         let expected_types = &self.func.signature.returns;
         if actual_types.len() != expected_types.len() {
             return errors.nonfatal((inst, self.context(inst), message));
@@ -1481,22 +1460,8 @@ impl<'a> Verifier<'a> {
 
     // Check special-purpose type constraints that can't be expressed in the normal opcode
     // constraints.
-    fn typecheck_special(&self, inst: Inst, errors: &mut VerifierErrors) -> VerifierStepResult<()> {
+    fn typecheck_special(&self, inst: Inst, errors: &mut VerifierErrors) -> VerifierStepResult {
         match self.func.dfg.insts[inst] {
-            ir::InstructionData::TableAddr { table, arg, .. } => {
-                let index_type = self.func.dfg.value_type(arg);
-                let table_index_type = self.func.tables[table].index_type;
-                if index_type != table_index_type {
-                    return errors.nonfatal((
-                        inst,
-                        self.context(inst),
-                        format!(
-                            "index type {} differs from table index type {}",
-                            index_type, table_index_type,
-                        ),
-                    ));
-                }
-            }
             ir::InstructionData::UnaryGlobalValue { global_value, .. } => {
                 if let Some(isa) = self.isa {
                     let inst_type = self.func.dfg.value_type(self.func.dfg.first_result(inst));
@@ -1505,8 +1470,7 @@ impl<'a> Verifier<'a> {
                         return errors.nonfatal((
                             inst, self.context(inst),
                             format!(
-                                "global_value instruction with type {} references global value with type {}",
-                                inst_type, global_type
+                                "global_value instruction with type {inst_type} references global value with type {global_type}"
                             )),
                         );
                     }
@@ -1521,7 +1485,7 @@ impl<'a> Verifier<'a> {
         &self,
         cfg: &ControlFlowGraph,
         errors: &mut VerifierErrors,
-    ) -> VerifierStepResult<()> {
+    ) -> VerifierStepResult {
         let mut expected_succs = BTreeSet::<Block>::new();
         let mut got_succs = BTreeSet::<Block>::new();
         let mut expected_preds = BTreeSet::<Inst>::new();
@@ -1536,7 +1500,7 @@ impl<'a> Verifier<'a> {
             if !missing_succs.is_empty() {
                 errors.report((
                     block,
-                    format!("cfg lacked the following successor(s) {:?}", missing_succs),
+                    format!("cfg lacked the following successor(s) {missing_succs:?}"),
                 ));
                 continue;
             }
@@ -1545,7 +1509,7 @@ impl<'a> Verifier<'a> {
             if !excess_succs.is_empty() {
                 errors.report((
                     block,
-                    format!("cfg had unexpected successor(s) {:?}", excess_succs),
+                    format!("cfg had unexpected successor(s) {excess_succs:?}"),
                 ));
                 continue;
             }
@@ -1564,10 +1528,7 @@ impl<'a> Verifier<'a> {
             if !missing_preds.is_empty() {
                 errors.report((
                     block,
-                    format!(
-                        "cfg lacked the following predecessor(s) {:?}",
-                        missing_preds
-                    ),
+                    format!("cfg lacked the following predecessor(s) {missing_preds:?}"),
                 ));
                 continue;
             }
@@ -1576,7 +1537,7 @@ impl<'a> Verifier<'a> {
             if !excess_preds.is_empty() {
                 errors.report((
                     block,
-                    format!("cfg had unexpected predecessor(s) {:?}", excess_preds),
+                    format!("cfg had unexpected predecessor(s) {excess_preds:?}"),
                 ));
                 continue;
             }
@@ -1589,11 +1550,7 @@ impl<'a> Verifier<'a> {
         errors.as_result()
     }
 
-    fn immediate_constraints(
-        &self,
-        inst: Inst,
-        errors: &mut VerifierErrors,
-    ) -> VerifierStepResult<()> {
+    fn immediate_constraints(&self, inst: Inst, errors: &mut VerifierErrors) -> VerifierStepResult {
         let inst_data = &self.func.dfg.insts[inst];
 
         match *inst_data {
@@ -1627,7 +1584,7 @@ impl<'a> Verifier<'a> {
                     errors.fatal((
                         inst,
                         self.context(inst),
-                        format!("The lane {} does not index into the type {}", lane, ty,),
+                        format!("The lane {lane} does not index into the type {ty}",),
                     ))
                 } else {
                     Ok(())
@@ -1659,7 +1616,7 @@ impl<'a> Verifier<'a> {
         }
     }
 
-    fn iconst_bounds(&self, inst: Inst, errors: &mut VerifierErrors) -> VerifierStepResult<()> {
+    fn iconst_bounds(&self, inst: Inst, errors: &mut VerifierErrors) -> VerifierStepResult {
         use crate::ir::instructions::InstructionData::UnaryImm;
 
         let inst_data = &self.func.dfg.insts[inst];
@@ -1692,7 +1649,7 @@ impl<'a> Verifier<'a> {
         }
     }
 
-    fn typecheck_function_signature(&self, errors: &mut VerifierErrors) -> VerifierStepResult<()> {
+    fn typecheck_function_signature(&self, errors: &mut VerifierErrors) -> VerifierStepResult {
         let params = self
             .func
             .signature
@@ -1752,16 +1709,16 @@ impl<'a> Verifier<'a> {
         }
     }
 
-    pub fn run(&self, errors: &mut VerifierErrors) -> VerifierStepResult<()> {
+    pub fn run(&self, errors: &mut VerifierErrors) -> VerifierStepResult {
         self.verify_global_values(errors)?;
-        self.verify_tables(errors)?;
+        self.verify_memory_types(errors)?;
         self.typecheck_entry_block_params(errors)?;
         self.check_entry_not_cold(errors)?;
         self.typecheck_function_signature(errors)?;
 
         for block in self.func.layout.blocks() {
             if self.func.layout.first_inst(block).is_none() {
-                return errors.fatal((block, format!("{} cannot be empty", block)));
+                return errors.fatal((block, format!("{block} cannot be empty")));
             }
             for inst in self.func.layout.block_insts(block) {
                 self.block_integrity(block, inst, errors)?;
@@ -1861,7 +1818,7 @@ mod tests {
             args: Default::default(),
         });
 
-        func.dfg.append_result(test_inst, ctrl_typevar);
+        func.dfg.make_inst_results(test_inst, ctrl_typevar);
         func.layout.append_inst(test_inst, block0);
         func.layout.append_inst(end_inst, block0);
 
@@ -1947,13 +1904,11 @@ mod tests {
         let block0 = func.dfg.make_block();
         func.layout.append_block(block0);
 
-        // Build instruction: v0, v1 = iconst 42
-        let inst = func.dfg.make_inst(InstructionData::UnaryImm {
-            opcode: Opcode::Iconst,
-            imm: 42.into(),
+        // Build instruction "f64const 0.0" (missing one required result)
+        let inst = func.dfg.make_inst(InstructionData::UnaryIeee64 {
+            opcode: Opcode::F64const,
+            imm: 0.0.into(),
         });
-        func.dfg.append_result(inst, types::I32);
-        func.dfg.append_result(inst, types::I32);
         func.layout.append_inst(inst, block0);
 
         // Setup verifier.
@@ -1962,11 +1917,11 @@ mod tests {
         let verifier = Verifier::new(&func, flags.into());
 
         // Now the error message, when printed, should contain the instruction sequence causing the
-        // error (i.e. v0, v1 = iconst.i32 42) and not only its entity value (i.e. inst0)
+        // error (i.e. f64const 0.0) and not only its entity value (i.e. inst0)
         let _ = verifier.typecheck_results(inst, types::I32, &mut errors);
         assert_eq!(
             format!("{}", errors.0[0]),
-            "inst0 (v0, v1 = iconst.i32 42): has more result values than expected"
+            "inst0 (f64const 0.0): has fewer result values than expected"
         )
     }
 
diff --git a/cranelift/codegen/src/write.rs b/cranelift/codegen/src/write.rs
index 39025fd7addc..5c77aa679275 100644
--- a/cranelift/codegen/src/write.rs
+++ b/cranelift/codegen/src/write.rs
@@ -5,7 +5,9 @@
 
 use crate::entity::SecondaryMap;
 use crate::ir::entities::AnyEntity;
-use crate::ir::{Block, DataFlowGraph, Function, Inst, SigRef, Type, Value, ValueDef};
+use crate::ir::immediates::Ieee128;
+use crate::ir::pcc::Fact;
+use crate::ir::{Block, DataFlowGraph, Function, Inst, Opcode, SigRef, Type, Value, ValueDef};
 use crate::packed_option::ReservedValue;
 use alloc::string::{String, ToString};
 use alloc::vec::Vec;
@@ -43,31 +45,30 @@ pub trait FuncWriter {
 
         for (ss, slot) in func.dynamic_stack_slots.iter() {
             any = true;
-            self.write_entity_definition(w, func, ss.into(), slot)?;
+            self.write_entity_definition(w, func, ss.into(), slot, None)?;
         }
 
         for (ss, slot) in func.sized_stack_slots.iter() {
             any = true;
-            self.write_entity_definition(w, func, ss.into(), slot)?;
+            self.write_entity_definition(w, func, ss.into(), slot, None)?;
         }
 
         for (gv, gv_data) in &func.global_values {
             any = true;
-            self.write_entity_definition(w, func, gv.into(), gv_data)?;
+            let maybe_fact = func.global_value_facts[gv].as_ref();
+            self.write_entity_definition(w, func, gv.into(), gv_data, maybe_fact)?;
         }
 
-        for (table, table_data) in &func.tables {
-            if !table_data.index_type.is_invalid() {
-                any = true;
-                self.write_entity_definition(w, func, table.into(), table_data)?;
-            }
+        for (mt, mt_data) in &func.memory_types {
+            any = true;
+            self.write_entity_definition(w, func, mt.into(), mt_data, None)?;
         }
 
         // Write out all signatures before functions since function declarations can refer to
         // signatures.
         for (sig, sig_data) in &func.dfg.signatures {
             any = true;
-            self.write_entity_definition(w, func, sig.into(), &sig_data)?;
+            self.write_entity_definition(w, func, sig.into(), &sig_data, None)?;
         }
 
         for (fnref, ext_func) in &func.dfg.ext_funcs {
@@ -78,18 +79,19 @@ pub trait FuncWriter {
                     func,
                     fnref.into(),
                     &ext_func.display(Some(&func.params)),
+                    None,
                 )?;
             }
         }
 
         for (&cref, cval) in func.dfg.constants.iter() {
             any = true;
-            self.write_entity_definition(w, func, cref.into(), cval)?;
+            self.write_entity_definition(w, func, cref.into(), cval, None)?;
         }
 
         if let Some(limit) = func.stack_limit {
             any = true;
-            self.write_entity_definition(w, func, AnyEntity::StackLimit, &limit)?;
+            self.write_entity_definition(w, func, AnyEntity::StackLimit, &limit, None)?;
         }
 
         Ok(any)
@@ -102,8 +104,9 @@ pub trait FuncWriter {
         func: &Function,
         entity: AnyEntity,
         value: &dyn fmt::Display,
+        maybe_fact: Option<&Fact>,
     ) -> fmt::Result {
-        self.super_entity_definition(w, func, entity, value)
+        self.super_entity_definition(w, func, entity, value, maybe_fact)
     }
 
     /// Default impl of `write_entity_definition`
@@ -114,8 +117,13 @@ pub trait FuncWriter {
         func: &Function,
         entity: AnyEntity,
         value: &dyn fmt::Display,
+        maybe_fact: Option<&Fact>,
     ) -> fmt::Result {
-        writeln!(w, "    {} = {}", entity, value)
+        if let Some(fact) = maybe_fact {
+            writeln!(w, "    {entity} ! {fact} = {value}")
+        } else {
+            writeln!(w, "    {entity} = {value}")
+        }
     }
 }
 
@@ -199,14 +207,19 @@ fn write_spec(w: &mut dyn Write, func: &Function) -> fmt::Result {
 // Basic blocks
 
 fn write_arg(w: &mut dyn Write, func: &Function, arg: Value) -> fmt::Result {
-    write!(w, "{}: {}", arg, func.dfg.value_type(arg))
+    let ty = func.dfg.value_type(arg);
+    if let Some(f) = &func.dfg.facts[arg] {
+        write!(w, "{arg} ! {f}: {ty}")
+    } else {
+        write!(w, "{arg}: {ty}")
+    }
 }
 
 /// Write out the basic block header, outdented:
 ///
 ///    block1:
 ///    block1(v1: i32):
-///    block10(v4: f64, v5: b1):
+///    block10(v4: f64, v5: i8):
 ///
 pub fn write_block_header(
     w: &mut dyn Write,
@@ -225,7 +238,7 @@ pub fn write_block_header(
 
     let mut args = func.dfg.block_params(block).iter().cloned();
     match args.next() {
-        None => return writeln!(w, "{}:", cold),
+        None => return writeln!(w, "{cold}:"),
         Some(arg) => {
             write!(w, "(")?;
             write_arg(w, func, arg)?;
@@ -236,7 +249,7 @@ pub fn write_block_header(
         write!(w, ", ")?;
         write_arg(w, func, arg)?;
     }
-    writeln!(w, "){}:", cold)
+    writeln!(w, "){cold}:")
 }
 
 fn decorate_block<FW: FuncWriter>(
@@ -331,20 +344,23 @@ fn write_instruction(
     // Source location goes first.
     let srcloc = func.srcloc(inst);
     if !srcloc.is_default() {
-        write!(s, "{} ", srcloc)?;
+        write!(s, "{srcloc} ")?;
     }
 
     // Write out prefix and indent the instruction.
-    write!(w, "{1:0$}", indent, s)?;
+    write!(w, "{s:indent$}")?;
 
     // Write out the result values, if any.
     let mut has_results = false;
     for r in func.dfg.inst_results(inst) {
         if !has_results {
             has_results = true;
-            write!(w, "{}", r)?;
+            write!(w, "{r}")?;
         } else {
-            write!(w, ", {}", r)?;
+            write!(w, ", {r}")?;
+        }
+        if let Some(f) = &func.dfg.facts[*r] {
+            write!(w, " ! {f}")?;
         }
     }
     if has_results {
@@ -355,8 +371,8 @@ fn write_instruction(
     let opcode = func.dfg.insts[inst].opcode();
 
     match type_suffix(func, inst) {
-        Some(suf) => write!(w, "{}.{}", opcode, suf)?,
-        None => write!(w, "{}", opcode)?,
+        Some(suf) => write!(w, "{opcode}.{suf}")?,
+        None => write!(w, "{opcode}")?,
     }
 
     write_operands(w, &func.dfg, inst)?;
@@ -374,22 +390,36 @@ pub fn write_operands(w: &mut dyn Write, dfg: &DataFlowGraph, inst: Inst) -> fmt
     let pool = &dfg.value_lists;
     let jump_tables = &dfg.jump_tables;
     use crate::ir::instructions::InstructionData::*;
+    let ctrl_ty = dfg.ctrl_typevar(inst);
     match dfg.insts[inst] {
         AtomicRmw { op, args, .. } => write!(w, " {} {}, {}", op, args[0], args[1]),
         AtomicCas { args, .. } => write!(w, " {}, {}, {}", args[0], args[1], args[2]),
-        LoadNoOffset { flags, arg, .. } => write!(w, "{} {}", flags, arg),
+        LoadNoOffset { flags, arg, .. } => write!(w, "{flags} {arg}"),
         StoreNoOffset { flags, args, .. } => write!(w, "{} {}, {}", flags, args[0], args[1]),
-        Unary { arg, .. } => write!(w, " {}", arg),
-        UnaryImm { imm, .. } => write!(w, " {}", imm),
-        UnaryIeee32 { imm, .. } => write!(w, " {}", imm),
-        UnaryIeee64 { imm, .. } => write!(w, " {}", imm),
-        UnaryGlobalValue { global_value, .. } => write!(w, " {}", global_value),
+        Unary { arg, .. } => write!(w, " {arg}"),
+        UnaryImm { imm, .. } => write!(w, " {}", {
+            let mut imm = imm;
+            if ctrl_ty.bits() != 0 {
+                imm = imm.sign_extend_from_width(ctrl_ty.bits());
+            }
+            imm
+        }),
+        UnaryIeee16 { imm, .. } => write!(w, " {imm}"),
+        UnaryIeee32 { imm, .. } => write!(w, " {imm}"),
+        UnaryIeee64 { imm, .. } => write!(w, " {imm}"),
+        UnaryGlobalValue { global_value, .. } => write!(w, " {global_value}"),
         UnaryConst {
             constant_handle, ..
-        } => write!(w, " {}", constant_handle),
+        } => write!(w, " {constant_handle}"),
         Binary { args, .. } => write!(w, " {}, {}", args[0], args[1]),
-        BinaryImm8 { arg, imm, .. } => write!(w, " {}, {}", arg, imm),
-        BinaryImm64 { arg, imm, .. } => write!(w, " {}, {}", arg, imm),
+        BinaryImm8 { arg, imm, .. } => write!(w, " {arg}, {imm}"),
+        BinaryImm64 { arg, imm, .. } => write!(w, " {}, {}", arg, {
+            let mut imm = imm;
+            if ctrl_ty.bits() != 0 {
+                imm = imm.sign_extend_from_width(ctrl_ty.bits());
+            }
+            imm
+        }),
         Ternary { args, .. } => write!(w, " {}, {}, {}", args[0], args[1], args[2]),
         MultiAry { ref args, .. } => {
             if args.is_empty() {
@@ -407,7 +437,13 @@ pub fn write_operands(w: &mut dyn Write, dfg: &DataFlowGraph, inst: Inst) -> fmt
             write!(w, " {}, {}, {}", args[0], args[1], data)
         }
         IntCompare { cond, args, .. } => write!(w, " {} {}, {}", cond, args[0], args[1]),
-        IntCompareImm { cond, arg, imm, .. } => write!(w, " {} {}, {}", cond, arg, imm),
+        IntCompareImm { cond, arg, imm, .. } => write!(w, " {} {}, {}", cond, arg, {
+            let mut imm = imm;
+            if ctrl_ty.bits() != 0 {
+                imm = imm.sign_extend_from_width(ctrl_ty.bits());
+            }
+            imm
+        }),
         IntAddTrap { args, code, .. } => write!(w, " {}, {}, {}", args[0], args[1], code),
         FloatCompare { cond, args, .. } => write!(w, " {} {}, {}", cond, args[0], args[1]),
         Jump { destination, .. } => {
@@ -426,7 +462,10 @@ pub fn write_operands(w: &mut dyn Write, dfg: &DataFlowGraph, inst: Inst) -> fmt
         }
         Call {
             func_ref, ref args, ..
-        } => write!(w, " {}({})", func_ref, DisplayValues(args.as_slice(pool))),
+        } => {
+            write!(w, " {}({})", func_ref, DisplayValues(args.as_slice(pool)))?;
+            write_user_stack_map_entries(w, dfg, inst)
+        }
         CallIndirect {
             sig_ref, ref args, ..
         } => {
@@ -437,67 +476,90 @@ pub fn write_operands(w: &mut dyn Write, dfg: &DataFlowGraph, inst: Inst) -> fmt
                 sig_ref,
                 args[0],
                 DisplayValues(&args[1..])
-            )
+            )?;
+            write_user_stack_map_entries(w, dfg, inst)
         }
-        FuncAddr { func_ref, .. } => write!(w, " {}", func_ref),
+        FuncAddr { func_ref, .. } => write!(w, " {func_ref}"),
         StackLoad {
             stack_slot, offset, ..
-        } => write!(w, " {}{}", stack_slot, offset),
+        } => write!(w, " {stack_slot}{offset}"),
         StackStore {
             arg,
             stack_slot,
             offset,
             ..
-        } => write!(w, " {}, {}{}", arg, stack_slot, offset),
+        } => write!(w, " {arg}, {stack_slot}{offset}"),
         DynamicStackLoad {
             dynamic_stack_slot, ..
-        } => write!(w, " {}", dynamic_stack_slot),
+        } => write!(w, " {dynamic_stack_slot}"),
         DynamicStackStore {
             arg,
             dynamic_stack_slot,
             ..
-        } => write!(w, " {}, {}", arg, dynamic_stack_slot),
-        TableAddr {
-            table, arg, offset, ..
-        } => {
-            if i32::from(offset) == 0 {
-                write!(w, " {}, {}", table, arg)
-            } else {
-                write!(w, " {}, {}{}", table, arg, offset)
-            }
-        }
+        } => write!(w, " {arg}, {dynamic_stack_slot}"),
         Load {
             flags, arg, offset, ..
-        } => write!(w, "{} {}{}", flags, arg, offset),
+        } => write!(w, "{flags} {arg}{offset}"),
         Store {
             flags,
             args,
             offset,
             ..
         } => write!(w, "{} {}, {}{}", flags, args[0], args[1], offset),
-        Trap { code, .. } => write!(w, " {}", code),
-        CondTrap { arg, code, .. } => write!(w, " {}, {}", arg, code),
+        Trap { code, .. } => write!(w, " {code}"),
+        CondTrap { arg, code, .. } => write!(w, " {arg}, {code}"),
     }?;
 
     let mut sep = "  ; ";
     for arg in dfg.inst_values(inst) {
         if let ValueDef::Result(src, _) = dfg.value_def(arg) {
             let imm = match dfg.insts[src] {
-                UnaryImm { imm, .. } => imm.to_string(),
+                UnaryImm { imm, .. } => {
+                    let mut imm = imm;
+                    if dfg.ctrl_typevar(src).bits() != 0 {
+                        imm = imm.sign_extend_from_width(dfg.ctrl_typevar(src).bits());
+                    }
+                    imm.to_string()
+                }
+                UnaryIeee16 { imm, .. } => imm.to_string(),
                 UnaryIeee32 { imm, .. } => imm.to_string(),
                 UnaryIeee64 { imm, .. } => imm.to_string(),
+                UnaryConst {
+                    constant_handle,
+                    opcode: Opcode::F128const,
+                } => Ieee128::try_from(dfg.constants.get(constant_handle))
+                    .expect("16-byte f128 constant")
+                    .to_string(),
                 UnaryConst {
                     constant_handle, ..
                 } => constant_handle.to_string(),
                 _ => continue,
             };
-            write!(w, "{}{} = {}", sep, arg, imm)?;
+            write!(w, "{sep}{arg} = {imm}")?;
             sep = ", ";
         }
     }
     Ok(())
 }
 
+fn write_user_stack_map_entries(w: &mut dyn Write, dfg: &DataFlowGraph, inst: Inst) -> fmt::Result {
+    let entries = match dfg.user_stack_map_entries(inst) {
+        None => return Ok(()),
+        Some(es) => es,
+    };
+    write!(w, ", stack_map=[")?;
+    let mut need_comma = false;
+    for entry in entries {
+        if need_comma {
+            write!(w, ", ")?;
+        }
+        write!(w, "{} @ {}+{}", entry.ty, entry.slot, entry.offset)?;
+        need_comma = true;
+    }
+    write!(w, "]")?;
+    Ok(())
+}
+
 /// Displayable slice of values.
 struct DisplayValues<'a>(&'a [Value]);
 
@@ -505,9 +567,9 @@ impl<'a> fmt::Display for DisplayValues<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         for (i, val) in self.0.iter().enumerate() {
             if i == 0 {
-                write!(f, "{}", val)?;
+                write!(f, "{val}")?;
             } else {
-                write!(f, ", {}", val)?;
+                write!(f, ", {val}")?;
             }
         }
         Ok(())
@@ -529,7 +591,7 @@ mod tests {
         f.name = UserFuncName::testcase("foo");
         assert_eq!(f.to_string(), "function %foo() fast {\n}\n");
 
-        f.create_sized_stack_slot(StackSlotData::new(StackSlotKind::ExplicitSlot, 4));
+        f.create_sized_stack_slot(StackSlotData::new(StackSlotKind::ExplicitSlot, 4, 0));
         assert_eq!(
             f.to_string(),
             "function %foo() fast {\n    ss0 = explicit_slot 4\n}\n"
@@ -563,6 +625,13 @@ mod tests {
             f.to_string(),
             "function %foo() fast {\n    ss0 = explicit_slot 4\n\nblock0(v0: i8, v1: f32x4):\n    return\n}\n"
         );
+
+        let mut f = Function::new();
+        f.create_sized_stack_slot(StackSlotData::new(StackSlotKind::ExplicitSlot, 4, 2));
+        assert_eq!(
+            f.to_string(),
+            "function u0:0() fast {\n    ss0 = explicit_slot 4, align = 4\n}\n"
+        );
     }
 
     #[test]
diff --git a/cranelift/control/Cargo.toml b/cranelift/control/Cargo.toml
index 006afd14420d..ebbc9447d58a 100644
--- a/cranelift/control/Cargo.toml
+++ b/cranelift/control/Cargo.toml
@@ -1,20 +1,25 @@
 [package]
 authors = ["The Cranelift Project Developers"]
 name = "cranelift-control"
-version = "0.101.0"
+version = "0.112.0"
 description = "White-box fuzz testing framework"
 license = "Apache-2.0 WITH LLVM-exception"
 repository = "https://github.com/bytecodealliance/wasmtime"
 readme = "README.md"
 keywords = ["fuzz", "test"]
 edition.workspace = true
+rust-version.workspace = true
 
 [dependencies]
-arbitrary = { version = "1.3.0" }
+arbitrary = { workspace = true, optional = true }
 
 [features]
+default = ["fuzz"]
+
+# Enable fuzzing support with `arbitrary`. Does not work on `no_std` targets.
+fuzz = ["dep:arbitrary"]
 
 # Turn on chaos mode.
 # Without this feature, a zero-sized dummy will be compiled
 # for the control plane.
-chaos = []
+chaos = ["fuzz"]
diff --git a/cranelift/control/src/chaos.rs b/cranelift/control/src/chaos.rs
index 5d86e10cfe95..2db8d5f9f267 100644
--- a/cranelift/control/src/chaos.rs
+++ b/cranelift/control/src/chaos.rs
@@ -1,3 +1,4 @@
+use alloc::vec::Vec;
 use arbitrary::{Arbitrary, Unstructured};
 
 /// The control plane of chaos mode.
@@ -73,7 +74,7 @@ impl ControlPlane {
         let rest = u.take_rest();
         self.tmp.resize(rest.len(), 0); // allocates once per control plane
         self.tmp.copy_from_slice(rest);
-        std::mem::swap(&mut self.data, &mut self.tmp);
+        core::mem::swap(&mut self.data, &mut self.tmp);
 
         res
     }
@@ -107,7 +108,7 @@ impl ControlPlane {
         let rest = u.take_rest();
         self.tmp.resize(rest.len(), 0); // allocates once per control plane
         self.tmp.copy_from_slice(rest);
-        std::mem::swap(&mut self.data, &mut self.tmp);
+        core::mem::swap(&mut self.data, &mut self.tmp);
     }
 
     /// Returns a new iterator over the same items as the input iterator in
diff --git a/cranelift/control/src/lib.rs b/cranelift/control/src/lib.rs
index b5f712b7cb1c..20c33cb740a6 100644
--- a/cranelift/control/src/lib.rs
+++ b/cranelift/control/src/lib.rs
@@ -12,7 +12,7 @@
 //! etc.
 //!
 //! There are two ways to acquire a [ControlPlane]:
-//! - [arbitrary] for the real deal
+//! - [arbitrary] for the real deal (requires the `fuzz` feature, enabled by default)
 //! - [default] for an "empty" control plane which always returns default
 //!   values
 //!
@@ -31,9 +31,23 @@
 //! cargo fuzz run --features chaos $TARGET -- --fuel=16
 //! ```
 //!
+//! ## `no_std` support
+//!
+//! This crate compiles in `no_std` environments, although both the `fuzz`
+//! or `chaos` features have a dependency on `std`. This means that on `no_std`
+//! you can't use [arbitrary] to initialize [ControlPlane] and can't enable
+//! chaos mode, although the rest of the usual [ControlPlane] API is available.
+//!
 //! [arbitrary]: ControlPlane#method.arbitrary
 //! [default]: ControlPlane#method.default
 
+#![no_std]
+
+// The `alloc` crate is only needed by chaos mode, which guarantees that
+// `alloc` is present because of its dependency on `std`.
+#[cfg(feature = "chaos")]
+extern crate alloc;
+
 #[cfg(not(feature = "chaos"))]
 mod zero_sized;
 #[cfg(not(feature = "chaos"))]
diff --git a/cranelift/control/src/zero_sized.rs b/cranelift/control/src/zero_sized.rs
index c6e908fec5b5..8cf2fd0c9c2a 100644
--- a/cranelift/control/src/zero_sized.rs
+++ b/cranelift/control/src/zero_sized.rs
@@ -12,6 +12,7 @@ pub struct ControlPlane {
 /// A shim for ControlPlane's `Arbitrary` implementation when chaos mode is
 /// disabled. It doesn't consume any bytes and always returns a default
 /// control plane.
+#[cfg(feature = "fuzz")]
 impl arbitrary::Arbitrary<'_> for ControlPlane {
     fn arbitrary(_u: &mut arbitrary::Unstructured<'_>) -> arbitrary::Result<Self> {
         Ok(Self::default())
@@ -33,7 +34,7 @@ impl ControlPlane {
     /// Returns an arbitrary value. This variant is used when chaos mode is
     /// disabled. It always returns the default value.
     #[inline]
-    pub fn get_arbitrary<T: for<'a> arbitrary::Arbitrary<'a> + Default>(&mut self) -> T {
+    pub fn get_arbitrary<T: Default>(&mut self) -> T {
         T::default()
     }
 
diff --git a/cranelift/docs/compare-llvm.md b/cranelift/docs/compare-llvm.md
index bc9e2060fba2..d1fe5272e410 100644
--- a/cranelift/docs/compare-llvm.md
+++ b/cranelift/docs/compare-llvm.md
@@ -155,9 +155,9 @@ can hold.
 - Cranelift has no aggregate types. LLVM has named and anonymous struct types as
   well as array types.
 
-Cranelift has multiple boolean types, whereas LLVM simply uses `i1`. The sized
-Cranelift boolean types are used to represent SIMD vector masks like `b32x4`
-where each lane is either all 0 or all 1 bits.
+Cranelift uses integer-typed values of `0` or `1` for booleans, whereas LLVM
+simply uses `i1`. The sized Cranelift integer types are used to represent SIMD
+vector masks like `i32x4` where each lane is either all 0 or all 1 bits.
 
 Cranelift instructions and function calls can return multiple result values. LLVM
 instead models this by returning a single value of an aggregate type.
diff --git a/cranelift/docs/ir.md b/cranelift/docs/ir.md
index f2b48627f975..832cae39d355 100644
--- a/cranelift/docs/ir.md
+++ b/cranelift/docs/ir.md
@@ -28,8 +28,7 @@ each other directly.
 This is a simple C function that computes the average of an array of floats:
 
 ```c
-float
-average(const float *array, size_t count)
+float average(const float *array, size_t count)
 {
     double sum = 0;
     for (size_t i = 0; i < count; i++)
@@ -553,41 +552,11 @@ GV = [colocated] symbol Name
     :arg Name: External name.
     :result GV: Global value.
 
-### Tables
-
-Code compiled from WebAssembly often needs access to objects outside of its
-linear memory. WebAssembly uses *tables* to allow programs to refer to opaque
-values through integer indices.
-
-A table is declared in the function preamble and can be accessed with the
-`table_addr` instruction that [traps] on out-of-bounds accesses.
-Table addresses can be smaller than the native pointer size, for example
-unsigned `i32` offsets on a 64-bit architecture.
-
-A table appears as a consecutive range of address space, conceptually
-divided into elements of fixed sizes, which are identified by their index.
-The memory is [accessible].
-
-The *table bound* is the number of elements currently in the table. This is
-the bound that `table_addr` checks against.
-
-A table can be relocated to a different base address when it is resized, and
-its bound can move dynamically. The bound of a table is stored in a global
-value.
-
-T = dynamic Base, min MinElements, bound BoundGV, element_size ElementSize
-    Declare a table in the preamble.
-
-    :arg Base: Global value holding the table's base address.
-    :arg MinElements: Guaranteed minimum table size in elements.
-    :arg BoundGV: Global value containing the current table bound in elements.
-    :arg ElementSize: Size of each element.
-
 ### Constant materialization
 
 A few instructions have variants that take immediate operands, but in general
 an instruction is required to load a constant into an SSA value: `iconst`,
-`f32const`, `f64const` and `bconst` serve this purpose.
+`f32const` and `f64const` serve this purpose.
 
 ### Bitwise operations
 
diff --git a/cranelift/entity/Cargo.toml b/cranelift/entity/Cargo.toml
index 5740ce49538f..1c0c1bf0eb4d 100644
--- a/cranelift/entity/Cargo.toml
+++ b/cranelift/entity/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 authors = ["The Cranelift Project Developers"]
 name = "cranelift-entity"
-version = "0.101.0"
+version = "0.112.0"
 description = "Data structures using entity references as mapping keys"
 license = "Apache-2.0 WITH LLVM-exception"
 documentation = "https://docs.rs/cranelift-entity"
@@ -10,10 +10,15 @@ categories = ["no-std"]
 readme = "README.md"
 keywords = ["entity", "set", "map"]
 edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
 
 [dependencies]
-serde = { version = "1.0.188", optional = true }
-serde_derive = { version = "1.0.188", optional = true }
+cranelift-bitset = { workspace=true }
+serde = { workspace = true, optional = true }
+serde_derive = { workspace = true, optional = true }
 
 [features]
-enable-serde = ["serde", "serde_derive"]
+enable-serde = ["serde", "serde_derive", "cranelift-bitset/enable-serde"]
diff --git a/cranelift/entity/src/lib.rs b/cranelift/entity/src/lib.rs
index cdd6b2f08964..4cbed9d0a7a8 100644
--- a/cranelift/entity/src/lib.rs
+++ b/cranelift/entity/src/lib.rs
@@ -29,8 +29,7 @@
 //!   references allocated from an associated memory pool. It has a much smaller footprint than
 //!   `Vec`.
 
-#![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)]
-#![warn(unused_import_braces)]
+#![deny(missing_docs)]
 #![no_std]
 
 extern crate alloc;
@@ -39,6 +38,9 @@ extern crate alloc;
 #[doc(hidden)]
 pub extern crate core as __core;
 
+use core::iter::FusedIterator;
+use core::ops::Range;
+
 /// A type wrapping a small integer index should implement `EntityRef` so it can be used as the key
 /// of an `SecondaryMap` or `SparseMap`.
 pub trait EntityRef: Copy + Eq {
@@ -50,6 +52,67 @@ pub trait EntityRef: Copy + Eq {
     fn index(self) -> usize;
 }
 
+/// Iterate over a `Range<E: EntityRef>`, yielding a sequence of `E` items.
+#[inline]
+pub fn iter_entity_range<E>(range: Range<E>) -> IterEntityRange<E>
+where
+    E: EntityRef,
+{
+    IterEntityRange {
+        range: range.start.index()..range.end.index(),
+        _phantom: core::marker::PhantomData,
+    }
+}
+
+/// Iterator type returned by `iter_entity_range`.
+pub struct IterEntityRange<E> {
+    range: Range<usize>,
+    _phantom: core::marker::PhantomData<E>,
+}
+
+impl<E> Iterator for IterEntityRange<E>
+where
+    E: EntityRef,
+{
+    type Item = E;
+
+    #[inline]
+    fn next(&mut self) -> Option<Self::Item> {
+        let i = self.range.next()?;
+        Some(E::new(i))
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.range.size_hint()
+    }
+}
+
+impl<E> DoubleEndedIterator for IterEntityRange<E>
+where
+    E: EntityRef,
+{
+    #[inline]
+    fn next_back(&mut self) -> Option<Self::Item> {
+        let i = self.range.next_back()?;
+        Some(E::new(i))
+    }
+}
+
+impl<E> FusedIterator for IterEntityRange<E>
+where
+    E: EntityRef,
+    Range<usize>: FusedIterator,
+{
+}
+
+impl<E> ExactSizeIterator for IterEntityRange<E>
+where
+    E: EntityRef,
+    Range<usize>: ExactSizeIterator,
+{
+}
+
 /// Macro which provides the common implementation of a 32-bit entity reference.
 #[macro_export]
 macro_rules! entity_impl {
@@ -203,6 +266,7 @@ mod map;
 mod primary;
 mod set;
 mod sparse;
+mod unsigned;
 
 pub use self::boxed_slice::BoxedSlice;
 pub use self::iter::{Iter, IterMut};
@@ -212,6 +276,7 @@ pub use self::map::SecondaryMap;
 pub use self::primary::PrimaryMap;
 pub use self::set::EntitySet;
 pub use self::sparse::{SparseMap, SparseMapValue, SparseSet};
+pub use self::unsigned::Unsigned;
 
 /// A collection of tests to ensure that use of the different `entity_impl!` forms will generate
 /// `EntityRef` implementations that behave the same way.
@@ -279,7 +344,7 @@ mod tests {
         #[test]
         fn display_prefix_works() {
             let e = PrefixEntity::new(0);
-            assert_eq!(alloc::format!("{}", e), "prefix-0");
+            assert_eq!(alloc::format!("{e}"), "prefix-0");
         }
     }
 
@@ -310,7 +375,7 @@ mod tests {
         #[test]
         fn display_prefix_works() {
             let e = InnerEntity::new(0);
-            assert_eq!(alloc::format!("{}", e), "inner-0");
+            assert_eq!(alloc::format!("{e}"), "inner-0");
         }
     }
 }
diff --git a/cranelift/entity/src/list.rs b/cranelift/entity/src/list.rs
index 922389f0ca1a..65d54d43e0e6 100644
--- a/cranelift/entity/src/list.rs
+++ b/cranelift/entity/src/list.rs
@@ -642,8 +642,6 @@ impl<T: EntityRef + ReservedValue> EntityList<T> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use super::{sclass_for_length, sclass_size};
-    use crate::EntityRef;
 
     /// An opaque reference to an instruction in a function.
     #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
diff --git a/cranelift/entity/src/packed_option.rs b/cranelift/entity/src/packed_option.rs
index bc5cb381284b..e6d0eed1468c 100644
--- a/cranelift/entity/src/packed_option.rs
+++ b/cranelift/entity/src/packed_option.rs
@@ -55,11 +55,13 @@ impl<T: ReservedValue> PackedOption<T> {
     }
 
     /// Unwrap a packed `Some` value or panic.
+    #[track_caller]
     pub fn unwrap(self) -> T {
         self.expand().unwrap()
     }
 
     /// Unwrap a packed `Some` value or panic.
+    #[track_caller]
     pub fn expect(self, msg: &str) -> T {
         self.expand().expect(msg)
     }
diff --git a/cranelift/entity/src/primary.rs b/cranelift/entity/src/primary.rs
index 573f53546b0d..b47e8073db9c 100644
--- a/cranelift/entity/src/primary.rs
+++ b/cranelift/entity/src/primary.rs
@@ -5,8 +5,8 @@ use crate::keys::Keys;
 use crate::EntityRef;
 use alloc::boxed::Box;
 use alloc::vec::Vec;
-use core::iter::FromIterator;
 use core::marker::PhantomData;
+use core::mem;
 use core::ops::{Index, IndexMut};
 use core::slice;
 #[cfg(feature = "enable-serde")]
@@ -158,6 +158,41 @@ where
         unsafe { BoxedSlice::<K, V>::from_raw(Box::<[V]>::into_raw(self.elems.into_boxed_slice())) }
     }
 
+    /// Returns mutable references to many elements at once.
+    ///
+    /// Returns an error if an element does not exist, or if the same key was passed more than
+    /// once.
+    // This implementation is taken from the unstable `get_many_mut`.
+    //
+    // Once it has been stabilised we can call that method directly.
+    pub fn get_many_mut<const N: usize>(
+        &mut self,
+        indices: [K; N],
+    ) -> Result<[&mut V; N], GetManyMutError<K>> {
+        for (i, &idx) in indices.iter().enumerate() {
+            if idx.index() >= self.len() {
+                return Err(GetManyMutError::DoesNotExist(idx));
+            }
+            for &idx2 in &indices[..i] {
+                if idx == idx2 {
+                    return Err(GetManyMutError::MultipleOf(idx));
+                }
+            }
+        }
+
+        let slice: *mut V = self.elems.as_mut_ptr();
+        let mut arr: mem::MaybeUninit<[&mut V; N]> = mem::MaybeUninit::uninit();
+        let arr_ptr = arr.as_mut_ptr();
+
+        unsafe {
+            for i in 0..N {
+                let idx = *indices.get_unchecked(i);
+                *(*arr_ptr).get_unchecked_mut(i) = &mut *slice.add(idx.index());
+            }
+            Ok(arr.assume_init())
+        }
+    }
+
     /// Performs a binary search on the values with a key extraction function.
     ///
     /// Assumes that the values are sorted by the key extracted by the function.
@@ -181,6 +216,12 @@ where
     }
 }
 
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub enum GetManyMutError<K> {
+    DoesNotExist(K),
+    MultipleOf(K),
+}
+
 impl<K, V> Default for PrimaryMap<K, V>
 where
     K: EntityRef,
@@ -264,6 +305,18 @@ where
     }
 }
 
+impl<K, V> From<Vec<V>> for PrimaryMap<K, V>
+where
+    K: EntityRef,
+{
+    fn from(elems: Vec<V>) -> Self {
+        Self {
+            elems,
+            unused: PhantomData,
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -453,4 +506,35 @@ mod tests {
             assert!(*me == **ne);
         }
     }
+
+    #[test]
+    fn from_vec() {
+        let mut m: PrimaryMap<E, usize> = PrimaryMap::new();
+        m.push(12);
+        m.push(33);
+
+        let n = PrimaryMap::<E, &usize>::from(m.values().collect::<Vec<_>>());
+        assert!(m.len() == n.len());
+        for (me, ne) in m.values().zip(n.values()) {
+            assert!(*me == **ne);
+        }
+    }
+
+    #[test]
+    fn get_many_mut() {
+        let mut m: PrimaryMap<E, usize> = PrimaryMap::new();
+        let _0 = m.push(0);
+        let _1 = m.push(1);
+        let _2 = m.push(2);
+
+        assert_eq!([&mut 0, &mut 2], m.get_many_mut([_0, _2]).unwrap());
+        assert_eq!(
+            m.get_many_mut([_0, _0]),
+            Err(GetManyMutError::MultipleOf(_0))
+        );
+        assert_eq!(
+            m.get_many_mut([E(4)]),
+            Err(GetManyMutError::DoesNotExist(E(4)))
+        );
+    }
 }
diff --git a/cranelift/entity/src/set.rs b/cranelift/entity/src/set.rs
index 60578d6e4b9b..3c5925a219b8 100644
--- a/cranelift/entity/src/set.rs
+++ b/cranelift/entity/src/set.rs
@@ -2,11 +2,8 @@
 
 use crate::keys::Keys;
 use crate::EntityRef;
-use alloc::vec::Vec;
 use core::marker::PhantomData;
-
-// How many bits are used to represent a single element in `EntitySet`.
-const BITS: usize = core::mem::size_of::<usize>() * 8;
+use cranelift_bitset::CompoundBitSet;
 
 /// A set of `K` for densely indexed entity references.
 ///
@@ -17,21 +14,27 @@ pub struct EntitySet<K>
 where
     K: EntityRef,
 {
-    elems: Vec<usize>,
-    len: usize,
+    bitset: CompoundBitSet,
     unused: PhantomData<K>,
 }
 
 impl<K: EntityRef> Default for EntitySet<K> {
     fn default() -> Self {
         Self {
-            elems: Vec::new(),
-            len: 0,
+            bitset: CompoundBitSet::default(),
             unused: PhantomData,
         }
     }
 }
 
+impl<K: EntityRef> Extend<K> for EntitySet<K> {
+    fn extend<T: IntoIterator<Item = K>>(&mut self, iter: T) {
+        for k in iter {
+            self.insert(k);
+        }
+    }
+}
+
 /// Shared `EntitySet` implementation for all value types.
 impl<K> EntitySet<K>
 where
@@ -45,101 +48,55 @@ where
     /// Creates a new empty set with the specified capacity.
     pub fn with_capacity(capacity: usize) -> Self {
         Self {
-            elems: Vec::with_capacity((capacity + (BITS - 1)) / BITS),
-            ..Self::new()
+            bitset: CompoundBitSet::with_capacity(capacity),
+            unused: PhantomData,
         }
     }
 
+    /// Ensure that the set has enough capacity to hold `capacity` total
+    /// elements.
+    pub fn ensure_capacity(&mut self, capacity: usize) {
+        self.bitset.ensure_capacity(capacity);
+    }
+
     /// Get the element at `k` if it exists.
     pub fn contains(&self, k: K) -> bool {
         let index = k.index();
-        if index < self.len {
-            (self.elems[index / BITS] & (1 << (index % BITS))) != 0
-        } else {
-            false
-        }
+        self.bitset.contains(index)
     }
 
     /// Is this set completely empty?
     pub fn is_empty(&self) -> bool {
-        if self.len != 0 {
-            false
-        } else {
-            self.elems.iter().all(|&e| e == 0)
-        }
-    }
-
-    /// Returns the cardinality of the set. More precisely, it returns the number of calls to
-    /// `insert` with different key values, that have happened since the the set was most recently
-    /// `clear`ed or created with `new`.
-    pub fn cardinality(&self) -> usize {
-        self.elems[..(self.len + (BITS - 1)) / BITS]
-            .iter()
-            .map(|x| x.count_ones() as usize)
-            .sum()
+        self.bitset.is_empty()
     }
 
     /// Remove all entries from this set.
     pub fn clear(&mut self) {
-        self.len = 0;
-        self.elems.clear()
+        self.bitset.clear()
     }
 
     /// Iterate over all the keys in this set.
     pub fn keys(&self) -> Keys<K> {
-        Keys::with_len(self.len)
-    }
-
-    /// Resize the set to have `n` entries by adding default entries as needed.
-    pub fn resize(&mut self, n: usize) {
-        self.elems.resize((n + (BITS - 1)) / BITS, 0);
-        self.len = n
+        Keys::with_len(self.bitset.max().map_or(0, |x| x + 1))
     }
 
     /// Insert the element at `k`.
     pub fn insert(&mut self, k: K) -> bool {
         let index = k.index();
-        if index >= self.len {
-            self.resize(index + 1)
-        }
-        let result = !self.contains(k);
-        self.elems[index / BITS] |= 1 << (index % BITS);
-        result
+        self.bitset.insert(index)
     }
 
     /// Removes and returns the entity from the set if it exists.
     pub fn pop(&mut self) -> Option<K> {
-        if self.len == 0 {
-            return None;
-        }
-
-        // Clear the last known entity in the list.
-        let last_index = self.len - 1;
-        self.elems[last_index / BITS] &= !(1 << (last_index % BITS));
-
-        // Set the length to the next last stored entity or zero if we pop'ed
-        // the last entity.
-        self.len = self
-            .elems
-            .iter()
-            .enumerate()
-            .rev()
-            .find(|(_, &elem)| elem != 0)
-            // Map `i` from `elem` index to bit level index.
-            // `(i + 1) * BITS` = Last bit in `elem`.
-            // `last - elem.leading_zeros()` = last set bit in `elem`.
-            // `as usize` won't ever truncate as the potential range is `0..=8`.
-            .map_or(0, |(i, elem)| {
-                ((i + 1) * BITS) - elem.leading_zeros() as usize
-            });
-
-        Some(K::new(last_index))
+        let index = self.bitset.pop()?;
+        Some(K::new(index))
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use alloc::vec::Vec;
     use core::u32;
 
     // `EntityRef` impl for testing.
@@ -178,7 +135,6 @@ mod tests {
         let v: Vec<E> = m.keys().collect();
         assert_eq!(v, [r0, r1, r2]);
 
-        m.resize(20);
         assert!(!m.contains(E(3)));
         assert!(!m.contains(E(4)));
         assert!(!m.contains(E(8)));
@@ -239,7 +195,7 @@ mod tests {
         for &block in &blocks {
             m.insert(block);
         }
-        assert_eq!(m.len, 13);
+        assert_eq!(m.bitset.max(), Some(12));
         blocks.sort();
 
         for &block in blocks.iter().rev() {
@@ -248,43 +204,4 @@ mod tests {
 
         assert!(m.is_empty());
     }
-
-    #[test]
-    fn cardinality() {
-        let mut m = EntitySet::new();
-
-        m.insert(E(1));
-        assert!(m.cardinality() == 1);
-
-        m.insert(E(0));
-        assert!(m.cardinality() == 2);
-
-        m.insert(E(1));
-        assert!(m.cardinality() == 2);
-
-        m.insert(E(BITS as u32 - 1));
-        assert!(m.cardinality() == 3);
-
-        m.insert(E(BITS as u32));
-        assert!(m.cardinality() == 4);
-
-        m.insert(E(BITS as u32 - 1));
-        assert!(m.cardinality() == 4);
-
-        assert!(m.pop() == Some(E(BITS as u32)));
-        assert!(m.cardinality() == 3);
-        assert!(m.pop() == Some(E(BITS as u32 - 1)));
-        assert!(m.cardinality() == 2);
-
-        m.insert(E(100));
-        assert!(m.cardinality() == 3);
-
-        assert!(m.pop() == Some(E(100)));
-        assert!(m.cardinality() == 2);
-
-        m.insert(E(100));
-        m.insert(E(101));
-        m.insert(E(102));
-        assert!(m.cardinality() == 5);
-    }
 }
diff --git a/cranelift/entity/src/sparse.rs b/cranelift/entity/src/sparse.rs
index 96d8c7b026ee..bcdce7288e1f 100644
--- a/cranelift/entity/src/sparse.rs
+++ b/cranelift/entity/src/sparse.rs
@@ -5,7 +5,7 @@
 //! the paper:
 //!
 //! > Briggs, Torczon, *An efficient representation for sparse sets*,
-//!   ACM Letters on Programming Languages and Systems, Volume 2, Issue 1-4, March-Dec. 1993.
+//! > ACM Letters on Programming Languages and Systems, Volume 2, Issue 1-4, March-Dec. 1993.
 
 use crate::map::SecondaryMap;
 use crate::EntityRef;
@@ -235,7 +235,6 @@ pub type SparseSet<T> = SparseMap<T, T>;
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::EntityRef;
 
     /// An opaque reference to an instruction in a function.
     #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
diff --git a/cranelift/entity/src/unsigned.rs b/cranelift/entity/src/unsigned.rs
new file mode 100644
index 000000000000..2d8eb4c640ca
--- /dev/null
+++ b/cranelift/entity/src/unsigned.rs
@@ -0,0 +1,71 @@
+/// Helper trait used to add `unsigned()` methods to primitive signed integer
+/// types.
+///
+/// The purpose of this trait is to signal the intent that the sign bit of a
+/// signed integer is intended to be discarded and the value is instead
+/// understood to be a "bag of bits" where the conversion to an unsigned number
+/// is intended to be lossless. This can be used for example when converting a
+/// signed integer into a larger width with zero-extension.
+pub trait Unsigned {
+    /// The unsigned integer for this type which has the same width.
+    type Unsigned;
+
+    /// View this signed integer as an unsigned integer of the same width.
+    ///
+    /// All bits are preserved.
+    fn unsigned(self) -> Self::Unsigned;
+}
+
+impl Unsigned for i8 {
+    type Unsigned = u8;
+
+    #[inline]
+    fn unsigned(self) -> u8 {
+        self as u8
+    }
+}
+
+impl Unsigned for i16 {
+    type Unsigned = u16;
+
+    #[inline]
+    fn unsigned(self) -> u16 {
+        self as u16
+    }
+}
+
+impl Unsigned for i32 {
+    type Unsigned = u32;
+
+    #[inline]
+    fn unsigned(self) -> u32 {
+        self as u32
+    }
+}
+
+impl Unsigned for i64 {
+    type Unsigned = u64;
+
+    #[inline]
+    fn unsigned(self) -> u64 {
+        self as u64
+    }
+}
+
+impl Unsigned for i128 {
+    type Unsigned = u128;
+
+    #[inline]
+    fn unsigned(self) -> u128 {
+        self as u128
+    }
+}
+
+impl Unsigned for isize {
+    type Unsigned = usize;
+
+    #[inline]
+    fn unsigned(self) -> usize {
+        self as usize
+    }
+}
diff --git a/cranelift/filetests/Cargo.toml b/cranelift/filetests/Cargo.toml
index f3618d0de8ca..b6e0df9814f2 100644
--- a/cranelift/filetests/Cargo.toml
+++ b/cranelift/filetests/Cargo.toml
@@ -8,6 +8,10 @@ documentation = "https://docs.rs/cranelift-filetests"
 repository = "https://github.com/bytecodealliance/wasmtime"
 publish = false
 edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
 
 [dependencies]
 cranelift-codegen = { workspace = true, features = ["disas"] }
@@ -20,17 +24,17 @@ cranelift-module = { workspace = true }
 cranelift-control = { workspace = true }
 file-per-thread-logger = { workspace = true }
 filecheck = { workspace = true }
-gimli = { workspace = true }
+gimli = { workspace = true, features = ['std'] }
 log = { workspace = true }
 num_cpus = "1.8.0"
 target-lexicon = { workspace = true }
 thiserror = { workspace = true }
 anyhow = { workspace = true }
-similar ={ workspace = true }
+similar = { workspace = true }
 wat.workspace = true
 toml = { workspace = true }
 serde = { workspace = true }
 serde_derive = { workspace = true }
-cranelift-wasm.workspace = true
-wasmparser.workspace = true
 cranelift.workspace = true
+smallvec = { workspace = true }
+pulley-interpreter = { workspace = true, features = ["disas", "std"] }
diff --git a/cranelift/filetests/filetests/dce/basic.clif b/cranelift/filetests/filetests/dce/basic.clif
deleted file mode 100644
index b077e13f77bd..000000000000
--- a/cranelift/filetests/filetests/dce/basic.clif
+++ /dev/null
@@ -1,44 +0,0 @@
-test dce
-
-function %simple() -> i32 {
-block0:
-    v2 = iconst.i32 2
-    v3 = iconst.i32 3
-    return v3
-}
-; sameln: function %simple
-; nextln: block0:
-; nextln:     v3 = iconst.i32 3
-; nextln:     return v3
-; nextln: }
-
-function %some_branching(i32, i32) -> i32 {
-block0(v0: i32, v1: i32):
-    v3 = iconst.i32 70
-    v4 = iconst.i32 71
-    v5 = iconst.i32 72
-    v8 = iconst.i32 73
-    brif v0, block2(v8), block1
-
-block1:
-    v2 = iadd v0, v3
-    return v0
-
-block2(v9: i32):
-    v6 = iadd v1, v4
-    v7 = iadd v6, v9
-    return v7
-}
-; sameln: function %some_branching
-; nextln: block0(v0: i32, v1: i32):
-; nextln:     v4 = iconst.i32 71
-; nextln:     v8 = iconst.i32 73
-; nextln:     brif v0, block2(v8), block1
-; nextln: 
-; nextln: block1:
-; nextln:     return v0
-; nextln: 
-; nextln: block2(v9: i32):
-; nextln:     v6 = iadd.i32 v1, v4
-; nextln:     v7 = iadd v6, v9
-; nextln:     return v7
diff --git a/cranelift/filetests/filetests/egraph/arithmetic.clif b/cranelift/filetests/filetests/egraph/arithmetic.clif
index 630aebeca450..2e64d73d863d 100644
--- a/cranelift/filetests/filetests/egraph/arithmetic.clif
+++ b/cranelift/filetests/filetests/egraph/arithmetic.clif
@@ -4,10 +4,11 @@ target x86_64
 
 function %f0(i32) -> i32 {
 block0(v0: i32):
-    v1 = iconst.i32 2
+    v1 = iconst.i32 4
     v2 = imul v0, v1
-    ; check: v5 = ishl v0, v4  ; v4 = 1
-    ; check: return v5
+    ; check: v3 = iconst.i32 2
+    ; check: v4 = ishl v0, v3  ; v3 = 2
+    ; check: return v4
     return v2
 }
 
@@ -19,6 +20,42 @@ block0(v0: i32):
     ; check: return v0
 }
 
+function %add_ineg(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+    v2 = ineg v1
+    v3 = iadd v0, v2
+    return v3
+    ; check: v4 = isub v0, v1
+    ; check: return v4
+}
+
+function %ineg_add(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+    v2 = ineg v0
+    v3 = iadd v2, v1
+    return v3
+    ; check: v4 = isub v1, v0
+    ; check: return v4
+}
+
+function %sub_ineg(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+    v2 = ineg v1
+    v3 = isub v0, v2
+    return v3
+    ; check: v4 = iadd v0, v1
+    ; check: return v4
+}
+
+function %sub_then_ineg(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+    v2 = isub v0, v1
+    v3 = ineg v2
+    return v3
+    ; check: v4 = isub v1, v0
+    ; check: return v4
+}
+
 function %imul_ineg_cancel(i32, i32) -> i32 {
 block0(v0: i32, v1: i32):
     v2 = ineg v0
@@ -54,13 +91,45 @@ block0(v0: i32):
     ; check: return v2
 }
 
+function %zero_plus(i32) -> i32 {
+block0(v0: i32):
+    v1 = iconst.i32 0
+    v2 = iadd v1, v0
+    return v2
+    ; check: return v0
+}
+
+function %zero_times(i32) -> i32 {
+block0(v0: i32):
+    v1 = iconst.i32 0
+    v2 = imul v1, v0
+    return v2
+    ; check: return v1
+}
+
+function %one_times(i32) -> i32 {
+block0(v0: i32):
+    v1 = iconst.i32 1
+    v2 = imul v1, v0
+    return v2
+    ; check: return v0
+}
+
+function %two_times(i32) -> i32 {
+block0(v0: i32):
+    v1 = iconst.i32 2
+    v2 = imul v1, v0
+    return v2
+    ; check: v6 = iadd v0, v0
+    ; check: return v6
+}
+
 function %mul_minus_one(i32) -> i32 {
 block0(v0: i32):
     v1 = iconst.i32 0xffff_ffff ; -1
     v2 = imul v0, v1
     return v2
     ; check: v3 = ineg v0
-    ; check: v4 -> v3
     ; check: return v3
 }
 
@@ -69,8 +138,8 @@ block0(v0: i32):
     v1 = iconst.i32 0xffff_ffff ; -1
     v2 = imul v1, v0
     return v2
-    ; check: v3 = ineg v0
-    ; check: return v3
+    ; check: v4 = ineg v0
+    ; check: return v4
 }
 
 function %ineg_not_plus_one(i32) -> i32 {
@@ -92,8 +161,8 @@ block0(v0: i32):
     return v3
 }
 
-; check: v4 = ineg v0
-; check: return v4
+; check: v5 = ineg v0
+; check: return v5
 
 function %ineg_not_minus_neg_1(i32) -> i32 {
 block0(v0: i32):
@@ -103,8 +172,8 @@ block0(v0: i32):
     return v3
 }
 
-; check: v4 = ineg v0
-; check: return v4
+; check: v6 = ineg v0
+; check: return v6
 
 function %ineg_not_sub_one(i32) -> i32 {
 block0(v0: i32):
@@ -139,7 +208,17 @@ block0(v0: i32):
 ; check: v6 = ineg v0
 ; check: return v6
 
+function %byte_sub_smax_twice(i8) -> i8 {
+block0(v0: i8):
+    v1 = iconst.i8 127
+    v2 = isub v0, v1
+    v3 = isub v2, v1
+    return v3
+}
 
+; check: v6 = iconst.i8 2
+; check: v7 = iadd v0, v6  ; v6 = 2
+; check: return v7
 
 function %double_fneg(f32) -> f32 {
 block0(v1: f32):
@@ -171,3 +250,108 @@ block0(v1: f32, v2: f32):
 
 ; check: v6 = fmul v1, v2
 ; check: return v6
+
+function %manual_smulhi_32(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+    v2 = sextend.i64 v0
+    v3 = sextend.i64 v1
+    v4 = imul v2, v3
+    v5 = iconst.i32 32
+    v6 = sshr v4, v5
+    v7 = ireduce.i32 v6
+    return v7
+}
+
+; check: v8 = smulhi v0, v1
+; check: return v8
+
+function %manual_smulhi_64(i64, i64) -> i64 {
+block0(v0: i64, v1: i64):
+    v2 = sextend.i128 v0
+    v3 = sextend.i128 v1
+    v4 = imul v2, v3
+    v5 = iconst.i32 64
+    v6 = sshr v4, v5
+    v7 = ireduce.i64 v6
+    return v7
+}
+
+; check: v8 = smulhi v0, v1
+; check: return v8
+
+function %manual_umulhi_32(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+    v2 = uextend.i64 v0
+    v3 = uextend.i64 v1
+    v4 = imul v2, v3
+    v5 = iconst.i32 32
+    v6 = ushr v4, v5
+    v7 = ireduce.i32 v6
+    return v7
+}
+
+; check: v8 = umulhi v0, v1
+; check: return v8
+
+function %manual_umulhi_64(i64, i64) -> i64 {
+block0(v0: i64, v1: i64):
+    v2 = uextend.i128 v0
+    v3 = uextend.i128 v1
+    v4 = imul v2, v3
+    v5 = iconst.i32 64
+    v6 = ushr v4, v5
+    v7 = ireduce.i64 v6
+    return v7
+}
+
+; check: v8 = umulhi v0, v1
+; check: return v8
+
+function %u64_widening_mul(i64, i64, i64) {
+block0(v0: i64, v1: i64, v2: i64):
+    v3 = uextend.i128 v1
+    v4 = uextend.i128 v2
+    v5 = imul v3, v4
+    v6 = iconst.i32 64
+    v7 = ushr v5, v6
+    v8 = ireduce.i64 v7
+    v9 = ireduce.i64 v5
+    store.i64 v9, v0
+    store.i64 v8, v0+8
+    return
+}
+
+; check: v15 = imul v1, v2
+; check: store v15, v0
+; check: v10 = umulhi v1, v2
+; check: store v10, v0+8
+
+function %char_plus_one(i8) -> i8 {
+block0(v0: i8):
+    v1 = sextend.i32 v0
+    v2 = iconst.i32 257
+    v3 = iadd v1, v2
+    v4 = ireduce.i8 v3
+    return v4
+}
+
+; check: v7 = iconst.i8 1
+; check: v8 = iadd v0, v7  ; v7 = 1
+; check: return v8
+
+;; Adding three `short`s together and storing them in a `short`,
+;; which in C involves extending them to `int`s in the middle.
+function %extend_iadd_iadd_reduce(i16, i16, i16) -> i16 {
+block0(v0: i16, v1: i16, v2: i16):
+    v3 = sextend.i32 v0
+    v4 = sextend.i32 v1
+    v5 = sextend.i32 v2
+    v6 = iadd v3, v4
+    v7 = iadd v6, v5
+    v8 = ireduce.i16 v7
+    return v8
+}
+
+; check: v12 = iadd v0, v1
+; check: v15 = iadd v12, v2
+; check: return v15
diff --git a/cranelift/filetests/filetests/egraph/associative-and-commutative.clif b/cranelift/filetests/filetests/egraph/associative-and-commutative.clif
new file mode 100644
index 000000000000..dd1d8567f0c8
--- /dev/null
+++ b/cranelift/filetests/filetests/egraph/associative-and-commutative.clif
@@ -0,0 +1,287 @@
+test optimize
+set opt_level=speed
+target x86_64
+
+function %iadd_shallow_and_wide(i32, i32, i32, i32) -> i32 {
+block0(v0: i32, v1: i32, v2: i32, v3: i32):
+    v4 = iadd v0, v1
+    v5 = iadd v4, v2
+    v6 = iadd v5, v3
+    return v6
+; check:  v4 = iadd v0, v1
+; nextln: v7 = iadd v2, v3
+; nextln: v8 = iadd v4, v7
+; check: return v8
+}
+
+function %iadd_shallow_and_wide_twice(i32, i32, i32, i32, i32, i32) -> i32 {
+block0(v0: i32, v1: i32, v2: i32, v3: i32, v4: i32, v5: i32):
+    v6 = iadd v0, v1
+    v7 = iadd v6, v2
+    v8 = iadd v7, v3
+    v9 = iadd v8, v4
+    v10 = iadd v9, v5
+    return v10
+; check:  v6 = iadd v0, v1
+; nextln: v11 = iadd v2, v3
+; nextln: v12 = iadd v6, v11
+; nextln: v16 = iadd v4, v5
+; nextln: v23 = iadd v12, v16
+; nextln: return v23
+}
+
+function %iadd_reassociate_then_cprop(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+    v2 = iconst.i32 42
+    v3 = iconst.i32 36
+    v4 = iadd v0, v2
+    v5 = iadd v1, v3
+    v6 = iadd v4, v5
+    return v6
+; check:  v7 = iadd v0, v1
+; nextln: v9 = iconst.i32 78
+; nextln: v15 = iadd v7, v9  ; v9 = 78
+; check:  return v15
+}
+
+function %imul_shallow_and_wide(i32, i32, i32, i32) -> i32 {
+block0(v0: i32, v1: i32, v2: i32, v3: i32):
+    v4 = imul v0, v1
+    v5 = imul v4, v2
+    v6 = imul v5, v3
+    return v6
+; check:  v4 = imul v0, v1
+; nextln: v7 = imul v2, v3
+; nextln: v8 = imul v4, v7
+; check: return v8
+}
+
+function %band_shallow_and_wide(i32, i32, i32, i32) -> i32 {
+block0(v0: i32, v1: i32, v2: i32, v3: i32):
+    v4 = band v0, v1
+    v5 = band v4, v2
+    v6 = band v5, v3
+    return v6
+; check:  v4 = band v0, v1
+; nextln: v7 = band v2, v3
+; nextln: v8 = band v4, v7
+; check: return v8
+}
+
+function %bxor_shallow_and_wide(i32, i32, i32, i32) -> i32 {
+block0(v0: i32, v1: i32, v2: i32, v3: i32):
+    v4 = bxor v0, v1
+    v5 = bxor v4, v2
+    v6 = bxor v5, v3
+    return v6
+; check:  v4 = bxor v0, v1
+; nextln: v7 = bxor v2, v3
+; nextln: v8 = bxor v4, v7
+; check: return v8
+}
+
+;; We don't have any assertions about the result of optimizing this function,
+;; but it's a good canary for unbounded recursion in optimization rulesets. In
+;; particular, because of the shared structure in the dag, it won't be obvious
+;; to rules that are pattern matching on trees that this is actually a chain,
+;; and they will exhibit exponential behavior as a result.
+function %iadd_big_chain(i8) -> i16 {
+block0(v0: i8):
+    v1 = uextend.i32 v0
+    v2 = iconst.i32 42
+    v3 = iadd v1, v2
+    v4 = iadd v3, v3
+    v5 = iadd v4, v4
+    v6 = iadd v5, v5
+    v7 = iadd v6, v6
+    v8 = iadd v7, v7
+    v9 = iadd v8, v8
+    v10 = iadd v9, v9
+    v11 = iadd v10, v10
+    v12 = iadd v11, v11
+    v13 = iadd v12, v12
+    v14 = iadd v13, v13
+    v15 = iadd v14, v14
+    v16 = iadd v15, v15
+    v17 = iadd v16, v16
+    v18 = iadd v17, v17
+    v19 = iadd v18, v18
+    v20 = iadd v19, v19
+    v21 = iadd v20, v20
+    v22 = iadd v21, v21
+    v23 = iadd v22, v22
+    v24 = iadd v23, v23
+    v25 = iadd v24, v24
+    v26 = iadd v25, v25
+    v27 = iadd v26, v26
+    v28 = ireduce.i16 v27
+    return v28
+}
+
+function %iadd_sub_1_shallow_and_wide(i32, i32, i32, i32) -> i32 {
+block0(v0: i32, v1: i32, v2: i32, v3: i32):
+    v4 = isub v2, v3
+    v5 = isub v1, v4
+    v6 = isub v0, v5
+    return v6
+; check:  v7 = isub v0, v1
+; nextln: v4 = isub v2, v3
+; nextln: v8 = iadd v7, v4
+; check: return v8
+}
+
+function %iadd_sub_2_shallow_and_wide(i32, i32, i32, i32) -> i32 {
+block0(v0: i32, v1: i32, v2: i32, v3: i32):
+    v4 = iadd v2, v3
+    v5 = isub v1, v4
+    v6 = isub v0, v5
+    return v6
+; check:  v7 = isub v0, v1
+; nextln: v4 = iadd v2, v3
+; nextln: v8 = iadd v7, v4
+; check: return v8
+}
+
+function %iadd_sub_3_shallow_and_wide(i32, i32, i32, i32) -> i32 {
+block0(v0: i32, v1: i32, v2: i32, v3: i32):
+    v4 = isub v2, v3
+    v5 = iadd v1, v4
+    v6 = isub v0, v5
+    return v6
+; check:  v7 = isub v0, v1
+; nextln: v4 = isub v2, v3
+; nextln: v8 = isub v7, v4
+; check: return v8
+}
+
+function %iadd_sub_4_shallow_and_wide(i32, i32, i32, i32) -> i32 {
+block0(v0: i32, v1: i32, v2: i32, v3: i32):
+    v4 = iadd v2, v3
+    v5 = iadd v1, v4
+    v6 = isub v0, v5
+    return v6
+; check:  v7 = isub v0, v1
+; nextln: v4 = iadd v2, v3
+; nextln: v8 = isub v7, v4
+; check: return v8
+}
+
+function %iadd_sub_5_shallow_and_wide(i32, i32, i32, i32) -> i32 {
+block0(v0: i32, v1: i32, v2: i32, v3: i32):
+    v4 = isub v2, v3
+    v5 = isub v1, v4
+    v6 = iadd v0, v5
+    return v6
+; check:  v7 = iadd v0, v1
+; nextln: v4 = isub v2, v3
+; nextln: v8 = isub v7, v4
+; check: return v8
+}
+
+function %iadd_sub_6_shallow_and_wide(i32, i32, i32, i32) -> i32 {
+block0(v0: i32, v1: i32, v2: i32, v3: i32):
+    v4 = iadd v2, v3
+    v5 = isub v1, v4
+    v6 = iadd v0, v5
+    return v6
+; check:  v7 = iadd v0, v1
+; nextln: v4 = iadd v2, v3
+; nextln: v8 = isub v7, v4
+; check: return v8
+}
+
+function %iadd_sub_7_shallow_and_wide(i32, i32, i32, i32) -> i32 {
+block0(v0: i32, v1: i32, v2: i32, v3: i32):
+    v4 = isub v2, v3
+    v5 = iadd v1, v4
+    v6 = iadd v0, v5
+    return v6
+; check:  v7 = iadd v0, v1
+; nextln: v4 = isub v2, v3
+; nextln: v8 = iadd v7, v4
+; check: return v8
+}
+
+function %isub_add_1_shallow_and_wide(i32, i32, i32, i32) -> i32 {
+block0(v0: i32, v1: i32, v2: i32, v3: i32):
+    v4 = isub v0, v1
+    v5 = isub v4, v2
+    v6 = isub v5, v3
+    return v6
+; check:  v4 = isub v0, v1
+; nextln: v7 = iadd v2, v3
+; nextln: v8 = isub v4, v7
+; check: return v8
+}
+
+function %isub_add_2_shallow_and_wide(i32, i32, i32, i32) -> i32 {
+block0(v0: i32, v1: i32, v2: i32, v3: i32):
+    v4 = isub v0, v1
+    v5 = isub v4, v2
+    v6 = iadd v5, v3
+    return v6
+; check:  v4 = isub v0, v1
+; nextln: v7 = isub v2, v3
+; nextln: v8 = isub v4, v7
+; check: return v8
+}
+
+function %isub_add_3_shallow_and_wide(i32, i32, i32, i32) -> i32 {
+block0(v0: i32, v1: i32, v2: i32, v3: i32):
+    v4 = isub v0, v1
+    v5 = iadd v4, v2
+    v6 = isub v5, v3
+    return v6
+; check:  v4 = isub v0, v1
+; nextln: v7 = isub v2, v3
+; nextln: v8 = iadd v4, v7
+; check: return v8
+}
+
+function %isub_add_4_shallow_and_wide(i32, i32, i32, i32) -> i32 {
+block0(v0: i32, v1: i32, v2: i32, v3: i32):
+    v4 = isub v0, v1
+    v5 = iadd v4, v2
+    v6 = iadd v5, v3
+    return v6
+; check:  v4 = isub v0, v1
+; nextln: v7 = iadd v2, v3
+; nextln: v8 = iadd v4, v7
+; check: return v8
+}
+
+function %isub_add_5_shallow_and_wide(i32, i32, i32, i32) -> i32 {
+block0(v0: i32, v1: i32, v2: i32, v3: i32):
+    v4 = iadd v0, v1
+    v5 = isub v4, v2
+    v6 = isub v5, v3
+    return v6
+; check:  v4 = iadd v0, v1
+; nextln: v7 = iadd v2, v3
+; nextln: v8 = isub v4, v7
+; check: return v8
+}
+
+function %isub_add_6_shallow_and_wide(i32, i32, i32, i32) -> i32 {
+block0(v0: i32, v1: i32, v2: i32, v3: i32):
+    v4 = iadd v0, v1
+    v5 = isub v4, v2
+    v6 = iadd v5, v3
+    return v6
+; check:  v4 = iadd v0, v1
+; nextln: v7 = isub v2, v3
+; nextln: v8 = isub v4, v7
+; check: return v8
+}
+
+function %isub_add_7_shallow_and_wide(i32, i32, i32, i32) -> i32 {
+block0(v0: i32, v1: i32, v2: i32, v3: i32):
+    v4 = iadd v0, v1
+    v5 = iadd v4, v2
+    v6 = isub v5, v3
+    return v6
+; check:  v4 = iadd v0, v1
+; nextln: v7 = isub v2, v3
+; nextln: v8 = iadd v4, v7
+; check: return v8
+}
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/egraph/cprop-splat.clif b/cranelift/filetests/filetests/egraph/cprop-splat.clif
index 798671fe2a48..90ee138200ce 100644
--- a/cranelift/filetests/filetests/egraph/cprop-splat.clif
+++ b/cranelift/filetests/filetests/egraph/cprop-splat.clif
@@ -14,7 +14,6 @@ block0:
 ;
 ; block0:
 ;     v3 = vconst.i8x16 const0
-;     v4 -> v3
 ;     return v3  ; v3 = const0
 ; }
 
@@ -30,7 +29,6 @@ block0:
 ;
 ; block0:
 ;     v3 = vconst.i8x16 const0
-;     v4 -> v3
 ;     return v3  ; v3 = const0
 ; }
 
@@ -46,7 +44,6 @@ block0:
 ;
 ; block0:
 ;     v3 = vconst.i16x8 const0
-;     v4 -> v3
 ;     return v3  ; v3 = const0
 ; }
 
@@ -62,7 +59,6 @@ block0:
 ;
 ; block0:
 ;     v3 = vconst.i16x8 const0
-;     v4 -> v3
 ;     return v3  ; v3 = const0
 ; }
 
@@ -78,7 +74,6 @@ block0:
 ;
 ; block0:
 ;     v3 = vconst.i32x4 const0
-;     v4 -> v3
 ;     return v3  ; v3 = const0
 ; }
 
@@ -94,7 +89,6 @@ block0:
 ;
 ; block0:
 ;     v3 = vconst.i32x4 const0
-;     v4 -> v3
 ;     return v3  ; v3 = const0
 ; }
 
@@ -110,7 +104,6 @@ block0:
 ;
 ; block0:
 ;     v3 = vconst.i64x2 const0
-;     v4 -> v3
 ;     return v3  ; v3 = const0
 ; }
 
@@ -126,7 +119,6 @@ block0:
 ;
 ; block0:
 ;     v3 = vconst.i64x2 const0
-;     v4 -> v3
 ;     return v3  ; v3 = const0
 ; }
 
@@ -142,7 +134,6 @@ block0:
 ;
 ; block0:
 ;     v3 = vconst.i8x16 const0
-;     v4 -> v3
 ;     return v3  ; v3 = const0
 ; }
 
@@ -158,7 +149,6 @@ block0:
 ;
 ; block0:
 ;     v3 = vconst.f32x4 const0
-;     v4 -> v3
 ;     return v3  ; v3 = const0
 ; }
 
@@ -174,7 +164,6 @@ block0:
 ;
 ; block0:
 ;     v3 = vconst.f64x2 const0
-;     v4 -> v3
 ;     return v3  ; v3 = const0
 ; }
 
diff --git a/cranelift/filetests/filetests/egraph/cprop.clif b/cranelift/filetests/filetests/egraph/cprop.clif
index e9fef8ca8707..ab9a1254543d 100644
--- a/cranelift/filetests/filetests/egraph/cprop.clif
+++ b/cranelift/filetests/filetests/egraph/cprop.clif
@@ -9,8 +9,8 @@ block0:
     return v2
 }
 
-; check: v9 = iconst.i8 41
-; nextln: return v9
+; check: v3 = iconst.i8 41
+; nextln: return v3
 
 function %f1() -> i16 {
 block0:
@@ -19,7 +19,7 @@ block0:
     return v2
 }
 
-; check: v3 = iconst.i16 0xfffe
+; check: v3 = iconst.i16 -2
 ; nextln: return v3
 
 function %ishl() -> i8 {
@@ -96,7 +96,7 @@ block0:
     return v2
 }
 
-; check: v3 = iconst.i8 252
+; check: v3 = iconst.i8 -4
 ; check: return v3
 
 function %sshr_i8_i16() -> i8 {
@@ -107,7 +107,7 @@ block0:
     return v2
 }
 
-; check: v3 = iconst.i8 252
+; check: v3 = iconst.i8 -4
 ; check: return v3
 
 function %sshr_i16_i8() -> i16 {
@@ -118,7 +118,7 @@ block0:
     return v2
 }
 
-; check: v3 = iconst.i16 0xfffc
+; check: v3 = iconst.i16 -4
 ; check: return v3
 
 function %icmp_eq_i32() -> i8 {
@@ -238,7 +238,7 @@ block0:
     return v2
 }
 
-; check: v3 = iconst.i8 246
+; check: v3 = iconst.i8 -10
 ; nextln: return v3
 
 function %sextend_iconst() -> i32 {
@@ -248,7 +248,7 @@ block0:
     return v2
 }
 
-; check: v3 = iconst.i32 0xffff_fff6
+; check: v3 = iconst.i32 -10
 ; nextln: return v3
 
 function %uextend_iconst() -> i32 {
@@ -260,3 +260,640 @@ block0:
 
 ; check: v3 = iconst.i32 0xfff6
 ; nextln: return v3
+
+function %sub_u8max(i8) -> i8 {
+block0(v0: i8):
+    v1 = iconst.i8 255
+    v2 = isub v0, v1
+    return v2
+}
+
+; check: v3 = iconst.i8 1
+; nextln: v4 = iadd v0, v3  ; v3 = 1
+; nextln: return v4
+
+function %sub_u32max(i32) -> i32 {
+block0(v0: i32):
+    v1 = iconst.i32 0xFFFF_FFFF
+    v2 = isub v0, v1
+    return v2
+}
+
+; check: v3 = iconst.i32 1
+; nextln: v4 = iadd v0, v3  ; v3 = 1
+; nextln: return v4
+
+function %bswap_i16() -> i16 {
+block0:
+    v0 = iconst.i16 0x1234
+    v1 = bswap v0
+    return v1
+}
+
+; check: v2 = iconst.i16 0x3412
+; nextln: return v2
+
+function %bswap_i32() -> i32 {
+block0:
+    v0 = iconst.i32 0x1234_5678
+    v1 = bswap v0
+    return v1
+}
+
+; check: v2 = iconst.i32 0x7856_3412
+; nextln: return v2
+
+function %bswap_i64() -> i64 {
+block0:
+    v0 = iconst.i64 0x1234_5678_9abc_def0
+    v1 = bswap v0
+    return v1
+}
+
+; check: v2 = iconst.i64 -1090226688147180526
+; nextln: return v2
+
+function %f16_fmin() -> f16 {
+block0:
+    v1 = f16const -0x1.5p6
+    v2 = f16const -0x1.5p7
+    v3 = fmin v2, v1
+    return v3
+}
+
+; check: v4 = f16const -0x1.500p7
+; check: return v4  ; v4 = -0x1.500p7
+
+function %f16_fmin_zero_1() -> f16 {
+block0:
+    v1 = f16const 0.0
+    v2 = f16const -0.0
+    v3 = fmin v1, v2
+    return v3
+}
+
+; check: v4 = f16const -0.0
+; check: return v4  ; v4 = -0.0
+
+function %f16_fmin_zero_2() -> f16 {
+block0:
+    v1 = f16const -0.0
+    v2 = f16const 0.0
+    v3 = fmin v1, v2
+    return v3
+}
+
+; check: v4 = f16const -0.0
+; check: return v4  ; v4 = -0.0
+
+function %f16_fmax() -> f16 {
+block0:
+    v1 = f16const -0x1.5p6
+    v2 = f16const -0x1.5p7
+    v3 = fmax v2, v1
+    return v3
+}
+
+; check: v4 = f16const -0x1.500p6
+; check: return v4  ; v4 = -0x1.500p6
+
+function %f16_fmax_zero_1() -> f16 {
+block0:
+    v1 = f16const 0.0
+    v2 = f16const -0.0
+    v3 = fmax v1, v2
+    return v3
+}
+
+; check: v4 = f16const 0.0
+; check: return v4  ; v4 = 0.0
+
+function %f16_fmax_zero_2() -> f16 {
+block0:
+    v1 = f16const -0.0
+    v2 = f16const 0.0
+    v3 = fmax v1, v2
+    return v3
+}
+
+; check: v4 = f16const 0.0
+; check: return v4  ; v4 = 0.0
+
+function %f16_fneg() -> f16 {
+block0:
+    v1 = f16const 0.0
+    v2 = fneg v1
+    return v2
+}
+
+; check: v3 = f16const -0.0
+; check: return v3  ; v3 = -0.0
+
+function %f16_fabs() -> f16 {
+block0:
+    v1 = f16const -0.0
+    v2 = fabs v1
+    return v2
+}
+
+; check: v3 = f16const 0.0
+; check: return v3  ; v3 = 0.0
+
+function %f16_fcopysign() -> f16 {
+block0:
+    v1 = f16const -0.0
+    v2 = f16const NaN
+    v3 = fcopysign v2, v1
+    return v3
+}
+
+; check: v4 = f16const -NaN
+; check: return v4  ; v4 = -NaN
+
+function %f32_fadd() -> f32 {
+block0:
+    v1 = f32const 0x1.fp2
+    v2 = f32const 0x1.9p3
+    v3 = fadd v1, v2
+    return v3
+}
+
+; check: v4 = f32const 0x1.440000p4
+; check: return v4  ; v4 = 0x1.440000p4
+
+function %f32_fsub() -> f32 {
+block0:
+    v1 = f32const 0x1.fp2
+    v2 = f32const 0x1.9p3
+    v3 = fsub v1, v2
+    return v3
+}
+
+; check: v4 = f32const -0x1.300000p2
+; check: return v4  ; v4 = -0x1.300000p2
+
+function %f32_fmul() -> f32 {
+block0:
+    v1 = f32const 0x1.fp2
+    v2 = f32const 0x1.9p3
+    v3 = fmul v1, v2
+    return v3
+}
+
+; check: v4 = f32const 0x1.838000p6
+; check: return v4  ; v4 = 0x1.838000p6
+
+function %f32_fdiv() -> f32 {
+block0:
+    v1 = f32const 0x1.9p5
+    v2 = f32const 0x1.9p3
+    v3 = fdiv v1, v2
+    return v3
+}
+
+; check: v4 = f32const 0x1.000000p2
+; check: return v4  ; v4 = 0x1.000000p2
+
+function %f32_sqrt() -> f32 {
+block0:
+    v1 = f32const 0x1.9p4
+    v2 = sqrt v1
+    return v2
+}
+
+; check: v3 = f32const 0x1.400000p2
+; check: return v3  ; v3 = 0x1.400000p2
+
+function %f32_ceil() -> f32 {
+block0:
+    v1 = f32const -0x1.9p3
+    v2 = ceil v1
+    return v2
+}
+
+; check: v3 = f32const -0x1.800000p3
+; check: return v3  ; v3 = -0x1.800000p3
+
+function %f32_floor() -> f32 {
+block0:
+    v1 = f32const -0x1.9p3
+    v2 = floor v1
+    return v2
+}
+
+; check: v3 = f32const -0x1.a00000p3
+; check: return v3  ; v3 = -0x1.a00000p3
+
+function %f32_trunc() -> f32 {
+block0:
+    v1 = f32const 0x1.9p3
+    v2 = trunc v1
+    return v2
+}
+
+; check: v3 = f32const 0x1.800000p3
+; check: return v3  ; v3 = 0x1.800000p3
+
+function %f32_nearest() -> f32 {
+block0:
+    v1 = f32const 0x1.9p3
+    v2 = nearest v1
+    return v2
+}
+
+; check: v3 = f32const 0x1.800000p3
+; check: return v3  ; v3 = 0x1.800000p3
+
+function %f32_fmin() -> f32 {
+block0:
+    v1 = f32const 0x1.5p6
+    v2 = f32const 0x1.5p7
+    v3 = fmin v2, v1
+    return v3
+}
+
+; check: v4 = f32const 0x1.500000p6
+; check: return v4  ; v4 = 0x1.500000p6
+
+function %f32_fmin_zero_1() -> f32 {
+block0:
+    v1 = f32const 0.0
+    v2 = f32const -0.0
+    v3 = fmin v1, v2
+    return v3
+}
+
+; check: v4 = f32const -0.0
+; check: return v4  ; v4 = -0.0
+
+function %f32_fmin_zero_2() -> f32 {
+block0:
+    v1 = f32const -0.0
+    v2 = f32const 0.0
+    v3 = fmin v1, v2
+    return v3
+}
+
+; check: v4 = f32const -0.0
+; check: return v4  ; v4 = -0.0
+
+function %f32_fmax() -> f32 {
+block0:
+    v1 = f32const 0x1.5p6
+    v2 = f32const 0x1.5p7
+    v3 = fmax v2, v1
+    return v3
+}
+
+; check: v4 = f32const 0x1.500000p7
+; check: return v4  ; v4 = 0x1.500000p7
+
+function %f32_fmax_zero_1() -> f32 {
+block0:
+    v1 = f32const 0.0
+    v2 = f32const -0.0
+    v3 = fmax v1, v2
+    return v3
+}
+
+; check: v4 = f32const 0.0
+; check: return v4  ; v4 = 0.0
+
+function %f32_fmax_zero_2() -> f32 {
+block0:
+    v1 = f32const -0.0
+    v2 = f32const 0.0
+    v3 = fmax v1, v2
+    return v3
+}
+
+; check: v4 = f32const 0.0
+; check: return v4  ; v4 = 0.0
+
+function %f32_fneg() -> f32 {
+block0:
+    v1 = f32const 0.0
+    v2 = fneg v1
+    return v2
+}
+
+; check: v3 = f32const -0.0
+; check: return v3  ; v3 = -0.0
+
+function %f32_fabs() -> f32 {
+block0:
+    v1 = f32const -0.0
+    v2 = fabs v1
+    return v2
+}
+
+; check: v3 = f32const 0.0
+; check: return v3  ; v3 = 0.0
+
+function %f32_fcopysign() -> f32 {
+block0:
+    v1 = f32const -0.0
+    v2 = f32const NaN
+    v3 = fcopysign v2, v1
+    return v3
+}
+
+; check: v4 = f32const -NaN
+; check: return v4  ; v4 = -NaN
+
+function %f64_fadd() -> f64 {
+block0:
+    v1 = f64const 0x1.fp2
+    v2 = f64const 0x1.9p3
+    v3 = fadd v1, v2
+    return v3
+}
+
+; check: v4 = f64const 0x1.4400000000000p4
+; check: return v4  ; v4 = 0x1.4400000000000p4
+
+function %f64_fsub() -> f64 {
+block0:
+    v1 = f64const 0x1.fp2
+    v2 = f64const 0x1.9p3
+    v3 = fsub v1, v2
+    return v3
+}
+
+; check: v4 = f64const -0x1.3000000000000p2
+; check: return v4  ; v4 = -0x1.3000000000000p2
+
+function %f64_fmul() -> f64 {
+block0:
+    v1 = f64const 0x1.fp2
+    v2 = f64const 0x1.9p3
+    v3 = fmul v1, v2
+    return v3
+}
+
+; check: v4 = f64const 0x1.8380000000000p6
+; check: return v4  ; v4 = 0x1.8380000000000p6
+
+function %f64_fdiv() -> f64 {
+block0:
+    v1 = f64const 0x1.9p5
+    v2 = f64const 0x1.9p3
+    v3 = fdiv v1, v2
+    return v3
+}
+
+; check: v4 = f64const 0x1.0000000000000p2
+; check: return v4  ; v4 = 0x1.0000000000000p2
+
+function %f64_sqrt() -> f64 {
+block0:
+    v1 = f64const 0x1.9p4
+    v2 = sqrt v1
+    return v2
+}
+
+; check: v3 = f64const 0x1.4000000000000p2
+; check: return v3  ; v3 = 0x1.4000000000000p2
+
+function %f64_ceil() -> f64 {
+block0:
+    v1 = f64const 0x1.9p3
+    v2 = ceil v1
+    return v2
+}
+
+; check: v3 = f64const 0x1.a000000000000p3
+; check: return v3  ; v3 = 0x1.a000000000000p3
+
+function %f64_floor() -> f64 {
+block0:
+    v1 = f64const 0x1.9p3
+    v2 = floor v1
+    return v2
+}
+
+; check: v3 = f64const 0x1.8000000000000p3
+; check: return v3  ; v3 = 0x1.8000000000000p3
+
+function %f64_trunc() -> f64 {
+block0:
+    v1 = f64const 0x1.9p3
+    v2 = trunc v1
+    return v2
+}
+
+; check: v3 = f64const 0x1.8000000000000p3
+; check: return v3  ; v3 = 0x1.8000000000000p3
+
+function %f64_nearest() -> f64 {
+block0:
+    v1 = f64const 0x1.9p3
+    v2 = nearest v1
+    return v2
+}
+
+; check: v3 = f64const 0x1.8000000000000p3
+; check: return v3  ; v3 = 0x1.8000000000000p3
+
+function %f64_fmin() -> f64 {
+block0:
+    v1 = f64const -0x1.5p6
+    v2 = f64const -0x1.5p7
+    v3 = fmin v2, v1
+    return v3
+}
+
+; check: v4 = f64const -0x1.5000000000000p7
+; check: return v4  ; v4 = -0x1.5000000000000p7
+
+function %f64_fmin_zero_1() -> f64 {
+block0:
+    v1 = f64const 0.0
+    v2 = f64const -0.0
+    v3 = fmin v1, v2
+    return v3
+}
+
+; check: v4 = f64const -0.0
+; check: return v4  ; v4 = -0.0
+
+function %f64_fmin_zero_2() -> f64 {
+block0:
+    v1 = f64const -0.0
+    v2 = f64const 0.0
+    v3 = fmin v1, v2
+    return v3
+}
+
+; check: v4 = f64const -0.0
+; check: return v4  ; v4 = -0.0
+
+function %f64_fmax() -> f64 {
+block0:
+    v1 = f64const -0x1.5p6
+    v2 = f64const -0x1.5p7
+    v3 = fmax v2, v1
+    return v3
+}
+
+; check: v4 = f64const -0x1.5000000000000p6
+; check: return v4  ; v4 = -0x1.5000000000000p6
+
+function %f64_fmax_zero_1() -> f64 {
+block0:
+    v1 = f64const 0.0
+    v2 = f64const -0.0
+    v3 = fmax v1, v2
+    return v3
+}
+
+; check: v4 = f64const 0.0
+; check: return v4  ; v4 = 0.0
+
+function %f64_fmax_zero_2() -> f64 {
+block0:
+    v1 = f64const -0.0
+    v2 = f64const 0.0
+    v3 = fmax v1, v2
+    return v3
+}
+
+; check: v4 = f64const 0.0
+; check: return v4  ; v4 = 0.0
+
+function %f64_fneg() -> f64 {
+block0:
+    v1 = f64const 0.0
+    v2 = fneg v1
+    return v2
+}
+
+; check: v3 = f64const -0.0
+; check: return v3  ; v3 = -0.0
+
+function %f64_fabs() -> f64 {
+block0:
+    v1 = f64const -0.0
+    v2 = fabs v1
+    return v2
+}
+
+; check: v3 = f64const 0.0
+; check: return v3  ; v3 = 0.0
+
+function %f64_fcopysign() -> f64 {
+block0:
+    v1 = f64const -0.0
+    v2 = f64const NaN
+    v3 = fcopysign v2, v1
+    return v3
+}
+
+; check: v4 = f64const -NaN
+; check: return v4  ; v4 = -NaN
+
+function %f128_fmin() -> f128 {
+block0:
+    v1 = f128const 0x1.5p6
+    v2 = f128const 0x1.5p7
+    v3 = fmin v2, v1
+    return v3
+}
+
+; check: const0 = 0x40055000000000000000000000000000
+; check: v4 = f128const const0
+; check: return v4  ; v4 = 0x1.5000000000000000000000000000p6
+
+function %f128_fmin_zero_1() -> f128 {
+block0:
+    v1 = f128const 0.0
+    v2 = f128const -0.0
+    v3 = fmin v1, v2
+    return v3
+}
+
+; check: const1 = 0x80000000000000000000000000000000
+; check: v4 = f128const const1
+; check: return v4  ; v4 = -0.0
+
+function %f128_fmin_zero_2() -> f128 {
+block0:
+    v1 = f128const -0.0
+    v2 = f128const 0.0
+    v3 = fmin v1, v2
+    return v3
+}
+
+; check: const0 = 0x80000000000000000000000000000000
+; check: v4 = f128const const0
+; check: return v4  ; v4 = -0.0
+
+function %f128_fmax() -> f128 {
+block0:
+    v1 = f128const 0x1.5p6
+    v2 = f128const 0x1.5p7
+    v3 = fmax v2, v1
+    return v3
+}
+
+; check: const1 = 0x40065000000000000000000000000000
+; check: v4 = f128const const1
+; check: return v4  ; v4 = 0x1.5000000000000000000000000000p7
+
+function %f128_fmax_zero_1() -> f128 {
+block0:
+    v1 = f128const 0.0
+    v2 = f128const -0.0
+    v3 = fmax v1, v2
+    return v3
+}
+
+; check: const0 = 0x00000000000000000000000000000000
+; check: v4 = f128const const0
+; check: return v4  ; v4 = 0.0
+
+function %f128_fmax_zero_2() -> f128 {
+block0:
+    v1 = f128const -0.0
+    v2 = f128const 0.0
+    v3 = fmax v1, v2
+    return v3
+}
+
+; check: const1 = 0x00000000000000000000000000000000
+; check: v4 = f128const const1
+; check: return v4  ; v4 = 0.0
+
+function %f128_fneg() -> f128 {
+block0:
+    v1 = f128const 0.0
+    v2 = fneg v1
+    return v2
+}
+
+; check: const1 = 0x80000000000000000000000000000000
+; check: v3 = f128const const1
+; check: return v3  ; v3 = -0.0
+
+function %f128_fabs() -> f128 {
+block0:
+    v1 = f128const -0.0
+    v2 = fabs v1
+    return v2
+}
+
+; check: const1 = 0x00000000000000000000000000000000
+; check: v3 = f128const const1
+; check: return v3  ; v3 = 0.0
+
+function %f128_fcopysign() -> f128 {
+block0:
+    v1 = f128const -0.0
+    v2 = f128const NaN
+    v3 = fcopysign v2, v1
+    return v3
+}
+
+; check: const2 = 0xffff8000000000000000000000000000
+; check: v4 = f128const const2
+; check: return v4  ; v4 = -NaN
diff --git a/cranelift/filetests/filetests/egraph/extends.clif b/cranelift/filetests/filetests/egraph/extends.clif
index 7ebb2642f572..a4b260eebf7d 100644
--- a/cranelift/filetests/filetests/egraph/extends.clif
+++ b/cranelift/filetests/filetests/egraph/extends.clif
@@ -54,6 +54,28 @@ block0(v1: i16):
 ; check: v4 = sextend.i64 v1
 ; check: return v4
 
+function %suextend_icmp(i16, i16) -> i64 {
+block0(v0: i16, v1: i16):
+    v2 = icmp slt v0, v1
+    v3 = uextend.i32 v2
+    v4 = sextend.i64 v3
+    return v4
+}
+
+; check: v5 = uextend.i64 v2
+; check: return v5
+
+function %usextend_icmp(i16, i16) -> i64 {
+block0(v0: i16, v1: i16):
+    v2 = icmp uge v0, v1
+    v3 = sextend.i32 v2
+    v4 = uextend.i64 v3
+    return v4
+}
+
+; check: v7 = uextend.i64 v2
+; check: return v7
+
 function %sextend_then_reduce(i16) -> i16 {
 block0(v1: i16):
     v2 = sextend.i32 v1
@@ -71,3 +93,157 @@ block0(v1: i32):
 }
 
 ; check: return v1
+
+function %sextend_then_reduce_smaller(i32) -> i16 {
+block0(v1: i32):
+    v2 = sextend.i64 v1
+    v3 = ireduce.i16 v2
+    return v3
+}
+
+; check: v4 = ireduce.i16 v1
+; check: return v4
+
+function %uextend_then_reduce_smaller(i32) -> i16 {
+block0(v1: i32):
+    v2 = uextend.i64 v1
+    v3 = ireduce.i16 v2
+    return v3
+}
+
+; check: v4 = ireduce.i16 v1
+; check: return v4
+
+function %sextend_then_reduce_partially(i16) -> i32 {
+block0(v1: i16):
+    v2 = sextend.i64 v1
+    v3 = ireduce.i32 v2
+    return v3
+}
+
+; check: v4 = sextend.i32 v1
+; check: return v4
+
+function %uextend_then_reduce_partially(i16) -> i32 {
+block0(v1: i16):
+    v2 = uextend.i64 v1
+    v3 = ireduce.i32 v2
+    return v3
+}
+
+; check: v4 = uextend.i32 v1
+; check: return v4
+
+function %sextend_then_slt_zero(i8) -> i8 {
+block0(v0: i8):
+    v1 = sextend.i16 v0
+    v2 = iconst.i16 0
+    v3 = icmp slt v1, v2
+    return v3
+}
+
+; check: v4 = iconst.i8 0
+; check: v5 = icmp slt v0, v4
+; check: return v5
+
+function %sextend_then_ne_zero(i8) -> i8 {
+block0(v0: i8):
+    v1 = sextend.i16 v0
+    v2 = iconst.i16 0
+    v3 = icmp ne v1, v2
+    return v3
+}
+
+; check: v4 = iconst.i8 0
+; check: v5 = icmp ne v0, v4
+; check: return v5
+
+function %extend_imul_reduce(i64, i64) -> i64 {
+block0(v0: i64, v1: i64):
+    v2 = uextend.i128 v0
+    v3 = uextend.i128 v1
+    v4 = imul v2, v3
+    v5 = ireduce.i64 v4
+    return v5
+}
+
+; check: v8 = imul v0, v1
+; check: return v8
+
+function %extend_iadd_reduce(i16, i16) -> i16 {
+block0(v0: i16, v1: i16):
+    v2 = sextend.i32 v0
+    v3 = sextend.i32 v1
+    v4 = iadd v2, v3
+    v5 = ireduce.i16 v4
+    return v5
+}
+
+; check: v8 = iadd v0, v1
+; check: return v8
+
+function %extend_bxor_reduce(i64, i64) -> i64 {
+block0(v0: i64, v1: i64):
+    v2 = uextend.i128 v0
+    v3 = uextend.i128 v1
+    v4 = bxor v2, v3
+    v5 = ireduce.i64 v4
+    return v5
+}
+
+; check: v6 = bxor v0, v1
+; check: return v6
+
+function %extend_band_reduce(i16, i16) -> i16 {
+block0(v0: i16, v1: i16):
+    v2 = sextend.i32 v0
+    v3 = sextend.i32 v1
+    v4 = band v2, v3
+    v5 = ireduce.i16 v4
+    return v5
+}
+
+; check: v8 = band v0, v1
+; check: return v8
+
+function %extend_ineg_reduce(i64) -> i64 {
+block0(v0: i64):
+    v1 = sextend.i128 v0
+    v2 = ineg v1
+    v3 = ireduce.i64 v2
+    return v3
+}
+
+; check: v5 = ineg v0
+; check: return v5
+
+function %extend_bnot_reduce(i16) -> i16 {
+block0(v0: i16):
+    v1 = uextend.i32 v0
+    v2 = bnot v1
+    v3 = ireduce.i16 v2
+    return v3
+}
+
+; check: v5 = bnot v0
+; check: return v5
+
+function %concat_zero(i64) -> i128 {
+block0(v0: i64):
+    v1 = iconst.i64 0
+    v2 = iconcat v0, v1
+    return v2
+}
+
+; check: v3 = uextend.i128 v0
+; check: return v3
+
+function %sext128(i64) -> i128 {
+block0(v0: i64):
+    v1 = sshr_imm v0, 63
+    v2 = iconcat v0, v1
+    return v2
+}
+
+; check: v4 = sextend.i128 v0
+; check: return v4
diff --git a/cranelift/filetests/filetests/egraph/fcvt-from-int.clif b/cranelift/filetests/filetests/egraph/fcvt-from-int.clif
new file mode 100644
index 000000000000..9d98b01412b0
--- /dev/null
+++ b/cranelift/filetests/filetests/egraph/fcvt-from-int.clif
@@ -0,0 +1,222 @@
+test optimize
+set opt_level=speed
+target x86_64
+target aarch64
+target s390x
+target riscv64
+
+function %i32_0_to_f32() -> f32 {
+block0:
+  v0 = iconst.i32 0
+  v1 = fcvt_from_sint.f32 v0
+  return v1
+  ; check: v2 = f32const 0.0
+  ; check: return v2
+}
+
+function %i32_neg1_to_f32() -> f32 {
+block0:
+  v0 = iconst.i32 -1
+  v1 = fcvt_from_sint.f32 v0
+  return v1
+  ; check: v2 = f32const -0x1.000000p0
+  ; check: return v2
+}
+
+function %i32_1_to_f32() -> f32 {
+block0:
+  v0 = iconst.i32 1
+  v1 = fcvt_from_sint.f32 v0
+  return v1
+  ; check: v2 = f32const 0x1.000000p0
+  ; check: return v2
+}
+
+function %u32_0_to_f32() -> f32 {
+block0:
+  v0 = iconst.i32 0
+  v1 = fcvt_from_uint.f32 v0
+  return v1
+  ; check: v2 = f32const 0.0
+  ; check: return v2
+}
+
+function %u32_neg1_to_f32() -> f32 {
+block0:
+  v0 = iconst.i32 -1
+  v1 = fcvt_from_uint.f32 v0
+  return v1
+  ; check: v2 = f32const 0x1.000000p32
+  ; check: return v2
+}
+
+function %u32_1_to_f32() -> f32 {
+block0:
+  v0 = iconst.i32 1
+  v1 = fcvt_from_uint.f32 v0
+  return v1
+  ; check: v2 = f32const 0x1.000000p0
+  ; check: return v2
+}
+
+function %i32_0_to_f64() -> f64 {
+block0:
+  v0 = iconst.i32 0
+  v1 = fcvt_from_sint.f64 v0
+  return v1
+  ; check: v2 = f64const 0.0
+  ; check: return v2
+}
+
+function %i32_neg1_to_f64() -> f64 {
+block0:
+  v0 = iconst.i32 -1
+  v1 = fcvt_from_sint.f64 v0
+  return v1
+  ; check: v2 = f64const -0x1.0000000000000p0
+  ; check: return v2
+}
+
+function %i32_1_to_f64() -> f64 {
+block0:
+  v0 = iconst.i32 1
+  v1 = fcvt_from_sint.f64 v0
+  return v1
+  ; check: v2 = f64const 0x1.0000000000000p0
+  ; check: return v2
+}
+
+function %u32_0_to_f64() -> f64 {
+block0:
+  v0 = iconst.i32 0
+  v1 = fcvt_from_uint.f64 v0
+  return v1
+  ; check: v2 = f64const 0.0
+  ; check: return v2
+}
+
+function %u32_neg1_to_f64() -> f64 {
+block0:
+  v0 = iconst.i32 -1
+  v1 = fcvt_from_uint.f64 v0
+  return v1
+  ; check: v2 = f64const 0x1.fffffffe00000p31
+  ; check: return v2
+}
+
+function %u32_1_to_f64() -> f64 {
+block0:
+  v0 = iconst.i32 1
+  v1 = fcvt_from_uint.f64 v0
+  return v1
+  ; check: v2 = f64const 0x1.0000000000000p0
+  ; check: return v2
+}
+
+function %i64_0_to_f32() -> f32 {
+block0:
+  v0 = iconst.i64 0
+  v1 = fcvt_from_sint.f32 v0
+  return v1
+  ; check: v2 = f32const 0.0
+  ; check: return v2
+}
+
+function %i64_neg1_to_f32() -> f32 {
+block0:
+  v0 = iconst.i64 -1
+  v1 = fcvt_from_sint.f32 v0
+  return v1
+  ; check: v2 = f32const -0x1.000000p0
+  ; check: return v2
+}
+
+function %i64_1_to_f32() -> f32 {
+block0:
+  v0 = iconst.i64 1
+  v1 = fcvt_from_sint.f32 v0
+  return v1
+  ; check: v2 = f32const 0x1.000000p0
+  ; check: return v2
+}
+
+function %u64_0_to_f32() -> f32 {
+block0:
+  v0 = iconst.i64 0
+  v1 = fcvt_from_uint.f32 v0
+  return v1
+  ; check: v2 = f32const 0.0
+  ; check: return v2
+}
+
+function %u64_neg1_to_f32() -> f32 {
+block0:
+  v0 = iconst.i64 -1
+  v1 = fcvt_from_uint.f32 v0
+  return v1
+  ; check: v2 = f32const 0x1.000000p64
+  ; check: return v2
+}
+
+function %u64_1_to_f32() -> f32 {
+block0:
+  v0 = iconst.i64 1
+  v1 = fcvt_from_uint.f32 v0
+  return v1
+  ; check: v2 = f32const 0x1.000000p0
+  ; check: return v2
+}
+
+function %i64_0_to_f64() -> f64 {
+block0:
+  v0 = iconst.i64 0
+  v1 = fcvt_from_sint.f64 v0
+  return v1
+  ; check: v2 = f64const 0.0
+  ; check: return v2
+}
+
+function %i64_neg1_to_f64() -> f64 {
+block0:
+  v0 = iconst.i64 -1
+  v1 = fcvt_from_sint.f64 v0
+  return v1
+  ; check: v2 = f64const -0x1.0000000000000p0
+  ; check: return v2
+}
+
+function %i64_1_to_f64() -> f64 {
+block0:
+  v0 = iconst.i64 1
+  v1 = fcvt_from_sint.f64 v0
+  return v1
+  ; check: v2 = f64const 0x1.0000000000000p0
+  ; check: return v2
+}
+
+function %u64_0_to_f64() -> f64 {
+block0:
+  v0 = iconst.i64 0
+  v1 = fcvt_from_uint.f64 v0
+  return v1
+  ; check: v2 = f64const 0.0
+  ; check: return v2
+}
+
+function %u64_neg1_to_f64() -> f64 {
+block0:
+  v0 = iconst.i64 -1
+  v1 = fcvt_from_uint.f64 v0
+  return v1
+  ; check: v2 = f64const 0x1.0000000000000p64
+  ; check: return v2
+}
+
+function %u64_1_to_f64() -> f64 {
+block0:
+  v0 = iconst.i64 1
+  v1 = fcvt_from_uint.f64 v0
+  return v1
+  ; check: v2 = f64const 0x1.0000000000000p0
+  ; check: return v2
+}
diff --git a/cranelift/filetests/filetests/egraph/fcvt.clif b/cranelift/filetests/filetests/egraph/fcvt.clif
new file mode 100644
index 000000000000..2aacfbe3b1dd
--- /dev/null
+++ b/cranelift/filetests/filetests/egraph/fcvt.clif
@@ -0,0 +1,43 @@
+test optimize
+set opt_level=speed
+target x86_64
+
+function %u32_ext_to_f32(i32) -> f32 {
+block0(v0: i32):
+  v1 = uextend.i64 v0
+  v2 = fcvt_from_uint.f32 v1
+  return v2
+
+  ; check: v3 = fcvt_from_uint.f32 v0
+  ; check: return v3
+}
+
+function %u32_ext_to_f64(i32) -> f64 {
+block0(v0: i32):
+  v1 = uextend.i64 v0
+  v2 = fcvt_from_uint.f64 v1
+  return v2
+
+  ; check: v3 = fcvt_from_uint.f64 v0
+  ; check: return v3
+}
+
+function %i32_ext_to_f32(i32) -> f32 {
+block0(v0: i32):
+  v1 = sextend.i64 v0
+  v2 = fcvt_from_sint.f32 v1
+  return v2
+
+  ; check: v3 = fcvt_from_sint.f32 v0
+  ; check: return v3
+}
+
+function %i32_ext_to_f64(i32) -> f64 {
+block0(v0: i32):
+  v1 = sextend.i64 v0
+  v2 = fcvt_from_sint.f64 v1
+  return v2
+
+  ; check: v3 = fcvt_from_sint.f64 v0
+  ; check: return v3
+}
diff --git a/cranelift/filetests/filetests/egraph/i128-opts.clif b/cranelift/filetests/filetests/egraph/i128-opts.clif
index 40ef77f76763..86a04b1642e1 100644
--- a/cranelift/filetests/filetests/egraph/i128-opts.clif
+++ b/cranelift/filetests/filetests/egraph/i128-opts.clif
@@ -2,11 +2,156 @@ test optimize
 set opt_level=speed
 target x86_64
 
-; This it a regression test to ensure that we don't insert a iconst.i128 when optimizing bxor.
-function %bxor_i128(i128) -> i128 system_v {
+;; There's no `iconst.i128`, so these tests check that the various patterns
+;; that might apply to `i128` introduce extended 64-bit constants instead,
+;; or they're sufficiently conditioned to not apply.
+
+function %bxor_self_i128(i128) -> i128 {
 block0(v0: i128):
     v1 = bxor v0, v0
     return v1
-    ; check: v1 = bxor v0, v0
-    ; nextln: return v1
+    ; check: v2 = iconst.i64 0
+    ; check: v3 = uextend.i128 v2
+    ; check: return v3
+}
+
+function %isub_self_i128(i128) -> i128 {
+block0(v0: i128):
+    v1 = isub v0, v0
+    return v1
+    ; check: v2 = iconst.i64 0
+    ; check: v3 = uextend.i128 v2  ; v2 = 0
+    ; check: return v3
+}
+
+function %band_bnot_self_i128(i128) -> i128 {
+block0(v0: i128):
+    v1 = bnot v0
+    v2 = band v0, v1
+    return v2
+    ; check: v3 = iconst.i64 0
+    ; check: v4 = uextend.i128 v3  ; v3 = 0
+    ; check: return v4
+}
+
+function %bxor_bnot_self_i128(i128) -> i128 {
+block0(v0: i128):
+    v1 = bnot v0
+    v2 = bxor v0, v1
+    return v2
+    ; check: v3 = iconst.i64 -1
+    ; check: v4 = sextend.i128 v3  ; v3 = -1
+    ; check: return v4
+}
+
+function %bor_bnot_self_i128(i128) -> i128 {
+block0(v0: i128):
+    v1 = bnot v0
+    v2 = bor v0, v1
+    return v2
+    ; check: v3 = iconst.i64 -1
+    ; check: v4 = sextend.i128 v3  ; v3 = -1
+    ; check: return v4
+}
+
+function %eq_self_i128(i128) -> i8 {
+block0(v0: i128):
+    v1 = icmp eq v0, v0
+    return v1
+    ; check: v2 = iconst.i8 1
+    ; check: return v2  ; v2 = 1
+}
+
+function %ne_self_i128(i128) -> i8 {
+block0(v0: i128):
+    v1 = icmp ne v0, v0
+    return v1
+    ; check: v2 = iconst.i8 0
+    ; check: return v2  ; v2 = 0
+}
+
+function %eq_self_v128(i8x16) -> i8x16 {
+block0(v0: i8x16):
+    v1 = icmp eq v0, v0
+    return v1
+    ; check: v1 = icmp eq v0, v0
+    ; check: return v1
+}
+
+function %ne_self_v128(i8x16) -> i8x16 {
+block0(v0: i8x16):
+    v1 = icmp ne v0, v0
+    return v1
+    ; check: v1 = icmp ne v0, v0
+    ; check: return v1
+}
+
+function %bor_extended_constants_i128() -> i128 {
+block0:
+    v0 = iconst.i32 9
+    v1 = uextend.i128 v0
+    v2 = iconst.i32 12
+    v3 = uextend.i128 v2
+    v4 = bor v1, v3
+    return v4
+    ; check: v6 = iconst.i32 13
+    ; check: v12 = uextend.i128 v6  ; v6 = 13
+    ; check: return v12
+}
+
+;; These are big enough that they overflow u64, so should not be collapsed
+
+function %bnot_extended_constant_i128() -> i128 {
+block0:
+    v0 = iconst.i32 0
+    v1 = uextend.i128 v0
+    v2 = bnot v1
+    return v2
+    ; check: v0 = iconst.i32 0
+    ; check: v1 = uextend.i128 v0
+    ; check: return v2
+}
+
+function %imul_extended_constants_i128() -> i128 {
+block0:
+    v0 = iconst.i64 5_000_000_000
+    v1 = uextend.i128 v0
+    v2 = iconst.i64 7_000_000_000
+    v3 = uextend.i128 v2
+    v4 = imul v1, v3
+    return v4
+    ; check: v4 = imul v1, v3
+    ; check: return v4
+}
+
+function %iadd_extended_constants_i128() -> i128 {
+block0:
+    v0 = iconst.i64 0x8888_8888_8888_8888
+    v1 = uextend.i128 v0
+    v2 = iconst.i64 0x9999_9999_9999_9999
+    v3 = uextend.i128 v2
+    v4 = iadd v1, v3
+    return v4
+    ; check: v4 = iadd v1, v3
+    ; check: return v4
+}
+
+function %slt() -> i8 {
+block0:
+    v0 = iconst.i64 0
+    v1 = uextend.i128 v0
+    v2 = icmp slt v1, v1
+    return v2
+    ; check: v3 = iconst.i8 0
+    ; check: return
+}
+
+function %ult() -> i8 {
+block0:
+    v0 = iconst.i64 0
+    v1 = uextend.i128 v0
+    v2 = icmp ult v1, v1
+    return v2
+    ; check: v3 = iconst.i8 0
+    ; check: return
 }
diff --git a/cranelift/filetests/filetests/egraph/icmp-parameterized.clif b/cranelift/filetests/filetests/egraph/icmp-parameterized.clif
index 7c7c93083baa..0d5222f9219a 100644
--- a/cranelift/filetests/filetests/egraph/icmp-parameterized.clif
+++ b/cranelift/filetests/filetests/egraph/icmp-parameterized.clif
@@ -16,7 +16,6 @@ block0(v0: i32):
 ; function %icmp_eq_self(i32) -> i8 fast {
 ; block0(v0: i32):
 ;     v2 = iconst.i8 1
-;     v3 -> v2
 ;     return v2  ; v2 = 1
 ; }
 
@@ -29,7 +28,6 @@ block0(v0: i32):
 ; function %icmp_ne_self(i32) -> i8 fast {
 ; block0(v0: i32):
 ;     v2 = iconst.i8 0
-;     v3 -> v2
 ;     return v2  ; v2 = 0
 ; }
 
@@ -42,7 +40,6 @@ block0(v0: i32):
 ; function %icmp_ult_self(i32) -> i8 fast {
 ; block0(v0: i32):
 ;     v2 = iconst.i8 0
-;     v3 -> v2
 ;     return v2  ; v2 = 0
 ; }
 
@@ -55,7 +52,6 @@ block0(v0: i32):
 ; function %icmp_ule_self(i32) -> i8 fast {
 ; block0(v0: i32):
 ;     v2 = iconst.i8 1
-;     v3 -> v2
 ;     return v2  ; v2 = 1
 ; }
 
@@ -68,7 +64,6 @@ block0(v0: i32):
 ; function %icmp_ugt_self(i32) -> i8 fast {
 ; block0(v0: i32):
 ;     v2 = iconst.i8 0
-;     v3 -> v2
 ;     return v2  ; v2 = 0
 ; }
 
@@ -81,7 +76,6 @@ block0(v0: i32):
 ; function %icmp_uge_self(i32) -> i8 fast {
 ; block0(v0: i32):
 ;     v2 = iconst.i8 1
-;     v3 -> v2
 ;     return v2  ; v2 = 1
 ; }
 
@@ -94,7 +88,6 @@ block0(v0: i32):
 ; function %icmp_slt_self(i32) -> i8 fast {
 ; block0(v0: i32):
 ;     v2 = iconst.i8 0
-;     v3 -> v2
 ;     return v2  ; v2 = 0
 ; }
 
@@ -107,7 +100,6 @@ block0(v0: i32):
 ; function %icmp_sle_self(i32) -> i8 fast {
 ; block0(v0: i32):
 ;     v2 = iconst.i8 1
-;     v3 -> v2
 ;     return v2  ; v2 = 1
 ; }
 
@@ -120,7 +112,6 @@ block0(v0: i32):
 ; function %icmp_sgt_self(i32) -> i8 fast {
 ; block0(v0: i32):
 ;     v2 = iconst.i8 0
-;     v3 -> v2
 ;     return v2  ; v2 = 0
 ; }
 
@@ -133,7 +124,6 @@ block0(v0: i32):
 ; function %icmp_sge_self(i32) -> i8 fast {
 ; block0(v0: i32):
 ;     v2 = iconst.i8 1
-;     v3 -> v2
 ;     return v2  ; v2 = 1
 ; }
 
@@ -148,7 +138,6 @@ block0(v1: i64, v2: i64):
 ; function %mask_icmp_result(i64, i64) -> i8 fast {
 ; block0(v1: i64, v2: i64):
 ;     v3 = icmp ult v1, v2
-;     v6 -> v3
 ;     return v3
 ; }
 
@@ -165,7 +154,6 @@ block0(v1: i64, v2: i64):
 ; block0(v1: i64, v2: i64):
 ;     v3 = icmp ult v1, v2
 ;     v4 = uextend.i64 v3
-;     v7 -> v4
 ;     return v4
 ; }
 
@@ -192,8 +180,8 @@ block0(v0: i32):
 
 ; function %icmp_eq_umax(i32) -> i8 fast {
 ; block0(v0: i32):
-;     v1 = iconst.i32 0xffff_ffff
-;     v2 = icmp eq v0, v1  ; v1 = 0xffff_ffff
+;     v1 = iconst.i32 -1
+;     v2 = icmp eq v0, v1  ; v1 = -1
 ;     return v2
 ; }
 
@@ -206,8 +194,8 @@ block0(v0: i32):
 
 ; function %icmp_eq_smin(i32) -> i8 fast {
 ; block0(v0: i32):
-;     v1 = iconst.i32 0x8000_0000
-;     v2 = icmp eq v0, v1  ; v1 = 0x8000_0000
+;     v1 = iconst.i32 -2147483648
+;     v2 = icmp eq v0, v1  ; v1 = -2147483648
 ;     return v2
 ; }
 
@@ -248,8 +236,8 @@ block0(v0: i32):
 
 ; function %icmp_ne_umax(i32) -> i8 fast {
 ; block0(v0: i32):
-;     v1 = iconst.i32 0xffff_ffff
-;     v2 = icmp ne v0, v1  ; v1 = 0xffff_ffff
+;     v1 = iconst.i32 -1
+;     v2 = icmp ne v0, v1  ; v1 = -1
 ;     return v2
 ; }
 
@@ -262,8 +250,8 @@ block0(v0: i32):
 
 ; function %icmp_ne_smin(i32) -> i8 fast {
 ; block0(v0: i32):
-;     v1 = iconst.i32 0x8000_0000
-;     v2 = icmp ne v0, v1  ; v1 = 0x8000_0000
+;     v1 = iconst.i32 -2147483648
+;     v2 = icmp ne v0, v1  ; v1 = -2147483648
 ;     return v2
 ; }
 
@@ -303,9 +291,8 @@ block0(v0: i32):
 
 ; function %icmp_ult_umax(i32) -> i8 fast {
 ; block0(v0: i32):
-;     v1 = iconst.i32 0xffff_ffff
-;     v3 = icmp ne v0, v1  ; v1 = 0xffff_ffff
-;     v4 -> v3
+;     v1 = iconst.i32 -1
+;     v3 = icmp ne v0, v1  ; v1 = -1
 ;     return v3
 ; }
 
@@ -318,8 +305,8 @@ block0(v0: i32):
 
 ; function %icmp_ult_smin(i32) -> i8 fast {
 ; block0(v0: i32):
-;     v1 = iconst.i32 0x8000_0000
-;     v2 = icmp ult v0, v1  ; v1 = 0x8000_0000
+;     v1 = iconst.i32 -2147483648
+;     v2 = icmp ult v0, v1  ; v1 = -2147483648
 ;     return v2
 ; }
 
@@ -348,7 +335,6 @@ block0(v0: i32):
 ; block0(v0: i32):
 ;     v1 = iconst.i32 0
 ;     v3 = icmp eq v0, v1  ; v1 = 0
-;     v4 -> v3
 ;     return v3
 ; }
 
@@ -374,8 +360,8 @@ block0(v0: i32):
 
 ; function %icmp_ule_smin(i32) -> i8 fast {
 ; block0(v0: i32):
-;     v1 = iconst.i32 0x8000_0000
-;     v2 = icmp ule v0, v1  ; v1 = 0x8000_0000
+;     v1 = iconst.i32 -2147483648
+;     v2 = icmp ule v0, v1  ; v1 = -2147483648
 ;     return v2
 ; }
 
@@ -404,7 +390,6 @@ block0(v0: i32):
 ; block0(v0: i32):
 ;     v1 = iconst.i32 0
 ;     v3 = icmp ne v0, v1  ; v1 = 0
-;     v4 -> v3
 ;     return v3
 ; }
 
@@ -430,8 +415,8 @@ block0(v0: i32):
 
 ; function %icmp_ugt_smin(i32) -> i8 fast {
 ; block0(v0: i32):
-;     v1 = iconst.i32 0x8000_0000
-;     v2 = icmp ugt v0, v1  ; v1 = 0x8000_0000
+;     v1 = iconst.i32 -2147483648
+;     v2 = icmp ugt v0, v1  ; v1 = -2147483648
 ;     return v2
 ; }
 
@@ -471,9 +456,8 @@ block0(v0: i32):
 
 ; function %icmp_uge_umax(i32) -> i8 fast {
 ; block0(v0: i32):
-;     v1 = iconst.i32 0xffff_ffff
-;     v3 = icmp eq v0, v1  ; v1 = 0xffff_ffff
-;     v4 -> v3
+;     v1 = iconst.i32 -1
+;     v3 = icmp eq v0, v1  ; v1 = -1
 ;     return v3
 ; }
 
@@ -486,8 +470,8 @@ block0(v0: i32):
 
 ; function %icmp_uge_smin(i32) -> i8 fast {
 ; block0(v0: i32):
-;     v1 = iconst.i32 0x8000_0000
-;     v2 = icmp uge v0, v1  ; v1 = 0x8000_0000
+;     v1 = iconst.i32 -2147483648
+;     v2 = icmp uge v0, v1  ; v1 = -2147483648
 ;     return v2
 ; }
 
@@ -528,8 +512,8 @@ block0(v0: i32):
 
 ; function %icmp_slt_umax(i32) -> i8 fast {
 ; block0(v0: i32):
-;     v1 = iconst.i32 0xffff_ffff
-;     v2 = icmp slt v0, v1  ; v1 = 0xffff_ffff
+;     v1 = iconst.i32 -1
+;     v2 = icmp slt v0, v1  ; v1 = -1
 ;     return v2
 ; }
 
@@ -557,7 +541,6 @@ block0(v0: i32):
 ; block0(v0: i32):
 ;     v1 = iconst.i32 0x7fff_ffff
 ;     v3 = icmp ne v0, v1  ; v1 = 0x7fff_ffff
-;     v4 -> v3
 ;     return v3
 ; }
 
@@ -584,9 +567,9 @@ block0(v0: i32):
 
 ; function %icmp_sle_umax(i32) -> i8 fast {
 ; block0(v0: i32):
-;     v1 = iconst.i32 0xffff_ffff
-;     v2 = icmp sle v0, v1  ; v1 = 0xffff_ffff
-;     return v2
+;     v3 = iconst.i32 0
+;     v4 = icmp slt v0, v3  ; v3 = 0
+;     return v4
 ; }
 
 function %icmp_sle_smin(i32) -> i8 {
@@ -598,9 +581,8 @@ block0(v0: i32):
 
 ; function %icmp_sle_smin(i32) -> i8 fast {
 ; block0(v0: i32):
-;     v1 = iconst.i32 0x8000_0000
-;     v3 = icmp eq v0, v1  ; v1 = 0x8000_0000
-;     v4 -> v3
+;     v1 = iconst.i32 -2147483648
+;     v3 = icmp eq v0, v1  ; v1 = -2147483648
 ;     return v3
 ; }
 
@@ -640,9 +622,9 @@ block0(v0: i32):
 
 ; function %icmp_sgt_umax(i32) -> i8 fast {
 ; block0(v0: i32):
-;     v1 = iconst.i32 0xffff_ffff
-;     v2 = icmp sgt v0, v1  ; v1 = 0xffff_ffff
-;     return v2
+;     v3 = iconst.i32 0
+;     v4 = icmp sge v0, v3  ; v3 = 0
+;     return v4
 ; }
 
 function %icmp_sgt_smin(i32) -> i8 {
@@ -654,9 +636,8 @@ block0(v0: i32):
 
 ; function %icmp_sgt_smin(i32) -> i8 fast {
 ; block0(v0: i32):
-;     v1 = iconst.i32 0x8000_0000
-;     v3 = icmp ne v0, v1  ; v1 = 0x8000_0000
-;     v4 -> v3
+;     v1 = iconst.i32 -2147483648
+;     v3 = icmp ne v0, v1  ; v1 = -2147483648
 ;     return v3
 ; }
 
@@ -696,8 +677,8 @@ block0(v0: i32):
 
 ; function %icmp_sge_umax(i32) -> i8 fast {
 ; block0(v0: i32):
-;     v1 = iconst.i32 0xffff_ffff
-;     v2 = icmp sge v0, v1  ; v1 = 0xffff_ffff
+;     v1 = iconst.i32 -1
+;     v2 = icmp sge v0, v1  ; v1 = -1
 ;     return v2
 ; }
 
@@ -725,7 +706,6 @@ block0(v0: i32):
 ; block0(v0: i32):
 ;     v1 = iconst.i32 0x7fff_ffff
 ;     v3 = icmp eq v0, v1  ; v1 = 0x7fff_ffff
-;     v4 -> v3
 ;     return v3
 ; }
 
@@ -782,7 +762,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_eq_ule(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp eq v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -811,7 +790,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_eq_uge(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp eq v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -840,7 +818,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_eq_sle(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp eq v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -869,7 +846,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_eq_sge(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp eq v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -912,7 +888,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_ne_ult(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ult v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -927,7 +902,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_ne_ule(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ult v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -942,7 +916,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_ne_ugt(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ugt v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -957,7 +930,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_ne_uge(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ugt v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -972,7 +944,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_ne_slt(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp slt v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -987,7 +958,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_ne_sle(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp slt v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -1002,7 +972,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_ne_sgt(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp sgt v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -1017,7 +986,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_ne_sge(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp sgt v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -1046,7 +1014,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_ult_ne(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ult v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -1075,7 +1042,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_ult_ule(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ult v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -1182,7 +1148,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_ule_eq(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp eq v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -1197,7 +1162,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_ule_ne(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ult v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -1212,7 +1176,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_ule_ult(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ult v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -1255,7 +1218,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_ule_uge(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp eq v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -1348,7 +1310,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_ugt_ne(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ugt v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -1405,7 +1366,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_ugt_uge(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ugt v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -1484,7 +1444,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_uge_eq(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp eq v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -1499,7 +1458,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_uge_ne(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ugt v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -1528,7 +1486,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_uge_ule(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp eq v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -1543,7 +1500,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_uge_ugt(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ugt v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -1650,7 +1606,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_slt_ne(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp slt v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -1743,7 +1698,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_slt_sle(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp slt v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -1786,7 +1740,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_sle_eq(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp eq v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -1801,7 +1754,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_sle_ne(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp slt v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -1880,7 +1832,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_sle_slt(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp slt v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -1923,7 +1874,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_sle_sge(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp eq v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -1952,7 +1902,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_sgt_ne(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp sgt v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -2073,7 +2022,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_sgt_sge(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp sgt v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -2088,7 +2036,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_sge_eq(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp eq v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -2103,7 +2050,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_sge_ne(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp sgt v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -2196,7 +2142,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_sge_sle(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp eq v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -2211,7 +2156,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_and_sge_sgt(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp sgt v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -2268,7 +2212,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_eq_ult(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ule v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -2283,7 +2226,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_eq_ule(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ule v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -2298,7 +2240,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_eq_ugt(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp uge v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -2313,7 +2254,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_eq_uge(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp uge v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -2328,7 +2268,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_eq_slt(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp sle v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -2343,7 +2282,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_eq_sle(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp sle v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -2358,7 +2296,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_eq_sgt(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp sge v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -2373,7 +2310,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_eq_sge(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp sge v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -2416,7 +2352,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_ne_ult(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ne v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -2445,7 +2380,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_ne_ugt(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ne v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -2474,7 +2408,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_ne_slt(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ne v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -2503,7 +2436,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_ne_sgt(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ne v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -2532,7 +2464,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_ult_eq(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ule v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -2547,7 +2478,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_ult_ne(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ne v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -2576,7 +2506,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_ult_ule(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ule v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -2591,7 +2520,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_ult_ugt(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ne v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -2684,7 +2612,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_ule_eq(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ule v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -2713,7 +2640,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_ule_ult(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ule v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -2834,7 +2760,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_ugt_eq(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp uge v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -2849,7 +2774,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_ugt_ne(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ne v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -2864,7 +2788,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_ugt_ult(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ne v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -2907,7 +2830,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_ugt_uge(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp uge v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -2986,7 +2908,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_uge_eq(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp uge v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -3043,7 +2964,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_uge_ugt(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp uge v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -3136,7 +3056,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_slt_eq(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp sle v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -3151,7 +3070,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_slt_ne(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ne v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -3244,7 +3162,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_slt_sle(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp sle v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -3259,7 +3176,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_slt_sgt(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ne v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -3288,7 +3204,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_sle_eq(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp sle v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -3381,7 +3296,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_sle_slt(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp sle v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -3438,7 +3352,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_sgt_eq(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp sge v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -3453,7 +3366,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_sgt_ne(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ne v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -3532,7 +3444,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_sgt_slt(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp ne v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -3575,7 +3486,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_sgt_sge(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp sge v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -3590,7 +3500,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_sge_eq(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp sge v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -3711,7 +3620,6 @@ block0(v0: i32, v1: i32):
 ; function %icmp_or_sge_sgt(i32, i32) -> i8 fast {
 ; block0(v0: i32, v1: i32):
 ;     v5 = icmp sge v0, v1
-;     v6 -> v5
 ;     return v5
 ; }
 
@@ -3728,4 +3636,3 @@ block0(v0: i32, v1: i32):
 ;     v2 = icmp sge v0, v1
 ;     return v2
 ; }
-
diff --git a/cranelift/filetests/filetests/egraph/icmp.clif b/cranelift/filetests/filetests/egraph/icmp.clif
index af37fa443a50..44f50201dbda 100644
--- a/cranelift/filetests/filetests/egraph/icmp.clif
+++ b/cranelift/filetests/filetests/egraph/icmp.clif
@@ -15,7 +15,6 @@ block0(v1: i64, v2: i64):
 ; function %mask_icmp_result(i64, i64) -> i8 fast {
 ; block0(v1: i64, v2: i64):
 ;     v3 = icmp ult v1, v2
-;     v6 -> v3
 ;     return v3
 ; }
 
@@ -32,7 +31,142 @@ block0(v1: i64, v2: i64):
 ; block0(v1: i64, v2: i64):
 ;     v3 = icmp ult v1, v2
 ;     v4 = uextend.i64 v3
-;     v7 -> v4
 ;     return v4
 ; }
 
+function %icmp_simplify_does_not_build_iconst_i128() -> i8 {
+block0:
+    v0 = iconst.i64 0x6350_5050_5050_3750
+    v1 = iconcat v0, v0
+    v2 = bmask.i8 v1
+    v3 = iconst.i8 0
+    v4 = icmp ugt v2, v3
+    return v4
+}
+
+; function %icmp_simplify_does_not_build_iconst_i128() -> i8 fast {
+; block0:
+;     v0 = iconst.i64 0x6350_5050_5050_3750
+;     v1 = iconcat v0, v0  ; v0 = 0x6350_5050_5050_3750, v0 = 0x6350_5050_5050_3750
+;     v2 = bmask.i8 v1
+;     v3 = iconst.i8 0
+;     v5 = icmp ne v2, v3  ; v3 = 0
+;     return v5
+; }
+
+function %sge_one(i64) -> i8 {
+block0(v0: i64):
+    v1 = iconst.i64 1
+    v2 = icmp sge v0, v1
+    return v2
+}
+
+; function %sge_one(i64) -> i8 fast {
+; block0(v0: i64):
+;     v3 = iconst.i64 0
+;     v4 = icmp sgt v0, v3  ; v3 = 0
+;     return v4
+; }
+
+function %slt_one(i16) -> i8 {
+block0(v0: i16):
+    v1 = iconst.i16 1
+    v2 = icmp slt v0, v1
+    return v2
+}
+
+; function %slt_one(i16) -> i8 fast {
+; block0(v0: i16):
+;     v3 = iconst.i16 0
+;     v4 = icmp sle v0, v3  ; v3 = 0
+;     return v4
+; }
+
+function %uge_one(i32) -> i8 {
+block0(v0: i32):
+    v1 = iconst.i32 1
+    v2 = icmp uge v0, v1
+    return v2
+}
+
+; function %uge_one(i32) -> i8 fast {
+; block0(v0: i32):
+;     v3 = iconst.i32 0
+;     v4 = icmp ne v0, v3  ; v3 = 0
+;     return v4
+; }
+
+function %ult_one(i8) -> i8 {
+block0(v0: i8):
+    v1 = iconst.i8 1
+    v2 = icmp ult v0, v1
+    return v2
+}
+
+; function %ult_one(i8) -> i8 fast {
+; block0(v0: i8):
+;     v3 = iconst.i8 0
+;     v4 = icmp eq v0, v3  ; v3 = 0
+;     return v4
+; }
+
+function %byte_icmp_ucmp(i8) -> i8 {
+block0(v0: i8):
+    v1 = iconst.i8 0
+    v2 = icmp sge v0, v1
+    v3 = icmp eq v2, v1
+    return v3
+}
+
+; function %byte_icmp_ucmp(i8) -> i8 fast {
+; block0(v0: i8):
+;     v1 = iconst.i8 0
+;     v4 = icmp slt v0, v1  ; v1 = 0
+;     return v4
+; }
+
+function %eq_one_of_icmp(i8) -> i8 fast {
+block0(v0: i8):
+    v1 = iconst.i8 5
+    v2 = icmp eq v0, v1
+    v3 = iconst.i8 1
+    v4 = icmp eq v2, v3
+    return v4
+}
+
+; function %eq_one_of_icmp(i8) -> i8 fast {
+; block0(v0: i8):
+;     v1 = iconst.i8 5
+;     v2 = icmp eq v0, v1  ; v1 = 5
+;     return v2
+; }
+
+function %ne_one_of_icmp(i8) -> i8 fast {
+block0(v0: i8):
+    v1 = iconst.i8 5
+    v2 = icmp eq v0, v1
+    v3 = iconst.i8 1
+    v4 = icmp ne v2, v3
+    return v4
+}
+
+; function %ne_one_of_icmp(i8) -> i8 fast {
+; block0(v0: i8):
+;     v1 = iconst.i8 5
+;     v5 = icmp ne v0, v1  ; v1 = 5
+;     return v5
+; }
+
+function %negate_lt(i8, i8) -> i8 fast {
+block0(v0: i8, v1: i8):
+    v2 = icmp ult v0, v1
+    v3 = iconst.i8 1
+    v4 = icmp ne v2, v3
+    return v4
+}
+
+; function %negate_lt(i8, i8) -> i8 fast {
+; block0(v0: i8, v1: i8):
+;     v5 = icmp uge v0, v1
+;     return v5
+; }
diff --git a/cranelift/filetests/filetests/egraph/issue-7875.clif b/cranelift/filetests/filetests/egraph/issue-7875.clif
new file mode 100644
index 000000000000..abdcb32288a5
--- /dev/null
+++ b/cranelift/filetests/filetests/egraph/issue-7875.clif
@@ -0,0 +1,37 @@
+test optimize
+set enable_verifier=true
+set opt_level=speed
+target x86_64
+
+;; This test case should optimize just fine, and should definitely not produce
+;; CLIF that has verifier errors like
+;;
+;;     error: inst10 (v12 = select.f32 v11, v4, v10 ; v11 = 1): uses value arg
+;;     from non-dominating block4
+
+function %foo() {
+block0:
+    v0 = iconst.i64 0
+    v2 = f32const 0.0
+    v9 = f32const 0.0
+    v20 = fneg v2
+    v18 = fcmp eq v20, v20
+    v4 = select v18, v2, v20
+    v8 = iconst.i32 0
+    v11 = iconst.i32 1
+    brif v0, block2, block3
+
+block2:
+    brif.i32 v8, block4(v2), block4(v9)
+
+block4(v10: f32):
+    v12 = select.f32 v11, v4, v10
+    v13 = bitcast.i32 v12
+    store v13, v0
+    trap user0
+
+block3:
+    v15 = bitcast.i32 v4
+    store v15, v0
+    return
+}
diff --git a/cranelift/filetests/filetests/egraph/issue-7891.clif b/cranelift/filetests/filetests/egraph/issue-7891.clif
new file mode 100644
index 000000000000..c30e1edc75c1
--- /dev/null
+++ b/cranelift/filetests/filetests/egraph/issue-7891.clif
@@ -0,0 +1,103 @@
+test optimize
+set opt_level=speed
+target x86_64
+
+; An eclass that is transitively referenced by a side-effecting instruction in a
+; block must not contain any alternatives that use values which are not available
+; in that block. If we violate this rule, then we only get correct results if
+; elaboration happens to not choose the bad alternatives, which means we're
+; relying on the cost function, and there's no reason to believe that's reliable
+; for this purpose.
+; 
+; Unfortunately, we can't currently write test assertions about which alternatives
+; are generated by simplification in the egraph pass. We can only observe which
+; choice was selected by the cost function. So instead these tests try to hit
+; assertions in the egraph pass if the above rule is broken.
+; 
+; These tests are carefully constructed to hit specific code paths in the egraph
+; pass without getting key parts transformed away by other optimizations first:
+; 
+; - There are no loops, to avoid having LICM move the code we care about.
+; 
+; - There are two blocks which contain pure instructions that are identical after
+;   simplification.
+; 
+; - Neither of these blocks dominates the other, so GVN will only combine them if
+;   we allow it to consider instructions in different scopes.
+; 
+; - References to these blocks are constructed to create a specific domtree so the
+;   egraph pass will traverse them in a specific order.
+; 
+; - The block which the egraph pass examines first uses a value that is only
+;   available in that block: a block-param or the result of an effectful
+;   instruction.
+; 
+; By doing all that, we create an opportunity where the first block could produce
+; an eclass which references the value that's only available in that block, and
+; GVN could reuse that eclass for the equivalent instruction in the second block.
+; If the egraph pass does both of those things then it violates the rule above.
+;
+; For more discussion, see:
+; https://github.com/bytecodealliance/wasmtime/pull/7891
+
+function %bad_param_reuse(i32) -> i8 {
+block0(v0: i32): 
+    v1 = iconst.i32 0
+    brif v0, block1, block2(v0)
+
+block1:
+; To prevent the remove-constant-phi pass from removing the block-param, there are
+; multiple references to block2 using different values for the block-param. This
+; reference is dynamically unreachable but Cranelift doesn't know that.
+    brif v0, block3, block2(v1)
+
+block2(v2: i32):
+    v3 = isub v2, v2
+    ; v3 simplifies to `iconst 0`, which is equivalent to v1
+    v4 = icmp eq v0, v3
+    return v4
+
+block3:
+    ; If this icmp replaces v1 with v3, elaboration would clone the isub into this
+    ; block, introducing a reference to v2, which is not in scope here.
+    v5 = icmp eq v0, v1
+    return v5
+}
+
+; check: block2(v2: i32):
+; check:     v8 = iconst.i32 0
+; check:     v4 = icmp.i32 eq v0, v8  ; v8 = 0
+; check:     return v4
+; check: block3:
+; check:     v6 = iconst.i32 0
+; check:     v7 = icmp.i32 eq v0, v6  ; v6 = 0
+; check:     return v7
+
+function %bad_effect_reuse(i64) -> i8 {
+block0(v0: i64):
+    brif v0, block1, block2
+
+block1:
+    v1 = load.i64 heap v0
+    v2 = isub v1, v1
+    ; v2 simplifies to `iconst 0`, which is equivalent to v4
+    v3 = icmp eq v0, v2
+    return v3
+
+block2:
+    v4 = iconst.i64 0
+    ; If this icmp replaces v4 with v2, elaboration would clone the isub into this
+    ; block, introducing a reference to v1, which is not in scope here.
+    v5 = icmp eq v0, v4
+    return v5
+}
+
+; check: block1:
+; check:     v1 = load.i64 heap v0
+; check:     v7 = iconst.i64 0
+; check:     v8 = icmp.i64 eq v0, v7  ; v7 = 0
+; check:     return v8
+; check: block2:
+; check:     v6 = iconst.i64 0
+; check:     v3 = icmp.i64 eq v0, v6  ; v6 = 0
+; check:     return v3
diff --git a/cranelift/filetests/filetests/egraph/issue-7999.clif b/cranelift/filetests/filetests/egraph/issue-7999.clif
new file mode 100644
index 000000000000..2903d2a33c8c
--- /dev/null
+++ b/cranelift/filetests/filetests/egraph/issue-7999.clif
@@ -0,0 +1,15 @@
+test optimize
+set opt_level=speed
+target x86_64
+
+function u0:11(i8) -> i8 system_v {
+block0(v0: i8):
+    v1 = uextend.i64 v0
+    v2 = imul_imm v1, 256
+    v3 = ireduce.i8 v2
+    return v3
+
+    ;; This function should get optimized down to simply returning zero:
+
+    ; check: return v10  ; v10 = 0
+}
diff --git a/cranelift/filetests/filetests/egraph/licm.clif b/cranelift/filetests/filetests/egraph/licm.clif
index f2f84c58302c..8409f3dc0a5e 100644
--- a/cranelift/filetests/filetests/egraph/licm.clif
+++ b/cranelift/filetests/filetests/egraph/licm.clif
@@ -20,21 +20,21 @@ block2(v9: i32):
 }
 
 ; check:  block0(v0: i32, v1: i32):
-; nextln:     jump block1(v0)
+; check:      jump block1(v0)
 
 ; check:  block1(v2: i32):
-;; constants are not lifted; they are rematerialized in each block where used
-; check:      v5 = iconst.i32 40
-; check:      v6 = icmp eq v2, v5
-; check:      v3 = iconst.i32 1
-; check:      v8 = iadd v2, v3
-; check:      brif v6, block2, block1(v8)
+;; constants are rematerialized in each block where used
+; check:      v10 = iconst.i32 40
+; check:      v11 = icmp eq v2, v10
+; check:      v12 = iconst.i32 1
+; check:      v13 = iadd v2, v12
+; check:      brif v11, block2, block1(v13)
 
 
 ; check:  block2:
-; check:      v10 = iconst.i32 1
-; check:      v4 = iadd.i32 v1, v10
-; check:      return v4
+; check:      v14 = iconst.i32 1
+; check:      v15 = iadd.i32 v1, v14
+; check:      return v15
 
 function %f(i64x2, i32) -> i64x2 {
 block0(v0: i64x2, v1: i32):
@@ -52,14 +52,13 @@ block2(v8: i64x2):
 }
 
 ; check:  block0(v0: i64x2, v1: i32):
-; nextln:     v4 = vconst.i64x2 const0
+; check:      v4 = vconst.i64x2 const0
 ; nextln:     jump block1(v0, v1)
 ; check:  block1(v2: i64x2, v3: i32):
-; check:      v6 = iconst.i32 1
-; check:      v7 = isub v3, v6
+; check:      v9 = iconst.i32 1
+; check:      v10 = isub v3, v9
 ; check:      v5 = iadd v2, v4
-; check:      v8 -> v5
-; check:      brif v7, block1(v5, v7), block2
+; check:      brif v10, block1(v5, v10), block2
 ; check:  block2:
 ; check:      return v5
 
@@ -94,13 +93,50 @@ block4:
 ; check:      v8 = vconst.i64x2 const0
 ; check:      jump block2(v3, v1)
 ; check:  block2(v6: i64x2, v7: i32):
-; check:      v10 = iconst.i32 1
-; check:      v11 = isub v7, v10
+; check:      v15 = iconst.i32 1
+; check:      v16 = isub v7, v15
 ; check:      v9 = iadd v6, v8
-; check:      brif v11, block2(v9, v11), block3
+; check:      brif v16, block2(v9, v16), block3
 ; check:  block3:
-; check:      v15 = iconst.i32 1
-; check:      v14 = isub.i32 v5, v15
-; check:      brif v14, block1(v9, v14), block4
+; check:      v17 = iconst.i32 1
+; check:      v18 = isub.i32 v5, v17
+; check:      brif v18, block1(v9, v18), block4
 ; check:  block4:
 ; check:      return v9
+
+;; Don't let a rematerialized iconst inhibit (or even reverse)
+;; LICM. See issue #7283.
+
+function %f(i64, i64) {
+block0(v0: i64, v1: i64):
+    ;; Create a loop-invariant value `v10` which is some operation which
+    ;; includes a constant somewhere.
+    v8 = load.f64 v0+100
+    v9 = f64const 0x1.0000000000000p1
+    v10 = fdiv v8, v9
+
+    ;; jump to the loop
+    v3 = iconst.i64 0
+    jump block2(v3)  ; v3 = 0
+
+block2(v11: i64):
+    ;; store the loop-invariant `v10` to memory "somewhere"
+    v15 = iadd v0, v11
+    store.f64 v10, v15
+
+    ;; loop breakout condition
+    v17 = iadd_imm v11, 1
+    v19 = icmp_imm ne v17, 100
+    brif v19, block2(v17), block1
+
+block1:
+    return
+}
+
+; check: load
+; check: f64const
+; check: fdiv
+; check: block2(v11: i64)
+; check: iadd
+; check: store
+; check: brif
diff --git a/cranelift/filetests/filetests/egraph/load-hoist.clif b/cranelift/filetests/filetests/egraph/load-hoist.clif
index f52a1995c434..37cf9ad360ee 100644
--- a/cranelift/filetests/filetests/egraph/load-hoist.clif
+++ b/cranelift/filetests/filetests/egraph/load-hoist.clif
@@ -41,4 +41,4 @@ function %foo(i64 vmctx, i64, i32, i32) -> i32 fast {
 ; check: block2(v6: i32, v7: i32, v15: i32):
 ; check:    v10 = iadd.i64 v9, v8
 ; check:    v11 = load.i32 little heap v10
-; check:    brif v17, block2(v12, v14, v17), block4
+; check:    brif v19, block2(v12, v21, v19), block4
diff --git a/cranelift/filetests/filetests/egraph/reassociate-constants-in-shifts.clif b/cranelift/filetests/filetests/egraph/reassociate-constants-in-shifts.clif
new file mode 100644
index 000000000000..9d50399d5b1c
--- /dev/null
+++ b/cranelift/filetests/filetests/egraph/reassociate-constants-in-shifts.clif
@@ -0,0 +1,41 @@
+test optimize
+set opt_level=speed
+target x86_64
+
+;; Test egraph rewrite rules that reassociate constants out of nested shifts.
+
+function %a(i32) -> i32 {
+block0(v0: i32):
+    v1 = iconst.i32 1
+    v2 = ishl v1, v0
+    v3 = iconst.i32 2
+    v4 = ishl v2, v3
+    return v4
+; check:  v6 = iconst.i32 4
+; nextln: v7 = ishl v6, v0
+; check:  return v7
+}
+
+function %b(i32) -> i32 {
+block0(v0: i32):
+    v1 = iconst.i32 8
+    v2 = ushr v1, v0
+    v3 = iconst.i32 2
+    v4 = ushr v2, v3
+    return v4
+; check:  v3 = iconst.i32 2
+; nextln: v6 = ushr v3, v0
+; check:  return v6
+}
+
+function %c(i32) -> i32 {
+block0(v0: i32):
+    v1 = iconst.i32 8
+    v2 = sshr v1, v0
+    v3 = iconst.i32 2
+    v4 = sshr v2, v3
+    return v4
+; check:  v3 = iconst.i32 2
+; nextln: v6 = sshr v3, v0
+; check:  return v6
+}
diff --git a/cranelift/filetests/filetests/egraph/remat.clif b/cranelift/filetests/filetests/egraph/remat.clif
index 861e4a8cdd9e..5c98a0751647 100644
--- a/cranelift/filetests/filetests/egraph/remat.clif
+++ b/cranelift/filetests/filetests/egraph/remat.clif
@@ -22,11 +22,9 @@ block2:
 ; check:      v2 = iadd v0, v1
 ; check:      brif v2, block1, block2
 ; check:   block1:
-; check:      v11 = iconst.i32 126
-; check:      v13 = iadd.i32 v0, v11
-; check:      return v13
+; check:      v6 = iconst.i32 126
+; check:      v12 = iadd.i32 v0, v6
+; check:      return v12
 ; check:   block2:
-; check:      v15 = iconst.i32 42
-; check:      v16 = iadd.i32 v0, v15
-; check:      return v16
-
+; check:      v14 = iadd.i32 v0, v1
+; check:      return v14
diff --git a/cranelift/filetests/filetests/egraph/select.clif b/cranelift/filetests/filetests/egraph/select.clif
index 8f5339417f72..2cde44efaa56 100644
--- a/cranelift/filetests/filetests/egraph/select.clif
+++ b/cranelift/filetests/filetests/egraph/select.clif
@@ -141,3 +141,92 @@ block0(v0: i32, v1: i32, v2: i32, v3: i32):
 ; check:    v4 = icmp ule v0, v1
 ; check:    v5 = select v4, v2, v3
 ; check:    return v5
+
+function %then_true_else_false(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp ule v0, v1
+    v3 = iconst.i8 1
+    v4 = iconst.i8 0
+    v5 = select v2, v3, v4
+    return v5
+}
+; check: return v2
+
+function %then_false_else_true(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp slt v0, v1
+    v3 = iconst.i8 0
+    v4 = iconst.i8 1
+    v5 = select v2, v3, v4
+    return v5
+}
+; check: v6 = icmp sge v0, v1
+; check: return v6
+
+function %then_one_else_zero(i32, i32) -> i64 {
+block0(v0: i32, v1: i32):
+    v2 = icmp ule v0, v1
+    v3 = iconst.i64 1
+    v4 = iconst.i64 0
+    v5 = select v2, v3, v4
+    return v5
+}
+; check: v6 = uextend.i64 v2
+; check: return v6
+
+function %then_zero_else_false(i32, i32) -> i64 {
+block0(v0: i32, v1: i32):
+    v2 = icmp slt v0, v1
+    v3 = iconst.i64 0
+    v4 = iconst.i64 1
+    v5 = select v2, v3, v4
+    return v5
+}
+; check: v6 = icmp sge v0, v1
+; check: v8 = uextend.i64 v6
+; check: return v8
+
+function %then_negone_else_zero(i32, i32) -> i64 {
+block0(v0: i32, v1: i32):
+    v2 = icmp ule v0, v1
+    v3 = iconst.i64 -1
+    v4 = iconst.i64 0
+    v5 = select v2, v3, v4
+    return v5
+}
+; check: v6 = bmask.i64 v2
+; check: return v6
+
+function %then_zero_else_else_negone(i32, i32) -> i64 {
+block0(v0: i32, v1: i32):
+    v2 = icmp sle v0, v1
+    v3 = iconst.i64 0
+    v4 = iconst.i64 -1
+    v5 = select v2, v3, v4
+    return v5
+}
+; check: v6 = icmp sgt v0, v1
+; check: v8 = bmask.i64 v6
+; check: return v8
+
+function %lift_uextend_out_of_select(i8, i32, i32) -> i64 {
+block0(v0: i8, v1: i32, v2: i32):
+    v3 = uextend.i64 v1
+    v4 = uextend.i64 v2
+    v5 = select v0, v3, v4
+    return v5
+}
+; check: v6 = select v0, v1, v2
+; check: v7 = uextend.i64 v6
+; check: return v7
+
+function %lift_sextend_out_of_select(i8, i32, i32) -> i64 {
+block0(v0: i8, v1: i32, v2: i32):
+    v3 = sextend.i64 v1
+    v4 = sextend.i64 v2
+    v5 = select v0, v3, v4
+    return v5
+}
+; check: v6 = select v0, v1, v2
+; check: v7 = sextend.i64 v6
+; check: return v7
diff --git a/cranelift/filetests/filetests/egraph/shifts.clif b/cranelift/filetests/filetests/egraph/shifts.clif
index b8028c50e6f0..8e8192d3e06f 100644
--- a/cranelift/filetests/filetests/egraph/shifts.clif
+++ b/cranelift/filetests/filetests/egraph/shifts.clif
@@ -8,7 +8,7 @@ block0(v0: i8):
     v2 = ushr v0, v1
     v3 = ishl v2, v1
     return v3
-    ; check: v4 = iconst.i8 224
+    ; check: v4 = iconst.i8 -32
     ; check: v5 = band v0, v4
     ; check: return v5
 }
@@ -19,7 +19,7 @@ block0(v0: i32):
     v2 = ushr v0, v1
     v3 = ishl v2, v1
     return v3
-    ; check: v4 = iconst.i32 0xffff_ffe0
+    ; check: v4 = iconst.i32 -32
     ; check: v5 = band v0, v4
     ; check: return v5
 }
@@ -41,7 +41,7 @@ block0(v0: i8):
     v2 = sshr v0, v1
     v3 = ishl v2, v1
     return v3
-    ; check: v4 = iconst.i8 224
+    ; check: v4 = iconst.i8 -32
     ; check: v5 = band v0, v4
     ; check: return v5
 }
@@ -52,7 +52,7 @@ block0(v0: i32):
     v2 = sshr v0, v1
     v3 = ishl v2, v1
     return v3
-    ; check: v4 = iconst.i32 0xffff_ffe0
+    ; check: v4 = iconst.i32 -32
     ; check: v5 = band v0, v4
     ; check: return v5
 }
@@ -74,9 +74,9 @@ block0(v0: i8):
     v2 = sshr v0, v1
     v3 = ishl v2, v1
     return v3
-    ; check: v4 = iconst.i8 224
-    ; check: v5 = band v0, v4
-    ; check: return v5
+    ; check: v7 = iconst.i8 -32
+    ; check: v8 = band v0, v7
+    ; check: return v8
 }
 
 function %sextend_shift_32_64_unsigned(i32) -> i64 {
@@ -315,3 +315,499 @@ block0(v0: i64):
     ; check: v8 = uextend.i64 v7
     ; check: return v8
 }
+
+function %ishl_amt_type_ireduce(i8, i16) -> i8 {
+block0(v0: i8, v1: i16):
+    v2 = ireduce.i8 v1
+    v3 = ishl.i8 v0, v2
+    return v3
+}
+
+; check: v4 = ishl v0, v1
+; check: return v4
+
+function %ishl_amt_type_sextend(i8, i16) -> i8 {
+block0(v0: i8, v1: i16):
+    v2 = sextend.i32 v1
+    v3 = ishl.i8 v0, v2
+    return v3
+}
+
+; check: v4 = ishl v0, v1
+; check: return v4
+
+function %ishl_amt_type_uextend(i8, i16) -> i8 {
+block0(v0: i8, v1: i16):
+    v2 = uextend.i32 v1
+    v3 = ishl.i8 v0, v2
+    return v3
+}
+
+; check: v4 = ishl v0, v1
+; check: return v4
+
+
+function %ushr_amt_type_ireduce(i8, i16) -> i8 {
+block0(v0: i8, v1: i16):
+    v2 = ireduce.i8 v1
+    v3 = ushr.i8 v0, v2
+    return v3
+}
+
+; check: v4 = ushr v0, v1
+; check: return v4
+
+function %ushr_amt_type_sextend(i8, i16) -> i8 {
+block0(v0: i8, v1: i16):
+    v2 = sextend.i32 v1
+    v3 = ushr.i8 v0, v2
+    return v3
+}
+
+; check: v4 = ushr v0, v1
+; check: return v4
+
+function %ushr_amt_type_uextend(i8, i16) -> i8 {
+block0(v0: i8, v1: i16):
+    v2 = uextend.i32 v1
+    v3 = ushr.i8 v0, v2
+    return v3
+}
+
+; check: v4 = ushr v0, v1
+; check: return v4
+
+
+function %sshr_amt_type_ireduce(i8, i16) -> i8 {
+block0(v0: i8, v1: i16):
+    v2 = ireduce.i8 v1
+    v3 = sshr.i8 v0, v2
+    return v3
+}
+
+; check: v4 = sshr v0, v1
+; check: return v4
+
+function %sshr_amt_type_sextend(i8, i16) -> i8 {
+block0(v0: i8, v1: i16):
+    v2 = sextend.i32 v1
+    v3 = sshr.i8 v0, v2
+    return v3
+}
+
+; check: v4 = sshr v0, v1
+; check: return v4
+
+function %sshr_amt_type_uextend(i8, i16) -> i8 {
+block0(v0: i8, v1: i16):
+    v2 = uextend.i32 v1
+    v3 = sshr.i8 v0, v2
+    return v3
+}
+
+; check: v4 = sshr v0, v1
+; check: return v4
+
+
+function %rotr_amt_type_ireduce(i8, i16) -> i8 {
+block0(v0: i8, v1: i16):
+    v2 = ireduce.i8 v1
+    v3 = rotr.i8 v0, v2
+    return v3
+}
+
+; check: v4 = rotr v0, v1
+; check: return v4
+
+function %rotr_amt_type_sextend(i8, i16) -> i8 {
+block0(v0: i8, v1: i16):
+    v2 = sextend.i32 v1
+    v3 = rotr.i8 v0, v2
+    return v3
+}
+
+; check: v4 = rotr v0, v1
+; check: return v4
+
+function %rotr_amt_type_uextend(i8, i16) -> i8 {
+block0(v0: i8, v1: i16):
+    v2 = uextend.i32 v1
+    v3 = rotr.i8 v0, v2
+    return v3
+}
+
+; check: v4 = rotr v0, v1
+; check: return v4
+
+
+function %rotl_amt_type_ireduce(i8, i16) -> i8 {
+block0(v0: i8, v1: i16):
+    v2 = ireduce.i8 v1
+    v3 = rotl.i8 v0, v2
+    return v3
+}
+
+; check: v4 = rotl v0, v1
+; check: return v4
+
+function %rotl_amt_type_sextend(i8, i16) -> i8 {
+block0(v0: i8, v1: i16):
+    v2 = sextend.i32 v1
+    v3 = rotl.i8 v0, v2
+    return v3
+}
+
+; check: v4 = rotl v0, v1
+; check: return v4
+
+function %rotl_amt_type_uextend(i8, i16) -> i8 {
+block0(v0: i8, v1: i16):
+    v2 = uextend.i32 v1
+    v3 = rotl.i8 v0, v2
+    return v3
+}
+
+; check: v4 = rotl v0, v1
+; check: return v4
+
+
+function %ishl_amt_type_iconcat(i8, i16, i16) -> i8 {
+block0(v0: i8, v1: i16, v2: i16):
+    v3 = iconcat.i16 v1, v2
+    v4 = ishl.i8 v0, v3
+    return v4
+}
+
+; check: v5 = ishl v0, v1
+; check: return v5
+
+
+function %ushr_amt_type_iconcat(i8, i16, i16) -> i8 {
+block0(v0: i8, v1: i16, v2: i16):
+    v3 = iconcat.i16 v1, v2
+    v4 = ushr.i8 v0, v3
+    return v4
+}
+
+; check: v5 = ushr v0, v1
+; check: return v5
+
+
+function %sshr_amt_type_iconcat(i8, i16, i16) -> i8 {
+block0(v0: i8, v1: i16, v2: i16):
+    v3 = iconcat.i16 v1, v2
+    v4 = sshr.i8 v0, v3
+    return v4
+}
+
+; check: v5 = sshr v0, v1
+; check: return v5
+
+
+function %rotr_amt_type_iconcat(i8, i16, i16) -> i8 {
+block0(v0: i8, v1: i16, v2: i16):
+    v3 = iconcat.i16 v1, v2
+    v4 = rotr.i8 v0, v3
+    return v4
+}
+
+; check: v5 = rotr v0, v1
+; check: return v5
+
+
+function %rotl_amt_type_iconcat(i8, i16, i16) -> i8 {
+block0(v0: i8, v1: i16, v2: i16):
+    v3 = iconcat.i16 v1, v2
+    v4 = rotl.i8 v0, v3
+    return v4
+}
+
+; check: v5 = rotl v0, v1
+; check: return v5
+
+function %ishl_prop_overflow(i8) -> i8 {
+block0(v0: i8):
+    v1 = iconst.i8 7
+    v2 = iconst.i8 7
+    v3 = ishl.i8 v0, v1
+    v4 = ishl.i8 v3, v2
+    return v4
+}
+
+; check: v5 = iconst.i8 0
+; check: return v5  ; v5 = 0
+
+function %ishl_prop_type_diff(i8) -> i8 {
+block0(v0: i8):
+    v1 = iconst.i16 7
+    v2 = iconst.i16 7
+    v3 = ishl.i8 v0, v1
+    v4 = ishl.i8 v3, v2
+    return v4
+}
+
+; check: v5 = iconst.i8 0
+; check: return v5  ; v5 = 0
+
+function %ushr_prop(i8) -> i8 {
+block0(v0: i8):
+    v1 = iconst.i8 1
+    v2 = iconst.i8 1
+    v3 = ushr.i8 v0, v1
+    v4 = ushr.i8 v3, v2
+    return v4
+}
+
+; check: v5 = iconst.i8 2
+; check: v6 = ushr v0, v5  ; v5 = 2
+; check: return v6
+
+function %ushr_prop_overflow(i8) -> i8 {
+block0(v0: i8):
+    v1 = iconst.i8 7
+    v2 = iconst.i8 7
+    v3 = ushr.i8 v0, v1
+    v4 = ushr.i8 v3, v2
+    return v4
+}
+
+; check: v5 = iconst.i8 0
+; check: return v5  ; v5 = 0
+
+
+function %sshr_prop(i8) -> i8 {
+block0(v0: i8):
+    v1 = iconst.i8 1
+    v2 = iconst.i8 1
+    v3 = sshr.i8 v0, v1
+    v4 = sshr.i8 v3, v2
+    return v4
+}
+
+; check: v5 = iconst.i8 2
+; check: v6 = sshr v0, v5  ; v5 = 2
+; check: return v6
+
+function %i128_ushr_overflow_becomes_0(i128) -> i128 {
+block0(v0: i128):
+    v1 = iconst.i16 200
+    v2 = ushr v0, v1
+    v3 = ushr v2, v1
+    return v3
+}
+
+; check: v7 = iconst.i64 0
+; nextln: v8 = uextend.i128 v7
+; nextln: return v8
+
+
+function %i128_ishl_overflow_becomes_0(i128) -> i128 {
+block0(v0: i128):
+    v1 = iconst.i16 200
+    v2 = ishl v0, v1
+    v3 = ishl v2, v1
+    return v3
+}
+
+; check: v7 = iconst.i64 0
+; nextln: v8 = uextend.i128 v7
+; nextln: return v8
+
+function %simd_shift_does_not_panic(i8x16) -> i8x16 {
+block0(v0: i8x16):
+    v1 = iconst.i64 0
+    v2 = ushr v0, v1
+    v3 = ushr v2, v1
+    return v3
+}
+
+; check: v1 = iconst.i64 0
+; nextln: v2 = ushr v0, v1  ; v1 = 0
+; check: return v2
+
+function %merges_shift_amount_based_on_lane_type(i8x16) -> i8x16 {
+block0(v0: i8x16):
+    v1 = iconst.i16 30
+    v2 = iconst.i16 3
+
+    v3 = sshr v0, v1
+    v4 = sshr v3, v2
+    v5 = sshr v4, v2
+    return v5
+}
+
+; check: v6 = iconst.i16 6
+; check: v7 = sshr v0, v6
+; check: v9 = sshr v7, v6
+; check: return v9
+
+
+function %rotr_rotr_prop(i8) -> i8 {
+block0(v0: i8):
+    v1 = iconst.i8 1
+    v2 = iconst.i8 1
+    v3 = rotr.i8 v0, v1
+    v4 = rotr.i8 v3, v2
+    return v4
+}
+
+; check: v6 = iconst.i8 2
+; check: v12 = rotr v0, v6  ; v6 = 2
+; check: return v12
+
+function %rotr_rotr_add(i8, i8, i8) -> i8 {
+block0(v0: i8, v1: i8, v2: i8):
+    v3 = rotr.i8 v0, v1
+    v4 = rotr.i8 v3, v2
+    return v4
+}
+
+; check: v5 = iadd v1, v2
+; check: v6 = rotr v0, v5
+; check: return v6
+
+function %rotl_rotl_prop(i8) -> i8 {
+block0(v0: i8):
+    v1 = iconst.i8 1
+    v2 = iconst.i8 1
+    v3 = rotl.i8 v0, v1
+    v4 = rotl.i8 v3, v2
+    return v4
+}
+
+; check: v6 = iconst.i8 2
+; check: v12 = rotl v0, v6  ; v6 = 2
+; check: return v12
+
+function %rotl_rotl_add(i8, i8, i8) -> i8 {
+block0(v0: i8, v1: i8, v2: i8):
+    v3 = rotl.i8 v0, v1
+    v4 = rotl.i8 v3, v2
+    return v4
+}
+
+; check: v5 = iadd v1, v2
+; check: v6 = rotl v0, v5
+; check: return v6
+
+
+function %rotl_rotr_prop(i8) -> i8 {
+block0(v0: i8):
+    v1 = iconst.i8 2
+    v2 = iconst.i8 1
+    v3 = rotr.i8 v0, v1
+    v4 = rotl.i8 v3, v2
+    return v4
+}
+
+; check: v2 = iconst.i8 1
+; check: v15 = rotr v0, v2  ; v2 = 1
+; check: return v15
+
+function %rotl_rotr_add(i8, i8, i8) -> i8 {
+block0(v0: i8, v1: i8, v2: i8):
+    v3 = rotr.i8 v0, v1
+    v4 = rotl.i8 v3, v2
+    return v4
+}
+
+; check: v5 = isub v1, v2
+; check: v6 = rotr v0, v5
+; check: return v6
+
+function %rotl_rotr_prop(i8) -> i8 {
+block0(v0: i8):
+    v1 = iconst.i8 2
+    v2 = iconst.i8 1
+    v3 = rotl.i8 v0, v1
+    v4 = rotr.i8 v3, v2
+    return v4
+}
+
+; check: v2 = iconst.i8 1
+; check: v15 = rotl v0, v2  ; v2 = 1
+; check: return v15
+
+function %rotl_rotr_add(i8, i8, i8) -> i8 {
+block0(v0: i8, v1: i8, v2: i8):
+    v3 = rotl.i8 v0, v1
+    v4 = rotr.i8 v3, v2
+    return v4
+}
+
+; check: v5 = isub v1, v2
+; check: v6 = rotl v0, v5
+; check: return v6
+
+function %rotl_rotr_subsume(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = rotl.i8 v0, v1
+    v3 = rotr.i8 v2, v1
+    return v3
+}
+
+; check: return v0
+
+
+function %rotr_rotl_subsume(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = rotr.i8 v0, v1
+    v3 = rotl.i8 v2, v1
+    return v3
+}
+
+; check: return v0
+
+function %shifts_to_rotl(i64) -> i64 {
+block0(v0: i64):
+    v1 = iconst.i16 3
+    v2 = iconst.i32 61
+    v3 = ishl v0, v1
+    v4 = ushr v0, v2
+    v5 = bor v3, v4
+    return v5
+}
+
+; check: v1 = iconst.i16 3
+; nextln: v6 = rotl v0, v1  ; v1 = 3
+; check: return v6
+
+
+function %shifts_to_rotl_reverse(i64) -> i64 {
+block0(v0: i64):
+    v1 = iconst.i16 32
+    v2 = iconst.i32 32
+    v3 = ishl v0, v1
+    v4 = ushr v0, v2
+    v5 = bor v4, v3
+    return v5
+}
+
+; check: v1 = iconst.i16 32
+; nextln: v6 = rotl v0, v1  ; v1 = 32
+; check: return v6
+
+function %shifts_to_rotr_equivalent(i64) -> i64 {
+block0(v0: i64):
+    v1 = iconst.i16 3
+    v2 = iconst.i32 61
+    v3 = ishl v0, v2
+    v4 = ushr v0, v1
+    v5 = bor v3, v4
+    return v5
+}
+
+; check: v2 = iconst.i32 61
+; nextln: v6 = rotl v0, v2  ; v2 = 61
+; check: return v6
+
+function %ishl_normalize_amount(i64) -> i64 {
+block0(v0: i64):
+    v1 = iconst.i32 99
+    v2 = ishl v0, v1
+    return v2
+}
+
+; check: v3 = iconst.i32 35
+; check: v4 = ishl v0, v3
+; check: return v4
diff --git a/cranelift/filetests/filetests/egraph/spaceship.clif b/cranelift/filetests/filetests/egraph/spaceship.clif
new file mode 100644
index 000000000000..7c1c8e2be099
--- /dev/null
+++ b/cranelift/filetests/filetests/egraph/spaceship.clif
@@ -0,0 +1,528 @@
+test optimize
+set opt_level=speed
+target x86_64
+target aarch64
+target s390x
+target riscv64
+
+function %cmp_s1a(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp slt v0, v1
+    v3 = icmp eq v0, v1
+    v4 = iconst.i8 -1
+    v5 = iconst.i8 0
+    v6 = iconst.i8 +1
+    v7 = select v3, v5, v6
+    v8 = select v2, v4, v7
+    return v8
+    ; check: v13 = icmp sgt v0, v1
+    ; check: v14 = icmp slt v0, v1
+    ; check: v15 = isub v13, v14
+    ; check: return v15
+}
+
+function %cmp_s1b(i32, i32) -> i16 {
+block0(v0: i32, v1: i32):
+    v2 = icmp slt v0, v1
+    v3 = icmp sle v0, v1
+    v4 = iconst.i16 -1
+    v5 = iconst.i16 0
+    v6 = iconst.i16 +1
+    v7 = select v3, v5, v6
+    v8 = select v2, v4, v7
+    return v8
+    ; check: v9 = icmp sgt v0, v1
+    ; check: v14 = icmp slt v0, v1
+    ; check: v15 = isub v9, v14
+    ; check: v16 = sextend.i16 v15
+    ; check: return v16
+}
+
+function %cmp_s2a(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp slt v0, v1
+    v3 = icmp ne v0, v1
+    v4 = iconst.i8 -1
+    v5 = iconst.i8 +1
+    v6 = iconst.i8 0
+    v7 = select v3, v5, v6
+    v8 = select v2, v4, v7
+    return v8
+    ; check: v10 = icmp sgt v0, v1
+    ; check: v11 = icmp slt v0, v1
+    ; check: v12 = isub v10, v11
+    ; check: return v12
+}
+
+function %cmp_s2b(i32, i32) -> i16 {
+block0(v0: i32, v1: i32):
+    v2 = icmp slt v0, v1
+    v3 = icmp sgt v0, v1
+    v4 = iconst.i16 -1
+    v5 = iconst.i16 +1
+    v6 = iconst.i16 0
+    v7 = select v3, v5, v6
+    v8 = select v2, v4, v7
+    return v8
+    ; check: v11 = icmp sgt v0, v1
+    ; check: v12 = icmp slt v0, v1
+    ; check: v13 = isub v11, v12
+    ; check: v14 = sextend.i16 v13
+    ; check: return v14
+}
+
+function %cmp_s3a(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp eq v0, v1
+    v3 = icmp slt v0, v1
+    v4 = iconst.i8 0
+    v5 = iconst.i8 -1
+    v6 = iconst.i8 +1
+    v7 = select v3, v5, v6
+    v8 = select v2, v4, v7
+    return v8
+    ; check: v9 = icmp sgt v0, v1
+    ; check: v10 = icmp slt v0, v1
+    ; check: v11 = isub v9, v10
+    ; check: return v11
+}
+
+function %cmp_s3b(i32, i32) -> i16 {
+block0(v0: i32, v1: i32):
+    v2 = icmp eq v0, v1
+    v3 = icmp sle v0, v1
+    v4 = iconst.i16 0
+    v5 = iconst.i16 -1
+    v6 = iconst.i16 +1
+    v7 = select v3, v5, v6
+    v8 = select v2, v4, v7
+    return v8
+    ; check: v9 = icmp sgt v0, v1
+    ; check: v10 = icmp slt v0, v1
+    ; check: v11 = isub v9, v10
+    ; check: v12 = sextend.i16 v11
+    ; check: return v12
+}
+
+function %cmp_s4a(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp eq v0, v1
+    v3 = icmp sgt v0, v1
+    v4 = iconst.i8 0
+    v5 = iconst.i8 +1
+    v6 = iconst.i8 -1
+    v7 = select v3, v5, v6
+    v8 = select v2, v4, v7
+    return v8
+    ; check: v9 = icmp sgt v0, v1
+    ; check: v10 = icmp slt v0, v1
+    ; check: v11 = isub v9, v10
+    ; check: return v11
+}
+
+function %cmp_s4b(i32, i32) -> i16 {
+block0(v0: i32, v1: i32):
+    v2 = icmp eq v0, v1
+    v3 = icmp sge v0, v1
+    v4 = iconst.i16 0
+    v5 = iconst.i16 +1
+    v6 = iconst.i16 -1
+    v7 = select v3, v5, v6
+    v8 = select v2, v4, v7
+    return v8
+    ; check: v9 = icmp sgt v0, v1
+    ; check: v10 = icmp slt v0, v1
+    ; check: v11 = isub v9, v10
+    ; check: v12 = sextend.i16 v11
+    ; check: return v12
+}
+
+function %cmp_s5a(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp sgt v0, v1
+    v3 = icmp slt v0, v1
+    v4 = iconst.i8 +1
+    v5 = iconst.i8 -1
+    v6 = iconst.i8 0
+    v7 = select v3, v5, v6
+    v8 = select v2, v4, v7
+    return v8
+    ; check: v13 = icmp sgt v0, v1
+    ; check: v14 = icmp slt v0, v1
+    ; check: v15 = isub v13, v14
+    ; check: return v15
+}
+
+function %cmp_s5b(i32, i32) -> i16 {
+block0(v0: i32, v1: i32):
+    v2 = icmp sgt v0, v1
+    v3 = icmp ne v0, v1
+    v4 = iconst.i16 +1
+    v5 = iconst.i16 -1
+    v6 = iconst.i16 0
+    v7 = select v3, v5, v6
+    v8 = select v2, v4, v7
+    return v8
+    ; check: v11 = icmp sgt v0, v1
+    ; check: v12 = icmp slt v0, v1
+    ; check: v13 = isub v11, v12
+    ; check: v14 = sextend.i16 v13
+    ; check: return v14
+}
+
+function %cmp_s6a(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp sgt v0, v1
+    v3 = icmp sge v0, v1
+    v4 = iconst.i8 +1
+    v5 = iconst.i8 0
+    v6 = iconst.i8 -1
+    v7 = select v3, v5, v6
+    v8 = select v2, v4, v7
+    return v8
+    ; check: v16 = icmp sgt v0, v1
+    ; check: v9 = icmp slt v0, v1
+    ; check: v17 = isub v16, v9
+    ; check: return v17
+}
+
+function %cmp_s6b(i32, i32) -> i16 {
+block0(v0: i32, v1: i32):
+    v2 = icmp sgt v0, v1
+    v3 = icmp eq v0, v1
+    v4 = iconst.i16 +1
+    v5 = iconst.i16 0
+    v6 = iconst.i16 -1
+    v7 = select v3, v5, v6
+    v8 = select v2, v4, v7
+    return v8
+    ; check: v14 = icmp sgt v0, v1
+    ; check: v15 = icmp slt v0, v1
+    ; check: v16 = isub v14, v15
+    ; check: v17 = sextend.i16 v16
+    ; check: return v17
+}
+
+;; And again for unsigned...
+
+function %cmp_u1a(i32, i32) -> i16 {
+block0(v0: i32, v1: i32):
+    v2 = icmp ult v0, v1
+    v3 = icmp eq v0, v1
+    v4 = iconst.i16 -1
+    v5 = iconst.i16 0
+    v6 = iconst.i16 +1
+    v7 = select v3, v5, v6
+    v8 = select v2, v4, v7
+    return v8
+    ; check: v14 = icmp ugt v0, v1
+    ; check: v15 = icmp ult v0, v1
+    ; check: v16 = isub v14, v15
+    ; check: v17 = sextend.i16 v16
+    ; check: return v17
+}
+
+function %cmp_u1b(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp ult v0, v1
+    v3 = icmp ule v0, v1
+    v4 = iconst.i8 -1
+    v5 = iconst.i8 0
+    v6 = iconst.i8 +1
+    v7 = select v3, v5, v6
+    v8 = select v2, v4, v7
+    return v8
+    ; check: v9 = icmp ugt v0, v1
+    ; check: v13 = icmp ult v0, v1
+    ; check: v14 = isub v9, v13
+    ; check: return v14
+}
+
+function %cmp_u2a(i32, i32) -> i16 {
+block0(v0: i32, v1: i32):
+    v2 = icmp ult v0, v1
+    v3 = icmp ne v0, v1
+    v4 = iconst.i16 -1
+    v5 = iconst.i16 +1
+    v6 = iconst.i16 0
+    v7 = select v3, v5, v6
+    v8 = select v2, v4, v7
+    return v8
+    ; check: v11 = icmp ugt v0, v1
+    ; check: v12 = icmp ult v0, v1
+    ; check: v13 = isub v11, v12
+    ; check: v14 = sextend.i16 v13
+    ; check: return v14
+}
+
+function %cmp_u2b(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp ult v0, v1
+    v3 = icmp ugt v0, v1
+    v4 = iconst.i8 -1
+    v5 = iconst.i8 +1
+    v6 = iconst.i8 0
+    v7 = select v3, v5, v6
+    v8 = select v2, v4, v7
+    return v8
+    ; check: v10 = icmp ugt v0, v1
+    ; check: v11 = icmp ult v0, v1
+    ; check: v12 = isub v10, v11
+    ; check: return v12
+}
+
+function %cmp_u3a(i32, i32) -> i16 {
+block0(v0: i32, v1: i32):
+    v2 = icmp eq v0, v1
+    v3 = icmp ult v0, v1
+    v4 = iconst.i16 0
+    v5 = iconst.i16 -1
+    v6 = iconst.i16 +1
+    v7 = select v3, v5, v6
+    v8 = select v2, v4, v7
+    return v8
+    ; check: v9 = icmp ugt v0, v1
+    ; check: v10 = icmp ult v0, v1
+    ; check: v11 = isub v9, v10
+    ; check: v12 = sextend.i16 v11
+    ; check: return v12
+}
+
+function %cmp_u3b(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp eq v0, v1
+    v3 = icmp ule v0, v1
+    v4 = iconst.i8 0
+    v5 = iconst.i8 -1
+    v6 = iconst.i8 +1
+    v7 = select v3, v5, v6
+    v8 = select v2, v4, v7
+    return v8
+    ; check: v9 = icmp ugt v0, v1
+    ; check: v10 = icmp ult v0, v1
+    ; check: v11 = isub v9, v10
+    ; check: return v11
+}
+
+function %cmp_u4a(i32, i32) -> i16 {
+block0(v0: i32, v1: i32):
+    v2 = icmp eq v0, v1
+    v3 = icmp ugt v0, v1
+    v4 = iconst.i16 0
+    v5 = iconst.i16 +1
+    v6 = iconst.i16 -1
+    v7 = select v3, v5, v6
+    v8 = select v2, v4, v7
+    return v8
+    ; check: v9 = icmp ugt v0, v1
+    ; check: v10 = icmp ult v0, v1
+    ; check: v11 = isub v9, v10
+    ; check: v12 = sextend.i16 v11
+    ; check: return v12
+}
+
+function %cmp_u4b(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp eq v0, v1
+    v3 = icmp uge v0, v1
+    v4 = iconst.i8 0
+    v5 = iconst.i8 +1
+    v6 = iconst.i8 -1
+    v7 = select v3, v5, v6
+    v8 = select v2, v4, v7
+    return v8
+    ; check: v9 = icmp ugt v0, v1
+    ; check: v10 = icmp ult v0, v1
+    ; check: v11 = isub v9, v10
+    ; check: return v11
+}
+
+function %cmp_u5a(i32, i32) -> i16 {
+block0(v0: i32, v1: i32):
+    v2 = icmp ugt v0, v1
+    v3 = icmp ult v0, v1
+    v4 = iconst.i16 +1
+    v5 = iconst.i16 -1
+    v6 = iconst.i16 0
+    v7 = select v3, v5, v6
+    v8 = select v2, v4, v7
+    return v8
+    ; check: v11 = icmp ugt v0, v1
+    ; check: v12 = icmp ult v0, v1
+    ; check: v13 = isub v11, v12
+    ; check: v14 = sextend.i16 v13
+    ; check: return v14
+}
+
+function %cmp_u5b(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp ugt v0, v1
+    v3 = icmp ne v0, v1
+    v4 = iconst.i8 +1
+    v5 = iconst.i8 -1
+    v6 = iconst.i8 0
+    v7 = select v3, v5, v6
+    v8 = select v2, v4, v7
+    return v8
+    ; check: v13 = icmp ugt v0, v1
+    ; check: v14 = icmp ult v0, v1
+    ; check: v15 = isub v13, v14
+    ; check: return v15
+}
+
+function %cmp_u6a(i32, i32) -> i16 {
+block0(v0: i32, v1: i32):
+    v2 = icmp ugt v0, v1
+    v3 = icmp uge v0, v1
+    v4 = iconst.i16 +1
+    v5 = iconst.i16 0
+    v6 = iconst.i16 -1
+    v7 = select v3, v5, v6
+    v8 = select v2, v4, v7
+    return v8
+    ; check: v14 = icmp ugt v0, v1
+    ; check: v9 = icmp ult v0, v1
+    ; check: v15 = isub v14, v9
+    ; check: v16 = sextend.i16 v15
+    ; check: return v16
+}
+
+function %cmp_u6b(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp ugt v0, v1
+    v3 = icmp eq v0, v1
+    v4 = iconst.i8 +1
+    v5 = iconst.i8 0
+    v6 = iconst.i8 -1
+    v7 = select v3, v5, v6
+    v8 = select v2, v4, v7
+    return v8
+    ; check: v16 = icmp ugt v0, v1
+    ; check: v17 = icmp ult v0, v1
+    ; check: v18 = isub v16, v17
+    ; check: return v18
+}
+
+;; Then a few of the simplifications
+
+function %ult_via_cmp(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = icmp ugt v0, v1
+    v3 = icmp ult v0, v1
+    v4 = isub v2, v3
+    v5 = iconst.i8 0
+    v6 = icmp slt v4, v5
+    return v6
+    ; check: v3 = icmp ult v0, v1
+    ; check: return v3
+}
+
+function %sle_via_cmp(i16, i16) -> i8 {
+block0(v0: i16, v1: i16):
+    v2 = icmp sgt v0, v1
+    v3 = icmp slt v0, v1
+    v4 = isub v2, v3
+    v5 = iconst.i8 0
+    v6 = icmp sle v4, v5
+    return v6
+    ; check: v7 = icmp sle v0, v1
+    ; check: return v7
+}
+
+function %sgt_via_cmp(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp sgt v0, v1
+    v3 = icmp slt v0, v1
+    v4 = isub v2, v3
+    v5 = iconst.i8 0
+    v6 = icmp sgt v4, v5
+    return v6
+    ; check: v7 = icmp sgt v0, v1
+    ; check: return v7
+}
+
+function %uge_via_cmp(i64, i64) -> i8 {
+block0(v0: i64, v1: i64):
+    v2 = icmp ugt v0, v1
+    v3 = icmp ult v0, v1
+    v4 = isub v2, v3
+    v5 = iconst.i8 0
+    v6 = icmp sge v4, v5
+    return v6
+    ; check: v7 = icmp uge v0, v1
+    ; check: return v7
+}
+
+function %eq_via_cmp(i16, i16) -> i8 {
+block0(v0: i16, v1: i16):
+    v2 = icmp ugt v0, v1
+    v3 = icmp ult v0, v1
+    v4 = isub v2, v3
+    v5 = sextend.i32 v4
+    v6 = iconst.i32 0
+    v7 = icmp eq v5, v6
+    return v7
+    ; check: v10 = icmp eq v0, v1
+    ; check: return v10
+}
+
+function %ne_via_cmp(i16, i16) -> i8 {
+block0(v0: i16, v1: i16):
+    v2 = icmp ugt v0, v1
+    v3 = icmp ult v0, v1
+    v4 = isub v2, v3
+    v5 = sextend.i32 v4
+    v6 = iconst.i32 0
+    v7 = icmp ne v5, v6
+    return v7
+    ; check: v10 = icmp ne v0, v1
+    ; check: return v10
+}
+
+function %ult_via_cmp_eq_less(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = icmp ugt v0, v1
+    v3 = icmp ult v0, v1
+    v4 = isub v2, v3
+    v5 = iconst.i8 -1
+    v6 = icmp eq v4, v5
+    return v6
+    ; check: v3 = icmp ult v0, v1
+    ; check: return v3
+}
+
+function %uge_via_cmp_ne_less(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = icmp ugt v0, v1
+    v3 = icmp ult v0, v1
+    v4 = isub v2, v3
+    v5 = iconst.i8 -1
+    v6 = icmp ne v4, v5
+    return v6
+    ; check: v7 = icmp uge v0, v1
+    ; check: return v7
+}
+
+function %sgt_via_cmp_eq_greater(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = icmp sgt v0, v1
+    v3 = icmp slt v0, v1
+    v4 = isub v2, v3
+    v5 = iconst.i8 1
+    v6 = icmp eq v4, v5
+    return v6
+    ; check: v2 = icmp sgt v0, v1
+    ; check: return v2
+}
+
+function %sle_via_cmp_ne_less(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = icmp sgt v0, v1
+    v3 = icmp slt v0, v1
+    v4 = isub v2, v3
+    v5 = iconst.i8 1
+    v6 = icmp ne v4, v5
+    return v6
+    ; check: v7 = icmp sle v0, v1
+    ; check: return v7
+}
diff --git a/cranelift/filetests/filetests/egraph/spectre.clif b/cranelift/filetests/filetests/egraph/spectre.clif
new file mode 100644
index 000000000000..ca3432f61ffc
--- /dev/null
+++ b/cranelift/filetests/filetests/egraph/spectre.clif
@@ -0,0 +1,26 @@
+test optimize
+set opt_level=speed
+target x86_64
+
+function %same_value(i8, i64) -> i64 {
+block0(v0: i8, v1: i64):
+    v2 = select_spectre_guard v0, v1, v1
+    return v2
+}
+; check: return v1
+
+function %const_true(i64, i64) -> i64 {
+block0(v0: i64, v1: i64):
+    v2 = iconst.i8 42
+    v3 = select_spectre_guard v2, v0, v1
+    return v3
+}
+; check: return v0
+
+function %const_false(i64, i64) -> i64 {
+block0(v0: i64, v1: i64):
+    v2 = iconst.i8 0
+    v3 = select_spectre_guard v2, v0, v1
+    return v3
+}
+; check: return v1
diff --git a/cranelift/filetests/filetests/egraph/unordered.clif b/cranelift/filetests/filetests/egraph/unordered.clif
new file mode 100644
index 000000000000..5afaa13ab292
--- /dev/null
+++ b/cranelift/filetests/filetests/egraph/unordered.clif
@@ -0,0 +1,24 @@
+test optimize precise-output
+set opt_level=speed
+target x86_64
+
+; https://github.com/bytecodealliance/wasmtime/issues/6126
+;
+; In this example, iconst defines v2, and later an identical iconst defines v1. 
+; In between, v2 is used in an iadd instruction that's added to the GVN map.
+; Finally, v1 is used in another iadd which should unify with the first one.
+function %unordered(i32) -> i32, i32 {
+block0(v0: i32):
+    v2 = iconst.i32 42
+    v3 = iadd v0, v2
+    v1 = iconst.i32 42
+    v4 = iadd v0, v1
+    return v3, v4
+}
+
+; function %unordered(i32) -> i32, i32 fast {
+; block0(v0: i32):
+;     v2 = iconst.i32 42
+;     v3 = iadd v0, v2  ; v2 = 42
+;     return v3, v3
+; }
diff --git a/cranelift/filetests/filetests/egraph/vector.clif b/cranelift/filetests/filetests/egraph/vector.clif
index 4ecbaa83b318..a9cb2cbe7746 100644
--- a/cranelift/filetests/filetests/egraph/vector.clif
+++ b/cranelift/filetests/filetests/egraph/vector.clif
@@ -18,10 +18,9 @@ block0(v0: i32):
   v2 = splat.i64x2 v1
   v3 = fcvt_from_uint.f64x2 v2
   return v3
-  ; check: v1 = uextend.i64 v0
-  ; check: v4 = fcvt_from_uint.f64 v1
-  ; check: v5 = splat.f64x2 v4
-  ; check: return v5
+  ; check: v5 = fcvt_from_uint.f64 v0
+  ; check: v7 = splat.f64x2 v5
+  ; check: return v7
 }
 
 function %f3(i32) -> f64x2 {
diff --git a/cranelift/filetests/filetests/isa/aarch64/amodes.clif b/cranelift/filetests/filetests/isa/aarch64/amodes.clif
index 176f70da7bd3..e4a672165420 100644
--- a/cranelift/filetests/filetests/isa/aarch64/amodes.clif
+++ b/cranelift/filetests/filetests/isa/aarch64/amodes.clif
@@ -17,7 +17,7 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldr w0, [x0, w1, sxtw]
+;   ldr w0, [x0, w1, sxtw] ; trap: heap_oob
 ;   ret
 
 function %f6(i64, i32) -> i32 {
@@ -35,7 +35,7 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldr w0, [x0, w1, sxtw]
+;   ldr w0, [x0, w1, sxtw] ; trap: heap_oob
 ;   ret
 
 function %f7(i32, i32) -> i32 {
@@ -56,7 +56,7 @@ block0(v0: i32, v1: i32):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   mov w4, w1
-;   ldr w0, [x4, w0, uxtw]
+;   ldr w0, [x4, w0, uxtw] ; trap: heap_oob
 ;   ret
 
 function %f8(i64, i32) -> i32 {
@@ -85,7 +85,7 @@ block0(v0: i64, v1: i32):
 ;   add x7, x7, #0x20
 ;   add x7, x7, x0
 ;   add x6, x7, #4
-;   ldr w0, [x6, x7]
+;   ldr w0, [x6, x7] ; trap: heap_oob
 ;   ret
 
 function %f9(i64, i64, i64) -> i32 {
@@ -109,7 +109,7 @@ block0(v0: i64, v1: i64, v2: i64):
 ; block0: ; offset 0x0
 ;   add x6, x0, x1
 ;   add x5, x6, #0x30
-;   ldr w0, [x5, x2]
+;   ldr w0, [x5, x2] ; trap: heap_oob
 ;   ret
 
 function %f10(i64, i64, i64) -> i32 {
@@ -135,7 +135,7 @@ block0(v0: i64, v1: i64, v2: i64):
 ;   add x7, x0, x1
 ;   mov x5, #0x1004
 ;   add x7, x7, x5
-;   ldr w0, [x7, x2]
+;   ldr w0, [x7, x2] ; trap: heap_oob
 ;   ret
 
 function %f10() -> i32 {
@@ -154,7 +154,7 @@ block0:
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   mov x1, #0x4d2
-;   ldr w0, [x1]
+;   ldr w0, [x1] ; trap: heap_oob
 ;   ret
 
 function %f11(i64) -> i32 {
@@ -174,7 +174,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   mov x2, #0x800000
-;   ldr w0, [x0, x2]
+;   ldr w0, [x0, x2] ; trap: heap_oob
 ;   ret
 
 function %add_imm12_max_shifted(i64) -> i32 {
@@ -194,7 +194,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   orr x2, xzr, #0xfff000
-;   ldr w0, [x0, x2]
+;   ldr w0, [x0, x2] ; trap: heap_oob
 ;   ret
 
 function %f12(i64) -> i32 {
@@ -212,7 +212,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldur w0, [x0, #-4]
+;   ldur w0, [x0, #-4] ; trap: heap_oob
 ;   ret
 
 function %f13(i64) -> i32 {
@@ -234,7 +234,7 @@ block0(v0: i64):
 ; block0: ; offset 0x0
 ;   mov w3, #0xca00
 ;   movk w3, #0x3b9a, lsl #16
-;   ldr w0, [x0, x3]
+;   ldr w0, [x0, x3] ; trap: heap_oob
 ;   ret
 
 function %f14(i32) -> i32 {
@@ -253,7 +253,7 @@ block0(v0: i32):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   sxtw x3, w0
-;   ldr w0, [x3]
+;   ldr w0, [x3] ; trap: heap_oob
 ;   ret
 
 function %f15(i32, i32) -> i32 {
@@ -274,7 +274,7 @@ block0(v0: i32, v1: i32):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   sxtw x4, w1
-;   ldr w0, [x4, w0, sxtw]
+;   ldr w0, [x4, w0, sxtw] ; trap: heap_oob
 ;   ret
 
 function %f18(i64, i64, i64) -> i32 {
@@ -287,16 +287,16 @@ block0(v0: i64, v1: i64, v2: i64):
 
 ; VCode:
 ; block0:
-;   movn w6, #4097
-;   mov w6, w6
-;   ldrsh x0, [x6]
+;   movn w2, #4097
+;   mov w2, w2
+;   ldrsh x0, [x2]
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mov w6, #-0x1002
-;   mov w6, w6
-;   ldrsh x0, [x6]
+;   mov w2, #-0x1002
+;   mov w2, w2
+;   ldrsh x0, [x2] ; trap: heap_oob
 ;   ret
 
 function %f19(i64, i64, i64) -> i32 {
@@ -309,16 +309,16 @@ block0(v0: i64, v1: i64, v2: i64):
 
 ; VCode:
 ; block0:
-;   movz w6, #4098
-;   mov w6, w6
-;   ldrsh x0, [x6]
+;   movz w2, #4098
+;   mov w2, w2
+;   ldrsh x0, [x2]
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mov w6, #0x1002
-;   mov w6, w6
-;   ldrsh x0, [x6]
+;   mov w2, #0x1002
+;   mov w2, w2
+;   ldrsh x0, [x2] ; trap: heap_oob
 ;   ret
 
 function %f20(i64, i64, i64) -> i32 {
@@ -331,16 +331,16 @@ block0(v0: i64, v1: i64, v2: i64):
 
 ; VCode:
 ; block0:
-;   movn w6, #4097
-;   sxtw x6, w6
-;   ldrsh x0, [x6]
+;   movn w2, #4097
+;   sxtw x2, w2
+;   ldrsh x0, [x2]
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mov w6, #-0x1002
-;   sxtw x6, w6
-;   ldrsh x0, [x6]
+;   mov w2, #-0x1002
+;   sxtw x2, w2
+;   ldrsh x0, [x2] ; trap: heap_oob
 ;   ret
 
 function %f21(i64, i64, i64) -> i32 {
@@ -353,16 +353,16 @@ block0(v0: i64, v1: i64, v2: i64):
 
 ; VCode:
 ; block0:
-;   movz w6, #4098
-;   sxtw x6, w6
-;   ldrsh x0, [x6]
+;   movz w2, #4098
+;   sxtw x2, w2
+;   ldrsh x0, [x2]
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mov w6, #0x1002
-;   sxtw x6, w6
-;   ldrsh x0, [x6]
+;   mov w2, #0x1002
+;   sxtw x2, w2
+;   ldrsh x0, [x2] ; trap: heap_oob
 ;   ret
 
 function %i128(i64) -> i128 {
@@ -382,8 +382,8 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   mov x5, x0
-;   ldp x0, x1, [x5]
-;   stp x0, x1, [x5]
+;   ldp x0, x1, [x5] ; trap: heap_oob
+;   stp x0, x1, [x5] ; trap: heap_oob
 ;   ret
 
 function %i128_imm_offset(i64) -> i128 {
@@ -403,8 +403,8 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   mov x5, x0
-;   ldp x0, x1, [x5, #0x10]
-;   stp x0, x1, [x5, #0x10]
+;   ldp x0, x1, [x5, #0x10] ; trap: heap_oob
+;   stp x0, x1, [x5, #0x10] ; trap: heap_oob
 ;   ret
 
 function %i128_imm_offset_large(i64) -> i128 {
@@ -424,8 +424,8 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   mov x5, x0
-;   ldp x0, x1, [x5, #0x1f8]
-;   stp x0, x1, [x5, #0x1f8]
+;   ldp x0, x1, [x5, #0x1f8] ; trap: heap_oob
+;   stp x0, x1, [x5, #0x1f8] ; trap: heap_oob
 ;   ret
 
 function %i128_imm_offset_negative_large(i64) -> i128 {
@@ -445,8 +445,8 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   mov x5, x0
-;   ldp x0, x1, [x5, #-0x200]
-;   stp x0, x1, [x5, #-0x200]
+;   ldp x0, x1, [x5, #-0x200] ; trap: heap_oob
+;   stp x0, x1, [x5, #-0x200] ; trap: heap_oob
 ;   ret
 
 function %i128_add_offset(i64) -> i128 {
@@ -467,8 +467,8 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   add x4, x0, #0x20
-;   ldp x0, x1, [x4]
-;   stp x0, x1, [x4]
+;   ldp x0, x1, [x4] ; trap: heap_oob
+;   stp x0, x1, [x4] ; trap: heap_oob
 ;   ret
 
 function %i128_32bit_sextend_simple(i32) -> i128 {
@@ -489,8 +489,8 @@ block0(v0: i32):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   sxtw x4, w0
-;   ldp x0, x1, [x4]
-;   stp x0, x1, [x4]
+;   ldp x0, x1, [x4] ; trap: heap_oob
+;   stp x0, x1, [x4] ; trap: heap_oob
 ;   ret
 
 function %i128_32bit_sextend(i64, i32) -> i128 {
@@ -515,8 +515,8 @@ block0(v0: i64, v1: i32):
 ; block0: ; offset 0x0
 ;   add x6, x0, w1, sxtw
 ;   add x6, x6, #0x18
-;   ldp x0, x1, [x6]
-;   stp x0, x1, [x6]
+;   ldp x0, x1, [x6] ; trap: heap_oob
+;   stp x0, x1, [x6] ; trap: heap_oob
 ;   ret
 
 function %load_scaled16(i64, i64) -> i8 {
@@ -534,7 +534,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldrb w0, [x0, x1, lsl #0]
+;   ldrb w0, [x0, x1, lsl #0] ; trap: heap_oob
 ;   ret
 
 function %load_scaled16(i64, i64) -> i16 {
@@ -552,7 +552,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldrh w0, [x0, x1, lsl #1]
+;   ldrh w0, [x0, x1, lsl #1] ; trap: heap_oob
 ;   ret
 
 function %load_scaled32(i64, i64) -> i32 {
@@ -570,7 +570,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldr w0, [x0, x1, lsl #2]
+;   ldr w0, [x0, x1, lsl #2] ; trap: heap_oob
 ;   ret
 
 function %load_scaled64(i64, i64) -> i64 {
@@ -588,7 +588,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldr x0, [x0, x1, lsl #3]
+;   ldr x0, [x0, x1, lsl #3] ; trap: heap_oob
 ;   ret
 
 function %load_not_scaled64(i64, i64) -> i64 {
@@ -608,7 +608,7 @@ block0(v0: i64, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   lsl x4, x1, #2
-;   ldr x0, [x0, x4]
+;   ldr x0, [x0, x4] ; trap: heap_oob
 ;   ret
 
 function %load_uextend_scaled16(i64, i32) -> i8 {
@@ -627,7 +627,7 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldrb w0, [x0, w1, uxtw #0]
+;   ldrb w0, [x0, w1, uxtw #0] ; trap: heap_oob
 ;   ret
 
 function %load_uextend_scaled16(i64, i32) -> i16 {
@@ -646,7 +646,7 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldrh w0, [x0, w1, uxtw #1]
+;   ldrh w0, [x0, w1, uxtw #1] ; trap: heap_oob
 ;   ret
 
 function %load_uextend_scaled32(i64, i32) -> i32 {
@@ -665,10 +665,9 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldr w0, [x0, w1, uxtw #2]
+;   ldr w0, [x0, w1, uxtw #2] ; trap: heap_oob
 ;   ret
 
-
 function %load_uextend_scaled64(i64, i32) -> i64 {
 block0(v0: i64, v1: i32):
   v2 = uextend.i64 v1
@@ -685,7 +684,7 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldr x0, [x0, w1, uxtw #3]
+;   ldr x0, [x0, w1, uxtw #3] ; trap: heap_oob
 ;   ret
 
 function %load_not_extend_scaled64(i64, i32) -> i64 {
@@ -706,7 +705,7 @@ block0(v0: i64, v1: i32):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   lsl w4, w1, #3
-;   ldr x0, [x0, w4, uxtw]
+;   ldr x0, [x0, w4, uxtw] ; trap: heap_oob
 ;   ret
 
 function %load_sextend_scaled8(i64, i32) -> i8 {
@@ -725,7 +724,7 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldrb w0, [x0, w1, sxtw #0]
+;   ldrb w0, [x0, w1, sxtw #0] ; trap: heap_oob
 ;   ret
 
 function %load_sextend_scaled16(i64, i32) -> i16 {
@@ -744,7 +743,7 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldrh w0, [x0, w1, sxtw #1]
+;   ldrh w0, [x0, w1, sxtw #1] ; trap: heap_oob
 ;   ret
 
 function %load_sextend_scaled32(i64, i32) -> i32 {
@@ -763,7 +762,7 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldr w0, [x0, w1, sxtw #2]
+;   ldr w0, [x0, w1, sxtw #2] ; trap: heap_oob
 ;   ret
 
 function %load_sextend_scaled64(i64, i32) -> i64 {
@@ -782,6 +781,6 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldr x0, [x0, w1, sxtw #3]
+;   ldr x0, [x0, w1, sxtw #3] ; trap: heap_oob
 ;   ret
 
diff --git a/cranelift/filetests/filetests/isa/aarch64/arithmetic.clif b/cranelift/filetests/filetests/isa/aarch64/arithmetic.clif
index c8abe7cb4681..569b9daa3c88 100644
--- a/cranelift/filetests/filetests/isa/aarch64/arithmetic.clif
+++ b/cranelift/filetests/filetests/isa/aarch64/arithmetic.clif
@@ -542,14 +542,14 @@ block0(v0: i64):
 
 ; VCode:
 ; block0:
-;   movz x3, #1
-;   sub x0, xzr, x3
+;   movz x1, #1
+;   sub x0, xzr, x1
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mov x3, #1
-;   neg x0, x3
+;   mov x1, #1
+;   neg x0, x1
 ;   ret
 
 function %f30(i8x16) -> i8x16 {
diff --git a/cranelift/filetests/filetests/isa/aarch64/atomic-cas.clif b/cranelift/filetests/filetests/isa/aarch64/atomic-cas.clif
index 883fdc9c869b..dd0e2994563a 100644
--- a/cranelift/filetests/filetests/isa/aarch64/atomic-cas.clif
+++ b/cranelift/filetests/filetests/isa/aarch64/atomic-cas.clif
@@ -40,10 +40,10 @@ block0(v0: i64, v1: i32, v2: i32):
 ;   mov x25, x0
 ;   mov x26, x1
 ;   mov x28, x2
-;   ldaxr w27, [x25]
+;   ldaxr w27, [x25] ; trap: heap_oob
 ;   cmp x27, x26
 ;   b.ne #0x34
-;   stlxr w24, w28, [x25]
+;   stlxr w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x20
 ;   cmp w27, w26
 ;   cset x0, eq
diff --git a/cranelift/filetests/filetests/isa/aarch64/atomic-rmw-lse.clif b/cranelift/filetests/filetests/isa/aarch64/atomic-rmw-lse.clif
index 2f0e7afdd85c..ca5776fccb18 100644
--- a/cranelift/filetests/filetests/isa/aarch64/atomic-rmw-lse.clif
+++ b/cranelift/filetests/filetests/isa/aarch64/atomic-rmw-lse.clif
@@ -14,7 +14,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldaddal x1, x3, [x0]
+;   ldaddal x1, x3, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_add_i32(i64, i32) {
@@ -30,7 +30,7 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldaddal w1, w3, [x0]
+;   ldaddal w1, w3, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_add_i16(i64, i16) {
@@ -46,7 +46,7 @@ block0(v0: i64, v1: i16):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldaddalh w1, w3, [x0]
+;   ldaddalh w1, w3, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_add_i8(i64, i8) {
@@ -62,7 +62,7 @@ block0(v0: i64, v1: i8):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldaddalb w1, w3, [x0]
+;   ldaddalb w1, w3, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_sub_i64(i64, i64) {
@@ -80,7 +80,7 @@ block0(v0: i64, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   neg x3, x1
-;   ldaddal x3, x5, [x0]
+;   ldaddal x3, x5, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_sub_i32(i64, i32) {
@@ -98,7 +98,7 @@ block0(v0: i64, v1: i32):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   neg w3, w1
-;   ldaddal w3, w5, [x0]
+;   ldaddal w3, w5, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_sub_i16(i64, i16) {
@@ -116,7 +116,7 @@ block0(v0: i64, v1: i16):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   neg w3, w1
-;   ldaddalh w3, w5, [x0]
+;   ldaddalh w3, w5, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_sub_i8(i64, i8) {
@@ -134,7 +134,7 @@ block0(v0: i64, v1: i8):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   neg w3, w1
-;   ldaddalb w3, w5, [x0]
+;   ldaddalb w3, w5, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_and_i64(i64, i64) {
@@ -152,7 +152,7 @@ block0(v0: i64, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   eon x3, x1, xzr
-;   ldclral x3, x5, [x0]
+;   ldclral x3, x5, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_and_i32(i64, i32) {
@@ -170,7 +170,7 @@ block0(v0: i64, v1: i32):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   eon w3, w1, wzr
-;   ldclral w3, w5, [x0]
+;   ldclral w3, w5, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_and_i16(i64, i16) {
@@ -188,7 +188,7 @@ block0(v0: i64, v1: i16):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   eon w3, w1, wzr
-;   ldclralh w3, w5, [x0]
+;   ldclralh w3, w5, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_and_i8(i64, i8) {
@@ -206,7 +206,7 @@ block0(v0: i64, v1: i8):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   eon w3, w1, wzr
-;   ldclralb w3, w5, [x0]
+;   ldclralb w3, w5, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_nand_i64(i64, i64) {
@@ -241,10 +241,10 @@ block0(v0: i64, v1: i64):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxr x27, [x25]
+;   ldaxr x27, [x25] ; trap: heap_oob
 ;   and x28, x27, x26
 ;   mvn x28, x28
-;   stlxr w24, x28, [x25]
+;   stlxr w24, x28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -284,10 +284,10 @@ block0(v0: i64, v1: i32):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxr w27, [x25]
+;   ldaxr w27, [x25] ; trap: heap_oob
 ;   and w28, w27, w26
 ;   mvn w28, w28
-;   stlxr w24, w28, [x25]
+;   stlxr w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -327,10 +327,10 @@ block0(v0: i64, v1: i16):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxrh w27, [x25]
+;   ldaxrh w27, [x25] ; trap: heap_oob
 ;   and w28, w27, w26
 ;   mvn w28, w28
-;   stlxrh w24, w28, [x25]
+;   stlxrh w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -370,10 +370,10 @@ block0(v0: i64, v1: i8):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxrb w27, [x25]
+;   ldaxrb w27, [x25] ; trap: heap_oob
 ;   and w28, w27, w26
 ;   mvn w28, w28
-;   stlxrb w24, w28, [x25]
+;   stlxrb w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -394,7 +394,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldsetal x1, x3, [x0]
+;   ldsetal x1, x3, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_or_i32(i64, i32) {
@@ -410,7 +410,7 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldsetal w1, w3, [x0]
+;   ldsetal w1, w3, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_or_i16(i64, i16) {
@@ -426,7 +426,7 @@ block0(v0: i64, v1: i16):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldsetalh w1, w3, [x0]
+;   ldsetalh w1, w3, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_or_i8(i64, i8) {
@@ -442,7 +442,7 @@ block0(v0: i64, v1: i8):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldsetalb w1, w3, [x0]
+;   ldsetalb w1, w3, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_xor_i64(i64, i64) {
@@ -458,7 +458,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldeoral x1, x3, [x0]
+;   ldeoral x1, x3, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_xor_i32(i64, i32) {
@@ -474,7 +474,7 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldeoral w1, w3, [x0]
+;   ldeoral w1, w3, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_xor_i16(i64, i16) {
@@ -490,7 +490,7 @@ block0(v0: i64, v1: i16):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldeoralh w1, w3, [x0]
+;   ldeoralh w1, w3, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_xor_i8(i64, i8) {
@@ -506,7 +506,7 @@ block0(v0: i64, v1: i8):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldeoralb w1, w3, [x0]
+;   ldeoralb w1, w3, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_smax_i64(i64, i64) {
@@ -522,7 +522,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldsmaxal x1, x3, [x0]
+;   ldsmaxal x1, x3, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_smax_i32(i64, i32) {
@@ -538,7 +538,7 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldsmaxal w1, w3, [x0]
+;   ldsmaxal w1, w3, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_smax_i16(i64, i16) {
@@ -554,7 +554,7 @@ block0(v0: i64, v1: i16):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldsmaxalh w1, w3, [x0]
+;   ldsmaxalh w1, w3, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_smax_i8(i64, i8) {
@@ -570,7 +570,7 @@ block0(v0: i64, v1: i8):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldsmaxalb w1, w3, [x0]
+;   ldsmaxalb w1, w3, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_umax_i64(i64, i64) {
@@ -586,7 +586,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldumaxal x1, x3, [x0]
+;   ldumaxal x1, x3, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_umax_i32(i64, i32) {
@@ -602,7 +602,7 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldumaxal w1, w3, [x0]
+;   ldumaxal w1, w3, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_umax_i16(i64, i16) {
@@ -618,7 +618,7 @@ block0(v0: i64, v1: i16):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldumaxalh w1, w3, [x0]
+;   ldumaxalh w1, w3, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_umax_i8(i64, i8) {
@@ -634,7 +634,7 @@ block0(v0: i64, v1: i8):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldumaxalb w1, w3, [x0]
+;   ldumaxalb w1, w3, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_smin_i64(i64, i64) {
@@ -650,7 +650,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldsminal x1, x3, [x0]
+;   ldsminal x1, x3, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_smin_i32(i64, i32) {
@@ -666,7 +666,7 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldsminal w1, w3, [x0]
+;   ldsminal w1, w3, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_smin_i16(i64, i16) {
@@ -682,7 +682,7 @@ block0(v0: i64, v1: i16):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldsminalh w1, w3, [x0]
+;   ldsminalh w1, w3, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_smin_i8(i64, i8) {
@@ -698,7 +698,7 @@ block0(v0: i64, v1: i8):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldsminalb w1, w3, [x0]
+;   ldsminalb w1, w3, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_umin_i64(i64, i64) {
@@ -714,7 +714,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lduminal x1, x3, [x0]
+;   lduminal x1, x3, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_umin_i32(i64, i32) {
@@ -730,7 +730,7 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lduminal w1, w3, [x0]
+;   lduminal w1, w3, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_umin_i16(i64, i16) {
@@ -746,7 +746,7 @@ block0(v0: i64, v1: i16):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lduminalh w1, w3, [x0]
+;   lduminalh w1, w3, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_umin_i8(i64, i8) {
@@ -762,6 +762,6 @@ block0(v0: i64, v1: i8):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lduminalb w1, w3, [x0]
+;   lduminalb w1, w3, [x0] ; trap: heap_oob
 ;   ret
 
diff --git a/cranelift/filetests/filetests/isa/aarch64/atomic-rmw.clif b/cranelift/filetests/filetests/isa/aarch64/atomic-rmw.clif
index 1c0d03afb376..d1c620f3cbfd 100644
--- a/cranelift/filetests/filetests/isa/aarch64/atomic-rmw.clif
+++ b/cranelift/filetests/filetests/isa/aarch64/atomic-rmw.clif
@@ -33,9 +33,9 @@ block0(v0: i64, v1: i64):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxr x27, [x25]
+;   ldaxr x27, [x25] ; trap: heap_oob
 ;   add x28, x27, x26
-;   stlxr w24, x28, [x25]
+;   stlxr w24, x28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -75,9 +75,9 @@ block0(v0: i64, v1: i32):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxr w27, [x25]
+;   ldaxr w27, [x25] ; trap: heap_oob
 ;   add w28, w27, w26
-;   stlxr w24, w28, [x25]
+;   stlxr w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -117,9 +117,9 @@ block0(v0: i64, v1: i16):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxrh w27, [x25]
+;   ldaxrh w27, [x25] ; trap: heap_oob
 ;   add w28, w27, w26
-;   stlxrh w24, w28, [x25]
+;   stlxrh w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -159,9 +159,9 @@ block0(v0: i64, v1: i8):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxrb w27, [x25]
+;   ldaxrb w27, [x25] ; trap: heap_oob
 ;   add w28, w27, w26
-;   stlxrb w24, w28, [x25]
+;   stlxrb w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -201,9 +201,9 @@ block0(v0: i64, v1: i64):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxr x27, [x25]
+;   ldaxr x27, [x25] ; trap: heap_oob
 ;   sub x28, x27, x26
-;   stlxr w24, x28, [x25]
+;   stlxr w24, x28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -243,9 +243,9 @@ block0(v0: i64, v1: i32):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxr w27, [x25]
+;   ldaxr w27, [x25] ; trap: heap_oob
 ;   sub w28, w27, w26
-;   stlxr w24, w28, [x25]
+;   stlxr w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -285,9 +285,9 @@ block0(v0: i64, v1: i16):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxrh w27, [x25]
+;   ldaxrh w27, [x25] ; trap: heap_oob
 ;   sub w28, w27, w26
-;   stlxrh w24, w28, [x25]
+;   stlxrh w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -327,9 +327,9 @@ block0(v0: i64, v1: i8):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxrb w27, [x25]
+;   ldaxrb w27, [x25] ; trap: heap_oob
 ;   sub w28, w27, w26
-;   stlxrb w24, w28, [x25]
+;   stlxrb w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -369,9 +369,9 @@ block0(v0: i64, v1: i64):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxr x27, [x25]
+;   ldaxr x27, [x25] ; trap: heap_oob
 ;   and x28, x27, x26
-;   stlxr w24, x28, [x25]
+;   stlxr w24, x28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -411,9 +411,9 @@ block0(v0: i64, v1: i32):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxr w27, [x25]
+;   ldaxr w27, [x25] ; trap: heap_oob
 ;   and w28, w27, w26
-;   stlxr w24, w28, [x25]
+;   stlxr w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -453,9 +453,9 @@ block0(v0: i64, v1: i16):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxrh w27, [x25]
+;   ldaxrh w27, [x25] ; trap: heap_oob
 ;   and w28, w27, w26
-;   stlxrh w24, w28, [x25]
+;   stlxrh w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -495,9 +495,9 @@ block0(v0: i64, v1: i8):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxrb w27, [x25]
+;   ldaxrb w27, [x25] ; trap: heap_oob
 ;   and w28, w27, w26
-;   stlxrb w24, w28, [x25]
+;   stlxrb w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -537,10 +537,10 @@ block0(v0: i64, v1: i64):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxr x27, [x25]
+;   ldaxr x27, [x25] ; trap: heap_oob
 ;   and x28, x27, x26
 ;   mvn x28, x28
-;   stlxr w24, x28, [x25]
+;   stlxr w24, x28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -580,10 +580,10 @@ block0(v0: i64, v1: i32):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxr w27, [x25]
+;   ldaxr w27, [x25] ; trap: heap_oob
 ;   and w28, w27, w26
 ;   mvn w28, w28
-;   stlxr w24, w28, [x25]
+;   stlxr w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -623,10 +623,10 @@ block0(v0: i64, v1: i16):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxrh w27, [x25]
+;   ldaxrh w27, [x25] ; trap: heap_oob
 ;   and w28, w27, w26
 ;   mvn w28, w28
-;   stlxrh w24, w28, [x25]
+;   stlxrh w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -666,10 +666,10 @@ block0(v0: i64, v1: i8):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxrb w27, [x25]
+;   ldaxrb w27, [x25] ; trap: heap_oob
 ;   and w28, w27, w26
 ;   mvn w28, w28
-;   stlxrb w24, w28, [x25]
+;   stlxrb w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -709,9 +709,9 @@ block0(v0: i64, v1: i64):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxr x27, [x25]
+;   ldaxr x27, [x25] ; trap: heap_oob
 ;   orr x28, x27, x26
-;   stlxr w24, x28, [x25]
+;   stlxr w24, x28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -751,9 +751,9 @@ block0(v0: i64, v1: i32):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxr w27, [x25]
+;   ldaxr w27, [x25] ; trap: heap_oob
 ;   orr w28, w27, w26
-;   stlxr w24, w28, [x25]
+;   stlxr w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -793,9 +793,9 @@ block0(v0: i64, v1: i16):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxrh w27, [x25]
+;   ldaxrh w27, [x25] ; trap: heap_oob
 ;   orr w28, w27, w26
-;   stlxrh w24, w28, [x25]
+;   stlxrh w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -835,9 +835,9 @@ block0(v0: i64, v1: i8):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxrb w27, [x25]
+;   ldaxrb w27, [x25] ; trap: heap_oob
 ;   orr w28, w27, w26
-;   stlxrb w24, w28, [x25]
+;   stlxrb w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -877,9 +877,9 @@ block0(v0: i64, v1: i64):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxr x27, [x25]
+;   ldaxr x27, [x25] ; trap: heap_oob
 ;   eor x28, x27, x26
-;   stlxr w24, x28, [x25]
+;   stlxr w24, x28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -919,9 +919,9 @@ block0(v0: i64, v1: i32):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxr w27, [x25]
+;   ldaxr w27, [x25] ; trap: heap_oob
 ;   eor w28, w27, w26
-;   stlxr w24, w28, [x25]
+;   stlxr w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -961,9 +961,9 @@ block0(v0: i64, v1: i16):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxrh w27, [x25]
+;   ldaxrh w27, [x25] ; trap: heap_oob
 ;   eor w28, w27, w26
-;   stlxrh w24, w28, [x25]
+;   stlxrh w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -1003,9 +1003,9 @@ block0(v0: i64, v1: i8):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxrb w27, [x25]
+;   ldaxrb w27, [x25] ; trap: heap_oob
 ;   eor w28, w27, w26
-;   stlxrb w24, w28, [x25]
+;   stlxrb w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -1045,10 +1045,10 @@ block0(v0: i64, v1: i64):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxr x27, [x25]
+;   ldaxr x27, [x25] ; trap: heap_oob
 ;   cmp x27, x26
 ;   csel x28, x27, x26, gt
-;   stlxr w24, x28, [x25]
+;   stlxr w24, x28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -1088,10 +1088,10 @@ block0(v0: i64, v1: i32):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxr w27, [x25]
+;   ldaxr w27, [x25] ; trap: heap_oob
 ;   cmp w27, w26
 ;   csel x28, x27, x26, gt
-;   stlxr w24, w28, [x25]
+;   stlxr w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -1131,11 +1131,11 @@ block0(v0: i64, v1: i16):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxrh w27, [x25]
+;   ldaxrh w27, [x25] ; trap: heap_oob
 ;   sxth w27, w27
 ;   cmp w27, w26, sxth
 ;   csel x28, x27, x26, gt
-;   stlxrh w24, w28, [x25]
+;   stlxrh w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -1175,11 +1175,11 @@ block0(v0: i64, v1: i8):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxrb w27, [x25]
+;   ldaxrb w27, [x25] ; trap: heap_oob
 ;   sxtb w27, w27
 ;   cmp w27, w26, sxtb
 ;   csel x28, x27, x26, gt
-;   stlxrb w24, w28, [x25]
+;   stlxrb w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -1219,10 +1219,10 @@ block0(v0: i64, v1: i64):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxr x27, [x25]
+;   ldaxr x27, [x25] ; trap: heap_oob
 ;   cmp x27, x26
 ;   csel x28, x27, x26, hi
-;   stlxr w24, x28, [x25]
+;   stlxr w24, x28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -1262,10 +1262,10 @@ block0(v0: i64, v1: i32):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxr w27, [x25]
+;   ldaxr w27, [x25] ; trap: heap_oob
 ;   cmp w27, w26
 ;   csel x28, x27, x26, hi
-;   stlxr w24, w28, [x25]
+;   stlxr w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -1305,10 +1305,10 @@ block0(v0: i64, v1: i16):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxrh w27, [x25]
+;   ldaxrh w27, [x25] ; trap: heap_oob
 ;   cmp w27, w26
 ;   csel x28, x27, x26, hi
-;   stlxrh w24, w28, [x25]
+;   stlxrh w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -1348,10 +1348,10 @@ block0(v0: i64, v1: i8):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxrb w27, [x25]
+;   ldaxrb w27, [x25] ; trap: heap_oob
 ;   cmp w27, w26
 ;   csel x28, x27, x26, hi
-;   stlxrb w24, w28, [x25]
+;   stlxrb w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -1391,10 +1391,10 @@ block0(v0: i64, v1: i64):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxr x27, [x25]
+;   ldaxr x27, [x25] ; trap: heap_oob
 ;   cmp x27, x26
 ;   csel x28, x27, x26, lt
-;   stlxr w24, x28, [x25]
+;   stlxr w24, x28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -1434,10 +1434,10 @@ block0(v0: i64, v1: i32):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxr w27, [x25]
+;   ldaxr w27, [x25] ; trap: heap_oob
 ;   cmp w27, w26
 ;   csel x28, x27, x26, lt
-;   stlxr w24, w28, [x25]
+;   stlxr w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -1477,11 +1477,11 @@ block0(v0: i64, v1: i16):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxrh w27, [x25]
+;   ldaxrh w27, [x25] ; trap: heap_oob
 ;   sxth w27, w27
 ;   cmp w27, w26, sxth
 ;   csel x28, x27, x26, lt
-;   stlxrh w24, w28, [x25]
+;   stlxrh w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -1521,11 +1521,11 @@ block0(v0: i64, v1: i8):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxrb w27, [x25]
+;   ldaxrb w27, [x25] ; trap: heap_oob
 ;   sxtb w27, w27
 ;   cmp w27, w26, sxtb
 ;   csel x28, x27, x26, lt
-;   stlxrb w24, w28, [x25]
+;   stlxrb w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -1565,10 +1565,10 @@ block0(v0: i64, v1: i64):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxr x27, [x25]
+;   ldaxr x27, [x25] ; trap: heap_oob
 ;   cmp x27, x26
 ;   csel x28, x27, x26, lo
-;   stlxr w24, x28, [x25]
+;   stlxr w24, x28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -1608,10 +1608,10 @@ block0(v0: i64, v1: i32):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxr w27, [x25]
+;   ldaxr w27, [x25] ; trap: heap_oob
 ;   cmp w27, w26
 ;   csel x28, x27, x26, lo
-;   stlxr w24, w28, [x25]
+;   stlxr w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -1651,10 +1651,10 @@ block0(v0: i64, v1: i16):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxrh w27, [x25]
+;   ldaxrh w27, [x25] ; trap: heap_oob
 ;   cmp w27, w26
 ;   csel x28, x27, x26, lo
-;   stlxrh w24, w28, [x25]
+;   stlxrh w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
@@ -1694,10 +1694,10 @@ block0(v0: i64, v1: i8):
 ; block1: ; offset 0x14
 ;   mov x25, x0
 ;   mov x26, x1
-;   ldaxrb w27, [x25]
+;   ldaxrb w27, [x25] ; trap: heap_oob
 ;   cmp w27, w26
 ;   csel x28, x27, x26, lo
-;   stlxrb w24, w28, [x25]
+;   stlxrb w24, w28, [x25] ; trap: heap_oob
 ;   cbnz x24, #0x1c
 ;   ldp x24, x25, [sp], #0x10
 ;   ldp x26, x27, [sp], #0x10
diff --git a/cranelift/filetests/filetests/isa/aarch64/atomic_load.clif b/cranelift/filetests/filetests/isa/aarch64/atomic_load.clif
index f5262d219911..044cf0f14190 100644
--- a/cranelift/filetests/filetests/isa/aarch64/atomic_load.clif
+++ b/cranelift/filetests/filetests/isa/aarch64/atomic_load.clif
@@ -14,7 +14,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldar x0, [x0]
+;   ldar x0, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_load_i32(i64) -> i32 {
@@ -30,7 +30,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldar w0, [x0]
+;   ldar w0, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_load_i16(i64) -> i16 {
@@ -46,7 +46,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldarh w0, [x0]
+;   ldarh w0, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_load_i8(i64) -> i8 {
@@ -62,7 +62,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldarb w0, [x0]
+;   ldarb w0, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_load_i32_i64(i64) -> i64 {
@@ -79,7 +79,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldar w0, [x0]
+;   ldar w0, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_load_i16_i64(i64) -> i64 {
@@ -96,7 +96,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldarh w0, [x0]
+;   ldarh w0, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_load_i8_i64(i64) -> i64 {
@@ -113,7 +113,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldarb w0, [x0]
+;   ldarb w0, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_load_i16_i32(i64) -> i32 {
@@ -130,7 +130,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldarh w0, [x0]
+;   ldarh w0, [x0] ; trap: heap_oob
 ;   ret
 
 function %atomic_load_i8_i32(i64) -> i32 {
@@ -147,6 +147,6 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldarb w0, [x0]
+;   ldarb w0, [x0] ; trap: heap_oob
 ;   ret
 
diff --git a/cranelift/filetests/filetests/isa/aarch64/atomic_store.clif b/cranelift/filetests/filetests/isa/aarch64/atomic_store.clif
index edbfb445b854..97927059cf8d 100644
--- a/cranelift/filetests/filetests/isa/aarch64/atomic_store.clif
+++ b/cranelift/filetests/filetests/isa/aarch64/atomic_store.clif
@@ -14,7 +14,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stlr x0, [x1]
+;   stlr x0, [x1] ; trap: heap_oob
 ;   ret
 
 function %atomic_store_i32(i32, i64) {
@@ -30,7 +30,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stlr w0, [x1]
+;   stlr w0, [x1] ; trap: heap_oob
 ;   ret
 
 function %atomic_store_i16(i16, i64) {
@@ -46,7 +46,7 @@ block0(v0: i16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stlrh w0, [x1]
+;   stlrh w0, [x1] ; trap: heap_oob
 ;   ret
 
 function %atomic_store_i8(i8, i64) {
@@ -62,7 +62,7 @@ block0(v0: i8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stlrb w0, [x1]
+;   stlrb w0, [x1] ; trap: heap_oob
 ;   ret
 
 function %atomic_store_i64_i32(i64, i64) {
@@ -79,7 +79,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stlr w0, [x1]
+;   stlr w0, [x1] ; trap: heap_oob
 ;   ret
 
 function %atomic_store_i64_i16(i64, i64) {
@@ -96,7 +96,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stlrh w0, [x1]
+;   stlrh w0, [x1] ; trap: heap_oob
 ;   ret
 
 function %atomic_store_i64_i8(i64, i64) {
@@ -113,7 +113,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stlrb w0, [x1]
+;   stlrb w0, [x1] ; trap: heap_oob
 ;   ret
 
 function %atomic_store_i32_i16(i32, i64) {
@@ -130,7 +130,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stlrh w0, [x1]
+;   stlrh w0, [x1] ; trap: heap_oob
 ;   ret
 
 function %atomic_store_i32_i8(i32, i64) {
@@ -147,6 +147,6 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stlrb w0, [x1]
+;   stlrb w0, [x1] ; trap: heap_oob
 ;   ret
 
diff --git a/cranelift/filetests/filetests/isa/aarch64/bitcast-fp16.clif b/cranelift/filetests/filetests/isa/aarch64/bitcast-fp16.clif
new file mode 100644
index 000000000000..ad9d8b7736cd
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/aarch64/bitcast-fp16.clif
@@ -0,0 +1,35 @@
+test compile precise-output
+target aarch64 has_fp16
+
+function %bitcast_f16_to_i16(f16) -> i16 {
+block0(v0: f16):
+  v1 = bitcast.i16 v0
+  return v1
+}
+
+; VCode:
+; block0:
+;   umov w0, v0.h[0]
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   umov w0, v0.h[0]
+;   ret
+
+function %bitcast_i16_to_f16(i16) -> f16 {
+block0(v0: i16):
+  v1 = bitcast.f16 v0
+  return v1
+}
+
+; VCode:
+; block0:
+;   fmov h0, w0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   fmov h0, w0
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/aarch64/bitcast.clif b/cranelift/filetests/filetests/isa/aarch64/bitcast.clif
index f8968694f980..9306044458dc 100644
--- a/cranelift/filetests/filetests/isa/aarch64/bitcast.clif
+++ b/cranelift/filetests/filetests/isa/aarch64/bitcast.clif
@@ -1,7 +1,39 @@
 test compile precise-output
 target aarch64
 
-function %f1(f32) -> i32 {
+function %bitcast_f16_to_i16(f16) -> i16 {
+block0(v0: f16):
+  v1 = bitcast.i16 v0
+  return v1
+}
+
+; VCode:
+; block0:
+;   umov w0, v0.h[0]
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   umov w0, v0.h[0]
+;   ret
+
+function %bitcast_i16_to_f16(i16) -> f16 {
+block0(v0: i16):
+  v1 = bitcast.f16 v0
+  return v1
+}
+
+; VCode:
+; block0:
+;   fmov s0, w0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   fmov s0, w0
+;   ret
+
+function %bitcast_f32_to_i32(f32) -> i32 {
 block0(v0: f32):
   v1 = bitcast.i32 v0
   return v1
@@ -17,7 +49,7 @@ block0(v0: f32):
 ;   mov w0, v0.s[0]
 ;   ret
 
-function %f2(i32) -> f32 {
+function %bitcast_i32_to_f32(i32) -> f32 {
 block0(v0: i32):
   v1 = bitcast.f32 v0
   return v1
@@ -33,7 +65,7 @@ block0(v0: i32):
 ;   fmov s0, w0
 ;   ret
 
-function %f3(f64) -> i64 {
+function %bitcast_f64_to_i64(f64) -> i64 {
 block0(v0: f64):
   v1 = bitcast.i64 v0
   return v1
@@ -49,7 +81,7 @@ block0(v0: f64):
 ;   mov x0, v0.d[0]
 ;   ret
 
-function %f4(i64) -> f64 {
+function %bitcast_i64_to_f64(i64) -> f64 {
 block0(v0: i64):
   v1 = bitcast.f64 v0
   return v1
@@ -65,3 +97,75 @@ block0(v0: i64):
 ;   fmov d0, x0
 ;   ret
 
+function %bitcast_f128_to_i128(f128) -> i128 {
+block0(v0: f128):
+  v1 = bitcast.i128 v0
+  return v1
+}
+
+; VCode:
+; block0:
+;   mov x0, v0.d[0]
+;   mov x1, v0.d[1]
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   mov x0, v0.d[0]
+;   mov x1, v0.d[1]
+;   ret
+
+function %bitcast_i128_to_f128(i128) -> f128 {
+block0(v0: i128):
+  v1 = bitcast.f128 v0
+  return v1
+}
+
+; VCode:
+; block0:
+;   fmov d0, x0
+;   mov v0.d[1], v0.d[1], x1
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   fmov d0, x0
+;   mov v0.d[1], x1
+;   ret
+
+function %bitcast_i64x2_to_i128(i64x2) -> i128 {
+block0(v0: i64x2):
+  v1 = bitcast.i128 little v0
+  return v1
+}
+
+; VCode:
+; block0:
+;   mov x0, v0.d[0]
+;   mov x1, v0.d[1]
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   mov x0, v0.d[0]
+;   mov x1, v0.d[1]
+;   ret
+
+function %bitcast_i128_to_i64x2(i128) -> i64x2 {
+block0(v0: i128):
+  v1 = bitcast.i64x2 little v0
+  return v1
+}
+
+; VCode:
+; block0:
+;   fmov d0, x0
+;   mov v0.d[1], v0.d[1], x1
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   fmov d0, x0
+;   mov v0.d[1], x1
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/aarch64/call-pauth-bkey.clif b/cranelift/filetests/filetests/isa/aarch64/call-pauth-bkey.clif
index 06e6ecc54e48..9b37ca1521b5 100644
--- a/cranelift/filetests/filetests/isa/aarch64/call-pauth-bkey.clif
+++ b/cranelift/filetests/filetests/isa/aarch64/call-pauth-bkey.clif
@@ -63,8 +63,8 @@ block0(v0: i64):
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
 ; block0:
-;   mov x0, x2
 ;   load_ext_name x3, TestCase(%g)+0
+;   mov x0, x2
 ;   blr x3
 ;   mov x2, x0
 ;   ldp fp, lr, [sp], #16
@@ -76,11 +76,11 @@ block0(v0: i64):
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
 ; block1: ; offset 0xc
-;   mov x0, x2
-;   ldr x3, #0x18
-;   b #0x20
+;   ldr x3, #0x14
+;   b #0x1c
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %g 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
+;   mov x0, x2
 ;   blr x3
 ;   mov x2, x0
 ;   ldp x29, x30, [sp], #0x10
@@ -99,8 +99,8 @@ block0(v0: i64):
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
 ; block0:
-;   load_ext_name x3, TestCase(%g)+0
-;   return_call_ind x3 old_stack_arg_size:0 new_stack_arg_size:0 x2=x2
+;   load_ext_name x1, TestCase(%g)+0
+;   return_call_ind x1 new_stack_arg_size:0 x2=x2
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
@@ -108,13 +108,11 @@ block0(v0: i64):
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
 ; block1: ; offset 0xc
-;   ldr x3, #0x14
+;   ldr x1, #0x14
 ;   b #0x1c
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %g 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   ldp x16, x30, [x29]
-;   add sp, x29, #0x10
-;   mov x29, x16
+;   ldp x29, x30, [sp], #0x10
 ;   autibz
-;   br x3
+;   br x1
 
diff --git a/cranelift/filetests/filetests/isa/aarch64/call-pauth.clif b/cranelift/filetests/filetests/isa/aarch64/call-pauth.clif
index 74dbb2cfd82c..736cafe2e0c3 100644
--- a/cranelift/filetests/filetests/isa/aarch64/call-pauth.clif
+++ b/cranelift/filetests/filetests/isa/aarch64/call-pauth.clif
@@ -64,8 +64,8 @@ block0(v0: i64):
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
 ; block0:
-;   mov x0, x2
 ;   load_ext_name x3, TestCase(%g)+0
+;   mov x0, x2
 ;   blr x3
 ;   mov x2, x0
 ;   ldp fp, lr, [sp], #16
@@ -77,11 +77,11 @@ block0(v0: i64):
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
 ; block1: ; offset 0xc
-;   mov x0, x2
-;   ldr x3, #0x18
-;   b #0x20
+;   ldr x3, #0x14
+;   b #0x1c
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %g 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
+;   mov x0, x2
 ;   blr x3
 ;   mov x2, x0
 ;   ldp x29, x30, [sp], #0x10
@@ -100,8 +100,8 @@ block0(v0: i64):
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
 ; block0:
-;   load_ext_name x3, TestCase(%g)+0
-;   return_call_ind x3 old_stack_arg_size:0 new_stack_arg_size:0 x2=x2
+;   load_ext_name x1, TestCase(%g)+0
+;   return_call_ind x1 new_stack_arg_size:0 x2=x2
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
@@ -109,13 +109,11 @@ block0(v0: i64):
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
 ; block1: ; offset 0xc
-;   ldr x3, #0x14
+;   ldr x1, #0x14
 ;   b #0x1c
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %g 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   ldp x16, x30, [x29]
-;   add sp, x29, #0x10
-;   mov x29, x16
+;   ldp x29, x30, [sp], #0x10
 ;   autiaz
-;   br x3
+;   br x1
 
diff --git a/cranelift/filetests/filetests/isa/aarch64/call.clif b/cranelift/filetests/filetests/isa/aarch64/call.clif
index 7f371334e244..ee69a6a2819a 100644
--- a/cranelift/filetests/filetests/isa/aarch64/call.clif
+++ b/cranelift/filetests/filetests/isa/aarch64/call.clif
@@ -1,6 +1,7 @@
 test compile precise-output
 set unwind_info=false
 set enable_probestack=false
+set enable_llvm_abi_extensions
 target aarch64
 
 function %f1(i64) -> i64 {
@@ -131,10 +132,9 @@ block0(v0: i8):
 ; VCode:
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
+;   sub sp, sp, #16
 ; block0:
 ;   movz w7, #42
-;   sub sp, sp, #16
-;   virtual_sp_offset_adjust 16
 ;   strb w0, [sp]
 ;   load_ext_name x8, TestCase(%g)+0
 ;   mov x0, x7
@@ -146,7 +146,6 @@ block0(v0: i8):
 ;   mov x6, x7
 ;   blr x8
 ;   add sp, sp, #16
-;   virtual_sp_offset_adjust -16
 ;   ldp fp, lr, [sp], #16
 ;   ret
 ;
@@ -154,9 +153,9 @@ block0(v0: i8):
 ; block0: ; offset 0x0
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
-; block1: ; offset 0x8
-;   mov w7, #0x2a
 ;   sub sp, sp, #0x10
+; block1: ; offset 0xc
+;   mov w7, #0x2a
 ;   sturb w0, [sp]
 ;   ldr x8, #0x1c
 ;   b #0x24
@@ -530,9 +529,9 @@ block0(v0: i64):
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
 ; block0:
-;   mov x1, x0
 ;   movz x2, #42
 ;   load_ext_name x4, TestCase(%f11)+0
+;   mov x1, x0
 ;   mov x0, x2
 ;   blr x4
 ;   ldp fp, lr, [sp], #16
@@ -543,12 +542,12 @@ block0(v0: i64):
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
 ; block1: ; offset 0x8
-;   mov x1, x0
 ;   mov x2, #0x2a
-;   ldr x4, #0x18
-;   b #0x20
+;   ldr x4, #0x14
+;   b #0x1c
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %f11 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
+;   mov x1, x0
 ;   mov x0, x2
 ;   blr x4
 ;   ldp x29, x30, [sp], #0x10
@@ -584,9 +583,9 @@ block0(v0: i64):
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
 ; block0:
-;   mov x2, x0
 ;   movz x3, #42
 ;   load_ext_name x4, TestCase(%f12)+0
+;   mov x2, x0
 ;   mov x0, x3
 ;   blr x4
 ;   ldp fp, lr, [sp], #16
@@ -597,12 +596,12 @@ block0(v0: i64):
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
 ; block1: ; offset 0x8
-;   mov x2, x0
 ;   mov x3, #0x2a
-;   ldr x4, #0x18
-;   b #0x20
+;   ldr x4, #0x14
+;   b #0x1c
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %f12 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
+;   mov x2, x0
 ;   mov x0, x3
 ;   blr x4
 ;   ldp x29, x30, [sp], #0x10
@@ -638,9 +637,9 @@ block0(v0: i64):
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
 ; block0:
-;   mov x1, x0
 ;   movz x2, #42
 ;   load_ext_name x4, TestCase(%f13)+0
+;   mov x1, x0
 ;   mov x0, x2
 ;   blr x4
 ;   ldp fp, lr, [sp], #16
@@ -651,12 +650,12 @@ block0(v0: i64):
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
 ; block1: ; offset 0x8
-;   mov x1, x0
 ;   mov x2, #0x2a
-;   ldr x4, #0x18
-;   b #0x20
+;   ldr x4, #0x14
+;   b #0x1c
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %f13 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
+;   mov x1, x0
 ;   mov x0, x2
 ;   blr x4
 ;   ldp x29, x30, [sp], #0x10
@@ -671,8 +670,8 @@ block0(v0: i128, v1: i128, v2: i128, v3: i64, v4: i128):
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
 ; block0:
-;   ldr x0, [fp, #16]
-;   ldr x1, [fp, #24]
+;   ldr x0, [sp, #16]
+;   ldr x1, [sp, #24]
 ;   ldp fp, lr, [sp], #16
 ;   ret
 ;
@@ -681,8 +680,8 @@ block0(v0: i128, v1: i128, v2: i128, v3: i64, v4: i128):
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
 ; block1: ; offset 0x8
-;   ldur x0, [x29, #0x10]
-;   ldur x1, [x29, #0x18]
+;   ldur x0, [sp, #0x10]
+;   ldur x1, [sp, #0x18]
 ;   ldp x29, x30, [sp], #0x10
 ;   ret
 
@@ -697,22 +696,18 @@ block0(v0: i128, v1: i64):
 ; VCode:
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
-; block0:
-;   mov x6, x2
 ;   sub sp, sp, #16
-;   virtual_sp_offset_adjust 16
+; block0:
 ;   str x0, [sp]
-;   mov x4, x0
 ;   str x1, [sp, #8]
+;   load_ext_name x8, TestCase(%f14)+0
+;   mov x4, x0
 ;   mov x5, x1
-;   load_ext_name x10, TestCase(%f14)+0
-;   mov x0, x4
+;   mov x6, x2
 ;   mov x2, x4
-;   mov x1, x5
 ;   mov x3, x5
-;   blr x10
+;   blr x8
 ;   add sp, sp, #16
-;   virtual_sp_offset_adjust -16
 ;   ldp fp, lr, [sp], #16
 ;   ret
 ;
@@ -720,22 +715,20 @@ block0(v0: i128, v1: i64):
 ; block0: ; offset 0x0
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
-; block1: ; offset 0x8
-;   mov x6, x2
 ;   sub sp, sp, #0x10
+; block1: ; offset 0xc
 ;   stur x0, [sp]
-;   mov x4, x0
 ;   stur x1, [sp, #8]
-;   mov x5, x1
-;   ldr x10, #0x28
-;   b #0x30
+;   ldr x8, #0x1c
+;   b #0x24
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %f14 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   mov x0, x4
+;   mov x4, x0
+;   mov x5, x1
+;   mov x6, x2
 ;   mov x2, x4
-;   mov x1, x5
 ;   mov x3, x5
-;   blr x10
+;   blr x8
 ;   add sp, sp, #0x10
 ;   ldp x29, x30, [sp], #0x10
 ;   ret
@@ -749,8 +742,8 @@ block0(v0: i128, v1: i128, v2: i128, v3: i64, v4: i128):
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
 ; block0:
-;   ldr x0, [fp, #16]
-;   ldr x1, [fp, #24]
+;   ldr x0, [sp, #16]
+;   ldr x1, [sp, #24]
 ;   ldp fp, lr, [sp], #16
 ;   ret
 ;
@@ -759,8 +752,8 @@ block0(v0: i128, v1: i128, v2: i128, v3: i64, v4: i128):
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
 ; block1: ; offset 0x8
-;   ldur x0, [x29, #0x10]
-;   ldur x1, [x29, #0x18]
+;   ldur x0, [sp, #0x10]
+;   ldur x1, [sp, #0x18]
 ;   ldp x29, x30, [sp], #0x10
 ;   ret
 
@@ -775,22 +768,18 @@ block0(v0: i128, v1: i64):
 ; VCode:
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
-; block0:
-;   mov x6, x2
 ;   sub sp, sp, #16
-;   virtual_sp_offset_adjust 16
+; block0:
 ;   str x0, [sp]
-;   mov x4, x0
 ;   str x1, [sp, #8]
+;   load_ext_name x8, TestCase(%f15)+0
+;   mov x4, x0
 ;   mov x5, x1
-;   load_ext_name x10, TestCase(%f15)+0
-;   mov x0, x4
+;   mov x6, x2
 ;   mov x2, x4
-;   mov x1, x5
 ;   mov x3, x5
-;   blr x10
+;   blr x8
 ;   add sp, sp, #16
-;   virtual_sp_offset_adjust -16
 ;   ldp fp, lr, [sp], #16
 ;   ret
 ;
@@ -798,22 +787,20 @@ block0(v0: i128, v1: i64):
 ; block0: ; offset 0x0
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
-; block1: ; offset 0x8
-;   mov x6, x2
 ;   sub sp, sp, #0x10
+; block1: ; offset 0xc
 ;   stur x0, [sp]
-;   mov x4, x0
 ;   stur x1, [sp, #8]
-;   mov x5, x1
-;   ldr x10, #0x28
-;   b #0x30
+;   ldr x8, #0x1c
+;   b #0x24
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %f15 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   mov x0, x4
+;   mov x4, x0
+;   mov x5, x1
+;   mov x6, x2
 ;   mov x2, x4
-;   mov x1, x5
 ;   mov x3, x5
-;   blr x10
+;   blr x8
 ;   add sp, sp, #0x10
 ;   ldp x29, x30, [sp], #0x10
 ;   ret
@@ -834,7 +821,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   mov x2, #0x2a
-;   str x2, [x8]
+;   str x2, [x8] ; trap: heap_oob
 ;   ret
 
 function %f18(i64) -> i64 {
@@ -849,8 +836,8 @@ block0(v0: i64):
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
 ; block0:
-;   mov x8, x0
 ;   load_ext_name x3, TestCase(%g)+0
+;   mov x8, x0
 ;   blr x3
 ;   ldp fp, lr, [sp], #16
 ;   ret
@@ -860,11 +847,11 @@ block0(v0: i64):
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
 ; block1: ; offset 0x8
-;   mov x8, x0
-;   ldr x3, #0x14
-;   b #0x1c
+;   ldr x3, #0x10
+;   b #0x18
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %g 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
+;   mov x8, x0
 ;   blr x3
 ;   ldp x29, x30, [sp], #0x10
 ;   ret
@@ -880,14 +867,13 @@ block0(v0: i64):
 ; VCode:
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
-;   str x23, [sp, #-16]!
+;   str x24, [sp, #-16]!
 ; block0:
-;   mov x23, x8
+;   mov x24, x8
 ;   load_ext_name x2, TestCase(%g)+0
-;   mov x8, x23
 ;   blr x2
-;   mov x8, x23
-;   ldr x23, [sp], #16
+;   mov x8, x24
+;   ldr x24, [sp], #16
 ;   ldp fp, lr, [sp], #16
 ;   ret
 ;
@@ -895,17 +881,16 @@ block0(v0: i64):
 ; block0: ; offset 0x0
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
-;   str x23, [sp, #-0x10]!
+;   str x24, [sp, #-0x10]!
 ; block1: ; offset 0xc
-;   mov x23, x8
+;   mov x24, x8
 ;   ldr x2, #0x18
 ;   b #0x20
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %g 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   mov x8, x23
 ;   blr x2
-;   mov x8, x23
-;   ldr x23, [sp], #0x10
+;   mov x8, x24
+;   ldr x24, [sp], #0x10
 ;   ldp x29, x30, [sp], #0x10
 ;   ret
 
@@ -939,3 +924,63 @@ block0:
 ;   ldp x29, x30, [sp], #0x10
 ;   ret
 
+function %second_f16(f16, f16) -> f16 system_v {
+block0(v0: f16, v1: f16):
+    return v1
+}
+
+; VCode:
+; block0:
+;   mov v0.16b, v1.16b
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   mov v0.16b, v1.16b
+;   ret
+
+function %second_f128(f128, f128) -> f128 system_v {
+block0(v0: f128, v1: f128):
+    return v1
+}
+
+; VCode:
+; block0:
+;   mov v0.16b, v1.16b
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   mov v0.16b, v1.16b
+;   ret
+
+function %second_f16_apple(f16, f16) -> f16 apple_aarch64 {
+block0(v0: f16, v1: f16):
+    return v1
+}
+
+; VCode:
+; block0:
+;   mov v0.16b, v1.16b
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   mov v0.16b, v1.16b
+;   ret
+
+function %second_f128_apple(f128, f128) -> f128 apple_aarch64 {
+block0(v0: f128, v1: f128):
+    return v1
+}
+
+; VCode:
+; block0:
+;   mov v0.16b, v1.16b
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   mov v0.16b, v1.16b
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/aarch64/condbr.clif b/cranelift/filetests/filetests/isa/aarch64/condbr.clif
index f0661556de90..13d59de14513 100644
--- a/cranelift/filetests/filetests/isa/aarch64/condbr.clif
+++ b/cranelift/filetests/filetests/isa/aarch64/condbr.clif
@@ -733,3 +733,183 @@ block1:
 ; block1: ; offset 0x1c
 ;   ret
 
+function %tbnz_i8(i8) {
+block0(v0: i8):
+  v1 = band_imm v0, 0x10
+  brif v1, block1, block2
+
+block1:
+  return
+block2:
+  return
+}
+
+; VCode:
+; block0:
+;   tbnz x0, #4, label2 ; b label1
+; block1:
+;   ret
+; block2:
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   tbnz w0, #4, #8
+; block1: ; offset 0x4
+;   ret
+; block2: ; offset 0x8
+;   ret
+
+function %tbz_i16(i16) {
+block0(v0: i16):
+  v1 = band_imm v0, 0x1000
+  v2 = icmp_imm eq v1, 0
+  brif v2, block1, block2
+
+block1:
+  return
+block2:
+  return
+}
+
+; VCode:
+; block0:
+;   tbz x0, #12, label2 ; b label1
+; block1:
+;   ret
+; block2:
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   tbz w0, #0xc, #8
+; block1: ; offset 0x4
+;   ret
+; block2: ; offset 0x8
+;   ret
+
+function %tbnz_i32(i32) {
+block0(v0: i32):
+  v1 = band_imm v0, 0x10000
+  brif v1, block1, block2
+
+block1:
+  return
+block2:
+  return
+}
+
+; VCode:
+; block0:
+;   tbnz x0, #16, label2 ; b label1
+; block1:
+;   ret
+; block2:
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   tbnz w0, #0x10, #8
+; block1: ; offset 0x4
+;   ret
+; block2: ; offset 0x8
+;   ret
+
+
+function %tbz_i64(i64) {
+block0(v0: i64):
+  v1 = band_imm v0, 0x1_00000000
+  v2 = icmp_imm eq v1, 0
+  brif v2, block1, block2
+
+block1:
+  return
+block2:
+  return
+}
+
+; VCode:
+; block0:
+;   tbz x0, #32, label2 ; b label1
+; block1:
+;   ret
+; block2:
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   tbz x0, #0x20, #8
+; block1: ; offset 0x4
+;   ret
+; block2: ; offset 0x8
+;   ret
+
+function %not_tbz1(i8) {
+block0(v0: i8):
+  v1 = band_imm v0, 0x100
+  v2 = icmp_imm eq v1, 0
+  brif v2, block1, block2
+
+block1:
+  return
+block2:
+  return
+}
+
+; VCode:
+; block0:
+;   movz w4, #0
+;   and w4, w0, w4
+;   uxtb w4, w4
+;   subs wzr, w4, #0
+;   b.eq label2 ; b label1
+; block1:
+;   ret
+; block2:
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   mov w4, #0
+;   and w4, w0, w4
+;   uxtb w4, w4
+;   cmp w4, #0
+;   b.eq #0x18
+; block1: ; offset 0x14
+;   ret
+; block2: ; offset 0x18
+;   ret
+
+function %not_tbz2(i8) {
+block0(v0: i8):
+  v1 = band_imm v0, 0x3
+  v2 = icmp_imm eq v1, 0
+  brif v2, block1, block2
+
+block1:
+  return
+block2:
+  return
+}
+
+; VCode:
+; block0:
+;   and w3, w0, #3
+;   uxtb w3, w3
+;   subs wzr, w3, #0
+;   b.eq label2 ; b label1
+; block1:
+;   ret
+; block2:
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   and w3, w0, #3
+;   uxtb w3, w3
+;   cmp w3, #0
+;   b.eq #0x14
+; block1: ; offset 0x10
+;   ret
+; block2: ; offset 0x14
+;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/constants-fp16.clif b/cranelift/filetests/filetests/isa/aarch64/constants-fp16.clif
new file mode 100644
index 000000000000..0531cc0e26a1
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/aarch64/constants-fp16.clif
@@ -0,0 +1,70 @@
+test compile precise-output
+set unwind_info=false
+target aarch64 has_fp16
+
+function %f() -> f16 {
+block0:
+  v0 = f16const 0x1.0
+  return v0
+}
+
+; VCode:
+; block0:
+;   fmov h0, #1
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   fmov h0, #1.00000000
+;   ret
+
+function %f() -> f16 {
+block0:
+  v0 = f16const 0x32.0
+  return v0
+}
+
+; VCode:
+; block0:
+;   movz w0, #21056
+;   fmov h0, w0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   mov w0, #0x5240
+;   fmov h0, w0
+;   ret
+
+function %f() -> f16 {
+block0:
+  v0 = f16const 0x0.0
+  return v0
+}
+
+; VCode:
+; block0:
+;   movi v0.2s, #0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   movi v0.2s, #0
+;   ret
+
+function %f() -> f16 {
+block0:
+  v0 = f16const -0x10.0
+  return v0
+}
+
+; VCode:
+; block0:
+;   fmov h0, #-16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   fmov h0, #-16.00000000
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/aarch64/constants.clif b/cranelift/filetests/filetests/isa/aarch64/constants.clif
index 596fc4fbe551..5f733b3f0644 100644
--- a/cranelift/filetests/filetests/isa/aarch64/constants.clif
+++ b/cranelift/filetests/filetests/isa/aarch64/constants.clif
@@ -316,6 +316,28 @@ block0:
 ;   mov x0, #-9
 ;   ret
 
+function %f() -> f128 {
+block0:
+  v0 = f128const 0x1.0
+  return v0
+}
+
+; VCode:
+; block0:
+;   ldr q0, [const(0)]
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   ldr q0, #0x10
+;   ret
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   .byte 0x00, 0x00, 0xff, 0x3f
+
 function %f() -> f64 {
 block0:
   v0 = f64const 0x1.0
@@ -348,6 +370,46 @@ block0:
 ;   fmov s0, #5.00000000
 ;   ret
 
+function %f() -> f16 {
+block0:
+  v0 = f16const 0x1.0
+  return v0
+}
+
+; VCode:
+; block0:
+;   movz w0, #15360
+;   fmov s0, w0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   mov w0, #0x3c00
+;   fmov s0, w0
+;   ret
+
+function %f() -> f128 {
+block0:
+  v0 = f128const 0x32.0
+  return v0
+}
+
+; VCode:
+; block0:
+;   ldr q0, [const(0)]
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   ldr q0, #0x10
+;   ret
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   .byte 0x00, 0x90, 0x04, 0x40
+
 function %f() -> f64 {
 block0:
   v0 = f64const 0x32.0
@@ -384,6 +446,40 @@ block0:
 ;   fmov s0, w0
 ;   ret
 
+function %f() -> f16 {
+block0:
+  v0 = f16const 0x32.0
+  return v0
+}
+
+; VCode:
+; block0:
+;   movz w0, #21056
+;   fmov s0, w0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   mov w0, #0x5240
+;   fmov s0, w0
+;   ret
+
+function %f() -> f128 {
+block0:
+  v0 = f128const 0x0.0
+  return v0
+}
+
+; VCode:
+; block0:
+;   movi v0.16b, #0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   movi v0.16b, #0
+;   ret
+
 function %f() -> f64 {
 block0:
   v0 = f64const 0x0.0
@@ -416,6 +512,44 @@ block0:
 ;   movi v0.2s, #0
 ;   ret
 
+function %f() -> f16 {
+block0:
+  v0 = f16const 0x0.0
+  return v0
+}
+
+; VCode:
+; block0:
+;   movi v0.2s, #0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   movi v0.2s, #0
+;   ret
+
+function %f() -> f128 {
+block0:
+  v0 = f128const -0x10.0
+  return v0
+}
+
+; VCode:
+; block0:
+;   ldr q0, [const(0)]
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   ldr q0, #0x10
+;   ret
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   .byte 0x00, 0x00, 0x03, 0xc0
+
 function %f() -> f64 {
 block0:
   v0 = f64const -0x10.0
@@ -448,3 +582,21 @@ block0:
 ;   fmov s0, #-16.00000000
 ;   ret
 
+function %f() -> f16 {
+block0:
+  v0 = f16const -0x10.0
+  return v0
+}
+
+; VCode:
+; block0:
+;   movz w0, #52224
+;   fmov s0, w0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   mov w0, #0xcc00
+;   fmov s0, w0
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/aarch64/fma.clif b/cranelift/filetests/filetests/isa/aarch64/fma.clif
index 247e67a03c96..a0b714d09d4b 100644
--- a/cranelift/filetests/filetests/isa/aarch64/fma.clif
+++ b/cranelift/filetests/filetests/isa/aarch64/fma.clif
@@ -33,6 +33,106 @@ block0(v0: f64, v1: f64, v2: f64):
 ;   fmadd d0, d0, d1, d2
 ;   ret
 
+function %fmsub_f32(f32, f32, f32) -> f32 {
+block0(v0: f32, v1: f32, v2: f32):
+    v3 = fneg v1
+    v4 = fma v0, v3, v2
+    return v4
+}
+
+; VCode:
+; block0:
+;   fmsub s0, s0, s1, s2
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   fmsub s0, s0, s1, s2
+;   ret
+
+function %fmsub_f64(f64, f64, f64) -> f64 {
+block0(v0: f64, v1: f64, v2: f64):
+    v3 = fneg v1
+    v4 = fma v0, v3, v2
+    return v4
+}
+
+; VCode:
+; block0:
+;   fmsub d0, d0, d1, d2
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   fmsub d0, d0, d1, d2
+;   ret
+
+function %fnmadd_f32(f32, f32, f32) -> f32 {
+block0(v0: f32, v1: f32, v2: f32):
+    v3 = fneg v1
+    v4 = fneg v2
+    v5 = fma v0, v3, v4
+    return v5
+}
+; VCode:
+; block0:
+;   fnmadd s0, s0, s1, s2
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   fnmadd s0, s0, s1, s2
+;   ret
+
+function %fnmadd_f64(f64, f64, f64) -> f64 {
+block0(v0: f64, v1: f64, v2: f64):
+    v3 = fneg v1
+    v4 = fneg v2
+    v5 = fma v0, v3, v4
+    return v5
+}
+; VCode:
+; block0:
+;   fnmadd d0, d0, d1, d2
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   fnmadd d0, d0, d1, d2
+;   ret
+
+function %fnmadd_f32(f32, f32, f32) -> f32 {
+block0(v0: f32, v1: f32, v2: f32):
+    v3 = fneg v2
+    v4 = fma v0, v1, v3
+    return v4
+}
+; VCode:
+; block0:
+;   fnmsub s0, s0, s1, s2
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   fnmsub s0, s0, s1, s2
+;   ret
+
+function %fnmadd_f64(f64, f64, f64) -> f64 {
+block0(v0: f64, v1: f64, v2: f64):
+    v3 = fneg v2
+    v4 = fma v0, v1, v3
+    return v4
+}
+; VCode:
+; block0:
+;   fnmsub d0, d0, d1, d2
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   fnmsub d0, d0, d1, d2
+;   ret
+
 function %fma_f32x4(f32x4, f32x4, f32x4) -> f32x4 {
 block0(v0: f32x4, v1: f32x4, v2: f32x4):
     v3 = fma v0, v1, v2
@@ -258,28 +358,28 @@ block0(v0: f32x4, v1: f32x4, v2: f32x4):
 
 ; VCode:
 ; block0:
-;   mov v31.16b, v1.16b
 ;   movz w6, #7452
 ;   movk w6, w6, #7966, LSL #16
 ;   dup v17.4s, w6
+;   mov v31.16b, v1.16b
 ;   mov v30.16b, v31.16b
 ;   tbl v19.16b, { v30.16b, v31.16b }, v17.16b
-;   mov v23.16b, v0.16b
+;   mov v22.16b, v0.16b
 ;   mov v0.16b, v2.16b
-;   fmla v0.4s, v0.4s, v23.4s, v19.4s
+;   fmla v0.4s, v0.4s, v22.4s, v19.4s
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mov v31.16b, v1.16b
 ;   mov w6, #0x1d1c
 ;   movk w6, #0x1f1e, lsl #16
 ;   dup v17.4s, w6
+;   mov v31.16b, v1.16b
 ;   mov v30.16b, v31.16b
 ;   tbl v19.16b, {v30.16b, v31.16b}, v17.16b
-;   mov v23.16b, v0.16b
+;   mov v22.16b, v0.16b
 ;   mov v0.16b, v2.16b
-;   fmla v0.4s, v23.4s, v19.4s
+;   fmla v0.4s, v22.4s, v19.4s
 ;   ret
 
 function %f64x2_splat0(f64x2, f64x2, f64x2) -> f64x2 {
diff --git a/cranelift/filetests/filetests/isa/aarch64/fuzzbug-60035.clif b/cranelift/filetests/filetests/isa/aarch64/fuzzbug-60035.clif
index ebddc1125802..40fd6ccfa4da 100644
--- a/cranelift/filetests/filetests/isa/aarch64/fuzzbug-60035.clif
+++ b/cranelift/filetests/filetests/isa/aarch64/fuzzbug-60035.clif
@@ -15,33 +15,12 @@ block0:
 ; VCode:
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
-;   stp x27, x28, [sp, #-16]!
-;   stp x25, x26, [sp, #-16]!
-;   stp x23, x24, [sp, #-16]!
-;   stp x21, x22, [sp, #-16]!
-;   stp x19, x20, [sp, #-16]!
-;   stp d14, d15, [sp, #-16]!
-;   stp d12, d13, [sp, #-16]!
-;   stp d10, d11, [sp, #-16]!
-;   stp d8, d9, [sp, #-16]!
-;   sub sp, sp, #16
+;   str x19, [sp, #-16]!
 ; block0:
-;   load_ext_name x1, User(userextname0)+0
-;   str x1, [sp]
-;   ldr x1, [sp]
-;   blr x1
-;   ldr x1, [sp]
-;   blr x1
-;   add sp, sp, #16
-;   ldp d8, d9, [sp], #16
-;   ldp d10, d11, [sp], #16
-;   ldp d12, d13, [sp], #16
-;   ldp d14, d15, [sp], #16
-;   ldp x19, x20, [sp], #16
-;   ldp x21, x22, [sp], #16
-;   ldp x23, x24, [sp], #16
-;   ldp x25, x26, [sp], #16
-;   ldp x27, x28, [sp], #16
+;   load_ext_name x19, User(userextname0)+0
+;   blr x19
+;   blr x19
+;   ldr x19, [sp], #16
 ;   ldp fp, lr, [sp], #16
 ;   ret
 ;
@@ -49,36 +28,15 @@ block0:
 ; block0: ; offset 0x0
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
-;   stp x27, x28, [sp, #-0x10]!
-;   stp x25, x26, [sp, #-0x10]!
-;   stp x23, x24, [sp, #-0x10]!
-;   stp x21, x22, [sp, #-0x10]!
-;   stp x19, x20, [sp, #-0x10]!
-;   stp d14, d15, [sp, #-0x10]!
-;   stp d12, d13, [sp, #-0x10]!
-;   stp d10, d11, [sp, #-0x10]!
-;   stp d8, d9, [sp, #-0x10]!
-;   sub sp, sp, #0x10
-; block1: ; offset 0x30
-;   ldr x1, #0x38
-;   b #0x40
+;   str x19, [sp, #-0x10]!
+; block1: ; offset 0xc
+;   ldr x19, #0x14
+;   b #0x1c
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 u1:7 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   stur x1, [sp]
-;   ldur x1, [sp]
-;   blr x1
-;   ldur x1, [sp]
-;   blr x1
-;   add sp, sp, #0x10
-;   ldp d8, d9, [sp], #0x10
-;   ldp d10, d11, [sp], #0x10
-;   ldp d12, d13, [sp], #0x10
-;   ldp d14, d15, [sp], #0x10
-;   ldp x19, x20, [sp], #0x10
-;   ldp x21, x22, [sp], #0x10
-;   ldp x23, x24, [sp], #0x10
-;   ldp x25, x26, [sp], #0x10
-;   ldp x27, x28, [sp], #0x10
+;   blr x19
+;   blr x19
+;   ldr x19, [sp], #0x10
 ;   ldp x29, x30, [sp], #0x10
 ;   ret
 
diff --git a/cranelift/filetests/filetests/isa/aarch64/iabs.clif b/cranelift/filetests/filetests/isa/aarch64/iabs.clif
index c559a2313e11..b76916e8bba7 100644
--- a/cranelift/filetests/filetests/isa/aarch64/iabs.clif
+++ b/cranelift/filetests/filetests/isa/aarch64/iabs.clif
@@ -190,3 +190,27 @@ block0(v0: i64):
 ;   cneg x0, x0, le
 ;   ret
 
+function %f11(i128) -> i128 {
+block0(v0: i128):
+  v1 = iabs v0
+  return v1
+}
+
+; VCode:
+; block0:
+;   asr x3, x1, #63
+;   eor x5, x1, x3
+;   eor x7, x0, x3
+;   subs x0, x7, x3
+;   sbc x1, x5, x3
+;   ret
+; 
+; Disassembled:
+; block0: ; offset 0x0
+;   asr x3, x1, #0x3f
+;   eor x5, x1, x3
+;   eor x7, x0, x3
+;   subs x0, x7, x3
+;   sbc x1, x5, x3
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/aarch64/inline-probestack.clif b/cranelift/filetests/filetests/isa/aarch64/inline-probestack.clif
index 2ec7431b95e7..eee45fd76d87 100644
--- a/cranelift/filetests/filetests/isa/aarch64/inline-probestack.clif
+++ b/cranelift/filetests/filetests/isa/aarch64/inline-probestack.clif
@@ -47,9 +47,13 @@ block0:
 ; VCode:
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
-;   movn x16, #4095 ; str wzr, [sp, x16, SXTX]
-;   movn x16, #8191 ; str wzr, [sp, x16, SXTX]
-;   movn x16, #12287 ; str wzr, [sp, x16, SXTX]
+;   sub sp, sp, #4096
+;   str wzr, [sp]
+;   sub sp, sp, #4096
+;   str wzr, [sp]
+;   sub sp, sp, #4096
+;   str wzr, [sp]
+;   add sp, sp, #12288
 ;   sub sp, sp, #12288
 ; block0:
 ;   mov x0, sp
@@ -61,14 +65,15 @@ block0:
 ; block0: ; offset 0x0
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
-;   mov x16, #-0x1000
-;   str wzr, [sp, x16, sxtx]
-;   mov x16, #-0x2000
-;   str wzr, [sp, x16, sxtx]
-;   mov x16, #-0x3000
-;   str wzr, [sp, x16, sxtx]
+;   sub sp, sp, #1, lsl #12
+;   stur wzr, [sp]
+;   sub sp, sp, #1, lsl #12
+;   stur wzr, [sp]
+;   sub sp, sp, #1, lsl #12
+;   stur wzr, [sp]
+;   add sp, sp, #3, lsl #12
 ;   sub sp, sp, #3, lsl #12
-; block1: ; offset 0x24
+; block1: ; offset 0x28
 ;   mov x0, sp
 ;   add sp, sp, #3, lsl #12
 ;   ldp x29, x30, [sp], #0x10
diff --git a/cranelift/filetests/filetests/isa/aarch64/issue-8659.clif b/cranelift/filetests/filetests/isa/aarch64/issue-8659.clif
new file mode 100644
index 000000000000..d21ecf02f4b3
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/aarch64/issue-8659.clif
@@ -0,0 +1,16 @@
+test compile precise-output
+target aarch64
+
+function u0:11(i64 sret) system_v {
+block0(v0: i64):
+    return
+}
+
+; VCode:
+; block0:
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/aarch64/load-extends.clif b/cranelift/filetests/filetests/isa/aarch64/load-extends.clif
new file mode 100644
index 000000000000..de9240eb39bf
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/aarch64/load-extends.clif
@@ -0,0 +1,208 @@
+test compile precise-output
+set unwind_info=false
+target aarch64
+
+function %load_uextend_i8_i16(i64) -> i16 {
+block0(v0: i64):
+  v1 = load.i8 v0
+  v2 = uextend.i16 v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   ldrb w0, [x0]
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   ldrb w0, [x0] ; trap: heap_oob
+;   ret
+
+function %load_uextend_i8_i32(i64) -> i32 {
+block0(v0: i64):
+  v1 = load.i8 v0
+  v2 = uextend.i32 v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   ldrb w0, [x0]
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   ldrb w0, [x0] ; trap: heap_oob
+;   ret
+
+function %load_uextend_i8_i64(i64) -> i64 {
+block0(v0: i64):
+  v1 = load.i8 v0
+  v2 = uextend.i64 v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   ldrb w0, [x0]
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   ldrb w0, [x0] ; trap: heap_oob
+;   ret
+
+function %load_uextend_i16_i32(i64) -> i32 {
+block0(v0: i64):
+  v1 = load.i16 v0
+  v2 = uextend.i32 v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   ldrh w0, [x0]
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   ldrh w0, [x0] ; trap: heap_oob
+;   ret
+
+function %load_uextend_i16_i64(i64) -> i64 {
+block0(v0: i64):
+  v1 = load.i16 v0
+  v2 = uextend.i64 v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   ldrh w0, [x0]
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   ldrh w0, [x0] ; trap: heap_oob
+;   ret
+
+function %load_uextend_i32_i64(i64) -> i64 {
+block0(v0: i64):
+  v1 = load.i32 v0
+  v2 = uextend.i64 v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   ldr w0, [x0]
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   ldr w0, [x0] ; trap: heap_oob
+;   ret
+
+function %load_sextend_i8_i16(i64) -> i16 {
+block0(v0: i64):
+  v1 = load.i8 v0
+  v2 = sextend.i16 v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   ldrsb x0, [x0]
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   ldrsb x0, [x0] ; trap: heap_oob
+;   ret
+
+function %load_sextend_i8_i32(i64) -> i32 {
+block0(v0: i64):
+  v1 = load.i8 v0
+  v2 = sextend.i32 v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   ldrsb x0, [x0]
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   ldrsb x0, [x0] ; trap: heap_oob
+;   ret
+
+function %load_sextend_i8_i64(i64) -> i64 {
+block0(v0: i64):
+  v1 = load.i8 v0
+  v2 = sextend.i64 v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   ldrsb x0, [x0]
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   ldrsb x0, [x0] ; trap: heap_oob
+;   ret
+
+function %load_sextend_i16_i32(i64) -> i32 {
+block0(v0: i64):
+  v1 = load.i16 v0
+  v2 = sextend.i32 v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   ldrsh x0, [x0]
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   ldrsh x0, [x0] ; trap: heap_oob
+;   ret
+
+function %load_sextend_i16_i64(i64) -> i64 {
+block0(v0: i64):
+  v1 = load.i16 v0
+  v2 = sextend.i64 v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   ldrsh x0, [x0]
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   ldrsh x0, [x0] ; trap: heap_oob
+;   ret
+
+function %load_sextend_i32_i64(i64) -> i64 {
+block0(v0: i64):
+  v1 = load.i32 v0
+  v2 = sextend.i64 v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   ldrsw x0, [x0]
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   ldrsw x0, [x0] ; trap: heap_oob
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/aarch64/load-f16-f128.clif b/cranelift/filetests/filetests/isa/aarch64/load-f16-f128.clif
new file mode 100644
index 000000000000..e9d74613698b
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/aarch64/load-f16-f128.clif
@@ -0,0 +1,36 @@
+test compile precise-output
+set unwind_info=false
+target aarch64
+
+function %load_f16(i64) -> f16 {
+block0(v0: i64):
+    v1 = load.f16 v0
+    return v1
+}
+
+; VCode:
+; block0:
+;   ldr h0, [x0]
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   ldr h0, [x0] ; trap: heap_oob
+;   ret
+
+function %load_f128(i64) -> f128 {
+block0(v0: i64):
+    v1 = load.f128 v0
+    return v1
+}
+
+; VCode:
+; block0:
+;   ldr q0, [x0]
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   ldr q0, [x0] ; trap: heap_oob
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/aarch64/nan-canonicalization.clif b/cranelift/filetests/filetests/isa/aarch64/nan-canonicalization.clif
new file mode 100644
index 000000000000..8ffffcdd2d49
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/aarch64/nan-canonicalization.clif
@@ -0,0 +1,140 @@
+test compile precise-output
+set enable_nan_canonicalization=true 
+target x86_64 sse41
+
+function %f0(f32x4, f32x4) -> f32x4 {
+block0(v0: f32x4, v1: f32x4):
+	v2 = fadd v0, v1
+	return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   addps   %xmm0, %xmm1, %xmm0
+;   movl    $2143289344, %r10d
+;   movd    %r10d, %xmm7
+;   shufps  $0, %xmm7, const(0), %xmm7
+;   movdqa  %xmm0, %xmm1
+;   cmpps   $3, %xmm1, %xmm0, %xmm1
+;   movdqa  %xmm0, %xmm2
+;   movdqa  %xmm1, %xmm0
+;   movdqa  %xmm2, %xmm1
+;   pblendvb %xmm1, %xmm7, %xmm1
+;   movdqa  %xmm1, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   addps %xmm1, %xmm0
+;   movl $0x7fc00000, %r10d
+;   movd %r10d, %xmm7
+;   shufps $0, 0x26(%rip), %xmm7
+;   movdqa %xmm0, %xmm1
+;   cmpunordps %xmm0, %xmm1
+;   movdqa %xmm0, %xmm2
+;   movdqa %xmm1, %xmm0
+;   movdqa %xmm2, %xmm1
+;   pblendvb %xmm0, %xmm7, %xmm1
+;   movdqa %xmm1, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   sarb $0, (%rdi)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+
+function %f1(f64, f64) -> f64 {
+block0(v0: f64, v1: f64):
+	v2 = fadd v0, v1
+	return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   addsd   %xmm0, %xmm1, %xmm0
+;   movabsq $9221120237041090560, %r9
+;   movq    %r9, %xmm1
+;   movdqa  %xmm0, %xmm7
+;   cmppd   $3, %xmm7, %xmm0, %xmm7
+;   movdqa  %xmm0, %xmm5
+;   movdqa  %xmm7, %xmm0
+;   pblendvb %xmm5, %xmm1, %xmm5
+;   movdqa  %xmm5, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   addsd %xmm1, %xmm0
+;   movabsq $0x7ff8000000000000, %r9
+;   movq %r9, %xmm1
+;   movdqa %xmm0, %xmm7
+;   cmpunordpd %xmm0, %xmm7
+;   movdqa %xmm0, %xmm5
+;   movdqa %xmm7, %xmm0
+;   pblendvb %xmm0, %xmm1, %xmm5
+;   movdqa %xmm5, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %f1(f32, f32) -> f32 {
+block0(v0: f32, v1: f32):
+	v2 = fadd v0, v1
+	return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   addss   %xmm0, %xmm1, %xmm0
+;   movl    $2143289344, %r9d
+;   movd    %r9d, %xmm1
+;   movdqa  %xmm0, %xmm7
+;   cmpps   $3, %xmm7, %xmm0, %xmm7
+;   movdqa  %xmm0, %xmm5
+;   movdqa  %xmm7, %xmm0
+;   pblendvb %xmm5, %xmm1, %xmm5
+;   movdqa  %xmm5, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   addss %xmm1, %xmm0
+;   movl $0x7fc00000, %r9d
+;   movd %r9d, %xmm1
+;   movdqa %xmm0, %xmm7
+;   cmpunordps %xmm0, %xmm7
+;   movdqa %xmm0, %xmm5
+;   movdqa %xmm7, %xmm0
+;   pblendvb %xmm0, %xmm1, %xmm5
+;   movdqa %xmm5, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/aarch64/reftypes.clif b/cranelift/filetests/filetests/isa/aarch64/reftypes.clif
deleted file mode 100644
index 55bc5678e184..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/reftypes.clif
+++ /dev/null
@@ -1,160 +0,0 @@
-test compile precise-output
-set unwind_info=false
-target aarch64
-
-function %f0(r64) -> r64 {
-block0(v0: r64):
-  return v0
-}
-
-; VCode:
-; block0:
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   ret
-
-function %f1(r64) -> i8 {
-block0(v0: r64):
-  v1 = is_null v0
-  return v1
-}
-
-; VCode:
-; block0:
-;   subs xzr, x0, #0
-;   cset x0, eq
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   cmp x0, #0
-;   cset x0, eq
-;   ret
-
-function %f2(r64) -> i8 {
-block0(v0: r64):
-  v1 = is_invalid v0
-  return v1
-}
-
-; VCode:
-; block0:
-;   adds xzr, x0, #1
-;   cset x0, eq
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   cmn x0, #1
-;   cset x0, eq
-;   ret
-
-function %f3() -> r64 {
-block0:
-  v0 = null.r64
-  return v0
-}
-
-; VCode:
-; block0:
-;   movz x0, #0
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   mov x0, #0
-;   ret
-
-function %f4(r64, r64) -> r64, r64, r64 {
-    fn0 = %f(r64) -> i8
-    ss0 = explicit_slot 8
-
-block0(v0: r64, v1: r64):
-    v2 = call fn0(v0)
-    stack_store.r64 v0, ss0
-    brif v2, block2(v0, v1), block1(v1, v0)
-
-block1(v3: r64, v4: r64):
-    jump block3(v3, v4)
-
-block2(v5: r64, v6: r64):
-    jump block3(v5, v6)
-
-block3(v7: r64, v8: r64):
-    v9 = stack_load.r64 ss0
-    return v7, v8, v9
-}
-
-; VCode:
-;   stp fp, lr, [sp, #-16]!
-;   mov fp, sp
-;   str x24, [sp, #-16]!
-;   sub sp, sp, #32
-; block0:
-;   mov x5, x0
-;   str x1, [sp, #16]
-;   mov x0, x5
-;   mov x24, x5
-;   load_ext_name x12, TestCase(%f)+0
-;   str x24, [sp, #8]
-;   blr x12
-;   mov x11, sp
-;   mov x5, x24
-;   str x5, [x11]
-;   uxtb w12, w0
-;   cbnz x12, label2 ; b label1
-; block1:
-;   mov x1, x24
-;   ldr x0, [sp, #16]
-;   b label3
-; block2:
-;   mov x0, x24
-;   ldr x1, [sp, #16]
-;   b label3
-; block3:
-;   mov x15, sp
-;   ldr x2, [x15]
-;   add sp, sp, #32
-;   ldr x24, [sp], #16
-;   ldp fp, lr, [sp], #16
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   stp x29, x30, [sp, #-0x10]!
-;   mov x29, sp
-;   str x24, [sp, #-0x10]!
-;   sub sp, sp, #0x20
-; block1: ; offset 0x10
-;   mov x5, x0
-;   stur x1, [sp, #0x10]
-;   mov x0, x5
-;   mov x24, x5
-;   ldr x12, #0x28
-;   b #0x30
-;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %f 0
-;   .byte 0x00, 0x00, 0x00, 0x00
-;   stur x24, [sp, #8]
-;   blr x12
-;   mov x11, sp
-;   mov x5, x24
-;   str x5, [x11]
-;   uxtb w12, w0
-;   cbnz x12, #0x58
-; block2: ; offset 0x4c
-;   mov x1, x24
-;   ldur x0, [sp, #0x10]
-;   b #0x60
-; block3: ; offset 0x58
-;   mov x0, x24
-;   ldur x1, [sp, #0x10]
-; block4: ; offset 0x60
-;   mov x15, sp
-;   ldr x2, [x15]
-;   add sp, sp, #0x20
-;   ldr x24, [sp], #0x10
-;   ldp x29, x30, [sp], #0x10
-;   ret
-
diff --git a/cranelift/filetests/filetests/isa/aarch64/return-call-indirect.clif b/cranelift/filetests/filetests/isa/aarch64/return-call-indirect.clif
new file mode 100644
index 000000000000..ca0c1fcd48e7
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/aarch64/return-call-indirect.clif
@@ -0,0 +1,359 @@
+test compile precise-output
+
+target aarch64
+
+;;;; Test passing `i64`s ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+function %callee_i64(i64) -> i64 tail {
+block0(v0: i64):
+    v1 = iadd_imm.i64 v0, 10
+    return v1
+}
+
+; VCode:
+; block0:
+;   add x2, x2, #10
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   add x2, x2, #0xa
+;   ret
+
+function %call_i64(i64) -> i64 tail {
+    sig0 = (i64) -> i64 tail
+    fn0 = %callee_i64(i64) -> i64 tail
+
+block0(v0: i64):
+    v1 = func_addr.i64 fn0
+    return_call_indirect sig0, v1(v0)
+}
+
+; VCode:
+;   stp fp, lr, [sp, #-16]!
+;   mov fp, sp
+; block0:
+;   load_ext_name x1, TestCase(%callee_i64)+0
+;   return_call_ind x1 new_stack_arg_size:0 x2=x2
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stp x29, x30, [sp, #-0x10]!
+;   mov x29, sp
+; block1: ; offset 0x8
+;   ldr x1, #0x10
+;   b #0x18
+;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %callee_i64 0
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   ldp x29, x30, [sp], #0x10
+;   br x1
+
+;;;; Test colocated tail calls ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+function %colocated_i64(i64) -> i64 tail {
+    sig0 = (i64) -> i64 tail
+    fn0 = colocated %callee_i64(i64) -> i64 tail
+
+block0(v0: i64):
+    v1 = func_addr.i64 fn0
+    return_call_indirect sig0, v1(v0)
+}
+
+; VCode:
+;   stp fp, lr, [sp, #-16]!
+;   mov fp, sp
+; block0:
+;   load_ext_name x1, TestCase(%callee_i64)+0
+;   return_call_ind x1 new_stack_arg_size:0 x2=x2
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stp x29, x30, [sp, #-0x10]!
+;   mov x29, sp
+; block1: ; offset 0x8
+;   ldr x1, #0x10
+;   b #0x18
+;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %callee_i64 0
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   ldp x29, x30, [sp], #0x10
+;   br x1
+
+;;;; Test passing `f64`s ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+function %callee_f64(f64) -> f64 tail {
+block0(v0: f64):
+    v1 = f64const 0x10.0
+    v2 = fadd.f64 v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   fmov d3, #16
+;   fadd d0, d0, d3
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   fmov d3, #16.00000000
+;   fadd d0, d0, d3
+;   ret
+
+function %call_f64(f64) -> f64 tail {
+    sig0 = (f64) -> f64 tail
+    fn0 = %callee_f64(f64) -> f64 tail
+
+block0(v0: f64):
+    v1 = func_addr.i64 fn0
+    return_call_indirect sig0, v1(v0)
+}
+
+; VCode:
+;   stp fp, lr, [sp, #-16]!
+;   mov fp, sp
+; block0:
+;   load_ext_name x1, TestCase(%callee_f64)+0
+;   return_call_ind x1 new_stack_arg_size:0 v0=v0
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stp x29, x30, [sp, #-0x10]!
+;   mov x29, sp
+; block1: ; offset 0x8
+;   ldr x1, #0x10
+;   b #0x18
+;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %callee_f64 0
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   ldp x29, x30, [sp], #0x10
+;   br x1
+
+;;;; Test passing `i8`s ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+function %callee_i8(i8) -> i8 tail {
+block0(v0: i8):
+    v1 = iconst.i8 0
+    v2 = icmp eq v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   uxtb w2, w2
+;   subs wzr, w2, #0
+;   cset x2, eq
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   uxtb w2, w2
+;   cmp w2, #0
+;   cset x2, eq
+;   ret
+
+function %call_i8(i8) -> i8 tail {
+    sig0 = (i8) -> i8 tail
+    fn0 = %callee_i8(i8) -> i8 tail
+
+block0(v0: i8):
+    v1 = func_addr.i64 fn0
+    return_call_indirect sig0, v1(v0)
+}
+
+; VCode:
+;   stp fp, lr, [sp, #-16]!
+;   mov fp, sp
+; block0:
+;   load_ext_name x1, TestCase(%callee_i8)+0
+;   return_call_ind x1 new_stack_arg_size:0 x2=x2
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stp x29, x30, [sp, #-0x10]!
+;   mov x29, sp
+; block1: ; offset 0x8
+;   ldr x1, #0x10
+;   b #0x18
+;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %callee_i8 0
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   ldp x29, x30, [sp], #0x10
+;   br x1
+
+;;;; Test passing many arguments on stack ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+function %tail_caller_stack_args() -> i64 tail {
+    fn0 = %tail_callee_stack_args(i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64) -> i64 tail
+
+block0:
+    v0 = iconst.i64 10
+    v1 = iconst.i64 15
+    v2 = iconst.i64 20
+    v3 = iconst.i64 25
+    v4 = iconst.i64 30
+    v5 = iconst.i64 35
+    v6 = iconst.i64 40
+    v7 = iconst.i64 45
+    v8 = iconst.i64 50
+    v9 = iconst.i64 55
+    v10 = iconst.i64 60
+    v11 = iconst.i64 65
+    v12 = iconst.i64 70
+    v13 = iconst.i64 75
+    v14 = iconst.i64 80
+    v15 = iconst.i64 85
+    v16 = iconst.i64 90
+    v17 = iconst.i64 95
+    v18 = iconst.i64 100
+    v19 = iconst.i64 105
+    v20 = iconst.i64 110
+    v21 = iconst.i64 115
+    v22 = iconst.i64 120
+    v23 = iconst.i64 125
+    v24 = iconst.i64 130
+    v25 = iconst.i64 135
+    v26 = func_addr.i64 fn0
+    return_call_indirect sig0, v26(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25)
+}
+
+; VCode:
+;   stp fp, lr, [sp, #-16]!
+;   mov fp, sp
+;   sub sp, sp, #160
+;   ldr fp, [sp, #160]
+;   stp fp, lr, [sp]
+;   mov fp, sp
+;   stp x27, x28, [sp, #-16]!
+;   stp x25, x26, [sp, #-16]!
+;   stp x23, x24, [sp, #-16]!
+;   stp x21, x22, [sp, #-16]!
+;   stp x19, x20, [sp, #-16]!
+;   sub sp, sp, #16
+; block0:
+;   movz x3, #10
+;   str x3, [sp]
+;   movz x3, #15
+;   movz x4, #20
+;   movz x5, #25
+;   movz x6, #30
+;   movz x7, #35
+;   movz x10, #40
+;   movz x11, #45
+;   movz x12, #50
+;   movz x13, #55
+;   movz x14, #60
+;   movz x15, #65
+;   movz x0, #70
+;   movz x1, #75
+;   movz x8, #80
+;   movz x9, #85
+;   movz x26, #90
+;   movz x27, #95
+;   movz x28, #100
+;   movz x21, #105
+;   movz x19, #110
+;   movz x20, #115
+;   movz x22, #120
+;   movz x23, #125
+;   movz x24, #130
+;   movz x25, #135
+;   load_ext_name x2, TestCase(%tail_callee_stack_args)+0
+;   str x10, [sp, #112]
+;   str x11, [sp, #120]
+;   str x12, [sp, #128]
+;   str x13, [sp, #136]
+;   str x14, [sp, #144]
+;   str x15, [sp, #152]
+;   str x0, [sp, #160]
+;   str x1, [sp, #168]
+;   str x8, [sp, #176]
+;   str x9, [sp, #184]
+;   str x26, [sp, #192]
+;   str x27, [sp, #200]
+;   str x28, [sp, #208]
+;   str x21, [sp, #216]
+;   str x19, [sp, #224]
+;   str x20, [sp, #232]
+;   str x22, [sp, #240]
+;   str x23, [sp, #248]
+;   str x24, [sp, #256]
+;   str x25, [sp, #264]
+;   mov x1, x2
+;   ldr x2, [sp]
+;   return_call_ind x1 new_stack_arg_size:160 x2=x2 x3=x3 x4=x4 x5=x5 x6=x6 x7=x7
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stp x29, x30, [sp, #-0x10]!
+;   mov x29, sp
+;   sub sp, sp, #0xa0
+;   ldur x29, [sp, #0xa0]
+;   stp x29, x30, [sp]
+;   mov x29, sp
+;   stp x27, x28, [sp, #-0x10]!
+;   stp x25, x26, [sp, #-0x10]!
+;   stp x23, x24, [sp, #-0x10]!
+;   stp x21, x22, [sp, #-0x10]!
+;   stp x19, x20, [sp, #-0x10]!
+;   sub sp, sp, #0x10
+; block1: ; offset 0x30
+;   mov x3, #0xa
+;   stur x3, [sp]
+;   mov x3, #0xf
+;   mov x4, #0x14
+;   mov x5, #0x19
+;   mov x6, #0x1e
+;   mov x7, #0x23
+;   mov x10, #0x28
+;   mov x11, #0x2d
+;   mov x12, #0x32
+;   mov x13, #0x37
+;   mov x14, #0x3c
+;   mov x15, #0x41
+;   mov x0, #0x46
+;   mov x1, #0x4b
+;   mov x8, #0x50
+;   mov x9, #0x55
+;   mov x26, #0x5a
+;   mov x27, #0x5f
+;   mov x28, #0x64
+;   mov x21, #0x69
+;   mov x19, #0x6e
+;   mov x20, #0x73
+;   mov x22, #0x78
+;   mov x23, #0x7d
+;   mov x24, #0x82
+;   mov x25, #0x87
+;   ldr x2, #0xa4
+;   b #0xac
+;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %tail_callee_stack_args 0
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   stur x10, [sp, #0x70]
+;   stur x11, [sp, #0x78]
+;   stur x12, [sp, #0x80]
+;   stur x13, [sp, #0x88]
+;   stur x14, [sp, #0x90]
+;   stur x15, [sp, #0x98]
+;   stur x0, [sp, #0xa0]
+;   stur x1, [sp, #0xa8]
+;   stur x8, [sp, #0xb0]
+;   stur x9, [sp, #0xb8]
+;   stur x26, [sp, #0xc0]
+;   stur x27, [sp, #0xc8]
+;   stur x28, [sp, #0xd0]
+;   stur x21, [sp, #0xd8]
+;   stur x19, [sp, #0xe0]
+;   stur x20, [sp, #0xe8]
+;   stur x22, [sp, #0xf0]
+;   stur x23, [sp, #0xf8]
+;   str x24, [sp, #0x100]
+;   str x25, [sp, #0x108]
+;   mov x1, x2
+;   ldur x2, [sp]
+;   add sp, sp, #0x10
+;   ldp x19, x20, [sp], #0x10
+;   ldp x21, x22, [sp], #0x10
+;   ldp x23, x24, [sp], #0x10
+;   ldp x25, x26, [sp], #0x10
+;   ldp x27, x28, [sp], #0x10
+;   ldp x29, x30, [sp], #0x10
+;   br x1
+
diff --git a/cranelift/filetests/filetests/isa/aarch64/return-call.clif b/cranelift/filetests/filetests/isa/aarch64/return-call.clif
index ebcc8a1e309b..46a9ce746ca3 100644
--- a/cranelift/filetests/filetests/isa/aarch64/return-call.clif
+++ b/cranelift/filetests/filetests/isa/aarch64/return-call.clif
@@ -31,22 +31,20 @@ block0(v0: i64):
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
 ; block0:
-;   load_ext_name x3, TestCase(%callee_i64)+0
-;   return_call_ind x3 old_stack_arg_size:0 new_stack_arg_size:0 x2=x2
+;   load_ext_name x1, TestCase(%callee_i64)+0
+;   return_call_ind x1 new_stack_arg_size:0 x2=x2
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
 ; block1: ; offset 0x8
-;   ldr x3, #0x10
+;   ldr x1, #0x10
 ;   b #0x18
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %callee_i64 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   ldp x16, x30, [x29]
-;   add sp, x29, #0x10
-;   mov x29, x16
-;   br x3
+;   ldp x29, x30, [sp], #0x10
+;   br x1
 
 ;;;; Test colocated tail calls ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
@@ -61,17 +59,15 @@ block0(v0: i64):
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
 ; block0:
-;   return_call TestCase(%callee_i64) old_stack_arg_size:0 new_stack_arg_size:0 x2=x2
+;   return_call TestCase(%callee_i64) new_stack_arg_size:0 x2=x2
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
 ; block1: ; offset 0x8
-;   ldp x16, x30, [x29]
-;   add sp, x29, #0x10
-;   mov x29, x16
-;   b #0x14 ; reloc_external Call %callee_i64 0
+;   ldp x29, x30, [sp], #0x10
+;   b #0xc ; reloc_external Call %callee_i64 0
 
 ;;;; Test passing `f64`s ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
@@ -105,22 +101,20 @@ block0(v0: f64):
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
 ; block0:
-;   load_ext_name x2, TestCase(%callee_f64)+0
-;   return_call_ind x2 old_stack_arg_size:0 new_stack_arg_size:0 v0=v0
+;   load_ext_name x1, TestCase(%callee_f64)+0
+;   return_call_ind x1 new_stack_arg_size:0 v0=v0
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
 ; block1: ; offset 0x8
-;   ldr x2, #0x10
+;   ldr x1, #0x10
 ;   b #0x18
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %callee_f64 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   ldp x16, x30, [x29]
-;   add sp, x29, #0x10
-;   mov x29, x16
-;   br x2
+;   ldp x29, x30, [sp], #0x10
+;   br x1
 
 ;;;; Test passing `i8`s ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
@@ -156,22 +150,20 @@ block0(v0: i8):
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
 ; block0:
-;   load_ext_name x3, TestCase(%callee_i8)+0
-;   return_call_ind x3 old_stack_arg_size:0 new_stack_arg_size:0 x2=x2
+;   load_ext_name x1, TestCase(%callee_i8)+0
+;   return_call_ind x1 new_stack_arg_size:0 x2=x2
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
 ; block1: ; offset 0x8
-;   ldr x3, #0x10
+;   ldr x1, #0x10
 ;   b #0x18
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %callee_i8 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   ldp x16, x30, [x29]
-;   add sp, x29, #0x10
-;   mov x29, x16
-;   br x3
+;   ldp x29, x30, [sp], #0x10
+;   br x1
 
 ;;;; Test passing many arguments on stack ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
@@ -184,10 +176,9 @@ block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64, v6: i64, v7: i64, v
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
 ; block0:
-;   ldr x9, [fp, #16]
-;   ldr x2, [fp, #24]
+;   ldr x2, [sp, #168]
 ;   ldp fp, lr, [sp], #16
-;   add sp, sp, #16
+;   add sp, sp, #160
 ;   ret
 ;
 ; Disassembled:
@@ -195,10 +186,9 @@ block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64, v6: i64, v7: i64, v
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
 ; block1: ; offset 0x8
-;   ldur x9, [x29, #0x10]
-;   ldur x2, [x29, #0x18]
+;   ldur x2, [sp, #0xa8]
 ;   ldp x29, x30, [sp], #0x10
-;   add sp, sp, #0x10
+;   add sp, sp, #0xa0
 ;   ret
 
 function %tail_caller_stack_args() -> i64 tail {
@@ -237,6 +227,15 @@ block0:
 ; VCode:
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
+;   sub sp, sp, #160
+;   ldr fp, [sp, #160]
+;   stp fp, lr, [sp]
+;   mov fp, sp
+;   stp x27, x28, [sp, #-16]!
+;   stp x25, x26, [sp, #-16]!
+;   stp x23, x24, [sp, #-16]!
+;   stp x21, x22, [sp, #-16]!
+;   stp x19, x20, [sp, #-16]!
 ; block0:
 ;   movz x2, #10
 ;   movz x3, #15
@@ -244,79 +243,120 @@ block0:
 ;   movz x5, #25
 ;   movz x6, #30
 ;   movz x7, #35
-;   movz x8, #40
-;   movz x9, #45
-;   movz x10, #50
-;   movz x11, #55
-;   movz x12, #60
-;   movz x13, #65
-;   movz x14, #70
-;   movz x15, #75
-;   movz x19, #80
-;   movz x20, #85
-;   movz x21, #90
-;   movz x22, #95
-;   movz x23, #100
-;   movz x24, #105
-;   movz x25, #110
-;   movz x26, #115
-;   movz x27, #120
-;   movz x28, #125
-;   movz x0, #130
-;   movz x1, #135
-;   sub sp, sp, #16
-;   virtual_sp_offset_adjust 16
-;   str x0, [sp]
-;   str x1, [sp, #8]
-;   load_ext_name x0, TestCase(%tail_callee_stack_args)+0
-;   return_call_ind x0 old_stack_arg_size:0 new_stack_arg_size:16 x2=x2 x3=x3 x4=x4 x5=x5 x6=x6 x7=x7 x8=x8 x9=x9 x10=x10 x11=x11 x12=x12 x13=x13 x14=x14 x15=x15 x19=x19 x20=x20 x21=x21 x22=x22 x23=x23 x24=x24 x25=x25 x26=x26 x27=x27 x28=x28
+;   movz x10, #40
+;   movz x11, #45
+;   movz x12, #50
+;   movz x13, #55
+;   movz x14, #60
+;   movz x15, #65
+;   movz x0, #70
+;   movz x1, #75
+;   movz x8, #80
+;   movz x9, #85
+;   movz x26, #90
+;   movz x27, #95
+;   movz x28, #100
+;   movz x21, #105
+;   movz x19, #110
+;   movz x20, #115
+;   movz x22, #120
+;   movz x23, #125
+;   movz x24, #130
+;   movz x25, #135
+;   str x10, [sp, #96]
+;   str x11, [sp, #104]
+;   str x12, [sp, #112]
+;   str x13, [sp, #120]
+;   str x14, [sp, #128]
+;   str x15, [sp, #136]
+;   str x0, [sp, #144]
+;   str x1, [sp, #152]
+;   str x8, [sp, #160]
+;   str x9, [sp, #168]
+;   str x26, [sp, #176]
+;   str x27, [sp, #184]
+;   str x28, [sp, #192]
+;   str x21, [sp, #200]
+;   str x19, [sp, #208]
+;   str x20, [sp, #216]
+;   str x22, [sp, #224]
+;   str x23, [sp, #232]
+;   str x24, [sp, #240]
+;   str x25, [sp, #248]
+;   load_ext_name x1, TestCase(%tail_callee_stack_args)+0
+;   return_call_ind x1 new_stack_arg_size:160 x2=x2 x3=x3 x4=x4 x5=x5 x6=x6 x7=x7
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
-; block1: ; offset 0x8
+;   sub sp, sp, #0xa0
+;   ldur x29, [sp, #0xa0]
+;   stp x29, x30, [sp]
+;   mov x29, sp
+;   stp x27, x28, [sp, #-0x10]!
+;   stp x25, x26, [sp, #-0x10]!
+;   stp x23, x24, [sp, #-0x10]!
+;   stp x21, x22, [sp, #-0x10]!
+;   stp x19, x20, [sp, #-0x10]!
+; block1: ; offset 0x2c
 ;   mov x2, #0xa
 ;   mov x3, #0xf
 ;   mov x4, #0x14
 ;   mov x5, #0x19
 ;   mov x6, #0x1e
 ;   mov x7, #0x23
-;   mov x8, #0x28
-;   mov x9, #0x2d
-;   mov x10, #0x32
-;   mov x11, #0x37
-;   mov x12, #0x3c
-;   mov x13, #0x41
-;   mov x14, #0x46
-;   mov x15, #0x4b
-;   mov x19, #0x50
-;   mov x20, #0x55
-;   mov x21, #0x5a
-;   mov x22, #0x5f
-;   mov x23, #0x64
-;   mov x24, #0x69
-;   mov x25, #0x6e
-;   mov x26, #0x73
-;   mov x27, #0x78
-;   mov x28, #0x7d
-;   mov x0, #0x82
-;   mov x1, #0x87
-;   sub sp, sp, #0x10
-;   stur x0, [sp]
-;   stur x1, [sp, #8]
-;   ldr x0, #0x84
-;   b #0x8c
+;   mov x10, #0x28
+;   mov x11, #0x2d
+;   mov x12, #0x32
+;   mov x13, #0x37
+;   mov x14, #0x3c
+;   mov x15, #0x41
+;   mov x0, #0x46
+;   mov x1, #0x4b
+;   mov x8, #0x50
+;   mov x9, #0x55
+;   mov x26, #0x5a
+;   mov x27, #0x5f
+;   mov x28, #0x64
+;   mov x21, #0x69
+;   mov x19, #0x6e
+;   mov x20, #0x73
+;   mov x22, #0x78
+;   mov x23, #0x7d
+;   mov x24, #0x82
+;   mov x25, #0x87
+;   stur x10, [sp, #0x60]
+;   stur x11, [sp, #0x68]
+;   stur x12, [sp, #0x70]
+;   stur x13, [sp, #0x78]
+;   stur x14, [sp, #0x80]
+;   stur x15, [sp, #0x88]
+;   stur x0, [sp, #0x90]
+;   stur x1, [sp, #0x98]
+;   stur x8, [sp, #0xa0]
+;   stur x9, [sp, #0xa8]
+;   stur x26, [sp, #0xb0]
+;   stur x27, [sp, #0xb8]
+;   stur x28, [sp, #0xc0]
+;   stur x21, [sp, #0xc8]
+;   stur x19, [sp, #0xd0]
+;   stur x20, [sp, #0xd8]
+;   stur x22, [sp, #0xe0]
+;   stur x23, [sp, #0xe8]
+;   stur x24, [sp, #0xf0]
+;   stur x25, [sp, #0xf8]
+;   ldr x1, #0xec
+;   b #0xf4
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %tail_callee_stack_args 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   ldp x16, x30, [x29]
-;   ldur x17, [sp, #8]
-;   stur x17, [x29, #8]
-;   ldur x17, [sp]
-;   stur x17, [x29]
-;   mov sp, x29
-;   mov x29, x16
-;   br x0
+;   ldp x19, x20, [sp], #0x10
+;   ldp x21, x22, [sp], #0x10
+;   ldp x23, x24, [sp], #0x10
+;   ldp x25, x26, [sp], #0x10
+;   ldp x27, x28, [sp], #0x10
+;   ldp x29, x30, [sp], #0x10
+;   br x1
 
 ;;;; Test diff blocks with diff return calls with diff # of stack args ;;;;;;;;;
 
@@ -329,10 +369,9 @@ block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64, v6: i64, v7: i64, v
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
 ; block0:
-;   ldr x9, [fp, #16]
-;   ldr x2, [fp, #24]
+;   ldr x2, [sp, #168]
 ;   ldp fp, lr, [sp], #16
-;   add sp, sp, #16
+;   add sp, sp, #160
 ;   ret
 ;
 ; Disassembled:
@@ -340,10 +379,9 @@ block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64, v6: i64, v7: i64, v
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
 ; block1: ; offset 0x8
-;   ldur x9, [x29, #0x10]
-;   ldur x2, [x29, #0x18]
+;   ldur x2, [sp, #0xa8]
 ;   ldp x29, x30, [sp], #0x10
-;   add sp, sp, #0x10
+;   add sp, sp, #0xa0
 ;   ret
 
 function %different_callee2(i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64) -> i64 tail {
@@ -355,11 +393,9 @@ block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64, v6: i64, v7: i64, v
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
 ; block0:
-;   ldr x9, [fp, #16]
-;   ldr x11, [fp, #24]
-;   ldr x2, [fp, #32]
+;   ldr x2, [sp, #176]
 ;   ldp fp, lr, [sp], #16
-;   add sp, sp, #32
+;   add sp, sp, #176
 ;   ret
 ;
 ; Disassembled:
@@ -367,11 +403,9 @@ block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64, v6: i64, v7: i64, v
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
 ; block1: ; offset 0x8
-;   ldur x9, [x29, #0x10]
-;   ldur x11, [x29, #0x18]
-;   ldur x2, [x29, #0x20]
+;   ldur x2, [sp, #0xb0]
 ;   ldp x29, x30, [sp], #0x10
-;   add sp, sp, #0x20
+;   add sp, sp, #0xb0
 ;   ret
 
 function %caller_of_different_callees(i64) -> i64 tail {
@@ -418,127 +452,208 @@ block2:
 ; VCode:
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
+;   sub sp, sp, #176
+;   ldr fp, [sp, #176]
+;   stp fp, lr, [sp]
+;   mov fp, sp
+;   stp x27, x28, [sp, #-16]!
+;   stp x25, x26, [sp, #-16]!
+;   stp x23, x24, [sp, #-16]!
+;   stp x21, x22, [sp, #-16]!
+;   stp x19, x20, [sp, #-16]!
 ;   sub sp, sp, #16
 ; block0:
-;   movz x14, #10
-;   str x14, [sp]
+;   movz x3, #10
+;   str x3, [sp]
 ;   movz x3, #15
 ;   movz x4, #20
 ;   movz x5, #25
 ;   movz x6, #30
 ;   movz x7, #35
-;   movz x8, #40
-;   movz x9, #45
-;   movz x10, #50
-;   movz x11, #55
-;   movz x12, #60
-;   movz x13, #65
-;   movz x14, #70
-;   movz x15, #75
-;   movz x19, #80
-;   movz x20, #85
-;   movz x21, #90
-;   movz x22, #95
-;   movz x23, #100
-;   movz x24, #105
-;   movz x25, #110
-;   movz x26, #115
-;   movz x27, #120
-;   movz x28, #125
-;   movz x1, #130
-;   movz x0, #135
+;   movz x25, #40
+;   movz x21, #45
+;   movz x28, #50
+;   movz x27, #55
+;   movz x26, #60
+;   movz x24, #65
+;   movz x23, #70
+;   movz x22, #75
+;   movz x20, #80
+;   movz x19, #85
+;   movz x13, #90
+;   movz x12, #95
+;   movz x11, #100
+;   movz x10, #105
+;   movz x9, #110
+;   movz x8, #115
+;   movz x1, #120
+;   movz x0, #125
+;   movz x15, #130
+;   movz x14, #135
 ;   cbnz x2, label2 ; b label1
 ; block1:
 ;   movz x2, #140
-;   sub sp, sp, #32
-;   virtual_sp_offset_adjust 32
-;   str x1, [sp]
-;   str x0, [sp, #8]
-;   str x2, [sp, #16]
-;   load_ext_name x0, TestCase(%different_callee2)+0
-;   ldr x2, [sp, #32]
-;   return_call_ind x0 old_stack_arg_size:0 new_stack_arg_size:32 x2=x2 x3=x3 x4=x4 x5=x5 x6=x6 x7=x7 x8=x8 x9=x9 x10=x10 x11=x11 x12=x12 x13=x13 x14=x14 x15=x15 x19=x19 x20=x20 x21=x21 x22=x22 x23=x23 x24=x24 x25=x25 x26=x26 x27=x27 x28=x28
+;   str x25, [sp, #112]
+;   str x21, [sp, #120]
+;   str x28, [sp, #128]
+;   str x27, [sp, #136]
+;   str x26, [sp, #144]
+;   str x24, [sp, #152]
+;   str x23, [sp, #160]
+;   str x22, [sp, #168]
+;   str x20, [sp, #176]
+;   str x19, [sp, #184]
+;   str x13, [sp, #192]
+;   str x12, [sp, #200]
+;   str x11, [sp, #208]
+;   str x10, [sp, #216]
+;   str x9, [sp, #224]
+;   str x8, [sp, #232]
+;   str x1, [sp, #240]
+;   str x0, [sp, #248]
+;   str x15, [sp, #256]
+;   str x14, [sp, #264]
+;   str x2, [sp, #272]
+;   load_ext_name x1, TestCase(%different_callee2)+0
+;   ldr x2, [sp]
+;   return_call_ind x1 new_stack_arg_size:176 x2=x2 x3=x3 x4=x4 x5=x5 x6=x6 x7=x7
 ; block2:
 ;   ldr x2, [sp]
-;   sub sp, sp, #16
-;   virtual_sp_offset_adjust 16
-;   str x1, [sp]
-;   str x0, [sp, #8]
-;   load_ext_name x0, TestCase(%different_callee1)+0
-;   return_call_ind x0 old_stack_arg_size:0 new_stack_arg_size:16 x2=x2 x3=x3 x4=x4 x5=x5 x6=x6 x7=x7 x8=x8 x9=x9 x10=x10 x11=x11 x12=x12 x13=x13 x14=x14 x15=x15 x19=x19 x20=x20 x21=x21 x22=x22 x23=x23 x24=x24 x25=x25 x26=x26 x27=x27 x28=x28
+;   str x25, [sp, #128]
+;   str x21, [sp, #136]
+;   str x28, [sp, #144]
+;   str x27, [sp, #152]
+;   str x26, [sp, #160]
+;   str x24, [sp, #168]
+;   str x23, [sp, #176]
+;   str x22, [sp, #184]
+;   str x20, [sp, #192]
+;   str x19, [sp, #200]
+;   str x13, [sp, #208]
+;   str x12, [sp, #216]
+;   str x11, [sp, #224]
+;   str x10, [sp, #232]
+;   str x9, [sp, #240]
+;   str x8, [sp, #248]
+;   str x1, [sp, #256]
+;   str x0, [sp, #264]
+;   str x15, [sp, #272]
+;   str x14, [sp, #280]
+;   load_ext_name x1, TestCase(%different_callee1)+0
+;   return_call_ind x1 new_stack_arg_size:160 x2=x2 x3=x3 x4=x4 x5=x5 x6=x6 x7=x7
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
+;   sub sp, sp, #0xb0
+;   ldur x29, [sp, #0xb0]
+;   stp x29, x30, [sp]
+;   mov x29, sp
+;   stp x27, x28, [sp, #-0x10]!
+;   stp x25, x26, [sp, #-0x10]!
+;   stp x23, x24, [sp, #-0x10]!
+;   stp x21, x22, [sp, #-0x10]!
+;   stp x19, x20, [sp, #-0x10]!
 ;   sub sp, sp, #0x10
-; block1: ; offset 0xc
-;   mov x14, #0xa
-;   stur x14, [sp]
+; block1: ; offset 0x30
+;   mov x3, #0xa
+;   stur x3, [sp]
 ;   mov x3, #0xf
 ;   mov x4, #0x14
 ;   mov x5, #0x19
 ;   mov x6, #0x1e
 ;   mov x7, #0x23
-;   mov x8, #0x28
-;   mov x9, #0x2d
-;   mov x10, #0x32
-;   mov x11, #0x37
-;   mov x12, #0x3c
-;   mov x13, #0x41
-;   mov x14, #0x46
-;   mov x15, #0x4b
-;   mov x19, #0x50
-;   mov x20, #0x55
-;   mov x21, #0x5a
-;   mov x22, #0x5f
-;   mov x23, #0x64
-;   mov x24, #0x69
-;   mov x25, #0x6e
-;   mov x26, #0x73
-;   mov x27, #0x78
-;   mov x28, #0x7d
-;   mov x1, #0x82
-;   mov x0, #0x87
-;   cbnz x2, #0xd4
-; block2: ; offset 0x7c
+;   mov x25, #0x28
+;   mov x21, #0x2d
+;   mov x28, #0x32
+;   mov x27, #0x37
+;   mov x26, #0x3c
+;   mov x24, #0x41
+;   mov x23, #0x46
+;   mov x22, #0x4b
+;   mov x20, #0x50
+;   mov x19, #0x55
+;   mov x13, #0x5a
+;   mov x12, #0x5f
+;   mov x11, #0x64
+;   mov x10, #0x69
+;   mov x9, #0x6e
+;   mov x8, #0x73
+;   mov x1, #0x78
+;   mov x0, #0x7d
+;   mov x15, #0x82
+;   mov x14, #0x87
+;   cbnz x2, #0x12c
+; block2: ; offset 0xa0
 ;   mov x2, #0x8c
-;   sub sp, sp, #0x20
-;   stur x1, [sp]
-;   stur x0, [sp, #8]
-;   stur x2, [sp, #0x10]
-;   ldr x0, #0x98
-;   b #0xa0
+;   stur x25, [sp, #0x70]
+;   stur x21, [sp, #0x78]
+;   stur x28, [sp, #0x80]
+;   stur x27, [sp, #0x88]
+;   stur x26, [sp, #0x90]
+;   stur x24, [sp, #0x98]
+;   stur x23, [sp, #0xa0]
+;   stur x22, [sp, #0xa8]
+;   stur x20, [sp, #0xb0]
+;   stur x19, [sp, #0xb8]
+;   stur x13, [sp, #0xc0]
+;   stur x12, [sp, #0xc8]
+;   stur x11, [sp, #0xd0]
+;   stur x10, [sp, #0xd8]
+;   stur x9, [sp, #0xe0]
+;   stur x8, [sp, #0xe8]
+;   stur x1, [sp, #0xf0]
+;   stur x0, [sp, #0xf8]
+;   str x15, [sp, #0x100]
+;   str x14, [sp, #0x108]
+;   str x2, [sp, #0x110]
+;   ldr x1, #0x100
+;   b #0x108
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %different_callee2 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   ldur x2, [sp, #0x20]
-;   ldp x16, x30, [x29]
-;   ldur x17, [sp, #0x18]
-;   stur x17, [x29, #8]
-;   ldur x17, [sp, #0x10]
-;   stur x17, [x29]
-;   ldur x17, [sp, #8]
-;   stur x17, [x29, #-8]
-;   ldur x17, [sp]
-;   stur x17, [x29, #-0x10]
-;   sub sp, x29, #0x10
-;   mov x29, x16
-;   br x0
-; block3: ; offset 0xd4
 ;   ldur x2, [sp]
-;   sub sp, sp, #0x10
-;   stur x1, [sp]
-;   stur x0, [sp, #8]
-;   ldr x0, #0xec
-;   b #0xf4
+;   add sp, sp, #0x10
+;   ldp x19, x20, [sp], #0x10
+;   ldp x21, x22, [sp], #0x10
+;   ldp x23, x24, [sp], #0x10
+;   ldp x25, x26, [sp], #0x10
+;   ldp x27, x28, [sp], #0x10
+;   ldp x29, x30, [sp], #0x10
+;   br x1
+; block3: ; offset 0x12c
+;   ldur x2, [sp]
+;   stur x25, [sp, #0x80]
+;   stur x21, [sp, #0x88]
+;   stur x28, [sp, #0x90]
+;   stur x27, [sp, #0x98]
+;   stur x26, [sp, #0xa0]
+;   stur x24, [sp, #0xa8]
+;   stur x23, [sp, #0xb0]
+;   stur x22, [sp, #0xb8]
+;   stur x20, [sp, #0xc0]
+;   stur x19, [sp, #0xc8]
+;   stur x13, [sp, #0xd0]
+;   stur x12, [sp, #0xd8]
+;   stur x11, [sp, #0xe0]
+;   stur x10, [sp, #0xe8]
+;   stur x9, [sp, #0xf0]
+;   stur x8, [sp, #0xf8]
+;   str x1, [sp, #0x100]
+;   str x0, [sp, #0x108]
+;   str x15, [sp, #0x110]
+;   str x14, [sp, #0x118]
+;   ldr x1, #0x188
+;   b #0x190
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %different_callee1 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   ldp x16, x30, [x29]
-;   ldur x17, [sp, #8]
-;   stur x17, [x29, #8]
-;   ldur x17, [sp]
-;   stur x17, [x29]
-;   mov sp, x29
-;   mov x29, x16
-;   br x0
+;   add sp, sp, #0x10
+;   ldp x19, x20, [sp], #0x10
+;   ldp x21, x22, [sp], #0x10
+;   ldp x23, x24, [sp], #0x10
+;   ldp x25, x26, [sp], #0x10
+;   ldp x27, x28, [sp], #0x10
+;   ldp x29, x30, [sp], #0x10
+;   add sp, sp, #0x10
+;   br x1
 
diff --git a/cranelift/filetests/filetests/isa/aarch64/select-fp16.clif b/cranelift/filetests/filetests/isa/aarch64/select-fp16.clif
new file mode 100644
index 000000000000..a8fd9aee97ee
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/aarch64/select-fp16.clif
@@ -0,0 +1,21 @@
+test compile precise-output
+target aarch64 has_fp16
+
+function %select_f16(i8, f16, f16) -> f16 {
+block0(v0: i8, v1: f16, v2: f16):
+    v3 = select.f16 v0, v1, v2
+    return v3
+}
+
+; VCode:
+; block0:
+;   ands wzr, w0, #255
+;   fcsel h0, h0, h1, ne
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   tst w0, #0xff
+;   fcsel h0, h0, h1, ne
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/aarch64/select.clif b/cranelift/filetests/filetests/isa/aarch64/select.clif
index af780b7da72c..27dbee27e4e1 100644
--- a/cranelift/filetests/filetests/isa/aarch64/select.clif
+++ b/cranelift/filetests/filetests/isa/aarch64/select.clif
@@ -41,3 +41,78 @@ block0(v0: f32, v1: f32, v2: i64, v3: i64):
 ;   csel x0, x0, x1, eq
 ;   ret
 
+function %select_f16(i8, f16, f16) -> f16 {
+block0(v0: i8, v1: f16, v2: f16):
+    v3 = select.f16 v0, v1, v2
+    return v3
+}
+
+; VCode:
+; block0:
+;   ands wzr, w0, #255
+;   fcsel s0, s0, s1, ne
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   tst w0, #0xff
+;   fcsel s0, s0, s1, ne
+;   ret
+
+function %select_f32(i8, f32, f32) -> f32 {
+block0(v0: i8, v1: f32, v2: f32):
+    v3 = select.f32 v0, v1, v2
+    return v3
+}
+
+; VCode:
+; block0:
+;   ands wzr, w0, #255
+;   fcsel s0, s0, s1, ne
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   tst w0, #0xff
+;   fcsel s0, s0, s1, ne
+;   ret
+
+function %select_f64(i8, f64, f64) -> f64 {
+block0(v0: i8, v1: f64, v2: f64):
+    v3 = select.f64 v0, v1, v2
+    return v3
+}
+
+; VCode:
+; block0:
+;   ands wzr, w0, #255
+;   fcsel d0, d0, d1, ne
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   tst w0, #0xff
+;   fcsel d0, d0, d1, ne
+;   ret
+
+function %select_f128(i8, f128, f128) -> f128 {
+block0(v0: i8, v1: f128, v2: f128):
+    v3 = select.f128 v0, v1, v2
+    return v3
+}
+
+; VCode:
+; block0:
+;   ands wzr, w0, #255
+;   vcsel v0.16b, v0.16b, v1.16b, ne (if-then-else diamond)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   tst w0, #0xff
+;   b.ne #0x10
+;   mov v0.16b, v1.16b
+;   b #0x14
+;   mov v0.16b, v0.16b
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/aarch64/shuffle.clif b/cranelift/filetests/filetests/isa/aarch64/shuffle.clif
index d22518b02aeb..b20ceee6d052 100644
--- a/cranelift/filetests/filetests/isa/aarch64/shuffle.clif
+++ b/cranelift/filetests/filetests/isa/aarch64/shuffle.clif
@@ -10,17 +10,17 @@ block0(v0: i8x16, v1: i8x16):
 
 ; VCode:
 ; block0:
+;   ldr q3, [const(0)]
 ;   mov v30.16b, v0.16b
 ;   mov v31.16b, v1.16b
-;   ldr q3, [const(0)]
 ;   tbl v0.16b, { v30.16b, v31.16b }, v3.16b
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
+;   ldr q3, #0x20
 ;   mov v30.16b, v0.16b
 ;   mov v31.16b, v1.16b
-;   ldr q3, #0x20
 ;   tbl v0.16b, {v30.16b, v31.16b}, v3.16b
 ;   ret
 ;   .byte 0x00, 0x00, 0x00, 0x00
@@ -541,17 +541,17 @@ block0(v0: i8x16, v1: i8x16):
 
 ; VCode:
 ; block0:
+;   ldr q3, [const(0)]
 ;   mov v30.16b, v0.16b
 ;   mov v31.16b, v1.16b
-;   ldr q3, [const(0)]
 ;   tbl v0.16b, { v30.16b, v31.16b }, v3.16b
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
+;   ldr q3, #0x20
 ;   mov v30.16b, v0.16b
 ;   mov v31.16b, v1.16b
-;   ldr q3, #0x20
 ;   tbl v0.16b, {v30.16b, v31.16b}, v3.16b
 ;   ret
 ;   .byte 0x00, 0x00, 0x00, 0x00
diff --git a/cranelift/filetests/filetests/isa/aarch64/simd-lane-access-compile.clif b/cranelift/filetests/filetests/isa/aarch64/simd-lane-access-compile.clif
index d437f897a324..c855573ed727 100644
--- a/cranelift/filetests/filetests/isa/aarch64/simd-lane-access-compile.clif
+++ b/cranelift/filetests/filetests/isa/aarch64/simd-lane-access-compile.clif
@@ -176,7 +176,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldr w3, [x0]
+;   ldr w3, [x0] ; trap: heap_oob
 ;   fmov s0, w3
 ;   ret
 
diff --git a/cranelift/filetests/filetests/isa/aarch64/simd-narrow.clif b/cranelift/filetests/filetests/isa/aarch64/simd-narrow.clif
index f8bb1410c2a5..da19dff51b0f 100644
--- a/cranelift/filetests/filetests/isa/aarch64/simd-narrow.clif
+++ b/cranelift/filetests/filetests/isa/aarch64/simd-narrow.clif
@@ -10,16 +10,14 @@ block0(v0: i16x4, v1: i16x4):
 
 ; VCode:
 ; block0:
-;   mov v3.16b, v0.16b
-;   mov v3.d[1], v3.d[1], v1.d[0]
-;   sqxtn v0.8b, v3.8h
+;   mov v0.d[1], v0.d[1], v1.d[0]
+;   sqxtn v0.8b, v0.8h
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mov v3.16b, v0.16b
-;   mov v3.d[1], v1.d[0]
-;   sqxtn v0.8b, v3.8h
+;   mov v0.d[1], v1.d[0]
+;   sqxtn v0.8b, v0.8h
 ;   ret
 
 function %snarrow_i16x8(i16x8, i16x8) -> i8x16 {
@@ -48,16 +46,14 @@ block0(v0: i32x2, v1: i32x2):
 
 ; VCode:
 ; block0:
-;   mov v3.16b, v0.16b
-;   mov v3.d[1], v3.d[1], v1.d[0]
-;   sqxtn v0.4h, v3.4s
+;   mov v0.d[1], v0.d[1], v1.d[0]
+;   sqxtn v0.4h, v0.4s
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mov v3.16b, v0.16b
-;   mov v3.d[1], v1.d[0]
-;   sqxtn v0.4h, v3.4s
+;   mov v0.d[1], v1.d[0]
+;   sqxtn v0.4h, v0.4s
 ;   ret
 
 function %snarrow_i32x4(i32x4, i32x4) -> i16x8 {
@@ -104,16 +100,14 @@ block0(v0: i16x4, v1: i16x4):
 
 ; VCode:
 ; block0:
-;   mov v3.16b, v0.16b
-;   mov v3.d[1], v3.d[1], v1.d[0]
-;   sqxtun v0.8b, v3.8h
+;   mov v0.d[1], v0.d[1], v1.d[0]
+;   sqxtun v0.8b, v0.8h
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mov v3.16b, v0.16b
-;   mov v3.d[1], v1.d[0]
-;   sqxtun v0.8b, v3.8h
+;   mov v0.d[1], v1.d[0]
+;   sqxtun v0.8b, v0.8h
 ;   ret
 
 function %unarrow_i16x8(i16x8, i16x8) -> i8x16 {
@@ -142,16 +136,14 @@ block0(v0: i32x2, v1: i32x2):
 
 ; VCode:
 ; block0:
-;   mov v3.16b, v0.16b
-;   mov v3.d[1], v3.d[1], v1.d[0]
-;   sqxtun v0.4h, v3.4s
+;   mov v0.d[1], v0.d[1], v1.d[0]
+;   sqxtun v0.4h, v0.4s
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mov v3.16b, v0.16b
-;   mov v3.d[1], v1.d[0]
-;   sqxtun v0.4h, v3.4s
+;   mov v0.d[1], v1.d[0]
+;   sqxtun v0.4h, v0.4s
 ;   ret
 
 function %unarrow_i32x4(i32x4, i32x4) -> i16x8 {
@@ -198,16 +190,14 @@ block0(v0: i16x4, v1: i16x4):
 
 ; VCode:
 ; block0:
-;   mov v3.16b, v0.16b
-;   mov v3.d[1], v3.d[1], v1.d[0]
-;   uqxtn v0.8b, v3.8h
+;   mov v0.d[1], v0.d[1], v1.d[0]
+;   uqxtn v0.8b, v0.8h
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mov v3.16b, v0.16b
-;   mov v3.d[1], v1.d[0]
-;   uqxtn v0.8b, v3.8h
+;   mov v0.d[1], v1.d[0]
+;   uqxtn v0.8b, v0.8h
 ;   ret
 
 function %uunarrow_i16x8(i16x8, i16x8) -> i8x16 {
@@ -236,16 +226,14 @@ block0(v0: i32x2, v1: i32x2):
 
 ; VCode:
 ; block0:
-;   mov v3.16b, v0.16b
-;   mov v3.d[1], v3.d[1], v1.d[0]
-;   uqxtn v0.4h, v3.4s
+;   mov v0.d[1], v0.d[1], v1.d[0]
+;   uqxtn v0.4h, v0.4s
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mov v3.16b, v0.16b
-;   mov v3.d[1], v1.d[0]
-;   uqxtn v0.4h, v3.4s
+;   mov v0.d[1], v1.d[0]
+;   uqxtn v0.4h, v0.4s
 ;   ret
 
 function %uunarrow_i32x4(i32x4, i32x4) -> i16x8 {
diff --git a/cranelift/filetests/filetests/isa/aarch64/simd-splat.clif b/cranelift/filetests/filetests/isa/aarch64/simd-splat.clif
index 18e35f9fd0d7..37fd1485cf35 100644
--- a/cranelift/filetests/filetests/isa/aarch64/simd-splat.clif
+++ b/cranelift/filetests/filetests/isa/aarch64/simd-splat.clif
@@ -16,7 +16,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld1r {v0.2d}, [x0]
+;   ld1r {v0.2d}, [x0] ; trap: heap_oob
 ;   ret
 
 function %splat_load2(i64) -> i64x2 {
@@ -35,7 +35,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   add x2, x0, #0x64
-;   ld1r {v0.2d}, [x2]
+;   ld1r {v0.2d}, [x2] ; trap: heap_oob
 ;   ret
 
 function %splat_load3(i64) -> i64x2 {
@@ -56,7 +56,7 @@ block0(v0: i64):
 ; block0: ; offset 0x0
 ;   mov x2, #0xfff0000
 ;   add x4, x0, x2
-;   ld1r {v0.2d}, [x4]
+;   ld1r {v0.2d}, [x4] ; trap: heap_oob
 ;   ret
 
 function %splat_load4(i64, i64) -> i64x2 {
@@ -76,7 +76,7 @@ block0(v0: i64, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   add x4, x0, x1
-;   ld1r {v0.2d}, [x4]
+;   ld1r {v0.2d}, [x4] ; trap: heap_oob
 ;   ret
 
 function %splat_load5(i64, i64) -> i64x2 {
@@ -98,7 +98,7 @@ block0(v0: i64, v1: i64):
 ; block0: ; offset 0x0
 ;   add x5, x0, x1
 ;   add x4, x5, #0x64
-;   ld1r {v0.2d}, [x4]
+;   ld1r {v0.2d}, [x4] ; trap: heap_oob
 ;   ret
 
 function %splat_load6(i64, i64) -> i64x2 {
@@ -123,6 +123,6 @@ block0(v0: i64, v1: i64):
 ;   mov x6, #2
 ;   madd x6, x1, x6, x0
 ;   add x5, x6, #0x64
-;   ld1r {v0.2d}, [x5]
+;   ld1r {v0.2d}, [x5] ; trap: heap_oob
 ;   ret
 
diff --git a/cranelift/filetests/filetests/isa/aarch64/simd.clif b/cranelift/filetests/filetests/isa/aarch64/simd.clif
index 499bd2b75bda..bf01fc4bbf5b 100644
--- a/cranelift/filetests/filetests/isa/aarch64/simd.clif
+++ b/cranelift/filetests/filetests/isa/aarch64/simd.clif
@@ -78,7 +78,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld1r {v0.16b}, [x0]
+;   ld1r {v0.16b}, [x0] ; trap: heap_oob
 ;   ret
 
 function %f6(i64, i64) -> i8x16, i8x16 {
@@ -98,8 +98,8 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld1r {v0.16b}, [x0]
-;   ld1r {v1.16b}, [x1]
+;   ld1r {v0.16b}, [x0] ; trap: heap_oob
+;   ld1r {v1.16b}, [x1] ; trap: heap_oob
 ;   ret
 
 function %f7(i64, i64) -> i8x16, i8x16 {
@@ -120,8 +120,8 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldrb w5, [x0]
-;   ld1r {v0.16b}, [x1]
+;   ldrb w5, [x0] ; trap: heap_oob
+;   ld1r {v0.16b}, [x1] ; trap: heap_oob
 ;   dup v1.16b, w5
 ;   ret
 
@@ -135,16 +135,16 @@ block0(v0: i64, v1: i64):
 
 ; VCode:
 ; block0:
-;   ldrb w5, [x0]
-;   dup v0.16b, w5
-;   dup v1.16b, w5
+;   ldrb w4, [x0]
+;   dup v0.16b, w4
+;   dup v1.16b, w4
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldrb w5, [x0]
-;   dup v0.16b, w5
-;   dup v1.16b, w5
+;   ldrb w4, [x0] ; trap: heap_oob
+;   dup v0.16b, w4
+;   dup v1.16b, w4
 ;   ret
 
 function %f9() -> i32x2 {
@@ -214,6 +214,6 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ldr d0, [x0, #0x800]
+;   ldr d0, [x0, #0x800] ; trap: heap_oob
 ;   ret
 
diff --git a/cranelift/filetests/filetests/isa/aarch64/stack-limit.clif b/cranelift/filetests/filetests/isa/aarch64/stack-limit.clif
index 6bd7520ba92d..49d4963f6b8f 100644
--- a/cranelift/filetests/filetests/isa/aarch64/stack-limit.clif
+++ b/cranelift/filetests/filetests/isa/aarch64/stack-limit.clif
@@ -15,19 +15,6 @@ block0:
 ; block0: ; offset 0x0
 ;   ret
 
-function %stack_limit_leaf_zero(i64 stack_limit) {
-block0(v0: i64):
-    return
-}
-
-; VCode:
-; block0:
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   ret
-
 function %stack_limit_gv_leaf_zero(i64 vmctx) {
     gv0 = vmctx
     gv1 = load.i64 notrap aligned gv0
@@ -45,40 +32,6 @@ block0(v0: i64):
 ; block0: ; offset 0x0
 ;   ret
 
-function %stack_limit_call_zero(i64 stack_limit) {
-    fn0 = %foo()
-block0(v0: i64):
-    call fn0()
-    return
-}
-
-; VCode:
-;   stp fp, lr, [sp, #-16]!
-;   mov fp, sp
-;   subs xzr, sp, x0, UXTX
-;   b.lo #trap=stk_ovf
-; block0:
-;   load_ext_name x2, TestCase(%foo)+0
-;   blr x2
-;   ldp fp, lr, [sp], #16
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   stp x29, x30, [sp, #-0x10]!
-;   mov x29, sp
-;   cmp sp, x0
-;   b.lo #0x2c
-; block1: ; offset 0x10
-;   ldr x2, #0x18
-;   b #0x20
-;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %foo 0
-;   .byte 0x00, 0x00, 0x00, 0x00
-;   blr x2
-;   ldp x29, x30, [sp], #0x10
-;   ret
-;   .byte 0x1f, 0xc1, 0x00, 0x00 ; trap: stk_ovf
-
 function %stack_limit_gv_call_zero(i64 vmctx) {
     gv0 = vmctx
     gv1 = load.i64 notrap aligned gv0
@@ -95,11 +48,12 @@ block0(v0: i64):
 ;   mov fp, sp
 ;   ldr x16, [x0]
 ;   ldr x16, [x16, #4]
+;   add x16, x16, #16
 ;   subs xzr, sp, x16, UXTX
 ;   b.lo #trap=stk_ovf
 ; block0:
-;   load_ext_name x2, TestCase(%foo)+0
-;   blr x2
+;   load_ext_name x0, TestCase(%foo)+0
+;   blr x0
 ;   ldp fp, lr, [sp], #16
 ;   ret
 ;
@@ -109,98 +63,18 @@ block0(v0: i64):
 ;   mov x29, sp
 ;   ldur x16, [x0]
 ;   ldur x16, [x16, #4]
+;   add x16, x16, #0x10
 ;   cmp sp, x16
-;   b.lo #0x34
-; block1: ; offset 0x18
-;   ldr x2, #0x20
-;   b #0x28
+;   b.lo #0x38
+; block1: ; offset 0x1c
+;   ldr x0, #0x24
+;   b #0x2c
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %foo 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   blr x2
-;   ldp x29, x30, [sp], #0x10
-;   ret
-;   .byte 0x1f, 0xc1, 0x00, 0x00 ; trap: stk_ovf
-
-function %stack_limit(i64 stack_limit) {
-    ss0 = explicit_slot 168
-block0(v0: i64):
-    return
-}
-
-; VCode:
-;   stp fp, lr, [sp, #-16]!
-;   mov fp, sp
-;   add x16, x0, #176
-;   subs xzr, sp, x16, UXTX
-;   b.lo #trap=stk_ovf
-;   sub sp, sp, #176
-; block0:
-;   add sp, sp, #176
-;   ldp fp, lr, [sp], #16
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   stp x29, x30, [sp, #-0x10]!
-;   mov x29, sp
-;   add x16, x0, #0xb0
-;   cmp sp, x16
-;   b.lo #0x24
-;   sub sp, sp, #0xb0
-; block1: ; offset 0x18
-;   add sp, sp, #0xb0
-;   ldp x29, x30, [sp], #0x10
-;   ret
-;   .byte 0x1f, 0xc1, 0x00, 0x00 ; trap: stk_ovf
-
-function %huge_stack_limit(i64 stack_limit) {
-    ss0 = explicit_slot 400000
-block0(v0: i64):
-    return
-}
-
-; VCode:
-;   stp fp, lr, [sp, #-16]!
-;   mov fp, sp
-;   subs xzr, sp, x0, UXTX
-;   b.lo #trap=stk_ovf
-;   movz w17, #6784
-;   movk w17, w17, #6, LSL #16
-;   add x16, x0, x17, UXTX
-;   subs xzr, sp, x16, UXTX
-;   b.lo #trap=stk_ovf
-;   movz w16, #6784
-;   movk w16, w16, #6, LSL #16
-;   sub sp, sp, x16, UXTX
-; block0:
-;   movz w16, #6784
-;   movk w16, w16, #6, LSL #16
-;   add sp, sp, x16, UXTX
-;   ldp fp, lr, [sp], #16
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   stp x29, x30, [sp, #-0x10]!
-;   mov x29, sp
-;   cmp sp, x0
-;   b.lo #0x44
-;   mov w17, #0x1a80
-;   movk w17, #6, lsl #16
-;   add x16, x0, x17, uxtx
-;   cmp sp, x16
-;   b.lo #0x48
-;   mov w16, #0x1a80
-;   movk w16, #6, lsl #16
-;   sub sp, sp, x16
-; block1: ; offset 0x30
-;   mov w16, #0x1a80
-;   movk w16, #6, lsl #16
-;   add sp, sp, x16
+;   blr x0
 ;   ldp x29, x30, [sp], #0x10
 ;   ret
 ;   .byte 0x1f, 0xc1, 0x00, 0x00 ; trap: stk_ovf
-;   .byte 0x1f, 0xc1, 0x00, 0x00 ; trap: stk_ovf
 
 function %limit_preamble(i64 vmctx) {
     gv0 = vmctx
diff --git a/cranelift/filetests/filetests/isa/aarch64/stack.clif b/cranelift/filetests/filetests/isa/aarch64/stack.clif
index 8369c5efc419..12b9788ec195 100644
--- a/cranelift/filetests/filetests/isa/aarch64/stack.clif
+++ b/cranelift/filetests/filetests/isa/aarch64/stack.clif
@@ -463,28 +463,28 @@ block0(v0: i8):
 ;   add x0, x0, #31
 ;   ldr x7, [sp, #1208]
 ;   add x7, x7, #33
-;   ldr x9, [sp, #1200]
-;   add x8, x9, #35
-;   ldr x12, [sp, #1192]
-;   add x9, x12, #37
-;   ldr x15, [sp, #1184]
-;   add x10, x15, #39
-;   ldr x2, [sp, #1176]
-;   add x11, x2, #31
-;   ldr x5, [sp, #1168]
-;   add x12, x5, #33
+;   ldr x10, [sp, #1200]
+;   add x8, x10, #35
+;   ldr x13, [sp, #1192]
+;   add x9, x13, #37
+;   ldr x1, [sp, #1184]
+;   add x10, x1, #39
+;   ldr x3, [sp, #1176]
+;   add x11, x3, #31
+;   ldr x6, [sp, #1168]
+;   add x12, x6, #33
 ;   ldr x13, [sp, #1160]
 ;   add x13, x13, #35
 ;   ldr x14, [sp, #1152]
 ;   add x14, x14, #37
 ;   ldr x15, [sp, #1144]
 ;   add x15, x15, #39
-;   ldr x3, [sp, #1128]
-;   ldr x1, [sp, #1136]
-;   add x1, x1, x3
+;   ldr x2, [sp, #1136]
+;   ldr x4, [sp, #1128]
+;   add x1, x2, x4
 ;   ldr x2, [sp, #1112]
-;   ldr x6, [sp, #1120]
-;   add x2, x6, x2
+;   ldr x3, [sp, #1120]
+;   add x2, x3, x2
 ;   ldr x3, [sp, #1096]
 ;   ldr x4, [sp, #1104]
 ;   add x3, x4, x3
@@ -500,8 +500,8 @@ block0(v0: i8):
 ;   ldr x23, [sp, #1032]
 ;   ldr x24, [sp, #1040]
 ;   add x23, x24, x23
-;   ldr x25, [sp, #1016]
 ;   ldr x24, [sp, #1024]
+;   ldr x25, [sp, #1016]
 ;   add x24, x24, x25
 ;   ldr x25, [sp, #1008]
 ;   add x25, x25, x26
@@ -641,28 +641,28 @@ block0(v0: i8):
 ;   add x0, x0, #0x1f
 ;   ldr x7, [sp, #0x4b8]
 ;   add x7, x7, #0x21
-;   ldr x9, [sp, #0x4b0]
-;   add x8, x9, #0x23
-;   ldr x12, [sp, #0x4a8]
-;   add x9, x12, #0x25
-;   ldr x15, [sp, #0x4a0]
-;   add x10, x15, #0x27
-;   ldr x2, [sp, #0x498]
-;   add x11, x2, #0x1f
-;   ldr x5, [sp, #0x490]
-;   add x12, x5, #0x21
+;   ldr x10, [sp, #0x4b0]
+;   add x8, x10, #0x23
+;   ldr x13, [sp, #0x4a8]
+;   add x9, x13, #0x25
+;   ldr x1, [sp, #0x4a0]
+;   add x10, x1, #0x27
+;   ldr x3, [sp, #0x498]
+;   add x11, x3, #0x1f
+;   ldr x6, [sp, #0x490]
+;   add x12, x6, #0x21
 ;   ldr x13, [sp, #0x488]
 ;   add x13, x13, #0x23
 ;   ldr x14, [sp, #0x480]
 ;   add x14, x14, #0x25
 ;   ldr x15, [sp, #0x478]
 ;   add x15, x15, #0x27
-;   ldr x3, [sp, #0x468]
-;   ldr x1, [sp, #0x470]
-;   add x1, x1, x3
+;   ldr x2, [sp, #0x470]
+;   ldr x4, [sp, #0x468]
+;   add x1, x2, x4
 ;   ldr x2, [sp, #0x458]
-;   ldr x6, [sp, #0x460]
-;   add x2, x6, x2
+;   ldr x3, [sp, #0x460]
+;   add x2, x3, x2
 ;   ldr x3, [sp, #0x448]
 ;   ldr x4, [sp, #0x450]
 ;   add x3, x4, x3
@@ -678,8 +678,8 @@ block0(v0: i8):
 ;   ldr x23, [sp, #0x408]
 ;   ldr x24, [sp, #0x410]
 ;   add x23, x24, x23
-;   ldr x25, [sp, #0x3f8]
 ;   ldr x24, [sp, #0x400]
+;   ldr x25, [sp, #0x3f8]
 ;   add x24, x24, x25
 ;   ldr x25, [sp, #0x3f0]
 ;   add x25, x25, x26
diff --git a/cranelift/filetests/filetests/isa/aarch64/store-f16-f128.clif b/cranelift/filetests/filetests/isa/aarch64/store-f16-f128.clif
new file mode 100644
index 000000000000..83c3807a75c6
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/aarch64/store-f16-f128.clif
@@ -0,0 +1,36 @@
+test compile precise-output
+set unwind_info=false
+target aarch64
+
+function %store_f16(f16, i64) {
+block0(v0: f16, v1: i64):
+    store.f16 v0, v1
+    return
+}
+
+; VCode:
+; block0:
+;   str h0, [x0]
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   str h0, [x0] ; trap: heap_oob
+;   ret
+
+function %store_f128(f128, i64) {
+block0(v0: f128, v1: i64):
+    store.f128 v0, v1
+    return
+}
+
+; VCode:
+; block0:
+;   str q0, [x0]
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   str q0, [x0] ; trap: heap_oob
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/aarch64/tail-call-conv.clif b/cranelift/filetests/filetests/isa/aarch64/tail-call-conv.clif
index 40e1917bbe68..9a9da0b515c7 100644
--- a/cranelift/filetests/filetests/isa/aarch64/tail-call-conv.clif
+++ b/cranelift/filetests/filetests/isa/aarch64/tail-call-conv.clif
@@ -12,10 +12,9 @@ block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64, v6: i64, v7: i64, v
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
 ; block0:
-;   ldr x9, [fp, #16]
-;   ldr x2, [fp, #24]
+;   ldr x2, [sp, #168]
 ;   ldp fp, lr, [sp], #16
-;   add sp, sp, #16
+;   add sp, sp, #160
 ;   ret
 ;
 ; Disassembled:
@@ -23,10 +22,9 @@ block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64, v6: i64, v7: i64, v
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
 ; block1: ; offset 0x8
-;   ldur x9, [x29, #0x10]
-;   ldur x2, [x29, #0x18]
+;   ldur x2, [sp, #0xa8]
 ;   ldp x29, x30, [sp], #0x10
-;   add sp, sp, #0x10
+;   add sp, sp, #0xa0
 ;   ret
 
 function %tail_caller_stack_args() -> i64 tail {
@@ -66,6 +64,12 @@ block0:
 ; VCode:
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
+;   stp x27, x28, [sp, #-16]!
+;   stp x25, x26, [sp, #-16]!
+;   stp x23, x24, [sp, #-16]!
+;   stp x21, x22, [sp, #-16]!
+;   stp x19, x20, [sp, #-16]!
+;   sub sp, sp, #160
 ; block0:
 ;   movz x2, #10
 ;   movz x3, #15
@@ -73,32 +77,54 @@ block0:
 ;   movz x5, #25
 ;   movz x6, #30
 ;   movz x7, #35
-;   movz x8, #40
-;   movz x9, #45
-;   movz x10, #50
-;   movz x11, #55
-;   movz x12, #60
-;   movz x13, #65
-;   movz x14, #70
-;   movz x15, #75
-;   movz x19, #80
-;   movz x20, #85
-;   movz x21, #90
-;   movz x22, #95
-;   movz x23, #100
-;   movz x24, #105
-;   movz x25, #110
-;   movz x26, #115
-;   movz x27, #120
-;   movz x28, #125
-;   movz x0, #130
-;   movz x1, #135
-;   sub sp, sp, #16
-;   virtual_sp_offset_adjust 16
-;   str x0, [sp]
-;   str x1, [sp, #8]
-;   load_ext_name x1, TestCase(%tail_callee_stack_args)+0
-;   blr x1
+;   movz x11, #40
+;   movz x12, #45
+;   movz x13, #50
+;   movz x14, #55
+;   movz x15, #60
+;   movz x0, #65
+;   movz x1, #70
+;   movz x8, #75
+;   movz x9, #80
+;   movz x10, #85
+;   movz x27, #90
+;   movz x28, #95
+;   movz x21, #100
+;   movz x19, #105
+;   movz x20, #110
+;   movz x22, #115
+;   movz x23, #120
+;   movz x24, #125
+;   movz x25, #130
+;   movz x26, #135
+;   str x11, [sp]
+;   str x12, [sp, #8]
+;   str x13, [sp, #16]
+;   str x14, [sp, #24]
+;   str x15, [sp, #32]
+;   str x0, [sp, #40]
+;   str x1, [sp, #48]
+;   str x8, [sp, #56]
+;   str x9, [sp, #64]
+;   str x10, [sp, #72]
+;   str x27, [sp, #80]
+;   str x28, [sp, #88]
+;   str x21, [sp, #96]
+;   str x19, [sp, #104]
+;   str x20, [sp, #112]
+;   str x22, [sp, #120]
+;   str x23, [sp, #128]
+;   str x24, [sp, #136]
+;   str x25, [sp, #144]
+;   str x26, [sp, #152]
+;   load_ext_name x15, TestCase(%tail_callee_stack_args)+0
+;   blr x15
+;   add sp, sp, #160
+;   ldp x19, x20, [sp], #16
+;   ldp x21, x22, [sp], #16
+;   ldp x23, x24, [sp], #16
+;   ldp x25, x26, [sp], #16
+;   ldp x27, x28, [sp], #16
 ;   ldp fp, lr, [sp], #16
 ;   ret
 ;
@@ -106,41 +132,71 @@ block0:
 ; block0: ; offset 0x0
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
-; block1: ; offset 0x8
+;   stp x27, x28, [sp, #-0x10]!
+;   stp x25, x26, [sp, #-0x10]!
+;   stp x23, x24, [sp, #-0x10]!
+;   stp x21, x22, [sp, #-0x10]!
+;   stp x19, x20, [sp, #-0x10]!
+;   sub sp, sp, #0xa0
+; block1: ; offset 0x20
 ;   mov x2, #0xa
 ;   mov x3, #0xf
 ;   mov x4, #0x14
 ;   mov x5, #0x19
 ;   mov x6, #0x1e
 ;   mov x7, #0x23
-;   mov x8, #0x28
-;   mov x9, #0x2d
-;   mov x10, #0x32
-;   mov x11, #0x37
-;   mov x12, #0x3c
-;   mov x13, #0x41
-;   mov x14, #0x46
-;   mov x15, #0x4b
-;   mov x19, #0x50
-;   mov x20, #0x55
-;   mov x21, #0x5a
-;   mov x22, #0x5f
-;   mov x23, #0x64
-;   mov x24, #0x69
-;   mov x25, #0x6e
-;   mov x26, #0x73
-;   mov x27, #0x78
-;   mov x28, #0x7d
-;   mov x0, #0x82
-;   mov x1, #0x87
-;   sub sp, sp, #0x10
-;   stur x0, [sp]
-;   stur x1, [sp, #8]
-;   ldr x1, #0x84
-;   b #0x8c
+;   mov x11, #0x28
+;   mov x12, #0x2d
+;   mov x13, #0x32
+;   mov x14, #0x37
+;   mov x15, #0x3c
+;   mov x0, #0x41
+;   mov x1, #0x46
+;   mov x8, #0x4b
+;   mov x9, #0x50
+;   mov x10, #0x55
+;   mov x27, #0x5a
+;   mov x28, #0x5f
+;   mov x21, #0x64
+;   mov x19, #0x69
+;   mov x20, #0x6e
+;   mov x22, #0x73
+;   mov x23, #0x78
+;   mov x24, #0x7d
+;   mov x25, #0x82
+;   mov x26, #0x87
+;   stur x11, [sp]
+;   stur x12, [sp, #8]
+;   stur x13, [sp, #0x10]
+;   stur x14, [sp, #0x18]
+;   stur x15, [sp, #0x20]
+;   stur x0, [sp, #0x28]
+;   stur x1, [sp, #0x30]
+;   stur x8, [sp, #0x38]
+;   stur x9, [sp, #0x40]
+;   stur x10, [sp, #0x48]
+;   stur x27, [sp, #0x50]
+;   stur x28, [sp, #0x58]
+;   stur x21, [sp, #0x60]
+;   stur x19, [sp, #0x68]
+;   stur x20, [sp, #0x70]
+;   stur x22, [sp, #0x78]
+;   stur x23, [sp, #0x80]
+;   stur x24, [sp, #0x88]
+;   stur x25, [sp, #0x90]
+;   stur x26, [sp, #0x98]
+;   ldr x15, #0xe0
+;   b #0xe8
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %tail_callee_stack_args 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   blr x1
+;   blr x15
+;   sub sp, sp, #0xa0
+;   add sp, sp, #0xa0
+;   ldp x19, x20, [sp], #0x10
+;   ldp x21, x22, [sp], #0x10
+;   ldp x23, x24, [sp], #0x10
+;   ldp x25, x26, [sp], #0x10
+;   ldp x27, x28, [sp], #0x10
 ;   ldp x29, x30, [sp], #0x10
 ;   ret
 
@@ -180,39 +236,67 @@ block0:
 ; VCode:
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
+;   stp x27, x28, [sp, #-16]!
+;   stp x25, x26, [sp, #-16]!
+;   stp x23, x24, [sp, #-16]!
+;   stp x21, x22, [sp, #-16]!
+;   stp x19, x20, [sp, #-16]!
 ;   sub sp, sp, #16
 ; block0:
-;   movz x2, #10
-;   str x2, [sp]
+;   movz x3, #10
+;   str x3, [sp]
 ;   movz x3, #15
 ;   movz x4, #20
 ;   movz x5, #25
 ;   movz x6, #30
 ;   movz x7, #35
-;   movz x8, #40
-;   movz x9, #45
-;   movz x10, #50
-;   movz x11, #55
-;   movz x12, #60
-;   movz x13, #65
-;   movz x14, #70
-;   movz x15, #75
-;   movz x19, #80
-;   movz x20, #85
-;   movz x21, #90
-;   movz x22, #95
-;   movz x23, #100
-;   movz x24, #105
-;   movz x25, #110
-;   movz x26, #115
-;   movz x27, #120
-;   movz x28, #125
-;   movz x1, #130
+;   movz x11, #40
+;   movz x12, #45
+;   movz x13, #50
+;   movz x14, #55
+;   movz x15, #60
+;   movz x1, #65
+;   movz x8, #70
+;   movz x9, #75
+;   movz x10, #80
+;   movz x27, #85
+;   movz x28, #90
+;   movz x21, #95
+;   movz x19, #100
+;   movz x20, #105
+;   movz x22, #110
+;   movz x23, #115
+;   movz x24, #120
+;   movz x25, #125
+;   movz x26, #130
 ;   movz x2, #135
-;   str x1, [x0]
-;   str x2, [x0, #8]
+;   str x11, [x0]
+;   str x12, [x0, #8]
+;   str x13, [x0, #16]
+;   str x14, [x0, #24]
+;   str x15, [x0, #32]
+;   str x1, [x0, #40]
+;   str x8, [x0, #48]
+;   str x9, [x0, #56]
+;   str x10, [x0, #64]
+;   str x27, [x0, #72]
+;   str x28, [x0, #80]
+;   str x21, [x0, #88]
+;   str x19, [x0, #96]
+;   str x20, [x0, #104]
+;   str x22, [x0, #112]
+;   str x23, [x0, #120]
+;   str x24, [x0, #128]
+;   str x25, [x0, #136]
+;   str x26, [x0, #144]
+;   str x2, [x0, #152]
 ;   ldr x2, [sp]
 ;   add sp, sp, #16
+;   ldp x19, x20, [sp], #16
+;   ldp x21, x22, [sp], #16
+;   ldp x23, x24, [sp], #16
+;   ldp x25, x26, [sp], #16
+;   ldp x27, x28, [sp], #16
 ;   ldp fp, lr, [sp], #16
 ;   ret
 ;
@@ -220,39 +304,67 @@ block0:
 ; block0: ; offset 0x0
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
+;   stp x27, x28, [sp, #-0x10]!
+;   stp x25, x26, [sp, #-0x10]!
+;   stp x23, x24, [sp, #-0x10]!
+;   stp x21, x22, [sp, #-0x10]!
+;   stp x19, x20, [sp, #-0x10]!
 ;   sub sp, sp, #0x10
-; block1: ; offset 0xc
-;   mov x2, #0xa
-;   stur x2, [sp]
+; block1: ; offset 0x20
+;   mov x3, #0xa
+;   stur x3, [sp]
 ;   mov x3, #0xf
 ;   mov x4, #0x14
 ;   mov x5, #0x19
 ;   mov x6, #0x1e
 ;   mov x7, #0x23
-;   mov x8, #0x28
-;   mov x9, #0x2d
-;   mov x10, #0x32
-;   mov x11, #0x37
-;   mov x12, #0x3c
-;   mov x13, #0x41
-;   mov x14, #0x46
-;   mov x15, #0x4b
-;   mov x19, #0x50
-;   mov x20, #0x55
-;   mov x21, #0x5a
-;   mov x22, #0x5f
-;   mov x23, #0x64
-;   mov x24, #0x69
-;   mov x25, #0x6e
-;   mov x26, #0x73
-;   mov x27, #0x78
-;   mov x28, #0x7d
-;   mov x1, #0x82
+;   mov x11, #0x28
+;   mov x12, #0x2d
+;   mov x13, #0x32
+;   mov x14, #0x37
+;   mov x15, #0x3c
+;   mov x1, #0x41
+;   mov x8, #0x46
+;   mov x9, #0x4b
+;   mov x10, #0x50
+;   mov x27, #0x55
+;   mov x28, #0x5a
+;   mov x21, #0x5f
+;   mov x19, #0x64
+;   mov x20, #0x69
+;   mov x22, #0x6e
+;   mov x23, #0x73
+;   mov x24, #0x78
+;   mov x25, #0x7d
+;   mov x26, #0x82
 ;   mov x2, #0x87
-;   stur x1, [x0]
-;   stur x2, [x0, #8]
+;   stur x11, [x0]
+;   stur x12, [x0, #8]
+;   stur x13, [x0, #0x10]
+;   stur x14, [x0, #0x18]
+;   stur x15, [x0, #0x20]
+;   stur x1, [x0, #0x28]
+;   stur x8, [x0, #0x30]
+;   stur x9, [x0, #0x38]
+;   stur x10, [x0, #0x40]
+;   stur x27, [x0, #0x48]
+;   stur x28, [x0, #0x50]
+;   stur x21, [x0, #0x58]
+;   stur x19, [x0, #0x60]
+;   stur x20, [x0, #0x68]
+;   stur x22, [x0, #0x70]
+;   stur x23, [x0, #0x78]
+;   stur x24, [x0, #0x80]
+;   stur x25, [x0, #0x88]
+;   stur x26, [x0, #0x90]
+;   stur x2, [x0, #0x98]
 ;   ldur x2, [sp]
 ;   add sp, sp, #0x10
+;   ldp x19, x20, [sp], #0x10
+;   ldp x21, x22, [sp], #0x10
+;   ldp x23, x24, [sp], #0x10
+;   ldp x25, x26, [sp], #0x10
+;   ldp x27, x28, [sp], #0x10
 ;   ldp x29, x30, [sp], #0x10
 ;   ret
 
@@ -267,16 +379,32 @@ block0:
 ; VCode:
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
+;   sub sp, sp, #160
 ; block0:
-;   sub sp, sp, #16
-;   virtual_sp_offset_adjust 16
 ;   mov x0, sp
-;   load_ext_name x1, TestCase(%tail_callee_stack_rets)+0
-;   blr x1
-;   ldr x13, [sp]
-;   ldr x2, [sp, #8]
-;   add sp, sp, #16
-;   virtual_sp_offset_adjust -16
+;   load_ext_name x12, TestCase(%tail_callee_stack_rets)+0
+;   blr x12
+;   ldr x9, [sp]
+;   ldr x11, [sp, #8]
+;   ldr x13, [sp, #16]
+;   ldr x15, [sp, #24]
+;   ldr x1, [sp, #32]
+;   ldr x3, [sp, #40]
+;   ldr x5, [sp, #48]
+;   ldr x7, [sp, #56]
+;   ldr x9, [sp, #64]
+;   ldr x11, [sp, #72]
+;   ldr x13, [sp, #80]
+;   ldr x15, [sp, #88]
+;   ldr x1, [sp, #96]
+;   ldr x3, [sp, #104]
+;   ldr x5, [sp, #112]
+;   ldr x7, [sp, #120]
+;   ldr x9, [sp, #128]
+;   ldr x11, [sp, #136]
+;   ldr x13, [sp, #144]
+;   ldr x2, [sp, #152]
+;   add sp, sp, #160
 ;   ldp fp, lr, [sp], #16
 ;   ret
 ;
@@ -284,17 +412,35 @@ block0:
 ; block0: ; offset 0x0
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
-; block1: ; offset 0x8
-;   sub sp, sp, #0x10
+;   sub sp, sp, #0xa0
+; block1: ; offset 0xc
 ;   mov x0, sp
-;   ldr x1, #0x18
+;   ldr x12, #0x18
 ;   b #0x20
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %tail_callee_stack_rets 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   blr x1
-;   ldur x13, [sp]
-;   ldur x2, [sp, #8]
-;   add sp, sp, #0x10
+;   blr x12
+;   ldur x9, [sp]
+;   ldur x11, [sp, #8]
+;   ldur x13, [sp, #0x10]
+;   ldur x15, [sp, #0x18]
+;   ldur x1, [sp, #0x20]
+;   ldur x3, [sp, #0x28]
+;   ldur x5, [sp, #0x30]
+;   ldur x7, [sp, #0x38]
+;   ldur x9, [sp, #0x40]
+;   ldur x11, [sp, #0x48]
+;   ldur x13, [sp, #0x50]
+;   ldur x15, [sp, #0x58]
+;   ldur x1, [sp, #0x60]
+;   ldur x3, [sp, #0x68]
+;   ldur x5, [sp, #0x70]
+;   ldur x7, [sp, #0x78]
+;   ldur x9, [sp, #0x80]
+;   ldur x11, [sp, #0x88]
+;   ldur x13, [sp, #0x90]
+;   ldur x2, [sp, #0x98]
+;   add sp, sp, #0xa0
 ;   ldp x29, x30, [sp], #0x10
 ;   ret
 
@@ -309,34 +455,126 @@ block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64, v6: i64, v7: i64, v
 ; VCode:
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
+;   stp x27, x28, [sp, #-16]!
+;   stp x25, x26, [sp, #-16]!
+;   stp x23, x24, [sp, #-16]!
+;   stp x21, x22, [sp, #-16]!
+;   stp x19, x20, [sp, #-16]!
 ;   sub sp, sp, #16
 ; block0:
-;   str x9, [sp]
-;   ldr x9, [fp, #16]
-;   ldr x1, [fp, #24]
-;   str x9, [x0]
-;   str x1, [x0, #8]
-;   ldr x9, [sp]
+;   str x7, [sp]
+;   ldr x7, [sp, #112]
+;   ldr x19, [sp, #120]
+;   ldr x22, [sp, #128]
+;   ldr x24, [sp, #136]
+;   ldr x26, [sp, #144]
+;   ldr x28, [sp, #152]
+;   ldr x21, [sp, #160]
+;   ldr x20, [sp, #168]
+;   ldr x23, [sp, #176]
+;   ldr x25, [sp, #184]
+;   ldr x27, [sp, #192]
+;   ldr x14, [sp, #200]
+;   ldr x15, [sp, #208]
+;   ldr x1, [sp, #216]
+;   ldr x12, [sp, #224]
+;   ldr x10, [sp, #232]
+;   ldr x8, [sp, #240]
+;   ldr x9, [sp, #248]
+;   ldr x11, [sp, #256]
+;   ldr x13, [sp, #264]
+;   str x7, [x0]
+;   str x19, [x0, #8]
+;   str x22, [x0, #16]
+;   str x24, [x0, #24]
+;   str x26, [x0, #32]
+;   str x28, [x0, #40]
+;   str x21, [x0, #48]
+;   str x20, [x0, #56]
+;   str x23, [x0, #64]
+;   str x25, [x0, #72]
+;   str x27, [x0, #80]
+;   str x14, [x0, #88]
+;   str x15, [x0, #96]
+;   str x1, [x0, #104]
+;   str x12, [x0, #112]
+;   str x10, [x0, #120]
+;   str x8, [x0, #128]
+;   str x9, [x0, #136]
+;   str x11, [x0, #144]
+;   str x13, [x0, #152]
+;   ldr x7, [sp]
 ;   add sp, sp, #16
+;   ldp x19, x20, [sp], #16
+;   ldp x21, x22, [sp], #16
+;   ldp x23, x24, [sp], #16
+;   ldp x25, x26, [sp], #16
+;   ldp x27, x28, [sp], #16
 ;   ldp fp, lr, [sp], #16
-;   add sp, sp, #16
+;   add sp, sp, #160
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
+;   stp x27, x28, [sp, #-0x10]!
+;   stp x25, x26, [sp, #-0x10]!
+;   stp x23, x24, [sp, #-0x10]!
+;   stp x21, x22, [sp, #-0x10]!
+;   stp x19, x20, [sp, #-0x10]!
 ;   sub sp, sp, #0x10
-; block1: ; offset 0xc
-;   stur x9, [sp]
-;   ldur x9, [x29, #0x10]
-;   ldur x1, [x29, #0x18]
-;   stur x9, [x0]
-;   stur x1, [x0, #8]
-;   ldur x9, [sp]
+; block1: ; offset 0x20
+;   stur x7, [sp]
+;   ldur x7, [sp, #0x70]
+;   ldur x19, [sp, #0x78]
+;   ldur x22, [sp, #0x80]
+;   ldur x24, [sp, #0x88]
+;   ldur x26, [sp, #0x90]
+;   ldur x28, [sp, #0x98]
+;   ldur x21, [sp, #0xa0]
+;   ldur x20, [sp, #0xa8]
+;   ldur x23, [sp, #0xb0]
+;   ldur x25, [sp, #0xb8]
+;   ldur x27, [sp, #0xc0]
+;   ldur x14, [sp, #0xc8]
+;   ldur x15, [sp, #0xd0]
+;   ldur x1, [sp, #0xd8]
+;   ldur x12, [sp, #0xe0]
+;   ldur x10, [sp, #0xe8]
+;   ldur x8, [sp, #0xf0]
+;   ldur x9, [sp, #0xf8]
+;   ldr x11, [sp, #0x100]
+;   ldr x13, [sp, #0x108]
+;   stur x7, [x0]
+;   stur x19, [x0, #8]
+;   stur x22, [x0, #0x10]
+;   stur x24, [x0, #0x18]
+;   stur x26, [x0, #0x20]
+;   stur x28, [x0, #0x28]
+;   stur x21, [x0, #0x30]
+;   stur x20, [x0, #0x38]
+;   stur x23, [x0, #0x40]
+;   stur x25, [x0, #0x48]
+;   stur x27, [x0, #0x50]
+;   stur x14, [x0, #0x58]
+;   stur x15, [x0, #0x60]
+;   stur x1, [x0, #0x68]
+;   stur x12, [x0, #0x70]
+;   stur x10, [x0, #0x78]
+;   stur x8, [x0, #0x80]
+;   stur x9, [x0, #0x88]
+;   stur x11, [x0, #0x90]
+;   stur x13, [x0, #0x98]
+;   ldur x7, [sp]
 ;   add sp, sp, #0x10
+;   ldp x19, x20, [sp], #0x10
+;   ldp x21, x22, [sp], #0x10
+;   ldp x23, x24, [sp], #0x10
+;   ldp x25, x26, [sp], #0x10
+;   ldp x27, x28, [sp], #0x10
 ;   ldp x29, x30, [sp], #0x10
-;   add sp, sp, #0x10
+;   add sp, sp, #0xa0
 ;   ret
 
 function %tail_caller_stack_args_and_rets() -> i64 tail {
@@ -376,6 +614,12 @@ block0:
 ; VCode:
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
+;   stp x27, x28, [sp, #-16]!
+;   stp x25, x26, [sp, #-16]!
+;   stp x23, x24, [sp, #-16]!
+;   stp x21, x22, [sp, #-16]!
+;   stp x19, x20, [sp, #-16]!
+;   sub sp, sp, #320
 ; block0:
 ;   movz x2, #10
 ;   movz x3, #15
@@ -391,29 +635,67 @@ block0:
 ;   movz x13, #65
 ;   movz x14, #70
 ;   movz x15, #75
-;   movz x19, #80
-;   movz x20, #85
-;   movz x21, #90
-;   movz x22, #95
-;   movz x23, #100
-;   movz x24, #105
-;   movz x25, #110
-;   movz x26, #115
-;   movz x27, #120
-;   movz x28, #125
-;   movz x0, #130
-;   movz x1, #135
-;   sub sp, sp, #32
-;   virtual_sp_offset_adjust 32
-;   str x0, [sp]
-;   str x1, [sp, #8]
-;   add x0, sp, #16
-;   load_ext_name x1, TestCase(%tail_callee_stack_args_and_rets)+0
-;   blr x1
-;   ldr x9, [sp]
-;   ldr x2, [sp, #8]
-;   add sp, sp, #16
-;   virtual_sp_offset_adjust -16
+;   movz x0, #80
+;   movz x1, #85
+;   movz x23, #90
+;   movz x24, #95
+;   movz x25, #100
+;   movz x26, #105
+;   movz x27, #110
+;   movz x28, #115
+;   movz x21, #120
+;   movz x19, #125
+;   movz x20, #130
+;   movz x22, #135
+;   str x8, [sp]
+;   str x9, [sp, #8]
+;   str x10, [sp, #16]
+;   str x11, [sp, #24]
+;   str x12, [sp, #32]
+;   str x13, [sp, #40]
+;   str x14, [sp, #48]
+;   str x15, [sp, #56]
+;   str x0, [sp, #64]
+;   str x1, [sp, #72]
+;   str x23, [sp, #80]
+;   str x24, [sp, #88]
+;   str x25, [sp, #96]
+;   str x26, [sp, #104]
+;   str x27, [sp, #112]
+;   str x28, [sp, #120]
+;   str x21, [sp, #128]
+;   str x19, [sp, #136]
+;   str x20, [sp, #144]
+;   str x22, [sp, #152]
+;   add x0, sp, #160
+;   load_ext_name x10, TestCase(%tail_callee_stack_args_and_rets)+0
+;   blr x10
+;   ldr x7, [sp, #160]
+;   ldr x9, [sp, #168]
+;   ldr x11, [sp, #176]
+;   ldr x13, [sp, #184]
+;   ldr x15, [sp, #192]
+;   ldr x1, [sp, #200]
+;   ldr x3, [sp, #208]
+;   ldr x5, [sp, #216]
+;   ldr x7, [sp, #224]
+;   ldr x9, [sp, #232]
+;   ldr x11, [sp, #240]
+;   ldr x13, [sp, #248]
+;   ldr x15, [sp, #256]
+;   ldr x1, [sp, #264]
+;   ldr x3, [sp, #272]
+;   ldr x5, [sp, #280]
+;   ldr x7, [sp, #288]
+;   ldr x9, [sp, #296]
+;   ldr x11, [sp, #304]
+;   ldr x2, [sp, #312]
+;   add sp, sp, #320
+;   ldp x19, x20, [sp], #16
+;   ldp x21, x22, [sp], #16
+;   ldp x23, x24, [sp], #16
+;   ldp x25, x26, [sp], #16
+;   ldp x27, x28, [sp], #16
 ;   ldp fp, lr, [sp], #16
 ;   ret
 ;
@@ -421,7 +703,13 @@ block0:
 ; block0: ; offset 0x0
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
-; block1: ; offset 0x8
+;   stp x27, x28, [sp, #-0x10]!
+;   stp x25, x26, [sp, #-0x10]!
+;   stp x23, x24, [sp, #-0x10]!
+;   stp x21, x22, [sp, #-0x10]!
+;   stp x19, x20, [sp, #-0x10]!
+;   sub sp, sp, #0x140
+; block1: ; offset 0x20
 ;   mov x2, #0xa
 ;   mov x3, #0xf
 ;   mov x4, #0x14
@@ -436,30 +724,71 @@ block0:
 ;   mov x13, #0x41
 ;   mov x14, #0x46
 ;   mov x15, #0x4b
-;   mov x19, #0x50
-;   mov x20, #0x55
-;   mov x21, #0x5a
-;   mov x22, #0x5f
-;   mov x23, #0x64
-;   mov x24, #0x69
-;   mov x25, #0x6e
-;   mov x26, #0x73
-;   mov x27, #0x78
-;   mov x28, #0x7d
-;   mov x0, #0x82
-;   mov x1, #0x87
-;   sub sp, sp, #0x20
-;   stur x0, [sp]
-;   stur x1, [sp, #8]
-;   add x0, sp, #0x10
-;   ldr x1, #0x88
-;   b #0x90
+;   mov x0, #0x50
+;   mov x1, #0x55
+;   mov x23, #0x5a
+;   mov x24, #0x5f
+;   mov x25, #0x64
+;   mov x26, #0x69
+;   mov x27, #0x6e
+;   mov x28, #0x73
+;   mov x21, #0x78
+;   mov x19, #0x7d
+;   mov x20, #0x82
+;   mov x22, #0x87
+;   stur x8, [sp]
+;   stur x9, [sp, #8]
+;   stur x10, [sp, #0x10]
+;   stur x11, [sp, #0x18]
+;   stur x12, [sp, #0x20]
+;   stur x13, [sp, #0x28]
+;   stur x14, [sp, #0x30]
+;   stur x15, [sp, #0x38]
+;   stur x0, [sp, #0x40]
+;   stur x1, [sp, #0x48]
+;   stur x23, [sp, #0x50]
+;   stur x24, [sp, #0x58]
+;   stur x25, [sp, #0x60]
+;   stur x26, [sp, #0x68]
+;   stur x27, [sp, #0x70]
+;   stur x28, [sp, #0x78]
+;   stur x21, [sp, #0x80]
+;   stur x19, [sp, #0x88]
+;   stur x20, [sp, #0x90]
+;   stur x22, [sp, #0x98]
+;   add x0, sp, #0xa0
+;   ldr x10, #0xe4
+;   b #0xec
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %tail_callee_stack_args_and_rets 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   blr x1
-;   ldur x9, [sp]
-;   ldur x2, [sp, #8]
-;   add sp, sp, #0x10
+;   blr x10
+;   sub sp, sp, #0xa0
+;   ldur x7, [sp, #0xa0]
+;   ldur x9, [sp, #0xa8]
+;   ldur x11, [sp, #0xb0]
+;   ldur x13, [sp, #0xb8]
+;   ldur x15, [sp, #0xc0]
+;   ldur x1, [sp, #0xc8]
+;   ldur x3, [sp, #0xd0]
+;   ldur x5, [sp, #0xd8]
+;   ldur x7, [sp, #0xe0]
+;   ldur x9, [sp, #0xe8]
+;   ldur x11, [sp, #0xf0]
+;   ldur x13, [sp, #0xf8]
+;   ldr x15, [sp, #0x100]
+;   ldr x1, [sp, #0x108]
+;   ldr x3, [sp, #0x110]
+;   ldr x5, [sp, #0x118]
+;   ldr x7, [sp, #0x120]
+;   ldr x9, [sp, #0x128]
+;   ldr x11, [sp, #0x130]
+;   ldr x2, [sp, #0x138]
+;   add sp, sp, #0x140
+;   ldp x19, x20, [sp], #0x10
+;   ldp x21, x22, [sp], #0x10
+;   ldp x23, x24, [sp], #0x10
+;   ldp x25, x26, [sp], #0x10
+;   ldp x27, x28, [sp], #0x10
 ;   ldp x29, x30, [sp], #0x10
 ;   ret
 
diff --git a/cranelift/filetests/filetests/isa/aarch64/tls-elf-gd.clif b/cranelift/filetests/filetests/isa/aarch64/tls-elf-gd.clif
index 9aec19e6867a..7f185e4b2e81 100644
--- a/cranelift/filetests/filetests/isa/aarch64/tls-elf-gd.clif
+++ b/cranelift/filetests/filetests/isa/aarch64/tls-elf-gd.clif
@@ -13,21 +13,11 @@ block0(v0: i32):
 ; VCode:
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
-;   str x24, [sp, #-16]!
-;   stp d14, d15, [sp, #-16]!
-;   stp d12, d13, [sp, #-16]!
-;   stp d10, d11, [sp, #-16]!
-;   stp d8, d9, [sp, #-16]!
 ; block0:
-;   mov x24, x0
-;   elf_tls_get_addr x0, userextname0
+;   mov x6, x0
+;   elf_tls_get_addr x0, x3, userextname0
 ;   mov x1, x0
-;   mov x0, x24
-;   ldp d8, d9, [sp], #16
-;   ldp d10, d11, [sp], #16
-;   ldp d12, d13, [sp], #16
-;   ldp d14, d15, [sp], #16
-;   ldr x24, [sp], #16
+;   mov x0, x6
 ;   ldp fp, lr, [sp], #16
 ;   ret
 ;
@@ -35,24 +25,16 @@ block0(v0: i32):
 ; block0: ; offset 0x0
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
-;   str x24, [sp, #-0x10]!
-;   stp d14, d15, [sp, #-0x10]!
-;   stp d12, d13, [sp, #-0x10]!
-;   stp d10, d11, [sp, #-0x10]!
-;   stp d8, d9, [sp, #-0x10]!
-; block1: ; offset 0x1c
-;   mov x24, x0
-;   adrp x0, #0 ; reloc_external Aarch64TlsGdAdrPage21 u1:0 0
-;   add x0, x0, #0 ; reloc_external Aarch64TlsGdAddLo12Nc u1:0 0
-;   bl #0x28 ; reloc_external Call %ElfTlsGetAddr 0
-;   nop
+; block1: ; offset 0x8
+;   mov x6, x0
+;   adrp x0, #0 ; reloc_external Aarch64TlsDescAdrPage21 u1:0 0
+;   ldr x3, [x0] ; reloc_external Aarch64TlsDescLd64Lo12 u1:0 0
+;   add x0, x0, #0 ; reloc_external Aarch64TlsDescAddLo12 u1:0 0
+;   blr x3 ; reloc_external Aarch64TlsDescCall u1:0 0
+;   mrs x3, tpidr_el0
+;   add x0, x0, x3
 ;   mov x1, x0
-;   mov x0, x24
-;   ldp d8, d9, [sp], #0x10
-;   ldp d10, d11, [sp], #0x10
-;   ldp d12, d13, [sp], #0x10
-;   ldp d14, d15, [sp], #0x10
-;   ldr x24, [sp], #0x10
+;   mov x0, x6
 ;   ldp x29, x30, [sp], #0x10
 ;   ret
 
diff --git a/cranelift/filetests/filetests/isa/aarch64/tls-macho.clif b/cranelift/filetests/filetests/isa/aarch64/tls-macho.clif
index 5a74b0948444..23a20eb52ce1 100644
--- a/cranelift/filetests/filetests/isa/aarch64/tls-macho.clif
+++ b/cranelift/filetests/filetests/isa/aarch64/tls-macho.clif
@@ -13,21 +13,21 @@ block0(v0: i32):
 ; VCode:
 ;   stp fp, lr, [sp, #-16]!
 ;   mov fp, sp
-;   str x24, [sp, #-16]!
+;   str x25, [sp, #-16]!
 ;   stp d14, d15, [sp, #-16]!
 ;   stp d12, d13, [sp, #-16]!
 ;   stp d10, d11, [sp, #-16]!
 ;   stp d8, d9, [sp, #-16]!
 ; block0:
-;   mov x24, x0
+;   mov x25, x0
 ;   macho_tls_get_addr x0, userextname0
 ;   mov x1, x0
-;   mov x0, x24
+;   mov x0, x25
 ;   ldp d8, d9, [sp], #16
 ;   ldp d10, d11, [sp], #16
 ;   ldp d12, d13, [sp], #16
 ;   ldp d14, d15, [sp], #16
-;   ldr x24, [sp], #16
+;   ldr x25, [sp], #16
 ;   ldp fp, lr, [sp], #16
 ;   ret
 ;
@@ -35,24 +35,24 @@ block0(v0: i32):
 ; block0: ; offset 0x0
 ;   stp x29, x30, [sp, #-0x10]!
 ;   mov x29, sp
-;   str x24, [sp, #-0x10]!
+;   str x25, [sp, #-0x10]!
 ;   stp d14, d15, [sp, #-0x10]!
 ;   stp d12, d13, [sp, #-0x10]!
 ;   stp d10, d11, [sp, #-0x10]!
 ;   stp d8, d9, [sp, #-0x10]!
 ; block1: ; offset 0x1c
-;   mov x24, x0
+;   mov x25, x0
 ;   adrp x0, #0 ; reloc_external MachOAarch64TlsAdrPage21 u1:0 0
 ;   ldr x0, [x0] ; reloc_external MachOAarch64TlsAdrPageOff12 u1:0 0
 ;   ldr x1, [x0]
 ;   blr x1
 ;   mov x1, x0
-;   mov x0, x24
+;   mov x0, x25
 ;   ldp d8, d9, [sp], #0x10
 ;   ldp d10, d11, [sp], #0x10
 ;   ldp d12, d13, [sp], #0x10
 ;   ldp d14, d15, [sp], #0x10
-;   ldr x24, [sp], #0x10
+;   ldr x25, [sp], #0x10
 ;   ldp x29, x30, [sp], #0x10
 ;   ret
 
diff --git a/cranelift/filetests/filetests/isa/aarch64/trap_sdiv.clif b/cranelift/filetests/filetests/isa/aarch64/trap_sdiv.clif
new file mode 100644
index 000000000000..c780f31e5346
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/aarch64/trap_sdiv.clif
@@ -0,0 +1,123 @@
+test compile precise-output
+target aarch64
+
+function %div8(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+  v2 = sdiv v0, v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   sxtb x3, w0
+;   sxtb x5, w1
+;   cbz x5, #trap=int_divz
+;   lsl w8, w3, #24
+;   adds wzr, w5, #1
+;   ccmp w8, #1, #nzcv, eq
+;   b.vs #trap=int_ovf
+;   sdiv x0, x3, x5
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   sxtb x3, w0
+;   sxtb x5, w1
+;   cbz x5, #0x24
+;   lsl w8, w3, #0x18
+;   cmn w5, #1
+;   ccmp w8, #1, #0, eq
+;   b.vs #0x28
+;   sdiv x0, x3, x5
+;   ret
+;   .byte 0x1f, 0xc1, 0x00, 0x00 ; trap: int_divz
+;   .byte 0x1f, 0xc1, 0x00, 0x00 ; trap: int_ovf
+
+function %div16(i16, i16) -> i16 {
+block0(v0: i16, v1: i16):
+  v2 = sdiv v0, v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   sxth x3, w0
+;   sxth x5, w1
+;   cbz x5, #trap=int_divz
+;   lsl w8, w3, #16
+;   adds wzr, w5, #1
+;   ccmp w8, #1, #nzcv, eq
+;   b.vs #trap=int_ovf
+;   sdiv x0, x3, x5
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   sxth x3, w0
+;   sxth x5, w1
+;   cbz x5, #0x24
+;   lsl w8, w3, #0x10
+;   cmn w5, #1
+;   ccmp w8, #1, #0, eq
+;   b.vs #0x28
+;   sdiv x0, x3, x5
+;   ret
+;   .byte 0x1f, 0xc1, 0x00, 0x00 ; trap: int_divz
+;   .byte 0x1f, 0xc1, 0x00, 0x00 ; trap: int_ovf
+
+function %div32(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+  v2 = sdiv v0, v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   sxtw x3, w0
+;   sxtw x5, w1
+;   cbz x5, #trap=int_divz
+;   adds wzr, w5, #1
+;   ccmp w3, #1, #nzcv, eq
+;   b.vs #trap=int_ovf
+;   sdiv x0, x3, x5
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   sxtw x3, w0
+;   sxtw x5, w1
+;   cbz x5, #0x20
+;   cmn w5, #1
+;   ccmp w3, #1, #0, eq
+;   b.vs #0x24
+;   sdiv x0, x3, x5
+;   ret
+;   .byte 0x1f, 0xc1, 0x00, 0x00 ; trap: int_divz
+;   .byte 0x1f, 0xc1, 0x00, 0x00 ; trap: int_ovf
+
+function %div64(i64, i64) -> i64 {
+block0(v0: i64, v1: i64):
+  v2 = sdiv v0, v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   cbz x1, #trap=int_divz
+;   adds xzr, x1, #1
+;   ccmp x0, #1, #nzcv, eq
+;   b.vs #trap=int_ovf
+;   sdiv x0, x0, x1
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   cbz x1, #0x18
+;   cmn x1, #1
+;   ccmp x0, #1, #0, eq
+;   b.vs #0x1c
+;   sdiv x0, x0, x1
+;   ret
+;   .byte 0x1f, 0xc1, 0x00, 0x00 ; trap: int_divz
+;   .byte 0x1f, 0xc1, 0x00, 0x00 ; trap: int_ovf
+
diff --git a/cranelift/filetests/filetests/isa/aarch64/uext-sext-handling.clif b/cranelift/filetests/filetests/isa/aarch64/uext-sext-handling.clif
new file mode 100644
index 000000000000..473f3b7f1692
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/aarch64/uext-sext-handling.clif
@@ -0,0 +1,36 @@
+test compile
+target aarch64
+
+; The aapcs64 call conv ignores the uext and sext flags
+function u0:0(i8) system_v {
+    sig0 = (i8 uext) system_v
+    fn0 = u0:0 sig0
+
+block0(v0: i8):
+    call fn0(v0)
+    return
+}
+
+; check: stp fp, lr, [sp, #-16]!
+; nextln: mov fp, sp
+; nextln: block0:
+; check-not: uxtb w0, w0
+; nextln: load_ext_name x2, User(userextname0)+0
+; nextln: blr x2
+
+; The aaple aarch64 call conv respects the uext and sext flags
+function u0:0(i8) apple_aarch64 {
+    sig0 = (i8 uext) apple_aarch64
+    fn0 = u0:0 sig0
+
+block0(v0: i8):
+    call fn0(v0)
+    return
+}
+
+; check: stp fp, lr, [sp, #-16]!
+; nextln: mov fp, sp
+; nextln: block0:
+; nextln: uxtb w0, w0
+; nextln: load_ext_name x4, User(userextname0)+0
+; nextln: blr x4
diff --git a/cranelift/filetests/filetests/isa/aarch64/user_stack_maps.clif b/cranelift/filetests/filetests/isa/aarch64/user_stack_maps.clif
new file mode 100644
index 000000000000..531ecb748afe
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/aarch64/user_stack_maps.clif
@@ -0,0 +1,207 @@
+test compile precise-output
+set unwind_info=false
+set enable_probestack=false
+target aarch64
+
+function %foo() system_v {
+    ss0 = explicit_slot 12, align = 4
+    sig0 = (i32) system_v
+    fn0 = colocated u0:0 sig0
+
+block0:
+    v0 = iconst.i32 0
+    v1 = iconst.i32 1
+    v2 = iconst.i32 2
+    v3 = iconst.i32 3
+
+    stack_store v0, ss0
+    stack_store v1, ss0+4
+    stack_store v2, ss0+8
+    call fn0(v0), stack_map=[i32 @ ss0+0, i32 @ ss0+4, i32 @ ss0+8]
+
+    stack_store v1, ss0
+    stack_store v2, ss0+4
+    call fn0(v0), stack_map=[i32 @ ss0+0, i32 @ ss0+4]
+
+    stack_store v2, ss0
+    call fn0(v1), stack_map=[i32 @ ss0+0]
+
+    call fn0(v2)
+
+    return
+}
+
+; VCode:
+;   stp fp, lr, [sp, #-16]!
+;   mov fp, sp
+;   str x28, [sp, #-16]!
+;   stp x19, x21, [sp, #-16]!
+;   sub sp, sp, #16
+; block0:
+;   movz w19, #0
+;   movz w28, #1
+;   movz w21, #2
+;   mov x8, sp
+;   str w19, [x8]
+;   add x9, sp, #4
+;   str w28, [x9]
+;   add x10, sp, #8
+;   str w21, [x10]
+;   mov x0, x19
+;   bl 0
+;   ; UserStackMap { by_type: [(types::I32, CompoundBitSet {0, 4, 8})], sp_to_sized_stack_slots: None }
+;   mov x12, sp
+;   str w28, [x12]
+;   add x13, sp, #4
+;   str w21, [x13]
+;   mov x0, x19
+;   bl 0
+;   ; UserStackMap { by_type: [(types::I32, CompoundBitSet {0, 4})], sp_to_sized_stack_slots: None }
+;   mov x15, sp
+;   str w21, [x15]
+;   mov x0, x28
+;   bl 0
+;   ; UserStackMap { by_type: [(types::I32, CompoundBitSet {0})], sp_to_sized_stack_slots: None }
+;   mov x0, x21
+;   bl 0
+;   add sp, sp, #16
+;   ldp x19, x21, [sp], #16
+;   ldr x28, [sp], #16
+;   ldp fp, lr, [sp], #16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stp x29, x30, [sp, #-0x10]!
+;   mov x29, sp
+;   str x28, [sp, #-0x10]!
+;   stp x19, x21, [sp, #-0x10]!
+;   sub sp, sp, #0x10
+; block1: ; offset 0x14
+;   mov w19, #0
+;   mov w28, #1
+;   mov w21, #2
+;   mov x8, sp
+;   str w19, [x8]
+;   add x9, sp, #4
+;   str w28, [x9]
+;   add x10, sp, #8
+;   str w21, [x10]
+;   mov x0, x19
+;   bl #0x3c ; reloc_external Call u0:0 0
+;   mov x12, sp
+;   str w28, [x12]
+;   add x13, sp, #4
+;   str w21, [x13]
+;   mov x0, x19
+;   bl #0x54 ; reloc_external Call u0:0 0
+;   mov x15, sp
+;   str w21, [x15]
+;   mov x0, x28
+;   bl #0x64 ; reloc_external Call u0:0 0
+;   mov x0, x21
+;   bl #0x6c ; reloc_external Call u0:0 0
+;   add sp, sp, #0x10
+;   ldp x19, x21, [sp], #0x10
+;   ldr x28, [sp], #0x10
+;   ldp x29, x30, [sp], #0x10
+;   ret
+
+function %different_types(i8, i16, i32, i64, f32, f64) -> i8, i16, i32, i64, f32, f64 {
+    ss0 = explicit_slot 1
+    ss1 = explicit_slot 2, align = 2
+    ss2 = explicit_slot 8, align = 4
+    ss3 = explicit_slot 16, align = 8
+    ss4 = explicit_slot 48, align = 16
+    sig0 = () system_v
+    fn0 = colocated u0:0 sig0
+
+block0(v0: i8, v1: i16, v2: i32, v3: i64, v4: f32, v5: f64):
+    stack_store v0, ss0
+    stack_store v1, ss1
+    stack_store v2, ss2
+    stack_store v4, ss2+4
+    stack_store v3, ss3
+    stack_store v5, ss3+8
+    call fn0(), stack_map=[i8 @ ss0+0, i16 @ ss1+0, i32 @ ss2+0, f32 @ ss2+4, i64 @ ss3+0, f64 @ ss3+8]
+    return v0, v1, v2, v3, v4, v5
+}
+
+; VCode:
+;   stp fp, lr, [sp, #-16]!
+;   mov fp, sp
+;   stp x23, x26, [sp, #-16]!
+;   stp x19, x21, [sp, #-16]!
+;   sub sp, sp, #128
+; block0:
+;   mov x12, sp
+;   strb w0, [x12]
+;   mov x21, x0
+;   add x13, sp, #8
+;   strh w1, [x13]
+;   mov x26, x1
+;   add x14, sp, #16
+;   str w2, [x14]
+;   mov x23, x2
+;   add x15, sp, #20
+;   str s0, [x15]
+;   str q0, [sp, #96]
+;   add x0, sp, #24
+;   str x3, [x0]
+;   mov x19, x3
+;   add x1, sp, #32
+;   str d1, [x1]
+;   str q1, [sp, #112]
+;   bl 0
+;   ; UserStackMap { by_type: [(types::I8, CompoundBitSet {0}), (types::I16, CompoundBitSet {8}), (types::I32, CompoundBitSet {16}), (types::F32, CompoundBitSet {20}), (types::I64, CompoundBitSet {24}), (types::F64, CompoundBitSet {32})], sp_to_sized_stack_slots: None }
+;   mov x0, x21
+;   mov x1, x26
+;   mov x2, x23
+;   mov x3, x19
+;   ldr q0, [sp, #96]
+;   ldr q1, [sp, #112]
+;   add sp, sp, #128
+;   ldp x19, x21, [sp], #16
+;   ldp x23, x26, [sp], #16
+;   ldp fp, lr, [sp], #16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stp x29, x30, [sp, #-0x10]!
+;   mov x29, sp
+;   stp x23, x26, [sp, #-0x10]!
+;   stp x19, x21, [sp, #-0x10]!
+;   sub sp, sp, #0x80
+; block1: ; offset 0x14
+;   mov x12, sp
+;   strb w0, [x12]
+;   mov x21, x0
+;   add x13, sp, #8
+;   strh w1, [x13]
+;   mov x26, x1
+;   add x14, sp, #0x10
+;   str w2, [x14]
+;   mov x23, x2
+;   add x15, sp, #0x14
+;   str s0, [x15]
+;   stur q0, [sp, #0x60]
+;   add x0, sp, #0x18
+;   str x3, [x0]
+;   mov x19, x3
+;   add x1, sp, #0x20
+;   str d1, [x1]
+;   stur q1, [sp, #0x70]
+;   bl #0x5c ; reloc_external Call u0:0 0
+;   mov x0, x21
+;   mov x1, x26
+;   mov x2, x23
+;   mov x3, x19
+;   ldur q0, [sp, #0x60]
+;   ldur q1, [sp, #0x70]
+;   add sp, sp, #0x80
+;   ldp x19, x21, [sp], #0x10
+;   ldp x23, x26, [sp], #0x10
+;   ldp x29, x30, [sp], #0x10
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 5be7248ea2d1..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   mov w7, w0
-;;   ldr x8, [x2, #8]
-;;   sub x8, x8, #4
-;;   subs xzr, x7, x8
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x9, [x2]
-;;   str w1, [x9, w0, UXTW]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   mov w7, w0
-;;   ldr x8, [x1, #8]
-;;   sub x8, x8, #4
-;;   subs xzr, x7, x8
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x9, [x1]
-;;   ldr w0, [x9, w0, UXTW]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 154b1ce23d16..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   mov w9, w0
-;;   ldr x10, [x2, #8]
-;;   movn x11, #4099
-;;   add x10, x10, x11
-;;   subs xzr, x9, x10
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x11, [x2]
-;;   add x11, x11, #4096
-;;   str w1, [x11, w0, UXTW]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   mov w9, w0
-;;   ldr x10, [x1, #8]
-;;   movn x11, #4099
-;;   add x10, x10, x11
-;;   subs xzr, x9, x10
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x11, [x1]
-;;   add x10, x11, #4096
-;;   ldr w0, [x10, w0, UXTW]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 0238c249d9f4..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   mov w10, w0
-;;   movn w11, #65531
-;;   adds x10, x10, x11
-;;   b.hs #trap=heap_oob
-;;   ldr x11, [x2, #8]
-;;   subs xzr, x10, x11
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x13, [x2]
-;;   add x13, x13, x0, UXTW
-;;   movz x14, #65535, LSL #16
-;;   str w1, [x13, x14]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   mov w10, w0
-;;   movn w11, #65531
-;;   adds x10, x10, x11
-;;   b.hs #trap=heap_oob
-;;   ldr x11, [x1, #8]
-;;   subs xzr, x10, x11
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x13, [x1]
-;;   add x13, x13, x0, UXTW
-;;   movz x14, #65535, LSL #16
-;;   ldr w0, [x13, x14]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index f5d495057aae..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   mov w6, w0
-;;   ldr x7, [x2, #8]
-;;   subs xzr, x6, x7
-;;   b.hs label3 ; b label1
-;; block1:
-;;   ldr x8, [x2]
-;;   strb w1, [x8, w0, UXTW]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   mov w6, w0
-;;   ldr x7, [x1, #8]
-;;   subs xzr, x6, x7
-;;   b.hs label3 ; b label1
-;; block1:
-;;   ldr x8, [x1]
-;;   ldrb w0, [x8, w0, UXTW]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 1b255cb20419..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   mov w9, w0
-;;   ldr x10, [x2, #8]
-;;   movn x11, #4096
-;;   add x10, x10, x11
-;;   subs xzr, x9, x10
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x11, [x2]
-;;   add x11, x11, #4096
-;;   strb w1, [x11, w0, UXTW]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   mov w9, w0
-;;   ldr x10, [x1, #8]
-;;   movn x11, #4096
-;;   add x10, x10, x11
-;;   subs xzr, x9, x10
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x11, [x1]
-;;   add x10, x11, #4096
-;;   ldrb w0, [x10, w0, UXTW]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index c867fbe749f2..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   mov w10, w0
-;;   movn w11, #65534
-;;   adds x10, x10, x11
-;;   b.hs #trap=heap_oob
-;;   ldr x11, [x2, #8]
-;;   subs xzr, x10, x11
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x13, [x2]
-;;   add x13, x13, x0, UXTW
-;;   movz x14, #65535, LSL #16
-;;   strb w1, [x13, x14]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   mov w10, w0
-;;   movn w11, #65534
-;;   adds x10, x10, x11
-;;   b.hs #trap=heap_oob
-;;   ldr x11, [x1, #8]
-;;   subs xzr, x10, x11
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x13, [x1]
-;;   add x13, x13, x0, UXTW
-;;   movz x14, #65535, LSL #16
-;;   ldrb w0, [x13, x14]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index c1a0052ad19c..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   mov w10, w0
-;;   ldr x11, [x2, #8]
-;;   sub x11, x11, #4
-;;   ldr x12, [x2]
-;;   add x12, x12, x0, UXTW
-;;   movz x13, #0
-;;   subs xzr, x10, x11
-;;   csel x11, x13, x12, hi
-;;   csdb
-;;   str w1, [x11]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   mov w10, w0
-;;   ldr x11, [x1, #8]
-;;   sub x11, x11, #4
-;;   ldr x12, [x1]
-;;   add x12, x12, x0, UXTW
-;;   movz x13, #0
-;;   subs xzr, x10, x11
-;;   csel x11, x13, x12, hi
-;;   csdb
-;;   ldr w0, [x11]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index c917cceeaeeb..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   mov w12, w0
-;;   ldr x13, [x2, #8]
-;;   movn x14, #4099
-;;   add x13, x13, x14
-;;   ldr x14, [x2]
-;;   add x14, x14, x0, UXTW
-;;   add x14, x14, #4096
-;;   movz x15, #0
-;;   subs xzr, x12, x13
-;;   csel x13, x15, x14, hi
-;;   csdb
-;;   str w1, [x13]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   mov w12, w0
-;;   ldr x13, [x1, #8]
-;;   movn x14, #4099
-;;   add x13, x13, x14
-;;   ldr x14, [x1]
-;;   add x14, x14, x0, UXTW
-;;   add x14, x14, #4096
-;;   movz x15, #0
-;;   subs xzr, x12, x13
-;;   csel x13, x15, x14, hi
-;;   csdb
-;;   ldr w0, [x13]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 4de99642b576..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   mov w13, w0
-;;   movn w14, #65531
-;;   adds x13, x13, x14
-;;   b.hs #trap=heap_oob
-;;   ldr x14, [x2, #8]
-;;   ldr x15, [x2]
-;;   add x15, x15, x0, UXTW
-;;   movz x0, #65535, LSL #16
-;;   add x15, x15, x0
-;;   movz x0, #0
-;;   subs xzr, x13, x14
-;;   csel x15, x0, x15, hi
-;;   csdb
-;;   str w1, [x15]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   mov w13, w0
-;;   movn w14, #65531
-;;   adds x13, x13, x14
-;;   b.hs #trap=heap_oob
-;;   ldr x14, [x1, #8]
-;;   ldr x15, [x1]
-;;   add x15, x15, x0, UXTW
-;;   movz x0, #65535, LSL #16
-;;   add x15, x15, x0
-;;   movz x0, #0
-;;   subs xzr, x13, x14
-;;   csel x15, x0, x15, hi
-;;   csdb
-;;   ldr w0, [x15]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index e066c1e8b6c9..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   mov w9, w0
-;;   ldr x10, [x2, #8]
-;;   ldr x11, [x2]
-;;   add x11, x11, x0, UXTW
-;;   movz x12, #0
-;;   subs xzr, x9, x10
-;;   csel x10, x12, x11, hs
-;;   csdb
-;;   strb w1, [x10]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   mov w9, w0
-;;   ldr x10, [x1, #8]
-;;   ldr x11, [x1]
-;;   add x11, x11, x0, UXTW
-;;   movz x12, #0
-;;   subs xzr, x9, x10
-;;   csel x10, x12, x11, hs
-;;   csdb
-;;   ldrb w0, [x10]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 14ef6fdd8d42..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   mov w12, w0
-;;   ldr x13, [x2, #8]
-;;   movn x14, #4096
-;;   add x13, x13, x14
-;;   ldr x14, [x2]
-;;   add x14, x14, x0, UXTW
-;;   add x14, x14, #4096
-;;   movz x15, #0
-;;   subs xzr, x12, x13
-;;   csel x13, x15, x14, hi
-;;   csdb
-;;   strb w1, [x13]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   mov w12, w0
-;;   ldr x13, [x1, #8]
-;;   movn x14, #4096
-;;   add x13, x13, x14
-;;   ldr x14, [x1]
-;;   add x14, x14, x0, UXTW
-;;   add x14, x14, #4096
-;;   movz x15, #0
-;;   subs xzr, x12, x13
-;;   csel x13, x15, x14, hi
-;;   csdb
-;;   ldrb w0, [x13]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index f4b29bfe8fce..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   mov w13, w0
-;;   movn w14, #65534
-;;   adds x13, x13, x14
-;;   b.hs #trap=heap_oob
-;;   ldr x14, [x2, #8]
-;;   ldr x15, [x2]
-;;   add x15, x15, x0, UXTW
-;;   movz x0, #65535, LSL #16
-;;   add x15, x15, x0
-;;   movz x0, #0
-;;   subs xzr, x13, x14
-;;   csel x15, x0, x15, hi
-;;   csdb
-;;   strb w1, [x15]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   mov w13, w0
-;;   movn w14, #65534
-;;   adds x13, x13, x14
-;;   b.hs #trap=heap_oob
-;;   ldr x14, [x1, #8]
-;;   ldr x15, [x1]
-;;   add x15, x15, x0, UXTW
-;;   movz x0, #65535, LSL #16
-;;   add x15, x15, x0
-;;   movz x0, #0
-;;   subs xzr, x13, x14
-;;   csel x15, x0, x15, hi
-;;   csdb
-;;   ldrb w0, [x15]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index c00574e05190..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   mov w6, w0
-;;   ldr x7, [x2, #8]
-;;   subs xzr, x6, x7
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x8, [x2]
-;;   str w1, [x8, w0, UXTW]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   mov w6, w0
-;;   ldr x7, [x1, #8]
-;;   subs xzr, x6, x7
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x8, [x1]
-;;   ldr w0, [x8, w0, UXTW]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 23715cf3c573..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   mov w7, w0
-;;   ldr x8, [x2, #8]
-;;   subs xzr, x7, x8
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x9, [x2]
-;;   add x9, x9, #4096
-;;   str w1, [x9, w0, UXTW]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   mov w7, w0
-;;   ldr x8, [x1, #8]
-;;   subs xzr, x7, x8
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x9, [x1]
-;;   add x8, x9, #4096
-;;   ldr w0, [x8, w0, UXTW]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 5e98e3ab470a..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   mov w8, w0
-;;   ldr x9, [x2, #8]
-;;   subs xzr, x8, x9
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x10, [x2]
-;;   add x10, x10, x0, UXTW
-;;   movz x11, #65535, LSL #16
-;;   str w1, [x10, x11]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   mov w8, w0
-;;   ldr x9, [x1, #8]
-;;   subs xzr, x8, x9
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x10, [x1]
-;;   add x10, x10, x0, UXTW
-;;   movz x11, #65535, LSL #16
-;;   ldr w0, [x10, x11]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index f78dcf838ace..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   mov w6, w0
-;;   ldr x7, [x2, #8]
-;;   subs xzr, x6, x7
-;;   b.hs label3 ; b label1
-;; block1:
-;;   ldr x8, [x2]
-;;   strb w1, [x8, w0, UXTW]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   mov w6, w0
-;;   ldr x7, [x1, #8]
-;;   subs xzr, x6, x7
-;;   b.hs label3 ; b label1
-;; block1:
-;;   ldr x8, [x1]
-;;   ldrb w0, [x8, w0, UXTW]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 7310b1078679..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   mov w7, w0
-;;   ldr x8, [x2, #8]
-;;   subs xzr, x7, x8
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x9, [x2]
-;;   add x9, x9, #4096
-;;   strb w1, [x9, w0, UXTW]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   mov w7, w0
-;;   ldr x8, [x1, #8]
-;;   subs xzr, x7, x8
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x9, [x1]
-;;   add x8, x9, #4096
-;;   ldrb w0, [x8, w0, UXTW]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 21d00ae4207e..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   mov w8, w0
-;;   ldr x9, [x2, #8]
-;;   subs xzr, x8, x9
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x10, [x2]
-;;   add x10, x10, x0, UXTW
-;;   movz x11, #65535, LSL #16
-;;   strb w1, [x10, x11]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   mov w8, w0
-;;   ldr x9, [x1, #8]
-;;   subs xzr, x8, x9
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x10, [x1]
-;;   add x10, x10, x0, UXTW
-;;   movz x11, #65535, LSL #16
-;;   ldrb w0, [x10, x11]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 2fd45db6f999..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   mov w9, w0
-;;   ldr x10, [x2, #8]
-;;   ldr x11, [x2]
-;;   add x11, x11, x0, UXTW
-;;   movz x12, #0
-;;   subs xzr, x9, x10
-;;   csel x10, x12, x11, hi
-;;   csdb
-;;   str w1, [x10]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   mov w9, w0
-;;   ldr x10, [x1, #8]
-;;   ldr x11, [x1]
-;;   add x11, x11, x0, UXTW
-;;   movz x12, #0
-;;   subs xzr, x9, x10
-;;   csel x10, x12, x11, hi
-;;   csdb
-;;   ldr w0, [x10]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index caaa5c7422ec..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   mov w10, w0
-;;   ldr x11, [x2, #8]
-;;   ldr x12, [x2]
-;;   add x12, x12, x0, UXTW
-;;   add x12, x12, #4096
-;;   movz x13, #0
-;;   subs xzr, x10, x11
-;;   csel x11, x13, x12, hi
-;;   csdb
-;;   str w1, [x11]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   mov w10, w0
-;;   ldr x11, [x1, #8]
-;;   ldr x12, [x1]
-;;   add x12, x12, x0, UXTW
-;;   add x12, x12, #4096
-;;   movz x13, #0
-;;   subs xzr, x10, x11
-;;   csel x11, x13, x12, hi
-;;   csdb
-;;   ldr w0, [x11]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 7cf6b60eb634..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   mov w11, w0
-;;   ldr x12, [x2, #8]
-;;   ldr x13, [x2]
-;;   add x13, x13, x0, UXTW
-;;   movz x14, #65535, LSL #16
-;;   add x13, x13, x14
-;;   movz x14, #0
-;;   subs xzr, x11, x12
-;;   csel x12, x14, x13, hi
-;;   csdb
-;;   str w1, [x12]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   mov w11, w0
-;;   ldr x12, [x1, #8]
-;;   ldr x13, [x1]
-;;   add x13, x13, x0, UXTW
-;;   movz x14, #65535, LSL #16
-;;   add x13, x13, x14
-;;   movz x14, #0
-;;   subs xzr, x11, x12
-;;   csel x12, x14, x13, hi
-;;   csdb
-;;   ldr w0, [x12]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 67990cf28ffd..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   mov w9, w0
-;;   ldr x10, [x2, #8]
-;;   ldr x11, [x2]
-;;   add x11, x11, x0, UXTW
-;;   movz x12, #0
-;;   subs xzr, x9, x10
-;;   csel x10, x12, x11, hs
-;;   csdb
-;;   strb w1, [x10]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   mov w9, w0
-;;   ldr x10, [x1, #8]
-;;   ldr x11, [x1]
-;;   add x11, x11, x0, UXTW
-;;   movz x12, #0
-;;   subs xzr, x9, x10
-;;   csel x10, x12, x11, hs
-;;   csdb
-;;   ldrb w0, [x10]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 8a818ff9a992..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   mov w10, w0
-;;   ldr x11, [x2, #8]
-;;   ldr x12, [x2]
-;;   add x12, x12, x0, UXTW
-;;   add x12, x12, #4096
-;;   movz x13, #0
-;;   subs xzr, x10, x11
-;;   csel x11, x13, x12, hi
-;;   csdb
-;;   strb w1, [x11]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   mov w10, w0
-;;   ldr x11, [x1, #8]
-;;   ldr x12, [x1]
-;;   add x12, x12, x0, UXTW
-;;   add x12, x12, #4096
-;;   movz x13, #0
-;;   subs xzr, x10, x11
-;;   csel x11, x13, x12, hi
-;;   csdb
-;;   ldrb w0, [x11]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index b1c0307ed8f6..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   mov w11, w0
-;;   ldr x12, [x2, #8]
-;;   ldr x13, [x2]
-;;   add x13, x13, x0, UXTW
-;;   movz x14, #65535, LSL #16
-;;   add x13, x13, x14
-;;   movz x14, #0
-;;   subs xzr, x11, x12
-;;   csel x12, x14, x13, hi
-;;   csdb
-;;   strb w1, [x12]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   mov w11, w0
-;;   ldr x12, [x1, #8]
-;;   ldr x13, [x1]
-;;   add x13, x13, x0, UXTW
-;;   movz x14, #65535, LSL #16
-;;   add x13, x13, x14
-;;   movz x14, #0
-;;   subs xzr, x11, x12
-;;   csel x12, x14, x13, hi
-;;   csdb
-;;   ldrb w0, [x12]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index d39c4d5afa31..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   ldr x6, [x2, #8]
-;;   sub x6, x6, #4
-;;   subs xzr, x0, x6
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x8, [x2]
-;;   str w1, [x8, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x6, [x1, #8]
-;;   sub x6, x6, #4
-;;   subs xzr, x0, x6
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x8, [x1]
-;;   ldr w0, [x8, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index f3de9844911d..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   ldr x8, [x2, #8]
-;;   movn x9, #4099
-;;   add x8, x8, x9
-;;   subs xzr, x0, x8
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x10, [x2]
-;;   add x10, x10, #4096
-;;   str w1, [x10, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x8, [x1, #8]
-;;   movn x9, #4099
-;;   add x8, x8, x9
-;;   subs xzr, x0, x8
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x10, [x1]
-;;   add x9, x10, #4096
-;;   ldr w0, [x9, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 8579f91a0bca..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   movn w9, #65531
-;;   adds x9, x0, x9
-;;   b.hs #trap=heap_oob
-;;   ldr x10, [x2, #8]
-;;   subs xzr, x9, x10
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x12, [x2]
-;;   add x12, x12, x0
-;;   movz x13, #65535, LSL #16
-;;   str w1, [x12, x13]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   movn w9, #65531
-;;   adds x9, x0, x9
-;;   b.hs #trap=heap_oob
-;;   ldr x10, [x1, #8]
-;;   subs xzr, x9, x10
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x12, [x1]
-;;   add x12, x12, x0
-;;   movz x13, #65535, LSL #16
-;;   ldr w0, [x12, x13]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index c91e916d7cd1..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   ldr x5, [x2, #8]
-;;   subs xzr, x0, x5
-;;   b.hs label3 ; b label1
-;; block1:
-;;   ldr x7, [x2]
-;;   strb w1, [x7, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x5, [x1, #8]
-;;   subs xzr, x0, x5
-;;   b.hs label3 ; b label1
-;; block1:
-;;   ldr x7, [x1]
-;;   ldrb w0, [x7, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 5a15eb207f0f..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   ldr x8, [x2, #8]
-;;   movn x9, #4096
-;;   add x8, x8, x9
-;;   subs xzr, x0, x8
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x10, [x2]
-;;   add x10, x10, #4096
-;;   strb w1, [x10, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x8, [x1, #8]
-;;   movn x9, #4096
-;;   add x8, x8, x9
-;;   subs xzr, x0, x8
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x10, [x1]
-;;   add x9, x10, #4096
-;;   ldrb w0, [x9, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index f5c183221ca5..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   movn w9, #65534
-;;   adds x9, x0, x9
-;;   b.hs #trap=heap_oob
-;;   ldr x10, [x2, #8]
-;;   subs xzr, x9, x10
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x12, [x2]
-;;   add x12, x12, x0
-;;   movz x13, #65535, LSL #16
-;;   strb w1, [x12, x13]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   movn w9, #65534
-;;   adds x9, x0, x9
-;;   b.hs #trap=heap_oob
-;;   ldr x10, [x1, #8]
-;;   subs xzr, x9, x10
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x12, [x1]
-;;   add x12, x12, x0
-;;   movz x13, #65535, LSL #16
-;;   ldrb w0, [x12, x13]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index f09ae0ad1ec0..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   ldr x9, [x2, #8]
-;;   sub x9, x9, #4
-;;   ldr x10, [x2]
-;;   add x10, x10, x0
-;;   movz x11, #0
-;;   subs xzr, x0, x9
-;;   csel x10, x11, x10, hi
-;;   csdb
-;;   str w1, [x10]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x9, [x1, #8]
-;;   sub x9, x9, #4
-;;   ldr x10, [x1]
-;;   add x10, x10, x0
-;;   movz x11, #0
-;;   subs xzr, x0, x9
-;;   csel x10, x11, x10, hi
-;;   csdb
-;;   ldr w0, [x10]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 6ac9272ab005..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   ldr x11, [x2, #8]
-;;   movn x12, #4099
-;;   add x11, x11, x12
-;;   ldr x12, [x2]
-;;   add x12, x12, x0
-;;   add x12, x12, #4096
-;;   movz x13, #0
-;;   subs xzr, x0, x11
-;;   csel x12, x13, x12, hi
-;;   csdb
-;;   str w1, [x12]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x11, [x1, #8]
-;;   movn x12, #4099
-;;   add x11, x11, x12
-;;   ldr x12, [x1]
-;;   add x12, x12, x0
-;;   add x12, x12, #4096
-;;   movz x13, #0
-;;   subs xzr, x0, x11
-;;   csel x12, x13, x12, hi
-;;   csdb
-;;   ldr w0, [x12]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index a3655408552b..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   movn w12, #65531
-;;   adds x12, x0, x12
-;;   b.hs #trap=heap_oob
-;;   ldr x13, [x2, #8]
-;;   ldr x14, [x2]
-;;   add x14, x14, x0
-;;   movz x15, #65535, LSL #16
-;;   add x14, x14, x15
-;;   movz x15, #0
-;;   subs xzr, x12, x13
-;;   csel x14, x15, x14, hi
-;;   csdb
-;;   str w1, [x14]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   movn w12, #65531
-;;   adds x12, x0, x12
-;;   b.hs #trap=heap_oob
-;;   ldr x13, [x1, #8]
-;;   ldr x14, [x1]
-;;   add x14, x14, x0
-;;   movz x15, #65535, LSL #16
-;;   add x14, x14, x15
-;;   movz x15, #0
-;;   subs xzr, x12, x13
-;;   csel x14, x15, x14, hi
-;;   csdb
-;;   ldr w0, [x14]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 4de033d48050..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   ldr x8, [x2, #8]
-;;   ldr x9, [x2]
-;;   add x9, x9, x0
-;;   movz x10, #0
-;;   subs xzr, x0, x8
-;;   csel x9, x10, x9, hs
-;;   csdb
-;;   strb w1, [x9]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x8, [x1, #8]
-;;   ldr x9, [x1]
-;;   add x9, x9, x0
-;;   movz x10, #0
-;;   subs xzr, x0, x8
-;;   csel x9, x10, x9, hs
-;;   csdb
-;;   ldrb w0, [x9]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 72e9ff240a1c..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   ldr x11, [x2, #8]
-;;   movn x12, #4096
-;;   add x11, x11, x12
-;;   ldr x12, [x2]
-;;   add x12, x12, x0
-;;   add x12, x12, #4096
-;;   movz x13, #0
-;;   subs xzr, x0, x11
-;;   csel x12, x13, x12, hi
-;;   csdb
-;;   strb w1, [x12]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x11, [x1, #8]
-;;   movn x12, #4096
-;;   add x11, x11, x12
-;;   ldr x12, [x1]
-;;   add x12, x12, x0
-;;   add x12, x12, #4096
-;;   movz x13, #0
-;;   subs xzr, x0, x11
-;;   csel x12, x13, x12, hi
-;;   csdb
-;;   ldrb w0, [x12]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 44bba3f36d45..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   movn w12, #65534
-;;   adds x12, x0, x12
-;;   b.hs #trap=heap_oob
-;;   ldr x13, [x2, #8]
-;;   ldr x14, [x2]
-;;   add x14, x14, x0
-;;   movz x15, #65535, LSL #16
-;;   add x14, x14, x15
-;;   movz x15, #0
-;;   subs xzr, x12, x13
-;;   csel x14, x15, x14, hi
-;;   csdb
-;;   strb w1, [x14]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   movn w12, #65534
-;;   adds x12, x0, x12
-;;   b.hs #trap=heap_oob
-;;   ldr x13, [x1, #8]
-;;   ldr x14, [x1]
-;;   add x14, x14, x0
-;;   movz x15, #65535, LSL #16
-;;   add x14, x14, x15
-;;   movz x15, #0
-;;   subs xzr, x12, x13
-;;   csel x14, x15, x14, hi
-;;   csdb
-;;   ldrb w0, [x14]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index bc5472cdd259..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   ldr x5, [x2, #8]
-;;   subs xzr, x0, x5
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x7, [x2]
-;;   str w1, [x7, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x5, [x1, #8]
-;;   subs xzr, x0, x5
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x7, [x1]
-;;   ldr w0, [x7, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 6b383ae8abc2..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   ldr x6, [x2, #8]
-;;   subs xzr, x0, x6
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x8, [x2]
-;;   add x8, x8, #4096
-;;   str w1, [x8, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x6, [x1, #8]
-;;   subs xzr, x0, x6
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x8, [x1]
-;;   add x7, x8, #4096
-;;   ldr w0, [x7, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 72d7e0999cd3..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   ldr x7, [x2, #8]
-;;   subs xzr, x0, x7
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x9, [x2]
-;;   add x9, x9, x0
-;;   movz x10, #65535, LSL #16
-;;   str w1, [x9, x10]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x7, [x1, #8]
-;;   subs xzr, x0, x7
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x9, [x1]
-;;   add x9, x9, x0
-;;   movz x10, #65535, LSL #16
-;;   ldr w0, [x9, x10]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index d16fca1aea3c..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   ldr x5, [x2, #8]
-;;   subs xzr, x0, x5
-;;   b.hs label3 ; b label1
-;; block1:
-;;   ldr x7, [x2]
-;;   strb w1, [x7, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x5, [x1, #8]
-;;   subs xzr, x0, x5
-;;   b.hs label3 ; b label1
-;; block1:
-;;   ldr x7, [x1]
-;;   ldrb w0, [x7, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 4a23e244afec..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   ldr x6, [x2, #8]
-;;   subs xzr, x0, x6
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x8, [x2]
-;;   add x8, x8, #4096
-;;   strb w1, [x8, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x6, [x1, #8]
-;;   subs xzr, x0, x6
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x8, [x1]
-;;   add x7, x8, #4096
-;;   ldrb w0, [x7, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index bca2c0388607..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   ldr x7, [x2, #8]
-;;   subs xzr, x0, x7
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x9, [x2]
-;;   add x9, x9, x0
-;;   movz x10, #65535, LSL #16
-;;   strb w1, [x9, x10]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x7, [x1, #8]
-;;   subs xzr, x0, x7
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x9, [x1]
-;;   add x9, x9, x0
-;;   movz x10, #65535, LSL #16
-;;   ldrb w0, [x9, x10]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 13f19a701363..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   ldr x8, [x2, #8]
-;;   ldr x9, [x2]
-;;   add x9, x9, x0
-;;   movz x10, #0
-;;   subs xzr, x0, x8
-;;   csel x9, x10, x9, hi
-;;   csdb
-;;   str w1, [x9]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x8, [x1, #8]
-;;   ldr x9, [x1]
-;;   add x9, x9, x0
-;;   movz x10, #0
-;;   subs xzr, x0, x8
-;;   csel x9, x10, x9, hi
-;;   csdb
-;;   ldr w0, [x9]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 0b1c0abab533..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   ldr x9, [x2, #8]
-;;   ldr x10, [x2]
-;;   add x10, x10, x0
-;;   add x10, x10, #4096
-;;   movz x11, #0
-;;   subs xzr, x0, x9
-;;   csel x10, x11, x10, hi
-;;   csdb
-;;   str w1, [x10]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x9, [x1, #8]
-;;   ldr x10, [x1]
-;;   add x10, x10, x0
-;;   add x10, x10, #4096
-;;   movz x11, #0
-;;   subs xzr, x0, x9
-;;   csel x10, x11, x10, hi
-;;   csdb
-;;   ldr w0, [x10]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 8de45f0e4920..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   ldr x10, [x2, #8]
-;;   ldr x11, [x2]
-;;   add x11, x11, x0
-;;   movz x12, #65535, LSL #16
-;;   add x11, x11, x12
-;;   movz x12, #0
-;;   subs xzr, x0, x10
-;;   csel x11, x12, x11, hi
-;;   csdb
-;;   str w1, [x11]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x10, [x1, #8]
-;;   ldr x11, [x1]
-;;   add x11, x11, x0
-;;   movz x12, #65535, LSL #16
-;;   add x11, x11, x12
-;;   movz x12, #0
-;;   subs xzr, x0, x10
-;;   csel x11, x12, x11, hi
-;;   csdb
-;;   ldr w0, [x11]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 79c56568ddc9..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   ldr x8, [x2, #8]
-;;   ldr x9, [x2]
-;;   add x9, x9, x0
-;;   movz x10, #0
-;;   subs xzr, x0, x8
-;;   csel x9, x10, x9, hs
-;;   csdb
-;;   strb w1, [x9]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x8, [x1, #8]
-;;   ldr x9, [x1]
-;;   add x9, x9, x0
-;;   movz x10, #0
-;;   subs xzr, x0, x8
-;;   csel x9, x10, x9, hs
-;;   csdb
-;;   ldrb w0, [x9]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 04f58c9c670d..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   ldr x9, [x2, #8]
-;;   ldr x10, [x2]
-;;   add x10, x10, x0
-;;   add x10, x10, #4096
-;;   movz x11, #0
-;;   subs xzr, x0, x9
-;;   csel x10, x11, x10, hi
-;;   csdb
-;;   strb w1, [x10]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x9, [x1, #8]
-;;   ldr x10, [x1]
-;;   add x10, x10, x0
-;;   add x10, x10, #4096
-;;   movz x11, #0
-;;   subs xzr, x0, x9
-;;   csel x10, x11, x10, hi
-;;   csdb
-;;   ldrb w0, [x10]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index afec49c09cbc..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   ldr x10, [x2, #8]
-;;   ldr x11, [x2]
-;;   add x11, x11, x0
-;;   movz x12, #65535, LSL #16
-;;   add x11, x11, x12
-;;   movz x12, #0
-;;   subs xzr, x0, x10
-;;   csel x11, x12, x11, hi
-;;   csdb
-;;   strb w1, [x11]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x10, [x1, #8]
-;;   ldr x11, [x1]
-;;   add x11, x11, x0
-;;   movz x12, #65535, LSL #16
-;;   add x11, x11, x12
-;;   movz x12, #0
-;;   subs xzr, x0, x10
-;;   csel x11, x12, x11, hi
-;;   csdb
-;;   ldrb w0, [x11]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 54972027788e..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   mov w6, w0
-;;   orr x7, xzr, #268435452
-;;   subs xzr, x6, x7
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x8, [x2]
-;;   str w1, [x8, w0, UXTW]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   mov w6, w0
-;;   orr x7, xzr, #268435452
-;;   subs xzr, x6, x7
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x8, [x1]
-;;   ldr w0, [x8, w0, UXTW]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index d619dc1b261a..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   mov w8, w0
-;;   movz w9, #61436
-;;   movk w9, w9, #4095, LSL #16
-;;   subs xzr, x8, x9
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x10, [x2]
-;;   add x10, x10, #4096
-;;   str w1, [x10, w0, UXTW]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   mov w8, w0
-;;   movz w9, #61436
-;;   movk w9, w9, #4095, LSL #16
-;;   subs xzr, x8, x9
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x10, [x1]
-;;   add x9, x10, #4096
-;;   ldr w0, [x9, w0, UXTW]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index df1caebc4600..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   udf #0xc11f
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 5b909164d673..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   mov w6, w0
-;;   orr x7, xzr, #268435455
-;;   subs xzr, x6, x7
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x8, [x2]
-;;   strb w1, [x8, w0, UXTW]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   mov w6, w0
-;;   orr x7, xzr, #268435455
-;;   subs xzr, x6, x7
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x8, [x1]
-;;   ldrb w0, [x8, w0, UXTW]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 4b984566b626..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   mov w8, w0
-;;   movz w9, #61439
-;;   movk w9, w9, #4095, LSL #16
-;;   subs xzr, x8, x9
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x10, [x2]
-;;   add x10, x10, #4096
-;;   strb w1, [x10, w0, UXTW]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   mov w8, w0
-;;   movz w9, #61439
-;;   movk w9, w9, #4095, LSL #16
-;;   subs xzr, x8, x9
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x10, [x1]
-;;   add x9, x10, #4096
-;;   ldrb w0, [x9, w0, UXTW]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 8db0d38772f3..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   udf #0xc11f
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index c2cae883b912..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   mov w9, w0
-;;   ldr x10, [x2]
-;;   add x10, x10, x0, UXTW
-;;   movz x11, #0
-;;   orr x8, xzr, #268435452
-;;   subs xzr, x9, x8
-;;   csel x11, x11, x10, hi
-;;   csdb
-;;   str w1, [x11]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   mov w9, w0
-;;   ldr x10, [x1]
-;;   add x10, x10, x0, UXTW
-;;   movz x11, #0
-;;   orr x8, xzr, #268435452
-;;   subs xzr, x9, x8
-;;   csel x11, x11, x10, hi
-;;   csdb
-;;   ldr w0, [x11]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index f388a44c871d..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   mov w11, w0
-;;   ldr x12, [x2]
-;;   add x12, x12, x0, UXTW
-;;   add x12, x12, #4096
-;;   movz x13, #0
-;;   movz w10, #61436
-;;   movk w10, w10, #4095, LSL #16
-;;   subs xzr, x11, x10
-;;   csel x14, x13, x12, hi
-;;   csdb
-;;   str w1, [x14]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   mov w11, w0
-;;   ldr x12, [x1]
-;;   add x12, x12, x0, UXTW
-;;   add x12, x12, #4096
-;;   movz x13, #0
-;;   movz w10, #61436
-;;   movk w10, w10, #4095, LSL #16
-;;   subs xzr, x11, x10
-;;   csel x14, x13, x12, hi
-;;   csdb
-;;   ldr w0, [x14]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 5cdc824d244b..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   udf #0xc11f
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 43e501106918..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   mov w9, w0
-;;   ldr x10, [x2]
-;;   add x10, x10, x0, UXTW
-;;   movz x11, #0
-;;   orr x8, xzr, #268435455
-;;   subs xzr, x9, x8
-;;   csel x11, x11, x10, hi
-;;   csdb
-;;   strb w1, [x11]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   mov w9, w0
-;;   ldr x10, [x1]
-;;   add x10, x10, x0, UXTW
-;;   movz x11, #0
-;;   orr x8, xzr, #268435455
-;;   subs xzr, x9, x8
-;;   csel x11, x11, x10, hi
-;;   csdb
-;;   ldrb w0, [x11]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index b1276331847b..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   mov w11, w0
-;;   ldr x12, [x2]
-;;   add x12, x12, x0, UXTW
-;;   add x12, x12, #4096
-;;   movz x13, #0
-;;   movz w10, #61439
-;;   movk w10, w10, #4095, LSL #16
-;;   subs xzr, x11, x10
-;;   csel x14, x13, x12, hi
-;;   csdb
-;;   strb w1, [x14]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   mov w11, w0
-;;   ldr x12, [x1]
-;;   add x12, x12, x0, UXTW
-;;   add x12, x12, #4096
-;;   movz x13, #0
-;;   movz w10, #61439
-;;   movk w10, w10, #4095, LSL #16
-;;   subs xzr, x11, x10
-;;   csel x14, x13, x12, hi
-;;   csdb
-;;   ldrb w0, [x14]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index b012bdf5d131..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   udf #0xc11f
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index c62f5ffe7a68..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,54 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   ldr x4, [x2]
-;;   str w1, [x4, w0, UXTW]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x4, [x1]
-;;   ldr w0, [x4, w0, UXTW]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 832f76671cb4..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,56 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   ldr x5, [x2]
-;;   add x5, x5, #4096
-;;   str w1, [x5, w0, UXTW]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x5, [x1]
-;;   add x4, x5, #4096
-;;   ldr w0, [x4, w0, UXTW]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index a6773c867367..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   udf #0xc11f
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 035b3a9793f5..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,54 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   ldr x4, [x2]
-;;   strb w1, [x4, w0, UXTW]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x4, [x1]
-;;   ldrb w0, [x4, w0, UXTW]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index c7a0b8d71efc..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,56 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   ldr x5, [x2]
-;;   add x5, x5, #4096
-;;   strb w1, [x5, w0, UXTW]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x5, [x1]
-;;   add x4, x5, #4096
-;;   ldrb w0, [x4, w0, UXTW]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 11b44de08edd..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   udf #0xc11f
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 4cd63f73a6ce..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,54 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   ldr x4, [x2]
-;;   str w1, [x4, w0, UXTW]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x4, [x1]
-;;   ldr w0, [x4, w0, UXTW]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index f5aa7bed193e..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,56 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   ldr x5, [x2]
-;;   add x5, x5, #4096
-;;   str w1, [x5, w0, UXTW]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x5, [x1]
-;;   add x4, x5, #4096
-;;   ldr w0, [x4, w0, UXTW]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index d0d62100fe01..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   udf #0xc11f
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 36dc09c694c6..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,54 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   ldr x4, [x2]
-;;   strb w1, [x4, w0, UXTW]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x4, [x1]
-;;   ldrb w0, [x4, w0, UXTW]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 0f77e69103d2..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,56 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   ldr x5, [x2]
-;;   add x5, x5, #4096
-;;   strb w1, [x5, w0, UXTW]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x5, [x1]
-;;   add x4, x5, #4096
-;;   ldrb w0, [x4, w0, UXTW]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index bc1227b9948b..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   udf #0xc11f
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index cbf7f16e9979..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,66 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   orr x5, xzr, #268435452
-;;   subs xzr, x0, x5
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x7, [x2]
-;;   str w1, [x7, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   orr x5, xzr, #268435452
-;;   subs xzr, x0, x5
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x7, [x1]
-;;   ldr w0, [x7, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 356a25cd37e9..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   movz w7, #61436
-;;   movk w7, w7, #4095, LSL #16
-;;   subs xzr, x0, x7
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x9, [x2]
-;;   add x9, x9, #4096
-;;   str w1, [x9, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   movz w7, #61436
-;;   movk w7, w7, #4095, LSL #16
-;;   subs xzr, x0, x7
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x9, [x1]
-;;   add x8, x9, #4096
-;;   ldr w0, [x8, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 45da79cdb5f6..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   udf #0xc11f
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index ae7dba18c3a2..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,66 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   orr x5, xzr, #268435455
-;;   subs xzr, x0, x5
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x7, [x2]
-;;   strb w1, [x7, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   orr x5, xzr, #268435455
-;;   subs xzr, x0, x5
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x7, [x1]
-;;   ldrb w0, [x7, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 95a0b0c354d7..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   movz w7, #61439
-;;   movk w7, w7, #4095, LSL #16
-;;   subs xzr, x0, x7
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x9, [x2]
-;;   add x9, x9, #4096
-;;   strb w1, [x9, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   movz w7, #61439
-;;   movk w7, w7, #4095, LSL #16
-;;   subs xzr, x0, x7
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x9, [x1]
-;;   add x8, x9, #4096
-;;   ldrb w0, [x8, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index f67e08452839..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   udf #0xc11f
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 3eecbc69d549..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,66 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   ldr x8, [x2]
-;;   add x8, x8, x0
-;;   movz x9, #0
-;;   orr x7, xzr, #268435452
-;;   subs xzr, x0, x7
-;;   csel x10, x9, x8, hi
-;;   csdb
-;;   str w1, [x10]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x8, [x1]
-;;   add x8, x8, x0
-;;   movz x9, #0
-;;   orr x7, xzr, #268435452
-;;   subs xzr, x0, x7
-;;   csel x10, x9, x8, hi
-;;   csdb
-;;   ldr w0, [x10]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index e62084ec1c2d..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   ldr x10, [x2]
-;;   add x10, x10, x0
-;;   add x10, x10, #4096
-;;   movz x11, #0
-;;   movz w9, #61436
-;;   movk w9, w9, #4095, LSL #16
-;;   subs xzr, x0, x9
-;;   csel x13, x11, x10, hi
-;;   csdb
-;;   str w1, [x13]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x10, [x1]
-;;   add x10, x10, x0
-;;   add x10, x10, #4096
-;;   movz x11, #0
-;;   movz w9, #61436
-;;   movk w9, w9, #4095, LSL #16
-;;   subs xzr, x0, x9
-;;   csel x13, x11, x10, hi
-;;   csdb
-;;   ldr w0, [x13]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index c21d2caa23b1..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   udf #0xc11f
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 17ae6b229350..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,66 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   ldr x8, [x2]
-;;   add x8, x8, x0
-;;   movz x9, #0
-;;   orr x7, xzr, #268435455
-;;   subs xzr, x0, x7
-;;   csel x10, x9, x8, hi
-;;   csdb
-;;   strb w1, [x10]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x8, [x1]
-;;   add x8, x8, x0
-;;   movz x9, #0
-;;   orr x7, xzr, #268435455
-;;   subs xzr, x0, x7
-;;   csel x10, x9, x8, hi
-;;   csdb
-;;   ldrb w0, [x10]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 5ef524ba36cd..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   ldr x10, [x2]
-;;   add x10, x10, x0
-;;   add x10, x10, #4096
-;;   movz x11, #0
-;;   movz w9, #61439
-;;   movk w9, w9, #4095, LSL #16
-;;   subs xzr, x0, x9
-;;   csel x13, x11, x10, hi
-;;   csdb
-;;   strb w1, [x13]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x10, [x1]
-;;   add x10, x10, x0
-;;   add x10, x10, #4096
-;;   movz x11, #0
-;;   movz w9, #61439
-;;   movk w9, w9, #4095, LSL #16
-;;   subs xzr, x0, x9
-;;   csel x13, x11, x10, hi
-;;   csdb
-;;   ldrb w0, [x13]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index e72895b062cf..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   udf #0xc11f
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 0379278a2020..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,66 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   orr x5, xzr, #268435452
-;;   subs xzr, x0, x5
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x7, [x2]
-;;   str w1, [x7, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   orr x5, xzr, #268435452
-;;   subs xzr, x0, x5
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x7, [x1]
-;;   ldr w0, [x7, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index d6f23c3acf3e..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   movz w7, #61436
-;;   movk w7, w7, #4095, LSL #16
-;;   subs xzr, x0, x7
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x9, [x2]
-;;   add x9, x9, #4096
-;;   str w1, [x9, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   movz w7, #61436
-;;   movk w7, w7, #4095, LSL #16
-;;   subs xzr, x0, x7
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x9, [x1]
-;;   add x8, x9, #4096
-;;   ldr w0, [x8, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 5d6ab28cf3db..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   udf #0xc11f
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index f4611c295606..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,66 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   orr x5, xzr, #268435455
-;;   subs xzr, x0, x5
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x7, [x2]
-;;   strb w1, [x7, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   orr x5, xzr, #268435455
-;;   subs xzr, x0, x5
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x7, [x1]
-;;   ldrb w0, [x7, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 4ce8d4ecada8..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   movz w7, #61439
-;;   movk w7, w7, #4095, LSL #16
-;;   subs xzr, x0, x7
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x9, [x2]
-;;   add x9, x9, #4096
-;;   strb w1, [x9, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   movz w7, #61439
-;;   movk w7, w7, #4095, LSL #16
-;;   subs xzr, x0, x7
-;;   b.hi label3 ; b label1
-;; block1:
-;;   ldr x9, [x1]
-;;   add x8, x9, #4096
-;;   ldrb w0, [x8, x0]
-;;   b label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf #0xc11f
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index b176811d003e..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   udf #0xc11f
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index d7f7dfd57247..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,66 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   ldr x8, [x2]
-;;   add x8, x8, x0
-;;   movz x9, #0
-;;   orr x7, xzr, #268435452
-;;   subs xzr, x0, x7
-;;   csel x10, x9, x8, hi
-;;   csdb
-;;   str w1, [x10]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x8, [x1]
-;;   add x8, x8, x0
-;;   movz x9, #0
-;;   orr x7, xzr, #268435452
-;;   subs xzr, x0, x7
-;;   csel x10, x9, x8, hi
-;;   csdb
-;;   ldr w0, [x10]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index fe83d58c7a5c..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   ldr x10, [x2]
-;;   add x10, x10, x0
-;;   add x10, x10, #4096
-;;   movz x11, #0
-;;   movz w9, #61436
-;;   movk w9, w9, #4095, LSL #16
-;;   subs xzr, x0, x9
-;;   csel x13, x11, x10, hi
-;;   csdb
-;;   str w1, [x13]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x10, [x1]
-;;   add x10, x10, x0
-;;   add x10, x10, #4096
-;;   movz x11, #0
-;;   movz w9, #61436
-;;   movk w9, w9, #4095, LSL #16
-;;   subs xzr, x0, x9
-;;   csel x13, x11, x10, hi
-;;   csdb
-;;   ldr w0, [x13]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index cf7e58ea38d7..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   udf #0xc11f
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index f57d6cd7f0c0..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,66 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   ldr x8, [x2]
-;;   add x8, x8, x0
-;;   movz x9, #0
-;;   orr x7, xzr, #268435455
-;;   subs xzr, x0, x7
-;;   csel x10, x9, x8, hi
-;;   csdb
-;;   strb w1, [x10]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x8, [x1]
-;;   add x8, x8, x0
-;;   movz x9, #0
-;;   orr x7, xzr, #268435455
-;;   subs xzr, x0, x7
-;;   csel x10, x9, x8, hi
-;;   csdb
-;;   ldrb w0, [x10]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 90bec6b250e4..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   ldr x10, [x2]
-;;   add x10, x10, x0
-;;   add x10, x10, #4096
-;;   movz x11, #0
-;;   movz w9, #61439
-;;   movk w9, w9, #4095, LSL #16
-;;   subs xzr, x0, x9
-;;   csel x13, x11, x10, hi
-;;   csdb
-;;   strb w1, [x13]
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ldr x10, [x1]
-;;   add x10, x10, x0
-;;   add x10, x10, #4096
-;;   movz x11, #0
-;;   movz w9, #61439
-;;   movk w9, w9, #4095, LSL #16
-;;   subs xzr, x0, x9
-;;   csel x13, x11, x10, hi
-;;   csdb
-;;   ldrb w0, [x13]
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index cfd4909140ab..000000000000
--- a/cranelift/filetests/filetests/isa/aarch64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "aarch64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf #0xc11f
-;;
-;; function u0:1:
-;; block0:
-;;   udf #0xc11f
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/pulley32/brif-icmp.clif b/cranelift/filetests/filetests/isa/pulley32/brif-icmp.clif
new file mode 100644
index 000000000000..e40370d9f24e
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/pulley32/brif-icmp.clif
@@ -0,0 +1,345 @@
+test compile precise-output
+target pulley32
+
+function %brif_icmp_eq(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+  v2 = icmp eq v0, v1
+  brif v2, block2, block1
+
+block1:
+  v3 = iconst.i32 1
+  return v3
+
+block2:
+  v4 = iconst.i32 2
+  return v4
+}
+
+; VCode:
+; block0:
+;   br_if_xeq32 x0, x1, label2; jump label1
+; block1:
+;   x0 = xconst8 1
+;   ret
+; block2:
+;   x0 = xconst8 2
+;   ret
+;
+; Disassembled:
+;        0: 05 00 01 0b 00 00 00            br_if_xeq32 x0, x1, 0xb    // target = 0xb
+;        7: 0e 00 01                        xconst8 x0, 1
+;        a: 00                              ret
+;        b: 0e 00 02                        xconst8 x0, 2
+;        e: 00                              ret
+
+function %brif_icmp_ne(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+  v2 = icmp ne v0, v1
+  brif v2, block2, block1
+
+block1:
+  v3 = iconst.i32 1
+  return v3
+
+block2:
+  v4 = iconst.i32 2
+  return v4
+}
+
+; VCode:
+; block0:
+;   br_if_xneq32 x0, x1, label2; jump label1
+; block1:
+;   x0 = xconst8 1
+;   ret
+; block2:
+;   x0 = xconst8 2
+;   ret
+;
+; Disassembled:
+;        0: 06 00 01 0b 00 00 00            br_if_xneq32 x0, x1, 0xb    // target = 0xb
+;        7: 0e 00 01                        xconst8 x0, 1
+;        a: 00                              ret
+;        b: 0e 00 02                        xconst8 x0, 2
+;        e: 00                              ret
+
+function %brif_icmp_ult(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+  v2 = icmp ult v0, v1
+  brif v2, block2, block1
+
+block1:
+  v3 = iconst.i32 1
+  return v3
+
+block2:
+  v4 = iconst.i32 2
+  return v4
+}
+
+; VCode:
+; block0:
+;   br_if_xult32 x0, x1, label2; jump label1
+; block1:
+;   x0 = xconst8 1
+;   ret
+; block2:
+;   x0 = xconst8 2
+;   ret
+;
+; Disassembled:
+;        0: 09 00 01 0b 00 00 00            br_if_xult32 x0, x1, 0xb    // target = 0xb
+;        7: 0e 00 01                        xconst8 x0, 1
+;        a: 00                              ret
+;        b: 0e 00 02                        xconst8 x0, 2
+;        e: 00                              ret
+
+function %brif_icmp_ule(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+  v2 = icmp ule v0, v1
+  brif v2, block2, block1
+
+block1:
+  v3 = iconst.i32 1
+  return v3
+
+block2:
+  v4 = iconst.i32 2
+  return v4
+}
+
+; VCode:
+; block0:
+;   br_if_xulteq32 x0, x1, label2; jump label1
+; block1:
+;   x0 = xconst8 1
+;   ret
+; block2:
+;   x0 = xconst8 2
+;   ret
+;
+; Disassembled:
+;        0: 0a 00 01 0b 00 00 00            br_if_xulteq32 x0, x1, 0xb    // target = 0xb
+;        7: 0e 00 01                        xconst8 x0, 1
+;        a: 00                              ret
+;        b: 0e 00 02                        xconst8 x0, 2
+;        e: 00                              ret
+
+function %brif_icmp_slt(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+  v2 = icmp slt v0, v1
+  brif v2, block2, block1
+
+block1:
+  v3 = iconst.i32 1
+  return v3
+
+block2:
+  v4 = iconst.i32 2
+  return v4
+}
+
+; VCode:
+; block0:
+;   br_if_xslt32 x0, x1, label2; jump label1
+; block1:
+;   x0 = xconst8 1
+;   ret
+; block2:
+;   x0 = xconst8 2
+;   ret
+;
+; Disassembled:
+;        0: 07 00 01 0b 00 00 00            br_if_xslt32 x0, x1, 0xb    // target = 0xb
+;        7: 0e 00 01                        xconst8 x0, 1
+;        a: 00                              ret
+;        b: 0e 00 02                        xconst8 x0, 2
+;        e: 00                              ret
+
+function %brif_icmp_sle(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+  v2 = icmp sle v0, v1
+  brif v2, block2, block1
+
+block1:
+  v3 = iconst.i32 1
+  return v3
+
+block2:
+  v4 = iconst.i32 2
+  return v4
+}
+
+; VCode:
+; block0:
+;   br_if_xslteq32 x0, x1, label2; jump label1
+; block1:
+;   x0 = xconst8 1
+;   ret
+; block2:
+;   x0 = xconst8 2
+;   ret
+;
+; Disassembled:
+;        0: 08 00 01 0b 00 00 00            br_if_xslteq32 x0, x1, 0xb    // target = 0xb
+;        7: 0e 00 01                        xconst8 x0, 1
+;        a: 00                              ret
+;        b: 0e 00 02                        xconst8 x0, 2
+;        e: 00                              ret
+
+function %brif_icmp_ugt(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+  v2 = icmp ugt v0, v1
+  brif v2, block2, block1
+
+block1:
+  v3 = iconst.i32 1
+  return v3
+
+block2:
+  v4 = iconst.i32 2
+  return v4
+}
+
+; VCode:
+; block0:
+;   br_if_xult32 x1, x0, label2; jump label1
+; block1:
+;   x0 = xconst8 1
+;   ret
+; block2:
+;   x0 = xconst8 2
+;   ret
+;
+; Disassembled:
+;        0: 09 01 00 0b 00 00 00            br_if_xult32 x1, x0, 0xb    // target = 0xb
+;        7: 0e 00 01                        xconst8 x0, 1
+;        a: 00                              ret
+;        b: 0e 00 02                        xconst8 x0, 2
+;        e: 00                              ret
+
+function %brif_icmp_uge(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+  v2 = icmp uge v0, v1
+  brif v2, block2, block1
+
+block1:
+  v3 = iconst.i32 1
+  return v3
+
+block2:
+  v4 = iconst.i32 2
+  return v4
+}
+
+; VCode:
+; block0:
+;   br_if_xulteq32 x1, x0, label2; jump label1
+; block1:
+;   x0 = xconst8 1
+;   ret
+; block2:
+;   x0 = xconst8 2
+;   ret
+;
+; Disassembled:
+;        0: 0a 01 00 0b 00 00 00            br_if_xulteq32 x1, x0, 0xb    // target = 0xb
+;        7: 0e 00 01                        xconst8 x0, 1
+;        a: 00                              ret
+;        b: 0e 00 02                        xconst8 x0, 2
+;        e: 00                              ret
+
+function %brif_icmp_sgt(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+  v2 = icmp sgt v0, v1
+  brif v2, block2, block1
+
+block1:
+  v3 = iconst.i32 1
+  return v3
+
+block2:
+  v4 = iconst.i32 2
+  return v4
+}
+
+; VCode:
+; block0:
+;   br_if_xslt32 x1, x0, label2; jump label1
+; block1:
+;   x0 = xconst8 1
+;   ret
+; block2:
+;   x0 = xconst8 2
+;   ret
+;
+; Disassembled:
+;        0: 07 01 00 0b 00 00 00            br_if_xslt32 x1, x0, 0xb    // target = 0xb
+;        7: 0e 00 01                        xconst8 x0, 1
+;        a: 00                              ret
+;        b: 0e 00 02                        xconst8 x0, 2
+;        e: 00                              ret
+
+function %brif_icmp_sge(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+  v2 = icmp sge v0, v1
+  brif v2, block2, block1
+
+block1:
+  v3 = iconst.i32 1
+  return v3
+
+block2:
+  v4 = iconst.i32 2
+  return v4
+}
+
+; VCode:
+; block0:
+;   br_if_xslteq32 x1, x0, label2; jump label1
+; block1:
+;   x0 = xconst8 1
+;   ret
+; block2:
+;   x0 = xconst8 2
+;   ret
+;
+; Disassembled:
+;        0: 08 01 00 0b 00 00 00            br_if_xslteq32 x1, x0, 0xb    // target = 0xb
+;        7: 0e 00 01                        xconst8 x0, 1
+;        a: 00                              ret
+;        b: 0e 00 02                        xconst8 x0, 2
+;        e: 00                              ret
+
+function %brif_uextend_icmp_eq(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+  v2 = icmp eq v0, v1
+  v3 = uextend.i32 v2
+  brif v3, block2, block1
+
+block1:
+  v4 = iconst.i32 1
+  return v4
+
+block2:
+  v5 = iconst.i32 2
+  return v5
+}
+
+; VCode:
+; block0:
+;   br_if_xeq32 x0, x1, label2; jump label1
+; block1:
+;   x0 = xconst8 1
+;   ret
+; block2:
+;   x0 = xconst8 2
+;   ret
+;
+; Disassembled:
+;        0: 05 00 01 0b 00 00 00            br_if_xeq32 x0, x1, 0xb    // target = 0xb
+;        7: 0e 00 01                        xconst8 x0, 1
+;        a: 00                              ret
+;        b: 0e 00 02                        xconst8 x0, 2
+;        e: 00                              ret
+
diff --git a/cranelift/filetests/filetests/isa/pulley32/brif.clif b/cranelift/filetests/filetests/isa/pulley32/brif.clif
new file mode 100644
index 000000000000..b2f943d7cb19
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/pulley32/brif.clif
@@ -0,0 +1,253 @@
+test compile precise-output
+target pulley32
+
+function %brif_i8(i8) -> i8 {
+block0(v0: i8):
+  brif v0, block1, block2
+
+block1:
+  v1 = iconst.i8 1
+  return v1
+
+block2:
+  v2 = iconst.i8 0
+  return v2
+}
+
+; VCode:
+; block0:
+;   br_if x0, label2; jump label1
+; block1:
+;   x0 = xconst8 0
+;   ret
+; block2:
+;   x0 = xconst8 1
+;   ret
+;
+; Disassembled:
+;        0: 03 00 0a 00 00 00               br_if x0, 0xa    // target = 0xa
+;        6: 0e 00 00                        xconst8 x0, 0
+;        9: 00                              ret
+;        a: 0e 00 01                        xconst8 x0, 1
+;        d: 00                              ret
+
+function %brif_i16(i16) -> i8 {
+block0(v0: i16):
+  brif v0, block1, block2
+
+block1:
+  v1 = iconst.i8 1
+  return v1
+
+block2:
+  v2 = iconst.i8 0
+  return v2
+}
+
+; VCode:
+; block0:
+;   br_if x0, label2; jump label1
+; block1:
+;   x0 = xconst8 0
+;   ret
+; block2:
+;   x0 = xconst8 1
+;   ret
+;
+; Disassembled:
+;        0: 03 00 0a 00 00 00               br_if x0, 0xa    // target = 0xa
+;        6: 0e 00 00                        xconst8 x0, 0
+;        9: 00                              ret
+;        a: 0e 00 01                        xconst8 x0, 1
+;        d: 00                              ret
+
+function %brif_i32(i32) -> i8 {
+block0(v0: i32):
+  brif v0, block1, block2
+
+block1:
+  v1 = iconst.i8 1
+  return v1
+
+block2:
+  v2 = iconst.i8 0
+  return v2
+}
+
+; VCode:
+; block0:
+;   br_if x0, label2; jump label1
+; block1:
+;   x0 = xconst8 0
+;   ret
+; block2:
+;   x0 = xconst8 1
+;   ret
+;
+; Disassembled:
+;        0: 03 00 0a 00 00 00               br_if x0, 0xa    // target = 0xa
+;        6: 0e 00 00                        xconst8 x0, 0
+;        9: 00                              ret
+;        a: 0e 00 01                        xconst8 x0, 1
+;        d: 00                              ret
+
+function %brif_i64(i64) -> i8 {
+block0(v0: i64):
+  brif v0, block1, block2
+
+block1:
+  v1 = iconst.i8 1
+  return v1
+
+block2:
+  v2 = iconst.i8 0
+  return v2
+}
+
+; VCode:
+; block0:
+;   br_if x0, label2; jump label1
+; block1:
+;   x0 = xconst8 0
+;   ret
+; block2:
+;   x0 = xconst8 1
+;   ret
+;
+; Disassembled:
+;        0: 03 00 0a 00 00 00               br_if x0, 0xa    // target = 0xa
+;        6: 0e 00 00                        xconst8 x0, 0
+;        9: 00                              ret
+;        a: 0e 00 01                        xconst8 x0, 1
+;        d: 00                              ret
+
+function %brif_icmp_i8(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+  v2 = icmp eq v0, v1
+  brif v2, block1, block2
+
+block1:
+  v3 = iconst.i8 1
+  return v3
+
+block2:
+  v4 = iconst.i8 0
+  return v4
+}
+
+; VCode:
+; block0:
+;   x5 = xeq32 x0, x1
+;   br_if x5, label2; jump label1
+; block1:
+;   x0 = xconst8 0
+;   ret
+; block2:
+;   x0 = xconst8 1
+;   ret
+;
+; Disassembled:
+;        0: 1a 05 04                        xeq32 x5, x0, x1
+;        3: 03 05 0a 00 00 00               br_if x5, 0xa    // target = 0xd
+;        9: 0e 00 00                        xconst8 x0, 0
+;        c: 00                              ret
+;        d: 0e 00 01                        xconst8 x0, 1
+;       10: 00                              ret
+
+function %brif_icmp_i16(i16, i16) -> i8 {
+block0(v0: i16, v1: i16):
+  v2 = icmp ne v0, v1
+  brif v2, block1, block2
+
+block1:
+  v3 = iconst.i8 1
+  return v3
+
+block2:
+  v4 = iconst.i8 0
+  return v4
+}
+
+; VCode:
+; block0:
+;   x5 = xneq32 x0, x1
+;   br_if x5, label2; jump label1
+; block1:
+;   x0 = xconst8 0
+;   ret
+; block2:
+;   x0 = xconst8 1
+;   ret
+;
+; Disassembled:
+;        0: 1b 05 04                        xneq32 x5, x0, x1
+;        3: 03 05 0a 00 00 00               br_if x5, 0xa    // target = 0xd
+;        9: 0e 00 00                        xconst8 x0, 0
+;        c: 00                              ret
+;        d: 0e 00 01                        xconst8 x0, 1
+;       10: 00                              ret
+
+function %brif_icmp_i32(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+  v2 = icmp slt v0, v1
+  brif v2, block1, block2
+
+block1:
+  v3 = iconst.i8 1
+  return v3
+
+block2:
+  v4 = iconst.i8 0
+  return v4
+}
+
+; VCode:
+; block0:
+;   br_if_xslt32 x0, x1, label2; jump label1
+; block1:
+;   x0 = xconst8 0
+;   ret
+; block2:
+;   x0 = xconst8 1
+;   ret
+;
+; Disassembled:
+;        0: 07 00 01 0b 00 00 00            br_if_xslt32 x0, x1, 0xb    // target = 0xb
+;        7: 0e 00 00                        xconst8 x0, 0
+;        a: 00                              ret
+;        b: 0e 00 01                        xconst8 x0, 1
+;        e: 00                              ret
+
+function %brif_icmp_i64(i64, i64) -> i8 {
+block0(v0: i64, v1: i64):
+  v2 = icmp uge v0, v1
+  brif v2, block1, block2
+
+block1:
+  v3 = iconst.i8 1
+  return v3
+
+block2:
+  v4 = iconst.i8 0
+  return v4
+}
+
+; VCode:
+; block0:
+;   x5 = xulteq64 x1, x0
+;   br_if x5, label2; jump label1
+; block1:
+;   x0 = xconst8 0
+;   ret
+; block2:
+;   x0 = xconst8 1
+;   ret
+;
+; Disassembled:
+;        0: 19 25 00                        xulteq64 x5, x1, x0
+;        3: 03 05 0a 00 00 00               br_if x5, 0xa    // target = 0xd
+;        9: 0e 00 00                        xconst8 x0, 0
+;        c: 00                              ret
+;        d: 0e 00 01                        xconst8 x0, 1
+;       10: 00                              ret
+
diff --git a/cranelift/filetests/filetests/isa/pulley32/call.clif b/cranelift/filetests/filetests/isa/pulley32/call.clif
new file mode 100644
index 000000000000..d02583907c31
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/pulley32/call.clif
@@ -0,0 +1,409 @@
+test compile precise-output
+target pulley32
+
+function %colocated_args_i64_rets_i64() -> i64 {
+    fn0 = colocated %g(i64) -> i64
+
+block0:
+    v0 = iconst.i64 0
+    v1 = call fn0(v0)
+    v2 = iconst.i64 1
+    return v2
+}
+
+; VCode:
+;   x30 = xconst8 -16
+;   x27 = xadd32 x27, x30
+;   store64 sp+8, x28 // flags =  notrap aligned
+;   store64 sp+0, x29 // flags =  notrap aligned
+;   x29 = xmov x27
+; block0:
+;   x0 = xconst8 0
+;   call TestCase(%g), CallInfo { uses: [CallArgPair { vreg: p0i, preg: p0i }], defs: [CallRetPair { vreg: Writable { reg: p0i }, preg: p0i }], clobbers: PRegSet { bits: [65534, 65279, 4294967295, 0] }, callee_pop_size: 0 }
+;   x0 = xconst8 1
+;   x28 = load64_u sp+8 // flags = notrap aligned
+;   x29 = load64_u sp+0 // flags = notrap aligned
+;   x30 = xconst8 16
+;   x27 = xadd32 x27, x30
+;   ret
+;
+; Disassembled:
+;        0: 0e 1e f0                        xconst8 spilltmp0, -16
+;        3: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;        6: 2c 1b 08 1c                     store64_offset8 sp, 8, lr
+;        a: 2a 1b 1d                        store64 sp, fp
+;        d: 0b 1d 1b                        xmov fp, sp
+;       10: 0e 00 00                        xconst8 x0, 0
+;       13: 01 00 00 00 00                  call 0x0    // target = 0x13
+;       18: 0e 00 01                        xconst8 x0, 1
+;       1b: 25 1c 1b 08                     load64_offset8 lr, sp, 8
+;       1f: 22 1d 1b                        load64 fp, sp
+;       22: 0e 1e 10                        xconst8 spilltmp0, 16
+;       25: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;       28: 00                              ret
+
+function %colocated_args_i32_rets_i32() -> i32 {
+    fn0 = colocated %g(i32) -> i32
+
+block0:
+    v0 = iconst.i32 0
+    v1 = call fn0(v0)
+    v2 = iconst.i32 1
+    return v2
+}
+
+; VCode:
+;   x30 = xconst8 -16
+;   x27 = xadd32 x27, x30
+;   store64 sp+8, x28 // flags =  notrap aligned
+;   store64 sp+0, x29 // flags =  notrap aligned
+;   x29 = xmov x27
+; block0:
+;   x0 = xconst8 0
+;   call TestCase(%g), CallInfo { uses: [CallArgPair { vreg: p0i, preg: p0i }], defs: [CallRetPair { vreg: Writable { reg: p0i }, preg: p0i }], clobbers: PRegSet { bits: [65534, 65279, 4294967295, 0] }, callee_pop_size: 0 }
+;   x0 = xconst8 1
+;   x28 = load64_u sp+8 // flags = notrap aligned
+;   x29 = load64_u sp+0 // flags = notrap aligned
+;   x30 = xconst8 16
+;   x27 = xadd32 x27, x30
+;   ret
+;
+; Disassembled:
+;        0: 0e 1e f0                        xconst8 spilltmp0, -16
+;        3: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;        6: 2c 1b 08 1c                     store64_offset8 sp, 8, lr
+;        a: 2a 1b 1d                        store64 sp, fp
+;        d: 0b 1d 1b                        xmov fp, sp
+;       10: 0e 00 00                        xconst8 x0, 0
+;       13: 01 00 00 00 00                  call 0x0    // target = 0x13
+;       18: 0e 00 01                        xconst8 x0, 1
+;       1b: 25 1c 1b 08                     load64_offset8 lr, sp, 8
+;       1f: 22 1d 1b                        load64 fp, sp
+;       22: 0e 1e 10                        xconst8 spilltmp0, 16
+;       25: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;       28: 00                              ret
+
+function %colocated_args_i64_i32_i64_i32() {
+    fn0 = colocated %g(i64, i32, i64, i32)
+
+block0:
+    v0 = iconst.i64 0
+    v1 = iconst.i32 1
+    v2 = iconst.i64 2
+    v3 = iconst.i32 3
+    call fn0(v0, v1, v2, v3)
+    return
+}
+
+; VCode:
+;   x30 = xconst8 -16
+;   x27 = xadd32 x27, x30
+;   store64 sp+8, x28 // flags =  notrap aligned
+;   store64 sp+0, x29 // flags =  notrap aligned
+;   x29 = xmov x27
+; block0:
+;   x0 = xconst8 0
+;   x1 = xconst8 1
+;   x2 = xconst8 2
+;   x3 = xconst8 3
+;   call TestCase(%g), CallInfo { uses: [CallArgPair { vreg: p0i, preg: p0i }, CallArgPair { vreg: p1i, preg: p1i }, CallArgPair { vreg: p2i, preg: p2i }, CallArgPair { vreg: p3i, preg: p3i }], defs: [], clobbers: PRegSet { bits: [65535, 65279, 4294967295, 0] }, callee_pop_size: 0 }
+;   x28 = load64_u sp+8 // flags = notrap aligned
+;   x29 = load64_u sp+0 // flags = notrap aligned
+;   x30 = xconst8 16
+;   x27 = xadd32 x27, x30
+;   ret
+;
+; Disassembled:
+;        0: 0e 1e f0                        xconst8 spilltmp0, -16
+;        3: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;        6: 2c 1b 08 1c                     store64_offset8 sp, 8, lr
+;        a: 2a 1b 1d                        store64 sp, fp
+;        d: 0b 1d 1b                        xmov fp, sp
+;       10: 0e 00 00                        xconst8 x0, 0
+;       13: 0e 01 01                        xconst8 x1, 1
+;       16: 0e 02 02                        xconst8 x2, 2
+;       19: 0e 03 03                        xconst8 x3, 3
+;       1c: 01 00 00 00 00                  call 0x0    // target = 0x1c
+;       21: 25 1c 1b 08                     load64_offset8 lr, sp, 8
+;       25: 22 1d 1b                        load64 fp, sp
+;       28: 0e 1e 10                        xconst8 spilltmp0, 16
+;       2b: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;       2e: 00                              ret
+
+function %colocated_rets_i64_i64_i64_i64() -> i64 {
+    fn0 = colocated %g() -> i64, i64, i64, i64
+
+block0:
+    v0, v1, v2, v3 = call fn0()
+    v4 = iadd v0, v2
+    v5 = iadd v1, v3
+    v6 = iadd v4, v5
+    return v6
+}
+
+; VCode:
+;   x30 = xconst8 -16
+;   x27 = xadd32 x27, x30
+;   store64 sp+8, x28 // flags =  notrap aligned
+;   store64 sp+0, x29 // flags =  notrap aligned
+;   x29 = xmov x27
+; block0:
+;   call TestCase(%g), CallInfo { uses: [], defs: [CallRetPair { vreg: Writable { reg: p0i }, preg: p0i }, CallRetPair { vreg: Writable { reg: p1i }, preg: p1i }, CallRetPair { vreg: Writable { reg: p2i }, preg: p2i }, CallRetPair { vreg: Writable { reg: p3i }, preg: p3i }], clobbers: PRegSet { bits: [65520, 65279, 4294967295, 0] }, callee_pop_size: 0 }
+;   x4 = xadd64 x0, x2
+;   x3 = xadd64 x1, x3
+;   x0 = xadd64 x4, x3
+;   x28 = load64_u sp+8 // flags = notrap aligned
+;   x29 = load64_u sp+0 // flags = notrap aligned
+;   x30 = xconst8 16
+;   x27 = xadd32 x27, x30
+;   ret
+;
+; Disassembled:
+;        0: 0e 1e f0                        xconst8 spilltmp0, -16
+;        3: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;        6: 2c 1b 08 1c                     store64_offset8 sp, 8, lr
+;        a: 2a 1b 1d                        store64 sp, fp
+;        d: 0b 1d 1b                        xmov fp, sp
+;       10: 01 00 00 00 00                  call 0x0    // target = 0x10
+;       15: 13 04 08                        xadd64 x4, x0, x2
+;       18: 13 23 0c                        xadd64 x3, x1, x3
+;       1b: 13 80 0c                        xadd64 x0, x4, x3
+;       1e: 25 1c 1b 08                     load64_offset8 lr, sp, 8
+;       22: 22 1d 1b                        load64 fp, sp
+;       25: 0e 1e 10                        xconst8 spilltmp0, 16
+;       28: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;       2b: 00                              ret
+
+function %colocated_stack_args() {
+    fn0 = colocated %g(i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64)
+
+block0:
+    v0 = iconst.i64 0
+    call fn0(v0, v0, v0, v0, v0, v0, v0, v0, v0, v0, v0, v0, v0, v0, v0, v0, v0, v0, v0, v0, v0, v0)
+    return
+}
+
+; VCode:
+;   x30 = xconst8 -16
+;   x27 = xadd32 x27, x30
+;   store64 sp+8, x28 // flags =  notrap aligned
+;   store64 sp+0, x29 // flags =  notrap aligned
+;   x29 = xmov x27
+;   x30 = xconst8 -48
+;   x27 = xadd32 x27, x30
+; block0:
+;   x15 = xconst8 0
+;   store64 OutgoingArg(0), x15 // flags =  notrap aligned
+;   store64 OutgoingArg(8), x15 // flags =  notrap aligned
+;   store64 OutgoingArg(16), x15 // flags =  notrap aligned
+;   store64 OutgoingArg(24), x15 // flags =  notrap aligned
+;   store64 OutgoingArg(32), x15 // flags =  notrap aligned
+;   store64 OutgoingArg(40), x15 // flags =  notrap aligned
+;   x0 = xmov x15
+;   x1 = xmov x15
+;   x2 = xmov x15
+;   x3 = xmov x15
+;   x4 = xmov x15
+;   x5 = xmov x15
+;   x6 = xmov x15
+;   x7 = xmov x15
+;   x8 = xmov x15
+;   x9 = xmov x15
+;   x10 = xmov x15
+;   x11 = xmov x15
+;   x12 = xmov x15
+;   x13 = xmov x15
+;   x14 = xmov x15
+;   call TestCase(%g), CallInfo { uses: [CallArgPair { vreg: p0i, preg: p0i }, CallArgPair { vreg: p1i, preg: p1i }, CallArgPair { vreg: p2i, preg: p2i }, CallArgPair { vreg: p3i, preg: p3i }, CallArgPair { vreg: p4i, preg: p4i }, CallArgPair { vreg: p5i, preg: p5i }, CallArgPair { vreg: p6i, preg: p6i }, CallArgPair { vreg: p7i, preg: p7i }, CallArgPair { vreg: p8i, preg: p8i }, CallArgPair { vreg: p9i, preg: p9i }, CallArgPair { vreg: p10i, preg: p10i }, CallArgPair { vreg: p11i, preg: p11i }, CallArgPair { vreg: p12i, preg: p12i }, CallArgPair { vreg: p13i, preg: p13i }, CallArgPair { vreg: p14i, preg: p14i }, CallArgPair { vreg: p15i, preg: p15i }], defs: [], clobbers: PRegSet { bits: [65535, 65279, 4294967295, 0] }, callee_pop_size: 0 }
+;   x30 = xconst8 48
+;   x27 = xadd32 x27, x30
+;   x28 = load64_u sp+8 // flags = notrap aligned
+;   x29 = load64_u sp+0 // flags = notrap aligned
+;   x30 = xconst8 16
+;   x27 = xadd32 x27, x30
+;   ret
+;
+; Disassembled:
+;        0: 0e 1e f0                        xconst8 spilltmp0, -16
+;        3: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;        6: 2c 1b 08 1c                     store64_offset8 sp, 8, lr
+;        a: 2a 1b 1d                        store64 sp, fp
+;        d: 0b 1d 1b                        xmov fp, sp
+;       10: 0e 1e d0                        xconst8 spilltmp0, -48
+;       13: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;       16: 0e 0f 00                        xconst8 x15, 0
+;       19: 2a 1b 0f                        store64 sp, x15
+;       1c: 2c 1b 08 0f                     store64_offset8 sp, 8, x15
+;       20: 2c 1b 10 0f                     store64_offset8 sp, 16, x15
+;       24: 2c 1b 18 0f                     store64_offset8 sp, 24, x15
+;       28: 2c 1b 20 0f                     store64_offset8 sp, 32, x15
+;       2c: 2c 1b 28 0f                     store64_offset8 sp, 40, x15
+;       30: 0b 00 0f                        xmov x0, x15
+;       33: 0b 01 0f                        xmov x1, x15
+;       36: 0b 02 0f                        xmov x2, x15
+;       39: 0b 03 0f                        xmov x3, x15
+;       3c: 0b 04 0f                        xmov x4, x15
+;       3f: 0b 05 0f                        xmov x5, x15
+;       42: 0b 06 0f                        xmov x6, x15
+;       45: 0b 07 0f                        xmov x7, x15
+;       48: 0b 08 0f                        xmov x8, x15
+;       4b: 0b 09 0f                        xmov x9, x15
+;       4e: 0b 0a 0f                        xmov x10, x15
+;       51: 0b 0b 0f                        xmov x11, x15
+;       54: 0b 0c 0f                        xmov x12, x15
+;       57: 0b 0d 0f                        xmov x13, x15
+;       5a: 0b 0e 0f                        xmov x14, x15
+;       5d: 01 00 00 00 00                  call 0x0    // target = 0x5d
+;       62: 0e 1e 30                        xconst8 spilltmp0, 48
+;       65: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;       68: 25 1c 1b 08                     load64_offset8 lr, sp, 8
+;       6c: 22 1d 1b                        load64 fp, sp
+;       6f: 0e 1e 10                        xconst8 spilltmp0, 16
+;       72: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;       75: 00                              ret
+
+function %colocated_stack_rets() -> i64 {
+    fn0 = colocated %g() -> i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64
+
+block0:
+    v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20 = call fn0()
+
+    v22 = iadd v0, v1
+    v23 = iadd v2, v3
+    v24 = iadd v4, v5
+    v25 = iadd v6, v7
+    v26 = iadd v8, v9
+    v27 = iadd v10, v11
+    v28 = iadd v12, v13
+    v29 = iadd v14, v15
+    v30 = iadd v16, v17
+    v31 = iadd v17, v18
+    v32 = iadd v19, v20
+
+    v33 = iadd v22, v23
+    v34 = iadd v24, v25
+    v35 = iadd v26, v27
+    v36 = iadd v28, v29
+    v37 = iadd v30, v31
+    v38 = iadd v32, v32
+
+    v39 = iadd v33, v34
+    v40 = iadd v35, v36
+    v41 = iadd v37, v38
+
+    v42 = iadd v39, v40
+    v43 = iadd v41, v41
+
+    v44 = iadd v42, v43
+    return v44
+}
+
+; VCode:
+;   x30 = xconst8 -16
+;   x27 = xadd32 x27, x30
+;   store64 sp+8, x28 // flags =  notrap aligned
+;   store64 sp+0, x29 // flags =  notrap aligned
+;   x29 = xmov x27
+;   x30 = xconst8 -64
+;   x27 = xadd32 x27, x30
+;   store64 sp+56, x16 // flags =  notrap aligned
+;   store64 sp+48, x18 // flags =  notrap aligned
+; block0:
+;   x0 = load_addr OutgoingArg(0)
+;   call TestCase(%g), CallInfo { uses: [CallArgPair { vreg: p0i, preg: p0i }], defs: [CallRetPair { vreg: Writable { reg: p0i }, preg: p0i }, CallRetPair { vreg: Writable { reg: p1i }, preg: p1i }, CallRetPair { vreg: Writable { reg: p2i }, preg: p2i }, CallRetPair { vreg: Writable { reg: p3i }, preg: p3i }, CallRetPair { vreg: Writable { reg: p4i }, preg: p4i }, CallRetPair { vreg: Writable { reg: p5i }, preg: p5i }, CallRetPair { vreg: Writable { reg: p6i }, preg: p6i }, CallRetPair { vreg: Writable { reg: p7i }, preg: p7i }, CallRetPair { vreg: Writable { reg: p8i }, preg: p8i }, CallRetPair { vreg: Writable { reg: p9i }, preg: p9i }, CallRetPair { vreg: Writable { reg: p10i }, preg: p10i }, CallRetPair { vreg: Writable { reg: p11i }, preg: p11i }, CallRetPair { vreg: Writable { reg: p12i }, preg: p12i }, CallRetPair { vreg: Writable { reg: p13i }, preg: p13i }, CallRetPair { vreg: Writable { reg: p14i }, preg: p14i }, CallRetPair { vreg: Writable { reg: p15i }, preg: p15i }], clobbers: PRegSet { bits: [0, 65279, 4294967295, 0] }, callee_pop_size: 0 }
+;   x16 = xmov x13
+;   x18 = xmov x11
+;   x25 = load64_u OutgoingArg(0) // flags = notrap aligned
+;   x11 = load64_u OutgoingArg(8) // flags = notrap aligned
+;   x13 = load64_u OutgoingArg(16) // flags = notrap aligned
+;   x31 = load64_u OutgoingArg(24) // flags = notrap aligned
+;   x17 = load64_u OutgoingArg(32) // flags = notrap aligned
+;   x30 = xadd64 x0, x1
+;   x29 = xadd64 x2, x3
+;   x5 = xadd64 x4, x5
+;   x6 = xadd64 x6, x7
+;   x7 = xadd64 x8, x9
+;   x0 = xmov x18
+;   x4 = xadd64 x10, x0
+;   x10 = xmov x16
+;   x8 = xadd64 x12, x10
+;   x14 = xadd64 x14, x15
+;   x15 = xadd64 x25, x11
+;   x13 = xadd64 x11, x13
+;   x0 = xadd64 x31, x17
+;   x1 = xadd64 x30, x29
+;   x2 = xadd64 x5, x6
+;   x3 = xadd64 x7, x4
+;   x14 = xadd64 x8, x14
+;   x13 = xadd64 x15, x13
+;   x15 = xadd64 x0, x0
+;   x0 = xadd64 x1, x2
+;   x14 = xadd64 x3, x14
+;   x13 = xadd64 x13, x15
+;   x14 = xadd64 x0, x14
+;   x13 = xadd64 x13, x13
+;   x0 = xadd64 x14, x13
+;   x16 = load64_u sp+56 // flags = notrap aligned
+;   x18 = load64_u sp+48 // flags = notrap aligned
+;   x30 = xconst8 64
+;   x27 = xadd32 x27, x30
+;   x28 = load64_u sp+8 // flags = notrap aligned
+;   x29 = load64_u sp+0 // flags = notrap aligned
+;   x30 = xconst8 16
+;   x27 = xadd32 x27, x30
+;   ret
+;
+; Disassembled:
+;        0: 0e 1e f0                        xconst8 spilltmp0, -16
+;        3: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;        6: 2c 1b 08 1c                     store64_offset8 sp, 8, lr
+;        a: 2a 1b 1d                        store64 sp, fp
+;        d: 0b 1d 1b                        xmov fp, sp
+;       10: 0e 1e c0                        xconst8 spilltmp0, -64
+;       13: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;       16: 2c 1b 38 10                     store64_offset8 sp, 56, x16
+;       1a: 2c 1b 30 12                     store64_offset8 sp, 48, x18
+;       1e: 0b 00 1b                        xmov x0, sp
+;       21: 01 00 00 00 00                  call 0x0    // target = 0x21
+;       26: 0b 10 0d                        xmov x16, x13
+;       29: 0b 12 0b                        xmov x18, x11
+;       2c: 22 19 1b                        load64 x25, sp
+;       2f: 25 0b 1b 08                     load64_offset8 x11, sp, 8
+;       33: 25 0d 1b 10                     load64_offset8 x13, sp, 16
+;       37: 25 1f 1b 18                     load64_offset8 spilltmp1, sp, 24
+;       3b: 25 11 1b 20                     load64_offset8 x17, sp, 32
+;       3f: 13 1e 04                        xadd64 spilltmp0, x0, x1
+;       42: 13 5d 0c                        xadd64 fp, x2, x3
+;       45: 13 85 14                        xadd64 x5, x4, x5
+;       48: 13 c6 1c                        xadd64 x6, x6, x7
+;       4b: 13 07 25                        xadd64 x7, x8, x9
+;       4e: 0b 00 12                        xmov x0, x18
+;       51: 13 44 01                        xadd64 x4, x10, x0
+;       54: 0b 0a 10                        xmov x10, x16
+;       57: 13 88 29                        xadd64 x8, x12, x10
+;       5a: 13 ce 3d                        xadd64 x14, x14, x15
+;       5d: 13 2f 2f                        xadd64 x15, x25, x11
+;       60: 13 6d 35                        xadd64 x13, x11, x13
+;       63: 13 e0 47                        xadd64 x0, spilltmp1, x17
+;       66: 13 c1 77                        xadd64 x1, spilltmp0, fp
+;       69: 13 a2 18                        xadd64 x2, x5, x6
+;       6c: 13 e3 10                        xadd64 x3, x7, x4
+;       6f: 13 0e 39                        xadd64 x14, x8, x14
+;       72: 13 ed 35                        xadd64 x13, x15, x13
+;       75: 13 0f 00                        xadd64 x15, x0, x0
+;       78: 13 20 08                        xadd64 x0, x1, x2
+;       7b: 13 6e 38                        xadd64 x14, x3, x14
+;       7e: 13 ad 3d                        xadd64 x13, x13, x15
+;       81: 13 0e 38                        xadd64 x14, x0, x14
+;       84: 13 ad 35                        xadd64 x13, x13, x13
+;       87: 13 c0 35                        xadd64 x0, x14, x13
+;       8a: 25 10 1b 38                     load64_offset8 x16, sp, 56
+;       8e: 25 12 1b 30                     load64_offset8 x18, sp, 48
+;       92: 0e 1e 40                        xconst8 spilltmp0, 64
+;       95: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;       98: 25 1c 1b 08                     load64_offset8 lr, sp, 8
+;       9c: 22 1d 1b                        load64 fp, sp
+;       9f: 0e 1e 10                        xconst8 spilltmp0, 16
+;       a2: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;       a5: 00                              ret
+
diff --git a/cranelift/filetests/filetests/isa/pulley32/get_stack_pointer.clif b/cranelift/filetests/filetests/isa/pulley32/get_stack_pointer.clif
new file mode 100644
index 000000000000..1bae8c297e72
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/pulley32/get_stack_pointer.clif
@@ -0,0 +1,17 @@
+test compile precise-output
+target pulley32
+
+function %get_stack_pointer() -> i32 {
+block0:
+  v0 = get_stack_pointer.i32
+  return v0
+}
+
+; VCode:
+; block0:
+;   x0 = get_sp
+;   ret
+;
+; Disassembled:
+;        0: 3d 02 00 00                     get_sp x0
+;        4: 00                              ret
diff --git a/cranelift/filetests/filetests/isa/pulley32/iadd.clif b/cranelift/filetests/filetests/isa/pulley32/iadd.clif
new file mode 100644
index 000000000000..68bfe902da4b
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/pulley32/iadd.clif
@@ -0,0 +1,63 @@
+test compile precise-output
+target pulley32
+
+function %i8(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = iadd v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xadd32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 12 00 04                        xadd32 x0, x0, x1
+;        3: 00                              ret
+
+function %i16(i16, i16) -> i16 {
+block0(v0: i16, v1: i16):
+    v2 = iadd v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xadd32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 12 00 04                        xadd32 x0, x0, x1
+;        3: 00                              ret
+
+function %i32(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+    v2 = iadd v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xadd32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 12 00 04                        xadd32 x0, x0, x1
+;        3: 00                              ret
+
+function %i64(i64, i64) -> i64 {
+block0(v0: i64, v1: i64):
+    v2 = iadd v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xadd64 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 13 00 04                        xadd64 x0, x0, x1
+;        3: 00                              ret
+
diff --git a/cranelift/filetests/filetests/isa/pulley32/icmp.clif b/cranelift/filetests/filetests/isa/pulley32/icmp.clif
new file mode 100644
index 000000000000..d6f489e68c8c
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/pulley32/icmp.clif
@@ -0,0 +1,603 @@
+test compile precise-output
+target pulley32
+
+function %i8_eq(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = icmp eq v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xeq32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1a 00 04                        xeq32 x0, x0, x1
+;        3: 00                              ret
+
+function %i16_eq(i16, i16) -> i8 {
+block0(v0: i16, v1: i16):
+    v2 = icmp eq v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xeq32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1a 00 04                        xeq32 x0, x0, x1
+;        3: 00                              ret
+
+function %i32_eq(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp eq v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xeq32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1a 00 04                        xeq32 x0, x0, x1
+;        3: 00                              ret
+
+function %i64_eq(i64, i64) -> i8 {
+block0(v0: i64, v1: i64):
+    v2 = icmp eq v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xeq64 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 14 00 04                        xeq64 x0, x0, x1
+;        3: 00                              ret
+
+function %i8_ne(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = icmp ne v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xneq32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1b 00 04                        xneq32 x0, x0, x1
+;        3: 00                              ret
+
+function %i16_ne(i16, i16) -> i8 {
+block0(v0: i16, v1: i16):
+    v2 = icmp ne v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xneq32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1b 00 04                        xneq32 x0, x0, x1
+;        3: 00                              ret
+
+function %i32_ne(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp ne v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xneq32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1b 00 04                        xneq32 x0, x0, x1
+;        3: 00                              ret
+
+function %i64_ne(i64, i64) -> i8 {
+block0(v0: i64, v1: i64):
+    v2 = icmp ne v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xneq64 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 15 00 04                        xneq64 x0, x0, x1
+;        3: 00                              ret
+
+function %i8_ult(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = icmp ult v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xult32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1e 00 04                        xult32 x0, x0, x1
+;        3: 00                              ret
+
+function %i16_ult(i16, i16) -> i8 {
+block0(v0: i16, v1: i16):
+    v2 = icmp ult v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xult32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1e 00 04                        xult32 x0, x0, x1
+;        3: 00                              ret
+
+function %i32_ult(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp ult v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xult32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1e 00 04                        xult32 x0, x0, x1
+;        3: 00                              ret
+
+function %i64_ult(i64, i64) -> i8 {
+block0(v0: i64, v1: i64):
+    v2 = icmp ult v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xult64 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 18 00 04                        xult64 x0, x0, x1
+;        3: 00                              ret
+
+function %i8_ule(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = icmp ule v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xulteq32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1f 00 04                        xulteq32 x0, x0, x1
+;        3: 00                              ret
+
+function %i16_ule(i16, i16) -> i8 {
+block0(v0: i16, v1: i16):
+    v2 = icmp ule v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xulteq32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1f 00 04                        xulteq32 x0, x0, x1
+;        3: 00                              ret
+
+function %i32_ule(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp ule v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xulteq32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1f 00 04                        xulteq32 x0, x0, x1
+;        3: 00                              ret
+
+function %i64_ule(i64, i64) -> i8 {
+block0(v0: i64, v1: i64):
+    v2 = icmp ule v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xulteq64 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 19 00 04                        xulteq64 x0, x0, x1
+;        3: 00                              ret
+
+function %i8_slt(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = icmp slt v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslt32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1c 00 04                        xslt32 x0, x0, x1
+;        3: 00                              ret
+
+function %i16_slt(i16, i16) -> i8 {
+block0(v0: i16, v1: i16):
+    v2 = icmp slt v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslt32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1c 00 04                        xslt32 x0, x0, x1
+;        3: 00                              ret
+
+function %i32_slt(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp slt v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslt32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1c 00 04                        xslt32 x0, x0, x1
+;        3: 00                              ret
+
+function %i64_slt(i64, i64) -> i8 {
+block0(v0: i64, v1: i64):
+    v2 = icmp slt v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslt64 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 16 00 04                        xslt64 x0, x0, x1
+;        3: 00                              ret
+
+function %i8_sle(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = icmp sle v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslteq32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1d 00 04                        xslteq32 x0, x0, x1
+;        3: 00                              ret
+
+function %i16_sle(i16, i16) -> i8 {
+block0(v0: i16, v1: i16):
+    v2 = icmp sle v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslteq32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1d 00 04                        xslteq32 x0, x0, x1
+;        3: 00                              ret
+
+function %i32_sle(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp sle v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslteq32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1d 00 04                        xslteq32 x0, x0, x1
+;        3: 00                              ret
+
+function %i64_sle(i64, i64) -> i8 {
+block0(v0: i64, v1: i64):
+    v2 = icmp sle v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslteq64 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 17 00 04                        xslteq64 x0, x0, x1
+;        3: 00                              ret
+
+function %i8_ugt(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = icmp ugt v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xult32 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 1e 20 00                        xult32 x0, x1, x0
+;        3: 00                              ret
+
+function %i16_ugt(i16, i16) -> i8 {
+block0(v0: i16, v1: i16):
+    v2 = icmp ugt v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xult32 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 1e 20 00                        xult32 x0, x1, x0
+;        3: 00                              ret
+
+function %i32_ugt(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp ugt v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xult32 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 1e 20 00                        xult32 x0, x1, x0
+;        3: 00                              ret
+
+function %i64_ugt(i64, i64) -> i8 {
+block0(v0: i64, v1: i64):
+    v2 = icmp ugt v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xult64 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 18 20 00                        xult64 x0, x1, x0
+;        3: 00                              ret
+
+function %i8_sgt(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = icmp sgt v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslt32 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 1c 20 00                        xslt32 x0, x1, x0
+;        3: 00                              ret
+
+function %i16_sgt(i16, i16) -> i8 {
+block0(v0: i16, v1: i16):
+    v2 = icmp sgt v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslt32 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 1c 20 00                        xslt32 x0, x1, x0
+;        3: 00                              ret
+
+function %i32_sgt(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp sgt v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslt32 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 1c 20 00                        xslt32 x0, x1, x0
+;        3: 00                              ret
+
+function %i64_sgt(i64, i64) -> i8 {
+block0(v0: i64, v1: i64):
+    v2 = icmp sgt v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslt64 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 16 20 00                        xslt64 x0, x1, x0
+;        3: 00                              ret
+
+function %i8_uge(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = icmp uge v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xulteq32 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 1f 20 00                        xulteq32 x0, x1, x0
+;        3: 00                              ret
+
+function %i16_uge(i16, i16) -> i8 {
+block0(v0: i16, v1: i16):
+    v2 = icmp uge v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xulteq32 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 1f 20 00                        xulteq32 x0, x1, x0
+;        3: 00                              ret
+
+function %i32_uge(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp uge v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xulteq32 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 1f 20 00                        xulteq32 x0, x1, x0
+;        3: 00                              ret
+
+function %i64_uge(i64, i64) -> i8 {
+block0(v0: i64, v1: i64):
+    v2 = icmp uge v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xulteq64 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 19 20 00                        xulteq64 x0, x1, x0
+;        3: 00                              ret
+
+function %i8_sge(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = icmp sge v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslteq32 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 1d 20 00                        xslteq32 x0, x1, x0
+;        3: 00                              ret
+
+function %i16_sge(i16, i16) -> i8 {
+block0(v0: i16, v1: i16):
+    v2 = icmp sge v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslteq32 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 1d 20 00                        xslteq32 x0, x1, x0
+;        3: 00                              ret
+
+function %i32_sge(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp sge v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslteq32 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 1d 20 00                        xslteq32 x0, x1, x0
+;        3: 00                              ret
+
+function %i64_sge(i64, i64) -> i8 {
+block0(v0: i64, v1: i64):
+    v2 = icmp sge v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslteq64 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 17 20 00                        xslteq64 x0, x1, x0
+;        3: 00                              ret
+
diff --git a/cranelift/filetests/filetests/isa/pulley32/iconst.clif b/cranelift/filetests/filetests/isa/pulley32/iconst.clif
new file mode 100644
index 000000000000..f38de07e3ddf
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/pulley32/iconst.clif
@@ -0,0 +1,63 @@
+test compile precise-output
+target pulley32
+
+function %i8() -> i8 {
+block0:
+    v0 = iconst.i8 0xff
+    return v0
+}
+
+; VCode:
+; block0:
+;   x0 = xconst16 255
+;   ret
+;
+; Disassembled:
+;        0: 0f 00 ff 00                     xconst16 x0, 255
+;        4: 00                              ret
+
+function %i16() -> i16 {
+block0:
+    v0 = iconst.i16 0xffff
+    return v0
+}
+
+; VCode:
+; block0:
+;   x0 = xconst32 65535
+;   ret
+;
+; Disassembled:
+;        0: 10 00 ff ff 00 00               xconst32 x0, 65535
+;        6: 00                              ret
+
+function %i32() -> i32 {
+block0:
+    v0 = iconst.i32 0xffff_ffff
+    return v0
+}
+
+; VCode:
+; block0:
+;   x0 = xconst32 -1
+;   ret
+;
+; Disassembled:
+;        0: 10 00 ff ff ff ff               xconst32 x0, -1
+;        6: 00                              ret
+
+function %i64() -> i64 {
+block0:
+    v0 = iconst.i64 0xffff_ffff_ffff_ffff
+    return v0
+}
+
+; VCode:
+; block0:
+;   x0 = xconst64 -1
+;   ret
+;
+; Disassembled:
+;        0: 11 00 ff ff ff ff ff ff ff ff   xconst64 x0, -1
+;        a: 00                              ret
+
diff --git a/cranelift/filetests/filetests/isa/pulley32/jump.clif b/cranelift/filetests/filetests/isa/pulley32/jump.clif
new file mode 100644
index 000000000000..c216be08ed40
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/pulley32/jump.clif
@@ -0,0 +1,38 @@
+test compile precise-output
+target pulley32
+
+function %jump(i8) -> i8 {
+block0(v0: i8):
+  brif v0, block1, block2
+
+block1:
+  v1 = iconst.i8 1
+  jump block3(v1)
+
+block2:
+  v2 = iconst.i8 0
+  jump block3(v2)
+
+block3(v3: i8):
+  return v3
+}
+
+; VCode:
+; block0:
+;   br_if x0, label2; jump label1
+; block1:
+;   x0 = xconst8 0
+;   jump label3
+; block2:
+;   x0 = xconst8 1
+;   jump label3
+; block3:
+;   ret
+;
+; Disassembled:
+;        0: 03 00 0e 00 00 00               br_if x0, 0xe    // target = 0xe
+;        6: 0e 00 00                        xconst8 x0, 0
+;        9: 02 08 00 00 00                  jump 0x8    // target = 0x11
+;        e: 0e 00 01                        xconst8 x0, 1
+;       11: 00                              ret
+
diff --git a/cranelift/filetests/filetests/isa/pulley32/load.clif b/cranelift/filetests/filetests/isa/pulley32/load.clif
new file mode 100644
index 000000000000..427d1a4a0d69
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/pulley32/load.clif
@@ -0,0 +1,63 @@
+test compile precise-output
+target pulley32
+
+function %load_i32(i32) -> i32 {
+block0(v0: i32):
+    v1 = load.i32 v0
+    return v1
+}
+
+; VCode:
+; block0:
+;   x0 = load32_u x0+0 // flags =
+;   ret
+;
+; Disassembled:
+;        0: 20 00 00                        load32_u x0, x0
+;        3: 00                              ret
+
+function %load_i64(i32) -> i64 {
+block0(v0: i32):
+    v1 = load.i64 v0
+    return v1
+}
+
+; VCode:
+; block0:
+;   x0 = load64_u x0+0 // flags =
+;   ret
+;
+; Disassembled:
+;        0: 22 00 00                        load64 x0, x0
+;        3: 00                              ret
+
+function %load_i32_with_offset(i32) -> i32 {
+block0(v0: i32):
+    v1 = load.i32 v0+4
+    return v1
+}
+
+; VCode:
+; block0:
+;   x0 = load32_u x0+4 // flags =
+;   ret
+;
+; Disassembled:
+;        0: 23 00 00 04                     load32_u_offset8 x0, x0, 4
+;        4: 00                              ret
+
+function %load_i64_with_offset(i32) -> i64 {
+block0(v0: i32):
+    v1 = load.i64 v0+8
+    return v1
+}
+
+; VCode:
+; block0:
+;   x0 = load64_u x0+8 // flags =
+;   ret
+;
+; Disassembled:
+;        0: 25 00 00 08                     load64_offset8 x0, x0, 8
+;        4: 00                              ret
+
diff --git a/cranelift/filetests/filetests/isa/pulley32/store.clif b/cranelift/filetests/filetests/isa/pulley32/store.clif
new file mode 100644
index 000000000000..57ec3de6f1c8
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/pulley32/store.clif
@@ -0,0 +1,63 @@
+test compile precise-output
+target pulley32
+
+function %store_i32(i32, i32) {
+block0(v0: i32, v1: i32):
+    store v0, v1
+    return
+}
+
+; VCode:
+; block0:
+;   store32 x1+0, x0 // flags = 
+;   ret
+;
+; Disassembled:
+;        0: 29 01 00                        store32 x1, x0
+;        3: 00                              ret
+
+function %store_i64(i64, i32) {
+block0(v0: i64, v1: i32):
+    store v0, v1
+    return
+}
+
+; VCode:
+; block0:
+;   store64 x1+0, x0 // flags = 
+;   ret
+;
+; Disassembled:
+;        0: 2a 01 00                        store64 x1, x0
+;        3: 00                              ret
+
+function %store_i32_with_offset(i32, i32) {
+block0(v0: i32, v1: i32):
+    store v0, v1+4
+    return
+}
+
+; VCode:
+; block0:
+;   store32 x1+4, x0 // flags = 
+;   ret
+;
+; Disassembled:
+;        0: 2b 01 04 00                     store32_offset8 x1, 4, x0
+;        4: 00                              ret
+
+function %store_i64_with_offset(i64, i32) {
+block0(v0: i64, v1: i32):
+    store v0, v1+8
+    return
+}
+
+; VCode:
+; block0:
+;   store64 x1+8, x0 // flags = 
+;   ret
+;
+; Disassembled:
+;        0: 2c 01 08 00                     store64_offset8 x1, 8, x0
+;        4: 00                              ret
+
diff --git a/cranelift/filetests/filetests/isa/pulley32/trap.clif b/cranelift/filetests/filetests/isa/pulley32/trap.clif
new file mode 100644
index 000000000000..983c35ce4bf6
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/pulley32/trap.clif
@@ -0,0 +1,64 @@
+test compile precise-output
+target pulley32
+
+function %trap() {
+block0:
+  trap user0
+}
+
+; VCode:
+; block0:
+;   trap // code = User(0)
+;
+; Disassembled:
+;        0: 3d 00 00                        trap
+
+function %trapnz(i64) {
+block0(v0: i64):
+  v1 = iconst.i64 42
+  v2 = icmp eq v0, v1
+  trapnz v2, user0
+  return
+}
+
+; VCode:
+; block0:
+;   x3 = xconst8 42
+;   x3 = xeq64 x0, x3
+;   br_if x3, label2; jump label1
+; block1:
+;   ret
+; block2:
+;   trap // code = User(0)
+;
+; Disassembled:
+;        0: 0e 03 2a                        xconst8 x3, 42
+;        3: 14 03 0c                        xeq64 x3, x0, x3
+;        6: 03 03 07 00 00 00               br_if x3, 0x7    // target = 0xd
+;        c: 00                              ret
+;        d: 3d 00 00                        trap
+
+function %trapz(i64) {
+block0(v0: i64):
+  v1 = iconst.i64 42
+  v2 = icmp eq v0, v1
+  trapz v2, user0
+  return
+}
+
+; VCode:
+; block0:
+;   x3 = xconst8 42
+;   x3 = xeq64 x0, x3
+;   br_if x3, label2; jump label1
+; block2:
+;   ret
+; block1:
+;   trap // code = User(0)
+;
+; Disassembled:
+;        0: 0e 03 2a                        xconst8 x3, 42
+;        3: 14 03 0c                        xeq64 x3, x0, x3
+;        6: 04 03 07 00 00 00               br_if_not x3, 0x7    // target = 0xd
+;        c: 00                              ret
+;        d: 3d 00 00                        trap
diff --git a/cranelift/filetests/filetests/isa/pulley64/brif-icmp.clif b/cranelift/filetests/filetests/isa/pulley64/brif-icmp.clif
new file mode 100644
index 000000000000..ba51bf4aa4ed
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/pulley64/brif-icmp.clif
@@ -0,0 +1,345 @@
+test compile precise-output
+target pulley64
+
+function %brif_icmp_eq(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+  v2 = icmp eq v0, v1
+  brif v2, block2, block1
+
+block1:
+  v3 = iconst.i32 1
+  return v3
+
+block2:
+  v4 = iconst.i32 2
+  return v4
+}
+
+; VCode:
+; block0:
+;   br_if_xeq32 x0, x1, label2; jump label1
+; block1:
+;   x0 = xconst8 1
+;   ret
+; block2:
+;   x0 = xconst8 2
+;   ret
+;
+; Disassembled:
+;        0: 05 00 01 0b 00 00 00            br_if_xeq32 x0, x1, 0xb    // target = 0xb
+;        7: 0e 00 01                        xconst8 x0, 1
+;        a: 00                              ret
+;        b: 0e 00 02                        xconst8 x0, 2
+;        e: 00                              ret
+
+function %brif_icmp_ne(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+  v2 = icmp ne v0, v1
+  brif v2, block2, block1
+
+block1:
+  v3 = iconst.i32 1
+  return v3
+
+block2:
+  v4 = iconst.i32 2
+  return v4
+}
+
+; VCode:
+; block0:
+;   br_if_xneq32 x0, x1, label2; jump label1
+; block1:
+;   x0 = xconst8 1
+;   ret
+; block2:
+;   x0 = xconst8 2
+;   ret
+;
+; Disassembled:
+;        0: 06 00 01 0b 00 00 00            br_if_xneq32 x0, x1, 0xb    // target = 0xb
+;        7: 0e 00 01                        xconst8 x0, 1
+;        a: 00                              ret
+;        b: 0e 00 02                        xconst8 x0, 2
+;        e: 00                              ret
+
+function %brif_icmp_ult(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+  v2 = icmp ult v0, v1
+  brif v2, block2, block1
+
+block1:
+  v3 = iconst.i32 1
+  return v3
+
+block2:
+  v4 = iconst.i32 2
+  return v4
+}
+
+; VCode:
+; block0:
+;   br_if_xult32 x0, x1, label2; jump label1
+; block1:
+;   x0 = xconst8 1
+;   ret
+; block2:
+;   x0 = xconst8 2
+;   ret
+;
+; Disassembled:
+;        0: 09 00 01 0b 00 00 00            br_if_xult32 x0, x1, 0xb    // target = 0xb
+;        7: 0e 00 01                        xconst8 x0, 1
+;        a: 00                              ret
+;        b: 0e 00 02                        xconst8 x0, 2
+;        e: 00                              ret
+
+function %brif_icmp_ule(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+  v2 = icmp ule v0, v1
+  brif v2, block2, block1
+
+block1:
+  v3 = iconst.i32 1
+  return v3
+
+block2:
+  v4 = iconst.i32 2
+  return v4
+}
+
+; VCode:
+; block0:
+;   br_if_xulteq32 x0, x1, label2; jump label1
+; block1:
+;   x0 = xconst8 1
+;   ret
+; block2:
+;   x0 = xconst8 2
+;   ret
+;
+; Disassembled:
+;        0: 0a 00 01 0b 00 00 00            br_if_xulteq32 x0, x1, 0xb    // target = 0xb
+;        7: 0e 00 01                        xconst8 x0, 1
+;        a: 00                              ret
+;        b: 0e 00 02                        xconst8 x0, 2
+;        e: 00                              ret
+
+function %brif_icmp_slt(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+  v2 = icmp slt v0, v1
+  brif v2, block2, block1
+
+block1:
+  v3 = iconst.i32 1
+  return v3
+
+block2:
+  v4 = iconst.i32 2
+  return v4
+}
+
+; VCode:
+; block0:
+;   br_if_xslt32 x0, x1, label2; jump label1
+; block1:
+;   x0 = xconst8 1
+;   ret
+; block2:
+;   x0 = xconst8 2
+;   ret
+;
+; Disassembled:
+;        0: 07 00 01 0b 00 00 00            br_if_xslt32 x0, x1, 0xb    // target = 0xb
+;        7: 0e 00 01                        xconst8 x0, 1
+;        a: 00                              ret
+;        b: 0e 00 02                        xconst8 x0, 2
+;        e: 00                              ret
+
+function %brif_icmp_sle(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+  v2 = icmp sle v0, v1
+  brif v2, block2, block1
+
+block1:
+  v3 = iconst.i32 1
+  return v3
+
+block2:
+  v4 = iconst.i32 2
+  return v4
+}
+
+; VCode:
+; block0:
+;   br_if_xslteq32 x0, x1, label2; jump label1
+; block1:
+;   x0 = xconst8 1
+;   ret
+; block2:
+;   x0 = xconst8 2
+;   ret
+;
+; Disassembled:
+;        0: 08 00 01 0b 00 00 00            br_if_xslteq32 x0, x1, 0xb    // target = 0xb
+;        7: 0e 00 01                        xconst8 x0, 1
+;        a: 00                              ret
+;        b: 0e 00 02                        xconst8 x0, 2
+;        e: 00                              ret
+
+function %brif_icmp_ugt(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+  v2 = icmp ugt v0, v1
+  brif v2, block2, block1
+
+block1:
+  v3 = iconst.i32 1
+  return v3
+
+block2:
+  v4 = iconst.i32 2
+  return v4
+}
+
+; VCode:
+; block0:
+;   br_if_xult32 x1, x0, label2; jump label1
+; block1:
+;   x0 = xconst8 1
+;   ret
+; block2:
+;   x0 = xconst8 2
+;   ret
+;
+; Disassembled:
+;        0: 09 01 00 0b 00 00 00            br_if_xult32 x1, x0, 0xb    // target = 0xb
+;        7: 0e 00 01                        xconst8 x0, 1
+;        a: 00                              ret
+;        b: 0e 00 02                        xconst8 x0, 2
+;        e: 00                              ret
+
+function %brif_icmp_uge(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+  v2 = icmp uge v0, v1
+  brif v2, block2, block1
+
+block1:
+  v3 = iconst.i32 1
+  return v3
+
+block2:
+  v4 = iconst.i32 2
+  return v4
+}
+
+; VCode:
+; block0:
+;   br_if_xulteq32 x1, x0, label2; jump label1
+; block1:
+;   x0 = xconst8 1
+;   ret
+; block2:
+;   x0 = xconst8 2
+;   ret
+;
+; Disassembled:
+;        0: 0a 01 00 0b 00 00 00            br_if_xulteq32 x1, x0, 0xb    // target = 0xb
+;        7: 0e 00 01                        xconst8 x0, 1
+;        a: 00                              ret
+;        b: 0e 00 02                        xconst8 x0, 2
+;        e: 00                              ret
+
+function %brif_icmp_sgt(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+  v2 = icmp sgt v0, v1
+  brif v2, block2, block1
+
+block1:
+  v3 = iconst.i32 1
+  return v3
+
+block2:
+  v4 = iconst.i32 2
+  return v4
+}
+
+; VCode:
+; block0:
+;   br_if_xslt32 x1, x0, label2; jump label1
+; block1:
+;   x0 = xconst8 1
+;   ret
+; block2:
+;   x0 = xconst8 2
+;   ret
+;
+; Disassembled:
+;        0: 07 01 00 0b 00 00 00            br_if_xslt32 x1, x0, 0xb    // target = 0xb
+;        7: 0e 00 01                        xconst8 x0, 1
+;        a: 00                              ret
+;        b: 0e 00 02                        xconst8 x0, 2
+;        e: 00                              ret
+
+function %brif_icmp_sge(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+  v2 = icmp sge v0, v1
+  brif v2, block2, block1
+
+block1:
+  v3 = iconst.i32 1
+  return v3
+
+block2:
+  v4 = iconst.i32 2
+  return v4
+}
+
+; VCode:
+; block0:
+;   br_if_xslteq32 x1, x0, label2; jump label1
+; block1:
+;   x0 = xconst8 1
+;   ret
+; block2:
+;   x0 = xconst8 2
+;   ret
+;
+; Disassembled:
+;        0: 08 01 00 0b 00 00 00            br_if_xslteq32 x1, x0, 0xb    // target = 0xb
+;        7: 0e 00 01                        xconst8 x0, 1
+;        a: 00                              ret
+;        b: 0e 00 02                        xconst8 x0, 2
+;        e: 00                              ret
+
+function %brif_uextend_icmp_eq(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+  v2 = icmp eq v0, v1
+  v3 = uextend.i32 v2
+  brif v3, block2, block1
+
+block1:
+  v4 = iconst.i32 1
+  return v4
+
+block2:
+  v5 = iconst.i32 2
+  return v5
+}
+
+; VCode:
+; block0:
+;   br_if_xeq32 x0, x1, label2; jump label1
+; block1:
+;   x0 = xconst8 1
+;   ret
+; block2:
+;   x0 = xconst8 2
+;   ret
+;
+; Disassembled:
+;        0: 05 00 01 0b 00 00 00            br_if_xeq32 x0, x1, 0xb    // target = 0xb
+;        7: 0e 00 01                        xconst8 x0, 1
+;        a: 00                              ret
+;        b: 0e 00 02                        xconst8 x0, 2
+;        e: 00                              ret
+
diff --git a/cranelift/filetests/filetests/isa/pulley64/brif.clif b/cranelift/filetests/filetests/isa/pulley64/brif.clif
new file mode 100644
index 000000000000..597257d0d4b9
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/pulley64/brif.clif
@@ -0,0 +1,253 @@
+test compile precise-output
+target pulley64
+
+function %brif_i8(i8) -> i8 {
+block0(v0: i8):
+  brif v0, block1, block2
+
+block1:
+  v1 = iconst.i8 1
+  return v1
+
+block2:
+  v2 = iconst.i8 0
+  return v2
+}
+
+; VCode:
+; block0:
+;   br_if x0, label2; jump label1
+; block1:
+;   x0 = xconst8 0
+;   ret
+; block2:
+;   x0 = xconst8 1
+;   ret
+;
+; Disassembled:
+;        0: 03 00 0a 00 00 00               br_if x0, 0xa    // target = 0xa
+;        6: 0e 00 00                        xconst8 x0, 0
+;        9: 00                              ret
+;        a: 0e 00 01                        xconst8 x0, 1
+;        d: 00                              ret
+
+function %brif_i16(i16) -> i8 {
+block0(v0: i16):
+  brif v0, block1, block2
+
+block1:
+  v1 = iconst.i8 1
+  return v1
+
+block2:
+  v2 = iconst.i8 0
+  return v2
+}
+
+; VCode:
+; block0:
+;   br_if x0, label2; jump label1
+; block1:
+;   x0 = xconst8 0
+;   ret
+; block2:
+;   x0 = xconst8 1
+;   ret
+;
+; Disassembled:
+;        0: 03 00 0a 00 00 00               br_if x0, 0xa    // target = 0xa
+;        6: 0e 00 00                        xconst8 x0, 0
+;        9: 00                              ret
+;        a: 0e 00 01                        xconst8 x0, 1
+;        d: 00                              ret
+
+function %brif_i32(i32) -> i8 {
+block0(v0: i32):
+  brif v0, block1, block2
+
+block1:
+  v1 = iconst.i8 1
+  return v1
+
+block2:
+  v2 = iconst.i8 0
+  return v2
+}
+
+; VCode:
+; block0:
+;   br_if x0, label2; jump label1
+; block1:
+;   x0 = xconst8 0
+;   ret
+; block2:
+;   x0 = xconst8 1
+;   ret
+;
+; Disassembled:
+;        0: 03 00 0a 00 00 00               br_if x0, 0xa    // target = 0xa
+;        6: 0e 00 00                        xconst8 x0, 0
+;        9: 00                              ret
+;        a: 0e 00 01                        xconst8 x0, 1
+;        d: 00                              ret
+
+function %brif_i64(i64) -> i8 {
+block0(v0: i64):
+  brif v0, block1, block2
+
+block1:
+  v1 = iconst.i8 1
+  return v1
+
+block2:
+  v2 = iconst.i8 0
+  return v2
+}
+
+; VCode:
+; block0:
+;   br_if x0, label2; jump label1
+; block1:
+;   x0 = xconst8 0
+;   ret
+; block2:
+;   x0 = xconst8 1
+;   ret
+;
+; Disassembled:
+;        0: 03 00 0a 00 00 00               br_if x0, 0xa    // target = 0xa
+;        6: 0e 00 00                        xconst8 x0, 0
+;        9: 00                              ret
+;        a: 0e 00 01                        xconst8 x0, 1
+;        d: 00                              ret
+
+function %brif_icmp_i8(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+  v2 = icmp eq v0, v1
+  brif v2, block1, block2
+
+block1:
+  v3 = iconst.i8 1
+  return v3
+
+block2:
+  v4 = iconst.i8 0
+  return v4
+}
+
+; VCode:
+; block0:
+;   x5 = xeq32 x0, x1
+;   br_if x5, label2; jump label1
+; block1:
+;   x0 = xconst8 0
+;   ret
+; block2:
+;   x0 = xconst8 1
+;   ret
+;
+; Disassembled:
+;        0: 1a 05 04                        xeq32 x5, x0, x1
+;        3: 03 05 0a 00 00 00               br_if x5, 0xa    // target = 0xd
+;        9: 0e 00 00                        xconst8 x0, 0
+;        c: 00                              ret
+;        d: 0e 00 01                        xconst8 x0, 1
+;       10: 00                              ret
+
+function %brif_icmp_i16(i16, i16) -> i8 {
+block0(v0: i16, v1: i16):
+  v2 = icmp ne v0, v1
+  brif v2, block1, block2
+
+block1:
+  v3 = iconst.i8 1
+  return v3
+
+block2:
+  v4 = iconst.i8 0
+  return v4
+}
+
+; VCode:
+; block0:
+;   x5 = xneq32 x0, x1
+;   br_if x5, label2; jump label1
+; block1:
+;   x0 = xconst8 0
+;   ret
+; block2:
+;   x0 = xconst8 1
+;   ret
+;
+; Disassembled:
+;        0: 1b 05 04                        xneq32 x5, x0, x1
+;        3: 03 05 0a 00 00 00               br_if x5, 0xa    // target = 0xd
+;        9: 0e 00 00                        xconst8 x0, 0
+;        c: 00                              ret
+;        d: 0e 00 01                        xconst8 x0, 1
+;       10: 00                              ret
+
+function %brif_icmp_i32(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+  v2 = icmp slt v0, v1
+  brif v2, block1, block2
+
+block1:
+  v3 = iconst.i8 1
+  return v3
+
+block2:
+  v4 = iconst.i8 0
+  return v4
+}
+
+; VCode:
+; block0:
+;   br_if_xslt32 x0, x1, label2; jump label1
+; block1:
+;   x0 = xconst8 0
+;   ret
+; block2:
+;   x0 = xconst8 1
+;   ret
+;
+; Disassembled:
+;        0: 07 00 01 0b 00 00 00            br_if_xslt32 x0, x1, 0xb    // target = 0xb
+;        7: 0e 00 00                        xconst8 x0, 0
+;        a: 00                              ret
+;        b: 0e 00 01                        xconst8 x0, 1
+;        e: 00                              ret
+
+function %brif_icmp_i64(i64, i64) -> i8 {
+block0(v0: i64, v1: i64):
+  v2 = icmp uge v0, v1
+  brif v2, block1, block2
+
+block1:
+  v3 = iconst.i8 1
+  return v3
+
+block2:
+  v4 = iconst.i8 0
+  return v4
+}
+
+; VCode:
+; block0:
+;   x5 = xulteq64 x1, x0
+;   br_if x5, label2; jump label1
+; block1:
+;   x0 = xconst8 0
+;   ret
+; block2:
+;   x0 = xconst8 1
+;   ret
+;
+; Disassembled:
+;        0: 19 25 00                        xulteq64 x5, x1, x0
+;        3: 03 05 0a 00 00 00               br_if x5, 0xa    // target = 0xd
+;        9: 0e 00 00                        xconst8 x0, 0
+;        c: 00                              ret
+;        d: 0e 00 01                        xconst8 x0, 1
+;       10: 00                              ret
+
diff --git a/cranelift/filetests/filetests/isa/pulley64/call.clif b/cranelift/filetests/filetests/isa/pulley64/call.clif
new file mode 100644
index 000000000000..daefab228804
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/pulley64/call.clif
@@ -0,0 +1,409 @@
+test compile precise-output
+target pulley64
+
+function %colocated_args_i64_rets_i64() -> i64 {
+    fn0 = colocated %g(i64) -> i64
+
+block0:
+    v0 = iconst.i64 0
+    v1 = call fn0(v0)
+    v2 = iconst.i64 1
+    return v2
+}
+
+; VCode:
+;   x30 = xconst8 -16
+;   x27 = xadd32 x27, x30
+;   store64 sp+8, x28 // flags =  notrap aligned
+;   store64 sp+0, x29 // flags =  notrap aligned
+;   x29 = xmov x27
+; block0:
+;   x0 = xconst8 0
+;   call TestCase(%g), CallInfo { uses: [CallArgPair { vreg: p0i, preg: p0i }], defs: [CallRetPair { vreg: Writable { reg: p0i }, preg: p0i }], clobbers: PRegSet { bits: [65534, 65279, 4294967295, 0] }, callee_pop_size: 0 }
+;   x0 = xconst8 1
+;   x28 = load64_u sp+8 // flags = notrap aligned
+;   x29 = load64_u sp+0 // flags = notrap aligned
+;   x30 = xconst8 16
+;   x27 = xadd32 x27, x30
+;   ret
+;
+; Disassembled:
+;        0: 0e 1e f0                        xconst8 spilltmp0, -16
+;        3: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;        6: 2c 1b 08 1c                     store64_offset8 sp, 8, lr
+;        a: 2a 1b 1d                        store64 sp, fp
+;        d: 0b 1d 1b                        xmov fp, sp
+;       10: 0e 00 00                        xconst8 x0, 0
+;       13: 01 00 00 00 00                  call 0x0    // target = 0x13
+;       18: 0e 00 01                        xconst8 x0, 1
+;       1b: 25 1c 1b 08                     load64_offset8 lr, sp, 8
+;       1f: 22 1d 1b                        load64 fp, sp
+;       22: 0e 1e 10                        xconst8 spilltmp0, 16
+;       25: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;       28: 00                              ret
+
+function %colocated_args_i32_rets_i32() -> i32 {
+    fn0 = colocated %g(i32) -> i32
+
+block0:
+    v0 = iconst.i32 0
+    v1 = call fn0(v0)
+    v2 = iconst.i32 1
+    return v2
+}
+
+; VCode:
+;   x30 = xconst8 -16
+;   x27 = xadd32 x27, x30
+;   store64 sp+8, x28 // flags =  notrap aligned
+;   store64 sp+0, x29 // flags =  notrap aligned
+;   x29 = xmov x27
+; block0:
+;   x0 = xconst8 0
+;   call TestCase(%g), CallInfo { uses: [CallArgPair { vreg: p0i, preg: p0i }], defs: [CallRetPair { vreg: Writable { reg: p0i }, preg: p0i }], clobbers: PRegSet { bits: [65534, 65279, 4294967295, 0] }, callee_pop_size: 0 }
+;   x0 = xconst8 1
+;   x28 = load64_u sp+8 // flags = notrap aligned
+;   x29 = load64_u sp+0 // flags = notrap aligned
+;   x30 = xconst8 16
+;   x27 = xadd32 x27, x30
+;   ret
+;
+; Disassembled:
+;        0: 0e 1e f0                        xconst8 spilltmp0, -16
+;        3: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;        6: 2c 1b 08 1c                     store64_offset8 sp, 8, lr
+;        a: 2a 1b 1d                        store64 sp, fp
+;        d: 0b 1d 1b                        xmov fp, sp
+;       10: 0e 00 00                        xconst8 x0, 0
+;       13: 01 00 00 00 00                  call 0x0    // target = 0x13
+;       18: 0e 00 01                        xconst8 x0, 1
+;       1b: 25 1c 1b 08                     load64_offset8 lr, sp, 8
+;       1f: 22 1d 1b                        load64 fp, sp
+;       22: 0e 1e 10                        xconst8 spilltmp0, 16
+;       25: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;       28: 00                              ret
+
+function %colocated_args_i64_i32_i64_i32() {
+    fn0 = colocated %g(i64, i32, i64, i32)
+
+block0:
+    v0 = iconst.i64 0
+    v1 = iconst.i32 1
+    v2 = iconst.i64 2
+    v3 = iconst.i32 3
+    call fn0(v0, v1, v2, v3)
+    return
+}
+
+; VCode:
+;   x30 = xconst8 -16
+;   x27 = xadd32 x27, x30
+;   store64 sp+8, x28 // flags =  notrap aligned
+;   store64 sp+0, x29 // flags =  notrap aligned
+;   x29 = xmov x27
+; block0:
+;   x0 = xconst8 0
+;   x1 = xconst8 1
+;   x2 = xconst8 2
+;   x3 = xconst8 3
+;   call TestCase(%g), CallInfo { uses: [CallArgPair { vreg: p0i, preg: p0i }, CallArgPair { vreg: p1i, preg: p1i }, CallArgPair { vreg: p2i, preg: p2i }, CallArgPair { vreg: p3i, preg: p3i }], defs: [], clobbers: PRegSet { bits: [65535, 65279, 4294967295, 0] }, callee_pop_size: 0 }
+;   x28 = load64_u sp+8 // flags = notrap aligned
+;   x29 = load64_u sp+0 // flags = notrap aligned
+;   x30 = xconst8 16
+;   x27 = xadd32 x27, x30
+;   ret
+;
+; Disassembled:
+;        0: 0e 1e f0                        xconst8 spilltmp0, -16
+;        3: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;        6: 2c 1b 08 1c                     store64_offset8 sp, 8, lr
+;        a: 2a 1b 1d                        store64 sp, fp
+;        d: 0b 1d 1b                        xmov fp, sp
+;       10: 0e 00 00                        xconst8 x0, 0
+;       13: 0e 01 01                        xconst8 x1, 1
+;       16: 0e 02 02                        xconst8 x2, 2
+;       19: 0e 03 03                        xconst8 x3, 3
+;       1c: 01 00 00 00 00                  call 0x0    // target = 0x1c
+;       21: 25 1c 1b 08                     load64_offset8 lr, sp, 8
+;       25: 22 1d 1b                        load64 fp, sp
+;       28: 0e 1e 10                        xconst8 spilltmp0, 16
+;       2b: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;       2e: 00                              ret
+
+function %colocated_rets_i64_i64_i64_i64() -> i64 {
+    fn0 = colocated %g() -> i64, i64, i64, i64
+
+block0:
+    v0, v1, v2, v3 = call fn0()
+    v4 = iadd v0, v2
+    v5 = iadd v1, v3
+    v6 = iadd v4, v5
+    return v6
+}
+
+; VCode:
+;   x30 = xconst8 -16
+;   x27 = xadd32 x27, x30
+;   store64 sp+8, x28 // flags =  notrap aligned
+;   store64 sp+0, x29 // flags =  notrap aligned
+;   x29 = xmov x27
+; block0:
+;   call TestCase(%g), CallInfo { uses: [], defs: [CallRetPair { vreg: Writable { reg: p0i }, preg: p0i }, CallRetPair { vreg: Writable { reg: p1i }, preg: p1i }, CallRetPair { vreg: Writable { reg: p2i }, preg: p2i }, CallRetPair { vreg: Writable { reg: p3i }, preg: p3i }], clobbers: PRegSet { bits: [65520, 65279, 4294967295, 0] }, callee_pop_size: 0 }
+;   x4 = xadd64 x0, x2
+;   x3 = xadd64 x1, x3
+;   x0 = xadd64 x4, x3
+;   x28 = load64_u sp+8 // flags = notrap aligned
+;   x29 = load64_u sp+0 // flags = notrap aligned
+;   x30 = xconst8 16
+;   x27 = xadd32 x27, x30
+;   ret
+;
+; Disassembled:
+;        0: 0e 1e f0                        xconst8 spilltmp0, -16
+;        3: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;        6: 2c 1b 08 1c                     store64_offset8 sp, 8, lr
+;        a: 2a 1b 1d                        store64 sp, fp
+;        d: 0b 1d 1b                        xmov fp, sp
+;       10: 01 00 00 00 00                  call 0x0    // target = 0x10
+;       15: 13 04 08                        xadd64 x4, x0, x2
+;       18: 13 23 0c                        xadd64 x3, x1, x3
+;       1b: 13 80 0c                        xadd64 x0, x4, x3
+;       1e: 25 1c 1b 08                     load64_offset8 lr, sp, 8
+;       22: 22 1d 1b                        load64 fp, sp
+;       25: 0e 1e 10                        xconst8 spilltmp0, 16
+;       28: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;       2b: 00                              ret
+
+function %colocated_stack_args() {
+    fn0 = colocated %g(i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64)
+
+block0:
+    v0 = iconst.i64 0
+    call fn0(v0, v0, v0, v0, v0, v0, v0, v0, v0, v0, v0, v0, v0, v0, v0, v0, v0, v0, v0, v0, v0, v0)
+    return
+}
+
+; VCode:
+;   x30 = xconst8 -16
+;   x27 = xadd32 x27, x30
+;   store64 sp+8, x28 // flags =  notrap aligned
+;   store64 sp+0, x29 // flags =  notrap aligned
+;   x29 = xmov x27
+;   x30 = xconst8 -48
+;   x27 = xadd32 x27, x30
+; block0:
+;   x15 = xconst8 0
+;   store64 OutgoingArg(0), x15 // flags =  notrap aligned
+;   store64 OutgoingArg(8), x15 // flags =  notrap aligned
+;   store64 OutgoingArg(16), x15 // flags =  notrap aligned
+;   store64 OutgoingArg(24), x15 // flags =  notrap aligned
+;   store64 OutgoingArg(32), x15 // flags =  notrap aligned
+;   store64 OutgoingArg(40), x15 // flags =  notrap aligned
+;   x0 = xmov x15
+;   x1 = xmov x15
+;   x2 = xmov x15
+;   x3 = xmov x15
+;   x4 = xmov x15
+;   x5 = xmov x15
+;   x6 = xmov x15
+;   x7 = xmov x15
+;   x8 = xmov x15
+;   x9 = xmov x15
+;   x10 = xmov x15
+;   x11 = xmov x15
+;   x12 = xmov x15
+;   x13 = xmov x15
+;   x14 = xmov x15
+;   call TestCase(%g), CallInfo { uses: [CallArgPair { vreg: p0i, preg: p0i }, CallArgPair { vreg: p1i, preg: p1i }, CallArgPair { vreg: p2i, preg: p2i }, CallArgPair { vreg: p3i, preg: p3i }, CallArgPair { vreg: p4i, preg: p4i }, CallArgPair { vreg: p5i, preg: p5i }, CallArgPair { vreg: p6i, preg: p6i }, CallArgPair { vreg: p7i, preg: p7i }, CallArgPair { vreg: p8i, preg: p8i }, CallArgPair { vreg: p9i, preg: p9i }, CallArgPair { vreg: p10i, preg: p10i }, CallArgPair { vreg: p11i, preg: p11i }, CallArgPair { vreg: p12i, preg: p12i }, CallArgPair { vreg: p13i, preg: p13i }, CallArgPair { vreg: p14i, preg: p14i }, CallArgPair { vreg: p15i, preg: p15i }], defs: [], clobbers: PRegSet { bits: [65535, 65279, 4294967295, 0] }, callee_pop_size: 0 }
+;   x30 = xconst8 48
+;   x27 = xadd32 x27, x30
+;   x28 = load64_u sp+8 // flags = notrap aligned
+;   x29 = load64_u sp+0 // flags = notrap aligned
+;   x30 = xconst8 16
+;   x27 = xadd32 x27, x30
+;   ret
+;
+; Disassembled:
+;        0: 0e 1e f0                        xconst8 spilltmp0, -16
+;        3: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;        6: 2c 1b 08 1c                     store64_offset8 sp, 8, lr
+;        a: 2a 1b 1d                        store64 sp, fp
+;        d: 0b 1d 1b                        xmov fp, sp
+;       10: 0e 1e d0                        xconst8 spilltmp0, -48
+;       13: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;       16: 0e 0f 00                        xconst8 x15, 0
+;       19: 2a 1b 0f                        store64 sp, x15
+;       1c: 2c 1b 08 0f                     store64_offset8 sp, 8, x15
+;       20: 2c 1b 10 0f                     store64_offset8 sp, 16, x15
+;       24: 2c 1b 18 0f                     store64_offset8 sp, 24, x15
+;       28: 2c 1b 20 0f                     store64_offset8 sp, 32, x15
+;       2c: 2c 1b 28 0f                     store64_offset8 sp, 40, x15
+;       30: 0b 00 0f                        xmov x0, x15
+;       33: 0b 01 0f                        xmov x1, x15
+;       36: 0b 02 0f                        xmov x2, x15
+;       39: 0b 03 0f                        xmov x3, x15
+;       3c: 0b 04 0f                        xmov x4, x15
+;       3f: 0b 05 0f                        xmov x5, x15
+;       42: 0b 06 0f                        xmov x6, x15
+;       45: 0b 07 0f                        xmov x7, x15
+;       48: 0b 08 0f                        xmov x8, x15
+;       4b: 0b 09 0f                        xmov x9, x15
+;       4e: 0b 0a 0f                        xmov x10, x15
+;       51: 0b 0b 0f                        xmov x11, x15
+;       54: 0b 0c 0f                        xmov x12, x15
+;       57: 0b 0d 0f                        xmov x13, x15
+;       5a: 0b 0e 0f                        xmov x14, x15
+;       5d: 01 00 00 00 00                  call 0x0    // target = 0x5d
+;       62: 0e 1e 30                        xconst8 spilltmp0, 48
+;       65: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;       68: 25 1c 1b 08                     load64_offset8 lr, sp, 8
+;       6c: 22 1d 1b                        load64 fp, sp
+;       6f: 0e 1e 10                        xconst8 spilltmp0, 16
+;       72: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;       75: 00                              ret
+
+function %colocated_stack_rets() -> i64 {
+    fn0 = colocated %g() -> i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64
+
+block0:
+    v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20 = call fn0()
+
+    v22 = iadd v0, v1
+    v23 = iadd v2, v3
+    v24 = iadd v4, v5
+    v25 = iadd v6, v7
+    v26 = iadd v8, v9
+    v27 = iadd v10, v11
+    v28 = iadd v12, v13
+    v29 = iadd v14, v15
+    v30 = iadd v16, v17
+    v31 = iadd v17, v18
+    v32 = iadd v19, v20
+
+    v33 = iadd v22, v23
+    v34 = iadd v24, v25
+    v35 = iadd v26, v27
+    v36 = iadd v28, v29
+    v37 = iadd v30, v31
+    v38 = iadd v32, v32
+
+    v39 = iadd v33, v34
+    v40 = iadd v35, v36
+    v41 = iadd v37, v38
+
+    v42 = iadd v39, v40
+    v43 = iadd v41, v41
+
+    v44 = iadd v42, v43
+    return v44
+}
+
+; VCode:
+;   x30 = xconst8 -16
+;   x27 = xadd32 x27, x30
+;   store64 sp+8, x28 // flags =  notrap aligned
+;   store64 sp+0, x29 // flags =  notrap aligned
+;   x29 = xmov x27
+;   x30 = xconst8 -64
+;   x27 = xadd32 x27, x30
+;   store64 sp+56, x16 // flags =  notrap aligned
+;   store64 sp+48, x18 // flags =  notrap aligned
+; block0:
+;   x0 = load_addr OutgoingArg(0)
+;   call TestCase(%g), CallInfo { uses: [CallArgPair { vreg: p0i, preg: p0i }], defs: [CallRetPair { vreg: Writable { reg: p0i }, preg: p0i }, CallRetPair { vreg: Writable { reg: p1i }, preg: p1i }, CallRetPair { vreg: Writable { reg: p2i }, preg: p2i }, CallRetPair { vreg: Writable { reg: p3i }, preg: p3i }, CallRetPair { vreg: Writable { reg: p4i }, preg: p4i }, CallRetPair { vreg: Writable { reg: p5i }, preg: p5i }, CallRetPair { vreg: Writable { reg: p6i }, preg: p6i }, CallRetPair { vreg: Writable { reg: p7i }, preg: p7i }, CallRetPair { vreg: Writable { reg: p8i }, preg: p8i }, CallRetPair { vreg: Writable { reg: p9i }, preg: p9i }, CallRetPair { vreg: Writable { reg: p10i }, preg: p10i }, CallRetPair { vreg: Writable { reg: p11i }, preg: p11i }, CallRetPair { vreg: Writable { reg: p12i }, preg: p12i }, CallRetPair { vreg: Writable { reg: p13i }, preg: p13i }, CallRetPair { vreg: Writable { reg: p14i }, preg: p14i }, CallRetPair { vreg: Writable { reg: p15i }, preg: p15i }], clobbers: PRegSet { bits: [0, 65279, 4294967295, 0] }, callee_pop_size: 0 }
+;   x16 = xmov x13
+;   x18 = xmov x11
+;   x25 = load64_u OutgoingArg(0) // flags = notrap aligned
+;   x11 = load64_u OutgoingArg(8) // flags = notrap aligned
+;   x13 = load64_u OutgoingArg(16) // flags = notrap aligned
+;   x31 = load64_u OutgoingArg(24) // flags = notrap aligned
+;   x17 = load64_u OutgoingArg(32) // flags = notrap aligned
+;   x30 = xadd64 x0, x1
+;   x29 = xadd64 x2, x3
+;   x5 = xadd64 x4, x5
+;   x6 = xadd64 x6, x7
+;   x7 = xadd64 x8, x9
+;   x0 = xmov x18
+;   x4 = xadd64 x10, x0
+;   x10 = xmov x16
+;   x8 = xadd64 x12, x10
+;   x14 = xadd64 x14, x15
+;   x15 = xadd64 x25, x11
+;   x13 = xadd64 x11, x13
+;   x0 = xadd64 x31, x17
+;   x1 = xadd64 x30, x29
+;   x2 = xadd64 x5, x6
+;   x3 = xadd64 x7, x4
+;   x14 = xadd64 x8, x14
+;   x13 = xadd64 x15, x13
+;   x15 = xadd64 x0, x0
+;   x0 = xadd64 x1, x2
+;   x14 = xadd64 x3, x14
+;   x13 = xadd64 x13, x15
+;   x14 = xadd64 x0, x14
+;   x13 = xadd64 x13, x13
+;   x0 = xadd64 x14, x13
+;   x16 = load64_u sp+56 // flags = notrap aligned
+;   x18 = load64_u sp+48 // flags = notrap aligned
+;   x30 = xconst8 64
+;   x27 = xadd32 x27, x30
+;   x28 = load64_u sp+8 // flags = notrap aligned
+;   x29 = load64_u sp+0 // flags = notrap aligned
+;   x30 = xconst8 16
+;   x27 = xadd32 x27, x30
+;   ret
+;
+; Disassembled:
+;        0: 0e 1e f0                        xconst8 spilltmp0, -16
+;        3: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;        6: 2c 1b 08 1c                     store64_offset8 sp, 8, lr
+;        a: 2a 1b 1d                        store64 sp, fp
+;        d: 0b 1d 1b                        xmov fp, sp
+;       10: 0e 1e c0                        xconst8 spilltmp0, -64
+;       13: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;       16: 2c 1b 38 10                     store64_offset8 sp, 56, x16
+;       1a: 2c 1b 30 12                     store64_offset8 sp, 48, x18
+;       1e: 0b 00 1b                        xmov x0, sp
+;       21: 01 00 00 00 00                  call 0x0    // target = 0x21
+;       26: 0b 10 0d                        xmov x16, x13
+;       29: 0b 12 0b                        xmov x18, x11
+;       2c: 22 19 1b                        load64 x25, sp
+;       2f: 25 0b 1b 08                     load64_offset8 x11, sp, 8
+;       33: 25 0d 1b 10                     load64_offset8 x13, sp, 16
+;       37: 25 1f 1b 18                     load64_offset8 spilltmp1, sp, 24
+;       3b: 25 11 1b 20                     load64_offset8 x17, sp, 32
+;       3f: 13 1e 04                        xadd64 spilltmp0, x0, x1
+;       42: 13 5d 0c                        xadd64 fp, x2, x3
+;       45: 13 85 14                        xadd64 x5, x4, x5
+;       48: 13 c6 1c                        xadd64 x6, x6, x7
+;       4b: 13 07 25                        xadd64 x7, x8, x9
+;       4e: 0b 00 12                        xmov x0, x18
+;       51: 13 44 01                        xadd64 x4, x10, x0
+;       54: 0b 0a 10                        xmov x10, x16
+;       57: 13 88 29                        xadd64 x8, x12, x10
+;       5a: 13 ce 3d                        xadd64 x14, x14, x15
+;       5d: 13 2f 2f                        xadd64 x15, x25, x11
+;       60: 13 6d 35                        xadd64 x13, x11, x13
+;       63: 13 e0 47                        xadd64 x0, spilltmp1, x17
+;       66: 13 c1 77                        xadd64 x1, spilltmp0, fp
+;       69: 13 a2 18                        xadd64 x2, x5, x6
+;       6c: 13 e3 10                        xadd64 x3, x7, x4
+;       6f: 13 0e 39                        xadd64 x14, x8, x14
+;       72: 13 ed 35                        xadd64 x13, x15, x13
+;       75: 13 0f 00                        xadd64 x15, x0, x0
+;       78: 13 20 08                        xadd64 x0, x1, x2
+;       7b: 13 6e 38                        xadd64 x14, x3, x14
+;       7e: 13 ad 3d                        xadd64 x13, x13, x15
+;       81: 13 0e 38                        xadd64 x14, x0, x14
+;       84: 13 ad 35                        xadd64 x13, x13, x13
+;       87: 13 c0 35                        xadd64 x0, x14, x13
+;       8a: 25 10 1b 38                     load64_offset8 x16, sp, 56
+;       8e: 25 12 1b 30                     load64_offset8 x18, sp, 48
+;       92: 0e 1e 40                        xconst8 spilltmp0, 64
+;       95: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;       98: 25 1c 1b 08                     load64_offset8 lr, sp, 8
+;       9c: 22 1d 1b                        load64 fp, sp
+;       9f: 0e 1e 10                        xconst8 spilltmp0, 16
+;       a2: 12 7b 7b                        xadd32 sp, sp, spilltmp0
+;       a5: 00                              ret
+
diff --git a/cranelift/filetests/filetests/isa/pulley64/get_stack_pointer.clif b/cranelift/filetests/filetests/isa/pulley64/get_stack_pointer.clif
new file mode 100644
index 000000000000..f2520abaeef2
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/pulley64/get_stack_pointer.clif
@@ -0,0 +1,17 @@
+test compile precise-output
+target pulley64
+
+function %get_stack_pointer() -> i64 {
+block0:
+  v0 = get_stack_pointer.i64
+  return v0
+}
+
+; VCode:
+; block0:
+;   x0 = get_sp
+;   ret
+;
+; Disassembled:
+;        0: 3d 02 00 00                     get_sp x0
+;        4: 00                              ret
diff --git a/cranelift/filetests/filetests/isa/pulley64/iadd.clif b/cranelift/filetests/filetests/isa/pulley64/iadd.clif
new file mode 100644
index 000000000000..7a6cffde6e6d
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/pulley64/iadd.clif
@@ -0,0 +1,63 @@
+test compile precise-output
+target pulley64
+
+function %i8(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = iadd v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xadd32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 12 00 04                        xadd32 x0, x0, x1
+;        3: 00                              ret
+
+function %i16(i16, i16) -> i16 {
+block0(v0: i16, v1: i16):
+    v2 = iadd v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xadd32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 12 00 04                        xadd32 x0, x0, x1
+;        3: 00                              ret
+
+function %i32(i32, i32) -> i32 {
+block0(v0: i32, v1: i32):
+    v2 = iadd v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xadd32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 12 00 04                        xadd32 x0, x0, x1
+;        3: 00                              ret
+
+function %i64(i64, i64) -> i64 {
+block0(v0: i64, v1: i64):
+    v2 = iadd v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xadd64 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 13 00 04                        xadd64 x0, x0, x1
+;        3: 00                              ret
+
diff --git a/cranelift/filetests/filetests/isa/pulley64/icmp.clif b/cranelift/filetests/filetests/isa/pulley64/icmp.clif
new file mode 100644
index 000000000000..7aaf069f584e
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/pulley64/icmp.clif
@@ -0,0 +1,603 @@
+test compile precise-output
+target pulley64
+
+function %i8_eq(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = icmp eq v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xeq32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1a 00 04                        xeq32 x0, x0, x1
+;        3: 00                              ret
+
+function %i16_eq(i16, i16) -> i8 {
+block0(v0: i16, v1: i16):
+    v2 = icmp eq v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xeq32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1a 00 04                        xeq32 x0, x0, x1
+;        3: 00                              ret
+
+function %i32_eq(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp eq v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xeq32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1a 00 04                        xeq32 x0, x0, x1
+;        3: 00                              ret
+
+function %i64_eq(i64, i64) -> i8 {
+block0(v0: i64, v1: i64):
+    v2 = icmp eq v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xeq64 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 14 00 04                        xeq64 x0, x0, x1
+;        3: 00                              ret
+
+function %i8_ne(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = icmp ne v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xneq32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1b 00 04                        xneq32 x0, x0, x1
+;        3: 00                              ret
+
+function %i16_ne(i16, i16) -> i8 {
+block0(v0: i16, v1: i16):
+    v2 = icmp ne v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xneq32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1b 00 04                        xneq32 x0, x0, x1
+;        3: 00                              ret
+
+function %i32_ne(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp ne v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xneq32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1b 00 04                        xneq32 x0, x0, x1
+;        3: 00                              ret
+
+function %i64_ne(i64, i64) -> i8 {
+block0(v0: i64, v1: i64):
+    v2 = icmp ne v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xneq64 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 15 00 04                        xneq64 x0, x0, x1
+;        3: 00                              ret
+
+function %i8_ult(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = icmp ult v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xult32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1e 00 04                        xult32 x0, x0, x1
+;        3: 00                              ret
+
+function %i16_ult(i16, i16) -> i8 {
+block0(v0: i16, v1: i16):
+    v2 = icmp ult v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xult32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1e 00 04                        xult32 x0, x0, x1
+;        3: 00                              ret
+
+function %i32_ult(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp ult v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xult32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1e 00 04                        xult32 x0, x0, x1
+;        3: 00                              ret
+
+function %i64_ult(i64, i64) -> i8 {
+block0(v0: i64, v1: i64):
+    v2 = icmp ult v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xult64 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 18 00 04                        xult64 x0, x0, x1
+;        3: 00                              ret
+
+function %i8_ule(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = icmp ule v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xulteq32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1f 00 04                        xulteq32 x0, x0, x1
+;        3: 00                              ret
+
+function %i16_ule(i16, i16) -> i8 {
+block0(v0: i16, v1: i16):
+    v2 = icmp ule v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xulteq32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1f 00 04                        xulteq32 x0, x0, x1
+;        3: 00                              ret
+
+function %i32_ule(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp ule v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xulteq32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1f 00 04                        xulteq32 x0, x0, x1
+;        3: 00                              ret
+
+function %i64_ule(i64, i64) -> i8 {
+block0(v0: i64, v1: i64):
+    v2 = icmp ule v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xulteq64 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 19 00 04                        xulteq64 x0, x0, x1
+;        3: 00                              ret
+
+function %i8_slt(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = icmp slt v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslt32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1c 00 04                        xslt32 x0, x0, x1
+;        3: 00                              ret
+
+function %i16_slt(i16, i16) -> i8 {
+block0(v0: i16, v1: i16):
+    v2 = icmp slt v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslt32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1c 00 04                        xslt32 x0, x0, x1
+;        3: 00                              ret
+
+function %i32_slt(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp slt v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslt32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1c 00 04                        xslt32 x0, x0, x1
+;        3: 00                              ret
+
+function %i64_slt(i64, i64) -> i8 {
+block0(v0: i64, v1: i64):
+    v2 = icmp slt v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslt64 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 16 00 04                        xslt64 x0, x0, x1
+;        3: 00                              ret
+
+function %i8_sle(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = icmp sle v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslteq32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1d 00 04                        xslteq32 x0, x0, x1
+;        3: 00                              ret
+
+function %i16_sle(i16, i16) -> i8 {
+block0(v0: i16, v1: i16):
+    v2 = icmp sle v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslteq32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1d 00 04                        xslteq32 x0, x0, x1
+;        3: 00                              ret
+
+function %i32_sle(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp sle v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslteq32 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 1d 00 04                        xslteq32 x0, x0, x1
+;        3: 00                              ret
+
+function %i64_sle(i64, i64) -> i8 {
+block0(v0: i64, v1: i64):
+    v2 = icmp sle v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslteq64 x0, x1
+;   ret
+;
+; Disassembled:
+;        0: 17 00 04                        xslteq64 x0, x0, x1
+;        3: 00                              ret
+
+function %i8_ugt(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = icmp ugt v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xult32 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 1e 20 00                        xult32 x0, x1, x0
+;        3: 00                              ret
+
+function %i16_ugt(i16, i16) -> i8 {
+block0(v0: i16, v1: i16):
+    v2 = icmp ugt v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xult32 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 1e 20 00                        xult32 x0, x1, x0
+;        3: 00                              ret
+
+function %i32_ugt(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp ugt v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xult32 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 1e 20 00                        xult32 x0, x1, x0
+;        3: 00                              ret
+
+function %i64_ugt(i64, i64) -> i8 {
+block0(v0: i64, v1: i64):
+    v2 = icmp ugt v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xult64 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 18 20 00                        xult64 x0, x1, x0
+;        3: 00                              ret
+
+function %i8_sgt(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = icmp sgt v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslt32 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 1c 20 00                        xslt32 x0, x1, x0
+;        3: 00                              ret
+
+function %i16_sgt(i16, i16) -> i8 {
+block0(v0: i16, v1: i16):
+    v2 = icmp sgt v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslt32 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 1c 20 00                        xslt32 x0, x1, x0
+;        3: 00                              ret
+
+function %i32_sgt(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp sgt v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslt32 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 1c 20 00                        xslt32 x0, x1, x0
+;        3: 00                              ret
+
+function %i64_sgt(i64, i64) -> i8 {
+block0(v0: i64, v1: i64):
+    v2 = icmp sgt v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslt64 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 16 20 00                        xslt64 x0, x1, x0
+;        3: 00                              ret
+
+function %i8_uge(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = icmp uge v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xulteq32 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 1f 20 00                        xulteq32 x0, x1, x0
+;        3: 00                              ret
+
+function %i16_uge(i16, i16) -> i8 {
+block0(v0: i16, v1: i16):
+    v2 = icmp uge v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xulteq32 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 1f 20 00                        xulteq32 x0, x1, x0
+;        3: 00                              ret
+
+function %i32_uge(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp uge v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xulteq32 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 1f 20 00                        xulteq32 x0, x1, x0
+;        3: 00                              ret
+
+function %i64_uge(i64, i64) -> i8 {
+block0(v0: i64, v1: i64):
+    v2 = icmp uge v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xulteq64 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 19 20 00                        xulteq64 x0, x1, x0
+;        3: 00                              ret
+
+function %i8_sge(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = icmp sge v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslteq32 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 1d 20 00                        xslteq32 x0, x1, x0
+;        3: 00                              ret
+
+function %i16_sge(i16, i16) -> i8 {
+block0(v0: i16, v1: i16):
+    v2 = icmp sge v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslteq32 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 1d 20 00                        xslteq32 x0, x1, x0
+;        3: 00                              ret
+
+function %i32_sge(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+    v2 = icmp sge v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslteq32 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 1d 20 00                        xslteq32 x0, x1, x0
+;        3: 00                              ret
+
+function %i64_sge(i64, i64) -> i8 {
+block0(v0: i64, v1: i64):
+    v2 = icmp sge v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   x0 = xslteq64 x1, x0
+;   ret
+;
+; Disassembled:
+;        0: 17 20 00                        xslteq64 x0, x1, x0
+;        3: 00                              ret
+
diff --git a/cranelift/filetests/filetests/isa/pulley64/iconst.clif b/cranelift/filetests/filetests/isa/pulley64/iconst.clif
new file mode 100644
index 000000000000..36ae9b0095f4
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/pulley64/iconst.clif
@@ -0,0 +1,63 @@
+test compile precise-output
+target pulley64
+
+function %i8() -> i8 {
+block0:
+    v0 = iconst.i8 0xff
+    return v0
+}
+
+; VCode:
+; block0:
+;   x0 = xconst16 255
+;   ret
+;
+; Disassembled:
+;        0: 0f 00 ff 00                     xconst16 x0, 255
+;        4: 00                              ret
+
+function %i16() -> i16 {
+block0:
+    v0 = iconst.i16 0xffff
+    return v0
+}
+
+; VCode:
+; block0:
+;   x0 = xconst32 65535
+;   ret
+;
+; Disassembled:
+;        0: 10 00 ff ff 00 00               xconst32 x0, 65535
+;        6: 00                              ret
+
+function %i32() -> i32 {
+block0:
+    v0 = iconst.i32 0xffff_ffff
+    return v0
+}
+
+; VCode:
+; block0:
+;   x0 = xconst32 -1
+;   ret
+;
+; Disassembled:
+;        0: 10 00 ff ff ff ff               xconst32 x0, -1
+;        6: 00                              ret
+
+function %i64() -> i64 {
+block0:
+    v0 = iconst.i64 0xffff_ffff_ffff_ffff
+    return v0
+}
+
+; VCode:
+; block0:
+;   x0 = xconst64 -1
+;   ret
+;
+; Disassembled:
+;        0: 11 00 ff ff ff ff ff ff ff ff   xconst64 x0, -1
+;        a: 00                              ret
+
diff --git a/cranelift/filetests/filetests/isa/pulley64/jump.clif b/cranelift/filetests/filetests/isa/pulley64/jump.clif
new file mode 100644
index 000000000000..011984697dcf
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/pulley64/jump.clif
@@ -0,0 +1,38 @@
+test compile precise-output
+target pulley64
+
+function %jump(i8) -> i8 {
+block0(v0: i8):
+  brif v0, block1, block2
+
+block1:
+  v1 = iconst.i8 1
+  jump block3(v1)
+
+block2:
+  v2 = iconst.i8 0
+  jump block3(v2)
+
+block3(v3: i8):
+  return v3
+}
+
+; VCode:
+; block0:
+;   br_if x0, label2; jump label1
+; block1:
+;   x0 = xconst8 0
+;   jump label3
+; block2:
+;   x0 = xconst8 1
+;   jump label3
+; block3:
+;   ret
+;
+; Disassembled:
+;        0: 03 00 0e 00 00 00               br_if x0, 0xe    // target = 0xe
+;        6: 0e 00 00                        xconst8 x0, 0
+;        9: 02 08 00 00 00                  jump 0x8    // target = 0x11
+;        e: 0e 00 01                        xconst8 x0, 1
+;       11: 00                              ret
+
diff --git a/cranelift/filetests/filetests/isa/pulley64/load.clif b/cranelift/filetests/filetests/isa/pulley64/load.clif
new file mode 100644
index 000000000000..a692da083b5b
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/pulley64/load.clif
@@ -0,0 +1,62 @@
+test compile precise-output
+target pulley64
+
+function %load_i32(i64) -> i32 {
+block0(v0: i64):
+    v1 = load.i32 v0
+    return v1
+}
+
+; VCode:
+; block0:
+;   x0 = load32_u x0+0 // flags =
+;   ret
+;
+; Disassembled:
+;        0: 20 00 00                        load32_u x0, x0
+;        3: 00                              ret
+
+function %load_i64(i64) -> i64 {
+block0(v0: i64):
+    v1 = load.i64 v0
+    return v1
+}
+
+; VCode:
+; block0:
+;   x0 = load64_u x0+0 // flags =
+;   ret
+;
+; Disassembled:
+;        0: 22 00 00                        load64 x0, x0
+;        3: 00                              ret
+
+function %load_i32_with_offset(i64) -> i32 {
+block0(v0: i64):
+    v1 = load.i32 v0+4
+    return v1
+}
+
+; VCode:
+; block0:
+;   x0 = load32_u x0+4 // flags =
+;   ret
+;
+; Disassembled:
+;        0: 23 00 00 04                     load32_u_offset8 x0, x0, 4
+;        4: 00                              ret
+
+function %load_i64_with_offset(i64) -> i64 {
+block0(v0: i64):
+    v1 = load.i64 v0+8
+    return v1
+}
+
+; VCode:
+; block0:
+;   x0 = load64_u x0+8 // flags =
+;   ret
+;
+; Disassembled:
+;        0: 25 00 00 08                     load64_offset8 x0, x0, 8
+;        4: 00                              ret
diff --git a/cranelift/filetests/filetests/isa/pulley64/store.clif b/cranelift/filetests/filetests/isa/pulley64/store.clif
new file mode 100644
index 000000000000..bec7e1a77344
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/pulley64/store.clif
@@ -0,0 +1,63 @@
+test compile precise-output
+target pulley64
+
+function %store_i32(i32, i64) {
+block0(v0: i32, v1: i64):
+    store v0, v1
+    return
+}
+
+; VCode:
+; block0:
+;   store32 x1+0, x0 // flags = 
+;   ret
+;
+; Disassembled:
+;        0: 29 01 00                        store32 x1, x0
+;        3: 00                              ret
+
+function %store_i64(i64, i64) {
+block0(v0: i64, v1: i64):
+    store v0, v1
+    return
+}
+
+; VCode:
+; block0:
+;   store64 x1+0, x0 // flags = 
+;   ret
+;
+; Disassembled:
+;        0: 2a 01 00                        store64 x1, x0
+;        3: 00                              ret
+
+function %store_i32_with_offset(i32, i64) {
+block0(v0: i32, v1: i64):
+    store v0, v1+4
+    return
+}
+
+; VCode:
+; block0:
+;   store32 x1+4, x0 // flags = 
+;   ret
+;
+; Disassembled:
+;        0: 2b 01 04 00                     store32_offset8 x1, 4, x0
+;        4: 00                              ret
+
+function %store_i64_with_offset(i64, i64) {
+block0(v0: i64, v1: i64):
+    store v0, v1+8
+    return
+}
+
+; VCode:
+; block0:
+;   store64 x1+8, x0 // flags = 
+;   ret
+;
+; Disassembled:
+;        0: 2c 01 08 00                     store64_offset8 x1, 8, x0
+;        4: 00                              ret
+
diff --git a/cranelift/filetests/filetests/isa/pulley64/trap.clif b/cranelift/filetests/filetests/isa/pulley64/trap.clif
new file mode 100644
index 000000000000..7615f2a74685
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/pulley64/trap.clif
@@ -0,0 +1,64 @@
+test compile precise-output
+target pulley64
+
+function %trap() {
+block0:
+  trap user0
+}
+
+; VCode:
+; block0:
+;   trap // code = User(0)
+;
+; Disassembled:
+;        0: 3d 00 00                        trap
+
+function %trapnz(i64) {
+block0(v0: i64):
+  v1 = iconst.i64 42
+  v2 = icmp eq v0, v1
+  trapnz v2, user0
+  return
+}
+
+; VCode:
+; block0:
+;   x3 = xconst8 42
+;   x3 = xeq64 x0, x3
+;   br_if x3, label2; jump label1
+; block1:
+;   ret
+; block2:
+;   trap // code = User(0)
+;
+; Disassembled:
+;        0: 0e 03 2a                        xconst8 x3, 42
+;        3: 14 03 0c                        xeq64 x3, x0, x3
+;        6: 03 03 07 00 00 00               br_if x3, 0x7    // target = 0xd
+;        c: 00                              ret
+;        d: 3d 00 00                        trap
+
+function %trapz(i64) {
+block0(v0: i64):
+  v1 = iconst.i64 42
+  v2 = icmp eq v0, v1
+  trapz v2, user0
+  return
+}
+
+; VCode:
+; block0:
+;   x3 = xconst8 42
+;   x3 = xeq64 x0, x3
+;   br_if x3, label2; jump label1
+; block2:
+;   ret
+; block1:
+;   trap // code = User(0)
+;
+; Disassembled:
+;        0: 0e 03 2a                        xconst8 x3, 42
+;        3: 14 03 0c                        xeq64 x3, x0, x3
+;        6: 04 03 07 00 00 00               br_if_not x3, 0x7    // target = 0xd
+;        c: 00                              ret
+;        d: 3d 00 00                        trap
diff --git a/cranelift/filetests/filetests/isa/riscv64/amodes-fp.clif b/cranelift/filetests/filetests/isa/riscv64/amodes-fp.clif
index 6d138aaccc6c..f9788870590f 100644
--- a/cranelift/filetests/filetests/isa/riscv64/amodes-fp.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/amodes-fp.clif
@@ -11,7 +11,7 @@ block0:
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
@@ -19,7 +19,7 @@ block0:
 ;   ld a0,24(fp)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -29,7 +29,7 @@ block0:
 ;   sd s0, 0(sp)
 ;   mv s0, sp
 ; block1: ; offset 0x10
-;   ld a0, 0x18(s0)
+;   ld a0, 0x18(s0) ; trap: heap_oob
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
diff --git a/cranelift/filetests/filetests/isa/riscv64/amodes.clif b/cranelift/filetests/filetests/isa/riscv64/amodes.clif
index 0c6743ac0cb0..678b86f30200 100644
--- a/cranelift/filetests/filetests/isa/riscv64/amodes.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/amodes.clif
@@ -21,7 +21,7 @@ block0(v0: i64, v1: i32):
 ; block0: ; offset 0x0
 ;   sext.w a5, a1
 ;   add a5, a0, a5
-;   lw a0, 0(a5)
+;   lw a0, 0(a5) ; trap: heap_oob
 ;   ret
 
 function %f6(i64, i32) -> i32 {
@@ -43,7 +43,7 @@ block0(v0: i64, v1: i32):
 ; block0: ; offset 0x0
 ;   sext.w a5, a1
 ;   add a5, a5, a0
-;   lw a0, 0(a5)
+;   lw a0, 0(a5) ; trap: heap_oob
 ;   ret
 
 function %f7(i32, i32) -> i32 {
@@ -72,7 +72,7 @@ block0(v0: i32, v1: i32):
 ;   slli a1, a1, 0x20
 ;   srli a4, a1, 0x20
 ;   add a2, a3, a4
-;   lw a0, 0(a2)
+;   lw a0, 0(a2) ; trap: heap_oob
 ;   ret
 
 function %f8(i64, i32) -> i32 {
@@ -101,7 +101,7 @@ block0(v0: i64, v1: i32):
 ;   addi a1, a1, 0x20
 ;   add a1, a1, a0
 ;   add a1, a1, a1
-;   lw a0, 4(a1)
+;   lw a0, 4(a1) ; trap: heap_oob
 ;   ret
 
 function %f9(i64, i64, i64) -> i32 {
@@ -125,7 +125,7 @@ block0(v0: i64, v1: i64, v2: i64):
 ; block0: ; offset 0x0
 ;   add a0, a0, a1
 ;   add a0, a0, a2
-;   lw a0, 0x30(a0)
+;   lw a0, 0x30(a0) ; trap: heap_oob
 ;   ret
 
 function %f10(i64, i64, i64) -> i32 {
@@ -152,7 +152,7 @@ block0(v0: i64, v1: i64, v2: i64):
 ;   lui t6, 1
 ;   addi t6, t6, 4
 ;   add t6, t6, a0
-;   lw a0, 0(t6)
+;   lw a0, 0(t6) ; trap: heap_oob
 ;   ret
 
 function %f10() -> i32 {
@@ -171,7 +171,7 @@ block0:
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   addi a1, zero, 0x4d2
-;   lw a0, 0(a1)
+;   lw a0, 0(a1) ; trap: heap_oob
 ;   ret
 
 function %f11(i64) -> i32 {
@@ -191,7 +191,7 @@ block0(v0: i64):
 ; block0: ; offset 0x0
 ;   lui t6, 0x800
 ;   add t6, t6, a0
-;   lw a0, 0(t6)
+;   lw a0, 0(t6) ; trap: heap_oob
 ;   ret
 
 function %f12(i64) -> i32 {
@@ -209,7 +209,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lw a0, -4(a0)
+;   lw a0, -4(a0) ; trap: heap_oob
 ;   ret
 
 function %f13(i64) -> i32 {
@@ -230,7 +230,7 @@ block0(v0: i64):
 ;   lui t6, 0x3b9ad
 ;   addi t6, t6, -0x600
 ;   add t6, t6, a0
-;   lw a0, 0(t6)
+;   lw a0, 0(t6) ; trap: heap_oob
 ;   ret
 
 function %f14(i32) -> i32 {
@@ -249,7 +249,7 @@ block0(v0: i32):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   sext.w a3, a0
-;   lw a0, 0(a3)
+;   lw a0, 0(a3) ; trap: heap_oob
 ;   ret
 
 function %f15(i32, i32) -> i32 {
@@ -274,7 +274,7 @@ block0(v0: i32, v1: i32):
 ;   sext.w a0, a0
 ;   sext.w a1, a1
 ;   add a0, a0, a1
-;   lw a0, 0(a0)
+;   lw a0, 0(a0) ; trap: heap_oob
 ;   ret
 
 function %f18(i64, i64, i64) -> i32 {
@@ -287,20 +287,20 @@ block0(v0: i64, v1: i64, v2: i64):
 
 ; VCode:
 ; block0:
-;   lui a1,-1
-;   addi a3,a1,-2
-;   slli a1,a3,32
-;   srli a3,a1,32
-;   lh a0,0(a3)
+;   lui a3,-1
+;   addi a5,a3,-2
+;   slli a3,a5,32
+;   srli a5,a3,32
+;   lh a0,0(a5)
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lui a1, 0xfffff
-;   addi a3, a1, -2
-;   slli a1, a3, 0x20
-;   srli a3, a1, 0x20
-;   lh a0, 0(a3)
+;   lui a3, 0xfffff
+;   addi a5, a3, -2
+;   slli a3, a5, 0x20
+;   srli a5, a3, 0x20
+;   lh a0, 0(a5) ; trap: heap_oob
 ;   ret
 
 function %f19(i64, i64, i64) -> i32 {
@@ -313,20 +313,20 @@ block0(v0: i64, v1: i64, v2: i64):
 
 ; VCode:
 ; block0:
-;   lui a1,1
-;   addi a3,a1,2
-;   slli a1,a3,32
-;   srli a3,a1,32
-;   lh a0,0(a3)
+;   lui a3,1
+;   addi a5,a3,2
+;   slli a3,a5,32
+;   srli a5,a3,32
+;   lh a0,0(a5)
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lui a1, 1
-;   addi a3, a1, 2
-;   slli a1, a3, 0x20
-;   srli a3, a1, 0x20
-;   lh a0, 0(a3)
+;   lui a3, 1
+;   addi a5, a3, 2
+;   slli a3, a5, 0x20
+;   srli a5, a3, 0x20
+;   lh a0, 0(a5) ; trap: heap_oob
 ;   ret
 
 function %f20(i64, i64, i64) -> i32 {
@@ -339,18 +339,18 @@ block0(v0: i64, v1: i64, v2: i64):
 
 ; VCode:
 ; block0:
-;   lui a0,-1
-;   addi a2,a0,-2
-;   sext.w a1,a2
-;   lh a0,0(a1)
+;   lui a2,-1
+;   addi a4,a2,-2
+;   sext.w a3,a4
+;   lh a0,0(a3)
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lui a0, 0xfffff
-;   addi a2, a0, -2
-;   sext.w a1, a2
-;   lh a0, 0(a1)
+;   lui a2, 0xfffff
+;   addi a4, a2, -2
+;   sext.w a3, a4
+;   lh a0, 0(a3) ; trap: heap_oob
 ;   ret
 
 function %f21(i64, i64, i64) -> i32 {
@@ -363,18 +363,18 @@ block0(v0: i64, v1: i64, v2: i64):
 
 ; VCode:
 ; block0:
-;   lui a0,1
-;   addi a2,a0,2
-;   sext.w a1,a2
-;   lh a0,0(a1)
+;   lui a2,1
+;   addi a4,a2,2
+;   sext.w a3,a4
+;   lh a0,0(a3)
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lui a0, 1
-;   addi a2, a0, 2
-;   sext.w a1, a2
-;   lh a0, 0(a1)
+;   lui a2, 1
+;   addi a4, a2, 2
+;   sext.w a3, a4
+;   lh a0, 0(a3) ; trap: heap_oob
 ;   ret
 
 function %i128(i64) -> i128 {
@@ -387,21 +387,19 @@ block0(v0: i64):
 ; VCode:
 ; block0:
 ;   ld a2,0(a0)
-;   mv a4,a2
 ;   ld a1,8(a0)
 ;   sd a2,0(a0)
 ;   sd a1,8(a0)
-;   mv a0,a4
+;   mv a0,a2
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld a2, 0(a0)
-;   mv a4, a2
-;   ld a1, 8(a0)
-;   sd a2, 0(a0)
-;   sd a1, 8(a0)
-;   mv a0, a4
+;   ld a2, 0(a0) ; trap: heap_oob
+;   ld a1, 8(a0) ; trap: heap_oob
+;   sd a2, 0(a0) ; trap: heap_oob
+;   sd a1, 8(a0) ; trap: heap_oob
+;   mv a0, a2
 ;   ret
 
 function %i128_imm_offset(i64) -> i128 {
@@ -414,21 +412,19 @@ block0(v0: i64):
 ; VCode:
 ; block0:
 ;   ld a2,16(a0)
-;   mv a4,a2
 ;   ld a1,24(a0)
 ;   sd a2,16(a0)
 ;   sd a1,24(a0)
-;   mv a0,a4
+;   mv a0,a2
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld a2, 0x10(a0)
-;   mv a4, a2
-;   ld a1, 0x18(a0)
-;   sd a2, 0x10(a0)
-;   sd a1, 0x18(a0)
-;   mv a0, a4
+;   ld a2, 0x10(a0) ; trap: heap_oob
+;   ld a1, 0x18(a0) ; trap: heap_oob
+;   sd a2, 0x10(a0) ; trap: heap_oob
+;   sd a1, 0x18(a0) ; trap: heap_oob
+;   mv a0, a2
 ;   ret
 
 function %i128_imm_offset_large(i64) -> i128 {
@@ -441,21 +437,19 @@ block0(v0: i64):
 ; VCode:
 ; block0:
 ;   ld a2,504(a0)
-;   mv a4,a2
 ;   ld a1,512(a0)
 ;   sd a2,504(a0)
 ;   sd a1,512(a0)
-;   mv a0,a4
+;   mv a0,a2
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld a2, 0x1f8(a0)
-;   mv a4, a2
-;   ld a1, 0x200(a0)
-;   sd a2, 0x1f8(a0)
-;   sd a1, 0x200(a0)
-;   mv a0, a4
+;   ld a2, 0x1f8(a0) ; trap: heap_oob
+;   ld a1, 0x200(a0) ; trap: heap_oob
+;   sd a2, 0x1f8(a0) ; trap: heap_oob
+;   sd a1, 0x200(a0) ; trap: heap_oob
+;   mv a0, a2
 ;   ret
 
 function %i128_imm_offset_negative_large(i64) -> i128 {
@@ -468,21 +462,19 @@ block0(v0: i64):
 ; VCode:
 ; block0:
 ;   ld a2,-512(a0)
-;   mv a4,a2
 ;   ld a1,-504(a0)
 ;   sd a2,-512(a0)
 ;   sd a1,-504(a0)
-;   mv a0,a4
+;   mv a0,a2
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld a2, -0x200(a0)
-;   mv a4, a2
-;   ld a1, -0x1f8(a0)
-;   sd a2, -0x200(a0)
-;   sd a1, -0x1f8(a0)
-;   mv a0, a4
+;   ld a2, -0x200(a0) ; trap: heap_oob
+;   ld a1, -0x1f8(a0) ; trap: heap_oob
+;   sd a2, -0x200(a0) ; trap: heap_oob
+;   sd a1, -0x1f8(a0) ; trap: heap_oob
+;   mv a0, a2
 ;   ret
 
 function %i128_add_offset(i64) -> i128 {
@@ -496,21 +488,19 @@ block0(v0: i64):
 ; VCode:
 ; block0:
 ;   ld a2,32(a0)
-;   mv a4,a2
 ;   ld a1,40(a0)
 ;   sd a2,32(a0)
 ;   sd a1,40(a0)
-;   mv a0,a4
+;   mv a0,a2
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld a2, 0x20(a0)
-;   mv a4, a2
-;   ld a1, 0x28(a0)
-;   sd a2, 0x20(a0)
-;   sd a1, 0x28(a0)
-;   mv a0, a4
+;   ld a2, 0x20(a0) ; trap: heap_oob
+;   ld a1, 0x28(a0) ; trap: heap_oob
+;   sd a2, 0x20(a0) ; trap: heap_oob
+;   sd a1, 0x28(a0) ; trap: heap_oob
+;   mv a0, a2
 ;   ret
 
 function %i128_32bit_sextend_simple(i32) -> i128 {
@@ -533,10 +523,10 @@ block0(v0: i32):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   sext.w a4, a0
-;   ld a0, 0(a4)
-;   ld a1, 8(a4)
-;   sd a0, 0(a4)
-;   sd a1, 8(a4)
+;   ld a0, 0(a4) ; trap: heap_oob
+;   ld a1, 8(a4) ; trap: heap_oob
+;   sd a0, 0(a4) ; trap: heap_oob
+;   sd a1, 8(a4) ; trap: heap_oob
 ;   ret
 
 function %i128_32bit_sextend(i64, i32) -> i128 {
@@ -554,23 +544,21 @@ block0(v0: i64, v1: i32):
 ;   sext.w a1,a1
 ;   add a0,a0,a1
 ;   ld a5,24(a0)
-;   mv a2,a5
 ;   ld a1,32(a0)
 ;   sd a5,24(a0)
 ;   sd a1,32(a0)
-;   mv a0,a2
+;   mv a0,a5
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   sext.w a1, a1
 ;   add a0, a0, a1
-;   ld a5, 0x18(a0)
-;   mv a2, a5
-;   ld a1, 0x20(a0)
-;   sd a5, 0x18(a0)
-;   sd a1, 0x20(a0)
-;   mv a0, a2
+;   ld a5, 0x18(a0) ; trap: heap_oob
+;   ld a1, 0x20(a0) ; trap: heap_oob
+;   sd a5, 0x18(a0) ; trap: heap_oob
+;   sd a1, 0x20(a0) ; trap: heap_oob
+;   mv a0, a5
 ;   ret
 
 function %load_from_get_stack_pointer() -> i64 {
@@ -587,6 +575,6 @@ block0:
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld a0, 8(sp)
+;   ld a0, 8(sp) ; trap: heap_oob
 ;   ret
 
diff --git a/cranelift/filetests/filetests/isa/riscv64/arithmetic.clif b/cranelift/filetests/filetests/isa/riscv64/arithmetic.clif
index a34749817fd3..775137e8fb30 100644
--- a/cranelift/filetests/filetests/isa/riscv64/arithmetic.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/arithmetic.clif
@@ -512,14 +512,12 @@ block0(v0: i32):
 
 ; VCode:
 ; block0:
-;   li a3,-1
-;   subw a0,a0,a3
+;   addiw a0,a0,1
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a3, zero, -1
-;   subw a0, a0, a3
+;   addiw a0, a0, 1
 ;   ret
 
 function %f28(i64) -> i64 {
@@ -531,14 +529,12 @@ block0(v0: i64):
 
 ; VCode:
 ; block0:
-;   li a3,-1
-;   sub a0,a0,a3
+;   addi a0,a0,1
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a3, zero, -1
-;   sub a0, a0, a3
+;   addi a0, a0, 1
 ;   ret
 
 function %f29(i64) -> i64 {
@@ -550,14 +546,14 @@ block0(v0: i64):
 
 ; VCode:
 ; block0:
-;   li a3,1
-;   sub a0,zero,a3
+;   li a1,1
+;   sub a0,zero,a1
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a3, zero, 1
-;   neg a0, a3
+;   addi a1, zero, 1
+;   neg a0, a1
 ;   ret
 
 function %add_i128(i128, i128) -> i128 {
@@ -591,21 +587,19 @@ block0(v0: i128, v1: i128):
 ; VCode:
 ; block0:
 ;   sub a5,a0,a2
-;   mv a4,a5
-;   sltu a2,a0,a4
-;   mv a0,a4
+;   sltu a2,a0,a5
 ;   sub a3,a1,a3
 ;   sub a1,a3,a2
+;   mv a0,a5
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   sub a5, a0, a2
-;   mv a4, a5
-;   sltu a2, a0, a4
-;   mv a0, a4
+;   sltu a2, a0, a5
 ;   sub a3, a1, a3
 ;   sub a1, a3, a2
+;   mv a0, a5
 ;   ret
 
 function %add_mul_2(i32, i32, i32) -> i32 {
@@ -618,13 +612,13 @@ block0(v0: i32, v1: i32, v2: i32):
 ; VCode:
 ; block0:
 ;   mulw a5,a1,a2
-;   add a0,a5,a0
+;   addw a0,a5,a0
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   mulw a5, a1, a2
-;   add a0, a5, a0
+;   addw a0, a5, a0
 ;   ret
 
 function %msub_i32(i32, i32, i32) -> i32 {
diff --git a/cranelift/filetests/filetests/isa/riscv64/atomic-rmw.clif b/cranelift/filetests/filetests/isa/riscv64/atomic-rmw.clif
index 6de5418b1d65..59053bd2cc8f 100644
--- a/cranelift/filetests/filetests/isa/riscv64/atomic-rmw.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/atomic-rmw.clif
@@ -15,7 +15,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   amoadd.d.aqrl a3, a1, (a0)
+;   amoadd.d.aqrl a3, a1, (a0) ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_add_i32(i64, i32) {
@@ -31,7 +31,7 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   amoadd.w.aqrl a3, a1, (a0)
+;   amoadd.w.aqrl a3, a1, (a0) ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_sub_i64(i64, i64) {
@@ -49,7 +49,7 @@ block0(v0: i64, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   neg a3, a1
-;   amoadd.d.aqrl a5, a3, (a0)
+;   amoadd.d.aqrl a5, a3, (a0) ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_sub_i32(i64, i32) {
@@ -67,7 +67,7 @@ block0(v0: i64, v1: i32):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   neg a3, a1
-;   amoadd.w.aqrl a5, a3, (a0)
+;   amoadd.w.aqrl a5, a3, (a0) ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_and_i64(i64, i64) {
@@ -83,7 +83,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   amoand.d.aqrl a3, a1, (a0)
+;   amoand.d.aqrl a3, a1, (a0) ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_and_i32(i64, i32) {
@@ -99,7 +99,7 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   amoand.w.aqrl a3, a1, (a0)
+;   amoand.w.aqrl a3, a1, (a0) ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_nand_i64(i64, i64) {
@@ -115,10 +115,10 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lr.d.aqrl a3, (a0)
+;   lr.d.aqrl a3, (a0) ; trap: heap_oob
 ;   and a4, a1, a3
 ;   not a4, a4
-;   sc.d.aqrl a4, a4, (a0)
+;   sc.d.aqrl a4, a4, (a0) ; trap: heap_oob
 ;   bnez a4, -0x10
 ;   ret
 
@@ -135,10 +135,10 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lr.w.aqrl a3, (a0)
+;   lr.w.aqrl a3, (a0) ; trap: heap_oob
 ;   and a4, a1, a3
 ;   not a4, a4
-;   sc.w.aqrl a4, a4, (a0)
+;   sc.w.aqrl a4, a4, (a0) ; trap: heap_oob
 ;   bnez a4, -0x10
 ;   ret
 
@@ -155,7 +155,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   amoor.d.aqrl a3, a1, (a0)
+;   amoor.d.aqrl a3, a1, (a0) ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_or_i32(i64, i32) {
@@ -171,7 +171,7 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   amoor.w.aqrl a3, a1, (a0)
+;   amoor.w.aqrl a3, a1, (a0) ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_xor_i64(i64, i64) {
@@ -187,7 +187,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   amoxor.d.aqrl a3, a1, (a0)
+;   amoxor.d.aqrl a3, a1, (a0) ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_xor_i32(i64, i32) {
@@ -203,7 +203,7 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   amoxor.w.aqrl a3, a1, (a0)
+;   amoxor.w.aqrl a3, a1, (a0) ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_smax_i64(i64, i64) {
@@ -219,7 +219,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   amomax.d.aqrl a3, a1, (a0)
+;   amomax.d.aqrl a3, a1, (a0) ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_smax_i32(i64, i32) {
@@ -235,7 +235,7 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   amomax.w.aqrl a3, a1, (a0)
+;   amomax.w.aqrl a3, a1, (a0) ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_umax_i64(i64, i64) {
@@ -251,7 +251,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   amomaxu.d.aqrl a3, a1, (a0)
+;   amomaxu.d.aqrl a3, a1, (a0) ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_umax_i32(i64, i32) {
@@ -267,7 +267,7 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   amomaxu.w.aqrl a3, a1, (a0)
+;   amomaxu.w.aqrl a3, a1, (a0) ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_smin_i64(i64, i64) {
@@ -283,7 +283,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   amomin.d.aqrl a3, a1, (a0)
+;   amomin.d.aqrl a3, a1, (a0) ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_smin_i32(i64, i32) {
@@ -299,7 +299,7 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   amomin.w.aqrl a3, a1, (a0)
+;   amomin.w.aqrl a3, a1, (a0) ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_umin_i64(i64, i64) {
@@ -315,7 +315,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   amominu.d.aqrl a3, a1, (a0)
+;   amominu.d.aqrl a3, a1, (a0) ; trap: heap_oob
 ;   ret
 
 function %atomic_rmw_umin_i32(i64, i32) {
@@ -331,6 +331,6 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   amominu.w.aqrl a3, a1, (a0)
+;   amominu.w.aqrl a3, a1, (a0) ; trap: heap_oob
 ;   ret
 
diff --git a/cranelift/filetests/filetests/isa/riscv64/atomic_load.clif b/cranelift/filetests/filetests/isa/riscv64/atomic_load.clif
index f6b827598aa5..a81104594652 100644
--- a/cranelift/filetests/filetests/isa/riscv64/atomic_load.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/atomic_load.clif
@@ -16,7 +16,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   fence rw, rw
-;   ld a0, 0(a0)
+;   ld a0, 0(a0) ; trap: heap_oob
 ;   fence r, rw
 ;   ret
 
@@ -34,7 +34,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   fence rw, rw
-;   lw a0, 0(a0)
+;   lw a0, 0(a0) ; trap: heap_oob
 ;   fence r, rw
 ;   ret
 
@@ -55,7 +55,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   fence rw, rw
-;   lw a4, 0(a0)
+;   lw a4, 0(a0) ; trap: heap_oob
 ;   fence r, rw
 ;   slli a3, a4, 0x20
 ;   srli a0, a3, 0x20
diff --git a/cranelift/filetests/filetests/isa/riscv64/atomic_store.clif b/cranelift/filetests/filetests/isa/riscv64/atomic_store.clif
index 90925a57c081..f3024e07270e 100644
--- a/cranelift/filetests/filetests/isa/riscv64/atomic_store.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/atomic_store.clif
@@ -16,7 +16,7 @@ block0(v0: i64, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   fence rw, w
-;   sd a0, 0(a1)
+;   sd a0, 0(a1) ; trap: heap_oob
 ;   ret
 
 function %atomic_store_i64_sym(i64) {
@@ -41,7 +41,7 @@ block0(v0: i64):
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %sym 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
 ;   fence rw, w
-;   sd a0, 0(a2)
+;   sd a0, 0(a2) ; trap: heap_oob
 ;   ret
 
 function %atomic_store_imm_i64(i64) {
@@ -63,7 +63,7 @@ block0(v0: i64):
 ;   lui a2, 3
 ;   addi a4, a2, 0x39
 ;   fence rw, w
-;   sd a4, 0(a0)
+;   sd a4, 0(a0) ; trap: heap_oob
 ;   ret
 
 function %atomic_store_i32(i32, i64) {
@@ -80,7 +80,7 @@ block0(v0: i32, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   fence rw, w
-;   sw a0, 0(a1)
+;   sw a0, 0(a1) ; trap: heap_oob
 ;   ret
 
 function %atomic_store_i32_sym(i32) {
@@ -105,7 +105,7 @@ block0(v0: i32):
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %sym 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
 ;   fence rw, w
-;   sw a0, 0(a2)
+;   sw a0, 0(a2) ; trap: heap_oob
 ;   ret
 
 function %atomic_store_imm_i32(i64) {
@@ -127,6 +127,6 @@ block0(v0: i64):
 ;   lui a2, 3
 ;   addi a4, a2, 0x39
 ;   fence rw, w
-;   sw a4, 0(a0)
+;   sw a4, 0(a0) ; trap: heap_oob
 ;   ret
 
diff --git a/cranelift/filetests/filetests/isa/riscv64/bitcast-scalar-vector.clif b/cranelift/filetests/filetests/isa/riscv64/bitcast-scalar-vector.clif
new file mode 100644
index 000000000000..5658fbe5a618
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/bitcast-scalar-vector.clif
@@ -0,0 +1,236 @@
+test compile precise-output
+set unwind_info=false
+target riscv64 has_v
+
+function %bitcast_vec_to_i128(i64x2) -> i128 {
+block0(v0: i64x2):
+    v1 = bitcast.i128 little v0
+    return v1
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+; block0:
+;   vle8.v v8,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vmv.x.s a0,v8 #avl=2, #vtype=(e64, m1, ta, ma)
+;   vslidedown.vi v12,v8,1 #avl=2, #vtype=(e64, m1, ta, ma)
+;   vmv.x.s a1,v12 #avl=2, #vtype=(e64, m1, ta, ma)
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+; block1: ; offset 0x10
+;   .byte 0x57, 0x70, 0x08, 0xcc
+;   addi t6, sp, 0x10
+;   .byte 0x07, 0x84, 0x0f, 0x02
+;   .byte 0x57, 0x70, 0x81, 0xcd
+;   .byte 0x57, 0x25, 0x80, 0x42
+;   .byte 0x57, 0xb6, 0x80, 0x3e
+;   .byte 0xd7, 0x25, 0xc0, 0x42
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   ret
+
+function %bitcast_i128_to_vec(i128) -> i64x2 {
+block0(v0: i128):
+    v1 = bitcast.i64x2 little v0
+    return v1
+}
+
+; VCode:
+; block0:
+;   vmv.s.x v12,a1 #avl=2, #vtype=(e64, m1, ta, ma)
+;   vmv1r.v v14,v12
+;   vslide1up.vx v14,v12,a0 #avl=2, #vtype=(e64, m1, ta, ma)
+;   vse8.v v14,0(a2) #avl=16, #vtype=(e8, m1, ta, ma)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x57, 0x70, 0x81, 0xcd
+;   .byte 0x57, 0xe6, 0x05, 0x42
+;   .byte 0x57, 0x37, 0xc0, 0x9e
+;   .byte 0x57, 0x67, 0xc5, 0x3a
+;   .byte 0x57, 0x70, 0x08, 0xcc
+;   .byte 0x27, 0x07, 0x06, 0x02
+;   ret
+
+function %bitcast_vec_to_i64(i32x2) -> i64 {
+block0(v0: i32x2):
+    v1 = bitcast.i64 little v0
+    return v1
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+; block0:
+;   vle8.v v8,-16(incoming_arg) #avl=8, #vtype=(e8, m1, ta, ma)
+;   vmv.x.s a0,v8 #avl=1, #vtype=(e64, m1, ta, ma)
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+; block1: ; offset 0x10
+;   .byte 0x57, 0x70, 0x04, 0xcc
+;   addi t6, sp, 0x10
+;   .byte 0x07, 0x84, 0x0f, 0x02
+;   .byte 0x57, 0xf0, 0x80, 0xcd
+;   .byte 0x57, 0x25, 0x80, 0x42
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   ret
+
+function %bitcast_i64_to_vec(i64) -> i32x2 {
+block0(v0: i64):
+    v1 = bitcast.i32x2 little v0
+    return v1
+}
+
+; VCode:
+; block0:
+;   vmv.s.x v11,a0 #avl=1, #vtype=(e64, m1, ta, ma)
+;   vse8.v v11,0(a1) #avl=8, #vtype=(e8, m1, ta, ma)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x57, 0xf0, 0x80, 0xcd
+;   .byte 0xd7, 0x65, 0x05, 0x42
+;   .byte 0x57, 0x70, 0x04, 0xcc
+;   .byte 0xa7, 0x85, 0x05, 0x02
+;   ret
+
+function %bitcast_vec_to_f64(i32x2) -> f64 {
+block0(v0: i32x2):
+    v1 = bitcast.f64 little v0
+    return v1
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+; block0:
+;   vle8.v v8,-16(incoming_arg) #avl=8, #vtype=(e8, m1, ta, ma)
+;   vfmv.f.s fa0,v8 #avl=1, #vtype=(e64, m1, ta, ma)
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+; block1: ; offset 0x10
+;   .byte 0x57, 0x70, 0x04, 0xcc
+;   addi t6, sp, 0x10
+;   .byte 0x07, 0x84, 0x0f, 0x02
+;   .byte 0x57, 0xf0, 0x80, 0xcd
+;   .byte 0x57, 0x15, 0x80, 0x42
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   ret
+
+function %bitcast_f64_to_vec(f64) -> i32x2 {
+block0(v0: f64):
+    v1 = bitcast.i32x2 little v0
+    return v1
+}
+
+; VCode:
+; block0:
+;   vfmv.s.f v11,fa0 #avl=1, #vtype=(e64, m1, ta, ma)
+;   vse8.v v11,0(a0) #avl=8, #vtype=(e8, m1, ta, ma)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x57, 0xf0, 0x80, 0xcd
+;   .byte 0xd7, 0x55, 0x05, 0x42
+;   .byte 0x57, 0x70, 0x04, 0xcc
+;   .byte 0xa7, 0x05, 0x05, 0x02
+;   ret
+
+function %bitcast_i16x2_to_f32(i16x2) -> f32 {
+block0(v0: i16x2):
+    v1 = bitcast.f32 little v0
+    return v1
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+; block0:
+;   vle8.v v8,-16(incoming_arg) #avl=4, #vtype=(e8, m1, ta, ma)
+;   vfmv.f.s fa0,v8 #avl=1, #vtype=(e32, m1, ta, ma)
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+; block1: ; offset 0x10
+;   .byte 0x57, 0x70, 0x02, 0xcc
+;   addi t6, sp, 0x10
+;   .byte 0x07, 0x84, 0x0f, 0x02
+;   .byte 0x57, 0xf0, 0x00, 0xcd
+;   .byte 0x57, 0x15, 0x80, 0x42
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   ret
+
+function %bitcast_f32_to_i16x2(f32) -> i16x2 {
+block0(v0: f32):
+    v1 = bitcast.i16x2 little v0
+    return v1
+}
+
+; VCode:
+; block0:
+;   vfmv.s.f v11,fa0 #avl=1, #vtype=(e32, m1, ta, ma)
+;   vse8.v v11,0(a0) #avl=4, #vtype=(e8, m1, ta, ma)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x57, 0xf0, 0x00, 0xcd
+;   .byte 0xd7, 0x55, 0x05, 0x42
+;   .byte 0x57, 0x70, 0x02, 0xcc
+;   .byte 0xa7, 0x05, 0x05, 0x02
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/bitops-float.clif b/cranelift/filetests/filetests/isa/riscv64/bitops-float.clif
index c4b228d76229..a302407c6dfc 100644
--- a/cranelift/filetests/filetests/isa/riscv64/bitops-float.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/bitops-float.clif
@@ -22,20 +22,19 @@ block1(v4: f32):
 ; VCode:
 ; block0:
 ;   li a0,0
-;   li a1,0
+;   fmv.w.x fa1,zero
+;   fmv.x.w a5,fa1
+;   not a1,a5
 ;   fmv.w.x fa3,a1
+;   fmv.x.w a4,fa3
 ;   fmv.x.w a1,fa3
-;   not a2,a1
-;   fmv.w.x fa4,a2
-;   fmv.x.w a5,fa4
-;   fmv.x.w a1,fa4
-;   or a3,a5,a1
-;   fmv.w.x fa4,a3
-;   br_table a0,[MachLabel(1),MachLabel(2)]##tmp1=a1,tmp2=a2
+;   or a2,a4,a1
+;   fmv.w.x fa2,a2
+;   br_table a0,[MachLabel(1),MachLabel(2)]##tmp1=a2,tmp2=a1
 ; block1:
 ;   j label3
 ; block2:
-;   fmv.d fa4,fa3
+;   fmv.d fa2,fa1
 ;   j label3
 ; block3:
 ;   ret
@@ -43,31 +42,30 @@ block1(v4: f32):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   mv a0, zero
-;   mv a1, zero
+;   fmv.w.x fa1, zero
+;   fmv.x.w a5, fa1
+;   not a1, a5
 ;   fmv.w.x fa3, a1
+;   fmv.x.w a4, fa3
 ;   fmv.x.w a1, fa3
-;   not a2, a1
-;   fmv.w.x fa4, a2
-;   fmv.x.w a5, fa4
-;   fmv.x.w a1, fa4
-;   or a3, a5, a1
-;   fmv.w.x fa4, a3
+;   or a2, a4, a1
+;   fmv.w.x fa2, a2
 ;   slli t6, a0, 0x20
 ;   srli t6, t6, 0x20
-;   addi a2, zero, 1
-;   bltu t6, a2, 0xc
-;   auipc a2, 0
-;   jalr zero, a2, 0x28
+;   addi a1, zero, 1
+;   bltu t6, a1, 0xc
 ;   auipc a1, 0
-;   slli a2, t6, 3
-;   add a1, a1, a2
-;   jalr zero, a1, 0x10
+;   jalr zero, a1, 0x28
 ;   auipc a2, 0
-;   jalr zero, a2, 0xc
-; block1: ; offset 0x58
+;   slli a1, t6, 3
+;   add a2, a2, a1
+;   jalr zero, a2, 0x10
+;   auipc a1, 0
+;   jalr zero, a1, 0xc
+; block1: ; offset 0x54
 ;   j 8
-; block2: ; offset 0x5c
-;   fmv.d fa4, fa3
-; block3: ; offset 0x60
+; block2: ; offset 0x58
+;   fmv.d fa2, fa1
+; block3: ; offset 0x5c
 ;   ret
 
diff --git a/cranelift/filetests/filetests/isa/riscv64/bitops.clif b/cranelift/filetests/filetests/isa/riscv64/bitops.clif
index f1d34cddff8d..724afe20809a 100644
--- a/cranelift/filetests/filetests/isa/riscv64/bitops.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/bitops.clif
@@ -2,289 +2,6 @@ test compile precise-output
 set unwind_info=false
 target riscv64
 
-function %a(i8) -> i8 {
-block0(v0: i8):
-    v1 = bitrev v0
-    return v1
-}
-
-; VCode:
-; block0:
-;   mv a1,a0
-;   brev8 a0,a1##tmp=a2 tmp2=a3 step=a4 ty=i8
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   mv a1, a0
-;   mv a0, zero
-;   addi a4, zero, 8
-;   addi a2, zero, 1
-;   slli a2, a2, 7
-;   addi a3, zero, 1
-;   slli a3, a3, 0
-;   blez a4, 0x34
-;   and t5, a2, a1
-;   beq zero, t5, 8
-;   or a0, a0, a3
-;   addi a4, a4, -1
-;   srli a2, a2, 1
-;   addi t5, zero, 8
-;   rem t5, a4, t5
-;   bnez t5, 0xc
-;   srli a3, a3, 0xf
-;   j -0x28
-;   slli a3, a3, 1
-;   j -0x30
-;   ret
-
-function %a(i16) -> i16 {
-block0(v0: i16):
-    v1 = bitrev v0
-    return v1
-}
-
-; VCode:
-; block0:
-;   brev8 a5,a0##tmp=a2 tmp2=a3 step=a4 ty=i16
-;   rev8 a1,a5##step=a3 tmp=a2
-;   srli a0,a1,48
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   mv a5, zero
-;   addi a4, zero, 0x10
-;   addi a2, zero, 1
-;   slli a2, a2, 0xf
-;   addi a3, zero, 1
-;   slli a3, a3, 8
-;   blez a4, 0x34
-;   and t5, a2, a0
-;   beq zero, t5, 8
-;   or a5, a5, a3
-;   addi a4, a4, -1
-;   srli a2, a2, 1
-;   addi t5, zero, 8
-;   rem t5, a4, t5
-;   bnez t5, 0xc
-;   srli a3, a3, 0xf
-;   j -0x28
-;   slli a3, a3, 1
-;   j -0x30
-;   mv a1, zero
-;   mv a2, a5
-;   addi a3, zero, 0x38
-;   bltz a3, 0x1c
-;   andi t6, a2, 0xff
-;   sll t6, t6, a3
-;   or a1, a1, t6
-;   addi a3, a3, -8
-;   srli a2, a2, 8
-;   j -0x18
-;   srli a0, a1, 0x30
-;   ret
-
-function %a(i32) -> i32 {
-block0(v0: i32):
-    v1 = bitrev v0
-    return v1
-}
-
-; VCode:
-; block0:
-;   brev8 a5,a0##tmp=a2 tmp2=a3 step=a4 ty=i32
-;   rev8 a1,a5##step=a3 tmp=a2
-;   srli a0,a1,32
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   mv a5, zero
-;   addi a4, zero, 0x20
-;   addi a2, zero, 1
-;   slli a2, a2, 0x1f
-;   addi a3, zero, 1
-;   slli a3, a3, 0x18
-;   blez a4, 0x34
-;   and t5, a2, a0
-;   beq zero, t5, 8
-;   or a5, a5, a3
-;   addi a4, a4, -1
-;   srli a2, a2, 1
-;   addi t5, zero, 8
-;   rem t5, a4, t5
-;   bnez t5, 0xc
-;   srli a3, a3, 0xf
-;   j -0x28
-;   slli a3, a3, 1
-;   j -0x30
-;   mv a1, zero
-;   mv a2, a5
-;   addi a3, zero, 0x38
-;   bltz a3, 0x1c
-;   andi t6, a2, 0xff
-;   sll t6, t6, a3
-;   or a1, a1, t6
-;   addi a3, a3, -8
-;   srli a2, a2, 8
-;   j -0x18
-;   srli a0, a1, 0x20
-;   ret
-
-function %a(i64) -> i64 {
-block0(v0: i64):
-    v1 = bitrev v0
-    return v1
-}
-
-; VCode:
-; block0:
-;   rev8 a5,a0##step=a4 tmp=a3
-;   brev8 a0,a5##tmp=a3 tmp2=a1 step=a2 ty=i64
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   mv a5, zero
-;   mv a3, a0
-;   addi a4, zero, 0x38
-;   bltz a4, 0x1c
-;   andi t6, a3, 0xff
-;   sll t6, t6, a4
-;   or a5, a5, t6
-;   addi a4, a4, -8
-;   srli a3, a3, 8
-;   j -0x18
-;   mv a0, zero
-;   addi a2, zero, 0x40
-;   addi a3, zero, 1
-;   slli a3, a3, 0x3f
-;   addi a1, zero, 1
-;   slli a1, a1, 0x38
-;   blez a2, 0x34
-;   and t5, a3, a5
-;   beq zero, t5, 8
-;   or a0, a0, a1
-;   addi a2, a2, -1
-;   srli a3, a3, 1
-;   addi t5, zero, 8
-;   rem t5, a2, t5
-;   bnez t5, 0xc
-;   srli a1, a1, 0xf
-;   j -0x28
-;   slli a1, a1, 1
-;   j -0x30
-;   ret
-
-function %a(i128) -> i128 {
-block0(v0: i128):
-    v1 = bitrev v0
-    return v1
-}
-
-; VCode:
-;   add sp,-16
-;   sd ra,8(sp)
-;   sd fp,0(sp)
-;   mv fp,sp
-;   sd s6,-8(sp)
-;   sd s11,-16(sp)
-;   add sp,-16
-; block0:
-;   mv s11,a1
-;   mv a1,a0
-;   rev8 a0,a1##step=a5 tmp=a4
-;   brev8 a1,a0##tmp=a4 tmp2=a2 step=a3 ty=i64
-;   mv a4,s11
-;   rev8 s6,a4##step=a2 tmp=a3
-;   brev8 a0,s6##tmp=a4 tmp2=a5 step=a2 ty=i64
-;   add sp,+16
-;   ld s6,-8(sp)
-;   ld s11,-16(sp)
-;   ld ra,8(sp)
-;   ld fp,0(sp)
-;   add sp,+16
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   addi sp, sp, -0x10
-;   sd ra, 8(sp)
-;   sd s0, 0(sp)
-;   mv s0, sp
-;   sd s6, -8(sp)
-;   sd s11, -0x10(sp)
-;   addi sp, sp, -0x10
-; block1: ; offset 0x1c
-;   mv s11, a1
-;   mv a1, a0
-;   mv a0, zero
-;   mv a4, a1
-;   addi a5, zero, 0x38
-;   bltz a5, 0x1c
-;   andi t6, a4, 0xff
-;   sll t6, t6, a5
-;   or a0, a0, t6
-;   addi a5, a5, -8
-;   srli a4, a4, 8
-;   j -0x18
-;   mv a1, zero
-;   addi a3, zero, 0x40
-;   addi a4, zero, 1
-;   slli a4, a4, 0x3f
-;   addi a2, zero, 1
-;   slli a2, a2, 0x38
-;   blez a3, 0x34
-;   and t5, a4, a0
-;   beq zero, t5, 8
-;   or a1, a1, a2
-;   addi a3, a3, -1
-;   srli a4, a4, 1
-;   addi t5, zero, 8
-;   rem t5, a3, t5
-;   bnez t5, 0xc
-;   srli a2, a2, 0xf
-;   j -0x28
-;   slli a2, a2, 1
-;   j -0x30
-;   mv a4, s11
-;   mv s6, zero
-;   mv a3, a4
-;   addi a2, zero, 0x38
-;   bltz a2, 0x1c
-;   andi t6, a3, 0xff
-;   sll t6, t6, a2
-;   or s6, s6, t6
-;   addi a2, a2, -8
-;   srli a3, a3, 8
-;   j -0x18
-;   mv a0, zero
-;   addi a2, zero, 0x40
-;   addi a4, zero, 1
-;   slli a4, a4, 0x3f
-;   addi a5, zero, 1
-;   slli a5, a5, 0x38
-;   blez a2, 0x34
-;   and t5, a4, s6
-;   beq zero, t5, 8
-;   or a0, a0, a5
-;   addi a2, a2, -1
-;   srli a4, a4, 1
-;   addi t5, zero, 8
-;   rem t5, a2, t5
-;   bnez t5, 0xc
-;   srli a5, a5, 0xf
-;   j -0x28
-;   slli a5, a5, 1
-;   j -0x30
-;   addi sp, sp, 0x10
-;   ld s6, -8(sp)
-;   ld s11, -0x10(sp)
-;   ld ra, 8(sp)
-;   ld s0, 0(sp)
-;   addi sp, sp, 0x10
-;   ret
 
 function %b(i8) -> i8 {
 block0(v0: i8):
@@ -437,9 +154,8 @@ block0(v0: i128):
 ;   addi a2, a2, -1
 ;   srli a4, a4, 1
 ;   j -0x18
-;   bnez a1, 0xc
 ;   mv a0, a3
-;   j 8
+;   beqz a1, 8
 ;   mv a0, zero
 ;   add a0, a5, a0
 ;   mv a1, zero
@@ -466,9 +182,8 @@ block0(v0: i8):
 ;   slli a2, a0, 0x38
 ;   srai a4, a2, 0x38
 ;   not a0, a4
-;   bgez a4, 0xc
 ;   mv a2, a0
-;   j 8
+;   bltz a4, 8
 ;   mv a2, a4
 ;   mv a0, zero
 ;   addi a5, zero, 0x40
@@ -505,9 +220,8 @@ block0(v0: i16):
 ;   slli a2, a0, 0x30
 ;   srai a4, a2, 0x30
 ;   not a0, a4
-;   bgez a4, 0xc
 ;   mv a2, a0
-;   j 8
+;   bltz a4, 8
 ;   mv a2, a4
 ;   mv a0, zero
 ;   addi a5, zero, 0x40
@@ -542,9 +256,8 @@ block0(v0: i32):
 ; block0: ; offset 0x0
 ;   sext.w a2, a0
 ;   not a4, a2
-;   bgez a2, 0xc
 ;   mv a0, a4
-;   j 8
+;   bltz a2, 8
 ;   mv a0, a2
 ;   mv a4, zero
 ;   addi a3, zero, 0x40
@@ -577,9 +290,8 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   not a2, a0
-;   bgez a0, 0xc
 ;   mv a4, a2
-;   j 8
+;   bltz a0, 8
 ;   mv a4, a0
 ;   mv a2, zero
 ;   addi a1, zero, 0x40
@@ -618,14 +330,12 @@ block0(v0: i128):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   not a3, a0
-;   bgez a1, 0xc
 ;   mv a5, a3
-;   j 8
+;   bltz a1, 8
 ;   mv a5, a0
 ;   not a2, a1
-;   bgez a1, 0xc
 ;   mv a3, a2
-;   j 8
+;   bltz a1, 8
 ;   mv a3, a1
 ;   mv a1, zero
 ;   addi a0, zero, 0x40
@@ -649,9 +359,8 @@ block0(v0: i128):
 ;   addi a4, a4, -1
 ;   srli a2, a2, 1
 ;   j -0x18
-;   bnez a3, 0xc
 ;   mv a2, a0
-;   j 8
+;   beqz a3, 8
 ;   mv a2, zero
 ;   add a3, a1, a2
 ;   addi a0, a3, -1
@@ -1727,10 +1436,10 @@ block0(v0: i128, v1: i8):
 ;   srl a0,a0,a3
 ;   select a3,zero,a0##condition=(a5 eq zero)
 ;   sll a5,a1,a5
-;   or a5,a3,a5
+;   or t0,a3,a5
 ;   li a3,64
-;   andi a2,a2,127
-;   select [a0,a1],[zero,a4],[a4,a5]##condition=(a2 uge a3)
+;   andi a5,a2,127
+;   select [a0,a1],[zero,a4],[a4,t0]##condition=(a5 uge a3)
 ;   ret
 ;
 ; Disassembled:
@@ -1740,20 +1449,18 @@ block0(v0: i128, v1: i8):
 ;   sub a3, a3, a5
 ;   sll a4, a0, a5
 ;   srl a0, a0, a3
-;   bnez a5, 0xc
 ;   mv a3, zero
-;   j 8
+;   beqz a5, 8
 ;   mv a3, a0
 ;   sll a5, a1, a5
-;   or a5, a3, a5
+;   or t0, a3, a5
 ;   addi a3, zero, 0x40
-;   andi a2, a2, 0x7f
-;   bltu a2, a3, 0x10
+;   andi a5, a2, 0x7f
 ;   mv a0, zero
 ;   mv a1, a4
-;   j 0xc
+;   bgeu a5, a3, 0xc
 ;   mv a0, a4
-;   mv a1, a5
+;   mv a1, t0
 ;   ret
 
 function %ishl_i128_i128(i128, i128) -> i128 {
@@ -1794,10 +1501,9 @@ block0(v0: i128, v1: i128):
 ;   or a4, a3, a0
 ;   addi a3, zero, 0x40
 ;   andi a2, a2, 0x7f
-;   bltu a2, a3, 0x10
 ;   mv a0, zero
 ;   mv a1, a5
-;   j 0xc
+;   bgeu a2, a3, 0xc
 ;   mv a0, a5
 ;   mv a1, a4
 ;   ret
@@ -1829,19 +1535,17 @@ block0(v0: i128, v1: i8):
 ;   addi a3, zero, 0x40
 ;   sub a3, a3, a4
 ;   sll a5, a1, a3
-;   bnez a4, 0xc
 ;   mv a3, zero
-;   j 8
+;   beqz a4, 8
 ;   mv a3, a5
 ;   srl a5, a0, a4
 ;   or a5, a3, a5
 ;   addi t0, zero, 0x40
 ;   srl a3, a1, a4
 ;   andi a4, a2, 0x7f
-;   bltu a4, t0, 0x10
 ;   mv a0, a3
 ;   mv a1, zero
-;   j 0xc
+;   bgeu a4, t0, 0xc
 ;   mv a0, a5
 ;   mv a1, a3
 ;   ret
@@ -1853,12 +1557,12 @@ block0(v0: i128, v1: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   sd s11,-8(sp)
-;   add sp,-16
+;   addi sp,sp,-16
+;   sd s11,8(sp)
 ; block0:
 ;   andi a5,a2,63
 ;   li a3,64
@@ -1871,11 +1575,11 @@ block0(v0: i128, v1: i128):
 ;   srl a4,a1,a5
 ;   andi a5,a2,127
 ;   select [a0,a1],[a4,zero],[s11,a4]##condition=(a5 uge a3)
-;   add sp,+16
-;   ld s11,-8(sp)
+;   ld s11,8(sp)
+;   addi sp,sp,16
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -1884,8 +1588,8 @@ block0(v0: i128, v1: i128):
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   sd s11, -8(sp)
 ;   addi sp, sp, -0x10
+;   sd s11, 8(sp)
 ; block1: ; offset 0x18
 ;   andi a5, a2, 0x3f
 ;   addi a3, zero, 0x40
@@ -1898,14 +1602,13 @@ block0(v0: i128, v1: i128):
 ;   addi a3, zero, 0x40
 ;   srl a4, a1, a5
 ;   andi a5, a2, 0x7f
-;   bltu a5, a3, 0x10
 ;   mv a0, a4
 ;   mv a1, zero
-;   j 0xc
+;   bgeu a5, a3, 0xc
 ;   mv a0, s11
 ;   mv a1, a4
+;   ld s11, 8(sp)
 ;   addi sp, sp, 0x10
-;   ld s11, -8(sp)
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -1941,25 +1644,22 @@ block0(v0: i128, v1: i8):
 ;   addi a3, zero, 0x40
 ;   sub a3, a3, a4
 ;   sll a5, a1, a3
-;   bnez a4, 0xc
 ;   mv a3, zero
-;   j 8
+;   beqz a4, 8
 ;   mv a3, a5
 ;   srl a5, a0, a4
 ;   or a5, a3, a5
 ;   addi a0, zero, 0x40
 ;   sra a3, a1, a4
 ;   addi a4, zero, -1
-;   bgez a1, 0xc
 ;   mv t4, a4
-;   j 8
+;   bltz a1, 8
 ;   mv t4, zero
 ;   addi a4, zero, 0x40
 ;   andi a2, a2, 0x7f
-;   bltu a2, a4, 0x10
 ;   mv a0, a3
 ;   mv a1, t4
-;   j 0xc
+;   bgeu a2, a4, 0xc
 ;   mv a0, a5
 ;   mv a1, a3
 ;   ret
@@ -1971,12 +1671,12 @@ block0(v0: i128, v1: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   sd s11,-8(sp)
-;   add sp,-16
+;   addi sp,sp,-16
+;   sd s11,8(sp)
 ; block0:
 ;   andi a5,a2,63
 ;   li a3,64
@@ -1992,11 +1692,11 @@ block0(v0: i128, v1: i128):
 ;   li a4,64
 ;   andi a2,a2,127
 ;   select [a0,a1],[a3,a5],[s11,a3]##condition=(a2 uge a4)
-;   add sp,+16
-;   ld s11,-8(sp)
+;   ld s11,8(sp)
+;   addi sp,sp,16
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -2005,8 +1705,8 @@ block0(v0: i128, v1: i128):
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   sd s11, -8(sp)
 ;   addi sp, sp, -0x10
+;   sd s11, 8(sp)
 ; block1: ; offset 0x18
 ;   andi a5, a2, 0x3f
 ;   addi a3, zero, 0x40
@@ -2023,14 +1723,13 @@ block0(v0: i128, v1: i128):
 ;   mv a5, zero
 ;   addi a4, zero, 0x40
 ;   andi a2, a2, 0x7f
-;   bltu a2, a4, 0x10
 ;   mv a0, a3
 ;   mv a1, a5
-;   j 0xc
+;   bgeu a2, a4, 0xc
 ;   mv a0, s11
 ;   mv a1, a3
+;   ld s11, 8(sp)
 ;   addi sp, sp, 0x10
-;   ld s11, -8(sp)
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
diff --git a/cranelift/filetests/filetests/isa/riscv64/bitrev-zbb-zbkb.clif b/cranelift/filetests/filetests/isa/riscv64/bitrev-zbb-zbkb.clif
new file mode 100644
index 000000000000..84d16bfea213
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/bitrev-zbb-zbkb.clif
@@ -0,0 +1,104 @@
+test compile precise-output
+set unwind_info=false
+target riscv64 has_zbkb has_zbb
+
+function %bitrev_i8(i8) -> i8 {
+block0(v0: i8):
+    v1 = bitrev v0
+    return v1
+}
+
+; VCode:
+; block0:
+;   brev8 a0,a0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x13, 0x55, 0x75, 0x68
+;   ret
+
+function %bitrev_i16(i16) -> i16 {
+block0(v0: i16):
+    v1 = bitrev v0
+    return v1
+}
+
+; VCode:
+; block0:
+;   rev8 a2,a0
+;   brev8 a4,a2
+;   srli a0,a4,48
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x13, 0x56, 0x85, 0x6b
+;   .byte 0x13, 0x57, 0x76, 0x68
+;   srli a0, a4, 0x30
+;   ret
+
+function %bitrev_i32(i32) -> i32 {
+block0(v0: i32):
+    v1 = bitrev v0
+    return v1
+}
+
+; VCode:
+; block0:
+;   rev8 a2,a0
+;   brev8 a4,a2
+;   srli a0,a4,32
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x13, 0x56, 0x85, 0x6b
+;   .byte 0x13, 0x57, 0x76, 0x68
+;   srli a0, a4, 0x20
+;   ret
+
+function %bitrev_i64(i64) -> i64 {
+block0(v0: i64):
+    v1 = bitrev v0
+    return v1
+}
+
+; VCode:
+; block0:
+;   rev8 a2,a0
+;   brev8 a0,a2
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x13, 0x56, 0x85, 0x6b
+;   .byte 0x13, 0x55, 0x76, 0x68
+;   ret
+
+function %bitrev_i128(i128) -> i128 {
+block0(v0: i128):
+    v1 = bitrev v0
+    return v1
+}
+
+; VCode:
+; block0:
+;   mv a2,a0
+;   rev8 a3,a1
+;   brev8 a0,a3
+;   mv a3,a2
+;   rev8 a1,a3
+;   brev8 a1,a1
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   mv a2, a0
+;   .byte 0x93, 0xd6, 0x85, 0x6b
+;   .byte 0x13, 0xd5, 0x76, 0x68
+;   mv a3, a2
+;   .byte 0x93, 0xd5, 0x86, 0x6b
+;   .byte 0x93, 0xd5, 0x75, 0x68
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/bitrev.clif b/cranelift/filetests/filetests/isa/riscv64/bitrev.clif
new file mode 100644
index 000000000000..2d03516441cb
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/bitrev.clif
@@ -0,0 +1,552 @@
+test compile precise-output
+set unwind_info=false
+target riscv64
+
+function %bitrev_i8(i8) -> i8 {
+block0(v0: i8):
+    v1 = bitrev v0
+    return v1
+}
+
+; VCode:
+; block0:
+;   mv a1,a0
+;   brev8 a0,a1##tmp=a2 tmp2=a3 step=a4 ty=i8
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   mv a1, a0
+;   mv a0, zero
+;   addi a4, zero, 8
+;   addi a2, zero, 1
+;   slli a2, a2, 7
+;   addi a3, zero, 1
+;   slli a3, a3, 0
+;   blez a4, 0x34
+;   and t5, a2, a1
+;   beq zero, t5, 8
+;   or a0, a0, a3
+;   addi a4, a4, -1
+;   srli a2, a2, 1
+;   addi t5, zero, 8
+;   rem t5, a4, t5
+;   bnez t5, 0xc
+;   srli a3, a3, 0xf
+;   j -0x28
+;   slli a3, a3, 1
+;   j -0x30
+;   ret
+
+function %bitrev_i16(i16) -> i16 {
+block0(v0: i16):
+    v1 = bitrev v0
+    return v1
+}
+
+; VCode:
+; block0:
+;   slli a2,a0,8
+;   srli a4,a0,8
+;   slli a1,a4,56
+;   srli a3,a1,56
+;   or a4,a2,a3
+;   slli a1,a4,16
+;   srli a2,a0,16
+;   slli a4,a2,8
+;   srli a2,a2,8
+;   slli a2,a2,56
+;   srli a5,a2,56
+;   or a2,a4,a5
+;   slli a2,a2,48
+;   srli a4,a2,48
+;   or a1,a1,a4
+;   slli a2,a1,32
+;   srli a5,a0,32
+;   slli a0,a5,8
+;   srli a3,a5,8
+;   slli a4,a3,56
+;   srli a1,a4,56
+;   or a3,a0,a1
+;   slli a4,a3,16
+;   srli a0,a5,16
+;   slli a3,a0,8
+;   srli a5,a0,8
+;   slli a0,a5,56
+;   srli a5,a0,56
+;   or a5,a3,a5
+;   slli a0,a5,48
+;   srli a3,a0,48
+;   or a4,a4,a3
+;   slli a0,a4,32
+;   srli a3,a0,32
+;   or a4,a2,a3
+;   brev8 a3,a4##tmp=a0 tmp2=a1 step=a2 ty=i64
+;   srli a0,a3,48
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   slli a2, a0, 8
+;   srli a4, a0, 8
+;   slli a1, a4, 0x38
+;   srli a3, a1, 0x38
+;   or a4, a2, a3
+;   slli a1, a4, 0x10
+;   srli a2, a0, 0x10
+;   slli a4, a2, 8
+;   srli a2, a2, 8
+;   slli a2, a2, 0x38
+;   srli a5, a2, 0x38
+;   or a2, a4, a5
+;   slli a2, a2, 0x30
+;   srli a4, a2, 0x30
+;   or a1, a1, a4
+;   slli a2, a1, 0x20
+;   srli a5, a0, 0x20
+;   slli a0, a5, 8
+;   srli a3, a5, 8
+;   slli a4, a3, 0x38
+;   srli a1, a4, 0x38
+;   or a3, a0, a1
+;   slli a4, a3, 0x10
+;   srli a0, a5, 0x10
+;   slli a3, a0, 8
+;   srli a5, a0, 8
+;   slli a0, a5, 0x38
+;   srli a5, a0, 0x38
+;   or a5, a3, a5
+;   slli a0, a5, 0x30
+;   srli a3, a0, 0x30
+;   or a4, a4, a3
+;   slli a0, a4, 0x20
+;   srli a3, a0, 0x20
+;   or a4, a2, a3
+;   mv a3, zero
+;   addi a2, zero, 0x40
+;   addi a0, zero, 1
+;   slli a0, a0, 0x3f
+;   addi a1, zero, 1
+;   slli a1, a1, 0x38
+;   blez a2, 0x34
+;   and t5, a0, a4
+;   beq zero, t5, 8
+;   or a3, a3, a1
+;   addi a2, a2, -1
+;   srli a0, a0, 1
+;   addi t5, zero, 8
+;   rem t5, a2, t5
+;   bnez t5, 0xc
+;   srli a1, a1, 0xf
+;   j -0x28
+;   slli a1, a1, 1
+;   j -0x30
+;   srli a0, a3, 0x30
+;   ret
+
+function %bitrev_i32(i32) -> i32 {
+block0(v0: i32):
+    v1 = bitrev v0
+    return v1
+}
+
+; VCode:
+; block0:
+;   slli a2,a0,8
+;   srli a4,a0,8
+;   slli a1,a4,56
+;   srli a3,a1,56
+;   or a4,a2,a3
+;   slli a1,a4,16
+;   srli a2,a0,16
+;   slli a4,a2,8
+;   srli a2,a2,8
+;   slli a2,a2,56
+;   srli a5,a2,56
+;   or a2,a4,a5
+;   slli a2,a2,48
+;   srli a4,a2,48
+;   or a1,a1,a4
+;   slli a2,a1,32
+;   srli a5,a0,32
+;   slli a0,a5,8
+;   srli a3,a5,8
+;   slli a4,a3,56
+;   srli a1,a4,56
+;   or a3,a0,a1
+;   slli a4,a3,16
+;   srli a0,a5,16
+;   slli a3,a0,8
+;   srli a5,a0,8
+;   slli a0,a5,56
+;   srli a5,a0,56
+;   or a5,a3,a5
+;   slli a0,a5,48
+;   srli a3,a0,48
+;   or a4,a4,a3
+;   slli a0,a4,32
+;   srli a3,a0,32
+;   or a4,a2,a3
+;   brev8 a3,a4##tmp=a0 tmp2=a1 step=a2 ty=i64
+;   srli a0,a3,32
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   slli a2, a0, 8
+;   srli a4, a0, 8
+;   slli a1, a4, 0x38
+;   srli a3, a1, 0x38
+;   or a4, a2, a3
+;   slli a1, a4, 0x10
+;   srli a2, a0, 0x10
+;   slli a4, a2, 8
+;   srli a2, a2, 8
+;   slli a2, a2, 0x38
+;   srli a5, a2, 0x38
+;   or a2, a4, a5
+;   slli a2, a2, 0x30
+;   srli a4, a2, 0x30
+;   or a1, a1, a4
+;   slli a2, a1, 0x20
+;   srli a5, a0, 0x20
+;   slli a0, a5, 8
+;   srli a3, a5, 8
+;   slli a4, a3, 0x38
+;   srli a1, a4, 0x38
+;   or a3, a0, a1
+;   slli a4, a3, 0x10
+;   srli a0, a5, 0x10
+;   slli a3, a0, 8
+;   srli a5, a0, 8
+;   slli a0, a5, 0x38
+;   srli a5, a0, 0x38
+;   or a5, a3, a5
+;   slli a0, a5, 0x30
+;   srli a3, a0, 0x30
+;   or a4, a4, a3
+;   slli a0, a4, 0x20
+;   srli a3, a0, 0x20
+;   or a4, a2, a3
+;   mv a3, zero
+;   addi a2, zero, 0x40
+;   addi a0, zero, 1
+;   slli a0, a0, 0x3f
+;   addi a1, zero, 1
+;   slli a1, a1, 0x38
+;   blez a2, 0x34
+;   and t5, a0, a4
+;   beq zero, t5, 8
+;   or a3, a3, a1
+;   addi a2, a2, -1
+;   srli a0, a0, 1
+;   addi t5, zero, 8
+;   rem t5, a2, t5
+;   bnez t5, 0xc
+;   srli a1, a1, 0xf
+;   j -0x28
+;   slli a1, a1, 1
+;   j -0x30
+;   srli a0, a3, 0x20
+;   ret
+
+function %bitrev_i64(i64) -> i64 {
+block0(v0: i64):
+    v1 = bitrev v0
+    return v1
+}
+
+; VCode:
+; block0:
+;   slli a2,a0,8
+;   srli a4,a0,8
+;   slli a1,a4,56
+;   srli a3,a1,56
+;   or a4,a2,a3
+;   slli a1,a4,16
+;   srli a2,a0,16
+;   slli a4,a2,8
+;   srli a2,a2,8
+;   slli a2,a2,56
+;   srli a5,a2,56
+;   or a2,a4,a5
+;   slli a2,a2,48
+;   srli a4,a2,48
+;   or a1,a1,a4
+;   slli a2,a1,32
+;   srli a5,a0,32
+;   slli a0,a5,8
+;   srli a3,a5,8
+;   slli a4,a3,56
+;   srli a1,a4,56
+;   or a3,a0,a1
+;   slli a4,a3,16
+;   srli a0,a5,16
+;   slli a3,a0,8
+;   srli a5,a0,8
+;   slli a0,a5,56
+;   srli a5,a0,56
+;   or a5,a3,a5
+;   slli a0,a5,48
+;   srli a3,a0,48
+;   or a4,a4,a3
+;   slli a0,a4,32
+;   srli a3,a0,32
+;   or a4,a2,a3
+;   brev8 a0,a4##tmp=a3 tmp2=a1 step=a2 ty=i64
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   slli a2, a0, 8
+;   srli a4, a0, 8
+;   slli a1, a4, 0x38
+;   srli a3, a1, 0x38
+;   or a4, a2, a3
+;   slli a1, a4, 0x10
+;   srli a2, a0, 0x10
+;   slli a4, a2, 8
+;   srli a2, a2, 8
+;   slli a2, a2, 0x38
+;   srli a5, a2, 0x38
+;   or a2, a4, a5
+;   slli a2, a2, 0x30
+;   srli a4, a2, 0x30
+;   or a1, a1, a4
+;   slli a2, a1, 0x20
+;   srli a5, a0, 0x20
+;   slli a0, a5, 8
+;   srli a3, a5, 8
+;   slli a4, a3, 0x38
+;   srli a1, a4, 0x38
+;   or a3, a0, a1
+;   slli a4, a3, 0x10
+;   srli a0, a5, 0x10
+;   slli a3, a0, 8
+;   srli a5, a0, 8
+;   slli a0, a5, 0x38
+;   srli a5, a0, 0x38
+;   or a5, a3, a5
+;   slli a0, a5, 0x30
+;   srli a3, a0, 0x30
+;   or a4, a4, a3
+;   slli a0, a4, 0x20
+;   srli a3, a0, 0x20
+;   or a4, a2, a3
+;   mv a0, zero
+;   addi a2, zero, 0x40
+;   addi a3, zero, 1
+;   slli a3, a3, 0x3f
+;   addi a1, zero, 1
+;   slli a1, a1, 0x38
+;   blez a2, 0x34
+;   and t5, a3, a4
+;   beq zero, t5, 8
+;   or a0, a0, a1
+;   addi a2, a2, -1
+;   srli a3, a3, 1
+;   addi t5, zero, 8
+;   rem t5, a2, t5
+;   bnez t5, 0xc
+;   srli a1, a1, 0xf
+;   j -0x28
+;   slli a1, a1, 1
+;   j -0x30
+;   ret
+
+function %bitrev_i128(i128) -> i128 {
+block0(v0: i128):
+    v1 = bitrev v0
+    return v1
+}
+
+; VCode:
+; block0:
+;   slli a3,a1,8
+;   srli a5,a1,8
+;   slli a2,a5,56
+;   srli a4,a2,56
+;   or a5,a3,a4
+;   slli a2,a5,16
+;   srli a3,a1,16
+;   slli a5,a3,8
+;   srli a3,a3,8
+;   slli a3,a3,56
+;   srli a3,a3,56
+;   or a3,a5,a3
+;   slli a3,a3,48
+;   srli a5,a3,48
+;   or a2,a2,a5
+;   slli a3,a2,32
+;   srli a1,a1,32
+;   slli a2,a1,8
+;   srli a4,a1,8
+;   slli a5,a4,56
+;   srli a4,a5,56
+;   or a4,a2,a4
+;   slli a5,a4,16
+;   srli a1,a1,16
+;   slli a4,a1,8
+;   srli a1,a1,8
+;   slli a1,a1,56
+;   srli a1,a1,56
+;   or a1,a4,a1
+;   slli a1,a1,48
+;   srli a4,a1,48
+;   or a5,a5,a4
+;   slli a1,a5,32
+;   srli a4,a1,32
+;   or a5,a3,a4
+;   brev8 a4,a5##tmp=a1 tmp2=a2 step=a3 ty=i64
+;   slli a1,a0,8
+;   srli a2,a0,8
+;   slli a5,a2,56
+;   srli a2,a5,56
+;   or a2,a1,a2
+;   slli a5,a2,16
+;   srli a1,a0,16
+;   slli a2,a1,8
+;   srli a1,a1,8
+;   slli a1,a1,56
+;   srli a3,a1,56
+;   or a1,a2,a3
+;   slli a1,a1,48
+;   srli a2,a1,48
+;   or a5,a5,a2
+;   slli a1,a5,32
+;   srli a3,a0,32
+;   slli a5,a3,8
+;   srli a0,a3,8
+;   slli a2,a0,56
+;   srli a0,a2,56
+;   or a0,a5,a0
+;   slli a2,a0,16
+;   srli a5,a3,16
+;   slli a0,a5,8
+;   srli a3,a5,8
+;   slli a5,a3,56
+;   srli a3,a5,56
+;   or a3,a0,a3
+;   slli a5,a3,48
+;   srli a0,a5,48
+;   or a2,a2,a0
+;   slli a5,a2,32
+;   srli a0,a5,32
+;   or a3,a1,a0
+;   brev8 a1,a3##tmp=a2 tmp2=a5 step=a0 ty=i64
+;   mv a0,a4
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   slli a3, a1, 8
+;   srli a5, a1, 8
+;   slli a2, a5, 0x38
+;   srli a4, a2, 0x38
+;   or a5, a3, a4
+;   slli a2, a5, 0x10
+;   srli a3, a1, 0x10
+;   slli a5, a3, 8
+;   srli a3, a3, 8
+;   slli a3, a3, 0x38
+;   srli a3, a3, 0x38
+;   or a3, a5, a3
+;   slli a3, a3, 0x30
+;   srli a5, a3, 0x30
+;   or a2, a2, a5
+;   slli a3, a2, 0x20
+;   srli a1, a1, 0x20
+;   slli a2, a1, 8
+;   srli a4, a1, 8
+;   slli a5, a4, 0x38
+;   srli a4, a5, 0x38
+;   or a4, a2, a4
+;   slli a5, a4, 0x10
+;   srli a1, a1, 0x10
+;   slli a4, a1, 8
+;   srli a1, a1, 8
+;   slli a1, a1, 0x38
+;   srli a1, a1, 0x38
+;   or a1, a4, a1
+;   slli a1, a1, 0x30
+;   srli a4, a1, 0x30
+;   or a5, a5, a4
+;   slli a1, a5, 0x20
+;   srli a4, a1, 0x20
+;   or a5, a3, a4
+;   mv a4, zero
+;   addi a3, zero, 0x40
+;   addi a1, zero, 1
+;   slli a1, a1, 0x3f
+;   addi a2, zero, 1
+;   slli a2, a2, 0x38
+;   blez a3, 0x34
+;   and t5, a1, a5
+;   beq zero, t5, 8
+;   or a4, a4, a2
+;   addi a3, a3, -1
+;   srli a1, a1, 1
+;   addi t5, zero, 8
+;   rem t5, a3, t5
+;   bnez t5, 0xc
+;   srli a2, a2, 0xf
+;   j -0x28
+;   slli a2, a2, 1
+;   j -0x30
+;   slli a1, a0, 8
+;   srli a2, a0, 8
+;   slli a5, a2, 0x38
+;   srli a2, a5, 0x38
+;   or a2, a1, a2
+;   slli a5, a2, 0x10
+;   srli a1, a0, 0x10
+;   slli a2, a1, 8
+;   srli a1, a1, 8
+;   slli a1, a1, 0x38
+;   srli a3, a1, 0x38
+;   or a1, a2, a3
+;   slli a1, a1, 0x30
+;   srli a2, a1, 0x30
+;   or a5, a5, a2
+;   slli a1, a5, 0x20
+;   srli a3, a0, 0x20
+;   slli a5, a3, 8
+;   srli a0, a3, 8
+;   slli a2, a0, 0x38
+;   srli a0, a2, 0x38
+;   or a0, a5, a0
+;   slli a2, a0, 0x10
+;   srli a5, a3, 0x10
+;   slli a0, a5, 8
+;   srli a3, a5, 8
+;   slli a5, a3, 0x38
+;   srli a3, a5, 0x38
+;   or a3, a0, a3
+;   slli a5, a3, 0x30
+;   srli a0, a5, 0x30
+;   or a2, a2, a0
+;   slli a5, a2, 0x20
+;   srli a0, a5, 0x20
+;   or a3, a1, a0
+;   mv a1, zero
+;   addi a0, zero, 0x40
+;   addi a2, zero, 1
+;   slli a2, a2, 0x3f
+;   addi a5, zero, 1
+;   slli a5, a5, 0x38
+;   blez a0, 0x34
+;   and t5, a2, a3
+;   beq zero, t5, 8
+;   or a1, a1, a5
+;   addi a0, a0, -1
+;   srli a2, a2, 1
+;   addi t5, zero, 8
+;   rem t5, a0, t5
+;   bnez t5, 0xc
+;   srli a5, a5, 0xf
+;   j -0x28
+;   slli a5, a5, 1
+;   j -0x30
+;   mv a0, a4
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/br_table.clif b/cranelift/filetests/filetests/isa/riscv64/br_table.clif
index 8c5bde3ef46a..38bf96b51498 100644
--- a/cranelift/filetests/filetests/isa/riscv64/br_table.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/br_table.clif
@@ -47,7 +47,7 @@ block5(v5: i32):
 ;   li a5,4
 ;   j label7
 ; block7:
-;   add a0,a0,a5
+;   addw a0,a0,a5
 ;   ret
 ;
 ; Disassembled:
@@ -84,6 +84,6 @@ block5(v5: i32):
 ; block5: ; offset 0x64
 ;   addi a5, zero, 4
 ; block6: ; offset 0x68
-;   add a0, a0, a5
+;   addw a0, a0, a5
 ;   ret
 
diff --git a/cranelift/filetests/filetests/isa/riscv64/brif.clif b/cranelift/filetests/filetests/isa/riscv64/brif.clif
index 8f61a5982ae3..f998b0bf5da8 100644
--- a/cranelift/filetests/filetests/isa/riscv64/brif.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/brif.clif
@@ -234,10 +234,10 @@ block2:
 ; block0:
 ;   mv a3,a1
 ;   slli a5,a0,48
-;   srli a1,a5,48
+;   srai a1,a5,48
 ;   mv a5,a3
 ;   slli a3,a5,48
-;   srli a5,a3,48
+;   srai a5,a3,48
 ;   bne a1,a5,taken(label2),not_taken(label1)
 ; block1:
 ;   li a0,0
@@ -250,10 +250,10 @@ block2:
 ; block0: ; offset 0x0
 ;   mv a3, a1
 ;   slli a5, a0, 0x30
-;   srli a1, a5, 0x30
+;   srai a1, a5, 0x30
 ;   mv a5, a3
 ;   slli a3, a5, 0x30
-;   srli a5, a3, 0x30
+;   srai a5, a3, 0x30
 ;   bne a1, a5, 0xc
 ; block1: ; offset 0x1c
 ;   mv a0, zero
@@ -349,30 +349,66 @@ block2:
 }
 
 ; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+;   addi sp,sp,-16
+;   sd s1,8(sp)
 ; block0:
-;   sgt a1,[a0,a1],[a2,a3]##ty=i128
+;   slt s1,a3,a1
+;   sltu a4,a2,a0
+;   xor a5,a3,a1
+;   select a1,a4,s1##condition=(a5 eq zero)
 ;   bne a1,zero,taken(label2),not_taken(label1)
 ; block1:
 ;   li a0,0
+;   ld s1,8(sp)
+;   addi sp,sp,16
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
 ;   ret
 ; block2:
 ;   li a0,1
+;   ld s1,8(sp)
+;   addi sp,sp,16
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   blt a3, a1, 0xc
-;   bne a1, a3, 0x10
-;   bgeu a2, a0, 0xc
-;   addi a1, zero, 1
-;   j 8
-;   mv a1, zero
-;   bnez a1, 0xc
-; block1: ; offset 0x1c
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+;   addi sp, sp, -0x10
+;   sd s1, 8(sp)
+; block1: ; offset 0x18
+;   slt s1, a3, a1
+;   sltu a4, a2, a0
+;   xor a5, a3, a1
+;   mv a1, a4
+;   beqz a5, 8
+;   mv a1, s1
+;   bnez a1, 0x20
+; block2: ; offset 0x34
 ;   mv a0, zero
+;   ld s1, 8(sp)
+;   addi sp, sp, 0x10
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
 ;   ret
-; block2: ; offset 0x24
+; block3: ; offset 0x50
 ;   addi a0, zero, 1
+;   ld s1, 8(sp)
+;   addi sp, sp, 0x10
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
 ;   ret
 
 function %brif_fcmp_f32(f32, f32) -> i8 {
diff --git a/cranelift/filetests/filetests/isa/riscv64/bswap.clif b/cranelift/filetests/filetests/isa/riscv64/bswap.clif
index cbcfe12e57c0..4007284550c5 100644
--- a/cranelift/filetests/filetests/isa/riscv64/bswap.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/bswap.clif
@@ -197,43 +197,42 @@ block0(v0: i128):
 ;   slli a1,a5,32
 ;   srli a4,a1,32
 ;   or a5,a3,a4
-;   mv t1,a5
 ;   slli a1,a0,8
 ;   srli a3,a0,8
-;   slli a5,a3,56
-;   srli a2,a5,56
+;   slli a2,a3,56
+;   srli a2,a2,56
 ;   or a3,a1,a2
-;   slli a5,a3,16
-;   srli a1,a0,16
-;   slli a3,a1,8
-;   srli a1,a1,8
-;   slli a1,a1,56
-;   srli a4,a1,56
-;   or a1,a3,a4
-;   slli a1,a1,48
-;   srli a3,a1,48
-;   or a5,a5,a3
-;   slli a1,a5,32
+;   slli a1,a3,16
+;   srli a2,a0,16
+;   slli a3,a2,8
+;   srli a2,a2,8
+;   slli a2,a2,56
+;   srli a4,a2,56
+;   or a2,a3,a4
+;   slli a2,a2,48
+;   srli a3,a2,48
+;   or a1,a1,a3
+;   slli a1,a1,32
 ;   srli a4,a0,32
-;   slli a5,a4,8
+;   slli a0,a4,8
 ;   srli a2,a4,8
 ;   slli a3,a2,56
-;   srli a0,a3,56
-;   or a2,a5,a0
+;   srli a2,a3,56
+;   or a2,a0,a2
 ;   slli a3,a2,16
-;   srli a5,a4,16
-;   slli a2,a5,8
-;   srli a4,a5,8
-;   slli a5,a4,56
-;   srli a4,a5,56
+;   srli a0,a4,16
+;   slli a2,a0,8
+;   srli a4,a0,8
+;   slli a0,a4,56
+;   srli a4,a0,56
 ;   or a4,a2,a4
-;   slli a5,a4,48
-;   srli a2,a5,48
+;   slli a0,a4,48
+;   srli a2,a0,48
 ;   or a3,a3,a2
-;   slli a5,a3,32
-;   srli a2,a5,32
+;   slli a0,a3,32
+;   srli a2,a0,32
 ;   or a1,a1,a2
-;   mv a0,t1
+;   mv a0,a5
 ;   ret
 ;
 ; Disassembled:
@@ -273,42 +272,41 @@ block0(v0: i128):
 ;   slli a1, a5, 0x20
 ;   srli a4, a1, 0x20
 ;   or a5, a3, a4
-;   mv t1, a5
 ;   slli a1, a0, 8
 ;   srli a3, a0, 8
-;   slli a5, a3, 0x38
-;   srli a2, a5, 0x38
+;   slli a2, a3, 0x38
+;   srli a2, a2, 0x38
 ;   or a3, a1, a2
-;   slli a5, a3, 0x10
-;   srli a1, a0, 0x10
-;   slli a3, a1, 8
-;   srli a1, a1, 8
-;   slli a1, a1, 0x38
-;   srli a4, a1, 0x38
-;   or a1, a3, a4
-;   slli a1, a1, 0x30
-;   srli a3, a1, 0x30
-;   or a5, a5, a3
-;   slli a1, a5, 0x20
+;   slli a1, a3, 0x10
+;   srli a2, a0, 0x10
+;   slli a3, a2, 8
+;   srli a2, a2, 8
+;   slli a2, a2, 0x38
+;   srli a4, a2, 0x38
+;   or a2, a3, a4
+;   slli a2, a2, 0x30
+;   srli a3, a2, 0x30
+;   or a1, a1, a3
+;   slli a1, a1, 0x20
 ;   srli a4, a0, 0x20
-;   slli a5, a4, 8
+;   slli a0, a4, 8
 ;   srli a2, a4, 8
 ;   slli a3, a2, 0x38
-;   srli a0, a3, 0x38
-;   or a2, a5, a0
+;   srli a2, a3, 0x38
+;   or a2, a0, a2
 ;   slli a3, a2, 0x10
-;   srli a5, a4, 0x10
-;   slli a2, a5, 8
-;   srli a4, a5, 8
-;   slli a5, a4, 0x38
-;   srli a4, a5, 0x38
+;   srli a0, a4, 0x10
+;   slli a2, a0, 8
+;   srli a4, a0, 8
+;   slli a0, a4, 0x38
+;   srli a4, a0, 0x38
 ;   or a4, a2, a4
-;   slli a5, a4, 0x30
-;   srli a2, a5, 0x30
+;   slli a0, a4, 0x30
+;   srli a2, a0, 0x30
 ;   or a3, a3, a2
-;   slli a5, a3, 0x20
-;   srli a2, a5, 0x20
+;   slli a0, a3, 0x20
+;   srli a2, a0, 0x20
 ;   or a1, a1, a2
-;   mv a0, t1
+;   mv a0, a5
 ;   ret
 
diff --git a/cranelift/filetests/filetests/isa/riscv64/c-inline-probestack.clif b/cranelift/filetests/filetests/isa/riscv64/c-inline-probestack.clif
new file mode 100644
index 000000000000..0a57c4816fc5
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/c-inline-probestack.clif
@@ -0,0 +1,162 @@
+test compile precise-output
+set enable_probestack=true
+set probestack_strategy=inline
+; This is the default and is equivalent to a page size of 4096
+set probestack_size_log2=12
+target riscv64 has_c
+
+
+; If the stack size is just one page, we can avoid the stack probe entirely
+function %single_page() -> i64 system_v {
+ss0 = explicit_slot 2048
+
+block0:
+  v1 = stack_addr.i64 ss0
+  return v1
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+;   addi sp,sp,-2048
+; block0:
+;   load_addr a0,0(slot)
+;   lui t6,1
+;   addi t6,t6,-2048
+;   add sp,sp,t6
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   c.addi16sp sp, -0x10
+;   c.sdsp ra, 8(sp)
+;   c.sdsp s0, 0(sp)
+;   c.mv s0, sp
+;   addi sp, sp, -0x800
+; block1: ; offset 0xc
+;   c.mv a0, sp
+;   c.lui t6, 1
+;   addi t6, t6, -0x800
+;   c.add sp, t6
+;   c.ldsp ra, 8(sp)
+;   c.ldsp s0, 0(sp)
+;   c.addi16sp sp, 0x10
+;   c.jr ra
+
+function %unrolled() -> i64 system_v {
+ss0 = explicit_slot 12288
+
+block0:
+  v1 = stack_addr.i64 ss0
+  return v1
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+;   lui t3,-1
+;   add sp,sp,t3
+;   sw zero,0(sp)
+;   add sp,sp,t3
+;   sw zero,0(sp)
+;   add sp,sp,t3
+;   sw zero,0(sp)
+;   lui t6,3
+;   add sp,sp,t6
+;   lui t6,-3
+;   add sp,sp,t6
+; block0:
+;   load_addr a0,0(slot)
+;   lui t6,3
+;   add sp,sp,t6
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   c.addi16sp sp, -0x10
+;   c.sdsp ra, 8(sp)
+;   c.sdsp s0, 0(sp)
+;   c.mv s0, sp
+;   c.lui t3, 0xfffff
+;   c.add sp, t3
+;   c.swsp zero, 0(sp)
+;   c.add sp, t3
+;   c.swsp zero, 0(sp)
+;   c.add sp, t3
+;   c.swsp zero, 0(sp)
+;   c.lui t6, 3
+;   c.add sp, t6
+;   c.lui t6, 0xffffd
+;   c.add sp, t6
+; block1: ; offset 0x1e
+;   c.mv a0, sp
+;   c.lui t6, 3
+;   c.add sp, t6
+;   c.ldsp ra, 8(sp)
+;   c.ldsp s0, 0(sp)
+;   c.addi16sp sp, 0x10
+;   c.jr ra
+
+function %large() -> i64 system_v {
+ss0 = explicit_slot 100000
+
+block0:
+  v1 = stack_addr.i64 ss0
+  return v1
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+;   inline_stack_probe##guard_size=4096 probe_count=25 tmp=t3
+;   lui t6,-24
+;   addi t6,t6,-1696
+;   add sp,sp,t6
+; block0:
+;   load_addr a0,0(slot)
+;   lui t6,24
+;   addi t6,t6,1696
+;   add sp,sp,t6
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   c.addi16sp sp, -0x10
+;   c.sdsp ra, 8(sp)
+;   c.sdsp s0, 0(sp)
+;   c.mv s0, sp
+;   c.lui t6, 0x19
+;   c.lui t3, 1
+;   bgeu t3, t6, 0x12
+;   sub t5, sp, t6
+;   sb zero, 0(t5) ; trap: heap_oob
+;   sub t6, t6, t3
+;   c.j -0x10
+;   c.lui t6, 0xfffe8
+;   addi t6, t6, -0x6a0
+;   c.add sp, t6
+; block1: ; offset 0x26
+;   c.mv a0, sp
+;   c.lui t6, 0x18
+;   addi t6, t6, 0x6a0
+;   c.add sp, t6
+;   c.ldsp ra, 8(sp)
+;   c.ldsp s0, 0(sp)
+;   c.addi16sp sp, 0x10
+;   c.jr ra
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/call-indirect.clif b/cranelift/filetests/filetests/isa/riscv64/call-indirect.clif
index 01b2d3343a86..8747d9b2ecba 100644
--- a/cranelift/filetests/filetests/isa/riscv64/call-indirect.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/call-indirect.clif
@@ -10,7 +10,7 @@ block0(v0: i64, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
@@ -18,7 +18,7 @@ block0(v0: i64, v1: i64):
 ;   callind a1
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
diff --git a/cranelift/filetests/filetests/isa/riscv64/call.clif b/cranelift/filetests/filetests/isa/riscv64/call.clif
index 8fa3cad65681..8fcfe0f709aa 100644
--- a/cranelift/filetests/filetests/isa/riscv64/call.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/call.clif
@@ -11,7 +11,7 @@ block0(v0: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
@@ -20,7 +20,7 @@ block0(v0: i64):
 ;   callind a3
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -50,7 +50,7 @@ block0(v0: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
@@ -60,7 +60,7 @@ block0(v0: i32):
 ;   callind a5
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -108,7 +108,7 @@ block0(v0: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
@@ -118,7 +118,7 @@ block0(v0: i32):
 ;   callind a5
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -167,19 +167,17 @@ block0(v0: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   sd s3,-8(sp)
-;   add sp,-16
+;   addi sp,sp,-32
+;   sd s1,24(sp)
 ; block0:
 ;   li a7,42
-;   add sp,-16
-;   virtual_sp_offset_adj +16
-;   slli a5,a0,56; srai a5,a5,56
-;   sd a5,0(sp)
-;   load_sym s3,%g+0
+;   slli a3,a0,56; srai a3,a3,56
+;   sd a3,0(sp)
+;   load_sym s1,%g+0
 ;   mv a0,a7
 ;   mv a1,a7
 ;   mv a2,a7
@@ -187,14 +185,12 @@ block0(v0: i8):
 ;   mv a4,a7
 ;   mv a5,a7
 ;   mv a6,a7
-;   callind s3
-;   add sp,+16
-;   virtual_sp_offset_adj -16
-;   add sp,+16
-;   ld s3,-8(sp)
+;   callind s1
+;   ld s1,24(sp)
+;   addi sp,sp,32
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -203,16 +199,15 @@ block0(v0: i8):
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   sd s3, -8(sp)
-;   addi sp, sp, -0x10
+;   addi sp, sp, -0x20
+;   sd s1, 0x18(sp)
 ; block1: ; offset 0x18
 ;   addi a7, zero, 0x2a
-;   addi sp, sp, -0x10
-;   slli a5, a0, 0x38
-;   srai a5, a5, 0x38
-;   sd a5, 0(sp)
-;   auipc s3, 0
-;   ld s3, 0xc(s3)
+;   slli a3, a0, 0x38
+;   srai a3, a3, 0x38
+;   sd a3, 0(sp)
+;   auipc s1, 0
+;   ld s1, 0xc(s1)
 ;   j 0xc
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %g 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
@@ -223,10 +218,9 @@ block0(v0: i8):
 ;   mv a4, a7
 ;   mv a5, a7
 ;   mv a6, a7
-;   jalr s3
-;   addi sp, sp, 0x10
-;   addi sp, sp, 0x10
-;   ld s3, -8(sp)
+;   jalr s1
+;   ld s1, 0x18(sp)
+;   addi sp, sp, 0x20
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -290,14 +284,14 @@ block0:
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   fsd fs0,-8(sp)
-;   fsd fs2,-16(sp)
-;   fsd fs3,-24(sp)
-;   add sp,-32
+;   addi sp,sp,-32
+;   fsd fs0,24(sp)
+;   fsd fs2,16(sp)
+;   fsd fs4,8(sp)
 ; block0:
 ;   load_sym a3,%g0+0
 ;   callind a3
@@ -307,7 +301,7 @@ block0:
 ;   fmv.d fs2,fa0
 ;   load_sym a3,%g1+0
 ;   callind a3
-;   fmv.d fs3,fa0
+;   fmv.d fs4,fa0
 ;   load_sym a3,%g2+0
 ;   callind a3
 ;   load_sym a4,%g3+0
@@ -317,15 +311,15 @@ block0:
 ;   fmv.d fa0,fs2
 ;   callind a5
 ;   load_sym a0,%g4+0
-;   fmv.d fa0,fs3
+;   fmv.d fa0,fs4
 ;   callind a0
-;   add sp,+32
-;   fld fs0,-8(sp)
-;   fld fs2,-16(sp)
-;   fld fs3,-24(sp)
+;   fld fs0,24(sp)
+;   fld fs2,16(sp)
+;   fld fs4,8(sp)
+;   addi sp,sp,32
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -334,10 +328,10 @@ block0:
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   fsd fs0, -8(sp)
-;   fsd fs2, -0x10(sp)
-;   fsd fs3, -0x18(sp)
 ;   addi sp, sp, -0x20
+;   fsd fs0, 0x18(sp)
+;   fsd fs2, 0x10(sp)
+;   fsd fs4, 8(sp)
 ; block1: ; offset 0x20
 ;   auipc a3, 0
 ;   ld a3, 0xc(a3)
@@ -359,7 +353,7 @@ block0:
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %g1 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
 ;   jalr a3
-;   fmv.d fs3, fa0
+;   fmv.d fs4, fa0
 ;   auipc a3, 0
 ;   ld a3, 0xc(a3)
 ;   j 0xc
@@ -385,12 +379,12 @@ block0:
 ;   j 0xc
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %g4 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   fmv.d fa0, fs3
+;   fmv.d fa0, fs4
 ;   jalr a0
+;   fld fs0, 0x18(sp)
+;   fld fs2, 0x10(sp)
+;   fld fs4, 8(sp)
 ;   addi sp, sp, 0x20
-;   fld fs0, -8(sp)
-;   fld fs2, -0x10(sp)
-;   fld fs3, -0x18(sp)
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -423,19 +417,19 @@ block0(v0: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   mv a1,a0
 ;   li a2,42
 ;   load_sym a4,%f11+0
+;   mv a1,a0
 ;   mv a0,a2
 ;   callind a4
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -445,13 +439,13 @@ block0(v0: i64):
 ;   sd s0, 0(sp)
 ;   mv s0, sp
 ; block1: ; offset 0x10
-;   mv a1, a0
 ;   addi a2, zero, 0x2a
 ;   auipc a4, 0
 ;   ld a4, 0xc(a4)
 ;   j 0xc
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %f11 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
+;   mv a1, a0
 ;   mv a0, a2
 ;   jalr a4
 ;   ld ra, 8(sp)
@@ -486,19 +480,19 @@ block0(v0: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   mv a1,a0
 ;   li a2,42
 ;   load_sym a4,%f12+0
+;   mv a1,a0
 ;   mv a0,a2
 ;   callind a4
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -508,13 +502,13 @@ block0(v0: i64):
 ;   sd s0, 0(sp)
 ;   mv s0, sp
 ; block1: ; offset 0x10
-;   mv a1, a0
 ;   addi a2, zero, 0x2a
 ;   auipc a4, 0
 ;   ld a4, 0xc(a4)
 ;   j 0xc
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %f12 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
+;   mv a1, a0
 ;   mv a0, a2
 ;   jalr a4
 ;   ld ra, 8(sp)
@@ -549,19 +543,19 @@ block0(v0: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   mv a1,a0
 ;   li a2,42
 ;   load_sym a4,%f13+0
+;   mv a1,a0
 ;   mv a0,a2
 ;   callind a4
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -571,13 +565,13 @@ block0(v0: i64):
 ;   sd s0, 0(sp)
 ;   mv s0, sp
 ; block1: ; offset 0x10
-;   mv a1, a0
 ;   addi a2, zero, 0x2a
 ;   auipc a4, 0
 ;   ld a4, 0xc(a4)
 ;   j 0xc
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %f13 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
+;   mv a1, a0
 ;   mv a0, a2
 ;   jalr a4
 ;   ld ra, 8(sp)
@@ -591,16 +585,16 @@ block0(v0: i128, v1: i128, v2: i128, v3: i64, v4: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
+;   ld a1,-16(incoming_arg)
 ;   mv a0,a7
-;   ld a1,16(fp)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -610,8 +604,8 @@ block0(v0: i128, v1: i128, v2: i128, v3: i64, v4: i128):
 ;   sd s0, 0(sp)
 ;   mv s0, sp
 ; block1: ; offset 0x10
+;   ld a1, 0x10(sp)
 ;   mv a0, a7
-;   ld a1, 0x10(s0)
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -626,33 +620,27 @@ block0(v0: i128, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   sd s3,-8(sp)
-;   add sp,-16
+;   addi sp,sp,-32
+;   sd s1,24(sp)
 ; block0:
-;   mv a7,a0
-;   mv a6,a2
-;   add sp,-16
-;   virtual_sp_offset_adj +16
 ;   sd a1,0(sp)
+;   load_sym s1,%f14+0
 ;   mv a5,a1
-;   load_sym s3,%f14+0
-;   mv a1,a5
-;   mv a3,a5
-;   mv a0,a7
+;   mv a6,a2
+;   mv a7,a0
 ;   mv a2,a7
+;   mv a3,a5
 ;   mv a4,a7
-;   callind s3
-;   add sp,+16
-;   virtual_sp_offset_adj -16
-;   add sp,+16
-;   ld s3,-8(sp)
+;   callind s1
+;   ld s1,24(sp)
+;   addi sp,sp,32
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -661,28 +649,24 @@ block0(v0: i128, v1: i64):
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   sd s3, -8(sp)
-;   addi sp, sp, -0x10
+;   addi sp, sp, -0x20
+;   sd s1, 0x18(sp)
 ; block1: ; offset 0x18
-;   mv a7, a0
-;   mv a6, a2
-;   addi sp, sp, -0x10
 ;   sd a1, 0(sp)
-;   mv a5, a1
-;   auipc s3, 0
-;   ld s3, 0xc(s3)
+;   auipc s1, 0
+;   ld s1, 0xc(s1)
 ;   j 0xc
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %f14 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   mv a1, a5
-;   mv a3, a5
-;   mv a0, a7
+;   mv a5, a1
+;   mv a6, a2
+;   mv a7, a0
 ;   mv a2, a7
+;   mv a3, a5
 ;   mv a4, a7
-;   jalr s3
-;   addi sp, sp, 0x10
-;   addi sp, sp, 0x10
-;   ld s3, -8(sp)
+;   jalr s1
+;   ld s1, 0x18(sp)
+;   addi sp, sp, 0x20
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -694,16 +678,16 @@ block0(v0: i128, v1: i128, v2: i128, v3: i64, v4: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
+;   ld a1,-16(incoming_arg)
 ;   mv a0,a7
-;   ld a1,16(fp)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -713,8 +697,8 @@ block0(v0: i128, v1: i128, v2: i128, v3: i64, v4: i128):
 ;   sd s0, 0(sp)
 ;   mv s0, sp
 ; block1: ; offset 0x10
+;   ld a1, 0x10(sp)
 ;   mv a0, a7
-;   ld a1, 0x10(s0)
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -729,33 +713,27 @@ block0(v0: i128, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   sd s3,-8(sp)
-;   add sp,-16
+;   addi sp,sp,-32
+;   sd s1,24(sp)
 ; block0:
-;   mv a7,a0
-;   mv a6,a2
-;   add sp,-16
-;   virtual_sp_offset_adj +16
 ;   sd a1,0(sp)
+;   load_sym s1,%f15+0
 ;   mv a5,a1
-;   load_sym s3,%f15+0
-;   mv a1,a5
-;   mv a3,a5
-;   mv a0,a7
+;   mv a6,a2
+;   mv a7,a0
 ;   mv a2,a7
+;   mv a3,a5
 ;   mv a4,a7
-;   callind s3
-;   add sp,+16
-;   virtual_sp_offset_adj -16
-;   add sp,+16
-;   ld s3,-8(sp)
+;   callind s1
+;   ld s1,24(sp)
+;   addi sp,sp,32
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -764,28 +742,24 @@ block0(v0: i128, v1: i64):
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   sd s3, -8(sp)
-;   addi sp, sp, -0x10
+;   addi sp, sp, -0x20
+;   sd s1, 0x18(sp)
 ; block1: ; offset 0x18
-;   mv a7, a0
-;   mv a6, a2
-;   addi sp, sp, -0x10
 ;   sd a1, 0(sp)
-;   mv a5, a1
-;   auipc s3, 0
-;   ld s3, 0xc(s3)
+;   auipc s1, 0
+;   ld s1, 0xc(s1)
 ;   j 0xc
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %f15 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   mv a1, a5
-;   mv a3, a5
-;   mv a0, a7
+;   mv a5, a1
+;   mv a6, a2
+;   mv a7, a0
 ;   mv a2, a7
+;   mv a3, a5
 ;   mv a4, a7
-;   jalr s3
-;   addi sp, sp, 0x10
-;   addi sp, sp, 0x10
-;   ld s3, -8(sp)
+;   jalr s1
+;   ld s1, 0x18(sp)
+;   addi sp, sp, 0x20
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -820,21 +794,21 @@ block0(v0: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   sd s1,-8(sp)
-;   add sp,-16
+;   addi sp,sp,-16
+;   sd s1,8(sp)
 ; block0:
 ;   mv s1,a0
 ;   call userextname0
 ;   mv a0,s1
-;   add sp,+16
-;   ld s1,-8(sp)
+;   ld s1,8(sp)
+;   addi sp,sp,16
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -843,15 +817,15 @@ block0(v0: i16):
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   sd s1, -8(sp)
 ;   addi sp, sp, -0x10
+;   sd s1, 8(sp)
 ; block1: ; offset 0x18
 ;   mv s1, a0
-;   auipc ra, 0 ; reloc_external RiscvCall u0:0 0
+;   auipc ra, 0 ; reloc_external RiscvCallPlt u0:0 0
 ;   jalr ra
 ;   mv a0, s1
+;   ld s1, 8(sp)
 ;   addi sp, sp, 0x10
-;   ld s1, -8(sp)
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
diff --git a/cranelift/filetests/filetests/isa/riscv64/ceil.clif b/cranelift/filetests/filetests/isa/riscv64/ceil.clif
new file mode 100644
index 000000000000..8958ea25e6e9
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/ceil.clif
@@ -0,0 +1,78 @@
+test compile precise-output
+set unwind_info=false
+target riscv64
+
+
+function %ceil_f32(f32) -> f32 {
+block0(v0: f32):
+  v1 = ceil v0
+  return v1
+}
+
+; VCode:
+; block0:
+;   lui a2,307200
+;   fmv.w.x fa4,a2
+;   fabs.s fa1,fa0
+;   flt.s a2,fa1,fa4
+;   fcvt.w.s a4,fa0,rup
+;   fcvt.s.w fa1,a4,rup
+;   fsgnj.s fa2,fa1,fa0
+;   fmv.w.x fa4,zero
+;   fadd.s fa0,fa0,fa4,rne
+;   select fa0,fa0,fa2##condition=(a2 eq zero)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   lui a2, 0x4b000
+;   fmv.w.x fa4, a2
+;   fabs.s fa1, fa0
+;   flt.s a2, fa1, fa4
+;   fcvt.w.s a4, fa0, rup ; trap: bad_toint
+;   fcvt.s.w fa1, a4, rup
+;   fsgnj.s fa2, fa1, fa0
+;   fmv.w.x fa4, zero
+;   fadd.s fa0, fa0, fa4, rne
+;   beqz a2, 8
+;   fmv.d fa0, fa2
+;   ret
+
+function %ceil_f64(f64) -> f64 {
+block0(v0: f64):
+  v1 = ceil v0
+  return v1
+}
+
+; VCode:
+; block0:
+;   lui a2,1075
+;   slli a4,a2,40
+;   fmv.d.x fa1,a4
+;   fabs.d fa2,fa0
+;   flt.d a4,fa2,fa1
+;   fcvt.l.d a0,fa0,rup
+;   fcvt.d.l fa2,a0,rup
+;   fsgnj.d fa4,fa2,fa0
+;   fmv.d.x fa1,zero
+;   fadd.d fa2,fa0,fa1,rne
+;   select fa0,fa2,fa4##condition=(a4 eq zero)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   lui a2, 0x433
+;   slli a4, a2, 0x28
+;   fmv.d.x fa1, a4
+;   fabs.d fa2, fa0
+;   flt.d a4, fa2, fa1
+;   fcvt.l.d a0, fa0, rup ; trap: bad_toint
+;   fcvt.d.l fa2, a0, rup
+;   fsgnj.d fa4, fa2, fa0
+;   fmv.d.x fa1, zero
+;   fadd.d fa2, fa0, fa1, rne
+;   fmv.d fa0, fa2
+;   beqz a4, 8
+;   fmv.d fa0, fa4
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/cls-zbb.clif b/cranelift/filetests/filetests/isa/riscv64/cls-zbb.clif
index 1477bb8ba5d4..229b157beedf 100644
--- a/cranelift/filetests/filetests/isa/riscv64/cls-zbb.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/cls-zbb.clif
@@ -22,9 +22,8 @@ block0(v0: i8):
 ; block0: ; offset 0x0
 ;   .byte 0x13, 0x16, 0x45, 0x60
 ;   not a4, a2
-;   bgez a2, 0xc
 ;   mv a0, a4
-;   j 8
+;   bltz a2, 8
 ;   mv a0, a2
 ;   .byte 0x13, 0x16, 0x05, 0x60
 ;   addi a0, a2, -0x39
@@ -49,9 +48,8 @@ block0(v0: i16):
 ; block0: ; offset 0x0
 ;   .byte 0x13, 0x16, 0x55, 0x60
 ;   not a4, a2
-;   bgez a2, 0xc
 ;   mv a0, a4
-;   j 8
+;   bltz a2, 8
 ;   mv a0, a2
 ;   .byte 0x13, 0x16, 0x05, 0x60
 ;   addi a0, a2, -0x31
@@ -76,9 +74,8 @@ block0(v0: i32):
 ; block0: ; offset 0x0
 ;   sext.w a2, a0
 ;   not a4, a2
-;   bgez a2, 0xc
 ;   mv a0, a4
-;   j 8
+;   bltz a2, 8
 ;   mv a0, a2
 ;   .byte 0x13, 0x16, 0x05, 0x60
 ;   addi a0, a2, -0x21
@@ -101,9 +98,8 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   not a2, a0
-;   bgez a0, 0xc
 ;   mv a4, a2
-;   j 8
+;   bltz a0, 8
 ;   mv a4, a0
 ;   .byte 0x13, 0x15, 0x07, 0x60
 ;   addi a0, a0, -1
@@ -123,8 +119,8 @@ block0(v0: i128):
 ;   select a3,a2,a1##condition=(a1 slt zero)
 ;   clz a0,a3
 ;   clz a1,a5
-;   select a3,a1,zero##condition=(a3 eq zero)
-;   add a5,a0,a3
+;   select a4,a1,zero##condition=(a3 eq zero)
+;   add a5,a0,a4
 ;   addi a0,a5,-1
 ;   li a1,0
 ;   ret
@@ -132,22 +128,19 @@ block0(v0: i128):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   not a3, a0
-;   bgez a1, 0xc
 ;   mv a5, a3
-;   j 8
+;   bltz a1, 8
 ;   mv a5, a0
 ;   not a2, a1
-;   bgez a1, 0xc
 ;   mv a3, a2
-;   j 8
+;   bltz a1, 8
 ;   mv a3, a1
 ;   .byte 0x13, 0x95, 0x06, 0x60
 ;   .byte 0x93, 0x95, 0x07, 0x60
-;   bnez a3, 0xc
-;   mv a3, a1
-;   j 8
-;   mv a3, zero
-;   add a5, a0, a3
+;   mv a4, a1
+;   beqz a3, 8
+;   mv a4, zero
+;   add a5, a0, a4
 ;   addi a0, a5, -1
 ;   mv a1, zero
 ;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/clz-zbb.clif b/cranelift/filetests/filetests/isa/riscv64/clz-zbb.clif
index fda9f412930d..41789817995e 100644
--- a/cranelift/filetests/filetests/isa/riscv64/clz-zbb.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/clz-zbb.clif
@@ -84,8 +84,8 @@ block0(v0: i128):
 ; block0:
 ;   clz a3,a1
 ;   clz a5,a0
-;   select a1,a5,zero##condition=(a1 eq zero)
-;   add a0,a3,a1
+;   select a2,a5,zero##condition=(a1 eq zero)
+;   add a0,a3,a2
 ;   li a1,0
 ;   ret
 ;
@@ -93,11 +93,10 @@ block0(v0: i128):
 ; block0: ; offset 0x0
 ;   .byte 0x93, 0x96, 0x05, 0x60
 ;   .byte 0x93, 0x17, 0x05, 0x60
-;   bnez a1, 0xc
-;   mv a1, a5
-;   j 8
-;   mv a1, zero
-;   add a0, a3, a1
+;   mv a2, a5
+;   beqz a1, 8
+;   mv a2, zero
+;   add a0, a3, a2
 ;   mv a1, zero
 ;   ret
 
diff --git a/cranelift/filetests/filetests/isa/riscv64/condbr.clif b/cranelift/filetests/filetests/isa/riscv64/condbr.clif
index c9c93c2016e7..6912c0b5502e 100644
--- a/cranelift/filetests/filetests/isa/riscv64/condbr.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/condbr.clif
@@ -10,15 +10,14 @@ block0(v0: i64, v1: i64):
 
 ; VCode:
 ; block0:
-;   eq a0,a0,a1##ty=i64
+;   xor a3,a0,a1
+;   seqz a0,a3
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   bne a0, a1, 0xc
-;   addi a0, zero, 1
-;   j 8
-;   mv a0, zero
+;   xor a3, a0, a1
+;   seqz a0, a3
 ;   ret
 
 function %icmp_eq_i128(i128, i128) -> i8 {
@@ -29,16 +28,18 @@ block0(v0: i128, v1: i128):
 
 ; VCode:
 ; block0:
-;   eq a0,[a0,a1],[a2,a3]##ty=i128
+;   xor a5,a0,a2
+;   xor a1,a1,a3
+;   or a3,a5,a1
+;   seqz a0,a3
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   bne a1, a3, 0x10
-;   bne a0, a2, 0xc
-;   addi a0, zero, 1
-;   j 8
-;   mv a0, zero
+;   xor a5, a0, a2
+;   xor a1, a1, a3
+;   or a3, a5, a1
+;   seqz a0, a3
 ;   ret
 
 function %icmp_ne_i128(i128, i128) -> i8 {
@@ -49,16 +50,18 @@ block0(v0: i128, v1: i128):
 
 ; VCode:
 ; block0:
-;   ne a0,[a0,a1],[a2,a3]##ty=i128
+;   xor a5,a0,a2
+;   xor a1,a1,a3
+;   or a3,a5,a1
+;   sltu a0,zero,a3
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   bne a1, a3, 8
-;   beq a0, a2, 0xc
-;   addi a0, zero, 1
-;   j 8
-;   mv a0, zero
+;   xor a5, a0, a2
+;   xor a1, a1, a3
+;   or a3, a5, a1
+;   snez a0, a3
 ;   ret
 
 function %icmp_slt_i128(i128, i128) -> i8 {
@@ -69,17 +72,20 @@ block0(v0: i128, v1: i128):
 
 ; VCode:
 ; block0:
-;   slt a0,[a0,a1],[a2,a3]##ty=i128
+;   slt a5,a1,a3
+;   sltu a2,a0,a2
+;   xor a3,a1,a3
+;   select a0,a2,a5##condition=(a3 eq zero)
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   blt a1, a3, 0xc
-;   bne a1, a3, 0x10
-;   bgeu a0, a2, 0xc
-;   addi a0, zero, 1
-;   j 8
-;   mv a0, zero
+;   slt a5, a1, a3
+;   sltu a2, a0, a2
+;   xor a3, a1, a3
+;   mv a0, a2
+;   beqz a3, 8
+;   mv a0, a5
 ;   ret
 
 function %icmp_ult_i128(i128, i128) -> i8 {
@@ -90,17 +96,20 @@ block0(v0: i128, v1: i128):
 
 ; VCode:
 ; block0:
-;   ult a0,[a0,a1],[a2,a3]##ty=i128
+;   sltu a5,a1,a3
+;   sltu a2,a0,a2
+;   xor a3,a1,a3
+;   select a0,a2,a5##condition=(a3 eq zero)
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   bltu a1, a3, 0xc
-;   bne a1, a3, 0x10
-;   bgeu a0, a2, 0xc
-;   addi a0, zero, 1
-;   j 8
-;   mv a0, zero
+;   sltu a5, a1, a3
+;   sltu a2, a0, a2
+;   xor a3, a1, a3
+;   mv a0, a2
+;   beqz a3, 8
+;   mv a0, a5
 ;   ret
 
 function %icmp_sle_i128(i128, i128) -> i8 {
@@ -111,17 +120,21 @@ block0(v0: i128, v1: i128):
 
 ; VCode:
 ; block0:
-;   sle a0,[a0,a1],[a2,a3]##ty=i128
+;   slt a5,a3,a1
+;   sltu a2,a2,a0
+;   xor a3,a3,a1
+;   select a5,a2,a5##condition=(a3 eq zero)
+;   xori a0,a5,1
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   blt a1, a3, 0xc
-;   bne a1, a3, 0x10
-;   bltu a2, a0, 0xc
-;   addi a0, zero, 1
-;   j 8
-;   mv a0, zero
+;   slt a5, a3, a1
+;   sltu a2, a2, a0
+;   xor a3, a3, a1
+;   bnez a3, 8
+;   mv a5, a2
+;   xori a0, a5, 1
 ;   ret
 
 function %icmp_ule_i128(i128, i128) -> i8 {
@@ -132,17 +145,21 @@ block0(v0: i128, v1: i128):
 
 ; VCode:
 ; block0:
-;   ule a0,[a0,a1],[a2,a3]##ty=i128
+;   sltu a5,a3,a1
+;   sltu a2,a2,a0
+;   xor a3,a3,a1
+;   select a5,a2,a5##condition=(a3 eq zero)
+;   xori a0,a5,1
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   bltu a1, a3, 0xc
-;   bne a1, a3, 0x10
-;   bltu a2, a0, 0xc
-;   addi a0, zero, 1
-;   j 8
-;   mv a0, zero
+;   sltu a5, a3, a1
+;   sltu a2, a2, a0
+;   xor a3, a3, a1
+;   bnez a3, 8
+;   mv a5, a2
+;   xori a0, a5, 1
 ;   ret
 
 function %icmp_sgt_i128(i128, i128) -> i8 {
@@ -153,17 +170,20 @@ block0(v0: i128, v1: i128):
 
 ; VCode:
 ; block0:
-;   sgt a0,[a0,a1],[a2,a3]##ty=i128
+;   slt a5,a3,a1
+;   sltu a2,a2,a0
+;   xor a3,a3,a1
+;   select a0,a2,a5##condition=(a3 eq zero)
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   blt a3, a1, 0xc
-;   bne a1, a3, 0x10
-;   bgeu a2, a0, 0xc
-;   addi a0, zero, 1
-;   j 8
-;   mv a0, zero
+;   slt a5, a3, a1
+;   sltu a2, a2, a0
+;   xor a3, a3, a1
+;   mv a0, a2
+;   beqz a3, 8
+;   mv a0, a5
 ;   ret
 
 function %icmp_ugt_i128(i128, i128) -> i8 {
@@ -174,17 +194,20 @@ block0(v0: i128, v1: i128):
 
 ; VCode:
 ; block0:
-;   ugt a0,[a0,a1],[a2,a3]##ty=i128
+;   sltu a5,a3,a1
+;   sltu a2,a2,a0
+;   xor a3,a3,a1
+;   select a0,a2,a5##condition=(a3 eq zero)
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   bltu a3, a1, 0xc
-;   bne a1, a3, 0x10
-;   bgeu a2, a0, 0xc
-;   addi a0, zero, 1
-;   j 8
-;   mv a0, zero
+;   sltu a5, a3, a1
+;   sltu a2, a2, a0
+;   xor a3, a3, a1
+;   mv a0, a2
+;   beqz a3, 8
+;   mv a0, a5
 ;   ret
 
 function %icmp_sge_i128(i128, i128) -> i8 {
@@ -195,17 +218,21 @@ block0(v0: i128, v1: i128):
 
 ; VCode:
 ; block0:
-;   sge a0,[a0,a1],[a2,a3]##ty=i128
+;   slt a5,a1,a3
+;   sltu a2,a0,a2
+;   xor a3,a1,a3
+;   select a5,a2,a5##condition=(a3 eq zero)
+;   xori a0,a5,1
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   blt a3, a1, 0xc
-;   bne a1, a3, 0x10
-;   bltu a0, a2, 0xc
-;   addi a0, zero, 1
-;   j 8
-;   mv a0, zero
+;   slt a5, a1, a3
+;   sltu a2, a0, a2
+;   xor a3, a1, a3
+;   bnez a3, 8
+;   mv a5, a2
+;   xori a0, a5, 1
 ;   ret
 
 function %icmp_uge_i128(i128, i128) -> i8 {
@@ -216,17 +243,21 @@ block0(v0: i128, v1: i128):
 
 ; VCode:
 ; block0:
-;   uge a0,[a0,a1],[a2,a3]##ty=i128
+;   sltu a5,a1,a3
+;   sltu a2,a0,a2
+;   xor a3,a1,a3
+;   select a5,a2,a5##condition=(a3 eq zero)
+;   xori a0,a5,1
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   bltu a3, a1, 0xc
-;   bne a1, a3, 0x10
-;   bltu a0, a2, 0xc
-;   addi a0, zero, 1
-;   j 8
-;   mv a0, zero
+;   sltu a5, a1, a3
+;   sltu a2, a0, a2
+;   xor a3, a1, a3
+;   bnez a3, 8
+;   mv a5, a2
+;   xori a0, a5, 1
 ;   ret
 
 function %f(i64, i64) -> i64 {
@@ -326,7 +357,10 @@ block1:
 
 ; VCode:
 ; block0:
-;   eq a5,[a0,a1],[a2,a3]##ty=i128
+;   xor a5,a0,a2
+;   xor a1,a1,a3
+;   or a3,a5,a1
+;   seqz a5,a3
 ;   bne a5,zero,taken(label1),not_taken(label2)
 ; block1:
 ;   j label3
@@ -337,12 +371,11 @@ block1:
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   bne a1, a3, 0x10
-;   bne a0, a2, 0xc
-;   addi a5, zero, 1
-;   j 8
-;   mv a5, zero
-; block1: ; offset 0x14
+;   xor a5, a0, a2
+;   xor a1, a1, a3
+;   or a3, a5, a1
+;   seqz a5, a3
+; block1: ; offset 0x10
 ;   ret
 
 function %i128_bricmp_ne(i128, i128) {
@@ -356,7 +389,10 @@ block1:
 
 ; VCode:
 ; block0:
-;   ne a5,[a0,a1],[a2,a3]##ty=i128
+;   xor a5,a0,a2
+;   xor a1,a1,a3
+;   or a3,a5,a1
+;   sltu a5,zero,a3
 ;   bne a5,zero,taken(label1),not_taken(label2)
 ; block1:
 ;   j label3
@@ -367,12 +403,11 @@ block1:
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   bne a1, a3, 8
-;   beq a0, a2, 0xc
-;   addi a5, zero, 1
-;   j 8
-;   mv a5, zero
-; block1: ; offset 0x14
+;   xor a5, a0, a2
+;   xor a1, a1, a3
+;   or a3, a5, a1
+;   snez a5, a3
+; block1: ; offset 0x10
 ;   ret
 
 function %i128_bricmp_slt(i128, i128) {
@@ -386,7 +421,10 @@ block1:
 
 ; VCode:
 ; block0:
-;   slt a5,[a0,a1],[a2,a3]##ty=i128
+;   slt a5,a1,a3
+;   sltu a2,a0,a2
+;   xor a3,a1,a3
+;   select a5,a2,a5##condition=(a3 eq zero)
 ;   bne a5,zero,taken(label1),not_taken(label2)
 ; block1:
 ;   j label3
@@ -397,13 +435,12 @@ block1:
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   blt a1, a3, 0xc
-;   bne a1, a3, 0x10
-;   bgeu a0, a2, 0xc
-;   addi a5, zero, 1
-;   j 8
-;   mv a5, zero
-; block1: ; offset 0x18
+;   slt a5, a1, a3
+;   sltu a2, a0, a2
+;   xor a3, a1, a3
+;   bnez a3, 8
+;   mv a5, a2
+; block1: ; offset 0x14
 ;   ret
 
 function %i128_bricmp_ult(i128, i128) {
@@ -417,7 +454,10 @@ block1:
 
 ; VCode:
 ; block0:
-;   ult a5,[a0,a1],[a2,a3]##ty=i128
+;   sltu a5,a1,a3
+;   sltu a2,a0,a2
+;   xor a3,a1,a3
+;   select a5,a2,a5##condition=(a3 eq zero)
 ;   bne a5,zero,taken(label1),not_taken(label2)
 ; block1:
 ;   j label3
@@ -428,13 +468,12 @@ block1:
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   bltu a1, a3, 0xc
-;   bne a1, a3, 0x10
-;   bgeu a0, a2, 0xc
-;   addi a5, zero, 1
-;   j 8
-;   mv a5, zero
-; block1: ; offset 0x18
+;   sltu a5, a1, a3
+;   sltu a2, a0, a2
+;   xor a3, a1, a3
+;   bnez a3, 8
+;   mv a5, a2
+; block1: ; offset 0x14
 ;   ret
 
 function %i128_bricmp_sle(i128, i128) {
@@ -448,8 +487,12 @@ block1:
 
 ; VCode:
 ; block0:
-;   sle a5,[a0,a1],[a2,a3]##ty=i128
-;   bne a5,zero,taken(label1),not_taken(label2)
+;   slt a5,a3,a1
+;   sltu a2,a2,a0
+;   xor a3,a3,a1
+;   select a5,a2,a5##condition=(a3 eq zero)
+;   xori a1,a5,1
+;   bne a1,zero,taken(label1),not_taken(label2)
 ; block1:
 ;   j label3
 ; block2:
@@ -459,12 +502,12 @@ block1:
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   blt a1, a3, 0xc
-;   bne a1, a3, 0x10
-;   bltu a2, a0, 0xc
-;   addi a5, zero, 1
-;   j 8
-;   mv a5, zero
+;   slt a5, a3, a1
+;   sltu a2, a2, a0
+;   xor a3, a3, a1
+;   bnez a3, 8
+;   mv a5, a2
+;   xori a1, a5, 1
 ; block1: ; offset 0x18
 ;   ret
 
@@ -479,8 +522,12 @@ block1:
 
 ; VCode:
 ; block0:
-;   ule a5,[a0,a1],[a2,a3]##ty=i128
-;   bne a5,zero,taken(label1),not_taken(label2)
+;   sltu a5,a3,a1
+;   sltu a2,a2,a0
+;   xor a3,a3,a1
+;   select a5,a2,a5##condition=(a3 eq zero)
+;   xori a1,a5,1
+;   bne a1,zero,taken(label1),not_taken(label2)
 ; block1:
 ;   j label3
 ; block2:
@@ -490,12 +537,12 @@ block1:
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   bltu a1, a3, 0xc
-;   bne a1, a3, 0x10
-;   bltu a2, a0, 0xc
-;   addi a5, zero, 1
-;   j 8
-;   mv a5, zero
+;   sltu a5, a3, a1
+;   sltu a2, a2, a0
+;   xor a3, a3, a1
+;   bnez a3, 8
+;   mv a5, a2
+;   xori a1, a5, 1
 ; block1: ; offset 0x18
 ;   ret
 
@@ -510,7 +557,10 @@ block1:
 
 ; VCode:
 ; block0:
-;   sgt a5,[a0,a1],[a2,a3]##ty=i128
+;   slt a5,a3,a1
+;   sltu a2,a2,a0
+;   xor a3,a3,a1
+;   select a5,a2,a5##condition=(a3 eq zero)
 ;   bne a5,zero,taken(label1),not_taken(label2)
 ; block1:
 ;   j label3
@@ -521,13 +571,12 @@ block1:
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   blt a3, a1, 0xc
-;   bne a1, a3, 0x10
-;   bgeu a2, a0, 0xc
-;   addi a5, zero, 1
-;   j 8
-;   mv a5, zero
-; block1: ; offset 0x18
+;   slt a5, a3, a1
+;   sltu a2, a2, a0
+;   xor a3, a3, a1
+;   bnez a3, 8
+;   mv a5, a2
+; block1: ; offset 0x14
 ;   ret
 
 function %i128_bricmp_ugt(i128, i128) {
@@ -541,7 +590,10 @@ block1:
 
 ; VCode:
 ; block0:
-;   ugt a5,[a0,a1],[a2,a3]##ty=i128
+;   sltu a5,a3,a1
+;   sltu a2,a2,a0
+;   xor a3,a3,a1
+;   select a5,a2,a5##condition=(a3 eq zero)
 ;   bne a5,zero,taken(label1),not_taken(label2)
 ; block1:
 ;   j label3
@@ -552,13 +604,12 @@ block1:
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   bltu a3, a1, 0xc
-;   bne a1, a3, 0x10
-;   bgeu a2, a0, 0xc
-;   addi a5, zero, 1
-;   j 8
-;   mv a5, zero
-; block1: ; offset 0x18
+;   sltu a5, a3, a1
+;   sltu a2, a2, a0
+;   xor a3, a3, a1
+;   bnez a3, 8
+;   mv a5, a2
+; block1: ; offset 0x14
 ;   ret
 
 function %i128_bricmp_sge(i128, i128) {
@@ -572,8 +623,12 @@ block1:
 
 ; VCode:
 ; block0:
-;   sge a5,[a0,a1],[a2,a3]##ty=i128
-;   bne a5,zero,taken(label1),not_taken(label2)
+;   slt a5,a1,a3
+;   sltu a2,a0,a2
+;   xor a3,a1,a3
+;   select a5,a2,a5##condition=(a3 eq zero)
+;   xori a1,a5,1
+;   bne a1,zero,taken(label1),not_taken(label2)
 ; block1:
 ;   j label3
 ; block2:
@@ -583,12 +638,12 @@ block1:
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   blt a3, a1, 0xc
-;   bne a1, a3, 0x10
-;   bltu a0, a2, 0xc
-;   addi a5, zero, 1
-;   j 8
-;   mv a5, zero
+;   slt a5, a1, a3
+;   sltu a2, a0, a2
+;   xor a3, a1, a3
+;   bnez a3, 8
+;   mv a5, a2
+;   xori a1, a5, 1
 ; block1: ; offset 0x18
 ;   ret
 
@@ -603,8 +658,12 @@ block1:
 
 ; VCode:
 ; block0:
-;   uge a5,[a0,a1],[a2,a3]##ty=i128
-;   bne a5,zero,taken(label1),not_taken(label2)
+;   sltu a5,a1,a3
+;   sltu a2,a0,a2
+;   xor a3,a1,a3
+;   select a5,a2,a5##condition=(a3 eq zero)
+;   xori a1,a5,1
+;   bne a1,zero,taken(label1),not_taken(label2)
 ; block1:
 ;   j label3
 ; block2:
@@ -614,12 +673,12 @@ block1:
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   bltu a3, a1, 0xc
-;   bne a1, a3, 0x10
-;   bltu a0, a2, 0xc
-;   addi a5, zero, 1
-;   j 8
-;   mv a5, zero
+;   sltu a5, a1, a3
+;   sltu a2, a0, a2
+;   xor a3, a1, a3
+;   bnez a3, 8
+;   mv a5, a2
+;   xori a1, a5, 1
 ; block1: ; offset 0x18
 ;   ret
 
diff --git a/cranelift/filetests/filetests/isa/riscv64/condops.clif b/cranelift/filetests/filetests/isa/riscv64/condops.clif
index 6dbba5087c05..f134e0dde614 100644
--- a/cranelift/filetests/filetests/isa/riscv64/condops.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/condops.clif
@@ -23,9 +23,8 @@ block0(v0: i8, v1: i64, v2: i64):
 ;   addi a3, zero, 0x2a
 ;   andi a5, a0, 0xff
 ;   andi a3, a3, 0xff
-;   bne a5, a3, 0xc
 ;   mv a0, a1
-;   j 8
+;   beq a5, a3, 8
 ;   mv a0, a2
 ;   ret
 
@@ -38,21 +37,18 @@ block0(v0: i8):
 
 ; VCode:
 ; block0:
-;   li a5,42
-;   andi a3,a0,255
-;   andi a5,a5,255
-;   eq a0,a3,a5##ty=i8
+;   slli a2,a0,56
+;   srai a4,a2,56
+;   xori a0,a4,42
+;   seqz a0,a0
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a5, zero, 0x2a
-;   andi a3, a0, 0xff
-;   andi a5, a5, 0xff
-;   bne a3, a5, 0xc
-;   addi a0, zero, 1
-;   j 8
-;   mv a0, zero
+;   slli a2, a0, 0x38
+;   srai a4, a2, 0x38
+;   xori a0, a4, 0x2a
+;   seqz a0, a0
 ;   ret
 
 function %h(i8, i8, i8) -> i8 {
@@ -92,9 +88,8 @@ block0(v0: i8, v1: i8, v2: i8):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   andi a4, a0, 0xff
-;   beqz a4, 0xc
 ;   mv a0, a1
-;   j 8
+;   bnez a4, 8
 ;   mv a0, a2
 ;   ret
 
@@ -119,9 +114,8 @@ block0(v0: i32, v1: i8, v2: i8):
 ;   addi a3, zero, 0x2a
 ;   sext.w a5, a0
 ;   sext.w a3, a3
-;   bne a5, a3, 0xc
 ;   mv a0, a1
-;   j 8
+;   beq a5, a3, 8
 ;   mv a0, a2
 ;   ret
 
@@ -132,21 +126,21 @@ block0(v0: i8, v1: i128, v2: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   sd s4,-8(sp)
-;   add sp,-16
+;   addi sp,sp,-16
+;   sd s4,8(sp)
 ; block0:
 ;   mv s4,a1
 ;   andi a5,a0,255
 ;   select [a0,a1],[s4,a2],[a3,a4]##condition=(a5 ne zero)
-;   add sp,+16
-;   ld s4,-8(sp)
+;   ld s4,8(sp)
+;   addi sp,sp,16
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -155,19 +149,18 @@ block0(v0: i8, v1: i128, v2: i128):
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   sd s4, -8(sp)
 ;   addi sp, sp, -0x10
+;   sd s4, 8(sp)
 ; block1: ; offset 0x18
 ;   mv s4, a1
 ;   andi a5, a0, 0xff
-;   beqz a5, 0x10
 ;   mv a0, s4
 ;   mv a1, a2
-;   j 0xc
+;   bnez a5, 0xc
 ;   mv a0, a3
 ;   mv a1, a4
+;   ld s4, 8(sp)
 ;   addi sp, sp, 0x10
-;   ld s4, -8(sp)
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
diff --git a/cranelift/filetests/filetests/isa/riscv64/constants.clif b/cranelift/filetests/filetests/isa/riscv64/constants.clif
index 3a159071e434..9e81223ee579 100644
--- a/cranelift/filetests/filetests/isa/riscv64/constants.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/constants.clif
@@ -426,14 +426,12 @@ block0:
 
 ; VCode:
 ; block0:
-;   li a0,0
-;   fmv.d.x fa0,a0
+;   fmv.d.x fa0,zero
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mv a0, zero
-;   fmv.d.x fa0, a0
+;   fmv.d.x fa0, zero
 ;   ret
 
 function %f() -> f32 {
@@ -444,14 +442,12 @@ block0:
 
 ; VCode:
 ; block0:
-;   li a0,0
-;   fmv.w.x fa0,a0
+;   fmv.w.x fa0,zero
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mv a0, zero
-;   fmv.w.x fa0, a0
+;   fmv.w.x fa0, zero
 ;   ret
 
 function %f() -> f64 {
diff --git a/cranelift/filetests/filetests/isa/riscv64/ctz-zbb.clif b/cranelift/filetests/filetests/isa/riscv64/ctz-zbb.clif
index d5959eb63d3c..97c6ba309dfa 100644
--- a/cranelift/filetests/filetests/isa/riscv64/ctz-zbb.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/ctz-zbb.clif
@@ -92,9 +92,8 @@ block0(v0: i128):
 ; block0: ; offset 0x0
 ;   .byte 0x93, 0x96, 0x15, 0x60
 ;   .byte 0x93, 0x17, 0x15, 0x60
-;   bnez a0, 0xc
 ;   mv a1, a3
-;   j 8
+;   beqz a0, 8
 ;   mv a1, zero
 ;   add a0, a5, a1
 ;   mv a1, zero
diff --git a/cranelift/filetests/filetests/isa/riscv64/extend.clif b/cranelift/filetests/filetests/isa/riscv64/extend.clif
index 604e31ea5fe9..445671f2c8af 100644
--- a/cranelift/filetests/filetests/isa/riscv64/extend.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/extend.clif
@@ -258,3 +258,21 @@ block0(v0: i8, v1: i64):
 ;   add a0, a0, a1
 ;   ret
 
+
+function %extend_fcmp(f64, f64) -> i64 {
+block0(v0: f64, v1: f64):
+  v3 = fcmp.f64 lt v0, v1
+  v4 = sextend.i64 v3
+  return v4
+}
+
+; VCode:
+; block0:
+;   flt.d a0,fa0,fa1
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   flt.d a0, fa0, fa1
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/f16-bitcast.clif b/cranelift/filetests/filetests/isa/riscv64/f16-bitcast.clif
new file mode 100644
index 000000000000..f7cf54546ef3
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/f16-bitcast.clif
@@ -0,0 +1,35 @@
+test compile precise-output
+target riscv64 has_zfh
+
+function %bitcast_i16_f16(i16) -> f16 fast {
+block0(v0: i16):
+    v1 = bitcast.f16 v0
+    return v1
+}
+
+; VCode:
+; block0:
+;   fmv.h.x fa0,a0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x53, 0x05, 0x05, 0xf4
+;   ret
+
+function %bitcast_f16_i16(f16) -> i16 fast {
+block0(v0: f16):
+    v1 = bitcast.i16 v0
+    return v1
+}
+
+; VCode:
+; block0:
+;   fmv.x.h a0,fa0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x53, 0x05, 0x05, 0xe4
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/f16-fma.clif b/cranelift/filetests/filetests/isa/riscv64/f16-fma.clif
new file mode 100644
index 000000000000..7e3c4c57558b
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/f16-fma.clif
@@ -0,0 +1,74 @@
+test compile precise-output
+set unwind_info=false
+target riscv64 has_zfh
+
+
+function %fmadd(f16, f16, f16) -> f16 {
+block0(v0: f16, v1: f16, v2: f16):
+  v3 = fma v0, v1, v2
+  return v3
+}
+
+; VCode:
+; block0:
+;   fmadd.h fa0,fa0,fa1,fa2,rne
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x43, 0x05, 0xb5, 0x64
+;   ret
+
+
+
+function %fmsub(f16, f16, f16) -> f16 {
+block0(v0: f16, v1: f16, v2: f16):
+    v3 = fneg v2
+    v4 = fma v0, v1, v3
+    return v4
+}
+
+; VCode:
+; block0:
+;   fmsub.h fa0,fa0,fa1,fa2,rne
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x47, 0x05, 0xb5, 0x64
+;   ret
+
+function %fnmsub(f16, f16, f16) -> f16 {
+block0(v0: f16, v1: f16, v2: f16):
+    v3 = fneg v0
+    v4 = fma v3, v1, v2
+    return v4
+}
+
+; VCode:
+; block0:
+;   fnmsub.h fa0,fa0,fa1,fa2,rne
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x4b, 0x05, 0xb5, 0x64
+;   ret
+
+function %fnmadd(f16, f16, f16) -> f16 {
+block0(v0: f16, v1: f16, v2: f16):
+    v3 = fneg v0
+    v4 = fneg v2
+    v5 = fma v3, v1, v4
+    return v5
+}
+
+; VCode:
+; block0:
+;   fnmadd.h fa0,fa0,fa1,fa2,rne
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x4f, 0x05, 0xb5, 0x64
+;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/f16-memory.clif b/cranelift/filetests/filetests/isa/riscv64/f16-memory.clif
new file mode 100644
index 000000000000..166771fc07ce
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/f16-memory.clif
@@ -0,0 +1,125 @@
+test compile precise-output
+target riscv64 has_zfh
+
+function %f16_load(i16) -> f16 {
+    ss0 = explicit_slot 4
+
+block0(v0: i16):
+    stack_store.i16 v0, ss0+2
+    
+    v1 = stack_load.f16 ss0+2
+    return v1
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+;   addi sp,sp,-16
+; block0:
+;   sh a0,2(slot)
+;   flh fa0,2(slot)
+;   addi sp,sp,16
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+;   addi sp, sp, -0x10
+; block1: ; offset 0x14
+;   sh a0, 2(sp)
+;   .byte 0x07, 0x15, 0x21, 0x00
+;   addi sp, sp, 0x10
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   ret
+
+function %f16_store(f16) -> i16 {
+    ss0 = explicit_slot 4
+
+block0(v0: f16):
+    stack_store.f16 v0, ss0+2
+    
+    v1 = stack_load.i16 ss0+2
+    return v1
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+;   addi sp,sp,-16
+; block0:
+;   fsh fa0,2(slot)
+;   lh a0,2(slot)
+;   addi sp,sp,16
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+;   addi sp, sp, -0x10
+; block1: ; offset 0x14
+;   .byte 0x27, 0x11, 0xa1, 0x00
+;   lh a0, 2(sp)
+;   addi sp, sp, 0x10
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   ret
+
+function %f16_roundtrip(f16) -> f16 {
+    ss0 = explicit_slot 2
+
+block0(v0: f16):
+    stack_store.f16 v0, ss0
+    v1 = stack_load.f16 ss0
+    return v1
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+;   addi sp,sp,-16
+; block0:
+;   fsh fa0,0(slot)
+;   flh fa0,0(slot)
+;   addi sp,sp,16
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+;   addi sp, sp, -0x10
+; block1: ; offset 0x14
+;   .byte 0x27, 0x10, 0xa1, 0x00
+;   .byte 0x07, 0x15, 0x01, 0x00
+;   addi sp, sp, 0x10
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/f16-select.clif b/cranelift/filetests/filetests/isa/riscv64/f16-select.clif
new file mode 100644
index 000000000000..02e57425ba33
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/f16-select.clif
@@ -0,0 +1,103 @@
+test compile precise-output
+target riscv64 has_zfh
+
+function %select_icmp_i8_f16(i8, f16, f16) -> f16 {
+block0(v0: i8, v1: f16, v2: f16):
+  v3 = iconst.i8 42
+  v4 = icmp eq v0, v3
+  v5 = select.f16 v4, v1, v2
+  return v5
+}
+
+; VCode:
+; block0:
+;   li a1,42
+;   andi a5,a0,255
+;   andi a1,a1,255
+;   select fa0,fa0,fa1##condition=(a5 eq a1)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi a1, zero, 0x2a
+;   andi a5, a0, 0xff
+;   andi a1, a1, 0xff
+;   beq a5, a1, 8
+;   fmv.d fa0, fa1
+;   ret
+
+function %select_icmp_i16_f16(i16, f16, f16) -> f16 {
+block0(v0: i16, v1: f16, v2: f16):
+  v3 = iconst.i16 42
+  v4 = icmp eq v0, v3
+  v5 = select.f16 v4, v1, v2
+  return v5
+}
+
+; VCode:
+; block0:
+;   li a3,42
+;   slli a5,a0,48
+;   srai a1,a5,48
+;   slli a3,a3,48
+;   srai a5,a3,48
+;   select fa0,fa0,fa1##condition=(a1 eq a5)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi a3, zero, 0x2a
+;   slli a5, a0, 0x30
+;   srai a1, a5, 0x30
+;   slli a3, a3, 0x30
+;   srai a5, a3, 0x30
+;   beq a1, a5, 8
+;   fmv.d fa0, fa1
+;   ret
+
+function %select_icmp_i32_f16(i32, f16, f16) -> f16 {
+block0(v0: i32, v1: f16, v2: f16):
+  v3 = iconst.i32 42
+  v4 = icmp eq v0, v3
+  v5 = select.f16 v4, v1, v2
+  return v5
+}
+
+; VCode:
+; block0:
+;   li a1,42
+;   sext.w a5,a0
+;   sext.w a1,a1
+;   select fa0,fa0,fa1##condition=(a5 eq a1)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi a1, zero, 0x2a
+;   sext.w a5, a0
+;   sext.w a1, a1
+;   beq a5, a1, 8
+;   fmv.d fa0, fa1
+;   ret
+
+function %select_icmp_i64_f16(i64, f16, f16) -> f16 {
+block0(v0: i64, v1: f16, v2: f16):
+  v3 = iconst.i64 42
+  v4 = icmp eq v0, v3
+  v5 = select.f16 v4, v1, v2
+  return v5
+}
+
+; VCode:
+; block0:
+;   li a5,42
+;   select fa0,fa0,fa1##condition=(a0 eq a5)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi a5, zero, 0x2a
+;   beq a0, a5, 8
+;   fmv.d fa0, fa1
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/f16.clif b/cranelift/filetests/filetests/isa/riscv64/f16.clif
new file mode 100644
index 000000000000..8727ddfddcd3
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/f16.clif
@@ -0,0 +1,131 @@
+test compile precise-output
+set unwind_info=false
+target riscv64 has_zfh
+
+function %fadd(f16, f16) -> f16 {
+block0(v0: f16, v1: f16):
+  v2 = fadd v0, v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   fadd.h fa0,fa0,fa1,rne
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x53, 0x05, 0xb5, 0x04
+;   ret
+
+function %fsub(f16, f16) -> f16 {
+block0(v0: f16, v1: f16):
+  v2 = fsub v0, v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   fsub.h fa0,fa0,fa1,rne
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x53, 0x05, 0xb5, 0x0c
+;   ret
+
+function %fmul(f16, f16) -> f16 {
+block0(v0: f16, v1: f16):
+  v2 = fmul v0, v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   fmul.h fa0,fa0,fa1,rne
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x53, 0x05, 0xb5, 0x14
+;   ret
+
+function %fdiv(f16, f16) -> f16 {
+block0(v0: f16, v1: f16):
+  v2 = fdiv v0, v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   fdiv.h fa0,fa0,fa1,rne
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x53, 0x05, 0xb5, 0x1c
+;   ret
+
+function %fsqrt(f16) -> f16 {
+block0(v0: f16):
+  v1 = sqrt v0
+  return v1
+}
+
+; VCode:
+; block0:
+;   fsqrt.h fa0,fa0,rne
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x53, 0x05, 0x05, 0x5c
+;   ret
+
+function %fabs(f16) -> f16 {
+block0(v0: f16):
+  v1 = fabs v0
+  return v1
+}
+
+; VCode:
+; block0:
+;   fabs.h fa0,fa0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x53, 0x25, 0xa5, 0x24
+;   ret
+
+function %fneg_h(f16) -> f16 {
+block0(v0: f16):
+  v1 = fneg v0
+  return v1
+}
+
+; VCode:
+; block0:
+;   fneg.h fa0,fa0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x53, 0x15, 0xa5, 0x24
+;   ret
+
+function %fsignj_h(f16, f16) -> f16 {
+block0(v0: f16, v1: f16):
+  v2 = fcopysign v0, v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   fsgnj.h fa0,fa0,fa1
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x53, 0x05, 0xb5, 0x24
+;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/f16const.clif b/cranelift/filetests/filetests/isa/riscv64/f16const.clif
new file mode 100644
index 000000000000..1ee3d9366f7b
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/f16const.clif
@@ -0,0 +1,39 @@
+test compile precise-output
+target riscv64 has_zfh
+
+function %ret_0() -> f16 {
+block0():
+  v0 = f16const 0.0
+  return v0
+}
+
+; VCode:
+; block0:
+;   fmv.h.x fa0,zero
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x53, 0x05, 0x00, 0xf4
+;   ret
+
+function %ret_1() -> f16 {
+block0():
+  v0 = f16const 0x1.0
+  return v0
+}
+
+; VCode:
+; block0:
+;   lui a0,4
+;   addi a2,a0,-1024
+;   fmv.h.x fa0,a2
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   lui a0, 4
+;   addi a2, a0, -0x400
+;   .byte 0x53, 0x05, 0x06, 0xf4
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/fcmp.clif b/cranelift/filetests/filetests/isa/riscv64/fcmp.clif
index 01b569b0fdf8..8e2ee2f91b3c 100644
--- a/cranelift/filetests/filetests/isa/riscv64/fcmp.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/fcmp.clif
@@ -14,10 +14,9 @@ block1:
 
 ; VCode:
 ; block0:
-;   li a1,0
-;   fmv.d.x fa3,a1
-;   fle.d a2,fa3,fa3
-;   beq a2,zero,taken(label1),not_taken(label2)
+;   fmv.d.x fa1,zero
+;   fle.d a1,fa1,fa1
+;   beq a1,zero,taken(label1),not_taken(label2)
 ; block1:
 ;   j label3
 ; block2:
@@ -27,10 +26,9 @@ block1:
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mv a1, zero
-;   fmv.d.x fa3, a1
-;   fle.d a2, fa3, fa3
-; block1: ; offset 0xc
+;   fmv.d.x fa1, zero
+;   fle.d a1, fa1, fa1
+; block1: ; offset 0x8
 ;   ret
 
 function %f1() {
@@ -45,10 +43,9 @@ block1:
 
 ; VCode:
 ; block0:
-;   li a1,0
-;   fmv.d.x fa3,a1
-;   fle.d a2,fa3,fa3
-;   beq a2,zero,taken(label1),not_taken(label2)
+;   fmv.d.x fa1,zero
+;   fle.d a1,fa1,fa1
+;   beq a1,zero,taken(label1),not_taken(label2)
 ; block1:
 ;   j label3
 ; block2:
@@ -58,10 +55,9 @@ block1:
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mv a1, zero
-;   fmv.d.x fa3, a1
-;   fle.d a2, fa3, fa3
-; block1: ; offset 0xc
+;   fmv.d.x fa1, zero
+;   fle.d a1, fa1, fa1
+; block1: ; offset 0x8
 ;   ret
 
 function %ord(f32, f32) -> i8 {
diff --git a/cranelift/filetests/filetests/isa/riscv64/fcvt-small.clif b/cranelift/filetests/filetests/isa/riscv64/fcvt-small.clif
index 26745e25a37c..f9bf123db02b 100644
--- a/cranelift/filetests/filetests/isa/riscv64/fcvt-small.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/fcvt-small.clif
@@ -11,13 +11,13 @@ block0(v0: i8):
 ; VCode:
 ; block0:
 ;   andi a2,a0,255
-;   fcvt.s.lu fa0,a2
+;   fcvt.s.lu fa0,a2,rne
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   andi a2, a0, 0xff
-;   fcvt.s.lu fa0, a2
+;   fcvt.s.lu fa0, a2, rne
 ;   ret
 
 function u0:0(i8) -> f64 {
@@ -29,13 +29,13 @@ block0(v0: i8):
 ; VCode:
 ; block0:
 ;   andi a2,a0,255
-;   fcvt.d.lu fa0,a2
+;   fcvt.d.lu fa0,a2,rne
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   andi a2, a0, 0xff
-;   fcvt.d.lu fa0, a2
+;   fcvt.d.lu fa0, a2, rne
 ;   ret
 
 function u0:0(i16) -> f32 {
@@ -48,14 +48,14 @@ block0(v0: i16):
 ; block0:
 ;   slli a2,a0,48
 ;   srli a4,a2,48
-;   fcvt.s.lu fa0,a4
+;   fcvt.s.lu fa0,a4,rne
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   slli a2, a0, 0x30
 ;   srli a4, a2, 0x30
-;   fcvt.s.lu fa0, a4
+;   fcvt.s.lu fa0, a4, rne
 ;   ret
 
 function u0:0(i16) -> f64 {
@@ -68,14 +68,14 @@ block0(v0: i16):
 ; block0:
 ;   slli a2,a0,48
 ;   srli a4,a2,48
-;   fcvt.d.lu fa0,a4
+;   fcvt.d.lu fa0,a4,rne
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   slli a2, a0, 0x30
 ;   srli a4, a2, 0x30
-;   fcvt.d.lu fa0, a4
+;   fcvt.d.lu fa0, a4, rne
 ;   ret
 
 function u0:0(f32) -> i8 {
@@ -86,29 +86,35 @@ block0(v0: f32):
 
 ; VCode:
 ; block0:
-;   fcvt_to_uint.i8 a0,fa0##in_ty=f32 tmp=fa3
+;   feq.s a2,fa0,fa0
+;   trap_if bad_toint##(a2 eq zero)
+;   lui a5,-264192
+;   fmv.w.x fa1,a5
+;   fle.s a3,fa0,fa1
+;   trap_if int_ovf##(a3 ne zero)
+;   lui a0,276480
+;   fmv.w.x fa2,a0
+;   fle.s a4,fa2,fa0
+;   trap_if int_ovf##(a4 ne zero)
+;   fcvt.wu.s a0,fa0,rtz
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   feq.s a0, fa0, fa0
-;   beqz a0, 0x40
-;   auipc t6, 0
-;   lw t6, 0xc(t6)
-;   j 8
-;   .byte 0x00, 0x00, 0x80, 0xbf
-;   fmv.w.x fa3, t6
-;   fle.s a0, fa0, fa3
-;   beqz a0, 8
+;   feq.s a2, fa0, fa0
+;   bnez a2, 8
+;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: bad_toint
+;   lui a5, 0xbf800
+;   fmv.w.x fa1, a5
+;   fle.s a3, fa0, fa1
+;   beqz a3, 8
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: int_ovf
-;   lui t6, 0x43800
-;   fmv.w.x fa3, t6
-;   fle.s a0, fa3, fa0
-;   beqz a0, 8
+;   lui a0, 0x43800
+;   fmv.w.x fa2, a0
+;   fle.s a4, fa2, fa0
+;   beqz a4, 8
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: int_ovf
-;   fcvt.wu.s a0, fa0, rtz
-;   j 8
-;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: bad_toint
+;   fcvt.wu.s a0, fa0, rtz ; trap: bad_toint
 ;   ret
 
 function u0:0(f64) -> i8 {
@@ -119,34 +125,39 @@ block0(v0: f64):
 
 ; VCode:
 ; block0:
-;   fcvt_to_uint.i8 a0,fa0##in_ty=f64 tmp=fa3
+;   feq.d a2,fa0,fa0
+;   trap_if bad_toint##(a2 eq zero)
+;   lui a5,3071
+;   slli a1,a5,40
+;   fmv.d.x fa3,a1
+;   fle.d a5,fa0,fa3
+;   trap_if int_ovf##(a5 ne zero)
+;   lui a2,1031
+;   slli a4,a2,40
+;   fmv.d.x fa1,a4
+;   fle.d a2,fa1,fa0
+;   trap_if int_ovf##(a2 ne zero)
+;   fcvt.wu.d a0,fa0,rtz
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   feq.d a0, fa0, fa0
-;   beqz a0, 0x54
-;   auipc t6, 0
-;   ld t6, 0xc(t6)
-;   j 0xc
-;   .byte 0x00, 0x00, 0x00, 0x00
-;   .byte 0x00, 0x00, 0xf0, 0xbf
-;   fmv.d.x fa3, t6
-;   fle.d a0, fa0, fa3
-;   beqz a0, 8
+;   feq.d a2, fa0, fa0
+;   bnez a2, 8
+;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: bad_toint
+;   lui a5, 0xbff
+;   slli a1, a5, 0x28
+;   fmv.d.x fa3, a1
+;   fle.d a5, fa0, fa3
+;   beqz a5, 8
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: int_ovf
-;   auipc t6, 0
-;   ld t6, 0xc(t6)
-;   j 0xc
-;   .byte 0x00, 0x00, 0x00, 0x00
-;   .byte 0x00, 0x00, 0x70, 0x40
-;   fmv.d.x fa3, t6
-;   fle.d a0, fa3, fa0
-;   beqz a0, 8
+;   lui a2, 0x407
+;   slli a4, a2, 0x28
+;   fmv.d.x fa1, a4
+;   fle.d a2, fa1, fa0
+;   beqz a2, 8
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: int_ovf
-;   fcvt.wu.d a0, fa0, rtz
-;   j 8
-;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: bad_toint
+;   fcvt.wu.d a0, fa0, rtz ; trap: bad_toint
 ;   ret
 
 function u0:0(f32) -> i16 {
@@ -157,29 +168,35 @@ block0(v0: f32):
 
 ; VCode:
 ; block0:
-;   fcvt_to_uint.i16 a0,fa0##in_ty=f32 tmp=fa3
+;   feq.s a2,fa0,fa0
+;   trap_if bad_toint##(a2 eq zero)
+;   lui a5,-264192
+;   fmv.w.x fa1,a5
+;   fle.s a3,fa0,fa1
+;   trap_if int_ovf##(a3 ne zero)
+;   lui a0,292864
+;   fmv.w.x fa2,a0
+;   fle.s a4,fa2,fa0
+;   trap_if int_ovf##(a4 ne zero)
+;   fcvt.wu.s a0,fa0,rtz
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   feq.s a0, fa0, fa0
-;   beqz a0, 0x40
-;   auipc t6, 0
-;   lw t6, 0xc(t6)
-;   j 8
-;   .byte 0x00, 0x00, 0x80, 0xbf
-;   fmv.w.x fa3, t6
-;   fle.s a0, fa0, fa3
-;   beqz a0, 8
+;   feq.s a2, fa0, fa0
+;   bnez a2, 8
+;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: bad_toint
+;   lui a5, 0xbf800
+;   fmv.w.x fa1, a5
+;   fle.s a3, fa0, fa1
+;   beqz a3, 8
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: int_ovf
-;   lui t6, 0x47800
-;   fmv.w.x fa3, t6
-;   fle.s a0, fa3, fa0
-;   beqz a0, 8
+;   lui a0, 0x47800
+;   fmv.w.x fa2, a0
+;   fle.s a4, fa2, fa0
+;   beqz a4, 8
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: int_ovf
-;   fcvt.wu.s a0, fa0, rtz
-;   j 8
-;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: bad_toint
+;   fcvt.wu.s a0, fa0, rtz ; trap: bad_toint
 ;   ret
 
 function u0:0(f64) -> i16 {
@@ -190,33 +207,38 @@ block0(v0: f64):
 
 ; VCode:
 ; block0:
-;   fcvt_to_uint.i16 a0,fa0##in_ty=f64 tmp=fa3
+;   feq.d a2,fa0,fa0
+;   trap_if bad_toint##(a2 eq zero)
+;   lui a5,3071
+;   slli a1,a5,40
+;   fmv.d.x fa3,a1
+;   fle.d a5,fa0,fa3
+;   trap_if int_ovf##(a5 ne zero)
+;   lui a2,1039
+;   slli a4,a2,40
+;   fmv.d.x fa1,a4
+;   fle.d a2,fa1,fa0
+;   trap_if int_ovf##(a2 ne zero)
+;   fcvt.wu.d a0,fa0,rtz
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   feq.d a0, fa0, fa0
-;   beqz a0, 0x54
-;   auipc t6, 0
-;   ld t6, 0xc(t6)
-;   j 0xc
-;   .byte 0x00, 0x00, 0x00, 0x00
-;   .byte 0x00, 0x00, 0xf0, 0xbf
-;   fmv.d.x fa3, t6
-;   fle.d a0, fa0, fa3
-;   beqz a0, 8
+;   feq.d a2, fa0, fa0
+;   bnez a2, 8
+;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: bad_toint
+;   lui a5, 0xbff
+;   slli a1, a5, 0x28
+;   fmv.d.x fa3, a1
+;   fle.d a5, fa0, fa3
+;   beqz a5, 8
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: int_ovf
-;   auipc t6, 0
-;   ld t6, 0xc(t6)
-;   j 0xc
-;   .byte 0x00, 0x00, 0x00, 0x00
-;   .byte 0x00, 0x00, 0xf0, 0x40
-;   fmv.d.x fa3, t6
-;   fle.d a0, fa3, fa0
-;   beqz a0, 8
+;   lui a2, 0x40f
+;   slli a4, a2, 0x28
+;   fmv.d.x fa1, a4
+;   fle.d a2, fa1, fa0
+;   beqz a2, 8
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: int_ovf
-;   fcvt.wu.d a0, fa0, rtz
-;   j 8
-;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: bad_toint
+;   fcvt.wu.d a0, fa0, rtz ; trap: bad_toint
 ;   ret
 
diff --git a/cranelift/filetests/filetests/isa/riscv64/float.clif b/cranelift/filetests/filetests/isa/riscv64/float.clif
index 2b5cd9564023..718959709d04 100644
--- a/cranelift/filetests/filetests/isa/riscv64/float.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/float.clif
@@ -10,12 +10,12 @@ block0(v0: f32, v1: f32):
 
 ; VCode:
 ; block0:
-;   fadd.s fa0,fa0,fa1
+;   fadd.s fa0,fa0,fa1,rne
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   fadd.s fa0, fa0, fa1
+;   fadd.s fa0, fa0, fa1, rne
 ;   ret
 
 function %f2(f64, f64) -> f64 {
@@ -26,12 +26,12 @@ block0(v0: f64, v1: f64):
 
 ; VCode:
 ; block0:
-;   fadd.d fa0,fa0,fa1
+;   fadd.d fa0,fa0,fa1,rne
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   fadd.d fa0, fa0, fa1
+;   fadd.d fa0, fa0, fa1, rne
 ;   ret
 
 function %f3(f32, f32) -> f32 {
@@ -42,12 +42,12 @@ block0(v0: f32, v1: f32):
 
 ; VCode:
 ; block0:
-;   fsub.s fa0,fa0,fa1
+;   fsub.s fa0,fa0,fa1,rne
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   fsub.s fa0, fa0, fa1
+;   fsub.s fa0, fa0, fa1, rne
 ;   ret
 
 function %f4(f64, f64) -> f64 {
@@ -58,12 +58,12 @@ block0(v0: f64, v1: f64):
 
 ; VCode:
 ; block0:
-;   fsub.d fa0,fa0,fa1
+;   fsub.d fa0,fa0,fa1,rne
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   fsub.d fa0, fa0, fa1
+;   fsub.d fa0, fa0, fa1, rne
 ;   ret
 
 function %f5(f32, f32) -> f32 {
@@ -74,12 +74,12 @@ block0(v0: f32, v1: f32):
 
 ; VCode:
 ; block0:
-;   fmul.s fa0,fa0,fa1
+;   fmul.s fa0,fa0,fa1,rne
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   fmul.s fa0, fa0, fa1
+;   fmul.s fa0, fa0, fa1, rne
 ;   ret
 
 function %f6(f64, f64) -> f64 {
@@ -90,12 +90,12 @@ block0(v0: f64, v1: f64):
 
 ; VCode:
 ; block0:
-;   fmul.d fa0,fa0,fa1
+;   fmul.d fa0,fa0,fa1,rne
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   fmul.d fa0, fa0, fa1
+;   fmul.d fa0, fa0, fa1, rne
 ;   ret
 
 function %f7(f32, f32) -> f32 {
@@ -106,12 +106,12 @@ block0(v0: f32, v1: f32):
 
 ; VCode:
 ; block0:
-;   fdiv.s fa0,fa0,fa1
+;   fdiv.s fa0,fa0,fa1,rne
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   fdiv.s fa0, fa0, fa1
+;   fdiv.s fa0, fa0, fa1, rne
 ;   ret
 
 function %f8(f64, f64) -> f64 {
@@ -122,160 +122,12 @@ block0(v0: f64, v1: f64):
 
 ; VCode:
 ; block0:
-;   fdiv.d fa0,fa0,fa1
+;   fdiv.d fa0,fa0,fa1,rne
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   fdiv.d fa0, fa0, fa1
-;   ret
-
-function %f9(f32, f32) -> f32 {
-block0(v0: f32, v1: f32):
-  v2 = fmin v0, v1
-  return v2
-}
-
-; VCode:
-; block0:
-;   fmv.d fa5,fa0
-;   fmin.s fa0,fa5,fa1##tmp=a4 ty=f32
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   fmv.d fa5, fa0
-;   feq.s a4, fa5, fa5
-;   beqz a4, 0x3c
-;   feq.s a4, fa1, fa1
-;   beqz a4, 0x34
-;   fmin.s fa0, fa5, fa1
-;   fclass.s a4, fa5
-;   andi a4, a4, 0x18
-;   beqz a4, 0x34
-;   fclass.s a4, fa1
-;   andi a4, a4, 0x18
-;   beqz a4, 0x28
-;   fmv.x.w a4, fa5
-;   fmv.x.w t6, fa1
-;   or a4, a4, t6
-;   fmv.w.x fa0, a4
-;   j 0x14
-;   addi a4, zero, -1
-;   srli a4, a4, 0x16
-;   slli a4, a4, 0x16
-;   fmv.w.x fa0, a4
-;   ret
-
-function %f10(f64, f64) -> f64 {
-block0(v0: f64, v1: f64):
-  v2 = fmin v0, v1
-  return v2
-}
-
-; VCode:
-; block0:
-;   fmv.d fa5,fa0
-;   fmin.d fa0,fa5,fa1##tmp=a4 ty=f64
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   fmv.d fa5, fa0
-;   feq.d a4, fa5, fa5
-;   beqz a4, 0x3c
-;   feq.d a4, fa1, fa1
-;   beqz a4, 0x34
-;   fmin.d fa0, fa5, fa1
-;   fclass.d a4, fa5
-;   andi a4, a4, 0x18
-;   beqz a4, 0x34
-;   fclass.d a4, fa1
-;   andi a4, a4, 0x18
-;   beqz a4, 0x28
-;   fmv.x.d a4, fa5
-;   fmv.x.d t6, fa1
-;   or a4, a4, t6
-;   fmv.d.x fa0, a4
-;   j 0x14
-;   addi a4, zero, -1
-;   srli a4, a4, 0x33
-;   slli a4, a4, 0x33
-;   fmv.d.x fa0, a4
-;   ret
-
-function %f11(f32, f32) -> f32 {
-block0(v0: f32, v1: f32):
-  v2 = fmax v0, v1
-  return v2
-}
-
-; VCode:
-; block0:
-;   fmv.d fa5,fa0
-;   fmax.s fa0,fa5,fa1##tmp=a4 ty=f32
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   fmv.d fa5, fa0
-;   feq.s a4, fa5, fa5
-;   beqz a4, 0x3c
-;   feq.s a4, fa1, fa1
-;   beqz a4, 0x34
-;   fmax.s fa0, fa5, fa1
-;   fclass.s a4, fa5
-;   andi a4, a4, 0x18
-;   beqz a4, 0x34
-;   fclass.s a4, fa1
-;   andi a4, a4, 0x18
-;   beqz a4, 0x28
-;   fmv.x.w a4, fa5
-;   fmv.x.w t6, fa1
-;   and a4, a4, t6
-;   fmv.w.x fa0, a4
-;   j 0x14
-;   addi a4, zero, -1
-;   srli a4, a4, 0x16
-;   slli a4, a4, 0x16
-;   fmv.w.x fa0, a4
-;   ret
-
-function %f12(f64, f64) -> f64 {
-block0(v0: f64, v1: f64):
-  v2 = fmax v0, v1
-  return v2
-}
-
-; VCode:
-; block0:
-;   fmv.d fa5,fa0
-;   fmax.d fa0,fa5,fa1##tmp=a4 ty=f64
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   fmv.d fa5, fa0
-;   feq.d a4, fa5, fa5
-;   beqz a4, 0x3c
-;   feq.d a4, fa1, fa1
-;   beqz a4, 0x34
-;   fmax.d fa0, fa5, fa1
-;   fclass.d a4, fa5
-;   andi a4, a4, 0x18
-;   beqz a4, 0x34
-;   fclass.d a4, fa1
-;   andi a4, a4, 0x18
-;   beqz a4, 0x28
-;   fmv.x.d a4, fa5
-;   fmv.x.d t6, fa1
-;   and a4, a4, t6
-;   fmv.d.x fa0, a4
-;   j 0x14
-;   addi a4, zero, -1
-;   srli a4, a4, 0x33
-;   slli a4, a4, 0x33
-;   fmv.d.x fa0, a4
+;   fdiv.d fa0, fa0, fa1, rne
 ;   ret
 
 function %f13(f32) -> f32 {
@@ -286,12 +138,12 @@ block0(v0: f32):
 
 ; VCode:
 ; block0:
-;   fsqrt.s fa0,fa0
+;   fsqrt.s fa0,fa0,rne
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   fsqrt.s fa0, fa0
+;   fsqrt.s fa0, fa0, rne
 ;   ret
 
 function %f15(f64) -> f64 {
@@ -302,12 +154,12 @@ block0(v0: f64):
 
 ; VCode:
 ; block0:
-;   fsqrt.d fa0,fa0
+;   fsqrt.d fa0,fa0,rne
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   fsqrt.d fa0, fa0
+;   fsqrt.d fa0, fa0, rne
 ;   ret
 
 function %f16(f32) -> f32 {
@@ -382,12 +234,12 @@ block0(v0: f32):
 
 ; VCode:
 ; block0:
-;   fcvt.d.s fa0,fa0
+;   fcvt.d.s fa0,fa0,rne
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0x53, 0x75, 0x05, 0x42
+;   fcvt.d.s fa0, fa0
 ;   ret
 
 function %f21(f64) -> f32 {
@@ -398,309 +250,14 @@ block0(v0: f64):
 
 ; VCode:
 ; block0:
-;   fcvt.s.d fa0,fa0
+;   fcvt.s.d fa0,fa0,rne
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   fcvt.s.d fa0, fa0
+;   fcvt.s.d fa0, fa0, rne
 ;   ret
 
-function %f22(f32) -> f32 {
-block0(v0: f32):
-  v1 = ceil v0
-  return v1
-}
-
-; VCode:
-; block0:
-;   fmv.d fa5,fa0
-;   ceil fa0,fa5##int_tmp=a3 f_tmp=fa4 ty=f32
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   fmv.d fa5, fa0
-;   feq.s a3, fa5, fa5
-;   beqz a3, 0x28
-;   lui t6, 0x4b800
-;   fmv.w.x fa4, t6
-;   fabs.s fa0, fa5
-;   flt.s a3, fa4, fa0
-;   bnez a3, 0x1c
-;   fcvt.l.s a3, fa5, rup
-;   fcvt.s.l fa0, a3, rup
-;   fsgnj.s fa0, fa0, fa5
-;   j 0x10
-;   fadd.s fa0, fa5, fa5
-;   j 8
-;   fmv.s fa0, fa5
-;   ret
-
-function %f22(f64) -> f64 {
-block0(v0: f64):
-  v1 = ceil v0
-  return v1
-}
-
-; VCode:
-; block0:
-;   fmv.d fa5,fa0
-;   ceil fa0,fa5##int_tmp=a3 f_tmp=fa4 ty=f64
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   fmv.d fa5, fa0
-;   feq.d a3, fa5, fa5
-;   beqz a3, 0x38
-;   auipc t6, 0
-;   ld t6, 0xc(t6)
-;   j 0xc
-;   .byte 0x00, 0x00, 0x00, 0x00
-;   .byte 0x00, 0x00, 0x40, 0x43
-;   fmv.d.x fa4, t6
-;   fabs.d fa0, fa5
-;   flt.d a3, fa4, fa0
-;   bnez a3, 0x1c
-;   fcvt.l.d a3, fa5, rup
-;   fcvt.d.l fa0, a3, rup
-;   fsgnj.d fa0, fa0, fa5
-;   j 0x10
-;   fadd.d fa0, fa5, fa5
-;   j 8
-;   fmv.d fa0, fa5
-;   ret
-
-function %f23(f32) -> f32 {
-block0(v0: f32):
-  v1 = floor v0
-  return v1
-}
-
-; VCode:
-; block0:
-;   fmv.d fa5,fa0
-;   floor fa0,fa5##int_tmp=a3 f_tmp=fa4 ty=f32
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   fmv.d fa5, fa0
-;   feq.s a3, fa5, fa5
-;   beqz a3, 0x28
-;   lui t6, 0x4b800
-;   fmv.w.x fa4, t6
-;   fabs.s fa0, fa5
-;   flt.s a3, fa4, fa0
-;   bnez a3, 0x1c
-;   fcvt.l.s a3, fa5, rdn
-;   fcvt.s.l fa0, a3, rdn
-;   fsgnj.s fa0, fa0, fa5
-;   j 0x10
-;   fadd.s fa0, fa5, fa5
-;   j 8
-;   fmv.s fa0, fa5
-;   ret
-
-function %f24(f64) -> f64 {
-block0(v0: f64):
-  v1 = floor v0
-  return v1
-}
-
-; VCode:
-; block0:
-;   fmv.d fa5,fa0
-;   floor fa0,fa5##int_tmp=a3 f_tmp=fa4 ty=f64
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   fmv.d fa5, fa0
-;   feq.d a3, fa5, fa5
-;   beqz a3, 0x38
-;   auipc t6, 0
-;   ld t6, 0xc(t6)
-;   j 0xc
-;   .byte 0x00, 0x00, 0x00, 0x00
-;   .byte 0x00, 0x00, 0x40, 0x43
-;   fmv.d.x fa4, t6
-;   fabs.d fa0, fa5
-;   flt.d a3, fa4, fa0
-;   bnez a3, 0x1c
-;   fcvt.l.d a3, fa5, rdn
-;   fcvt.d.l fa0, a3, rdn
-;   fsgnj.d fa0, fa0, fa5
-;   j 0x10
-;   fadd.d fa0, fa5, fa5
-;   j 8
-;   fmv.d fa0, fa5
-;   ret
-
-function %f25(f32) -> f32 {
-block0(v0: f32):
-  v1 = trunc v0
-  return v1
-}
-
-; VCode:
-; block0:
-;   fmv.d fa5,fa0
-;   trunc fa0,fa5##int_tmp=a3 f_tmp=fa4 ty=f32
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   fmv.d fa5, fa0
-;   feq.s a3, fa5, fa5
-;   beqz a3, 0x28
-;   lui t6, 0x4b800
-;   fmv.w.x fa4, t6
-;   fabs.s fa0, fa5
-;   flt.s a3, fa4, fa0
-;   bnez a3, 0x1c
-;   fcvt.l.s a3, fa5, rtz
-;   fcvt.s.l fa0, a3, rtz
-;   fsgnj.s fa0, fa0, fa5
-;   j 0x10
-;   fadd.s fa0, fa5, fa5
-;   j 8
-;   fmv.s fa0, fa5
-;   ret
-
-function %f26(f64) -> f64 {
-block0(v0: f64):
-  v1 = trunc v0
-  return v1
-}
-
-; VCode:
-; block0:
-;   fmv.d fa5,fa0
-;   trunc fa0,fa5##int_tmp=a3 f_tmp=fa4 ty=f64
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   fmv.d fa5, fa0
-;   feq.d a3, fa5, fa5
-;   beqz a3, 0x38
-;   auipc t6, 0
-;   ld t6, 0xc(t6)
-;   j 0xc
-;   .byte 0x00, 0x00, 0x00, 0x00
-;   .byte 0x00, 0x00, 0x40, 0x43
-;   fmv.d.x fa4, t6
-;   fabs.d fa0, fa5
-;   flt.d a3, fa4, fa0
-;   bnez a3, 0x1c
-;   fcvt.l.d a3, fa5, rtz
-;   fcvt.d.l fa0, a3, rtz
-;   fsgnj.d fa0, fa0, fa5
-;   j 0x10
-;   fadd.d fa0, fa5, fa5
-;   j 8
-;   fmv.d fa0, fa5
-;   ret
-
-function %f27(f32) -> f32 {
-block0(v0: f32):
-  v1 = nearest v0
-  return v1
-}
-
-; VCode:
-; block0:
-;   fmv.d fa5,fa0
-;   nearest fa0,fa5##int_tmp=a3 f_tmp=fa4 ty=f32
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   fmv.d fa5, fa0
-;   feq.s a3, fa5, fa5
-;   beqz a3, 0x28
-;   lui t6, 0x4b800
-;   fmv.w.x fa4, t6
-;   fabs.s fa0, fa5
-;   flt.s a3, fa4, fa0
-;   bnez a3, 0x1c
-;   fcvt.l.s a3, fa5, rne
-;   fcvt.s.l fa0, a3, rne
-;   fsgnj.s fa0, fa0, fa5
-;   j 0x10
-;   fadd.s fa0, fa5, fa5
-;   j 8
-;   fmv.s fa0, fa5
-;   ret
-
-function %f28(f64) -> f64 {
-block0(v0: f64):
-  v1 = nearest v0
-  return v1
-}
-
-; VCode:
-; block0:
-;   fmv.d fa5,fa0
-;   nearest fa0,fa5##int_tmp=a3 f_tmp=fa4 ty=f64
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   fmv.d fa5, fa0
-;   feq.d a3, fa5, fa5
-;   beqz a3, 0x38
-;   auipc t6, 0
-;   ld t6, 0xc(t6)
-;   j 0xc
-;   .byte 0x00, 0x00, 0x00, 0x00
-;   .byte 0x00, 0x00, 0x40, 0x43
-;   fmv.d.x fa4, t6
-;   fabs.d fa0, fa5
-;   flt.d a3, fa4, fa0
-;   bnez a3, 0x1c
-;   fcvt.l.d a3, fa5, rne
-;   fcvt.d.l fa0, a3, rne
-;   fsgnj.d fa0, fa0, fa5
-;   j 0x10
-;   fadd.d fa0, fa5, fa5
-;   j 8
-;   fmv.d fa0, fa5
-;   ret
-
-function %f29(f32, f32, f32) -> f32 {
-block0(v0: f32, v1: f32, v2: f32):
-  v3 = fma v0, v1, v2
-  return v3
-}
-
-; VCode:
-; block0:
-;   fmadd.s fa0,fa0,fa1,fa2
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   fmadd.s fa0, fa0, fa1, fa2
-;   ret
-
-function %f30(f64, f64, f64) -> f64 {
-block0(v0: f64, v1: f64, v2: f64):
-  v3 = fma v0, v1, v2
-  return v3
-}
-
-; VCode:
-; block0:
-;   fmadd.d fa0,fa0,fa1,fa2
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   fmadd.d fa0, fa0, fa1, fa2
-;   ret
 
 function %f31(f32, f32) -> f32 {
 block0(v0: f32, v1: f32):
@@ -742,29 +299,35 @@ block0(v0: f32):
 
 ; VCode:
 ; block0:
-;   fcvt_to_uint.i32 a0,fa0##in_ty=f32 tmp=fa3
+;   feq.s a2,fa0,fa0
+;   trap_if bad_toint##(a2 eq zero)
+;   lui a5,-264192
+;   fmv.w.x fa1,a5
+;   fle.s a3,fa0,fa1
+;   trap_if int_ovf##(a3 ne zero)
+;   lui a0,325632
+;   fmv.w.x fa2,a0
+;   fle.s a4,fa2,fa0
+;   trap_if int_ovf##(a4 ne zero)
+;   fcvt.wu.s a0,fa0,rtz
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   feq.s a0, fa0, fa0
-;   beqz a0, 0x40
-;   auipc t6, 0
-;   lw t6, 0xc(t6)
-;   j 8
-;   .byte 0x00, 0x00, 0x80, 0xbf
-;   fmv.w.x fa3, t6
-;   fle.s a0, fa0, fa3
-;   beqz a0, 8
+;   feq.s a2, fa0, fa0
+;   bnez a2, 8
+;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: bad_toint
+;   lui a5, 0xbf800
+;   fmv.w.x fa1, a5
+;   fle.s a3, fa0, fa1
+;   beqz a3, 8
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: int_ovf
-;   lui t6, 0x4f800
-;   fmv.w.x fa3, t6
-;   fle.s a0, fa3, fa0
-;   beqz a0, 8
+;   lui a0, 0x4f800
+;   fmv.w.x fa2, a0
+;   fle.s a4, fa2, fa0
+;   beqz a4, 8
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: int_ovf
-;   fcvt.wu.s a0, fa0, rtz
-;   j 8
-;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: bad_toint
+;   fcvt.wu.s a0, fa0, rtz ; trap: bad_toint
 ;   ret
 
 function %f34(f32) -> i32 {
@@ -775,29 +338,37 @@ block0(v0: f32):
 
 ; VCode:
 ; block0:
-;   fcvt_to_sint.i32 a0,fa0##in_ty=f32 tmp=fa3
+;   feq.s a2,fa0,fa0
+;   trap_if bad_toint##(a2 eq zero)
+;   lui a5,-200704
+;   addi a1,a5,1
+;   fmv.w.x fa3,a1
+;   fle.s a5,fa0,fa3
+;   trap_if int_ovf##(a5 ne zero)
+;   lui a2,323584
+;   fmv.w.x fa4,a2
+;   fle.s a0,fa4,fa0
+;   trap_if int_ovf##(a0 ne zero)
+;   fcvt.w.s a0,fa0,rtz
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   feq.s a0, fa0, fa0
-;   beqz a0, 0x40
-;   auipc t6, 0
-;   lw t6, 0xc(t6)
-;   j 8
-;   .byte 0x01, 0x00, 0x00, 0xcf
-;   fmv.w.x fa3, t6
-;   fle.s a0, fa0, fa3
-;   beqz a0, 8
+;   feq.s a2, fa0, fa0
+;   bnez a2, 8
+;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: bad_toint
+;   lui a5, 0xcf000
+;   addi a1, a5, 1
+;   fmv.w.x fa3, a1
+;   fle.s a5, fa0, fa3
+;   beqz a5, 8
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: int_ovf
-;   lui t6, 0x4f000
-;   fmv.w.x fa3, t6
-;   fle.s a0, fa3, fa0
+;   lui a2, 0x4f000
+;   fmv.w.x fa4, a2
+;   fle.s a0, fa4, fa0
 ;   beqz a0, 8
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: int_ovf
-;   fcvt.w.s a0, fa0, rtz
-;   j 8
-;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: bad_toint
+;   fcvt.w.s a0, fa0, rtz ; trap: bad_toint
 ;   ret
 
 function %f35(f32) -> i64 {
@@ -808,29 +379,35 @@ block0(v0: f32):
 
 ; VCode:
 ; block0:
-;   fcvt_to_uint.i64 a0,fa0##in_ty=f32 tmp=fa3
+;   feq.s a2,fa0,fa0
+;   trap_if bad_toint##(a2 eq zero)
+;   lui a5,-264192
+;   fmv.w.x fa1,a5
+;   fle.s a3,fa0,fa1
+;   trap_if int_ovf##(a3 ne zero)
+;   lui a0,391168
+;   fmv.w.x fa2,a0
+;   fle.s a4,fa2,fa0
+;   trap_if int_ovf##(a4 ne zero)
+;   fcvt.lu.s a0,fa0,rtz
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   feq.s a0, fa0, fa0
-;   beqz a0, 0x40
-;   auipc t6, 0
-;   lw t6, 0xc(t6)
-;   j 8
-;   .byte 0x00, 0x00, 0x80, 0xbf
-;   fmv.w.x fa3, t6
-;   fle.s a0, fa0, fa3
-;   beqz a0, 8
+;   feq.s a2, fa0, fa0
+;   bnez a2, 8
+;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: bad_toint
+;   lui a5, 0xbf800
+;   fmv.w.x fa1, a5
+;   fle.s a3, fa0, fa1
+;   beqz a3, 8
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: int_ovf
-;   lui t6, 0x5f800
-;   fmv.w.x fa3, t6
-;   fle.s a0, fa3, fa0
-;   beqz a0, 8
+;   lui a0, 0x5f800
+;   fmv.w.x fa2, a0
+;   fle.s a4, fa2, fa0
+;   beqz a4, 8
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: int_ovf
-;   fcvt.lu.s a0, fa0, rtz
-;   j 8
-;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: bad_toint
+;   fcvt.lu.s a0, fa0, rtz ; trap: bad_toint
 ;   ret
 
 function %f36(f32) -> i64 {
@@ -841,29 +418,37 @@ block0(v0: f32):
 
 ; VCode:
 ; block0:
-;   fcvt_to_sint.i64 a0,fa0##in_ty=f32 tmp=fa3
+;   feq.s a2,fa0,fa0
+;   trap_if bad_toint##(a2 eq zero)
+;   lui a5,-135168
+;   addi a1,a5,1
+;   fmv.w.x fa3,a1
+;   fle.s a5,fa0,fa3
+;   trap_if int_ovf##(a5 ne zero)
+;   lui a2,389120
+;   fmv.w.x fa4,a2
+;   fle.s a0,fa4,fa0
+;   trap_if int_ovf##(a0 ne zero)
+;   fcvt.l.s a0,fa0,rtz
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   feq.s a0, fa0, fa0
-;   beqz a0, 0x40
-;   auipc t6, 0
-;   lw t6, 0xc(t6)
-;   j 8
-;   .byte 0x01, 0x00, 0x00, 0xdf
-;   fmv.w.x fa3, t6
-;   fle.s a0, fa0, fa3
-;   beqz a0, 8
+;   feq.s a2, fa0, fa0
+;   bnez a2, 8
+;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: bad_toint
+;   lui a5, 0xdf000
+;   addi a1, a5, 1
+;   fmv.w.x fa3, a1
+;   fle.s a5, fa0, fa3
+;   beqz a5, 8
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: int_ovf
-;   lui t6, 0x5f000
-;   fmv.w.x fa3, t6
-;   fle.s a0, fa3, fa0
+;   lui a2, 0x5f000
+;   fmv.w.x fa4, a2
+;   fle.s a0, fa4, fa0
 ;   beqz a0, 8
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: int_ovf
-;   fcvt.l.s a0, fa0, rtz
-;   j 8
-;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: bad_toint
+;   fcvt.l.s a0, fa0, rtz ; trap: bad_toint
 ;   ret
 
 function %f37(f64) -> i32 {
@@ -874,34 +459,39 @@ block0(v0: f64):
 
 ; VCode:
 ; block0:
-;   fcvt_to_uint.i32 a0,fa0##in_ty=f64 tmp=fa3
+;   feq.d a2,fa0,fa0
+;   trap_if bad_toint##(a2 eq zero)
+;   lui a5,3071
+;   slli a1,a5,40
+;   fmv.d.x fa3,a1
+;   fle.d a5,fa0,fa3
+;   trap_if int_ovf##(a5 ne zero)
+;   lui a2,1055
+;   slli a4,a2,40
+;   fmv.d.x fa1,a4
+;   fle.d a2,fa1,fa0
+;   trap_if int_ovf##(a2 ne zero)
+;   fcvt.wu.d a0,fa0,rtz
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   feq.d a0, fa0, fa0
-;   beqz a0, 0x54
-;   auipc t6, 0
-;   ld t6, 0xc(t6)
-;   j 0xc
-;   .byte 0x00, 0x00, 0x00, 0x00
-;   .byte 0x00, 0x00, 0xf0, 0xbf
-;   fmv.d.x fa3, t6
-;   fle.d a0, fa0, fa3
-;   beqz a0, 8
+;   feq.d a2, fa0, fa0
+;   bnez a2, 8
+;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: bad_toint
+;   lui a5, 0xbff
+;   slli a1, a5, 0x28
+;   fmv.d.x fa3, a1
+;   fle.d a5, fa0, fa3
+;   beqz a5, 8
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: int_ovf
-;   auipc t6, 0
-;   ld t6, 0xc(t6)
-;   j 0xc
-;   .byte 0x00, 0x00, 0x00, 0x00
-;   .byte 0x00, 0x00, 0xf0, 0x41
-;   fmv.d.x fa3, t6
-;   fle.d a0, fa3, fa0
-;   beqz a0, 8
+;   lui a2, 0x41f
+;   slli a4, a2, 0x28
+;   fmv.d.x fa1, a4
+;   fle.d a2, fa1, fa0
+;   beqz a2, 8
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: int_ovf
-;   fcvt.wu.d a0, fa0, rtz
-;   j 8
-;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: bad_toint
+;   fcvt.wu.d a0, fa0, rtz ; trap: bad_toint
 ;   ret
 
 function %f38(f64) -> i32 {
@@ -912,35 +502,42 @@ block0(v0: f64):
 
 ; VCode:
 ; block0:
-;   fcvt_to_sint.i32 a0,fa0##in_ty=f64 tmp=fa3
+;   feq.d a2,fa0,fa0
+;   trap_if bad_toint##(a2 eq zero)
+;   ld a5,[const(0)]
+;   fmv.d.x fa1,a5
+;   fle.d a3,fa0,fa1
+;   trap_if int_ovf##(a3 ne zero)
+;   lui a0,527
+;   slli a2,a0,41
+;   fmv.d.x fa4,a2
+;   fle.d a0,fa4,fa0
+;   trap_if int_ovf##(a0 ne zero)
+;   fcvt.w.d a0,fa0,rtz
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   feq.d a0, fa0, fa0
-;   beqz a0, 0x54
-;   auipc t6, 0
-;   ld t6, 0xc(t6)
-;   j 0xc
-;   .byte 0x00, 0x00, 0x20, 0x00
-;   .byte 0x00, 0x00, 0xe0, 0xc1
-;   fmv.d.x fa3, t6
-;   fle.d a0, fa0, fa3
-;   beqz a0, 8
+;   feq.d a2, fa0, fa0
+;   bnez a2, 8
+;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: bad_toint
+;   auipc a5, 0
+;   ld a5, 0x3c(a5)
+;   fmv.d.x fa1, a5
+;   fle.d a3, fa0, fa1
+;   beqz a3, 8
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: int_ovf
-;   auipc t6, 0
-;   ld t6, 0xc(t6)
-;   j 0xc
-;   .byte 0x00, 0x00, 0x00, 0x00
-;   .byte 0x00, 0x00, 0xe0, 0x41
-;   fmv.d.x fa3, t6
-;   fle.d a0, fa3, fa0
+;   lui a0, 0x20f
+;   slli a2, a0, 0x29
+;   fmv.d.x fa4, a2
+;   fle.d a0, fa4, fa0
 ;   beqz a0, 8
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: int_ovf
-;   fcvt.w.d a0, fa0, rtz
-;   j 8
-;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: bad_toint
+;   fcvt.w.d a0, fa0, rtz ; trap: bad_toint
 ;   ret
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   .byte 0x00, 0x00, 0x20, 0x00
+;   .byte 0x00, 0x00, 0xe0, 0xc1
 
 function %f39(f64) -> i64 {
 block0(v0: f64):
@@ -950,34 +547,39 @@ block0(v0: f64):
 
 ; VCode:
 ; block0:
-;   fcvt_to_uint.i64 a0,fa0##in_ty=f64 tmp=fa3
+;   feq.d a2,fa0,fa0
+;   trap_if bad_toint##(a2 eq zero)
+;   lui a5,3071
+;   slli a1,a5,40
+;   fmv.d.x fa3,a1
+;   fle.d a5,fa0,fa3
+;   trap_if int_ovf##(a5 ne zero)
+;   lui a2,1087
+;   slli a4,a2,40
+;   fmv.d.x fa1,a4
+;   fle.d a2,fa1,fa0
+;   trap_if int_ovf##(a2 ne zero)
+;   fcvt.lu.d a0,fa0,rtz
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   feq.d a0, fa0, fa0
-;   beqz a0, 0x54
-;   auipc t6, 0
-;   ld t6, 0xc(t6)
-;   j 0xc
-;   .byte 0x00, 0x00, 0x00, 0x00
-;   .byte 0x00, 0x00, 0xf0, 0xbf
-;   fmv.d.x fa3, t6
-;   fle.d a0, fa0, fa3
-;   beqz a0, 8
+;   feq.d a2, fa0, fa0
+;   bnez a2, 8
+;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: bad_toint
+;   lui a5, 0xbff
+;   slli a1, a5, 0x28
+;   fmv.d.x fa3, a1
+;   fle.d a5, fa0, fa3
+;   beqz a5, 8
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: int_ovf
-;   auipc t6, 0
-;   ld t6, 0xc(t6)
-;   j 0xc
-;   .byte 0x00, 0x00, 0x00, 0x00
-;   .byte 0x00, 0x00, 0xf0, 0x43
-;   fmv.d.x fa3, t6
-;   fle.d a0, fa3, fa0
-;   beqz a0, 8
+;   lui a2, 0x43f
+;   slli a4, a2, 0x28
+;   fmv.d.x fa1, a4
+;   fle.d a2, fa1, fa0
+;   beqz a2, 8
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: int_ovf
-;   fcvt.lu.d a0, fa0, rtz
-;   j 8
-;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: bad_toint
+;   fcvt.lu.d a0, fa0, rtz ; trap: bad_toint
 ;   ret
 
 function %f40(f64) -> i64 {
@@ -988,35 +590,42 @@ block0(v0: f64):
 
 ; VCode:
 ; block0:
-;   fcvt_to_sint.i64 a0,fa0##in_ty=f64 tmp=fa3
+;   feq.d a2,fa0,fa0
+;   trap_if bad_toint##(a2 eq zero)
+;   ld a5,[const(0)]
+;   fmv.d.x fa1,a5
+;   fle.d a3,fa0,fa1
+;   trap_if int_ovf##(a3 ne zero)
+;   lui a0,543
+;   slli a2,a0,41
+;   fmv.d.x fa4,a2
+;   fle.d a0,fa4,fa0
+;   trap_if int_ovf##(a0 ne zero)
+;   fcvt.l.d a0,fa0,rtz
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   feq.d a0, fa0, fa0
-;   beqz a0, 0x54
-;   auipc t6, 0
-;   ld t6, 0xc(t6)
-;   j 0xc
-;   .byte 0x01, 0x00, 0x00, 0x00
-;   .byte 0x00, 0x00, 0xe0, 0xc3
-;   fmv.d.x fa3, t6
-;   fle.d a0, fa0, fa3
-;   beqz a0, 8
+;   feq.d a2, fa0, fa0
+;   bnez a2, 8
+;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: bad_toint
+;   auipc a5, 0
+;   ld a5, 0x3c(a5)
+;   fmv.d.x fa1, a5
+;   fle.d a3, fa0, fa1
+;   beqz a3, 8
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: int_ovf
-;   auipc t6, 0
-;   ld t6, 0xc(t6)
-;   j 0xc
-;   .byte 0x00, 0x00, 0x00, 0x00
-;   .byte 0x00, 0x00, 0xe0, 0x43
-;   fmv.d.x fa3, t6
-;   fle.d a0, fa3, fa0
+;   lui a0, 0x21f
+;   slli a2, a0, 0x29
+;   fmv.d.x fa4, a2
+;   fle.d a0, fa4, fa0
 ;   beqz a0, 8
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: int_ovf
-;   fcvt.l.d a0, fa0, rtz
-;   j 8
-;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: bad_toint
+;   fcvt.l.d a0, fa0, rtz ; trap: bad_toint
 ;   ret
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   .byte 0x01, 0x00, 0x00, 0x00
+;   .byte 0x00, 0x00, 0xe0, 0xc3
 
 function %f41(i32) -> f32 {
 block0(v0: i32):
@@ -1026,12 +635,12 @@ block0(v0: i32):
 
 ; VCode:
 ; block0:
-;   fcvt.s.wu fa0,a0
+;   fcvt.s.wu fa0,a0,rne
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   fcvt.s.wu fa0, a0
+;   fcvt.s.wu fa0, a0, rne
 ;   ret
 
 function %f42(i32) -> f32 {
@@ -1042,12 +651,12 @@ block0(v0: i32):
 
 ; VCode:
 ; block0:
-;   fcvt.s.w fa0,a0
+;   fcvt.s.w fa0,a0,rne
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   fcvt.s.w fa0, a0
+;   fcvt.s.w fa0, a0, rne
 ;   ret
 
 function %f43(i64) -> f32 {
@@ -1058,12 +667,12 @@ block0(v0: i64):
 
 ; VCode:
 ; block0:
-;   fcvt.s.lu fa0,a0
+;   fcvt.s.lu fa0,a0,rne
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   fcvt.s.lu fa0, a0
+;   fcvt.s.lu fa0, a0, rne
 ;   ret
 
 function %f44(i64) -> f32 {
@@ -1074,12 +683,12 @@ block0(v0: i64):
 
 ; VCode:
 ; block0:
-;   fcvt.s.l fa0,a0
+;   fcvt.s.l fa0,a0,rne
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   fcvt.s.l fa0, a0
+;   fcvt.s.l fa0, a0, rne
 ;   ret
 
 function %f45(i32) -> f64 {
@@ -1090,7 +699,7 @@ block0(v0: i32):
 
 ; VCode:
 ; block0:
-;   fcvt.d.wu fa0,a0
+;   fcvt.d.wu fa0,a0,rne
 ;   ret
 ;
 ; Disassembled:
@@ -1106,12 +715,12 @@ block0(v0: i32):
 
 ; VCode:
 ; block0:
-;   fcvt.d.w fa0,a0
+;   fcvt.d.w fa0,a0,rne
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0x53, 0x75, 0x05, 0xd2
+;   fcvt.d.w fa0, a0
 ;   ret
 
 function %f47(i64) -> f64 {
@@ -1122,12 +731,12 @@ block0(v0: i64):
 
 ; VCode:
 ; block0:
-;   fcvt.d.lu fa0,a0
+;   fcvt.d.lu fa0,a0,rne
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   fcvt.d.lu fa0, a0
+;   fcvt.d.lu fa0, a0, rne
 ;   ret
 
 function %f48(i64) -> f64 {
@@ -1138,12 +747,12 @@ block0(v0: i64):
 
 ; VCode:
 ; block0:
-;   fcvt.d.l fa0,a0
+;   fcvt.d.l fa0,a0,rne
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   fcvt.d.l fa0, a0
+;   fcvt.d.l fa0, a0, rne
 ;   ret
 
 function %f49(f32) -> i32 {
@@ -1154,16 +763,18 @@ block0(v0: f32):
 
 ; VCode:
 ; block0:
-;   fcvt_to_uint_sat.i32 a0,fa0##in_ty=f32 tmp=fa3
+;   fcvt.wu.s a2,fa0,rtz
+;   feq.s a4,fa0,fa0
+;   sub a0,zero,a4
+;   and a0,a2,a0
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   feq.s a0, fa0, fa0
-;   beqz a0, 0xc
-;   fcvt.wu.s a0, fa0, rtz
-;   j 8
-;   mv a0, zero
+;   fcvt.wu.s a2, fa0, rtz ; trap: bad_toint
+;   feq.s a4, fa0, fa0
+;   neg a0, a4
+;   and a0, a2, a0
 ;   ret
 
 function %f50(f32) -> i32 {
@@ -1174,16 +785,18 @@ block0(v0: f32):
 
 ; VCode:
 ; block0:
-;   fcvt_to_sint_sat.i32 a0,fa0##in_ty=f32 tmp=fa3
+;   fcvt.w.s a2,fa0,rtz
+;   feq.s a4,fa0,fa0
+;   sub a0,zero,a4
+;   and a0,a2,a0
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   feq.s a0, fa0, fa0
-;   beqz a0, 0xc
-;   fcvt.w.s a0, fa0, rtz
-;   j 8
-;   mv a0, zero
+;   fcvt.w.s a2, fa0, rtz ; trap: bad_toint
+;   feq.s a4, fa0, fa0
+;   neg a0, a4
+;   and a0, a2, a0
 ;   ret
 
 function %f51(f32) -> i64 {
@@ -1194,16 +807,18 @@ block0(v0: f32):
 
 ; VCode:
 ; block0:
-;   fcvt_to_uint_sat.i64 a0,fa0##in_ty=f32 tmp=fa3
+;   fcvt.lu.s a2,fa0,rtz
+;   feq.s a4,fa0,fa0
+;   sub a0,zero,a4
+;   and a0,a2,a0
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   feq.s a0, fa0, fa0
-;   beqz a0, 0xc
-;   fcvt.lu.s a0, fa0, rtz
-;   j 8
-;   mv a0, zero
+;   fcvt.lu.s a2, fa0, rtz ; trap: bad_toint
+;   feq.s a4, fa0, fa0
+;   neg a0, a4
+;   and a0, a2, a0
 ;   ret
 
 function %f52(f32) -> i64 {
@@ -1214,16 +829,18 @@ block0(v0: f32):
 
 ; VCode:
 ; block0:
-;   fcvt_to_sint_sat.i64 a0,fa0##in_ty=f32 tmp=fa3
+;   fcvt.l.s a2,fa0,rtz
+;   feq.s a4,fa0,fa0
+;   sub a0,zero,a4
+;   and a0,a2,a0
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   feq.s a0, fa0, fa0
-;   beqz a0, 0xc
-;   fcvt.l.s a0, fa0, rtz
-;   j 8
-;   mv a0, zero
+;   fcvt.l.s a2, fa0, rtz ; trap: bad_toint
+;   feq.s a4, fa0, fa0
+;   neg a0, a4
+;   and a0, a2, a0
 ;   ret
 
 function %f53(f64) -> i32 {
@@ -1234,16 +851,18 @@ block0(v0: f64):
 
 ; VCode:
 ; block0:
-;   fcvt_to_uint_sat.i32 a0,fa0##in_ty=f64 tmp=fa3
+;   fcvt.wu.d a2,fa0,rtz
+;   feq.d a4,fa0,fa0
+;   sub a0,zero,a4
+;   and a0,a2,a0
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   feq.d a0, fa0, fa0
-;   beqz a0, 0xc
-;   fcvt.wu.d a0, fa0, rtz
-;   j 8
-;   mv a0, zero
+;   fcvt.wu.d a2, fa0, rtz ; trap: bad_toint
+;   feq.d a4, fa0, fa0
+;   neg a0, a4
+;   and a0, a2, a0
 ;   ret
 
 function %f54(f64) -> i32 {
@@ -1254,16 +873,18 @@ block0(v0: f64):
 
 ; VCode:
 ; block0:
-;   fcvt_to_sint_sat.i32 a0,fa0##in_ty=f64 tmp=fa3
+;   fcvt.w.d a2,fa0,rtz
+;   feq.d a4,fa0,fa0
+;   sub a0,zero,a4
+;   and a0,a2,a0
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   feq.d a0, fa0, fa0
-;   beqz a0, 0xc
-;   fcvt.w.d a0, fa0, rtz
-;   j 8
-;   mv a0, zero
+;   fcvt.w.d a2, fa0, rtz ; trap: bad_toint
+;   feq.d a4, fa0, fa0
+;   neg a0, a4
+;   and a0, a2, a0
 ;   ret
 
 function %f55(f64) -> i64 {
@@ -1274,16 +895,18 @@ block0(v0: f64):
 
 ; VCode:
 ; block0:
-;   fcvt_to_uint_sat.i64 a0,fa0##in_ty=f64 tmp=fa3
+;   fcvt.lu.d a2,fa0,rtz
+;   feq.d a4,fa0,fa0
+;   sub a0,zero,a4
+;   and a0,a2,a0
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   feq.d a0, fa0, fa0
-;   beqz a0, 0xc
-;   fcvt.lu.d a0, fa0, rtz
-;   j 8
-;   mv a0, zero
+;   fcvt.lu.d a2, fa0, rtz ; trap: bad_toint
+;   feq.d a4, fa0, fa0
+;   neg a0, a4
+;   and a0, a2, a0
 ;   ret
 
 function %f56(f64) -> i64 {
@@ -1294,15 +917,17 @@ block0(v0: f64):
 
 ; VCode:
 ; block0:
-;   fcvt_to_sint_sat.i64 a0,fa0##in_ty=f64 tmp=fa3
+;   fcvt.l.d a2,fa0,rtz
+;   feq.d a4,fa0,fa0
+;   sub a0,zero,a4
+;   and a0,a2,a0
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   feq.d a0, fa0, fa0
-;   beqz a0, 0xc
-;   fcvt.l.d a0, fa0, rtz
-;   j 8
-;   mv a0, zero
+;   fcvt.l.d a2, fa0, rtz ; trap: bad_toint
+;   feq.d a4, fa0, fa0
+;   neg a0, a4
+;   and a0, a2, a0
 ;   ret
 
diff --git a/cranelift/filetests/filetests/isa/riscv64/floor.clif b/cranelift/filetests/filetests/isa/riscv64/floor.clif
new file mode 100644
index 000000000000..87d37139de96
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/floor.clif
@@ -0,0 +1,78 @@
+test compile precise-output
+set unwind_info=false
+target riscv64
+
+
+function %floor_f32(f32) -> f32 {
+block0(v0: f32):
+  v1 = floor v0
+  return v1
+}
+
+; VCode:
+; block0:
+;   lui a2,307200
+;   fmv.w.x fa4,a2
+;   fabs.s fa1,fa0
+;   flt.s a2,fa1,fa4
+;   fcvt.w.s a4,fa0,rdn
+;   fcvt.s.w fa1,a4,rdn
+;   fsgnj.s fa2,fa1,fa0
+;   fmv.w.x fa4,zero
+;   fadd.s fa0,fa0,fa4,rne
+;   select fa0,fa0,fa2##condition=(a2 eq zero)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   lui a2, 0x4b000
+;   fmv.w.x fa4, a2
+;   fabs.s fa1, fa0
+;   flt.s a2, fa1, fa4
+;   fcvt.w.s a4, fa0, rdn ; trap: bad_toint
+;   fcvt.s.w fa1, a4, rdn
+;   fsgnj.s fa2, fa1, fa0
+;   fmv.w.x fa4, zero
+;   fadd.s fa0, fa0, fa4, rne
+;   beqz a2, 8
+;   fmv.d fa0, fa2
+;   ret
+
+function %floor_f64(f64) -> f64 {
+block0(v0: f64):
+  v1 = floor v0
+  return v1
+}
+
+; VCode:
+; block0:
+;   lui a2,1075
+;   slli a4,a2,40
+;   fmv.d.x fa1,a4
+;   fabs.d fa2,fa0
+;   flt.d a4,fa2,fa1
+;   fcvt.l.d a0,fa0,rdn
+;   fcvt.d.l fa2,a0,rdn
+;   fsgnj.d fa4,fa2,fa0
+;   fmv.d.x fa1,zero
+;   fadd.d fa2,fa0,fa1,rne
+;   select fa0,fa2,fa4##condition=(a4 eq zero)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   lui a2, 0x433
+;   slli a4, a2, 0x28
+;   fmv.d.x fa1, a4
+;   fabs.d fa2, fa0
+;   flt.d a4, fa2, fa1
+;   fcvt.l.d a0, fa0, rdn ; trap: bad_toint
+;   fcvt.d.l fa2, a0, rdn
+;   fsgnj.d fa4, fa2, fa0
+;   fmv.d.x fa1, zero
+;   fadd.d fa2, fa0, fa1, rne
+;   fmv.d fa0, fa2
+;   beqz a4, 8
+;   fmv.d fa0, fa4
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/fma.clif b/cranelift/filetests/filetests/isa/riscv64/fma.clif
new file mode 100644
index 000000000000..ff2ea89aa960
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/fma.clif
@@ -0,0 +1,142 @@
+test compile precise-output
+set unwind_info=false
+target riscv64
+
+
+function %fmadd_f32(f32, f32, f32) -> f32 {
+block0(v0: f32, v1: f32, v2: f32):
+    v3 = fma v0, v1, v2
+    return v3
+}
+
+; VCode:
+; block0:
+;   fmadd.s fa0,fa0,fa1,fa2,rne
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   fmadd.s fa0, fa0, fa1, fa2, rne
+;   ret
+
+function %fmadd_f64(f64, f64, f64) -> f64 {
+block0(v0: f64, v1: f64, v2: f64):
+    v3 = fma v0, v1, v2
+    return v3
+}
+
+; VCode:
+; block0:
+;   fmadd.d fa0,fa0,fa1,fa2,rne
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   fmadd.d fa0, fa0, fa1, fa2, rne
+;   ret
+
+
+function %fmsub_f32(f32, f32, f32) -> f32 {
+block0(v0: f32, v1: f32, v2: f32):
+    v3 = fneg v2
+    v4 = fma v0, v1, v3
+    return v4
+}
+
+; VCode:
+; block0:
+;   fmsub.s fa0,fa0,fa1,fa2,rne
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   fmsub.s fa0, fa0, fa1, fa2, rne
+;   ret
+
+function %fmsub_f64(f64, f64, f64) -> f64 {
+block0(v0: f64, v1: f64, v2: f64):
+    v3 = fneg v2
+    v4 = fma v0, v1, v3
+    return v4
+}
+
+; VCode:
+; block0:
+;   fmsub.d fa0,fa0,fa1,fa2,rne
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   fmsub.d fa0, fa0, fa1, fa2, rne
+;   ret
+
+function %fnmsub_f32(f32, f32, f32) -> f32 {
+block0(v0: f32, v1: f32, v2: f32):
+    v3 = fneg v0
+    v4 = fma v3, v1, v2
+    return v4
+}
+
+; VCode:
+; block0:
+;   fnmsub.s fa0,fa0,fa1,fa2,rne
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   fnmsub.s fa0, fa0, fa1, fa2, rne
+;   ret
+
+function %fnmsub_f64(f64, f64, f64) -> f64 {
+block0(v0: f64, v1: f64, v2: f64):
+    v3 = fneg v0
+    v4 = fma v3, v1, v2
+    return v4
+}
+
+; VCode:
+; block0:
+;   fnmsub.d fa0,fa0,fa1,fa2,rne
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   fnmsub.d fa0, fa0, fa1, fa2, rne
+;   ret
+
+function %fnmadd_f32(f32, f32, f32) -> f32 {
+block0(v0: f32, v1: f32, v2: f32):
+    v3 = fneg v0
+    v4 = fneg v2
+    v5 = fma v3, v1, v4
+    return v5
+}
+
+; VCode:
+; block0:
+;   fnmadd.s fa0,fa0,fa1,fa2,rne
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   fnmadd.s fa0, fa0, fa1, fa2, rne
+;   ret
+
+function %fnmadd_f64(f64, f64, f64) -> f64 {
+block0(v0: f64, v1: f64, v2: f64):
+    v3 = fneg v0
+    v4 = fneg v2
+    v5 = fma v3, v1, v4
+    return v5
+}
+
+; VCode:
+; block0:
+;   fnmadd.d fa0,fa0,fa1,fa2,rne
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   fnmadd.d fa0, fa0, fa1, fa2, rne
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/fmax.clif b/cranelift/filetests/filetests/isa/riscv64/fmax.clif
new file mode 100644
index 000000000000..456ad8ca0823
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/fmax.clif
@@ -0,0 +1,60 @@
+test compile precise-output
+set unwind_info=false
+target riscv64
+
+function %fmax_f32(f32, f32) -> f32 {
+block0(v0: f32, v1: f32):
+    v2 = fmax v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   feq.s a3,fa0,fa0
+;   feq.s a5,fa1,fa1
+;   and a1,a3,a5
+;   fadd.s fa3,fa0,fa1,rne
+;   fmax.s fa5,fa0,fa1
+;   select fa0,fa5,fa3##condition=(a1 ne zero)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   feq.s a3, fa0, fa0
+;   feq.s a5, fa1, fa1
+;   and a1, a3, a5
+;   fadd.s fa3, fa0, fa1, rne
+;   fmax.s fa5, fa0, fa1
+;   fmv.d fa0, fa5
+;   bnez a1, 8
+;   fmv.d fa0, fa3
+;   ret
+
+function %fmax_f64(f64, f64) -> f64 {
+block0(v0: f64, v1: f64):
+    v2 = fmax v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   feq.d a3,fa0,fa0
+;   feq.d a5,fa1,fa1
+;   and a1,a3,a5
+;   fadd.d fa3,fa0,fa1,rne
+;   fmax.d fa5,fa0,fa1
+;   select fa0,fa5,fa3##condition=(a1 ne zero)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   feq.d a3, fa0, fa0
+;   feq.d a5, fa1, fa1
+;   and a1, a3, a5
+;   fadd.d fa3, fa0, fa1, rne
+;   fmax.d fa5, fa0, fa1
+;   fmv.d fa0, fa5
+;   bnez a1, 8
+;   fmv.d fa0, fa3
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/fmin.clif b/cranelift/filetests/filetests/isa/riscv64/fmin.clif
new file mode 100644
index 000000000000..dd208cb24a60
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/fmin.clif
@@ -0,0 +1,60 @@
+test compile precise-output
+set unwind_info=false
+target riscv64
+
+function %fmin_f32(f32, f32) -> f32 {
+block0(v0: f32, v1: f32):
+    v2 = fmin v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   feq.s a3,fa0,fa0
+;   feq.s a5,fa1,fa1
+;   and a1,a3,a5
+;   fadd.s fa3,fa0,fa1,rne
+;   fmin.s fa5,fa0,fa1
+;   select fa0,fa5,fa3##condition=(a1 ne zero)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   feq.s a3, fa0, fa0
+;   feq.s a5, fa1, fa1
+;   and a1, a3, a5
+;   fadd.s fa3, fa0, fa1, rne
+;   fmin.s fa5, fa0, fa1
+;   fmv.d fa0, fa5
+;   bnez a1, 8
+;   fmv.d fa0, fa3
+;   ret
+
+function %fmin_f64(f64, f64) -> f64 {
+block0(v0: f64, v1: f64):
+    v2 = fmin v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   feq.d a3,fa0,fa0
+;   feq.d a5,fa1,fa1
+;   and a1,a3,a5
+;   fadd.d fa3,fa0,fa1,rne
+;   fmin.d fa5,fa0,fa1
+;   select fa0,fa5,fa3##condition=(a1 ne zero)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   feq.d a3, fa0, fa0
+;   feq.d a5, fa1, fa1
+;   and a1, a3, a5
+;   fadd.d fa3, fa0, fa1, rne
+;   fmin.d fa5, fa0, fa1
+;   fmv.d fa0, fa5
+;   bnez a1, 8
+;   fmv.d fa0, fa3
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/fuzzbug-60035.clif b/cranelift/filetests/filetests/isa/riscv64/fuzzbug-60035.clif
index 4b3dd6167907..8c5d54cea4e0 100644
--- a/cranelift/filetests/filetests/isa/riscv64/fuzzbug-60035.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/fuzzbug-60035.clif
@@ -13,64 +13,21 @@ block0:
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   sd s1,-8(sp)
-;   sd s2,-16(sp)
-;   sd s3,-24(sp)
-;   sd s4,-32(sp)
-;   sd s5,-40(sp)
-;   sd s6,-48(sp)
-;   sd s7,-56(sp)
-;   sd s8,-64(sp)
-;   sd s9,-72(sp)
-;   sd s10,-80(sp)
-;   sd s11,-88(sp)
-;   fsd fs2,-96(sp)
-;   fsd fs3,-104(sp)
-;   fsd fs4,-112(sp)
-;   fsd fs5,-120(sp)
-;   fsd fs6,-128(sp)
-;   fsd fs7,-136(sp)
-;   fsd fs8,-144(sp)
-;   fsd fs9,-152(sp)
-;   fsd fs10,-160(sp)
-;   fsd fs11,-168(sp)
-;   add sp,-192
+;   addi sp,sp,-16
+;   sd s1,8(sp)
 ; block0:
-;   load_sym t0,userextname0+0
-;   sd t0,0(nominal_sp)
-;   ld t0,0(nominal_sp)
-;   callind t0
-;   ld t0,0(nominal_sp)
-;   callind t0
-;   add sp,+192
-;   ld s1,-8(sp)
-;   ld s2,-16(sp)
-;   ld s3,-24(sp)
-;   ld s4,-32(sp)
-;   ld s5,-40(sp)
-;   ld s6,-48(sp)
-;   ld s7,-56(sp)
-;   ld s8,-64(sp)
-;   ld s9,-72(sp)
-;   ld s10,-80(sp)
-;   ld s11,-88(sp)
-;   fld fs2,-96(sp)
-;   fld fs3,-104(sp)
-;   fld fs4,-112(sp)
-;   fld fs5,-120(sp)
-;   fld fs6,-128(sp)
-;   fld fs7,-136(sp)
-;   fld fs8,-144(sp)
-;   fld fs9,-152(sp)
-;   fld fs10,-160(sp)
-;   fld fs11,-168(sp)
+;   load_sym s1,userextname0+0
+;   callind s1
+;   callind s1
+;   ld s1,8(sp)
+;   addi sp,sp,16
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -79,61 +36,18 @@ block0:
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   sd s1, -8(sp)
-;   sd s2, -0x10(sp)
-;   sd s3, -0x18(sp)
-;   sd s4, -0x20(sp)
-;   sd s5, -0x28(sp)
-;   sd s6, -0x30(sp)
-;   sd s7, -0x38(sp)
-;   sd s8, -0x40(sp)
-;   sd s9, -0x48(sp)
-;   sd s10, -0x50(sp)
-;   sd s11, -0x58(sp)
-;   fsd fs2, -0x60(sp)
-;   fsd fs3, -0x68(sp)
-;   fsd fs4, -0x70(sp)
-;   fsd fs5, -0x78(sp)
-;   fsd fs6, -0x80(sp)
-;   fsd fs7, -0x88(sp)
-;   fsd fs8, -0x90(sp)
-;   fsd fs9, -0x98(sp)
-;   fsd fs10, -0xa0(sp)
-;   fsd fs11, -0xa8(sp)
-;   addi sp, sp, -0xc0
-; block1: ; offset 0x68
-;   auipc t0, 0
-;   ld t0, 0xc(t0)
+;   addi sp, sp, -0x10
+;   sd s1, 8(sp)
+; block1: ; offset 0x18
+;   auipc s1, 0
+;   ld s1, 0xc(s1)
 ;   j 0xc
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 u1:7 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   sd t0, 0(sp)
-;   ld t0, 0(sp)
-;   jalr t0
-;   ld t0, 0(sp)
-;   jalr t0
-;   addi sp, sp, 0xc0
-;   ld s1, -8(sp)
-;   ld s2, -0x10(sp)
-;   ld s3, -0x18(sp)
-;   ld s4, -0x20(sp)
-;   ld s5, -0x28(sp)
-;   ld s6, -0x30(sp)
-;   ld s7, -0x38(sp)
-;   ld s8, -0x40(sp)
-;   ld s9, -0x48(sp)
-;   ld s10, -0x50(sp)
-;   ld s11, -0x58(sp)
-;   fld fs2, -0x60(sp)
-;   fld fs3, -0x68(sp)
-;   fld fs4, -0x70(sp)
-;   fld fs5, -0x78(sp)
-;   fld fs6, -0x80(sp)
-;   fld fs7, -0x88(sp)
-;   fld fs8, -0x90(sp)
-;   fld fs9, -0x98(sp)
-;   fld fs10, -0xa0(sp)
-;   fld fs11, -0xa8(sp)
+;   jalr s1
+;   jalr s1
+;   ld s1, 8(sp)
+;   addi sp, sp, 0x10
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
diff --git a/cranelift/filetests/filetests/isa/riscv64/iabs.clif b/cranelift/filetests/filetests/isa/riscv64/iabs.clif
index 6a91b7cb1dde..8c8290a8966e 100644
--- a/cranelift/filetests/filetests/isa/riscv64/iabs.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/iabs.clif
@@ -11,17 +11,18 @@ block0(v0: i8):
 ; block0:
 ;   slli a2,a0,56
 ;   srai a4,a2,56
-;   sub a0,zero,a4
-;   select a0,a4,a0##condition=(a4 sgt a0)
+;   sub a1,zero,a4
+;   select a0,a4,a1##condition=(a4 sgt a1)
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   slli a2, a0, 0x38
 ;   srai a4, a2, 0x38
-;   neg a0, a4
-;   bge a0, a4, 8
+;   neg a1, a4
 ;   mv a0, a4
+;   blt a1, a4, 8
+;   mv a0, a1
 ;   ret
 
 function %iabs_i16(i16) -> i16 {
@@ -34,17 +35,18 @@ block0(v0: i16):
 ; block0:
 ;   slli a2,a0,48
 ;   srai a4,a2,48
-;   sub a0,zero,a4
-;   select a0,a4,a0##condition=(a4 sgt a0)
+;   sub a1,zero,a4
+;   select a0,a4,a1##condition=(a4 sgt a1)
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   slli a2, a0, 0x30
 ;   srai a4, a2, 0x30
-;   neg a0, a4
-;   bge a0, a4, 8
+;   neg a1, a4
 ;   mv a0, a4
+;   blt a1, a4, 8
+;   mv a0, a1
 ;   ret
 
 function %iabs_i32(i32) -> i32 {
@@ -64,9 +66,8 @@ block0(v0: i32):
 ; block0: ; offset 0x0
 ;   sext.w a2, a0
 ;   neg a4, a2
-;   bge a4, a2, 0xc
 ;   mv a0, a2
-;   j 8
+;   blt a4, a2, 8
 ;   mv a0, a4
 ;   ret
 
@@ -79,13 +80,16 @@ block0(v0: i64):
 ; VCode:
 ; block0:
 ;   sub a2,zero,a0
-;   select a0,a0,a2##condition=(a0 sgt a2)
+;   mv a5,a0
+;   select a0,a5,a2##condition=(a5 sgt a2)
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   neg a2, a0
-;   blt a2, a0, 8
+;   mv a5, a0
+;   mv a0, a5
+;   blt a2, a5, 8
 ;   mv a0, a2
 ;   ret
 
diff --git a/cranelift/filetests/filetests/isa/riscv64/iconst-icmp-small.clif b/cranelift/filetests/filetests/isa/riscv64/iconst-icmp-small.clif
index bbb8be09d181..49ef59eb2640 100644
--- a/cranelift/filetests/filetests/isa/riscv64/iconst-icmp-small.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/iconst-icmp-small.clif
@@ -12,26 +12,445 @@ block0:
 
 ; VCode:
 ; block0:
-;   lui a5,-2
-;   addi a1,a5,-564
-;   slli a2,a1,48
-;   srli a4,a2,48
-;   slli a0,a1,48
-;   srli a2,a0,48
-;   ne a0,a4,a2##ty=i16
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   lui a5, 0xffffe
-;   addi a1, a5, -0x234
-;   slli a2, a1, 0x30
-;   srli a4, a2, 0x30
-;   slli a0, a1, 0x30
-;   srli a2, a0, 0x30
-;   beq a4, a2, 0xc
-;   addi a0, zero, 1
-;   j 8
-;   mv a0, zero
+;   lui a0,-2
+;   addi a2,a0,-564
+;   slli a3,a2,48
+;   srai a4,a3,48
+;   slli a0,a2,48
+;   srai a2,a0,48
+;   xor a4,a4,a2
+;   sltu a0,zero,a4
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   lui a0, 0xffffe
+;   addi a2, a0, -0x234
+;   slli a3, a2, 0x30
+;   srai a4, a3, 0x30
+;   slli a0, a2, 0x30
+;   srai a2, a0, 0x30
+;   xor a4, a4, a2
+;   snez a0, a4
+;   ret
+
+function %seq_const0(i64) -> i8 system_v {
+block0(v0: i64):
+    v2 = icmp_imm eq v0, 0
+    return v2
+}
+
+; VCode:
+; block0:
+;   seqz a0,a0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   seqz a0, a0
+;   ret
+
+function %sne_const0(i64) -> i8 system_v {
+block0(v0: i64):
+    v2 = icmp_imm ne v0, 0
+    return v2
+}
+
+; VCode:
+; block0:
+;   sltu a0,zero,a0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   snez a0, a0
+;   ret
+
+function %slt_const0(i64) -> i8 system_v {
+block0(v0: i64):
+    v2 = icmp_imm slt v0, 0
+    return v2
+}
+
+; VCode:
+; block0:
+;   slt a0,a0,zero
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   sltz a0, a0
+;   ret
+
+function %sgt_const0(i64) -> i8 system_v {
+block0(v0: i64):
+    v2 = icmp_imm sgt v0, 0
+    return v2
+}
+
+; VCode:
+; block0:
+;   slt a0,zero,a0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   sgtz a0, a0
+;   ret
+
+function %ult_const0(i64) -> i8 system_v {
+block0(v0: i64):
+    v2 = icmp_imm ult v0, 0
+    return v2
+}
+
+; VCode:
+; block0:
+;   sltu a0,a0,zero
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   sltu a0, a0, zero
+;   ret
+
+function %ugt_const0(i64) -> i8 system_v {
+block0(v0: i64):
+    v2 = icmp_imm ugt v0, 0
+    return v2
+}
+
+; VCode:
+; block0:
+;   sltu a0,zero,a0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   snez a0, a0
+;   ret
+
+function %seq_const1(i64) -> i8 system_v {
+block0(v0: i64):
+    v2 = icmp_imm eq v0, 1
+    return v2
+}
+
+; VCode:
+; block0:
+;   xori a2,a0,1
+;   seqz a0,a2
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   xori a2, a0, 1
+;   seqz a0, a2
+;   ret
+
+function %sne_const1(i64) -> i8 system_v {
+block0(v0: i64):
+    v2 = icmp_imm ne v0, 1
+    return v2
+}
+
+; VCode:
+; block0:
+;   xori a2,a0,1
+;   sltu a0,zero,a2
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   xori a2, a0, 1
+;   snez a0, a2
+;   ret
+
+function %slt_const1(i64) -> i8 system_v {
+block0(v0: i64):
+    v2 = icmp_imm slt v0, 1
+    return v2
+}
+
+; VCode:
+; block0:
+;   slti a0,a0,1
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   slti a0, a0, 1
+;   ret
+
+function %sgt_const1(i64) -> i8 system_v {
+block0(v0: i64):
+    v2 = icmp_imm sgt v0, 1
+    return v2
+}
+
+; VCode:
+; block0:
+;   li a3,1
+;   slt a0,a3,a0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi a3, zero, 1
+;   slt a0, a3, a0
+;   ret
+
+function %ult_const1(i64) -> i8 system_v {
+block0(v0: i64):
+    v2 = icmp_imm ult v0, 1
+    return v2
+}
+
+; VCode:
+; block0:
+;   seqz a0,a0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   seqz a0, a0
+;   ret
+
+function %ugt_const1(i64) -> i8 system_v {
+block0(v0: i64):
+    v2 = icmp_imm ugt v0, 1
+    return v2
+}
+
+; VCode:
+; block0:
+;   li a3,1
+;   sltu a0,a3,a0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi a3, zero, 1
+;   sltu a0, a3, a0
+;   ret
+
+function %seq_const2(i64) -> i8 system_v {
+block0(v0: i64):
+    v2 = icmp_imm eq v0, 2
+    return v2
+}
+
+; VCode:
+; block0:
+;   xori a2,a0,2
+;   seqz a0,a2
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   xori a2, a0, 2
+;   seqz a0, a2
+;   ret
+
+function %sne_const2(i64) -> i8 system_v {
+block0(v0: i64):
+    v2 = icmp_imm ne v0, 2
+    return v2
+}
+
+; VCode:
+; block0:
+;   xori a2,a0,2
+;   sltu a0,zero,a2
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   xori a2, a0, 2
+;   snez a0, a2
+;   ret
+
+function %slt_const2(i64) -> i8 system_v {
+block0(v0: i64):
+    v2 = icmp_imm slt v0, 2
+    return v2
+}
+
+; VCode:
+; block0:
+;   slti a0,a0,2
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   slti a0, a0, 2
+;   ret
+
+function %sgt_const2(i64) -> i8 system_v {
+block0(v0: i64):
+    v2 = icmp_imm sgt v0, 2
+    return v2
+}
+
+; VCode:
+; block0:
+;   li a3,2
+;   slt a0,a3,a0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi a3, zero, 2
+;   slt a0, a3, a0
+;   ret
+
+function %ult_const2(i64) -> i8 system_v {
+block0(v0: i64):
+    v2 = icmp_imm ult v0, 2
+    return v2
+}
+
+; VCode:
+; block0:
+;   sltiu a0,a0,2
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   sltiu a0, a0, 2
+;   ret
+
+function %ugt_const2(i64) -> i8 system_v {
+block0(v0: i64):
+    v2 = icmp_imm ugt v0, 2
+    return v2
+}
+
+; VCode:
+; block0:
+;   li a3,2
+;   sltu a0,a3,a0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi a3, zero, 2
+;   sltu a0, a3, a0
+;   ret
+
+function %sle_const2(i64) -> i8 system_v {
+block0(v0: i64):
+    v2 = icmp_imm sle v0, 2
+    return v2
+}
+
+; VCode:
+; block0:
+;   li a4,2
+;   slt a3,a4,a0
+;   xori a0,a3,1
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi a4, zero, 2
+;   slt a3, a4, a0
+;   xori a0, a3, 1
+;   ret
+
+function %sle_const_2046(i64) -> i8 system_v {
+block0(v0: i64):
+    v2 = icmp_imm sle v0, 2046
+    return v2
+}
+
+; VCode:
+; block0:
+;   li a4,2046
+;   slt a3,a4,a0
+;   xori a0,a3,1
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi a4, zero, 0x7fe
+;   slt a3, a4, a0
+;   xori a0, a3, 1
+;   ret
+
+function %sle_const_2047(i64) -> i8 system_v {
+block0(v0: i64):
+    v2 = icmp_imm sle v0, 2047
+    return v2
+}
+
+; VCode:
+; block0:
+;   li a4,2047
+;   slt a3,a4,a0
+;   xori a0,a3,1
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi a4, zero, 0x7ff
+;   slt a3, a4, a0
+;   xori a0, a3, 1
+;   ret
+
+function %sge_const2(i64) -> i8 system_v {
+block0(v0: i64):
+    v2 = icmp_imm sge v0, 2
+    return v2
+}
+
+; VCode:
+; block0:
+;   slti a2,a0,2
+;   xori a0,a2,1
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   slti a2, a0, 2
+;   xori a0, a2, 1
+;   ret
+
+function %ule_const2(i64) -> i8 system_v {
+block0(v0: i64):
+    v2 = icmp_imm ule v0, 2
+    return v2
+}
+
+; VCode:
+; block0:
+;   li a4,2
+;   sltu a3,a4,a0
+;   xori a0,a3,1
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi a4, zero, 2
+;   sltu a3, a4, a0
+;   xori a0, a3, 1
+;   ret
+
+function %uge_const2(i64) -> i8 system_v {
+block0(v0: i64):
+    v2 = icmp_imm uge v0, 2
+    return v2
+}
+
+; VCode:
+; block0:
+;   sltiu a2,a0,2
+;   xori a0,a2,1
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   sltiu a2, a0, 2
+;   xori a0, a2, 1
 ;   ret
 
diff --git a/cranelift/filetests/filetests/isa/riscv64/inline-probestack.clif b/cranelift/filetests/filetests/isa/riscv64/inline-probestack.clif
new file mode 100644
index 000000000000..8047d4bf5db3
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/inline-probestack.clif
@@ -0,0 +1,162 @@
+test compile precise-output
+set enable_probestack=true
+set probestack_strategy=inline
+; This is the default and is equivalent to a page size of 4096
+set probestack_size_log2=12
+target riscv64
+
+
+; If the stack size is just one page, we can avoid the stack probe entirely
+function %single_page() -> i64 system_v {
+ss0 = explicit_slot 2048
+
+block0:
+  v1 = stack_addr.i64 ss0
+  return v1
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+;   addi sp,sp,-2048
+; block0:
+;   load_addr a0,0(slot)
+;   lui t6,1
+;   addi t6,t6,-2048
+;   add sp,sp,t6
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+;   addi sp, sp, -0x800
+; block1: ; offset 0x14
+;   mv a0, sp
+;   lui t6, 1
+;   addi t6, t6, -0x800
+;   add sp, sp, t6
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   ret
+
+function %unrolled() -> i64 system_v {
+ss0 = explicit_slot 12288
+
+block0:
+  v1 = stack_addr.i64 ss0
+  return v1
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+;   lui t3,-1
+;   add sp,sp,t3
+;   sw zero,0(sp)
+;   add sp,sp,t3
+;   sw zero,0(sp)
+;   add sp,sp,t3
+;   sw zero,0(sp)
+;   lui t6,3
+;   add sp,sp,t6
+;   lui t6,-3
+;   add sp,sp,t6
+; block0:
+;   load_addr a0,0(slot)
+;   lui t6,3
+;   add sp,sp,t6
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+;   lui t3, 0xfffff
+;   add sp, sp, t3
+;   sw zero, 0(sp)
+;   add sp, sp, t3
+;   sw zero, 0(sp)
+;   add sp, sp, t3
+;   sw zero, 0(sp)
+;   lui t6, 3
+;   add sp, sp, t6
+;   lui t6, 0xffffd
+;   add sp, sp, t6
+; block1: ; offset 0x3c
+;   mv a0, sp
+;   lui t6, 3
+;   add sp, sp, t6
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   ret
+
+function %large() -> i64 system_v {
+ss0 = explicit_slot 100000
+
+block0:
+  v1 = stack_addr.i64 ss0
+  return v1
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+;   inline_stack_probe##guard_size=4096 probe_count=25 tmp=t3
+;   lui t6,-24
+;   addi t6,t6,-1696
+;   add sp,sp,t6
+; block0:
+;   load_addr a0,0(slot)
+;   lui t6,24
+;   addi t6,t6,1696
+;   add sp,sp,t6
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+;   lui t6, 0x19
+;   lui t3, 1
+;   bgeu t3, t6, 0x14
+;   sub t5, sp, t6
+;   sb zero, 0(t5) ; trap: heap_oob
+;   sub t6, t6, t3
+;   j -0x10
+;   lui t6, 0xfffe8
+;   addi t6, t6, -0x6a0
+;   add sp, sp, t6
+; block1: ; offset 0x38
+;   mv a0, sp
+;   lui t6, 0x18
+;   addi t6, t6, 0x6a0
+;   add sp, sp, t6
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/ishl-const.clif b/cranelift/filetests/filetests/isa/riscv64/ishl-const.clif
index c46b536daa88..d50f69938565 100644
--- a/cranelift/filetests/filetests/isa/riscv64/ishl-const.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/ishl-const.clif
@@ -364,10 +364,10 @@ block0(v0: i128):
 ;   srl a0,a0,a2
 ;   select a2,zero,a0##condition=(a5 eq zero)
 ;   sll a5,a1,a5
-;   or a5,a2,a5
+;   or t0,a2,a5
 ;   li a2,64
-;   andi a3,a3,127
-;   select [a0,a1],[zero,a4],[a4,a5]##condition=(a3 uge a2)
+;   andi a5,a3,127
+;   select [a0,a1],[zero,a4],[a4,t0]##condition=(a5 uge a2)
 ;   ret
 ;
 ; Disassembled:
@@ -378,20 +378,18 @@ block0(v0: i128):
 ;   sub a2, a2, a5
 ;   sll a4, a0, a5
 ;   srl a0, a0, a2
-;   bnez a5, 0xc
 ;   mv a2, zero
-;   j 8
+;   beqz a5, 8
 ;   mv a2, a0
 ;   sll a5, a1, a5
-;   or a5, a2, a5
+;   or t0, a2, a5
 ;   addi a2, zero, 0x40
-;   andi a3, a3, 0x7f
-;   bltu a3, a2, 0x10
+;   andi a5, a3, 0x7f
 ;   mv a0, zero
 ;   mv a1, a4
-;   j 0xc
+;   bgeu a5, a2, 0xc
 ;   mv a0, a4
-;   mv a1, a5
+;   mv a1, t0
 ;   ret
 
 function %ishl_i128_const_i16(i128) -> i128 {
@@ -411,10 +409,10 @@ block0(v0: i128):
 ;   srl a0,a0,a2
 ;   select a2,zero,a0##condition=(a5 eq zero)
 ;   sll a5,a1,a5
-;   or a5,a2,a5
+;   or t0,a2,a5
 ;   li a2,64
-;   andi a3,a3,127
-;   select [a0,a1],[zero,a4],[a4,a5]##condition=(a3 uge a2)
+;   andi a5,a3,127
+;   select [a0,a1],[zero,a4],[a4,t0]##condition=(a5 uge a2)
 ;   ret
 ;
 ; Disassembled:
@@ -425,20 +423,18 @@ block0(v0: i128):
 ;   sub a2, a2, a5
 ;   sll a4, a0, a5
 ;   srl a0, a0, a2
-;   bnez a5, 0xc
 ;   mv a2, zero
-;   j 8
+;   beqz a5, 8
 ;   mv a2, a0
 ;   sll a5, a1, a5
-;   or a5, a2, a5
+;   or t0, a2, a5
 ;   addi a2, zero, 0x40
-;   andi a3, a3, 0x7f
-;   bltu a3, a2, 0x10
+;   andi a5, a3, 0x7f
 ;   mv a0, zero
 ;   mv a1, a4
-;   j 0xc
+;   bgeu a5, a2, 0xc
 ;   mv a0, a4
-;   mv a1, a5
+;   mv a1, t0
 ;   ret
 
 function %ishl_i128_const_i32(i128) -> i128 {
@@ -458,10 +454,10 @@ block0(v0: i128):
 ;   srl a0,a0,a2
 ;   select a2,zero,a0##condition=(a5 eq zero)
 ;   sll a5,a1,a5
-;   or a5,a2,a5
+;   or t0,a2,a5
 ;   li a2,64
-;   andi a3,a3,127
-;   select [a0,a1],[zero,a4],[a4,a5]##condition=(a3 uge a2)
+;   andi a5,a3,127
+;   select [a0,a1],[zero,a4],[a4,t0]##condition=(a5 uge a2)
 ;   ret
 ;
 ; Disassembled:
@@ -472,20 +468,18 @@ block0(v0: i128):
 ;   sub a2, a2, a5
 ;   sll a4, a0, a5
 ;   srl a0, a0, a2
-;   bnez a5, 0xc
 ;   mv a2, zero
-;   j 8
+;   beqz a5, 8
 ;   mv a2, a0
 ;   sll a5, a1, a5
-;   or a5, a2, a5
+;   or t0, a2, a5
 ;   addi a2, zero, 0x40
-;   andi a3, a3, 0x7f
-;   bltu a3, a2, 0x10
+;   andi a5, a3, 0x7f
 ;   mv a0, zero
 ;   mv a1, a4
-;   j 0xc
+;   bgeu a5, a2, 0xc
 ;   mv a0, a4
-;   mv a1, a5
+;   mv a1, t0
 ;   ret
 
 function %ishl_i128_const_i64(i128) -> i128 {
@@ -505,10 +499,10 @@ block0(v0: i128):
 ;   srl a0,a0,a2
 ;   select a2,zero,a0##condition=(a5 eq zero)
 ;   sll a5,a1,a5
-;   or a5,a2,a5
+;   or t0,a2,a5
 ;   li a2,64
-;   andi a3,a3,127
-;   select [a0,a1],[zero,a4],[a4,a5]##condition=(a3 uge a2)
+;   andi a5,a3,127
+;   select [a0,a1],[zero,a4],[a4,t0]##condition=(a5 uge a2)
 ;   ret
 ;
 ; Disassembled:
@@ -519,20 +513,18 @@ block0(v0: i128):
 ;   sub a2, a2, a5
 ;   sll a4, a0, a5
 ;   srl a0, a0, a2
-;   bnez a5, 0xc
 ;   mv a2, zero
-;   j 8
+;   beqz a5, 8
 ;   mv a2, a0
 ;   sll a5, a1, a5
-;   or a5, a2, a5
+;   or t0, a2, a5
 ;   addi a2, zero, 0x40
-;   andi a3, a3, 0x7f
-;   bltu a3, a2, 0x10
+;   andi a5, a3, 0x7f
 ;   mv a0, zero
 ;   mv a1, a4
-;   j 0xc
+;   bgeu a5, a2, 0xc
 ;   mv a0, a4
-;   mv a1, a5
+;   mv a1, t0
 ;   ret
 
 function %ishl_i128_const_i128(i128) -> i128 {
@@ -575,10 +567,9 @@ block0(v0: i128):
 ;   or a2, a3, a0
 ;   addi a3, zero, 0x40
 ;   andi a4, a4, 0x7f
-;   bltu a4, a3, 0x10
 ;   mv a0, zero
 ;   mv a1, a5
-;   j 0xc
+;   bgeu a4, a3, 0xc
 ;   mv a0, a5
 ;   mv a1, a2
 ;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/ishl.clif b/cranelift/filetests/filetests/isa/riscv64/ishl.clif
index 3dbb73cdd11b..bff7536722b8 100644
--- a/cranelift/filetests/filetests/isa/riscv64/ishl.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/ishl.clif
@@ -358,10 +358,10 @@ block0(v0: i128, v1: i8):
 ;   srl a0,a0,a3
 ;   select a3,zero,a0##condition=(a5 eq zero)
 ;   sll a5,a1,a5
-;   or a5,a3,a5
+;   or t0,a3,a5
 ;   li a3,64
-;   andi a2,a2,127
-;   select [a0,a1],[zero,a4],[a4,a5]##condition=(a2 uge a3)
+;   andi a5,a2,127
+;   select [a0,a1],[zero,a4],[a4,t0]##condition=(a5 uge a3)
 ;   ret
 ;
 ; Disassembled:
@@ -371,20 +371,18 @@ block0(v0: i128, v1: i8):
 ;   sub a3, a3, a5
 ;   sll a4, a0, a5
 ;   srl a0, a0, a3
-;   bnez a5, 0xc
 ;   mv a3, zero
-;   j 8
+;   beqz a5, 8
 ;   mv a3, a0
 ;   sll a5, a1, a5
-;   or a5, a3, a5
+;   or t0, a3, a5
 ;   addi a3, zero, 0x40
-;   andi a2, a2, 0x7f
-;   bltu a2, a3, 0x10
+;   andi a5, a2, 0x7f
 ;   mv a0, zero
 ;   mv a1, a4
-;   j 0xc
+;   bgeu a5, a3, 0xc
 ;   mv a0, a4
-;   mv a1, a5
+;   mv a1, t0
 ;   ret
 
 function %ishl_i128_i16(i128, i16) -> i128 {
@@ -402,10 +400,10 @@ block0(v0: i128, v1: i16):
 ;   srl a0,a0,a3
 ;   select a3,zero,a0##condition=(a5 eq zero)
 ;   sll a5,a1,a5
-;   or a5,a3,a5
+;   or t0,a3,a5
 ;   li a3,64
-;   andi a2,a2,127
-;   select [a0,a1],[zero,a4],[a4,a5]##condition=(a2 uge a3)
+;   andi a5,a2,127
+;   select [a0,a1],[zero,a4],[a4,t0]##condition=(a5 uge a3)
 ;   ret
 ;
 ; Disassembled:
@@ -415,20 +413,18 @@ block0(v0: i128, v1: i16):
 ;   sub a3, a3, a5
 ;   sll a4, a0, a5
 ;   srl a0, a0, a3
-;   bnez a5, 0xc
 ;   mv a3, zero
-;   j 8
+;   beqz a5, 8
 ;   mv a3, a0
 ;   sll a5, a1, a5
-;   or a5, a3, a5
+;   or t0, a3, a5
 ;   addi a3, zero, 0x40
-;   andi a2, a2, 0x7f
-;   bltu a2, a3, 0x10
+;   andi a5, a2, 0x7f
 ;   mv a0, zero
 ;   mv a1, a4
-;   j 0xc
+;   bgeu a5, a3, 0xc
 ;   mv a0, a4
-;   mv a1, a5
+;   mv a1, t0
 ;   ret
 
 function %ishl_i128_i32(i128, i32) -> i128 {
@@ -446,10 +442,10 @@ block0(v0: i128, v1: i32):
 ;   srl a0,a0,a3
 ;   select a3,zero,a0##condition=(a5 eq zero)
 ;   sll a5,a1,a5
-;   or a5,a3,a5
+;   or t0,a3,a5
 ;   li a3,64
-;   andi a2,a2,127
-;   select [a0,a1],[zero,a4],[a4,a5]##condition=(a2 uge a3)
+;   andi a5,a2,127
+;   select [a0,a1],[zero,a4],[a4,t0]##condition=(a5 uge a3)
 ;   ret
 ;
 ; Disassembled:
@@ -459,20 +455,18 @@ block0(v0: i128, v1: i32):
 ;   sub a3, a3, a5
 ;   sll a4, a0, a5
 ;   srl a0, a0, a3
-;   bnez a5, 0xc
 ;   mv a3, zero
-;   j 8
+;   beqz a5, 8
 ;   mv a3, a0
 ;   sll a5, a1, a5
-;   or a5, a3, a5
+;   or t0, a3, a5
 ;   addi a3, zero, 0x40
-;   andi a2, a2, 0x7f
-;   bltu a2, a3, 0x10
+;   andi a5, a2, 0x7f
 ;   mv a0, zero
 ;   mv a1, a4
-;   j 0xc
+;   bgeu a5, a3, 0xc
 ;   mv a0, a4
-;   mv a1, a5
+;   mv a1, t0
 ;   ret
 
 function %ishl_i128_i64(i128, i64) -> i128 {
@@ -490,10 +484,10 @@ block0(v0: i128, v1: i64):
 ;   srl a0,a0,a3
 ;   select a3,zero,a0##condition=(a5 eq zero)
 ;   sll a5,a1,a5
-;   or a5,a3,a5
+;   or t0,a3,a5
 ;   li a3,64
-;   andi a2,a2,127
-;   select [a0,a1],[zero,a4],[a4,a5]##condition=(a2 uge a3)
+;   andi a5,a2,127
+;   select [a0,a1],[zero,a4],[a4,t0]##condition=(a5 uge a3)
 ;   ret
 ;
 ; Disassembled:
@@ -503,20 +497,18 @@ block0(v0: i128, v1: i64):
 ;   sub a3, a3, a5
 ;   sll a4, a0, a5
 ;   srl a0, a0, a3
-;   bnez a5, 0xc
 ;   mv a3, zero
-;   j 8
+;   beqz a5, 8
 ;   mv a3, a0
 ;   sll a5, a1, a5
-;   or a5, a3, a5
+;   or t0, a3, a5
 ;   addi a3, zero, 0x40
-;   andi a2, a2, 0x7f
-;   bltu a2, a3, 0x10
+;   andi a5, a2, 0x7f
 ;   mv a0, zero
 ;   mv a1, a4
-;   j 0xc
+;   bgeu a5, a3, 0xc
 ;   mv a0, a4
-;   mv a1, a5
+;   mv a1, t0
 ;   ret
 
 function %ishl_i128_i128(i128, i128) -> i128 {
@@ -557,10 +549,9 @@ block0(v0: i128, v1: i128):
 ;   or a4, a3, a0
 ;   addi a3, zero, 0x40
 ;   andi a2, a2, 0x7f
-;   bltu a2, a3, 0x10
 ;   mv a0, zero
 ;   mv a1, a5
-;   j 0xc
+;   bgeu a2, a3, 0xc
 ;   mv a0, a5
 ;   mv a1, a4
 ;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/issue-6954.clif b/cranelift/filetests/filetests/isa/riscv64/issue-6954.clif
index 9aa772b2539b..f11dc422e89a 100644
--- a/cranelift/filetests/filetests/isa/riscv64/issue-6954.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/issue-6954.clif
@@ -119,205 +119,163 @@ block0(v0: i16, v1: f32, v2: f64x2, v3: i32, v4: i8, v5: i64x2, v6: i8, v7: f32x
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   add sp,-384
+;   addi sp,sp,-384
 ; block0:
-;   vle8.v v11,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v15,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v10,48(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v12,64(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v10,-64(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v13,-48(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v15,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a0,0
 ;   li a2,0
-;   li a3,0
-;   li a4,0
-;   sd a3,0(nominal_sp)
-;   sd a4,8(nominal_sp)
-;   sd a3,16(nominal_sp)
-;   sd a4,24(nominal_sp)
-;   sd a3,32(nominal_sp)
-;   sd a4,40(nominal_sp)
-;   sd a3,48(nominal_sp)
-;   sd a4,56(nominal_sp)
-;   sd a3,64(nominal_sp)
-;   sd a4,72(nominal_sp)
-;   sd a3,80(nominal_sp)
-;   sd a4,88(nominal_sp)
-;   sd a3,96(nominal_sp)
-;   sd a4,104(nominal_sp)
-;   sd a3,112(nominal_sp)
-;   sw a2,120(nominal_sp)
-;   sh a0,124(nominal_sp)
-;   sd a3,128(nominal_sp)
-;   sd a4,136(nominal_sp)
-;   sd a3,144(nominal_sp)
-;   sd a4,152(nominal_sp)
-;   sd a3,160(nominal_sp)
-;   sd a4,168(nominal_sp)
-;   sd a3,176(nominal_sp)
-;   sd a4,184(nominal_sp)
-;   sd a3,192(nominal_sp)
-;   sd a4,200(nominal_sp)
-;   sd a3,208(nominal_sp)
-;   sd a4,216(nominal_sp)
-;   sd a3,224(nominal_sp)
-;   sd a4,232(nominal_sp)
-;   sd a3,240(nominal_sp)
-;   sw a2,248(nominal_sp)
-;   sh a0,252(nominal_sp)
-;   sd a3,256(nominal_sp)
-;   sd a4,264(nominal_sp)
-;   sd a3,272(nominal_sp)
-;   sd a4,280(nominal_sp)
-;   sd a3,288(nominal_sp)
-;   sd a4,296(nominal_sp)
-;   sd a3,304(nominal_sp)
-;   sd a4,312(nominal_sp)
-;   sd a3,320(nominal_sp)
-;   sd a4,328(nominal_sp)
-;   sd a3,336(nominal_sp)
-;   sd a4,344(nominal_sp)
-;   sd a3,352(nominal_sp)
-;   sd a4,360(nominal_sp)
-;   sd a3,368(nominal_sp)
-;   sw a2,376(nominal_sp)
-;   sh a0,380(nominal_sp)
+;   sd a0,0(slot)
+;   sd a2,8(slot)
+;   sd a0,16(slot)
+;   sd a2,24(slot)
+;   sd a0,32(slot)
+;   sd a2,40(slot)
+;   sd a0,48(slot)
+;   sd a2,56(slot)
+;   sd a0,64(slot)
+;   sd a2,72(slot)
+;   sd a0,80(slot)
+;   sd a2,88(slot)
+;   sd a0,96(slot)
+;   sd a2,104(slot)
+;   sd zero,112(slot)
+;   sw zero,120(slot)
+;   sh zero,124(slot)
+;   sd a0,128(slot)
+;   sd a2,136(slot)
+;   sd a0,144(slot)
+;   sd a2,152(slot)
+;   sd a0,160(slot)
+;   sd a2,168(slot)
+;   sd a0,176(slot)
+;   sd a2,184(slot)
+;   sd a0,192(slot)
+;   sd a2,200(slot)
+;   sd a0,208(slot)
+;   sd a2,216(slot)
+;   sd a0,224(slot)
+;   sd a2,232(slot)
+;   sd zero,240(slot)
+;   sw zero,248(slot)
+;   sh zero,252(slot)
+;   sd a0,256(slot)
+;   sd a2,264(slot)
+;   sd a0,272(slot)
+;   sd a2,280(slot)
+;   sd a0,288(slot)
+;   sd a2,296(slot)
+;   sd a0,304(slot)
+;   sd a2,312(slot)
+;   sd a0,320(slot)
+;   sd a2,328(slot)
+;   sd a0,336(slot)
+;   sd a2,344(slot)
+;   sd a0,352(slot)
+;   sd a2,360(slot)
+;   sd zero,368(slot)
+;   sw zero,376(slot)
+;   sh zero,380(slot)
 ;   sext.w a2,a1
-;   select v12,v12,v12##condition=(a2 ne zero)
+;   select v12,v15,v15##condition=(a2 ne zero)
 ;   sext.w a2,a1
 ;   select v12,v12,v12##condition=(a2 ne zero)
 ;   sext.w a2,a1
-;   select v12,v12,v12##condition=(a2 ne zero)
-;   vfsqrt.v v10,v11 #avl=2, #vtype=(e64, m1, ta, ma)
-;   lui a0,4095
-;   slli a2,a0,39
-;   fmv.d.x fa4,a2
-;   vfmv.v.f v11,fa4 #avl=2, #vtype=(e64, m1, ta, ma)
-;   vmfne.vv v0,v10,v10 #avl=2, #vtype=(e64, m1, ta, ma)
-;   vmerge.vvm v13,v10,v11,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
-;   vfsqrt.v v10,v13 #avl=2, #vtype=(e64, m1, ta, ma)
-;   lui a0,4095
-;   slli a2,a0,39
-;   fmv.d.x fa4,a2
-;   vfmv.v.f v13,fa4 #avl=2, #vtype=(e64, m1, ta, ma)
-;   vmfne.vv v0,v10,v10 #avl=2, #vtype=(e64, m1, ta, ma)
-;   vmerge.vvm v11,v10,v13,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
+;   select v14,v12,v12##condition=(a2 ne zero)
+;   vfsqrt.v v11,v10 #avl=2, #vtype=(e64, m1, ta, ma)
+;   lui a2,4095
+;   slli a3,a2,39
+;   fmv.d.x fa5,a3
+;   vfmv.v.f v12,fa5 #avl=2, #vtype=(e64, m1, ta, ma)
+;   vmfne.vv v0,v11,v11 #avl=2, #vtype=(e64, m1, ta, ma)
+;   vmerge.vvm v15,v11,v12,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
+;   vfsqrt.v v11,v15 #avl=2, #vtype=(e64, m1, ta, ma)
+;   lui a2,4095
+;   slli a3,a2,39
+;   fmv.d.x fa5,a3
+;   vfmv.v.f v15,fa5 #avl=2, #vtype=(e64, m1, ta, ma)
+;   vmfne.vv v0,v11,v11 #avl=2, #vtype=(e64, m1, ta, ma)
+;   vmerge.vvm v12,v11,v15,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   sext.w a2,a1
-;   select v12,v12,v12##condition=(a2 ne zero)
+;   select v14,v14,v14##condition=(a2 ne zero)
 ;   sext.w a2,a1
-;   select v12,v12,v12##condition=(a2 ne zero)
+;   select v14,v14,v14##condition=(a2 ne zero)
 ;   sext.w a2,a1
-;   select v12,v12,v12##condition=(a2 ne zero)
+;   select v14,v14,v14##condition=(a2 ne zero)
 ;   sext.w a2,a1
-;   select v12,v12,v12##condition=(a2 ne zero)
+;   select v14,v14,v14##condition=(a2 ne zero)
 ;   sext.w a2,a1
-;   select v12,v12,v12##condition=(a2 ne zero)
+;   select v14,v14,v14##condition=(a2 ne zero)
 ;   sext.w a2,a1
-;   select v12,v12,v12##condition=(a2 ne zero)
+;   select v14,v14,v14##condition=(a2 ne zero)
 ;   sext.w a2,a1
-;   select v12,v12,v12##condition=(a2 ne zero)
+;   select v14,v14,v14##condition=(a2 ne zero)
 ;   sext.w a2,a1
-;   select v12,v12,v12##condition=(a2 ne zero)
-;   add a2,a1,a1
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   vmax.vv v10,v15,v15 #avl=2, #vtype=(e64, m1, ta, ma)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   load_addr a3,3(nominal_sp)
-;   addi a3,a3,0
-;   andi a0,a3,3
-;   slli a4,a0,3
-;   andi a1,a3,-4
-;   atomic_rmw.i8 and a0,a5,(a1)##t0=a3 offset=a4
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   vse64.v v10,33(nominal_sp) #avl=2, #vtype=(e64, m1, ta, ma)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   sext.w a1,a2
-;   select v12,v12,v12##condition=(a1 ne zero)
-;   vse8.v v11,0(a6) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vse8.v v12,16(a6) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vse8.v v11,32(a6) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vse8.v v12,48(a6) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vse8.v v12,64(a6) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vse8.v v12,80(a6) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vse8.v v12,96(a6) #avl=16, #vtype=(e8, m1, ta, ma)
-;   add sp,+384
+;   select v14,v14,v14##condition=(a2 ne zero)
+;   addw a3,a1,a1
+;   select v11,v14,v14##condition=(a3 ne zero)
+;   select v11,v11,v11##condition=(a3 ne zero)
+;   select v11,v11,v11##condition=(a3 ne zero)
+;   select v11,v11,v11##condition=(a3 ne zero)
+;   select v14,v11,v11##condition=(a3 ne zero)
+;   vmax.vv v11,v13,v13 #avl=2, #vtype=(e64, m1, ta, ma)
+;   select v13,v14,v14##condition=(a3 ne zero)
+;   load_addr a4,3(slot)
+;   addi a4,a4,0
+;   andi a1,a4,3
+;   slli a1,a1,3
+;   andi a2,a4,-4
+;   atomic_rmw.i8 and a0,a5,(a2)##t0=a4 offset=a1
+;   select v10,v13,v13##condition=(a3 ne zero)
+;   select v10,v10,v10##condition=(a3 ne zero)
+;   select v10,v10,v10##condition=(a3 ne zero)
+;   select v10,v10,v10##condition=(a3 ne zero)
+;   select v10,v10,v10##condition=(a3 ne zero)
+;   select v10,v10,v10##condition=(a3 ne zero)
+;   select v10,v10,v10##condition=(a3 ne zero)
+;   vse64.v v11,33(slot) #avl=2, #vtype=(e64, m1, ta, ma)
+;   select v11,v10,v10##condition=(a3 ne zero)
+;   select v11,v11,v11##condition=(a3 ne zero)
+;   select v11,v11,v11##condition=(a3 ne zero)
+;   select v11,v11,v11##condition=(a3 ne zero)
+;   select v11,v11,v11##condition=(a3 ne zero)
+;   select v11,v11,v11##condition=(a3 ne zero)
+;   select v11,v11,v11##condition=(a3 ne zero)
+;   select v11,v11,v11##condition=(a3 ne zero)
+;   select v11,v11,v11##condition=(a3 ne zero)
+;   select v11,v11,v11##condition=(a3 ne zero)
+;   select v11,v11,v11##condition=(a3 ne zero)
+;   select v11,v11,v11##condition=(a3 ne zero)
+;   select v11,v11,v11##condition=(a3 ne zero)
+;   select v11,v11,v11##condition=(a3 ne zero)
+;   select v11,v11,v11##condition=(a3 ne zero)
+;   select v11,v11,v11##condition=(a3 ne zero)
+;   select v11,v11,v11##condition=(a3 ne zero)
+;   select v11,v11,v11##condition=(a3 ne zero)
+;   select v11,v11,v11##condition=(a3 ne zero)
+;   select v11,v11,v11##condition=(a3 ne zero)
+;   select v11,v11,v11##condition=(a3 ne zero)
+;   select v11,v11,v11##condition=(a3 ne zero)
+;   select v11,v11,v11##condition=(a3 ne zero)
+;   select v11,v11,v11##condition=(a3 ne zero)
+;   select v11,v11,v11##condition=(a3 ne zero)
+;   select v11,v11,v11##condition=(a3 ne zero)
+;   vse8.v v12,0(a6) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vse8.v v11,16(a6) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vse8.v v12,32(a6) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vse8.v v11,48(a6) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vse8.v v11,64(a6) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vse8.v v11,80(a6) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vse8.v v11,96(a6) #avl=16, #vtype=(e8, m1, ta, ma)
+;   addi sp,sp,384
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -329,87 +287,89 @@ block0(v0: i16, v1: f32, v2: f64x2, v3: i32, v4: i8, v5: i64x2, v6: i8, v7: f32x
 ;   addi sp, sp, -0x180
 ; block1: ; offset 0x14
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
-;   .byte 0x87, 0x85, 0x0f, 0x02
-;   addi t6, s0, 0x20
-;   .byte 0x87, 0x87, 0x0f, 0x02
-;   addi t6, s0, 0x30
+;   addi t6, sp, 0x190
 ;   .byte 0x07, 0x85, 0x0f, 0x02
-;   addi t6, s0, 0x40
-;   .byte 0x07, 0x86, 0x0f, 0x02
+;   addi t6, sp, 0x1a0
+;   .byte 0x87, 0x86, 0x0f, 0x02
+;   addi t6, sp, 0x1c0
+;   .byte 0x87, 0x87, 0x0f, 0x02
 ;   mv a0, zero
 ;   mv a2, zero
-;   mv a3, zero
-;   mv a4, zero
-;   sd a3, 0(sp)
-;   sd a4, 8(sp)
-;   sd a3, 0x10(sp)
-;   sd a4, 0x18(sp)
-;   sd a3, 0x20(sp)
-;   sd a4, 0x28(sp)
-;   sd a3, 0x30(sp)
-;   sd a4, 0x38(sp)
-;   sd a3, 0x40(sp)
-;   sd a4, 0x48(sp)
-;   sd a3, 0x50(sp)
-;   sd a4, 0x58(sp)
-;   sd a3, 0x60(sp)
-;   sd a4, 0x68(sp)
-;   sd a3, 0x70(sp)
-;   sw a2, 0x78(sp)
-;   sh a0, 0x7c(sp)
-;   sd a3, 0x80(sp)
-;   sd a4, 0x88(sp)
-;   sd a3, 0x90(sp)
-;   sd a4, 0x98(sp)
-;   sd a3, 0xa0(sp)
-;   sd a4, 0xa8(sp)
-;   sd a3, 0xb0(sp)
-;   sd a4, 0xb8(sp)
-;   sd a3, 0xc0(sp)
-;   sd a4, 0xc8(sp)
-;   sd a3, 0xd0(sp)
-;   sd a4, 0xd8(sp)
-;   sd a3, 0xe0(sp)
-;   sd a4, 0xe8(sp)
-;   sd a3, 0xf0(sp)
-;   sw a2, 0xf8(sp)
-;   sh a0, 0xfc(sp)
-;   sd a3, 0x100(sp)
-;   sd a4, 0x108(sp)
-;   sd a3, 0x110(sp)
-;   sd a4, 0x118(sp)
-;   sd a3, 0x120(sp)
-;   sd a4, 0x128(sp)
-;   sd a3, 0x130(sp)
-;   sd a4, 0x138(sp)
-;   sd a3, 0x140(sp)
-;   sd a4, 0x148(sp)
-;   sd a3, 0x150(sp)
-;   sd a4, 0x158(sp)
-;   sd a3, 0x160(sp)
-;   sd a4, 0x168(sp)
-;   sd a3, 0x170(sp)
-;   sw a2, 0x178(sp)
-;   sh a0, 0x17c(sp)
+;   sd a0, 0(sp)
+;   sd a2, 8(sp)
+;   sd a0, 0x10(sp)
+;   sd a2, 0x18(sp)
+;   sd a0, 0x20(sp)
+;   sd a2, 0x28(sp)
+;   sd a0, 0x30(sp)
+;   sd a2, 0x38(sp)
+;   sd a0, 0x40(sp)
+;   sd a2, 0x48(sp)
+;   sd a0, 0x50(sp)
+;   sd a2, 0x58(sp)
+;   sd a0, 0x60(sp)
+;   sd a2, 0x68(sp)
+;   sd zero, 0x70(sp)
+;   sw zero, 0x78(sp)
+;   sh zero, 0x7c(sp)
+;   sd a0, 0x80(sp)
+;   sd a2, 0x88(sp)
+;   sd a0, 0x90(sp)
+;   sd a2, 0x98(sp)
+;   sd a0, 0xa0(sp)
+;   sd a2, 0xa8(sp)
+;   sd a0, 0xb0(sp)
+;   sd a2, 0xb8(sp)
+;   sd a0, 0xc0(sp)
+;   sd a2, 0xc8(sp)
+;   sd a0, 0xd0(sp)
+;   sd a2, 0xd8(sp)
+;   sd a0, 0xe0(sp)
+;   sd a2, 0xe8(sp)
+;   sd zero, 0xf0(sp)
+;   sw zero, 0xf8(sp)
+;   sh zero, 0xfc(sp)
+;   sd a0, 0x100(sp)
+;   sd a2, 0x108(sp)
+;   sd a0, 0x110(sp)
+;   sd a2, 0x118(sp)
+;   sd a0, 0x120(sp)
+;   sd a2, 0x128(sp)
+;   sd a0, 0x130(sp)
+;   sd a2, 0x138(sp)
+;   sd a0, 0x140(sp)
+;   sd a2, 0x148(sp)
+;   sd a0, 0x150(sp)
+;   sd a2, 0x158(sp)
+;   sd a0, 0x160(sp)
+;   sd a2, 0x168(sp)
+;   sd zero, 0x170(sp)
+;   sw zero, 0x178(sp)
+;   sh zero, 0x17c(sp)
 ;   sext.w a2, a1
+;   .byte 0x57, 0x36, 0xf0, 0x9e
+;   bnez a2, 8
+;   .byte 0x57, 0x36, 0xf0, 0x9e
 ;   sext.w a2, a1
 ;   sext.w a2, a1
+;   .byte 0x57, 0x37, 0xc0, 0x9e
+;   bnez a2, 8
+;   .byte 0x57, 0x37, 0xc0, 0x9e
 ;   .byte 0x57, 0x70, 0x81, 0xcd
-;   .byte 0x57, 0x15, 0xb0, 0x4e
-;   lui a0, 0xfff
-;   slli a2, a0, 0x27
-;   fmv.d.x fa4, a2
-;   .byte 0xd7, 0x55, 0x07, 0x5e
-;   .byte 0x57, 0x10, 0xa5, 0x72
-;   .byte 0xd7, 0x86, 0xa5, 0x5c
-;   .byte 0x57, 0x15, 0xd0, 0x4e
-;   lui a0, 0xfff
-;   slli a2, a0, 0x27
-;   fmv.d.x fa4, a2
-;   .byte 0xd7, 0x56, 0x07, 0x5e
-;   .byte 0x57, 0x10, 0xa5, 0x72
-;   .byte 0xd7, 0x85, 0xa6, 0x5c
+;   .byte 0xd7, 0x15, 0xa0, 0x4e
+;   lui a2, 0xfff
+;   slli a3, a2, 0x27
+;   fmv.d.x fa5, a3
+;   .byte 0x57, 0xd6, 0x07, 0x5e
+;   .byte 0x57, 0x90, 0xb5, 0x72
+;   .byte 0xd7, 0x07, 0xb6, 0x5c
+;   .byte 0xd7, 0x15, 0xf0, 0x4e
+;   lui a2, 0xfff
+;   slli a3, a2, 0x27
+;   fmv.d.x fa5, a3
+;   .byte 0xd7, 0xd7, 0x07, 0x5e
+;   .byte 0x57, 0x90, 0xb5, 0x72
+;   .byte 0x57, 0x86, 0xb7, 0x5c
 ;   sext.w a2, a1
 ;   sext.w a2, a1
 ;   sext.w a2, a1
@@ -418,82 +378,58 @@ block0(v0: i16, v1: f32, v2: f64x2, v3: i32, v4: i8, v5: i64x2, v6: i8, v7: f32x
 ;   sext.w a2, a1
 ;   sext.w a2, a1
 ;   sext.w a2, a1
-;   add a2, a1, a1
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   .byte 0x57, 0x85, 0xf7, 0x1e
-;   sext.w a1, a2
-;   addi a3, sp, 3
-;   mv a3, a3
-;   andi a0, a3, 3
-;   slli a4, a0, 3
-;   andi a1, a3, -4
-;   lr.w.aqrl a0, (a1)
-;   srl a0, a0, a4
+;   addw a3, a1, a1
+;   .byte 0xd7, 0x35, 0xe0, 0x9e
+;   bnez a3, 8
+;   .byte 0xd7, 0x35, 0xe0, 0x9e
+;   .byte 0x57, 0x37, 0xb0, 0x9e
+;   bnez a3, 8
+;   .byte 0x57, 0x37, 0xb0, 0x9e
+;   .byte 0xd7, 0x85, 0xd6, 0x1e
+;   .byte 0xd7, 0x36, 0xe0, 0x9e
+;   bnez a3, 8
+;   .byte 0xd7, 0x36, 0xe0, 0x9e
+;   addi a4, sp, 3
+;   mv a4, a4
+;   andi a1, a4, 3
+;   slli a1, a1, 3
+;   andi a2, a4, -4
+;   lr.w.aqrl a0, (a2) ; trap: heap_oob
+;   srl a0, a0, a1
 ;   andi a0, a0, 0xff
-;   and a3, a0, a5
-;   lr.w.aqrl t5, (a1)
+;   and a4, a0, a5
+;   lr.w.aqrl t5, (a2) ; trap: heap_oob
 ;   addi t6, zero, 0xff
-;   sll t6, t6, a4
+;   sll t6, t6, a1
 ;   not t6, t6
 ;   and t5, t5, t6
-;   andi t6, a3, 0xff
-;   sll t6, t6, a4
+;   andi t6, a4, 0xff
+;   sll t6, t6, a1
 ;   or t5, t5, t6
-;   sc.w.aqrl a3, t5, (a1)
-;   bnez a3, -0x34
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
+;   sc.w.aqrl a4, t5, (a2) ; trap: heap_oob
+;   bnez a4, -0x34
+;   .byte 0x57, 0x35, 0xd0, 0x9e
+;   bnez a3, 8
+;   .byte 0x57, 0x35, 0xd0, 0x9e
 ;   addi t6, sp, 0x21
-;   .byte 0x27, 0xf5, 0x0f, 0x02
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
-;   sext.w a1, a2
+;   .byte 0xa7, 0xf5, 0x0f, 0x02
+;   .byte 0xd7, 0x35, 0xa0, 0x9e
+;   bnez a3, 8
+;   .byte 0xd7, 0x35, 0xa0, 0x9e
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   .byte 0xa7, 0x05, 0x08, 0x02
+;   .byte 0x27, 0x06, 0x08, 0x02
 ;   addi t6, a6, 0x10
-;   .byte 0x27, 0x86, 0x0f, 0x02
-;   addi t6, a6, 0x20
 ;   .byte 0xa7, 0x85, 0x0f, 0x02
-;   addi t6, a6, 0x30
+;   addi t6, a6, 0x20
 ;   .byte 0x27, 0x86, 0x0f, 0x02
+;   addi t6, a6, 0x30
+;   .byte 0xa7, 0x85, 0x0f, 0x02
 ;   addi t6, a6, 0x40
-;   .byte 0x27, 0x86, 0x0f, 0x02
+;   .byte 0xa7, 0x85, 0x0f, 0x02
 ;   addi t6, a6, 0x50
-;   .byte 0x27, 0x86, 0x0f, 0x02
+;   .byte 0xa7, 0x85, 0x0f, 0x02
 ;   addi t6, a6, 0x60
-;   .byte 0x27, 0x86, 0x0f, 0x02
+;   .byte 0xa7, 0x85, 0x0f, 0x02
 ;   addi sp, sp, 0x180
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
diff --git a/cranelift/filetests/filetests/isa/riscv64/issue8847-1.clif b/cranelift/filetests/filetests/isa/riscv64/issue8847-1.clif
new file mode 100644
index 000000000000..64dae40ca8ef
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/issue8847-1.clif
@@ -0,0 +1,57 @@
+;; Compile test case
+
+test compile
+target riscv64
+
+function u1:0() tail {
+    ss0 = explicit_slot 50, align = 512
+    ss1 = explicit_slot 47, align = 4
+    ss2 = explicit_slot 34, align = 32
+    ss3 = explicit_slot 103, align = 1024
+    ss4 = explicit_slot 110, align = 512
+    ss5 = explicit_slot 126, align = 512
+    sig0 = (i64 sext, i64 sext, i64 sext, i64 sext, i64 sext, i64 sext, i64 sext, i8 uext, i16 uext, i16, i64 sext, i64 sext, i128 uext, i8 sext, f32) tail
+
+block0:
+    v0 = iconst.i64 0xef31_de2a_2352_79ff
+    v3 = iconst.i16 0xffef
+    v164 = iconst.i64 0
+    v7 = uextend.i128 v164  ; v164 = 0
+    v14 = iconst.i8 203
+    v15 = f32const -0x1.979796p24
+    v112 = iconst.i8 0
+    v134 = iconst.i8 0
+    v147 = iconst.i8 0
+    v154 = iconst.i8 0
+    v156 = iconst.i32 0
+    v157 = iconst.i32 0
+    v163 = iconst.i64 0
+    brif v112, block40, block39  ; v112 = 0
+
+block40:
+    trap user0
+
+block39:
+    brif.i8 v134, block58, block57  ; v134 = 0
+
+block58:
+    trap user0
+
+block57:
+    brif.i8 v147, block68, block67  ; v147 = 0
+
+block68:
+    trap user0
+
+block67:
+    brif.i8 v154, block73, block72  ; v154 = 0
+
+block73:
+    br_table v156, block1, [block1, block1]  ; v156 = 0
+
+block72:
+    br_table v157, block1, [block1, block1]  ; v157 = 0
+
+block1 cold:
+    return_call_indirect.i64 sig0, v163(v0, v0, v0, v0, v0, v0, v0, v14, v3, v3, v0, v0, v7, v14, v15)  ; v163 = 0, v0 = 0xef31_de2a_2352_79ff, v0 = 0xef31_de2a_2352_79ff, v0 = 0xef31_de2a_2352_79ff, v0 = 0xef31_de2a_2352_79ff, v0 = 0xef31_de2a_2352_79ff, v0 = 0xef31_de2a_2352_79ff, v0 = 0xef31_de2a_2352_79ff, v14 = 203, v3 = 0xffef, v3 = 0xffef, v0 = 0xef31_de2a_2352_79ff, v0 = 0xef31_de2a_2352_79ff, v14 = 203, v15 = -0x1.979796p24
+}
diff --git a/cranelift/filetests/filetests/isa/riscv64/issue8847.clif b/cranelift/filetests/filetests/isa/riscv64/issue8847.clif
new file mode 100644
index 000000000000..c7c79d5b8809
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/issue8847.clif
@@ -0,0 +1,480 @@
+;; Compile test case
+
+test compile
+set bb_padding_log2_minus_one=4
+set enable_alias_analysis=false
+set enable_llvm_abi_extensions=true
+set machine_code_cfg_info=true
+set enable_jump_tables=false
+set enable_heap_access_spectre_mitigation=false
+target riscv64 has_zcd has_zbkb has_zbc has_zbs has_zicond has_zvl32b has_zvl64b has_zvl128b has_zvl1024b has_zvl2048b has_zvl4096b has_zvl8192b has_zvl16384b has_zvl32768b
+
+function u1:0() tail {
+    ss0 = explicit_slot 50, align = 512
+    ss1 = explicit_slot 47, align = 4
+    ss2 = explicit_slot 34, align = 32
+    ss3 = explicit_slot 103, align = 1024
+    ss4 = explicit_slot 110, align = 512
+    ss5 = explicit_slot 126, align = 512
+    sig0 = (f32, f64, f64, f32, i8 uext, i128, i8 uext, i32, i16 sext, i64, i64 sext, i128, i8 sext, i8, i64, i64 sext) -> i16 sext, i64 sext, f64, i32 sext, f64, i8 sext, i64 sext, f32
+    sig1 = () system_v
+    sig2 = (i128, i16 sext, i128 sext, i32 sext, i16, i64 uext, f32, i8 sext, f32, i8, i64, i64, i64, i64 uext, f64) -> f64, i8 uext, f32, i128, i64 uext, i8, i16 sext, i64 sext tail
+    sig3 = () -> i8 sext, f32, i128, i32, f32, i128 uext, i8, i8 uext, f64, i8 sext, f32 system_v
+    sig4 = (i8, i16, i64 sext, i64 sext, i128 uext, i8, i32, f64, i32, f32, i128 uext, i8, i8 uext, f64, f64) -> i8 uext system_v
+    sig5 = (i8 sext, i64 uext, i16 sext, i64 sext, i128 uext, i128 sext, f32, i16 uext, i64 sext, i32 sext, i64, i64 uext, f64, f64, i16 sext) -> f32 tail
+    sig6 = (i64 sext, i64 sext, i64 sext, i64 sext, i64 sext, i64 sext, i64 sext, i8 uext, i16 uext, i16, i64 sext, i64 sext, i128 uext, i8 sext, f32) tail
+    sig7 = (f32) -> f32 system_v
+    sig8 = (f64) -> f64 system_v
+    sig9 = (f32) -> f32 system_v
+    sig10 = (f64) -> f64 system_v
+    sig11 = (f32) -> f32 system_v
+    sig12 = (f64) -> f64 system_v
+    sig13 = (f32) -> f32 system_v
+    sig14 = (f64) -> f64 system_v
+    sig15 = (f32, f32, f32) -> f32 system_v
+    sig16 = (f64, f64, f64) -> f64 system_v
+    fn0 = colocated u2:0 sig0
+    fn1 = colocated u2:1 sig1
+    fn2 = colocated u2:2 sig2
+    fn3 = colocated u2:3 sig3
+    fn4 = colocated u2:4 sig4
+    fn5 = colocated u2:5 sig5
+    fn6 = colocated u2:6 sig6
+    fn7 = %CeilF32 sig7
+    fn8 = %CeilF64 sig8
+    fn9 = %FloorF32 sig9
+    fn10 = %FloorF64 sig10
+    fn11 = colocated %TruncF32 sig11
+    fn12 = %TruncF64 sig12
+    fn13 = colocated %NearestF32 sig13
+    fn14 = %NearestF64 sig14
+    fn15 = %FmaF32 sig15
+    fn16 = %FmaF64 sig16
+
+block0:
+    v0 = iconst.i64 0xef31_de2a_2352_79ff
+    v158 -> v0
+    v1 = iconst.i64 0x2231_ffd1_ff29_ff26
+    v2 = f64const 0x1.8ff2320672823p-225
+    v3 = iconst.i16 0xffef
+    v160 -> v3
+    v4 = iconst.i64 0xddde_2a23_52f9_ffff
+    v5 = iconst.i64 0xc8c8_c8c8_c8c8_c8c8
+    v6 = iconst.i64 0xc8c8_c8c8_c8c8_c8c8
+    v7 = iconcat v6, v5  ; v6 = 0xc8c8_c8c8_c8c8_c8c8, v5 = 0xc8c8_c8c8_c8c8_c8c8
+    v161 -> v7
+    v8 = iconst.i64 0xc8c8_c8c8_c8c8_c8c8
+    v9 = iconst.i64 0xc8c8_c8c8_c8c8_c8c8
+    v10 = iconcat v9, v8  ; v9 = 0xc8c8_c8c8_c8c8_c8c8, v8 = 0xc8c8_c8c8_c8c8_c8c8
+    v11 = iconst.i64 0xcbcb_cbcb_cbc8_c8c8
+    v12 = iconst.i64 0xc8c8_c8c8_c8c8_c8c8
+    v13 = iconcat v12, v11  ; v12 = 0xc8c8_c8c8_c8c8_c8c8, v11 = 0xcbcb_cbcb_cbc8_c8c8
+    v14 = iconst.i8 203
+    v159 -> v14
+    v15 = f32const -0x1.979796p24
+    v162 -> v15
+    v16 = iconst.i64 0x0031_2222_2a2f
+    v17 = iconst.i64 0xcbcb_2adc_9e98_d7d4
+    v18 = iconcat v17, v16  ; v17 = 0xcbcb_2adc_9e98_d7d4, v16 = 0x0031_2222_2a2f
+    v19 = iconst.i8 0
+    v20 = iconst.i16 0
+    v21 = iconst.i32 0
+    v22 = iconst.i64 0
+    v23 = uextend.i128 v22  ; v22 = 0
+    v24 = stack_addr.i64 ss2
+    store notrap table v23, v24
+    v25 = stack_addr.i64 ss2+16
+    store notrap table v23, v25
+    v26 = stack_addr.i64 ss2+32
+    store notrap table v20, v26  ; v20 = 0
+    v27 = stack_addr.i64 ss1
+    store notrap table v23, v27
+    v28 = stack_addr.i64 ss1+16
+    store notrap table v23, v28
+    v29 = stack_addr.i64 ss1+32
+    store notrap table v22, v29  ; v22 = 0
+    v30 = stack_addr.i64 ss1+40
+    store notrap table v21, v30  ; v21 = 0
+    v31 = stack_addr.i64 ss1+44
+    store notrap table v20, v31  ; v20 = 0
+    v32 = stack_addr.i64 ss1+46
+    store notrap table v19, v32  ; v19 = 0
+    v33 = stack_addr.i64 ss0
+    store notrap table v23, v33
+    v34 = stack_addr.i64 ss0+16
+    store notrap table v23, v34
+    v35 = stack_addr.i64 ss0+32
+    store notrap table v23, v35
+    v36 = stack_addr.i64 ss0+48
+    store notrap table v20, v36  ; v20 = 0
+    v37 = stack_addr.i64 ss3
+    store notrap vmctx v23, v37
+    v38 = stack_addr.i64 ss3+16
+    store notrap vmctx v23, v38
+    v39 = stack_addr.i64 ss3+32
+    store notrap vmctx v23, v39
+    v40 = stack_addr.i64 ss3+48
+    store notrap vmctx v23, v40
+    v41 = stack_addr.i64 ss3+64
+    store notrap vmctx v23, v41
+    v42 = stack_addr.i64 ss3+80
+    store notrap vmctx v23, v42
+    v43 = stack_addr.i64 ss3+96
+    store notrap vmctx v21, v43  ; v21 = 0
+    v44 = stack_addr.i64 ss3+100
+    store notrap vmctx v20, v44  ; v20 = 0
+    v45 = stack_addr.i64 ss3+102
+    store notrap vmctx v19, v45  ; v19 = 0
+    v46 = stack_addr.i64 ss4
+    store notrap heap v23, v46
+    v47 = stack_addr.i64 ss4+16
+    store notrap heap v23, v47
+    v48 = stack_addr.i64 ss4+32
+    store notrap heap v23, v48
+    v49 = stack_addr.i64 ss4+48
+    store notrap heap v23, v49
+    v50 = stack_addr.i64 ss4+64
+    store notrap heap v23, v50
+    v51 = stack_addr.i64 ss4+80
+    store notrap heap v23, v51
+    v52 = stack_addr.i64 ss4+96
+    store notrap heap v22, v52  ; v22 = 0
+    v53 = stack_addr.i64 ss4+104
+    store notrap heap v21, v53  ; v21 = 0
+    v54 = stack_addr.i64 ss4+108
+    store notrap heap v20, v54  ; v20 = 0
+    v55 = stack_addr.i64 ss5
+    store notrap vmctx v23, v55
+    v56 = stack_addr.i64 ss5+16
+    store notrap vmctx v23, v56
+    v57 = stack_addr.i64 ss5+32
+    store notrap vmctx v23, v57
+    v58 = stack_addr.i64 ss5+48
+    store notrap vmctx v23, v58
+    v59 = stack_addr.i64 ss5+64
+    store notrap vmctx v23, v59
+    v60 = stack_addr.i64 ss5+80
+    store notrap vmctx v23, v60
+    v61 = stack_addr.i64 ss5+96
+    store notrap vmctx v23, v61
+    v62 = stack_addr.i64 ss5+112
+    store notrap vmctx v22, v62  ; v22 = 0
+    v63 = stack_addr.i64 ss5+120
+    store notrap vmctx v21, v63  ; v21 = 0
+    v64 = stack_addr.i64 ss5+124
+    store notrap vmctx v20, v64  ; v20 = 0
+    v65 = icmp_imm uge v3, 0x5123  ; v3 = 0xffef
+    brif v65, block3, block2
+
+block3:
+    v66 = icmp_imm.i16 uge v3, 0xd5d7  ; v3 = 0xffef
+    brif v66, block5, block4
+
+block5:
+    v67 = icmp_imm.i16 uge v3, 0xf6ff  ; v3 = 0xffef
+    brif v67, block7, block6
+
+block7:
+    v68 = icmp_imm.i16 uge v3, 0xff22  ; v3 = 0xffef
+    brif v68, block9, block8
+
+block9:
+    v69 = icmp_imm.i16 eq v3, 0xffdd  ; v3 = 0xffef
+    brif v69, block1, block10
+
+block10:
+    v70 = icmp_imm.i16 uge v3, 0xff79  ; v3 = 0xffef
+    brif v70, block12, block11
+
+block12:
+    v71 = iadd_imm.i16 v3, 0xffff_ffff_ffff_0087  ; v3 = 0xffef
+    v72 = uextend.i32 v71
+    br_table v72, block1, [block1, block1, block1, block1, block1, block1]
+
+block11:
+    v73 = icmp_imm.i16 uge v3, 0xff22  ; v3 = 0xffef
+    brif v73, block13, block1
+
+block13:
+    v74 = iadd_imm.i16 v3, 0xffff_ffff_ffff_00de  ; v3 = 0xffef
+    v75 = uextend.i32 v74
+    br_table v75, block1, [block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1]
+
+block8:
+    v76 = icmp_imm.i16 eq v3, 0xf951  ; v3 = 0xffef
+    brif v76, block1, block14
+
+block14:
+    v77 = icmp_imm.i16 uge v3, 0xf6ff  ; v3 = 0xffef
+    brif v77, block15, block1
+
+block15:
+    v78 = iadd_imm.i16 v3, 0xffff_ffff_ffff_0901  ; v3 = 0xffef
+    v79 = uextend.i32 v78
+    br_table v79, block1, [block1, block1, block1, block1, block1, block1, block1]
+
+block6:
+    v80 = icmp_imm.i16 uge v3, 0xef2a  ; v3 = 0xffef
+    brif v80, block17, block16
+
+block17:
+    v81 = icmp_imm.i16 eq v3, 0xf426  ; v3 = 0xffef
+    brif v81, block1, block18
+
+block18:
+    v82 = icmp_imm.i16 uge v3, 0xefff  ; v3 = 0xffef
+    brif v82, block20, block19
+
+block20:
+    v83 = iadd_imm.i16 v3, 0xffff_ffff_ffff_1001  ; v3 = 0xffef
+    v84 = uextend.i32 v83
+    br_table v84, block1, [block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1]
+
+block19:
+    v85 = icmp_imm.i16 uge v3, 0xef2a  ; v3 = 0xffef
+    brif v85, block21, block1
+
+block21:
+    v86 = iadd_imm.i16 v3, 0xffff_ffff_ffff_10d6  ; v3 = 0xffef
+    v87 = uextend.i32 v86
+    br_table v87, block1, [block1, block1, block1, block1, block1, block1, block1, block1, block1]
+
+block16:
+    v88 = icmp_imm.i16 eq v3, 0xdc2a  ; v3 = 0xffef
+    brif v88, block1, block22
+
+block22:
+    v89 = icmp_imm.i16 uge v3, 0xd5d7  ; v3 = 0xffef
+    brif v89, block23, block1
+
+block23:
+    v90 = iadd_imm.i16 v3, 0xffff_ffff_ffff_2a29  ; v3 = 0xffef
+    v91 = uextend.i32 v90
+    br_table v91, block1, [block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1]
+
+block4:
+    v92 = icmp_imm.i16 uge v3, 0x7363  ; v3 = 0xffef
+    brif v92, block25, block24
+
+block25:
+    v93 = icmp_imm.i16 uge v3, 0x9f22  ; v3 = 0xffef
+    brif v93, block27, block26
+
+block27:
+    v94 = icmp_imm.i16 uge v3, 0xbf41  ; v3 = 0xffef
+    brif v94, block29, block28
+
+block29:
+    v95 = iadd_imm.i16 v3, 0xffff_ffff_ffff_40bf  ; v3 = 0xffef
+    v96 = uextend.i32 v95
+    br_table v96, block1, [block1, block1, block1, block1, block1, block1, block1, block1, block1]
+
+block28:
+    v97 = icmp_imm.i16 eq v3, 0xae73  ; v3 = 0xffef
+    brif v97, block1, block30
+
+block30:
+    v98 = icmp_imm.i16 eq v3, 0x9f22  ; v3 = 0xffef
+    brif v98, block1, block1
+
+block26:
+    v99 = icmp_imm.i16 uge v3, 0x9301  ; v3 = 0xffef
+    brif v99, block32, block31
+
+block32:
+    v100 = iadd_imm.i16 v3, 0xffff_ffff_ffff_6cff  ; v3 = 0xffef
+    v101 = uextend.i32 v100
+    br_table v101, block1, [block1, block1, block1, block1, block1, block1, block1]
+
+block31:
+    v102 = icmp_imm.i16 uge v3, 0x7363  ; v3 = 0xffef
+    brif v102, block33, block1
+
+block33:
+    v103 = iadd_imm.i16 v3, 0xffff_ffff_ffff_8c9d  ; v3 = 0xffef
+    v104 = uextend.i32 v103
+    br_table v104, block1, [block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1]
+
+block24:
+    v105 = icmp_imm.i16 uge v3, 0x56cc  ; v3 = 0xffef
+    brif v105, block35, block34
+
+block35:
+    v106 = icmp_imm.i16 eq v3, 0x6720  ; v3 = 0xffef
+    brif v106, block1, block36
+
+block36:
+    v107 = icmp_imm.i16 eq v3, 0x56cc  ; v3 = 0xffef
+    brif v107, block1, block1
+
+block34:
+    v108 = icmp_imm.i16 eq v3, 0x5230  ; v3 = 0xffef
+    brif v108, block1, block37
+
+block37:
+    v109 = icmp_imm.i16 uge v3, 0x5123  ; v3 = 0xffef
+    brif v109, block38, block1
+
+block38:
+    v110 = iadd_imm.i16 v3, 0xffff_ffff_ffff_aedd  ; v3 = 0xffef
+    v111 = uextend.i32 v110
+    br_table v111, block1, [block1, block1, block1, block1, block1, block1, block1]
+
+block2:
+    v112 = icmp_imm.i16 uge v3, 0x2a20  ; v3 = 0xffef
+    brif v112, block40, block39
+
+block40:
+    v113 = icmp_imm.i16 uge v3, 0x2f22  ; v3 = 0xffef
+    brif v113, block42, block41
+
+block42:
+    v114 = icmp_imm.i16 uge v3, 0x3320  ; v3 = 0xffef
+    brif v114, block44, block43
+
+block44:
+    v115 = icmp_imm.i16 uge v3, 0x504d  ; v3 = 0xffef
+    brif v115, block46, block45
+
+block46:
+    v116 = iadd_imm.i16 v3, 0xffff_ffff_ffff_afb3  ; v3 = 0xffef
+    v117 = uextend.i32 v116
+    br_table v117, block1, [block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1]
+
+block45:
+    v118 = icmp_imm.i16 eq v3, 0x4118  ; v3 = 0xffef
+    brif v118, block1, block47
+
+block47:
+    v119 = icmp_imm.i16 eq v3, 0x3320  ; v3 = 0xffef
+    brif v119, block1, block1
+
+block43:
+    v120 = icmp_imm.i16 uge v3, 0x2f2a  ; v3 = 0xffef
+    brif v120, block49, block48
+
+block49:
+    v121 = iadd_imm.i16 v3, 0xffff_ffff_ffff_d0d6  ; v3 = 0xffef
+    v122 = uextend.i32 v121
+    br_table v122, block1, [block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1]
+
+block48:
+    v123 = icmp_imm.i16 eq v3, 0x2f22  ; v3 = 0xffef
+    brif v123, block1, block1
+
+block41:
+    v124 = icmp_imm.i16 uge v3, 0x2a67  ; v3 = 0xffef
+    brif v124, block51, block50
+
+block51:
+    v125 = icmp_imm.i16 uge v3, 0x2ade  ; v3 = 0xffef
+    brif v125, block53, block52
+
+block53:
+    v126 = iadd_imm.i16 v3, 0xffff_ffff_ffff_d522  ; v3 = 0xffef
+    v127 = uextend.i32 v126
+    br_table v127, block1, [block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1]
+
+block52:
+    v128 = icmp_imm.i16 eq v3, 0x2ab2  ; v3 = 0xffef
+    brif v128, block1, block54
+
+block54:
+    v129 = icmp_imm.i16 uge v3, 0x2a67  ; v3 = 0xffef
+    brif v129, block55, block1
+
+block55:
+    v130 = iadd_imm.i16 v3, 0xffff_ffff_ffff_d599  ; v3 = 0xffef
+    v131 = uextend.i32 v130
+    br_table v131, block1, [block1, block1, block1, block1, block1, block1]
+
+block50:
+    v132 = icmp_imm.i16 eq v3, 0x2a38  ; v3 = 0xffef
+    brif v132, block1, block56
+
+block56:
+    v133 = icmp_imm.i16 eq v3, 0x2a20  ; v3 = 0xffef
+    brif v133, block1, block1
+
+block39:
+    v134 = icmp_imm.i16 uge v3, 512  ; v3 = 0xffef
+    brif v134, block58, block57
+
+block58:
+    v135 = icmp_imm.i16 uge v3, 8241  ; v3 = 0xffef
+    brif v135, block60, block59
+
+block60:
+    v136 = icmp_imm.i16 eq v3, 9983  ; v3 = 0xffef
+    brif v136, block1, block61
+
+block61:
+    v137 = icmp_imm.i16 uge v3, 8738  ; v3 = 0xffef
+    brif v137, block63, block62
+
+block63:
+    v138 = iadd_imm.i16 v3, -8738  ; v3 = 0xffef
+    v139 = uextend.i32 v138
+    br_table v139, block1, [block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1]
+
+block62:
+    v140 = icmp_imm.i16 uge v3, 8241  ; v3 = 0xffef
+    brif v140, block64, block1
+
+block64:
+    v141 = iadd_imm.i16 v3, -8241  ; v3 = 0xffef
+    v142 = uextend.i32 v141
+    br_table v142, block1, [block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1]
+
+block59:
+    v143 = icmp_imm.i16 eq v3, 6493  ; v3 = 0xffef
+    brif v143, block1, block65
+
+block65:
+    v144 = icmp_imm.i16 uge v3, 512  ; v3 = 0xffef
+    brif v144, block66, block1
+
+block66:
+    v145 = iadd_imm.i16 v3, -512  ; v3 = 0xffef
+    v146 = uextend.i32 v145
+    br_table v146, block1, [block1, block1, block1]
+
+block57:
+    v147 = icmp_imm.i16 uge v3, 212  ; v3 = 0xffef
+    brif v147, block68, block67
+
+block68:
+    v148 = icmp_imm.i16 uge v3, 341  ; v3 = 0xffef
+    brif v148, block70, block69
+
+block70:
+    v149 = iadd_imm.i16 v3, -341  ; v3 = 0xffef
+    v150 = uextend.i32 v149
+    br_table v150, block1, [block1, block1]
+
+block69:
+    v151 = icmp_imm.i16 uge v3, 212  ; v3 = 0xffef
+    brif v151, block71, block1
+
+block71:
+    v152 = iadd_imm.i16 v3, -212  ; v3 = 0xffef
+    v153 = uextend.i32 v152
+    br_table v153, block1, [block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1]
+
+block67:
+    v154 = icmp_imm.i16 uge v3, 128  ; v3 = 0xffef
+    brif v154, block73, block72
+
+block73:
+    v155 = iadd_imm.i16 v3, -128  ; v3 = 0xffef
+    v156 = uextend.i32 v155
+    br_table v156, block1, [block1, block1]
+
+block72:
+    v157 = uextend.i32 v3  ; v3 = 0xffef
+    br_table v157, block1, [block1, block1]
+
+block1 cold:
+    v163 = func_addr.i64 fn6
+    return_call_indirect sig6, v163(v158, v158, v158, v158, v158, v158, v158, v159, v160, v160, v158, v158, v161, v159, v162)  ; v158 = 0xef31_de2a_2352_79ff, v158 = 0xef31_de2a_2352_79ff, v158 = 0xef31_de2a_2352_79ff, v158 = 0xef31_de2a_2352_79ff, v158 = 0xef31_de2a_2352_79ff, v158 = 0xef31_de2a_2352_79ff, v158 = 0xef31_de2a_2352_79ff, v159 = 203, v160 = 0xffef, v160 = 0xffef, v158 = 0xef31_de2a_2352_79ff, v158 = 0xef31_de2a_2352_79ff, v159 = 203, v162 = -0x1.979796p24
+}
diff --git a/cranelift/filetests/filetests/isa/riscv64/issue8866.clif b/cranelift/filetests/filetests/isa/riscv64/issue8866.clif
new file mode 100644
index 000000000000..b55f140a902f
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/issue8866.clif
@@ -0,0 +1,489 @@
+;; Compile test case
+
+test compile
+set bb_padding_log2_minus_one=4
+set enable_alias_analysis=false
+set enable_llvm_abi_extensions=true
+set machine_code_cfg_info=true
+set enable_jump_tables=false
+set enable_heap_access_spectre_mitigation=false
+target riscv64 has_zcd has_zbkb has_zbc has_zbs has_zicond has_zvl32b has_zvl64b has_zvl128b has_zvl1024b has_zvl2048b has_zvl4096b has_zvl8192b has_zvl16384b has_zvl32768b
+
+function u1:0() tail {
+    ss0 = explicit_slot 50, align = 512
+    ss1 = explicit_slot 47, align = 4
+    ss2 = explicit_slot 34, align = 32
+    ss3 = explicit_slot 103, align = 1024
+    ss4 = explicit_slot 110, align = 512
+    ss5 = explicit_slot 126, align = 512
+    sig0 = (f32, f64, f64, f32, i8 uext, i128, i8 uext, i32, i16 sext, i64, i64 sext, i128, i8 sext, i8, i64, i64 sext) -> i16 sext, i64 sext, f64, i32 sext, f64, i8 sext, i64 sext, f32 cold
+    sig1 = () system_v
+    sig2 = (i128, i16 sext, i128 sext, i32 sext, i16, i64 uext, f32, i8 sext, f32, i8, i64, i64, i64, i64 uext, f64) -> f64, i8 uext, f32, i128, i64 uext, i8, i16 sext, i64 sext tail
+    sig3 = () -> i8 sext, f32, i128, i32, f32, i128 uext, i8, i8 uext, f64, i8 sext, f32 system_v
+    sig4 = (i8, i16, i64 sext, i64 sext, i128 uext, i8, i32, f64, i32, f32, i128 uext, i8, i8 uext, f64, f64) -> i8 uext system_v
+    sig5 = (i8 sext, i64 uext, i16 sext, i64 sext, i128 uext, i128 sext, f32, i16 uext, i64 sext, i32 sext, i64, i64 uext, f64, f64, i16 sext) -> f32 tail
+    sig6 = (i64 sext, i64 sext, i64 sext, i64 sext, i64 sext, i64 sext, i64 sext, i8 uext, i16 uext, i16, i64 sext, i64 sext, i128 uext, i8 sext, f32) tail
+    sig7 = (f32) -> f32 system_v
+    sig8 = (f64) -> f64 system_v
+    sig9 = (f32) -> f32 system_v
+    sig10 = (f64) -> f64 system_v
+    sig11 = (f32) -> f32 system_v
+    sig12 = (f64) -> f64 system_v
+    sig13 = (f32) -> f32 system_v
+    sig14 = (f64) -> f64 system_v
+    sig15 = (f32, f32, f32) -> f32 system_v
+    sig16 = (f64, f64, f64) -> f64 system_v
+    fn0 = colocated u2:0 sig0
+    fn1 = colocated u2:1 sig1
+    fn2 = colocated u2:2 sig2
+    fn3 = colocated u2:3 sig3
+    fn4 = colocated u2:4 sig4
+    fn5 = colocated u2:5 sig5
+    fn6 = colocated u2:6 sig6
+    fn7 = %CeilF32 sig7
+    fn8 = %CeilF64 sig8
+    fn9 = %FloorF32 sig9
+    fn10 = %FloorF64 sig10
+    fn11 = colocated %TruncF32 sig11
+    fn12 = %TruncF64 sig12
+    fn13 = colocated %NearestF32 sig13
+    fn14 = %NearestF64 sig14
+    fn15 = %FmaF32 sig15
+    fn16 = %FmaF64 sig16
+
+block0:
+    v0 = iconst.i64 0xef31_de2a_2352_79ff
+    v161 -> v0
+    v1 = iconst.i64 0x2231_ffd1_ff29_ff26
+    v2 = f64const 0x1.8ff2320672823p-225
+    v3 = iconst.i16 0xffef
+    v163 -> v3
+    v4 = iconst.i64 0xddde_2a23_52f9_ffff
+    v5 = iconst.i64 0xc8c8_c8c8_c8c8_c8c8
+    v6 = iconst.i64 0xc8c8_c8c8_c8c8_c8c8
+    v7 = iconcat v6, v5  ; v6 = 0xc8c8_c8c8_c8c8_c8c8, v5 = 0xc8c8_c8c8_c8c8_c8c8
+    v164 -> v7
+    v8 = iconst.i64 0xc8c8_c8c8_c8c8_c8c8
+    v9 = iconst.i64 0xc8c8_c8c8_c8c8_c8c8
+    v10 = iconcat v9, v8  ; v9 = 0xc8c8_c8c8_c8c8_c8c8, v8 = 0xc8c8_c8c8_c8c8_c8c8
+    v11 = iconst.i64 0xcbcb_cbcb_cbc8_c8c8
+    v12 = iconst.i64 0xc8c8_c8c8_c8c8_c8c8
+    v13 = iconcat v12, v11  ; v12 = 0xc8c8_c8c8_c8c8_c8c8, v11 = 0xcbcb_cbcb_cbc8_c8c8
+    v14 = iconst.i8 203
+    v162 -> v14
+    v15 = f32const -0x1.979796p24
+    v165 -> v15
+    v16 = iconst.i64 0x0031_2222_2a2f
+    v17 = iconst.i64 0xcbcb_2adc_9e98_d7d4
+    v18 = iconcat v17, v16  ; v17 = 0xcbcb_2adc_9e98_d7d4, v16 = 0x0031_2222_2a2f
+    v19 = iconst.i8 0
+    v20 = iconst.i16 0
+    v21 = iconst.i32 0
+    v22 = iconst.i64 0
+    v23 = uextend.i128 v22  ; v22 = 0
+    v24 = stack_addr.i64 ss2
+    store notrap table v23, v24
+    v25 = stack_addr.i64 ss2+16
+    store notrap table v23, v25
+    v26 = stack_addr.i64 ss2+32
+    store notrap table v20, v26  ; v20 = 0
+    v27 = stack_addr.i64 ss1
+    store notrap table v23, v27
+    v28 = stack_addr.i64 ss1+16
+    store notrap table v23, v28
+    v29 = stack_addr.i64 ss1+32
+    store notrap table v22, v29  ; v22 = 0
+    v30 = stack_addr.i64 ss1+40
+    store notrap table v21, v30  ; v21 = 0
+    v31 = stack_addr.i64 ss1+44
+    store notrap table v20, v31  ; v20 = 0
+    v32 = stack_addr.i64 ss1+46
+    store notrap table v19, v32  ; v19 = 0
+    v33 = stack_addr.i64 ss0
+    store notrap table v23, v33
+    v34 = stack_addr.i64 ss0+16
+    store notrap table v23, v34
+    v35 = stack_addr.i64 ss0+32
+    store notrap table v23, v35
+    v36 = stack_addr.i64 ss0+48
+    store notrap table v20, v36  ; v20 = 0
+    v37 = stack_addr.i64 ss3
+    store notrap vmctx v23, v37
+    v38 = stack_addr.i64 ss3+16
+    store notrap vmctx v23, v38
+    v39 = stack_addr.i64 ss3+32
+    store notrap vmctx v23, v39
+    v40 = stack_addr.i64 ss3+48
+    store notrap vmctx v23, v40
+    v41 = stack_addr.i64 ss3+64
+    store notrap vmctx v23, v41
+    v42 = stack_addr.i64 ss3+80
+    store notrap vmctx v23, v42
+    v43 = stack_addr.i64 ss3+96
+    store notrap vmctx v21, v43  ; v21 = 0
+    v44 = stack_addr.i64 ss3+100
+    store notrap vmctx v20, v44  ; v20 = 0
+    v45 = stack_addr.i64 ss3+102
+    store notrap vmctx v19, v45  ; v19 = 0
+    v46 = stack_addr.i64 ss4
+    store notrap heap v23, v46
+    v47 = stack_addr.i64 ss4+16
+    store notrap heap v23, v47
+    v48 = stack_addr.i64 ss4+32
+    store notrap heap v23, v48
+    v49 = stack_addr.i64 ss4+48
+    store notrap heap v23, v49
+    v50 = stack_addr.i64 ss4+64
+    store notrap heap v23, v50
+    v51 = stack_addr.i64 ss4+80
+    store notrap heap v23, v51
+    v52 = stack_addr.i64 ss4+96
+    store notrap heap v22, v52  ; v22 = 0
+    v53 = stack_addr.i64 ss4+104
+    store notrap heap v21, v53  ; v21 = 0
+    v54 = stack_addr.i64 ss4+108
+    store notrap heap v20, v54  ; v20 = 0
+    v55 = stack_addr.i64 ss5
+    store notrap vmctx v23, v55
+    v56 = stack_addr.i64 ss5+16
+    store notrap vmctx v23, v56
+    v57 = stack_addr.i64 ss5+32
+    store notrap vmctx v23, v57
+    v58 = stack_addr.i64 ss5+48
+    store notrap vmctx v23, v58
+    v59 = stack_addr.i64 ss5+64
+    store notrap vmctx v23, v59
+    v60 = stack_addr.i64 ss5+80
+    store notrap vmctx v23, v60
+    v61 = stack_addr.i64 ss5+96
+    store notrap vmctx v23, v61
+    v62 = stack_addr.i64 ss5+112
+    store notrap vmctx v22, v62  ; v22 = 0
+    v63 = stack_addr.i64 ss5+120
+    store notrap vmctx v21, v63  ; v21 = 0
+    v64 = stack_addr.i64 ss5+124
+    store notrap vmctx v20, v64  ; v20 = 0
+    v65 = icmp_imm uge v3, 0x504d  ; v3 = 0xffef
+    brif v65, block3, block2
+
+block3:
+    v66 = icmp_imm.i16 uge v3, 0xd5d7  ; v3 = 0xffef
+    brif v66, block5, block4
+
+block5:
+    v67 = icmp_imm.i16 uge v3, 0xf6ff  ; v3 = 0xffef
+    brif v67, block7, block6
+
+block7:
+    v68 = icmp_imm.i16 uge v3, 0xff22  ; v3 = 0xffef
+    brif v68, block9, block8
+
+block9:
+    v69 = icmp_imm.i16 eq v3, 0xffdd  ; v3 = 0xffef
+    brif v69, block1, block10
+
+block10:
+    v70 = icmp_imm.i16 uge v3, 0xff79  ; v3 = 0xffef
+    brif v70, block12, block11
+
+block12:
+    v71 = iadd_imm.i16 v3, 0xffff_ffff_ffff_0087  ; v3 = 0xffef
+    v72 = uextend.i32 v71
+    br_table v72, block1, [block1, block1, block1, block1, block1, block1]
+
+block11:
+    v73 = icmp_imm.i16 uge v3, 0xff22  ; v3 = 0xffef
+    brif v73, block13, block1
+
+block13:
+    v74 = iadd_imm.i16 v3, 0xffff_ffff_ffff_00de  ; v3 = 0xffef
+    v75 = uextend.i32 v74
+    br_table v75, block1, [block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1]
+
+block8:
+    v76 = icmp_imm.i16 eq v3, 0xf951  ; v3 = 0xffef
+    brif v76, block1, block14
+
+block14:
+    v77 = icmp_imm.i16 uge v3, 0xf6ff  ; v3 = 0xffef
+    brif v77, block15, block1
+
+block15:
+    v78 = iadd_imm.i16 v3, 0xffff_ffff_ffff_0901  ; v3 = 0xffef
+    v79 = uextend.i32 v78
+    br_table v79, block1, [block1, block1, block1, block1, block1, block1, block1]
+
+block6:
+    v80 = icmp_imm.i16 uge v3, 0xef2a  ; v3 = 0xffef
+    brif v80, block17, block16
+
+block17:
+    v81 = icmp_imm.i16 eq v3, 0xf426  ; v3 = 0xffef
+    brif v81, block1, block18
+
+block18:
+    v82 = icmp_imm.i16 uge v3, 0xefff  ; v3 = 0xffef
+    brif v82, block20, block19
+
+block20:
+    v83 = iadd_imm.i16 v3, 0xffff_ffff_ffff_1001  ; v3 = 0xffef
+    v84 = uextend.i32 v83
+    br_table v84, block1, [block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1]
+
+block19:
+    v85 = icmp_imm.i16 uge v3, 0xef2a  ; v3 = 0xffef
+    brif v85, block21, block1
+
+block21:
+    v86 = iadd_imm.i16 v3, 0xffff_ffff_ffff_10d6  ; v3 = 0xffef
+    v87 = uextend.i32 v86
+    br_table v87, block1, [block1, block1, block1, block1, block1, block1, block1, block1, block1]
+
+block16:
+    v88 = icmp_imm.i16 eq v3, 0xdc2a  ; v3 = 0xffef
+    brif v88, block1, block22
+
+block22:
+    v89 = icmp_imm.i16 uge v3, 0xd5d7  ; v3 = 0xffef
+    brif v89, block23, block1
+
+block23:
+    v90 = iadd_imm.i16 v3, 0xffff_ffff_ffff_2a29  ; v3 = 0xffef
+    v91 = uextend.i32 v90
+    br_table v91, block1, [block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1]
+
+block4:
+    v92 = icmp_imm.i16 uge v3, 0x7363  ; v3 = 0xffef
+    brif v92, block25, block24
+
+block25:
+    v93 = icmp_imm.i16 uge v3, 0x9f22  ; v3 = 0xffef
+    brif v93, block27, block26
+
+block27:
+    v94 = icmp_imm.i16 uge v3, 0xbf41  ; v3 = 0xffef
+    brif v94, block29, block28
+
+block29:
+    v95 = iadd_imm.i16 v3, 0xffff_ffff_ffff_40bf  ; v3 = 0xffef
+    v96 = uextend.i32 v95
+    br_table v96, block1, [block1, block1, block1, block1, block1, block1, block1, block1, block1]
+
+block28:
+    v97 = icmp_imm.i16 eq v3, 0xae73  ; v3 = 0xffef
+    brif v97, block1, block30
+
+block30:
+    v98 = icmp_imm.i16 eq v3, 0x9f22  ; v3 = 0xffef
+    brif v98, block1, block1
+
+block26:
+    v99 = icmp_imm.i16 uge v3, 0x9301  ; v3 = 0xffef
+    brif v99, block32, block31
+
+block32:
+    v100 = iadd_imm.i16 v3, 0xffff_ffff_ffff_6cff  ; v3 = 0xffef
+    v101 = uextend.i32 v100
+    br_table v101, block1, [block1, block1, block1, block1, block1, block1, block1]
+
+block31:
+    v102 = icmp_imm.i16 uge v3, 0x7363  ; v3 = 0xffef
+    brif v102, block33, block1
+
+block33:
+    v103 = iadd_imm.i16 v3, 0xffff_ffff_ffff_8c9d  ; v3 = 0xffef
+    v104 = uextend.i32 v103
+    br_table v104, block1, [block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1]
+
+block24:
+    v105 = icmp_imm.i16 uge v3, 0x5230  ; v3 = 0xffef
+    brif v105, block35, block34
+
+block35:
+    v106 = icmp_imm.i16 eq v3, 0x6720  ; v3 = 0xffef
+    brif v106, block1, block36
+
+block36:
+    v107 = icmp_imm.i16 eq v3, 0x56cc  ; v3 = 0xffef
+    brif v107, block1, block37
+
+block37:
+    v108 = icmp_imm.i16 eq v3, 0x5230  ; v3 = 0xffef
+    brif v108, block1, block1
+
+block34:
+    v109 = icmp_imm.i16 uge v3, 0x5123  ; v3 = 0xffef
+    brif v109, block39, block38
+
+block39:
+    v110 = iadd_imm.i16 v3, 0xffff_ffff_ffff_aedd  ; v3 = 0xffef
+    v111 = uextend.i32 v110
+    br_table v111, block1, [block1, block1, block1, block1, block1, block1, block1]
+
+block38:
+    v112 = icmp_imm.i16 uge v3, 0x504d  ; v3 = 0xffef
+    brif v112, block40, block1
+
+block40:
+    v113 = iadd_imm.i16 v3, 0xffff_ffff_ffff_afb3  ; v3 = 0xffef
+    v114 = uextend.i32 v113
+    br_table v114, block1, [block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1]
+
+block2:
+    v115 = icmp_imm.i16 uge v3, 9983  ; v3 = 0xffef
+    brif v115, block42, block41
+
+block42:
+    v116 = icmp_imm.i16 uge v3, 0x2ade  ; v3 = 0xffef
+    brif v116, block44, block43
+
+block44:
+    v117 = icmp_imm.i16 uge v3, 0x2f2a  ; v3 = 0xffef
+    brif v117, block46, block45
+
+block46:
+    v118 = icmp_imm.i16 eq v3, 0x4118  ; v3 = 0xffef
+    brif v118, block1, block47
+
+block47:
+    v119 = icmp_imm.i16 eq v3, 0x3320  ; v3 = 0xffef
+    brif v119, block1, block48
+
+block48:
+    v120 = icmp_imm.i16 uge v3, 0x2f2a  ; v3 = 0xffef
+    brif v120, block49, block1
+
+block49:
+    v121 = iadd_imm.i16 v3, 0xffff_ffff_ffff_d0d6  ; v3 = 0xffef
+    v122 = uextend.i32 v121
+    br_table v122, block1, [block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1]
+
+block45:
+    v123 = icmp_imm.i16 eq v3, 0x2f22  ; v3 = 0xffef
+    brif v123, block1, block50
+
+block50:
+    v124 = icmp_imm.i16 uge v3, 0x2ade  ; v3 = 0xffef
+    brif v124, block51, block1
+
+block51:
+    v125 = iadd_imm.i16 v3, 0xffff_ffff_ffff_d522  ; v3 = 0xffef
+    v126 = uextend.i32 v125
+    br_table v126, block1, [block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1]
+
+block43:
+    v127 = icmp_imm.i16 uge v3, 0x2a38  ; v3 = 0xffef
+    brif v127, block53, block52
+
+block53:
+    v128 = icmp_imm.i16 eq v3, 0x2ab2  ; v3 = 0xffef
+    brif v128, block1, block54
+
+block54:
+    v129 = icmp_imm.i16 uge v3, 0x2a67  ; v3 = 0xffef
+    brif v129, block56, block55
+
+block56:
+    v130 = iadd_imm.i16 v3, 0xffff_ffff_ffff_d599  ; v3 = 0xffef
+    v131 = uextend.i32 v130
+    br_table v131, block1, [block1, block1, block1, block1, block1, block1]
+
+block55:
+    v132 = icmp_imm.i16 eq v3, 0x2a38  ; v3 = 0xffef
+    brif v132, block1, block1
+
+block52:
+    v133 = icmp_imm.i16 eq v3, 0x2a20  ; v3 = 0xffef
+    brif v133, block1, block57
+
+block57:
+    v134 = icmp_imm.i16 eq v3, 9983  ; v3 = 0xffef
+    brif v134, block1, block1
+
+block41:
+    v135 = icmp_imm.i16 uge v3, 341  ; v3 = 0xffef
+    brif v135, block59, block58
+
+block59:
+    v136 = icmp_imm.i16 uge v3, 6493  ; v3 = 0xffef
+    brif v136, block61, block60
+
+block61:
+    v137 = icmp_imm.i16 uge v3, 8738  ; v3 = 0xffef
+    brif v137, block63, block62
+
+block63:
+    v138 = iadd_imm.i16 v3, -8738  ; v3 = 0xffef
+    v139 = uextend.i32 v138
+    br_table v139, block1, [block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1]
+
+block62:
+    v140 = icmp_imm.i16 uge v3, 8241  ; v3 = 0xffef
+    brif v140, block65, block64
+
+block65:
+    v141 = iadd_imm.i16 v3, -8241  ; v3 = 0xffef
+    v142 = uextend.i32 v141
+    br_table v142, block1, [block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1]
+
+block64:
+    v143 = icmp_imm.i16 eq v3, 6493  ; v3 = 0xffef
+    brif v143, block1, block1
+
+block60:
+    v144 = icmp_imm.i16 uge v3, 512  ; v3 = 0xffef
+    brif v144, block67, block66
+
+block67:
+    v145 = iadd_imm.i16 v3, -512  ; v3 = 0xffef
+    v146 = uextend.i32 v145
+    br_table v146, block1, [block1, block1, block1]
+
+block66:
+    v147 = icmp_imm.i16 uge v3, 341  ; v3 = 0xffef
+    brif v147, block68, block1
+
+block68:
+    v148 = iadd_imm.i16 v3, -341  ; v3 = 0xffef
+    v149 = uextend.i32 v148
+    br_table v149, block1, [block1, block1]
+
+block58:
+    v150 = icmp_imm.i16 uge v3, 148  ; v3 = 0xffef
+    brif v150, block70, block69
+
+block70:
+    v151 = icmp_imm.i16 uge v3, 212  ; v3 = 0xffef
+    brif v151, block72, block71
+
+block72:
+    v152 = iadd_imm.i16 v3, -212  ; v3 = 0xffef
+    v153 = uextend.i32 v152
+    br_table v153, block1, [block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1]
+
+block71:
+    v154 = icmp_imm.i16 uge v3, 148  ; v3 = 0xffef
+    brif v154, block73, block1
+
+block73:
+    v155 = iadd_imm.i16 v3, -148  ; v3 = 0xffef
+    v156 = uextend.i32 v155
+    br_table v156, block1, [block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1, block1]
+
+block69:
+    v157 = icmp_imm.i16 uge v3, 128  ; v3 = 0xffef
+    brif v157, block75, block74
+
+block75:
+    v158 = iadd_imm.i16 v3, -128  ; v3 = 0xffef
+    v159 = uextend.i32 v158
+    br_table v159, block1, [block1, block1]
+
+block74:
+    v160 = uextend.i32 v3  ; v3 = 0xffef
+    br_table v160, block1, [block1, block1]
+
+block1 cold:
+    v166 = func_addr.i64 fn6
+    return_call_indirect sig6, v166(v161, v161, v161, v161, v161, v161, v161, v162, v163, v163, v161, v161, v164, v162, v165)  ; v161 = 0xef31_de2a_2352_79ff, v161 = 0xef31_de2a_2352_79ff, v161 = 0xef31_de2a_2352_79ff, v161 = 0xef31_de2a_2352_79ff, v161 = 0xef31_de2a_2352_79ff, v161 = 0xef31_de2a_2352_79ff, v161 = 0xef31_de2a_2352_79ff, v162 = 203, v163 = 0xffef, v163 = 0xffef, v161 = 0xef31_de2a_2352_79ff, v161 = 0xef31_de2a_2352_79ff, v162 = 203, v165 = -0x1.979796p24
+}
diff --git a/cranelift/filetests/filetests/isa/riscv64/load-extends.clif b/cranelift/filetests/filetests/isa/riscv64/load-extends.clif
new file mode 100644
index 000000000000..ffba7781174b
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/load-extends.clif
@@ -0,0 +1,210 @@
+test compile precise-output
+set unwind_info=false
+target riscv64
+
+function %load_uextend_i8_i16(i64) -> i16 {
+block0(v0: i64):
+  v1 = load.i8 v0
+  v2 = uextend.i16 v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   lbu a0,0(a0)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   lbu a0, 0(a0) ; trap: heap_oob
+;   ret
+
+function %load_uextend_i8_i32(i64) -> i32 {
+block0(v0: i64):
+  v1 = load.i8 v0
+  v2 = uextend.i32 v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   lbu a0,0(a0)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   lbu a0, 0(a0) ; trap: heap_oob
+;   ret
+
+function %load_uextend_i8_i64(i64) -> i64 {
+block0(v0: i64):
+  v1 = load.i8 v0
+  v2 = uextend.i64 v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   lbu a0,0(a0)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   lbu a0, 0(a0) ; trap: heap_oob
+;   ret
+
+function %load_uextend_i16_i32(i64) -> i32 {
+block0(v0: i64):
+  v1 = load.i16 v0
+  v2 = uextend.i32 v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   lhu a0,0(a0)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   lhu a0, 0(a0) ; trap: heap_oob
+;   ret
+
+function %load_uextend_i16_i64(i64) -> i64 {
+block0(v0: i64):
+  v1 = load.i16 v0
+  v2 = uextend.i64 v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   lhu a0,0(a0)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   lhu a0, 0(a0) ; trap: heap_oob
+;   ret
+
+function %load_uextend_i32_i64(i64) -> i64 {
+block0(v0: i64):
+  v1 = load.i32 v0
+  v2 = uextend.i64 v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   lwu a0,0(a0)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   lwu a0, 0(a0) ; trap: heap_oob
+;   ret
+
+
+
+function %load_sextend_i8_i16(i64) -> i16 {
+block0(v0: i64):
+  v1 = load.i8 v0
+  v2 = sextend.i16 v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   lb a0,0(a0)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   lb a0, 0(a0) ; trap: heap_oob
+;   ret
+
+function %load_sextend_i8_i32(i64) -> i32 {
+block0(v0: i64):
+  v1 = load.i8 v0
+  v2 = sextend.i32 v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   lb a0,0(a0)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   lb a0, 0(a0) ; trap: heap_oob
+;   ret
+
+function %load_sextend_i8_i64(i64) -> i64 {
+block0(v0: i64):
+  v1 = load.i8 v0
+  v2 = sextend.i64 v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   lb a0,0(a0)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   lb a0, 0(a0) ; trap: heap_oob
+;   ret
+
+function %load_sextend_i16_i32(i64) -> i32 {
+block0(v0: i64):
+  v1 = load.i16 v0
+  v2 = sextend.i32 v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   lh a0,0(a0)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   lh a0, 0(a0) ; trap: heap_oob
+;   ret
+
+function %load_sextend_i16_i64(i64) -> i64 {
+block0(v0: i64):
+  v1 = load.i16 v0
+  v2 = sextend.i64 v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   lh a0,0(a0)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   lh a0, 0(a0) ; trap: heap_oob
+;   ret
+
+function %load_sextend_i32_i64(i64) -> i64 {
+block0(v0: i64):
+  v1 = load.i32 v0
+  v2 = sextend.i64 v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   lw a0,0(a0)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   lw a0, 0(a0) ; trap: heap_oob
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/nan-canonicalization-has_v.clif b/cranelift/filetests/filetests/isa/riscv64/nan-canonicalization-has_v.clif
new file mode 100644
index 000000000000..2452813e858b
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/nan-canonicalization-has_v.clif
@@ -0,0 +1,160 @@
+test compile precise-output
+set enable_nan_canonicalization=true
+target riscv64 has_v
+
+function %f0(f32x4, f32x4) -> f32x4 {
+block0(v0: f32x4, v1: f32x4):
+	v2 = fadd v0, v1
+	return v2
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+; block0:
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vfadd.vv v13,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
+;   lui a1,523264
+;   fmv.w.x fa2,a1
+;   vfmv.v.f v14,fa2 #avl=4, #vtype=(e32, m1, ta, ma)
+;   vmfne.vv v10,v13,v13 #avl=4, #vtype=(e32, m1, ta, ma)
+;   vmfne.vv v12,v13,v13 #avl=4, #vtype=(e32, m1, ta, ma)
+;   vmor.mm v0,v10,v12 #avl=4, #vtype=(e32, m1, ta, ma)
+;   vmerge.vvm v8,v13,v14,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
+;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+; block1: ; offset 0x10
+;   .byte 0x57, 0x70, 0x08, 0xcc
+;   addi t6, sp, 0x10
+;   .byte 0x87, 0x84, 0x0f, 0x02
+;   addi t6, sp, 0x20
+;   .byte 0x87, 0x85, 0x0f, 0x02
+;   .byte 0x57, 0x70, 0x02, 0xcd
+;   .byte 0xd7, 0x96, 0x95, 0x02
+;   lui a1, 0x7fc00
+;   fmv.w.x fa2, a1
+;   .byte 0x57, 0x57, 0x06, 0x5e
+;   .byte 0x57, 0x95, 0xd6, 0x72
+;   .byte 0x57, 0x96, 0xd6, 0x72
+;   .byte 0x57, 0x20, 0xa6, 0x6a
+;   .byte 0x57, 0x04, 0xd7, 0x5c
+;   .byte 0x57, 0x70, 0x08, 0xcc
+;   .byte 0x27, 0x04, 0x05, 0x02
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   ret
+
+function %f1(f64, f64) -> f64 {
+block0(v0: f64, v1: f64):
+	v2 = fadd v0, v1
+	return v2
+}
+
+; VCode:
+; block0:
+;   fadd.d fa1,fa0,fa1,rne
+;   lui a5,4095
+;   slli a1,a5,39
+;   fmv.d.x fa3,a1
+;   vmv.v.x v8,zero #avl=2, #vtype=(e64, m1, ta, ma)
+;   vfmv.s.f v10,fa3 #avl=2, #vtype=(e64, m1, ta, ma)
+;   vmv.v.i v0,1 #avl=2, #vtype=(e64, m1, ta, ma)
+;   vmerge.vvm v14,v8,v10,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
+;   vmv.v.x v8,zero #avl=2, #vtype=(e64, m1, ta, ma)
+;   vfmv.s.f v10,fa1 #avl=2, #vtype=(e64, m1, ta, ma)
+;   vmv.v.i v0,1 #avl=2, #vtype=(e64, m1, ta, ma)
+;   vmerge.vvm v15,v8,v10,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
+;   vmfne.vv v8,v15,v15 #avl=2, #vtype=(e64, m1, ta, ma)
+;   vmfne.vv v10,v15,v15 #avl=2, #vtype=(e64, m1, ta, ma)
+;   vmor.mm v0,v8,v10 #avl=2, #vtype=(e64, m1, ta, ma)
+;   vmerge.vvm v8,v15,v14,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
+;   vfmv.f.s fa0,v8 #avl=2, #vtype=(e64, m1, ta, ma)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   fadd.d fa1, fa0, fa1, rne
+;   lui a5, 0xfff
+;   slli a1, a5, 0x27
+;   fmv.d.x fa3, a1
+;   .byte 0x57, 0x70, 0x81, 0xcd
+;   .byte 0x57, 0x44, 0x00, 0x5e
+;   .byte 0x57, 0xd5, 0x06, 0x42
+;   .byte 0x57, 0xb0, 0x00, 0x5e
+;   .byte 0x57, 0x07, 0x85, 0x5c
+;   .byte 0x57, 0x44, 0x00, 0x5e
+;   .byte 0x57, 0xd5, 0x05, 0x42
+;   .byte 0x57, 0xb0, 0x00, 0x5e
+;   .byte 0xd7, 0x07, 0x85, 0x5c
+;   .byte 0x57, 0x94, 0xf7, 0x72
+;   .byte 0x57, 0x95, 0xf7, 0x72
+;   .byte 0x57, 0x20, 0x85, 0x6a
+;   .byte 0x57, 0x04, 0xf7, 0x5c
+;   .byte 0x57, 0x15, 0x80, 0x42
+;   ret
+
+function %f1(f32, f32) -> f32 {
+block0(v0: f32, v1: f32):
+	v2 = fadd v0, v1
+	return v2
+}
+
+; VCode:
+; block0:
+;   fadd.s fa0,fa0,fa1,rne
+;   lui a5,523264
+;   fmv.w.x fa1,a5
+;   vmv.v.x v15,zero #avl=4, #vtype=(e32, m1, ta, ma)
+;   vfmv.s.f v9,fa1 #avl=4, #vtype=(e32, m1, ta, ma)
+;   vmv.v.i v0,1 #avl=2, #vtype=(e64, m1, ta, ma)
+;   vmerge.vvm v13,v15,v9,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
+;   vmv.v.x v15,zero #avl=4, #vtype=(e32, m1, ta, ma)
+;   vfmv.s.f v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
+;   vmv.v.i v0,1 #avl=2, #vtype=(e64, m1, ta, ma)
+;   vmerge.vvm v14,v15,v9,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
+;   vmfne.vv v15,v14,v14 #avl=4, #vtype=(e32, m1, ta, ma)
+;   vmfne.vv v9,v14,v14 #avl=4, #vtype=(e32, m1, ta, ma)
+;   vmor.mm v0,v15,v9 #avl=4, #vtype=(e32, m1, ta, ma)
+;   vmerge.vvm v15,v14,v13,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
+;   vfmv.f.s fa0,v15 #avl=4, #vtype=(e32, m1, ta, ma)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   fadd.s fa0, fa0, fa1, rne
+;   lui a5, 0x7fc00
+;   fmv.w.x fa1, a5
+;   .byte 0x57, 0x70, 0x02, 0xcd
+;   .byte 0xd7, 0x47, 0x00, 0x5e
+;   .byte 0xd7, 0xd4, 0x05, 0x42
+;   .byte 0x57, 0x70, 0x81, 0xcd
+;   .byte 0x57, 0xb0, 0x00, 0x5e
+;   .byte 0x57, 0x70, 0x02, 0xcd
+;   .byte 0xd7, 0x86, 0xf4, 0x5c
+;   .byte 0xd7, 0x47, 0x00, 0x5e
+;   .byte 0xd7, 0x54, 0x05, 0x42
+;   .byte 0x57, 0x70, 0x81, 0xcd
+;   .byte 0x57, 0xb0, 0x00, 0x5e
+;   .byte 0x57, 0x70, 0x02, 0xcd
+;   .byte 0x57, 0x87, 0xf4, 0x5c
+;   .byte 0xd7, 0x17, 0xe7, 0x72
+;   .byte 0xd7, 0x14, 0xe7, 0x72
+;   .byte 0x57, 0xa0, 0xf4, 0x6a
+;   .byte 0xd7, 0x87, 0xe6, 0x5c
+;   .byte 0x57, 0x15, 0xf0, 0x42
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/nan-canonicalization.clif b/cranelift/filetests/filetests/isa/riscv64/nan-canonicalization.clif
new file mode 100644
index 000000000000..41f2f7792562
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/nan-canonicalization.clif
@@ -0,0 +1,65 @@
+test compile precise-output
+set enable_nan_canonicalization=true 
+target riscv64
+
+function %f1(f64, f64) -> f64 {
+block0(v0: f64, v1: f64):
+	v2 = fadd v0, v1
+	return v2
+}
+
+; VCode:
+; block0:
+;   fadd.d fa4,fa0,fa1,rne
+;   lui a2,4095
+;   slli a4,a2,39
+;   fmv.d.x fa0,a4
+;   feq.d a1,fa4,fa4
+;   feq.d a3,fa4,fa4
+;   and a5,a1,a3
+;   select fa0,fa0,fa4##condition=(a5 eq zero)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   fadd.d fa4, fa0, fa1, rne
+;   lui a2, 0xfff
+;   slli a4, a2, 0x27
+;   fmv.d.x fa0, a4
+;   feq.d a1, fa4, fa4
+;   feq.d a3, fa4, fa4
+;   and a5, a1, a3
+;   beqz a5, 8
+;   fmv.d fa0, fa4
+;   ret
+
+function %f1(f32, f32) -> f32 {
+block0(v0: f32, v1: f32):
+	v2 = fadd v0, v1
+	return v2
+}
+
+; VCode:
+; block0:
+;   fadd.s fa3,fa0,fa1,rne
+;   lui a2,523264
+;   fmv.w.x fa4,a2
+;   feq.s a0,fa3,fa3
+;   feq.s a2,fa3,fa3
+;   and a4,a0,a2
+;   select fa0,fa4,fa3##condition=(a4 eq zero)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   fadd.s fa3, fa0, fa1, rne
+;   lui a2, 0x7fc00
+;   fmv.w.x fa4, a2
+;   feq.s a0, fa3, fa3
+;   feq.s a2, fa3, fa3
+;   and a4, a0, a2
+;   fmv.d fa0, fa4
+;   beqz a4, 8
+;   fmv.d fa0, fa3
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/narrow-arithmetic.clif b/cranelift/filetests/filetests/isa/riscv64/narrow-arithmetic.clif
index 6223052f8bff..05b39aeea943 100644
--- a/cranelift/filetests/filetests/isa/riscv64/narrow-arithmetic.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/narrow-arithmetic.clif
@@ -10,12 +10,12 @@ block0(v0: i8, v1: i8):
 
 ; VCode:
 ; block0:
-;   add a0,a0,a1
+;   addw a0,a0,a1
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   add a0, a0, a1
+;   addw a0, a0, a1
 ;   ret
 
 function %add16(i16, i16) -> i16 {
@@ -26,12 +26,12 @@ block0(v0: i16, v1: i16):
 
 ; VCode:
 ; block0:
-;   add a0,a0,a1
+;   addw a0,a0,a1
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   add a0, a0, a1
+;   addw a0, a0, a1
 ;   ret
 
 function %add32(i32, i32) -> i32 {
@@ -42,12 +42,12 @@ block0(v0: i32, v1: i32):
 
 ; VCode:
 ; block0:
-;   add a0,a0,a1
+;   addw a0,a0,a1
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   add a0, a0, a1
+;   addw a0, a0, a1
 ;   ret
 
 function %add32_8(i32, i8) -> i32 {
@@ -61,14 +61,14 @@ block0(v0: i32, v1: i8):
 ; block0:
 ;   slli a4,a1,56
 ;   srai a1,a4,56
-;   add a0,a0,a1
+;   addw a0,a0,a1
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   slli a4, a1, 0x38
 ;   srai a1, a4, 0x38
-;   add a0, a0, a1
+;   addw a0, a0, a1
 ;   ret
 
 function %add64_32(i64, i32) -> i64 {
diff --git a/cranelift/filetests/filetests/isa/riscv64/nearest.clif b/cranelift/filetests/filetests/isa/riscv64/nearest.clif
new file mode 100644
index 000000000000..d1d6a284323f
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/nearest.clif
@@ -0,0 +1,77 @@
+test compile precise-output
+set unwind_info=false
+target riscv64
+
+function %nearest_f32(f32) -> f32 {
+block0(v0: f32):
+  v1 = nearest v0
+  return v1
+}
+
+; VCode:
+; block0:
+;   lui a2,307200
+;   fmv.w.x fa4,a2
+;   fabs.s fa1,fa0
+;   flt.s a2,fa1,fa4
+;   fcvt.w.s a4,fa0,rne
+;   fcvt.s.w fa1,a4,rne
+;   fsgnj.s fa2,fa1,fa0
+;   fmv.w.x fa4,zero
+;   fadd.s fa0,fa0,fa4,rne
+;   select fa0,fa0,fa2##condition=(a2 eq zero)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   lui a2, 0x4b000
+;   fmv.w.x fa4, a2
+;   fabs.s fa1, fa0
+;   flt.s a2, fa1, fa4
+;   fcvt.w.s a4, fa0, rne ; trap: bad_toint
+;   fcvt.s.w fa1, a4, rne
+;   fsgnj.s fa2, fa1, fa0
+;   fmv.w.x fa4, zero
+;   fadd.s fa0, fa0, fa4, rne
+;   beqz a2, 8
+;   fmv.d fa0, fa2
+;   ret
+
+function %nearest_f64(f64) -> f64 {
+block0(v0: f64):
+  v1 = nearest v0
+  return v1
+}
+
+; VCode:
+; block0:
+;   lui a2,1075
+;   slli a4,a2,40
+;   fmv.d.x fa1,a4
+;   fabs.d fa2,fa0
+;   flt.d a4,fa2,fa1
+;   fcvt.l.d a0,fa0,rne
+;   fcvt.d.l fa2,a0,rne
+;   fsgnj.d fa4,fa2,fa0
+;   fmv.d.x fa1,zero
+;   fadd.d fa2,fa0,fa1,rne
+;   select fa0,fa2,fa4##condition=(a4 eq zero)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   lui a2, 0x433
+;   slli a4, a2, 0x28
+;   fmv.d.x fa1, a4
+;   fabs.d fa2, fa0
+;   flt.d a4, fa2, fa1
+;   fcvt.l.d a0, fa0, rne ; trap: bad_toint
+;   fcvt.d.l fa2, a0, rne
+;   fsgnj.d fa4, fa2, fa0
+;   fmv.d.x fa1, zero
+;   fadd.d fa2, fa0, fa1, rne
+;   fmv.d fa0, fa2
+;   beqz a4, 8
+;   fmv.d fa0, fa4
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/prologue.clif b/cranelift/filetests/filetests/isa/riscv64/prologue.clif
index 1d865a133a52..c7abde812fbf 100644
--- a/cranelift/filetests/filetests/isa/riscv64/prologue.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/prologue.clif
@@ -76,100 +76,100 @@ block0(v0: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   fsd fs0,-8(sp)
-;   fsd fs2,-16(sp)
-;   fsd fs3,-24(sp)
-;   fsd fs4,-32(sp)
-;   fsd fs5,-40(sp)
-;   fsd fs6,-48(sp)
-;   fsd fs7,-56(sp)
-;   fsd fs8,-64(sp)
-;   fsd fs9,-72(sp)
-;   fsd fs10,-80(sp)
-;   fsd fs11,-88(sp)
-;   add sp,-96
+;   addi sp,sp,-96
+;   fsd fs0,88(sp)
+;   fsd fs2,80(sp)
+;   fsd fs3,72(sp)
+;   fsd fs4,64(sp)
+;   fsd fs5,56(sp)
+;   fsd fs6,48(sp)
+;   fsd fs7,40(sp)
+;   fsd fs8,32(sp)
+;   fsd fs9,24(sp)
+;   fsd fs10,16(sp)
+;   fsd fs11,8(sp)
 ; block0:
-;   fadd.d fa3,fa0,fa0
-;   fadd.d fa4,fa0,fa0
-;   fadd.d fa5,fa0,fa0
-;   fadd.d fa1,fa0,fa0
-;   fadd.d fa2,fa0,fa0
-;   fadd.d ft9,fa0,fa0
-;   fadd.d ft10,fa0,fa0
-;   fadd.d ft11,fa0,fa0
-;   fadd.d fs0,fa0,fa0
-;   fadd.d fs1,fa0,fa0
-;   fadd.d fs2,fa0,fa0
-;   fadd.d fs3,fa0,fa0
-;   fadd.d fs4,fa0,fa0
-;   fadd.d fs5,fa0,fa0
-;   fadd.d fs6,fa0,fa0
-;   fadd.d fs7,fa0,fa0
-;   fadd.d fs8,fa0,fa0
-;   fadd.d fs9,fa0,fa0
-;   fadd.d fs10,fa0,fa0
-;   fadd.d fs11,fa0,fa0
-;   fadd.d ft0,fa0,fa0
-;   fadd.d ft1,fa0,fa0
-;   fadd.d ft2,fa0,fa0
-;   fadd.d ft3,fa0,fa0
-;   fadd.d ft4,fa0,fa0
-;   fadd.d ft5,fa0,fa0
-;   fadd.d ft6,fa0,fa0
-;   fadd.d ft7,fa0,fa0
-;   fadd.d fa6,fa0,fa0
-;   fadd.d fa7,fa0,fa0
-;   fadd.d ft8,fa0,fa0
-;   fadd.d fa3,fa0,fa3
-;   fadd.d fa4,fa4,fa5
-;   fadd.d fa5,fa1,fa2
-;   fadd.d fa0,ft9,ft10
-;   fadd.d fa1,ft11,fs0
-;   fadd.d fa2,fs1,fs2
-;   fadd.d ft9,fs3,fs4
-;   fadd.d ft10,fs5,fs6
-;   fadd.d ft11,fs7,fs8
-;   fadd.d fs0,fs9,fs10
-;   fadd.d fs1,fs11,ft0
-;   fadd.d fs2,ft1,ft2
-;   fadd.d fs3,ft3,ft4
-;   fadd.d fs4,ft5,ft6
-;   fadd.d fs5,ft7,fa6
-;   fadd.d fs6,fa7,ft8
-;   fadd.d fa3,fa3,fa4
-;   fadd.d fa4,fa5,fa0
-;   fadd.d fa5,fa1,fa2
-;   fadd.d fa0,ft9,ft10
-;   fadd.d fa1,ft11,fs0
-;   fadd.d fa2,fs1,fs2
-;   fadd.d ft9,fs3,fs4
-;   fadd.d ft10,fs5,fs6
-;   fadd.d fa3,fa3,fa4
-;   fadd.d fa4,fa5,fa0
-;   fadd.d fa5,fa1,fa2
-;   fadd.d fa0,ft9,ft10
-;   fadd.d fa3,fa3,fa4
-;   fadd.d fa4,fa5,fa0
-;   fadd.d fa0,fa3,fa4
-;   add sp,+96
-;   fld fs0,-8(sp)
-;   fld fs2,-16(sp)
-;   fld fs3,-24(sp)
-;   fld fs4,-32(sp)
-;   fld fs5,-40(sp)
-;   fld fs6,-48(sp)
-;   fld fs7,-56(sp)
-;   fld fs8,-64(sp)
-;   fld fs9,-72(sp)
-;   fld fs10,-80(sp)
-;   fld fs11,-88(sp)
+;   fadd.d fa3,fa0,fa0,rne
+;   fadd.d fa4,fa0,fa0,rne
+;   fadd.d fa5,fa0,fa0,rne
+;   fadd.d fa1,fa0,fa0,rne
+;   fadd.d fa2,fa0,fa0,rne
+;   fadd.d ft9,fa0,fa0,rne
+;   fadd.d ft10,fa0,fa0,rne
+;   fadd.d ft11,fa0,fa0,rne
+;   fadd.d fs0,fa0,fa0,rne
+;   fadd.d fs1,fa0,fa0,rne
+;   fadd.d fs2,fa0,fa0,rne
+;   fadd.d fs3,fa0,fa0,rne
+;   fadd.d fs4,fa0,fa0,rne
+;   fadd.d fs5,fa0,fa0,rne
+;   fadd.d fs6,fa0,fa0,rne
+;   fadd.d fs7,fa0,fa0,rne
+;   fadd.d fs8,fa0,fa0,rne
+;   fadd.d fs9,fa0,fa0,rne
+;   fadd.d fs10,fa0,fa0,rne
+;   fadd.d fs11,fa0,fa0,rne
+;   fadd.d ft0,fa0,fa0,rne
+;   fadd.d ft1,fa0,fa0,rne
+;   fadd.d ft2,fa0,fa0,rne
+;   fadd.d ft3,fa0,fa0,rne
+;   fadd.d ft4,fa0,fa0,rne
+;   fadd.d ft5,fa0,fa0,rne
+;   fadd.d ft6,fa0,fa0,rne
+;   fadd.d ft7,fa0,fa0,rne
+;   fadd.d fa6,fa0,fa0,rne
+;   fadd.d fa7,fa0,fa0,rne
+;   fadd.d ft8,fa0,fa0,rne
+;   fadd.d fa3,fa0,fa3,rne
+;   fadd.d fa4,fa4,fa5,rne
+;   fadd.d fa5,fa1,fa2,rne
+;   fadd.d fa0,ft9,ft10,rne
+;   fadd.d fa1,ft11,fs0,rne
+;   fadd.d fa2,fs1,fs2,rne
+;   fadd.d ft9,fs3,fs4,rne
+;   fadd.d ft10,fs5,fs6,rne
+;   fadd.d ft11,fs7,fs8,rne
+;   fadd.d fs0,fs9,fs10,rne
+;   fadd.d fs1,fs11,ft0,rne
+;   fadd.d fs2,ft1,ft2,rne
+;   fadd.d fs3,ft3,ft4,rne
+;   fadd.d fs4,ft5,ft6,rne
+;   fadd.d fs5,ft7,fa6,rne
+;   fadd.d fs6,fa7,ft8,rne
+;   fadd.d fa3,fa3,fa4,rne
+;   fadd.d fa4,fa5,fa0,rne
+;   fadd.d fa5,fa1,fa2,rne
+;   fadd.d fa0,ft9,ft10,rne
+;   fadd.d fa1,ft11,fs0,rne
+;   fadd.d fa2,fs1,fs2,rne
+;   fadd.d ft9,fs3,fs4,rne
+;   fadd.d ft10,fs5,fs6,rne
+;   fadd.d fa3,fa3,fa4,rne
+;   fadd.d fa4,fa5,fa0,rne
+;   fadd.d fa5,fa1,fa2,rne
+;   fadd.d fa0,ft9,ft10,rne
+;   fadd.d fa3,fa3,fa4,rne
+;   fadd.d fa4,fa5,fa0,rne
+;   fadd.d fa0,fa3,fa4,rne
+;   fld fs0,88(sp)
+;   fld fs2,80(sp)
+;   fld fs3,72(sp)
+;   fld fs4,64(sp)
+;   fld fs5,56(sp)
+;   fld fs6,48(sp)
+;   fld fs7,40(sp)
+;   fld fs8,32(sp)
+;   fld fs9,24(sp)
+;   fld fs10,16(sp)
+;   fld fs11,8(sp)
+;   addi sp,sp,96
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -178,93 +178,93 @@ block0(v0: f64):
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   fsd fs0, -8(sp)
-;   fsd fs2, -0x10(sp)
-;   fsd fs3, -0x18(sp)
-;   fsd fs4, -0x20(sp)
-;   fsd fs5, -0x28(sp)
-;   fsd fs6, -0x30(sp)
-;   fsd fs7, -0x38(sp)
-;   fsd fs8, -0x40(sp)
-;   fsd fs9, -0x48(sp)
-;   fsd fs10, -0x50(sp)
-;   fsd fs11, -0x58(sp)
 ;   addi sp, sp, -0x60
+;   fsd fs0, 0x58(sp)
+;   fsd fs2, 0x50(sp)
+;   fsd fs3, 0x48(sp)
+;   fsd fs4, 0x40(sp)
+;   fsd fs5, 0x38(sp)
+;   fsd fs6, 0x30(sp)
+;   fsd fs7, 0x28(sp)
+;   fsd fs8, 0x20(sp)
+;   fsd fs9, 0x18(sp)
+;   fsd fs10, 0x10(sp)
+;   fsd fs11, 8(sp)
 ; block1: ; offset 0x40
-;   fadd.d fa3, fa0, fa0
-;   fadd.d fa4, fa0, fa0
-;   fadd.d fa5, fa0, fa0
-;   fadd.d fa1, fa0, fa0
-;   fadd.d fa2, fa0, fa0
-;   fadd.d ft9, fa0, fa0
-;   fadd.d ft10, fa0, fa0
-;   fadd.d ft11, fa0, fa0
-;   fadd.d fs0, fa0, fa0
-;   fadd.d fs1, fa0, fa0
-;   fadd.d fs2, fa0, fa0
-;   fadd.d fs3, fa0, fa0
-;   fadd.d fs4, fa0, fa0
-;   fadd.d fs5, fa0, fa0
-;   fadd.d fs6, fa0, fa0
-;   fadd.d fs7, fa0, fa0
-;   fadd.d fs8, fa0, fa0
-;   fadd.d fs9, fa0, fa0
-;   fadd.d fs10, fa0, fa0
-;   fadd.d fs11, fa0, fa0
-;   fadd.d ft0, fa0, fa0
-;   fadd.d ft1, fa0, fa0
-;   fadd.d ft2, fa0, fa0
-;   fadd.d ft3, fa0, fa0
-;   fadd.d ft4, fa0, fa0
-;   fadd.d ft5, fa0, fa0
-;   fadd.d ft6, fa0, fa0
-;   fadd.d ft7, fa0, fa0
-;   fadd.d fa6, fa0, fa0
-;   fadd.d fa7, fa0, fa0
-;   fadd.d ft8, fa0, fa0
-;   fadd.d fa3, fa0, fa3
-;   fadd.d fa4, fa4, fa5
-;   fadd.d fa5, fa1, fa2
-;   fadd.d fa0, ft9, ft10
-;   fadd.d fa1, ft11, fs0
-;   fadd.d fa2, fs1, fs2
-;   fadd.d ft9, fs3, fs4
-;   fadd.d ft10, fs5, fs6
-;   fadd.d ft11, fs7, fs8
-;   fadd.d fs0, fs9, fs10
-;   fadd.d fs1, fs11, ft0
-;   fadd.d fs2, ft1, ft2
-;   fadd.d fs3, ft3, ft4
-;   fadd.d fs4, ft5, ft6
-;   fadd.d fs5, ft7, fa6
-;   fadd.d fs6, fa7, ft8
-;   fadd.d fa3, fa3, fa4
-;   fadd.d fa4, fa5, fa0
-;   fadd.d fa5, fa1, fa2
-;   fadd.d fa0, ft9, ft10
-;   fadd.d fa1, ft11, fs0
-;   fadd.d fa2, fs1, fs2
-;   fadd.d ft9, fs3, fs4
-;   fadd.d ft10, fs5, fs6
-;   fadd.d fa3, fa3, fa4
-;   fadd.d fa4, fa5, fa0
-;   fadd.d fa5, fa1, fa2
-;   fadd.d fa0, ft9, ft10
-;   fadd.d fa3, fa3, fa4
-;   fadd.d fa4, fa5, fa0
-;   fadd.d fa0, fa3, fa4
+;   fadd.d fa3, fa0, fa0, rne
+;   fadd.d fa4, fa0, fa0, rne
+;   fadd.d fa5, fa0, fa0, rne
+;   fadd.d fa1, fa0, fa0, rne
+;   fadd.d fa2, fa0, fa0, rne
+;   fadd.d ft9, fa0, fa0, rne
+;   fadd.d ft10, fa0, fa0, rne
+;   fadd.d ft11, fa0, fa0, rne
+;   fadd.d fs0, fa0, fa0, rne
+;   fadd.d fs1, fa0, fa0, rne
+;   fadd.d fs2, fa0, fa0, rne
+;   fadd.d fs3, fa0, fa0, rne
+;   fadd.d fs4, fa0, fa0, rne
+;   fadd.d fs5, fa0, fa0, rne
+;   fadd.d fs6, fa0, fa0, rne
+;   fadd.d fs7, fa0, fa0, rne
+;   fadd.d fs8, fa0, fa0, rne
+;   fadd.d fs9, fa0, fa0, rne
+;   fadd.d fs10, fa0, fa0, rne
+;   fadd.d fs11, fa0, fa0, rne
+;   fadd.d ft0, fa0, fa0, rne
+;   fadd.d ft1, fa0, fa0, rne
+;   fadd.d ft2, fa0, fa0, rne
+;   fadd.d ft3, fa0, fa0, rne
+;   fadd.d ft4, fa0, fa0, rne
+;   fadd.d ft5, fa0, fa0, rne
+;   fadd.d ft6, fa0, fa0, rne
+;   fadd.d ft7, fa0, fa0, rne
+;   fadd.d fa6, fa0, fa0, rne
+;   fadd.d fa7, fa0, fa0, rne
+;   fadd.d ft8, fa0, fa0, rne
+;   fadd.d fa3, fa0, fa3, rne
+;   fadd.d fa4, fa4, fa5, rne
+;   fadd.d fa5, fa1, fa2, rne
+;   fadd.d fa0, ft9, ft10, rne
+;   fadd.d fa1, ft11, fs0, rne
+;   fadd.d fa2, fs1, fs2, rne
+;   fadd.d ft9, fs3, fs4, rne
+;   fadd.d ft10, fs5, fs6, rne
+;   fadd.d ft11, fs7, fs8, rne
+;   fadd.d fs0, fs9, fs10, rne
+;   fadd.d fs1, fs11, ft0, rne
+;   fadd.d fs2, ft1, ft2, rne
+;   fadd.d fs3, ft3, ft4, rne
+;   fadd.d fs4, ft5, ft6, rne
+;   fadd.d fs5, ft7, fa6, rne
+;   fadd.d fs6, fa7, ft8, rne
+;   fadd.d fa3, fa3, fa4, rne
+;   fadd.d fa4, fa5, fa0, rne
+;   fadd.d fa5, fa1, fa2, rne
+;   fadd.d fa0, ft9, ft10, rne
+;   fadd.d fa1, ft11, fs0, rne
+;   fadd.d fa2, fs1, fs2, rne
+;   fadd.d ft9, fs3, fs4, rne
+;   fadd.d ft10, fs5, fs6, rne
+;   fadd.d fa3, fa3, fa4, rne
+;   fadd.d fa4, fa5, fa0, rne
+;   fadd.d fa5, fa1, fa2, rne
+;   fadd.d fa0, ft9, ft10, rne
+;   fadd.d fa3, fa3, fa4, rne
+;   fadd.d fa4, fa5, fa0, rne
+;   fadd.d fa0, fa3, fa4, rne
+;   fld fs0, 0x58(sp)
+;   fld fs2, 0x50(sp)
+;   fld fs3, 0x48(sp)
+;   fld fs4, 0x40(sp)
+;   fld fs5, 0x38(sp)
+;   fld fs6, 0x30(sp)
+;   fld fs7, 0x28(sp)
+;   fld fs8, 0x20(sp)
+;   fld fs9, 0x18(sp)
+;   fld fs10, 0x10(sp)
+;   fld fs11, 8(sp)
 ;   addi sp, sp, 0x60
-;   fld fs0, -8(sp)
-;   fld fs2, -0x10(sp)
-;   fld fs3, -0x18(sp)
-;   fld fs4, -0x20(sp)
-;   fld fs5, -0x28(sp)
-;   fld fs6, -0x30(sp)
-;   fld fs7, -0x38(sp)
-;   fld fs8, -0x40(sp)
-;   fld fs9, -0x48(sp)
-;   fld fs10, -0x50(sp)
-;   fld fs11, -0x58(sp)
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -317,18 +317,18 @@ block0(v0: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   sd s1,-8(sp)
-;   sd s2,-16(sp)
-;   sd s3,-24(sp)
-;   sd s4,-32(sp)
-;   sd s5,-40(sp)
-;   sd s6,-48(sp)
-;   sd s7,-56(sp)
-;   add sp,-64
+;   addi sp,sp,-64
+;   sd s1,56(sp)
+;   sd s2,48(sp)
+;   sd s3,40(sp)
+;   sd s4,32(sp)
+;   sd s5,24(sp)
+;   sd s6,16(sp)
+;   sd s7,8(sp)
 ; block0:
 ;   add a1,a0,a0
 ;   add a2,a0,a1
@@ -366,17 +366,17 @@ block0(v0: i64):
 ;   add a2,a3,a4
 ;   add a1,a5,a1
 ;   add a0,a2,a1
-;   add sp,+64
-;   ld s1,-8(sp)
-;   ld s2,-16(sp)
-;   ld s3,-24(sp)
-;   ld s4,-32(sp)
-;   ld s5,-40(sp)
-;   ld s6,-48(sp)
-;   ld s7,-56(sp)
+;   ld s1,56(sp)
+;   ld s2,48(sp)
+;   ld s3,40(sp)
+;   ld s4,32(sp)
+;   ld s5,24(sp)
+;   ld s6,16(sp)
+;   ld s7,8(sp)
+;   addi sp,sp,64
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -385,14 +385,14 @@ block0(v0: i64):
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   sd s1, -8(sp)
-;   sd s2, -0x10(sp)
-;   sd s3, -0x18(sp)
-;   sd s4, -0x20(sp)
-;   sd s5, -0x28(sp)
-;   sd s6, -0x30(sp)
-;   sd s7, -0x38(sp)
 ;   addi sp, sp, -0x40
+;   sd s1, 0x38(sp)
+;   sd s2, 0x30(sp)
+;   sd s3, 0x28(sp)
+;   sd s4, 0x20(sp)
+;   sd s5, 0x18(sp)
+;   sd s6, 0x10(sp)
+;   sd s7, 8(sp)
 ; block1: ; offset 0x30
 ;   add a1, a0, a0
 ;   add a2, a0, a1
@@ -430,14 +430,14 @@ block0(v0: i64):
 ;   add a2, a3, a4
 ;   add a1, a5, a1
 ;   add a0, a2, a1
+;   ld s1, 0x38(sp)
+;   ld s2, 0x30(sp)
+;   ld s3, 0x28(sp)
+;   ld s4, 0x20(sp)
+;   ld s5, 0x18(sp)
+;   ld s6, 0x10(sp)
+;   ld s7, 8(sp)
 ;   addi sp, sp, 0x40
-;   ld s1, -8(sp)
-;   ld s2, -0x10(sp)
-;   ld s3, -0x18(sp)
-;   ld s4, -0x20(sp)
-;   ld s5, -0x28(sp)
-;   ld s6, -0x30(sp)
-;   ld s7, -0x38(sp)
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
diff --git a/cranelift/filetests/filetests/isa/riscv64/reftypes.clif b/cranelift/filetests/filetests/isa/riscv64/reftypes.clif
deleted file mode 100644
index 85bcfdadfce9..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/reftypes.clif
+++ /dev/null
@@ -1,173 +0,0 @@
-test compile precise-output
-set unwind_info=false
-target riscv64
-
-function %f0(r64) -> r64 {
-block0(v0: r64):
-  return v0
-}
-
-; VCode:
-; block0:
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   ret
-
-function %f1(r64) -> i8 {
-block0(v0: r64):
-  v1 = is_null v0
-  return v1
-}
-
-; VCode:
-; block0:
-;   seqz a0,a0
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   seqz a0, a0
-;   ret
-
-function %f2(r64) -> i8 {
-block0(v0: r64):
-  v1 = is_invalid v0
-  return v1
-}
-
-; VCode:
-; block0:
-;   addi a2,a0,1
-;   seqz a0,a2
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   addi a2, a0, 1
-;   seqz a0, a2
-;   ret
-
-function %f3() -> r64 {
-block0:
-  v0 = null.r64
-  return v0
-}
-
-; VCode:
-; block0:
-;   li a0,0
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   mv a0, zero
-;   ret
-
-function %f4(r64, r64) -> r64, r64, r64 {
-    fn0 = %f(r64) -> i8
-    ss0 = explicit_slot 8
-
-block0(v0: r64, v1: r64):
-    v2 = call fn0(v0)
-    stack_store.r64 v0, ss0
-    brif v2, block2(v0, v1), block1(v1, v0)
-
-block1(v3: r64, v4: r64):
-    jump block3(v3, v4)
-
-block2(v5: r64, v6: r64):
-    jump block3(v5, v6)
-
-block3(v7: r64, v8: r64):
-    v9 = stack_load.r64 ss0
-    return v7, v8, v9
-}
-
-; VCode:
-;   add sp,-16
-;   sd ra,8(sp)
-;   sd fp,0(sp)
-;   mv fp,sp
-;   sd s5,-8(sp)
-;   sd s9,-16(sp)
-;   add sp,-48
-; block0:
-;   mv a3,a0
-;   sd a1,16(nominal_sp)
-;   mv s5,a2
-;   mv a3,a0
-;   mv s9,a3
-;   load_sym a5,%f+0
-;   sd s9,8(nominal_sp)
-;   callind a5
-;   mv a3,s9
-;   sd a3,0(nominal_sp)
-;   andi a5,a0,255
-;   bne a5,zero,taken(label2),not_taken(label1)
-; block1:
-;   mv a1,s9
-;   ld a0,16(nominal_sp)
-;   j label3
-; block2:
-;   mv a0,s9
-;   ld a1,16(nominal_sp)
-;   j label3
-; block3:
-;   ld a2,0(nominal_sp)
-;   mv a3,s5
-;   sd a2,0(a3)
-;   add sp,+48
-;   ld s5,-8(sp)
-;   ld s9,-16(sp)
-;   ld ra,8(sp)
-;   ld fp,0(sp)
-;   add sp,+16
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   addi sp, sp, -0x10
-;   sd ra, 8(sp)
-;   sd s0, 0(sp)
-;   mv s0, sp
-;   sd s5, -8(sp)
-;   sd s9, -0x10(sp)
-;   addi sp, sp, -0x30
-; block1: ; offset 0x1c
-;   mv a3, a0
-;   sd a1, 0x10(sp)
-;   mv s5, a2
-;   mv a0, a3
-;   mv s9, a3
-;   auipc a5, 0
-;   ld a5, 0xc(a5)
-;   j 0xc
-;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %f 0
-;   .byte 0x00, 0x00, 0x00, 0x00
-;   sd s9, 8(sp)
-;   jalr a5
-;   mv a3, s9
-;   sd a3, 0(sp)
-;   andi a5, a0, 0xff
-;   bnez a5, 0x10
-; block2: ; offset 0x5c
-;   mv a1, s9
-;   ld a0, 0x10(sp)
-;   j 0xc
-; block3: ; offset 0x68
-;   mv a0, s9
-;   ld a1, 0x10(sp)
-; block4: ; offset 0x70
-;   ld a2, 0(sp)
-;   mv a3, s5
-;   sd a2, 0(a3)
-;   addi sp, sp, 0x30
-;   ld s5, -8(sp)
-;   ld s9, -0x10(sp)
-;   ld ra, 8(sp)
-;   ld s0, 0(sp)
-;   addi sp, sp, 0x10
-;   ret
-
diff --git a/cranelift/filetests/filetests/isa/riscv64/return-call-indirect.clif b/cranelift/filetests/filetests/isa/riscv64/return-call-indirect.clif
new file mode 100644
index 000000000000..d5d1d7b5740f
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/return-call-indirect.clif
@@ -0,0 +1,419 @@
+test compile precise-output
+
+target riscv64
+
+;;;; Test passing `i64`s ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+function %callee_i64(i64) -> i64 tail {
+block0(v0: i64):
+    v1 = iadd_imm.i64 v0, 10
+    return v1
+}
+
+; VCode:
+; block0:
+;   addi a0,a0,10
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi a0, a0, 0xa
+;   ret
+
+function %call_i64(i64) -> i64 tail {
+    sig0 = (i64) -> i64 tail
+    fn0 = %callee_i64(i64) -> i64 tail
+
+block0(v0: i64):
+    v1 = func_addr.i64 fn0
+    return_call_indirect sig0, v1(v0)
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+; block0:
+;   load_sym t0,%callee_i64+0
+;   return_call_ind t0 new_stack_arg_size:0 a0=a0
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+; block1: ; offset 0x10
+;   auipc t0, 0
+;   ld t0, 0xc(t0)
+;   j 0xc
+;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %callee_i64 0
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   jr t0
+
+;;;; Test colocated tail calls ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+function %colocated_i64(i64) -> i64 tail {
+    sig0 = (i64) -> i64 tail
+    fn0 = colocated %callee_i64(i64) -> i64 tail
+
+block0(v0: i64):
+    v1 = func_addr.i64 fn0
+    return_call_indirect sig0, v1(v0)
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+; block0:
+;   load_sym t0,%callee_i64+0
+;   return_call_ind t0 new_stack_arg_size:0 a0=a0
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+; block1: ; offset 0x10
+;   auipc t0, 0
+;   ld t0, 0xc(t0)
+;   j 0xc
+;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %callee_i64 0
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   jr t0
+
+;;;; Test passing `f64`s ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+function %callee_f64(f64) -> f64 tail {
+block0(v0: f64):
+    v1 = f64const 0x10.0
+    v2 = fadd.f64 v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   lui a3,1027
+;   slli a5,a3,40
+;   fmv.d.x fa1,a5
+;   fadd.d fa0,fa0,fa1,rne
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   lui a3, 0x403
+;   slli a5, a3, 0x28
+;   fmv.d.x fa1, a5
+;   fadd.d fa0, fa0, fa1, rne
+;   ret
+
+function %call_f64(f64) -> f64 tail {
+    sig0 = (f64) -> f64 tail
+    fn0 = %callee_f64(f64) -> f64 tail
+
+block0(v0: f64):
+    v1 = func_addr.i64 fn0
+    return_call_indirect sig0, v1(v0)
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+; block0:
+;   load_sym t0,%callee_f64+0
+;   return_call_ind t0 new_stack_arg_size:0 fa0=fa0
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+; block1: ; offset 0x10
+;   auipc t0, 0
+;   ld t0, 0xc(t0)
+;   j 0xc
+;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %callee_f64 0
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   jr t0
+
+;;;; Test passing `i8`s ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+function %callee_i8(i8) -> i8 tail {
+block0(v0: i8):
+    v1 = iconst.i8 0
+    v2 = icmp eq v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   andi a2,a0,255
+;   seqz a0,a2
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   andi a2, a0, 0xff
+;   seqz a0, a2
+;   ret
+
+function %call_i8(i8) -> i8 tail {
+    sig0 = (i8) -> i8 tail
+    fn0 = %callee_i8(i8) -> i8 tail
+
+block0(v0: i8):
+    v1 = func_addr.i64 fn0
+    return_call_indirect sig0, v1(v0)
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+; block0:
+;   load_sym t0,%callee_i8+0
+;   return_call_ind t0 new_stack_arg_size:0 a0=a0
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+; block1: ; offset 0x10
+;   auipc t0, 0
+;   ld t0, 0xc(t0)
+;   j 0xc
+;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %callee_i8 0
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   jr t0
+
+;;;; Test passing many arguments on stack ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+function %tail_caller_stack_args() -> i64 tail {
+    fn0 = %tail_callee_stack_args(i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64) -> i64 tail
+
+block0:
+    v0 = iconst.i64 10
+    v1 = iconst.i64 15
+    v2 = iconst.i64 20
+    v3 = iconst.i64 25
+    v4 = iconst.i64 30
+    v5 = iconst.i64 35
+    v6 = iconst.i64 40
+    v7 = iconst.i64 45
+    v8 = iconst.i64 50
+    v9 = iconst.i64 55
+    v10 = iconst.i64 60
+    v11 = iconst.i64 65
+    v12 = iconst.i64 70
+    v13 = iconst.i64 75
+    v14 = iconst.i64 80
+    v15 = iconst.i64 85
+    v16 = iconst.i64 90
+    v17 = iconst.i64 95
+    v18 = iconst.i64 100
+    v19 = iconst.i64 105
+    v20 = iconst.i64 110
+    v21 = iconst.i64 115
+    v22 = iconst.i64 120
+    v23 = iconst.i64 125
+    v24 = iconst.i64 130
+    v25 = iconst.i64 135
+    v26 = func_addr.i64 fn0
+    return_call_indirect sig0, v26(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25)
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+;   addi sp,sp,-144
+;   sd ra,8(sp)
+;   ld fp,144(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+;   addi sp,sp,-128
+;   sd s1,120(sp)
+;   sd s2,112(sp)
+;   sd s3,104(sp)
+;   sd s4,96(sp)
+;   sd s5,88(sp)
+;   sd s6,80(sp)
+;   sd s7,72(sp)
+;   sd s8,64(sp)
+;   sd s9,56(sp)
+;   sd s10,48(sp)
+;   sd s11,40(sp)
+; block0:
+;   li a1,10
+;   sd a1,16(slot)
+;   li a2,15
+;   sd a2,8(slot)
+;   li a3,20
+;   sd a3,0(slot)
+;   li a3,25
+;   li a4,30
+;   li a5,35
+;   li a6,40
+;   li a7,45
+;   li s2,50
+;   li s3,55
+;   li s4,60
+;   li s5,65
+;   li s6,70
+;   li s7,75
+;   li s8,80
+;   li s9,85
+;   li s10,90
+;   li s11,95
+;   li t0,100
+;   li t1,105
+;   li t2,110
+;   li t3,115
+;   li t4,120
+;   li s1,125
+;   li a0,130
+;   li a1,135
+;   load_sym a2,%tail_callee_stack_args+0
+;   sd s2,-144(incoming_arg)
+;   sd s3,-136(incoming_arg)
+;   sd s4,-128(incoming_arg)
+;   sd s5,-120(incoming_arg)
+;   sd s6,-112(incoming_arg)
+;   sd s7,-104(incoming_arg)
+;   sd s8,-96(incoming_arg)
+;   sd s9,-88(incoming_arg)
+;   sd s10,-80(incoming_arg)
+;   sd s11,-72(incoming_arg)
+;   sd t0,-64(incoming_arg)
+;   sd t1,-56(incoming_arg)
+;   sd t2,-48(incoming_arg)
+;   sd t3,-40(incoming_arg)
+;   sd t4,-32(incoming_arg)
+;   sd s1,-24(incoming_arg)
+;   sd a0,-16(incoming_arg)
+;   sd a1,-8(incoming_arg)
+;   ld a1,8(slot)
+;   ld a0,16(slot)
+;   mv t0,a2
+;   ld a2,0(slot)
+;   return_call_ind t0 new_stack_arg_size:144 a0=a0 a1=a1 a2=a2 a3=a3 a4=a4 a5=a5 a6=a6 a7=a7
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+;   addi sp, sp, -0x90
+;   sd ra, 8(sp)
+;   ld s0, 0x90(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+;   addi sp, sp, -0x80
+;   sd s1, 0x78(sp)
+;   sd s2, 0x70(sp)
+;   sd s3, 0x68(sp)
+;   sd s4, 0x60(sp)
+;   sd s5, 0x58(sp)
+;   sd s6, 0x50(sp)
+;   sd s7, 0x48(sp)
+;   sd s8, 0x40(sp)
+;   sd s9, 0x38(sp)
+;   sd s10, 0x30(sp)
+;   sd s11, 0x28(sp)
+; block1: ; offset 0x54
+;   addi a1, zero, 0xa
+;   sd a1, 0x10(sp)
+;   addi a2, zero, 0xf
+;   sd a2, 8(sp)
+;   addi a3, zero, 0x14
+;   sd a3, 0(sp)
+;   addi a3, zero, 0x19
+;   addi a4, zero, 0x1e
+;   addi a5, zero, 0x23
+;   addi a6, zero, 0x28
+;   addi a7, zero, 0x2d
+;   addi s2, zero, 0x32
+;   addi s3, zero, 0x37
+;   addi s4, zero, 0x3c
+;   addi s5, zero, 0x41
+;   addi s6, zero, 0x46
+;   addi s7, zero, 0x4b
+;   addi s8, zero, 0x50
+;   addi s9, zero, 0x55
+;   addi s10, zero, 0x5a
+;   addi s11, zero, 0x5f
+;   addi t0, zero, 0x64
+;   addi t1, zero, 0x69
+;   addi t2, zero, 0x6e
+;   addi t3, zero, 0x73
+;   addi t4, zero, 0x78
+;   addi s1, zero, 0x7d
+;   addi a0, zero, 0x82
+;   addi a1, zero, 0x87
+;   auipc a2, 0
+;   ld a2, 0xc(a2)
+;   j 0xc
+;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %tail_callee_stack_args 0
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   sd s2, 0x90(sp)
+;   sd s3, 0x98(sp)
+;   sd s4, 0xa0(sp)
+;   sd s5, 0xa8(sp)
+;   sd s6, 0xb0(sp)
+;   sd s7, 0xb8(sp)
+;   sd s8, 0xc0(sp)
+;   sd s9, 0xc8(sp)
+;   sd s10, 0xd0(sp)
+;   sd s11, 0xd8(sp)
+;   sd t0, 0xe0(sp)
+;   sd t1, 0xe8(sp)
+;   sd t2, 0xf0(sp)
+;   sd t3, 0xf8(sp)
+;   sd t4, 0x100(sp)
+;   sd s1, 0x108(sp)
+;   sd a0, 0x110(sp)
+;   sd a1, 0x118(sp)
+;   ld a1, 8(sp)
+;   ld a0, 0x10(sp)
+;   mv t0, a2
+;   ld a2, 0(sp)
+;   ld s1, 0x78(sp)
+;   ld s2, 0x70(sp)
+;   ld s3, 0x68(sp)
+;   ld s4, 0x60(sp)
+;   ld s5, 0x58(sp)
+;   ld s6, 0x50(sp)
+;   ld s7, 0x48(sp)
+;   ld s8, 0x40(sp)
+;   ld s9, 0x38(sp)
+;   ld s10, 0x30(sp)
+;   ld s11, 0x28(sp)
+;   ld ra, 0x88(sp)
+;   ld s0, 0x80(sp)
+;   addi sp, sp, 0x90
+;   jr t0
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/return-call.clif b/cranelift/filetests/filetests/isa/riscv64/return-call.clif
index ae7d8951717f..b472a6c31c3a 100644
--- a/cranelift/filetests/filetests/isa/riscv64/return-call.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/return-call.clif
@@ -12,12 +12,12 @@ block0(v0: i64):
 
 ; VCode:
 ; block0:
-;   addi s1,s1,10
+;   addi a0,a0,10
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi s1, s1, 0xa
+;   addi a0, a0, 0xa
 ;   ret
 
 function %call_i64(i64) -> i64 tail {
@@ -28,13 +28,13 @@ block0(v0: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   load_sym a2,%callee_i64+0
-;   return_call_ind a2 old_stack_arg_size:0 new_stack_arg_size:0 s1=s1
+;   load_sym t0,%callee_i64+0
+;   return_call_ind t0 new_stack_arg_size:0 a0=a0
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
@@ -43,16 +43,15 @@ block0(v0: i64):
 ;   sd s0, 0(sp)
 ;   mv s0, sp
 ; block1: ; offset 0x10
-;   auipc a2, 0
-;   ld a2, 0xc(a2)
+;   auipc t0, 0
+;   ld t0, 0xc(t0)
 ;   j 0xc
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %callee_i64 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   ld ra, 8(s0)
-;   ld t6, 0(s0)
-;   addi sp, s0, 0x10
-;   mv s0, t6
-;   jr a2
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   jr t0
 
 ;;;; Test colocated tail calls ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
@@ -64,12 +63,12 @@ block0(v0: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   return_call TestCase(%callee_i64) old_stack_arg_size:0 new_stack_arg_size:0 s1=s1
+;   return_call TestCase(%callee_i64) new_stack_arg_size:0 a0=a0
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
@@ -78,11 +77,10 @@ block0(v0: i64):
 ;   sd s0, 0(sp)
 ;   mv s0, sp
 ; block1: ; offset 0x10
-;   ld ra, 8(s0)
-;   ld t6, 0(s0)
-;   addi sp, s0, 0x10
-;   mv s0, t6
-;   auipc t6, 0 ; reloc_external RiscvCall %callee_i64 0
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   auipc t6, 0 ; reloc_external RiscvCallPlt %callee_i64 0
 ;   jr t6
 
 ;;;; Test passing `f64`s ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -99,7 +97,7 @@ block0(v0: f64):
 ;   lui a3,1027
 ;   slli a5,a3,40
 ;   fmv.d.x fa1,a5
-;   fadd.d ft0,ft0,fa1
+;   fadd.d fa0,fa0,fa1,rne
 ;   ret
 ;
 ; Disassembled:
@@ -107,7 +105,7 @@ block0(v0: f64):
 ;   lui a3, 0x403
 ;   slli a5, a3, 0x28
 ;   fmv.d.x fa1, a5
-;   fadd.d ft0, ft0, fa1
+;   fadd.d fa0, fa0, fa1, rne
 ;   ret
 
 function %call_f64(f64) -> f64 tail {
@@ -118,13 +116,13 @@ block0(v0: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   load_sym a2,%callee_f64+0
-;   return_call_ind a2 old_stack_arg_size:0 new_stack_arg_size:0 ft0=ft0
+;   load_sym t0,%callee_f64+0
+;   return_call_ind t0 new_stack_arg_size:0 fa0=fa0
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
@@ -133,16 +131,15 @@ block0(v0: f64):
 ;   sd s0, 0(sp)
 ;   mv s0, sp
 ; block1: ; offset 0x10
-;   auipc a2, 0
-;   ld a2, 0xc(a2)
+;   auipc t0, 0
+;   ld t0, 0xc(t0)
 ;   j 0xc
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %callee_f64 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   ld ra, 8(s0)
-;   ld t6, 0(s0)
-;   addi sp, s0, 0x10
-;   mv s0, t6
-;   jr a2
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   jr t0
 
 ;;;; Test passing `i8`s ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
@@ -155,21 +152,14 @@ block0(v0: i8):
 
 ; VCode:
 ; block0:
-;   li a5,0
-;   andi a3,s1,255
-;   andi a5,a5,255
-;   eq s1,a3,a5##ty=i8
+;   andi a2,a0,255
+;   seqz a0,a2
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mv a5, zero
-;   andi a3, s1, 0xff
-;   andi a5, a5, 0xff
-;   bne a3, a5, 0xc
-;   addi s1, zero, 1
-;   j 8
-;   mv s1, zero
+;   andi a2, a0, 0xff
+;   seqz a0, a2
 ;   ret
 
 function %call_i8(i8) -> i8 tail {
@@ -180,13 +170,13 @@ block0(v0: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   load_sym a2,%callee_i8+0
-;   return_call_ind a2 old_stack_arg_size:0 new_stack_arg_size:0 s1=s1
+;   load_sym t0,%callee_i8+0
+;   return_call_ind t0 new_stack_arg_size:0 a0=a0
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
@@ -195,16 +185,15 @@ block0(v0: i8):
 ;   sd s0, 0(sp)
 ;   mv s0, sp
 ; block1: ; offset 0x10
-;   auipc a2, 0
-;   ld a2, 0xc(a2)
+;   auipc t0, 0
+;   ld t0, 0xc(t0)
 ;   j 0xc
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %callee_i8 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   ld ra, 8(s0)
-;   ld t6, 0(s0)
-;   addi sp, s0, 0x10
-;   mv s0, t6
-;   jr a2
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   jr t0
 
 ;;;; Test passing many arguments on stack ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
@@ -214,20 +203,16 @@ block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64, v6: i64, v7: i64, v
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   ld a4,16(fp)
-;   ld a0,24(fp)
-;   ld a2,32(fp)
-;   ld a4,40(fp)
-;   ld s1,48(fp)
+;   ld a0,-8(incoming_arg)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
-;   add sp,+48
+;   addi sp,sp,16
+;   addi sp,sp,144
 ;   ret
 ;
 ; Disassembled:
@@ -237,15 +222,11 @@ block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64, v6: i64, v7: i64, v
 ;   sd s0, 0(sp)
 ;   mv s0, sp
 ; block1: ; offset 0x10
-;   ld a4, 0x10(s0)
-;   ld a0, 0x18(s0)
-;   ld a2, 0x20(s0)
-;   ld a4, 0x28(s0)
-;   ld s1, 0x30(s0)
+;   ld a0, 0x98(sp)
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
-;   addi sp, sp, 0x30
+;   addi sp, sp, 0x90
 ;   ret
 
 function %tail_caller_stack_args() -> i64 tail {
@@ -282,51 +263,78 @@ block0:
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   add sp,-16
+;   addi sp,sp,-144
+;   sd ra,8(sp)
+;   ld fp,144(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+;   addi sp,sp,-112
+;   sd s1,104(sp)
+;   sd s2,96(sp)
+;   sd s3,88(sp)
+;   sd s4,80(sp)
+;   sd s5,72(sp)
+;   sd s6,64(sp)
+;   sd s7,56(sp)
+;   sd s8,48(sp)
+;   sd s9,40(sp)
+;   sd s10,32(sp)
+;   sd s11,24(sp)
 ; block0:
-;   li s1,10
-;   sd s1,8(nominal_sp)
-;   li a0,15
-;   sd a0,0(nominal_sp)
-;   li a1,20
-;   li a2,25
-;   li a3,30
-;   li a4,35
-;   li a5,40
-;   li a6,45
-;   li a7,50
-;   li s2,55
-;   li s3,60
-;   li s4,65
-;   li s5,70
-;   li s6,75
-;   li s7,80
-;   li s8,85
-;   li s9,90
-;   li s10,95
-;   li s11,100
-;   li t3,105
-;   li t4,110
-;   li t0,115
-;   li t1,120
-;   li t2,125
-;   li s1,130
-;   li a0,135
-;   add sp,-48
-;   virtual_sp_offset_adj +48
-;   sd t0,0(sp)
-;   sd t1,8(sp)
-;   sd t2,16(sp)
-;   sd s1,24(sp)
-;   sd a0,32(sp)
+;   li a1,10
+;   sd a1,8(slot)
+;   li a2,15
+;   sd a2,0(slot)
+;   li a2,20
+;   li a3,25
+;   li a4,30
+;   li a5,35
+;   li a6,40
+;   li a7,45
+;   li s2,50
+;   li s3,55
+;   li s4,60
+;   li s5,65
+;   li s6,70
+;   li s7,75
+;   li s8,80
+;   li s9,85
+;   li s10,90
+;   li s11,95
+;   li t0,100
+;   li t1,105
+;   li t2,110
+;   li t3,115
+;   li t4,120
+;   li s1,125
+;   li a0,130
+;   li a1,135
+;   sd s2,-144(incoming_arg)
+;   sd s3,-136(incoming_arg)
+;   sd s4,-128(incoming_arg)
+;   sd s5,-120(incoming_arg)
+;   sd s6,-112(incoming_arg)
+;   sd s7,-104(incoming_arg)
+;   sd s8,-96(incoming_arg)
+;   sd s9,-88(incoming_arg)
+;   sd s10,-80(incoming_arg)
+;   sd s11,-72(incoming_arg)
+;   sd t0,-64(incoming_arg)
+;   sd t1,-56(incoming_arg)
+;   sd t2,-48(incoming_arg)
+;   sd t3,-40(incoming_arg)
+;   sd t4,-32(incoming_arg)
+;   sd s1,-24(incoming_arg)
+;   sd a0,-16(incoming_arg)
+;   sd a1,-8(incoming_arg)
 ;   load_sym t0,%tail_callee_stack_args+0
-;   ld a0,0(nominal_sp)
-;   ld s1,8(nominal_sp)
-;   return_call_ind t0 old_stack_arg_size:0 new_stack_arg_size:48 s1=s1 a0=a0 a1=a1 a2=a2 a3=a3 a4=a4 a5=a5 a6=a6 a7=a7 s2=s2 s3=s3 s4=s4 s5=s5 s6=s6 s7=s7 s8=s8 s9=s9 s10=s10 s11=s11 t3=t3 t4=t4
+;   ld a0,8(slot)
+;   ld a1,0(slot)
+;   return_call_ind t0 new_stack_arg_size:144 a0=a0 a1=a1 a2=a2 a3=a3 a4=a4 a5=a5 a6=a6 a7=a7
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
@@ -334,65 +342,91 @@ block0:
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   addi sp, sp, -0x10
-; block1: ; offset 0x14
-;   addi s1, zero, 0xa
-;   sd s1, 8(sp)
-;   addi a0, zero, 0xf
-;   sd a0, 0(sp)
-;   addi a1, zero, 0x14
-;   addi a2, zero, 0x19
-;   addi a3, zero, 0x1e
-;   addi a4, zero, 0x23
-;   addi a5, zero, 0x28
-;   addi a6, zero, 0x2d
-;   addi a7, zero, 0x32
-;   addi s2, zero, 0x37
-;   addi s3, zero, 0x3c
-;   addi s4, zero, 0x41
-;   addi s5, zero, 0x46
-;   addi s6, zero, 0x4b
-;   addi s7, zero, 0x50
-;   addi s8, zero, 0x55
-;   addi s9, zero, 0x5a
-;   addi s10, zero, 0x5f
-;   addi s11, zero, 0x64
-;   addi t3, zero, 0x69
-;   addi t4, zero, 0x6e
-;   addi t0, zero, 0x73
-;   addi t1, zero, 0x78
-;   addi t2, zero, 0x7d
-;   addi s1, zero, 0x82
-;   addi a0, zero, 0x87
-;   addi sp, sp, -0x30
-;   sd t0, 0(sp)
-;   sd t1, 8(sp)
-;   sd t2, 0x10(sp)
-;   sd s1, 0x18(sp)
-;   sd a0, 0x20(sp)
+;   addi sp, sp, -0x90
+;   sd ra, 8(sp)
+;   ld s0, 0x90(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+;   addi sp, sp, -0x70
+;   sd s1, 0x68(sp)
+;   sd s2, 0x60(sp)
+;   sd s3, 0x58(sp)
+;   sd s4, 0x50(sp)
+;   sd s5, 0x48(sp)
+;   sd s6, 0x40(sp)
+;   sd s7, 0x38(sp)
+;   sd s8, 0x30(sp)
+;   sd s9, 0x28(sp)
+;   sd s10, 0x20(sp)
+;   sd s11, 0x18(sp)
+; block1: ; offset 0x54
+;   addi a1, zero, 0xa
+;   sd a1, 8(sp)
+;   addi a2, zero, 0xf
+;   sd a2, 0(sp)
+;   addi a2, zero, 0x14
+;   addi a3, zero, 0x19
+;   addi a4, zero, 0x1e
+;   addi a5, zero, 0x23
+;   addi a6, zero, 0x28
+;   addi a7, zero, 0x2d
+;   addi s2, zero, 0x32
+;   addi s3, zero, 0x37
+;   addi s4, zero, 0x3c
+;   addi s5, zero, 0x41
+;   addi s6, zero, 0x46
+;   addi s7, zero, 0x4b
+;   addi s8, zero, 0x50
+;   addi s9, zero, 0x55
+;   addi s10, zero, 0x5a
+;   addi s11, zero, 0x5f
+;   addi t0, zero, 0x64
+;   addi t1, zero, 0x69
+;   addi t2, zero, 0x6e
+;   addi t3, zero, 0x73
+;   addi t4, zero, 0x78
+;   addi s1, zero, 0x7d
+;   addi a0, zero, 0x82
+;   addi a1, zero, 0x87
+;   sd s2, 0x80(sp)
+;   sd s3, 0x88(sp)
+;   sd s4, 0x90(sp)
+;   sd s5, 0x98(sp)
+;   sd s6, 0xa0(sp)
+;   sd s7, 0xa8(sp)
+;   sd s8, 0xb0(sp)
+;   sd s9, 0xb8(sp)
+;   sd s10, 0xc0(sp)
+;   sd s11, 0xc8(sp)
+;   sd t0, 0xd0(sp)
+;   sd t1, 0xd8(sp)
+;   sd t2, 0xe0(sp)
+;   sd t3, 0xe8(sp)
+;   sd t4, 0xf0(sp)
+;   sd s1, 0xf8(sp)
+;   sd a0, 0x100(sp)
+;   sd a1, 0x108(sp)
 ;   auipc t0, 0
 ;   ld t0, 0xc(t0)
 ;   j 0xc
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %tail_callee_stack_args 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   ld a0, 0x30(sp)
-;   ld s1, 0x38(sp)
-;   ld ra, 8(s0)
-;   ld t6, 0(s0)
-;   ld t5, 0x28(sp)
-;   sd t5, 8(s0)
-;   ld t5, 0x20(sp)
-;   sd t5, 0(s0)
-;   ld t5, 0x18(sp)
-;   sd t5, -8(s0)
-;   ld t5, 0x10(sp)
-;   sd t5, -0x10(s0)
-;   ld t5, 8(sp)
-;   sd t5, -0x18(s0)
-;   ld t5, 0(sp)
-;   sd t5, -0x20(s0)
-;   addi sp, s0, -0x20
-;   mv s0, t6
+;   ld a0, 8(sp)
+;   ld a1, 0(sp)
+;   ld s1, 0x68(sp)
+;   ld s2, 0x60(sp)
+;   ld s3, 0x58(sp)
+;   ld s4, 0x50(sp)
+;   ld s5, 0x48(sp)
+;   ld s6, 0x40(sp)
+;   ld s7, 0x38(sp)
+;   ld s8, 0x30(sp)
+;   ld s9, 0x28(sp)
+;   ld s10, 0x20(sp)
+;   ld s11, 0x18(sp)
+;   ld ra, 0x78(sp)
+;   ld s0, 0x70(sp)
+;   addi sp, sp, 0x80
 ;   jr t0
 
 ;;;; Test diff blocks with diff return calls with diff # of stack args ;;;;;;;;;
@@ -403,20 +437,16 @@ block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64, v6: i64, v7: i64, v
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   ld a4,16(fp)
-;   ld a0,24(fp)
-;   ld a2,32(fp)
-;   ld a4,40(fp)
-;   ld s1,48(fp)
+;   ld a0,-8(incoming_arg)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
-;   add sp,+48
+;   addi sp,sp,16
+;   addi sp,sp,144
 ;   ret
 ;
 ; Disassembled:
@@ -426,15 +456,11 @@ block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64, v6: i64, v7: i64, v
 ;   sd s0, 0(sp)
 ;   mv s0, sp
 ; block1: ; offset 0x10
-;   ld a4, 0x10(s0)
-;   ld a0, 0x18(s0)
-;   ld a2, 0x20(s0)
-;   ld a4, 0x28(s0)
-;   ld s1, 0x30(s0)
+;   ld a0, 0x98(sp)
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
-;   addi sp, sp, 0x30
+;   addi sp, sp, 0x90
 ;   ret
 
 function %different_callee2(i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64) -> i64 tail {
@@ -443,21 +469,16 @@ block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64, v6: i64, v7: i64, v
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   ld a4,16(fp)
-;   ld a0,24(fp)
-;   ld a2,32(fp)
-;   ld a4,40(fp)
-;   ld a0,48(fp)
-;   ld s1,56(fp)
+;   ld a0,-16(incoming_arg)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
-;   add sp,+48
+;   addi sp,sp,16
+;   addi sp,sp,160
 ;   ret
 ;
 ; Disassembled:
@@ -467,16 +488,11 @@ block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64, v6: i64, v7: i64, v
 ;   sd s0, 0(sp)
 ;   mv s0, sp
 ; block1: ; offset 0x10
-;   ld a4, 0x10(s0)
-;   ld a0, 0x18(s0)
-;   ld a2, 0x20(s0)
-;   ld a4, 0x28(s0)
-;   ld a0, 0x30(s0)
-;   ld s1, 0x38(s0)
+;   ld a0, 0xa0(sp)
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
-;   addi sp, sp, 0x30
+;   addi sp, sp, 0xa0
 ;   ret
 
 function %caller_of_different_callees(i64) -> i64 tail {
@@ -521,70 +537,108 @@ block2:
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+;   addi sp,sp,-160
 ;   sd ra,8(sp)
+;   ld fp,160(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   add sp,-32
+;   addi sp,sp,-128
+;   sd s1,120(sp)
+;   sd s2,112(sp)
+;   sd s3,104(sp)
+;   sd s4,96(sp)
+;   sd s5,88(sp)
+;   sd s6,80(sp)
+;   sd s7,72(sp)
+;   sd s8,64(sp)
+;   sd s9,56(sp)
+;   sd s10,48(sp)
+;   sd s11,40(sp)
 ; block0:
-;   li a0,10
-;   sd a0,16(nominal_sp)
-;   li a0,15
-;   sd a0,8(nominal_sp)
-;   li a1,20
-;   sd a1,0(nominal_sp)
-;   li a2,25
-;   li a3,30
-;   li a4,35
-;   li a5,40
-;   li a6,45
-;   li a7,50
-;   li s2,55
-;   li s3,60
-;   li s4,65
-;   li s5,70
-;   li s6,75
-;   li s7,80
-;   li s8,85
-;   li s9,90
-;   li s10,95
-;   li s11,100
-;   li t3,105
-;   li t4,110
-;   li a1,115
-;   li a0,120
-;   li t2,125
-;   li t1,130
-;   li t0,135
-;   bne s1,zero,taken(label2),not_taken(label1)
+;   li a1,10
+;   sd a1,16(slot)
+;   li a2,15
+;   sd a2,8(slot)
+;   li a3,20
+;   sd a3,0(slot)
+;   li a3,25
+;   li a4,30
+;   li a5,35
+;   li a6,40
+;   li a7,45
+;   li a2,50
+;   li a1,55
+;   li s1,60
+;   li s5,65
+;   li s4,70
+;   li s3,75
+;   li s2,80
+;   li t4,85
+;   li t3,90
+;   li t2,95
+;   li t1,100
+;   li t0,105
+;   li s11,110
+;   li s10,115
+;   li s9,120
+;   li s8,125
+;   li s7,130
+;   li s6,135
+;   bne a0,zero,taken(label2),not_taken(label1)
 ; block1:
-;   li s1,140
-;   add sp,-48
-;   virtual_sp_offset_adj +48
-;   sd a1,0(sp)
-;   sd a0,8(sp)
-;   sd t2,16(sp)
-;   sd t1,24(sp)
-;   sd t0,32(sp)
-;   sd s1,40(sp)
+;   li a0,140
+;   sd a2,-160(incoming_arg)
+;   sd a1,-152(incoming_arg)
+;   sd s1,-144(incoming_arg)
+;   sd s5,-136(incoming_arg)
+;   sd s4,-128(incoming_arg)
+;   sd s3,-120(incoming_arg)
+;   sd s2,-112(incoming_arg)
+;   sd t4,-104(incoming_arg)
+;   sd t3,-96(incoming_arg)
+;   sd t2,-88(incoming_arg)
+;   sd t1,-80(incoming_arg)
+;   sd t0,-72(incoming_arg)
+;   sd s11,-64(incoming_arg)
+;   sd s10,-56(incoming_arg)
+;   sd s9,-48(incoming_arg)
+;   sd s8,-40(incoming_arg)
+;   sd s7,-32(incoming_arg)
+;   sd s6,-24(incoming_arg)
+;   sd a0,-16(incoming_arg)
 ;   load_sym t0,%different_callee2+0
-;   ld a1,0(nominal_sp)
-;   ld a0,8(nominal_sp)
-;   ld s1,16(nominal_sp)
-;   return_call_ind t0 old_stack_arg_size:0 new_stack_arg_size:48 s1=s1 a0=a0 a1=a1 a2=a2 a3=a3 a4=a4 a5=a5 a6=a6 a7=a7 s2=s2 s3=s3 s4=s4 s5=s5 s6=s6 s7=s7 s8=s8 s9=s9 s10=s10 s11=s11 t3=t3 t4=t4
+;   ld a0,16(slot)
+;   ld a1,8(slot)
+;   ld a2,0(slot)
+;   return_call_ind t0 new_stack_arg_size:160 a0=a0 a1=a1 a2=a2 a3=a3 a4=a4 a5=a5 a6=a6 a7=a7
 ; block2:
-;   ld s1,16(nominal_sp)
-;   add sp,-48
-;   virtual_sp_offset_adj +48
-;   sd a1,0(sp)
-;   sd a0,8(sp)
-;   sd t2,16(sp)
-;   sd t1,24(sp)
-;   sd t0,32(sp)
+;   ld a0,16(slot)
+;   sd a2,-144(incoming_arg)
+;   sd a1,-136(incoming_arg)
+;   sd s1,-128(incoming_arg)
+;   sd s5,-120(incoming_arg)
+;   sd s4,-112(incoming_arg)
+;   sd s3,-104(incoming_arg)
+;   sd s2,-96(incoming_arg)
+;   sd t4,-88(incoming_arg)
+;   sd t3,-80(incoming_arg)
+;   sd t2,-72(incoming_arg)
+;   sd t1,-64(incoming_arg)
+;   sd t0,-56(incoming_arg)
+;   sd s11,-48(incoming_arg)
+;   sd s10,-40(incoming_arg)
+;   sd s9,-32(incoming_arg)
+;   sd s8,-24(incoming_arg)
+;   sd s7,-16(incoming_arg)
+;   sd s6,-8(incoming_arg)
 ;   load_sym t0,%different_callee1+0
-;   ld a1,0(nominal_sp)
-;   ld a0,8(nominal_sp)
-;   return_call_ind t0 old_stack_arg_size:0 new_stack_arg_size:48 s1=s1 a0=a0 a1=a1 a2=a2 a3=a3 a4=a4 a5=a5 a6=a6 a7=a7 s2=s2 s3=s3 s4=s4 s5=s5 s6=s6 s7=s7 s8=s8 s9=s9 s10=s10 s11=s11 t3=t3 t4=t4
+;   ld a1,8(slot)
+;   ld a2,0(slot)
+;   return_call_ind t0 new_stack_arg_size:144 a0=a0 a1=a1 a2=a2 a3=a3 a4=a4 a5=a5 a6=a6 a7=a7
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
@@ -592,102 +646,138 @@ block2:
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   addi sp, sp, -0x20
-; block1: ; offset 0x14
-;   addi a0, zero, 0xa
-;   sd a0, 0x10(sp)
-;   addi a0, zero, 0xf
-;   sd a0, 8(sp)
-;   addi a1, zero, 0x14
-;   sd a1, 0(sp)
-;   addi a2, zero, 0x19
-;   addi a3, zero, 0x1e
-;   addi a4, zero, 0x23
-;   addi a5, zero, 0x28
-;   addi a6, zero, 0x2d
-;   addi a7, zero, 0x32
-;   addi s2, zero, 0x37
-;   addi s3, zero, 0x3c
-;   addi s4, zero, 0x41
-;   addi s5, zero, 0x46
-;   addi s6, zero, 0x4b
-;   addi s7, zero, 0x50
-;   addi s8, zero, 0x55
-;   addi s9, zero, 0x5a
-;   addi s10, zero, 0x5f
-;   addi s11, zero, 0x64
-;   addi t3, zero, 0x69
-;   addi t4, zero, 0x6e
-;   addi a1, zero, 0x73
-;   addi a0, zero, 0x78
-;   addi t2, zero, 0x7d
-;   addi t1, zero, 0x82
-;   addi t0, zero, 0x87
-;   bnez s1, 0x88
-; block2: ; offset 0x8c
-;   addi s1, zero, 0x8c
-;   addi sp, sp, -0x30
-;   sd a1, 0(sp)
-;   sd a0, 8(sp)
-;   sd t2, 0x10(sp)
-;   sd t1, 0x18(sp)
-;   sd t0, 0x20(sp)
-;   sd s1, 0x28(sp)
+;   addi sp, sp, -0xa0
+;   sd ra, 8(sp)
+;   ld s0, 0xa0(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+;   addi sp, sp, -0x80
+;   sd s1, 0x78(sp)
+;   sd s2, 0x70(sp)
+;   sd s3, 0x68(sp)
+;   sd s4, 0x60(sp)
+;   sd s5, 0x58(sp)
+;   sd s6, 0x50(sp)
+;   sd s7, 0x48(sp)
+;   sd s8, 0x40(sp)
+;   sd s9, 0x38(sp)
+;   sd s10, 0x30(sp)
+;   sd s11, 0x28(sp)
+; block1: ; offset 0x54
+;   addi a1, zero, 0xa
+;   sd a1, 0x10(sp)
+;   addi a2, zero, 0xf
+;   sd a2, 8(sp)
+;   addi a3, zero, 0x14
+;   sd a3, 0(sp)
+;   addi a3, zero, 0x19
+;   addi a4, zero, 0x1e
+;   addi a5, zero, 0x23
+;   addi a6, zero, 0x28
+;   addi a7, zero, 0x2d
+;   addi a2, zero, 0x32
+;   addi a1, zero, 0x37
+;   addi s1, zero, 0x3c
+;   addi s5, zero, 0x41
+;   addi s4, zero, 0x46
+;   addi s3, zero, 0x4b
+;   addi s2, zero, 0x50
+;   addi t4, zero, 0x55
+;   addi t3, zero, 0x5a
+;   addi t2, zero, 0x5f
+;   addi t1, zero, 0x64
+;   addi t0, zero, 0x69
+;   addi s11, zero, 0x6e
+;   addi s10, zero, 0x73
+;   addi s9, zero, 0x78
+;   addi s8, zero, 0x7d
+;   addi s7, zero, 0x82
+;   addi s6, zero, 0x87
+;   bnez a0, 0xb0
+; block2: ; offset 0xcc
+;   addi a0, zero, 0x8c
+;   sd a2, 0x90(sp)
+;   sd a1, 0x98(sp)
+;   sd s1, 0xa0(sp)
+;   sd s5, 0xa8(sp)
+;   sd s4, 0xb0(sp)
+;   sd s3, 0xb8(sp)
+;   sd s2, 0xc0(sp)
+;   sd t4, 0xc8(sp)
+;   sd t3, 0xd0(sp)
+;   sd t2, 0xd8(sp)
+;   sd t1, 0xe0(sp)
+;   sd t0, 0xe8(sp)
+;   sd s11, 0xf0(sp)
+;   sd s10, 0xf8(sp)
+;   sd s9, 0x100(sp)
+;   sd s8, 0x108(sp)
+;   sd s7, 0x110(sp)
+;   sd s6, 0x118(sp)
+;   sd a0, 0x120(sp)
 ;   auipc t0, 0
 ;   ld t0, 0xc(t0)
 ;   j 0xc
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %different_callee2 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   ld a1, 0x30(sp)
-;   ld a0, 0x38(sp)
-;   ld s1, 0x40(sp)
-;   ld ra, 8(s0)
-;   ld t6, 0(s0)
-;   ld t5, 0x28(sp)
-;   sd t5, 8(s0)
-;   ld t5, 0x20(sp)
-;   sd t5, 0(s0)
-;   ld t5, 0x18(sp)
-;   sd t5, -8(s0)
-;   ld t5, 0x10(sp)
-;   sd t5, -0x10(s0)
-;   ld t5, 8(sp)
-;   sd t5, -0x18(s0)
-;   ld t5, 0(sp)
-;   sd t5, -0x20(s0)
-;   addi sp, s0, -0x20
-;   mv s0, t6
+;   ld a0, 0x10(sp)
+;   ld a1, 8(sp)
+;   ld a2, 0(sp)
+;   ld s1, 0x78(sp)
+;   ld s2, 0x70(sp)
+;   ld s3, 0x68(sp)
+;   ld s4, 0x60(sp)
+;   ld s5, 0x58(sp)
+;   ld s6, 0x50(sp)
+;   ld s7, 0x48(sp)
+;   ld s8, 0x40(sp)
+;   ld s9, 0x38(sp)
+;   ld s10, 0x30(sp)
+;   ld s11, 0x28(sp)
+;   ld ra, 0x88(sp)
+;   ld s0, 0x80(sp)
+;   addi sp, sp, 0x90
 ;   jr t0
-; block3: ; offset 0x110
-;   ld s1, 0x10(sp)
-;   addi sp, sp, -0x30
-;   sd a1, 0(sp)
-;   sd a0, 8(sp)
-;   sd t2, 0x10(sp)
-;   sd t1, 0x18(sp)
-;   sd t0, 0x20(sp)
+; block3: ; offset 0x178
+;   ld a0, 0x10(sp)
+;   sd a2, 0xa0(sp)
+;   sd a1, 0xa8(sp)
+;   sd s1, 0xb0(sp)
+;   sd s5, 0xb8(sp)
+;   sd s4, 0xc0(sp)
+;   sd s3, 0xc8(sp)
+;   sd s2, 0xd0(sp)
+;   sd t4, 0xd8(sp)
+;   sd t3, 0xe0(sp)
+;   sd t2, 0xe8(sp)
+;   sd t1, 0xf0(sp)
+;   sd t0, 0xf8(sp)
+;   sd s11, 0x100(sp)
+;   sd s10, 0x108(sp)
+;   sd s9, 0x110(sp)
+;   sd s8, 0x118(sp)
+;   sd s7, 0x120(sp)
+;   sd s6, 0x128(sp)
 ;   auipc t0, 0
 ;   ld t0, 0xc(t0)
 ;   j 0xc
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %different_callee1 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   ld a1, 0x30(sp)
-;   ld a0, 0x38(sp)
-;   ld ra, 8(s0)
-;   ld t6, 0(s0)
-;   ld t5, 0x28(sp)
-;   sd t5, 8(s0)
-;   ld t5, 0x20(sp)
-;   sd t5, 0(s0)
-;   ld t5, 0x18(sp)
-;   sd t5, -8(s0)
-;   ld t5, 0x10(sp)
-;   sd t5, -0x10(s0)
-;   ld t5, 8(sp)
-;   sd t5, -0x18(s0)
-;   ld t5, 0(sp)
-;   sd t5, -0x20(s0)
-;   addi sp, s0, -0x20
-;   mv s0, t6
+;   ld a1, 8(sp)
+;   ld a2, 0(sp)
+;   ld s1, 0x78(sp)
+;   ld s2, 0x70(sp)
+;   ld s3, 0x68(sp)
+;   ld s4, 0x60(sp)
+;   ld s5, 0x58(sp)
+;   ld s6, 0x50(sp)
+;   ld s7, 0x48(sp)
+;   ld s8, 0x40(sp)
+;   ld s9, 0x38(sp)
+;   ld s10, 0x30(sp)
+;   ld s11, 0x28(sp)
+;   ld ra, 0x88(sp)
+;   ld s0, 0x80(sp)
+;   addi sp, sp, 0xa0
 ;   jr t0
 
diff --git a/cranelift/filetests/filetests/isa/riscv64/rotl.clif b/cranelift/filetests/filetests/isa/riscv64/rotl.clif
index b67632cbec15..baa526eae016 100644
--- a/cranelift/filetests/filetests/isa/riscv64/rotl.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/rotl.clif
@@ -9,13 +9,14 @@ block0(v0: i128, v1: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   sd s7,-8(sp)
-;   sd s9,-16(sp)
-;   add sp,-16
+;   addi sp,sp,-32
+;   sd s1,24(sp)
+;   sd s7,16(sp)
+;   sd s9,8(sp)
 ; block0:
 ;   andi a5,a2,63
 ;   li a3,64
@@ -26,17 +27,18 @@ block0(v0: i128, v1: i128):
 ;   or a3,a3,s9
 ;   sll a1,a1,a5
 ;   srl a4,a0,a4
-;   select a5,zero,a4##condition=(a5 eq zero)
-;   or a5,a1,a5
+;   select a0,zero,a4##condition=(a5 eq zero)
+;   or s1,a1,a0
 ;   li a4,64
-;   andi a2,a2,127
-;   select [a0,a1],[a5,a3],[a3,a5]##condition=(a2 uge a4)
-;   add sp,+16
-;   ld s7,-8(sp)
-;   ld s9,-16(sp)
+;   andi a5,a2,127
+;   select [a0,a1],[s1,a3],[a3,s1]##condition=(a5 uge a4)
+;   ld s1,24(sp)
+;   ld s7,16(sp)
+;   ld s9,8(sp)
+;   addi sp,sp,32
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -45,38 +47,37 @@ block0(v0: i128, v1: i128):
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   sd s7, -8(sp)
-;   sd s9, -0x10(sp)
-;   addi sp, sp, -0x10
-; block1: ; offset 0x1c
+;   addi sp, sp, -0x20
+;   sd s1, 0x18(sp)
+;   sd s7, 0x10(sp)
+;   sd s9, 8(sp)
+; block1: ; offset 0x20
 ;   andi a5, a2, 0x3f
 ;   addi a3, zero, 0x40
 ;   sub a4, a3, a5
 ;   sll a3, a0, a5
 ;   srl s7, a1, a4
-;   bnez a5, 0xc
 ;   mv s9, zero
-;   j 8
+;   beqz a5, 8
 ;   mv s9, s7
 ;   or a3, a3, s9
 ;   sll a1, a1, a5
 ;   srl a4, a0, a4
-;   bnez a5, 0xc
-;   mv a5, zero
-;   j 8
-;   mv a5, a4
-;   or a5, a1, a5
+;   mv a0, zero
+;   beqz a5, 8
+;   mv a0, a4
+;   or s1, a1, a0
 ;   addi a4, zero, 0x40
-;   andi a2, a2, 0x7f
-;   bltu a2, a4, 0x10
-;   mv a0, a5
+;   andi a5, a2, 0x7f
+;   mv a0, s1
 ;   mv a1, a3
-;   j 0xc
+;   bgeu a5, a4, 0xc
 ;   mv a0, a3
-;   mv a1, a5
-;   addi sp, sp, 0x10
-;   ld s7, -8(sp)
-;   ld s9, -0x10(sp)
+;   mv a1, s1
+;   ld s1, 0x18(sp)
+;   ld s7, 0x10(sp)
+;   ld s9, 8(sp)
+;   addi sp, sp, 0x20
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -106,9 +107,8 @@ block0(v0: i64, v1: i64):
 ;   sub a1, a5, a3
 ;   sll a4, a0, a3
 ;   srl a5, a0, a1
-;   bnez a3, 0xc
 ;   mv a1, zero
-;   j 8
+;   beqz a3, 8
 ;   mv a1, a5
 ;   or a0, a4, a1
 ;   ret
@@ -141,9 +141,8 @@ block0(v0: i32, v1: i32):
 ;   sub a0, a3, a1
 ;   sll a2, a5, a1
 ;   srl a3, a5, a0
-;   bnez a1, 0xc
 ;   mv a5, zero
-;   j 8
+;   beqz a1, 8
 ;   mv a5, a3
 ;   or a0, a2, a5
 ;   ret
@@ -176,9 +175,8 @@ block0(v0: i16, v1: i16):
 ;   sub a0, a3, a1
 ;   sll a2, a5, a1
 ;   srl a3, a5, a0
-;   bnez a1, 0xc
 ;   mv a5, zero
-;   j 8
+;   beqz a1, 8
 ;   mv a5, a3
 ;   or a0, a2, a5
 ;   ret
@@ -209,9 +207,8 @@ block0(v0: i8, v1: i8):
 ;   sub a4, a1, a5
 ;   sll a0, a3, a5
 ;   srl a1, a3, a4
-;   bnez a5, 0xc
 ;   mv a3, zero
-;   j 8
+;   beqz a5, 8
 ;   mv a3, a1
 ;   or a0, a0, a3
 ;   ret
@@ -243,9 +240,8 @@ block0(v0: i64):
 ;   sub a1, a5, a3
 ;   sll a4, a0, a3
 ;   srl a5, a0, a1
-;   bnez a3, 0xc
 ;   mv a1, zero
-;   j 8
+;   beqz a3, 8
 ;   mv a1, a5
 ;   or a0, a4, a1
 ;   ret
@@ -281,9 +277,8 @@ block0(v0: i32):
 ;   sub a0, a3, a1
 ;   sll a2, a5, a1
 ;   srl a3, a5, a0
-;   bnez a1, 0xc
 ;   mv a5, zero
-;   j 8
+;   beqz a1, 8
 ;   mv a5, a3
 ;   or a0, a2, a5
 ;   ret
@@ -319,9 +314,8 @@ block0(v0: i16):
 ;   sub a0, a3, a1
 ;   sll a2, a5, a1
 ;   srl a3, a5, a0
-;   bnez a1, 0xc
 ;   mv a5, zero
-;   j 8
+;   beqz a1, 8
 ;   mv a5, a3
 ;   or a0, a2, a5
 ;   ret
@@ -355,9 +349,8 @@ block0(v0: i8):
 ;   sub a4, a1, a5
 ;   sll a0, a3, a5
 ;   srl a1, a3, a4
-;   bnez a5, 0xc
 ;   mv a3, zero
-;   j 8
+;   beqz a5, 8
 ;   mv a3, a1
 ;   or a0, a0, a3
 ;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/rotr.clif b/cranelift/filetests/filetests/isa/riscv64/rotr.clif
index 196206a92f80..3528c4e07b29 100644
--- a/cranelift/filetests/filetests/isa/riscv64/rotr.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/rotr.clif
@@ -9,13 +9,14 @@ block0(v0: i128, v1: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   sd s7,-8(sp)
-;   sd s9,-16(sp)
-;   add sp,-16
+;   addi sp,sp,-32
+;   sd s1,24(sp)
+;   sd s7,16(sp)
+;   sd s9,8(sp)
 ; block0:
 ;   andi a5,a2,63
 ;   li a3,64
@@ -26,17 +27,18 @@ block0(v0: i128, v1: i128):
 ;   or a3,a3,s9
 ;   srl a1,a1,a5
 ;   sll a4,a0,a4
-;   select a5,zero,a4##condition=(a5 eq zero)
-;   or a5,a1,a5
+;   select a0,zero,a4##condition=(a5 eq zero)
+;   or s1,a1,a0
 ;   li a4,64
-;   andi a2,a2,127
-;   select [a0,a1],[a5,a3],[a3,a5]##condition=(a2 uge a4)
-;   add sp,+16
-;   ld s7,-8(sp)
-;   ld s9,-16(sp)
+;   andi a5,a2,127
+;   select [a0,a1],[s1,a3],[a3,s1]##condition=(a5 uge a4)
+;   ld s1,24(sp)
+;   ld s7,16(sp)
+;   ld s9,8(sp)
+;   addi sp,sp,32
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -45,38 +47,37 @@ block0(v0: i128, v1: i128):
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   sd s7, -8(sp)
-;   sd s9, -0x10(sp)
-;   addi sp, sp, -0x10
-; block1: ; offset 0x1c
+;   addi sp, sp, -0x20
+;   sd s1, 0x18(sp)
+;   sd s7, 0x10(sp)
+;   sd s9, 8(sp)
+; block1: ; offset 0x20
 ;   andi a5, a2, 0x3f
 ;   addi a3, zero, 0x40
 ;   sub a4, a3, a5
 ;   srl a3, a0, a5
 ;   sll s7, a1, a4
-;   bnez a5, 0xc
 ;   mv s9, zero
-;   j 8
+;   beqz a5, 8
 ;   mv s9, s7
 ;   or a3, a3, s9
 ;   srl a1, a1, a5
 ;   sll a4, a0, a4
-;   bnez a5, 0xc
-;   mv a5, zero
-;   j 8
-;   mv a5, a4
-;   or a5, a1, a5
+;   mv a0, zero
+;   beqz a5, 8
+;   mv a0, a4
+;   or s1, a1, a0
 ;   addi a4, zero, 0x40
-;   andi a2, a2, 0x7f
-;   bltu a2, a4, 0x10
-;   mv a0, a5
+;   andi a5, a2, 0x7f
+;   mv a0, s1
 ;   mv a1, a3
-;   j 0xc
+;   bgeu a5, a4, 0xc
 ;   mv a0, a3
-;   mv a1, a5
-;   addi sp, sp, 0x10
-;   ld s7, -8(sp)
-;   ld s9, -0x10(sp)
+;   mv a1, s1
+;   ld s1, 0x18(sp)
+;   ld s7, 0x10(sp)
+;   ld s9, 8(sp)
+;   addi sp, sp, 0x20
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -106,9 +107,8 @@ block0(v0: i64, v1: i64):
 ;   sub a1, a5, a3
 ;   srl a4, a0, a3
 ;   sll a5, a0, a1
-;   bnez a3, 0xc
 ;   mv a1, zero
-;   j 8
+;   beqz a3, 8
 ;   mv a1, a5
 ;   or a0, a4, a1
 ;   ret
@@ -141,9 +141,8 @@ block0(v0: i32, v1: i32):
 ;   sub a0, a3, a1
 ;   srl a2, a5, a1
 ;   sll a3, a5, a0
-;   bnez a1, 0xc
 ;   mv a5, zero
-;   j 8
+;   beqz a1, 8
 ;   mv a5, a3
 ;   or a0, a2, a5
 ;   ret
@@ -176,9 +175,8 @@ block0(v0: i16, v1: i16):
 ;   sub a0, a3, a1
 ;   srl a2, a5, a1
 ;   sll a3, a5, a0
-;   bnez a1, 0xc
 ;   mv a5, zero
-;   j 8
+;   beqz a1, 8
 ;   mv a5, a3
 ;   or a0, a2, a5
 ;   ret
@@ -209,9 +207,8 @@ block0(v0: i8, v1: i8):
 ;   sub a4, a1, a5
 ;   srl a0, a3, a5
 ;   sll a1, a3, a4
-;   bnez a5, 0xc
 ;   mv a3, zero
-;   j 8
+;   beqz a5, 8
 ;   mv a3, a1
 ;   or a0, a0, a3
 ;   ret
@@ -243,9 +240,8 @@ block0(v0: i64):
 ;   sub a1, a5, a3
 ;   srl a4, a0, a3
 ;   sll a5, a0, a1
-;   bnez a3, 0xc
 ;   mv a1, zero
-;   j 8
+;   beqz a3, 8
 ;   mv a1, a5
 ;   or a0, a4, a1
 ;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/select-float.clif b/cranelift/filetests/filetests/isa/riscv64/select-float.clif
index 3e1b7ffceff1..684fd934fc46 100644
--- a/cranelift/filetests/filetests/isa/riscv64/select-float.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/select-float.clif
@@ -65,9 +65,9 @@ block0(v0: i16, v1: f32, v2: f32):
 ; block0:
 ;   li a3,42
 ;   slli a5,a0,48
-;   srli a1,a5,48
+;   srai a1,a5,48
 ;   slli a3,a3,48
-;   srli a5,a3,48
+;   srai a5,a3,48
 ;   select fa0,fa0,fa1##condition=(a1 eq a5)
 ;   ret
 ;
@@ -75,9 +75,9 @@ block0(v0: i16, v1: f32, v2: f32):
 ; block0: ; offset 0x0
 ;   addi a3, zero, 0x2a
 ;   slli a5, a0, 0x30
-;   srli a1, a5, 0x30
+;   srai a1, a5, 0x30
 ;   slli a3, a3, 0x30
-;   srli a5, a3, 0x30
+;   srai a5, a3, 0x30
 ;   beq a1, a5, 8
 ;   fmv.d fa0, fa1
 ;   ret
@@ -94,9 +94,9 @@ block0(v0: i16, v1: f64, v2: f64):
 ; block0:
 ;   li a3,42
 ;   slli a5,a0,48
-;   srli a1,a5,48
+;   srai a1,a5,48
 ;   slli a3,a3,48
-;   srli a5,a3,48
+;   srai a5,a3,48
 ;   select fa0,fa0,fa1##condition=(a1 eq a5)
 ;   ret
 ;
@@ -104,9 +104,9 @@ block0(v0: i16, v1: f64, v2: f64):
 ; block0: ; offset 0x0
 ;   addi a3, zero, 0x2a
 ;   slli a5, a0, 0x30
-;   srli a1, a5, 0x30
+;   srai a1, a5, 0x30
 ;   slli a3, a3, 0x30
-;   srli a5, a3, 0x30
+;   srai a5, a3, 0x30
 ;   beq a1, a5, 8
 ;   fmv.d fa0, fa1
 ;   ret
@@ -214,21 +214,23 @@ block0(v0: i128, v1: f32, v2: f32):
 
 ; VCode:
 ; block0:
-;   li a2,42
-;   li a3,0
-;   eq a2,[a0,a1],[a2,a3]##ty=i128
+;   li a5,42
+;   li a2,0
+;   xor a3,a0,a5
+;   xor a4,a1,a2
+;   or a0,a3,a4
+;   seqz a2,a0
 ;   select fa0,fa0,fa1##condition=(a2 ne zero)
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a2, zero, 0x2a
-;   mv a3, zero
-;   bne a1, a3, 0x10
-;   bne a0, a2, 0xc
-;   addi a2, zero, 1
-;   j 8
+;   addi a5, zero, 0x2a
 ;   mv a2, zero
+;   xor a3, a0, a5
+;   xor a4, a1, a2
+;   or a0, a3, a4
+;   seqz a2, a0
 ;   bnez a2, 8
 ;   fmv.d fa0, fa1
 ;   ret
@@ -244,21 +246,23 @@ block0(v0: i128, v1: f64, v2: f64):
 
 ; VCode:
 ; block0:
-;   li a2,42
-;   li a3,0
-;   eq a2,[a0,a1],[a2,a3]##ty=i128
+;   li a5,42
+;   li a2,0
+;   xor a3,a0,a5
+;   xor a4,a1,a2
+;   or a0,a3,a4
+;   seqz a2,a0
 ;   select fa0,fa0,fa1##condition=(a2 ne zero)
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a2, zero, 0x2a
-;   mv a3, zero
-;   bne a1, a3, 0x10
-;   bne a0, a2, 0xc
-;   addi a2, zero, 1
-;   j 8
+;   addi a5, zero, 0x2a
 ;   mv a2, zero
+;   xor a3, a0, a5
+;   xor a4, a1, a2
+;   or a0, a3, a4
+;   seqz a2, a0
 ;   bnez a2, 8
 ;   fmv.d fa0, fa1
 ;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/select.clif b/cranelift/filetests/filetests/isa/riscv64/select.clif
index 57b9ec24c866..3b27d8eb704e 100644
--- a/cranelift/filetests/filetests/isa/riscv64/select.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/select.clif
@@ -23,9 +23,8 @@ block0(v0: i8, v1: i8, v2: i8):
 ;   addi a3, zero, 0x2a
 ;   andi a5, a0, 0xff
 ;   andi a3, a3, 0xff
-;   bne a5, a3, 0xc
 ;   mv a0, a1
-;   j 8
+;   beq a5, a3, 8
 ;   mv a0, a2
 ;   ret
 
@@ -50,9 +49,8 @@ block0(v0: i8, v1: i16, v2: i16):
 ;   addi a3, zero, 0x2a
 ;   andi a5, a0, 0xff
 ;   andi a3, a3, 0xff
-;   bne a5, a3, 0xc
 ;   mv a0, a1
-;   j 8
+;   beq a5, a3, 8
 ;   mv a0, a2
 ;   ret
 
@@ -77,9 +75,8 @@ block0(v0: i8, v1: i32, v2: i32):
 ;   addi a3, zero, 0x2a
 ;   andi a5, a0, 0xff
 ;   andi a3, a3, 0xff
-;   bne a5, a3, 0xc
 ;   mv a0, a1
-;   j 8
+;   beq a5, a3, 8
 ;   mv a0, a2
 ;   ret
 
@@ -104,9 +101,8 @@ block0(v0: i8, v1: i64, v2: i64):
 ;   addi a3, zero, 0x2a
 ;   andi a5, a0, 0xff
 ;   andi a3, a3, 0xff
-;   bne a5, a3, 0xc
 ;   mv a0, a1
-;   j 8
+;   beq a5, a3, 8
 ;   mv a0, a2
 ;   ret
 
@@ -119,25 +115,26 @@ block0(v0: i8, v1: i128, v2: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   sd s1,-8(sp)
-;   sd s8,-16(sp)
-;   add sp,-16
+;   addi sp,sp,-16
+;   sd s3,8(sp)
+;   sd s10,0(sp)
 ; block0:
-;   mv s8,a1
-;   li a5,42
-;   andi s1,a0,255
-;   andi a5,a5,255
-;   select [a0,a1],[s8,a2],[a3,a4]##condition=(s1 eq a5)
-;   add sp,+16
-;   ld s1,-8(sp)
-;   ld s8,-16(sp)
+;   mv s10,a1
+;   mv a1,a0
+;   li a0,42
+;   andi a5,a1,255
+;   andi s3,a0,255
+;   select [a0,a1],[s10,a2],[a3,a4]##condition=(a5 eq s3)
+;   ld s3,8(sp)
+;   ld s10,0(sp)
+;   addi sp,sp,16
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -146,23 +143,23 @@ block0(v0: i8, v1: i128, v2: i128):
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   sd s1, -8(sp)
-;   sd s8, -0x10(sp)
 ;   addi sp, sp, -0x10
+;   sd s3, 8(sp)
+;   sd s10, 0(sp)
 ; block1: ; offset 0x1c
-;   mv s8, a1
-;   addi a5, zero, 0x2a
-;   andi s1, a0, 0xff
-;   andi a5, a5, 0xff
-;   bne s1, a5, 0x10
-;   mv a0, s8
+;   mv s10, a1
+;   mv a1, a0
+;   addi a0, zero, 0x2a
+;   andi a5, a1, 0xff
+;   andi s3, a0, 0xff
+;   mv a0, s10
 ;   mv a1, a2
-;   j 0xc
+;   beq a5, s3, 0xc
 ;   mv a0, a3
 ;   mv a1, a4
+;   ld s3, 8(sp)
+;   ld s10, 0(sp)
 ;   addi sp, sp, 0x10
-;   ld s1, -8(sp)
-;   ld s8, -0x10(sp)
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -178,24 +175,23 @@ block0(v0: i16, v1: i8, v2: i8):
 
 ; VCode:
 ; block0:
-;   li a3,42
+;   li a4,42
 ;   slli a5,a0,48
-;   srli a4,a5,48
-;   slli a3,a3,48
-;   srli a5,a3,48
-;   select a0,a1,a2##condition=(a4 eq a5)
+;   srai a3,a5,48
+;   slli a4,a4,48
+;   srai a5,a4,48
+;   select a0,a1,a2##condition=(a3 eq a5)
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a3, zero, 0x2a
+;   addi a4, zero, 0x2a
 ;   slli a5, a0, 0x30
-;   srli a4, a5, 0x30
-;   slli a3, a3, 0x30
-;   srli a5, a3, 0x30
-;   bne a4, a5, 0xc
+;   srai a3, a5, 0x30
+;   slli a4, a4, 0x30
+;   srai a5, a4, 0x30
 ;   mv a0, a1
-;   j 8
+;   beq a3, a5, 8
 ;   mv a0, a2
 ;   ret
 
@@ -209,24 +205,23 @@ block0(v0: i16, v1: i16, v2: i16):
 
 ; VCode:
 ; block0:
-;   li a3,42
+;   li a4,42
 ;   slli a5,a0,48
-;   srli a4,a5,48
-;   slli a3,a3,48
-;   srli a5,a3,48
-;   select a0,a1,a2##condition=(a4 eq a5)
+;   srai a3,a5,48
+;   slli a4,a4,48
+;   srai a5,a4,48
+;   select a0,a1,a2##condition=(a3 eq a5)
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a3, zero, 0x2a
+;   addi a4, zero, 0x2a
 ;   slli a5, a0, 0x30
-;   srli a4, a5, 0x30
-;   slli a3, a3, 0x30
-;   srli a5, a3, 0x30
-;   bne a4, a5, 0xc
+;   srai a3, a5, 0x30
+;   slli a4, a4, 0x30
+;   srai a5, a4, 0x30
 ;   mv a0, a1
-;   j 8
+;   beq a3, a5, 8
 ;   mv a0, a2
 ;   ret
 
@@ -240,24 +235,23 @@ block0(v0: i16, v1: i32, v2: i32):
 
 ; VCode:
 ; block0:
-;   li a3,42
+;   li a4,42
 ;   slli a5,a0,48
-;   srli a4,a5,48
-;   slli a3,a3,48
-;   srli a5,a3,48
-;   select a0,a1,a2##condition=(a4 eq a5)
+;   srai a3,a5,48
+;   slli a4,a4,48
+;   srai a5,a4,48
+;   select a0,a1,a2##condition=(a3 eq a5)
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a3, zero, 0x2a
+;   addi a4, zero, 0x2a
 ;   slli a5, a0, 0x30
-;   srli a4, a5, 0x30
-;   slli a3, a3, 0x30
-;   srli a5, a3, 0x30
-;   bne a4, a5, 0xc
+;   srai a3, a5, 0x30
+;   slli a4, a4, 0x30
+;   srai a5, a4, 0x30
 ;   mv a0, a1
-;   j 8
+;   beq a3, a5, 8
 ;   mv a0, a2
 ;   ret
 
@@ -271,24 +265,23 @@ block0(v0: i16, v1: i64, v2: i64):
 
 ; VCode:
 ; block0:
-;   li a3,42
+;   li a4,42
 ;   slli a5,a0,48
-;   srli a4,a5,48
-;   slli a3,a3,48
-;   srli a5,a3,48
-;   select a0,a1,a2##condition=(a4 eq a5)
+;   srai a3,a5,48
+;   slli a4,a4,48
+;   srai a5,a4,48
+;   select a0,a1,a2##condition=(a3 eq a5)
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a3, zero, 0x2a
+;   addi a4, zero, 0x2a
 ;   slli a5, a0, 0x30
-;   srli a4, a5, 0x30
-;   slli a3, a3, 0x30
-;   srli a5, a3, 0x30
-;   bne a4, a5, 0xc
+;   srai a3, a5, 0x30
+;   slli a4, a4, 0x30
+;   srai a5, a4, 0x30
 ;   mv a0, a1
-;   j 8
+;   beq a3, a5, 8
 ;   mv a0, a2
 ;   ret
 
@@ -301,27 +294,27 @@ block0(v0: i16, v1: i128, v2: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   sd s6,-8(sp)
-;   sd s7,-16(sp)
-;   add sp,-16
+;   addi sp,sp,-16
+;   sd s6,8(sp)
+;   sd s7,0(sp)
 ; block0:
 ;   mv t0,a1
 ;   li s6,42
 ;   slli a1,a0,48
-;   srli a5,a1,48
+;   srai a5,a1,48
 ;   slli a0,s6,48
-;   srli s7,a0,48
+;   srai s7,a0,48
 ;   select [a0,a1],[t0,a2],[a3,a4]##condition=(a5 eq s7)
-;   add sp,+16
-;   ld s6,-8(sp)
-;   ld s7,-16(sp)
+;   ld s6,8(sp)
+;   ld s7,0(sp)
+;   addi sp,sp,16
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -330,25 +323,24 @@ block0(v0: i16, v1: i128, v2: i128):
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   sd s6, -8(sp)
-;   sd s7, -0x10(sp)
 ;   addi sp, sp, -0x10
+;   sd s6, 8(sp)
+;   sd s7, 0(sp)
 ; block1: ; offset 0x1c
 ;   mv t0, a1
 ;   addi s6, zero, 0x2a
 ;   slli a1, a0, 0x30
-;   srli a5, a1, 0x30
+;   srai a5, a1, 0x30
 ;   slli a0, s6, 0x30
-;   srli s7, a0, 0x30
-;   bne a5, s7, 0x10
+;   srai s7, a0, 0x30
 ;   mv a0, t0
 ;   mv a1, a2
-;   j 0xc
+;   beq a5, s7, 0xc
 ;   mv a0, a3
 ;   mv a1, a4
+;   ld s6, 8(sp)
+;   ld s7, 0(sp)
 ;   addi sp, sp, 0x10
-;   ld s6, -8(sp)
-;   ld s7, -0x10(sp)
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -375,9 +367,8 @@ block0(v0: i32, v1: i8, v2: i8):
 ;   addi a3, zero, 0x2a
 ;   sext.w a5, a0
 ;   sext.w a3, a3
-;   bne a5, a3, 0xc
 ;   mv a0, a1
-;   j 8
+;   beq a5, a3, 8
 ;   mv a0, a2
 ;   ret
 
@@ -402,9 +393,8 @@ block0(v0: i32, v1: i16, v2: i16):
 ;   addi a3, zero, 0x2a
 ;   sext.w a5, a0
 ;   sext.w a3, a3
-;   bne a5, a3, 0xc
 ;   mv a0, a1
-;   j 8
+;   beq a5, a3, 8
 ;   mv a0, a2
 ;   ret
 
@@ -429,9 +419,8 @@ block0(v0: i32, v1: i32, v2: i32):
 ;   addi a3, zero, 0x2a
 ;   sext.w a5, a0
 ;   sext.w a3, a3
-;   bne a5, a3, 0xc
 ;   mv a0, a1
-;   j 8
+;   beq a5, a3, 8
 ;   mv a0, a2
 ;   ret
 
@@ -456,9 +445,8 @@ block0(v0: i32, v1: i64, v2: i64):
 ;   addi a3, zero, 0x2a
 ;   sext.w a5, a0
 ;   sext.w a3, a3
-;   bne a5, a3, 0xc
 ;   mv a0, a1
-;   j 8
+;   beq a5, a3, 8
 ;   mv a0, a2
 ;   ret
 
@@ -471,25 +459,26 @@ block0(v0: i32, v1: i128, v2: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   sd s1,-8(sp)
-;   sd s8,-16(sp)
-;   add sp,-16
+;   addi sp,sp,-16
+;   sd s3,8(sp)
+;   sd s10,0(sp)
 ; block0:
-;   mv s8,a1
-;   li a5,42
-;   sext.w s1,a0
-;   sext.w a5,a5
-;   select [a0,a1],[s8,a2],[a3,a4]##condition=(s1 eq a5)
-;   add sp,+16
-;   ld s1,-8(sp)
-;   ld s8,-16(sp)
+;   mv s10,a1
+;   mv a1,a0
+;   li a0,42
+;   sext.w a5,a1
+;   sext.w s3,a0
+;   select [a0,a1],[s10,a2],[a3,a4]##condition=(a5 eq s3)
+;   ld s3,8(sp)
+;   ld s10,0(sp)
+;   addi sp,sp,16
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -498,23 +487,23 @@ block0(v0: i32, v1: i128, v2: i128):
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   sd s1, -8(sp)
-;   sd s8, -0x10(sp)
 ;   addi sp, sp, -0x10
+;   sd s3, 8(sp)
+;   sd s10, 0(sp)
 ; block1: ; offset 0x1c
-;   mv s8, a1
-;   addi a5, zero, 0x2a
-;   sext.w s1, a0
-;   sext.w a5, a5
-;   bne s1, a5, 0x10
-;   mv a0, s8
+;   mv s10, a1
+;   mv a1, a0
+;   addi a0, zero, 0x2a
+;   sext.w a5, a1
+;   sext.w s3, a0
+;   mv a0, s10
 ;   mv a1, a2
-;   j 0xc
+;   beq a5, s3, 0xc
 ;   mv a0, a3
 ;   mv a1, a4
+;   ld s3, 8(sp)
+;   ld s10, 0(sp)
 ;   addi sp, sp, 0x10
-;   ld s1, -8(sp)
-;   ld s8, -0x10(sp)
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -531,15 +520,16 @@ block0(v0: i64, v1: i8, v2: i8):
 ; VCode:
 ; block0:
 ;   li a5,42
-;   select a0,a1,a2##condition=(a0 eq a5)
+;   mv a3,a0
+;   select a0,a1,a2##condition=(a3 eq a5)
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   addi a5, zero, 0x2a
-;   bne a0, a5, 0xc
+;   mv a3, a0
 ;   mv a0, a1
-;   j 8
+;   beq a3, a5, 8
 ;   mv a0, a2
 ;   ret
 
@@ -554,15 +544,16 @@ block0(v0: i64, v1: i16, v2: i16):
 ; VCode:
 ; block0:
 ;   li a5,42
-;   select a0,a1,a2##condition=(a0 eq a5)
+;   mv a3,a0
+;   select a0,a1,a2##condition=(a3 eq a5)
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   addi a5, zero, 0x2a
-;   bne a0, a5, 0xc
+;   mv a3, a0
 ;   mv a0, a1
-;   j 8
+;   beq a3, a5, 8
 ;   mv a0, a2
 ;   ret
 
@@ -577,15 +568,16 @@ block0(v0: i64, v1: i32, v2: i32):
 ; VCode:
 ; block0:
 ;   li a5,42
-;   select a0,a1,a2##condition=(a0 eq a5)
+;   mv a3,a0
+;   select a0,a1,a2##condition=(a3 eq a5)
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   addi a5, zero, 0x2a
-;   bne a0, a5, 0xc
+;   mv a3, a0
 ;   mv a0, a1
-;   j 8
+;   beq a3, a5, 8
 ;   mv a0, a2
 ;   ret
 
@@ -600,15 +592,16 @@ block0(v0: i64, v1: i64, v2: i64):
 ; VCode:
 ; block0:
 ;   li a5,42
-;   select a0,a1,a2##condition=(a0 eq a5)
+;   mv a3,a0
+;   select a0,a1,a2##condition=(a3 eq a5)
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   addi a5, zero, 0x2a
-;   bne a0, a5, 0xc
+;   mv a3, a0
 ;   mv a0, a1
-;   j 8
+;   beq a3, a5, 8
 ;   mv a0, a2
 ;   ret
 
@@ -621,24 +614,25 @@ block0(v0: i64, v1: i128, v2: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   sd s4,-8(sp)
-;   sd s6,-16(sp)
-;   add sp,-16
+;   addi sp,sp,-16
+;   sd s4,8(sp)
+;   sd s6,0(sp)
 ; block0:
-;   mv s6,a0
-;   mv s4,a1
-;   li a5,42
-;   select [a0,a1],[s4,a2],[a3,a4]##condition=(s6 eq a5)
-;   add sp,+16
-;   ld s4,-8(sp)
-;   ld s6,-16(sp)
+;   mv s4,a2
+;   mv s6,a1
+;   li a2,42
+;   mv a5,a0
+;   select [a0,a1],[s6,s4],[a3,a4]##condition=(a5 eq a2)
+;   ld s4,8(sp)
+;   ld s6,0(sp)
+;   addi sp,sp,16
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -647,22 +641,22 @@ block0(v0: i64, v1: i128, v2: i128):
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   sd s4, -8(sp)
-;   sd s6, -0x10(sp)
 ;   addi sp, sp, -0x10
+;   sd s4, 8(sp)
+;   sd s6, 0(sp)
 ; block1: ; offset 0x1c
-;   mv s6, a0
-;   mv s4, a1
-;   addi a5, zero, 0x2a
-;   bne s6, a5, 0x10
-;   mv a0, s4
-;   mv a1, a2
-;   j 0xc
+;   mv s4, a2
+;   mv s6, a1
+;   addi a2, zero, 0x2a
+;   mv a5, a0
+;   mv a0, s6
+;   mv a1, s4
+;   beq a5, a2, 0xc
 ;   mv a0, a3
 ;   mv a1, a4
+;   ld s4, 8(sp)
+;   ld s6, 0(sp)
 ;   addi sp, sp, 0x10
-;   ld s4, -8(sp)
-;   ld s6, -0x10(sp)
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -679,24 +673,25 @@ block0(v0: i128, v1: i8, v2: i8):
 
 ; VCode:
 ; block0:
-;   li a4,42
-;   li a5,0
-;   eq a4,[a0,a1],[a4,a5]##ty=i128
+;   li a5,42
+;   li a4,0
+;   xor a5,a0,a5
+;   xor a4,a1,a4
+;   or a0,a5,a4
+;   seqz a4,a0
 ;   select a0,a2,a3##condition=(a4 ne zero)
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a4, zero, 0x2a
-;   mv a5, zero
-;   bne a1, a5, 0x10
-;   bne a0, a4, 0xc
-;   addi a4, zero, 1
-;   j 8
+;   addi a5, zero, 0x2a
 ;   mv a4, zero
-;   beqz a4, 0xc
+;   xor a5, a0, a5
+;   xor a4, a1, a4
+;   or a0, a5, a4
+;   seqz a4, a0
 ;   mv a0, a2
-;   j 8
+;   bnez a4, 8
 ;   mv a0, a3
 ;   ret
 
@@ -711,24 +706,25 @@ block0(v0: i128, v1: i16, v2: i16):
 
 ; VCode:
 ; block0:
-;   li a4,42
-;   li a5,0
-;   eq a4,[a0,a1],[a4,a5]##ty=i128
+;   li a5,42
+;   li a4,0
+;   xor a5,a0,a5
+;   xor a4,a1,a4
+;   or a0,a5,a4
+;   seqz a4,a0
 ;   select a0,a2,a3##condition=(a4 ne zero)
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a4, zero, 0x2a
-;   mv a5, zero
-;   bne a1, a5, 0x10
-;   bne a0, a4, 0xc
-;   addi a4, zero, 1
-;   j 8
+;   addi a5, zero, 0x2a
 ;   mv a4, zero
-;   beqz a4, 0xc
+;   xor a5, a0, a5
+;   xor a4, a1, a4
+;   or a0, a5, a4
+;   seqz a4, a0
 ;   mv a0, a2
-;   j 8
+;   bnez a4, 8
 ;   mv a0, a3
 ;   ret
 
@@ -743,24 +739,25 @@ block0(v0: i128, v1: i32, v2: i32):
 
 ; VCode:
 ; block0:
-;   li a4,42
-;   li a5,0
-;   eq a4,[a0,a1],[a4,a5]##ty=i128
+;   li a5,42
+;   li a4,0
+;   xor a5,a0,a5
+;   xor a4,a1,a4
+;   or a0,a5,a4
+;   seqz a4,a0
 ;   select a0,a2,a3##condition=(a4 ne zero)
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a4, zero, 0x2a
-;   mv a5, zero
-;   bne a1, a5, 0x10
-;   bne a0, a4, 0xc
-;   addi a4, zero, 1
-;   j 8
+;   addi a5, zero, 0x2a
 ;   mv a4, zero
-;   beqz a4, 0xc
+;   xor a5, a0, a5
+;   xor a4, a1, a4
+;   or a0, a5, a4
+;   seqz a4, a0
 ;   mv a0, a2
-;   j 8
+;   bnez a4, 8
 ;   mv a0, a3
 ;   ret
 
@@ -775,24 +772,25 @@ block0(v0: i128, v1: i64, v2: i64):
 
 ; VCode:
 ; block0:
-;   li a4,42
-;   li a5,0
-;   eq a4,[a0,a1],[a4,a5]##ty=i128
+;   li a5,42
+;   li a4,0
+;   xor a5,a0,a5
+;   xor a4,a1,a4
+;   or a0,a5,a4
+;   seqz a4,a0
 ;   select a0,a2,a3##condition=(a4 ne zero)
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a4, zero, 0x2a
-;   mv a5, zero
-;   bne a1, a5, 0x10
-;   bne a0, a4, 0xc
-;   addi a4, zero, 1
-;   j 8
+;   addi a5, zero, 0x2a
 ;   mv a4, zero
-;   beqz a4, 0xc
+;   xor a5, a0, a5
+;   xor a4, a1, a4
+;   or a0, a5, a4
+;   seqz a4, a0
 ;   mv a0, a2
-;   j 8
+;   bnez a4, 8
 ;   mv a0, a3
 ;   ret
 
@@ -806,27 +804,29 @@ block0(v0: i128, v1: i128, v2: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   sd s4,-8(sp)
-;   sd s5,-16(sp)
-;   sd s6,-24(sp)
-;   add sp,-32
+;   addi sp,sp,-32
+;   sd s8,24(sp)
+;   sd s9,16(sp)
+;   sd s11,8(sp)
 ; block0:
-;   li s5,42
-;   li s6,0
-;   eq a0,[a0,a1],[s5,s6]##ty=i128
-;   select [s4,a1],[a2,a3],[a4,a5]##condition=(a0 ne zero)
-;   mv a0,s4
-;   add sp,+32
-;   ld s4,-8(sp)
-;   ld s5,-16(sp)
-;   ld s6,-24(sp)
+;   li s8,42
+;   li s9,0
+;   xor a0,a0,s8
+;   xor a1,a1,s9
+;   or a0,a0,a1
+;   seqz s11,a0
+;   select [a0,a1],[a2,a3],[a4,a5]##condition=(s11 ne zero)
+;   ld s8,24(sp)
+;   ld s9,16(sp)
+;   ld s11,8(sp)
+;   addi sp,sp,32
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -835,29 +835,26 @@ block0(v0: i128, v1: i128, v2: i128):
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   sd s4, -8(sp)
-;   sd s5, -0x10(sp)
-;   sd s6, -0x18(sp)
 ;   addi sp, sp, -0x20
+;   sd s8, 0x18(sp)
+;   sd s9, 0x10(sp)
+;   sd s11, 8(sp)
 ; block1: ; offset 0x20
-;   addi s5, zero, 0x2a
-;   mv s6, zero
-;   bne a1, s6, 0x10
-;   bne a0, s5, 0xc
-;   addi a0, zero, 1
-;   j 8
-;   mv a0, zero
-;   beqz a0, 0x10
-;   mv s4, a2
+;   addi s8, zero, 0x2a
+;   mv s9, zero
+;   xor a0, a0, s8
+;   xor a1, a1, s9
+;   or a0, a0, a1
+;   seqz s11, a0
+;   mv a0, a2
 ;   mv a1, a3
-;   j 0xc
-;   mv s4, a4
+;   bnez s11, 0xc
+;   mv a0, a4
 ;   mv a1, a5
-;   mv a0, s4
+;   ld s8, 0x18(sp)
+;   ld s9, 0x10(sp)
+;   ld s11, 8(sp)
 ;   addi sp, sp, 0x20
-;   ld s4, -8(sp)
-;   ld s5, -0x10(sp)
-;   ld s6, -0x18(sp)
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
diff --git a/cranelift/filetests/filetests/isa/riscv64/select_spectre_guard.clif b/cranelift/filetests/filetests/isa/riscv64/select_spectre_guard.clif
index ab91c78b6c7e..8466d02feff2 100644
--- a/cranelift/filetests/filetests/isa/riscv64/select_spectre_guard.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/select_spectre_guard.clif
@@ -12,33 +12,28 @@ block0(v0: i8, v1: i8, v2: i8):
 
 ; VCode:
 ; block0:
-;   li a3,42
-;   andi a5,a0,255
-;   andi a3,a3,255
-;   eq a3,a5,a3##ty=i8
-;   sltu a3,zero,a3
-;   sub a4,zero,a3
-;   and a0,a1,a4
-;   not a3,a4
-;   and a4,a2,a3
-;   or a0,a0,a4
+;   slli a3,a0,56
+;   srai a5,a3,56
+;   xori a3,a5,42
+;   seqz a3,a3
+;   sub a3,zero,a3
+;   and a4,a3,a1
+;   not a0,a3
+;   and a2,a2,a0
+;   or a0,a4,a2
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a3, zero, 0x2a
-;   andi a5, a0, 0xff
-;   andi a3, a3, 0xff
-;   bne a5, a3, 0xc
-;   addi a3, zero, 1
-;   j 8
-;   mv a3, zero
-;   snez a3, a3
-;   neg a4, a3
-;   and a0, a1, a4
-;   not a3, a4
-;   and a4, a2, a3
-;   or a0, a0, a4
+;   slli a3, a0, 0x38
+;   srai a5, a3, 0x38
+;   xori a3, a5, 0x2a
+;   seqz a3, a3
+;   neg a3, a3
+;   and a4, a3, a1
+;   not a0, a3
+;   and a2, a2, a0
+;   or a0, a4, a2
 ;   ret
 
 function %f(i8, i16, i16) -> i16 {
@@ -51,33 +46,28 @@ block0(v0: i8, v1: i16, v2: i16):
 
 ; VCode:
 ; block0:
-;   li a3,42
-;   andi a5,a0,255
-;   andi a3,a3,255
-;   eq a3,a5,a3##ty=i8
-;   sltu a3,zero,a3
-;   sub a4,zero,a3
-;   and a0,a1,a4
-;   not a3,a4
-;   and a4,a2,a3
-;   or a0,a0,a4
+;   slli a3,a0,56
+;   srai a5,a3,56
+;   xori a3,a5,42
+;   seqz a3,a3
+;   sub a3,zero,a3
+;   and a4,a3,a1
+;   not a0,a3
+;   and a2,a2,a0
+;   or a0,a4,a2
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a3, zero, 0x2a
-;   andi a5, a0, 0xff
-;   andi a3, a3, 0xff
-;   bne a5, a3, 0xc
-;   addi a3, zero, 1
-;   j 8
-;   mv a3, zero
-;   snez a3, a3
-;   neg a4, a3
-;   and a0, a1, a4
-;   not a3, a4
-;   and a4, a2, a3
-;   or a0, a0, a4
+;   slli a3, a0, 0x38
+;   srai a5, a3, 0x38
+;   xori a3, a5, 0x2a
+;   seqz a3, a3
+;   neg a3, a3
+;   and a4, a3, a1
+;   not a0, a3
+;   and a2, a2, a0
+;   or a0, a4, a2
 ;   ret
 
 function %f(i8, i32, i32) -> i32 {
@@ -90,33 +80,28 @@ block0(v0: i8, v1: i32, v2: i32):
 
 ; VCode:
 ; block0:
-;   li a3,42
-;   andi a5,a0,255
-;   andi a3,a3,255
-;   eq a3,a5,a3##ty=i8
-;   sltu a3,zero,a3
-;   sub a4,zero,a3
-;   and a0,a1,a4
-;   not a3,a4
-;   and a4,a2,a3
-;   or a0,a0,a4
+;   slli a3,a0,56
+;   srai a5,a3,56
+;   xori a3,a5,42
+;   seqz a3,a3
+;   sub a3,zero,a3
+;   and a4,a3,a1
+;   not a0,a3
+;   and a2,a2,a0
+;   or a0,a4,a2
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a3, zero, 0x2a
-;   andi a5, a0, 0xff
-;   andi a3, a3, 0xff
-;   bne a5, a3, 0xc
-;   addi a3, zero, 1
-;   j 8
-;   mv a3, zero
-;   snez a3, a3
-;   neg a4, a3
-;   and a0, a1, a4
-;   not a3, a4
-;   and a4, a2, a3
-;   or a0, a0, a4
+;   slli a3, a0, 0x38
+;   srai a5, a3, 0x38
+;   xori a3, a5, 0x2a
+;   seqz a3, a3
+;   neg a3, a3
+;   and a4, a3, a1
+;   not a0, a3
+;   and a2, a2, a0
+;   or a0, a4, a2
 ;   ret
 
 function %f(i8, i64, i64) -> i64 {
@@ -129,33 +114,28 @@ block0(v0: i8, v1: i64, v2: i64):
 
 ; VCode:
 ; block0:
-;   li a3,42
-;   andi a5,a0,255
-;   andi a3,a3,255
-;   eq a3,a5,a3##ty=i8
-;   sltu a3,zero,a3
-;   sub a4,zero,a3
-;   and a0,a1,a4
-;   not a3,a4
-;   and a4,a2,a3
-;   or a0,a0,a4
+;   slli a3,a0,56
+;   srai a5,a3,56
+;   xori a3,a5,42
+;   seqz a3,a3
+;   sub a3,zero,a3
+;   and a4,a3,a1
+;   not a0,a3
+;   and a2,a2,a0
+;   or a0,a4,a2
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a3, zero, 0x2a
-;   andi a5, a0, 0xff
-;   andi a3, a3, 0xff
-;   bne a5, a3, 0xc
-;   addi a3, zero, 1
-;   j 8
-;   mv a3, zero
-;   snez a3, a3
-;   neg a4, a3
-;   and a0, a1, a4
-;   not a3, a4
-;   and a4, a2, a3
-;   or a0, a0, a4
+;   slli a3, a0, 0x38
+;   srai a5, a3, 0x38
+;   xori a3, a5, 0x2a
+;   seqz a3, a3
+;   neg a3, a3
+;   and a4, a3, a1
+;   not a0, a3
+;   and a2, a2, a0
+;   or a0, a4, a2
 ;   ret
 
 function %f(i8, i128, i128) -> i128 {
@@ -167,65 +147,37 @@ block0(v0: i8, v1: i128, v2: i128):
 }
 
 ; VCode:
-;   add sp,-16
-;   sd ra,8(sp)
-;   sd fp,0(sp)
-;   mv fp,sp
-;   sd s6,-8(sp)
-;   add sp,-16
 ; block0:
-;   li a5,42
-;   andi a0,a0,255
-;   andi a5,a5,255
-;   eq a5,a0,a5##ty=i8
-;   sltu a5,zero,a5
-;   sub s6,zero,a5
-;   and a0,a1,s6
-;   and a5,a2,s6
-;   not a2,s6
-;   not a1,s6
-;   and a2,a3,a2
-;   and a1,a4,a1
-;   or a0,a0,a2
-;   or a1,a5,a1
-;   add sp,+16
-;   ld s6,-8(sp)
-;   ld ra,8(sp)
-;   ld fp,0(sp)
-;   add sp,+16
+;   slli a5,a0,56
+;   srai a5,a5,56
+;   xori a5,a5,42
+;   seqz a5,a5
+;   sub a5,zero,a5
+;   and a0,a5,a1
+;   not a1,a5
+;   and a1,a3,a1
+;   or a0,a0,a1
+;   and a2,a5,a2
+;   not a5,a5
+;   and a1,a4,a5
+;   or a1,a2,a1
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi sp, sp, -0x10
-;   sd ra, 8(sp)
-;   sd s0, 0(sp)
-;   mv s0, sp
-;   sd s6, -8(sp)
-;   addi sp, sp, -0x10
-; block1: ; offset 0x18
-;   addi a5, zero, 0x2a
-;   andi a0, a0, 0xff
-;   andi a5, a5, 0xff
-;   bne a0, a5, 0xc
-;   addi a5, zero, 1
-;   j 8
-;   mv a5, zero
-;   snez a5, a5
-;   neg s6, a5
-;   and a0, a1, s6
-;   and a5, a2, s6
-;   not a2, s6
-;   not a1, s6
-;   and a2, a3, a2
-;   and a1, a4, a1
-;   or a0, a0, a2
-;   or a1, a5, a1
-;   addi sp, sp, 0x10
-;   ld s6, -8(sp)
-;   ld ra, 8(sp)
-;   ld s0, 0(sp)
-;   addi sp, sp, 0x10
+;   slli a5, a0, 0x38
+;   srai a5, a5, 0x38
+;   xori a5, a5, 0x2a
+;   seqz a5, a5
+;   neg a5, a5
+;   and a0, a5, a1
+;   not a1, a5
+;   and a1, a3, a1
+;   or a0, a0, a1
+;   and a2, a5, a2
+;   not a5, a5
+;   and a1, a4, a5
+;   or a1, a2, a1
 ;   ret
 
 function %f(i16, i8, i8) -> i8 {
@@ -238,37 +190,28 @@ block0(v0: i16, v1: i8, v2: i8):
 
 ; VCode:
 ; block0:
-;   li a3,42
-;   slli a5,a0,48
-;   srli a4,a5,48
-;   slli a3,a3,48
-;   srli a5,a3,48
-;   eq a3,a4,a5##ty=i16
-;   sltu a4,zero,a3
-;   sub a0,zero,a4
-;   and a3,a1,a0
-;   not a4,a0
-;   and a0,a2,a4
-;   or a0,a3,a0
+;   slli a3,a0,48
+;   srai a5,a3,48
+;   xori a3,a5,42
+;   seqz a3,a3
+;   sub a3,zero,a3
+;   and a4,a3,a1
+;   not a0,a3
+;   and a2,a2,a0
+;   or a0,a4,a2
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a3, zero, 0x2a
-;   slli a5, a0, 0x30
-;   srli a4, a5, 0x30
-;   slli a3, a3, 0x30
-;   srli a5, a3, 0x30
-;   bne a4, a5, 0xc
-;   addi a3, zero, 1
-;   j 8
-;   mv a3, zero
-;   snez a4, a3
-;   neg a0, a4
-;   and a3, a1, a0
-;   not a4, a0
-;   and a0, a2, a4
-;   or a0, a3, a0
+;   slli a3, a0, 0x30
+;   srai a5, a3, 0x30
+;   xori a3, a5, 0x2a
+;   seqz a3, a3
+;   neg a3, a3
+;   and a4, a3, a1
+;   not a0, a3
+;   and a2, a2, a0
+;   or a0, a4, a2
 ;   ret
 
 function %f(i16, i16, i16) -> i16 {
@@ -281,37 +224,28 @@ block0(v0: i16, v1: i16, v2: i16):
 
 ; VCode:
 ; block0:
-;   li a3,42
-;   slli a5,a0,48
-;   srli a4,a5,48
-;   slli a3,a3,48
-;   srli a5,a3,48
-;   eq a3,a4,a5##ty=i16
-;   sltu a4,zero,a3
-;   sub a0,zero,a4
-;   and a3,a1,a0
-;   not a4,a0
-;   and a0,a2,a4
-;   or a0,a3,a0
+;   slli a3,a0,48
+;   srai a5,a3,48
+;   xori a3,a5,42
+;   seqz a3,a3
+;   sub a3,zero,a3
+;   and a4,a3,a1
+;   not a0,a3
+;   and a2,a2,a0
+;   or a0,a4,a2
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a3, zero, 0x2a
-;   slli a5, a0, 0x30
-;   srli a4, a5, 0x30
-;   slli a3, a3, 0x30
-;   srli a5, a3, 0x30
-;   bne a4, a5, 0xc
-;   addi a3, zero, 1
-;   j 8
-;   mv a3, zero
-;   snez a4, a3
-;   neg a0, a4
-;   and a3, a1, a0
-;   not a4, a0
-;   and a0, a2, a4
-;   or a0, a3, a0
+;   slli a3, a0, 0x30
+;   srai a5, a3, 0x30
+;   xori a3, a5, 0x2a
+;   seqz a3, a3
+;   neg a3, a3
+;   and a4, a3, a1
+;   not a0, a3
+;   and a2, a2, a0
+;   or a0, a4, a2
 ;   ret
 
 function %f(i16, i32, i32) -> i32 {
@@ -324,37 +258,28 @@ block0(v0: i16, v1: i32, v2: i32):
 
 ; VCode:
 ; block0:
-;   li a3,42
-;   slli a5,a0,48
-;   srli a4,a5,48
-;   slli a3,a3,48
-;   srli a5,a3,48
-;   eq a3,a4,a5##ty=i16
-;   sltu a4,zero,a3
-;   sub a0,zero,a4
-;   and a3,a1,a0
-;   not a4,a0
-;   and a0,a2,a4
-;   or a0,a3,a0
+;   slli a3,a0,48
+;   srai a5,a3,48
+;   xori a3,a5,42
+;   seqz a3,a3
+;   sub a3,zero,a3
+;   and a4,a3,a1
+;   not a0,a3
+;   and a2,a2,a0
+;   or a0,a4,a2
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a3, zero, 0x2a
-;   slli a5, a0, 0x30
-;   srli a4, a5, 0x30
-;   slli a3, a3, 0x30
-;   srli a5, a3, 0x30
-;   bne a4, a5, 0xc
-;   addi a3, zero, 1
-;   j 8
-;   mv a3, zero
-;   snez a4, a3
-;   neg a0, a4
-;   and a3, a1, a0
-;   not a4, a0
-;   and a0, a2, a4
-;   or a0, a3, a0
+;   slli a3, a0, 0x30
+;   srai a5, a3, 0x30
+;   xori a3, a5, 0x2a
+;   seqz a3, a3
+;   neg a3, a3
+;   and a4, a3, a1
+;   not a0, a3
+;   and a2, a2, a0
+;   or a0, a4, a2
 ;   ret
 
 function %f(i16, i64, i64) -> i64 {
@@ -367,37 +292,28 @@ block0(v0: i16, v1: i64, v2: i64):
 
 ; VCode:
 ; block0:
-;   li a3,42
-;   slli a5,a0,48
-;   srli a4,a5,48
-;   slli a3,a3,48
-;   srli a5,a3,48
-;   eq a3,a4,a5##ty=i16
-;   sltu a4,zero,a3
-;   sub a0,zero,a4
-;   and a3,a1,a0
-;   not a4,a0
-;   and a0,a2,a4
-;   or a0,a3,a0
+;   slli a3,a0,48
+;   srai a5,a3,48
+;   xori a3,a5,42
+;   seqz a3,a3
+;   sub a3,zero,a3
+;   and a4,a3,a1
+;   not a0,a3
+;   and a2,a2,a0
+;   or a0,a4,a2
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a3, zero, 0x2a
-;   slli a5, a0, 0x30
-;   srli a4, a5, 0x30
-;   slli a3, a3, 0x30
-;   srli a5, a3, 0x30
-;   bne a4, a5, 0xc
-;   addi a3, zero, 1
-;   j 8
-;   mv a3, zero
-;   snez a4, a3
-;   neg a0, a4
-;   and a3, a1, a0
-;   not a4, a0
-;   and a0, a2, a4
-;   or a0, a3, a0
+;   slli a3, a0, 0x30
+;   srai a5, a3, 0x30
+;   xori a3, a5, 0x2a
+;   seqz a3, a3
+;   neg a3, a3
+;   and a4, a3, a1
+;   not a0, a3
+;   and a2, a2, a0
+;   or a0, a4, a2
 ;   ret
 
 function %f(i16, i128, i128) -> i128 {
@@ -409,69 +325,37 @@ block0(v0: i16, v1: i128, v2: i128):
 }
 
 ; VCode:
-;   add sp,-16
-;   sd ra,8(sp)
-;   sd fp,0(sp)
-;   mv fp,sp
-;   sd s8,-8(sp)
-;   add sp,-16
 ; block0:
-;   li a5,42
-;   slli a0,a0,48
-;   srli a0,a0,48
-;   slli a5,a5,48
-;   srli a5,a5,48
-;   eq a5,a0,a5##ty=i16
-;   sltu a0,zero,a5
-;   sub s8,zero,a0
-;   and a5,a1,s8
-;   and a1,a2,s8
-;   not a0,s8
-;   not a2,s8
-;   and a0,a3,a0
-;   and a2,a4,a2
-;   or a0,a5,a0
-;   or a1,a1,a2
-;   add sp,+16
-;   ld s8,-8(sp)
-;   ld ra,8(sp)
-;   ld fp,0(sp)
-;   add sp,+16
+;   slli a5,a0,48
+;   srai a5,a5,48
+;   xori a5,a5,42
+;   seqz a5,a5
+;   sub a5,zero,a5
+;   and a0,a5,a1
+;   not a1,a5
+;   and a1,a3,a1
+;   or a0,a0,a1
+;   and a2,a5,a2
+;   not a5,a5
+;   and a1,a4,a5
+;   or a1,a2,a1
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi sp, sp, -0x10
-;   sd ra, 8(sp)
-;   sd s0, 0(sp)
-;   mv s0, sp
-;   sd s8, -8(sp)
-;   addi sp, sp, -0x10
-; block1: ; offset 0x18
-;   addi a5, zero, 0x2a
-;   slli a0, a0, 0x30
-;   srli a0, a0, 0x30
-;   slli a5, a5, 0x30
-;   srli a5, a5, 0x30
-;   bne a0, a5, 0xc
-;   addi a5, zero, 1
-;   j 8
-;   mv a5, zero
-;   snez a0, a5
-;   neg s8, a0
-;   and a5, a1, s8
-;   and a1, a2, s8
-;   not a0, s8
-;   not a2, s8
-;   and a0, a3, a0
-;   and a2, a4, a2
-;   or a0, a5, a0
-;   or a1, a1, a2
-;   addi sp, sp, 0x10
-;   ld s8, -8(sp)
-;   ld ra, 8(sp)
-;   ld s0, 0(sp)
-;   addi sp, sp, 0x10
+;   slli a5, a0, 0x30
+;   srai a5, a5, 0x30
+;   xori a5, a5, 0x2a
+;   seqz a5, a5
+;   neg a5, a5
+;   and a0, a5, a1
+;   not a1, a5
+;   and a1, a3, a1
+;   or a0, a0, a1
+;   and a2, a5, a2
+;   not a5, a5
+;   and a1, a4, a5
+;   or a1, a2, a1
 ;   ret
 
 function %f(i32, i8, i8) -> i8 {
@@ -484,37 +368,26 @@ block0(v0: i32, v1: i8, v2: i8):
 
 ; VCode:
 ; block0:
-;   li a3,42
-;   slli a5,a0,32
-;   srli a4,a5,32
-;   slli a3,a3,32
-;   srli a5,a3,32
-;   eq a3,a4,a5##ty=i32
-;   sltu a4,zero,a3
-;   sub a0,zero,a4
-;   and a3,a1,a0
-;   not a4,a0
-;   and a0,a2,a4
-;   or a0,a3,a0
+;   sext.w a3,a0
+;   xori a5,a3,42
+;   seqz a3,a5
+;   sub a4,zero,a3
+;   and a3,a4,a1
+;   not a5,a4
+;   and a1,a2,a5
+;   or a0,a3,a1
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a3, zero, 0x2a
-;   slli a5, a0, 0x20
-;   srli a4, a5, 0x20
-;   slli a3, a3, 0x20
-;   srli a5, a3, 0x20
-;   bne a4, a5, 0xc
-;   addi a3, zero, 1
-;   j 8
-;   mv a3, zero
-;   snez a4, a3
-;   neg a0, a4
-;   and a3, a1, a0
-;   not a4, a0
-;   and a0, a2, a4
-;   or a0, a3, a0
+;   sext.w a3, a0
+;   xori a5, a3, 0x2a
+;   seqz a3, a5
+;   neg a4, a3
+;   and a3, a4, a1
+;   not a5, a4
+;   and a1, a2, a5
+;   or a0, a3, a1
 ;   ret
 
 function %f(i32, i16, i16) -> i16 {
@@ -527,37 +400,26 @@ block0(v0: i32, v1: i16, v2: i16):
 
 ; VCode:
 ; block0:
-;   li a3,42
-;   slli a5,a0,32
-;   srli a4,a5,32
-;   slli a3,a3,32
-;   srli a5,a3,32
-;   eq a3,a4,a5##ty=i32
-;   sltu a4,zero,a3
-;   sub a0,zero,a4
-;   and a3,a1,a0
-;   not a4,a0
-;   and a0,a2,a4
-;   or a0,a3,a0
+;   sext.w a3,a0
+;   xori a5,a3,42
+;   seqz a3,a5
+;   sub a4,zero,a3
+;   and a3,a4,a1
+;   not a5,a4
+;   and a1,a2,a5
+;   or a0,a3,a1
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a3, zero, 0x2a
-;   slli a5, a0, 0x20
-;   srli a4, a5, 0x20
-;   slli a3, a3, 0x20
-;   srli a5, a3, 0x20
-;   bne a4, a5, 0xc
-;   addi a3, zero, 1
-;   j 8
-;   mv a3, zero
-;   snez a4, a3
-;   neg a0, a4
-;   and a3, a1, a0
-;   not a4, a0
-;   and a0, a2, a4
-;   or a0, a3, a0
+;   sext.w a3, a0
+;   xori a5, a3, 0x2a
+;   seqz a3, a5
+;   neg a4, a3
+;   and a3, a4, a1
+;   not a5, a4
+;   and a1, a2, a5
+;   or a0, a3, a1
 ;   ret
 
 function %f(i32, i32, i32) -> i32 {
@@ -570,37 +432,26 @@ block0(v0: i32, v1: i32, v2: i32):
 
 ; VCode:
 ; block0:
-;   li a3,42
-;   slli a5,a0,32
-;   srli a4,a5,32
-;   slli a3,a3,32
-;   srli a5,a3,32
-;   eq a3,a4,a5##ty=i32
-;   sltu a4,zero,a3
-;   sub a0,zero,a4
-;   and a3,a1,a0
-;   not a4,a0
-;   and a0,a2,a4
-;   or a0,a3,a0
+;   sext.w a3,a0
+;   xori a5,a3,42
+;   seqz a3,a5
+;   sub a4,zero,a3
+;   and a3,a4,a1
+;   not a5,a4
+;   and a1,a2,a5
+;   or a0,a3,a1
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a3, zero, 0x2a
-;   slli a5, a0, 0x20
-;   srli a4, a5, 0x20
-;   slli a3, a3, 0x20
-;   srli a5, a3, 0x20
-;   bne a4, a5, 0xc
-;   addi a3, zero, 1
-;   j 8
-;   mv a3, zero
-;   snez a4, a3
-;   neg a0, a4
-;   and a3, a1, a0
-;   not a4, a0
-;   and a0, a2, a4
-;   or a0, a3, a0
+;   sext.w a3, a0
+;   xori a5, a3, 0x2a
+;   seqz a3, a5
+;   neg a4, a3
+;   and a3, a4, a1
+;   not a5, a4
+;   and a1, a2, a5
+;   or a0, a3, a1
 ;   ret
 
 function %f(i32, i64, i64) -> i64 {
@@ -613,37 +464,26 @@ block0(v0: i32, v1: i64, v2: i64):
 
 ; VCode:
 ; block0:
-;   li a3,42
-;   slli a5,a0,32
-;   srli a4,a5,32
-;   slli a3,a3,32
-;   srli a5,a3,32
-;   eq a3,a4,a5##ty=i32
-;   sltu a4,zero,a3
-;   sub a0,zero,a4
-;   and a3,a1,a0
-;   not a4,a0
-;   and a0,a2,a4
-;   or a0,a3,a0
+;   sext.w a3,a0
+;   xori a5,a3,42
+;   seqz a3,a5
+;   sub a4,zero,a3
+;   and a3,a4,a1
+;   not a5,a4
+;   and a1,a2,a5
+;   or a0,a3,a1
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a3, zero, 0x2a
-;   slli a5, a0, 0x20
-;   srli a4, a5, 0x20
-;   slli a3, a3, 0x20
-;   srli a5, a3, 0x20
-;   bne a4, a5, 0xc
-;   addi a3, zero, 1
-;   j 8
-;   mv a3, zero
-;   snez a4, a3
-;   neg a0, a4
-;   and a3, a1, a0
-;   not a4, a0
-;   and a0, a2, a4
-;   or a0, a3, a0
+;   sext.w a3, a0
+;   xori a5, a3, 0x2a
+;   seqz a3, a5
+;   neg a4, a3
+;   and a3, a4, a1
+;   not a5, a4
+;   and a1, a2, a5
+;   or a0, a3, a1
 ;   ret
 
 function %f(i32, i128, i128) -> i128 {
@@ -655,69 +495,35 @@ block0(v0: i32, v1: i128, v2: i128):
 }
 
 ; VCode:
-;   add sp,-16
-;   sd ra,8(sp)
-;   sd fp,0(sp)
-;   mv fp,sp
-;   sd s8,-8(sp)
-;   add sp,-16
 ; block0:
-;   li a5,42
-;   slli a0,a0,32
-;   srli a0,a0,32
-;   slli a5,a5,32
-;   srli a5,a5,32
-;   eq a5,a0,a5##ty=i32
-;   sltu a0,zero,a5
-;   sub s8,zero,a0
-;   and a5,a1,s8
-;   and a1,a2,s8
-;   not a0,s8
-;   not a2,s8
-;   and a0,a3,a0
-;   and a2,a4,a2
-;   or a0,a5,a0
-;   or a1,a1,a2
-;   add sp,+16
-;   ld s8,-8(sp)
-;   ld ra,8(sp)
-;   ld fp,0(sp)
-;   add sp,+16
+;   sext.w a5,a0
+;   xori a5,a5,42
+;   seqz a5,a5
+;   sub a5,zero,a5
+;   and a0,a5,a1
+;   not a1,a5
+;   and a3,a3,a1
+;   or a0,a0,a3
+;   and a1,a5,a2
+;   not a3,a5
+;   and a5,a4,a3
+;   or a1,a1,a5
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi sp, sp, -0x10
-;   sd ra, 8(sp)
-;   sd s0, 0(sp)
-;   mv s0, sp
-;   sd s8, -8(sp)
-;   addi sp, sp, -0x10
-; block1: ; offset 0x18
-;   addi a5, zero, 0x2a
-;   slli a0, a0, 0x20
-;   srli a0, a0, 0x20
-;   slli a5, a5, 0x20
-;   srli a5, a5, 0x20
-;   bne a0, a5, 0xc
-;   addi a5, zero, 1
-;   j 8
-;   mv a5, zero
-;   snez a0, a5
-;   neg s8, a0
-;   and a5, a1, s8
-;   and a1, a2, s8
-;   not a0, s8
-;   not a2, s8
-;   and a0, a3, a0
-;   and a2, a4, a2
-;   or a0, a5, a0
-;   or a1, a1, a2
-;   addi sp, sp, 0x10
-;   ld s8, -8(sp)
-;   ld ra, 8(sp)
-;   ld s0, 0(sp)
-;   addi sp, sp, 0x10
+;   sext.w a5, a0
+;   xori a5, a5, 0x2a
+;   seqz a5, a5
+;   neg a5, a5
+;   and a0, a5, a1
+;   not a1, a5
+;   and a3, a3, a1
+;   or a0, a0, a3
+;   and a1, a5, a2
+;   not a3, a5
+;   and a5, a4, a3
+;   or a1, a1, a5
 ;   ret
 
 function %f(i64, i8, i8) -> i8 {
@@ -730,29 +536,24 @@ block0(v0: i64, v1: i8, v2: i8):
 
 ; VCode:
 ; block0:
-;   li a5,42
-;   eq a5,a0,a5##ty=i64
-;   sltu a0,zero,a5
-;   sub a3,zero,a0
-;   and a4,a1,a3
-;   not a0,a3
-;   and a2,a2,a0
-;   or a0,a4,a2
+;   xori a3,a0,42
+;   seqz a5,a3
+;   sub a0,zero,a5
+;   and a3,a0,a1
+;   not a4,a0
+;   and a0,a2,a4
+;   or a0,a3,a0
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a5, zero, 0x2a
-;   bne a0, a5, 0xc
-;   addi a5, zero, 1
-;   j 8
-;   mv a5, zero
-;   snez a0, a5
-;   neg a3, a0
-;   and a4, a1, a3
-;   not a0, a3
-;   and a2, a2, a0
-;   or a0, a4, a2
+;   xori a3, a0, 0x2a
+;   seqz a5, a3
+;   neg a0, a5
+;   and a3, a0, a1
+;   not a4, a0
+;   and a0, a2, a4
+;   or a0, a3, a0
 ;   ret
 
 function %f(i64, i16, i16) -> i16 {
@@ -765,29 +566,24 @@ block0(v0: i64, v1: i16, v2: i16):
 
 ; VCode:
 ; block0:
-;   li a5,42
-;   eq a5,a0,a5##ty=i64
-;   sltu a0,zero,a5
-;   sub a3,zero,a0
-;   and a4,a1,a3
-;   not a0,a3
-;   and a2,a2,a0
-;   or a0,a4,a2
+;   xori a3,a0,42
+;   seqz a5,a3
+;   sub a0,zero,a5
+;   and a3,a0,a1
+;   not a4,a0
+;   and a0,a2,a4
+;   or a0,a3,a0
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a5, zero, 0x2a
-;   bne a0, a5, 0xc
-;   addi a5, zero, 1
-;   j 8
-;   mv a5, zero
-;   snez a0, a5
-;   neg a3, a0
-;   and a4, a1, a3
-;   not a0, a3
-;   and a2, a2, a0
-;   or a0, a4, a2
+;   xori a3, a0, 0x2a
+;   seqz a5, a3
+;   neg a0, a5
+;   and a3, a0, a1
+;   not a4, a0
+;   and a0, a2, a4
+;   or a0, a3, a0
 ;   ret
 
 function %f(i64, i32, i32) -> i32 {
@@ -800,29 +596,24 @@ block0(v0: i64, v1: i32, v2: i32):
 
 ; VCode:
 ; block0:
-;   li a5,42
-;   eq a5,a0,a5##ty=i64
-;   sltu a0,zero,a5
-;   sub a3,zero,a0
-;   and a4,a1,a3
-;   not a0,a3
-;   and a2,a2,a0
-;   or a0,a4,a2
+;   xori a3,a0,42
+;   seqz a5,a3
+;   sub a0,zero,a5
+;   and a3,a0,a1
+;   not a4,a0
+;   and a0,a2,a4
+;   or a0,a3,a0
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a5, zero, 0x2a
-;   bne a0, a5, 0xc
-;   addi a5, zero, 1
-;   j 8
-;   mv a5, zero
-;   snez a0, a5
-;   neg a3, a0
-;   and a4, a1, a3
-;   not a0, a3
-;   and a2, a2, a0
-;   or a0, a4, a2
+;   xori a3, a0, 0x2a
+;   seqz a5, a3
+;   neg a0, a5
+;   and a3, a0, a1
+;   not a4, a0
+;   and a0, a2, a4
+;   or a0, a3, a0
 ;   ret
 
 function %f(i64, i64, i64) -> i64 {
@@ -835,29 +626,24 @@ block0(v0: i64, v1: i64, v2: i64):
 
 ; VCode:
 ; block0:
-;   li a5,42
-;   eq a5,a0,a5##ty=i64
-;   sltu a0,zero,a5
-;   sub a3,zero,a0
-;   and a4,a1,a3
-;   not a0,a3
-;   and a2,a2,a0
-;   or a0,a4,a2
+;   xori a3,a0,42
+;   seqz a5,a3
+;   sub a0,zero,a5
+;   and a3,a0,a1
+;   not a4,a0
+;   and a0,a2,a4
+;   or a0,a3,a0
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi a5, zero, 0x2a
-;   bne a0, a5, 0xc
-;   addi a5, zero, 1
-;   j 8
-;   mv a5, zero
-;   snez a0, a5
-;   neg a3, a0
-;   and a4, a1, a3
-;   not a0, a3
-;   and a2, a2, a0
-;   or a0, a4, a2
+;   xori a3, a0, 0x2a
+;   seqz a5, a3
+;   neg a0, a5
+;   and a3, a0, a1
+;   not a4, a0
+;   and a0, a2, a4
+;   or a0, a3, a0
 ;   ret
 
 function %f(i64, i128, i128) -> i128 {
@@ -869,30 +655,31 @@ block0(v0: i64, v1: i128, v2: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   sd s10,-8(sp)
-;   add sp,-16
+;   addi sp,sp,-16
+;   sd s11,8(sp)
 ; block0:
-;   li a5,42
-;   eq a5,a0,a5##ty=i64
-;   sltu a5,zero,a5
-;   sub a5,zero,a5
-;   and a0,a1,a5
-;   and a2,a2,a5
-;   not s10,a5
-;   not a1,a5
-;   and a3,a3,s10
-;   and a4,a4,a1
-;   or a0,a0,a3
-;   or a1,a2,a4
-;   add sp,+16
-;   ld s10,-8(sp)
+;   mv s11,a3
+;   xori a3,a0,42
+;   seqz a5,a3
+;   sub a3,zero,a5
+;   and a5,a3,a1
+;   not a0,a3
+;   mv a1,s11
+;   and a0,a1,a0
+;   or a0,a5,a0
+;   and a1,a3,a2
+;   not a2,a3
+;   and a4,a4,a2
+;   or a1,a1,a4
+;   ld s11,8(sp)
+;   addi sp,sp,16
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -901,26 +688,24 @@ block0(v0: i64, v1: i128, v2: i128):
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   sd s10, -8(sp)
 ;   addi sp, sp, -0x10
+;   sd s11, 8(sp)
 ; block1: ; offset 0x18
-;   addi a5, zero, 0x2a
-;   bne a0, a5, 0xc
-;   addi a5, zero, 1
-;   j 8
-;   mv a5, zero
-;   snez a5, a5
-;   neg a5, a5
-;   and a0, a1, a5
-;   and a2, a2, a5
-;   not s10, a5
-;   not a1, a5
-;   and a3, a3, s10
-;   and a4, a4, a1
-;   or a0, a0, a3
-;   or a1, a2, a4
+;   mv s11, a3
+;   xori a3, a0, 0x2a
+;   seqz a5, a3
+;   neg a3, a5
+;   and a5, a3, a1
+;   not a0, a3
+;   mv a1, s11
+;   and a0, a1, a0
+;   or a0, a5, a0
+;   and a1, a3, a2
+;   not a2, a3
+;   and a4, a4, a2
+;   or a1, a1, a4
+;   ld s11, 8(sp)
 ;   addi sp, sp, 0x10
-;   ld s10, -8(sp)
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -939,30 +724,30 @@ block0(v0: i128, v1: i8, v2: i8):
 ; block0:
 ;   li a4,42
 ;   li a5,0
-;   eq a1,[a0,a1],[a4,a5]##ty=i128
-;   sltu a4,zero,a1
-;   sub a4,zero,a4
-;   and a0,a2,a4
-;   not a2,a4
-;   and a4,a3,a2
-;   or a0,a0,a4
+;   xor a0,a0,a4
+;   xor a4,a1,a5
+;   or a4,a0,a4
+;   seqz a0,a4
+;   sub a5,zero,a0
+;   and a1,a5,a2
+;   not a4,a5
+;   and a5,a3,a4
+;   or a0,a1,a5
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   addi a4, zero, 0x2a
 ;   mv a5, zero
-;   bne a1, a5, 0x10
-;   bne a0, a4, 0xc
-;   addi a1, zero, 1
-;   j 8
-;   mv a1, zero
-;   snez a4, a1
-;   neg a4, a4
-;   and a0, a2, a4
-;   not a2, a4
-;   and a4, a3, a2
-;   or a0, a0, a4
+;   xor a0, a0, a4
+;   xor a4, a1, a5
+;   or a4, a0, a4
+;   seqz a0, a4
+;   neg a5, a0
+;   and a1, a5, a2
+;   not a4, a5
+;   and a5, a3, a4
+;   or a0, a1, a5
 ;   ret
 
 function %f(i128, i16, i16) -> i16 {
@@ -978,30 +763,30 @@ block0(v0: i128, v1: i16, v2: i16):
 ; block0:
 ;   li a4,42
 ;   li a5,0
-;   eq a1,[a0,a1],[a4,a5]##ty=i128
-;   sltu a4,zero,a1
-;   sub a4,zero,a4
-;   and a0,a2,a4
-;   not a2,a4
-;   and a4,a3,a2
-;   or a0,a0,a4
+;   xor a0,a0,a4
+;   xor a4,a1,a5
+;   or a4,a0,a4
+;   seqz a0,a4
+;   sub a5,zero,a0
+;   and a1,a5,a2
+;   not a4,a5
+;   and a5,a3,a4
+;   or a0,a1,a5
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   addi a4, zero, 0x2a
 ;   mv a5, zero
-;   bne a1, a5, 0x10
-;   bne a0, a4, 0xc
-;   addi a1, zero, 1
-;   j 8
-;   mv a1, zero
-;   snez a4, a1
-;   neg a4, a4
-;   and a0, a2, a4
-;   not a2, a4
-;   and a4, a3, a2
-;   or a0, a0, a4
+;   xor a0, a0, a4
+;   xor a4, a1, a5
+;   or a4, a0, a4
+;   seqz a0, a4
+;   neg a5, a0
+;   and a1, a5, a2
+;   not a4, a5
+;   and a5, a3, a4
+;   or a0, a1, a5
 ;   ret
 
 function %f(i128, i32, i32) -> i32 {
@@ -1017,30 +802,30 @@ block0(v0: i128, v1: i32, v2: i32):
 ; block0:
 ;   li a4,42
 ;   li a5,0
-;   eq a1,[a0,a1],[a4,a5]##ty=i128
-;   sltu a4,zero,a1
-;   sub a4,zero,a4
-;   and a0,a2,a4
-;   not a2,a4
-;   and a4,a3,a2
-;   or a0,a0,a4
+;   xor a0,a0,a4
+;   xor a4,a1,a5
+;   or a4,a0,a4
+;   seqz a0,a4
+;   sub a5,zero,a0
+;   and a1,a5,a2
+;   not a4,a5
+;   and a5,a3,a4
+;   or a0,a1,a5
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   addi a4, zero, 0x2a
 ;   mv a5, zero
-;   bne a1, a5, 0x10
-;   bne a0, a4, 0xc
-;   addi a1, zero, 1
-;   j 8
-;   mv a1, zero
-;   snez a4, a1
-;   neg a4, a4
-;   and a0, a2, a4
-;   not a2, a4
-;   and a4, a3, a2
-;   or a0, a0, a4
+;   xor a0, a0, a4
+;   xor a4, a1, a5
+;   or a4, a0, a4
+;   seqz a0, a4
+;   neg a5, a0
+;   and a1, a5, a2
+;   not a4, a5
+;   and a5, a3, a4
+;   or a0, a1, a5
 ;   ret
 
 function %f(i128, i64, i64) -> i64 {
@@ -1056,30 +841,30 @@ block0(v0: i128, v1: i64, v2: i64):
 ; block0:
 ;   li a4,42
 ;   li a5,0
-;   eq a1,[a0,a1],[a4,a5]##ty=i128
-;   sltu a4,zero,a1
-;   sub a4,zero,a4
-;   and a0,a2,a4
-;   not a2,a4
-;   and a4,a3,a2
-;   or a0,a0,a4
+;   xor a0,a0,a4
+;   xor a4,a1,a5
+;   or a4,a0,a4
+;   seqz a0,a4
+;   sub a5,zero,a0
+;   and a1,a5,a2
+;   not a4,a5
+;   and a5,a3,a4
+;   or a0,a1,a5
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   addi a4, zero, 0x2a
 ;   mv a5, zero
-;   bne a1, a5, 0x10
-;   bne a0, a4, 0xc
-;   addi a1, zero, 1
-;   j 8
-;   mv a1, zero
-;   snez a4, a1
-;   neg a4, a4
-;   and a0, a2, a4
-;   not a2, a4
-;   and a4, a3, a2
-;   or a0, a0, a4
+;   xor a0, a0, a4
+;   xor a4, a1, a5
+;   or a4, a0, a4
+;   seqz a0, a4
+;   neg a5, a0
+;   and a1, a5, a2
+;   not a4, a5
+;   and a5, a3, a4
+;   or a0, a1, a5
 ;   ret
 
 function %f(i128, i128, i128) -> i128 {
@@ -1093,39 +878,39 @@ block0(v0: i128, v1: i128, v2: i128):
 
 ; VCode:
 ; block0:
-;   li t1,42
-;   li t2,0
-;   eq a1,[a0,a1],[t1,t2]##ty=i128
-;   sltu a0,zero,a1
+;   li a6,42
+;   li a7,0
+;   xor a0,a0,a6
+;   xor a1,a1,a7
+;   or a0,a0,a1
+;   seqz a0,a0
 ;   sub a1,zero,a0
-;   and a2,a2,a1
-;   and a3,a3,a1
-;   not t0,a1
-;   not a0,a1
-;   and a4,a4,t0
-;   and a1,a5,a0
-;   or a0,a2,a4
-;   or a1,a3,a1
+;   and a0,a1,a2
+;   not a2,a1
+;   and a2,a4,a2
+;   or a0,a0,a2
+;   and a2,a1,a3
+;   not a1,a1
+;   and a3,a5,a1
+;   or a1,a2,a3
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   addi t1, zero, 0x2a
-;   mv t2, zero
-;   bne a1, t2, 0x10
-;   bne a0, t1, 0xc
-;   addi a1, zero, 1
-;   j 8
-;   mv a1, zero
-;   snez a0, a1
+;   addi a6, zero, 0x2a
+;   mv a7, zero
+;   xor a0, a0, a6
+;   xor a1, a1, a7
+;   or a0, a0, a1
+;   seqz a0, a0
 ;   neg a1, a0
-;   and a2, a2, a1
-;   and a3, a3, a1
-;   not t0, a1
-;   not a0, a1
-;   and a4, a4, t0
-;   and a1, a5, a0
-;   or a0, a2, a4
-;   or a1, a3, a1
+;   and a0, a1, a2
+;   not a2, a1
+;   and a2, a4, a2
+;   or a0, a0, a2
+;   and a2, a1, a3
+;   not a1, a1
+;   and a3, a5, a1
+;   or a1, a2, a3
 ;   ret
 
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-abi-large-spill.clif b/cranelift/filetests/filetests/isa/riscv64/simd-abi-large-spill.clif
index f8412ce89cde..85cb74f6f7dc 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-abi-large-spill.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-abi-large-spill.clif
@@ -16,25 +16,25 @@ block0:
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   sd s1,-8(sp)
-;   add sp,-1040
+;   addi sp,sp,-1040
+;   sd s1,1032(sp)
 ; block0:
 ;   mv s1,a0
 ;   vle16.v v11,[const(0)] #avl=8, #vtype=(e16, m1, ta, ma)
-;   vse8.v v11,0(nominal_sp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vse8.v v11,0(slot) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   call userextname0
 ;   mv a0,s1
-;   vle8.v v11,0(nominal_sp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,0(slot) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v11,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
-;   add sp,+1040
-;   ld s1,-8(sp)
+;   ld s1,1032(sp)
+;   addi sp,sp,1040
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -43,8 +43,8 @@ block0:
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   sd s1, -8(sp)
 ;   addi sp, sp, -0x410
+;   sd s1, 0x408(sp)
 ; block1: ; offset 0x18
 ;   mv s1, a0
 ;   .byte 0x57, 0x70, 0x84, 0xcc
@@ -53,13 +53,13 @@ block0:
 ;   .byte 0x87, 0xd5, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x08, 0xcc
 ;   .byte 0xa7, 0x05, 0x01, 0x02
-;   auipc ra, 0 ; reloc_external RiscvCall u2:0 0
+;   auipc ra, 0 ; reloc_external RiscvCallPlt u2:0 0
 ;   jalr ra
 ;   mv a0, s1
 ;   .byte 0x87, 0x05, 0x01, 0x02
 ;   .byte 0xa7, 0x05, 0x05, 0x02
+;   ld s1, 0x408(sp)
 ;   addi sp, sp, 0x410
-;   ld s1, -8(sp)
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-abi.clif b/cranelift/filetests/filetests/isa/riscv64/simd-abi.clif
index 745a584e81d8..d92455801c2a 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-abi.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-abi.clif
@@ -33,48 +33,48 @@ block0(
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   add sp,-256
+;   addi sp,sp,-256
 ; block0:
-;   vle8.v v11,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vse8.v v11,0(nominal_sp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v13,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vse8.v v13,128(nominal_sp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v13,48(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v15,64(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v10,80(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v12,96(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v14,112(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v8,128(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v25,144(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v27,160(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v29,176(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v31,192(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v1,208(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v3,224(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v5,240(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v7,256(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v17,272(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v19,288(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v21,304(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v23,320(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v26,336(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v28,352(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v30,368(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v0,384(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v2,400(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v4,416(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v6,432(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v16,448(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v18,464(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v20,480(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v22,496(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v24,512(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v9,528(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,544(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-544(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vse8.v v11,0(slot) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v13,-528(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vse8.v v13,128(slot) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v13,-512(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v15,-496(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v10,-480(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v12,-464(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v14,-448(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v8,-432(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v25,-416(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v27,-400(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v29,-384(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v31,-368(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v1,-352(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v3,-336(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v5,-320(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v7,-304(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v17,-288(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v19,-272(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v21,-256(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v23,-240(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v26,-224(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v28,-208(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v30,-192(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v0,-176(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v2,-160(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v4,-144(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v6,-128(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v16,-112(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v18,-96(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v20,-80(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v22,-64(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v24,-48(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v11,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v9,16(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v24,32(a0) #avl=16, #vtype=(e8, m1, ta, ma)
@@ -107,14 +107,14 @@ block0(
 ;   vse8.v v10,464(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v15,480(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,496(a0) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v13,128(nominal_sp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v13,128(slot) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,512(a0) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,0(nominal_sp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,0(slot) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v11,528(a0) #avl=16, #vtype=(e8, m1, ta, ma)
-;   add sp,+256
+;   addi sp,sp,256
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -126,76 +126,76 @@ block0(
 ;   addi sp, sp, -0x100
 ; block1: ; offset 0x14
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x110
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0xa7, 0x05, 0x01, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x120
 ;   .byte 0x87, 0x86, 0x0f, 0x02
 ;   addi t6, sp, 0x80
 ;   .byte 0xa7, 0x86, 0x0f, 0x02
-;   addi t6, s0, 0x30
+;   addi t6, sp, 0x130
 ;   .byte 0x87, 0x86, 0x0f, 0x02
-;   addi t6, s0, 0x40
+;   addi t6, sp, 0x140
 ;   .byte 0x87, 0x87, 0x0f, 0x02
-;   addi t6, s0, 0x50
+;   addi t6, sp, 0x150
 ;   .byte 0x07, 0x85, 0x0f, 0x02
-;   addi t6, s0, 0x60
+;   addi t6, sp, 0x160
 ;   .byte 0x07, 0x86, 0x0f, 0x02
-;   addi t6, s0, 0x70
+;   addi t6, sp, 0x170
 ;   .byte 0x07, 0x87, 0x0f, 0x02
-;   addi t6, s0, 0x80
+;   addi t6, sp, 0x180
 ;   .byte 0x07, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x90
+;   addi t6, sp, 0x190
 ;   .byte 0x87, 0x8c, 0x0f, 0x02
-;   addi t6, s0, 0xa0
+;   addi t6, sp, 0x1a0
 ;   .byte 0x87, 0x8d, 0x0f, 0x02
-;   addi t6, s0, 0xb0
+;   addi t6, sp, 0x1b0
 ;   .byte 0x87, 0x8e, 0x0f, 0x02
-;   addi t6, s0, 0xc0
+;   addi t6, sp, 0x1c0
 ;   .byte 0x87, 0x8f, 0x0f, 0x02
-;   addi t6, s0, 0xd0
+;   addi t6, sp, 0x1d0
 ;   .byte 0x87, 0x80, 0x0f, 0x02
-;   addi t6, s0, 0xe0
+;   addi t6, sp, 0x1e0
 ;   .byte 0x87, 0x81, 0x0f, 0x02
-;   addi t6, s0, 0xf0
+;   addi t6, sp, 0x1f0
 ;   .byte 0x87, 0x82, 0x0f, 0x02
-;   addi t6, s0, 0x100
+;   addi t6, sp, 0x200
 ;   .byte 0x87, 0x83, 0x0f, 0x02
-;   addi t6, s0, 0x110
+;   addi t6, sp, 0x210
 ;   .byte 0x87, 0x88, 0x0f, 0x02
-;   addi t6, s0, 0x120
+;   addi t6, sp, 0x220
 ;   .byte 0x87, 0x89, 0x0f, 0x02
-;   addi t6, s0, 0x130
+;   addi t6, sp, 0x230
 ;   .byte 0x87, 0x8a, 0x0f, 0x02
-;   addi t6, s0, 0x140
+;   addi t6, sp, 0x240
 ;   .byte 0x87, 0x8b, 0x0f, 0x02
-;   addi t6, s0, 0x150
+;   addi t6, sp, 0x250
 ;   .byte 0x07, 0x8d, 0x0f, 0x02
-;   addi t6, s0, 0x160
+;   addi t6, sp, 0x260
 ;   .byte 0x07, 0x8e, 0x0f, 0x02
-;   addi t6, s0, 0x170
+;   addi t6, sp, 0x270
 ;   .byte 0x07, 0x8f, 0x0f, 0x02
-;   addi t6, s0, 0x180
+;   addi t6, sp, 0x280
 ;   .byte 0x07, 0x80, 0x0f, 0x02
-;   addi t6, s0, 0x190
+;   addi t6, sp, 0x290
 ;   .byte 0x07, 0x81, 0x0f, 0x02
-;   addi t6, s0, 0x1a0
+;   addi t6, sp, 0x2a0
 ;   .byte 0x07, 0x82, 0x0f, 0x02
-;   addi t6, s0, 0x1b0
+;   addi t6, sp, 0x2b0
 ;   .byte 0x07, 0x83, 0x0f, 0x02
-;   addi t6, s0, 0x1c0
+;   addi t6, sp, 0x2c0
 ;   .byte 0x07, 0x88, 0x0f, 0x02
-;   addi t6, s0, 0x1d0
+;   addi t6, sp, 0x2d0
 ;   .byte 0x07, 0x89, 0x0f, 0x02
-;   addi t6, s0, 0x1e0
+;   addi t6, sp, 0x2e0
 ;   .byte 0x07, 0x8a, 0x0f, 0x02
-;   addi t6, s0, 0x1f0
+;   addi t6, sp, 0x2f0
 ;   .byte 0x07, 0x8b, 0x0f, 0x02
-;   addi t6, s0, 0x200
+;   addi t6, sp, 0x300
 ;   .byte 0x07, 0x8c, 0x0f, 0x02
-;   addi t6, s0, 0x210
+;   addi t6, sp, 0x310
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x220
+;   addi t6, sp, 0x320
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0xa7, 0x05, 0x05, 0x02
 ;   addi t6, a0, 0x10
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-avg_round.clif b/cranelift/filetests/filetests/isa/riscv64/simd-avg_round.clif
index 177fd2faf081..2a67e16ce043 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-avg_round.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-avg_round.clif
@@ -9,13 +9,13 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vand.vv v14,v9,v11 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vxor.vv v8,v9,v11 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vssrl.vi v10,v8,1 #avl=16, #vtype=(e8, m1, ta, ma)
@@ -23,7 +23,7 @@ block0(v0: i8x16, v1: i8x16):
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -34,9 +34,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x87, 0x95, 0x26
 ;   .byte 0x57, 0x84, 0x95, 0x2e
@@ -55,13 +55,13 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vand.vv v14,v9,v11 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vxor.vv v8,v9,v11 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vssrl.vi v10,v8,1 #avl=8, #vtype=(e16, m1, ta, ma)
@@ -69,7 +69,7 @@ block0(v0: i16x8, v1: i16x8):
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -80,9 +80,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x87, 0x95, 0x26
@@ -103,13 +103,13 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vand.vv v14,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vxor.vv v8,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vssrl.vi v10,v8,1 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -117,7 +117,7 @@ block0(v0: i32x4, v1: i32x4):
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -128,9 +128,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x26
@@ -151,13 +151,13 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vand.vv v14,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vxor.vv v8,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vssrl.vi v10,v8,1 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -165,7 +165,7 @@ block0(v0: i64x2, v1: i64x2):
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -176,9 +176,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x26
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-band.clif b/cranelift/filetests/filetests/isa/riscv64/simd-band.clif
index 1949e2e1f65d..291dac39a19c 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-band.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-band.clif
@@ -10,18 +10,18 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vand.vv v14,v9,v11 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,9 +32,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x87, 0x95, 0x26
 ;   .byte 0x27, 0x07, 0x05, 0x02
@@ -50,18 +50,18 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vand.vv v14,v9,v11 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -72,9 +72,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x87, 0x95, 0x26
@@ -92,18 +92,18 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vand.vv v14,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -114,9 +114,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x26
@@ -134,18 +134,18 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vand.vv v14,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -156,9 +156,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x26
@@ -178,17 +178,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vand.vi v12,v9,5 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -199,7 +199,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0xb6, 0x92, 0x26
 ;   .byte 0x27, 0x06, 0x05, 0x02
@@ -217,17 +217,17 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vand.vi v12,v9,-16 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -238,7 +238,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x36, 0x98, 0x26
@@ -258,17 +258,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vand.vi v12,v9,15 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -279,7 +279,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xb6, 0x97, 0x26
@@ -299,17 +299,17 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vand.vi v12,v9,-5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -320,7 +320,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb6, 0x9d, 0x26
@@ -339,17 +339,17 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vand.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -360,7 +360,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x46, 0x95, 0x26
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -377,17 +377,17 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vand.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -398,7 +398,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x46, 0x95, 0x26
@@ -417,17 +417,17 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vand.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -438,7 +438,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x26
@@ -457,17 +457,17 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vand.vx v13,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -478,7 +478,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x26
@@ -498,19 +498,19 @@ block0(v0: f32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   fmv.w.x fa1,a0
 ;   vfmv.v.f v15,fa1 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vand.vv v15,v9,v15 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v15,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -521,7 +521,7 @@ block0(v0: f32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   fmv.w.x fa1, a0
 ;   .byte 0x57, 0x70, 0x02, 0xcd
@@ -543,19 +543,19 @@ block0(v0: f64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   fmv.d.x fa1,a0
 ;   vfmv.v.f v15,fa1 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vand.vv v15,v9,v15 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v15,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -566,7 +566,7 @@ block0(v0: f64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   fmv.d.x fa1, a0
 ;   .byte 0x57, 0x70, 0x81, 0xcd
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-bitselect.clif b/cranelift/filetests/filetests/isa/riscv64/simd-bitselect.clif
index de99095ca401..96b265692972 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-bitselect.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-bitselect.clif
@@ -9,14 +9,14 @@ block0(v0: i64x2, v1: i64x2, v2: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v13,48(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-48(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v13,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vand.vv v8,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vnot.v v10,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vand.vv v12,v10,v13 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -24,7 +24,7 @@ block0(v0: i64x2, v1: i64x2, v2: i64x2):
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -35,11 +35,11 @@ block0(v0: i64x2, v1: i64x2, v2: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
-;   addi t6, s0, 0x30
+;   addi t6, sp, 0x30
 ;   .byte 0x87, 0x86, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x84, 0x95, 0x26
@@ -60,14 +60,14 @@ block0(v0: i32x4, v1: i32x4, v2: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v13,48(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-48(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v13,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vand.vv v8,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vnot.v v10,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vand.vv v12,v10,v13 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -75,7 +75,7 @@ block0(v0: i32x4, v1: i32x4, v2: i32x4):
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -86,11 +86,11 @@ block0(v0: i32x4, v1: i32x4, v2: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
-;   addi t6, s0, 0x30
+;   addi t6, sp, 0x30
 ;   .byte 0x87, 0x86, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x84, 0x95, 0x26
@@ -111,14 +111,14 @@ block0(v0: i16x8, v1: i16x8, v2: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v13,48(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-48(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v13,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vand.vv v8,v9,v11 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vnot.v v10,v9 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vand.vv v12,v10,v13 #avl=8, #vtype=(e16, m1, ta, ma)
@@ -126,7 +126,7 @@ block0(v0: i16x8, v1: i16x8, v2: i16x8):
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -137,11 +137,11 @@ block0(v0: i16x8, v1: i16x8, v2: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
-;   addi t6, s0, 0x30
+;   addi t6, sp, 0x30
 ;   .byte 0x87, 0x86, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x84, 0x95, 0x26
@@ -162,14 +162,14 @@ block0(v0: i8x16, v1: i8x16, v2: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v13,48(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-48(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v13,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vand.vv v8,v9,v11 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vnot.v v10,v9 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vand.vv v12,v10,v13 #avl=16, #vtype=(e8, m1, ta, ma)
@@ -177,7 +177,7 @@ block0(v0: i8x16, v1: i8x16, v2: i8x16):
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -188,11 +188,11 @@ block0(v0: i8x16, v1: i8x16, v2: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
-;   addi t6, s0, 0x30
+;   addi t6, sp, 0x30
 ;   .byte 0x87, 0x86, 0x0f, 0x02
 ;   .byte 0x57, 0x84, 0x95, 0x26
 ;   .byte 0x57, 0xb5, 0x9f, 0x2e
@@ -212,21 +212,21 @@ block0(v0: i64x2, v1: i64x2, v2: i64x2, v3: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v13,48(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v15,64(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-64(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-48(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v13,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v15,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmseq.vv v0,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vvm v12,v15,v13,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -237,13 +237,13 @@ block0(v0: i64x2, v1: i64x2, v2: i64x2, v3: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
-;   addi t6, s0, 0x30
+;   addi t6, sp, 0x30
 ;   .byte 0x87, 0x86, 0x0f, 0x02
-;   addi t6, s0, 0x40
+;   addi t6, sp, 0x40
 ;   .byte 0x87, 0x87, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x80, 0x95, 0x62
@@ -263,21 +263,21 @@ block0(v0: f64x2, v1: f64x2, v2: i64x2, v3: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v13,48(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v15,64(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-64(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-48(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v13,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v15,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfle.vv v0,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vvm v12,v15,v13,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -288,13 +288,13 @@ block0(v0: f64x2, v1: f64x2, v2: i64x2, v3: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
-;   addi t6, s0, 0x30
+;   addi t6, sp, 0x30
 ;   .byte 0x87, 0x86, 0x0f, 0x02
-;   addi t6, s0, 0x40
+;   addi t6, sp, 0x40
 ;   .byte 0x87, 0x87, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x90, 0x95, 0x66
@@ -315,21 +315,21 @@ block0(v0: f64x2, v1: f64x2, v2: f64x2, v3: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v13,48(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v15,64(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-64(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-48(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v13,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v15,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfle.vv v0,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vvm v12,v15,v13,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -340,13 +340,13 @@ block0(v0: f64x2, v1: f64x2, v2: f64x2, v3: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
-;   addi t6, s0, 0x30
+;   addi t6, sp, 0x30
 ;   .byte 0x87, 0x86, 0x0f, 0x02
-;   addi t6, s0, 0x40
+;   addi t6, sp, 0x40
 ;   .byte 0x87, 0x87, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x90, 0x95, 0x66
@@ -367,21 +367,21 @@ block0(v0: i64x2, v1: i64x2, v2: f64x2, v3: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v13,48(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v15,64(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-64(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-48(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v13,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v15,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmseq.vv v0,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vvm v12,v15,v13,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -392,13 +392,13 @@ block0(v0: i64x2, v1: i64x2, v2: f64x2, v3: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
-;   addi t6, s0, 0x30
+;   addi t6, sp, 0x30
 ;   .byte 0x87, 0x86, 0x0f, 0x02
-;   addi t6, s0, 0x40
+;   addi t6, sp, 0x40
 ;   .byte 0x87, 0x87, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x80, 0x95, 0x62
@@ -410,3 +410,115 @@ block0(v0: i64x2, v1: i64x2, v2: f64x2, v3: f64x2):
 ;   addi sp, sp, 0x10
 ;   ret
 
+function %bitselect_i8x16_fcmp_f64x2(i8x16) -> i8x16 fast {
+    const0 = 0x00000000000000000000000000000000
+
+block0(v0: i8x16):
+    v1 = bitcast.f64x2 little v0
+    v2 = fcmp eq v1, v1
+    v3 = bitcast.i8x16 little v2
+    v4 = vconst.i8x16 const0
+    v5 = bitselect.i8x16 v3, v0, v4
+    return v5
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+; block0:
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v14,[const(0)] #avl=16, #vtype=(e8, m1, ta, ma)
+;   vmfeq.vv v0,v9,v9 #avl=2, #vtype=(e64, m1, ta, ma)
+;   vmerge.vvm v15,v14,v9,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
+;   vse8.v v15,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+; block1: ; offset 0x10
+;   .byte 0x57, 0x70, 0x08, 0xcc
+;   addi t6, sp, 0x10
+;   .byte 0x87, 0x84, 0x0f, 0x02
+;   auipc t6, 0
+;   addi t6, t6, 0x34
+;   .byte 0x07, 0x87, 0x0f, 0x02
+;   .byte 0x57, 0x70, 0x81, 0xcd
+;   .byte 0x57, 0x90, 0x94, 0x62
+;   .byte 0xd7, 0x87, 0xe4, 0x5c
+;   .byte 0x57, 0x70, 0x08, 0xcc
+;   .byte 0xa7, 0x07, 0x05, 0x02
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   ret
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   .byte 0x00, 0x00, 0x00, 0x00
+
+function %bitselect_i8x16_icmp_i64x2(i8x16) -> i8x16 fast {
+    const0 = 0x00000000000000000000000000000000
+
+block0(v0: i8x16):
+    v1 = bitcast.i64x2 little v0
+    v2 = icmp eq v1, v1
+    v3 = bitcast.i8x16 little v2
+    v4 = vconst.i8x16 const0
+    v5 = bitselect.i8x16 v3, v0, v4
+    return v5
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+; block0:
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v14,[const(0)] #avl=16, #vtype=(e8, m1, ta, ma)
+;   vmseq.vv v0,v9,v9 #avl=2, #vtype=(e64, m1, ta, ma)
+;   vmerge.vvm v15,v14,v9,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
+;   vse8.v v15,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+; block1: ; offset 0x10
+;   .byte 0x57, 0x70, 0x08, 0xcc
+;   addi t6, sp, 0x10
+;   .byte 0x87, 0x84, 0x0f, 0x02
+;   auipc t6, 0
+;   addi t6, t6, 0x34
+;   .byte 0x07, 0x87, 0x0f, 0x02
+;   .byte 0x57, 0x70, 0x81, 0xcd
+;   .byte 0x57, 0x80, 0x94, 0x62
+;   .byte 0xd7, 0x87, 0xe4, 0x5c
+;   .byte 0x57, 0x70, 0x08, 0xcc
+;   .byte 0xa7, 0x07, 0x05, 0x02
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   ret
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   .byte 0x00, 0x00, 0x00, 0x00
+;   .byte 0x00, 0x00, 0x00, 0x00
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-bnot.clif b/cranelift/filetests/filetests/isa/riscv64/simd-bnot.clif
index 3f68009af0a4..b51d67acaa9b 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-bnot.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-bnot.clif
@@ -10,17 +10,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vnot.v v12,v9 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -31,7 +31,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0xb6, 0x9f, 0x2e
 ;   .byte 0x27, 0x06, 0x05, 0x02
@@ -47,17 +47,17 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vnot.v v12,v9 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -68,7 +68,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0xb6, 0x9f, 0x2e
@@ -86,17 +86,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vnot.v v12,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -107,7 +107,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xb6, 0x9f, 0x2e
@@ -125,17 +125,17 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vnot.v v12,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -146,7 +146,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb6, 0x9f, 0x2e
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-bor.clif b/cranelift/filetests/filetests/isa/riscv64/simd-bor.clif
index 0dfec3f9a0ab..ada66286cbf0 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-bor.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-bor.clif
@@ -10,18 +10,18 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vor.vv v14,v9,v11 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,9 +32,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x87, 0x95, 0x2a
 ;   .byte 0x27, 0x07, 0x05, 0x02
@@ -50,18 +50,18 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vor.vv v14,v9,v11 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -72,9 +72,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x87, 0x95, 0x2a
@@ -92,18 +92,18 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vor.vv v14,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -114,9 +114,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x2a
@@ -134,18 +134,18 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vor.vv v14,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -156,9 +156,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x2a
@@ -178,17 +178,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vor.vi v12,v9,5 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -199,7 +199,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0xb6, 0x92, 0x2a
 ;   .byte 0x27, 0x06, 0x05, 0x02
@@ -217,17 +217,17 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vor.vi v12,v9,-16 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -238,7 +238,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x36, 0x98, 0x2a
@@ -258,17 +258,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vor.vi v12,v9,15 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -279,7 +279,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xb6, 0x97, 0x2a
@@ -299,17 +299,17 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vor.vi v12,v9,-5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -320,7 +320,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb6, 0x9d, 0x2a
@@ -339,17 +339,17 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vor.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -360,7 +360,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x46, 0x95, 0x2a
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -377,17 +377,17 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vor.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -398,7 +398,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x46, 0x95, 0x2a
@@ -417,17 +417,17 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vor.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -438,7 +438,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x2a
@@ -457,17 +457,17 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vor.vx v13,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -478,7 +478,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x2a
@@ -498,19 +498,19 @@ block0(v0: f32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   fmv.w.x fa1,a0
 ;   vfmv.v.f v15,fa1 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vor.vv v15,v9,v15 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v15,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -521,7 +521,7 @@ block0(v0: f32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   fmv.w.x fa1, a0
 ;   .byte 0x57, 0x70, 0x02, 0xcd
@@ -543,19 +543,19 @@ block0(v0: f64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   fmv.d.x fa1,a0
 ;   vfmv.v.f v15,fa1 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vor.vv v15,v9,v15 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v15,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -566,7 +566,7 @@ block0(v0: f64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   fmv.d.x fa1, a0
 ;   .byte 0x57, 0x70, 0x81, 0xcd
@@ -587,17 +587,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vor.vi v12,v9,5 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -608,7 +608,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0xb6, 0x92, 0x2a
 ;   .byte 0x27, 0x06, 0x05, 0x02
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-bxor.clif b/cranelift/filetests/filetests/isa/riscv64/simd-bxor.clif
index f8bb79bc8cb0..9abaad32e6fc 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-bxor.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-bxor.clif
@@ -10,18 +10,18 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vxor.vv v14,v9,v11 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,9 +32,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x87, 0x95, 0x2e
 ;   .byte 0x27, 0x07, 0x05, 0x02
@@ -50,18 +50,18 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vxor.vv v14,v9,v11 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -72,9 +72,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x87, 0x95, 0x2e
@@ -92,18 +92,18 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vxor.vv v14,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -114,9 +114,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x2e
@@ -134,18 +134,18 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vxor.vv v14,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -156,9 +156,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x2e
@@ -178,17 +178,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vxor.vi v12,v9,5 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -199,7 +199,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0xb6, 0x92, 0x2e
 ;   .byte 0x27, 0x06, 0x05, 0x02
@@ -217,17 +217,17 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vxor.vi v12,v9,-16 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -238,7 +238,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x36, 0x98, 0x2e
@@ -258,17 +258,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vxor.vi v12,v9,15 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -279,7 +279,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xb6, 0x97, 0x2e
@@ -299,17 +299,17 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vxor.vi v12,v9,-5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -320,7 +320,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb6, 0x9d, 0x2e
@@ -339,17 +339,17 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vxor.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -360,7 +360,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x46, 0x95, 0x2e
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -377,17 +377,17 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vxor.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -398,7 +398,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x46, 0x95, 0x2e
@@ -417,17 +417,17 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vxor.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -438,7 +438,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x2e
@@ -457,17 +457,17 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vxor.vx v13,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -478,7 +478,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x2e
@@ -498,19 +498,19 @@ block0(v0: f32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   fmv.w.x fa1,a0
 ;   vfmv.v.f v15,fa1 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vxor.vv v15,v9,v15 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v15,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -521,7 +521,7 @@ block0(v0: f32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   fmv.w.x fa1, a0
 ;   .byte 0x57, 0x70, 0x02, 0xcd
@@ -543,19 +543,19 @@ block0(v0: f64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   fmv.d.x fa1,a0
 ;   vfmv.v.f v15,fa1 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vxor.vv v15,v9,v15 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v15,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -566,7 +566,7 @@ block0(v0: f64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   fmv.d.x fa1, a0
 ;   .byte 0x57, 0x70, 0x81, 0xcd
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-ceil.clif b/cranelift/filetests/filetests/isa/riscv64/simd-ceil.clif
index 41b2b9c902c0..1ab85de31f32 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-ceil.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-ceil.clif
@@ -10,12 +10,12 @@ block0(v0: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfabs.v v12,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   lui a1,307200
 ;   fmv.w.x fa2,a1
@@ -31,7 +31,7 @@ block0(v0: f32x4):
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -42,7 +42,7 @@ block0(v0: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x96, 0x94, 0x2a
@@ -71,12 +71,12 @@ block0(v0: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfabs.v v12,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   lui a1,1075
 ;   slli a2,a1,40
@@ -93,7 +93,7 @@ block0(v0: f64x2):
 ;   vse8.v v11,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -104,7 +104,7 @@ block0(v0: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x96, 0x94, 0x2a
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-extractlane.clif b/cranelift/filetests/filetests/isa/riscv64/simd-extractlane.clif
index 9909d80ef20a..95083cea7dc7 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-extractlane.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-extractlane.clif
@@ -9,16 +9,16 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v8,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v8,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.x.s a0,v8 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -29,7 +29,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x25, 0x80, 0x42
 ;   ld ra, 8(sp)
@@ -44,16 +44,16 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v8,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v8,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.x.s a0,v8 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -64,7 +64,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x25, 0x80, 0x42
@@ -80,16 +80,16 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v8,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v8,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.x.s a0,v8 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -100,7 +100,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x25, 0x80, 0x42
@@ -116,16 +116,16 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v8,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v8,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.x.s a0,v8 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -136,7 +136,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x25, 0x80, 0x42
@@ -152,16 +152,16 @@ block0(v0: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v8,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v8,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfmv.f.s fa0,v8 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -172,7 +172,7 @@ block0(v0: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x15, 0x80, 0x42
@@ -188,16 +188,16 @@ block0(v0: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v8,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v8,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfmv.f.s fa0,v8 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -208,7 +208,7 @@ block0(v0: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x15, 0x80, 0x42
@@ -224,17 +224,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v8,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v8,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v10,v8,1 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.x.s a0,v10 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -245,7 +245,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0xb5, 0x80, 0x3e
 ;   .byte 0x57, 0x25, 0xa0, 0x42
@@ -261,17 +261,17 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v8,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v8,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v10,v8,1 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vmv.x.s a0,v10 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -282,7 +282,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0xb5, 0x80, 0x3e
@@ -299,17 +299,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v8,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v8,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v10,v8,1 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.x.s a0,v10 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -320,7 +320,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xb5, 0x80, 0x3e
@@ -337,17 +337,17 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v8,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v8,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v10,v8,1 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.x.s a0,v10 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -358,7 +358,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb5, 0x80, 0x3e
@@ -375,17 +375,17 @@ block0(v0: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v8,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v8,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v10,v8,1 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vfmv.f.s fa0,v10 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -396,7 +396,7 @@ block0(v0: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xb5, 0x80, 0x3e
@@ -413,17 +413,17 @@ block0(v0: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v8,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v8,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v10,v8,1 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vfmv.f.s fa0,v10 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -434,7 +434,7 @@ block0(v0: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb5, 0x80, 0x3e
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fabs.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fabs.clif
index 00b86eb6435c..0aa10f170557 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fabs.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fabs.clif
@@ -10,17 +10,17 @@ block0(v0: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfabs.v v12,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -31,7 +31,7 @@ block0(v0: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x96, 0x94, 0x2a
@@ -49,17 +49,17 @@ block0(v0: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfabs.v v12,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -70,7 +70,7 @@ block0(v0: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x96, 0x94, 0x2a
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fadd.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fadd.clif
index 05fda7b7bda4..e2db637dbb8f 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fadd.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fadd.clif
@@ -10,18 +10,18 @@ block0(v0: f32x4, v1: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfadd.vv v14,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,9 +32,9 @@ block0(v0: f32x4, v1: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x97, 0x95, 0x02
@@ -53,17 +53,17 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfadd.vf v13,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -74,7 +74,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x02
@@ -93,17 +93,17 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfadd.vf v13,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -114,7 +114,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x02
@@ -132,18 +132,18 @@ block0(v0: f64x2, v1: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfadd.vv v14,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -154,9 +154,9 @@ block0(v0: f64x2, v1: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x97, 0x95, 0x02
@@ -175,17 +175,17 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfadd.vf v13,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -196,7 +196,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x02
@@ -215,17 +215,17 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfadd.vf v13,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -236,7 +236,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x02
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-eq.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-eq.clif
index 390dd4222088..85d502b3f44e 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-eq.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-eq.clif
@@ -9,20 +9,20 @@ block0(v0: f32x4, v1: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfeq.vv v0,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -33,9 +33,9 @@ block0(v0: f32x4, v1: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x90, 0x95, 0x62
@@ -56,19 +56,19 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfeq.vf v0,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -79,7 +79,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x50, 0x95, 0x62
@@ -100,19 +100,19 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfeq.vf v0,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -123,7 +123,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x50, 0x95, 0x62
@@ -143,20 +143,20 @@ block0(v0: f64x2, v1: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfeq.vv v0,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -167,9 +167,9 @@ block0(v0: f64x2, v1: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x90, 0x95, 0x62
@@ -190,19 +190,19 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfeq.vf v0,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -213,7 +213,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x50, 0x95, 0x62
@@ -234,19 +234,19 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfeq.vf v0,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -257,7 +257,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x50, 0x95, 0x62
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-ge.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-ge.clif
index a3065e0c635f..60003504d67b 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-ge.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-ge.clif
@@ -9,20 +9,20 @@ block0(v0: f32x4, v1: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfle.vv v0,v11,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -33,9 +33,9 @@ block0(v0: f32x4, v1: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x90, 0xb4, 0x66
@@ -56,19 +56,19 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfge.vf v0,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -79,7 +79,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x50, 0x95, 0x7e
@@ -100,19 +100,19 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfle.vf v0,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -123,7 +123,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x50, 0x95, 0x66
@@ -143,20 +143,20 @@ block0(v0: f64x2, v1: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfle.vv v0,v11,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -167,9 +167,9 @@ block0(v0: f64x2, v1: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x90, 0xb4, 0x66
@@ -190,19 +190,19 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfge.vf v0,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -213,7 +213,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x50, 0x95, 0x7e
@@ -234,19 +234,19 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfle.vf v0,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -257,7 +257,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x50, 0x95, 0x66
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-gt.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-gt.clif
index c32517bacd53..4665210832e9 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-gt.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-gt.clif
@@ -9,20 +9,20 @@ block0(v0: f32x4, v1: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmflt.vv v0,v11,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -33,9 +33,9 @@ block0(v0: f32x4, v1: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x90, 0xb4, 0x6e
@@ -56,19 +56,19 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfgt.vf v0,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -79,7 +79,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x50, 0x95, 0x76
@@ -100,19 +100,19 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmflt.vf v0,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -123,7 +123,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x50, 0x95, 0x6e
@@ -143,20 +143,20 @@ block0(v0: f64x2, v1: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmflt.vv v0,v11,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -167,9 +167,9 @@ block0(v0: f64x2, v1: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x90, 0xb4, 0x6e
@@ -190,19 +190,19 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfgt.vf v0,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -213,7 +213,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x50, 0x95, 0x76
@@ -234,19 +234,19 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmflt.vf v0,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -257,7 +257,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x50, 0x95, 0x6e
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-le.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-le.clif
index 46b36e8cf4fc..d75e9843c02b 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-le.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-le.clif
@@ -9,20 +9,20 @@ block0(v0: f32x4, v1: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfle.vv v0,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -33,9 +33,9 @@ block0(v0: f32x4, v1: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x90, 0x95, 0x66
@@ -56,19 +56,19 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfle.vf v0,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -79,7 +79,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x50, 0x95, 0x66
@@ -100,19 +100,19 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfge.vf v0,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -123,7 +123,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x50, 0x95, 0x7e
@@ -143,20 +143,20 @@ block0(v0: f64x2, v1: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfle.vv v0,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -167,9 +167,9 @@ block0(v0: f64x2, v1: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x90, 0x95, 0x66
@@ -190,19 +190,19 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfle.vf v0,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -213,7 +213,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x50, 0x95, 0x66
@@ -234,19 +234,19 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfge.vf v0,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -257,7 +257,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x50, 0x95, 0x7e
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-lt.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-lt.clif
index 7f8598a6f7a3..8b95737e1523 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-lt.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-lt.clif
@@ -9,20 +9,20 @@ block0(v0: f32x4, v1: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmflt.vv v0,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -33,9 +33,9 @@ block0(v0: f32x4, v1: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x90, 0x95, 0x6e
@@ -56,19 +56,19 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmflt.vf v0,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -79,7 +79,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x50, 0x95, 0x6e
@@ -100,19 +100,19 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfgt.vf v0,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -123,7 +123,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x50, 0x95, 0x76
@@ -143,20 +143,20 @@ block0(v0: f64x2, v1: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmflt.vv v0,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -167,9 +167,9 @@ block0(v0: f64x2, v1: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x90, 0x95, 0x6e
@@ -190,19 +190,19 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmflt.vf v0,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -213,7 +213,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x50, 0x95, 0x6e
@@ -234,19 +234,19 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfgt.vf v0,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -257,7 +257,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x50, 0x95, 0x76
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-ne.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-ne.clif
index a4de7165366c..d8cfc7019e0f 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-ne.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-ne.clif
@@ -9,20 +9,20 @@ block0(v0: f32x4, v1: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfne.vv v0,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -33,9 +33,9 @@ block0(v0: f32x4, v1: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x90, 0x95, 0x72
@@ -56,19 +56,19 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfne.vf v0,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -79,7 +79,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x50, 0x95, 0x72
@@ -100,19 +100,19 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfne.vf v0,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -123,7 +123,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x50, 0x95, 0x72
@@ -143,20 +143,20 @@ block0(v0: f64x2, v1: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfne.vv v0,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -167,9 +167,9 @@ block0(v0: f64x2, v1: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x90, 0x95, 0x72
@@ -190,19 +190,19 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfne.vf v0,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -213,7 +213,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x50, 0x95, 0x72
@@ -234,19 +234,19 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfne.vf v0,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -257,7 +257,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x50, 0x95, 0x72
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-one.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-one.clif
index 1e7133dc3122..47a72759f0bc 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-one.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-one.clif
@@ -9,13 +9,13 @@ block0(v0: f32x4, v1: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmflt.vv v14,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmflt.vv v8,v11,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmor.mm v0,v14,v8 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -24,7 +24,7 @@ block0(v0: f32x4, v1: f32x4):
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -35,9 +35,9 @@ block0(v0: f32x4, v1: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x97, 0x95, 0x6e
@@ -60,12 +60,12 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmflt.vf v13,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmfgt.vf v15,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmor.mm v0,v13,v15 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -74,7 +74,7 @@ block0(v0: f32x4, v1: f32):
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -85,7 +85,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x6e
@@ -108,12 +108,12 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfgt.vf v13,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmflt.vf v15,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmor.mm v0,v13,v15 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -122,7 +122,7 @@ block0(v0: f32x4, v1: f32):
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -133,7 +133,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x76
@@ -155,13 +155,13 @@ block0(v0: f64x2, v1: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmflt.vv v14,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmflt.vv v8,v11,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmor.mm v0,v14,v8 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -170,7 +170,7 @@ block0(v0: f64x2, v1: f64x2):
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -181,9 +181,9 @@ block0(v0: f64x2, v1: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x97, 0x95, 0x6e
@@ -206,12 +206,12 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmflt.vf v13,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmfgt.vf v15,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmor.mm v0,v13,v15 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -220,7 +220,7 @@ block0(v0: f64x2, v1: f64):
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -231,7 +231,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x6e
@@ -254,12 +254,12 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfgt.vf v13,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmflt.vf v15,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmor.mm v0,v13,v15 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -268,7 +268,7 @@ block0(v0: f64x2, v1: f64):
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -279,7 +279,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x76
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-ord.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-ord.clif
index bb205fa4bb15..9d0afa5400bb 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-ord.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-ord.clif
@@ -9,13 +9,13 @@ block0(v0: f32x4, v1: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfeq.vv v14,v9,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmfeq.vv v8,v11,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmand.mm v0,v14,v8 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -24,7 +24,7 @@ block0(v0: f32x4, v1: f32x4):
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -35,9 +35,9 @@ block0(v0: f32x4, v1: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x97, 0x94, 0x62
@@ -60,12 +60,12 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfmv.v.f v10,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmfeq.vv v14,v9,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmfeq.vf v8,v10,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -75,7 +75,7 @@ block0(v0: f32x4, v1: f32):
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -86,7 +86,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x55, 0x05, 0x5e
@@ -110,12 +110,12 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfmv.v.f v10,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmfeq.vf v14,v10,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmfeq.vv v8,v9,v9 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -125,7 +125,7 @@ block0(v0: f32x4, v1: f32):
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -136,7 +136,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x55, 0x05, 0x5e
@@ -159,13 +159,13 @@ block0(v0: f64x2, v1: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfeq.vv v14,v9,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmfeq.vv v8,v11,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmand.mm v0,v14,v8 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -174,7 +174,7 @@ block0(v0: f64x2, v1: f64x2):
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -185,9 +185,9 @@ block0(v0: f64x2, v1: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x97, 0x94, 0x62
@@ -210,12 +210,12 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfmv.v.f v10,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmfeq.vv v14,v9,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmfeq.vf v8,v10,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -225,7 +225,7 @@ block0(v0: f64x2, v1: f64):
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -236,7 +236,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x55, 0x05, 0x5e
@@ -260,12 +260,12 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfmv.v.f v10,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmfeq.vf v14,v10,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmfeq.vv v8,v9,v9 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -275,7 +275,7 @@ block0(v0: f64x2, v1: f64):
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -286,7 +286,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x55, 0x05, 0x5e
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-ueq.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-ueq.clif
index d72aa86b8680..ee0a81e5ff82 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-ueq.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-ueq.clif
@@ -9,13 +9,13 @@ block0(v0: f32x4, v1: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmflt.vv v14,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmflt.vv v8,v11,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmnor.mm v0,v14,v8 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -24,7 +24,7 @@ block0(v0: f32x4, v1: f32x4):
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -35,9 +35,9 @@ block0(v0: f32x4, v1: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x97, 0x95, 0x6e
@@ -60,12 +60,12 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmflt.vf v13,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmfgt.vf v15,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmnor.mm v0,v13,v15 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -74,7 +74,7 @@ block0(v0: f32x4, v1: f32):
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -85,7 +85,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x6e
@@ -108,12 +108,12 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfgt.vf v13,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmflt.vf v15,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmnor.mm v0,v13,v15 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -122,7 +122,7 @@ block0(v0: f32x4, v1: f32):
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -133,7 +133,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x76
@@ -155,13 +155,13 @@ block0(v0: f64x2, v1: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmflt.vv v14,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmflt.vv v8,v11,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmnor.mm v0,v14,v8 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -170,7 +170,7 @@ block0(v0: f64x2, v1: f64x2):
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -181,9 +181,9 @@ block0(v0: f64x2, v1: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x97, 0x95, 0x6e
@@ -206,12 +206,12 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmflt.vf v13,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmfgt.vf v15,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmnor.mm v0,v13,v15 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -220,7 +220,7 @@ block0(v0: f64x2, v1: f64):
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -231,7 +231,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x6e
@@ -254,12 +254,12 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfgt.vf v13,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmflt.vf v15,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmnor.mm v0,v13,v15 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -268,7 +268,7 @@ block0(v0: f64x2, v1: f64):
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -279,7 +279,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x76
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-uge.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-uge.clif
index ea013e1cc11e..17daafb9b404 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-uge.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-uge.clif
@@ -9,13 +9,13 @@ block0(v0: f32x4, v1: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmflt.vv v14,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmnot.m v0,v14 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v10,0 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -23,7 +23,7 @@ block0(v0: f32x4, v1: f32x4):
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -34,9 +34,9 @@ block0(v0: f32x4, v1: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x97, 0x95, 0x6e
@@ -58,12 +58,12 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmflt.vf v13,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmnot.m v0,v13 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v9,0 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -71,7 +71,7 @@ block0(v0: f32x4, v1: f32):
 ;   vse8.v v11,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -82,7 +82,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x6e
@@ -104,12 +104,12 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfgt.vf v13,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmnot.m v0,v13 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v9,0 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -117,7 +117,7 @@ block0(v0: f32x4, v1: f32):
 ;   vse8.v v11,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -128,7 +128,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x76
@@ -149,13 +149,13 @@ block0(v0: f64x2, v1: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmflt.vv v14,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmnot.m v0,v14 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v10,0 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -163,7 +163,7 @@ block0(v0: f64x2, v1: f64x2):
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -174,9 +174,9 @@ block0(v0: f64x2, v1: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x97, 0x95, 0x6e
@@ -198,12 +198,12 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmflt.vf v13,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmnot.m v0,v13 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v9,0 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -211,7 +211,7 @@ block0(v0: f64x2, v1: f64):
 ;   vse8.v v11,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -222,7 +222,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x6e
@@ -244,12 +244,12 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfgt.vf v13,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmnot.m v0,v13 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v9,0 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -257,7 +257,7 @@ block0(v0: f64x2, v1: f64):
 ;   vse8.v v11,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -268,7 +268,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x76
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-ugt.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-ugt.clif
index 4d4b66e0d492..78e03965d0ae 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-ugt.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-ugt.clif
@@ -9,13 +9,13 @@ block0(v0: f32x4, v1: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfle.vv v14,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmnot.m v0,v14 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v10,0 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -23,7 +23,7 @@ block0(v0: f32x4, v1: f32x4):
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -34,9 +34,9 @@ block0(v0: f32x4, v1: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x97, 0x95, 0x66
@@ -58,12 +58,12 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfle.vf v13,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmnot.m v0,v13 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v9,0 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -71,7 +71,7 @@ block0(v0: f32x4, v1: f32):
 ;   vse8.v v11,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -82,7 +82,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x66
@@ -104,12 +104,12 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfge.vf v13,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmnot.m v0,v13 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v9,0 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -117,7 +117,7 @@ block0(v0: f32x4, v1: f32):
 ;   vse8.v v11,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -128,7 +128,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x7e
@@ -149,13 +149,13 @@ block0(v0: f64x2, v1: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfle.vv v14,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmnot.m v0,v14 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v10,0 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -163,7 +163,7 @@ block0(v0: f64x2, v1: f64x2):
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -174,9 +174,9 @@ block0(v0: f64x2, v1: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x97, 0x95, 0x66
@@ -198,12 +198,12 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfle.vf v13,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmnot.m v0,v13 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v9,0 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -211,7 +211,7 @@ block0(v0: f64x2, v1: f64):
 ;   vse8.v v11,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -222,7 +222,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x66
@@ -244,12 +244,12 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfge.vf v13,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmnot.m v0,v13 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v9,0 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -257,7 +257,7 @@ block0(v0: f64x2, v1: f64):
 ;   vse8.v v11,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -268,7 +268,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x7e
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-ule.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-ule.clif
index f681473ba5cf..53627613852a 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-ule.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-ule.clif
@@ -9,13 +9,13 @@ block0(v0: f32x4, v1: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmflt.vv v14,v11,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmnot.m v0,v14 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v10,0 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -23,7 +23,7 @@ block0(v0: f32x4, v1: f32x4):
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -34,9 +34,9 @@ block0(v0: f32x4, v1: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x97, 0xb4, 0x6e
@@ -58,12 +58,12 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfgt.vf v13,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmnot.m v0,v13 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v9,0 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -71,7 +71,7 @@ block0(v0: f32x4, v1: f32):
 ;   vse8.v v11,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -82,7 +82,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x76
@@ -104,12 +104,12 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmflt.vf v13,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmnot.m v0,v13 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v9,0 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -117,7 +117,7 @@ block0(v0: f32x4, v1: f32):
 ;   vse8.v v11,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -128,7 +128,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x6e
@@ -149,13 +149,13 @@ block0(v0: f64x2, v1: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmflt.vv v14,v11,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmnot.m v0,v14 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v10,0 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -163,7 +163,7 @@ block0(v0: f64x2, v1: f64x2):
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -174,9 +174,9 @@ block0(v0: f64x2, v1: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x97, 0xb4, 0x6e
@@ -198,12 +198,12 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfgt.vf v13,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmnot.m v0,v13 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v9,0 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -211,7 +211,7 @@ block0(v0: f64x2, v1: f64):
 ;   vse8.v v11,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -222,7 +222,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x76
@@ -244,12 +244,12 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmflt.vf v13,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmnot.m v0,v13 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v9,0 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -257,7 +257,7 @@ block0(v0: f64x2, v1: f64):
 ;   vse8.v v11,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -268,7 +268,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x6e
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-ult.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-ult.clif
index 55f1717560f4..b06f412010d4 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-ult.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-ult.clif
@@ -9,13 +9,13 @@ block0(v0: f32x4, v1: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfle.vv v14,v11,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmnot.m v0,v14 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v10,0 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -23,7 +23,7 @@ block0(v0: f32x4, v1: f32x4):
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -34,9 +34,9 @@ block0(v0: f32x4, v1: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x97, 0xb4, 0x66
@@ -58,12 +58,12 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfge.vf v13,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmnot.m v0,v13 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v9,0 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -71,7 +71,7 @@ block0(v0: f32x4, v1: f32):
 ;   vse8.v v11,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -82,7 +82,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x7e
@@ -104,12 +104,12 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfle.vf v13,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmnot.m v0,v13 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v9,0 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -117,7 +117,7 @@ block0(v0: f32x4, v1: f32):
 ;   vse8.v v11,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -128,7 +128,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x66
@@ -149,13 +149,13 @@ block0(v0: f64x2, v1: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfle.vv v14,v11,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmnot.m v0,v14 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v10,0 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -163,7 +163,7 @@ block0(v0: f64x2, v1: f64x2):
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -174,9 +174,9 @@ block0(v0: f64x2, v1: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x97, 0xb4, 0x66
@@ -198,12 +198,12 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfge.vf v13,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmnot.m v0,v13 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v9,0 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -211,7 +211,7 @@ block0(v0: f64x2, v1: f64):
 ;   vse8.v v11,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -222,7 +222,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x7e
@@ -244,12 +244,12 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfle.vf v13,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmnot.m v0,v13 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v9,0 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -257,7 +257,7 @@ block0(v0: f64x2, v1: f64):
 ;   vse8.v v11,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -268,7 +268,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x66
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-uno.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-uno.clif
index 3e53a4b08a1b..8406ec2a45f5 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-uno.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fcmp-uno.clif
@@ -9,13 +9,13 @@ block0(v0: f32x4, v1: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfne.vv v14,v9,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmfne.vv v8,v11,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmor.mm v0,v14,v8 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -24,7 +24,7 @@ block0(v0: f32x4, v1: f32x4):
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -35,9 +35,9 @@ block0(v0: f32x4, v1: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x97, 0x94, 0x72
@@ -60,12 +60,12 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfmv.v.f v10,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmfne.vv v14,v9,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmfne.vf v8,v10,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -75,7 +75,7 @@ block0(v0: f32x4, v1: f32):
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -86,7 +86,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x55, 0x05, 0x5e
@@ -110,12 +110,12 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfmv.v.f v10,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmfne.vf v14,v10,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmfne.vv v8,v9,v9 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -125,7 +125,7 @@ block0(v0: f32x4, v1: f32):
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -136,7 +136,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x55, 0x05, 0x5e
@@ -159,13 +159,13 @@ block0(v0: f64x2, v1: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfne.vv v14,v9,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmfne.vv v8,v11,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmor.mm v0,v14,v8 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -174,7 +174,7 @@ block0(v0: f64x2, v1: f64x2):
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -185,9 +185,9 @@ block0(v0: f64x2, v1: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x97, 0x94, 0x72
@@ -210,12 +210,12 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfmv.v.f v10,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmfne.vv v14,v9,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmfne.vf v8,v10,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -225,7 +225,7 @@ block0(v0: f64x2, v1: f64):
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -236,7 +236,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x55, 0x05, 0x5e
@@ -260,12 +260,12 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfmv.v.f v10,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmfne.vf v14,v10,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmfne.vv v8,v9,v9 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -275,7 +275,7 @@ block0(v0: f64x2, v1: f64):
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -286,7 +286,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x55, 0x05, 0x5e
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fcopysign.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fcopysign.clif
index e0713247ef11..40ffa16ed92d 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fcopysign.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fcopysign.clif
@@ -10,18 +10,18 @@ block0(v0: f32x4, v1: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfsgnj.vv v14,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,9 +32,9 @@ block0(v0: f32x4, v1: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x97, 0x95, 0x22
@@ -53,17 +53,17 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfsgnj.vf v13,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -74,7 +74,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x22
@@ -92,18 +92,18 @@ block0(v0: f64x2, v1: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfsgnj.vv v14,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -114,9 +114,9 @@ block0(v0: f64x2, v1: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x97, 0x95, 0x22
@@ -135,17 +135,17 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfsgnj.vf v13,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -156,7 +156,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x22
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fcvt-from-sint.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fcvt-from-sint.clif
index f147616965cc..581e9f781c3b 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fcvt-from-sint.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fcvt-from-sint.clif
@@ -9,17 +9,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfcvt.f.x.v v12,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -30,7 +30,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x96, 0x91, 0x4a
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fcvt-from-uint.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fcvt-from-uint.clif
index 7c9d707b135b..df45eb1d2eb4 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fcvt-from-uint.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fcvt-from-uint.clif
@@ -9,17 +9,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfcvt.f.xu.v v12,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -30,7 +30,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x16, 0x91, 0x4a
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fcvt-to-sint-sat.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fcvt-to-sint-sat.clif
index 486b19c7aff3..5beaf7b97d84 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fcvt-to-sint-sat.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fcvt-to-sint-sat.clif
@@ -9,19 +9,19 @@ block0(v0:f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfne.vv v0,v9,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vfcvt.rtz.x.f.v v14,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v8,v14,0,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,7 +32,7 @@ block0(v0:f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x90, 0x94, 0x72
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fcvt-to-uint-sat.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fcvt-to-uint-sat.clif
index 28c2054a8f8c..8897a874c461 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fcvt-to-uint-sat.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fcvt-to-uint-sat.clif
@@ -9,19 +9,19 @@ block0(v0:f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfne.vv v0,v9,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vfcvt.rtz.xu.f.v v14,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v8,v14,0,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,7 +32,7 @@ block0(v0:f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x90, 0x94, 0x72
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fdiv.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fdiv.clif
index d8697b6d92bc..a7886d2cace3 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fdiv.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fdiv.clif
@@ -10,18 +10,18 @@ block0(v0: f32x4, v1: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfdiv.vv v14,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,9 +32,9 @@ block0(v0: f32x4, v1: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x97, 0x95, 0x82
@@ -53,17 +53,17 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfdiv.vf v13,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -74,7 +74,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x82
@@ -93,17 +93,17 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfrdiv.vf v13,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -114,7 +114,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x86
@@ -132,18 +132,18 @@ block0(v0: f64x2, v1: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfdiv.vv v14,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -154,9 +154,9 @@ block0(v0: f64x2, v1: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x97, 0x95, 0x82
@@ -175,17 +175,17 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfdiv.vf v13,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -196,7 +196,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x82
@@ -215,17 +215,17 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfrdiv.vf v13,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -236,7 +236,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x86
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-floor.clif b/cranelift/filetests/filetests/isa/riscv64/simd-floor.clif
index 50b9cbde183a..e797aacde9c1 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-floor.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-floor.clif
@@ -10,12 +10,12 @@ block0(v0: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfabs.v v12,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   lui a1,307200
 ;   fmv.w.x fa2,a1
@@ -31,7 +31,7 @@ block0(v0: f32x4):
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -42,7 +42,7 @@ block0(v0: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x96, 0x94, 0x2a
@@ -71,12 +71,12 @@ block0(v0: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfabs.v v12,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   lui a1,1075
 ;   slli a2,a1,40
@@ -93,7 +93,7 @@ block0(v0: f64x2):
 ;   vse8.v v11,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -104,7 +104,7 @@ block0(v0: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x96, 0x94, 0x2a
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fma.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fma.clif
index 2c9e1f8e852c..313afba1a15d 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fma.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fma.clif
@@ -9,19 +9,19 @@ block0(v0: f64x2, v1: f64x2, v2: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v15,48(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-48(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v15,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfmacc.vv v15,v11,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v15,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,11 +32,11 @@ block0(v0: f64x2, v1: f64x2, v2: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
-;   addi t6, s0, 0x30
+;   addi t6, sp, 0x30
 ;   .byte 0x87, 0x87, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x97, 0xb4, 0xb2
@@ -55,18 +55,18 @@ block0(v0: f64, v1: f64x2, v2: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v10,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v14,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v10,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v14,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfmacc.vf v14,v10,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -77,9 +77,9 @@ block0(v0: f64, v1: f64x2, v2: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x85, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x07, 0x87, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x57, 0xa5, 0xb2
@@ -98,19 +98,19 @@ block0(v0: f64x2, v1: f64x2, v2: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v15,48(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-48(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v15,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfmsac.vv v15,v11,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v15,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -121,11 +121,11 @@ block0(v0: f64x2, v1: f64x2, v2: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
-;   addi t6, s0, 0x30
+;   addi t6, sp, 0x30
 ;   .byte 0x87, 0x87, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x97, 0xb4, 0xba
@@ -145,18 +145,18 @@ block0(v0: f64, v1: f64x2, v2: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v10,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v14,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v10,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v14,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfmsac.vf v14,v10,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -167,9 +167,9 @@ block0(v0: f64, v1: f64x2, v2: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x85, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x07, 0x87, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x57, 0xa5, 0xba
@@ -189,19 +189,19 @@ block0(v0: f64x2, v1: f64x2, v2: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v15,48(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-48(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v15,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfnmacc.vv v15,v11,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v15,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -212,11 +212,11 @@ block0(v0: f64x2, v1: f64x2, v2: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
-;   addi t6, s0, 0x30
+;   addi t6, sp, 0x30
 ;   .byte 0x87, 0x87, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x97, 0xb4, 0xb6
@@ -237,18 +237,18 @@ block0(v0: f64, v1: f64x2, v2: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v10,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v14,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v10,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v14,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfnmacc.vf v14,v10,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -259,9 +259,9 @@ block0(v0: f64, v1: f64x2, v2: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x85, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x07, 0x87, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x57, 0xa5, 0xb6
@@ -280,19 +280,19 @@ block0(v0: f64x2, v1: f64x2, v2: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v15,48(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-48(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v15,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfnmsac.vv v15,v11,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v15,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -303,11 +303,11 @@ block0(v0: f64x2, v1: f64x2, v2: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
-;   addi t6, s0, 0x30
+;   addi t6, sp, 0x30
 ;   .byte 0x87, 0x87, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x97, 0xb4, 0xbe
@@ -327,18 +327,18 @@ block0(v0: f64, v1: f64x2, v2: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v10,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v14,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v10,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v14,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfnmsac.vf v14,v10,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -349,9 +349,9 @@ block0(v0: f64, v1: f64x2, v2: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x85, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x07, 0x87, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x57, 0xa5, 0xbe
@@ -362,3 +362,90 @@ block0(v0: f64, v1: f64x2, v2: f64x2):
 ;   addi sp, sp, 0x10
 ;   ret
 
+
+function %fma_splat_y_f32x4(f32x4, f32, f32x4) -> f32x4 {
+block0(v0: f32x4, v1: f32, v2: f32x4):
+    v3 = splat.f32x4 v1
+    v4 = fma v0, v3, v2
+    return v4
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+; block0:
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v14,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vfmacc.vf v14,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
+;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+; block1: ; offset 0x10
+;   .byte 0x57, 0x70, 0x08, 0xcc
+;   addi t6, sp, 0x10
+;   .byte 0x87, 0x84, 0x0f, 0x02
+;   addi t6, sp, 0x20
+;   .byte 0x07, 0x87, 0x0f, 0x02
+;   .byte 0x57, 0x70, 0x02, 0xcd
+;   .byte 0x57, 0x57, 0x95, 0xb2
+;   .byte 0x57, 0x70, 0x08, 0xcc
+;   .byte 0x27, 0x07, 0x05, 0x02
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   ret
+
+function %fma_splat_y_f64x2(f64x2, f64, f64x2) -> f64x2 {
+block0(v0: f64x2, v1: f64, v2: f64x2):
+    v3 = splat.f64x2 v1
+    v4 = fma v0, v3, v2
+    return v4
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+; block0:
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v14,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vfmacc.vf v14,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
+;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+; block1: ; offset 0x10
+;   .byte 0x57, 0x70, 0x08, 0xcc
+;   addi t6, sp, 0x10
+;   .byte 0x87, 0x84, 0x0f, 0x02
+;   addi t6, sp, 0x20
+;   .byte 0x07, 0x87, 0x0f, 0x02
+;   .byte 0x57, 0x70, 0x81, 0xcd
+;   .byte 0x57, 0x57, 0x95, 0xb2
+;   .byte 0x57, 0x70, 0x08, 0xcc
+;   .byte 0x27, 0x07, 0x05, 0x02
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fmax.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fmax.clif
index 5c141df2a94c..9f7085dd7f67 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fmax.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fmax.clif
@@ -9,13 +9,13 @@ block0(v0: f64x2, v1: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfeq.vv v14,v9,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmfeq.vv v8,v11,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmand.mm v0,v14,v8 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -27,7 +27,7 @@ block0(v0: f64x2, v1: f64x2):
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -38,9 +38,9 @@ block0(v0: f64x2, v1: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x97, 0x94, 0x62
@@ -65,13 +65,13 @@ block0(v0: f32x4, v1: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfeq.vv v14,v9,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmfeq.vv v8,v11,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmand.mm v0,v14,v8 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -82,7 +82,7 @@ block0(v0: f32x4, v1: f32x4):
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -93,9 +93,9 @@ block0(v0: f32x4, v1: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x97, 0x94, 0x62
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fmin.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fmin.clif
index 94bef3ee07e9..04e2a7bf6040 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fmin.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fmin.clif
@@ -9,13 +9,13 @@ block0(v0: f64x2, v1: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfeq.vv v14,v9,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmfeq.vv v8,v11,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmand.mm v0,v14,v8 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -27,7 +27,7 @@ block0(v0: f64x2, v1: f64x2):
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -38,9 +38,9 @@ block0(v0: f64x2, v1: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x97, 0x94, 0x62
@@ -65,13 +65,13 @@ block0(v0: f32x4, v1: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmfeq.vv v14,v9,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmfeq.vv v8,v11,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmand.mm v0,v14,v8 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -82,7 +82,7 @@ block0(v0: f32x4, v1: f32x4):
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -93,9 +93,9 @@ block0(v0: f32x4, v1: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x97, 0x94, 0x62
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fmul.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fmul.clif
index 0f2cfe700fb3..403a68ddebb3 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fmul.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fmul.clif
@@ -10,18 +10,18 @@ block0(v0: f32x4, v1: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfmul.vv v14,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,9 +32,9 @@ block0(v0: f32x4, v1: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x97, 0x95, 0x92
@@ -53,17 +53,17 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfmul.vf v13,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -74,7 +74,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x92
@@ -93,17 +93,17 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfmul.vf v13,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -114,7 +114,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x92
@@ -132,18 +132,18 @@ block0(v0: f64x2, v1: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfmul.vv v14,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -154,9 +154,9 @@ block0(v0: f64x2, v1: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x97, 0x95, 0x92
@@ -175,17 +175,17 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfmul.vf v13,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -196,7 +196,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x92
@@ -215,17 +215,17 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfmul.vf v13,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -236,7 +236,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x92
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fneg.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fneg.clif
index 7fdfe5e957fb..2b890a33d35f 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fneg.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fneg.clif
@@ -10,17 +10,17 @@ block0(v0: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfneg.v v12,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -31,7 +31,7 @@ block0(v0: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x96, 0x94, 0x26
@@ -49,17 +49,17 @@ block0(v0: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfneg.v v12,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -70,7 +70,7 @@ block0(v0: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x96, 0x94, 0x26
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fsub.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fsub.clif
index 236a509525ea..950cd5c71671 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fsub.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fsub.clif
@@ -10,18 +10,18 @@ block0(v0: f32x4, v1: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfsub.vv v14,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,9 +32,9 @@ block0(v0: f32x4, v1: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x97, 0x95, 0x0a
@@ -53,17 +53,17 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfsub.vf v13,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -74,7 +74,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x0a
@@ -93,17 +93,17 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfrsub.vf v13,v9,fa0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -114,7 +114,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x9e
@@ -132,18 +132,18 @@ block0(v0: f64x2, v1: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfsub.vv v14,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -154,9 +154,9 @@ block0(v0: f64x2, v1: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x97, 0x95, 0x0a
@@ -175,17 +175,17 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfsub.vf v13,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -196,7 +196,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x0a
@@ -215,17 +215,17 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfrsub.vf v13,v9,fa0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -236,7 +236,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x56, 0x95, 0x9e
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fvdemote.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fvdemote.clif
index 7f679b97f14b..efc9c0fa566f 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fvdemote.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fvdemote.clif
@@ -9,19 +9,19 @@ block0(v0: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfncvt.f.f.w v12,v9 #avl=4, #vtype=(e32, mf2, ta, ma)
 ;   vmv.v.i v0,12 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v8,v12,0,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,7 +32,7 @@ block0(v0: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x72, 0xcd
 ;   .byte 0x57, 0x16, 0x9a, 0x4a
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-fvpromote-low.clif b/cranelift/filetests/filetests/isa/riscv64/simd-fvpromote-low.clif
index 663abbdfe313..a521416f4329 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-fvpromote-low.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-fvpromote-low.clif
@@ -9,17 +9,17 @@ block0(v0: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfwcvt.f.f.v v12,v9 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -30,7 +30,7 @@ block0(v0: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x71, 0xcd
 ;   .byte 0x57, 0x16, 0x96, 0x4a
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-iabs.clif b/cranelift/filetests/filetests/isa/riscv64/simd-iabs.clif
index 4b1df26d4f11..0f998fa91f34 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-iabs.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-iabs.clif
@@ -9,18 +9,18 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vneg.v v12,v9 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmax.vv v14,v9,v12 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -31,7 +31,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x46, 0x90, 0x0e
 ;   .byte 0x57, 0x07, 0x96, 0x1e
@@ -48,18 +48,18 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vneg.v v12,v9 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vmax.vv v14,v9,v12 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -70,7 +70,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x46, 0x90, 0x0e
@@ -89,18 +89,18 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vneg.v v12,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmax.vv v14,v9,v12 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -111,7 +111,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x46, 0x90, 0x0e
@@ -130,18 +130,18 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vneg.v v12,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmax.vv v14,v9,v12 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -152,7 +152,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x46, 0x90, 0x0e
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-iadd-big.clif b/cranelift/filetests/filetests/isa/riscv64/simd-iadd-big.clif
index 80bc76d5f8b2..d4faeeff6cc2 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-iadd-big.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-iadd-big.clif
@@ -11,18 +11,18 @@ block0(v0:i64x4, v1:i64x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle16.v v9,16(fp) #avl=16, #vtype=(e16, m1, ta, ma)
-;   vle16.v v11,48(fp) #avl=16, #vtype=(e16, m1, ta, ma)
+;   vle16.v v9,-64(incoming_arg) #avl=16, #vtype=(e16, m1, ta, ma)
+;   vle16.v v11,-32(incoming_arg) #avl=16, #vtype=(e16, m1, ta, ma)
 ;   vadd.vv v14,v9,v11 #avl=4, #vtype=(e64, m1, ta, ma)
 ;   vse16.v v14,0(a0) #avl=16, #vtype=(e16, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -33,9 +33,9 @@ block0(v0:i64x4, v1:i64x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x88, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0xd4, 0x0f, 0x02
-;   addi t6, s0, 0x30
+;   addi t6, sp, 0x30
 ;   .byte 0x87, 0xd5, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x82, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x02
@@ -53,18 +53,18 @@ block0(v0:i64x8, v1:i64x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle32.v v9,16(fp) #avl=16, #vtype=(e32, m1, ta, ma)
-;   vle32.v v11,80(fp) #avl=16, #vtype=(e32, m1, ta, ma)
+;   vle32.v v9,-128(incoming_arg) #avl=16, #vtype=(e32, m1, ta, ma)
+;   vle32.v v11,-64(incoming_arg) #avl=16, #vtype=(e32, m1, ta, ma)
 ;   vadd.vv v14,v9,v11 #avl=8, #vtype=(e64, m1, ta, ma)
 ;   vse32.v v14,0(a0) #avl=16, #vtype=(e32, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -75,9 +75,9 @@ block0(v0:i64x8, v1:i64x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcd
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0xe4, 0x0f, 0x02
-;   addi t6, s0, 0x50
+;   addi t6, sp, 0x50
 ;   .byte 0x87, 0xe5, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x02
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-iadd-small.clif b/cranelift/filetests/filetests/isa/riscv64/simd-iadd-small.clif
index 44ed615b2dcd..8e616e8fc567 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-iadd-small.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-iadd-small.clif
@@ -10,18 +10,18 @@ block0(v0:i8x8, v1:i8x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=8, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,24(fp) #avl=8, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=8, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-8(incoming_arg) #avl=8, #vtype=(e8, m1, ta, ma)
 ;   vadd.vv v14,v9,v11 #avl=8, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=8, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,9 +32,9 @@ block0(v0:i8x8, v1:i8x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x04, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x18
+;   addi t6, sp, 0x18
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x87, 0x95, 0x02
 ;   .byte 0x27, 0x07, 0x05, 0x02
@@ -50,18 +50,18 @@ block0(v0:i16x4, v1:i16x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=8, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,24(fp) #avl=8, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=8, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-8(incoming_arg) #avl=8, #vtype=(e8, m1, ta, ma)
 ;   vadd.vv v14,v9,v11 #avl=4, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=8, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -72,9 +72,9 @@ block0(v0:i16x4, v1:i16x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x04, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x18
+;   addi t6, sp, 0x18
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x82, 0xcc
 ;   .byte 0x57, 0x87, 0x95, 0x02
@@ -92,18 +92,18 @@ block0(v0:i32x2, v1:i32x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=8, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,24(fp) #avl=8, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=8, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-8(incoming_arg) #avl=8, #vtype=(e8, m1, ta, ma)
 ;   vadd.vv v14,v9,v11 #avl=2, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=8, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -114,9 +114,9 @@ block0(v0:i32x2, v1:i32x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x04, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x18
+;   addi t6, sp, 0x18
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x01, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x02
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-iadd-splat-extend.clif b/cranelift/filetests/filetests/isa/riscv64/simd-iadd-splat-extend.clif
index 1b4566fa6c2e..4a80201513bc 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-iadd-splat-extend.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-iadd-splat-extend.clif
@@ -11,17 +11,17 @@ block0(v0: i16x8, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwadd.wx v13,v9,a0 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,7 +32,7 @@ block0(v0: i16x8, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x74, 0xcc
 ;   .byte 0xd7, 0x66, 0x95, 0xd6
@@ -52,17 +52,17 @@ block0(v0: i32x4, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwadd.wx v13,v9,a0 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -73,7 +73,7 @@ block0(v0: i32x4, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0xf2, 0xcc
 ;   .byte 0xd7, 0x66, 0x95, 0xd6
@@ -93,17 +93,17 @@ block0(v0: i64x2, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwadd.wx v13,v9,a0 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -114,7 +114,7 @@ block0(v0: i64x2, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x71, 0xcd
 ;   .byte 0xd7, 0x66, 0x95, 0xd6
@@ -134,17 +134,17 @@ block0(v0: i16x8, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwaddu.wx v13,v9,a0 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -155,7 +155,7 @@ block0(v0: i16x8, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x74, 0xcc
 ;   .byte 0xd7, 0x66, 0x95, 0xd2
@@ -175,17 +175,17 @@ block0(v0: i32x4, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwaddu.wx v13,v9,a0 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -196,7 +196,7 @@ block0(v0: i32x4, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0xf2, 0xcc
 ;   .byte 0xd7, 0x66, 0x95, 0xd2
@@ -216,17 +216,17 @@ block0(v0: i64x2, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwaddu.wx v13,v9,a0 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -237,7 +237,7 @@ block0(v0: i64x2, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x71, 0xcd
 ;   .byte 0xd7, 0x66, 0x95, 0xd2
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-iadd-swiden-high.clif b/cranelift/filetests/filetests/isa/riscv64/simd-iadd-swiden-high.clif
index 9dde4aeb2c30..04674c5fd7c5 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-iadd-swiden-high.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-iadd-swiden-high.clif
@@ -11,20 +11,20 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,2 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vslidedown.vi v8,v11,2 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vwadd.vv v10,v14,v8 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -35,9 +35,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x37, 0x91, 0x3e
@@ -60,20 +60,20 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,4 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vslidedown.vi v8,v11,4 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vwadd.vv v10,v14,v8 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -84,9 +84,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x37, 0x92, 0x3e
@@ -109,20 +109,20 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,8 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v8,v11,8 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwadd.vv v10,v14,v8 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -133,9 +133,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x37, 0x94, 0x3e
 ;   .byte 0x57, 0x34, 0xb4, 0x3e
@@ -158,18 +158,18 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v13,v9,2 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vwadd.vx v15,v13,a0 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v15,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -180,7 +180,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x36, 0x91, 0x3e
@@ -203,18 +203,18 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v13,v9,4 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vwadd.vx v15,v13,a0 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v15,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -225,7 +225,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x36, 0x92, 0x3e
@@ -248,18 +248,18 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v13,v9,8 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwadd.vx v15,v13,a0 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v15,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -270,7 +270,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x36, 0x94, 0x3e
 ;   .byte 0x57, 0x70, 0x74, 0xcc
@@ -290,19 +290,19 @@ block0(v0: i32x4, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,2 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vwadd.wv v8,v11,v14 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -313,9 +313,9 @@ block0(v0: i32x4, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x37, 0x91, 0x3e
@@ -336,19 +336,19 @@ block0(v0: i16x8, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,4 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vwadd.wv v8,v11,v14 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -359,9 +359,9 @@ block0(v0: i16x8, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x37, 0x92, 0x3e
@@ -382,19 +382,19 @@ block0(v0: i8x16, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,8 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwadd.wv v8,v11,v14 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -405,9 +405,9 @@ block0(v0: i8x16, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x37, 0x94, 0x3e
 ;   .byte 0x57, 0x70, 0x74, 0xcc
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-iadd-swiden-low.clif b/cranelift/filetests/filetests/isa/riscv64/simd-iadd-swiden-low.clif
index 0c945c0b4f63..059ebd2323cd 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-iadd-swiden-low.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-iadd-swiden-low.clif
@@ -11,18 +11,18 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwadd.vv v14,v9,v11 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -33,9 +33,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x71, 0xcd
 ;   .byte 0x57, 0xa7, 0x95, 0xc6
@@ -55,18 +55,18 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwadd.vv v14,v9,v11 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -77,9 +77,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0xf2, 0xcc
 ;   .byte 0x57, 0xa7, 0x95, 0xc6
@@ -99,18 +99,18 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwadd.vv v14,v9,v11 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -121,9 +121,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x74, 0xcc
 ;   .byte 0x57, 0xa7, 0x95, 0xc6
@@ -144,17 +144,17 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwadd.vx v13,v9,a0 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -165,7 +165,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x71, 0xcd
 ;   .byte 0xd7, 0x66, 0x95, 0xc6
@@ -186,17 +186,17 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwadd.vx v13,v9,a0 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -207,7 +207,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0xf2, 0xcc
 ;   .byte 0xd7, 0x66, 0x95, 0xc6
@@ -228,17 +228,17 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwadd.vx v13,v9,a0 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -249,7 +249,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x74, 0xcc
 ;   .byte 0xd7, 0x66, 0x95, 0xc6
@@ -268,18 +268,18 @@ block0(v0: i32x4, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwadd.wv v14,v11,v9 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -290,9 +290,9 @@ block0(v0: i32x4, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x71, 0xcd
 ;   .byte 0x57, 0xa7, 0xb4, 0xd6
@@ -311,18 +311,18 @@ block0(v0: i16x8, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwadd.wv v14,v11,v9 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -333,9 +333,9 @@ block0(v0: i16x8, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0xf2, 0xcc
 ;   .byte 0x57, 0xa7, 0xb4, 0xd6
@@ -354,18 +354,18 @@ block0(v0: i8x16, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwadd.wv v14,v11,v9 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -376,9 +376,9 @@ block0(v0: i8x16, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x74, 0xcc
 ;   .byte 0x57, 0xa7, 0xb4, 0xd6
@@ -397,18 +397,18 @@ block0(v0: i8x16, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwadd.wv v14,v11,v9 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -419,9 +419,9 @@ block0(v0: i8x16, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x74, 0xcc
 ;   .byte 0x57, 0xa7, 0xb4, 0xd6
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-iadd-swiden-mix.clif b/cranelift/filetests/filetests/isa/riscv64/simd-iadd-swiden-mix.clif
index 994101d965f3..c12b1e293495 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-iadd-swiden-mix.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-iadd-swiden-mix.clif
@@ -11,19 +11,19 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,2 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vwadd.vv v8,v14,v11 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -34,9 +34,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x37, 0x91, 0x3e
@@ -58,19 +58,19 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,4 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vwadd.vv v8,v14,v11 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -81,9 +81,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x37, 0x92, 0x3e
@@ -105,19 +105,19 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,8 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwadd.vv v8,v14,v11 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -128,9 +128,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x37, 0x94, 0x3e
 ;   .byte 0x57, 0x70, 0x74, 0xcc
@@ -151,19 +151,19 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v11,2 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vwadd.vv v8,v9,v14 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -174,9 +174,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x37, 0xb1, 0x3e
@@ -198,19 +198,19 @@ block0(v0: i16x8, v1:i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v11,4 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vwadd.vv v8,v9,v14 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -221,9 +221,9 @@ block0(v0: i16x8, v1:i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x37, 0xb2, 0x3e
@@ -245,19 +245,19 @@ block0(v0: i8x16, v1:i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v11,8 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwadd.vv v8,v9,v14 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -268,9 +268,9 @@ block0(v0: i8x16, v1:i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x37, 0xb4, 0x3e
 ;   .byte 0x57, 0x70, 0x74, 0xcc
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-iadd-uwiden-high.clif b/cranelift/filetests/filetests/isa/riscv64/simd-iadd-uwiden-high.clif
index b421b79b3707..d71d40584e7d 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-iadd-uwiden-high.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-iadd-uwiden-high.clif
@@ -12,20 +12,20 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,2 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vslidedown.vi v8,v11,2 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vwaddu.vv v10,v14,v8 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -36,9 +36,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x37, 0x91, 0x3e
@@ -61,20 +61,20 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,4 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vslidedown.vi v8,v11,4 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vwaddu.vv v10,v14,v8 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -85,9 +85,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x37, 0x92, 0x3e
@@ -110,20 +110,20 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,8 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v8,v11,8 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwaddu.vv v10,v14,v8 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -134,9 +134,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x37, 0x94, 0x3e
 ;   .byte 0x57, 0x34, 0xb4, 0x3e
@@ -159,18 +159,18 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v13,v9,2 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vwaddu.vx v15,v13,a0 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v15,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -181,7 +181,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x36, 0x91, 0x3e
@@ -204,18 +204,18 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v13,v9,4 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vwaddu.vx v15,v13,a0 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v15,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -226,7 +226,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x36, 0x92, 0x3e
@@ -249,18 +249,18 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v13,v9,8 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwaddu.vx v15,v13,a0 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v15,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -271,7 +271,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x36, 0x94, 0x3e
 ;   .byte 0x57, 0x70, 0x74, 0xcc
@@ -291,19 +291,19 @@ block0(v0: i32x4, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,2 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vwaddu.wv v8,v11,v14 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -314,9 +314,9 @@ block0(v0: i32x4, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x37, 0x91, 0x3e
@@ -337,19 +337,19 @@ block0(v0: i16x8, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,4 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vwaddu.wv v8,v11,v14 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -360,9 +360,9 @@ block0(v0: i16x8, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x37, 0x92, 0x3e
@@ -383,19 +383,19 @@ block0(v0: i8x16, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,8 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwaddu.wv v8,v11,v14 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -406,9 +406,9 @@ block0(v0: i8x16, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x37, 0x94, 0x3e
 ;   .byte 0x57, 0x70, 0x74, 0xcc
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-iadd-uwiden-low.clif b/cranelift/filetests/filetests/isa/riscv64/simd-iadd-uwiden-low.clif
index e12f9e37bc14..79ba345a5844 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-iadd-uwiden-low.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-iadd-uwiden-low.clif
@@ -12,18 +12,18 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwaddu.vv v14,v9,v11 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -34,9 +34,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x71, 0xcd
 ;   .byte 0x57, 0xa7, 0x95, 0xc2
@@ -56,18 +56,18 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwaddu.vv v14,v9,v11 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -78,9 +78,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0xf2, 0xcc
 ;   .byte 0x57, 0xa7, 0x95, 0xc2
@@ -100,18 +100,18 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwaddu.vv v14,v9,v11 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -122,9 +122,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x74, 0xcc
 ;   .byte 0x57, 0xa7, 0x95, 0xc2
@@ -145,17 +145,17 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwaddu.vx v13,v9,a0 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -166,7 +166,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x71, 0xcd
 ;   .byte 0xd7, 0x66, 0x95, 0xc2
@@ -187,17 +187,17 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwaddu.vx v13,v9,a0 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -208,7 +208,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0xf2, 0xcc
 ;   .byte 0xd7, 0x66, 0x95, 0xc2
@@ -229,17 +229,17 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwaddu.vx v13,v9,a0 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -250,7 +250,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x74, 0xcc
 ;   .byte 0xd7, 0x66, 0x95, 0xc2
@@ -269,18 +269,18 @@ block0(v0: i32x4, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwaddu.wv v14,v11,v9 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -291,9 +291,9 @@ block0(v0: i32x4, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x71, 0xcd
 ;   .byte 0x57, 0xa7, 0xb4, 0xd2
@@ -312,18 +312,18 @@ block0(v0: i16x8, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwaddu.wv v14,v11,v9 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -334,9 +334,9 @@ block0(v0: i16x8, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0xf2, 0xcc
 ;   .byte 0x57, 0xa7, 0xb4, 0xd2
@@ -355,18 +355,18 @@ block0(v0: i8x16, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwaddu.wv v14,v11,v9 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -377,9 +377,9 @@ block0(v0: i8x16, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x74, 0xcc
 ;   .byte 0x57, 0xa7, 0xb4, 0xd2
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-iadd-uwiden-mix.clif b/cranelift/filetests/filetests/isa/riscv64/simd-iadd-uwiden-mix.clif
index 268a2446841c..a3e1fda04e77 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-iadd-uwiden-mix.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-iadd-uwiden-mix.clif
@@ -13,19 +13,19 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,2 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vwaddu.vv v8,v14,v11 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -36,9 +36,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x37, 0x91, 0x3e
@@ -60,19 +60,19 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,4 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vwaddu.vv v8,v14,v11 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -83,9 +83,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x37, 0x92, 0x3e
@@ -107,19 +107,19 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,8 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwaddu.vv v8,v14,v11 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -130,9 +130,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x37, 0x94, 0x3e
 ;   .byte 0x57, 0x70, 0x74, 0xcc
@@ -153,19 +153,19 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v11,2 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vwaddu.vv v8,v9,v14 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -176,9 +176,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x37, 0xb1, 0x3e
@@ -200,19 +200,19 @@ block0(v0: i16x8, v1:i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v11,4 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vwaddu.vv v8,v9,v14 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -223,9 +223,9 @@ block0(v0: i16x8, v1:i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x37, 0xb2, 0x3e
@@ -247,19 +247,19 @@ block0(v0: i8x16, v1:i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v11,8 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwaddu.vv v8,v9,v14 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -270,9 +270,9 @@ block0(v0: i8x16, v1:i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x37, 0xb4, 0x3e
 ;   .byte 0x57, 0x70, 0x74, 0xcc
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-iadd.clif b/cranelift/filetests/filetests/isa/riscv64/simd-iadd.clif
index a348e3639c31..0817d46b5949 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-iadd.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-iadd.clif
@@ -10,18 +10,18 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vadd.vv v14,v9,v11 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,9 +32,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x87, 0x95, 0x02
 ;   .byte 0x27, 0x07, 0x05, 0x02
@@ -50,18 +50,18 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vadd.vv v14,v9,v11 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -72,9 +72,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x87, 0x95, 0x02
@@ -92,18 +92,18 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vadd.vv v14,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -114,9 +114,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x02
@@ -134,18 +134,18 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vadd.vv v14,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -156,9 +156,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x02
@@ -178,17 +178,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vadd.vi v12,v9,5 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -199,7 +199,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0xb6, 0x92, 0x02
 ;   .byte 0x27, 0x06, 0x05, 0x02
@@ -217,17 +217,17 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vadd.vi v12,v9,-16 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -238,7 +238,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x36, 0x98, 0x02
@@ -258,17 +258,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vadd.vi v12,v9,15 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -279,7 +279,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xb6, 0x97, 0x02
@@ -299,17 +299,17 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vadd.vi v12,v9,-5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -320,7 +320,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb6, 0x9d, 0x02
@@ -339,17 +339,17 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vadd.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -360,7 +360,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x46, 0x95, 0x02
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -377,17 +377,17 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vadd.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -398,7 +398,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x46, 0x95, 0x02
@@ -417,17 +417,17 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vadd.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -438,7 +438,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x02
@@ -457,17 +457,17 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vadd.vx v13,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -478,7 +478,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x02
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-iadd_pairwise.clif b/cranelift/filetests/filetests/isa/riscv64/simd-iadd_pairwise.clif
index dbf3f4b4e0e9..95b012dc6c28 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-iadd_pairwise.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-iadd_pairwise.clif
@@ -9,13 +9,13 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld a1,[const(0)]
 ;   vmv.s.x v8,a1 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vcompress.vm v12,v9,v8 #avl=16, #vtype=(e8, m1, ta, ma)
@@ -30,7 +30,7 @@ block0(v0: i8x16, v1: i8x16):
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -41,9 +41,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   auipc a1, 0
 ;   ld a1, 0x5c(a1)
@@ -80,13 +80,13 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld a1,[const(0)]
 ;   vmv.s.x v8,a1 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vcompress.vm v12,v9,v8 #avl=8, #vtype=(e16, m1, ta, ma)
@@ -101,7 +101,7 @@ block0(v0: i16x8, v1: i16x8):
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -112,9 +112,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   auipc a1, 0
 ;   ld a1, 0x5c(a1)
@@ -151,13 +151,13 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld a1,[const(0)]
 ;   vmv.s.x v8,a1 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vcompress.vm v12,v9,v8 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -172,7 +172,7 @@ block0(v0: i32x4, v1: i32x4):
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -183,9 +183,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   auipc a1, 0
 ;   ld a1, 0x5c(a1)
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-icmp-eq.clif b/cranelift/filetests/filetests/isa/riscv64/simd-icmp-eq.clif
index 0facac260b13..0195f0e248ea 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-icmp-eq.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-icmp-eq.clif
@@ -9,20 +9,20 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmseq.vv v0,v9,v11 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -33,9 +33,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x80, 0x95, 0x62
 ;   .byte 0x57, 0x34, 0x00, 0x5e
@@ -53,20 +53,20 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmseq.vv v0,v9,v11 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -77,9 +77,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x80, 0x95, 0x62
@@ -99,20 +99,20 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmseq.vv v0,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -123,9 +123,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x80, 0x95, 0x62
@@ -145,20 +145,20 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmseq.vv v0,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -169,9 +169,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x80, 0x95, 0x62
@@ -192,19 +192,19 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmseq.vx v0,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v9,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -215,7 +215,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x40, 0x95, 0x62
@@ -236,19 +236,19 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmseq.vx v0,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v9,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -259,7 +259,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x40, 0x95, 0x62
@@ -281,19 +281,19 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmseq.vi v0,v9,10 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v14,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v8,v14,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -304,7 +304,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x30, 0x95, 0x62
@@ -326,19 +326,19 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmseq.vi v0,v9,10 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v14,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v8,v14,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -349,7 +349,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x30, 0x95, 0x62
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-icmp-ne.clif b/cranelift/filetests/filetests/isa/riscv64/simd-icmp-ne.clif
index 954f5745bfb3..22ffa436535d 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-icmp-ne.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-icmp-ne.clif
@@ -9,20 +9,20 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsne.vv v0,v9,v11 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -33,9 +33,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x80, 0x95, 0x66
 ;   .byte 0x57, 0x34, 0x00, 0x5e
@@ -53,20 +53,20 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsne.vv v0,v9,v11 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -77,9 +77,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x80, 0x95, 0x66
@@ -99,20 +99,20 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsne.vv v0,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -123,9 +123,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x80, 0x95, 0x66
@@ -145,20 +145,20 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsne.vv v0,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -169,9 +169,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x80, 0x95, 0x66
@@ -192,19 +192,19 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsne.vx v0,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v9,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -215,7 +215,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x40, 0x95, 0x66
@@ -236,19 +236,19 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsne.vx v0,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v9,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -259,7 +259,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x40, 0x95, 0x66
@@ -281,19 +281,19 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsne.vi v0,v9,10 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v14,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v8,v14,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -304,7 +304,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x30, 0x95, 0x66
@@ -326,19 +326,19 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsne.vi v0,v9,10 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v14,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v8,v14,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -349,7 +349,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x30, 0x95, 0x66
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-icmp-sge.clif b/cranelift/filetests/filetests/isa/riscv64/simd-icmp-sge.clif
index 6c901cf7ee4e..25bf9b1924e0 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-icmp-sge.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-icmp-sge.clif
@@ -9,20 +9,20 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsle.vv v0,v11,v9 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -33,9 +33,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x80, 0xb4, 0x76
 ;   .byte 0x57, 0x34, 0x00, 0x5e
@@ -53,20 +53,20 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsle.vv v0,v11,v9 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -77,9 +77,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x80, 0xb4, 0x76
@@ -99,20 +99,20 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsle.vv v0,v11,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -123,9 +123,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x80, 0xb4, 0x76
@@ -145,20 +145,20 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsle.vv v0,v11,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -169,9 +169,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x80, 0xb4, 0x76
@@ -192,12 +192,12 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.x v8,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmsle.vv v0,v8,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -205,7 +205,7 @@ block0(v0: i64x2, v1: i64):
 ;   vse8.v v10,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -216,7 +216,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x44, 0x05, 0x5e
@@ -238,19 +238,19 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsle.vx v0,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v9,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -261,7 +261,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x40, 0x95, 0x76
@@ -283,12 +283,12 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.i v15,10 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmsle.vv v0,v15,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -296,7 +296,7 @@ block0(v0: i64x2):
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -307,7 +307,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x37, 0x05, 0x5e
@@ -330,19 +330,19 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsle.vi v0,v9,10 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v14,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v8,v14,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -353,7 +353,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x30, 0x95, 0x76
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-icmp-sgt.clif b/cranelift/filetests/filetests/isa/riscv64/simd-icmp-sgt.clif
index 4bef12eb57e3..d0a7ae8f3ed7 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-icmp-sgt.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-icmp-sgt.clif
@@ -9,20 +9,20 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmslt.vv v0,v11,v9 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -33,9 +33,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x80, 0xb4, 0x6e
 ;   .byte 0x57, 0x34, 0x00, 0x5e
@@ -53,20 +53,20 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmslt.vv v0,v11,v9 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -77,9 +77,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x80, 0xb4, 0x6e
@@ -99,20 +99,20 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmslt.vv v0,v11,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -123,9 +123,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x80, 0xb4, 0x6e
@@ -145,20 +145,20 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmslt.vv v0,v11,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -169,9 +169,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x80, 0xb4, 0x6e
@@ -192,19 +192,19 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsgt.vx v0,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v9,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -215,7 +215,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x40, 0x95, 0x7e
@@ -236,19 +236,19 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmslt.vx v0,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v9,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -259,7 +259,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x40, 0x95, 0x6e
@@ -281,19 +281,19 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsgt.vi v0,v9,10 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v14,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v8,v14,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -304,7 +304,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x30, 0x95, 0x7e
@@ -326,12 +326,12 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a1,10
 ;   vmslt.vx v0,v9,a1 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -339,7 +339,7 @@ block0(v0: i64x2):
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -350,7 +350,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a1, zero, 0xa
 ;   .byte 0x57, 0x70, 0x81, 0xcd
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-icmp-sle.clif b/cranelift/filetests/filetests/isa/riscv64/simd-icmp-sle.clif
index 9fc9ca183154..72d3bcb520d6 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-icmp-sle.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-icmp-sle.clif
@@ -9,20 +9,20 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsle.vv v0,v9,v11 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -33,9 +33,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x80, 0x95, 0x76
 ;   .byte 0x57, 0x34, 0x00, 0x5e
@@ -53,20 +53,20 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsle.vv v0,v9,v11 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -77,9 +77,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x80, 0x95, 0x76
@@ -99,20 +99,20 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsle.vv v0,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -123,9 +123,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x80, 0x95, 0x76
@@ -145,20 +145,20 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsle.vv v0,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -169,9 +169,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x80, 0x95, 0x76
@@ -192,19 +192,19 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsle.vx v0,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v9,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -215,7 +215,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x40, 0x95, 0x76
@@ -236,12 +236,12 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.x v8,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmsle.vv v0,v8,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -249,7 +249,7 @@ block0(v0: i64x2, v1: i64):
 ;   vse8.v v10,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -260,7 +260,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x44, 0x05, 0x5e
@@ -283,19 +283,19 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsle.vi v0,v9,10 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v14,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v8,v14,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -306,7 +306,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x30, 0x95, 0x76
@@ -328,12 +328,12 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.i v15,10 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmsle.vv v0,v15,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -341,7 +341,7 @@ block0(v0: i64x2):
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -352,7 +352,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x37, 0x05, 0x5e
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-icmp-slt.clif b/cranelift/filetests/filetests/isa/riscv64/simd-icmp-slt.clif
index bb00daef7743..7c3b1d1ab6ec 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-icmp-slt.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-icmp-slt.clif
@@ -9,20 +9,20 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmslt.vv v0,v9,v11 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -33,9 +33,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x80, 0x95, 0x6e
 ;   .byte 0x57, 0x34, 0x00, 0x5e
@@ -53,20 +53,20 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmslt.vv v0,v9,v11 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -77,9 +77,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x80, 0x95, 0x6e
@@ -99,20 +99,20 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmslt.vv v0,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -123,9 +123,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x80, 0x95, 0x6e
@@ -145,20 +145,20 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmslt.vv v0,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -169,9 +169,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x80, 0x95, 0x6e
@@ -192,19 +192,19 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmslt.vx v0,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v9,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -215,7 +215,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x40, 0x95, 0x6e
@@ -236,19 +236,19 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsgt.vx v0,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v9,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -259,7 +259,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x40, 0x95, 0x7e
@@ -281,12 +281,12 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a1,10
 ;   vmslt.vx v0,v9,a1 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -294,7 +294,7 @@ block0(v0: i64x2):
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -305,7 +305,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a1, zero, 0xa
 ;   .byte 0x57, 0x70, 0x81, 0xcd
@@ -328,19 +328,19 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsgt.vi v0,v9,10 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v14,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v8,v14,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -351,7 +351,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x30, 0x95, 0x7e
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-icmp-uge.clif b/cranelift/filetests/filetests/isa/riscv64/simd-icmp-uge.clif
index 038204e521b4..5d4cd129f96a 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-icmp-uge.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-icmp-uge.clif
@@ -9,20 +9,20 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsleu.vv v0,v11,v9 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -33,9 +33,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x80, 0xb4, 0x72
 ;   .byte 0x57, 0x34, 0x00, 0x5e
@@ -53,20 +53,20 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsleu.vv v0,v11,v9 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -77,9 +77,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x80, 0xb4, 0x72
@@ -99,20 +99,20 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsleu.vv v0,v11,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -123,9 +123,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x80, 0xb4, 0x72
@@ -145,20 +145,20 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsleu.vv v0,v11,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -169,9 +169,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x80, 0xb4, 0x72
@@ -192,12 +192,12 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.x v8,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmsleu.vv v0,v8,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -205,7 +205,7 @@ block0(v0: i64x2, v1: i64):
 ;   vse8.v v10,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -216,7 +216,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x44, 0x05, 0x5e
@@ -238,19 +238,19 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsleu.vx v0,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v9,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -261,7 +261,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x40, 0x95, 0x72
@@ -283,12 +283,12 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.i v15,10 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmsleu.vv v0,v15,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -296,7 +296,7 @@ block0(v0: i64x2):
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -307,7 +307,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x37, 0x05, 0x5e
@@ -330,19 +330,19 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsleu.vi v0,v9,10 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v14,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v8,v14,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -353,7 +353,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x30, 0x95, 0x72
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-icmp-ugt.clif b/cranelift/filetests/filetests/isa/riscv64/simd-icmp-ugt.clif
index 9596c6ff5e5e..0819e3f5e0e1 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-icmp-ugt.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-icmp-ugt.clif
@@ -9,20 +9,20 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsltu.vv v0,v11,v9 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -33,9 +33,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x80, 0xb4, 0x6a
 ;   .byte 0x57, 0x34, 0x00, 0x5e
@@ -53,20 +53,20 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsltu.vv v0,v11,v9 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -77,9 +77,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x80, 0xb4, 0x6a
@@ -99,20 +99,20 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsltu.vv v0,v11,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -123,9 +123,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x80, 0xb4, 0x6a
@@ -145,20 +145,20 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsltu.vv v0,v11,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -169,9 +169,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x80, 0xb4, 0x6a
@@ -192,19 +192,19 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsgtu.vx v0,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v9,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -215,7 +215,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x40, 0x95, 0x7a
@@ -236,19 +236,19 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsltu.vx v0,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v9,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -259,7 +259,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x40, 0x95, 0x6a
@@ -281,19 +281,19 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsgtu.vi v0,v9,10 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v14,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v8,v14,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -304,7 +304,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x30, 0x95, 0x7a
@@ -326,12 +326,12 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a1,10
 ;   vmsltu.vx v0,v9,a1 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -339,7 +339,7 @@ block0(v0: i64x2):
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -350,7 +350,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a1, zero, 0xa
 ;   .byte 0x57, 0x70, 0x81, 0xcd
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-icmp-ule.clif b/cranelift/filetests/filetests/isa/riscv64/simd-icmp-ule.clif
index 5d0955e2fa31..0e48c405e8ce 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-icmp-ule.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-icmp-ule.clif
@@ -9,20 +9,20 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsleu.vv v0,v9,v11 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -33,9 +33,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x80, 0x95, 0x72
 ;   .byte 0x57, 0x34, 0x00, 0x5e
@@ -53,20 +53,20 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsleu.vv v0,v9,v11 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -77,9 +77,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x80, 0x95, 0x72
@@ -99,20 +99,20 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsleu.vv v0,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -123,9 +123,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x80, 0x95, 0x72
@@ -145,20 +145,20 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsleu.vv v0,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -169,9 +169,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x80, 0x95, 0x72
@@ -192,19 +192,19 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsleu.vx v0,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v9,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -215,7 +215,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x40, 0x95, 0x72
@@ -236,12 +236,12 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.x v8,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmsleu.vv v0,v8,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -249,7 +249,7 @@ block0(v0: i64x2, v1: i64):
 ;   vse8.v v10,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -260,7 +260,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x44, 0x05, 0x5e
@@ -283,19 +283,19 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsleu.vi v0,v9,10 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v14,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v8,v14,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -306,7 +306,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x30, 0x95, 0x72
@@ -328,12 +328,12 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.i v15,10 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmsleu.vv v0,v15,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -341,7 +341,7 @@ block0(v0: i64x2):
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -352,7 +352,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x37, 0x05, 0x5e
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-icmp-ult.clif b/cranelift/filetests/filetests/isa/riscv64/simd-icmp-ult.clif
index 3c364d68709b..5e08d8baca78 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-icmp-ult.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-icmp-ult.clif
@@ -9,20 +9,20 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsltu.vv v0,v9,v11 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -33,9 +33,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x80, 0x95, 0x6a
 ;   .byte 0x57, 0x34, 0x00, 0x5e
@@ -53,20 +53,20 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsltu.vv v0,v9,v11 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -77,9 +77,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x80, 0x95, 0x6a
@@ -99,20 +99,20 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsltu.vv v0,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -123,9 +123,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x80, 0x95, 0x6a
@@ -145,20 +145,20 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsltu.vv v0,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v8,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v10,v8,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -169,9 +169,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x80, 0x95, 0x6a
@@ -192,19 +192,19 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsltu.vx v0,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v9,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -215,7 +215,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x40, 0x95, 0x6a
@@ -236,19 +236,19 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsgtu.vx v0,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v9,v15,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v9,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -259,7 +259,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x40, 0x95, 0x7a
@@ -281,12 +281,12 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a1,10
 ;   vmsltu.vx v0,v9,a1 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v15,0 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -294,7 +294,7 @@ block0(v0: i64x2):
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -305,7 +305,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a1, zero, 0xa
 ;   .byte 0x57, 0x70, 0x81, 0xcd
@@ -328,19 +328,19 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmsgtu.vi v0,v9,10 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.v.i v14,0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v8,v14,-1,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -351,7 +351,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x30, 0x95, 0x7a
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-ifma.clif b/cranelift/filetests/filetests/isa/riscv64/simd-ifma.clif
index 53233fc827bd..4cf20464dd0d 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-ifma.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-ifma.clif
@@ -11,19 +11,19 @@ block0(v0: i64x2, v1: i64x2, v2: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v15,48(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-48(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v15,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmacc.vv v15,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v15,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -34,11 +34,11 @@ block0(v0: i64x2, v1: i64x2, v2: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
-;   addi t6, s0, 0x30
+;   addi t6, sp, 0x30
 ;   .byte 0x87, 0x87, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0xa7, 0x95, 0xb6
@@ -58,19 +58,19 @@ block0(v0: i64x2, v1: i64x2, v2: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.x v15,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmacc.vv v15,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v15,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -81,9 +81,9 @@ block0(v0: i64x2, v1: i64x2, v2: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x47, 0x05, 0x5e
@@ -104,19 +104,19 @@ block0(v0: i64x2, v1: i64x2, v2: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v15,48(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-48(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v15,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vnmsac.vv v15,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v15,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -127,11 +127,11 @@ block0(v0: i64x2, v1: i64x2, v2: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
-;   addi t6, s0, 0x30
+;   addi t6, sp, 0x30
 ;   .byte 0x87, 0x87, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0xa7, 0x95, 0xbe
@@ -152,19 +152,19 @@ block0(v0: i64x2, v1: i64x2, v2: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.x v15,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vnmsac.vv v15,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v15,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -175,9 +175,9 @@ block0(v0: i64x2, v1: i64x2, v2: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x47, 0x05, 0x5e
@@ -197,20 +197,20 @@ block0(v0: i64x2, v1: i64x2, v2: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v13,48(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-48(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v13,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmul.vv v9,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vsub.vv v9,v13,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -221,11 +221,11 @@ block0(v0: i64x2, v1: i64x2, v2: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
-;   addi t6, s0, 0x30
+;   addi t6, sp, 0x30
 ;   .byte 0x87, 0x86, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0xa4, 0x95, 0x96
@@ -246,19 +246,19 @@ block0(v0: i64x2, v1: i64x2, v2: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmul.vv v8,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vsub.vx v8,v8,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v8,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -269,9 +269,9 @@ block0(v0: i64x2, v1: i64x2, v2: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xa4, 0x95, 0x96
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-imul.clif b/cranelift/filetests/filetests/isa/riscv64/simd-imul.clif
index 14409bfa0353..6fa6608a08ea 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-imul.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-imul.clif
@@ -10,18 +10,18 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmul.vv v14,v9,v11 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,9 +32,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0xa7, 0x95, 0x96
 ;   .byte 0x27, 0x07, 0x05, 0x02
@@ -50,18 +50,18 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmul.vv v14,v9,v11 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -72,9 +72,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0xa7, 0x95, 0x96
@@ -92,18 +92,18 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmul.vv v14,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -114,9 +114,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xa7, 0x95, 0x96
@@ -134,18 +134,18 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmul.vv v14,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -156,9 +156,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xa7, 0x95, 0x96
@@ -177,17 +177,17 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmul.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -198,7 +198,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x66, 0x95, 0x96
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -215,17 +215,17 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmul.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -236,7 +236,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x66, 0x95, 0x96
@@ -255,17 +255,17 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmul.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -276,7 +276,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x66, 0x95, 0x96
@@ -295,17 +295,17 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmul.vx v13,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -316,7 +316,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x66, 0x95, 0x96
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-ineg.clif b/cranelift/filetests/filetests/isa/riscv64/simd-ineg.clif
index 7b3b74a5d2c1..edd3a6327847 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-ineg.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-ineg.clif
@@ -10,17 +10,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vneg.v v12,v9 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -31,7 +31,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x46, 0x90, 0x0e
 ;   .byte 0x27, 0x06, 0x05, 0x02
@@ -47,17 +47,17 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vneg.v v12,v9 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -68,7 +68,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x46, 0x90, 0x0e
@@ -86,17 +86,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vneg.v v12,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -107,7 +107,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x46, 0x90, 0x0e
@@ -125,17 +125,17 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vneg.v v12,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -146,7 +146,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x46, 0x90, 0x0e
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-insertlane.clif b/cranelift/filetests/filetests/isa/riscv64/simd-insertlane.clif
index 5c920d65ff48..31fbc39b3e2e 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-insertlane.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-insertlane.clif
@@ -9,19 +9,19 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   lui a5,8
 ;   vmv.s.x v0,a5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vxm v10,v9,a0,v0.t #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v10,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,7 +32,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   lui a5, 8
 ;   .byte 0x57, 0x70, 0x81, 0xcd
@@ -52,19 +52,19 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a5,32
 ;   vmv.s.x v0,a5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vxm v10,v9,a0,v0.t #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v10,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -75,7 +75,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a5, zero, 0x20
 ;   .byte 0x57, 0x70, 0x81, 0xcd
@@ -96,18 +96,18 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.i v0,4 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vxm v15,v9,a0,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v15,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -118,7 +118,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x30, 0x02, 0x5e
@@ -138,18 +138,18 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.i v0,1 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vxm v15,v9,a0,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v15,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -160,7 +160,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb0, 0x00, 0x5e
@@ -179,18 +179,18 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.i v0,1 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vfmerge.vfm v15,v9,fa0,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v15,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -201,7 +201,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb0, 0x00, 0x5e
@@ -220,18 +220,18 @@ block0(v0: f64x2, v1: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.i v0,2 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vfmerge.vfm v15,v9,fa0,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v15,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -242,7 +242,7 @@ block0(v0: f64x2, v1: f64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x30, 0x01, 0x5e
@@ -261,18 +261,18 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.i v0,1 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vfmerge.vfm v15,v9,fa0,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v15,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -283,7 +283,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb0, 0x00, 0x5e
@@ -303,18 +303,18 @@ block0(v0: f32x4, v1: f32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.i v0,2 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vfmerge.vfm v15,v9,fa0,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v15,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -325,7 +325,7 @@ block0(v0: f32x4, v1: f32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x30, 0x01, 0x5e
@@ -346,19 +346,19 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   lui a4,8
 ;   vmv.s.x v0,a4 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v8,v9,10,v0.t #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -369,7 +369,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   lui a4, 8
 ;   .byte 0x57, 0x70, 0x81, 0xcd
@@ -390,19 +390,19 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a4,32
 ;   vmv.s.x v0,a4 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v8,v9,-2,v0.t #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -413,7 +413,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a4, zero, 0x20
 ;   .byte 0x57, 0x70, 0x81, 0xcd
@@ -435,18 +435,18 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.i v0,4 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v14,v9,15,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -457,7 +457,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x30, 0x02, 0x5e
@@ -478,18 +478,18 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.i v0,1 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmerge.vim v14,v9,-9,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -500,7 +500,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb0, 0x00, 0x5e
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-ishl-const.clif b/cranelift/filetests/filetests/isa/riscv64/simd-ishl-const.clif
index 5ec336f0be3b..c1d10bc5ae4a 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-ishl-const.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-ishl-const.clif
@@ -11,17 +11,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vi v12,v9,5 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,7 +32,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0xb6, 0x92, 0x96
 ;   .byte 0x27, 0x06, 0x05, 0x02
@@ -49,17 +49,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vi v12,v9,5 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -70,7 +70,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0xb6, 0x92, 0x96
 ;   .byte 0x27, 0x06, 0x05, 0x02
@@ -87,17 +87,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vi v12,v9,5 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -108,7 +108,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0xb6, 0x92, 0x96
 ;   .byte 0x27, 0x06, 0x05, 0x02
@@ -125,17 +125,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vi v12,v9,5 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -146,7 +146,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0xb6, 0x92, 0x96
 ;   .byte 0x27, 0x06, 0x05, 0x02
@@ -164,17 +164,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vi v12,v9,5 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -185,7 +185,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0xb6, 0x92, 0x96
 ;   .byte 0x27, 0x06, 0x05, 0x02
@@ -202,17 +202,17 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vi v12,v9,5 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -223,7 +223,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0xb6, 0x92, 0x96
@@ -242,17 +242,17 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vi v12,v9,5 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -263,7 +263,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0xb6, 0x92, 0x96
@@ -282,17 +282,17 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vi v12,v9,5 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -303,7 +303,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0xb6, 0x92, 0x96
@@ -322,17 +322,17 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vi v12,v9,5 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -343,7 +343,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0xb6, 0x92, 0x96
@@ -363,17 +363,17 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vi v12,v9,5 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -384,7 +384,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0xb6, 0x92, 0x96
@@ -403,17 +403,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vi v12,v9,5 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -424,7 +424,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0x96
@@ -443,17 +443,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vi v12,v9,5 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -464,7 +464,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0x96
@@ -483,17 +483,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vi v12,v9,5 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -504,7 +504,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0x96
@@ -523,17 +523,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vi v12,v9,5 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -544,7 +544,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0x96
@@ -564,17 +564,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vi v12,v9,5 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -585,7 +585,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0x96
@@ -604,17 +604,17 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vi v12,v9,5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -625,7 +625,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0x96
@@ -644,17 +644,17 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vi v12,v9,5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -665,7 +665,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0x96
@@ -684,17 +684,17 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vi v12,v9,5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -705,7 +705,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0x96
@@ -724,17 +724,17 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vi v12,v9,5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -745,7 +745,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0x96
@@ -765,17 +765,17 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vi v12,v9,5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -786,7 +786,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0x96
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-ishl.clif b/cranelift/filetests/filetests/isa/riscv64/simd-ishl.clif
index a115b8ea1532..7a57ece57f12 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-ishl.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-ishl.clif
@@ -9,17 +9,17 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -30,7 +30,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x46, 0x95, 0x96
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -46,17 +46,17 @@ block0(v0: i8x16, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -67,7 +67,7 @@ block0(v0: i8x16, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x46, 0x95, 0x96
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -83,17 +83,17 @@ block0(v0: i8x16, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -104,7 +104,7 @@ block0(v0: i8x16, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x46, 0x95, 0x96
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -120,17 +120,17 @@ block0(v0: i8x16, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -141,7 +141,7 @@ block0(v0: i8x16, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x46, 0x95, 0x96
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -157,17 +157,17 @@ block0(v0: i8x16, v1: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vx v14,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v14,0(a2) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -178,7 +178,7 @@ block0(v0: i8x16, v1: i128):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x47, 0x95, 0x96
 ;   .byte 0x27, 0x07, 0x06, 0x02
@@ -194,17 +194,17 @@ block0(v0: i16x8, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -215,7 +215,7 @@ block0(v0: i16x8, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x46, 0x95, 0x96
@@ -233,17 +233,17 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -254,7 +254,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x46, 0x95, 0x96
@@ -272,17 +272,17 @@ block0(v0: i16x8, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -293,7 +293,7 @@ block0(v0: i16x8, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x46, 0x95, 0x96
@@ -311,17 +311,17 @@ block0(v0: i16x8, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -332,7 +332,7 @@ block0(v0: i16x8, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x46, 0x95, 0x96
@@ -350,17 +350,17 @@ block0(v0: i16x8, v1: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vx v14,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v14,0(a2) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -371,7 +371,7 @@ block0(v0: i16x8, v1: i128):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x47, 0x95, 0x96
@@ -389,17 +389,17 @@ block0(v0: i32x4, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -410,7 +410,7 @@ block0(v0: i32x4, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x96
@@ -428,17 +428,17 @@ block0(v0: i32x4, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -449,7 +449,7 @@ block0(v0: i32x4, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x96
@@ -467,17 +467,17 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -488,7 +488,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x96
@@ -506,17 +506,17 @@ block0(v0: i32x4, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -527,7 +527,7 @@ block0(v0: i32x4, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x96
@@ -545,17 +545,17 @@ block0(v0: i32x4, v1: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vx v14,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a2) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -566,7 +566,7 @@ block0(v0: i32x4, v1: i128):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x47, 0x95, 0x96
@@ -584,17 +584,17 @@ block0(v0: i64x2, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vx v13,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -605,7 +605,7 @@ block0(v0: i64x2, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x96
@@ -623,17 +623,17 @@ block0(v0: i64x2, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vx v13,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -644,7 +644,7 @@ block0(v0: i64x2, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x96
@@ -662,17 +662,17 @@ block0(v0: i64x2, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vx v13,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -683,7 +683,7 @@ block0(v0: i64x2, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x96
@@ -701,17 +701,17 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vx v13,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -722,7 +722,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x96
@@ -740,17 +740,17 @@ block0(v0: i64x2, v1: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsll.vx v14,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a2) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -761,7 +761,7 @@ block0(v0: i64x2, v1: i128):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x47, 0x95, 0x96
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-isub-splat.clif b/cranelift/filetests/filetests/isa/riscv64/simd-isub-splat.clif
index 37df496405f4..f15bc103a5e6 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-isub-splat.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-isub-splat.clif
@@ -11,17 +11,17 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vrsub.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,7 +32,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x46, 0x95, 0x0e
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -49,17 +49,17 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vrsub.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -70,7 +70,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x46, 0x95, 0x0e
@@ -89,17 +89,17 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vrsub.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -110,7 +110,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x0e
@@ -129,17 +129,17 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vrsub.vx v13,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -150,7 +150,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x0e
@@ -169,17 +169,17 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsub.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -190,7 +190,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x46, 0x95, 0x0a
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -207,17 +207,17 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsub.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -228,7 +228,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x46, 0x95, 0x0a
@@ -247,17 +247,17 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsub.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -268,7 +268,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x0a
@@ -287,17 +287,17 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsub.vx v13,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -308,7 +308,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x0a
@@ -328,18 +328,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   li a5,5
-;   vsub.vx v13,v9,a5 #avl=16, #vtype=(e8, m1, ta, ma)
-;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vadd.vi v12,v9,-5 #avl=16, #vtype=(e8, m1, ta, ma)
+;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -350,11 +349,10 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi a5, zero, 5
-;   .byte 0xd7, 0xc6, 0x97, 0x0a
-;   .byte 0xa7, 0x06, 0x05, 0x02
+;   .byte 0x57, 0xb6, 0x9d, 0x02
+;   .byte 0x27, 0x06, 0x05, 0x02
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -369,18 +367,18 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a5,-16
 ;   vsub.vx v13,v9,a5 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -391,7 +389,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a5, zero, -0x10
 ;   .byte 0x57, 0x70, 0x84, 0xcc
@@ -412,18 +410,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   li a5,15
-;   vsub.vx v13,v9,a5 #avl=4, #vtype=(e32, m1, ta, ma)
-;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vadd.vi v12,v9,-15 #avl=4, #vtype=(e32, m1, ta, ma)
+;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -434,13 +431,12 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi a5, zero, 0xf
 ;   .byte 0x57, 0x70, 0x02, 0xcd
-;   .byte 0xd7, 0xc6, 0x97, 0x0a
+;   .byte 0x57, 0xb6, 0x98, 0x02
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   .byte 0xa7, 0x06, 0x05, 0x02
+;   .byte 0x27, 0x06, 0x05, 0x02
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -455,18 +451,17 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   li a5,-5
-;   vsub.vx v13,v9,a5 #avl=2, #vtype=(e64, m1, ta, ma)
-;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vadd.vi v12,v9,5 #avl=2, #vtype=(e64, m1, ta, ma)
+;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -477,13 +472,12 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi a5, zero, -5
 ;   .byte 0x57, 0x70, 0x81, 0xcd
-;   .byte 0xd7, 0xc6, 0x97, 0x0a
+;   .byte 0x57, 0xb6, 0x92, 0x02
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   .byte 0xa7, 0x06, 0x05, 0x02
+;   .byte 0x27, 0x06, 0x05, 0x02
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -498,17 +492,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vrsub.vi v12,v9,5 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -519,7 +513,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0xb6, 0x92, 0x0e
 ;   .byte 0x27, 0x06, 0x05, 0x02
@@ -537,17 +531,17 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vrsub.vi v12,v9,-16 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -558,7 +552,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x36, 0x98, 0x0e
@@ -578,17 +572,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vrsub.vi v12,v9,15 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -599,7 +593,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xb6, 0x97, 0x0e
@@ -619,17 +613,17 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vrsub.vi v12,v9,-5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -640,7 +634,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb6, 0x9d, 0x0e
@@ -660,17 +654,17 @@ block0(v0: i16x8, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsub.wx v13,v9,a0 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -681,7 +675,7 @@ block0(v0: i16x8, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x74, 0xcc
 ;   .byte 0xd7, 0x66, 0x95, 0xde
@@ -701,17 +695,17 @@ block0(v0: i32x4, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsub.wx v13,v9,a0 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -722,7 +716,7 @@ block0(v0: i32x4, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0xf2, 0xcc
 ;   .byte 0xd7, 0x66, 0x95, 0xde
@@ -742,17 +736,17 @@ block0(v0: i64x2, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsub.wx v13,v9,a0 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -763,7 +757,7 @@ block0(v0: i64x2, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x71, 0xcd
 ;   .byte 0xd7, 0x66, 0x95, 0xde
@@ -783,17 +777,17 @@ block0(v0: i16x8, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsubu.wx v13,v9,a0 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -804,7 +798,7 @@ block0(v0: i16x8, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x74, 0xcc
 ;   .byte 0xd7, 0x66, 0x95, 0xda
@@ -824,17 +818,17 @@ block0(v0: i32x4, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsubu.wx v13,v9,a0 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -845,7 +839,7 @@ block0(v0: i32x4, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0xf2, 0xcc
 ;   .byte 0xd7, 0x66, 0x95, 0xda
@@ -865,17 +859,17 @@ block0(v0: i64x2, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsubu.wx v13,v9,a0 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -886,7 +880,7 @@ block0(v0: i64x2, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x71, 0xcd
 ;   .byte 0xd7, 0x66, 0x95, 0xda
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-isub-swiden-high.clif b/cranelift/filetests/filetests/isa/riscv64/simd-isub-swiden-high.clif
index 2a9322089ec2..0b32f873b71e 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-isub-swiden-high.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-isub-swiden-high.clif
@@ -11,20 +11,20 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,2 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vslidedown.vi v8,v11,2 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vwsub.vv v10,v14,v8 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -35,9 +35,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x37, 0x91, 0x3e
@@ -60,20 +60,20 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,4 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vslidedown.vi v8,v11,4 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vwsub.vv v10,v14,v8 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -84,9 +84,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x37, 0x92, 0x3e
@@ -109,20 +109,20 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,8 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v8,v11,8 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsub.vv v10,v14,v8 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -133,9 +133,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x37, 0x94, 0x3e
 ;   .byte 0x57, 0x34, 0xb4, 0x3e
@@ -158,18 +158,18 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v13,v9,2 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vwsub.vx v15,v13,a0 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v15,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -180,7 +180,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x36, 0x91, 0x3e
@@ -203,18 +203,18 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v13,v9,4 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vwsub.vx v15,v13,a0 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v15,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -225,7 +225,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x36, 0x92, 0x3e
@@ -248,18 +248,18 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v13,v9,8 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsub.vx v15,v13,a0 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v15,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -270,7 +270,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x36, 0x94, 0x3e
 ;   .byte 0x57, 0x70, 0x74, 0xcc
@@ -290,19 +290,19 @@ block0(v0: i32x4, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,2 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vwsub.wv v8,v11,v14 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -313,9 +313,9 @@ block0(v0: i32x4, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x37, 0x91, 0x3e
@@ -336,19 +336,19 @@ block0(v0: i16x8, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,4 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vwsub.wv v8,v11,v14 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -359,9 +359,9 @@ block0(v0: i16x8, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x37, 0x92, 0x3e
@@ -382,19 +382,19 @@ block0(v0: i8x16, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,8 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsub.wv v8,v11,v14 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -405,9 +405,9 @@ block0(v0: i8x16, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x37, 0x94, 0x3e
 ;   .byte 0x57, 0x70, 0x74, 0xcc
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-isub-swiden-low.clif b/cranelift/filetests/filetests/isa/riscv64/simd-isub-swiden-low.clif
index 424df797fdf0..6ab178ffeafa 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-isub-swiden-low.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-isub-swiden-low.clif
@@ -11,18 +11,18 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsub.vv v14,v9,v11 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -33,9 +33,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x71, 0xcd
 ;   .byte 0x57, 0xa7, 0x95, 0xce
@@ -55,18 +55,18 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsub.vv v14,v9,v11 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -77,9 +77,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0xf2, 0xcc
 ;   .byte 0x57, 0xa7, 0x95, 0xce
@@ -99,18 +99,18 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsub.vv v14,v9,v11 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -121,9 +121,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x74, 0xcc
 ;   .byte 0x57, 0xa7, 0x95, 0xce
@@ -144,17 +144,17 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsub.vx v13,v9,a0 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -165,7 +165,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x71, 0xcd
 ;   .byte 0xd7, 0x66, 0x95, 0xce
@@ -186,17 +186,17 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsub.vx v13,v9,a0 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -207,7 +207,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0xf2, 0xcc
 ;   .byte 0xd7, 0x66, 0x95, 0xce
@@ -228,17 +228,17 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsub.vx v13,v9,a0 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -249,7 +249,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x74, 0xcc
 ;   .byte 0xd7, 0x66, 0x95, 0xce
@@ -268,18 +268,18 @@ block0(v0: i32x4, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsub.wv v14,v11,v9 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -290,9 +290,9 @@ block0(v0: i32x4, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x71, 0xcd
 ;   .byte 0x57, 0xa7, 0xb4, 0xde
@@ -311,18 +311,18 @@ block0(v0: i16x8, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsub.wv v14,v11,v9 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -333,9 +333,9 @@ block0(v0: i16x8, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0xf2, 0xcc
 ;   .byte 0x57, 0xa7, 0xb4, 0xde
@@ -354,18 +354,18 @@ block0(v0: i8x16, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsub.wv v14,v11,v9 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -376,9 +376,9 @@ block0(v0: i8x16, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x74, 0xcc
 ;   .byte 0x57, 0xa7, 0xb4, 0xde
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-isub-uwiden-high.clif b/cranelift/filetests/filetests/isa/riscv64/simd-isub-uwiden-high.clif
index 809e2bf01940..f01f25dc7938 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-isub-uwiden-high.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-isub-uwiden-high.clif
@@ -11,20 +11,20 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,2 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vslidedown.vi v8,v11,2 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vwsubu.vv v10,v14,v8 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -35,9 +35,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x37, 0x91, 0x3e
@@ -60,20 +60,20 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,4 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vslidedown.vi v8,v11,4 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vwsubu.vv v10,v14,v8 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -84,9 +84,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x37, 0x92, 0x3e
@@ -109,20 +109,20 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,8 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v8,v11,8 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsubu.vv v10,v14,v8 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -133,9 +133,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x37, 0x94, 0x3e
 ;   .byte 0x57, 0x34, 0xb4, 0x3e
@@ -158,18 +158,18 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v13,v9,2 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vwsubu.vx v15,v13,a0 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v15,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -180,7 +180,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x36, 0x91, 0x3e
@@ -203,18 +203,18 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v13,v9,4 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vwsubu.vx v15,v13,a0 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v15,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -225,7 +225,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x36, 0x92, 0x3e
@@ -248,18 +248,18 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v13,v9,8 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsubu.vx v15,v13,a0 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v15,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -270,7 +270,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x36, 0x94, 0x3e
 ;   .byte 0x57, 0x70, 0x74, 0xcc
@@ -290,19 +290,19 @@ block0(v0: i32x4, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,2 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vwsubu.wv v8,v11,v14 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -313,9 +313,9 @@ block0(v0: i32x4, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x37, 0x91, 0x3e
@@ -336,19 +336,19 @@ block0(v0: i16x8, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,4 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vwsubu.wv v8,v11,v14 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -359,9 +359,9 @@ block0(v0: i16x8, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x37, 0x92, 0x3e
@@ -382,19 +382,19 @@ block0(v0: i8x16, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v14,v9,8 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsubu.wv v8,v11,v14 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -405,9 +405,9 @@ block0(v0: i8x16, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x37, 0x94, 0x3e
 ;   .byte 0x57, 0x70, 0x74, 0xcc
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-isub-uwiden-low.clif b/cranelift/filetests/filetests/isa/riscv64/simd-isub-uwiden-low.clif
index a8992b096f0e..93eaee5074c0 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-isub-uwiden-low.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-isub-uwiden-low.clif
@@ -11,18 +11,18 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsubu.vv v14,v9,v11 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -33,9 +33,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x71, 0xcd
 ;   .byte 0x57, 0xa7, 0x95, 0xca
@@ -55,18 +55,18 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsubu.vv v14,v9,v11 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -77,9 +77,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0xf2, 0xcc
 ;   .byte 0x57, 0xa7, 0x95, 0xca
@@ -99,18 +99,18 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsubu.vv v14,v9,v11 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -121,9 +121,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x74, 0xcc
 ;   .byte 0x57, 0xa7, 0x95, 0xca
@@ -144,17 +144,17 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsubu.vx v13,v9,a0 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -165,7 +165,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x71, 0xcd
 ;   .byte 0xd7, 0x66, 0x95, 0xca
@@ -186,17 +186,17 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsubu.vx v13,v9,a0 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -207,7 +207,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0xf2, 0xcc
 ;   .byte 0xd7, 0x66, 0x95, 0xca
@@ -228,17 +228,17 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsubu.vx v13,v9,a0 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -249,7 +249,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x74, 0xcc
 ;   .byte 0xd7, 0x66, 0x95, 0xca
@@ -268,18 +268,18 @@ block0(v0: i32x4, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsubu.wv v14,v11,v9 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -290,9 +290,9 @@ block0(v0: i32x4, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x71, 0xcd
 ;   .byte 0x57, 0xa7, 0xb4, 0xda
@@ -311,18 +311,18 @@ block0(v0: i16x8, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsubu.wv v14,v11,v9 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -333,9 +333,9 @@ block0(v0: i16x8, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0xf2, 0xcc
 ;   .byte 0x57, 0xa7, 0xb4, 0xda
@@ -354,18 +354,18 @@ block0(v0: i8x16, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vwsubu.wv v14,v11,v9 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -376,9 +376,9 @@ block0(v0: i8x16, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x74, 0xcc
 ;   .byte 0x57, 0xa7, 0xb4, 0xda
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-isub.clif b/cranelift/filetests/filetests/isa/riscv64/simd-isub.clif
index e4b368d12129..a4c495bc4347 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-isub.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-isub.clif
@@ -10,18 +10,18 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsub.vv v14,v9,v11 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,9 +32,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x87, 0x95, 0x0a
 ;   .byte 0x27, 0x07, 0x05, 0x02
@@ -50,18 +50,18 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsub.vv v14,v9,v11 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -72,9 +72,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x87, 0x95, 0x0a
@@ -92,18 +92,18 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsub.vv v14,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -114,9 +114,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x0a
@@ -134,18 +134,18 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsub.vv v14,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -156,9 +156,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x0a
@@ -177,17 +177,17 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsub.vx v13,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -198,7 +198,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x0a
@@ -217,17 +217,17 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vrsub.vx v13,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -238,7 +238,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x0e
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-load-extend.clif b/cranelift/filetests/filetests/isa/riscv64/simd-load-extend.clif
index 9b66d084ddb7..1fdb40c63e52 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-load-extend.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-load-extend.clif
@@ -18,7 +18,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   .byte 0x57, 0xf0, 0x80, 0xcd
-;   .byte 0x87, 0x75, 0x05, 0x02
+;   .byte 0x87, 0x75, 0x05, 0x02 ; trap: heap_oob
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x26, 0xb3, 0x4a
 ;   .byte 0x57, 0x70, 0x08, 0xcc
@@ -41,7 +41,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   .byte 0x57, 0xf0, 0x80, 0xcd
-;   .byte 0x87, 0x75, 0x05, 0x02
+;   .byte 0x87, 0x75, 0x05, 0x02 ; trap: heap_oob
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0xa6, 0xb3, 0x4a
 ;   .byte 0x57, 0x70, 0x08, 0xcc
@@ -64,7 +64,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   .byte 0x57, 0xf0, 0x80, 0xcd
-;   .byte 0x87, 0x75, 0x05, 0x02
+;   .byte 0x87, 0x75, 0x05, 0x02 ; trap: heap_oob
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x26, 0xb3, 0x4a
 ;   .byte 0x57, 0x70, 0x08, 0xcc
@@ -87,7 +87,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   .byte 0x57, 0xf0, 0x80, 0xcd
-;   .byte 0x87, 0x75, 0x05, 0x02
+;   .byte 0x87, 0x75, 0x05, 0x02 ; trap: heap_oob
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0xa6, 0xb3, 0x4a
 ;   .byte 0x57, 0x70, 0x08, 0xcc
@@ -110,7 +110,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   .byte 0x57, 0xf0, 0x80, 0xcd
-;   .byte 0x87, 0x75, 0x05, 0x02
+;   .byte 0x87, 0x75, 0x05, 0x02 ; trap: heap_oob
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x26, 0xb3, 0x4a
 ;   .byte 0x57, 0x70, 0x08, 0xcc
@@ -133,7 +133,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   .byte 0x57, 0xf0, 0x80, 0xcd
-;   .byte 0x87, 0x75, 0x05, 0x02
+;   .byte 0x87, 0x75, 0x05, 0x02 ; trap: heap_oob
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0xa6, 0xb3, 0x4a
 ;   .byte 0x57, 0x70, 0x08, 0xcc
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-load-splat.clif b/cranelift/filetests/filetests/isa/riscv64/simd-load-splat.clif
index 66ff1f368f23..32a2a3593e87 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-load-splat.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-load-splat.clif
@@ -18,7 +18,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lb a4, 0(a0)
+;   lb a4, 0(a0) ; trap: heap_oob
 ;   .byte 0x57, 0x70, 0x08, 0xcc
 ;   .byte 0x57, 0x46, 0x07, 0x5e
 ;   .byte 0x27, 0x86, 0x05, 0x02
@@ -40,7 +40,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lh a4, 0(a0)
+;   lh a4, 0(a0) ; trap: heap_oob
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x46, 0x07, 0x5e
 ;   .byte 0x57, 0x70, 0x08, 0xcc
@@ -63,7 +63,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lw a4, 0(a0)
+;   lw a4, 0(a0) ; trap: heap_oob
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x46, 0x07, 0x5e
 ;   .byte 0x57, 0x70, 0x08, 0xcc
@@ -86,7 +86,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld a4, 0(a0)
+;   ld a4, 0(a0) ; trap: heap_oob
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x46, 0x07, 0x5e
 ;   .byte 0x57, 0x70, 0x08, 0xcc
@@ -109,7 +109,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   flw fa4, 0(a0)
+;   flw fa4, 0(a0) ; trap: heap_oob
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x56, 0x07, 0x5e
 ;   .byte 0x57, 0x70, 0x08, 0xcc
@@ -132,7 +132,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   fld fa4, 0(a0)
+;   fld fa4, 0(a0) ; trap: heap_oob
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x56, 0x07, 0x5e
 ;   .byte 0x57, 0x70, 0x08, 0xcc
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-loads.clif b/cranelift/filetests/filetests/isa/riscv64/simd-loads.clif
index 509cd772b9bc..3c9c61d3e4aa 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-loads.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-loads.clif
@@ -18,7 +18,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   .byte 0x87, 0x05, 0x05, 0x02
+;   .byte 0x87, 0x05, 0x05, 0x02 ; trap: heap_oob
 ;   .byte 0xa7, 0x85, 0x05, 0x02
 ;   ret
 
@@ -37,7 +37,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   .byte 0x57, 0x70, 0x84, 0xcc
-;   .byte 0x87, 0x55, 0x05, 0x02
+;   .byte 0x87, 0x55, 0x05, 0x02 ; trap: heap_oob
 ;   .byte 0x57, 0x70, 0x08, 0xcc
 ;   .byte 0xa7, 0x85, 0x05, 0x02
 ;   ret
@@ -57,7 +57,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   .byte 0x57, 0x70, 0x02, 0xcd
-;   .byte 0x87, 0x65, 0x05, 0x02
+;   .byte 0x87, 0x65, 0x05, 0x02 ; trap: heap_oob
 ;   .byte 0x57, 0x70, 0x08, 0xcc
 ;   .byte 0xa7, 0x85, 0x05, 0x02
 ;   ret
@@ -77,7 +77,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   .byte 0x57, 0x70, 0x81, 0xcd
-;   .byte 0x87, 0x75, 0x05, 0x02
+;   .byte 0x87, 0x75, 0x05, 0x02 ; trap: heap_oob
 ;   .byte 0x57, 0x70, 0x08, 0xcc
 ;   .byte 0xa7, 0x85, 0x05, 0x02
 ;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-nearest.clif b/cranelift/filetests/filetests/isa/riscv64/simd-nearest.clif
index 7cd455b63bca..052e16155ce0 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-nearest.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-nearest.clif
@@ -10,12 +10,12 @@ block0(v0: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfabs.v v12,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   lui a1,307200
 ;   fmv.w.x fa2,a1
@@ -31,7 +31,7 @@ block0(v0: f32x4):
 ;   vse8.v v9,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -42,7 +42,7 @@ block0(v0: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x96, 0x94, 0x2a
@@ -71,12 +71,12 @@ block0(v0: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfabs.v v12,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   lui a1,1075
 ;   slli a2,a1,40
@@ -93,7 +93,7 @@ block0(v0: f64x2):
 ;   vse8.v v11,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -104,7 +104,7 @@ block0(v0: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x96, 0x94, 0x2a
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-popcnt.clif b/cranelift/filetests/filetests/isa/riscv64/simd-popcnt.clif
index 542541dc69b1..b4034edbe5e7 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-popcnt.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-popcnt.clif
@@ -9,12 +9,12 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a4,85
 ;   vsrl.vi v14,v9,1 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vand.vx v8,v14,a4 #avl=16, #vtype=(e8, m1, ta, ma)
@@ -35,7 +35,7 @@ block0(v0: i8x16):
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -46,7 +46,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a4, zero, 0x55
 ;   .byte 0x57, 0xb7, 0x90, 0xa2
@@ -78,12 +78,12 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   lui a4,5
 ;   addi a1,a4,1365
 ;   vsrl.vi v8,v9,1 #avl=8, #vtype=(e16, m1, ta, ma)
@@ -107,7 +107,7 @@ block0(v0: i16x8):
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -118,7 +118,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   lui a4, 5
 ;   addi a1, a4, 0x555
@@ -155,12 +155,12 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   lui a4,349525
 ;   addi a1,a4,1365
 ;   vsrl.vi v8,v9,1 #avl=4, #vtype=(e32, m1, ta, ma)
@@ -185,7 +185,7 @@ block0(v0: i32x4):
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -196,7 +196,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   lui a4, 0x55555
 ;   addi a1, a4, 0x555
@@ -234,12 +234,12 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld a4,[const(0)]
 ;   vsrl.vi v14,v9,1 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vand.vx v8,v14,a4 #avl=2, #vtype=(e64, m1, ta, ma)
@@ -260,7 +260,7 @@ block0(v0: i64x2):
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -271,7 +271,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   auipc a4, 0
 ;   ld a4, 0x74(a4)
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-saddsat.clif b/cranelift/filetests/filetests/isa/riscv64/simd-saddsat.clif
index d25c6489f955..38ae37223c65 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-saddsat.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-saddsat.clif
@@ -10,18 +10,18 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsadd.vv v14,v9,v11 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,9 +32,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x87, 0x95, 0x86
 ;   .byte 0x27, 0x07, 0x05, 0x02
@@ -50,18 +50,18 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsadd.vv v14,v9,v11 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -72,9 +72,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x87, 0x95, 0x86
@@ -92,18 +92,18 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsadd.vv v14,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -114,9 +114,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x86
@@ -134,18 +134,18 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsadd.vv v14,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -156,9 +156,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x86
@@ -178,17 +178,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsadd.vi v12,v9,5 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -199,7 +199,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0xb6, 0x92, 0x86
 ;   .byte 0x27, 0x06, 0x05, 0x02
@@ -217,17 +217,17 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsadd.vi v12,v9,-16 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -238,7 +238,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x36, 0x98, 0x86
@@ -258,17 +258,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsadd.vi v12,v9,15 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -279,7 +279,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xb6, 0x97, 0x86
@@ -299,17 +299,17 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsadd.vi v12,v9,-5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -320,7 +320,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb6, 0x9d, 0x86
@@ -339,17 +339,17 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsadd.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -360,7 +360,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x46, 0x95, 0x86
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -377,17 +377,17 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsadd.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -398,7 +398,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x46, 0x95, 0x86
@@ -417,17 +417,17 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsadd.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -438,7 +438,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x86
@@ -457,17 +457,17 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsadd.vx v13,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -478,7 +478,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x86
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-scalartovector.clif b/cranelift/filetests/filetests/isa/riscv64/simd-scalartovector.clif
index e9be3c8451b0..c503c4f5c8bc 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-scalartovector.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-scalartovector.clif
@@ -157,3 +157,108 @@ block0(v0: f64):
 ;   .byte 0xa7, 0x04, 0x05, 0x02
 ;   ret
 
+function %scalartovector_i8_imm(i8) -> i8x16 {
+block0(v0: i8):
+    v1 = iconst.i8 7
+    v2 = scalar_to_vector.i8x16 v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   vmv.v.x v10,zero #avl=16, #vtype=(e8, m1, ta, ma)
+;   vmv.v.i v0,1 #avl=2, #vtype=(e64, m1, ta, ma)
+;   vmerge.vim v14,v10,7,v0.t #avl=16, #vtype=(e8, m1, ta, ma)
+;   vse8.v v14,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x57, 0x70, 0x08, 0xcc
+;   .byte 0x57, 0x45, 0x00, 0x5e
+;   .byte 0x57, 0x70, 0x81, 0xcd
+;   .byte 0x57, 0xb0, 0x00, 0x5e
+;   .byte 0x57, 0x70, 0x08, 0xcc
+;   .byte 0x57, 0xb7, 0xa3, 0x5c
+;   .byte 0x27, 0x87, 0x05, 0x02
+;   ret
+
+function %scalartovector_i16_imm(i16) -> i16x8 {
+block0(v0: i16):
+    v1 = iconst.i16 7
+    v2 = scalar_to_vector.i16x8 v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   vmv.v.x v10,zero #avl=8, #vtype=(e16, m1, ta, ma)
+;   vmv.v.i v0,1 #avl=2, #vtype=(e64, m1, ta, ma)
+;   vmerge.vim v14,v10,7,v0.t #avl=8, #vtype=(e16, m1, ta, ma)
+;   vse8.v v14,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x57, 0x70, 0x84, 0xcc
+;   .byte 0x57, 0x45, 0x00, 0x5e
+;   .byte 0x57, 0x70, 0x81, 0xcd
+;   .byte 0x57, 0xb0, 0x00, 0x5e
+;   .byte 0x57, 0x70, 0x84, 0xcc
+;   .byte 0x57, 0xb7, 0xa3, 0x5c
+;   .byte 0x57, 0x70, 0x08, 0xcc
+;   .byte 0x27, 0x87, 0x05, 0x02
+;   ret
+
+function %scalartovector_i32_imm(i32) -> i32x4 {
+block0(v0: i32):
+    v1 = iconst.i32 7
+    v2 = scalar_to_vector.i32x4 v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   vmv.v.x v10,zero #avl=4, #vtype=(e32, m1, ta, ma)
+;   vmv.v.i v0,1 #avl=2, #vtype=(e64, m1, ta, ma)
+;   vmerge.vim v14,v10,7,v0.t #avl=4, #vtype=(e32, m1, ta, ma)
+;   vse8.v v14,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x57, 0x70, 0x02, 0xcd
+;   .byte 0x57, 0x45, 0x00, 0x5e
+;   .byte 0x57, 0x70, 0x81, 0xcd
+;   .byte 0x57, 0xb0, 0x00, 0x5e
+;   .byte 0x57, 0x70, 0x02, 0xcd
+;   .byte 0x57, 0xb7, 0xa3, 0x5c
+;   .byte 0x57, 0x70, 0x08, 0xcc
+;   .byte 0x27, 0x87, 0x05, 0x02
+;   ret
+
+function %scalartovector_i64_imm(i64) -> i64x2 {
+block0(v0: i64):
+    v1 = iconst.i64 7
+    v2 = scalar_to_vector.i64x2 v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   vmv.v.x v10,zero #avl=2, #vtype=(e64, m1, ta, ma)
+;   vmv.v.i v0,1 #avl=2, #vtype=(e64, m1, ta, ma)
+;   vmerge.vim v14,v10,7,v0.t #avl=2, #vtype=(e64, m1, ta, ma)
+;   vse8.v v14,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x57, 0x70, 0x81, 0xcd
+;   .byte 0x57, 0x45, 0x00, 0x5e
+;   .byte 0x57, 0xb0, 0x00, 0x5e
+;   .byte 0x57, 0xb7, 0xa3, 0x5c
+;   .byte 0x57, 0x70, 0x08, 0xcc
+;   .byte 0x27, 0x87, 0x05, 0x02
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-select.clif b/cranelift/filetests/filetests/isa/riscv64/simd-select.clif
index 5429e72e69ea..acbf77ed55d7 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-select.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-select.clif
@@ -9,18 +9,18 @@ block0(v0: i64, v1: i64x2, v2: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v10,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v12,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v10,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v12,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   select v15,v10,v12##condition=(a0 ne zero)
 ;   vse8.v v15,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -31,13 +31,12 @@ block0(v0: i64, v1: i64x2, v2: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x85, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x07, 0x86, 0x0f, 0x02
-;   beqz a0, 0xc
 ;   .byte 0xd7, 0x37, 0xa0, 0x9e
-;   j 8
+;   bnez a0, 8
 ;   .byte 0xd7, 0x37, 0xc0, 0x9e
 ;   .byte 0xa7, 0x87, 0x05, 0x02
 ;   ld ra, 8(sp)
@@ -52,19 +51,19 @@ block0(v0: i32, v1: i32x4, v2: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v10,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v12,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v10,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v12,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   sext.w a2,a0
 ;   select v9,v10,v12##condition=(a2 ne zero)
 ;   vse8.v v9,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -75,14 +74,13 @@ block0(v0: i32, v1: i32x4, v2: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x85, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x07, 0x86, 0x0f, 0x02
 ;   sext.w a2, a0
-;   beqz a2, 0xc
 ;   .byte 0xd7, 0x34, 0xa0, 0x9e
-;   j 8
+;   bnez a2, 8
 ;   .byte 0xd7, 0x34, 0xc0, 0x9e
 ;   .byte 0xa7, 0x84, 0x05, 0x02
 ;   ld ra, 8(sp)
@@ -97,20 +95,20 @@ block0(v0: i16, v1: i16x8, v2: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v10,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v12,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v10,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v12,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   slli a2,a0,48
 ;   srai a3,a2,48
 ;   select v11,v10,v12##condition=(a3 ne zero)
 ;   vse8.v v11,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -121,15 +119,14 @@ block0(v0: i16, v1: i16x8, v2: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x85, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x07, 0x86, 0x0f, 0x02
 ;   slli a2, a0, 0x30
 ;   srai a3, a2, 0x30
-;   beqz a3, 0xc
 ;   .byte 0xd7, 0x35, 0xa0, 0x9e
-;   j 8
+;   bnez a3, 8
 ;   .byte 0xd7, 0x35, 0xc0, 0x9e
 ;   .byte 0xa7, 0x85, 0x05, 0x02
 ;   ld ra, 8(sp)
@@ -144,19 +141,19 @@ block0(v0: i8, v1: i8x16, v2: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v10,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v12,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v10,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v12,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   andi a2,a0,255
 ;   select v9,v10,v12##condition=(a2 ne zero)
 ;   vse8.v v9,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -167,14 +164,13 @@ block0(v0: i8, v1: i8x16, v2: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x85, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x07, 0x86, 0x0f, 0x02
 ;   andi a2, a0, 0xff
-;   beqz a2, 0xc
 ;   .byte 0xd7, 0x34, 0xa0, 0x9e
-;   j 8
+;   bnez a2, 8
 ;   .byte 0xd7, 0x34, 0xc0, 0x9e
 ;   .byte 0xa7, 0x84, 0x05, 0x02
 ;   ld ra, 8(sp)
@@ -189,18 +185,18 @@ block0(v0: i64, v1: f64x2, v2: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v10,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v12,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v10,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v12,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   select v15,v10,v12##condition=(a0 ne zero)
 ;   vse8.v v15,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -211,13 +207,12 @@ block0(v0: i64, v1: f64x2, v2: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x85, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x07, 0x86, 0x0f, 0x02
-;   beqz a0, 0xc
 ;   .byte 0xd7, 0x37, 0xa0, 0x9e
-;   j 8
+;   bnez a0, 8
 ;   .byte 0xd7, 0x37, 0xc0, 0x9e
 ;   .byte 0xa7, 0x87, 0x05, 0x02
 ;   ld ra, 8(sp)
@@ -232,18 +227,18 @@ block0(v0: i64, v1: f32x4, v2: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v10,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v12,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v10,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v12,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   select v15,v10,v12##condition=(a0 ne zero)
 ;   vse8.v v15,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -254,13 +249,12 @@ block0(v0: i64, v1: f32x4, v2: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x85, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x07, 0x86, 0x0f, 0x02
-;   beqz a0, 0xc
 ;   .byte 0xd7, 0x37, 0xa0, 0x9e
-;   j 8
+;   bnez a0, 8
 ;   .byte 0xd7, 0x37, 0xc0, 0x9e
 ;   .byte 0xa7, 0x87, 0x05, 0x02
 ;   ld ra, 8(sp)
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-shuffle.clif b/cranelift/filetests/filetests/isa/riscv64/simd-shuffle.clif
index ff1b5e65cb96..fcabdcaf629c 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-shuffle.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-shuffle.clif
@@ -9,13 +9,13 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vle8.v v14,[const(0)] #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vrgather.vv v8,v9,v14 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vadd.vi v10,v14,-16 #avl=16, #vtype=(e8, m1, ta, ma)
@@ -24,7 +24,7 @@ block0(v0: i8x16, v1: i8x16):
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -35,9 +35,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   auipc t6, 0
 ;   addi t6, t6, 0x3c
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-smax.clif b/cranelift/filetests/filetests/isa/riscv64/simd-smax.clif
index 471a676ea15e..fc305527e324 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-smax.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-smax.clif
@@ -10,18 +10,18 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmax.vv v14,v9,v11 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,9 +32,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x87, 0x95, 0x1e
 ;   .byte 0x27, 0x07, 0x05, 0x02
@@ -50,18 +50,18 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmax.vv v14,v9,v11 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -72,9 +72,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x87, 0x95, 0x1e
@@ -92,18 +92,18 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmax.vv v14,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -114,9 +114,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x1e
@@ -134,18 +134,18 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmax.vv v14,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -156,9 +156,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x1e
@@ -178,18 +178,18 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a5,5
 ;   vmax.vx v13,v9,a5 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -200,7 +200,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a5, zero, 5
 ;   .byte 0xd7, 0xc6, 0x97, 0x1e
@@ -219,18 +219,18 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a5,-16
 ;   vmax.vx v13,v9,a5 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -241,7 +241,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a5, zero, -0x10
 ;   .byte 0x57, 0x70, 0x84, 0xcc
@@ -262,18 +262,18 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a5,15
 ;   vmax.vx v13,v9,a5 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -284,7 +284,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a5, zero, 0xf
 ;   .byte 0x57, 0x70, 0x02, 0xcd
@@ -305,18 +305,18 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a5,-5
 ;   vmax.vx v13,v9,a5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -327,7 +327,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a5, zero, -5
 ;   .byte 0x57, 0x70, 0x81, 0xcd
@@ -347,17 +347,17 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmax.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -368,7 +368,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x46, 0x95, 0x1e
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -385,17 +385,17 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmax.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -406,7 +406,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x46, 0x95, 0x1e
@@ -425,17 +425,17 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmax.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -446,7 +446,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x1e
@@ -465,17 +465,17 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmax.vx v13,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -486,7 +486,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x1e
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-smin.clif b/cranelift/filetests/filetests/isa/riscv64/simd-smin.clif
index e7cbf22b212b..cf451712c9e5 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-smin.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-smin.clif
@@ -10,18 +10,18 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmin.vv v14,v9,v11 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,9 +32,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x87, 0x95, 0x16
 ;   .byte 0x27, 0x07, 0x05, 0x02
@@ -50,18 +50,18 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmin.vv v14,v9,v11 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -72,9 +72,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x87, 0x95, 0x16
@@ -92,18 +92,18 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmin.vv v14,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -114,9 +114,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x16
@@ -134,18 +134,18 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmin.vv v14,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -156,9 +156,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x16
@@ -178,18 +178,18 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a5,5
 ;   vmin.vx v13,v9,a5 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -200,7 +200,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a5, zero, 5
 ;   .byte 0xd7, 0xc6, 0x97, 0x16
@@ -219,18 +219,18 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a5,-16
 ;   vmin.vx v13,v9,a5 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -241,7 +241,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a5, zero, -0x10
 ;   .byte 0x57, 0x70, 0x84, 0xcc
@@ -262,18 +262,18 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a5,15
 ;   vmin.vx v13,v9,a5 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -284,7 +284,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a5, zero, 0xf
 ;   .byte 0x57, 0x70, 0x02, 0xcd
@@ -305,18 +305,18 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a5,-5
 ;   vmin.vx v13,v9,a5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -327,7 +327,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a5, zero, -5
 ;   .byte 0x57, 0x70, 0x81, 0xcd
@@ -347,17 +347,17 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmin.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -368,7 +368,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x46, 0x95, 0x16
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -385,17 +385,17 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmin.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -406,7 +406,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x46, 0x95, 0x16
@@ -425,17 +425,17 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmin.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -446,7 +446,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x16
@@ -465,17 +465,17 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmin.vx v13,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -486,7 +486,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x16
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-smulhi.clif b/cranelift/filetests/filetests/isa/riscv64/simd-smulhi.clif
index 337985f82a1c..0cc1a40e87d2 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-smulhi.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-smulhi.clif
@@ -10,18 +10,18 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmulh.vv v14,v9,v11 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,9 +32,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0xa7, 0x95, 0x9e
 ;   .byte 0x27, 0x07, 0x05, 0x02
@@ -50,18 +50,18 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmulh.vv v14,v9,v11 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -72,9 +72,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0xa7, 0x95, 0x9e
@@ -92,18 +92,18 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmulh.vv v14,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -114,9 +114,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xa7, 0x95, 0x9e
@@ -134,18 +134,18 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmulh.vv v14,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -156,9 +156,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xa7, 0x95, 0x9e
@@ -177,17 +177,17 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmulh.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -198,7 +198,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x66, 0x95, 0x9e
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -215,17 +215,17 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmulh.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -236,7 +236,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x66, 0x95, 0x9e
@@ -255,17 +255,17 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmulh.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -276,7 +276,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x66, 0x95, 0x9e
@@ -295,17 +295,17 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmulh.vx v13,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -316,7 +316,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x66, 0x95, 0x9e
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-snarrow.clif b/cranelift/filetests/filetests/isa/riscv64/simd-snarrow.clif
index 1d05fbc75420..aa02ba6dff91 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-snarrow.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-snarrow.clif
@@ -9,20 +9,20 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vnclip.wi v8,v9,0 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vnclip.wi v9,v11,0 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vslideup.vi v8,v9,8 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -33,9 +33,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x74, 0xcc
 ;   .byte 0x57, 0x34, 0x90, 0xbe
@@ -55,20 +55,20 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vnclip.wi v8,v9,0 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vnclip.wi v9,v11,0 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vslideup.vi v8,v9,4 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -79,9 +79,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0xf2, 0xcc
 ;   .byte 0x57, 0x34, 0x90, 0xbe
@@ -102,20 +102,20 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vnclip.wi v8,v9,0 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vnclip.wi v9,v11,0 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vslideup.vi v8,v9,2 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -126,9 +126,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x71, 0xcd
 ;   .byte 0x57, 0x34, 0x90, 0xbe
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-sqmulroundsat.clif b/cranelift/filetests/filetests/isa/riscv64/simd-sqmulroundsat.clif
index 878bbd68ed29..caf2d70f6c7c 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-sqmulroundsat.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-sqmulroundsat.clif
@@ -9,18 +9,18 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsmul.vv v14,v9,v11 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -31,9 +31,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x87, 0x95, 0x9e
@@ -51,18 +51,18 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsmul.vv v14,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -73,9 +73,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x9e
@@ -94,17 +94,17 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsmul.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -115,7 +115,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x46, 0x95, 0x9e
@@ -134,17 +134,17 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsmul.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -155,7 +155,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x9e
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-sqrt.clif b/cranelift/filetests/filetests/isa/riscv64/simd-sqrt.clif
index 5b0513b5eea0..18fa204882c9 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-sqrt.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-sqrt.clif
@@ -10,17 +10,17 @@ block0(v0: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfsqrt.v v12,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -31,7 +31,7 @@ block0(v0: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x16, 0x90, 0x4e
@@ -49,17 +49,17 @@ block0(v0: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfsqrt.v v12,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -70,7 +70,7 @@ block0(v0: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x16, 0x90, 0x4e
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-sshr-const.clif b/cranelift/filetests/filetests/isa/riscv64/simd-sshr-const.clif
index 73ecefb1b014..eeba9163a722 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-sshr-const.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-sshr-const.clif
@@ -11,17 +11,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vi v12,v9,5 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,7 +32,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0xb6, 0x92, 0xa6
 ;   .byte 0x27, 0x06, 0x05, 0x02
@@ -49,17 +49,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vi v12,v9,5 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -70,7 +70,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0xb6, 0x92, 0xa6
 ;   .byte 0x27, 0x06, 0x05, 0x02
@@ -87,17 +87,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vi v12,v9,5 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -108,7 +108,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0xb6, 0x92, 0xa6
 ;   .byte 0x27, 0x06, 0x05, 0x02
@@ -125,17 +125,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vi v12,v9,5 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -146,7 +146,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0xb6, 0x92, 0xa6
 ;   .byte 0x27, 0x06, 0x05, 0x02
@@ -164,17 +164,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vi v12,v9,5 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -185,7 +185,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0xb6, 0x92, 0xa6
 ;   .byte 0x27, 0x06, 0x05, 0x02
@@ -202,17 +202,17 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vi v12,v9,5 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -223,7 +223,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0xb6, 0x92, 0xa6
@@ -242,17 +242,17 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vi v12,v9,5 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -263,7 +263,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0xb6, 0x92, 0xa6
@@ -282,17 +282,17 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vi v12,v9,5 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -303,7 +303,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0xb6, 0x92, 0xa6
@@ -322,17 +322,17 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vi v12,v9,5 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -343,7 +343,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0xb6, 0x92, 0xa6
@@ -363,17 +363,17 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vi v12,v9,5 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -384,7 +384,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0xb6, 0x92, 0xa6
@@ -403,17 +403,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vi v12,v9,5 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -424,7 +424,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0xa6
@@ -443,17 +443,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vi v12,v9,5 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -464,7 +464,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0xa6
@@ -483,17 +483,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vi v12,v9,5 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -504,7 +504,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0xa6
@@ -523,17 +523,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vi v12,v9,5 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -544,7 +544,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0xa6
@@ -564,17 +564,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vi v12,v9,5 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -585,7 +585,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0xa6
@@ -604,17 +604,17 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vi v12,v9,5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -625,7 +625,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0xa6
@@ -644,17 +644,17 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vi v12,v9,5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -665,7 +665,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0xa6
@@ -684,17 +684,17 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vi v12,v9,5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -705,7 +705,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0xa6
@@ -724,17 +724,17 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vi v12,v9,5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -745,7 +745,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0xa6
@@ -765,17 +765,17 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vi v12,v9,5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -786,7 +786,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0xa6
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-sshr.clif b/cranelift/filetests/filetests/isa/riscv64/simd-sshr.clif
index bb6af5e1c99e..c38ad904e738 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-sshr.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-sshr.clif
@@ -9,17 +9,17 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -30,7 +30,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x46, 0x95, 0xa6
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -46,17 +46,17 @@ block0(v0: i8x16, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -67,7 +67,7 @@ block0(v0: i8x16, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x46, 0x95, 0xa6
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -83,17 +83,17 @@ block0(v0: i8x16, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -104,7 +104,7 @@ block0(v0: i8x16, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x46, 0x95, 0xa6
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -120,17 +120,17 @@ block0(v0: i8x16, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -141,7 +141,7 @@ block0(v0: i8x16, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x46, 0x95, 0xa6
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -157,17 +157,17 @@ block0(v0: i8x16, v1: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vx v14,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v14,0(a2) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -178,7 +178,7 @@ block0(v0: i8x16, v1: i128):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x47, 0x95, 0xa6
 ;   .byte 0x27, 0x07, 0x06, 0x02
@@ -194,17 +194,17 @@ block0(v0: i16x8, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -215,7 +215,7 @@ block0(v0: i16x8, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x46, 0x95, 0xa6
@@ -233,17 +233,17 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -254,7 +254,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x46, 0x95, 0xa6
@@ -272,17 +272,17 @@ block0(v0: i16x8, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -293,7 +293,7 @@ block0(v0: i16x8, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x46, 0x95, 0xa6
@@ -311,17 +311,17 @@ block0(v0: i16x8, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -332,7 +332,7 @@ block0(v0: i16x8, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x46, 0x95, 0xa6
@@ -350,17 +350,17 @@ block0(v0: i16x8, v1: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vx v14,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v14,0(a2) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -371,7 +371,7 @@ block0(v0: i16x8, v1: i128):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x47, 0x95, 0xa6
@@ -389,17 +389,17 @@ block0(v0: i32x4, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -410,7 +410,7 @@ block0(v0: i32x4, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0xa6
@@ -428,17 +428,17 @@ block0(v0: i32x4, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -449,7 +449,7 @@ block0(v0: i32x4, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0xa6
@@ -467,17 +467,17 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -488,7 +488,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0xa6
@@ -506,17 +506,17 @@ block0(v0: i32x4, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -527,7 +527,7 @@ block0(v0: i32x4, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0xa6
@@ -545,17 +545,17 @@ block0(v0: i32x4, v1: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vx v14,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a2) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -566,7 +566,7 @@ block0(v0: i32x4, v1: i128):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x47, 0x95, 0xa6
@@ -584,17 +584,17 @@ block0(v0: i64x2, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vx v13,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -605,7 +605,7 @@ block0(v0: i64x2, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0xa6
@@ -623,17 +623,17 @@ block0(v0: i64x2, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vx v13,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -644,7 +644,7 @@ block0(v0: i64x2, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0xa6
@@ -662,17 +662,17 @@ block0(v0: i64x2, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vx v13,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -683,7 +683,7 @@ block0(v0: i64x2, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0xa6
@@ -701,17 +701,17 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vx v13,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -722,7 +722,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0xa6
@@ -740,17 +740,17 @@ block0(v0: i64x2, v1: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsra.vx v14,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a2) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -761,7 +761,7 @@ block0(v0: i64x2, v1: i128):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x47, 0x95, 0xa6
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-ssubsat.clif b/cranelift/filetests/filetests/isa/riscv64/simd-ssubsat.clif
index 3d53f6a10da6..5ca62728b027 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-ssubsat.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-ssubsat.clif
@@ -10,18 +10,18 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vssub.vv v14,v9,v11 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,9 +32,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x87, 0x95, 0x8e
 ;   .byte 0x27, 0x07, 0x05, 0x02
@@ -50,18 +50,18 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vssub.vv v14,v9,v11 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -72,9 +72,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x87, 0x95, 0x8e
@@ -92,18 +92,18 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vssub.vv v14,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -114,9 +114,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x8e
@@ -134,18 +134,18 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vssub.vv v14,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -156,9 +156,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x8e
@@ -178,18 +178,18 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a5,5
 ;   vssub.vx v13,v9,a5 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -200,7 +200,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a5, zero, 5
 ;   .byte 0xd7, 0xc6, 0x97, 0x8e
@@ -219,18 +219,18 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a5,-16
 ;   vssub.vx v13,v9,a5 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -241,7 +241,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a5, zero, -0x10
 ;   .byte 0x57, 0x70, 0x84, 0xcc
@@ -262,18 +262,18 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a5,15
 ;   vssub.vx v13,v9,a5 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -284,7 +284,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a5, zero, 0xf
 ;   .byte 0x57, 0x70, 0x02, 0xcd
@@ -305,18 +305,18 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.i v13,-5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vssub.vv v13,v13,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -327,7 +327,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0xb6, 0x0d, 0x5e
@@ -347,17 +347,17 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vssub.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -368,7 +368,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x46, 0x95, 0x8e
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -385,17 +385,17 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vssub.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -406,7 +406,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x46, 0x95, 0x8e
@@ -425,17 +425,17 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vssub.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -446,7 +446,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x8e
@@ -465,18 +465,18 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.x v14,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vssub.vv v14,v14,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -487,7 +487,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x47, 0x05, 0x5e
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-stores.clif b/cranelift/filetests/filetests/isa/riscv64/simd-stores.clif
index 2105d2c74471..60e7103ce6c0 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-stores.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-stores.clif
@@ -10,16 +10,16 @@ block0(v0: i64, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v10,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v10,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -30,9 +30,9 @@ block0(v0: i64, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x85, 0x0f, 0x02
-;   .byte 0x27, 0x05, 0x05, 0x02
+;   .byte 0x27, 0x05, 0x05, 0x02 ; trap: heap_oob
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -45,16 +45,16 @@ block0(v0: i64, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v10,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v10,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse16.v v10,0(a0) #avl=8, #vtype=(e16, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -65,10 +65,10 @@ block0(v0: i64, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
-;   .byte 0x27, 0x55, 0x05, 0x02
+;   .byte 0x27, 0x55, 0x05, 0x02 ; trap: heap_oob
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -81,16 +81,16 @@ block0(v0: i64, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v10,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v10,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse32.v v10,0(a0) #avl=4, #vtype=(e32, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -101,10 +101,10 @@ block0(v0: i64, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
-;   .byte 0x27, 0x65, 0x05, 0x02
+;   .byte 0x27, 0x65, 0x05, 0x02 ; trap: heap_oob
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -117,16 +117,16 @@ block0(v0: i64, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v10,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v10,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse64.v v10,0(a0) #avl=2, #vtype=(e64, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -137,10 +137,10 @@ block0(v0: i64, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
-;   .byte 0x27, 0x75, 0x05, 0x02
+;   .byte 0x27, 0x75, 0x05, 0x02 ; trap: heap_oob
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-swiden_high.clif b/cranelift/filetests/filetests/isa/riscv64/simd-swiden_high.clif
index 27e8fbb81023..cdaf053417a2 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-swiden_high.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-swiden_high.clif
@@ -9,18 +9,18 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v12,v9,8 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsext.vf2 v14,v12 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -31,7 +31,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x36, 0x94, 0x3e
 ;   .byte 0x57, 0x70, 0x84, 0xcc
@@ -50,18 +50,18 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v12,v9,4 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vsext.vf2 v14,v12 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -72,7 +72,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x36, 0x92, 0x3e
@@ -92,18 +92,18 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v12,v9,2 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vsext.vf2 v14,v12 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -114,7 +114,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x36, 0x91, 0x3e
@@ -135,18 +135,18 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v12,v9,12 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsext.vf4 v14,v12 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -157,7 +157,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x36, 0x96, 0x3e
 ;   .byte 0x57, 0x70, 0x02, 0xcd
@@ -177,18 +177,18 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v12,v9,6 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vsext.vf4 v14,v12 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -199,7 +199,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x36, 0x93, 0x3e
@@ -221,18 +221,18 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v12,v9,14 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsext.vf8 v14,v12 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -243,7 +243,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x36, 0x97, 0x3e
 ;   .byte 0x57, 0x70, 0x81, 0xcd
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-swiden_low.clif b/cranelift/filetests/filetests/isa/riscv64/simd-swiden_low.clif
index d19533868334..52f5182b1019 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-swiden_low.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-swiden_low.clif
@@ -9,17 +9,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsext.vf2 v12,v9 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -30,7 +30,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0xa6, 0x93, 0x4a
@@ -48,17 +48,17 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsext.vf2 v12,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -69,7 +69,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xa6, 0x93, 0x4a
@@ -87,17 +87,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsext.vf2 v12,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -108,7 +108,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xa6, 0x93, 0x4a
@@ -127,17 +127,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsext.vf4 v12,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -148,7 +148,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xa6, 0x92, 0x4a
@@ -167,17 +167,17 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsext.vf4 v12,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -188,7 +188,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xa6, 0x92, 0x4a
@@ -208,17 +208,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsext.vf8 v12,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -229,7 +229,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xa6, 0x91, 0x4a
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-swizzle.clif b/cranelift/filetests/filetests/isa/riscv64/simd-swizzle.clif
index f958fa0c8579..f58871878c00 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-swizzle.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-swizzle.clif
@@ -9,18 +9,18 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vrgather.vv v14,v9,v11 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -31,9 +31,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x87, 0x95, 0x32
 ;   .byte 0x27, 0x07, 0x05, 0x02
@@ -50,17 +50,17 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vrgather.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -71,7 +71,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x46, 0x95, 0x32
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -89,17 +89,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vrgather.vi v12,v9,2 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -110,7 +110,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x36, 0x91, 0x32
 ;   .byte 0x27, 0x06, 0x05, 0x02
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-trunc.clif b/cranelift/filetests/filetests/isa/riscv64/simd-trunc.clif
index 723c07e55de3..7feed3fc1ed5 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-trunc.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-trunc.clif
@@ -10,12 +10,12 @@ block0(v0: f32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfabs.v v12,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   lui a1,307200
 ;   fmv.w.x fa2,a1
@@ -29,7 +29,7 @@ block0(v0: f32x4):
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -40,7 +40,7 @@ block0(v0: f32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x96, 0x94, 0x2a
@@ -67,12 +67,12 @@ block0(v0: f64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vfabs.v v12,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   lui a1,1075
 ;   slli a2,a1,40
@@ -87,7 +87,7 @@ block0(v0: f64x2):
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -98,7 +98,7 @@ block0(v0: f64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x96, 0x94, 0x2a
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-uaddsat.clif b/cranelift/filetests/filetests/isa/riscv64/simd-uaddsat.clif
index c6e514e313ba..be89331422d7 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-uaddsat.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-uaddsat.clif
@@ -10,18 +10,18 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsaddu.vv v14,v9,v11 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,9 +32,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x87, 0x95, 0x82
 ;   .byte 0x27, 0x07, 0x05, 0x02
@@ -50,18 +50,18 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsaddu.vv v14,v9,v11 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -72,9 +72,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x87, 0x95, 0x82
@@ -92,18 +92,18 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsaddu.vv v14,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -114,9 +114,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x82
@@ -134,18 +134,18 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsaddu.vv v14,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -156,9 +156,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x82
@@ -178,17 +178,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsaddu.vi v12,v9,5 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -199,7 +199,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0xb6, 0x92, 0x82
 ;   .byte 0x27, 0x06, 0x05, 0x02
@@ -217,17 +217,17 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsaddu.vi v12,v9,-16 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -238,7 +238,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x36, 0x98, 0x82
@@ -258,17 +258,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsaddu.vi v12,v9,15 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -279,7 +279,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xb6, 0x97, 0x82
@@ -299,17 +299,17 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsaddu.vi v12,v9,-5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -320,7 +320,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb6, 0x9d, 0x82
@@ -339,17 +339,17 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsaddu.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -360,7 +360,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x46, 0x95, 0x82
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -377,17 +377,17 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsaddu.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -398,7 +398,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x46, 0x95, 0x82
@@ -417,17 +417,17 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsaddu.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -438,7 +438,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x82
@@ -457,17 +457,17 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsaddu.vx v13,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -478,7 +478,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x82
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-umax.clif b/cranelift/filetests/filetests/isa/riscv64/simd-umax.clif
index e08860a3ea26..e14c88d9ca2d 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-umax.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-umax.clif
@@ -9,18 +9,18 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmaxu.vv v14,v9,v11 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -31,9 +31,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x87, 0x95, 0x1a
 ;   .byte 0x27, 0x07, 0x05, 0x02
@@ -49,18 +49,18 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmaxu.vv v14,v9,v11 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -71,9 +71,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x87, 0x95, 0x1a
@@ -91,18 +91,18 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmaxu.vv v14,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -113,9 +113,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x1a
@@ -133,18 +133,18 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmaxu.vv v14,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -155,9 +155,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x1a
@@ -177,18 +177,18 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a5,5
 ;   vmaxu.vx v13,v9,a5 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -199,7 +199,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a5, zero, 5
 ;   .byte 0xd7, 0xc6, 0x97, 0x1a
@@ -218,18 +218,18 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a5,-16
 ;   vmaxu.vx v13,v9,a5 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -240,7 +240,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a5, zero, -0x10
 ;   .byte 0x57, 0x70, 0x84, 0xcc
@@ -261,18 +261,18 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a5,15
 ;   vmaxu.vx v13,v9,a5 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -283,7 +283,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a5, zero, 0xf
 ;   .byte 0x57, 0x70, 0x02, 0xcd
@@ -304,18 +304,18 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a5,-5
 ;   vmaxu.vx v13,v9,a5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -326,7 +326,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a5, zero, -5
 ;   .byte 0x57, 0x70, 0x81, 0xcd
@@ -346,17 +346,17 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmaxu.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -367,7 +367,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x46, 0x95, 0x1a
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -384,17 +384,17 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmaxu.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -405,7 +405,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x46, 0x95, 0x1a
@@ -424,17 +424,17 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmaxu.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -445,7 +445,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x1a
@@ -464,17 +464,17 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmaxu.vx v13,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -485,7 +485,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x1a
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-umin.clif b/cranelift/filetests/filetests/isa/riscv64/simd-umin.clif
index 72482e74f45e..ff3b37cf47a3 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-umin.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-umin.clif
@@ -10,18 +10,18 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vminu.vv v14,v9,v11 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,9 +32,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x87, 0x95, 0x12
 ;   .byte 0x27, 0x07, 0x05, 0x02
@@ -50,18 +50,18 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vminu.vv v14,v9,v11 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -72,9 +72,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x87, 0x95, 0x12
@@ -92,18 +92,18 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vminu.vv v14,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -114,9 +114,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x12
@@ -134,18 +134,18 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vminu.vv v14,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -156,9 +156,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x12
@@ -178,18 +178,18 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a5,5
 ;   vminu.vx v13,v9,a5 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -200,7 +200,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a5, zero, 5
 ;   .byte 0xd7, 0xc6, 0x97, 0x12
@@ -219,18 +219,18 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a5,-16
 ;   vminu.vx v13,v9,a5 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -241,7 +241,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a5, zero, -0x10
 ;   .byte 0x57, 0x70, 0x84, 0xcc
@@ -262,18 +262,18 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a5,15
 ;   vminu.vx v13,v9,a5 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -284,7 +284,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a5, zero, 0xf
 ;   .byte 0x57, 0x70, 0x02, 0xcd
@@ -305,18 +305,18 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a5,-5
 ;   vminu.vx v13,v9,a5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -327,7 +327,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a5, zero, -5
 ;   .byte 0x57, 0x70, 0x81, 0xcd
@@ -347,17 +347,17 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vminu.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -368,7 +368,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x46, 0x95, 0x12
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -385,17 +385,17 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vminu.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -406,7 +406,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x46, 0x95, 0x12
@@ -425,17 +425,17 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vminu.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -446,7 +446,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x12
@@ -465,17 +465,17 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vminu.vx v13,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -486,7 +486,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x12
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-umulhi.clif b/cranelift/filetests/filetests/isa/riscv64/simd-umulhi.clif
index 0e61ff3ff633..57327e2d8254 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-umulhi.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-umulhi.clif
@@ -10,18 +10,18 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmulhu.vv v14,v9,v11 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,9 +32,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0xa7, 0x95, 0x92
 ;   .byte 0x27, 0x07, 0x05, 0x02
@@ -50,18 +50,18 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmulhu.vv v14,v9,v11 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -72,9 +72,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0xa7, 0x95, 0x92
@@ -92,18 +92,18 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmulhu.vv v14,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -114,9 +114,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xa7, 0x95, 0x92
@@ -134,18 +134,18 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmulhu.vv v14,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -156,9 +156,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xa7, 0x95, 0x92
@@ -177,17 +177,17 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmulhu.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -198,7 +198,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x66, 0x95, 0x92
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -215,17 +215,17 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmulhu.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -236,7 +236,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x66, 0x95, 0x92
@@ -255,17 +255,17 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmulhu.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -276,7 +276,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x66, 0x95, 0x92
@@ -295,17 +295,17 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmulhu.vx v13,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -316,7 +316,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x66, 0x95, 0x92
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-unarrow.clif b/cranelift/filetests/filetests/isa/riscv64/simd-unarrow.clif
index ff46b1bbb248..2fce74bc3ff3 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-unarrow.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-unarrow.clif
@@ -9,13 +9,13 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmax.vx v14,v9,zero #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vmax.vx v8,v11,zero #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vnclipu.wi v12,v14,0 #avl=8, #vtype=(e8, mf2, ta, ma)
@@ -24,7 +24,7 @@ block0(v0: i16x8, v1: i16x8):
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -35,9 +35,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x47, 0x90, 0x1e
@@ -60,13 +60,13 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmax.vx v14,v9,zero #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmax.vx v8,v11,zero #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vnclipu.wi v12,v14,0 #avl=4, #vtype=(e16, mf2, ta, ma)
@@ -75,7 +75,7 @@ block0(v0: i32x4, v1: i32x4):
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -86,9 +86,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x47, 0x90, 0x1e
@@ -112,13 +112,13 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmax.vx v14,v9,zero #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmax.vx v8,v11,zero #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vnclipu.wi v12,v14,0 #avl=2, #vtype=(e32, mf2, ta, ma)
@@ -127,7 +127,7 @@ block0(v0: i64x2, v1: i64x2):
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -138,9 +138,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x47, 0x90, 0x1e
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-ushr-const.clif b/cranelift/filetests/filetests/isa/riscv64/simd-ushr-const.clif
index 4bda7ac83b3b..962276dd6538 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-ushr-const.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-ushr-const.clif
@@ -11,17 +11,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vi v12,v9,5 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,7 +32,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0xb6, 0x92, 0xa2
 ;   .byte 0x27, 0x06, 0x05, 0x02
@@ -49,17 +49,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vi v12,v9,5 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -70,7 +70,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0xb6, 0x92, 0xa2
 ;   .byte 0x27, 0x06, 0x05, 0x02
@@ -87,17 +87,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vi v12,v9,5 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -108,7 +108,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0xb6, 0x92, 0xa2
 ;   .byte 0x27, 0x06, 0x05, 0x02
@@ -125,17 +125,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vi v12,v9,5 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -146,7 +146,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0xb6, 0x92, 0xa2
 ;   .byte 0x27, 0x06, 0x05, 0x02
@@ -164,17 +164,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vi v12,v9,5 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -185,7 +185,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0xb6, 0x92, 0xa2
 ;   .byte 0x27, 0x06, 0x05, 0x02
@@ -202,17 +202,17 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vi v12,v9,5 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -223,7 +223,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0xb6, 0x92, 0xa2
@@ -242,17 +242,17 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vi v12,v9,5 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -263,7 +263,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0xb6, 0x92, 0xa2
@@ -282,17 +282,17 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vi v12,v9,5 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -303,7 +303,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0xb6, 0x92, 0xa2
@@ -322,17 +322,17 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vi v12,v9,5 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -343,7 +343,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0xb6, 0x92, 0xa2
@@ -363,17 +363,17 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vi v12,v9,5 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -384,7 +384,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0xb6, 0x92, 0xa2
@@ -403,17 +403,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vi v12,v9,5 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -424,7 +424,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0xa2
@@ -443,17 +443,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vi v12,v9,5 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -464,7 +464,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0xa2
@@ -483,17 +483,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vi v12,v9,5 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -504,7 +504,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0xa2
@@ -523,17 +523,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vi v12,v9,5 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -544,7 +544,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0xa2
@@ -564,17 +564,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vi v12,v9,5 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -585,7 +585,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0xa2
@@ -604,17 +604,17 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vi v12,v9,5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -625,7 +625,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0xa2
@@ -644,17 +644,17 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vi v12,v9,5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -665,7 +665,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0xa2
@@ -684,17 +684,17 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vi v12,v9,5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -705,7 +705,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0xa2
@@ -724,17 +724,17 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vi v12,v9,5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -745,7 +745,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0xa2
@@ -765,17 +765,17 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vi v12,v9,5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -786,7 +786,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb6, 0x92, 0xa2
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-ushr.clif b/cranelift/filetests/filetests/isa/riscv64/simd-ushr.clif
index de8ddf56995a..3f2fba5aa60d 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-ushr.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-ushr.clif
@@ -9,17 +9,17 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -30,7 +30,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x46, 0x95, 0xa2
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -46,17 +46,17 @@ block0(v0: i8x16, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -67,7 +67,7 @@ block0(v0: i8x16, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x46, 0x95, 0xa2
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -83,17 +83,17 @@ block0(v0: i8x16, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -104,7 +104,7 @@ block0(v0: i8x16, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x46, 0x95, 0xa2
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -120,17 +120,17 @@ block0(v0: i8x16, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -141,7 +141,7 @@ block0(v0: i8x16, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x46, 0x95, 0xa2
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -157,17 +157,17 @@ block0(v0: i8x16, v1: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vx v14,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v14,0(a2) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -178,7 +178,7 @@ block0(v0: i8x16, v1: i128):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x47, 0x95, 0xa2
 ;   .byte 0x27, 0x07, 0x06, 0x02
@@ -194,17 +194,17 @@ block0(v0: i16x8, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -215,7 +215,7 @@ block0(v0: i16x8, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x46, 0x95, 0xa2
@@ -233,17 +233,17 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -254,7 +254,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x46, 0x95, 0xa2
@@ -272,17 +272,17 @@ block0(v0: i16x8, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -293,7 +293,7 @@ block0(v0: i16x8, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x46, 0x95, 0xa2
@@ -311,17 +311,17 @@ block0(v0: i16x8, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -332,7 +332,7 @@ block0(v0: i16x8, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x46, 0x95, 0xa2
@@ -350,17 +350,17 @@ block0(v0: i16x8, v1: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vx v14,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v14,0(a2) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -371,7 +371,7 @@ block0(v0: i16x8, v1: i128):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x47, 0x95, 0xa2
@@ -389,17 +389,17 @@ block0(v0: i32x4, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -410,7 +410,7 @@ block0(v0: i32x4, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0xa2
@@ -428,17 +428,17 @@ block0(v0: i32x4, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -449,7 +449,7 @@ block0(v0: i32x4, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0xa2
@@ -467,17 +467,17 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -488,7 +488,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0xa2
@@ -506,17 +506,17 @@ block0(v0: i32x4, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -527,7 +527,7 @@ block0(v0: i32x4, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0xa2
@@ -545,17 +545,17 @@ block0(v0: i32x4, v1: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vx v14,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a2) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -566,7 +566,7 @@ block0(v0: i32x4, v1: i128):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x47, 0x95, 0xa2
@@ -584,17 +584,17 @@ block0(v0: i64x2, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vx v13,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -605,7 +605,7 @@ block0(v0: i64x2, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0xa2
@@ -623,17 +623,17 @@ block0(v0: i64x2, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vx v13,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -644,7 +644,7 @@ block0(v0: i64x2, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0xa2
@@ -662,17 +662,17 @@ block0(v0: i64x2, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vx v13,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -683,7 +683,7 @@ block0(v0: i64x2, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0xa2
@@ -701,17 +701,17 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vx v13,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -722,7 +722,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0xa2
@@ -740,17 +740,17 @@ block0(v0: i64x2, v1: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vsrl.vx v14,v9,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a2) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -761,7 +761,7 @@ block0(v0: i64x2, v1: i128):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x47, 0x95, 0xa2
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-usubsat.clif b/cranelift/filetests/filetests/isa/riscv64/simd-usubsat.clif
index b24beb465c61..7e2941f551bf 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-usubsat.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-usubsat.clif
@@ -10,18 +10,18 @@ block0(v0: i8x16, v1: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vssubu.vv v14,v9,v11 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,9 +32,9 @@ block0(v0: i8x16, v1: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x87, 0x95, 0x8a
 ;   .byte 0x27, 0x07, 0x05, 0x02
@@ -50,18 +50,18 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vssubu.vv v14,v9,v11 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -72,9 +72,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x87, 0x95, 0x8a
@@ -92,18 +92,18 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vssubu.vv v14,v9,v11 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -114,9 +114,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x8a
@@ -134,18 +134,18 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vssubu.vv v14,v9,v11 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -156,9 +156,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x87, 0x95, 0x8a
@@ -178,18 +178,18 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a5,5
 ;   vssubu.vx v13,v9,a5 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -200,7 +200,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a5, zero, 5
 ;   .byte 0xd7, 0xc6, 0x97, 0x8a
@@ -219,18 +219,18 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a5,-16
 ;   vssubu.vx v13,v9,a5 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -241,7 +241,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a5, zero, -0x10
 ;   .byte 0x57, 0x70, 0x84, 0xcc
@@ -262,18 +262,18 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   li a5,15
 ;   vssubu.vx v13,v9,a5 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -284,7 +284,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   addi a5, zero, 0xf
 ;   .byte 0x57, 0x70, 0x02, 0xcd
@@ -305,18 +305,18 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.i v13,-5 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vssubu.vv v13,v13,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v13,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -327,7 +327,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0xd7, 0xb6, 0x0d, 0x5e
@@ -347,17 +347,17 @@ block0(v0: i8x16, v1: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vssubu.vx v13,v9,a0 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -368,7 +368,7 @@ block0(v0: i8x16, v1: i8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0xd7, 0x46, 0x95, 0x8a
 ;   .byte 0xa7, 0x86, 0x05, 0x02
@@ -385,17 +385,17 @@ block0(v0: i16x8, v1: i16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vssubu.vx v13,v9,a0 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -406,7 +406,7 @@ block0(v0: i16x8, v1: i16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0xd7, 0x46, 0x95, 0x8a
@@ -425,17 +425,17 @@ block0(v0: i32x4, v1: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vssubu.vx v13,v9,a0 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v13,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -446,7 +446,7 @@ block0(v0: i32x4, v1: i32):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0xd7, 0x46, 0x95, 0x8a
@@ -465,18 +465,18 @@ block0(v0: i64x2, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.x v14,a0 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vssubu.vv v14,v14,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a1) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -487,7 +487,7 @@ block0(v0: i64x2, v1: i64):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x47, 0x05, 0x5e
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-uunarrow.clif b/cranelift/filetests/filetests/isa/riscv64/simd-uunarrow.clif
index 6e5321eebf2f..44f0d3e33234 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-uunarrow.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-uunarrow.clif
@@ -9,20 +9,20 @@ block0(v0: i16x8, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vnclipu.wi v8,v9,0 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vnclipu.wi v9,v11,0 #avl=8, #vtype=(e8, mf2, ta, ma)
 ;   vslideup.vi v8,v9,8 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -33,9 +33,9 @@ block0(v0: i16x8, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x74, 0xcc
 ;   .byte 0x57, 0x34, 0x90, 0xba
@@ -55,20 +55,20 @@ block0(v0: i32x4, v1: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vnclipu.wi v8,v9,0 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vnclipu.wi v9,v11,0 #avl=4, #vtype=(e16, mf2, ta, ma)
 ;   vslideup.vi v8,v9,4 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -79,9 +79,9 @@ block0(v0: i32x4, v1: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0xf2, 0xcc
 ;   .byte 0x57, 0x34, 0x90, 0xba
@@ -102,20 +102,20 @@ block0(v0: i64x2, v1: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vnclipu.wi v8,v9,0 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vnclipu.wi v9,v11,0 #avl=2, #vtype=(e32, mf2, ta, ma)
 ;   vslideup.vi v8,v9,2 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v8,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -126,9 +126,9 @@ block0(v0: i64x2, v1: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x71, 0xcd
 ;   .byte 0x57, 0x34, 0x90, 0xba
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-uwiden_high.clif b/cranelift/filetests/filetests/isa/riscv64/simd-uwiden_high.clif
index 1ab8bc5707e0..dea0e6ba83ba 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-uwiden_high.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-uwiden_high.clif
@@ -10,18 +10,18 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v12,v9,8 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vzext.vf2 v14,v12 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,7 +32,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x36, 0x94, 0x3e
 ;   .byte 0x57, 0x70, 0x84, 0xcc
@@ -51,18 +51,18 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v12,v9,4 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vzext.vf2 v14,v12 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -73,7 +73,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x36, 0x92, 0x3e
@@ -93,18 +93,18 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v12,v9,2 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vzext.vf2 v14,v12 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -115,7 +115,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x36, 0x91, 0x3e
@@ -136,18 +136,18 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v12,v9,12 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vzext.vf4 v14,v12 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -158,7 +158,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x36, 0x96, 0x3e
 ;   .byte 0x57, 0x70, 0x02, 0xcd
@@ -178,18 +178,18 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v12,v9,6 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vzext.vf4 v14,v12 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -200,7 +200,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x36, 0x93, 0x3e
@@ -222,18 +222,18 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vslidedown.vi v12,v9,14 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vzext.vf8 v14,v12 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v14,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -244,7 +244,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x36, 0x97, 0x3e
 ;   .byte 0x57, 0x70, 0x81, 0xcd
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-uwiden_low.clif b/cranelift/filetests/filetests/isa/riscv64/simd-uwiden_low.clif
index dd99d93d81b4..af2f19eb6b3a 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-uwiden_low.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-uwiden_low.clif
@@ -10,17 +10,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vzext.vf2 v12,v9 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -31,7 +31,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x26, 0x93, 0x4a
@@ -49,17 +49,17 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vzext.vf2 v12,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -70,7 +70,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x26, 0x93, 0x4a
@@ -88,17 +88,17 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vzext.vf2 v12,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -109,7 +109,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x26, 0x93, 0x4a
@@ -128,17 +128,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vzext.vf4 v12,v9 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -149,7 +149,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x26, 0x92, 0x4a
@@ -168,17 +168,17 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vzext.vf4 v12,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -189,7 +189,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x26, 0x92, 0x4a
@@ -209,17 +209,17 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vzext.vf8 v12,v9 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vse8.v v12,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -230,7 +230,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x26, 0x91, 0x4a
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-valltrue.clif b/cranelift/filetests/filetests/isa/riscv64/simd-valltrue.clif
index f59e1a542d79..d719b2f701a0 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-valltrue.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-valltrue.clif
@@ -9,18 +9,18 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v8,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v8,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.i v10,1 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vredminu.vs v12,v8,v10 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.x.s a0,v12 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -31,7 +31,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0xb5, 0x00, 0x5e
 ;   .byte 0x57, 0x26, 0x85, 0x12
@@ -48,18 +48,18 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v8,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v8,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.i v10,1 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vredminu.vs v12,v8,v10 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vmv.x.s a0,v12 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -70,7 +70,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0xb5, 0x00, 0x5e
@@ -88,18 +88,18 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v8,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v8,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.i v10,1 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vredminu.vs v12,v8,v10 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.x.s a0,v12 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -110,7 +110,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0xb5, 0x00, 0x5e
@@ -128,18 +128,18 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v8,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v8,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.v.i v10,1 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vredminu.vs v12,v8,v10 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.x.s a0,v12 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -150,7 +150,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0xb5, 0x00, 0x5e
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-vanytrue.clif b/cranelift/filetests/filetests/isa/riscv64/simd-vanytrue.clif
index 6495cc757364..99e199487d92 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-vanytrue.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-vanytrue.clif
@@ -10,18 +10,18 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v8,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v8,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vredmaxu.vs v10,v8,v8 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.x.s a4,v10 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   sltu a0,zero,a4
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -32,7 +32,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x25, 0x84, 0x1a
 ;   .byte 0x57, 0x27, 0xa0, 0x42
@@ -49,18 +49,18 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v8,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v8,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vredmaxu.vs v10,v8,v8 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vmv.x.s a4,v10 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   sltu a0,zero,a4
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -71,7 +71,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x25, 0x84, 0x1a
@@ -89,18 +89,18 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v8,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v8,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vredmaxu.vs v10,v8,v8 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.x.s a4,v10 #avl=4, #vtype=(e32, m1, ta, ma)
 ;   sltu a0,zero,a4
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -111,7 +111,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x25, 0x84, 0x1a
@@ -129,18 +129,18 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v8,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v8,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vredmaxu.vs v10,v8,v8 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.x.s a4,v10 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   sltu a0,zero,a4
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -151,7 +151,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x25, 0x84, 0x1a
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-vhighbits.clif b/cranelift/filetests/filetests/isa/riscv64/simd-vhighbits.clif
index 4c40c040de7c..c44d253e0b7b 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-vhighbits.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-vhighbits.clif
@@ -10,12 +10,12 @@ block0(v0: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v8,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v8,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmslt.vx v10,v8,zero #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmv.x.s a4,v10 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   lui a0,16
@@ -23,7 +23,7 @@ block0(v0: i8x16):
 ;   and a0,a4,a2
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -34,7 +34,7 @@ block0(v0: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x45, 0x80, 0x6e
 ;   .byte 0x57, 0x70, 0x81, 0xcd
@@ -54,18 +54,18 @@ block0(v0: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v8,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v8,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmslt.vx v10,v8,zero #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vmv.x.s a4,v10 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   andi a0,a4,255
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -76,7 +76,7 @@ block0(v0: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
 ;   .byte 0x57, 0x45, 0x80, 0x6e
@@ -95,18 +95,18 @@ block0(v0: i32x4):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v8,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v8,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmslt.vx v10,v8,zero #avl=4, #vtype=(e32, m1, ta, ma)
 ;   vmv.x.s a4,v10 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   andi a0,a4,15
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -117,7 +117,7 @@ block0(v0: i32x4):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x02, 0xcd
 ;   .byte 0x57, 0x45, 0x80, 0x6e
@@ -136,18 +136,18 @@ block0(v0: i64x2):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v8,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v8,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vmslt.vx v10,v8,zero #avl=2, #vtype=(e64, m1, ta, ma)
 ;   vmv.x.s a4,v10 #avl=2, #vtype=(e64, m1, ta, ma)
 ;   andi a0,a4,3
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -158,7 +158,7 @@ block0(v0: i64x2):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x07, 0x84, 0x0f, 0x02
 ;   .byte 0x57, 0x70, 0x81, 0xcd
 ;   .byte 0x57, 0x45, 0x80, 0x6e
diff --git a/cranelift/filetests/filetests/isa/riscv64/simd-vstate.clif b/cranelift/filetests/filetests/isa/riscv64/simd-vstate.clif
index c8a3c3594d7f..c6f5dc2c985b 100644
--- a/cranelift/filetests/filetests/isa/riscv64/simd-vstate.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/simd-vstate.clif
@@ -12,13 +12,13 @@ block0(v0: i8x16, v1: i16x8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vadd.vv v8,v9,v9 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vadd.vv v9,v11,v11 #avl=8, #vtype=(e16, m1, ta, ma)
 ;   vadd.vv v9,v9,v9 #avl=8, #vtype=(e16, m1, ta, ma)
@@ -26,7 +26,7 @@ block0(v0: i8x16, v1: i16x8):
 ;   vse8.v v9,16(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -37,9 +37,9 @@ block0(v0: i8x16, v1: i16x8):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x84, 0x94, 0x02
 ;   .byte 0x57, 0x70, 0x84, 0xcc
@@ -71,13 +71,13 @@ block2(v6: i8x16, v7: i8x16):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   vle8.v v9,16(fp) #avl=16, #vtype=(e8, m1, ta, ma)
-;   vle8.v v11,32(fp) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v9,-32(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
+;   vle8.v v11,-16(incoming_arg) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   vadd.vv v8,v9,v11 #avl=16, #vtype=(e8, m1, ta, ma)
 ;   j label1
 ; block1:
@@ -88,7 +88,7 @@ block2(v6: i8x16, v7: i8x16):
 ;   vse8.v v10,0(a0) #avl=16, #vtype=(e8, m1, ta, ma)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -99,9 +99,9 @@ block2(v6: i8x16, v7: i8x16):
 ;   mv s0, sp
 ; block1: ; offset 0x10
 ;   .byte 0x57, 0x70, 0x08, 0xcc
-;   addi t6, s0, 0x10
+;   addi t6, sp, 0x10
 ;   .byte 0x87, 0x84, 0x0f, 0x02
-;   addi t6, s0, 0x20
+;   addi t6, sp, 0x20
 ;   .byte 0x87, 0x85, 0x0f, 0x02
 ;   .byte 0x57, 0x84, 0x95, 0x02
 ; block2: ; offset 0x28
diff --git a/cranelift/filetests/filetests/isa/riscv64/smax-zbb.clif b/cranelift/filetests/filetests/isa/riscv64/smax-zbb.clif
new file mode 100644
index 000000000000..c14a89689e97
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/smax-zbb.clif
@@ -0,0 +1,140 @@
+test compile precise-output
+set unwind_info=false
+target riscv64 has_zbb
+
+function %smax_i8(i8, i8) -> i8{
+block0(v0: i8, v1: i8):
+    v2 = smax v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   sext.b a3,a0
+;   sext.b a5,a1
+;   max a0,a3,a5
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x93, 0x16, 0x45, 0x60
+;   .byte 0x93, 0x97, 0x45, 0x60
+;   .byte 0x33, 0xe5, 0xf6, 0x0a
+;   ret
+
+function %smax_i16(i16, i16) -> i16{
+block0(v0: i16, v1: i16):
+    v2 = smax v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   sext.h a3,a0
+;   sext.h a5,a1
+;   max a0,a3,a5
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x93, 0x16, 0x55, 0x60
+;   .byte 0x93, 0x97, 0x55, 0x60
+;   .byte 0x33, 0xe5, 0xf6, 0x0a
+;   ret
+
+function %smax_i32(i32, i32) -> i32{
+block0(v0: i32, v1: i32):
+    v2 = smax v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   sext.w a3,a0
+;   sext.w a5,a1
+;   max a0,a3,a5
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   sext.w a3, a0
+;   sext.w a5, a1
+;   .byte 0x33, 0xe5, 0xf6, 0x0a
+;   ret
+
+function %smax_i64(i64, i64) -> i64{
+block0(v0: i64, v1: i64):
+    v2 = smax v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   max a0,a0,a1
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x33, 0x65, 0xb5, 0x0a
+;   ret
+
+function %smax_i128(i128, i128) -> i128{
+block0(v0: i128, v1: i128):
+    v2 = smax v0, v1
+    return v2
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+;   addi sp,sp,-16
+;   sd s1,8(sp)
+;   sd s9,0(sp)
+; block0:
+;   slt a5,a3,a1
+;   sltu s1,a2,a0
+;   xor a4,a3,a1
+;   mv s9,a1
+;   select a5,s1,a5##condition=(a4 eq zero)
+;   mv a4,a0
+;   select [a0,a1],[a4,s9],[a2,a3]##condition=(a5 ne zero)
+;   ld s1,8(sp)
+;   ld s9,0(sp)
+;   addi sp,sp,16
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+;   addi sp, sp, -0x10
+;   sd s1, 8(sp)
+;   sd s9, 0(sp)
+; block1: ; offset 0x1c
+;   slt a5, a3, a1
+;   sltu s1, a2, a0
+;   xor a4, a3, a1
+;   mv s9, a1
+;   bnez a4, 8
+;   mv a5, s1
+;   mv a4, a0
+;   mv a0, a4
+;   mv a1, s9
+;   bnez a5, 0xc
+;   mv a0, a2
+;   mv a1, a3
+;   ld s1, 8(sp)
+;   ld s9, 0(sp)
+;   addi sp, sp, 0x10
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/smax.clif b/cranelift/filetests/filetests/isa/riscv64/smax.clif
index 271ab6bdd047..72fe68009665 100644
--- a/cranelift/filetests/filetests/isa/riscv64/smax.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/smax.clif
@@ -23,9 +23,8 @@ block0(v0: i8, v1: i8):
 ;   srai a5, a3, 0x38
 ;   slli a1, a1, 0x38
 ;   srai a3, a1, 0x38
-;   bge a3, a5, 0xc
 ;   mv a0, a5
-;   j 8
+;   blt a3, a5, 8
 ;   mv a0, a3
 ;   ret
 
@@ -50,9 +49,8 @@ block0(v0: i16, v1: i16):
 ;   srai a5, a3, 0x30
 ;   slli a1, a1, 0x30
 ;   srai a3, a1, 0x30
-;   bge a3, a5, 0xc
 ;   mv a0, a5
-;   j 8
+;   blt a3, a5, 8
 ;   mv a0, a3
 ;   ret
 
@@ -73,9 +71,8 @@ block0(v0: i32, v1: i32):
 ; block0: ; offset 0x0
 ;   sext.w a3, a0
 ;   sext.w a5, a1
-;   bge a5, a3, 0xc
 ;   mv a0, a3
-;   j 8
+;   blt a5, a3, 8
 ;   mv a0, a5
 ;   ret
 
@@ -87,12 +84,15 @@ block0(v0: i64, v1: i64):
 
 ; VCode:
 ; block0:
-;   select a0,a0,a1##condition=(a0 sgt a1)
+;   mv a4,a0
+;   select a0,a4,a1##condition=(a4 sgt a1)
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   blt a1, a0, 8
+;   mv a4, a0
+;   mv a0, a4
+;   blt a1, a4, 8
 ;   mv a0, a1
 ;   ret
 
@@ -103,22 +103,27 @@ block0(v0: i128, v1: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   sd s3,-8(sp)
-;   add sp,-16
+;   addi sp,sp,-16
+;   sd s1,8(sp)
+;   sd s9,0(sp)
 ; block0:
-;   sgt a5,[a0,a1],[a2,a3]##ty=i128
+;   slt a5,a3,a1
+;   sltu s1,a2,a0
+;   xor a4,a3,a1
+;   mv s9,a1
+;   select a5,s1,a5##condition=(a4 eq zero)
 ;   mv a4,a0
-;   mv s3,a1
-;   select [a0,a1],[a4,s3],[a2,a3]##condition=(a5 ne zero)
-;   add sp,+16
-;   ld s3,-8(sp)
+;   select [a0,a1],[a4,s9],[a2,a3]##condition=(a5 ne zero)
+;   ld s1,8(sp)
+;   ld s9,0(sp)
+;   addi sp,sp,16
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -127,25 +132,25 @@ block0(v0: i128, v1: i128):
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   sd s3, -8(sp)
 ;   addi sp, sp, -0x10
-; block1: ; offset 0x18
-;   blt a3, a1, 0xc
-;   bne a1, a3, 0x10
-;   bgeu a2, a0, 0xc
-;   addi a5, zero, 1
-;   j 8
-;   mv a5, zero
+;   sd s1, 8(sp)
+;   sd s9, 0(sp)
+; block1: ; offset 0x1c
+;   slt a5, a3, a1
+;   sltu s1, a2, a0
+;   xor a4, a3, a1
+;   mv s9, a1
+;   bnez a4, 8
+;   mv a5, s1
 ;   mv a4, a0
-;   mv s3, a1
-;   beqz a5, 0x10
 ;   mv a0, a4
-;   mv a1, s3
-;   j 0xc
+;   mv a1, s9
+;   bnez a5, 0xc
 ;   mv a0, a2
 ;   mv a1, a3
+;   ld s1, 8(sp)
+;   ld s9, 0(sp)
 ;   addi sp, sp, 0x10
-;   ld s3, -8(sp)
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
diff --git a/cranelift/filetests/filetests/isa/riscv64/smin-zbb.clif b/cranelift/filetests/filetests/isa/riscv64/smin-zbb.clif
new file mode 100644
index 000000000000..5af7c25ff86f
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/smin-zbb.clif
@@ -0,0 +1,140 @@
+test compile precise-output
+set unwind_info=false
+target riscv64 has_zbb
+
+function %smin_i8(i8, i8) -> i8{
+block0(v0: i8, v1: i8):
+    v2 = smin v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   sext.b a3,a0
+;   sext.b a5,a1
+;   min a0,a3,a5
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x93, 0x16, 0x45, 0x60
+;   .byte 0x93, 0x97, 0x45, 0x60
+;   .byte 0x33, 0xc5, 0xf6, 0x0a
+;   ret
+
+function %smin_i16(i16, i16) -> i16{
+block0(v0: i16, v1: i16):
+    v2 = smin v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   sext.h a3,a0
+;   sext.h a5,a1
+;   min a0,a3,a5
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x93, 0x16, 0x55, 0x60
+;   .byte 0x93, 0x97, 0x55, 0x60
+;   .byte 0x33, 0xc5, 0xf6, 0x0a
+;   ret
+
+function %smin_i32(i32, i32) -> i32{
+block0(v0: i32, v1: i32):
+    v2 = smin v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   sext.w a3,a0
+;   sext.w a5,a1
+;   min a0,a3,a5
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   sext.w a3, a0
+;   sext.w a5, a1
+;   .byte 0x33, 0xc5, 0xf6, 0x0a
+;   ret
+
+function %smin_i64(i64, i64) -> i64{
+block0(v0: i64, v1: i64):
+    v2 = smin v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   min a0,a0,a1
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x33, 0x45, 0xb5, 0x0a
+;   ret
+
+function %smin_i128(i128, i128) -> i128{
+block0(v0: i128, v1: i128):
+    v2 = smin v0, v1
+    return v2
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+;   addi sp,sp,-16
+;   sd s1,8(sp)
+;   sd s9,0(sp)
+; block0:
+;   slt a5,a1,a3
+;   sltu s1,a0,a2
+;   xor a4,a1,a3
+;   mv s9,a1
+;   select a5,s1,a5##condition=(a4 eq zero)
+;   mv a4,a0
+;   select [a0,a1],[a4,s9],[a2,a3]##condition=(a5 ne zero)
+;   ld s1,8(sp)
+;   ld s9,0(sp)
+;   addi sp,sp,16
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+;   addi sp, sp, -0x10
+;   sd s1, 8(sp)
+;   sd s9, 0(sp)
+; block1: ; offset 0x1c
+;   slt a5, a1, a3
+;   sltu s1, a0, a2
+;   xor a4, a1, a3
+;   mv s9, a1
+;   bnez a4, 8
+;   mv a5, s1
+;   mv a4, a0
+;   mv a0, a4
+;   mv a1, s9
+;   bnez a5, 0xc
+;   mv a0, a2
+;   mv a1, a3
+;   ld s1, 8(sp)
+;   ld s9, 0(sp)
+;   addi sp, sp, 0x10
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/smin.clif b/cranelift/filetests/filetests/isa/riscv64/smin.clif
index 92ed89a5bdce..8528fdc3a090 100644
--- a/cranelift/filetests/filetests/isa/riscv64/smin.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/smin.clif
@@ -23,9 +23,8 @@ block0(v0: i8, v1: i8):
 ;   srai a5, a3, 0x38
 ;   slli a1, a1, 0x38
 ;   srai a3, a1, 0x38
-;   bge a5, a3, 0xc
 ;   mv a0, a5
-;   j 8
+;   blt a5, a3, 8
 ;   mv a0, a3
 ;   ret
 
@@ -50,9 +49,8 @@ block0(v0: i16, v1: i16):
 ;   srai a5, a3, 0x30
 ;   slli a1, a1, 0x30
 ;   srai a3, a1, 0x30
-;   bge a5, a3, 0xc
 ;   mv a0, a5
-;   j 8
+;   blt a5, a3, 8
 ;   mv a0, a3
 ;   ret
 
@@ -73,9 +71,8 @@ block0(v0: i32, v1: i32):
 ; block0: ; offset 0x0
 ;   sext.w a3, a0
 ;   sext.w a5, a1
-;   bge a3, a5, 0xc
 ;   mv a0, a3
-;   j 8
+;   blt a3, a5, 8
 ;   mv a0, a5
 ;   ret
 
@@ -87,12 +84,15 @@ block0(v0: i64, v1: i64):
 
 ; VCode:
 ; block0:
-;   select a0,a0,a1##condition=(a0 slt a1)
+;   mv a4,a0
+;   select a0,a4,a1##condition=(a4 slt a1)
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   blt a0, a1, 8
+;   mv a4, a0
+;   mv a0, a4
+;   blt a4, a1, 8
 ;   mv a0, a1
 ;   ret
 
@@ -103,22 +103,27 @@ block0(v0: i128, v1: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   sd s3,-8(sp)
-;   add sp,-16
+;   addi sp,sp,-16
+;   sd s1,8(sp)
+;   sd s9,0(sp)
 ; block0:
-;   slt a5,[a0,a1],[a2,a3]##ty=i128
+;   slt a5,a1,a3
+;   sltu s1,a0,a2
+;   xor a4,a1,a3
+;   mv s9,a1
+;   select a5,s1,a5##condition=(a4 eq zero)
 ;   mv a4,a0
-;   mv s3,a1
-;   select [a0,a1],[a4,s3],[a2,a3]##condition=(a5 ne zero)
-;   add sp,+16
-;   ld s3,-8(sp)
+;   select [a0,a1],[a4,s9],[a2,a3]##condition=(a5 ne zero)
+;   ld s1,8(sp)
+;   ld s9,0(sp)
+;   addi sp,sp,16
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -127,25 +132,25 @@ block0(v0: i128, v1: i128):
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   sd s3, -8(sp)
 ;   addi sp, sp, -0x10
-; block1: ; offset 0x18
-;   blt a1, a3, 0xc
-;   bne a1, a3, 0x10
-;   bgeu a0, a2, 0xc
-;   addi a5, zero, 1
-;   j 8
-;   mv a5, zero
+;   sd s1, 8(sp)
+;   sd s9, 0(sp)
+; block1: ; offset 0x1c
+;   slt a5, a1, a3
+;   sltu s1, a0, a2
+;   xor a4, a1, a3
+;   mv s9, a1
+;   bnez a4, 8
+;   mv a5, s1
 ;   mv a4, a0
-;   mv s3, a1
-;   beqz a5, 0x10
 ;   mv a0, a4
-;   mv a1, s3
-;   j 0xc
+;   mv a1, s9
+;   bnez a5, 0xc
 ;   mv a0, a2
 ;   mv a1, a3
+;   ld s1, 8(sp)
+;   ld s9, 0(sp)
 ;   addi sp, sp, 0x10
-;   ld s3, -8(sp)
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
diff --git a/cranelift/filetests/filetests/isa/riscv64/sshr-const.clif b/cranelift/filetests/filetests/isa/riscv64/sshr-const.clif
index a524ce84bb6d..dbb3ed234850 100644
--- a/cranelift/filetests/filetests/isa/riscv64/sshr-const.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/sshr-const.clif
@@ -420,25 +420,22 @@ block0(v0: i128):
 ;   addi a3, zero, 0x40
 ;   sub a3, a3, a4
 ;   sll a5, a1, a3
-;   bnez a4, 0xc
 ;   mv a3, zero
-;   j 8
+;   beqz a4, 8
 ;   mv a3, a5
 ;   srl a5, a0, a4
 ;   or a5, a3, a5
 ;   addi a0, zero, 0x40
 ;   sra a3, a1, a4
 ;   addi a4, zero, -1
-;   bgez a1, 0xc
 ;   mv t4, a4
-;   j 8
+;   bltz a1, 8
 ;   mv t4, zero
 ;   addi a4, zero, 0x40
 ;   andi a2, a2, 0x7f
-;   bltu a2, a4, 0x10
 ;   mv a0, a3
 ;   mv a1, t4
-;   j 0xc
+;   bgeu a2, a4, 0xc
 ;   mv a0, a5
 ;   mv a1, a3
 ;   ret
@@ -476,25 +473,22 @@ block0(v0: i128):
 ;   addi a3, zero, 0x40
 ;   sub a3, a3, a4
 ;   sll a5, a1, a3
-;   bnez a4, 0xc
 ;   mv a3, zero
-;   j 8
+;   beqz a4, 8
 ;   mv a3, a5
 ;   srl a5, a0, a4
 ;   or a5, a3, a5
 ;   addi a0, zero, 0x40
 ;   sra a3, a1, a4
 ;   addi a4, zero, -1
-;   bgez a1, 0xc
 ;   mv t4, a4
-;   j 8
+;   bltz a1, 8
 ;   mv t4, zero
 ;   addi a4, zero, 0x40
 ;   andi a2, a2, 0x7f
-;   bltu a2, a4, 0x10
 ;   mv a0, a3
 ;   mv a1, t4
-;   j 0xc
+;   bgeu a2, a4, 0xc
 ;   mv a0, a5
 ;   mv a1, a3
 ;   ret
@@ -532,25 +526,22 @@ block0(v0: i128):
 ;   addi a3, zero, 0x40
 ;   sub a3, a3, a4
 ;   sll a5, a1, a3
-;   bnez a4, 0xc
 ;   mv a3, zero
-;   j 8
+;   beqz a4, 8
 ;   mv a3, a5
 ;   srl a5, a0, a4
 ;   or a5, a3, a5
 ;   addi a0, zero, 0x40
 ;   sra a3, a1, a4
 ;   addi a4, zero, -1
-;   bgez a1, 0xc
 ;   mv t4, a4
-;   j 8
+;   bltz a1, 8
 ;   mv t4, zero
 ;   addi a4, zero, 0x40
 ;   andi a2, a2, 0x7f
-;   bltu a2, a4, 0x10
 ;   mv a0, a3
 ;   mv a1, t4
-;   j 0xc
+;   bgeu a2, a4, 0xc
 ;   mv a0, a5
 ;   mv a1, a3
 ;   ret
@@ -588,25 +579,22 @@ block0(v0: i128):
 ;   addi a3, zero, 0x40
 ;   sub a3, a3, a4
 ;   sll a5, a1, a3
-;   bnez a4, 0xc
 ;   mv a3, zero
-;   j 8
+;   beqz a4, 8
 ;   mv a3, a5
 ;   srl a5, a0, a4
 ;   or a5, a3, a5
 ;   addi a0, zero, 0x40
 ;   sra a3, a1, a4
 ;   addi a4, zero, -1
-;   bgez a1, 0xc
 ;   mv t4, a4
-;   j 8
+;   bltz a1, 8
 ;   mv t4, zero
 ;   addi a4, zero, 0x40
 ;   andi a2, a2, 0x7f
-;   bltu a2, a4, 0x10
 ;   mv a0, a3
 ;   mv a1, t4
-;   j 0xc
+;   bgeu a2, a4, 0xc
 ;   mv a0, a5
 ;   mv a1, a3
 ;   ret
@@ -620,12 +608,12 @@ block0(v0: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   sd s11,-8(sp)
-;   add sp,-16
+;   addi sp,sp,-16
+;   sd s11,8(sp)
 ; block0:
 ;   li a2,5
 ;   li a3,0
@@ -643,11 +631,11 @@ block0(v0: i128):
 ;   li a4,64
 ;   andi a2,a2,127
 ;   select [a0,a1],[a3,a5],[s11,a3]##condition=(a2 uge a4)
-;   add sp,+16
-;   ld s11,-8(sp)
+;   ld s11,8(sp)
+;   addi sp,sp,16
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -656,8 +644,8 @@ block0(v0: i128):
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   sd s11, -8(sp)
 ;   addi sp, sp, -0x10
+;   sd s11, 8(sp)
 ; block1: ; offset 0x18
 ;   addi a2, zero, 5
 ;   mv a3, zero
@@ -676,14 +664,13 @@ block0(v0: i128):
 ;   mv a5, zero
 ;   addi a4, zero, 0x40
 ;   andi a2, a2, 0x7f
-;   bltu a2, a4, 0x10
 ;   mv a0, a3
 ;   mv a1, a5
-;   j 0xc
+;   bgeu a2, a4, 0xc
 ;   mv a0, s11
 ;   mv a1, a3
+;   ld s11, 8(sp)
 ;   addi sp, sp, 0x10
-;   ld s11, -8(sp)
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
diff --git a/cranelift/filetests/filetests/isa/riscv64/sshr.clif b/cranelift/filetests/filetests/isa/riscv64/sshr.clif
index 66f684b0620a..2901c74d805d 100644
--- a/cranelift/filetests/filetests/isa/riscv64/sshr.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/sshr.clif
@@ -413,25 +413,22 @@ block0(v0: i128, v1: i8):
 ;   addi a3, zero, 0x40
 ;   sub a3, a3, a4
 ;   sll a5, a1, a3
-;   bnez a4, 0xc
 ;   mv a3, zero
-;   j 8
+;   beqz a4, 8
 ;   mv a3, a5
 ;   srl a5, a0, a4
 ;   or a5, a3, a5
 ;   addi a0, zero, 0x40
 ;   sra a3, a1, a4
 ;   addi a4, zero, -1
-;   bgez a1, 0xc
 ;   mv t4, a4
-;   j 8
+;   bltz a1, 8
 ;   mv t4, zero
 ;   addi a4, zero, 0x40
 ;   andi a2, a2, 0x7f
-;   bltu a2, a4, 0x10
 ;   mv a0, a3
 ;   mv a1, t4
-;   j 0xc
+;   bgeu a2, a4, 0xc
 ;   mv a0, a5
 ;   mv a1, a3
 ;   ret
@@ -466,25 +463,22 @@ block0(v0: i128, v1: i16):
 ;   addi a3, zero, 0x40
 ;   sub a3, a3, a4
 ;   sll a5, a1, a3
-;   bnez a4, 0xc
 ;   mv a3, zero
-;   j 8
+;   beqz a4, 8
 ;   mv a3, a5
 ;   srl a5, a0, a4
 ;   or a5, a3, a5
 ;   addi a0, zero, 0x40
 ;   sra a3, a1, a4
 ;   addi a4, zero, -1
-;   bgez a1, 0xc
 ;   mv t4, a4
-;   j 8
+;   bltz a1, 8
 ;   mv t4, zero
 ;   addi a4, zero, 0x40
 ;   andi a2, a2, 0x7f
-;   bltu a2, a4, 0x10
 ;   mv a0, a3
 ;   mv a1, t4
-;   j 0xc
+;   bgeu a2, a4, 0xc
 ;   mv a0, a5
 ;   mv a1, a3
 ;   ret
@@ -519,25 +513,22 @@ block0(v0: i128, v1: i32):
 ;   addi a3, zero, 0x40
 ;   sub a3, a3, a4
 ;   sll a5, a1, a3
-;   bnez a4, 0xc
 ;   mv a3, zero
-;   j 8
+;   beqz a4, 8
 ;   mv a3, a5
 ;   srl a5, a0, a4
 ;   or a5, a3, a5
 ;   addi a0, zero, 0x40
 ;   sra a3, a1, a4
 ;   addi a4, zero, -1
-;   bgez a1, 0xc
 ;   mv t4, a4
-;   j 8
+;   bltz a1, 8
 ;   mv t4, zero
 ;   addi a4, zero, 0x40
 ;   andi a2, a2, 0x7f
-;   bltu a2, a4, 0x10
 ;   mv a0, a3
 ;   mv a1, t4
-;   j 0xc
+;   bgeu a2, a4, 0xc
 ;   mv a0, a5
 ;   mv a1, a3
 ;   ret
@@ -572,25 +563,22 @@ block0(v0: i128, v1: i64):
 ;   addi a3, zero, 0x40
 ;   sub a3, a3, a4
 ;   sll a5, a1, a3
-;   bnez a4, 0xc
 ;   mv a3, zero
-;   j 8
+;   beqz a4, 8
 ;   mv a3, a5
 ;   srl a5, a0, a4
 ;   or a5, a3, a5
 ;   addi a0, zero, 0x40
 ;   sra a3, a1, a4
 ;   addi a4, zero, -1
-;   bgez a1, 0xc
 ;   mv t4, a4
-;   j 8
+;   bltz a1, 8
 ;   mv t4, zero
 ;   addi a4, zero, 0x40
 ;   andi a2, a2, 0x7f
-;   bltu a2, a4, 0x10
 ;   mv a0, a3
 ;   mv a1, t4
-;   j 0xc
+;   bgeu a2, a4, 0xc
 ;   mv a0, a5
 ;   mv a1, a3
 ;   ret
@@ -602,12 +590,12 @@ block0(v0: i128, v1: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   sd s11,-8(sp)
-;   add sp,-16
+;   addi sp,sp,-16
+;   sd s11,8(sp)
 ; block0:
 ;   andi a5,a2,63
 ;   li a3,64
@@ -623,11 +611,11 @@ block0(v0: i128, v1: i128):
 ;   li a4,64
 ;   andi a2,a2,127
 ;   select [a0,a1],[a3,a5],[s11,a3]##condition=(a2 uge a4)
-;   add sp,+16
-;   ld s11,-8(sp)
+;   ld s11,8(sp)
+;   addi sp,sp,16
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -636,8 +624,8 @@ block0(v0: i128, v1: i128):
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   sd s11, -8(sp)
 ;   addi sp, sp, -0x10
+;   sd s11, 8(sp)
 ; block1: ; offset 0x18
 ;   andi a5, a2, 0x3f
 ;   addi a3, zero, 0x40
@@ -654,14 +642,13 @@ block0(v0: i128, v1: i128):
 ;   mv a5, zero
 ;   addi a4, zero, 0x40
 ;   andi a2, a2, 0x7f
-;   bltu a2, a4, 0x10
 ;   mv a0, a3
 ;   mv a1, a5
-;   j 0xc
+;   bgeu a2, a4, 0xc
 ;   mv a0, s11
 ;   mv a1, a3
+;   ld s11, 8(sp)
 ;   addi sp, sp, 0x10
-;   ld s11, -8(sp)
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
diff --git a/cranelift/filetests/filetests/isa/riscv64/stack-limit.clif b/cranelift/filetests/filetests/isa/riscv64/stack-limit.clif
index d33f83bdd740..fe934fc7cfea 100644
--- a/cranelift/filetests/filetests/isa/riscv64/stack-limit.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/stack-limit.clif
@@ -16,19 +16,6 @@ block0:
 ; block0: ; offset 0x0
 ;   ret
 
-function %stack_limit_leaf_zero(i64 stack_limit) {
-block0(v0: i64):
-    return
-}
-
-; VCode:
-; block0:
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   ret
-
 function %stack_limit_gv_leaf_zero(i64 vmctx) {
     gv0 = vmctx
     gv1 = load.i64 notrap aligned gv0
@@ -46,47 +33,6 @@ block0(v0: i64):
 ; block0: ; offset 0x0
 ;   ret
 
-function %stack_limit_call_zero(i64 stack_limit) {
-    fn0 = %foo()
-block0(v0: i64):
-    call fn0()
-    return
-}
-
-; VCode:
-;   add sp,-16
-;   sd ra,8(sp)
-;   sd fp,0(sp)
-;   mv fp,sp
-;   trap_if stk_ovf##(sp ult a0)
-; block0:
-;   load_sym a2,%foo+0
-;   callind a2
-;   ld ra,8(sp)
-;   ld fp,0(sp)
-;   add sp,+16
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   addi sp, sp, -0x10
-;   sd ra, 8(sp)
-;   sd s0, 0(sp)
-;   mv s0, sp
-;   bgeu sp, a0, 8
-;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: stk_ovf
-; block1: ; offset 0x18
-;   auipc a2, 0
-;   ld a2, 0xc(a2)
-;   j 0xc
-;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %foo 0
-;   .byte 0x00, 0x00, 0x00, 0x00
-;   jalr a2
-;   ld ra, 8(sp)
-;   ld s0, 0(sp)
-;   addi sp, sp, 0x10
-;   ret
-
 function %stack_limit_gv_call_zero(i64 vmctx) {
     gv0 = vmctx
     gv1 = load.i64 notrap aligned gv0
@@ -99,19 +45,20 @@ block0(v0: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ;   ld t6,0(a0)
 ;   ld t6,4(t6)
+;   addi t6,t6,16
 ;   trap_if stk_ovf##(sp ult t6)
 ; block0:
-;   load_sym a2,%foo+0
-;   callind a2
+;   load_sym a0,%foo+0
+;   callind a0
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -122,113 +69,16 @@ block0(v0: i64):
 ;   mv s0, sp
 ;   ld t6, 0(a0)
 ;   ld t6, 4(t6)
+;   addi t6, t6, 0x10
 ;   bgeu sp, t6, 8
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: stk_ovf
-; block1: ; offset 0x20
-;   auipc a2, 0
-;   ld a2, 0xc(a2)
+; block1: ; offset 0x24
+;   auipc a0, 0
+;   ld a0, 0xc(a0)
 ;   j 0xc
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %foo 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   jalr a2
-;   ld ra, 8(sp)
-;   ld s0, 0(sp)
-;   addi sp, sp, 0x10
-;   ret
-
-function %stack_limit(i64 stack_limit) {
-    ss0 = explicit_slot 168
-block0(v0: i64):
-    return
-}
-
-; VCode:
-;   add sp,-16
-;   sd ra,8(sp)
-;   sd fp,0(sp)
-;   mv fp,sp
-;   addi t6,a0,176
-;   trap_if stk_ovf##(sp ult t6)
-;   add sp,-176
-; block0:
-;   add sp,+176
-;   ld ra,8(sp)
-;   ld fp,0(sp)
-;   add sp,+16
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   addi sp, sp, -0x10
-;   sd ra, 8(sp)
-;   sd s0, 0(sp)
-;   mv s0, sp
-;   addi t6, a0, 0xb0
-;   bgeu sp, t6, 8
-;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: stk_ovf
-;   addi sp, sp, -0xb0
-; block1: ; offset 0x20
-;   addi sp, sp, 0xb0
-;   ld ra, 8(sp)
-;   ld s0, 0(sp)
-;   addi sp, sp, 0x10
-;   ret
-
-function %huge_stack_limit(i64 stack_limit) {
-    ss0 = explicit_slot 400000
-block0(v0: i64):
-    return
-}
-
-; VCode:
-;   add sp,-16
-;   sd ra,8(sp)
-;   sd fp,0(sp)
-;   mv fp,sp
-;   trap_if stk_ovf##(sp ult a0)
-;   lui t5,98
-;   addi t5,t5,-1408
-;   add t6,t5,a0
-;   trap_if stk_ovf##(sp ult t6)
-;   lui a0,98
-;   addi a0,a0,-1408
-;   call %Probestack
-;   add sp,-400000
-; block0:
-;   add sp,+400000
-;   ld ra,8(sp)
-;   ld fp,0(sp)
-;   add sp,+16
-;   ret
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   addi sp, sp, -0x10
-;   sd ra, 8(sp)
-;   sd s0, 0(sp)
-;   mv s0, sp
-;   bgeu sp, a0, 8
-;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: stk_ovf
-;   lui t5, 0x62
-;   addi t5, t5, -0x580
-;   add t6, t5, a0
-;   bgeu sp, t6, 8
-;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: stk_ovf
-;   lui a0, 0x62
-;   addi a0, a0, -0x580
-;   auipc t5, 0
-;   ld t5, 0xc(t5)
-;   j 0xc
-;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %Probestack 0
-;   .byte 0x00, 0x00, 0x00, 0x00
-;   jalr t5
-;   lui t6, 0xfff9e
-;   addi t6, t6, 0x580
-;   add sp, t6, sp
-; block1: ; offset 0x58
-;   lui t6, 0x62
-;   addi t6, t6, -0x580
-;   add sp, t6, sp
+;   jalr a0
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -245,7 +95,7 @@ block0(v0: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
@@ -253,12 +103,12 @@ block0(v0: i64):
 ;   ld t6,4(t6)
 ;   addi t6,t6,32
 ;   trap_if stk_ovf##(sp ult t6)
-;   add sp,-32
+;   addi sp,sp,-32
 ; block0:
-;   add sp,+32
+;   addi sp,sp,32
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -291,7 +141,7 @@ block0(v0: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
@@ -305,12 +155,16 @@ block0(v0: i64):
 ;   lui a0,98
 ;   addi a0,a0,-1408
 ;   call %Probestack
-;   add sp,-400000
+;   lui t6,-98
+;   addi t6,t6,1408
+;   add sp,sp,t6
 ; block0:
-;   add sp,+400000
+;   lui t6,98
+;   addi t6,t6,-1408
+;   add sp,sp,t6
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -330,19 +184,15 @@ block0(v0: i64):
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; trap: stk_ovf
 ;   lui a0, 0x62
 ;   addi a0, a0, -0x580
-;   auipc t5, 0
-;   ld t5, 0xc(t5)
-;   j 0xc
-;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %Probestack 0
-;   .byte 0x00, 0x00, 0x00, 0x00
-;   jalr t5
+;   auipc ra, 0 ; reloc_external RiscvCallPlt %Probestack 0
+;   jalr ra
 ;   lui t6, 0xfff9e
 ;   addi t6, t6, 0x580
-;   add sp, t6, sp
-; block1: ; offset 0x60
+;   add sp, sp, t6
+; block1: ; offset 0x50
 ;   lui t6, 0x62
 ;   addi t6, t6, -0x580
-;   add sp, t6, sp
+;   add sp, sp, t6
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -358,19 +208,19 @@ block0(v0: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ;   ld t6,400000(a0)
 ;   addi t6,t6,32
 ;   trap_if stk_ovf##(sp ult t6)
-;   add sp,-32
+;   addi sp,sp,-32
 ; block0:
-;   add sp,+32
+;   addi sp,sp,32
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
diff --git a/cranelift/filetests/filetests/isa/riscv64/stack.clif b/cranelift/filetests/filetests/isa/riscv64/stack.clif
index 08a73c80436c..88df5938e976 100644
--- a/cranelift/filetests/filetests/isa/riscv64/stack.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/stack.clif
@@ -12,17 +12,17 @@ block0:
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   add sp,-16
+;   addi sp,sp,-16
 ; block0:
-;   load_addr a0,0(nominal_sp)
-;   add sp,+16
+;   load_addr a0,0(slot)
+;   addi sp,sp,16
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -50,20 +50,24 @@ block0:
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ;   lui a0,24
 ;   addi a0,a0,1712
 ;   call %Probestack
-;   add sp,-100016
+;   lui t6,-24
+;   addi t6,t6,-1712
+;   add sp,sp,t6
 ; block0:
-;   load_addr a0,0(nominal_sp)
-;   add sp,+100016
+;   load_addr a0,0(slot)
+;   lui t6,24
+;   addi t6,t6,1712
+;   add sp,sp,t6
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -74,20 +78,16 @@ block0:
 ;   mv s0, sp
 ;   lui a0, 0x18
 ;   addi a0, a0, 0x6b0
-;   auipc t5, 0
-;   ld t5, 0xc(t5)
-;   j 0xc
-;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %Probestack 0
-;   .byte 0x00, 0x00, 0x00, 0x00
-;   jalr t5
+;   auipc ra, 0 ; reloc_external RiscvCallPlt %Probestack 0
+;   jalr ra
 ;   lui t6, 0xfffe8
 ;   addi t6, t6, -0x6b0
-;   add sp, t6, sp
-; block1: ; offset 0x3c
+;   add sp, sp, t6
+; block1: ; offset 0x2c
 ;   mv a0, sp
 ;   lui t6, 0x18
 ;   addi t6, t6, 0x6b0
-;   add sp, t6, sp
+;   add sp, sp, t6
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -102,17 +102,17 @@ block0:
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   add sp,-16
+;   addi sp,sp,-16
 ; block0:
-;   ld a0,0(nominal_sp)
-;   add sp,+16
+;   ld a0,0(slot)
+;   addi sp,sp,16
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -140,20 +140,24 @@ block0:
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ;   lui a0,24
 ;   addi a0,a0,1712
 ;   call %Probestack
-;   add sp,-100016
+;   lui t6,-24
+;   addi t6,t6,-1712
+;   add sp,sp,t6
 ; block0:
-;   ld a0,0(nominal_sp)
-;   add sp,+100016
+;   ld a0,0(slot)
+;   lui t6,24
+;   addi t6,t6,1712
+;   add sp,sp,t6
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -164,20 +168,16 @@ block0:
 ;   mv s0, sp
 ;   lui a0, 0x18
 ;   addi a0, a0, 0x6b0
-;   auipc t5, 0
-;   ld t5, 0xc(t5)
-;   j 0xc
-;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %Probestack 0
-;   .byte 0x00, 0x00, 0x00, 0x00
-;   jalr t5
+;   auipc ra, 0 ; reloc_external RiscvCallPlt %Probestack 0
+;   jalr ra
 ;   lui t6, 0xfffe8
 ;   addi t6, t6, -0x6b0
-;   add sp, t6, sp
-; block1: ; offset 0x3c
+;   add sp, sp, t6
+; block1: ; offset 0x2c
 ;   ld a0, 0(sp)
 ;   lui t6, 0x18
 ;   addi t6, t6, 0x6b0
-;   add sp, t6, sp
+;   add sp, sp, t6
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -192,17 +192,17 @@ block0(v0: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   add sp,-16
+;   addi sp,sp,-16
 ; block0:
-;   sd a0,0(nominal_sp)
-;   add sp,+16
+;   sd a0,0(slot)
+;   addi sp,sp,16
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -230,20 +230,24 @@ block0(v0: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ;   lui a0,24
 ;   addi a0,a0,1712
 ;   call %Probestack
-;   add sp,-100016
+;   lui t6,-24
+;   addi t6,t6,-1712
+;   add sp,sp,t6
 ; block0:
-;   sd a0,0(nominal_sp)
-;   add sp,+100016
+;   sd a0,0(slot)
+;   lui t6,24
+;   addi t6,t6,1712
+;   add sp,sp,t6
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -254,20 +258,16 @@ block0(v0: i64):
 ;   mv s0, sp
 ;   lui a0, 0x18
 ;   addi a0, a0, 0x6b0
-;   auipc t5, 0
-;   ld t5, 0xc(t5)
-;   j 0xc
-;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %Probestack 0
-;   .byte 0x00, 0x00, 0x00, 0x00
-;   jalr t5
+;   auipc ra, 0 ; reloc_external RiscvCallPlt %Probestack 0
+;   jalr ra
 ;   lui t6, 0xfffe8
 ;   addi t6, t6, -0x6b0
-;   add sp, t6, sp
-; block1: ; offset 0x3c
+;   add sp, sp, t6
+; block1: ; offset 0x2c
 ;   sd a0, 0(sp)
 ;   lui t6, 0x18
 ;   addi t6, t6, 0x6b0
-;   add sp, t6, sp
+;   add sp, sp, t6
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -425,26 +425,26 @@ block0(v0: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   sd s1,-8(sp)
-;   sd s2,-16(sp)
-;   sd s3,-24(sp)
-;   sd s4,-32(sp)
-;   sd s5,-40(sp)
-;   sd s6,-48(sp)
-;   sd s7,-56(sp)
-;   sd s8,-64(sp)
-;   sd s9,-72(sp)
-;   sd s10,-80(sp)
-;   sd s11,-88(sp)
-;   add sp,-1360
+;   addi sp,sp,-1360
+;   sd s1,1352(sp)
+;   sd s2,1344(sp)
+;   sd s3,1336(sp)
+;   sd s4,1328(sp)
+;   sd s5,1320(sp)
+;   sd s6,1312(sp)
+;   sd s7,1304(sp)
+;   sd s8,1296(sp)
+;   sd s9,1288(sp)
+;   sd s10,1280(sp)
+;   sd s11,1272(sp)
 ; block0:
-;   sd a0,1000(nominal_sp)
+;   sd a0,1000(slot)
 ;   li a2,2
-;   sd a2,1008(nominal_sp)
+;   sd a2,1008(slot)
 ;   li a2,4
 ;   li a3,6
 ;   li a4,8
@@ -469,125 +469,125 @@ block0(v0: i8):
 ;   li s6,36
 ;   li a0,38
 ;   li a1,30
-;   sd a1,1256(nominal_sp)
+;   sd a1,1256(slot)
 ;   li a1,32
-;   sd a1,1248(nominal_sp)
+;   sd a1,1248(slot)
 ;   li a1,34
-;   sd a1,1240(nominal_sp)
+;   sd a1,1240(slot)
 ;   li a1,36
-;   sd a1,1232(nominal_sp)
+;   sd a1,1232(slot)
 ;   li a1,38
-;   sd a1,1224(nominal_sp)
+;   sd a1,1224(slot)
 ;   li a1,30
-;   sd a1,1216(nominal_sp)
+;   sd a1,1216(slot)
 ;   li a1,32
-;   sd a1,1208(nominal_sp)
+;   sd a1,1208(slot)
 ;   li a1,34
-;   sd a1,1200(nominal_sp)
+;   sd a1,1200(slot)
 ;   li a1,36
-;   sd a1,1192(nominal_sp)
+;   sd a1,1192(slot)
 ;   li a1,38
-;   sd a1,1184(nominal_sp)
-;   ld a1,1008(nominal_sp)
+;   sd a1,1184(slot)
+;   ld a1,1008(slot)
 ;   addi a1,a1,1
-;   sd a1,1176(nominal_sp)
+;   sd a1,1176(slot)
 ;   addi a1,a2,3
-;   sd a1,1168(nominal_sp)
+;   sd a1,1168(slot)
 ;   addi a1,a3,5
-;   sd a1,1160(nominal_sp)
+;   sd a1,1160(slot)
 ;   addi a1,a4,7
-;   sd a1,1152(nominal_sp)
+;   sd a1,1152(slot)
 ;   addi a1,a5,9
-;   sd a1,1144(nominal_sp)
+;   sd a1,1144(slot)
 ;   addi a1,s7,11
-;   sd a1,1136(nominal_sp)
+;   sd a1,1136(slot)
 ;   addi a1,s8,13
-;   sd a1,1128(nominal_sp)
+;   sd a1,1128(slot)
 ;   addi a1,s9,15
-;   sd a1,1120(nominal_sp)
+;   sd a1,1120(slot)
 ;   addi a1,s10,17
-;   sd a1,1112(nominal_sp)
+;   sd a1,1112(slot)
 ;   addi a1,s11,19
-;   sd a1,1104(nominal_sp)
+;   sd a1,1104(slot)
 ;   addi a1,t0,21
-;   sd a1,1096(nominal_sp)
+;   sd a1,1096(slot)
 ;   addi a1,t1,23
-;   sd a1,1088(nominal_sp)
+;   sd a1,1088(slot)
 ;   addi a1,t2,25
-;   sd a1,1080(nominal_sp)
+;   sd a1,1080(slot)
 ;   addi a1,a6,27
-;   sd a1,1072(nominal_sp)
+;   sd a1,1072(slot)
 ;   addi a1,a7,29
-;   sd a1,1064(nominal_sp)
+;   sd a1,1064(slot)
 ;   addi a1,t3,31
-;   sd a1,1056(nominal_sp)
+;   sd a1,1056(slot)
 ;   addi a1,t4,33
-;   sd a1,1048(nominal_sp)
+;   sd a1,1048(slot)
 ;   addi a1,s1,35
-;   sd a1,1040(nominal_sp)
+;   sd a1,1040(slot)
 ;   addi a1,s2,37
-;   sd a1,1032(nominal_sp)
+;   sd a1,1032(slot)
 ;   addi a1,s3,39
-;   sd a1,1024(nominal_sp)
+;   sd a1,1024(slot)
 ;   addi a1,s4,31
-;   sd a1,1016(nominal_sp)
+;   sd a1,1016(slot)
 ;   addi a1,s5,33
-;   sd a1,1008(nominal_sp)
+;   sd a1,1008(slot)
 ;   addi s6,s6,35
 ;   addi a0,a0,37
-;   ld a1,1256(nominal_sp)
+;   ld a1,1256(slot)
 ;   addi a1,a1,39
-;   ld a5,1248(nominal_sp)
-;   addi a2,a5,31
-;   ld a3,1240(nominal_sp)
+;   ld a2,1248(slot)
+;   addi a2,a2,31
+;   ld a3,1240(slot)
 ;   addi a3,a3,33
-;   ld a5,1232(nominal_sp)
-;   addi a4,a5,35
-;   ld a5,1224(nominal_sp)
+;   ld a4,1232(slot)
+;   addi a4,a4,35
+;   ld a5,1224(slot)
 ;   addi a5,a5,37
-;   ld s11,1216(nominal_sp)
-;   addi s7,s11,39
-;   ld t2,1208(nominal_sp)
-;   addi s8,t2,31
-;   ld t3,1200(nominal_sp)
-;   addi s9,t3,33
-;   ld s2,1192(nominal_sp)
-;   addi s10,s2,35
-;   ld s5,1184(nominal_sp)
-;   addi s11,s5,37
-;   ld t0,1176(nominal_sp)
+;   ld t0,1216(slot)
+;   addi s7,t0,39
+;   ld a6,1208(slot)
+;   addi s8,a6,31
+;   ld t4,1200(slot)
+;   addi s9,t4,33
+;   ld s3,1192(slot)
+;   addi s10,s3,35
+;   ld s11,1184(slot)
+;   addi s11,s11,37
+;   ld t0,1176(slot)
 ;   addi t0,t0,39
-;   ld t1,1160(nominal_sp)
-;   ld t2,1168(nominal_sp)
-;   add t1,t2,t1
-;   ld t4,1144(nominal_sp)
-;   ld a7,1152(nominal_sp)
-;   add t2,a7,t4
-;   ld s5,1128(nominal_sp)
-;   ld s3,1136(nominal_sp)
-;   add a6,s3,s5
-;   ld a7,1112(nominal_sp)
-;   ld t3,1120(nominal_sp)
+;   ld t1,1168(slot)
+;   ld t2,1160(slot)
+;   add t1,t1,t2
+;   ld s1,1144(slot)
+;   ld t3,1152(slot)
+;   add t2,t3,s1
+;   ld a6,1128(slot)
+;   ld s4,1136(slot)
+;   add a6,s4,a6
+;   ld a7,1112(slot)
+;   ld t3,1120(slot)
 ;   add a7,t3,a7
-;   ld t3,1096(nominal_sp)
-;   ld t4,1104(nominal_sp)
+;   ld t3,1096(slot)
+;   ld t4,1104(slot)
 ;   add t3,t4,t3
-;   ld s2,1080(nominal_sp)
-;   ld t4,1088(nominal_sp)
-;   add t4,t4,s2
-;   ld s1,1064(nominal_sp)
-;   ld s5,1072(nominal_sp)
-;   add s1,s5,s1
-;   ld s2,1048(nominal_sp)
-;   ld s3,1056(nominal_sp)
+;   ld s1,1088(slot)
+;   ld s3,1080(slot)
+;   add t4,s1,s3
+;   ld s1,1064(slot)
+;   ld s2,1072(slot)
+;   add s1,s2,s1
+;   ld s2,1048(slot)
+;   ld s3,1056(slot)
 ;   add s2,s3,s2
-;   ld s3,1032(nominal_sp)
-;   ld s4,1040(nominal_sp)
+;   ld s3,1032(slot)
+;   ld s4,1040(slot)
 ;   add s3,s4,s3
-;   ld s5,1016(nominal_sp)
-;   ld s4,1024(nominal_sp)
+;   ld s4,1024(slot)
+;   ld s5,1016(slot)
 ;   add s4,s4,s5
-;   ld s5,1008(nominal_sp)
+;   ld s5,1008(slot)
 ;   add s5,s5,s6
 ;   add a1,a0,a1
 ;   add a2,a2,a3
@@ -611,22 +611,22 @@ block0(v0: i8):
 ;   add a3,a5,a0
 ;   add a1,a1,a2
 ;   add a1,a3,a1
-;   ld a0,1000(nominal_sp)
-;   add sp,+1360
-;   ld s1,-8(sp)
-;   ld s2,-16(sp)
-;   ld s3,-24(sp)
-;   ld s4,-32(sp)
-;   ld s5,-40(sp)
-;   ld s6,-48(sp)
-;   ld s7,-56(sp)
-;   ld s8,-64(sp)
-;   ld s9,-72(sp)
-;   ld s10,-80(sp)
-;   ld s11,-88(sp)
+;   ld a0,1000(slot)
+;   ld s1,1352(sp)
+;   ld s2,1344(sp)
+;   ld s3,1336(sp)
+;   ld s4,1328(sp)
+;   ld s5,1320(sp)
+;   ld s6,1312(sp)
+;   ld s7,1304(sp)
+;   ld s8,1296(sp)
+;   ld s9,1288(sp)
+;   ld s10,1280(sp)
+;   ld s11,1272(sp)
+;   addi sp,sp,1360
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -635,18 +635,18 @@ block0(v0: i8):
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   sd s1, -8(sp)
-;   sd s2, -0x10(sp)
-;   sd s3, -0x18(sp)
-;   sd s4, -0x20(sp)
-;   sd s5, -0x28(sp)
-;   sd s6, -0x30(sp)
-;   sd s7, -0x38(sp)
-;   sd s8, -0x40(sp)
-;   sd s9, -0x48(sp)
-;   sd s10, -0x50(sp)
-;   sd s11, -0x58(sp)
 ;   addi sp, sp, -0x550
+;   sd s1, 0x548(sp)
+;   sd s2, 0x540(sp)
+;   sd s3, 0x538(sp)
+;   sd s4, 0x530(sp)
+;   sd s5, 0x528(sp)
+;   sd s6, 0x520(sp)
+;   sd s7, 0x518(sp)
+;   sd s8, 0x510(sp)
+;   sd s9, 0x508(sp)
+;   sd s10, 0x500(sp)
+;   sd s11, 0x4f8(sp)
 ; block1: ; offset 0x40
 ;   sd a0, 0x3e8(sp)
 ;   addi a2, zero, 2
@@ -743,55 +743,55 @@ block0(v0: i8):
 ;   addi a0, a0, 0x25
 ;   ld a1, 0x4e8(sp)
 ;   addi a1, a1, 0x27
-;   ld a5, 0x4e0(sp)
-;   addi a2, a5, 0x1f
+;   ld a2, 0x4e0(sp)
+;   addi a2, a2, 0x1f
 ;   ld a3, 0x4d8(sp)
 ;   addi a3, a3, 0x21
-;   ld a5, 0x4d0(sp)
-;   addi a4, a5, 0x23
+;   ld a4, 0x4d0(sp)
+;   addi a4, a4, 0x23
 ;   ld a5, 0x4c8(sp)
 ;   addi a5, a5, 0x25
-;   ld s11, 0x4c0(sp)
-;   addi s7, s11, 0x27
-;   ld t2, 0x4b8(sp)
-;   addi s8, t2, 0x1f
-;   ld t3, 0x4b0(sp)
-;   addi s9, t3, 0x21
-;   ld s2, 0x4a8(sp)
-;   addi s10, s2, 0x23
-;   ld s5, 0x4a0(sp)
-;   addi s11, s5, 0x25
+;   ld t0, 0x4c0(sp)
+;   addi s7, t0, 0x27
+;   ld a6, 0x4b8(sp)
+;   addi s8, a6, 0x1f
+;   ld t4, 0x4b0(sp)
+;   addi s9, t4, 0x21
+;   ld s3, 0x4a8(sp)
+;   addi s10, s3, 0x23
+;   ld s11, 0x4a0(sp)
+;   addi s11, s11, 0x25
 ;   ld t0, 0x498(sp)
 ;   addi t0, t0, 0x27
-;   ld t1, 0x488(sp)
-;   ld t2, 0x490(sp)
-;   add t1, t2, t1
-;   ld t4, 0x478(sp)
-;   ld a7, 0x480(sp)
-;   add t2, a7, t4
-;   ld s5, 0x468(sp)
-;   ld s3, 0x470(sp)
-;   add a6, s3, s5
+;   ld t1, 0x490(sp)
+;   ld t2, 0x488(sp)
+;   add t1, t1, t2
+;   ld s1, 0x478(sp)
+;   ld t3, 0x480(sp)
+;   add t2, t3, s1
+;   ld a6, 0x468(sp)
+;   ld s4, 0x470(sp)
+;   add a6, s4, a6
 ;   ld a7, 0x458(sp)
 ;   ld t3, 0x460(sp)
 ;   add a7, t3, a7
 ;   ld t3, 0x448(sp)
 ;   ld t4, 0x450(sp)
 ;   add t3, t4, t3
-;   ld s2, 0x438(sp)
-;   ld t4, 0x440(sp)
-;   add t4, t4, s2
+;   ld s1, 0x440(sp)
+;   ld s3, 0x438(sp)
+;   add t4, s1, s3
 ;   ld s1, 0x428(sp)
-;   ld s5, 0x430(sp)
-;   add s1, s5, s1
+;   ld s2, 0x430(sp)
+;   add s1, s2, s1
 ;   ld s2, 0x418(sp)
 ;   ld s3, 0x420(sp)
 ;   add s2, s3, s2
 ;   ld s3, 0x408(sp)
 ;   ld s4, 0x410(sp)
 ;   add s3, s4, s3
-;   ld s5, 0x3f8(sp)
 ;   ld s4, 0x400(sp)
+;   ld s5, 0x3f8(sp)
 ;   add s4, s4, s5
 ;   ld s5, 0x3f0(sp)
 ;   add s5, s5, s6
@@ -818,18 +818,18 @@ block0(v0: i8):
 ;   add a1, a1, a2
 ;   add a1, a3, a1
 ;   ld a0, 0x3e8(sp)
+;   ld s1, 0x548(sp)
+;   ld s2, 0x540(sp)
+;   ld s3, 0x538(sp)
+;   ld s4, 0x530(sp)
+;   ld s5, 0x528(sp)
+;   ld s6, 0x520(sp)
+;   ld s7, 0x518(sp)
+;   ld s8, 0x510(sp)
+;   ld s9, 0x508(sp)
+;   ld s10, 0x500(sp)
+;   ld s11, 0x4f8(sp)
 ;   addi sp, sp, 0x550
-;   ld s1, -8(sp)
-;   ld s2, -0x10(sp)
-;   ld s3, -0x18(sp)
-;   ld s4, -0x20(sp)
-;   ld s5, -0x28(sp)
-;   ld s6, -0x30(sp)
-;   ld s7, -0x38(sp)
-;   ld s8, -0x40(sp)
-;   ld s9, -0x48(sp)
-;   ld s10, -0x50(sp)
-;   ld s11, -0x58(sp)
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -844,18 +844,18 @@ block0(v0: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   add sp,-16
+;   addi sp,sp,-16
 ; block0:
-;   sd a0,0(nominal_sp)
-;   sd a1,8(nominal_sp)
-;   add sp,+16
+;   sd a0,0(slot)
+;   sd a1,8(slot)
+;   addi sp,sp,16
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -884,18 +884,18 @@ block0(v0: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   add sp,-32
+;   addi sp,sp,-32
 ; block0:
-;   sd a0,32(nominal_sp)
-;   sd a1,40(nominal_sp)
-;   add sp,+32
+;   sd a0,32(slot)
+;   sd a1,40(slot)
+;   addi sp,sp,32
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -924,21 +924,25 @@ block0(v0: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ;   lui a0,24
 ;   addi a0,a0,1712
 ;   call %Probestack
-;   add sp,-100016
+;   lui t6,-24
+;   addi t6,t6,-1712
+;   add sp,sp,t6
 ; block0:
-;   sd a0,0(nominal_sp)
-;   sd a1,8(nominal_sp)
-;   add sp,+100016
+;   sd a0,0(slot)
+;   sd a1,8(slot)
+;   lui t6,24
+;   addi t6,t6,1712
+;   add sp,sp,t6
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -949,21 +953,17 @@ block0(v0: i128):
 ;   mv s0, sp
 ;   lui a0, 0x18
 ;   addi a0, a0, 0x6b0
-;   auipc t5, 0
-;   ld t5, 0xc(t5)
-;   j 0xc
-;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %Probestack 0
-;   .byte 0x00, 0x00, 0x00, 0x00
-;   jalr t5
+;   auipc ra, 0 ; reloc_external RiscvCallPlt %Probestack 0
+;   jalr ra
 ;   lui t6, 0xfffe8
 ;   addi t6, t6, -0x6b0
-;   add sp, t6, sp
-; block1: ; offset 0x3c
+;   add sp, sp, t6
+; block1: ; offset 0x2c
 ;   sd a0, 0(sp)
 ;   sd a1, 8(sp)
 ;   lui t6, 0x18
 ;   addi t6, t6, 0x6b0
-;   add sp, t6, sp
+;   add sp, sp, t6
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -978,18 +978,18 @@ block0:
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   add sp,-16
+;   addi sp,sp,-16
 ; block0:
-;   ld a0,0(nominal_sp)
-;   ld a1,8(nominal_sp)
-;   add sp,+16
+;   ld a0,0(slot)
+;   ld a1,8(slot)
+;   addi sp,sp,16
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -1018,18 +1018,18 @@ block0:
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   add sp,-32
+;   addi sp,sp,-32
 ; block0:
-;   ld a0,32(nominal_sp)
-;   ld a1,40(nominal_sp)
-;   add sp,+32
+;   ld a0,32(slot)
+;   ld a1,40(slot)
+;   addi sp,sp,32
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -1058,21 +1058,25 @@ block0:
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ;   lui a0,24
 ;   addi a0,a0,1712
 ;   call %Probestack
-;   add sp,-100016
+;   lui t6,-24
+;   addi t6,t6,-1712
+;   add sp,sp,t6
 ; block0:
-;   ld a0,0(nominal_sp)
-;   ld a1,8(nominal_sp)
-;   add sp,+100016
+;   ld a0,0(slot)
+;   ld a1,8(slot)
+;   lui t6,24
+;   addi t6,t6,1712
+;   add sp,sp,t6
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -1083,21 +1087,17 @@ block0:
 ;   mv s0, sp
 ;   lui a0, 0x18
 ;   addi a0, a0, 0x6b0
-;   auipc t5, 0
-;   ld t5, 0xc(t5)
-;   j 0xc
-;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %Probestack 0
-;   .byte 0x00, 0x00, 0x00, 0x00
-;   jalr t5
+;   auipc ra, 0 ; reloc_external RiscvCallPlt %Probestack 0
+;   jalr ra
 ;   lui t6, 0xfffe8
 ;   addi t6, t6, -0x6b0
-;   add sp, t6, sp
-; block1: ; offset 0x3c
+;   add sp, sp, t6
+; block1: ; offset 0x2c
 ;   ld a0, 0(sp)
 ;   ld a1, 8(sp)
 ;   lui t6, 0x18
 ;   addi t6, t6, 0x6b0
-;   add sp, t6, sp
+;   add sp, sp, t6
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
diff --git a/cranelift/filetests/filetests/isa/riscv64/symbol-value-pic.clif b/cranelift/filetests/filetests/isa/riscv64/symbol-value-pic.clif
new file mode 100644
index 000000000000..049e9717d54e
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/symbol-value-pic.clif
@@ -0,0 +1,24 @@
+test compile precise-output
+set unwind_info=false
+set is_pic
+target riscv64
+
+function %f() -> i64 {
+  gv0 = symbol %my_global
+
+block0:
+  v0 = symbol_value.i64 gv0
+  return v0
+}
+
+; VCode:
+; block0:
+;   load_sym a0,%my_global+0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   auipc a0, 0 ; reloc_external RiscvGotHi20 %my_global 0
+;   ld a0, 0(a0) ; reloc_external RiscvPCRelLo12I func+0 0
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/tail-call-conv.clif b/cranelift/filetests/filetests/isa/riscv64/tail-call-conv.clif
index f8f17dea411a..279f8da1af91 100644
--- a/cranelift/filetests/filetests/isa/riscv64/tail-call-conv.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/tail-call-conv.clif
@@ -9,20 +9,16 @@ block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64, v6: i64, v7: i64, v
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   ld a4,16(fp)
-;   ld a0,24(fp)
-;   ld a2,32(fp)
-;   ld a4,40(fp)
-;   ld s1,48(fp)
+;   ld a0,-8(incoming_arg)
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
-;   add sp,+48
+;   addi sp,sp,16
+;   addi sp,sp,144
 ;   ret
 ;
 ; Disassembled:
@@ -32,15 +28,11 @@ block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64, v6: i64, v7: i64, v
 ;   sd s0, 0(sp)
 ;   mv s0, sp
 ; block1: ; offset 0x10
-;   ld a4, 0x10(s0)
-;   ld a0, 0x18(s0)
-;   ld a2, 0x20(s0)
-;   ld a4, 0x28(s0)
-;   ld s1, 0x30(s0)
+;   ld a0, 0x98(sp)
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
-;   addi sp, sp, 0x30
+;   addi sp, sp, 0x90
 ;   ret
 
 function %tail_caller_stack_args() -> i64 tail {
@@ -78,55 +70,88 @@ block0:
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   add sp,-16
+;   addi sp,sp,-256
+;   sd s1,248(sp)
+;   sd s2,240(sp)
+;   sd s3,232(sp)
+;   sd s4,224(sp)
+;   sd s5,216(sp)
+;   sd s6,208(sp)
+;   sd s7,200(sp)
+;   sd s8,192(sp)
+;   sd s9,184(sp)
+;   sd s10,176(sp)
+;   sd s11,168(sp)
 ; block0:
-;   li s1,10
-;   sd s1,8(nominal_sp)
-;   li a0,15
-;   sd a0,0(nominal_sp)
-;   li a1,20
-;   li a2,25
-;   li a3,30
-;   li a4,35
-;   li a5,40
-;   li a6,45
-;   li a7,50
-;   li s2,55
-;   li s3,60
-;   li s4,65
-;   li s5,70
-;   li s6,75
-;   li s7,80
-;   li s8,85
-;   li s9,90
-;   li s10,95
-;   li s11,100
-;   li t3,105
-;   li t4,110
-;   li t0,115
-;   li t1,120
-;   li t2,125
-;   li s1,130
-;   li a0,135
-;   add sp,-48
-;   virtual_sp_offset_adj +48
-;   sd t0,0(sp)
-;   sd t1,8(sp)
-;   sd t2,16(sp)
-;   sd s1,24(sp)
-;   sd a0,32(sp)
-;   load_sym t0,%tail_callee_stack_args+0
-;   ld a0,0(nominal_sp)
-;   ld s1,8(nominal_sp)
-;   callind t0
-;   add sp,+16
+;   li a1,10
+;   sd a1,8(slot)
+;   li a2,15
+;   sd a2,0(slot)
+;   li a2,20
+;   li a3,25
+;   li a4,30
+;   li a5,35
+;   li a6,40
+;   li a7,45
+;   li s3,50
+;   li s4,55
+;   li s5,60
+;   li s6,65
+;   li s7,70
+;   li s8,75
+;   li s9,80
+;   li s10,85
+;   li s11,90
+;   li t0,95
+;   li t1,100
+;   li t2,105
+;   li t3,110
+;   li t4,115
+;   li s1,120
+;   li s2,125
+;   li a0,130
+;   li a1,135
+;   sd s3,0(sp)
+;   sd s4,8(sp)
+;   sd s5,16(sp)
+;   sd s6,24(sp)
+;   sd s7,32(sp)
+;   sd s8,40(sp)
+;   sd s9,48(sp)
+;   sd s10,56(sp)
+;   sd s11,64(sp)
+;   sd t0,72(sp)
+;   sd t1,80(sp)
+;   sd t2,88(sp)
+;   sd t3,96(sp)
+;   sd t4,104(sp)
+;   sd s1,112(sp)
+;   sd s2,120(sp)
+;   sd a0,128(sp)
+;   sd a1,136(sp)
+;   load_sym s3,%tail_callee_stack_args+0
+;   ld a0,8(slot)
+;   ld a1,0(slot)
+;   callind s3
+;   ld s1,248(sp)
+;   ld s2,240(sp)
+;   ld s3,232(sp)
+;   ld s4,224(sp)
+;   ld s5,216(sp)
+;   ld s6,208(sp)
+;   ld s7,200(sp)
+;   ld s8,192(sp)
+;   ld s9,184(sp)
+;   ld s10,176(sp)
+;   ld s11,168(sp)
+;   addi sp,sp,256
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -135,51 +160,86 @@ block0:
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   addi sp, sp, -0x10
-; block1: ; offset 0x14
-;   addi s1, zero, 0xa
-;   sd s1, 8(sp)
-;   addi a0, zero, 0xf
-;   sd a0, 0(sp)
-;   addi a1, zero, 0x14
-;   addi a2, zero, 0x19
-;   addi a3, zero, 0x1e
-;   addi a4, zero, 0x23
-;   addi a5, zero, 0x28
-;   addi a6, zero, 0x2d
-;   addi a7, zero, 0x32
-;   addi s2, zero, 0x37
-;   addi s3, zero, 0x3c
-;   addi s4, zero, 0x41
-;   addi s5, zero, 0x46
-;   addi s6, zero, 0x4b
-;   addi s7, zero, 0x50
-;   addi s8, zero, 0x55
-;   addi s9, zero, 0x5a
-;   addi s10, zero, 0x5f
-;   addi s11, zero, 0x64
-;   addi t3, zero, 0x69
-;   addi t4, zero, 0x6e
-;   addi t0, zero, 0x73
-;   addi t1, zero, 0x78
-;   addi t2, zero, 0x7d
-;   addi s1, zero, 0x82
-;   addi a0, zero, 0x87
-;   addi sp, sp, -0x30
-;   sd t0, 0(sp)
-;   sd t1, 8(sp)
-;   sd t2, 0x10(sp)
-;   sd s1, 0x18(sp)
-;   sd a0, 0x20(sp)
-;   auipc t0, 0
-;   ld t0, 0xc(t0)
+;   addi sp, sp, -0x100
+;   sd s1, 0xf8(sp)
+;   sd s2, 0xf0(sp)
+;   sd s3, 0xe8(sp)
+;   sd s4, 0xe0(sp)
+;   sd s5, 0xd8(sp)
+;   sd s6, 0xd0(sp)
+;   sd s7, 0xc8(sp)
+;   sd s8, 0xc0(sp)
+;   sd s9, 0xb8(sp)
+;   sd s10, 0xb0(sp)
+;   sd s11, 0xa8(sp)
+; block1: ; offset 0x40
+;   addi a1, zero, 0xa
+;   sd a1, 0x98(sp)
+;   addi a2, zero, 0xf
+;   sd a2, 0x90(sp)
+;   addi a2, zero, 0x14
+;   addi a3, zero, 0x19
+;   addi a4, zero, 0x1e
+;   addi a5, zero, 0x23
+;   addi a6, zero, 0x28
+;   addi a7, zero, 0x2d
+;   addi s3, zero, 0x32
+;   addi s4, zero, 0x37
+;   addi s5, zero, 0x3c
+;   addi s6, zero, 0x41
+;   addi s7, zero, 0x46
+;   addi s8, zero, 0x4b
+;   addi s9, zero, 0x50
+;   addi s10, zero, 0x55
+;   addi s11, zero, 0x5a
+;   addi t0, zero, 0x5f
+;   addi t1, zero, 0x64
+;   addi t2, zero, 0x69
+;   addi t3, zero, 0x6e
+;   addi t4, zero, 0x73
+;   addi s1, zero, 0x78
+;   addi s2, zero, 0x7d
+;   addi a0, zero, 0x82
+;   addi a1, zero, 0x87
+;   sd s3, 0(sp)
+;   sd s4, 8(sp)
+;   sd s5, 0x10(sp)
+;   sd s6, 0x18(sp)
+;   sd s7, 0x20(sp)
+;   sd s8, 0x28(sp)
+;   sd s9, 0x30(sp)
+;   sd s10, 0x38(sp)
+;   sd s11, 0x40(sp)
+;   sd t0, 0x48(sp)
+;   sd t1, 0x50(sp)
+;   sd t2, 0x58(sp)
+;   sd t3, 0x60(sp)
+;   sd t4, 0x68(sp)
+;   sd s1, 0x70(sp)
+;   sd s2, 0x78(sp)
+;   sd a0, 0x80(sp)
+;   sd a1, 0x88(sp)
+;   auipc s3, 0
+;   ld s3, 0xc(s3)
 ;   j 0xc
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %tail_callee_stack_args 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   ld a0, 0x30(sp)
-;   ld s1, 0x38(sp)
-;   jalr t0
-;   addi sp, sp, 0x10
+;   ld a0, 0x98(sp)
+;   ld a1, 0x90(sp)
+;   jalr s3
+;   addi sp, sp, -0x90
+;   ld s1, 0xf8(sp)
+;   ld s2, 0xf0(sp)
+;   ld s3, 0xe8(sp)
+;   ld s4, 0xe0(sp)
+;   ld s5, 0xd8(sp)
+;   ld s6, 0xd0(sp)
+;   ld s7, 0xc8(sp)
+;   ld s8, 0xc0(sp)
+;   ld s9, 0xb8(sp)
+;   ld s10, 0xb0(sp)
+;   ld s11, 0xa8(sp)
+;   addi sp, sp, 0x100
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -219,53 +279,94 @@ block0:
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   add sp,-32
+;   addi sp,sp,-128
+;   sd s1,120(sp)
+;   sd s2,112(sp)
+;   sd s3,104(sp)
+;   sd s4,96(sp)
+;   sd s5,88(sp)
+;   sd s6,80(sp)
+;   sd s7,72(sp)
+;   sd s8,64(sp)
+;   sd s9,56(sp)
+;   sd s10,48(sp)
+;   sd s11,40(sp)
 ; block0:
-;   li a3,10
-;   sd a3,16(nominal_sp)
-;   li a0,15
-;   sd a0,8(nominal_sp)
-;   li a1,20
-;   sd a1,0(nominal_sp)
-;   li a2,25
-;   li a3,30
-;   li a4,35
-;   li a5,40
-;   li a6,45
-;   li a7,50
-;   li s2,55
-;   li s3,60
-;   li s4,65
-;   li s5,70
-;   li s6,75
-;   li s7,80
-;   li s8,85
-;   li s9,90
-;   li s10,95
-;   li s11,100
+;   li a1,10
+;   sd a1,16(slot)
+;   li a1,15
+;   sd a1,8(slot)
+;   li a4,20
+;   li a5,25
+;   li a2,30
+;   li s3,35
+;   li s4,40
+;   li s5,45
+;   li s6,50
+;   li s7,55
+;   li s8,60
+;   li s9,65
+;   li s10,70
+;   li s11,75
+;   li t0,80
+;   li t1,85
+;   li t2,90
+;   li a6,95
+;   li a7,100
 ;   li t3,105
 ;   li t4,110
-;   li t0,115
-;   li t1,120
-;   li t2,125
-;   li a0,130
-;   li a1,135
-;   sd t0,0(s1)
-;   sd t1,8(s1)
-;   sd t2,16(s1)
-;   sd a0,24(s1)
-;   sd a1,32(s1)
-;   ld a1,0(nominal_sp)
-;   ld a0,8(nominal_sp)
-;   ld s1,16(nominal_sp)
-;   add sp,+32
+;   li s1,115
+;   li s2,120
+;   li a3,125
+;   sd a3,0(slot)
+;   li a1,130
+;   li a3,135
+;   sd a4,0(a0)
+;   sd a5,8(a0)
+;   sd a2,16(a0)
+;   sd s3,24(a0)
+;   sd s4,32(a0)
+;   sd s5,40(a0)
+;   sd s6,48(a0)
+;   sd s7,56(a0)
+;   sd s8,64(a0)
+;   sd s9,72(a0)
+;   sd s10,80(a0)
+;   sd s11,88(a0)
+;   sd t0,96(a0)
+;   sd t1,104(a0)
+;   sd t2,112(a0)
+;   sd a6,120(a0)
+;   sd a7,128(a0)
+;   sd t3,136(a0)
+;   sd t4,144(a0)
+;   sd s1,152(a0)
+;   sd s2,160(a0)
+;   ld a4,0(slot)
+;   sd a4,168(a0)
+;   sd a1,176(a0)
+;   sd a3,184(a0)
+;   ld a0,16(slot)
+;   ld a1,8(slot)
+;   ld s1,120(sp)
+;   ld s2,112(sp)
+;   ld s3,104(sp)
+;   ld s4,96(sp)
+;   ld s5,88(sp)
+;   ld s6,80(sp)
+;   ld s7,72(sp)
+;   ld s8,64(sp)
+;   ld s9,56(sp)
+;   ld s10,48(sp)
+;   ld s11,40(sp)
+;   addi sp,sp,128
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -274,46 +375,87 @@ block0:
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   addi sp, sp, -0x20
-; block1: ; offset 0x14
-;   addi a3, zero, 0xa
-;   sd a3, 0x10(sp)
-;   addi a0, zero, 0xf
-;   sd a0, 8(sp)
-;   addi a1, zero, 0x14
-;   sd a1, 0(sp)
-;   addi a2, zero, 0x19
-;   addi a3, zero, 0x1e
-;   addi a4, zero, 0x23
-;   addi a5, zero, 0x28
-;   addi a6, zero, 0x2d
-;   addi a7, zero, 0x32
-;   addi s2, zero, 0x37
-;   addi s3, zero, 0x3c
-;   addi s4, zero, 0x41
-;   addi s5, zero, 0x46
-;   addi s6, zero, 0x4b
-;   addi s7, zero, 0x50
-;   addi s8, zero, 0x55
-;   addi s9, zero, 0x5a
-;   addi s10, zero, 0x5f
-;   addi s11, zero, 0x64
+;   addi sp, sp, -0x80
+;   sd s1, 0x78(sp)
+;   sd s2, 0x70(sp)
+;   sd s3, 0x68(sp)
+;   sd s4, 0x60(sp)
+;   sd s5, 0x58(sp)
+;   sd s6, 0x50(sp)
+;   sd s7, 0x48(sp)
+;   sd s8, 0x40(sp)
+;   sd s9, 0x38(sp)
+;   sd s10, 0x30(sp)
+;   sd s11, 0x28(sp)
+; block1: ; offset 0x40
+;   addi a1, zero, 0xa
+;   sd a1, 0x10(sp)
+;   addi a1, zero, 0xf
+;   sd a1, 8(sp)
+;   addi a4, zero, 0x14
+;   addi a5, zero, 0x19
+;   addi a2, zero, 0x1e
+;   addi s3, zero, 0x23
+;   addi s4, zero, 0x28
+;   addi s5, zero, 0x2d
+;   addi s6, zero, 0x32
+;   addi s7, zero, 0x37
+;   addi s8, zero, 0x3c
+;   addi s9, zero, 0x41
+;   addi s10, zero, 0x46
+;   addi s11, zero, 0x4b
+;   addi t0, zero, 0x50
+;   addi t1, zero, 0x55
+;   addi t2, zero, 0x5a
+;   addi a6, zero, 0x5f
+;   addi a7, zero, 0x64
 ;   addi t3, zero, 0x69
 ;   addi t4, zero, 0x6e
-;   addi t0, zero, 0x73
-;   addi t1, zero, 0x78
-;   addi t2, zero, 0x7d
-;   addi a0, zero, 0x82
-;   addi a1, zero, 0x87
-;   sd t0, 0(s1)
-;   sd t1, 8(s1)
-;   sd t2, 0x10(s1)
-;   sd a0, 0x18(s1)
-;   sd a1, 0x20(s1)
-;   ld a1, 0(sp)
-;   ld a0, 8(sp)
-;   ld s1, 0x10(sp)
-;   addi sp, sp, 0x20
+;   addi s1, zero, 0x73
+;   addi s2, zero, 0x78
+;   addi a3, zero, 0x7d
+;   sd a3, 0(sp)
+;   addi a1, zero, 0x82
+;   addi a3, zero, 0x87
+;   sd a4, 0(a0)
+;   sd a5, 8(a0)
+;   sd a2, 0x10(a0)
+;   sd s3, 0x18(a0)
+;   sd s4, 0x20(a0)
+;   sd s5, 0x28(a0)
+;   sd s6, 0x30(a0)
+;   sd s7, 0x38(a0)
+;   sd s8, 0x40(a0)
+;   sd s9, 0x48(a0)
+;   sd s10, 0x50(a0)
+;   sd s11, 0x58(a0)
+;   sd t0, 0x60(a0)
+;   sd t1, 0x68(a0)
+;   sd t2, 0x70(a0)
+;   sd a6, 0x78(a0)
+;   sd a7, 0x80(a0)
+;   sd t3, 0x88(a0)
+;   sd t4, 0x90(a0)
+;   sd s1, 0x98(a0)
+;   sd s2, 0xa0(a0)
+;   ld a4, 0(sp)
+;   sd a4, 0xa8(a0)
+;   sd a1, 0xb0(a0)
+;   sd a3, 0xb8(a0)
+;   ld a0, 0x10(sp)
+;   ld a1, 8(sp)
+;   ld s1, 0x78(sp)
+;   ld s2, 0x70(sp)
+;   ld s3, 0x68(sp)
+;   ld s4, 0x60(sp)
+;   ld s5, 0x58(sp)
+;   ld s6, 0x50(sp)
+;   ld s7, 0x48(sp)
+;   ld s8, 0x40(sp)
+;   ld s9, 0x38(sp)
+;   ld s10, 0x30(sp)
+;   ld s11, 0x28(sp)
+;   addi sp, sp, 0x80
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -328,26 +470,43 @@ block0:
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
+;   addi sp,sp,-192
 ; block0:
-;   add sp,-48
-;   virtual_sp_offset_adj +48
-;   load_addr s1,0(sp)
-;   load_sym t0,%tail_callee_stack_rets+0
-;   callind t0
-;   ld a2,0(sp)
-;   ld a4,8(sp)
-;   ld a0,16(sp)
-;   ld a2,24(sp)
-;   ld s1,32(sp)
-;   add sp,+48
-;   virtual_sp_offset_adj -48
+;   load_addr a0,0(sp)
+;   load_sym a4,%tail_callee_stack_rets+0
+;   callind a4
+;   ld a5,0(sp)
+;   ld a1,8(sp)
+;   ld a3,16(sp)
+;   ld a5,24(sp)
+;   ld a1,32(sp)
+;   ld a3,40(sp)
+;   ld a5,48(sp)
+;   ld a1,56(sp)
+;   ld a3,64(sp)
+;   ld a5,72(sp)
+;   ld a1,80(sp)
+;   ld a3,88(sp)
+;   ld a5,96(sp)
+;   ld a1,104(sp)
+;   ld a3,112(sp)
+;   ld a5,120(sp)
+;   ld a1,128(sp)
+;   ld a3,136(sp)
+;   ld a5,144(sp)
+;   ld a1,152(sp)
+;   ld a3,160(sp)
+;   ld a5,168(sp)
+;   ld a1,176(sp)
+;   ld a0,184(sp)
+;   addi sp,sp,192
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -356,21 +515,40 @@ block0:
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-; block1: ; offset 0x10
-;   addi sp, sp, -0x30
-;   mv s1, sp
-;   auipc t0, 0
-;   ld t0, 0xc(t0)
+;   addi sp, sp, -0xc0
+; block1: ; offset 0x14
+;   mv a0, sp
+;   auipc a4, 0
+;   ld a4, 0xc(a4)
 ;   j 0xc
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %tail_callee_stack_rets 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   jalr t0
-;   ld a2, 0(sp)
-;   ld a4, 8(sp)
-;   ld a0, 0x10(sp)
-;   ld a2, 0x18(sp)
-;   ld s1, 0x20(sp)
-;   addi sp, sp, 0x30
+;   jalr a4
+;   ld a5, 0(sp)
+;   ld a1, 8(sp)
+;   ld a3, 0x10(sp)
+;   ld a5, 0x18(sp)
+;   ld a1, 0x20(sp)
+;   ld a3, 0x28(sp)
+;   ld a5, 0x30(sp)
+;   ld a1, 0x38(sp)
+;   ld a3, 0x40(sp)
+;   ld a5, 0x48(sp)
+;   ld a1, 0x50(sp)
+;   ld a3, 0x58(sp)
+;   ld a5, 0x60(sp)
+;   ld a1, 0x68(sp)
+;   ld a3, 0x70(sp)
+;   ld a5, 0x78(sp)
+;   ld a1, 0x80(sp)
+;   ld a3, 0x88(sp)
+;   ld a5, 0x90(sp)
+;   ld a1, 0x98(sp)
+;   ld a3, 0xa0(sp)
+;   ld a5, 0xa8(sp)
+;   ld a1, 0xb0(sp)
+;   ld a0, 0xb8(sp)
+;   addi sp, sp, 0xc0
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
@@ -385,34 +563,88 @@ block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64, v6: i64, v7: i64, v
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   add sp,-32
+;   addi sp,sp,-128
+;   sd s1,120(sp)
+;   sd s2,112(sp)
+;   sd s3,104(sp)
+;   sd s4,96(sp)
+;   sd s5,88(sp)
+;   sd s6,80(sp)
+;   sd s7,72(sp)
+;   sd s8,64(sp)
+;   sd s9,56(sp)
+;   sd s10,48(sp)
+;   sd s11,40(sp)
 ; block0:
-;   sd a0,0(nominal_sp)
-;   sd a2,8(nominal_sp)
-;   sd a4,16(nominal_sp)
-;   ld a4,16(fp)
-;   ld a0,24(fp)
-;   ld t2,32(fp)
-;   ld t1,40(fp)
-;   ld t0,48(fp)
-;   ld a2,56(fp)
-;   sd a4,0(a2)
-;   sd a0,8(a2)
-;   sd t2,16(a2)
-;   sd t1,24(a2)
-;   sd t0,32(a2)
-;   ld a0,0(nominal_sp)
-;   ld a2,8(nominal_sp)
-;   ld a4,16(nominal_sp)
-;   add sp,+32
+;   sd a0,0(slot)
+;   sd a1,8(slot)
+;   ld s4,-160(incoming_arg)
+;   ld s6,-152(incoming_arg)
+;   ld s8,-144(incoming_arg)
+;   ld s10,-136(incoming_arg)
+;   ld t0,-128(incoming_arg)
+;   ld t1,-120(incoming_arg)
+;   ld t4,-112(incoming_arg)
+;   ld t3,-104(incoming_arg)
+;   ld s1,-96(incoming_arg)
+;   ld s3,-88(incoming_arg)
+;   ld s5,-80(incoming_arg)
+;   ld s7,-72(incoming_arg)
+;   ld s9,-64(incoming_arg)
+;   ld s11,-56(incoming_arg)
+;   ld a1,-48(incoming_arg)
+;   ld a0,-40(incoming_arg)
+;   ld s2,-32(incoming_arg)
+;   ld t2,-24(incoming_arg)
+;   sd t2,16(slot)
+;   ld t2,-16(incoming_arg)
+;   sd a2,0(t2)
+;   sd a3,8(t2)
+;   sd a4,16(t2)
+;   sd a5,24(t2)
+;   sd a6,32(t2)
+;   sd a7,40(t2)
+;   sd s4,48(t2)
+;   sd s6,56(t2)
+;   sd s8,64(t2)
+;   sd s10,72(t2)
+;   sd t0,80(t2)
+;   sd t1,88(t2)
+;   sd t4,96(t2)
+;   sd t3,104(t2)
+;   sd s1,112(t2)
+;   sd s3,120(t2)
+;   sd s5,128(t2)
+;   sd s7,136(t2)
+;   sd s9,144(t2)
+;   sd s11,152(t2)
+;   sd a1,160(t2)
+;   sd a0,168(t2)
+;   sd s2,176(t2)
+;   ld a1,16(slot)
+;   sd a1,184(t2)
+;   ld a0,0(slot)
+;   ld a1,8(slot)
+;   ld s1,120(sp)
+;   ld s2,112(sp)
+;   ld s3,104(sp)
+;   ld s4,96(sp)
+;   ld s5,88(sp)
+;   ld s6,80(sp)
+;   ld s7,72(sp)
+;   ld s8,64(sp)
+;   ld s9,56(sp)
+;   ld s10,48(sp)
+;   ld s11,40(sp)
+;   addi sp,sp,128
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
-;   add sp,+48
+;   addi sp,sp,16
+;   addi sp,sp,160
 ;   ret
 ;
 ; Disassembled:
@@ -421,30 +653,84 @@ block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64, v6: i64, v7: i64, v
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   addi sp, sp, -0x20
-; block1: ; offset 0x14
+;   addi sp, sp, -0x80
+;   sd s1, 0x78(sp)
+;   sd s2, 0x70(sp)
+;   sd s3, 0x68(sp)
+;   sd s4, 0x60(sp)
+;   sd s5, 0x58(sp)
+;   sd s6, 0x50(sp)
+;   sd s7, 0x48(sp)
+;   sd s8, 0x40(sp)
+;   sd s9, 0x38(sp)
+;   sd s10, 0x30(sp)
+;   sd s11, 0x28(sp)
+; block1: ; offset 0x40
 ;   sd a0, 0(sp)
-;   sd a2, 8(sp)
-;   sd a4, 0x10(sp)
-;   ld a4, 0x10(s0)
-;   ld a0, 0x18(s0)
-;   ld t2, 0x20(s0)
-;   ld t1, 0x28(s0)
-;   ld t0, 0x30(s0)
-;   ld a2, 0x38(s0)
-;   sd a4, 0(a2)
-;   sd a0, 8(a2)
-;   sd t2, 0x10(a2)
-;   sd t1, 0x18(a2)
-;   sd t0, 0x20(a2)
+;   sd a1, 8(sp)
+;   ld s4, 0x90(sp)
+;   ld s6, 0x98(sp)
+;   ld s8, 0xa0(sp)
+;   ld s10, 0xa8(sp)
+;   ld t0, 0xb0(sp)
+;   ld t1, 0xb8(sp)
+;   ld t4, 0xc0(sp)
+;   ld t3, 0xc8(sp)
+;   ld s1, 0xd0(sp)
+;   ld s3, 0xd8(sp)
+;   ld s5, 0xe0(sp)
+;   ld s7, 0xe8(sp)
+;   ld s9, 0xf0(sp)
+;   ld s11, 0xf8(sp)
+;   ld a1, 0x100(sp)
+;   ld a0, 0x108(sp)
+;   ld s2, 0x110(sp)
+;   ld t2, 0x118(sp)
+;   sd t2, 0x10(sp)
+;   ld t2, 0x120(sp)
+;   sd a2, 0(t2)
+;   sd a3, 8(t2)
+;   sd a4, 0x10(t2)
+;   sd a5, 0x18(t2)
+;   sd a6, 0x20(t2)
+;   sd a7, 0x28(t2)
+;   sd s4, 0x30(t2)
+;   sd s6, 0x38(t2)
+;   sd s8, 0x40(t2)
+;   sd s10, 0x48(t2)
+;   sd t0, 0x50(t2)
+;   sd t1, 0x58(t2)
+;   sd t4, 0x60(t2)
+;   sd t3, 0x68(t2)
+;   sd s1, 0x70(t2)
+;   sd s3, 0x78(t2)
+;   sd s5, 0x80(t2)
+;   sd s7, 0x88(t2)
+;   sd s9, 0x90(t2)
+;   sd s11, 0x98(t2)
+;   sd a1, 0xa0(t2)
+;   sd a0, 0xa8(t2)
+;   sd s2, 0xb0(t2)
+;   ld a1, 0x10(sp)
+;   sd a1, 0xb8(t2)
 ;   ld a0, 0(sp)
-;   ld a2, 8(sp)
-;   ld a4, 0x10(sp)
-;   addi sp, sp, 0x20
+;   ld a1, 8(sp)
+;   ld s1, 0x78(sp)
+;   ld s2, 0x70(sp)
+;   ld s3, 0x68(sp)
+;   ld s4, 0x60(sp)
+;   ld s5, 0x58(sp)
+;   ld s6, 0x50(sp)
+;   ld s7, 0x48(sp)
+;   ld s8, 0x40(sp)
+;   ld s9, 0x38(sp)
+;   ld s10, 0x30(sp)
+;   ld s11, 0x28(sp)
+;   addi sp, sp, 0x80
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
-;   addi sp, sp, 0x30
+;   addi sp, sp, 0xa0
 ;   ret
 
 function %tail_caller_stack_args_and_rets() -> i64 tail {
@@ -482,64 +768,114 @@ block0:
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   add sp,-16
+;   addi sp,sp,-464
+;   sd s1,456(sp)
+;   sd s2,448(sp)
+;   sd s3,440(sp)
+;   sd s4,432(sp)
+;   sd s5,424(sp)
+;   sd s6,416(sp)
+;   sd s7,408(sp)
+;   sd s8,400(sp)
+;   sd s9,392(sp)
+;   sd s10,384(sp)
+;   sd s11,376(sp)
 ; block0:
-;   li s1,10
-;   sd s1,8(nominal_sp)
-;   li a0,15
-;   sd a0,0(nominal_sp)
-;   li a1,20
-;   li a2,25
-;   li a3,30
-;   li a4,35
-;   li a5,40
-;   li a6,45
-;   li a7,50
-;   li s2,55
-;   li s3,60
-;   li s4,65
-;   li s5,70
-;   li s6,75
-;   li s7,80
-;   li s8,85
-;   li s9,90
-;   li s10,95
-;   li s11,100
-;   li t3,105
-;   li t4,110
-;   li t0,115
-;   li t1,120
-;   li t2,125
-;   li s1,130
-;   li a0,135
-;   add sp,-96
-;   virtual_sp_offset_adj +96
-;   sd t0,0(sp)
-;   sd t1,8(sp)
-;   sd t2,16(sp)
-;   sd s1,24(sp)
-;   sd a0,32(sp)
-;   load_addr a0,48(sp)
-;   sd a0,40(sp)
-;   load_sym t0,%tail_callee_stack_args_and_rets+0
-;   ld a0,0(nominal_sp)
-;   ld s1,8(nominal_sp)
-;   callind t0
-;   ld a4,0(sp)
-;   ld a0,8(sp)
-;   ld a2,16(sp)
-;   ld a4,24(sp)
-;   ld s1,32(sp)
-;   add sp,+48
-;   virtual_sp_offset_adj -48
-;   add sp,+16
+;   li a1,10
+;   sd a1,8(slot)
+;   li a2,15
+;   sd a2,0(slot)
+;   li a2,20
+;   li a3,25
+;   li a4,30
+;   li a5,35
+;   li a6,40
+;   li a7,45
+;   li s11,50
+;   li t0,55
+;   li t1,60
+;   li t2,65
+;   li t3,70
+;   li t4,75
+;   li s1,80
+;   li s2,85
+;   li s3,90
+;   li s4,95
+;   li s5,100
+;   li s6,105
+;   li s7,110
+;   li s8,115
+;   li s9,120
+;   li s10,125
+;   li a0,130
+;   li a1,135
+;   sd s11,0(sp)
+;   sd t0,8(sp)
+;   sd t1,16(sp)
+;   sd t2,24(sp)
+;   sd t3,32(sp)
+;   sd t4,40(sp)
+;   sd s1,48(sp)
+;   sd s2,56(sp)
+;   sd s3,64(sp)
+;   sd s4,72(sp)
+;   sd s5,80(sp)
+;   sd s6,88(sp)
+;   sd s7,96(sp)
+;   sd s8,104(sp)
+;   sd s9,112(sp)
+;   sd s10,120(sp)
+;   sd a0,128(sp)
+;   sd a1,136(sp)
+;   load_addr a0,160(sp)
+;   sd a0,144(sp)
+;   load_sym t1,%tail_callee_stack_args_and_rets+0
+;   ld a0,8(slot)
+;   ld a1,0(slot)
+;   callind t1
+;   ld a2,160(sp)
+;   ld a4,168(sp)
+;   ld a0,176(sp)
+;   ld a2,184(sp)
+;   ld a4,192(sp)
+;   ld a0,200(sp)
+;   ld a2,208(sp)
+;   ld a4,216(sp)
+;   ld a0,224(sp)
+;   ld a2,232(sp)
+;   ld a4,240(sp)
+;   ld a0,248(sp)
+;   ld a2,256(sp)
+;   ld a4,264(sp)
+;   ld a0,272(sp)
+;   ld a2,280(sp)
+;   ld a4,288(sp)
+;   ld a0,296(sp)
+;   ld a2,304(sp)
+;   ld a4,312(sp)
+;   ld a0,320(sp)
+;   ld a2,328(sp)
+;   ld a4,336(sp)
+;   ld a0,344(sp)
+;   ld s1,456(sp)
+;   ld s2,448(sp)
+;   ld s3,440(sp)
+;   ld s4,432(sp)
+;   ld s5,424(sp)
+;   ld s6,416(sp)
+;   ld s7,408(sp)
+;   ld s8,400(sp)
+;   ld s9,392(sp)
+;   ld s10,384(sp)
+;   ld s11,376(sp)
+;   addi sp,sp,464
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -548,59 +884,112 @@ block0:
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   addi sp, sp, -0x10
-; block1: ; offset 0x14
-;   addi s1, zero, 0xa
-;   sd s1, 8(sp)
-;   addi a0, zero, 0xf
-;   sd a0, 0(sp)
-;   addi a1, zero, 0x14
-;   addi a2, zero, 0x19
-;   addi a3, zero, 0x1e
-;   addi a4, zero, 0x23
-;   addi a5, zero, 0x28
-;   addi a6, zero, 0x2d
-;   addi a7, zero, 0x32
-;   addi s2, zero, 0x37
-;   addi s3, zero, 0x3c
-;   addi s4, zero, 0x41
-;   addi s5, zero, 0x46
-;   addi s6, zero, 0x4b
-;   addi s7, zero, 0x50
-;   addi s8, zero, 0x55
-;   addi s9, zero, 0x5a
-;   addi s10, zero, 0x5f
-;   addi s11, zero, 0x64
-;   addi t3, zero, 0x69
-;   addi t4, zero, 0x6e
-;   addi t0, zero, 0x73
-;   addi t1, zero, 0x78
-;   addi t2, zero, 0x7d
-;   addi s1, zero, 0x82
-;   addi a0, zero, 0x87
-;   addi sp, sp, -0x60
-;   sd t0, 0(sp)
-;   sd t1, 8(sp)
-;   sd t2, 0x10(sp)
-;   sd s1, 0x18(sp)
-;   sd a0, 0x20(sp)
-;   addi a0, sp, 0x30
-;   sd a0, 0x28(sp)
-;   auipc t0, 0
-;   ld t0, 0xc(t0)
+;   addi sp, sp, -0x1d0
+;   sd s1, 0x1c8(sp)
+;   sd s2, 0x1c0(sp)
+;   sd s3, 0x1b8(sp)
+;   sd s4, 0x1b0(sp)
+;   sd s5, 0x1a8(sp)
+;   sd s6, 0x1a0(sp)
+;   sd s7, 0x198(sp)
+;   sd s8, 0x190(sp)
+;   sd s9, 0x188(sp)
+;   sd s10, 0x180(sp)
+;   sd s11, 0x178(sp)
+; block1: ; offset 0x40
+;   addi a1, zero, 0xa
+;   sd a1, 0x168(sp)
+;   addi a2, zero, 0xf
+;   sd a2, 0x160(sp)
+;   addi a2, zero, 0x14
+;   addi a3, zero, 0x19
+;   addi a4, zero, 0x1e
+;   addi a5, zero, 0x23
+;   addi a6, zero, 0x28
+;   addi a7, zero, 0x2d
+;   addi s11, zero, 0x32
+;   addi t0, zero, 0x37
+;   addi t1, zero, 0x3c
+;   addi t2, zero, 0x41
+;   addi t3, zero, 0x46
+;   addi t4, zero, 0x4b
+;   addi s1, zero, 0x50
+;   addi s2, zero, 0x55
+;   addi s3, zero, 0x5a
+;   addi s4, zero, 0x5f
+;   addi s5, zero, 0x64
+;   addi s6, zero, 0x69
+;   addi s7, zero, 0x6e
+;   addi s8, zero, 0x73
+;   addi s9, zero, 0x78
+;   addi s10, zero, 0x7d
+;   addi a0, zero, 0x82
+;   addi a1, zero, 0x87
+;   sd s11, 0(sp)
+;   sd t0, 8(sp)
+;   sd t1, 0x10(sp)
+;   sd t2, 0x18(sp)
+;   sd t3, 0x20(sp)
+;   sd t4, 0x28(sp)
+;   sd s1, 0x30(sp)
+;   sd s2, 0x38(sp)
+;   sd s3, 0x40(sp)
+;   sd s4, 0x48(sp)
+;   sd s5, 0x50(sp)
+;   sd s6, 0x58(sp)
+;   sd s7, 0x60(sp)
+;   sd s8, 0x68(sp)
+;   sd s9, 0x70(sp)
+;   sd s10, 0x78(sp)
+;   sd a0, 0x80(sp)
+;   sd a1, 0x88(sp)
+;   addi a0, sp, 0xa0
+;   sd a0, 0x90(sp)
+;   auipc t1, 0
+;   ld t1, 0xc(t1)
 ;   j 0xc
 ;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %tail_callee_stack_args_and_rets 0
 ;   .byte 0x00, 0x00, 0x00, 0x00
-;   ld a0, 0x60(sp)
-;   ld s1, 0x68(sp)
-;   jalr t0
-;   ld a4, 0(sp)
-;   ld a0, 8(sp)
-;   ld a2, 0x10(sp)
-;   ld a4, 0x18(sp)
-;   ld s1, 0x20(sp)
-;   addi sp, sp, 0x30
-;   addi sp, sp, 0x10
+;   ld a0, 0x168(sp)
+;   ld a1, 0x160(sp)
+;   jalr t1
+;   addi sp, sp, -0xa0
+;   ld a2, 0xa0(sp)
+;   ld a4, 0xa8(sp)
+;   ld a0, 0xb0(sp)
+;   ld a2, 0xb8(sp)
+;   ld a4, 0xc0(sp)
+;   ld a0, 0xc8(sp)
+;   ld a2, 0xd0(sp)
+;   ld a4, 0xd8(sp)
+;   ld a0, 0xe0(sp)
+;   ld a2, 0xe8(sp)
+;   ld a4, 0xf0(sp)
+;   ld a0, 0xf8(sp)
+;   ld a2, 0x100(sp)
+;   ld a4, 0x108(sp)
+;   ld a0, 0x110(sp)
+;   ld a2, 0x118(sp)
+;   ld a4, 0x120(sp)
+;   ld a0, 0x128(sp)
+;   ld a2, 0x130(sp)
+;   ld a4, 0x138(sp)
+;   ld a0, 0x140(sp)
+;   ld a2, 0x148(sp)
+;   ld a4, 0x150(sp)
+;   ld a0, 0x158(sp)
+;   ld s1, 0x1c8(sp)
+;   ld s2, 0x1c0(sp)
+;   ld s3, 0x1b8(sp)
+;   ld s4, 0x1b0(sp)
+;   ld s5, 0x1a8(sp)
+;   ld s6, 0x1a0(sp)
+;   ld s7, 0x198(sp)
+;   ld s8, 0x190(sp)
+;   ld s9, 0x188(sp)
+;   ld s10, 0x180(sp)
+;   ld s11, 0x178(sp)
+;   addi sp, sp, 0x1d0
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
diff --git a/cranelift/filetests/filetests/isa/riscv64/tls-elf.clif b/cranelift/filetests/filetests/isa/riscv64/tls-elf.clif
index 18e781b2fc0d..c75afecfc58d 100644
--- a/cranelift/filetests/filetests/isa/riscv64/tls-elf.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/tls-elf.clif
@@ -11,22 +11,22 @@ block0(v0: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   sd s1,-8(sp)
-;   add sp,-16
+;   addi sp,sp,-16
+;   sd s1,8(sp)
 ; block0:
 ;   mv s1,a0
 ;   elf_tls_get_addr a0,userextname0
 ;   mv a1,a0
 ;   mv a0,s1
-;   add sp,+16
-;   ld s1,-8(sp)
+;   ld s1,8(sp)
+;   addi sp,sp,16
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -35,22 +35,61 @@ block0(v0: i32):
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   sd s1, -8(sp)
 ;   addi sp, sp, -0x10
+;   sd s1, 8(sp)
 ; block1: ; offset 0x18
 ;   mv s1, a0
 ;   auipc a0, 0 ; reloc_external RiscvTlsGdHi20 u1:0 0
 ;   mv a0, a0 ; reloc_external RiscvPCRelLo12I func+28 0
-;   auipc t5, 0
-;   ld t5, 0xc(t5)
-;   j 0xc
-;   .byte 0x00, 0x00, 0x00, 0x00 ; reloc_external Abs8 %ElfTlsGetAddr 0
-;   .byte 0x00, 0x00, 0x00, 0x00
-;   jalr t5
+;   auipc ra, 0 ; reloc_external RiscvCallPlt %ElfTlsGetAddr 0
+;   jalr ra
 ;   mv a1, a0
 ;   mv a0, s1
+;   ld s1, 8(sp)
 ;   addi sp, sp, 0x10
-;   ld s1, -8(sp)
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   ret
+
+function u0:1(i64) -> i64 system_v {
+gv0 = symbol colocated tls u1:0
+
+block0(v0: i64):
+    v1 = tls_value.i64 gv0
+    v2 = iconst.i8 0
+    store notrap v2, v1
+    v3 = iconst.i64 0
+    return v3
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+; block0:
+;   elf_tls_get_addr a0,userextname0
+;   sb zero,0(a0)
+;   li a0,0
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+; block1: ; offset 0x10
+;   auipc a0, 0 ; reloc_external RiscvTlsGdHi20 u1:0 0
+;   mv a0, a0 ; reloc_external RiscvPCRelLo12I func+16 0
+;   auipc ra, 0 ; reloc_external RiscvCallPlt %ElfTlsGetAddr 0
+;   jalr ra
+;   sb zero, 0(a0)
+;   mv a0, zero
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
diff --git a/cranelift/filetests/filetests/isa/riscv64/trunc.clif b/cranelift/filetests/filetests/isa/riscv64/trunc.clif
new file mode 100644
index 000000000000..e554ccf18381
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/trunc.clif
@@ -0,0 +1,77 @@
+test compile precise-output
+set unwind_info=false
+target riscv64
+
+function %f25(f32) -> f32 {
+block0(v0: f32):
+  v1 = trunc v0
+  return v1
+}
+
+; VCode:
+; block0:
+;   lui a2,307200
+;   fmv.w.x fa4,a2
+;   fabs.s fa1,fa0
+;   flt.s a2,fa1,fa4
+;   fcvt.w.s a4,fa0,rtz
+;   fcvt.s.w fa1,a4,rtz
+;   fsgnj.s fa2,fa1,fa0
+;   fmv.w.x fa4,zero
+;   fadd.s fa0,fa0,fa4,rne
+;   select fa0,fa0,fa2##condition=(a2 eq zero)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   lui a2, 0x4b000
+;   fmv.w.x fa4, a2
+;   fabs.s fa1, fa0
+;   flt.s a2, fa1, fa4
+;   fcvt.w.s a4, fa0, rtz ; trap: bad_toint
+;   fcvt.s.w fa1, a4, rtz
+;   fsgnj.s fa2, fa1, fa0
+;   fmv.w.x fa4, zero
+;   fadd.s fa0, fa0, fa4, rne
+;   beqz a2, 8
+;   fmv.d fa0, fa2
+;   ret
+
+function %f26(f64) -> f64 {
+block0(v0: f64):
+  v1 = trunc v0
+  return v1
+}
+
+; VCode:
+; block0:
+;   lui a2,1075
+;   slli a4,a2,40
+;   fmv.d.x fa1,a4
+;   fabs.d fa2,fa0
+;   flt.d a4,fa2,fa1
+;   fcvt.l.d a0,fa0,rtz
+;   fcvt.d.l fa2,a0,rtz
+;   fsgnj.d fa4,fa2,fa0
+;   fmv.d.x fa1,zero
+;   fadd.d fa2,fa0,fa1,rne
+;   select fa0,fa2,fa4##condition=(a4 eq zero)
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   lui a2, 0x433
+;   slli a4, a2, 0x28
+;   fmv.d.x fa1, a4
+;   fabs.d fa2, fa0
+;   flt.d a4, fa2, fa1
+;   fcvt.l.d a0, fa0, rtz ; trap: bad_toint
+;   fcvt.d.l fa2, a0, rtz
+;   fsgnj.d fa4, fa2, fa0
+;   fmv.d.x fa1, zero
+;   fadd.d fa2, fa0, fa1, rne
+;   fmv.d fa0, fa2
+;   beqz a4, 8
+;   fmv.d fa0, fa4
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/umax-zbb.clif b/cranelift/filetests/filetests/isa/riscv64/umax-zbb.clif
new file mode 100644
index 000000000000..583b7f14efef
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/umax-zbb.clif
@@ -0,0 +1,144 @@
+test compile precise-output
+set unwind_info=false
+target riscv64 has_zbb
+
+function %umax_i8(i8, i8) -> i8{
+block0(v0: i8, v1: i8):
+    v2 = umax v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   andi a3,a0,255
+;   andi a5,a1,255
+;   maxu a0,a3,a5
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   andi a3, a0, 0xff
+;   andi a5, a1, 0xff
+;   .byte 0x33, 0xf5, 0xf6, 0x0a
+;   ret
+
+function %umax_i16(i16, i16) -> i16{
+block0(v0: i16, v1: i16):
+    v2 = umax v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   zext.h a3,a0
+;   zext.h a5,a1
+;   maxu a0,a3,a5
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0xbb, 0x46, 0x05, 0x08
+;   .byte 0xbb, 0xc7, 0x05, 0x08
+;   .byte 0x33, 0xf5, 0xf6, 0x0a
+;   ret
+
+function %umax_i32(i32, i32) -> i32{
+block0(v0: i32, v1: i32):
+    v2 = umax v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   slli a3,a0,32
+;   srli a5,a3,32
+;   slli a1,a1,32
+;   srli a3,a1,32
+;   maxu a0,a5,a3
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   slli a3, a0, 0x20
+;   srli a5, a3, 0x20
+;   slli a1, a1, 0x20
+;   srli a3, a1, 0x20
+;   .byte 0x33, 0xf5, 0xd7, 0x0a
+;   ret
+
+function %umax_i64(i64, i64) -> i64{
+block0(v0: i64, v1: i64):
+    v2 = umax v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   maxu a0,a0,a1
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x33, 0x75, 0xb5, 0x0a
+;   ret
+
+function %umax_i128(i128, i128) -> i128{
+block0(v0: i128, v1: i128):
+    v2 = umax v0, v1
+    return v2
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+;   addi sp,sp,-16
+;   sd s1,8(sp)
+;   sd s9,0(sp)
+; block0:
+;   sltu a5,a3,a1
+;   sltu s1,a2,a0
+;   xor a4,a3,a1
+;   mv s9,a1
+;   select a5,s1,a5##condition=(a4 eq zero)
+;   mv a4,a0
+;   select [a0,a1],[a4,s9],[a2,a3]##condition=(a5 ne zero)
+;   ld s1,8(sp)
+;   ld s9,0(sp)
+;   addi sp,sp,16
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+;   addi sp, sp, -0x10
+;   sd s1, 8(sp)
+;   sd s9, 0(sp)
+; block1: ; offset 0x1c
+;   sltu a5, a3, a1
+;   sltu s1, a2, a0
+;   xor a4, a3, a1
+;   mv s9, a1
+;   bnez a4, 8
+;   mv a5, s1
+;   mv a4, a0
+;   mv a0, a4
+;   mv a1, s9
+;   bnez a5, 0xc
+;   mv a0, a2
+;   mv a1, a3
+;   ld s1, 8(sp)
+;   ld s9, 0(sp)
+;   addi sp, sp, 0x10
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/umax.clif b/cranelift/filetests/filetests/isa/riscv64/umax.clif
index a2eb42d2e5e9..4895758b78ef 100644
--- a/cranelift/filetests/filetests/isa/riscv64/umax.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/umax.clif
@@ -19,9 +19,8 @@ block0(v0: i8, v1: i8):
 ; block0: ; offset 0x0
 ;   andi a3, a0, 0xff
 ;   andi a5, a1, 0xff
-;   bgeu a5, a3, 0xc
 ;   mv a0, a3
-;   j 8
+;   bltu a5, a3, 8
 ;   mv a0, a5
 ;   ret
 
@@ -46,9 +45,8 @@ block0(v0: i16, v1: i16):
 ;   srli a5, a3, 0x30
 ;   slli a1, a1, 0x30
 ;   srli a3, a1, 0x30
-;   bgeu a3, a5, 0xc
 ;   mv a0, a5
-;   j 8
+;   bltu a3, a5, 8
 ;   mv a0, a3
 ;   ret
 
@@ -73,9 +71,8 @@ block0(v0: i32, v1: i32):
 ;   srli a5, a3, 0x20
 ;   slli a1, a1, 0x20
 ;   srli a3, a1, 0x20
-;   bgeu a3, a5, 0xc
 ;   mv a0, a5
-;   j 8
+;   bltu a3, a5, 8
 ;   mv a0, a3
 ;   ret
 
@@ -87,12 +84,15 @@ block0(v0: i64, v1: i64):
 
 ; VCode:
 ; block0:
-;   select a0,a0,a1##condition=(a0 ugt a1)
+;   mv a4,a0
+;   select a0,a4,a1##condition=(a4 ugt a1)
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   bltu a1, a0, 8
+;   mv a4, a0
+;   mv a0, a4
+;   bltu a1, a4, 8
 ;   mv a0, a1
 ;   ret
 
@@ -103,22 +103,27 @@ block0(v0: i128, v1: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   sd s3,-8(sp)
-;   add sp,-16
+;   addi sp,sp,-16
+;   sd s1,8(sp)
+;   sd s9,0(sp)
 ; block0:
-;   ugt a5,[a0,a1],[a2,a3]##ty=i128
+;   sltu a5,a3,a1
+;   sltu s1,a2,a0
+;   xor a4,a3,a1
+;   mv s9,a1
+;   select a5,s1,a5##condition=(a4 eq zero)
 ;   mv a4,a0
-;   mv s3,a1
-;   select [a0,a1],[a4,s3],[a2,a3]##condition=(a5 ne zero)
-;   add sp,+16
-;   ld s3,-8(sp)
+;   select [a0,a1],[a4,s9],[a2,a3]##condition=(a5 ne zero)
+;   ld s1,8(sp)
+;   ld s9,0(sp)
+;   addi sp,sp,16
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -127,25 +132,25 @@ block0(v0: i128, v1: i128):
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   sd s3, -8(sp)
 ;   addi sp, sp, -0x10
-; block1: ; offset 0x18
-;   bltu a3, a1, 0xc
-;   bne a1, a3, 0x10
-;   bgeu a2, a0, 0xc
-;   addi a5, zero, 1
-;   j 8
-;   mv a5, zero
+;   sd s1, 8(sp)
+;   sd s9, 0(sp)
+; block1: ; offset 0x1c
+;   sltu a5, a3, a1
+;   sltu s1, a2, a0
+;   xor a4, a3, a1
+;   mv s9, a1
+;   bnez a4, 8
+;   mv a5, s1
 ;   mv a4, a0
-;   mv s3, a1
-;   beqz a5, 0x10
 ;   mv a0, a4
-;   mv a1, s3
-;   j 0xc
+;   mv a1, s9
+;   bnez a5, 0xc
 ;   mv a0, a2
 ;   mv a1, a3
+;   ld s1, 8(sp)
+;   ld s9, 0(sp)
 ;   addi sp, sp, 0x10
-;   ld s3, -8(sp)
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
diff --git a/cranelift/filetests/filetests/isa/riscv64/umin-zbb.clif b/cranelift/filetests/filetests/isa/riscv64/umin-zbb.clif
new file mode 100644
index 000000000000..1aa46c528611
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/umin-zbb.clif
@@ -0,0 +1,144 @@
+test compile precise-output
+set unwind_info=false
+target riscv64 has_zbb
+
+function %umin_i8(i8, i8) -> i8{
+block0(v0: i8, v1: i8):
+    v2 = umin v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   andi a3,a0,255
+;   andi a5,a1,255
+;   minu a0,a3,a5
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   andi a3, a0, 0xff
+;   andi a5, a1, 0xff
+;   .byte 0x33, 0xd5, 0xf6, 0x0a
+;   ret
+
+function %umin_i16(i16, i16) -> i16{
+block0(v0: i16, v1: i16):
+    v2 = umin v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   zext.h a3,a0
+;   zext.h a5,a1
+;   minu a0,a3,a5
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0xbb, 0x46, 0x05, 0x08
+;   .byte 0xbb, 0xc7, 0x05, 0x08
+;   .byte 0x33, 0xd5, 0xf6, 0x0a
+;   ret
+
+function %umin_i32(i32, i32) -> i32{
+block0(v0: i32, v1: i32):
+    v2 = umin v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   slli a3,a0,32
+;   srli a5,a3,32
+;   slli a1,a1,32
+;   srli a3,a1,32
+;   minu a0,a5,a3
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   slli a3, a0, 0x20
+;   srli a5, a3, 0x20
+;   slli a1, a1, 0x20
+;   srli a3, a1, 0x20
+;   .byte 0x33, 0xd5, 0xd7, 0x0a
+;   ret
+
+function %umin_i64(i64, i64) -> i64{
+block0(v0: i64, v1: i64):
+    v2 = umin v0, v1
+    return v2
+}
+
+; VCode:
+; block0:
+;   minu a0,a0,a1
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x33, 0x55, 0xb5, 0x0a
+;   ret
+
+function %umin_i128(i128, i128) -> i128{
+block0(v0: i128, v1: i128):
+    v2 = umin v0, v1
+    return v2
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+;   addi sp,sp,-16
+;   sd s1,8(sp)
+;   sd s9,0(sp)
+; block0:
+;   sltu a5,a1,a3
+;   sltu s1,a0,a2
+;   xor a4,a1,a3
+;   mv s9,a1
+;   select a5,s1,a5##condition=(a4 eq zero)
+;   mv a4,a0
+;   select [a0,a1],[a4,s9],[a2,a3]##condition=(a5 ne zero)
+;   ld s1,8(sp)
+;   ld s9,0(sp)
+;   addi sp,sp,16
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+;   addi sp, sp, -0x10
+;   sd s1, 8(sp)
+;   sd s9, 0(sp)
+; block1: ; offset 0x1c
+;   sltu a5, a1, a3
+;   sltu s1, a0, a2
+;   xor a4, a1, a3
+;   mv s9, a1
+;   bnez a4, 8
+;   mv a5, s1
+;   mv a4, a0
+;   mv a0, a4
+;   mv a1, s9
+;   bnez a5, 0xc
+;   mv a0, a2
+;   mv a1, a3
+;   ld s1, 8(sp)
+;   ld s9, 0(sp)
+;   addi sp, sp, 0x10
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/umin.clif b/cranelift/filetests/filetests/isa/riscv64/umin.clif
index 74eb80d45c56..fb99352d36bb 100644
--- a/cranelift/filetests/filetests/isa/riscv64/umin.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/umin.clif
@@ -19,9 +19,8 @@ block0(v0: i8, v1: i8):
 ; block0: ; offset 0x0
 ;   andi a3, a0, 0xff
 ;   andi a5, a1, 0xff
-;   bgeu a3, a5, 0xc
 ;   mv a0, a3
-;   j 8
+;   bltu a3, a5, 8
 ;   mv a0, a5
 ;   ret
 
@@ -46,9 +45,8 @@ block0(v0: i16, v1: i16):
 ;   srli a5, a3, 0x30
 ;   slli a1, a1, 0x30
 ;   srli a3, a1, 0x30
-;   bgeu a5, a3, 0xc
 ;   mv a0, a5
-;   j 8
+;   bltu a5, a3, 8
 ;   mv a0, a3
 ;   ret
 
@@ -73,9 +71,8 @@ block0(v0: i32, v1: i32):
 ;   srli a5, a3, 0x20
 ;   slli a1, a1, 0x20
 ;   srli a3, a1, 0x20
-;   bgeu a5, a3, 0xc
 ;   mv a0, a5
-;   j 8
+;   bltu a5, a3, 8
 ;   mv a0, a3
 ;   ret
 
@@ -87,12 +84,15 @@ block0(v0: i64, v1: i64):
 
 ; VCode:
 ; block0:
-;   select a0,a0,a1##condition=(a0 ult a1)
+;   mv a4,a0
+;   select a0,a4,a1##condition=(a4 ult a1)
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   bltu a0, a1, 8
+;   mv a4, a0
+;   mv a0, a4
+;   bltu a4, a1, 8
 ;   mv a0, a1
 ;   ret
 
@@ -103,22 +103,27 @@ block0(v0: i128, v1: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   sd s3,-8(sp)
-;   add sp,-16
+;   addi sp,sp,-16
+;   sd s1,8(sp)
+;   sd s9,0(sp)
 ; block0:
-;   ult a5,[a0,a1],[a2,a3]##ty=i128
+;   sltu a5,a1,a3
+;   sltu s1,a0,a2
+;   xor a4,a1,a3
+;   mv s9,a1
+;   select a5,s1,a5##condition=(a4 eq zero)
 ;   mv a4,a0
-;   mv s3,a1
-;   select [a0,a1],[a4,s3],[a2,a3]##condition=(a5 ne zero)
-;   add sp,+16
-;   ld s3,-8(sp)
+;   select [a0,a1],[a4,s9],[a2,a3]##condition=(a5 ne zero)
+;   ld s1,8(sp)
+;   ld s9,0(sp)
+;   addi sp,sp,16
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -127,25 +132,25 @@ block0(v0: i128, v1: i128):
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   sd s3, -8(sp)
 ;   addi sp, sp, -0x10
-; block1: ; offset 0x18
-;   bltu a1, a3, 0xc
-;   bne a1, a3, 0x10
-;   bgeu a0, a2, 0xc
-;   addi a5, zero, 1
-;   j 8
-;   mv a5, zero
+;   sd s1, 8(sp)
+;   sd s9, 0(sp)
+; block1: ; offset 0x1c
+;   sltu a5, a1, a3
+;   sltu s1, a0, a2
+;   xor a4, a1, a3
+;   mv s9, a1
+;   bnez a4, 8
+;   mv a5, s1
 ;   mv a4, a0
-;   mv s3, a1
-;   beqz a5, 0x10
 ;   mv a0, a4
-;   mv a1, s3
-;   j 0xc
+;   mv a1, s9
+;   bnez a5, 0xc
 ;   mv a0, a2
 ;   mv a1, a3
+;   ld s1, 8(sp)
+;   ld s9, 0(sp)
 ;   addi sp, sp, 0x10
-;   ld s3, -8(sp)
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
diff --git a/cranelift/filetests/filetests/isa/riscv64/user_stack_maps.clif b/cranelift/filetests/filetests/isa/riscv64/user_stack_maps.clif
new file mode 100644
index 000000000000..4b18ae8abd3e
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/user_stack_maps.clif
@@ -0,0 +1,236 @@
+test compile precise-output
+set unwind_info=false
+set enable_probestack=false
+target riscv64
+
+function %foo() system_v {
+    ss0 = explicit_slot 12, align = 4
+    sig0 = (i32) system_v
+    fn0 = colocated u0:0 sig0
+
+block0:
+    v0 = iconst.i32 0
+    v1 = iconst.i32 1
+    v2 = iconst.i32 2
+    v3 = iconst.i32 3
+
+    stack_store v0, ss0
+    stack_store v1, ss0+4
+    stack_store v2, ss0+8
+    call fn0(v0), stack_map=[i32 @ ss0+0, i32 @ ss0+4, i32 @ ss0+8]
+
+    stack_store v1, ss0
+    stack_store v2, ss0+4
+    call fn0(v0), stack_map=[i32 @ ss0+0, i32 @ ss0+4]
+
+    stack_store v2, ss0
+    call fn0(v1), stack_map=[i32 @ ss0+0]
+
+    call fn0(v2)
+
+    return
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+;   addi sp,sp,-48
+;   sd s1,40(sp)
+;   sd s2,32(sp)
+;   sd s3,24(sp)
+; block0:
+;   li s3,0
+;   li s1,1
+;   li s2,2
+;   sw zero,0(slot)
+;   sw s1,4(slot)
+;   sw s2,8(slot)
+;   mv a0,s3
+;   call userextname0
+;   ; UserStackMap { by_type: [(types::I32, CompoundBitSet {0, 4, 8})], sp_to_sized_stack_slots: None }
+;   sw s1,0(slot)
+;   sw s2,4(slot)
+;   mv a0,s3
+;   call userextname0
+;   ; UserStackMap { by_type: [(types::I32, CompoundBitSet {0, 4})], sp_to_sized_stack_slots: None }
+;   sw s2,0(slot)
+;   mv a0,s1
+;   call userextname0
+;   ; UserStackMap { by_type: [(types::I32, CompoundBitSet {0})], sp_to_sized_stack_slots: None }
+;   mv a0,s2
+;   call userextname0
+;   ld s1,40(sp)
+;   ld s2,32(sp)
+;   ld s3,24(sp)
+;   addi sp,sp,48
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+;   addi sp, sp, -0x30
+;   sd s1, 0x28(sp)
+;   sd s2, 0x20(sp)
+;   sd s3, 0x18(sp)
+; block1: ; offset 0x20
+;   mv s3, zero
+;   addi s1, zero, 1
+;   addi s2, zero, 2
+;   sw zero, 0(sp)
+;   sw s1, 4(sp)
+;   sw s2, 8(sp)
+;   mv a0, s3
+;   auipc ra, 0 ; reloc_external RiscvCallPlt u0:0 0
+;   jalr ra
+;   sw s1, 0(sp)
+;   sw s2, 4(sp)
+;   mv a0, s3
+;   auipc ra, 0 ; reloc_external RiscvCallPlt u0:0 0
+;   jalr ra
+;   sw s2, 0(sp)
+;   mv a0, s1
+;   auipc ra, 0 ; reloc_external RiscvCallPlt u0:0 0
+;   jalr ra
+;   mv a0, s2
+;   auipc ra, 0 ; reloc_external RiscvCallPlt u0:0 0
+;   jalr ra
+;   ld s1, 0x28(sp)
+;   ld s2, 0x20(sp)
+;   ld s3, 0x18(sp)
+;   addi sp, sp, 0x30
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   ret
+
+function %different_types(i8, i16, i32, i64, f32, f64) -> i8, i16, i32, i64, f32, f64 {
+    ss0 = explicit_slot 1
+    ss1 = explicit_slot 2, align = 2
+    ss2 = explicit_slot 8, align = 4
+    ss3 = explicit_slot 16, align = 8
+    ss4 = explicit_slot 48, align = 16
+    sig0 = () system_v
+    fn0 = colocated u0:0 sig0
+
+block0(v0: i8, v1: i16, v2: i32, v3: i64, v4: f32, v5: f64):
+    stack_store v0, ss0
+    stack_store v1, ss1
+    stack_store v2, ss2
+    stack_store v4, ss2+4
+    stack_store v3, ss3
+    stack_store v5, ss3+8
+    call fn0(), stack_map=[i8 @ ss0+0, i16 @ ss1+0, i32 @ ss2+0, f32 @ ss2+4, i64 @ ss3+0, f64 @ ss3+8]
+    return v0, v1, v2, v3, v4, v5
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+;   addi sp,sp,-160
+;   sd s1,152(sp)
+;   sd s2,144(sp)
+;   sd s3,136(sp)
+;   sd s4,128(sp)
+;   sd s9,120(sp)
+;   fsd fs0,112(sp)
+;   fsd fs2,104(sp)
+; block0:
+;   mv s2,a4
+;   sb a0,0(slot)
+;   mv s1,a0
+;   sh a1,8(slot)
+;   mv s9,a1
+;   sw a2,16(slot)
+;   mv s4,a2
+;   fsw fa0,20(slot)
+;   fmv.d fs2,fa0
+;   sd a3,24(slot)
+;   mv s3,a3
+;   fsd fa1,32(slot)
+;   fmv.d fs0,fa1
+;   call userextname0
+;   ; UserStackMap { by_type: [(types::I8, CompoundBitSet {0}), (types::I16, CompoundBitSet {8}), (types::I32, CompoundBitSet {16}), (types::F32, CompoundBitSet {20}), (types::I64, CompoundBitSet {24}), (types::F64, CompoundBitSet {32})], sp_to_sized_stack_slots: None }
+;   mv a2,s4
+;   mv a4,s2
+;   sw a2,0(a4)
+;   mv a3,s3
+;   sd a3,8(a4)
+;   mv a0,s1
+;   mv a1,s9
+;   fmv.d fa0,fs2
+;   fmv.d fa1,fs0
+;   ld s1,152(sp)
+;   ld s2,144(sp)
+;   ld s3,136(sp)
+;   ld s4,128(sp)
+;   ld s9,120(sp)
+;   fld fs0,112(sp)
+;   fld fs2,104(sp)
+;   addi sp,sp,160
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+;   addi sp, sp, -0xa0
+;   sd s1, 0x98(sp)
+;   sd s2, 0x90(sp)
+;   sd s3, 0x88(sp)
+;   sd s4, 0x80(sp)
+;   sd s9, 0x78(sp)
+;   fsd fs0, 0x70(sp)
+;   fsd fs2, 0x68(sp)
+; block1: ; offset 0x30
+;   mv s2, a4
+;   sb a0, 0(sp)
+;   mv s1, a0
+;   sh a1, 8(sp)
+;   mv s9, a1
+;   sw a2, 0x10(sp)
+;   mv s4, a2
+;   fsw fa0, 0x14(sp)
+;   fmv.d fs2, fa0
+;   sd a3, 0x18(sp)
+;   mv s3, a3
+;   fsd fa1, 0x20(sp)
+;   fmv.d fs0, fa1
+;   auipc ra, 0 ; reloc_external RiscvCallPlt u0:0 0
+;   jalr ra
+;   mv a2, s4
+;   mv a4, s2
+;   sw a2, 0(a4)
+;   mv a3, s3
+;   sd a3, 8(a4)
+;   mv a0, s1
+;   mv a1, s9
+;   fmv.d fa0, fs2
+;   fmv.d fa1, fs0
+;   ld s1, 0x98(sp)
+;   ld s2, 0x90(sp)
+;   ld s3, 0x88(sp)
+;   ld s4, 0x80(sp)
+;   ld s9, 0x78(sp)
+;   fld fs0, 0x70(sp)
+;   fld fs2, 0x68(sp)
+;   addi sp, sp, 0xa0
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/ushr-const.clif b/cranelift/filetests/filetests/isa/riscv64/ushr-const.clif
index 5851a974b373..309df79c26fb 100644
--- a/cranelift/filetests/filetests/isa/riscv64/ushr-const.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/ushr-const.clif
@@ -407,19 +407,17 @@ block0(v0: i128):
 ;   addi a2, zero, 0x40
 ;   sub a2, a2, a4
 ;   sll a5, a1, a2
-;   bnez a4, 0xc
 ;   mv a2, zero
-;   j 8
+;   beqz a4, 8
 ;   mv a2, a5
 ;   srl a5, a0, a4
 ;   or a5, a2, a5
 ;   addi t0, zero, 0x40
 ;   srl a2, a1, a4
 ;   andi a4, a3, 0x7f
-;   bltu a4, t0, 0x10
 ;   mv a0, a2
 ;   mv a1, zero
-;   j 0xc
+;   bgeu a4, t0, 0xc
 ;   mv a0, a5
 ;   mv a1, a2
 ;   ret
@@ -454,19 +452,17 @@ block0(v0: i128):
 ;   addi a2, zero, 0x40
 ;   sub a2, a2, a4
 ;   sll a5, a1, a2
-;   bnez a4, 0xc
 ;   mv a2, zero
-;   j 8
+;   beqz a4, 8
 ;   mv a2, a5
 ;   srl a5, a0, a4
 ;   or a5, a2, a5
 ;   addi t0, zero, 0x40
 ;   srl a2, a1, a4
 ;   andi a4, a3, 0x7f
-;   bltu a4, t0, 0x10
 ;   mv a0, a2
 ;   mv a1, zero
-;   j 0xc
+;   bgeu a4, t0, 0xc
 ;   mv a0, a5
 ;   mv a1, a2
 ;   ret
@@ -501,19 +497,17 @@ block0(v0: i128):
 ;   addi a2, zero, 0x40
 ;   sub a2, a2, a4
 ;   sll a5, a1, a2
-;   bnez a4, 0xc
 ;   mv a2, zero
-;   j 8
+;   beqz a4, 8
 ;   mv a2, a5
 ;   srl a5, a0, a4
 ;   or a5, a2, a5
 ;   addi t0, zero, 0x40
 ;   srl a2, a1, a4
 ;   andi a4, a3, 0x7f
-;   bltu a4, t0, 0x10
 ;   mv a0, a2
 ;   mv a1, zero
-;   j 0xc
+;   bgeu a4, t0, 0xc
 ;   mv a0, a5
 ;   mv a1, a2
 ;   ret
@@ -548,19 +542,17 @@ block0(v0: i128):
 ;   addi a2, zero, 0x40
 ;   sub a2, a2, a4
 ;   sll a5, a1, a2
-;   bnez a4, 0xc
 ;   mv a2, zero
-;   j 8
+;   beqz a4, 8
 ;   mv a2, a5
 ;   srl a5, a0, a4
 ;   or a5, a2, a5
 ;   addi t0, zero, 0x40
 ;   srl a2, a1, a4
 ;   andi a4, a3, 0x7f
-;   bltu a4, t0, 0x10
 ;   mv a0, a2
 ;   mv a1, zero
-;   j 0xc
+;   bgeu a4, t0, 0xc
 ;   mv a0, a5
 ;   mv a1, a2
 ;   ret
@@ -574,12 +566,12 @@ block0(v0: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   sd s11,-8(sp)
-;   add sp,-16
+;   addi sp,sp,-16
+;   sd s11,8(sp)
 ; block0:
 ;   li a4,5
 ;   li a5,0
@@ -594,11 +586,11 @@ block0(v0: i128):
 ;   srl a3,a1,a5
 ;   andi a5,a4,127
 ;   select [a0,a1],[a3,zero],[s11,a3]##condition=(a5 uge a2)
-;   add sp,+16
-;   ld s11,-8(sp)
+;   ld s11,8(sp)
+;   addi sp,sp,16
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -607,8 +599,8 @@ block0(v0: i128):
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   sd s11, -8(sp)
 ;   addi sp, sp, -0x10
+;   sd s11, 8(sp)
 ; block1: ; offset 0x18
 ;   addi a4, zero, 5
 ;   mv a5, zero
@@ -623,14 +615,13 @@ block0(v0: i128):
 ;   addi a2, zero, 0x40
 ;   srl a3, a1, a5
 ;   andi a5, a4, 0x7f
-;   bltu a5, a2, 0x10
 ;   mv a0, a3
 ;   mv a1, zero
-;   j 0xc
+;   bgeu a5, a2, 0xc
 ;   mv a0, s11
 ;   mv a1, a3
+;   ld s11, 8(sp)
 ;   addi sp, sp, 0x10
-;   ld s11, -8(sp)
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
diff --git a/cranelift/filetests/filetests/isa/riscv64/ushr.clif b/cranelift/filetests/filetests/isa/riscv64/ushr.clif
index a9faa81c617e..2332389c33ef 100644
--- a/cranelift/filetests/filetests/isa/riscv64/ushr.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/ushr.clif
@@ -400,19 +400,17 @@ block0(v0: i128, v1: i8):
 ;   addi a3, zero, 0x40
 ;   sub a3, a3, a4
 ;   sll a5, a1, a3
-;   bnez a4, 0xc
 ;   mv a3, zero
-;   j 8
+;   beqz a4, 8
 ;   mv a3, a5
 ;   srl a5, a0, a4
 ;   or a5, a3, a5
 ;   addi t0, zero, 0x40
 ;   srl a3, a1, a4
 ;   andi a4, a2, 0x7f
-;   bltu a4, t0, 0x10
 ;   mv a0, a3
 ;   mv a1, zero
-;   j 0xc
+;   bgeu a4, t0, 0xc
 ;   mv a0, a5
 ;   mv a1, a3
 ;   ret
@@ -444,19 +442,17 @@ block0(v0: i128, v1: i16):
 ;   addi a3, zero, 0x40
 ;   sub a3, a3, a4
 ;   sll a5, a1, a3
-;   bnez a4, 0xc
 ;   mv a3, zero
-;   j 8
+;   beqz a4, 8
 ;   mv a3, a5
 ;   srl a5, a0, a4
 ;   or a5, a3, a5
 ;   addi t0, zero, 0x40
 ;   srl a3, a1, a4
 ;   andi a4, a2, 0x7f
-;   bltu a4, t0, 0x10
 ;   mv a0, a3
 ;   mv a1, zero
-;   j 0xc
+;   bgeu a4, t0, 0xc
 ;   mv a0, a5
 ;   mv a1, a3
 ;   ret
@@ -488,19 +484,17 @@ block0(v0: i128, v1: i32):
 ;   addi a3, zero, 0x40
 ;   sub a3, a3, a4
 ;   sll a5, a1, a3
-;   bnez a4, 0xc
 ;   mv a3, zero
-;   j 8
+;   beqz a4, 8
 ;   mv a3, a5
 ;   srl a5, a0, a4
 ;   or a5, a3, a5
 ;   addi t0, zero, 0x40
 ;   srl a3, a1, a4
 ;   andi a4, a2, 0x7f
-;   bltu a4, t0, 0x10
 ;   mv a0, a3
 ;   mv a1, zero
-;   j 0xc
+;   bgeu a4, t0, 0xc
 ;   mv a0, a5
 ;   mv a1, a3
 ;   ret
@@ -532,19 +526,17 @@ block0(v0: i128, v1: i64):
 ;   addi a3, zero, 0x40
 ;   sub a3, a3, a4
 ;   sll a5, a1, a3
-;   bnez a4, 0xc
 ;   mv a3, zero
-;   j 8
+;   beqz a4, 8
 ;   mv a3, a5
 ;   srl a5, a0, a4
 ;   or a5, a3, a5
 ;   addi t0, zero, 0x40
 ;   srl a3, a1, a4
 ;   andi a4, a2, 0x7f
-;   bltu a4, t0, 0x10
 ;   mv a0, a3
 ;   mv a1, zero
-;   j 0xc
+;   bgeu a4, t0, 0xc
 ;   mv a0, a5
 ;   mv a1, a3
 ;   ret
@@ -556,12 +548,12 @@ block0(v0: i128, v1: i128):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   sd s11,-8(sp)
-;   add sp,-16
+;   addi sp,sp,-16
+;   sd s11,8(sp)
 ; block0:
 ;   andi a5,a2,63
 ;   li a3,64
@@ -574,11 +566,11 @@ block0(v0: i128, v1: i128):
 ;   srl a4,a1,a5
 ;   andi a5,a2,127
 ;   select [a0,a1],[a4,zero],[s11,a4]##condition=(a5 uge a3)
-;   add sp,+16
-;   ld s11,-8(sp)
+;   ld s11,8(sp)
+;   addi sp,sp,16
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -587,8 +579,8 @@ block0(v0: i128, v1: i128):
 ;   sd ra, 8(sp)
 ;   sd s0, 0(sp)
 ;   mv s0, sp
-;   sd s11, -8(sp)
 ;   addi sp, sp, -0x10
+;   sd s11, 8(sp)
 ; block1: ; offset 0x18
 ;   andi a5, a2, 0x3f
 ;   addi a3, zero, 0x40
@@ -601,14 +593,13 @@ block0(v0: i128, v1: i128):
 ;   addi a3, zero, 0x40
 ;   srl a4, a1, a5
 ;   andi a5, a2, 0x7f
-;   bltu a5, a3, 0x10
 ;   mv a0, a4
 ;   mv a1, zero
-;   j 0xc
+;   bgeu a5, a3, 0xc
 ;   mv a0, s11
 ;   mv a1, a4
+;   ld s11, 8(sp)
 ;   addi sp, sp, 0x10
-;   ld s11, -8(sp)
 ;   ld ra, 8(sp)
 ;   ld s0, 0(sp)
 ;   addi sp, sp, 0x10
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index d72cfed5a124..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   slli a3,a0,32
-;;   srli a4,a3,32
-;;   ld a3,8(a2)
-;;   addi a3,a3,-4
-;;   bgtu a4,a3,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a5,0(a2)
-;;   add a4,a5,a4
-;;   sw a1,0(a4)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   slli a2,a0,32
-;;   srli a4,a2,32
-;;   ld a3,8(a1)
-;;   addi a3,a3,-4
-;;   bgtu a4,a3,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a5,0(a1)
-;;   add a4,a5,a4
-;;   lw a0,0(a4)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index f877835d280c..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   slli a4,a0,32
-;;   srli a0,a4,32
-;;   ld a5,8(a2)
-;;   lui a4,-1
-;;   addi a3,a4,-4
-;;   add a5,a5,a3
-;;   bgtu a0,a5,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a2,0(a2)
-;;   add a0,a2,a0
-;;   sw a1,4096(a0)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   slli a4,a0,32
-;;   srli a0,a4,32
-;;   ld a5,8(a1)
-;;   lui a4,-1
-;;   addi a2,a4,-4
-;;   add a5,a5,a2
-;;   bgtu a0,a5,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a1,0(a1)
-;;   add a0,a1,a0
-;;   lw a0,4096(a0)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 16a262f3b76f..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,88 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   slli a3,a0,32
-;;   srli a4,a3,32
-;;   lui a3,262140
-;;   addi a3,a3,1
-;;   slli a5,a3,2
-;;   add a3,a4,a5
-;;   trap_if heap_oob##(a3 ult a4)
-;;   ld a5,8(a2)
-;;   bgtu a3,a5,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a5,0(a2)
-;;   add a5,a5,a4
-;;   lui a4,65535
-;;   slli a0,a4,4
-;;   add a5,a5,a0
-;;   sw a1,0(a5)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   slli a2,a0,32
-;;   srli a4,a2,32
-;;   lui a2,262140
-;;   addi a3,a2,1
-;;   slli a5,a3,2
-;;   add a3,a4,a5
-;;   trap_if heap_oob##(a3 ult a4)
-;;   ld a5,8(a1)
-;;   bgtu a3,a5,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a5,0(a1)
-;;   add a5,a5,a4
-;;   lui a4,65535
-;;   slli a0,a4,4
-;;   add a5,a5,a0
-;;   lw a0,0(a5)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 9a41cc69378c..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   slli a3,a0,32
-;;   srli a3,a3,32
-;;   ld a4,8(a2)
-;;   bgeu a3,a4,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a4,0(a2)
-;;   add a3,a4,a3
-;;   sb a1,0(a3)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   slli a2,a0,32
-;;   srli a3,a2,32
-;;   ld a2,8(a1)
-;;   bgeu a3,a2,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a4,0(a1)
-;;   add a3,a4,a3
-;;   lbu a0,0(a3)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index f7870c3feb68..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   slli a4,a0,32
-;;   srli a0,a4,32
-;;   ld a5,8(a2)
-;;   lui a4,-1
-;;   addi a3,a4,-1
-;;   add a5,a5,a3
-;;   bgtu a0,a5,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a2,0(a2)
-;;   add a0,a2,a0
-;;   sb a1,4096(a0)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   slli a4,a0,32
-;;   srli a0,a4,32
-;;   ld a5,8(a1)
-;;   lui a4,-1
-;;   addi a2,a4,-1
-;;   add a5,a5,a2
-;;   bgtu a0,a5,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a1,0(a1)
-;;   add a0,a1,a0
-;;   lbu a0,4096(a0)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 43443094f4b7..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,84 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   slli a0,a0,32
-;;   srli a3,a0,32
-;;   ld a4,[const(0)]
-;;   add a4,a3,a4
-;;   trap_if heap_oob##(a4 ult a3)
-;;   ld a5,8(a2)
-;;   bgtu a4,a5,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a4,0(a2)
-;;   add a3,a4,a3
-;;   lui a2,65535
-;;   slli a4,a2,4
-;;   add a3,a3,a4
-;;   sb a1,0(a3)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   slli a0,a0,32
-;;   srli a2,a0,32
-;;   ld a3,[const(0)]
-;;   add a3,a2,a3
-;;   trap_if heap_oob##(a3 ult a2)
-;;   ld a4,8(a1)
-;;   bgtu a3,a4,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a3,0(a1)
-;;   add a3,a3,a2
-;;   lui a2,65535
-;;   slli a4,a2,4
-;;   add a3,a3,a4
-;;   lbu a0,0(a3)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index b5aa9400304d..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,82 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   slli a4,a0,32
-;;   srli a0,a4,32
-;;   ld a5,8(a2)
-;;   addi a5,a5,-4
-;;   ugt a3,a0,a5##ty=i64
-;;   ld a5,0(a2)
-;;   add a5,a5,a0
-;;   li a0,0
-;;   sltu a2,zero,a3
-;;   sub a2,zero,a2
-;;   and a4,a0,a2
-;;   not a0,a2
-;;   and a2,a5,a0
-;;   or a4,a4,a2
-;;   sw a1,0(a4)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   slli a4,a0,32
-;;   srli a0,a4,32
-;;   ld a5,8(a1)
-;;   addi a5,a5,-4
-;;   ugt a2,a0,a5##ty=i64
-;;   ld a5,0(a1)
-;;   add a5,a5,a0
-;;   li a0,0
-;;   sltu a1,zero,a2
-;;   sub a2,zero,a1
-;;   and a4,a0,a2
-;;   not a0,a2
-;;   and a2,a5,a0
-;;   or a4,a4,a2
-;;   lw a0,0(a4)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 665af0e6def1..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,90 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   slli a3,a0,32
-;;   srli a4,a3,32
-;;   ld a3,8(a2)
-;;   lui a5,-1
-;;   addi a5,a5,-4
-;;   add a3,a3,a5
-;;   ugt a3,a4,a3##ty=i64
-;;   ld a5,0(a2)
-;;   add a4,a5,a4
-;;   lui a5,1
-;;   add a4,a4,a5
-;;   li a5,0
-;;   sltu a0,zero,a3
-;;   sub a0,zero,a0
-;;   and a2,a5,a0
-;;   not a5,a0
-;;   and a0,a4,a5
-;;   or a2,a2,a0
-;;   sw a1,0(a2)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   slli a2,a0,32
-;;   srli a4,a2,32
-;;   ld a3,8(a1)
-;;   lui a2,-1
-;;   addi a5,a2,-4
-;;   add a3,a3,a5
-;;   ugt a3,a4,a3##ty=i64
-;;   ld a5,0(a1)
-;;   add a4,a5,a4
-;;   lui a5,1
-;;   add a4,a4,a5
-;;   li a5,0
-;;   sltu a0,zero,a3
-;;   sub a0,zero,a0
-;;   and a2,a5,a0
-;;   not a5,a0
-;;   and a0,a4,a5
-;;   or a2,a2,a0
-;;   lw a0,0(a2)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 8e2d5c2cc84a..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,96 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   slli a4,a0,32
-;;   srli a0,a4,32
-;;   lui a3,262140
-;;   addi a5,a3,1
-;;   slli a3,a5,2
-;;   add a5,a0,a3
-;;   trap_if heap_oob##(a5 ult a0)
-;;   ld a3,8(a2)
-;;   ugt a3,a5,a3##ty=i64
-;;   ld a2,0(a2)
-;;   add a0,a2,a0
-;;   lui a5,65535
-;;   slli a2,a5,4
-;;   add a0,a0,a2
-;;   li a2,0
-;;   sltu a3,zero,a3
-;;   sub a3,zero,a3
-;;   and a5,a2,a3
-;;   not a2,a3
-;;   and a3,a0,a2
-;;   or a5,a5,a3
-;;   sw a1,0(a5)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   slli a4,a0,32
-;;   srli a0,a4,32
-;;   lui a3,262140
-;;   addi a5,a3,1
-;;   slli a2,a5,2
-;;   add a5,a0,a2
-;;   trap_if heap_oob##(a5 ult a0)
-;;   ld a2,8(a1)
-;;   ugt a2,a5,a2##ty=i64
-;;   ld a1,0(a1)
-;;   add a0,a1,a0
-;;   lui a5,65535
-;;   slli a1,a5,4
-;;   add a0,a0,a1
-;;   li a1,0
-;;   sltu a2,zero,a2
-;;   sub a3,zero,a2
-;;   and a5,a1,a3
-;;   not a1,a3
-;;   and a3,a0,a1
-;;   or a5,a5,a3
-;;   lw a0,0(a5)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index ec33de9fcad6..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   slli a3,a0,32
-;;   srli a5,a3,32
-;;   ld a4,8(a2)
-;;   uge a0,a5,a4##ty=i64
-;;   ld a4,0(a2)
-;;   add a4,a4,a5
-;;   li a5,0
-;;   sltu a0,zero,a0
-;;   sub a2,zero,a0
-;;   and a3,a5,a2
-;;   not a5,a2
-;;   and a2,a4,a5
-;;   or a3,a3,a2
-;;   sb a1,0(a3)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   slli a3,a0,32
-;;   srli a5,a3,32
-;;   ld a4,8(a1)
-;;   uge a0,a5,a4##ty=i64
-;;   ld a4,0(a1)
-;;   add a4,a4,a5
-;;   li a5,0
-;;   sltu a0,zero,a0
-;;   sub a1,zero,a0
-;;   and a3,a5,a1
-;;   not a5,a1
-;;   and a1,a4,a5
-;;   or a3,a3,a1
-;;   lbu a0,0(a3)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 19db59b51168..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,90 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   slli a3,a0,32
-;;   srli a4,a3,32
-;;   ld a3,8(a2)
-;;   lui a5,-1
-;;   addi a5,a5,-1
-;;   add a3,a3,a5
-;;   ugt a3,a4,a3##ty=i64
-;;   ld a5,0(a2)
-;;   add a4,a5,a4
-;;   lui a5,1
-;;   add a4,a4,a5
-;;   li a5,0
-;;   sltu a0,zero,a3
-;;   sub a0,zero,a0
-;;   and a2,a5,a0
-;;   not a5,a0
-;;   and a0,a4,a5
-;;   or a2,a2,a0
-;;   sb a1,0(a2)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   slli a2,a0,32
-;;   srli a4,a2,32
-;;   ld a3,8(a1)
-;;   lui a2,-1
-;;   addi a5,a2,-1
-;;   add a3,a3,a5
-;;   ugt a3,a4,a3##ty=i64
-;;   ld a5,0(a1)
-;;   add a4,a5,a4
-;;   lui a5,1
-;;   add a4,a4,a5
-;;   li a5,0
-;;   sltu a0,zero,a3
-;;   sub a0,zero,a0
-;;   and a2,a5,a0
-;;   not a5,a0
-;;   and a0,a4,a5
-;;   or a2,a2,a0
-;;   lbu a0,0(a2)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index bc39f65d29da..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,92 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   slli a3,a0,32
-;;   srli a4,a3,32
-;;   ld a3,[const(0)]
-;;   add a3,a4,a3
-;;   trap_if heap_oob##(a3 ult a4)
-;;   ld a5,8(a2)
-;;   ugt a5,a3,a5##ty=i64
-;;   ld a0,0(a2)
-;;   add a4,a0,a4
-;;   lui a3,65535
-;;   slli a0,a3,4
-;;   add a4,a4,a0
-;;   li a0,0
-;;   sltu a5,zero,a5
-;;   sub a2,zero,a5
-;;   and a3,a0,a2
-;;   not a5,a2
-;;   and a2,a4,a5
-;;   or a3,a3,a2
-;;   sb a1,0(a3)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   slli a2,a0,32
-;;   srli a4,a2,32
-;;   ld a3,[const(0)]
-;;   add a3,a4,a3
-;;   trap_if heap_oob##(a3 ult a4)
-;;   ld a5,8(a1)
-;;   ugt a5,a3,a5##ty=i64
-;;   ld a0,0(a1)
-;;   add a4,a0,a4
-;;   lui a3,65535
-;;   slli a0,a3,4
-;;   add a4,a4,a0
-;;   li a0,0
-;;   sltu a5,zero,a5
-;;   sub a1,zero,a5
-;;   and a3,a0,a1
-;;   not a5,a1
-;;   and a1,a4,a5
-;;   or a3,a3,a1
-;;   lbu a0,0(a3)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index d30b15cce958..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   slli a3,a0,32
-;;   srli a3,a3,32
-;;   ld a4,8(a2)
-;;   bgtu a3,a4,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a4,0(a2)
-;;   add a3,a4,a3
-;;   sw a1,0(a3)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   slli a2,a0,32
-;;   srli a3,a2,32
-;;   ld a2,8(a1)
-;;   bgtu a3,a2,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a4,0(a1)
-;;   add a3,a4,a3
-;;   lw a0,0(a3)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index fa671f933dab..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   slli a3,a0,32
-;;   srli a3,a3,32
-;;   ld a4,8(a2)
-;;   bgtu a3,a4,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a4,0(a2)
-;;   add a3,a4,a3
-;;   sw a1,4096(a3)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   slli a2,a0,32
-;;   srli a3,a2,32
-;;   ld a2,8(a1)
-;;   bgtu a3,a2,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a4,0(a1)
-;;   add a3,a4,a3
-;;   lw a0,4096(a3)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 2abf0fb9a8ba..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   slli a4,a0,32
-;;   srli a0,a4,32
-;;   ld a5,8(a2)
-;;   bgtu a0,a5,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a2,0(a2)
-;;   add a0,a2,a0
-;;   lui a5,65535
-;;   slli a2,a5,4
-;;   add a0,a0,a2
-;;   sw a1,0(a0)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   slli a4,a0,32
-;;   srli a0,a4,32
-;;   ld a5,8(a1)
-;;   bgtu a0,a5,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a1,0(a1)
-;;   add a0,a1,a0
-;;   lui a5,65535
-;;   slli a1,a5,4
-;;   add a0,a0,a1
-;;   lw a0,0(a0)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 0137cdbbbc0c..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   slli a3,a0,32
-;;   srli a3,a3,32
-;;   ld a4,8(a2)
-;;   bgeu a3,a4,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a4,0(a2)
-;;   add a3,a4,a3
-;;   sb a1,0(a3)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   slli a2,a0,32
-;;   srli a3,a2,32
-;;   ld a2,8(a1)
-;;   bgeu a3,a2,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a4,0(a1)
-;;   add a3,a4,a3
-;;   lbu a0,0(a3)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 3e9a20ee72d1..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   slli a3,a0,32
-;;   srli a3,a3,32
-;;   ld a4,8(a2)
-;;   bgtu a3,a4,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a4,0(a2)
-;;   add a3,a4,a3
-;;   sb a1,4096(a3)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   slli a2,a0,32
-;;   srli a3,a2,32
-;;   ld a2,8(a1)
-;;   bgtu a3,a2,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a4,0(a1)
-;;   add a3,a4,a3
-;;   lbu a0,4096(a3)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 3064723e08ae..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   slli a4,a0,32
-;;   srli a0,a4,32
-;;   ld a5,8(a2)
-;;   bgtu a0,a5,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a2,0(a2)
-;;   add a0,a2,a0
-;;   lui a5,65535
-;;   slli a2,a5,4
-;;   add a0,a0,a2
-;;   sb a1,0(a0)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   slli a4,a0,32
-;;   srli a0,a4,32
-;;   ld a5,8(a1)
-;;   bgtu a0,a5,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a1,0(a1)
-;;   add a0,a1,a0
-;;   lui a5,65535
-;;   slli a1,a5,4
-;;   add a0,a0,a1
-;;   lbu a0,0(a0)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 3dd2f91baac1..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   slli a3,a0,32
-;;   srli a5,a3,32
-;;   ld a4,8(a2)
-;;   ugt a0,a5,a4##ty=i64
-;;   ld a4,0(a2)
-;;   add a4,a4,a5
-;;   li a5,0
-;;   sltu a0,zero,a0
-;;   sub a2,zero,a0
-;;   and a3,a5,a2
-;;   not a5,a2
-;;   and a2,a4,a5
-;;   or a3,a3,a2
-;;   sw a1,0(a3)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   slli a3,a0,32
-;;   srli a5,a3,32
-;;   ld a4,8(a1)
-;;   ugt a0,a5,a4##ty=i64
-;;   ld a4,0(a1)
-;;   add a4,a4,a5
-;;   li a5,0
-;;   sltu a0,zero,a0
-;;   sub a1,zero,a0
-;;   and a3,a5,a1
-;;   not a5,a1
-;;   and a1,a4,a5
-;;   or a3,a3,a1
-;;   lw a0,0(a3)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index f00d09c2bc70..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,84 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   slli a5,a0,32
-;;   srli a3,a5,32
-;;   ld a0,8(a2)
-;;   ugt a0,a3,a0##ty=i64
-;;   ld a2,0(a2)
-;;   add a2,a2,a3
-;;   lui a3,1
-;;   add a2,a2,a3
-;;   li a3,0
-;;   sltu a4,zero,a0
-;;   sub a4,zero,a4
-;;   and a5,a3,a4
-;;   not a3,a4
-;;   and a3,a2,a3
-;;   or a5,a5,a3
-;;   sw a1,0(a5)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   slli a5,a0,32
-;;   srli a2,a5,32
-;;   ld a0,8(a1)
-;;   ugt a0,a2,a0##ty=i64
-;;   ld a1,0(a1)
-;;   add a1,a1,a2
-;;   lui a2,1
-;;   add a1,a1,a2
-;;   li a2,0
-;;   sltu a3,zero,a0
-;;   sub a3,zero,a3
-;;   and a5,a2,a3
-;;   not a2,a3
-;;   and a3,a1,a2
-;;   or a5,a5,a3
-;;   lw a0,0(a5)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 6ed2f33eb810..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,86 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   slli a0,a0,32
-;;   srli a3,a0,32
-;;   ld a4,8(a2)
-;;   ugt a4,a3,a4##ty=i64
-;;   ld a2,0(a2)
-;;   add a2,a2,a3
-;;   lui a0,65535
-;;   slli a3,a0,4
-;;   add a3,a2,a3
-;;   li a2,0
-;;   sltu a4,zero,a4
-;;   sub a4,zero,a4
-;;   and a0,a2,a4
-;;   not a2,a4
-;;   and a4,a3,a2
-;;   or a0,a0,a4
-;;   sw a1,0(a0)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   slli a0,a0,32
-;;   srli a2,a0,32
-;;   ld a3,8(a1)
-;;   ugt a3,a2,a3##ty=i64
-;;   ld a1,0(a1)
-;;   add a1,a1,a2
-;;   lui a0,65535
-;;   slli a2,a0,4
-;;   add a2,a1,a2
-;;   li a1,0
-;;   sltu a3,zero,a3
-;;   sub a4,zero,a3
-;;   and a0,a1,a4
-;;   not a3,a4
-;;   and a4,a2,a3
-;;   or a0,a0,a4
-;;   lw a0,0(a0)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index cf9be3f6d245..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   slli a3,a0,32
-;;   srli a5,a3,32
-;;   ld a4,8(a2)
-;;   uge a0,a5,a4##ty=i64
-;;   ld a4,0(a2)
-;;   add a4,a4,a5
-;;   li a5,0
-;;   sltu a0,zero,a0
-;;   sub a2,zero,a0
-;;   and a3,a5,a2
-;;   not a5,a2
-;;   and a2,a4,a5
-;;   or a3,a3,a2
-;;   sb a1,0(a3)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   slli a3,a0,32
-;;   srli a5,a3,32
-;;   ld a4,8(a1)
-;;   uge a0,a5,a4##ty=i64
-;;   ld a4,0(a1)
-;;   add a4,a4,a5
-;;   li a5,0
-;;   sltu a0,zero,a0
-;;   sub a1,zero,a0
-;;   and a3,a5,a1
-;;   not a5,a1
-;;   and a1,a4,a5
-;;   or a3,a3,a1
-;;   lbu a0,0(a3)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index fac8d232e735..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,84 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   slli a5,a0,32
-;;   srli a3,a5,32
-;;   ld a0,8(a2)
-;;   ugt a0,a3,a0##ty=i64
-;;   ld a2,0(a2)
-;;   add a2,a2,a3
-;;   lui a3,1
-;;   add a2,a2,a3
-;;   li a3,0
-;;   sltu a4,zero,a0
-;;   sub a4,zero,a4
-;;   and a5,a3,a4
-;;   not a3,a4
-;;   and a3,a2,a3
-;;   or a5,a5,a3
-;;   sb a1,0(a5)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   slli a5,a0,32
-;;   srli a2,a5,32
-;;   ld a0,8(a1)
-;;   ugt a0,a2,a0##ty=i64
-;;   ld a1,0(a1)
-;;   add a1,a1,a2
-;;   lui a2,1
-;;   add a1,a1,a2
-;;   li a2,0
-;;   sltu a3,zero,a0
-;;   sub a3,zero,a3
-;;   and a5,a2,a3
-;;   not a2,a3
-;;   and a3,a1,a2
-;;   or a5,a5,a3
-;;   lbu a0,0(a5)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 579c3e1c7312..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,86 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   slli a0,a0,32
-;;   srli a3,a0,32
-;;   ld a4,8(a2)
-;;   ugt a4,a3,a4##ty=i64
-;;   ld a2,0(a2)
-;;   add a2,a2,a3
-;;   lui a0,65535
-;;   slli a3,a0,4
-;;   add a3,a2,a3
-;;   li a2,0
-;;   sltu a4,zero,a4
-;;   sub a4,zero,a4
-;;   and a0,a2,a4
-;;   not a2,a4
-;;   and a4,a3,a2
-;;   or a0,a0,a4
-;;   sb a1,0(a0)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   slli a0,a0,32
-;;   srli a2,a0,32
-;;   ld a3,8(a1)
-;;   ugt a3,a2,a3##ty=i64
-;;   ld a1,0(a1)
-;;   add a1,a1,a2
-;;   lui a0,65535
-;;   slli a2,a0,4
-;;   add a2,a1,a2
-;;   li a1,0
-;;   sltu a3,zero,a3
-;;   sub a4,zero,a3
-;;   and a0,a1,a4
-;;   not a3,a4
-;;   and a4,a2,a3
-;;   or a0,a0,a4
-;;   lbu a0,0(a0)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index f21969e0c25e..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   ld a3,8(a2)
-;;   addi a3,a3,-4
-;;   bgtu a0,a3,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a2,0(a2)
-;;   add a2,a2,a0
-;;   sw a1,0(a2)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   ld a2,8(a1)
-;;   addi a2,a2,-4
-;;   bgtu a0,a2,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a2,0(a1)
-;;   add a2,a2,a0
-;;   lw a0,0(a2)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 025f33dde63e..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   ld a3,8(a2)
-;;   lui a4,-1
-;;   addi a4,a4,-4
-;;   add a3,a3,a4
-;;   bgtu a0,a3,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a4,0(a2)
-;;   add a4,a4,a0
-;;   sw a1,4096(a4)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   ld a3,8(a1)
-;;   lui a2,-1
-;;   addi a4,a2,-4
-;;   add a3,a3,a4
-;;   bgtu a0,a3,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a4,0(a1)
-;;   add a4,a4,a0
-;;   lw a0,4096(a4)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index fa4768c25dfa..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,84 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   lui a5,262140
-;;   addi a3,a5,1
-;;   slli a3,a3,2
-;;   add a3,a0,a3
-;;   trap_if heap_oob##(a3 ult a0)
-;;   ld a4,8(a2)
-;;   bgtu a3,a4,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a3,0(a2)
-;;   add a3,a3,a0
-;;   lui a2,65535
-;;   slli a4,a2,4
-;;   add a3,a3,a4
-;;   sw a1,0(a3)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   lui a5,262140
-;;   addi a2,a5,1
-;;   slli a3,a2,2
-;;   add a2,a0,a3
-;;   trap_if heap_oob##(a2 ult a0)
-;;   ld a3,8(a1)
-;;   bgtu a2,a3,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a3,0(a1)
-;;   add a3,a3,a0
-;;   lui a2,65535
-;;   slli a4,a2,4
-;;   add a3,a3,a4
-;;   lw a0,0(a3)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 3a323cef4580..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   ld a3,8(a2)
-;;   bgeu a0,a3,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a2,0(a2)
-;;   add a2,a2,a0
-;;   sb a1,0(a2)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   ld a2,8(a1)
-;;   bgeu a0,a2,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a1,0(a1)
-;;   add a1,a1,a0
-;;   lbu a0,0(a1)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index ee26ad7f0626..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   ld a3,8(a2)
-;;   lui a4,-1
-;;   addi a4,a4,-1
-;;   add a3,a3,a4
-;;   bgtu a0,a3,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a4,0(a2)
-;;   add a4,a4,a0
-;;   sb a1,4096(a4)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   ld a3,8(a1)
-;;   lui a2,-1
-;;   addi a4,a2,-1
-;;   add a3,a3,a4
-;;   bgtu a0,a3,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a4,0(a1)
-;;   add a4,a4,a0
-;;   lbu a0,4096(a4)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 445a2b6d9885..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   ld a5,[const(0)]
-;;   add a5,a0,a5
-;;   trap_if heap_oob##(a5 ult a0)
-;;   ld a3,8(a2)
-;;   bgtu a5,a3,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a2,0(a2)
-;;   add a2,a2,a0
-;;   lui a0,65535
-;;   slli a3,a0,4
-;;   add a2,a2,a3
-;;   sb a1,0(a2)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   ld a5,[const(0)]
-;;   add a5,a0,a5
-;;   trap_if heap_oob##(a5 ult a0)
-;;   ld a2,8(a1)
-;;   bgtu a5,a2,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a1,0(a1)
-;;   add a1,a1,a0
-;;   lui a0,65535
-;;   slli a2,a0,4
-;;   add a1,a1,a2
-;;   lbu a0,0(a1)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index c52b742f2170..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   ld a3,8(a2)
-;;   addi a3,a3,-4
-;;   ugt a4,a0,a3##ty=i64
-;;   ld a3,0(a2)
-;;   add a3,a3,a0
-;;   li a5,0
-;;   sltu a4,zero,a4
-;;   sub a0,zero,a4
-;;   and a2,a5,a0
-;;   not a4,a0
-;;   and a0,a3,a4
-;;   or a2,a2,a0
-;;   sw a1,0(a2)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ld a3,8(a1)
-;;   addi a3,a3,-4
-;;   ugt a4,a0,a3##ty=i64
-;;   ld a3,0(a1)
-;;   add a3,a3,a0
-;;   li a5,0
-;;   sltu a4,zero,a4
-;;   sub a0,zero,a4
-;;   and a2,a5,a0
-;;   not a4,a0
-;;   and a0,a3,a4
-;;   or a2,a2,a0
-;;   lw a0,0(a2)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index cf61dff531a1..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,86 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   ld a3,8(a2)
-;;   lui a4,-1
-;;   addi a4,a4,-4
-;;   add a3,a3,a4
-;;   ugt a4,a0,a3##ty=i64
-;;   ld a2,0(a2)
-;;   add a2,a2,a0
-;;   lui a3,1
-;;   add a3,a2,a3
-;;   li a2,0
-;;   sltu a4,zero,a4
-;;   sub a4,zero,a4
-;;   and a0,a2,a4
-;;   not a2,a4
-;;   and a4,a3,a2
-;;   or a0,a0,a4
-;;   sw a1,0(a0)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ld a2,8(a1)
-;;   lui a3,-1
-;;   addi a3,a3,-4
-;;   add a2,a2,a3
-;;   ugt a3,a0,a2##ty=i64
-;;   ld a1,0(a1)
-;;   add a1,a1,a0
-;;   lui a2,1
-;;   add a2,a1,a2
-;;   li a1,0
-;;   sltu a3,zero,a3
-;;   sub a4,zero,a3
-;;   and a0,a1,a4
-;;   not a3,a4
-;;   and a4,a2,a3
-;;   or a0,a0,a4
-;;   lw a0,0(a0)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index f49466b1499c..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,92 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   lui a3,262140
-;;   addi a3,a3,1
-;;   slli a5,a3,2
-;;   add a3,a0,a5
-;;   trap_if heap_oob##(a3 ult a0)
-;;   ld a4,8(a2)
-;;   ugt a4,a3,a4##ty=i64
-;;   ld a5,0(a2)
-;;   add a5,a5,a0
-;;   lui a3,65535
-;;   slli a0,a3,4
-;;   add a5,a5,a0
-;;   li a0,0
-;;   sltu a2,zero,a4
-;;   sub a2,zero,a2
-;;   and a3,a0,a2
-;;   not a0,a2
-;;   and a2,a5,a0
-;;   or a3,a3,a2
-;;   sw a1,0(a3)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   lui a2,262140
-;;   addi a3,a2,1
-;;   slli a5,a3,2
-;;   add a3,a0,a5
-;;   trap_if heap_oob##(a3 ult a0)
-;;   ld a4,8(a1)
-;;   ugt a4,a3,a4##ty=i64
-;;   ld a5,0(a1)
-;;   add a5,a5,a0
-;;   lui a3,65535
-;;   slli a0,a3,4
-;;   add a5,a5,a0
-;;   li a0,0
-;;   sltu a1,zero,a4
-;;   sub a1,zero,a1
-;;   and a3,a0,a1
-;;   not a0,a1
-;;   and a1,a5,a0
-;;   or a3,a3,a1
-;;   lw a0,0(a3)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 8602214200a3..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   ld a3,8(a2)
-;;   uge a3,a0,a3##ty=i64
-;;   ld a2,0(a2)
-;;   add a2,a2,a0
-;;   li a4,0
-;;   sltu a3,zero,a3
-;;   sub a5,zero,a3
-;;   and a3,a4,a5
-;;   not a4,a5
-;;   and a5,a2,a4
-;;   or a2,a3,a5
-;;   sb a1,0(a2)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ld a2,8(a1)
-;;   uge a3,a0,a2##ty=i64
-;;   ld a2,0(a1)
-;;   add a2,a2,a0
-;;   li a4,0
-;;   sltu a3,zero,a3
-;;   sub a5,zero,a3
-;;   and a1,a4,a5
-;;   not a3,a5
-;;   and a5,a2,a3
-;;   or a1,a1,a5
-;;   lbu a0,0(a1)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 6b6da4a049a2..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,86 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   ld a3,8(a2)
-;;   lui a4,-1
-;;   addi a4,a4,-1
-;;   add a3,a3,a4
-;;   ugt a4,a0,a3##ty=i64
-;;   ld a2,0(a2)
-;;   add a2,a2,a0
-;;   lui a3,1
-;;   add a3,a2,a3
-;;   li a2,0
-;;   sltu a4,zero,a4
-;;   sub a4,zero,a4
-;;   and a0,a2,a4
-;;   not a2,a4
-;;   and a4,a3,a2
-;;   or a0,a0,a4
-;;   sb a1,0(a0)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ld a2,8(a1)
-;;   lui a3,-1
-;;   addi a3,a3,-1
-;;   add a2,a2,a3
-;;   ugt a3,a0,a2##ty=i64
-;;   ld a1,0(a1)
-;;   add a1,a1,a0
-;;   lui a2,1
-;;   add a2,a1,a2
-;;   li a1,0
-;;   sltu a3,zero,a3
-;;   sub a4,zero,a3
-;;   and a0,a1,a4
-;;   not a3,a4
-;;   and a4,a2,a3
-;;   or a0,a0,a4
-;;   lbu a0,0(a0)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 26e0d05f0b4d..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,88 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   ld a3,[const(0)]
-;;   add a3,a0,a3
-;;   trap_if heap_oob##(a3 ult a0)
-;;   ld a4,8(a2)
-;;   ugt a4,a3,a4##ty=i64
-;;   ld a2,0(a2)
-;;   add a2,a2,a0
-;;   lui a3,65535
-;;   slli a3,a3,4
-;;   add a3,a2,a3
-;;   li a2,0
-;;   sltu a4,zero,a4
-;;   sub a5,zero,a4
-;;   and a2,a2,a5
-;;   not a4,a5
-;;   and a5,a3,a4
-;;   or a2,a2,a5
-;;   sb a1,0(a2)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ld a2,[const(0)]
-;;   add a2,a0,a2
-;;   trap_if heap_oob##(a2 ult a0)
-;;   ld a3,8(a1)
-;;   ugt a2,a2,a3##ty=i64
-;;   ld a3,0(a1)
-;;   add a3,a3,a0
-;;   lui a1,65535
-;;   slli a4,a1,4
-;;   add a3,a3,a4
-;;   li a4,0
-;;   sltu a5,zero,a2
-;;   sub a5,zero,a5
-;;   and a1,a4,a5
-;;   not a4,a5
-;;   and a5,a3,a4
-;;   or a1,a1,a5
-;;   lbu a0,0(a1)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 216eea7f715d..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   ld a3,8(a2)
-;;   bgtu a0,a3,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a2,0(a2)
-;;   add a2,a2,a0
-;;   sw a1,0(a2)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   ld a2,8(a1)
-;;   bgtu a0,a2,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a1,0(a1)
-;;   add a1,a1,a0
-;;   lw a0,0(a1)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index f7784defa517..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   ld a3,8(a2)
-;;   bgtu a0,a3,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a2,0(a2)
-;;   add a2,a2,a0
-;;   sw a1,4096(a2)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   ld a2,8(a1)
-;;   bgtu a0,a2,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a1,0(a1)
-;;   add a1,a1,a0
-;;   lw a0,4096(a1)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 3a8325aa3646..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   ld a3,8(a2)
-;;   bgtu a0,a3,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a4,0(a2)
-;;   add a4,a4,a0
-;;   lui a3,65535
-;;   slli a5,a3,4
-;;   add a4,a4,a5
-;;   sw a1,0(a4)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   ld a3,8(a1)
-;;   bgtu a0,a3,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a4,0(a1)
-;;   add a4,a4,a0
-;;   lui a3,65535
-;;   slli a5,a3,4
-;;   add a4,a4,a5
-;;   lw a0,0(a4)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 598727d97962..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   ld a3,8(a2)
-;;   bgeu a0,a3,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a2,0(a2)
-;;   add a2,a2,a0
-;;   sb a1,0(a2)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   ld a2,8(a1)
-;;   bgeu a0,a2,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a1,0(a1)
-;;   add a1,a1,a0
-;;   lbu a0,0(a1)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 10beda2e0206..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   ld a3,8(a2)
-;;   bgtu a0,a3,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a2,0(a2)
-;;   add a2,a2,a0
-;;   sb a1,4096(a2)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   ld a2,8(a1)
-;;   bgtu a0,a2,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a1,0(a1)
-;;   add a1,a1,a0
-;;   lbu a0,4096(a1)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 6ac50e3591b9..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   ld a3,8(a2)
-;;   bgtu a0,a3,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a4,0(a2)
-;;   add a4,a4,a0
-;;   lui a3,65535
-;;   slli a5,a3,4
-;;   add a4,a4,a5
-;;   sb a1,0(a4)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   ld a3,8(a1)
-;;   bgtu a0,a3,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a4,0(a1)
-;;   add a4,a4,a0
-;;   lui a3,65535
-;;   slli a5,a3,4
-;;   add a4,a4,a5
-;;   lbu a0,0(a4)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 489b039647cb..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   ld a3,8(a2)
-;;   ugt a3,a0,a3##ty=i64
-;;   ld a2,0(a2)
-;;   add a2,a2,a0
-;;   li a4,0
-;;   sltu a3,zero,a3
-;;   sub a5,zero,a3
-;;   and a3,a4,a5
-;;   not a4,a5
-;;   and a5,a2,a4
-;;   or a2,a3,a5
-;;   sw a1,0(a2)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ld a2,8(a1)
-;;   ugt a3,a0,a2##ty=i64
-;;   ld a2,0(a1)
-;;   add a2,a2,a0
-;;   li a4,0
-;;   sltu a3,zero,a3
-;;   sub a5,zero,a3
-;;   and a1,a4,a5
-;;   not a3,a5
-;;   and a5,a2,a3
-;;   or a1,a1,a5
-;;   lw a0,0(a1)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 3a0708c20d19..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   ld a4,8(a2)
-;;   ugt a4,a0,a4##ty=i64
-;;   ld a5,0(a2)
-;;   add a5,a5,a0
-;;   lui a0,1
-;;   add a5,a5,a0
-;;   li a0,0
-;;   sltu a2,zero,a4
-;;   sub a2,zero,a2
-;;   and a3,a0,a2
-;;   not a0,a2
-;;   and a2,a5,a0
-;;   or a3,a3,a2
-;;   sw a1,0(a3)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ld a4,8(a1)
-;;   ugt a4,a0,a4##ty=i64
-;;   ld a5,0(a1)
-;;   add a5,a5,a0
-;;   lui a0,1
-;;   add a5,a5,a0
-;;   li a0,0
-;;   sltu a1,zero,a4
-;;   sub a1,zero,a1
-;;   and a3,a0,a1
-;;   not a0,a1
-;;   and a1,a5,a0
-;;   or a3,a3,a1
-;;   lw a0,0(a3)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 9efd0648bb0e..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,82 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   ld a5,8(a2)
-;;   ugt a5,a0,a5##ty=i64
-;;   ld a2,0(a2)
-;;   add a0,a2,a0
-;;   lui a4,65535
-;;   slli a2,a4,4
-;;   add a0,a0,a2
-;;   li a2,0
-;;   sltu a3,zero,a5
-;;   sub a3,zero,a3
-;;   and a4,a2,a3
-;;   not a2,a3
-;;   and a2,a0,a2
-;;   or a4,a4,a2
-;;   sw a1,0(a4)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ld a5,8(a1)
-;;   ugt a5,a0,a5##ty=i64
-;;   ld a1,0(a1)
-;;   add a0,a1,a0
-;;   lui a4,65535
-;;   slli a1,a4,4
-;;   add a0,a0,a1
-;;   li a1,0
-;;   sltu a2,zero,a5
-;;   sub a2,zero,a2
-;;   and a4,a1,a2
-;;   not a1,a2
-;;   and a2,a0,a1
-;;   or a4,a4,a2
-;;   lw a0,0(a4)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index fe719e0e93e2..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   ld a3,8(a2)
-;;   uge a3,a0,a3##ty=i64
-;;   ld a2,0(a2)
-;;   add a2,a2,a0
-;;   li a4,0
-;;   sltu a3,zero,a3
-;;   sub a5,zero,a3
-;;   and a3,a4,a5
-;;   not a4,a5
-;;   and a5,a2,a4
-;;   or a2,a3,a5
-;;   sb a1,0(a2)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ld a2,8(a1)
-;;   uge a3,a0,a2##ty=i64
-;;   ld a2,0(a1)
-;;   add a2,a2,a0
-;;   li a4,0
-;;   sltu a3,zero,a3
-;;   sub a5,zero,a3
-;;   and a1,a4,a5
-;;   not a3,a5
-;;   and a5,a2,a3
-;;   or a1,a1,a5
-;;   lbu a0,0(a1)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index c473fe49d832..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   ld a4,8(a2)
-;;   ugt a4,a0,a4##ty=i64
-;;   ld a5,0(a2)
-;;   add a5,a5,a0
-;;   lui a0,1
-;;   add a5,a5,a0
-;;   li a0,0
-;;   sltu a2,zero,a4
-;;   sub a2,zero,a2
-;;   and a3,a0,a2
-;;   not a0,a2
-;;   and a2,a5,a0
-;;   or a3,a3,a2
-;;   sb a1,0(a3)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ld a4,8(a1)
-;;   ugt a4,a0,a4##ty=i64
-;;   ld a5,0(a1)
-;;   add a5,a5,a0
-;;   lui a0,1
-;;   add a5,a5,a0
-;;   li a0,0
-;;   sltu a1,zero,a4
-;;   sub a1,zero,a1
-;;   and a3,a0,a1
-;;   not a0,a1
-;;   and a1,a5,a0
-;;   or a3,a3,a1
-;;   lbu a0,0(a3)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 8543e04f2fa2..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,82 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   ld a5,8(a2)
-;;   ugt a5,a0,a5##ty=i64
-;;   ld a2,0(a2)
-;;   add a0,a2,a0
-;;   lui a4,65535
-;;   slli a2,a4,4
-;;   add a0,a0,a2
-;;   li a2,0
-;;   sltu a3,zero,a5
-;;   sub a3,zero,a3
-;;   and a4,a2,a3
-;;   not a2,a3
-;;   and a2,a0,a2
-;;   or a4,a4,a2
-;;   sb a1,0(a4)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   ld a5,8(a1)
-;;   ugt a5,a0,a5##ty=i64
-;;   ld a1,0(a1)
-;;   add a0,a1,a0
-;;   lui a4,65535
-;;   slli a1,a4,4
-;;   add a0,a0,a1
-;;   li a1,0
-;;   sltu a2,zero,a5
-;;   sub a2,zero,a2
-;;   and a4,a1,a2
-;;   not a1,a2
-;;   and a2,a0,a1
-;;   or a4,a4,a2
-;;   lbu a0,0(a4)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index be756e1e6b5a..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   slli a3,a0,32
-;;   srli a4,a3,32
-;;   lui a3,65536
-;;   addi a5,a3,-4
-;;   bgtu a4,a5,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a5,0(a2)
-;;   add a4,a5,a4
-;;   sw a1,0(a4)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   slli a2,a0,32
-;;   srli a4,a2,32
-;;   lui a2,65536
-;;   addi a5,a2,-4
-;;   bgtu a4,a5,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a5,0(a1)
-;;   add a4,a5,a4
-;;   lw a0,0(a4)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index bb58c0d19bf0..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   slli a3,a0,32
-;;   srli a4,a3,32
-;;   lui a3,65535
-;;   addi a5,a3,-4
-;;   bgtu a4,a5,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a5,0(a2)
-;;   add a4,a5,a4
-;;   sw a1,4096(a4)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   slli a2,a0,32
-;;   srli a4,a2,32
-;;   lui a2,65535
-;;   addi a5,a2,-4
-;;   bgtu a4,a5,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a5,0(a1)
-;;   add a4,a5,a4
-;;   lw a0,4096(a4)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 186d97569215..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   udf##trap_code=heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 10a641f261a1..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   slli a3,a0,32
-;;   srli a4,a3,32
-;;   lui a3,65536
-;;   addi a5,a3,-1
-;;   bgtu a4,a5,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a5,0(a2)
-;;   add a4,a5,a4
-;;   sb a1,0(a4)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   slli a2,a0,32
-;;   srli a4,a2,32
-;;   lui a2,65536
-;;   addi a5,a2,-1
-;;   bgtu a4,a5,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a5,0(a1)
-;;   add a4,a5,a4
-;;   lbu a0,0(a4)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 3c3968591466..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   slli a3,a0,32
-;;   srli a4,a3,32
-;;   lui a3,65535
-;;   addi a5,a3,-1
-;;   bgtu a4,a5,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a5,0(a2)
-;;   add a4,a5,a4
-;;   sb a1,4096(a4)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   slli a2,a0,32
-;;   srli a4,a2,32
-;;   lui a2,65535
-;;   addi a5,a2,-1
-;;   bgtu a4,a5,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a5,0(a1)
-;;   add a4,a5,a4
-;;   lbu a0,4096(a4)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 162da88fc761..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   udf##trap_code=heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 0a75a7b3d6da..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   slli a4,a0,32
-;;   srli a0,a4,32
-;;   lui a4,65536
-;;   addi a3,a4,-4
-;;   ugt a3,a0,a3##ty=i64
-;;   ld a5,0(a2)
-;;   add a5,a5,a0
-;;   li a0,0
-;;   sltu a2,zero,a3
-;;   sub a2,zero,a2
-;;   and a4,a0,a2
-;;   not a0,a2
-;;   and a2,a5,a0
-;;   or a4,a4,a2
-;;   sw a1,0(a4)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   slli a4,a0,32
-;;   srli a0,a4,32
-;;   lui a4,65536
-;;   addi a2,a4,-4
-;;   ugt a2,a0,a2##ty=i64
-;;   ld a5,0(a1)
-;;   add a5,a5,a0
-;;   li a0,0
-;;   sltu a1,zero,a2
-;;   sub a2,zero,a1
-;;   and a4,a0,a2
-;;   not a0,a2
-;;   and a2,a5,a0
-;;   or a4,a4,a2
-;;   lw a0,0(a4)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 90d1bca843f1..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,87 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   mv a4,a2
-;;   slli a0,a0,32
-;;   srli a3,a0,32
-;;   lui a0,65535
-;;   addi a2,a0,-4
-;;   ugt a2,a3,a2##ty=i64
-;;   ld a4,0(a4)
-;;   add a3,a4,a3
-;;   lui a4,1
-;;   add a3,a3,a4
-;;   li a4,0
-;;   sltu a2,zero,a2
-;;   sub a5,zero,a2
-;;   and a0,a4,a5
-;;   not a2,a5
-;;   and a4,a3,a2
-;;   or a0,a0,a4
-;;   sw a1,0(a0)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   mv a4,a1
-;;   slli a0,a0,32
-;;   srli a2,a0,32
-;;   lui a0,65535
-;;   addi a3,a0,-4
-;;   ugt a1,a2,a3##ty=i64
-;;   mv a3,a4
-;;   ld a3,0(a3)
-;;   add a2,a3,a2
-;;   lui a3,1
-;;   add a2,a2,a3
-;;   li a3,0
-;;   sltu a4,zero,a1
-;;   sub a4,zero,a4
-;;   and a0,a3,a4
-;;   not a3,a4
-;;   and a4,a2,a3
-;;   or a0,a0,a4
-;;   lw a0,0(a0)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index eafaf4ef1356..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   udf##trap_code=heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 168a14a89d3d..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   slli a4,a0,32
-;;   srli a0,a4,32
-;;   lui a4,65536
-;;   addi a3,a4,-1
-;;   ugt a3,a0,a3##ty=i64
-;;   ld a5,0(a2)
-;;   add a5,a5,a0
-;;   li a0,0
-;;   sltu a2,zero,a3
-;;   sub a2,zero,a2
-;;   and a4,a0,a2
-;;   not a0,a2
-;;   and a2,a5,a0
-;;   or a4,a4,a2
-;;   sb a1,0(a4)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   slli a4,a0,32
-;;   srli a0,a4,32
-;;   lui a4,65536
-;;   addi a2,a4,-1
-;;   ugt a2,a0,a2##ty=i64
-;;   ld a5,0(a1)
-;;   add a5,a5,a0
-;;   li a0,0
-;;   sltu a1,zero,a2
-;;   sub a2,zero,a1
-;;   and a4,a0,a2
-;;   not a0,a2
-;;   and a2,a5,a0
-;;   or a4,a4,a2
-;;   lbu a0,0(a4)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 3b7117ad7c32..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,87 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   mv a4,a2
-;;   slli a0,a0,32
-;;   srli a3,a0,32
-;;   lui a0,65535
-;;   addi a2,a0,-1
-;;   ugt a2,a3,a2##ty=i64
-;;   ld a4,0(a4)
-;;   add a3,a4,a3
-;;   lui a4,1
-;;   add a3,a3,a4
-;;   li a4,0
-;;   sltu a2,zero,a2
-;;   sub a5,zero,a2
-;;   and a0,a4,a5
-;;   not a2,a5
-;;   and a4,a3,a2
-;;   or a0,a0,a4
-;;   sb a1,0(a0)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   mv a4,a1
-;;   slli a0,a0,32
-;;   srli a2,a0,32
-;;   lui a0,65535
-;;   addi a3,a0,-1
-;;   ugt a1,a2,a3##ty=i64
-;;   mv a3,a4
-;;   ld a3,0(a3)
-;;   add a2,a3,a2
-;;   lui a3,1
-;;   add a2,a2,a3
-;;   li a3,0
-;;   sltu a4,zero,a1
-;;   sub a4,zero,a4
-;;   and a0,a3,a4
-;;   not a3,a4
-;;   and a4,a2,a3
-;;   or a0,a0,a4
-;;   lbu a0,0(a0)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 084fc90ac43f..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   udf##trap_code=heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 9aa990e2be0f..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,60 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   slli a0,a0,32
-;;   srli a3,a0,32
-;;   ld a2,0(a2)
-;;   add a2,a2,a3
-;;   sw a1,0(a2)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   slli a0,a0,32
-;;   srli a2,a0,32
-;;   ld a1,0(a1)
-;;   add a1,a1,a2
-;;   lw a0,0(a1)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 0d16208377cd..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,60 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   slli a0,a0,32
-;;   srli a3,a0,32
-;;   ld a2,0(a2)
-;;   add a2,a2,a3
-;;   sw a1,4096(a2)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   slli a0,a0,32
-;;   srli a2,a0,32
-;;   ld a1,0(a1)
-;;   add a1,a1,a2
-;;   lw a0,4096(a1)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 9307ec8c743e..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   udf##trap_code=heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 9b0820e8658c..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,60 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   slli a0,a0,32
-;;   srli a3,a0,32
-;;   ld a2,0(a2)
-;;   add a2,a2,a3
-;;   sb a1,0(a2)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   slli a0,a0,32
-;;   srli a2,a0,32
-;;   ld a1,0(a1)
-;;   add a1,a1,a2
-;;   lbu a0,0(a1)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 1a3f9d4396f3..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,60 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   slli a0,a0,32
-;;   srli a3,a0,32
-;;   ld a2,0(a2)
-;;   add a2,a2,a3
-;;   sb a1,4096(a2)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   slli a0,a0,32
-;;   srli a2,a0,32
-;;   ld a1,0(a1)
-;;   add a1,a1,a2
-;;   lbu a0,4096(a1)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index b80b3414752b..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   udf##trap_code=heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index c58cd7d6b105..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,60 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   slli a0,a0,32
-;;   srli a3,a0,32
-;;   ld a2,0(a2)
-;;   add a2,a2,a3
-;;   sw a1,0(a2)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   slli a0,a0,32
-;;   srli a2,a0,32
-;;   ld a1,0(a1)
-;;   add a1,a1,a2
-;;   lw a0,0(a1)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index d7355dbe7037..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,60 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   slli a0,a0,32
-;;   srli a3,a0,32
-;;   ld a2,0(a2)
-;;   add a2,a2,a3
-;;   sw a1,4096(a2)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   slli a0,a0,32
-;;   srli a2,a0,32
-;;   ld a1,0(a1)
-;;   add a1,a1,a2
-;;   lw a0,4096(a1)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index b0c6cc398038..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   udf##trap_code=heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 23d958d3593d..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,60 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   slli a0,a0,32
-;;   srli a3,a0,32
-;;   ld a2,0(a2)
-;;   add a2,a2,a3
-;;   sb a1,0(a2)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   slli a0,a0,32
-;;   srli a2,a0,32
-;;   ld a1,0(a1)
-;;   add a1,a1,a2
-;;   lbu a0,0(a1)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index a6cd0f771bd9..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,60 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   slli a0,a0,32
-;;   srli a3,a0,32
-;;   ld a2,0(a2)
-;;   add a2,a2,a3
-;;   sb a1,4096(a2)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   slli a0,a0,32
-;;   srli a2,a0,32
-;;   ld a1,0(a1)
-;;   add a1,a1,a2
-;;   lbu a0,4096(a1)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 8eefcbb20011..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   udf##trap_code=heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 2ccf3332dafe..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   lui a3,65536
-;;   addi a3,a3,-4
-;;   bgtu a0,a3,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a2,0(a2)
-;;   add a2,a2,a0
-;;   sw a1,0(a2)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   lui a2,65536
-;;   addi a2,a2,-4
-;;   bgtu a0,a2,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a2,0(a1)
-;;   add a2,a2,a0
-;;   lw a0,0(a2)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 1e526bff3979..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   lui a3,65535
-;;   addi a3,a3,-4
-;;   bgtu a0,a3,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a2,0(a2)
-;;   add a2,a2,a0
-;;   sw a1,4096(a2)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   lui a2,65535
-;;   addi a2,a2,-4
-;;   bgtu a0,a2,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a2,0(a1)
-;;   add a2,a2,a0
-;;   lw a0,4096(a2)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 387204d0daa5..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   udf##trap_code=heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 0b54080054b9..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   lui a3,65536
-;;   addi a3,a3,-1
-;;   bgtu a0,a3,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a2,0(a2)
-;;   add a2,a2,a0
-;;   sb a1,0(a2)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   lui a2,65536
-;;   addi a2,a2,-1
-;;   bgtu a0,a2,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a2,0(a1)
-;;   add a2,a2,a0
-;;   lbu a0,0(a2)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index f85b1a0bd8fe..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   lui a3,65535
-;;   addi a3,a3,-1
-;;   bgtu a0,a3,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a2,0(a2)
-;;   add a2,a2,a0
-;;   sb a1,4096(a2)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   lui a2,65535
-;;   addi a2,a2,-1
-;;   bgtu a0,a2,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a2,0(a1)
-;;   add a2,a2,a0
-;;   lbu a0,4096(a2)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 1104e644c3e9..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   udf##trap_code=heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 05335a7dfc54..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   lui a3,65536
-;;   addi a4,a3,-4
-;;   ugt a4,a0,a4##ty=i64
-;;   ld a3,0(a2)
-;;   add a3,a3,a0
-;;   li a5,0
-;;   sltu a4,zero,a4
-;;   sub a0,zero,a4
-;;   and a2,a5,a0
-;;   not a4,a0
-;;   and a0,a3,a4
-;;   or a2,a2,a0
-;;   sw a1,0(a2)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   lui a2,65536
-;;   addi a4,a2,-4
-;;   ugt a4,a0,a4##ty=i64
-;;   ld a3,0(a1)
-;;   add a3,a3,a0
-;;   li a5,0
-;;   sltu a4,zero,a4
-;;   sub a0,zero,a4
-;;   and a2,a5,a0
-;;   not a4,a0
-;;   and a0,a3,a4
-;;   or a2,a2,a0
-;;   lw a0,0(a2)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 51822e1df936..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   lui a4,65535
-;;   addi a3,a4,-4
-;;   ugt a5,a0,a3##ty=i64
-;;   ld a2,0(a2)
-;;   add a0,a2,a0
-;;   lui a2,1
-;;   add a0,a0,a2
-;;   li a2,0
-;;   sltu a3,zero,a5
-;;   sub a3,zero,a3
-;;   and a4,a2,a3
-;;   not a2,a3
-;;   and a2,a0,a2
-;;   or a4,a4,a2
-;;   sw a1,0(a4)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   lui a4,65535
-;;   addi a2,a4,-4
-;;   ugt a5,a0,a2##ty=i64
-;;   ld a1,0(a1)
-;;   add a0,a1,a0
-;;   lui a1,1
-;;   add a0,a0,a1
-;;   li a1,0
-;;   sltu a2,zero,a5
-;;   sub a2,zero,a2
-;;   and a4,a1,a2
-;;   not a1,a2
-;;   and a2,a0,a1
-;;   or a4,a4,a2
-;;   lw a0,0(a4)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index d84c81cf50bf..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   udf##trap_code=heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index bb9a15f71417..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   lui a3,65536
-;;   addi a4,a3,-1
-;;   ugt a4,a0,a4##ty=i64
-;;   ld a3,0(a2)
-;;   add a3,a3,a0
-;;   li a5,0
-;;   sltu a4,zero,a4
-;;   sub a0,zero,a4
-;;   and a2,a5,a0
-;;   not a4,a0
-;;   and a0,a3,a4
-;;   or a2,a2,a0
-;;   sb a1,0(a2)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   lui a2,65536
-;;   addi a4,a2,-1
-;;   ugt a4,a0,a4##ty=i64
-;;   ld a3,0(a1)
-;;   add a3,a3,a0
-;;   li a5,0
-;;   sltu a4,zero,a4
-;;   sub a0,zero,a4
-;;   and a2,a5,a0
-;;   not a4,a0
-;;   and a0,a3,a4
-;;   or a2,a2,a0
-;;   lbu a0,0(a2)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index e7c33e026da5..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   lui a4,65535
-;;   addi a3,a4,-1
-;;   ugt a5,a0,a3##ty=i64
-;;   ld a2,0(a2)
-;;   add a0,a2,a0
-;;   lui a2,1
-;;   add a0,a0,a2
-;;   li a2,0
-;;   sltu a3,zero,a5
-;;   sub a3,zero,a3
-;;   and a4,a2,a3
-;;   not a2,a3
-;;   and a2,a0,a2
-;;   or a4,a4,a2
-;;   sb a1,0(a4)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   lui a4,65535
-;;   addi a2,a4,-1
-;;   ugt a5,a0,a2##ty=i64
-;;   ld a1,0(a1)
-;;   add a0,a1,a0
-;;   lui a1,1
-;;   add a0,a0,a1
-;;   li a1,0
-;;   sltu a2,zero,a5
-;;   sub a2,zero,a2
-;;   and a4,a1,a2
-;;   not a1,a2
-;;   and a2,a0,a1
-;;   or a4,a4,a2
-;;   lbu a0,0(a4)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 49190329a44f..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   udf##trap_code=heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 7ee1cabd23a5..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   lui a3,65536
-;;   addi a3,a3,-4
-;;   bgtu a0,a3,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a2,0(a2)
-;;   add a2,a2,a0
-;;   sw a1,0(a2)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   lui a2,65536
-;;   addi a2,a2,-4
-;;   bgtu a0,a2,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a2,0(a1)
-;;   add a2,a2,a0
-;;   lw a0,0(a2)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 27c1f657371c..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   lui a3,65535
-;;   addi a3,a3,-4
-;;   bgtu a0,a3,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a2,0(a2)
-;;   add a2,a2,a0
-;;   sw a1,4096(a2)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   lui a2,65535
-;;   addi a2,a2,-4
-;;   bgtu a0,a2,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a2,0(a1)
-;;   add a2,a2,a0
-;;   lw a0,4096(a2)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 4dd28696b26f..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   udf##trap_code=heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 60b63137691f..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   lui a3,65536
-;;   addi a3,a3,-1
-;;   bgtu a0,a3,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a2,0(a2)
-;;   add a2,a2,a0
-;;   sb a1,0(a2)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   lui a2,65536
-;;   addi a2,a2,-1
-;;   bgtu a0,a2,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a2,0(a1)
-;;   add a2,a2,a0
-;;   lbu a0,0(a2)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 8568f99897bc..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   lui a3,65535
-;;   addi a3,a3,-1
-;;   bgtu a0,a3,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a2,0(a2)
-;;   add a2,a2,a0
-;;   sb a1,4096(a2)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   lui a2,65535
-;;   addi a2,a2,-1
-;;   bgtu a0,a2,taken(label3),not_taken(label1)
-;; block1:
-;;   ld a2,0(a1)
-;;   add a2,a2,a0
-;;   lbu a0,4096(a2)
-;;   j label2
-;; block2:
-;;   ret
-;; block3:
-;;   udf##trap_code=heap_oob
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 93b2ed4755c2..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   udf##trap_code=heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index aa54e8732573..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;; block0:
-;;   lui a3,65536
-;;   addi a4,a3,-4
-;;   ugt a4,a0,a4##ty=i64
-;;   ld a3,0(a2)
-;;   add a3,a3,a0
-;;   li a5,0
-;;   sltu a4,zero,a4
-;;   sub a0,zero,a4
-;;   and a2,a5,a0
-;;   not a4,a0
-;;   and a0,a3,a4
-;;   or a2,a2,a0
-;;   sw a1,0(a2)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   lui a2,65536
-;;   addi a4,a2,-4
-;;   ugt a4,a0,a4##ty=i64
-;;   ld a3,0(a1)
-;;   add a3,a3,a0
-;;   li a5,0
-;;   sltu a4,zero,a4
-;;   sub a0,zero,a4
-;;   and a2,a5,a0
-;;   not a4,a0
-;;   and a0,a3,a4
-;;   or a2,a2,a0
-;;   lw a0,0(a2)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index da0371942a94..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   lui a4,65535
-;;   addi a3,a4,-4
-;;   ugt a5,a0,a3##ty=i64
-;;   ld a2,0(a2)
-;;   add a0,a2,a0
-;;   lui a2,1
-;;   add a0,a0,a2
-;;   li a2,0
-;;   sltu a3,zero,a5
-;;   sub a3,zero,a3
-;;   and a4,a2,a3
-;;   not a2,a3
-;;   and a2,a0,a2
-;;   or a4,a4,a2
-;;   sw a1,0(a4)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   lui a4,65535
-;;   addi a2,a4,-4
-;;   ugt a5,a0,a2##ty=i64
-;;   ld a1,0(a1)
-;;   add a0,a1,a0
-;;   lui a1,1
-;;   add a0,a0,a1
-;;   li a1,0
-;;   sltu a2,zero,a5
-;;   sub a2,zero,a2
-;;   and a4,a1,a2
-;;   not a1,a2
-;;   and a2,a0,a1
-;;   or a4,a4,a2
-;;   lw a0,0(a4)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 2777fe37070d..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   udf##trap_code=heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 32123e5ef387..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;; block0:
-;;   lui a3,65536
-;;   addi a4,a3,-1
-;;   ugt a4,a0,a4##ty=i64
-;;   ld a3,0(a2)
-;;   add a3,a3,a0
-;;   li a5,0
-;;   sltu a4,zero,a4
-;;   sub a0,zero,a4
-;;   and a2,a5,a0
-;;   not a4,a0
-;;   and a0,a3,a4
-;;   or a2,a2,a0
-;;   sb a1,0(a2)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   lui a2,65536
-;;   addi a4,a2,-1
-;;   ugt a4,a0,a4##ty=i64
-;;   ld a3,0(a1)
-;;   add a3,a3,a0
-;;   li a5,0
-;;   sltu a4,zero,a4
-;;   sub a0,zero,a4
-;;   and a2,a5,a0
-;;   not a4,a0
-;;   and a0,a3,a4
-;;   or a2,a2,a0
-;;   lbu a0,0(a2)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 5c5b2fa6d655..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;; block0:
-;;   lui a4,65535
-;;   addi a3,a4,-1
-;;   ugt a5,a0,a3##ty=i64
-;;   ld a2,0(a2)
-;;   add a0,a2,a0
-;;   lui a2,1
-;;   add a0,a0,a2
-;;   li a2,0
-;;   sltu a3,zero,a5
-;;   sub a3,zero,a3
-;;   and a4,a2,a3
-;;   not a2,a3
-;;   and a2,a0,a2
-;;   or a4,a4,a2
-;;   sb a1,0(a4)
-;;   j label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   lui a4,65535
-;;   addi a2,a4,-1
-;;   ugt a5,a0,a2##ty=i64
-;;   ld a1,0(a1)
-;;   add a0,a1,a0
-;;   lui a1,1
-;;   add a0,a0,a1
-;;   li a1,0
-;;   sltu a2,zero,a5
-;;   sub a2,zero,a2
-;;   and a4,a1,a2
-;;   not a1,a2
-;;   and a2,a0,a1
-;;   or a4,a4,a2
-;;   lbu a0,0(a4)
-;;   j label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index b0c522984d0f..000000000000
--- a/cranelift/filetests/filetests/isa/riscv64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "riscv64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;; block0:
-;;   udf##trap_code=heap_oob
-;;
-;; function u0:1:
-;; block0:
-;;   udf##trap_code=heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/riscv64/zca.clif b/cranelift/filetests/filetests/isa/riscv64/zca.clif
index 4726ec5d488d..69b31eb2f9d7 100644
--- a/cranelift/filetests/filetests/isa/riscv64/zca.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/zca.clif
@@ -163,9 +163,8 @@ block0(v0: i8, v1: i8, v2: i8):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   andi a4, a0, 0xff
-;   beqz a4, 8
 ;   c.mv a0, a1
-;   c.j 4
+;   bnez a4, 6
 ;   c.mv a0, a2
 ;   c.jr ra
 
@@ -178,13 +177,13 @@ block0(v0: i8):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
 ; block0:
-;   load_sym a2,%callee_i8+0
-;   return_call_ind a2 old_stack_arg_size:0 new_stack_arg_size:0 s1=s1
+;   load_sym t0,%callee_i8+0
+;   return_call_ind t0 new_stack_arg_size:0 a0=a0
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
@@ -193,18 +192,17 @@ block0(v0: i8):
 ;   c.sdsp s0, 0(sp)
 ;   c.mv s0, sp
 ; block1: ; offset 0x8
-;   auipc a2, 0
-;   ld a2, 0xa(a2)
+;   auipc t0, 0
+;   ld t0, 0xa(t0)
 ;   c.j 0xa
 ;   c.unimp ; reloc_external Abs8 %callee_i8 0
 ;   c.unimp
 ;   c.unimp
 ;   c.unimp
-;   ld ra, 8(s0)
-;   ld t6, 0(s0)
-;   addi sp, s0, 0x10
-;   c.mv s0, t6
-;   c.jr a2
+;   c.ldsp ra, 8(sp)
+;   c.ldsp s0, 0(sp)
+;   c.addi16sp sp, 0x10
+;   c.jr t0
 
 function %c_ret(i32) -> i32 {
 block0(v0: i32):
@@ -228,7 +226,7 @@ block0(v0: i64, v1: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
@@ -236,7 +234,7 @@ block0(v0: i64, v1: i64):
 ;   callind a1
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -356,17 +354,17 @@ block0:
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   add sp,-16
+;   addi sp,sp,-16
 ; block0:
-;   load_addr a0,0(nominal_sp)
-;   add sp,+16
+;   load_addr a0,0(slot)
+;   addi sp,sp,16
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -432,26 +430,91 @@ block0(v0: i64):
 ;   c.srli a0, 0x14
 ;   c.jr ra
 
-function %c_addi4spn() -> i64 {
-  ss0 = explicit_slot 64
+function %c_addi4spn() -> i64, i64, i64, i64, i64 {
+  ss0 = explicit_slot 2048
 
 block0:
-  v0 = stack_addr.i64 ss0+24
-  return v0
+  v0 = stack_addr.i64 ss0+1020
+  v1 = stack_addr.i64 ss0+4
+  v2 = stack_addr.i64 ss0+512
+  v4 = stack_addr.i64 ss0+256
+  v5 = stack_addr.i64 ss0+64
+  return v0, v1, v2, v4, v5
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+;   addi sp,sp,-2048
+; block0:
+;   load_addr a2,1020(slot)
+;   load_addr a1,4(slot)
+;   load_addr a3,512(slot)
+;   load_addr a4,256(slot)
+;   load_addr a5,64(slot)
+;   sd a3,0(a0)
+;   sd a4,8(a0)
+;   sd a5,16(a0)
+;   mv a0,a2
+;   lui t6,1
+;   addi t6,t6,-2048
+;   add sp,sp,t6
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   c.addi16sp sp, -0x10
+;   c.sdsp ra, 8(sp)
+;   c.sdsp s0, 0(sp)
+;   c.mv s0, sp
+;   addi sp, sp, -0x800
+; block1: ; offset 0xc
+;   c.addi4spn a2, sp, 0x3fc
+;   c.addi4spn a1, sp, 4
+;   c.addi4spn a3, sp, 0x200
+;   c.addi4spn a4, sp, 0x100
+;   c.addi4spn a5, sp, 0x40
+;   c.sd a3, 0(a0)
+;   c.sd a4, 8(a0)
+;   c.sd a5, 0x10(a0)
+;   c.mv a0, a2
+;   c.lui t6, 1
+;   addi t6, t6, -0x800
+;   c.add sp, t6
+;   c.ldsp ra, 8(sp)
+;   c.ldsp s0, 0(sp)
+;   c.addi16sp sp, 0x10
+;   c.jr ra
+
+function %out_of_bounds_c_addi4spn() -> i64, i64 {
+  ss0 = explicit_slot 2048
+
+block0:
+  v0 = stack_addr.i64 ss0+1024
+  v1 = stack_addr.i64 ss0+0
+  return v0, v1
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   add sp,-64
+;   addi sp,sp,-2048
 ; block0:
-;   load_addr a0,24(nominal_sp)
-;   add sp,+64
+;   load_addr a0,1024(slot)
+;   load_addr a1,0(slot)
+;   lui t6,1
+;   addi t6,t6,-2048
+;   add sp,sp,t6
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -460,31 +523,90 @@ block0:
 ;   c.sdsp ra, 8(sp)
 ;   c.sdsp s0, 0(sp)
 ;   c.mv s0, sp
-;   c.addi16sp sp, -0x40
-; block1: ; offset 0xa
-;   c.addi4spn a0, sp, 0x18
-;   c.addi16sp sp, 0x40
+;   addi sp, sp, -0x800
+; block1: ; offset 0xc
+;   addi a0, sp, 0x400
+;   c.mv a1, sp
+;   c.lui t6, 1
+;   addi t6, t6, -0x800
+;   c.add sp, t6
 ;   c.ldsp ra, 8(sp)
 ;   c.ldsp s0, 0(sp)
 ;   c.addi16sp sp, 0x10
 ;   c.jr ra
 
-function %c_li() -> i64 {
+function %c_addi4spn_512() -> i64 {
+  ss0 = explicit_slot 1024
+
 block0:
-  v0 = iconst.i64 1
+  v0 = stack_addr.i64 ss0+512
   return v0
 }
 
 ; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+;   addi sp,sp,-1024
 ; block0:
-;   li a0,1
+;   load_addr a0,512(slot)
+;   addi sp,sp,1024
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   c.li a0, 1
+;   c.addi16sp sp, -0x10
+;   c.sdsp ra, 8(sp)
+;   c.sdsp s0, 0(sp)
+;   c.mv s0, sp
+;   addi sp, sp, -0x400
+; block1: ; offset 0xc
+;   c.addi4spn a0, sp, 0x200
+;   addi sp, sp, 0x400
+;   c.ldsp ra, 8(sp)
+;   c.ldsp s0, 0(sp)
+;   c.addi16sp sp, 0x10
 ;   c.jr ra
 
+function %c_li() -> i64, i64, i64, i64, i64 {
+block0:
+  v0 = iconst.i64 0
+  v1 = iconst.i64 1
+  v2 = iconst.i64 -1
+  v3 = iconst.i64 -32
+  v4 = iconst.i64 31
+  return v0, v1, v2, v3, v4
+}
+
+; VCode:
+; block0:
+;   li a2,0
+;   li a1,1
+;   li a3,-1
+;   li a4,-32
+;   li a5,31
+;   sd a3,0(a0)
+;   sd a4,8(a0)
+;   sd a5,16(a0)
+;   mv a0,a2
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   c.li a2, 0
+;   c.li a1, 1
+;   c.li a3, -1
+;   c.li a4, -0x20
+;   c.li a5, 0x1f
+;   c.sd a3, 0(a0)
+;   c.sd a4, 8(a0)
+;   c.sd a5, 0x10(a0)
+;   c.mv a0, a2
+;   c.jr ra
 
 function %c_lui() -> i64, i64, i64 {
 block0:
@@ -569,17 +691,17 @@ block0:
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   add sp,-16
+;   addi sp,sp,-16
 ; block0:
-;   lw a0,12(nominal_sp)
-;   add sp,+16
+;   lw a0,12(slot)
+;   addi sp,sp,16
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -606,17 +728,17 @@ block0:
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   add sp,-128
+;   addi sp,sp,-128
 ; block0:
-;   ld a0,64(nominal_sp)
-;   add sp,+128
+;   ld a0,64(slot)
+;   addi sp,sp,128
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -643,17 +765,17 @@ block0(v0: i32):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   add sp,-16
+;   addi sp,sp,-16
 ; block0:
-;   sw a0,12(nominal_sp)
-;   add sp,+16
+;   sw a0,12(slot)
+;   addi sp,sp,16
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -680,17 +802,17 @@ block0(v0: i64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   add sp,-128
+;   addi sp,sp,-128
 ; block0:
-;   sd a0,64(nominal_sp)
-;   add sp,+128
+;   sd a0,64(slot)
+;   addi sp,sp,128
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -708,7 +830,6 @@ block0(v0: i64):
 ;   c.addi16sp sp, 0x10
 ;   c.jr ra
 
-
 function %c_sw(i64, i32) {
 block0(v0: i64, v1: i32):
   store.i32 v1, v0+12
@@ -724,8 +845,8 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   c.sw a1, 0xc(a0)
-;   sw a1, -0xc(a0)
+;   c.sw a1, 0xc(a0) ; trap: heap_oob
+;   sw a1, -0xc(a0) ; trap: heap_oob
 ;   c.jr ra
 
 function %c_sd(i64, i64) {
@@ -743,8 +864,8 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   c.sd a1, 0x10(a0)
-;   sd a1, -0x10(a0)
+;   c.sd a1, 0x10(a0) ; trap: heap_oob
+;   sd a1, -0x10(a0) ; trap: heap_oob
 ;   c.jr ra
 
 function %c_lw(i64) -> i32 {
@@ -760,7 +881,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   c.lw a0, 0x40(a0)
+;   c.lw a0, 0x40(a0) ; trap: heap_oob
 ;   c.jr ra
 
 function %c_ld(i64) -> i64 {
@@ -776,6 +897,22 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   c.ld a0, 0x40(a0)
+;   c.ld a0, 0x40(a0) ; trap: heap_oob
+;   c.jr ra
+
+function %band_reverse(i64, i64) -> i64 {
+block0(v0: i64, v1: i64):
+    v2 = band v1, v0
+    return v2
+}
+
+; VCode:
+; block0:
+;   and a0,a1,a0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   c.and a0, a1
 ;   c.jr ra
 
diff --git a/cranelift/filetests/filetests/isa/riscv64/zcb.clif b/cranelift/filetests/filetests/isa/riscv64/zcb.clif
index 76c68310c209..c5f73c1f725a 100644
--- a/cranelift/filetests/filetests/isa/riscv64/zcb.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/zcb.clif
@@ -127,17 +127,15 @@ block0(v0: i64):
 ; VCode:
 ; block0:
 ;   lbu a3,0(a0)
-;   mv a4,a3
 ;   lbu a1,3(a0)
-;   mv a0,a4
+;   mv a0,a3
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0x14, 0x81
-;   c.mv a4, a3
-;   .byte 0x6c, 0x81
-;   c.mv a0, a4
+;   .byte 0x14, 0x81 ; trap: heap_oob
+;   .byte 0x6c, 0x81 ; trap: heap_oob
+;   c.mv a0, a3
 ;   c.jr ra
 
 function %c_lhu(i64) -> i32, i64 {
@@ -150,17 +148,15 @@ block0(v0: i64):
 ; VCode:
 ; block0:
 ;   lhu a3,0(a0)
-;   mv a4,a3
 ;   lhu a1,2(a0)
-;   mv a0,a4
+;   mv a0,a3
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0x14, 0x85
-;   c.mv a4, a3
-;   .byte 0x2c, 0x85
-;   c.mv a0, a4
+;   .byte 0x14, 0x85 ; trap: heap_oob
+;   .byte 0x2c, 0x85 ; trap: heap_oob
+;   c.mv a0, a3
 ;   c.jr ra
 
 function %c_lh(i64) -> i16, i16 {
@@ -173,20 +169,17 @@ block0(v0: i64):
 ; VCode:
 ; block0:
 ;   lh a3,0(a0)
-;   mv a4,a3
 ;   lh a1,2(a0)
-;   mv a0,a4
+;   mv a0,a3
 ;   ret
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0x54, 0x85
-;   c.mv a4, a3
-;   .byte 0x6c, 0x85
-;   c.mv a0, a4
+;   .byte 0x54, 0x85 ; trap: heap_oob
+;   .byte 0x6c, 0x85 ; trap: heap_oob
+;   c.mv a0, a3
 ;   c.jr ra
 
-
 function %c_sb(i64, i8) {
 block0(v0: i64, v1: i8):
   store.i8 v1, v0+0
@@ -208,11 +201,11 @@ block0(v0: i64, v1: i8):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0x0c, 0x89
-;   .byte 0x4c, 0x89
-;   .byte 0x2c, 0x89
-;   .byte 0x6c, 0x89
-;   sb a1, 4(a0)
+;   .byte 0x0c, 0x89 ; trap: heap_oob
+;   .byte 0x4c, 0x89 ; trap: heap_oob
+;   .byte 0x2c, 0x89 ; trap: heap_oob
+;   .byte 0x6c, 0x89 ; trap: heap_oob
+;   sb a1, 4(a0) ; trap: heap_oob
 ;   c.jr ra
 
 function %c_sh(i64, i16) {
@@ -232,8 +225,96 @@ block0(v0: i64, v1: i16):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0x0c, 0x8d
-;   .byte 0x2c, 0x8d
-;   sh a1, 3(a0)
+;   .byte 0x0c, 0x8d ; trap: heap_oob
+;   .byte 0x2c, 0x8d ; trap: heap_oob
+;   sh a1, 3(a0) ; trap: heap_oob
+;   c.jr ra
+
+function %no_compress_store_zero(i64) {
+    ss1 = explicit_slot 1
+    ss2 = explicit_slot 2
+    ss4 = explicit_slot 4
+    ss8 = explicit_slot 8
+block0(v0: i64):
+  v1 = iconst.i8 0
+  store.i8 notrap v1, v0
+  stack_store.i8 v1, ss1
+
+  v2 = iconst.i16 0
+  store.i16 notrap v2, v0
+  stack_store.i16 v2, ss2
+
+  v3 = iconst.i32 0
+  store.i32 notrap v3, v0
+  stack_store.i32 v3, ss4
+
+  v4 = iconst.i64 0
+  store.i64 notrap v4, v0
+  stack_store.i64 v4, ss8
+
+  v5 = f32const 0.0
+  store.f32 notrap v5, v0
+  stack_store.f32 v5, ss4
+
+  v6 = f64const 0.0
+  store.f64 notrap v6, v0
+  stack_store.f64 v6, ss8
+
+  return
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+;   addi sp,sp,-32
+; block0:
+;   sb zero,0(a0)
+;   sb zero,0(slot)
+;   sh zero,0(a0)
+;   sh zero,8(slot)
+;   sw zero,0(a0)
+;   sw zero,16(slot)
+;   sd zero,0(a0)
+;   sd zero,24(slot)
+;   fmv.w.x fa5,zero
+;   fsw fa5,0(a0)
+;   fsw fa5,16(slot)
+;   fmv.d.x fa1,zero
+;   fsd fa1,0(a0)
+;   fsd fa1,24(slot)
+;   addi sp,sp,32
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   c.addi16sp sp, -0x10
+;   c.sdsp ra, 8(sp)
+;   c.sdsp s0, 0(sp)
+;   c.mv s0, sp
+;   c.addi16sp sp, -0x20
+; block1: ; offset 0xa
+;   sb zero, 0(a0)
+;   sb zero, 0(sp)
+;   sh zero, 0(a0)
+;   sh zero, 8(sp)
+;   sw zero, 0(a0)
+;   c.swsp zero, 0x10(sp)
+;   sd zero, 0(a0)
+;   c.sdsp zero, 0x18(sp)
+;   fmv.w.x fa5, zero
+;   fsw fa5, 0(a0)
+;   fsw fa5, 0x10(sp)
+;   fmv.d.x fa1, zero
+;   fsd fa1, 0(a0)
+;   fsd fa1, 0x18(sp)
+;   c.addi16sp sp, 0x20
+;   c.ldsp ra, 8(sp)
+;   c.ldsp s0, 0(sp)
+;   c.addi16sp sp, 0x10
 ;   c.jr ra
 
diff --git a/cranelift/filetests/filetests/isa/riscv64/zcd.clif b/cranelift/filetests/filetests/isa/riscv64/zcd.clif
index f67537775f74..360ac48d146f 100644
--- a/cranelift/filetests/filetests/isa/riscv64/zcd.clif
+++ b/cranelift/filetests/filetests/isa/riscv64/zcd.clif
@@ -11,17 +11,17 @@ block0:
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   add sp,-16
+;   addi sp,sp,-16
 ; block0:
-;   fld fa0,8(nominal_sp)
-;   add sp,+16
+;   fld fa0,8(slot)
+;   addi sp,sp,16
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -48,17 +48,17 @@ block0(v0: f64):
 }
 
 ; VCode:
-;   add sp,-16
+;   addi sp,sp,-16
 ;   sd ra,8(sp)
 ;   sd fp,0(sp)
 ;   mv fp,sp
-;   add sp,-128
+;   addi sp,sp,-128
 ; block0:
-;   fsd fa0,64(nominal_sp)
-;   add sp,+128
+;   fsd fa0,64(slot)
+;   addi sp,sp,128
 ;   ld ra,8(sp)
 ;   ld fp,0(sp)
-;   add sp,+16
+;   addi sp,sp,16
 ;   ret
 ;
 ; Disassembled:
@@ -76,7 +76,6 @@ block0(v0: f64):
 ;   c.addi16sp sp, 0x10
 ;   c.jr ra
 
-
 function %c_fsd(i64, f64) {
 block0(v0: i64, v1: f64):
   store.i32 v1, v0+16
@@ -92,8 +91,8 @@ block0(v0: i64, v1: f64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   c.fsd fa0, 0x10(a0)
-;   fsd fa0, -0x10(a0)
+;   c.fsd fa0, 0x10(a0) ; trap: heap_oob
+;   fsd fa0, -0x10(a0) ; trap: heap_oob
 ;   c.jr ra
 
 function %c_fld(i64) -> f64 {
@@ -109,6 +108,6 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   c.fld fa0, 0x40(a0)
+;   c.fld fa0, 0x40(a0) ; trap: heap_oob
 ;   c.jr ra
 
diff --git a/cranelift/filetests/filetests/isa/riscv64/zfa.clif b/cranelift/filetests/filetests/isa/riscv64/zfa.clif
new file mode 100644
index 000000000000..4c3345bb5fa8
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/zfa.clif
@@ -0,0 +1,673 @@
+test compile precise-output
+set unwind_info=false
+target riscv64 has_zfa
+
+
+function %fminm_s(f32, f32) -> f32 {
+block0(v0: f32, v1: f32):
+  v2 = fmin.f32 v0, v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   fminm.s fa0,fa0,fa1,rdn
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x53, 0x25, 0xb5, 0x28
+;   ret
+
+
+function %fminm_d(f64, f64) -> f64 {
+block0(v0: f64, v1: f64):
+  v2 = fmin.f64 v0, v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   fminm.d fa0,fa0,fa1,rdn
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x53, 0x25, 0xb5, 0x2a
+;   ret
+
+function %fmaxm_s(f32, f32) -> f32 {
+block0(v0: f32, v1: f32):
+  v2 = fmax.f32 v0, v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   fmaxm.s fa0,fa0,fa1,rup
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x53, 0x35, 0xb5, 0x28
+;   ret
+
+function %fmaxm_d(f64, f64) -> f64 {
+block0(v0: f64, v1: f64):
+  v2 = fmax.f64 v0, v1
+  return v2
+}
+
+; VCode:
+; block0:
+;   fmaxm.d fa0,fa0,fa1,rup
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x53, 0x35, 0xb5, 0x2a
+;   ret
+
+
+
+function %ceil_f32(f32) -> f32 {
+block0(v0: f32):
+  v1 = ceil v0
+  return v1
+}
+
+; VCode:
+; block0:
+;   fround.s fa0,fa0,rup
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x53, 0x35, 0x45, 0x40
+;   ret
+
+
+function %ceil_f64(f64) -> f64 {
+block0(v0: f64):
+  v1 = ceil v0
+  return v1
+}
+
+; VCode:
+; block0:
+;   fround.d fa0,fa0,rup
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x53, 0x35, 0x45, 0x42
+;   ret
+
+
+function %floor_f32(f32) -> f32 {
+block0(v0: f32):
+  v1 = floor v0
+  return v1
+}
+
+; VCode:
+; block0:
+;   fround.s fa0,fa0,rdn
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x53, 0x25, 0x45, 0x40
+;   ret
+
+
+function %floor_f64(f64) -> f64 {
+block0(v0: f64):
+  v1 = floor v0
+  return v1
+}
+
+; VCode:
+; block0:
+;   fround.d fa0,fa0,rdn
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x53, 0x25, 0x45, 0x42
+;   ret
+
+
+function %trunc_f32(f32) -> f32 {
+block0(v0: f32):
+  v1 = trunc v0
+  return v1
+}
+
+; VCode:
+; block0:
+;   fround.s fa0,fa0,rtz
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x53, 0x15, 0x45, 0x40
+;   ret
+
+
+function %trunc_f64(f64) -> f64 {
+block0(v0: f64):
+  v1 = trunc v0
+  return v1
+}
+
+; VCode:
+; block0:
+;   fround.d fa0,fa0,rtz
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x53, 0x15, 0x45, 0x42
+;   ret
+
+
+function %nearest_f32(f32) -> f32 {
+block0(v0: f32):
+  v1 = nearest v0
+  return v1
+}
+
+; VCode:
+; block0:
+;   fround.s fa0,fa0,rne
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x53, 0x05, 0x45, 0x40
+;   ret
+
+
+function %nearest_f64(f64) -> f64 {
+block0(v0: f64):
+  v1 = nearest v0
+  return v1
+}
+
+; VCode:
+; block0:
+;   fround.d fa0,fa0,rne
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x53, 0x05, 0x45, 0x42
+;   ret
+
+
+function %fli_s() -> f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32 {
+block0:
+    v0 = f32const -0x1.p0
+    v1 = f32const 0x1.p-126
+    v2 = f32const 0x1.p-16
+    v3 = f32const 0x1.p-15
+    v4 = f32const 0x1.p-8
+    v5 = f32const 0x1.p-7
+    v6 = f32const 0x1.p-4
+    v7 = f32const 0x1.p-3
+    v8 = f32const 0x1.p-2
+    v9 = f32const 0x1.4p-2
+    v10 = f32const 0x1.8p-2
+    v11 = f32const 0x1.cp-2
+    v12 = f32const 0x1.p-1
+    v13 = f32const 0x1.4p-1
+    v14 = f32const 0x1.8p-1
+    v15 = f32const 0x1.cp-1
+    v16 = f32const 0x1.p0
+    v17 = f32const 0x1.4p0
+    v18 = f32const 0x1.8p0
+    v19 = f32const 0x1.cp0
+    v20 = f32const 0x1.p1
+    v21 = f32const 0x1.4p1
+    v22 = f32const 0x1.8p1
+    v23 = f32const 0x1.p2
+    v24 = f32const 0x1.p3
+    v25 = f32const 0x1.p4
+    v26 = f32const 0x1.p7
+    v27 = f32const 0x1.p8
+    v28 = f32const 0x1.p15
+    v29 = f32const 0x1.p16
+    v30 = f32const +Inf
+    v31 = f32const +NaN
+
+    return v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+;   addi sp,sp,-96
+;   fsd fs0,88(sp)
+;   fsd fs2,80(sp)
+;   fsd fs3,72(sp)
+;   fsd fs4,64(sp)
+;   fsd fs5,56(sp)
+;   fsd fs6,48(sp)
+;   fsd fs7,40(sp)
+;   fsd fs8,32(sp)
+;   fsd fs9,24(sp)
+;   fsd fs10,16(sp)
+;   fsd fs11,8(sp)
+; block0:
+;   fli.s fa0,-1.0
+;   fli.s fa1,min
+;   fli.s fa3,2^-16
+;   fli.s fa4,2^-15
+;   fli.s fa5,2^-8
+;   fli.s fa2,2^-7
+;   fli.s ft7,0.0625
+;   fli.s fa6,0.125
+;   fli.s fa7,0.25
+;   fli.s ft8,0.3125
+;   fli.s ft9,0.375
+;   fli.s ft10,0.4375
+;   fli.s ft11,0.5
+;   fli.s fs0,0.625
+;   fli.s fs1,0.75
+;   fli.s fs2,0.875
+;   fli.s fs3,1.0
+;   fli.s fs4,1.25
+;   fli.s fs5,1.5
+;   fli.s fs6,1.75
+;   fli.s fs7,2.0
+;   fli.s fs8,2.5
+;   fli.s fs9,3.0
+;   fli.s fs10,4.0
+;   fli.s fs11,8.0
+;   fli.s ft0,16.0
+;   fli.s ft1,128.0
+;   fli.s ft2,256.0
+;   fli.s ft3,32768.0
+;   fli.s ft4,65536.0
+;   fli.s ft5,inf
+;   fli.s ft6,nan
+;   fsw fa3,0(a0)
+;   fsw fa4,8(a0)
+;   fsw fa5,16(a0)
+;   fsw fa2,24(a0)
+;   fsw ft7,32(a0)
+;   fsw fa6,40(a0)
+;   fsw fa7,48(a0)
+;   fsw ft8,56(a0)
+;   fsw ft9,64(a0)
+;   fsw ft10,72(a0)
+;   fsw ft11,80(a0)
+;   fsw fs0,88(a0)
+;   fsw fs1,96(a0)
+;   fsw fs2,104(a0)
+;   fsw fs3,112(a0)
+;   fsw fs4,120(a0)
+;   fsw fs5,128(a0)
+;   fsw fs6,136(a0)
+;   fsw fs7,144(a0)
+;   fsw fs8,152(a0)
+;   fsw fs9,160(a0)
+;   fsw fs10,168(a0)
+;   fsw fs11,176(a0)
+;   fsw ft0,184(a0)
+;   fsw ft1,192(a0)
+;   fsw ft2,200(a0)
+;   fsw ft3,208(a0)
+;   fsw ft4,216(a0)
+;   fsw ft5,224(a0)
+;   fsw ft6,232(a0)
+;   fld fs0,88(sp)
+;   fld fs2,80(sp)
+;   fld fs3,72(sp)
+;   fld fs4,64(sp)
+;   fld fs5,56(sp)
+;   fld fs6,48(sp)
+;   fld fs7,40(sp)
+;   fld fs8,32(sp)
+;   fld fs9,24(sp)
+;   fld fs10,16(sp)
+;   fld fs11,8(sp)
+;   addi sp,sp,96
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+;   addi sp, sp, -0x60
+;   fsd fs0, 0x58(sp)
+;   fsd fs2, 0x50(sp)
+;   fsd fs3, 0x48(sp)
+;   fsd fs4, 0x40(sp)
+;   fsd fs5, 0x38(sp)
+;   fsd fs6, 0x30(sp)
+;   fsd fs7, 0x28(sp)
+;   fsd fs8, 0x20(sp)
+;   fsd fs9, 0x18(sp)
+;   fsd fs10, 0x10(sp)
+;   fsd fs11, 8(sp)
+; block1: ; offset 0x40
+;   .byte 0x53, 0x05, 0x10, 0xf0
+;   .byte 0xd3, 0x85, 0x10, 0xf0
+;   .byte 0xd3, 0x06, 0x11, 0xf0
+;   .byte 0x53, 0x87, 0x11, 0xf0
+;   .byte 0xd3, 0x07, 0x12, 0xf0
+;   .byte 0x53, 0x86, 0x12, 0xf0
+;   .byte 0xd3, 0x03, 0x13, 0xf0
+;   .byte 0x53, 0x88, 0x13, 0xf0
+;   .byte 0xd3, 0x08, 0x14, 0xf0
+;   .byte 0x53, 0x8e, 0x14, 0xf0
+;   .byte 0xd3, 0x0e, 0x15, 0xf0
+;   .byte 0x53, 0x8f, 0x15, 0xf0
+;   .byte 0xd3, 0x0f, 0x16, 0xf0
+;   .byte 0x53, 0x84, 0x16, 0xf0
+;   .byte 0xd3, 0x04, 0x17, 0xf0
+;   .byte 0x53, 0x89, 0x17, 0xf0
+;   .byte 0xd3, 0x09, 0x18, 0xf0
+;   .byte 0x53, 0x8a, 0x18, 0xf0
+;   .byte 0xd3, 0x0a, 0x19, 0xf0
+;   .byte 0x53, 0x8b, 0x19, 0xf0
+;   .byte 0xd3, 0x0b, 0x1a, 0xf0
+;   .byte 0x53, 0x8c, 0x1a, 0xf0
+;   .byte 0xd3, 0x0c, 0x1b, 0xf0
+;   .byte 0x53, 0x8d, 0x1b, 0xf0
+;   .byte 0xd3, 0x0d, 0x1c, 0xf0
+;   .byte 0x53, 0x80, 0x1c, 0xf0
+;   .byte 0xd3, 0x00, 0x1d, 0xf0
+;   .byte 0x53, 0x81, 0x1d, 0xf0
+;   .byte 0xd3, 0x01, 0x1e, 0xf0
+;   .byte 0x53, 0x82, 0x1e, 0xf0
+;   .byte 0xd3, 0x02, 0x1f, 0xf0
+;   .byte 0x53, 0x83, 0x1f, 0xf0
+;   fsw fa3, 0(a0)
+;   fsw fa4, 8(a0)
+;   fsw fa5, 0x10(a0)
+;   fsw fa2, 0x18(a0)
+;   fsw ft7, 0x20(a0)
+;   fsw fa6, 0x28(a0)
+;   fsw fa7, 0x30(a0)
+;   fsw ft8, 0x38(a0)
+;   fsw ft9, 0x40(a0)
+;   fsw ft10, 0x48(a0)
+;   fsw ft11, 0x50(a0)
+;   fsw fs0, 0x58(a0)
+;   fsw fs1, 0x60(a0)
+;   fsw fs2, 0x68(a0)
+;   fsw fs3, 0x70(a0)
+;   fsw fs4, 0x78(a0)
+;   fsw fs5, 0x80(a0)
+;   fsw fs6, 0x88(a0)
+;   fsw fs7, 0x90(a0)
+;   fsw fs8, 0x98(a0)
+;   fsw fs9, 0xa0(a0)
+;   fsw fs10, 0xa8(a0)
+;   fsw fs11, 0xb0(a0)
+;   fsw ft0, 0xb8(a0)
+;   fsw ft1, 0xc0(a0)
+;   fsw ft2, 0xc8(a0)
+;   fsw ft3, 0xd0(a0)
+;   fsw ft4, 0xd8(a0)
+;   fsw ft5, 0xe0(a0)
+;   fsw ft6, 0xe8(a0)
+;   fld fs0, 0x58(sp)
+;   fld fs2, 0x50(sp)
+;   fld fs3, 0x48(sp)
+;   fld fs4, 0x40(sp)
+;   fld fs5, 0x38(sp)
+;   fld fs6, 0x30(sp)
+;   fld fs7, 0x28(sp)
+;   fld fs8, 0x20(sp)
+;   fld fs9, 0x18(sp)
+;   fld fs10, 0x10(sp)
+;   fld fs11, 8(sp)
+;   addi sp, sp, 0x60
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   ret
+
+function %fli_d() -> f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64 {
+block0:
+    v0 = f64const -0x1.p0
+    v1 = f64const 0x1.p-1022
+    v2 = f64const 0x1.p-16
+    v3 = f64const 0x1.p-15
+    v4 = f64const 0x1.p-8
+    v5 = f64const 0x1.p-7
+    v6 = f64const 0x1.p-4
+    v7 = f64const 0x1.p-3
+    v8 = f64const 0x1.p-2
+    v9 = f64const 0x1.4p-2
+    v10 = f64const 0x1.8p-2
+    v11 = f64const 0x1.cp-2
+    v12 = f64const 0x1.p-1
+    v13 = f64const 0x1.4p-1
+    v14 = f64const 0x1.8p-1
+    v15 = f64const 0x1.cp-1
+    v16 = f64const 0x1.p0
+    v17 = f64const 0x1.4p0
+    v18 = f64const 0x1.8p0
+    v19 = f64const 0x1.cp0
+    v20 = f64const 0x1.p1
+    v21 = f64const 0x1.4p1
+    v22 = f64const 0x1.8p1
+    v23 = f64const 0x1.p2
+    v24 = f64const 0x1.p3
+    v25 = f64const 0x1.p4
+    v26 = f64const 0x1.p7
+    v27 = f64const 0x1.p8
+    v28 = f64const 0x1.p15
+    v29 = f64const 0x1.p16
+    v30 = f64const +Inf
+    v31 = f64const +NaN
+    return v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31
+}
+
+; VCode:
+;   addi sp,sp,-16
+;   sd ra,8(sp)
+;   sd fp,0(sp)
+;   mv fp,sp
+;   addi sp,sp,-96
+;   fsd fs0,88(sp)
+;   fsd fs2,80(sp)
+;   fsd fs3,72(sp)
+;   fsd fs4,64(sp)
+;   fsd fs5,56(sp)
+;   fsd fs6,48(sp)
+;   fsd fs7,40(sp)
+;   fsd fs8,32(sp)
+;   fsd fs9,24(sp)
+;   fsd fs10,16(sp)
+;   fsd fs11,8(sp)
+; block0:
+;   fli.d fa0,-1.0
+;   fli.d fa1,min
+;   fli.d fa3,2^-16
+;   fli.d fa4,2^-15
+;   fli.d fa5,2^-8
+;   fli.d fa2,2^-7
+;   fli.d ft7,0.0625
+;   fli.d fa6,0.125
+;   fli.d fa7,0.25
+;   fli.d ft8,0.3125
+;   fli.d ft9,0.375
+;   fli.d ft10,0.4375
+;   fli.d ft11,0.5
+;   fli.d fs0,0.625
+;   fli.d fs1,0.75
+;   fli.d fs2,0.875
+;   fli.d fs3,1.0
+;   fli.d fs4,1.25
+;   fli.d fs5,1.5
+;   fli.d fs6,1.75
+;   fli.d fs7,2.0
+;   fli.d fs8,2.5
+;   fli.d fs9,3.0
+;   fli.d fs10,4.0
+;   fli.d fs11,8.0
+;   fli.d ft0,16.0
+;   fli.d ft1,128.0
+;   fli.d ft2,256.0
+;   fli.d ft3,32768.0
+;   fli.d ft4,65536.0
+;   fli.d ft5,inf
+;   fli.d ft6,nan
+;   fsd fa3,0(a0)
+;   fsd fa4,8(a0)
+;   fsd fa5,16(a0)
+;   fsd fa2,24(a0)
+;   fsd ft7,32(a0)
+;   fsd fa6,40(a0)
+;   fsd fa7,48(a0)
+;   fsd ft8,56(a0)
+;   fsd ft9,64(a0)
+;   fsd ft10,72(a0)
+;   fsd ft11,80(a0)
+;   fsd fs0,88(a0)
+;   fsd fs1,96(a0)
+;   fsd fs2,104(a0)
+;   fsd fs3,112(a0)
+;   fsd fs4,120(a0)
+;   fsd fs5,128(a0)
+;   fsd fs6,136(a0)
+;   fsd fs7,144(a0)
+;   fsd fs8,152(a0)
+;   fsd fs9,160(a0)
+;   fsd fs10,168(a0)
+;   fsd fs11,176(a0)
+;   fsd ft0,184(a0)
+;   fsd ft1,192(a0)
+;   fsd ft2,200(a0)
+;   fsd ft3,208(a0)
+;   fsd ft4,216(a0)
+;   fsd ft5,224(a0)
+;   fsd ft6,232(a0)
+;   fld fs0,88(sp)
+;   fld fs2,80(sp)
+;   fld fs3,72(sp)
+;   fld fs4,64(sp)
+;   fld fs5,56(sp)
+;   fld fs6,48(sp)
+;   fld fs7,40(sp)
+;   fld fs8,32(sp)
+;   fld fs9,24(sp)
+;   fld fs10,16(sp)
+;   fld fs11,8(sp)
+;   addi sp,sp,96
+;   ld ra,8(sp)
+;   ld fp,0(sp)
+;   addi sp,sp,16
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   addi sp, sp, -0x10
+;   sd ra, 8(sp)
+;   sd s0, 0(sp)
+;   mv s0, sp
+;   addi sp, sp, -0x60
+;   fsd fs0, 0x58(sp)
+;   fsd fs2, 0x50(sp)
+;   fsd fs3, 0x48(sp)
+;   fsd fs4, 0x40(sp)
+;   fsd fs5, 0x38(sp)
+;   fsd fs6, 0x30(sp)
+;   fsd fs7, 0x28(sp)
+;   fsd fs8, 0x20(sp)
+;   fsd fs9, 0x18(sp)
+;   fsd fs10, 0x10(sp)
+;   fsd fs11, 8(sp)
+; block1: ; offset 0x40
+;   .byte 0x53, 0x05, 0x10, 0xf2
+;   .byte 0xd3, 0x85, 0x10, 0xf2
+;   .byte 0xd3, 0x06, 0x11, 0xf2
+;   .byte 0x53, 0x87, 0x11, 0xf2
+;   .byte 0xd3, 0x07, 0x12, 0xf2
+;   .byte 0x53, 0x86, 0x12, 0xf2
+;   .byte 0xd3, 0x03, 0x13, 0xf2
+;   .byte 0x53, 0x88, 0x13, 0xf2
+;   .byte 0xd3, 0x08, 0x14, 0xf2
+;   .byte 0x53, 0x8e, 0x14, 0xf2
+;   .byte 0xd3, 0x0e, 0x15, 0xf2
+;   .byte 0x53, 0x8f, 0x15, 0xf2
+;   .byte 0xd3, 0x0f, 0x16, 0xf2
+;   .byte 0x53, 0x84, 0x16, 0xf2
+;   .byte 0xd3, 0x04, 0x17, 0xf2
+;   .byte 0x53, 0x89, 0x17, 0xf2
+;   .byte 0xd3, 0x09, 0x18, 0xf2
+;   .byte 0x53, 0x8a, 0x18, 0xf2
+;   .byte 0xd3, 0x0a, 0x19, 0xf2
+;   .byte 0x53, 0x8b, 0x19, 0xf2
+;   .byte 0xd3, 0x0b, 0x1a, 0xf2
+;   .byte 0x53, 0x8c, 0x1a, 0xf2
+;   .byte 0xd3, 0x0c, 0x1b, 0xf2
+;   .byte 0x53, 0x8d, 0x1b, 0xf2
+;   .byte 0xd3, 0x0d, 0x1c, 0xf2
+;   .byte 0x53, 0x80, 0x1c, 0xf2
+;   .byte 0xd3, 0x00, 0x1d, 0xf2
+;   .byte 0x53, 0x81, 0x1d, 0xf2
+;   .byte 0xd3, 0x01, 0x1e, 0xf2
+;   .byte 0x53, 0x82, 0x1e, 0xf2
+;   .byte 0xd3, 0x02, 0x1f, 0xf2
+;   .byte 0x53, 0x83, 0x1f, 0xf2
+;   fsd fa3, 0(a0)
+;   fsd fa4, 8(a0)
+;   fsd fa5, 0x10(a0)
+;   fsd fa2, 0x18(a0)
+;   fsd ft7, 0x20(a0)
+;   fsd fa6, 0x28(a0)
+;   fsd fa7, 0x30(a0)
+;   fsd ft8, 0x38(a0)
+;   fsd ft9, 0x40(a0)
+;   fsd ft10, 0x48(a0)
+;   fsd ft11, 0x50(a0)
+;   fsd fs0, 0x58(a0)
+;   fsd fs1, 0x60(a0)
+;   fsd fs2, 0x68(a0)
+;   fsd fs3, 0x70(a0)
+;   fsd fs4, 0x78(a0)
+;   fsd fs5, 0x80(a0)
+;   fsd fs6, 0x88(a0)
+;   fsd fs7, 0x90(a0)
+;   fsd fs8, 0x98(a0)
+;   fsd fs9, 0xa0(a0)
+;   fsd fs10, 0xa8(a0)
+;   fsd fs11, 0xb0(a0)
+;   fsd ft0, 0xb8(a0)
+;   fsd ft1, 0xc0(a0)
+;   fsd ft2, 0xc8(a0)
+;   fsd ft3, 0xd0(a0)
+;   fsd ft4, 0xd8(a0)
+;   fsd ft5, 0xe0(a0)
+;   fsd ft6, 0xe8(a0)
+;   fld fs0, 0x58(sp)
+;   fld fs2, 0x50(sp)
+;   fld fs3, 0x48(sp)
+;   fld fs4, 0x40(sp)
+;   fld fs5, 0x38(sp)
+;   fld fs6, 0x30(sp)
+;   fld fs7, 0x28(sp)
+;   fld fs8, 0x20(sp)
+;   fld fs9, 0x18(sp)
+;   fld fs10, 0x10(sp)
+;   fld fs11, 8(sp)
+;   addi sp, sp, 0x60
+;   ld ra, 8(sp)
+;   ld s0, 0(sp)
+;   addi sp, sp, 0x10
+;   ret
+
diff --git a/cranelift/filetests/filetests/isa/riscv64/zicond.clif b/cranelift/filetests/filetests/isa/riscv64/zicond.clif
new file mode 100644
index 000000000000..00b0c37dd024
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/riscv64/zicond.clif
@@ -0,0 +1,185 @@
+test compile precise-output
+set unwind_info=false
+target riscv64 has_zicond
+
+
+function %select_zero(i64, i64) -> i64 {
+block0(v0: i64, v1: i64):
+  v2 = iconst.i64 0
+  v3 = select.i64 v0, v1, v2
+  return v3
+}
+
+; VCode:
+; block0:
+;   czero.eqz a0,a1,a0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x33, 0xd5, 0xa5, 0x0e
+;   ret
+
+function %select_zero_icmp_neq(i64, i64) -> i64 {
+block0(v0: i64, v1: i64):
+  v2 = iconst.i64 0
+  v3 = icmp.i64 ne v0, v2
+  v4 = select.i64 v3, v1, v2
+  return v4
+}
+
+; VCode:
+; block0:
+;   czero.eqz a0,a1,a0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x33, 0xd5, 0xa5, 0x0e
+;   ret
+
+function %select_zero_icmp_neq_reverse(i64, i64) -> i64 {
+block0(v0: i64, v1: i64):
+  v2 = iconst.i64 0
+  v3 = icmp.i64 ne v2, v0
+  v4 = select.i64 v3, v2, v1
+  return v4
+}
+
+; VCode:
+; block0:
+;   czero.nez a0,a1,a0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x33, 0xf5, 0xa5, 0x0e
+;   ret
+
+function %select_zero_icmp_eqz(i64, i64) -> i64 {
+block0(v0: i64, v1: i64):
+  v2 = iconst.i64 0
+  v3 = icmp.i64 eq v0, v2
+  v4 = select.i64 v3, v1, v2
+  return v4
+}
+
+; VCode:
+; block0:
+;   czero.nez a0,a1,a0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x33, 0xf5, 0xa5, 0x0e
+;   ret
+
+
+function %select_zero_icmp_eqz_reverse(i64, i64) -> i64 {
+block0(v0: i64, v1: i64):
+  v2 = iconst.i64 0
+  v3 = icmp.i64 eq v2, v0
+  v4 = select.i64 v3, v2, v1
+  return v4
+}
+
+; VCode:
+; block0:
+;   czero.eqz a0,a1,a0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x33, 0xd5, 0xa5, 0x0e
+;   ret
+
+
+function %select_icmp_eq_zero(i64, i64, i64) -> i64 {
+block0(v0: i64, v1: i64, v2: i64):
+  v3 = iconst.i64 0
+  v4 = icmp.i64 eq v0, v3
+  v5 = select.i64 v4, v1, v2
+  return v5
+}
+
+; VCode:
+; block0:
+;   czero.nez a4,a1,a0
+;   czero.eqz a0,a2,a0
+;   or a0,a4,a0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x33, 0xf7, 0xa5, 0x0e
+;   .byte 0x33, 0x55, 0xa6, 0x0e
+;   or a0, a4, a0
+;   ret
+
+function %select_icmp_ne_zero(i64, i64, i64) -> i64 {
+block0(v0: i64, v1: i64, v2: i64):
+  v3 = iconst.i64 0
+  v4 = icmp.i64 ne v0, v3
+  v5 = select.i64 v4, v1, v2
+  return v5
+}
+
+; VCode:
+; block0:
+;   czero.eqz a4,a1,a0
+;   czero.nez a0,a2,a0
+;   or a0,a4,a0
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   .byte 0x33, 0xd7, 0xa5, 0x0e
+;   .byte 0x33, 0x75, 0xa6, 0x0e
+;   or a0, a4, a0
+;   ret
+
+
+function %select_icmp_sle(i64, i64, i64, i64) -> i64 {
+block0(v0: i64, v1: i64, v2: i64, v3: i64):
+  v4 = icmp.i64 slt v0, v1
+  v5 = select.i64 v4, v2, v3
+  return v5
+}
+
+; VCode:
+; block0:
+;   slt a5,a0,a1
+;   czero.eqz a1,a2,a5
+;   czero.nez a3,a3,a5
+;   or a0,a1,a3
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   slt a5, a0, a1
+;   .byte 0xb3, 0x55, 0xf6, 0x0e
+;   .byte 0xb3, 0xf6, 0xf6, 0x0e
+;   or a0, a1, a3
+;   ret
+
+;; This can trigger a stack overflow with if the rules don't prevent
+;; this situation.
+function %check_rule_stack_overflow(i64, i64, i64) -> i64 {
+block0(v0: i64, v1: i64, v2: i64):
+  v3 = iconst.i64 0
+  v4 = icmp.i64 ne v3, v3
+  v5 = select.i64 v4, v3, v3
+  return v5
+}
+
+; VCode:
+; block0:
+;   li a1,0
+;   czero.nez a0,a1,zero
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   mv a1, zero
+;   .byte 0x33, 0xf5, 0x05, 0x0e
+;   ret
diff --git a/cranelift/filetests/filetests/isa/s390x/arithmetic.clif b/cranelift/filetests/filetests/isa/s390x/arithmetic.clif
index b1821d01eeb2..a72ea47288ed 100644
--- a/cranelift/filetests/filetests/isa/s390x/arithmetic.clif
+++ b/cranelift/filetests/filetests/isa/s390x/arithmetic.clif
@@ -104,7 +104,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ag %r2, 0(%r3)
+;   ag %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %iadd_i64_mem_ext16(i64, i64) -> i64 {
@@ -121,7 +121,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   agh %r2, 0(%r3)
+;   agh %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %iadd_i64_mem_ext32(i64, i64) -> i64 {
@@ -138,7 +138,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   agf %r2, 0(%r3)
+;   agf %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %iadd_i32(i32, i32) -> i32 {
@@ -205,7 +205,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   a %r2, 0(%r3)
+;   a %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %iadd_i32_memoff(i32, i64) -> i32 {
@@ -222,7 +222,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ay %r2, 0x1000(%r3)
+;   ay %r2, 0x1000(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %iadd_i32_mem_ext16(i32, i64) -> i32 {
@@ -239,7 +239,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ah %r2, 0(%r3)
+;   ah %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %iadd_i32_memoff_ext16(i32, i64) -> i32 {
@@ -256,7 +256,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ahy %r2, 0x1000(%r3)
+;   ahy %r2, 0x1000(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %iadd_i16(i16, i16) -> i16 {
@@ -306,7 +306,7 @@ block0(v0: i16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ah %r2, 0(%r3)
+;   ah %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %iadd_i8(i8, i8) -> i8 {
@@ -357,7 +357,7 @@ block0(v0: i8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llc %r3, 0(%r3)
+;   llc %r3, 0(%r3) ; trap: heap_oob
 ;   ar %r2, %r3
 ;   br %r14
 
@@ -464,7 +464,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sg %r2, 0(%r3)
+;   sg %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %isub_i64_mem_ext16(i64, i64) -> i64 {
@@ -481,7 +481,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sgh %r2, 0(%r3)
+;   sgh %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %isub_i64_mem_ext32(i64, i64) -> i64 {
@@ -498,7 +498,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sgf %r2, 0(%r3)
+;   sgf %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %isub_i32(i32, i32) -> i32 {
@@ -565,7 +565,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   s %r2, 0(%r3)
+;   s %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %isub_i32_memoff(i32, i64) -> i32 {
@@ -582,7 +582,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sy %r2, 0x1000(%r3)
+;   sy %r2, 0x1000(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %isub_i32_mem_ext16(i32, i64) -> i32 {
@@ -599,7 +599,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sh %r2, 0(%r3)
+;   sh %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %isub_i32_memoff_ext16(i32, i64) -> i32 {
@@ -616,7 +616,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   shy %r2, 0x1000(%r3)
+;   shy %r2, 0x1000(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %isub_i16(i16, i16) -> i16 {
@@ -666,7 +666,7 @@ block0(v0: i16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sh %r2, 0(%r3)
+;   sh %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %isub_i8(i8, i8) -> i8 {
@@ -717,7 +717,7 @@ block0(v0: i8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llc %r3, 0(%r3)
+;   llc %r3, 0(%r3) ; trap: heap_oob
 ;   sr %r2, %r3
 ;   br %r14
 
@@ -1052,7 +1052,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   msg %r2, 0(%r3)
+;   msg %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %imul_i64_mem_ext16(i64, i64) -> i64 {
@@ -1069,7 +1069,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mgh %r2, 0(%r3)
+;   mgh %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %imul_i64_mem_ext32(i64, i64) -> i64 {
@@ -1086,7 +1086,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   msgf %r2, 0(%r3)
+;   msgf %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %imul_i32(i32, i32) -> i32 {
@@ -1153,7 +1153,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ms %r2, 0(%r3)
+;   ms %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %imul_i32_memoff(i32, i64) -> i32 {
@@ -1170,7 +1170,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   msy %r2, 0x1000(%r3)
+;   msy %r2, 0x1000(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %imul_i32_mem_ext16(i32, i64) -> i32 {
@@ -1187,7 +1187,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mh %r2, 0(%r3)
+;   mh %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %imul_i32_memoff_ext16(i32, i64) -> i32 {
@@ -1204,7 +1204,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mhy %r2, 0x1000(%r3)
+;   mhy %r2, 0x1000(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %imul_i16(i16, i16) -> i16 {
@@ -1254,7 +1254,7 @@ block0(v0: i16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mh %r2, 0(%r3)
+;   mh %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %imul_i8(i8, i8) -> i8 {
@@ -1305,7 +1305,7 @@ block0(v0: i8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llc %r3, 0(%r3)
+;   llc %r3, 0(%r3) ; trap: heap_oob
 ;   msr %r2, %r3
 ;   br %r14
 
@@ -1489,10 +1489,11 @@ block0(v0: i64, v1: i64):
 ;   iilf %r4, 4294967295
 ;   xgrk %r5, %r4, %r2
 ;   ngrk %r4, %r5, %r3
+;   lgr %r5, %r3
 ;   cgite %r4, -1
-;   lgr %r4, %r3
 ;   lgr %r3, %r2
-;   dsgr %r2, %r4
+;   lgr %r2, %r5
+;   dsgr %r2, %r2
 ;   lgr %r2, %r3
 ;   br %r14
 ;
@@ -1502,10 +1503,11 @@ block0(v0: i64, v1: i64):
 ;   iilf %r4, 0xffffffff
 ;   xgrk %r5, %r4, %r2
 ;   ngrk %r4, %r5, %r3
+;   lgr %r5, %r3
 ;   cgite %r4, -1 ; trap: int_ovf
-;   lgr %r4, %r3
 ;   lgr %r3, %r2
-;   dsgr %r2, %r4 ; trap: int_divz
+;   lgr %r2, %r5
+;   dsgr %r2, %r2 ; trap: int_divz
 ;   lgr %r2, %r3
 ;   br %r14
 
@@ -1518,16 +1520,16 @@ block0(v0: i64):
 
 ; VCode:
 ; block0:
-;   lgr %r3, %r2
 ;   lghi %r4, 2
+;   lgr %r3, %r2
 ;   dsgr %r2, %r4
 ;   lgr %r2, %r3
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r3, %r2
 ;   lghi %r4, 2
+;   lgr %r3, %r2
 ;   dsgr %r2, %r4 ; trap: int_divz
 ;   lgr %r2, %r3
 ;   br %r14
@@ -1601,13 +1603,12 @@ block0(v0: i16, v1: i16):
 ; VCode:
 ; block0:
 ;   lghr %r5, %r2
-;   lgr %r2, %r5
 ;   lhr %r4, %r3
-;   lhi %r5, 32767
-;   lgr %r3, %r2
-;   xr %r5, %r3
-;   nr %r5, %r4
-;   cite %r5, -1
+;   lhi %r2, 32767
+;   xrk %r3, %r2, %r5
+;   nrk %r2, %r3, %r4
+;   cite %r2, -1
+;   lgr %r3, %r5
 ;   dsgfr %r2, %r4
 ;   lgr %r2, %r3
 ;   br %r14
@@ -1615,13 +1616,12 @@ block0(v0: i16, v1: i16):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   lghr %r5, %r2
-;   lgr %r2, %r5
 ;   lhr %r4, %r3
-;   lhi %r5, 0x7fff
-;   lgr %r3, %r2
-;   xr %r5, %r3
-;   nr %r5, %r4
-;   cite %r5, -1 ; trap: int_ovf
+;   lhi %r2, 0x7fff
+;   xrk %r3, %r2, %r5
+;   nrk %r2, %r3, %r4
+;   cite %r2, -1 ; trap: int_ovf
+;   lgr %r3, %r5
 ;   dsgfr %r2, %r4 ; trap: int_divz
 ;   lgr %r2, %r3
 ;   br %r14
@@ -1658,13 +1658,12 @@ block0(v0: i8, v1: i8):
 ; VCode:
 ; block0:
 ;   lgbr %r5, %r2
-;   lgr %r2, %r5
 ;   lbr %r4, %r3
-;   lhi %r5, 127
-;   lgr %r3, %r2
-;   xr %r5, %r3
-;   nr %r5, %r4
-;   cite %r5, -1
+;   lhi %r2, 127
+;   xrk %r3, %r2, %r5
+;   nrk %r2, %r3, %r4
+;   cite %r2, -1
+;   lgr %r3, %r5
 ;   dsgfr %r2, %r4
 ;   lgr %r2, %r3
 ;   br %r14
@@ -1672,13 +1671,12 @@ block0(v0: i8, v1: i8):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   lgbr %r5, %r2
-;   lgr %r2, %r5
 ;   lbr %r4, %r3
-;   lhi %r5, 0x7f
-;   lgr %r3, %r2
-;   xr %r5, %r3
-;   nr %r5, %r4
-;   cite %r5, -1 ; trap: int_ovf
+;   lhi %r2, 0x7f
+;   xrk %r3, %r2, %r5
+;   nrk %r2, %r3, %r4
+;   cite %r2, -1 ; trap: int_ovf
+;   lgr %r3, %r5
 ;   dsgfr %r2, %r4 ; trap: int_divz
 ;   lgr %r2, %r3
 ;   br %r14
@@ -1714,19 +1712,19 @@ block0(v0: i64, v1: i64):
 
 ; VCode:
 ; block0:
-;   lgr %r4, %r3
+;   lgr %r5, %r3
 ;   lgr %r3, %r2
 ;   lghi %r2, 0
-;   dlgr %r2, %r4
+;   dlgr %r2, %r5
 ;   lgr %r2, %r3
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r4, %r3
+;   lgr %r5, %r3
 ;   lgr %r3, %r2
 ;   lghi %r2, 0
-;   dlgr %r2, %r4 ; trap: int_divz
+;   dlgr %r2, %r5 ; trap: int_divz
 ;   lgr %r2, %r3
 ;   br %r14
 
@@ -1763,19 +1761,19 @@ block0(v0: i32, v1: i32):
 
 ; VCode:
 ; block0:
-;   lgr %r4, %r3
+;   lgr %r5, %r3
 ;   lgr %r3, %r2
 ;   lhi %r2, 0
-;   dlr %r2, %r4
+;   dlr %r2, %r5
 ;   lgr %r2, %r3
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r4, %r3
+;   lgr %r5, %r3
 ;   lgr %r3, %r2
 ;   lhi %r2, 0
-;   dlr %r2, %r4 ; trap: int_divz
+;   dlr %r2, %r5 ; trap: int_divz
 ;   lgr %r2, %r3
 ;   br %r14
 
@@ -1811,32 +1809,25 @@ block0(v0: i16, v1: i16):
 }
 
 ; VCode:
-;   stmg %r7, %r15, 56(%r15)
 ; block0:
 ;   lgr %r4, %r3
 ;   lhi %r5, 0
-;   lgr %r7, %r5
 ;   llhr %r3, %r2
-;   llhr %r5, %r4
-;   lgr %r2, %r7
-;   dlr %r2, %r5
+;   llhr %r4, %r4
+;   lgr %r2, %r5
+;   dlr %r2, %r4
 ;   lgr %r2, %r3
-;   lmg %r7, %r15, 56(%r15)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stmg %r7, %r15, 0x38(%r15)
-; block1: ; offset 0x6
 ;   lgr %r4, %r3
 ;   lhi %r5, 0
-;   lgr %r7, %r5
 ;   llhr %r3, %r2
-;   llhr %r5, %r4
-;   lgr %r2, %r7
-;   dlr %r2, %r5 ; trap: int_divz
+;   llhr %r4, %r4
+;   lgr %r2, %r5
+;   dlr %r2, %r4 ; trap: int_divz
 ;   lgr %r2, %r3
-;   lmg %r7, %r15, 0x38(%r15)
 ;   br %r14
 
 function %udiv_i16_imm(i16) -> i16 {
@@ -1849,22 +1840,20 @@ block0(v0: i16):
 ; VCode:
 ; block0:
 ;   lhi %r4, 0
-;   lgr %r5, %r4
 ;   llhr %r3, %r2
-;   lhi %r4, 2
-;   lgr %r2, %r5
-;   dlr %r2, %r4
+;   lhi %r5, 2
+;   lgr %r2, %r4
+;   dlr %r2, %r5
 ;   lgr %r2, %r3
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   lhi %r4, 0
-;   lgr %r5, %r4
 ;   llhr %r3, %r2
-;   lhi %r4, 2
-;   lgr %r2, %r5
-;   dlr %r2, %r4 ; trap: int_divz
+;   lhi %r5, 2
+;   lgr %r2, %r4
+;   dlr %r2, %r5 ; trap: int_divz
 ;   lgr %r2, %r3
 ;   br %r14
 
@@ -1875,32 +1864,25 @@ block0(v0: i8, v1: i8):
 }
 
 ; VCode:
-;   stmg %r7, %r15, 56(%r15)
 ; block0:
 ;   lgr %r4, %r3
 ;   lhi %r5, 0
-;   lgr %r7, %r5
 ;   llcr %r3, %r2
-;   llcr %r5, %r4
-;   lgr %r2, %r7
-;   dlr %r2, %r5
+;   llcr %r4, %r4
+;   lgr %r2, %r5
+;   dlr %r2, %r4
 ;   lgr %r2, %r3
-;   lmg %r7, %r15, 56(%r15)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stmg %r7, %r15, 0x38(%r15)
-; block1: ; offset 0x6
 ;   lgr %r4, %r3
 ;   lhi %r5, 0
-;   lgr %r7, %r5
 ;   llcr %r3, %r2
-;   llcr %r5, %r4
-;   lgr %r2, %r7
-;   dlr %r2, %r5 ; trap: int_divz
+;   llcr %r4, %r4
+;   lgr %r2, %r5
+;   dlr %r2, %r4 ; trap: int_divz
 ;   lgr %r2, %r3
-;   lmg %r7, %r15, 0x38(%r15)
 ;   br %r14
 
 function %udiv_i8_imm(i8) -> i8 {
@@ -1913,22 +1895,20 @@ block0(v0: i8):
 ; VCode:
 ; block0:
 ;   lhi %r4, 0
-;   lgr %r5, %r4
 ;   llcr %r3, %r2
-;   lhi %r4, 2
-;   lgr %r2, %r5
-;   dlr %r2, %r4
+;   lhi %r5, 2
+;   lgr %r2, %r4
+;   dlr %r2, %r5
 ;   lgr %r2, %r3
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   lhi %r4, 0
-;   lgr %r5, %r4
 ;   llcr %r3, %r2
-;   lhi %r4, 2
-;   lgr %r2, %r5
-;   dlr %r2, %r4 ; trap: int_divz
+;   lhi %r5, 2
+;   lgr %r2, %r4
+;   dlr %r2, %r5 ; trap: int_divz
 ;   lgr %r2, %r3
 ;   br %r14
 
@@ -2077,30 +2057,23 @@ block0(v0: i16, v1: i16):
 }
 
 ; VCode:
-;   stmg %r7, %r15, 56(%r15)
 ; block0:
 ;   lgr %r4, %r3
 ;   lhi %r5, 0
-;   lgr %r7, %r5
 ;   llhr %r3, %r2
-;   llhr %r5, %r4
-;   lgr %r2, %r7
-;   dlr %r2, %r5
-;   lmg %r7, %r15, 56(%r15)
+;   llhr %r4, %r4
+;   lgr %r2, %r5
+;   dlr %r2, %r4
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stmg %r7, %r15, 0x38(%r15)
-; block1: ; offset 0x6
 ;   lgr %r4, %r3
 ;   lhi %r5, 0
-;   lgr %r7, %r5
 ;   llhr %r3, %r2
-;   llhr %r5, %r4
-;   lgr %r2, %r7
-;   dlr %r2, %r5 ; trap: int_divz
-;   lmg %r7, %r15, 0x38(%r15)
+;   llhr %r4, %r4
+;   lgr %r2, %r5
+;   dlr %r2, %r4 ; trap: int_divz
 ;   br %r14
 
 function %urem_i8(i8, i8) -> i8 {
@@ -2110,29 +2083,22 @@ block0(v0: i8, v1: i8):
 }
 
 ; VCode:
-;   stmg %r7, %r15, 56(%r15)
 ; block0:
 ;   lgr %r4, %r3
 ;   lhi %r5, 0
-;   lgr %r7, %r5
 ;   llcr %r3, %r2
-;   llcr %r5, %r4
-;   lgr %r2, %r7
-;   dlr %r2, %r5
-;   lmg %r7, %r15, 56(%r15)
+;   llcr %r4, %r4
+;   lgr %r2, %r5
+;   dlr %r2, %r4
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stmg %r7, %r15, 0x38(%r15)
-; block1: ; offset 0x6
 ;   lgr %r4, %r3
 ;   lhi %r5, 0
-;   lgr %r7, %r5
 ;   llcr %r3, %r2
-;   llcr %r5, %r4
-;   lgr %r2, %r7
-;   dlr %r2, %r5 ; trap: int_divz
-;   lmg %r7, %r15, 0x38(%r15)
+;   llcr %r4, %r4
+;   lgr %r2, %r5
+;   dlr %r2, %r4 ; trap: int_divz
 ;   br %r14
 
diff --git a/cranelift/filetests/filetests/isa/s390x/atomic_cas-little.clif b/cranelift/filetests/filetests/isa/s390x/atomic_cas-little.clif
index 2396a691683a..50c62ab0c84c 100644
--- a/cranelift/filetests/filetests/isa/s390x/atomic_cas-little.clif
+++ b/cranelift/filetests/filetests/isa/s390x/atomic_cas-little.clif
@@ -23,7 +23,7 @@ block0(v0: i64, v1: i64, v2: i64):
 ; block0: ; offset 0x0
 ;   lrvgr %r5, %r2
 ;   lrvgr %r2, %r3
-;   csg %r5, %r2, 0(%r4)
+;   csg %r5, %r2, 0(%r4) ; trap: heap_oob
 ;   lrvgr %r2, %r5
 ;   br %r14
 
@@ -45,7 +45,7 @@ block0(v0: i32, v1: i32, v2: i64):
 ; block0: ; offset 0x0
 ;   lrvr %r5, %r2
 ;   lrvr %r2, %r3
-;   cs %r5, %r2, 0(%r4)
+;   cs %r5, %r2, 0(%r4) ; trap: heap_oob
 ;   lrvr %r2, %r5
 ;   br %r14
 
@@ -56,38 +56,33 @@ block0(v0: i64, v1: i16, v2: i16, v3: i64):
 }
 
 ; VCode:
-;   stmg %r11, %r15, 88(%r15)
 ; block0:
-;   sllk %r11, %r5, 3
+;   sllk %r2, %r5, 3
 ;   nill %r5, 65532
-;   lrvr %r2, %r3
-;   lrvr %r3, %r4
+;   lrvr %r3, %r3
+;   lrvr %r4, %r4
 ;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 16(%r11) ; rxsbg %r1, %r2, 176, 64, 48 ; jglh 1f ; risbgn %r1, %r3, 48, 64, 48 ; rll %r1, %r1, 16(%r11) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r5, %r0, 0(%r11)
-;   lrvr %r2, %r5
-;   lmg %r11, %r15, 88(%r15)
+;   0: rll %r1, %r0, 16(%r2) ; rxsbg %r1, %r3, 176, 64, 48 ; jglh 1f ; risbgn %r1, %r4, 48, 64, 48 ; rll %r1, %r1, 16(%r2) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
+;   rll %r4, %r0, 0(%r2)
+;   lrvr %r2, %r4
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stmg %r11, %r15, 0x58(%r15)
-; block1: ; offset 0x6
-;   sllk %r11, %r5, 3
+;   sllk %r2, %r5, 3
 ;   nill %r5, 0xfffc
-;   lrvr %r2, %r3
-;   lrvr %r3, %r4
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0x10(%r11)
-;   rxsbg %r1, %r2, 0xb0, 0x40, 0x30
-;   jglh 0x44
-;   risbgn %r1, %r3, 0x30, 0x40, 0x30
-;   rll %r1, %r1, 0x10(%r11)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x1c
-;   rll %r5, %r0, 0(%r11)
-;   lrvr %r2, %r5
-;   lmg %r11, %r15, 0x58(%r15)
+;   lrvr %r3, %r3
+;   lrvr %r4, %r4
+;   l %r0, 0(%r5) ; trap: heap_oob
+;   rll %r1, %r0, 0x10(%r2)
+;   rxsbg %r1, %r3, 0xb0, 0x40, 0x30
+;   jglh 0x3e
+;   risbgn %r1, %r4, 0x30, 0x40, 0x30
+;   rll %r1, %r1, 0x10(%r2)
+;   cs %r0, %r1, 0(%r5) ; trap: heap_oob
+;   jglh 0x16
+;   rll %r4, %r0, 0(%r2)
+;   lrvr %r2, %r4
 ;   br %r14
 
 function %atomic_cas_i8(i64, i8, i8, i64) -> i8 {
@@ -97,35 +92,33 @@ block0(v0: i64, v1: i8, v2: i8, v3: i64):
 }
 
 ; VCode:
-;   stmg %r10, %r15, 80(%r15)
+;   stmg %r14, %r15, 112(%r15)
 ; block0:
-;   lgr %r10, %r3
-;   sllk %r3, %r5, 3
+;   sllk %r2, %r5, 3
 ;   nill %r5, 65532
-;   lcr %r2, %r3
+;   lcr %r14, %r2
 ;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r3) ; rxsbg %r1, %r10, 160, 40, 24 ; jglh 1f ; risbgn %r1, %r4, 32, 40, 24 ; rll %r1, %r1, 0(%r2) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 8(%r3)
-;   lmg %r10, %r15, 80(%r15)
+;   0: rll %r1, %r0, 0(%r2) ; rxsbg %r1, %r3, 160, 40, 24 ; jglh 1f ; risbgn %r1, %r4, 32, 40, 24 ; rll %r1, %r1, 0(%r14) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
+;   rll %r2, %r0, 8(%r2)
+;   lmg %r14, %r15, 112(%r15)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stmg %r10, %r15, 0x50(%r15)
+;   stmg %r14, %r15, 0x70(%r15)
 ; block1: ; offset 0x6
-;   lgr %r10, %r3
-;   sllk %r3, %r5, 3
+;   sllk %r2, %r5, 3
 ;   nill %r5, 0xfffc
-;   lcr %r2, %r3
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r3)
-;   rxsbg %r1, %r10, 0xa0, 0x28, 0x18
-;   jglh 0x42
+;   lcr %r14, %r2
+;   l %r0, 0(%r5) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r2)
+;   rxsbg %r1, %r3, 0xa0, 0x28, 0x18
+;   jglh 0x3e
 ;   risbgn %r1, %r4, 0x20, 0x28, 0x18
-;   rll %r1, %r1, 0(%r2)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x1a
-;   rll %r2, %r0, 8(%r3)
-;   lmg %r10, %r15, 0x50(%r15)
+;   rll %r1, %r1, 0(%r14)
+;   cs %r0, %r1, 0(%r5) ; trap: heap_oob
+;   jglh 0x16
+;   rll %r2, %r0, 8(%r2)
+;   lmg %r14, %r15, 0x70(%r15)
 ;   br %r14
 
diff --git a/cranelift/filetests/filetests/isa/s390x/atomic_cas.clif b/cranelift/filetests/filetests/isa/s390x/atomic_cas.clif
index 24d0b506b116..bab8d64b714b 100644
--- a/cranelift/filetests/filetests/isa/s390x/atomic_cas.clif
+++ b/cranelift/filetests/filetests/isa/s390x/atomic_cas.clif
@@ -18,7 +18,7 @@ block0(v0: i64, v1: i64, v2: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   csg %r2, %r3, 0(%r4)
+;   csg %r2, %r3, 0(%r4) ; trap: heap_oob
 ;   br %r14
 
 function %atomic_cas_i32(i32, i32, i64) -> i32 {
@@ -34,7 +34,7 @@ block0(v0: i32, v1: i32, v2: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   cs %r2, %r3, 0(%r4)
+;   cs %r2, %r3, 0(%r4) ; trap: heap_oob
 ;   br %r14
 
 function %atomic_cas_i16(i64, i16, i16, i64) -> i16 {
@@ -45,28 +45,26 @@ block0(v0: i64, v1: i16, v2: i16, v3: i64):
 
 ; VCode:
 ; block0:
-;   lgr %r2, %r3
-;   sllk %r3, %r5, 3
+;   sllk %r2, %r5, 3
 ;   nill %r5, 65532
 ;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r3) ; rxsbg %r1, %r2, 160, 48, 16 ; jglh 1f ; risbgn %r1, %r4, 32, 48, 16 ; rll %r1, %r1, 0(%r3) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 16(%r3)
+;   0: rll %r1, %r0, 0(%r2) ; rxsbg %r1, %r3, 160, 48, 16 ; jglh 1f ; risbgn %r1, %r4, 32, 48, 16 ; rll %r1, %r1, 0(%r2) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
+;   rll %r2, %r0, 16(%r2)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r2, %r3
-;   sllk %r3, %r5, 3
+;   sllk %r2, %r5, 3
 ;   nill %r5, 0xfffc
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r3)
-;   rxsbg %r1, %r2, 0xa0, 0x30, 0x10
-;   jglh 0x3a
+;   l %r0, 0(%r5) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r2)
+;   rxsbg %r1, %r3, 0xa0, 0x30, 0x10
+;   jglh 0x36
 ;   risbgn %r1, %r4, 0x20, 0x30, 0x10
-;   rll %r1, %r1, 0(%r3)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x12
-;   rll %r2, %r0, 0x10(%r3)
+;   rll %r1, %r1, 0(%r2)
+;   cs %r0, %r1, 0(%r5) ; trap: heap_oob
+;   jglh 0xe
+;   rll %r2, %r0, 0x10(%r2)
 ;   br %r14
 
 function %atomic_cas_i8(i64, i8, i8, i64) -> i8 {
@@ -76,35 +74,33 @@ block0(v0: i64, v1: i8, v2: i8, v3: i64):
 }
 
 ; VCode:
-;   stmg %r10, %r15, 80(%r15)
+;   stmg %r14, %r15, 112(%r15)
 ; block0:
-;   lgr %r10, %r3
-;   sllk %r3, %r5, 3
+;   sllk %r2, %r5, 3
 ;   nill %r5, 65532
-;   lcr %r2, %r3
+;   lcr %r14, %r2
 ;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r3) ; rxsbg %r1, %r10, 160, 40, 24 ; jglh 1f ; risbgn %r1, %r4, 32, 40, 24 ; rll %r1, %r1, 0(%r2) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 8(%r3)
-;   lmg %r10, %r15, 80(%r15)
+;   0: rll %r1, %r0, 0(%r2) ; rxsbg %r1, %r3, 160, 40, 24 ; jglh 1f ; risbgn %r1, %r4, 32, 40, 24 ; rll %r1, %r1, 0(%r14) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
+;   rll %r2, %r0, 8(%r2)
+;   lmg %r14, %r15, 112(%r15)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stmg %r10, %r15, 0x50(%r15)
+;   stmg %r14, %r15, 0x70(%r15)
 ; block1: ; offset 0x6
-;   lgr %r10, %r3
-;   sllk %r3, %r5, 3
+;   sllk %r2, %r5, 3
 ;   nill %r5, 0xfffc
-;   lcr %r2, %r3
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r3)
-;   rxsbg %r1, %r10, 0xa0, 0x28, 0x18
-;   jglh 0x42
+;   lcr %r14, %r2
+;   l %r0, 0(%r5) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r2)
+;   rxsbg %r1, %r3, 0xa0, 0x28, 0x18
+;   jglh 0x3e
 ;   risbgn %r1, %r4, 0x20, 0x28, 0x18
-;   rll %r1, %r1, 0(%r2)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x1a
-;   rll %r2, %r0, 8(%r3)
-;   lmg %r10, %r15, 0x50(%r15)
+;   rll %r1, %r1, 0(%r14)
+;   cs %r0, %r1, 0(%r5) ; trap: heap_oob
+;   jglh 0x16
+;   rll %r2, %r0, 8(%r2)
+;   lmg %r14, %r15, 0x70(%r15)
 ;   br %r14
 
diff --git a/cranelift/filetests/filetests/isa/s390x/atomic_load-little.clif b/cranelift/filetests/filetests/isa/s390x/atomic_load-little.clif
index 02e4ba9f7b9d..91632579adf9 100644
--- a/cranelift/filetests/filetests/isa/s390x/atomic_load-little.clif
+++ b/cranelift/filetests/filetests/isa/s390x/atomic_load-little.clif
@@ -14,7 +14,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r2, 0(%r2)
+;   lrvg %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %atomic_load_i64_sym() -> i64 {
@@ -33,7 +33,7 @@ block0:
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   larl %r1, 0 ; reloc_external PCRel32Dbl %sym 2
-;   lrvg %r2, 0(%r1)
+;   lrvg %r2, 0(%r1) ; trap: heap_oob
 ;   br %r14
 
 function %atomic_load_i32(i64) -> i32 {
@@ -49,7 +49,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrv %r2, 0(%r2)
+;   lrv %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %atomic_load_i32_sym() -> i32 {
@@ -68,7 +68,7 @@ block0:
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   larl %r1, 0 ; reloc_external PCRel32Dbl %sym 2
-;   lrv %r2, 0(%r1)
+;   lrv %r2, 0(%r1) ; trap: heap_oob
 ;   br %r14
 
 function %atomic_load_i16(i64) -> i16 {
@@ -84,7 +84,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvh %r2, 0(%r2)
+;   lrvh %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %atomic_load_i16_sym() -> i16 {
@@ -103,7 +103,7 @@ block0:
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   larl %r1, 0 ; reloc_external PCRel32Dbl %sym 2
-;   lrvh %r2, 0(%r1)
+;   lrvh %r2, 0(%r1) ; trap: heap_oob
 ;   br %r14
 
 function %atomic_load_i8(i64) -> i8 {
@@ -119,6 +119,6 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llc %r2, 0(%r2)
+;   llc %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
diff --git a/cranelift/filetests/filetests/isa/s390x/atomic_load.clif b/cranelift/filetests/filetests/isa/s390x/atomic_load.clif
index 81fa52eed820..accaa1567199 100644
--- a/cranelift/filetests/filetests/isa/s390x/atomic_load.clif
+++ b/cranelift/filetests/filetests/isa/s390x/atomic_load.clif
@@ -14,7 +14,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lg %r2, 0(%r2)
+;   lg %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %atomic_load_i64_sym() -> i64 {
@@ -32,7 +32,7 @@ block0:
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   lgrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   br %r14
 
 function %atomic_load_i32(i64) -> i32 {
@@ -48,7 +48,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   l %r2, 0(%r2)
+;   l %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %atomic_load_i32_sym() -> i32 {
@@ -66,7 +66,7 @@ block0:
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   lrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   br %r14
 
 function %atomic_load_i16(i64) -> i16 {
@@ -82,7 +82,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llh %r2, 0(%r2)
+;   llh %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %atomic_load_i16_sym() -> i16 {
@@ -100,7 +100,7 @@ block0:
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llhrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   llhrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   br %r14
 
 function %atomic_load_i8(i64) -> i8 {
@@ -116,6 +116,6 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llc %r2, 0(%r2)
+;   llc %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
diff --git a/cranelift/filetests/filetests/isa/s390x/atomic_rmw-arch13.clif b/cranelift/filetests/filetests/isa/s390x/atomic_rmw-arch13.clif
index 3aa194f547e4..aada84480f31 100644
--- a/cranelift/filetests/filetests/isa/s390x/atomic_rmw-arch13.clif
+++ b/cranelift/filetests/filetests/isa/s390x/atomic_rmw-arch13.clif
@@ -16,9 +16,9 @@ block0(v0: i64, v1: i64, v2: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lg %r0, 0(%r3)
+;   lg %r0, 0(%r3) ; trap: heap_oob
 ;   .byte 0xb9, 0x64
-;   sth %r1, 0xb01(%r14)
+;   sth %r1, 0xb01(%r14) ; trap: heap_oob
 ;   lper %f0, %f0
 ;   .byte 0x00, 0x30
 ;   jglh 6
@@ -40,9 +40,9 @@ block0(v0: i64, v1: i64, v2: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   l %r0, 0(%r3)
+;   l %r0, 0(%r3) ; trap: heap_oob
 ;   .byte 0xb9, 0x74
-;   sth %r1, 0xa01(%r11)
+;   sth %r1, 0xa01(%r11) ; trap: heap_oob
 ;   lper %f0, %f0
 ;   jglh 4
 ;   lgr %r2, %r0
@@ -56,27 +56,25 @@ block0(v0: i64, v1: i64, v2: i16):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; rnsbg %r1, %r4, 32, 48, 16 ; xilf %r1, 4294901760 ; rll %r1, %r1, 0(%r2) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 16(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; rnsbg %r1, %r4, 32, 48, 16 ; xilf %r1, 4294901760 ; rll %r1, %r1, 0(%r5) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 16(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
 ;   rnsbg %r1, %r4, 0x20, 0x30, 0x10
 ;   xilf %r1, 0xffff0000
-;   rll %r1, %r1, 0(%r2)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x12
-;   rll %r2, %r0, 0x10(%r2)
+;   rll %r1, %r1, 0(%r5)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0xe
+;   rll %r2, %r0, 0x10(%r5)
 ;   br %r14
 
 function %atomic_rmw_nand_i8(i64, i64, i8) -> i8 {
@@ -87,29 +85,27 @@ block0(v0: i64, v1: i64, v2: i8):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   lcr %r3, %r2
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; rnsbg %r1, %r4, 32, 40, 24 ; xilf %r1, 4278190080 ; rll %r1, %r1, 0(%r3) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 8(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   lcr %r2, %r5
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; rnsbg %r1, %r4, 32, 40, 24 ; xilf %r1, 4278190080 ; rll %r1, %r1, 0(%r2) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   lcr %r3, %r2
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   lcr %r2, %r5
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
 ;   rnsbg %r1, %r4, 0x20, 0x28, 0x18
 ;   xilf %r1, 0xff000000
-;   rll %r1, %r1, 0(%r3)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x14
-;   rll %r2, %r0, 8(%r2)
+;   rll %r1, %r1, 0(%r2)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x10
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 
 function %atomic_rmw_nand_i64(i64, i64, i64) -> i64 {
@@ -120,19 +116,20 @@ block0(v0: i64, v1: i64, v2: i64):
 
 ; VCode:
 ; block0:
-;   lrvgr %r2, %r4
+;   lrvgr %r5, %r4
 ;   lg %r0, 0(%r3)
-;   0: nngrk %r1, %r0, %r2 ; csg %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   0: nngrk %r1, %r0, %r5 ; csg %r0, %r1, 0(%r3) ; jglh 0b ; 1:
 ;   lrvgr %r2, %r0
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvgr %r2, %r4
-;   lg %r0, 0(%r3)
+;   lrvgr %r5, %r4
+;   lg %r0, 0(%r3) ; trap: heap_oob
 ;   .byte 0xb9, 0x64
-;   lpdr %f1, %f0
-;   csg %r0, %r1, 0(%r3)
+;   st %r1, 0xb01(%r14) ; trap: heap_oob
+;   lper %f0, %f0
+;   .byte 0x00, 0x30
 ;   jglh 0xa
 ;   lrvgr %r2, %r0
 ;   br %r14
@@ -145,19 +142,19 @@ block0(v0: i64, v1: i64, v2: i32):
 
 ; VCode:
 ; block0:
-;   lrvr %r2, %r4
+;   lrvr %r5, %r4
 ;   l %r0, 0(%r3)
-;   0: nnrk %r1, %r0, %r2 ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   0: nnrk %r1, %r0, %r5 ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
 ;   lrvr %r2, %r0
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvr %r2, %r4
-;   l %r0, 0(%r3)
+;   lrvr %r5, %r4
+;   l %r0, 0(%r3) ; trap: heap_oob
 ;   .byte 0xb9, 0x74
-;   lpdr %f1, %f0
-;   cs %r0, %r1, 0(%r3)
+;   st %r1, 0xa01(%r11) ; trap: heap_oob
+;   lper %f0, %f0
 ;   jglh 8
 ;   lrvr %r2, %r0
 ;   br %r14
@@ -170,33 +167,29 @@ block0(v0: i64, v1: i64, v2: i16):
 
 ; VCode:
 ; block0:
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 65532
-;   lrvr %r3, %r5
-;   l %r0, 0(%r4)
-;   0: rll %r1, %r0, 16(%r2) ; rnsbg %r1, %r3, 48, 64, 48 ; xilf %r1, 65535 ; rll %r1, %r1, 16(%r2) ; cs %r0, %r1, 0(%r4) ; jglh 0b ; 1:
-;   rll %r2, %r0, 0(%r2)
-;   lrvr %r2, %r2
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   lrvr %r2, %r4
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 16(%r5) ; rnsbg %r1, %r2, 48, 64, 48 ; xilf %r1, 65535 ; rll %r1, %r1, 16(%r5) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r5, %r0, 0(%r5)
+;   lrvr %r2, %r5
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 0xfffc
-;   lrvr %r3, %r5
-;   l %r0, 0(%r4)
-;   rll %r1, %r0, 0x10(%r2)
-;   rnsbg %r1, %r3, 0x30, 0x40, 0x30
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   lrvr %r2, %r4
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0x10(%r5)
+;   rnsbg %r1, %r2, 0x30, 0x40, 0x30
 ;   xilf %r1, 0xffff
-;   rll %r1, %r1, 0x10(%r2)
-;   cs %r0, %r1, 0(%r4)
-;   jglh 0x1a
-;   rll %r2, %r0, 0(%r2)
-;   lrvr %r2, %r2
+;   rll %r1, %r1, 0x10(%r5)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x12
+;   rll %r5, %r0, 0(%r5)
+;   lrvr %r2, %r5
 ;   br %r14
 
 function %atomic_rmw_nand_i8(i64, i64, i8) -> i8 {
@@ -207,28 +200,26 @@ block0(v0: i64, v1: i64, v2: i8):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   lcr %r3, %r2
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; rnsbg %r1, %r4, 32, 40, 24 ; xilf %r1, 4278190080 ; rll %r1, %r1, 0(%r3) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 8(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   lcr %r2, %r5
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; rnsbg %r1, %r4, 32, 40, 24 ; xilf %r1, 4278190080 ; rll %r1, %r1, 0(%r2) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   lcr %r3, %r2
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   lcr %r2, %r5
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
 ;   rnsbg %r1, %r4, 0x20, 0x28, 0x18
 ;   xilf %r1, 0xff000000
-;   rll %r1, %r1, 0(%r3)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x14
-;   rll %r2, %r0, 8(%r2)
+;   rll %r1, %r1, 0(%r2)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x10
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 
diff --git a/cranelift/filetests/filetests/isa/s390x/atomic_rmw-little.clif b/cranelift/filetests/filetests/isa/s390x/atomic_rmw-little.clif
index b113d1c94c9e..e06d6fff265c 100644
--- a/cranelift/filetests/filetests/isa/s390x/atomic_rmw-little.clif
+++ b/cranelift/filetests/filetests/isa/s390x/atomic_rmw-little.clif
@@ -13,17 +13,17 @@ block0(v0: i64, v1: i64, v2: i64):
 
 ; VCode:
 ; block0:
-;   lrvgr %r2, %r4
+;   lrvgr %r5, %r4
 ;   lg %r0, 0(%r3)
-;   0: csg %r0, %r2, 0(%r3) ; jglh 0b ; 1:
+;   0: csg %r0, %r5, 0(%r3) ; jglh 0b ; 1:
 ;   lrvgr %r2, %r0
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvgr %r2, %r4
-;   lg %r0, 0(%r3)
-;   csg %r0, %r2, 0(%r3)
+;   lrvgr %r5, %r4
+;   lg %r0, 0(%r3) ; trap: heap_oob
+;   csg %r0, %r5, 0(%r3) ; trap: heap_oob
 ;   jglh 0xa
 ;   lrvgr %r2, %r0
 ;   br %r14
@@ -36,17 +36,17 @@ block0(v0: i64, v1: i64, v2: i32):
 
 ; VCode:
 ; block0:
-;   lrvr %r2, %r4
+;   lrvr %r5, %r4
 ;   l %r0, 0(%r3)
-;   0: cs %r0, %r2, 0(%r3) ; jglh 0b ; 1:
+;   0: cs %r0, %r5, 0(%r3) ; jglh 0b ; 1:
 ;   lrvr %r2, %r0
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvr %r2, %r4
-;   l %r0, 0(%r3)
-;   cs %r0, %r2, 0(%r3)
+;   lrvr %r5, %r4
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   cs %r0, %r5, 0(%r3) ; trap: heap_oob
 ;   jglh 8
 ;   lrvr %r2, %r0
 ;   br %r14
@@ -59,32 +59,28 @@ block0(v0: i64, v1: i64, v2: i16):
 
 ; VCode:
 ; block0:
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 65532
-;   lrvr %r3, %r5
-;   l %r0, 0(%r4)
-;   0: rll %r1, %r0, 16(%r2) ; risbgn %r1, %r3, 48, 64, 48 ; rll %r1, %r1, 16(%r2) ; cs %r0, %r1, 0(%r4) ; jglh 0b ; 1:
-;   rll %r2, %r0, 0(%r2)
-;   lrvr %r2, %r2
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   lrvr %r2, %r4
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 16(%r5) ; risbgn %r1, %r2, 48, 64, 48 ; rll %r1, %r1, 16(%r5) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r5, %r0, 0(%r5)
+;   lrvr %r2, %r5
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 0xfffc
-;   lrvr %r3, %r5
-;   l %r0, 0(%r4)
-;   rll %r1, %r0, 0x10(%r2)
-;   risbgn %r1, %r3, 0x30, 0x40, 0x30
-;   rll %r1, %r1, 0x10(%r2)
-;   cs %r0, %r1, 0(%r4)
-;   jglh 0x1a
-;   rll %r2, %r0, 0(%r2)
-;   lrvr %r2, %r2
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   lrvr %r2, %r4
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0x10(%r5)
+;   risbgn %r1, %r2, 0x30, 0x40, 0x30
+;   rll %r1, %r1, 0x10(%r5)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x12
+;   rll %r5, %r0, 0(%r5)
+;   lrvr %r2, %r5
 ;   br %r14
 
 function %atomic_rmw_xchg_i8(i64, i64, i8) -> i8 {
@@ -95,28 +91,26 @@ block0(v0: i64, v1: i64, v2: i8):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   lcr %r3, %r2
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; risbgn %r1, %r4, 32, 40, 24 ; rll %r1, %r1, 0(%r3) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 8(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   lcr %r2, %r5
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; risbgn %r1, %r4, 32, 40, 24 ; rll %r1, %r1, 0(%r2) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   lcr %r3, %r2
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   lcr %r2, %r5
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
 ;   risbgn %r1, %r4, 0x20, 0x28, 0x18
-;   rll %r1, %r1, 0(%r3)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x14
-;   rll %r2, %r0, 8(%r2)
+;   rll %r1, %r1, 0(%r2)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x10
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 
 function %atomic_rmw_add_i64(i64, i64, i64) -> i64 {
@@ -134,11 +128,11 @@ block0(v0: i64, v1: i64, v2: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lg %r0, 0(%r3)
+;   lg %r0, 0(%r3) ; trap: heap_oob
 ;   lrvgr %r1, %r0
 ;   agr %r1, %r4
 ;   lrvgr %r1, %r1
-;   csg %r0, %r1, 0(%r3)
+;   csg %r0, %r1, 0(%r3) ; trap: heap_oob
 ;   jglh 6
 ;   lrvgr %r2, %r0
 ;   br %r14
@@ -158,11 +152,11 @@ block0(v0: i64, v1: i64, v2: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   l %r0, 0(%r3)
+;   l %r0, 0(%r3) ; trap: heap_oob
 ;   lrvr %r1, %r0
 ;   ar %r1, %r4
 ;   lrvr %r1, %r1
-;   cs %r0, %r1, 0(%r3)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
 ;   jglh 4
 ;   lrvr %r2, %r0
 ;   br %r14
@@ -175,34 +169,30 @@ block0(v0: i64, v1: i64, v2: i16):
 
 ; VCode:
 ; block0:
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 65532
-;   sllk %r3, %r5, 16
-;   l %r0, 0(%r4)
-;   0: rll %r1, %r0, 16(%r2) ; lrvr %r1, %r1 ; ar %r1, %r3 ; lrvr %r1, %r1 ; rll %r1, %r1, 16(%r2) ; cs %r0, %r1, 0(%r4) ; jglh 0b ; 1:
-;   rll %r2, %r0, 0(%r2)
-;   lrvr %r2, %r2
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   sllk %r2, %r4, 16
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 16(%r5) ; lrvr %r1, %r1 ; ar %r1, %r2 ; lrvr %r1, %r1 ; rll %r1, %r1, 16(%r5) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r5, %r0, 0(%r5)
+;   lrvr %r2, %r5
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 0xfffc
-;   sllk %r3, %r5, 0x10
-;   l %r0, 0(%r4)
-;   rll %r1, %r0, 0x10(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   sllk %r2, %r4, 0x10
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0x10(%r5)
 ;   lrvr %r1, %r1
-;   ar %r1, %r3
+;   ar %r1, %r2
 ;   lrvr %r1, %r1
-;   rll %r1, %r1, 0x10(%r2)
-;   cs %r0, %r1, 0(%r4)
-;   jglh 0x1c
-;   rll %r2, %r0, 0(%r2)
-;   lrvr %r2, %r2
+;   rll %r1, %r1, 0x10(%r5)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x14
+;   rll %r5, %r0, 0(%r5)
+;   lrvr %r2, %r5
 ;   br %r14
 
 function %atomic_rmw_add_i8(i64, i64, i8) -> i8 {
@@ -213,30 +203,28 @@ block0(v0: i64, v1: i64, v2: i8):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   sllk %r3, %r4, 24
-;   lcr %r4, %r2
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; ar %r1, %r3 ; rll %r1, %r1, 0(%r4) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 8(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   sllk %r2, %r4, 24
+;   lcr %r4, %r5
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; ar %r1, %r2 ; rll %r1, %r1, 0(%r4) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   sllk %r3, %r4, 0x18
-;   lcr %r4, %r2
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
-;   ar %r1, %r3
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   sllk %r2, %r4, 0x18
+;   lcr %r4, %r5
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
+;   ar %r1, %r2
 ;   rll %r1, %r1, 0(%r4)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x1a
-;   rll %r2, %r0, 8(%r2)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x16
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 
 function %atomic_rmw_sub_i64(i64, i64, i64) -> i64 {
@@ -254,11 +242,11 @@ block0(v0: i64, v1: i64, v2: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lg %r0, 0(%r3)
+;   lg %r0, 0(%r3) ; trap: heap_oob
 ;   lrvgr %r1, %r0
 ;   sgr %r1, %r4
 ;   lrvgr %r1, %r1
-;   csg %r0, %r1, 0(%r3)
+;   csg %r0, %r1, 0(%r3) ; trap: heap_oob
 ;   jglh 6
 ;   lrvgr %r2, %r0
 ;   br %r14
@@ -278,11 +266,11 @@ block0(v0: i64, v1: i64, v2: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   l %r0, 0(%r3)
+;   l %r0, 0(%r3) ; trap: heap_oob
 ;   lrvr %r1, %r0
 ;   sr %r1, %r4
 ;   lrvr %r1, %r1
-;   cs %r0, %r1, 0(%r3)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
 ;   jglh 4
 ;   lrvr %r2, %r0
 ;   br %r14
@@ -295,34 +283,30 @@ block0(v0: i64, v1: i64, v2: i16):
 
 ; VCode:
 ; block0:
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 65532
-;   sllk %r3, %r5, 16
-;   l %r0, 0(%r4)
-;   0: rll %r1, %r0, 16(%r2) ; lrvr %r1, %r1 ; sr %r1, %r3 ; lrvr %r1, %r1 ; rll %r1, %r1, 16(%r2) ; cs %r0, %r1, 0(%r4) ; jglh 0b ; 1:
-;   rll %r2, %r0, 0(%r2)
-;   lrvr %r2, %r2
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   sllk %r2, %r4, 16
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 16(%r5) ; lrvr %r1, %r1 ; sr %r1, %r2 ; lrvr %r1, %r1 ; rll %r1, %r1, 16(%r5) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r5, %r0, 0(%r5)
+;   lrvr %r2, %r5
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 0xfffc
-;   sllk %r3, %r5, 0x10
-;   l %r0, 0(%r4)
-;   rll %r1, %r0, 0x10(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   sllk %r2, %r4, 0x10
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0x10(%r5)
 ;   lrvr %r1, %r1
-;   sr %r1, %r3
+;   sr %r1, %r2
 ;   lrvr %r1, %r1
-;   rll %r1, %r1, 0x10(%r2)
-;   cs %r0, %r1, 0(%r4)
-;   jglh 0x1c
-;   rll %r2, %r0, 0(%r2)
-;   lrvr %r2, %r2
+;   rll %r1, %r1, 0x10(%r5)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x14
+;   rll %r5, %r0, 0(%r5)
+;   lrvr %r2, %r5
 ;   br %r14
 
 function %atomic_rmw_sub_i8(i64, i64, i8) -> i8 {
@@ -333,30 +317,28 @@ block0(v0: i64, v1: i64, v2: i8):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   sllk %r3, %r4, 24
-;   lcr %r4, %r2
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; sr %r1, %r3 ; rll %r1, %r1, 0(%r4) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 8(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   sllk %r2, %r4, 24
+;   lcr %r4, %r5
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; sr %r1, %r2 ; rll %r1, %r1, 0(%r4) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   sllk %r3, %r4, 0x18
-;   lcr %r4, %r2
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
-;   sr %r1, %r3
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   sllk %r2, %r4, 0x18
+;   lcr %r4, %r5
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
+;   sr %r1, %r2
 ;   rll %r1, %r1, 0(%r4)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x1a
-;   rll %r2, %r0, 8(%r2)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x16
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 
 function %atomic_rmw_and_i64(i64, i64, i64) -> i64 {
@@ -367,16 +349,16 @@ block0(v0: i64, v1: i64, v2: i64):
 
 ; VCode:
 ; block0:
-;   lrvgr %r2, %r4
-;   lang %r4, %r2, 0(%r3)
-;   lrvgr %r2, %r4
+;   lrvgr %r5, %r4
+;   lang %r3, %r5, 0(%r3)
+;   lrvgr %r2, %r3
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvgr %r2, %r4
-;   lang %r4, %r2, 0(%r3)
-;   lrvgr %r2, %r4
+;   lrvgr %r5, %r4
+;   lang %r3, %r5, 0(%r3) ; trap: heap_oob
+;   lrvgr %r2, %r3
 ;   br %r14
 
 function %atomic_rmw_and_i32(i64, i64, i32) -> i32 {
@@ -387,16 +369,16 @@ block0(v0: i64, v1: i64, v2: i32):
 
 ; VCode:
 ; block0:
-;   lrvr %r2, %r4
-;   lan %r4, %r2, 0(%r3)
-;   lrvr %r2, %r4
+;   lrvr %r5, %r4
+;   lan %r3, %r5, 0(%r3)
+;   lrvr %r2, %r3
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvr %r2, %r4
-;   lan %r4, %r2, 0(%r3)
-;   lrvr %r2, %r4
+;   lrvr %r5, %r4
+;   lan %r3, %r5, 0(%r3) ; trap: heap_oob
+;   lrvr %r2, %r3
 ;   br %r14
 
 function %atomic_rmw_and_i16(i64, i64, i16) -> i16 {
@@ -407,32 +389,28 @@ block0(v0: i64, v1: i64, v2: i16):
 
 ; VCode:
 ; block0:
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 65532
-;   lrvr %r3, %r5
-;   l %r0, 0(%r4)
-;   0: rll %r1, %r0, 16(%r2) ; rnsbg %r1, %r3, 48, 64, 48 ; rll %r1, %r1, 16(%r2) ; cs %r0, %r1, 0(%r4) ; jglh 0b ; 1:
-;   rll %r2, %r0, 0(%r2)
-;   lrvr %r2, %r2
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   lrvr %r2, %r4
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 16(%r5) ; rnsbg %r1, %r2, 48, 64, 48 ; rll %r1, %r1, 16(%r5) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r5, %r0, 0(%r5)
+;   lrvr %r2, %r5
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 0xfffc
-;   lrvr %r3, %r5
-;   l %r0, 0(%r4)
-;   rll %r1, %r0, 0x10(%r2)
-;   rnsbg %r1, %r3, 0x30, 0x40, 0x30
-;   rll %r1, %r1, 0x10(%r2)
-;   cs %r0, %r1, 0(%r4)
-;   jglh 0x1a
-;   rll %r2, %r0, 0(%r2)
-;   lrvr %r2, %r2
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   lrvr %r2, %r4
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0x10(%r5)
+;   rnsbg %r1, %r2, 0x30, 0x40, 0x30
+;   rll %r1, %r1, 0x10(%r5)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x12
+;   rll %r5, %r0, 0(%r5)
+;   lrvr %r2, %r5
 ;   br %r14
 
 function %atomic_rmw_and_i8(i64, i64, i8) -> i8 {
@@ -443,28 +421,26 @@ block0(v0: i64, v1: i64, v2: i8):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   lcr %r3, %r2
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; rnsbg %r1, %r4, 32, 40, 24 ; rll %r1, %r1, 0(%r3) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 8(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   lcr %r2, %r5
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; rnsbg %r1, %r4, 32, 40, 24 ; rll %r1, %r1, 0(%r2) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   lcr %r3, %r2
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   lcr %r2, %r5
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
 ;   rnsbg %r1, %r4, 0x20, 0x28, 0x18
-;   rll %r1, %r1, 0(%r3)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x14
-;   rll %r2, %r0, 8(%r2)
+;   rll %r1, %r1, 0(%r2)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x10
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 
 function %atomic_rmw_or_i64(i64, i64, i64) -> i64 {
@@ -475,16 +451,16 @@ block0(v0: i64, v1: i64, v2: i64):
 
 ; VCode:
 ; block0:
-;   lrvgr %r2, %r4
-;   laog %r4, %r2, 0(%r3)
-;   lrvgr %r2, %r4
+;   lrvgr %r5, %r4
+;   laog %r3, %r5, 0(%r3)
+;   lrvgr %r2, %r3
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvgr %r2, %r4
-;   laog %r4, %r2, 0(%r3)
-;   lrvgr %r2, %r4
+;   lrvgr %r5, %r4
+;   laog %r3, %r5, 0(%r3) ; trap: heap_oob
+;   lrvgr %r2, %r3
 ;   br %r14
 
 function %atomic_rmw_or_i32(i64, i64, i32) -> i32 {
@@ -495,16 +471,16 @@ block0(v0: i64, v1: i64, v2: i32):
 
 ; VCode:
 ; block0:
-;   lrvr %r2, %r4
-;   lao %r4, %r2, 0(%r3)
-;   lrvr %r2, %r4
+;   lrvr %r5, %r4
+;   lao %r3, %r5, 0(%r3)
+;   lrvr %r2, %r3
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvr %r2, %r4
-;   lao %r4, %r2, 0(%r3)
-;   lrvr %r2, %r4
+;   lrvr %r5, %r4
+;   lao %r3, %r5, 0(%r3) ; trap: heap_oob
+;   lrvr %r2, %r3
 ;   br %r14
 
 function %atomic_rmw_or_i16(i64, i64, i16) -> i16 {
@@ -515,32 +491,28 @@ block0(v0: i64, v1: i64, v2: i16):
 
 ; VCode:
 ; block0:
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 65532
-;   lrvr %r3, %r5
-;   l %r0, 0(%r4)
-;   0: rll %r1, %r0, 16(%r2) ; rosbg %r1, %r3, 48, 64, 48 ; rll %r1, %r1, 16(%r2) ; cs %r0, %r1, 0(%r4) ; jglh 0b ; 1:
-;   rll %r2, %r0, 0(%r2)
-;   lrvr %r2, %r2
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   lrvr %r2, %r4
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 16(%r5) ; rosbg %r1, %r2, 48, 64, 48 ; rll %r1, %r1, 16(%r5) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r5, %r0, 0(%r5)
+;   lrvr %r2, %r5
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 0xfffc
-;   lrvr %r3, %r5
-;   l %r0, 0(%r4)
-;   rll %r1, %r0, 0x10(%r2)
-;   rosbg %r1, %r3, 0x30, 0x40, 0x30
-;   rll %r1, %r1, 0x10(%r2)
-;   cs %r0, %r1, 0(%r4)
-;   jglh 0x1a
-;   rll %r2, %r0, 0(%r2)
-;   lrvr %r2, %r2
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   lrvr %r2, %r4
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0x10(%r5)
+;   rosbg %r1, %r2, 0x30, 0x40, 0x30
+;   rll %r1, %r1, 0x10(%r5)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x12
+;   rll %r5, %r0, 0(%r5)
+;   lrvr %r2, %r5
 ;   br %r14
 
 function %atomic_rmw_or_i8(i64, i64, i8) -> i8 {
@@ -551,28 +523,26 @@ block0(v0: i64, v1: i64, v2: i8):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   lcr %r3, %r2
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; rosbg %r1, %r4, 32, 40, 24 ; rll %r1, %r1, 0(%r3) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 8(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   lcr %r2, %r5
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; rosbg %r1, %r4, 32, 40, 24 ; rll %r1, %r1, 0(%r2) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   lcr %r3, %r2
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   lcr %r2, %r5
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
 ;   rosbg %r1, %r4, 0x20, 0x28, 0x18
-;   rll %r1, %r1, 0(%r3)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x14
-;   rll %r2, %r0, 8(%r2)
+;   rll %r1, %r1, 0(%r2)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x10
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 
 function %atomic_rmw_xor_i64(i64, i64, i64) -> i64 {
@@ -583,16 +553,16 @@ block0(v0: i64, v1: i64, v2: i64):
 
 ; VCode:
 ; block0:
-;   lrvgr %r2, %r4
-;   laxg %r4, %r2, 0(%r3)
-;   lrvgr %r2, %r4
+;   lrvgr %r5, %r4
+;   laxg %r3, %r5, 0(%r3)
+;   lrvgr %r2, %r3
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvgr %r2, %r4
-;   laxg %r4, %r2, 0(%r3)
-;   lrvgr %r2, %r4
+;   lrvgr %r5, %r4
+;   laxg %r3, %r5, 0(%r3) ; trap: heap_oob
+;   lrvgr %r2, %r3
 ;   br %r14
 
 function %atomic_rmw_xor_i32(i64, i64, i32) -> i32 {
@@ -603,16 +573,16 @@ block0(v0: i64, v1: i64, v2: i32):
 
 ; VCode:
 ; block0:
-;   lrvr %r2, %r4
-;   lax %r4, %r2, 0(%r3)
-;   lrvr %r2, %r4
+;   lrvr %r5, %r4
+;   lax %r3, %r5, 0(%r3)
+;   lrvr %r2, %r3
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvr %r2, %r4
-;   lax %r4, %r2, 0(%r3)
-;   lrvr %r2, %r4
+;   lrvr %r5, %r4
+;   lax %r3, %r5, 0(%r3) ; trap: heap_oob
+;   lrvr %r2, %r3
 ;   br %r14
 
 function %atomic_rmw_xor_i16(i64, i64, i16) -> i16 {
@@ -623,32 +593,28 @@ block0(v0: i64, v1: i64, v2: i16):
 
 ; VCode:
 ; block0:
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 65532
-;   lrvr %r3, %r5
-;   l %r0, 0(%r4)
-;   0: rll %r1, %r0, 16(%r2) ; rxsbg %r1, %r3, 48, 64, 48 ; rll %r1, %r1, 16(%r2) ; cs %r0, %r1, 0(%r4) ; jglh 0b ; 1:
-;   rll %r2, %r0, 0(%r2)
-;   lrvr %r2, %r2
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   lrvr %r2, %r4
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 16(%r5) ; rxsbg %r1, %r2, 48, 64, 48 ; rll %r1, %r1, 16(%r5) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r5, %r0, 0(%r5)
+;   lrvr %r2, %r5
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 0xfffc
-;   lrvr %r3, %r5
-;   l %r0, 0(%r4)
-;   rll %r1, %r0, 0x10(%r2)
-;   rxsbg %r1, %r3, 0x30, 0x40, 0x30
-;   rll %r1, %r1, 0x10(%r2)
-;   cs %r0, %r1, 0(%r4)
-;   jglh 0x1a
-;   rll %r2, %r0, 0(%r2)
-;   lrvr %r2, %r2
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   lrvr %r2, %r4
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0x10(%r5)
+;   rxsbg %r1, %r2, 0x30, 0x40, 0x30
+;   rll %r1, %r1, 0x10(%r5)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x12
+;   rll %r5, %r0, 0(%r5)
+;   lrvr %r2, %r5
 ;   br %r14
 
 function %atomic_rmw_xor_i8(i64, i64, i8) -> i8 {
@@ -659,28 +625,26 @@ block0(v0: i64, v1: i64, v2: i8):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   lcr %r3, %r2
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; rxsbg %r1, %r4, 32, 40, 24 ; rll %r1, %r1, 0(%r3) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 8(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   lcr %r2, %r5
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; rxsbg %r1, %r4, 32, 40, 24 ; rll %r1, %r1, 0(%r2) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   lcr %r3, %r2
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   lcr %r2, %r5
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
 ;   rxsbg %r1, %r4, 0x20, 0x28, 0x18
-;   rll %r1, %r1, 0(%r3)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x14
-;   rll %r2, %r0, 8(%r2)
+;   rll %r1, %r1, 0(%r2)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x10
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 
 function %atomic_rmw_nand_i64(i64, i64, i64) -> i64 {
@@ -691,20 +655,20 @@ block0(v0: i64, v1: i64, v2: i64):
 
 ; VCode:
 ; block0:
-;   lrvgr %r2, %r4
+;   lrvgr %r5, %r4
 ;   lg %r0, 0(%r3)
-;   0: ngrk %r1, %r0, %r2 ; xilf %r1, 4294967295 ; xihf %r1, 4294967295 ; csg %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   0: ngrk %r1, %r0, %r5 ; xilf %r1, 4294967295 ; xihf %r1, 4294967295 ; csg %r0, %r1, 0(%r3) ; jglh 0b ; 1:
 ;   lrvgr %r2, %r0
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvgr %r2, %r4
-;   lg %r0, 0(%r3)
-;   ngrk %r1, %r0, %r2
+;   lrvgr %r5, %r4
+;   lg %r0, 0(%r3) ; trap: heap_oob
+;   ngrk %r1, %r0, %r5
 ;   xilf %r1, 0xffffffff
 ;   xihf %r1, 0xffffffff
-;   csg %r0, %r1, 0(%r3)
+;   csg %r0, %r1, 0(%r3) ; trap: heap_oob
 ;   jglh 0xa
 ;   lrvgr %r2, %r0
 ;   br %r14
@@ -717,19 +681,19 @@ block0(v0: i64, v1: i64, v2: i32):
 
 ; VCode:
 ; block0:
-;   lrvr %r2, %r4
+;   lrvr %r5, %r4
 ;   l %r0, 0(%r3)
-;   0: nrk %r1, %r0, %r2 ; xilf %r1, 4294967295 ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   0: nrk %r1, %r0, %r5 ; xilf %r1, 4294967295 ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
 ;   lrvr %r2, %r0
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvr %r2, %r4
-;   l %r0, 0(%r3)
-;   nrk %r1, %r0, %r2
+;   lrvr %r5, %r4
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   nrk %r1, %r0, %r5
 ;   xilf %r1, 0xffffffff
-;   cs %r0, %r1, 0(%r3)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
 ;   jglh 8
 ;   lrvr %r2, %r0
 ;   br %r14
@@ -742,33 +706,29 @@ block0(v0: i64, v1: i64, v2: i16):
 
 ; VCode:
 ; block0:
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 65532
-;   lrvr %r3, %r5
-;   l %r0, 0(%r4)
-;   0: rll %r1, %r0, 16(%r2) ; rnsbg %r1, %r3, 48, 64, 48 ; xilf %r1, 65535 ; rll %r1, %r1, 16(%r2) ; cs %r0, %r1, 0(%r4) ; jglh 0b ; 1:
-;   rll %r2, %r0, 0(%r2)
-;   lrvr %r2, %r2
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   lrvr %r2, %r4
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 16(%r5) ; rnsbg %r1, %r2, 48, 64, 48 ; xilf %r1, 65535 ; rll %r1, %r1, 16(%r5) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r5, %r0, 0(%r5)
+;   lrvr %r2, %r5
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 0xfffc
-;   lrvr %r3, %r5
-;   l %r0, 0(%r4)
-;   rll %r1, %r0, 0x10(%r2)
-;   rnsbg %r1, %r3, 0x30, 0x40, 0x30
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   lrvr %r2, %r4
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0x10(%r5)
+;   rnsbg %r1, %r2, 0x30, 0x40, 0x30
 ;   xilf %r1, 0xffff
-;   rll %r1, %r1, 0x10(%r2)
-;   cs %r0, %r1, 0(%r4)
-;   jglh 0x1a
-;   rll %r2, %r0, 0(%r2)
-;   lrvr %r2, %r2
+;   rll %r1, %r1, 0x10(%r5)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x12
+;   rll %r5, %r0, 0(%r5)
+;   lrvr %r2, %r5
 ;   br %r14
 
 function %atomic_rmw_nand_i8(i64, i64, i8) -> i8 {
@@ -779,29 +739,27 @@ block0(v0: i64, v1: i64, v2: i8):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   lcr %r3, %r2
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; rnsbg %r1, %r4, 32, 40, 24 ; xilf %r1, 4278190080 ; rll %r1, %r1, 0(%r3) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 8(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   lcr %r2, %r5
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; rnsbg %r1, %r4, 32, 40, 24 ; xilf %r1, 4278190080 ; rll %r1, %r1, 0(%r2) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   lcr %r3, %r2
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   lcr %r2, %r5
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
 ;   rnsbg %r1, %r4, 0x20, 0x28, 0x18
 ;   xilf %r1, 0xff000000
-;   rll %r1, %r1, 0(%r3)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x14
-;   rll %r2, %r0, 8(%r2)
+;   rll %r1, %r1, 0(%r2)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x10
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 
 function %atomic_rmw_smin_i64(i64, i64, i64) -> i64 {
@@ -819,12 +777,12 @@ block0(v0: i64, v1: i64, v2: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lg %r0, 0(%r3)
+;   lg %r0, 0(%r3) ; trap: heap_oob
 ;   lrvgr %r1, %r0
 ;   cgr %r4, %r1
 ;   jgnl 0x24
 ;   lrvgr %r1, %r4
-;   csg %r0, %r1, 0(%r3)
+;   csg %r0, %r1, 0(%r3) ; trap: heap_oob
 ;   jglh 6
 ;   lrvgr %r2, %r0
 ;   br %r14
@@ -844,12 +802,12 @@ block0(v0: i64, v1: i64, v2: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   l %r0, 0(%r3)
+;   l %r0, 0(%r3) ; trap: heap_oob
 ;   lrvr %r1, %r0
 ;   cr %r4, %r1
 ;   jgnl 0x1e
 ;   lrvr %r1, %r4
-;   cs %r0, %r1, 0(%r3)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
 ;   jglh 4
 ;   lrvr %r2, %r0
 ;   br %r14
@@ -862,36 +820,32 @@ block0(v0: i64, v1: i64, v2: i16):
 
 ; VCode:
 ; block0:
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 65532
-;   sllk %r3, %r5, 16
-;   l %r0, 0(%r4)
-;   0: rll %r1, %r0, 16(%r2) ; lrvr %r1, %r1 ; cr %r3, %r1 ; jgnl 1f ; risbgn %r1, %r3, 32, 48, 0 ; lrvr %r1, %r1 ; rll %r1, %r1, 16(%r2) ; cs %r0, %r1, 0(%r4) ; jglh 0b ; 1:
-;   rll %r2, %r0, 0(%r2)
-;   lrvr %r2, %r2
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   sllk %r2, %r4, 16
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 16(%r5) ; lrvr %r1, %r1 ; cr %r2, %r1 ; jgnl 1f ; risbgn %r1, %r2, 32, 48, 0 ; lrvr %r1, %r1 ; rll %r1, %r1, 16(%r5) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r5, %r0, 0(%r5)
+;   lrvr %r2, %r5
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 0xfffc
-;   sllk %r3, %r5, 0x10
-;   l %r0, 0(%r4)
-;   rll %r1, %r0, 0x10(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   sllk %r2, %r4, 0x10
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0x10(%r5)
 ;   lrvr %r1, %r1
-;   cr %r3, %r1
-;   jgnl 0x48
-;   risbgn %r1, %r3, 0x20, 0x30, 0
+;   cr %r2, %r1
+;   jgnl 0x40
+;   risbgn %r1, %r2, 0x20, 0x30, 0
 ;   lrvr %r1, %r1
-;   rll %r1, %r1, 0x10(%r2)
-;   cs %r0, %r1, 0(%r4)
-;   jglh 0x1c
-;   rll %r2, %r0, 0(%r2)
-;   lrvr %r2, %r2
+;   rll %r1, %r1, 0x10(%r5)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x14
+;   rll %r5, %r0, 0(%r5)
+;   lrvr %r2, %r5
 ;   br %r14
 
 function %atomic_rmw_smin_i8(i64, i64, i8) -> i8 {
@@ -902,32 +856,30 @@ block0(v0: i64, v1: i64, v2: i8):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   sllk %r3, %r4, 24
-;   lcr %r4, %r2
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; cr %r3, %r1 ; jgnl 1f ; risbgn %r1, %r3, 32, 40, 0 ; rll %r1, %r1, 0(%r4) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 8(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   sllk %r2, %r4, 24
+;   lcr %r4, %r5
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; cr %r2, %r1 ; jgnl 1f ; risbgn %r1, %r2, 32, 40, 0 ; rll %r1, %r1, 0(%r4) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   sllk %r3, %r4, 0x18
-;   lcr %r4, %r2
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
-;   cr %r3, %r1
-;   jgnl 0x3e
-;   risbgn %r1, %r3, 0x20, 0x28, 0
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   sllk %r2, %r4, 0x18
+;   lcr %r4, %r5
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
+;   cr %r2, %r1
+;   jgnl 0x3a
+;   risbgn %r1, %r2, 0x20, 0x28, 0
 ;   rll %r1, %r1, 0(%r4)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x1a
-;   rll %r2, %r0, 8(%r2)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x16
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 
 function %atomic_rmw_smax_i64(i64, i64, i64) -> i64 {
@@ -945,12 +897,12 @@ block0(v0: i64, v1: i64, v2: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lg %r0, 0(%r3)
+;   lg %r0, 0(%r3) ; trap: heap_oob
 ;   lrvgr %r1, %r0
 ;   cgr %r4, %r1
 ;   jgnh 0x24
 ;   lrvgr %r1, %r4
-;   csg %r0, %r1, 0(%r3)
+;   csg %r0, %r1, 0(%r3) ; trap: heap_oob
 ;   jglh 6
 ;   lrvgr %r2, %r0
 ;   br %r14
@@ -970,12 +922,12 @@ block0(v0: i64, v1: i64, v2: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   l %r0, 0(%r3)
+;   l %r0, 0(%r3) ; trap: heap_oob
 ;   lrvr %r1, %r0
 ;   cr %r4, %r1
 ;   jgnh 0x1e
 ;   lrvr %r1, %r4
-;   cs %r0, %r1, 0(%r3)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
 ;   jglh 4
 ;   lrvr %r2, %r0
 ;   br %r14
@@ -988,36 +940,32 @@ block0(v0: i64, v1: i64, v2: i16):
 
 ; VCode:
 ; block0:
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 65532
-;   sllk %r3, %r5, 16
-;   l %r0, 0(%r4)
-;   0: rll %r1, %r0, 16(%r2) ; lrvr %r1, %r1 ; cr %r3, %r1 ; jgnh 1f ; risbgn %r1, %r3, 32, 48, 0 ; lrvr %r1, %r1 ; rll %r1, %r1, 16(%r2) ; cs %r0, %r1, 0(%r4) ; jglh 0b ; 1:
-;   rll %r2, %r0, 0(%r2)
-;   lrvr %r2, %r2
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   sllk %r2, %r4, 16
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 16(%r5) ; lrvr %r1, %r1 ; cr %r2, %r1 ; jgnh 1f ; risbgn %r1, %r2, 32, 48, 0 ; lrvr %r1, %r1 ; rll %r1, %r1, 16(%r5) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r5, %r0, 0(%r5)
+;   lrvr %r2, %r5
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 0xfffc
-;   sllk %r3, %r5, 0x10
-;   l %r0, 0(%r4)
-;   rll %r1, %r0, 0x10(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   sllk %r2, %r4, 0x10
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0x10(%r5)
 ;   lrvr %r1, %r1
-;   cr %r3, %r1
-;   jgnh 0x48
-;   risbgn %r1, %r3, 0x20, 0x30, 0
+;   cr %r2, %r1
+;   jgnh 0x40
+;   risbgn %r1, %r2, 0x20, 0x30, 0
 ;   lrvr %r1, %r1
-;   rll %r1, %r1, 0x10(%r2)
-;   cs %r0, %r1, 0(%r4)
-;   jglh 0x1c
-;   rll %r2, %r0, 0(%r2)
-;   lrvr %r2, %r2
+;   rll %r1, %r1, 0x10(%r5)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x14
+;   rll %r5, %r0, 0(%r5)
+;   lrvr %r2, %r5
 ;   br %r14
 
 function %atomic_rmw_smax_i8(i64, i64, i8) -> i8 {
@@ -1028,32 +976,30 @@ block0(v0: i64, v1: i64, v2: i8):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   sllk %r3, %r4, 24
-;   lcr %r4, %r2
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; cr %r3, %r1 ; jgnh 1f ; risbgn %r1, %r3, 32, 40, 0 ; rll %r1, %r1, 0(%r4) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 8(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   sllk %r2, %r4, 24
+;   lcr %r4, %r5
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; cr %r2, %r1 ; jgnh 1f ; risbgn %r1, %r2, 32, 40, 0 ; rll %r1, %r1, 0(%r4) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   sllk %r3, %r4, 0x18
-;   lcr %r4, %r2
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
-;   cr %r3, %r1
-;   jgnh 0x3e
-;   risbgn %r1, %r3, 0x20, 0x28, 0
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   sllk %r2, %r4, 0x18
+;   lcr %r4, %r5
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
+;   cr %r2, %r1
+;   jgnh 0x3a
+;   risbgn %r1, %r2, 0x20, 0x28, 0
 ;   rll %r1, %r1, 0(%r4)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x1a
-;   rll %r2, %r0, 8(%r2)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x16
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 
 function %atomic_rmw_umin_i64(i64, i64, i64) -> i64 {
@@ -1071,12 +1017,12 @@ block0(v0: i64, v1: i64, v2: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lg %r0, 0(%r3)
+;   lg %r0, 0(%r3) ; trap: heap_oob
 ;   lrvgr %r1, %r0
 ;   clgr %r4, %r1
 ;   jgnl 0x24
 ;   lrvgr %r1, %r4
-;   csg %r0, %r1, 0(%r3)
+;   csg %r0, %r1, 0(%r3) ; trap: heap_oob
 ;   jglh 6
 ;   lrvgr %r2, %r0
 ;   br %r14
@@ -1096,12 +1042,12 @@ block0(v0: i64, v1: i64, v2: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   l %r0, 0(%r3)
+;   l %r0, 0(%r3) ; trap: heap_oob
 ;   lrvr %r1, %r0
 ;   clr %r4, %r1
 ;   jgnl 0x1e
 ;   lrvr %r1, %r4
-;   cs %r0, %r1, 0(%r3)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
 ;   jglh 4
 ;   lrvr %r2, %r0
 ;   br %r14
@@ -1114,36 +1060,32 @@ block0(v0: i64, v1: i64, v2: i16):
 
 ; VCode:
 ; block0:
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 65532
-;   sllk %r3, %r5, 16
-;   l %r0, 0(%r4)
-;   0: rll %r1, %r0, 16(%r2) ; lrvr %r1, %r1 ; clr %r3, %r1 ; jgnl 1f ; risbgn %r1, %r3, 32, 48, 0 ; lrvr %r1, %r1 ; rll %r1, %r1, 16(%r2) ; cs %r0, %r1, 0(%r4) ; jglh 0b ; 1:
-;   rll %r2, %r0, 0(%r2)
-;   lrvr %r2, %r2
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   sllk %r2, %r4, 16
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 16(%r5) ; lrvr %r1, %r1 ; clr %r2, %r1 ; jgnl 1f ; risbgn %r1, %r2, 32, 48, 0 ; lrvr %r1, %r1 ; rll %r1, %r1, 16(%r5) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r5, %r0, 0(%r5)
+;   lrvr %r2, %r5
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 0xfffc
-;   sllk %r3, %r5, 0x10
-;   l %r0, 0(%r4)
-;   rll %r1, %r0, 0x10(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   sllk %r2, %r4, 0x10
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0x10(%r5)
 ;   lrvr %r1, %r1
-;   clr %r3, %r1
-;   jgnl 0x48
-;   risbgn %r1, %r3, 0x20, 0x30, 0
+;   clr %r2, %r1
+;   jgnl 0x40
+;   risbgn %r1, %r2, 0x20, 0x30, 0
 ;   lrvr %r1, %r1
-;   rll %r1, %r1, 0x10(%r2)
-;   cs %r0, %r1, 0(%r4)
-;   jglh 0x1c
-;   rll %r2, %r0, 0(%r2)
-;   lrvr %r2, %r2
+;   rll %r1, %r1, 0x10(%r5)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x14
+;   rll %r5, %r0, 0(%r5)
+;   lrvr %r2, %r5
 ;   br %r14
 
 function %atomic_rmw_umin_i8(i64, i64, i8) -> i8 {
@@ -1154,32 +1096,30 @@ block0(v0: i64, v1: i64, v2: i8):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   sllk %r3, %r4, 24
-;   lcr %r4, %r2
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; clr %r3, %r1 ; jgnl 1f ; risbgn %r1, %r3, 32, 40, 0 ; rll %r1, %r1, 0(%r4) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 8(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   sllk %r2, %r4, 24
+;   lcr %r4, %r5
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; clr %r2, %r1 ; jgnl 1f ; risbgn %r1, %r2, 32, 40, 0 ; rll %r1, %r1, 0(%r4) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   sllk %r3, %r4, 0x18
-;   lcr %r4, %r2
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
-;   clr %r3, %r1
-;   jgnl 0x3e
-;   risbgn %r1, %r3, 0x20, 0x28, 0
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   sllk %r2, %r4, 0x18
+;   lcr %r4, %r5
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
+;   clr %r2, %r1
+;   jgnl 0x3a
+;   risbgn %r1, %r2, 0x20, 0x28, 0
 ;   rll %r1, %r1, 0(%r4)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x1a
-;   rll %r2, %r0, 8(%r2)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x16
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 
 function %atomic_rmw_umax_i64(i64, i64, i64) -> i64 {
@@ -1197,12 +1137,12 @@ block0(v0: i64, v1: i64, v2: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lg %r0, 0(%r3)
+;   lg %r0, 0(%r3) ; trap: heap_oob
 ;   lrvgr %r1, %r0
 ;   clgr %r4, %r1
 ;   jgnh 0x24
 ;   lrvgr %r1, %r4
-;   csg %r0, %r1, 0(%r3)
+;   csg %r0, %r1, 0(%r3) ; trap: heap_oob
 ;   jglh 6
 ;   lrvgr %r2, %r0
 ;   br %r14
@@ -1222,12 +1162,12 @@ block0(v0: i64, v1: i64, v2: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   l %r0, 0(%r3)
+;   l %r0, 0(%r3) ; trap: heap_oob
 ;   lrvr %r1, %r0
 ;   clr %r4, %r1
 ;   jgnh 0x1e
 ;   lrvr %r1, %r4
-;   cs %r0, %r1, 0(%r3)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
 ;   jglh 4
 ;   lrvr %r2, %r0
 ;   br %r14
@@ -1240,36 +1180,32 @@ block0(v0: i64, v1: i64, v2: i16):
 
 ; VCode:
 ; block0:
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 65532
-;   sllk %r3, %r5, 16
-;   l %r0, 0(%r4)
-;   0: rll %r1, %r0, 16(%r2) ; lrvr %r1, %r1 ; clr %r3, %r1 ; jgnh 1f ; risbgn %r1, %r3, 32, 48, 0 ; lrvr %r1, %r1 ; rll %r1, %r1, 16(%r2) ; cs %r0, %r1, 0(%r4) ; jglh 0b ; 1:
-;   rll %r2, %r0, 0(%r2)
-;   lrvr %r2, %r2
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   sllk %r2, %r4, 16
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 16(%r5) ; lrvr %r1, %r1 ; clr %r2, %r1 ; jgnh 1f ; risbgn %r1, %r2, 32, 48, 0 ; lrvr %r1, %r1 ; rll %r1, %r1, 16(%r5) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r5, %r0, 0(%r5)
+;   lrvr %r2, %r5
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 0xfffc
-;   sllk %r3, %r5, 0x10
-;   l %r0, 0(%r4)
-;   rll %r1, %r0, 0x10(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   sllk %r2, %r4, 0x10
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0x10(%r5)
 ;   lrvr %r1, %r1
-;   clr %r3, %r1
-;   jgnh 0x48
-;   risbgn %r1, %r3, 0x20, 0x30, 0
+;   clr %r2, %r1
+;   jgnh 0x40
+;   risbgn %r1, %r2, 0x20, 0x30, 0
 ;   lrvr %r1, %r1
-;   rll %r1, %r1, 0x10(%r2)
-;   cs %r0, %r1, 0(%r4)
-;   jglh 0x1c
-;   rll %r2, %r0, 0(%r2)
-;   lrvr %r2, %r2
+;   rll %r1, %r1, 0x10(%r5)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x14
+;   rll %r5, %r0, 0(%r5)
+;   lrvr %r2, %r5
 ;   br %r14
 
 function %atomic_rmw_umax_i8(i64, i64, i8) -> i8 {
@@ -1280,31 +1216,29 @@ block0(v0: i64, v1: i64, v2: i8):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   sllk %r3, %r4, 24
-;   lcr %r4, %r2
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; clr %r3, %r1 ; jgnh 1f ; risbgn %r1, %r3, 32, 40, 0 ; rll %r1, %r1, 0(%r4) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 8(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   sllk %r2, %r4, 24
+;   lcr %r4, %r5
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; clr %r2, %r1 ; jgnh 1f ; risbgn %r1, %r2, 32, 40, 0 ; rll %r1, %r1, 0(%r4) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   sllk %r3, %r4, 0x18
-;   lcr %r4, %r2
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
-;   clr %r3, %r1
-;   jgnh 0x3e
-;   risbgn %r1, %r3, 0x20, 0x28, 0
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   sllk %r2, %r4, 0x18
+;   lcr %r4, %r5
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
+;   clr %r2, %r1
+;   jgnh 0x3a
+;   risbgn %r1, %r2, 0x20, 0x28, 0
 ;   rll %r1, %r1, 0(%r4)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x1a
-;   rll %r2, %r0, 8(%r2)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x16
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 
diff --git a/cranelift/filetests/filetests/isa/s390x/atomic_rmw.clif b/cranelift/filetests/filetests/isa/s390x/atomic_rmw.clif
index 50366a46feff..ec38ec433af4 100644
--- a/cranelift/filetests/filetests/isa/s390x/atomic_rmw.clif
+++ b/cranelift/filetests/filetests/isa/s390x/atomic_rmw.clif
@@ -20,8 +20,8 @@ block0(v0: i64, v1: i64, v2: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lg %r0, 0(%r3)
-;   csg %r0, %r4, 0(%r3)
+;   lg %r0, 0(%r3) ; trap: heap_oob
+;   csg %r0, %r4, 0(%r3) ; trap: heap_oob
 ;   jglh 6
 ;   lgr %r2, %r0
 ;   br %r14
@@ -41,8 +41,8 @@ block0(v0: i64, v1: i64, v2: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   l %r0, 0(%r3)
-;   cs %r0, %r4, 0(%r3)
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   cs %r0, %r4, 0(%r3) ; trap: heap_oob
 ;   jglh 4
 ;   lgr %r2, %r0
 ;   br %r14
@@ -55,26 +55,24 @@ block0(v0: i64, v1: i64, v2: i16):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; risbgn %r1, %r4, 32, 48, 16 ; rll %r1, %r1, 0(%r2) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 16(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; risbgn %r1, %r4, 32, 48, 16 ; rll %r1, %r1, 0(%r5) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 16(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
 ;   risbgn %r1, %r4, 0x20, 0x30, 0x10
-;   rll %r1, %r1, 0(%r2)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x12
-;   rll %r2, %r0, 0x10(%r2)
+;   rll %r1, %r1, 0(%r5)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0xe
+;   rll %r2, %r0, 0x10(%r5)
 ;   br %r14
 
 function %atomic_rmw_xchg_i8(i64, i64, i8) -> i8 {
@@ -85,28 +83,26 @@ block0(v0: i64, v1: i64, v2: i8):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   lcr %r3, %r2
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; risbgn %r1, %r4, 32, 40, 24 ; rll %r1, %r1, 0(%r3) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 8(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   lcr %r2, %r5
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; risbgn %r1, %r4, 32, 40, 24 ; rll %r1, %r1, 0(%r2) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   lcr %r3, %r2
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   lcr %r2, %r5
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
 ;   risbgn %r1, %r4, 0x20, 0x28, 0x18
-;   rll %r1, %r1, 0(%r3)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x14
-;   rll %r2, %r0, 8(%r2)
+;   rll %r1, %r1, 0(%r2)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x10
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 
 function %atomic_rmw_add_i64(i64, i64) -> i64 {
@@ -122,7 +118,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   laag %r2, %r3, 0(%r2)
+;   laag %r2, %r3, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %atomic_rmw_add_i32(i64, i32) -> i32 {
@@ -138,7 +134,7 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   laa %r2, %r3, 0(%r2)
+;   laa %r2, %r3, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %atomic_rmw_add_i16(i64, i64, i16) -> i16 {
@@ -149,30 +145,26 @@ block0(v0: i64, v1: i64, v2: i16):
 
 ; VCode:
 ; block0:
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 65532
-;   sllk %r3, %r5, 16
-;   l %r0, 0(%r4)
-;   0: rll %r1, %r0, 0(%r2) ; ar %r1, %r3 ; rll %r1, %r1, 0(%r2) ; cs %r0, %r1, 0(%r4) ; jglh 0b ; 1:
-;   rll %r2, %r0, 16(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   sllk %r2, %r4, 16
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; ar %r1, %r2 ; rll %r1, %r1, 0(%r5) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 16(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 0xfffc
-;   sllk %r3, %r5, 0x10
-;   l %r0, 0(%r4)
-;   rll %r1, %r0, 0(%r2)
-;   ar %r1, %r3
-;   rll %r1, %r1, 0(%r2)
-;   cs %r0, %r1, 0(%r4)
-;   jglh 0x1c
-;   rll %r2, %r0, 0x10(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   sllk %r2, %r4, 0x10
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
+;   ar %r1, %r2
+;   rll %r1, %r1, 0(%r5)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x14
+;   rll %r2, %r0, 0x10(%r5)
 ;   br %r14
 
 function %atomic_rmw_add_i8(i64, i64, i8) -> i8 {
@@ -183,30 +175,28 @@ block0(v0: i64, v1: i64, v2: i8):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   sllk %r3, %r4, 24
-;   lcr %r4, %r2
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; ar %r1, %r3 ; rll %r1, %r1, 0(%r4) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 8(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   sllk %r2, %r4, 24
+;   lcr %r4, %r5
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; ar %r1, %r2 ; rll %r1, %r1, 0(%r4) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   sllk %r3, %r4, 0x18
-;   lcr %r4, %r2
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
-;   ar %r1, %r3
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   sllk %r2, %r4, 0x18
+;   lcr %r4, %r5
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
+;   ar %r1, %r2
 ;   rll %r1, %r1, 0(%r4)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x1a
-;   rll %r2, %r0, 8(%r2)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x16
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 
 function %atomic_rmw_sub_i64(i64, i64) -> i64 {
@@ -224,7 +214,7 @@ block0(v0: i64, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   lcgr %r5, %r3
-;   laag %r2, %r5, 0(%r2)
+;   laag %r2, %r5, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %atomic_rmw_sub_i32(i64, i32) -> i32 {
@@ -242,7 +232,7 @@ block0(v0: i64, v1: i32):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   lcr %r5, %r3
-;   laa %r2, %r5, 0(%r2)
+;   laa %r2, %r5, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %atomic_rmw_sub_i16(i64, i64, i16) -> i16 {
@@ -253,30 +243,26 @@ block0(v0: i64, v1: i64, v2: i16):
 
 ; VCode:
 ; block0:
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 65532
-;   sllk %r3, %r5, 16
-;   l %r0, 0(%r4)
-;   0: rll %r1, %r0, 0(%r2) ; sr %r1, %r3 ; rll %r1, %r1, 0(%r2) ; cs %r0, %r1, 0(%r4) ; jglh 0b ; 1:
-;   rll %r2, %r0, 16(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   sllk %r2, %r4, 16
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; sr %r1, %r2 ; rll %r1, %r1, 0(%r5) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 16(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 0xfffc
-;   sllk %r3, %r5, 0x10
-;   l %r0, 0(%r4)
-;   rll %r1, %r0, 0(%r2)
-;   sr %r1, %r3
-;   rll %r1, %r1, 0(%r2)
-;   cs %r0, %r1, 0(%r4)
-;   jglh 0x1c
-;   rll %r2, %r0, 0x10(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   sllk %r2, %r4, 0x10
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
+;   sr %r1, %r2
+;   rll %r1, %r1, 0(%r5)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x14
+;   rll %r2, %r0, 0x10(%r5)
 ;   br %r14
 
 function %atomic_rmw_sub_i8(i64, i64, i8) -> i8 {
@@ -287,30 +273,28 @@ block0(v0: i64, v1: i64, v2: i8):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   sllk %r3, %r4, 24
-;   lcr %r4, %r2
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; sr %r1, %r3 ; rll %r1, %r1, 0(%r4) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 8(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   sllk %r2, %r4, 24
+;   lcr %r4, %r5
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; sr %r1, %r2 ; rll %r1, %r1, 0(%r4) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   sllk %r3, %r4, 0x18
-;   lcr %r4, %r2
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
-;   sr %r1, %r3
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   sllk %r2, %r4, 0x18
+;   lcr %r4, %r5
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
+;   sr %r1, %r2
 ;   rll %r1, %r1, 0(%r4)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x1a
-;   rll %r2, %r0, 8(%r2)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x16
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 
 function %atomic_rmw_and_i64(i64, i64) -> i64 {
@@ -326,7 +310,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lang %r2, %r3, 0(%r2)
+;   lang %r2, %r3, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %atomic_rmw_and_i32(i64, i32) -> i32 {
@@ -342,7 +326,7 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lan %r2, %r3, 0(%r2)
+;   lan %r2, %r3, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %atomic_rmw_and_i16(i64, i64, i16) -> i16 {
@@ -353,26 +337,24 @@ block0(v0: i64, v1: i64, v2: i16):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; rnsbg %r1, %r4, 32, 48, 16 ; rll %r1, %r1, 0(%r2) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 16(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; rnsbg %r1, %r4, 32, 48, 16 ; rll %r1, %r1, 0(%r5) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 16(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
 ;   rnsbg %r1, %r4, 0x20, 0x30, 0x10
-;   rll %r1, %r1, 0(%r2)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x12
-;   rll %r2, %r0, 0x10(%r2)
+;   rll %r1, %r1, 0(%r5)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0xe
+;   rll %r2, %r0, 0x10(%r5)
 ;   br %r14
 
 function %atomic_rmw_and_i8(i64, i64, i8) -> i8 {
@@ -383,28 +365,26 @@ block0(v0: i64, v1: i64, v2: i8):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   lcr %r3, %r2
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; rnsbg %r1, %r4, 32, 40, 24 ; rll %r1, %r1, 0(%r3) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 8(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   lcr %r2, %r5
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; rnsbg %r1, %r4, 32, 40, 24 ; rll %r1, %r1, 0(%r2) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   lcr %r3, %r2
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   lcr %r2, %r5
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
 ;   rnsbg %r1, %r4, 0x20, 0x28, 0x18
-;   rll %r1, %r1, 0(%r3)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x14
-;   rll %r2, %r0, 8(%r2)
+;   rll %r1, %r1, 0(%r2)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x10
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 
 function %atomic_rmw_or_i64(i64, i64) -> i64 {
@@ -420,7 +400,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   laog %r2, %r3, 0(%r2)
+;   laog %r2, %r3, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %atomic_rmw_or_i32(i64, i32) -> i32 {
@@ -436,7 +416,7 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lao %r2, %r3, 0(%r2)
+;   lao %r2, %r3, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %atomic_rmw_or_i16(i64, i64, i16) -> i16 {
@@ -447,26 +427,24 @@ block0(v0: i64, v1: i64, v2: i16):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; rosbg %r1, %r4, 32, 48, 16 ; rll %r1, %r1, 0(%r2) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 16(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; rosbg %r1, %r4, 32, 48, 16 ; rll %r1, %r1, 0(%r5) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 16(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
 ;   rosbg %r1, %r4, 0x20, 0x30, 0x10
-;   rll %r1, %r1, 0(%r2)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x12
-;   rll %r2, %r0, 0x10(%r2)
+;   rll %r1, %r1, 0(%r5)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0xe
+;   rll %r2, %r0, 0x10(%r5)
 ;   br %r14
 
 function %atomic_rmw_or_i8(i64, i64, i8) -> i8 {
@@ -477,28 +455,26 @@ block0(v0: i64, v1: i64, v2: i8):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   lcr %r3, %r2
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; rosbg %r1, %r4, 32, 40, 24 ; rll %r1, %r1, 0(%r3) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 8(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   lcr %r2, %r5
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; rosbg %r1, %r4, 32, 40, 24 ; rll %r1, %r1, 0(%r2) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   lcr %r3, %r2
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   lcr %r2, %r5
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
 ;   rosbg %r1, %r4, 0x20, 0x28, 0x18
-;   rll %r1, %r1, 0(%r3)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x14
-;   rll %r2, %r0, 8(%r2)
+;   rll %r1, %r1, 0(%r2)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x10
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 
 function %atomic_rmw_xor_i64(i64, i64) -> i64 {
@@ -514,7 +490,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   laxg %r2, %r3, 0(%r2)
+;   laxg %r2, %r3, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %atomic_rmw_xor_i32(i64, i32) -> i32 {
@@ -530,7 +506,7 @@ block0(v0: i64, v1: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lax %r2, %r3, 0(%r2)
+;   lax %r2, %r3, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %atomic_rmw_xor_i16(i64, i64, i16) -> i16 {
@@ -541,26 +517,24 @@ block0(v0: i64, v1: i64, v2: i16):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; rxsbg %r1, %r4, 32, 48, 16 ; rll %r1, %r1, 0(%r2) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 16(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; rxsbg %r1, %r4, 32, 48, 16 ; rll %r1, %r1, 0(%r5) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 16(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
 ;   rxsbg %r1, %r4, 0x20, 0x30, 0x10
-;   rll %r1, %r1, 0(%r2)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x12
-;   rll %r2, %r0, 0x10(%r2)
+;   rll %r1, %r1, 0(%r5)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0xe
+;   rll %r2, %r0, 0x10(%r5)
 ;   br %r14
 
 function %atomic_rmw_xor_i8(i64, i64, i8) -> i8 {
@@ -571,28 +545,26 @@ block0(v0: i64, v1: i64, v2: i8):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   lcr %r3, %r2
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; rxsbg %r1, %r4, 32, 40, 24 ; rll %r1, %r1, 0(%r3) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 8(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   lcr %r2, %r5
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; rxsbg %r1, %r4, 32, 40, 24 ; rll %r1, %r1, 0(%r2) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   lcr %r3, %r2
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   lcr %r2, %r5
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
 ;   rxsbg %r1, %r4, 0x20, 0x28, 0x18
-;   rll %r1, %r1, 0(%r3)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x14
-;   rll %r2, %r0, 8(%r2)
+;   rll %r1, %r1, 0(%r2)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x10
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 
 function %atomic_rmw_nand_i64(i64, i64, i64) -> i64 {
@@ -610,11 +582,11 @@ block0(v0: i64, v1: i64, v2: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lg %r0, 0(%r3)
+;   lg %r0, 0(%r3) ; trap: heap_oob
 ;   ngrk %r1, %r0, %r4
 ;   xilf %r1, 0xffffffff
 ;   xihf %r1, 0xffffffff
-;   csg %r0, %r1, 0(%r3)
+;   csg %r0, %r1, 0(%r3) ; trap: heap_oob
 ;   jglh 6
 ;   lgr %r2, %r0
 ;   br %r14
@@ -634,10 +606,10 @@ block0(v0: i64, v1: i64, v2: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   l %r0, 0(%r3)
+;   l %r0, 0(%r3) ; trap: heap_oob
 ;   nrk %r1, %r0, %r4
 ;   xilf %r1, 0xffffffff
-;   cs %r0, %r1, 0(%r3)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
 ;   jglh 4
 ;   lgr %r2, %r0
 ;   br %r14
@@ -650,27 +622,25 @@ block0(v0: i64, v1: i64, v2: i16):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; rnsbg %r1, %r4, 32, 48, 16 ; xilf %r1, 4294901760 ; rll %r1, %r1, 0(%r2) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 16(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; rnsbg %r1, %r4, 32, 48, 16 ; xilf %r1, 4294901760 ; rll %r1, %r1, 0(%r5) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 16(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
 ;   rnsbg %r1, %r4, 0x20, 0x30, 0x10
 ;   xilf %r1, 0xffff0000
-;   rll %r1, %r1, 0(%r2)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x12
-;   rll %r2, %r0, 0x10(%r2)
+;   rll %r1, %r1, 0(%r5)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0xe
+;   rll %r2, %r0, 0x10(%r5)
 ;   br %r14
 
 function %atomic_rmw_nand_i8(i64, i64, i8) -> i8 {
@@ -681,29 +651,27 @@ block0(v0: i64, v1: i64, v2: i8):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   lcr %r3, %r2
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; rnsbg %r1, %r4, 32, 40, 24 ; xilf %r1, 4278190080 ; rll %r1, %r1, 0(%r3) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 8(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   lcr %r2, %r5
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; rnsbg %r1, %r4, 32, 40, 24 ; xilf %r1, 4278190080 ; rll %r1, %r1, 0(%r2) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   lcr %r3, %r2
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   lcr %r2, %r5
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
 ;   rnsbg %r1, %r4, 0x20, 0x28, 0x18
 ;   xilf %r1, 0xff000000
-;   rll %r1, %r1, 0(%r3)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x14
-;   rll %r2, %r0, 8(%r2)
+;   rll %r1, %r1, 0(%r2)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x10
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 
 function %atomic_rmw_smin_i64(i64, i64, i64) -> i64 {
@@ -721,10 +689,10 @@ block0(v0: i64, v1: i64, v2: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lg %r0, 0(%r3)
+;   lg %r0, 0(%r3) ; trap: heap_oob
 ;   cgr %r4, %r0
 ;   jgnl 0x1c
-;   csg %r0, %r4, 0(%r3)
+;   csg %r0, %r4, 0(%r3) ; trap: heap_oob
 ;   jglh 6
 ;   lgr %r2, %r0
 ;   br %r14
@@ -744,10 +712,10 @@ block0(v0: i64, v1: i64, v2: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   l %r0, 0(%r3)
+;   l %r0, 0(%r3) ; trap: heap_oob
 ;   cr %r4, %r0
 ;   jgnl 0x16
-;   cs %r0, %r4, 0(%r3)
+;   cs %r0, %r4, 0(%r3) ; trap: heap_oob
 ;   jglh 4
 ;   lgr %r2, %r0
 ;   br %r14
@@ -760,32 +728,28 @@ block0(v0: i64, v1: i64, v2: i16):
 
 ; VCode:
 ; block0:
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 65532
-;   sllk %r3, %r5, 16
-;   l %r0, 0(%r4)
-;   0: rll %r1, %r0, 0(%r2) ; cr %r3, %r1 ; jgnl 1f ; risbgn %r1, %r3, 32, 48, 0 ; rll %r1, %r1, 0(%r2) ; cs %r0, %r1, 0(%r4) ; jglh 0b ; 1:
-;   rll %r2, %r0, 16(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   sllk %r2, %r4, 16
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; cr %r2, %r1 ; jgnl 1f ; risbgn %r1, %r2, 32, 48, 0 ; rll %r1, %r1, 0(%r5) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 16(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 0xfffc
-;   sllk %r3, %r5, 0x10
-;   l %r0, 0(%r4)
-;   rll %r1, %r0, 0(%r2)
-;   cr %r3, %r1
-;   jgnl 0x40
-;   risbgn %r1, %r3, 0x20, 0x30, 0
-;   rll %r1, %r1, 0(%r2)
-;   cs %r0, %r1, 0(%r4)
-;   jglh 0x1c
-;   rll %r2, %r0, 0x10(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   sllk %r2, %r4, 0x10
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
+;   cr %r2, %r1
+;   jgnl 0x38
+;   risbgn %r1, %r2, 0x20, 0x30, 0
+;   rll %r1, %r1, 0(%r5)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x14
+;   rll %r2, %r0, 0x10(%r5)
 ;   br %r14
 
 function %atomic_rmw_smin_i8(i64, i64, i8) -> i8 {
@@ -796,32 +760,30 @@ block0(v0: i64, v1: i64, v2: i8):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   sllk %r3, %r4, 24
-;   lcr %r4, %r2
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; cr %r3, %r1 ; jgnl 1f ; risbgn %r1, %r3, 32, 40, 0 ; rll %r1, %r1, 0(%r4) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 8(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   sllk %r2, %r4, 24
+;   lcr %r4, %r5
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; cr %r2, %r1 ; jgnl 1f ; risbgn %r1, %r2, 32, 40, 0 ; rll %r1, %r1, 0(%r4) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   sllk %r3, %r4, 0x18
-;   lcr %r4, %r2
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
-;   cr %r3, %r1
-;   jgnl 0x3e
-;   risbgn %r1, %r3, 0x20, 0x28, 0
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   sllk %r2, %r4, 0x18
+;   lcr %r4, %r5
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
+;   cr %r2, %r1
+;   jgnl 0x3a
+;   risbgn %r1, %r2, 0x20, 0x28, 0
 ;   rll %r1, %r1, 0(%r4)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x1a
-;   rll %r2, %r0, 8(%r2)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x16
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 
 function %atomic_rmw_smax_i64(i64, i64, i64) -> i64 {
@@ -839,10 +801,10 @@ block0(v0: i64, v1: i64, v2: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lg %r0, 0(%r3)
+;   lg %r0, 0(%r3) ; trap: heap_oob
 ;   cgr %r4, %r0
 ;   jgnh 0x1c
-;   csg %r0, %r4, 0(%r3)
+;   csg %r0, %r4, 0(%r3) ; trap: heap_oob
 ;   jglh 6
 ;   lgr %r2, %r0
 ;   br %r14
@@ -862,10 +824,10 @@ block0(v0: i64, v1: i64, v2: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   l %r0, 0(%r3)
+;   l %r0, 0(%r3) ; trap: heap_oob
 ;   cr %r4, %r0
 ;   jgnh 0x16
-;   cs %r0, %r4, 0(%r3)
+;   cs %r0, %r4, 0(%r3) ; trap: heap_oob
 ;   jglh 4
 ;   lgr %r2, %r0
 ;   br %r14
@@ -878,32 +840,28 @@ block0(v0: i64, v1: i64, v2: i16):
 
 ; VCode:
 ; block0:
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 65532
-;   sllk %r3, %r5, 16
-;   l %r0, 0(%r4)
-;   0: rll %r1, %r0, 0(%r2) ; cr %r3, %r1 ; jgnh 1f ; risbgn %r1, %r3, 32, 48, 0 ; rll %r1, %r1, 0(%r2) ; cs %r0, %r1, 0(%r4) ; jglh 0b ; 1:
-;   rll %r2, %r0, 16(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   sllk %r2, %r4, 16
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; cr %r2, %r1 ; jgnh 1f ; risbgn %r1, %r2, 32, 48, 0 ; rll %r1, %r1, 0(%r5) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 16(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 0xfffc
-;   sllk %r3, %r5, 0x10
-;   l %r0, 0(%r4)
-;   rll %r1, %r0, 0(%r2)
-;   cr %r3, %r1
-;   jgnh 0x40
-;   risbgn %r1, %r3, 0x20, 0x30, 0
-;   rll %r1, %r1, 0(%r2)
-;   cs %r0, %r1, 0(%r4)
-;   jglh 0x1c
-;   rll %r2, %r0, 0x10(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   sllk %r2, %r4, 0x10
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
+;   cr %r2, %r1
+;   jgnh 0x38
+;   risbgn %r1, %r2, 0x20, 0x30, 0
+;   rll %r1, %r1, 0(%r5)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x14
+;   rll %r2, %r0, 0x10(%r5)
 ;   br %r14
 
 function %atomic_rmw_smax_i8(i64, i64, i8) -> i8 {
@@ -914,32 +872,30 @@ block0(v0: i64, v1: i64, v2: i8):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   sllk %r3, %r4, 24
-;   lcr %r4, %r2
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; cr %r3, %r1 ; jgnh 1f ; risbgn %r1, %r3, 32, 40, 0 ; rll %r1, %r1, 0(%r4) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 8(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   sllk %r2, %r4, 24
+;   lcr %r4, %r5
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; cr %r2, %r1 ; jgnh 1f ; risbgn %r1, %r2, 32, 40, 0 ; rll %r1, %r1, 0(%r4) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   sllk %r3, %r4, 0x18
-;   lcr %r4, %r2
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
-;   cr %r3, %r1
-;   jgnh 0x3e
-;   risbgn %r1, %r3, 0x20, 0x28, 0
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   sllk %r2, %r4, 0x18
+;   lcr %r4, %r5
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
+;   cr %r2, %r1
+;   jgnh 0x3a
+;   risbgn %r1, %r2, 0x20, 0x28, 0
 ;   rll %r1, %r1, 0(%r4)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x1a
-;   rll %r2, %r0, 8(%r2)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x16
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 
 function %atomic_rmw_umin_i64(i64, i64, i64) -> i64 {
@@ -957,10 +913,10 @@ block0(v0: i64, v1: i64, v2: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lg %r0, 0(%r3)
+;   lg %r0, 0(%r3) ; trap: heap_oob
 ;   clgr %r4, %r0
 ;   jgnl 0x1c
-;   csg %r0, %r4, 0(%r3)
+;   csg %r0, %r4, 0(%r3) ; trap: heap_oob
 ;   jglh 6
 ;   lgr %r2, %r0
 ;   br %r14
@@ -980,10 +936,10 @@ block0(v0: i64, v1: i64, v2: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   l %r0, 0(%r3)
+;   l %r0, 0(%r3) ; trap: heap_oob
 ;   clr %r4, %r0
 ;   jgnl 0x16
-;   cs %r0, %r4, 0(%r3)
+;   cs %r0, %r4, 0(%r3) ; trap: heap_oob
 ;   jglh 4
 ;   lgr %r2, %r0
 ;   br %r14
@@ -996,32 +952,28 @@ block0(v0: i64, v1: i64, v2: i16):
 
 ; VCode:
 ; block0:
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 65532
-;   sllk %r3, %r5, 16
-;   l %r0, 0(%r4)
-;   0: rll %r1, %r0, 0(%r2) ; clr %r3, %r1 ; jgnl 1f ; risbgn %r1, %r3, 32, 48, 0 ; rll %r1, %r1, 0(%r2) ; cs %r0, %r1, 0(%r4) ; jglh 0b ; 1:
-;   rll %r2, %r0, 16(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   sllk %r2, %r4, 16
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; clr %r2, %r1 ; jgnl 1f ; risbgn %r1, %r2, 32, 48, 0 ; rll %r1, %r1, 0(%r5) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 16(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 0xfffc
-;   sllk %r3, %r5, 0x10
-;   l %r0, 0(%r4)
-;   rll %r1, %r0, 0(%r2)
-;   clr %r3, %r1
-;   jgnl 0x40
-;   risbgn %r1, %r3, 0x20, 0x30, 0
-;   rll %r1, %r1, 0(%r2)
-;   cs %r0, %r1, 0(%r4)
-;   jglh 0x1c
-;   rll %r2, %r0, 0x10(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   sllk %r2, %r4, 0x10
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
+;   clr %r2, %r1
+;   jgnl 0x38
+;   risbgn %r1, %r2, 0x20, 0x30, 0
+;   rll %r1, %r1, 0(%r5)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x14
+;   rll %r2, %r0, 0x10(%r5)
 ;   br %r14
 
 function %atomic_rmw_umin_i8(i64, i64, i8) -> i8 {
@@ -1032,32 +984,30 @@ block0(v0: i64, v1: i64, v2: i8):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   sllk %r3, %r4, 24
-;   lcr %r4, %r2
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; clr %r3, %r1 ; jgnl 1f ; risbgn %r1, %r3, 32, 40, 0 ; rll %r1, %r1, 0(%r4) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 8(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   sllk %r2, %r4, 24
+;   lcr %r4, %r5
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; clr %r2, %r1 ; jgnl 1f ; risbgn %r1, %r2, 32, 40, 0 ; rll %r1, %r1, 0(%r4) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   sllk %r3, %r4, 0x18
-;   lcr %r4, %r2
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
-;   clr %r3, %r1
-;   jgnl 0x3e
-;   risbgn %r1, %r3, 0x20, 0x28, 0
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   sllk %r2, %r4, 0x18
+;   lcr %r4, %r5
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
+;   clr %r2, %r1
+;   jgnl 0x3a
+;   risbgn %r1, %r2, 0x20, 0x28, 0
 ;   rll %r1, %r1, 0(%r4)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x1a
-;   rll %r2, %r0, 8(%r2)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x16
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 
 function %atomic_rmw_umax_i64(i64, i64, i64) -> i64 {
@@ -1075,10 +1025,10 @@ block0(v0: i64, v1: i64, v2: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lg %r0, 0(%r3)
+;   lg %r0, 0(%r3) ; trap: heap_oob
 ;   clgr %r4, %r0
 ;   jgnh 0x1c
-;   csg %r0, %r4, 0(%r3)
+;   csg %r0, %r4, 0(%r3) ; trap: heap_oob
 ;   jglh 6
 ;   lgr %r2, %r0
 ;   br %r14
@@ -1098,10 +1048,10 @@ block0(v0: i64, v1: i64, v2: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   l %r0, 0(%r3)
+;   l %r0, 0(%r3) ; trap: heap_oob
 ;   clr %r4, %r0
 ;   jgnh 0x16
-;   cs %r0, %r4, 0(%r3)
+;   cs %r0, %r4, 0(%r3) ; trap: heap_oob
 ;   jglh 4
 ;   lgr %r2, %r0
 ;   br %r14
@@ -1114,32 +1064,28 @@ block0(v0: i64, v1: i64, v2: i16):
 
 ; VCode:
 ; block0:
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 65532
-;   sllk %r3, %r5, 16
-;   l %r0, 0(%r4)
-;   0: rll %r1, %r0, 0(%r2) ; clr %r3, %r1 ; jgnh 1f ; risbgn %r1, %r3, 32, 48, 0 ; rll %r1, %r1, 0(%r2) ; cs %r0, %r1, 0(%r4) ; jglh 0b ; 1:
-;   rll %r2, %r0, 16(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   sllk %r2, %r4, 16
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; clr %r2, %r1 ; jgnh 1f ; risbgn %r1, %r2, 32, 48, 0 ; rll %r1, %r1, 0(%r5) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 16(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r5, %r4
-;   sllk %r2, %r3, 3
-;   lgr %r4, %r3
-;   nill %r4, 0xfffc
-;   sllk %r3, %r5, 0x10
-;   l %r0, 0(%r4)
-;   rll %r1, %r0, 0(%r2)
-;   clr %r3, %r1
-;   jgnh 0x40
-;   risbgn %r1, %r3, 0x20, 0x30, 0
-;   rll %r1, %r1, 0(%r2)
-;   cs %r0, %r1, 0(%r4)
-;   jglh 0x1c
-;   rll %r2, %r0, 0x10(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   sllk %r2, %r4, 0x10
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
+;   clr %r2, %r1
+;   jgnh 0x38
+;   risbgn %r1, %r2, 0x20, 0x30, 0
+;   rll %r1, %r1, 0(%r5)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x14
+;   rll %r2, %r0, 0x10(%r5)
 ;   br %r14
 
 function %atomic_rmw_umax_i8(i64, i64, i8) -> i8 {
@@ -1150,31 +1096,29 @@ block0(v0: i64, v1: i64, v2: i8):
 
 ; VCode:
 ; block0:
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 65532
-;   sllk %r3, %r4, 24
-;   lcr %r4, %r2
-;   l %r0, 0(%r5)
-;   0: rll %r1, %r0, 0(%r2) ; clr %r3, %r1 ; jgnh 1f ; risbgn %r1, %r3, 32, 40, 0 ; rll %r1, %r1, 0(%r4) ; cs %r0, %r1, 0(%r5) ; jglh 0b ; 1:
-;   rll %r2, %r0, 8(%r2)
+;   sllk %r5, %r3, 3
+;   nill %r3, 65532
+;   sllk %r2, %r4, 24
+;   lcr %r4, %r5
+;   l %r0, 0(%r3)
+;   0: rll %r1, %r0, 0(%r5) ; clr %r2, %r1 ; jgnh 1f ; risbgn %r1, %r2, 32, 40, 0 ; rll %r1, %r1, 0(%r4) ; cs %r0, %r1, 0(%r3) ; jglh 0b ; 1:
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sllk %r2, %r3, 3
-;   lgr %r5, %r3
-;   nill %r5, 0xfffc
-;   sllk %r3, %r4, 0x18
-;   lcr %r4, %r2
-;   l %r0, 0(%r5)
-;   rll %r1, %r0, 0(%r2)
-;   clr %r3, %r1
-;   jgnh 0x3e
-;   risbgn %r1, %r3, 0x20, 0x28, 0
+;   sllk %r5, %r3, 3
+;   nill %r3, 0xfffc
+;   sllk %r2, %r4, 0x18
+;   lcr %r4, %r5
+;   l %r0, 0(%r3) ; trap: heap_oob
+;   rll %r1, %r0, 0(%r5)
+;   clr %r2, %r1
+;   jgnh 0x3a
+;   risbgn %r1, %r2, 0x20, 0x28, 0
 ;   rll %r1, %r1, 0(%r4)
-;   cs %r0, %r1, 0(%r5)
-;   jglh 0x1a
-;   rll %r2, %r0, 8(%r2)
+;   cs %r0, %r1, 0(%r3) ; trap: heap_oob
+;   jglh 0x16
+;   rll %r2, %r0, 8(%r5)
 ;   br %r14
 
diff --git a/cranelift/filetests/filetests/isa/s390x/atomic_store-little.clif b/cranelift/filetests/filetests/isa/s390x/atomic_store-little.clif
index c9416031f731..17f8591e4ed6 100644
--- a/cranelift/filetests/filetests/isa/s390x/atomic_store-little.clif
+++ b/cranelift/filetests/filetests/isa/s390x/atomic_store-little.clif
@@ -15,7 +15,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   strvg %r2, 0(%r3)
+;   strvg %r2, 0(%r3) ; trap: heap_oob
 ;   bnor %r0
 ;   br %r14
 
@@ -36,7 +36,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   larl %r1, 0 ; reloc_external PCRel32Dbl %sym 2
-;   strvg %r2, 0(%r1)
+;   strvg %r2, 0(%r1) ; trap: heap_oob
 ;   bnor %r0
 ;   br %r14
 
@@ -57,7 +57,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   lghi %r4, 0x3039
-;   strvg %r4, 0(%r2)
+;   strvg %r4, 0(%r2) ; trap: heap_oob
 ;   bnor %r0
 ;   br %r14
 
@@ -75,7 +75,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   strv %r2, 0(%r3)
+;   strv %r2, 0(%r3) ; trap: heap_oob
 ;   bnor %r0
 ;   br %r14
 
@@ -96,7 +96,7 @@ block0(v0: i32):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   larl %r1, 0 ; reloc_external PCRel32Dbl %sym 2
-;   strv %r2, 0(%r1)
+;   strv %r2, 0(%r1) ; trap: heap_oob
 ;   bnor %r0
 ;   br %r14
 
@@ -117,7 +117,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   lhi %r4, 0x3039
-;   strv %r4, 0(%r2)
+;   strv %r4, 0(%r2) ; trap: heap_oob
 ;   bnor %r0
 ;   br %r14
 
@@ -135,7 +135,7 @@ block0(v0: i16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   strvh %r2, 0(%r3)
+;   strvh %r2, 0(%r3) ; trap: heap_oob
 ;   bnor %r0
 ;   br %r14
 
@@ -156,7 +156,7 @@ block0(v0: i16):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   larl %r1, 0 ; reloc_external PCRel32Dbl %sym 2
-;   strvh %r2, 0(%r1)
+;   strvh %r2, 0(%r1) ; trap: heap_oob
 ;   bnor %r0
 ;   br %r14
 
@@ -175,7 +175,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mvhhi 0(%r2), 0x3930
+;   mvhhi 0(%r2), 0x3930 ; trap: heap_oob
 ;   bnor %r0
 ;   br %r14
 
@@ -193,7 +193,7 @@ block0(v0: i8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stc %r2, 0(%r3)
+;   stc %r2, 0(%r3) ; trap: heap_oob
 ;   bnor %r0
 ;   br %r14
 
@@ -212,7 +212,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mvi 0(%r2), 0x7b
+;   mvi 0(%r2), 0x7b ; trap: heap_oob
 ;   bnor %r0
 ;   br %r14
 
diff --git a/cranelift/filetests/filetests/isa/s390x/atomic_store.clif b/cranelift/filetests/filetests/isa/s390x/atomic_store.clif
index 5fd1f02ad247..67270559cec9 100644
--- a/cranelift/filetests/filetests/isa/s390x/atomic_store.clif
+++ b/cranelift/filetests/filetests/isa/s390x/atomic_store.clif
@@ -15,7 +15,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stg %r2, 0(%r3)
+;   stg %r2, 0(%r3) ; trap: heap_oob
 ;   bnor %r0
 ;   br %r14
 
@@ -35,7 +35,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stgrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   stgrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   bnor %r0
 ;   br %r14
 
@@ -54,7 +54,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mvghi 0(%r2), 0x3039
+;   mvghi 0(%r2), 0x3039 ; trap: heap_oob
 ;   bnor %r0
 ;   br %r14
 
@@ -72,7 +72,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   st %r2, 0(%r3)
+;   st %r2, 0(%r3) ; trap: heap_oob
 ;   bnor %r0
 ;   br %r14
 
@@ -92,7 +92,7 @@ block0(v0: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   strl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   strl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   bnor %r0
 ;   br %r14
 
@@ -111,7 +111,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mvhi 0(%r2), 0x3039
+;   mvhi 0(%r2), 0x3039 ; trap: heap_oob
 ;   bnor %r0
 ;   br %r14
 
@@ -129,7 +129,7 @@ block0(v0: i16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sth %r2, 0(%r3)
+;   sth %r2, 0(%r3) ; trap: heap_oob
 ;   bnor %r0
 ;   br %r14
 
@@ -149,7 +149,7 @@ block0(v0: i16):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sthrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   sthrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   bnor %r0
 ;   br %r14
 
@@ -168,7 +168,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mvhhi 0(%r2), 0x3039
+;   mvhhi 0(%r2), 0x3039 ; trap: heap_oob
 ;   bnor %r0
 ;   br %r14
 
@@ -186,7 +186,7 @@ block0(v0: i8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stc %r2, 0(%r3)
+;   stc %r2, 0(%r3) ; trap: heap_oob
 ;   bnor %r0
 ;   br %r14
 
@@ -205,7 +205,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mvi 0(%r2), 0x7b
+;   mvi 0(%r2), 0x7b ; trap: heap_oob
 ;   bnor %r0
 ;   br %r14
 
diff --git a/cranelift/filetests/filetests/isa/s390x/bitcast.clif b/cranelift/filetests/filetests/isa/s390x/bitcast.clif
index f783f9058a6d..0232401dfd72 100644
--- a/cranelift/filetests/filetests/isa/s390x/bitcast.clif
+++ b/cranelift/filetests/filetests/isa/s390x/bitcast.clif
@@ -76,46 +76,3 @@ block0(v0: i128):
 ;   vl %v1, 0(%r3)
 ;   vst %v1, 0(%r2)
 ;   br %r14
-
-function %bitcast_r64_i64(r64) -> i64 {
-block0(v0: r64):
-  v1 = bitcast.i64 v0
-  return v1
-}
-
-; VCode:
-; block0:
-;   br %r14
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   br %r14
-
-function %bitcast_i64_r64(i64) -> r64 {
-block0(v0: i64):
-  v1 = bitcast.r64 v0
-  return v1
-}
-
-; VCode:
-; block0:
-;   br %r14
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   br %r14
-
-function %bitcast_r64_r64(r64) -> r64 {
-block0(v0: r64):
-  v1 = bitcast.r64 v0
-  return v1
-}
-
-; VCode:
-; block0:
-;   br %r14
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   br %r14
-
diff --git a/cranelift/filetests/filetests/isa/s390x/bitops.clif b/cranelift/filetests/filetests/isa/s390x/bitops.clif
index eda5849401a2..62fc004022bd 100644
--- a/cranelift/filetests/filetests/isa/s390x/bitops.clif
+++ b/cranelift/filetests/filetests/isa/s390x/bitops.clif
@@ -603,10 +603,9 @@ block0(v0: i64):
 ;   lcgr %r4, %r2
 ;   ngr %r2, %r4
 ;   flogr %r2, %r2
-;   lgr %r3, %r2
-;   locghie %r3, -1
+;   locghie %r2, -1
 ;   lghi %r5, 63
-;   sgrk %r2, %r5, %r3
+;   sgrk %r2, %r5, %r2
 ;   br %r14
 ;
 ; Disassembled:
@@ -614,10 +613,9 @@ block0(v0: i64):
 ;   lcgr %r4, %r2
 ;   ngr %r2, %r4
 ;   flogr %r2, %r2
-;   lgr %r3, %r2
-;   locghie %r3, -1
+;   locghie %r2, -1
 ;   lghi %r5, 0x3f
-;   sgrk %r2, %r5, %r3
+;   sgrk %r2, %r5, %r2
 ;   br %r14
 
 function %ctz_i32(i32) -> i32 {
@@ -628,10 +626,9 @@ block0(v0: i32):
 
 ; VCode:
 ; block0:
-;   lgr %r4, %r2
-;   oihl %r4, 1
-;   lcgr %r2, %r4
-;   ngr %r4, %r2
+;   oihl %r2, 1
+;   lcgr %r3, %r2
+;   ngrk %r4, %r2, %r3
 ;   flogr %r2, %r4
 ;   lhi %r5, 63
 ;   srk %r2, %r5, %r2
@@ -639,10 +636,9 @@ block0(v0: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r4, %r2
-;   oihl %r4, 1
-;   lcgr %r2, %r4
-;   ngr %r4, %r2
+;   oihl %r2, 1
+;   lcgr %r3, %r2
+;   ngrk %r4, %r2, %r3
 ;   flogr %r2, %r4
 ;   lhi %r5, 0x3f
 ;   srk %r2, %r5, %r2
@@ -656,10 +652,9 @@ block0(v0: i16):
 
 ; VCode:
 ; block0:
-;   lgr %r4, %r2
-;   oilh %r4, 1
-;   lcgr %r2, %r4
-;   ngr %r4, %r2
+;   oilh %r2, 1
+;   lcgr %r3, %r2
+;   ngrk %r4, %r2, %r3
 ;   flogr %r2, %r4
 ;   lhi %r5, 63
 ;   srk %r2, %r5, %r2
@@ -667,10 +662,9 @@ block0(v0: i16):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r4, %r2
-;   oilh %r4, 1
-;   lcgr %r2, %r4
-;   ngr %r4, %r2
+;   oilh %r2, 1
+;   lcgr %r3, %r2
+;   ngrk %r4, %r2, %r3
 ;   flogr %r2, %r4
 ;   lhi %r5, 0x3f
 ;   srk %r2, %r5, %r2
@@ -684,10 +678,9 @@ block0(v0: i8):
 
 ; VCode:
 ; block0:
-;   lgr %r4, %r2
-;   oill %r4, 256
-;   lcgr %r2, %r4
-;   ngr %r4, %r2
+;   oill %r2, 256
+;   lcgr %r3, %r2
+;   ngrk %r4, %r2, %r3
 ;   flogr %r2, %r4
 ;   lhi %r5, 63
 ;   srk %r2, %r5, %r2
@@ -695,10 +688,9 @@ block0(v0: i8):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r4, %r2
-;   oill %r4, 0x100
-;   lcgr %r2, %r4
-;   ngr %r4, %r2
+;   oill %r2, 0x100
+;   lcgr %r3, %r2
+;   ngrk %r4, %r2, %r3
 ;   flogr %r2, %r4
 ;   lhi %r5, 0x3f
 ;   srk %r2, %r5, %r2
diff --git a/cranelift/filetests/filetests/isa/s390x/bitwise.clif b/cranelift/filetests/filetests/isa/s390x/bitwise.clif
index cee8bfd674d3..df4c6b967a94 100644
--- a/cranelift/filetests/filetests/isa/s390x/bitwise.clif
+++ b/cranelift/filetests/filetests/isa/s390x/bitwise.clif
@@ -56,7 +56,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ng %r2, 0(%r3)
+;   ng %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %band_i32(i32, i32) -> i32 {
@@ -89,7 +89,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   n %r2, 0(%r3)
+;   n %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %band_i32_memoff(i32, i64) -> i32 {
@@ -106,7 +106,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ny %r2, 0x1000(%r3)
+;   ny %r2, 0x1000(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %band_i16(i16, i16) -> i16 {
@@ -140,7 +140,7 @@ block0(v0: i16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llh %r3, 0(%r3)
+;   llh %r3, 0(%r3) ; trap: heap_oob
 ;   nr %r2, %r3
 ;   br %r14
 
@@ -175,7 +175,7 @@ block0(v0: i8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llc %r3, 0(%r3)
+;   llc %r3, 0(%r3) ; trap: heap_oob
 ;   nr %r2, %r3
 ;   br %r14
 
@@ -231,7 +231,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   og %r2, 0(%r3)
+;   og %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %bor_i32(i32, i32) -> i32 {
@@ -264,7 +264,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   o %r2, 0(%r3)
+;   o %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %bor_i32_memoff(i32, i64) -> i32 {
@@ -281,7 +281,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   oy %r2, 0x1000(%r3)
+;   oy %r2, 0x1000(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %bor_i16(i16, i16) -> i16 {
@@ -315,7 +315,7 @@ block0(v0: i16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llh %r3, 0(%r3)
+;   llh %r3, 0(%r3) ; trap: heap_oob
 ;   or %r2, %r3
 ;   br %r14
 
@@ -350,7 +350,7 @@ block0(v0: i8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llc %r3, 0(%r3)
+;   llc %r3, 0(%r3) ; trap: heap_oob
 ;   or %r2, %r3
 ;   br %r14
 
@@ -406,7 +406,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   xg %r2, 0(%r3)
+;   xg %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %bxor_i32(i32, i32) -> i32 {
@@ -439,7 +439,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   x %r2, 0(%r3)
+;   x %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %bxor_i32_memoff(i32, i64) -> i32 {
@@ -456,7 +456,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   xy %r2, 0x1000(%r3)
+;   xy %r2, 0x1000(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %bxor_i16(i16, i16) -> i16 {
@@ -490,7 +490,7 @@ block0(v0: i16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llh %r3, 0(%r3)
+;   llh %r3, 0(%r3) ; trap: heap_oob
 ;   xr %r2, %r3
 ;   br %r14
 
@@ -525,7 +525,7 @@ block0(v0: i8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llc %r3, 0(%r3)
+;   llc %r3, 0(%r3) ; trap: heap_oob
 ;   xr %r2, %r3
 ;   br %r14
 
@@ -936,20 +936,18 @@ block0(v0: i64, v1: i64, v2: i64):
 ; VCode:
 ; block0:
 ;   ngr %r3, %r2
-;   lgr %r5, %r2
-;   xilf %r5, 4294967295
-;   xihf %r5, 4294967295
-;   ngr %r4, %r5
+;   xilf %r2, 4294967295
+;   xihf %r2, 4294967295
+;   ngr %r4, %r2
 ;   ogrk %r2, %r4, %r3
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   ngr %r3, %r2
-;   lgr %r5, %r2
-;   xilf %r5, 0xffffffff
-;   xihf %r5, 0xffffffff
-;   ngr %r4, %r5
+;   xilf %r2, 0xffffffff
+;   xihf %r2, 0xffffffff
+;   ngr %r4, %r2
 ;   ogrk %r2, %r4, %r3
 ;   br %r14
 
@@ -962,18 +960,16 @@ block0(v0: i32, v1: i32, v2: i32):
 ; VCode:
 ; block0:
 ;   nr %r3, %r2
-;   lgr %r5, %r2
-;   xilf %r5, 4294967295
-;   nrk %r2, %r4, %r5
+;   xilf %r2, 4294967295
+;   nrk %r2, %r4, %r2
 ;   or %r2, %r3
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   nr %r3, %r2
-;   lgr %r5, %r2
-;   xilf %r5, 0xffffffff
-;   nrk %r2, %r4, %r5
+;   xilf %r2, 0xffffffff
+;   nrk %r2, %r4, %r2
 ;   or %r2, %r3
 ;   br %r14
 
@@ -986,18 +982,16 @@ block0(v0: i16, v1: i16, v2: i16):
 ; VCode:
 ; block0:
 ;   nr %r3, %r2
-;   lgr %r5, %r2
-;   xilf %r5, 4294967295
-;   nrk %r2, %r4, %r5
+;   xilf %r2, 4294967295
+;   nrk %r2, %r4, %r2
 ;   or %r2, %r3
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   nr %r3, %r2
-;   lgr %r5, %r2
-;   xilf %r5, 0xffffffff
-;   nrk %r2, %r4, %r5
+;   xilf %r2, 0xffffffff
+;   nrk %r2, %r4, %r2
 ;   or %r2, %r3
 ;   br %r14
 
@@ -1010,18 +1004,16 @@ block0(v0: i8, v1: i8, v2: i8):
 ; VCode:
 ; block0:
 ;   nr %r3, %r2
-;   lgr %r5, %r2
-;   xilf %r5, 4294967295
-;   nrk %r2, %r4, %r5
+;   xilf %r2, 4294967295
+;   nrk %r2, %r4, %r2
 ;   or %r2, %r3
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   nr %r3, %r2
-;   lgr %r5, %r2
-;   xilf %r5, 0xffffffff
-;   nrk %r2, %r4, %r5
+;   xilf %r2, 0xffffffff
+;   nrk %r2, %r4, %r2
 ;   or %r2, %r3
 ;   br %r14
 
diff --git a/cranelift/filetests/filetests/isa/s390x/call-tail.clif b/cranelift/filetests/filetests/isa/s390x/call-tail.clif
new file mode 100644
index 000000000000..1ce224b65ce8
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/s390x/call-tail.clif
@@ -0,0 +1,316 @@
+test compile precise-output
+target s390x
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; CALL
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+function %call(i64) -> i64 tail {
+    fn0 = %g(i64) -> i64 tail
+
+block0(v0: i64):
+    v1 = call fn0(v0)
+    return v1
+}
+
+; VCode:
+;   stmg %r14, %r15, 112(%r15)
+;   aghi %r15, -160
+; block0:
+;   bras %r1, 12 ; data %g + 0 ; lg %r5, 0(%r1)
+;   basr %r14, %r5
+;   lmg %r14, %r15, 272(%r15)
+;   br %r14
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r14, %r15, 0x70(%r15)
+;   aghi %r15, -0xa0
+; block1: ; offset 0xa
+;   bras %r1, 0x16
+;   .byte 0x00, 0x00 ; reloc_external Abs8 %g 0
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   lg %r5, 0(%r1)
+;   basr %r14, %r5
+;   lmg %r14, %r15, 0x110(%r15)
+;   br %r14
+
+function %call_colocated(i64) -> i64 tail {
+    fn0 = colocated %g(i64) -> i64 tail
+
+block0(v0: i64):
+    v1 = call fn0(v0)
+    return v1
+}
+
+; VCode:
+;   stmg %r14, %r15, 112(%r15)
+;   aghi %r15, -160
+; block0:
+;   brasl %r14, %g
+;   lmg %r14, %r15, 272(%r15)
+;   br %r14
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r14, %r15, 0x70(%r15)
+;   aghi %r15, -0xa0
+; block1: ; offset 0xa
+;   brasl %r14, 0xa ; reloc_external PLTRel32Dbl %g 2
+;   lmg %r14, %r15, 0x110(%r15)
+;   br %r14
+
+function %call_indirect(i64, i64) -> i64 tail {
+    sig0 = (i64) -> i64 tail
+block0(v0: i64, v1: i64):
+    v2 = call_indirect.i64 sig0, v1(v0)
+    return v2
+}
+
+; VCode:
+;   stmg %r14, %r15, 112(%r15)
+;   aghi %r15, -160
+; block0:
+;   basr %r14, %r3
+;   lmg %r14, %r15, 272(%r15)
+;   br %r14
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r14, %r15, 0x70(%r15)
+;   aghi %r15, -0xa0
+; block1: ; offset 0xa
+;   basr %r14, %r3
+;   lmg %r14, %r15, 0x110(%r15)
+;   br %r14
+
+function %incoming_args(i64, i32, i32 uext, i32 sext, i16, i16 uext, i16 sext, i8, i8 uext, i8 sext) -> i64 tail {
+block0(v0: i64, v1: i32, v2: i32, v3: i32, v4: i16, v5: i16, v6: i16, v7: i8, v8: i8, v9: i8):
+    v10 = uextend.i64 v1
+    v11 = uextend.i64 v2
+    v12 = uextend.i64 v3
+    v13 = uextend.i64 v4
+    v14 = uextend.i64 v5
+    v15 = uextend.i64 v6
+    v16 = uextend.i64 v7
+    v17 = uextend.i64 v8
+    v18 = uextend.i64 v9
+    v19 = iadd v0, v10
+    v20 = iadd v11, v12
+    v21 = iadd v13, v14
+    v22 = iadd v15, v16
+    v23 = iadd v17, v18
+    v24 = iadd v19, v20
+    v25 = iadd v21, v22
+    v26 = iadd v23, v24
+    v27 = iadd v25, v26
+    return v27
+}
+
+; VCode:
+;   stmg %r8, %r15, 256(%r15)
+;   aghi %r15, -8
+; block0:
+;   lgr %r14, %r7
+;   stg %r2, 0(%r15)
+;   lg %r8, 168(%r15)
+;   llgc %r10, 183(%r15)
+;   lg %r7, 184(%r15)
+;   lg %r2, 192(%r15)
+;   llgfr %r11, %r3
+;   llgfr %r9, %r4
+;   llgfr %r12, %r5
+;   llghr %r13, %r6
+;   lgr %r3, %r14
+;   llghr %r6, %r3
+;   llghr %r14, %r8
+;   llgcr %r5, %r10
+;   llgcr %r7, %r7
+;   llgcr %r4, %r2
+;   lg %r2, 0(%r15)
+;   agr %r2, %r11
+;   agrk %r3, %r9, %r12
+;   agrk %r6, %r13, %r6
+;   agrk %r5, %r14, %r5
+;   agrk %r4, %r7, %r4
+;   agrk %r7, %r2, %r3
+;   agrk %r5, %r6, %r5
+;   agr %r4, %r7
+;   agrk %r2, %r5, %r4
+;   aghi %r15, 200
+;   lmg %r8, %r14, 64(%r15)
+;   br %r14
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r8, %r15, 0x100(%r15)
+;   aghi %r15, -8
+; block1: ; offset 0xa
+;   lgr %r14, %r7
+;   stg %r2, 0(%r15)
+;   lg %r8, 0xa8(%r15)
+;   llgc %r10, 0xb7(%r15)
+;   lg %r7, 0xb8(%r15)
+;   lg %r2, 0xc0(%r15)
+;   llgfr %r11, %r3
+;   llgfr %r9, %r4
+;   llgfr %r12, %r5
+;   llghr %r13, %r6
+;   lgr %r3, %r14
+;   llghr %r6, %r3
+;   llghr %r14, %r8
+;   llgcr %r5, %r10
+;   llgcr %r7, %r7
+;   llgcr %r4, %r2
+;   lg %r2, 0(%r15)
+;   agr %r2, %r11
+;   agrk %r3, %r9, %r12
+;   agrk %r6, %r13, %r6
+;   agrk %r5, %r14, %r5
+;   agrk %r4, %r7, %r4
+;   agrk %r7, %r2, %r3
+;   agrk %r5, %r6, %r5
+;   agr %r4, %r7
+;   agrk %r2, %r5, %r4
+;   aghi %r15, 0xc8
+;   lmg %r8, %r14, 0x40(%r15)
+;   br %r14
+
+function %outgoing_args(i64) -> i64 tail {
+    fn0 = colocated %g(i64, i64, i64, i64, i64, i64, i64, i64) -> i64 tail
+
+block0(v0: i64):
+    v1 = call fn0(v0, v0, v0, v0, v0, v0, v0, v0)
+    return v1
+}
+
+; VCode:
+;   stmg %r14, %r15, 112(%r15)
+;   aghi %r15, -160
+; block0:
+;   aghi %r15, -176
+;   stg %r2, 160(%r15)
+;   stg %r2, 168(%r15)
+;   lgr %r7, %r2
+;   lgr %r3, %r7
+;   lgr %r4, %r7
+;   lgr %r5, %r7
+;   lgr %r6, %r7
+;   brasl %r14, %g ; callee_pop_size 176
+;   lmg %r14, %r15, 272(%r15)
+;   br %r14
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r14, %r15, 0x70(%r15)
+;   aghi %r15, -0xa0
+; block1: ; offset 0xa
+;   aghi %r15, -0xb0
+;   stg %r2, 0xa0(%r15)
+;   stg %r2, 0xa8(%r15)
+;   lgr %r7, %r2
+;   lgr %r3, %r7
+;   lgr %r4, %r7
+;   lgr %r5, %r7
+;   lgr %r6, %r7
+;   brasl %r14, 0x2e ; reloc_external PLTRel32Dbl %g 2
+;   lmg %r14, %r15, 0x110(%r15)
+;   br %r14
+
+function %outgoing_args_stack_load(i64) -> i64 tail {
+    fn0 = colocated %f() -> i64 tail
+    fn1 = colocated %g(i64, i64, i64, i64, i64, i64, i64, i64) -> i64 tail
+    ss0 = explicit_slot 8
+
+block0(v0: i64):
+    v1 = call fn0()
+    v2 = call fn0()
+    v3 = call fn0()
+    v4 = call fn0()
+    v5 = call fn0()
+    v6 = call fn0()
+    v7 = call fn0()
+    v8 = call fn0()
+
+    v17 = call fn1(v0, v1, v2, v3, v4, v5, v6, v7)
+
+    return v8
+}
+
+; VCode:
+;   stmg %r8, %r15, 64(%r15)
+;   aghi %r15, -192
+; block0:
+;   lgr %r10, %r2
+;   brasl %r14, %f
+;   lgr %r13, %r2
+;   brasl %r14, %f
+;   lgr %r9, %r2
+;   brasl %r14, %f
+;   lgr %r12, %r2
+;   brasl %r14, %f
+;   lgr %r8, %r2
+;   brasl %r14, %f
+;   lgr %r11, %r2
+;   brasl %r14, %f
+;   stg %r2, 184(%r15)
+;   brasl %r14, %f
+;   stg %r2, 176(%r15)
+;   brasl %r14, %f
+;   stg %r2, 168(%r15)
+;   aghi %r15, -176
+;   lg %r2, 360(%r15)
+;   stg %r2, 160(%r15)
+;   lg %r2, 352(%r15)
+;   stg %r2, 168(%r15)
+;   lgr %r2, %r10
+;   lgr %r3, %r13
+;   lgr %r4, %r9
+;   lgr %r5, %r12
+;   lgr %r6, %r8
+;   lgr %r7, %r11
+;   brasl %r14, %g ; callee_pop_size 176
+;   lg %r2, 168(%r15)
+;   lmg %r8, %r15, 256(%r15)
+;   br %r14
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r8, %r15, 0x40(%r15)
+;   aghi %r15, -0xc0
+; block1: ; offset 0xa
+;   lgr %r10, %r2
+;   brasl %r14, 0xe ; reloc_external PLTRel32Dbl %f 2
+;   lgr %r13, %r2
+;   brasl %r14, 0x18 ; reloc_external PLTRel32Dbl %f 2
+;   lgr %r9, %r2
+;   brasl %r14, 0x22 ; reloc_external PLTRel32Dbl %f 2
+;   lgr %r12, %r2
+;   brasl %r14, 0x2c ; reloc_external PLTRel32Dbl %f 2
+;   lgr %r8, %r2
+;   brasl %r14, 0x36 ; reloc_external PLTRel32Dbl %f 2
+;   lgr %r11, %r2
+;   brasl %r14, 0x40 ; reloc_external PLTRel32Dbl %f 2
+;   stg %r2, 0xb8(%r15)
+;   brasl %r14, 0x4c ; reloc_external PLTRel32Dbl %f 2
+;   stg %r2, 0xb0(%r15)
+;   brasl %r14, 0x58 ; reloc_external PLTRel32Dbl %f 2
+;   stg %r2, 0xa8(%r15)
+;   aghi %r15, -0xb0
+;   lg %r2, 0x168(%r15)
+;   stg %r2, 0xa0(%r15)
+;   lg %r2, 0x160(%r15)
+;   stg %r2, 0xa8(%r15)
+;   lgr %r2, %r10
+;   lgr %r3, %r13
+;   lgr %r4, %r9
+;   lgr %r5, %r12
+;   lgr %r6, %r8
+;   lgr %r7, %r11
+;   brasl %r14, 0x98 ; reloc_external PLTRel32Dbl %g 2
+;   lg %r2, 0xa8(%r15)
+;   lmg %r8, %r15, 0x100(%r15)
+;   br %r14
+
diff --git a/cranelift/filetests/filetests/isa/s390x/call.clif b/cranelift/filetests/filetests/isa/s390x/call.clif
index 1d72253b1289..db78a3f28cfe 100644
--- a/cranelift/filetests/filetests/isa/s390x/call.clif
+++ b/cranelift/filetests/filetests/isa/s390x/call.clif
@@ -16,7 +16,6 @@ block0(v0: i64):
 ; VCode:
 ;   stmg %r14, %r15, 112(%r15)
 ;   aghi %r15, -160
-;   virtual_sp_offset_adjust 160
 ; block0:
 ;   bras %r1, 12 ; data %g + 0 ; lg %r5, 0(%r1)
 ;   basr %r14, %r5
@@ -49,7 +48,6 @@ block0(v0: i32):
 ; VCode:
 ;   stmg %r14, %r15, 112(%r15)
 ;   aghi %r15, -160
-;   virtual_sp_offset_adjust 160
 ; block0:
 ;   llgfr %r2, %r2
 ;   bras %r1, 12 ; data %g + 0 ; lg %r3, 0(%r1)
@@ -99,7 +97,6 @@ block0(v0: i32):
 ; VCode:
 ;   stmg %r14, %r15, 112(%r15)
 ;   aghi %r15, -160
-;   virtual_sp_offset_adjust 160
 ; block0:
 ;   lgfr %r2, %r2
 ;   bras %r1, 12 ; data %g + 0 ; lg %r3, 0(%r1)
@@ -149,7 +146,6 @@ block0(v0: i64):
 ; VCode:
 ;   stmg %r14, %r15, 112(%r15)
 ;   aghi %r15, -160
-;   virtual_sp_offset_adjust 160
 ; block0:
 ;   brasl %r14, %g
 ;   lmg %r14, %r15, 272(%r15)
@@ -175,7 +171,6 @@ block0(v0: i32):
 ; VCode:
 ;   stmg %r14, %r15, 112(%r15)
 ;   aghi %r15, -160
-;   virtual_sp_offset_adjust 160
 ; block0:
 ;   llgfr %r2, %r2
 ;   bras %r1, 12 ; data %g + 0 ; lg %r3, 0(%r1)
@@ -209,7 +204,6 @@ block0(v0: i64, v1: i64):
 ; VCode:
 ;   stmg %r14, %r15, 112(%r15)
 ;   aghi %r15, -160
-;   virtual_sp_offset_adjust 160
 ; block0:
 ;   basr %r14, %r3
 ;   lmg %r14, %r15, 272(%r15)
@@ -332,14 +326,14 @@ block0(v0: i128, v1: i128, v2: i128, v3: i128, v4: i128, v5: i128, v6: i128, v7:
 ;   vl %v24, 0(%r5)
 ;   lg %r4, 184(%r15)
 ;   vl %v27, 0(%r4)
-;   vaq %v16, %v1, %v3
-;   vaq %v17, %v5, %v7
-;   vaq %v18, %v18, %v21
-;   vaq %v19, %v24, %v27
-;   vaq %v16, %v16, %v17
-;   vaq %v17, %v18, %v19
-;   vaq %v16, %v16, %v17
-;   vst %v16, 0(%r2)
+;   vaq %v4, %v1, %v3
+;   vaq %v5, %v5, %v7
+;   vaq %v6, %v18, %v21
+;   vaq %v7, %v24, %v27
+;   vaq %v4, %v4, %v5
+;   vaq %v5, %v6, %v7
+;   vaq %v4, %v4, %v5
+;   vst %v4, 0(%r2)
 ;   br %r14
 ;
 ; Disassembled:
@@ -356,14 +350,14 @@ block0(v0: i128, v1: i128, v2: i128, v3: i128, v4: i128, v5: i128, v6: i128, v7:
 ;   vl %v24, 0(%r5)
 ;   lg %r4, 0xb8(%r15)
 ;   vl %v27, 0(%r4)
-;   vaq %v16, %v1, %v3
-;   vaq %v17, %v5, %v7
-;   vaq %v18, %v18, %v21
-;   vaq %v19, %v24, %v27
-;   vaq %v16, %v16, %v17
-;   vaq %v17, %v18, %v19
-;   vaq %v16, %v16, %v17
-;   vst %v16, 0(%r2)
+;   vaq %v4, %v1, %v3
+;   vaq %v5, %v5, %v7
+;   vaq %v6, %v18, %v21
+;   vaq %v7, %v24, %v27
+;   vaq %v4, %v4, %v5
+;   vaq %v5, %v6, %v7
+;   vaq %v4, %v4, %v5
+;   vst %v4, 0(%r2)
 ;   br %r14
 
 function %call_sret() -> i64 {
@@ -378,7 +372,6 @@ block0:
 ; VCode:
 ;   stmg %r14, %r15, 112(%r15)
 ;   aghi %r15, -160
-;   virtual_sp_offset_adjust 160
 ; block0:
 ;   lghi %r2, 0
 ;   brasl %r14, %g
diff --git a/cranelift/filetests/filetests/isa/s390x/conversions.clif b/cranelift/filetests/filetests/isa/s390x/conversions.clif
index 1f791abdb7a7..b94111582e7b 100644
--- a/cranelift/filetests/filetests/isa/s390x/conversions.clif
+++ b/cranelift/filetests/filetests/isa/s390x/conversions.clif
@@ -660,19 +660,19 @@ block0(v0: i64, v1: i64):
 ; VCode:
 ; block0:
 ;   cghi %r4, 0
-;   lghi %r4, 0
-;   locghilh %r4, -1
-;   vlvgp %v17, %r4, %r4
-;   vst %v17, 0(%r2)
+;   lghi %r3, 0
+;   locghilh %r3, -1
+;   vlvgp %v16, %r3, %r3
+;   vst %v16, 0(%r2)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   cghi %r4, 0
-;   lghi %r4, 0
-;   locghilh %r4, -1
-;   vlvgp %v17, %r4, %r4
-;   vst %v17, 0(%r2)
+;   lghi %r3, 0
+;   locghilh %r3, -1
+;   vlvgp %v16, %r3, %r3
+;   vst %v16, 0(%r2)
 ;   br %r14
 
 function %bmask_i64_i64(i64, i64) -> i64 {
@@ -764,19 +764,19 @@ block0(v0: i32, v1: i32):
 ; VCode:
 ; block0:
 ;   chi %r4, 0
-;   lghi %r4, 0
-;   locghilh %r4, -1
-;   vlvgp %v17, %r4, %r4
-;   vst %v17, 0(%r2)
+;   lghi %r3, 0
+;   locghilh %r3, -1
+;   vlvgp %v16, %r3, %r3
+;   vst %v16, 0(%r2)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   chi %r4, 0
-;   lghi %r4, 0
-;   locghilh %r4, -1
-;   vlvgp %v17, %r4, %r4
-;   vst %v17, 0(%r2)
+;   lghi %r3, 0
+;   locghilh %r3, -1
+;   vlvgp %v16, %r3, %r3
+;   vst %v16, 0(%r2)
 ;   br %r14
 
 function %bmask_i32_i64(i32, i32) -> i64 {
@@ -867,22 +867,22 @@ block0(v0: i16, v1: i16):
 
 ; VCode:
 ; block0:
-;   lhr %r3, %r4
-;   chi %r3, 0
-;   lghi %r3, 0
-;   locghilh %r3, -1
-;   vlvgp %v19, %r3, %r3
-;   vst %v19, 0(%r2)
+;   lhr %r5, %r4
+;   chi %r5, 0
+;   lghi %r5, 0
+;   locghilh %r5, -1
+;   vlvgp %v18, %r5, %r5
+;   vst %v18, 0(%r2)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lhr %r3, %r4
-;   chi %r3, 0
-;   lghi %r3, 0
-;   locghilh %r3, -1
-;   vlvgp %v19, %r3, %r3
-;   vst %v19, 0(%r2)
+;   lhr %r5, %r4
+;   chi %r5, 0
+;   lghi %r5, 0
+;   locghilh %r5, -1
+;   vlvgp %v18, %r5, %r5
+;   vst %v18, 0(%r2)
 ;   br %r14
 
 function %bmask_i16_i64(i16, i16) -> i64 {
@@ -893,16 +893,16 @@ block0(v0: i16, v1: i16):
 
 ; VCode:
 ; block0:
-;   lhr %r5, %r3
-;   chi %r5, 0
+;   lhr %r4, %r3
+;   chi %r4, 0
 ;   lghi %r2, 0
 ;   locghilh %r2, -1
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lhr %r5, %r3
-;   chi %r5, 0
+;   lhr %r4, %r3
+;   chi %r4, 0
 ;   lghi %r2, 0
 ;   locghilh %r2, -1
 ;   br %r14
@@ -915,16 +915,16 @@ block0(v0: i16, v1: i16):
 
 ; VCode:
 ; block0:
-;   lhr %r5, %r3
-;   chi %r5, 0
+;   lhr %r4, %r3
+;   chi %r4, 0
 ;   lhi %r2, 0
 ;   lochilh %r2, -1
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lhr %r5, %r3
-;   chi %r5, 0
+;   lhr %r4, %r3
+;   chi %r4, 0
 ;   lhi %r2, 0
 ;   lochilh %r2, -1
 ;   br %r14
@@ -937,16 +937,16 @@ block0(v0: i16, v1: i16):
 
 ; VCode:
 ; block0:
-;   lhr %r5, %r3
-;   chi %r5, 0
+;   lhr %r4, %r3
+;   chi %r4, 0
 ;   lhi %r2, 0
 ;   lochilh %r2, -1
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lhr %r5, %r3
-;   chi %r5, 0
+;   lhr %r4, %r3
+;   chi %r4, 0
 ;   lhi %r2, 0
 ;   lochilh %r2, -1
 ;   br %r14
@@ -959,16 +959,16 @@ block0(v0: i16, v1: i16):
 
 ; VCode:
 ; block0:
-;   lhr %r5, %r3
-;   chi %r5, 0
+;   lhr %r4, %r3
+;   chi %r4, 0
 ;   lhi %r2, 0
 ;   lochilh %r2, -1
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lhr %r5, %r3
-;   chi %r5, 0
+;   lhr %r4, %r3
+;   chi %r4, 0
 ;   lhi %r2, 0
 ;   lochilh %r2, -1
 ;   br %r14
@@ -981,22 +981,22 @@ block0(v0: i8, v1: i8):
 
 ; VCode:
 ; block0:
-;   lbr %r3, %r4
-;   chi %r3, 0
-;   lghi %r3, 0
-;   locghilh %r3, -1
-;   vlvgp %v19, %r3, %r3
-;   vst %v19, 0(%r2)
+;   lbr %r5, %r4
+;   chi %r5, 0
+;   lghi %r5, 0
+;   locghilh %r5, -1
+;   vlvgp %v18, %r5, %r5
+;   vst %v18, 0(%r2)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lbr %r3, %r4
-;   chi %r3, 0
-;   lghi %r3, 0
-;   locghilh %r3, -1
-;   vlvgp %v19, %r3, %r3
-;   vst %v19, 0(%r2)
+;   lbr %r5, %r4
+;   chi %r5, 0
+;   lghi %r5, 0
+;   locghilh %r5, -1
+;   vlvgp %v18, %r5, %r5
+;   vst %v18, 0(%r2)
 ;   br %r14
 
 function %bmask_i8_i64(i8, i8) -> i64 {
@@ -1007,16 +1007,16 @@ block0(v0: i8, v1: i8):
 
 ; VCode:
 ; block0:
-;   lbr %r5, %r3
-;   chi %r5, 0
+;   lbr %r4, %r3
+;   chi %r4, 0
 ;   lghi %r2, 0
 ;   locghilh %r2, -1
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lbr %r5, %r3
-;   chi %r5, 0
+;   lbr %r4, %r3
+;   chi %r4, 0
 ;   lghi %r2, 0
 ;   locghilh %r2, -1
 ;   br %r14
@@ -1029,16 +1029,16 @@ block0(v0: i8, v1: i8):
 
 ; VCode:
 ; block0:
-;   lbr %r5, %r3
-;   chi %r5, 0
+;   lbr %r4, %r3
+;   chi %r4, 0
 ;   lhi %r2, 0
 ;   lochilh %r2, -1
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lbr %r5, %r3
-;   chi %r5, 0
+;   lbr %r4, %r3
+;   chi %r4, 0
 ;   lhi %r2, 0
 ;   lochilh %r2, -1
 ;   br %r14
@@ -1051,16 +1051,16 @@ block0(v0: i8, v1: i8):
 
 ; VCode:
 ; block0:
-;   lbr %r5, %r3
-;   chi %r5, 0
+;   lbr %r4, %r3
+;   chi %r4, 0
 ;   lhi %r2, 0
 ;   lochilh %r2, -1
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lbr %r5, %r3
-;   chi %r5, 0
+;   lbr %r4, %r3
+;   chi %r4, 0
 ;   lhi %r2, 0
 ;   lochilh %r2, -1
 ;   br %r14
@@ -1073,16 +1073,16 @@ block0(v0: i8, v1: i8):
 
 ; VCode:
 ; block0:
-;   lbr %r5, %r3
-;   chi %r5, 0
+;   lbr %r4, %r3
+;   chi %r4, 0
 ;   lhi %r2, 0
 ;   lochilh %r2, -1
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lbr %r5, %r3
-;   chi %r5, 0
+;   lbr %r4, %r3
+;   chi %r4, 0
 ;   lhi %r2, 0
 ;   lochilh %r2, -1
 ;   br %r14
@@ -1095,22 +1095,22 @@ block0(v0: i8, v1: i8):
 
 ; VCode:
 ; block0:
-;   lbr %r3, %r4
-;   chi %r3, 0
-;   lghi %r3, 0
-;   locghilh %r3, -1
-;   vlvgp %v19, %r3, %r3
-;   vst %v19, 0(%r2)
+;   lbr %r5, %r4
+;   chi %r5, 0
+;   lghi %r5, 0
+;   locghilh %r5, -1
+;   vlvgp %v18, %r5, %r5
+;   vst %v18, 0(%r2)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lbr %r3, %r4
-;   chi %r3, 0
-;   lghi %r3, 0
-;   locghilh %r3, -1
-;   vlvgp %v19, %r3, %r3
-;   vst %v19, 0(%r2)
+;   lbr %r5, %r4
+;   chi %r5, 0
+;   lghi %r5, 0
+;   locghilh %r5, -1
+;   vlvgp %v18, %r5, %r5
+;   vst %v18, 0(%r2)
 ;   br %r14
 
 function %bmask_i8_i64(i8, i8) -> i64 {
@@ -1121,16 +1121,16 @@ block0(v0: i8, v1: i8):
 
 ; VCode:
 ; block0:
-;   lbr %r5, %r3
-;   chi %r5, 0
+;   lbr %r4, %r3
+;   chi %r4, 0
 ;   lghi %r2, 0
 ;   locghilh %r2, -1
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lbr %r5, %r3
-;   chi %r5, 0
+;   lbr %r4, %r3
+;   chi %r4, 0
 ;   lghi %r2, 0
 ;   locghilh %r2, -1
 ;   br %r14
@@ -1143,16 +1143,16 @@ block0(v0: i8, v1: i8):
 
 ; VCode:
 ; block0:
-;   lbr %r5, %r3
-;   chi %r5, 0
+;   lbr %r4, %r3
+;   chi %r4, 0
 ;   lhi %r2, 0
 ;   lochilh %r2, -1
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lbr %r5, %r3
-;   chi %r5, 0
+;   lbr %r4, %r3
+;   chi %r4, 0
 ;   lhi %r2, 0
 ;   lochilh %r2, -1
 ;   br %r14
@@ -1165,16 +1165,16 @@ block0(v0: i8, v1: i8):
 
 ; VCode:
 ; block0:
-;   lbr %r5, %r3
-;   chi %r5, 0
+;   lbr %r4, %r3
+;   chi %r4, 0
 ;   lhi %r2, 0
 ;   lochilh %r2, -1
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lbr %r5, %r3
-;   chi %r5, 0
+;   lbr %r4, %r3
+;   chi %r4, 0
 ;   lhi %r2, 0
 ;   lochilh %r2, -1
 ;   br %r14
@@ -1187,16 +1187,16 @@ block0(v0: i8, v1: i8):
 
 ; VCode:
 ; block0:
-;   lbr %r5, %r3
-;   chi %r5, 0
+;   lbr %r4, %r3
+;   chi %r4, 0
 ;   lhi %r2, 0
 ;   lochilh %r2, -1
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lbr %r5, %r3
-;   chi %r5, 0
+;   lbr %r4, %r3
+;   chi %r4, 0
 ;   lhi %r2, 0
 ;   lochilh %r2, -1
 ;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/fp_sp_pc.clif b/cranelift/filetests/filetests/isa/s390x/fp_sp_pc.clif
index 5d7cb3703b4b..423e065370af 100644
--- a/cranelift/filetests/filetests/isa/s390x/fp_sp_pc.clif
+++ b/cranelift/filetests/filetests/isa/s390x/fp_sp_pc.clif
@@ -12,7 +12,6 @@ block0:
 ;   stmg %r14, %r15, 112(%r15)
 ;   lgr %r1, %r15
 ;   aghi %r15, -160
-;   virtual_sp_offset_adjust 160
 ;   stg %r1, 0(%r15)
 ; block0:
 ;   lg %r2, 0(%r15)
@@ -40,7 +39,6 @@ block0:
 ;   stmg %r14, %r15, 112(%r15)
 ;   lgr %r1, %r15
 ;   aghi %r15, -160
-;   virtual_sp_offset_adjust 160
 ;   stg %r1, 0(%r15)
 ; block0:
 ;   lgr %r2, %r15
@@ -68,7 +66,6 @@ block0:
 ;   stmg %r14, %r15, 112(%r15)
 ;   lgr %r1, %r15
 ;   aghi %r15, -160
-;   virtual_sp_offset_adjust 160
 ;   stg %r1, 0(%r15)
 ; block0:
 ;   lg %r2, 272(%r15)
diff --git a/cranelift/filetests/filetests/isa/s390x/fpmem-arch13.clif b/cranelift/filetests/filetests/isa/s390x/fpmem-arch13.clif
index 446af5e7c874..1fa49f8516ab 100644
--- a/cranelift/filetests/filetests/isa/s390x/fpmem-arch13.clif
+++ b/cranelift/filetests/filetests/isa/s390x/fpmem-arch13.clif
@@ -14,7 +14,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x00
+;   .byte 0xe6, 0x00 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x00, 0x02
 ;   br %r14
@@ -32,7 +32,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x00
+;   .byte 0xe6, 0x00 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x00, 0x03
 ;   br %r14
@@ -50,7 +50,7 @@ block0(v0: f64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x00
+;   .byte 0xe6, 0x00 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x00, 0x0a
 ;   br %r14
@@ -68,7 +68,7 @@ block0(v0: f32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x00
+;   .byte 0xe6, 0x00 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x00, 0x0b
 ;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/fpmem.clif b/cranelift/filetests/filetests/isa/s390x/fpmem.clif
index d91ffc351205..63361d4a084c 100644
--- a/cranelift/filetests/filetests/isa/s390x/fpmem.clif
+++ b/cranelift/filetests/filetests/isa/s390x/fpmem.clif
@@ -14,7 +14,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld %f0, 0(%r2)
+;   ld %f0, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %load_f32(i64) -> f32 {
@@ -30,7 +30,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   le %f0, 0(%r2)
+;   le %f0, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %load_f64_little(i64) -> f64 {
@@ -47,7 +47,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0(%r2)
+;   lrvg %r4, 0(%r2) ; trap: heap_oob
 ;   ldgr %f0, %r4
 ;   br %r14
 
@@ -65,7 +65,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrv %r4, 0(%r2)
+;   lrv %r4, 0(%r2) ; trap: heap_oob
 ;   vlvgf %v0, %r4, 0
 ;   br %r14
 
@@ -82,7 +82,7 @@ block0(v0: f64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   std %f0, 0(%r2)
+;   std %f0, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_f32(f32, i64) {
@@ -98,7 +98,7 @@ block0(v0: f32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ste %f0, 0(%r2)
+;   ste %f0, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_f64_little(f64, i64) {
@@ -116,7 +116,7 @@ block0(v0: f64, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   lgdr %r5, %f0
-;   strvg %r5, 0(%r2)
+;   strvg %r5, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_f32_little(f32, i64) {
@@ -134,6 +134,6 @@ block0(v0: f32, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vlgvf %r5, %v0, 0
-;   strv %r5, 0(%r2)
+;   strv %r5, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
diff --git a/cranelift/filetests/filetests/isa/s390x/icmp.clif b/cranelift/filetests/filetests/isa/s390x/icmp.clif
index cce8b757fbe0..6b8707eb4039 100644
--- a/cranelift/filetests/filetests/isa/s390x/icmp.clif
+++ b/cranelift/filetests/filetests/isa/s390x/icmp.clif
@@ -100,7 +100,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   cg %r2, 0(%r3)
+;   cg %r2, 0(%r3) ; trap: heap_oob
 ;   lhi %r2, 0
 ;   lochil %r2, 1
 ;   br %r14
@@ -123,7 +123,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   cgrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   cgrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   lhi %r2, 0
 ;   lochil %r2, 1
 ;   br %r14
@@ -144,7 +144,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   cgh %r2, 0(%r3)
+;   cgh %r2, 0(%r3) ; trap: heap_oob
 ;   lhi %r2, 0
 ;   lochil %r2, 1
 ;   br %r14
@@ -167,7 +167,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   cghrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   cghrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   lhi %r2, 0
 ;   lochil %r2, 1
 ;   br %r14
@@ -188,7 +188,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   cgf %r2, 0(%r3)
+;   cgf %r2, 0(%r3) ; trap: heap_oob
 ;   lhi %r2, 0
 ;   lochil %r2, 1
 ;   br %r14
@@ -211,7 +211,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   cgfrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   cgfrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   lhi %r2, 0
 ;   lochil %r2, 1
 ;   br %r14
@@ -294,7 +294,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   c %r2, 0(%r3)
+;   c %r2, 0(%r3) ; trap: heap_oob
 ;   lhi %r2, 0
 ;   lochil %r2, 1
 ;   br %r14
@@ -315,7 +315,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   cy %r2, 0x1000(%r3)
+;   cy %r2, 0x1000(%r3) ; trap: heap_oob
 ;   lhi %r2, 0
 ;   lochil %r2, 1
 ;   br %r14
@@ -338,7 +338,7 @@ block0(v0: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   crl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   crl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   lhi %r2, 0
 ;   lochil %r2, 1
 ;   br %r14
@@ -359,7 +359,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ch %r2, 0(%r3)
+;   ch %r2, 0(%r3) ; trap: heap_oob
 ;   lhi %r2, 0
 ;   lochil %r2, 1
 ;   br %r14
@@ -380,7 +380,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   chy %r2, 0x1000(%r3)
+;   chy %r2, 0x1000(%r3) ; trap: heap_oob
 ;   lhi %r2, 0
 ;   lochil %r2, 1
 ;   br %r14
@@ -403,7 +403,7 @@ block0(v0: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   chrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   chrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   lhi %r2, 0
 ;   lochil %r2, 1
 ;   br %r14
@@ -473,7 +473,7 @@ block0(v0: i16, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   lhr %r5, %r2
-;   ch %r5, 0(%r3)
+;   ch %r5, 0(%r3) ; trap: heap_oob
 ;   lhi %r2, 0
 ;   lochil %r2, 1
 ;   br %r14
@@ -498,7 +498,7 @@ block0(v0: i16):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   lhr %r4, %r2
-;   chrl %r4, 4 ; reloc_external PCRel32Dbl %sym 2
+;   chrl %r4, 4 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   lhi %r2, 0
 ;   lochil %r2, 1
 ;   br %r14
@@ -569,7 +569,7 @@ block0(v0: i8, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   lbr %r5, %r2
-;   lb %r3, 0(%r3)
+;   lb %r3, 0(%r3) ; trap: heap_oob
 ;   cr %r5, %r3
 ;   lhi %r2, 0
 ;   lochil %r2, 1
@@ -653,7 +653,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   clg %r2, 0(%r3)
+;   clg %r2, 0(%r3) ; trap: heap_oob
 ;   lhi %r2, 0
 ;   lochil %r2, 1
 ;   br %r14
@@ -676,7 +676,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   clgrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   clgrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   lhi %r2, 0
 ;   lochil %r2, 1
 ;   br %r14
@@ -697,7 +697,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   clgf %r2, 0(%r3)
+;   clgf %r2, 0(%r3) ; trap: heap_oob
 ;   lhi %r2, 0
 ;   lochil %r2, 1
 ;   br %r14
@@ -720,7 +720,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   clgfrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   clgfrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   lhi %r2, 0
 ;   lochil %r2, 1
 ;   br %r14
@@ -742,7 +742,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llgh %r3, 0(%r3)
+;   llgh %r3, 0(%r3) ; trap: heap_oob
 ;   clgr %r2, %r3
 ;   lhi %r2, 0
 ;   lochil %r2, 1
@@ -766,7 +766,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   clghrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   clghrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   lhi %r2, 0
 ;   lochil %r2, 1
 ;   br %r14
@@ -828,7 +828,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   cl %r2, 0(%r3)
+;   cl %r2, 0(%r3) ; trap: heap_oob
 ;   lhi %r2, 0
 ;   lochil %r2, 1
 ;   br %r14
@@ -849,7 +849,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   cly %r2, 0x1000(%r3)
+;   cly %r2, 0x1000(%r3) ; trap: heap_oob
 ;   lhi %r2, 0
 ;   lochil %r2, 1
 ;   br %r14
@@ -872,7 +872,7 @@ block0(v0: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   clrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   clrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   lhi %r2, 0
 ;   lochil %r2, 1
 ;   br %r14
@@ -894,7 +894,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llh %r3, 0(%r3)
+;   llh %r3, 0(%r3) ; trap: heap_oob
 ;   clr %r2, %r3
 ;   lhi %r2, 0
 ;   lochil %r2, 1
@@ -918,7 +918,7 @@ block0(v0: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   clhrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   clhrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   lhi %r2, 0
 ;   lochil %r2, 1
 ;   br %r14
@@ -989,7 +989,7 @@ block0(v0: i16, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   llhr %r5, %r2
-;   llh %r3, 0(%r3)
+;   llh %r3, 0(%r3) ; trap: heap_oob
 ;   clr %r5, %r3
 ;   lhi %r2, 0
 ;   lochil %r2, 1
@@ -1015,7 +1015,7 @@ block0(v0: i16):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   llhr %r4, %r2
-;   clhrl %r4, 4 ; reloc_external PCRel32Dbl %sym 2
+;   clhrl %r4, 4 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   lhi %r2, 0
 ;   lochil %r2, 1
 ;   br %r14
@@ -1086,7 +1086,7 @@ block0(v0: i8, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   llcr %r5, %r2
-;   llc %r3, 0(%r3)
+;   llc %r3, 0(%r3) ; trap: heap_oob
 ;   clr %r5, %r3
 ;   lhi %r2, 0
 ;   lochil %r2, 1
diff --git a/cranelift/filetests/filetests/isa/s390x/leaf_with_preserve_frame_pointers.clif b/cranelift/filetests/filetests/isa/s390x/leaf_with_preserve_frame_pointers.clif
index 5cff1c3d3dec..a7de7ab9b7de 100644
--- a/cranelift/filetests/filetests/isa/s390x/leaf_with_preserve_frame_pointers.clif
+++ b/cranelift/filetests/filetests/isa/s390x/leaf_with_preserve_frame_pointers.clif
@@ -14,7 +14,6 @@ block0(v0: i64):
 ;   stmg %r14, %r15, 112(%r15)
 ;   lgr %r1, %r15
 ;   aghi %r15, -160
-;   virtual_sp_offset_adjust 160
 ;   stg %r1, 0(%r15)
 ; block0:
 ;   lmg %r14, %r15, 272(%r15)
diff --git a/cranelift/filetests/filetests/isa/s390x/load-little.clif b/cranelift/filetests/filetests/isa/s390x/load-little.clif
index 34e3cbc62172..abbd3baeae5d 100644
--- a/cranelift/filetests/filetests/isa/s390x/load-little.clif
+++ b/cranelift/filetests/filetests/isa/s390x/load-little.clif
@@ -14,7 +14,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r2, 0(%r2)
+;   lrvg %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %load_i64_sym() -> i64 {
@@ -33,7 +33,7 @@ block0:
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   larl %r1, 0 ; reloc_external PCRel32Dbl %sym 2
-;   lrvg %r2, 0(%r1)
+;   lrvg %r2, 0(%r1) ; trap: heap_oob
 ;   br %r14
 
 function %uload8_i64(i64) -> i64 {
@@ -49,7 +49,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llgc %r2, 0(%r2)
+;   llgc %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %sload8_i64(i64) -> i64 {
@@ -65,7 +65,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgb %r2, 0(%r2)
+;   lgb %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %uload16_i64(i64) -> i64 {
@@ -82,7 +82,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvh %r4, 0(%r2)
+;   lrvh %r4, 0(%r2) ; trap: heap_oob
 ;   llghr %r2, %r4
 ;   br %r14
 
@@ -103,7 +103,7 @@ block0:
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   larl %r1, 0 ; reloc_external PCRel32Dbl %sym 2
-;   lrvh %r2, 0(%r1)
+;   lrvh %r2, 0(%r1) ; trap: heap_oob
 ;   llghr %r2, %r2
 ;   br %r14
 
@@ -121,7 +121,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvh %r4, 0(%r2)
+;   lrvh %r4, 0(%r2) ; trap: heap_oob
 ;   lghr %r2, %r4
 ;   br %r14
 
@@ -142,7 +142,7 @@ block0:
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   larl %r1, 0 ; reloc_external PCRel32Dbl %sym 2
-;   lrvh %r2, 0(%r1)
+;   lrvh %r2, 0(%r1) ; trap: heap_oob
 ;   lghr %r2, %r2
 ;   br %r14
 
@@ -160,7 +160,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrv %r4, 0(%r2)
+;   lrv %r4, 0(%r2) ; trap: heap_oob
 ;   llgfr %r2, %r4
 ;   br %r14
 
@@ -181,7 +181,7 @@ block0:
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   larl %r1, 0 ; reloc_external PCRel32Dbl %sym 2
-;   lrv %r2, 0(%r1)
+;   lrv %r2, 0(%r1) ; trap: heap_oob
 ;   llgfr %r2, %r2
 ;   br %r14
 
@@ -199,7 +199,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrv %r4, 0(%r2)
+;   lrv %r4, 0(%r2) ; trap: heap_oob
 ;   lgfr %r2, %r4
 ;   br %r14
 
@@ -220,7 +220,7 @@ block0:
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   larl %r1, 0 ; reloc_external PCRel32Dbl %sym 2
-;   lrv %r2, 0(%r1)
+;   lrv %r2, 0(%r1) ; trap: heap_oob
 ;   lgfr %r2, %r2
 ;   br %r14
 
@@ -237,7 +237,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrv %r2, 0(%r2)
+;   lrv %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %load_i32_sym() -> i32 {
@@ -256,7 +256,7 @@ block0:
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   larl %r1, 0 ; reloc_external PCRel32Dbl %sym 2
-;   lrv %r2, 0(%r1)
+;   lrv %r2, 0(%r1) ; trap: heap_oob
 ;   br %r14
 
 function %uload8_i32(i64) -> i32 {
@@ -272,7 +272,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llc %r2, 0(%r2)
+;   llc %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %sload8_i32(i64) -> i32 {
@@ -288,7 +288,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lb %r2, 0(%r2)
+;   lb %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %uload16_i32(i64) -> i32 {
@@ -305,7 +305,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvh %r4, 0(%r2)
+;   lrvh %r4, 0(%r2) ; trap: heap_oob
 ;   llhr %r2, %r4
 ;   br %r14
 
@@ -326,7 +326,7 @@ block0:
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   larl %r1, 0 ; reloc_external PCRel32Dbl %sym 2
-;   lrvh %r2, 0(%r1)
+;   lrvh %r2, 0(%r1) ; trap: heap_oob
 ;   llhr %r2, %r2
 ;   br %r14
 
@@ -344,7 +344,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvh %r4, 0(%r2)
+;   lrvh %r4, 0(%r2) ; trap: heap_oob
 ;   lhr %r2, %r4
 ;   br %r14
 
@@ -365,7 +365,7 @@ block0:
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   larl %r1, 0 ; reloc_external PCRel32Dbl %sym 2
-;   lrvh %r2, 0(%r1)
+;   lrvh %r2, 0(%r1) ; trap: heap_oob
 ;   lhr %r2, %r2
 ;   br %r14
 
@@ -382,7 +382,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvh %r2, 0(%r2)
+;   lrvh %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %load_i16_sym() -> i16 {
@@ -401,7 +401,7 @@ block0:
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   larl %r1, 0 ; reloc_external PCRel32Dbl %sym 2
-;   lrvh %r2, 0(%r1)
+;   lrvh %r2, 0(%r1) ; trap: heap_oob
 ;   br %r14
 
 function %uload8_i16(i64) -> i16 {
@@ -417,7 +417,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llc %r2, 0(%r2)
+;   llc %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %sload8_i16(i64) -> i16 {
@@ -433,7 +433,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lb %r2, 0(%r2)
+;   lb %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %load_i8(i64) -> i8 {
@@ -449,6 +449,6 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llc %r2, 0(%r2)
+;   llc %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
diff --git a/cranelift/filetests/filetests/isa/s390x/load.clif b/cranelift/filetests/filetests/isa/s390x/load.clif
index 67abac1f5986..fb5c459ea38a 100644
--- a/cranelift/filetests/filetests/isa/s390x/load.clif
+++ b/cranelift/filetests/filetests/isa/s390x/load.clif
@@ -14,7 +14,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lg %r2, 0(%r2)
+;   lg %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %load_i64_sym() -> i64 {
@@ -32,7 +32,7 @@ block0:
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   lgrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   br %r14
 
 function %uload8_i64(i64) -> i64 {
@@ -48,7 +48,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llgc %r2, 0(%r2)
+;   llgc %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %sload8_i64(i64) -> i64 {
@@ -64,7 +64,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgb %r2, 0(%r2)
+;   lgb %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %uload16_i64(i64) -> i64 {
@@ -80,7 +80,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llgh %r2, 0(%r2)
+;   llgh %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %uload16_i64_sym() -> i64 {
@@ -98,7 +98,7 @@ block0:
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llghrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   llghrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   br %r14
 
 function %sload16_i64(i64) -> i64 {
@@ -114,7 +114,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgh %r2, 0(%r2)
+;   lgh %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %sload16_i64_sym() -> i64 {
@@ -132,7 +132,7 @@ block0:
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lghrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   lghrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   br %r14
 
 function %uload32_i64(i64) -> i64 {
@@ -148,7 +148,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llgf %r2, 0(%r2)
+;   llgf %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %uload32_i64_sym() -> i64 {
@@ -166,7 +166,7 @@ block0:
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llgfrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   llgfrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   br %r14
 
 function %sload32_i64(i64) -> i64 {
@@ -182,7 +182,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgf %r2, 0(%r2)
+;   lgf %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %sload32_i64_sym() -> i64 {
@@ -200,7 +200,7 @@ block0:
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgfrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   lgfrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   br %r14
 
 function %load_i32(i64) -> i32 {
@@ -216,7 +216,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   l %r2, 0(%r2)
+;   l %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %load_i32_sym() -> i32 {
@@ -234,7 +234,7 @@ block0:
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   lrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   br %r14
 
 function %load_i32_off(i64) -> i32 {
@@ -250,7 +250,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ly %r2, 0x1000(%r2)
+;   ly %r2, 0x1000(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %uload8_i32(i64) -> i32 {
@@ -266,7 +266,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llc %r2, 0(%r2)
+;   llc %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %sload8_i32(i64) -> i32 {
@@ -282,7 +282,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lb %r2, 0(%r2)
+;   lb %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %uload16_i32(i64) -> i32 {
@@ -298,7 +298,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llh %r2, 0(%r2)
+;   llh %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %uload16_i32_sym() -> i32 {
@@ -316,7 +316,7 @@ block0:
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llhrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   llhrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   br %r14
 
 function %sload16_i32(i64) -> i32 {
@@ -332,7 +332,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lh %r2, 0(%r2)
+;   lh %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %sload16_i32_off(i64) -> i32 {
@@ -348,7 +348,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lhy %r2, 0x1000(%r2)
+;   lhy %r2, 0x1000(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %sload16_i32_sym() -> i32 {
@@ -366,7 +366,7 @@ block0:
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lhrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   lhrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   br %r14
 
 function %load_i16(i64) -> i16 {
@@ -382,7 +382,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llh %r2, 0(%r2)
+;   llh %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %load_i16_sym() -> i16 {
@@ -400,7 +400,7 @@ block0:
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llhrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   llhrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   br %r14
 
 function %uload8_i16(i64) -> i16 {
@@ -416,7 +416,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llc %r2, 0(%r2)
+;   llc %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %sload8_i16(i64) -> i16 {
@@ -432,7 +432,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lb %r2, 0(%r2)
+;   lb %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %load_i8(i64) -> i8 {
@@ -448,6 +448,6 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llc %r2, 0(%r2)
+;   llc %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
diff --git a/cranelift/filetests/filetests/isa/s390x/multivalue-ret.clif b/cranelift/filetests/filetests/isa/s390x/multivalue-ret.clif
index 75937accc011..b80531782d16 100644
--- a/cranelift/filetests/filetests/isa/s390x/multivalue-ret.clif
+++ b/cranelift/filetests/filetests/isa/s390x/multivalue-ret.clif
@@ -40,16 +40,15 @@ block1:
 ; VCode:
 ;   stmg %r6, %r15, 48(%r15)
 ; block0:
-;   lghi %r5, 1
-;   lgr %r6, %r5
+;   lghi %r13, 1
 ;   lghi %r3, 2
 ;   lghi %r4, 3
 ;   lghi %r5, 4
-;   lghi %r13, 5
-;   lghi %r14, 6
-;   stg %r13, 0(%r2)
-;   stg %r14, 8(%r2)
-;   lgr %r2, %r6
+;   lghi %r14, 5
+;   lghi %r6, 6
+;   stg %r14, 0(%r2)
+;   stg %r6, 8(%r2)
+;   lgr %r2, %r13
 ;   lmg %r6, %r15, 48(%r15)
 ;   br %r14
 ;
@@ -57,16 +56,15 @@ block1:
 ; block0: ; offset 0x0
 ;   stmg %r6, %r15, 0x30(%r15)
 ; block1: ; offset 0x6
-;   lghi %r5, 1
-;   lgr %r6, %r5
+;   lghi %r13, 1
 ;   lghi %r3, 2
 ;   lghi %r4, 3
 ;   lghi %r5, 4
-;   lghi %r13, 5
-;   lghi %r14, 6
-;   stg %r13, 0(%r2)
-;   stg %r14, 8(%r2)
-;   lgr %r2, %r6
+;   lghi %r14, 5
+;   lghi %r6, 6
+;   stg %r14, 0(%r2)
+;   stg %r6, 8(%r2)
+;   lgr %r2, %r13
 ;   lmg %r6, %r15, 0x30(%r15)
 ;   br %r14
 
diff --git a/cranelift/filetests/filetests/isa/s390x/nan-canonicalization.clif b/cranelift/filetests/filetests/isa/s390x/nan-canonicalization.clif
new file mode 100644
index 000000000000..f2619125d987
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/s390x/nan-canonicalization.clif
@@ -0,0 +1,112 @@
+test compile precise-output
+set enable_nan_canonicalization=true 
+target s390x
+
+function %f0(f32x4, f32x4) -> f32x4 {
+block0(v0: f32x4, v1: f32x4):
+	v2 = fadd v0, v1
+	return v2
+}
+
+; VCode:
+; block0:
+;   vfasb %v17, %v24, %v25
+;   bras %r1, 8 ; data.f32 NaN ; vlef %v18, 0(%r1), 0
+;   vrepf %v18, %v18, 0
+;   vfchesb %v7, %v17, %v17
+;   vfchesb %v19, %v17, %v17
+;   vno %v19, %v7, %v19
+;   vsel %v24, %v18, %v17, %v19
+;   br %r14
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   vfasb %v17, %v24, %v25
+;   bras %r1, 0xe
+;   su %f12, 0
+;   vlef %v18, 0(%r1), 0
+;   vrepf %v18, %v18, 0
+;   vfchesb %v7, %v17, %v17
+;   vfchesb %v19, %v17, %v17
+;   vno %v19, %v7, %v19
+;   vsel %v24, %v18, %v17, %v19
+;   br %r14
+
+function %f1(f64, f64) -> f64 {
+block0(v0: f64, v1: f64):
+	v2 = fadd v0, v1
+	return v2
+}
+
+; VCode:
+; block0:
+;   wfadb %v21, %f0, %f2
+;   bras %r1, 12 ; data.f64 NaN ; vleg %v22, 0(%r1), 0
+;   vgbm %v20, 0
+;   vpdi %v22, %v22, %v20, 0
+;   vgbm %v20, 0
+;   vpdi %v23, %v21, %v20, 0
+;   vfchedb %v19, %v23, %v23
+;   vfchedb %v21, %v23, %v23
+;   vno %v24, %v19, %v21
+;   vsel %v21, %v22, %v23, %v24
+;   vrepg %v0, %v21, 0
+;   br %r14
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   wfadb %v21, %f0, %f2
+;   bras %r1, 0x12
+;   su %f15, 0(%r8)
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   vleg %v22, 0(%r1), 0
+;   vzero %v20
+;   vpdi %v22, %v22, %v20, 0
+;   vzero %v20
+;   vpdi %v23, %v21, %v20, 0
+;   vfchedb %v19, %v23, %v23
+;   vfchedb %v21, %v23, %v23
+;   vno %v24, %v19, %v21
+;   vsel %v21, %v22, %v23, %v24
+;   vrepg %v0, %v21, 0
+;   br %r14
+
+function %f1(f32, f32) -> f32 {
+block0(v0: f32, v1: f32):
+	v2 = fadd v0, v1
+	return v2
+}
+
+; VCode:
+; block0:
+;   wfasb %v21, %f0, %f2
+;   bras %r1, 8 ; data.f32 NaN ; vlef %v22, 0(%r1), 0
+;   vgbm %v20, 61440
+;   vn %v22, %v22, %v20
+;   vgbm %v20, 61440
+;   vn %v23, %v21, %v20
+;   vfchesb %v19, %v23, %v23
+;   vfchesb %v21, %v23, %v23
+;   vno %v24, %v19, %v21
+;   vsel %v21, %v22, %v23, %v24
+;   vrepf %v0, %v21, 0
+;   br %r14
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   wfasb %v21, %f0, %f2
+;   bras %r1, 0xe
+;   su %f12, 0
+;   vlef %v22, 0(%r1), 0
+;   vgbm %v20, 0xf000
+;   vn %v22, %v22, %v20
+;   vgbm %v20, 0xf000
+;   vn %v23, %v21, %v20
+;   vfchesb %v19, %v23, %v23
+;   vfchesb %v21, %v23, %v23
+;   vno %v24, %v19, %v21
+;   vsel %v21, %v22, %v23, %v24
+;   vrepf %v0, %v21, 0
+;   br %r14
+
diff --git a/cranelift/filetests/filetests/isa/s390x/reftypes.clif b/cranelift/filetests/filetests/isa/s390x/reftypes.clif
deleted file mode 100644
index a879eb37c9c4..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/reftypes.clif
+++ /dev/null
@@ -1,162 +0,0 @@
-test compile precise-output
-target s390x
-
-function %f0(r64, r64) -> r64 {
-block0(v0: r64, v1: r64):
-  return v1
-}
-
-; VCode:
-; block0:
-;   lgr %r2, %r3
-;   br %r14
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   lgr %r2, %r3
-;   br %r14
-
-function %f1(r64) -> i8 {
-block0(v0: r64):
-  v1 = is_null v0
-  return v1
-}
-
-; VCode:
-; block0:
-;   cghi %r2, 0
-;   lhi %r2, 0
-;   lochie %r2, 1
-;   br %r14
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   cghi %r2, 0
-;   lhi %r2, 0
-;   lochie %r2, 1
-;   br %r14
-
-function %f2(r64) -> i8 {
-block0(v0: r64):
-  v1 = is_invalid v0
-  return v1
-}
-
-; VCode:
-; block0:
-;   cghi %r2, -1
-;   lhi %r2, 0
-;   lochie %r2, 1
-;   br %r14
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   cghi %r2, -1
-;   lhi %r2, 0
-;   lochie %r2, 1
-;   br %r14
-
-function %f3() -> r64 {
-block0:
-  v0 = null.r64
-  return v0
-}
-
-; VCode:
-; block0:
-;   lghi %r2, 0
-;   br %r14
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   lghi %r2, 0
-;   br %r14
-
-function %f4(r64, r64) -> r64, r64, r64 {
-    fn0 = %f(r64) -> i8
-    ss0 = explicit_slot 8
-
-block0(v0: r64, v1: r64):
-    v2 = call fn0(v0)
-    stack_store.r64 v0, ss0
-    brif v2, block2(v0, v1), block1(v1, v0)
-
-block1(v3: r64, v4: r64):
-    jump block3(v3, v4)
-
-block2(v5: r64, v6: r64):
-    jump block3(v5, v6)
-
-block3(v7: r64, v8: r64):
-    v9 = stack_load.r64 ss0
-    return v7, v8, v9
-}
-
-; VCode:
-;   stmg %r11, %r15, 88(%r15)
-;   aghi %r15, -184
-;   virtual_sp_offset_adjust 160
-; block0:
-;   stg %r3, 176(%r15)
-;   lgr %r3, %r2
-;   lgr %r2, %r3
-;   lgr %r11, %r3
-;   bras %r1, 12 ; data %f + 0 ; lg %r3, 0(%r1)
-;   stg %r11, 168(%r15)
-;   basr %r14, %r3
-;   la %r5, 160(%r15)
-;   lgr %r3, %r11
-;   stg %r3, 0(%r5)
-;   lbr %r2, %r2
-;   chi %r2, 0
-;   jglh label2 ; jg label1
-; block1:
-;   lgr %r3, %r11
-;   lg %r2, 176(%r15)
-;   jg label3
-; block2:
-;   lgr %r2, %r11
-;   lg %r3, 176(%r15)
-;   jg label3
-; block3:
-;   la %r4, 160(%r15)
-;   lg %r4, 0(%r4)
-;   lmg %r11, %r15, 272(%r15)
-;   br %r14
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   stmg %r11, %r15, 0x58(%r15)
-;   aghi %r15, -0xb8
-; block1: ; offset 0xa
-;   stg %r3, 0xb0(%r15)
-;   lgr %r3, %r2
-;   lgr %r2, %r3
-;   lgr %r11, %r3
-;   bras %r1, 0x28
-;   .byte 0x00, 0x00 ; reloc_external Abs8 %f 0
-;   .byte 0x00, 0x00
-;   .byte 0x00, 0x00
-;   .byte 0x00, 0x00
-;   lg %r3, 0(%r1)
-;   stg %r11, 0xa8(%r15)
-;   basr %r14, %r3
-;   la %r5, 0xa0(%r15)
-;   lgr %r3, %r11
-;   stg %r3, 0(%r5)
-;   lbr %r2, %r2
-;   chi %r2, 0
-;   jglh 0x62
-; block2: ; offset 0x52
-;   lgr %r3, %r11
-;   lg %r2, 0xb0(%r15)
-;   jg 0x6c
-; block3: ; offset 0x62
-;   lgr %r2, %r11
-;   lg %r3, 0xb0(%r15)
-; block4: ; offset 0x6c
-;   la %r4, 0xa0(%r15)
-;   lg %r4, 0(%r4)
-;   lmg %r11, %r15, 0x110(%r15)
-;   br %r14
-
diff --git a/cranelift/filetests/filetests/isa/s390x/return-call-indirect.clif b/cranelift/filetests/filetests/isa/s390x/return-call-indirect.clif
new file mode 100644
index 000000000000..eb4bf5f5cc6f
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/s390x/return-call-indirect.clif
@@ -0,0 +1,457 @@
+test compile precise-output
+set preserve_frame_pointers=true
+target s390x
+
+;;;; Test passing `i64`s ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+function %callee_i64(i64) -> i64 tail {
+block0(v0: i64):
+    v1 = iadd_imm.i64 v0, 10
+    return v1
+}
+
+; VCode:
+;   stmg %r14, %r15, 112(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -160
+;   stg %r1, 0(%r15)
+; block0:
+;   aghi %r2, 10
+;   lmg %r14, %r15, 272(%r15)
+;   br %r14
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r14, %r15, 0x70(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -0xa0
+;   stg %r1, 0(%r15)
+; block1: ; offset 0x14
+;   aghi %r2, 0xa
+;   lmg %r14, %r15, 0x110(%r15)
+;   br %r14
+
+function %call_i64(i64) -> i64 tail {
+    sig0 = (i64) -> i64 tail
+    fn0 = %callee_i64(i64) -> i64 tail
+
+block0(v0: i64):
+    v1 = func_addr.i64 fn0
+    return_call_indirect sig0, v1(v0)
+}
+
+; VCode:
+;   stmg %r14, %r15, 112(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -160
+;   stg %r1, 0(%r15)
+; block0:
+;   bras %r1, 12 ; data %callee_i64 + 0 ; lg %r4, 0(%r1)
+;   return_call_ind %r4
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r14, %r15, 0x70(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -0xa0
+;   stg %r1, 0(%r15)
+; block1: ; offset 0x14
+;   bras %r1, 0x20
+;   .byte 0x00, 0x00 ; reloc_external Abs8 %callee_i64 0
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   lg %r4, 0(%r1)
+;   lmg %r14, %r15, 0x110(%r15)
+;   br %r4
+
+;;;; Test colocated tail calls ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+function %colocated_i64(i64) -> i64 tail {
+    sig0 = (i64) -> i64 tail
+    fn0 = colocated %callee_i64(i64) -> i64 tail
+
+block0(v0: i64):
+    v1 = func_addr.i64 fn0
+    return_call_indirect sig0, v1(v0)
+}
+
+; VCode:
+;   stmg %r14, %r15, 112(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -160
+;   stg %r1, 0(%r15)
+; block0:
+;   larl %r4, %callee_i64 + 0
+;   return_call_ind %r4
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r14, %r15, 0x70(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -0xa0
+;   stg %r1, 0(%r15)
+; block1: ; offset 0x14
+;   larl %r4, 0x14 ; reloc_external PCRel32Dbl %callee_i64 2
+;   lmg %r14, %r15, 0x110(%r15)
+;   br %r4
+
+;;;; Test passing `f64`s ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+function %callee_f64(f64) -> f64 tail {
+block0(v0: f64):
+    v1 = f64const 0x10.0
+    v2 = fadd.f64 v0, v1
+    return v2
+}
+
+; VCode:
+;   stmg %r14, %r15, 112(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -160
+;   stg %r1, 0(%r15)
+; block0:
+;   bras %r1, 12 ; data.f64 16 ; ld %f3, 0(%r1)
+;   adbr %f0, %f3
+;   lmg %r14, %r15, 272(%r15)
+;   br %r14
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r14, %r15, 0x70(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -0xa0
+;   stg %r1, 0(%r15)
+; block1: ; offset 0x14
+;   bras %r1, 0x20
+;   sth %r3, 0
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   ld %f3, 0(%r1)
+;   adbr %f0, %f3
+;   lmg %r14, %r15, 0x110(%r15)
+;   br %r14
+
+function %call_f64(f64) -> f64 tail {
+    sig0 = (f64) -> f64 tail
+    fn0 = %callee_f64(f64) -> f64 tail
+
+block0(v0: f64):
+    v1 = func_addr.i64 fn0
+    return_call_indirect sig0, v1(v0)
+}
+
+; VCode:
+;   stmg %r14, %r15, 112(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -160
+;   stg %r1, 0(%r15)
+; block0:
+;   bras %r1, 12 ; data %callee_f64 + 0 ; lg %r4, 0(%r1)
+;   return_call_ind %r4
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r14, %r15, 0x70(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -0xa0
+;   stg %r1, 0(%r15)
+; block1: ; offset 0x14
+;   bras %r1, 0x20
+;   .byte 0x00, 0x00 ; reloc_external Abs8 %callee_f64 0
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   lg %r4, 0(%r1)
+;   lmg %r14, %r15, 0x110(%r15)
+;   br %r4
+
+;;;; Test passing `i8`s ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+function %callee_i8(i8) -> i8 tail {
+block0(v0: i8):
+    v1 = iconst.i8 0
+    v2 = icmp eq v0, v1
+    return v2
+}
+
+; VCode:
+;   stmg %r14, %r15, 112(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -160
+;   stg %r1, 0(%r15)
+; block0:
+;   llcr %r4, %r2
+;   clfi %r4, 0
+;   lhi %r2, 0
+;   lochie %r2, 1
+;   lmg %r14, %r15, 272(%r15)
+;   br %r14
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r14, %r15, 0x70(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -0xa0
+;   stg %r1, 0(%r15)
+; block1: ; offset 0x14
+;   llcr %r4, %r2
+;   clfi %r4, 0
+;   lhi %r2, 0
+;   lochie %r2, 1
+;   lmg %r14, %r15, 0x110(%r15)
+;   br %r14
+
+function %call_i8(i8) -> i8 tail {
+    sig0 = (i8) -> i8 tail
+    fn0 = %callee_i8(i8) -> i8 tail
+
+block0(v0: i8):
+    v1 = func_addr.i64 fn0
+    return_call_indirect sig0, v1(v0)
+}
+
+; VCode:
+;   stmg %r14, %r15, 112(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -160
+;   stg %r1, 0(%r15)
+; block0:
+;   bras %r1, 12 ; data %callee_i8 + 0 ; lg %r4, 0(%r1)
+;   return_call_ind %r4
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r14, %r15, 0x70(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -0xa0
+;   stg %r1, 0(%r15)
+; block1: ; offset 0x14
+;   bras %r1, 0x20
+;   .byte 0x00, 0x00 ; reloc_external Abs8 %callee_i8 0
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   lg %r4, 0(%r1)
+;   lmg %r14, %r15, 0x110(%r15)
+;   br %r4
+
+;;;; Test passing many arguments on stack ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+function %tail_caller_stack_args() -> i64 tail {
+    fn0 = %tail_callee_stack_args(i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64) -> i64 tail
+
+block0:
+    v0 = iconst.i64 10
+    v1 = iconst.i64 15
+    v2 = iconst.i64 20
+    v3 = iconst.i64 25
+    v4 = iconst.i64 30
+    v5 = iconst.i64 35
+    v6 = iconst.i64 40
+    v7 = iconst.i64 45
+    v8 = iconst.i64 50
+    v9 = iconst.i64 55
+    v10 = iconst.i64 60
+    v11 = iconst.i64 65
+    v12 = iconst.i64 70
+    v13 = iconst.i64 75
+    v14 = iconst.i64 80
+    v15 = iconst.i64 85
+    v16 = iconst.i64 90
+    v17 = iconst.i64 95
+    v18 = iconst.i64 100
+    v19 = iconst.i64 105
+    v20 = iconst.i64 110
+    v21 = iconst.i64 115
+    v22 = iconst.i64 120
+    v23 = iconst.i64 125
+    v24 = iconst.i64 130
+    v25 = iconst.i64 135
+    v26 = func_addr.i64 fn0
+    return_call_indirect sig0, v26(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25)
+}
+
+; VCode:
+;   stmg %r8, %r15, 64(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -600
+;   stg %r1, 0(%r15)
+; block0:
+;   lghi %r3, 10
+;   stg %r3, 272(%r15)
+;   lghi %r4, 15
+;   stg %r4, 264(%r15)
+;   lghi %r5, 20
+;   stg %r5, 256(%r15)
+;   lghi %r6, 25
+;   stg %r6, 248(%r15)
+;   lghi %r7, 30
+;   stg %r7, 240(%r15)
+;   lghi %r7, 35
+;   stg %r7, 232(%r15)
+;   lghi %r14, 40
+;   lghi %r8, 45
+;   lghi %r9, 50
+;   lghi %r10, 55
+;   lghi %r11, 60
+;   lghi %r12, 65
+;   lghi %r13, 70
+;   lghi %r2, 75
+;   lghi %r3, 80
+;   lghi %r4, 85
+;   lghi %r6, 90
+;   stg %r6, 224(%r15)
+;   lghi %r6, 95
+;   lghi %r7, 100
+;   lghi %r5, 105
+;   stg %r5, 216(%r15)
+;   lghi %r5, 110
+;   stg %r5, 208(%r15)
+;   lghi %r5, 115
+;   stg %r5, 200(%r15)
+;   lghi %r5, 120
+;   stg %r5, 192(%r15)
+;   lghi %r5, 125
+;   stg %r5, 184(%r15)
+;   lghi %r5, 130
+;   stg %r5, 176(%r15)
+;   lghi %r5, 135
+;   stg %r5, 168(%r15)
+;   bras %r1, 12 ; data %tail_callee_stack_args + 0 ; lg %r5, 0(%r1)
+;   stg %r5, 160(%r15)
+;   lg %r5, 600(%r15)
+;   stg %r5, 280(%r15)
+;   stg %r14, 440(%r15)
+;   stg %r8, 448(%r15)
+;   stg %r9, 456(%r15)
+;   stg %r10, 464(%r15)
+;   stg %r11, 472(%r15)
+;   stg %r12, 480(%r15)
+;   stg %r13, 488(%r15)
+;   stg %r2, 496(%r15)
+;   stg %r3, 504(%r15)
+;   stg %r4, 512(%r15)
+;   lg %r2, 224(%r15)
+;   stg %r2, 520(%r15)
+;   stg %r6, 528(%r15)
+;   stg %r7, 536(%r15)
+;   lg %r5, 216(%r15)
+;   stg %r5, 544(%r15)
+;   lg %r5, 208(%r15)
+;   stg %r5, 552(%r15)
+;   lg %r5, 200(%r15)
+;   stg %r5, 560(%r15)
+;   lg %r5, 192(%r15)
+;   stg %r5, 568(%r15)
+;   lg %r5, 184(%r15)
+;   stg %r5, 576(%r15)
+;   lg %r5, 176(%r15)
+;   stg %r5, 584(%r15)
+;   lg %r5, 168(%r15)
+;   stg %r5, 592(%r15)
+;   lg %r2, 272(%r15)
+;   lg %r3, 264(%r15)
+;   lg %r4, 256(%r15)
+;   lg %r5, 248(%r15)
+;   lg %r6, 240(%r15)
+;   lg %r7, 232(%r15)
+;   lg %r12, 160(%r15)
+;   return_call_ind %r12 ; callee_pop_size 320
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r8, %r15, 0x40(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -0x258
+;   stg %r1, 0(%r15)
+; block1: ; offset 0x14
+;   lghi %r3, 0xa
+;   stg %r3, 0x110(%r15)
+;   lghi %r4, 0xf
+;   stg %r4, 0x108(%r15)
+;   lghi %r5, 0x14
+;   stg %r5, 0x100(%r15)
+;   lghi %r6, 0x19
+;   stg %r6, 0xf8(%r15)
+;   lghi %r7, 0x1e
+;   stg %r7, 0xf0(%r15)
+;   lghi %r7, 0x23
+;   stg %r7, 0xe8(%r15)
+;   lghi %r14, 0x28
+;   lghi %r8, 0x2d
+;   lghi %r9, 0x32
+;   lghi %r10, 0x37
+;   lghi %r11, 0x3c
+;   lghi %r12, 0x41
+;   lghi %r13, 0x46
+;   lghi %r2, 0x4b
+;   lghi %r3, 0x50
+;   lghi %r4, 0x55
+;   lghi %r6, 0x5a
+;   stg %r6, 0xe0(%r15)
+;   lghi %r6, 0x5f
+;   lghi %r7, 0x64
+;   lghi %r5, 0x69
+;   stg %r5, 0xd8(%r15)
+;   lghi %r5, 0x6e
+;   stg %r5, 0xd0(%r15)
+;   lghi %r5, 0x73
+;   stg %r5, 0xc8(%r15)
+;   lghi %r5, 0x78
+;   stg %r5, 0xc0(%r15)
+;   lghi %r5, 0x7d
+;   stg %r5, 0xb8(%r15)
+;   lghi %r5, 0x82
+;   stg %r5, 0xb0(%r15)
+;   lghi %r5, 0x87
+;   stg %r5, 0xa8(%r15)
+;   bras %r1, 0xdc
+;   .byte 0x00, 0x00 ; reloc_external Abs8 %tail_callee_stack_args 0
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   lg %r5, 0(%r1)
+;   stg %r5, 0xa0(%r15)
+;   lg %r5, 0x258(%r15)
+;   stg %r5, 0x118(%r15)
+;   stg %r14, 0x1b8(%r15)
+;   stg %r8, 0x1c0(%r15)
+;   stg %r9, 0x1c8(%r15)
+;   stg %r10, 0x1d0(%r15)
+;   stg %r11, 0x1d8(%r15)
+;   stg %r12, 0x1e0(%r15)
+;   stg %r13, 0x1e8(%r15)
+;   stg %r2, 0x1f0(%r15)
+;   stg %r3, 0x1f8(%r15)
+;   stg %r4, 0x200(%r15)
+;   lg %r2, 0xe0(%r15)
+;   stg %r2, 0x208(%r15)
+;   stg %r6, 0x210(%r15)
+;   stg %r7, 0x218(%r15)
+;   lg %r5, 0xd8(%r15)
+;   stg %r5, 0x220(%r15)
+;   lg %r5, 0xd0(%r15)
+;   stg %r5, 0x228(%r15)
+;   lg %r5, 0xc8(%r15)
+;   stg %r5, 0x230(%r15)
+;   lg %r5, 0xc0(%r15)
+;   stg %r5, 0x238(%r15)
+;   lg %r5, 0xb8(%r15)
+;   stg %r5, 0x240(%r15)
+;   lg %r5, 0xb0(%r15)
+;   stg %r5, 0x248(%r15)
+;   lg %r5, 0xa8(%r15)
+;   stg %r5, 0x250(%r15)
+;   lg %r2, 0x110(%r15)
+;   lg %r3, 0x108(%r15)
+;   lg %r4, 0x100(%r15)
+;   lg %r5, 0xf8(%r15)
+;   lg %r6, 0xf0(%r15)
+;   lg %r7, 0xe8(%r15)
+;   lg %r12, 0xa0(%r15)
+;   lgr %r1, %r12
+;   aghi %r15, 0x118
+;   lmg %r8, %r14, 0x180(%r15)
+;   br %r1
+
diff --git a/cranelift/filetests/filetests/isa/s390x/return-call.clif b/cranelift/filetests/filetests/isa/s390x/return-call.clif
new file mode 100644
index 000000000000..bd521bc8d71a
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/s390x/return-call.clif
@@ -0,0 +1,711 @@
+test compile precise-output
+set preserve_frame_pointers=true
+target s390x
+
+;;;; Test passing `i64`s ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+function %callee_i64(i64) -> i64 tail {
+block0(v0: i64):
+    v1 = iadd_imm.i64 v0, 10
+    return v1
+}
+
+; VCode:
+;   stmg %r14, %r15, 112(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -160
+;   stg %r1, 0(%r15)
+; block0:
+;   aghi %r2, 10
+;   lmg %r14, %r15, 272(%r15)
+;   br %r14
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r14, %r15, 0x70(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -0xa0
+;   stg %r1, 0(%r15)
+; block1: ; offset 0x14
+;   aghi %r2, 0xa
+;   lmg %r14, %r15, 0x110(%r15)
+;   br %r14
+
+function %call_i64(i64) -> i64 tail {
+    fn0 = %callee_i64(i64) -> i64 tail
+
+block0(v0: i64):
+    return_call fn0(v0)
+}
+
+; VCode:
+;   stmg %r14, %r15, 112(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -160
+;   stg %r1, 0(%r15)
+; block0:
+;   bras %r1, 12 ; data %callee_i64 + 0 ; lg %r4, 0(%r1)
+;   return_call_ind %r4
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r14, %r15, 0x70(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -0xa0
+;   stg %r1, 0(%r15)
+; block1: ; offset 0x14
+;   bras %r1, 0x20
+;   .byte 0x00, 0x00 ; reloc_external Abs8 %callee_i64 0
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   lg %r4, 0(%r1)
+;   lmg %r14, %r15, 0x110(%r15)
+;   br %r4
+
+function %call_i64_multiret(i64) -> i64, i64, i64, i64, i64, i64, i64, i64 tail {
+    fn0 = %callee_i64_multiret(i64) -> i64, i64, i64, i64, i64, i64, i64, i64 tail
+
+block0(v0: i64):
+    return_call fn0(v0)
+}
+
+; VCode:
+;   stmg %r14, %r15, 112(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -160
+;   stg %r1, 0(%r15)
+; block0:
+;   bras %r1, 12 ; data %callee_i64_multiret + 0 ; lg %r5, 0(%r1)
+;   return_call_ind %r5
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r14, %r15, 0x70(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -0xa0
+;   stg %r1, 0(%r15)
+; block1: ; offset 0x14
+;   bras %r1, 0x20
+;   .byte 0x00, 0x00 ; reloc_external Abs8 %callee_i64_multiret 0
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   lg %r5, 0(%r1)
+;   lmg %r14, %r15, 0x110(%r15)
+;   br %r5
+
+function %call_i64_multiret_clobber(i64) -> i64, i64, i64, i64, i64, i64, i64, i64 tail {
+    fn0 = %callee_i64_multiret(i64) -> i64, i64, i64, i64, i64, i64, i64, i64 tail
+    fn1 = %callee_i64(i64) -> i64 tail
+
+block0(v0: i64):
+    v1 = call fn1(v0)
+    return_call fn0(v1)
+}
+
+; VCode:
+;   stmg %r9, %r15, 72(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -160
+;   stg %r1, 0(%r15)
+; block0:
+;   lgr %r9, %r2
+;   bras %r1, 12 ; data %callee_i64 + 0 ; lg %r7, 0(%r1)
+;   lgr %r2, %r3
+;   basr %r14, %r7
+;   bras %r1, 12 ; data %callee_i64_multiret + 0 ; lg %r7, 0(%r1)
+;   lgr %r3, %r2
+;   lgr %r2, %r9
+;   return_call_ind %r7
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r9, %r15, 0x48(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -0xa0
+;   stg %r1, 0(%r15)
+; block1: ; offset 0x14
+;   lgr %r9, %r2
+;   bras %r1, 0x24
+;   .byte 0x00, 0x00 ; reloc_external Abs8 %callee_i64 0
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   lg %r7, 0(%r1)
+;   lgr %r2, %r3
+;   basr %r14, %r7
+;   bras %r1, 0x3c
+;   .byte 0x00, 0x00 ; reloc_external Abs8 %callee_i64_multiret 0
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   lg %r7, 0(%r1)
+;   lgr %r3, %r2
+;   lgr %r2, %r9
+;   lmg %r9, %r15, 0xe8(%r15)
+;   br %r7
+
+;;;; Test colocated tail calls ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+function %colocated_i64(i64) -> i64 tail {
+    fn0 = colocated %callee_i64(i64) -> i64 tail
+
+block0(v0: i64):
+    return_call fn0(v0)
+}
+
+; VCode:
+;   stmg %r14, %r15, 112(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -160
+;   stg %r1, 0(%r15)
+; block0:
+;   return_call %callee_i64
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r14, %r15, 0x70(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -0xa0
+;   stg %r1, 0(%r15)
+; block1: ; offset 0x14
+;   lmg %r14, %r15, 0x110(%r15)
+;   jg 0x1a ; reloc_external PLTRel32Dbl %callee_i64 2
+
+;;;; Test passing `f64`s ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+function %callee_f64(f64) -> f64 tail {
+block0(v0: f64):
+    v1 = f64const 0x10.0
+    v2 = fadd.f64 v0, v1
+    return v2
+}
+
+; VCode:
+;   stmg %r14, %r15, 112(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -160
+;   stg %r1, 0(%r15)
+; block0:
+;   bras %r1, 12 ; data.f64 16 ; ld %f3, 0(%r1)
+;   adbr %f0, %f3
+;   lmg %r14, %r15, 272(%r15)
+;   br %r14
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r14, %r15, 0x70(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -0xa0
+;   stg %r1, 0(%r15)
+; block1: ; offset 0x14
+;   bras %r1, 0x20
+;   sth %r3, 0
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   ld %f3, 0(%r1)
+;   adbr %f0, %f3
+;   lmg %r14, %r15, 0x110(%r15)
+;   br %r14
+
+function %call_f64(f64) -> f64 tail {
+    fn0 = %callee_f64(f64) -> f64 tail
+
+block0(v0: f64):
+    return_call fn0(v0)
+}
+
+; VCode:
+;   stmg %r14, %r15, 112(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -160
+;   stg %r1, 0(%r15)
+; block0:
+;   bras %r1, 12 ; data %callee_f64 + 0 ; lg %r4, 0(%r1)
+;   return_call_ind %r4
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r14, %r15, 0x70(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -0xa0
+;   stg %r1, 0(%r15)
+; block1: ; offset 0x14
+;   bras %r1, 0x20
+;   .byte 0x00, 0x00 ; reloc_external Abs8 %callee_f64 0
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   lg %r4, 0(%r1)
+;   lmg %r14, %r15, 0x110(%r15)
+;   br %r4
+
+;;;; Test passing `i8`s ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+function %callee_i8(i8) -> i8 tail {
+block0(v0: i8):
+    v1 = iconst.i8 0
+    v2 = icmp eq v0, v1
+    return v2
+}
+
+; VCode:
+;   stmg %r14, %r15, 112(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -160
+;   stg %r1, 0(%r15)
+; block0:
+;   llcr %r4, %r2
+;   clfi %r4, 0
+;   lhi %r2, 0
+;   lochie %r2, 1
+;   lmg %r14, %r15, 272(%r15)
+;   br %r14
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r14, %r15, 0x70(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -0xa0
+;   stg %r1, 0(%r15)
+; block1: ; offset 0x14
+;   llcr %r4, %r2
+;   clfi %r4, 0
+;   lhi %r2, 0
+;   lochie %r2, 1
+;   lmg %r14, %r15, 0x110(%r15)
+;   br %r14
+
+function %call_i8(i8) -> i8 tail {
+    fn0 = %callee_i8(i8) -> i8 tail
+
+block0(v0: i8):
+    return_call fn0(v0)
+}
+
+; VCode:
+;   stmg %r14, %r15, 112(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -160
+;   stg %r1, 0(%r15)
+; block0:
+;   bras %r1, 12 ; data %callee_i8 + 0 ; lg %r4, 0(%r1)
+;   return_call_ind %r4
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r14, %r15, 0x70(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -0xa0
+;   stg %r1, 0(%r15)
+; block1: ; offset 0x14
+;   bras %r1, 0x20
+;   .byte 0x00, 0x00 ; reloc_external Abs8 %callee_i8 0
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   lg %r4, 0(%r1)
+;   lmg %r14, %r15, 0x110(%r15)
+;   br %r4
+
+;;;; Test passing fewer arguments on the stack ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+function %one_stack_arg(i32, i32, i32, i32, i32, i32, i32) tail {
+block0(v0: i32, v1: i32, v2: i32, v3: i32, v4: i32, v5: i32, v6: i32):
+    return
+}
+
+; VCode:
+;   stmg %r14, %r15, 280(%r15)
+;   la %r1, 168(%r15)
+;   aghi %r15, -160
+;   stg %r1, 0(%r15)
+; block0:
+;   aghi %r15, 328
+;   lmg %r14, %r14, 112(%r15)
+;   br %r14
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r14, %r15, 0x118(%r15)
+;   la %r1, 0xa8(%r15)
+;   aghi %r15, -0xa0
+;   stg %r1, 0(%r15)
+; block1: ; offset 0x14
+;   aghi %r15, 0x148
+;   lmg %r14, %r14, 0x70(%r15)
+;   br %r14
+
+function %call_one_stack_arg(i32, i32, i32, i32, i32, i32, i32, i32, i32) tail {
+    fn0 = colocated %one_stack_arg(i32, i32, i32, i32, i32, i32, i32) tail
+
+block0(v0: i32, v1: i32, v2: i32, v3: i32, v4: i32, v5: i32, v6: i32, v7: i32, v8: i32):
+    return_call fn0(v2, v3, v4, v5, v6, v7, v8)
+}
+
+; VCode:
+;   stmg %r9, %r15, 256(%r15)
+;   la %r1, 184(%r15)
+;   aghi %r15, -160
+;   stg %r1, 0(%r15)
+; block0:
+;   lgr %r9, %r7
+;   lgr %r14, %r6
+;   llgf %r6, 324(%r15)
+;   llgf %r7, 332(%r15)
+;   llgf %r2, 340(%r15)
+;   lg %r3, 344(%r15)
+;   stg %r3, 176(%r15)
+;   st %r2, 340(%r15)
+;   lgr %r3, %r5
+;   lgr %r5, %r9
+;   lgr %r2, %r4
+;   lgr %r4, %r14
+;   return_call %one_stack_arg ; callee_pop_size 168
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r9, %r15, 0x100(%r15)
+;   la %r1, 0xb8(%r15)
+;   aghi %r15, -0xa0
+;   stg %r1, 0(%r15)
+; block1: ; offset 0x14
+;   lgr %r9, %r7
+;   lgr %r14, %r6
+;   llgf %r6, 0x144(%r15)
+;   llgf %r7, 0x14c(%r15)
+;   llgf %r2, 0x154(%r15)
+;   lg %r3, 0x158(%r15)
+;   stg %r3, 0xb0(%r15)
+;   st %r2, 0x154(%r15)
+;   lgr %r3, %r5
+;   lgr %r5, %r9
+;   lgr %r2, %r4
+;   lgr %r4, %r14
+;   aghi %r15, 0xb0
+;   lmg %r9, %r14, 0xf0(%r15)
+;   jg 0x58 ; reloc_external PLTRel32Dbl %one_stack_arg 2
+
+function %call_zero_stack_args(i32, i32, i32, i32, i32, i32, i32, i32, i8) -> i8 tail {
+    fn0 = colocated %callee_i8(i8) -> i8 tail
+
+block0(v0: i32, v1: i32, v2: i32, v3: i32, v4: i32, v5: i32, v6: i32, v7: i32, v8: i8):
+    return_call fn0(v8)
+}
+
+; VCode:
+;   stmg %r14, %r15, 296(%r15)
+;   la %r1, 184(%r15)
+;   aghi %r15, -160
+;   stg %r1, 0(%r15)
+; block0:
+;   llgc %r2, 343(%r15)
+;   return_call %callee_i8
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r14, %r15, 0x128(%r15)
+;   la %r1, 0xb8(%r15)
+;   aghi %r15, -0xa0
+;   stg %r1, 0(%r15)
+; block1: ; offset 0x14
+;   llgc %r2, 0x157(%r15)
+;   aghi %r15, 0x158
+;   lmg %r14, %r14, 0x70(%r15)
+;   jg 0x24 ; reloc_external PLTRel32Dbl %callee_i8 2
+
+;;;; Test growing the argument area when it's non-empty ;;;;;;;;;;;;;;;;;;;;;;;;
+
+function %call_from_one_stack_arg(i32, i32, i32, i32, i32, i32, i32) tail {
+    fn0 = colocated %call_one_stack_arg(i32, i32, i32, i32, i32, i32, i32, i32, i32) tail
+
+block0(v0: i32, v1: i32, v2: i32, v3: i32, v4: i32, v5: i32, v6: i32):
+    return_call fn0(v1, v2, v3, v4, v5, v6, v0, v0, v1)
+}
+
+; VCode:
+;   stmg %r8, %r15, 232(%r15)
+;   la %r1, 168(%r15)
+;   aghi %r15, -176
+;   stg %r1, 0(%r15)
+; block0:
+;   lgr %r8, %r7
+;   llgf %r7, 340(%r15)
+;   lg %r10, 344(%r15)
+;   stg %r10, 160(%r15)
+;   st %r2, 324(%r15)
+;   st %r2, 332(%r15)
+;   st %r3, 340(%r15)
+;   lgr %r2, %r3
+;   lgr %r3, %r4
+;   lgr %r4, %r5
+;   lgr %r5, %r6
+;   lgr %r6, %r8
+;   return_call %call_one_stack_arg ; callee_pop_size 184
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r8, %r15, 0xe8(%r15)
+;   la %r1, 0xa8(%r15)
+;   aghi %r15, -0xb0
+;   stg %r1, 0(%r15)
+; block1: ; offset 0x14
+;   lgr %r8, %r7
+;   llgf %r7, 0x154(%r15)
+;   lg %r10, 0x158(%r15)
+;   stg %r10, 0xa0(%r15)
+;   st %r2, 0x144(%r15)
+;   st %r2, 0x14c(%r15)
+;   st %r3, 0x154(%r15)
+;   lgr %r2, %r3
+;   lgr %r3, %r4
+;   lgr %r4, %r5
+;   lgr %r5, %r6
+;   lgr %r6, %r8
+;   aghi %r15, 0xa0
+;   lmg %r8, %r14, 0xf8(%r15)
+;   jg 0x54 ; reloc_external PLTRel32Dbl %call_one_stack_arg 2
+
+;;;; Test passing many arguments on stack ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+function %tail_callee_stack_args(i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64) -> i64 tail {
+block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64, v6: i64, v7: i64, v8: i64, v9: i64, v10: i64, v11: i64, v12: i64, v13: i64, v14: i64, v15: i64, v16: i64, v17: i64, v18: i64, v19: i64, v20: i64, v21: i64, v22: i64, v23: i64, v24: i64, v25: i64):
+    return v25
+}
+
+; VCode:
+;   stmg %r14, %r15, 432(%r15)
+;   la %r1, 320(%r15)
+;   aghi %r15, -160
+;   stg %r1, 0(%r15)
+; block0:
+;   lg %r2, 472(%r15)
+;   aghi %r15, 480
+;   lmg %r14, %r14, 112(%r15)
+;   br %r14
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r14, %r15, 0x1b0(%r15)
+;   la %r1, 0x140(%r15)
+;   aghi %r15, -0xa0
+;   stg %r1, 0(%r15)
+; block1: ; offset 0x14
+;   lg %r2, 0x1d8(%r15)
+;   aghi %r15, 0x1e0
+;   lmg %r14, %r14, 0x70(%r15)
+;   br %r14
+
+function %tail_caller_stack_args() -> i64 tail {
+    fn0 = %tail_callee_stack_args(i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64) -> i64 tail
+
+block0:
+    v0 = iconst.i64 10
+    v1 = iconst.i64 15
+    v2 = iconst.i64 20
+    v3 = iconst.i64 25
+    v4 = iconst.i64 30
+    v5 = iconst.i64 35
+    v6 = iconst.i64 40
+    v7 = iconst.i64 45
+    v8 = iconst.i64 50
+    v9 = iconst.i64 55
+    v10 = iconst.i64 60
+    v11 = iconst.i64 65
+    v12 = iconst.i64 70
+    v13 = iconst.i64 75
+    v14 = iconst.i64 80
+    v15 = iconst.i64 85
+    v16 = iconst.i64 90
+    v17 = iconst.i64 95
+    v18 = iconst.i64 100
+    v19 = iconst.i64 105
+    v20 = iconst.i64 110
+    v21 = iconst.i64 115
+    v22 = iconst.i64 120
+    v23 = iconst.i64 125
+    v24 = iconst.i64 130
+    v25 = iconst.i64 135
+    return_call fn0(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25)
+}
+
+; VCode:
+;   stmg %r8, %r15, 64(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -592
+;   stg %r1, 0(%r15)
+; block0:
+;   lghi %r3, 10
+;   stg %r3, 264(%r15)
+;   lghi %r4, 15
+;   stg %r4, 256(%r15)
+;   lghi %r5, 20
+;   stg %r5, 248(%r15)
+;   lghi %r6, 25
+;   stg %r6, 240(%r15)
+;   lghi %r7, 30
+;   stg %r7, 232(%r15)
+;   lghi %r7, 35
+;   stg %r7, 224(%r15)
+;   lghi %r14, 40
+;   lghi %r8, 45
+;   lghi %r9, 50
+;   lghi %r10, 55
+;   lghi %r11, 60
+;   lghi %r12, 65
+;   lghi %r13, 70
+;   lghi %r2, 75
+;   lghi %r3, 80
+;   lghi %r4, 85
+;   lghi %r6, 90
+;   stg %r6, 216(%r15)
+;   lghi %r6, 95
+;   lghi %r7, 100
+;   lghi %r5, 105
+;   stg %r5, 208(%r15)
+;   lghi %r5, 110
+;   stg %r5, 200(%r15)
+;   lghi %r5, 115
+;   stg %r5, 192(%r15)
+;   lghi %r5, 120
+;   stg %r5, 184(%r15)
+;   lghi %r5, 125
+;   stg %r5, 176(%r15)
+;   lghi %r5, 130
+;   stg %r5, 168(%r15)
+;   lghi %r5, 135
+;   stg %r5, 160(%r15)
+;   lg %r5, 592(%r15)
+;   stg %r5, 272(%r15)
+;   stg %r14, 432(%r15)
+;   stg %r8, 440(%r15)
+;   stg %r9, 448(%r15)
+;   stg %r10, 456(%r15)
+;   stg %r11, 464(%r15)
+;   stg %r12, 472(%r15)
+;   stg %r13, 480(%r15)
+;   stg %r2, 488(%r15)
+;   stg %r3, 496(%r15)
+;   stg %r4, 504(%r15)
+;   lg %r4, 216(%r15)
+;   stg %r4, 512(%r15)
+;   stg %r6, 520(%r15)
+;   stg %r7, 528(%r15)
+;   lg %r5, 208(%r15)
+;   stg %r5, 536(%r15)
+;   lg %r5, 200(%r15)
+;   stg %r5, 544(%r15)
+;   lg %r5, 192(%r15)
+;   stg %r5, 552(%r15)
+;   lg %r5, 184(%r15)
+;   stg %r5, 560(%r15)
+;   lg %r5, 176(%r15)
+;   stg %r5, 568(%r15)
+;   lg %r5, 168(%r15)
+;   stg %r5, 576(%r15)
+;   lg %r5, 160(%r15)
+;   stg %r5, 584(%r15)
+;   bras %r1, 12 ; data %tail_callee_stack_args + 0 ; lg %r8, 0(%r1)
+;   lg %r2, 264(%r15)
+;   lg %r3, 256(%r15)
+;   lg %r4, 248(%r15)
+;   lg %r5, 240(%r15)
+;   lg %r6, 232(%r15)
+;   lg %r7, 224(%r15)
+;   return_call_ind %r8 ; callee_pop_size 320
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r8, %r15, 0x40(%r15)
+;   lgr %r1, %r15
+;   aghi %r15, -0x250
+;   stg %r1, 0(%r15)
+; block1: ; offset 0x14
+;   lghi %r3, 0xa
+;   stg %r3, 0x108(%r15)
+;   lghi %r4, 0xf
+;   stg %r4, 0x100(%r15)
+;   lghi %r5, 0x14
+;   stg %r5, 0xf8(%r15)
+;   lghi %r6, 0x19
+;   stg %r6, 0xf0(%r15)
+;   lghi %r7, 0x1e
+;   stg %r7, 0xe8(%r15)
+;   lghi %r7, 0x23
+;   stg %r7, 0xe0(%r15)
+;   lghi %r14, 0x28
+;   lghi %r8, 0x2d
+;   lghi %r9, 0x32
+;   lghi %r10, 0x37
+;   lghi %r11, 0x3c
+;   lghi %r12, 0x41
+;   lghi %r13, 0x46
+;   lghi %r2, 0x4b
+;   lghi %r3, 0x50
+;   lghi %r4, 0x55
+;   lghi %r6, 0x5a
+;   stg %r6, 0xd8(%r15)
+;   lghi %r6, 0x5f
+;   lghi %r7, 0x64
+;   lghi %r5, 0x69
+;   stg %r5, 0xd0(%r15)
+;   lghi %r5, 0x6e
+;   stg %r5, 0xc8(%r15)
+;   lghi %r5, 0x73
+;   stg %r5, 0xc0(%r15)
+;   lghi %r5, 0x78
+;   stg %r5, 0xb8(%r15)
+;   lghi %r5, 0x7d
+;   stg %r5, 0xb0(%r15)
+;   lghi %r5, 0x82
+;   stg %r5, 0xa8(%r15)
+;   lghi %r5, 0x87
+;   stg %r5, 0xa0(%r15)
+;   lg %r5, 0x250(%r15)
+;   stg %r5, 0x110(%r15)
+;   stg %r14, 0x1b0(%r15)
+;   stg %r8, 0x1b8(%r15)
+;   stg %r9, 0x1c0(%r15)
+;   stg %r10, 0x1c8(%r15)
+;   stg %r11, 0x1d0(%r15)
+;   stg %r12, 0x1d8(%r15)
+;   stg %r13, 0x1e0(%r15)
+;   stg %r2, 0x1e8(%r15)
+;   stg %r3, 0x1f0(%r15)
+;   stg %r4, 0x1f8(%r15)
+;   lg %r4, 0xd8(%r15)
+;   stg %r4, 0x200(%r15)
+;   stg %r6, 0x208(%r15)
+;   stg %r7, 0x210(%r15)
+;   lg %r5, 0xd0(%r15)
+;   stg %r5, 0x218(%r15)
+;   lg %r5, 0xc8(%r15)
+;   stg %r5, 0x220(%r15)
+;   lg %r5, 0xc0(%r15)
+;   stg %r5, 0x228(%r15)
+;   lg %r5, 0xb8(%r15)
+;   stg %r5, 0x230(%r15)
+;   lg %r5, 0xb0(%r15)
+;   stg %r5, 0x238(%r15)
+;   lg %r5, 0xa8(%r15)
+;   stg %r5, 0x240(%r15)
+;   lg %r5, 0xa0(%r15)
+;   stg %r5, 0x248(%r15)
+;   bras %r1, 0x190
+;   .byte 0x00, 0x00 ; reloc_external Abs8 %tail_callee_stack_args 0
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   lg %r8, 0(%r1)
+;   lg %r2, 0x108(%r15)
+;   lg %r3, 0x100(%r15)
+;   lg %r4, 0xf8(%r15)
+;   lg %r5, 0xf0(%r15)
+;   lg %r6, 0xe8(%r15)
+;   lg %r7, 0xe0(%r15)
+;   lgr %r1, %r8
+;   aghi %r15, 0x110
+;   lmg %r8, %r14, 0x180(%r15)
+;   br %r1
+
diff --git a/cranelift/filetests/filetests/isa/s390x/shift-rotate.clif b/cranelift/filetests/filetests/isa/s390x/shift-rotate.clif
index 044a454395b3..c11ea0659971 100644
--- a/cranelift/filetests/filetests/isa/s390x/shift-rotate.clif
+++ b/cranelift/filetests/filetests/isa/s390x/shift-rotate.clif
@@ -915,16 +915,14 @@ block0(v0: i32, v1: i32):
 
 ; VCode:
 ; block0:
-;   lgr %r5, %r3
-;   nill %r5, 31
-;   srlk %r2, %r2, 0(%r5)
+;   nill %r3, 31
+;   srlk %r2, %r2, 0(%r3)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r5, %r3
-;   nill %r5, 0x1f
-;   srlk %r2, %r2, 0(%r5)
+;   nill %r3, 0x1f
+;   srlk %r2, %r2, 0(%r3)
 ;   br %r14
 
 function %ushr_i32_imm(i32) -> i32 {
@@ -1230,16 +1228,14 @@ block0(v0: i32, v1: i32):
 
 ; VCode:
 ; block0:
-;   lgr %r5, %r3
-;   nill %r5, 31
-;   sllk %r2, %r2, 0(%r5)
+;   nill %r3, 31
+;   sllk %r2, %r2, 0(%r3)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r5, %r3
-;   nill %r5, 0x1f
-;   sllk %r2, %r2, 0(%r5)
+;   nill %r3, 0x1f
+;   sllk %r2, %r2, 0(%r3)
 ;   br %r14
 
 function %ishl_i32_imm(i32) -> i32 {
@@ -1289,16 +1285,14 @@ block0(v0: i16, v1: i16):
 
 ; VCode:
 ; block0:
-;   lgr %r5, %r3
-;   nill %r5, 15
-;   sllk %r2, %r2, 0(%r5)
+;   nill %r3, 15
+;   sllk %r2, %r2, 0(%r3)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r5, %r3
-;   nill %r5, 0xf
-;   sllk %r2, %r2, 0(%r5)
+;   nill %r3, 0xf
+;   sllk %r2, %r2, 0(%r3)
 ;   br %r14
 
 function %ishl_i16_imm(i16) -> i16 {
@@ -1348,16 +1342,14 @@ block0(v0: i8, v1: i8):
 
 ; VCode:
 ; block0:
-;   lgr %r5, %r3
-;   nill %r5, 7
-;   sllk %r2, %r2, 0(%r5)
+;   nill %r3, 7
+;   sllk %r2, %r2, 0(%r3)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r5, %r3
-;   nill %r5, 7
-;   sllk %r2, %r2, 0(%r5)
+;   nill %r3, 7
+;   sllk %r2, %r2, 0(%r3)
 ;   br %r14
 
 function %ishl_i8_imm(i8) -> i8 {
@@ -1537,16 +1529,14 @@ block0(v0: i32, v1: i32):
 
 ; VCode:
 ; block0:
-;   lgr %r5, %r3
-;   nill %r5, 31
-;   srak %r2, %r2, 0(%r5)
+;   nill %r3, 31
+;   srak %r2, %r2, 0(%r3)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lgr %r5, %r3
-;   nill %r5, 0x1f
-;   srak %r2, %r2, 0(%r5)
+;   nill %r3, 0x1f
+;   srak %r2, %r2, 0(%r3)
 ;   br %r14
 
 function %sshr_i32_imm(i32) -> i32 {
diff --git a/cranelift/filetests/filetests/isa/s390x/stack-limit.clif b/cranelift/filetests/filetests/isa/s390x/stack-limit.clif
index 0a2387b2fd6e..7b31db18f7ed 100644
--- a/cranelift/filetests/filetests/isa/s390x/stack-limit.clif
+++ b/cranelift/filetests/filetests/isa/s390x/stack-limit.clif
@@ -14,19 +14,6 @@ block0:
 ; block0: ; offset 0x0
 ;   br %r14
 
-function %stack_limit_leaf_zero(i64 stack_limit) {
-block0(v0: i64):
-    return
-}
-
-; VCode:
-; block0:
-;   br %r14
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   br %r14
-
 function %stack_limit_gv_leaf_zero(i64 vmctx) {
     gv0 = vmctx
     gv1 = load.i64 notrap aligned gv0
@@ -44,40 +31,6 @@ block0(v0: i64):
 ; block0: ; offset 0x0
 ;   br %r14
 
-function %stack_limit_call_zero(i64 stack_limit) {
-    fn0 = %foo()
-block0(v0: i64):
-    call fn0()
-    return
-}
-
-; VCode:
-;   clgrtle %r15, %r2
-;   stmg %r14, %r15, 112(%r15)
-;   aghi %r15, -160
-;   virtual_sp_offset_adjust 160
-; block0:
-;   bras %r1, 12 ; data %foo + 0 ; lg %r4, 0(%r1)
-;   basr %r14, %r4
-;   lmg %r14, %r15, 272(%r15)
-;   br %r14
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   clgrtle %r15, %r2 ; trap: stk_ovf
-;   stmg %r14, %r15, 0x70(%r15)
-;   aghi %r15, -0xa0
-; block1: ; offset 0xe
-;   bras %r1, 0x1a
-;   .byte 0x00, 0x00 ; reloc_external Abs8 %foo 0
-;   .byte 0x00, 0x00
-;   .byte 0x00, 0x00
-;   .byte 0x00, 0x00
-;   lg %r4, 0(%r1)
-;   basr %r14, %r4
-;   lmg %r14, %r15, 0x110(%r15)
-;   br %r14
-
 function %stack_limit_gv_call_zero(i64 vmctx) {
     gv0 = vmctx
     gv1 = load.i64 notrap aligned gv0
@@ -92,13 +45,13 @@ block0(v0: i64):
 ; VCode:
 ;   lg %r1, 0(%r2)
 ;   lg %r1, 4(%r1)
+;   la %r1, 160(%r1)
 ;   clgrtle %r15, %r1
 ;   stmg %r14, %r15, 112(%r15)
 ;   aghi %r15, -160
-;   virtual_sp_offset_adjust 160
 ; block0:
-;   bras %r1, 12 ; data %foo + 0 ; lg %r4, 0(%r1)
-;   basr %r14, %r4
+;   bras %r1, 12 ; data %foo + 0 ; lg %r2, 0(%r1)
+;   basr %r14, %r2
 ;   lmg %r14, %r15, 272(%r15)
 ;   br %r14
 ;
@@ -106,95 +59,21 @@ block0(v0: i64):
 ; block0: ; offset 0x0
 ;   lg %r1, 0(%r2)
 ;   lg %r1, 4(%r1)
+;   la %r1, 0xa0(%r1)
 ;   clgrtle %r15, %r1 ; trap: stk_ovf
 ;   stmg %r14, %r15, 0x70(%r15)
 ;   aghi %r15, -0xa0
-; block1: ; offset 0x1a
-;   bras %r1, 0x26
+; block1: ; offset 0x1e
+;   bras %r1, 0x2a
 ;   .byte 0x00, 0x00 ; reloc_external Abs8 %foo 0
 ;   .byte 0x00, 0x00
 ;   .byte 0x00, 0x00
 ;   .byte 0x00, 0x00
-;   lg %r4, 0(%r1)
-;   basr %r14, %r4
+;   lg %r2, 0(%r1)
+;   basr %r14, %r2
 ;   lmg %r14, %r15, 0x110(%r15)
 ;   br %r14
 
-function %stack_limit(i64 stack_limit) {
-    ss0 = explicit_slot 168
-block0(v0: i64):
-    return
-}
-
-; VCode:
-;   la %r1, 168(%r2)
-;   clgrtle %r15, %r1
-;   aghi %r15, -168
-; block0:
-;   aghi %r15, 168
-;   br %r14
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   la %r1, 0xa8(%r2)
-;   clgrtle %r15, %r1 ; trap: stk_ovf
-;   aghi %r15, -0xa8
-; block1: ; offset 0xc
-;   aghi %r15, 0xa8
-;   br %r14
-
-function %large_stack_limit(i64 stack_limit) {
-    ss0 = explicit_slot 400000
-block0(v0: i64):
-    return
-}
-
-; VCode:
-;   clgrtle %r15, %r2
-;   lay %r1, 400000(%r2)
-;   clgrtle %r15, %r1
-;   agfi %r15, -400000
-; block0:
-;   agfi %r15, 400000
-;   br %r14
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   clgrtle %r15, %r2 ; trap: stk_ovf
-;   lay %r1, 0x61a80(%r2)
-;   clgrtle %r15, %r1 ; trap: stk_ovf
-;   agfi %r15, -0x61a80
-; block1: ; offset 0x14
-;   agfi %r15, 0x61a80
-;   br %r14
-
-function %huge_stack_limit(i64 stack_limit) {
-    ss0 = explicit_slot 4000000
-block0(v0: i64):
-    return
-}
-
-; VCode:
-;   clgrtle %r15, %r2
-;   lgr %r1, %r2
-;   algfi %r1, 4000000
-;   clgrtle %r15, %r1
-;   agfi %r15, -4000000
-; block0:
-;   agfi %r15, 4000000
-;   br %r14
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   clgrtle %r15, %r2 ; trap: stk_ovf
-;   lgr %r1, %r2
-;   algfi %r1, 0x3d0900
-;   clgrtle %r15, %r1 ; trap: stk_ovf
-;   agfi %r15, -0x3d0900
-; block1: ; offset 0x18
-;   agfi %r15, 0x3d0900
-;   br %r14
-
 function %limit_preamble(i64 vmctx) {
     gv0 = vmctx
     gv1 = load.i64 notrap aligned gv0
diff --git a/cranelift/filetests/filetests/isa/s390x/store-little.clif b/cranelift/filetests/filetests/isa/s390x/store-little.clif
index b50095dda8a6..72ae91940ba0 100644
--- a/cranelift/filetests/filetests/isa/s390x/store-little.clif
+++ b/cranelift/filetests/filetests/isa/s390x/store-little.clif
@@ -14,7 +14,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   strvg %r2, 0(%r3)
+;   strvg %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %store_i64_sym(i64) {
@@ -33,7 +33,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   larl %r1, 0 ; reloc_external PCRel32Dbl %sym 2
-;   strvg %r2, 0(%r1)
+;   strvg %r2, 0(%r1) ; trap: heap_oob
 ;   br %r14
 
 function %store_imm_i64(i64) {
@@ -52,7 +52,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   lghi %r4, 0x3039
-;   strvg %r4, 0(%r2)
+;   strvg %r4, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %istore8_i64(i64, i64) {
@@ -68,7 +68,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stc %r2, 0(%r3)
+;   stc %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %istore8_imm_i64(i64) {
@@ -85,7 +85,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mvi 0(%r2), 0x7b
+;   mvi 0(%r2), 0x7b ; trap: heap_oob
 ;   br %r14
 
 function %istore16_i64(i64, i64) {
@@ -101,7 +101,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   strvh %r2, 0(%r3)
+;   strvh %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %istore16_i64_sym(i64) {
@@ -120,7 +120,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   larl %r1, 0 ; reloc_external PCRel32Dbl %sym 2
-;   strvh %r2, 0(%r1)
+;   strvh %r2, 0(%r1) ; trap: heap_oob
 ;   br %r14
 
 function %istore16_imm_i64(i64) {
@@ -137,7 +137,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mvhhi 0(%r2), 0x3930
+;   mvhhi 0(%r2), 0x3930 ; trap: heap_oob
 ;   br %r14
 
 function %istore32_i64(i64, i64) {
@@ -153,7 +153,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   strv %r2, 0(%r3)
+;   strv %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %istore32_i64_sym(i64) {
@@ -172,7 +172,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   larl %r1, 0 ; reloc_external PCRel32Dbl %sym 2
-;   strv %r2, 0(%r1)
+;   strv %r2, 0(%r1) ; trap: heap_oob
 ;   br %r14
 
 function %istore32_imm_i64(i64) {
@@ -191,7 +191,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   lghi %r4, 0x3039
-;   strv %r4, 0(%r2)
+;   strv %r4, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_i32(i32, i64) {
@@ -207,7 +207,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   strv %r2, 0(%r3)
+;   strv %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %store_i32_sym(i32) {
@@ -226,7 +226,7 @@ block0(v0: i32):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   larl %r1, 0 ; reloc_external PCRel32Dbl %sym 2
-;   strv %r2, 0(%r1)
+;   strv %r2, 0(%r1) ; trap: heap_oob
 ;   br %r14
 
 function %store_imm_i32(i64) {
@@ -245,7 +245,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   lhi %r4, 0x3039
-;   strv %r4, 0(%r2)
+;   strv %r4, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %istore8_i32(i32, i64) {
@@ -261,7 +261,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stc %r2, 0(%r3)
+;   stc %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %istore8_imm_i32(i64) {
@@ -278,7 +278,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mvi 0(%r2), 0x7b
+;   mvi 0(%r2), 0x7b ; trap: heap_oob
 ;   br %r14
 
 function %istore16_i32(i32, i64) {
@@ -294,7 +294,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   strvh %r2, 0(%r3)
+;   strvh %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %istore16_i32_sym(i32) {
@@ -313,7 +313,7 @@ block0(v0: i32):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   larl %r1, 0 ; reloc_external PCRel32Dbl %sym 2
-;   strvh %r2, 0(%r1)
+;   strvh %r2, 0(%r1) ; trap: heap_oob
 ;   br %r14
 
 function %istore16_imm_i32(i64) {
@@ -330,7 +330,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mvhhi 0(%r2), 0x3930
+;   mvhhi 0(%r2), 0x3930 ; trap: heap_oob
 ;   br %r14
 
 function %store_i16(i16, i64) {
@@ -346,7 +346,7 @@ block0(v0: i16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   strvh %r2, 0(%r3)
+;   strvh %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %store_i16_sym(i16) {
@@ -365,7 +365,7 @@ block0(v0: i16):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   larl %r1, 0 ; reloc_external PCRel32Dbl %sym 2
-;   strvh %r2, 0(%r1)
+;   strvh %r2, 0(%r1) ; trap: heap_oob
 ;   br %r14
 
 function %store_imm_i16(i64) {
@@ -382,7 +382,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mvhhi 0(%r2), 0x3930
+;   mvhhi 0(%r2), 0x3930 ; trap: heap_oob
 ;   br %r14
 
 function %istore8_i16(i16, i64) {
@@ -398,7 +398,7 @@ block0(v0: i16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stc %r2, 0(%r3)
+;   stc %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %istore8_imm_i16(i64) {
@@ -415,7 +415,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mvi 0(%r2), 0x7b
+;   mvi 0(%r2), 0x7b ; trap: heap_oob
 ;   br %r14
 
 function %store_i8(i8, i64) {
@@ -431,7 +431,7 @@ block0(v0: i8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stc %r2, 0(%r3)
+;   stc %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %store_i8_off(i8, i64) {
@@ -447,7 +447,7 @@ block0(v0: i8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stcy %r2, 0x1000(%r3)
+;   stcy %r2, 0x1000(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %store_imm_i8(i64) {
@@ -464,7 +464,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mvi 0(%r2), 0x7b
+;   mvi 0(%r2), 0x7b ; trap: heap_oob
 ;   br %r14
 
 function %store_imm_i8_off(i64) {
@@ -481,6 +481,6 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mviy 0x1000(%r2), 0x7b
+;   mviy 0x1000(%r2), 0x7b ; trap: heap_oob
 ;   br %r14
 
diff --git a/cranelift/filetests/filetests/isa/s390x/store.clif b/cranelift/filetests/filetests/isa/s390x/store.clif
index 6526d4e8608e..31e6f540b5ee 100644
--- a/cranelift/filetests/filetests/isa/s390x/store.clif
+++ b/cranelift/filetests/filetests/isa/s390x/store.clif
@@ -14,7 +14,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stg %r2, 0(%r3)
+;   stg %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %store_i64_sym(i64) {
@@ -32,7 +32,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stgrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   stgrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   br %r14
 
 function %store_imm_i64(i64) {
@@ -49,7 +49,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mvghi 0(%r2), 0x3039
+;   mvghi 0(%r2), 0x3039 ; trap: heap_oob
 ;   br %r14
 
 function %istore8_i64(i64, i64) {
@@ -65,7 +65,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stc %r2, 0(%r3)
+;   stc %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %istore8_imm_i64(i64) {
@@ -82,7 +82,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mvi 0(%r2), 0x7b
+;   mvi 0(%r2), 0x7b ; trap: heap_oob
 ;   br %r14
 
 function %istore16_i64(i64, i64) {
@@ -98,7 +98,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sth %r2, 0(%r3)
+;   sth %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %istore16_i64_sym(i64) {
@@ -116,7 +116,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sthrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   sthrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   br %r14
 
 function %istore16_imm_i64(i64) {
@@ -133,7 +133,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mvhhi 0(%r2), 0x3039
+;   mvhhi 0(%r2), 0x3039 ; trap: heap_oob
 ;   br %r14
 
 function %istore32_i64(i64, i64) {
@@ -149,7 +149,7 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   st %r2, 0(%r3)
+;   st %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %istore32_i64_sym(i64) {
@@ -167,7 +167,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   strl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   strl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   br %r14
 
 function %istore32_imm_i64(i64) {
@@ -184,7 +184,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mvhi 0(%r2), 0x3039
+;   mvhi 0(%r2), 0x3039 ; trap: heap_oob
 ;   br %r14
 
 function %store_i32(i32, i64) {
@@ -200,7 +200,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   st %r2, 0(%r3)
+;   st %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %store_i32_sym(i32) {
@@ -218,7 +218,7 @@ block0(v0: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   strl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   strl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   br %r14
 
 function %store_i32_off(i32, i64) {
@@ -234,7 +234,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sty %r2, 0x1000(%r3)
+;   sty %r2, 0x1000(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %store_imm_i32(i64) {
@@ -251,7 +251,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mvhi 0(%r2), 0x3039
+;   mvhi 0(%r2), 0x3039 ; trap: heap_oob
 ;   br %r14
 
 function %istore8_i32(i32, i64) {
@@ -267,7 +267,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stc %r2, 0(%r3)
+;   stc %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %istore8_imm_i32(i64) {
@@ -284,7 +284,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mvi 0(%r2), 0x7b
+;   mvi 0(%r2), 0x7b ; trap: heap_oob
 ;   br %r14
 
 function %istore16_i32(i32, i64) {
@@ -300,7 +300,7 @@ block0(v0: i32, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sth %r2, 0(%r3)
+;   sth %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %istore16_i32_sym(i32) {
@@ -318,7 +318,7 @@ block0(v0: i32):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sthrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   sthrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   br %r14
 
 function %istore16_imm_i32(i64) {
@@ -335,7 +335,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mvhhi 0(%r2), 0x3039
+;   mvhhi 0(%r2), 0x3039 ; trap: heap_oob
 ;   br %r14
 
 function %store_i16(i16, i64) {
@@ -351,7 +351,7 @@ block0(v0: i16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sth %r2, 0(%r3)
+;   sth %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %store_i16_sym(i16) {
@@ -369,7 +369,7 @@ block0(v0: i16):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sthrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2
+;   sthrl %r2, 0 ; reloc_external PCRel32Dbl %sym 2 ; trap: heap_oob
 ;   br %r14
 
 function %store_i16_off(i16, i64) {
@@ -385,7 +385,7 @@ block0(v0: i16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   sthy %r2, 0x1000(%r3)
+;   sthy %r2, 0x1000(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %store_imm_i16(i64) {
@@ -402,7 +402,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mvhhi 0(%r2), 0x3039
+;   mvhhi 0(%r2), 0x3039 ; trap: heap_oob
 ;   br %r14
 
 function %istore8_i16(i16, i64) {
@@ -418,7 +418,7 @@ block0(v0: i16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stc %r2, 0(%r3)
+;   stc %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %istore8_imm_i16(i64) {
@@ -435,7 +435,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mvi 0(%r2), 0x7b
+;   mvi 0(%r2), 0x7b ; trap: heap_oob
 ;   br %r14
 
 function %store_i8(i8, i64) {
@@ -451,7 +451,7 @@ block0(v0: i8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stc %r2, 0(%r3)
+;   stc %r2, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %store_i8_off(i8, i64) {
@@ -467,7 +467,7 @@ block0(v0: i8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stcy %r2, 0x1000(%r3)
+;   stcy %r2, 0x1000(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %store_imm_i8(i64) {
@@ -484,7 +484,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mvi 0(%r2), 0x7b
+;   mvi 0(%r2), 0x7b ; trap: heap_oob
 ;   br %r14
 
 function %store_imm_i8_off(i64) {
@@ -501,6 +501,6 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   mviy 0x1000(%r2), 0x7b
+;   mviy 0x1000(%r2), 0x7b ; trap: heap_oob
 ;   br %r14
 
diff --git a/cranelift/filetests/filetests/isa/s390x/struct-arg.clif b/cranelift/filetests/filetests/isa/s390x/struct-arg.clif
index 95d7ed465584..b7b8f20974d1 100644
--- a/cranelift/filetests/filetests/isa/s390x/struct-arg.clif
+++ b/cranelift/filetests/filetests/isa/s390x/struct-arg.clif
@@ -14,7 +14,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llc %r2, 0(%r2)
+;   llc %r2, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function u0:1(i64 sarg(64), i64) -> i8 system_v {
@@ -34,8 +34,8 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   llc %r3, 0(%r3)
-;   llc %r4, 0(%r2)
+;   llc %r3, 0(%r3) ; trap: heap_oob
+;   llc %r4, 0(%r2) ; trap: heap_oob
 ;   ark %r2, %r3, %r4
 ;   br %r14
 
@@ -50,7 +50,6 @@ block0(v0: i64):
 ; VCode:
 ;   stmg %r14, %r15, 112(%r15)
 ;   aghi %r15, -224
-;   virtual_sp_offset_adjust 224
 ; block0:
 ;   mvc 160(63,%r15), 0(%r2)
 ;   la %r2, 160(%r15)
@@ -80,7 +79,6 @@ block0(v0: i64, v1: i64):
 ; VCode:
 ;   stmg %r14, %r15, 112(%r15)
 ;   aghi %r15, -224
-;   virtual_sp_offset_adjust 224
 ; block0:
 ;   mvc 160(63,%r15), 0(%r3)
 ;   la %r3, 160(%r15)
@@ -118,8 +116,8 @@ block0(v0: i64, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   lgr %r5, %r3
-;   llc %r3, 0(%r2)
-;   llc %r4, 0(%r5)
+;   llc %r3, 0(%r2) ; trap: heap_oob
+;   llc %r4, 0(%r5) ; trap: heap_oob
 ;   ark %r2, %r3, %r4
 ;   br %r14
 
@@ -134,7 +132,6 @@ block0(v0: i64, v1: i64, v2: i64):
 ; VCode:
 ;   stmg %r14, %r15, 112(%r15)
 ;   aghi %r15, -480
-;   virtual_sp_offset_adjust 480
 ; block0:
 ;   mvc 160(255,%r15), 0(%r3)
 ;   mvc 416(63,%r15), 0(%r4)
@@ -166,42 +163,41 @@ block0(v0: i64, v1: i64, v2: i64):
 }
 
 ; VCode:
-;   stmg %r7, %r15, 56(%r15)
+;   stmg %r8, %r15, 64(%r15)
 ;   aghi %r15, -1248
-;   virtual_sp_offset_adjust 1248
 ; block0:
-;   lgr %r7, %r2
-;   lgr %r9, %r4
+;   lgr %r8, %r2
+;   lgr %r10, %r4
 ;   la %r2, 160(%r15)
 ;   la %r3, 0(%r3)
 ;   lghi %r4, 1024
 ;   brasl %r14, %Memcpy
-;   lgr %r4, %r9
+;   lgr %r4, %r10
 ;   mvc 1184(63,%r15), 0(%r4)
 ;   la %r3, 160(%r15)
 ;   la %r4, 1184(%r15)
-;   lgr %r2, %r7
+;   lgr %r2, %r8
 ;   brasl %r14, userextname0
-;   lmg %r7, %r15, 1304(%r15)
+;   lmg %r8, %r15, 1312(%r15)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   stmg %r7, %r15, 0x38(%r15)
+;   stmg %r8, %r15, 0x40(%r15)
 ;   aghi %r15, -0x4e0
 ; block1: ; offset 0xa
-;   lgr %r7, %r2
-;   lgr %r9, %r4
+;   lgr %r8, %r2
+;   lgr %r10, %r4
 ;   la %r2, 0xa0(%r15)
 ;   la %r3, 0(%r3)
 ;   lghi %r4, 0x400
 ;   brasl %r14, 0x1e ; reloc_external PLTRel32Dbl %Memcpy 2
-;   lgr %r4, %r9
+;   lgr %r4, %r10
 ;   mvc 0x4a0(0x40, %r15), 0(%r4)
 ;   la %r3, 0xa0(%r15)
 ;   la %r4, 0x4a0(%r15)
-;   lgr %r2, %r7
+;   lgr %r2, %r8
 ;   brasl %r14, 0x3a ; reloc_external PLTRel32Dbl u0:0 2
-;   lmg %r7, %r15, 0x518(%r15)
+;   lmg %r8, %r15, 0x520(%r15)
 ;   br %r14
 
diff --git a/cranelift/filetests/filetests/isa/s390x/tls_elf.clif b/cranelift/filetests/filetests/isa/s390x/tls_elf.clif
index 0436b892be81..250f1c50c1c7 100644
--- a/cranelift/filetests/filetests/isa/s390x/tls_elf.clif
+++ b/cranelift/filetests/filetests/isa/s390x/tls_elf.clif
@@ -13,15 +13,14 @@ block0(v0: i32):
 ; VCode:
 ;   stmg %r12, %r15, 96(%r15)
 ;   aghi %r15, -160
-;   virtual_sp_offset_adjust 160
 ; block0:
 ;   larl %r12, %ElfGlobalOffsetTable + 0
 ;   bras %r1, 12 ; data userextname0@tlsgd ; lg %r2, 0(%r1)
 ;   brasl %r14, %ElfTlsGetOffset:tls_gdcall:userextname0
-;   ear %r3, %a0
-;   sllg %r5, %r3, 32
-;   ear %r5, %a1
-;   agr %r2, %r5
+;   ear %r4, %a0
+;   sllg %r3, %r4, 32
+;   ear %r3, %a1
+;   agr %r2, %r3
 ;   lmg %r12, %r15, 256(%r15)
 ;   br %r14
 ;
@@ -37,11 +36,11 @@ block0(v0: i32):
 ;   .byte 0x00, 0x00
 ;   .byte 0x00, 0x00
 ;   lg %r2, 0(%r1)
-;   brasl %r14, 0x22 ; reloc_external TlsGdCall u1:0 0
-;   ear %r3, %a0
-;   sllg %r5, %r3, 0x20
-;   ear %r5, %a1
-;   agr %r2, %r5
+;   brasl %r14, 0x22 ; reloc_external PLTRel32Dbl %ElfTlsGetOffset 2 ; reloc_external TlsGdCall u1:0 0
+;   ear %r4, %a0
+;   sllg %r3, %r4, 0x20
+;   ear %r3, %a1
+;   agr %r2, %r3
 ;   lmg %r12, %r15, 0x100(%r15)
 ;   br %r14
 
diff --git a/cranelift/filetests/filetests/isa/s390x/traps.clif b/cranelift/filetests/filetests/isa/s390x/traps.clif
index f231f085107f..54a071823063 100644
--- a/cranelift/filetests/filetests/isa/s390x/traps.clif
+++ b/cranelift/filetests/filetests/isa/s390x/traps.clif
@@ -2,7 +2,7 @@ test compile precise-output
 target s390x
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; TRAP/RESUMABLE_TRAP
+;; TRAP
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 function %trap() {
@@ -18,19 +18,6 @@ block0:
 ; block0: ; offset 0x0
 ;   .byte 0x00, 0x00 ; trap: user0
 
-function %resumable_trap() {
-block0:
-  trap user0
-}
-
-; VCode:
-; block0:
-;   .word 0x0000 # trap=user0
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   .byte 0x00, 0x00 ; trap: user0
-
 function %trapz(i64) {
 block0(v0: i64):
   v1 = iconst.i64 42
@@ -83,32 +70,6 @@ block0(v0: i64):
 ; block2: ; offset 0xe
 ;   .byte 0x00, 0x00 ; trap: user0
 
-function %resumable_trapnz(i64) {
-block0(v0: i64):
-  v1 = iconst.i64 42
-  v2 = icmp eq v0, v1
-  trapnz v2, user0
-  return
-}
-
-; VCode:
-; block0:
-;   clgfi %r2, 42
-;   jge label2 ; jg label1
-; block1:
-;   br %r14
-; block2:
-;   .word 0x0000 # trap=user0
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   clgfi %r2, 0x2a
-;   jge 0xe
-; block1: ; offset 0xc
-;   br %r14
-; block2: ; offset 0xe
-;   .byte 0x00, 0x00 ; trap: user0
-
 function %h() {
 block0:
   debugtrap
@@ -124,4 +85,3 @@ block0:
 ; block0: ; offset 0x0
 ;   .byte 0x00, 0x01
 ;   br %r14
-
diff --git a/cranelift/filetests/filetests/isa/s390x/user_stack_maps.clif b/cranelift/filetests/filetests/isa/s390x/user_stack_maps.clif
new file mode 100644
index 000000000000..053dde2c7217
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/s390x/user_stack_maps.clif
@@ -0,0 +1,215 @@
+test compile precise-output
+set unwind_info=false
+set enable_probestack=false
+target s390x
+
+function %foo() system_v {
+    ss0 = explicit_slot 12, align = 4
+    sig0 = (i32) system_v
+    fn0 = colocated u0:0 sig0
+
+block0:
+    v0 = iconst.i32 0
+    v1 = iconst.i32 1
+    v2 = iconst.i32 2
+    v3 = iconst.i32 3
+
+    stack_store v0, ss0
+    stack_store v1, ss0+4
+    stack_store v2, ss0+8
+    call fn0(v0), stack_map=[i32 @ ss0+0, i32 @ ss0+4, i32 @ ss0+8]
+
+    stack_store v1, ss0
+    stack_store v2, ss0+4
+    call fn0(v0), stack_map=[i32 @ ss0+0, i32 @ ss0+4]
+
+    stack_store v2, ss0
+    call fn0(v1), stack_map=[i32 @ ss0+0]
+
+    call fn0(v2)
+
+    return
+}
+
+; VCode:
+;   stmg %r6, %r15, 48(%r15)
+;   aghi %r15, -176
+; block0:
+;   lhi %r8, 0
+;   lhi %r6, 1
+;   lhi %r7, 2
+;   la %r2, 160(%r15)
+;   mvhi 0(%r2), 0
+;   la %r3, 164(%r15)
+;   mvhi 0(%r3), 1
+;   la %r4, 168(%r15)
+;   mvhi 0(%r4), 2
+;   lgr %r2, %r8
+;   brasl %r14, userextname0
+;   ; UserStackMap { by_type: [(types::I32, CompoundBitSet {0, 4, 8})], sp_to_sized_stack_slots: None }
+;   la %r2, 160(%r15)
+;   mvhi 0(%r2), 1
+;   la %r3, 164(%r15)
+;   mvhi 0(%r3), 2
+;   lgr %r2, %r8
+;   brasl %r14, userextname0
+;   ; UserStackMap { by_type: [(types::I32, CompoundBitSet {0, 4})], sp_to_sized_stack_slots: None }
+;   la %r5, 160(%r15)
+;   mvhi 0(%r5), 2
+;   lgr %r2, %r6
+;   brasl %r14, userextname0
+;   ; UserStackMap { by_type: [(types::I32, CompoundBitSet {0})], sp_to_sized_stack_slots: None }
+;   lgr %r2, %r7
+;   brasl %r14, userextname0
+;   lmg %r6, %r15, 224(%r15)
+;   br %r14
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r6, %r15, 0x30(%r15)
+;   aghi %r15, -0xb0
+; block1: ; offset 0xa
+;   lhi %r8, 0
+;   lhi %r6, 1
+;   lhi %r7, 2
+;   la %r2, 0xa0(%r15)
+;   mvhi 0(%r2), 0
+;   la %r3, 0xa4(%r15)
+;   mvhi 0(%r3), 1
+;   la %r4, 0xa8(%r15)
+;   mvhi 0(%r4), 2
+;   lgr %r2, %r8
+;   brasl %r14, 0x38 ; reloc_external PLTRel32Dbl u0:0 2
+;   la %r2, 0xa0(%r15)
+;   mvhi 0(%r2), 1
+;   la %r3, 0xa4(%r15)
+;   mvhi 0(%r3), 2
+;   lgr %r2, %r8
+;   brasl %r14, 0x56 ; reloc_external PLTRel32Dbl u0:0 2
+;   la %r5, 0xa0(%r15)
+;   mvhi 0(%r5), 2
+;   lgr %r2, %r6
+;   brasl %r14, 0x6a ; reloc_external PLTRel32Dbl u0:0 2
+;   lgr %r2, %r7
+;   brasl %r14, 0x74 ; reloc_external PLTRel32Dbl u0:0 2
+;   lmg %r6, %r15, 0xe0(%r15)
+;   br %r14
+
+function %different_types(i8, i16, i32, i64, f32, f64) -> i8, i16, i32, i64, f32, f64 {
+    ss0 = explicit_slot 1
+    ss1 = explicit_slot 2, align = 2
+    ss2 = explicit_slot 8, align = 4
+    ss3 = explicit_slot 16, align = 8
+    ss4 = explicit_slot 48, align = 16
+    sig0 = () system_v
+    fn0 = colocated u0:0 sig0
+
+block0(v0: i8, v1: i16, v2: i32, v3: i64, v4: f32, v5: f64):
+    stack_store v0, ss0
+    stack_store v1, ss1
+    stack_store v2, ss2
+    stack_store v4, ss2+4
+    stack_store v3, ss3
+    stack_store v5, ss3+8
+    call fn0(), stack_map=[i8 @ ss0+0, i16 @ ss1+0, i32 @ ss2+0, f32 @ ss2+4, i64 @ ss3+0, f64 @ ss3+8]
+    return v0, v1, v2, v3, v4, v5
+}
+
+; VCode:
+;   stmg %r6, %r15, 48(%r15)
+;   aghi %r15, -352
+;   std %f8, 288(%r15)
+;   std %f9, 296(%r15)
+;   std %f10, 304(%r15)
+;   std %f11, 312(%r15)
+;   std %f12, 320(%r15)
+;   std %f13, 328(%r15)
+;   std %f14, 336(%r15)
+;   std %f15, 344(%r15)
+; block0:
+;   la %r9, 160(%r15)
+;   stc %r2, 0(%r9)
+;   lgr %r9, %r2
+;   la %r2, 168(%r15)
+;   sth %r3, 0(%r2)
+;   lgr %r6, %r3
+;   la %r2, 176(%r15)
+;   st %r4, 0(%r2)
+;   lgr %r11, %r4
+;   la %r2, 180(%r15)
+;   ste %f0, 0(%r2)
+;   vst %v0, 256(%r15)
+;   la %r2, 184(%r15)
+;   stg %r5, 0(%r2)
+;   lgr %r8, %r5
+;   la %r3, 192(%r15)
+;   std %f2, 0(%r3)
+;   vst %v2, 272(%r15)
+;   brasl %r14, userextname0
+;   ; UserStackMap { by_type: [(types::I8, CompoundBitSet {0}), (types::I16, CompoundBitSet {8}), (types::I32, CompoundBitSet {16}), (types::F32, CompoundBitSet {20}), (types::I64, CompoundBitSet {24}), (types::F64, CompoundBitSet {32})], sp_to_sized_stack_slots: None }
+;   lgr %r2, %r9
+;   lgr %r3, %r6
+;   lgr %r4, %r11
+;   lgr %r5, %r8
+;   vl %v0, 256(%r15)
+;   vl %v2, 272(%r15)
+;   ld %f8, 288(%r15)
+;   ld %f9, 296(%r15)
+;   ld %f10, 304(%r15)
+;   ld %f11, 312(%r15)
+;   ld %f12, 320(%r15)
+;   ld %f13, 328(%r15)
+;   ld %f14, 336(%r15)
+;   ld %f15, 344(%r15)
+;   lmg %r6, %r15, 400(%r15)
+;   br %r14
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r6, %r15, 0x30(%r15)
+;   aghi %r15, -0x160
+;   std %f8, 0x120(%r15)
+;   std %f9, 0x128(%r15)
+;   std %f10, 0x130(%r15)
+;   std %f11, 0x138(%r15)
+;   std %f12, 0x140(%r15)
+;   std %f13, 0x148(%r15)
+;   std %f14, 0x150(%r15)
+;   std %f15, 0x158(%r15)
+; block1: ; offset 0x2a
+;   la %r9, 0xa0(%r15)
+;   stc %r2, 0(%r9)
+;   lgr %r9, %r2
+;   la %r2, 0xa8(%r15)
+;   sth %r3, 0(%r2)
+;   lgr %r6, %r3
+;   la %r2, 0xb0(%r15)
+;   st %r4, 0(%r2)
+;   lgr %r11, %r4
+;   la %r2, 0xb4(%r15)
+;   ste %f0, 0(%r2)
+;   vst %v0, 0x100(%r15)
+;   la %r2, 0xb8(%r15)
+;   stg %r5, 0(%r2)
+;   lgr %r8, %r5
+;   la %r3, 0xc0(%r15)
+;   std %f2, 0(%r3)
+;   vst %v2, 0x110(%r15)
+;   brasl %r14, 0x78 ; reloc_external PLTRel32Dbl u0:0 2
+;   lgr %r2, %r9
+;   lgr %r3, %r6
+;   lgr %r4, %r11
+;   lgr %r5, %r8
+;   vl %v0, 0x100(%r15)
+;   vl %v2, 0x110(%r15)
+;   ld %f8, 0x120(%r15)
+;   ld %f9, 0x128(%r15)
+;   ld %f10, 0x130(%r15)
+;   ld %f11, 0x138(%r15)
+;   ld %f12, 0x140(%r15)
+;   ld %f13, 0x148(%r15)
+;   ld %f14, 0x150(%r15)
+;   ld %f15, 0x158(%r15)
+;   lmg %r6, %r15, 0x190(%r15)
+;   br %r14
+
diff --git a/cranelift/filetests/filetests/isa/s390x/vec-abi-128.clif b/cranelift/filetests/filetests/isa/s390x/vec-abi-128.clif
new file mode 100644
index 000000000000..978a582e710b
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/s390x/vec-abi-128.clif
@@ -0,0 +1,267 @@
+test compile precise-output
+target s390x
+
+function %caller_be_to_be(i128) -> i128 {
+    fn0 = %callee_be(i128) -> i128
+
+block0(v0: i128):
+    v1 = call fn0(v0)
+    return v1
+}
+
+; VCode:
+;   stmg %r6, %r15, 48(%r15)
+;   aghi %r15, -192
+; block0:
+;   lgr %r6, %r2
+;   vl %v1, 0(%r3)
+;   vst %v1, 160(%r15)
+;   la %r3, 160(%r15)
+;   la %r2, 176(%r15)
+;   bras %r1, 12 ; data %callee_be + 0 ; lg %r4, 0(%r1)
+;   basr %r14, %r4
+;   vl %v20, 176(%r15)
+;   lgr %r2, %r6
+;   vst %v20, 0(%r2)
+;   lmg %r6, %r15, 240(%r15)
+;   br %r14
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r6, %r15, 0x30(%r15)
+;   aghi %r15, -0xc0
+; block1: ; offset 0xa
+;   lgr %r6, %r2
+;   vl %v1, 0(%r3)
+;   vst %v1, 0xa0(%r15)
+;   la %r3, 0xa0(%r15)
+;   la %r2, 0xb0(%r15)
+;   bras %r1, 0x2e
+;   .byte 0x00, 0x00 ; reloc_external Abs8 %callee_be 0
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   lg %r4, 0(%r1)
+;   basr %r14, %r4
+;   vl %v20, 0xb0(%r15)
+;   lgr %r2, %r6
+;   vst %v20, 0(%r2)
+;   lmg %r6, %r15, 0xf0(%r15)
+;   br %r14
+
+function %caller_be_to_le(i128) -> i128 {
+    fn0 = %callee_le(i128) -> i128 tail
+
+block0(v0: i128):
+    v1 = call fn0(v0)
+    return v1
+}
+
+; VCode:
+;   stmg %r6, %r15, 48(%r15)
+;   aghi %r15, -240
+;   std %f8, 176(%r15)
+;   std %f9, 184(%r15)
+;   std %f10, 192(%r15)
+;   std %f11, 200(%r15)
+;   std %f12, 208(%r15)
+;   std %f13, 216(%r15)
+;   std %f14, 224(%r15)
+;   std %f15, 232(%r15)
+; block0:
+;   lgr %r8, %r2
+;   vl %v1, 0(%r3)
+;   aghi %r15, -176
+;   vst %v1, 160(%r15)
+;   la %r3, 160(%r15)
+;   la %r2, 336(%r15)
+;   bras %r1, 12 ; data %callee_le + 0 ; lg %r4, 0(%r1)
+;   basr %r14, %r4 ; callee_pop_size 176
+;   vl %v21, 160(%r15)
+;   lgr %r2, %r8
+;   vst %v21, 0(%r2)
+;   ld %f8, 176(%r15)
+;   ld %f9, 184(%r15)
+;   ld %f10, 192(%r15)
+;   ld %f11, 200(%r15)
+;   ld %f12, 208(%r15)
+;   ld %f13, 216(%r15)
+;   ld %f14, 224(%r15)
+;   ld %f15, 232(%r15)
+;   lmg %r6, %r15, 288(%r15)
+;   br %r14
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r6, %r15, 0x30(%r15)
+;   aghi %r15, -0xf0
+;   std %f8, 0xb0(%r15)
+;   std %f9, 0xb8(%r15)
+;   std %f10, 0xc0(%r15)
+;   std %f11, 0xc8(%r15)
+;   std %f12, 0xd0(%r15)
+;   std %f13, 0xd8(%r15)
+;   std %f14, 0xe0(%r15)
+;   std %f15, 0xe8(%r15)
+; block1: ; offset 0x2a
+;   lgr %r8, %r2
+;   vl %v1, 0(%r3)
+;   aghi %r15, -0xb0
+;   vst %v1, 0xa0(%r15)
+;   la %r3, 0xa0(%r15)
+;   la %r2, 0x150(%r15)
+;   bras %r1, 0x52
+;   .byte 0x00, 0x00 ; reloc_external Abs8 %callee_le 0
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   lg %r4, 0(%r1)
+;   basr %r14, %r4
+;   vl %v21, 0xa0(%r15)
+;   lgr %r2, %r8
+;   vst %v21, 0(%r2)
+;   ld %f8, 0xb0(%r15)
+;   ld %f9, 0xb8(%r15)
+;   ld %f10, 0xc0(%r15)
+;   ld %f11, 0xc8(%r15)
+;   ld %f12, 0xd0(%r15)
+;   ld %f13, 0xd8(%r15)
+;   ld %f14, 0xe0(%r15)
+;   ld %f15, 0xe8(%r15)
+;   lmg %r6, %r15, 0x120(%r15)
+;   br %r14
+
+function %caller_le_to_be(i128) -> i128 tail {
+    fn0 = %callee_be(i128) -> i128
+
+block0(v0: i128):
+    v1 = call fn0(v0)
+    return v1
+}
+
+; VCode:
+;   stmg %r14, %r15, 288(%r15)
+;   aghi %r15, -256
+;   std %f8, 192(%r15)
+;   std %f9, 200(%r15)
+;   std %f10, 208(%r15)
+;   std %f11, 216(%r15)
+;   std %f12, 224(%r15)
+;   std %f13, 232(%r15)
+;   std %f14, 240(%r15)
+;   std %f15, 248(%r15)
+; block0:
+;   lgr %r6, %r2
+;   vl %v1, 0(%r3)
+;   vst %v1, 160(%r15)
+;   la %r3, 160(%r15)
+;   la %r2, 176(%r15)
+;   bras %r1, 12 ; data %callee_be + 0 ; lg %r5, 0(%r1)
+;   basr %r14, %r5
+;   vl %v20, 176(%r15)
+;   lgr %r2, %r6
+;   vst %v20, 0(%r2)
+;   ld %f8, 192(%r15)
+;   ld %f9, 200(%r15)
+;   ld %f10, 208(%r15)
+;   ld %f11, 216(%r15)
+;   ld %f12, 224(%r15)
+;   ld %f13, 232(%r15)
+;   ld %f14, 240(%r15)
+;   ld %f15, 248(%r15)
+;   aghi %r15, 432
+;   lmg %r14, %r14, 112(%r15)
+;   br %r14
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r14, %r15, 0x120(%r15)
+;   aghi %r15, -0x100
+;   std %f8, 0xc0(%r15)
+;   std %f9, 0xc8(%r15)
+;   std %f10, 0xd0(%r15)
+;   std %f11, 0xd8(%r15)
+;   std %f12, 0xe0(%r15)
+;   std %f13, 0xe8(%r15)
+;   std %f14, 0xf0(%r15)
+;   std %f15, 0xf8(%r15)
+; block1: ; offset 0x2a
+;   lgr %r6, %r2
+;   vl %v1, 0(%r3)
+;   vst %v1, 0xa0(%r15)
+;   la %r3, 0xa0(%r15)
+;   la %r2, 0xb0(%r15)
+;   bras %r1, 0x4e
+;   .byte 0x00, 0x00 ; reloc_external Abs8 %callee_be 0
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   lg %r5, 0(%r1)
+;   basr %r14, %r5
+;   vl %v20, 0xb0(%r15)
+;   lgr %r2, %r6
+;   vst %v20, 0(%r2)
+;   ld %f8, 0xc0(%r15)
+;   ld %f9, 0xc8(%r15)
+;   ld %f10, 0xd0(%r15)
+;   ld %f11, 0xd8(%r15)
+;   ld %f12, 0xe0(%r15)
+;   ld %f13, 0xe8(%r15)
+;   ld %f14, 0xf0(%r15)
+;   ld %f15, 0xf8(%r15)
+;   aghi %r15, 0x1b0
+;   lmg %r14, %r14, 0x70(%r15)
+;   br %r14
+
+function %caller_le_to_le(i128) -> i128 tail {
+    fn0 = %callee_le(i128) -> i128 tail
+
+block0(v0: i128):
+    v1 = call fn0(v0)
+    return v1
+}
+
+; VCode:
+;   stmg %r9, %r15, 248(%r15)
+;   aghi %r15, -176
+; block0:
+;   lgr %r9, %r2
+;   vl %v1, 0(%r3)
+;   aghi %r15, -176
+;   vst %v1, 160(%r15)
+;   la %r3, 160(%r15)
+;   la %r2, 336(%r15)
+;   bras %r1, 12 ; data %callee_le + 0 ; lg %r6, 0(%r1)
+;   basr %r14, %r6 ; callee_pop_size 176
+;   vl %v21, 160(%r15)
+;   lgr %r2, %r9
+;   vst %v21, 0(%r2)
+;   aghi %r15, 352
+;   lmg %r9, %r14, 72(%r15)
+;   br %r14
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   stmg %r9, %r15, 0xf8(%r15)
+;   aghi %r15, -0xb0
+; block1: ; offset 0xa
+;   lgr %r9, %r2
+;   vl %v1, 0(%r3)
+;   aghi %r15, -0xb0
+;   vst %v1, 0xa0(%r15)
+;   la %r3, 0xa0(%r15)
+;   la %r2, 0x150(%r15)
+;   bras %r1, 0x32
+;   .byte 0x00, 0x00 ; reloc_external Abs8 %callee_le 0
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   .byte 0x00, 0x00
+;   lg %r6, 0(%r1)
+;   basr %r14, %r6
+;   vl %v21, 0xa0(%r15)
+;   lgr %r2, %r9
+;   vst %v21, 0(%r2)
+;   aghi %r15, 0x160
+;   lmg %r9, %r14, 0x48(%r15)
+;   br %r14
+
diff --git a/cranelift/filetests/filetests/isa/s390x/vec-abi.clif b/cranelift/filetests/filetests/isa/s390x/vec-abi.clif
index 76130443c40e..7b98e45c342b 100644
--- a/cranelift/filetests/filetests/isa/s390x/vec-abi.clif
+++ b/cranelift/filetests/filetests/isa/s390x/vec-abi.clif
@@ -1,247 +1,387 @@
 test compile precise-output
 target s390x
 
-function %caller_be_to_be(i64x2, i32x4, i16x8, i8x16) -> i32x4 {
-    fn0 = %callee_be(i64x2, i32x4, i16x8, i8x16) -> i32x4
+function %caller_be_to_be(i64x2, i32x4, i16x8, i8x16, i64x2, i32x4, i16x8, i8x16, i64x2, i32x4, i16x8, i8x16) -> i32x4 {
+    fn0 = %callee_be(i64x2, i32x4, i16x8, i8x16, i64x2, i32x4, i16x8, i8x16, i64x2, i32x4, i16x8, i8x16) -> i32x4
 
-block0(v0: i64x2, v1: i32x4, v2: i16x8, v3: i8x16):
-    v4 = call fn0(v0, v1, v2, v3)
-    return v4
+block0(v0: i64x2, v1: i32x4, v2: i16x8, v3: i8x16, v4: i64x2, v5: i32x4, v6: i16x8, v7: i8x16, v8: i64x2, v9: i32x4, v10: i16x8, v11: i8x16):
+    v12 = call fn0(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)
+    return v12
 }
 
 ; VCode:
 ;   stmg %r14, %r15, 112(%r15)
-;   aghi %r15, -160
-;   virtual_sp_offset_adjust 160
+;   aghi %r15, -224
 ; block0:
+;   vl %v17, 384(%r15)
+;   vl %v19, 400(%r15)
+;   vl %v21, 416(%r15)
+;   vl %v23, 432(%r15)
+;   vst %v17, 160(%r15)
+;   vst %v19, 176(%r15)
+;   vst %v21, 192(%r15)
+;   vst %v23, 208(%r15)
 ;   bras %r1, 12 ; data %callee_be + 0 ; lg %r4, 0(%r1)
 ;   basr %r14, %r4
-;   lmg %r14, %r15, 272(%r15)
+;   lmg %r14, %r15, 336(%r15)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   stmg %r14, %r15, 0x70(%r15)
-;   aghi %r15, -0xa0
+;   aghi %r15, -0xe0
 ; block1: ; offset 0xa
-;   bras %r1, 0x16
+;   vl %v17, 0x180(%r15)
+;   vl %v19, 0x190(%r15)
+;   vl %v21, 0x1a0(%r15)
+;   vl %v23, 0x1b0(%r15)
+;   vst %v17, 0xa0(%r15)
+;   vst %v19, 0xb0(%r15)
+;   vst %v21, 0xc0(%r15)
+;   vst %v23, 0xd0(%r15)
+;   bras %r1, 0x46
 ;   .byte 0x00, 0x00 ; reloc_external Abs8 %callee_be 0
 ;   .byte 0x00, 0x00
 ;   .byte 0x00, 0x00
 ;   .byte 0x00, 0x00
 ;   lg %r4, 0(%r1)
 ;   basr %r14, %r4
-;   lmg %r14, %r15, 0x110(%r15)
+;   lmg %r14, %r15, 0x150(%r15)
 ;   br %r14
 
-function %caller_be_to_le(i64x2, i32x4, i16x8, i8x16) -> i32x4 {
-    fn0 = %callee_le(i64x2, i32x4, i16x8, i8x16) -> i32x4 wasmtime_system_v
+function %caller_be_to_le(i64x2, i32x4, i16x8, i8x16, i64x2, i32x4, i16x8, i8x16, i64x2, i32x4, i16x8, i8x16) -> i32x4 {
+    fn0 = %callee_le(i64x2, i32x4, i16x8, i8x16, i64x2, i32x4, i16x8, i8x16, i64x2, i32x4, i16x8, i8x16) -> i32x4 wasmtime_system_v
 
-block0(v0: i64x2, v1: i32x4, v2: i16x8, v3: i8x16):
-    v4 = call fn0(v0, v1, v2, v3)
-    return v4
+block0(v0: i64x2, v1: i32x4, v2: i16x8, v3: i8x16, v4: i64x2, v5: i32x4, v6: i16x8, v7: i8x16, v8: i64x2, v9: i32x4, v10: i16x8, v11: i8x16):
+    v12 = call fn0(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)
+    return v12
 }
 
 ; VCode:
 ;   stmg %r14, %r15, 112(%r15)
-;   aghi %r15, -224
-;   virtual_sp_offset_adjust 160
-;   std %f8, 160(%r15)
-;   std %f9, 168(%r15)
-;   std %f10, 176(%r15)
-;   std %f11, 184(%r15)
-;   std %f12, 192(%r15)
-;   std %f13, 200(%r15)
-;   std %f14, 208(%r15)
-;   std %f15, 216(%r15)
+;   aghi %r15, -288
+;   std %f8, 224(%r15)
+;   std %f9, 232(%r15)
+;   std %f10, 240(%r15)
+;   std %f11, 248(%r15)
+;   std %f12, 256(%r15)
+;   std %f13, 264(%r15)
+;   std %f14, 272(%r15)
+;   std %f15, 280(%r15)
 ; block0:
+;   vl %v17, 448(%r15)
+;   vl %v19, 464(%r15)
+;   vl %v21, 480(%r15)
+;   vl %v23, 496(%r15)
 ;   vpdi %v24, %v24, %v24, 4
-;   vpdi %v7, %v25, %v25, 4
-;   verllg %v25, %v7, 32
-;   vpdi %v19, %v26, %v26, 4
-;   verllg %v21, %v19, 32
-;   verllf %v26, %v21, 16
-;   vpdi %v27, %v27, %v27, 4
-;   verllg %v27, %v27, 32
-;   verllf %v29, %v27, 16
-;   verllh %v27, %v29, 8
+;   vpdi %v0, %v25, %v25, 4
+;   verllg %v25, %v0, 32
+;   vpdi %v0, %v26, %v26, 4
+;   verllg %v1, %v0, 32
+;   verllf %v26, %v1, 16
+;   vpdi %v5, %v27, %v27, 4
+;   verllg %v7, %v5, 32
+;   verllf %v18, %v7, 16
+;   verllh %v27, %v18, 8
+;   vpdi %v28, %v28, %v28, 4
+;   vpdi %v29, %v29, %v29, 4
+;   verllg %v29, %v29, 32
+;   vpdi %v30, %v30, %v30, 4
+;   verllg %v30, %v30, 32
+;   verllf %v30, %v30, 16
+;   vpdi %v1, %v31, %v31, 4
+;   verllg %v3, %v1, 32
+;   verllf %v5, %v3, 16
+;   verllh %v31, %v5, 8
+;   vpdi %v17, %v17, %v17, 4
+;   vst %v17, 160(%r15)
+;   vpdi %v20, %v19, %v19, 4
+;   verllg %v22, %v20, 32
+;   vst %v22, 176(%r15)
+;   vpdi %v0, %v21, %v21, 4
+;   verllg %v0, %v0, 32
+;   verllf %v0, %v0, 16
+;   vst %v0, 192(%r15)
+;   vpdi %v0, %v23, %v23, 4
+;   verllg %v2, %v0, 32
+;   verllf %v4, %v2, 16
+;   verllh %v6, %v4, 8
+;   vst %v6, 208(%r15)
 ;   bras %r1, 12 ; data %callee_le + 0 ; lg %r4, 0(%r1)
 ;   basr %r14, %r4
-;   vpdi %v5, %v24, %v24, 4
-;   verllg %v24, %v5, 32
-;   ld %f8, 160(%r15)
-;   ld %f9, 168(%r15)
-;   ld %f10, 176(%r15)
-;   ld %f11, 184(%r15)
-;   ld %f12, 192(%r15)
-;   ld %f13, 200(%r15)
-;   ld %f14, 208(%r15)
-;   ld %f15, 216(%r15)
-;   lmg %r14, %r15, 336(%r15)
+;   vpdi %v21, %v24, %v24, 4
+;   verllg %v24, %v21, 32
+;   ld %f8, 224(%r15)
+;   ld %f9, 232(%r15)
+;   ld %f10, 240(%r15)
+;   ld %f11, 248(%r15)
+;   ld %f12, 256(%r15)
+;   ld %f13, 264(%r15)
+;   ld %f14, 272(%r15)
+;   ld %f15, 280(%r15)
+;   lmg %r14, %r15, 400(%r15)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   stmg %r14, %r15, 0x70(%r15)
-;   aghi %r15, -0xe0
-;   std %f8, 0xa0(%r15)
-;   std %f9, 0xa8(%r15)
-;   std %f10, 0xb0(%r15)
-;   std %f11, 0xb8(%r15)
-;   std %f12, 0xc0(%r15)
-;   std %f13, 0xc8(%r15)
-;   std %f14, 0xd0(%r15)
-;   std %f15, 0xd8(%r15)
+;   aghi %r15, -0x120
+;   std %f8, 0xe0(%r15)
+;   std %f9, 0xe8(%r15)
+;   std %f10, 0xf0(%r15)
+;   std %f11, 0xf8(%r15)
+;   std %f12, 0x100(%r15)
+;   std %f13, 0x108(%r15)
+;   std %f14, 0x110(%r15)
+;   std %f15, 0x118(%r15)
 ; block1: ; offset 0x2a
+;   vl %v17, 0x1c0(%r15)
+;   vl %v19, 0x1d0(%r15)
+;   vl %v21, 0x1e0(%r15)
+;   vl %v23, 0x1f0(%r15)
 ;   vpdi %v24, %v24, %v24, 4
-;   vpdi %v7, %v25, %v25, 4
-;   verllg %v25, %v7, 0x20
-;   vpdi %v19, %v26, %v26, 4
-;   verllg %v21, %v19, 0x20
-;   verllf %v26, %v21, 0x10
-;   vpdi %v27, %v27, %v27, 4
-;   verllg %v27, %v27, 0x20
-;   verllf %v29, %v27, 0x10
-;   verllh %v27, %v29, 8
-;   bras %r1, 0x72
+;   vpdi %v0, %v25, %v25, 4
+;   verllg %v25, %v0, 0x20
+;   vpdi %v0, %v26, %v26, 4
+;   verllg %v1, %v0, 0x20
+;   verllf %v26, %v1, 0x10
+;   vpdi %v5, %v27, %v27, 4
+;   verllg %v7, %v5, 0x20
+;   verllf %v18, %v7, 0x10
+;   verllh %v27, %v18, 8
+;   vpdi %v28, %v28, %v28, 4
+;   vpdi %v29, %v29, %v29, 4
+;   verllg %v29, %v29, 0x20
+;   vpdi %v30, %v30, %v30, 4
+;   verllg %v30, %v30, 0x20
+;   verllf %v30, %v30, 0x10
+;   vpdi %v1, %v31, %v31, 4
+;   verllg %v3, %v1, 0x20
+;   verllf %v5, %v3, 0x10
+;   verllh %v31, %v5, 8
+;   vpdi %v17, %v17, %v17, 4
+;   vst %v17, 0xa0(%r15)
+;   vpdi %v20, %v19, %v19, 4
+;   verllg %v22, %v20, 0x20
+;   vst %v22, 0xb0(%r15)
+;   vpdi %v0, %v21, %v21, 4
+;   verllg %v0, %v0, 0x20
+;   verllf %v0, %v0, 0x10
+;   vst %v0, 0xc0(%r15)
+;   vpdi %v0, %v23, %v23, 4
+;   verllg %v2, %v0, 0x20
+;   verllf %v4, %v2, 0x10
+;   verllh %v6, %v4, 8
+;   vst %v6, 0xd0(%r15)
+;   bras %r1, 0x11a
 ;   .byte 0x00, 0x00 ; reloc_external Abs8 %callee_le 0
 ;   .byte 0x00, 0x00
 ;   .byte 0x00, 0x00
 ;   .byte 0x00, 0x00
 ;   lg %r4, 0(%r1)
 ;   basr %r14, %r4
-;   vpdi %v5, %v24, %v24, 4
-;   verllg %v24, %v5, 0x20
-;   ld %f8, 0xa0(%r15)
-;   ld %f9, 0xa8(%r15)
-;   ld %f10, 0xb0(%r15)
-;   ld %f11, 0xb8(%r15)
-;   ld %f12, 0xc0(%r15)
-;   ld %f13, 0xc8(%r15)
-;   ld %f14, 0xd0(%r15)
-;   ld %f15, 0xd8(%r15)
-;   lmg %r14, %r15, 0x150(%r15)
+;   vpdi %v21, %v24, %v24, 4
+;   verllg %v24, %v21, 0x20
+;   ld %f8, 0xe0(%r15)
+;   ld %f9, 0xe8(%r15)
+;   ld %f10, 0xf0(%r15)
+;   ld %f11, 0xf8(%r15)
+;   ld %f12, 0x100(%r15)
+;   ld %f13, 0x108(%r15)
+;   ld %f14, 0x110(%r15)
+;   ld %f15, 0x118(%r15)
+;   lmg %r14, %r15, 0x190(%r15)
 ;   br %r14
 
-function %caller_le_to_be(i64x2, i32x4, i16x8, i8x16) -> i32x4 wasmtime_system_v {
-    fn0 = %callee_be(i64x2, i32x4, i16x8, i8x16) -> i32x4
+function %caller_le_to_be(i64x2, i32x4, i16x8, i8x16, i64x2, i32x4, i16x8, i8x16, i64x2, i32x4, i16x8, i8x16) -> i32x4 wasmtime_system_v {
+    fn0 = %callee_be(i64x2, i32x4, i16x8, i8x16, i64x2, i32x4, i16x8, i8x16, i64x2, i32x4, i16x8, i8x16) -> i32x4
 
-block0(v0: i64x2, v1: i32x4, v2: i16x8, v3: i8x16):
-    v4 = call fn0(v0, v1, v2, v3)
-    return v4
+block0(v0: i64x2, v1: i32x4, v2: i16x8, v3: i8x16, v4: i64x2, v5: i32x4, v6: i16x8, v7: i8x16, v8: i64x2, v9: i32x4, v10: i16x8, v11: i8x16):
+    v12 = call fn0(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)
+    return v12
 }
 
 ; VCode:
 ;   stmg %r14, %r15, 112(%r15)
-;   aghi %r15, -224
-;   virtual_sp_offset_adjust 160
-;   std %f8, 160(%r15)
-;   std %f9, 168(%r15)
-;   std %f10, 176(%r15)
-;   std %f11, 184(%r15)
-;   std %f12, 192(%r15)
-;   std %f13, 200(%r15)
-;   std %f14, 208(%r15)
-;   std %f15, 216(%r15)
+;   aghi %r15, -288
+;   std %f8, 224(%r15)
+;   std %f9, 232(%r15)
+;   std %f10, 240(%r15)
+;   std %f11, 248(%r15)
+;   std %f12, 256(%r15)
+;   std %f13, 264(%r15)
+;   std %f14, 272(%r15)
+;   std %f15, 280(%r15)
 ; block0:
+;   vl %v17, 448(%r15)
+;   vl %v19, 464(%r15)
+;   vl %v21, 480(%r15)
+;   vl %v23, 496(%r15)
 ;   vpdi %v24, %v24, %v24, 4
-;   vpdi %v7, %v25, %v25, 4
-;   verllg %v25, %v7, 32
-;   vpdi %v19, %v26, %v26, 4
-;   verllg %v21, %v19, 32
-;   verllf %v26, %v21, 16
-;   vpdi %v27, %v27, %v27, 4
-;   verllg %v27, %v27, 32
-;   verllf %v29, %v27, 16
-;   verllh %v27, %v29, 8
+;   vpdi %v0, %v25, %v25, 4
+;   verllg %v25, %v0, 32
+;   vpdi %v0, %v26, %v26, 4
+;   verllg %v1, %v0, 32
+;   verllf %v26, %v1, 16
+;   vpdi %v5, %v27, %v27, 4
+;   verllg %v7, %v5, 32
+;   verllf %v18, %v7, 16
+;   verllh %v27, %v18, 8
+;   vpdi %v28, %v28, %v28, 4
+;   vpdi %v29, %v29, %v29, 4
+;   verllg %v29, %v29, 32
+;   vpdi %v30, %v30, %v30, 4
+;   verllg %v30, %v30, 32
+;   verllf %v30, %v30, 16
+;   vpdi %v1, %v31, %v31, 4
+;   verllg %v3, %v1, 32
+;   verllf %v5, %v3, 16
+;   verllh %v31, %v5, 8
+;   vpdi %v17, %v17, %v17, 4
+;   vst %v17, 160(%r15)
+;   vpdi %v20, %v19, %v19, 4
+;   verllg %v22, %v20, 32
+;   vst %v22, 176(%r15)
+;   vpdi %v0, %v21, %v21, 4
+;   verllg %v0, %v0, 32
+;   verllf %v0, %v0, 16
+;   vst %v0, 192(%r15)
+;   vpdi %v0, %v23, %v23, 4
+;   verllg %v2, %v0, 32
+;   verllf %v4, %v2, 16
+;   verllh %v6, %v4, 8
+;   vst %v6, 208(%r15)
 ;   bras %r1, 12 ; data %callee_be + 0 ; lg %r4, 0(%r1)
 ;   basr %r14, %r4
-;   vpdi %v5, %v24, %v24, 4
-;   verllg %v24, %v5, 32
-;   ld %f8, 160(%r15)
-;   ld %f9, 168(%r15)
-;   ld %f10, 176(%r15)
-;   ld %f11, 184(%r15)
-;   ld %f12, 192(%r15)
-;   ld %f13, 200(%r15)
-;   ld %f14, 208(%r15)
-;   ld %f15, 216(%r15)
-;   lmg %r14, %r15, 336(%r15)
+;   vpdi %v21, %v24, %v24, 4
+;   verllg %v24, %v21, 32
+;   ld %f8, 224(%r15)
+;   ld %f9, 232(%r15)
+;   ld %f10, 240(%r15)
+;   ld %f11, 248(%r15)
+;   ld %f12, 256(%r15)
+;   ld %f13, 264(%r15)
+;   ld %f14, 272(%r15)
+;   ld %f15, 280(%r15)
+;   lmg %r14, %r15, 400(%r15)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   stmg %r14, %r15, 0x70(%r15)
-;   aghi %r15, -0xe0
-;   std %f8, 0xa0(%r15)
-;   std %f9, 0xa8(%r15)
-;   std %f10, 0xb0(%r15)
-;   std %f11, 0xb8(%r15)
-;   std %f12, 0xc0(%r15)
-;   std %f13, 0xc8(%r15)
-;   std %f14, 0xd0(%r15)
-;   std %f15, 0xd8(%r15)
+;   aghi %r15, -0x120
+;   std %f8, 0xe0(%r15)
+;   std %f9, 0xe8(%r15)
+;   std %f10, 0xf0(%r15)
+;   std %f11, 0xf8(%r15)
+;   std %f12, 0x100(%r15)
+;   std %f13, 0x108(%r15)
+;   std %f14, 0x110(%r15)
+;   std %f15, 0x118(%r15)
 ; block1: ; offset 0x2a
+;   vl %v17, 0x1c0(%r15)
+;   vl %v19, 0x1d0(%r15)
+;   vl %v21, 0x1e0(%r15)
+;   vl %v23, 0x1f0(%r15)
 ;   vpdi %v24, %v24, %v24, 4
-;   vpdi %v7, %v25, %v25, 4
-;   verllg %v25, %v7, 0x20
-;   vpdi %v19, %v26, %v26, 4
-;   verllg %v21, %v19, 0x20
-;   verllf %v26, %v21, 0x10
-;   vpdi %v27, %v27, %v27, 4
-;   verllg %v27, %v27, 0x20
-;   verllf %v29, %v27, 0x10
-;   verllh %v27, %v29, 8
-;   bras %r1, 0x72
+;   vpdi %v0, %v25, %v25, 4
+;   verllg %v25, %v0, 0x20
+;   vpdi %v0, %v26, %v26, 4
+;   verllg %v1, %v0, 0x20
+;   verllf %v26, %v1, 0x10
+;   vpdi %v5, %v27, %v27, 4
+;   verllg %v7, %v5, 0x20
+;   verllf %v18, %v7, 0x10
+;   verllh %v27, %v18, 8
+;   vpdi %v28, %v28, %v28, 4
+;   vpdi %v29, %v29, %v29, 4
+;   verllg %v29, %v29, 0x20
+;   vpdi %v30, %v30, %v30, 4
+;   verllg %v30, %v30, 0x20
+;   verllf %v30, %v30, 0x10
+;   vpdi %v1, %v31, %v31, 4
+;   verllg %v3, %v1, 0x20
+;   verllf %v5, %v3, 0x10
+;   verllh %v31, %v5, 8
+;   vpdi %v17, %v17, %v17, 4
+;   vst %v17, 0xa0(%r15)
+;   vpdi %v20, %v19, %v19, 4
+;   verllg %v22, %v20, 0x20
+;   vst %v22, 0xb0(%r15)
+;   vpdi %v0, %v21, %v21, 4
+;   verllg %v0, %v0, 0x20
+;   verllf %v0, %v0, 0x10
+;   vst %v0, 0xc0(%r15)
+;   vpdi %v0, %v23, %v23, 4
+;   verllg %v2, %v0, 0x20
+;   verllf %v4, %v2, 0x10
+;   verllh %v6, %v4, 8
+;   vst %v6, 0xd0(%r15)
+;   bras %r1, 0x11a
 ;   .byte 0x00, 0x00 ; reloc_external Abs8 %callee_be 0
 ;   .byte 0x00, 0x00
 ;   .byte 0x00, 0x00
 ;   .byte 0x00, 0x00
 ;   lg %r4, 0(%r1)
 ;   basr %r14, %r4
-;   vpdi %v5, %v24, %v24, 4
-;   verllg %v24, %v5, 0x20
-;   ld %f8, 0xa0(%r15)
-;   ld %f9, 0xa8(%r15)
-;   ld %f10, 0xb0(%r15)
-;   ld %f11, 0xb8(%r15)
-;   ld %f12, 0xc0(%r15)
-;   ld %f13, 0xc8(%r15)
-;   ld %f14, 0xd0(%r15)
-;   ld %f15, 0xd8(%r15)
-;   lmg %r14, %r15, 0x150(%r15)
+;   vpdi %v21, %v24, %v24, 4
+;   verllg %v24, %v21, 0x20
+;   ld %f8, 0xe0(%r15)
+;   ld %f9, 0xe8(%r15)
+;   ld %f10, 0xf0(%r15)
+;   ld %f11, 0xf8(%r15)
+;   ld %f12, 0x100(%r15)
+;   ld %f13, 0x108(%r15)
+;   ld %f14, 0x110(%r15)
+;   ld %f15, 0x118(%r15)
+;   lmg %r14, %r15, 0x190(%r15)
 ;   br %r14
 
-function %caller_le_to_le(i64x2, i32x4, i16x8, i8x16) -> i32x4 wasmtime_system_v {
-    fn0 = %callee_le(i64x2, i32x4, i16x8, i8x16) -> i32x4 wasmtime_system_v
+function %caller_le_to_le(i64x2, i32x4, i16x8, i8x16, i64x2, i32x4, i16x8, i8x16, i64x2, i32x4, i16x8, i8x16) -> i32x4 wasmtime_system_v {
+    fn0 = %callee_le(i64x2, i32x4, i16x8, i8x16, i64x2, i32x4, i16x8, i8x16, i64x2, i32x4, i16x8, i8x16) -> i32x4 wasmtime_system_v
 
-block0(v0: i64x2, v1: i32x4, v2: i16x8, v3: i8x16):
-    v4 = call fn0(v0, v1, v2, v3)
-    return v4
+block0(v0: i64x2, v1: i32x4, v2: i16x8, v3: i8x16, v4: i64x2, v5: i32x4, v6: i16x8, v7: i8x16, v8: i64x2, v9: i32x4, v10: i16x8, v11: i8x16):
+    v12 = call fn0(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)
+    return v12
 }
 
 ; VCode:
 ;   stmg %r14, %r15, 112(%r15)
-;   aghi %r15, -160
-;   virtual_sp_offset_adjust 160
+;   aghi %r15, -224
 ; block0:
+;   vl %v17, 384(%r15)
+;   vl %v19, 400(%r15)
+;   vl %v21, 416(%r15)
+;   vl %v23, 432(%r15)
+;   vst %v17, 160(%r15)
+;   vst %v19, 176(%r15)
+;   vst %v21, 192(%r15)
+;   vst %v23, 208(%r15)
 ;   bras %r1, 12 ; data %callee_le + 0 ; lg %r4, 0(%r1)
 ;   basr %r14, %r4
-;   lmg %r14, %r15, 272(%r15)
+;   lmg %r14, %r15, 336(%r15)
 ;   br %r14
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   stmg %r14, %r15, 0x70(%r15)
-;   aghi %r15, -0xa0
+;   aghi %r15, -0xe0
 ; block1: ; offset 0xa
-;   bras %r1, 0x16
+;   vl %v17, 0x180(%r15)
+;   vl %v19, 0x190(%r15)
+;   vl %v21, 0x1a0(%r15)
+;   vl %v23, 0x1b0(%r15)
+;   vst %v17, 0xa0(%r15)
+;   vst %v19, 0xb0(%r15)
+;   vst %v21, 0xc0(%r15)
+;   vst %v23, 0xd0(%r15)
+;   bras %r1, 0x46
 ;   .byte 0x00, 0x00 ; reloc_external Abs8 %callee_le 0
 ;   .byte 0x00, 0x00
 ;   .byte 0x00, 0x00
 ;   .byte 0x00, 0x00
 ;   lg %r4, 0(%r1)
 ;   basr %r14, %r4
-;   lmg %r14, %r15, 0x110(%r15)
+;   lmg %r14, %r15, 0x150(%r15)
 ;   br %r14
 
diff --git a/cranelift/filetests/filetests/isa/s390x/vec-lane-arch13.clif b/cranelift/filetests/filetests/isa/s390x/vec-lane-arch13.clif
index 21a94a42f253..9bc8cea4512e 100644
--- a/cranelift/filetests/filetests/isa/s390x/vec-lane-arch13.clif
+++ b/cranelift/filetests/filetests/isa/s390x/vec-lane-arch13.clif
@@ -15,7 +15,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleg %v24, 0(%r2), 0
+;   vleg %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i64x2_mem_1(i64x2, i64) -> i64x2 {
@@ -32,7 +32,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleg %v24, 0(%r2), 1
+;   vleg %v24, 0(%r2), 1 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i64x2_mem_little_0(i64x2, i64) -> i64x2 {
@@ -49,7 +49,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x08, 0x02
 ;   br %r14
@@ -68,7 +68,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lr %r0, %r2
 ;   br %r14
@@ -87,7 +87,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlef %v24, 0(%r2), 0
+;   vlef %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i32x4_mem_3(i32x4, i64) -> i32x4 {
@@ -104,7 +104,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlef %v24, 0(%r2), 3
+;   vlef %v24, 0(%r2), 3 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i32x4_mem_little_0(i32x4, i64) -> i32x4 {
@@ -121,7 +121,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x08, 0x03
 ;   br %r14
@@ -140,7 +140,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ler %f0, %f3
 ;   br %r14
@@ -159,7 +159,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleh %v24, 0(%r2), 0
+;   vleh %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i16x8_mem_7(i16x8, i64) -> i16x8 {
@@ -176,7 +176,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleh %v24, 0(%r2), 7
+;   vleh %v24, 0(%r2), 7 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i16x8_mem_little_0(i16x8, i64) -> i16x8 {
@@ -193,7 +193,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x08, 0x01
 ;   br %r14
@@ -212,7 +212,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   le %f0, 0x7fe(%r1)
 
@@ -230,7 +230,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleb %v24, 0(%r2), 0
+;   vleb %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i8x16_mem_15(i8x16, i64) -> i8x16 {
@@ -247,7 +247,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleb %v24, 0(%r2), 0xf
+;   vleb %v24, 0(%r2), 0xf ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i8x16_mem_little_0(i8x16, i64) -> i8x16 {
@@ -264,7 +264,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleb %v24, 0(%r2), 0
+;   vleb %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i8x16_mem_little_15(i8x16, i64) -> i8x16 {
@@ -281,7 +281,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleb %v24, 0(%r2), 0xf
+;   vleb %v24, 0(%r2), 0xf ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_f64x2_mem_0(f64x2, i64) -> f64x2 {
@@ -298,7 +298,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleg %v24, 0(%r2), 0
+;   vleg %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_f64x2_mem_1(f64x2, i64) -> f64x2 {
@@ -315,7 +315,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleg %v24, 0(%r2), 1
+;   vleg %v24, 0(%r2), 1 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_f64x2_mem_little_0(f64x2, i64) -> f64x2 {
@@ -332,7 +332,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x08, 0x02
 ;   br %r14
@@ -351,7 +351,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lr %r0, %r2
 ;   br %r14
@@ -370,7 +370,7 @@ block0(v0: f32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlef %v24, 0(%r2), 0
+;   vlef %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i32x4_mem_3(i32x4, i64) -> i32x4 {
@@ -387,7 +387,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlef %v24, 0(%r2), 3
+;   vlef %v24, 0(%r2), 3 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_f32x4_mem_little_0(f32x4, i64) -> f32x4 {
@@ -404,7 +404,7 @@ block0(v0: f32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x08, 0x03
 ;   br %r14
@@ -423,7 +423,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ler %f0, %f3
 ;   br %r14
@@ -442,7 +442,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteg %v24, 0(%r2), 0
+;   vsteg %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i64x2_mem_1(i64x2, i64) {
@@ -459,7 +459,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteg %v24, 0(%r2), 1
+;   vsteg %v24, 0(%r2), 1 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i64x2_mem_little_0(i64x2, i64) {
@@ -476,7 +476,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x08, 0x0a
 ;   br %r14
@@ -495,7 +495,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lr %r0, %r10
 ;   br %r14
@@ -514,7 +514,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vstef %v24, 0(%r2), 0
+;   vstef %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i32x4_mem_3(i32x4, i64) {
@@ -531,7 +531,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vstef %v24, 0(%r2), 3
+;   vstef %v24, 0(%r2), 3 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i32x4_mem_little_0(i32x4, i64) {
@@ -548,7 +548,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x08, 0x0b
 ;   br %r14
@@ -567,7 +567,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ler %f0, %f11
 ;   br %r14
@@ -586,7 +586,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteh %v24, 0(%r2), 0
+;   vsteh %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i16x8_mem_7(i16x8, i64) {
@@ -603,7 +603,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteh %v24, 0(%r2), 7
+;   vsteh %v24, 0(%r2), 7 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i16x8_mem_little_0(i16x8, i64) {
@@ -620,7 +620,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x08, 0x09
 ;   br %r14
@@ -639,7 +639,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   le %f0, 0x7fe(%r9)
 
@@ -657,7 +657,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteb %v24, 0(%r2), 0
+;   vsteb %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i8x16_mem_15(i8x16, i64) {
@@ -674,7 +674,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteb %v24, 0(%r2), 0xf
+;   vsteb %v24, 0(%r2), 0xf ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i8x16_mem_little_0(i8x16, i64) {
@@ -691,7 +691,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteb %v24, 0(%r2), 0
+;   vsteb %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i8x16_mem_little_15(i8x16, i64) {
@@ -708,7 +708,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteb %v24, 0(%r2), 0xf
+;   vsteb %v24, 0(%r2), 0xf ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_f64x2_mem_0(f64x2, i64) {
@@ -725,7 +725,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteg %v24, 0(%r2), 0
+;   vsteg %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_f64x2_mem_1(f64x2, i64) {
@@ -742,7 +742,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteg %v24, 0(%r2), 1
+;   vsteg %v24, 0(%r2), 1 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_f64x2_mem_little_0(f64x2, i64) {
@@ -759,7 +759,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x08, 0x0a
 ;   br %r14
@@ -778,7 +778,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lr %r0, %r10
 ;   br %r14
@@ -797,7 +797,7 @@ block0(v0: f32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vstef %v24, 0(%r2), 0
+;   vstef %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_f32x4_mem_3(f32x4, i64) {
@@ -814,7 +814,7 @@ block0(v0: f32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vstef %v24, 0(%r2), 3
+;   vstef %v24, 0(%r2), 3 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_f32x4_mem_little_0(f32x4, i64) {
@@ -831,7 +831,7 @@ block0(v0: f32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x08, 0x0b
 ;   br %r14
@@ -850,7 +850,7 @@ block0(v0: f32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ler %f0, %f11
 ;   br %r14
@@ -869,7 +869,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlrepg %v24, 0(%r2)
+;   vlrepg %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_i64x2_mem_little(i64) -> i64x2 {
@@ -886,7 +886,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ler %f0, %f5
 ;   br %r14
@@ -905,7 +905,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlrepf %v24, 0(%r2)
+;   vlrepf %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_i32x4_mem_little(i64) -> i32x4 {
@@ -922,7 +922,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ldr %f0, %f5
 ;   br %r14
@@ -941,7 +941,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlreph %v24, 0(%r2)
+;   vlreph %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_i16x8_mem_little(i64) -> i16x8 {
@@ -958,7 +958,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lr %r0, %r5
 ;   br %r14
@@ -977,7 +977,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlrepb %v24, 0(%r2)
+;   vlrepb %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_i8x16_mem_little(i64) -> i8x16 {
@@ -994,7 +994,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlrepb %v24, 0(%r2)
+;   vlrepb %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_f64x2_mem(i64) -> f64x2 {
@@ -1011,7 +1011,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlrepg %v24, 0(%r2)
+;   vlrepg %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_f64x2_mem_little(i64) -> f64x2 {
@@ -1028,7 +1028,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ler %f0, %f5
 ;   br %r14
@@ -1047,7 +1047,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlrepf %v24, 0(%r2)
+;   vlrepf %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_f32x4_mem_little(i64) -> f32x4 {
@@ -1064,7 +1064,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ldr %f0, %f5
 ;   br %r14
@@ -1085,7 +1085,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   vleg %v24, 0(%r2), 0
+;   vleg %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %scalar_to_vector_i64x2_mem_little(i64) -> i64x2 {
@@ -1104,7 +1104,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x08, 0x02
 ;   br %r14
@@ -1125,7 +1125,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   vlef %v24, 0(%r2), 0
+;   vlef %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %scalar_to_vector_i32x4_mem_little(i64) -> i32x4 {
@@ -1144,7 +1144,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x08, 0x03
 ;   br %r14
@@ -1165,7 +1165,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   vleh %v24, 0(%r2), 0
+;   vleh %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %scalar_to_vector_i16x8_mem_little(i64) -> i16x8 {
@@ -1184,7 +1184,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x08, 0x01
 ;   br %r14
@@ -1205,7 +1205,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   vleb %v24, 0(%r2), 0
+;   vleb %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %scalar_to_vector_i8x16_mem_little(i64) -> i8x16 {
@@ -1224,7 +1224,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   vleb %v24, 0(%r2), 0
+;   vleb %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %scalar_to_vector_f64x2_mem(i64) -> f64x2 {
@@ -1243,7 +1243,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   vleg %v24, 0(%r2), 0
+;   vleg %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %scalar_to_vector_f64x2_mem_little(i64) -> f64x2 {
@@ -1262,7 +1262,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x08, 0x02
 ;   br %r14
@@ -1283,7 +1283,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   vlef %v24, 0(%r2), 0
+;   vlef %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %scalar_to_vector_f32x4_mem_little(i64) -> f32x4 {
@@ -1302,7 +1302,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x08, 0x03
 ;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/vec-lane-le-lane-arch13.clif b/cranelift/filetests/filetests/isa/s390x/vec-lane-le-lane-arch13.clif
index 1c776beeeb32..9eb290a6926a 100644
--- a/cranelift/filetests/filetests/isa/s390x/vec-lane-le-lane-arch13.clif
+++ b/cranelift/filetests/filetests/isa/s390x/vec-lane-le-lane-arch13.clif
@@ -15,7 +15,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleg %v24, 0(%r2), 1
+;   vleg %v24, 0(%r2), 1 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i64x2_mem_1(i64x2, i64) -> i64x2 wasmtime_system_v {
@@ -32,7 +32,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleg %v24, 0(%r2), 0
+;   vleg %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i64x2_mem_little_0(i64x2, i64) -> i64x2 wasmtime_system_v {
@@ -49,7 +49,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lr %r0, %r2
 ;   br %r14
@@ -68,7 +68,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x08, 0x02
 ;   br %r14
@@ -87,7 +87,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlef %v24, 0(%r2), 3
+;   vlef %v24, 0(%r2), 3 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i32x4_mem_3(i32x4, i64) -> i32x4 wasmtime_system_v {
@@ -104,7 +104,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlef %v24, 0(%r2), 0
+;   vlef %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i32x4_mem_little_0(i32x4, i64) -> i32x4 wasmtime_system_v {
@@ -121,7 +121,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ler %f0, %f3
 ;   br %r14
@@ -140,7 +140,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x08, 0x03
 ;   br %r14
@@ -159,7 +159,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleh %v24, 0(%r2), 7
+;   vleh %v24, 0(%r2), 7 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i16x8_mem_7(i16x8, i64) -> i16x8 wasmtime_system_v {
@@ -176,7 +176,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleh %v24, 0(%r2), 0
+;   vleh %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i16x8_mem_little_0(i16x8, i64) -> i16x8 wasmtime_system_v {
@@ -193,7 +193,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   le %f0, 0x7fe(%r1)
 
@@ -211,7 +211,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x08, 0x01
 ;   br %r14
@@ -230,7 +230,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleb %v24, 0(%r2), 0xf
+;   vleb %v24, 0(%r2), 0xf ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i8x16_mem_15(i8x16, i64) -> i8x16 wasmtime_system_v {
@@ -247,7 +247,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleb %v24, 0(%r2), 0
+;   vleb %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i8x16_mem_little_0(i8x16, i64) -> i8x16 wasmtime_system_v {
@@ -264,7 +264,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleb %v24, 0(%r2), 0xf
+;   vleb %v24, 0(%r2), 0xf ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i8x16_mem_little_15(i8x16, i64) -> i8x16 wasmtime_system_v {
@@ -281,7 +281,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleb %v24, 0(%r2), 0
+;   vleb %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_f64x2_mem_0(f64x2, i64) -> f64x2 wasmtime_system_v {
@@ -298,7 +298,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleg %v24, 0(%r2), 1
+;   vleg %v24, 0(%r2), 1 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_f64x2_mem_1(f64x2, i64) -> f64x2 wasmtime_system_v {
@@ -315,7 +315,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleg %v24, 0(%r2), 0
+;   vleg %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_f64x2_mem_little_0(f64x2, i64) -> f64x2 wasmtime_system_v {
@@ -332,7 +332,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lr %r0, %r2
 ;   br %r14
@@ -351,7 +351,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x08, 0x02
 ;   br %r14
@@ -370,7 +370,7 @@ block0(v0: f32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlef %v24, 0(%r2), 3
+;   vlef %v24, 0(%r2), 3 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i32x4_mem_3(i32x4, i64) -> i32x4 wasmtime_system_v {
@@ -387,7 +387,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlef %v24, 0(%r2), 0
+;   vlef %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_f32x4_mem_little_0(f32x4, i64) -> f32x4 wasmtime_system_v {
@@ -404,7 +404,7 @@ block0(v0: f32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ler %f0, %f3
 ;   br %r14
@@ -423,7 +423,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x08, 0x03
 ;   br %r14
@@ -442,7 +442,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteg %v24, 0(%r2), 1
+;   vsteg %v24, 0(%r2), 1 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i64x2_mem_1(i64x2, i64) wasmtime_system_v {
@@ -459,7 +459,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteg %v24, 0(%r2), 0
+;   vsteg %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i64x2_mem_little_0(i64x2, i64) wasmtime_system_v {
@@ -476,7 +476,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lr %r0, %r10
 ;   br %r14
@@ -495,7 +495,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x08, 0x0a
 ;   br %r14
@@ -514,7 +514,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vstef %v24, 0(%r2), 3
+;   vstef %v24, 0(%r2), 3 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i32x4_mem_3(i32x4, i64) wasmtime_system_v {
@@ -531,7 +531,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vstef %v24, 0(%r2), 0
+;   vstef %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i32x4_mem_little_0(i32x4, i64) wasmtime_system_v {
@@ -548,7 +548,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ler %f0, %f11
 ;   br %r14
@@ -567,7 +567,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x08, 0x0b
 ;   br %r14
@@ -586,7 +586,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteh %v24, 0(%r2), 7
+;   vsteh %v24, 0(%r2), 7 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i16x8_mem_7(i16x8, i64) wasmtime_system_v {
@@ -603,7 +603,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteh %v24, 0(%r2), 0
+;   vsteh %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i16x8_mem_little_0(i16x8, i64) wasmtime_system_v {
@@ -620,7 +620,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   le %f0, 0x7fe(%r9)
 
@@ -638,7 +638,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x08, 0x09
 ;   br %r14
@@ -657,7 +657,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteb %v24, 0(%r2), 0xf
+;   vsteb %v24, 0(%r2), 0xf ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i8x16_mem_15(i8x16, i64) wasmtime_system_v {
@@ -674,7 +674,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteb %v24, 0(%r2), 0
+;   vsteb %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i8x16_mem_little_0(i8x16, i64) wasmtime_system_v {
@@ -691,7 +691,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteb %v24, 0(%r2), 0xf
+;   vsteb %v24, 0(%r2), 0xf ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i8x16_mem_little_15(i8x16, i64) wasmtime_system_v {
@@ -708,7 +708,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteb %v24, 0(%r2), 0
+;   vsteb %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_f64x2_mem_0(f64x2, i64) wasmtime_system_v {
@@ -725,7 +725,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteg %v24, 0(%r2), 1
+;   vsteg %v24, 0(%r2), 1 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_f64x2_mem_1(f64x2, i64) wasmtime_system_v {
@@ -742,7 +742,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteg %v24, 0(%r2), 0
+;   vsteg %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_f64x2_mem_little_0(f64x2, i64) wasmtime_system_v {
@@ -759,7 +759,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lr %r0, %r10
 ;   br %r14
@@ -778,7 +778,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x08, 0x0a
 ;   br %r14
@@ -797,7 +797,7 @@ block0(v0: f32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vstef %v24, 0(%r2), 3
+;   vstef %v24, 0(%r2), 3 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_f32x4_mem_3(f32x4, i64) wasmtime_system_v {
@@ -814,7 +814,7 @@ block0(v0: f32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vstef %v24, 0(%r2), 0
+;   vstef %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_f32x4_mem_little_0(f32x4, i64) wasmtime_system_v {
@@ -831,7 +831,7 @@ block0(v0: f32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ler %f0, %f11
 ;   br %r14
@@ -850,7 +850,7 @@ block0(v0: f32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x08, 0x0b
 ;   br %r14
@@ -869,7 +869,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlrepg %v24, 0(%r2)
+;   vlrepg %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_i64x2_mem_little(i64) -> i64x2 wasmtime_system_v {
@@ -886,7 +886,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ler %f0, %f5
 ;   br %r14
@@ -905,7 +905,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlrepf %v24, 0(%r2)
+;   vlrepf %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_i32x4_mem_little(i64) -> i32x4 wasmtime_system_v {
@@ -922,7 +922,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ldr %f0, %f5
 ;   br %r14
@@ -941,7 +941,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlreph %v24, 0(%r2)
+;   vlreph %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_i16x8_mem_little(i64) -> i16x8 wasmtime_system_v {
@@ -958,7 +958,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lr %r0, %r5
 ;   br %r14
@@ -977,7 +977,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlrepb %v24, 0(%r2)
+;   vlrepb %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_i8x16_mem_little(i64) -> i8x16 wasmtime_system_v {
@@ -994,7 +994,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlrepb %v24, 0(%r2)
+;   vlrepb %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_f64x2_mem(i64) -> f64x2 wasmtime_system_v {
@@ -1011,7 +1011,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlrepg %v24, 0(%r2)
+;   vlrepg %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_f64x2_mem_little(i64) -> f64x2 wasmtime_system_v {
@@ -1028,7 +1028,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ler %f0, %f5
 ;   br %r14
@@ -1047,7 +1047,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlrepf %v24, 0(%r2)
+;   vlrepf %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_f32x4_mem_little(i64) -> f32x4 wasmtime_system_v {
@@ -1064,7 +1064,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ldr %f0, %f5
 ;   br %r14
@@ -1085,7 +1085,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   vleg %v24, 0(%r2), 1
+;   vleg %v24, 0(%r2), 1 ; trap: heap_oob
 ;   br %r14
 
 function %scalar_to_vector_i64x2_mem_little(i64) -> i64x2 wasmtime_system_v {
@@ -1104,7 +1104,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lr %r0, %r2
 ;   br %r14
@@ -1125,7 +1125,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   vlef %v24, 0(%r2), 3
+;   vlef %v24, 0(%r2), 3 ; trap: heap_oob
 ;   br %r14
 
 function %scalar_to_vector_i32x4_mem_little(i64) -> i32x4 wasmtime_system_v {
@@ -1144,7 +1144,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ler %f0, %f3
 ;   br %r14
@@ -1165,7 +1165,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   vleh %v24, 0(%r2), 7
+;   vleh %v24, 0(%r2), 7 ; trap: heap_oob
 ;   br %r14
 
 function %scalar_to_vector_i16x8_mem_little(i64) -> i16x8 wasmtime_system_v {
@@ -1184,7 +1184,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   le %f0, 0x7fe(%r1)
 
@@ -1204,7 +1204,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   vleb %v24, 0(%r2), 0xf
+;   vleb %v24, 0(%r2), 0xf ; trap: heap_oob
 ;   br %r14
 
 function %scalar_to_vector_i8x16_mem_little(i64) -> i8x16 wasmtime_system_v {
@@ -1223,7 +1223,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   vleb %v24, 0(%r2), 0xf
+;   vleb %v24, 0(%r2), 0xf ; trap: heap_oob
 ;   br %r14
 
 function %scalar_to_vector_f64x2_mem(i64) -> f64x2 wasmtime_system_v {
@@ -1242,7 +1242,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   vleg %v24, 0(%r2), 1
+;   vleg %v24, 0(%r2), 1 ; trap: heap_oob
 ;   br %r14
 
 function %scalar_to_vector_f64x2_mem_little(i64) -> f64x2 wasmtime_system_v {
@@ -1261,7 +1261,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lr %r0, %r2
 ;   br %r14
@@ -1282,7 +1282,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   vlef %v24, 0(%r2), 3
+;   vlef %v24, 0(%r2), 3 ; trap: heap_oob
 ;   br %r14
 
 function %scalar_to_vector_f32x4_mem_little(i64) -> f32x4 wasmtime_system_v {
@@ -1301,7 +1301,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ler %f0, %f3
 ;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/vec-lane-le-lane.clif b/cranelift/filetests/filetests/isa/s390x/vec-lane-le-lane.clif
index 9a9978315590..93bd55d78e02 100644
--- a/cranelift/filetests/filetests/isa/s390x/vec-lane-le-lane.clif
+++ b/cranelift/filetests/filetests/isa/s390x/vec-lane-le-lane.clif
@@ -149,7 +149,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleg %v24, 0(%r2), 1
+;   vleg %v24, 0(%r2), 1 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i64x2_mem_1(i64x2, i64) -> i64x2 wasmtime_system_v {
@@ -166,7 +166,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleg %v24, 0(%r2), 0
+;   vleg %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i64x2_mem_little_0(i64x2, i64) -> i64x2 wasmtime_system_v {
@@ -184,7 +184,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r5, 0(%r2)
+;   lrvg %r5, 0(%r2) ; trap: heap_oob
 ;   vlvgg %v24, %r5, 1
 ;   br %r14
 
@@ -203,7 +203,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r5, 0(%r2)
+;   lrvg %r5, 0(%r2) ; trap: heap_oob
 ;   vlvgg %v24, %r5, 0
 ;   br %r14
 
@@ -367,7 +367,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlef %v24, 0(%r2), 3
+;   vlef %v24, 0(%r2), 3 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i32x4_mem_3(i32x4, i64) -> i32x4 wasmtime_system_v {
@@ -384,7 +384,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlef %v24, 0(%r2), 0
+;   vlef %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i32x4_mem_little_0(i32x4, i64) -> i32x4 wasmtime_system_v {
@@ -402,7 +402,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrv %r5, 0(%r2)
+;   lrv %r5, 0(%r2) ; trap: heap_oob
 ;   vlvgf %v24, %r5, 3
 ;   br %r14
 
@@ -421,7 +421,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrv %r5, 0(%r2)
+;   lrv %r5, 0(%r2) ; trap: heap_oob
 ;   vlvgf %v24, %r5, 0
 ;   br %r14
 
@@ -585,7 +585,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleh %v24, 0(%r2), 7
+;   vleh %v24, 0(%r2), 7 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i16x8_mem_7(i16x8, i64) -> i16x8 wasmtime_system_v {
@@ -602,7 +602,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleh %v24, 0(%r2), 0
+;   vleh %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i16x8_mem_little_0(i16x8, i64) -> i16x8 wasmtime_system_v {
@@ -620,7 +620,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvh %r5, 0(%r2)
+;   lrvh %r5, 0(%r2) ; trap: heap_oob
 ;   vlvgh %v24, %r5, 7
 ;   br %r14
 
@@ -639,7 +639,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvh %r5, 0(%r2)
+;   lrvh %r5, 0(%r2) ; trap: heap_oob
 ;   vlvgh %v24, %r5, 0
 ;   br %r14
 
@@ -803,7 +803,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleb %v24, 0(%r2), 0xf
+;   vleb %v24, 0(%r2), 0xf ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i8x16_mem_15(i8x16, i64) -> i8x16 wasmtime_system_v {
@@ -820,7 +820,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleb %v24, 0(%r2), 0
+;   vleb %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i8x16_mem_little_0(i8x16, i64) -> i8x16 wasmtime_system_v {
@@ -837,7 +837,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleb %v24, 0(%r2), 0xf
+;   vleb %v24, 0(%r2), 0xf ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i8x16_mem_little_15(i8x16, i64) -> i8x16 wasmtime_system_v {
@@ -854,7 +854,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleb %v24, 0(%r2), 0
+;   vleb %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_f64x2_0(f64x2, f64) -> f64x2 wasmtime_system_v {
@@ -971,7 +971,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleg %v24, 0(%r2), 1
+;   vleg %v24, 0(%r2), 1 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_f64x2_mem_1(f64x2, i64) -> f64x2 wasmtime_system_v {
@@ -988,7 +988,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleg %v24, 0(%r2), 0
+;   vleg %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_f64x2_mem_little_0(f64x2, i64) -> f64x2 wasmtime_system_v {
@@ -1006,7 +1006,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r5, 0(%r2)
+;   lrvg %r5, 0(%r2) ; trap: heap_oob
 ;   vlvgg %v24, %r5, 1
 ;   br %r14
 
@@ -1025,7 +1025,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r5, 0(%r2)
+;   lrvg %r5, 0(%r2) ; trap: heap_oob
 ;   vlvgg %v24, %r5, 0
 ;   br %r14
 
@@ -1161,7 +1161,7 @@ block0(v0: f32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlef %v24, 0(%r2), 3
+;   vlef %v24, 0(%r2), 3 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i32x4_mem_3(i32x4, i64) -> i32x4 wasmtime_system_v {
@@ -1178,7 +1178,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlef %v24, 0(%r2), 0
+;   vlef %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_f32x4_mem_little_0(f32x4, i64) -> f32x4 wasmtime_system_v {
@@ -1196,7 +1196,7 @@ block0(v0: f32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrv %r5, 0(%r2)
+;   lrv %r5, 0(%r2) ; trap: heap_oob
 ;   vlvgf %v24, %r5, 3
 ;   br %r14
 
@@ -1215,7 +1215,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrv %r5, 0(%r2)
+;   lrv %r5, 0(%r2) ; trap: heap_oob
 ;   vlvgf %v24, %r5, 0
 ;   br %r14
 
@@ -1265,7 +1265,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteg %v24, 0(%r2), 1
+;   vsteg %v24, 0(%r2), 1 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i64x2_mem_1(i64x2, i64) wasmtime_system_v {
@@ -1282,7 +1282,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteg %v24, 0(%r2), 0
+;   vsteg %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i64x2_mem_little_0(i64x2, i64) wasmtime_system_v {
@@ -1301,7 +1301,7 @@ block0(v0: i64x2, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vlgvg %r5, %v24, 1
-;   strvg %r5, 0(%r2)
+;   strvg %r5, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i64x2_mem_little_1(i64x2, i64) wasmtime_system_v {
@@ -1320,7 +1320,7 @@ block0(v0: i64x2, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vlgvg %r5, %v24, 0
-;   strvg %r5, 0(%r2)
+;   strvg %r5, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i32x4_0(i32x4) -> i32 wasmtime_system_v {
@@ -1369,7 +1369,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vstef %v24, 0(%r2), 3
+;   vstef %v24, 0(%r2), 3 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i32x4_mem_3(i32x4, i64) wasmtime_system_v {
@@ -1386,7 +1386,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vstef %v24, 0(%r2), 0
+;   vstef %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i32x4_mem_little_0(i32x4, i64) wasmtime_system_v {
@@ -1405,7 +1405,7 @@ block0(v0: i32x4, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vlgvf %r5, %v24, 3
-;   strv %r5, 0(%r2)
+;   strv %r5, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i32x4_mem_little_3(i32x4, i64) wasmtime_system_v {
@@ -1424,7 +1424,7 @@ block0(v0: i32x4, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vlgvf %r5, %v24, 0
-;   strv %r5, 0(%r2)
+;   strv %r5, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i16x8_0(i16x8) -> i16 wasmtime_system_v {
@@ -1473,7 +1473,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteh %v24, 0(%r2), 7
+;   vsteh %v24, 0(%r2), 7 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i16x8_mem_7(i16x8, i64) wasmtime_system_v {
@@ -1490,7 +1490,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteh %v24, 0(%r2), 0
+;   vsteh %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i16x8_mem_little_0(i16x8, i64) wasmtime_system_v {
@@ -1509,7 +1509,7 @@ block0(v0: i16x8, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vlgvh %r5, %v24, 7
-;   strvh %r5, 0(%r2)
+;   strvh %r5, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i16x8_mem_little_7(i16x8, i64) wasmtime_system_v {
@@ -1528,7 +1528,7 @@ block0(v0: i16x8, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vlgvh %r5, %v24, 0
-;   strvh %r5, 0(%r2)
+;   strvh %r5, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i8x16_0(i8x16) -> i8 wasmtime_system_v {
@@ -1577,7 +1577,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteb %v24, 0(%r2), 0xf
+;   vsteb %v24, 0(%r2), 0xf ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i8x16_mem_15(i8x16, i64) wasmtime_system_v {
@@ -1594,7 +1594,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteb %v24, 0(%r2), 0
+;   vsteb %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i8x16_mem_little_0(i8x16, i64) wasmtime_system_v {
@@ -1611,7 +1611,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteb %v24, 0(%r2), 0xf
+;   vsteb %v24, 0(%r2), 0xf ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i8x16_mem_little_15(i8x16, i64) wasmtime_system_v {
@@ -1628,7 +1628,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteb %v24, 0(%r2), 0
+;   vsteb %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_f64x2_0(f64x2) -> f64 wasmtime_system_v {
@@ -1677,7 +1677,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteg %v24, 0(%r2), 1
+;   vsteg %v24, 0(%r2), 1 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_f64x2_mem_1(f64x2, i64) wasmtime_system_v {
@@ -1694,7 +1694,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteg %v24, 0(%r2), 0
+;   vsteg %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_f64x2_mem_little_0(f64x2, i64) wasmtime_system_v {
@@ -1713,7 +1713,7 @@ block0(v0: f64x2, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vlgvg %r5, %v24, 1
-;   strvg %r5, 0(%r2)
+;   strvg %r5, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_f64x2_mem_little_1(f64x2, i64) wasmtime_system_v {
@@ -1732,7 +1732,7 @@ block0(v0: f64x2, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vlgvg %r5, %v24, 0
-;   strvg %r5, 0(%r2)
+;   strvg %r5, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_f32x4_0(f32x4) -> f32 wasmtime_system_v {
@@ -1781,7 +1781,7 @@ block0(v0: f32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vstef %v24, 0(%r2), 3
+;   vstef %v24, 0(%r2), 3 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_f32x4_mem_3(f32x4, i64) wasmtime_system_v {
@@ -1798,7 +1798,7 @@ block0(v0: f32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vstef %v24, 0(%r2), 0
+;   vstef %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_f32x4_mem_little_0(f32x4, i64) wasmtime_system_v {
@@ -1817,7 +1817,7 @@ block0(v0: f32x4, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vlgvf %r5, %v24, 3
-;   strv %r5, 0(%r2)
+;   strv %r5, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_f32x4_mem_little_3(f32x4, i64) wasmtime_system_v {
@@ -1836,7 +1836,7 @@ block0(v0: f32x4, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vlgvf %r5, %v24, 0
-;   strv %r5, 0(%r2)
+;   strv %r5, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_i64x2(i64) -> i64x2 wasmtime_system_v {
@@ -1922,7 +1922,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlrepg %v24, 0(%r2)
+;   vlrepg %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_i64x2_mem_little(i64) -> i64x2 wasmtime_system_v {
@@ -1941,7 +1941,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0(%r2)
+;   lrvg %r4, 0(%r2) ; trap: heap_oob
 ;   ldgr %f4, %r4
 ;   vrepg %v24, %v4, 0
 ;   br %r14
@@ -2029,7 +2029,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlrepf %v24, 0(%r2)
+;   vlrepf %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_i32x4_mem_little(i64) -> i32x4 wasmtime_system_v {
@@ -2048,7 +2048,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrv %r4, 0(%r2)
+;   lrv %r4, 0(%r2) ; trap: heap_oob
 ;   vlvgf %v4, %r4, 0
 ;   vrepf %v24, %v4, 0
 ;   br %r14
@@ -2136,7 +2136,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlreph %v24, 0(%r2)
+;   vlreph %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_i16x8_mem_little(i64) -> i16x8 wasmtime_system_v {
@@ -2155,7 +2155,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvh %r4, 0(%r2)
+;   lrvh %r4, 0(%r2) ; trap: heap_oob
 ;   vlvgh %v4, %r4, 0
 ;   vreph %v24, %v4, 0
 ;   br %r14
@@ -2243,7 +2243,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlrepb %v24, 0(%r2)
+;   vlrepb %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_i8x16_mem_little(i64) -> i8x16 wasmtime_system_v {
@@ -2260,7 +2260,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlrepb %v24, 0(%r2)
+;   vlrepb %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_f64x2(f64) -> f64x2 wasmtime_system_v {
@@ -2327,7 +2327,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlrepg %v24, 0(%r2)
+;   vlrepg %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_f64x2_mem_little(i64) -> f64x2 wasmtime_system_v {
@@ -2346,7 +2346,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0(%r2)
+;   lrvg %r4, 0(%r2) ; trap: heap_oob
 ;   ldgr %f4, %r4
 ;   vrepg %v24, %v4, 0
 ;   br %r14
@@ -2415,7 +2415,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlrepf %v24, 0(%r2)
+;   vlrepf %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_f32x4_mem_little(i64) -> f32x4 wasmtime_system_v {
@@ -2434,7 +2434,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrv %r4, 0(%r2)
+;   lrv %r4, 0(%r2) ; trap: heap_oob
 ;   vlvgf %v4, %r4, 0
 ;   vrepf %v24, %v4, 0
 ;   br %r14
@@ -2530,7 +2530,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   vleg %v24, 0(%r2), 1
+;   vleg %v24, 0(%r2), 1 ; trap: heap_oob
 ;   br %r14
 
 function %scalar_to_vector_i64x2_mem_little(i64) -> i64x2 wasmtime_system_v {
@@ -2550,7 +2550,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   lrvg %r2, 0(%r2)
+;   lrvg %r2, 0(%r2) ; trap: heap_oob
 ;   vlvgg %v24, %r2, 1
 ;   br %r14
 
@@ -2647,7 +2647,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   vlef %v24, 0(%r2), 3
+;   vlef %v24, 0(%r2), 3 ; trap: heap_oob
 ;   br %r14
 
 function %scalar_to_vector_i32x4_mem_little(i64) -> i32x4 wasmtime_system_v {
@@ -2667,7 +2667,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   lrv %r2, 0(%r2)
+;   lrv %r2, 0(%r2) ; trap: heap_oob
 ;   vlvgf %v24, %r2, 3
 ;   br %r14
 
@@ -2764,7 +2764,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   vleh %v24, 0(%r2), 7
+;   vleh %v24, 0(%r2), 7 ; trap: heap_oob
 ;   br %r14
 
 function %scalar_to_vector_i16x8_mem_little(i64) -> i16x8 wasmtime_system_v {
@@ -2784,7 +2784,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   lrvh %r2, 0(%r2)
+;   lrvh %r2, 0(%r2) ; trap: heap_oob
 ;   vlvgh %v24, %r2, 7
 ;   br %r14
 
@@ -2881,7 +2881,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   vleb %v24, 0(%r2), 0xf
+;   vleb %v24, 0(%r2), 0xf ; trap: heap_oob
 ;   br %r14
 
 function %scalar_to_vector_i8x16_mem_little(i64) -> i8x16 wasmtime_system_v {
@@ -2900,7 +2900,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   vleb %v24, 0(%r2), 0xf
+;   vleb %v24, 0(%r2), 0xf ; trap: heap_oob
 ;   br %r14
 
 function %scalar_to_vector_f64x2(f64) -> f64x2 wasmtime_system_v {
@@ -2975,7 +2975,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   vleg %v24, 0(%r2), 1
+;   vleg %v24, 0(%r2), 1 ; trap: heap_oob
 ;   br %r14
 
 function %scalar_to_vector_f64x2_mem_little(i64) -> f64x2 wasmtime_system_v {
@@ -2995,7 +2995,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   lrvg %r2, 0(%r2)
+;   lrvg %r2, 0(%r2) ; trap: heap_oob
 ;   vlvgg %v24, %r2, 1
 ;   br %r14
 
@@ -3075,7 +3075,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   vlef %v24, 0(%r2), 3
+;   vlef %v24, 0(%r2), 3 ; trap: heap_oob
 ;   br %r14
 
 function %scalar_to_vector_f32x4_mem_little(i64) -> f32x4 wasmtime_system_v {
@@ -3095,7 +3095,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   lrv %r2, 0(%r2)
+;   lrv %r2, 0(%r2) ; trap: heap_oob
 ;   vlvgf %v24, %r2, 3
 ;   br %r14
 
diff --git a/cranelift/filetests/filetests/isa/s390x/vec-lane.clif b/cranelift/filetests/filetests/isa/s390x/vec-lane.clif
index e865a9bf311f..587faaf42343 100644
--- a/cranelift/filetests/filetests/isa/s390x/vec-lane.clif
+++ b/cranelift/filetests/filetests/isa/s390x/vec-lane.clif
@@ -149,7 +149,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleg %v24, 0(%r2), 0
+;   vleg %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i64x2_mem_1(i64x2, i64) -> i64x2 {
@@ -166,7 +166,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleg %v24, 0(%r2), 1
+;   vleg %v24, 0(%r2), 1 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i64x2_mem_little_0(i64x2, i64) -> i64x2 {
@@ -184,7 +184,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r5, 0(%r2)
+;   lrvg %r5, 0(%r2) ; trap: heap_oob
 ;   vlvgg %v24, %r5, 0
 ;   br %r14
 
@@ -203,7 +203,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r5, 0(%r2)
+;   lrvg %r5, 0(%r2) ; trap: heap_oob
 ;   vlvgg %v24, %r5, 1
 ;   br %r14
 
@@ -367,7 +367,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlef %v24, 0(%r2), 0
+;   vlef %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i32x4_mem_3(i32x4, i64) -> i32x4 {
@@ -384,7 +384,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlef %v24, 0(%r2), 3
+;   vlef %v24, 0(%r2), 3 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i32x4_mem_little_0(i32x4, i64) -> i32x4 {
@@ -402,7 +402,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrv %r5, 0(%r2)
+;   lrv %r5, 0(%r2) ; trap: heap_oob
 ;   vlvgf %v24, %r5, 0
 ;   br %r14
 
@@ -421,7 +421,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrv %r5, 0(%r2)
+;   lrv %r5, 0(%r2) ; trap: heap_oob
 ;   vlvgf %v24, %r5, 3
 ;   br %r14
 
@@ -585,7 +585,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleh %v24, 0(%r2), 0
+;   vleh %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i16x8_mem_7(i16x8, i64) -> i16x8 {
@@ -602,7 +602,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleh %v24, 0(%r2), 7
+;   vleh %v24, 0(%r2), 7 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i16x8_mem_little_0(i16x8, i64) -> i16x8 {
@@ -620,7 +620,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvh %r5, 0(%r2)
+;   lrvh %r5, 0(%r2) ; trap: heap_oob
 ;   vlvgh %v24, %r5, 0
 ;   br %r14
 
@@ -639,7 +639,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvh %r5, 0(%r2)
+;   lrvh %r5, 0(%r2) ; trap: heap_oob
 ;   vlvgh %v24, %r5, 7
 ;   br %r14
 
@@ -803,7 +803,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleb %v24, 0(%r2), 0
+;   vleb %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i8x16_mem_15(i8x16, i64) -> i8x16 {
@@ -820,7 +820,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleb %v24, 0(%r2), 0xf
+;   vleb %v24, 0(%r2), 0xf ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i8x16_mem_little_0(i8x16, i64) -> i8x16 {
@@ -837,7 +837,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleb %v24, 0(%r2), 0
+;   vleb %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i8x16_mem_little_15(i8x16, i64) -> i8x16 {
@@ -854,7 +854,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleb %v24, 0(%r2), 0xf
+;   vleb %v24, 0(%r2), 0xf ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_f64x2_0(f64x2, f64) -> f64x2 {
@@ -971,7 +971,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleg %v24, 0(%r2), 0
+;   vleg %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_f64x2_mem_1(f64x2, i64) -> f64x2 {
@@ -988,7 +988,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vleg %v24, 0(%r2), 1
+;   vleg %v24, 0(%r2), 1 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_f64x2_mem_little_0(f64x2, i64) -> f64x2 {
@@ -1006,7 +1006,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r5, 0(%r2)
+;   lrvg %r5, 0(%r2) ; trap: heap_oob
 ;   vlvgg %v24, %r5, 0
 ;   br %r14
 
@@ -1025,7 +1025,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r5, 0(%r2)
+;   lrvg %r5, 0(%r2) ; trap: heap_oob
 ;   vlvgg %v24, %r5, 1
 ;   br %r14
 
@@ -1161,7 +1161,7 @@ block0(v0: f32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlef %v24, 0(%r2), 0
+;   vlef %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_i32x4_mem_3(i32x4, i64) -> i32x4 {
@@ -1178,7 +1178,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlef %v24, 0(%r2), 3
+;   vlef %v24, 0(%r2), 3 ; trap: heap_oob
 ;   br %r14
 
 function %insertlane_f32x4_mem_little_0(f32x4, i64) -> f32x4 {
@@ -1196,7 +1196,7 @@ block0(v0: f32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrv %r5, 0(%r2)
+;   lrv %r5, 0(%r2) ; trap: heap_oob
 ;   vlvgf %v24, %r5, 0
 ;   br %r14
 
@@ -1215,7 +1215,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrv %r5, 0(%r2)
+;   lrv %r5, 0(%r2) ; trap: heap_oob
 ;   vlvgf %v24, %r5, 3
 ;   br %r14
 
@@ -1265,7 +1265,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteg %v24, 0(%r2), 0
+;   vsteg %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i64x2_mem_1(i64x2, i64) {
@@ -1282,7 +1282,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteg %v24, 0(%r2), 1
+;   vsteg %v24, 0(%r2), 1 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i64x2_mem_little_0(i64x2, i64) {
@@ -1301,7 +1301,7 @@ block0(v0: i64x2, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vlgvg %r5, %v24, 0
-;   strvg %r5, 0(%r2)
+;   strvg %r5, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i64x2_mem_little_1(i64x2, i64) {
@@ -1320,7 +1320,7 @@ block0(v0: i64x2, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vlgvg %r5, %v24, 1
-;   strvg %r5, 0(%r2)
+;   strvg %r5, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i32x4_0(i32x4) -> i32 {
@@ -1369,7 +1369,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vstef %v24, 0(%r2), 0
+;   vstef %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i32x4_mem_3(i32x4, i64) {
@@ -1386,7 +1386,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vstef %v24, 0(%r2), 3
+;   vstef %v24, 0(%r2), 3 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i32x4_mem_little_0(i32x4, i64) {
@@ -1405,7 +1405,7 @@ block0(v0: i32x4, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vlgvf %r5, %v24, 0
-;   strv %r5, 0(%r2)
+;   strv %r5, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i32x4_mem_little_3(i32x4, i64) {
@@ -1424,7 +1424,7 @@ block0(v0: i32x4, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vlgvf %r5, %v24, 3
-;   strv %r5, 0(%r2)
+;   strv %r5, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i16x8_0(i16x8) -> i16 {
@@ -1473,7 +1473,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteh %v24, 0(%r2), 0
+;   vsteh %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i16x8_mem_7(i16x8, i64) {
@@ -1490,7 +1490,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteh %v24, 0(%r2), 7
+;   vsteh %v24, 0(%r2), 7 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i16x8_mem_little_0(i16x8, i64) {
@@ -1509,7 +1509,7 @@ block0(v0: i16x8, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vlgvh %r5, %v24, 0
-;   strvh %r5, 0(%r2)
+;   strvh %r5, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i16x8_mem_little_7(i16x8, i64) {
@@ -1528,7 +1528,7 @@ block0(v0: i16x8, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vlgvh %r5, %v24, 7
-;   strvh %r5, 0(%r2)
+;   strvh %r5, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i8x16_0(i8x16) -> i8 {
@@ -1577,7 +1577,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteb %v24, 0(%r2), 0
+;   vsteb %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i8x16_mem_15(i8x16, i64) {
@@ -1594,7 +1594,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteb %v24, 0(%r2), 0xf
+;   vsteb %v24, 0(%r2), 0xf ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i8x16_mem_little_0(i8x16, i64) {
@@ -1611,7 +1611,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteb %v24, 0(%r2), 0
+;   vsteb %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_i8x16_mem_little_15(i8x16, i64) {
@@ -1628,7 +1628,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteb %v24, 0(%r2), 0xf
+;   vsteb %v24, 0(%r2), 0xf ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_f64x2_0(f64x2) -> f64 {
@@ -1677,7 +1677,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteg %v24, 0(%r2), 0
+;   vsteg %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_f64x2_mem_1(f64x2, i64) {
@@ -1694,7 +1694,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vsteg %v24, 0(%r2), 1
+;   vsteg %v24, 0(%r2), 1 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_f64x2_mem_little_0(f64x2, i64) {
@@ -1713,7 +1713,7 @@ block0(v0: f64x2, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vlgvg %r5, %v24, 0
-;   strvg %r5, 0(%r2)
+;   strvg %r5, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_f64x2_mem_little_1(f64x2, i64) {
@@ -1732,7 +1732,7 @@ block0(v0: f64x2, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vlgvg %r5, %v24, 1
-;   strvg %r5, 0(%r2)
+;   strvg %r5, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_f32x4_0(f32x4) -> f32 {
@@ -1781,7 +1781,7 @@ block0(v0: f32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vstef %v24, 0(%r2), 0
+;   vstef %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_f32x4_mem_3(f32x4, i64) {
@@ -1798,7 +1798,7 @@ block0(v0: f32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vstef %v24, 0(%r2), 3
+;   vstef %v24, 0(%r2), 3 ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_f32x4_mem_little_0(f32x4, i64) {
@@ -1817,7 +1817,7 @@ block0(v0: f32x4, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vlgvf %r5, %v24, 0
-;   strv %r5, 0(%r2)
+;   strv %r5, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %extractlane_f32x4_mem_little_3(f32x4, i64) {
@@ -1836,7 +1836,7 @@ block0(v0: f32x4, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vlgvf %r5, %v24, 3
-;   strv %r5, 0(%r2)
+;   strv %r5, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_i64x2(i64) -> i64x2 {
@@ -1922,7 +1922,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlrepg %v24, 0(%r2)
+;   vlrepg %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_i64x2_mem_little(i64) -> i64x2 {
@@ -1941,7 +1941,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0(%r2)
+;   lrvg %r4, 0(%r2) ; trap: heap_oob
 ;   ldgr %f4, %r4
 ;   vrepg %v24, %v4, 0
 ;   br %r14
@@ -2029,7 +2029,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlrepf %v24, 0(%r2)
+;   vlrepf %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_i32x4_mem_little(i64) -> i32x4 {
@@ -2048,7 +2048,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrv %r4, 0(%r2)
+;   lrv %r4, 0(%r2) ; trap: heap_oob
 ;   vlvgf %v4, %r4, 0
 ;   vrepf %v24, %v4, 0
 ;   br %r14
@@ -2136,7 +2136,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlreph %v24, 0(%r2)
+;   vlreph %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_i16x8_mem_little(i64) -> i16x8 {
@@ -2155,7 +2155,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvh %r4, 0(%r2)
+;   lrvh %r4, 0(%r2) ; trap: heap_oob
 ;   vlvgh %v4, %r4, 0
 ;   vreph %v24, %v4, 0
 ;   br %r14
@@ -2243,7 +2243,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlrepb %v24, 0(%r2)
+;   vlrepb %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_i8x16_mem_little(i64) -> i8x16 {
@@ -2260,7 +2260,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlrepb %v24, 0(%r2)
+;   vlrepb %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_f64x2(f64) -> f64x2 {
@@ -2327,7 +2327,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlrepg %v24, 0(%r2)
+;   vlrepg %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_f64x2_mem_little(i64) -> f64x2 {
@@ -2346,7 +2346,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0(%r2)
+;   lrvg %r4, 0(%r2) ; trap: heap_oob
 ;   ldgr %f4, %r4
 ;   vrepg %v24, %v4, 0
 ;   br %r14
@@ -2415,7 +2415,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vlrepf %v24, 0(%r2)
+;   vlrepf %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %splat_f32x4_mem_little(i64) -> f32x4 {
@@ -2434,7 +2434,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrv %r4, 0(%r2)
+;   lrv %r4, 0(%r2) ; trap: heap_oob
 ;   vlvgf %v4, %r4, 0
 ;   vrepf %v24, %v4, 0
 ;   br %r14
@@ -2530,7 +2530,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   vleg %v24, 0(%r2), 0
+;   vleg %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %scalar_to_vector_i64x2_mem_little(i64) -> i64x2 {
@@ -2550,7 +2550,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   lrvg %r2, 0(%r2)
+;   lrvg %r2, 0(%r2) ; trap: heap_oob
 ;   vlvgg %v24, %r2, 0
 ;   br %r14
 
@@ -2647,7 +2647,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   vlef %v24, 0(%r2), 0
+;   vlef %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %scalar_to_vector_i32x4_mem_little(i64) -> i32x4 {
@@ -2667,7 +2667,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   lrv %r2, 0(%r2)
+;   lrv %r2, 0(%r2) ; trap: heap_oob
 ;   vlvgf %v24, %r2, 0
 ;   br %r14
 
@@ -2764,7 +2764,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   vleh %v24, 0(%r2), 0
+;   vleh %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %scalar_to_vector_i16x8_mem_little(i64) -> i16x8 {
@@ -2784,7 +2784,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   lrvh %r2, 0(%r2)
+;   lrvh %r2, 0(%r2) ; trap: heap_oob
 ;   vlvgh %v24, %r2, 0
 ;   br %r14
 
@@ -2881,7 +2881,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   vleb %v24, 0(%r2), 0
+;   vleb %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %scalar_to_vector_i8x16_mem_little(i64) -> i8x16 {
@@ -2900,7 +2900,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   vleb %v24, 0(%r2), 0
+;   vleb %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %scalar_to_vector_f64x2(f64) -> f64x2 {
@@ -2975,7 +2975,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   vleg %v24, 0(%r2), 0
+;   vleg %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %scalar_to_vector_f64x2_mem_little(i64) -> f64x2 {
@@ -2995,7 +2995,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   lrvg %r2, 0(%r2)
+;   lrvg %r2, 0(%r2) ; trap: heap_oob
 ;   vlvgg %v24, %r2, 0
 ;   br %r14
 
@@ -3073,7 +3073,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   vlef %v24, 0(%r2), 0
+;   vlef %v24, 0(%r2), 0 ; trap: heap_oob
 ;   br %r14
 
 function %scalar_to_vector_f32x4_mem_little(i64) -> f32x4 {
@@ -3093,7 +3093,7 @@ block0(v0: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vzero %v24
-;   lrv %r2, 0(%r2)
+;   lrv %r2, 0(%r2) ; trap: heap_oob
 ;   vlvgf %v24, %r2, 0
 ;   br %r14
 
diff --git a/cranelift/filetests/filetests/isa/s390x/vecmem-arch13.clif b/cranelift/filetests/filetests/isa/s390x/vecmem-arch13.clif
index 0f3c9aa70ad5..9ed2418ff949 100644
--- a/cranelift/filetests/filetests/isa/s390x/vecmem-arch13.clif
+++ b/cranelift/filetests/filetests/isa/s390x/vecmem-arch13.clif
@@ -15,7 +15,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld %f2, 0(%r2)
+;   ld %f2, 0(%r2) ; trap: heap_oob
 ;   vuplhb %v24, %v2
 ;   br %r14
 
@@ -33,7 +33,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld %f2, 0(%r2)
+;   ld %f2, 0(%r2) ; trap: heap_oob
 ;   vuplhh %v24, %v2
 ;   br %r14
 
@@ -51,7 +51,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld %f2, 0(%r2)
+;   ld %f2, 0(%r2) ; trap: heap_oob
 ;   vuplhf %v24, %v2
 ;   br %r14
 
@@ -69,7 +69,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld %f2, 0(%r2)
+;   ld %f2, 0(%r2) ; trap: heap_oob
 ;   vuphb %v24, %v2
 ;   br %r14
 
@@ -87,7 +87,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld %f2, 0(%r2)
+;   ld %f2, 0(%r2) ; trap: heap_oob
 ;   vuphh %v24, %v2
 ;   br %r14
 
@@ -105,7 +105,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld %f2, 0(%r2)
+;   ld %f2, 0(%r2) ; trap: heap_oob
 ;   vuphf %v24, %v2
 ;   br %r14
 
@@ -122,7 +122,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vl %v24, 0(%r2)
+;   vl %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %load_i16x8_big(i64) -> i16x8 {
@@ -138,7 +138,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vl %v24, 0(%r2)
+;   vl %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %load_i32x4_big(i64) -> i32x4 {
@@ -154,7 +154,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vl %v24, 0(%r2)
+;   vl %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %load_i64x2_big(i64) -> i64x2 {
@@ -170,7 +170,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vl %v24, 0(%r2)
+;   vl %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %load_i128_big(i64) -> i128 {
@@ -187,7 +187,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vl %v3, 0(%r3)
+;   vl %v3, 0(%r3) ; trap: heap_oob
 ;   vst %v3, 0(%r2)
 ;   br %r14
 
@@ -204,7 +204,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vl %v24, 0(%r2)
+;   vl %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %load_f64x2_big(i64) -> f64x2 {
@@ -220,7 +220,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vl %v24, 0(%r2)
+;   vl %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_i8x16_big(i8x16, i64) {
@@ -236,7 +236,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vst %v24, 0(%r2)
+;   vst %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_i16x8_big(i16x8, i64) {
@@ -252,7 +252,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vst %v24, 0(%r2)
+;   vst %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_i32x4_big(i32x4, i64) {
@@ -268,7 +268,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vst %v24, 0(%r2)
+;   vst %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_i64x2_big(i64x2, i64) {
@@ -284,7 +284,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vst %v24, 0(%r2)
+;   vst %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_i128_big(i128, i64) {
@@ -302,7 +302,7 @@ block0(v0: i128, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vl %v1, 0(%r2)
-;   vst %v1, 0(%r3)
+;   vst %v1, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %store_f32x4_big(f32x4, i64) {
@@ -318,7 +318,7 @@ block0(v0: f32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vst %v24, 0(%r2)
+;   vst %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_f64x2_big(f64x2, i64) {
@@ -334,7 +334,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vst %v24, 0(%r2)
+;   vst %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %uload8x8_little(i64) -> i16x8 {
@@ -351,7 +351,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld %f2, 0(%r2)
+;   ld %f2, 0(%r2) ; trap: heap_oob
 ;   vuplhb %v24, %v2
 ;   br %r14
 
@@ -370,7 +370,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld %f2, 0(%r2)
+;   ld %f2, 0(%r2) ; trap: heap_oob
 ;   verllh %v4, %v2, 8
 ;   vuplhh %v24, %v4
 ;   br %r14
@@ -390,7 +390,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x20
+;   .byte 0xe6, 0x20 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x00, 0x02
 ;   verllg %v4, %v2, 0x20
@@ -411,7 +411,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld %f2, 0(%r2)
+;   ld %f2, 0(%r2) ; trap: heap_oob
 ;   vuphb %v24, %v2
 ;   br %r14
 
@@ -430,7 +430,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld %f2, 0(%r2)
+;   ld %f2, 0(%r2) ; trap: heap_oob
 ;   verllh %v4, %v2, 8
 ;   vuphh %v24, %v4
 ;   br %r14
@@ -450,7 +450,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x20
+;   .byte 0xe6, 0x20 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x00, 0x02
 ;   verllg %v4, %v2, 0x20
@@ -470,7 +470,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vl %v24, 0(%r2)
+;   vl %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %load_i16x8_little(i64) -> i16x8 {
@@ -486,7 +486,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lr %r0, %r6
 ;   br %r14
@@ -504,7 +504,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ldr %f0, %f6
 ;   br %r14
@@ -522,7 +522,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ler %f0, %f6
 ;   br %r14
@@ -541,7 +541,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x30
+;   .byte 0xe6, 0x30 ; trap: heap_oob
 ;   lper %f0, %f0
 ;   sth %r0, 0x730(%r6, %r14)
 ;   lpdr %f0, %f0
@@ -561,7 +561,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ldr %f0, %f6
 ;   br %r14
@@ -579,7 +579,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ler %f0, %f6
 ;   br %r14
@@ -597,7 +597,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vst %v24, 0(%r2)
+;   vst %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_i16x8_little(i16x8, i64) {
@@ -613,7 +613,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lr %r0, %r14
 ;   br %r14
@@ -631,7 +631,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ldr %f0, %f14
 ;   br %r14
@@ -649,7 +649,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ler %f0, %f14
 ;   br %r14
@@ -669,7 +669,7 @@ block0(v0: i128, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vl %v1, 0(%r2)
-;   .byte 0xe6, 0x10
+;   .byte 0xe6, 0x10 ; trap: heap_oob
 ;   lper %f0, %f0
 ;   sth %r0, 0x7fe(%r14)
 
@@ -686,7 +686,7 @@ block0(v0: f32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ldr %f0, %f14
 ;   br %r14
@@ -704,7 +704,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ler %f0, %f14
 ;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/vecmem-le-lane-arch13.clif b/cranelift/filetests/filetests/isa/s390x/vecmem-le-lane-arch13.clif
index 08c6bd2ca2ba..b5f1fcfcb73a 100644
--- a/cranelift/filetests/filetests/isa/s390x/vecmem-le-lane-arch13.clif
+++ b/cranelift/filetests/filetests/isa/s390x/vecmem-le-lane-arch13.clif
@@ -15,7 +15,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x20
+;   .byte 0xe6, 0x20 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x00, 0x02
 ;   vuplhb %v24, %v2
@@ -36,7 +36,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x20
+;   .byte 0xe6, 0x20 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x00, 0x02
 ;   verllh %v4, %v2, 8
@@ -58,7 +58,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld %f2, 0(%r2)
+;   ld %f2, 0(%r2) ; trap: heap_oob
 ;   verllg %v4, %v2, 0x20
 ;   vuplhf %v24, %v4
 ;   br %r14
@@ -77,7 +77,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x20
+;   .byte 0xe6, 0x20 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x00, 0x02
 ;   vuphb %v24, %v2
@@ -98,7 +98,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x20
+;   .byte 0xe6, 0x20 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x00, 0x02
 ;   verllh %v4, %v2, 8
@@ -120,7 +120,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld %f2, 0(%r2)
+;   ld %f2, 0(%r2) ; trap: heap_oob
 ;   verllg %v4, %v2, 0x20
 ;   vuphf %v24, %v4
 ;   br %r14
@@ -138,7 +138,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lh %r0, 0x7fe(%r6)
 
@@ -155,7 +155,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lr %r0, %r7
 ;   br %r14
@@ -173,7 +173,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ldr %f0, %f7
 ;   br %r14
@@ -191,7 +191,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ler %f0, %f7
 ;   br %r14
@@ -209,7 +209,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ldr %f0, %f7
 ;   br %r14
@@ -227,7 +227,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ler %f0, %f7
 ;   br %r14
@@ -245,7 +245,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lh %r0, 0x7fe(%r14)
 
@@ -262,7 +262,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lr %r0, %r15
 ;   br %r14
@@ -280,7 +280,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ldr %f0, %f15
 ;   br %r14
@@ -298,7 +298,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ler %f0, %f15
 ;   br %r14
@@ -316,7 +316,7 @@ block0(v0: f32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ldr %f0, %f15
 ;   br %r14
@@ -334,7 +334,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   ler %f0, %f15
 ;   br %r14
@@ -353,7 +353,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x20
+;   .byte 0xe6, 0x20 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x00, 0x02
 ;   vuplhb %v24, %v2
@@ -373,7 +373,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x20
+;   .byte 0xe6, 0x20 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x00, 0x02
 ;   vuplhh %v24, %v2
@@ -393,7 +393,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x20
+;   .byte 0xe6, 0x20 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x00, 0x02
 ;   vuplhf %v24, %v2
@@ -413,7 +413,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x20
+;   .byte 0xe6, 0x20 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x00, 0x02
 ;   vuphb %v24, %v2
@@ -433,7 +433,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x20
+;   .byte 0xe6, 0x20 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x00, 0x02
 ;   vuphh %v24, %v2
@@ -453,7 +453,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x20
+;   .byte 0xe6, 0x20 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   .byte 0x00, 0x02
 ;   vuphf %v24, %v2
@@ -472,7 +472,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lh %r0, 0x7fe(%r6)
 
@@ -489,7 +489,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lh %r0, 0x7fe(%r6)
 
@@ -506,7 +506,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lh %r0, 0x7fe(%r6)
 
@@ -523,7 +523,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lh %r0, 0x7fe(%r6)
 
@@ -540,7 +540,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lh %r0, 0x7fe(%r6)
 
@@ -557,7 +557,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lh %r0, 0x7fe(%r6)
 
@@ -574,7 +574,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lh %r0, 0x7fe(%r14)
 
@@ -591,7 +591,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lh %r0, 0x7fe(%r14)
 
@@ -608,7 +608,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lh %r0, 0x7fe(%r14)
 
@@ -625,7 +625,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lh %r0, 0x7fe(%r14)
 
@@ -642,7 +642,7 @@ block0(v0: f32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lh %r0, 0x7fe(%r14)
 
@@ -659,7 +659,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   .byte 0xe6, 0x80
+;   .byte 0xe6, 0x80 ; trap: heap_oob
 ;   lpdr %f0, %f0
 ;   lh %r0, 0x7fe(%r14)
 
diff --git a/cranelift/filetests/filetests/isa/s390x/vecmem-le-lane.clif b/cranelift/filetests/filetests/isa/s390x/vecmem-le-lane.clif
index 266538f7046c..9e1792834047 100644
--- a/cranelift/filetests/filetests/isa/s390x/vecmem-le-lane.clif
+++ b/cranelift/filetests/filetests/isa/s390x/vecmem-le-lane.clif
@@ -16,7 +16,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0(%r2)
+;   lrvg %r4, 0(%r2) ; trap: heap_oob
 ;   ldgr %f4, %r4
 ;   vuplhb %v24, %v4
 ;   br %r14
@@ -37,7 +37,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0(%r2)
+;   lrvg %r4, 0(%r2) ; trap: heap_oob
 ;   ldgr %f4, %r4
 ;   verllh %v6, %v4, 8
 ;   vuplhh %v24, %v6
@@ -58,7 +58,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld %f2, 0(%r2)
+;   ld %f2, 0(%r2) ; trap: heap_oob
 ;   verllg %v4, %v2, 0x20
 ;   vuplhf %v24, %v4
 ;   br %r14
@@ -78,7 +78,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0(%r2)
+;   lrvg %r4, 0(%r2) ; trap: heap_oob
 ;   ldgr %f4, %r4
 ;   vuphb %v24, %v4
 ;   br %r14
@@ -99,7 +99,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0(%r2)
+;   lrvg %r4, 0(%r2) ; trap: heap_oob
 ;   ldgr %f4, %r4
 ;   verllh %v6, %v4, 8
 ;   vuphh %v24, %v6
@@ -120,7 +120,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld %f2, 0(%r2)
+;   ld %f2, 0(%r2) ; trap: heap_oob
 ;   verllg %v4, %v2, 0x20
 ;   vuphf %v24, %v4
 ;   br %r14
@@ -140,8 +140,8 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0(%r2)
-;   lrvg %r2, 8(%r2)
+;   lrvg %r4, 0(%r2) ; trap: heap_oob
+;   lrvg %r2, 8(%r2) ; trap: heap_oob
 ;   vlvgp %v24, %r2, %r4
 ;   br %r14
 
@@ -161,7 +161,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vl %v2, 0(%r2)
+;   vl %v2, 0(%r2) ; trap: heap_oob
 ;   vpdi %v4, %v2, %v2, 4
 ;   verllg %v6, %v4, 0x20
 ;   verllf %v24, %v6, 0x10
@@ -182,7 +182,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vl %v2, 0(%r2)
+;   vl %v2, 0(%r2) ; trap: heap_oob
 ;   vpdi %v4, %v2, %v2, 4
 ;   verllg %v24, %v4, 0x20
 ;   br %r14
@@ -201,7 +201,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vl %v2, 0(%r2)
+;   vl %v2, 0(%r2) ; trap: heap_oob
 ;   vpdi %v24, %v2, %v2, 4
 ;   br %r14
 
@@ -220,7 +220,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vl %v2, 0(%r2)
+;   vl %v2, 0(%r2) ; trap: heap_oob
 ;   vpdi %v4, %v2, %v2, 4
 ;   verllg %v24, %v4, 0x20
 ;   br %r14
@@ -239,7 +239,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vl %v2, 0(%r2)
+;   vl %v2, 0(%r2) ; trap: heap_oob
 ;   vpdi %v24, %v2, %v2, 4
 ;   br %r14
 
@@ -261,8 +261,8 @@ block0(v0: i8x16, v1: i64):
 ; block0: ; offset 0x0
 ;   vlgvg %r5, %v24, 1
 ;   vlgvg %r3, %v24, 0
-;   strvg %r5, 0(%r2)
-;   strvg %r3, 8(%r2)
+;   strvg %r5, 0(%r2) ; trap: heap_oob
+;   strvg %r3, 8(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_i16x8_big(i16x8, i64) wasmtime_system_v {
@@ -284,7 +284,7 @@ block0(v0: i16x8, v1: i64):
 ;   vpdi %v3, %v24, %v24, 4
 ;   verllg %v5, %v3, 0x20
 ;   verllf %v7, %v5, 0x10
-;   vst %v7, 0(%r2)
+;   vst %v7, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_i32x4_big(i32x4, i64) wasmtime_system_v {
@@ -304,7 +304,7 @@ block0(v0: i32x4, v1: i64):
 ; block0: ; offset 0x0
 ;   vpdi %v3, %v24, %v24, 4
 ;   verllg %v5, %v3, 0x20
-;   vst %v5, 0(%r2)
+;   vst %v5, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_i64x2_big(i64x2, i64) wasmtime_system_v {
@@ -322,7 +322,7 @@ block0(v0: i64x2, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vpdi %v3, %v24, %v24, 4
-;   vst %v3, 0(%r2)
+;   vst %v3, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_f32x4_big(f32x4, i64) wasmtime_system_v {
@@ -342,7 +342,7 @@ block0(v0: f32x4, v1: i64):
 ; block0: ; offset 0x0
 ;   vpdi %v3, %v24, %v24, 4
 ;   verllg %v5, %v3, 0x20
-;   vst %v5, 0(%r2)
+;   vst %v5, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_f64x2_big(f64x2, i64) wasmtime_system_v {
@@ -360,7 +360,7 @@ block0(v0: f64x2, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vpdi %v3, %v24, %v24, 4
-;   vst %v3, 0(%r2)
+;   vst %v3, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %uload8x8_little(i64) -> i16x8 wasmtime_system_v {
@@ -378,7 +378,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0(%r2)
+;   lrvg %r4, 0(%r2) ; trap: heap_oob
 ;   ldgr %f4, %r4
 ;   vuplhb %v24, %v4
 ;   br %r14
@@ -398,7 +398,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0(%r2)
+;   lrvg %r4, 0(%r2) ; trap: heap_oob
 ;   ldgr %f4, %r4
 ;   vuplhh %v24, %v4
 ;   br %r14
@@ -418,7 +418,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0(%r2)
+;   lrvg %r4, 0(%r2) ; trap: heap_oob
 ;   ldgr %f4, %r4
 ;   vuplhf %v24, %v4
 ;   br %r14
@@ -438,7 +438,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0(%r2)
+;   lrvg %r4, 0(%r2) ; trap: heap_oob
 ;   ldgr %f4, %r4
 ;   vuphb %v24, %v4
 ;   br %r14
@@ -458,7 +458,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0(%r2)
+;   lrvg %r4, 0(%r2) ; trap: heap_oob
 ;   ldgr %f4, %r4
 ;   vuphh %v24, %v4
 ;   br %r14
@@ -478,7 +478,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0(%r2)
+;   lrvg %r4, 0(%r2) ; trap: heap_oob
 ;   ldgr %f4, %r4
 ;   vuphf %v24, %v4
 ;   br %r14
@@ -498,8 +498,8 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0(%r2)
-;   lrvg %r2, 8(%r2)
+;   lrvg %r4, 0(%r2) ; trap: heap_oob
+;   lrvg %r2, 8(%r2) ; trap: heap_oob
 ;   vlvgp %v24, %r2, %r4
 ;   br %r14
 
@@ -518,8 +518,8 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0(%r2)
-;   lrvg %r2, 8(%r2)
+;   lrvg %r4, 0(%r2) ; trap: heap_oob
+;   lrvg %r2, 8(%r2) ; trap: heap_oob
 ;   vlvgp %v24, %r2, %r4
 ;   br %r14
 
@@ -538,8 +538,8 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0(%r2)
-;   lrvg %r2, 8(%r2)
+;   lrvg %r4, 0(%r2) ; trap: heap_oob
+;   lrvg %r2, 8(%r2) ; trap: heap_oob
 ;   vlvgp %v24, %r2, %r4
 ;   br %r14
 
@@ -558,8 +558,8 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0(%r2)
-;   lrvg %r2, 8(%r2)
+;   lrvg %r4, 0(%r2) ; trap: heap_oob
+;   lrvg %r2, 8(%r2) ; trap: heap_oob
 ;   vlvgp %v24, %r2, %r4
 ;   br %r14
 
@@ -578,8 +578,8 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0(%r2)
-;   lrvg %r2, 8(%r2)
+;   lrvg %r4, 0(%r2) ; trap: heap_oob
+;   lrvg %r2, 8(%r2) ; trap: heap_oob
 ;   vlvgp %v24, %r2, %r4
 ;   br %r14
 
@@ -598,8 +598,8 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0(%r2)
-;   lrvg %r2, 8(%r2)
+;   lrvg %r4, 0(%r2) ; trap: heap_oob
+;   lrvg %r2, 8(%r2) ; trap: heap_oob
 ;   vlvgp %v24, %r2, %r4
 ;   br %r14
 
@@ -619,8 +619,8 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r5, 0(%r3, %r2)
-;   lrvg %r3, 8(%r3, %r2)
+;   lrvg %r5, 0(%r3, %r2) ; trap: heap_oob
+;   lrvg %r3, 8(%r3, %r2) ; trap: heap_oob
 ;   vlvgp %v24, %r3, %r5
 ;   br %r14
 
@@ -639,8 +639,8 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0x80(%r2)
-;   lrvg %r2, 0x88(%r2)
+;   lrvg %r4, 0x80(%r2) ; trap: heap_oob
+;   lrvg %r2, 0x88(%r2) ; trap: heap_oob
 ;   vlvgp %v24, %r2, %r4
 ;   br %r14
 
@@ -662,8 +662,8 @@ block0(v0: i8x16, v1: i64):
 ; block0: ; offset 0x0
 ;   vlgvg %r5, %v24, 1
 ;   vlgvg %r3, %v24, 0
-;   strvg %r5, 0(%r2)
-;   strvg %r3, 8(%r2)
+;   strvg %r5, 0(%r2) ; trap: heap_oob
+;   strvg %r3, 8(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_i16x8_little(i16x8, i64) wasmtime_system_v {
@@ -684,8 +684,8 @@ block0(v0: i16x8, v1: i64):
 ; block0: ; offset 0x0
 ;   vlgvg %r5, %v24, 1
 ;   vlgvg %r3, %v24, 0
-;   strvg %r5, 0(%r2)
-;   strvg %r3, 8(%r2)
+;   strvg %r5, 0(%r2) ; trap: heap_oob
+;   strvg %r3, 8(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_i32x4_little(i32x4, i64) wasmtime_system_v {
@@ -706,8 +706,8 @@ block0(v0: i32x4, v1: i64):
 ; block0: ; offset 0x0
 ;   vlgvg %r5, %v24, 1
 ;   vlgvg %r3, %v24, 0
-;   strvg %r5, 0(%r2)
-;   strvg %r3, 8(%r2)
+;   strvg %r5, 0(%r2) ; trap: heap_oob
+;   strvg %r3, 8(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_i64x2_little(i64x2, i64) wasmtime_system_v {
@@ -728,8 +728,8 @@ block0(v0: i64x2, v1: i64):
 ; block0: ; offset 0x0
 ;   vlgvg %r5, %v24, 1
 ;   vlgvg %r3, %v24, 0
-;   strvg %r5, 0(%r2)
-;   strvg %r3, 8(%r2)
+;   strvg %r5, 0(%r2) ; trap: heap_oob
+;   strvg %r3, 8(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_f32x4_little(f32x4, i64) wasmtime_system_v {
@@ -750,8 +750,8 @@ block0(v0: f32x4, v1: i64):
 ; block0: ; offset 0x0
 ;   vlgvg %r5, %v24, 1
 ;   vlgvg %r3, %v24, 0
-;   strvg %r5, 0(%r2)
-;   strvg %r3, 8(%r2)
+;   strvg %r5, 0(%r2) ; trap: heap_oob
+;   strvg %r3, 8(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_f64x2_little(f64x2, i64) wasmtime_system_v {
@@ -772,8 +772,8 @@ block0(v0: f64x2, v1: i64):
 ; block0: ; offset 0x0
 ;   vlgvg %r5, %v24, 1
 ;   vlgvg %r3, %v24, 0
-;   strvg %r5, 0(%r2)
-;   strvg %r3, 8(%r2)
+;   strvg %r5, 0(%r2) ; trap: heap_oob
+;   strvg %r3, 8(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_f64x2_sum_little(f64x2, i64, i64) wasmtime_system_v {
@@ -795,8 +795,8 @@ block0(v0: f64x2, v1: i64, v2: i64):
 ; block0: ; offset 0x0
 ;   vlgvg %r5, %v24, 1
 ;   vlgvg %r4, %v24, 0
-;   strvg %r5, 0(%r3, %r2)
-;   strvg %r4, 8(%r3, %r2)
+;   strvg %r5, 0(%r3, %r2) ; trap: heap_oob
+;   strvg %r4, 8(%r3, %r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_f64x2_off_little(f64x2, i64) wasmtime_system_v {
@@ -817,7 +817,7 @@ block0(v0: f64x2, v1: i64):
 ; block0: ; offset 0x0
 ;   vlgvg %r5, %v24, 1
 ;   vlgvg %r3, %v24, 0
-;   strvg %r5, 0x80(%r2)
-;   strvg %r3, 0x88(%r2)
+;   strvg %r5, 0x80(%r2) ; trap: heap_oob
+;   strvg %r3, 0x88(%r2) ; trap: heap_oob
 ;   br %r14
 
diff --git a/cranelift/filetests/filetests/isa/s390x/vecmem.clif b/cranelift/filetests/filetests/isa/s390x/vecmem.clif
index 460d637538d7..490e384080f4 100644
--- a/cranelift/filetests/filetests/isa/s390x/vecmem.clif
+++ b/cranelift/filetests/filetests/isa/s390x/vecmem.clif
@@ -15,7 +15,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld %f2, 0(%r2)
+;   ld %f2, 0(%r2) ; trap: heap_oob
 ;   vuplhb %v24, %v2
 ;   br %r14
 
@@ -33,7 +33,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld %f2, 0(%r2)
+;   ld %f2, 0(%r2) ; trap: heap_oob
 ;   vuplhh %v24, %v2
 ;   br %r14
 
@@ -51,7 +51,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld %f2, 0(%r2)
+;   ld %f2, 0(%r2) ; trap: heap_oob
 ;   vuplhf %v24, %v2
 ;   br %r14
 
@@ -69,7 +69,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld %f2, 0(%r2)
+;   ld %f2, 0(%r2) ; trap: heap_oob
 ;   vuphb %v24, %v2
 ;   br %r14
 
@@ -87,7 +87,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld %f2, 0(%r2)
+;   ld %f2, 0(%r2) ; trap: heap_oob
 ;   vuphh %v24, %v2
 ;   br %r14
 
@@ -105,7 +105,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld %f2, 0(%r2)
+;   ld %f2, 0(%r2) ; trap: heap_oob
 ;   vuphf %v24, %v2
 ;   br %r14
 
@@ -122,7 +122,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vl %v24, 0(%r2)
+;   vl %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %load_i16x8_big(i64) -> i16x8 {
@@ -138,7 +138,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vl %v24, 0(%r2)
+;   vl %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %load_i32x4_big(i64) -> i32x4 {
@@ -154,7 +154,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vl %v24, 0(%r2)
+;   vl %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %load_i64x2_big(i64) -> i64x2 {
@@ -170,7 +170,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vl %v24, 0(%r2)
+;   vl %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %load_i128_big(i64) -> i128 {
@@ -187,7 +187,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vl %v3, 0(%r3)
+;   vl %v3, 0(%r3) ; trap: heap_oob
 ;   vst %v3, 0(%r2)
 ;   br %r14
 
@@ -204,7 +204,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vl %v24, 0(%r2)
+;   vl %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %load_f64x2_big(i64) -> f64x2 {
@@ -220,7 +220,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vl %v24, 0(%r2)
+;   vl %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_i8x16_big(i8x16, i64) {
@@ -236,7 +236,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vst %v24, 0(%r2)
+;   vst %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_i16x8_big(i16x8, i64) {
@@ -252,7 +252,7 @@ block0(v0: i16x8, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vst %v24, 0(%r2)
+;   vst %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_i32x4_big(i32x4, i64) {
@@ -268,7 +268,7 @@ block0(v0: i32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vst %v24, 0(%r2)
+;   vst %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_i64x2_big(i64x2, i64) {
@@ -284,7 +284,7 @@ block0(v0: i64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vst %v24, 0(%r2)
+;   vst %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_i128_big(i128, i64) {
@@ -302,7 +302,7 @@ block0(v0: i128, v1: i64):
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   vl %v1, 0(%r2)
-;   vst %v1, 0(%r3)
+;   vst %v1, 0(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %store_f32x4_big(f32x4, i64) {
@@ -318,7 +318,7 @@ block0(v0: f32x4, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vst %v24, 0(%r2)
+;   vst %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_f64x2_big(f64x2, i64) {
@@ -334,7 +334,7 @@ block0(v0: f64x2, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vst %v24, 0(%r2)
+;   vst %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %uload8x8_little(i64) -> i16x8 {
@@ -351,7 +351,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld %f2, 0(%r2)
+;   ld %f2, 0(%r2) ; trap: heap_oob
 ;   vuplhb %v24, %v2
 ;   br %r14
 
@@ -370,7 +370,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld %f2, 0(%r2)
+;   ld %f2, 0(%r2) ; trap: heap_oob
 ;   verllh %v4, %v2, 8
 ;   vuplhh %v24, %v4
 ;   br %r14
@@ -391,7 +391,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0(%r2)
+;   lrvg %r4, 0(%r2) ; trap: heap_oob
 ;   ldgr %f4, %r4
 ;   verllg %v6, %v4, 0x20
 ;   vuplhf %v24, %v6
@@ -411,7 +411,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld %f2, 0(%r2)
+;   ld %f2, 0(%r2) ; trap: heap_oob
 ;   vuphb %v24, %v2
 ;   br %r14
 
@@ -430,7 +430,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   ld %f2, 0(%r2)
+;   ld %f2, 0(%r2) ; trap: heap_oob
 ;   verllh %v4, %v2, 8
 ;   vuphh %v24, %v4
 ;   br %r14
@@ -451,7 +451,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0(%r2)
+;   lrvg %r4, 0(%r2) ; trap: heap_oob
 ;   ldgr %f4, %r4
 ;   verllg %v6, %v4, 0x20
 ;   vuphf %v24, %v6
@@ -470,7 +470,7 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vl %v24, 0(%r2)
+;   vl %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %load_i16x8_little(i64) -> i16x8 {
@@ -491,8 +491,8 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0(%r2)
-;   lrvg %r2, 8(%r2)
+;   lrvg %r4, 0(%r2) ; trap: heap_oob
+;   lrvg %r2, 8(%r2) ; trap: heap_oob
 ;   vlvgp %v6, %r2, %r4
 ;   vpdi %v16, %v6, %v6, 4
 ;   verllg %v18, %v16, 0x20
@@ -516,8 +516,8 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0(%r2)
-;   lrvg %r2, 8(%r2)
+;   lrvg %r4, 0(%r2) ; trap: heap_oob
+;   lrvg %r2, 8(%r2) ; trap: heap_oob
 ;   vlvgp %v6, %r2, %r4
 ;   vpdi %v16, %v6, %v6, 4
 ;   verllg %v24, %v16, 0x20
@@ -539,8 +539,8 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0(%r2)
-;   lrvg %r2, 8(%r2)
+;   lrvg %r4, 0(%r2) ; trap: heap_oob
+;   lrvg %r2, 8(%r2) ; trap: heap_oob
 ;   vlvgp %v6, %r2, %r4
 ;   vpdi %v24, %v6, %v6, 4
 ;   br %r14
@@ -561,8 +561,8 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r5, 0(%r3)
-;   lrvg %r3, 8(%r3)
+;   lrvg %r5, 0(%r3) ; trap: heap_oob
+;   lrvg %r3, 8(%r3) ; trap: heap_oob
 ;   vlvgp %v7, %r3, %r5
 ;   vst %v7, 0(%r2)
 ;   br %r14
@@ -584,8 +584,8 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0(%r2)
-;   lrvg %r2, 8(%r2)
+;   lrvg %r4, 0(%r2) ; trap: heap_oob
+;   lrvg %r2, 8(%r2) ; trap: heap_oob
 ;   vlvgp %v6, %r2, %r4
 ;   vpdi %v16, %v6, %v6, 4
 ;   verllg %v24, %v16, 0x20
@@ -607,8 +607,8 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0(%r2)
-;   lrvg %r2, 8(%r2)
+;   lrvg %r4, 0(%r2) ; trap: heap_oob
+;   lrvg %r2, 8(%r2) ; trap: heap_oob
 ;   vlvgp %v6, %r2, %r4
 ;   vpdi %v24, %v6, %v6, 4
 ;   br %r14
@@ -630,8 +630,8 @@ block0(v0: i64, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r5, 0(%r3, %r2)
-;   lrvg %r3, 8(%r3, %r2)
+;   lrvg %r5, 0(%r3, %r2) ; trap: heap_oob
+;   lrvg %r3, 8(%r3, %r2) ; trap: heap_oob
 ;   vlvgp %v7, %r3, %r5
 ;   vpdi %v24, %v7, %v7, 4
 ;   br %r14
@@ -652,8 +652,8 @@ block0(v0: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   lrvg %r4, 0x80(%r2)
-;   lrvg %r2, 0x88(%r2)
+;   lrvg %r4, 0x80(%r2) ; trap: heap_oob
+;   lrvg %r2, 0x88(%r2) ; trap: heap_oob
 ;   vlvgp %v6, %r2, %r4
 ;   vpdi %v24, %v6, %v6, 4
 ;   br %r14
@@ -671,7 +671,7 @@ block0(v0: i8x16, v1: i64):
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
-;   vst %v24, 0(%r2)
+;   vst %v24, 0(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_i16x8_little(i16x8, i64) {
@@ -698,8 +698,8 @@ block0(v0: i16x8, v1: i64):
 ;   verllf %v7, %v5, 0x10
 ;   vlgvg %r3, %v7, 1
 ;   lgdr %r5, %f7
-;   strvg %r3, 0(%r2)
-;   strvg %r5, 8(%r2)
+;   strvg %r3, 0(%r2) ; trap: heap_oob
+;   strvg %r5, 8(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_i32x4_little(i32x4, i64) {
@@ -724,8 +724,8 @@ block0(v0: i32x4, v1: i64):
 ;   verllg %v5, %v3, 0x20
 ;   vlgvg %r5, %v5, 1
 ;   lgdr %r3, %f5
-;   strvg %r5, 0(%r2)
-;   strvg %r3, 8(%r2)
+;   strvg %r5, 0(%r2) ; trap: heap_oob
+;   strvg %r3, 8(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_i64x2_little(i64x2, i64) {
@@ -748,8 +748,8 @@ block0(v0: i64x2, v1: i64):
 ;   vpdi %v3, %v24, %v24, 4
 ;   vlgvg %r3, %v3, 1
 ;   lgdr %r5, %f3
-;   strvg %r3, 0(%r2)
-;   strvg %r5, 8(%r2)
+;   strvg %r3, 0(%r2) ; trap: heap_oob
+;   strvg %r5, 8(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_i128_little(i128, i64) {
@@ -772,8 +772,8 @@ block0(v0: i128, v1: i64):
 ;   vl %v1, 0(%r2)
 ;   vlgvg %r2, %v1, 1
 ;   lgdr %r4, %f1
-;   strvg %r2, 0(%r3)
-;   strvg %r4, 8(%r3)
+;   strvg %r2, 0(%r3) ; trap: heap_oob
+;   strvg %r4, 8(%r3) ; trap: heap_oob
 ;   br %r14
 
 function %store_f32x4_little(f32x4, i64) {
@@ -798,8 +798,8 @@ block0(v0: f32x4, v1: i64):
 ;   verllg %v5, %v3, 0x20
 ;   vlgvg %r5, %v5, 1
 ;   lgdr %r3, %f5
-;   strvg %r5, 0(%r2)
-;   strvg %r3, 8(%r2)
+;   strvg %r5, 0(%r2) ; trap: heap_oob
+;   strvg %r3, 8(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_f64x2_little(f64x2, i64) {
@@ -822,8 +822,8 @@ block0(v0: f64x2, v1: i64):
 ;   vpdi %v3, %v24, %v24, 4
 ;   vlgvg %r3, %v3, 1
 ;   lgdr %r5, %f3
-;   strvg %r3, 0(%r2)
-;   strvg %r5, 8(%r2)
+;   strvg %r3, 0(%r2) ; trap: heap_oob
+;   strvg %r5, 8(%r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_f64x2_sum_little(f64x2, i64, i64) {
@@ -847,8 +847,8 @@ block0(v0: f64x2, v1: i64, v2: i64):
 ;   vpdi %v4, %v24, %v24, 4
 ;   vlgvg %r5, %v4, 1
 ;   lgdr %r4, %f4
-;   strvg %r5, 0(%r3, %r2)
-;   strvg %r4, 8(%r3, %r2)
+;   strvg %r5, 0(%r3, %r2) ; trap: heap_oob
+;   strvg %r4, 8(%r3, %r2) ; trap: heap_oob
 ;   br %r14
 
 function %store_f64x2_off_little(f64x2, i64) {
@@ -871,7 +871,7 @@ block0(v0: f64x2, v1: i64):
 ;   vpdi %v3, %v24, %v24, 4
 ;   vlgvg %r3, %v3, 1
 ;   lgdr %r5, %f3
-;   strvg %r3, 0x80(%r2)
-;   strvg %r5, 0x88(%r2)
+;   strvg %r3, 0x80(%r2) ; trap: heap_oob
+;   strvg %r5, 0x88(%r2) ; trap: heap_oob
 ;   br %r14
 
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index bce6ac9ab2c5..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r5, %r2
-;;   lghi %r2, -4
-;;   ag %r2, 8(%r4)
-;;   clgr %r5, %r2
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lg %r4, 0(%r4)
-;;   strv %r3, 0(%r5,%r4)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r5, %r2
-;;   lghi %r4, -4
-;;   ag %r4, 8(%r3)
-;;   clgr %r5, %r4
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lg %r3, 0(%r3)
-;;   lrv %r2, 0(%r5,%r3)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 709818f96383..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,81 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r4
-;;   llgfr %r4, %r2
-;;   lghi %r2, -4100
-;;   ag %r2, 8(%r5)
-;;   clgr %r4, %r2
-;;   jgh label3 ; jg label1
-;; block1:
-;;   ag %r4, 0(%r5)
-;;   lghi %r5, 4096
-;;   strv %r3, 0(%r5,%r4)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r4, %r3
-;;   llgfr %r3, %r2
-;;   lghi %r2, -4100
-;;   lgr %r5, %r4
-;;   ag %r2, 8(%r5)
-;;   clgr %r3, %r2
-;;   jgh label3 ; jg label1
-;; block1:
-;;   ag %r3, 0(%r5)
-;;   lghi %r4, 4096
-;;   lrv %r2, 0(%r4,%r3)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 92de57a3f35a..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,99 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r7, %r15, 56(%r15)
-;;   unwind SaveReg { clobber_offset: 56, reg: p7i }
-;;   unwind SaveReg { clobber_offset: 64, reg: p8i }
-;;   unwind SaveReg { clobber_offset: 72, reg: p9i }
-;;   unwind SaveReg { clobber_offset: 80, reg: p10i }
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r7, %r4
-;;   llgfr %r4, %r2
-;;   lgr %r5, %r2
-;;   llilf %r2, 4294901764
-;;   algfr %r2, %r5
-;;   jgnle .+2 # trap=heap_oob
-;;   lgr %r5, %r7
-;;   lg %r7, 8(%r5)
-;;   clgr %r2, %r7
-;;   jgh label3 ; jg label1
-;; block1:
-;;   ag %r4, 0(%r5)
-;;   llilh %r2, 65535
-;;   strv %r3, 0(%r2,%r4)
-;;   jg label2
-;; block2:
-;;   lmg %r7, %r15, 56(%r15)
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r3
-;;   llgfr %r3, %r2
-;;   lgr %r4, %r2
-;;   llilf %r2, 4294901764
-;;   algfr %r2, %r4
-;;   jgnle .+2 # trap=heap_oob
-;;   lgr %r4, %r5
-;;   lg %r5, 8(%r4)
-;;   clgr %r2, %r5
-;;   jgh label3 ; jg label1
-;; block1:
-;;   ag %r3, 0(%r4)
-;;   llilh %r2, 65535
-;;   lrv %r2, 0(%r2,%r3)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 8d2f03cd770a..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r4
-;;   llgfr %r4, %r2
-;;   lgr %r2, %r5
-;;   lg %r5, 8(%r2)
-;;   clgr %r4, %r5
-;;   jghe label3 ; jg label1
-;; block1:
-;;   lg %r2, 0(%r2)
-;;   stc %r3, 0(%r4,%r2)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r4, %r2
-;;   lg %r5, 8(%r3)
-;;   clgr %r4, %r5
-;;   jghe label3 ; jg label1
-;; block1:
-;;   lg %r2, 0(%r3)
-;;   llc %r2, 0(%r4,%r2)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 2b7e0f548c57..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,81 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r4
-;;   llgfr %r4, %r2
-;;   lghi %r2, -4097
-;;   ag %r2, 8(%r5)
-;;   clgr %r4, %r2
-;;   jgh label3 ; jg label1
-;; block1:
-;;   ag %r4, 0(%r5)
-;;   lghi %r5, 4096
-;;   stc %r3, 0(%r5,%r4)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r4, %r3
-;;   llgfr %r3, %r2
-;;   lghi %r2, -4097
-;;   lgr %r5, %r4
-;;   ag %r2, 8(%r5)
-;;   clgr %r3, %r2
-;;   jgh label3 ; jg label1
-;; block1:
-;;   ag %r3, 0(%r5)
-;;   lghi %r4, 4096
-;;   llc %r2, 0(%r4,%r3)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 559b03c3e981..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,99 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r7, %r15, 56(%r15)
-;;   unwind SaveReg { clobber_offset: 56, reg: p7i }
-;;   unwind SaveReg { clobber_offset: 64, reg: p8i }
-;;   unwind SaveReg { clobber_offset: 72, reg: p9i }
-;;   unwind SaveReg { clobber_offset: 80, reg: p10i }
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r7, %r4
-;;   llgfr %r4, %r2
-;;   lgr %r5, %r2
-;;   llilf %r2, 4294901761
-;;   algfr %r2, %r5
-;;   jgnle .+2 # trap=heap_oob
-;;   lgr %r5, %r7
-;;   lg %r7, 8(%r5)
-;;   clgr %r2, %r7
-;;   jgh label3 ; jg label1
-;; block1:
-;;   ag %r4, 0(%r5)
-;;   llilh %r2, 65535
-;;   stc %r3, 0(%r2,%r4)
-;;   jg label2
-;; block2:
-;;   lmg %r7, %r15, 56(%r15)
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r3
-;;   llgfr %r3, %r2
-;;   lgr %r4, %r2
-;;   llilf %r2, 4294901761
-;;   algfr %r2, %r4
-;;   jgnle .+2 # trap=heap_oob
-;;   lgr %r4, %r5
-;;   lg %r5, 8(%r4)
-;;   clgr %r2, %r5
-;;   jgh label3 ; jg label1
-;; block1:
-;;   ag %r3, 0(%r4)
-;;   llilh %r2, 65535
-;;   llc %r2, 0(%r2,%r3)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 43b77d818c52..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,89 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r6, %r15, 48(%r15)
-;;   unwind SaveReg { clobber_offset: 48, reg: p6i }
-;;   unwind SaveReg { clobber_offset: 56, reg: p7i }
-;;   unwind SaveReg { clobber_offset: 64, reg: p8i }
-;;   unwind SaveReg { clobber_offset: 72, reg: p9i }
-;;   unwind SaveReg { clobber_offset: 80, reg: p10i }
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r4
-;;   llgfr %r4, %r2
-;;   lghi %r2, -4
-;;   lgr %r9, %r5
-;;   ag %r2, 8(%r9)
-;;   lgr %r5, %r4
-;;   ag %r5, 0(%r9)
-;;   lghi %r6, 0
-;;   clgr %r4, %r2
-;;   locgrh %r5, %r6
-;;   strv %r3, 0(%r5)
-;;   jg label1
-;; block1:
-;;   lmg %r6, %r15, 48(%r15)
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r4, %r3
-;;   llgfr %r3, %r2
-;;   lghi %r2, -4
-;;   ag %r2, 8(%r4)
-;;   lgr %r5, %r3
-;;   ag %r5, 0(%r4)
-;;   lghi %r4, 0
-;;   clgr %r3, %r2
-;;   locgrh %r5, %r4
-;;   lrv %r2, 0(%r5)
-;;   jg label1
-;; block1:
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 81e0453db504..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,88 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r7, %r15, 56(%r15)
-;;   unwind SaveReg { clobber_offset: 56, reg: p7i }
-;;   unwind SaveReg { clobber_offset: 64, reg: p8i }
-;;   unwind SaveReg { clobber_offset: 72, reg: p9i }
-;;   unwind SaveReg { clobber_offset: 80, reg: p10i }
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r2, %r2
-;;   lghi %r5, -4100
-;;   ag %r5, 8(%r4)
-;;   lgr %r7, %r2
-;;   ag %r7, 0(%r4)
-;;   aghik %r4, %r7, 4096
-;;   lghi %r7, 0
-;;   clgr %r2, %r5
-;;   locgrh %r4, %r7
-;;   strv %r3, 0(%r4)
-;;   jg label1
-;; block1:
-;;   lmg %r7, %r15, 56(%r15)
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r3
-;;   llgfr %r4, %r2
-;;   lghi %r3, -4100
-;;   ag %r3, 8(%r5)
-;;   lgr %r2, %r4
-;;   ag %r2, 0(%r5)
-;;   aghi %r2, 4096
-;;   lghi %r5, 0
-;;   clgr %r4, %r3
-;;   locgrh %r2, %r5
-;;   lrv %r2, 0(%r2)
-;;   jg label1
-;; block1:
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 5d1c7f1916ee..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,92 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r10, %r15, 80(%r15)
-;;   unwind SaveReg { clobber_offset: 80, reg: p10i }
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r14, %r2
-;;   llilf %r5, 4294901764
-;;   algfr %r5, %r2
-;;   jgnle .+2 # trap=heap_oob
-;;   lg %r10, 8(%r4)
-;;   ag %r14, 0(%r4)
-;;   llilh %r4, 65535
-;;   agrk %r2, %r14, %r4
-;;   lghi %r4, 0
-;;   clgr %r5, %r10
-;;   locgrh %r2, %r4
-;;   strv %r3, 0(%r2)
-;;   jg label1
-;; block1:
-;;   lmg %r10, %r15, 80(%r15)
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r14, %r15, 112(%r15)
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r14, %r2
-;;   llilf %r5, 4294901764
-;;   algfr %r5, %r2
-;;   jgnle .+2 # trap=heap_oob
-;;   lg %r4, 8(%r3)
-;;   ag %r14, 0(%r3)
-;;   llilh %r3, 65535
-;;   agrk %r2, %r14, %r3
-;;   lghi %r3, 0
-;;   clgr %r5, %r4
-;;   locgrh %r2, %r3
-;;   lrv %r2, 0(%r2)
-;;   jg label1
-;; block1:
-;;   lmg %r14, %r15, 112(%r15)
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 334a42b8eee9..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,83 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r8, %r15, 64(%r15)
-;;   unwind SaveReg { clobber_offset: 64, reg: p8i }
-;;   unwind SaveReg { clobber_offset: 72, reg: p9i }
-;;   unwind SaveReg { clobber_offset: 80, reg: p10i }
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r2, %r2
-;;   lg %r5, 8(%r4)
-;;   lgr %r8, %r4
-;;   lgr %r4, %r2
-;;   ag %r4, 0(%r8)
-;;   lghi %r14, 0
-;;   clgr %r2, %r5
-;;   locgrhe %r4, %r14
-;;   stc %r3, 0(%r4)
-;;   jg label1
-;; block1:
-;;   lmg %r8, %r15, 64(%r15)
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r2, %r2
-;;   lg %r5, 8(%r3)
-;;   lgr %r4, %r2
-;;   ag %r4, 0(%r3)
-;;   lghi %r3, 0
-;;   clgr %r2, %r5
-;;   locgrhe %r4, %r3
-;;   llc %r2, 0(%r4)
-;;   jg label1
-;; block1:
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 6b8578881d42..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,88 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r7, %r15, 56(%r15)
-;;   unwind SaveReg { clobber_offset: 56, reg: p7i }
-;;   unwind SaveReg { clobber_offset: 64, reg: p8i }
-;;   unwind SaveReg { clobber_offset: 72, reg: p9i }
-;;   unwind SaveReg { clobber_offset: 80, reg: p10i }
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r2, %r2
-;;   lghi %r5, -4097
-;;   ag %r5, 8(%r4)
-;;   lgr %r7, %r2
-;;   ag %r7, 0(%r4)
-;;   aghik %r4, %r7, 4096
-;;   lghi %r7, 0
-;;   clgr %r2, %r5
-;;   locgrh %r4, %r7
-;;   stc %r3, 0(%r4)
-;;   jg label1
-;; block1:
-;;   lmg %r7, %r15, 56(%r15)
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r3
-;;   llgfr %r4, %r2
-;;   lghi %r3, -4097
-;;   ag %r3, 8(%r5)
-;;   lgr %r2, %r4
-;;   ag %r2, 0(%r5)
-;;   aghi %r2, 4096
-;;   lghi %r5, 0
-;;   clgr %r4, %r3
-;;   locgrh %r2, %r5
-;;   llc %r2, 0(%r2)
-;;   jg label1
-;; block1:
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 93550319358b..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,92 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r10, %r15, 80(%r15)
-;;   unwind SaveReg { clobber_offset: 80, reg: p10i }
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r14, %r2
-;;   llilf %r5, 4294901761
-;;   algfr %r5, %r2
-;;   jgnle .+2 # trap=heap_oob
-;;   lg %r10, 8(%r4)
-;;   ag %r14, 0(%r4)
-;;   llilh %r4, 65535
-;;   agrk %r2, %r14, %r4
-;;   lghi %r4, 0
-;;   clgr %r5, %r10
-;;   locgrh %r2, %r4
-;;   stc %r3, 0(%r2)
-;;   jg label1
-;; block1:
-;;   lmg %r10, %r15, 80(%r15)
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r14, %r15, 112(%r15)
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r14, %r2
-;;   llilf %r5, 4294901761
-;;   algfr %r5, %r2
-;;   jgnle .+2 # trap=heap_oob
-;;   lg %r4, 8(%r3)
-;;   ag %r14, 0(%r3)
-;;   llilh %r3, 65535
-;;   agrk %r2, %r14, %r3
-;;   lghi %r3, 0
-;;   clgr %r5, %r4
-;;   locgrh %r2, %r3
-;;   llc %r2, 0(%r2)
-;;   jg label1
-;; block1:
-;;   lmg %r14, %r15, 112(%r15)
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index a746643e22fa..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r4
-;;   llgfr %r4, %r2
-;;   lgr %r2, %r5
-;;   lg %r5, 8(%r2)
-;;   clgr %r4, %r5
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lg %r2, 0(%r2)
-;;   strv %r3, 0(%r4,%r2)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r4, %r2
-;;   lg %r5, 8(%r3)
-;;   clgr %r4, %r5
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lg %r2, 0(%r3)
-;;   lrv %r2, 0(%r4,%r2)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 898fac6ffcc6..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r4
-;;   llgfr %r4, %r2
-;;   lg %r2, 8(%r5)
-;;   clgr %r4, %r2
-;;   jgh label3 ; jg label1
-;; block1:
-;;   ag %r4, 0(%r5)
-;;   lghi %r5, 4096
-;;   strv %r3, 0(%r5,%r4)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r4, %r3
-;;   llgfr %r3, %r2
-;;   lg %r5, 8(%r4)
-;;   clgr %r3, %r5
-;;   jgh label3 ; jg label1
-;; block1:
-;;   ag %r3, 0(%r4)
-;;   lghi %r4, 4096
-;;   lrv %r2, 0(%r4,%r3)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 47d8b57e247f..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r4
-;;   llgfr %r4, %r2
-;;   lg %r2, 8(%r5)
-;;   clgr %r4, %r2
-;;   jgh label3 ; jg label1
-;; block1:
-;;   ag %r4, 0(%r5)
-;;   llilh %r5, 65535
-;;   strv %r3, 0(%r5,%r4)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r4, %r3
-;;   llgfr %r3, %r2
-;;   lg %r5, 8(%r4)
-;;   clgr %r3, %r5
-;;   jgh label3 ; jg label1
-;; block1:
-;;   ag %r3, 0(%r4)
-;;   llilh %r4, 65535
-;;   lrv %r2, 0(%r4,%r3)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 306699d99f7c..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r4
-;;   llgfr %r4, %r2
-;;   lgr %r2, %r5
-;;   lg %r5, 8(%r2)
-;;   clgr %r4, %r5
-;;   jghe label3 ; jg label1
-;; block1:
-;;   lg %r2, 0(%r2)
-;;   stc %r3, 0(%r4,%r2)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r4, %r2
-;;   lg %r5, 8(%r3)
-;;   clgr %r4, %r5
-;;   jghe label3 ; jg label1
-;; block1:
-;;   lg %r2, 0(%r3)
-;;   llc %r2, 0(%r4,%r2)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index d3bac7e16fac..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r4
-;;   llgfr %r4, %r2
-;;   lg %r2, 8(%r5)
-;;   clgr %r4, %r2
-;;   jgh label3 ; jg label1
-;; block1:
-;;   ag %r4, 0(%r5)
-;;   lghi %r5, 4096
-;;   stc %r3, 0(%r5,%r4)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r4, %r3
-;;   llgfr %r3, %r2
-;;   lg %r5, 8(%r4)
-;;   clgr %r3, %r5
-;;   jgh label3 ; jg label1
-;; block1:
-;;   ag %r3, 0(%r4)
-;;   lghi %r4, 4096
-;;   llc %r2, 0(%r4,%r3)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 50469a1d1b84..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r4
-;;   llgfr %r4, %r2
-;;   lg %r2, 8(%r5)
-;;   clgr %r4, %r2
-;;   jgh label3 ; jg label1
-;; block1:
-;;   ag %r4, 0(%r5)
-;;   llilh %r5, 65535
-;;   stc %r3, 0(%r5,%r4)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r4, %r3
-;;   llgfr %r3, %r2
-;;   lg %r5, 8(%r4)
-;;   clgr %r3, %r5
-;;   jgh label3 ; jg label1
-;; block1:
-;;   ag %r3, 0(%r4)
-;;   llilh %r4, 65535
-;;   llc %r2, 0(%r4,%r3)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 3f0878a849f0..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,83 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r8, %r15, 64(%r15)
-;;   unwind SaveReg { clobber_offset: 64, reg: p8i }
-;;   unwind SaveReg { clobber_offset: 72, reg: p9i }
-;;   unwind SaveReg { clobber_offset: 80, reg: p10i }
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r2, %r2
-;;   lg %r5, 8(%r4)
-;;   lgr %r8, %r4
-;;   lgr %r4, %r2
-;;   ag %r4, 0(%r8)
-;;   lghi %r14, 0
-;;   clgr %r2, %r5
-;;   locgrh %r4, %r14
-;;   strv %r3, 0(%r4)
-;;   jg label1
-;; block1:
-;;   lmg %r8, %r15, 64(%r15)
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r2, %r2
-;;   lg %r5, 8(%r3)
-;;   lgr %r4, %r2
-;;   ag %r4, 0(%r3)
-;;   lghi %r3, 0
-;;   clgr %r2, %r5
-;;   locgrh %r4, %r3
-;;   lrv %r2, 0(%r4)
-;;   jg label1
-;; block1:
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 2d0a997c86de..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,86 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r6, %r15, 48(%r15)
-;;   unwind SaveReg { clobber_offset: 48, reg: p6i }
-;;   unwind SaveReg { clobber_offset: 56, reg: p7i }
-;;   unwind SaveReg { clobber_offset: 64, reg: p8i }
-;;   unwind SaveReg { clobber_offset: 72, reg: p9i }
-;;   unwind SaveReg { clobber_offset: 80, reg: p10i }
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r6, %r2
-;;   lg %r5, 8(%r4)
-;;   lgr %r2, %r6
-;;   ag %r2, 0(%r4)
-;;   aghi %r2, 4096
-;;   lghi %r4, 0
-;;   clgr %r6, %r5
-;;   locgrh %r2, %r4
-;;   strv %r3, 0(%r2)
-;;   jg label1
-;; block1:
-;;   lmg %r6, %r15, 48(%r15)
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r2, %r2
-;;   lg %r4, 8(%r3)
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r3)
-;;   aghi %r5, 4096
-;;   lghi %r3, 0
-;;   clgr %r2, %r4
-;;   locgrh %r5, %r3
-;;   lrv %r2, 0(%r5)
-;;   jg label1
-;; block1:
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index d013a5d8a469..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,87 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r7, %r15, 56(%r15)
-;;   unwind SaveReg { clobber_offset: 56, reg: p7i }
-;;   unwind SaveReg { clobber_offset: 64, reg: p8i }
-;;   unwind SaveReg { clobber_offset: 72, reg: p9i }
-;;   unwind SaveReg { clobber_offset: 80, reg: p10i }
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r7, %r2
-;;   lg %r5, 8(%r4)
-;;   lgr %r2, %r7
-;;   ag %r2, 0(%r4)
-;;   llilh %r4, 65535
-;;   agr %r2, %r4
-;;   lghi %r4, 0
-;;   clgr %r7, %r5
-;;   locgrh %r2, %r4
-;;   strv %r3, 0(%r2)
-;;   jg label1
-;; block1:
-;;   lmg %r7, %r15, 56(%r15)
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r4, %r2
-;;   lg %r5, 8(%r3)
-;;   lgr %r2, %r4
-;;   ag %r2, 0(%r3)
-;;   llilh %r3, 65535
-;;   agr %r2, %r3
-;;   lghi %r3, 0
-;;   clgr %r4, %r5
-;;   locgrh %r2, %r3
-;;   lrv %r2, 0(%r2)
-;;   jg label1
-;; block1:
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 47f15780d729..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,83 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r8, %r15, 64(%r15)
-;;   unwind SaveReg { clobber_offset: 64, reg: p8i }
-;;   unwind SaveReg { clobber_offset: 72, reg: p9i }
-;;   unwind SaveReg { clobber_offset: 80, reg: p10i }
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r2, %r2
-;;   lg %r5, 8(%r4)
-;;   lgr %r8, %r4
-;;   lgr %r4, %r2
-;;   ag %r4, 0(%r8)
-;;   lghi %r14, 0
-;;   clgr %r2, %r5
-;;   locgrhe %r4, %r14
-;;   stc %r3, 0(%r4)
-;;   jg label1
-;; block1:
-;;   lmg %r8, %r15, 64(%r15)
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r2, %r2
-;;   lg %r5, 8(%r3)
-;;   lgr %r4, %r2
-;;   ag %r4, 0(%r3)
-;;   lghi %r3, 0
-;;   clgr %r2, %r5
-;;   locgrhe %r4, %r3
-;;   llc %r2, 0(%r4)
-;;   jg label1
-;; block1:
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 342e1136474d..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,86 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r6, %r15, 48(%r15)
-;;   unwind SaveReg { clobber_offset: 48, reg: p6i }
-;;   unwind SaveReg { clobber_offset: 56, reg: p7i }
-;;   unwind SaveReg { clobber_offset: 64, reg: p8i }
-;;   unwind SaveReg { clobber_offset: 72, reg: p9i }
-;;   unwind SaveReg { clobber_offset: 80, reg: p10i }
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r6, %r2
-;;   lg %r5, 8(%r4)
-;;   lgr %r2, %r6
-;;   ag %r2, 0(%r4)
-;;   aghi %r2, 4096
-;;   lghi %r4, 0
-;;   clgr %r6, %r5
-;;   locgrh %r2, %r4
-;;   stc %r3, 0(%r2)
-;;   jg label1
-;; block1:
-;;   lmg %r6, %r15, 48(%r15)
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r2, %r2
-;;   lg %r4, 8(%r3)
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r3)
-;;   aghi %r5, 4096
-;;   lghi %r3, 0
-;;   clgr %r2, %r4
-;;   locgrh %r5, %r3
-;;   llc %r2, 0(%r5)
-;;   jg label1
-;; block1:
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 4a9bb7442205..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,87 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r7, %r15, 56(%r15)
-;;   unwind SaveReg { clobber_offset: 56, reg: p7i }
-;;   unwind SaveReg { clobber_offset: 64, reg: p8i }
-;;   unwind SaveReg { clobber_offset: 72, reg: p9i }
-;;   unwind SaveReg { clobber_offset: 80, reg: p10i }
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r7, %r2
-;;   lg %r5, 8(%r4)
-;;   lgr %r2, %r7
-;;   ag %r2, 0(%r4)
-;;   llilh %r4, 65535
-;;   agr %r2, %r4
-;;   lghi %r4, 0
-;;   clgr %r7, %r5
-;;   locgrh %r2, %r4
-;;   stc %r3, 0(%r2)
-;;   jg label1
-;; block1:
-;;   lmg %r7, %r15, 56(%r15)
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r4, %r2
-;;   lg %r5, 8(%r3)
-;;   lgr %r2, %r4
-;;   ag %r2, 0(%r3)
-;;   llilh %r3, 65535
-;;   agr %r2, %r3
-;;   lghi %r3, 0
-;;   clgr %r4, %r5
-;;   locgrh %r2, %r3
-;;   llc %r2, 0(%r2)
-;;   jg label1
-;; block1:
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 7c7974d27da6..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lghi %r5, -4
-;;   ag %r5, 8(%r4)
-;;   clgr %r2, %r5
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lg %r4, 0(%r4)
-;;   strv %r3, 0(%r2,%r4)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lghi %r4, -4
-;;   ag %r4, 8(%r3)
-;;   clgr %r2, %r4
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lg %r3, 0(%r3)
-;;   lrv %r2, 0(%r2,%r3)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index daeb205fa0ba..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lghi %r5, -4100
-;;   ag %r5, 8(%r4)
-;;   clgr %r2, %r5
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r4)
-;;   lghi %r4, 4096
-;;   strv %r3, 0(%r4,%r5)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lghi %r4, -4100
-;;   ag %r4, 8(%r3)
-;;   clgr %r2, %r4
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lgr %r4, %r2
-;;   ag %r4, 0(%r3)
-;;   lghi %r3, 4096
-;;   lrv %r2, 0(%r3,%r4)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 3c280d330546..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,86 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r14, %r15, 112(%r15)
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r2
-;;   algfi %r5, 4294901764
-;;   jgnle .+2 # trap=heap_oob
-;;   lg %r14, 8(%r4)
-;;   clgr %r5, %r14
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r4)
-;;   llilh %r4, 65535
-;;   strv %r3, 0(%r4,%r5)
-;;   jg label2
-;; block2:
-;;   lmg %r14, %r15, 112(%r15)
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r2
-;;   algfi %r5, 4294901764
-;;   jgnle .+2 # trap=heap_oob
-;;   lg %r4, 8(%r3)
-;;   clgr %r5, %r4
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lgr %r4, %r2
-;;   ag %r4, 0(%r3)
-;;   llilh %r5, 65535
-;;   lrv %r2, 0(%r5,%r4)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 2a46594c5cba..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lg %r5, 8(%r4)
-;;   clgr %r2, %r5
-;;   jghe label3 ; jg label1
-;; block1:
-;;   lg %r5, 0(%r4)
-;;   stc %r3, 0(%r2,%r5)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lg %r4, 8(%r3)
-;;   clgr %r2, %r4
-;;   jghe label3 ; jg label1
-;; block1:
-;;   lg %r5, 0(%r3)
-;;   llc %r2, 0(%r2,%r5)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index d3f740891bc0..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lghi %r5, -4097
-;;   ag %r5, 8(%r4)
-;;   clgr %r2, %r5
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r4)
-;;   lghi %r4, 4096
-;;   stc %r3, 0(%r4,%r5)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lghi %r4, -4097
-;;   ag %r4, 8(%r3)
-;;   clgr %r2, %r4
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lgr %r4, %r2
-;;   ag %r4, 0(%r3)
-;;   lghi %r3, 4096
-;;   llc %r2, 0(%r3,%r4)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 631727f67640..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,86 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r14, %r15, 112(%r15)
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r2
-;;   algfi %r5, 4294901761
-;;   jgnle .+2 # trap=heap_oob
-;;   lg %r14, 8(%r4)
-;;   clgr %r5, %r14
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r4)
-;;   llilh %r4, 65535
-;;   stc %r3, 0(%r4,%r5)
-;;   jg label2
-;; block2:
-;;   lmg %r14, %r15, 112(%r15)
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r2
-;;   algfi %r5, 4294901761
-;;   jgnle .+2 # trap=heap_oob
-;;   lg %r4, 8(%r3)
-;;   clgr %r5, %r4
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lgr %r4, %r2
-;;   ag %r4, 0(%r3)
-;;   llilh %r5, 65535
-;;   llc %r2, 0(%r5,%r4)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 82cf46d301ff..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,83 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r8, %r15, 64(%r15)
-;;   unwind SaveReg { clobber_offset: 64, reg: p8i }
-;;   unwind SaveReg { clobber_offset: 72, reg: p9i }
-;;   unwind SaveReg { clobber_offset: 80, reg: p10i }
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lghi %r5, -4
-;;   ag %r5, 8(%r4)
-;;   lgr %r8, %r4
-;;   lgr %r4, %r2
-;;   ag %r4, 0(%r8)
-;;   lghi %r14, 0
-;;   clgr %r2, %r5
-;;   locgrh %r4, %r14
-;;   strv %r3, 0(%r4)
-;;   jg label1
-;; block1:
-;;   lmg %r8, %r15, 64(%r15)
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lghi %r5, -4
-;;   ag %r5, 8(%r3)
-;;   lgr %r4, %r2
-;;   ag %r4, 0(%r3)
-;;   lghi %r3, 0
-;;   clgr %r2, %r5
-;;   locgrh %r4, %r3
-;;   lrv %r2, 0(%r4)
-;;   jg label1
-;; block1:
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index c4d85cd4d808..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,89 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r6, %r15, 48(%r15)
-;;   unwind SaveReg { clobber_offset: 48, reg: p6i }
-;;   unwind SaveReg { clobber_offset: 56, reg: p7i }
-;;   unwind SaveReg { clobber_offset: 64, reg: p8i }
-;;   unwind SaveReg { clobber_offset: 72, reg: p9i }
-;;   unwind SaveReg { clobber_offset: 80, reg: p10i }
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r4
-;;   lghi %r4, -4100
-;;   ag %r4, 8(%r5)
-;;   lgr %r6, %r2
-;;   ag %r6, 0(%r5)
-;;   aghik %r5, %r6, 4096
-;;   lghi %r6, 0
-;;   clgr %r2, %r4
-;;   locgrh %r5, %r6
-;;   strv %r3, 0(%r5)
-;;   jg label1
-;; block1:
-;;   lmg %r6, %r15, 48(%r15)
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r4, %r3
-;;   lghi %r3, -4100
-;;   lgr %r5, %r4
-;;   ag %r3, 8(%r5)
-;;   lgr %r4, %r2
-;;   ag %r4, 0(%r5)
-;;   aghik %r5, %r4, 4096
-;;   lghi %r4, 0
-;;   clgr %r2, %r3
-;;   locgrh %r5, %r4
-;;   lrv %r2, 0(%r5)
-;;   jg label1
-;; block1:
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index ee6cac682505..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,89 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r7, %r15, 56(%r15)
-;;   unwind SaveReg { clobber_offset: 56, reg: p7i }
-;;   unwind SaveReg { clobber_offset: 64, reg: p8i }
-;;   unwind SaveReg { clobber_offset: 72, reg: p9i }
-;;   unwind SaveReg { clobber_offset: 80, reg: p10i }
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r7, %r2
-;;   algfi %r7, 4294901764
-;;   jgnle .+2 # trap=heap_oob
-;;   lg %r5, 8(%r4)
-;;   ag %r2, 0(%r4)
-;;   llilh %r4, 65535
-;;   agrk %r4, %r2, %r4
-;;   lghi %r2, 0
-;;   clgr %r7, %r5
-;;   locgrh %r4, %r2
-;;   strv %r3, 0(%r4)
-;;   jg label1
-;; block1:
-;;   lmg %r7, %r15, 56(%r15)
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r4, %r2
-;;   algfi %r4, 4294901764
-;;   jgnle .+2 # trap=heap_oob
-;;   lg %r5, 8(%r3)
-;;   ag %r2, 0(%r3)
-;;   llilh %r3, 65535
-;;   agrk %r3, %r2, %r3
-;;   lghi %r2, 0
-;;   clgr %r4, %r5
-;;   locgrh %r3, %r2
-;;   lrv %r2, 0(%r3)
-;;   jg label1
-;; block1:
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 907d9e6b9505..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,84 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r11, %r15, 88(%r15)
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lg %r5, 8(%r4)
-;;   lgr %r11, %r2
-;;   ag %r11, 0(%r4)
-;;   lghi %r13, 0
-;;   clgr %r2, %r5
-;;   locgrhe %r11, %r13
-;;   stc %r3, 0(%r11)
-;;   jg label1
-;; block1:
-;;   lmg %r11, %r15, 88(%r15)
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r11, %r15, 88(%r15)
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lg %r5, 8(%r3)
-;;   lgr %r11, %r2
-;;   ag %r11, 0(%r3)
-;;   lghi %r4, 0
-;;   clgr %r2, %r5
-;;   locgrhe %r11, %r4
-;;   llc %r2, 0(%r11)
-;;   jg label1
-;; block1:
-;;   lmg %r11, %r15, 88(%r15)
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index abb8aeca61ae..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,89 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r6, %r15, 48(%r15)
-;;   unwind SaveReg { clobber_offset: 48, reg: p6i }
-;;   unwind SaveReg { clobber_offset: 56, reg: p7i }
-;;   unwind SaveReg { clobber_offset: 64, reg: p8i }
-;;   unwind SaveReg { clobber_offset: 72, reg: p9i }
-;;   unwind SaveReg { clobber_offset: 80, reg: p10i }
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r4
-;;   lghi %r4, -4097
-;;   ag %r4, 8(%r5)
-;;   lgr %r6, %r2
-;;   ag %r6, 0(%r5)
-;;   aghik %r5, %r6, 4096
-;;   lghi %r6, 0
-;;   clgr %r2, %r4
-;;   locgrh %r5, %r6
-;;   stc %r3, 0(%r5)
-;;   jg label1
-;; block1:
-;;   lmg %r6, %r15, 48(%r15)
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r4, %r3
-;;   lghi %r3, -4097
-;;   lgr %r5, %r4
-;;   ag %r3, 8(%r5)
-;;   lgr %r4, %r2
-;;   ag %r4, 0(%r5)
-;;   aghik %r5, %r4, 4096
-;;   lghi %r4, 0
-;;   clgr %r2, %r3
-;;   locgrh %r5, %r4
-;;   llc %r2, 0(%r5)
-;;   jg label1
-;; block1:
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 8fcb0d779b38..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,89 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r7, %r15, 56(%r15)
-;;   unwind SaveReg { clobber_offset: 56, reg: p7i }
-;;   unwind SaveReg { clobber_offset: 64, reg: p8i }
-;;   unwind SaveReg { clobber_offset: 72, reg: p9i }
-;;   unwind SaveReg { clobber_offset: 80, reg: p10i }
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r7, %r2
-;;   algfi %r7, 4294901761
-;;   jgnle .+2 # trap=heap_oob
-;;   lg %r5, 8(%r4)
-;;   ag %r2, 0(%r4)
-;;   llilh %r4, 65535
-;;   agrk %r4, %r2, %r4
-;;   lghi %r2, 0
-;;   clgr %r7, %r5
-;;   locgrh %r4, %r2
-;;   stc %r3, 0(%r4)
-;;   jg label1
-;; block1:
-;;   lmg %r7, %r15, 56(%r15)
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r4, %r2
-;;   algfi %r4, 4294901761
-;;   jgnle .+2 # trap=heap_oob
-;;   lg %r5, 8(%r3)
-;;   ag %r2, 0(%r3)
-;;   llilh %r3, 65535
-;;   agrk %r3, %r2, %r3
-;;   lghi %r2, 0
-;;   clgr %r4, %r5
-;;   locgrh %r3, %r2
-;;   llc %r2, 0(%r3)
-;;   jg label1
-;; block1:
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index b16a1ef87561..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lg %r5, 8(%r4)
-;;   clgr %r2, %r5
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lg %r5, 0(%r4)
-;;   strv %r3, 0(%r2,%r5)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lg %r4, 8(%r3)
-;;   clgr %r2, %r4
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lg %r5, 0(%r3)
-;;   lrv %r2, 0(%r2,%r5)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index c034f17edad9..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lg %r5, 8(%r4)
-;;   clgr %r2, %r5
-;;   jgh label3 ; jg label1
-;; block1:
-;;   ag %r2, 0(%r4)
-;;   lghi %r4, 4096
-;;   strv %r3, 0(%r4,%r2)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lg %r4, 8(%r3)
-;;   clgr %r2, %r4
-;;   jgh label3 ; jg label1
-;; block1:
-;;   ag %r2, 0(%r3)
-;;   lghi %r3, 4096
-;;   lrv %r2, 0(%r3,%r2)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 27825b12e20d..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lg %r5, 8(%r4)
-;;   clgr %r2, %r5
-;;   jgh label3 ; jg label1
-;; block1:
-;;   ag %r2, 0(%r4)
-;;   llilh %r4, 65535
-;;   strv %r3, 0(%r4,%r2)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lg %r4, 8(%r3)
-;;   clgr %r2, %r4
-;;   jgh label3 ; jg label1
-;; block1:
-;;   ag %r2, 0(%r3)
-;;   llilh %r3, 65535
-;;   lrv %r2, 0(%r3,%r2)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 437423679855..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lg %r5, 8(%r4)
-;;   clgr %r2, %r5
-;;   jghe label3 ; jg label1
-;; block1:
-;;   lg %r5, 0(%r4)
-;;   stc %r3, 0(%r2,%r5)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lg %r4, 8(%r3)
-;;   clgr %r2, %r4
-;;   jghe label3 ; jg label1
-;; block1:
-;;   lg %r5, 0(%r3)
-;;   llc %r2, 0(%r2,%r5)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 076de1172519..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lg %r5, 8(%r4)
-;;   clgr %r2, %r5
-;;   jgh label3 ; jg label1
-;; block1:
-;;   ag %r2, 0(%r4)
-;;   lghi %r4, 4096
-;;   stc %r3, 0(%r4,%r2)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lg %r4, 8(%r3)
-;;   clgr %r2, %r4
-;;   jgh label3 ; jg label1
-;; block1:
-;;   ag %r2, 0(%r3)
-;;   lghi %r3, 4096
-;;   llc %r2, 0(%r3,%r2)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index d4473f5877f8..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lg %r5, 8(%r4)
-;;   clgr %r2, %r5
-;;   jgh label3 ; jg label1
-;; block1:
-;;   ag %r2, 0(%r4)
-;;   llilh %r4, 65535
-;;   stc %r3, 0(%r4,%r2)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lg %r4, 8(%r3)
-;;   clgr %r2, %r4
-;;   jgh label3 ; jg label1
-;; block1:
-;;   ag %r2, 0(%r3)
-;;   llilh %r3, 65535
-;;   llc %r2, 0(%r3,%r2)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 7ffb39d00c00..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,84 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r11, %r15, 88(%r15)
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lg %r5, 8(%r4)
-;;   lgr %r11, %r2
-;;   ag %r11, 0(%r4)
-;;   lghi %r13, 0
-;;   clgr %r2, %r5
-;;   locgrh %r11, %r13
-;;   strv %r3, 0(%r11)
-;;   jg label1
-;; block1:
-;;   lmg %r11, %r15, 88(%r15)
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r11, %r15, 88(%r15)
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lg %r5, 8(%r3)
-;;   lgr %r11, %r2
-;;   ag %r11, 0(%r3)
-;;   lghi %r4, 0
-;;   clgr %r2, %r5
-;;   locgrh %r11, %r4
-;;   lrv %r2, 0(%r11)
-;;   jg label1
-;; block1:
-;;   lmg %r11, %r15, 88(%r15)
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 1c2070ffc42c..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,88 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r6, %r15, 48(%r15)
-;;   unwind SaveReg { clobber_offset: 48, reg: p6i }
-;;   unwind SaveReg { clobber_offset: 56, reg: p7i }
-;;   unwind SaveReg { clobber_offset: 64, reg: p8i }
-;;   unwind SaveReg { clobber_offset: 72, reg: p9i }
-;;   unwind SaveReg { clobber_offset: 80, reg: p10i }
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lg %r6, 8(%r4)
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r4)
-;;   aghi %r5, 4096
-;;   lghi %r14, 0
-;;   clgr %r2, %r6
-;;   locgrh %r5, %r14
-;;   strv %r3, 0(%r5)
-;;   jg label1
-;; block1:
-;;   lmg %r6, %r15, 48(%r15)
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r14, %r15, 112(%r15)
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lg %r14, 8(%r3)
-;;   lgr %r4, %r2
-;;   ag %r4, 0(%r3)
-;;   aghi %r4, 4096
-;;   lghi %r5, 0
-;;   clgr %r2, %r14
-;;   locgrh %r4, %r5
-;;   lrv %r2, 0(%r4)
-;;   jg label1
-;; block1:
-;;   lmg %r14, %r15, 112(%r15)
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 3d8f014252ba..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,98 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r6, %r15, 48(%r15)
-;;   unwind SaveReg { clobber_offset: 48, reg: p6i }
-;;   unwind SaveReg { clobber_offset: 56, reg: p7i }
-;;   unwind SaveReg { clobber_offset: 64, reg: p8i }
-;;   unwind SaveReg { clobber_offset: 72, reg: p9i }
-;;   unwind SaveReg { clobber_offset: 80, reg: p10i }
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lg %r7, 8(%r4)
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r4)
-;;   llilh %r4, 65535
-;;   agr %r5, %r4
-;;   lghi %r6, 0
-;;   clgr %r2, %r7
-;;   locgrh %r5, %r6
-;;   strv %r3, 0(%r5)
-;;   jg label1
-;; block1:
-;;   lmg %r6, %r15, 48(%r15)
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r6, %r15, 48(%r15)
-;;   unwind SaveReg { clobber_offset: 48, reg: p6i }
-;;   unwind SaveReg { clobber_offset: 56, reg: p7i }
-;;   unwind SaveReg { clobber_offset: 64, reg: p8i }
-;;   unwind SaveReg { clobber_offset: 72, reg: p9i }
-;;   unwind SaveReg { clobber_offset: 80, reg: p10i }
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lg %r6, 8(%r3)
-;;   lgr %r4, %r2
-;;   ag %r4, 0(%r3)
-;;   llilh %r3, 65535
-;;   agrk %r5, %r4, %r3
-;;   lghi %r4, 0
-;;   clgr %r2, %r6
-;;   locgrh %r5, %r4
-;;   lrv %r2, 0(%r5)
-;;   jg label1
-;; block1:
-;;   lmg %r6, %r15, 48(%r15)
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 175a19bf50e8..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,84 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r11, %r15, 88(%r15)
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lg %r5, 8(%r4)
-;;   lgr %r11, %r2
-;;   ag %r11, 0(%r4)
-;;   lghi %r13, 0
-;;   clgr %r2, %r5
-;;   locgrhe %r11, %r13
-;;   stc %r3, 0(%r11)
-;;   jg label1
-;; block1:
-;;   lmg %r11, %r15, 88(%r15)
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r11, %r15, 88(%r15)
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lg %r5, 8(%r3)
-;;   lgr %r11, %r2
-;;   ag %r11, 0(%r3)
-;;   lghi %r4, 0
-;;   clgr %r2, %r5
-;;   locgrhe %r11, %r4
-;;   llc %r2, 0(%r11)
-;;   jg label1
-;; block1:
-;;   lmg %r11, %r15, 88(%r15)
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 9a62871d7006..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,88 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r6, %r15, 48(%r15)
-;;   unwind SaveReg { clobber_offset: 48, reg: p6i }
-;;   unwind SaveReg { clobber_offset: 56, reg: p7i }
-;;   unwind SaveReg { clobber_offset: 64, reg: p8i }
-;;   unwind SaveReg { clobber_offset: 72, reg: p9i }
-;;   unwind SaveReg { clobber_offset: 80, reg: p10i }
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lg %r6, 8(%r4)
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r4)
-;;   aghi %r5, 4096
-;;   lghi %r14, 0
-;;   clgr %r2, %r6
-;;   locgrh %r5, %r14
-;;   stc %r3, 0(%r5)
-;;   jg label1
-;; block1:
-;;   lmg %r6, %r15, 48(%r15)
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r14, %r15, 112(%r15)
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lg %r14, 8(%r3)
-;;   lgr %r4, %r2
-;;   ag %r4, 0(%r3)
-;;   aghi %r4, 4096
-;;   lghi %r5, 0
-;;   clgr %r2, %r14
-;;   locgrh %r4, %r5
-;;   llc %r2, 0(%r4)
-;;   jg label1
-;; block1:
-;;   lmg %r14, %r15, 112(%r15)
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 2f861cc1f10a..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,98 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r6, %r15, 48(%r15)
-;;   unwind SaveReg { clobber_offset: 48, reg: p6i }
-;;   unwind SaveReg { clobber_offset: 56, reg: p7i }
-;;   unwind SaveReg { clobber_offset: 64, reg: p8i }
-;;   unwind SaveReg { clobber_offset: 72, reg: p9i }
-;;   unwind SaveReg { clobber_offset: 80, reg: p10i }
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lg %r7, 8(%r4)
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r4)
-;;   llilh %r4, 65535
-;;   agr %r5, %r4
-;;   lghi %r6, 0
-;;   clgr %r2, %r7
-;;   locgrh %r5, %r6
-;;   stc %r3, 0(%r5)
-;;   jg label1
-;; block1:
-;;   lmg %r6, %r15, 48(%r15)
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   stmg %r6, %r15, 48(%r15)
-;;   unwind SaveReg { clobber_offset: 48, reg: p6i }
-;;   unwind SaveReg { clobber_offset: 56, reg: p7i }
-;;   unwind SaveReg { clobber_offset: 64, reg: p8i }
-;;   unwind SaveReg { clobber_offset: 72, reg: p9i }
-;;   unwind SaveReg { clobber_offset: 80, reg: p10i }
-;;   unwind SaveReg { clobber_offset: 88, reg: p11i }
-;;   unwind SaveReg { clobber_offset: 96, reg: p12i }
-;;   unwind SaveReg { clobber_offset: 104, reg: p13i }
-;;   unwind SaveReg { clobber_offset: 112, reg: p14i }
-;;   unwind SaveReg { clobber_offset: 120, reg: p15i }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lg %r6, 8(%r3)
-;;   lgr %r4, %r2
-;;   ag %r4, 0(%r3)
-;;   llilh %r3, 65535
-;;   agrk %r5, %r4, %r3
-;;   lghi %r4, 0
-;;   clgr %r2, %r6
-;;   locgrh %r5, %r4
-;;   llc %r2, 0(%r5)
-;;   jg label1
-;; block1:
-;;   lmg %r6, %r15, 48(%r15)
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 8526bb67e0a9..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r4
-;;   llgfr %r4, %r2
-;;   clgfi %r4, 268435452
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lg %r5, 0(%r5)
-;;   strv %r3, 0(%r4,%r5)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r4, %r3
-;;   llgfr %r3, %r2
-;;   clgfi %r3, 268435452
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lg %r5, 0(%r4)
-;;   lrv %r2, 0(%r3,%r5)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index dff24197b473..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,75 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r4
-;;   llgfr %r4, %r2
-;;   clgfi %r4, 268431356
-;;   jgh label3 ; jg label1
-;; block1:
-;;   ag %r4, 0(%r5)
-;;   lghi %r2, 4096
-;;   strv %r3, 0(%r2,%r4)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r3
-;;   llgfr %r3, %r2
-;;   clgfi %r3, 268431356
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lgr %r4, %r5
-;;   ag %r3, 0(%r4)
-;;   lghi %r2, 4096
-;;   lrv %r2, 0(%r2,%r3)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 66463fee14a7..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,50 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index fd21695646d9..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r4
-;;   llgfr %r4, %r2
-;;   clgfi %r4, 268435455
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lg %r5, 0(%r5)
-;;   stc %r3, 0(%r4,%r5)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r4, %r3
-;;   llgfr %r3, %r2
-;;   clgfi %r3, 268435455
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lg %r5, 0(%r4)
-;;   llc %r2, 0(%r3,%r5)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 072dfed1e7c6..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,75 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r4
-;;   llgfr %r4, %r2
-;;   clgfi %r4, 268431359
-;;   jgh label3 ; jg label1
-;; block1:
-;;   ag %r4, 0(%r5)
-;;   lghi %r2, 4096
-;;   stc %r3, 0(%r2,%r4)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r3
-;;   llgfr %r3, %r2
-;;   clgfi %r3, 268431359
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lgr %r4, %r5
-;;   ag %r3, 0(%r4)
-;;   lghi %r2, 4096
-;;   llc %r2, 0(%r2,%r3)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 2f85b8cdf7c4..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,50 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 502fc9856a03..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r5, %r2
-;;   lgr %r2, %r4
-;;   lgr %r4, %r5
-;;   ag %r4, 0(%r2)
-;;   lghi %r2, 0
-;;   clgfi %r5, 268435452
-;;   locgrh %r4, %r2
-;;   strv %r3, 0(%r4)
-;;   jg label1
-;; block1:
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r5, %r2
-;;   lgr %r4, %r3
-;;   lgr %r3, %r5
-;;   ag %r3, 0(%r4)
-;;   lghi %r2, 0
-;;   clgfi %r5, 268435452
-;;   locgrh %r3, %r2
-;;   lrv %r2, 0(%r3)
-;;   jg label1
-;; block1:
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 8366b8251c3f..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r2, %r2
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r4)
-;;   aghik %r4, %r5, 4096
-;;   lghi %r5, 0
-;;   clgfi %r2, 268431356
-;;   locgrh %r4, %r5
-;;   strv %r3, 0(%r4)
-;;   jg label1
-;; block1:
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r2, %r2
-;;   lgr %r4, %r2
-;;   ag %r4, 0(%r3)
-;;   aghi %r4, 4096
-;;   lghi %r3, 0
-;;   clgfi %r2, 268431356
-;;   locgrh %r4, %r3
-;;   lrv %r2, 0(%r4)
-;;   jg label1
-;; block1:
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 36579daecdf4..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,50 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 3594b2b9e64c..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r5, %r2
-;;   lgr %r2, %r4
-;;   lgr %r4, %r5
-;;   ag %r4, 0(%r2)
-;;   lghi %r2, 0
-;;   clgfi %r5, 268435455
-;;   locgrh %r4, %r2
-;;   stc %r3, 0(%r4)
-;;   jg label1
-;; block1:
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r5, %r2
-;;   lgr %r4, %r3
-;;   lgr %r3, %r5
-;;   ag %r3, 0(%r4)
-;;   lghi %r2, 0
-;;   clgfi %r5, 268435455
-;;   locgrh %r3, %r2
-;;   llc %r2, 0(%r3)
-;;   jg label1
-;; block1:
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index c51890d0a287..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r2, %r2
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r4)
-;;   aghik %r4, %r5, 4096
-;;   lghi %r5, 0
-;;   clgfi %r2, 268431359
-;;   locgrh %r4, %r5
-;;   stc %r3, 0(%r4)
-;;   jg label1
-;; block1:
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   llgfr %r2, %r2
-;;   lgr %r4, %r2
-;;   ag %r4, 0(%r3)
-;;   aghi %r4, 4096
-;;   lghi %r3, 0
-;;   clgfi %r2, 268431359
-;;   locgrh %r4, %r3
-;;   llc %r2, 0(%r4)
-;;   jg label1
-;; block1:
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 648929ef8ef9..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,50 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 4ba00626fca1..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,62 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r4
-;;   llgfr %r4, %r2
-;;   lg %r5, 0(%r5)
-;;   strv %r3, 0(%r4,%r5)
-;;   jg label1
-;; block1:
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r3
-;;   llgfr %r3, %r2
-;;   lg %r4, 0(%r5)
-;;   lrv %r2, 0(%r3,%r4)
-;;   jg label1
-;; block1:
-;;   br %r14
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 794a1572764f..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,66 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r4
-;;   llgfr %r4, %r2
-;;   lgr %r2, %r5
-;;   ag %r4, 0(%r2)
-;;   lghi %r5, 4096
-;;   strv %r3, 0(%r5,%r4)
-;;   jg label1
-;; block1:
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r3
-;;   llgfr %r3, %r2
-;;   lgr %r2, %r5
-;;   ag %r3, 0(%r2)
-;;   lghi %r4, 4096
-;;   lrv %r2, 0(%r4,%r3)
-;;   jg label1
-;; block1:
-;;   br %r14
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 4ba9e532a450..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,50 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index b6b14039a01d..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,62 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r4
-;;   llgfr %r4, %r2
-;;   lg %r5, 0(%r5)
-;;   stc %r3, 0(%r4,%r5)
-;;   jg label1
-;; block1:
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r3
-;;   llgfr %r3, %r2
-;;   lg %r4, 0(%r5)
-;;   llc %r2, 0(%r3,%r4)
-;;   jg label1
-;; block1:
-;;   br %r14
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index bbeb3ae418b5..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,66 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r4
-;;   llgfr %r4, %r2
-;;   lgr %r2, %r5
-;;   ag %r4, 0(%r2)
-;;   lghi %r5, 4096
-;;   stc %r3, 0(%r5,%r4)
-;;   jg label1
-;; block1:
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r3
-;;   llgfr %r3, %r2
-;;   lgr %r2, %r5
-;;   ag %r3, 0(%r2)
-;;   lghi %r4, 4096
-;;   llc %r2, 0(%r4,%r3)
-;;   jg label1
-;; block1:
-;;   br %r14
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 6ffce7d78fb3..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,50 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index baba30b88d25..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,62 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r4
-;;   llgfr %r4, %r2
-;;   lg %r5, 0(%r5)
-;;   strv %r3, 0(%r4,%r5)
-;;   jg label1
-;; block1:
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r3
-;;   llgfr %r3, %r2
-;;   lg %r4, 0(%r5)
-;;   lrv %r2, 0(%r3,%r4)
-;;   jg label1
-;; block1:
-;;   br %r14
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index e76eae59fe0b..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,66 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r4
-;;   llgfr %r4, %r2
-;;   lgr %r2, %r5
-;;   ag %r4, 0(%r2)
-;;   lghi %r5, 4096
-;;   strv %r3, 0(%r5,%r4)
-;;   jg label1
-;; block1:
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r3
-;;   llgfr %r3, %r2
-;;   lgr %r2, %r5
-;;   ag %r3, 0(%r2)
-;;   lghi %r4, 4096
-;;   lrv %r2, 0(%r4,%r3)
-;;   jg label1
-;; block1:
-;;   br %r14
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 9c1d577ce8c0..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,50 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index a704c050090c..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,62 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r4
-;;   llgfr %r4, %r2
-;;   lg %r5, 0(%r5)
-;;   stc %r3, 0(%r4,%r5)
-;;   jg label1
-;; block1:
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r3
-;;   llgfr %r3, %r2
-;;   lg %r4, 0(%r5)
-;;   llc %r2, 0(%r3,%r4)
-;;   jg label1
-;; block1:
-;;   br %r14
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 94614dc1c641..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,66 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r4
-;;   llgfr %r4, %r2
-;;   lgr %r2, %r5
-;;   ag %r4, 0(%r2)
-;;   lghi %r5, 4096
-;;   stc %r3, 0(%r5,%r4)
-;;   jg label1
-;; block1:
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r3
-;;   llgfr %r3, %r2
-;;   lgr %r2, %r5
-;;   ag %r3, 0(%r2)
-;;   lghi %r4, 4096
-;;   llc %r2, 0(%r4,%r3)
-;;   jg label1
-;; block1:
-;;   br %r14
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index a66de6355e13..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,50 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index ac557b60ab8e..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   clgfi %r2, 268435452
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lg %r4, 0(%r4)
-;;   strv %r3, 0(%r2,%r4)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   clgfi %r2, 268435452
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lg %r4, 0(%r3)
-;;   lrv %r2, 0(%r2,%r4)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 0d1ed849d45f..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   clgfi %r2, 268431356
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r4)
-;;   lghi %r2, 4096
-;;   strv %r3, 0(%r2,%r5)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   clgfi %r2, 268431356
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r3)
-;;   lghi %r2, 4096
-;;   lrv %r2, 0(%r2,%r5)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index be3e0b57ab7b..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,50 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 66f1a626f768..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   clgfi %r2, 268435455
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lg %r4, 0(%r4)
-;;   stc %r3, 0(%r2,%r4)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   clgfi %r2, 268435455
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lg %r4, 0(%r3)
-;;   llc %r2, 0(%r2,%r4)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index f9ed4aab9b37..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   clgfi %r2, 268431359
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r4)
-;;   lghi %r2, 4096
-;;   stc %r3, 0(%r2,%r5)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   clgfi %r2, 268431359
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r3)
-;;   lghi %r2, 4096
-;;   llc %r2, 0(%r2,%r5)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 2a0585aaac44..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,50 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 05c6839d5969..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,66 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r4)
-;;   lghi %r4, 0
-;;   clgfi %r2, 268435452
-;;   locgrh %r5, %r4
-;;   strv %r3, 0(%r5)
-;;   jg label1
-;; block1:
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r3)
-;;   lghi %r4, 0
-;;   clgfi %r2, 268435452
-;;   locgrh %r5, %r4
-;;   lrv %r2, 0(%r5)
-;;   jg label1
-;; block1:
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 2851ab44629e..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r4)
-;;   aghik %r4, %r5, 4096
-;;   lghi %r5, 0
-;;   clgfi %r2, 268431356
-;;   locgrh %r4, %r5
-;;   strv %r3, 0(%r4)
-;;   jg label1
-;; block1:
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r3)
-;;   aghik %r3, %r5, 4096
-;;   lghi %r5, 0
-;;   clgfi %r2, 268431356
-;;   locgrh %r3, %r5
-;;   lrv %r2, 0(%r3)
-;;   jg label1
-;; block1:
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 99cd316b7252..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,50 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 0df2d11cbba4..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,66 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r4)
-;;   lghi %r4, 0
-;;   clgfi %r2, 268435455
-;;   locgrh %r5, %r4
-;;   stc %r3, 0(%r5)
-;;   jg label1
-;; block1:
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r3)
-;;   lghi %r4, 0
-;;   clgfi %r2, 268435455
-;;   locgrh %r5, %r4
-;;   llc %r2, 0(%r5)
-;;   jg label1
-;; block1:
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 5b8b480191b1..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r4)
-;;   aghik %r4, %r5, 4096
-;;   lghi %r5, 0
-;;   clgfi %r2, 268431359
-;;   locgrh %r4, %r5
-;;   stc %r3, 0(%r4)
-;;   jg label1
-;; block1:
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r3)
-;;   aghik %r3, %r5, 4096
-;;   lghi %r5, 0
-;;   clgfi %r2, 268431359
-;;   locgrh %r3, %r5
-;;   llc %r2, 0(%r3)
-;;   jg label1
-;; block1:
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index aa942f5c24a2..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,50 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 2e53bc16d749..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   clgfi %r2, 268435452
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lg %r4, 0(%r4)
-;;   strv %r3, 0(%r2,%r4)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   clgfi %r2, 268435452
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lg %r4, 0(%r3)
-;;   lrv %r2, 0(%r2,%r4)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 5e17082f889a..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   clgfi %r2, 268431356
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r4)
-;;   lghi %r2, 4096
-;;   strv %r3, 0(%r2,%r5)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   clgfi %r2, 268431356
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r3)
-;;   lghi %r2, 4096
-;;   lrv %r2, 0(%r2,%r5)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 79d407bf5055..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,50 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 4c98b41e5d99..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   clgfi %r2, 268435455
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lg %r4, 0(%r4)
-;;   stc %r3, 0(%r2,%r4)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   clgfi %r2, 268435455
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lg %r4, 0(%r3)
-;;   llc %r2, 0(%r2,%r4)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index d9442a3a1f20..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   clgfi %r2, 268431359
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r4)
-;;   lghi %r2, 4096
-;;   stc %r3, 0(%r2,%r5)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   clgfi %r2, 268431359
-;;   jgh label3 ; jg label1
-;; block1:
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r3)
-;;   lghi %r2, 4096
-;;   llc %r2, 0(%r2,%r5)
-;;   jg label2
-;; block2:
-;;   br %r14
-;; block3:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index c154ac31a553..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,50 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 486133ed00ff..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,66 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r4)
-;;   lghi %r4, 0
-;;   clgfi %r2, 268435452
-;;   locgrh %r5, %r4
-;;   strv %r3, 0(%r5)
-;;   jg label1
-;; block1:
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r3)
-;;   lghi %r4, 0
-;;   clgfi %r2, 268435452
-;;   locgrh %r5, %r4
-;;   lrv %r2, 0(%r5)
-;;   jg label1
-;; block1:
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index a71863212d37..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r4)
-;;   aghik %r4, %r5, 4096
-;;   lghi %r5, 0
-;;   clgfi %r2, 268431356
-;;   locgrh %r4, %r5
-;;   strv %r3, 0(%r4)
-;;   jg label1
-;; block1:
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r3)
-;;   aghik %r3, %r5, 4096
-;;   lghi %r5, 0
-;;   clgfi %r2, 268431356
-;;   locgrh %r3, %r5
-;;   lrv %r2, 0(%r3)
-;;   jg label1
-;; block1:
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index a346794bcda1..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,50 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 89aec920be0d..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,66 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r4)
-;;   lghi %r4, 0
-;;   clgfi %r2, 268435455
-;;   locgrh %r5, %r4
-;;   stc %r3, 0(%r5)
-;;   jg label1
-;; block1:
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r3)
-;;   lghi %r4, 0
-;;   clgfi %r2, 268435455
-;;   locgrh %r5, %r4
-;;   llc %r2, 0(%r5)
-;;   jg label1
-;; block1:
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 548feaca8244..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r4)
-;;   aghik %r4, %r5, 4096
-;;   lghi %r5, 0
-;;   clgfi %r2, 268431359
-;;   locgrh %r4, %r5
-;;   stc %r3, 0(%r4)
-;;   jg label1
-;; block1:
-;;   br %r14
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   lgr %r5, %r2
-;;   ag %r5, 0(%r3)
-;;   aghik %r3, %r5, 4096
-;;   lghi %r5, 0
-;;   clgfi %r2, 268431359
-;;   locgrh %r3, %r5
-;;   llc %r2, 0(%r3)
-;;   jg label1
-;; block1:
-;;   br %r14
diff --git a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index f69fb1447a60..000000000000
--- a/cranelift/filetests/filetests/isa/s390x/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,50 +0,0 @@
-;;! target = "s390x"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
-;;
-;; function u0:1:
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 160, offset_downward_to_clobbers: 0 }
-;;   unwind StackAlloc { size: 0 }
-;; block0:
-;;   .word 0x0000 # trap=heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/amode-opt.clif b/cranelift/filetests/filetests/isa/x64/amode-opt.clif
index 2c8b00c744ec..1188f022bb0d 100644
--- a/cranelift/filetests/filetests/isa/x64/amode-opt.clif
+++ b/cranelift/filetests/filetests/isa/x64/amode-opt.clif
@@ -210,9 +210,8 @@ block0(v0: i64, v1: i32):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rsi, %rdx
-;   shll    $3, %edx, %edx
-;   movq    -1(%rdi,%rdx,1), %rax
+;   shll    $3, %esi, %esi
+;   movq    -1(%rdi,%rsi,1), %rax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -222,9 +221,8 @@ block0(v0: i64, v1: i32):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rsi, %rdx
-;   shll $3, %edx
-;   movq -1(%rdi, %rdx), %rax ; trap: heap_oob
+;   shll $3, %esi
+;   movq -1(%rdi, %rsi), %rax ; trap: heap_oob
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
diff --git a/cranelift/filetests/filetests/isa/x64/bitcast.clif b/cranelift/filetests/filetests/isa/x64/bitcast.clif
index aee59d0171b4..ef1a2f3fca21 100644
--- a/cranelift/filetests/filetests/isa/x64/bitcast.clif
+++ b/cranelift/filetests/filetests/isa/x64/bitcast.clif
@@ -1,7 +1,59 @@
 test compile precise-output
+set enable_llvm_abi_extensions
 target x86_64
 
-function %f1(f32) -> i32 {
+function %bitcast_f16_to_i16(f16) -> i16 {
+block0(v0: f16):
+  v1 = bitcast.i16 v0
+  return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   pextrw  $0, %xmm0, %rax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   pextrw $0, %xmm0, %eax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %bitcast_i16_to_f16(i16) -> f16 {
+block0(v0: i16):
+  v1 = bitcast.f16 v0
+  return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   uninit  %xmm0
+;   pinsrw  $0, %xmm0, %rdi, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   pinsrw $0, %edi, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %bitcast_f32_to_i32(f32) -> i32 {
 block0(v0: f32):
   v1 = bitcast.i32 v0
   return v1
@@ -26,7 +78,7 @@ block0(v0: f32):
 ;   popq %rbp
 ;   retq
 
-function %f2(i32) -> f32 {
+function %bitcast_i32_to_f32(i32) -> f32 {
 block0(v0: i32):
   v1 = bitcast.f32 v0
   return v1
@@ -51,7 +103,7 @@ block0(v0: i32):
 ;   popq %rbp
 ;   retq
 
-function %f3(f64) -> i64 {
+function %bitcast_f64_to_i64(f64) -> i64 {
 block0(v0: f64):
   v1 = bitcast.i64 v0
   return v1
@@ -76,7 +128,7 @@ block0(v0: f64):
 ;   popq %rbp
 ;   retq
 
-function %f4(i64) -> f64 {
+function %bitcast_i64_to_f64(i64) -> f64 {
 block0(v0: i64):
   v1 = bitcast.f64 v0
   return v1
@@ -101,3 +153,119 @@ block0(v0: i64):
 ;   popq %rbp
 ;   retq
 
+function %bitcast_f128_to_i128(f128) -> i128 {
+block0(v0: f128):
+  v1 = bitcast.i128 v0
+  return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movq    %xmm0, %rax
+;   pshufd  $238, %xmm0, %xmm4
+;   movq    %xmm4, %rdx
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movq %xmm0, %rax
+;   pshufd $0xee, %xmm0, %xmm4
+;   movq %xmm4, %rdx
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %bitcast_i128_to_f128(i128) -> f128 {
+block0(v0: i128):
+  v1 = bitcast.f128 v0
+  return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movq    %rdi, %xmm0
+;   movq    %rsi, %xmm5
+;   punpcklqdq %xmm0, %xmm5, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movq %rdi, %xmm0
+;   movq %rsi, %xmm5
+;   punpcklqdq %xmm5, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %bitcast_i64x2_to_i128(i64x2) -> i128 {
+block0(v0: i64x2):
+  v1 = bitcast.i128 little v0
+  return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movq    %xmm0, %rax
+;   pshufd  $238, %xmm0, %xmm4
+;   movq    %xmm4, %rdx
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movq %xmm0, %rax
+;   pshufd $0xee, %xmm0, %xmm4
+;   movq %xmm4, %rdx
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %bitcast_i128_to_i64x2(i128) -> i64x2 {
+block0(v0: i128):
+  v1 = bitcast.i64x2 little v0
+  return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movq    %rdi, %xmm0
+;   movq    %rsi, %xmm5
+;   punpcklqdq %xmm0, %xmm5, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movq %rdi, %xmm0
+;   movq %rsi, %xmm5
+;   punpcklqdq %xmm5, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/bmask.clif b/cranelift/filetests/filetests/isa/x64/bmask.clif
index 8184c444cd66..4fc904755747 100644
--- a/cranelift/filetests/filetests/isa/x64/bmask.clif
+++ b/cranelift/filetests/filetests/isa/x64/bmask.clif
@@ -509,11 +509,11 @@ block0(v0: i128):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rdi, %rdx
-;   orq     %rdx, %rsi, %rdx
-;   movq    %rdx, %r8
+;   orq     %rdi, %rsi, %rdi
+;   movq    %rdi, %r8
 ;   negq    %r8, %r8
-;   sbbq    %rdx, %rdx, %rdx
+;   movq    %rdi, %rdx
+;   sbbq    %rdx, %rdi, %rdx
 ;   movq    %rdx, %rax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -524,11 +524,11 @@ block0(v0: i128):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rdi, %rdx
-;   orq %rsi, %rdx
-;   movq %rdx, %r8
+;   orq %rsi, %rdi
+;   movq %rdi, %r8
 ;   negq %r8
-;   sbbq %rdx, %rdx
+;   movq %rdi, %rdx
+;   sbbq %rdi, %rdx
 ;   movq %rdx, %rax
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -544,11 +544,11 @@ block0(v0: i128):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rdi, %rax
-;   orq     %rax, %rsi, %rax
-;   movq    %rax, %r8
+;   orq     %rdi, %rsi, %rdi
+;   movq    %rdi, %r8
 ;   negq    %r8, %r8
-;   sbbq    %rax, %rax, %rax
+;   movq    %rdi, %rax
+;   sbbq    %rax, %rdi, %rax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -558,11 +558,11 @@ block0(v0: i128):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rdi, %rax
-;   orq %rsi, %rax
-;   movq %rax, %r8
+;   orq %rsi, %rdi
+;   movq %rdi, %r8
 ;   negq %r8
-;   sbbq %rax, %rax
+;   movq %rdi, %rax
+;   sbbq %rdi, %rax
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -577,11 +577,11 @@ block0(v0: i128):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rdi, %rax
-;   orq     %rax, %rsi, %rax
-;   movq    %rax, %r8
+;   orq     %rdi, %rsi, %rdi
+;   movq    %rdi, %r8
 ;   negq    %r8, %r8
-;   sbbl    %eax, %eax, %eax
+;   movq    %rdi, %rax
+;   sbbl    %eax, %edi, %eax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -591,11 +591,11 @@ block0(v0: i128):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rdi, %rax
-;   orq %rsi, %rax
-;   movq %rax, %r8
+;   orq %rsi, %rdi
+;   movq %rdi, %r8
 ;   negq %r8
-;   sbbl %eax, %eax
+;   movq %rdi, %rax
+;   sbbl %edi, %eax
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -610,11 +610,11 @@ block0(v0: i128):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rdi, %rax
-;   orq     %rax, %rsi, %rax
-;   movq    %rax, %r8
+;   orq     %rdi, %rsi, %rdi
+;   movq    %rdi, %r8
 ;   negq    %r8, %r8
-;   sbbl    %eax, %eax, %eax
+;   movq    %rdi, %rax
+;   sbbl    %eax, %edi, %eax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -624,11 +624,11 @@ block0(v0: i128):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rdi, %rax
-;   orq %rsi, %rax
-;   movq %rax, %r8
+;   orq %rsi, %rdi
+;   movq %rdi, %r8
 ;   negq %r8
-;   sbbl %eax, %eax
+;   movq %rdi, %rax
+;   sbbl %edi, %eax
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -643,11 +643,11 @@ block0(v0: i128):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rdi, %rax
-;   orq     %rax, %rsi, %rax
-;   movq    %rax, %r8
+;   orq     %rdi, %rsi, %rdi
+;   movq    %rdi, %r8
 ;   negq    %r8, %r8
-;   sbbl    %eax, %eax, %eax
+;   movq    %rdi, %rax
+;   sbbl    %eax, %edi, %eax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -657,11 +657,11 @@ block0(v0: i128):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rdi, %rax
-;   orq %rsi, %rax
-;   movq %rax, %r8
+;   orq %rsi, %rdi
+;   movq %rdi, %r8
 ;   negq %r8
-;   sbbl %eax, %eax
+;   movq %rdi, %rax
+;   sbbl %edi, %eax
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -798,3 +798,66 @@ block0(v0: i8):
 ;   popq %rbp
 ;   retq
 
+function %bmask_icmp_i32_i8(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+  v2 = icmp sgt v0, v1
+  v3 = bmask.i8 v2
+  return v3
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   cmpl    %esi, %edi
+;   setnle  %al
+;   movq    %rax, %r8
+;   negb    %r8b, %r8b
+;   sbbl    %eax, %eax, %eax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   cmpl %esi, %edi
+;   setg %al
+;   movq %rax, %r8
+;   negb %r8b
+;   sbbl %eax, %eax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %ineg_icmp_i32_i8(i32, i32) -> i8 {
+block0(v0: i32, v1: i32):
+  v2 = icmp sgt v0, v1
+  v3 = ineg v2
+  return v3
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   cmpl    %esi, %edi
+;   setnle  %al
+;   negb    %al, %al
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   cmpl %esi, %edi
+;   setg %al
+;   negb %al
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
diff --git a/cranelift/filetests/filetests/isa/x64/bmi2.clif b/cranelift/filetests/filetests/isa/x64/bmi2.clif
index b65825742732..134853ed393e 100644
--- a/cranelift/filetests/filetests/isa/x64/bmi2.clif
+++ b/cranelift/filetests/filetests/isa/x64/bmi2.clif
@@ -268,9 +268,8 @@ block0(v0: i32, v1: i32):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rsi, %rcx
-;   andl    %ecx, $31, %ecx
-;   bzhi    %edi, %ecx, %eax
+;   andl    %esi, $31, %esi
+;   bzhi    %edi, %esi, %eax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -280,9 +279,8 @@ block0(v0: i32, v1: i32):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rsi, %rcx
-;   andl $0x1f, %ecx
-;   bzhil %ecx, %edi, %eax
+;   andl $0x1f, %esi
+;   bzhil %esi, %edi, %eax
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -300,9 +298,8 @@ block0(v0: i64, v1: i64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rsi, %rcx
-;   andq    %rcx, $63, %rcx
-;   bzhi    %rdi, %rcx, %rax
+;   andq    %rsi, $63, %rsi
+;   bzhi    %rdi, %rsi, %rax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -312,9 +309,8 @@ block0(v0: i64, v1: i64):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rsi, %rcx
-;   andq $0x3f, %rcx
-;   bzhiq %rcx, %rdi, %rax
+;   andq $0x3f, %rsi
+;   bzhiq %rsi, %rdi, %rax
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -333,9 +329,8 @@ block0(v0: i64, v1: i32):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rsi, %rcx
-;   andl    %ecx, $31, %ecx
-;   bzhi    20(%rdi), %ecx, %eax
+;   andl    %esi, $31, %esi
+;   bzhi    20(%rdi), %esi, %eax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -345,9 +340,8 @@ block0(v0: i64, v1: i32):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rsi, %rcx
-;   andl $0x1f, %ecx
-;   bzhil %ecx, 0x14(%rdi), %eax ; trap: heap_oob
+;   andl $0x1f, %esi
+;   bzhil %esi, 0x14(%rdi), %eax ; trap: heap_oob
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
diff --git a/cranelift/filetests/filetests/isa/x64/branches.clif b/cranelift/filetests/filetests/isa/x64/branches.clif
index 57ab4de3fbae..fbbd876b8e98 100644
--- a/cranelift/filetests/filetests/isa/x64/branches.clif
+++ b/cranelift/filetests/filetests/isa/x64/branches.clif
@@ -630,15 +630,13 @@ block202:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movl    $1112539136, %eax
-;   movd    %eax, %xmm4
-;   ucomiss %xmm4, %xmm0
+;   ucomiss const(1), %xmm0
 ;   jp      label2
 ;   jnz     label2; j label1
 ; block1:
 ;   jmp     label5
 ; block2:
-;   ucomiss %xmm4, %xmm0
+;   ucomiss const(0), %xmm0
 ;   jnp     label4; j label3
 ; block3:
 ;   jmp     label5
@@ -654,20 +652,36 @@ block202:
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movl $0x42500000, %eax
-;   movd %eax, %xmm4
-;   ucomiss %xmm4, %xmm0
-;   jp 0x1c
-;   je 0x27
-; block2: ; offset 0x1c
-;   ucomiss %xmm4, %xmm0
-;   jp 0x27
-; block3: ; offset 0x25
+;   ucomiss 0x25(%rip), %xmm0
+;   jp 0x17
+;   je 0x26
+; block2: ; offset 0x17
+;   ucomiss 0x22(%rip), %xmm0
+;   jp 0x26
+; block3: ; offset 0x24
 ;   ud2 ; trap: heap_oob
-; block4: ; offset 0x27
+; block4: ; offset 0x26
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %dl, 0x42(%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   pushq %rax
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
 
 function %br_i8_icmp(i32, i32) -> i32 {
 block0(v0: i32, v1: i32):
diff --git a/cranelift/filetests/filetests/isa/x64/call-conv.clif b/cranelift/filetests/filetests/isa/x64/call-conv.clif
index 1e0cede45e3b..6b9deb3a5be1 100644
--- a/cranelift/filetests/filetests/isa/x64/call-conv.clif
+++ b/cranelift/filetests/filetests/isa/x64/call-conv.clif
@@ -1,4 +1,5 @@
 test compile precise-output
+set enable_llvm_abi_extensions
 target x86_64
 
 function %one_arg(i32) system_v {
@@ -12,13 +13,11 @@ block0(v0: i32):
 ; VCode:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
+;   subq    %rsp, $32, %rsp
 ; block0:
 ;   movq    %rdi, %rcx
-;   subq    %rsp, $32, %rsp
-;   virtual_sp_offset_adjust 32
 ;   call    *%rcx
 ;   addq    %rsp, $32, %rsp
-;   virtual_sp_offset_adjust -32
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -27,9 +26,9 @@ block0(v0: i32):
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
-; block1: ; offset 0x4
-;   movq %rdi, %rcx
 ;   subq $0x20, %rsp
+; block1: ; offset 0x8
+;   movq %rdi, %rcx
 ;   callq *%rcx
 ;   addq $0x20, %rsp
 ;   movq %rbp, %rsp
@@ -49,17 +48,15 @@ block0(v0: i32, v1: f32):
 ; VCode:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
+;   subq    %rsp, $32, %rsp
 ; block0:
 ;   movdqa  %xmm0, %xmm6
-;   subq    %rsp, $32, %rsp
-;   virtual_sp_offset_adjust 32
 ;   movq    %rdi, %rcx
 ;   movdqa  %xmm6, %xmm1
 ;   call    *%rdi
-;   addq    %rsp, $32, %rsp
-;   virtual_sp_offset_adjust -32
 ;   movdqa  %xmm6, %xmm0
 ;   call    *%rdi
+;   addq    %rsp, $32, %rsp
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -68,15 +65,15 @@ block0(v0: i32, v1: f32):
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
-; block1: ; offset 0x4
-;   movdqa %xmm0, %xmm6
 ;   subq $0x20, %rsp
+; block1: ; offset 0x8
+;   movdqa %xmm0, %xmm6
 ;   movq %rdi, %rcx
 ;   movdqa %xmm6, %xmm1
 ;   callq *%rdi
-;   addq $0x20, %rsp
 ;   movdqa %xmm6, %xmm0
 ;   callq *%rdi
+;   addq $0x20, %rsp
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -194,18 +191,12 @@ block0(
 ; VCode:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
-; block0:
-;   movq    %rcx, %rax
-;   movq    %rdx, %rcx
-;   movq    %rsi, %rdx
-;   movq    %rdi, %rsi
-;   movq    %rax, %rdi
-;   movq    16(%rbp), %r10
-;   movq    24(%rbp), %r11
-;   movss   32(%rbp), %xmm11
-;   movsd   40(%rbp), %xmm13
 ;   subq    %rsp, $144, %rsp
-;   virtual_sp_offset_adjust 144
+; block0:
+;   movq    rbp(stack args max - 32), %r10
+;   movq    rbp(stack args max - 24), %r11
+;   movss   rbp(stack args max - 16), %xmm11
+;   movsd   rbp(stack args max - 8), %xmm13
 ;   movq    %r8, 32(%rsp)
 ;   movq    %r9, 40(%rsp)
 ;   movsd   %xmm0, 48(%rsp)
@@ -220,12 +211,12 @@ block0(
 ;   movl    %r11d, 120(%rsp)
 ;   movss   %xmm11, 128(%rsp)
 ;   movsd   %xmm13, 136(%rsp)
-;   movq    %rdi, %r9
-;   movq    %rcx, %r8
-;   movq    %rsi, %rcx
+;   movq    %rcx, %r9
+;   movq    %rdx, %r8
+;   movq    %rsi, %rdx
+;   movq    %rdi, %rcx
 ;   call    *%rcx
 ;   addq    %rsp, $144, %rsp
-;   virtual_sp_offset_adjust -144
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -234,17 +225,12 @@ block0(
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
-; block1: ; offset 0x4
-;   movq %rcx, %rax
-;   movq %rdx, %rcx
-;   movq %rsi, %rdx
-;   movq %rdi, %rsi
-;   movq %rax, %rdi
+;   subq $0x90, %rsp
+; block1: ; offset 0xb
 ;   movq 0x10(%rbp), %r10
 ;   movq 0x18(%rbp), %r11
 ;   movss 0x20(%rbp), %xmm11
 ;   movsd 0x28(%rbp), %xmm13
-;   subq $0x90, %rsp
 ;   movq %r8, 0x20(%rsp)
 ;   movq %r9, 0x28(%rsp)
 ;   movsd %xmm0, 0x30(%rsp)
@@ -259,9 +245,10 @@ block0(
 ;   movl %r11d, 0x78(%rsp)
 ;   movss %xmm11, 0x80(%rsp)
 ;   movsd %xmm13, 0x88(%rsp)
-;   movq %rdi, %r9
-;   movq %rcx, %r8
-;   movq %rsi, %rcx
+;   movq %rcx, %r9
+;   movq %rdx, %r8
+;   movq %rsi, %rdx
+;   movq %rdi, %rcx
 ;   callq *%rcx
 ;   addq $0x90, %rsp
 ;   movq %rbp, %rsp
@@ -283,18 +270,15 @@ block0(v0: i64, v1:i64, v2:i64, v3:i64, v4:i64):
 ; VCode:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
+;   subq    %rsp, $48, %rsp
 ; block0:
-;   movq    %rdx, %r11
+;   movq    %r8, 32(%rsp)
 ;   movq    %rcx, %r9
+;   movq    %rdx, %r8
 ;   movq    %rsi, %rdx
 ;   movq    %rdi, %rcx
-;   subq    %rsp, $48, %rsp
-;   virtual_sp_offset_adjust 48
-;   movq    %r8, 32(%rsp)
-;   movq    %r11, %r8
 ;   call    *%rcx
 ;   addq    %rsp, $48, %rsp
-;   virtual_sp_offset_adjust -48
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -303,14 +287,13 @@ block0(v0: i64, v1:i64, v2:i64, v3:i64, v4:i64):
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
-; block1: ; offset 0x4
-;   movq %rdx, %r11
+;   subq $0x30, %rsp
+; block1: ; offset 0x8
+;   movq %r8, 0x20(%rsp)
 ;   movq %rcx, %r9
+;   movq %rdx, %r8
 ;   movq %rsi, %rdx
 ;   movq %rdi, %rcx
-;   subq $0x30, %rsp
-;   movq %r8, 0x20(%rsp)
-;   movq %r11, %r8
 ;   callq *%rcx
 ;   addq $0x30, %rsp
 ;   movq %rbp, %rsp
@@ -327,13 +310,8 @@ block0(v0: i32, v1: f32, v2: i64, v3: f64, v4: i32, v5: i32, v6: i32, v7: f32, v
 ; VCode:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
-; block0:
-;   movq    %rsi, %r9
-;   movq    %rdi, %rsi
-;   movdqa  %xmm1, %xmm6
-;   movdqa  %xmm0, %xmm1
 ;   subq    %rsp, $96, %rsp
-;   virtual_sp_offset_adjust 96
+; block0:
 ;   movl    %edx, 32(%rsp)
 ;   movl    %ecx, 40(%rsp)
 ;   movl    %r8d, 48(%rsp)
@@ -341,12 +319,12 @@ block0(v0: i32, v1: f32, v2: i64, v3: f64, v4: i32, v5: i32, v6: i32, v7: f32, v
 ;   movsd   %xmm3, 64(%rsp)
 ;   movss   %xmm4, 72(%rsp)
 ;   movsd   %xmm5, 80(%rsp)
-;   movq    %rsi, %rcx
-;   movq    %r9, %r8
-;   movdqa  %xmm6, %xmm3
+;   movq    %rdi, %rcx
+;   movq    %rsi, %r8
+;   movdqa  %xmm1, %xmm3
+;   movdqa  %xmm0, %xmm1
 ;   call    *%rcx
 ;   addq    %rsp, $96, %rsp
-;   virtual_sp_offset_adjust -96
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -355,12 +333,8 @@ block0(v0: i32, v1: f32, v2: i64, v3: f64, v4: i32, v5: i32, v6: i32, v7: f32, v
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
-; block1: ; offset 0x4
-;   movq %rsi, %r9
-;   movq %rdi, %rsi
-;   movdqa %xmm1, %xmm6
-;   movdqa %xmm0, %xmm1
 ;   subq $0x60, %rsp
+; block1: ; offset 0x8
 ;   movl %edx, 0x20(%rsp)
 ;   movl %ecx, 0x28(%rsp)
 ;   movl %r8d, 0x30(%rsp)
@@ -368,9 +342,10 @@ block0(v0: i32, v1: f32, v2: i64, v3: f64, v4: i32, v5: i32, v6: i32, v7: f32, v
 ;   movsd %xmm3, 0x40(%rsp)
 ;   movss %xmm4, 0x48(%rsp)
 ;   movsd %xmm5, 0x50(%rsp)
-;   movq %rsi, %rcx
-;   movq %r9, %r8
-;   movdqa %xmm6, %xmm3
+;   movq %rdi, %rcx
+;   movq %rsi, %r8
+;   movdqa %xmm1, %xmm3
+;   movdqa %xmm0, %xmm1
 ;   callq *%rcx
 ;   addq $0x60, %rsp
 ;   movq %rbp, %rsp
@@ -387,14 +362,12 @@ block0(v0: i32, v1: i8x16):
 ; VCode:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
-; block0:
 ;   subq    %rsp, $48, %rsp
-;   virtual_sp_offset_adjust 48
+; block0:
 ;   lea     32(%rsp), %rcx
 ;   movdqu  %xmm0, 0(%rcx)
 ;   call    *%rdi
 ;   addq    %rsp, $48, %rsp
-;   virtual_sp_offset_adjust -48
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -403,8 +376,8 @@ block0(v0: i32, v1: i8x16):
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
-; block1: ; offset 0x4
 ;   subq $0x30, %rsp
+; block1: ; offset 0x8
 ;   leaq 0x20(%rsp), %rcx
 ;   movdqu %xmm0, (%rcx)
 ;   callq *%rdi
@@ -424,19 +397,17 @@ block0(v0: i32, v1: i32, v2: i8x16, v3: i64, v4: i8x16):
 ; VCode:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
+;   subq    %rsp, $64, %rsp
 ; block0:
 ;   movq    %rdx, %r8
-;   movq    %rsi, %rcx
-;   subq    %rsp, $64, %rsp
-;   virtual_sp_offset_adjust 64
 ;   lea     32(%rsp), %rdx
 ;   movdqu  %xmm0, 0(%rdx)
 ;   lea     48(%rsp), %r9
 ;   movdqu  %xmm1, 0(%r9)
+;   movq    %rsi, %rcx
 ;   call    *%rdi
-;   addq    %rsp, $64, %rsp
-;   virtual_sp_offset_adjust -64
 ;   paddb   %xmm0, %xmm0, %xmm0
+;   addq    %rsp, $64, %rsp
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -445,17 +416,17 @@ block0(v0: i32, v1: i32, v2: i8x16, v3: i64, v4: i8x16):
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
-; block1: ; offset 0x4
-;   movq %rdx, %r8
-;   movq %rsi, %rcx
 ;   subq $0x40, %rsp
+; block1: ; offset 0x8
+;   movq %rdx, %r8
 ;   leaq 0x20(%rsp), %rdx
 ;   movdqu %xmm0, (%rdx)
 ;   leaq 0x30(%rsp), %r9
 ;   movdqu %xmm1, (%r9)
+;   movq %rsi, %rcx
 ;   callq *%rdi
-;   addq $0x40, %rsp
 ;   paddb %xmm0, %xmm0
+;   addq $0x40, %rsp
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -470,19 +441,17 @@ block0(v0: i32, v1: i8x16):
 ; VCode:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
+;   subq    %rsp, $64, %rsp
 ; block0:
+;   lea     48(%rsp), %rcx
+;   movdqu  %xmm0, 0(%rcx)
+;   movq    %rcx, 32(%rsp)
 ;   movq    %rdi, %r9
-;   subq    %rsp, $64, %rsp
-;   virtual_sp_offset_adjust 64
-;   lea     48(%rsp), %r8
-;   movdqu  %xmm0, 0(%r8)
-;   movq    %r8, 32(%rsp)
 ;   movq    %r9, %rcx
 ;   movq    %r9, %rdx
 ;   movq    %r9, %r8
 ;   call    *%r9
 ;   addq    %rsp, $64, %rsp
-;   virtual_sp_offset_adjust -64
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -491,12 +460,12 @@ block0(v0: i32, v1: i8x16):
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
-; block1: ; offset 0x4
-;   movq %rdi, %r9
 ;   subq $0x40, %rsp
-;   leaq 0x30(%rsp), %r8
-;   movdqu %xmm0, (%r8)
-;   movq %r8, 0x20(%rsp)
+; block1: ; offset 0x8
+;   leaq 0x30(%rsp), %rcx
+;   movdqu %xmm0, (%rcx)
+;   movq %rcx, 0x20(%rsp)
+;   movq %rdi, %r9
 ;   movq %r9, %rcx
 ;   movq %r9, %rdx
 ;   movq %r9, %r8
@@ -516,22 +485,20 @@ block0(v0: i32, v1: i8x16):
 ; VCode:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
+;   subq    %rsp, $80, %rsp
 ; block0:
+;   lea     48(%rsp), %rcx
+;   movdqu  %xmm0, 0(%rcx)
+;   movq    %rcx, 32(%rsp)
+;   lea     64(%rsp), %r10
+;   movdqu  %xmm0, 0(%r10)
+;   movq    %r10, 40(%rsp)
 ;   movq    %rdi, %r9
-;   subq    %rsp, $80, %rsp
-;   virtual_sp_offset_adjust 80
-;   lea     48(%rsp), %r8
-;   movdqu  %xmm0, 0(%r8)
-;   movq    %r8, 32(%rsp)
-;   lea     64(%rsp), %rsi
-;   movdqu  %xmm0, 0(%rsi)
-;   movq    %rsi, 40(%rsp)
 ;   movq    %r9, %rcx
 ;   movq    %r9, %rdx
 ;   movq    %r9, %r8
 ;   call    *%r9
 ;   addq    %rsp, $80, %rsp
-;   virtual_sp_offset_adjust -80
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -540,15 +507,15 @@ block0(v0: i32, v1: i8x16):
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
-; block1: ; offset 0x4
-;   movq %rdi, %r9
 ;   subq $0x50, %rsp
-;   leaq 0x30(%rsp), %r8
-;   movdqu %xmm0, (%r8)
-;   movq %r8, 0x20(%rsp)
-;   leaq 0x40(%rsp), %rsi
-;   movdqu %xmm0, (%rsi)
-;   movq %rsi, 0x28(%rsp)
+; block1: ; offset 0x8
+;   leaq 0x30(%rsp), %rcx
+;   movdqu %xmm0, (%rcx)
+;   movq %rcx, 0x20(%rsp)
+;   leaq 0x40(%rsp), %r10
+;   movdqu %xmm0, (%r10)
+;   movq %r10, 0x28(%rsp)
+;   movq %rdi, %r9
 ;   movq %r9, %rcx
 ;   movq %r9, %rdx
 ;   movq %r9, %r8
@@ -568,23 +535,21 @@ block0(v0: i32, v1: i8x16):
 ; VCode:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
-; block0:
-;   movq    %rdi, %r9
 ;   subq    %rsp, $96, %rsp
-;   virtual_sp_offset_adjust 96
+; block0:
 ;   lea     48(%rsp), %rdx
 ;   movdqu  %xmm0, 0(%rdx)
-;   lea     64(%rsp), %r11
-;   movdqu  %xmm0, 0(%r11)
-;   movq    %r11, 32(%rsp)
-;   lea     80(%rsp), %rcx
-;   movdqu  %xmm0, 0(%rcx)
-;   movq    %rcx, 40(%rsp)
+;   lea     64(%rsp), %r9
+;   movdqu  %xmm0, 0(%r9)
+;   movq    %r9, 32(%rsp)
+;   lea     80(%rsp), %rax
+;   movdqu  %xmm0, 0(%rax)
+;   movq    %rax, 40(%rsp)
+;   movq    %rdi, %r9
 ;   movq    %r9, %rcx
 ;   movq    %r9, %r8
 ;   call    *%r9
 ;   addq    %rsp, $96, %rsp
-;   virtual_sp_offset_adjust -96
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -593,17 +558,17 @@ block0(v0: i32, v1: i8x16):
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
-; block1: ; offset 0x4
-;   movq %rdi, %r9
 ;   subq $0x60, %rsp
+; block1: ; offset 0x8
 ;   leaq 0x30(%rsp), %rdx
 ;   movdqu %xmm0, (%rdx)
-;   leaq 0x40(%rsp), %r11
-;   movdqu %xmm0, (%r11)
-;   movq %r11, 0x20(%rsp)
-;   leaq 0x50(%rsp), %rcx
-;   movdqu %xmm0, (%rcx)
-;   movq %rcx, 0x28(%rsp)
+;   leaq 0x40(%rsp), %r9
+;   movdqu %xmm0, (%r9)
+;   movq %r9, 0x20(%rsp)
+;   leaq 0x50(%rsp), %rax
+;   movdqu %xmm0, (%rax)
+;   movq %rax, 0x28(%rsp)
+;   movq %rdi, %r9
 ;   movq %r9, %rcx
 ;   movq %r9, %r8
 ;   callq *%r9
@@ -612,3 +577,98 @@ block0(v0: i32, v1: i8x16):
 ;   popq %rbp
 ;   retq
 
+function %second_f16(f16, f16) -> f16 system_v {
+block0(v0: f16, v1: f16):
+    return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movdqa  %xmm1, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movdqa %xmm1, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %second_f128(f128, f128) -> f128 system_v {
+block0(v0: f128, v1: f128):
+    return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movdqa  %xmm1, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movdqa %xmm1, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %second_f16_fastcall(f16, f16) -> f16 windows_fastcall {
+block0(v0: f16, v1: f16):
+    return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movdqa  %xmm1, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movdqa %xmm1, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %second_f128(f128, f128) -> f128 windows_fastcall {
+block0(v0: f128, v1: f128):
+    return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movdqa  %xmm1, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movdqa %xmm1, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
diff --git a/cranelift/filetests/filetests/isa/x64/clz-lzcnt.clif b/cranelift/filetests/filetests/isa/x64/clz-lzcnt.clif
index 24c8e3bcaa5a..af8ca47f5aec 100644
--- a/cranelift/filetests/filetests/isa/x64/clz-lzcnt.clif
+++ b/cranelift/filetests/filetests/isa/x64/clz-lzcnt.clif
@@ -1,6 +1,43 @@
 test compile precise-output
+set enable_llvm_abi_extensions=true
 target x86_64 has_lzcnt
 
+
+function %clz(i128) -> i128 {
+block0(v0: i128):
+    v1 = clz v0
+    return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   lzcntq  %rsi, %rcx
+;   lzcntq  %rdi, %rax
+;   addq    %rax, $64, %rax
+;   cmpq    $64, %rcx
+;   cmovnzq %rcx, %rax, %rax
+;   xorq    %rdx, %rdx, %rdx
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   lzcntq %rsi, %rcx
+;   lzcntq %rdi, %rax
+;   addq $0x40, %rax
+;   cmpq $0x40, %rcx
+;   cmovneq %rcx, %rax
+;   xorq %rdx, %rdx
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
 function %clz(i64) -> i64 {
 block0(v0: i64):
     v1 = clz v0
@@ -51,3 +88,61 @@ block0(v0: i32):
 ;   popq %rbp
 ;   retq
 
+function %clz(i16) -> i16 {
+block0(v0: i16):
+    v1 = clz v0
+    return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movzwq  %di, %rax
+;   lzcntq  %rax, %rax
+;   subq    %rax, $48, %rax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movzwq %di, %rax
+;   lzcntq %rax, %rax
+;   subq $0x30, %rax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %clz(i8) -> i8 {
+block0(v0: i8):
+    v1 = clz v0
+    return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movzbq  %dil, %rax
+;   lzcntq  %rax, %rax
+;   subq    %rax, $56, %rax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movzbq %dil, %rax
+;   lzcntq %rax, %rax
+;   subq $0x38, %rax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/clz.clif b/cranelift/filetests/filetests/isa/x64/clz.clif
new file mode 100644
index 000000000000..542024eb245d
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/clz.clif
@@ -0,0 +1,198 @@
+test compile precise-output
+set enable_llvm_abi_extensions=true
+target x86_64
+
+
+function %clz(i128) -> i128 {
+block0(v0: i128):
+    v1 = clz v0
+    return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movq    %rdi, %r8
+;   movabsq $-1, %rcx
+;   bsrq    %rsi, %r9
+;   cmovzq  %rcx, %r9, %r9
+;   movl    $63, %edi
+;   subq    %rdi, %r9, %rdi
+;   movabsq $-1, %rdx
+;   bsrq    %r8, %r10
+;   cmovzq  %rdx, %r10, %r10
+;   movl    $63, %eax
+;   subq    %rax, %r10, %rax
+;   addq    %rax, $64, %rax
+;   cmpq    $64, %rdi
+;   cmovnzq %rdi, %rax, %rax
+;   xorq    %rdx, %rdx, %rdx
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movq %rdi, %r8
+;   movq $18446744073709551615, %rcx
+;   bsrq %rsi, %r9
+;   cmoveq %rcx, %r9
+;   movl $0x3f, %edi
+;   subq %r9, %rdi
+;   movq $18446744073709551615, %rdx
+;   bsrq %r8, %r10
+;   cmoveq %rdx, %r10
+;   movl $0x3f, %eax
+;   subq %r10, %rax
+;   addq $0x40, %rax
+;   cmpq $0x40, %rdi
+;   cmovneq %rdi, %rax
+;   xorq %rdx, %rdx
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %clz(i64) -> i64 {
+block0(v0: i64):
+    v1 = clz v0
+    return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movabsq $-1, %rax
+;   bsrq    %rdi, %r8
+;   cmovzq  %rax, %r8, %r8
+;   movl    $63, %eax
+;   subq    %rax, %r8, %rax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movq $18446744073709551615, %rax
+;   bsrq %rdi, %r8
+;   cmoveq %rax, %r8
+;   movl $0x3f, %eax
+;   subq %r8, %rax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %clz(i32) -> i32 {
+block0(v0: i32):
+    v1 = clz v0
+    return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movabsq $-1, %rax
+;   bsrl    %edi, %r8d
+;   cmovzl  %eax, %r8d, %r8d
+;   movl    $31, %eax
+;   subl    %eax, %r8d, %eax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movq $18446744073709551615, %rax
+;   bsrl %edi, %r8d
+;   cmovel %eax, %r8d
+;   movl $0x1f, %eax
+;   subl %r8d, %eax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %clz(i16) -> i16 {
+block0(v0: i16):
+    v1 = clz v0
+    return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movzwq  %di, %rax
+;   movabsq $-1, %rdx
+;   bsrq    %rax, %r10
+;   cmovzq  %rdx, %r10, %r10
+;   movl    $63, %eax
+;   subq    %rax, %r10, %rax
+;   subq    %rax, $48, %rax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movzwq %di, %rax
+;   movq $18446744073709551615, %rdx
+;   bsrq %rax, %r10
+;   cmoveq %rdx, %r10
+;   movl $0x3f, %eax
+;   subq %r10, %rax
+;   subq $0x30, %rax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %clz(i8) -> i8 {
+block0(v0: i8):
+    v1 = clz v0
+    return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movzbq  %dil, %rax
+;   movabsq $-1, %rdx
+;   bsrq    %rax, %r10
+;   cmovzq  %rdx, %r10, %r10
+;   movl    $63, %eax
+;   subq    %rax, %r10, %rax
+;   subq    %rax, $56, %rax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movzbq %dil, %rax
+;   movq $18446744073709551615, %rdx
+;   bsrq %rax, %r10
+;   cmoveq %rdx, %r10
+;   movl $0x3f, %eax
+;   subq %r10, %rax
+;   subq $0x38, %rax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/conditional-values.clif b/cranelift/filetests/filetests/isa/x64/conditional-values.clif
index d54ebd4f34a8..8cba952ac3d7 100644
--- a/cranelift/filetests/filetests/isa/x64/conditional-values.clif
+++ b/cranelift/filetests/filetests/isa/x64/conditional-values.clif
@@ -347,8 +347,8 @@ block0(v0: i64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
+;   notq    %rdi, %rdi
 ;   movq    %rdi, %rax
-;   notq    %rax, %rax
 ;   shrq    $63, %rax, %rax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -359,8 +359,8 @@ block0(v0: i64):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
+;   notq %rdi
 ;   movq %rdi, %rax
-;   notq %rax
 ;   shrq $0x3f, %rax
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -377,8 +377,8 @@ block0(v0: i32):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
+;   notq    %rdi, %rdi
 ;   movq    %rdi, %rax
-;   notq    %rax, %rax
 ;   shrl    $31, %eax, %eax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -389,8 +389,8 @@ block0(v0: i32):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
+;   notq %rdi
 ;   movq %rdi, %rax
-;   notq %rax
 ;   shrl $0x1f, %eax
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -407,8 +407,8 @@ block0(v0: i64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
+;   notq    %rdi, %rdi
 ;   movq    %rdi, %rax
-;   notq    %rax, %rax
 ;   shrq    $63, %rax, %rax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -419,8 +419,8 @@ block0(v0: i64):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
+;   notq %rdi
 ;   movq %rdi, %rax
-;   notq %rax
 ;   shrq $0x3f, %rax
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -437,8 +437,8 @@ block0(v0: i32):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
+;   notq    %rdi, %rdi
 ;   movq    %rdi, %rax
-;   notq    %rax, %rax
 ;   shrl    $31, %eax, %eax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -449,8 +449,8 @@ block0(v0: i32):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
+;   notq %rdi
 ;   movq %rdi, %rax
-;   notq %rax
 ;   shrl $0x1f, %eax
 ;   movq %rbp, %rsp
 ;   popq %rbp
diff --git a/cranelift/filetests/filetests/isa/x64/ctz-bmi1.clif b/cranelift/filetests/filetests/isa/x64/ctz-bmi1.clif
index 473efb005f80..a2634db915f3 100644
--- a/cranelift/filetests/filetests/isa/x64/ctz-bmi1.clif
+++ b/cranelift/filetests/filetests/isa/x64/ctz-bmi1.clif
@@ -1,6 +1,43 @@
 test compile precise-output
+set enable_llvm_abi_extensions=true
 target x86_64 has_bmi1
 
+
+function %ctz(i128) -> i128 {
+block0(v0: i128):
+    v1 = ctz v0
+    return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   tzcntq  %rdi, %rax
+;   tzcntq  %rsi, %r9
+;   addq    %r9, $64, %r9
+;   cmpq    $64, %rax
+;   cmovzq  %r9, %rax, %rax
+;   xorq    %rdx, %rdx, %rdx
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   tzcntq %rdi, %rax
+;   tzcntq %rsi, %r9
+;   addq $0x40, %r9
+;   cmpq $0x40, %rax
+;   cmoveq %r9, %rax
+;   xorq %rdx, %rdx
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
 function %ctz(i64) -> i64 {
 block0(v0: i64):
     v1 = ctz v0
@@ -51,3 +88,61 @@ block0(v0: i32):
 ;   popq %rbp
 ;   retq
 
+function %ctz(i16) -> i16 {
+block0(v0: i16):
+    v1 = ctz v0
+    return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movzwl  %di, %ecx
+;   orl     %ecx, $65536, %ecx
+;   tzcntl  %ecx, %eax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movzwl %di, %ecx
+;   orl $0x10000, %ecx
+;   tzcntl %ecx, %eax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %ctz(i8) -> i8 {
+block0(v0: i8):
+    v1 = ctz v0
+    return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movzbl  %dil, %ecx
+;   orl     %ecx, $256, %ecx
+;   tzcntl  %ecx, %eax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movzbl %dil, %ecx
+;   orl $0x100, %ecx
+;   tzcntl %ecx, %eax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/ctz.clif b/cranelift/filetests/filetests/isa/x64/ctz.clif
new file mode 100644
index 000000000000..9c9ef5c053f0
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/ctz.clif
@@ -0,0 +1,172 @@
+test compile precise-output
+set enable_llvm_abi_extensions=true
+target x86_64
+
+
+function %ctz(i128) -> i128 {
+block0(v0: i128):
+    v1 = ctz v0
+    return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movl    $64, %ecx
+;   bsfq    %rdi, %rax
+;   cmovzq  %rcx, %rax, %rax
+;   movl    $64, %edi
+;   bsfq    %rsi, %rdx
+;   cmovzq  %rdi, %rdx, %rdx
+;   addq    %rdx, $64, %rdx
+;   cmpq    $64, %rax
+;   cmovzq  %rdx, %rax, %rax
+;   xorq    %rdx, %rdx, %rdx
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movl $0x40, %ecx
+;   bsfq %rdi, %rax
+;   cmoveq %rcx, %rax
+;   movl $0x40, %edi
+;   bsfq %rsi, %rdx
+;   cmoveq %rdi, %rdx
+;   addq $0x40, %rdx
+;   cmpq $0x40, %rax
+;   cmoveq %rdx, %rax
+;   xorq %rdx, %rdx
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %ctz(i64) -> i64 {
+block0(v0: i64):
+    v1 = ctz v0
+    return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movl    $64, %ecx
+;   bsfq    %rdi, %rax
+;   cmovzq  %rcx, %rax, %rax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movl $0x40, %ecx
+;   bsfq %rdi, %rax
+;   cmoveq %rcx, %rax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %ctz(i32) -> i32 {
+block0(v0: i32):
+    v1 = ctz v0
+    return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movl    $32, %ecx
+;   bsfl    %edi, %eax
+;   cmovzl  %ecx, %eax, %eax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movl $0x20, %ecx
+;   bsfl %edi, %eax
+;   cmovel %ecx, %eax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %ctz(i16) -> i16 {
+block0(v0: i16):
+    v1 = ctz v0
+    return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movzwl  %di, %ecx
+;   orl     %ecx, $65536, %ecx
+;   movl    $16, %r9d
+;   bsfl    %ecx, %eax
+;   cmovzl  %r9d, %eax, %eax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movzwl %di, %ecx
+;   orl $0x10000, %ecx
+;   movl $0x10, %r9d
+;   bsfl %ecx, %eax
+;   cmovel %r9d, %eax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %ctz(i8) -> i8 {
+block0(v0: i8):
+    v1 = ctz v0
+    return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movzbl  %dil, %ecx
+;   orl     %ecx, $256, %ecx
+;   movl    $8, %r9d
+;   bsfl    %ecx, %eax
+;   cmovzl  %r9d, %eax, %eax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movzbl %dil, %ecx
+;   orl $0x100, %ecx
+;   movl $8, %r9d
+;   bsfl %ecx, %eax
+;   cmovel %r9d, %eax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/f128const.clif b/cranelift/filetests/filetests/isa/x64/f128const.clif
new file mode 100644
index 000000000000..22ee804d6d6f
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/f128const.clif
@@ -0,0 +1,69 @@
+test compile precise-output
+target x86_64
+
+function %ret_0() -> f128 {
+block0():
+  v0 = f128const 0.0
+  return v0
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   uninit  %xmm0
+;   xorps   %xmm0, %xmm0, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   xorps %xmm0, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %ret_1() -> f128 {
+block0():
+  v0 = f128const 0x1.0
+  return v0
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movdqu  const(0), %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movdqu 0x14(%rip), %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %bh, %bh
+
diff --git a/cranelift/filetests/filetests/isa/x64/f16const.clif b/cranelift/filetests/filetests/isa/x64/f16const.clif
new file mode 100644
index 000000000000..edcaf2ac29fd
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/f16const.clif
@@ -0,0 +1,57 @@
+test compile precise-output
+target x86_64
+
+function %ret_0() -> f16 {
+block0():
+  v0 = f16const 0.0
+  return v0
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   uninit  %xmm0
+;   xorps   %xmm0, %xmm0, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   xorps %xmm0, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %ret_1() -> f16 {
+block0():
+  v0 = f16const 0x1.0
+  return v0
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movl    $15360, %esi
+;   uninit  %xmm0
+;   pinsrw  $0, %xmm0, %rsi, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movl $0x3c00, %esi
+;   pinsrw $0, %esi, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/f64-branches-avx.clif b/cranelift/filetests/filetests/isa/x64/f64-branches-avx.clif
new file mode 100644
index 000000000000..f40100bbfa97
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/f64-branches-avx.clif
@@ -0,0 +1,105 @@
+test compile precise-output
+target x86_64 has_avx
+
+function %f3(f32, f32) -> i32 {
+block0(v0: f32, v1: f32):
+  v2 = fcmp eq v0, v1
+  brif v2, block1, block2
+
+block1:
+  v3 = iconst.i32 1
+  return v3
+
+block2:
+  v4 = iconst.i32 2
+  return v4
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   vucomiss %xmm1, %xmm0
+;   jp      label1
+;   jnz     label1; j label2
+; block1:
+;   movl    $2, %eax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+; block2:
+;   movl    $1, %eax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   vucomiss %xmm1, %xmm0
+;   jp 0x14
+;   je 0x1e
+; block2: ; offset 0x14
+;   movl $2, %eax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+; block3: ; offset 0x1e
+;   movl $1, %eax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %f3(f64, f64) -> i32 {
+block0(v0: f64, v1: f64):
+  v2 = fcmp eq v0, v1
+  brif v2, block1, block2
+
+block1:
+  v3 = iconst.i32 1
+  return v3
+
+block2:
+  v4 = iconst.i32 2
+  return v4
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   vucomisd %xmm1, %xmm0
+;   jp      label1
+;   jnz     label1; j label2
+; block1:
+;   movl    $2, %eax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+; block2:
+;   movl    $1, %eax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   vucomisd %xmm1, %xmm0
+;   jp 0x14
+;   je 0x1e
+; block2: ; offset 0x14
+;   movl $2, %eax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+; block3: ; offset 0x1e
+;   movl $1, %eax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/fastcall.clif b/cranelift/filetests/filetests/isa/x64/fastcall.clif
index d83c9fbee0f0..b12e5452234e 100644
--- a/cranelift/filetests/filetests/isa/x64/fastcall.clif
+++ b/cranelift/filetests/filetests/isa/x64/fastcall.clif
@@ -180,8 +180,7 @@ block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64):
 ;   movq    %rsp, %rbp
 ;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
 ; block0:
-;   movq    48(%rbp), %r8
-;   movq    56(%rbp), %rax
+;   movq    rbp(stack args max - 8), %rax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -191,7 +190,6 @@ block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq 0x30(%rbp), %r8
 ;   movq 0x38(%rbp), %rax
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -208,9 +206,8 @@ block0(v0: i128, v1: i64, v2: i128, v3: i128):
 ;   movq    %rsp, %rbp
 ;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
 ; block0:
-;   movq    48(%rbp), %r8
-;   movq    56(%rbp), %rax
-;   movq    64(%rbp), %rdx
+;   movq    rbp(stack args max - 24), %rax
+;   movq    rbp(stack args max - 16), %rdx
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -220,7 +217,6 @@ block0(v0: i128, v1: i64, v2: i128, v3: i128):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq 0x30(%rbp), %r8
 ;   movq 0x38(%rbp), %rax
 ;   movq 0x40(%rbp), %rdx
 ;   movq %rbp, %rsp
@@ -241,27 +237,19 @@ block0(v0: i64):
 ;   pushq   %rbp
 ;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
 ;   movq    %rsp, %rbp
-;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 16 }
-;   subq    %rsp, $16, %rsp
-;   movq    %rdi, 0(%rsp)
-;   unwind SaveReg { clobber_offset: 0, reg: p7i }
+;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
+;   subq    %rsp, $48, %rsp
 ; block0:
 ;   uninit  %xmm3
 ;   xorpd   %xmm3, %xmm3, %xmm3
 ;   cvtsi2sd %xmm3, %rcx, %xmm3
-;   subq    %rsp, $48, %rsp
-;   virtual_sp_offset_adjust 48
 ;   movq    %rcx, 32(%rsp)
 ;   movq    %rcx, 40(%rsp)
+;   load_ext_name %g+0, %r11
 ;   movq    %rcx, %rdx
-;   load_ext_name %g+0, %rdi
-;   movq    %rdx, %rcx
 ;   movdqa  %xmm3, %xmm2
-;   call    *%rdi
+;   call    *%r11
 ;   addq    %rsp, $48, %rsp
-;   virtual_sp_offset_adjust -48
-;   movq    0(%rsp), %rdi
-;   addq    %rsp, $16, %rsp
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -270,22 +258,17 @@ block0(v0: i64):
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
-;   subq $0x10, %rsp
-;   movq %rdi, (%rsp)
-; block1: ; offset 0xc
+;   subq $0x30, %rsp
+; block1: ; offset 0x8
 ;   xorpd %xmm3, %xmm3
 ;   cvtsi2sdq %rcx, %xmm3
-;   subq $0x30, %rsp
 ;   movq %rcx, 0x20(%rsp)
 ;   movq %rcx, 0x28(%rsp)
+;   movabsq $0, %r11 ; reloc_external Abs8 %g 0
 ;   movq %rcx, %rdx
-;   movabsq $0, %rdi ; reloc_external Abs8 %g 0
-;   movq %rdx, %rcx
 ;   movdqa %xmm3, %xmm2
-;   callq *%rdi
+;   callq *%r11
 ;   addq $0x30, %rsp
-;   movq (%rsp), %rdi
-;   addq $0x10, %rsp
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
diff --git a/cranelift/filetests/filetests/isa/x64/fcvt-avx.clif b/cranelift/filetests/filetests/isa/x64/fcvt-avx.clif
index d46212e18597..61f7f0ec357b 100644
--- a/cranelift/filetests/filetests/isa/x64/fcvt-avx.clif
+++ b/cranelift/filetests/filetests/isa/x64/fcvt-avx.clif
@@ -113,3 +113,83 @@ block0(v0: i64):
 ;   popq %rbp
 ;   retq
 
+function %u64x2_to_f64x2(i64x2) -> f64x2 {
+block0(v0: i64x2):
+  v1 = fcvt_from_uint.f64x2 v0
+  return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   vpand   %xmm0, const(0), %xmm2
+;   vpor    %xmm2, const(1), %xmm4
+;   vpsrlq  %xmm0, $32, %xmm6
+;   vpor    %xmm6, const(2), %xmm0
+;   vsubpd  %xmm0, const(3), %xmm2
+;   vaddpd  %xmm4, %xmm2, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   vpand 0x34(%rip), %xmm0, %xmm2
+;   vpor 0x3c(%rip), %xmm2, %xmm4
+;   vpsrlq $0x20, %xmm0, %xmm6
+;   vpor 0x3f(%rip), %xmm6, %xmm0
+;   vsubpd 0x47(%rip), %xmm0, %xmm2
+;   vaddpd %xmm2, %xmm4, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+
+function %i64x2_to_f64x2(i64x2) -> f64x2 {
+block0(v0: i64x2):
+  v1 = fcvt_from_sint.f64x2 v0
+  return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   uninit  %xmm2
+;   vxorpd  %xmm2, %xmm2, %xmm4
+;   vmovq   %xmm0, %r9
+;   vcvtsi2sd %xmm4, %r9, %xmm1
+;   vpshufd $238, %xmm0, %xmm2
+;   vmovq   %xmm2, %rcx
+;   vcvtsi2sd %xmm4, %rcx, %xmm6
+;   vunpcklpd %xmm1, %xmm6, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   vxorpd %xmm2, %xmm2, %xmm4
+;   vmovq %xmm0, %r9
+;   vcvtsi2sdq %r9, %xmm4, %xmm1
+;   vpshufd $0xee, %xmm0, %xmm2
+;   vmovq %xmm2, %rcx
+;   vcvtsi2sdq %rcx, %xmm4, %xmm6
+;   vunpcklpd %xmm6, %xmm1, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/fcvt.clif b/cranelift/filetests/filetests/isa/x64/fcvt.clif
index 1a04881cf022..ae506aa096d1 100644
--- a/cranelift/filetests/filetests/isa/x64/fcvt.clif
+++ b/cranelift/filetests/filetests/isa/x64/fcvt.clif
@@ -1066,15 +1066,14 @@ block0(v0: f32x4):
 ; block0:
 ;   uninit  %xmm6
 ;   xorps   %xmm6, %xmm6, %xmm6
-;   movdqa  %xmm0, %xmm3
-;   maxps   %xmm3, %xmm6, %xmm3
+;   maxps   %xmm0, %xmm6, %xmm0
 ;   pcmpeqd %xmm6, %xmm6, %xmm6
 ;   psrld   %xmm6, $1, %xmm6
 ;   cvtdq2ps %xmm6, %xmm7
-;   cvttps2dq %xmm3, %xmm6
-;   subps   %xmm3, %xmm7, %xmm3
-;   cmpps   $2, %xmm7, %xmm3, %xmm7
-;   cvttps2dq %xmm3, %xmm0
+;   cvttps2dq %xmm0, %xmm6
+;   subps   %xmm0, %xmm7, %xmm0
+;   cmpps   $2, %xmm7, %xmm0, %xmm7
+;   cvttps2dq %xmm0, %xmm0
 ;   pxor    %xmm0, %xmm7, %xmm0
 ;   uninit  %xmm1
 ;   pxor    %xmm1, %xmm1, %xmm1
@@ -1090,15 +1089,14 @@ block0(v0: f32x4):
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
 ;   xorps %xmm6, %xmm6
-;   movdqa %xmm0, %xmm3
-;   maxps %xmm6, %xmm3
+;   maxps %xmm6, %xmm0
 ;   pcmpeqd %xmm6, %xmm6
 ;   psrld $1, %xmm6
 ;   cvtdq2ps %xmm6, %xmm7
-;   cvttps2dq %xmm3, %xmm6
-;   subps %xmm7, %xmm3
-;   cmpleps %xmm3, %xmm7
-;   cvttps2dq %xmm3, %xmm0
+;   cvttps2dq %xmm0, %xmm6
+;   subps %xmm7, %xmm0
+;   cmpleps %xmm0, %xmm7
+;   cvttps2dq %xmm0, %xmm0
 ;   pxor %xmm7, %xmm0
 ;   pxor %xmm1, %xmm1
 ;   pmaxsd %xmm1, %xmm0
@@ -1119,10 +1117,9 @@ block0(v0: f32x4):
 ; block0:
 ;   movdqa  %xmm0, %xmm4
 ;   cmpps   $0, %xmm4, %xmm0, %xmm4
-;   movdqa  %xmm0, %xmm5
-;   andps   %xmm5, %xmm4, %xmm5
-;   pxor    %xmm4, %xmm5, %xmm4
-;   cvttps2dq %xmm5, %xmm1
+;   andps   %xmm0, %xmm4, %xmm0
+;   pxor    %xmm4, %xmm0, %xmm4
+;   cvttps2dq %xmm0, %xmm1
 ;   movdqa  %xmm1, %xmm0
 ;   pand    %xmm0, %xmm4, %xmm0
 ;   psrad   %xmm0, $31, %xmm0
@@ -1138,10 +1135,9 @@ block0(v0: f32x4):
 ; block1: ; offset 0x4
 ;   movdqa %xmm0, %xmm4
 ;   cmpeqps %xmm0, %xmm4
-;   movdqa %xmm0, %xmm5
-;   andps %xmm4, %xmm5
-;   pxor %xmm5, %xmm4
-;   cvttps2dq %xmm5, %xmm1
+;   andps %xmm4, %xmm0
+;   pxor %xmm0, %xmm4
+;   cvttps2dq %xmm0, %xmm1
 ;   movdqa %xmm1, %xmm0
 ;   pand %xmm4, %xmm0
 ;   psrad $0x1f, %xmm0
@@ -1150,3 +1146,95 @@ block0(v0: f32x4):
 ;   popq %rbp
 ;   retq
 
+function %u64x2_to_f64x2(i64x2) -> f64x2 {
+block0(v0: i64x2):
+  v1 = fcvt_from_uint.f64x2 v0
+  return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movdqa  %xmm0, %xmm7
+;   pand    %xmm7, const(0), %xmm7
+;   movdqa  %xmm7, %xmm1
+;   por     %xmm1, const(1), %xmm1
+;   movdqa  %xmm1, %xmm7
+;   psrlq   %xmm0, $32, %xmm0
+;   por     %xmm0, const(2), %xmm0
+;   subpd   %xmm0, const(3), %xmm0
+;   movdqa  %xmm0, %xmm1
+;   movdqa  %xmm7, %xmm0
+;   addpd   %xmm0, %xmm1, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movdqa %xmm0, %xmm7
+;   pand 0x40(%rip), %xmm7
+;   movdqa %xmm7, %xmm1
+;   por 0x44(%rip), %xmm1
+;   movdqa %xmm1, %xmm7
+;   psrlq $0x20, %xmm0
+;   por 0x43(%rip), %xmm0
+;   subpd 0x4b(%rip), %xmm0
+;   movdqa %xmm0, %xmm1
+;   movdqa %xmm7, %xmm0
+;   addpd %xmm1, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+
+function %i64x2_to_f64x2(i64x2) -> f64x2 {
+block0(v0: i64x2):
+  v1 = fcvt_from_sint.f64x2 v0
+  return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   uninit  %xmm1
+;   xorpd   %xmm1, %xmm1, %xmm1
+;   movdqa  %xmm0, %xmm6
+;   movq    %xmm6, %r9
+;   movdqa  %xmm1, %xmm0
+;   cvtsi2sd %xmm0, %r9, %xmm0
+;   pshufd  $238, %xmm6, %xmm2
+;   movq    %xmm2, %rcx
+;   cvtsi2sd %xmm1, %rcx, %xmm1
+;   unpcklpd %xmm0, %xmm1, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   xorpd %xmm1, %xmm1
+;   movdqa %xmm0, %xmm6
+;   movq %xmm6, %r9
+;   movdqa %xmm1, %xmm0
+;   cvtsi2sdq %r9, %xmm0
+;   pshufd $0xee, %xmm6, %xmm2
+;   movq %xmm2, %rcx
+;   cvtsi2sdq %rcx, %xmm1
+;   unpcklpd %xmm1, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/fma-call.clif b/cranelift/filetests/filetests/isa/x64/fma-call.clif
index 3bb595a4fe26..5572974f00c1 100644
--- a/cranelift/filetests/filetests/isa/x64/fma-call.clif
+++ b/cranelift/filetests/filetests/isa/x64/fma-call.clif
@@ -70,30 +70,27 @@ block0(v0: f32x4, v1: f32x4, v2: f32x4):
 ;   movdqu  %xmm1, rsp(16 + virtual offset)
 ;   movdqu  %xmm2, rsp(32 + virtual offset)
 ;   load_ext_name %FmaF32+0, %r8
-;   movdqu  rsp(0 + virtual offset), %xmm0
-;   movdqu  rsp(16 + virtual offset), %xmm1
-;   movdqu  rsp(32 + virtual offset), %xmm2
 ;   call    *%r8
-;   movdqu  %xmm0, rsp(48 + virtual offset)
 ;   movdqu  rsp(0 + virtual offset), %xmm4
+;   movdqu  %xmm0, rsp(80 + virtual offset)
 ;   pshufd  $1, %xmm4, %xmm0
 ;   movdqu  rsp(16 + virtual offset), %xmm2
 ;   pshufd  $1, %xmm2, %xmm1
-;   movdqu  rsp(32 + virtual offset), %xmm4
-;   pshufd  $1, %xmm4, %xmm2
+;   movdqu  rsp(32 + virtual offset), %xmm5
+;   pshufd  $1, %xmm5, %xmm2
 ;   load_ext_name %FmaF32+0, %r9
 ;   call    *%r9
-;   movdqu  %xmm0, rsp(64 + virtual offset)
 ;   movdqu  rsp(0 + virtual offset), %xmm4
+;   movdqu  %xmm0, rsp(48 + virtual offset)
 ;   pshufd  $2, %xmm4, %xmm0
-;   movdqu  rsp(16 + virtual offset), %xmm6
-;   pshufd  $2, %xmm6, %xmm1
+;   movdqu  rsp(16 + virtual offset), %xmm7
+;   pshufd  $2, %xmm7, %xmm1
 ;   movdqu  rsp(32 + virtual offset), %xmm3
 ;   pshufd  $2, %xmm3, %xmm2
 ;   load_ext_name %FmaF32+0, %r10
 ;   call    *%r10
-;   movdqu  %xmm0, rsp(80 + virtual offset)
 ;   movdqu  rsp(0 + virtual offset), %xmm4
+;   movdqu  %xmm0, rsp(64 + virtual offset)
 ;   pshufd  $3, %xmm4, %xmm0
 ;   movdqu  rsp(16 + virtual offset), %xmm1
 ;   pshufd  $3, %xmm1, %xmm1
@@ -101,12 +98,12 @@ block0(v0: f32x4, v1: f32x4, v2: f32x4):
 ;   pshufd  $3, %xmm2, %xmm2
 ;   load_ext_name %FmaF32+0, %r11
 ;   call    *%r11
-;   movdqu  rsp(64 + virtual offset), %xmm4
 ;   movdqa  %xmm0, %xmm2
-;   movdqu  rsp(48 + virtual offset), %xmm0
-;   insertps $16, %xmm0, %xmm4, %xmm0
-;   movdqu  rsp(80 + virtual offset), %xmm1
-;   insertps $32, %xmm0, %xmm1, %xmm0
+;   movdqu  rsp(48 + virtual offset), %xmm1
+;   movdqu  rsp(80 + virtual offset), %xmm0
+;   insertps $16, %xmm0, %xmm1, %xmm0
+;   movdqu  rsp(64 + virtual offset), %xmm6
+;   insertps $32, %xmm0, %xmm6, %xmm0
 ;   movdqa  %xmm2, %xmm3
 ;   insertps $48, %xmm0, %xmm3, %xmm0
 ;   addq    %rsp, $96, %rsp
@@ -124,30 +121,27 @@ block0(v0: f32x4, v1: f32x4, v2: f32x4):
 ;   movdqu %xmm1, 0x10(%rsp)
 ;   movdqu %xmm2, 0x20(%rsp)
 ;   movabsq $0, %r8 ; reloc_external Abs8 %FmaF32 0
-;   movdqu (%rsp), %xmm0
-;   movdqu 0x10(%rsp), %xmm1
-;   movdqu 0x20(%rsp), %xmm2
 ;   callq *%r8
-;   movdqu %xmm0, 0x30(%rsp)
 ;   movdqu (%rsp), %xmm4
+;   movdqu %xmm0, 0x50(%rsp)
 ;   pshufd $1, %xmm4, %xmm0
 ;   movdqu 0x10(%rsp), %xmm2
 ;   pshufd $1, %xmm2, %xmm1
-;   movdqu 0x20(%rsp), %xmm4
-;   pshufd $1, %xmm4, %xmm2
+;   movdqu 0x20(%rsp), %xmm5
+;   pshufd $1, %xmm5, %xmm2
 ;   movabsq $0, %r9 ; reloc_external Abs8 %FmaF32 0
 ;   callq *%r9
-;   movdqu %xmm0, 0x40(%rsp)
 ;   movdqu (%rsp), %xmm4
+;   movdqu %xmm0, 0x30(%rsp)
 ;   pshufd $2, %xmm4, %xmm0
-;   movdqu 0x10(%rsp), %xmm6
-;   pshufd $2, %xmm6, %xmm1
+;   movdqu 0x10(%rsp), %xmm7
+;   pshufd $2, %xmm7, %xmm1
 ;   movdqu 0x20(%rsp), %xmm3
 ;   pshufd $2, %xmm3, %xmm2
 ;   movabsq $0, %r10 ; reloc_external Abs8 %FmaF32 0
 ;   callq *%r10
-;   movdqu %xmm0, 0x50(%rsp)
 ;   movdqu (%rsp), %xmm4
+;   movdqu %xmm0, 0x40(%rsp)
 ;   pshufd $3, %xmm4, %xmm0
 ;   movdqu 0x10(%rsp), %xmm1
 ;   pshufd $3, %xmm1, %xmm1
@@ -155,12 +149,12 @@ block0(v0: f32x4, v1: f32x4, v2: f32x4):
 ;   pshufd $3, %xmm2, %xmm2
 ;   movabsq $0, %r11 ; reloc_external Abs8 %FmaF32 0
 ;   callq *%r11
-;   movdqu 0x40(%rsp), %xmm4
 ;   movdqa %xmm0, %xmm2
-;   movdqu 0x30(%rsp), %xmm0
-;   insertps $0x10, %xmm4, %xmm0
-;   movdqu 0x50(%rsp), %xmm1
-;   insertps $0x20, %xmm1, %xmm0
+;   movdqu 0x30(%rsp), %xmm1
+;   movdqu 0x50(%rsp), %xmm0
+;   insertps $0x10, %xmm1, %xmm0
+;   movdqu 0x40(%rsp), %xmm6
+;   insertps $0x20, %xmm6, %xmm0
 ;   movdqa %xmm2, %xmm3
 ;   insertps $0x30, %xmm3, %xmm0
 ;   addq $0x60, %rsp
@@ -183,9 +177,6 @@ block0(v0: f64x2, v1: f64x2, v2: f64x2):
 ;   movdqu  %xmm1, rsp(16 + virtual offset)
 ;   movdqu  %xmm2, rsp(32 + virtual offset)
 ;   load_ext_name %FmaF64+0, %r8
-;   movdqu  rsp(0 + virtual offset), %xmm0
-;   movdqu  rsp(16 + virtual offset), %xmm1
-;   movdqu  rsp(32 + virtual offset), %xmm2
 ;   call    *%r8
 ;   movdqu  %xmm0, rsp(48 + virtual offset)
 ;   movdqu  rsp(0 + virtual offset), %xmm0
@@ -214,9 +205,6 @@ block0(v0: f64x2, v1: f64x2, v2: f64x2):
 ;   movdqu %xmm1, 0x10(%rsp)
 ;   movdqu %xmm2, 0x20(%rsp)
 ;   movabsq $0, %r8 ; reloc_external Abs8 %FmaF64 0
-;   movdqu (%rsp), %xmm0
-;   movdqu 0x10(%rsp), %xmm1
-;   movdqu 0x20(%rsp), %xmm2
 ;   callq *%r8
 ;   movdqu %xmm0, 0x30(%rsp)
 ;   movdqu (%rsp), %xmm0
diff --git a/cranelift/filetests/filetests/isa/x64/fmsub-inst.clif b/cranelift/filetests/filetests/isa/x64/fmsub-inst.clif
new file mode 100644
index 000000000000..a327bf3b8617
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/fmsub-inst.clif
@@ -0,0 +1,686 @@
+test compile precise-output
+target x86_64 has_avx=true has_fma=true
+
+function %vfmsub213ss(f32, f32, f32) -> f32 {
+block0(v0: f32, v1: f32, v2: f32):
+    v3 = fneg v2
+    v4 = fma v0, v1, v3
+    return v4
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   vfmsub213ss %xmm0, %xmm1, %xmm2, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   vfmsub213ss %xmm2, %xmm1, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %vfmsub213sd(f64, f64, i64) -> f64 {
+block0(v0: f64, v1: f64, v2: i64):
+    v3 = load.f64 v2
+    v4 = fneg v3
+    v5 = fma v0, v1, v4
+    return v5
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   vfmsub213sd %xmm0, %xmm1, 0(%rdi), %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   vfmsub213sd (%rdi), %xmm1, %xmm0 ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %vfmsub213ps(f32x4, f32x4, f32x4) -> f32x4 {
+block0(v0: f32x4, v1: f32x4, v2: f32x4):
+    v3 = fneg v2
+    v4 = fma v0, v1, v3
+    return v4
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   vfmsub213ps %xmm0, %xmm1, %xmm2, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   vfmsub213ps %xmm2, %xmm1, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %vfmsub213pd(f64x2, f64x2, f64x2) -> f64x2 {
+block0(v0: f64x2, v1: f64x2, v2: f64x2):
+    v3 = fneg v2
+    v4 = fma v0, v1, v3
+    return v4
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   vfmsub213pd %xmm0, %xmm1, %xmm2, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   vfmsub213pd %xmm2, %xmm1, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %vfmsub132ss(f32, i64, f32) -> f32 {
+block0(v0: f32, v1: i64, v2: f32):
+    v3 = load.f32 v1
+    v4 = fneg v2
+    v5 = fma v0, v3, v4
+    return v5
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   vfmsub132ss %xmm0, %xmm1, 0(%rdi), %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   vfmsub132ss (%rdi), %xmm1, %xmm0 ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %vfmsub132sd(i64, f64, f64) -> f64 {
+block0(v0: i64, v1: f64, v2: f64):
+    v3 = load.f64 v0
+    v4 = fneg v2
+    v5 = fma v3, v1, v4
+    return v5
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   vfmsub132sd %xmm0, %xmm1, 0(%rdi), %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   vfmsub132sd (%rdi), %xmm1, %xmm0 ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %vfmsub132ps(f32x4, i64, f32x4) -> f32x4 {
+block0(v0: f32x4, v1: i64, v2: f32x4):
+    v3 = load.f32x4 v1
+    v4 = fneg v2
+    v5 = fma v0, v3, v4
+    return v5
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   vfmsub132ps %xmm0, %xmm1, 0(%rdi), %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   vfmsub132ps (%rdi), %xmm1, %xmm0 ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %vfmsub132pd(i64, f64x2, f64x2) -> f64x2 {
+block0(v0: i64, v1: f64x2, v2: f64x2):
+    v3 = load.f64x2 v0
+    v4 = fneg v2
+    v5 = fma v3, v1, v4
+    return v5
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   vfmsub132pd %xmm0, %xmm1, 0(%rdi), %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   vfmsub132pd (%rdi), %xmm1, %xmm0 ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %vfnmsub213ss(f32, f32, f32) -> f32 {
+block0(v0: f32, v1: f32, v2: f32):
+    v3 = fneg v0
+    v4 = fneg v2
+    v5 = fma v3, v1, v4
+    return v5
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   vfnmsub213ss %xmm0, %xmm1, %xmm2, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   vfnmsub213ss %xmm2, %xmm1, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %vfnmsub213sd(f64, f64, f64) -> f64 {
+block0(v0: f64, v1: f64, v2: f64):
+    v3 = fneg v1
+    v4 = fneg v2
+    v5 = fma v0, v3, v4
+    return v5
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   vfnmsub213sd %xmm0, %xmm1, %xmm2, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   vfnmsub213sd %xmm2, %xmm1, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %vfnmsub213ps(f32x4, f32x4, i64) -> f32x4 {
+block0(v0: f32x4, v1: f32x4, v2: i64):
+    v3 = fneg v0
+    v4 = load.f32x4 v2
+    v5 = fneg v4
+    v6 = fma v3, v1, v5
+    return v6
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   vfnmsub213ps %xmm0, %xmm1, 0(%rdi), %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   vfnmsub213ps (%rdi), %xmm1, %xmm0 ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %vfnmsub213pd(f64x2, f64x2, i64) -> f64x2 {
+block0(v0: f64x2, v1: f64x2, v2: i64):
+    v3 = fneg v1
+    v4 = load.f64x2 v2
+    v5 = fneg v4
+    v6 = fma v0, v3, v5
+    return v6
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   vfnmsub213pd %xmm0, %xmm1, 0(%rdi), %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   vfnmsub213pd (%rdi), %xmm1, %xmm0 ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %vfnmsub132ss(f32, i64, f32) -> f32 {
+block0(v0: f32, v1: i64, v2: f32):
+    v3 = fneg v0
+    v4 = load.f32 v1
+    v5 = fneg v2
+    v6 = fma v3, v4, v5
+    return v6
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   vfnmsub132ss %xmm0, %xmm1, 0(%rdi), %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   vfnmsub132ss (%rdi), %xmm1, %xmm0 ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %vfnmsub132sd(i64, f64, f64) -> f64 {
+block0(v0: i64, v1: f64, v2: f64):
+    v3 = fneg v1
+    v4 = load.f64 v0
+    v5 = fneg v2
+    v6 = fma v4, v3, v5
+    return v6
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   vfnmsub132sd %xmm0, %xmm1, 0(%rdi), %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   vfnmsub132sd (%rdi), %xmm1, %xmm0 ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %vfnmsub132ps(i64, f32x4, f32x4) -> f32x4 {
+block0(v0: i64, v1: f32x4, v2: f32x4):
+    v3 = load.f32x4 v0
+    v4 = fneg v3
+    v5 = fneg v2
+    v6 = fma v4, v1, v5
+    return v6
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   vfnmsub132ps %xmm0, %xmm1, 0(%rdi), %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   vfnmsub132ps (%rdi), %xmm1, %xmm0 ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %vfnmsub132pd(f64x2, i64, f64x2) -> f64x2 {
+block0(v0: f64x2, v1: i64, v2: f64x2):
+    v3 = load.f64x2 v1
+    v4 = fneg v3
+    v5 = fneg v2
+    v6 = fma v0, v4, v5
+    return v6
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   vfnmsub132pd %xmm0, %xmm1, 0(%rdi), %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   vfnmsub132pd (%rdi), %xmm1, %xmm0 ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+;; The following tests are here to ensure, that the runtests for fnmsub actually
+;; generate code that sinks the loads. If they don't, then the runtests
+;; don't actually test the correct lowering
+
+function %fnmsub_f64(f64, f64, f64) -> f64 {
+    ss0 = explicit_slot 16
+block0(v0: f64, v1: f64, v2: f64):
+    v3 = stack_addr.i64 ss0
+    store.f64 v2, v3
+    v4 = load.f64 v3
+    v5 = fneg v0
+    v6 = fneg v4
+    v7 = fma v5, v1, v6
+    return v7
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+;   subq    %rsp, $16, %rsp
+; block0:
+;   lea     rsp(0 + virtual offset), %r8
+;   vmovsd  %xmm2, 0(%r8)
+;   vfnmsub213sd %xmm0, %xmm1, 0(%r8), %xmm0
+;   addq    %rsp, $16, %rsp
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+;   subq $0x10, %rsp
+; block1: ; offset 0x8
+;   leaq (%rsp), %r8
+;   vmovsd %xmm2, (%r8) ; trap: heap_oob
+;   vfnmsub213sd (%r8), %xmm1, %xmm0 ; trap: heap_oob
+;   addq $0x10, %rsp
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %fmsub_f64(f64, f64, f64) -> f64 {
+    ss0 = explicit_slot 16
+block0(v0: f64, v1: f64, v2: f64):
+    v3 = stack_addr.i64 ss0
+    store.f64 v2, v3
+    v4 = load.f64 v3
+    v5 = fneg v4
+    v6 = fma v0, v1, v5
+    return v6
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+;   subq    %rsp, $16, %rsp
+; block0:
+;   lea     rsp(0 + virtual offset), %r8
+;   vmovsd  %xmm2, 0(%r8)
+;   vfmsub213sd %xmm0, %xmm1, 0(%r8), %xmm0
+;   addq    %rsp, $16, %rsp
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+;   subq $0x10, %rsp
+; block1: ; offset 0x8
+;   leaq (%rsp), %r8
+;   vmovsd %xmm2, (%r8) ; trap: heap_oob
+;   vfmsub213sd (%r8), %xmm1, %xmm0 ; trap: heap_oob
+;   addq $0x10, %rsp
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %fmsub_f32(f32, f32, f32) -> f32 {
+    ss0 = explicit_slot 4
+block0(v0: f32, v1: f32, v2: f32):
+    v3 = stack_addr.i64 ss0
+    store.f32 v1, v3
+    v4 = load.f32 v3
+    v5 = fneg v2
+    v6 = fma v0, v4, v5
+    return v6
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+;   subq    %rsp, $16, %rsp
+; block0:
+;   lea     rsp(0 + virtual offset), %r8
+;   vmovss  %xmm1, 0(%r8)
+;   vfmsub132ss %xmm0, %xmm2, 0(%r8), %xmm0
+;   addq    %rsp, $16, %rsp
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+;   subq $0x10, %rsp
+; block1: ; offset 0x8
+;   leaq (%rsp), %r8
+;   vmovss %xmm1, (%r8) ; trap: heap_oob
+;   vfmsub132ss (%r8), %xmm2, %xmm0 ; trap: heap_oob
+;   addq $0x10, %rsp
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+;; load first, then negate
+function %fmnsub_f32(f32, f32, f32) -> f32 {
+    ss0 = explicit_slot 4
+block0(v0: f32, v1: f32, v2: f32):
+    v3 = stack_addr.i64 ss0
+    store.f32 v1, v3
+    v4 = load.f32 v3
+    v5 = fneg v4
+    v6 = fneg v2
+    v7 = fma v0, v5, v6
+    return v7
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+;   subq    %rsp, $16, %rsp
+; block0:
+;   lea     rsp(0 + virtual offset), %r8
+;   vmovss  %xmm1, 0(%r8)
+;   vfnmsub132ss %xmm0, %xmm2, 0(%r8), %xmm0
+;   addq    %rsp, $16, %rsp
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+;   subq $0x10, %rsp
+; block1: ; offset 0x8
+;   leaq (%rsp), %r8
+;   vmovss %xmm1, (%r8) ; trap: heap_oob
+;   vfnmsub132ss (%r8), %xmm2, %xmm0 ; trap: heap_oob
+;   addq $0x10, %rsp
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+;; negate first, then load
+;; FIXME (see issue #8953): there is a missed optimization here due to the order
+;; of load and negation. This should really generate a vfmnsub instruction 
+;; removing the need to negate the argument explicitly
+function %fmnsub_f32(f32, f32, f32) -> f32 {
+    ss0 = explicit_slot 4
+block0(v0: f32, v1: f32, v2: f32):
+    v3 = stack_addr.i64 ss0
+    v4 = fneg v1
+    store.f32 v4, v3
+    v5 = load.f32 v3
+    v6 = fneg v2
+    v7 = fma v0, v5, v6
+    return v7
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+;   subq    %rsp, $16, %rsp
+; block0:
+;   lea     rsp(0 + virtual offset), %r11
+;   movl    $-2147483648, %r9d
+;   vmovd   %r9d, %xmm3
+;   vxorps  %xmm1, %xmm3, %xmm3
+;   vmovss  %xmm3, 0(%r11)
+;   vfmsub132ss %xmm0, %xmm2, 0(%r11), %xmm0
+;   addq    %rsp, $16, %rsp
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+;   subq $0x10, %rsp
+; block1: ; offset 0x8
+;   leaq (%rsp), %r11
+;   movl $0x80000000, %r9d
+;   vmovd %r9d, %xmm3
+;   vxorps %xmm3, %xmm1, %xmm3
+;   vmovss %xmm3, (%r11) ; trap: heap_oob
+;   vfmsub132ss (%r11), %xmm2, %xmm0 ; trap: heap_oob
+;   addq $0x10, %rsp
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %fmsub_f32x4(f32x4, f32x4, f32x4) -> f32x4 {
+    ss0 = explicit_slot 16
+block0(v0: f32x4, v1: f32x4, v2: f32x4):
+    v3 = stack_addr.i64 ss0
+    store.f32x4 v0, v3
+    v4 = load.f32x4 v3
+    v5 = fneg v2
+    v6 = fma v4, v1, v5
+    return v6
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+;   subq    %rsp, $16, %rsp
+; block0:
+;   lea     rsp(0 + virtual offset), %r8
+;   vmovups %xmm0, 0(%r8)
+;   movdqa  %xmm1, %xmm0
+;   vfmsub132ps %xmm0, %xmm2, 0(%r8), %xmm0
+;   addq    %rsp, $16, %rsp
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+;   subq $0x10, %rsp
+; block1: ; offset 0x8
+;   leaq (%rsp), %r8
+;   vmovups %xmm0, (%r8) ; trap: heap_oob
+;   movdqa %xmm1, %xmm0
+;   vfmsub132ps (%r8), %xmm2, %xmm0 ; trap: heap_oob
+;   addq $0x10, %rsp
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/fpromote-demote-avx.clif b/cranelift/filetests/filetests/isa/x64/fpromote-demote-avx.clif
index 4b07ebfa4ad3..dc0f9cdfb2a3 100644
--- a/cranelift/filetests/filetests/isa/x64/fpromote-demote-avx.clif
+++ b/cranelift/filetests/filetests/isa/x64/fpromote-demote-avx.clif
@@ -11,7 +11,9 @@ block0(v0: f32):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   vcvtss2sd %xmm0, %xmm0
+;   uninit  %xmm2
+;   vxorpd  %xmm2, %xmm2, %xmm4
+;   vcvtss2sd %xmm4, %xmm0, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -21,7 +23,8 @@ block0(v0: f32):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   vcvtss2sd %xmm0, %xmm0, %xmm0
+;   vxorpd %xmm2, %xmm2, %xmm4
+;   vcvtss2sd %xmm0, %xmm4, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -42,9 +45,11 @@ block0(v1: i64, v2: f32):
 ;   movq    %rsp, %rbp
 ;   subq    %rsp, $16, %rsp
 ; block0:
-;   lea     rsp(0 + virtual offset), %rdx
-;   vmovss  %xmm0, 0(%rdx)
-;   vcvtss2sd 0(%rdx), %xmm0
+;   lea     rsp(0 + virtual offset), %r8
+;   vmovss  %xmm0, 0(%r8)
+;   uninit  %xmm4
+;   vxorpd  %xmm4, %xmm4, %xmm6
+;   vcvtss2sd %xmm6, 0(%r8), %xmm0
 ;   addq    %rsp, $16, %rsp
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -56,9 +61,10 @@ block0(v1: i64, v2: f32):
 ;   movq %rsp, %rbp
 ;   subq $0x10, %rsp
 ; block1: ; offset 0x8
-;   leaq (%rsp), %rdx
-;   vmovss %xmm0, (%rdx) ; trap: heap_oob
-;   vcvtss2sd (%rdx), %xmm0, %xmm0 ; trap: heap_oob
+;   leaq (%rsp), %r8
+;   vmovss %xmm0, (%r8) ; trap: heap_oob
+;   vxorpd %xmm4, %xmm4, %xmm6
+;   vcvtss2sd (%r8), %xmm6, %xmm0 ; trap: heap_oob
 ;   addq $0x10, %rsp
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -74,7 +80,9 @@ block0(v0: f64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   vcvtsd2ss %xmm0, %xmm0
+;   uninit  %xmm2
+;   vxorps  %xmm2, %xmm2, %xmm4
+;   vcvtsd2ss %xmm4, %xmm0, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -84,7 +92,8 @@ block0(v0: f64):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   vcvtsd2ss %xmm0, %xmm0, %xmm0
+;   vxorps %xmm2, %xmm2, %xmm4
+;   vcvtsd2ss %xmm0, %xmm4, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -105,9 +114,11 @@ block0(v1: i64, v2: f64):
 ;   movq    %rsp, %rbp
 ;   subq    %rsp, $16, %rsp
 ; block0:
-;   lea     rsp(0 + virtual offset), %rdx
-;   vmovsd  %xmm0, 0(%rdx)
-;   vcvtsd2ss 0(%rdx), %xmm0
+;   lea     rsp(0 + virtual offset), %r8
+;   vmovsd  %xmm0, 0(%r8)
+;   uninit  %xmm4
+;   vxorps  %xmm4, %xmm4, %xmm6
+;   vcvtsd2ss %xmm6, 0(%r8), %xmm0
 ;   addq    %rsp, $16, %rsp
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -119,9 +130,10 @@ block0(v1: i64, v2: f64):
 ;   movq %rsp, %rbp
 ;   subq $0x10, %rsp
 ; block1: ; offset 0x8
-;   leaq (%rsp), %rdx
-;   vmovsd %xmm0, (%rdx) ; trap: heap_oob
-;   vcvtsd2ss (%rdx), %xmm0, %xmm0 ; trap: heap_oob
+;   leaq (%rsp), %r8
+;   vmovsd %xmm0, (%r8) ; trap: heap_oob
+;   vxorps %xmm4, %xmm4, %xmm6
+;   vcvtsd2ss (%r8), %xmm6, %xmm0 ; trap: heap_oob
 ;   addq $0x10, %rsp
 ;   movq %rbp, %rsp
 ;   popq %rbp
diff --git a/cranelift/filetests/filetests/isa/x64/fpromote-demote.clif b/cranelift/filetests/filetests/isa/x64/fpromote-demote.clif
index 465460962f13..c064b2b6b85d 100644
--- a/cranelift/filetests/filetests/isa/x64/fpromote-demote.clif
+++ b/cranelift/filetests/filetests/isa/x64/fpromote-demote.clif
@@ -11,7 +11,11 @@ block0(v0: f32):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   cvtss2sd %xmm0, %xmm0
+;   movdqa  %xmm0, %xmm5
+;   uninit  %xmm0
+;   xorpd   %xmm0, %xmm0, %xmm0
+;   movdqa  %xmm5, %xmm7
+;   cvtss2sd %xmm0, %xmm7, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -21,7 +25,10 @@ block0(v0: f32):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   cvtss2sd %xmm0, %xmm0
+;   movdqa %xmm0, %xmm5
+;   xorpd %xmm0, %xmm0
+;   movdqa %xmm5, %xmm7
+;   cvtss2sd %xmm7, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -42,9 +49,11 @@ block0(v1: i64, v2: f32):
 ;   movq    %rsp, %rbp
 ;   subq    %rsp, $16, %rsp
 ; block0:
-;   lea     rsp(0 + virtual offset), %rdx
-;   movss   %xmm0, 0(%rdx)
-;   cvtss2sd 0(%rdx), %xmm0
+;   lea     rsp(0 + virtual offset), %r8
+;   movss   %xmm0, 0(%r8)
+;   uninit  %xmm0
+;   xorpd   %xmm0, %xmm0, %xmm0
+;   cvtss2sd %xmm0, 0(%r8), %xmm0
 ;   addq    %rsp, $16, %rsp
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -56,9 +65,10 @@ block0(v1: i64, v2: f32):
 ;   movq %rsp, %rbp
 ;   subq $0x10, %rsp
 ; block1: ; offset 0x8
-;   leaq (%rsp), %rdx
-;   movss %xmm0, (%rdx) ; trap: heap_oob
-;   cvtss2sd (%rdx), %xmm0 ; trap: heap_oob
+;   leaq (%rsp), %r8
+;   movss %xmm0, (%r8) ; trap: heap_oob
+;   xorpd %xmm0, %xmm0
+;   cvtss2sd (%r8), %xmm0 ; trap: heap_oob
 ;   addq $0x10, %rsp
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -74,7 +84,11 @@ block0(v0: f64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   cvtsd2ss %xmm0, %xmm0
+;   movdqa  %xmm0, %xmm5
+;   uninit  %xmm0
+;   xorps   %xmm0, %xmm0, %xmm0
+;   movdqa  %xmm5, %xmm7
+;   cvtsd2ss %xmm0, %xmm7, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -84,7 +98,10 @@ block0(v0: f64):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   cvtsd2ss %xmm0, %xmm0
+;   movdqa %xmm0, %xmm5
+;   xorps %xmm0, %xmm0
+;   movdqa %xmm5, %xmm7
+;   cvtsd2ss %xmm7, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -105,9 +122,11 @@ block0(v1: i64, v2: f64):
 ;   movq    %rsp, %rbp
 ;   subq    %rsp, $16, %rsp
 ; block0:
-;   lea     rsp(0 + virtual offset), %rdx
-;   movsd   %xmm0, 0(%rdx)
-;   cvtsd2ss 0(%rdx), %xmm0
+;   lea     rsp(0 + virtual offset), %r8
+;   movsd   %xmm0, 0(%r8)
+;   uninit  %xmm0
+;   xorps   %xmm0, %xmm0, %xmm0
+;   cvtsd2ss %xmm0, 0(%r8), %xmm0
 ;   addq    %rsp, $16, %rsp
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -119,9 +138,10 @@ block0(v1: i64, v2: f64):
 ;   movq %rsp, %rbp
 ;   subq $0x10, %rsp
 ; block1: ; offset 0x8
-;   leaq (%rsp), %rdx
-;   movsd %xmm0, (%rdx) ; trap: heap_oob
-;   cvtsd2ss (%rdx), %xmm0 ; trap: heap_oob
+;   leaq (%rsp), %r8
+;   movsd %xmm0, (%r8) ; trap: heap_oob
+;   xorps %xmm0, %xmm0
+;   cvtsd2ss (%r8), %xmm0 ; trap: heap_oob
 ;   addq $0x10, %rsp
 ;   movq %rbp, %rsp
 ;   popq %rbp
diff --git a/cranelift/filetests/filetests/isa/x64/fsqrt-avx.clif b/cranelift/filetests/filetests/isa/x64/fsqrt-avx.clif
index 1e87a00a223d..7740c538cfb7 100644
--- a/cranelift/filetests/filetests/isa/x64/fsqrt-avx.clif
+++ b/cranelift/filetests/filetests/isa/x64/fsqrt-avx.clif
@@ -11,7 +11,9 @@ block0(v0: f32):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   vsqrtss %xmm0, %xmm0
+;   uninit  %xmm2
+;   vxorps  %xmm2, %xmm2, %xmm4
+;   vsqrtss %xmm4, %xmm0, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -21,7 +23,8 @@ block0(v0: f32):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   vsqrtss %xmm0, %xmm0, %xmm0
+;   vxorps %xmm2, %xmm2, %xmm4
+;   vsqrtss %xmm0, %xmm4, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -36,7 +39,9 @@ block0(v0: f64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   vsqrtsd %xmm0, %xmm0
+;   uninit  %xmm2
+;   vxorpd  %xmm2, %xmm2, %xmm4
+;   vsqrtsd %xmm4, %xmm0, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -46,7 +51,8 @@ block0(v0: f64):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   vsqrtsd %xmm0, %xmm0, %xmm0
+;   vxorpd %xmm2, %xmm2, %xmm4
+;   vsqrtsd %xmm0, %xmm4, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
diff --git a/cranelift/filetests/filetests/isa/x64/fsqrt.clif b/cranelift/filetests/filetests/isa/x64/fsqrt.clif
index ec4c3f742460..be10b19ac4e8 100644
--- a/cranelift/filetests/filetests/isa/x64/fsqrt.clif
+++ b/cranelift/filetests/filetests/isa/x64/fsqrt.clif
@@ -11,7 +11,11 @@ block0(v0: f32):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   sqrtss  %xmm0, %xmm0
+;   movdqa  %xmm0, %xmm5
+;   uninit  %xmm0
+;   xorps   %xmm0, %xmm0, %xmm0
+;   movdqa  %xmm5, %xmm7
+;   sqrtss  %xmm0, %xmm7, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -21,7 +25,10 @@ block0(v0: f32):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   sqrtss %xmm0, %xmm0
+;   movdqa %xmm0, %xmm5
+;   xorps %xmm0, %xmm0
+;   movdqa %xmm5, %xmm7
+;   sqrtss %xmm7, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -36,7 +43,11 @@ block0(v0: f64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   sqrtsd  %xmm0, %xmm0
+;   movdqa  %xmm0, %xmm5
+;   uninit  %xmm0
+;   xorpd   %xmm0, %xmm0, %xmm0
+;   movdqa  %xmm5, %xmm7
+;   sqrtsd  %xmm0, %xmm7, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -46,7 +57,10 @@ block0(v0: f64):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   sqrtsd %xmm0, %xmm0
+;   movdqa %xmm0, %xmm5
+;   xorpd %xmm0, %xmm0
+;   movdqa %xmm5, %xmm7
+;   sqrtsd %xmm7, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
diff --git a/cranelift/filetests/filetests/isa/x64/fuzzbug-60035.clif b/cranelift/filetests/filetests/isa/x64/fuzzbug-60035.clif
index 0b533188e1d8..96709ee43504 100644
--- a/cranelift/filetests/filetests/isa/x64/fuzzbug-60035.clif
+++ b/cranelift/filetests/filetests/isa/x64/fuzzbug-60035.clif
@@ -15,25 +15,14 @@ block0:
 ; VCode:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
-;   subq    %rsp, $64, %rsp
-;   movq    %rbx, 16(%rsp)
-;   movq    %r12, 24(%rsp)
-;   movq    %r13, 32(%rsp)
-;   movq    %r14, 40(%rsp)
-;   movq    %r15, 48(%rsp)
+;   subq    %rsp, $16, %rsp
+;   movq    %rbx, 0(%rsp)
 ; block0:
-;   load_ext_name userextname0+0, %r15
-;   movq    %r15, rsp(0 + virtual offset)
-;   movq    rsp(0 + virtual offset), %r15
-;   call    *%r15
-;   movq    rsp(0 + virtual offset), %r15
-;   call    *%r15
-;   movq    16(%rsp), %rbx
-;   movq    24(%rsp), %r12
-;   movq    32(%rsp), %r13
-;   movq    40(%rsp), %r14
-;   movq    48(%rsp), %r15
-;   addq    %rsp, $64, %rsp
+;   load_ext_name userextname0+0, %rbx
+;   call    *%rbx
+;   call    *%rbx
+;   movq    0(%rsp), %rbx
+;   addq    %rsp, $16, %rsp
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -42,25 +31,14 @@ block0:
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
-;   subq $0x40, %rsp
-;   movq %rbx, 0x10(%rsp)
-;   movq %r12, 0x18(%rsp)
-;   movq %r13, 0x20(%rsp)
-;   movq %r14, 0x28(%rsp)
-;   movq %r15, 0x30(%rsp)
-; block1: ; offset 0x21
-;   movabsq $0, %r15 ; reloc_external Abs8 u1:7 0
-;   movq %r15, (%rsp)
-;   movq (%rsp), %r15
-;   callq *%r15
-;   movq (%rsp), %r15
-;   callq *%r15
-;   movq 0x10(%rsp), %rbx
-;   movq 0x18(%rsp), %r12
-;   movq 0x20(%rsp), %r13
-;   movq 0x28(%rsp), %r14
-;   movq 0x30(%rsp), %r15
-;   addq $0x40, %rsp
+;   subq $0x10, %rsp
+;   movq %rbx, (%rsp)
+; block1: ; offset 0xc
+;   movabsq $0, %rbx ; reloc_external Abs8 u1:7 0
+;   callq *%rbx
+;   callq *%rbx
+;   movq (%rsp), %rbx
+;   addq $0x10, %rsp
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
diff --git a/cranelift/filetests/filetests/isa/x64/i128.clif b/cranelift/filetests/filetests/isa/x64/i128.clif
index 74048b0a8115..9c1b901673c7 100644
--- a/cranelift/filetests/filetests/isa/x64/i128.clif
+++ b/cranelift/filetests/filetests/isa/x64/i128.clif
@@ -202,14 +202,13 @@ block0(v0: i128, v1: i128):
 ;   movq    %rdi, %rdx
 ;   imulq   %rdx, %rcx, %rdx
 ;   movq    %rax, %rcx
+;   imulq   %rsi, %rcx, %rsi
+;   addq    %rdx, %rsi, %rdx
 ;   movq    %rdi, %rax
-;   movq    %rsi, %r10
-;   imulq   %r10, %rcx, %r10
-;   addq    %rdx, %r10, %rdx
-;   movq    %rdx, %r9
-;   mul     %rax, %rcx, %rax, %rdx
+;   movq    %rdx, %r8
+;   mulq    %rax, %rcx, %rax, %rdx
 ;   movq    %rdx, %rcx
-;   movq    %r9, %rdx
+;   movq    %r8, %rdx
 ;   addq    %rdx, %rcx, %rdx
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -224,14 +223,13 @@ block0(v0: i128, v1: i128):
 ;   movq %rdi, %rdx
 ;   imulq %rcx, %rdx
 ;   movq %rax, %rcx
+;   imulq %rcx, %rsi
+;   addq %rsi, %rdx
 ;   movq %rdi, %rax
-;   movq %rsi, %r10
-;   imulq %rcx, %r10
-;   addq %r10, %rdx
-;   movq %rdx, %r9
+;   movq %rdx, %r8
 ;   mulq %rcx
 ;   movq %rdx, %rcx
-;   movq %r9, %rdx
+;   movq %r8, %rdx
 ;   addq %rcx, %rdx
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -247,8 +245,8 @@ block0(v0: i64, v1: i64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rsi, %rdx
 ;   movq    %rdi, %rax
+;   movq    %rsi, %rdx
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -258,8 +256,8 @@ block0(v0: i64, v1: i64):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rsi, %rdx
 ;   movq %rdi, %rax
+;   movq %rsi, %rdx
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -274,8 +272,8 @@ block0(v0: i128):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rsi, %rdx
 ;   movq    %rdi, %rax
+;   movq    %rsi, %rdx
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -285,8 +283,8 @@ block0(v0: i128):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rsi, %rdx
 ;   movq %rdi, %rax
+;   movq %rsi, %rdx
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -318,116 +316,71 @@ block0(v0: i128, v1: i128):
 ; VCode:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
-;   subq    %rsp, $64, %rsp
-;   movq    %rbx, 16(%rsp)
-;   movq    %r12, 24(%rsp)
-;   movq    %r13, 32(%rsp)
-;   movq    %r14, 40(%rsp)
-;   movq    %r15, 48(%rsp)
+;   subq    %rsp, $48, %rsp
+;   movq    %rbx, 0(%rsp)
+;   movq    %r12, 8(%rsp)
+;   movq    %r13, 16(%rsp)
+;   movq    %r14, 24(%rsp)
+;   movq    %r15, 32(%rsp)
 ; block0:
-;   cmpq    %rdx, %rdi
-;   setz    %r9b
-;   cmpq    %rcx, %rsi
-;   setz    %r10b
-;   andq    %r9, %r10, %r9
-;   testq   $1, %r9
-;   setnz   %al
-;   cmpq    %rdx, %rdi
-;   setnz   %r8b
-;   cmpq    %rcx, %rsi
-;   setnz   %r9b
+;   movq    %rdi, %rax
+;   xorq    %rax, %rdx, %rax
+;   movq    %rsi, %r8
+;   xorq    %r8, %rcx, %r8
+;   orq     %rax, %r8, %rax
+;   setz    %al
+;   movq    %rdi, %r8
+;   xorq    %r8, %rdx, %r8
+;   movq    %rsi, %r9
+;   xorq    %r9, %rcx, %r9
 ;   orq     %r8, %r9, %r8
-;   testq   $1, %r8
 ;   setnz   %r9b
-;   movq    %r9, rsp(0 + virtual offset)
-;   cmpq    %rcx, %rsi
-;   setl    %r8b
-;   setz    %r10b
-;   cmpq    %rdx, %rdi
-;   setb    %r11b
-;   andq    %r10, %r11, %r10
-;   orq     %r8, %r10, %r8
-;   testq   $1, %r8
-;   setnz   %r10b
-;   cmpq    %rcx, %rsi
-;   setl    %r11b
-;   setz    %r8b
-;   cmpq    %rdx, %rdi
-;   setbe   %r15b
-;   andq    %r8, %r15, %r8
-;   orq     %r11, %r8, %r11
-;   testq   $1, %r11
-;   setnz   %r8b
-;   cmpq    %rcx, %rsi
-;   setnle  %r11b
-;   setz    %r12b
-;   cmpq    %rdx, %rdi
-;   setnbe  %r13b
-;   andq    %r12, %r13, %r12
-;   orq     %r11, %r12, %r11
-;   testq   $1, %r11
-;   setnz   %r11b
-;   cmpq    %rcx, %rsi
-;   setnle  %r15b
-;   setz    %bl
 ;   cmpq    %rdx, %rdi
-;   setnb   %r12b
-;   andq    %rbx, %r12, %rbx
-;   orq     %r15, %rbx, %r15
-;   testq   $1, %r15
-;   setnz   %r13b
-;   cmpq    %rcx, %rsi
-;   setb    %r14b
-;   setz    %r15b
-;   cmpq    %rdx, %rdi
-;   setb    %bl
-;   andq    %r15, %rbx, %r15
-;   orq     %r14, %r15, %r14
-;   testq   $1, %r14
-;   setnz   %r14b
-;   cmpq    %rcx, %rsi
-;   setb    %bl
-;   setz    %r12b
+;   movq    %rsi, %r8
+;   sbbq    %r8, %rcx, %r8
+;   setl    %r8b
+;   cmpq    %rdi, %rdx
+;   movq    %rcx, %r10
+;   sbbq    %r10, %rsi, %r10
+;   setnl   %r11b
+;   cmpq    %rdi, %rdx
+;   movq    %rcx, %r10
+;   sbbq    %r10, %rsi, %r10
+;   setl    %r10b
 ;   cmpq    %rdx, %rdi
-;   setbe   %r15b
-;   andq    %r12, %r15, %r12
-;   orq     %rbx, %r12, %rbx
-;   testq   $1, %rbx
-;   setnz   %r15b
-;   cmpq    %rcx, %rsi
-;   setnbe  %bl
-;   setz    %r12b
+;   movq    %rsi, %rbx
+;   sbbq    %rbx, %rcx, %rbx
+;   setnl   %r14b
 ;   cmpq    %rdx, %rdi
-;   setnbe  %r9b
-;   andq    %r12, %r9, %r12
-;   orq     %rbx, %r12, %rbx
-;   testq   $1, %rbx
-;   setnz   %bl
-;   cmpq    %rcx, %rsi
-;   setnbe  %sil
-;   setz    %cl
+;   movq    %rsi, %r12
+;   sbbq    %r12, %rcx, %r12
+;   setb    %r13b
+;   cmpq    %rdi, %rdx
+;   movq    %rcx, %r15
+;   sbbq    %r15, %rsi, %r15
+;   setnb   %bl
+;   cmpq    %rdi, %rdx
+;   movq    %rcx, %r15
+;   sbbq    %r15, %rsi, %r15
+;   setb    %r15b
 ;   cmpq    %rdx, %rdi
+;   sbbq    %rsi, %rcx, %rsi
 ;   setnb   %dil
-;   andq    %rcx, %rdi, %rcx
-;   orq     %rsi, %rcx, %rsi
-;   testq   $1, %rsi
-;   setnz   %sil
-;   movq    rsp(0 + virtual offset), %rcx
-;   andl    %eax, %ecx, %eax
-;   andl    %r10d, %r8d, %r10d
-;   andl    %r11d, %r13d, %r11d
-;   andl    %r14d, %r15d, %r14d
-;   andl    %ebx, %esi, %ebx
+;   andl    %eax, %r9d, %eax
+;   andl    %r8d, %r11d, %r8d
+;   andl    %r10d, %r14d, %r10d
+;   andl    %r13d, %ebx, %r13d
+;   andl    %r15d, %edi, %r15d
+;   andl    %eax, %r8d, %eax
+;   andl    %r10d, %r13d, %r10d
 ;   andl    %eax, %r10d, %eax
-;   andl    %r11d, %r14d, %r11d
-;   andl    %eax, %r11d, %eax
-;   andl    %eax, %ebx, %eax
-;   movq    16(%rsp), %rbx
-;   movq    24(%rsp), %r12
-;   movq    32(%rsp), %r13
-;   movq    40(%rsp), %r14
-;   movq    48(%rsp), %r15
-;   addq    %rsp, $64, %rsp
+;   andl    %eax, %r15d, %eax
+;   movq    0(%rsp), %rbx
+;   movq    8(%rsp), %r12
+;   movq    16(%rsp), %r13
+;   movq    24(%rsp), %r14
+;   movq    32(%rsp), %r15
+;   addq    %rsp, $48, %rsp
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -436,116 +389,71 @@ block0(v0: i128, v1: i128):
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
-;   subq $0x40, %rsp
-;   movq %rbx, 0x10(%rsp)
-;   movq %r12, 0x18(%rsp)
-;   movq %r13, 0x20(%rsp)
-;   movq %r14, 0x28(%rsp)
-;   movq %r15, 0x30(%rsp)
-; block1: ; offset 0x21
-;   cmpq %rdx, %rdi
-;   sete %r9b
-;   cmpq %rcx, %rsi
-;   sete %r10b
-;   andq %r10, %r9
-;   testq $1, %r9
-;   setne %al
-;   cmpq %rdx, %rdi
-;   setne %r8b
-;   cmpq %rcx, %rsi
-;   setne %r9b
+;   subq $0x30, %rsp
+;   movq %rbx, (%rsp)
+;   movq %r12, 8(%rsp)
+;   movq %r13, 0x10(%rsp)
+;   movq %r14, 0x18(%rsp)
+;   movq %r15, 0x20(%rsp)
+; block1: ; offset 0x20
+;   movq %rdi, %rax
+;   xorq %rdx, %rax
+;   movq %rsi, %r8
+;   xorq %rcx, %r8
+;   orq %r8, %rax
+;   sete %al
+;   movq %rdi, %r8
+;   xorq %rdx, %r8
+;   movq %rsi, %r9
+;   xorq %rcx, %r9
 ;   orq %r9, %r8
-;   testq $1, %r8
 ;   setne %r9b
-;   movq %r9, (%rsp)
-;   cmpq %rcx, %rsi
-;   setl %r8b
-;   sete %r10b
 ;   cmpq %rdx, %rdi
-;   setb %r11b
-;   andq %r11, %r10
-;   orq %r10, %r8
-;   testq $1, %r8
-;   setne %r10b
-;   cmpq %rcx, %rsi
-;   setl %r11b
-;   sete %r8b
-;   cmpq %rdx, %rdi
-;   setbe %r15b
-;   andq %r15, %r8
-;   orq %r8, %r11
-;   testq $1, %r11
-;   setne %r8b
-;   cmpq %rcx, %rsi
-;   setg %r11b
-;   sete %r12b
-;   cmpq %rdx, %rdi
-;   seta %r13b
-;   andq %r13, %r12
-;   orq %r12, %r11
-;   testq $1, %r11
-;   setne %r11b
-;   cmpq %rcx, %rsi
-;   setg %r15b
-;   sete %bl
-;   cmpq %rdx, %rdi
-;   setae %r12b
-;   andq %r12, %rbx
-;   orq %rbx, %r15
-;   testq $1, %r15
-;   setne %r13b
-;   cmpq %rcx, %rsi
-;   setb %r14b
-;   sete %r15b
-;   cmpq %rdx, %rdi
-;   setb %bl
-;   andq %rbx, %r15
-;   orq %r15, %r14
-;   testq $1, %r14
-;   setne %r14b
-;   cmpq %rcx, %rsi
-;   setb %bl
-;   sete %r12b
+;   movq %rsi, %r8
+;   sbbq %rcx, %r8
+;   setl %r8b
+;   cmpq %rdi, %rdx
+;   movq %rcx, %r10
+;   sbbq %rsi, %r10
+;   setge %r11b
+;   cmpq %rdi, %rdx
+;   movq %rcx, %r10
+;   sbbq %rsi, %r10
+;   setl %r10b
 ;   cmpq %rdx, %rdi
-;   setbe %r15b
-;   andq %r15, %r12
-;   orq %r12, %rbx
-;   testq $1, %rbx
-;   setne %r15b
-;   cmpq %rcx, %rsi
-;   seta %bl
-;   sete %r12b
+;   movq %rsi, %rbx
+;   sbbq %rcx, %rbx
+;   setge %r14b
 ;   cmpq %rdx, %rdi
-;   seta %r9b
-;   andq %r9, %r12
-;   orq %r12, %rbx
-;   testq $1, %rbx
-;   setne %bl
-;   cmpq %rcx, %rsi
-;   seta %sil
-;   sete %cl
+;   movq %rsi, %r12
+;   sbbq %rcx, %r12
+;   setb %r13b
+;   cmpq %rdi, %rdx
+;   movq %rcx, %r15
+;   sbbq %rsi, %r15
+;   setae %bl
+;   cmpq %rdi, %rdx
+;   movq %rcx, %r15
+;   sbbq %rsi, %r15
+;   setb %r15b
 ;   cmpq %rdx, %rdi
+;   sbbq %rcx, %rsi
 ;   setae %dil
-;   andq %rdi, %rcx
-;   orq %rcx, %rsi
-;   testq $1, %rsi
-;   setne %sil
-;   movq (%rsp), %rcx
-;   andl %ecx, %eax
-;   andl %r8d, %r10d
-;   andl %r13d, %r11d
-;   andl %r15d, %r14d
-;   andl %esi, %ebx
+;   andl %r9d, %eax
+;   andl %r11d, %r8d
+;   andl %r14d, %r10d
+;   andl %ebx, %r13d
+;   andl %edi, %r15d
+;   andl %r8d, %eax
+;   andl %r13d, %r10d
 ;   andl %r10d, %eax
-;   andl %r14d, %r11d
-;   andl %r11d, %eax
-;   andl %ebx, %eax
-;   movq 0x10(%rsp), %rbx
-;   movq 0x18(%rsp), %r12
-;   movq 0x20(%rsp), %r13
-;   movq 0x28(%rsp), %r14
-;   movq 0x30(%rsp), %r15
-;   addq $0x40, %rsp
+;   andl %r15d, %eax
+;   movq (%rsp), %rbx
+;   movq 8(%rsp), %r12
+;   movq 0x10(%rsp), %r13
+;   movq 0x18(%rsp), %r14
+;   movq 0x20(%rsp), %r15
+;   addq $0x30, %rsp
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -567,12 +475,8 @@ block2:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   cmpq    $0, %rdi
-;   setz    %r9b
-;   cmpq    $0, %rsi
-;   setz    %sil
-;   testb   %r9b, %sil
-;   jz      label2; j label1
+;   orq     %rdi, %rsi, %rdi
+;   jnz     label2; j label1
 ; block1:
 ;   movl    $1, %eax
 ;   movq    %rbp, %rsp
@@ -589,18 +493,14 @@ block2:
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   cmpq $0, %rdi
-;   sete %r9b
-;   cmpq $0, %rsi
-;   sete %sil
-;   testb %r9b, %sil
-;   je 0x27
-; block2: ; offset 0x1d
+;   orq %rsi, %rdi
+;   jne 0x17
+; block2: ; offset 0xd
 ;   movl $1, %eax
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
-; block3: ; offset 0x27
+; block3: ; offset 0x17
 ;   movl $2, %eax
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -623,12 +523,8 @@ block2:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   cmpq    $0, %rdi
-;   setz    %r9b
-;   cmpq    $0, %rsi
-;   setz    %sil
-;   testb   %r9b, %sil
-;   jz      label2; j label1
+;   orq     %rdi, %rsi, %rdi
+;   jnz     label2; j label1
 ; block1:
 ;   movl    $2, %eax
 ;   movq    %rbp, %rsp
@@ -645,18 +541,14 @@ block2:
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   cmpq $0, %rdi
-;   sete %r9b
-;   cmpq $0, %rsi
-;   sete %sil
-;   testb %r9b, %sil
-;   je 0x27
-; block2: ; offset 0x1d
+;   orq %rsi, %rdi
+;   jne 0x17
+; block2: ; offset 0xd
 ;   movl $2, %eax
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
-; block3: ; offset 0x27
+; block3: ; offset 0x17
 ;   movl $1, %eax
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -672,8 +564,8 @@ block0(v0: i64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rdi, %rax
 ;   xorq    %rdx, %rdx, %rdx
+;   movq    %rdi, %rax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -683,8 +575,8 @@ block0(v0: i64):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rdi, %rax
 ;   xorq %rdx, %rdx
+;   movq %rdi, %rax
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -865,17 +757,16 @@ block0(v0: i128):
 ;   shrq    $1, %rax, %rax
 ;   movabsq $8608480567731124087, %r8
 ;   andq    %rax, %r8, %rax
-;   movq    %rdi, %r9
-;   subq    %r9, %rax, %r9
+;   subq    %rdi, %rax, %rdi
 ;   shrq    $1, %rax, %rax
 ;   andq    %rax, %r8, %rax
-;   subq    %r9, %rax, %r9
+;   subq    %rdi, %rax, %rdi
 ;   shrq    $1, %rax, %rax
 ;   andq    %rax, %r8, %rax
-;   subq    %r9, %rax, %r9
-;   movq    %r9, %rax
+;   subq    %rdi, %rax, %rdi
+;   movq    %rdi, %rax
 ;   shrq    $4, %rax, %rax
-;   addq    %rax, %r9, %rax
+;   addq    %rax, %rdi, %rax
 ;   movabsq $1085102592571150095, %rdi
 ;   andq    %rax, %rdi, %rax
 ;   movabsq $72340172838076673, %rdx
@@ -885,23 +776,22 @@ block0(v0: i128):
 ;   shrq    $1, %rdi, %rdi
 ;   movabsq $8608480567731124087, %rcx
 ;   andq    %rdi, %rcx, %rdi
-;   movq    %rsi, %rdx
-;   subq    %rdx, %rdi, %rdx
+;   subq    %rsi, %rdi, %rsi
 ;   shrq    $1, %rdi, %rdi
 ;   andq    %rdi, %rcx, %rdi
-;   subq    %rdx, %rdi, %rdx
+;   subq    %rsi, %rdi, %rsi
 ;   shrq    $1, %rdi, %rdi
 ;   andq    %rdi, %rcx, %rdi
-;   subq    %rdx, %rdi, %rdx
-;   movq    %rdx, %rsi
-;   shrq    $4, %rsi, %rsi
-;   addq    %rsi, %rdx, %rsi
+;   subq    %rsi, %rdi, %rsi
+;   movq    %rsi, %rdi
+;   shrq    $4, %rdi, %rdi
+;   addq    %rdi, %rsi, %rdi
 ;   movabsq $1085102592571150095, %r10
-;   andq    %rsi, %r10, %rsi
+;   andq    %rdi, %r10, %rdi
 ;   movabsq $72340172838076673, %rcx
-;   imulq   %rsi, %rcx, %rsi
-;   shrq    $56, %rsi, %rsi
-;   addq    %rax, %rsi, %rax
+;   imulq   %rdi, %rcx, %rdi
+;   shrq    $56, %rdi, %rdi
+;   addq    %rax, %rdi, %rax
 ;   xorq    %rdx, %rdx, %rdx
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -916,17 +806,16 @@ block0(v0: i128):
 ;   shrq $1, %rax
 ;   movabsq $0x7777777777777777, %r8
 ;   andq %r8, %rax
-;   movq %rdi, %r9
-;   subq %rax, %r9
+;   subq %rax, %rdi
 ;   shrq $1, %rax
 ;   andq %r8, %rax
-;   subq %rax, %r9
+;   subq %rax, %rdi
 ;   shrq $1, %rax
 ;   andq %r8, %rax
-;   subq %rax, %r9
-;   movq %r9, %rax
+;   subq %rax, %rdi
+;   movq %rdi, %rax
 ;   shrq $4, %rax
-;   addq %r9, %rax
+;   addq %rdi, %rax
 ;   movabsq $0xf0f0f0f0f0f0f0f, %rdi
 ;   andq %rdi, %rax
 ;   movabsq $0x101010101010101, %rdx
@@ -936,23 +825,22 @@ block0(v0: i128):
 ;   shrq $1, %rdi
 ;   movabsq $0x7777777777777777, %rcx
 ;   andq %rcx, %rdi
-;   movq %rsi, %rdx
-;   subq %rdi, %rdx
+;   subq %rdi, %rsi
 ;   shrq $1, %rdi
 ;   andq %rcx, %rdi
-;   subq %rdi, %rdx
+;   subq %rdi, %rsi
 ;   shrq $1, %rdi
 ;   andq %rcx, %rdi
-;   subq %rdi, %rdx
-;   movq %rdx, %rsi
-;   shrq $4, %rsi
-;   addq %rdx, %rsi
+;   subq %rdi, %rsi
+;   movq %rsi, %rdi
+;   shrq $4, %rdi
+;   addq %rsi, %rdi
 ;   movabsq $0xf0f0f0f0f0f0f0f, %r10
-;   andq %r10, %rsi
+;   andq %r10, %rdi
 ;   movabsq $0x101010101010101, %rcx
-;   imulq %rcx, %rsi
-;   shrq $0x38, %rsi
-;   addq %rsi, %rax
+;   imulq %rcx, %rdi
+;   shrq $0x38, %rdi
+;   addq %rdi, %rax
 ;   xorq %rdx, %rdx
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -971,11 +859,10 @@ block0(v0: i128):
 ;   movabsq $6148914691236517205, %rcx
 ;   movq    %rsi, %rdx
 ;   andq    %rdx, %rcx, %rdx
-;   movq    %rsi, %r11
-;   shrq    $1, %r11, %r11
-;   andq    %r11, %rcx, %r11
+;   shrq    $1, %rsi, %rsi
+;   andq    %rsi, %rcx, %rsi
 ;   shlq    $1, %rdx, %rdx
-;   orq     %rdx, %r11, %rdx
+;   orq     %rdx, %rsi, %rdx
 ;   movabsq $3689348814741910323, %r9
 ;   movq    %rdx, %r10
 ;   andq    %r10, %r9, %r10
@@ -1013,11 +900,10 @@ block0(v0: i128):
 ;   movabsq $6148914691236517205, %rdx
 ;   movq    %rdi, %rcx
 ;   andq    %rcx, %rdx, %rcx
-;   movq    %rdi, %r9
-;   shrq    $1, %r9, %r9
-;   andq    %r9, %rdx, %r9
+;   shrq    $1, %rdi, %rdi
+;   andq    %rdi, %rdx, %rdi
 ;   shlq    $1, %rcx, %rcx
-;   orq     %rcx, %r9, %rcx
+;   orq     %rcx, %rdi, %rcx
 ;   movabsq $3689348814741910323, %rdx
 ;   movq    %rcx, %r8
 ;   andq    %r8, %rdx, %r8
@@ -1064,11 +950,10 @@ block0(v0: i128):
 ;   movabsq $0x5555555555555555, %rcx
 ;   movq %rsi, %rdx
 ;   andq %rcx, %rdx
-;   movq %rsi, %r11
-;   shrq $1, %r11
-;   andq %rcx, %r11
+;   shrq $1, %rsi
+;   andq %rcx, %rsi
 ;   shlq $1, %rdx
-;   orq %r11, %rdx
+;   orq %rsi, %rdx
 ;   movabsq $0x3333333333333333, %r9
 ;   movq %rdx, %r10
 ;   andq %r9, %r10
@@ -1106,11 +991,10 @@ block0(v0: i128):
 ;   movabsq $0x5555555555555555, %rdx
 ;   movq %rdi, %rcx
 ;   andq %rdx, %rcx
-;   movq %rdi, %r9
-;   shrq $1, %r9
-;   andq %rdx, %r9
+;   shrq $1, %rdi
+;   andq %rdx, %rdi
 ;   shlq $1, %rcx
-;   orq %r9, %rcx
+;   orq %rdi, %rcx
 ;   movabsq $0x3333333333333333, %rdx
 ;   movq %rcx, %r8
 ;   andq %rdx, %r8
@@ -1227,25 +1111,20 @@ block2(v8: i128):
 ;   movq    %rsp, %rbp
 ; block0:
 ;   xorq    %rax, %rax, %rax
-;   xorq    %r9, %r9, %r9
-;   movq    %r9, %r8
+;   xorq    %r8, %r8, %r8
 ;   testb   %dl, %dl
 ;   jnz     label2; j label1
 ; block1:
-;   movl    $2, %r9d
-;   xorq    %r10, %r10, %r10
-;   addq    %rax, %r9, %rax
+;   addq    %rax, $2, %rax
 ;   movq    %r8, %rdx
-;   adcq    %rdx, %r10, %rdx
+;   adcq    %rdx, $0, %rdx
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
 ; block2:
 ;   movq    %r8, %rdx
-;   movl    $1, %r10d
-;   xorq    %r11, %r11, %r11
-;   addq    %rax, %r10, %rax
-;   adcq    %rdx, %r11, %rdx
+;   addq    %rax, $1, %rax
+;   adcq    %rdx, $0, %rdx
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -1256,25 +1135,20 @@ block2(v8: i128):
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
 ;   xorq %rax, %rax
-;   xorq %r9, %r9
-;   movq %r9, %r8
+;   xorq %r8, %r8
 ;   testb %dl, %dl
-;   jne 0x2c
-; block2: ; offset 0x15
-;   movl $2, %r9d
-;   xorq %r10, %r10
-;   addq %r9, %rax
+;   jne 0x22
+; block2: ; offset 0x12
+;   addq $2, %rax
 ;   movq %r8, %rdx
-;   adcq %r10, %rdx
+;   adcq $0, %rdx
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
-; block3: ; offset 0x2c
+; block3: ; offset 0x22
 ;   movq %r8, %rdx
-;   movl $1, %r10d
-;   xorq %r11, %r11
-;   addq %r10, %rax
-;   adcq %r11, %rdx
+;   addq $1, %rax
+;   adcq $0, %rdx
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -1295,39 +1169,31 @@ block0(v0: i128, v1: i128, v2: i64, v3: i128, v4: i128, v5: i128):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ;   subq    %rsp, $32, %rsp
-;   movq    %rbx, 0(%rsp)
-;   movq    %r12, 8(%rsp)
-;   movq    %r14, 16(%rsp)
-;   movq    %r15, 24(%rsp)
+;   movq    %r13, 0(%rsp)
+;   movq    %r14, 8(%rsp)
+;   movq    %r15, 16(%rsp)
 ; block0:
-;   movq    %r8, %r14
-;   movq    %rcx, %rbx
-;   movq    %rdx, %rcx
-;   movq    16(%rbp), %r15
-;   movq    24(%rbp), %rax
-;   movq    32(%rbp), %rdx
-;   movq    40(%rbp), %r11
-;   movq    48(%rbp), %r10
-;   movq    %rdi, %r8
-;   addq    %r8, %rcx, %r8
-;   movq    %rbx, %rdi
-;   movq    %rsi, %rcx
-;   adcq    %rcx, %rdi, %rcx
-;   xorq    %rdi, %rdi, %rdi
-;   movq    %r14, %r12
-;   movq    %r9, %rsi
-;   addq    %rsi, %r12, %rsi
-;   adcq    %r15, %rdi, %r15
+;   movq    %rcx, %r13
+;   movq    %rdx, %r15
+;   movq    rbp(stack args max - 48), %rcx
+;   movq    rbp(stack args max - 40), %rax
+;   movq    rbp(stack args max - 32), %rdx
+;   movq    rbp(stack args max - 24), %r11
+;   movq    rbp(stack args max - 16), %r10
+;   addq    %rdi, %r15, %rdi
+;   movq    %r13, %r14
+;   adcq    %rsi, %r14, %rsi
+;   addq    %r9, %r8, %r9
+;   adcq    %rcx, $0, %rcx
 ;   addq    %rax, %r11, %rax
 ;   adcq    %rdx, %r10, %rdx
-;   addq    %r8, %rsi, %r8
-;   adcq    %rcx, %r15, %rcx
-;   addq    %rax, %r8, %rax
-;   adcq    %rdx, %rcx, %rdx
-;   movq    0(%rsp), %rbx
-;   movq    8(%rsp), %r12
-;   movq    16(%rsp), %r14
-;   movq    24(%rsp), %r15
+;   addq    %rdi, %r9, %rdi
+;   adcq    %rsi, %rcx, %rsi
+;   addq    %rax, %rdi, %rax
+;   adcq    %rdx, %rsi, %rdx
+;   movq    0(%rsp), %r13
+;   movq    8(%rsp), %r14
+;   movq    16(%rsp), %r15
 ;   addq    %rsp, $32, %rsp
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -1338,39 +1204,31 @@ block0(v0: i128, v1: i128, v2: i64, v3: i128, v4: i128, v5: i128):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ;   subq $0x20, %rsp
-;   movq %rbx, (%rsp)
-;   movq %r12, 8(%rsp)
-;   movq %r14, 0x10(%rsp)
-;   movq %r15, 0x18(%rsp)
-; block1: ; offset 0x1b
-;   movq %r8, %r14
-;   movq %rcx, %rbx
-;   movq %rdx, %rcx
-;   movq 0x10(%rbp), %r15
+;   movq %r13, (%rsp)
+;   movq %r14, 8(%rsp)
+;   movq %r15, 0x10(%rsp)
+; block1: ; offset 0x16
+;   movq %rcx, %r13
+;   movq %rdx, %r15
+;   movq 0x10(%rbp), %rcx
 ;   movq 0x18(%rbp), %rax
 ;   movq 0x20(%rbp), %rdx
 ;   movq 0x28(%rbp), %r11
 ;   movq 0x30(%rbp), %r10
-;   movq %rdi, %r8
-;   addq %rcx, %r8
-;   movq %rbx, %rdi
-;   movq %rsi, %rcx
-;   adcq %rdi, %rcx
-;   xorq %rdi, %rdi
-;   movq %r14, %r12
-;   movq %r9, %rsi
-;   addq %r12, %rsi
-;   adcq %rdi, %r15
+;   addq %r15, %rdi
+;   movq %r13, %r14
+;   adcq %r14, %rsi
+;   addq %r8, %r9
+;   adcq $0, %rcx
 ;   addq %r11, %rax
 ;   adcq %r10, %rdx
-;   addq %rsi, %r8
-;   adcq %r15, %rcx
-;   addq %r8, %rax
-;   adcq %rcx, %rdx
-;   movq (%rsp), %rbx
-;   movq 8(%rsp), %r12
-;   movq 0x10(%rsp), %r14
-;   movq 0x18(%rsp), %r15
+;   addq %r9, %rdi
+;   adcq %rcx, %rsi
+;   addq %rdi, %rax
+;   adcq %rsi, %rdx
+;   movq (%rsp), %r13
+;   movq 8(%rsp), %r14
+;   movq 0x10(%rsp), %r15
 ;   addq $0x20, %rsp
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -1386,17 +1244,17 @@ block0(v0: i128):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rdi, 0(%rdx)
-;   movq    %rsi, 8(%rdx)
-;   movq    %rdi, 16(%rdx)
-;   movq    %rsi, 24(%rdx)
+;   movq    %rsi, 0(%rdx)
+;   movq    %rdi, 8(%rdx)
+;   movq    %rsi, 16(%rdx)
+;   movq    %rdi, 24(%rdx)
 ;   movq    %rdi, 32(%rdx)
-;   movq    %rdi, 40(%rdx)
-;   movq    %rsi, 48(%rdx)
-;   movq    %rdi, 56(%rdx)
-;   movq    %rdi, %rax
-;   movq    %rsi, 64(%rdx)
+;   movq    %rsi, 40(%rdx)
+;   movq    %rdi, 48(%rdx)
+;   movq    %rsi, 56(%rdx)
+;   movq    %rdi, %rcx
 ;   movq    %rsi, %rdx
+;   movq    %rcx, %rax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -1406,17 +1264,17 @@ block0(v0: i128):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rdi, (%rdx)
-;   movq %rsi, 8(%rdx)
-;   movq %rdi, 0x10(%rdx)
-;   movq %rsi, 0x18(%rdx)
+;   movq %rsi, (%rdx)
+;   movq %rdi, 8(%rdx)
+;   movq %rsi, 0x10(%rdx)
+;   movq %rdi, 0x18(%rdx)
 ;   movq %rdi, 0x20(%rdx)
-;   movq %rdi, 0x28(%rdx)
-;   movq %rsi, 0x30(%rdx)
-;   movq %rdi, 0x38(%rdx)
-;   movq %rdi, %rax
-;   movq %rsi, 0x40(%rdx)
+;   movq %rsi, 0x28(%rdx)
+;   movq %rdi, 0x30(%rdx)
+;   movq %rsi, 0x38(%rdx)
+;   movq %rdi, %rcx
 ;   movq %rsi, %rdx
+;   movq %rcx, %rax
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -1431,24 +1289,18 @@ block0(v0: i128, v1: i128):
 ; VCode:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
-;   subq    %rsp, $16, %rsp
-;   movq    %r13, 0(%rsp)
+;   subq    %rsp, $32, %rsp
+;   movq    %r13, 16(%rsp)
 ; block0:
 ;   movq    %r8, %r13
-;   subq    %rsp, $16, %rsp
-;   virtual_sp_offset_adjust 16
 ;   lea     0(%rsp), %r8
 ;   load_ext_name %g+0, %r9
 ;   call    *%r9
 ;   movq    0(%rsp), %r8
-;   movq    8(%rsp), %r9
-;   addq    %rsp, $16, %rsp
-;   virtual_sp_offset_adjust -16
-;   movq    %r13, %rcx
-;   movq    %r8, 0(%rcx)
-;   movq    %r9, 8(%rcx)
-;   movq    0(%rsp), %r13
-;   addq    %rsp, $16, %rsp
+;   movq    %r13, %r10
+;   movq    %r8, 0(%r10)
+;   movq    16(%rsp), %r13
+;   addq    %rsp, $32, %rsp
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -1457,22 +1309,18 @@ block0(v0: i128, v1: i128):
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
-;   subq $0x10, %rsp
-;   movq %r13, (%rsp)
-; block1: ; offset 0xc
+;   subq $0x20, %rsp
+;   movq %r13, 0x10(%rsp)
+; block1: ; offset 0xd
 ;   movq %r8, %r13
-;   subq $0x10, %rsp
 ;   leaq (%rsp), %r8
 ;   movabsq $0, %r9 ; reloc_external Abs8 %g 0
 ;   callq *%r9
 ;   movq (%rsp), %r8
-;   movq 8(%rsp), %r9
-;   addq $0x10, %rsp
-;   movq %r13, %rcx
-;   movq %r8, (%rcx)
-;   movq %r9, 8(%rcx)
-;   movq (%rsp), %r13
-;   addq $0x10, %rsp
+;   movq %r13, %r10
+;   movq %r8, (%r10)
+;   movq 0x10(%rsp), %r13
+;   addq $0x20, %rsp
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -1618,21 +1466,19 @@ block0(v0: i128, v1: i128):
 ;   movq    %rdx, %r10
 ;   movq    %rdi, %rdx
 ;   shlq    %cl, %rdx, %rdx
-;   movq    %rsi, %r11
-;   shlq    %cl, %r11, %r11
+;   shlq    %cl, %rsi, %rsi
 ;   movq    %rcx, %r10
 ;   movl    $64, %ecx
 ;   movq    %r10, %r8
 ;   subq    %rcx, %r8, %rcx
-;   movq    %rdi, %r10
-;   shrq    %cl, %r10, %r10
+;   shrq    %cl, %rdi, %rdi
 ;   xorq    %rax, %rax, %rax
 ;   testq   $127, %r8
-;   cmovzq  %rax, %r10, %r10
-;   orq     %r10, %r11, %r10
+;   cmovzq  %rax, %rdi, %rdi
+;   orq     %rdi, %rsi, %rdi
 ;   testq   $64, %r8
 ;   cmovzq  %rdx, %rax, %rax
-;   cmovzq  %r10, %rdx, %rdx
+;   cmovzq  %rdi, %rdx, %rdx
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -1646,21 +1492,19 @@ block0(v0: i128, v1: i128):
 ;   movq %rdx, %r10
 ;   movq %rdi, %rdx
 ;   shlq %cl, %rdx
-;   movq %rsi, %r11
-;   shlq %cl, %r11
+;   shlq %cl, %rsi
 ;   movq %rcx, %r10
 ;   movl $0x40, %ecx
 ;   movq %r10, %r8
 ;   subq %r8, %rcx
-;   movq %rdi, %r10
-;   shrq %cl, %r10
+;   shrq %cl, %rdi
 ;   xorq %rax, %rax
 ;   testq $0x7f, %r8
-;   cmoveq %rax, %r10
-;   orq %r11, %r10
+;   cmoveq %rax, %rdi
+;   orq %rsi, %rdi
 ;   testq $0x40, %r8
 ;   cmoveq %rdx, %rax
-;   cmoveq %r10, %rdx
+;   cmoveq %rdi, %rdx
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -1677,23 +1521,21 @@ block0(v0: i128, v1: i128):
 ; block0:
 ;   movq    %rdx, %rcx
 ;   movq    %rdx, %r11
-;   movq    %rdi, %r8
-;   shrq    %cl, %r8, %r8
+;   shrq    %cl, %rdi, %rdi
 ;   movq    %rsi, %r10
 ;   shrq    %cl, %r10, %r10
 ;   movq    %rcx, %r11
 ;   movl    $64, %ecx
-;   movq    %r11, %rdi
-;   subq    %rcx, %rdi, %rcx
-;   movq    %rsi, %r11
-;   shlq    %cl, %r11, %r11
+;   movq    %r11, %rax
+;   subq    %rcx, %rax, %rcx
+;   shlq    %cl, %rsi, %rsi
 ;   xorq    %rdx, %rdx, %rdx
-;   testq   $127, %rdi
-;   cmovzq  %rdx, %r11, %r11
-;   orq     %r11, %r8, %r11
-;   testq   $64, %rdi
+;   testq   $127, %rax
+;   cmovzq  %rdx, %rsi, %rsi
+;   orq     %rsi, %rdi, %rsi
+;   testq   $64, %rax
 ;   movq    %r10, %rax
-;   cmovzq  %r11, %rax, %rax
+;   cmovzq  %rsi, %rax, %rax
 ;   cmovzq  %r10, %rdx, %rdx
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -1706,23 +1548,21 @@ block0(v0: i128, v1: i128):
 ; block1: ; offset 0x4
 ;   movq %rdx, %rcx
 ;   movq %rdx, %r11
-;   movq %rdi, %r8
-;   shrq %cl, %r8
+;   shrq %cl, %rdi
 ;   movq %rsi, %r10
 ;   shrq %cl, %r10
 ;   movq %rcx, %r11
 ;   movl $0x40, %ecx
-;   movq %r11, %rdi
-;   subq %rdi, %rcx
-;   movq %rsi, %r11
-;   shlq %cl, %r11
+;   movq %r11, %rax
+;   subq %rax, %rcx
+;   shlq %cl, %rsi
 ;   xorq %rdx, %rdx
-;   testq $0x7f, %rdi
-;   cmoveq %rdx, %r11
-;   orq %r8, %r11
-;   testq $0x40, %rdi
+;   testq $0x7f, %rax
+;   cmoveq %rdx, %rsi
+;   orq %rdi, %rsi
+;   testq $0x40, %rax
 ;   movq %r10, %rax
-;   cmoveq %r11, %rax
+;   cmoveq %rsi, %rax
 ;   cmoveq %r10, %rdx
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -1740,8 +1580,7 @@ block0(v0: i128, v1: i128):
 ; block0:
 ;   movq    %rdx, %rcx
 ;   movq    %rdx, %r11
-;   movq    %rdi, %r8
-;   shrq    %cl, %r8, %r8
+;   shrq    %cl, %rdi, %rdi
 ;   movq    %rsi, %r10
 ;   sarq    %cl, %r10, %r10
 ;   movq    %rcx, %r11
@@ -1753,12 +1592,12 @@ block0(v0: i128, v1: i128):
 ;   xorq    %r11, %r11, %r11
 ;   testq   $127, %rax
 ;   cmovzq  %r11, %r9, %r9
-;   orq     %r8, %r9, %r8
-;   movq    %rsi, %rdx
-;   sarq    $63, %rdx, %rdx
+;   orq     %rdi, %r9, %rdi
+;   sarq    $63, %rsi, %rsi
 ;   testq   $64, %rax
 ;   movq    %r10, %rax
-;   cmovzq  %r8, %rax, %rax
+;   cmovzq  %rdi, %rax, %rax
+;   movq    %rsi, %rdx
 ;   cmovzq  %r10, %rdx, %rdx
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -1771,8 +1610,7 @@ block0(v0: i128, v1: i128):
 ; block1: ; offset 0x4
 ;   movq %rdx, %rcx
 ;   movq %rdx, %r11
-;   movq %rdi, %r8
-;   shrq %cl, %r8
+;   shrq %cl, %rdi
 ;   movq %rsi, %r10
 ;   sarq %cl, %r10
 ;   movq %rcx, %r11
@@ -1784,12 +1622,12 @@ block0(v0: i128, v1: i128):
 ;   xorq %r11, %r11
 ;   testq $0x7f, %rax
 ;   cmoveq %r11, %r9
-;   orq %r9, %r8
-;   movq %rsi, %rdx
-;   sarq $0x3f, %rdx
+;   orq %r9, %rdi
+;   sarq $0x3f, %rsi
 ;   testq $0x40, %rax
 ;   movq %r10, %rax
-;   cmoveq %r8, %rax
+;   cmoveq %rdi, %rax
+;   movq %rsi, %rdx
 ;   cmoveq %r10, %rdx
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -1828,26 +1666,24 @@ block0(v0: i128, v1: i128):
 ;   movl    $128, %ecx
 ;   movq    %r8, %r10
 ;   subq    %rcx, %r10, %rcx
-;   movq    %rdi, %r8
-;   shrq    %cl, %r8, %r8
+;   shrq    %cl, %rdi, %rdi
 ;   movq    %rsi, %r9
 ;   shrq    %cl, %r9, %r9
-;   movq    %rcx, %r10
+;   movq    %rcx, %r8
 ;   movl    $64, %ecx
-;   movq    %r10, %r11
-;   subq    %rcx, %r11, %rcx
-;   movq    %rsi, %r10
-;   shlq    %cl, %r10, %r10
-;   xorq    %rsi, %rsi, %rsi
-;   testq   $127, %r11
+;   movq    %r8, %r10
+;   subq    %rcx, %r10, %rcx
+;   shlq    %cl, %rsi, %rsi
+;   xorq    %r8, %r8, %r8
+;   testq   $127, %r10
+;   cmovzq  %r8, %rsi, %rsi
+;   orq     %rsi, %rdi, %rsi
+;   testq   $64, %r10
+;   movq    %r9, %r10
 ;   cmovzq  %rsi, %r10, %r10
-;   orq     %r10, %r8, %r10
-;   testq   $64, %r11
-;   movq    %r9, %r8
-;   cmovzq  %r10, %r8, %r8
-;   cmovzq  %r9, %rsi, %rsi
-;   orq     %rax, %r8, %rax
-;   orq     %rdx, %rsi, %rdx
+;   cmovzq  %r9, %r8, %r8
+;   orq     %rax, %r10, %rax
+;   orq     %rdx, %r8, %rdx
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -1880,26 +1716,24 @@ block0(v0: i128, v1: i128):
 ;   movl $0x80, %ecx
 ;   movq %r8, %r10
 ;   subq %r10, %rcx
-;   movq %rdi, %r8
-;   shrq %cl, %r8
+;   shrq %cl, %rdi
 ;   movq %rsi, %r9
 ;   shrq %cl, %r9
-;   movq %rcx, %r10
+;   movq %rcx, %r8
 ;   movl $0x40, %ecx
-;   movq %r10, %r11
-;   subq %r11, %rcx
-;   movq %rsi, %r10
-;   shlq %cl, %r10
-;   xorq %rsi, %rsi
-;   testq $0x7f, %r11
+;   movq %r8, %r10
+;   subq %r10, %rcx
+;   shlq %cl, %rsi
+;   xorq %r8, %r8
+;   testq $0x7f, %r10
+;   cmoveq %r8, %rsi
+;   orq %rdi, %rsi
+;   testq $0x40, %r10
+;   movq %r9, %r10
 ;   cmoveq %rsi, %r10
-;   orq %r8, %r10
-;   testq $0x40, %r11
-;   movq %r9, %r8
-;   cmoveq %r10, %r8
-;   cmoveq %r9, %rsi
-;   orq %r8, %rax
-;   orq %rsi, %rdx
+;   cmoveq %r9, %r8
+;   orq %r10, %rax
+;   orq %r8, %rdx
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -1940,21 +1774,18 @@ block0(v0: i128, v1: i128):
 ;   subq    %rcx, %r10, %rcx
 ;   movq    %rdi, %r8
 ;   shlq    %cl, %r8, %r8
-;   movq    %rsi, %r10
-;   shlq    %cl, %r10, %r10
+;   shlq    %cl, %rsi, %rsi
 ;   movq    %rcx, %r9
 ;   movl    $64, %ecx
-;   movq    %r9, %rsi
-;   subq    %rcx, %rsi, %rcx
-;   movq    %rdi, %r9
-;   shrq    %cl, %r9, %r9
+;   subq    %rcx, %r9, %rcx
+;   shrq    %cl, %rdi, %rdi
 ;   xorq    %r11, %r11, %r11
-;   testq   $127, %rsi
-;   cmovzq  %r11, %r9, %r9
-;   orq     %r9, %r10, %r9
-;   testq   $64, %rsi
+;   testq   $127, %r9
+;   cmovzq  %r11, %rdi, %rdi
+;   orq     %rdi, %rsi, %rdi
+;   testq   $64, %r9
 ;   cmovzq  %r8, %r11, %r11
-;   cmovzq  %r9, %r8, %r8
+;   cmovzq  %rdi, %r8, %r8
 ;   orq     %rax, %r11, %rax
 ;   orq     %rdx, %r8, %rdx
 ;   movq    %rbp, %rsp
@@ -1992,24 +1823,323 @@ block0(v0: i128, v1: i128):
 ;   subq %r10, %rcx
 ;   movq %rdi, %r8
 ;   shlq %cl, %r8
-;   movq %rsi, %r10
-;   shlq %cl, %r10
+;   shlq %cl, %rsi
 ;   movq %rcx, %r9
 ;   movl $0x40, %ecx
-;   movq %r9, %rsi
-;   subq %rsi, %rcx
-;   movq %rdi, %r9
-;   shrq %cl, %r9
+;   subq %r9, %rcx
+;   shrq %cl, %rdi
 ;   xorq %r11, %r11
-;   testq $0x7f, %rsi
-;   cmoveq %r11, %r9
-;   orq %r10, %r9
-;   testq $0x40, %rsi
+;   testq $0x7f, %r9
+;   cmoveq %r11, %rdi
+;   orq %rsi, %rdi
+;   testq $0x40, %r9
 ;   cmoveq %r8, %r11
-;   cmoveq %r9, %r8
+;   cmoveq %rdi, %r8
 ;   orq %r11, %rax
 ;   orq %r8, %rdx
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
 
+function %iabs_i128(i128) -> i128 {
+block0(v0: i128):
+    v1 = iabs.i128 v0
+    return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   xorq    %r8, %r8, %r8
+;   movq    %rdi, %rax
+;   negq    %rax, %rax
+;   movq    %rsi, %rdx
+;   adcq    %rdx, %r8, %rdx
+;   negq    %rdx, %rdx
+;   cmovsq  %rdi, %rax, %rax
+;   cmovsq  %rsi, %rdx, %rdx
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   xorq %r8, %r8
+;   movq %rdi, %rax
+;   negq %rax
+;   movq %rsi, %rdx
+;   adcq %r8, %rdx
+;   negq %rdx
+;   cmovsq %rdi, %rax
+;   cmovsq %rsi, %rdx
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %mul_wide_i64(i64, i64) -> i128 {
+block0(v0: i64, v1: i64):
+    v2 = uextend.i128 v0
+    v3 = uextend.i128 v1
+    v4 = imul v2, v3
+    return v4
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movq    %rdi, %rax
+;   mulq    %rax, %rsi, %rax, %rdx
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movq %rdi, %rax
+;   mulq %rsi
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %add_concat_64(i64, i64) -> i128 {
+block0(v0: i64, v1: i64):
+    v10 = iconst.i64 0
+    v2 = iconcat v0, v10
+    v3 = iconcat v1, v10
+    v4 = iadd v2, v3
+    return v4
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   xorq    %rdx, %rdx, %rdx
+;   movq    %rdi, %rax
+;   addq    %rax, %rsi, %rax
+;   adcq    %rdx, $0, %rdx
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   xorq %rdx, %rdx
+;   movq %rdi, %rax
+;   addq %rsi, %rax
+;   adcq $0, %rdx
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %mul_uextend_i64(i64, i64) -> i128 {
+block0(v0: i64, v1: i64):
+    v2 = uextend.i128 v0
+    v3 = uextend.i128 v1
+    v4 = imul v2, v3
+    return v4
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movq    %rdi, %rax
+;   mulq    %rax, %rsi, %rax, %rdx
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movq %rdi, %rax
+;   mulq %rsi
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %mul_sextend_i64(i64, i64) -> i128 {
+block0(v0: i64, v1: i64):
+    v2 = sextend.i128 v0
+    v3 = sextend.i128 v1
+    v4 = imul v2, v3
+    return v4
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movq    %rdi, %rax
+;   imulq   %rax, %rsi, %rax, %rdx
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movq %rdi, %rax
+;   imulq %rsi
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %sub_uextend_64(i64, i64) -> i128 {
+block0(v0: i64, v1: i64):
+    v2 = uextend.i128 v0
+    v3 = uextend.i128 v1
+    v4 = isub v2, v3
+    return v4
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   xorq    %rdx, %rdx, %rdx
+;   movq    %rdi, %rax
+;   subq    %rax, %rsi, %rax
+;   sbbq    %rdx, $0, %rdx
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   xorq %rdx, %rdx
+;   movq %rdi, %rax
+;   subq %rsi, %rax
+;   sbbq $0, %rdx
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %sink_load_of_i128_half(i64, i64) -> i64, i64 {
+block0(v0: i64, v1: i64):
+    v10 = load.i64 v0
+    v18 = uextend.i128 v1
+    v20 = uextend.i128 v10
+    v14 = iadd v18, v20
+    v15, v16 = isplit v14
+    return v15, v16
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   xorq    %rdx, %rdx, %rdx
+;   movq    %rsi, %rax
+;   addq    %rax, 0(%rdi), %rax
+;   adcq    %rdx, $0, %rdx
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   xorq %rdx, %rdx
+;   movq %rsi, %rax
+;   addq (%rdi), %rax ; trap: heap_oob
+;   adcq $0, %rdx
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %sink_two_i128_loads_in_add(i64, i64) -> i128 {
+block0(v0: i64, v1: i64):
+    v10 = load.i64 v0
+    v11 = load.i64 v0+8
+    v18 = uextend.i128 v1
+    v20 = iconcat v10, v11
+    v14 = iadd v18, v20
+    return v14
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movq    0(%rdi), %r9
+;   xorq    %rdx, %rdx, %rdx
+;   movq    %rsi, %rax
+;   addq    %rax, %r9, %rax
+;   adcq    %rdx, 8(%rdi), %rdx
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movq (%rdi), %r9 ; trap: heap_oob
+;   xorq %rdx, %rdx
+;   movq %rsi, %rax
+;   addq %r9, %rax
+;   adcq 8(%rdi), %rdx ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %sink_two_i128_loads_in_sub(i64, i64) -> i128 {
+block0(v0: i64, v1: i64):
+    v10 = load.i64 v0
+    v11 = load.i64 v0+8
+    v18 = uextend.i128 v1
+    v20 = iconcat v10, v11
+    v14 = isub v18, v20
+    return v14
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movq    0(%rdi), %r9
+;   xorq    %rdx, %rdx, %rdx
+;   movq    %rsi, %rax
+;   subq    %rax, %r9, %rax
+;   sbbq    %rdx, 8(%rdi), %rdx
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movq (%rdi), %r9 ; trap: heap_oob
+;   xorq %rdx, %rdx
+;   movq %rsi, %rax
+;   subq %r9, %rax
+;   sbbq 8(%rdi), %rdx ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/inline-probestack-large.clif b/cranelift/filetests/filetests/isa/x64/inline-probestack-large.clif
index adeab023c73e..c2193fd97321 100644
--- a/cranelift/filetests/filetests/isa/x64/inline-probestack-large.clif
+++ b/cranelift/filetests/filetests/isa/x64/inline-probestack-large.clif
@@ -50,9 +50,13 @@ block0:
 ; VCode:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
-;   movl    %esp, -65536(%rsp)
-;   movl    %esp, -131072(%rsp)
-;   movl    %esp, -196608(%rsp)
+;   subq    %rsp, $65536, %rsp
+;   movl    %esp, 0(%rsp)
+;   subq    %rsp, $65536, %rsp
+;   movl    %esp, 0(%rsp)
+;   subq    %rsp, $65536, %rsp
+;   movl    %esp, 0(%rsp)
+;   addq    %rsp, $196608, %rsp
 ;   subq    %rsp, $196608, %rsp
 ; block0:
 ;   lea     rsp(0 + virtual offset), %rax
@@ -65,11 +69,15 @@ block0:
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
-;   movl %esp, -0x10000(%rsp)
-;   movl %esp, -0x20000(%rsp)
-;   movl %esp, -0x30000(%rsp)
+;   subq $0x10000, %rsp
+;   movl %esp, (%rsp)
+;   subq $0x10000, %rsp
+;   movl %esp, (%rsp)
+;   subq $0x10000, %rsp
+;   movl %esp, (%rsp)
+;   addq $0x30000, %rsp
 ;   subq $0x30000, %rsp
-; block1: ; offset 0x20
+; block1: ; offset 0x30
 ;   leaq (%rsp), %rax
 ;   addq $0x30000, %rsp
 ;   movq %rbp, %rsp
diff --git a/cranelift/filetests/filetests/isa/x64/inline-probestack.clif b/cranelift/filetests/filetests/isa/x64/inline-probestack.clif
index c55c87000212..afb5b93fe670 100644
--- a/cranelift/filetests/filetests/isa/x64/inline-probestack.clif
+++ b/cranelift/filetests/filetests/isa/x64/inline-probestack.clif
@@ -49,9 +49,13 @@ block0:
 ; VCode:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
-;   movl    %esp, -4096(%rsp)
-;   movl    %esp, -8192(%rsp)
-;   movl    %esp, -12288(%rsp)
+;   subq    %rsp, $4096, %rsp
+;   movl    %esp, 0(%rsp)
+;   subq    %rsp, $4096, %rsp
+;   movl    %esp, 0(%rsp)
+;   subq    %rsp, $4096, %rsp
+;   movl    %esp, 0(%rsp)
+;   addq    %rsp, $12288, %rsp
 ;   subq    %rsp, $12288, %rsp
 ; block0:
 ;   lea     rsp(0 + virtual offset), %rax
@@ -64,11 +68,15 @@ block0:
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
-;   movl %esp, -0x1000(%rsp)
-;   movl %esp, -0x2000(%rsp)
-;   movl %esp, -0x3000(%rsp)
+;   subq $0x1000, %rsp
+;   movl %esp, (%rsp)
+;   subq $0x1000, %rsp
+;   movl %esp, (%rsp)
+;   subq $0x1000, %rsp
+;   movl %esp, (%rsp)
+;   addq $0x3000, %rsp
 ;   subq $0x3000, %rsp
-; block1: ; offset 0x20
+; block1: ; offset 0x30
 ;   leaq (%rsp), %rax
 ;   addq $0x3000, %rsp
 ;   movq %rbp, %rsp
diff --git a/cranelift/filetests/filetests/isa/x64/insertlane-avx.clif b/cranelift/filetests/filetests/isa/x64/insertlane-avx.clif
index 7b1368a9b58e..5f137321db84 100644
--- a/cranelift/filetests/filetests/isa/x64/insertlane-avx.clif
+++ b/cranelift/filetests/filetests/isa/x64/insertlane-avx.clif
@@ -62,8 +62,8 @@ block0(v0: f64x2, v1: i64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   vmovsd  0(%rdi), %xmm3
-;   vmovsd  %xmm0, %xmm3, %xmm0
+;   vmovsd  0(%rdi), %xmm4
+;   vmovsd  %xmm0, %xmm4, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -73,8 +73,8 @@ block0(v0: f64x2, v1: i64):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   vmovsd (%rdi), %xmm3 ; trap: heap_oob
-;   vmovsd %xmm3, %xmm0, %xmm0
+;   vmovsd (%rdi), %xmm4 ; trap: heap_oob
+;   vmovsd %xmm4, %xmm0, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -90,8 +90,7 @@ block0(v0: i8x16, v1: i64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movzbq  0(%rdi), %rdx
-;   vpinsrb $1, %xmm0, %rdx, %xmm0
+;   vpinsrb $1, %xmm0, 0(%rdi), %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -101,8 +100,7 @@ block0(v0: i8x16, v1: i64):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movzbq (%rdi), %rdx ; trap: heap_oob
-;   vpinsrb $1, %edx, %xmm0, %xmm0
+;   vpinsrb $1, (%rdi), %xmm0, %xmm0 ; trap: heap_oob
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -118,8 +116,7 @@ block0(v0: i16x8, v1: i64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movzwq  0(%rdi), %rdx
-;   vpinsrw $1, %xmm0, %rdx, %xmm0
+;   vpinsrw $1, %xmm0, 0(%rdi), %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -129,8 +126,7 @@ block0(v0: i16x8, v1: i64):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movzwq (%rdi), %rdx ; trap: heap_oob
-;   vpinsrw $1, %edx, %xmm0, %xmm0
+;   vpinsrw $1, (%rdi), %xmm0, %xmm0 ; trap: heap_oob
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
diff --git a/cranelift/filetests/filetests/isa/x64/insertlane.clif b/cranelift/filetests/filetests/isa/x64/insertlane.clif
index d15afb787dca..d27740f58571 100644
--- a/cranelift/filetests/filetests/isa/x64/insertlane.clif
+++ b/cranelift/filetests/filetests/isa/x64/insertlane.clif
@@ -62,8 +62,8 @@ block0(v0: f64x2, v1: i64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movsd   0(%rdi), %xmm3
-;   movsd   %xmm0, %xmm3, %xmm0
+;   movsd   0(%rdi), %xmm4
+;   movsd   %xmm0, %xmm4, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -73,8 +73,8 @@ block0(v0: f64x2, v1: i64):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movsd (%rdi), %xmm3 ; trap: heap_oob
-;   movsd %xmm3, %xmm0
+;   movsd (%rdi), %xmm4 ; trap: heap_oob
+;   movsd %xmm4, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -90,8 +90,7 @@ block0(v0: i8x16, v1: i64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movzbq  0(%rdi), %rdx
-;   pinsrb  $1, %xmm0, %rdx, %xmm0
+;   pinsrb  $1, %xmm0, 0(%rdi), %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -101,8 +100,7 @@ block0(v0: i8x16, v1: i64):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movzbq (%rdi), %rdx ; trap: heap_oob
-;   pinsrb $1, %edx, %xmm0
+;   pinsrb $1, (%rdi), %xmm0 ; trap: heap_oob
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -118,8 +116,7 @@ block0(v0: i16x8, v1: i64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movzwq  0(%rdi), %rdx
-;   pinsrw  $1, %xmm0, %rdx, %xmm0
+;   pinsrw  $1, %xmm0, 0(%rdi), %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -129,8 +126,7 @@ block0(v0: i16x8, v1: i64):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movzwq (%rdi), %rdx ; trap: heap_oob
-;   pinsrw $1, %edx, %xmm0
+;   pinsrw $1, (%rdi), %xmm0 ; trap: heap_oob
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
diff --git a/cranelift/filetests/filetests/isa/x64/ishl.clif b/cranelift/filetests/filetests/isa/x64/ishl.clif
index 743ea813cc49..32ab2f796270 100644
--- a/cranelift/filetests/filetests/isa/x64/ishl.clif
+++ b/cranelift/filetests/filetests/isa/x64/ishl.clif
@@ -21,21 +21,19 @@ block0(v0: i128, v1: i8):
 ;   movzbq  %dl, %rcx
 ;   movq    %rdi, %rdx
 ;   shlq    %cl, %rdx, %rdx
-;   movq    %rsi, %r11
-;   shlq    %cl, %r11, %r11
+;   shlq    %cl, %rsi, %rsi
 ;   movq    %rcx, %r9
 ;   movl    $64, %ecx
 ;   movq    %r9, %r8
 ;   subq    %rcx, %r8, %rcx
-;   movq    %rdi, %r10
-;   shrq    %cl, %r10, %r10
+;   shrq    %cl, %rdi, %rdi
 ;   xorq    %rax, %rax, %rax
 ;   testq   $127, %r8
-;   cmovzq  %rax, %r10, %r10
-;   orq     %r10, %r11, %r10
+;   cmovzq  %rax, %rdi, %rdi
+;   orq     %rdi, %rsi, %rdi
 ;   testq   $64, %r8
 ;   cmovzq  %rdx, %rax, %rax
-;   cmovzq  %r10, %rdx, %rdx
+;   cmovzq  %rdi, %rdx, %rdx
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -48,21 +46,19 @@ block0(v0: i128, v1: i8):
 ;   movzbq %dl, %rcx
 ;   movq %rdi, %rdx
 ;   shlq %cl, %rdx
-;   movq %rsi, %r11
-;   shlq %cl, %r11
+;   shlq %cl, %rsi
 ;   movq %rcx, %r9
 ;   movl $0x40, %ecx
 ;   movq %r9, %r8
 ;   subq %r8, %rcx
-;   movq %rdi, %r10
-;   shrq %cl, %r10
+;   shrq %cl, %rdi
 ;   xorq %rax, %rax
 ;   testq $0x7f, %r8
-;   cmoveq %rax, %r10
-;   orq %r11, %r10
+;   cmoveq %rax, %rdi
+;   orq %rsi, %rdi
 ;   testq $0x40, %r8
 ;   cmoveq %rdx, %rax
-;   cmoveq %r10, %rdx
+;   cmoveq %rdi, %rdx
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -81,21 +77,19 @@ block0(v0: i128, v1: i64):
 ;   movq    %rdx, %r9
 ;   movq    %rdi, %rdx
 ;   shlq    %cl, %rdx, %rdx
-;   movq    %rsi, %r10
-;   shlq    %cl, %r10, %r10
+;   shlq    %cl, %rsi, %rsi
 ;   movq    %rcx, %r9
 ;   movl    $64, %ecx
-;   movq    %r9, %rsi
-;   subq    %rcx, %rsi, %rcx
-;   movq    %rdi, %r9
-;   shrq    %cl, %r9, %r9
+;   movq    %r9, %r8
+;   subq    %rcx, %r8, %rcx
+;   shrq    %cl, %rdi, %rdi
 ;   xorq    %rax, %rax, %rax
-;   testq   $127, %rsi
-;   cmovzq  %rax, %r9, %r9
-;   orq     %r9, %r10, %r9
-;   testq   $64, %rsi
+;   testq   $127, %r8
+;   cmovzq  %rax, %rdi, %rdi
+;   orq     %rdi, %rsi, %rdi
+;   testq   $64, %r8
 ;   cmovzq  %rdx, %rax, %rax
-;   cmovzq  %r9, %rdx, %rdx
+;   cmovzq  %rdi, %rdx, %rdx
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -109,21 +103,19 @@ block0(v0: i128, v1: i64):
 ;   movq %rdx, %r9
 ;   movq %rdi, %rdx
 ;   shlq %cl, %rdx
-;   movq %rsi, %r10
-;   shlq %cl, %r10
+;   shlq %cl, %rsi
 ;   movq %rcx, %r9
 ;   movl $0x40, %ecx
-;   movq %r9, %rsi
-;   subq %rsi, %rcx
-;   movq %rdi, %r9
-;   shrq %cl, %r9
+;   movq %r9, %r8
+;   subq %r8, %rcx
+;   shrq %cl, %rdi
 ;   xorq %rax, %rax
-;   testq $0x7f, %rsi
-;   cmoveq %rax, %r9
-;   orq %r10, %r9
-;   testq $0x40, %rsi
+;   testq $0x7f, %r8
+;   cmoveq %rax, %rdi
+;   orq %rsi, %rdi
+;   testq $0x40, %r8
 ;   cmoveq %rdx, %rax
-;   cmoveq %r9, %rdx
+;   cmoveq %rdi, %rdx
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -142,21 +134,19 @@ block0(v0: i128, v1: i32):
 ;   movq    %rdx, %r9
 ;   movq    %rdi, %rdx
 ;   shlq    %cl, %rdx, %rdx
-;   movq    %rsi, %r10
-;   shlq    %cl, %r10, %r10
+;   shlq    %cl, %rsi, %rsi
 ;   movq    %rcx, %r9
 ;   movl    $64, %ecx
-;   movq    %r9, %rsi
-;   subq    %rcx, %rsi, %rcx
-;   movq    %rdi, %r9
-;   shrq    %cl, %r9, %r9
+;   movq    %r9, %r8
+;   subq    %rcx, %r8, %rcx
+;   shrq    %cl, %rdi, %rdi
 ;   xorq    %rax, %rax, %rax
-;   testq   $127, %rsi
-;   cmovzq  %rax, %r9, %r9
-;   orq     %r9, %r10, %r9
-;   testq   $64, %rsi
+;   testq   $127, %r8
+;   cmovzq  %rax, %rdi, %rdi
+;   orq     %rdi, %rsi, %rdi
+;   testq   $64, %r8
 ;   cmovzq  %rdx, %rax, %rax
-;   cmovzq  %r9, %rdx, %rdx
+;   cmovzq  %rdi, %rdx, %rdx
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -170,21 +160,19 @@ block0(v0: i128, v1: i32):
 ;   movq %rdx, %r9
 ;   movq %rdi, %rdx
 ;   shlq %cl, %rdx
-;   movq %rsi, %r10
-;   shlq %cl, %r10
+;   shlq %cl, %rsi
 ;   movq %rcx, %r9
 ;   movl $0x40, %ecx
-;   movq %r9, %rsi
-;   subq %rsi, %rcx
-;   movq %rdi, %r9
-;   shrq %cl, %r9
+;   movq %r9, %r8
+;   subq %r8, %rcx
+;   shrq %cl, %rdi
 ;   xorq %rax, %rax
-;   testq $0x7f, %rsi
-;   cmoveq %rax, %r9
-;   orq %r10, %r9
-;   testq $0x40, %rsi
+;   testq $0x7f, %r8
+;   cmoveq %rax, %rdi
+;   orq %rsi, %rdi
+;   testq $0x40, %r8
 ;   cmoveq %rdx, %rax
-;   cmoveq %r9, %rdx
+;   cmoveq %rdi, %rdx
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -203,21 +191,19 @@ block0(v0: i128, v1: i16):
 ;   movq    %rdx, %r9
 ;   movq    %rdi, %rdx
 ;   shlq    %cl, %rdx, %rdx
-;   movq    %rsi, %r10
-;   shlq    %cl, %r10, %r10
+;   shlq    %cl, %rsi, %rsi
 ;   movq    %rcx, %r9
 ;   movl    $64, %ecx
-;   movq    %r9, %rsi
-;   subq    %rcx, %rsi, %rcx
-;   movq    %rdi, %r9
-;   shrq    %cl, %r9, %r9
+;   movq    %r9, %r8
+;   subq    %rcx, %r8, %rcx
+;   shrq    %cl, %rdi, %rdi
 ;   xorq    %rax, %rax, %rax
-;   testq   $127, %rsi
-;   cmovzq  %rax, %r9, %r9
-;   orq     %r9, %r10, %r9
-;   testq   $64, %rsi
+;   testq   $127, %r8
+;   cmovzq  %rax, %rdi, %rdi
+;   orq     %rdi, %rsi, %rdi
+;   testq   $64, %r8
 ;   cmovzq  %rdx, %rax, %rax
-;   cmovzq  %r9, %rdx, %rdx
+;   cmovzq  %rdi, %rdx, %rdx
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -231,21 +217,19 @@ block0(v0: i128, v1: i16):
 ;   movq %rdx, %r9
 ;   movq %rdi, %rdx
 ;   shlq %cl, %rdx
-;   movq %rsi, %r10
-;   shlq %cl, %r10
+;   shlq %cl, %rsi
 ;   movq %rcx, %r9
 ;   movl $0x40, %ecx
-;   movq %r9, %rsi
-;   subq %rsi, %rcx
-;   movq %rdi, %r9
-;   shrq %cl, %r9
+;   movq %r9, %r8
+;   subq %r8, %rcx
+;   shrq %cl, %rdi
 ;   xorq %rax, %rax
-;   testq $0x7f, %rsi
-;   cmoveq %rax, %r9
-;   orq %r10, %r9
-;   testq $0x40, %rsi
+;   testq $0x7f, %r8
+;   cmoveq %rax, %rdi
+;   orq %rsi, %rdi
+;   testq $0x40, %r8
 ;   cmoveq %rdx, %rax
-;   cmoveq %r9, %rdx
+;   cmoveq %rdi, %rdx
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -264,21 +248,19 @@ block0(v0: i128, v1: i8):
 ;   movq    %rdx, %r9
 ;   movq    %rdi, %rdx
 ;   shlq    %cl, %rdx, %rdx
-;   movq    %rsi, %r10
-;   shlq    %cl, %r10, %r10
+;   shlq    %cl, %rsi, %rsi
 ;   movq    %rcx, %r9
 ;   movl    $64, %ecx
-;   movq    %r9, %rsi
-;   subq    %rcx, %rsi, %rcx
-;   movq    %rdi, %r9
-;   shrq    %cl, %r9, %r9
+;   movq    %r9, %r8
+;   subq    %rcx, %r8, %rcx
+;   shrq    %cl, %rdi, %rdi
 ;   xorq    %rax, %rax, %rax
-;   testq   $127, %rsi
-;   cmovzq  %rax, %r9, %r9
-;   orq     %r9, %r10, %r9
-;   testq   $64, %rsi
+;   testq   $127, %r8
+;   cmovzq  %rax, %rdi, %rdi
+;   orq     %rdi, %rsi, %rdi
+;   testq   $64, %r8
 ;   cmovzq  %rdx, %rax, %rax
-;   cmovzq  %r9, %rdx, %rdx
+;   cmovzq  %rdi, %rdx, %rdx
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -292,21 +274,19 @@ block0(v0: i128, v1: i8):
 ;   movq %rdx, %r9
 ;   movq %rdi, %rdx
 ;   shlq %cl, %rdx
-;   movq %rsi, %r10
-;   shlq %cl, %r10
+;   shlq %cl, %rsi
 ;   movq %rcx, %r9
 ;   movl $0x40, %ecx
-;   movq %r9, %rsi
-;   subq %rsi, %rcx
-;   movq %rdi, %r9
-;   shrq %cl, %r9
+;   movq %r9, %r8
+;   subq %r8, %rcx
+;   shrq %cl, %rdi
 ;   xorq %rax, %rax
-;   testq $0x7f, %rsi
-;   cmoveq %rax, %r9
-;   orq %r10, %r9
-;   testq $0x40, %rsi
+;   testq $0x7f, %r8
+;   cmoveq %rax, %rdi
+;   orq %rsi, %rdi
+;   testq $0x40, %r8
 ;   cmoveq %rdx, %rax
-;   cmoveq %r9, %rdx
+;   cmoveq %rdi, %rdx
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
diff --git a/cranelift/filetests/filetests/isa/x64/issue-8659.clif b/cranelift/filetests/filetests/isa/x64/issue-8659.clif
new file mode 100644
index 000000000000..24ef5b56ce2d
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/issue-8659.clif
@@ -0,0 +1,27 @@
+test compile precise-output
+target x86_64
+
+function u0:11(i64 sret) system_v {
+block0(v0: i64):
+    return
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movq    %rdi, %rax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movq %rdi, %rax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/llvm-abi-no-split-stack-u128.clif b/cranelift/filetests/filetests/isa/x64/llvm-abi-no-split-stack-u128.clif
new file mode 100644
index 000000000000..0d164b666fb3
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/llvm-abi-no-split-stack-u128.clif
@@ -0,0 +1,30 @@
+test compile precise-output
+set enable_llvm_abi_extensions=1
+target x86_64
+
+function u0:0(i64, i128, i128, i128) -> i128 system_v {
+block0(v0: i64, v1: i128, v2: i128, v3: i128):
+    return v3
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movq    rbp(stack args max - 16), %rax
+;   movq    rbp(stack args max - 8), %rdx
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movq 0x10(%rbp), %rax
+;   movq 0x18(%rbp), %rdx
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/llvm-abi-option-u128.clif b/cranelift/filetests/filetests/isa/x64/llvm-abi-option-u128.clif
new file mode 100644
index 000000000000..c777f9848c4a
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/llvm-abi-option-u128.clif
@@ -0,0 +1,36 @@
+test compile precise-output
+set enable_llvm_abi_extensions=1
+target x86_64
+
+function u0:0(i64) -> i64, i128 system_v {
+block0(v0: i64):
+    v1 = iconst.i64 0x1000_0000_0000_0000
+    v2 = iconst.i64 0x2000_0000_0000_0000
+    v3 = iconcat v1, v2
+    v6 = iconst.i64 1
+    return v6, v3
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movabsq $1152921504606846976, %rdx
+;   movabsq $2305843009213693952, %rcx
+;   movl    $1, %eax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movabsq $0x1000000000000000, %rdx
+;   movabsq $0x2000000000000000, %rcx
+;   movl $1, %eax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/load-extends.clif b/cranelift/filetests/filetests/isa/x64/load-extends.clif
new file mode 100644
index 000000000000..34aa146ebf6d
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/load-extends.clif
@@ -0,0 +1,316 @@
+test compile precise-output
+set unwind_info=false
+target x86_64
+
+function %load_uextend_i8_i16(i64) -> i16 {
+block0(v0: i64):
+  v1 = load.i8 v0
+  v2 = uextend.i16 v1
+  return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movzbl  0(%rdi), %eax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movzbl (%rdi), %eax ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %load_uextend_i8_i32(i64) -> i32 {
+block0(v0: i64):
+  v1 = load.i8 v0
+  v2 = uextend.i32 v1
+  return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movzbl  0(%rdi), %eax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movzbl (%rdi), %eax ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %load_uextend_i8_i64(i64) -> i64 {
+block0(v0: i64):
+  v1 = load.i8 v0
+  v2 = uextend.i64 v1
+  return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movzbq  0(%rdi), %rax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movzbq (%rdi), %rax ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %load_uextend_i16_i32(i64) -> i32 {
+block0(v0: i64):
+  v1 = load.i16 v0
+  v2 = uextend.i32 v1
+  return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movzwl  0(%rdi), %eax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movzwl (%rdi), %eax ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %load_uextend_i16_i64(i64) -> i64 {
+block0(v0: i64):
+  v1 = load.i16 v0
+  v2 = uextend.i64 v1
+  return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movzwq  0(%rdi), %rax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movzwq (%rdi), %rax ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %load_uextend_i32_i64(i64) -> i64 {
+block0(v0: i64):
+  v1 = load.i32 v0
+  v2 = uextend.i64 v1
+  return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movl    0(%rdi), %eax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movl (%rdi), %eax ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %load_sextend_i8_i16(i64) -> i16 {
+block0(v0: i64):
+  v1 = load.i8 v0
+  v2 = sextend.i16 v1
+  return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movsbl  0(%rdi), %eax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movsbl (%rdi), %eax ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %load_sextend_i8_i32(i64) -> i32 {
+block0(v0: i64):
+  v1 = load.i8 v0
+  v2 = sextend.i32 v1
+  return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movsbl  0(%rdi), %eax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movsbl (%rdi), %eax ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %load_sextend_i8_i64(i64) -> i64 {
+block0(v0: i64):
+  v1 = load.i8 v0
+  v2 = sextend.i64 v1
+  return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movsbq  0(%rdi), %rax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movsbq (%rdi), %rax ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %load_sextend_i16_i32(i64) -> i32 {
+block0(v0: i64):
+  v1 = load.i16 v0
+  v2 = sextend.i32 v1
+  return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movswl  0(%rdi), %eax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movswl (%rdi), %eax ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %load_sextend_i16_i64(i64) -> i64 {
+block0(v0: i64):
+  v1 = load.i16 v0
+  v2 = sextend.i64 v1
+  return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movswq  0(%rdi), %rax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movswq (%rdi), %rax ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %load_sextend_i32_i64(i64) -> i64 {
+block0(v0: i64):
+  v1 = load.i32 v0
+  v2 = sextend.i64 v1
+  return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movslq  0(%rdi), %rax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movslq (%rdi), %rax ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/load-f16-f128.clif b/cranelift/filetests/filetests/isa/x64/load-f16-f128.clif
new file mode 100644
index 000000000000..8bd94ae70709
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/load-f16-f128.clif
@@ -0,0 +1,54 @@
+test compile precise-output
+target x86_64
+
+function %load_f16(i64) -> f16 {
+block0(v0: i64):
+    v1 = load.f16 v0
+    return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   uninit  %xmm0
+;   pinsrw  $0, %xmm0, 0(%rdi), %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   pinsrw $0, (%rdi), %xmm0 ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %load_f128(i64) -> f128 {
+block0(v0: i64):
+    v1 = load.f128 v0
+    return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movdqu  0(%rdi), %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movdqu (%rdi), %xmm0 ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/mul.clif b/cranelift/filetests/filetests/isa/x64/mul.clif
new file mode 100644
index 000000000000..f12a73f05919
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/mul.clif
@@ -0,0 +1,489 @@
+test compile precise-output
+set unwind_info=false
+target x86_64
+
+function %imul_i8(i8, i8) -> i8{
+block0(v0: i8, v1: i8):
+    v2 = imul v0, v1
+    return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movq    %rdi, %rax
+;   mulb    %al, %sil, %al
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movq %rdi, %rax
+;   mulb %sil
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %imul_i16(i16, i16) -> i16{
+block0(v0: i16, v1: i16):
+    v2 = imul v0, v1
+    return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movq    %rdi, %rax
+;   imulw   %ax, %si, %ax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movq %rdi, %rax
+;   imull %esi, %eax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %imul_i32(i32, i32) -> i32{
+block0(v0: i32, v1: i32):
+    v2 = imul v0, v1
+    return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movq    %rdi, %rax
+;   imull   %eax, %esi, %eax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movq %rdi, %rax
+;   imull %esi, %eax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %imul_i64(i64, i64) -> i64{
+block0(v0: i64, v1: i64):
+    v2 = imul v0, v1
+    return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movq    %rdi, %rax
+;   imulq   %rax, %rsi, %rax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movq %rdi, %rax
+;   imulq %rsi, %rax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %imul_i8_three(i8, i8, i8) -> i8{
+block0(v0: i8, v1: i8, v2: i8):
+    v3 = imul v0, v1
+    v4 = imul v3, v2
+    return v4
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movq    %rdi, %rax
+;   mulb    %al, %sil, %al
+;   mulb    %al, %dl, %al
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movq %rdi, %rax
+;   mulb %sil
+;   mulb %dl
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %imul_i32_three(i32, i32, i32) -> i32{
+block0(v0: i32, v1: i32, v2: i32):
+    v3 = imul v0, v1
+    v4 = imul v3, v2
+    return v4
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   imull   %edi, %esi, %edi
+;   movq    %rdi, %rax
+;   imull   %eax, %edx, %eax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   imull %esi, %edi
+;   movq %rdi, %rax
+;   imull %edx, %eax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %imul_i32_load(i32, i64) -> i32 {
+block0(v0: i32, v1: i64):
+    v2 = load.i32 notrap v1
+    v3 = imul v0, v2
+    return v3
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movq    %rdi, %rax
+;   imull   %eax, 0(%rsi), %eax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movq %rdi, %rax
+;   imull (%rsi), %eax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %imul_i64_load(i64, i64) -> i64 {
+block0(v0: i64, v1: i64):
+    v2 = load.i64 notrap v1
+    v3 = imul v0, v2
+    return v3
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movq    %rdi, %rax
+;   imulq   %rax, 0(%rsi), %rax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movq %rdi, %rax
+;   imulq (%rsi), %rax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %imul_i8_const(i8) -> i8{
+block0(v0: i8):
+    v3 = imul_imm v0, 97
+    return v3
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movq    %rdi, %rax
+;   mulb    %al, const(0), %al
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movq %rdi, %rax
+;   mulb 0xb(%rip)
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+
+function %imul_i16_const(i16) -> i16{
+block0(v0: i16):
+    v3 = imul_imm v0, 97
+    return v3
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   imulw   %di, 0x61, %ax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   imulw $0x61, %di, %ax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %imul_i32_const(i32) -> i32{
+block0(v0: i32):
+    v3 = imul_imm v0, 97
+    return v3
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   imull   %edi, 0x61, %eax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   imull $0x61, %edi, %eax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %imul_i64_const(i64) -> i64{
+block0(v0: i64):
+    v3 = imul_imm v0, 97
+    return v3
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   imulq   %rdi, 0x61, %rax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   imulq $0x61, %rdi, %rax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+
+function %imul_i16_bigger_const(i16) -> i16{
+block0(v0: i16):
+    v3 = imul_imm v0, 1021
+    return v3
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   imulw   %di, 0x3fd, %ax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   imulw $0x3fd, %di, %ax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %imul_i32_bigger_const(i32) -> i32{
+block0(v0: i32):
+    v3 = imul_imm v0, 1021
+    return v3
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   imull   %edi, 0x3fd, %eax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   imull $0x3fd, %edi, %eax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %imul_i64_bigger_const(i64) -> i64{
+block0(v0: i64):
+    v3 = imul_imm v0, 1021
+    return v3
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   imulq   %rdi, 0x3fd, %rax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   imulq $0x3fd, %rdi, %rax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %imul_i16_const_and_load(i64) -> i16{
+block0(v0: i64):
+    v1 = load.i16 v0
+    v2 = imul_imm v1, 1021
+    return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movzwq  0(%rdi), %rcx
+;   imulw   %cx, 0x3fd, %ax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movzwq (%rdi), %rcx ; trap: heap_oob
+;   imulw $0x3fd, %cx, %ax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %imul_i32_const_and_load(i64) -> i32{
+block0(v0: i64):
+    v1 = load.i32 v0
+    v2 = imul_imm v1, 1021
+    return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   imull   0(%rdi), 0x3fd, %eax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   imull $0x3fd, (%rdi), %eax ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %imul_i64_const_and_load(i64) -> i64{
+block0(v0: i64):
+    v1 = load.i64 v0+100
+    v2 = imul_imm v1, 1021
+    return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   imulq   100(%rdi), 0x3fd, %rax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   imulq $0x3fd, 0x64(%rdi), %rax ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/nan-canonicalization-sse41.clif b/cranelift/filetests/filetests/isa/x64/nan-canonicalization-sse41.clif
new file mode 100644
index 000000000000..b29003307fe3
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/nan-canonicalization-sse41.clif
@@ -0,0 +1,140 @@
+test compile precise-output
+set enable_nan_canonicalization=true
+target x86_64 sse41
+
+function %f0(f32x4, f32x4) -> f32x4 {
+block0(v0: f32x4, v1: f32x4):
+	v2 = fadd v0, v1
+	return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   addps   %xmm0, %xmm1, %xmm0
+;   movl    $2143289344, %r10d
+;   movd    %r10d, %xmm7
+;   shufps  $0, %xmm7, const(0), %xmm7
+;   movdqa  %xmm0, %xmm1
+;   cmpps   $3, %xmm1, %xmm0, %xmm1
+;   movdqa  %xmm0, %xmm2
+;   movdqa  %xmm1, %xmm0
+;   movdqa  %xmm2, %xmm1
+;   pblendvb %xmm1, %xmm7, %xmm1
+;   movdqa  %xmm1, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   addps %xmm1, %xmm0
+;   movl $0x7fc00000, %r10d
+;   movd %r10d, %xmm7
+;   shufps $0, 0x26(%rip), %xmm7
+;   movdqa %xmm0, %xmm1
+;   cmpunordps %xmm0, %xmm1
+;   movdqa %xmm0, %xmm2
+;   movdqa %xmm1, %xmm0
+;   movdqa %xmm2, %xmm1
+;   pblendvb %xmm0, %xmm7, %xmm1
+;   movdqa %xmm1, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   sarb $0, (%rdi)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+
+function %f1(f64, f64) -> f64 {
+block0(v0: f64, v1: f64):
+	v2 = fadd v0, v1
+	return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   addsd   %xmm0, %xmm1, %xmm0
+;   movabsq $9221120237041090560, %r9
+;   movq    %r9, %xmm1
+;   movdqa  %xmm0, %xmm7
+;   cmppd   $3, %xmm7, %xmm0, %xmm7
+;   movdqa  %xmm0, %xmm5
+;   movdqa  %xmm7, %xmm0
+;   pblendvb %xmm5, %xmm1, %xmm5
+;   movdqa  %xmm5, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   addsd %xmm1, %xmm0
+;   movabsq $0x7ff8000000000000, %r9
+;   movq %r9, %xmm1
+;   movdqa %xmm0, %xmm7
+;   cmpunordpd %xmm0, %xmm7
+;   movdqa %xmm0, %xmm5
+;   movdqa %xmm7, %xmm0
+;   pblendvb %xmm0, %xmm1, %xmm5
+;   movdqa %xmm5, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %f1(f32, f32) -> f32 {
+block0(v0: f32, v1: f32):
+	v2 = fadd v0, v1
+	return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   addss   %xmm0, %xmm1, %xmm0
+;   movl    $2143289344, %r9d
+;   movd    %r9d, %xmm1
+;   movdqa  %xmm0, %xmm7
+;   cmpps   $3, %xmm7, %xmm0, %xmm7
+;   movdqa  %xmm0, %xmm5
+;   movdqa  %xmm7, %xmm0
+;   pblendvb %xmm5, %xmm1, %xmm5
+;   movdqa  %xmm5, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   addss %xmm1, %xmm0
+;   movl $0x7fc00000, %r9d
+;   movd %r9d, %xmm1
+;   movdqa %xmm0, %xmm7
+;   cmpunordps %xmm0, %xmm7
+;   movdqa %xmm0, %xmm5
+;   movdqa %xmm7, %xmm0
+;   pblendvb %xmm0, %xmm1, %xmm5
+;   movdqa %xmm5, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/nan-canonicalization.clif b/cranelift/filetests/filetests/isa/x64/nan-canonicalization.clif
new file mode 100644
index 000000000000..7454b82fa04d
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/nan-canonicalization.clif
@@ -0,0 +1,131 @@
+test compile precise-output
+set enable_nan_canonicalization=true 
+target x86_64
+
+function %f0(f32x4, f32x4) -> f32x4 {
+block0(v0: f32x4, v1: f32x4):
+	v2 = fadd v0, v1
+	return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   addps   %xmm0, %xmm1, %xmm0
+;   movdqa  %xmm0, %xmm1
+;   movl    $2143289344, %esi
+;   movd    %esi, %xmm5
+;   shufps  $0, %xmm5, const(0), %xmm5
+;   cmpps   $3, %xmm0, %xmm1, %xmm0
+;   andps   %xmm5, %xmm0, %xmm5
+;   andnps  %xmm0, %xmm1, %xmm0
+;   orps    %xmm0, %xmm5, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   addps %xmm1, %xmm0
+;   movdqa %xmm0, %xmm1
+;   movl $0x7fc00000, %esi
+;   movd %esi, %xmm5
+;   shufps $0, 0x14(%rip), %xmm5
+;   cmpunordps %xmm1, %xmm0
+;   andps %xmm0, %xmm5
+;   andnps %xmm1, %xmm0
+;   orps %xmm5, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   sarb $0, (%rdi)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+
+function %f1(f64, f64) -> f64 {
+block0(v0: f64, v1: f64):
+	v2 = fadd v0, v1
+	return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   addsd   %xmm0, %xmm1, %xmm0
+;   movdqa  %xmm0, %xmm7
+;   movabsq $9221120237041090560, %r11
+;   movq    %r11, %xmm5
+;   cmppd   $3, %xmm0, %xmm7, %xmm0
+;   andpd   %xmm5, %xmm0, %xmm5
+;   andnpd  %xmm0, %xmm7, %xmm0
+;   orpd    %xmm0, %xmm5, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   addsd %xmm1, %xmm0
+;   movdqa %xmm0, %xmm7
+;   movabsq $0x7ff8000000000000, %r11
+;   movq %r11, %xmm5
+;   cmpunordpd %xmm7, %xmm0
+;   andpd %xmm0, %xmm5
+;   andnpd %xmm7, %xmm0
+;   orpd %xmm5, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %f1(f32, f32) -> f32 {
+block0(v0: f32, v1: f32):
+	v2 = fadd v0, v1
+	return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   addss   %xmm0, %xmm1, %xmm0
+;   movdqa  %xmm0, %xmm7
+;   movl    $2143289344, %r11d
+;   movd    %r11d, %xmm5
+;   cmpps   $3, %xmm0, %xmm7, %xmm0
+;   andps   %xmm5, %xmm0, %xmm5
+;   andnps  %xmm0, %xmm7, %xmm0
+;   orps    %xmm0, %xmm5, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   addss %xmm1, %xmm0
+;   movdqa %xmm0, %xmm7
+;   movl $0x7fc00000, %r11d
+;   movd %r11d, %xmm5
+;   cmpunordps %xmm7, %xmm0
+;   andps %xmm0, %xmm5
+;   andnps %xmm7, %xmm0
+;   orps %xmm5, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/narrowing.clif b/cranelift/filetests/filetests/isa/x64/narrowing.clif
index 44dc282d7006..d46d1c9980da 100644
--- a/cranelift/filetests/filetests/isa/x64/narrowing.clif
+++ b/cranelift/filetests/filetests/isa/x64/narrowing.clif
@@ -66,9 +66,8 @@ block0(v0: f64x2):
 ;   movdqa  %xmm0, %xmm3
 ;   cmppd   $0, %xmm3, %xmm0, %xmm3
 ;   andps   %xmm3, const(0), %xmm3
-;   movdqa  %xmm0, %xmm6
-;   minpd   %xmm6, %xmm3, %xmm6
-;   cvttpd2dq %xmm6, %xmm0
+;   minpd   %xmm0, %xmm3, %xmm0
+;   cvttpd2dq %xmm0, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -81,9 +80,8 @@ block0(v0: f64x2):
 ;   movdqa %xmm0, %xmm3
 ;   cmpeqpd %xmm0, %xmm3
 ;   andps 0x1c(%rip), %xmm3
-;   movdqa %xmm0, %xmm6
-;   minpd %xmm3, %xmm6
-;   cvttpd2dq %xmm6, %xmm0
+;   minpd %xmm3, %xmm0
+;   cvttpd2dq %xmm0, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -93,6 +91,8 @@ block0(v0: f64x2):
 ;   addb %al, (%rax)
 ;   addb %al, (%rax)
 ;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
 ;   addb %al, %al
 
 function %f4(i16x8, i16x8) -> i8x16 {
diff --git a/cranelift/filetests/filetests/isa/x64/popcnt.clif b/cranelift/filetests/filetests/isa/x64/popcnt.clif
index 41ecc069c2a4..b74ba4b41622 100644
--- a/cranelift/filetests/filetests/isa/x64/popcnt.clif
+++ b/cranelift/filetests/filetests/isa/x64/popcnt.clif
@@ -11,21 +11,20 @@ block0(v0: i64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rdi, %rcx
-;   shrq    $1, %rdi, %rdi
-;   movq    %rcx, %r8
+;   movq    %rdi, %rax
+;   shrq    $1, %rax, %rax
 ;   movabsq $8608480567731124087, %rdx
-;   andq    %rdi, %rdx, %rdi
-;   subq    %r8, %rdi, %r8
-;   shrq    $1, %rdi, %rdi
-;   andq    %rdi, %rdx, %rdi
-;   subq    %r8, %rdi, %r8
-;   shrq    $1, %rdi, %rdi
-;   andq    %rdi, %rdx, %rdi
-;   subq    %r8, %rdi, %r8
-;   movq    %r8, %rax
+;   andq    %rax, %rdx, %rax
+;   subq    %rdi, %rax, %rdi
+;   shrq    $1, %rax, %rax
+;   andq    %rax, %rdx, %rax
+;   subq    %rdi, %rax, %rdi
+;   shrq    $1, %rax, %rax
+;   andq    %rax, %rdx, %rax
+;   subq    %rdi, %rax, %rdi
+;   movq    %rdi, %rax
 ;   shrq    $4, %rax, %rax
-;   addq    %rax, %r8, %rax
+;   addq    %rax, %rdi, %rax
 ;   movabsq $1085102592571150095, %r11
 ;   andq    %rax, %r11, %rax
 ;   movabsq $72340172838076673, %rcx
@@ -40,21 +39,20 @@ block0(v0: i64):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rdi, %rcx
-;   shrq $1, %rdi
-;   movq %rcx, %r8
+;   movq %rdi, %rax
+;   shrq $1, %rax
 ;   movabsq $0x7777777777777777, %rdx
-;   andq %rdx, %rdi
-;   subq %rdi, %r8
-;   shrq $1, %rdi
-;   andq %rdx, %rdi
-;   subq %rdi, %r8
-;   shrq $1, %rdi
-;   andq %rdx, %rdi
-;   subq %rdi, %r8
-;   movq %r8, %rax
+;   andq %rdx, %rax
+;   subq %rax, %rdi
+;   shrq $1, %rax
+;   andq %rdx, %rax
+;   subq %rax, %rdi
+;   shrq $1, %rax
+;   andq %rdx, %rax
+;   subq %rax, %rdi
+;   movq %rdi, %rax
 ;   shrq $4, %rax
-;   addq %r8, %rax
+;   addq %rdi, %rax
 ;   movabsq $0xf0f0f0f0f0f0f0f, %r11
 ;   andq %r11, %rax
 ;   movabsq $0x101010101010101, %rcx
@@ -139,22 +137,21 @@ block0(v0: i32):
 ;   movq    %rsp, %rbp
 ; block0:
 ;   movq    %rdi, %rax
-;   shrl    $1, %edi, %edi
+;   shrl    $1, %eax, %eax
 ;   movl    $2004318071, %edx
-;   andl    %edi, %edx, %edi
-;   movq    %rax, %r8
-;   subl    %r8d, %edi, %r8d
-;   shrl    $1, %edi, %edi
-;   andl    %edi, %edx, %edi
-;   subl    %r8d, %edi, %r8d
-;   shrl    $1, %edi, %edi
-;   andl    %edi, %edx, %edi
-;   subl    %r8d, %edi, %r8d
-;   movq    %r8, %rax
-;   shrl    $4, %eax, %eax
-;   addl    %eax, %r8d, %eax
-;   andl    %eax, $252645135, %eax
-;   imull   %eax, $16843009, %eax
+;   andl    %eax, %edx, %eax
+;   subl    %edi, %eax, %edi
+;   shrl    $1, %eax, %eax
+;   andl    %eax, %edx, %eax
+;   subl    %edi, %eax, %edi
+;   shrl    $1, %eax, %eax
+;   andl    %eax, %edx, %eax
+;   subl    %edi, %eax, %edi
+;   movq    %rdi, %r9
+;   shrl    $4, %r9d, %r9d
+;   addl    %r9d, %edi, %r9d
+;   andl    %r9d, $252645135, %r9d
+;   imull   %r9d, 0x1010101, %eax
 ;   shrl    $24, %eax, %eax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -166,22 +163,21 @@ block0(v0: i32):
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
 ;   movq %rdi, %rax
-;   shrl $1, %edi
+;   shrl $1, %eax
 ;   movl $0x77777777, %edx
-;   andl %edx, %edi
-;   movq %rax, %r8
-;   subl %edi, %r8d
-;   shrl $1, %edi
-;   andl %edx, %edi
-;   subl %edi, %r8d
-;   shrl $1, %edi
-;   andl %edx, %edi
-;   subl %edi, %r8d
-;   movq %r8, %rax
-;   shrl $4, %eax
-;   addl %r8d, %eax
-;   andl $0xf0f0f0f, %eax
-;   imull $0x1010101, %eax, %eax
+;   andl %edx, %eax
+;   subl %eax, %edi
+;   shrl $1, %eax
+;   andl %edx, %eax
+;   subl %eax, %edi
+;   shrl $1, %eax
+;   andl %edx, %eax
+;   subl %eax, %edi
+;   movq %rdi, %r9
+;   shrl $4, %r9d
+;   addl %edi, %r9d
+;   andl $0xf0f0f0f, %r9d
+;   imull $0x1010101, %r9d, %eax
 ;   shrl $0x18, %eax
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -198,23 +194,23 @@ block0(v0: i64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movl    0(%rdi), %edx
-;   movq    %rdx, %rcx
+;   movl    0(%rdi), %eax
+;   movq    %rax, %rcx
 ;   shrl    $1, %ecx, %ecx
 ;   movl    $2004318071, %r8d
 ;   andl    %ecx, %r8d, %ecx
-;   subl    %edx, %ecx, %edx
+;   subl    %eax, %ecx, %eax
 ;   shrl    $1, %ecx, %ecx
 ;   andl    %ecx, %r8d, %ecx
-;   subl    %edx, %ecx, %edx
+;   subl    %eax, %ecx, %eax
 ;   shrl    $1, %ecx, %ecx
 ;   andl    %ecx, %r8d, %ecx
-;   subl    %edx, %ecx, %edx
-;   movq    %rdx, %rax
-;   shrl    $4, %eax, %eax
-;   addl    %eax, %edx, %eax
-;   andl    %eax, $252645135, %eax
-;   imull   %eax, $16843009, %eax
+;   subl    %eax, %ecx, %eax
+;   movq    %rax, %r10
+;   shrl    $4, %r10d, %r10d
+;   addl    %r10d, %eax, %r10d
+;   andl    %r10d, $252645135, %r10d
+;   imull   %r10d, 0x1010101, %eax
 ;   shrl    $24, %eax, %eax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -225,23 +221,23 @@ block0(v0: i64):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movl (%rdi), %edx ; trap: heap_oob
-;   movq %rdx, %rcx
+;   movl (%rdi), %eax ; trap: heap_oob
+;   movq %rax, %rcx
 ;   shrl $1, %ecx
 ;   movl $0x77777777, %r8d
 ;   andl %r8d, %ecx
-;   subl %ecx, %edx
+;   subl %ecx, %eax
 ;   shrl $1, %ecx
 ;   andl %r8d, %ecx
-;   subl %ecx, %edx
+;   subl %ecx, %eax
 ;   shrl $1, %ecx
 ;   andl %r8d, %ecx
-;   subl %ecx, %edx
-;   movq %rdx, %rax
-;   shrl $4, %eax
-;   addl %edx, %eax
-;   andl $0xf0f0f0f, %eax
-;   imull $0x1010101, %eax, %eax
+;   subl %ecx, %eax
+;   movq %rax, %r10
+;   shrl $4, %r10d
+;   addl %eax, %r10d
+;   andl $0xf0f0f0f, %r10d
+;   imull $0x1010101, %r10d, %eax
 ;   shrl $0x18, %eax
 ;   movq %rbp, %rsp
 ;   popq %rbp
diff --git a/cranelift/filetests/filetests/isa/x64/return-call-indirect.clif b/cranelift/filetests/filetests/isa/x64/return-call-indirect.clif
index aaed4234279d..d8889e147673 100644
--- a/cranelift/filetests/filetests/isa/x64/return-call-indirect.clif
+++ b/cranelift/filetests/filetests/isa/x64/return-call-indirect.clif
@@ -14,7 +14,7 @@ block0(v0: i64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   lea     10(%rax), %rax
+;   lea     10(%rdi), %rax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -24,7 +24,7 @@ block0(v0: i64):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   addq $0xa, %rax
+;   leaq 0xa(%rdi), %rax
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -42,20 +42,18 @@ block0(v0: i64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   load_ext_name %callee_i64+0, %rdx
-;   movq    %rbp, %rcx
-;   return_call_unknown %rdx new_stack_arg_size:0 old_stack_arg_size:0 ret_addr:None fp:%v194 tmp:%v195 %rax=%rax
+;   load_ext_name %callee_i64+0, %r10
+;   return_call_unknown %r10 (0) tmp=%r11 %rdi=%rdi
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movabsq $0, %rdx ; reloc_external Abs8 %callee_i64 0
-;   movq %rbp, %rcx
-;   movq (%rcx), %rbp
-;   leaq 8(%rcx), %rsp
-;   jmpq *%rdx
+;   movabsq $0, %r10 ; reloc_external Abs8 %callee_i64 0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   jmpq *%r10
 
 ;;;; Test colocated tail calls ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
@@ -72,20 +70,18 @@ block0(v0: i64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   load_ext_name %callee_i64+0, %rdx
-;   movq    %rbp, %rcx
-;   return_call_unknown %rdx new_stack_arg_size:0 old_stack_arg_size:0 ret_addr:None fp:%v194 tmp:%v195 %rax=%rax
+;   load_ext_name %callee_i64+0, %r10
+;   return_call_unknown %r10 (0) tmp=%r11 %rdi=%rdi
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   leaq (%rip), %rdx ; reloc_external CallPCRel4 %callee_i64 -4
-;   movq %rbp, %rcx
-;   movq (%rcx), %rbp
-;   leaq 8(%rcx), %rsp
-;   jmpq *%rdx
+;   leaq (%rip), %r10 ; reloc_external CallPCRel4 %callee_i64 -4
+;   movq %rbp, %rsp
+;   popq %rbp
+;   jmpq *%r10
 
 ;;;; Test passing `f64`s ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
@@ -143,20 +139,18 @@ block0(v0: f64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   load_ext_name %callee_f64+0, %rdx
-;   movq    %rbp, %rcx
-;   return_call_unknown %rdx new_stack_arg_size:0 old_stack_arg_size:0 ret_addr:None fp:%v194 tmp:%v195 %xmm0=%xmm0
+;   load_ext_name %callee_f64+0, %r10
+;   return_call_unknown %r10 (0) tmp=%r11 %xmm0=%xmm0
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movabsq $0, %rdx ; reloc_external Abs8 %callee_f64 0
-;   movq %rbp, %rcx
-;   movq (%rcx), %rbp
-;   leaq 8(%rcx), %rsp
-;   jmpq *%rdx
+;   movabsq $0, %r10 ; reloc_external Abs8 %callee_f64 0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   jmpq *%r10
 
 ;;;; Test passing `i8`s ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
@@ -171,7 +165,7 @@ block0(v0: i8):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   testb   %al, %al
+;   testb   %dil, %dil
 ;   setz    %al
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -182,7 +176,7 @@ block0(v0: i8):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   testb %al, %al
+;   testb %dil, %dil
 ;   sete %al
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -201,18 +195,247 @@ block0(v0: i8):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   load_ext_name %callee_i8+0, %rdx
-;   movq    %rbp, %rcx
-;   return_call_unknown %rdx new_stack_arg_size:0 old_stack_arg_size:0 ret_addr:None fp:%v194 tmp:%v195 %rax=%rax
+;   load_ext_name %callee_i8+0, %r10
+;   return_call_unknown %r10 (0) tmp=%r11 %rdi=%rdi
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movabsq $0, %rdx ; reloc_external Abs8 %callee_i8 0
-;   movq %rbp, %rcx
-;   movq (%rcx), %rbp
-;   leaq 8(%rcx), %rsp
-;   jmpq *%rdx
+;   movabsq $0, %r10 ; reloc_external Abs8 %callee_i8 0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   jmpq *%r10
+
+;;;; Test passing many arguments on stack ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+function %tail_caller_stack_args() -> i64 tail {
+    fn0 = %tail_callee_stack_args(i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64) -> i64 tail
+
+block0:
+    v0 = iconst.i64 10
+    v1 = iconst.i64 15
+    v2 = iconst.i64 20
+    v3 = iconst.i64 25
+    v4 = iconst.i64 30
+    v5 = iconst.i64 35
+    v6 = iconst.i64 40
+    v7 = iconst.i64 45
+    v8 = iconst.i64 50
+    v9 = iconst.i64 55
+    v10 = iconst.i64 60
+    v11 = iconst.i64 65
+    v12 = iconst.i64 70
+    v13 = iconst.i64 75
+    v14 = iconst.i64 80
+    v15 = iconst.i64 85
+    v16 = iconst.i64 90
+    v17 = iconst.i64 95
+    v18 = iconst.i64 100
+    v19 = iconst.i64 105
+    v20 = iconst.i64 110
+    v21 = iconst.i64 115
+    v22 = iconst.i64 120
+    v23 = iconst.i64 125
+    v24 = iconst.i64 130
+    v25 = iconst.i64 135
+    v26 = func_addr.i64 fn0
+    return_call_indirect sig0, v26(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25)
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+;   subq    %rsp, $160, %rsp
+;   movq    %rsp, %rbp
+;   movq    160(%rsp), %r11
+;   movq    %r11, 0(%rsp)
+;   movq    168(%rsp), %r11
+;   movq    %r11, 8(%rsp)
+;   subq    %rsp, $160, %rsp
+;   movq    %rbx, 112(%rsp)
+;   movq    %r12, 120(%rsp)
+;   movq    %r13, 128(%rsp)
+;   movq    %r14, 136(%rsp)
+;   movq    %r15, 144(%rsp)
+; block0:
+;   movl    $10, %esi
+;   movq    %rsi, rsp(104 + virtual offset)
+;   movl    $15, %edx
+;   movq    %rdx, rsp(96 + virtual offset)
+;   movl    $20, %ecx
+;   movq    %rcx, rsp(88 + virtual offset)
+;   movl    $25, %r8d
+;   movq    %r8, rsp(80 + virtual offset)
+;   movl    $30, %r9d
+;   movq    %r9, rsp(72 + virtual offset)
+;   movl    $35, %r9d
+;   movq    %r9, rsp(64 + virtual offset)
+;   movl    $40, %eax
+;   movl    $45, %r10d
+;   movl    $50, %r11d
+;   movl    $55, %r13d
+;   movl    $60, %r14d
+;   movl    $65, %r15d
+;   movl    $70, %ebx
+;   movl    $75, %r12d
+;   movl    $80, %edi
+;   movl    $85, %esi
+;   movq    %rsi, rsp(56 + virtual offset)
+;   movl    $90, %edx
+;   movl    $95, %ecx
+;   movl    $100, %r8d
+;   movl    $105, %r9d
+;   movl    $110, %esi
+;   movq    %rsi, rsp(48 + virtual offset)
+;   movl    $115, %esi
+;   movq    %rsi, rsp(40 + virtual offset)
+;   movl    $120, %esi
+;   movq    %rsi, rsp(32 + virtual offset)
+;   movl    $125, %esi
+;   movq    %rsi, rsp(24 + virtual offset)
+;   movl    $130, %esi
+;   movq    %rsi, rsp(16 + virtual offset)
+;   movl    $135, %esi
+;   movq    %rsi, rsp(8 + virtual offset)
+;   load_ext_name %tail_callee_stack_args+0, %rsi
+;   movq    %rsi, rsp(0 + virtual offset)
+;   movq    %rax, rbp(stack args max - 160)
+;   movq    %r10, rbp(stack args max - 152)
+;   movq    %r11, rbp(stack args max - 144)
+;   movq    %r13, rbp(stack args max - 136)
+;   movq    %r14, rbp(stack args max - 128)
+;   movq    %r15, rbp(stack args max - 120)
+;   movq    %rbx, rbp(stack args max - 112)
+;   movq    %r12, rbp(stack args max - 104)
+;   movq    %rdi, rbp(stack args max - 96)
+;   movq    rsp(56 + virtual offset), %rdi
+;   movq    %rdi, rbp(stack args max - 88)
+;   movq    %rdx, rbp(stack args max - 80)
+;   movq    %rcx, rbp(stack args max - 72)
+;   movq    %r8, rbp(stack args max - 64)
+;   movq    %r9, rbp(stack args max - 56)
+;   movq    rsp(48 + virtual offset), %rsi
+;   movq    %rsi, rbp(stack args max - 48)
+;   movq    rsp(40 + virtual offset), %rsi
+;   movq    %rsi, rbp(stack args max - 40)
+;   movq    rsp(32 + virtual offset), %rsi
+;   movq    %rsi, rbp(stack args max - 32)
+;   movq    rsp(24 + virtual offset), %rsi
+;   movq    %rsi, rbp(stack args max - 24)
+;   movq    rsp(16 + virtual offset), %rsi
+;   movq    %rsi, rbp(stack args max - 16)
+;   movq    rsp(8 + virtual offset), %rsi
+;   movq    %rsi, rbp(stack args max - 8)
+;   movq    rsp(80 + virtual offset), %rcx
+;   movq    rsp(88 + virtual offset), %rdx
+;   movq    rsp(96 + virtual offset), %rsi
+;   movq    rsp(104 + virtual offset), %rdi
+;   movq    rsp(72 + virtual offset), %r8
+;   movq    rsp(64 + virtual offset), %r9
+;   movq    rsp(0 + virtual offset), %r10
+;   return_call_unknown %r10 (160) tmp=%r11 %rdi=%rdi %rsi=%rsi %rdx=%rdx %rcx=%rcx %r8=%r8 %r9=%r9
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+;   subq $0xa0, %rsp
+;   movq %rsp, %rbp
+;   movq 0xa0(%rsp), %r11
+;   movq %r11, (%rsp)
+;   movq 0xa8(%rsp), %r11
+;   movq %r11, 8(%rsp)
+;   subq $0xa0, %rsp
+;   movq %rbx, 0x70(%rsp)
+;   movq %r12, 0x78(%rsp)
+;   movq %r13, 0x80(%rsp)
+;   movq %r14, 0x88(%rsp)
+;   movq %r15, 0x90(%rsp)
+; block1: ; offset 0x50
+;   movl $0xa, %esi
+;   movq %rsi, 0x68(%rsp)
+;   movl $0xf, %edx
+;   movq %rdx, 0x60(%rsp)
+;   movl $0x14, %ecx
+;   movq %rcx, 0x58(%rsp)
+;   movl $0x19, %r8d
+;   movq %r8, 0x50(%rsp)
+;   movl $0x1e, %r9d
+;   movq %r9, 0x48(%rsp)
+;   movl $0x23, %r9d
+;   movq %r9, 0x40(%rsp)
+;   movl $0x28, %eax
+;   movl $0x2d, %r10d
+;   movl $0x32, %r11d
+;   movl $0x37, %r13d
+;   movl $0x3c, %r14d
+;   movl $0x41, %r15d
+;   movl $0x46, %ebx
+;   movl $0x4b, %r12d
+;   movl $0x50, %edi
+;   movl $0x55, %esi
+;   movq %rsi, 0x38(%rsp)
+;   movl $0x5a, %edx
+;   movl $0x5f, %ecx
+;   movl $0x64, %r8d
+;   movl $0x69, %r9d
+;   movl $0x6e, %esi
+;   movq %rsi, 0x30(%rsp)
+;   movl $0x73, %esi
+;   movq %rsi, 0x28(%rsp)
+;   movl $0x78, %esi
+;   movq %rsi, 0x20(%rsp)
+;   movl $0x7d, %esi
+;   movq %rsi, 0x18(%rsp)
+;   movl $0x82, %esi
+;   movq %rsi, 0x10(%rsp)
+;   movl $0x87, %esi
+;   movq %rsi, 8(%rsp)
+;   movabsq $0, %rsi ; reloc_external Abs8 %tail_callee_stack_args 0
+;   movq %rsi, (%rsp)
+;   movq %rax, 0x10(%rbp)
+;   movq %r10, 0x18(%rbp)
+;   movq %r11, 0x20(%rbp)
+;   movq %r13, 0x28(%rbp)
+;   movq %r14, 0x30(%rbp)
+;   movq %r15, 0x38(%rbp)
+;   movq %rbx, 0x40(%rbp)
+;   movq %r12, 0x48(%rbp)
+;   movq %rdi, 0x50(%rbp)
+;   movq 0x38(%rsp), %rdi
+;   movq %rdi, 0x58(%rbp)
+;   movq %rdx, 0x60(%rbp)
+;   movq %rcx, 0x68(%rbp)
+;   movq %r8, 0x70(%rbp)
+;   movq %r9, 0x78(%rbp)
+;   movq 0x30(%rsp), %rsi
+;   movq %rsi, 0x80(%rbp)
+;   movq 0x28(%rsp), %rsi
+;   movq %rsi, 0x88(%rbp)
+;   movq 0x20(%rsp), %rsi
+;   movq %rsi, 0x90(%rbp)
+;   movq 0x18(%rsp), %rsi
+;   movq %rsi, 0x98(%rbp)
+;   movq 0x10(%rsp), %rsi
+;   movq %rsi, 0xa0(%rbp)
+;   movq 8(%rsp), %rsi
+;   movq %rsi, 0xa8(%rbp)
+;   movq 0x50(%rsp), %rcx
+;   movq 0x58(%rsp), %rdx
+;   movq 0x60(%rsp), %rsi
+;   movq 0x68(%rsp), %rdi
+;   movq 0x48(%rsp), %r8
+;   movq 0x40(%rsp), %r9
+;   movq (%rsp), %r10
+;   movq 0x70(%rsp), %rbx
+;   movq 0x78(%rsp), %r12
+;   movq 0x80(%rsp), %r13
+;   movq 0x88(%rsp), %r14
+;   movq 0x90(%rsp), %r15
+;   addq $0xa0, %rsp
+;   movq %rbp, %rsp
+;   popq %rbp
+;   jmpq *%r10
 
diff --git a/cranelift/filetests/filetests/isa/x64/return-call.clif b/cranelift/filetests/filetests/isa/x64/return-call.clif
index 18b9dce2db26..e20657ff82e3 100644
--- a/cranelift/filetests/filetests/isa/x64/return-call.clif
+++ b/cranelift/filetests/filetests/isa/x64/return-call.clif
@@ -14,7 +14,7 @@ block0(v0: i64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   lea     10(%rax), %rax
+;   lea     10(%rdi), %rax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -24,7 +24,7 @@ block0(v0: i64):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   addq $0xa, %rax
+;   leaq 0xa(%rdi), %rax
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -40,20 +40,18 @@ block0(v0: i64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rbp, %rcx
-;   load_ext_name %callee_i64+0, %r8
-;   return_call_unknown %r8 new_stack_arg_size:0 old_stack_arg_size:0 ret_addr:None fp:%v193 tmp:%v194 %rax=%rax
+;   load_ext_name %callee_i64+0, %r10
+;   return_call_unknown %r10 (0) tmp=%r11 %rdi=%rdi
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rbp, %rcx
-;   movabsq $0, %r8 ; reloc_external Abs8 %callee_i64 0
-;   movq (%rcx), %rbp
-;   leaq 8(%rcx), %rsp
-;   jmpq *%r8
+;   movabsq $0, %r10 ; reloc_external Abs8 %callee_i64 0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   jmpq *%r10
 
 ;;;; Test colocated tail calls ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
@@ -68,18 +66,16 @@ block0(v0: i64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rbp, %rcx
-;   return_call_known TestCase(%callee_i64) new_stack_arg_size:0 old_stack_arg_size:0 ret_addr:None fp:%v193 tmp:%v194 %rax=%rax
+;   return_call_known TestCase(%callee_i64) (0) tmp=%r11 %rdi=%rdi
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rbp, %rcx
-;   movq (%rcx), %rbp
-;   leaq 8(%rcx), %rsp
-;   jmp 0x13 ; reloc_external CallPCRel4 %callee_i64 -4
+;   movq %rbp, %rsp
+;   popq %rbp
+;   jmp 0xd ; reloc_external CallPCRel4 %callee_i64 -4
 
 ;;;; Test passing `f64`s ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
@@ -135,20 +131,18 @@ block0(v0: f64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rbp, %rax
-;   load_ext_name %callee_f64+0, %r8
-;   return_call_unknown %r8 new_stack_arg_size:0 old_stack_arg_size:0 ret_addr:None fp:%v193 tmp:%v194 %xmm0=%xmm0
+;   load_ext_name %callee_f64+0, %r10
+;   return_call_unknown %r10 (0) tmp=%r11 %xmm0=%xmm0
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rbp, %rax
-;   movabsq $0, %r8 ; reloc_external Abs8 %callee_f64 0
-;   movq (%rax), %rbp
-;   leaq 8(%rax), %rsp
-;   jmpq *%r8
+;   movabsq $0, %r10 ; reloc_external Abs8 %callee_f64 0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   jmpq *%r10
 
 ;;;; Test passing `i8`s ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
@@ -163,7 +157,7 @@ block0(v0: i8):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   testb   %al, %al
+;   testb   %dil, %dil
 ;   setz    %al
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -174,7 +168,7 @@ block0(v0: i8):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   testb %al, %al
+;   testb %dil, %dil
 ;   sete %al
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -191,20 +185,170 @@ block0(v0: i8):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rbp, %rcx
-;   load_ext_name %callee_i8+0, %r8
-;   return_call_unknown %r8 new_stack_arg_size:0 old_stack_arg_size:0 ret_addr:None fp:%v193 tmp:%v194 %rax=%rax
+;   load_ext_name %callee_i8+0, %r10
+;   return_call_unknown %r10 (0) tmp=%r11 %rdi=%rdi
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movabsq $0, %r10 ; reloc_external Abs8 %callee_i8 0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   jmpq *%r10
+
+;;;; Test passing fewer arguments on the stack ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+function %one_stack_arg(i32, i32, i32, i32, i32, i32, i32) tail {
+block0(v0: i32, v1: i32, v2: i32, v3: i32, v4: i32, v5: i32, v6: i32):
+    return
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret 16
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq $0x10
+
+function %call_one_stack_arg(i32, i32, i32, i32, i32, i32, i32, i32, i32) tail {
+    fn0 = colocated %one_stack_arg(i32, i32, i32, i32, i32, i32, i32) tail
+
+block0(v0: i32, v1: i32, v2: i32, v3: i32, v4: i32, v5: i32, v6: i32, v7: i32, v8: i32):
+    return_call fn0(v2, v3, v4, v5, v6, v7, v8)
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movq    %r8, %r10
+;   movq    %r9, %r11
+;   movq    rbp(stack args max - 32), %r8
+;   movq    rbp(stack args max - 24), %r9
+;   movq    rbp(stack args max - 16), %rsi
+;   movl    %esi, rbp(stack args max - 16)
+;   movq    %rdx, %rdi
+;   movq    %rcx, %rsi
+;   movq    %r10, %rdx
+;   movq    %r11, %rcx
+;   return_call_known TestCase(%one_stack_arg) (16) tmp=%r11 %rdi=%rdi %rsi=%rsi %rdx=%rdx %rcx=%rcx %r8=%r8 %r9=%r9
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movq %r8, %r10
+;   movq %r9, %r11
+;   movq 0x10(%rbp), %r8
+;   movq 0x18(%rbp), %r9
+;   movq 0x20(%rbp), %rsi
+;   movl %esi, 0x20(%rbp)
+;   movq %rdx, %rdi
+;   movq %rcx, %rsi
+;   movq %r10, %rdx
+;   movq %r11, %rcx
+;   movq %rbp, %rsp
+;   popq %rbp
+;   movq (%rsp), %r11
+;   movq %r11, 0x10(%rsp)
+;   addq $0x10, %rsp
+;   jmp 0x3b ; reloc_external CallPCRel4 %one_stack_arg -4
+
+function %call_zero_stack_args(i32, i32, i32, i32, i32, i32, i32, i32, i8) -> i8 tail {
+    fn0 = colocated %callee_i8(i8) -> i8 tail
+
+block0(v0: i32, v1: i32, v2: i32, v3: i32, v4: i32, v5: i32, v6: i32, v7: i32, v8: i8):
+    return_call fn0(v8)
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movq    rbp(stack args max - 16), %rdi
+;   return_call_known TestCase(%callee_i8) (0) tmp=%r11 %rdi=%rdi
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rbp, %rcx
-;   movabsq $0, %r8 ; reloc_external Abs8 %callee_i8 0
-;   movq (%rcx), %rbp
-;   leaq 8(%rcx), %rsp
-;   jmpq *%r8
+;   movq 0x20(%rbp), %rdi
+;   movq %rbp, %rsp
+;   popq %rbp
+;   movq (%rsp), %r11
+;   movq %r11, 0x20(%rsp)
+;   addq $0x20, %rsp
+;   jmp 0x1e ; reloc_external CallPCRel4 %callee_i8 -4
+
+;;;; Test growing the argument area when it's non-empty ;;;;;;;;;;;;;;;;;;;;;;;;
+
+function %call_from_one_stack_arg(i32, i32, i32, i32, i32, i32, i32) tail {
+    fn0 = colocated %call_one_stack_arg(i32, i32, i32, i32, i32, i32, i32, i32, i32) tail
+
+block0(v0: i32, v1: i32, v2: i32, v3: i32, v4: i32, v5: i32, v6: i32):
+    return_call fn0(v1, v2, v3, v4, v5, v6, v0, v0, v1)
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+;   subq    %rsp, $16, %rsp
+;   movq    %rsp, %rbp
+;   movq    16(%rsp), %r11
+;   movq    %r11, 0(%rsp)
+;   movq    24(%rsp), %r11
+;   movq    %r11, 8(%rsp)
+; block0:
+;   movq    %r9, %r10
+;   movq    rbp(stack args max - 16), %r9
+;   movl    %edi, rbp(stack args max - 32)
+;   movl    %edi, rbp(stack args max - 24)
+;   movl    %esi, rbp(stack args max - 16)
+;   movq    %rsi, %rdi
+;   movq    %rdx, %rsi
+;   movq    %rcx, %rdx
+;   movq    %r8, %rcx
+;   movq    %r10, %r8
+;   return_call_known TestCase(%call_one_stack_arg) (32) tmp=%r11 %rdi=%rdi %rsi=%rsi %rdx=%rdx %rcx=%rcx %r8=%r8 %r9=%r9
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+;   subq $0x10, %rsp
+;   movq %rsp, %rbp
+;   movq 0x10(%rsp), %r11
+;   movq %r11, (%rsp)
+;   movq 0x18(%rsp), %r11
+;   movq %r11, 8(%rsp)
+; block1: ; offset 0x1e
+;   movq %r9, %r10
+;   movq 0x20(%rbp), %r9
+;   movl %edi, 0x10(%rbp)
+;   movl %edi, 0x18(%rbp)
+;   movl %esi, 0x20(%rbp)
+;   movq %rsi, %rdi
+;   movq %rdx, %rsi
+;   movq %rcx, %rdx
+;   movq %r8, %rcx
+;   movq %r10, %r8
+;   movq %rbp, %rsp
+;   popq %rbp
+;   jmp 0x46 ; reloc_external CallPCRel4 %call_one_stack_arg -4
 
 ;;;; Test passing many arguments on stack ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
@@ -217,50 +361,20 @@ block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64, v6: i64, v7: i64, v
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    16(%rbp), %rax
-;   movq    24(%rbp), %rdx
-;   movq    32(%rbp), %r9
-;   movq    40(%rbp), %r11
-;   movq    48(%rbp), %rdi
-;   movq    56(%rbp), %rcx
-;   movq    64(%rbp), %r8
-;   movq    72(%rbp), %r10
-;   movq    80(%rbp), %rsi
-;   movq    88(%rbp), %rax
-;   movq    96(%rbp), %rdx
-;   movq    104(%rbp), %r9
-;   movq    112(%rbp), %r11
-;   movq    120(%rbp), %rdi
-;   movq    128(%rbp), %rcx
-;   movq    136(%rbp), %rax
+;   movq    rbp(stack args max - 8), %rax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
-;   ret 128
+;   ret 160
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq 0x10(%rbp), %rax
-;   movq 0x18(%rbp), %rdx
-;   movq 0x20(%rbp), %r9
-;   movq 0x28(%rbp), %r11
-;   movq 0x30(%rbp), %rdi
-;   movq 0x38(%rbp), %rcx
-;   movq 0x40(%rbp), %r8
-;   movq 0x48(%rbp), %r10
-;   movq 0x50(%rbp), %rsi
-;   movq 0x58(%rbp), %rax
-;   movq 0x60(%rbp), %rdx
-;   movq 0x68(%rbp), %r9
-;   movq 0x70(%rbp), %r11
-;   movq 0x78(%rbp), %rdi
-;   movq 0x80(%rbp), %rcx
-;   movq 0x88(%rbp), %rax
+;   movq 0xa8(%rbp), %rax
 ;   movq %rbp, %rsp
 ;   popq %rbp
-;   retq $0x80
+;   retq $0xa0
 
 function %tail_caller_stack_args() -> i64 tail {
     fn0 = %tail_callee_stack_args(i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64) -> i64 tail
@@ -298,195 +412,191 @@ block0:
 ; VCode:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
-;   subq    %rsp, $112, %rsp
+;   subq    %rsp, $160, %rsp
+;   movq    %rsp, %rbp
+;   movq    160(%rsp), %r11
+;   movq    %r11, 0(%rsp)
+;   movq    168(%rsp), %r11
+;   movq    %r11, 8(%rsp)
+;   subq    %rsp, $160, %rsp
+;   movq    %rbx, 112(%rsp)
+;   movq    %r12, 120(%rsp)
+;   movq    %r13, 128(%rsp)
+;   movq    %r14, 136(%rsp)
+;   movq    %r15, 144(%rsp)
 ; block0:
-;   movl    $10, %eax
-;   movq    %rax, rsp(96 + virtual offset)
-;   movl    $15, %ecx
-;   movq    %rcx, rsp(88 + virtual offset)
-;   movl    $20, %edx
-;   movq    %rdx, rsp(80 + virtual offset)
-;   movl    $25, %ebx
-;   movq    %rbx, rsp(72 + virtual offset)
-;   movl    $30, %esi
-;   movq    %rsi, rsp(64 + virtual offset)
-;   movl    $35, %edi
-;   movq    %rdi, rsp(56 + virtual offset)
-;   movl    $40, %r8d
-;   movq    %r8, rsp(48 + virtual offset)
-;   movl    $45, %r9d
-;   movq    %r9, rsp(40 + virtual offset)
-;   movl    $50, %r10d
-;   movq    %r10, rsp(32 + virtual offset)
-;   movl    $55, %r11d
-;   movq    %r11, rsp(24 + virtual offset)
-;   movl    $60, %r15d
-;   movl    $65, %r12d
-;   movl    $70, %r13d
-;   movl    $75, %r14d
-;   movl    $80, %ecx
-;   movq    %rcx, rsp(16 + virtual offset)
-;   movl    $85, %ecx
+;   movl    $10, %esi
+;   movq    %rsi, rsp(96 + virtual offset)
+;   movl    $15, %edx
+;   movq    %rdx, rsp(88 + virtual offset)
+;   movl    $20, %ecx
+;   movq    %rcx, rsp(80 + virtual offset)
+;   movl    $25, %r8d
+;   movq    %r8, rsp(72 + virtual offset)
+;   movl    $30, %r9d
+;   movq    %r9, rsp(64 + virtual offset)
+;   movl    $35, %r9d
+;   movq    %r9, rsp(56 + virtual offset)
+;   movl    $40, %eax
+;   movl    $45, %r10d
+;   movl    $50, %r11d
+;   movl    $55, %r13d
+;   movl    $60, %r14d
+;   movl    $65, %r15d
+;   movl    $70, %ebx
+;   movl    $75, %r12d
+;   movl    $80, %edi
+;   movl    $85, %esi
+;   movq    %rsi, rsp(48 + virtual offset)
 ;   movl    $90, %edx
-;   movl    $95, %ebx
-;   movl    $100, %esi
-;   movl    $105, %edi
-;   movl    $110, %r8d
-;   movl    $115, %r9d
-;   movl    $120, %r10d
-;   movl    $125, %r11d
-;   movl    $130, %eax
-;   movq    %rax, rsp(8 + virtual offset)
-;   movl    $135, %eax
-;   movq    %rax, rsp(0 + virtual offset)
-;   subq    %rsp, $128, %rsp
-;   virtual_sp_offset_adjust 128
-;   movq    %r15, 0(%rsp)
-;   movq    %r12, 8(%rsp)
-;   movq    %r13, 16(%rsp)
-;   movq    %r14, 24(%rsp)
-;   movq    rsp(16 + virtual offset), %rax
-;   movq    %rax, 32(%rsp)
-;   movq    %rcx, 40(%rsp)
-;   movq    %rdx, 48(%rsp)
-;   movq    %rbx, 56(%rsp)
-;   movq    %rsi, 64(%rsp)
-;   movq    %rdi, 72(%rsp)
-;   movq    %r8, 80(%rsp)
-;   movq    %r9, 88(%rsp)
-;   movq    %r10, 96(%rsp)
-;   movq    %r11, 104(%rsp)
-;   movq    rsp(8 + virtual offset), %rax
-;   movq    %rax, 112(%rsp)
-;   movq    rsp(0 + virtual offset), %rax
-;   movq    %rax, 120(%rsp)
-;   movq    %rbp, %r15
-;   movq    8(%r15), %r13
-;   load_ext_name %tail_callee_stack_args+0, %r12
-;   movq    rsp(24 + virtual offset), %r11
-;   movq    rsp(32 + virtual offset), %r10
-;   movq    rsp(40 + virtual offset), %r9
-;   movq    rsp(48 + virtual offset), %r8
-;   movq    rsp(56 + virtual offset), %rdi
-;   movq    rsp(64 + virtual offset), %rsi
-;   movq    rsp(72 + virtual offset), %rbx
+;   movl    $95, %ecx
+;   movl    $100, %r8d
+;   movl    $105, %r9d
+;   movl    $110, %esi
+;   movq    %rsi, rsp(40 + virtual offset)
+;   movl    $115, %esi
+;   movq    %rsi, rsp(32 + virtual offset)
+;   movl    $120, %esi
+;   movq    %rsi, rsp(24 + virtual offset)
+;   movl    $125, %esi
+;   movq    %rsi, rsp(16 + virtual offset)
+;   movl    $130, %esi
+;   movq    %rsi, rsp(8 + virtual offset)
+;   movl    $135, %esi
+;   movq    %rsi, rsp(0 + virtual offset)
+;   movq    %rax, rbp(stack args max - 160)
+;   movq    %r10, rbp(stack args max - 152)
+;   movq    %r11, rbp(stack args max - 144)
+;   movq    %r13, rbp(stack args max - 136)
+;   movq    %r14, rbp(stack args max - 128)
+;   movq    %r15, rbp(stack args max - 120)
+;   movq    %rbx, rbp(stack args max - 112)
+;   movq    %r12, rbp(stack args max - 104)
+;   movq    %rdi, rbp(stack args max - 96)
+;   movq    rsp(48 + virtual offset), %rdi
+;   movq    %rdi, rbp(stack args max - 88)
+;   movq    %rdx, rbp(stack args max - 80)
+;   movq    %rcx, rbp(stack args max - 72)
+;   movq    %r8, rbp(stack args max - 64)
+;   movq    %r9, rbp(stack args max - 56)
+;   movq    rsp(40 + virtual offset), %rsi
+;   movq    %rsi, rbp(stack args max - 48)
+;   movq    rsp(32 + virtual offset), %rsi
+;   movq    %rsi, rbp(stack args max - 40)
+;   movq    rsp(24 + virtual offset), %rsi
+;   movq    %rsi, rbp(stack args max - 32)
+;   movq    rsp(16 + virtual offset), %rsi
+;   movq    %rsi, rbp(stack args max - 24)
+;   movq    rsp(8 + virtual offset), %rsi
+;   movq    %rsi, rbp(stack args max - 16)
+;   movq    rsp(0 + virtual offset), %rsi
+;   movq    %rsi, rbp(stack args max - 8)
+;   load_ext_name %tail_callee_stack_args+0, %r10
+;   movq    rsp(72 + virtual offset), %rcx
 ;   movq    rsp(80 + virtual offset), %rdx
-;   movq    rsp(88 + virtual offset), %rcx
-;   movq    rsp(96 + virtual offset), %rax
-;   return_call_unknown %r12 new_stack_arg_size:128 old_stack_arg_size:0 ret_addr:Some("%v219") fp:%v218 tmp:%v220 %rax=%rax %rcx=%rcx %rdx=%rdx %rbx=%rbx %rsi=%rsi %rdi=%rdi %r8=%r8 %r9=%r9 %r10=%r10 %r11=%r11
+;   movq    rsp(88 + virtual offset), %rsi
+;   movq    rsp(96 + virtual offset), %rdi
+;   movq    rsp(64 + virtual offset), %r8
+;   movq    rsp(56 + virtual offset), %r9
+;   return_call_unknown %r10 (160) tmp=%r11 %rdi=%rdi %rsi=%rsi %rdx=%rdx %rcx=%rcx %r8=%r8 %r9=%r9
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
-;   subq $0x70, %rsp
-; block1: ; offset 0x8
-;   movl $0xa, %eax
-;   movq %rax, 0x60(%rsp)
-;   movl $0xf, %ecx
-;   movq %rcx, 0x58(%rsp)
-;   movl $0x14, %edx
-;   movq %rdx, 0x50(%rsp)
-;   movl $0x19, %ebx
-;   movq %rbx, 0x48(%rsp)
-;   movl $0x1e, %esi
-;   movq %rsi, 0x40(%rsp)
-;   movl $0x23, %edi
-;   movq %rdi, 0x38(%rsp)
-;   movl $0x28, %r8d
-;   movq %r8, 0x30(%rsp)
-;   movl $0x2d, %r9d
-;   movq %r9, 0x28(%rsp)
-;   movl $0x32, %r10d
-;   movq %r10, 0x20(%rsp)
-;   movl $0x37, %r11d
-;   movq %r11, 0x18(%rsp)
-;   movl $0x3c, %r15d
-;   movl $0x41, %r12d
-;   movl $0x46, %r13d
-;   movl $0x4b, %r14d
-;   movl $0x50, %ecx
-;   movq %rcx, 0x10(%rsp)
-;   movl $0x55, %ecx
+;   subq $0xa0, %rsp
+;   movq %rsp, %rbp
+;   movq 0xa0(%rsp), %r11
+;   movq %r11, (%rsp)
+;   movq 0xa8(%rsp), %r11
+;   movq %r11, 8(%rsp)
+;   subq $0xa0, %rsp
+;   movq %rbx, 0x70(%rsp)
+;   movq %r12, 0x78(%rsp)
+;   movq %r13, 0x80(%rsp)
+;   movq %r14, 0x88(%rsp)
+;   movq %r15, 0x90(%rsp)
+; block1: ; offset 0x50
+;   movl $0xa, %esi
+;   movq %rsi, 0x60(%rsp)
+;   movl $0xf, %edx
+;   movq %rdx, 0x58(%rsp)
+;   movl $0x14, %ecx
+;   movq %rcx, 0x50(%rsp)
+;   movl $0x19, %r8d
+;   movq %r8, 0x48(%rsp)
+;   movl $0x1e, %r9d
+;   movq %r9, 0x40(%rsp)
+;   movl $0x23, %r9d
+;   movq %r9, 0x38(%rsp)
+;   movl $0x28, %eax
+;   movl $0x2d, %r10d
+;   movl $0x32, %r11d
+;   movl $0x37, %r13d
+;   movl $0x3c, %r14d
+;   movl $0x41, %r15d
+;   movl $0x46, %ebx
+;   movl $0x4b, %r12d
+;   movl $0x50, %edi
+;   movl $0x55, %esi
+;   movq %rsi, 0x30(%rsp)
 ;   movl $0x5a, %edx
-;   movl $0x5f, %ebx
-;   movl $0x64, %esi
-;   movl $0x69, %edi
-;   movl $0x6e, %r8d
-;   movl $0x73, %r9d
-;   movl $0x78, %r10d
-;   movl $0x7d, %r11d
-;   movl $0x82, %eax
-;   movq %rax, 8(%rsp)
-;   movl $0x87, %eax
-;   movq %rax, (%rsp)
-;   subq $0x80, %rsp
-;   movq %r15, (%rsp)
-;   movq %r12, 8(%rsp)
-;   movq %r13, 0x10(%rsp)
-;   movq %r14, 0x18(%rsp)
-;   movq 0x90(%rsp), %rax
-;   movq %rax, 0x20(%rsp)
-;   movq %rcx, 0x28(%rsp)
-;   movq %rdx, 0x30(%rsp)
-;   movq %rbx, 0x38(%rsp)
-;   movq %rsi, 0x40(%rsp)
-;   movq %rdi, 0x48(%rsp)
-;   movq %r8, 0x50(%rsp)
-;   movq %r9, 0x58(%rsp)
-;   movq %r10, 0x60(%rsp)
-;   movq %r11, 0x68(%rsp)
-;   movq 0x88(%rsp), %rax
-;   movq %rax, 0x70(%rsp)
-;   movq 0x80(%rsp), %rax
-;   movq %rax, 0x78(%rsp)
-;   movq %rbp, %r15
-;   movq 8(%r15), %r13
-;   movabsq $0, %r12 ; reloc_external Abs8 %tail_callee_stack_args 0
-;   movq 0x98(%rsp), %r11
-;   movq 0xa0(%rsp), %r10
-;   movq 0xa8(%rsp), %r9
-;   movq 0xb0(%rsp), %r8
-;   movq 0xb8(%rsp), %rdi
-;   movq 0xc0(%rsp), %rsi
-;   movq 0xc8(%rsp), %rbx
-;   movq 0xd0(%rsp), %rdx
-;   movq 0xd8(%rsp), %rcx
-;   movq 0xe0(%rsp), %rax
-;   movq (%r15), %rbp
-;   movq 0x78(%rsp), %r14
-;   movq %r14, 8(%r15)
-;   movq 0x70(%rsp), %r14
-;   movq %r14, (%r15)
-;   movq 0x68(%rsp), %r14
-;   movq %r14, -8(%r15)
-;   movq 0x60(%rsp), %r14
-;   movq %r14, -0x10(%r15)
-;   movq 0x58(%rsp), %r14
-;   movq %r14, -0x18(%r15)
-;   movq 0x50(%rsp), %r14
-;   movq %r14, -0x20(%r15)
-;   movq 0x48(%rsp), %r14
-;   movq %r14, -0x28(%r15)
-;   movq 0x40(%rsp), %r14
-;   movq %r14, -0x30(%r15)
-;   movq 0x38(%rsp), %r14
-;   movq %r14, -0x38(%r15)
-;   movq 0x30(%rsp), %r14
-;   movq %r14, -0x40(%r15)
-;   movq 0x28(%rsp), %r14
-;   movq %r14, -0x48(%r15)
-;   movq 0x20(%rsp), %r14
-;   movq %r14, -0x50(%r15)
-;   movq 0x18(%rsp), %r14
-;   movq %r14, -0x58(%r15)
-;   movq 0x10(%rsp), %r14
-;   movq %r14, -0x60(%r15)
-;   movq 8(%rsp), %r14
-;   movq %r14, -0x68(%r15)
-;   movq (%rsp), %r14
-;   movq %r14, -0x70(%r15)
-;   leaq -0x78(%r15), %rsp
-;   movq %r13, (%rsp)
-;   jmpq *%r12
+;   movl $0x5f, %ecx
+;   movl $0x64, %r8d
+;   movl $0x69, %r9d
+;   movl $0x6e, %esi
+;   movq %rsi, 0x28(%rsp)
+;   movl $0x73, %esi
+;   movq %rsi, 0x20(%rsp)
+;   movl $0x78, %esi
+;   movq %rsi, 0x18(%rsp)
+;   movl $0x7d, %esi
+;   movq %rsi, 0x10(%rsp)
+;   movl $0x82, %esi
+;   movq %rsi, 8(%rsp)
+;   movl $0x87, %esi
+;   movq %rsi, (%rsp)
+;   movq %rax, 0x10(%rbp)
+;   movq %r10, 0x18(%rbp)
+;   movq %r11, 0x20(%rbp)
+;   movq %r13, 0x28(%rbp)
+;   movq %r14, 0x30(%rbp)
+;   movq %r15, 0x38(%rbp)
+;   movq %rbx, 0x40(%rbp)
+;   movq %r12, 0x48(%rbp)
+;   movq %rdi, 0x50(%rbp)
+;   movq 0x30(%rsp), %rdi
+;   movq %rdi, 0x58(%rbp)
+;   movq %rdx, 0x60(%rbp)
+;   movq %rcx, 0x68(%rbp)
+;   movq %r8, 0x70(%rbp)
+;   movq %r9, 0x78(%rbp)
+;   movq 0x28(%rsp), %rsi
+;   movq %rsi, 0x80(%rbp)
+;   movq 0x20(%rsp), %rsi
+;   movq %rsi, 0x88(%rbp)
+;   movq 0x18(%rsp), %rsi
+;   movq %rsi, 0x90(%rbp)
+;   movq 0x10(%rsp), %rsi
+;   movq %rsi, 0x98(%rbp)
+;   movq 8(%rsp), %rsi
+;   movq %rsi, 0xa0(%rbp)
+;   movq (%rsp), %rsi
+;   movq %rsi, 0xa8(%rbp)
+;   movabsq $0, %r10 ; reloc_external Abs8 %tail_callee_stack_args 0
+;   movq 0x48(%rsp), %rcx
+;   movq 0x50(%rsp), %rdx
+;   movq 0x58(%rsp), %rsi
+;   movq 0x60(%rsp), %rdi
+;   movq 0x40(%rsp), %r8
+;   movq 0x38(%rsp), %r9
+;   movq 0x70(%rsp), %rbx
+;   movq 0x78(%rsp), %r12
+;   movq 0x80(%rsp), %r13
+;   movq 0x88(%rsp), %r14
+;   movq 0x90(%rsp), %r15
+;   addq $0xa0, %rsp
+;   movq %rbp, %rsp
+;   popq %rbp
+;   jmpq *%r10
 
diff --git a/cranelift/filetests/filetests/isa/x64/select-i128.clif b/cranelift/filetests/filetests/isa/x64/select-i128.clif
index 3586dc7523e8..74eae44aec8c 100644
--- a/cranelift/filetests/filetests/isa/x64/select-i128.clif
+++ b/cranelift/filetests/filetests/isa/x64/select-i128.clif
@@ -51,11 +51,11 @@ block0(v0: f32, v1: i128, v2: i128):
 ;   movq    %rsp, %rbp
 ; block0:
 ;   ucomiss %xmm0, %xmm0
+;   cmovpq  %rdx, %rdi, %rdi
 ;   movq    %rdi, %rax
-;   cmovpq  %rdx, %rax, %rax
 ;   cmovnzq %rdx, %rax, %rax
+;   cmovpq  %rcx, %rsi, %rsi
 ;   movq    %rsi, %rdx
-;   cmovpq  %rcx, %rdx, %rdx
 ;   cmovnzq %rcx, %rdx, %rdx
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -67,11 +67,11 @@ block0(v0: f32, v1: i128, v2: i128):
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
 ;   ucomiss %xmm0, %xmm0
+;   cmovpq %rdx, %rdi
 ;   movq %rdi, %rax
-;   cmovpq %rdx, %rax
 ;   cmovneq %rdx, %rax
+;   cmovpq %rcx, %rsi
 ;   movq %rsi, %rdx
-;   cmovpq %rcx, %rdx
 ;   cmovneq %rcx, %rdx
 ;   movq %rbp, %rsp
 ;   popq %rbp
diff --git a/cranelift/filetests/filetests/isa/x64/select.clif b/cranelift/filetests/filetests/isa/x64/select.clif
index a348b34a6e9e..d25799b74138 100644
--- a/cranelift/filetests/filetests/isa/x64/select.clif
+++ b/cranelift/filetests/filetests/isa/x64/select.clif
@@ -45,8 +45,8 @@ block0(v0: f32, v1: f32, v2: i64, v3: i64):
 ;   movq    %rsp, %rbp
 ; block0:
 ;   ucomiss %xmm1, %xmm0
+;   cmovpq  %rsi, %rdi, %rdi
 ;   movq    %rdi, %rax
-;   cmovpq  %rsi, %rax, %rax
 ;   cmovnzq %rsi, %rax, %rax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -58,10 +58,138 @@ block0(v0: f32, v1: f32, v2: i64, v3: i64):
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
 ;   ucomiss %xmm1, %xmm0
+;   cmovpq %rsi, %rdi
 ;   movq %rdi, %rax
-;   cmovpq %rsi, %rax
 ;   cmovneq %rsi, %rax
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
 
+function %select_f16(i8, f16, f16) -> f16 {
+block0(v0: i8, v1: f16, v2: f16):
+    v3 = select.f16 v0, v1, v2
+    return v3
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   testb   %dil, %dil
+;   movdqa  %xmm0, %xmm6
+;   movdqa  %xmm1, %xmm0
+;   movss %xmm0, %xmm0; jz $next; movss %xmm6, %xmm0; $next:
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   testb %dil, %dil
+;   movdqa %xmm0, %xmm6
+;   movdqa %xmm1, %xmm0
+;   je 0x19
+;   movsd %xmm6, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %select_f32(i8, f32, f32) -> f32 {
+block0(v0: i8, v1: f32, v2: f32):
+    v3 = select.f32 v0, v1, v2
+    return v3
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   testb   %dil, %dil
+;   movdqa  %xmm0, %xmm6
+;   movdqa  %xmm1, %xmm0
+;   movss %xmm0, %xmm0; jz $next; movss %xmm6, %xmm0; $next:
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   testb %dil, %dil
+;   movdqa %xmm0, %xmm6
+;   movdqa %xmm1, %xmm0
+;   je 0x19
+;   movsd %xmm6, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %select_f64(i8, f64, f64) -> f64 {
+block0(v0: i8, v1: f64, v2: f64):
+    v3 = select.f64 v0, v1, v2
+    return v3
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   testb   %dil, %dil
+;   movdqa  %xmm0, %xmm6
+;   movdqa  %xmm1, %xmm0
+;   movsd %xmm0, %xmm0; jz $next; movsd %xmm6, %xmm0; $next:
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   testb %dil, %dil
+;   movdqa %xmm0, %xmm6
+;   movdqa %xmm1, %xmm0
+;   je 0x19
+;   movsd %xmm6, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %select_f128(i8, f128, f128) -> f128 {
+block0(v0: i8, v1: f128, v2: f128):
+    v3 = select.f128 v0, v1, v2
+    return v3
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   testb   %dil, %dil
+;   movdqa  %xmm0, %xmm6
+;   movdqa  %xmm1, %xmm0
+;   movdqa %xmm0, %xmm0; jz $next; movdqa %xmm6, %xmm0; $next:
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   testb %dil, %dil
+;   movdqa %xmm0, %xmm6
+;   movdqa %xmm1, %xmm0
+;   je 0x19
+;   movdqa %xmm6, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/shuffle-avx512.clif b/cranelift/filetests/filetests/isa/x64/shuffle-avx512.clif
index 2ccae20022b6..e0dad66c7b60 100644
--- a/cranelift/filetests/filetests/isa/x64/shuffle-avx512.clif
+++ b/cranelift/filetests/filetests/isa/x64/shuffle-avx512.clif
@@ -15,7 +15,7 @@ block0(v0: i8x16, v1: i8x16):
 ;   movdqa  %xmm0, %xmm5
 ;   movdqu  const(0), %xmm0
 ;   movdqa  %xmm5, %xmm6
-;   vpermi2b %xmm0, %xmm6, %xmm1, %xmm0
+;   vpermi2b %xmm1, %xmm6, %xmm0, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -54,7 +54,7 @@ block0(v0: i8x16, v1: i8x16):
 ;   movdqa  %xmm0, %xmm5
 ;   movdqu  const(0), %xmm0
 ;   movdqa  %xmm5, %xmm6
-;   vpermi2b %xmm0, %xmm6, %xmm1, %xmm0
+;   vpermi2b %xmm1, %xmm6, %xmm0, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/simd-arith-avx.clif b/cranelift/filetests/filetests/isa/x64/simd-arith-avx.clif
index 8cd260a3f536..12e3ce7c3f5d 100644
--- a/cranelift/filetests/filetests/isa/x64/simd-arith-avx.clif
+++ b/cranelift/filetests/filetests/isa/x64/simd-arith-avx.clif
@@ -914,12 +914,11 @@ block0(v0: i8x16, v1: i32):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rdi, %r9
-;   andq    %r9, $7, %r9
+;   andq    %rdi, $7, %rdi
 ;   vpunpcklbw %xmm0, %xmm0, %xmm5
 ;   vpunpckhbw %xmm0, %xmm0, %xmm7
-;   addl    %r9d, $8, %r9d
-;   vmovd   %r9d, %xmm3
+;   addl    %edi, $8, %edi
+;   vmovd   %edi, %xmm3
 ;   vpsraw  %xmm5, %xmm3, %xmm5
 ;   vpsraw  %xmm7, %xmm3, %xmm7
 ;   vpacksswb %xmm5, %xmm7, %xmm0
@@ -932,12 +931,11 @@ block0(v0: i8x16, v1: i32):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rdi, %r9
-;   andq $7, %r9
+;   andq $7, %rdi
 ;   vpunpcklbw %xmm0, %xmm0, %xmm5
 ;   vpunpckhbw %xmm0, %xmm0, %xmm7
-;   addl $8, %r9d
-;   vmovd %r9d, %xmm3
+;   addl $8, %edi
+;   vmovd %edi, %xmm3
 ;   vpsraw %xmm3, %xmm5, %xmm5
 ;   vpsraw %xmm3, %xmm7, %xmm7
 ;   vpacksswb %xmm7, %xmm5, %xmm0
@@ -989,9 +987,8 @@ block0(v0: i16x8, v1: i32):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rdi, %rcx
-;   andq    %rcx, $15, %rcx
-;   vmovd   %ecx, %xmm5
+;   andq    %rdi, $15, %rdi
+;   vmovd   %edi, %xmm5
 ;   vpsraw  %xmm0, %xmm5, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -1002,9 +999,8 @@ block0(v0: i16x8, v1: i32):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rdi, %rcx
-;   andq $0xf, %rcx
-;   vmovd %ecx, %xmm5
+;   andq $0xf, %rdi
+;   vmovd %edi, %xmm5
 ;   vpsraw %xmm5, %xmm0, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -1046,9 +1042,8 @@ block0(v0: i32x4, v1: i32):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rdi, %rcx
-;   andq    %rcx, $31, %rcx
-;   vmovd   %ecx, %xmm5
+;   andq    %rdi, $31, %rdi
+;   vmovd   %edi, %xmm5
 ;   vpsrad  %xmm0, %xmm5, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -1059,9 +1054,8 @@ block0(v0: i32x4, v1: i32):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rdi, %rcx
-;   andq $0x1f, %rcx
-;   vmovd %ecx, %xmm5
+;   andq $0x1f, %rdi
+;   vmovd %edi, %xmm5
 ;   vpsrad %xmm5, %xmm0, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -1387,13 +1381,12 @@ block0(v0: i8x16, v1: i32):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rdi, %r10
-;   andq    %r10, $7, %r10
-;   vmovd   %r10d, %xmm5
+;   andq    %rdi, $7, %rdi
+;   vmovd   %edi, %xmm5
 ;   vpsllw  %xmm0, %xmm5, %xmm7
 ;   lea     const(0), %rsi
-;   shlq    $4, %r10, %r10
-;   vmovdqu 0(%rsi,%r10,1), %xmm5
+;   shlq    $4, %rdi, %rdi
+;   vmovdqu 0(%rsi,%rdi,1), %xmm5
 ;   vpand   %xmm7, %xmm5, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -1404,18 +1397,20 @@ block0(v0: i8x16, v1: i32):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rdi, %r10
-;   andq $7, %r10
-;   vmovd %r10d, %xmm5
+;   andq $7, %rdi
+;   vmovd %edi, %xmm5
 ;   vpsllw %xmm5, %xmm0, %xmm7
-;   leaq 0x15(%rip), %rsi
-;   shlq $4, %r10
-;   vmovdqu (%rsi, %r10), %xmm5
+;   leaq 0x19(%rip), %rsi
+;   shlq $4, %rdi
+;   vmovdqu (%rsi, %rdi), %xmm5
 ;   vpand %xmm5, %xmm7, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
 ;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %bh, %bh
 
 function %i8x16_shl_imm(i8x16) -> i8x16 {
 block0(v0: i8x16):
@@ -1460,9 +1455,8 @@ block0(v0: i16x8, v1: i32):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rdi, %rcx
-;   andq    %rcx, $15, %rcx
-;   vmovd   %ecx, %xmm5
+;   andq    %rdi, $15, %rdi
+;   vmovd   %edi, %xmm5
 ;   vpsllw  %xmm0, %xmm5, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -1473,9 +1467,8 @@ block0(v0: i16x8, v1: i32):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rdi, %rcx
-;   andq $0xf, %rcx
-;   vmovd %ecx, %xmm5
+;   andq $0xf, %rdi
+;   vmovd %edi, %xmm5
 ;   vpsllw %xmm5, %xmm0, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -1517,9 +1510,8 @@ block0(v0: i32x4, v1: i32):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rdi, %rcx
-;   andq    %rcx, $31, %rcx
-;   vmovd   %ecx, %xmm5
+;   andq    %rdi, $31, %rdi
+;   vmovd   %edi, %xmm5
 ;   vpslld  %xmm0, %xmm5, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -1530,9 +1522,8 @@ block0(v0: i32x4, v1: i32):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rdi, %rcx
-;   andq $0x1f, %rcx
-;   vmovd %ecx, %xmm5
+;   andq $0x1f, %rdi
+;   vmovd %edi, %xmm5
 ;   vpslld %xmm5, %xmm0, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -1574,9 +1565,8 @@ block0(v0: i64x2, v1: i32):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rdi, %rcx
-;   andq    %rcx, $63, %rcx
-;   vmovd   %ecx, %xmm5
+;   andq    %rdi, $63, %rdi
+;   vmovd   %edi, %xmm5
 ;   vpsllq  %xmm0, %xmm5, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -1587,9 +1577,8 @@ block0(v0: i64x2, v1: i32):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rdi, %rcx
-;   andq $0x3f, %rcx
-;   vmovd %ecx, %xmm5
+;   andq $0x3f, %rdi
+;   vmovd %edi, %xmm5
 ;   vpsllq %xmm5, %xmm0, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -1631,13 +1620,12 @@ block0(v0: i8x16, v1: i32):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rdi, %r10
-;   andq    %r10, $7, %r10
-;   vmovd   %r10d, %xmm5
+;   andq    %rdi, $7, %rdi
+;   vmovd   %edi, %xmm5
 ;   vpsrlw  %xmm0, %xmm5, %xmm7
 ;   lea     const(0), %rsi
-;   shlq    $4, %r10, %r10
-;   vpand   %xmm7, 0(%rsi,%r10,1), %xmm0
+;   shlq    $4, %rdi, %rdi
+;   vpand   %xmm7, 0(%rsi,%rdi,1), %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -1647,19 +1635,21 @@ block0(v0: i8x16, v1: i32):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rdi, %r10
-;   andq $7, %r10
-;   vmovd %r10d, %xmm5
+;   andq $7, %rdi
+;   vmovd %edi, %xmm5
 ;   vpsrlw %xmm5, %xmm0, %xmm7
-;   leaq 0x15(%rip), %rsi
-;   shlq $4, %r10
-;   vpand (%rsi, %r10), %xmm7, %xmm0
+;   leaq 0x19(%rip), %rsi
+;   shlq $4, %rdi
+;   vpand (%rsi, %rdi), %xmm7, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
 ;   addb %al, (%rax)
 ;   addb %al, (%rax)
 ;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %bh, %bh
 
 function %i8x16_ushr_imm(i8x16) -> i8x16 {
 block0(v0: i8x16):
@@ -1712,9 +1702,8 @@ block0(v0: i16x8, v1: i32):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rdi, %rcx
-;   andq    %rcx, $15, %rcx
-;   vmovd   %ecx, %xmm5
+;   andq    %rdi, $15, %rdi
+;   vmovd   %edi, %xmm5
 ;   vpsrlw  %xmm0, %xmm5, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -1725,9 +1714,8 @@ block0(v0: i16x8, v1: i32):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rdi, %rcx
-;   andq $0xf, %rcx
-;   vmovd %ecx, %xmm5
+;   andq $0xf, %rdi
+;   vmovd %edi, %xmm5
 ;   vpsrlw %xmm5, %xmm0, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -1769,9 +1757,8 @@ block0(v0: i32x4, v1: i32):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rdi, %rcx
-;   andq    %rcx, $31, %rcx
-;   vmovd   %ecx, %xmm5
+;   andq    %rdi, $31, %rdi
+;   vmovd   %edi, %xmm5
 ;   vpsrld  %xmm0, %xmm5, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -1782,9 +1769,8 @@ block0(v0: i32x4, v1: i32):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rdi, %rcx
-;   andq $0x1f, %rcx
-;   vmovd %ecx, %xmm5
+;   andq $0x1f, %rdi
+;   vmovd %edi, %xmm5
 ;   vpsrld %xmm5, %xmm0, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -1826,9 +1812,8 @@ block0(v0: i64x2, v1: i32):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rdi, %rcx
-;   andq    %rcx, $63, %rcx
-;   vmovd   %ecx, %xmm5
+;   andq    %rdi, $63, %rdi
+;   vmovd   %edi, %xmm5
 ;   vpsrlq  %xmm0, %xmm5, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -1839,9 +1824,8 @@ block0(v0: i64x2, v1: i32):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rdi, %rcx
-;   andq $0x3f, %rcx
-;   vmovd %ecx, %xmm5
+;   andq $0x3f, %rdi
+;   vmovd %edi, %xmm5
 ;   vpsrlq %xmm5, %xmm0, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
diff --git a/cranelift/filetests/filetests/isa/x64/simd-bitselect.clif b/cranelift/filetests/filetests/isa/x64/simd-bitselect.clif
index 6ffc922ee764..842fceb3bf1c 100644
--- a/cranelift/filetests/filetests/isa/x64/simd-bitselect.clif
+++ b/cranelift/filetests/filetests/isa/x64/simd-bitselect.clif
@@ -82,11 +82,12 @@ block0(v0: i8x16, v1: i8x16, v2: i32x4):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movdqa  %xmm0, %xmm4
-;   pand    %xmm4, %xmm2, %xmm4
+;   pand    %xmm0, %xmm2, %xmm0
+;   movdqa  %xmm0, %xmm7
+;   pandn   %xmm2, %xmm1, %xmm2
+;   movdqa  %xmm7, %xmm1
 ;   movdqa  %xmm2, %xmm0
-;   pandn   %xmm0, %xmm1, %xmm0
-;   por     %xmm0, %xmm4, %xmm0
+;   por     %xmm0, %xmm1, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -96,11 +97,12 @@ block0(v0: i8x16, v1: i8x16, v2: i32x4):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movdqa %xmm0, %xmm4
-;   pand %xmm2, %xmm4
+;   pand %xmm2, %xmm0
+;   movdqa %xmm0, %xmm7
+;   pandn %xmm1, %xmm2
+;   movdqa %xmm7, %xmm1
 ;   movdqa %xmm2, %xmm0
-;   pandn %xmm1, %xmm0
-;   por %xmm4, %xmm0
+;   por %xmm1, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -211,12 +213,12 @@ block0(v0: i8x16, v1: i8x16):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movdqa  %xmm0, %xmm2
+;   movdqa  %xmm0, %xmm7
 ;   movdqu  const(0), %xmm0
-;   movdqa  %xmm2, %xmm4
-;   pand    %xmm4, %xmm0, %xmm4
+;   movdqa  %xmm7, %xmm2
+;   pand    %xmm2, %xmm0, %xmm2
 ;   pandn   %xmm0, %xmm1, %xmm0
-;   por     %xmm0, %xmm4, %xmm0
+;   por     %xmm0, %xmm2, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -226,12 +228,12 @@ block0(v0: i8x16, v1: i8x16):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movdqa %xmm0, %xmm2
+;   movdqa %xmm0, %xmm7
 ;   movdqu 0x20(%rip), %xmm0
-;   movdqa %xmm2, %xmm4
-;   pand %xmm0, %xmm4
+;   movdqa %xmm7, %xmm2
+;   pand %xmm0, %xmm2
 ;   pandn %xmm1, %xmm0
-;   por %xmm4, %xmm0
+;   por %xmm2, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
diff --git a/cranelift/filetests/filetests/isa/x64/simd-bitwise-compile.clif b/cranelift/filetests/filetests/isa/x64/simd-bitwise-compile.clif
index b1ed1466069f..c0ec635df5da 100644
--- a/cranelift/filetests/filetests/isa/x64/simd-bitwise-compile.clif
+++ b/cranelift/filetests/filetests/isa/x64/simd-bitwise-compile.clif
@@ -236,10 +236,9 @@ block0(v0: i16x8, v1: i16x8, v2: i16x8):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movdqa  %xmm1, %xmm4
-;   pand    %xmm4, %xmm0, %xmm4
+;   pand    %xmm1, %xmm0, %xmm1
 ;   pandn   %xmm0, %xmm2, %xmm0
-;   por     %xmm0, %xmm4, %xmm0
+;   por     %xmm0, %xmm1, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -249,10 +248,9 @@ block0(v0: i16x8, v1: i16x8, v2: i16x8):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movdqa %xmm1, %xmm4
-;   pand %xmm0, %xmm4
+;   pand %xmm0, %xmm1
 ;   pandn %xmm2, %xmm0
-;   por %xmm4, %xmm0
+;   por %xmm1, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -267,10 +265,9 @@ block0(v0: f32x4, v1: f32x4, v2: f32x4):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movdqa  %xmm1, %xmm4
-;   andps   %xmm4, %xmm0, %xmm4
+;   andps   %xmm1, %xmm0, %xmm1
 ;   andnps  %xmm0, %xmm2, %xmm0
-;   orps    %xmm0, %xmm4, %xmm0
+;   orps    %xmm0, %xmm1, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -280,10 +277,9 @@ block0(v0: f32x4, v1: f32x4, v2: f32x4):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movdqa %xmm1, %xmm4
-;   andps %xmm0, %xmm4
+;   andps %xmm0, %xmm1
 ;   andnps %xmm2, %xmm0
-;   orps %xmm4, %xmm0
+;   orps %xmm1, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -298,10 +294,9 @@ block0(v0: f64x2, v1: f64x2, v2: f64x2):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movdqa  %xmm1, %xmm4
-;   andpd   %xmm4, %xmm0, %xmm4
+;   andpd   %xmm1, %xmm0, %xmm1
 ;   andnpd  %xmm0, %xmm2, %xmm0
-;   orpd    %xmm0, %xmm4, %xmm0
+;   orpd    %xmm0, %xmm1, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -311,10 +306,9 @@ block0(v0: f64x2, v1: f64x2, v2: f64x2):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movdqa %xmm1, %xmm4
-;   andpd %xmm0, %xmm4
+;   andpd %xmm0, %xmm1
 ;   andnpd %xmm2, %xmm0
-;   orpd %xmm4, %xmm0
+;   orpd %xmm1, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -331,13 +325,12 @@ block0(v0: i32):
 ;   movq    %rsp, %rbp
 ; block0:
 ;   movdqu  const(1), %xmm0
-;   movq    %rdi, %r10
-;   andq    %r10, $7, %r10
-;   movd    %r10d, %xmm5
+;   andq    %rdi, $7, %rdi
+;   movd    %edi, %xmm5
 ;   psllw   %xmm0, %xmm5, %xmm0
 ;   lea     const(0), %rsi
-;   shlq    $4, %r10, %r10
-;   movdqu  0(%rsi,%r10,1), %xmm5
+;   shlq    $4, %rdi, %rdi
+;   movdqu  0(%rsi,%rdi,1), %xmm5
 ;   pand    %xmm0, %xmm5, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -349,13 +342,12 @@ block0(v0: i32):
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
 ;   movdqu 0x34(%rip), %xmm0
-;   movq %rdi, %r10
-;   andq $7, %r10
-;   movd %r10d, %xmm5
+;   andq $7, %rdi
+;   movd %edi, %xmm5
 ;   psllw %xmm5, %xmm0
-;   leaq 0x2d(%rip), %rsi
-;   shlq $4, %r10
-;   movdqu (%rsi, %r10), %xmm5
+;   leaq 0x31(%rip), %rsi
+;   shlq $4, %rdi
+;   movdqu (%rsi, %rdi), %xmm5
 ;   pand %xmm5, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -365,9 +357,13 @@ block0(v0: i32):
 ;   addb %al, (%rax)
 ;   addb %al, (%rax)
 ;   addb %al, (%rax)
-;   addb %al, (%rcx)
-;   addb (%rbx), %al
-;   addb $5, %al
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addl %eax, (%rdx)
+;   addl 0x9080706(, %rax), %eax
+;   orb (%rbx), %cl
+;   orb $0xd, %al
 
 function %ishl_i8x16_imm(i8x16) -> i8x16 {
 block0(v0: i8x16):
@@ -605,13 +601,12 @@ block0(v0: i32):
 ;   movq    %rsp, %rbp
 ; block0:
 ;   movdqu  const(0), %xmm1
-;   movq    %rdi, %r9
-;   andq    %r9, $7, %r9
+;   andq    %rdi, $7, %rdi
 ;   movdqa  %xmm1, %xmm0
 ;   punpcklbw %xmm0, %xmm1, %xmm0
 ;   punpckhbw %xmm1, %xmm1, %xmm1
-;   addl    %r9d, $8, %r9d
-;   movd    %r9d, %xmm3
+;   addl    %edi, $8, %edi
+;   movd    %edi, %xmm3
 ;   psraw   %xmm0, %xmm3, %xmm0
 ;   psraw   %xmm1, %xmm3, %xmm1
 ;   packsswb %xmm0, %xmm1, %xmm0
@@ -625,13 +620,12 @@ block0(v0: i32):
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
 ;   movdqu 0x34(%rip), %xmm1
-;   movq %rdi, %r9
-;   andq $7, %r9
+;   andq $7, %rdi
 ;   movdqa %xmm1, %xmm0
 ;   punpcklbw %xmm1, %xmm0
 ;   punpckhbw %xmm1, %xmm1
-;   addl $8, %r9d
-;   movd %r9d, %xmm3
+;   addl $8, %edi
+;   movd %edi, %xmm3
 ;   psraw %xmm3, %xmm0
 ;   psraw %xmm3, %xmm1
 ;   packsswb %xmm1, %xmm0
@@ -642,10 +636,11 @@ block0(v0: i32):
 ;   addb %al, (%rax)
 ;   addb %al, (%rax)
 ;   addb %al, (%rax)
-;   addl %eax, (%rdx)
-;   addl 0x9080706(, %rax), %eax
-;   orb (%rbx), %cl
-;   orb $0xd, %al
+;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rcx)
+;   addb (%rbx), %al
+;   addb $5, %al
 
 function %sshr_i8x16_imm(i8x16, i32) -> i8x16 {
 block0(v0: i8x16, v1: i32):
@@ -657,15 +652,14 @@ block0(v0: i8x16, v1: i32):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movdqa  %xmm0, %xmm7
-;   punpcklbw %xmm7, %xmm0, %xmm7
-;   movdqa  %xmm7, %xmm1
-;   movdqa  %xmm0, %xmm7
-;   punpckhbw %xmm7, %xmm0, %xmm7
-;   movdqa  %xmm1, %xmm0
+;   movdqa  %xmm0, %xmm6
+;   punpcklbw %xmm6, %xmm0, %xmm6
+;   punpckhbw %xmm0, %xmm0, %xmm0
+;   movdqa  %xmm0, %xmm4
+;   movdqa  %xmm6, %xmm0
 ;   psraw   %xmm0, $11, %xmm0
-;   psraw   %xmm7, $11, %xmm7
-;   packsswb %xmm0, %xmm7, %xmm0
+;   psraw   %xmm4, $11, %xmm4
+;   packsswb %xmm0, %xmm4, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -675,15 +669,14 @@ block0(v0: i8x16, v1: i32):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movdqa %xmm0, %xmm7
-;   punpcklbw %xmm0, %xmm7
-;   movdqa %xmm7, %xmm1
-;   movdqa %xmm0, %xmm7
-;   punpckhbw %xmm0, %xmm7
-;   movdqa %xmm1, %xmm0
+;   movdqa %xmm0, %xmm6
+;   punpcklbw %xmm0, %xmm6
+;   punpckhbw %xmm0, %xmm0
+;   movdqa %xmm0, %xmm4
+;   movdqa %xmm6, %xmm0
 ;   psraw $0xb, %xmm0
-;   psraw $0xb, %xmm7
-;   packsswb %xmm7, %xmm0
+;   psraw $0xb, %xmm4
+;   packsswb %xmm4, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -754,9 +747,8 @@ block0(v0: i64x2):
 ;   movdqa  %xmm0, %xmm2
 ;   psrad   %xmm2, $1, %xmm2
 ;   pshufd  $237, %xmm2, %xmm4
-;   movdqa  %xmm0, %xmm6
-;   psrlq   %xmm6, $1, %xmm6
-;   pshufd  $232, %xmm6, %xmm0
+;   psrlq   %xmm0, $1, %xmm0
+;   pshufd  $232, %xmm0, %xmm0
 ;   punpckldq %xmm0, %xmm4, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -770,9 +762,8 @@ block0(v0: i64x2):
 ;   movdqa %xmm0, %xmm2
 ;   psrad $1, %xmm2
 ;   pshufd $0xed, %xmm2, %xmm4
-;   movdqa %xmm0, %xmm6
-;   psrlq $1, %xmm6
-;   pshufd $0xe8, %xmm6, %xmm0
+;   psrlq $1, %xmm0
+;   pshufd $0xe8, %xmm0, %xmm0
 ;   punpckldq %xmm4, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -790,9 +781,8 @@ block0(v0: i64x2):
 ;   movq    %rsp, %rbp
 ; block0:
 ;   pshufd  $237, %xmm0, %xmm5
-;   movdqa  %xmm0, %xmm4
-;   psrad   %xmm4, $31, %xmm4
-;   pshufd  $237, %xmm4, %xmm6
+;   psrad   %xmm0, $31, %xmm0
+;   pshufd  $237, %xmm0, %xmm6
 ;   movdqa  %xmm5, %xmm0
 ;   punpckldq %xmm0, %xmm6, %xmm0
 ;   movq    %rbp, %rsp
@@ -805,9 +795,8 @@ block0(v0: i64x2):
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
 ;   pshufd $0xed, %xmm0, %xmm5
-;   movdqa %xmm0, %xmm4
-;   psrad $0x1f, %xmm4
-;   pshufd $0xed, %xmm4, %xmm6
+;   psrad $0x1f, %xmm0
+;   pshufd $0xed, %xmm0, %xmm6
 ;   movdqa %xmm5, %xmm0
 ;   punpckldq %xmm6, %xmm0
 ;   movq %rbp, %rsp
@@ -828,9 +817,8 @@ block0(v0: i64x2):
 ;   movdqa  %xmm0, %xmm2
 ;   psrad   %xmm2, $31, %xmm2
 ;   pshufd  $237, %xmm2, %xmm4
-;   movdqa  %xmm0, %xmm6
-;   psrad   %xmm6, $22, %xmm6
-;   pshufd  $237, %xmm6, %xmm0
+;   psrad   %xmm0, $22, %xmm0
+;   pshufd  $237, %xmm0, %xmm0
 ;   punpckldq %xmm0, %xmm4, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -844,9 +832,8 @@ block0(v0: i64x2):
 ;   movdqa %xmm0, %xmm2
 ;   psrad $0x1f, %xmm2
 ;   pshufd $0xed, %xmm2, %xmm4
-;   movdqa %xmm0, %xmm6
-;   psrad $0x16, %xmm6
-;   pshufd $0xed, %xmm6, %xmm0
+;   psrad $0x16, %xmm0
+;   pshufd $0xed, %xmm0, %xmm0
 ;   punpckldq %xmm4, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -866,9 +853,8 @@ block0(v0: i64x2):
 ;   movdqa  %xmm0, %xmm2
 ;   psrad   %xmm2, $31, %xmm2
 ;   pshufd  $237, %xmm2, %xmm4
-;   movdqa  %xmm0, %xmm6
-;   psrad   %xmm6, $4, %xmm6
-;   pshufd  $237, %xmm6, %xmm0
+;   psrad   %xmm0, $4, %xmm0
+;   pshufd  $237, %xmm0, %xmm0
 ;   punpckldq %xmm0, %xmm4, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -882,9 +868,8 @@ block0(v0: i64x2):
 ;   movdqa %xmm0, %xmm2
 ;   psrad $0x1f, %xmm2
 ;   pshufd $0xed, %xmm2, %xmm4
-;   movdqa %xmm0, %xmm6
-;   psrad $4, %xmm6
-;   pshufd $0xed, %xmm6, %xmm0
+;   psrad $4, %xmm0
+;   pshufd $0xed, %xmm0, %xmm0
 ;   punpckldq %xmm4, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -900,15 +885,14 @@ block0(v0: i64x2, v1: i32):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rdi, %rcx
-;   andq    %rcx, $63, %rcx
-;   movq    %rcx, %xmm5
+;   andq    %rdi, $63, %rdi
+;   movq    %rdi, %xmm5
 ;   movdqu  const(0), %xmm1
 ;   psrlq   %xmm1, %xmm5, %xmm1
-;   movdqa  %xmm0, %xmm3
-;   psrlq   %xmm3, %xmm5, %xmm3
+;   psrlq   %xmm0, %xmm5, %xmm0
+;   movdqa  %xmm0, %xmm7
 ;   movdqa  %xmm1, %xmm0
-;   pxor    %xmm0, %xmm3, %xmm0
+;   pxor    %xmm0, %xmm7, %xmm0
 ;   psubq   %xmm0, %xmm1, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -919,15 +903,14 @@ block0(v0: i64x2, v1: i32):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rdi, %rcx
-;   andq $0x3f, %rcx
-;   movq %rcx, %xmm5
-;   movdqu 0x28(%rip), %xmm1
+;   andq $0x3f, %rdi
+;   movq %rdi, %xmm5
+;   movdqu 0x2b(%rip), %xmm1
 ;   psrlq %xmm5, %xmm1
-;   movdqa %xmm0, %xmm3
-;   psrlq %xmm5, %xmm3
+;   psrlq %xmm5, %xmm0
+;   movdqa %xmm0, %xmm7
 ;   movdqa %xmm1, %xmm0
-;   pxor %xmm3, %xmm0
+;   pxor %xmm7, %xmm0
 ;   psubq %xmm1, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -941,7 +924,7 @@ block0(v0: i64x2, v1: i32):
 ;   addb %al, (%rax)
 ;   addb %al, (%rax)
 ;   addb %al, (%rax)
-;   addb $0, (%rax)
+;   addb %al, (%rax)
 ;   addb %al, (%rax)
 ;   addb %al, (%rax)
 
diff --git a/cranelift/filetests/filetests/isa/x64/simd-float-min-max.clif b/cranelift/filetests/filetests/isa/x64/simd-float-min-max.clif
new file mode 100644
index 000000000000..6294479465ce
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/simd-float-min-max.clif
@@ -0,0 +1,187 @@
+test compile precise-output
+target x86_64 sse41
+
+function %fmax_f32x4(i64, f32x4) -> f32x4 {
+block0(v0: i64, v1: f32x4):
+    v2 = load.f32x4 v0
+    v3 = fmax v1, v2
+    return v3
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movups  0(%rdi), %xmm4
+;   movdqa  %xmm0, %xmm6
+;   maxps   %xmm0, %xmm4, %xmm0
+;   maxps   %xmm4, %xmm6, %xmm4
+;   movdqa  %xmm0, %xmm1
+;   xorps   %xmm1, %xmm4, %xmm1
+;   orps    %xmm0, %xmm1, %xmm0
+;   movdqa  %xmm0, %xmm4
+;   subps   %xmm4, %xmm1, %xmm4
+;   cmpps   $3, %xmm0, %xmm0, %xmm0
+;   psrld   %xmm0, $10, %xmm0
+;   andnps  %xmm0, %xmm4, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movups (%rdi), %xmm4 ; trap: heap_oob
+;   movdqa %xmm0, %xmm6
+;   maxps %xmm4, %xmm0
+;   maxps %xmm6, %xmm4
+;   movdqa %xmm0, %xmm1
+;   xorps %xmm4, %xmm1
+;   orps %xmm1, %xmm0
+;   movdqa %xmm0, %xmm4
+;   subps %xmm1, %xmm4
+;   cmpunordps %xmm0, %xmm0
+;   psrld $0xa, %xmm0
+;   andnps %xmm4, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %fmin_f32x4(i64, f32x4) -> f32x4 {
+block0(v0: i64, v1: f32x4):
+    v2 = load.f32x4 v0
+    v3 = fmin v1, v2
+    return v3
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movups  0(%rdi), %xmm4
+;   movdqa  %xmm0, %xmm1
+;   minps   %xmm1, %xmm4, %xmm1
+;   minps   %xmm4, %xmm0, %xmm4
+;   orps    %xmm1, %xmm4, %xmm1
+;   movdqa  %xmm1, %xmm0
+;   cmpps   $3, %xmm0, %xmm4, %xmm0
+;   orps    %xmm1, %xmm0, %xmm1
+;   psrld   %xmm0, $10, %xmm0
+;   andnps  %xmm0, %xmm1, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movups (%rdi), %xmm4 ; trap: heap_oob
+;   movdqa %xmm0, %xmm1
+;   minps %xmm4, %xmm1
+;   minps %xmm0, %xmm4
+;   orps %xmm4, %xmm1
+;   movdqa %xmm1, %xmm0
+;   cmpunordps %xmm4, %xmm0
+;   orps %xmm0, %xmm1
+;   psrld $0xa, %xmm0
+;   andnps %xmm1, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %fmax_f64x2(i64, f64x2) -> f64x2 {
+block0(v0: i64, v1: f64x2):
+    v2 = load.f64x2 v0
+    v3 = fmax v1, v2
+    return v3
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movupd  0(%rdi), %xmm4
+;   movdqa  %xmm0, %xmm6
+;   maxpd   %xmm0, %xmm4, %xmm0
+;   maxpd   %xmm4, %xmm6, %xmm4
+;   movdqa  %xmm0, %xmm1
+;   xorpd   %xmm1, %xmm4, %xmm1
+;   orpd    %xmm0, %xmm1, %xmm0
+;   movdqa  %xmm0, %xmm4
+;   subpd   %xmm4, %xmm1, %xmm4
+;   cmppd   $3, %xmm0, %xmm0, %xmm0
+;   psrlq   %xmm0, $13, %xmm0
+;   andnpd  %xmm0, %xmm4, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movupd (%rdi), %xmm4 ; trap: heap_oob
+;   movdqa %xmm0, %xmm6
+;   maxpd %xmm4, %xmm0
+;   maxpd %xmm6, %xmm4
+;   movdqa %xmm0, %xmm1
+;   xorpd %xmm4, %xmm1
+;   orpd %xmm1, %xmm0
+;   movdqa %xmm0, %xmm4
+;   subpd %xmm1, %xmm4
+;   cmpunordpd %xmm0, %xmm0
+;   psrlq $0xd, %xmm0
+;   andnpd %xmm4, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %fmin_f64x2(i64, f64x2) -> f64x2 {
+block0(v0: i64, v1: f64x2):
+    v2 = load.f64x2 v0
+    v3 = fmin v1, v2
+    return v3
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movupd  0(%rdi), %xmm4
+;   movdqa  %xmm0, %xmm5
+;   minpd   %xmm0, %xmm4, %xmm0
+;   minpd   %xmm4, %xmm5, %xmm4
+;   movdqa  %xmm0, %xmm2
+;   orpd    %xmm2, %xmm4, %xmm2
+;   cmppd   $3, %xmm0, %xmm4, %xmm0
+;   orpd    %xmm2, %xmm0, %xmm2
+;   psrlq   %xmm0, $13, %xmm0
+;   andnpd  %xmm0, %xmm2, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movupd (%rdi), %xmm4 ; trap: heap_oob
+;   movdqa %xmm0, %xmm5
+;   minpd %xmm4, %xmm0
+;   minpd %xmm5, %xmm4
+;   movdqa %xmm0, %xmm2
+;   orpd %xmm4, %xmm2
+;   cmpunordpd %xmm4, %xmm0
+;   orpd %xmm0, %xmm2
+;   psrlq $0xd, %xmm0
+;   andnpd %xmm2, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/simd-i64x2-mul-avx512.clif b/cranelift/filetests/filetests/isa/x64/simd-i64x2-mul-avx512.clif
new file mode 100644
index 000000000000..6f0e6dbc8563
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/simd-i64x2-mul-avx512.clif
@@ -0,0 +1,33 @@
+test compile precise-output
+target x86_64 sse42 has_avx has_avx2 has_avx512dq has_avx512vl
+
+function %imul(i64x2, i64x2) -> i64x2, i64x2 {
+block0(v0: i64x2, v1: i64x2):
+  ;; Force register allocation to pick a different destination than
+  ;; source for at least one of these instructions.
+  v2 = imul v0, v1
+  v3 = imul v2, v1
+  return v2, v3
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   vpmullq %xmm1, %xmm0, %xmm0
+;   vpmullq %xmm1, %xmm0, %xmm1
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   vpmullq %xmm1, %xmm0, %xmm0
+;   vpmullq %xmm1, %xmm0, %xmm1
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/simd-i64x2-shift-avx512.clif b/cranelift/filetests/filetests/isa/x64/simd-i64x2-shift-avx512.clif
index 8730dee0e2d5..d7a6796b9138 100644
--- a/cranelift/filetests/filetests/isa/x64/simd-i64x2-shift-avx512.clif
+++ b/cranelift/filetests/filetests/isa/x64/simd-i64x2-shift-avx512.clif
@@ -1,20 +1,26 @@
 test compile precise-output
 target x86_64 sse42 has_avx has_avx2 has_avx512f has_avx512vl
 
-function %sshr(i64x2, i64) -> i64x2 {
+function %sshr(i64x2, i64) -> i64x2, i64x2 {
 block0(v0: i64x2, v1: i64):
+  ;; Force register allocation to pick a different destination than
+  ;; source for at least one of these instructions.
   v2 = sshr v0, v1
-  return v2
+  v3 = sshr v2, v1
+  return v2, v3
 }
 
 ; VCode:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rdi, %rcx
-;   andq    %rcx, $63, %rcx
-;   vmovd   %ecx, %xmm5
-;   vpsraq  %xmm5, %xmm0, %xmm0
+;   movq    %rdi, %r9
+;   andq    %r9, $63, %r9
+;   vmovd   %r9d, %xmm1
+;   vpsraq  %xmm1, %xmm0, %xmm0
+;   andq    %rdi, $63, %rdi
+;   vmovd   %edi, %xmm1
+;   vpsraq  %xmm1, %xmm0, %xmm1
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -24,10 +30,13 @@ block0(v0: i64x2, v1: i64):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rdi, %rcx
-;   andq $0x3f, %rcx
-;   vmovd %ecx, %xmm5
-;   vpsraq %xmm5, %xmm0, %xmm0
+;   movq %rdi, %r9
+;   andq $0x3f, %r9
+;   vmovd %r9d, %xmm1
+;   vpsraq %xmm1, %xmm0, %xmm0
+;   andq $0x3f, %rdi
+;   vmovd %edi, %xmm1
+;   vpsraq %xmm1, %xmm0, %xmm1
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
diff --git a/cranelift/filetests/filetests/isa/x64/simd-lane-access-compile.clif b/cranelift/filetests/filetests/isa/x64/simd-lane-access-compile.clif
index 3331c776586c..e97c4c5e8504 100644
--- a/cranelift/filetests/filetests/isa/x64/simd-lane-access-compile.clif
+++ b/cranelift/filetests/filetests/isa/x64/simd-lane-access-compile.clif
@@ -15,11 +15,12 @@ block0:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movdqu  const(3), %xmm0
-;   movdqu  const(2), %xmm2
+;   uninit  %xmm0
+;   pxor    %xmm0, %xmm0, %xmm0
+;   movdqu  const(2), %xmm3
 ;   pshufb  %xmm0, const(0), %xmm0
-;   pshufb  %xmm2, const(1), %xmm2
-;   por     %xmm0, %xmm2, %xmm0
+;   pshufb  %xmm3, const(1), %xmm3
+;   por     %xmm0, %xmm3, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -29,22 +30,16 @@ block0:
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movdqu 0x24(%rip), %xmm0
-;   movdqu 0x2c(%rip), %xmm2
-;   pshufb 0x33(%rip), %xmm0
-;   pshufb 0x3a(%rip), %xmm2
-;   por %xmm2, %xmm0
+;   pxor %xmm0, %xmm0
+;   movdqu 0x20(%rip), %xmm3
+;   pshufb 0x27(%rip), %xmm0
+;   pshufb 0x2e(%rip), %xmm3
+;   por %xmm3, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
 ;   addb %al, (%rax)
 ;   addb %al, (%rax)
-;   addb %al, (%rax)
-;   addb %al, (%rax)
-;   addb %al, (%rax)
-;   addb %al, (%rax)
-;   addb %al, (%rax)
-;   addb %al, (%rax)
 ;   addb %al, (%rcx)
 ;   addb %al, (%rax)
 ;   addb %al, (%rax)
@@ -340,3 +335,135 @@ block0(v0: f32):
 ;   popq %rbp
 ;   retq
 
+
+
+function %load32_lane_coalesced(i64, i32x4) -> i32x4 {
+block0(v0: i64, v1: i32x4):
+    v2 = load.i32 v0
+    v3 = insertlane.i32x4 v1, v2, 3
+    return v3
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   pinsrd  $3, %xmm0, 0(%rdi), %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   pinsrd $3, (%rdi), %xmm0 ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %load16_lane_coalesced(i64, i16x8) -> i16x8 {
+block0(v0: i64, v1: i16x8):
+    v2 = load.i16 v0
+    v3 = insertlane.i16x8 v1, v2, 3
+    return v3
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   pinsrw  $3, %xmm0, 0(%rdi), %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   pinsrw $3, (%rdi), %xmm0 ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %load8_lane_coalesced(i64, i8x16) -> i8x16 {
+block0(v0: i64, v1: i8x16):
+    v2 = load.i8 v0
+    v3 = insertlane.i8x16 v1, v2, 3
+    return v3
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   pinsrb  $3, %xmm0, 0(%rdi), %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   pinsrb $3, (%rdi), %xmm0 ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %store32_lane_coalesced(i64, i32x4) {
+block0(v0: i64, v1: i32x4):
+    v2 = extractlane.i32x4 v1, 3
+    store.i32 v2, v0
+    return
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   pextrd  $3, %xmm0, 0(%rdi)
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   pextrd $3, %xmm0, (%rdi) ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %store8_lane_coalesced(i64, i16x8) {
+block0(v0: i64, v1: i16x8):
+    v2 = extractlane.i16x8 v1, 3
+    store.i16 v2, v0
+    return
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   pextrw  $3, %xmm0, 0(%rdi)
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   pextrw $3, %xmm0, (%rdi) ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/simd-logical-compile-avx.clif b/cranelift/filetests/filetests/isa/x64/simd-logical-compile-avx.clif
new file mode 100644
index 000000000000..f30b20acc453
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/simd-logical-compile-avx.clif
@@ -0,0 +1,62 @@
+test compile precise-output
+target x86_64 sse42 has_avx
+
+function %vany_true_i32x4(i32x4) -> i8 {
+block0(v0: i32x4):
+    v1 = vany_true v0
+    return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   vptest  %xmm0, %xmm0
+;   setnz   %al
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   vptest %xmm0, %xmm0
+;   setne %al
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %vall_true_i64x2(i64x2) -> i8 {
+block0(v0: i64x2):
+    v1 = vall_true v0
+    return v1
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   uninit  %xmm2
+;   vpxor   %xmm2, %xmm2, %xmm4
+;   vpcmpeqq %xmm0, %xmm4, %xmm6
+;   vptest  %xmm6, %xmm6
+;   setz    %al
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   vpxor %xmm2, %xmm2, %xmm4
+;   vpcmpeqq %xmm4, %xmm0, %xmm6
+;   vptest %xmm6, %xmm6
+;   sete %al
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/simd-logical-compile.clif b/cranelift/filetests/filetests/isa/x64/simd-logical-compile.clif
index e9df78d5fd82..0e95a11aa374 100644
--- a/cranelift/filetests/filetests/isa/x64/simd-logical-compile.clif
+++ b/cranelift/filetests/filetests/isa/x64/simd-logical-compile.clif
@@ -68,9 +68,8 @@ block0(v0: i64x2):
 ; block0:
 ;   uninit  %xmm3
 ;   pxor    %xmm3, %xmm3, %xmm3
-;   movdqa  %xmm0, %xmm6
-;   pcmpeqq %xmm6, %xmm3, %xmm6
-;   ptest   %xmm6, %xmm6
+;   pcmpeqq %xmm0, %xmm3, %xmm0
+;   ptest   %xmm0, %xmm0
 ;   setz    %al
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -82,9 +81,8 @@ block0(v0: i64x2):
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
 ;   pxor %xmm3, %xmm3
-;   movdqa %xmm0, %xmm6
-;   pcmpeqq %xmm3, %xmm6
-;   ptest %xmm6, %xmm6
+;   pcmpeqq %xmm3, %xmm0
+;   ptest %xmm0, %xmm0
 ;   sete %al
 ;   movq %rbp, %rsp
 ;   popq %rbp
diff --git a/cranelift/filetests/filetests/isa/x64/simd-make-vectors-avx.clif b/cranelift/filetests/filetests/isa/x64/simd-make-vectors-avx.clif
new file mode 100644
index 000000000000..a4cf9d705a5a
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/simd-make-vectors-avx.clif
@@ -0,0 +1,86 @@
+test compile precise-output
+target x86_64 sse42 has_avx
+
+function %i64x2_make0() -> i64x2 {
+block0:
+    v0 = vconst.i64x2 [0 0]
+    return v0
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   uninit  %xmm0
+;   vpxor   %xmm0, %xmm0, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   vpxor %xmm0, %xmm0, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %i64x2_make1(i64) -> i64x2 {
+block0(v0: i64):
+    v1 = vconst.i64x2 [0 0]
+    v2 = insertlane.i64x2 v1, v0, 0
+    return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   uninit  %xmm3
+;   vpxor   %xmm3, %xmm3, %xmm5
+;   vpinsrq $0, %xmm5, %rdi, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   vpxor %xmm3, %xmm3, %xmm5
+;   vpinsrq $0, %rdi, %xmm5, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %i64x2_make2(i64, i64) -> i64x2 {
+block0(v0: i64, v1: i64):
+    v2 = splat.i64x2 v0
+    v3 = insertlane.i64x2 v2, v1, 1
+    return v3
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   vmovq   %rdi, %xmm3
+;   vpinsrq $1, %xmm3, %rsi, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   vmovq %rdi, %xmm3
+;   vpinsrq $1, %rsi, %xmm3, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/simd-make-vectors.clif b/cranelift/filetests/filetests/isa/x64/simd-make-vectors.clif
new file mode 100644
index 000000000000..209c8fc56d9d
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/simd-make-vectors.clif
@@ -0,0 +1,86 @@
+test compile precise-output
+target x86_64 sse42
+
+function %i64x2_make0() -> i64x2 {
+block0:
+    v0 = vconst.i64x2 [0 0]
+    return v0
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   uninit  %xmm0
+;   pxor    %xmm0, %xmm0, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   pxor %xmm0, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %i64x2_make1(i64) -> i64x2 {
+block0(v0: i64):
+    v1 = vconst.i64x2 [0 0]
+    v2 = insertlane.i64x2 v1, v0, 0
+    return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   uninit  %xmm0
+;   pxor    %xmm0, %xmm0, %xmm0
+;   pinsrd.w $0, %xmm0, %rdi, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   pxor %xmm0, %xmm0
+;   pinsrq $0, %rdi, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %i64x2_make2(i64, i64) -> i64x2 {
+block0(v0: i64, v1: i64):
+    v2 = splat.i64x2 v0
+    v3 = insertlane.i64x2 v2, v1, 1
+    return v3
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movq    %rdi, %xmm0
+;   pinsrd.w $1, %xmm0, %rsi, %xmm0
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movq %rdi, %xmm0
+;   pinsrq $1, %rsi, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/simd-widen-mul.clif b/cranelift/filetests/filetests/isa/x64/simd-widen-mul.clif
index 4890d8bc4f75..69a43c63bc7f 100644
--- a/cranelift/filetests/filetests/isa/x64/simd-widen-mul.clif
+++ b/cranelift/filetests/filetests/isa/x64/simd-widen-mul.clif
@@ -13,12 +13,10 @@ block0(v0: i8x16, v1: i8x16):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movdqa  %xmm0, %xmm6
-;   palignr $8, %xmm6, %xmm0, %xmm6
-;   pmovsxbw %xmm6, %xmm0
-;   movdqa  %xmm1, %xmm6
-;   palignr $8, %xmm6, %xmm1, %xmm6
-;   pmovsxbw %xmm6, %xmm1
+;   palignr $8, %xmm0, %xmm0, %xmm0
+;   pmovsxbw %xmm0, %xmm0
+;   palignr $8, %xmm1, %xmm1, %xmm1
+;   pmovsxbw %xmm1, %xmm1
 ;   pmullw  %xmm0, %xmm1, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -29,12 +27,10 @@ block0(v0: i8x16, v1: i8x16):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movdqa %xmm0, %xmm6
-;   palignr $8, %xmm0, %xmm6
-;   pmovsxbw %xmm6, %xmm0
-;   movdqa %xmm1, %xmm6
-;   palignr $8, %xmm1, %xmm6
-;   pmovsxbw %xmm6, %xmm1
+;   palignr $8, %xmm0, %xmm0
+;   pmovsxbw %xmm0, %xmm0
+;   palignr $8, %xmm1, %xmm1
+;   pmovsxbw %xmm1, %xmm1
 ;   pmullw %xmm1, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -54,11 +50,10 @@ block0(v0: i16x8, v1: i16x8):
 ; block0:
 ;   movdqa  %xmm0, %xmm5
 ;   pmullw  %xmm5, %xmm1, %xmm5
-;   movdqa  %xmm5, %xmm6
-;   movdqa  %xmm0, %xmm5
-;   pmulhw  %xmm5, %xmm1, %xmm5
-;   movdqa  %xmm6, %xmm0
-;   punpckhwd %xmm0, %xmm5, %xmm0
+;   pmulhw  %xmm0, %xmm1, %xmm0
+;   movdqa  %xmm0, %xmm2
+;   movdqa  %xmm5, %xmm0
+;   punpckhwd %xmm0, %xmm2, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -70,11 +65,10 @@ block0(v0: i16x8, v1: i16x8):
 ; block1: ; offset 0x4
 ;   movdqa %xmm0, %xmm5
 ;   pmullw %xmm1, %xmm5
-;   movdqa %xmm5, %xmm6
-;   movdqa %xmm0, %xmm5
-;   pmulhw %xmm1, %xmm5
-;   movdqa %xmm6, %xmm0
-;   punpckhwd %xmm5, %xmm0
+;   pmulhw %xmm1, %xmm0
+;   movdqa %xmm0, %xmm2
+;   movdqa %xmm5, %xmm0
+;   punpckhwd %xmm2, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -155,11 +149,10 @@ block0(v0: i16x8, v1: i16x8):
 ; block0:
 ;   movdqa  %xmm0, %xmm5
 ;   pmullw  %xmm5, %xmm1, %xmm5
-;   movdqa  %xmm5, %xmm6
-;   movdqa  %xmm0, %xmm5
-;   pmulhw  %xmm5, %xmm1, %xmm5
-;   movdqa  %xmm6, %xmm0
-;   punpcklwd %xmm0, %xmm5, %xmm0
+;   pmulhw  %xmm0, %xmm1, %xmm0
+;   movdqa  %xmm0, %xmm2
+;   movdqa  %xmm5, %xmm0
+;   punpcklwd %xmm0, %xmm2, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -171,11 +164,10 @@ block0(v0: i16x8, v1: i16x8):
 ; block1: ; offset 0x4
 ;   movdqa %xmm0, %xmm5
 ;   pmullw %xmm1, %xmm5
-;   movdqa %xmm5, %xmm6
-;   movdqa %xmm0, %xmm5
-;   pmulhw %xmm1, %xmm5
-;   movdqa %xmm6, %xmm0
-;   punpcklwd %xmm5, %xmm0
+;   pmulhw %xmm1, %xmm0
+;   movdqa %xmm0, %xmm2
+;   movdqa %xmm5, %xmm0
+;   punpcklwd %xmm2, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -228,9 +220,8 @@ block0(v0: i8x16, v1: i8x16):
 ;   punpckhbw %xmm0, %xmm2, %xmm0
 ;   uninit  %xmm2
 ;   pxor    %xmm2, %xmm2, %xmm2
-;   movdqa  %xmm1, %xmm3
-;   punpckhbw %xmm3, %xmm2, %xmm3
-;   pmullw  %xmm0, %xmm3, %xmm0
+;   punpckhbw %xmm1, %xmm2, %xmm1
+;   pmullw  %xmm0, %xmm1, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -243,9 +234,8 @@ block0(v0: i8x16, v1: i8x16):
 ;   pxor %xmm2, %xmm2
 ;   punpckhbw %xmm2, %xmm0
 ;   pxor %xmm2, %xmm2
-;   movdqa %xmm1, %xmm3
-;   punpckhbw %xmm2, %xmm3
-;   pmullw %xmm3, %xmm0
+;   punpckhbw %xmm2, %xmm1
+;   pmullw %xmm1, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -264,11 +254,10 @@ block0(v0: i16x8, v1: i16x8):
 ; block0:
 ;   movdqa  %xmm0, %xmm5
 ;   pmullw  %xmm5, %xmm1, %xmm5
-;   movdqa  %xmm5, %xmm6
-;   movdqa  %xmm0, %xmm5
-;   pmulhuw %xmm5, %xmm1, %xmm5
-;   movdqa  %xmm6, %xmm0
-;   punpckhwd %xmm0, %xmm5, %xmm0
+;   pmulhuw %xmm0, %xmm1, %xmm0
+;   movdqa  %xmm0, %xmm2
+;   movdqa  %xmm5, %xmm0
+;   punpckhwd %xmm0, %xmm2, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -280,11 +269,10 @@ block0(v0: i16x8, v1: i16x8):
 ; block1: ; offset 0x4
 ;   movdqa %xmm0, %xmm5
 ;   pmullw %xmm1, %xmm5
-;   movdqa %xmm5, %xmm6
-;   movdqa %xmm0, %xmm5
-;   pmulhuw %xmm1, %xmm5
-;   movdqa %xmm6, %xmm0
-;   punpckhwd %xmm5, %xmm0
+;   pmulhuw %xmm1, %xmm0
+;   movdqa %xmm0, %xmm2
+;   movdqa %xmm5, %xmm0
+;   punpckhwd %xmm2, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -365,11 +353,10 @@ block0(v0: i16x8, v1: i16x8):
 ; block0:
 ;   movdqa  %xmm0, %xmm5
 ;   pmullw  %xmm5, %xmm1, %xmm5
-;   movdqa  %xmm5, %xmm6
-;   movdqa  %xmm0, %xmm5
-;   pmulhuw %xmm5, %xmm1, %xmm5
-;   movdqa  %xmm6, %xmm0
-;   punpcklwd %xmm0, %xmm5, %xmm0
+;   pmulhuw %xmm0, %xmm1, %xmm0
+;   movdqa  %xmm0, %xmm2
+;   movdqa  %xmm5, %xmm0
+;   punpcklwd %xmm0, %xmm2, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -381,11 +368,10 @@ block0(v0: i16x8, v1: i16x8):
 ; block1: ; offset 0x4
 ;   movdqa %xmm0, %xmm5
 ;   pmullw %xmm1, %xmm5
-;   movdqa %xmm5, %xmm6
-;   movdqa %xmm0, %xmm5
-;   pmulhuw %xmm1, %xmm5
-;   movdqa %xmm6, %xmm0
-;   punpcklwd %xmm5, %xmm0
+;   pmulhuw %xmm1, %xmm0
+;   movdqa %xmm0, %xmm2
+;   movdqa %xmm5, %xmm0
+;   punpcklwd %xmm2, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
diff --git a/cranelift/filetests/filetests/isa/x64/sink-load-store-of-bitwise-op-on-float.clif b/cranelift/filetests/filetests/isa/x64/sink-load-store-of-bitwise-op-on-float.clif
new file mode 100644
index 000000000000..085868bda22e
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/sink-load-store-of-bitwise-op-on-float.clif
@@ -0,0 +1,177 @@
+test compile precise-output
+target x86_64
+
+function %bor0(i64, f32) {
+block0(v0: i64, v1: f32):
+    v2 = load.f32 v0
+    v3 = bor v1, v2
+    store v3, v0
+    return
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movd    %xmm0, %ecx
+;   orl     %ecx, 0(%rdi)
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movd %xmm0, %ecx
+;   orl %ecx, (%rdi) ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %bor1(i64, f32) {
+block0(v0: i64, v1: f32):
+    v2 = load.f32 v0
+    v3 = bor v2, v1
+    store v3, v0
+    return
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movd    %xmm0, %ecx
+;   orl     %ecx, 0(%rdi)
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movd %xmm0, %ecx
+;   orl %ecx, (%rdi) ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %band0(i64, f32) {
+block0(v0: i64, v1: f32):
+    v2 = load.f32 v0
+    v3 = band v1, v2
+    store v3, v0
+    return
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movd    %xmm0, %ecx
+;   andl    %ecx, 0(%rdi)
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movd %xmm0, %ecx
+;   andl %ecx, (%rdi) ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %band1(i64, f32) {
+block0(v0: i64, v1: f32):
+    v2 = load.f32 v0
+    v3 = band v2, v1
+    store v3, v0
+    return
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movd    %xmm0, %ecx
+;   andl    %ecx, 0(%rdi)
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movd %xmm0, %ecx
+;   andl %ecx, (%rdi) ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %bxor0(i64, f32) {
+block0(v0: i64, v1: f32):
+    v2 = load.f32 v0
+    v3 = bxor v1, v2
+    store v3, v0
+    return
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movd    %xmm0, %ecx
+;   xorl    %ecx, 0(%rdi)
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movd %xmm0, %ecx
+;   xorl %ecx, (%rdi) ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %bxor1(i64, f32) {
+block0(v0: i64, v1: f32):
+    v2 = load.f32 v0
+    v3 = bxor v2, v1
+    store v3, v0
+    return
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movd    %xmm0, %ecx
+;   xorl    %ecx, 0(%rdi)
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movd %xmm0, %ecx
+;   xorl %ecx, (%rdi) ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/smulhi.clif b/cranelift/filetests/filetests/isa/x64/smulhi.clif
index 25c6db99c8a2..92589c2f0cfa 100644
--- a/cranelift/filetests/filetests/isa/x64/smulhi.clif
+++ b/cranelift/filetests/filetests/isa/x64/smulhi.clif
@@ -1,6 +1,35 @@
 test compile precise-output
 target x86_64
 
+function %smulhi_i8(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+  v2 = smulhi v0, v1
+  return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movq    %rdi, %rax
+;   imulb   %al, %sil, %al
+;   sarw    $8, %ax, %ax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movq %rdi, %rax
+;   imulb %sil
+;   sarw $8, %ax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
 function %f1(i16, i16) -> i16 {
 block0(v0: i16, v1: i16):
   v2 = smulhi v0, v1
@@ -12,7 +41,7 @@ block0(v0: i16, v1: i16):
 ;   movq    %rsp, %rbp
 ; block0:
 ;   movq    %rdi, %rax
-;   imul    %ax, %si, %ax, %dx
+;   imulw   %ax, %si, %ax, %dx
 ;   movq    %rdx, %rax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -41,7 +70,7 @@ block0(v0: i32, v1: i32):
 ;   movq    %rsp, %rbp
 ; block0:
 ;   movq    %rdi, %rax
-;   imul    %eax, %esi, %eax, %edx
+;   imull   %eax, %esi, %eax, %edx
 ;   movq    %rdx, %rax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -70,7 +99,7 @@ block0(v0: i64, v1: i64):
 ;   movq    %rsp, %rbp
 ; block0:
 ;   movq    %rdi, %rax
-;   imul    %rax, %rsi, %rax, %rdx
+;   imulq   %rax, %rsi, %rax, %rdx
 ;   movq    %rdx, %rax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
diff --git a/cranelift/filetests/filetests/isa/x64/sshr.clif b/cranelift/filetests/filetests/isa/x64/sshr.clif
index 45d7d9af7624..b44ad0c35ed6 100644
--- a/cranelift/filetests/filetests/isa/x64/sshr.clif
+++ b/cranelift/filetests/filetests/isa/x64/sshr.clif
@@ -18,8 +18,7 @@ block0(v0: i128, v1: i8):
 ;   movq    %rsp, %rbp
 ; block0:
 ;   movzbq  %dl, %rcx
-;   movq    %rdi, %r8
-;   shrq    %cl, %r8, %r8
+;   shrq    %cl, %rdi, %rdi
 ;   movq    %rsi, %r10
 ;   sarq    %cl, %r10, %r10
 ;   movq    %rcx, %r11
@@ -31,12 +30,12 @@ block0(v0: i128, v1: i8):
 ;   xorq    %r11, %r11, %r11
 ;   testq   $127, %rax
 ;   cmovzq  %r11, %r9, %r9
-;   orq     %r8, %r9, %r8
-;   movq    %rsi, %rdx
-;   sarq    $63, %rdx, %rdx
+;   orq     %rdi, %r9, %rdi
+;   sarq    $63, %rsi, %rsi
 ;   testq   $64, %rax
 ;   movq    %r10, %rax
-;   cmovzq  %r8, %rax, %rax
+;   cmovzq  %rdi, %rax, %rax
+;   movq    %rsi, %rdx
 ;   cmovzq  %r10, %rdx, %rdx
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -48,8 +47,7 @@ block0(v0: i128, v1: i8):
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
 ;   movzbq %dl, %rcx
-;   movq %rdi, %r8
-;   shrq %cl, %r8
+;   shrq %cl, %rdi
 ;   movq %rsi, %r10
 ;   sarq %cl, %r10
 ;   movq %rcx, %r11
@@ -61,12 +59,12 @@ block0(v0: i128, v1: i8):
 ;   xorq %r11, %r11
 ;   testq $0x7f, %rax
 ;   cmoveq %r11, %r9
-;   orq %r9, %r8
-;   movq %rsi, %rdx
-;   sarq $0x3f, %rdx
+;   orq %r9, %rdi
+;   sarq $0x3f, %rsi
 ;   testq $0x40, %rax
 ;   movq %r10, %rax
-;   cmoveq %r8, %rax
+;   cmoveq %rdi, %rax
+;   movq %rsi, %rdx
 ;   cmoveq %r10, %rdx
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -84,25 +82,24 @@ block0(v0: i128, v1: i64):
 ; block0:
 ;   movq    %rdx, %rcx
 ;   movq    %rdx, %r10
-;   movq    %rdi, %r11
-;   shrq    %cl, %r11, %r11
+;   shrq    %cl, %rdi, %rdi
 ;   movq    %rsi, %r9
 ;   sarq    %cl, %r9, %r9
 ;   movq    %rcx, %r10
 ;   movl    $64, %ecx
-;   movq    %r10, %rdi
-;   subq    %rcx, %rdi, %rcx
+;   movq    %r10, %rax
+;   subq    %rcx, %rax, %rcx
 ;   movq    %rsi, %r8
 ;   shlq    %cl, %r8, %r8
 ;   xorq    %r10, %r10, %r10
-;   testq   $127, %rdi
+;   testq   $127, %rax
 ;   cmovzq  %r10, %r8, %r8
-;   orq     %r11, %r8, %r11
-;   movq    %rsi, %rdx
-;   sarq    $63, %rdx, %rdx
-;   testq   $64, %rdi
+;   orq     %rdi, %r8, %rdi
+;   sarq    $63, %rsi, %rsi
+;   testq   $64, %rax
 ;   movq    %r9, %rax
-;   cmovzq  %r11, %rax, %rax
+;   cmovzq  %rdi, %rax, %rax
+;   movq    %rsi, %rdx
 ;   cmovzq  %r9, %rdx, %rdx
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -115,25 +112,24 @@ block0(v0: i128, v1: i64):
 ; block1: ; offset 0x4
 ;   movq %rdx, %rcx
 ;   movq %rdx, %r10
-;   movq %rdi, %r11
-;   shrq %cl, %r11
+;   shrq %cl, %rdi
 ;   movq %rsi, %r9
 ;   sarq %cl, %r9
 ;   movq %rcx, %r10
 ;   movl $0x40, %ecx
-;   movq %r10, %rdi
-;   subq %rdi, %rcx
+;   movq %r10, %rax
+;   subq %rax, %rcx
 ;   movq %rsi, %r8
 ;   shlq %cl, %r8
 ;   xorq %r10, %r10
-;   testq $0x7f, %rdi
+;   testq $0x7f, %rax
 ;   cmoveq %r10, %r8
-;   orq %r8, %r11
-;   movq %rsi, %rdx
-;   sarq $0x3f, %rdx
-;   testq $0x40, %rdi
+;   orq %r8, %rdi
+;   sarq $0x3f, %rsi
+;   testq $0x40, %rax
 ;   movq %r9, %rax
-;   cmoveq %r11, %rax
+;   cmoveq %rdi, %rax
+;   movq %rsi, %rdx
 ;   cmoveq %r9, %rdx
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -151,25 +147,24 @@ block0(v0: i128, v1: i32):
 ; block0:
 ;   movq    %rdx, %rcx
 ;   movq    %rdx, %r10
-;   movq    %rdi, %r11
-;   shrq    %cl, %r11, %r11
+;   shrq    %cl, %rdi, %rdi
 ;   movq    %rsi, %r9
 ;   sarq    %cl, %r9, %r9
 ;   movq    %rcx, %r10
 ;   movl    $64, %ecx
-;   movq    %r10, %rdi
-;   subq    %rcx, %rdi, %rcx
+;   movq    %r10, %rax
+;   subq    %rcx, %rax, %rcx
 ;   movq    %rsi, %r8
 ;   shlq    %cl, %r8, %r8
 ;   xorq    %r10, %r10, %r10
-;   testq   $127, %rdi
+;   testq   $127, %rax
 ;   cmovzq  %r10, %r8, %r8
-;   orq     %r11, %r8, %r11
-;   movq    %rsi, %rdx
-;   sarq    $63, %rdx, %rdx
-;   testq   $64, %rdi
+;   orq     %rdi, %r8, %rdi
+;   sarq    $63, %rsi, %rsi
+;   testq   $64, %rax
 ;   movq    %r9, %rax
-;   cmovzq  %r11, %rax, %rax
+;   cmovzq  %rdi, %rax, %rax
+;   movq    %rsi, %rdx
 ;   cmovzq  %r9, %rdx, %rdx
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -182,25 +177,24 @@ block0(v0: i128, v1: i32):
 ; block1: ; offset 0x4
 ;   movq %rdx, %rcx
 ;   movq %rdx, %r10
-;   movq %rdi, %r11
-;   shrq %cl, %r11
+;   shrq %cl, %rdi
 ;   movq %rsi, %r9
 ;   sarq %cl, %r9
 ;   movq %rcx, %r10
 ;   movl $0x40, %ecx
-;   movq %r10, %rdi
-;   subq %rdi, %rcx
+;   movq %r10, %rax
+;   subq %rax, %rcx
 ;   movq %rsi, %r8
 ;   shlq %cl, %r8
 ;   xorq %r10, %r10
-;   testq $0x7f, %rdi
+;   testq $0x7f, %rax
 ;   cmoveq %r10, %r8
-;   orq %r8, %r11
-;   movq %rsi, %rdx
-;   sarq $0x3f, %rdx
-;   testq $0x40, %rdi
+;   orq %r8, %rdi
+;   sarq $0x3f, %rsi
+;   testq $0x40, %rax
 ;   movq %r9, %rax
-;   cmoveq %r11, %rax
+;   cmoveq %rdi, %rax
+;   movq %rsi, %rdx
 ;   cmoveq %r9, %rdx
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -218,25 +212,24 @@ block0(v0: i128, v1: i16):
 ; block0:
 ;   movq    %rdx, %rcx
 ;   movq    %rdx, %r10
-;   movq    %rdi, %r11
-;   shrq    %cl, %r11, %r11
+;   shrq    %cl, %rdi, %rdi
 ;   movq    %rsi, %r9
 ;   sarq    %cl, %r9, %r9
 ;   movq    %rcx, %r10
 ;   movl    $64, %ecx
-;   movq    %r10, %rdi
-;   subq    %rcx, %rdi, %rcx
+;   movq    %r10, %rax
+;   subq    %rcx, %rax, %rcx
 ;   movq    %rsi, %r8
 ;   shlq    %cl, %r8, %r8
 ;   xorq    %r10, %r10, %r10
-;   testq   $127, %rdi
+;   testq   $127, %rax
 ;   cmovzq  %r10, %r8, %r8
-;   orq     %r11, %r8, %r11
-;   movq    %rsi, %rdx
-;   sarq    $63, %rdx, %rdx
-;   testq   $64, %rdi
+;   orq     %rdi, %r8, %rdi
+;   sarq    $63, %rsi, %rsi
+;   testq   $64, %rax
 ;   movq    %r9, %rax
-;   cmovzq  %r11, %rax, %rax
+;   cmovzq  %rdi, %rax, %rax
+;   movq    %rsi, %rdx
 ;   cmovzq  %r9, %rdx, %rdx
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -249,25 +242,24 @@ block0(v0: i128, v1: i16):
 ; block1: ; offset 0x4
 ;   movq %rdx, %rcx
 ;   movq %rdx, %r10
-;   movq %rdi, %r11
-;   shrq %cl, %r11
+;   shrq %cl, %rdi
 ;   movq %rsi, %r9
 ;   sarq %cl, %r9
 ;   movq %rcx, %r10
 ;   movl $0x40, %ecx
-;   movq %r10, %rdi
-;   subq %rdi, %rcx
+;   movq %r10, %rax
+;   subq %rax, %rcx
 ;   movq %rsi, %r8
 ;   shlq %cl, %r8
 ;   xorq %r10, %r10
-;   testq $0x7f, %rdi
+;   testq $0x7f, %rax
 ;   cmoveq %r10, %r8
-;   orq %r8, %r11
-;   movq %rsi, %rdx
-;   sarq $0x3f, %rdx
-;   testq $0x40, %rdi
+;   orq %r8, %rdi
+;   sarq $0x3f, %rsi
+;   testq $0x40, %rax
 ;   movq %r9, %rax
-;   cmoveq %r11, %rax
+;   cmoveq %rdi, %rax
+;   movq %rsi, %rdx
 ;   cmoveq %r9, %rdx
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -285,25 +277,24 @@ block0(v0: i128, v1: i8):
 ; block0:
 ;   movq    %rdx, %rcx
 ;   movq    %rdx, %r10
-;   movq    %rdi, %r11
-;   shrq    %cl, %r11, %r11
+;   shrq    %cl, %rdi, %rdi
 ;   movq    %rsi, %r9
 ;   sarq    %cl, %r9, %r9
 ;   movq    %rcx, %r10
 ;   movl    $64, %ecx
-;   movq    %r10, %rdi
-;   subq    %rcx, %rdi, %rcx
+;   movq    %r10, %rax
+;   subq    %rcx, %rax, %rcx
 ;   movq    %rsi, %r8
 ;   shlq    %cl, %r8, %r8
 ;   xorq    %r10, %r10, %r10
-;   testq   $127, %rdi
+;   testq   $127, %rax
 ;   cmovzq  %r10, %r8, %r8
-;   orq     %r11, %r8, %r11
-;   movq    %rsi, %rdx
-;   sarq    $63, %rdx, %rdx
-;   testq   $64, %rdi
+;   orq     %rdi, %r8, %rdi
+;   sarq    $63, %rsi, %rsi
+;   testq   $64, %rax
 ;   movq    %r9, %rax
-;   cmovzq  %r11, %rax, %rax
+;   cmovzq  %rdi, %rax, %rax
+;   movq    %rsi, %rdx
 ;   cmovzq  %r9, %rdx, %rdx
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -316,25 +307,24 @@ block0(v0: i128, v1: i8):
 ; block1: ; offset 0x4
 ;   movq %rdx, %rcx
 ;   movq %rdx, %r10
-;   movq %rdi, %r11
-;   shrq %cl, %r11
+;   shrq %cl, %rdi
 ;   movq %rsi, %r9
 ;   sarq %cl, %r9
 ;   movq %rcx, %r10
 ;   movl $0x40, %ecx
-;   movq %r10, %rdi
-;   subq %rdi, %rcx
+;   movq %r10, %rax
+;   subq %rax, %rcx
 ;   movq %rsi, %r8
 ;   shlq %cl, %r8
 ;   xorq %r10, %r10
-;   testq $0x7f, %rdi
+;   testq $0x7f, %rax
 ;   cmoveq %r10, %r8
-;   orq %r8, %r11
-;   movq %rsi, %rdx
-;   sarq $0x3f, %rdx
-;   testq $0x40, %rdi
+;   orq %r8, %rdi
+;   sarq $0x3f, %rsi
+;   testq $0x40, %rax
 ;   movq %r9, %rax
-;   cmoveq %r11, %rax
+;   cmoveq %rdi, %rax
+;   movq %rsi, %rdx
 ;   cmoveq %r9, %rdx
 ;   movq %rbp, %rsp
 ;   popq %rbp
diff --git a/cranelift/filetests/filetests/isa/x64/stack_switch.clif b/cranelift/filetests/filetests/isa/x64/stack_switch.clif
new file mode 100644
index 000000000000..333e8668b05b
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/stack_switch.clif
@@ -0,0 +1,605 @@
+test compile precise-output
+set opt_level=speed
+set stack_switch_model=basic
+target x86_64
+
+;; Test code emitted for stack switch itself
+function %switch(i64, i64, i64) -> i64 {
+block0(v0: i64, v1: i64, v2: i64):
+  v3 = stack_switch v0, v1, v2
+  return v3
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+;   subq    %rsp, $48, %rsp
+;   movq    %rbx, 0(%rsp)
+;   movq    %r12, 8(%rsp)
+;   movq    %r13, 16(%rsp)
+;   movq    %r14, 24(%rsp)
+;   movq    %r15, 32(%rsp)
+; block0:
+;   movq    %rdi, %r10
+;   movq    %rdx, %rdi
+;   %rdi = stack_switch_basic %r10, %rsi, %rdi
+;   movq    %rdi, %rax
+;   movq    0(%rsp), %rbx
+;   movq    8(%rsp), %r12
+;   movq    16(%rsp), %r13
+;   movq    24(%rsp), %r14
+;   movq    32(%rsp), %r15
+;   addq    %rsp, $48, %rsp
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+;   subq $0x30, %rsp
+;   movq %rbx, (%rsp)
+;   movq %r12, 8(%rsp)
+;   movq %r13, 0x10(%rsp)
+;   movq %r14, 0x18(%rsp)
+;   movq %r15, 0x20(%rsp)
+; block1: ; offset 0x20
+;   movq %rdi, %r10
+;   movq %rdx, %rdi
+;   movq (%rsi), %rax
+;   movq %rsp, (%r10)
+;   movq %rax, %rsp
+;   movq 8(%rsi), %rax
+;   movq %rbp, 8(%r10)
+;   movq %rax, %rbp
+;   movq 0x10(%rsi), %rax
+;   leaq 6(%rip), %rcx
+;   movq %rcx, 0x10(%r10)
+;   jmpq *%rax
+;   movq %rdi, %rax
+;   movq (%rsp), %rbx
+;   movq 8(%rsp), %r12
+;   movq 0x10(%rsp), %r13
+;   movq 0x18(%rsp), %r14
+;   movq 0x20(%rsp), %r15
+;   addq $0x30, %rsp
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+;; Test clobbering of all 14 GPRs used by Cranelift
+function %switch_int_clobber(i64, i64) -> i64 {
+block0(v0: i64, v1: i64):
+  v2 = iconst.i64 0
+
+;; We create values v100 to v114 before the stack_switch and want to use them
+;; afterwards. Thus, they must all be spilled on the stack.
+;; Given that they are loads, they cannot be moved behind the stack_switch.
+
+  v100 = load.i64 v0+0
+  v101 = load.i64 v0+8
+  v102 = load.i64 v0+16
+  v103 = load.i64 v0+24
+  v104 = load.i64 v0+32
+  v105 = load.i64 v0+40
+  v106 = load.i64 v0+48
+  v107 = load.i64 v0+56
+  v108 = load.i64 v0+64
+  v109 = load.i64 v0+72
+  v110 = load.i64 v0+80
+  v111 = load.i64 v0+88
+  v112 = load.i64 v0+96
+  v113 = load.i64 v0+104
+  v114 = load.i64 v0+112
+
+  v299 = stack_switch v1, v1, v2
+
+;; We use v100 - v114 after the switch: We load from each v(100+i) into
+;; v(200+i), and use v(300+i) as an accumulator of all values so far.
+;; These are loads and therefore they cannot be moved before the stack_switch.
+
+  v200 = load.i64 v100
+  v300 = iadd.i64 v299, v200
+  v201 = load.i64 v101
+  v301 = iadd.i64 v300, v201
+  v202 = load.i64 v102
+  v302 = iadd.i64 v301, v202
+  v203 = load.i64 v103
+  v303 = iadd.i64 v302, v203
+  v204 = load.i64 v104
+  v304 = iadd.i64 v303, v204
+  v205 = load.i64 v105
+  v305 = iadd.i64 v304, v205
+  v206 = load.i64 v106
+  v306 = iadd.i64 v305, v206
+  v207 = load.i64 v107
+  v307 = iadd.i64 v306, v207
+  v208 = load.i64 v108
+  v308 = iadd.i64 v307, v208
+  v209 = load.i64 v109
+  v309 = iadd.i64 v308, v209
+  v210 = load.i64 v110
+  v310 = iadd.i64 v309, v210
+  v211 = load.i64 v111
+  v311 = iadd.i64 v310, v211
+  v212 = load.i64 v112
+  v312 = iadd.i64 v311, v212
+  v213 = load.i64 v113
+  v313 = iadd.i64 v312, v213
+  v214 = load.i64 v114
+  v314 = iadd.i64 v313, v214
+
+;; Let's also use v0 again
+  v400 = iadd.i64 v314, v0
+
+;; We cannot use v1 again: That causes TooManyLiveRegs, as this usage is an
+;; instance of https://github.com/bytecodealliance/regalloc2/issues/145
+;; v401 = iadd.i64 v400, v1
+
+  return v400
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+;   subq    %rsp, $192, %rsp
+;   movq    %rbx, 144(%rsp)
+;   movq    %r12, 152(%rsp)
+;   movq    %r13, 160(%rsp)
+;   movq    %r14, 168(%rsp)
+;   movq    %r15, 176(%rsp)
+; block0:
+;   movq    0(%rdi), %rdx
+;   movq    %rdx, rsp(128 + virtual offset)
+;   movq    8(%rdi), %rdx
+;   movq    %rdx, rsp(8 + virtual offset)
+;   movq    16(%rdi), %rdx
+;   movq    %rdx, rsp(120 + virtual offset)
+;   movq    24(%rdi), %rdx
+;   movq    %rdx, rsp(112 + virtual offset)
+;   movq    32(%rdi), %rdx
+;   movq    %rdx, rsp(104 + virtual offset)
+;   movq    40(%rdi), %rdx
+;   movq    %rdx, rsp(96 + virtual offset)
+;   movq    48(%rdi), %rdx
+;   movq    %rdx, rsp(88 + virtual offset)
+;   movq    56(%rdi), %rdx
+;   movq    %rdx, rsp(80 + virtual offset)
+;   movq    64(%rdi), %rdx
+;   movq    %rdx, rsp(72 + virtual offset)
+;   movq    72(%rdi), %rdx
+;   movq    %rdx, rsp(64 + virtual offset)
+;   movq    80(%rdi), %rdx
+;   movq    %rdx, rsp(56 + virtual offset)
+;   movq    88(%rdi), %rdx
+;   movq    %rdx, rsp(48 + virtual offset)
+;   movq    96(%rdi), %rdx
+;   movq    %rdx, rsp(40 + virtual offset)
+;   movq    104(%rdi), %rdx
+;   movq    %rdx, rsp(32 + virtual offset)
+;   movq    112(%rdi), %rdx
+;   movq    %rdi, rsp(0 + virtual offset)
+;   movq    %rdx, rsp(24 + virtual offset)
+;   xorq    %rdi, %rdi, %rdi
+;   %rdi = stack_switch_basic %rsi, %rsi, %rdi
+;   movq    rsp(128 + virtual offset), %rdx
+;   movq    %rdi, rsp(16 + virtual offset)
+;   movq    0(%rdx), %r8
+;   movq    rsp(8 + virtual offset), %rdx
+;   movq    0(%rdx), %r9
+;   movq    rsp(120 + virtual offset), %rdx
+;   movq    %r9, rsp(8 + virtual offset)
+;   movq    0(%rdx), %r10
+;   movq    rsp(112 + virtual offset), %rdx
+;   movq    0(%rdx), %r9
+;   movq    rsp(104 + virtual offset), %rdx
+;   movq    0(%rdx), %rsi
+;   movq    rsp(96 + virtual offset), %rdx
+;   movq    0(%rdx), %rax
+;   movq    rsp(88 + virtual offset), %rdx
+;   movq    0(%rdx), %rcx
+;   movq    rsp(80 + virtual offset), %rdx
+;   movq    0(%rdx), %r15
+;   movq    rsp(72 + virtual offset), %rdx
+;   movq    0(%rdx), %r13
+;   movq    rsp(64 + virtual offset), %rdx
+;   movq    0(%rdx), %rbx
+;   movq    rsp(56 + virtual offset), %rdx
+;   movq    0(%rdx), %r14
+;   movq    rsp(48 + virtual offset), %rdx
+;   movq    0(%rdx), %r12
+;   movq    rsp(40 + virtual offset), %rdx
+;   movq    0(%rdx), %rdx
+;   movq    rsp(32 + virtual offset), %rdi
+;   movq    0(%rdi), %r11
+;   movq    rsp(16 + virtual offset), %rdi
+;   lea     0(%rdi,%r8,1), %r8
+;   movq    rsp(8 + virtual offset), %rdi
+;   lea     0(%rdi,%r10,1), %r10
+;   lea     0(%r8,%r10,1), %r8
+;   lea     0(%r9,%rsi,1), %r9
+;   lea     0(%rax,%rcx,1), %r10
+;   lea     0(%r15,%r13,1), %rsi
+;   lea     0(%r10,%rsi,1), %r10
+;   lea     0(%rbx,%r14,1), %rsi
+;   lea     0(%r10,%rsi,1), %r10
+;   lea     0(%r12,%rdx,1), %rdx
+;   lea     0(%r10,%rdx,1), %rdx
+;   lea     0(%r9,%rdx,1), %rdx
+;   lea     0(%r8,%rdx,1), %rdx
+;   movq    rsp(24 + virtual offset), %r8
+;   addq    %r11, 0(%r8), %r11
+;   movq    rsp(0 + virtual offset), %rdi
+;   lea     0(%r11,%rdi,1), %r8
+;   lea     0(%rdx,%r8,1), %rax
+;   movq    144(%rsp), %rbx
+;   movq    152(%rsp), %r12
+;   movq    160(%rsp), %r13
+;   movq    168(%rsp), %r14
+;   movq    176(%rsp), %r15
+;   addq    %rsp, $192, %rsp
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+;   subq $0xc0, %rsp
+;   movq %rbx, 0x90(%rsp)
+;   movq %r12, 0x98(%rsp)
+;   movq %r13, 0xa0(%rsp)
+;   movq %r14, 0xa8(%rsp)
+;   movq %r15, 0xb0(%rsp)
+; block1: ; offset 0x33
+;   movq (%rdi), %rdx ; trap: heap_oob
+;   movq %rdx, 0x80(%rsp)
+;   movq 8(%rdi), %rdx ; trap: heap_oob
+;   movq %rdx, 8(%rsp)
+;   movq 0x10(%rdi), %rdx ; trap: heap_oob
+;   movq %rdx, 0x78(%rsp)
+;   movq 0x18(%rdi), %rdx ; trap: heap_oob
+;   movq %rdx, 0x70(%rsp)
+;   movq 0x20(%rdi), %rdx ; trap: heap_oob
+;   movq %rdx, 0x68(%rsp)
+;   movq 0x28(%rdi), %rdx ; trap: heap_oob
+;   movq %rdx, 0x60(%rsp)
+;   movq 0x30(%rdi), %rdx ; trap: heap_oob
+;   movq %rdx, 0x58(%rsp)
+;   movq 0x38(%rdi), %rdx ; trap: heap_oob
+;   movq %rdx, 0x50(%rsp)
+;   movq 0x40(%rdi), %rdx ; trap: heap_oob
+;   movq %rdx, 0x48(%rsp)
+;   movq 0x48(%rdi), %rdx ; trap: heap_oob
+;   movq %rdx, 0x40(%rsp)
+;   movq 0x50(%rdi), %rdx ; trap: heap_oob
+;   movq %rdx, 0x38(%rsp)
+;   movq 0x58(%rdi), %rdx ; trap: heap_oob
+;   movq %rdx, 0x30(%rsp)
+;   movq 0x60(%rdi), %rdx ; trap: heap_oob
+;   movq %rdx, 0x28(%rsp)
+;   movq 0x68(%rdi), %rdx ; trap: heap_oob
+;   movq %rdx, 0x20(%rsp)
+;   movq 0x70(%rdi), %rdx ; trap: heap_oob
+;   movq %rdi, (%rsp)
+;   movq %rdx, 0x18(%rsp)
+;   xorq %rdi, %rdi
+;   movq (%rsi), %rax
+;   movq %rsp, (%rsi)
+;   movq %rax, %rsp
+;   movq 8(%rsi), %rax
+;   movq %rbp, 8(%rsi)
+;   movq %rax, %rbp
+;   movq 0x10(%rsi), %rax
+;   leaq 6(%rip), %rcx
+;   movq %rcx, 0x10(%rsi)
+;   jmpq *%rax
+;   movq 0x80(%rsp), %rdx
+;   movq %rdi, 0x10(%rsp)
+;   movq (%rdx), %r8 ; trap: heap_oob
+;   movq 8(%rsp), %rdx
+;   movq (%rdx), %r9 ; trap: heap_oob
+;   movq 0x78(%rsp), %rdx
+;   movq %r9, 8(%rsp)
+;   movq (%rdx), %r10 ; trap: heap_oob
+;   movq 0x70(%rsp), %rdx
+;   movq (%rdx), %r9 ; trap: heap_oob
+;   movq 0x68(%rsp), %rdx
+;   movq (%rdx), %rsi ; trap: heap_oob
+;   movq 0x60(%rsp), %rdx
+;   movq (%rdx), %rax ; trap: heap_oob
+;   movq 0x58(%rsp), %rdx
+;   movq (%rdx), %rcx ; trap: heap_oob
+;   movq 0x50(%rsp), %rdx
+;   movq (%rdx), %r15 ; trap: heap_oob
+;   movq 0x48(%rsp), %rdx
+;   movq (%rdx), %r13 ; trap: heap_oob
+;   movq 0x40(%rsp), %rdx
+;   movq (%rdx), %rbx ; trap: heap_oob
+;   movq 0x38(%rsp), %rdx
+;   movq (%rdx), %r14 ; trap: heap_oob
+;   movq 0x30(%rsp), %rdx
+;   movq (%rdx), %r12 ; trap: heap_oob
+;   movq 0x28(%rsp), %rdx
+;   movq (%rdx), %rdx ; trap: heap_oob
+;   movq 0x20(%rsp), %rdi
+;   movq (%rdi), %r11 ; trap: heap_oob
+;   movq 0x10(%rsp), %rdi
+;   addq %rdi, %r8
+;   movq 8(%rsp), %rdi
+;   addq %rdi, %r10
+;   addq %r10, %r8
+;   addq %rsi, %r9
+;   leaq (%rax, %rcx), %r10
+;   leaq (%r15, %r13), %rsi
+;   addq %rsi, %r10
+;   leaq (%rbx, %r14), %rsi
+;   addq %rsi, %r10
+;   addq %r12, %rdx
+;   addq %r10, %rdx
+;   addq %r9, %rdx
+;   addq %r8, %rdx
+;   movq 0x18(%rsp), %r8
+;   addq (%r8), %r11 ; trap: heap_oob
+;   movq (%rsp), %rdi
+;   leaq (%r11, %rdi), %r8
+;   leaq (%rdx, %r8), %rax
+;   movq 0x90(%rsp), %rbx
+;   movq 0x98(%rsp), %r12
+;   movq 0xa0(%rsp), %r13
+;   movq 0xa8(%rsp), %r14
+;   movq 0xb0(%rsp), %r15
+;   addq $0xc0, %rsp
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+;; Test clobbering of all 16 float registers
+function %switch_float_clobber(i64, i64) -> f64 {
+block0(v0: i64, v1: i64):
+  v2 = iconst.i64 0
+
+;; We create values v100 to v115 before the stack_switch and want to use them
+;; afterwards. Thus, they must all be spilled on the stack.
+;; Given that they are loads, they cannot be moved behind the stack_switch.
+
+  v100 = load.f64 v0+0
+  v101 = load.f64 v0+8
+  v102 = load.f64 v0+16
+  v103 = load.f64 v0+24
+  v104 = load.f64 v0+32
+  v105 = load.f64 v0+40
+  v106 = load.f64 v0+48
+  v107 = load.f64 v0+56
+  v108 = load.f64 v0+64
+  v109 = load.f64 v0+72
+  v110 = load.f64 v0+80
+  v111 = load.f64 v0+88
+  v112 = load.f64 v0+96
+  v113 = load.f64 v0+104
+  v114 = load.f64 v0+112
+  v115 = load.f64 v0+120
+
+  v198 = stack_switch v1, v1, v2
+  v199 = fcvt_from_uint.f64 v198
+
+;; We add v100 to v115, using v200 to v215 as an accumulator
+;; We make v199 part of the result to prevent summation of v100 to v115 before
+;; the switch.
+
+  v200 = fadd v199, v100
+  v201 = fadd v200, v101
+  v202 = fadd v201, v102
+  v203 = fadd v202, v103
+  v204 = fadd v203, v104
+  v205 = fadd v204, v105
+  v206 = fadd v205, v106
+  v207 = fadd v206, v107
+  v208 = fadd v207, v108
+  v209 = fadd v208, v109
+  v210 = fadd v209, v110
+  v211 = fadd v210, v111
+  v212 = fadd v211, v112
+  v213 = fadd v212, v113
+  v214 = fadd v213, v114
+  v215 = fadd v214, v115
+
+  return v215
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+;   subq    %rsp, $304, %rsp
+;   movq    %rbx, 256(%rsp)
+;   movq    %r12, 264(%rsp)
+;   movq    %r13, 272(%rsp)
+;   movq    %r14, 280(%rsp)
+;   movq    %r15, 288(%rsp)
+; block0:
+;   movsd   0(%rdi), %xmm7
+;   movdqu  %xmm7, rsp(240 + virtual offset)
+;   movsd   8(%rdi), %xmm7
+;   movdqu  %xmm7, rsp(224 + virtual offset)
+;   movsd   16(%rdi), %xmm7
+;   movdqu  %xmm7, rsp(208 + virtual offset)
+;   movsd   24(%rdi), %xmm7
+;   movdqu  %xmm7, rsp(192 + virtual offset)
+;   movsd   32(%rdi), %xmm7
+;   movdqu  %xmm7, rsp(176 + virtual offset)
+;   movsd   40(%rdi), %xmm7
+;   movdqu  %xmm7, rsp(160 + virtual offset)
+;   movsd   48(%rdi), %xmm7
+;   movdqu  %xmm7, rsp(144 + virtual offset)
+;   movsd   56(%rdi), %xmm7
+;   movdqu  %xmm7, rsp(128 + virtual offset)
+;   movsd   64(%rdi), %xmm7
+;   movdqu  %xmm7, rsp(112 + virtual offset)
+;   movsd   72(%rdi), %xmm7
+;   movdqu  %xmm7, rsp(96 + virtual offset)
+;   movsd   80(%rdi), %xmm7
+;   movdqu  %xmm7, rsp(80 + virtual offset)
+;   movsd   88(%rdi), %xmm7
+;   movdqu  %xmm7, rsp(64 + virtual offset)
+;   movsd   96(%rdi), %xmm7
+;   movdqu  %xmm7, rsp(48 + virtual offset)
+;   movsd   104(%rdi), %xmm7
+;   movdqu  %xmm7, rsp(32 + virtual offset)
+;   movsd   112(%rdi), %xmm7
+;   movdqu  %xmm7, rsp(16 + virtual offset)
+;   movsd   120(%rdi), %xmm7
+;   movdqu  %xmm7, rsp(0 + virtual offset)
+;   xorq    %rdi, %rdi, %rdi
+;   %rdi = stack_switch_basic %rsi, %rsi, %rdi
+;   u64_to_f64_seq %rdi, %xmm0, %rax, %rcx
+;   movdqu  rsp(240 + virtual offset), %xmm7
+;   addsd   %xmm0, %xmm7, %xmm0
+;   movdqu  rsp(224 + virtual offset), %xmm7
+;   addsd   %xmm0, %xmm7, %xmm0
+;   movdqu  rsp(208 + virtual offset), %xmm7
+;   addsd   %xmm0, %xmm7, %xmm0
+;   movdqu  rsp(192 + virtual offset), %xmm7
+;   addsd   %xmm0, %xmm7, %xmm0
+;   movdqu  rsp(176 + virtual offset), %xmm7
+;   addsd   %xmm0, %xmm7, %xmm0
+;   movdqu  rsp(160 + virtual offset), %xmm7
+;   addsd   %xmm0, %xmm7, %xmm0
+;   movdqu  rsp(144 + virtual offset), %xmm7
+;   addsd   %xmm0, %xmm7, %xmm0
+;   movdqu  rsp(128 + virtual offset), %xmm7
+;   addsd   %xmm0, %xmm7, %xmm0
+;   movdqu  rsp(112 + virtual offset), %xmm7
+;   addsd   %xmm0, %xmm7, %xmm0
+;   movdqu  rsp(96 + virtual offset), %xmm7
+;   addsd   %xmm0, %xmm7, %xmm0
+;   movdqu  rsp(80 + virtual offset), %xmm7
+;   addsd   %xmm0, %xmm7, %xmm0
+;   movdqu  rsp(64 + virtual offset), %xmm7
+;   addsd   %xmm0, %xmm7, %xmm0
+;   movdqu  rsp(48 + virtual offset), %xmm7
+;   addsd   %xmm0, %xmm7, %xmm0
+;   movdqu  rsp(32 + virtual offset), %xmm7
+;   addsd   %xmm0, %xmm7, %xmm0
+;   movdqu  rsp(16 + virtual offset), %xmm7
+;   addsd   %xmm0, %xmm7, %xmm0
+;   movdqu  rsp(0 + virtual offset), %xmm7
+;   addsd   %xmm0, %xmm7, %xmm0
+;   movq    256(%rsp), %rbx
+;   movq    264(%rsp), %r12
+;   movq    272(%rsp), %r13
+;   movq    280(%rsp), %r14
+;   movq    288(%rsp), %r15
+;   addq    %rsp, $304, %rsp
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+;   subq $0x130, %rsp
+;   movq %rbx, 0x100(%rsp)
+;   movq %r12, 0x108(%rsp)
+;   movq %r13, 0x110(%rsp)
+;   movq %r14, 0x118(%rsp)
+;   movq %r15, 0x120(%rsp)
+; block1: ; offset 0x33
+;   movsd (%rdi), %xmm7 ; trap: heap_oob
+;   movdqu %xmm7, 0xf0(%rsp)
+;   movsd 8(%rdi), %xmm7 ; trap: heap_oob
+;   movdqu %xmm7, 0xe0(%rsp)
+;   movsd 0x10(%rdi), %xmm7 ; trap: heap_oob
+;   movdqu %xmm7, 0xd0(%rsp)
+;   movsd 0x18(%rdi), %xmm7 ; trap: heap_oob
+;   movdqu %xmm7, 0xc0(%rsp)
+;   movsd 0x20(%rdi), %xmm7 ; trap: heap_oob
+;   movdqu %xmm7, 0xb0(%rsp)
+;   movsd 0x28(%rdi), %xmm7 ; trap: heap_oob
+;   movdqu %xmm7, 0xa0(%rsp)
+;   movsd 0x30(%rdi), %xmm7 ; trap: heap_oob
+;   movdqu %xmm7, 0x90(%rsp)
+;   movsd 0x38(%rdi), %xmm7 ; trap: heap_oob
+;   movdqu %xmm7, 0x80(%rsp)
+;   movsd 0x40(%rdi), %xmm7 ; trap: heap_oob
+;   movdqu %xmm7, 0x70(%rsp)
+;   movsd 0x48(%rdi), %xmm7 ; trap: heap_oob
+;   movdqu %xmm7, 0x60(%rsp)
+;   movsd 0x50(%rdi), %xmm7 ; trap: heap_oob
+;   movdqu %xmm7, 0x50(%rsp)
+;   movsd 0x58(%rdi), %xmm7 ; trap: heap_oob
+;   movdqu %xmm7, 0x40(%rsp)
+;   movsd 0x60(%rdi), %xmm7 ; trap: heap_oob
+;   movdqu %xmm7, 0x30(%rsp)
+;   movsd 0x68(%rdi), %xmm7 ; trap: heap_oob
+;   movdqu %xmm7, 0x20(%rsp)
+;   movsd 0x70(%rdi), %xmm7 ; trap: heap_oob
+;   movdqu %xmm7, 0x10(%rsp)
+;   movsd 0x78(%rdi), %xmm7 ; trap: heap_oob
+;   movdqu %xmm7, (%rsp)
+;   xorq %rdi, %rdi
+;   movq (%rsi), %rax
+;   movq %rsp, (%rsi)
+;   movq %rax, %rsp
+;   movq 8(%rsi), %rax
+;   movq %rbp, 8(%rsi)
+;   movq %rax, %rbp
+;   movq 0x10(%rsi), %rax
+;   leaq 6(%rip), %rcx
+;   movq %rcx, 0x10(%rsi)
+;   jmpq *%rax
+;   cmpq $0, %rdi
+;   jl 0x135
+;   cvtsi2sdq %rdi, %xmm0
+;   jmp 0x14f
+;   movq %rdi, %rax
+;   shrq $1, %rax
+;   movq %rdi, %rcx
+;   andq $1, %rcx
+;   orq %rax, %rcx
+;   cvtsi2sdq %rcx, %xmm0
+;   addsd %xmm0, %xmm0
+;   movdqu 0xf0(%rsp), %xmm7
+;   addsd %xmm7, %xmm0
+;   movdqu 0xe0(%rsp), %xmm7
+;   addsd %xmm7, %xmm0
+;   movdqu 0xd0(%rsp), %xmm7
+;   addsd %xmm7, %xmm0
+;   movdqu 0xc0(%rsp), %xmm7
+;   addsd %xmm7, %xmm0
+;   movdqu 0xb0(%rsp), %xmm7
+;   addsd %xmm7, %xmm0
+;   movdqu 0xa0(%rsp), %xmm7
+;   addsd %xmm7, %xmm0
+;   movdqu 0x90(%rsp), %xmm7
+;   addsd %xmm7, %xmm0
+;   movdqu 0x80(%rsp), %xmm7
+;   addsd %xmm7, %xmm0
+;   movdqu 0x70(%rsp), %xmm7
+;   addsd %xmm7, %xmm0
+;   movdqu 0x60(%rsp), %xmm7
+;   addsd %xmm7, %xmm0
+;   movdqu 0x50(%rsp), %xmm7
+;   addsd %xmm7, %xmm0
+;   movdqu 0x40(%rsp), %xmm7
+;   addsd %xmm7, %xmm0
+;   movdqu 0x30(%rsp), %xmm7
+;   addsd %xmm7, %xmm0
+;   movdqu 0x20(%rsp), %xmm7
+;   addsd %xmm7, %xmm0
+;   movdqu 0x10(%rsp), %xmm7
+;   addsd %xmm7, %xmm0
+;   movdqu (%rsp), %xmm7
+;   addsd %xmm7, %xmm0
+;   movq 0x100(%rsp), %rbx
+;   movq 0x108(%rsp), %r12
+;   movq 0x110(%rsp), %r13
+;   movq 0x118(%rsp), %r14
+;   movq 0x120(%rsp), %r15
+;   addq $0x130, %rsp
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/stackslot.clif b/cranelift/filetests/filetests/isa/x64/stackslot.clif
new file mode 100644
index 000000000000..b4c013839172
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/stackslot.clif
@@ -0,0 +1,61 @@
+test compile precise-output
+target x86_64
+
+function %f0(i64 vmctx) -> i64, i64, i64, i64 {
+  gv0 = vmctx
+  stack_limit = gv0
+  ss0 = explicit_slot 8, align=16
+  ss1 = explicit_slot 8, align=16
+  ss2 = explicit_slot 4
+  ss3 = explicit_slot 4
+
+block0(v0: i64):
+  v1 = stack_addr.i64 ss0
+  v2 = stack_addr.i64 ss1
+  v3 = stack_addr.i64 ss2
+  v4 = stack_addr.i64 ss3
+  return v1, v2, v3, v4
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+;   movq    %rdi, %r10
+;   addq    %r10, $48, %r10
+;   cmpq    %rsp, %r10
+;   jnbe #trap=stk_ovf
+;   subq    %rsp, $48, %rsp
+; block0:
+;   lea     rsp(0 + virtual offset), %rax
+;   lea     rsp(16 + virtual offset), %rdx
+;   lea     rsp(32 + virtual offset), %r8
+;   lea     rsp(40 + virtual offset), %r9
+;   movq    %r8, 0(%rsi)
+;   movq    %r9, 8(%rsi)
+;   addq    %rsp, $48, %rsp
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+;   movq %rdi, %r10
+;   addq $0x30, %r10
+;   cmpq %rsp, %r10
+;   ja 0x3b
+;   subq $0x30, %rsp
+; block1: ; offset 0x18
+;   leaq (%rsp), %rax
+;   leaq 0x10(%rsp), %rdx
+;   leaq 0x20(%rsp), %r8
+;   leaq 0x28(%rsp), %r9
+;   movq %r8, (%rsi)
+;   movq %r9, 8(%rsi)
+;   addq $0x30, %rsp
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+;   ud2 ; trap: stk_ovf
+
diff --git a/cranelift/filetests/filetests/isa/x64/store-f16-f128.clif b/cranelift/filetests/filetests/isa/x64/store-f16-f128.clif
new file mode 100644
index 000000000000..729d271c7913
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/store-f16-f128.clif
@@ -0,0 +1,55 @@
+test compile precise-output
+target x86_64
+
+function %store_f16(f16, i64) {
+block0(v0: f16, v1: i64):
+    store.f16 v0, v1
+    return
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   pextrw  $0, %xmm0, %rcx
+;   movw    %cx, 0(%rdi)
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   pextrw $0, %xmm0, %ecx
+;   movw %cx, (%rdi) ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %store_f128(f128, i64) {
+block0(v0: f128, v1: i64):
+    store.f128 v0, v1
+    return
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movdqu  %xmm0, 0(%rdi)
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movdqu %xmm0, (%rdi) ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/store-f16-sse41.clif b/cranelift/filetests/filetests/isa/x64/store-f16-sse41.clif
new file mode 100644
index 000000000000..bb89bf07354a
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/store-f16-sse41.clif
@@ -0,0 +1,28 @@
+test compile precise-output
+target x86_64 sse41
+
+function %store_f16(f16, i64) {
+block0(v0: f16, v1: i64):
+    store.f16 v0, v1
+    return
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   pextrw  $0, %xmm0, 0(%rdi)
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   pextrw $0, %xmm0, (%rdi) ; trap: heap_oob
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/struct-arg.clif b/cranelift/filetests/filetests/isa/x64/struct-arg.clif
index cf1606a892e5..95b1c4f6bce7 100644
--- a/cranelift/filetests/filetests/isa/x64/struct-arg.clif
+++ b/cranelift/filetests/filetests/isa/x64/struct-arg.clif
@@ -11,7 +11,7 @@ block0(v0: i64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   lea     16(%rbp), %rsi
+;   lea     rbp(stack args max - 64), %rsi
 ;   movzbq  0(%rsi), %rax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -40,7 +40,7 @@ block0(v0: i64, v1: i64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   lea     16(%rbp), %rcx
+;   lea     rbp(stack args max - 64), %rcx
 ;   movzbq  0(%rdi), %rax
 ;   movzbq  0(%rcx), %r9
 ;   addl    %eax, %r9d, %eax
@@ -72,17 +72,15 @@ block0(v0: i64):
 ; VCode:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
+;   subq    %rsp, $64, %rsp
 ; block0:
 ;   movq    %rdi, %rsi
-;   subq    %rsp, $64, %rsp
-;   virtual_sp_offset_adjust 64
 ;   lea     0(%rsp), %rdi
 ;   movl    $64, %edx
-;   load_ext_name %Memcpy+0, %r11
-;   call    *%r11
+;   load_ext_name %Memcpy+0, %r9
+;   call    *%r9
 ;   call    User(userextname0)
 ;   addq    %rsp, $64, %rsp
-;   virtual_sp_offset_adjust -64
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -91,13 +89,13 @@ block0(v0: i64):
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
-; block1: ; offset 0x4
-;   movq %rdi, %rsi
 ;   subq $0x40, %rsp
+; block1: ; offset 0x8
+;   movq %rdi, %rsi
 ;   leaq (%rsp), %rdi
 ;   movl $0x40, %edx
-;   movabsq $0, %r11 ; reloc_external Abs8 %Memcpy 0
-;   callq *%r11
+;   movabsq $0, %r9 ; reloc_external Abs8 %Memcpy 0
+;   callq *%r9
 ;   callq 0x26 ; reloc_external CallPCRel4 u0:0 -4
 ;   addq $0x40, %rsp
 ;   movq %rbp, %rsp
@@ -115,22 +113,18 @@ block0(v0: i64, v1: i64):
 ; VCode:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
-;   subq    %rsp, $16, %rsp
-;   movq    %r13, 0(%rsp)
+;   subq    %rsp, $80, %rsp
+;   movq    %r14, 64(%rsp)
 ; block0:
-;   movq    %rdi, %r13
-;   subq    %rsp, $64, %rsp
-;   virtual_sp_offset_adjust 64
+;   movq    %rdi, %r14
 ;   lea     0(%rsp), %rdi
 ;   movl    $64, %edx
-;   load_ext_name %Memcpy+0, %rax
-;   call    *%rax
-;   movq    %r13, %rdi
+;   load_ext_name %Memcpy+0, %r10
+;   call    *%r10
+;   movq    %r14, %rdi
 ;   call    User(userextname0)
-;   addq    %rsp, $64, %rsp
-;   virtual_sp_offset_adjust -64
-;   movq    0(%rsp), %r13
-;   addq    %rsp, $16, %rsp
+;   movq    64(%rsp), %r14
+;   addq    %rsp, $80, %rsp
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -139,20 +133,18 @@ block0(v0: i64, v1: i64):
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
-;   subq $0x10, %rsp
-;   movq %r13, (%rsp)
-; block1: ; offset 0xc
-;   movq %rdi, %r13
-;   subq $0x40, %rsp
+;   subq $0x50, %rsp
+;   movq %r14, 0x40(%rsp)
+; block1: ; offset 0xd
+;   movq %rdi, %r14
 ;   leaq (%rsp), %rdi
 ;   movl $0x40, %edx
-;   movabsq $0, %rax ; reloc_external Abs8 %Memcpy 0
-;   callq *%rax
-;   movq %r13, %rdi
-;   callq 0x30 ; reloc_external CallPCRel4 u0:0 -4
-;   addq $0x40, %rsp
-;   movq (%rsp), %r13
-;   addq $0x10, %rsp
+;   movabsq $0, %r10 ; reloc_external Abs8 %Memcpy 0
+;   callq *%r10
+;   movq %r14, %rdi
+;   callq 0x2e ; reloc_external CallPCRel4 u0:0 -4
+;   movq 0x40(%rsp), %r14
+;   addq $0x50, %rsp
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -169,8 +161,8 @@ block0(v0: i64, v1: i64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   lea     16(%rbp), %rsi
-;   lea     144(%rbp), %rcx
+;   lea     rbp(stack args max - 192), %rsi
+;   lea     rbp(stack args max - 64), %rcx
 ;   movzbq  0(%rsi), %rax
 ;   movzbq  0(%rcx), %r9
 ;   addl    %eax, %r9d, %eax
@@ -203,30 +195,26 @@ block0(v0: i64, v1: i64, v2: i64):
 ; VCode:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
-;   subq    %rsp, $16, %rsp
-;   movq    %r12, 0(%rsp)
-;   movq    %r14, 8(%rsp)
+;   subq    %rsp, $208, %rsp
+;   movq    %rbx, 192(%rsp)
+;   movq    %r13, 200(%rsp)
 ; block0:
-;   movq    %rdx, %r14
-;   movq    %rdi, %r12
-;   subq    %rsp, $192, %rsp
-;   virtual_sp_offset_adjust 192
+;   movq    %rdx, %rbx
+;   movq    %rdi, %r13
 ;   lea     0(%rsp), %rdi
 ;   movl    $128, %edx
-;   load_ext_name %Memcpy+0, %rax
-;   call    *%rax
-;   lea     128(%rsp), %rdi
-;   movl    $64, %edx
 ;   load_ext_name %Memcpy+0, %r11
-;   movq    %r14, %rsi
 ;   call    *%r11
-;   movq    %r12, %rdi
+;   lea     128(%rsp), %rdi
+;   movl    $64, %edx
+;   load_ext_name %Memcpy+0, %r9
+;   movq    %rbx, %rsi
+;   call    *%r9
+;   movq    %r13, %rdi
 ;   call    User(userextname0)
-;   addq    %rsp, $192, %rsp
-;   virtual_sp_offset_adjust -192
-;   movq    0(%rsp), %r12
-;   movq    8(%rsp), %r14
-;   addq    %rsp, $16, %rsp
+;   movq    192(%rsp), %rbx
+;   movq    200(%rsp), %r13
+;   addq    %rsp, $208, %rsp
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -235,28 +223,26 @@ block0(v0: i64, v1: i64, v2: i64):
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
-;   subq $0x10, %rsp
-;   movq %r12, (%rsp)
-;   movq %r14, 8(%rsp)
-; block1: ; offset 0x11
-;   movq %rdx, %r14
-;   movq %rdi, %r12
-;   subq $0xc0, %rsp
+;   subq $0xd0, %rsp
+;   movq %rbx, 0xc0(%rsp)
+;   movq %r13, 0xc8(%rsp)
+; block1: ; offset 0x1b
+;   movq %rdx, %rbx
+;   movq %rdi, %r13
 ;   leaq (%rsp), %rdi
 ;   movl $0x80, %edx
-;   movabsq $0, %rax ; reloc_external Abs8 %Memcpy 0
-;   callq *%rax
-;   leaq 0x80(%rsp), %rdi
-;   movl $0x40, %edx
 ;   movabsq $0, %r11 ; reloc_external Abs8 %Memcpy 0
-;   movq %r14, %rsi
 ;   callq *%r11
-;   movq %r12, %rdi
-;   callq 0x58 ; reloc_external CallPCRel4 u0:0 -4
-;   addq $0xc0, %rsp
-;   movq (%rsp), %r12
-;   movq 8(%rsp), %r14
-;   addq $0x10, %rsp
+;   leaq 0x80(%rsp), %rdi
+;   movl $0x40, %edx
+;   movabsq $0, %r9 ; reloc_external Abs8 %Memcpy 0
+;   movq %rbx, %rsi
+;   callq *%r9
+;   movq %r13, %rdi
+;   callq 0x5c ; reloc_external CallPCRel4 u0:0 -4
+;   movq 0xc0(%rsp), %rbx
+;   movq 0xc8(%rsp), %r13
+;   addq $0xd0, %rsp
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
diff --git a/cranelift/filetests/filetests/isa/x64/struct-ret.clif b/cranelift/filetests/filetests/isa/x64/struct-ret.clif
index 3732beee3741..2664c459c589 100644
--- a/cranelift/filetests/filetests/isa/x64/struct-ret.clif
+++ b/cranelift/filetests/filetests/isa/x64/struct-ret.clif
@@ -41,9 +41,9 @@ block0(v0: i64, v1: i64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
+;   load_ext_name %f2+0, %rcx
 ;   movq    %rsi, %rdi
-;   load_ext_name %f2+0, %rdx
-;   call    *%rdx
+;   call    *%rcx
 ;   movq    %rdx, %rax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -54,9 +54,9 @@ block0(v0: i64, v1: i64):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
+;   movabsq $0, %rcx ; reloc_external Abs8 %f2 0
 ;   movq %rsi, %rdi
-;   movabsq $0, %rdx ; reloc_external Abs8 %f2 0
-;   callq *%rdx
+;   callq *%rcx
 ;   movq %rdx, %rax
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -78,7 +78,6 @@ block0(v0: i64):
 ; block0:
 ;   movq    %rdi, %r15
 ;   load_ext_name %f4+0, %rax
-;   movq    %r15, %rdi
 ;   call    *%rax
 ;   movq    %r15, %rax
 ;   movq    0(%rsp), %r15
@@ -96,7 +95,6 @@ block0(v0: i64):
 ; block1: ; offset 0xc
 ;   movq %rdi, %r15
 ;   movabsq $0, %rax ; reloc_external Abs8 %f4 0
-;   movq %r15, %rdi
 ;   callq *%rax
 ;   movq %r15, %rax
 ;   movq (%rsp), %r15
diff --git a/cranelift/filetests/filetests/isa/x64/table.clif b/cranelift/filetests/filetests/isa/x64/table.clif
deleted file mode 100644
index c3c217fc9a06..000000000000
--- a/cranelift/filetests/filetests/isa/x64/table.clif
+++ /dev/null
@@ -1,59 +0,0 @@
-test compile precise-output
-set enable_safepoints=true
-set enable_table_access_spectre_mitigation=true
-
-target x86_64
-
-function %table_set(i32, r64, i64 vmctx) {
-    gv0 = vmctx
-    gv1 = load.i64 notrap aligned gv0
-    gv2 = load.i32 notrap aligned gv0 +8
-    table0 = dynamic gv1, element_size 1, bound gv2, index_type i32
-
-block0(v0: i32, v1: r64, v2: i64):
-    v3 = table_addr.i64 table0, v0+0
-    store.r64 notrap aligned v1, v3
-    return
-}
-
-; VCode:
-;   pushq   %rbp
-;   movq    %rsp, %rbp
-; block0:
-;   movl    8(%rdx), %r11d
-;   cmpl    %r11d, %edi
-;   jnb     label2; j label1
-; block1:
-;   movl    %edi, %ecx
-;   movq    0(%rdx), %rax
-;   lea     0(%rax,%rcx,1), %rcx
-;   cmpl    %r11d, %edi
-;   cmovnbq %rax, %rcx, %rcx
-;   movq    %rsi, 0(%rcx)
-;   movq    %rbp, %rsp
-;   popq    %rbp
-;   ret
-; block2:
-;   ud2 table_oob
-;
-; Disassembled:
-; block0: ; offset 0x0
-;   pushq %rbp
-;   movq %rsp, %rbp
-; block1: ; offset 0x4
-;   movl 8(%rdx), %r11d
-;   cmpl %r11d, %edi
-;   jae 0x28
-; block2: ; offset 0x11
-;   movl %edi, %ecx
-;   movq (%rdx), %rax
-;   addq %rax, %rcx
-;   cmpl %r11d, %edi
-;   cmovaeq %rax, %rcx
-;   movq %rsi, (%rcx)
-;   movq %rbp, %rsp
-;   popq %rbp
-;   retq
-; block3: ; offset 0x28
-;   ud2 ; trap: table_oob
-
diff --git a/cranelift/filetests/filetests/isa/x64/tail-call-conv.clif b/cranelift/filetests/filetests/isa/x64/tail-call-conv.clif
index 04012299b7b5..c919e5ce872d 100644
--- a/cranelift/filetests/filetests/isa/x64/tail-call-conv.clif
+++ b/cranelift/filetests/filetests/isa/x64/tail-call-conv.clif
@@ -1,4 +1,6 @@
 test compile precise-output
+set enable_llvm_abi_extensions
+set preserve_frame_pointers
 target x86_64
 
 ;; Test the `tail` calling convention with non-tail calls and stack arguments.
@@ -12,28 +14,20 @@ block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64, v6: i64, v7: i64, v
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    16(%rbp), %rax
-;   movq    24(%rbp), %rdx
-;   movq    32(%rbp), %r9
-;   movq    40(%rbp), %r11
-;   movq    48(%rbp), %rax
+;   movq    rbp(stack args max - 16), %rax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
-;   ret 48
+;   ret 80
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq 0x10(%rbp), %rax
-;   movq 0x18(%rbp), %rdx
-;   movq 0x20(%rbp), %r9
-;   movq 0x28(%rbp), %r11
-;   movq 0x30(%rbp), %rax
+;   movq 0x50(%rbp), %rax
 ;   movq %rbp, %rsp
 ;   popq %rbp
-;   retq $0x30
+;   retq $0x50
 
 function %tail_caller_stack_args() -> i64 {
     fn0 = %tail_callee_stack_args(i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64) -> i64 tail
@@ -61,45 +55,47 @@ block0:
 ; VCode:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
-;   subq    %rsp, $64, %rsp
-;   movq    %rbx, 16(%rsp)
+;   subq    %rsp, $144, %rsp
+;   movq    %rbx, 96(%rsp)
+;   movq    %r12, 104(%rsp)
+;   movq    %r13, 112(%rsp)
+;   movq    %r14, 120(%rsp)
+;   movq    %r15, 128(%rsp)
+; block0:
+;   movl    $10, %esi
+;   movq    %rsi, rsp(0 + virtual offset)
+;   movl    $15, %esi
+;   movl    $20, %edx
+;   movl    $25, %ecx
+;   movl    $30, %r8d
+;   movl    $35, %r9d
+;   movl    $40, %r10d
+;   movl    $45, %r11d
+;   movl    $50, %eax
+;   movl    $55, %r12d
+;   movl    $60, %r13d
+;   movl    $65, %r14d
+;   movl    $70, %r15d
+;   movl    $75, %ebx
+;   movl    $80, %edi
+;   movq    %r10, 0(%rsp)
+;   movq    %r11, 8(%rsp)
+;   movq    %rax, 16(%rsp)
 ;   movq    %r12, 24(%rsp)
 ;   movq    %r13, 32(%rsp)
 ;   movq    %r14, 40(%rsp)
 ;   movq    %r15, 48(%rsp)
-; block0:
-;   movl    $10, %eax
-;   movq    %rax, rsp(0 + virtual offset)
-;   movl    $15, %ecx
-;   movl    $20, %edx
-;   movl    $25, %ebx
-;   movl    $30, %esi
-;   movl    $35, %edi
-;   movl    $40, %r8d
-;   movl    $45, %r9d
-;   movl    $50, %r10d
-;   movl    $55, %r11d
-;   movl    $60, %r12d
-;   movl    $65, %r13d
-;   movl    $70, %r14d
-;   movl    $75, %r15d
-;   movl    $80, %eax
-;   subq    %rsp, $48, %rsp
-;   virtual_sp_offset_adjust 48
-;   movq    %r12, 0(%rsp)
-;   movq    %r13, 8(%rsp)
-;   movq    %r14, 16(%rsp)
-;   movq    %r15, 24(%rsp)
-;   movq    %rax, 32(%rsp)
-;   load_ext_name %tail_callee_stack_args+0, %r15
-;   movq    rsp(0 + virtual offset), %rax
-;   call    *%r15
-;   movq    16(%rsp), %rbx
-;   movq    24(%rsp), %r12
-;   movq    32(%rsp), %r13
-;   movq    40(%rsp), %r14
-;   movq    48(%rsp), %r15
-;   addq    %rsp, $64, %rsp
+;   movq    %rbx, 56(%rsp)
+;   movq    %rdi, 64(%rsp)
+;   load_ext_name %tail_callee_stack_args+0, %r10
+;   movq    rsp(0 + virtual offset), %rdi
+;   call    *%r10
+;   movq    96(%rsp), %rbx
+;   movq    104(%rsp), %r12
+;   movq    112(%rsp), %r13
+;   movq    120(%rsp), %r14
+;   movq    128(%rsp), %r15
+;   addq    %rsp, $144, %rsp
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -108,44 +104,48 @@ block0:
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
-;   subq $0x40, %rsp
-;   movq %rbx, 0x10(%rsp)
+;   subq $0x90, %rsp
+;   movq %rbx, 0x60(%rsp)
+;   movq %r12, 0x68(%rsp)
+;   movq %r13, 0x70(%rsp)
+;   movq %r14, 0x78(%rsp)
+;   movq %r15, 0x80(%rsp)
+; block1: ; offset 0x27
+;   movl $0xa, %esi
+;   movq %rsi, 0x50(%rsp)
+;   movl $0xf, %esi
+;   movl $0x14, %edx
+;   movl $0x19, %ecx
+;   movl $0x1e, %r8d
+;   movl $0x23, %r9d
+;   movl $0x28, %r10d
+;   movl $0x2d, %r11d
+;   movl $0x32, %eax
+;   movl $0x37, %r12d
+;   movl $0x3c, %r13d
+;   movl $0x41, %r14d
+;   movl $0x46, %r15d
+;   movl $0x4b, %ebx
+;   movl $0x50, %edi
+;   movq %r10, (%rsp)
+;   movq %r11, 8(%rsp)
+;   movq %rax, 0x10(%rsp)
 ;   movq %r12, 0x18(%rsp)
 ;   movq %r13, 0x20(%rsp)
 ;   movq %r14, 0x28(%rsp)
 ;   movq %r15, 0x30(%rsp)
-; block1: ; offset 0x21
-;   movl $0xa, %eax
-;   movq %rax, (%rsp)
-;   movl $0xf, %ecx
-;   movl $0x14, %edx
-;   movl $0x19, %ebx
-;   movl $0x1e, %esi
-;   movl $0x23, %edi
-;   movl $0x28, %r8d
-;   movl $0x2d, %r9d
-;   movl $0x32, %r10d
-;   movl $0x37, %r11d
-;   movl $0x3c, %r12d
-;   movl $0x41, %r13d
-;   movl $0x46, %r14d
-;   movl $0x4b, %r15d
-;   movl $0x50, %eax
-;   subq $0x30, %rsp
-;   movq %r12, (%rsp)
-;   movq %r13, 8(%rsp)
-;   movq %r14, 0x10(%rsp)
-;   movq %r15, 0x18(%rsp)
-;   movq %rax, 0x20(%rsp)
-;   movabsq $0, %r15 ; reloc_external Abs8 %tail_callee_stack_args 0
-;   movq 0x30(%rsp), %rax
-;   callq *%r15
-;   movq 0x10(%rsp), %rbx
-;   movq 0x18(%rsp), %r12
-;   movq 0x20(%rsp), %r13
-;   movq 0x28(%rsp), %r14
-;   movq 0x30(%rsp), %r15
-;   addq $0x40, %rsp
+;   movq %rbx, 0x38(%rsp)
+;   movq %rdi, 0x40(%rsp)
+;   movabsq $0, %r10 ; reloc_external Abs8 %tail_callee_stack_args 0
+;   movq 0x50(%rsp), %rdi
+;   callq *%r10
+;   subq $0x50, %rsp
+;   movq 0x60(%rsp), %rbx
+;   movq 0x68(%rsp), %r12
+;   movq 0x70(%rsp), %r13
+;   movq 0x78(%rsp), %r14
+;   movq 0x80(%rsp), %r15
+;   addq $0x90, %rsp
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -186,74 +186,90 @@ block0:
 ; VCode:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
-;   subq    %rsp, $112, %rsp
+;   subq    %rsp, $160, %rsp
+;   movq    %rbx, 112(%rsp)
+;   movq    %r12, 120(%rsp)
+;   movq    %r13, 128(%rsp)
+;   movq    %r14, 136(%rsp)
+;   movq    %r15, 144(%rsp)
 ; block0:
-;   movl    $10, %esi
-;   movq    %rsi, rsp(96 + virtual offset)
-;   movl    $15, %ecx
-;   movq    %rcx, rsp(88 + virtual offset)
-;   movl    $20, %edx
-;   movq    %rdx, rsp(80 + virtual offset)
-;   movl    $25, %ebx
-;   movq    %rbx, rsp(72 + virtual offset)
-;   movl    $30, %esi
-;   movq    %rsi, rsp(64 + virtual offset)
-;   movl    $35, %edi
-;   movq    %rdi, rsp(56 + virtual offset)
-;   movl    $40, %r8d
-;   movq    %r8, rsp(48 + virtual offset)
-;   movl    $45, %r9d
-;   movq    %r9, rsp(40 + virtual offset)
-;   movl    $50, %r10d
-;   movq    %r10, rsp(32 + virtual offset)
-;   movl    $55, %r11d
-;   movq    %r11, rsp(24 + virtual offset)
-;   movl    $60, %r12d
-;   movq    %r12, rsp(16 + virtual offset)
-;   movl    $65, %r13d
-;   movq    %r13, rsp(8 + virtual offset)
-;   movl    $70, %r14d
-;   movq    %r14, rsp(0 + virtual offset)
-;   movl    $75, %r15d
-;   movl    $80, %ecx
-;   movl    $85, %edx
-;   movl    $90, %ebx
+;   movl    $10, %ecx
+;   movq    %rcx, rsp(104 + virtual offset)
+;   movl    $15, %edx
+;   movq    %rdx, rsp(96 + virtual offset)
+;   movl    $20, %esi
+;   movq    %rsi, rsp(88 + virtual offset)
+;   movl    $25, %r8d
+;   movq    %r8, rsp(80 + virtual offset)
+;   movl    $30, %eax
+;   movq    %rax, rsp(72 + virtual offset)
+;   movl    $35, %r9d
+;   movq    %r9, rsp(64 + virtual offset)
+;   movl    $40, %r10d
+;   movq    %r10, rsp(56 + virtual offset)
+;   movl    $45, %r11d
+;   movq    %r11, rsp(48 + virtual offset)
+;   movl    $50, %r11d
+;   movq    %r11, rsp(40 + virtual offset)
+;   movl    $55, %r14d
+;   movl    $60, %r15d
+;   movl    $65, %ebx
+;   movl    $70, %r12d
+;   movl    $75, %r13d
+;   movl    $80, %eax
+;   movl    $85, %ecx
+;   movl    $90, %edx
 ;   movl    $95, %esi
-;   movl    $100, %edi
-;   movl    $105, %r8d
-;   movl    $110, %r9d
-;   movl    $115, %r10d
-;   movl    $120, %r11d
-;   movl    $125, %r12d
-;   movl    $130, %r13d
-;   movl    $135, %r14d
-;   movq    %r15, 0(%rax)
-;   movq    %rcx, 8(%rax)
-;   movq    %rdx, 16(%rax)
-;   movq    %rbx, 24(%rax)
-;   movq    %rsi, 32(%rax)
-;   movq    %rdi, 40(%rax)
-;   movq    %r8, 48(%rax)
-;   movq    %r9, 56(%rax)
-;   movq    %r10, 64(%rax)
-;   movq    %r11, 72(%rax)
-;   movq    %r12, 80(%rax)
-;   movq    %r13, 88(%rax)
-;   movq    %r14, 96(%rax)
-;   movq    rsp(0 + virtual offset), %r14
-;   movq    rsp(8 + virtual offset), %r13
-;   movq    rsp(16 + virtual offset), %r12
-;   movq    rsp(24 + virtual offset), %r11
-;   movq    rsp(32 + virtual offset), %r10
-;   movq    rsp(40 + virtual offset), %r9
-;   movq    rsp(48 + virtual offset), %r8
-;   movq    rsp(56 + virtual offset), %rdi
-;   movq    rsp(64 + virtual offset), %rsi
-;   movq    rsp(72 + virtual offset), %rbx
-;   movq    rsp(80 + virtual offset), %rdx
-;   movq    rsp(88 + virtual offset), %rcx
-;   movq    rsp(96 + virtual offset), %rax
-;   addq    %rsp, $112, %rsp
+;   movq    %rsi, rsp(32 + virtual offset)
+;   movl    $100, %r8d
+;   movl    $105, %r9d
+;   movl    $110, %r10d
+;   movl    $115, %r11d
+;   movl    $120, %esi
+;   movq    %rsi, rsp(24 + virtual offset)
+;   movl    $125, %esi
+;   movq    %rsi, rsp(16 + virtual offset)
+;   movl    $130, %esi
+;   movq    %rsi, rsp(8 + virtual offset)
+;   movl    $135, %esi
+;   movq    %rsi, rsp(0 + virtual offset)
+;   movq    %r14, 0(%rdi)
+;   movq    %r15, 8(%rdi)
+;   movq    %rbx, 16(%rdi)
+;   movq    %r12, 24(%rdi)
+;   movq    %r13, 32(%rdi)
+;   movq    %rax, 40(%rdi)
+;   movq    %rcx, 48(%rdi)
+;   movq    %rdx, 56(%rdi)
+;   movq    rsp(32 + virtual offset), %rax
+;   movq    %rax, 64(%rdi)
+;   movq    %r8, 72(%rdi)
+;   movq    %r9, 80(%rdi)
+;   movq    %r10, 88(%rdi)
+;   movq    %r11, 96(%rdi)
+;   movq    rsp(24 + virtual offset), %rsi
+;   movq    %rsi, 104(%rdi)
+;   movq    rsp(16 + virtual offset), %rsi
+;   movq    %rsi, 112(%rdi)
+;   movq    rsp(8 + virtual offset), %rsi
+;   movq    %rsi, 120(%rdi)
+;   movq    rsp(0 + virtual offset), %rsi
+;   movq    %rsi, 128(%rdi)
+;   movq    rsp(104 + virtual offset), %rax
+;   movq    rsp(96 + virtual offset), %rcx
+;   movq    rsp(88 + virtual offset), %rdx
+;   movq    rsp(80 + virtual offset), %rsi
+;   movq    rsp(72 + virtual offset), %rdi
+;   movq    rsp(64 + virtual offset), %r8
+;   movq    rsp(56 + virtual offset), %r9
+;   movq    rsp(48 + virtual offset), %r10
+;   movq    rsp(40 + virtual offset), %r11
+;   movq    112(%rsp), %rbx
+;   movq    120(%rsp), %r12
+;   movq    128(%rsp), %r13
+;   movq    136(%rsp), %r14
+;   movq    144(%rsp), %r15
+;   addq    %rsp, $160, %rsp
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -262,74 +278,90 @@ block0:
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
-;   subq $0x70, %rsp
-; block1: ; offset 0x8
-;   movl $0xa, %esi
-;   movq %rsi, 0x60(%rsp)
-;   movl $0xf, %ecx
-;   movq %rcx, 0x58(%rsp)
-;   movl $0x14, %edx
-;   movq %rdx, 0x50(%rsp)
-;   movl $0x19, %ebx
-;   movq %rbx, 0x48(%rsp)
-;   movl $0x1e, %esi
-;   movq %rsi, 0x40(%rsp)
-;   movl $0x23, %edi
-;   movq %rdi, 0x38(%rsp)
-;   movl $0x28, %r8d
-;   movq %r8, 0x30(%rsp)
-;   movl $0x2d, %r9d
-;   movq %r9, 0x28(%rsp)
-;   movl $0x32, %r10d
-;   movq %r10, 0x20(%rsp)
-;   movl $0x37, %r11d
-;   movq %r11, 0x18(%rsp)
-;   movl $0x3c, %r12d
-;   movq %r12, 0x10(%rsp)
-;   movl $0x41, %r13d
-;   movq %r13, 8(%rsp)
-;   movl $0x46, %r14d
-;   movq %r14, (%rsp)
-;   movl $0x4b, %r15d
-;   movl $0x50, %ecx
-;   movl $0x55, %edx
-;   movl $0x5a, %ebx
+;   subq $0xa0, %rsp
+;   movq %rbx, 0x70(%rsp)
+;   movq %r12, 0x78(%rsp)
+;   movq %r13, 0x80(%rsp)
+;   movq %r14, 0x88(%rsp)
+;   movq %r15, 0x90(%rsp)
+; block1: ; offset 0x2d
+;   movl $0xa, %ecx
+;   movq %rcx, 0x68(%rsp)
+;   movl $0xf, %edx
+;   movq %rdx, 0x60(%rsp)
+;   movl $0x14, %esi
+;   movq %rsi, 0x58(%rsp)
+;   movl $0x19, %r8d
+;   movq %r8, 0x50(%rsp)
+;   movl $0x1e, %eax
+;   movq %rax, 0x48(%rsp)
+;   movl $0x23, %r9d
+;   movq %r9, 0x40(%rsp)
+;   movl $0x28, %r10d
+;   movq %r10, 0x38(%rsp)
+;   movl $0x2d, %r11d
+;   movq %r11, 0x30(%rsp)
+;   movl $0x32, %r11d
+;   movq %r11, 0x28(%rsp)
+;   movl $0x37, %r14d
+;   movl $0x3c, %r15d
+;   movl $0x41, %ebx
+;   movl $0x46, %r12d
+;   movl $0x4b, %r13d
+;   movl $0x50, %eax
+;   movl $0x55, %ecx
+;   movl $0x5a, %edx
 ;   movl $0x5f, %esi
-;   movl $0x64, %edi
-;   movl $0x69, %r8d
-;   movl $0x6e, %r9d
-;   movl $0x73, %r10d
-;   movl $0x78, %r11d
-;   movl $0x7d, %r12d
-;   movl $0x82, %r13d
-;   movl $0x87, %r14d
-;   movq %r15, (%rax)
-;   movq %rcx, 8(%rax)
-;   movq %rdx, 0x10(%rax)
-;   movq %rbx, 0x18(%rax)
-;   movq %rsi, 0x20(%rax)
-;   movq %rdi, 0x28(%rax)
-;   movq %r8, 0x30(%rax)
-;   movq %r9, 0x38(%rax)
-;   movq %r10, 0x40(%rax)
-;   movq %r11, 0x48(%rax)
-;   movq %r12, 0x50(%rax)
-;   movq %r13, 0x58(%rax)
-;   movq %r14, 0x60(%rax)
-;   movq (%rsp), %r14
-;   movq 8(%rsp), %r13
-;   movq 0x10(%rsp), %r12
-;   movq 0x18(%rsp), %r11
-;   movq 0x20(%rsp), %r10
-;   movq 0x28(%rsp), %r9
-;   movq 0x30(%rsp), %r8
-;   movq 0x38(%rsp), %rdi
-;   movq 0x40(%rsp), %rsi
-;   movq 0x48(%rsp), %rbx
-;   movq 0x50(%rsp), %rdx
-;   movq 0x58(%rsp), %rcx
-;   movq 0x60(%rsp), %rax
-;   addq $0x70, %rsp
+;   movq %rsi, 0x20(%rsp)
+;   movl $0x64, %r8d
+;   movl $0x69, %r9d
+;   movl $0x6e, %r10d
+;   movl $0x73, %r11d
+;   movl $0x78, %esi
+;   movq %rsi, 0x18(%rsp)
+;   movl $0x7d, %esi
+;   movq %rsi, 0x10(%rsp)
+;   movl $0x82, %esi
+;   movq %rsi, 8(%rsp)
+;   movl $0x87, %esi
+;   movq %rsi, (%rsp)
+;   movq %r14, (%rdi)
+;   movq %r15, 8(%rdi)
+;   movq %rbx, 0x10(%rdi)
+;   movq %r12, 0x18(%rdi)
+;   movq %r13, 0x20(%rdi)
+;   movq %rax, 0x28(%rdi)
+;   movq %rcx, 0x30(%rdi)
+;   movq %rdx, 0x38(%rdi)
+;   movq 0x20(%rsp), %rax
+;   movq %rax, 0x40(%rdi)
+;   movq %r8, 0x48(%rdi)
+;   movq %r9, 0x50(%rdi)
+;   movq %r10, 0x58(%rdi)
+;   movq %r11, 0x60(%rdi)
+;   movq 0x18(%rsp), %rsi
+;   movq %rsi, 0x68(%rdi)
+;   movq 0x10(%rsp), %rsi
+;   movq %rsi, 0x70(%rdi)
+;   movq 8(%rsp), %rsi
+;   movq %rsi, 0x78(%rdi)
+;   movq (%rsp), %rsi
+;   movq %rsi, 0x80(%rdi)
+;   movq 0x68(%rsp), %rax
+;   movq 0x60(%rsp), %rcx
+;   movq 0x58(%rsp), %rdx
+;   movq 0x50(%rsp), %rsi
+;   movq 0x48(%rsp), %rdi
+;   movq 0x40(%rsp), %r8
+;   movq 0x38(%rsp), %r9
+;   movq 0x30(%rsp), %r10
+;   movq 0x28(%rsp), %r11
+;   movq 0x70(%rsp), %rbx
+;   movq 0x78(%rsp), %r12
+;   movq 0x80(%rsp), %r13
+;   movq 0x88(%rsp), %r14
+;   movq 0x90(%rsp), %r15
+;   addq $0xa0, %rsp
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -345,26 +377,28 @@ block0:
 ; VCode:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
+;   subq    %rsp, $144, %rsp
 ; block0:
-;   subq    %rsp, $112, %rsp
-;   virtual_sp_offset_adjust 112
-;   lea     0(%rsp), %rax
+;   lea     0(%rsp), %rdi
 ;   call    TestCase(%tail_callee_stack_rets)
-;   movq    0(%rsp), %r11
-;   movq    8(%rsp), %rdi
-;   movq    16(%rsp), %rcx
-;   movq    24(%rsp), %r8
-;   movq    32(%rsp), %r10
-;   movq    40(%rsp), %rsi
-;   movq    48(%rsp), %rax
-;   movq    56(%rsp), %rdx
-;   movq    64(%rsp), %r9
-;   movq    72(%rsp), %r11
-;   movq    80(%rsp), %rdi
-;   movq    88(%rsp), %rcx
-;   movq    96(%rsp), %rax
-;   addq    %rsp, $112, %rsp
-;   virtual_sp_offset_adjust -112
+;   movq    0(%rsp), %rax
+;   movq    8(%rsp), %rdx
+;   movq    16(%rsp), %r9
+;   movq    24(%rsp), %r11
+;   movq    32(%rsp), %rdi
+;   movq    40(%rsp), %rcx
+;   movq    48(%rsp), %r8
+;   movq    56(%rsp), %r10
+;   movq    64(%rsp), %rsi
+;   movq    72(%rsp), %rax
+;   movq    80(%rsp), %rdx
+;   movq    88(%rsp), %r9
+;   movq    96(%rsp), %r11
+;   movq    104(%rsp), %rdi
+;   movq    112(%rsp), %rcx
+;   movq    120(%rsp), %r8
+;   movq    128(%rsp), %rax
+;   addq    %rsp, $144, %rsp
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -373,24 +407,28 @@ block0:
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
-; block1: ; offset 0x4
-;   subq $0x70, %rsp
-;   leaq (%rsp), %rax
-;   callq 0x11 ; reloc_external CallPCRel4 %tail_callee_stack_rets -4
-;   movq (%rsp), %r11
-;   movq 8(%rsp), %rdi
-;   movq 0x10(%rsp), %rcx
-;   movq 0x18(%rsp), %r8
-;   movq 0x20(%rsp), %r10
-;   movq 0x28(%rsp), %rsi
-;   movq 0x30(%rsp), %rax
-;   movq 0x38(%rsp), %rdx
-;   movq 0x40(%rsp), %r9
-;   movq 0x48(%rsp), %r11
-;   movq 0x50(%rsp), %rdi
-;   movq 0x58(%rsp), %rcx
-;   movq 0x60(%rsp), %rax
-;   addq $0x70, %rsp
+;   subq $0x90, %rsp
+; block1: ; offset 0xb
+;   leaq (%rsp), %rdi
+;   callq 0x14 ; reloc_external CallPCRel4 %tail_callee_stack_rets -4
+;   movq (%rsp), %rax
+;   movq 8(%rsp), %rdx
+;   movq 0x10(%rsp), %r9
+;   movq 0x18(%rsp), %r11
+;   movq 0x20(%rsp), %rdi
+;   movq 0x28(%rsp), %rcx
+;   movq 0x30(%rsp), %r8
+;   movq 0x38(%rsp), %r10
+;   movq 0x40(%rsp), %rsi
+;   movq 0x48(%rsp), %rax
+;   movq 0x50(%rsp), %rdx
+;   movq 0x58(%rsp), %r9
+;   movq 0x60(%rsp), %r11
+;   movq 0x68(%rsp), %rdi
+;   movq 0x70(%rsp), %rcx
+;   movq 0x78(%rsp), %r8
+;   movq 0x80(%rsp), %rax
+;   addq $0x90, %rsp
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -406,135 +444,171 @@ block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64, v6: i64, v7: i64, v
 ; VCode:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
-;   subq    %rsp, $112, %rsp
+;   subq    %rsp, $160, %rsp
+;   movq    %rbx, 112(%rsp)
+;   movq    %r12, 120(%rsp)
+;   movq    %r13, 128(%rsp)
+;   movq    %r14, 136(%rsp)
+;   movq    %r15, 144(%rsp)
 ; block0:
-;   movq    %rax, rsp(0 + virtual offset)
-;   movq    %rcx, rsp(8 + virtual offset)
+;   movq    %rdi, rsp(0 + virtual offset)
+;   movq    %rsi, rsp(8 + virtual offset)
 ;   movq    %rdx, rsp(16 + virtual offset)
-;   movq    %rbx, rsp(24 + virtual offset)
-;   movq    %rsi, rsp(32 + virtual offset)
-;   movq    %rdi, rsp(40 + virtual offset)
-;   movq    %r8, rsp(48 + virtual offset)
-;   movq    %r9, rsp(56 + virtual offset)
-;   movq    %r10, rsp(64 + virtual offset)
-;   movq    %r11, rsp(72 + virtual offset)
-;   movq    16(%rbp), %r12
-;   movq    %r12, rsp(80 + virtual offset)
-;   movq    24(%rbp), %r13
-;   movq    %r13, rsp(88 + virtual offset)
-;   movq    32(%rbp), %r14
-;   movq    %r14, rsp(96 + virtual offset)
-;   movq    40(%rbp), %r13
-;   movq    48(%rbp), %r12
-;   movq    56(%rbp), %rbx
-;   movq    64(%rbp), %r8
-;   movq    72(%rbp), %r10
-;   movq    80(%rbp), %rsi
-;   movq    88(%rbp), %rax
-;   movq    96(%rbp), %rdx
-;   movq    104(%rbp), %r9
-;   movq    112(%rbp), %r11
-;   movq    120(%rbp), %rdi
-;   movq    128(%rbp), %rcx
-;   movq    136(%rbp), %r15
-;   movq    144(%rbp), %r14
-;   movq    %r13, 0(%r14)
-;   movq    %r12, 8(%r14)
-;   movq    %rbx, 16(%r14)
-;   movq    %r8, 24(%r14)
-;   movq    %r10, 32(%r14)
-;   movq    %rsi, 40(%r14)
-;   movq    %rax, 48(%r14)
-;   movq    %rdx, 56(%r14)
-;   movq    %r9, 64(%r14)
-;   movq    %r11, 72(%r14)
-;   movq    %rdi, 80(%r14)
-;   movq    %rcx, 88(%r14)
-;   movq    %r15, 96(%r14)
+;   movq    %rcx, rsp(24 + virtual offset)
+;   movq    %r8, rsp(32 + virtual offset)
+;   movq    %r9, rsp(40 + virtual offset)
+;   movq    rbp(stack args max - 176), %r10
+;   movq    %r10, rsp(48 + virtual offset)
+;   movq    rbp(stack args max - 168), %r11
+;   movq    %r11, rsp(56 + virtual offset)
+;   movq    rbp(stack args max - 160), %r11
+;   movq    %r11, rsp(64 + virtual offset)
+;   movq    rbp(stack args max - 152), %rdx
+;   movq    rbp(stack args max - 144), %r9
+;   movq    %r9, rsp(72 + virtual offset)
+;   movq    rbp(stack args max - 136), %r11
+;   movq    %r11, rsp(80 + virtual offset)
+;   movq    rbp(stack args max - 128), %r11
+;   movq    rbp(stack args max - 120), %r10
+;   movq    rbp(stack args max - 112), %r9
+;   movq    rbp(stack args max - 104), %rsi
+;   movq    %rsi, rsp(88 + virtual offset)
+;   movq    rbp(stack args max - 96), %rdi
+;   movq    rbp(stack args max - 88), %rcx
+;   movq    rbp(stack args max - 80), %r8
+;   movq    rbp(stack args max - 72), %rsi
+;   movq    rbp(stack args max - 64), %rbx
+;   movq    rbp(stack args max - 56), %r13
+;   movq    rbp(stack args max - 48), %r15
+;   movq    rbp(stack args max - 40), %r12
+;   movq    rbp(stack args max - 32), %r14
+;   movq    rbp(stack args max - 24), %rax
+;   movq    %rax, rsp(96 + virtual offset)
+;   movq    rbp(stack args max - 16), %rax
+;   movq    %rdx, 0(%rax)
+;   movq    rsp(72 + virtual offset), %rdx
+;   movq    %rdx, 8(%rax)
+;   movq    rsp(80 + virtual offset), %rdx
+;   movq    %rdx, 16(%rax)
+;   movq    %r11, 24(%rax)
+;   movq    %r10, 32(%rax)
+;   movq    %r9, 40(%rax)
+;   movq    rsp(88 + virtual offset), %r10
+;   movq    %r10, 48(%rax)
+;   movq    %rdi, 56(%rax)
+;   movq    %rcx, 64(%rax)
+;   movq    %r8, 72(%rax)
+;   movq    %rsi, 80(%rax)
+;   movq    %rbx, 88(%rax)
+;   movq    %r13, 96(%rax)
+;   movq    %r15, 104(%rax)
+;   movq    %r12, 112(%rax)
+;   movq    %r14, 120(%rax)
+;   movq    rsp(96 + virtual offset), %rsi
+;   movq    %rsi, 128(%rax)
 ;   movq    rsp(0 + virtual offset), %rax
 ;   movq    rsp(8 + virtual offset), %rcx
 ;   movq    rsp(16 + virtual offset), %rdx
-;   movq    rsp(24 + virtual offset), %rbx
-;   movq    rsp(32 + virtual offset), %rsi
-;   movq    rsp(40 + virtual offset), %rdi
-;   movq    rsp(48 + virtual offset), %r8
-;   movq    rsp(56 + virtual offset), %r9
-;   movq    rsp(64 + virtual offset), %r10
-;   movq    rsp(72 + virtual offset), %r11
-;   movq    rsp(80 + virtual offset), %r12
-;   movq    rsp(88 + virtual offset), %r13
-;   movq    rsp(96 + virtual offset), %r14
-;   addq    %rsp, $112, %rsp
+;   movq    rsp(24 + virtual offset), %rsi
+;   movq    rsp(32 + virtual offset), %rdi
+;   movq    rsp(40 + virtual offset), %r8
+;   movq    rsp(48 + virtual offset), %r9
+;   movq    rsp(56 + virtual offset), %r10
+;   movq    rsp(64 + virtual offset), %r11
+;   movq    112(%rsp), %rbx
+;   movq    120(%rsp), %r12
+;   movq    128(%rsp), %r13
+;   movq    136(%rsp), %r14
+;   movq    144(%rsp), %r15
+;   addq    %rsp, $160, %rsp
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
-;   ret 144
+;   ret 176
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
-;   subq $0x70, %rsp
-; block1: ; offset 0x8
-;   movq %rax, (%rsp)
-;   movq %rcx, 8(%rsp)
+;   subq $0xa0, %rsp
+;   movq %rbx, 0x70(%rsp)
+;   movq %r12, 0x78(%rsp)
+;   movq %r13, 0x80(%rsp)
+;   movq %r14, 0x88(%rsp)
+;   movq %r15, 0x90(%rsp)
+; block1: ; offset 0x2d
+;   movq %rdi, (%rsp)
+;   movq %rsi, 8(%rsp)
 ;   movq %rdx, 0x10(%rsp)
-;   movq %rbx, 0x18(%rsp)
-;   movq %rsi, 0x20(%rsp)
-;   movq %rdi, 0x28(%rsp)
-;   movq %r8, 0x30(%rsp)
-;   movq %r9, 0x38(%rsp)
-;   movq %r10, 0x40(%rsp)
-;   movq %r11, 0x48(%rsp)
-;   movq 0x10(%rbp), %r12
-;   movq %r12, 0x50(%rsp)
-;   movq 0x18(%rbp), %r13
-;   movq %r13, 0x58(%rsp)
-;   movq 0x20(%rbp), %r14
-;   movq %r14, 0x60(%rsp)
-;   movq 0x28(%rbp), %r13
-;   movq 0x30(%rbp), %r12
-;   movq 0x38(%rbp), %rbx
-;   movq 0x40(%rbp), %r8
+;   movq %rcx, 0x18(%rsp)
+;   movq %r8, 0x20(%rsp)
+;   movq %r9, 0x28(%rsp)
+;   movq 0x10(%rbp), %r10
+;   movq %r10, 0x30(%rsp)
+;   movq 0x18(%rbp), %r11
+;   movq %r11, 0x38(%rsp)
+;   movq 0x20(%rbp), %r11
+;   movq %r11, 0x40(%rsp)
+;   movq 0x28(%rbp), %rdx
+;   movq 0x30(%rbp), %r9
+;   movq %r9, 0x48(%rsp)
+;   movq 0x38(%rbp), %r11
+;   movq %r11, 0x50(%rsp)
+;   movq 0x40(%rbp), %r11
 ;   movq 0x48(%rbp), %r10
-;   movq 0x50(%rbp), %rsi
-;   movq 0x58(%rbp), %rax
-;   movq 0x60(%rbp), %rdx
-;   movq 0x68(%rbp), %r9
-;   movq 0x70(%rbp), %r11
-;   movq 0x78(%rbp), %rdi
-;   movq 0x80(%rbp), %rcx
-;   movq 0x88(%rbp), %r15
-;   movq 0x90(%rbp), %r14
-;   movq %r13, (%r14)
-;   movq %r12, 8(%r14)
-;   movq %rbx, 0x10(%r14)
-;   movq %r8, 0x18(%r14)
-;   movq %r10, 0x20(%r14)
-;   movq %rsi, 0x28(%r14)
-;   movq %rax, 0x30(%r14)
-;   movq %rdx, 0x38(%r14)
-;   movq %r9, 0x40(%r14)
-;   movq %r11, 0x48(%r14)
-;   movq %rdi, 0x50(%r14)
-;   movq %rcx, 0x58(%r14)
-;   movq %r15, 0x60(%r14)
+;   movq 0x50(%rbp), %r9
+;   movq 0x58(%rbp), %rsi
+;   movq %rsi, 0x58(%rsp)
+;   movq 0x60(%rbp), %rdi
+;   movq 0x68(%rbp), %rcx
+;   movq 0x70(%rbp), %r8
+;   movq 0x78(%rbp), %rsi
+;   movq 0x80(%rbp), %rbx
+;   movq 0x88(%rbp), %r13
+;   movq 0x90(%rbp), %r15
+;   movq 0x98(%rbp), %r12
+;   movq 0xa0(%rbp), %r14
+;   movq 0xa8(%rbp), %rax
+;   movq %rax, 0x60(%rsp)
+;   movq 0xb0(%rbp), %rax
+;   movq %rdx, (%rax)
+;   movq 0x48(%rsp), %rdx
+;   movq %rdx, 8(%rax)
+;   movq 0x50(%rsp), %rdx
+;   movq %rdx, 0x10(%rax)
+;   movq %r11, 0x18(%rax)
+;   movq %r10, 0x20(%rax)
+;   movq %r9, 0x28(%rax)
+;   movq 0x58(%rsp), %r10
+;   movq %r10, 0x30(%rax)
+;   movq %rdi, 0x38(%rax)
+;   movq %rcx, 0x40(%rax)
+;   movq %r8, 0x48(%rax)
+;   movq %rsi, 0x50(%rax)
+;   movq %rbx, 0x58(%rax)
+;   movq %r13, 0x60(%rax)
+;   movq %r15, 0x68(%rax)
+;   movq %r12, 0x70(%rax)
+;   movq %r14, 0x78(%rax)
+;   movq 0x60(%rsp), %rsi
+;   movq %rsi, 0x80(%rax)
 ;   movq (%rsp), %rax
 ;   movq 8(%rsp), %rcx
 ;   movq 0x10(%rsp), %rdx
-;   movq 0x18(%rsp), %rbx
-;   movq 0x20(%rsp), %rsi
-;   movq 0x28(%rsp), %rdi
-;   movq 0x30(%rsp), %r8
-;   movq 0x38(%rsp), %r9
-;   movq 0x40(%rsp), %r10
-;   movq 0x48(%rsp), %r11
-;   movq 0x50(%rsp), %r12
-;   movq 0x58(%rsp), %r13
-;   movq 0x60(%rsp), %r14
-;   addq $0x70, %rsp
+;   movq 0x18(%rsp), %rsi
+;   movq 0x20(%rsp), %rdi
+;   movq 0x28(%rsp), %r8
+;   movq 0x30(%rsp), %r9
+;   movq 0x38(%rsp), %r10
+;   movq 0x40(%rsp), %r11
+;   movq 0x70(%rsp), %rbx
+;   movq 0x78(%rsp), %r12
+;   movq 0x80(%rsp), %r13
+;   movq 0x88(%rsp), %r14
+;   movq 0x90(%rsp), %r15
+;   addq $0xa0, %rsp
 ;   movq %rbp, %rsp
 ;   popq %rbp
-;   retq $0x90
+;   retq $0xb0
 
 function %tail_caller_stack_args_and_rets() -> i64 tail {
     fn0 = %tail_callee_stack_args_and_rets(i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64) -> i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64 tail
@@ -573,98 +647,112 @@ block0:
 ; VCode:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
-;   subq    %rsp, $112, %rsp
+;   subq    %rsp, $480, %rsp
+;   movq    %rbx, 432(%rsp)
+;   movq    %r12, 440(%rsp)
+;   movq    %r13, 448(%rsp)
+;   movq    %r14, 456(%rsp)
+;   movq    %r15, 464(%rsp)
 ; block0:
-;   movl    $10, %eax
-;   movq    %rax, rsp(96 + virtual offset)
-;   movl    $15, %ecx
-;   movq    %rcx, rsp(88 + virtual offset)
-;   movl    $20, %edx
-;   movq    %rdx, rsp(80 + virtual offset)
-;   movl    $25, %ebx
-;   movq    %rbx, rsp(72 + virtual offset)
-;   movl    $30, %esi
-;   movq    %rsi, rsp(64 + virtual offset)
-;   movl    $35, %edi
-;   movq    %rdi, rsp(56 + virtual offset)
-;   movl    $40, %r8d
-;   movq    %r8, rsp(48 + virtual offset)
-;   movl    $45, %r9d
-;   movq    %r9, rsp(40 + virtual offset)
+;   movl    $10, %esi
+;   movq    %rsi, rsp(96 + virtual offset)
+;   movl    $15, %edx
+;   movq    %rdx, rsp(88 + virtual offset)
+;   movl    $20, %ecx
+;   movq    %rcx, rsp(80 + virtual offset)
+;   movl    $25, %r8d
+;   movq    %r8, rsp(72 + virtual offset)
+;   movl    $30, %r9d
+;   movq    %r9, rsp(64 + virtual offset)
+;   movl    $35, %r9d
+;   movq    %r9, rsp(56 + virtual offset)
+;   movl    $40, %esi
+;   movq    %rsi, rsp(48 + virtual offset)
+;   movl    $45, %eax
 ;   movl    $50, %r10d
-;   movq    %r10, rsp(32 + virtual offset)
-;   movl    $55, %r11d
-;   movq    %r11, rsp(24 + virtual offset)
-;   movl    $60, %r14d
-;   movl    $65, %r15d
+;   movl    $55, %r14d
+;   movl    $60, %r15d
+;   movl    $65, %ebx
 ;   movl    $70, %r12d
 ;   movl    $75, %r13d
-;   movl    $80, %eax
-;   movl    $85, %ecx
+;   movl    $80, %edi
+;   movl    $85, %esi
 ;   movl    $90, %edx
-;   movl    $95, %ebx
-;   movl    $100, %esi
-;   movl    $105, %edi
-;   movl    $110, %r8d
-;   movl    $115, %r9d
-;   movl    $120, %r10d
+;   movl    $95, %ecx
+;   movl    $100, %r8d
+;   movl    $105, %r9d
+;   movl    $110, %r11d
+;   movq    %r11, rsp(40 + virtual offset)
+;   movl    $115, %r11d
+;   movq    %r11, rsp(32 + virtual offset)
+;   movl    $120, %r11d
+;   movq    %r11, rsp(24 + virtual offset)
 ;   movl    $125, %r11d
 ;   movq    %r11, rsp(16 + virtual offset)
 ;   movl    $130, %r11d
 ;   movq    %r11, rsp(8 + virtual offset)
 ;   movl    $135, %r11d
 ;   movq    %r11, rsp(0 + virtual offset)
-;   subq    %rsp, $256, %rsp
-;   virtual_sp_offset_adjust 256
-;   movq    %r14, 0(%rsp)
-;   movq    %r15, 8(%rsp)
-;   movq    %r12, 16(%rsp)
-;   movq    %r13, 24(%rsp)
-;   movq    %rax, 32(%rsp)
-;   movq    %rcx, 40(%rsp)
-;   movq    %rdx, 48(%rsp)
-;   movq    %rbx, 56(%rsp)
-;   movq    %rsi, 64(%rsp)
-;   movq    %rdi, 72(%rsp)
-;   movq    %r8, 80(%rsp)
-;   movq    %r9, 88(%rsp)
-;   movq    %r10, 96(%rsp)
-;   movq    rsp(16 + virtual offset), %rsi
-;   movq    %rsi, 104(%rsp)
-;   movq    rsp(8 + virtual offset), %r11
+;   movq    rsp(48 + virtual offset), %r11
+;   movq    %r11, 0(%rsp)
+;   movq    %rax, 8(%rsp)
+;   movq    %r10, 16(%rsp)
+;   movq    %r14, 24(%rsp)
+;   movq    %r15, 32(%rsp)
+;   movq    %rbx, 40(%rsp)
+;   movq    %r12, 48(%rsp)
+;   movq    %r13, 56(%rsp)
+;   movq    %rdi, 64(%rsp)
+;   movq    %rsi, 72(%rsp)
+;   movq    %rdx, 80(%rsp)
+;   movq    %rcx, 88(%rsp)
+;   movq    %r8, 96(%rsp)
+;   movq    %r9, 104(%rsp)
+;   movq    rsp(40 + virtual offset), %r11
 ;   movq    %r11, 112(%rsp)
-;   movq    rsp(0 + virtual offset), %r11
+;   movq    rsp(32 + virtual offset), %r11
 ;   movq    %r11, 120(%rsp)
-;   lea     144(%rsp), %r10
-;   movq    %r10, 128(%rsp)
-;   load_ext_name %tail_callee_stack_args_and_rets+0, %r15
 ;   movq    rsp(24 + virtual offset), %r11
-;   movq    rsp(32 + virtual offset), %r10
-;   movq    rsp(40 + virtual offset), %r9
-;   movq    rsp(48 + virtual offset), %r8
-;   movq    rsp(56 + virtual offset), %rdi
-;   movq    rsp(64 + virtual offset), %rsi
-;   movq    rsp(72 + virtual offset), %rbx
+;   movq    %r11, 128(%rsp)
+;   movq    rsp(16 + virtual offset), %r11
+;   movq    %r11, 136(%rsp)
+;   movq    rsp(8 + virtual offset), %r11
+;   movq    %r11, 144(%rsp)
+;   movq    rsp(0 + virtual offset), %r11
+;   movq    %r11, 152(%rsp)
+;   lea     176(%rsp), %rsi
+;   movq    %rsi, 160(%rsp)
+;   load_ext_name %tail_callee_stack_args_and_rets+0, %r10
+;   movq    rsp(72 + virtual offset), %rcx
 ;   movq    rsp(80 + virtual offset), %rdx
-;   movq    rsp(88 + virtual offset), %rcx
-;   movq    rsp(96 + virtual offset), %rax
-;   call    *%r15
-;   movq    0(%rsp), %r10
-;   movq    8(%rsp), %rsi
-;   movq    16(%rsp), %rax
-;   movq    24(%rsp), %rdx
-;   movq    32(%rsp), %r9
-;   movq    40(%rsp), %r11
-;   movq    48(%rsp), %rdi
-;   movq    56(%rsp), %rcx
-;   movq    64(%rsp), %r8
-;   movq    72(%rsp), %r10
-;   movq    80(%rsp), %rsi
-;   movq    88(%rsp), %rax
-;   movq    96(%rsp), %rax
-;   addq    %rsp, $112, %rsp
-;   virtual_sp_offset_adjust -112
-;   addq    %rsp, $112, %rsp
+;   movq    rsp(88 + virtual offset), %rsi
+;   movq    rsp(96 + virtual offset), %rdi
+;   movq    rsp(64 + virtual offset), %r8
+;   movq    rsp(56 + virtual offset), %r9
+;   call    *%r10
+;   movq    176(%rsp), %r8
+;   movq    184(%rsp), %r10
+;   movq    192(%rsp), %rsi
+;   movq    200(%rsp), %rax
+;   movq    208(%rsp), %rdx
+;   movq    216(%rsp), %r9
+;   movq    224(%rsp), %r11
+;   movq    232(%rsp), %rdi
+;   movq    240(%rsp), %rcx
+;   movq    248(%rsp), %r8
+;   movq    256(%rsp), %r10
+;   movq    264(%rsp), %rsi
+;   movq    272(%rsp), %rax
+;   movq    280(%rsp), %rdx
+;   movq    288(%rsp), %r9
+;   movq    296(%rsp), %r11
+;   movq    304(%rsp), %rax
+;   movq    432(%rsp), %rbx
+;   movq    440(%rsp), %r12
+;   movq    448(%rsp), %r13
+;   movq    456(%rsp), %r14
+;   movq    464(%rsp), %r15
+;   addq    %rsp, $480, %rsp
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -673,97 +761,146 @@ block0:
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
-;   subq $0x70, %rsp
-; block1: ; offset 0x8
-;   movl $0xa, %eax
-;   movq %rax, 0x60(%rsp)
-;   movl $0xf, %ecx
-;   movq %rcx, 0x58(%rsp)
-;   movl $0x14, %edx
-;   movq %rdx, 0x50(%rsp)
-;   movl $0x19, %ebx
-;   movq %rbx, 0x48(%rsp)
-;   movl $0x1e, %esi
-;   movq %rsi, 0x40(%rsp)
-;   movl $0x23, %edi
-;   movq %rdi, 0x38(%rsp)
-;   movl $0x28, %r8d
-;   movq %r8, 0x30(%rsp)
-;   movl $0x2d, %r9d
-;   movq %r9, 0x28(%rsp)
+;   subq $0x1e0, %rsp
+;   movq %rbx, 0x1b0(%rsp)
+;   movq %r12, 0x1b8(%rsp)
+;   movq %r13, 0x1c0(%rsp)
+;   movq %r14, 0x1c8(%rsp)
+;   movq %r15, 0x1d0(%rsp)
+; block1: ; offset 0x33
+;   movl $0xa, %esi
+;   movq %rsi, 0x1a0(%rsp)
+;   movl $0xf, %edx
+;   movq %rdx, 0x198(%rsp)
+;   movl $0x14, %ecx
+;   movq %rcx, 0x190(%rsp)
+;   movl $0x19, %r8d
+;   movq %r8, 0x188(%rsp)
+;   movl $0x1e, %r9d
+;   movq %r9, 0x180(%rsp)
+;   movl $0x23, %r9d
+;   movq %r9, 0x178(%rsp)
+;   movl $0x28, %esi
+;   movq %rsi, 0x170(%rsp)
+;   movl $0x2d, %eax
 ;   movl $0x32, %r10d
-;   movq %r10, 0x20(%rsp)
-;   movl $0x37, %r11d
-;   movq %r11, 0x18(%rsp)
-;   movl $0x3c, %r14d
-;   movl $0x41, %r15d
+;   movl $0x37, %r14d
+;   movl $0x3c, %r15d
+;   movl $0x41, %ebx
 ;   movl $0x46, %r12d
 ;   movl $0x4b, %r13d
-;   movl $0x50, %eax
-;   movl $0x55, %ecx
+;   movl $0x50, %edi
+;   movl $0x55, %esi
 ;   movl $0x5a, %edx
-;   movl $0x5f, %ebx
-;   movl $0x64, %esi
-;   movl $0x69, %edi
-;   movl $0x6e, %r8d
-;   movl $0x73, %r9d
-;   movl $0x78, %r10d
+;   movl $0x5f, %ecx
+;   movl $0x64, %r8d
+;   movl $0x69, %r9d
+;   movl $0x6e, %r11d
+;   movq %r11, 0x168(%rsp)
+;   movl $0x73, %r11d
+;   movq %r11, 0x160(%rsp)
+;   movl $0x78, %r11d
+;   movq %r11, 0x158(%rsp)
 ;   movl $0x7d, %r11d
-;   movq %r11, 0x10(%rsp)
+;   movq %r11, 0x150(%rsp)
 ;   movl $0x82, %r11d
-;   movq %r11, 8(%rsp)
+;   movq %r11, 0x148(%rsp)
 ;   movl $0x87, %r11d
+;   movq %r11, 0x140(%rsp)
+;   movq 0x170(%rsp), %r11
 ;   movq %r11, (%rsp)
-;   subq $0x100, %rsp
-;   movq %r14, (%rsp)
-;   movq %r15, 8(%rsp)
-;   movq %r12, 0x10(%rsp)
-;   movq %r13, 0x18(%rsp)
-;   movq %rax, 0x20(%rsp)
-;   movq %rcx, 0x28(%rsp)
-;   movq %rdx, 0x30(%rsp)
-;   movq %rbx, 0x38(%rsp)
-;   movq %rsi, 0x40(%rsp)
-;   movq %rdi, 0x48(%rsp)
-;   movq %r8, 0x50(%rsp)
-;   movq %r9, 0x58(%rsp)
-;   movq %r10, 0x60(%rsp)
-;   movq 0x110(%rsp), %rsi
-;   movq %rsi, 0x68(%rsp)
-;   movq 0x108(%rsp), %r11
+;   movq %rax, 8(%rsp)
+;   movq %r10, 0x10(%rsp)
+;   movq %r14, 0x18(%rsp)
+;   movq %r15, 0x20(%rsp)
+;   movq %rbx, 0x28(%rsp)
+;   movq %r12, 0x30(%rsp)
+;   movq %r13, 0x38(%rsp)
+;   movq %rdi, 0x40(%rsp)
+;   movq %rsi, 0x48(%rsp)
+;   movq %rdx, 0x50(%rsp)
+;   movq %rcx, 0x58(%rsp)
+;   movq %r8, 0x60(%rsp)
+;   movq %r9, 0x68(%rsp)
+;   movq 0x168(%rsp), %r11
 ;   movq %r11, 0x70(%rsp)
-;   movq 0x100(%rsp), %r11
+;   movq 0x160(%rsp), %r11
 ;   movq %r11, 0x78(%rsp)
-;   leaq 0x90(%rsp), %r10
-;   movq %r10, 0x80(%rsp)
-;   movabsq $0, %r15 ; reloc_external Abs8 %tail_callee_stack_args_and_rets 0
-;   movq 0x118(%rsp), %r11
-;   movq 0x120(%rsp), %r10
-;   movq 0x128(%rsp), %r9
-;   movq 0x130(%rsp), %r8
-;   movq 0x138(%rsp), %rdi
-;   movq 0x140(%rsp), %rsi
-;   movq 0x148(%rsp), %rbx
-;   movq 0x150(%rsp), %rdx
-;   movq 0x158(%rsp), %rcx
-;   movq 0x160(%rsp), %rax
-;   callq *%r15
-;   movq (%rsp), %r10
-;   movq 8(%rsp), %rsi
-;   movq 0x10(%rsp), %rax
-;   movq 0x18(%rsp), %rdx
-;   movq 0x20(%rsp), %r9
-;   movq 0x28(%rsp), %r11
-;   movq 0x30(%rsp), %rdi
-;   movq 0x38(%rsp), %rcx
-;   movq 0x40(%rsp), %r8
-;   movq 0x48(%rsp), %r10
-;   movq 0x50(%rsp), %rsi
-;   movq 0x58(%rsp), %rax
-;   movq 0x60(%rsp), %rax
-;   addq $0x70, %rsp
-;   addq $0x70, %rsp
+;   movq 0x158(%rsp), %r11
+;   movq %r11, 0x80(%rsp)
+;   movq 0x150(%rsp), %r11
+;   movq %r11, 0x88(%rsp)
+;   movq 0x148(%rsp), %r11
+;   movq %r11, 0x90(%rsp)
+;   movq 0x140(%rsp), %r11
+;   movq %r11, 0x98(%rsp)
+;   leaq 0xb0(%rsp), %rsi
+;   movq %rsi, 0xa0(%rsp)
+;   movabsq $0, %r10 ; reloc_external Abs8 %tail_callee_stack_args_and_rets 0
+;   movq 0x188(%rsp), %rcx
+;   movq 0x190(%rsp), %rdx
+;   movq 0x198(%rsp), %rsi
+;   movq 0x1a0(%rsp), %rdi
+;   movq 0x180(%rsp), %r8
+;   movq 0x178(%rsp), %r9
+;   callq *%r10
+;   subq $0xb0, %rsp
+;   movq 0xb0(%rsp), %r8
+;   movq 0xb8(%rsp), %r10
+;   movq 0xc0(%rsp), %rsi
+;   movq 0xc8(%rsp), %rax
+;   movq 0xd0(%rsp), %rdx
+;   movq 0xd8(%rsp), %r9
+;   movq 0xe0(%rsp), %r11
+;   movq 0xe8(%rsp), %rdi
+;   movq 0xf0(%rsp), %rcx
+;   movq 0xf8(%rsp), %r8
+;   movq 0x100(%rsp), %r10
+;   movq 0x108(%rsp), %rsi
+;   movq 0x110(%rsp), %rax
+;   movq 0x118(%rsp), %rdx
+;   movq 0x120(%rsp), %r9
+;   movq 0x128(%rsp), %r11
+;   movq 0x130(%rsp), %rax
+;   movq 0x1b0(%rsp), %rbx
+;   movq 0x1b8(%rsp), %r12
+;   movq 0x1c0(%rsp), %r13
+;   movq 0x1c8(%rsp), %r14
+;   movq 0x1d0(%rsp), %r15
+;   addq $0x1e0, %rsp
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
 
+;; Test that tail calls that shrink the argument area don't clobber the location
+;; of an indirect jump
+
+function %tail_call_indirect_with_shrink(f64, f64, i8, i32 sext, i128, i32 sext, i128, i32, i128) -> i8 tail {
+    sig0 = () -> i8 tail
+    fn0 = %callee_simple sig0
+
+block0(v0: f64, v1: f64, v2: i8, v3: i32, v4: i128, v5: i32, v6: i128, v7: i32, v8: i128):
+    v14 = func_addr.i64 fn0
+    return_call_indirect sig0, v14()
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   load_ext_name %callee_simple+0, %r10
+;   return_call_unknown %r10 (0) tmp=%r11
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movabsq $0, %r10 ; reloc_external Abs8 %callee_simple 0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   movq (%rsp), %r11
+;   movq %r11, 0x20(%rsp)
+;   addq $0x20, %rsp
+;   jmpq *%r10
+
diff --git a/cranelift/filetests/filetests/isa/x64/tail-stack-limit.clif b/cranelift/filetests/filetests/isa/x64/tail-stack-limit.clif
index bef7884f7c70..bc61fc18fb23 100644
--- a/cranelift/filetests/filetests/isa/x64/tail-stack-limit.clif
+++ b/cranelift/filetests/filetests/isa/x64/tail-stack-limit.clif
@@ -19,33 +19,34 @@ block0(v0: i64, v1: i8, v2: i8, v3: i8, v4: i8, v5: i8, v6: i8, v7: i8, v8: i128
 ; VCode:
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
-;   movq    %rax, %r14
-;   addq    %r14, $16, %r14
-;   cmpq    %rsp, %r14
+;   movq    %rdi, %r10
+;   addq    %r10, $16, %r10
+;   cmpq    %rsp, %r10
 ;   jnbe #trap=stk_ovf
 ;   subq    %rsp, $16, %rsp
 ; block0:
-;   movq    %r10, %rax
-;   movq    %r11, %rcx
+;   movq    rbp(stack args max - 16), %rax
+;   movq    rbp(stack args max - 8), %rcx
 ;   addq    %rsp, $16, %rsp
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
-;   ret
+;   ret 32
 ;
 ; Disassembled:
 ; block0: ; offset 0x0
 ;   pushq %rbp
 ;   movq %rsp, %rbp
-;   movq %rax, %r14
-;   addq $0x10, %r14
-;   cmpq %rsp, %r14
-;   ja 0x27
+;   movq %rdi, %r10
+;   addq $0x10, %r10
+;   cmpq %rsp, %r10
+;   ja 0x2b
 ;   subq $0x10, %rsp
 ; block1: ; offset 0x18
-;   movq %r10, %rax
-;   movq %r11, %rcx
+;   movq 0x20(%rbp), %rax
+;   movq 0x28(%rbp), %rcx
 ;   addq $0x10, %rsp
 ;   movq %rbp, %rsp
 ;   popq %rbp
-;   retq
+;   retq $0x20
 ;   ud2 ; trap: stk_ovf
+
diff --git a/cranelift/filetests/filetests/isa/x64/traps.clif b/cranelift/filetests/filetests/isa/x64/traps.clif
index bd3e81ee3bf0..6645ecb3bb77 100644
--- a/cranelift/filetests/filetests/isa/x64/traps.clif
+++ b/cranelift/filetests/filetests/isa/x64/traps.clif
@@ -29,8 +29,7 @@ block0(v0: i64, v1: i64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rdi, %rcx
-;   addq    %rcx, %rsi, %rcx
+;   addq    %rdi, %rsi, %rdi
 ;   jb #trap=user0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -41,9 +40,8 @@ block0(v0: i64, v1: i64):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rdi, %rcx
-;   addq %rsi, %rcx
-;   jb 0x15
+;   addq %rsi, %rdi
+;   jb 0x12
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
diff --git a/cranelift/filetests/filetests/isa/x64/udiv.clif b/cranelift/filetests/filetests/isa/x64/udiv.clif
index 619cb79916b4..56b70ec88983 100644
--- a/cranelift/filetests/filetests/isa/x64/udiv.clif
+++ b/cranelift/filetests/filetests/isa/x64/udiv.clif
@@ -38,8 +38,8 @@ block0(v0: i16, v1: i16):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rdi, %rax
 ;   xorq    %rdx, %rdx, %rdx
+;   movq    %rdi, %rax
 ;   div     %ax, %dx, %si, %ax, %dx ; trap=int_divz
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -50,8 +50,8 @@ block0(v0: i16, v1: i16):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rdi, %rax
 ;   xorq %rdx, %rdx
+;   movq %rdi, %rax
 ;   divw %si ; trap: int_divz
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -67,8 +67,8 @@ block0(v0: i32, v1: i32):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rdi, %rax
 ;   xorq    %rdx, %rdx, %rdx
+;   movq    %rdi, %rax
 ;   div     %eax, %edx, %esi, %eax, %edx ; trap=int_divz
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -79,8 +79,8 @@ block0(v0: i32, v1: i32):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rdi, %rax
 ;   xorq %rdx, %rdx
+;   movq %rdi, %rax
 ;   divl %esi ; trap: int_divz
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -96,8 +96,8 @@ block0(v0: i64, v1: i64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rdi, %rax
 ;   xorq    %rdx, %rdx, %rdx
+;   movq    %rdi, %rax
 ;   div     %rax, %rdx, %rsi, %rax, %rdx ; trap=int_divz
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -108,8 +108,8 @@ block0(v0: i64, v1: i64):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rdi, %rax
 ;   xorq %rdx, %rdx
+;   movq %rdi, %rax
 ;   divq %rsi ; trap: int_divz
 ;   movq %rbp, %rsp
 ;   popq %rbp
diff --git a/cranelift/filetests/filetests/isa/x64/udivrem.clif b/cranelift/filetests/filetests/isa/x64/udivrem.clif
index 1468447aa1da..eb1e5da9ea32 100644
--- a/cranelift/filetests/filetests/isa/x64/udivrem.clif
+++ b/cranelift/filetests/filetests/isa/x64/udivrem.clif
@@ -16,12 +16,12 @@ block0(v0: i8, v1: i8):
 ; block0:
 ;   movzbl  %dil, %eax
 ;   div     %al, %sil, %al ; trap=int_divz
-;   movq    %rax, %r11
+;   movq    %rax, %rcx
 ;   movzbl  %dil, %eax
 ;   div     %al, %sil, %al ; trap=int_divz
 ;   movq    %rax, %rdx
 ;   shrq    $8, %rdx, %rdx
-;   movq    %r11, %rax
+;   movq    %rcx, %rax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -33,12 +33,12 @@ block0(v0: i8, v1: i8):
 ; block1: ; offset 0x4
 ;   movzbl %dil, %eax
 ;   divb %sil ; trap: int_divz
-;   movq %rax, %r11
+;   movq %rax, %rcx
 ;   movzbl %dil, %eax
 ;   divb %sil ; trap: int_divz
 ;   movq %rax, %rdx
 ;   shrq $8, %rdx
-;   movq %r11, %rax
+;   movq %rcx, %rax
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -58,8 +58,8 @@ block0(v0: i16, v1: i16):
 ;   movq    %rdi, %rax
 ;   div     %ax, %dx, %si, %ax, %dx ; trap=int_divz
 ;   movq    %rax, %rcx
-;   movq    %rdi, %rax
 ;   xorq    %rdx, %rdx, %rdx
+;   movq    %rdi, %rax
 ;   div     %ax, %dx, %si, %ax, %dx ; trap=int_divz
 ;   movq    %rcx, %rax
 ;   movq    %rbp, %rsp
@@ -75,8 +75,8 @@ block0(v0: i16, v1: i16):
 ;   movq %rdi, %rax
 ;   divw %si ; trap: int_divz
 ;   movq %rax, %rcx
-;   movq %rdi, %rax
 ;   xorq %rdx, %rdx
+;   movq %rdi, %rax
 ;   divw %si ; trap: int_divz
 ;   movq %rcx, %rax
 ;   movq %rbp, %rsp
@@ -98,8 +98,8 @@ block0(v0: i32, v1: i32):
 ;   movq    %rdi, %rax
 ;   div     %eax, %edx, %esi, %eax, %edx ; trap=int_divz
 ;   movq    %rax, %rcx
-;   movq    %rdi, %rax
 ;   xorq    %rdx, %rdx, %rdx
+;   movq    %rdi, %rax
 ;   div     %eax, %edx, %esi, %eax, %edx ; trap=int_divz
 ;   movq    %rcx, %rax
 ;   movq    %rbp, %rsp
@@ -115,8 +115,8 @@ block0(v0: i32, v1: i32):
 ;   movq %rdi, %rax
 ;   divl %esi ; trap: int_divz
 ;   movq %rax, %rcx
-;   movq %rdi, %rax
 ;   xorq %rdx, %rdx
+;   movq %rdi, %rax
 ;   divl %esi ; trap: int_divz
 ;   movq %rcx, %rax
 ;   movq %rbp, %rsp
@@ -138,8 +138,8 @@ block0(v0: i64, v1: i64):
 ;   movq    %rdi, %rax
 ;   div     %rax, %rdx, %rsi, %rax, %rdx ; trap=int_divz
 ;   movq    %rax, %rcx
-;   movq    %rdi, %rax
 ;   xorq    %rdx, %rdx, %rdx
+;   movq    %rdi, %rax
 ;   div     %rax, %rdx, %rsi, %rax, %rdx ; trap=int_divz
 ;   movq    %rcx, %rax
 ;   movq    %rbp, %rsp
@@ -155,8 +155,8 @@ block0(v0: i64, v1: i64):
 ;   movq %rdi, %rax
 ;   divq %rsi ; trap: int_divz
 ;   movq %rax, %rcx
-;   movq %rdi, %rax
 ;   xorq %rdx, %rdx
+;   movq %rdi, %rax
 ;   divq %rsi ; trap: int_divz
 ;   movq %rcx, %rax
 ;   movq %rbp, %rsp
diff --git a/cranelift/filetests/filetests/isa/x64/uext-sext-handling.clif b/cranelift/filetests/filetests/isa/x64/uext-sext-handling.clif
new file mode 100644
index 000000000000..aeeb94370767
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/uext-sext-handling.clif
@@ -0,0 +1,37 @@
+test compile
+target x86_64
+
+; The x86_64 system_v call conv respects uext and sext
+function u0:0(i8) system_v {
+    sig0 = (i8 uext) system_v
+    fn0 = u0:0 sig0
+
+block0(v0: i8):
+    call fn0(v0)
+    return
+}
+
+; check:  pushq   %rbp
+; nextln: movq    %rsp, %rbp
+; nextln: block0:
+; nextln: movzbq  %dil, %rdi
+; nextln: load_ext_name userextname0+0, %rdx
+; nextln: call    *%rdx
+
+; The x86_64 windows_fastcall call conv respects uext and sext
+function u0:0(i8) windows_fastcall {
+    sig0 = (i8 uext) windows_fastcall
+    fn0 = u0:0 sig0
+
+block0(v0: i8):
+    call fn0(v0)
+    return
+}
+
+; check: pushq   %rbp
+; nextln: movq    %rsp, %rbp
+; nextln: subq    %rsp, $$32, %rsp
+; nextln: block0:
+; nextln: movzbq  %cl, %rcx
+; nextln: load_ext_name userextname0+0, %rdx
+; nextln: call    *%rdx
diff --git a/cranelift/filetests/filetests/isa/x64/umulhi.clif b/cranelift/filetests/filetests/isa/x64/umulhi.clif
index e910de46ee6f..e68df725c1b8 100644
--- a/cranelift/filetests/filetests/isa/x64/umulhi.clif
+++ b/cranelift/filetests/filetests/isa/x64/umulhi.clif
@@ -1,6 +1,35 @@
 test compile precise-output
 target x86_64
 
+function %umulhi_i8(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+  v2 = umulhi v0, v1
+  return v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movq    %rdi, %rax
+;   mulb    %al, %sil, %al
+;   shrw    $8, %ax, %ax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movq %rdi, %rax
+;   mulb %sil
+;   shrw $8, %ax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
 function %f1(i16, i16) -> i16 {
 block0(v0: i16, v1: i16):
   v2 = umulhi v0, v1
@@ -12,7 +41,7 @@ block0(v0: i16, v1: i16):
 ;   movq    %rsp, %rbp
 ; block0:
 ;   movq    %rdi, %rax
-;   mul     %ax, %si, %ax, %dx
+;   mulw    %ax, %si, %ax, %dx
 ;   movq    %rdx, %rax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -41,7 +70,7 @@ block0(v0: i32, v1: i32):
 ;   movq    %rsp, %rbp
 ; block0:
 ;   movq    %rdi, %rax
-;   mul     %eax, %esi, %eax, %edx
+;   mull    %eax, %esi, %eax, %edx
 ;   movq    %rdx, %rax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -70,7 +99,7 @@ block0(v0: i64, v1: i64):
 ;   movq    %rsp, %rbp
 ; block0:
 ;   movq    %rdi, %rax
-;   mul     %rax, %rsi, %rax, %rdx
+;   mulq    %rax, %rsi, %rax, %rdx
 ;   movq    %rdx, %rax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
diff --git a/cranelift/filetests/filetests/isa/x64/urem.clif b/cranelift/filetests/filetests/isa/x64/urem.clif
index e886fcc94f25..50a63d9402a5 100644
--- a/cranelift/filetests/filetests/isa/x64/urem.clif
+++ b/cranelift/filetests/filetests/isa/x64/urem.clif
@@ -40,8 +40,8 @@ block0(v0: i16, v1: i16):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rdi, %rax
 ;   xorq    %rdx, %rdx, %rdx
+;   movq    %rdi, %rax
 ;   div     %ax, %dx, %si, %ax, %dx ; trap=int_divz
 ;   movq    %rdx, %rax
 ;   movq    %rbp, %rsp
@@ -53,8 +53,8 @@ block0(v0: i16, v1: i16):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rdi, %rax
 ;   xorq %rdx, %rdx
+;   movq %rdi, %rax
 ;   divw %si ; trap: int_divz
 ;   movq %rdx, %rax
 ;   movq %rbp, %rsp
@@ -71,8 +71,8 @@ block0(v0: i32, v1: i32):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rdi, %rax
 ;   xorq    %rdx, %rdx, %rdx
+;   movq    %rdi, %rax
 ;   div     %eax, %edx, %esi, %eax, %edx ; trap=int_divz
 ;   movq    %rdx, %rax
 ;   movq    %rbp, %rsp
@@ -84,8 +84,8 @@ block0(v0: i32, v1: i32):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rdi, %rax
 ;   xorq %rdx, %rdx
+;   movq %rdi, %rax
 ;   divl %esi ; trap: int_divz
 ;   movq %rdx, %rax
 ;   movq %rbp, %rsp
@@ -102,8 +102,8 @@ block0(v0: i64, v1: i64):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movq    %rdi, %rax
 ;   xorq    %rdx, %rdx, %rdx
+;   movq    %rdi, %rax
 ;   div     %rax, %rdx, %rsi, %rax, %rdx ; trap=int_divz
 ;   movq    %rdx, %rax
 ;   movq    %rbp, %rsp
@@ -115,8 +115,8 @@ block0(v0: i64, v1: i64):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movq %rdi, %rax
 ;   xorq %rdx, %rdx
+;   movq %rdi, %rax
 ;   divq %rsi ; trap: int_divz
 ;   movq %rdx, %rax
 ;   movq %rbp, %rsp
diff --git a/cranelift/filetests/filetests/isa/x64/user_stack_maps.clif b/cranelift/filetests/filetests/isa/x64/user_stack_maps.clif
new file mode 100644
index 000000000000..3ebdc9d5cc9c
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/user_stack_maps.clif
@@ -0,0 +1,235 @@
+test compile precise-output
+set unwind_info=false
+set enable_probestack=false
+target x86_64
+
+function %foo() system_v {
+    ss0 = explicit_slot 12, align = 4
+    sig0 = (i32) system_v
+    fn0 = colocated u0:0 sig0
+
+block0:
+    v0 = iconst.i32 0
+    v1 = iconst.i32 1
+    v2 = iconst.i32 2
+    v3 = iconst.i32 3
+
+    stack_store v0, ss0
+    stack_store v1, ss0+4
+    stack_store v2, ss0+8
+    call fn0(v0), stack_map=[i32 @ ss0+0, i32 @ ss0+4, i32 @ ss0+8]
+
+    stack_store v1, ss0
+    stack_store v2, ss0+4
+    call fn0(v0), stack_map=[i32 @ ss0+0, i32 @ ss0+4]
+
+    stack_store v2, ss0
+    call fn0(v1), stack_map=[i32 @ ss0+0]
+
+    call fn0(v2)
+
+    return
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+;   subq    %rsp, $48, %rsp
+;   movq    %rbx, 16(%rsp)
+;   movq    %r14, 24(%rsp)
+;   movq    %r15, 32(%rsp)
+; block0:
+;   xorl    %ebx, %ebx, %ebx
+;   movl    $1, %r14d
+;   movl    $2, %r15d
+;   lea     rsp(0 + virtual offset), %r11
+;   movl    $0, 0(%r11)
+;   lea     rsp(4 + virtual offset), %rsi
+;   movl    $1, 0(%rsi)
+;   lea     rsp(8 + virtual offset), %rdi
+;   movl    $2, 0(%rdi)
+;   movq    %rbx, %rdi
+;   call    User(userextname0)
+;   ; UserStackMap { by_type: [(types::I32, CompoundBitSet {0, 4, 8})], sp_to_sized_stack_slots: None }
+;   lea     rsp(0 + virtual offset), %rcx
+;   movl    $1, 0(%rcx)
+;   lea     rsp(4 + virtual offset), %rdx
+;   movl    $2, 0(%rdx)
+;   movq    %rbx, %rdi
+;   call    User(userextname0)
+;   ; UserStackMap { by_type: [(types::I32, CompoundBitSet {0, 4})], sp_to_sized_stack_slots: None }
+;   lea     rsp(0 + virtual offset), %r9
+;   movl    $2, 0(%r9)
+;   movq    %r14, %rdi
+;   call    User(userextname0)
+;   ; UserStackMap { by_type: [(types::I32, CompoundBitSet {0})], sp_to_sized_stack_slots: None }
+;   movq    %r15, %rdi
+;   call    User(userextname0)
+;   movq    16(%rsp), %rbx
+;   movq    24(%rsp), %r14
+;   movq    32(%rsp), %r15
+;   addq    %rsp, $48, %rsp
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+;   subq $0x30, %rsp
+;   movq %rbx, 0x10(%rsp)
+;   movq %r14, 0x18(%rsp)
+;   movq %r15, 0x20(%rsp)
+; block1: ; offset 0x17
+;   xorl %ebx, %ebx
+;   movl $1, %r14d
+;   movl $2, %r15d
+;   leaq (%rsp), %r11
+;   movl $0, (%r11)
+;   leaq 4(%rsp), %rsi
+;   movl $1, (%rsi)
+;   leaq 8(%rsp), %rdi
+;   movl $2, (%rdi)
+;   movq %rbx, %rdi
+;   callq 0x4e ; reloc_external CallPCRel4 u0:0 -4
+;   leaq (%rsp), %rcx
+;   movl $1, (%rcx)
+;   leaq 4(%rsp), %rdx
+;   movl $2, (%rdx)
+;   movq %rbx, %rdi
+;   callq 0x6b ; reloc_external CallPCRel4 u0:0 -4
+;   leaq (%rsp), %r9
+;   movl $2, (%r9)
+;   movq %r14, %rdi
+;   callq 0x7e ; reloc_external CallPCRel4 u0:0 -4
+;   movq %r15, %rdi
+;   callq 0x86 ; reloc_external CallPCRel4 u0:0 -4
+;   movq 0x10(%rsp), %rbx
+;   movq 0x18(%rsp), %r14
+;   movq 0x20(%rsp), %r15
+;   addq $0x30, %rsp
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %different_types(i8, i16, i32, i64, f32, f64) -> i8, i16, i32, i64, f32, f64 {
+    ss0 = explicit_slot 1
+    ss1 = explicit_slot 2, align = 2
+    ss2 = explicit_slot 8, align = 4
+    ss3 = explicit_slot 16, align = 8
+    ss4 = explicit_slot 48, align = 16
+    sig0 = () system_v
+    fn0 = colocated u0:0 sig0
+
+block0(v0: i8, v1: i16, v2: i32, v3: i64, v4: f32, v5: f64):
+    stack_store v0, ss0
+    stack_store v1, ss1
+    stack_store v2, ss2
+    stack_store v4, ss2+4
+    stack_store v3, ss3
+    stack_store v5, ss3+8
+    call fn0(), stack_map=[i8 @ ss0+0, i16 @ ss1+0, i32 @ ss2+0, f32 @ ss2+4, i64 @ ss3+0, f64 @ ss3+8]
+    return v0, v1, v2, v3, v4, v5
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+;   subq    %rsp, $176, %rsp
+;   movq    %rbx, 128(%rsp)
+;   movq    %r12, 136(%rsp)
+;   movq    %r13, 144(%rsp)
+;   movq    %r14, 152(%rsp)
+;   movq    %r15, 160(%rsp)
+; block0:
+;   movq    %r8, %r13
+;   lea     rsp(0 + virtual offset), %r8
+;   movb    %dil, 0(%r8)
+;   movq    %rdi, %r15
+;   lea     rsp(8 + virtual offset), %r8
+;   movw    %si, 0(%r8)
+;   movq    %rsi, %r12
+;   lea     rsp(16 + virtual offset), %r9
+;   movl    %edx, 0(%r9)
+;   movq    %rdx, %rbx
+;   lea     rsp(20 + virtual offset), %r10
+;   movss   %xmm0, 0(%r10)
+;   movdqu  %xmm0, rsp(96 + virtual offset)
+;   lea     rsp(24 + virtual offset), %r11
+;   movq    %rcx, 0(%r11)
+;   movq    %rcx, %r14
+;   lea     rsp(32 + virtual offset), %rsi
+;   movsd   %xmm1, 0(%rsi)
+;   movdqu  %xmm1, rsp(112 + virtual offset)
+;   call    User(userextname0)
+;   ; UserStackMap { by_type: [(types::I8, CompoundBitSet {0}), (types::I16, CompoundBitSet {8}), (types::I32, CompoundBitSet {16}), (types::F32, CompoundBitSet {20}), (types::I64, CompoundBitSet {24}), (types::F64, CompoundBitSet {32})], sp_to_sized_stack_slots: None }
+;   movq    %rbx, %rdx
+;   movq    %r13, %r8
+;   movl    %edx, 0(%r8)
+;   movq    %r14, %rcx
+;   movq    %rcx, 8(%r8)
+;   movq    %r15, %rax
+;   movq    %r12, %rdx
+;   movdqu  rsp(96 + virtual offset), %xmm0
+;   movdqu  rsp(112 + virtual offset), %xmm1
+;   movq    128(%rsp), %rbx
+;   movq    136(%rsp), %r12
+;   movq    144(%rsp), %r13
+;   movq    152(%rsp), %r14
+;   movq    160(%rsp), %r15
+;   addq    %rsp, $176, %rsp
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+;   subq $0xb0, %rsp
+;   movq %rbx, 0x80(%rsp)
+;   movq %r12, 0x88(%rsp)
+;   movq %r13, 0x90(%rsp)
+;   movq %r14, 0x98(%rsp)
+;   movq %r15, 0xa0(%rsp)
+; block1: ; offset 0x33
+;   movq %r8, %r13
+;   leaq (%rsp), %r8
+;   movb %dil, (%r8)
+;   movq %rdi, %r15
+;   leaq 8(%rsp), %r8
+;   movw %si, (%r8)
+;   movq %rsi, %r12
+;   leaq 0x10(%rsp), %r9
+;   movl %edx, (%r9)
+;   movq %rdx, %rbx
+;   leaq 0x14(%rsp), %r10
+;   movss %xmm0, (%r10)
+;   movdqu %xmm0, 0x60(%rsp)
+;   leaq 0x18(%rsp), %r11
+;   movq %rcx, (%r11)
+;   movq %rcx, %r14
+;   leaq 0x20(%rsp), %rsi
+;   movsd %xmm1, (%rsi)
+;   movdqu %xmm1, 0x70(%rsp)
+;   callq 0x86 ; reloc_external CallPCRel4 u0:0 -4
+;   movq %rbx, %rdx
+;   movq %r13, %r8
+;   movl %edx, (%r8)
+;   movq %r14, %rcx
+;   movq %rcx, 8(%r8)
+;   movq %r15, %rax
+;   movq %r12, %rdx
+;   movdqu 0x60(%rsp), %xmm0
+;   movdqu 0x70(%rsp), %xmm1
+;   movq 0x80(%rsp), %rbx
+;   movq 0x88(%rsp), %r12
+;   movq 0x90(%rsp), %r13
+;   movq 0x98(%rsp), %r14
+;   movq 0xa0(%rsp), %r15
+;   addq $0xb0, %rsp
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/ushr.clif b/cranelift/filetests/filetests/isa/x64/ushr.clif
index 710f35a11f33..8c760f2d48f0 100644
--- a/cranelift/filetests/filetests/isa/x64/ushr.clif
+++ b/cranelift/filetests/filetests/isa/x64/ushr.clif
@@ -17,23 +17,21 @@ block0(v0: i128, v1: i8):
 ;   movq    %rsp, %rbp
 ; block0:
 ;   movzbq  %dl, %rcx
-;   movq    %rdi, %r8
-;   shrq    %cl, %r8, %r8
+;   shrq    %cl, %rdi, %rdi
 ;   movq    %rsi, %r10
 ;   shrq    %cl, %r10, %r10
 ;   movq    %rcx, %r9
 ;   movl    $64, %ecx
-;   movq    %r9, %rdi
-;   subq    %rcx, %rdi, %rcx
-;   movq    %rsi, %r11
-;   shlq    %cl, %r11, %r11
+;   movq    %r9, %rax
+;   subq    %rcx, %rax, %rcx
+;   shlq    %cl, %rsi, %rsi
 ;   xorq    %rdx, %rdx, %rdx
-;   testq   $127, %rdi
-;   cmovzq  %rdx, %r11, %r11
-;   orq     %r11, %r8, %r11
-;   testq   $64, %rdi
+;   testq   $127, %rax
+;   cmovzq  %rdx, %rsi, %rsi
+;   orq     %rsi, %rdi, %rsi
+;   testq   $64, %rax
 ;   movq    %r10, %rax
-;   cmovzq  %r11, %rax, %rax
+;   cmovzq  %rsi, %rax, %rax
 ;   cmovzq  %r10, %rdx, %rdx
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -45,23 +43,21 @@ block0(v0: i128, v1: i8):
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
 ;   movzbq %dl, %rcx
-;   movq %rdi, %r8
-;   shrq %cl, %r8
+;   shrq %cl, %rdi
 ;   movq %rsi, %r10
 ;   shrq %cl, %r10
 ;   movq %rcx, %r9
 ;   movl $0x40, %ecx
-;   movq %r9, %rdi
-;   subq %rdi, %rcx
-;   movq %rsi, %r11
-;   shlq %cl, %r11
+;   movq %r9, %rax
+;   subq %rax, %rcx
+;   shlq %cl, %rsi
 ;   xorq %rdx, %rdx
-;   testq $0x7f, %rdi
-;   cmoveq %rdx, %r11
-;   orq %r8, %r11
-;   testq $0x40, %rdi
+;   testq $0x7f, %rax
+;   cmoveq %rdx, %rsi
+;   orq %rdi, %rsi
+;   testq $0x40, %rax
 ;   movq %r10, %rax
-;   cmoveq %r11, %rax
+;   cmoveq %rsi, %rax
 ;   cmoveq %r10, %rdx
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -79,23 +75,21 @@ block0(v0: i128, v1: i64):
 ; block0:
 ;   movq    %rdx, %rcx
 ;   movq    %rdx, %r10
-;   movq    %rdi, %r8
-;   shrq    %cl, %r8, %r8
+;   shrq    %cl, %rdi, %rdi
 ;   movq    %rsi, %r9
 ;   shrq    %cl, %r9, %r9
 ;   movq    %rcx, %r10
 ;   movl    $64, %ecx
-;   movq    %r10, %rdi
-;   subq    %rcx, %rdi, %rcx
-;   movq    %rsi, %r10
-;   shlq    %cl, %r10, %r10
+;   movq    %r10, %rax
+;   subq    %rcx, %rax, %rcx
+;   shlq    %cl, %rsi, %rsi
 ;   xorq    %rdx, %rdx, %rdx
-;   testq   $127, %rdi
-;   cmovzq  %rdx, %r10, %r10
-;   orq     %r10, %r8, %r10
-;   testq   $64, %rdi
+;   testq   $127, %rax
+;   cmovzq  %rdx, %rsi, %rsi
+;   orq     %rsi, %rdi, %rsi
+;   testq   $64, %rax
 ;   movq    %r9, %rax
-;   cmovzq  %r10, %rax, %rax
+;   cmovzq  %rsi, %rax, %rax
 ;   cmovzq  %r9, %rdx, %rdx
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -108,23 +102,21 @@ block0(v0: i128, v1: i64):
 ; block1: ; offset 0x4
 ;   movq %rdx, %rcx
 ;   movq %rdx, %r10
-;   movq %rdi, %r8
-;   shrq %cl, %r8
+;   shrq %cl, %rdi
 ;   movq %rsi, %r9
 ;   shrq %cl, %r9
 ;   movq %rcx, %r10
 ;   movl $0x40, %ecx
-;   movq %r10, %rdi
-;   subq %rdi, %rcx
-;   movq %rsi, %r10
-;   shlq %cl, %r10
+;   movq %r10, %rax
+;   subq %rax, %rcx
+;   shlq %cl, %rsi
 ;   xorq %rdx, %rdx
-;   testq $0x7f, %rdi
-;   cmoveq %rdx, %r10
-;   orq %r8, %r10
-;   testq $0x40, %rdi
+;   testq $0x7f, %rax
+;   cmoveq %rdx, %rsi
+;   orq %rdi, %rsi
+;   testq $0x40, %rax
 ;   movq %r9, %rax
-;   cmoveq %r10, %rax
+;   cmoveq %rsi, %rax
 ;   cmoveq %r9, %rdx
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -142,23 +134,21 @@ block0(v0: i128, v1: i32):
 ; block0:
 ;   movq    %rdx, %rcx
 ;   movq    %rdx, %r10
-;   movq    %rdi, %r8
-;   shrq    %cl, %r8, %r8
+;   shrq    %cl, %rdi, %rdi
 ;   movq    %rsi, %r9
 ;   shrq    %cl, %r9, %r9
 ;   movq    %rcx, %r10
 ;   movl    $64, %ecx
-;   movq    %r10, %rdi
-;   subq    %rcx, %rdi, %rcx
-;   movq    %rsi, %r10
-;   shlq    %cl, %r10, %r10
+;   movq    %r10, %rax
+;   subq    %rcx, %rax, %rcx
+;   shlq    %cl, %rsi, %rsi
 ;   xorq    %rdx, %rdx, %rdx
-;   testq   $127, %rdi
-;   cmovzq  %rdx, %r10, %r10
-;   orq     %r10, %r8, %r10
-;   testq   $64, %rdi
+;   testq   $127, %rax
+;   cmovzq  %rdx, %rsi, %rsi
+;   orq     %rsi, %rdi, %rsi
+;   testq   $64, %rax
 ;   movq    %r9, %rax
-;   cmovzq  %r10, %rax, %rax
+;   cmovzq  %rsi, %rax, %rax
 ;   cmovzq  %r9, %rdx, %rdx
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -171,23 +161,21 @@ block0(v0: i128, v1: i32):
 ; block1: ; offset 0x4
 ;   movq %rdx, %rcx
 ;   movq %rdx, %r10
-;   movq %rdi, %r8
-;   shrq %cl, %r8
+;   shrq %cl, %rdi
 ;   movq %rsi, %r9
 ;   shrq %cl, %r9
 ;   movq %rcx, %r10
 ;   movl $0x40, %ecx
-;   movq %r10, %rdi
-;   subq %rdi, %rcx
-;   movq %rsi, %r10
-;   shlq %cl, %r10
+;   movq %r10, %rax
+;   subq %rax, %rcx
+;   shlq %cl, %rsi
 ;   xorq %rdx, %rdx
-;   testq $0x7f, %rdi
-;   cmoveq %rdx, %r10
-;   orq %r8, %r10
-;   testq $0x40, %rdi
+;   testq $0x7f, %rax
+;   cmoveq %rdx, %rsi
+;   orq %rdi, %rsi
+;   testq $0x40, %rax
 ;   movq %r9, %rax
-;   cmoveq %r10, %rax
+;   cmoveq %rsi, %rax
 ;   cmoveq %r9, %rdx
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -205,23 +193,21 @@ block0(v0: i128, v1: i16):
 ; block0:
 ;   movq    %rdx, %rcx
 ;   movq    %rdx, %r10
-;   movq    %rdi, %r8
-;   shrq    %cl, %r8, %r8
+;   shrq    %cl, %rdi, %rdi
 ;   movq    %rsi, %r9
 ;   shrq    %cl, %r9, %r9
 ;   movq    %rcx, %r10
 ;   movl    $64, %ecx
-;   movq    %r10, %rdi
-;   subq    %rcx, %rdi, %rcx
-;   movq    %rsi, %r10
-;   shlq    %cl, %r10, %r10
+;   movq    %r10, %rax
+;   subq    %rcx, %rax, %rcx
+;   shlq    %cl, %rsi, %rsi
 ;   xorq    %rdx, %rdx, %rdx
-;   testq   $127, %rdi
-;   cmovzq  %rdx, %r10, %r10
-;   orq     %r10, %r8, %r10
-;   testq   $64, %rdi
+;   testq   $127, %rax
+;   cmovzq  %rdx, %rsi, %rsi
+;   orq     %rsi, %rdi, %rsi
+;   testq   $64, %rax
 ;   movq    %r9, %rax
-;   cmovzq  %r10, %rax, %rax
+;   cmovzq  %rsi, %rax, %rax
 ;   cmovzq  %r9, %rdx, %rdx
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -234,23 +220,21 @@ block0(v0: i128, v1: i16):
 ; block1: ; offset 0x4
 ;   movq %rdx, %rcx
 ;   movq %rdx, %r10
-;   movq %rdi, %r8
-;   shrq %cl, %r8
+;   shrq %cl, %rdi
 ;   movq %rsi, %r9
 ;   shrq %cl, %r9
 ;   movq %rcx, %r10
 ;   movl $0x40, %ecx
-;   movq %r10, %rdi
-;   subq %rdi, %rcx
-;   movq %rsi, %r10
-;   shlq %cl, %r10
+;   movq %r10, %rax
+;   subq %rax, %rcx
+;   shlq %cl, %rsi
 ;   xorq %rdx, %rdx
-;   testq $0x7f, %rdi
-;   cmoveq %rdx, %r10
-;   orq %r8, %r10
-;   testq $0x40, %rdi
+;   testq $0x7f, %rax
+;   cmoveq %rdx, %rsi
+;   orq %rdi, %rsi
+;   testq $0x40, %rax
 ;   movq %r9, %rax
-;   cmoveq %r10, %rax
+;   cmoveq %rsi, %rax
 ;   cmoveq %r9, %rdx
 ;   movq %rbp, %rsp
 ;   popq %rbp
@@ -268,23 +252,21 @@ block0(v0: i128, v1: i8):
 ; block0:
 ;   movq    %rdx, %rcx
 ;   movq    %rdx, %r10
-;   movq    %rdi, %r8
-;   shrq    %cl, %r8, %r8
+;   shrq    %cl, %rdi, %rdi
 ;   movq    %rsi, %r9
 ;   shrq    %cl, %r9, %r9
 ;   movq    %rcx, %r10
 ;   movl    $64, %ecx
-;   movq    %r10, %rdi
-;   subq    %rcx, %rdi, %rcx
-;   movq    %rsi, %r10
-;   shlq    %cl, %r10, %r10
+;   movq    %r10, %rax
+;   subq    %rcx, %rax, %rcx
+;   shlq    %cl, %rsi, %rsi
 ;   xorq    %rdx, %rdx, %rdx
-;   testq   $127, %rdi
-;   cmovzq  %rdx, %r10, %r10
-;   orq     %r10, %r8, %r10
-;   testq   $64, %rdi
+;   testq   $127, %rax
+;   cmovzq  %rdx, %rsi, %rsi
+;   orq     %rsi, %rdi, %rsi
+;   testq   $64, %rax
 ;   movq    %r9, %rax
-;   cmovzq  %r10, %rax, %rax
+;   cmovzq  %rsi, %rax, %rax
 ;   cmovzq  %r9, %rdx, %rdx
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -297,23 +279,21 @@ block0(v0: i128, v1: i8):
 ; block1: ; offset 0x4
 ;   movq %rdx, %rcx
 ;   movq %rdx, %r10
-;   movq %rdi, %r8
-;   shrq %cl, %r8
+;   shrq %cl, %rdi
 ;   movq %rsi, %r9
 ;   shrq %cl, %r9
 ;   movq %rcx, %r10
 ;   movl $0x40, %ecx
-;   movq %r10, %rdi
-;   subq %rdi, %rcx
-;   movq %rsi, %r10
-;   shlq %cl, %r10
+;   movq %r10, %rax
+;   subq %rax, %rcx
+;   shlq %cl, %rsi
 ;   xorq %rdx, %rdx
-;   testq $0x7f, %rdi
-;   cmoveq %rdx, %r10
-;   orq %r8, %r10
-;   testq $0x40, %rdi
+;   testq $0x7f, %rax
+;   cmoveq %rdx, %rsi
+;   orq %rdi, %rsi
+;   testq $0x40, %rax
 ;   movq %r9, %rax
-;   cmoveq %r10, %rax
+;   cmoveq %rsi, %rax
 ;   cmoveq %r9, %rdx
 ;   movq %rbp, %rsp
 ;   popq %rbp
diff --git a/cranelift/filetests/filetests/isa/x64/uunarrow.clif b/cranelift/filetests/filetests/isa/x64/uunarrow.clif
index 0abe8d104ba6..57fdf011cbaa 100644
--- a/cranelift/filetests/filetests/isa/x64/uunarrow.clif
+++ b/cranelift/filetests/filetests/isa/x64/uunarrow.clif
@@ -15,10 +15,9 @@ block0(v0: f64x2):
 ; block0:
 ;   uninit  %xmm3
 ;   xorpd   %xmm3, %xmm3, %xmm3
-;   movdqa  %xmm0, %xmm7
-;   maxpd   %xmm7, %xmm3, %xmm7
-;   minpd   %xmm7, const(0), %xmm7
-;   roundpd $3, %xmm7, %xmm0
+;   maxpd   %xmm0, %xmm3, %xmm0
+;   minpd   %xmm0, const(0), %xmm0
+;   roundpd $3, %xmm0, %xmm0
 ;   addpd   %xmm0, const(1), %xmm0
 ;   shufps  $136, %xmm0, %xmm3, %xmm0
 ;   movq    %rbp, %rsp
@@ -31,15 +30,16 @@ block0(v0: f64x2):
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
 ;   xorpd %xmm3, %xmm3
-;   movdqa %xmm0, %xmm7
-;   maxpd %xmm3, %xmm7
-;   minpd 0x18(%rip), %xmm7
-;   roundpd $3, %xmm7, %xmm0
-;   addpd 0x1a(%rip), %xmm0
+;   maxpd %xmm3, %xmm0
+;   minpd 0x1c(%rip), %xmm0
+;   roundpd $3, %xmm0, %xmm0
+;   addpd 0x1e(%rip), %xmm0
 ;   shufps $0x88, %xmm3, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
 ;   addb %al, (%rax)
+;   addb %al, (%rax)
+;   addb %al, (%rax)
 ;   addb %ah, %al
 
diff --git a/cranelift/filetests/filetests/isa/x64/very-carefully-sink-loads-in-float-compares.clif b/cranelift/filetests/filetests/isa/x64/very-carefully-sink-loads-in-float-compares.clif
new file mode 100644
index 000000000000..01c9d4db2344
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/very-carefully-sink-loads-in-float-compares.clif
@@ -0,0 +1,499 @@
+test compile precise-output
+target x86_64
+
+;; This test ensures that Cranelift does not attempt to too eagerly sink loads
+;; into float comparison operations. When a single `fcmp` is used multiple times
+;; it'll regenerate `ucomiss` instructions, for example, but if this duplication
+;; happens then it shouldn't have a load sunk into it because that would load
+;; at two different points in the program, possibly seeing two different
+;; results.
+;;
+;; Exactly how this guarantee is provided has changed a bit over time with
+;; Cranelift. Originally in #3934 this was done explicitly in ISLE by avoiding
+;; the use of `put_in_xmm_mem`. Later in #4061 that ended up removing the need
+;; for the safeguards in #3934. Today there are no guards in ISLE for this any
+;; more and this test is intended to serve as a reference-test for notifying
+;; reviewers if anything changes.
+
+function %select_cond_rhs(f32, i64, i32, i32) -> i32 {
+block0(v0: f32, v1: i64, v2: i32, v3: i32):
+  v4 = load.f32 notrap aligned v1
+  v5 = fcmp eq v0, v4
+  v6 = select v5, v2, v3
+  return v6
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   ucomiss 0(%rdi), %xmm0
+;   cmovpl  %edx, %esi, %esi
+;   movq    %rsi, %rax
+;   cmovnzl %edx, %eax, %eax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   ucomiss (%rdi), %xmm0
+;   cmovpl %edx, %esi
+;   movq %rsi, %rax
+;   cmovnel %edx, %eax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+
+function %select_cond_lhs(f32, i64, i32, i32) -> i32 {
+block0(v0: f32, v1: i64, v2: i32, v3: i32):
+  v4 = load.f32 notrap aligned v1
+  v5 = fcmp eq v4, v0
+  v6 = select v5, v2, v3
+  return v6
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movss   0(%rdi), %xmm7
+;   ucomiss %xmm0, %xmm7
+;   cmovpl  %edx, %esi, %esi
+;   movq    %rsi, %rax
+;   cmovnzl %edx, %eax, %eax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movss (%rdi), %xmm7
+;   ucomiss %xmm0, %xmm7
+;   cmovpl %edx, %esi
+;   movq %rsi, %rax
+;   cmovnel %edx, %eax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %select_cond_used_twice_rhs(f32, i64, i32, i32) -> i32, i32 {
+block0(v0: f32, v1: i64, v2: i32, v3: i32):
+  ;; this load should NOT sink into either `select` below
+  v4 = load.f32 notrap aligned v1
+  v5 = fcmp eq v0, v4
+  v6 = select v5, v2, v3
+  v7 = select v5, v3, v2
+  return v6, v7
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movss   0(%rdi), %xmm1
+;   ucomiss %xmm1, %xmm0
+;   movq    %rsi, %rax
+;   cmovpl  %edx, %eax, %eax
+;   cmovnzl %edx, %eax, %eax
+;   ucomiss %xmm1, %xmm0
+;   cmovpl  %esi, %edx, %edx
+;   cmovnzl %esi, %edx, %edx
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movss (%rdi), %xmm1
+;   ucomiss %xmm1, %xmm0
+;   movq %rsi, %rax
+;   cmovpl %edx, %eax
+;   cmovnel %edx, %eax
+;   ucomiss %xmm1, %xmm0
+;   cmovpl %esi, %edx
+;   cmovnel %esi, %edx
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+
+function %select_cond_used_twice_lhs(f32, i64, i32, i32) -> i32, i32 {
+block0(v0: f32, v1: i64, v2: i32, v3: i32):
+  ;; this load should NOT sink into either `select` below
+  v4 = load.f32 notrap aligned v1
+  v5 = fcmp eq v4, v0
+  v6 = select v5, v2, v3
+  v7 = select v5, v3, v2
+  return v6, v7
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movss   0(%rdi), %xmm1
+;   ucomiss %xmm0, %xmm1
+;   movq    %rsi, %rax
+;   cmovpl  %edx, %eax, %eax
+;   cmovnzl %edx, %eax, %eax
+;   ucomiss %xmm0, %xmm1
+;   cmovpl  %esi, %edx, %edx
+;   cmovnzl %esi, %edx, %edx
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movss (%rdi), %xmm1
+;   ucomiss %xmm0, %xmm1
+;   movq %rsi, %rax
+;   cmovpl %edx, %eax
+;   cmovnel %edx, %eax
+;   ucomiss %xmm0, %xmm1
+;   cmovpl %esi, %edx
+;   cmovnel %esi, %edx
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %brif_cond_rhs(f32, i64, i32, i32) -> i32 {
+block0(v0: f32, v1: i64, v2: i32, v3: i32):
+  v4 = load.f32 notrap aligned v1
+  v5 = fcmp eq v0, v4
+  brif v5, block1(v2), block1(v3)
+block1(v8: i32):
+  return v8
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movss   0(%rdi), %xmm1
+;   ucomiss %xmm1, %xmm0
+;   jp      label2
+;   jnz     label2; j label1
+; block1:
+;   movq    %rsi, %rax
+;   jmp     label3
+; block2:
+;   movq    %rdx, %rax
+;   jmp     label3
+; block3:
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movss (%rdi), %xmm1
+;   ucomiss %xmm1, %xmm0
+;   jp 0x1f
+;   jne 0x1f
+; block2: ; offset 0x17
+;   movq %rsi, %rax
+;   jmp 0x22
+; block3: ; offset 0x1f
+;   movq %rdx, %rax
+; block4: ; offset 0x22
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %brif_cond_lhs(f32, i64, i32, i32) -> i32 {
+block0(v0: f32, v1: i64, v2: i32, v3: i32):
+  v4 = load.f32 notrap aligned v1
+  v5 = fcmp eq v4, v0
+  brif v5, block1(v2), block1(v3)
+block1(v8: i32):
+  return v8
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movss   0(%rdi), %xmm1
+;   ucomiss %xmm0, %xmm1
+;   jp      label2
+;   jnz     label2; j label1
+; block1:
+;   movq    %rsi, %rax
+;   jmp     label3
+; block2:
+;   movq    %rdx, %rax
+;   jmp     label3
+; block3:
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movss (%rdi), %xmm1
+;   ucomiss %xmm0, %xmm1
+;   jp 0x1f
+;   jne 0x1f
+; block2: ; offset 0x17
+;   movq %rsi, %rax
+;   jmp 0x22
+; block3: ; offset 0x1f
+;   movq %rdx, %rax
+; block4: ; offset 0x22
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %brif_cond_used_twice_rhs(f32, i64, i32, i32) -> i32, i32 {
+block0(v0: f32, v1: i64, v2: i32, v3: i32):
+  v4 = load.f32 notrap aligned v1
+  v5 = fcmp eq v0, v4
+  brif v5, block1(v2), block1(v3)
+block1(v6: i32):
+  brif v5, block2(v3), block2(v2)
+block2(v7: i32):
+  return v6, v7
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movss   0(%rdi), %xmm3
+;   ucomiss %xmm3, %xmm0
+;   jp      label2
+;   jnz     label2; j label1
+; block1:
+;   movq    %rsi, %rax
+;   jmp     label3
+; block2:
+;   movq    %rdx, %rax
+;   jmp     label3
+; block3:
+;   ucomiss %xmm3, %xmm0
+;   jp      label5
+;   jnz     label5; j label4
+; block4:
+;   jmp     label6
+; block5:
+;   movq    %rsi, %rdx
+;   jmp     label6
+; block6:
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movss (%rdi), %xmm3
+;   ucomiss %xmm3, %xmm0
+;   jp 0x1f
+;   jne 0x1f
+; block2: ; offset 0x17
+;   movq %rsi, %rax
+;   jmp 0x22
+; block3: ; offset 0x1f
+;   movq %rdx, %rax
+; block4: ; offset 0x22
+;   ucomiss %xmm3, %xmm0
+;   jp 0x31
+;   je 0x34
+; block5: ; offset 0x31
+;   movq %rsi, %rdx
+; block6: ; offset 0x34
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %brif_cond_used_twice_lhs(f32, i64, i32, i32) -> i32, i32 {
+block0(v0: f32, v1: i64, v2: i32, v3: i32):
+  v4 = load.f32 notrap aligned v1
+  v5 = fcmp eq v4, v0
+  brif v5, block1(v2), block1(v3)
+block1(v6: i32):
+  brif v5, block2(v3), block2(v2)
+block2(v7: i32):
+  return v6, v7
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movss   0(%rdi), %xmm3
+;   ucomiss %xmm0, %xmm3
+;   jp      label2
+;   jnz     label2; j label1
+; block1:
+;   movq    %rsi, %rax
+;   jmp     label3
+; block2:
+;   movq    %rdx, %rax
+;   jmp     label3
+; block3:
+;   ucomiss %xmm0, %xmm3
+;   jp      label5
+;   jnz     label5; j label4
+; block4:
+;   jmp     label6
+; block5:
+;   movq    %rsi, %rdx
+;   jmp     label6
+; block6:
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movss (%rdi), %xmm3
+;   ucomiss %xmm0, %xmm3
+;   jp 0x1f
+;   jne 0x1f
+; block2: ; offset 0x17
+;   movq %rsi, %rax
+;   jmp 0x22
+; block3: ; offset 0x1f
+;   movq %rdx, %rax
+; block4: ; offset 0x22
+;   ucomiss %xmm0, %xmm3
+;   jp 0x31
+;   je 0x34
+; block5: ; offset 0x31
+;   movq %rsi, %rdx
+; block6: ; offset 0x34
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %mix_select_and_brif_rhs(f32, i64, i32, i32) -> i32, i32 {
+block0(v0: f32, v1: i64, v2: i32, v3: i32):
+  v4 = load.f32 notrap aligned v1
+  v5 = fcmp eq v0, v4
+  v6 = select v5, v2, v3
+  brif v5, block1(v3), block1(v2)
+block1(v7: i32):
+  return v6, v7
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movss   0(%rdi), %xmm2
+;   ucomiss %xmm2, %xmm0
+;   movq    %rsi, %rax
+;   cmovpl  %edx, %eax, %eax
+;   cmovnzl %edx, %eax, %eax
+;   ucomiss %xmm2, %xmm0
+;   jp      label2
+;   jnz     label2; j label1
+; block1:
+;   jmp     label3
+; block2:
+;   movq    %rsi, %rdx
+;   jmp     label3
+; block3:
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movss (%rdi), %xmm2
+;   ucomiss %xmm2, %xmm0
+;   movq %rsi, %rax
+;   cmovpl %edx, %eax
+;   cmovnel %edx, %eax
+;   ucomiss %xmm2, %xmm0
+;   jp 0x23
+;   je 0x26
+; block2: ; offset 0x23
+;   movq %rsi, %rdx
+; block3: ; offset 0x26
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %mix_select_and_brif_lhs(f32, i64, i32, i32) -> i32, i32 {
+block0(v0: f32, v1: i64, v2: i32, v3: i32):
+  v4 = load.f32 notrap aligned v1
+  v5 = fcmp eq v4, v0
+  v6 = select v5, v2, v3
+  brif v5, block1(v3), block1(v2)
+block1(v7: i32):
+  return v6, v7
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movss   0(%rdi), %xmm2
+;   ucomiss %xmm0, %xmm2
+;   movq    %rsi, %rax
+;   cmovpl  %edx, %eax, %eax
+;   cmovnzl %edx, %eax, %eax
+;   ucomiss %xmm0, %xmm2
+;   jp      label2
+;   jnz     label2; j label1
+; block1:
+;   jmp     label3
+; block2:
+;   movq    %rsi, %rdx
+;   jmp     label3
+; block3:
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movss (%rdi), %xmm2
+;   ucomiss %xmm0, %xmm2
+;   movq %rsi, %rax
+;   cmovpl %edx, %eax
+;   cmovnel %edx, %eax
+;   ucomiss %xmm0, %xmm2
+;   jp 0x23
+;   je 0x26
+; block2: ; offset 0x23
+;   movq %rsi, %rdx
+; block3: ; offset 0x26
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/vhigh_bits.clif b/cranelift/filetests/filetests/isa/x64/vhigh_bits.clif
index bf086f00c894..51fdff3a0bfc 100644
--- a/cranelift/filetests/filetests/isa/x64/vhigh_bits.clif
+++ b/cranelift/filetests/filetests/isa/x64/vhigh_bits.clif
@@ -61,9 +61,8 @@ block0(v0: i16x8):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movdqa  %xmm0, %xmm2
-;   packsswb %xmm2, %xmm0, %xmm2
-;   pmovmskb %xmm2, %eax
+;   packsswb %xmm0, %xmm0, %xmm0
+;   pmovmskb %xmm0, %eax
 ;   shrq    $8, %rax, %rax
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
@@ -74,9 +73,8 @@ block0(v0: i16x8):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movdqa %xmm0, %xmm2
-;   packsswb %xmm0, %xmm2
-;   pmovmskb %xmm2, %eax
+;   packsswb %xmm0, %xmm0
+;   pmovmskb %xmm0, %eax
 ;   shrq $8, %rax
 ;   movq %rbp, %rsp
 ;   popq %rbp
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index ee459925a1b6..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,84 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r10d
-;;   movabsq $-4, %r9
-;;   addq    %r9, 8(%rdx), %r9
-;;   cmpq    %r9, %r10
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rdx), %rdi
-;;   movl    %esi, 0(%rdi,%r10,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r10d
-;;   movabsq $-4, %r9
-;;   addq    %r9, 8(%rsi), %r9
-;;   cmpq    %r9, %r10
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rsi), %rsi
-;;   movl    0(%rsi,%r10,1), %eax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 46a0b9cddc07..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,84 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r10d
-;;   movabsq $-4100, %r9
-;;   addq    %r9, 8(%rdx), %r9
-;;   cmpq    %r9, %r10
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rdx), %rdi
-;;   movl    %esi, 4096(%rdi,%r10,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r10d
-;;   movabsq $-4100, %r9
-;;   addq    %r9, 8(%rsi), %r9
-;;   cmpq    %r9, %r10
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rsi), %rsi
-;;   movl    4096(%rsi,%r10,1), %eax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 23825be3f765..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,90 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   movq    %r8, %r11
-;;   addq    %r11, const(0), %r11
-;;   jb #trap=heap_oob
-;;   movq    8(%rdx), %rdi
-;;   cmpq    %rdi, %r11
-;;   jnbe    label3; j label1
-;; block1:
-;;   addq    %r8, 0(%rdx), %r8
-;;   movl    $-65536, %eax
-;;   movl    %esi, 0(%r8,%rax,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   movq    %r8, %r11
-;;   addq    %r11, const(0), %r11
-;;   jb #trap=heap_oob
-;;   movq    8(%rsi), %rdi
-;;   cmpq    %rdi, %r11
-;;   jnbe    label3; j label1
-;; block1:
-;;   addq    %r8, 0(%rsi), %r8
-;;   movl    $-65536, %eax
-;;   movl    0(%r8,%rax,1), %eax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index a3ff52013e94..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,82 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r9d
-;;   movq    8(%rdx), %r10
-;;   cmpq    %r10, %r9
-;;   jnb     label3; j label1
-;; block1:
-;;   movq    0(%rdx), %r11
-;;   movb    %sil, 0(%r11,%r9,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r9d
-;;   movq    8(%rsi), %r10
-;;   cmpq    %r10, %r9
-;;   jnb     label3; j label1
-;; block1:
-;;   movq    0(%rsi), %r11
-;;   movzbq  0(%r11,%r9,1), %rax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 51fbcfa63db4..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,84 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r10d
-;;   movabsq $-4097, %r9
-;;   addq    %r9, 8(%rdx), %r9
-;;   cmpq    %r9, %r10
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rdx), %rdi
-;;   movb    %sil, 4096(%rdi,%r10,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r10d
-;;   movabsq $-4097, %r9
-;;   addq    %r9, 8(%rsi), %r9
-;;   cmpq    %r9, %r10
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rsi), %rsi
-;;   movzbq  4096(%rsi,%r10,1), %rax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 187b535a986e..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,90 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   movq    %r8, %r11
-;;   addq    %r11, const(0), %r11
-;;   jb #trap=heap_oob
-;;   movq    8(%rdx), %rdi
-;;   cmpq    %rdi, %r11
-;;   jnbe    label3; j label1
-;; block1:
-;;   addq    %r8, 0(%rdx), %r8
-;;   movl    $-65536, %eax
-;;   movb    %sil, 0(%r8,%rax,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   movq    %r8, %r11
-;;   addq    %r11, const(0), %r11
-;;   jb #trap=heap_oob
-;;   movq    8(%rsi), %rdi
-;;   cmpq    %rdi, %r11
-;;   jnbe    label3; j label1
-;; block1:
-;;   addq    %r8, 0(%rsi), %r8
-;;   movl    $-65536, %eax
-;;   movzbq  0(%r8,%rax,1), %rax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index ef1fcddac967..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,84 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %edi
-;;   movabsq $-4, %r11
-;;   addq    %r11, 8(%rdx), %r11
-;;   movq    %rdi, %r10
-;;   addq    %r10, 0(%rdx), %r10
-;;   xorq    %rax, %rax, %rax
-;;   cmpq    %r11, %rdi
-;;   cmovnbeq %rax, %r10, %r10
-;;   movl    %esi, 0(%r10)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    %rsi, %rax
-;;   movl    %edi, %esi
-;;   movabsq $-4, %r11
-;;   movq    %rax, %rcx
-;;   addq    %r11, 8(%rcx), %r11
-;;   movq    %rsi, %r10
-;;   addq    %r10, 0(%rcx), %r10
-;;   xorq    %rdi, %rdi, %rdi
-;;   cmpq    %r11, %rsi
-;;   cmovnbeq %rdi, %r10, %r10
-;;   movl    0(%r10), %eax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 0f3b9e5d12a0..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,84 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %edi
-;;   movabsq $-4100, %rax
-;;   addq    %rax, 8(%rdx), %rax
-;;   movq    0(%rdx), %rcx
-;;   lea     4096(%rcx,%rdi,1), %r11
-;;   xorq    %rcx, %rcx, %rcx
-;;   cmpq    %rax, %rdi
-;;   cmovnbeq %rcx, %r11, %r11
-;;   movl    %esi, 0(%r11)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    %rsi, %rax
-;;   movl    %edi, %edi
-;;   movabsq $-4100, %rsi
-;;   movq    %rax, %rdx
-;;   addq    %rsi, 8(%rdx), %rsi
-;;   movq    0(%rdx), %rax
-;;   lea     4096(%rax,%rdi,1), %r11
-;;   xorq    %rax, %rax, %rax
-;;   cmpq    %rsi, %rdi
-;;   cmovnbeq %rax, %r11, %r11
-;;   movl    0(%r11), %eax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index dc35c58d198f..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,88 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r11d
-;;   movq    %r11, %rax
-;;   addq    %rax, const(0), %rax
-;;   jb #trap=heap_oob
-;;   movq    8(%rdx), %rcx
-;;   addq    %r11, 0(%rdx), %r11
-;;   movl    $-65536, %edx
-;;   lea     0(%r11,%rdx,1), %rdi
-;;   xorq    %rdx, %rdx, %rdx
-;;   cmpq    %rcx, %rax
-;;   cmovnbeq %rdx, %rdi, %rdi
-;;   movl    %esi, 0(%rdi)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r11d
-;;   movq    %r11, %rax
-;;   addq    %rax, const(0), %rax
-;;   jb #trap=heap_oob
-;;   movq    8(%rsi), %rcx
-;;   addq    %r11, 0(%rsi), %r11
-;;   movl    $-65536, %edx
-;;   lea     0(%r11,%rdx,1), %rdi
-;;   xorq    %rdx, %rdx, %rdx
-;;   cmpq    %rcx, %rax
-;;   cmovnbeq %rdx, %rdi, %rdi
-;;   movl    0(%rdi), %eax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 17a6726b0cc9..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r11d
-;;   movq    8(%rdx), %rdi
-;;   movq    %r11, %r9
-;;   addq    %r9, 0(%rdx), %r9
-;;   xorq    %rax, %rax, %rax
-;;   cmpq    %rdi, %r11
-;;   cmovnbq %rax, %r9, %r9
-;;   movb    %sil, 0(%r9)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r11d
-;;   movq    8(%rsi), %rdi
-;;   movq    %r11, %r9
-;;   addq    %r9, 0(%rsi), %r9
-;;   xorq    %rsi, %rsi, %rsi
-;;   cmpq    %rdi, %r11
-;;   cmovnbq %rsi, %r9, %r9
-;;   movzbq  0(%r9), %rax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index f105a06aa960..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,84 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %edi
-;;   movabsq $-4097, %rax
-;;   addq    %rax, 8(%rdx), %rax
-;;   movq    0(%rdx), %rcx
-;;   lea     4096(%rcx,%rdi,1), %r11
-;;   xorq    %rcx, %rcx, %rcx
-;;   cmpq    %rax, %rdi
-;;   cmovnbeq %rcx, %r11, %r11
-;;   movb    %sil, 0(%r11)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    %rsi, %rax
-;;   movl    %edi, %edi
-;;   movabsq $-4097, %rsi
-;;   movq    %rax, %rdx
-;;   addq    %rsi, 8(%rdx), %rsi
-;;   movq    0(%rdx), %rax
-;;   lea     4096(%rax,%rdi,1), %r11
-;;   xorq    %rax, %rax, %rax
-;;   cmpq    %rsi, %rdi
-;;   cmovnbeq %rax, %r11, %r11
-;;   movzbq  0(%r11), %rax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 171202116deb..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,88 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r11d
-;;   movq    %r11, %rax
-;;   addq    %rax, const(0), %rax
-;;   jb #trap=heap_oob
-;;   movq    8(%rdx), %rcx
-;;   addq    %r11, 0(%rdx), %r11
-;;   movl    $-65536, %edx
-;;   lea     0(%r11,%rdx,1), %rdi
-;;   xorq    %rdx, %rdx, %rdx
-;;   cmpq    %rcx, %rax
-;;   cmovnbeq %rdx, %rdi, %rdi
-;;   movb    %sil, 0(%rdi)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r11d
-;;   movq    %r11, %rax
-;;   addq    %rax, const(0), %rax
-;;   jb #trap=heap_oob
-;;   movq    8(%rsi), %rcx
-;;   addq    %r11, 0(%rsi), %r11
-;;   movl    $-65536, %edx
-;;   lea     0(%r11,%rdx,1), %rdi
-;;   xorq    %rdx, %rdx, %rdx
-;;   cmpq    %rcx, %rax
-;;   cmovnbeq %rdx, %rdi, %rdi
-;;   movzbq  0(%rdi), %rax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 221ecbae68f1..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,82 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r9d
-;;   movq    8(%rdx), %r10
-;;   cmpq    %r10, %r9
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rdx), %r11
-;;   movl    %esi, 0(%r11,%r9,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r9d
-;;   movq    8(%rsi), %r10
-;;   cmpq    %r10, %r9
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rsi), %r11
-;;   movl    0(%r11,%r9,1), %eax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 25bda2004753..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,82 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r9d
-;;   movq    8(%rdx), %r10
-;;   cmpq    %r10, %r9
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rdx), %r11
-;;   movl    %esi, 4096(%r11,%r9,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r9d
-;;   movq    8(%rsi), %r10
-;;   cmpq    %r10, %r9
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rsi), %r11
-;;   movl    4096(%r11,%r9,1), %eax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 57e2d1680d46..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,84 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   movq    8(%rdx), %r10
-;;   cmpq    %r10, %r8
-;;   jnbe    label3; j label1
-;; block1:
-;;   addq    %r8, 0(%rdx), %r8
-;;   movl    $-65536, %edi
-;;   movl    %esi, 0(%r8,%rdi,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   movq    8(%rsi), %r10
-;;   cmpq    %r10, %r8
-;;   jnbe    label3; j label1
-;; block1:
-;;   addq    %r8, 0(%rsi), %r8
-;;   movl    $-65536, %esi
-;;   movl    0(%r8,%rsi,1), %eax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index d7ca8a6c5b8c..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,82 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r9d
-;;   movq    8(%rdx), %r10
-;;   cmpq    %r10, %r9
-;;   jnb     label3; j label1
-;; block1:
-;;   movq    0(%rdx), %r11
-;;   movb    %sil, 0(%r11,%r9,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r9d
-;;   movq    8(%rsi), %r10
-;;   cmpq    %r10, %r9
-;;   jnb     label3; j label1
-;; block1:
-;;   movq    0(%rsi), %r11
-;;   movzbq  0(%r11,%r9,1), %rax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index f9c64c890270..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,82 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r9d
-;;   movq    8(%rdx), %r10
-;;   cmpq    %r10, %r9
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rdx), %r11
-;;   movb    %sil, 4096(%r11,%r9,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r9d
-;;   movq    8(%rsi), %r10
-;;   cmpq    %r10, %r9
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rsi), %r11
-;;   movzbq  4096(%r11,%r9,1), %rax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index f2c873612824..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,84 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   movq    8(%rdx), %r10
-;;   cmpq    %r10, %r8
-;;   jnbe    label3; j label1
-;; block1:
-;;   addq    %r8, 0(%rdx), %r8
-;;   movl    $-65536, %edi
-;;   movb    %sil, 0(%r8,%rdi,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   movq    8(%rsi), %r10
-;;   cmpq    %r10, %r8
-;;   jnbe    label3; j label1
-;; block1:
-;;   addq    %r8, 0(%rsi), %r8
-;;   movl    $-65536, %esi
-;;   movzbq  0(%r8,%rsi,1), %rax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 89b24d688248..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r11d
-;;   movq    8(%rdx), %rdi
-;;   movq    %r11, %r9
-;;   addq    %r9, 0(%rdx), %r9
-;;   xorq    %rax, %rax, %rax
-;;   cmpq    %rdi, %r11
-;;   cmovnbeq %rax, %r9, %r9
-;;   movl    %esi, 0(%r9)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r11d
-;;   movq    8(%rsi), %rdi
-;;   movq    %r11, %r9
-;;   addq    %r9, 0(%rsi), %r9
-;;   xorq    %rsi, %rsi, %rsi
-;;   cmpq    %rdi, %r11
-;;   cmovnbeq %rsi, %r9, %r9
-;;   movl    0(%r9), %eax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 5b49b27f4a88..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %edi
-;;   movq    8(%rdx), %rax
-;;   movq    0(%rdx), %rcx
-;;   lea     4096(%rcx,%rdi,1), %r10
-;;   xorq    %rcx, %rcx, %rcx
-;;   cmpq    %rax, %rdi
-;;   cmovnbeq %rcx, %r10, %r10
-;;   movl    %esi, 0(%r10)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %ecx
-;;   movq    8(%rsi), %rdi
-;;   movq    0(%rsi), %rsi
-;;   lea     4096(%rsi,%rcx,1), %r10
-;;   xorq    %rax, %rax, %rax
-;;   cmpq    %rdi, %rcx
-;;   cmovnbeq %rax, %r10, %r10
-;;   movl    0(%r10), %eax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 8b6846dfce16..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,84 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %edi
-;;   movq    8(%rdx), %rax
-;;   movq    %rdi, %rcx
-;;   addq    %rcx, 0(%rdx), %rcx
-;;   movl    $-65536, %edx
-;;   lea     0(%rcx,%rdx,1), %r11
-;;   xorq    %rcx, %rcx, %rcx
-;;   cmpq    %rax, %rdi
-;;   cmovnbeq %rcx, %r11, %r11
-;;   movl    %esi, 0(%r11)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %edi
-;;   movq    8(%rsi), %rax
-;;   movq    %rdi, %rcx
-;;   addq    %rcx, 0(%rsi), %rcx
-;;   movl    $-65536, %edx
-;;   lea     0(%rcx,%rdx,1), %r11
-;;   xorq    %rcx, %rcx, %rcx
-;;   cmpq    %rax, %rdi
-;;   cmovnbeq %rcx, %r11, %r11
-;;   movl    0(%r11), %eax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 1ac80ebbc66a..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r11d
-;;   movq    8(%rdx), %rdi
-;;   movq    %r11, %r9
-;;   addq    %r9, 0(%rdx), %r9
-;;   xorq    %rax, %rax, %rax
-;;   cmpq    %rdi, %r11
-;;   cmovnbq %rax, %r9, %r9
-;;   movb    %sil, 0(%r9)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r11d
-;;   movq    8(%rsi), %rdi
-;;   movq    %r11, %r9
-;;   addq    %r9, 0(%rsi), %r9
-;;   xorq    %rsi, %rsi, %rsi
-;;   cmpq    %rdi, %r11
-;;   cmovnbq %rsi, %r9, %r9
-;;   movzbq  0(%r9), %rax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 774e27d08615..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %edi
-;;   movq    8(%rdx), %rax
-;;   movq    0(%rdx), %rcx
-;;   lea     4096(%rcx,%rdi,1), %r10
-;;   xorq    %rcx, %rcx, %rcx
-;;   cmpq    %rax, %rdi
-;;   cmovnbeq %rcx, %r10, %r10
-;;   movb    %sil, 0(%r10)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %ecx
-;;   movq    8(%rsi), %rdi
-;;   movq    0(%rsi), %rsi
-;;   lea     4096(%rsi,%rcx,1), %r10
-;;   xorq    %rax, %rax, %rax
-;;   cmpq    %rdi, %rcx
-;;   cmovnbeq %rax, %r10, %r10
-;;   movzbq  0(%r10), %rax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 5ac256e173d3..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,84 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %edi
-;;   movq    8(%rdx), %rax
-;;   movq    %rdi, %rcx
-;;   addq    %rcx, 0(%rdx), %rcx
-;;   movl    $-65536, %edx
-;;   lea     0(%rcx,%rdx,1), %r11
-;;   xorq    %rcx, %rcx, %rcx
-;;   cmpq    %rax, %rdi
-;;   cmovnbeq %rcx, %r11, %r11
-;;   movb    %sil, 0(%r11)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %edi
-;;   movq    8(%rsi), %rax
-;;   movq    %rdi, %rcx
-;;   addq    %rcx, 0(%rsi), %rcx
-;;   movl    $-65536, %edx
-;;   lea     0(%rcx,%rdx,1), %r11
-;;   xorq    %rcx, %rcx, %rcx
-;;   cmpq    %rax, %rdi
-;;   cmovnbeq %rcx, %r11, %r11
-;;   movzbq  0(%r11), %rax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index df96ce78bdc7..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,82 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movabsq $-4, %r8
-;;   addq    %r8, 8(%rdx), %r8
-;;   cmpq    %r8, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rdx), %r11
-;;   movl    %esi, 0(%r11,%rdi,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movabsq $-4, %r8
-;;   addq    %r8, 8(%rsi), %r8
-;;   cmpq    %r8, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rsi), %r11
-;;   movl    0(%r11,%rdi,1), %eax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 5e04c5842661..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,82 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movabsq $-4100, %r8
-;;   addq    %r8, 8(%rdx), %r8
-;;   cmpq    %r8, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rdx), %r11
-;;   movl    %esi, 4096(%r11,%rdi,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movabsq $-4100, %r8
-;;   addq    %r8, 8(%rsi), %r8
-;;   cmpq    %r8, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rsi), %r11
-;;   movl    4096(%r11,%rdi,1), %eax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 606ac690204d..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,88 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    %rdi, %r10
-;;   addq    %r10, const(0), %r10
-;;   jb #trap=heap_oob
-;;   movq    8(%rdx), %r11
-;;   cmpq    %r11, %r10
-;;   jnbe    label3; j label1
-;; block1:
-;;   addq    %rdi, 0(%rdx), %rdi
-;;   movl    $-65536, %eax
-;;   movl    %esi, 0(%rdi,%rax,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    %rdi, %r10
-;;   addq    %r10, const(0), %r10
-;;   jb #trap=heap_oob
-;;   movq    8(%rsi), %r11
-;;   cmpq    %r11, %r10
-;;   jnbe    label3; j label1
-;; block1:
-;;   addq    %rdi, 0(%rsi), %rdi
-;;   movl    $-65536, %eax
-;;   movl    0(%rdi,%rax,1), %eax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 3581f4bd08e7..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    8(%rdx), %r8
-;;   cmpq    %r8, %rdi
-;;   jnb     label3; j label1
-;; block1:
-;;   movq    0(%rdx), %r10
-;;   movb    %sil, 0(%r10,%rdi,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    8(%rsi), %r8
-;;   cmpq    %r8, %rdi
-;;   jnb     label3; j label1
-;; block1:
-;;   movq    0(%rsi), %r10
-;;   movzbq  0(%r10,%rdi,1), %rax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index ebee6f63ec05..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,82 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movabsq $-4097, %r8
-;;   addq    %r8, 8(%rdx), %r8
-;;   cmpq    %r8, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rdx), %r11
-;;   movb    %sil, 4096(%r11,%rdi,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movabsq $-4097, %r8
-;;   addq    %r8, 8(%rsi), %r8
-;;   cmpq    %r8, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rsi), %r11
-;;   movzbq  4096(%r11,%rdi,1), %rax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 1253391f756b..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,88 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    %rdi, %r10
-;;   addq    %r10, const(0), %r10
-;;   jb #trap=heap_oob
-;;   movq    8(%rdx), %r11
-;;   cmpq    %r11, %r10
-;;   jnbe    label3; j label1
-;; block1:
-;;   addq    %rdi, 0(%rdx), %rdi
-;;   movl    $-65536, %eax
-;;   movb    %sil, 0(%rdi,%rax,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    %rdi, %r10
-;;   addq    %r10, const(0), %r10
-;;   jb #trap=heap_oob
-;;   movq    8(%rsi), %r11
-;;   cmpq    %r11, %r10
-;;   jnbe    label3; j label1
-;; block1:
-;;   addq    %rdi, 0(%rsi), %rdi
-;;   movl    $-65536, %eax
-;;   movzbq  0(%rdi,%rax,1), %rax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 5ce7b41a4c9d..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movabsq $-4, %r10
-;;   addq    %r10, 8(%rdx), %r10
-;;   movq    %rdi, %r9
-;;   addq    %r9, 0(%rdx), %r9
-;;   xorq    %r11, %r11, %r11
-;;   cmpq    %r10, %rdi
-;;   cmovnbeq %r11, %r9, %r9
-;;   movl    %esi, 0(%r9)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movabsq $-4, %r10
-;;   addq    %r10, 8(%rsi), %r10
-;;   movq    %rdi, %r9
-;;   addq    %r9, 0(%rsi), %r9
-;;   xorq    %r11, %r11, %r11
-;;   cmpq    %r10, %rdi
-;;   cmovnbeq %r11, %r9, %r9
-;;   movl    0(%r9), %eax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 97907fc88179..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movabsq $-4100, %r11
-;;   addq    %r11, 8(%rdx), %r11
-;;   movq    0(%rdx), %rax
-;;   lea     4096(%rax,%rdi,1), %r10
-;;   xorq    %rax, %rax, %rax
-;;   cmpq    %r11, %rdi
-;;   cmovnbeq %rax, %r10, %r10
-;;   movl    %esi, 0(%r10)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movabsq $-4100, %r11
-;;   addq    %r11, 8(%rsi), %r11
-;;   movq    0(%rsi), %rsi
-;;   lea     4096(%rsi,%rdi,1), %r10
-;;   xorq    %rsi, %rsi, %rsi
-;;   cmpq    %r11, %rdi
-;;   cmovnbeq %rsi, %r10, %r10
-;;   movl    0(%r10), %eax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 98836b711f88..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,88 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    %rdi, %r8
-;;   addq    %r8, const(0), %r8
-;;   jb #trap=heap_oob
-;;   movq    8(%rdx), %rax
-;;   movq    %rdi, %rcx
-;;   addq    %rcx, 0(%rdx), %rcx
-;;   movl    $-65536, %edx
-;;   lea     0(%rcx,%rdx,1), %rcx
-;;   xorq    %rdx, %rdx, %rdx
-;;   cmpq    %rax, %r8
-;;   cmovnbeq %rdx, %rcx, %rcx
-;;   movl    %esi, 0(%rcx)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    %rdi, %rcx
-;;   addq    %rcx, const(0), %rcx
-;;   jb #trap=heap_oob
-;;   movq    8(%rsi), %rax
-;;   movq    %rdi, %rdx
-;;   addq    %rdx, 0(%rsi), %rdx
-;;   movl    $-65536, %r8d
-;;   lea     0(%rdx,%r8,1), %rsi
-;;   xorq    %rdx, %rdx, %rdx
-;;   cmpq    %rax, %rcx
-;;   cmovnbeq %rdx, %rsi, %rsi
-;;   movl    0(%rsi), %eax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index b2f45beb12eb..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    8(%rdx), %r10
-;;   movq    %rdi, %r8
-;;   addq    %r8, 0(%rdx), %r8
-;;   xorq    %r11, %r11, %r11
-;;   cmpq    %r10, %rdi
-;;   cmovnbq %r11, %r8, %r8
-;;   movb    %sil, 0(%r8)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    8(%rsi), %r10
-;;   movq    %rdi, %r8
-;;   addq    %r8, 0(%rsi), %r8
-;;   xorq    %r11, %r11, %r11
-;;   cmpq    %r10, %rdi
-;;   cmovnbq %r11, %r8, %r8
-;;   movzbq  0(%r8), %rax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 3d1a7115acbd..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movabsq $-4097, %r11
-;;   addq    %r11, 8(%rdx), %r11
-;;   movq    0(%rdx), %rax
-;;   lea     4096(%rax,%rdi,1), %r10
-;;   xorq    %rax, %rax, %rax
-;;   cmpq    %r11, %rdi
-;;   cmovnbeq %rax, %r10, %r10
-;;   movb    %sil, 0(%r10)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movabsq $-4097, %r11
-;;   addq    %r11, 8(%rsi), %r11
-;;   movq    0(%rsi), %rsi
-;;   lea     4096(%rsi,%rdi,1), %r10
-;;   xorq    %rsi, %rsi, %rsi
-;;   cmpq    %r11, %rdi
-;;   cmovnbeq %rsi, %r10, %r10
-;;   movzbq  0(%r10), %rax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index be22d8a42144..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,88 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    %rdi, %r8
-;;   addq    %r8, const(0), %r8
-;;   jb #trap=heap_oob
-;;   movq    8(%rdx), %rax
-;;   movq    %rdi, %rcx
-;;   addq    %rcx, 0(%rdx), %rcx
-;;   movl    $-65536, %edx
-;;   lea     0(%rcx,%rdx,1), %rcx
-;;   xorq    %rdx, %rdx, %rdx
-;;   cmpq    %rax, %r8
-;;   cmovnbeq %rdx, %rcx, %rcx
-;;   movb    %sil, 0(%rcx)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    %rdi, %rcx
-;;   addq    %rcx, const(0), %rcx
-;;   jb #trap=heap_oob
-;;   movq    8(%rsi), %rax
-;;   movq    %rdi, %rdx
-;;   addq    %rdx, 0(%rsi), %rdx
-;;   movl    $-65536, %r8d
-;;   lea     0(%rdx,%r8,1), %rsi
-;;   xorq    %rdx, %rdx, %rdx
-;;   cmpq    %rax, %rcx
-;;   cmovnbeq %rdx, %rsi, %rsi
-;;   movzbq  0(%rsi), %rax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 73fef35eeb49..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    8(%rdx), %r8
-;;   cmpq    %r8, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rdx), %r10
-;;   movl    %esi, 0(%r10,%rdi,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    8(%rsi), %r8
-;;   cmpq    %r8, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rsi), %r10
-;;   movl    0(%r10,%rdi,1), %eax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 249d2ed6be98..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    8(%rdx), %r8
-;;   cmpq    %r8, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rdx), %r10
-;;   movl    %esi, 4096(%r10,%rdi,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    8(%rsi), %r8
-;;   cmpq    %r8, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rsi), %r10
-;;   movl    4096(%r10,%rdi,1), %eax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 6d9c1df46417..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,84 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    8(%rdx), %r9
-;;   cmpq    %r9, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    %rdi, %r11
-;;   addq    %r11, 0(%rdx), %r11
-;;   movl    $-65536, %edi
-;;   movl    %esi, 0(%r11,%rdi,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    8(%rsi), %r9
-;;   cmpq    %r9, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    %rdi, %r11
-;;   addq    %r11, 0(%rsi), %r11
-;;   movl    $-65536, %esi
-;;   movl    0(%r11,%rsi,1), %eax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 1c6a0c0c73a1..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    8(%rdx), %r8
-;;   cmpq    %r8, %rdi
-;;   jnb     label3; j label1
-;; block1:
-;;   movq    0(%rdx), %r10
-;;   movb    %sil, 0(%r10,%rdi,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    8(%rsi), %r8
-;;   cmpq    %r8, %rdi
-;;   jnb     label3; j label1
-;; block1:
-;;   movq    0(%rsi), %r10
-;;   movzbq  0(%r10,%rdi,1), %rax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 31864ae001f5..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    8(%rdx), %r8
-;;   cmpq    %r8, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rdx), %r10
-;;   movb    %sil, 4096(%r10,%rdi,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    8(%rsi), %r8
-;;   cmpq    %r8, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rsi), %r10
-;;   movzbq  4096(%r10,%rdi,1), %rax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 33e0e97a68c0..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,84 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    8(%rdx), %r9
-;;   cmpq    %r9, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    %rdi, %r11
-;;   addq    %r11, 0(%rdx), %r11
-;;   movl    $-65536, %edi
-;;   movb    %sil, 0(%r11,%rdi,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    8(%rsi), %r9
-;;   cmpq    %r9, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    %rdi, %r11
-;;   addq    %r11, 0(%rsi), %r11
-;;   movl    $-65536, %esi
-;;   movzbq  0(%r11,%rsi,1), %rax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index c7c43a0d3f9e..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    8(%rdx), %r10
-;;   movq    %rdi, %r8
-;;   addq    %r8, 0(%rdx), %r8
-;;   xorq    %r11, %r11, %r11
-;;   cmpq    %r10, %rdi
-;;   cmovnbeq %r11, %r8, %r8
-;;   movl    %esi, 0(%r8)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    8(%rsi), %r10
-;;   movq    %rdi, %r8
-;;   addq    %r8, 0(%rsi), %r8
-;;   xorq    %r11, %r11, %r11
-;;   cmpq    %r10, %rdi
-;;   cmovnbeq %r11, %r8, %r8
-;;   movl    0(%r8), %eax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 03cc24bf9787..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    8(%rdx), %r11
-;;   movq    0(%rdx), %rax
-;;   lea     4096(%rax,%rdi,1), %r9
-;;   xorq    %rax, %rax, %rax
-;;   cmpq    %r11, %rdi
-;;   cmovnbeq %rax, %r9, %r9
-;;   movl    %esi, 0(%r9)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    8(%rsi), %r11
-;;   movq    0(%rsi), %rsi
-;;   lea     4096(%rsi,%rdi,1), %r9
-;;   xorq    %rsi, %rsi, %rsi
-;;   cmpq    %r11, %rdi
-;;   cmovnbeq %rsi, %r9, %r9
-;;   movl    0(%r9), %eax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 3320b9fa3c4c..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,82 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    8(%rdx), %rax
-;;   movq    %rdi, %rcx
-;;   addq    %rcx, 0(%rdx), %rcx
-;;   movl    $-65536, %edx
-;;   lea     0(%rcx,%rdx,1), %r10
-;;   xorq    %rcx, %rcx, %rcx
-;;   cmpq    %rax, %rdi
-;;   cmovnbeq %rcx, %r10, %r10
-;;   movl    %esi, 0(%r10)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    8(%rsi), %rcx
-;;   movq    %rdi, %rax
-;;   addq    %rax, 0(%rsi), %rax
-;;   movl    $-65536, %esi
-;;   lea     0(%rax,%rsi,1), %r10
-;;   xorq    %rax, %rax, %rax
-;;   cmpq    %rcx, %rdi
-;;   cmovnbeq %rax, %r10, %r10
-;;   movl    0(%r10), %eax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 449f63560bf7..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    8(%rdx), %r10
-;;   movq    %rdi, %r8
-;;   addq    %r8, 0(%rdx), %r8
-;;   xorq    %r11, %r11, %r11
-;;   cmpq    %r10, %rdi
-;;   cmovnbq %r11, %r8, %r8
-;;   movb    %sil, 0(%r8)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    8(%rsi), %r10
-;;   movq    %rdi, %r8
-;;   addq    %r8, 0(%rsi), %r8
-;;   xorq    %r11, %r11, %r11
-;;   cmpq    %r10, %rdi
-;;   cmovnbq %r11, %r8, %r8
-;;   movzbq  0(%r8), %rax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index be1e9e7c9b74..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    8(%rdx), %r11
-;;   movq    0(%rdx), %rax
-;;   lea     4096(%rax,%rdi,1), %r9
-;;   xorq    %rax, %rax, %rax
-;;   cmpq    %r11, %rdi
-;;   cmovnbeq %rax, %r9, %r9
-;;   movb    %sil, 0(%r9)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    8(%rsi), %r11
-;;   movq    0(%rsi), %rsi
-;;   lea     4096(%rsi,%rdi,1), %r9
-;;   xorq    %rsi, %rsi, %rsi
-;;   cmpq    %r11, %rdi
-;;   cmovnbeq %rsi, %r9, %r9
-;;   movzbq  0(%r9), %rax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 214b6e06f87f..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,82 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    8(%rdx), %rax
-;;   movq    %rdi, %rcx
-;;   addq    %rcx, 0(%rdx), %rcx
-;;   movl    $-65536, %edx
-;;   lea     0(%rcx,%rdx,1), %r10
-;;   xorq    %rcx, %rcx, %rcx
-;;   cmpq    %rax, %rdi
-;;   cmovnbeq %rcx, %r10, %r10
-;;   movb    %sil, 0(%r10)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    8(%rsi), %rcx
-;;   movq    %rdi, %rax
-;;   addq    %rax, 0(%rsi), %rax
-;;   movl    $-65536, %esi
-;;   lea     0(%rax,%rsi,1), %r10
-;;   xorq    %rax, %rax, %rax
-;;   cmpq    %rcx, %rdi
-;;   cmovnbeq %rax, %r10, %r10
-;;   movzbq  0(%r10), %rax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index a220900031eb..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   cmpq    $268435452, %r8
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rdx), %r10
-;;   movl    %esi, 0(%r10,%r8,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   cmpq    $268435452, %r8
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rsi), %r10
-;;   movl    0(%r10,%r8,1), %eax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index a13d6118d6e2..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   cmpq    $268431356, %r8
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rdx), %r10
-;;   movl    %esi, 4096(%r10,%r8,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   cmpq    $268431356, %r8
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rsi), %r10
-;;   movl    4096(%r10,%r8,1), %eax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 82fd6761831e..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,54 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index eff61e0a05a6..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   cmpq    $268435455, %r8
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rdx), %r10
-;;   movb    %sil, 0(%r10,%r8,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   cmpq    $268435455, %r8
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rsi), %r10
-;;   movzbq  0(%r10,%r8,1), %rax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 9e0560dad3ad..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   cmpq    $268431359, %r8
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rdx), %r10
-;;   movb    %sil, 4096(%r10,%r8,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   cmpq    $268431359, %r8
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rsi), %r10
-;;   movzbq  4096(%r10,%r8,1), %rax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 4c670d22934f..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,54 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 8066a12155e7..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r10d
-;;   movq    %r10, %r8
-;;   addq    %r8, 0(%rdx), %r8
-;;   xorq    %r11, %r11, %r11
-;;   cmpq    $268435452, %r10
-;;   cmovnbeq %r11, %r8, %r8
-;;   movl    %esi, 0(%r8)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r10d
-;;   movq    %r10, %r8
-;;   addq    %r8, 0(%rsi), %r8
-;;   xorq    %r11, %r11, %r11
-;;   cmpq    $268435452, %r10
-;;   cmovnbeq %r11, %r8, %r8
-;;   movl    0(%r8), %eax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 0d6b731a7715..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r11d
-;;   movq    0(%rdx), %rdi
-;;   lea     4096(%rdi,%r11,1), %r9
-;;   xorq    %rdi, %rdi, %rdi
-;;   cmpq    $268431356, %r11
-;;   cmovnbeq %rdi, %r9, %r9
-;;   movl    %esi, 0(%r9)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r11d
-;;   movq    0(%rsi), %rsi
-;;   lea     4096(%rsi,%r11,1), %r9
-;;   xorq    %rsi, %rsi, %rsi
-;;   cmpq    $268431356, %r11
-;;   cmovnbeq %rsi, %r9, %r9
-;;   movl    0(%r9), %eax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index f34aedba4999..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,54 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 93d48967ab97..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r10d
-;;   movq    %r10, %r8
-;;   addq    %r8, 0(%rdx), %r8
-;;   xorq    %r11, %r11, %r11
-;;   cmpq    $268435455, %r10
-;;   cmovnbeq %r11, %r8, %r8
-;;   movb    %sil, 0(%r8)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r10d
-;;   movq    %r10, %r8
-;;   addq    %r8, 0(%rsi), %r8
-;;   xorq    %r11, %r11, %r11
-;;   cmpq    $268435455, %r10
-;;   cmovnbeq %r11, %r8, %r8
-;;   movzbq  0(%r8), %rax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index d7bb854fbeb8..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r11d
-;;   movq    0(%rdx), %rdi
-;;   lea     4096(%rdi,%r11,1), %r9
-;;   xorq    %rdi, %rdi, %rdi
-;;   cmpq    $268431359, %r11
-;;   cmovnbeq %rdi, %r9, %r9
-;;   movb    %sil, 0(%r9)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r11d
-;;   movq    0(%rsi), %rsi
-;;   lea     4096(%rsi,%r11,1), %r9
-;;   xorq    %rsi, %rsi, %rsi
-;;   cmpq    $268431359, %r11
-;;   cmovnbeq %rsi, %r9, %r9
-;;   movzbq  0(%r9), %rax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 7e5c5846cb9d..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,54 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index d45f5525a325..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   movq    0(%rdx), %r9
-;;   movl    %esi, 0(%r9,%r8,1)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   movq    0(%rsi), %r9
-;;   movl    0(%r9,%r8,1), %eax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index bdab2846dba8..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   movq    0(%rdx), %r9
-;;   movl    %esi, 4096(%r9,%r8,1)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   movq    0(%rsi), %r9
-;;   movl    4096(%r9,%r8,1), %eax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index e5018d57055c..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,54 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 5c8e5a3b36ec..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   movq    0(%rdx), %r9
-;;   movb    %sil, 0(%r9,%r8,1)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   movq    0(%rsi), %r9
-;;   movzbq  0(%r9,%r8,1), %rax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 8f925ce9c0d8..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   movq    0(%rdx), %r9
-;;   movb    %sil, 4096(%r9,%r8,1)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   movq    0(%rsi), %r9
-;;   movzbq  4096(%r9,%r8,1), %rax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 9f2885490949..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,54 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index df3b5c4e3585..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   movq    0(%rdx), %r9
-;;   movl    %esi, 0(%r9,%r8,1)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   movq    0(%rsi), %r9
-;;   movl    0(%r9,%r8,1), %eax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 068f359bc566..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   movq    0(%rdx), %r9
-;;   movl    %esi, 4096(%r9,%r8,1)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   movq    0(%rsi), %r9
-;;   movl    4096(%r9,%r8,1), %eax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 3a4534773e76..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,54 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index d49f324df520..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   movq    0(%rdx), %r9
-;;   movb    %sil, 0(%r9,%r8,1)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   movq    0(%rsi), %r9
-;;   movzbq  0(%r9,%r8,1), %rax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 818bd94e0e9a..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   movq    0(%rdx), %r9
-;;   movb    %sil, 4096(%r9,%r8,1)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movl    %edi, %r8d
-;;   movq    0(%rsi), %r9
-;;   movzbq  4096(%r9,%r8,1), %rax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index a05818211f5c..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,54 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index d2402463f745..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   cmpq    $268435452, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rdx), %r9
-;;   movl    %esi, 0(%r9,%rdi,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   cmpq    $268435452, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rsi), %r9
-;;   movl    0(%r9,%rdi,1), %eax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index d53cd5714294..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   cmpq    $268431356, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rdx), %r9
-;;   movl    %esi, 4096(%r9,%rdi,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   cmpq    $268431356, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rsi), %r9
-;;   movl    4096(%r9,%rdi,1), %eax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 594e6ca2a6ce..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,54 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 38b0b387e730..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   cmpq    $268435455, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rdx), %r9
-;;   movb    %sil, 0(%r9,%rdi,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   cmpq    $268435455, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rsi), %r9
-;;   movzbq  0(%r9,%rdi,1), %rax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index d65db2d58b6a..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   cmpq    $268431359, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rdx), %r9
-;;   movb    %sil, 4096(%r9,%rdi,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   cmpq    $268431359, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rsi), %r9
-;;   movzbq  4096(%r9,%rdi,1), %rax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index d503a444d673..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,54 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index c0113a35f739..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    %rdi, %r8
-;;   addq    %r8, 0(%rdx), %r8
-;;   xorq    %r9, %r9, %r9
-;;   cmpq    $268435452, %rdi
-;;   cmovnbeq %r9, %r8, %r8
-;;   movl    %esi, 0(%r8)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    %rdi, %rdx
-;;   addq    %rdx, 0(%rsi), %rdx
-;;   xorq    %r9, %r9, %r9
-;;   cmpq    $268435452, %rdi
-;;   cmovnbeq %r9, %rdx, %rdx
-;;   movl    0(%rdx), %eax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index f9df8f3f9f83..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    0(%rdx), %r10
-;;   lea     4096(%r10,%rdi,1), %r8
-;;   xorq    %r10, %r10, %r10
-;;   cmpq    $268431356, %rdi
-;;   cmovnbeq %r10, %r8, %r8
-;;   movl    %esi, 0(%r8)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    0(%rsi), %r10
-;;   lea     4096(%r10,%rdi,1), %r8
-;;   xorq    %r10, %r10, %r10
-;;   cmpq    $268431356, %rdi
-;;   cmovnbeq %r10, %r8, %r8
-;;   movl    0(%r8), %eax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index b6cff5cd1f74..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,54 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 6bf8e9cc8a0d..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    %rdi, %r8
-;;   addq    %r8, 0(%rdx), %r8
-;;   xorq    %r9, %r9, %r9
-;;   cmpq    $268435455, %rdi
-;;   cmovnbeq %r9, %r8, %r8
-;;   movb    %sil, 0(%r8)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    %rdi, %rdx
-;;   addq    %rdx, 0(%rsi), %rdx
-;;   xorq    %r9, %r9, %r9
-;;   cmpq    $268435455, %rdi
-;;   cmovnbeq %r9, %rdx, %rdx
-;;   movzbq  0(%rdx), %rax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index ffa89d0b8110..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    0(%rdx), %r10
-;;   lea     4096(%r10,%rdi,1), %r8
-;;   xorq    %r10, %r10, %r10
-;;   cmpq    $268431359, %rdi
-;;   cmovnbeq %r10, %r8, %r8
-;;   movb    %sil, 0(%r8)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    0(%rsi), %r10
-;;   lea     4096(%r10,%rdi,1), %r8
-;;   xorq    %r10, %r10, %r10
-;;   cmpq    $268431359, %rdi
-;;   cmovnbeq %r10, %r8, %r8
-;;   movzbq  0(%r8), %rax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 5f0763931ede..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,54 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index e6a6a89e4714..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   cmpq    $268435452, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rdx), %r9
-;;   movl    %esi, 0(%r9,%rdi,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   cmpq    $268435452, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rsi), %r9
-;;   movl    0(%r9,%rdi,1), %eax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 910b2a1c470a..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   cmpq    $268431356, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rdx), %r9
-;;   movl    %esi, 4096(%r9,%rdi,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   cmpq    $268431356, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rsi), %r9
-;;   movl    4096(%r9,%rdi,1), %eax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 1c2b921734b5..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,54 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index beb7961aea11..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   cmpq    $268435455, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rdx), %r9
-;;   movb    %sil, 0(%r9,%rdi,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   cmpq    $268435455, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rsi), %r9
-;;   movzbq  0(%r9,%rdi,1), %rax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 59b5b2cbadb7..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   cmpq    $268431359, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rdx), %r9
-;;   movb    %sil, 4096(%r9,%rdi,1)
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   cmpq    $268431359, %rdi
-;;   jnbe    label3; j label1
-;; block1:
-;;   movq    0(%rsi), %r9
-;;   movzbq  4096(%r9,%rdi,1), %rax
-;;   jmp     label2
-;; block2:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;; block3:
-;;   ud2 heap_oob
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 361b9da270f1..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,54 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index c58eeb9a84b1..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    %rdi, %r8
-;;   addq    %r8, 0(%rdx), %r8
-;;   xorq    %r9, %r9, %r9
-;;   cmpq    $268435452, %rdi
-;;   cmovnbeq %r9, %r8, %r8
-;;   movl    %esi, 0(%r8)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    %rdi, %rdx
-;;   addq    %rdx, 0(%rsi), %rdx
-;;   xorq    %r9, %r9, %r9
-;;   cmpq    $268435452, %rdi
-;;   cmovnbeq %r9, %rdx, %rdx
-;;   movl    0(%rdx), %eax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index d03ce63e4683..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    0(%rdx), %r10
-;;   lea     4096(%r10,%rdi,1), %r8
-;;   xorq    %r10, %r10, %r10
-;;   cmpq    $268431356, %rdi
-;;   cmovnbeq %r10, %r8, %r8
-;;   movl    %esi, 0(%r8)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    0(%rsi), %r10
-;;   lea     4096(%r10,%rdi,1), %r8
-;;   xorq    %r10, %r10, %r10
-;;   cmpq    $268431356, %rdi
-;;   cmovnbeq %r10, %r8, %r8
-;;   movl    0(%r8), %eax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index dd2838ae773a..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,54 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 421d738d86b7..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    %rdi, %r8
-;;   addq    %r8, 0(%rdx), %r8
-;;   xorq    %r9, %r9, %r9
-;;   cmpq    $268435455, %rdi
-;;   cmovnbeq %r9, %r8, %r8
-;;   movb    %sil, 0(%r8)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    %rdi, %rdx
-;;   addq    %rdx, 0(%rsi), %rdx
-;;   xorq    %r9, %r9, %r9
-;;   cmpq    $268435455, %rdi
-;;   cmovnbeq %r9, %rdx, %rdx
-;;   movzbq  0(%rdx), %rax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 0f2e210d57f7..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    0(%rdx), %r10
-;;   lea     4096(%r10,%rdi,1), %r8
-;;   xorq    %r10, %r10, %r10
-;;   cmpq    $268431359, %rdi
-;;   cmovnbeq %r10, %r8, %r8
-;;   movb    %sil, 0(%r8)
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movq    0(%rsi), %r10
-;;   lea     4096(%r10,%rdi,1), %r8
-;;   xorq    %r10, %r10, %r10
-;;   cmpq    $268431359, %rdi
-;;   cmovnbeq %r10, %r8, %r8
-;;   movzbq  0(%r8), %rax
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 5a363f190e03..000000000000
--- a/cranelift/filetests/filetests/isa/x64/wasm/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,54 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = true
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   ud2 heap_oob
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/isa/x64/widen-high-bug.clif b/cranelift/filetests/filetests/isa/x64/widen-high-bug.clif
index 4778fdd06f06..c3e4149fba62 100644
--- a/cranelift/filetests/filetests/isa/x64/widen-high-bug.clif
+++ b/cranelift/filetests/filetests/isa/x64/widen-high-bug.clif
@@ -13,9 +13,9 @@ block0(v0: i64, v2: i8x16):
 ;   movq    %rsp, %rbp
 ; block0:
 ;   movdqu  80(%rdi), %xmm0
-;   uninit  %xmm5
-;   pxor    %xmm5, %xmm5, %xmm5
-;   punpckhbw %xmm0, %xmm5, %xmm0
+;   uninit  %xmm4
+;   pxor    %xmm4, %xmm4, %xmm4
+;   punpckhbw %xmm0, %xmm4, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -26,8 +26,8 @@ block0(v0: i64, v2: i8x16):
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
 ;   movdqu 0x50(%rdi), %xmm0
-;   pxor %xmm5, %xmm5
-;   punpckhbw %xmm5, %xmm0
+;   pxor %xmm4, %xmm4
+;   punpckhbw %xmm4, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
diff --git a/cranelift/filetests/filetests/isa/x64/widening.clif b/cranelift/filetests/filetests/isa/x64/widening.clif
index 65d32fd50665..1bd9ef170bcb 100644
--- a/cranelift/filetests/filetests/isa/x64/widening.clif
+++ b/cranelift/filetests/filetests/isa/x64/widening.clif
@@ -86,9 +86,8 @@ block0(v0: i8x16):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movdqa  %xmm0, %xmm2
-;   palignr $8, %xmm2, %xmm0, %xmm2
-;   pmovsxbw %xmm2, %xmm0
+;   palignr $8, %xmm0, %xmm0, %xmm0
+;   pmovsxbw %xmm0, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -98,9 +97,8 @@ block0(v0: i8x16):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movdqa %xmm0, %xmm2
-;   palignr $8, %xmm0, %xmm2
-;   pmovsxbw %xmm2, %xmm0
+;   palignr $8, %xmm0, %xmm0
+;   pmovsxbw %xmm0, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
@@ -115,9 +113,8 @@ block0(v0: i16x8):
 ;   pushq   %rbp
 ;   movq    %rsp, %rbp
 ; block0:
-;   movdqa  %xmm0, %xmm2
-;   palignr $8, %xmm2, %xmm0, %xmm2
-;   pmovsxwd %xmm2, %xmm0
+;   palignr $8, %xmm0, %xmm0, %xmm0
+;   pmovsxwd %xmm0, %xmm0
 ;   movq    %rbp, %rsp
 ;   popq    %rbp
 ;   ret
@@ -127,9 +124,8 @@ block0(v0: i16x8):
 ;   pushq %rbp
 ;   movq %rsp, %rbp
 ; block1: ; offset 0x4
-;   movdqa %xmm0, %xmm2
-;   palignr $8, %xmm0, %xmm2
-;   pmovsxwd %xmm2, %xmm0
+;   palignr $8, %xmm0, %xmm0
+;   pmovsxwd %xmm0, %xmm0
 ;   movq %rbp, %rsp
 ;   popq %rbp
 ;   retq
diff --git a/cranelift/filetests/filetests/isa/x64/winch.clif b/cranelift/filetests/filetests/isa/x64/winch.clif
new file mode 100644
index 000000000000..56d042e9cde4
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/winch.clif
@@ -0,0 +1,446 @@
+test compile precise-output
+target x86_64
+
+function %f1() winch {
+block0:
+    return
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %f2(i64, i64, i64, i64, i64, i64) -> i64 winch {
+  sig0 = () winch
+  fn0 = %g sig0
+
+block0(v0:i64, v1:i64, v2:i64, v3:i64, v4:i64, v5:i64):
+  call fn0()
+  return v0
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+;   subq    %rsp, $16, %rsp
+; block0:
+;   movq    %rdi, rsp(0 + virtual offset)
+;   load_ext_name %g+0, %r10
+;   call    *%r10
+;   movq    rsp(0 + virtual offset), %rax
+;   addq    %rsp, $16, %rsp
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+;   subq $0x10, %rsp
+; block1: ; offset 0x8
+;   movq %rdi, (%rsp)
+;   movabsq $0, %r10 ; reloc_external Abs8 %g 0
+;   callq *%r10
+;   movq (%rsp), %rax
+;   addq $0x10, %rsp
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %f3(i64, i64, i64, i64, i64, i64) -> i64 {
+  sig0 = () winch
+  fn0 = %g sig0
+
+block0(v0:i64, v1:i64, v2:i64, v3:i64, v4:i64, v5:i64):
+  call fn0()
+  return v0
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+;   subq    %rsp, $64, %rsp
+;   movq    %rbx, 16(%rsp)
+;   movq    %r12, 24(%rsp)
+;   movq    %r13, 32(%rsp)
+;   movq    %r14, 40(%rsp)
+;   movq    %r15, 48(%rsp)
+; block0:
+;   movq    %rdi, rsp(0 + virtual offset)
+;   load_ext_name %g+0, %r10
+;   call    *%r10
+;   movq    rsp(0 + virtual offset), %rax
+;   movq    16(%rsp), %rbx
+;   movq    24(%rsp), %r12
+;   movq    32(%rsp), %r13
+;   movq    40(%rsp), %r14
+;   movq    48(%rsp), %r15
+;   addq    %rsp, $64, %rsp
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+;   subq $0x40, %rsp
+;   movq %rbx, 0x10(%rsp)
+;   movq %r12, 0x18(%rsp)
+;   movq %r13, 0x20(%rsp)
+;   movq %r14, 0x28(%rsp)
+;   movq %r15, 0x30(%rsp)
+; block1: ; offset 0x21
+;   movq %rdi, (%rsp)
+;   movabsq $0, %r10 ; reloc_external Abs8 %g 0
+;   callq *%r10
+;   movq (%rsp), %rax
+;   movq 0x10(%rsp), %rbx
+;   movq 0x18(%rsp), %r12
+;   movq 0x20(%rsp), %r13
+;   movq 0x28(%rsp), %r14
+;   movq 0x30(%rsp), %r15
+;   addq $0x40, %rsp
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %f4(i64, i64, i64, i64, i64, i64) -> i64 winch {
+  sig0 = (i64, i64, i64, i64, i64, i64) -> i64 winch
+  fn0 = %g sig0
+
+block0(v0:i64, v1:i64, v2:i64, v3:i64, v4:i64, v5:i64):
+  v6 = call fn0(v5, v1, v2, v3, v4, v0)
+  return v6
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   load_ext_name %g+0, %r10
+;   movq    %rdi, %rax
+;   movq    %r9, %rdi
+;   movq    %rax, %r9
+;   call    *%r10
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movabsq $0, %r10 ; reloc_external Abs8 %g 0
+;   movq %rdi, %rax
+;   movq %r9, %rdi
+;   movq %rax, %r9
+;   callq *%r10
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %f5(i64, i64, i64, i64, i64, i64) -> i64 {
+  sig0 = (i64, i64, i64, i64, i64, i64) -> i64 winch
+  fn0 = %g sig0
+
+block0(v0:i64, v1:i64, v2:i64, v3:i64, v4:i64, v5:i64):
+  v6 = call fn0(v5, v1, v2, v3, v4, v0)
+  return v6
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+;   subq    %rsp, $48, %rsp
+;   movq    %rbx, 0(%rsp)
+;   movq    %r12, 8(%rsp)
+;   movq    %r13, 16(%rsp)
+;   movq    %r14, 24(%rsp)
+;   movq    %r15, 32(%rsp)
+; block0:
+;   load_ext_name %g+0, %r10
+;   movq    %rdi, %rax
+;   movq    %r9, %rdi
+;   movq    %rax, %r9
+;   call    *%r10
+;   movq    0(%rsp), %rbx
+;   movq    8(%rsp), %r12
+;   movq    16(%rsp), %r13
+;   movq    24(%rsp), %r14
+;   movq    32(%rsp), %r15
+;   addq    %rsp, $48, %rsp
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+;   subq $0x30, %rsp
+;   movq %rbx, (%rsp)
+;   movq %r12, 8(%rsp)
+;   movq %r13, 0x10(%rsp)
+;   movq %r14, 0x18(%rsp)
+;   movq %r15, 0x20(%rsp)
+; block1: ; offset 0x20
+;   movabsq $0, %r10 ; reloc_external Abs8 %g 0
+;   movq %rdi, %rax
+;   movq %r9, %rdi
+;   movq %rax, %r9
+;   callq *%r10
+;   movq (%rsp), %rbx
+;   movq 8(%rsp), %r12
+;   movq 0x10(%rsp), %r13
+;   movq 0x18(%rsp), %r14
+;   movq 0x20(%rsp), %r15
+;   addq $0x30, %rsp
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function u1:0() system_v {
+    sig0 = () winch
+    fn0 = u2:0 sig0
+
+block0:
+    v5 = func_addr.i64 fn0
+    call_indirect sig0, v5()
+    call_indirect sig0, v5()
+    return
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+;   subq    %rsp, $64, %rsp
+;   movq    %rbx, 16(%rsp)
+;   movq    %r12, 24(%rsp)
+;   movq    %r13, 32(%rsp)
+;   movq    %r14, 40(%rsp)
+;   movq    %r15, 48(%rsp)
+; block0:
+;   load_ext_name userextname0+0, %r10
+;   movq    %r10, rsp(0 + virtual offset)
+;   call    *%r10
+;   movq    rsp(0 + virtual offset), %r10
+;   call    *%r10
+;   movq    16(%rsp), %rbx
+;   movq    24(%rsp), %r12
+;   movq    32(%rsp), %r13
+;   movq    40(%rsp), %r14
+;   movq    48(%rsp), %r15
+;   addq    %rsp, $64, %rsp
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+;   subq $0x40, %rsp
+;   movq %rbx, 0x10(%rsp)
+;   movq %r12, 0x18(%rsp)
+;   movq %r13, 0x20(%rsp)
+;   movq %r14, 0x28(%rsp)
+;   movq %r15, 0x30(%rsp)
+; block1: ; offset 0x21
+;   movabsq $0, %r10 ; reloc_external Abs8 u2:0 0
+;   movq %r10, (%rsp)
+;   callq *%r10
+;   movq (%rsp), %r10
+;   callq *%r10
+;   movq 0x10(%rsp), %rbx
+;   movq 0x18(%rsp), %r12
+;   movq 0x20(%rsp), %r13
+;   movq 0x28(%rsp), %r14
+;   movq 0x30(%rsp), %r15
+;   addq $0x40, %rsp
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %f6(i64) -> i32 {
+  sig0 = () -> i32, i32, f64 winch
+  fn0 = %g sig0
+
+block0(v0:i64):
+  v1, v2, v3 = call fn0()
+  v4 = band.i32 v1, v2
+  return v4
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+;   subq    %rsp, $64, %rsp
+;   movq    %rbx, 16(%rsp)
+;   movq    %r12, 24(%rsp)
+;   movq    %r13, 32(%rsp)
+;   movq    %r14, 40(%rsp)
+;   movq    %r15, 48(%rsp)
+; block0:
+;   lea     0(%rsp), %rdi
+;   load_ext_name %g+0, %r10
+;   call    *%r10
+;   movq    4(%rsp), %rax
+;   movq    0(%rsp), %r9
+;   andl    %eax, %r9d, %eax
+;   movq    16(%rsp), %rbx
+;   movq    24(%rsp), %r12
+;   movq    32(%rsp), %r13
+;   movq    40(%rsp), %r14
+;   movq    48(%rsp), %r15
+;   addq    %rsp, $64, %rsp
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+;   subq $0x40, %rsp
+;   movq %rbx, 0x10(%rsp)
+;   movq %r12, 0x18(%rsp)
+;   movq %r13, 0x20(%rsp)
+;   movq %r14, 0x28(%rsp)
+;   movq %r15, 0x30(%rsp)
+; block1: ; offset 0x21
+;   leaq (%rsp), %rdi
+;   movabsq $0, %r10 ; reloc_external Abs8 %g 0
+;   callq *%r10
+;   movq 4(%rsp), %rax
+;   movq (%rsp), %r9
+;   andl %r9d, %eax
+;   movq 0x10(%rsp), %rbx
+;   movq 0x18(%rsp), %r12
+;   movq 0x20(%rsp), %r13
+;   movq 0x28(%rsp), %r14
+;   movq 0x30(%rsp), %r15
+;   addq $0x40, %rsp
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %reverse_args(i32, i64, i32, i64) -> i64, i32, i64, i32 winch {
+block0(v0: i32, v1: i64, v2: i32, v3: i64):
+    return v3, v2, v1, v0
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movq    %rcx, 12(%r8)
+;   movl    %edx, 8(%r8)
+;   movq    %rsi, 0(%r8)
+;   movq    %rdi, %rax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movq %rcx, 0xc(%r8)
+;   movl %edx, 8(%r8)
+;   movq %rsi, (%r8)
+;   movq %rdi, %rax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %stack_result_extension() -> i64, i8 uext, i8 uext winch {
+block0:
+    v0 = iconst.i64 0x00000000ffff2222
+    v1 = iconst.i8 85
+    v2 = iconst.i8 11
+    return v0, v1, v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movl    $-56798, %r11d
+;   movl    $85, %r9d
+;   movl    $11, %r10d
+;   movq    %r11, 8(%rdi)
+;   movzbq  %r9b, %r11
+;   movq    %r9, 0(%rdi)
+;   movzbq  %r10b, %rax
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movl $0xffff2222, %r11d
+;   movl $0x55, %r9d
+;   movl $0xb, %r10d
+;   movq %r11, 8(%rdi)
+;   movzbq %r9b, %r11
+;   movq %r9, (%rdi)
+;   movzbq %r10b, %rax
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
+function %stack_result_no_extension() -> i64, i8, i8 winch {
+block0:
+    v0 = iconst.i64 0x00000000ffff2222
+    v1 = iconst.i8 85
+    v2 = iconst.i8 11
+    return v0, v1, v2
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movl    $-56798, %edx
+;   movl    $85, %r8d
+;   movl    $11, %eax
+;   movq    %rdx, 1(%rdi)
+;   movb    %r8b, 0(%rdi)
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movl $0xffff2222, %edx
+;   movl $0x55, %r8d
+;   movl $0xb, %eax
+;   movq %rdx, 1(%rdi)
+;   movb %r8b, (%rdi)
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/isa/x64/xmm-select-load.clif b/cranelift/filetests/filetests/isa/x64/xmm-select-load.clif
new file mode 100644
index 000000000000..a245ef0e53b0
--- /dev/null
+++ b/cranelift/filetests/filetests/isa/x64/xmm-select-load.clif
@@ -0,0 +1,34 @@
+test compile precise-output
+target x86_64
+
+function %a(i32, f64, i64) -> f64 {
+block0(v0: i32, v1: f64, v2: i64):
+  v3 = load.f64 v2
+  v4 = select v0, v3, v1
+  return v4
+}
+
+; VCode:
+;   pushq   %rbp
+;   movq    %rsp, %rbp
+; block0:
+;   movsd   0(%rsi), %xmm5
+;   testl   %edi, %edi
+;   movsd %xmm0, %xmm0; jz $next; movsd %xmm5, %xmm0; $next:
+;   movq    %rbp, %rsp
+;   popq    %rbp
+;   ret
+;
+; Disassembled:
+; block0: ; offset 0x0
+;   pushq %rbp
+;   movq %rsp, %rbp
+; block1: ; offset 0x4
+;   movsd (%rsi), %xmm5 ; trap: heap_oob
+;   testl %edi, %edi
+;   je 0x14
+;   movsd %xmm5, %xmm0
+;   movq %rbp, %rsp
+;   popq %rbp
+;   retq
+
diff --git a/cranelift/filetests/filetests/parser/call.clif b/cranelift/filetests/filetests/parser/call.clif
index 1334b07afbdd..927e441ff6f0 100644
--- a/cranelift/filetests/filetests/parser/call.clif
+++ b/cranelift/filetests/filetests/parser/call.clif
@@ -84,11 +84,11 @@ block0:
 ; check: return
 
 ; Special purpose function arguments
-function %special1(i32 sret, i32 stack_limit) -> i32 vmctx {
-block0(v1: i32, v2: i32):
+function %special1(i32 sret) -> i32 vmctx {
+block0(v1: i32):
     return v1
 }
-; check: function %special1(i32 sret, i32 stack_limit) -> i32 vmctx fast {
-; check: block0(v1: i32, v2: i32):
+; check: function %special1(i32 sret) -> i32 vmctx fast {
+; check: block0(v1: i32):
 ; check:     return v1
 ; check: }
diff --git a/cranelift/filetests/filetests/parser/cold.clif b/cranelift/filetests/filetests/parser/cold.clif
new file mode 100644
index 000000000000..55064fe6ae3d
--- /dev/null
+++ b/cranelift/filetests/filetests/parser/cold.clif
@@ -0,0 +1,12 @@
+test cat
+
+function %cold() cold {
+    sig0 = () cold
+    sig1 = () -> i8 cold
+block1:
+    return
+}
+
+; sameln: function %cold() cold {
+; nextln:     sig0 = () cold
+; nextln:     sig1 = () -> i8 cold
diff --git a/cranelift/filetests/filetests/parser/memory.clif b/cranelift/filetests/filetests/parser/memory.clif
index 8358ab04f909..7ef85c07f6f5 100644
--- a/cranelift/filetests/filetests/parser/memory.clif
+++ b/cranelift/filetests/filetests/parser/memory.clif
@@ -49,23 +49,3 @@ block0:
     v2 = bxor v0, v1
     return v2
 }
-
-function %table_addr(i32) {
-    table0 = dynamic gv1, element_size 1, bound gv2, index_type i32
-
-block0(v0: i32):
-    v1 = table_addr.i32 table0, v0
-    v2 = table_addr.i32 table0, v0+1
-    v3 = table_addr.i32 table0, v0+0
-    return
-}
-
-; sameln: function %table_addr(i32) fast {
-; nextln:     table0 = dynamic gv1, min 0, bound gv2, element_size 1, index_type i32
-; nextln: 
-; nextln: block0(v0: i32):
-; nextln:     v1 = table_addr.i32 table0, v0
-; nextln:     v2 = table_addr.i32 table0, v0+1
-; nextln:     v3 = table_addr.i32 table0, v0
-; nextln:     return
-; nextln: }
diff --git a/cranelift/filetests/filetests/parser/tiny.clif b/cranelift/filetests/filetests/parser/tiny.clif
index 90a8f28aa309..cbe44b3c0d92 100644
--- a/cranelift/filetests/filetests/parser/tiny.clif
+++ b/cranelift/filetests/filetests/parser/tiny.clif
@@ -10,6 +10,16 @@ block0:
 ; nextln:     trap user0
 ; nextln: }
 
+; The same small function, but with empty parens on the first block.
+function %minimal_empty_parens() {
+block0():
+    trap user0
+}
+; sameln: function %minimal_empty_parens() fast {
+; nextln: block0:
+; nextln:     trap user0
+; nextln: }
+
 ; Create and use values.
 ; Polymorphic instructions with type suffix.
 function %ivalues() {
@@ -36,7 +46,7 @@ block0:
 }
 ; sameln: function %bvalues() fast {
 ; nextln: block0:
-; nextln:     v0 = iconst.i32 0xffff_ffff
+; nextln:     v0 = iconst.i32 -1
 ; nextln:     v1 = iconst.i8 0
 ; nextln:     v2 = sextend.i32 v1
 ; nextln:     v3 = bxor v0, v2
@@ -111,7 +121,7 @@ block0(v90: f32, v91: f32):
 ; nextln: }
 
 ; The bitcast instruction has two type variables: The controlling type variable
-; controls the outout type, and the input type is a free variable.
+; controls the output type, and the input type is a free variable.
 function %bitcast(i32, f32) {
 block0(v90: i32, v91: f32):
     v0 = bitcast.i8x4 v90
diff --git a/cranelift/filetests/filetests/parser/user_stack_maps.clif b/cranelift/filetests/filetests/parser/user_stack_maps.clif
new file mode 100644
index 000000000000..8596849dbe93
--- /dev/null
+++ b/cranelift/filetests/filetests/parser/user_stack_maps.clif
@@ -0,0 +1,35 @@
+; Parser tests for user stack maps on call instructions.
+
+test cat
+
+function %foo() system_v {
+    ss0 = explicit_slot 12, align = 4
+    sig0 = (i32) system_v
+    fn0 = colocated u0:0 sig0
+
+block0:
+    v0 = iconst.i32 0
+    v1 = iconst.i32 1
+    v2 = iconst.i32 2
+    v3 = iconst.i32 3
+
+    stack_store v0, ss0
+    stack_store v1, ss0+4
+    stack_store v2, ss0+8
+    call fn0(v0), stack_map=[i32 @ ss0+0, i32 @ ss0+4, i32 @ ss0+8]
+; check: call fn0(v0), stack_map=[i32 @ ss0+0, i32 @ ss0+4, i32 @ ss0+8]
+
+    stack_store v1, ss0
+    stack_store v2, ss0+4
+    call fn0(v0), stack_map=[i32 @ ss0+0, i32 @ ss0+4]
+; check: call fn0(v0), stack_map=[i32 @ ss0+0, i32 @ ss0+4]
+
+    stack_store v2, ss0
+    call fn0(v1), stack_map=[i32 @ ss0+0]
+; check: call fn0(v1), stack_map=[i32 @ ss0+0]
+
+    call fn0(v2)
+; check: call fn0(v2)
+
+    return
+}
diff --git a/cranelift/filetests/filetests/pcc/fail/add.clif b/cranelift/filetests/filetests/pcc/fail/add.clif
new file mode 100644
index 000000000000..afcf9765015a
--- /dev/null
+++ b/cranelift/filetests/filetests/pcc/fail/add.clif
@@ -0,0 +1,51 @@
+test compile expect-fail
+set enable_pcc=true
+target aarch64
+target x86_64
+
+function %f0(i32, i32) -> i32 {
+block0(v0 ! range(32, 0, 0x100): i32, v1 ! range(32, 0, 0x80): i32):
+    v2 ! range(32, 0, 0x17f) = iadd.i32 v0, v1
+    return v2
+}
+
+function %f1(i32) -> i32 {
+block0(v0 ! range(32, 0, 0x100): i32):
+    v1 ! range(32, 0, 1) = iconst.i32 1
+    v2 ! range(32, 0, 0x100) = iadd.i32 v0, v1
+    return v2
+}
+
+function %f3(i32) -> i64 {
+block0(v0: i32):
+    v1 ! range(32, 0, 1) = iconst.i32 1
+    v2 ! range(32, 0, 0xffff_fffe) = iadd.i32 v0, v1
+    v3 ! range(64, 0, 0xffff_fffe) = uextend.i64 v2
+    return v3
+}
+
+function %f3(i32) -> i64 {
+block0(v0: i32):
+    v1 ! range(32, 0, 1) = iconst.i32 1
+    v2 ! range(32, 0, 0xffff_ffff) = iadd.i32 v0, v1
+    v3 ! range(64, 0, 0xffff_ffff) = uextend.i64 v2
+    v4 ! range(64, 0, 0x1) = iconst.i64 1
+    v5 ! range(64, 0, 0xffff_ffff) = iadd.i64 v3, v4
+    return v5
+}
+
+;; check merged ops:
+function %f4(i32, i32) -> i32 {
+block0(v0 ! range(32, 0, 0x100): i32, v1 ! range(32, 0, 0x200): i32):
+  v2 = iconst.i32 2
+  v3 ! range(32, 0, 0x400) = ishl.i32 v0, v2
+  v4 ! range(32, 0, 0x5ff) = iadd.i32 v1, v3
+  return v4
+}
+
+function %f5(i32, i64) -> i64 {
+block0(v0 ! range(32, 0, 0x100): i32, v1 ! range(64, 0, 0x200): i64):
+  v2 ! range(64, 0, 0x100) = uextend.i64 v0
+  v3 ! range(64, 0, 0x2ff) = iadd.i64 v1, v2
+  return v3
+}
diff --git a/cranelift/filetests/filetests/pcc/fail/blockparams.clif b/cranelift/filetests/filetests/pcc/fail/blockparams.clif
new file mode 100644
index 000000000000..3840f9932322
--- /dev/null
+++ b/cranelift/filetests/filetests/pcc/fail/blockparams.clif
@@ -0,0 +1,20 @@
+test compile expect-fail
+set enable_pcc=true
+target aarch64
+target x86_64
+
+function %f0(i64, i32) -> i64 {
+block0(v0 ! range(64, 0, 0x100): i64, v1: i32):
+    v2 ! range(64, 0, 0x100) = iconst.i64 0x100
+    v3 ! range(64, 0, 0x200) = iadd v0, v2
+    brif v1, block1(v0), block2(v3)
+
+block1(v4 ! range(64, 0, 0xff): i64):  ;; shrink the range -- should be caught
+    jump block3(v4)
+
+block2(v5 ! range(64, 0, 0x1ff): i64):
+    jump block3(v5)
+
+block3(v6 ! range(64, 0, 1): i64):
+    return v6
+}
diff --git a/cranelift/filetests/filetests/pcc/fail/extend.clif b/cranelift/filetests/filetests/pcc/fail/extend.clif
new file mode 100644
index 000000000000..43b830d7a998
--- /dev/null
+++ b/cranelift/filetests/filetests/pcc/fail/extend.clif
@@ -0,0 +1,10 @@
+test compile expect-fail
+set enable_pcc=true
+target aarch64
+target x86_64
+
+function %f0(i32) -> i64 {
+block0(v0 ! range(32, 0, 0xffff_ffff): i32):
+  v1 ! range(64, 0, 0xffff_0000) = uextend.i64 v0
+  return v1
+}
diff --git a/cranelift/filetests/filetests/pcc/fail/load.clif b/cranelift/filetests/filetests/pcc/fail/load.clif
new file mode 100644
index 000000000000..c4c086b1f19b
--- /dev/null
+++ b/cranelift/filetests/filetests/pcc/fail/load.clif
@@ -0,0 +1,65 @@
+test compile expect-fail
+set enable_pcc=true
+target aarch64
+target x86_64
+
+function %f0(i64, i32) -> i64 {
+    mt0 = memory 0x1000
+block0(v0 ! mem(mt0, 0, 0): i64, v1 ! range(32, 0, 0x1000): i32):
+    v2 ! range(64, 0, 0x100) = uextend.i64 v1
+    v3 ! mem(mt0, 0, 0x100) = iadd.i64 v0, v2
+    v4 = load.i64 checked v3
+    return v4
+}
+
+;; Insufficient guard region: the 8-byte load could go off the end.
+function %f1(i64, i32) -> i64 {
+    mt0 = memory 0x1_0000_0000
+block0(v0 ! mem(mt0, 0, 0): i64, v1 ! range(32, 0, 0xffff_ffff): i32):
+    v2 ! range(64, 0, 0xffff_ffff) = uextend.i64 v1
+    v3 ! mem(mt0, 0, 0xffff_ffff) = iadd.i64 v0, v2
+    v4 = load.i64 checked v3
+    return v4
+}
+
+;; RegRegExtend mode on aarch64.
+function %f2(i64, i32) -> i8 {
+    mt0 = memory 0x1000
+block0(v0 ! mem(mt0, 0, 0x1000): i64, v1 ! range(32, 0, 0x1000): i32):
+    v2 ! range(64, 0, 0x100) = uextend.i64 v1
+    v3 ! mem(mt0, 0, 0x100) = iadd.i64 v0, v2
+    v4 = load.i8 checked v3
+    return v4
+}
+
+;; RegReg mode on aarch64.
+function %f3(i64, i64) -> i8 {
+    mt0 = memory 0x100
+block0(v0 ! mem(mt0, 0, 0): i64, v1 ! range(64, 0, 0xfff): i64):
+    v2 ! mem(mt0, 0, 0xfff) = iadd.i64 v0, v1
+    v3 = load.i8 checked v2
+    return v3
+}
+
+;; RegScaledExtended mode on aarch64.
+function %f4(i64, i32) -> i64 {
+    mt0 = memory 0x7000
+block0(v0 ! mem(mt0, 0, 0): i64, v1 ! range(32, 0, 0xfff): i32):
+    v2 ! range(64, 0, 0xfff) = uextend.i64 v1
+    v3 = iconst.i32 3
+    v4 ! range(64, 0, 0x7ff8) = ishl.i64 v2, v3
+    v5 ! mem(mt0, 0, 0x7ff8) = iadd.i64 v0, v4
+    v6 = load.i64 checked v5
+    return v6
+}
+
+;; RegScaled mode on aarch64.
+function %f5(i64, i64) -> i64 {
+    mt0 = memory 0x7000
+block0(v0 ! mem(mt0, 0, 0): i64, v1 ! range(64, 0, 0xfff): i64):
+    v2 = iconst.i32 3
+    v3 ! range(64, 0, 0x7ff8) = ishl.i64 v1, v2
+    v4 ! mem(mt0, 0, 0x7ff8) = iadd.i64 v0, v3
+    v5 = load.i64 checked v4
+    return v5
+}
diff --git a/cranelift/filetests/filetests/pcc/fail/memtypes.clif b/cranelift/filetests/filetests/pcc/fail/memtypes.clif
new file mode 100644
index 000000000000..6f5b12a38307
--- /dev/null
+++ b/cranelift/filetests/filetests/pcc/fail/memtypes.clif
@@ -0,0 +1,30 @@
+test verifier
+set enable_pcc=true
+target aarch64
+target x86_64
+
+function %f0(i64) -> i32 {
+    mt0 = struct 8 { 4: i32, 0: i32 } ; error: out-of-order
+
+block0(v0 ! mem(mt0, 0, 0): i64):
+    v1 = load.i32 v0+0
+    return v1
+}
+
+function %f1(i64) -> i32 {
+    ;; out-of-bounds field:
+    mt0 = struct 8 { 0: i32, 6: i32 } ; error: field at offset 6 of size 4 that overflows
+
+block0(v0 ! mem(mt0, 0, 0): i64):
+    v1 = load.i32 v0+0
+    return v1
+}
+
+function %f2(i64) -> i32 {
+    ;; overflowing offset + field size:
+    mt0 = struct 8 { 0: i32, 0xffff_ffff_ffff_ffff: i32 } ; error: field at offset 18446744073709551615 of size 4; offset plus size overflows a u64
+
+block0(v0 ! mem(mt0, 0, 0): i64):
+    v1 = load.i32 v0+0
+    return v1
+}
diff --git a/cranelift/filetests/filetests/pcc/fail/shift.clif b/cranelift/filetests/filetests/pcc/fail/shift.clif
new file mode 100644
index 000000000000..b4f4929b3bc2
--- /dev/null
+++ b/cranelift/filetests/filetests/pcc/fail/shift.clif
@@ -0,0 +1,11 @@
+test compile expect-fail
+set enable_pcc=true
+target aarch64
+target x86_64
+
+function %f0(i32) -> i32 {
+block0(v0 ! range(32, 1, 0x100): i32):
+  v1 = iconst.i32 2
+  v2 ! range(32, 4, 0x3ff) = ishl.i32 v0, v1
+  return v2
+}
diff --git a/cranelift/filetests/filetests/pcc/fail/simple.clif b/cranelift/filetests/filetests/pcc/fail/simple.clif
new file mode 100644
index 000000000000..45b2e9ab665d
--- /dev/null
+++ b/cranelift/filetests/filetests/pcc/fail/simple.clif
@@ -0,0 +1,27 @@
+test compile expect-fail
+set enable_pcc=true
+target aarch64
+target x86_64
+
+;; The `memory` memtype is not large enough here -- the 4GiB-range
+;; 32-bit offset could go out of range. PCC should catch this.
+
+function %simple1(i64 vmctx, i32) -> i8 {
+    mt0 = memory 0x8000_0000
+block0(v0 ! mem(mt0, 0, 0): i64, v1 ! range(32, 0, 0xffff_ffff): i32):
+    v2 ! range(64, 0, 0xffff_ffff) = uextend.i64 v1
+    v3 ! mem(mt0, 0, 0xffff_ffff) = iadd.i64 v0, v2
+    v4 = load.i8 checked v3
+    return v4
+}
+
+;; Check that the offset in the `mem` is validated too.
+
+function %simple2(i64 vmctx, i32) -> i8 {
+    mt0 = memory 0x8000_0000
+block0(v0 ! mem(mt0, 0, 0): i64, v1 ! range(32, 0, 0xffff_ffff): i32):
+    v2 ! range(64, 0, 0xffff_ffff) = uextend.i64 v1
+    v3 ! mem(mt0, 0, 0) = iadd.i64 v0, v2
+    v4 = load.i8 checked v3
+    return v4
+}
diff --git a/cranelift/filetests/filetests/pcc/fail/struct.clif b/cranelift/filetests/filetests/pcc/fail/struct.clif
new file mode 100644
index 000000000000..88d905e32e3a
--- /dev/null
+++ b/cranelift/filetests/filetests/pcc/fail/struct.clif
@@ -0,0 +1,29 @@
+test compile expect-fail
+set enable_pcc=true
+target aarch64
+target x86_64
+
+function %f0(i64) -> i64 {
+    mt0 = struct 8 { 0: i64 ! mem(mt1, 0, 0) }
+    mt1 = memory 0x1_0000_0000
+block0(v0 ! mem(mt0, 0, 0): i64):
+    v1 ! mem(mt1, 8, 8) = load.i64 checked v0
+    return v1
+}
+
+function %f1(i64, i64) {
+    mt0 = struct 8 { 0: i64 ! mem(mt1, 0, 0) }
+    mt1 = memory 0x1_0000_0000
+block0(v0 ! mem(mt0, 0, 0): i64, v1 ! mem(mt1, 8, 8): i64):
+    store.i64 checked v1, v0
+    return
+}
+
+function %f2(i64) -> i32 {
+    mt0 = struct 8 { 0: i32 ! range(32, 0, 1), 4: i32 }
+
+    ;; insufficiently-constrained range:
+block0(v0 ! mem(mt0, 0, 8): i64):
+    v1 ! range(32, 0, 1) = load.i32 checked v0+0
+    return v1
+}
diff --git a/cranelift/filetests/filetests/pcc/fail/vmctx.clif b/cranelift/filetests/filetests/pcc/fail/vmctx.clif
new file mode 100644
index 000000000000..1dc947bf21fb
--- /dev/null
+++ b/cranelift/filetests/filetests/pcc/fail/vmctx.clif
@@ -0,0 +1,38 @@
+test compile expect-fail
+set enable_pcc=true
+target aarch64
+target x86_64
+
+;; Equivalent to a Wasm `i64.load` from a static memory.
+function %f0(i64, i32) -> i64 {
+    ;; mock vmctx struct:
+    mt0 = struct 8 { 0: i64 readonly ! mem(mt1, 0, 0) }
+    ;; mock static memory: 4GiB range, *but insufficient guard*
+    mt1 = memory 0x1_0000_0000
+
+block0(v0 ! mem(mt0, 0, 0): i64, v1: i32):
+    ;; Compute the address: base + offset. Guard region (2GiB) is
+    ;; sufficient for an 8-byte I64 load.
+    v2 ! mem(mt1, 0, 0) = load.i64 checked v0+0    ;; base pointer
+    v3 ! range(64, 0, 0xffff_ffff) = uextend.i64 v1  ;; offset
+    v4 ! mem(mt1, 0, 0xffff_ffff) = iadd.i64 v2, v3
+    v5 = load.i64 checked v4
+    return v5
+}
+
+;; Equivalent to a Wasm `i64.load` from a static memory.
+function %f1(i64, i32) -> i64 {
+    ;; mock vmctx struct:
+    mt0 = struct 16 { 0: i64 readonly ! mem(mt1, 0, 0), 8: i64 readonly }
+    ;; mock static memory: 4GiB range, *but insufficient guard*
+    mt1 = memory 0x1_8000_0000
+
+block0(v0 ! mem(mt0, 0, 0): i64, v1: i32):
+    ;; Compute the address: base + offset. Guard region (2GiB) is
+    ;; sufficient for an 8-byte I64 load.
+    v2 ! mem(mt1, 0, 0) = load.i64 checked v0+8    ;; base pointer, but the wrong one
+    v3 ! range(64, 0, 0xffff_ffff) = uextend.i64 v1  ;; offset
+    v4 ! mem(mt1, 0, 0xffff_ffff) = iadd.i64 v2, v3
+    v5 = load.i64 checked v4
+    return v5
+}
diff --git a/cranelift/filetests/filetests/pcc/succeed/add.clif b/cranelift/filetests/filetests/pcc/succeed/add.clif
new file mode 100644
index 000000000000..2e2416ce642d
--- /dev/null
+++ b/cranelift/filetests/filetests/pcc/succeed/add.clif
@@ -0,0 +1,61 @@
+test compile
+set enable_pcc=true
+target aarch64
+target x86_64
+
+function %f0(i32, i32) -> i32 {
+block0(v0 ! range(32, 0, 0x100): i32, v1 ! range(32, 0, 0x80): i32):
+    v2 ! range(32, 0, 0x180) = iadd.i32 v0, v1
+    return v2
+}
+
+function %f1(i32) -> i32 {
+block0(v0 ! range(32, 0, 0x100): i32):
+    v1 ! range(32, 0, 1) = iconst.i32 1
+    v2 ! range(32, 0, 0x101) = iadd.i32 v0, v1
+    return v2
+}
+
+;; a looser but still accurate bound should check too:
+function %f2(i32) -> i32 {
+block0(v0 ! range(32, 0, 0x100): i32):
+    v1 ! range(32, 0, 1) = iconst.i32 1
+    v2 ! range(32, 0, 0x102) = iadd.i32 v0, v1
+    return v2
+}
+
+;; we should be able to verify a range based on the type alone:
+function %f3(i32) -> i64 {
+block0(v0: i32):
+    v1 ! range(32, 0, 1) = iconst.i32 1
+    v2 ! range(32, 0, 0xffff_ffff) = iadd.i32 v0, v1
+    v3 ! range(64, 0, 0xffff_ffff) = uextend.i64 v2
+    return v3
+}
+
+;; we should be able to verify a range based on the type alone:
+function %f3(i32) -> i64 {
+block0(v0: i32):
+    v1 ! range(32, 0, 1) = iconst.i32 1
+    v2 ! range(32, 0, 0xffff_ffff) = iadd.i32 v0, v1
+    v3 ! range(64, 0, 0xffff_ffff) = uextend.i64 v2
+    v4 ! range(64, 0, 0x1) = iconst.i64 1
+    v5 ! range(64, 0, 0x1_0000_0000) = iadd.i64 v3, v4
+    return v5
+}
+
+;; check merged ops:
+function %f4(i32, i32) -> i32 {
+block0(v0 ! range(32, 0, 0x100): i32, v1 ! range(32, 0, 0x200): i32):
+  v2 = iconst.i32 2
+  v3 ! range(32, 0, 0x400) = ishl.i32 v0, v2
+  v4 ! range(32, 0, 0x600) = iadd.i32 v1, v3
+  return v4
+}
+
+function %f5(i32, i64) -> i64 {
+block0(v0 ! range(32, 0, 0x100): i32, v1 ! range(64, 0, 0x200): i64):
+  v2 ! range(64, 0, 0x100) = uextend.i64 v0
+  v3 ! range(64, 0, 0x300) = iadd.i64 v1, v2
+  return v3
+}
diff --git a/cranelift/filetests/filetests/pcc/succeed/blockparams.clif b/cranelift/filetests/filetests/pcc/succeed/blockparams.clif
new file mode 100644
index 000000000000..7a823e1bf27d
--- /dev/null
+++ b/cranelift/filetests/filetests/pcc/succeed/blockparams.clif
@@ -0,0 +1,20 @@
+test compile
+set enable_pcc=true
+target aarch64
+target x86_64
+
+function %f0(i64, i32) -> i64 {
+block0(v0 ! range(64, 0, 0x100): i64, v1: i32):
+    v2 ! range(64, 0, 0x100) = iconst.i64 0x100
+    v3 ! range(64, 0, 0x200) = iadd v0, v2
+    brif v1, block1(v0), block2(v3)
+
+block1(v4 ! range(64, 0, 0x1000): i64):  ;; broaden the range -- always allowed
+    jump block3(v4)
+
+block2(v5 ! range(64, 0, 0x2000): i64):
+    jump block3(v5)
+
+block3(v6 ! range(64, 0, 0x2001): i64):
+    return v6
+}
diff --git a/cranelift/filetests/filetests/pcc/succeed/const.clif b/cranelift/filetests/filetests/pcc/succeed/const.clif
new file mode 100644
index 000000000000..dd1e258d4e1c
--- /dev/null
+++ b/cranelift/filetests/filetests/pcc/succeed/const.clif
@@ -0,0 +1,42 @@
+test compile
+set enable_pcc=true
+target aarch64
+target x86_64
+
+function %f0() {
+block0:
+    v0 ! range(64, 0, 0) = iconst.i64 0
+    v1 ! range(64, 1, 1) = iconst.i64 1
+    v2 ! range(64, 0xfff, 0xfff) = iconst.i64 0xfff
+    v3 ! range(64, 0x10000, 0x10000) = iconst.i64 0x10000
+    v4 ! range(64, 0xffffc, 0xffffc) = iconst.i64 0xffffc
+    v5 ! range(64, 0x1_0000_0000, 0x1_0000_0000) = iconst.i64 0x1_0000_0000
+    v6 ! range(64, 0x1_0000_0000_0000, 0x1_0000_0000_0000) = iconst.i64 0x1_0000_0000_0000
+    v7 ! range(64, 0xffff_0000_0000_0000, 0xffff_0000_0000_0000) = iconst.i64 0xffff_0000_0000_0000
+    v8 ! range(64, 0xffff_0000_0000_ffff, 0xffff_0000_0000_ffff) = iconst.i64 0xffff_0000_0000_ffff
+    return
+}
+
+function %f1() -> i32 {
+block0:
+    v0 = iconst.i32 0x10_0010
+    return v0
+}
+
+function %f2() -> i64 {
+block0:
+    v0 = iconst.i64 0x9_ffff_ffff
+    return v0
+}
+
+function %f3() -> i64 {
+block0:
+    v0 = iconst.i64 0xffff_fff7
+    return v0
+}
+
+function %f4() -> i64 {
+block0:
+    v0 ! range(64, 0x1_0001_ffff_ffff, 0x1_0001_ffff_ffff) = iconst.i64 0x1_0001_ffff_ffff
+    return v0
+}
diff --git a/cranelift/filetests/filetests/pcc/succeed/dynamic.clif b/cranelift/filetests/filetests/pcc/succeed/dynamic.clif
new file mode 100644
index 000000000000..13f96bc8b3b9
--- /dev/null
+++ b/cranelift/filetests/filetests/pcc/succeed/dynamic.clif
@@ -0,0 +1,42 @@
+test compile
+set enable_pcc=true
+target aarch64
+target x86_64
+
+;; Equivalent to a Wasm `i64.load` from a dynamic memory.
+function %f0(i64 vmctx, i32) -> i64 {
+    gv0 = vmctx
+    gv1 = load.i64 notrap aligned checked gv0+0 ;; base
+    gv2 = load.i64 notrap aligned checked gv0+8 ;; size
+    
+    ;; mock vmctx struct:
+    mt0 = struct 16 {
+        0: i64 readonly ! dynamic_mem(mt1, 0, 0),
+        8: i64 readonly ! dynamic_range(64, gv2, gv2),
+    }
+    ;; mock dynamic memory: dynamic range, plus 2GiB guard
+    mt1 = dynamic_memory gv2 + 0x8000_0000
+
+block0(v0 ! mem(mt0, 0, 0): i64, v1 ! dynamic_range(32, v1, v1): i32):
+    v2 ! dynamic_range(64, v1, v1)            = uextend.i64 v1       ;; extended Wasm offset
+    v3 ! dynamic_mem(mt1, 0, 0)               = global_value.i64 gv1 ;; base
+    v4 ! dynamic_range(64, gv2, gv2)          = global_value.i64 gv2 ;; size
+    v5 ! compare(uge, v1, gv2)                = icmp.i64 uge v2, v4  ;; bounds-check compare of extended Wasm offset to size
+    v6 ! dynamic_mem(mt1, v1, v1)             = iadd.i64 v3, v2      ;; compute access address: memory base plus extended Wasm offset
+    v7 ! dynamic_mem(mt1, 0, 0, nullable)     = iconst.i64 0         ;; null pointer for speculative path
+    v8 ! dynamic_mem(mt1, 0, gv2-1, nullable) = select_spectre_guard v5, v7, v6  ;; if OOB, pick null, otherwise the real address
+    v9                                        = load.i64 checked v8
+    return v9
+}
+
+;; select sees:
+;;  v5 ! compare(uge, v1, gv2)
+;;  v6 ! dynamic_mem(mt1, v1, v1)
+;;  v7 ! dynamic_mem(mt0, 0, 0, nullable)
+;;
+;; preprocess:
+;; v6' (assuming compare is false) = dynamic_mem(mt1, 0, gv2-1)
+;; v7' (assuming compare is true)  = dynamic_mem(mt1, 0, 0, nullable)
+;;
+;; take the union of range and nullability:
+;; dynamic_mem(mt1, 0, gv2-1, nullable)
diff --git a/cranelift/filetests/filetests/pcc/succeed/extend.clif b/cranelift/filetests/filetests/pcc/succeed/extend.clif
new file mode 100644
index 000000000000..2926aa65bd7d
--- /dev/null
+++ b/cranelift/filetests/filetests/pcc/succeed/extend.clif
@@ -0,0 +1,17 @@
+test compile
+set enable_pcc=true
+target aarch64
+target x86_64
+
+function %f0(i32) -> i64 {
+block0(v0 ! range(32, 42, 0xffff_fffe): i32):
+  ;; we're allowed to broaden the range on either end:
+  v1 ! range(64, 1, 0xffff_ffff) = uextend.i64 v0
+  return v1
+}
+
+function %f1(i32) -> i64 {
+block0(v0 ! range(16, 0, 0xffff): i32):
+  v1 ! range(64, 0, 0xffff_ffff) = uextend.i64 v0
+  return v1
+}
diff --git a/cranelift/filetests/filetests/pcc/succeed/fuzz-float-loads.clif b/cranelift/filetests/filetests/pcc/succeed/fuzz-float-loads.clif
new file mode 100644
index 000000000000..a69bf96bca21
--- /dev/null
+++ b/cranelift/filetests/filetests/pcc/succeed/fuzz-float-loads.clif
@@ -0,0 +1,85 @@
+test compile
+set enable_pcc=true
+set opt_level=speed
+target x86_64
+
+function u0:0(i64 vmctx, i64) fast {
+    gv0 = vmctx
+    gv1 = load.i64 notrap aligned readonly gv0+8
+    gv2 = load.i64 notrap aligned gv1
+    gv3 ! mem(mt0, 0x0, 0x0) = vmctx
+    gv4 ! mem(mt1, 0x0, 0x0) = load.i64 notrap aligned readonly checked gv3+80
+    mt0 = struct 88 { 80: i64 readonly ! mem(mt1, 0x0, 0x0) }
+    mt1 = memory 0x180000000
+    sig0 = (i64 vmctx) system_v
+    sig1 = (i64 vmctx, i32 uext) system_v
+    sig2 = (i64 vmctx, i32 uext, i32 uext, i32 uext) -> i32 uext system_v
+    const0 = 0x02030077ff00ff04030077ff6cff5503
+    stack_limit = gv2
+
+block0(v0: i64, v1: i64):
+    v2 = iconst.i32 0
+    v25 -> v2
+    v45 -> v2
+    v24 -> v25
+    v3 = iconst.i64 0
+    v4 = global_value.i64 gv3
+    v5 = load.i64 notrap aligned v4+8
+    v17 -> v5
+    v44 -> v5
+    v42 -> v17
+    v6 = load.i64 notrap aligned v5+8
+    v7 = iadd_imm v6, 1
+    v8 = iconst.i64 0
+    v9 = icmp sge v7, v8  ; v8 = 0
+    brif v9, block2, block3(v7)
+
+block2:
+    store.i64 notrap aligned v7, v5+8
+    v10 = global_value.i64 gv3
+    v11 = load.i64 notrap aligned readonly v10+56
+    v12 = load.i64 notrap aligned readonly v11+120
+    call_indirect sig0, v12(v10)
+    v13 = load.i64 notrap aligned v5+8
+    jump block3(v13)
+
+block3(v43: i64):
+    v15 -> v43
+    jump block4
+
+block4:
+    v14 = iconst.i64 0
+    v16 = icmp.i64 sge v15, v14  ; v14 = 0
+    brif v16, block6, block7(v15)
+
+block6:
+    store.i64 notrap aligned v15, v17+8
+    v18 = global_value.i64 gv3
+    v19 = load.i64 notrap aligned readonly v18+56
+    v20 = load.i64 notrap aligned readonly v19+120
+    call_indirect sig0, v20(v18)
+    v21 = load.i64 notrap aligned v17+8
+    jump block7(v21)
+
+block7(v40: i64):
+    v22 = vconst.i8x16 const0
+    v23 = uwiden_high v22  ; v22 = const0
+    v26 = bitcast.i8x16 little v23
+    v27 = sshr v26, v25  ; v25 = 0
+    v28 = bitcast.i64x2 little v27
+    v29 = extractlane v28, 1
+    v30 = iconst.i32 1
+    v31 = global_value.i64 gv3
+    v32 = load.i64 notrap aligned readonly v31+56
+    v33 = load.i64 notrap aligned readonly v32+24
+    call_indirect sig1, v33(v31, v30)  ; v30 = 1
+    v34 = ireduce.i32 v29
+    v35 ! range(64, 0x0, 0xffffffff) = uextend.i64 v34
+    v36 ! mem(mt1, 0x0, 0x0) = global_value.i64 gv4
+    v37 ! mem(mt1, 0x0, 0xffffffff) = iadd v36, v35
+    v38 = load.f64 little checked heap v37
+    v39 = f64const 0x0.0000000005b28p-1022
+    v41 = iadd_imm v40, 9
+    store notrap aligned v41, v17+8
+    trap unreachable
+}
diff --git a/cranelift/filetests/filetests/pcc/succeed/gv_fact.clif b/cranelift/filetests/filetests/pcc/succeed/gv_fact.clif
new file mode 100644
index 000000000000..329b8d444edc
--- /dev/null
+++ b/cranelift/filetests/filetests/pcc/succeed/gv_fact.clif
@@ -0,0 +1,58 @@
+test compile
+set enable_pcc=true
+target aarch64
+target x86_64
+
+function %f0(i64 vmctx) -> i64 {
+    mt0 = struct 16 { 8: i64 ! mem(mt1, 0, 0) }
+    mt1 = memory 0x1_0000_0000
+    gv0 ! mem(mt0, 0, 0) = vmctx
+    gv1 ! mem(mt1, 0, 0) = load.i64 notrap aligned checked gv0+8
+    
+block0(v0 ! mem(mt0, 0, 0): i64):
+    v1 ! mem(mt1, 0, 0) = global_value.i64 gv1
+    return v1
+}
+
+function %f1(i64 vmctx) -> i64 {
+    mt0 = struct 16 { 8: i64 ! mem(mt1, 0, 0) }
+    mt1 = struct 8 { 0: i64 ! mem(mt2, 0, 0) }
+    mt2 = memory 0x1_0000_0000
+    gv0 ! mem(mt0, 0, 0) = vmctx
+    gv1 ! mem(mt1, 0, 0) = load.i64 notrap aligned checked gv0+8
+    gv2 ! mem(mt2, 0, 0) = load.i64 notrap aligned checked gv1+0
+    
+block0(v0 ! mem(mt0, 0, 0): i64):
+    v1 ! mem(mt2, 0, 0) = global_value.i64 gv2
+    return v1
+}
+
+function %f2(i64 vmctx) -> i64 {
+    mt0 = struct 16 { 8: i64 ! mem(mt1, 0, 0) }
+    mt1 = struct 8 { 0: i64 ! mem(mt2, 0, 0) }
+    mt2 = memory 0x1_0000_0000
+    gv0 ! mem(mt0, 0, 0) = vmctx
+    gv1 ! mem(mt1, 0, 0) = load.i64 notrap aligned checked gv0+8
+    gv2 ! mem(mt2, 0, 0) = load.i64 notrap aligned checked gv1+0
+    gv3 ! mem(mt2, 8, 8) = iadd_imm.i64 gv2, 8
+    
+block0(v0 ! mem(mt0, 0, 0): i64):
+    v1 ! mem(mt2, 8, 8) = global_value.i64 gv3
+    return v1
+}
+
+function %f3(i64 vmctx) -> i64 {
+    mt0 = struct 16 { 8: i64 ! mem(mt1, 0, 0) }
+    mt1 = struct 8 { 0: i64 ! mem(mt2, 0, 0) }
+    mt2 = memory 0x1_0000_0000
+    gv0 ! mem(mt0, 0, 0) = vmctx
+    gv1 ! mem(mt1, 0, 0) = load.i64 notrap aligned checked gv0+8
+    gv2 ! mem(mt2, 0, 0) = load.i64 notrap aligned checked gv1+0
+    gv3 ! mem(mt2, 8, 8) = iadd_imm.i64 gv2, 8
+
+    ;; like the above, but with no fact provided on `v0`; it should
+    ;; get copied from the GV.
+block0(v0: i64):
+    v1 ! mem(mt2, 8, 8) = global_value.i64 gv3
+    return v1
+}
diff --git a/cranelift/filetests/filetests/pcc/succeed/imul-fuzzbug.clif b/cranelift/filetests/filetests/pcc/succeed/imul-fuzzbug.clif
new file mode 100644
index 000000000000..8ce3274020de
--- /dev/null
+++ b/cranelift/filetests/filetests/pcc/succeed/imul-fuzzbug.clif
@@ -0,0 +1,282 @@
+test compile
+set enable_pcc=true
+set opt_level=speed
+target x86_64
+
+function u0:3(i64 vmctx, i64) fast {
+        gv0 = vmctx
+        gv1 = load.i64 notrap aligned readonly gv0+8
+        gv2 = load.i64 notrap aligned gv1
+        gv3 ! mem(mt0, 0x0, 0x0) = vmctx
+        mt0 = struct 0 { }
+        sig0 = (i64 vmctx, i32 uext) system_v
+        sig1 = (i64 vmctx, i32 uext, i32 uext) -> i32 uext system_v
+        sig2 = (i64 vmctx, i32 uext) -> i32 uext system_v
+        stack_limit = gv2
+    
+block0(v0 ! mem(mt0, 0x0, 0x0): i64, v1: i64):
+    v13 -> v0
+    v17 -> v0
+    v21 -> v0
+    v22 -> v0
+    v43 -> v0
+    v51 -> v0
+    v155 -> v0
+    v160 -> v0
+    v163 -> v0
+    v164 -> v0
+    v167 -> v0
+    v168 -> v0
+    v171 -> v0
+    v173 -> v0
+    v176 -> v0
+    v177 -> v0
+    v180 -> v0
+    v182 -> v0
+    v185 -> v0
+    v2 = f64const 0.0
+    v3 = iconst.i64 0
+    v4 = iconst.i64 0
+    v5 = iconst.i64 0
+    v6 = iconst.i64 0
+    v7 = iconst.i64 0
+    v8 = iconst.i64 0
+    v9 = iconst.i64 0
+    v10 = iconst.i64 0
+    v11 = iconst.i64 0
+    v12 = iconst.i64 0
+    v14 = load.i32 notrap aligned table v13+192
+    v186 = iconst.i32 0
+    v15 = icmp eq v14, v186  ; v186 = 0
+    v16 = uextend.i32 v15
+    brif v16, block2, block3
+
+block2:
+    trap unreachable
+
+block3:
+    v18 = load.i32 notrap aligned table v17+192
+    v19 = iconst.i32 1
+    v20 = isub v18, v19  ; v19 = 1
+    store notrap aligned table v20, v21+192
+    v23 = load.i32 notrap aligned table v22+128
+    v24 = f64const -0x1.3090455030609p194
+    v25 = fneg v24  ; v24 = -0x1.3090455030609p194
+    v26 = fneg v25
+    v27 = fneg v26
+    v28 = fneg v27
+    v29 = fneg v28
+    v30 = fneg v29
+    v31 = fneg v30
+    v32 = fneg v31
+    v33 = fneg v32
+    v34 = fneg v33
+    v35 = fneg v34
+    v36 = fneg v35
+    v37 = floor v36
+    v38 = f64const +NaN
+    v39 = fcmp eq v37, v37
+    v40 = uextend.i32 v39
+    v41 = select v40, v37, v38  ; v38 = +NaN
+    v42 = iconst.i32 0x1309_0455
+    v44 = load.i32 notrap aligned table v43+128
+    v45 = rotl v42, v44  ; v42 = 0x1309_0455
+    v46 = fcvt_from_sint.f32 v45
+    v47 = iconst.i64 0x2001_8113_0904_5503
+    v48 = iconst.i64 0x2001_8113_0904_5503
+    v187 = iconst.i64 0
+    v49 = icmp eq v48, v187  ; v48 = 0x2001_8113_0904_5503, v187 = 0
+    v50 = uextend.i32 v49
+    store notrap aligned table v50, v51+128
+    v52 = iconst.i32 0x2001_8113
+    v53 = iconst.i32 0x0904_5503
+    v54 = rotl v52, v53  ; v52 = 0x2001_8113, v53 = 0x0904_5503
+    v55 = fcvt_from_sint.f32 v54
+    v56 = iconst.i64 -1
+    v70 -> v56
+    v71 -> v56
+    v57 = iconst.i32 0xffff_ffff
+    v58 = uextend.i64 v57  ; v57 = 0xffff_ffff
+    v59 = iconst.i64 1
+    v188 = iconst.i64 0
+    v60 = icmp eq v58, v188  ; v188 = 0
+    v61 = uextend.i32 v60
+    v62 = select v61, v59, v58  ; v59 = 1
+    v73 -> v62
+    v63 = iconst.i64 0x8000_0000_0000_0000
+    v64 = icmp ne v56, v63  ; v56 = -1, v63 = 0x8000_0000_0000_0000
+    v65 = uextend.i32 v64
+    brif v65, block5, block6
+
+block6:
+    v66 = iconst.i64 -1
+    v67 = icmp.i64 ne v62, v66  ; v66 = -1
+    v68 = uextend.i32 v67
+    brif v68, block5, block7
+
+block7:
+    v69 = iconst.i64 1
+    jump block4(v69)  ; v69 = 1
+
+block5:
+    jump block4(v62)
+
+block4(v72: i64):
+    v74 = srem.i64 v56, v72  ; v56 = -1
+    v88 -> v74
+    v89 -> v74
+    v75 = iconst.i32 0xffff_ffff
+    v76 = uextend.i64 v75  ; v75 = 0xffff_ffff
+    v77 = iconst.i64 1
+    v189 = iconst.i64 0
+    v78 = icmp eq v76, v189  ; v189 = 0
+    v79 = uextend.i32 v78
+    v80 = select v79, v77, v76  ; v77 = 1
+    v91 -> v80
+    v81 = iconst.i64 0x8000_0000_0000_0000
+    v82 = icmp ne v74, v81  ; v81 = 0x8000_0000_0000_0000
+    v83 = uextend.i32 v82
+    brif v83, block9, block10
+
+block10:
+    v84 = iconst.i64 -1
+    v85 = icmp.i64 ne v80, v84  ; v84 = -1
+    v86 = uextend.i32 v85
+    brif v86, block9, block11
+
+block11:
+    v87 = iconst.i64 1
+    jump block8(v87)  ; v87 = 1
+
+block9:
+    jump block8(v80)
+
+block8(v90: i64):
+    v92 = srem.i64 v74, v90
+    v106 -> v92
+    v107 -> v92
+    v93 = iconst.i32 0xffff_ffff
+    v94 = uextend.i64 v93  ; v93 = 0xffff_ffff
+    v95 = iconst.i64 1
+    v190 = iconst.i64 0
+    v96 = icmp eq v94, v190  ; v190 = 0
+    v97 = uextend.i32 v96
+    v98 = select v97, v95, v94  ; v95 = 1
+    v109 -> v98
+    v99 = iconst.i64 0x8000_0000_0000_0000
+    v100 = icmp ne v92, v99  ; v99 = 0x8000_0000_0000_0000
+    v101 = uextend.i32 v100
+    brif v101, block13, block14
+
+block14:
+    v102 = iconst.i64 -1
+    v103 = icmp.i64 ne v98, v102  ; v102 = -1
+    v104 = uextend.i32 v103
+    brif v104, block13, block15
+
+block15:
+    v105 = iconst.i64 1
+    jump block12(v105)  ; v105 = 1
+
+block13:
+    jump block12(v98)
+
+block12(v108: i64):
+    v110 = srem.i64 v92, v108
+    v124 -> v110
+    v125 -> v110
+    v111 = iconst.i32 0xffff_ffff
+    v112 = uextend.i64 v111  ; v111 = 0xffff_ffff
+    v113 = iconst.i64 1
+    v191 = iconst.i64 0
+    v114 = icmp eq v112, v191  ; v191 = 0
+    v115 = uextend.i32 v114
+    v116 = select v115, v113, v112  ; v113 = 1
+    v127 -> v116
+    v117 = iconst.i64 0x8000_0000_0000_0000
+    v118 = icmp ne v110, v117  ; v117 = 0x8000_0000_0000_0000
+    v119 = uextend.i32 v118
+    brif v119, block17, block18
+
+block18:
+    v120 = iconst.i64 -1
+    v121 = icmp.i64 ne v116, v120  ; v120 = -1
+    v122 = uextend.i32 v121
+    brif v122, block17, block19
+
+block19:
+    v123 = iconst.i64 1
+    jump block16(v123)  ; v123 = 1
+
+block17:
+    jump block16(v116)
+
+block16(v126: i64):
+    v128 = srem.i64 v110, v126
+    v145 -> v128
+    v146 -> v128
+    v129 = iconst.i32 0x0944_0909
+    v130 = popcnt v129  ; v129 = 0x0944_0909
+    v131 = iconst.i32 0x3482_3582
+    v132 = imul v130, v131  ; v131 = 0x3482_3582
+    v133 = uextend.i64 v132
+    v134 = iconst.i64 1
+    v192 = iconst.i64 0
+    v135 = icmp eq v133, v192  ; v192 = 0
+    v136 = uextend.i32 v135
+    v137 = select v136, v134, v133  ; v134 = 1
+    v148 -> v137
+    v138 = iconst.i64 0x8000_0000_0000_0000
+    v139 = icmp ne v128, v138  ; v138 = 0x8000_0000_0000_0000
+    v140 = uextend.i32 v139
+    brif v140, block21, block22
+
+block22:
+    v141 = iconst.i64 -1
+    v142 = icmp.i64 ne v137, v141  ; v141 = -1
+    v143 = uextend.i32 v142
+    brif v143, block21, block23
+
+block23:
+    v144 = iconst.i64 1
+    jump block20(v144)  ; v144 = 1
+
+block21:
+    jump block20(v137)
+
+block20(v147: i64):
+    v149 = srem.i64 v128, v147
+    v150 = iconst.i32 0xb7b7_746e
+    v151 = fcvt_from_uint.f32 v150  ; v150 = 0xb7b7_746e
+    v152 = fcvt_to_sint_sat.i64 v151
+    v153 = icmp eq v149, v152
+    v154 = uextend.i32 v153
+    v156 = load.i32 notrap aligned table v155+128
+    v157 = ctz v156
+    v158 = f32const 0x1.bc0402p-124
+    v159 = bitcast.i32 v158  ; v158 = 0x1.bc0402p-124
+    v161 = load.i32 notrap aligned table v160+144
+    v162 = bxor v159, v161
+    store notrap aligned table v162, v163+144
+    v165 = load.i32 notrap aligned table v164+160
+    v166 = bxor v157, v165
+    store notrap aligned table v166, v167+160
+    v169 = load.i32 notrap aligned table v168+160
+    v170 = bxor v154, v169
+    store notrap aligned table v170, v171+160
+    v172 = bitcast.i32 v55
+    v174 = load.i32 notrap aligned table v173+144
+    v175 = bxor v172, v174
+    store notrap aligned table v175, v176+144
+    v178 = load.i64 notrap aligned table v177+176
+    v179 = bxor.i64 v47, v178  ; v47 = 0x2001_8113_0904_5503
+    store notrap aligned table v179, v180+176
+    v181 = bitcast.i32 v46
+    v183 = load.i32 notrap aligned table v182+144
+    v184 = bxor v181, v183
+    store notrap aligned table v184, v185+144
+    jump block1
+
+block1:
+    return
+}
diff --git a/cranelift/filetests/filetests/pcc/succeed/load.clif b/cranelift/filetests/filetests/pcc/succeed/load.clif
new file mode 100644
index 000000000000..59996ef05fae
--- /dev/null
+++ b/cranelift/filetests/filetests/pcc/succeed/load.clif
@@ -0,0 +1,85 @@
+test compile
+set enable_pcc=true
+target aarch64
+target x86_64
+
+function %f0(i64, i32) -> i64 {
+    mt0 = memory 0x1_0000_0000
+block0(v0 ! mem(mt0, 0, 0): i64, v1 ! range(32, 0, 0x100): i32):
+    v2 ! range(64, 0, 0x100) = uextend.i64 v1
+    v3 ! mem(mt0, 0, 8) = iadd.i64 v0, v2
+    v4 = load.i64 checked v3
+    return v4
+}
+
+function %f1(i64, i32) -> i64 {
+    ;; Note the guard region of 8 bytes -- just enough for the below!
+    mt0 = memory 0x1_0000_0008
+block0(v0 ! mem(mt0, 0, 0): i64, v1 ! range(32, 0, 0xffff_ffff): i32):
+    v2 ! range(64, 0, 0xffff_ffff) = uextend.i64 v1
+    v3 ! mem(mt0, 0, 0xffff_ffff) = iadd.i64 v0, v2
+    v4 = load.i64 checked v3
+    return v4
+}
+
+;; RegRegExtend mode on aarch64.
+function %f2(i64, i32) -> i8 {
+    mt0 = memory 0x1000
+block0(v0 ! mem(mt0, 0, 0): i64, v1 ! range(32, 0, 0xfff): i32):
+    v2 ! range(64, 0, 0xfff) = uextend.i64 v1
+    v3 ! mem(mt0, 0, 0xfff) = iadd.i64 v0, v2
+    v4 = load.i8 checked v3
+    return v4
+}
+
+;; RegReg mode on aarch64.
+function %f3(i64, i64) -> i8 {
+    mt0 = memory 0x1000
+block0(v0 ! mem(mt0, 0, 0): i64, v1 ! range(64, 0, 0xfff): i64):
+    v2 ! mem(mt0, 0, 0xfff) = iadd.i64 v0, v1
+    v3 = load.i8 checked v2
+    return v3
+}
+
+;; RegScaledExtended mode on aarch64.
+function %f4(i64, i32) -> i64 {
+    mt0 = memory 0x8000
+block0(v0 ! mem(mt0, 0, 0): i64, v1 ! range(32, 0, 0xfff): i32):
+    v2 ! range(64, 0, 0xfff) = uextend.i64 v1
+    v3 = iconst.i32 3
+    v4 ! range(64, 0, 0x7ff8) = ishl.i64 v2, v3
+    v5 ! mem(mt0, 0, 0x7ff8) = iadd.i64 v0, v4
+    v6 = load.i64 checked v5
+    return v6
+}
+
+;; RegScaled mode on aarch64.
+function %f5(i64, i64) -> i64 {
+    mt0 = memory 0x8000
+block0(v0 ! mem(mt0, 0, 0): i64, v1 ! range(64, 0, 0xfff): i64):
+    v2 = iconst.i32 3
+    v3 ! range(64, 0, 0x7ff8) = ishl.i64 v1, v2
+    v4 ! mem(mt0, 0, 0x7ff8) = iadd.i64 v0, v3
+    v5 = load.i64 checked v4
+    return v5
+}
+
+;; UnsignedOffset mode on aarch64.
+function %f6(i64) -> i64 {
+    mt0 = memory 0x8000
+block0(v0 ! mem(mt0, 0, 0): i64):
+    v2 = iconst.i64 8
+    v3 ! mem(mt0, 8, 8) = iadd.i64 v0, v2
+    v4 = load.i64 checked v3
+    return v4
+}
+
+;; Unscaled mode on aarch64.
+function %f6(i64) -> i64 {
+    mt0 = memory 0x8000
+block0(v0 ! mem(mt0, 8, 8): i64):
+    v2 = iconst.i64 8
+    v3 ! mem(mt0, 0, 0) = isub.i64 v0, v2
+    v4 = load.i64 checked v3
+    return v4
+}
diff --git a/cranelift/filetests/filetests/pcc/succeed/memtypes.clif b/cranelift/filetests/filetests/pcc/succeed/memtypes.clif
new file mode 100644
index 000000000000..dc4805c90cc5
--- /dev/null
+++ b/cranelift/filetests/filetests/pcc/succeed/memtypes.clif
@@ -0,0 +1,24 @@
+test compile
+set enable_pcc=true
+target aarch64
+target x86_64
+
+function %f0(i64) -> i32 {
+    mt0 = struct 8 { 0: i32, 4: i32 readonly }
+
+block0(v0 ! mem(mt0, 0, 0): i64):  ;; v0 points to an instance of mt0, at offset 0
+    v1 = load.i32 v0+0
+    v2 = load.i32 v0+4
+    v3 = iadd.i32 v1, v2
+    return v3
+}
+
+function %f1(i64) -> i32 {
+    mt0 = struct 8 { 0: i64 readonly ! mem(mt1, 0, 0) }
+    mt1 = memory 0x1_0000_0000
+
+block0(v0 ! mem(mt0, 0, 0): i64):
+    v1 ! mem(mt1, 0, 0) = load.i64 v0
+    v2 = load.i32 v1+0x1000
+    return v2
+}
diff --git a/cranelift/filetests/filetests/pcc/succeed/opt.clif b/cranelift/filetests/filetests/pcc/succeed/opt.clif
new file mode 100644
index 000000000000..8fda923223c4
--- /dev/null
+++ b/cranelift/filetests/filetests/pcc/succeed/opt.clif
@@ -0,0 +1,85 @@
+test compile
+set enable_pcc=true
+set opt_level=speed
+target aarch64
+target x86_64
+
+;; Equivalent to a Wasm `i64.load` from a static memory, but with some
+;; redundant stuff that should be optimized away (x+0 -> x).
+function %f0(i64, i32) -> i64 {
+    ;; mock vmctx struct:
+    mt0 = struct 8 { 0: i64 readonly ! mem(mt1, 0, 0) }
+    ;; mock static memory: 4GiB range, plus 2GiB guard
+    mt1 = memory 0x1_8000_0000
+
+block0(v0 ! mem(mt0, 0, 0): i64, v1: i32):
+    v2 ! mem(mt1, 0, 0) = load.i64 checked v0+0
+    v3 ! range(64, 0, 0xffff_ffff) = uextend.i64 v1
+    v4 = iconst.i64 0
+    v5 = iadd.i64 v3, v4
+    v6 ! mem(mt1, 0, 0xffff_ffff) = iadd.i64 v2, v5
+    v7 = load.i64 checked v6
+    return v7
+}
+
+;; GVN opportunity.
+function %f1(i64, i32) -> i64 {
+    ;; mock vmctx struct:
+    mt0 = struct 8 { 0: i64 readonly ! mem(mt1, 0, 0) }
+    ;; mock static memory: 4GiB range, plus 2GiB guard
+    mt1 = memory 0x1_8000_0000
+
+block0(v0 ! mem(mt0, 0, 0): i64, v1: i32):
+    v2 ! mem(mt1, 0, 0) = load.i64 checked notrap readonly v0+0
+    v3 ! range(64, 0, 0xffff_ffff) = uextend.i64 v1
+    v4 = iconst.i64 0
+    v5 = iadd.i64 v3, v4
+    v6 ! mem(mt1, 0, 0xffff_ffff) = iadd.i64 v2, v5
+    v7 = load.i64 checked v6
+
+    v8 = load.i64 checked notrap readonly v0+0
+    v9 = uextend.i64 v1
+    v10 ! mem(mt1, 0, 0xffff_ffff) = iadd.i64 v8, v9
+    v11 = load.i64 checked v10
+
+    v12 = iadd.i64 v7, v11
+
+    return v12
+}
+
+;; RLE opportunity.
+function %f2(i64, i32) -> i64 {
+    ;; mock vmctx struct:
+    mt0 = struct 8 { 0: i64 readonly ! mem(mt1, 0, 0) }
+    ;; mock static memory: 4GiB range, plus 2GiB guard
+    mt1 = memory 0x1_8000_0000
+
+block0(v0 ! mem(mt0, 0, 0): i64, v1: i32):
+    v2 ! mem(mt1, 0, 0) = load.i64 checked notrap readonly aligned v0+0
+    brif v1, block1, block2
+
+block1:
+    v3 ! mem(mt1, 0, 0) = load.i64 checked notrap readonly aligned v0+0
+    return v3
+
+block2:
+    v4 ! mem(mt1, 0, 0) = load.i64 checked notrap readonly aligned v0+0
+    return v4
+}
+
+function %f3(i64, i32) {
+    mt0 = struct 4 { 0: i32 ! range(32, 1, 3) }
+
+block0(v0 ! mem(mt0, 0, 0): i64, v1 ! range(32, 0, 1): i32):
+    v2 ! range(32, 1, 1) = iconst.i32 1
+    v3 ! range(32, 1, 2) = iadd.i32 v1, v2
+
+    v4 ! range(32, 1, 1) = iconst.i32 1
+    v5 ! range(32, 1, 3) = iadd.i32 v1, v4  ;; should GVN onto v3.
+
+    ;; v3/v5's facts should merge to the narrower range.
+    store.i32 checked v3, v0
+    store.i32 checked v5, v0
+
+    return
+}
diff --git a/cranelift/filetests/filetests/pcc/succeed/shift.clif b/cranelift/filetests/filetests/pcc/succeed/shift.clif
new file mode 100644
index 000000000000..0fcf627464ef
--- /dev/null
+++ b/cranelift/filetests/filetests/pcc/succeed/shift.clif
@@ -0,0 +1,18 @@
+test compile
+set enable_pcc=true
+target aarch64
+target x86_64
+
+function %f0(i32) -> i32 {
+block0(v0 ! range(32, 1, 0x100): i32):
+  v1 = iconst.i32 2
+  v2 ! range(32, 4, 0x400) = ishl.i32 v0, v1
+  return v2
+}
+
+function %f0(i32) -> i32 {
+block0(v0: i32):
+  v1 = iconst.i32 2
+  v2 ! range(32, 0, 0xffff_ffff) = ishl.i32 v0, v1
+  return v2
+}
diff --git a/cranelift/filetests/filetests/pcc/succeed/simple.clif b/cranelift/filetests/filetests/pcc/succeed/simple.clif
new file mode 100644
index 000000000000..80dc769899ef
--- /dev/null
+++ b/cranelift/filetests/filetests/pcc/succeed/simple.clif
@@ -0,0 +1,13 @@
+test compile
+set enable_pcc=true
+target aarch64
+target x86_64
+
+function %simple1(i64 vmctx, i32) -> i8 {
+    mt0 = memory 0x1_0000_0000
+block0(v0 ! mem(mt0, 0, 0): i64, v1 ! range(32, 0, 0xffff_ffff): i32):
+    v2 ! range(64, 0, 0xffff_ffff) = uextend.i64 v1
+    v3 ! mem(mt0, 0, 0xffff_ffff) = iadd.i64 v0, v2
+    v4 = load.i8 checked v3
+    return v4
+}
diff --git a/cranelift/filetests/filetests/pcc/succeed/struct.clif b/cranelift/filetests/filetests/pcc/succeed/struct.clif
new file mode 100644
index 000000000000..f53bdaff54d4
--- /dev/null
+++ b/cranelift/filetests/filetests/pcc/succeed/struct.clif
@@ -0,0 +1,20 @@
+test compile
+set enable_pcc=true
+target aarch64
+target x86_64
+
+function %f0(i64) -> i64 {
+    mt0 = struct 8 { 0: i64 ! mem(mt1, 0, 0) }
+    mt1 = memory 0x1_0000_0000
+block0(v0 ! mem(mt0, 0, 0): i64):
+    v1 ! mem(mt1, 0, 0) = load.i64 checked v0
+    return v1
+}
+
+function %f1(i64, i64) {
+    mt0 = struct 8 { 0: i64 ! mem(mt1, 0, 0) }
+    mt1 = memory 0x1_0000_0000
+block0(v0 ! mem(mt0, 0, 0): i64, v1 ! mem(mt1, 0, 0): i64):
+    store.i64 checked v1, v0
+    return
+}
diff --git a/cranelift/filetests/filetests/pcc/succeed/uextend-add-iconst.clif b/cranelift/filetests/filetests/pcc/succeed/uextend-add-iconst.clif
new file mode 100644
index 000000000000..9448298c81d0
--- /dev/null
+++ b/cranelift/filetests/filetests/pcc/succeed/uextend-add-iconst.clif
@@ -0,0 +1,119 @@
+test compile
+set enable_pcc=true
+set opt_level=speed
+target x86_64
+
+;; v110 is a uextend'd iconst; v111 is a memtype base; v112 is that
+;; base plus that fixed offset, and should be able to verify that its
+;; offset is in 0..4GiB. In the fuzzbug that inspired this test, we
+;; had a bare `iconst` with no range fact on it after optimization.
+
+function u0:2(i64 vmctx, i64, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32) -> i32, i32, i32, i32, i32, i32 fast {
+    gv0 = vmctx
+    gv1 = load.i64 notrap aligned readonly gv0+8
+    gv2 = load.i64 notrap aligned gv1
+    gv3 ! mem(mt0, 0x0, 0x0) = vmctx
+    gv4 ! mem(mt1, 0x0, 0x0) = load.i64 notrap aligned readonly checked gv3+96
+    mt0 = struct 104 { 96: i64 readonly ! mem(mt1, 0x0, 0x0) }
+    mt1 = memory 0x180000000
+    sig0 = (i64 vmctx, i32 uext) system_v
+    sig1 = (i64 vmctx, i32 uext, i32 uext, i32 uext) -> i32 uext system_v
+    sig2 = (i64 vmctx, i32 uext, i32 uext) -> i32 uext system_v
+    sig3 = (i64 vmctx, i32 uext) -> i32 uext system_v
+    stack_limit = gv2
+
+block0(v0 ! mem(mt0, 0x0, 0x0): i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32, v6: i32, v7: i32, v8: i32, v9: i32, v10: i32, v11: i32, v12: i32, v13: i32, v14: i32, v15: i32, v16: i32, v17: i32, v18: i32, v19: i32, v20: i32, v21: i32):
+    v77 -> v0
+    v81 -> v0
+    v85 -> v0
+    v87 -> v0
+    v91 -> v0
+    v95 -> v0
+    v97 -> v0
+    v130 -> v0
+    v78 = load.i32 notrap aligned table v77+176
+    v127 = iconst.i32 0
+    v79 = icmp eq v78, v127  ; v127 = 0
+    v80 = uextend.i32 v79
+    brif v80, block2, block3
+
+block2:
+    trap unreachable
+
+block3:
+    v82 = load.i32 notrap aligned table v81+176
+    v83 = iconst.i32 1
+    v84 = isub v82, v83  ; v83 = 1
+    store notrap aligned table v84, v85+176
+    jump block4
+
+block4:
+    v88 = load.i32 notrap aligned table v87+176
+    v128 = iconst.i32 0
+    v89 = icmp eq v88, v128  ; v128 = 0
+    v90 = uextend.i32 v89
+    brif v90, block6, block7
+
+block6:
+    trap unreachable
+
+block7:
+    v92 = load.i32 notrap aligned table v91+176
+    v93 = iconst.i32 1
+    v94 = isub v92, v93  ; v93 = 1
+    store notrap aligned table v94, v95+176
+    v96 = iconst.i32 0xffff_3234
+    v98 = load.i64 notrap aligned v97+104
+    v129 = iconst.i64 0x0001_0000
+    v99 = udiv v98, v129  ; v129 = 0x0001_0000
+    v100 = ireduce.i32 v99
+    v101 = iconst.i32 0x0001_0000
+    v102 = imul v100, v101  ; v101 = 0x0001_0000
+    v103 = iconst.i32 0x0005_ffee
+    v104 = iadd v103, v96  ; v103 = 0x0005_ffee, v96 = 0xffff_3234
+    v105 = icmp ule v102, v104
+    v106 = uextend.i32 v105
+    brif v106, block9, block10
+
+block10:
+    v107 = iconst.i32 0
+    v108 = icmp.i32 sle v96, v107  ; v96 = 0xffff_3234, v107 = 0
+    v109 = uextend.i32 v108
+    brif v109, block9, block11
+
+block11:
+    v110 ! range(64, 0x0, 0xffffffff) = uextend.i64 v96  ; v96 = 0xffff_3234
+    v111 ! mem(mt1, 0x0, 0x0) = load.i64 notrap aligned readonly checked v130+96
+    v112 ! mem(mt1, 0x0, 0xffffffff) = iadd v111, v110
+    v113 ! range(64, 0x5ffe6, 0x5ffe6) = iconst.i64 0x0005_ffe6
+    v114 ! mem(mt1, 0x5ffe6, 0x10005ffe5) = iadd v112, v113  ; v113 = 0x0005_ffe6
+    v115 = uload8.i64 little checked heap v114
+    jump block8(v115)
+
+block9:
+    v116 = iconst.i64 0
+    jump block8(v116)  ; v116 = 0
+
+block8(v117: i64):
+    v118 = fcvt_from_uint.f32 v117
+    v86 -> v118
+    jump block5
+
+block5:
+    v121 = iconst.i32 0
+    v22 -> v121
+    v122 = iconst.i32 0
+    v23 -> v122
+    v123 = iconst.i32 0
+    v24 -> v123
+    v124 = iconst.i32 0
+    v25 -> v124
+    v125 = iconst.i32 0
+    v26 -> v125
+    v126 = iconst.i32 0
+    v27 -> v126
+    jump block1
+
+block1:
+    return v22, v23, v24, v25, v26, v27  ; v22 = 0, v23 = 0, v24 = 0, v25 = 0, v26 = 0, v27 = 0
+}
diff --git a/cranelift/filetests/filetests/pcc/succeed/vmctx.clif b/cranelift/filetests/filetests/pcc/succeed/vmctx.clif
new file mode 100644
index 000000000000..ec05f22fa6c0
--- /dev/null
+++ b/cranelift/filetests/filetests/pcc/succeed/vmctx.clif
@@ -0,0 +1,21 @@
+test compile
+set enable_pcc=true
+target aarch64
+target x86_64
+
+;; Equivalent to a Wasm `i64.load` from a static memory.
+function %f0(i64, i32) -> i64 {
+    ;; mock vmctx struct:
+    mt0 = struct 8 { 0: i64 readonly ! mem(mt1, 0, 0) }
+    ;; mock static memory: 4GiB range, plus 2GiB guard
+    mt1 = memory 0x1_8000_0000
+
+block0(v0 ! mem(mt0, 0, 0): i64, v1: i32):
+    ;; Compute the address: base + offset. Guard region (2GiB) is
+    ;; sufficient for an 8-byte I64 load.
+    v2 ! mem(mt1, 0, 0) = load.i64 checked v0+0    ;; base pointer
+    v3 ! range(64, 0, 0xffff_ffff) = uextend.i64 v1  ;; offset
+    v4 ! mem(mt1, 0, 0xffff_ffff) = iadd.i64 v2, v3
+    v5 = load.i64 checked v4
+    return v5
+}
diff --git a/cranelift/filetests/filetests/runtests/arithmetic-extends.clif b/cranelift/filetests/filetests/runtests/arithmetic-extends.clif
index 4f4a3a040653..4c545947d584 100644
--- a/cranelift/filetests/filetests/runtests/arithmetic-extends.clif
+++ b/cranelift/filetests/filetests/runtests/arithmetic-extends.clif
@@ -113,7 +113,7 @@ block0(v0: i32):
 
 
 ;; These tests ensure that we don't merge the `uextend` and `ishl` instructions
-;; in a way that doesen't respect the `ishl` semantics of cutting off the high bits.
+;; in a way that doesn't respect the `ishl` semantics of cutting off the high bits.
 
 function %add_uext_ishl_1(i64, i32) -> i64 {
 block0(v0: i64, v1: i32):
diff --git a/cranelift/filetests/filetests/runtests/arithmetic.clif b/cranelift/filetests/filetests/runtests/arithmetic.clif
index c26f2a41e449..5b63c91445d1 100644
--- a/cranelift/filetests/filetests/runtests/arithmetic.clif
+++ b/cranelift/filetests/filetests/runtests/arithmetic.clif
@@ -127,6 +127,14 @@ block0(v0: i8,v1: i8):
 ; run: %sub_i8(0xAB, 0x0B) == 0xA0
 ; run: %sub_i8(0xC0, 0xDE) == 0xE2
 
+function %isub_const_lhs(i8, i32) -> i32 {
+block0(v0: i8, v1: i32):
+    v376 = iconst.i32 0xffff_fffd
+    v1161 = isub v376, v1
+    return v1161
+}
+
+; run: %isub_const_lhs(68, 4474) == -4477
 
 function %mul_i64(i64, i64) -> i64 {
 block0(v0: i64,v1: i64):
diff --git a/cranelift/filetests/filetests/runtests/bitcast-ref64.clif b/cranelift/filetests/filetests/runtests/bitcast-ref64.clif
deleted file mode 100644
index 698cea8e145c..000000000000
--- a/cranelift/filetests/filetests/runtests/bitcast-ref64.clif
+++ /dev/null
@@ -1,29 +0,0 @@
-test run
-target aarch64
-target x86_64
-target s390x
-target riscv64gc
-target riscv64 has_c has_zcb
-; the interpreter does not support bitcasting to/from references
-
-function %bitcast_ir64(i64) -> i8 {
-block0(v0: i64):
-  v1 = bitcast.r64 v0
-  v2 = is_null v1
-  return v2
-}
-; run: %bitcast_ir64(0) == 1
-; run: %bitcast_ir64(18446744073709551615) == 0
-; run: %bitcast_ir64(-1) == 0
-; run: %bitcast_ir64(127) == 0
-
-function %bitcast_ri64(i64) -> i64 {
-block0(v0: i64):
-  v1 = bitcast.r64 v0
-  v2 = bitcast.i64 v1
-  return v2
-}
-; run: %bitcast_ri64(0) == 0
-; run: %bitcast_ri64(18446744073709551615) == 18446744073709551615
-; run: %bitcast_ri64(-1) == -1
-; run: %bitcast_ri64(127) == 127
diff --git a/cranelift/filetests/filetests/runtests/bitrev.clif b/cranelift/filetests/filetests/runtests/bitrev.clif
index fff70f7b435e..4bcadd553224 100644
--- a/cranelift/filetests/filetests/runtests/bitrev.clif
+++ b/cranelift/filetests/filetests/runtests/bitrev.clif
@@ -4,6 +4,9 @@ target aarch64
 target s390x
 target x86_64
 target riscv64
+target riscv64 has_zbb
+target riscv64 has_zbkb
+target riscv64 has_zbb has_zbkb
 target riscv64 has_c has_zcb
 
 function %bitrev_i8(i8) -> i8 {
diff --git a/cranelift/filetests/filetests/runtests/call_libcall.clif b/cranelift/filetests/filetests/runtests/call_libcall.clif
index 5956fca9575e..5201b771d1aa 100644
--- a/cranelift/filetests/filetests/runtests/call_libcall.clif
+++ b/cranelift/filetests/filetests/runtests/call_libcall.clif
@@ -1,6 +1,9 @@
+test interpret
 test run
 target x86_64
-; AArch64 Does not have these libcalls
+target aarch64
+target aarch64 sign_return_address
+target aarch64 has_pauth sign_return_address
 target s390x
 target riscv64
 target riscv64 has_c has_zcb
diff --git a/cranelift/filetests/filetests/runtests/ceil.clif b/cranelift/filetests/filetests/runtests/ceil.clif
index 408f35bd1745..9ac7f24a32a9 100644
--- a/cranelift/filetests/filetests/runtests/ceil.clif
+++ b/cranelift/filetests/filetests/runtests/ceil.clif
@@ -7,6 +7,7 @@ target x86_64 sse42 has_avx
 target aarch64
 target s390x
 target riscv64
+target riscv64 has_zfa
 target riscv64 has_c has_zcb
 
 function %ceil_f32(f32) -> f32 {
diff --git a/cranelift/filetests/filetests/runtests/conversion-i8-i16.clif b/cranelift/filetests/filetests/runtests/conversion-i8-i16.clif
new file mode 100644
index 000000000000..dde4635be504
--- /dev/null
+++ b/cranelift/filetests/filetests/runtests/conversion-i8-i16.clif
@@ -0,0 +1,234 @@
+test interpret
+test run
+target aarch64
+target s390x
+target riscv64 has_c has_zcb
+target riscv64
+
+function %f32_to_i8(f32) -> i8 {
+block0(v0: f32):
+    v1 = fcvt_to_sint.i8 v0
+    return v1
+}
+; run: %f32_to_i8(0x0.0) == 0
+; run: %f32_to_i8(0x1.0) == 1
+; run: %f32_to_i8(0x8.1) == 8
+; run: %f32_to_i8(-0x8.1) == -8
+; run: %f32_to_i8(-0x80.1) == 0x80
+; run: %f32_to_i8(0x7f.1) == 0x7f
+; run: %f32_to_i8(-0x0.1) == 0
+
+function %f64_to_i8(f64) -> i8 {
+block0(v0: f64):
+    v1 = fcvt_to_sint.i8 v0
+    return v1
+}
+; run: %f64_to_i8(0x0.0) == 0
+; run: %f64_to_i8(0x1.0) == 1
+; run: %f64_to_i8(0x8.1) == 8
+; run: %f64_to_i8(-0x8.1) == -8
+; run: %f64_to_i8(-0x80.1) == 0x80
+; run: %f64_to_i8(0x7f.1) == 0x7f
+; run: %f64_to_i8(-0x0.1) == 0
+
+function %f32_to_i16(f32) -> i16 {
+block0(v0: f32):
+    v1 = fcvt_to_sint.i16 v0
+    return v1
+}
+; run: %f32_to_i16(0x0.0) == 0
+; run: %f32_to_i16(0x1.0) == 1
+; run: %f32_to_i16(0x8.1) == 8
+; run: %f32_to_i16(-0x8.1) == -8
+; run: %f32_to_i16(-0x8000.1) == 0x8000
+; run: %f32_to_i16(0x7fff.1) == 0x7fff
+; run: %f32_to_i16(-0x0.1) == 0
+
+function %f64_to_i16(f64) -> i16 {
+block0(v0: f64):
+    v1 = fcvt_to_sint.i16 v0
+    return v1
+}
+; run: %f64_to_i16(0x0.0) == 0
+; run: %f64_to_i16(0x1.0) == 1
+; run: %f64_to_i16(0x8.1) == 8
+; run: %f64_to_i16(-0x8.1) == -8
+; run: %f64_to_i16(-0x8000.1) == 0x8000
+; run: %f64_to_i16(0x7fff.1) == 0x7fff
+; run: %f64_to_i16(-0x0.1) == 0
+
+function %f32_to_u8(f32) -> i8 {
+block0(v0:f32):
+    v1 = fcvt_to_uint.i8 v0
+    return v1
+}
+; run: %f32_to_u8(0x0.0) == 0
+; run: %f32_to_u8(0x1.0) == 1
+; run: %f32_to_u8(0x4.2) == 4
+; run: %f32_to_u8(0x4.6) == 4
+; run: %f32_to_u8(-0x0.1) == 0
+
+function %f64_to_u8(f64) -> i8 {
+block0(v0:f64):
+    v1 = fcvt_to_uint.i8 v0
+    return v1
+}
+; run: %f64_to_u8(0x0.0) == 0
+; run: %f64_to_u8(0x1.0) == 1
+; run: %f64_to_u8(0x4.2) == 4
+; run: %f64_to_u8(0x4.6) == 4
+; run: %f64_to_u8(-0x0.1) == 0
+
+function %f32_to_u16(f32) -> i16 {
+block0(v0:f32):
+    v1 = fcvt_to_uint.i16 v0
+    return v1
+}
+; run: %f32_to_u16(0x0.0) == 0
+; run: %f32_to_u16(0x1.0) == 1
+; run: %f32_to_u16(0x4.2) == 4
+; run: %f32_to_u16(0x4.6) == 4
+; run: %f32_to_u16(-0x0.1) == 0
+
+function %f64_to_u16(f64) -> i16 {
+block0(v0:f64):
+    v1 = fcvt_to_uint.i16 v0
+    return v1
+}
+; run: %f64_to_u16(0x0.0) == 0
+; run: %f64_to_u16(0x1.0) == 1
+; run: %f64_to_u16(0x4.2) == 4
+; run: %f64_to_u16(0x4.6) == 4
+; run: %f64_to_u16(-0x0.1) == 0
+
+function %f32_to_i8_sat(f32) -> i8 {
+block0(v0: f32):
+    v1 = fcvt_to_sint_sat.i8 v0
+    return v1
+}
+; run: %f32_to_i8_sat(0x0.0) == 0
+; run: %f32_to_i8_sat(0x1.0) == 1
+; run: %f32_to_i8_sat(0x8.1) == 8
+; run: %f32_to_i8_sat(-0x1.0) == -1
+; run: %f32_to_i8_sat(0x1.fffffep127) == 0x7f
+; run: %f32_to_i8_sat(-0x1.fffffep127) == 0x80
+; run: %f32_to_i8_sat(+NaN) == 0
+; run: %f32_to_i8_sat(-NaN) == 0
+; run: %f32_to_i8_sat(+Inf) == 0x7f
+; run: %f32_to_i8_sat(-Inf) == 0x80
+
+function %f64_to_i8_sat(f64) -> i8 {
+block0(v0: f64):
+    v1 = fcvt_to_sint_sat.i8 v0
+    return v1
+}
+; run: %f64_to_i8_sat(0x0.0) == 0
+; run: %f64_to_i8_sat(0x1.0) == 1
+; run: %f64_to_i8_sat(0x8.1) == 8
+; run: %f64_to_i8_sat(-0x1.0) == -1
+; run: %f64_to_i8_sat(0x1.fffffep127) == 0x7f
+; run: %f64_to_i8_sat(-0x1.fffffep127) == 0x80
+; run: %f64_to_i8_sat(+NaN) == 0
+; run: %f64_to_i8_sat(-NaN) == 0
+; run: %f64_to_i8_sat(+Inf) == 0x7f
+; run: %f64_to_i8_sat(-Inf) == 0x80
+
+function %f32_to_i16_sat(f32) -> i16 {
+block0(v0: f32):
+    v1 = fcvt_to_sint_sat.i16 v0
+    return v1
+}
+; run: %f32_to_i16_sat(0x0.0) == 0
+; run: %f32_to_i16_sat(0x1.0) == 1
+; run: %f32_to_i16_sat(0x8.1) == 8
+; run: %f32_to_i16_sat(-0x1.0) == -1
+; run: %f32_to_i16_sat(0x1.fffffep127) == 0x7fff
+; run: %f32_to_i16_sat(-0x1.fffffep127) == 0x8000
+; run: %f32_to_i16_sat(+NaN) == 0
+; run: %f32_to_i16_sat(-NaN) == 0
+; run: %f32_to_i16_sat(+Inf) == 0x7fff
+; run: %f32_to_i16_sat(-Inf) == 0x8000
+
+function %f64_to_i16_sat(f64) -> i16 {
+block0(v0: f64):
+    v1 = fcvt_to_sint_sat.i16 v0
+    return v1
+}
+; run: %f64_to_i16_sat(0x0.0) == 0
+; run: %f64_to_i16_sat(0x1.0) == 1
+; run: %f64_to_i16_sat(0x8.1) == 8
+; run: %f64_to_i16_sat(-0x1.0) == -1
+; run: %f64_to_i16_sat(0x1.fffffep127) == 0x7fff
+; run: %f64_to_i16_sat(-0x1.fffffep127) == 0x8000
+; run: %f64_to_i16_sat(+NaN) == 0
+; run: %f64_to_i16_sat(-NaN) == 0
+; run: %f64_to_i16_sat(+Inf) == 0x7fff
+; run: %f64_to_i16_sat(-Inf) == 0x8000
+
+function %f32_to_u8_sat(f32) -> i8 {
+block0(v0:f32):
+    v1 = fcvt_to_uint_sat.i8 v0
+    return v1
+}
+; run: %f32_to_u8_sat(0x0.0) == 0
+; run: %f32_to_u8_sat(0x1.0) == 1
+; run: %f32_to_u8_sat(0x4.2) == 4
+; run: %f32_to_u8_sat(0x4.6) == 4
+; run: %f32_to_u8_sat(-0x1.0) == 0
+; run: %f32_to_u8_sat(0x1.fffffep127) == 0xff
+; run: %f32_to_u8_sat(-0x1.fffffep127) == 0
+; run: %f32_to_u8_sat(+NaN) == 0
+; run: %f32_to_u8_sat(-NaN) == 0
+; run: %f32_to_u8_sat(+Inf) == 0xff
+; run: %f32_to_u8_sat(-Inf) == 0
+
+function %f64_to_u8_sat(f64) -> i8 {
+block0(v0:f64):
+    v1 = fcvt_to_uint_sat.i8 v0
+    return v1
+}
+; run: %f64_to_u8_sat(0x0.0) == 0
+; run: %f64_to_u8_sat(0x1.0) == 1
+; run: %f64_to_u8_sat(0x4.2) == 4
+; run: %f64_to_u8_sat(0x4.6) == 4
+; run: %f64_to_u8_sat(-0x1.0) == 0
+; run: %f64_to_u8_sat(0x1.fffffep127) == 0xff
+; run: %f64_to_u8_sat(-0x1.fffffep127) == 0
+; run: %f64_to_u8_sat(+NaN) == 0
+; run: %f64_to_u8_sat(-NaN) == 0
+; run: %f64_to_u8_sat(+Inf) == 0xff
+; run: %f64_to_u8_sat(-Inf) == 0
+
+function %f32_to_u16_sat(f32) -> i16 {
+block0(v0:f32):
+    v1 = fcvt_to_uint_sat.i16 v0
+    return v1
+}
+; run: %f32_to_u16_sat(0x0.0) == 0
+; run: %f32_to_u16_sat(0x1.0) == 1
+; run: %f32_to_u16_sat(0x4.2) == 4
+; run: %f32_to_u16_sat(0x4.6) == 4
+; run: %f32_to_u16_sat(-0x1.0) == 0
+; run: %f32_to_u16_sat(0x1.fffffep127) == 0xffff
+; run: %f32_to_u16_sat(-0x1.fffffep127) == 0
+; run: %f32_to_u16_sat(+NaN) == 0
+; run: %f32_to_u16_sat(-NaN) == 0
+; run: %f32_to_u16_sat(+Inf) == 0xffff
+; run: %f32_to_u16_sat(-Inf) == 0
+
+function %f64_to_u16_sat(f64) -> i16 {
+block0(v0:f64):
+    v1 = fcvt_to_uint_sat.i16 v0
+    return v1
+}
+; run: %f64_to_u16_sat(0x0.0) == 0
+; run: %f64_to_u16_sat(0x1.0) == 1
+; run: %f64_to_u16_sat(0x4.2) == 4
+; run: %f64_to_u16_sat(0x4.6) == 4
+; run: %f64_to_u16_sat(-0x1.0) == 0
+; run: %f64_to_u16_sat(0x1.fffffep127) == 0xffff
+; run: %f64_to_u16_sat(-0x1.fffffep127) == 0
+; run: %f64_to_u16_sat(+NaN) == 0
+; run: %f64_to_u16_sat(-NaN) == 0
+; run: %f64_to_u16_sat(+Inf) == 0xffff
+; run: %f64_to_u16_sat(-Inf) == 0
diff --git a/cranelift/filetests/filetests/runtests/conversion.clif b/cranelift/filetests/filetests/runtests/conversion.clif
index 1040e7e1040f..5b4a554e080f 100644
--- a/cranelift/filetests/filetests/runtests/conversion.clif
+++ b/cranelift/filetests/filetests/runtests/conversion.clif
@@ -7,52 +7,248 @@ target x86_64 has_avx
 target riscv64 has_c has_zcb
 target riscv64
 
-function %fcvt_to_sint(f32) -> i32 {
+function %f32_to_i32(f32) -> i32 {
 block0(v0: f32):
     v1 = fcvt_to_sint.i32 v0
     return v1
 }
-; run: %fcvt_to_sint(0x0.0) == 0
-; run: %fcvt_to_sint(0x1.0) == 1
-; run: %fcvt_to_sint(0x1.d6f346p26) == 123456792
-; run: %fcvt_to_sint(0x8.1) == 8
+; run: %f32_to_i32(0x0.0) == 0
+; run: %f32_to_i32(0x1.0) == 1
+; run: %f32_to_i32(0x1.d6f346p26) == 123456792
+; run: %f32_to_i32(0x8.1) == 8
+; run: %f32_to_i32(-0x8.1) == -8
+; run: %f32_to_i32(-0x0.1) == 0
+; run: %f32_to_i32(-0x1.0p31) == 0x8000_0000
 
-function %fcvt_to_uint(f32) -> i32 {
+function %f64_to_i32(f64) -> i32 {
+block0(v0: f64):
+    v1 = fcvt_to_sint.i32 v0
+    return v1
+}
+; run: %f64_to_i32(0x0.0) == 0
+; run: %f64_to_i32(0x1.0) == 1
+; run: %f64_to_i32(0x1.d6f346p26) == 123456792
+; run: %f64_to_i32(0x8.1) == 8
+; run: %f64_to_i32(-0x8.1) == -8
+; run: %f64_to_i32(-0x0.1) == 0
+; run: %f64_to_i32(-0x1.0p31) == 0x8000_0000
+
+function %f32_to_i64(f32) -> i64 {
+block0(v0: f32):
+    v1 = fcvt_to_sint.i64 v0
+    return v1
+}
+; run: %f32_to_i64(0x0.0) == 0
+; run: %f32_to_i64(0x1.0) == 1
+; run: %f32_to_i64(0x1.d6f346p26) == 123456792
+; run: %f32_to_i64(0x8.1) == 8
+; run: %f32_to_i64(-0x8.1) == -8
+; run: %f32_to_i64(-0x0.1) == 0
+
+function %f64_to_i64(f64) -> i64 {
+block0(v0: f64):
+    v1 = fcvt_to_sint.i64 v0
+    return v1
+}
+; run: %f64_to_i64(0x0.0) == 0
+; run: %f64_to_i64(0x1.0) == 1
+; run: %f64_to_i64(0x1.d6f346p26) == 123456792
+; run: %f64_to_i64(0x8.1) == 8
+; run: %f64_to_i64(-0x8.1) == -8
+; run: %f64_to_i64(-0x0.1) == 0
+
+function %f32_to_u32(f32) -> i32 {
 block0(v0:f32):
     v1 = fcvt_to_uint.i32 v0
     return v1
 }
-; run: %fcvt_to_uint(0x0.0) == 0
-; run: %fcvt_to_uint(0x1.0) == 1
-; run: %fcvt_to_uint(0x4.2) == 4
-; run: %fcvt_to_uint(0x4.6) == 4
-; run: %fcvt_to_uint(0x1.d6f346p26) == 123456792
-; run: %fcvt_to_uint(0xB2D05E00.0) == 3000000000
+; run: %f32_to_u32(0x0.0) == 0
+; run: %f32_to_u32(0x1.0) == 1
+; run: %f32_to_u32(0x4.2) == 4
+; run: %f32_to_u32(0x4.6) == 4
+; run: %f32_to_u32(0x1.d6f346p26) == 123456792
+; run: %f32_to_u32(0xB2D05E00.0) == 3000000000
+; run: %f32_to_u32(-0x0.1) == 0
+
+function %f64_to_u32(f64) -> i32 {
+block0(v0:f64):
+    v1 = fcvt_to_uint.i32 v0
+    return v1
+}
+; run: %f64_to_u32(0x0.0) == 0
+; run: %f64_to_u32(0x1.0) == 1
+; run: %f64_to_u32(0x4.2) == 4
+; run: %f64_to_u32(0x4.6) == 4
+; run: %f64_to_u32(0x1.d6f346p26) == 123456792
+; run: %f64_to_u32(0xB2D05E00.0) == 3000000000
+; run: %f64_to_u32(-0x0.1) == 0
+
+function %f32_to_u64(f32) -> i64 {
+block0(v0:f32):
+    v1 = fcvt_to_uint.i64 v0
+    return v1
+}
+; run: %f32_to_u64(0x0.0) == 0
+; run: %f32_to_u64(0x1.0) == 1
+; run: %f32_to_u64(0x4.2) == 4
+; run: %f32_to_u64(0x4.6) == 4
+; run: %f32_to_u64(0x1.d6f346p26) == 123456792
+; run: %f32_to_u64(0xB2D05E00.0) == 3000000000
+; run: %f32_to_u64(-0x0.1) == 0
+
+function %f64_to_u64(f64) -> i64 {
+block0(v0:f64):
+    v1 = fcvt_to_uint.i64 v0
+    return v1
+}
+; run: %f64_to_u64(0x0.0) == 0
+; run: %f64_to_u64(0x1.0) == 1
+; run: %f64_to_u64(0x4.2) == 4
+; run: %f64_to_u64(0x4.6) == 4
+; run: %f64_to_u64(0x1.d6f346p26) == 123456792
+; run: %f64_to_u64(0xB2D05E00.0) == 3000000000
+; run: %f64_to_u64(-0x0.1) == 0
 
-function %fcvt_to_sint_sat(f32) -> i32 {
+function %f32_to_i32_sat(f32) -> i32 {
 block0(v0: f32):
     v1 = fcvt_to_sint_sat.i32 v0
     return v1
 }
-; run: %fcvt_to_sint_sat(0x0.0) == 0
-; run: %fcvt_to_sint_sat(0x1.0) == 1
-; run: %fcvt_to_sint_sat(0x1.d6f346p26) == 123456792
-; run: %fcvt_to_sint_sat(0x8.1) == 8
-; run: %fcvt_to_sint_sat(-0x1.0) == -1
-; run: %fcvt_to_sint_sat(0x1.fffffep127) == 2147483647
-; run: %fcvt_to_sint_sat(-0x1.fffffep127) == -2147483648
+; run: %f32_to_i32_sat(0x0.0) == 0
+; run: %f32_to_i32_sat(0x1.0) == 1
+; run: %f32_to_i32_sat(0x1.d6f346p26) == 123456792
+; run: %f32_to_i32_sat(0x8.1) == 8
+; run: %f32_to_i32_sat(-0x1.0) == -1
+; run: %f32_to_i32_sat(0x1.fffffep127) == 2147483647
+; run: %f32_to_i32_sat(-0x1.fffffep127) == -2147483648
+; run: %f32_to_i32_sat(+NaN) == 0
+; run: %f32_to_i32_sat(-NaN) == 0
+; run: %f32_to_i32_sat(+Inf) == 2147483647
+; run: %f32_to_i32_sat(-Inf) == -2147483648
 
-function %fcvt_to_uint_sat(f32) -> i32 {
+function %f64_to_i32_sat(f64) -> i32 {
+block0(v0: f64):
+    v1 = fcvt_to_sint_sat.i32 v0
+    return v1
+}
+; run: %f64_to_i32_sat(0x0.0) == 0
+; run: %f64_to_i32_sat(0x1.0) == 1
+; run: %f64_to_i32_sat(0x1.d6f346p26) == 123456792
+; run: %f64_to_i32_sat(0x8.1) == 8
+; run: %f64_to_i32_sat(-0x1.0) == -1
+; run: %f64_to_i32_sat(0x1.fffffep127) == 2147483647
+; run: %f64_to_i32_sat(-0x1.fffffep127) == -2147483648
+; run: %f64_to_i32_sat(+NaN) == 0
+; run: %f64_to_i32_sat(-NaN) == 0
+; run: %f64_to_i32_sat(+Inf) == 2147483647
+; run: %f64_to_i32_sat(-Inf) == -2147483648
+
+function %f32_to_i64_sat(f32) -> i64 {
+block0(v0: f32):
+    v1 = fcvt_to_sint_sat.i64 v0
+    return v1
+}
+; run: %f32_to_i64_sat(0x0.0) == 0
+; run: %f32_to_i64_sat(0x1.0) == 1
+; run: %f32_to_i64_sat(0x1.d6f346p26) == 123456792
+; run: %f32_to_i64_sat(0x8.1) == 8
+; run: %f32_to_i64_sat(-0x1.0) == -1
+; run: %f32_to_i64_sat(0x1.fffffep127) == 0x7fffffff_ffffffff
+; run: %f32_to_i64_sat(-0x1.fffffep127) == 0x80000000_00000000
+; run: %f32_to_i64_sat(+NaN) == 0
+; run: %f32_to_i64_sat(-NaN) == 0
+; run: %f32_to_i64_sat(+Inf) == 0x7fffffff_ffffffff
+; run: %f32_to_i64_sat(-Inf) == 0x80000000_00000000
+
+function %f64_to_i64_sat(f64) -> i64 {
+block0(v0: f64):
+    v1 = fcvt_to_sint_sat.i64 v0
+    return v1
+}
+; run: %f64_to_i64_sat(0x0.0) == 0
+; run: %f64_to_i64_sat(0x1.0) == 1
+; run: %f64_to_i64_sat(0x1.d6f346p26) == 123456792
+; run: %f64_to_i64_sat(0x8.1) == 8
+; run: %f64_to_i64_sat(-0x1.0) == -1
+; run: %f64_to_i64_sat(0x1.fffffep127) == 0x7fffffff_ffffffff
+; run: %f64_to_i64_sat(-0x1.fffffep127) == 0x80000000_00000000
+; run: %f64_to_i64_sat(+NaN) == 0
+; run: %f64_to_i64_sat(-NaN) == 0
+; run: %f64_to_i64_sat(+Inf) == 0x7fffffff_ffffffff
+; run: %f64_to_i64_sat(-Inf) == 0x80000000_00000000
+
+function %f32_to_u32_sat(f32) -> i32 {
 block0(v0:f32):
     v1 = fcvt_to_uint_sat.i32 v0
     return v1
 }
-; run: %fcvt_to_uint_sat(0x0.0) == 0
-; run: %fcvt_to_uint_sat(0x1.0) == 1
-; run: %fcvt_to_uint_sat(0x4.2) == 4
-; run: %fcvt_to_uint_sat(0x4.6) == 4
-; run: %fcvt_to_uint_sat(0x1.d6f346p26) == 123456792
-; run: %fcvt_to_uint_sat(0xB2D05E00.0) == 3000000000
-; run: %fcvt_to_uint_sat(-0x1.0) == 0
-; run: %fcvt_to_uint_sat(0x1.fffffep127) == 4294967295
-; run: %fcvt_to_uint_sat(-0x1.fffffep127) == 0
+; run: %f32_to_u32_sat(0x0.0) == 0
+; run: %f32_to_u32_sat(0x1.0) == 1
+; run: %f32_to_u32_sat(0x4.2) == 4
+; run: %f32_to_u32_sat(0x4.6) == 4
+; run: %f32_to_u32_sat(0x1.d6f346p26) == 123456792
+; run: %f32_to_u32_sat(0xB2D05E00.0) == 3000000000
+; run: %f32_to_u32_sat(-0x1.0) == 0
+; run: %f32_to_u32_sat(0x1.fffffep127) == 4294967295
+; run: %f32_to_u32_sat(-0x1.fffffep127) == 0
+; run: %f32_to_u32_sat(+NaN) == 0
+; run: %f32_to_u32_sat(-NaN) == 0
+; run: %f32_to_u32_sat(+Inf) == 0xffffffff
+; run: %f32_to_u32_sat(-Inf) == 0
+
+function %f64_to_u32_sat(f64) -> i32 {
+block0(v0:f64):
+    v1 = fcvt_to_uint_sat.i32 v0
+    return v1
+}
+; run: %f64_to_u32_sat(0x0.0) == 0
+; run: %f64_to_u32_sat(0x1.0) == 1
+; run: %f64_to_u32_sat(0x4.2) == 4
+; run: %f64_to_u32_sat(0x4.6) == 4
+; run: %f64_to_u32_sat(0x1.d6f346p26) == 123456792
+; run: %f64_to_u32_sat(0xB2D05E00.0) == 3000000000
+; run: %f64_to_u32_sat(-0x1.0) == 0
+; run: %f64_to_u32_sat(0x1.fffffep127) == 4294967295
+; run: %f64_to_u32_sat(-0x1.fffffep127) == 0
+; run: %f64_to_u32_sat(+NaN) == 0
+; run: %f64_to_u32_sat(-NaN) == 0
+; run: %f64_to_u32_sat(+Inf) == 0xffffffff
+; run: %f64_to_u32_sat(-Inf) == 0
+
+function %f32_to_u64_sat(f32) -> i64 {
+block0(v0:f32):
+    v1 = fcvt_to_uint_sat.i64 v0
+    return v1
+}
+; run: %f32_to_u64_sat(0x0.0) == 0
+; run: %f32_to_u64_sat(0x1.0) == 1
+; run: %f32_to_u64_sat(0x4.2) == 4
+; run: %f32_to_u64_sat(0x4.6) == 4
+; run: %f32_to_u64_sat(0x1.d6f346p26) == 123456792
+; run: %f32_to_u64_sat(0xB2D05E00.0) == 3000000000
+; run: %f32_to_u64_sat(-0x1.0) == 0
+; run: %f32_to_u64_sat(0x1.fffffep127) == 0xffffffff_ffffffff
+; run: %f32_to_u64_sat(-0x1.fffffep127) == 0
+; run: %f32_to_u64_sat(+NaN) == 0
+; run: %f32_to_u64_sat(-NaN) == 0
+; run: %f32_to_u64_sat(+Inf) == 0xffffffff_ffffffff
+; run: %f32_to_u64_sat(-Inf) == 0
+
+function %f64_to_u64_sat(f64) -> i64 {
+block0(v0:f64):
+    v1 = fcvt_to_uint_sat.i64 v0
+    return v1
+}
+; run: %f64_to_u64_sat(0x0.0) == 0
+; run: %f64_to_u64_sat(0x1.0) == 1
+; run: %f64_to_u64_sat(0x4.2) == 4
+; run: %f64_to_u64_sat(0x4.6) == 4
+; run: %f64_to_u64_sat(0x1.d6f346p26) == 123456792
+; run: %f64_to_u64_sat(0xB2D05E00.0) == 3000000000
+; run: %f64_to_u64_sat(-0x1.0) == 0
+; run: %f64_to_u64_sat(0x1.fffffep127) == 0xffffffff_ffffffff
+; run: %f64_to_u64_sat(-0x1.fffffep127) == 0
+; run: %f64_to_u64_sat(+NaN) == 0
+; run: %f64_to_u64_sat(-NaN) == 0
+; run: %f64_to_u64_sat(+Inf) == 0xffffffff_ffffffff
+; run: %f64_to_u64_sat(-Inf) == 0
diff --git a/cranelift/filetests/filetests/runtests/extend.clif b/cranelift/filetests/filetests/runtests/extend.clif
index bc02c2d23bad..710c33d9a8e9 100644
--- a/cranelift/filetests/filetests/runtests/extend.clif
+++ b/cranelift/filetests/filetests/runtests/extend.clif
@@ -216,3 +216,21 @@ block0(v0: i32, v1: i32):
 }
 ; run: %add_sextend32_64(0xffff_ee00, 0x1000_0001) == 0x0000_0000_0fff_ee01
 ; run: %add_sextend32_64(0xffff_ee00, 0x9000_0001) == 0xffff_ffff_8fff_ee01
+
+function %sext16_zext32(i8) -> i32 {
+block0(v0: i8):
+    v1 = sextend.i16 v0
+    v2 = uextend.i32 v1
+    return v2
+}
+; run: %sext16_zext32(0xff) == 0xffff
+; run: %sext16_zext32(0x7f) == 0x7f
+
+function %zext16_sext32(i8) -> i32 {
+block0(v0: i8):
+    v1 = uextend.i16 v0
+    v2 = sextend.i32 v1
+    return v2
+}
+; run: %zext16_sext32(0xff) == 0xff
+; run: %zext16_sext32(0x7f) == 0x7f
diff --git a/cranelift/filetests/filetests/runtests/f128-bitcast.clif b/cranelift/filetests/filetests/runtests/f128-bitcast.clif
new file mode 100644
index 000000000000..7d9ba7639ced
--- /dev/null
+++ b/cranelift/filetests/filetests/runtests/f128-bitcast.clif
@@ -0,0 +1,36 @@
+test interpret
+test run
+set enable_llvm_abi_extensions
+target x86_64
+target aarch64
+target aarch64 has_fp16
+
+function %bitcast_i128_f128(i128) -> f128 fast {
+block0(v0: i128):
+    v1 = bitcast.f128 v0
+    return v1
+}
+; run: %bitcast_i128_f128(0x00000000000000000000000000000000) == 0x0.0
+; run: %bitcast_i128_f128(0x00000000000000000000000000000001) == 0x0.0000000000000000000000000001p-16382
+; run: %bitcast_i128_f128(0x7fff0000000000000000000000000000) == Inf
+; run: %bitcast_i128_f128(0xffff8000000000000000000000000000) == -NaN
+; run: %bitcast_i128_f128(0x7fff0000000000000000000000000001) == +sNaN:0x1
+; run: %bitcast_i128_f128(0x3fff0000000000000000000000000000) == 0x1.0
+; run: %bitcast_i128_f128(0x3fff7fef123456789abcdefcda456987) == 0x1.7fef123456789abcdefcda456987
+; run: %bitcast_i128_f128(0xf0e0d0c0b0a090807060504030201000) == -0x1.d0c0b0a090807060504030201000p12513
+; run: %bitcast_i128_f128(0xabcdef01234567890123456789abcdef) == -0x1.ef01234567890123456789abcdefp-5170
+
+function %bitcast_f128_i128(f128) -> i128 fast {
+block0(v0: f128):
+    v1 = bitcast.i128 v0
+    return v1
+}
+; run: %bitcast_f128_i128(0x0.0) == 0x00000000000000000000000000000000
+; run: %bitcast_f128_i128(0x0.0000000000000000000000000001p-16382) == 0x00000000000000000000000000000001
+; run: %bitcast_f128_i128(Inf) == 0x7fff0000000000000000000000000000
+; run: %bitcast_f128_i128(-NaN) == 0xffff8000000000000000000000000000
+; run: %bitcast_f128_i128(+sNaN:0x1) == 0x7fff0000000000000000000000000001
+; run: %bitcast_f128_i128(0x1.0) == 0x3fff0000000000000000000000000000
+; run: %bitcast_f128_i128(0x1.7fef123456789abcdefcda456987) == 0x3fff7fef123456789abcdefcda456987
+; run: %bitcast_f128_i128(-0x1.d0c0b0a090807060504030201000p12513) == 0xf0e0d0c0b0a090807060504030201000
+; run: %bitcast_f128_i128(-0x1.ef01234567890123456789abcdefp-5170) == 0xabcdef01234567890123456789abcdef
diff --git a/cranelift/filetests/filetests/runtests/f128-select.clif b/cranelift/filetests/filetests/runtests/f128-select.clif
new file mode 100644
index 000000000000..2593988f8afa
--- /dev/null
+++ b/cranelift/filetests/filetests/runtests/f128-select.clif
@@ -0,0 +1,71 @@
+test interpret
+test run
+set enable_llvm_abi_extensions
+target x86_64
+target aarch64
+target aarch64 has_fp16
+
+function %select_icmp_i8_f128(i8, f128, f128) -> f128 {
+block0(v0: i8, v1: f128, v2: f128):
+  v3 = iconst.i8 42
+  v4 = icmp eq v0, v3
+  v5 = select.f128 v4, v1, v2
+  return v5
+}
+; run: %select_icmp_i8_f128(42, 0x0.0, 0x1.0) == 0x0.0
+; run: %select_icmp_i8_f128(10, 0x0.0, 0x1.0) == 0x1.0
+; run: %select_icmp_i8_f128(42, +Inf, -Inf) == +Inf
+; run: %select_icmp_i8_f128(10, +Inf, -Inf) == -Inf
+; run: %select_icmp_i8_f128(42, +NaN, -NaN) == +NaN
+; run: %select_icmp_i8_f128(10, +NaN, -NaN) == -NaN
+; run: %select_icmp_i8_f128(42, 0x0.8000000000000000000000000000p-16382, -0x0.8000000000000000000000000000p-16382) == 0x0.8000000000000000000000000000p-16382
+; run: %select_icmp_i8_f128(10, 0x0.8000000000000000000000000000p-16382, -0x0.8000000000000000000000000000p-16382) == -0x0.8000000000000000000000000000p-16382
+
+function %select_icmp_i16_f128(i16, f128, f128) -> f128 {
+block0(v0: i16, v1: f128, v2: f128):
+  v3 = iconst.i16 42
+  v4 = icmp eq v0, v3
+  v5 = select.f128 v4, v1, v2
+  return v5
+}
+; run: %select_icmp_i16_f128(42, 0x0.0, 0x1.0) == 0x0.0
+; run: %select_icmp_i16_f128(10, 0x0.0, 0x1.0) == 0x1.0
+; run: %select_icmp_i16_f128(42, +Inf, -Inf) == +Inf
+; run: %select_icmp_i16_f128(10, +Inf, -Inf) == -Inf
+; run: %select_icmp_i16_f128(42, +NaN, -NaN) == +NaN
+; run: %select_icmp_i16_f128(10, +NaN, -NaN) == -NaN
+; run: %select_icmp_i16_f128(42, 0x0.8000000000000000000000000000p-16382, -0x0.8000000000000000000000000000p-16382) == 0x0.8000000000000000000000000000p-16382
+; run: %select_icmp_i16_f128(10, 0x0.8000000000000000000000000000p-16382, -0x0.8000000000000000000000000000p-16382) == -0x0.8000000000000000000000000000p-16382
+
+
+function %select_icmp_i32_f128(i32, f128, f128) -> f128 {
+block0(v0: i32, v1: f128, v2: f128):
+  v3 = iconst.i32 42
+  v4 = icmp eq v0, v3
+  v5 = select.f128 v4, v1, v2
+  return v5
+}
+; run: %select_icmp_i32_f128(42, 0x0.0, 0x1.0) == 0x0.0
+; run: %select_icmp_i32_f128(10, 0x0.0, 0x1.0) == 0x1.0
+; run: %select_icmp_i32_f128(42, +Inf, -Inf) == +Inf
+; run: %select_icmp_i32_f128(10, +Inf, -Inf) == -Inf
+; run: %select_icmp_i32_f128(42, +NaN, -NaN) == +NaN
+; run: %select_icmp_i32_f128(10, +NaN, -NaN) == -NaN
+; run: %select_icmp_i32_f128(42, 0x0.8000000000000000000000000000p-16382, -0x0.8000000000000000000000000000p-16382) == 0x0.8000000000000000000000000000p-16382
+; run: %select_icmp_i32_f128(10, 0x0.8000000000000000000000000000p-16382, -0x0.8000000000000000000000000000p-16382) == -0x0.8000000000000000000000000000p-16382
+
+function %select_icmp_i64_f128(i64, f128, f128) -> f128 {
+block0(v0: i64, v1: f128, v2: f128):
+  v3 = iconst.i64 42
+  v4 = icmp eq v0, v3
+  v5 = select.f128 v4, v1, v2
+  return v5
+}
+; run: %select_icmp_i64_f128(42, 0x0.0, 0x1.0) == 0x0.0
+; run: %select_icmp_i64_f128(10, 0x0.0, 0x1.0) == 0x1.0
+; run: %select_icmp_i64_f128(42, +Inf, -Inf) == +Inf
+; run: %select_icmp_i64_f128(10, +Inf, -Inf) == -Inf
+; run: %select_icmp_i64_f128(42, +NaN, -NaN) == +NaN
+; run: %select_icmp_i64_f128(10, +NaN, -NaN) == -NaN
+; run: %select_icmp_i64_f128(42, 0x0.8000000000000000000000000000p-16382, -0x0.8000000000000000000000000000p-16382) == 0x0.8000000000000000000000000000p-16382
+; run: %select_icmp_i64_f128(10, 0x0.8000000000000000000000000000p-16382, -0x0.8000000000000000000000000000p-16382) == -0x0.8000000000000000000000000000p-16382
diff --git a/cranelift/filetests/filetests/runtests/f128const.clif b/cranelift/filetests/filetests/runtests/f128const.clif
new file mode 100644
index 000000000000..601664f15d99
--- /dev/null
+++ b/cranelift/filetests/filetests/runtests/f128const.clif
@@ -0,0 +1,65 @@
+test interpret
+test run
+set enable_llvm_abi_extensions
+target x86_64
+target aarch64
+
+
+;; These values are special for RISC-V since it has a dedicated
+;; instruction to generate them.
+
+function %special_f128_values() -> f128, f128, f128, f128, f128, f128, f128, f128, f128, f128, f128, f128, f128, f128, f128, f128, f128, f128, f128, f128, f128, f128, f128, f128, f128, f128, f128, f128, f128, f128, f128, f128 {
+block0:
+    v0 = f128const -0x1.p0
+    v1 = f128const 0x1.p-16382
+    v2 = f128const 0x1.p-16
+    v3 = f128const 0x1.p-15
+    v4 = f128const 0x1.p-8
+    v5 = f128const 0x1.p-7
+    v6 = f128const 0x1.p-4
+    v7 = f128const 0x1.p-3
+    v8 = f128const 0x1.p-2
+    v9 = f128const 0x1.4p-2
+    v10 = f128const 0x1.8p-2
+    v11 = f128const 0x1.cp-2
+    v12 = f128const 0x1.p-1
+    v13 = f128const 0x1.4p-1
+    v14 = f128const 0x1.8p-1
+    v15 = f128const 0x1.cp-1
+    v16 = f128const 0x1.p0
+    v17 = f128const 0x1.4p0
+    v18 = f128const 0x1.8p0
+    v19 = f128const 0x1.cp0
+    v20 = f128const 0x1.p1
+    v21 = f128const 0x1.4p1
+    v22 = f128const 0x1.8p1
+    v23 = f128const 0x1.p2
+    v24 = f128const 0x1.p3
+    v25 = f128const 0x1.p4
+    v26 = f128const 0x1.p7
+    v27 = f128const 0x1.p8
+    v28 = f128const 0x1.p15
+    v29 = f128const 0x1.p16
+    v30 = f128const +Inf
+    v31 = f128const +NaN
+
+    return v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31
+}
+
+; run: %special_f128_values() == [-0x1.p0, 0x1.p-16382, 0x1.p-16, 0x1.p-15, 0x1.p-8, 0x1.p-7, 0x1.p-4, 0x1.p-3, 0x1.p-2, 0x1.4p-2, 0x1.8p-2, 0x1.cp-2, 0x1.p-1, 0x1.4p-1, 0x1.8p-1, 0x1.cp-1, 0x1.p0, 0x1.4p0, 0x1.8p0, 0x1.cp0, 0x1.p1, 0x1.4p1, 0x1.8p1, 0x1.p2, 0x1.p3, 0x1.p4, 0x1.p7, 0x1.p8, 0x1.p15, 0x1.p16, +Inf, +NaN]
+
+function %f128const_neg_nan() -> f128 {
+block0:
+    v0 = f128const -NaN
+    return v0
+}
+
+; run: %f128const_neg_nan() == -NaN
+
+function %f128const_zero() -> f128 {
+block0:
+    v0 = f128const 0.0
+    return v0
+}
+
+; run: %f128const_zero() == 0.0
diff --git a/cranelift/filetests/filetests/runtests/f16-arithmetic.clif b/cranelift/filetests/filetests/runtests/f16-arithmetic.clif
new file mode 100644
index 000000000000..e1c80f9f3be6
--- /dev/null
+++ b/cranelift/filetests/filetests/runtests/f16-arithmetic.clif
@@ -0,0 +1,77 @@
+test run
+target riscv64 has_zfh
+
+function %fadd(f16, f16) -> f16 {
+block0(v0: f16, v1: f16):
+  v2 = fadd v0, v1
+  return v2
+}
+; run: %fadd(0x0.0, 0x0.0) == 0x0.0
+; run: %fadd(0x1.5, 0x2.9) == 0x1.fp1
+
+function %fsub(f16, f16) -> f16 {
+block0(v0: f16, v1: f16):
+  v2 = fsub v0, v1
+  return v2
+}
+; run: %fsub(0x0.5, 0x1.0) == -0x1.600p-1
+; run: %fsub(0x1.5, 0x2.9) == -0x1.400p0
+
+
+function %fmul(f16, f16) -> f16 {
+block0(v0: f16, v1: f16):
+  v2 = fmul v0, v1
+  return v2
+}
+; run: %fmul(0x0.5, 0x1.0) == 0x1.400p-2
+; run: %fmul(0x1.5, 0x2.9) == 0x1.ae8p1
+
+function %fdiv(f16, f16) -> f16 {
+block0(v0: f16, v1: f16):
+  v2 = fdiv v0, v1
+  return v2
+}
+; run: %fdiv(0x0.5, 0x1.0) == 0x1.400p-2
+; run: %fdiv(0x1.5, 0x2.9) == 0x1.064p-1
+
+function %sqrt(f16) -> f16 {
+block0(v0: f16):
+  v1 = sqrt v0
+  return v1
+}
+; run: %sqrt(0x9.0) == 0x3.0
+; run: %sqrt(0x0.0) == 0x0.0
+; run: %sqrt(-0x0.0) == -0x0.0
+; run: %sqrt(+Inf) == +Inf
+
+function %fabs(f16) -> f16 {
+block0(v0: f16):
+  v1 = fabs v0
+  return v1
+}
+; run: %fabs(0x9.0) == 0x9.0
+; run: %fabs(-0x9.0) == 0x9.0
+; run: %fabs(0x0.0) == 0x0.0
+; run: %fabs(-0x0.0) == 0x0.0
+
+function %fneg(f16) -> f16 {
+block0(v0: f16):
+  v1 = fneg v0
+  return v1
+}
+; run: %fneg(0x9.0) == -0x9.0
+; run: %fneg(-0x9.0) == 0x9.0
+; run: %fneg(0x0.0) == -0x0.0
+; run: %fneg(-0x0.0) == 0x0.0
+
+function %fcopysign(f16, f16) -> f16 {
+block0(v0: f16, v1: f16):
+  v2 = fcopysign v0, v1
+  return v2
+}
+; run: %fcopysign(0x9.0, 0x9.0) == 0x9.0
+; run: %fcopysign(-0x9.0, 0x9.0) == 0x9.0
+; run: %fcopysign(0x9.0, -0x9.0) == -0x9.0
+; run: %fcopysign(-0x9.0, -0x9.0) == -0x9.0
+; run: %fcopysign(0x0.0, -0x0.0) == -0x0.0
+; run: %fcopysign(-0x0.0, 0x0.0) == 0x0.0
diff --git a/cranelift/filetests/filetests/runtests/f16-bitcast.clif b/cranelift/filetests/filetests/runtests/f16-bitcast.clif
new file mode 100644
index 000000000000..214ed40882fb
--- /dev/null
+++ b/cranelift/filetests/filetests/runtests/f16-bitcast.clif
@@ -0,0 +1,35 @@
+test interpret
+test run
+set enable_llvm_abi_extensions
+target x86_64
+target riscv64 has_zfh
+
+function %bitcast_i16_f16(i16) -> f16 fast {
+block0(v0: i16):
+    v1 = bitcast.f16 v0
+    return v1
+}
+; run: %bitcast_i16_f16(0x0000) == 0x0.0
+; run: %bitcast_i16_f16(0x0001) == 0x0.004p-14
+; run: %bitcast_i16_f16(0x7c00) == Inf
+; run: %bitcast_i16_f16(0xfe00) == -NaN
+; run: %bitcast_i16_f16(0x7c01) == +sNaN:0x1
+; run: %bitcast_i16_f16(0x3c00) == 0x1.0
+; run: %bitcast_i16_f16(0x47fe) == 0x7.fe
+; run: %bitcast_i16_f16(0xf0e0) == -0x1.380p13
+; run: %bitcast_i16_f16(0xabcd) == -0x1.f34p-5
+
+function %bitcast_f16_i16(f16) -> i16 fast {
+block0(v0: f16):
+    v1 = bitcast.i16 v0
+    return v1
+}
+; run: %bitcast_f16_i16(0x0.0) == 0x0000
+; run: %bitcast_f16_i16(0x0.004p-14) == 0x0001
+; run: %bitcast_f16_i16(Inf) == 0x7c00
+; run: %bitcast_f16_i16(-NaN) == 0xfe00
+; run: %bitcast_f16_i16(+sNaN:0x1) == 0x7c01
+; run: %bitcast_f16_i16(0x1.0) == 0x3c00
+; run: %bitcast_f16_i16(0x7.fe) == 0x47fe
+; run: %bitcast_f16_i16(-0x1.3c0p13) == 0xf0f0
+; run: %bitcast_f16_i16(-0x1.f34p-5) == 0xabcd
diff --git a/cranelift/filetests/filetests/runtests/f16-fma.clif b/cranelift/filetests/filetests/runtests/f16-fma.clif
new file mode 100644
index 000000000000..0a4959df6295
--- /dev/null
+++ b/cranelift/filetests/filetests/runtests/f16-fma.clif
@@ -0,0 +1,38 @@
+test run
+target riscv64 has_zfh
+
+function %fmadd(f16, f16, f16) -> f16 {
+block0(v0: f16, v1: f16, v2: f16):
+  v3 = fma v0, v1, v2
+  return v3
+}
+; run: %fmadd(0x7.0, 0x8.0, 0x9.0) == 0x1.040p6
+
+
+
+function %fmsub(f16, f16, f16) -> f16 {
+block0(v0: f16, v1: f16, v2: f16):
+    v3 = fneg v2
+    v4 = fma v0, v1, v3
+    return v4
+}
+; run: %fmsub(0x7.0, 0x8.0, 0x9.0) == 0x1.780p5
+
+
+function %fnmsub(f16, f16, f16) -> f16 {
+block0(v0: f16, v1: f16, v2: f16):
+    v3 = fneg v0
+    v4 = fma v3, v1, v2
+    return v4
+}
+; run: %fnmsub(0x7.0, 0x8.0, 0x9.0) == -0x1.780p5
+
+
+function %fnmadd(f16, f16, f16) -> f16 {
+block0(v0: f16, v1: f16, v2: f16):
+    v3 = fneg v0
+    v4 = fneg v2
+    v5 = fma v3, v1, v4
+    return v5
+}
+; run: %fnmadd(0x7.0, 0x8.0, 0x9.0) == -0x1.040p6
diff --git a/cranelift/filetests/filetests/runtests/f16-memory.clif b/cranelift/filetests/filetests/runtests/f16-memory.clif
new file mode 100644
index 000000000000..60418f705bdf
--- /dev/null
+++ b/cranelift/filetests/filetests/runtests/f16-memory.clif
@@ -0,0 +1,48 @@
+test interpret
+test run
+set enable_llvm_abi_extensions
+target x86_64
+target riscv64 has_zfh
+
+function %f16_load(i16) -> f16 {
+    ss0 = explicit_slot 4
+
+block0(v0: i16):
+    stack_store.i16 v0, ss0+2
+    
+    v1 = stack_load.f16 ss0+2
+    return v1
+}
+; run: %f16_load(0) == 0x0.0
+; run: %f16_load(15680) == 0x1.5
+; run: %f16_load(32256)  == NaN
+; run: %f16_load(31744)  == Inf
+
+
+function %f16_store(f16) -> i16 {
+    ss0 = explicit_slot 4
+
+block0(v0: f16):
+    stack_store.f16 v0, ss0+2
+    
+    v1 = stack_load.i16 ss0+2
+    return v1
+}
+; run: %f16_store(0x0.0) == 0
+; run: %f16_store(0x1.5) == 15680
+; run: %f16_store(NaN) == 32256
+; run: %f16_store(Inf) == 31744
+
+
+function %f16_roundtrip(f16) -> f16 {
+    ss0 = explicit_slot 2
+
+block0(v0: f16):
+    stack_store.f16 v0, ss0
+    v1 = stack_load.f16 ss0
+    return v1
+}
+; run: %f16_roundtrip(0x0.0) == 0x0.0
+; run: %f16_roundtrip(0x1.5) == 0x1.5
+; run: %f16_roundtrip(NaN) == NaN
+; run: %f16_roundtrip(Inf) == Inf
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/runtests/f16-select.clif b/cranelift/filetests/filetests/runtests/f16-select.clif
new file mode 100644
index 000000000000..8d9ad4f32a4e
--- /dev/null
+++ b/cranelift/filetests/filetests/runtests/f16-select.clif
@@ -0,0 +1,70 @@
+test interpret
+test run
+set enable_llvm_abi_extensions
+target x86_64
+target riscv64 has_zfh
+
+function %select_icmp_i8_f16(i8, f16, f16) -> f16 {
+block0(v0: i8, v1: f16, v2: f16):
+  v3 = iconst.i8 42
+  v4 = icmp eq v0, v3
+  v5 = select.f16 v4, v1, v2
+  return v5
+}
+; run: %select_icmp_i8_f16(42, 0x0.0, 0x1.0) == 0x0.0
+; run: %select_icmp_i8_f16(10, 0x0.0, 0x1.0) == 0x1.0
+; run: %select_icmp_i8_f16(42, +Inf, -Inf) == +Inf
+; run: %select_icmp_i8_f16(10, +Inf, -Inf) == -Inf
+; run: %select_icmp_i8_f16(42, +NaN, -NaN) == +NaN
+; run: %select_icmp_i8_f16(10, +NaN, -NaN) == -NaN
+; run: %select_icmp_i8_f16(42, 0x0.800p-14, -0x0.800p-14) == 0x0.800p-14
+; run: %select_icmp_i8_f16(10, 0x0.800p-14, -0x0.800p-14) == -0x0.800p-14
+
+function %select_icmp_i16_f16(i16, f16, f16) -> f16 {
+block0(v0: i16, v1: f16, v2: f16):
+  v3 = iconst.i16 42
+  v4 = icmp eq v0, v3
+  v5 = select.f16 v4, v1, v2
+  return v5
+}
+; run: %select_icmp_i16_f16(42, 0x0.0, 0x1.0) == 0x0.0
+; run: %select_icmp_i16_f16(10, 0x0.0, 0x1.0) == 0x1.0
+; run: %select_icmp_i16_f16(42, +Inf, -Inf) == +Inf
+; run: %select_icmp_i16_f16(10, +Inf, -Inf) == -Inf
+; run: %select_icmp_i16_f16(42, +NaN, -NaN) == +NaN
+; run: %select_icmp_i16_f16(10, +NaN, -NaN) == -NaN
+; run: %select_icmp_i16_f16(42, 0x0.800p-14, -0x0.800p-14) == 0x0.800p-14
+; run: %select_icmp_i16_f16(10, 0x0.800p-14, -0x0.800p-14) == -0x0.800p-14
+
+function %select_icmp_i32_f16(i32, f16, f16) -> f16 {
+block0(v0: i32, v1: f16, v2: f16):
+  v3 = iconst.i32 42
+  v4 = icmp eq v0, v3
+  v5 = select.f16 v4, v1, v2
+  return v5
+}
+; run: %select_icmp_i32_f16(42, 0x0.0, 0x1.0) == 0x0.0
+; run: %select_icmp_i32_f16(10, 0x0.0, 0x1.0) == 0x1.0
+; run: %select_icmp_i32_f16(42, +Inf, -Inf) == +Inf
+; run: %select_icmp_i32_f16(10, +Inf, -Inf) == -Inf
+; run: %select_icmp_i32_f16(42, +NaN, -NaN) == +NaN
+; run: %select_icmp_i32_f16(10, +NaN, -NaN) == -NaN
+; run: %select_icmp_i32_f16(42, 0x0.800p-14, -0x0.800p-14) == 0x0.800p-14
+; run: %select_icmp_i32_f16(10, 0x0.800p-14, -0x0.800p-14) == -0x0.800p-14
+
+
+function %select_icmp_i64_f16(i64, f16, f16) -> f16 {
+block0(v0: i64, v1: f16, v2: f16):
+  v3 = iconst.i64 42
+  v4 = icmp eq v0, v3
+  v5 = select.f16 v4, v1, v2
+  return v5
+}
+; run: %select_icmp_i64_f16(42, 0x0.0, 0x1.0) == 0x0.0
+; run: %select_icmp_i64_f16(10, 0x0.0, 0x1.0) == 0x1.0
+; run: %select_icmp_i64_f16(42, +Inf, -Inf) == +Inf
+; run: %select_icmp_i64_f16(10, +Inf, -Inf) == -Inf
+; run: %select_icmp_i64_f16(42, +NaN, -NaN) == +NaN
+; run: %select_icmp_i64_f16(10, +NaN, -NaN) == -NaN
+; run: %select_icmp_i64_f16(42, 0x0.800p-14, -0x0.800p-14) == 0x0.800p-14
+; run: %select_icmp_i64_f16(10, 0x0.800p-14, -0x0.800p-14) == -0x0.800p-14
diff --git a/cranelift/filetests/filetests/runtests/f16const.clif b/cranelift/filetests/filetests/runtests/f16const.clif
new file mode 100644
index 000000000000..f5ea902a3b2d
--- /dev/null
+++ b/cranelift/filetests/filetests/runtests/f16const.clif
@@ -0,0 +1,67 @@
+test interpret
+test run
+set enable_llvm_abi_extensions
+target x86_64
+target aarch64
+target aarch64 has_fp16
+target riscv64 has_zfh
+
+
+;; These values are special for RISC-V since it has a dedicated
+;; instruction to generate them.
+
+function %special_f16_values() -> f16, f16, f16, f16, f16, f16, f16, f16, f16, f16, f16, f16, f16, f16, f16, f16, f16, f16, f16, f16, f16, f16, f16, f16, f16, f16, f16, f16, f16, f16, f16 {
+block0:
+    v0 = f16const -0x1.p0
+    v1 = f16const 0x1.p-14
+    v2 = f16const 0x1.p-16
+    v3 = f16const 0x1.p-15
+    v4 = f16const 0x1.p-8
+    v5 = f16const 0x1.p-7
+    v6 = f16const 0x1.p-4
+    v7 = f16const 0x1.p-3
+    v8 = f16const 0x1.p-2
+    v9 = f16const 0x1.4p-2
+    v10 = f16const 0x1.8p-2
+    v11 = f16const 0x1.cp-2
+    v12 = f16const 0x1.p-1
+    v13 = f16const 0x1.4p-1
+    v14 = f16const 0x1.8p-1
+    v15 = f16const 0x1.cp-1
+    v16 = f16const 0x1.p0
+    v17 = f16const 0x1.4p0
+    v18 = f16const 0x1.8p0
+    v19 = f16const 0x1.cp0
+    v20 = f16const 0x1.p1
+    v21 = f16const 0x1.4p1
+    v22 = f16const 0x1.8p1
+    v23 = f16const 0x1.p2
+    v24 = f16const 0x1.p3
+    v25 = f16const 0x1.p4
+    v26 = f16const 0x1.p7
+    v27 = f16const 0x1.p8
+    v28 = f16const 0x1.p15
+    v29 = f16const +Inf
+    v30 = f16const +NaN
+
+    return v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30
+}
+
+; run: %special_f16_values() == [-0x1.p0, 0x1.p-14, 0x1.p-16, 0x1.p-15, 0x1.p-8, 0x1.p-7, 0x1.p-4, 0x1.p-3, 0x1.p-2, 0x1.4p-2, 0x1.8p-2, 0x1.cp-2, 0x1.p-1, 0x1.4p-1, 0x1.8p-1, 0x1.cp-1, 0x1.p0, 0x1.4p0, 0x1.8p0, 0x1.cp0, 0x1.p1, 0x1.4p1, 0x1.8p1, 0x1.p2, 0x1.p3, 0x1.p4, 0x1.p7, 0x1.p8, 0x1.p15, +Inf, +NaN]
+
+
+function %f16const_neg_nan() -> f16 {
+block0:
+    v0 = f16const -NaN
+    return v0
+}
+
+; run: %f16const_neg_nan() == -NaN
+
+function %f16const_zero() -> f16 {
+block0:
+    v0 = f16const 0.0
+    return v0
+}
+
+; run: %f16const_zero() == 0.0
diff --git a/cranelift/filetests/filetests/runtests/f32const.clif b/cranelift/filetests/filetests/runtests/f32const.clif
new file mode 100644
index 000000000000..208220e33279
--- /dev/null
+++ b/cranelift/filetests/filetests/runtests/f32const.clif
@@ -0,0 +1,61 @@
+test interpret
+test run
+target x86_64
+target aarch64
+target s390x
+target riscv64
+target riscv64 has_zfa
+target riscv64 has_c has_zcb
+
+
+;; These values are special for RISC-V since it has a dedicated
+;; instruction to generate them.
+
+function %special_f32_values() -> f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32 {
+block0:
+    v0 = f32const -0x1.p0
+    v1 = f32const 0x1.p-126
+    v2 = f32const 0x1.p-16
+    v3 = f32const 0x1.p-15
+    v4 = f32const 0x1.p-8
+    v5 = f32const 0x1.p-7
+    v6 = f32const 0x1.p-4
+    v7 = f32const 0x1.p-3
+    v8 = f32const 0x1.p-2
+    v9 = f32const 0x1.4p-2
+    v10 = f32const 0x1.8p-2
+    v11 = f32const 0x1.cp-2
+    v12 = f32const 0x1.p-1
+    v13 = f32const 0x1.4p-1
+    v14 = f32const 0x1.8p-1
+    v15 = f32const 0x1.cp-1
+    v16 = f32const 0x1.p0
+    v17 = f32const 0x1.4p0
+    v18 = f32const 0x1.8p0
+    v19 = f32const 0x1.cp0
+    v20 = f32const 0x1.p1
+    v21 = f32const 0x1.4p1
+    v22 = f32const 0x1.8p1
+    v23 = f32const 0x1.p2
+    v24 = f32const 0x1.p3
+    v25 = f32const 0x1.p4
+    v26 = f32const 0x1.p7
+    v27 = f32const 0x1.p8
+    v28 = f32const 0x1.p15
+    v29 = f32const 0x1.p16
+    v30 = f32const +Inf
+    v31 = f32const +NaN
+
+    return v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31
+}
+
+; run: %special_f32_values() == [-0x1.p0, 0x1.p-126, 0x1.p-16, 0x1.p-15, 0x1.p-8, 0x1.p-7, 0x1.p-4, 0x1.p-3, 0x1.p-2, 0x1.4p-2, 0x1.8p-2, 0x1.cp-2, 0x1.p-1, 0x1.4p-1, 0x1.8p-1, 0x1.cp-1, 0x1.p0, 0x1.4p0, 0x1.8p0, 0x1.cp0, 0x1.p1, 0x1.4p1, 0x1.8p1, 0x1.p2, 0x1.p3, 0x1.p4, 0x1.p7, 0x1.p8, 0x1.p15, 0x1.p16, +Inf, +NaN]
+
+
+function %f32const_neg_nan() -> f32 {
+block0:
+    v0 = f32const -NaN
+    return v0
+}
+
+; run: %f32const_neg_nan() == -NaN
diff --git a/cranelift/filetests/filetests/runtests/f64const.clif b/cranelift/filetests/filetests/runtests/f64const.clif
new file mode 100644
index 000000000000..cb0d63a4443c
--- /dev/null
+++ b/cranelift/filetests/filetests/runtests/f64const.clif
@@ -0,0 +1,60 @@
+test interpret
+test run
+target x86_64
+target aarch64
+target s390x
+target riscv64
+target riscv64 has_zfa
+target riscv64 has_c has_zcb
+
+
+;; These values are special for RISC-V since it has a dedicated
+;; instruction to generate them.
+
+function %special_f64_values() -> f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64, f64 {
+block0:
+    v0 = f64const -0x1.p0
+    v1 = f64const 0x1.p-1022
+    v2 = f64const 0x1.p-16
+    v3 = f64const 0x1.p-15
+    v4 = f64const 0x1.p-8
+    v5 = f64const 0x1.p-7
+    v6 = f64const 0x1.p-4
+    v7 = f64const 0x1.p-3
+    v8 = f64const 0x1.p-2
+    v9 = f64const 0x1.4p-2
+    v10 = f64const 0x1.8p-2
+    v11 = f64const 0x1.cp-2
+    v12 = f64const 0x1.p-1
+    v13 = f64const 0x1.4p-1
+    v14 = f64const 0x1.8p-1
+    v15 = f64const 0x1.cp-1
+    v16 = f64const 0x1.p0
+    v17 = f64const 0x1.4p0
+    v18 = f64const 0x1.8p0
+    v19 = f64const 0x1.cp0
+    v20 = f64const 0x1.p1
+    v21 = f64const 0x1.4p1
+    v22 = f64const 0x1.8p1
+    v23 = f64const 0x1.p2
+    v24 = f64const 0x1.p3
+    v25 = f64const 0x1.p4
+    v26 = f64const 0x1.p7
+    v27 = f64const 0x1.p8
+    v28 = f64const 0x1.p15
+    v29 = f64const 0x1.p16
+    v30 = f64const +Inf
+    v31 = f64const +NaN
+
+    return v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31
+}
+
+; run: %special_f64_values() == [-0x1.p0, 0x1.p-1022, 0x1.p-16, 0x1.p-15, 0x1.p-8, 0x1.p-7, 0x1.p-4, 0x1.p-3, 0x1.p-2, 0x1.4p-2, 0x1.8p-2, 0x1.cp-2, 0x1.p-1, 0x1.4p-1, 0x1.8p-1, 0x1.cp-1, 0x1.p0, 0x1.4p0, 0x1.8p0, 0x1.cp0, 0x1.p1, 0x1.4p1, 0x1.8p1, 0x1.p2, 0x1.p3, 0x1.p4, 0x1.p7, 0x1.p8, 0x1.p15, 0x1.p16, +Inf, +NaN]
+
+function %f64const_neg_nan() -> f64 {
+block0:
+    v0 = f64const -NaN
+    return v0
+}
+
+; run: %f64const_neg_nan() == -NaN
diff --git a/cranelift/filetests/filetests/runtests/floor.clif b/cranelift/filetests/filetests/runtests/floor.clif
index 986061afbd0a..3c49a0a9d21e 100644
--- a/cranelift/filetests/filetests/runtests/floor.clif
+++ b/cranelift/filetests/filetests/runtests/floor.clif
@@ -7,6 +7,7 @@ target x86_64 sse42 has_avx
 target aarch64
 target s390x
 target riscv64
+target riscv64 has_zfa
 target riscv64 has_c has_zcb
 
 function %floor_f32(f32) -> f32 {
diff --git a/cranelift/filetests/filetests/runtests/fma.clif b/cranelift/filetests/filetests/runtests/fma.clif
index 424abff1c64f..c2638595a56d 100644
--- a/cranelift/filetests/filetests/runtests/fma.clif
+++ b/cranelift/filetests/filetests/runtests/fma.clif
@@ -151,3 +151,73 @@ block0(v0: f32, v1: f32, v2: f32):
     return v4
 }
 ; run: %fma_load_f32(0x9.0, 0x9.0, 0x9.0) == 0x1.680000p6
+
+
+
+
+function %fmsub_f32(f32, f32, f32) -> f32 {
+block0(v0: f32, v1: f32, v2: f32):
+    v3 = fneg v2
+    v4 = fma v0, v1, v3
+    return v4
+}
+; run: %fmsub_f32(0x83.0, 0x2.68091p6, 0x9.88721p1) == 0x1.3af060p14
+; run: %fmsub_f32(-0x83.0, 0x2.68091p6, 0x9.88721p1) == -0x1.3b88e6p14
+; run: %fmsub_f32(-0x83.0, 0x2.68091p6, -0x9.88721p1) == -0x1.3af060p14
+
+
+function %fmsub_f64(f64, f64, f64) -> f64 {
+block0(v0: f64, v1: f64, v2: f64):
+    v3 = fneg v2
+    v4 = fma v0, v1, v3
+    return v4
+}
+; run: %fmsub_f64(0x1.3b88ea148dd4ap14, 0x2.680916809121p6, 0x9.887218721837p1) == 0x1.7ba5badfd4333p21
+; run: %fmsub_f64(-0x1.3b88ea148dd4ap14, 0x2.680916809121p6, 0x9.887218721837p1) == -0x1.7ba6ebee17417p21
+; run: %fmsub_f64(-0x1.3b88ea148dd4ap14, 0x2.680916809121p6, -0x9.887218721837p1) == -0x1.7ba5badfd4333p21
+
+
+
+function %fnmsub_f32(f32, f32, f32) -> f32 {
+block0(v0: f32, v1: f32, v2: f32):
+    v3 = fneg v0
+    v4 = fma v3, v1, v2
+    return v4
+}
+; run: %fnmsub_f32(0x83.0, 0x2.68091p6, 0x9.88721p1) == -0x1.3af060p14
+; run: %fnmsub_f32(-0x83.0, 0x2.68091p6, 0x9.88721p1) == 0x1.3b88e6p14
+; run: %fnmsub_f32(-0x83.0, 0x2.68091p6, -0x9.88721p1) == 0x1.3af060p14
+
+function %fnmsub_f64(f64, f64, f64) -> f64 {
+block0(v0: f64, v1: f64, v2: f64):
+    v3 = fneg v0
+    v4 = fma v3, v1, v2
+    return v4
+}
+; run: %fnmsub_f64(0x1.3b88ea148dd4ap14, 0x2.680916809121p6, 0x9.887218721837p1) == -0x1.7ba5badfd4333p21
+; run: %fnmsub_f64(-0x1.3b88ea148dd4ap14, 0x2.680916809121p6, 0x9.887218721837p1) == 0x1.7ba6ebee17417p21
+; run: %fnmsub_f64(-0x1.3b88ea148dd4ap14, 0x2.680916809121p6, -0x9.887218721837p1) == 0x1.7ba5badfd4333p21
+
+
+
+function %fnmadd_f32(f32, f32, f32) -> f32 {
+block0(v0: f32, v1: f32, v2: f32):
+    v3 = fneg v0
+    v4 = fneg v2
+    v5 = fma v3, v1, v4
+    return v5
+}
+; run: %fnmadd_f32(0x83.0, 0x2.68091p6, 0x9.88721p1) == -0x1.3b88e6p14
+; run: %fnmadd_f32(-0x83.0, 0x2.68091p6, 0x9.88721p1) == 0x1.3af060p14
+; run: %fnmadd_f32(-0x83.0, 0x2.68091p6, -0x9.88721p1) == 0x1.3b88e6p14
+
+function %fnmadd_f64(f64, f64, f64) -> f64 {
+block0(v0: f64, v1: f64, v2: f64):
+    v3 = fneg v0
+    v4 = fneg v2
+    v5 = fma v3, v1, v4
+    return v5
+}
+; run: %fnmadd_f64(0x1.3b88ea148dd4ap14, 0x2.680916809121p6, 0x9.887218721837p1) == -0x1.7ba6ebee17417p21
+; run: %fnmadd_f64(-0x1.3b88ea148dd4ap14, 0x2.680916809121p6, 0x9.887218721837p1) == 0x1.7ba5badfd4333p21
+; run: %fnmadd_f64(-0x1.3b88ea148dd4ap14, 0x2.680916809121p6, -0x9.887218721837p1) == 0x1.7ba6ebee17417p21
diff --git a/cranelift/filetests/filetests/runtests/fmax-pseudo.clif b/cranelift/filetests/filetests/runtests/fmax-pseudo.clif
index 2abf227f8e2e..dcc923adbe88 100644
--- a/cranelift/filetests/filetests/runtests/fmax-pseudo.clif
+++ b/cranelift/filetests/filetests/runtests/fmax-pseudo.clif
@@ -4,6 +4,7 @@ target x86_64
 target x86_64 has_avx
 target aarch64
 target riscv64
+target riscv64 has_zfa
 target riscv64 has_c has_zcb
 target s390x
 
diff --git a/cranelift/filetests/filetests/runtests/fmax.clif b/cranelift/filetests/filetests/runtests/fmax.clif
index da7e23e047f8..e6d0edc83bc5 100644
--- a/cranelift/filetests/filetests/runtests/fmax.clif
+++ b/cranelift/filetests/filetests/runtests/fmax.clif
@@ -5,6 +5,7 @@ target x86_64 has_avx
 target aarch64
 target s390x
 target riscv64
+target riscv64 has_zfa
 target riscv64 has_c has_zcb
 
 function %fmax_f32(f32, f32) -> f32 {
diff --git a/cranelift/filetests/filetests/runtests/fmin-pseudo.clif b/cranelift/filetests/filetests/runtests/fmin-pseudo.clif
index 44ef7b197fca..e6b60b427c8b 100644
--- a/cranelift/filetests/filetests/runtests/fmin-pseudo.clif
+++ b/cranelift/filetests/filetests/runtests/fmin-pseudo.clif
@@ -4,6 +4,7 @@ target x86_64
 target x86_64 has_avx
 target aarch64
 target riscv64
+target riscv64 has_zfa
 target riscv64 has_c has_zcb
 target s390x
 
diff --git a/cranelift/filetests/filetests/runtests/fmin.clif b/cranelift/filetests/filetests/runtests/fmin.clif
index 72c17189635f..4e261502ec10 100644
--- a/cranelift/filetests/filetests/runtests/fmin.clif
+++ b/cranelift/filetests/filetests/runtests/fmin.clif
@@ -5,6 +5,7 @@ target x86_64 has_avx
 target aarch64
 target s390x
 target riscv64
+target riscv64 has_zfa
 target riscv64 has_c has_zcb
 
 function %fmin_f32(f32, f32) -> f32 {
diff --git a/cranelift/filetests/filetests/runtests/i128-arithmetic.clif b/cranelift/filetests/filetests/runtests/i128-arithmetic.clif
index 8fef49972089..e0f0a246faa9 100644
--- a/cranelift/filetests/filetests/runtests/i128-arithmetic.clif
+++ b/cranelift/filetests/filetests/runtests/i128-arithmetic.clif
@@ -23,6 +23,18 @@ block0(v0: i128,v1: i128):
 ; run: %add_i128(0x06060606_06060606_A00A00A0_0A00A00A, 0x30303030_30303030_0BB0BB0B_B0BB0BB0) == 0x36363636_36363636_ABBABBAB_BABBABBA
 ; run: %add_i128(0xC0FFEEEE_C0FFEEEE_C0FFEEEE_C0FFEEEE, 0x1DCB1111_1DCB1111_1DCB1111_1DCB1111) == 0xDECAFFFF_DECAFFFF_DECAFFFF_DECAFFFF
 
+function %add_i128_splats(i64, i64, i64, i64) -> i128 {
+block0(v0: i64, v1: i64, v2: i64, v3: i64):
+    v4 = iconcat v0, v1
+    v5 = iconcat v2, v3
+    v6 = iadd v4, v5
+    return v6
+}
+; run: %add_i128_splats(0, 0, 0, 0) == 0
+; run: %add_i128_splats(1, 0, 0, 0) == 1
+; run: %add_i128_splats(1, 0, 1, 0) == 2
+; run: %add_i128_splats(1, 0, -1, -1) == 0
+
 
 function %sub_i128(i128, i128) -> i128 {
 block0(v0: i128,v1: i128):
@@ -39,6 +51,18 @@ block0(v0: i128,v1: i128):
 ; run: %sub_i128(0x36363636_36363636_ABBABBAB_BABBABBA, 0x30303030_30303030_0BB0BB0B_B0BB0BB0) == 0x06060606_06060606_A00A00A0_0A00A00A
 ; run: %sub_i128(0xDECAFFFF_DECAFFFF_DECAFFFF_DECAFFFF, 0x1DCB1111_1DCB1111_1DCB1111_1DCB1111) == 0xC0FFEEEE_C0FFEEEE_C0FFEEEE_C0FFEEEE
 
+function %sub_i128_splats(i64, i64, i64, i64) -> i128 {
+block0(v0: i64, v1: i64, v2: i64, v3: i64):
+    v4 = iconcat v0, v1
+    v5 = iconcat v2, v3
+    v6 = isub v4, v5
+    return v6
+}
+; run: %sub_i128_splats(0, 0, 0, 0) == 0
+; run: %sub_i128_splats(1, 0, 0, 0) == 1
+; run: %sub_i128_splats(1, 0, 1, 0) == 0
+; run: %sub_i128_splats(1, 0, -1, -1) == 2
+
 
 function %mul_i128(i128, i128) -> i128 {
 block0(v0: i128,v1: i128):
@@ -59,6 +83,17 @@ block0(v0: i128,v1: i128):
 ; run: %mul_i128(0x00000000_01234567_89ABCDEF_00000000, 0x00000000_FEDCBA98_76543210_00000000) == 0x2236D88F_E5618CF0_00000000_00000000
 ; run: %mul_i128(0xC0FFEEEE_C0FFEEEE_C0FFEEEE_C0FFEEEE, 0xDECAFFFF_DECAFFFF_DECAFFFF_DECAFFFF) == 0x5ECD38B5_9D1C2B7E_DB6B1E48_19BA1112
 
+function %mul_i128_splats(i64, i64, i64, i64) -> i128 {
+block0(v0: i64, v1: i64, v2: i64, v3: i64):
+    v4 = iconcat v0, v1
+    v5 = iconcat v2, v3
+    v6 = imul v4, v5
+    return v6
+}
+; run: %mul_i128_splats(0, 0, 0, 0) == 0
+; run: %mul_i128_splats(1, 0, 0, 0) == 0
+; run: %mul_i128_splats(1, 0, 1, 0) == 1
+; run: %mul_i128_splats(1, 0, -1, -1) == -1
 
 ; Tests that imm's are sign extended on i128's
 ; See: https://github.com/bytecodealliance/wasmtime/issues/4568
@@ -68,3 +103,38 @@ block0(v0: i128):
     return v1
 }
 ; run: %iadd_imm_neg(1) == 0
+
+function %mul_uextend_i64(i64, i64) -> i128 {
+block0(v0: i64, v1: i64):
+    v2 = uextend.i128 v0
+    v3 = uextend.i128 v1
+    v4 = imul v2, v3
+    return v4
+}
+; run: %mul_uextend_i64(0, 0) == 0
+; run: %mul_uextend_i64(1, 2) == 2
+; run: %mul_uextend_i64(0x10000000_00000000, 0x10000000_00000000) == 0x1000000000000000000000000000000
+
+function %mul_sextend_i64(i64, i64) -> i128 {
+block0(v0: i64, v1: i64):
+    v2 = sextend.i128 v0
+    v3 = sextend.i128 v1
+    v4 = imul v2, v3
+    return v4
+}
+; run: %mul_sextend_i64(0, 0) == 0
+; run: %mul_sextend_i64(1, 2) == 2
+; run: %mul_sextend_i64(0x10000000_00000000, 0x10000000_00000000) == 0x1000000000000000000000000000000
+; run: %mul_sextend_i64(-2, 200) == -400
+; run: %mul_sextend_i64(300, -4) == -1200
+
+function %fuzz_test_case_4625018733002752() -> i128 {
+block0():
+    v21 = iconst.i64 0x00f5_f500_a7ff_b389
+    v22 = iconst.i64 -8557360460515480319
+    v23 = iconcat v22, v21  ; v22 = -8557360460515480319, v21 = 0x00f5_f500_a7ff_b389
+    v32 = iadd v23, v23
+    return v32
+}
+
+; run: %fuzz_test_case_4625018733002752() == 2554163945374095986207901943416805890
diff --git a/cranelift/filetests/filetests/runtests/i128-bitcast.clif b/cranelift/filetests/filetests/runtests/i128-bitcast.clif
new file mode 100644
index 000000000000..2b4cf930c6c6
--- /dev/null
+++ b/cranelift/filetests/filetests/runtests/i128-bitcast.clif
@@ -0,0 +1,15 @@
+test interpret
+test run
+set enable_llvm_abi_extensions=true
+target aarch64
+target x86_64
+target s390x
+target riscv64
+target riscv64 has_c has_zcb
+
+function %bitcast_i128_i128(i128) -> i128 {
+block0(v0: i128):
+  v1 = bitcast.i128 v0
+  return v1
+}
+; run: %bitcast_i128_i128(0) == 0
diff --git a/cranelift/filetests/filetests/runtests/i128-bitops-count.clif b/cranelift/filetests/filetests/runtests/i128-bitops-count.clif
index d97b5511cec3..0fe625b12c1e 100644
--- a/cranelift/filetests/filetests/runtests/i128-bitops-count.clif
+++ b/cranelift/filetests/filetests/runtests/i128-bitops-count.clif
@@ -3,6 +3,9 @@ set enable_llvm_abi_extensions=true
 target aarch64
 target s390x
 target x86_64
+target x86_64 has_lzcnt
+target x86_64 has_bmi1
+target x86_64 has_popcnt has_sse42
 target riscv64
 target riscv64 has_zbb
 target riscv64 has_zbb has_zbs
diff --git a/cranelift/filetests/filetests/runtests/i128-bitrev.clif b/cranelift/filetests/filetests/runtests/i128-bitrev.clif
index a3bc89eca2d2..c53cf0ba30e5 100644
--- a/cranelift/filetests/filetests/runtests/i128-bitrev.clif
+++ b/cranelift/filetests/filetests/runtests/i128-bitrev.clif
@@ -4,6 +4,9 @@ target aarch64
 target s390x
 target x86_64
 target riscv64
+target riscv64 has_zbb
+target riscv64 has_zbkb
+target riscv64 has_zbb has_zbkb
 target riscv64 has_c has_zcb
 
 function %reverse_bits_zero() -> i8 {
diff --git a/cranelift/filetests/filetests/runtests/i128-iabs.clif b/cranelift/filetests/filetests/runtests/i128-iabs.clif
index c84f2c03e09c..5078f8ac06ed 100644
--- a/cranelift/filetests/filetests/runtests/i128-iabs.clif
+++ b/cranelift/filetests/filetests/runtests/i128-iabs.clif
@@ -1,6 +1,9 @@
 test interpret
 test run
+set enable_llvm_abi_extensions=true
+target aarch64
 target s390x
+target x86_64
 
 function %iabs_i128(i128) -> i128 {
 block0(v0: i128):
@@ -10,4 +13,6 @@ block0(v0: i128):
 ; run: %iabs_i128(0) == 0
 ; run: %iabs_i128(-1) == 1
 ; run: %iabs_i128(1) == 1
+; run: %iabs_i128(0x40000000_00000000_80000000_00000000) == 0x40000000_00000000_80000000_00000000
+; run: %iabs_i128(0x80000000_00000000_80000000_00000000) == 0x7fffffff_ffffffff_80000000_00000000
 ; run: %iabs_i128(0x80000000_00000000_00000000_00000000) == 0x80000000_00000000_00000000_00000000
diff --git a/cranelift/filetests/filetests/runtests/i128-icmp.clif b/cranelift/filetests/filetests/runtests/i128-icmp.clif
index 75559b4b91d3..8db45d6bcc56 100644
--- a/cranelift/filetests/filetests/runtests/i128-icmp.clif
+++ b/cranelift/filetests/filetests/runtests/i128-icmp.clif
@@ -21,6 +21,7 @@ block0(v0: i128, v1: i128):
 ; run: %icmp_eq_i128(0xDECAFFFF_C0FFEEEE_C0FFEEEE_DECAFFFF, 0xDECAFFFF_C0FFEEEE_C0FFEEEE_DECAFFFF) == 1
 ; run: %icmp_eq_i128(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF, 0x00000000_00000001_00000000_00000001) == 0
 ; run: %icmp_eq_i128(0x00000000_00000001_FFFFFFFF_FFFFFFFF, 0x00000000_00000001_00000000_00000001) == 0
+; run: %icmp_eq_i128(0xffffffff_ffffffff, 0) == 0
 
 ; This is a regression test for aarch64, see: https://github.com/bytecodealliance/wasmtime/issues/4705
 ; run: %icmp_eq_i128(36893488147419103231, 0) == 0
@@ -40,6 +41,7 @@ block0(v0: i128, v1: i128):
 ; run: %icmp_ne_i128(0xDECAFFFF_C0FFEEEE_C0FFEEEE_DECAFFFF, 0xDECAFFFF_C0FFEEEE_C0FFEEEE_DECAFFFF) == 0
 ; run: %icmp_ne_i128(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF, 0x00000000_00000001_00000000_00000001) == 1
 ; run: %icmp_ne_i128(0x00000000_00000001_FFFFFFFF_FFFFFFFF, 0x00000000_00000001_00000000_00000001) == 1
+; run: %icmp_ne_i128(0xffffffff_ffffffff, 0) == 1
 
 
 
@@ -57,6 +59,7 @@ block0(v0: i128, v1: i128):
 ; run: %icmp_slt_i128(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == 1
 ; run: %icmp_slt_i128(0xC0FFEEEE_C0FFEEEE_00000000_00000000, 0xDECAFFFF_DECAFFFF_00000000_00000000) == 1
 ; run: %icmp_slt_i128(0xDECAFFFF_DECAFFFF_00000000_00000000, 0xC0FFEEEE_C0FFEEEE_00000000_00000000) == 0
+; run: %icmp_slt_i128(0xffffffff_ffffffff, 0) == 0
 
 
 function %icmp_ult_i128(i128, i128) -> i8 {
@@ -73,6 +76,7 @@ block0(v0: i128, v1: i128):
 ; run: %icmp_ult_i128(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == 1
 ; run: %icmp_ult_i128(0xC0FFEEEE_C0FFEEEE_00000000_00000000, 0xDECAFFFF_DECAFFFF_00000000_00000000) == 1
 ; run: %icmp_ult_i128(0xDECAFFFF_DECAFFFF_00000000_00000000, 0xC0FFEEEE_C0FFEEEE_00000000_00000000) == 0
+; run: %icmp_ult_i128(0xffffffff_ffffffff, 0) == 0
 
 
 function %icmp_sle_i128(i128, i128) -> i8 {
@@ -89,6 +93,7 @@ block0(v0: i128, v1: i128):
 ; run: %icmp_sle_i128(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == 1
 ; run: %icmp_sle_i128(0xC0FFEEEE_C0FFEEEE_00000000_00000000, 0xDECAFFFF_DECAFFFF_00000000_00000000) == 1
 ; run: %icmp_sle_i128(0xDECAFFFF_DECAFFFF_00000000_00000000, 0xC0FFEEEE_C0FFEEEE_00000000_00000000) == 0
+; run: %icmp_sle_i128(0xffffffff_ffffffff, 0) == 0
 
 
 function %icmp_ule_i128(i128, i128) -> i8 {
@@ -105,6 +110,7 @@ block0(v0: i128, v1: i128):
 ; run: %icmp_ule_i128(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == 1
 ; run: %icmp_ule_i128(0xC0FFEEEE_C0FFEEEE_00000000_00000000, 0xDECAFFFF_DECAFFFF_00000000_00000000) == 1
 ; run: %icmp_ule_i128(0xDECAFFFF_DECAFFFF_00000000_00000000, 0xC0FFEEEE_C0FFEEEE_00000000_00000000) == 0
+; run: %icmp_ule_i128(0xffffffff_ffffffff, 0) == 0
 
 
 function %icmp_sgt_i128(i128, i128) -> i8 {
@@ -121,6 +127,7 @@ block0(v0: i128, v1: i128):
 ; run: %icmp_sgt_i128(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == 0
 ; run: %icmp_sgt_i128(0xC0FFEEEE_C0FFEEEE_00000000_00000000, 0xDECAFFFF_DECAFFFF_00000000_00000000) == 0
 ; run: %icmp_sgt_i128(0xDECAFFFF_DECAFFFF_00000000_00000000, 0xC0FFEEEE_C0FFEEEE_00000000_00000000) == 1
+; run: %icmp_sgt_i128(0xffffffff_ffffffff, 0) == 1
 
 
 function %icmp_ugt_i128(i128, i128) -> i8 {
@@ -137,6 +144,7 @@ block0(v0: i128, v1: i128):
 ; run: %icmp_ugt_i128(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == 0
 ; run: %icmp_ugt_i128(0xC0FFEEEE_C0FFEEEE_00000000_00000000, 0xDECAFFFF_DECAFFFF_00000000_00000000) == 0
 ; run: %icmp_ugt_i128(0xDECAFFFF_DECAFFFF_00000000_00000000, 0xC0FFEEEE_C0FFEEEE_00000000_00000000) == 1
+; run: %icmp_ugt_i128(0xffffffff_ffffffff, 0) == 1
 
 
 function %icmp_sge_i128(i128, i128) -> i8 {
@@ -153,6 +161,7 @@ block0(v0: i128, v1: i128):
 ; run: %icmp_sge_i128(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == 0
 ; run: %icmp_sge_i128(0xC0FFEEEE_C0FFEEEE_00000000_00000000, 0xDECAFFFF_DECAFFFF_00000000_00000000) == 0
 ; run: %icmp_sge_i128(0xDECAFFFF_DECAFFFF_00000000_00000000, 0xC0FFEEEE_C0FFEEEE_00000000_00000000) == 1
+; run: %icmp_sge_i128(0xffffffff_ffffffff, 0) == 1
 
 
 function %icmp_uge_i128(i128, i128) -> i8 {
@@ -169,6 +178,7 @@ block0(v0: i128, v1: i128):
 ; run: %icmp_uge_i128(0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFD, 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF) == 0
 ; run: %icmp_uge_i128(0xC0FFEEEE_C0FFEEEE_00000000_00000000, 0xDECAFFFF_DECAFFFF_00000000_00000000) == 0
 ; run: %icmp_uge_i128(0xDECAFFFF_DECAFFFF_00000000_00000000, 0xC0FFEEEE_C0FFEEEE_00000000_00000000) == 1
+; run: %icmp_uge_i128(0xffffffff_ffffffff, 0) == 1
 
 
 ; Icmp Imm Tests
diff --git a/cranelift/filetests/filetests/runtests/icmp-of-icmp.clif b/cranelift/filetests/filetests/runtests/icmp-of-icmp.clif
new file mode 100644
index 000000000000..273d80dacd82
--- /dev/null
+++ b/cranelift/filetests/filetests/runtests/icmp-of-icmp.clif
@@ -0,0 +1,56 @@
+test interpret
+test run
+set opt_level=speed
+target aarch64
+target x86_64
+target s390x
+target riscv64
+target riscv64 has_c has_zcb
+
+function %eq_eq_zero(i8) -> i8 {
+block0(v0: i8):
+    v1 = iconst.i8 5
+    v2 = icmp eq v0, v1
+    v3 = iconst.i8 0
+    v4 = icmp eq v2, v3
+    return v4
+}
+
+; run: %eq_eq_zero(5) == 0
+; run: %eq_eq_zero(3) == 1
+
+function %ne_eq_one(i8) -> i8 {
+block0(v0: i8):
+    v1 = iconst.i8 5
+    v2 = icmp eq v0, v1
+    v3 = iconst.i8 1
+    v4 = icmp ne v2, v3
+    return v4
+}
+
+; run: %ne_eq_one(5) == 0
+; run: %ne_eq_one(3) == 1
+
+function %ne_eq_zero(i8) -> i8 {
+block0(v0: i8):
+    v1 = iconst.i8 5
+    v2 = icmp eq v0, v1
+    v3 = iconst.i8 0
+    v4 = icmp ne v2, v3
+    return v4
+}
+
+; run: %ne_eq_zero(5) == 1
+; run: %ne_eq_zero(3) == 0
+
+function %eq_eq_one(i8) -> i8 {
+block0(v0: i8):
+    v1 = iconst.i8 5
+    v2 = icmp eq v0, v1
+    v3 = iconst.i8 1
+    v4 = icmp eq v2, v3
+    return v4
+}
+
+; run: %eq_eq_one(5) == 1
+; run: %eq_eq_one(3) == 0
diff --git a/cranelift/filetests/filetests/runtests/icmp-uge.clif b/cranelift/filetests/filetests/runtests/icmp-uge.clif
index 72ef20767780..0459baf4317f 100644
--- a/cranelift/filetests/filetests/runtests/icmp-uge.clif
+++ b/cranelift/filetests/filetests/runtests/icmp-uge.clif
@@ -53,3 +53,13 @@ block0(v0: i64, v1: i64):
 ; run: %icmp_uge_i64(0, 1) == 0
 ; run: %icmp_uge_i64(-5, -1) == 0
 ; run: %icmp_uge_i64(1, -1) == 0
+
+
+function %constant_inputs() -> i8 {
+block0:
+    v9 = iconst.i8 128
+    v11 = iconst.i8 0
+    v17 = icmp uge v9, v11
+    return v17
+}
+; run: %constant_inputs() == 1
diff --git a/cranelift/filetests/filetests/runtests/icmp-ugt.clif b/cranelift/filetests/filetests/runtests/icmp-ugt.clif
index 3d2d33056a4b..274444262005 100644
--- a/cranelift/filetests/filetests/runtests/icmp-ugt.clif
+++ b/cranelift/filetests/filetests/runtests/icmp-ugt.clif
@@ -53,3 +53,13 @@ block0(v0: i64, v1: i64):
 ; run: %icmp_ugt_i64(0, 1) == 0
 ; run: %icmp_ugt_i64(-5, -1) == 0
 ; run: %icmp_ugt_i64(1, -1) == 0
+
+
+function %icmp_ugt_const() -> i8  {
+block0:
+    v11 = iconst.i8 196
+    v17 = icmp ugt v11, v11
+    return v17
+}
+
+; run: %icmp_ugt_const() == 0
diff --git a/cranelift/filetests/filetests/runtests/integer-minmax.clif b/cranelift/filetests/filetests/runtests/integer-minmax.clif
index a109cfb536e8..668f257d1844 100644
--- a/cranelift/filetests/filetests/runtests/integer-minmax.clif
+++ b/cranelift/filetests/filetests/runtests/integer-minmax.clif
@@ -4,6 +4,7 @@ target aarch64
 target s390x
 target x86_64
 target riscv64
+target riscv64 has_zbb
 target riscv64 has_c has_zcb
 
 
diff --git a/cranelift/filetests/filetests/runtests/issue-5992.clif b/cranelift/filetests/filetests/runtests/issue-5992.clif
new file mode 100644
index 000000000000..a1d9e3692639
--- /dev/null
+++ b/cranelift/filetests/filetests/runtests/issue-5992.clif
@@ -0,0 +1,36 @@
+test interpret
+test run
+target riscv64
+target aarch64
+target s390x
+
+function %a_f32(f32) -> i16 {
+block0(v0: f32):
+    v1 = fcvt_to_uint_sat.i16 v0
+    return v1
+}
+; run: %a_f32(0x1.949400p21) == -1
+
+
+function %b_f32(f32) -> i8 {
+block0(v0: f32):
+    v1 = fcvt_to_uint_sat.i8 v0
+    return v1
+}
+; run: %b_f32(0x1.949400p21) == -1
+
+
+function %a_f64(f64) -> i16 {
+block0(v0: f64):
+    v1 = fcvt_to_uint_sat.i16 v0
+    return v1
+}
+; run: %a_f64(0x1.949400p21) == -1
+
+
+function %b_f64(f64) -> i8 {
+block0(v0: f64):
+    v1 = fcvt_to_uint_sat.i8 v0
+    return v1
+}
+; run: %b_f64(0x1.949400p21) == -1
diff --git a/cranelift/filetests/filetests/runtests/issue-5993.clif b/cranelift/filetests/filetests/runtests/issue-5993.clif
new file mode 100644
index 000000000000..b19a865b246c
--- /dev/null
+++ b/cranelift/filetests/filetests/runtests/issue-5993.clif
@@ -0,0 +1,19 @@
+test interpret
+test run
+target riscv64
+target aarch64
+target s390x
+
+function %a(f64) -> i8 {
+block0(v0: f64):
+    v1 = fcvt_to_sint_sat.i8 v0
+    return v1
+}
+; run: %a(-0x1.811d818400000p30) == -128
+
+function %b(f64) -> i16 {
+block0(v0: f64):
+    v1 = fcvt_to_sint_sat.i16 v0
+    return v1
+}
+; run: %b(-0x1.811d818400000p30) == -32768
diff --git a/cranelift/filetests/filetests/runtests/nearest.clif b/cranelift/filetests/filetests/runtests/nearest.clif
index ee50e7b3864b..90496d4070db 100644
--- a/cranelift/filetests/filetests/runtests/nearest.clif
+++ b/cranelift/filetests/filetests/runtests/nearest.clif
@@ -7,6 +7,7 @@ target x86_64 sse42 has_avx
 target aarch64
 target s390x
 target riscv64
+target riscv64 has_zfa
 target riscv64 has_c has_zcb
 
 function %nearest_f32(f32) -> f32 {
diff --git a/cranelift/filetests/filetests/runtests/popcnt.clif b/cranelift/filetests/filetests/runtests/popcnt.clif
index 0a93cee98b62..f128e89d1052 100644
--- a/cranelift/filetests/filetests/runtests/popcnt.clif
+++ b/cranelift/filetests/filetests/runtests/popcnt.clif
@@ -3,7 +3,7 @@ test run
 target aarch64
 target s390x
 target x86_64
-target x86_64 has_popcnt
+target x86_64 has_popcnt has_sse42
 target riscv64
 target riscv64 has_c has_zcb
 
diff --git a/cranelift/filetests/filetests/runtests/ref64-invalid-null.clif b/cranelift/filetests/filetests/runtests/ref64-invalid-null.clif
deleted file mode 100644
index b0bca96b780b..000000000000
--- a/cranelift/filetests/filetests/runtests/ref64-invalid-null.clif
+++ /dev/null
@@ -1,44 +0,0 @@
-; Tests for platforms with 64-bit references.
-test run
-target aarch64
-target x86_64
-target s390x
-target riscv64
-target riscv64 has_c has_zcb
-
-function %is_null_true_r64() -> i8 {
-block0:
-  v0 = null.r64
-  v1 = is_null v0
-  return v1
-}
-; run: %is_null_true_r64() == 1
-
-function %is_null_r64(i64) -> i8 {
-block0(v0: i64):
-  v1 = bitcast.r64 v0
-  v2 = is_null v1
-  return v2
-}
-; run: %is_null_r64(256347) == 0
-; run: %is_null_r64(-1) == 0
-; run: %is_null_r64(0) == 1
-
-function %is_invalid_r64(i64) -> i8 {
-block0(v0: i64):
-  v1 = bitcast.r64 v0
-  v2 = is_invalid v1
-  return v2
-}
-; run: %is_invalid_r64(0xffffffffffffffff) == 1
-; run: %is_invalid_r64(-1) == 1
-; run: %is_invalid_r64(256347) == 0
-; run: %is_invalid_r64(0) == 0
-
-function %is_invalid_null_r64() -> i8 {
-block0:
-  v0 = null.r64
-  v1 = is_invalid v0
-  return v1
-}
-; run: %is_invalid_null_r64() == 0
diff --git a/cranelift/filetests/filetests/runtests/return-call-indirect.clif b/cranelift/filetests/filetests/runtests/return-call-indirect.clif
index 155e5f25c081..79155c881ea2 100644
--- a/cranelift/filetests/filetests/runtests/return-call-indirect.clif
+++ b/cranelift/filetests/filetests/runtests/return-call-indirect.clif
@@ -9,7 +9,7 @@ target aarch64 sign_return_address
 target aarch64 has_pauth sign_return_address
 target riscv64
 target riscv64 has_c has_zcb
-;; target s390x
+target s390x
 
 ;;;; Test passing `i64`s ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
@@ -79,3 +79,45 @@ block0(v0: i8):
 }
 ; run: %call_i8(1) == 0
 ; run: %call_i8(0) == 1
+
+;;;; Test passing many arguments on stack ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+function %tail_callee_stack_args(i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64) -> i64 tail {
+block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64, v6: i64, v7: i64, v8: i64, v9: i64, v10: i64, v11: i64, v12: i64, v13: i64, v14: i64, v15: i64, v16: i64, v17: i64, v18: i64, v19: i64, v20: i64, v21: i64, v22: i64, v23: i64, v24: i64, v25: i64):
+    return v25
+}
+
+function %tail_caller_stack_args() -> i64 tail {
+    fn0 = %tail_callee_stack_args(i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64, i64) -> i64 tail
+
+block0:
+    v0 = iconst.i64 10
+    v1 = iconst.i64 15
+    v2 = iconst.i64 20
+    v3 = iconst.i64 25
+    v4 = iconst.i64 30
+    v5 = iconst.i64 35
+    v6 = iconst.i64 40
+    v7 = iconst.i64 45
+    v8 = iconst.i64 50
+    v9 = iconst.i64 55
+    v10 = iconst.i64 60
+    v11 = iconst.i64 65
+    v12 = iconst.i64 70
+    v13 = iconst.i64 75
+    v14 = iconst.i64 80
+    v15 = iconst.i64 85
+    v16 = iconst.i64 90
+    v17 = iconst.i64 95
+    v18 = iconst.i64 100
+    v19 = iconst.i64 105
+    v20 = iconst.i64 110
+    v21 = iconst.i64 115
+    v22 = iconst.i64 120
+    v23 = iconst.i64 125
+    v24 = iconst.i64 130
+    v25 = iconst.i64 135
+    v26 = func_addr.i64 fn0
+    return_call_indirect sig0, v26(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25)
+}
+; run: %tail_caller_stack_args() == 135
diff --git a/cranelift/filetests/filetests/runtests/return-call-loop.clif b/cranelift/filetests/filetests/runtests/return-call-loop.clif
index 53b8cac12eac..e4042dee551e 100644
--- a/cranelift/filetests/filetests/runtests/return-call-loop.clif
+++ b/cranelift/filetests/filetests/runtests/return-call-loop.clif
@@ -6,7 +6,7 @@ target aarch64 sign_return_address
 target aarch64 has_pauth sign_return_address
 target riscv64
 target riscv64 has_c has_zcb
-;; target s390x
+target s390x
 
 ;;;; Tail-Recursive Loop ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
diff --git a/cranelift/filetests/filetests/runtests/return-call.clif b/cranelift/filetests/filetests/runtests/return-call.clif
index bdf9797c7328..2fe1c8aaa5f9 100644
--- a/cranelift/filetests/filetests/runtests/return-call.clif
+++ b/cranelift/filetests/filetests/runtests/return-call.clif
@@ -9,7 +9,7 @@ target aarch64 sign_return_address
 target aarch64 has_pauth sign_return_address
 target riscv64
 target riscv64 has_c has_zcb
-;; target s390x
+target s390x
 
 ;;;; Test passing `i64`s ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
diff --git a/cranelift/filetests/filetests/runtests/select.clif b/cranelift/filetests/filetests/runtests/select.clif
index 7740093e282b..e53e240e2cf5 100644
--- a/cranelift/filetests/filetests/runtests/select.clif
+++ b/cranelift/filetests/filetests/runtests/select.clif
@@ -4,6 +4,7 @@ target aarch64
 target s390x
 target x86_64
 target riscv64
+target riscv64 has_zicond
 target riscv64 has_c has_zcb
 
 function %select_eq_f32(f32, f32) -> i32 {
@@ -139,3 +140,43 @@ block0(v0: i32):
 ; run: %select_overflow_i32(2) == 1
 ; run: %select_overflow_i32(1) == 0
 ; run: %select_overflow_i32(98) == 1
+
+function %select_zero(i64, i64) -> i64 {
+block0(v0: i64, v1: i64):
+  v2 = iconst.i64 0
+  v3 = select.i64 v0, v1, v2
+  return v3
+}
+; run: %select_zero(0, 42) == 0
+; run: %select_zero(42, 42) == 42
+
+function %select_zero_icmp_neq_zero(i64, i64) -> i64 {
+block0(v0: i64, v1: i64):
+  v2 = iconst.i64 0
+  v3 = icmp.i64 ne v0, v2
+  v4 = select.i64 v3, v1, v2
+  return v4
+}
+; run: %select_zero_icmp_neq_zero(0, 42) == 0
+; run: %select_zero_icmp_neq_zero(42, 42) == 42
+
+function %select_icmp_eq_zero(i64, i64, i64) -> i64 {
+block0(v0: i64, v1: i64, v2: i64):
+  v3 = iconst.i64 0
+  v4 = icmp.i64 eq v0, v3
+  v5 = select.i64 v4, v1, v2
+  return v5
+}
+; run: %select_icmp_eq_zero(0, 42, 35) == 42
+; run: %select_icmp_eq_zero(42, 42, 35) == 35
+
+function %select_icmp_ne_zero(i64, i64, i64) -> i64 {
+block0(v0: i64, v1: i64, v2: i64):
+  v3 = iconst.i64 0
+  v4 = icmp.i64 ne v0, v3
+  v5 = select.i64 v4, v1, v2
+  return v5
+}
+; run: %select_icmp_ne_zero(0, 42, 35) == 35
+; run: %select_icmp_ne_zero(42, 42, 35) == 42
+
diff --git a/cranelift/filetests/filetests/runtests/simd-bitcast-64bit.clif b/cranelift/filetests/filetests/runtests/simd-bitcast-64bit.clif
new file mode 100644
index 000000000000..e58678025093
--- /dev/null
+++ b/cranelift/filetests/filetests/runtests/simd-bitcast-64bit.clif
@@ -0,0 +1,36 @@
+test run
+target riscv64 has_v
+target riscv64 has_v has_c has_zcb
+
+function %bitcast_i32x2_to_i64(i32x2) -> i64 {
+block0(v0: i32x2):
+    v1 = bitcast.i64 little v0
+    return v1
+}
+; run: %bitcast_i32x2_to_i64([0xBEEF 0xC0FFEE]) == 0x00c0ffee_0000beef
+; run: %bitcast_i32x2_to_i64([-1 127]) == 0x0000007f_ffffffff
+
+
+function %bitcast_i64_to_i32x2(i64) -> i32x2 {
+block0(v0: i64):
+    v1 = bitcast.i32x2 little v0
+    return v1
+}
+; run: %bitcast_i64_to_i32x2(0x00c0ffee_0000beef) == [0xBEEF 0xC0FFEE]
+; run: %bitcast_i64_to_i32x2(0x0000007f_ffffffff) == [-1 127]
+
+function %bitcast_i32x2_to_f64(i32x2) -> f64 {
+block0(v0: i32x2):
+    v1 = bitcast.f64 little v0
+    return v1
+}
+; run: %bitcast_i32x2_to_f64([0xBEEF 0xC0FFEE]) == 0x1.0ffee0000beefp-1011
+; run: %bitcast_i32x2_to_f64([-1 127]) == 0x0.0007fffffffffp-1022
+
+function %bitcast_f64_to_i32x2(f64) -> i32x2 {
+block0(v0: f64):
+    v1 = bitcast.i32x2 little v0
+    return v1
+}
+; run: %bitcast_f64_to_i32x2(0x1.0ffee0000beefp-1011) == [0xBEEF 0xC0FFEE]
+; run: %bitcast_f64_to_i32x2(0x0.0007fffffffffp-1022) == [-1 127]
diff --git a/cranelift/filetests/filetests/runtests/simd-bitcast-i128.clif b/cranelift/filetests/filetests/runtests/simd-bitcast-i128.clif
new file mode 100644
index 000000000000..08f1d63a0d39
--- /dev/null
+++ b/cranelift/filetests/filetests/runtests/simd-bitcast-i128.clif
@@ -0,0 +1,20 @@
+test run
+target riscv64 has_v
+target riscv64 has_v has_c has_zcb
+
+function %bitcast_i64x2_to_i128(i64x2) -> i128 {
+block0(v0: i64x2):
+    v1 = bitcast.i128 little v0
+    return v1
+}
+; run: %bitcast_i64x2_to_i128([0xBEEF 0xC0FFEE]) == 0x0000000000c0ffee_000000000000beef
+; run: %bitcast_i64x2_to_i128([-1 127]) == 0x000000000000007f_ffffffffffffffff
+
+
+function %bitcast_i128_to_i64x2(i128) -> i64x2 {
+block0(v0: i128):
+    v1 = bitcast.i64x2 little v0
+    return v1
+}
+; run: %bitcast_i128_to_i64x2(0x0000000000c0ffee_000000000000beef) == [0xBEEF 0xC0FFEE]
+; run: %bitcast_i128_to_i64x2(0x000000000000007f_ffffffffffffffff) == [-1 127]
diff --git a/cranelift/filetests/filetests/runtests/simd-bitselect.clif b/cranelift/filetests/filetests/runtests/simd-bitselect.clif
index 7d250c779cd4..6c399ee0343f 100644
--- a/cranelift/filetests/filetests/runtests/simd-bitselect.clif
+++ b/cranelift/filetests/filetests/runtests/simd-bitselect.clif
@@ -94,3 +94,37 @@ block0(v0: i64x2, v1: i64x2, v2: i64x2):
 ; run: %bitwise_bitselect_i64x2(0x11111111111111111111111111111111, 0x11111111111111111111111111111111, 0x00000000000000000000000000000000) == 0x11111111111111111111111111111111
 ; run: %bitwise_bitselect_i64x2(0x01010011000011110000000011111111, 0x11111111111111111111111111111111, 0x00000000000000000000000000000000) == 0x01010011000011110000000011111111
 ; run: %bitwise_bitselect_i64x2(0x00000000000000001111111111111111, 0x00000000000000000000000000000000, 0x11111111111111111111111111111111) == 0x11111111111111110000000000000000
+
+
+;; See issue #8131
+;;
+;; These tests test the fusion of `bitselect+bitcast+{f,i}cmp` that
+;; some backends perform. Importantly the `fcmp` and the `bitselect`
+;; have both different type sizes as well as a different number of
+;; lanes.
+
+function %bitselect_i8x16_fcmp_f64x2(i8x16) -> i8x16 fast {
+    const0 = 0x00000000000000000000000000000000
+
+block0(v0: i8x16):
+    v1 = bitcast.f64x2 little v0
+    v2 = fcmp eq v1, v1
+    v3 = bitcast.i8x16 little v2
+    v4 = vconst.i8x16 const0
+    v5 = bitselect.i8x16 v3, v0, v4  ; v3 = const0
+    return v5
+}
+; run: %bitselect_i8x16_fcmp_f64x2(0x80808080808080808080808080808080) == 0x80808080808080808080808080808080
+
+function %bitselect_i8x16_icmp_i64x2(i8x16) -> i8x16 fast {
+    const0 = 0x00000000000000000000000000000000
+
+block0(v0: i8x16):
+    v1 = bitcast.i64x2 little v0
+    v2 = icmp eq v1, v1
+    v3 = bitcast.i8x16 little v2
+    v4 = vconst.i8x16 const0
+    v5 = bitselect.i8x16 v3, v0, v4  ; v3 = const0
+    return v5
+}
+; run: %bitselect_i8x16_icmp_i64x2(0x80808080808080808080808080808080) == 0x80808080808080808080808080808080
diff --git a/cranelift/filetests/filetests/runtests/simd-fcvt-from-sint.clif b/cranelift/filetests/filetests/runtests/simd-fcvt-from-sint.clif
index f7e2e6571268..d5f86eb2d041 100644
--- a/cranelift/filetests/filetests/runtests/simd-fcvt-from-sint.clif
+++ b/cranelift/filetests/filetests/runtests/simd-fcvt-from-sint.clif
@@ -9,10 +9,18 @@ target x86_64 sse42 has_avx
 target riscv64 has_v
 target riscv64 has_v has_c has_zcb
 
-function %fcvt_from_sint(i32x4) -> f32x4 {
+function %fcvt_from_sint32(i32x4) -> f32x4 {
 block0(v0: i32x4):
     v1 = fcvt_from_sint.f32x4 v0
     return v1
 }
-; run: %fcvt_from_sint([-1 0 1 123456789]) == [-0x1.0 0.0 0x1.0 0x75bcd18.0]
+; run: %fcvt_from_sint32([-1 0 1 123456789]) == [-0x1.0 0.0 0x1.0 0x75bcd18.0]
 ; Note that 123456789 rounds to 123456792.0, an error of 3
+
+function %fcvt_from_sint64(i64x2) -> f64x2 {
+block0(v0: i64x2):
+    v1 = fcvt_from_sint.f64x2 v0
+    return v1
+}
+; run: %fcvt_from_sint64([-1 0]) == [-0x1.0 0.0]
+; run: %fcvt_from_sint64([1 123456789]) == [0x1.0 0x75bcd15.0]
diff --git a/cranelift/filetests/filetests/runtests/simd-fcvt-from-uint.clif b/cranelift/filetests/filetests/runtests/simd-fcvt-from-uint.clif
index fe538379762e..499cf80898c6 100644
--- a/cranelift/filetests/filetests/runtests/simd-fcvt-from-uint.clif
+++ b/cranelift/filetests/filetests/runtests/simd-fcvt-from-uint.clif
@@ -6,14 +6,25 @@ target x86_64
 target x86_64 sse41
 target x86_64 sse42
 target x86_64 sse42 has_avx
+target x86_64 sse42 has_avx has_avx512vl has_avx512f
 target riscv64 has_v
 target riscv64 has_v has_c has_zcb
 
-function %fcvt_from_uint(i32x4) -> f32x4 {
+function %fcvt_from_uint32(i32x4) -> f32x4 {
 block0(v0: i32x4):
     v1 = fcvt_from_uint.f32x4 v0
     return v1
 }
-; run: %fcvt_from_uint([0 0 0 0]) == [0x0.0 0x0.0 0x0.0 0x0.0]
-; run: %fcvt_from_uint([0xFFFFFFFF 0 1 123456789]) == [0x100000000.0 0.0 0x1.0 0x75bcd18.0]
+; run: %fcvt_from_uint32([0 0 0 0]) == [0x0.0 0x0.0 0x0.0 0x0.0]
+; run: %fcvt_from_uint32([0xFFFFFFFF 0 1 123456789]) == [0x100000000.0 0.0 0x1.0 0x75bcd18.0]
 ; Note that 0xFFFFFFFF is decimal 4,294,967,295 and is rounded up 1 to 4,294,967,296 in f32x4.
+
+function %fcvt_from_uint64(i64x2) -> f64x2 {
+block0(v0: i64x2):
+    v1 = fcvt_from_uint.f64x2 v0
+    return v1
+}
+; run: %fcvt_from_uint64([0 0]) == [0x0.0 0x0.0]
+; run: %fcvt_from_uint64([0xFFFFFFFF 0]) == [0xffffffff.0 0.0]
+; run: %fcvt_from_uint64([1 123456789]) == [0x1.0 0x75bcd15.0]
+; run: %fcvt_from_uint64([-1 0x20]) == [0x1.0p64 0x20.0]
diff --git a/cranelift/filetests/filetests/runtests/simd-make-vectors.clif b/cranelift/filetests/filetests/runtests/simd-make-vectors.clif
new file mode 100644
index 000000000000..b90c823264ee
--- /dev/null
+++ b/cranelift/filetests/filetests/runtests/simd-make-vectors.clif
@@ -0,0 +1,39 @@
+test interpret
+test run
+target aarch64
+target s390x
+target x86_64
+target x86_64 sse42
+target x86_64 sse42 has_avx
+target riscv64 has_v
+target riscv64 has_v has_c has_zcb
+
+function %i64x2_make0() -> i64x2 {
+block0:
+    v0 = vconst.i64x2 [0 0]
+    return v0
+}
+
+; run: %i64x2_make0() == [0 0]
+
+function %i64x2_make1(i64) -> i64x2 {
+block0(v0: i64):
+    v1 = vconst.i64x2 [0 0]
+    v2 = insertlane.i64x2 v1, v0, 0
+    return v2
+}
+
+; run: %i64x2_make1(0) == [0 0]
+; run: %i64x2_make1(0x123456789abcdef0) == [0x123456789abcdef0 0]
+
+function %i64x2_make2(i64, i64) -> i64x2 {
+block0(v0: i64, v1: i64):
+    v2 = splat.i64x2 v0
+    v3 = insertlane.i64x2 v2, v1, 1
+    return v3
+}
+
+; run: %i64x2_make2(0, 0) == [0 0]
+; run: %i64x2_make2(0x123456789abcdef0, 0) == [0x123456789abcdef0 0]
+; run: %i64x2_make2(0, 0x123456789abcdef0) == [0 0x123456789abcdef0]
+; run: %i64x2_make2(0x123456789abcdef0, 0x0fedcba987654321) == [0x123456789abcdef0 0x0fedcba987654321]
diff --git a/cranelift/filetests/filetests/runtests/simd-scalartovector.clif b/cranelift/filetests/filetests/runtests/simd-scalartovector.clif
index 5ec07bc47c50..5a92405b6ed1 100644
--- a/cranelift/filetests/filetests/runtests/simd-scalartovector.clif
+++ b/cranelift/filetests/filetests/runtests/simd-scalartovector.clif
@@ -15,6 +15,14 @@ block0(v0: i32):
 ; run: %scalartovector_i32(1) == [1 0 0 0]
 ; run: %scalartovector_i32(4294967295) == [4294967295 0 0 0]
 
+function %scalartovector_i32_imm(i32) -> i32x4 {
+block0(v0: i32):
+    v1 = iconst.i32 7
+    v2 = scalar_to_vector.i32x4 v1
+    return v2
+}
+; run: %scalartovector_i32_imm(1) == [7 0 0 0]
+
 function %scalartovector_i64(i64) -> i64x2 {
 block0(v0: i64):
     v1 = scalar_to_vector.i64x2 v0
@@ -24,6 +32,14 @@ block0(v0: i64):
 ; run: %scalartovector_i64(1) == [1 0]
 ; run: %scalartovector_i64(18446744073709551615) == [18446744073709551615 0]
 
+function %scalartovector_i64_imm(i64) -> i64x2 {
+block0(v0: i64):
+    v1 = iconst.i64 7
+    v2 = scalar_to_vector.i64x2 v1
+    return v2
+}
+; run: %scalartovector_i64_imm(1) == [7 0]
+
 function %scalartovector_f32(f32) -> f32x4 {
 block0(v0: f32):
     v1 = scalar_to_vector.f32x4 v0
diff --git a/cranelift/filetests/filetests/runtests/smulhi.clif b/cranelift/filetests/filetests/runtests/smulhi.clif
index 52a8d4d0ed98..df9f13adf377 100644
--- a/cranelift/filetests/filetests/runtests/smulhi.clif
+++ b/cranelift/filetests/filetests/runtests/smulhi.clif
@@ -8,6 +8,15 @@ target riscv64
 target riscv64 has_c has_zcb
 
 
+function %smulhi_i8(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = smulhi v0, v1
+    return v2
+}
+; run: %smulhi_i8(-2, -4) == 0
+; run: %smulhi_i8(2, -4) == -1
+; run: %smulhi_i8(255, 255) == 0
+
 function %smulhi_i16(i16, i16) -> i16 {
 block0(v0: i16, v1: i16):
     v2 = smulhi v0, v1
diff --git a/cranelift/filetests/filetests/runtests/tail-call-conv.clif b/cranelift/filetests/filetests/runtests/tail-call-conv.clif
index 195bc82ac2e2..aa403b175523 100644
--- a/cranelift/filetests/filetests/runtests/tail-call-conv.clif
+++ b/cranelift/filetests/filetests/runtests/tail-call-conv.clif
@@ -1,15 +1,14 @@
 test interpret
 test run
+set enable_llvm_abi_extensions
+set preserve_frame_pointers
 target x86_64
 target aarch64
 target aarch64 sign_return_address
 target aarch64 has_pauth sign_return_address
 target riscv64
 target riscv64 has_c has_zcb
-
-;; TODO(#6530): s390x doesn't support the `tail` calling convention yet.
-;;
-;; target s390x
+target s390x
 
 ;; Test the `tail` calling convention with non-tail calls.
 
@@ -125,3 +124,24 @@ block0:
 }
 
 ; run: %tail_caller_stack_rets() == 135
+
+
+;; Test that tail calls that shrink the argument area don't clobber the location
+;; of an indirect jump
+
+function %g() -> i8 tail {
+block0:
+    v0 = iconst.i8 0
+    return v0
+}
+
+function %f(f64, f64, i8, i32 sext, i128, i32 sext, i128, i32, i128) -> i8 tail {
+    sig0 = () -> i8 tail
+    fn0 = %g sig0
+
+block0(v0: f64, v1: f64, v2: i8, v3: i32, v4: i128, v5: i32, v6: i128, v7: i32, v8: i128):
+    v14 = func_addr.i64 fn0
+    return_call_indirect sig0, v14()
+}
+
+; run: %f(0.0, 0.0, 0, 0, 0, 0, 0, 0, 0) == 0
diff --git a/cranelift/filetests/filetests/runtests/trunc.clif b/cranelift/filetests/filetests/runtests/trunc.clif
index c858e6505d37..d2386d4258eb 100644
--- a/cranelift/filetests/filetests/runtests/trunc.clif
+++ b/cranelift/filetests/filetests/runtests/trunc.clif
@@ -7,6 +7,7 @@ target x86_64 sse42 has_avx
 target aarch64
 target s390x
 target riscv64
+target riscv64 has_zfa
 target riscv64 has_c has_zcb
 
 function %trunc_f32(f32) -> f32 {
diff --git a/cranelift/filetests/filetests/runtests/umulhi.clif b/cranelift/filetests/filetests/runtests/umulhi.clif
index 464a2bc6700a..51d4eee45d92 100644
--- a/cranelift/filetests/filetests/runtests/umulhi.clif
+++ b/cranelift/filetests/filetests/runtests/umulhi.clif
@@ -6,6 +6,14 @@ target s390x
 target riscv64
 target riscv64 has_c has_zcb
 
+function %umulhi_i8(i8, i8) -> i8 {
+block0(v0: i8, v1: i8):
+    v2 = umulhi v0, v1
+    return v2
+}
+; run: %umulhi_i8(2, 4) == 0
+; run: %umulhi_i8(255, 255) == 254
+
 function %umulhi_i16(i16, i16) -> i16 {
 block0(v0: i16, v1: i16):
     v2 = umulhi v0, v1
diff --git a/cranelift/filetests/filetests/runtests/urem.clif b/cranelift/filetests/filetests/runtests/urem.clif
index 42297ad37a2b..3fa2024240f8 100644
--- a/cranelift/filetests/filetests/runtests/urem.clif
+++ b/cranelift/filetests/filetests/runtests/urem.clif
@@ -135,3 +135,13 @@ block0(v0: i8):
 ; run: %urem_imm_i8(-19) == 0
 ; run: %urem_imm_i8(0xC0) == 0
 ; run: %urem_imm_i8(0x80) == 2
+
+
+function %constant_inputs() -> i8  {
+block0:
+    v3 = iconst.i8 208
+    v11 = urem v3, v3  ; v3 = 208, v3 = 208
+    return v11
+}
+
+; run: %constant_inputs() == 0
diff --git a/cranelift/filetests/filetests/runtests/winch.clif b/cranelift/filetests/filetests/runtests/winch.clif
new file mode 100644
index 000000000000..33d8baf6c0e5
--- /dev/null
+++ b/cranelift/filetests/filetests/runtests/winch.clif
@@ -0,0 +1,51 @@
+test run
+target x86_64
+
+function %reverse_args(i32, i64, i32, i64) -> i64, i32, i64, i32 winch {
+block0(v0: i32, v1: i64, v2: i32, v3: i64):
+    return v3, v2, v1, v0
+}
+
+function %call_winch() -> i64, i32, i64, i32 {
+    fn0 = %reverse_args(i32, i64, i32, i64) -> i64, i32, i64, i32 winch
+
+block0:
+    v0 = iconst.i32 0
+    v1 = iconst.i64 1
+    v2 = iconst.i32 2
+    v3 = iconst.i64 3
+    v4, v5, v6, v7 = call fn0(v0, v1, v2, v3)
+    return v4, v5, v6, v7
+}
+
+; run: %call_winch() == [3, 2, 1, 0]
+
+function %f1() -> i8 uext, i64, i8 uext winch {
+block0:
+    v0 = iconst.i64 0x40070000ffff2222
+    v1 = iconst.i8 85
+    v2 = iconst.i8 11
+    return v1, v0, v2
+}
+
+; run: %f1() == [85, 0x40070000ffff2222, 11]
+
+function %f2() -> i64, i8 uext, i8 uext winch {
+block0:
+    v0 = iconst.i64 0x00000000ffff2222
+    v1 = iconst.i8 85
+    v2 = iconst.i8 11
+    return v0, v1, v2
+}
+
+; run: %f2() == [0x00000000ffff2222, 85, 11]
+
+function %f3() -> f64, i8, i8 winch {
+block0:
+    v0 = f64const 0x0.400070088f700p-1022
+    v1 = iconst.i8 85
+    v2 = iconst.i8 11
+    return v0, v1, v2
+}
+
+; run: %f3() == [0x0.400070088f700p-1022, 85, 11]
diff --git a/cranelift/filetests/filetests/runtests/x64/fmsub.clif b/cranelift/filetests/filetests/runtests/x64/fmsub.clif
new file mode 100644
index 000000000000..412954e1901e
--- /dev/null
+++ b/cranelift/filetests/filetests/runtests/x64/fmsub.clif
@@ -0,0 +1,91 @@
+test interpret
+test run
+target x86_64 has_avx has_fma
+
+;; testing load sinkind on fmsub and fmnsub instructions
+function %fmsub_f32(f32, f32, f32) -> f32 {
+    ss0 = explicit_slot 4
+block0(v0: f32, v1: f32, v2: f32):
+    v3 = stack_addr.i64 ss0
+    store.f32 v1, v3
+    v4 = load.f32 v3
+    v5 = fneg v2
+    v6 = fma v0, v4, v5
+    return v6
+}
+; run: %fmsub_f32(0x83.0, 0x2.68091p6, 0x9.88721p1) == 0x1.3af060p14
+; run: %fmsub_f32(-0x83.0, 0x2.68091p6, 0x9.88721p1) == -0x1.3b88e6p14
+; run: %fmsub_f32(-0x83.0, 0x2.68091p6, -0x9.88721p1) == -0x1.3af060p14
+
+
+function %fmnsub_f32(f32, f32, f32) -> f32 {
+    ss0 = explicit_slot 4
+block0(v0: f32, v1: f32, v2: f32):
+    v3 = stack_addr.i64 ss0
+    v4 = fneg v1
+    store.f32 v4, v3
+    v5 = load.f32 v3
+    v6 = fneg v2
+    v7 = fma v0, v5, v6
+    return v7
+}
+; run: %fmnsub_f32(0x83.0, -0x2.68091p6, 0x9.88721p1) == 0x1.3af060p14
+; run: %fmnsub_f32(-0x83.0, -0x2.68091p6, 0x9.88721p1) == -0x1.3b88e6p14
+; run: %fmnsub_f32(-0x83.0, -0x2.68091p6, -0x9.88721p1) == -0x1.3af060p14
+
+;; load first, then negate
+function %fmnsub_f32_load_first(f32, f32, f32) -> f32 {
+    ss0 = explicit_slot 4
+block0(v0: f32, v1: f32, v2: f32):
+    v3 = stack_addr.i64 ss0
+    store.f32 v1, v3
+    v4 = load.f32 v3
+    v5 = fneg v4
+    v6 = fneg v2
+    v7 = fma v0, v5, v6
+    return v7
+}
+; run: %fmnsub_f32_load_first(0x83.0, -0x2.68091p6, 0x9.88721p1) == 0x1.3af060p14
+; run: %fmnsub_f32_load_first(-0x83.0, -0x2.68091p6, 0x9.88721p1) == -0x1.3b88e6p14
+; run: %fmnsub_f32_load_first(-0x83.0, -0x2.68091p6, -0x9.88721p1) == -0x1.3af060p14
+
+function %fnmsub_f64(f64, f64, f64) -> f64 {
+    ss0 = explicit_slot 16
+block0(v0: f64, v1: f64, v2: f64):
+    v3 = stack_addr.i64 ss0
+    store.f64 v2, v3
+    v4 = load.f64 v3
+    v5 = fneg v0
+    v6 = fneg v4
+    v7 = fma v5, v1, v6
+    return v7
+}
+; run: %fnmsub_f64(0x1.3b88ea148dd4ap14, 0x2.680916809121p6, 0x9.887218721837p1) == -0x1.7ba6ebee17417p21
+; run: %fnmsub_f64(-0x1.3b88ea148dd4ap14, 0x2.680916809121p6, 0x9.887218721837p1) == 0x1.7ba5badfd4333p21
+; run: %fnmsub_f64(-0x1.3b88ea148dd4ap14, 0x2.680916809121p6, -0x9.887218721837p1) == 0x1.7ba6ebee17417p21
+
+function %fmsub_f64(f64, f64, f64) -> f64 {
+    ss0 = explicit_slot 16
+block0(v0: f64, v1: f64, v2: f64):
+    v3 = stack_addr.i64 ss0
+    store.f64 v2, v3
+    v4 = load.f64 v3
+    v5 = fneg v4
+    v6 = fma v0, v1, v5
+    return v6
+}
+; run: %fmsub_f64(-0x1.3b88ea148dd4ap14, 0x2.680916809121p6, 0x9.887218721837p1) == -0x1.7ba6ebee17417p21
+; run: %fmsub_f64(0x1.3b88ea148dd4ap14, 0x2.680916809121p6, 0x9.887218721837p1) == 0x1.7ba5badfd4333p21
+; run: %fmsub_f64(0x1.3b88ea148dd4ap14, 0x2.680916809121p6, -0x9.887218721837p1) == 0x1.7ba6ebee17417p21
+
+function %fmsub_f32x4(f32x4, f32x4, f32x4) -> f32x4 {
+    ss0 = explicit_slot 16
+block0(v0: f32x4, v1: f32x4, v2: f32x4):
+    v3 = stack_addr.i64 ss0
+    store.f32x4 v0, v3
+    v4 = load.f32x4 v3
+    v5 = fneg v2
+    v6 = fma v4, v1, v5
+    return v6
+}
+; run: %fmsub_f32x4([0x9.0 0x83.0 0x1.99999ap-2 -0x1.4cccccp0], [0x9.0 0x2.68091p6 0x1.333334p-1 -0x1.666666p1], [-0x9.0 -0x9.88721p1 -0x1.400000p1 0x1.b33334p0]) == [0x1.680000p6 0x1.3b88e6p14 0x1.5eb852p1 0x1.f0a3d2p0]
diff --git a/cranelift/filetests/filetests/verifier/table.clif b/cranelift/filetests/filetests/verifier/table.clif
deleted file mode 100644
index 4cbfa79ce790..000000000000
--- a/cranelift/filetests/filetests/verifier/table.clif
+++ /dev/null
@@ -1,46 +0,0 @@
-test verifier
-target x86_64
-
-function %table_base_type(i64 vmctx) {
-    gv0 = vmctx
-    gv1 = load.i32 notrap aligned gv0
-    table0 = dynamic gv1, element_size 1, bound gv1, index_type i32 ; error: table base has type i32, which is not the pointer type i64
-
-block0(v0: i64):
-    return
-}
-
-function %invalid_base(i64 vmctx) {
-    gv0 = vmctx
-    table0 = dynamic gv1, bound gv0, element_size 1, index_type i64 ; error: invalid base global value gv1
-
-block0(v0: i64):
-    return
-}
-
-function %invalid_bound(i64 vmctx) {
-    gv0 = vmctx
-    table0 = dynamic gv0, bound gv1, element_size 1, index_type i64 ; error: invalid bound global value gv1
-
-block0(v0: i64):
-    return
-}
-
-function %table_bound_type(i64 vmctx) {
-    gv0 = vmctx
-    gv1 = load.i16 notrap aligned gv0
-    table0 = dynamic gv0, bound gv1, element_size 1, index_type i32 ; error: table index type i32 differs from the type of its bound, i16
-
-block0(v0: i64):
-    return
-}
-
-function %table_addr_index_type(i64 vmctx, i64) {
-    gv0 = vmctx
-    gv1 = load.i32 notrap aligned gv0
-    table0 = dynamic gv0, element_size 1, bound gv1, index_type i32
-
-block0(v0: i64, v1: i64):
-    v2 = table_addr.i64 table0, v1+0; error: index type i64 differs from table index type i32
-    return
-}
diff --git a/cranelift/filetests/filetests/wasm/aarch64-relaxed-simd.wat b/cranelift/filetests/filetests/wasm/aarch64-relaxed-simd.wat
deleted file mode 100644
index b1a0bcd4cb87..000000000000
--- a/cranelift/filetests/filetests/wasm/aarch64-relaxed-simd.wat
+++ /dev/null
@@ -1,87 +0,0 @@
-;;! target = "aarch64"
-;;! compile = true
-
-(module
-  (func (param v128) (result v128)
-    local.get 0
-    i32x4.relaxed_trunc_f32x4_s
-  )
-
-  (func (param v128) (result v128)
-    local.get 0
-    i32x4.relaxed_trunc_f32x4_u
-  )
-
-  (func (param v128) (result v128)
-    local.get 0
-    i32x4.relaxed_trunc_f64x2_s_zero
-  )
-
-  (func (param v128) (result v128)
-    local.get 0
-    i32x4.relaxed_trunc_f64x2_u_zero
-  )
-
-  (func (param v128 v128) (result v128)
-    local.get 0
-    local.get 1
-    i16x8.relaxed_dot_i8x16_i7x16_s
-  )
-
-  (func (param v128 v128 v128) (result v128)
-    local.get 0
-    local.get 1
-    local.get 2
-    i32x4.relaxed_dot_i8x16_i7x16_add_s
-  )
-)
-
-;; function u0:0:
-;; block0:
-;;   fcvtzs v0.4s, v0.4s
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:1:
-;; block0:
-;;   fcvtzu v0.4s, v0.4s
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:2:
-;; block0:
-;;   fcvtzs v4.2d, v0.2d
-;;   sqxtn v0.2s, v4.2d
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:3:
-;; block0:
-;;   fcvtzu v4.2d, v0.2d
-;;   uqxtn v0.2s, v4.2d
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:4:
-;; block0:
-;;   smull v6.8h, v0.8b, v1.8b
-;;   smull2 v7.8h, v0.16b, v1.16b
-;;   addp v0.8h, v6.8h, v7.8h
-;;   b label1
-;; block1:
-;;   ret
-;;
-;; function u0:5:
-;; block0:
-;;   smull v17.8h, v0.8b, v1.8b
-;;   smull2 v18.8h, v0.16b, v1.16b
-;;   addp v17.8h, v17.8h, v18.8h
-;;   saddlp v17.4s, v17.8h
-;;   add v0.4s, v17.4s, v2.4s
-;;   b label1
-;; block1:
-;;   ret
diff --git a/cranelift/filetests/filetests/wasm/basic-wat-test.wat b/cranelift/filetests/filetests/wasm/basic-wat-test.wat
deleted file mode 100644
index f42bc37bf720..000000000000
--- a/cranelift/filetests/filetests/wasm/basic-wat-test.wat
+++ /dev/null
@@ -1,45 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0
-;;! offset_guard_size = 0xFFFFFFFF
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x1000 }
-
-(module
-  (memory 0)
-  (func (param i32 i32) (result i32)
-    local.get 0
-    i32.load
-    local.get 1
-    i32.load
-    i32.add))
-
-;; function u0:0(i32, i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0021                               v4 = uextend.i64 v0
-;; @0021                               v5 = global_value.i64 gv1
-;; @0021                               v6 = iadd v5, v4
-;; @0021                               v7 = load.i32 little heap v6
-;; @0026                               v8 = uextend.i64 v1
-;; @0026                               v9 = global_value.i64 gv1
-;; @0026                               v10 = iadd v9, v8
-;; @0026                               v11 = load.i32 little heap v10
-;; @0029                               v12 = iadd v7, v11
-;; @002a                               jump block1(v12)
-;;
-;;                                 block1(v3: i32):
-;; @002a                               return v3
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/duplicate-loads-dynamic-memory.wat b/cranelift/filetests/filetests/wasm/duplicate-loads-dynamic-memory.wat
deleted file mode 100644
index 7d00c81bfdd5..000000000000
--- a/cranelift/filetests/filetests/wasm/duplicate-loads-dynamic-memory.wat
+++ /dev/null
@@ -1,87 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! optimize = true
-;;!
-;;! settings = [
-;;!   "enable_heap_access_spectre_mitigation=true",
-;;!   "opt_level=speed_and_size",
-;;! ]
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0 }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8 }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-(module
-  (memory (export "memory") 0)
-  (func (export "load-without-offset") (param i32) (result i32 i32)
-    local.get 0
-    i32.load
-    local.get 0
-    i32.load
-  )
-  (func (export "load-with-offset") (param i32) (result i32 i32)
-    local.get 0
-    i32.load offset=1234
-    local.get 0
-    i32.load offset=1234
-  )
-)
-
-;; function u0:0(i32, i64 vmctx) -> i32, i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned gv0+8
-;;     gv2 = load.i64 notrap aligned gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0057                               v5 = load.i64 notrap aligned v1+8
-;; @0057                               v7 = load.i64 notrap aligned v1
-;; @0057                               v4 = uextend.i64 v0
-;; @0057                               v6 = icmp ugt v4, v5
-;; @0057                               v9 = iconst.i64 0
-;; @0057                               v8 = iadd v7, v4
-;; @0057                               v10 = select_spectre_guard v6, v9, v8  ; v9 = 0
-;; @0057                               v11 = load.i32 little heap v10
-;;                                     v2 -> v11
-;; @005f                               jump block1
-;;
-;;                                 block1:
-;; @005f                               return v11, v11
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32, i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned gv0+8
-;;     gv2 = load.i64 notrap aligned gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0064                               v5 = load.i64 notrap aligned v1+8
-;; @0064                               v7 = load.i64 notrap aligned v1
-;; @0064                               v4 = uextend.i64 v0
-;; @0064                               v6 = icmp ugt v4, v5
-;; @0064                               v10 = iconst.i64 0
-;; @0064                               v8 = iadd v7, v4
-;;                                     v22 = iconst.i64 1234
-;; @0064                               v9 = iadd v8, v22  ; v22 = 1234
-;; @0064                               v11 = select_spectre_guard v6, v10, v9  ; v10 = 0
-;; @0064                               v12 = load.i32 little heap v11
-;;                                     v2 -> v12
-;; @006e                               jump block1
-;;
-;;                                 block1:
-;; @006e                               return v12, v12
-;; }
diff --git a/cranelift/filetests/filetests/wasm/duplicate-loads-static-memory.wat b/cranelift/filetests/filetests/wasm/duplicate-loads-static-memory.wat
deleted file mode 100644
index 16a4fe413335..000000000000
--- a/cranelift/filetests/filetests/wasm/duplicate-loads-static-memory.wat
+++ /dev/null
@@ -1,73 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! optimize = true
-;;!
-;;! settings = [
-;;!   "enable_heap_access_spectre_mitigation=true",
-;;!   "opt_level=speed_and_size",
-;;! ]
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-(module
-  (memory (export "memory") 1)
-  (func (export "load-without-offset") (param i32) (result i32 i32)
-    local.get 0
-    i32.load
-    local.get 0
-    i32.load
-  )
-  (func (export "load-with-offset") (param i32) (result i32 i32)
-    local.get 0
-    i32.load offset=1234
-    local.get 0
-    i32.load offset=1234
-  )
-)
-
-;; function u0:0(i32, i64 vmctx) -> i32, i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0057                               v5 = load.i64 notrap aligned readonly v1
-;; @0057                               v4 = uextend.i64 v0
-;; @0057                               v6 = iadd v5, v4
-;; @0057                               v7 = load.i32 little heap v6
-;;                                     v2 -> v7
-;; @005f                               jump block1
-;;
-;;                                 block1:
-;; @005f                               return v7, v7
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32, i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0064                               v5 = load.i64 notrap aligned readonly v1
-;; @0064                               v4 = uextend.i64 v0
-;; @0064                               v6 = iadd v5, v4
-;;                                     v14 = iconst.i64 1234
-;; @0064                               v7 = iadd v6, v14  ; v14 = 1234
-;; @0064                               v8 = load.i32 little heap v7
-;;                                     v2 -> v8
-;; @006e                               jump block1
-;;
-;;                                 block1:
-;; @006e                               return v8, v8
-;; }
diff --git a/cranelift/filetests/filetests/wasm/dynamic-memory-no-spectre-access-same-index-different-offsets.wat b/cranelift/filetests/filetests/wasm/dynamic-memory-no-spectre-access-same-index-different-offsets.wat
deleted file mode 100644
index d3f19dfe5266..000000000000
--- a/cranelift/filetests/filetests/wasm/dynamic-memory-no-spectre-access-same-index-different-offsets.wat
+++ /dev/null
@@ -1,153 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! optimize = true
-;;!
-;;! settings = [
-;;!   "enable_heap_access_spectre_mitigation=false",
-;;!   "opt_level=speed_and_size",
-;;! ]
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0 }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8 }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0
-;;! offset_guard_size = 0x0000ffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-(module
-  (memory (export "memory") 0)
-
-  (func (export "loads") (param i32) (result i32 i32 i32)
-    ;; Within the guard region.
-    local.get 0
-    i32.load offset=0
-    ;; Also within the guard region, bounds check should GVN with previous.
-    local.get 0
-    i32.load offset=4
-    ;; Outside the guard region, needs additional bounds checks.
-    local.get 0
-    i32.load offset=0x000fffff
-  )
-
-  ;; Same as above, but for stores.
-  (func (export "stores") (param i32 i32 i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0
-    local.get 0
-    local.get 2
-    i32.store offset=4
-    local.get 0
-    local.get 3
-    i32.store offset=0x000fffff
-  )
-)
-
-;; function u0:0(i32, i64 vmctx) -> i32, i32, i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned gv0+8
-;;     gv2 = load.i64 notrap aligned gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0047                               v6 = load.i64 notrap aligned v1+8
-;; @0047                               v5 = uextend.i64 v0
-;; @0047                               v7 = icmp ugt v5, v6
-;; @0047                               brif v7, block2, block3
-;;
-;;                                 block2 cold:
-;; @0047                               trap heap_oob
-;;
-;;                                 block3:
-;; @0047                               v8 = load.i64 notrap aligned v1
-;; @0047                               v9 = iadd v8, v5
-;; @0047                               v10 = load.i32 little heap v9
-;;                                     v2 -> v10
-;; @004c                               brif.i8 v7, block4, block5
-;;
-;;                                 block4 cold:
-;; @004c                               trap heap_oob
-;;
-;;                                 block5:
-;;                                     v27 = iconst.i64 4
-;; @004c                               v16 = iadd.i64 v9, v27  ; v27 = 4
-;; @004c                               v17 = load.i32 little heap v16
-;;                                     v3 -> v17
-;; @0051                               v19 = iconst.i64 0x0010_0003
-;; @0051                               v20 = uadd_overflow_trap.i64 v5, v19, heap_oob  ; v19 = 0x0010_0003
-;; @0051                               v22 = icmp ugt v20, v6
-;; @0051                               brif v22, block6, block7
-;;
-;;                                 block6 cold:
-;; @0051                               trap heap_oob
-;;
-;;                                 block7:
-;; @0051                               v23 = load.i64 notrap aligned v1
-;; @0051                               v24 = iadd v23, v5
-;;                                     v28 = iconst.i64 0x000f_ffff
-;; @0051                               v25 = iadd v24, v28  ; v28 = 0x000f_ffff
-;; @0051                               v26 = load.i32 little heap v25
-;;                                     v4 -> v26
-;; @0056                               jump block1
-;;
-;;                                 block1:
-;; @0056                               return v10, v17, v26
-;; }
-;;
-;; function u0:1(i32, i32, i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned gv0+8
-;;     gv2 = load.i64 notrap aligned gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i32, v3: i32, v4: i64):
-;; @005d                               v6 = load.i64 notrap aligned v4+8
-;; @005d                               v5 = uextend.i64 v0
-;; @005d                               v7 = icmp ugt v5, v6
-;; @005d                               brif v7, block2, block3
-;;
-;;                                 block2 cold:
-;; @005d                               trap heap_oob
-;;
-;;                                 block3:
-;; @005d                               v8 = load.i64 notrap aligned v4
-;; @005d                               v9 = iadd v8, v5
-;; @005d                               store.i32 little heap v1, v9
-;; @0064                               brif.i8 v7, block4, block5
-;;
-;;                                 block4 cold:
-;; @0064                               trap heap_oob
-;;
-;;                                 block5:
-;;                                     v24 = iconst.i64 4
-;; @0064                               v15 = iadd.i64 v9, v24  ; v24 = 4
-;; @0064                               store.i32 little heap v2, v15
-;; @006b                               v17 = iconst.i64 0x0010_0003
-;; @006b                               v18 = uadd_overflow_trap.i64 v5, v17, heap_oob  ; v17 = 0x0010_0003
-;; @006b                               v20 = icmp ugt v18, v6
-;; @006b                               brif v20, block6, block7
-;;
-;;                                 block6 cold:
-;; @006b                               trap heap_oob
-;;
-;;                                 block7:
-;; @006b                               v21 = load.i64 notrap aligned v4
-;; @006b                               v22 = iadd v21, v5
-;;                                     v25 = iconst.i64 0x000f_ffff
-;; @006b                               v23 = iadd v22, v25  ; v25 = 0x000f_ffff
-;; @006b                               store.i32 little heap v3, v23
-;; @0070                               jump block1
-;;
-;;                                 block1:
-;; @0070                               return
-;; }
diff --git a/cranelift/filetests/filetests/wasm/dynamic-memory-yes-spectre-access-same-index-different-offsets.wat b/cranelift/filetests/filetests/wasm/dynamic-memory-yes-spectre-access-same-index-different-offsets.wat
deleted file mode 100644
index c31b82338eb6..000000000000
--- a/cranelift/filetests/filetests/wasm/dynamic-memory-yes-spectre-access-same-index-different-offsets.wat
+++ /dev/null
@@ -1,121 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! optimize = true
-;;!
-;;! settings = [
-;;!   "enable_heap_access_spectre_mitigation=true",
-;;!   "opt_level=speed_and_size",
-;;! ]
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0 }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8 }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0
-;;! offset_guard_size = 0x0000ffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-(module
-  (memory (export "memory") 0)
-
-  (func (export "loads") (param i32) (result i32 i32 i32)
-    ;; Within the guard region.
-    local.get 0
-    i32.load offset=0
-    ;; Also within the guard region, bounds check should GVN with previous.
-    local.get 0
-    i32.load offset=4
-    ;; Outside the guard region, needs additional bounds checks.
-    local.get 0
-    i32.load offset=0x000fffff
-  )
-
-  ;; Same as above, but for stores.
-  (func (export "stores") (param i32 i32 i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0
-    local.get 0
-    local.get 2
-    i32.store offset=4
-    local.get 0
-    local.get 3
-    i32.store offset=0x000fffff
-  )
-)
-
-;; function u0:0(i32, i64 vmctx) -> i32, i32, i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned gv0+8
-;;     gv2 = load.i64 notrap aligned gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0047                               v6 = load.i64 notrap aligned v1+8
-;; @0047                               v8 = load.i64 notrap aligned v1
-;; @0047                               v5 = uextend.i64 v0
-;; @0047                               v7 = icmp ugt v5, v6
-;; @0047                               v10 = iconst.i64 0
-;; @0047                               v9 = iadd v8, v5
-;; @0047                               v11 = select_spectre_guard v7, v10, v9  ; v10 = 0
-;; @0047                               v12 = load.i32 little heap v11
-;;                                     v2 -> v12
-;;                                     v33 = iconst.i64 4
-;; @004c                               v18 = iadd v9, v33  ; v33 = 4
-;; @004c                               v20 = select_spectre_guard v7, v10, v18  ; v10 = 0
-;; @004c                               v21 = load.i32 little heap v20
-;;                                     v3 -> v21
-;; @0051                               v23 = iconst.i64 0x0010_0003
-;; @0051                               v24 = uadd_overflow_trap v5, v23, heap_oob  ; v23 = 0x0010_0003
-;; @0051                               v26 = icmp ugt v24, v6
-;;                                     v34 = iconst.i64 0x000f_ffff
-;; @0051                               v29 = iadd v9, v34  ; v34 = 0x000f_ffff
-;; @0051                               v31 = select_spectre_guard v26, v10, v29  ; v10 = 0
-;; @0051                               v32 = load.i32 little heap v31
-;;                                     v4 -> v32
-;; @0056                               jump block1
-;;
-;;                                 block1:
-;; @0056                               return v12, v21, v32
-;; }
-;;
-;; function u0:1(i32, i32, i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned gv0+8
-;;     gv2 = load.i64 notrap aligned gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i32, v3: i32, v4: i64):
-;; @005d                               v6 = load.i64 notrap aligned v4+8
-;; @005d                               v8 = load.i64 notrap aligned v4
-;; @005d                               v5 = uextend.i64 v0
-;; @005d                               v7 = icmp ugt v5, v6
-;; @005d                               v10 = iconst.i64 0
-;; @005d                               v9 = iadd v8, v5
-;; @005d                               v11 = select_spectre_guard v7, v10, v9  ; v10 = 0
-;; @005d                               store little heap v1, v11
-;;                                     v30 = iconst.i64 4
-;; @0064                               v17 = iadd v9, v30  ; v30 = 4
-;; @0064                               v19 = select_spectre_guard v7, v10, v17  ; v10 = 0
-;; @0064                               store little heap v2, v19
-;; @006b                               v21 = iconst.i64 0x0010_0003
-;; @006b                               v22 = uadd_overflow_trap v5, v21, heap_oob  ; v21 = 0x0010_0003
-;; @006b                               v24 = icmp ugt v22, v6
-;;                                     v31 = iconst.i64 0x000f_ffff
-;; @006b                               v27 = iadd v9, v31  ; v31 = 0x000f_ffff
-;; @006b                               v29 = select_spectre_guard v24, v10, v27  ; v10 = 0
-;; @006b                               store little heap v3, v29
-;; @0070                               jump block1
-;;
-;;                                 block1:
-;; @0070                               return
-;; }
diff --git a/cranelift/filetests/filetests/wasm/f32-load.wat b/cranelift/filetests/filetests/wasm/f32-load.wat
deleted file mode 100644
index e568cd9e2910..000000000000
--- a/cranelift/filetests/filetests/wasm/f32-load.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (memory 1)
-  (func (export "f32.load") (param i32) (result f32)
-    local.get 0
-    f32.load))
-
-;; function u0:0(i32, i64 vmctx) -> f32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @002e                               v3 = uextend.i64 v0
-;; @002e                               v4 = global_value.i64 gv1
-;; @002e                               v5 = iadd v4, v3
-;; @002e                               v6 = load.f32 little heap v5
-;; @0031                               jump block1(v6)
-;;
-;;                                 block1(v2: f32):
-;; @0031                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/f32-store.wat b/cranelift/filetests/filetests/wasm/f32-store.wat
deleted file mode 100644
index 48526a18cfb5..000000000000
--- a/cranelift/filetests/filetests/wasm/f32-store.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "x86_64"
-
-;; Test basic code generation for f32 memory WebAssembly instructions.
-
-(module
-  (memory 1)
-  (func (export "f32.store") (param i32 f32)
-    local.get 0
-    local.get 1
-    f32.store))
-
-;; function u0:0(i32, f32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: f32, v2: i64):
-;; @0031                               v3 = uextend.i64 v0
-;; @0031                               v4 = global_value.i64 gv1
-;; @0031                               v5 = iadd v4, v3
-;; @0031                               store little heap v1, v5
-;; @0034                               jump block1
-;;
-;;                                 block1:
-;; @0034                               return
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/f64-load.wat b/cranelift/filetests/filetests/wasm/f64-load.wat
deleted file mode 100644
index ce9cc37f569c..000000000000
--- a/cranelift/filetests/filetests/wasm/f64-load.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-;; Test basic code generation for f64 memory WebAssembly instructions.
-
-(module
-  (memory 1)
-  (func (export "f64.load") (param i32) (result f64)
-    local.get 0
-    f64.load))
-
-;; function u0:0(i32, i64 vmctx) -> f64 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @002e                               v3 = uextend.i64 v0
-;; @002e                               v4 = global_value.i64 gv1
-;; @002e                               v5 = iadd v4, v3
-;; @002e                               v6 = load.f64 little heap v5
-;; @0031                               jump block1(v6)
-;;
-;;                                 block1(v2: f64):
-;; @0031                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/f64-store.wat b/cranelift/filetests/filetests/wasm/f64-store.wat
deleted file mode 100644
index f23e3a89b593..000000000000
--- a/cranelift/filetests/filetests/wasm/f64-store.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "x86_64"
-
-;; Test basic code generation for f64 memory WebAssembly instructions.
-
-(module
-  (memory 1)
-  (func (export "f64.store") (param i32 f64)
-    local.get 0
-    local.get 1
-    f64.store))
-
-;; function u0:0(i32, f64, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: f64, v2: i64):
-;; @0031                               v3 = uextend.i64 v0
-;; @0031                               v4 = global_value.i64 gv1
-;; @0031                               v5 = iadd v4, v3
-;; @0031                               store little heap v1, v5
-;; @0034                               jump block1
-;;
-;;                                 block1:
-;; @0034                               return
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/i32-load.wat b/cranelift/filetests/filetests/wasm/i32-load.wat
deleted file mode 100644
index d0005d3c9894..000000000000
--- a/cranelift/filetests/filetests/wasm/i32-load.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-;; Test basic code generation for i32 memory WebAssembly instructions.
-
-(module
-  (memory 1)
-  (func (export "i32.load") (param i32) (result i32)
-    local.get 0
-    i32.load))
-
-;; function u0:0(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @002e                               v3 = uextend.i64 v0
-;; @002e                               v4 = global_value.i64 gv1
-;; @002e                               v5 = iadd v4, v3
-;; @002e                               v6 = load.i32 little heap v5
-;; @0031                               jump block1(v6)
-;;
-;;                                 block1(v2: i32):
-;; @0031                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/i32-load16-s.wat b/cranelift/filetests/filetests/wasm/i32-load16-s.wat
deleted file mode 100644
index a944b0615882..000000000000
--- a/cranelift/filetests/filetests/wasm/i32-load16-s.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-;; Test basic code generation for i32 memory WebAssembly instructions.
-
-(module
-  (memory 1)
-  (func (export "i32.load16_s") (param i32) (result i32)
-    local.get 0
-    i32.load16_s))
-
-;; function u0:0(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0032                               v3 = uextend.i64 v0
-;; @0032                               v4 = global_value.i64 gv1
-;; @0032                               v5 = iadd v4, v3
-;; @0032                               v6 = sload16.i32 little heap v5
-;; @0035                               jump block1(v6)
-;;
-;;                                 block1(v2: i32):
-;; @0035                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/i32-load16-u.wat b/cranelift/filetests/filetests/wasm/i32-load16-u.wat
deleted file mode 100644
index 0c2ab9fde762..000000000000
--- a/cranelift/filetests/filetests/wasm/i32-load16-u.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-;; Test basic code generation for i32 memory WebAssembly instructions.
-
-(module
-  (memory 1)
-  (func (export "i32.load16_u") (param i32) (result i32)
-    local.get 0
-    i32.load16_u))
-
-;; function u0:0(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0032                               v3 = uextend.i64 v0
-;; @0032                               v4 = global_value.i64 gv1
-;; @0032                               v5 = iadd v4, v3
-;; @0032                               v6 = uload16.i32 little heap v5
-;; @0035                               jump block1(v6)
-;;
-;;                                 block1(v2: i32):
-;; @0035                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/i32-load8-s.wat b/cranelift/filetests/filetests/wasm/i32-load8-s.wat
deleted file mode 100644
index 82802355e313..000000000000
--- a/cranelift/filetests/filetests/wasm/i32-load8-s.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-;; Test basic code generation for i32 memory WebAssembly instructions.
-
-(module
-  (memory 1)
-  (func (export "i32.load8_s") (param i32) (result i32)
-    local.get 0
-    i32.load8_s))
-
-;; function u0:0(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0031                               v3 = uextend.i64 v0
-;; @0031                               v4 = global_value.i64 gv1
-;; @0031                               v5 = iadd v4, v3
-;; @0031                               v6 = sload8.i32 little heap v5
-;; @0034                               jump block1(v6)
-;;
-;;                                 block1(v2: i32):
-;; @0034                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/i32-load8-u.wat b/cranelift/filetests/filetests/wasm/i32-load8-u.wat
deleted file mode 100644
index 1c19fe37bab8..000000000000
--- a/cranelift/filetests/filetests/wasm/i32-load8-u.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-;; Test basic code generation for i32 memory WebAssembly instructions.
-
-(module
-  (memory 1)
-  (func (export "i32.load8_u") (param i32) (result i32)
-    local.get 0
-    i32.load8_u))
-
-;; function u0:0(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0031                               v3 = uextend.i64 v0
-;; @0031                               v4 = global_value.i64 gv1
-;; @0031                               v5 = iadd v4, v3
-;; @0031                               v6 = uload8.i32 little heap v5
-;; @0034                               jump block1(v6)
-;;
-;;                                 block1(v2: i32):
-;; @0034                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/i32-not-x64.wat b/cranelift/filetests/filetests/wasm/i32-not-x64.wat
deleted file mode 100644
index e4eb54957a4a..000000000000
--- a/cranelift/filetests/filetests/wasm/i32-not-x64.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;!target = "x86_64"
-;;!compile = true
-;;!settings = ["opt_level=speed", "has_bmi1=true"]
-
-(module
-  ;; this should get optimized to a `bnot` in clif
-  (func (param i32) (result i32)
-    i32.const -1
-    local.get 0
-    i32.xor)
-
-  ;; this should get optimized to a single `andn` instruction
-  (func (param i32 i32) (result i32)
-    local.get 0
-    i32.const -1
-    local.get 1
-    i32.xor
-    i32.and)
-)
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   movq    %rdi, %rax
-;;   notl    %eax, %eax
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   andn    %edi, %esi, %eax
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/wasm/i32-store.wat b/cranelift/filetests/filetests/wasm/i32-store.wat
deleted file mode 100644
index 5f9d77287367..000000000000
--- a/cranelift/filetests/filetests/wasm/i32-store.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "x86_64"
-
-;; Test basic code generation for i32 memory WebAssembly instructions.
-
-(module
-  (memory 1)
-  (func (export "i32.store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0031                               v3 = uextend.i64 v0
-;; @0031                               v4 = global_value.i64 gv1
-;; @0031                               v5 = iadd v4, v3
-;; @0031                               store little heap v1, v5
-;; @0034                               jump block1
-;;
-;;                                 block1:
-;; @0034                               return
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/i32-store16.wat b/cranelift/filetests/filetests/wasm/i32-store16.wat
deleted file mode 100644
index f486e34db490..000000000000
--- a/cranelift/filetests/filetests/wasm/i32-store16.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "x86_64"
-
-;; Test basic code generation for i32 memory WebAssembly instructions.
-
-(module
-  (memory 1)
-  (func (export "i32.store16") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store16))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0033                               v3 = uextend.i64 v0
-;; @0033                               v4 = global_value.i64 gv1
-;; @0033                               v5 = iadd v4, v3
-;; @0033                               istore16 little heap v1, v5
-;; @0036                               jump block1
-;;
-;;                                 block1:
-;; @0036                               return
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/i32-store8.wat b/cranelift/filetests/filetests/wasm/i32-store8.wat
deleted file mode 100644
index eb64c0ac0529..000000000000
--- a/cranelift/filetests/filetests/wasm/i32-store8.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "x86_64"
-
-;; Test basic code generation for i32 memory WebAssembly instructions.
-
-(module
-  (memory 1)
-  (func (export "i32.store8") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0032                               v3 = uextend.i64 v0
-;; @0032                               v4 = global_value.i64 gv1
-;; @0032                               v5 = iadd v4, v3
-;; @0032                               istore8 little heap v1, v5
-;; @0035                               jump block1
-;;
-;;                                 block1:
-;; @0035                               return
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/i64-load.wat b/cranelift/filetests/filetests/wasm/i64-load.wat
deleted file mode 100644
index 1fe9bc04eae7..000000000000
--- a/cranelift/filetests/filetests/wasm/i64-load.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-;; Test basic code generation for i32 memory WebAssembly instructions.
-
-(module
-  (memory 1)
-  (func (export "i64.load") (param i32) (result i64)
-    local.get 0
-    i64.load))
-
-;; function u0:0(i32, i64 vmctx) -> i64 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @002e                               v3 = uextend.i64 v0
-;; @002e                               v4 = global_value.i64 gv1
-;; @002e                               v5 = iadd v4, v3
-;; @002e                               v6 = load.i64 little heap v5
-;; @0031                               jump block1(v6)
-;;
-;;                                 block1(v2: i64):
-;; @0031                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/i64-load16-s.wat b/cranelift/filetests/filetests/wasm/i64-load16-s.wat
deleted file mode 100644
index d18d9b297eee..000000000000
--- a/cranelift/filetests/filetests/wasm/i64-load16-s.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-;; Test basic code generation for i64 memory WebAssembly instructions.
-
-(module
-  (memory 1)
-  (func (export "i64.load16_s") (param i32) (result i64)
-    local.get 0
-    i64.load16_s))
-
-;; function u0:0(i32, i64 vmctx) -> i64 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0032                               v3 = uextend.i64 v0
-;; @0032                               v4 = global_value.i64 gv1
-;; @0032                               v5 = iadd v4, v3
-;; @0032                               v6 = sload16.i64 little heap v5
-;; @0035                               jump block1(v6)
-;;
-;;                                 block1(v2: i64):
-;; @0035                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/i64-load16-u.wat b/cranelift/filetests/filetests/wasm/i64-load16-u.wat
deleted file mode 100644
index 358e141afc14..000000000000
--- a/cranelift/filetests/filetests/wasm/i64-load16-u.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-;; Test basic code generation for i64 memory WebAssembly instructions.
-
-(module
-  (memory 1)
-  (func (export "i64.load16_u") (param i32) (result i64)
-    local.get 0
-    i64.load16_u))
-
-;; function u0:0(i32, i64 vmctx) -> i64 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0032                               v3 = uextend.i64 v0
-;; @0032                               v4 = global_value.i64 gv1
-;; @0032                               v5 = iadd v4, v3
-;; @0032                               v6 = uload16.i64 little heap v5
-;; @0035                               jump block1(v6)
-;;
-;;                                 block1(v2: i64):
-;; @0035                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/i64-load8-s.wat b/cranelift/filetests/filetests/wasm/i64-load8-s.wat
deleted file mode 100644
index 8537e734527a..000000000000
--- a/cranelift/filetests/filetests/wasm/i64-load8-s.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-;; Test basic code generation for i64 memory WebAssembly instructions.
-
-(module
-  (memory 1)
-  (func (export "i64.load8_s") (param i32) (result i64)
-    local.get 0
-    i64.load8_s))
-
-;; function u0:0(i32, i64 vmctx) -> i64 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0031                               v3 = uextend.i64 v0
-;; @0031                               v4 = global_value.i64 gv1
-;; @0031                               v5 = iadd v4, v3
-;; @0031                               v6 = sload8.i64 little heap v5
-;; @0034                               jump block1(v6)
-;;
-;;                                 block1(v2: i64):
-;; @0034                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/i64-load8-u.wat b/cranelift/filetests/filetests/wasm/i64-load8-u.wat
deleted file mode 100644
index c1e6297c90be..000000000000
--- a/cranelift/filetests/filetests/wasm/i64-load8-u.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-;; Test basic code generation for i64 memory WebAssembly instructions.
-
-(module
-  (memory 1)
-  (func (export "i64.load8_u") (param i32) (result i64)
-    local.get 0
-    i64.load8_u))
-
-;; function u0:0(i32, i64 vmctx) -> i64 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0031                               v3 = uextend.i64 v0
-;; @0031                               v4 = global_value.i64 gv1
-;; @0031                               v5 = iadd v4, v3
-;; @0031                               v6 = uload8.i64 little heap v5
-;; @0034                               jump block1(v6)
-;;
-;;                                 block1(v2: i64):
-;; @0034                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/i64-store.wat b/cranelift/filetests/filetests/wasm/i64-store.wat
deleted file mode 100644
index f500ec8498fd..000000000000
--- a/cranelift/filetests/filetests/wasm/i64-store.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "x86_64"
-
-;; Test basic code generation for i32 memory WebAssembly instructions.
-
-(module
-  (memory 1)
-  (func (export "i64.store") (param i32 i64)
-    local.get 0
-    local.get 1
-    i64.store))
-
-;; function u0:0(i32, i64, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64, v2: i64):
-;; @0031                               v3 = uextend.i64 v0
-;; @0031                               v4 = global_value.i64 gv1
-;; @0031                               v5 = iadd v4, v3
-;; @0031                               store little heap v1, v5
-;; @0034                               jump block1
-;;
-;;                                 block1:
-;; @0034                               return
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/i64-store16.wat b/cranelift/filetests/filetests/wasm/i64-store16.wat
deleted file mode 100644
index e0950125d211..000000000000
--- a/cranelift/filetests/filetests/wasm/i64-store16.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "x86_64"
-
-;; Test basic code generation for i64 memory WebAssembly instructions.
-
-(module
-  (memory 1)
-  (func (export "i64.store16") (param i32 i64)
-    local.get 0
-    local.get 1
-    i64.store16))
-
-;; function u0:0(i32, i64, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64, v2: i64):
-;; @0033                               v3 = uextend.i64 v0
-;; @0033                               v4 = global_value.i64 gv1
-;; @0033                               v5 = iadd v4, v3
-;; @0033                               istore16 little heap v1, v5
-;; @0036                               jump block1
-;;
-;;                                 block1:
-;; @0036                               return
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/i64-store32.wat b/cranelift/filetests/filetests/wasm/i64-store32.wat
deleted file mode 100644
index 59cc1d050067..000000000000
--- a/cranelift/filetests/filetests/wasm/i64-store32.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "x86_64"
-
-;; Test basic code generation for i64 memory WebAssembly instructions.
-
-(module
-  (memory 1)
-  (func (export "i64.store32") (param i32 i64)
-    local.get 0
-    local.get 1
-    i64.store32))
-
-;; function u0:0(i32, i64, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64, v2: i64):
-;; @0033                               v3 = uextend.i64 v0
-;; @0033                               v4 = global_value.i64 gv1
-;; @0033                               v5 = iadd v4, v3
-;; @0033                               istore32 little heap v1, v5
-;; @0036                               jump block1
-;;
-;;                                 block1:
-;; @0036                               return
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/i64-store8.wat b/cranelift/filetests/filetests/wasm/i64-store8.wat
deleted file mode 100644
index 27a92006b42d..000000000000
--- a/cranelift/filetests/filetests/wasm/i64-store8.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "x86_64"
-
-;; Test basic code generation for i64 memory WebAssembly instructions.
-
-(module
-  (memory 1)
-  (func (export "i64.store8") (param i32 i64)
-    local.get 0
-    local.get 1
-    i64.store8))
-
-;; function u0:0(i32, i64, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64, v2: i64):
-;; @0032                               v3 = uextend.i64 v0
-;; @0032                               v4 = global_value.i64 gv1
-;; @0032                               v5 = iadd v4, v3
-;; @0032                               istore8 little heap v1, v5
-;; @0035                               jump block1
-;;
-;;                                 block1:
-;; @0035                               return
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/issue-5696.wat b/cranelift/filetests/filetests/wasm/issue-5696.wat
deleted file mode 100644
index d8a2ddaabe05..000000000000
--- a/cranelift/filetests/filetests/wasm/issue-5696.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-;;! optimize = true
-;;! settings = ["opt_level=speed"]
-
-(module
-  (func (;0;) (param i64) (result i64)
-    i64.const 32
-    i64.const -19
-    i64.shr_u
-    ;; call 0
-  )
-)
-;; function u0:0(i64, i64 vmctx) -> i64 fast {
-;;                                 block0(v0: i64, v1: i64):
-;; @001e                               jump block1
-;;
-;;                                 block1:
-;;                                     v6 = iconst.i64 0
-;; @001e                               return v6  ; v6 = 0
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index abdee4670612..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd_imm v4, -4
-;; @0040                               v6 = icmp ugt v3, v5
-;; @0040                               trapnz v6, heap_oob
-;; @0040                               v7 = global_value.i64 gv2
-;; @0040                               v8 = iadd v7, v3
-;; @0040                               store little heap v1, v8
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0048                               v3 = uextend.i64 v0
-;; @0048                               v4 = global_value.i64 gv1
-;; @0048                               v5 = iadd_imm v4, -4
-;; @0048                               v6 = icmp ugt v3, v5
-;; @0048                               trapnz v6, heap_oob
-;; @0048                               v7 = global_value.i64 gv2
-;; @0048                               v8 = iadd v7, v3
-;; @0048                               v9 = load.i32 little heap v8
-;; @004b                               jump block1(v9)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 6311eff510f4..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,82 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd_imm v4, -4100
-;; @0040                               v6 = icmp ugt v3, v5
-;; @0040                               trapnz v6, heap_oob
-;; @0040                               v7 = global_value.i64 gv2
-;; @0040                               v8 = iadd v7, v3
-;; @0040                               v9 = iadd_imm v8, 4096
-;; @0040                               store little heap v1, v9
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0049                               v3 = uextend.i64 v0
-;; @0049                               v4 = global_value.i64 gv1
-;; @0049                               v5 = iadd_imm v4, -4100
-;; @0049                               v6 = icmp ugt v3, v5
-;; @0049                               trapnz v6, heap_oob
-;; @0049                               v7 = global_value.i64 gv2
-;; @0049                               v8 = iadd v7, v3
-;; @0049                               v9 = iadd_imm v8, 4096
-;; @0049                               v10 = load.i32 little heap v9
-;; @004d                               jump block1(v10)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 0e5e00017750..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,84 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = iconst.i64 0xffff_0004
-;; @0040                               v5 = uadd_overflow_trap v3, v4, heap_oob  ; v4 = 0xffff_0004
-;; @0040                               v6 = global_value.i64 gv1
-;; @0040                               v7 = icmp ugt v5, v6
-;; @0040                               trapnz v7, heap_oob
-;; @0040                               v8 = global_value.i64 gv2
-;; @0040                               v9 = iadd v8, v3
-;; @0040                               v10 = iadd_imm v9, 0xffff_0000
-;; @0040                               store little heap v1, v10
-;; @0047                               jump block1
-;;
-;;                                 block1:
-;; @0047                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @004c                               v3 = uextend.i64 v0
-;; @004c                               v4 = iconst.i64 0xffff_0004
-;; @004c                               v5 = uadd_overflow_trap v3, v4, heap_oob  ; v4 = 0xffff_0004
-;; @004c                               v6 = global_value.i64 gv1
-;; @004c                               v7 = icmp ugt v5, v6
-;; @004c                               trapnz v7, heap_oob
-;; @004c                               v8 = global_value.i64 gv2
-;; @004c                               v9 = iadd v8, v3
-;; @004c                               v10 = iadd_imm v9, 0xffff_0000
-;; @004c                               v11 = load.i32 little heap v10
-;; @0053                               jump block1(v11)
-;;
-;;                                 block1(v2: i32):
-;; @0053                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 3eb89a7137dd..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = icmp uge v3, v4
-;; @0040                               trapnz v5, heap_oob
-;; @0040                               v6 = global_value.i64 gv2
-;; @0040                               v7 = iadd v6, v3
-;; @0040                               istore8 little heap v1, v7
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0048                               v3 = uextend.i64 v0
-;; @0048                               v4 = global_value.i64 gv1
-;; @0048                               v5 = icmp uge v3, v4
-;; @0048                               trapnz v5, heap_oob
-;; @0048                               v6 = global_value.i64 gv2
-;; @0048                               v7 = iadd v6, v3
-;; @0048                               v8 = uload8.i32 little heap v7
-;; @004b                               jump block1(v8)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 7868f17e506d..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,82 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd_imm v4, -4097
-;; @0040                               v6 = icmp ugt v3, v5
-;; @0040                               trapnz v6, heap_oob
-;; @0040                               v7 = global_value.i64 gv2
-;; @0040                               v8 = iadd v7, v3
-;; @0040                               v9 = iadd_imm v8, 4096
-;; @0040                               istore8 little heap v1, v9
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0049                               v3 = uextend.i64 v0
-;; @0049                               v4 = global_value.i64 gv1
-;; @0049                               v5 = iadd_imm v4, -4097
-;; @0049                               v6 = icmp ugt v3, v5
-;; @0049                               trapnz v6, heap_oob
-;; @0049                               v7 = global_value.i64 gv2
-;; @0049                               v8 = iadd v7, v3
-;; @0049                               v9 = iadd_imm v8, 4096
-;; @0049                               v10 = uload8.i32 little heap v9
-;; @004d                               jump block1(v10)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index d678f9f53be9..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,84 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = iconst.i64 0xffff_0001
-;; @0040                               v5 = uadd_overflow_trap v3, v4, heap_oob  ; v4 = 0xffff_0001
-;; @0040                               v6 = global_value.i64 gv1
-;; @0040                               v7 = icmp ugt v5, v6
-;; @0040                               trapnz v7, heap_oob
-;; @0040                               v8 = global_value.i64 gv2
-;; @0040                               v9 = iadd v8, v3
-;; @0040                               v10 = iadd_imm v9, 0xffff_0000
-;; @0040                               istore8 little heap v1, v10
-;; @0047                               jump block1
-;;
-;;                                 block1:
-;; @0047                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @004c                               v3 = uextend.i64 v0
-;; @004c                               v4 = iconst.i64 0xffff_0001
-;; @004c                               v5 = uadd_overflow_trap v3, v4, heap_oob  ; v4 = 0xffff_0001
-;; @004c                               v6 = global_value.i64 gv1
-;; @004c                               v7 = icmp ugt v5, v6
-;; @004c                               trapnz v7, heap_oob
-;; @004c                               v8 = global_value.i64 gv2
-;; @004c                               v9 = iadd v8, v3
-;; @004c                               v10 = iadd_imm v9, 0xffff_0000
-;; @004c                               v11 = uload8.i32 little heap v10
-;; @0053                               jump block1(v11)
-;;
-;;                                 block1(v2: i32):
-;; @0053                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 682469a512c2..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,82 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd_imm v4, -4
-;; @0040                               v6 = icmp ugt v3, v5
-;; @0040                               v7 = global_value.i64 gv2
-;; @0040                               v8 = iadd v7, v3
-;; @0040                               v9 = iconst.i64 0
-;; @0040                               v10 = select_spectre_guard v6, v9, v8  ; v9 = 0
-;; @0040                               store little heap v1, v10
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0048                               v3 = uextend.i64 v0
-;; @0048                               v4 = global_value.i64 gv1
-;; @0048                               v5 = iadd_imm v4, -4
-;; @0048                               v6 = icmp ugt v3, v5
-;; @0048                               v7 = global_value.i64 gv2
-;; @0048                               v8 = iadd v7, v3
-;; @0048                               v9 = iconst.i64 0
-;; @0048                               v10 = select_spectre_guard v6, v9, v8  ; v9 = 0
-;; @0048                               v11 = load.i32 little heap v10
-;; @004b                               jump block1(v11)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index d87ec248c314..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,84 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd_imm v4, -4100
-;; @0040                               v6 = icmp ugt v3, v5
-;; @0040                               v7 = global_value.i64 gv2
-;; @0040                               v8 = iadd v7, v3
-;; @0040                               v9 = iadd_imm v8, 4096
-;; @0040                               v10 = iconst.i64 0
-;; @0040                               v11 = select_spectre_guard v6, v10, v9  ; v10 = 0
-;; @0040                               store little heap v1, v11
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0049                               v3 = uextend.i64 v0
-;; @0049                               v4 = global_value.i64 gv1
-;; @0049                               v5 = iadd_imm v4, -4100
-;; @0049                               v6 = icmp ugt v3, v5
-;; @0049                               v7 = global_value.i64 gv2
-;; @0049                               v8 = iadd v7, v3
-;; @0049                               v9 = iadd_imm v8, 4096
-;; @0049                               v10 = iconst.i64 0
-;; @0049                               v11 = select_spectre_guard v6, v10, v9  ; v10 = 0
-;; @0049                               v12 = load.i32 little heap v11
-;; @004d                               jump block1(v12)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 3f41ddeb92fe..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,86 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = iconst.i64 0xffff_0004
-;; @0040                               v5 = uadd_overflow_trap v3, v4, heap_oob  ; v4 = 0xffff_0004
-;; @0040                               v6 = global_value.i64 gv1
-;; @0040                               v7 = icmp ugt v5, v6
-;; @0040                               v8 = global_value.i64 gv2
-;; @0040                               v9 = iadd v8, v3
-;; @0040                               v10 = iadd_imm v9, 0xffff_0000
-;; @0040                               v11 = iconst.i64 0
-;; @0040                               v12 = select_spectre_guard v7, v11, v10  ; v11 = 0
-;; @0040                               store little heap v1, v12
-;; @0047                               jump block1
-;;
-;;                                 block1:
-;; @0047                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @004c                               v3 = uextend.i64 v0
-;; @004c                               v4 = iconst.i64 0xffff_0004
-;; @004c                               v5 = uadd_overflow_trap v3, v4, heap_oob  ; v4 = 0xffff_0004
-;; @004c                               v6 = global_value.i64 gv1
-;; @004c                               v7 = icmp ugt v5, v6
-;; @004c                               v8 = global_value.i64 gv2
-;; @004c                               v9 = iadd v8, v3
-;; @004c                               v10 = iadd_imm v9, 0xffff_0000
-;; @004c                               v11 = iconst.i64 0
-;; @004c                               v12 = select_spectre_guard v7, v11, v10  ; v11 = 0
-;; @004c                               v13 = load.i32 little heap v12
-;; @0053                               jump block1(v13)
-;;
-;;                                 block1(v2: i32):
-;; @0053                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 0cd13ef90c8e..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = icmp uge v3, v4
-;; @0040                               v6 = global_value.i64 gv2
-;; @0040                               v7 = iadd v6, v3
-;; @0040                               v8 = iconst.i64 0
-;; @0040                               v9 = select_spectre_guard v5, v8, v7  ; v8 = 0
-;; @0040                               istore8 little heap v1, v9
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0048                               v3 = uextend.i64 v0
-;; @0048                               v4 = global_value.i64 gv1
-;; @0048                               v5 = icmp uge v3, v4
-;; @0048                               v6 = global_value.i64 gv2
-;; @0048                               v7 = iadd v6, v3
-;; @0048                               v8 = iconst.i64 0
-;; @0048                               v9 = select_spectre_guard v5, v8, v7  ; v8 = 0
-;; @0048                               v10 = uload8.i32 little heap v9
-;; @004b                               jump block1(v10)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 05f55e95069b..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,84 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd_imm v4, -4097
-;; @0040                               v6 = icmp ugt v3, v5
-;; @0040                               v7 = global_value.i64 gv2
-;; @0040                               v8 = iadd v7, v3
-;; @0040                               v9 = iadd_imm v8, 4096
-;; @0040                               v10 = iconst.i64 0
-;; @0040                               v11 = select_spectre_guard v6, v10, v9  ; v10 = 0
-;; @0040                               istore8 little heap v1, v11
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0049                               v3 = uextend.i64 v0
-;; @0049                               v4 = global_value.i64 gv1
-;; @0049                               v5 = iadd_imm v4, -4097
-;; @0049                               v6 = icmp ugt v3, v5
-;; @0049                               v7 = global_value.i64 gv2
-;; @0049                               v8 = iadd v7, v3
-;; @0049                               v9 = iadd_imm v8, 4096
-;; @0049                               v10 = iconst.i64 0
-;; @0049                               v11 = select_spectre_guard v6, v10, v9  ; v10 = 0
-;; @0049                               v12 = uload8.i32 little heap v11
-;; @004d                               jump block1(v12)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 5da9f16544d3..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,86 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = iconst.i64 0xffff_0001
-;; @0040                               v5 = uadd_overflow_trap v3, v4, heap_oob  ; v4 = 0xffff_0001
-;; @0040                               v6 = global_value.i64 gv1
-;; @0040                               v7 = icmp ugt v5, v6
-;; @0040                               v8 = global_value.i64 gv2
-;; @0040                               v9 = iadd v8, v3
-;; @0040                               v10 = iadd_imm v9, 0xffff_0000
-;; @0040                               v11 = iconst.i64 0
-;; @0040                               v12 = select_spectre_guard v7, v11, v10  ; v11 = 0
-;; @0040                               istore8 little heap v1, v12
-;; @0047                               jump block1
-;;
-;;                                 block1:
-;; @0047                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @004c                               v3 = uextend.i64 v0
-;; @004c                               v4 = iconst.i64 0xffff_0001
-;; @004c                               v5 = uadd_overflow_trap v3, v4, heap_oob  ; v4 = 0xffff_0001
-;; @004c                               v6 = global_value.i64 gv1
-;; @004c                               v7 = icmp ugt v5, v6
-;; @004c                               v8 = global_value.i64 gv2
-;; @004c                               v9 = iadd v8, v3
-;; @004c                               v10 = iadd_imm v9, 0xffff_0000
-;; @004c                               v11 = iconst.i64 0
-;; @004c                               v12 = select_spectre_guard v7, v11, v10  ; v11 = 0
-;; @004c                               v13 = uload8.i32 little heap v12
-;; @0053                               jump block1(v13)
-;;
-;;                                 block1(v2: i32):
-;; @0053                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 84cf2e055b97..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = icmp ugt v3, v4
-;; @0040                               trapnz v5, heap_oob
-;; @0040                               v6 = global_value.i64 gv2
-;; @0040                               v7 = iadd v6, v3
-;; @0040                               store little heap v1, v7
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0048                               v3 = uextend.i64 v0
-;; @0048                               v4 = global_value.i64 gv1
-;; @0048                               v5 = icmp ugt v3, v4
-;; @0048                               trapnz v5, heap_oob
-;; @0048                               v6 = global_value.i64 gv2
-;; @0048                               v7 = iadd v6, v3
-;; @0048                               v8 = load.i32 little heap v7
-;; @004b                               jump block1(v8)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 830fcdb0e5d0..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = icmp ugt v3, v4
-;; @0040                               trapnz v5, heap_oob
-;; @0040                               v6 = global_value.i64 gv2
-;; @0040                               v7 = iadd v6, v3
-;; @0040                               v8 = iadd_imm v7, 4096
-;; @0040                               store little heap v1, v8
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0049                               v3 = uextend.i64 v0
-;; @0049                               v4 = global_value.i64 gv1
-;; @0049                               v5 = icmp ugt v3, v4
-;; @0049                               trapnz v5, heap_oob
-;; @0049                               v6 = global_value.i64 gv2
-;; @0049                               v7 = iadd v6, v3
-;; @0049                               v8 = iadd_imm v7, 4096
-;; @0049                               v9 = load.i32 little heap v8
-;; @004d                               jump block1(v9)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 56f3565d164f..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = icmp ugt v3, v4
-;; @0040                               trapnz v5, heap_oob
-;; @0040                               v6 = global_value.i64 gv2
-;; @0040                               v7 = iadd v6, v3
-;; @0040                               v8 = iadd_imm v7, 0xffff_0000
-;; @0040                               store little heap v1, v8
-;; @0047                               jump block1
-;;
-;;                                 block1:
-;; @0047                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @004c                               v3 = uextend.i64 v0
-;; @004c                               v4 = global_value.i64 gv1
-;; @004c                               v5 = icmp ugt v3, v4
-;; @004c                               trapnz v5, heap_oob
-;; @004c                               v6 = global_value.i64 gv2
-;; @004c                               v7 = iadd v6, v3
-;; @004c                               v8 = iadd_imm v7, 0xffff_0000
-;; @004c                               v9 = load.i32 little heap v8
-;; @0053                               jump block1(v9)
-;;
-;;                                 block1(v2: i32):
-;; @0053                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index e90e8d56e3cb..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = icmp uge v3, v4
-;; @0040                               trapnz v5, heap_oob
-;; @0040                               v6 = global_value.i64 gv2
-;; @0040                               v7 = iadd v6, v3
-;; @0040                               istore8 little heap v1, v7
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0048                               v3 = uextend.i64 v0
-;; @0048                               v4 = global_value.i64 gv1
-;; @0048                               v5 = icmp uge v3, v4
-;; @0048                               trapnz v5, heap_oob
-;; @0048                               v6 = global_value.i64 gv2
-;; @0048                               v7 = iadd v6, v3
-;; @0048                               v8 = uload8.i32 little heap v7
-;; @004b                               jump block1(v8)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 72a89f431d4c..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = icmp ugt v3, v4
-;; @0040                               trapnz v5, heap_oob
-;; @0040                               v6 = global_value.i64 gv2
-;; @0040                               v7 = iadd v6, v3
-;; @0040                               v8 = iadd_imm v7, 4096
-;; @0040                               istore8 little heap v1, v8
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0049                               v3 = uextend.i64 v0
-;; @0049                               v4 = global_value.i64 gv1
-;; @0049                               v5 = icmp ugt v3, v4
-;; @0049                               trapnz v5, heap_oob
-;; @0049                               v6 = global_value.i64 gv2
-;; @0049                               v7 = iadd v6, v3
-;; @0049                               v8 = iadd_imm v7, 4096
-;; @0049                               v9 = uload8.i32 little heap v8
-;; @004d                               jump block1(v9)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index ea033f97e078..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = icmp ugt v3, v4
-;; @0040                               trapnz v5, heap_oob
-;; @0040                               v6 = global_value.i64 gv2
-;; @0040                               v7 = iadd v6, v3
-;; @0040                               v8 = iadd_imm v7, 0xffff_0000
-;; @0040                               istore8 little heap v1, v8
-;; @0047                               jump block1
-;;
-;;                                 block1:
-;; @0047                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @004c                               v3 = uextend.i64 v0
-;; @004c                               v4 = global_value.i64 gv1
-;; @004c                               v5 = icmp ugt v3, v4
-;; @004c                               trapnz v5, heap_oob
-;; @004c                               v6 = global_value.i64 gv2
-;; @004c                               v7 = iadd v6, v3
-;; @004c                               v8 = iadd_imm v7, 0xffff_0000
-;; @004c                               v9 = uload8.i32 little heap v8
-;; @0053                               jump block1(v9)
-;;
-;;                                 block1(v2: i32):
-;; @0053                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index c977428b8418..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = icmp ugt v3, v4
-;; @0040                               v6 = global_value.i64 gv2
-;; @0040                               v7 = iadd v6, v3
-;; @0040                               v8 = iconst.i64 0
-;; @0040                               v9 = select_spectre_guard v5, v8, v7  ; v8 = 0
-;; @0040                               store little heap v1, v9
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0048                               v3 = uextend.i64 v0
-;; @0048                               v4 = global_value.i64 gv1
-;; @0048                               v5 = icmp ugt v3, v4
-;; @0048                               v6 = global_value.i64 gv2
-;; @0048                               v7 = iadd v6, v3
-;; @0048                               v8 = iconst.i64 0
-;; @0048                               v9 = select_spectre_guard v5, v8, v7  ; v8 = 0
-;; @0048                               v10 = load.i32 little heap v9
-;; @004b                               jump block1(v10)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 7735b88823b4..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,82 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = icmp ugt v3, v4
-;; @0040                               v6 = global_value.i64 gv2
-;; @0040                               v7 = iadd v6, v3
-;; @0040                               v8 = iadd_imm v7, 4096
-;; @0040                               v9 = iconst.i64 0
-;; @0040                               v10 = select_spectre_guard v5, v9, v8  ; v9 = 0
-;; @0040                               store little heap v1, v10
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0049                               v3 = uextend.i64 v0
-;; @0049                               v4 = global_value.i64 gv1
-;; @0049                               v5 = icmp ugt v3, v4
-;; @0049                               v6 = global_value.i64 gv2
-;; @0049                               v7 = iadd v6, v3
-;; @0049                               v8 = iadd_imm v7, 4096
-;; @0049                               v9 = iconst.i64 0
-;; @0049                               v10 = select_spectre_guard v5, v9, v8  ; v9 = 0
-;; @0049                               v11 = load.i32 little heap v10
-;; @004d                               jump block1(v11)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 0f6b07a13d8d..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,82 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = icmp ugt v3, v4
-;; @0040                               v6 = global_value.i64 gv2
-;; @0040                               v7 = iadd v6, v3
-;; @0040                               v8 = iadd_imm v7, 0xffff_0000
-;; @0040                               v9 = iconst.i64 0
-;; @0040                               v10 = select_spectre_guard v5, v9, v8  ; v9 = 0
-;; @0040                               store little heap v1, v10
-;; @0047                               jump block1
-;;
-;;                                 block1:
-;; @0047                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @004c                               v3 = uextend.i64 v0
-;; @004c                               v4 = global_value.i64 gv1
-;; @004c                               v5 = icmp ugt v3, v4
-;; @004c                               v6 = global_value.i64 gv2
-;; @004c                               v7 = iadd v6, v3
-;; @004c                               v8 = iadd_imm v7, 0xffff_0000
-;; @004c                               v9 = iconst.i64 0
-;; @004c                               v10 = select_spectre_guard v5, v9, v8  ; v9 = 0
-;; @004c                               v11 = load.i32 little heap v10
-;; @0053                               jump block1(v11)
-;;
-;;                                 block1(v2: i32):
-;; @0053                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 1304aa7cf34e..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = icmp uge v3, v4
-;; @0040                               v6 = global_value.i64 gv2
-;; @0040                               v7 = iadd v6, v3
-;; @0040                               v8 = iconst.i64 0
-;; @0040                               v9 = select_spectre_guard v5, v8, v7  ; v8 = 0
-;; @0040                               istore8 little heap v1, v9
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0048                               v3 = uextend.i64 v0
-;; @0048                               v4 = global_value.i64 gv1
-;; @0048                               v5 = icmp uge v3, v4
-;; @0048                               v6 = global_value.i64 gv2
-;; @0048                               v7 = iadd v6, v3
-;; @0048                               v8 = iconst.i64 0
-;; @0048                               v9 = select_spectre_guard v5, v8, v7  ; v8 = 0
-;; @0048                               v10 = uload8.i32 little heap v9
-;; @004b                               jump block1(v10)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 4c00fe0b8181..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,82 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = icmp ugt v3, v4
-;; @0040                               v6 = global_value.i64 gv2
-;; @0040                               v7 = iadd v6, v3
-;; @0040                               v8 = iadd_imm v7, 4096
-;; @0040                               v9 = iconst.i64 0
-;; @0040                               v10 = select_spectre_guard v5, v9, v8  ; v9 = 0
-;; @0040                               istore8 little heap v1, v10
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0049                               v3 = uextend.i64 v0
-;; @0049                               v4 = global_value.i64 gv1
-;; @0049                               v5 = icmp ugt v3, v4
-;; @0049                               v6 = global_value.i64 gv2
-;; @0049                               v7 = iadd v6, v3
-;; @0049                               v8 = iadd_imm v7, 4096
-;; @0049                               v9 = iconst.i64 0
-;; @0049                               v10 = select_spectre_guard v5, v9, v8  ; v9 = 0
-;; @0049                               v11 = uload8.i32 little heap v10
-;; @004d                               jump block1(v11)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 8f44855404ab..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,82 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = icmp ugt v3, v4
-;; @0040                               v6 = global_value.i64 gv2
-;; @0040                               v7 = iadd v6, v3
-;; @0040                               v8 = iadd_imm v7, 0xffff_0000
-;; @0040                               v9 = iconst.i64 0
-;; @0040                               v10 = select_spectre_guard v5, v9, v8  ; v9 = 0
-;; @0040                               istore8 little heap v1, v10
-;; @0047                               jump block1
-;;
-;;                                 block1:
-;; @0047                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @004c                               v3 = uextend.i64 v0
-;; @004c                               v4 = global_value.i64 gv1
-;; @004c                               v5 = icmp ugt v3, v4
-;; @004c                               v6 = global_value.i64 gv2
-;; @004c                               v7 = iadd v6, v3
-;; @004c                               v8 = iadd_imm v7, 0xffff_0000
-;; @004c                               v9 = iconst.i64 0
-;; @004c                               v10 = select_spectre_guard v5, v9, v8  ; v9 = 0
-;; @004c                               v11 = uload8.i32 little heap v10
-;; @0053                               jump block1(v11)
-;;
-;;                                 block1(v2: i32):
-;; @0053                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index d1bbfe763afd..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = global_value.i64 gv1
-;; @0040                               v4 = iadd_imm v3, -4
-;; @0040                               v5 = icmp ugt v0, v4
-;; @0040                               trapnz v5, heap_oob
-;; @0040                               v6 = global_value.i64 gv2
-;; @0040                               v7 = iadd v6, v0
-;; @0040                               store little heap v1, v7
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0048                               v3 = global_value.i64 gv1
-;; @0048                               v4 = iadd_imm v3, -4
-;; @0048                               v5 = icmp ugt v0, v4
-;; @0048                               trapnz v5, heap_oob
-;; @0048                               v6 = global_value.i64 gv2
-;; @0048                               v7 = iadd v6, v0
-;; @0048                               v8 = load.i32 little heap v7
-;; @004b                               jump block1(v8)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 48d3c4cdb9b4..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = global_value.i64 gv1
-;; @0040                               v4 = iadd_imm v3, -4100
-;; @0040                               v5 = icmp ugt v0, v4
-;; @0040                               trapnz v5, heap_oob
-;; @0040                               v6 = global_value.i64 gv2
-;; @0040                               v7 = iadd v6, v0
-;; @0040                               v8 = iadd_imm v7, 4096
-;; @0040                               store little heap v1, v8
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0049                               v3 = global_value.i64 gv1
-;; @0049                               v4 = iadd_imm v3, -4100
-;; @0049                               v5 = icmp ugt v0, v4
-;; @0049                               trapnz v5, heap_oob
-;; @0049                               v6 = global_value.i64 gv2
-;; @0049                               v7 = iadd v6, v0
-;; @0049                               v8 = iadd_imm v7, 4096
-;; @0049                               v9 = load.i32 little heap v8
-;; @004d                               jump block1(v9)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 2818830f2e5e..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,82 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = iconst.i64 0xffff_0004
-;; @0040                               v4 = uadd_overflow_trap v0, v3, heap_oob  ; v3 = 0xffff_0004
-;; @0040                               v5 = global_value.i64 gv1
-;; @0040                               v6 = icmp ugt v4, v5
-;; @0040                               trapnz v6, heap_oob
-;; @0040                               v7 = global_value.i64 gv2
-;; @0040                               v8 = iadd v7, v0
-;; @0040                               v9 = iadd_imm v8, 0xffff_0000
-;; @0040                               store little heap v1, v9
-;; @0047                               jump block1
-;;
-;;                                 block1:
-;; @0047                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @004c                               v3 = iconst.i64 0xffff_0004
-;; @004c                               v4 = uadd_overflow_trap v0, v3, heap_oob  ; v3 = 0xffff_0004
-;; @004c                               v5 = global_value.i64 gv1
-;; @004c                               v6 = icmp ugt v4, v5
-;; @004c                               trapnz v6, heap_oob
-;; @004c                               v7 = global_value.i64 gv2
-;; @004c                               v8 = iadd v7, v0
-;; @004c                               v9 = iadd_imm v8, 0xffff_0000
-;; @004c                               v10 = load.i32 little heap v9
-;; @0053                               jump block1(v10)
-;;
-;;                                 block1(v2: i32):
-;; @0053                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 344421bd20a4..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = global_value.i64 gv1
-;; @0040                               v4 = icmp uge v0, v3
-;; @0040                               trapnz v4, heap_oob
-;; @0040                               v5 = global_value.i64 gv2
-;; @0040                               v6 = iadd v5, v0
-;; @0040                               istore8 little heap v1, v6
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0048                               v3 = global_value.i64 gv1
-;; @0048                               v4 = icmp uge v0, v3
-;; @0048                               trapnz v4, heap_oob
-;; @0048                               v5 = global_value.i64 gv2
-;; @0048                               v6 = iadd v5, v0
-;; @0048                               v7 = uload8.i32 little heap v6
-;; @004b                               jump block1(v7)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index fe99a3a69a27..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = global_value.i64 gv1
-;; @0040                               v4 = iadd_imm v3, -4097
-;; @0040                               v5 = icmp ugt v0, v4
-;; @0040                               trapnz v5, heap_oob
-;; @0040                               v6 = global_value.i64 gv2
-;; @0040                               v7 = iadd v6, v0
-;; @0040                               v8 = iadd_imm v7, 4096
-;; @0040                               istore8 little heap v1, v8
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0049                               v3 = global_value.i64 gv1
-;; @0049                               v4 = iadd_imm v3, -4097
-;; @0049                               v5 = icmp ugt v0, v4
-;; @0049                               trapnz v5, heap_oob
-;; @0049                               v6 = global_value.i64 gv2
-;; @0049                               v7 = iadd v6, v0
-;; @0049                               v8 = iadd_imm v7, 4096
-;; @0049                               v9 = uload8.i32 little heap v8
-;; @004d                               jump block1(v9)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index dfffbffa10a9..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,82 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = iconst.i64 0xffff_0001
-;; @0040                               v4 = uadd_overflow_trap v0, v3, heap_oob  ; v3 = 0xffff_0001
-;; @0040                               v5 = global_value.i64 gv1
-;; @0040                               v6 = icmp ugt v4, v5
-;; @0040                               trapnz v6, heap_oob
-;; @0040                               v7 = global_value.i64 gv2
-;; @0040                               v8 = iadd v7, v0
-;; @0040                               v9 = iadd_imm v8, 0xffff_0000
-;; @0040                               istore8 little heap v1, v9
-;; @0047                               jump block1
-;;
-;;                                 block1:
-;; @0047                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @004c                               v3 = iconst.i64 0xffff_0001
-;; @004c                               v4 = uadd_overflow_trap v0, v3, heap_oob  ; v3 = 0xffff_0001
-;; @004c                               v5 = global_value.i64 gv1
-;; @004c                               v6 = icmp ugt v4, v5
-;; @004c                               trapnz v6, heap_oob
-;; @004c                               v7 = global_value.i64 gv2
-;; @004c                               v8 = iadd v7, v0
-;; @004c                               v9 = iadd_imm v8, 0xffff_0000
-;; @004c                               v10 = uload8.i32 little heap v9
-;; @0053                               jump block1(v10)
-;;
-;;                                 block1(v2: i32):
-;; @0053                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 05b21bbf5541..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = global_value.i64 gv1
-;; @0040                               v4 = iadd_imm v3, -4
-;; @0040                               v5 = icmp ugt v0, v4
-;; @0040                               v6 = global_value.i64 gv2
-;; @0040                               v7 = iadd v6, v0
-;; @0040                               v8 = iconst.i64 0
-;; @0040                               v9 = select_spectre_guard v5, v8, v7  ; v8 = 0
-;; @0040                               store little heap v1, v9
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0048                               v3 = global_value.i64 gv1
-;; @0048                               v4 = iadd_imm v3, -4
-;; @0048                               v5 = icmp ugt v0, v4
-;; @0048                               v6 = global_value.i64 gv2
-;; @0048                               v7 = iadd v6, v0
-;; @0048                               v8 = iconst.i64 0
-;; @0048                               v9 = select_spectre_guard v5, v8, v7  ; v8 = 0
-;; @0048                               v10 = load.i32 little heap v9
-;; @004b                               jump block1(v10)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 4c7f300166e6..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,82 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = global_value.i64 gv1
-;; @0040                               v4 = iadd_imm v3, -4100
-;; @0040                               v5 = icmp ugt v0, v4
-;; @0040                               v6 = global_value.i64 gv2
-;; @0040                               v7 = iadd v6, v0
-;; @0040                               v8 = iadd_imm v7, 4096
-;; @0040                               v9 = iconst.i64 0
-;; @0040                               v10 = select_spectre_guard v5, v9, v8  ; v9 = 0
-;; @0040                               store little heap v1, v10
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0049                               v3 = global_value.i64 gv1
-;; @0049                               v4 = iadd_imm v3, -4100
-;; @0049                               v5 = icmp ugt v0, v4
-;; @0049                               v6 = global_value.i64 gv2
-;; @0049                               v7 = iadd v6, v0
-;; @0049                               v8 = iadd_imm v7, 4096
-;; @0049                               v9 = iconst.i64 0
-;; @0049                               v10 = select_spectre_guard v5, v9, v8  ; v9 = 0
-;; @0049                               v11 = load.i32 little heap v10
-;; @004d                               jump block1(v11)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index fc82ac16b563..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,84 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = iconst.i64 0xffff_0004
-;; @0040                               v4 = uadd_overflow_trap v0, v3, heap_oob  ; v3 = 0xffff_0004
-;; @0040                               v5 = global_value.i64 gv1
-;; @0040                               v6 = icmp ugt v4, v5
-;; @0040                               v7 = global_value.i64 gv2
-;; @0040                               v8 = iadd v7, v0
-;; @0040                               v9 = iadd_imm v8, 0xffff_0000
-;; @0040                               v10 = iconst.i64 0
-;; @0040                               v11 = select_spectre_guard v6, v10, v9  ; v10 = 0
-;; @0040                               store little heap v1, v11
-;; @0047                               jump block1
-;;
-;;                                 block1:
-;; @0047                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @004c                               v3 = iconst.i64 0xffff_0004
-;; @004c                               v4 = uadd_overflow_trap v0, v3, heap_oob  ; v3 = 0xffff_0004
-;; @004c                               v5 = global_value.i64 gv1
-;; @004c                               v6 = icmp ugt v4, v5
-;; @004c                               v7 = global_value.i64 gv2
-;; @004c                               v8 = iadd v7, v0
-;; @004c                               v9 = iadd_imm v8, 0xffff_0000
-;; @004c                               v10 = iconst.i64 0
-;; @004c                               v11 = select_spectre_guard v6, v10, v9  ; v10 = 0
-;; @004c                               v12 = load.i32 little heap v11
-;; @0053                               jump block1(v12)
-;;
-;;                                 block1(v2: i32):
-;; @0053                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index ee6f40ecdeb3..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = global_value.i64 gv1
-;; @0040                               v4 = icmp uge v0, v3
-;; @0040                               v5 = global_value.i64 gv2
-;; @0040                               v6 = iadd v5, v0
-;; @0040                               v7 = iconst.i64 0
-;; @0040                               v8 = select_spectre_guard v4, v7, v6  ; v7 = 0
-;; @0040                               istore8 little heap v1, v8
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0048                               v3 = global_value.i64 gv1
-;; @0048                               v4 = icmp uge v0, v3
-;; @0048                               v5 = global_value.i64 gv2
-;; @0048                               v6 = iadd v5, v0
-;; @0048                               v7 = iconst.i64 0
-;; @0048                               v8 = select_spectre_guard v4, v7, v6  ; v7 = 0
-;; @0048                               v9 = uload8.i32 little heap v8
-;; @004b                               jump block1(v9)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index c68c778f8789..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,82 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = global_value.i64 gv1
-;; @0040                               v4 = iadd_imm v3, -4097
-;; @0040                               v5 = icmp ugt v0, v4
-;; @0040                               v6 = global_value.i64 gv2
-;; @0040                               v7 = iadd v6, v0
-;; @0040                               v8 = iadd_imm v7, 4096
-;; @0040                               v9 = iconst.i64 0
-;; @0040                               v10 = select_spectre_guard v5, v9, v8  ; v9 = 0
-;; @0040                               istore8 little heap v1, v10
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0049                               v3 = global_value.i64 gv1
-;; @0049                               v4 = iadd_imm v3, -4097
-;; @0049                               v5 = icmp ugt v0, v4
-;; @0049                               v6 = global_value.i64 gv2
-;; @0049                               v7 = iadd v6, v0
-;; @0049                               v8 = iadd_imm v7, 4096
-;; @0049                               v9 = iconst.i64 0
-;; @0049                               v10 = select_spectre_guard v5, v9, v8  ; v9 = 0
-;; @0049                               v11 = uload8.i32 little heap v10
-;; @004d                               jump block1(v11)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 694152664d8b..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,84 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = iconst.i64 0xffff_0001
-;; @0040                               v4 = uadd_overflow_trap v0, v3, heap_oob  ; v3 = 0xffff_0001
-;; @0040                               v5 = global_value.i64 gv1
-;; @0040                               v6 = icmp ugt v4, v5
-;; @0040                               v7 = global_value.i64 gv2
-;; @0040                               v8 = iadd v7, v0
-;; @0040                               v9 = iadd_imm v8, 0xffff_0000
-;; @0040                               v10 = iconst.i64 0
-;; @0040                               v11 = select_spectre_guard v6, v10, v9  ; v10 = 0
-;; @0040                               istore8 little heap v1, v11
-;; @0047                               jump block1
-;;
-;;                                 block1:
-;; @0047                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @004c                               v3 = iconst.i64 0xffff_0001
-;; @004c                               v4 = uadd_overflow_trap v0, v3, heap_oob  ; v3 = 0xffff_0001
-;; @004c                               v5 = global_value.i64 gv1
-;; @004c                               v6 = icmp ugt v4, v5
-;; @004c                               v7 = global_value.i64 gv2
-;; @004c                               v8 = iadd v7, v0
-;; @004c                               v9 = iadd_imm v8, 0xffff_0000
-;; @004c                               v10 = iconst.i64 0
-;; @004c                               v11 = select_spectre_guard v6, v10, v9  ; v10 = 0
-;; @004c                               v12 = uload8.i32 little heap v11
-;; @0053                               jump block1(v12)
-;;
-;;                                 block1(v2: i32):
-;; @0053                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 656a44c14efd..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = global_value.i64 gv1
-;; @0040                               v4 = icmp ugt v0, v3
-;; @0040                               trapnz v4, heap_oob
-;; @0040                               v5 = global_value.i64 gv2
-;; @0040                               v6 = iadd v5, v0
-;; @0040                               store little heap v1, v6
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0048                               v3 = global_value.i64 gv1
-;; @0048                               v4 = icmp ugt v0, v3
-;; @0048                               trapnz v4, heap_oob
-;; @0048                               v5 = global_value.i64 gv2
-;; @0048                               v6 = iadd v5, v0
-;; @0048                               v7 = load.i32 little heap v6
-;; @004b                               jump block1(v7)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index c8f3414adea3..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = global_value.i64 gv1
-;; @0040                               v4 = icmp ugt v0, v3
-;; @0040                               trapnz v4, heap_oob
-;; @0040                               v5 = global_value.i64 gv2
-;; @0040                               v6 = iadd v5, v0
-;; @0040                               v7 = iadd_imm v6, 4096
-;; @0040                               store little heap v1, v7
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0049                               v3 = global_value.i64 gv1
-;; @0049                               v4 = icmp ugt v0, v3
-;; @0049                               trapnz v4, heap_oob
-;; @0049                               v5 = global_value.i64 gv2
-;; @0049                               v6 = iadd v5, v0
-;; @0049                               v7 = iadd_imm v6, 4096
-;; @0049                               v8 = load.i32 little heap v7
-;; @004d                               jump block1(v8)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 4f1f011e6fab..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = global_value.i64 gv1
-;; @0040                               v4 = icmp ugt v0, v3
-;; @0040                               trapnz v4, heap_oob
-;; @0040                               v5 = global_value.i64 gv2
-;; @0040                               v6 = iadd v5, v0
-;; @0040                               v7 = iadd_imm v6, 0xffff_0000
-;; @0040                               store little heap v1, v7
-;; @0047                               jump block1
-;;
-;;                                 block1:
-;; @0047                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @004c                               v3 = global_value.i64 gv1
-;; @004c                               v4 = icmp ugt v0, v3
-;; @004c                               trapnz v4, heap_oob
-;; @004c                               v5 = global_value.i64 gv2
-;; @004c                               v6 = iadd v5, v0
-;; @004c                               v7 = iadd_imm v6, 0xffff_0000
-;; @004c                               v8 = load.i32 little heap v7
-;; @0053                               jump block1(v8)
-;;
-;;                                 block1(v2: i32):
-;; @0053                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index e0e5a5379751..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = global_value.i64 gv1
-;; @0040                               v4 = icmp uge v0, v3
-;; @0040                               trapnz v4, heap_oob
-;; @0040                               v5 = global_value.i64 gv2
-;; @0040                               v6 = iadd v5, v0
-;; @0040                               istore8 little heap v1, v6
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0048                               v3 = global_value.i64 gv1
-;; @0048                               v4 = icmp uge v0, v3
-;; @0048                               trapnz v4, heap_oob
-;; @0048                               v5 = global_value.i64 gv2
-;; @0048                               v6 = iadd v5, v0
-;; @0048                               v7 = uload8.i32 little heap v6
-;; @004b                               jump block1(v7)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index d25588855566..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = global_value.i64 gv1
-;; @0040                               v4 = icmp ugt v0, v3
-;; @0040                               trapnz v4, heap_oob
-;; @0040                               v5 = global_value.i64 gv2
-;; @0040                               v6 = iadd v5, v0
-;; @0040                               v7 = iadd_imm v6, 4096
-;; @0040                               istore8 little heap v1, v7
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0049                               v3 = global_value.i64 gv1
-;; @0049                               v4 = icmp ugt v0, v3
-;; @0049                               trapnz v4, heap_oob
-;; @0049                               v5 = global_value.i64 gv2
-;; @0049                               v6 = iadd v5, v0
-;; @0049                               v7 = iadd_imm v6, 4096
-;; @0049                               v8 = uload8.i32 little heap v7
-;; @004d                               jump block1(v8)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index eadb8b32c184..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = global_value.i64 gv1
-;; @0040                               v4 = icmp ugt v0, v3
-;; @0040                               trapnz v4, heap_oob
-;; @0040                               v5 = global_value.i64 gv2
-;; @0040                               v6 = iadd v5, v0
-;; @0040                               v7 = iadd_imm v6, 0xffff_0000
-;; @0040                               istore8 little heap v1, v7
-;; @0047                               jump block1
-;;
-;;                                 block1:
-;; @0047                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @004c                               v3 = global_value.i64 gv1
-;; @004c                               v4 = icmp ugt v0, v3
-;; @004c                               trapnz v4, heap_oob
-;; @004c                               v5 = global_value.i64 gv2
-;; @004c                               v6 = iadd v5, v0
-;; @004c                               v7 = iadd_imm v6, 0xffff_0000
-;; @004c                               v8 = uload8.i32 little heap v7
-;; @0053                               jump block1(v8)
-;;
-;;                                 block1(v2: i32):
-;; @0053                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index c4dd62dc3fc9..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = global_value.i64 gv1
-;; @0040                               v4 = icmp ugt v0, v3
-;; @0040                               v5 = global_value.i64 gv2
-;; @0040                               v6 = iadd v5, v0
-;; @0040                               v7 = iconst.i64 0
-;; @0040                               v8 = select_spectre_guard v4, v7, v6  ; v7 = 0
-;; @0040                               store little heap v1, v8
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0048                               v3 = global_value.i64 gv1
-;; @0048                               v4 = icmp ugt v0, v3
-;; @0048                               v5 = global_value.i64 gv2
-;; @0048                               v6 = iadd v5, v0
-;; @0048                               v7 = iconst.i64 0
-;; @0048                               v8 = select_spectre_guard v4, v7, v6  ; v7 = 0
-;; @0048                               v9 = load.i32 little heap v8
-;; @004b                               jump block1(v9)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index bc6c14897347..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = global_value.i64 gv1
-;; @0040                               v4 = icmp ugt v0, v3
-;; @0040                               v5 = global_value.i64 gv2
-;; @0040                               v6 = iadd v5, v0
-;; @0040                               v7 = iadd_imm v6, 4096
-;; @0040                               v8 = iconst.i64 0
-;; @0040                               v9 = select_spectre_guard v4, v8, v7  ; v8 = 0
-;; @0040                               store little heap v1, v9
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0049                               v3 = global_value.i64 gv1
-;; @0049                               v4 = icmp ugt v0, v3
-;; @0049                               v5 = global_value.i64 gv2
-;; @0049                               v6 = iadd v5, v0
-;; @0049                               v7 = iadd_imm v6, 4096
-;; @0049                               v8 = iconst.i64 0
-;; @0049                               v9 = select_spectre_guard v4, v8, v7  ; v8 = 0
-;; @0049                               v10 = load.i32 little heap v9
-;; @004d                               jump block1(v10)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 501d164e2b49..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = global_value.i64 gv1
-;; @0040                               v4 = icmp ugt v0, v3
-;; @0040                               v5 = global_value.i64 gv2
-;; @0040                               v6 = iadd v5, v0
-;; @0040                               v7 = iadd_imm v6, 0xffff_0000
-;; @0040                               v8 = iconst.i64 0
-;; @0040                               v9 = select_spectre_guard v4, v8, v7  ; v8 = 0
-;; @0040                               store little heap v1, v9
-;; @0047                               jump block1
-;;
-;;                                 block1:
-;; @0047                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @004c                               v3 = global_value.i64 gv1
-;; @004c                               v4 = icmp ugt v0, v3
-;; @004c                               v5 = global_value.i64 gv2
-;; @004c                               v6 = iadd v5, v0
-;; @004c                               v7 = iadd_imm v6, 0xffff_0000
-;; @004c                               v8 = iconst.i64 0
-;; @004c                               v9 = select_spectre_guard v4, v8, v7  ; v8 = 0
-;; @004c                               v10 = load.i32 little heap v9
-;; @0053                               jump block1(v10)
-;;
-;;                                 block1(v2: i32):
-;; @0053                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 309180aea195..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,78 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = global_value.i64 gv1
-;; @0040                               v4 = icmp uge v0, v3
-;; @0040                               v5 = global_value.i64 gv2
-;; @0040                               v6 = iadd v5, v0
-;; @0040                               v7 = iconst.i64 0
-;; @0040                               v8 = select_spectre_guard v4, v7, v6  ; v7 = 0
-;; @0040                               istore8 little heap v1, v8
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0048                               v3 = global_value.i64 gv1
-;; @0048                               v4 = icmp uge v0, v3
-;; @0048                               v5 = global_value.i64 gv2
-;; @0048                               v6 = iadd v5, v0
-;; @0048                               v7 = iconst.i64 0
-;; @0048                               v8 = select_spectre_guard v4, v7, v6  ; v7 = 0
-;; @0048                               v9 = uload8.i32 little heap v8
-;; @004b                               jump block1(v9)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index f4f55950bcdb..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = global_value.i64 gv1
-;; @0040                               v4 = icmp ugt v0, v3
-;; @0040                               v5 = global_value.i64 gv2
-;; @0040                               v6 = iadd v5, v0
-;; @0040                               v7 = iadd_imm v6, 4096
-;; @0040                               v8 = iconst.i64 0
-;; @0040                               v9 = select_spectre_guard v4, v8, v7  ; v8 = 0
-;; @0040                               istore8 little heap v1, v9
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0049                               v3 = global_value.i64 gv1
-;; @0049                               v4 = icmp ugt v0, v3
-;; @0049                               v5 = global_value.i64 gv2
-;; @0049                               v6 = iadd v5, v0
-;; @0049                               v7 = iadd_imm v6, 4096
-;; @0049                               v8 = iconst.i64 0
-;; @0049                               v9 = select_spectre_guard v4, v8, v7  ; v8 = 0
-;; @0049                               v10 = uload8.i32 little heap v9
-;; @004d                               jump block1(v10)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index aad253adbfb8..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,80 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "dynamic", bound = "heap_bound" }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = global_value.i64 gv1
-;; @0040                               v4 = icmp ugt v0, v3
-;; @0040                               v5 = global_value.i64 gv2
-;; @0040                               v6 = iadd v5, v0
-;; @0040                               v7 = iadd_imm v6, 0xffff_0000
-;; @0040                               v8 = iconst.i64 0
-;; @0040                               v9 = select_spectre_guard v4, v8, v7  ; v8 = 0
-;; @0040                               istore8 little heap v1, v9
-;; @0047                               jump block1
-;;
-;;                                 block1:
-;; @0047                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0+8
-;;     gv2 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @004c                               v3 = global_value.i64 gv1
-;; @004c                               v4 = icmp ugt v0, v3
-;; @004c                               v5 = global_value.i64 gv2
-;; @004c                               v6 = iadd v5, v0
-;; @004c                               v7 = iadd_imm v6, 0xffff_0000
-;; @004c                               v8 = iconst.i64 0
-;; @004c                               v9 = select_spectre_guard v4, v8, v7  ; v8 = 0
-;; @004c                               v10 = uload8.i32 little heap v9
-;; @0053                               jump block1(v10)
-;;
-;;                                 block1(v2: i32):
-;; @0053                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 3da0d433a944..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = icmp_imm ugt v3, 0x0fff_fffc
-;; @0040                               trapnz v4, heap_oob
-;; @0040                               v5 = global_value.i64 gv1
-;; @0040                               v6 = iadd v5, v3
-;; @0040                               store little heap v1, v6
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0048                               v3 = uextend.i64 v0
-;; @0048                               v4 = icmp_imm ugt v3, 0x0fff_fffc
-;; @0048                               trapnz v4, heap_oob
-;; @0048                               v5 = global_value.i64 gv1
-;; @0048                               v6 = iadd v5, v3
-;; @0048                               v7 = load.i32 little heap v6
-;; @004b                               jump block1(v7)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 44734b44a023..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = icmp_imm ugt v3, 0x0fff_effc
-;; @0040                               trapnz v4, heap_oob
-;; @0040                               v5 = global_value.i64 gv1
-;; @0040                               v6 = iadd v5, v3
-;; @0040                               v7 = iadd_imm v6, 4096
-;; @0040                               store little heap v1, v7
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0049                               v3 = uextend.i64 v0
-;; @0049                               v4 = icmp_imm ugt v3, 0x0fff_effc
-;; @0049                               trapnz v4, heap_oob
-;; @0049                               v5 = global_value.i64 gv1
-;; @0049                               v6 = iadd v5, v3
-;; @0049                               v7 = iadd_imm v6, 4096
-;; @0049                               v8 = load.i32 little heap v7
-;; @004d                               jump block1(v8)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 38a9566727a0..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,56 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               trap heap_oob
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @004c                               v3 = uextend.i64 v0
-;; @004c                               trap heap_oob
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index acae947c597d..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = icmp_imm ugt v3, 0x0fff_ffff
-;; @0040                               trapnz v4, heap_oob
-;; @0040                               v5 = global_value.i64 gv1
-;; @0040                               v6 = iadd v5, v3
-;; @0040                               istore8 little heap v1, v6
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0048                               v3 = uextend.i64 v0
-;; @0048                               v4 = icmp_imm ugt v3, 0x0fff_ffff
-;; @0048                               trapnz v4, heap_oob
-;; @0048                               v5 = global_value.i64 gv1
-;; @0048                               v6 = iadd v5, v3
-;; @0048                               v7 = uload8.i32 little heap v6
-;; @004b                               jump block1(v7)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 29d67fe8a912..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = icmp_imm ugt v3, 0x0fff_efff
-;; @0040                               trapnz v4, heap_oob
-;; @0040                               v5 = global_value.i64 gv1
-;; @0040                               v6 = iadd v5, v3
-;; @0040                               v7 = iadd_imm v6, 4096
-;; @0040                               istore8 little heap v1, v7
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0049                               v3 = uextend.i64 v0
-;; @0049                               v4 = icmp_imm ugt v3, 0x0fff_efff
-;; @0049                               trapnz v4, heap_oob
-;; @0049                               v5 = global_value.i64 gv1
-;; @0049                               v6 = iadd v5, v3
-;; @0049                               v7 = iadd_imm v6, 4096
-;; @0049                               v8 = uload8.i32 little heap v7
-;; @004d                               jump block1(v8)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 1eec80fbfcf9..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,56 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               trap heap_oob
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @004c                               v3 = uextend.i64 v0
-;; @004c                               trap heap_oob
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 2a56e4567375..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = icmp_imm ugt v3, 0x0fff_fffc
-;; @0040                               v5 = global_value.i64 gv1
-;; @0040                               v6 = iadd v5, v3
-;; @0040                               v7 = iconst.i64 0
-;; @0040                               v8 = select_spectre_guard v4, v7, v6  ; v7 = 0
-;; @0040                               store little heap v1, v8
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0048                               v3 = uextend.i64 v0
-;; @0048                               v4 = icmp_imm ugt v3, 0x0fff_fffc
-;; @0048                               v5 = global_value.i64 gv1
-;; @0048                               v6 = iadd v5, v3
-;; @0048                               v7 = iconst.i64 0
-;; @0048                               v8 = select_spectre_guard v4, v7, v6  ; v7 = 0
-;; @0048                               v9 = load.i32 little heap v8
-;; @004b                               jump block1(v9)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 902597df6514..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = icmp_imm ugt v3, 0x0fff_effc
-;; @0040                               v5 = global_value.i64 gv1
-;; @0040                               v6 = iadd v5, v3
-;; @0040                               v7 = iadd_imm v6, 4096
-;; @0040                               v8 = iconst.i64 0
-;; @0040                               v9 = select_spectre_guard v4, v8, v7  ; v8 = 0
-;; @0040                               store little heap v1, v9
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0049                               v3 = uextend.i64 v0
-;; @0049                               v4 = icmp_imm ugt v3, 0x0fff_effc
-;; @0049                               v5 = global_value.i64 gv1
-;; @0049                               v6 = iadd v5, v3
-;; @0049                               v7 = iadd_imm v6, 4096
-;; @0049                               v8 = iconst.i64 0
-;; @0049                               v9 = select_spectre_guard v4, v8, v7  ; v8 = 0
-;; @0049                               v10 = load.i32 little heap v9
-;; @004d                               jump block1(v10)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 4e906a0097d2..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,56 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               trap heap_oob
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @004c                               v3 = uextend.i64 v0
-;; @004c                               trap heap_oob
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 4d4ecb64f71c..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = icmp_imm ugt v3, 0x0fff_ffff
-;; @0040                               v5 = global_value.i64 gv1
-;; @0040                               v6 = iadd v5, v3
-;; @0040                               v7 = iconst.i64 0
-;; @0040                               v8 = select_spectre_guard v4, v7, v6  ; v7 = 0
-;; @0040                               istore8 little heap v1, v8
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0048                               v3 = uextend.i64 v0
-;; @0048                               v4 = icmp_imm ugt v3, 0x0fff_ffff
-;; @0048                               v5 = global_value.i64 gv1
-;; @0048                               v6 = iadd v5, v3
-;; @0048                               v7 = iconst.i64 0
-;; @0048                               v8 = select_spectre_guard v4, v7, v6  ; v7 = 0
-;; @0048                               v9 = uload8.i32 little heap v8
-;; @004b                               jump block1(v9)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index a5043ee3fbbe..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,76 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = icmp_imm ugt v3, 0x0fff_efff
-;; @0040                               v5 = global_value.i64 gv1
-;; @0040                               v6 = iadd v5, v3
-;; @0040                               v7 = iadd_imm v6, 4096
-;; @0040                               v8 = iconst.i64 0
-;; @0040                               v9 = select_spectre_guard v4, v8, v7  ; v8 = 0
-;; @0040                               istore8 little heap v1, v9
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0049                               v3 = uextend.i64 v0
-;; @0049                               v4 = icmp_imm ugt v3, 0x0fff_efff
-;; @0049                               v5 = global_value.i64 gv1
-;; @0049                               v6 = iadd v5, v3
-;; @0049                               v7 = iadd_imm v6, 4096
-;; @0049                               v8 = iconst.i64 0
-;; @0049                               v9 = select_spectre_guard v4, v8, v7  ; v8 = 0
-;; @0049                               v10 = uload8.i32 little heap v9
-;; @004d                               jump block1(v10)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index cb81063e2bb3..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,56 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               trap heap_oob
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @004c                               v3 = uextend.i64 v0
-;; @004c                               trap heap_oob
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 9b6881e65b1a..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd v4, v3
-;; @0040                               store little heap v1, v5
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0048                               v3 = uextend.i64 v0
-;; @0048                               v4 = global_value.i64 gv1
-;; @0048                               v5 = iadd v4, v3
-;; @0048                               v6 = load.i32 little heap v5
-;; @004b                               jump block1(v6)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index a7b43d2075fb..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd v4, v3
-;; @0040                               v6 = iadd_imm v5, 4096
-;; @0040                               store little heap v1, v6
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0049                               v3 = uextend.i64 v0
-;; @0049                               v4 = global_value.i64 gv1
-;; @0049                               v5 = iadd v4, v3
-;; @0049                               v6 = iadd_imm v5, 4096
-;; @0049                               v7 = load.i32 little heap v6
-;; @004d                               jump block1(v7)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index c89980fea651..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,56 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               trap heap_oob
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @004c                               v3 = uextend.i64 v0
-;; @004c                               trap heap_oob
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 463974ba4d4a..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd v4, v3
-;; @0040                               istore8 little heap v1, v5
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0048                               v3 = uextend.i64 v0
-;; @0048                               v4 = global_value.i64 gv1
-;; @0048                               v5 = iadd v4, v3
-;; @0048                               v6 = uload8.i32 little heap v5
-;; @004b                               jump block1(v6)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 2764a8734e04..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd v4, v3
-;; @0040                               v6 = iadd_imm v5, 4096
-;; @0040                               istore8 little heap v1, v6
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0049                               v3 = uextend.i64 v0
-;; @0049                               v4 = global_value.i64 gv1
-;; @0049                               v5 = iadd v4, v3
-;; @0049                               v6 = iadd_imm v5, 4096
-;; @0049                               v7 = uload8.i32 little heap v6
-;; @004d                               jump block1(v7)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 9b9b2f48263c..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,56 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               trap heap_oob
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @004c                               v3 = uextend.i64 v0
-;; @004c                               trap heap_oob
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 9151ef442b7f..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd v4, v3
-;; @0040                               store little heap v1, v5
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0048                               v3 = uextend.i64 v0
-;; @0048                               v4 = global_value.i64 gv1
-;; @0048                               v5 = iadd v4, v3
-;; @0048                               v6 = load.i32 little heap v5
-;; @004b                               jump block1(v6)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index ff6527a8b67c..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd v4, v3
-;; @0040                               v6 = iadd_imm v5, 4096
-;; @0040                               store little heap v1, v6
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0049                               v3 = uextend.i64 v0
-;; @0049                               v4 = global_value.i64 gv1
-;; @0049                               v5 = iadd v4, v3
-;; @0049                               v6 = iadd_imm v5, 4096
-;; @0049                               v7 = load.i32 little heap v6
-;; @004d                               jump block1(v7)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index fb6cd492543d..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,56 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               trap heap_oob
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @004c                               v3 = uextend.i64 v0
-;; @004c                               trap heap_oob
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 58e13849d186..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,68 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd v4, v3
-;; @0040                               istore8 little heap v1, v5
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0048                               v3 = uextend.i64 v0
-;; @0048                               v4 = global_value.i64 gv1
-;; @0048                               v5 = iadd v4, v3
-;; @0048                               v6 = uload8.i32 little heap v5
-;; @004b                               jump block1(v6)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 25153188f6bd..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd v4, v3
-;; @0040                               v6 = iadd_imm v5, 4096
-;; @0040                               istore8 little heap v1, v6
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @0049                               v3 = uextend.i64 v0
-;; @0049                               v4 = global_value.i64 gv1
-;; @0049                               v5 = iadd v4, v3
-;; @0049                               v6 = iadd_imm v5, 4096
-;; @0049                               v7 = uload8.i32 little heap v6
-;; @004d                               jump block1(v7)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 3603eb0f520c..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,56 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i32"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i32 1)
-
-  (func (export "do_store") (param i32 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i32) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0(i32, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i32, v2: i64):
-;; @0040                               v3 = uextend.i64 v0
-;; @0040                               trap heap_oob
-;; }
-;;
-;; function u0:1(i32, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i32, v1: i64):
-;; @004c                               v3 = uextend.i64 v0
-;; @004c                               trap heap_oob
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index a6924a9af8d8..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = icmp_imm ugt v0, 0x0fff_fffc
-;; @0040                               trapnz v3, heap_oob
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd v4, v0
-;; @0040                               store little heap v1, v5
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0048                               v3 = icmp_imm ugt v0, 0x0fff_fffc
-;; @0048                               trapnz v3, heap_oob
-;; @0048                               v4 = global_value.i64 gv1
-;; @0048                               v5 = iadd v4, v0
-;; @0048                               v6 = load.i32 little heap v5
-;; @004b                               jump block1(v6)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index bff5b7a49b84..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = icmp_imm ugt v0, 0x0fff_effc
-;; @0040                               trapnz v3, heap_oob
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd v4, v0
-;; @0040                               v6 = iadd_imm v5, 4096
-;; @0040                               store little heap v1, v6
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0049                               v3 = icmp_imm ugt v0, 0x0fff_effc
-;; @0049                               trapnz v3, heap_oob
-;; @0049                               v4 = global_value.i64 gv1
-;; @0049                               v5 = iadd v4, v0
-;; @0049                               v6 = iadd_imm v5, 4096
-;; @0049                               v7 = load.i32 little heap v6
-;; @004d                               jump block1(v7)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 151d19741c0f..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,54 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               trap heap_oob
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @004c                               trap heap_oob
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 34f78ee4e832..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = icmp_imm ugt v0, 0x0fff_ffff
-;; @0040                               trapnz v3, heap_oob
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd v4, v0
-;; @0040                               istore8 little heap v1, v5
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0048                               v3 = icmp_imm ugt v0, 0x0fff_ffff
-;; @0048                               trapnz v3, heap_oob
-;; @0048                               v4 = global_value.i64 gv1
-;; @0048                               v5 = iadd v4, v0
-;; @0048                               v6 = uload8.i32 little heap v5
-;; @004b                               jump block1(v6)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 6218cb0e8806..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = icmp_imm ugt v0, 0x0fff_efff
-;; @0040                               trapnz v3, heap_oob
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd v4, v0
-;; @0040                               v6 = iadd_imm v5, 4096
-;; @0040                               istore8 little heap v1, v6
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0049                               v3 = icmp_imm ugt v0, 0x0fff_efff
-;; @0049                               trapnz v3, heap_oob
-;; @0049                               v4 = global_value.i64 gv1
-;; @0049                               v5 = iadd v4, v0
-;; @0049                               v6 = iadd_imm v5, 4096
-;; @0049                               v7 = uload8.i32 little heap v6
-;; @004d                               jump block1(v7)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 1a7729d88a6c..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,54 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               trap heap_oob
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @004c                               trap heap_oob
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 012ea8d5905a..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = icmp_imm ugt v0, 0x0fff_fffc
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd v4, v0
-;; @0040                               v6 = iconst.i64 0
-;; @0040                               v7 = select_spectre_guard v3, v6, v5  ; v6 = 0
-;; @0040                               store little heap v1, v7
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0048                               v3 = icmp_imm ugt v0, 0x0fff_fffc
-;; @0048                               v4 = global_value.i64 gv1
-;; @0048                               v5 = iadd v4, v0
-;; @0048                               v6 = iconst.i64 0
-;; @0048                               v7 = select_spectre_guard v3, v6, v5  ; v6 = 0
-;; @0048                               v8 = load.i32 little heap v7
-;; @004b                               jump block1(v8)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 44bffc8e0cf6..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = icmp_imm ugt v0, 0x0fff_effc
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd v4, v0
-;; @0040                               v6 = iadd_imm v5, 4096
-;; @0040                               v7 = iconst.i64 0
-;; @0040                               v8 = select_spectre_guard v3, v7, v6  ; v7 = 0
-;; @0040                               store little heap v1, v8
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0049                               v3 = icmp_imm ugt v0, 0x0fff_effc
-;; @0049                               v4 = global_value.i64 gv1
-;; @0049                               v5 = iadd v4, v0
-;; @0049                               v6 = iadd_imm v5, 4096
-;; @0049                               v7 = iconst.i64 0
-;; @0049                               v8 = select_spectre_guard v3, v7, v6  ; v7 = 0
-;; @0049                               v9 = load.i32 little heap v8
-;; @004d                               jump block1(v9)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 9d0e47fc048d..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,54 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               trap heap_oob
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @004c                               trap heap_oob
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 7850ca73f978..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = icmp_imm ugt v0, 0x0fff_ffff
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd v4, v0
-;; @0040                               v6 = iconst.i64 0
-;; @0040                               v7 = select_spectre_guard v3, v6, v5  ; v6 = 0
-;; @0040                               istore8 little heap v1, v7
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0048                               v3 = icmp_imm ugt v0, 0x0fff_ffff
-;; @0048                               v4 = global_value.i64 gv1
-;; @0048                               v5 = iadd v4, v0
-;; @0048                               v6 = iconst.i64 0
-;; @0048                               v7 = select_spectre_guard v3, v6, v5  ; v6 = 0
-;; @0048                               v8 = uload8.i32 little heap v7
-;; @004b                               jump block1(v8)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index e6597d66d1e3..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = icmp_imm ugt v0, 0x0fff_efff
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd v4, v0
-;; @0040                               v6 = iadd_imm v5, 4096
-;; @0040                               v7 = iconst.i64 0
-;; @0040                               v8 = select_spectre_guard v3, v7, v6  ; v7 = 0
-;; @0040                               istore8 little heap v1, v8
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0049                               v3 = icmp_imm ugt v0, 0x0fff_efff
-;; @0049                               v4 = global_value.i64 gv1
-;; @0049                               v5 = iadd v4, v0
-;; @0049                               v6 = iadd_imm v5, 4096
-;; @0049                               v7 = iconst.i64 0
-;; @0049                               v8 = select_spectre_guard v3, v7, v6  ; v7 = 0
-;; @0049                               v9 = uload8.i32 little heap v8
-;; @004d                               jump block1(v9)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 1ba900ed2d24..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,54 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               trap heap_oob
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @004c                               trap heap_oob
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
deleted file mode 100644
index 17be28d960ae..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = icmp_imm ugt v0, 0x0fff_fffc
-;; @0040                               trapnz v3, heap_oob
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd v4, v0
-;; @0040                               store little heap v1, v5
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0048                               v3 = icmp_imm ugt v0, 0x0fff_fffc
-;; @0048                               trapnz v3, heap_oob
-;; @0048                               v4 = global_value.i64 gv1
-;; @0048                               v5 = iadd v4, v0
-;; @0048                               v6 = load.i32 little heap v5
-;; @004b                               jump block1(v6)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index 0527549ce39e..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = icmp_imm ugt v0, 0x0fff_effc
-;; @0040                               trapnz v3, heap_oob
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd v4, v0
-;; @0040                               v6 = iadd_imm v5, 4096
-;; @0040                               store little heap v1, v6
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0049                               v3 = icmp_imm ugt v0, 0x0fff_effc
-;; @0049                               trapnz v3, heap_oob
-;; @0049                               v4 = global_value.i64 gv1
-;; @0049                               v5 = iadd v4, v0
-;; @0049                               v6 = iadd_imm v5, 4096
-;; @0049                               v7 = load.i32 little heap v6
-;; @004d                               jump block1(v7)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index 10e61b6b121d..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,54 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               trap heap_oob
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @004c                               trap heap_oob
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
deleted file mode 100644
index c9ad77fa55c0..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,70 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = icmp_imm ugt v0, 0x0fff_ffff
-;; @0040                               trapnz v3, heap_oob
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd v4, v0
-;; @0040                               istore8 little heap v1, v5
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0048                               v3 = icmp_imm ugt v0, 0x0fff_ffff
-;; @0048                               trapnz v3, heap_oob
-;; @0048                               v4 = global_value.i64 gv1
-;; @0048                               v5 = iadd v4, v0
-;; @0048                               v6 = uload8.i32 little heap v5
-;; @004b                               jump block1(v6)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index cb8badc5518e..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = icmp_imm ugt v0, 0x0fff_efff
-;; @0040                               trapnz v3, heap_oob
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd v4, v0
-;; @0040                               v6 = iadd_imm v5, 4096
-;; @0040                               istore8 little heap v1, v6
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0049                               v3 = icmp_imm ugt v0, 0x0fff_efff
-;; @0049                               trapnz v3, heap_oob
-;; @0049                               v4 = global_value.i64 gv1
-;; @0049                               v5 = iadd v4, v0
-;; @0049                               v6 = iadd_imm v5, 4096
-;; @0049                               v7 = uload8.i32 little heap v6
-;; @004d                               jump block1(v7)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index 96de204b22ae..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,54 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=false']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               trap heap_oob
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @004c                               trap heap_oob
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
deleted file mode 100644
index bb88fdca4d7c..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = icmp_imm ugt v0, 0x0fff_fffc
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd v4, v0
-;; @0040                               v6 = iconst.i64 0
-;; @0040                               v7 = select_spectre_guard v3, v6, v5  ; v6 = 0
-;; @0040                               store little heap v1, v7
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0048                               v3 = icmp_imm ugt v0, 0x0fff_fffc
-;; @0048                               v4 = global_value.i64 gv1
-;; @0048                               v5 = iadd v4, v0
-;; @0048                               v6 = iconst.i64 0
-;; @0048                               v7 = select_spectre_guard v3, v6, v5  ; v6 = 0
-;; @0048                               v8 = load.i32 little heap v7
-;; @004b                               jump block1(v8)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
deleted file mode 100644
index db80822e8fb0..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0x1000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = icmp_imm ugt v0, 0x0fff_effc
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd v4, v0
-;; @0040                               v6 = iadd_imm v5, 4096
-;; @0040                               v7 = iconst.i64 0
-;; @0040                               v8 = select_spectre_guard v3, v7, v6  ; v7 = 0
-;; @0040                               store little heap v1, v8
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0049                               v3 = icmp_imm ugt v0, 0x0fff_effc
-;; @0049                               v4 = global_value.i64 gv1
-;; @0049                               v5 = iadd v4, v0
-;; @0049                               v6 = iadd_imm v5, 4096
-;; @0049                               v7 = iconst.i64 0
-;; @0049                               v8 = select_spectre_guard v3, v7, v6  ; v7 = 0
-;; @0049                               v9 = load.i32 little heap v8
-;; @004d                               jump block1(v9)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
deleted file mode 100644
index d17f9c5d0545..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,54 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load offset=0xffff0000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               trap heap_oob
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @004c                               trap heap_oob
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
deleted file mode 100644
index 93c4b1e5e14c..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
+++ /dev/null
@@ -1,72 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = icmp_imm ugt v0, 0x0fff_ffff
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd v4, v0
-;; @0040                               v6 = iconst.i64 0
-;; @0040                               v7 = select_spectre_guard v3, v6, v5  ; v6 = 0
-;; @0040                               istore8 little heap v1, v7
-;; @0043                               jump block1
-;;
-;;                                 block1:
-;; @0043                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0048                               v3 = icmp_imm ugt v0, 0x0fff_ffff
-;; @0048                               v4 = global_value.i64 gv1
-;; @0048                               v5 = iadd v4, v0
-;; @0048                               v6 = iconst.i64 0
-;; @0048                               v7 = select_spectre_guard v3, v6, v5  ; v6 = 0
-;; @0048                               v8 = uload8.i32 little heap v7
-;; @004b                               jump block1(v8)
-;;
-;;                                 block1(v2: i32):
-;; @004b                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
deleted file mode 100644
index 98344abf7a8d..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
+++ /dev/null
@@ -1,74 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0x1000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0x1000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               v3 = icmp_imm ugt v0, 0x0fff_efff
-;; @0040                               v4 = global_value.i64 gv1
-;; @0040                               v5 = iadd v4, v0
-;; @0040                               v6 = iadd_imm v5, 4096
-;; @0040                               v7 = iconst.i64 0
-;; @0040                               v8 = select_spectre_guard v3, v7, v6  ; v7 = 0
-;; @0040                               istore8 little heap v1, v8
-;; @0044                               jump block1
-;;
-;;                                 block1:
-;; @0044                               return
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @0049                               v3 = icmp_imm ugt v0, 0x0fff_efff
-;; @0049                               v4 = global_value.i64 gv1
-;; @0049                               v5 = iadd v4, v0
-;; @0049                               v6 = iadd_imm v5, 4096
-;; @0049                               v7 = iconst.i64 0
-;; @0049                               v8 = select_spectre_guard v3, v7, v6  ; v7 = 0
-;; @0049                               v9 = uload8.i32 little heap v8
-;; @004d                               jump block1(v9)
-;;
-;;                                 block1(v2: i32):
-;; @004d                               return v2
-;; }
diff --git a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
deleted file mode 100644
index cfd6a406b20f..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
+++ /dev/null
@@ -1,54 +0,0 @@
-;;! target = "x86_64"
-;;!
-;;! settings = ['enable_heap_access_spectre_mitigation=true']
-;;!
-;;! compile = false
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-;;! # (no heap_bound global for static heaps)
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = 0xffffffff
-;;! index_type = "i64"
-;;! style = { kind = "static", bound = 0x10000000 }
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory i64 1)
-
-  (func (export "do_store") (param i64 i32)
-    local.get 0
-    local.get 1
-    i32.store8 offset=0xffff0000)
-
-  (func (export "do_load") (param i64) (result i32)
-    local.get 0
-    i32.load8_u offset=0xffff0000))
-
-;; function u0:0(i64, i32, i64 vmctx) fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i32, v2: i64):
-;; @0040                               trap heap_oob
-;; }
-;;
-;; function u0:1(i64, i64 vmctx) -> i32 fast {
-;;     gv0 = vmctx
-;;     gv1 = load.i64 notrap aligned readonly gv0
-;;
-;;                                 block0(v0: i64, v1: i64):
-;; @004c                               trap heap_oob
-;; }
\ No newline at end of file
diff --git a/cranelift/filetests/filetests/wasm/load-store/make-load-store-tests.sh b/cranelift/filetests/filetests/wasm/load-store/make-load-store-tests.sh
deleted file mode 100755
index a4b1d1ae0357..000000000000
--- a/cranelift/filetests/filetests/wasm/load-store/make-load-store-tests.sh
+++ /dev/null
@@ -1,134 +0,0 @@
-#!/usr/bin/env bash
-
-# This script generates the `load_store_*.clif` test files.
-#
-# Usage:
-#
-#     $ ./make-load-store-tests.sh
-
-set -e
-cd $(dirname "$0")
-
-function main {
-    for spectre in "yes" "no"; do
-        for guard in "0" "0xffffffff"; do
-            for index_type in "i32" "i64"; do
-                for kind in "static" "dynamic"; do
-                    for access_type in "i32" "i8"; do
-                        for offset in "0" "0x1000" "0xffff0000"; do
-                            generate_one_test $kind $index_type $guard $spectre $access_type $offset x86_64 false
-                            for target in "x86_64" "aarch64" "s390x" "riscv64"; do
-                                generate_one_test $kind $index_type $guard $spectre $access_type $offset $target true
-                            done
-                        done
-                    done
-                done
-            done
-        done
-    done
-    echo "Done!"
-}
-
-function generate_one_test() {
-    local kind=$1
-    local index_type=$2
-    local guard=$3
-    local spectre=$4
-    local access_type=$5
-    local offset=$6
-    local target=$7
-    local compile=$8
-
-    local filename="load_store_${kind}_kind_${index_type}_index_${guard}_guard_${spectre}_spectre_${access_type}_access_${offset}_offset.wat"
-    if [[ $compile == "true" ]]; then
-        local target_dir=${target}
-        if [[ $target == "x86_64" ]]; then
-            target_dir="x64"
-        fi
-        filename="../../isa/${target_dir}/wasm/${filename}"
-    fi
-    echo "Generating $filename..."
-
-    local enable_spectre=true
-    if [[ $spectre == "no" ]]; then
-        enable_spectre=false
-    fi
-    local settings="['enable_heap_access_spectre_mitigation=$enable_spectre']"
-
-    local store_op=
-    local load_op=
-    case $access_type in
-        "i32")
-            store_op="i32.store"
-            load_op="i32.load"
-            ;;
-        "i8")
-            store_op="i32.store8"
-            load_op="i32.load8_u"
-            ;;
-    esac
-
-    local bound_global=""
-    local style=""
-    case $kind in
-        "dynamic")
-            bound_global=$(cat <<EOF
-;;! [globals.heap_bound]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 8, readonly = true }
-EOF
-                        )
-            style='{ kind = "dynamic", bound = "heap_bound" }'
-            ;;
-        "static")
-            bound_global=";;! # (no heap_bound global for static heaps)"
-            style='{ kind = "static", bound = 0x10000000 }'
-        ;;
-    esac
-
-    cat <<EOF > "$filename"
-;;! target = "${target}"
-;;!
-;;! settings = ${settings}
-;;!
-;;! compile = ${compile}
-;;!
-;;! [globals.vmctx]
-;;! type = "i64"
-;;! vmctx = true
-;;!
-;;! [globals.heap_base]
-;;! type = "i64"
-;;! load = { base = "vmctx", offset = 0, readonly = true }
-;;!
-${bound_global}
-;;!
-;;! [[heaps]]
-;;! base = "heap_base"
-;;! min_size = 0x10000
-;;! offset_guard_size = ${guard}
-;;! index_type = "${index_type}"
-;;! style = ${style}
-
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
-;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-
-(module
-  (memory ${index_type} 1)
-
-  (func (export "do_store") (param ${index_type} i32)
-    local.get 0
-    local.get 1
-    ${store_op} offset=${offset})
-
-  (func (export "do_load") (param ${index_type}) (result i32)
-    local.get 0
-    ${load_op} offset=${offset}))
-
-;; TODO: run with the 'CRANELIFT_TEST_BLESS=1' env var set to update this test's
-;; expected output.
-EOF
-}
-
-main
diff --git a/cranelift/filetests/filetests/wasm/r32.clif b/cranelift/filetests/filetests/wasm/r32.clif
deleted file mode 100644
index 4ac3f3701b7a..000000000000
--- a/cranelift/filetests/filetests/wasm/r32.clif
+++ /dev/null
@@ -1,75 +0,0 @@
-; Test basic code generation for 32-bit reftypes
-; This test is the 32-bit version of r64.clif. If you change this test you
-; should most likely update that test as well.
-test compile
-set enable_safepoints=true
-
-target aarch64
-target i686 haswell
-
-function %select_ref(i32, r32, r32) -> r32 {
-block0(v0: i32, v1: r32, v2: r32):
-    brif v0, block1(v1), block1(v2)
-
-block1(v3: r32):
-    return v3
-}
-
-function %table_set(i32, r32, i32 vmctx) {
-    gv0 = vmctx
-    gv1 = load.i32 notrap aligned gv0
-    gv2 = load.i32 notrap aligned gv0 +4
-    table0 = dynamic gv1, element_size 1, bound gv2, index_type i32
-
-block0(v0: i32, v1: r32, v2: i32):
-    v3 = table_addr.i32 table0, v0, +0;
-    store.r32 notrap aligned v1, v3
-    return
-}
-
-function %table_get(i32, i32 vmctx) -> r32 {
-    gv0 = vmctx
-    gv1 = load.i32 notrap aligned gv0
-    gv2 = load.i32 notrap aligned gv0 +4
-    table0 = dynamic gv1, element_size 1, bound gv2, index_type i32
-
-block0(v0: i32, v1: i32):
-    v2 = table_addr.i32 table0, v0, +0;
-    v3 = load.r32 notrap aligned v2
-    return v3
-}
-
-function %test_refs(r32, r32, r32, i32 vmctx) {
-    fn0 = %select_ref(i32, r32, r32) -> r32
-    fn1 = %table_set(i32, r32, i32 vmctx)
-    fn2 = %table_get(i32, i32 vmctx) -> r32
-
-block0(v0: r32, v1: r32, v2: r32, v3: i32):
-    v4 = iconst.i32 0
-    v5 = iconst.i32 1
-    v8 = iconst.i32 2
-
-    ; Shuffle around the first two refs
-    v6 = call fn0(v4, v0, v1)
-    v7 = call fn0(v5, v0, v1)
-
-    ; Store in the table
-    call fn1(v4, v6, v3)
-    call fn1(v5, v7, v3)
-    call fn1(v8, v2, v3)
-
-    ; Load from the table
-    v9 = call fn2(v4, v3)
-    v10 = call fn2(v5, v3)
-    v11 = call fn2(v8, v3)
-
-    ; Compare the results
-    v12 = is_null v9
-    trapnz v12, user0
-    v13 = is_null v10
-    trapnz v13, user0
-    v14 = is_invalid v11
-    trapnz v14, user0
-
-    return
-}
diff --git a/cranelift/filetests/filetests/wasm/r64.clif b/cranelift/filetests/filetests/wasm/r64.clif
deleted file mode 100644
index 74f6c7764063..000000000000
--- a/cranelift/filetests/filetests/wasm/r64.clif
+++ /dev/null
@@ -1,75 +0,0 @@
-; Test basic code generation for 64-bit reftypes
-; This test is the 64-bit version of r32.clif. If you change this test you
-; should most likely update that test as well.
-test compile
-set enable_safepoints=true
-
-target aarch64
-target x86_64 haswell
-
-function %select_ref(i32, r64, r64) -> r64 {
-block0(v0: i32, v1: r64, v2: r64):
-    brif v0, block1(v1), block1(v2)
-
-block1(v3: r64):
-    return v3
-}
-
-function %table_set(i32, r64, i64 vmctx) {
-    gv0 = vmctx
-    gv1 = load.i64 notrap aligned gv0
-    gv2 = load.i32 notrap aligned gv0 +8
-    table0 = dynamic gv1, element_size 1, bound gv2, index_type i32
-
-block0(v0: i32, v1: r64, v2: i64):
-    v3 = table_addr.i64 table0, v0+0;
-    store.r64 notrap aligned v1, v3
-    return
-}
-
-function %table_get(i32, i64 vmctx) -> r64 {
-    gv0 = vmctx
-    gv1 = load.i64 notrap aligned gv0
-    gv2 = load.i32 notrap aligned gv0 +8
-    table0 = dynamic gv1, element_size 1, bound gv2, index_type i32
-
-block0(v0: i32, v1: i64):
-    v2 = table_addr.i64 table0, v0+0;
-    v3 = load.r64 notrap aligned v2
-    return v3
-}
-
-function %test_refs(r64, r64, r64, i64 vmctx) {
-    fn0 = %select_ref(i32, r64, r64) -> r64
-    fn1 = %table_set(i32, r64, i64 vmctx)
-    fn2 = %table_get(i32, i64 vmctx) -> r64
-
-block0(v0: r64, v1: r64, v2: r64, v3: i64):
-    v4 = iconst.i32 0
-    v5 = iconst.i32 1
-    v8 = iconst.i32 2
-
-    ; Shuffle around the first two refs
-    v6 = call fn0(v4, v0, v1)
-    v7 = call fn0(v5, v0, v1)
-
-    ; Store in the table
-    call fn1(v4, v6, v3)
-    call fn1(v5, v7, v3)
-    call fn1(v8, v2, v3)
-
-    ; Load from the table
-    v9 = call fn2(v4, v3)
-    v10 = call fn2(v5, v3)
-    v11 = call fn2(v8, v3)
-
-    ; Compare the results
-    v12 = is_null v9
-    trapnz v12, user0
-    v13 = is_null v10
-    trapnz v13, user0
-    v14 = is_invalid v11
-    trapnz v14, user0
-
-    return
-}
diff --git a/cranelift/filetests/filetests/wasm/x64-bmi1.wat b/cranelift/filetests/filetests/wasm/x64-bmi1.wat
deleted file mode 100644
index b23120c780b9..000000000000
--- a/cranelift/filetests/filetests/wasm/x64-bmi1.wat
+++ /dev/null
@@ -1,176 +0,0 @@
-;;! target = "x86_64"
-;;! compile = true
-;;! settings = ["has_bmi1", "opt_level=speed", "has_avx"]
-
-(module
-  (func (export "blsi32") (param i32) (result i32)
-    (i32.and
-      (local.get 0)
-      (i32.sub (i32.const 0) (local.get 0))))
-
-  (func (export "blsi64") (param i64) (result i64)
-    (i64.and
-      (local.get 0)
-      (i64.sub (i64.const 0) (local.get 0))))
-
-  (func (export "blsr32") (param i32) (result i32)
-    (i32.and
-      (local.get 0)
-      (i32.add (local.get 0) (i32.const -1))))
-
-  (func (export "blsr64") (param i64) (result i64)
-    (i64.and
-      (local.get 0)
-      (i64.sub (local.get 0) (i64.const 1))))
-
-  (func (export "blsmsk32") (param i32) (result i32)
-    (i32.xor
-      (local.get 0)
-      (i32.sub (local.get 0) (i32.const 1))))
-
-  (func (export "blsmsk64") (param i64) (result i64)
-    (i64.xor
-      (local.get 0)
-      (i64.add (local.get 0) (i64.const -1))))
-
-  (func (export "tzcnt32") (param i32) (result i32)
-    (i32.ctz (local.get 0)))
-
-  (func (export "tzcnt64") (param i64) (result i64)
-    (i64.ctz (local.get 0)))
-
-  (func (export "andn32") (param i32 i32) (result i32)
-    (i32.and (local.get 0) (i32.xor (local.get 1) (i32.const -1))))
-
-  (func (export "andn64") (param i64 i64) (result i64)
-    (i64.and (local.get 0) (i64.xor (local.get 1) (i64.const -1))))
-)
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   blsil   %edi, %eax
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   blsiq   %rdi, %rax
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:2:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   blsrl   %edi, %eax
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:3:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   blsrq   %rdi, %rax
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:4:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   blsmskl %edi, %eax
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:5:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   blsmskq %rdi, %rax
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:6:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   tzcntl  %edi, %eax
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:7:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   tzcntq  %rdi, %rax
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:8:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   andn    %edi, %esi, %eax
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:9:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   andn    %rdi, %rsi, %rax
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/wasm/x64-bmi2.wat b/cranelift/filetests/filetests/wasm/x64-bmi2.wat
deleted file mode 100644
index 21418a017e82..000000000000
--- a/cranelift/filetests/filetests/wasm/x64-bmi2.wat
+++ /dev/null
@@ -1,177 +0,0 @@
-;;! target = "x86_64"
-;;! compile = true
-;;! settings = ["has_bmi2", "opt_level=speed", "has_avx"]
-
-(module
-  (func (export "bzhi32") (param i32 i32) (result i32)
-    (i32.and
-      (local.get 0)
-      (i32.sub
-        (i32.shl
-          (i32.const 1)
-          (local.get 1))
-        (i32.const 1))))
-
-  (func (export "bzhi64") (param i64 i64) (result i64)
-    (i64.and
-      (local.get 0)
-      (i64.add
-        (i64.shl
-          (i64.const 1)
-          (local.get 1))
-        (i64.const -1))))
-
-  (func (export "rorx32") (param i32) (result i32)
-    (i32.rotr (local.get 0) (i32.const 8)))
-
-  (func (export "rorx64") (param i64) (result i64)
-    (i64.rotl (local.get 0) (i64.const 9)))
-
-  (func (export "shlx32") (param i32 i32) (result i32)
-    (i32.shl (local.get 0) (local.get 1)))
-  (func (export "shlx64") (param i64 i64) (result i64)
-    (i64.shl (local.get 0) (local.get 1)))
-
-  (func (export "shrx32") (param i32 i32) (result i32)
-    (i32.shr_u (local.get 0) (local.get 1)))
-  (func (export "shrx64") (param i64 i64) (result i64)
-    (i64.shr_u (local.get 0) (local.get 1)))
-
-  (func (export "sarx32") (param i32 i32) (result i32)
-    (i32.shr_s (local.get 0) (local.get 1)))
-  (func (export "sarx64") (param i64 i64) (result i64)
-    (i64.shr_s (local.get 0) (local.get 1)))
-)
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   movq    %rsi, %r8
-;;   andl    %r8d, $31, %r8d
-;;   bzhi    %edi, %r8d, %eax
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   movq    %rsi, %r8
-;;   andq    %r8, $63, %r8
-;;   bzhi    %rdi, %r8, %rax
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:2:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   rorxl   $8, %edi, %eax
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:3:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   rorxq   $55, %rdi, %rax
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:4:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   shlx    %edi, %esi, %eax
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:5:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   shlx    %rdi, %rsi, %rax
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:6:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   shrx    %edi, %esi, %eax
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:7:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   shrx    %rdi, %rsi, %rax
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:8:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   sarx    %edi, %esi, %eax
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:9:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   sarx    %rdi, %rsi, %rax
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/wasm/x64-pmin.wat b/cranelift/filetests/filetests/wasm/x64-pmin.wat
deleted file mode 100644
index 474009b70a26..000000000000
--- a/cranelift/filetests/filetests/wasm/x64-pmin.wat
+++ /dev/null
@@ -1,136 +0,0 @@
-;;! target = "x86_64"
-;;! compile = true
-;;! settings = ["sse42", "opt_level=speed", "has_avx"]
-
-(module
-  (func (export "f32.pmin") (param f32 f32) (result f32)
-    (select
-      (local.get 1) (local.get 0)
-      (f32.lt (local.get 1) (local.get 0))))
-  (func (export "f32.pmax") (param f32 f32) (result f32)
-    (select
-      (local.get 1) (local.get 0)
-      (f32.lt (local.get 0) (local.get 1))))
-
-  (func (export "f64.pmin") (param f64 f64) (result f64)
-    (select
-      (local.get 1) (local.get 0)
-      (f64.lt (local.get 1) (local.get 0))))
-  (func (export "f64.pmax") (param f64 f64) (result f64)
-    (select
-      (local.get 1) (local.get 0)
-      (f64.lt (local.get 0) (local.get 1))))
-
-  (func (export "f32x4.pmin") (param v128 v128) (result v128)
-    (f32x4.pmin (local.get 0) (local.get 1)))
-  (func (export "f32x4.pmax") (param v128 v128) (result v128)
-    (f32x4.pmax (local.get 0) (local.get 1)))
-
-  (func (export "f64x2.pmin") (param v128 v128) (result v128)
-    (f64x2.pmin (local.get 0) (local.get 1)))
-  (func (export "f64x2.pmax") (param v128 v128) (result v128)
-    (f64x2.pmax (local.get 0) (local.get 1)))
-)
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   vminss  %xmm1, %xmm0, %xmm0
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   vmaxss  %xmm1, %xmm0, %xmm0
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:2:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   vminsd  %xmm1, %xmm0, %xmm0
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:3:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   vmaxsd  %xmm1, %xmm0, %xmm0
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:4:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   vminps  %xmm1, %xmm0, %xmm0
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:5:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   vmaxps  %xmm1, %xmm0, %xmm0
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:6:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   vminpd  %xmm1, %xmm0, %xmm0
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:7:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   jmp     label1
-;; block1:
-;;   vmaxpd  %xmm1, %xmm0, %xmm0
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/wasm/x64-relaxed-simd-deterministic.wat b/cranelift/filetests/filetests/wasm/x64-relaxed-simd-deterministic.wat
deleted file mode 100644
index 381a74fe34c8..000000000000
--- a/cranelift/filetests/filetests/wasm/x64-relaxed-simd-deterministic.wat
+++ /dev/null
@@ -1,164 +0,0 @@
-;;! target = "x86_64"
-;;! compile = true
-;;! relaxed_simd_deterministic = true
-;;! settings = ["sse42", "has_avx"]
-
-(module
-  (func (param v128) (result v128)
-    local.get 0
-    i32x4.relaxed_trunc_f32x4_s
-  )
-
-  (func (param v128) (result v128)
-    local.get 0
-    i32x4.relaxed_trunc_f32x4_u
-  )
-
-  (func (param v128) (result v128)
-    local.get 0
-    i32x4.relaxed_trunc_f64x2_s_zero
-  )
-
-  (func (param v128) (result v128)
-    local.get 0
-    i32x4.relaxed_trunc_f64x2_u_zero
-  )
-
-  (func (param v128 v128) (result v128)
-    local.get 0
-    local.get 1
-    i16x8.relaxed_dot_i8x16_i7x16_s
-  )
-
-  (func (param v128 v128 v128) (result v128)
-    local.get 0
-    local.get 1
-    local.get 2
-    i32x4.relaxed_dot_i8x16_i7x16_add_s
-  )
-)
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   vcmpps  $0, %xmm0, %xmm0, %xmm3
-;;   vandps  %xmm0, %xmm3, %xmm5
-;;   vpxor   %xmm3, %xmm5, %xmm7
-;;   vcvttps2dq %xmm5, %xmm1
-;;   vpand   %xmm1, %xmm7, %xmm3
-;;   vpsrad  %xmm3, $31, %xmm5
-;;   vpxor   %xmm5, %xmm1, %xmm0
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   uninit  %xmm3
-;;   vxorps  %xmm3, %xmm3, %xmm5
-;;   vmaxps  %xmm0, %xmm5, %xmm0
-;;   vpcmpeqd %xmm5, %xmm5, %xmm1
-;;   vpsrld  %xmm1, $1, %xmm3
-;;   vcvtdq2ps %xmm3, %xmm5
-;;   vcvttps2dq %xmm0, %xmm7
-;;   vsubps  %xmm0, %xmm5, %xmm1
-;;   vcmpps  $2, %xmm5, %xmm1, %xmm3
-;;   vcvttps2dq %xmm1, %xmm5
-;;   vpxor   %xmm5, %xmm3, %xmm0
-;;   uninit  %xmm1
-;;   vpxor   %xmm1, %xmm1, %xmm3
-;;   vpmaxsd %xmm0, %xmm3, %xmm5
-;;   vpaddd  %xmm5, %xmm7, %xmm0
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:2:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   vcmppd  $0, %xmm0, %xmm0, %xmm3
-;;   vandps  %xmm3, const(0), %xmm5
-;;   vminpd  %xmm0, %xmm5, %xmm7
-;;   vcvttpd2dq %xmm7, %xmm0
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:3:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   uninit  %xmm3
-;;   vxorpd  %xmm3, %xmm3, %xmm5
-;;   vmaxpd  %xmm0, %xmm5, %xmm7
-;;   vminpd  %xmm7, const(0), %xmm1
-;;   vroundpd $3, %xmm1, %xmm3
-;;   vaddpd  %xmm3, const(1), %xmm6
-;;   vshufps $136, %xmm6, %xmm5, %xmm0
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:4:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   vpmovsxbw %xmm0, %xmm4
-;;   vpmovsxbw %xmm1, %xmm5
-;;   vpmullw %xmm4, %xmm5, %xmm4
-;;   vpalignr $8, %xmm0, %xmm0, %xmm3
-;;   vpmovsxbw %xmm3, %xmm5
-;;   vpalignr $8, %xmm1, %xmm1, %xmm3
-;;   vpmovsxbw %xmm3, %xmm6
-;;   vpmullw %xmm5, %xmm6, %xmm5
-;;   vphaddw %xmm4, %xmm5, %xmm0
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:5:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   vpmovsxbw %xmm0, %xmm7
-;;   vpmovsxbw %xmm1, %xmm3
-;;   vpmullw %xmm7, %xmm3, %xmm7
-;;   vpalignr $8, %xmm0, %xmm0, %xmm6
-;;   vpmovsxbw %xmm6, %xmm0
-;;   vpalignr $8, %xmm1, %xmm1, %xmm6
-;;   vpmovsxbw %xmm6, %xmm1
-;;   vpmullw %xmm0, %xmm1, %xmm0
-;;   vphaddw %xmm7, %xmm0, %xmm7
-;;   vpmaddwd %xmm7, const(0), %xmm7
-;;   vpaddd  %xmm7, %xmm2, %xmm0
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/filetests/wasm/x64-relaxed-simd.wat b/cranelift/filetests/filetests/wasm/x64-relaxed-simd.wat
deleted file mode 100644
index d3bbfd4441e2..000000000000
--- a/cranelift/filetests/filetests/wasm/x64-relaxed-simd.wat
+++ /dev/null
@@ -1,144 +0,0 @@
-;;! target = "x86_64"
-;;! compile = true
-;;! settings = ["sse41"]
-
-(module
-  (func (param v128) (result v128)
-    local.get 0
-    i32x4.relaxed_trunc_f32x4_s
-  )
-
-  (func (param v128) (result v128)
-    local.get 0
-    i32x4.relaxed_trunc_f32x4_u
-  )
-
-  (func (param v128) (result v128)
-    local.get 0
-    i32x4.relaxed_trunc_f64x2_s_zero
-  )
-
-  (func (param v128) (result v128)
-    local.get 0
-    i32x4.relaxed_trunc_f64x2_u_zero
-  )
-
-  (func (param v128 v128) (result v128)
-    local.get 0
-    local.get 1
-    i16x8.relaxed_dot_i8x16_i7x16_s
-  )
-
-  (func (param v128 v128 v128) (result v128)
-    local.get 0
-    local.get 1
-    local.get 2
-    i32x4.relaxed_dot_i8x16_i7x16_add_s
-  )
-)
-
-;; function u0:0:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   cvttps2dq %xmm0, %xmm0
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:1:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   uninit  %xmm7
-;;   xorps   %xmm7, %xmm7, %xmm7
-;;   movdqa  %xmm0, %xmm4
-;;   maxps   %xmm4, %xmm7, %xmm4
-;;   pcmpeqd %xmm7, %xmm7, %xmm7
-;;   psrld   %xmm7, $1, %xmm7
-;;   cvtdq2ps %xmm7, %xmm1
-;;   cvttps2dq %xmm4, %xmm7
-;;   subps   %xmm4, %xmm1, %xmm4
-;;   cmpps   $2, %xmm1, %xmm4, %xmm1
-;;   cvttps2dq %xmm4, %xmm0
-;;   pxor    %xmm0, %xmm1, %xmm0
-;;   uninit  %xmm2
-;;   pxor    %xmm2, %xmm2, %xmm2
-;;   pmaxsd  %xmm0, %xmm2, %xmm0
-;;   paddd   %xmm0, %xmm7, %xmm0
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:2:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   cvttpd2dq %xmm0, %xmm0
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:3:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   uninit  %xmm4
-;;   xorpd   %xmm4, %xmm4, %xmm4
-;;   maxpd   %xmm0, %xmm4, %xmm0
-;;   minpd   %xmm0, const(0), %xmm0
-;;   roundpd $3, %xmm0, %xmm0
-;;   addpd   %xmm0, const(1), %xmm0
-;;   shufps  $136, %xmm0, %xmm4, %xmm0
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:4:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movdqa  %xmm1, %xmm4
-;;   pmaddubsw %xmm4, %xmm0, %xmm4
-;;   movdqa  %xmm4, %xmm0
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
-;;
-;; function u0:5:
-;;   pushq   %rbp
-;;   unwind PushFrameRegs { offset_upward_to_caller_sp: 16 }
-;;   movq    %rsp, %rbp
-;;   unwind DefineNewFrame { offset_upward_to_caller_sp: 16, offset_downward_to_clobbers: 0 }
-;; block0:
-;;   movdqa  %xmm1, %xmm3
-;;   movdqa  %xmm0, %xmm1
-;;   movdqa  %xmm3, %xmm0
-;;   pmaddubsw %xmm0, %xmm1, %xmm0
-;;   pmaddwd %xmm0, const(0), %xmm0
-;;   paddd   %xmm0, %xmm2, %xmm0
-;;   jmp     label1
-;; block1:
-;;   movq    %rbp, %rsp
-;;   popq    %rbp
-;;   ret
diff --git a/cranelift/filetests/src/concurrent.rs b/cranelift/filetests/src/concurrent.rs
index c85f50fa53e5..fec83b3b957b 100644
--- a/cranelift/filetests/src/concurrent.rs
+++ b/cranelift/filetests/src/concurrent.rs
@@ -6,9 +6,7 @@
 use crate::runone;
 use cranelift_codegen::dbg::LOG_FILENAME_PREFIX;
 use cranelift_codegen::timing;
-use file_per_thread_logger;
 use log::error;
-use num_cpus;
 use std::panic::catch_unwind;
 use std::path::{Path, PathBuf};
 use std::sync::mpsc::{channel, Receiver, Sender};
@@ -23,7 +21,6 @@ struct Request(usize, PathBuf);
 pub enum Reply {
     Starting {
         jobid: usize,
-        thread_num: usize,
     },
     Done {
         jobid: usize,
@@ -88,7 +85,7 @@ impl ConcurrentRunner {
         for h in self.handles.drain(..) {
             match h.join() {
                 Ok(t) => pass_times.add(&t),
-                Err(e) => println!("worker panicked: {:?}", e),
+                Err(e) => println!("worker panicked: {e:?}"),
             }
         }
         pass_times
@@ -135,7 +132,7 @@ fn worker_thread(
     replies: Sender<Reply>,
 ) -> thread::JoinHandle<timing::PassTimes> {
     thread::Builder::new()
-        .name(format!("worker #{}", thread_num))
+        .name(format!("worker #{thread_num}"))
         .spawn(move || {
             file_per_thread_logger::initialize(LOG_FILENAME_PREFIX);
             loop {
@@ -147,7 +144,7 @@ fn worker_thread(
 
                 // Tell them we're starting this job.
                 // The receiver should always be present for this as long as we have jobs.
-                replies.send(Reply::Starting { jobid, thread_num }).unwrap();
+                replies.send(Reply::Starting { jobid }).unwrap();
 
                 let result = catch_unwind(|| runone::run(path.as_path(), None, None))
                     .unwrap_or_else(|e| {
diff --git a/cranelift/filetests/src/function_runner.rs b/cranelift/filetests/src/function_runner.rs
index 5f034fc51a21..2feae28e0183 100644
--- a/cranelift/filetests/src/function_runner.rs
+++ b/cranelift/filetests/src/function_runner.rs
@@ -101,6 +101,20 @@ impl TestFileCompiler {
                 }
             }));
         }
+
+        // On Unix platforms force `libm` to get linked into this executable
+        // because tests that use libcalls rely on this library being present.
+        // Without this it's been seen that when cross-compiled to riscv64 the
+        // final binary doesn't link in `libm`.
+        #[cfg(unix)]
+        {
+            extern "C" {
+                fn ceilf(f: f32) -> f32;
+            }
+            let f = 1.2_f32;
+            assert_eq!(f.ceil(), unsafe { ceilf(f) });
+        }
+
         let module = JITModule::new(builder);
         let ctx = module.make_context();
 
@@ -618,8 +632,8 @@ mod test {
             &function.signature,
             compiler.module.isa(),
         );
-        println!("{}", trampoline);
-        assert!(format!("{}", trampoline).ends_with(
+        println!("{trampoline}");
+        assert!(format!("{trampoline}").ends_with(
             "sig0 = (f32, i8, i64x2, i8) -> f32x4, i64 fast
 
 block0(v0: i64, v1: i64):
diff --git a/cranelift/filetests/src/lib.rs b/cranelift/filetests/src/lib.rs
index 64fa3f50c337..b09ba6560737 100644
--- a/cranelift/filetests/src/lib.rs
+++ b/cranelift/filetests/src/lib.rs
@@ -3,13 +3,7 @@
 //! This crate contains the main test driver as well as implementations of the
 //! available filetest commands.
 
-#![deny(
-    missing_docs,
-    trivial_numeric_casts,
-    unused_extern_crates,
-    unstable_features
-)]
-#![warn(unused_import_braces)]
+#![deny(missing_docs)]
 
 pub use crate::function_runner::TestFileCompiler;
 use crate::runner::TestRunner;
@@ -26,7 +20,6 @@ mod subtest;
 mod test_alias_analysis;
 mod test_cat;
 mod test_compile;
-mod test_dce;
 mod test_domtree;
 mod test_interpret;
 mod test_legalizer;
@@ -36,7 +29,6 @@ mod test_run;
 mod test_safepoint;
 mod test_unwind;
 mod test_verifier;
-mod test_wasm;
 
 /// Main entry point for `clif-util test`.
 ///
@@ -96,7 +88,6 @@ fn new_subtest(parsed: &TestCommand) -> anyhow::Result<Box<dyn subtest::SubTest>
         "alias-analysis" => test_alias_analysis::subtest(parsed),
         "cat" => test_cat::subtest(parsed),
         "compile" => test_compile::subtest(parsed),
-        "dce" => test_dce::subtest(parsed),
         "domtree" => test_domtree::subtest(parsed),
         "interpret" => test_interpret::subtest(parsed),
         "legalizer" => test_legalizer::subtest(parsed),
diff --git a/cranelift/filetests/src/match_directive.rs b/cranelift/filetests/src/match_directive.rs
index bb379f25c95d..54944194e8d1 100644
--- a/cranelift/filetests/src/match_directive.rs
+++ b/cranelift/filetests/src/match_directive.rs
@@ -10,11 +10,7 @@ pub fn match_directive<'a>(comment: &'a str, directive: &str) -> Option<&'a str>
         "Directive must include trailing colon"
     );
     let text = comment.trim_start_matches(';').trim_start();
-    if text.starts_with(directive) {
-        Some(text[directive.len()..].trim())
-    } else {
-        None
-    }
+    text.strip_prefix(directive).map(|s| s.trim())
 }
 
 #[test]
diff --git a/cranelift/filetests/src/runner.rs b/cranelift/filetests/src/runner.rs
index a1517b4dccd7..af80aaff885a 100644
--- a/cranelift/filetests/src/runner.rs
+++ b/cranelift/filetests/src/runner.rs
@@ -47,8 +47,8 @@ impl Display for QueueEntry {
         let p = self.path.to_string_lossy();
         match self.state {
             State::Done(Ok(dur)) => write!(f, "{}.{:03} {}", dur.as_secs(), dur.subsec_millis(), p),
-            State::Done(Err(ref e)) => write!(f, "FAIL {}: {:?}", p, e),
-            _ => write!(f, "{}", p),
+            State::Done(Err(ref e)) => write!(f, "FAIL {p}: {e:?}"),
+            _ => write!(f, "{p}"),
         }
     }
 }
@@ -299,7 +299,7 @@ impl TestRunner {
             }
             let pass_times = conc.join();
             if self.report_times {
-                println!("{}", pass_times);
+                println!("{pass_times}");
             }
         }
     }
@@ -349,7 +349,7 @@ impl TestRunner {
             } => dur > cut,
             _ => false,
         }) {
-            println!("slow: {}", t)
+            println!("slow: {t}")
         }
     }
 
diff --git a/cranelift/filetests/src/runone.rs b/cranelift/filetests/src/runone.rs
index c616f4538471..0ac1c55e75b7 100644
--- a/cranelift/filetests/src/runone.rs
+++ b/cranelift/filetests/src/runone.rs
@@ -30,11 +30,6 @@ pub fn run(
     let buffer =
         fs::read_to_string(path).with_context(|| format!("failed to read {}", path.display()))?;
 
-    if path.extension().map_or(false, |ext| ext == "wat") {
-        crate::test_wasm::run(path, &buffer)?;
-        return Ok(started.elapsed());
-    }
-
     let options = ParseOptions {
         target,
         passes,
@@ -181,7 +176,7 @@ impl FileUpdate {
         assert!(location.line_number > self.last_update.get());
         self.last_update.set(location.line_number);
 
-        // Read the old test file and calculate thte new line number we're
+        // Read the old test file and calculate the new line number we're
         // preserving up to based on how many lines prior to this have been
         // removed or added.
         let old_test = std::fs::read_to_string(&self.path)?;
diff --git a/cranelift/filetests/src/subtest.rs b/cranelift/filetests/src/subtest.rs
index 24c0d8a6b77c..a0761ad9ba21 100644
--- a/cranelift/filetests/src/subtest.rs
+++ b/cranelift/filetests/src/subtest.rs
@@ -29,6 +29,7 @@ pub struct Context<'a> {
     pub isa: Option<&'a dyn TargetIsa>,
 
     /// Full path to the file containing the test.
+    #[allow(dead_code)]
     pub file_path: &'a str,
 
     /// Context used to update the original `file_path` in-place with its test
diff --git a/cranelift/filetests/src/test_alias_analysis.rs b/cranelift/filetests/src/test_alias_analysis.rs
index 5fbf86dfefcf..029392d40d98 100644
--- a/cranelift/filetests/src/test_alias_analysis.rs
+++ b/cranelift/filetests/src/test_alias_analysis.rs
@@ -7,7 +7,6 @@
 //! The resulting function is sent to `filecheck`.
 
 use crate::subtest::{run_filecheck, Context, SubTest};
-use cranelift_codegen;
 use cranelift_codegen::ir::Function;
 use cranelift_reader::TestCommand;
 use std::borrow::Cow;
diff --git a/cranelift/filetests/src/test_compile.rs b/cranelift/filetests/src/test_compile.rs
index 8b6b2eb5bdca..a99343b80072 100644
--- a/cranelift/filetests/src/test_compile.rs
+++ b/cranelift/filetests/src/test_compile.rs
@@ -53,7 +53,7 @@ impl SubTest for TestCompile {
         let params = func.params.clone();
         let mut comp_ctx = cranelift_codegen::Context::for_function(func.into_owned());
 
-        // With `MachBackend`s, we need to explicitly request dissassembly results.
+        // With `MachBackend`s, we need to explicitly request disassembly results.
         comp_ctx.set_disasm(true);
 
         let compiled_code = comp_ctx.compile(isa, &mut Default::default());
@@ -73,10 +73,19 @@ impl SubTest for TestCompile {
         info!("Generated {} bytes of code:\n{}", total_size, vcode);
 
         if self.precise_output {
-            let cs = isa
-                .to_capstone()
-                .map_err(|e| anyhow::format_err!("{}", e))?;
-            let dis = compiled_code.disassemble(Some(&params), &cs)?;
+            let dis = match isa.triple().architecture {
+                target_lexicon::Architecture::Pulley32 | target_lexicon::Architecture::Pulley64 => {
+                    pulley_interpreter::disas::Disassembler::disassemble_all(
+                        compiled_code.buffer.data(),
+                    )?
+                }
+                _ => {
+                    let cs = isa
+                        .to_capstone()
+                        .map_err(|e| anyhow::format_err!("{}", e))?;
+                    compiled_code.disassemble(Some(&params), &cs)?
+                }
+            };
 
             let actual = Vec::from_iter(
                 std::iter::once("VCode:")
@@ -84,6 +93,7 @@ impl SubTest for TestCompile {
                     .chain(["", "Disassembled:"])
                     .chain(dis.lines()),
             );
+
             check_precise_output(&actual, context)
         } else {
             run_filecheck(&vcode, context)
diff --git a/cranelift/filetests/src/test_dce.rs b/cranelift/filetests/src/test_dce.rs
deleted file mode 100644
index 48d28c7e72bb..000000000000
--- a/cranelift/filetests/src/test_dce.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-//! Test command for testing the DCE pass.
-//!
-//! The `dce` test command runs each function through the DCE pass after ensuring
-//! that all instructions are legal for the target.
-//!
-//! The resulting function is sent to `filecheck`.
-
-use crate::subtest::{run_filecheck, Context, SubTest};
-use cranelift_codegen;
-use cranelift_codegen::ir::Function;
-use cranelift_reader::TestCommand;
-use std::borrow::Cow;
-
-struct TestDCE;
-
-pub fn subtest(parsed: &TestCommand) -> anyhow::Result<Box<dyn SubTest>> {
-    assert_eq!(parsed.command, "dce");
-    if !parsed.options.is_empty() {
-        anyhow::bail!("No options allowed on {}", parsed);
-    }
-    Ok(Box::new(TestDCE))
-}
-
-impl SubTest for TestDCE {
-    fn name(&self) -> &'static str {
-        "dce"
-    }
-
-    fn is_mutating(&self) -> bool {
-        true
-    }
-
-    fn run(&self, func: Cow<Function>, context: &Context) -> anyhow::Result<()> {
-        let mut comp_ctx = cranelift_codegen::Context::for_function(func.into_owned());
-
-        comp_ctx.flowgraph();
-        comp_ctx.compute_loop_analysis();
-        comp_ctx
-            .dce(context.flags_or_isa())
-            .map_err(|e| crate::pretty_anyhow_error(&comp_ctx.func, Into::into(e)))?;
-
-        let text = comp_ctx.func.display().to_string();
-        run_filecheck(&text, context)
-    }
-}
diff --git a/cranelift/filetests/src/test_domtree.rs b/cranelift/filetests/src/test_domtree.rs
index ba9d51301d00..89374dd1c2a2 100644
--- a/cranelift/filetests/src/test_domtree.rs
+++ b/cranelift/filetests/src/test_domtree.rs
@@ -105,7 +105,7 @@ impl SubTest for TestDomtree {
             if let Some(got_inst) = domtree.idom(block) {
                 anyhow::bail!(
                     "mismatching idoms for renumbered {}:\n\
-                     want: unrechable, got: {}",
+                     want: unreachable, got: {}",
                     block,
                     got_inst
                 );
@@ -123,7 +123,7 @@ fn filecheck_text(func: &Function, domtree: &DominatorTree) -> Result<String, fm
 
     write!(s, "cfg_postorder:")?;
     for &block in domtree.cfg_postorder() {
-        write!(s, " {}", block)?;
+        write!(s, " {block}")?;
     }
     writeln!(s)?;
 
@@ -134,10 +134,10 @@ fn filecheck_text(func: &Function, domtree: &DominatorTree) -> Result<String, fm
     let mut stack = Vec::new();
     stack.extend(func.layout.entry_block());
     while let Some(block) = stack.pop() {
-        write!(s, "    {}:", block)?;
+        write!(s, "    {block}:")?;
         let i = stack.len();
         for ch in dtpo.children(block) {
-            write!(s, " {}", ch)?;
+            write!(s, " {ch}")?;
             stack.push(ch);
         }
         writeln!(s)?;
diff --git a/cranelift/filetests/src/test_interpret.rs b/cranelift/filetests/src/test_interpret.rs
index f8d2f1b57b48..8f653349a0f7 100644
--- a/cranelift/filetests/src/test_interpret.rs
+++ b/cranelift/filetests/src/test_interpret.rs
@@ -6,15 +6,17 @@
 use crate::runone::FileUpdate;
 use crate::subtest::SubTest;
 use anyhow::Context;
-use cranelift_codegen::ir::Function;
+use cranelift_codegen::data_value::DataValue;
+use cranelift_codegen::ir;
+use cranelift_codegen::ir::{Function, LibCall};
 use cranelift_codegen::isa::TargetIsa;
 use cranelift_codegen::settings::Flags;
-use cranelift_codegen::{self, ir};
 use cranelift_interpreter::environment::FunctionStore;
-use cranelift_interpreter::interpreter::{Interpreter, InterpreterState};
+use cranelift_interpreter::interpreter::{Interpreter, InterpreterState, LibCallValues};
 use cranelift_interpreter::step::ControlFlow;
 use cranelift_reader::{parse_run_command, Details, TestCommand, TestFile};
 use log::{info, trace};
+use smallvec::smallvec;
 use std::borrow::Cow;
 
 struct TestInterpret;
@@ -83,19 +85,32 @@ fn run_test(func_store: &FunctionStore, func: &Function, details: &Details) -> a
                 .run(|func_name, run_args| {
                     // Rebuild the interpreter state on every run to ensure that we don't accidentally depend on
                     // some leftover state
-                    let state = InterpreterState::default().with_function_store(func_store.clone());
+                    let state = InterpreterState::default()
+                        .with_function_store(func_store.clone())
+                        .with_libcall_handler(|libcall: LibCall, args: LibCallValues| {
+                            use LibCall::*;
+                            Ok(smallvec![match (libcall, &args[..]) {
+                                (CeilF32, [DataValue::F32(a)]) => DataValue::F32(a.ceil()),
+                                (CeilF64, [DataValue::F64(a)]) => DataValue::F64(a.ceil()),
+                                (FloorF32, [DataValue::F32(a)]) => DataValue::F32(a.floor()),
+                                (FloorF64, [DataValue::F64(a)]) => DataValue::F64(a.floor()),
+                                (TruncF32, [DataValue::F32(a)]) => DataValue::F32(a.trunc()),
+                                (TruncF64, [DataValue::F64(a)]) => DataValue::F64(a.trunc()),
+                                _ => unreachable!(),
+                            }])
+                        });
 
                     let mut args = Vec::with_capacity(run_args.len());
                     args.extend_from_slice(run_args);
 
                     // Because we have stored function names with a leading %, we need to re-add it.
-                    let func_name = &format!("%{}", func_name);
+                    let func_name = &format!("%{func_name}");
                     match Interpreter::new(state).call_by_name(func_name, &args) {
                         Ok(ControlFlow::Return(results)) => Ok(results.to_vec()),
                         Ok(e) => {
-                            panic!("Unexpected returned control flow: {:?}", e)
+                            panic!("Unexpected returned control flow: {e:?}")
                         }
-                        Err(t) => Err(format!("unexpected trap: {:?}", t)),
+                        Err(t) => Err(format!("unexpected trap: {t:?}")),
                     }
                 })
                 .map_err(|e| anyhow::anyhow!("{}", e))?;
diff --git a/cranelift/filetests/src/test_legalizer.rs b/cranelift/filetests/src/test_legalizer.rs
index 8af819bed234..c0c12e220f46 100644
--- a/cranelift/filetests/src/test_legalizer.rs
+++ b/cranelift/filetests/src/test_legalizer.rs
@@ -4,7 +4,6 @@
 //! the result to filecheck.
 
 use crate::subtest::{run_filecheck, Context, SubTest};
-use cranelift_codegen;
 use cranelift_codegen::ir::Function;
 use cranelift_reader::TestCommand;
 use std::borrow::Cow;
diff --git a/cranelift/filetests/src/test_optimize.rs b/cranelift/filetests/src/test_optimize.rs
index fd76a8fe041f..4550d5ab037d 100644
--- a/cranelift/filetests/src/test_optimize.rs
+++ b/cranelift/filetests/src/test_optimize.rs
@@ -10,6 +10,7 @@
 use crate::subtest::{check_precise_output, run_filecheck, Context, SubTest};
 use anyhow::Result;
 use cranelift_codegen::ir;
+use cranelift_control::ControlPlane;
 use cranelift_reader::{TestCommand, TestOption};
 use std::borrow::Cow;
 
@@ -53,7 +54,7 @@ impl SubTest for TestOptimize {
         let mut comp_ctx = cranelift_codegen::Context::for_function(func.into_owned());
 
         comp_ctx
-            .optimize(isa)
+            .optimize(isa, &mut ControlPlane::default())
             .map_err(|e| crate::pretty_anyhow_error(&comp_ctx.func, e))?;
 
         let clif = format!("{:?}", comp_ctx.func);
diff --git a/cranelift/filetests/src/test_run.rs b/cranelift/filetests/src/test_run.rs
index bf0fafe97929..1e7e977c2b24 100644
--- a/cranelift/filetests/src/test_run.rs
+++ b/cranelift/filetests/src/test_run.rs
@@ -63,8 +63,7 @@ fn is_isa_compatible(
         (Architecture::Riscv64(_), Architecture::Riscv64(_)) => {}
         _ => {
             return Err(format!(
-                "skipped {}: host can't run {:?} programs",
-                file_path, requested_arch
+                "skipped {file_path}: host can't run {requested_arch:?} programs"
             ))
         }
     }
diff --git a/cranelift/filetests/src/test_unwind.rs b/cranelift/filetests/src/test_unwind.rs
index 90bb4393b823..f9fe196dff02 100644
--- a/cranelift/filetests/src/test_unwind.rs
+++ b/cranelift/filetests/src/test_unwind.rs
@@ -3,7 +3,7 @@
 //! The `unwind` test command runs each function through the full code generator pipeline.
 
 use crate::subtest::{run_filecheck, Context, SubTest};
-use cranelift_codegen::{self, ir, isa::unwind::UnwindInfo};
+use cranelift_codegen::{ir, isa::unwind::UnwindInfo};
 use cranelift_reader::TestCommand;
 use gimli::{
     write::{Address, EhFrame, EndianVec, FrameTable},
@@ -97,12 +97,8 @@ mod windowsx64 {
             writeln!(text, "                 info: {}", code.info).unwrap();
             match code.value {
                 UnwindValue::None => {}
-                UnwindValue::U16(v) => {
-                    writeln!(text, "                value: {} (u16)", v).unwrap()
-                }
-                UnwindValue::U32(v) => {
-                    writeln!(text, "                value: {} (u32)", v).unwrap()
-                }
+                UnwindValue::U16(v) => writeln!(text, "                value: {v} (u16)").unwrap(),
+                UnwindValue::U32(v) => writeln!(text, "                value: {v} (u32)").unwrap(),
             };
         }
     }
@@ -369,10 +365,10 @@ mod systemv {
     fn dump_pointer<W: Write>(w: &mut W, p: gimli::Pointer) -> Result<()> {
         match p {
             gimli::Pointer::Direct(p) => {
-                write!(w, "{:#018x}", p)?;
+                write!(w, "{p:#018x}")?;
             }
             gimli::Pointer::Indirect(p) => {
-                write!(w, "({:#018x})", p)?;
+                write!(w, "({p:#018x})")?;
             }
         }
         Ok(())
@@ -400,7 +396,7 @@ mod systemv {
         loop {
             match insns.next() {
                 Err(e) => {
-                    writeln!(w, "Failed to decode CFI instruction: {}", e)?;
+                    writeln!(w, "Failed to decode CFI instruction: {e}")?;
                     return Ok(());
                 }
                 Ok(None) => {
@@ -411,10 +407,10 @@ mod systemv {
                 }
                 Ok(Some(op)) => match op {
                     SetLoc { address } => {
-                        writeln!(w, "                DW_CFA_set_loc ({:#x})", address)?;
+                        writeln!(w, "                DW_CFA_set_loc ({address:#x})")?;
                     }
                     AdvanceLoc { delta } => {
-                        writeln!(w, "                DW_CFA_advance_loc ({})", delta)?;
+                        writeln!(w, "                DW_CFA_advance_loc ({delta})")?;
                     }
                     DefCfa { register, offset } => {
                         writeln!(
@@ -443,13 +439,12 @@ mod systemv {
                         )?;
                     }
                     DefCfaOffset { offset } => {
-                        writeln!(w, "                DW_CFA_def_cfa_offset ({})", offset)?;
+                        writeln!(w, "                DW_CFA_def_cfa_offset ({offset})")?;
                     }
                     DefCfaOffsetSf { factored_offset } => {
                         writeln!(
                             w,
-                            "                DW_CFA_def_cfa_offset_sf ({})",
-                            factored_offset
+                            "                DW_CFA_def_cfa_offset_sf ({factored_offset})"
                         )?;
                     }
                     DefCfaExpression { expression: _ } => {
@@ -558,7 +553,7 @@ mod systemv {
                         writeln!(w, "                DW_CFA_restore_state")?;
                     }
                     ArgsSize { size } => {
-                        writeln!(w, "                DW_CFA_GNU_args_size ({})", size)?;
+                        writeln!(w, "                DW_CFA_GNU_args_size ({size})")?;
                     }
                     NegateRaState => {
                         writeln!(w, "                DW_CFA_AARCH64_negate_ra_state")?;
diff --git a/cranelift/filetests/src/test_verifier.rs b/cranelift/filetests/src/test_verifier.rs
index e1d74853656a..2835d7acb4eb 100644
--- a/cranelift/filetests/src/test_verifier.rs
+++ b/cranelift/filetests/src/test_verifier.rs
@@ -79,7 +79,7 @@ impl SubTest for TestVerifier {
 
                 // Report remaining errors.
                 for err in errors {
-                    writeln!(msg, "unexpected error {}", err).unwrap();
+                    writeln!(msg, "unexpected error {err}").unwrap();
                 }
 
                 if msg.is_empty() {
diff --git a/cranelift/filetests/src/test_wasm.rs b/cranelift/filetests/src/test_wasm.rs
deleted file mode 100644
index c3bcc25ca3f0..000000000000
--- a/cranelift/filetests/src/test_wasm.rs
+++ /dev/null
@@ -1,134 +0,0 @@
-//! Test runner for `.wat` files to exercise CLIF-to-Wasm translations.
-
-mod config;
-mod env;
-
-use anyhow::{bail, ensure, Context, Result};
-use config::TestConfig;
-use env::ModuleEnv;
-use similar::TextDiff;
-use std::{fmt::Write, path::Path};
-
-/// Run one `.wat` test.
-pub fn run(path: &Path, wat: &str) -> Result<()> {
-    debug_assert_eq!(path.extension().unwrap_or_default(), "wat");
-
-    // The test config source is the leading lines of the WAT file that are
-    // prefixed with `;;!`.
-    let config_lines: Vec<_> = wat
-        .lines()
-        .take_while(|l| l.starts_with(";;!"))
-        .map(|l| &l[3..])
-        .collect();
-    let config_text = config_lines.join("\n");
-
-    let config: TestConfig =
-        toml::from_str(&config_text).context("failed to parse the test configuration")?;
-    log::debug!("Wasm test config = {config:#?}");
-
-    config
-        .validate()
-        .context("test configuration is malformed")?;
-
-    let parsed = cranelift_reader::parse_sets_and_triple(&config.settings, &config.target)
-        .context("invalid ISA target or Cranelift settings")?;
-    let flags_or_isa = parsed.as_fisa();
-    ensure!(
-        flags_or_isa.isa.is_some(),
-        "Running `.wat` tests requires specifying an ISA"
-    );
-    let isa = flags_or_isa.isa.unwrap();
-
-    let mut env = ModuleEnv::new(isa, config.clone());
-
-    let wasm = wat::parse_str(wat).context("failed to parse the test WAT")?;
-    let mut validator = wasmparser::Validator::new_with_features(
-        cranelift_wasm::ModuleEnvironment::wasm_features(&env),
-    );
-    validator
-        .validate_all(&wasm)
-        .context("test WAT failed to validate")?;
-
-    cranelift_wasm::translate_module(&wasm, &mut env)
-        .context("failed to translate the test case into CLIF")?;
-
-    let mut actual = String::new();
-    for (_index, func) in env.inner.info.function_bodies.iter() {
-        if config.compile {
-            let mut ctx = cranelift_codegen::Context::for_function(func.clone());
-            ctx.set_disasm(true);
-            let code = ctx
-                .compile(isa, &mut Default::default())
-                .map_err(|e| crate::pretty_anyhow_error(&e.func, e.inner))?;
-            writeln!(&mut actual, "function {}:", func.name).unwrap();
-            writeln!(&mut actual, "{}", code.vcode.as_ref().unwrap()).unwrap();
-        } else if config.optimize {
-            let mut ctx = cranelift_codegen::Context::for_function(func.clone());
-            ctx.optimize(isa)
-                .map_err(|e| crate::pretty_anyhow_error(&ctx.func, e))?;
-            writeln!(&mut actual, "{}", ctx.func.display()).unwrap();
-        } else {
-            writeln!(&mut actual, "{}", func.display()).unwrap();
-        }
-    }
-    let actual = actual.trim();
-    log::debug!("=== actual ===\n{actual}");
-
-    // The test's expectation is the final comment.
-    let mut expected_lines: Vec<_> = wat
-        .lines()
-        .rev()
-        .take_while(|l| l.starts_with(";;"))
-        .map(|l| {
-            if l.starts_with(";; ") {
-                &l[3..]
-            } else {
-                &l[2..]
-            }
-        })
-        .collect();
-    expected_lines.reverse();
-    let expected = expected_lines.join("\n");
-    let expected = expected.trim();
-    log::debug!("=== expected ===\n{expected}");
-
-    if actual == expected {
-        return Ok(());
-    }
-
-    if std::env::var("CRANELIFT_TEST_BLESS").unwrap_or_default() == "1" {
-        let old_expectation_line_count = wat
-            .lines()
-            .rev()
-            .take_while(|l| l.starts_with(";;"))
-            .count();
-        let old_wat_line_count = wat.lines().count();
-        let new_wat_lines: Vec<_> = wat
-            .lines()
-            .take(old_wat_line_count - old_expectation_line_count)
-            .map(|l| l.to_string())
-            .chain(actual.lines().map(|l| {
-                if l.is_empty() {
-                    ";;".to_string()
-                } else {
-                    format!(";; {l}")
-                }
-            }))
-            .collect();
-        let mut new_wat = new_wat_lines.join("\n");
-        new_wat.push('\n');
-        std::fs::write(path, new_wat)
-            .with_context(|| format!("failed to write file: {}", path.display()))?;
-        return Ok(());
-    }
-
-    bail!(
-        "Did not get the expected CLIF translation:\n\n\
-         {}\n\n\
-         Note: You can re-run with the `CRANELIFT_TEST_BLESS=1` environment\n\
-         variable set to update test expectations.",
-        TextDiff::from_lines(expected, actual)
-            .unified_diff()
-            .header("expected", "actual")
-    )
-}
diff --git a/cranelift/filetests/src/test_wasm/config.rs b/cranelift/filetests/src/test_wasm/config.rs
deleted file mode 100644
index ab85af333f49..000000000000
--- a/cranelift/filetests/src/test_wasm/config.rs
+++ /dev/null
@@ -1,223 +0,0 @@
-//! Configuration of `.wat` tests.
-//!
-//! The config is the leading `;;!` comments in the WAT. It is in TOML.
-
-use anyhow::{bail, ensure, Result};
-use cranelift_codegen::ir;
-use serde_derive::{Deserialize, Serialize};
-use std::collections::BTreeMap;
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct TestConfig {
-    #[serde(default)]
-    pub target: String,
-
-    #[serde(default)]
-    pub compile: bool,
-
-    #[serde(default)]
-    pub optimize: bool,
-
-    #[serde(default)]
-    pub settings: Vec<String>,
-
-    #[serde(default)]
-    pub globals: BTreeMap<String, TestGlobal>,
-
-    #[serde(default)]
-    pub heaps: Vec<TestHeap>,
-
-    #[serde(default)]
-    pub relaxed_simd_deterministic: bool,
-}
-
-impl TestConfig {
-    pub fn validate(&self) -> Result<()> {
-        if self.compile || self.optimize {
-            ensure!(
-                !(self.compile && self.optimize),
-                "The `compile` and `optimize` options are mutually exclusive."
-            );
-        }
-
-        for global in self.globals.values() {
-            ensure!(
-                global.vmctx || global.load.is_some(),
-                "global must be either `vmctx` or a `load`"
-            );
-            ensure!(
-                !(global.vmctx && global.load.is_some()),
-                "global cannot be both a `vmctx` and a `load`"
-            );
-
-            if let Some(load) = &global.load {
-                ensure!(
-                    self.globals.contains_key(&load.base),
-                    "global's load base must be another global"
-                );
-            }
-        }
-
-        for heap in &self.heaps {
-            ensure!(
-                self.globals.contains_key(&heap.base),
-                "heap base must be a declared global"
-            );
-
-            match heap.style.kind.as_str() {
-                "static" => match &heap.style.bound {
-                    toml::value::Value::Integer(x) => {
-                        ensure!(*x >= 0, "static heap bound cannot be negative")
-                    }
-                    _ => bail!("static heap bounds must be integers"),
-                },
-                "dynamic" => match &heap.style.bound {
-                    toml::value::Value::String(g) => {
-                        ensure!(
-                            self.globals.contains_key(g),
-                            "dynamic heap bound must be a declared global"
-                        )
-                    }
-                    _ => bail!("dynamic heap bounds must be strings"),
-                },
-                other => {
-                    bail!(
-                        "heap style must be 'static' or 'dynamic', found '{}'",
-                        other
-                    )
-                }
-            }
-        }
-
-        Ok(())
-    }
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct TestGlobal {
-    #[serde(rename = "type")]
-    pub type_: String,
-
-    #[serde(default)]
-    pub vmctx: bool,
-
-    #[serde(default)]
-    pub load: Option<TestGlobalLoad>,
-}
-
-impl TestGlobal {
-    pub fn to_ir(
-        &self,
-        name_to_ir_global: &BTreeMap<String, ir::GlobalValue>,
-    ) -> ir::GlobalValueData {
-        if self.vmctx {
-            ir::GlobalValueData::VMContext
-        } else if let Some(load) = &self.load {
-            ir::GlobalValueData::Load {
-                base: name_to_ir_global[&load.base],
-                offset: i32::try_from(load.offset).unwrap().into(),
-                global_type: match self.type_.as_str() {
-                    "i32" => ir::types::I32,
-                    "i64" => ir::types::I64,
-                    other => panic!("test globals cannot be of type '{other}'"),
-                },
-                readonly: load.readonly,
-            }
-        } else {
-            unreachable!()
-        }
-    }
-
-    pub fn dependencies<'a>(&'a self) -> impl Iterator<Item = &'a str> + 'a {
-        let mut deps = None;
-        if let Some(load) = &self.load {
-            deps = Some(load.base.as_str());
-        }
-        deps.into_iter()
-    }
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct TestGlobalLoad {
-    pub base: String,
-
-    #[serde(default)]
-    pub offset: u32,
-
-    #[serde(default)]
-    pub readonly: bool,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct TestHeap {
-    pub base: String,
-
-    #[serde(default)]
-    pub min_size: u64,
-
-    #[serde(default)]
-    pub offset_guard_size: u64,
-
-    pub style: TestHeapStyle,
-
-    pub index_type: String,
-}
-
-impl TestHeap {
-    pub fn to_ir(
-        &self,
-        name_to_ir_global: &BTreeMap<String, ir::GlobalValue>,
-    ) -> cranelift_wasm::HeapData {
-        cranelift_wasm::HeapData {
-            base: name_to_ir_global[&self.base],
-            min_size: self.min_size.into(),
-            offset_guard_size: self.offset_guard_size.into(),
-            style: self.style.to_ir(name_to_ir_global),
-            index_type: match self.index_type.as_str() {
-                "i32" => ir::types::I32,
-                "i64" => ir::types::I64,
-                other => panic!("heap indices may only be i32 or i64, found '{other}'"),
-            },
-        }
-    }
-
-    pub fn dependencies<'a>(&'a self) -> impl Iterator<Item = &'a str> + 'a {
-        let mut deps = vec![self.base.as_str()];
-        if self.style.kind == "dynamic" {
-            deps.push(match &self.style.bound {
-                toml::Value::String(g) => g.as_str(),
-                _ => unreachable!(),
-            });
-        }
-        deps.into_iter()
-    }
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct TestHeapStyle {
-    pub kind: String,
-    pub bound: toml::value::Value,
-}
-
-impl TestHeapStyle {
-    pub fn to_ir(
-        &self,
-        name_to_ir_global: &BTreeMap<String, ir::GlobalValue>,
-    ) -> cranelift_wasm::HeapStyle {
-        match self.kind.as_str() {
-            "static" => cranelift_wasm::HeapStyle::Static {
-                bound: match &self.bound {
-                    toml::Value::Integer(x) => u64::try_from(*x).unwrap().into(),
-                    _ => unreachable!(),
-                },
-            },
-            "dynamic" => cranelift_wasm::HeapStyle::Dynamic {
-                bound_gv: match &self.bound {
-                    toml::Value::String(g) => name_to_ir_global[g],
-                    _ => unreachable!(),
-                },
-            },
-            _ => unreachable!(),
-        }
-    }
-}
diff --git a/cranelift/filetests/src/test_wasm/env.rs b/cranelift/filetests/src/test_wasm/env.rs
index 89c7ad2119eb..dccc9c31fce2 100644
--- a/cranelift/filetests/src/test_wasm/env.rs
+++ b/cranelift/filetests/src/test_wasm/env.rs
@@ -20,6 +20,7 @@ pub struct ModuleEnv {
     pub inner: DummyEnvironment,
     pub config: TestConfig,
     pub heap_access_spectre_mitigation: bool,
+    pub proof_carrying_code: bool,
 }
 
 impl ModuleEnv {
@@ -31,6 +32,7 @@ impl ModuleEnv {
             heap_access_spectre_mitigation: target_isa
                 .flags()
                 .enable_heap_access_spectre_mitigation(),
+            proof_carrying_code: target_isa.flags().enable_pcc(),
         }
     }
 }
@@ -51,6 +53,7 @@ impl<'data> ModuleEnvironment<'data> for ModuleEnv {
                 self.inner.expected_reachability.clone(),
                 self.config.clone(),
                 self.heap_access_spectre_mitigation,
+                self.proof_carrying_code,
             );
             let func_index = FuncIndex::new(
                 self.inner.get_num_func_imports() + self.inner.info.function_bodies.len(),
@@ -76,12 +79,10 @@ impl<'data> ModuleEnvironment<'data> for ModuleEnv {
     }
 
     fn wasm_features(&self) -> wasmparser::WasmFeatures {
-        wasmparser::WasmFeatures {
-            memory64: true,
-            multi_memory: true,
-            relaxed_simd: true,
-            ..self.inner.wasm_features()
-        }
+        self.inner.wasm_features()
+            | wasmparser::WasmFeatures::MEMORY64
+            | wasmparser::WasmFeatures::MULTI_MEMORY
+            | wasmparser::WasmFeatures::RELAXED_SIMD
     }
 
     // ================================================================
@@ -233,7 +234,7 @@ impl<'data> ModuleEnvironment<'data> for ModuleEnv {
 }
 
 impl TypeConvert for ModuleEnv {
-    fn lookup_heap_type(&self, _index: TypeIndex) -> WasmHeapType {
+    fn lookup_heap_type(&self, _index: wasmparser::UnpackedIndex) -> WasmHeapType {
         todo!()
     }
 }
@@ -244,6 +245,7 @@ pub struct FuncEnv<'a> {
     pub name_to_ir_global: BTreeMap<String, ir::GlobalValue>,
     pub next_heap: usize,
     pub heap_access_spectre_mitigation: bool,
+    pub proof_carrying_code: bool,
 }
 
 impl<'a> FuncEnv<'a> {
@@ -252,6 +254,7 @@ impl<'a> FuncEnv<'a> {
         expected_reachability: Option<cranelift_wasm::ExpectedReachability>,
         config: TestConfig,
         heap_access_spectre_mitigation: bool,
+        proof_carrying_code: bool,
     ) -> Self {
         let inner = cranelift_wasm::DummyFuncEnvironment::new(mod_info, expected_reachability);
         Self {
@@ -260,12 +263,13 @@ impl<'a> FuncEnv<'a> {
             name_to_ir_global: Default::default(),
             next_heap: 0,
             heap_access_spectre_mitigation,
+            proof_carrying_code,
         }
     }
 }
 
 impl TypeConvert for FuncEnv<'_> {
-    fn lookup_heap_type(&self, _index: TypeIndex) -> WasmHeapType {
+    fn lookup_heap_type(&self, _index: wasmparser::UnpackedIndex) -> WasmHeapType {
         todo!()
     }
 }
@@ -278,6 +282,10 @@ impl<'a> TargetEnvironment for FuncEnv<'a> {
     fn heap_access_spectre_mitigation(&self) -> bool {
         self.heap_access_spectre_mitigation
     }
+
+    fn proof_carrying_code(&self) -> bool {
+        self.proof_carrying_code
+    }
 }
 
 impl<'a> FuncEnvironment for FuncEnv<'a> {
@@ -677,4 +685,28 @@ impl<'a> FuncEnvironment for FuncEnv<'a> {
     ) -> cranelift_wasm::WasmResult<ir::Inst> {
         unimplemented!()
     }
+
+    fn translate_ref_i31(
+        &mut self,
+        _pos: cranelift_codegen::cursor::FuncCursor,
+        _val: ir::Value,
+    ) -> cranelift_wasm::WasmResult<ir::Value> {
+        unimplemented!()
+    }
+
+    fn translate_i31_get_s(
+        &mut self,
+        _pos: cranelift_codegen::cursor::FuncCursor,
+        _i31ref: ir::Value,
+    ) -> cranelift_wasm::WasmResult<ir::Value> {
+        unimplemented!()
+    }
+
+    fn translate_i31_get_u(
+        &mut self,
+        _pos: cranelift_codegen::cursor::FuncCursor,
+        _i31ref: ir::Value,
+    ) -> cranelift_wasm::WasmResult<ir::Value> {
+        unimplemented!()
+    }
 }
diff --git a/cranelift/frontend/Cargo.toml b/cranelift/frontend/Cargo.toml
index fffa87065d7b..4352525dc607 100644
--- a/cranelift/frontend/Cargo.toml
+++ b/cranelift/frontend/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 authors = ["The Cranelift Project Developers"]
 name = "cranelift-frontend"
-version = "0.101.0"
+version = "0.112.0"
 description = "Cranelift IR builder helper"
 license = "Apache-2.0 WITH LLVM-exception"
 documentation = "https://docs.rs/cranelift-frontend"
@@ -9,6 +9,10 @@ categories = ["no-std"]
 repository = "https://github.com/bytecodealliance/wasmtime"
 readme = "README.md"
 edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
 
 [dependencies]
 cranelift-codegen = { workspace = true }
@@ -18,7 +22,9 @@ hashbrown = { workspace = true, optional = true }
 smallvec = { workspace = true }
 
 [dev-dependencies]
+env_logger = { workspace = true }
 similar = { workspace = true }
+cranelift-codegen = { workspace = true, features = ['x86'] }
 
 [features]
 default = ["std"]
diff --git a/cranelift/frontend/src/frontend.rs b/cranelift/frontend/src/frontend.rs
index 631f6ba8cb8e..125be6a773b7 100644
--- a/cranelift/frontend/src/frontend.rs
+++ b/cranelift/frontend/src/frontend.rs
@@ -1,8 +1,9 @@
 //! A frontend for building Cranelift IR from other languages.
 use crate::ssa::{SSABuilder, SideEffects};
 use crate::variable::Variable;
+use alloc::vec::Vec;
 use core::fmt::{self, Debug};
-use cranelift_codegen::cursor::{Cursor, FuncCursor};
+use cranelift_codegen::cursor::{Cursor, CursorPosition, FuncCursor};
 use cranelift_codegen::entity::{EntityRef, EntitySet, SecondaryMap};
 use cranelift_codegen::ir;
 use cranelift_codegen::ir::condcodes::IntCC;
@@ -15,20 +16,27 @@ use cranelift_codegen::ir::{
 };
 use cranelift_codegen::isa::TargetFrontendConfig;
 use cranelift_codegen::packed_option::PackedOption;
+use cranelift_codegen::traversals::Dfs;
+use smallvec::SmallVec;
+
+mod safepoints;
 
 /// Structure used for translating a series of functions into Cranelift IR.
 ///
 /// In order to reduce memory reallocations when compiling multiple functions,
-/// `FunctionBuilderContext` holds various data structures which are cleared between
+/// [`FunctionBuilderContext`] holds various data structures which are cleared between
 /// functions, rather than dropped, preserving the underlying allocations.
 #[derive(Default)]
 pub struct FunctionBuilderContext {
     ssa: SSABuilder,
     status: SecondaryMap<Block, BlockStatus>,
     types: SecondaryMap<Variable, Type>,
+    stack_map_vars: EntitySet<Variable>,
+    stack_map_values: EntitySet<Value>,
+    safepoints: safepoints::SafepointSpiller,
 }
 
-/// Temporary object used to build a single Cranelift IR `Function`.
+/// Temporary object used to build a single Cranelift IR [`Function`].
 pub struct FunctionBuilder<'a> {
     /// The function currently being built.
     /// This field is public so the function can be re-borrowed.
@@ -53,16 +61,27 @@ enum BlockStatus {
 }
 
 impl FunctionBuilderContext {
-    /// Creates a FunctionBuilderContext structure. The structure is automatically cleared after
-    /// each [`FunctionBuilder`](struct.FunctionBuilder.html) completes translating a function.
+    /// Creates a [`FunctionBuilderContext`] structure. The structure is automatically cleared after
+    /// each [`FunctionBuilder`] completes translating a function.
     pub fn new() -> Self {
         Self::default()
     }
 
     fn clear(&mut self) {
-        self.ssa.clear();
-        self.status.clear();
-        self.types.clear();
+        let FunctionBuilderContext {
+            ssa,
+            status,
+            types,
+            stack_map_vars,
+            stack_map_values,
+            safepoints,
+        } = self;
+        ssa.clear();
+        status.clear();
+        types.clear();
+        stack_map_values.clear();
+        stack_map_vars.clear();
+        safepoints.clear();
     }
 
     fn is_empty(&self) -> bool {
@@ -70,7 +89,7 @@ impl FunctionBuilderContext {
     }
 }
 
-/// Implementation of the [`InstBuilder`](cranelift_codegen::ir::InstBuilder) that has
+/// Implementation of the [`InstBuilder`] that has
 /// one convenience method per Cranelift IR instruction.
 pub struct FuncInstBuilder<'short, 'long: 'short> {
     builder: &'short mut FunctionBuilder<'long>,
@@ -99,7 +118,7 @@ impl<'short, 'long> InstBuilderBase<'short> for FuncInstBuilder<'short, 'long> {
         // We only insert the Block in the layout when an instruction is added to it
         self.builder.ensure_inserted_block();
 
-        let inst = self.builder.func.dfg.make_inst(data.clone());
+        let inst = self.builder.func.dfg.make_inst(data);
         self.builder.func.dfg.make_inst_results(inst, ctrl_typevar);
         self.builder.func.layout.append_inst(inst, self.block);
         if !self.builder.srcloc.is_default() {
@@ -223,7 +242,7 @@ pub enum DefVariableError {
     ///
     /// note: to obtain the type of the value, you can call
     /// [`cranelift_codegen::ir::dfg::DataFlowGraph::value_type`] (using the
-    /// [`FunctionBuilder.func.dfg`] field)
+    /// `FunctionBuilder.func.dfg` field)
     TypeMismatch(Variable, Value),
     /// The value was defined (in a call to [`FunctionBuilder::def_var`]) before
     /// it was declared (in a call to [`FunctionBuilder::declare_var`]).
@@ -246,7 +265,7 @@ impl fmt::Display for DefVariableError {
             DefVariableError::DefinedBeforeDeclared(variable) => {
                 write!(
                     f,
-                    "the value of variabe {} was declared before it was defined",
+                    "the value of variable {} was declared before it was defined",
                     variable.index()
                 )?;
             }
@@ -261,7 +280,7 @@ impl fmt::Display for DefVariableError {
 /// The module is parametrized by one type which is the representation of variables in your
 /// origin language. It offers a way to conveniently append instruction to your program flow.
 /// You are responsible to split your instruction flow into extended blocks (declared with
-/// `create_block`) whose properties are:
+/// [`create_block`](Self::create_block)) whose properties are:
 ///
 /// - branch and jump instructions can only point at the top of extended blocks;
 /// - the last instruction of each block is a terminator instruction which has no natural successor,
@@ -269,28 +288,27 @@ impl fmt::Display for DefVariableError {
 ///
 /// The parameters of Cranelift IR instructions are Cranelift IR values, which can only be created
 /// as results of other Cranelift IR instructions. To be able to create variables redefined multiple
-/// times in your program, use the `def_var` and `use_var` command, that will maintain the
-/// correspondence between your variables and Cranelift IR SSA values.
+/// times in your program, use the [`def_var`](Self::def_var) and [`use_var`](Self::use_var) command,
+/// that will maintain the correspondence between your variables and Cranelift IR SSA values.
 ///
-/// The first block for which you call `switch_to_block` will be assumed to be the beginning of
-/// the function.
+/// The first block for which you call [`switch_to_block`](Self::switch_to_block) will be assumed to
+/// be the beginning of the function.
 ///
-/// At creation, a `FunctionBuilder` instance borrows an already allocated `Function` which it
+/// At creation, a [`FunctionBuilder`] instance borrows an already allocated `Function` which it
 /// modifies with the information stored in the mutable borrowed
-/// [`FunctionBuilderContext`](struct.FunctionBuilderContext.html). The function passed in
-/// argument should be newly created with
-/// [`Function::with_name_signature()`](Function::with_name_signature), whereas the
-/// `FunctionBuilderContext` can be kept as is between two function translations.
+/// [`FunctionBuilderContext`]. The function passed in argument should be newly created with
+/// [`Function::with_name_signature()`], whereas the [`FunctionBuilderContext`] can be kept as is
+/// between two function translations.
 ///
 /// # Errors
 ///
 /// The functions below will panic in debug mode whenever you try to modify the Cranelift IR
 /// function in a way that violate the coherence of the code. For instance: switching to a new
-/// `Block` when you haven't filled the current one with a terminator instruction, inserting a
+/// [`Block`] when you haven't filled the current one with a terminator instruction, inserting a
 /// return instruction with arguments that don't match the function's signature.
 impl<'a> FunctionBuilder<'a> {
-    /// Creates a new FunctionBuilder structure that will operate on a `Function` using a
-    /// `FunctionBuilderContext`.
+    /// Creates a new [`FunctionBuilder`] structure that will operate on a [`Function`] using a
+    /// [`FunctionBuilderContext`].
     pub fn new(func: &'a mut Function, func_ctx: &'a mut FunctionBuilderContext) -> Self {
         debug_assert!(func_ctx.is_empty());
         Self {
@@ -311,7 +329,7 @@ impl<'a> FunctionBuilder<'a> {
         self.srcloc = srcloc;
     }
 
-    /// Creates a new `Block` and returns its reference.
+    /// Creates a new [`Block`] and returns its reference.
     pub fn create_block(&mut self) -> Block {
         let block = self.func.dfg.make_block();
         self.func_ctx.ssa.declare_block(block);
@@ -332,7 +350,7 @@ impl<'a> FunctionBuilder<'a> {
     }
 
     /// After the call to this function, new instructions will be inserted into the designated
-    /// block, in the order they are declared. You must declare the types of the Block arguments
+    /// block, in the order they are declared. You must declare the types of the [`Block`] arguments
     /// you will use here.
     ///
     /// When inserting the terminator instruction (which doesn't have a fallthrough to its immediate
@@ -367,9 +385,9 @@ impl<'a> FunctionBuilder<'a> {
         self.handle_ssa_side_effects(side_effects);
     }
 
-    /// Effectively calls seal_block on all unsealed blocks in the function.
+    /// Effectively calls [seal_block](Self::seal_block) on all unsealed blocks in the function.
     ///
-    /// It's more efficient to seal `Block`s as soon as possible, during
+    /// It's more efficient to seal [`Block`]s as soon as possible, during
     /// translation, but for frontends where this is impractical to do, this
     /// function can be used at the end of translating all blocks to ensure
     /// that everything is sealed.
@@ -378,9 +396,15 @@ impl<'a> FunctionBuilder<'a> {
         self.handle_ssa_side_effects(side_effects);
     }
 
-    /// Declares the type of a variable, so that it can be used later (by calling
-    /// [`FunctionBuilder::use_var`]). This function will return an error if the variable
-    /// has been previously declared.
+    /// Declares the type of a variable.
+    ///
+    /// This allows the variable to be used later (by calling
+    /// [`FunctionBuilder::use_var`]).
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error if the variable has been previously
+    /// declared.
     pub fn try_declare_var(&mut self, var: Variable, ty: Type) -> Result<(), DeclareVariableError> {
         if self.func_ctx.types[var] != types::INVALID {
             return Err(DeclareVariableError::DeclaredMultipleTimes(var));
@@ -389,11 +413,36 @@ impl<'a> FunctionBuilder<'a> {
         Ok(())
     }
 
-    /// In order to use a variable (by calling [`FunctionBuilder::use_var`]), you need
-    /// to first declare its type with this method.
+    /// Declares the type of a variable, panicking if it is already declared.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the variable has already been declared.
     pub fn declare_var(&mut self, var: Variable, ty: Type) {
         self.try_declare_var(var, ty)
-            .unwrap_or_else(|_| panic!("the variable {:?} has been declared multiple times", var))
+            .unwrap_or_else(|_| panic!("the variable {var:?} has been declared multiple times"))
+    }
+
+    /// Declare that all uses of the given variable must be included in stack
+    /// map metadata.
+    ///
+    /// All values that are uses of this variable will be spilled to the stack
+    /// before each safepoint and their location on the stack included in stack
+    /// maps. Stack maps allow the garbage collector to identify the on-stack GC
+    /// roots.
+    ///
+    /// This does not affect any pre-existing uses of the variable.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the variable's type is larger than 16 bytes or if this
+    /// variable has not been declared yet.
+    pub fn declare_var_needs_stack_map(&mut self, var: Variable) {
+        log::trace!("declare_var_needs_stack_map({var:?})");
+        let ty = self.func_ctx.types[var];
+        assert!(ty != types::INVALID);
+        assert!(ty.bytes() <= 16);
+        self.func_ctx.stack_map_vars.insert(var);
     }
 
     /// Returns the Cranelift IR necessary to use a previously defined user
@@ -414,14 +463,20 @@ impl<'a> FunctionBuilder<'a> {
             debug_assert_ne!(
                 ty,
                 types::INVALID,
-                "variable {:?} is used but its type has not been declared",
-                var
+                "variable {var:?} is used but its type has not been declared"
             );
             self.func_ctx
                 .ssa
                 .use_var(self.func, var, ty, self.position.unwrap())
         };
         self.handle_ssa_side_effects(side_effects);
+
+        // If the variable was declared as needing stack maps, then propagate
+        // that requirement to all values derived from using the variable.
+        if self.func_ctx.stack_map_vars.contains(var) {
+            self.declare_value_needs_stack_map(val);
+        }
+
         Ok(val)
     }
 
@@ -429,10 +484,7 @@ impl<'a> FunctionBuilder<'a> {
     /// position of a previously defined user variable.
     pub fn use_var(&mut self, var: Variable) -> Value {
         self.try_use_var(var).unwrap_or_else(|_| {
-            panic!(
-                "variable {:?} is used but its type has not been declared",
-                var
-            )
+            panic!("variable {var:?} is used but its type has not been declared")
         })
     }
 
@@ -449,6 +501,11 @@ impl<'a> FunctionBuilder<'a> {
             return Err(DefVariableError::TypeMismatch(var, val));
         }
 
+        // If `var` needs inclusion in stack maps, then `val` does too.
+        if self.func_ctx.stack_map_vars.contains(var) {
+            self.declare_value_needs_stack_map(val);
+        }
+
         self.func_ctx.ssa.def_var(var, val, self.position.unwrap());
         Ok(())
     }
@@ -459,23 +516,18 @@ impl<'a> FunctionBuilder<'a> {
         self.try_def_var(var, val)
             .unwrap_or_else(|error| match error {
                 DefVariableError::TypeMismatch(var, val) => {
-                    panic!(
-                        "declared type of variable {:?} doesn't match type of value {}",
-                        var, val
-                    );
+                    panic!("declared type of variable {var:?} doesn't match type of value {val}");
                 }
                 DefVariableError::DefinedBeforeDeclared(var) => {
-                    panic!(
-                        "variable {:?} is used but its type has not been declared",
-                        var
-                    );
+                    panic!("variable {var:?} is used but its type has not been declared");
                 }
             })
     }
 
-    /// Set label for Value
+    /// Set label for [`Value`]
     ///
-    /// This will not do anything unless `func.dfg.collect_debug_info` is called first.
+    /// This will not do anything unless
+    /// [`func.dfg.collect_debug_info`](DataFlowGraph::collect_debug_info) is called first.
     pub fn set_val_label(&mut self, val: Value, label: ValueLabel) {
         if let Some(values_labels) = self.func.stencil.dfg.values_labels.as_mut() {
             use alloc::collections::btree_map::Entry;
@@ -497,19 +549,43 @@ impl<'a> FunctionBuilder<'a> {
         }
     }
 
-    /// Creates a jump table in the function, to be used by `br_table` instructions.
+    /// Declare that the given value is a GC reference that requires inclusion
+    /// in a stack map when it is live across GC safepoints.
+    ///
+    /// At the current moment, values that need inclusion in stack maps are
+    /// spilled before safepoints, but they are not reloaded afterwards. This
+    /// means that moving GCs are not yet supported, however the intention is to
+    /// add this support in the near future.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `val` is larger than 16 bytes.
+    pub fn declare_value_needs_stack_map(&mut self, val: Value) {
+        log::trace!("declare_value_needs_stack_map({val:?})");
+
+        // We rely on these properties in `insert_safepoint_spills`.
+        let size = self.func.dfg.value_type(val).bytes();
+        assert!(size <= 16);
+        assert!(size.is_power_of_two());
+
+        self.func_ctx.stack_map_values.insert(val);
+    }
+
+    /// Creates a jump table in the function, to be used by [`br_table`](InstBuilder::br_table) instructions.
     pub fn create_jump_table(&mut self, data: JumpTableData) -> JumpTable {
         self.func.create_jump_table(data)
     }
 
-    /// Creates a sized stack slot in the function, to be used by `stack_load`, `stack_store` and
-    /// `stack_addr` instructions.
+    /// Creates a sized stack slot in the function, to be used by [`stack_load`](InstBuilder::stack_load),
+    /// [`stack_store`](InstBuilder::stack_store) and [`stack_addr`](InstBuilder::stack_addr) instructions.
     pub fn create_sized_stack_slot(&mut self, data: StackSlotData) -> StackSlot {
         self.func.create_sized_stack_slot(data)
     }
 
-    /// Creates a dynamic stack slot in the function, to be used by `dynamic_stack_load`,
-    /// `dynamic_stack_store` and `dynamic_stack_addr` instructions.
+    /// Creates a dynamic stack slot in the function, to be used by
+    /// [`dynamic_stack_load`](InstBuilder::dynamic_stack_load),
+    /// [`dynamic_stack_store`](InstBuilder::dynamic_stack_store) and
+    /// [`dynamic_stack_addr`](InstBuilder::dynamic_stack_addr) instructions.
     pub fn create_dynamic_stack_slot(&mut self, data: DynamicStackSlotData) -> DynamicStackSlot {
         self.func.create_dynamic_stack_slot(data)
     }
@@ -529,8 +605,8 @@ impl<'a> FunctionBuilder<'a> {
         self.func.create_global_value(data)
     }
 
-    /// Returns an object with the [`InstBuilder`](cranelift_codegen::ir::InstBuilder)
-    /// trait that allows to conveniently append an instruction to the current `Block` being built.
+    /// Returns an object with the [`InstBuilder`]
+    /// trait that allows to conveniently append an instruction to the current [`Block`] being built.
     pub fn ins<'short>(&'short mut self) -> FuncInstBuilder<'short, 'a> {
         let block = self
             .position
@@ -554,10 +630,10 @@ impl<'a> FunctionBuilder<'a> {
         }
     }
 
-    /// Returns a `FuncCursor` pointed at the current position ready for inserting instructions.
+    /// Returns a [`FuncCursor`] pointed at the current position ready for inserting instructions.
     ///
     /// This can be used to insert SSA code that doesn't need to access locals and that doesn't
-    /// need to know about `FunctionBuilder` at all.
+    /// need to know about [`FunctionBuilder`] at all.
     pub fn cursor(&mut self) -> FuncCursor {
         self.ensure_inserted_block();
         FuncCursor::new(self.func)
@@ -565,7 +641,7 @@ impl<'a> FunctionBuilder<'a> {
             .at_bottom(self.position.unwrap())
     }
 
-    /// Append parameters to the given `Block` corresponding to the function
+    /// Append parameters to the given [`Block`] corresponding to the function
     /// parameters. This can be used to set up the block parameters for the
     /// entry block.
     pub fn append_block_params_for_function_params(&mut self, block: Block) {
@@ -589,7 +665,7 @@ impl<'a> FunctionBuilder<'a> {
         }
     }
 
-    /// Append parameters to the given `Block` corresponding to the function
+    /// Append parameters to the given [`Block`] corresponding to the function
     /// return values. This can be used to set up the block parameters for a
     /// function exit block.
     pub fn append_block_params_for_function_returns(&mut self, block: Block) {
@@ -610,9 +686,9 @@ impl<'a> FunctionBuilder<'a> {
 
     /// Declare that translation of the current function is complete.
     ///
-    /// This resets the state of the `FunctionBuilderContext` in preparation to
+    /// This resets the state of the [`FunctionBuilderContext`] in preparation to
     /// be used for another function.
-    pub fn finalize(self) {
+    pub fn finalize(mut self) {
         // Check that all the `Block`s are filled and sealed.
         #[cfg(debug_assertions)]
         {
@@ -620,13 +696,11 @@ impl<'a> FunctionBuilder<'a> {
                 if !self.is_pristine(block) {
                     assert!(
                         self.func_ctx.ssa.is_sealed(block),
-                        "FunctionBuilder finalized, but block {} is not sealed",
-                        block,
+                        "FunctionBuilder finalized, but block {block} is not sealed",
                     );
                     assert!(
                         self.is_filled(block),
-                        "FunctionBuilder finalized, but block {} is not filled",
-                        block,
+                        "FunctionBuilder finalized, but block {block} is not filled",
                     );
                 }
             }
@@ -639,14 +713,17 @@ impl<'a> FunctionBuilder<'a> {
             for block in self.func_ctx.status.keys() {
                 if let Err((inst, msg)) = self.func.is_block_basic(block) {
                     let inst_str = self.func.dfg.display_inst(inst);
-                    panic!(
-                        "{} failed basic block invariants on {}: {}",
-                        block, inst_str, msg
-                    );
+                    panic!("{block} failed basic block invariants on {inst_str}: {msg}");
                 }
             }
         }
 
+        if !self.func_ctx.stack_map_values.is_empty() {
+            self.func_ctx
+                .safepoints
+                .run(&mut self.func, &self.func_ctx.stack_map_values);
+        }
+
         // Clear the state (but preserve the allocated buffers) in preparation
         // for translation another function.
         self.func_ctx.clear();
@@ -659,18 +736,19 @@ impl<'a> FunctionBuilder<'a> {
 /// function. The functions below help you inspect the function you're creating and modify it
 /// in ways that can be unsafe if used incorrectly.
 impl<'a> FunctionBuilder<'a> {
-    /// Retrieves all the parameters for a `Block` currently inferred from the jump instructions
+    /// Retrieves all the parameters for a [`Block`] currently inferred from the jump instructions
     /// inserted that target it and the SSA construction.
     pub fn block_params(&self, block: Block) -> &[Value] {
         self.func.dfg.block_params(block)
     }
 
-    /// Retrieves the signature with reference `sigref` previously added with `import_signature`.
+    /// Retrieves the signature with reference `sigref` previously added with
+    /// [`import_signature`](Self::import_signature).
     pub fn signature(&self, sigref: SigRef) -> Option<&Signature> {
         self.func.dfg.signatures.get(sigref)
     }
 
-    /// Creates a parameter for a specific `Block` by appending it to the list of already existing
+    /// Creates a parameter for a specific [`Block`] by appending it to the list of already existing
     /// parameters.
     ///
     /// **Note:** this function has to be called at the creation of the `Block` before adding
@@ -703,7 +781,7 @@ impl<'a> FunctionBuilder<'a> {
         }
     }
 
-    /// Returns `true` if and only if the current `Block` is sealed and has no predecessors declared.
+    /// Returns `true` if and only if the current [`Block`] is sealed and has no predecessors declared.
     ///
     /// The entry block of a function is never unreachable.
     pub fn is_unreachable(&self) -> bool {
@@ -720,13 +798,13 @@ impl<'a> FunctionBuilder<'a> {
     }
 
     /// Returns `true` if and only if no instructions have been added since the last call to
-    /// `switch_to_block`.
+    /// [`switch_to_block`](Self::switch_to_block).
     fn is_pristine(&self, block: Block) -> bool {
         self.func_ctx.status[block] == BlockStatus::Empty
     }
 
     /// Returns `true` if and only if a terminator instruction has been inserted since the
-    /// last call to `switch_to_block`.
+    /// last call to [`switch_to_block`](Self::switch_to_block).
     fn is_filled(&self, block: Block) -> bool {
         self.func_ctx.status[block] == BlockStatus::Filled
     }
@@ -1038,7 +1116,7 @@ impl<'a> FunctionBuilder<'a> {
             | SignedGreaterThanOrEqual
             | SignedGreaterThan
             | SignedLessThanOrEqual => {
-                panic!("Signed comparison {} not supported by memcmp", int_cc)
+                panic!("Signed comparison {int_cc} not supported by memcmp")
             }
         };
 
@@ -1235,12 +1313,12 @@ mod tests {
 
     #[track_caller]
     fn check(func: &Function, expected_ir: &str) {
+        let expected_ir = expected_ir.trim();
         let actual_ir = func.display().to_string();
+        let actual_ir = actual_ir.trim();
         assert!(
             expected_ir == actual_ir,
-            "Expected:\n{}\nGot:\n{}",
-            expected_ir,
-            actual_ir
+            "Expected:\n{expected_ir}\nGot:\n{actual_ir}"
         );
     }
 
@@ -1249,6 +1327,7 @@ mod tests {
         TargetFrontendConfig {
             default_call_conv: CallConv::SystemV,
             pointer_width: PointerWidth::U64,
+            page_size_align_log2: 12,
         }
     }
 
@@ -1754,7 +1833,7 @@ block0:
 
         check(
             &func,
-            &format!("function %sample() -> i8 system_v {{{}\n}}\n", expected),
+            &format!("function %sample() -> i8 system_v {{{expected}\n}}\n"),
         );
     }
 
@@ -1851,4 +1930,34 @@ block0:
             );
         }
     }
+
+    #[test]
+    fn test_builder_with_iconst_and_negative_constant() {
+        let sig = Signature::new(CallConv::SystemV);
+        let mut fn_ctx = FunctionBuilderContext::new();
+        let mut func = Function::with_name_signature(UserFuncName::testcase("sample"), sig);
+
+        let mut builder = FunctionBuilder::new(&mut func, &mut fn_ctx);
+
+        let block0 = builder.create_block();
+        builder.switch_to_block(block0);
+        builder.ins().iconst(I32, -1);
+        builder.ins().return_(&[]);
+
+        builder.seal_all_blocks();
+        builder.finalize();
+
+        let flags = cranelift_codegen::settings::Flags::new(cranelift_codegen::settings::builder());
+        let ctx = cranelift_codegen::Context::for_function(func);
+        ctx.verify(&flags).expect("should be valid");
+
+        check(
+            &ctx.func,
+            "function %sample() system_v {
+block0:
+    v0 = iconst.i32 -1
+    return
+}",
+        );
+    }
 }
diff --git a/cranelift/frontend/src/frontend/safepoints.rs b/cranelift/frontend/src/frontend/safepoints.rs
new file mode 100644
index 000000000000..f4a9f8455a1d
--- /dev/null
+++ b/cranelift/frontend/src/frontend/safepoints.rs
@@ -0,0 +1,2409 @@
+//! Support for safepoints and stack maps.
+
+use super::*;
+use crate::{HashMap, HashSet};
+use core::ops::{Index, IndexMut};
+
+#[derive(Clone, Copy)]
+#[repr(u8)]
+enum SlotSize {
+    Size8 = 0,
+    Size16 = 1,
+    Size32 = 2,
+    Size64 = 3,
+    Size128 = 4,
+    // If adding support for more slot sizes, update `SLOT_SIZE_LEN` below.
+}
+const SLOT_SIZE_LEN: usize = 5;
+
+impl TryFrom<ir::Type> for SlotSize {
+    type Error = &'static str;
+
+    fn try_from(ty: ir::Type) -> Result<Self, Self::Error> {
+        Self::new(ty.bytes()).ok_or("type is not supported in stack maps")
+    }
+}
+
+impl SlotSize {
+    fn new(bytes: u32) -> Option<Self> {
+        match bytes {
+            1 => Some(Self::Size8),
+            2 => Some(Self::Size16),
+            4 => Some(Self::Size32),
+            8 => Some(Self::Size64),
+            16 => Some(Self::Size128),
+            _ => None,
+        }
+    }
+
+    fn unwrap_new(bytes: u32) -> Self {
+        Self::new(bytes).unwrap_or_else(|| panic!("cannot create a `SlotSize` for {bytes} bytes"))
+    }
+}
+
+/// A map from every `SlotSize` to a `T`.
+struct SlotSizeMap<T>([T; SLOT_SIZE_LEN]);
+
+impl<T> Default for SlotSizeMap<T>
+where
+    T: Default,
+{
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<T> Index<SlotSize> for SlotSizeMap<T> {
+    type Output = T;
+    fn index(&self, index: SlotSize) -> &Self::Output {
+        self.get(index)
+    }
+}
+
+impl<T> IndexMut<SlotSize> for SlotSizeMap<T> {
+    fn index_mut(&mut self, index: SlotSize) -> &mut Self::Output {
+        self.get_mut(index)
+    }
+}
+
+impl<T> SlotSizeMap<T> {
+    fn new() -> Self
+    where
+        T: Default,
+    {
+        Self([
+            T::default(),
+            T::default(),
+            T::default(),
+            T::default(),
+            T::default(),
+        ])
+    }
+
+    fn clear(&mut self)
+    where
+        T: Default,
+    {
+        *self = Self::new();
+    }
+
+    fn get(&self, size: SlotSize) -> &T {
+        let index = size as u8 as usize;
+        &self.0[index]
+    }
+
+    fn get_mut(&mut self, size: SlotSize) -> &mut T {
+        let index = size as u8 as usize;
+        &mut self.0[index]
+    }
+}
+
+/// A set of live values.
+///
+/// Make sure to copy to a vec and sort, or something, before iterating over the
+/// values to ensure deterministic output.
+type LiveSet = HashSet<ir::Value>;
+
+/// A worklist of blocks' post-order indices that we need to process.
+#[derive(Default)]
+struct Worklist {
+    /// Stack of blocks to process.
+    stack: Vec<u32>,
+
+    /// The set of blocks that need to be updated.
+    ///
+    /// This is a subset of the elements present in `self.stack`, *not* the
+    /// exact same elements. `self.stack` is allowed to have duplicates, and
+    /// once we pop the first occurrence of a duplicate, we remove it from this
+    /// set, since it no longer needs updates at that point. This potentially
+    /// uses more stack space than necessary, but prefers processing immediate
+    /// predecessors, and therefore inner loop bodies before continuing to
+    /// process outer loop bodies. This ultimately results in fewer iterations
+    /// required to reach a fixed point.
+    need_updates: HashSet<u32>,
+}
+
+impl Extend<u32> for Worklist {
+    fn extend<T>(&mut self, iter: T)
+    where
+        T: IntoIterator<Item = u32>,
+    {
+        for block_index in iter {
+            self.push(block_index);
+        }
+    }
+}
+
+impl Worklist {
+    fn clear(&mut self) {
+        let Worklist {
+            stack,
+            need_updates,
+        } = self;
+        stack.clear();
+        need_updates.clear();
+    }
+
+    fn reserve(&mut self, capacity: usize) {
+        let Worklist {
+            stack,
+            need_updates,
+        } = self;
+        stack.reserve(capacity);
+        need_updates.reserve(capacity);
+    }
+
+    fn push(&mut self, block_index: u32) {
+        // Mark this block as needing an update. If it wasn't in `self.stack`,
+        // now it is and it needs an update. If it was already in `self.stack`,
+        // then pushing this copy logically hoists it to the top of the
+        // stack. See the above note about processing inner-most loops first.
+        self.need_updates.insert(block_index);
+        self.stack.push(block_index);
+    }
+
+    fn pop(&mut self) -> Option<u32> {
+        while let Some(block_index) = self.stack.pop() {
+            // If this block was pushed multiple times, we only need to update
+            // it once, so remove it from the need-updates set. In other words
+            // it was logically hoisted up to the top of the stack, while this
+            // entry was left behind, and we already popped the hoisted
+            // copy. See the above note about processing inner-most loops first.
+            if self.need_updates.remove(&block_index) {
+                return Some(block_index);
+            }
+        }
+        None
+    }
+}
+
+/// A simple liveness analysis.
+///
+/// This analysis is used to determine which needs-stack-map values are live
+/// across safepoint instructions.
+///
+/// This is a backwards analysis, from uses (which mark values live) to defs
+/// (which remove values from the live set) and from successor blocks to
+/// predecessor blocks.
+///
+/// We compute two live sets for each block:
+///
+/// 1. The live-in set, which is the set of values that are live when control
+///    enters the block.
+///
+/// 2. The live-out set, which is the set of values that are live when control
+///    exits the block.
+///
+/// A block's live-out set is the union of its successors' live-in sets. A
+/// block's live-in set is the set of values that are still live after the
+/// block's instructions have been processed.
+///
+/// ```text
+/// live_in(block) = union(live_out(s) for s in successors(block))
+/// live_out(block) = live_in(block) - defs(block) + uses(block)
+/// ```
+///
+/// Whenever we update a block's live-in set, we must reprocess all of its
+/// predecessors, because those predecessors' live-out sets depend on this
+/// block's live-in set. Processing continues until the live sets stop changing
+/// and we've reached a fixed-point. Each time we process a block, its live sets
+/// can only grow monotonically, and therefore we know that the computation will
+/// reach its fixed-point and terminate. This fixed-point is implemented with a
+/// classic worklist algorithm.
+///
+/// The worklist is seeded such that we initially process blocks in post-order,
+/// which ensures that, when we have a loop-free control-flow graph, we only
+/// process each block once. We pop a block off the worklist for
+/// processing. Whenever a block's live-in set is updated during processing, we
+/// push its predecessors onto the worklist so that their live-in sets can be
+/// updated. Once the worklist is empty, there are no more blocks needing
+/// updates, and we've reached the fixed-point.
+///
+/// Note: For simplicity, we do not flow liveness from block parameters back to
+/// branch arguments, and instead always consider branch arguments live.
+///
+/// Furthermore, we do not differentiate between uses of a needs-stack-map value
+/// that ultimately flow into a side-effecting operation versus uses that
+/// themselves are not live. This could be tightened up in the future, but we're
+/// starting with the easiest, simplest thing. It also means that we do not need
+/// `O(all values)` space, only `O(needs-stack-map values)`. Finally, none of
+/// our mid-end optimization passes have run at this point in time yet, so there
+/// probably isn't much, if any, dead code.
+///
+/// After we've computed the live-in and -out sets for each block, we pass once
+/// more over each block, processing its instructions again. This time, we
+/// record the precise set of needs-stack-map values that are live across each
+/// safepoint instruction inside the block, which is the final output of this
+/// analysis.
+pub(crate) struct LivenessAnalysis {
+    /// Reusable depth-first search state for traversing a function's blocks.
+    dfs: Dfs,
+
+    /// The cached post-order traversal of the function's blocks.
+    post_order: Vec<ir::Block>,
+
+    /// A secondary map from each block to its index in `post_order`.
+    block_to_index: SecondaryMap<ir::Block, u32>,
+
+    /// A mapping from each block's post-order index to the post-order indices
+    /// of its direct (non-transitive) predecessors.
+    predecessors: Vec<SmallVec<[u32; 4]>>,
+
+    /// A worklist of blocks to process. Used to determine which blocks need
+    /// updates cascaded to them and when we reach a fixed-point.
+    worklist: Worklist,
+
+    /// A map from a block's post-order index to its live-in set.
+    live_ins: Vec<LiveSet>,
+
+    /// A map from a block's post-order index to its live-out set.
+    live_outs: Vec<LiveSet>,
+
+    /// The set of each needs-stack-map value that is currently live while
+    /// processing a block.
+    currently_live: LiveSet,
+
+    /// A mapping from each safepoint instruction to the set of needs-stack-map
+    /// values that are live across it.
+    safepoints: HashMap<ir::Inst, SmallVec<[ir::Value; 4]>>,
+
+    /// The set of values that are live across *any* safepoint in the function,
+    /// i.e. the union of all the values in the `safepoints` map.
+    live_across_any_safepoint: EntitySet<ir::Value>,
+}
+
+impl Default for LivenessAnalysis {
+    fn default() -> Self {
+        Self {
+            dfs: Default::default(),
+            post_order: Default::default(),
+            block_to_index: SecondaryMap::with_default(u32::MAX),
+            predecessors: Default::default(),
+            worklist: Default::default(),
+            live_ins: Default::default(),
+            live_outs: Default::default(),
+            currently_live: Default::default(),
+            safepoints: Default::default(),
+            live_across_any_safepoint: Default::default(),
+        }
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum RecordSafepoints {
+    Yes,
+    No,
+}
+
+impl LivenessAnalysis {
+    /// Clear and reset all internal state such that this analysis is ready for
+    /// reuse with a new function.
+    pub fn clear(&mut self) {
+        let LivenessAnalysis {
+            dfs,
+            post_order,
+            block_to_index,
+            predecessors,
+            worklist,
+            live_ins,
+            live_outs,
+            currently_live,
+            safepoints,
+            live_across_any_safepoint,
+        } = self;
+        dfs.clear();
+        post_order.clear();
+        block_to_index.clear();
+        predecessors.clear();
+        worklist.clear();
+        live_ins.clear();
+        live_outs.clear();
+        currently_live.clear();
+        safepoints.clear();
+        live_across_any_safepoint.clear();
+    }
+
+    /// Given that we've initialized `self.post_order`, reserve capacity for the
+    /// various data structures we use during our analysis.
+    fn reserve_capacity(&mut self, func: &Function) {
+        let LivenessAnalysis {
+            dfs: _,
+            post_order,
+            block_to_index,
+            predecessors,
+            worklist,
+            live_ins,
+            live_outs,
+            currently_live: _,
+            safepoints: _,
+            live_across_any_safepoint: _,
+        } = self;
+
+        block_to_index.resize(func.dfg.num_blocks());
+
+        let capacity = post_order.len();
+        worklist.reserve(capacity);
+        predecessors.resize(capacity, Default::default());
+        live_ins.resize(capacity, Default::default());
+        live_outs.resize(capacity, Default::default());
+    }
+
+    fn initialize_block_to_index_map(&mut self) {
+        for (block_index, block) in self.post_order.iter().enumerate() {
+            self.block_to_index[*block] = u32::try_from(block_index).unwrap();
+        }
+    }
+
+    fn initialize_predecessors_map(&mut self, func: &Function) {
+        for (block_index, block) in self.post_order.iter().enumerate() {
+            let block_index = u32::try_from(block_index).unwrap();
+            for succ in func.block_successors(*block) {
+                let succ_index = self.block_to_index[succ];
+                debug_assert_ne!(succ_index, u32::MAX);
+                let succ_index = usize::try_from(succ_index).unwrap();
+                self.predecessors[succ_index].push(block_index);
+            }
+        }
+    }
+
+    /// Process a value's definition, removing it from the currently-live set.
+    fn process_def(&mut self, val: ir::Value) {
+        if self.currently_live.remove(&val) {
+            log::trace!("liveness:   defining {val:?}, removing it from the live set");
+        }
+    }
+
+    /// Record the live set of needs-stack-map values at the given safepoint.
+    fn record_safepoint(&mut self, func: &Function, inst: Inst) {
+        log::trace!(
+            "liveness:   found safepoint: {inst:?}: {}",
+            func.dfg.display_inst(inst)
+        );
+        log::trace!("liveness:     live set = {:?}", self.currently_live);
+
+        let mut live = self.currently_live.iter().copied().collect::<SmallVec<_>>();
+        // Keep order deterministic since we add stack map entries in this
+        // order.
+        live.sort();
+
+        self.live_across_any_safepoint.extend(live.iter().copied());
+        self.safepoints.insert(inst, live);
+    }
+
+    /// Process a use of a needs-stack-map value, inserting it into the
+    /// currently-live set.
+    fn process_use(&mut self, func: &Function, inst: Inst, val: Value) {
+        if self.currently_live.insert(val) {
+            log::trace!(
+                "liveness:   found use of {val:?}, marking it live: {inst:?}: {}",
+                func.dfg.display_inst(inst)
+            );
+        }
+    }
+
+    /// Process all the instructions in a block in reverse order.
+    fn process_block(
+        &mut self,
+        func: &mut Function,
+        stack_map_values: &EntitySet<ir::Value>,
+        block_index: usize,
+        record_safepoints: RecordSafepoints,
+    ) {
+        let block = self.post_order[block_index];
+        log::trace!("liveness: traversing {block:?}");
+
+        // Reset the currently-live set to this block's live-out set.
+        self.currently_live.clear();
+        self.currently_live
+            .extend(self.live_outs[block_index].iter().copied());
+
+        // Now process this block's instructions, incrementally building its
+        // live-in set inside the currently-live set.
+        let mut option_inst = func.layout.last_inst(block);
+        while let Some(inst) = option_inst {
+            // Process any needs-stack-map values defined by this instruction.
+            for val in func.dfg.inst_results(inst) {
+                self.process_def(*val);
+            }
+
+            // If this instruction is a safepoint and we've been asked to record
+            // safepoints, then do so.
+            let opcode = func.dfg.insts[inst].opcode();
+            if record_safepoints == RecordSafepoints::Yes && opcode.is_safepoint() {
+                self.record_safepoint(func, inst);
+            }
+
+            // Process any needs-stack-map values used by this instruction.
+            for val in func.dfg.inst_values(inst) {
+                let val = func.dfg.resolve_aliases(val);
+                if stack_map_values.contains(val) {
+                    self.process_use(func, inst, val);
+                }
+            }
+
+            option_inst = func.layout.prev_inst(inst);
+        }
+
+        // After we've processed this block's instructions, remove its
+        // parameters from the live set. This is part of step (1).
+        for val in func.dfg.block_params(block) {
+            self.process_def(*val);
+        }
+    }
+
+    /// Run the liveness analysis on the given function.
+    pub fn run(&mut self, func: &mut Function, stack_map_values: &EntitySet<ir::Value>) {
+        self.clear();
+        self.post_order.extend(self.dfs.post_order_iter(func));
+        self.reserve_capacity(func);
+        self.initialize_block_to_index_map();
+        self.initialize_predecessors_map(func);
+
+        // Initially enqueue all blocks for processing. We push them in reverse
+        // post-order (which yields them in post-order when popped) because if
+        // there are no back-edges in the control-flow graph, post-order will
+        // result in only a single pass over the blocks.
+        self.worklist
+            .extend((0..u32::try_from(self.post_order.len()).unwrap()).rev());
+
+        // Pump the worklist until we reach a fixed-point.
+        while let Some(block_index) = self.worklist.pop() {
+            let block_index = usize::try_from(block_index).unwrap();
+
+            // Because our live sets grow monotonically, we just need to see if
+            // the size changed to determine whether the whole set changed.
+            let initial_live_in_len = self.live_ins[block_index].len();
+
+            // The live-out set for a block is the union of the live-in sets of
+            // its successors.
+            for successor in func.block_successors(self.post_order[block_index]) {
+                let successor_index = self.block_to_index[successor];
+                debug_assert_ne!(successor_index, u32::MAX);
+                let successor_index = usize::try_from(successor_index).unwrap();
+                self.live_outs[block_index].extend(self.live_ins[successor_index].iter().copied());
+            }
+
+            // Process the block to compute its live-in set, but do not record
+            // safepoints yet, as we haven't yet processed loop back edges (see
+            // below).
+            self.process_block(func, stack_map_values, block_index, RecordSafepoints::No);
+
+            // The live-in set for a block is the set of values that are still
+            // live after the block's instructions have been processed.
+            self.live_ins[block_index].extend(self.currently_live.iter().copied());
+
+            // If the live-in set changed, then we need to revisit all this
+            // block's predecessors.
+            if self.live_ins[block_index].len() != initial_live_in_len {
+                self.worklist
+                    .extend(self.predecessors[block_index].iter().copied());
+            }
+        }
+
+        // Once we've reached a fixed-point, compute the actual live set for
+        // each safepoint instruction in each block, backwards from the block's
+        // live-out set.
+        for block_index in 0..self.post_order.len() {
+            self.process_block(func, stack_map_values, block_index, RecordSafepoints::Yes);
+
+            debug_assert_eq!(
+                self.currently_live, self.live_ins[block_index],
+                "when we recompute the live-in set for a block as part of \
+                 computing live sets at each safepoint, we should get the same \
+                 result we computed in the fixed-point"
+            );
+        }
+    }
+}
+
+/// A mapping from each needs-stack-map value to its associated stack slot.
+///
+/// Internally maintains free lists for stack slots that won't be used again, so
+/// that we can reuse them and minimize the number of stack slots we need to
+/// allocate.
+#[derive(Default)]
+struct StackSlots {
+    /// A mapping from each needs-stack-map value that is live across some
+    /// safepoint to the stack slot that it resides within. Note that if a
+    /// needs-stack-map value is never live across a safepoint, then we won't
+    /// ever add it to this map, it can remain in a virtual register for the
+    /// duration of its lifetime, and we won't replace all its uses with reloads
+    /// and all that stuff.
+    stack_slots: HashMap<ir::Value, ir::StackSlot>,
+
+    /// A map from slot size to free stack slots that are not being used
+    /// anymore. This allows us to reuse stack slots across multiple values
+    /// helps cut down on the ultimate size of our stack frames.
+    free_stack_slots: SlotSizeMap<SmallVec<[ir::StackSlot; 4]>>,
+}
+
+impl StackSlots {
+    fn clear(&mut self) {
+        let StackSlots {
+            stack_slots,
+            free_stack_slots,
+        } = self;
+        stack_slots.clear();
+        free_stack_slots.clear();
+    }
+
+    fn get(&self, val: ir::Value) -> Option<ir::StackSlot> {
+        self.stack_slots.get(&val).copied()
+    }
+
+    fn get_or_create_stack_slot(&mut self, func: &mut Function, val: ir::Value) -> ir::StackSlot {
+        *self.stack_slots.entry(val).or_insert_with(|| {
+            log::trace!("rewriting:     {val:?} needs a stack slot");
+            let ty = func.dfg.value_type(val);
+            let size = ty.bytes();
+            match self.free_stack_slots[SlotSize::unwrap_new(size)].pop() {
+                Some(slot) => {
+                    log::trace!("rewriting:       reusing free stack slot {slot:?} for {val:?}");
+                    slot
+                }
+                None => {
+                    debug_assert!(size.is_power_of_two());
+                    let log2_size = size.ilog2();
+                    let slot = func.create_sized_stack_slot(ir::StackSlotData::new(
+                        ir::StackSlotKind::ExplicitSlot,
+                        size,
+                        log2_size.try_into().unwrap(),
+                    ));
+                    log::trace!("rewriting:       created new stack slot {slot:?} for {val:?}");
+                    slot
+                }
+            }
+        })
+    }
+
+    fn free_stack_slot(&mut self, size: SlotSize, slot: ir::StackSlot) {
+        log::trace!("rewriting:     returning {slot:?} to the free list");
+        self.free_stack_slots[size].push(slot);
+    }
+}
+
+/// A pass to rewrite a function's instructions to spill and reload values that
+/// are live across safepoints.
+///
+/// A single `SafepointSpiller` instance may be reused to rewrite many
+/// functions, amortizing the cost of its internal allocations and avoiding
+/// repeated `malloc` and `free` calls.
+#[derive(Default)]
+pub(super) struct SafepointSpiller {
+    liveness: LivenessAnalysis,
+    stack_slots: StackSlots,
+}
+
+impl SafepointSpiller {
+    /// Clear and reset all internal state such that this pass is ready to run
+    /// on a new function.
+    pub fn clear(&mut self) {
+        let SafepointSpiller {
+            liveness,
+            stack_slots,
+        } = self;
+        liveness.clear();
+        stack_slots.clear();
+    }
+
+    /// Identify needs-stack-map values that are live across safepoints, and
+    /// rewrite the function's instructions to spill and reload them as
+    /// necessary.
+    pub fn run(&mut self, func: &mut Function, stack_map_values: &EntitySet<ir::Value>) {
+        log::trace!(
+            "values needing inclusion in stack maps: {:?}",
+            stack_map_values
+        );
+        log::trace!(
+            "before inserting safepoint spills and reloads:\n{}",
+            func.display()
+        );
+
+        self.clear();
+        self.liveness.run(func, stack_map_values);
+        self.rewrite(func);
+
+        log::trace!(
+            "after inserting safepoint spills and reloads:\n{}",
+            func.display()
+        );
+    }
+
+    /// Spill this value to a stack slot if it has been declared that it must be
+    /// included in stack maps and is live across any safepoints.
+    ///
+    /// The given cursor must point just after this value's definition.
+    fn rewrite_def(&mut self, pos: &mut FuncCursor<'_>, val: ir::Value) {
+        if let Some(slot) = self.stack_slots.get(val) {
+            let i = pos.ins().stack_store(val, slot, 0);
+            log::trace!(
+                "rewriting:   spilling {val:?} to {slot:?}: {}",
+                pos.func.dfg.display_inst(i)
+            );
+
+            // Now that we've defined this value, there cannot be any more uses
+            // of it, and therefore this stack slot is now available for reuse.
+            let ty = pos.func.dfg.value_type(val);
+            let size = SlotSize::try_from(ty).unwrap();
+            self.stack_slots.free_stack_slot(size, slot);
+        }
+    }
+
+    /// Add a stack map entry for each needs-stack-map value that is live across
+    /// the given safepoint instruction.
+    ///
+    /// This will additionally assign stack slots to needs-stack-map values, if
+    /// no such assignment has already been made.
+    fn rewrite_safepoint(&mut self, func: &mut Function, inst: ir::Inst) {
+        log::trace!(
+            "rewriting:   found safepoint: {inst:?}: {}",
+            func.dfg.display_inst(inst)
+        );
+
+        let live = self
+            .liveness
+            .safepoints
+            .get(&inst)
+            .expect("should only call `rewrite_safepoint` on safepoint instructions");
+
+        for val in live {
+            // Get or create the stack slot for this live needs-stack-map value.
+            let slot = self.stack_slots.get_or_create_stack_slot(func, *val);
+
+            log::trace!(
+                "rewriting:     adding stack map entry for {val:?} at {slot:?}: {}",
+                func.dfg.display_inst(inst)
+            );
+            let ty = func.dfg.value_type(*val);
+            func.dfg.append_user_stack_map_entry(
+                inst,
+                ir::UserStackMapEntry {
+                    ty,
+                    slot,
+                    offset: 0,
+                },
+            );
+        }
+    }
+
+    /// If `val` is a needs-stack-map value that has been spilled to a stack
+    /// slot, then rewrite `val` to be a load from its associated stack
+    /// slot.
+    ///
+    /// Returns `true` if `val` was rewritten, `false` if not.
+    ///
+    /// The given cursor must point just before the use of the value that we are
+    /// replacing.
+    fn rewrite_use(&mut self, pos: &mut FuncCursor<'_>, val: &mut ir::Value) -> bool {
+        if !self.liveness.live_across_any_safepoint.contains(*val) {
+            return false;
+        }
+
+        let old_val = *val;
+        log::trace!("rewriting:     found use of {old_val:?}");
+
+        let ty = pos.func.dfg.value_type(*val);
+        let slot = self.stack_slots.get_or_create_stack_slot(pos.func, *val);
+        *val = pos.ins().stack_load(ty, slot, 0);
+
+        log::trace!(
+            "rewriting:     reloading {old_val:?}: {}",
+            pos.func
+                .dfg
+                .display_inst(pos.func.dfg.value_def(*val).unwrap_inst())
+        );
+
+        true
+    }
+
+    /// Rewrite the function's instructions to spill and reload values that are
+    /// live across safepoints:
+    ///
+    /// 1. Definitions of needs-stack-map values that are live across some
+    ///    safepoint need to be spilled to their assigned stack slot.
+    ///
+    /// 2. Instructions that are themselves safepoints must have stack map
+    ///    entries added for the needs-stack-map values that are live across
+    ///    them.
+    ///
+    /// 3. Uses of needs-stack-map values that have been spilled to a stack slot
+    ///    need to be replaced with reloads from the slot.
+    fn rewrite(&mut self, func: &mut Function) {
+        // Shared temporary storage for operand and result lists.
+        let mut vals: SmallVec<[_; 8]> = Default::default();
+
+        // Rewrite the function's instructions in post-order. This ensures that
+        // we rewrite uses before defs, and therefore once we see a def we know
+        // its stack slot will never be used for that value again. Therefore,
+        // the slot can be reappropriated for a new needs-stack-map value with a
+        // non-overlapping live range. See `rewrite_def` and `free_stack_slots`
+        // for more details.
+        for block_index in 0..self.liveness.post_order.len() {
+            let block = self.liveness.post_order[block_index];
+            log::trace!("rewriting: processing {block:?}");
+
+            let mut option_inst = func.layout.last_inst(block);
+            while let Some(inst) = option_inst {
+                // If this instruction defines a needs-stack-map value that is
+                // live across a safepoint, then spill the value to its stack
+                // slot.
+                let mut pos = FuncCursor::new(func).after_inst(inst);
+                vals.extend_from_slice(pos.func.dfg.inst_results(inst));
+                for val in vals.drain(..) {
+                    self.rewrite_def(&mut pos, val);
+                }
+
+                // If this instruction is a safepoint, then we must add stack
+                // map entries for the needs-stack-map values that are live
+                // across it.
+                if self.liveness.safepoints.contains_key(&inst) {
+                    self.rewrite_safepoint(func, inst);
+                }
+
+                // Replace all uses of needs-stack-map values with loads from
+                // the value's associated stack slot.
+                let mut pos = FuncCursor::new(func).at_inst(inst);
+                vals.extend(pos.func.dfg.inst_values(inst));
+                let mut replaced_any = false;
+                for val in &mut vals {
+                    replaced_any |= self.rewrite_use(&mut pos, val);
+                }
+                if replaced_any {
+                    pos.func.dfg.overwrite_inst_values(inst, vals.drain(..));
+                    log::trace!(
+                        "rewriting:     updated {inst:?} operands with reloaded values: {}",
+                        pos.func.dfg.display_inst(inst)
+                    );
+                } else {
+                    vals.clear();
+                }
+
+                option_inst = func.layout.prev_inst(inst);
+            }
+
+            // Spill needs-stack-map values defined by block parameters to their
+            // associated stack slots.
+            let mut pos = FuncCursor::new(func).at_position(CursorPosition::Before(block));
+            pos.next_inst(); // Advance to the first instruction in the block.
+            vals.clear();
+            vals.extend_from_slice(pos.func.dfg.block_params(block));
+            for val in vals.drain(..) {
+                self.rewrite_def(&mut pos, val);
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use alloc::string::ToString;
+    use cranelift_codegen::isa::CallConv;
+
+    #[test]
+    fn needs_stack_map_and_loop() {
+        let mut sig = Signature::new(CallConv::SystemV);
+        sig.params.push(AbiParam::new(ir::types::I32));
+        sig.params.push(AbiParam::new(ir::types::I32));
+
+        let mut fn_ctx = FunctionBuilderContext::new();
+        let mut func = Function::with_name_signature(ir::UserFuncName::testcase("sample"), sig);
+        let mut builder = FunctionBuilder::new(&mut func, &mut fn_ctx);
+
+        let name = builder
+            .func
+            .declare_imported_user_function(ir::UserExternalName {
+                namespace: 0,
+                index: 0,
+            });
+        let mut sig = Signature::new(CallConv::SystemV);
+        sig.params.push(AbiParam::new(ir::types::I32));
+        let signature = builder.func.import_signature(sig);
+        let func_ref = builder.import_function(ir::ExtFuncData {
+            name: ir::ExternalName::user(name),
+            signature,
+            colocated: true,
+        });
+
+        // Here the value `v1` is technically not live but our single-pass liveness
+        // analysis treats every branch argument to a block as live to avoid
+        // needing to do a fixed-point loop.
+        //
+        //     block0(v0, v1):
+        //       call $foo(v0)
+        //       jump block0(v0, v1)
+        let block0 = builder.create_block();
+        builder.append_block_params_for_function_params(block0);
+        let a = builder.func.dfg.block_params(block0)[0];
+        let b = builder.func.dfg.block_params(block0)[1];
+        builder.declare_value_needs_stack_map(a);
+        builder.declare_value_needs_stack_map(b);
+        builder.switch_to_block(block0);
+        builder.ins().call(func_ref, &[a]);
+        builder.ins().jump(block0, &[a, b]);
+        builder.seal_all_blocks();
+        builder.finalize();
+
+        assert_eq_output!(
+            func.display().to_string(),
+            r#"
+function %sample(i32, i32) system_v {
+    ss0 = explicit_slot 4, align = 4
+    ss1 = explicit_slot 4, align = 4
+    sig0 = (i32) system_v
+    fn0 = colocated u0:0 sig0
+
+block0(v0: i32, v1: i32):
+    stack_store v0, ss0
+    stack_store v1, ss1
+    v4 = stack_load.i32 ss0
+    call fn0(v4), stack_map=[i32 @ ss0+0, i32 @ ss1+0]
+    v2 = stack_load.i32 ss0
+    v3 = stack_load.i32 ss1
+    jump block0(v2, v3)
+}
+            "#
+        );
+    }
+
+    #[test]
+    fn needs_stack_map_simple() {
+        let _ = env_logger::try_init();
+
+        let sig = Signature::new(CallConv::SystemV);
+
+        let mut fn_ctx = FunctionBuilderContext::new();
+        let mut func = Function::with_name_signature(ir::UserFuncName::testcase("sample"), sig);
+        let mut builder = FunctionBuilder::new(&mut func, &mut fn_ctx);
+
+        let name = builder
+            .func
+            .declare_imported_user_function(ir::UserExternalName {
+                namespace: 0,
+                index: 0,
+            });
+        let mut sig = Signature::new(CallConv::SystemV);
+        sig.params.push(AbiParam::new(ir::types::I32));
+        let signature = builder.func.import_signature(sig);
+        let func_ref = builder.import_function(ir::ExtFuncData {
+            name: ir::ExternalName::user(name),
+            signature,
+            colocated: true,
+        });
+
+        // At each `call` we are losing one more value as no longer live, so
+        // each stack map should be one smaller than the last. `v3` is never
+        // live across a safepoint, so should never appear in a stack map. Note
+        // that a value that is an argument to the call, but is not live after
+        // the call, should not appear in the stack map. This is why `v0`
+        // appears in the first call's stack map, but not the second call's
+        // stack map.
+        //
+        //     block0:
+        //       v0 = needs stack map
+        //       v1 = needs stack map
+        //       v2 = needs stack map
+        //       v3 = needs stack map
+        //       call $foo(v3)
+        //       call $foo(v0)
+        //       call $foo(v1)
+        //       call $foo(v2)
+        //       return
+        let block0 = builder.create_block();
+        builder.append_block_params_for_function_params(block0);
+        builder.switch_to_block(block0);
+        let v0 = builder.ins().iconst(ir::types::I32, 0);
+        builder.declare_value_needs_stack_map(v0);
+        let v1 = builder.ins().iconst(ir::types::I32, 1);
+        builder.declare_value_needs_stack_map(v1);
+        let v2 = builder.ins().iconst(ir::types::I32, 2);
+        builder.declare_value_needs_stack_map(v2);
+        let v3 = builder.ins().iconst(ir::types::I32, 3);
+        builder.declare_value_needs_stack_map(v3);
+        builder.ins().call(func_ref, &[v3]);
+        builder.ins().call(func_ref, &[v0]);
+        builder.ins().call(func_ref, &[v1]);
+        builder.ins().call(func_ref, &[v2]);
+        builder.ins().return_(&[]);
+        builder.seal_all_blocks();
+        builder.finalize();
+
+        assert_eq_output!(
+            func.display().to_string(),
+            r#"
+function %sample() system_v {
+    ss0 = explicit_slot 4, align = 4
+    ss1 = explicit_slot 4, align = 4
+    ss2 = explicit_slot 4, align = 4
+    sig0 = (i32) system_v
+    fn0 = colocated u0:0 sig0
+
+block0:
+    v0 = iconst.i32 0
+    stack_store v0, ss2  ; v0 = 0
+    v1 = iconst.i32 1
+    stack_store v1, ss1  ; v1 = 1
+    v2 = iconst.i32 2
+    stack_store v2, ss0  ; v2 = 2
+    v3 = iconst.i32 3
+    call fn0(v3), stack_map=[i32 @ ss2+0, i32 @ ss1+0, i32 @ ss0+0]  ; v3 = 3
+    v6 = stack_load.i32 ss2
+    call fn0(v6), stack_map=[i32 @ ss1+0, i32 @ ss0+0]
+    v5 = stack_load.i32 ss1
+    call fn0(v5), stack_map=[i32 @ ss0+0]
+    v4 = stack_load.i32 ss0
+    call fn0(v4)
+    return
+}
+            "#
+        );
+    }
+
+    #[test]
+    fn needs_stack_map_and_post_order_early_return() {
+        let mut sig = Signature::new(CallConv::SystemV);
+        sig.params.push(AbiParam::new(ir::types::I32));
+
+        let mut fn_ctx = FunctionBuilderContext::new();
+        let mut func = Function::with_name_signature(ir::UserFuncName::testcase("sample"), sig);
+        let mut builder = FunctionBuilder::new(&mut func, &mut fn_ctx);
+
+        let name = builder
+            .func
+            .declare_imported_user_function(ir::UserExternalName {
+                namespace: 0,
+                index: 0,
+            });
+        let signature = builder
+            .func
+            .import_signature(Signature::new(CallConv::SystemV));
+        let func_ref = builder.import_function(ir::ExtFuncData {
+            name: ir::ExternalName::user(name),
+            signature,
+            colocated: true,
+        });
+
+        // Here we rely on the post-order to make sure that we never visit block
+        // 4 and add `v1` to our live set, then visit block 2 and add `v1` to
+        // its stack map even though `v1` is not in scope. Thanksfully, that
+        // sequence is impossible because it would be an invalid post-order
+        // traversal. The only valid post-order traversals are [3, 1, 2, 0] and
+        // [2, 3, 1, 0].
+        //
+        //     block0(v0):
+        //       brif v0, block1, block2
+        //
+        //     block1:
+        //       <stuff>
+        //       v1 = get some gc ref
+        //       jump block3
+        //
+        //     block2:
+        //       call $needs_safepoint_accidentally
+        //       return
+        //
+        //     block3:
+        //       stuff keeping v1 live
+        //       return
+        let block0 = builder.create_block();
+        let block1 = builder.create_block();
+        let block2 = builder.create_block();
+        let block3 = builder.create_block();
+        builder.append_block_params_for_function_params(block0);
+
+        builder.switch_to_block(block0);
+        let v0 = builder.func.dfg.block_params(block0)[0];
+        builder.ins().brif(v0, block1, &[], block2, &[]);
+
+        builder.switch_to_block(block1);
+        let v1 = builder.ins().iconst(ir::types::I64, 0x12345678);
+        builder.declare_value_needs_stack_map(v1);
+        builder.ins().jump(block3, &[]);
+
+        builder.switch_to_block(block2);
+        builder.ins().call(func_ref, &[]);
+        builder.ins().return_(&[]);
+
+        builder.switch_to_block(block3);
+        // NB: Our simplistic liveness analysis conservatively treats any use of
+        // a value as keeping it live, regardless if the use has side effects or
+        // is otherwise itself live, so an `iadd_imm` suffices to keep `v1` live
+        // here.
+        builder.ins().iadd_imm(v1, 0);
+        builder.ins().return_(&[]);
+
+        builder.seal_all_blocks();
+        builder.finalize();
+
+        assert_eq_output!(
+            func.display().to_string(),
+            r#"
+function %sample(i32) system_v {
+    sig0 = () system_v
+    fn0 = colocated u0:0 sig0
+
+block0(v0: i32):
+    brif v0, block1, block2
+
+block1:
+    v1 = iconst.i64 0x1234_5678
+    jump block3
+
+block2:
+    call fn0()
+    return
+
+block3:
+    v2 = iadd_imm.i64 v1, 0  ; v1 = 0x1234_5678
+    return
+}
+            "#
+        );
+    }
+
+    #[test]
+    fn needs_stack_map_conditional_branches_and_liveness() {
+        let mut sig = Signature::new(CallConv::SystemV);
+        sig.params.push(AbiParam::new(ir::types::I32));
+
+        let mut fn_ctx = FunctionBuilderContext::new();
+        let mut func = Function::with_name_signature(ir::UserFuncName::testcase("sample"), sig);
+        let mut builder = FunctionBuilder::new(&mut func, &mut fn_ctx);
+
+        let name = builder
+            .func
+            .declare_imported_user_function(ir::UserExternalName {
+                namespace: 0,
+                index: 0,
+            });
+        let signature = builder
+            .func
+            .import_signature(Signature::new(CallConv::SystemV));
+        let func_ref = builder.import_function(ir::ExtFuncData {
+            name: ir::ExternalName::user(name),
+            signature,
+            colocated: true,
+        });
+
+        // We should not have a stack map entry for `v1` in block 1 because it
+        // is not live across the call.
+        //
+        //     block0(v0):
+        //       v1 = needs stack map
+        //       brif v0, block1, block2
+        //
+        //     block1:
+        //       call $foo()
+        //       return
+        //
+        //     block2:
+        //       keep v1 alive
+        //       return
+        let block0 = builder.create_block();
+        let block1 = builder.create_block();
+        let block2 = builder.create_block();
+        builder.append_block_params_for_function_params(block0);
+
+        builder.switch_to_block(block0);
+        let v0 = builder.func.dfg.block_params(block0)[0];
+        let v1 = builder.ins().iconst(ir::types::I64, 0x12345678);
+        builder.declare_value_needs_stack_map(v1);
+        builder.ins().brif(v0, block1, &[], block2, &[]);
+
+        builder.switch_to_block(block1);
+        builder.ins().call(func_ref, &[]);
+        builder.ins().return_(&[]);
+
+        builder.switch_to_block(block2);
+        // NB: Our simplistic liveness analysis conservatively treats any use of
+        // a value as keeping it live, regardless if the use has side effects or
+        // is otherwise itself live, so an `iadd_imm` suffices to keep `v1` live
+        // here.
+        builder.ins().iadd_imm(v1, 0);
+        builder.ins().return_(&[]);
+
+        builder.seal_all_blocks();
+        builder.finalize();
+
+        assert_eq_output!(
+            func.display().to_string(),
+            r#"
+function %sample(i32) system_v {
+    sig0 = () system_v
+    fn0 = colocated u0:0 sig0
+
+block0(v0: i32):
+    v1 = iconst.i64 0x1234_5678
+    brif v0, block1, block2
+
+block1:
+    call fn0()
+    return
+
+block2:
+    v2 = iadd_imm.i64 v1, 0  ; v1 = 0x1234_5678
+    return
+}
+            "#
+        );
+
+        // Now do the same test but with block 1 and 2 swapped so that we
+        // exercise what we are trying to exercise, regardless of which
+        // post-order traversal we happen to take.
+        func.clear();
+        fn_ctx.clear();
+
+        let mut sig = Signature::new(CallConv::SystemV);
+        sig.params.push(AbiParam::new(ir::types::I32));
+
+        func.signature = sig;
+        let mut builder = FunctionBuilder::new(&mut func, &mut fn_ctx);
+
+        let name = builder
+            .func
+            .declare_imported_user_function(ir::UserExternalName {
+                namespace: 0,
+                index: 0,
+            });
+        let signature = builder
+            .func
+            .import_signature(Signature::new(CallConv::SystemV));
+        let func_ref = builder.import_function(ir::ExtFuncData {
+            name: ir::ExternalName::user(name),
+            signature,
+            colocated: true,
+        });
+
+        let block0 = builder.create_block();
+        let block1 = builder.create_block();
+        let block2 = builder.create_block();
+        builder.append_block_params_for_function_params(block0);
+
+        builder.switch_to_block(block0);
+        let v0 = builder.func.dfg.block_params(block0)[0];
+        let v1 = builder.ins().iconst(ir::types::I64, 0x12345678);
+        builder.declare_value_needs_stack_map(v1);
+        builder.ins().brif(v0, block1, &[], block2, &[]);
+
+        builder.switch_to_block(block1);
+        builder.ins().iadd_imm(v1, 0);
+        builder.ins().return_(&[]);
+
+        builder.switch_to_block(block2);
+        builder.ins().call(func_ref, &[]);
+        builder.ins().return_(&[]);
+
+        builder.seal_all_blocks();
+        builder.finalize();
+
+        assert_eq_output!(
+            func.display().to_string(),
+            r#"
+function u0:0(i32) system_v {
+    sig0 = () system_v
+    fn0 = colocated u0:0 sig0
+
+block0(v0: i32):
+    v1 = iconst.i64 0x1234_5678
+    brif v0, block1, block2
+
+block1:
+    v2 = iadd_imm.i64 v1, 0  ; v1 = 0x1234_5678
+    return
+
+block2:
+    call fn0()
+    return
+}
+            "#
+        );
+    }
+
+    #[test]
+    fn needs_stack_map_and_tail_calls() {
+        let mut sig = Signature::new(CallConv::SystemV);
+        sig.params.push(AbiParam::new(ir::types::I32));
+
+        let mut fn_ctx = FunctionBuilderContext::new();
+        let mut func = Function::with_name_signature(ir::UserFuncName::testcase("sample"), sig);
+        let mut builder = FunctionBuilder::new(&mut func, &mut fn_ctx);
+
+        let name = builder
+            .func
+            .declare_imported_user_function(ir::UserExternalName {
+                namespace: 0,
+                index: 0,
+            });
+        let signature = builder
+            .func
+            .import_signature(Signature::new(CallConv::SystemV));
+        let func_ref = builder.import_function(ir::ExtFuncData {
+            name: ir::ExternalName::user(name),
+            signature,
+            colocated: true,
+        });
+
+        // Depending on which post-order traversal we take, we might consider
+        // `v1` live inside `block1`. But nothing is live after a tail call so
+        // we shouldn't spill `v1` either way here.
+        //
+        //     block0(v0):
+        //       v1 = needs stack map
+        //       brif v0, block1, block2
+        //
+        //     block1:
+        //       return_call $foo()
+        //
+        //     block2:
+        //       keep v1 alive
+        //       return
+        let block0 = builder.create_block();
+        let block1 = builder.create_block();
+        let block2 = builder.create_block();
+        builder.append_block_params_for_function_params(block0);
+
+        builder.switch_to_block(block0);
+        let v0 = builder.func.dfg.block_params(block0)[0];
+        let v1 = builder.ins().iconst(ir::types::I64, 0x12345678);
+        builder.declare_value_needs_stack_map(v1);
+        builder.ins().brif(v0, block1, &[], block2, &[]);
+
+        builder.switch_to_block(block1);
+        builder.ins().return_call(func_ref, &[]);
+
+        builder.switch_to_block(block2);
+        // NB: Our simplistic liveness analysis conservatively treats any use of
+        // a value as keeping it live, regardless if the use has side effects or
+        // is otherwise itself live, so an `iadd_imm` suffices to keep `v1` live
+        // here.
+        builder.ins().iadd_imm(v1, 0);
+        builder.ins().return_(&[]);
+
+        builder.seal_all_blocks();
+        builder.finalize();
+
+        assert_eq_output!(
+            func.display().to_string(),
+            r#"
+function %sample(i32) system_v {
+    sig0 = () system_v
+    fn0 = colocated u0:0 sig0
+
+block0(v0: i32):
+    v1 = iconst.i64 0x1234_5678
+    brif v0, block1, block2
+
+block1:
+    return_call fn0()
+
+block2:
+    v2 = iadd_imm.i64 v1, 0  ; v1 = 0x1234_5678
+    return
+}
+            "#
+        );
+
+        // Do the same test but with block 1 and 2 swapped so that we exercise
+        // what we are trying to exercise, regardless of which post-order
+        // traversal we happen to take.
+        func.clear();
+        fn_ctx.clear();
+
+        let mut sig = Signature::new(CallConv::SystemV);
+        sig.params.push(AbiParam::new(ir::types::I32));
+        func.signature = sig;
+
+        let mut builder = FunctionBuilder::new(&mut func, &mut fn_ctx);
+
+        let name = builder
+            .func
+            .declare_imported_user_function(ir::UserExternalName {
+                namespace: 0,
+                index: 0,
+            });
+        let signature = builder
+            .func
+            .import_signature(Signature::new(CallConv::SystemV));
+        let func_ref = builder.import_function(ir::ExtFuncData {
+            name: ir::ExternalName::user(name),
+            signature,
+            colocated: true,
+        });
+
+        let block0 = builder.create_block();
+        let block1 = builder.create_block();
+        let block2 = builder.create_block();
+        builder.append_block_params_for_function_params(block0);
+
+        builder.switch_to_block(block0);
+        let v0 = builder.func.dfg.block_params(block0)[0];
+        let v1 = builder.ins().iconst(ir::types::I64, 0x12345678);
+        builder.declare_value_needs_stack_map(v1);
+        builder.ins().brif(v0, block1, &[], block2, &[]);
+
+        builder.switch_to_block(block1);
+        builder.ins().iadd_imm(v1, 0);
+        builder.ins().return_(&[]);
+
+        builder.switch_to_block(block2);
+        builder.ins().return_call(func_ref, &[]);
+
+        builder.seal_all_blocks();
+        builder.finalize();
+
+        assert_eq_output!(
+            func.display().to_string(),
+            r#"
+function u0:0(i32) system_v {
+    sig0 = () system_v
+    fn0 = colocated u0:0 sig0
+
+block0(v0: i32):
+    v1 = iconst.i64 0x1234_5678
+    brif v0, block1, block2
+
+block1:
+    v2 = iadd_imm.i64 v1, 0  ; v1 = 0x1234_5678
+    return
+
+block2:
+    return_call fn0()
+}
+            "#
+        );
+    }
+
+    #[test]
+    fn needs_stack_map_and_cfg_diamond() {
+        let mut sig = Signature::new(CallConv::SystemV);
+        sig.params.push(AbiParam::new(ir::types::I32));
+
+        let mut fn_ctx = FunctionBuilderContext::new();
+        let mut func = Function::with_name_signature(ir::UserFuncName::testcase("sample"), sig);
+        let mut builder = FunctionBuilder::new(&mut func, &mut fn_ctx);
+
+        let name = builder
+            .func
+            .declare_imported_user_function(ir::UserExternalName {
+                namespace: 0,
+                index: 0,
+            });
+        let signature = builder
+            .func
+            .import_signature(Signature::new(CallConv::SystemV));
+        let func_ref = builder.import_function(ir::ExtFuncData {
+            name: ir::ExternalName::user(name),
+            signature,
+            colocated: true,
+        });
+
+        // Create an if/else CFG diamond that and check that various things get
+        // spilled as needed.
+        //
+        //     block0(v0):
+        //       brif v0, block1, block2
+        //
+        //     block1:
+        //       v1 = needs stack map
+        //       v2 = needs stack map
+        //       call $foo()
+        //       jump block3(v1, v2)
+        //
+        //     block2:
+        //       v3 = needs stack map
+        //       v4 = needs stack map
+        //       call $foo()
+        //       jump block3(v3, v3)  ;; Note: v4 is not live
+        //
+        //     block3(v5, v6):
+        //       call $foo()
+        //       keep v5 alive, but not v6
+        let block0 = builder.create_block();
+        let block1 = builder.create_block();
+        let block2 = builder.create_block();
+        let block3 = builder.create_block();
+        builder.append_block_params_for_function_params(block0);
+
+        builder.switch_to_block(block0);
+        let v0 = builder.func.dfg.block_params(block0)[0];
+        builder.ins().brif(v0, block1, &[], block2, &[]);
+
+        builder.switch_to_block(block1);
+        let v1 = builder.ins().iconst(ir::types::I64, 1);
+        builder.declare_value_needs_stack_map(v1);
+        let v2 = builder.ins().iconst(ir::types::I64, 2);
+        builder.declare_value_needs_stack_map(v2);
+        builder.ins().call(func_ref, &[]);
+        builder.ins().jump(block3, &[v1, v2]);
+
+        builder.switch_to_block(block2);
+        let v3 = builder.ins().iconst(ir::types::I64, 3);
+        builder.declare_value_needs_stack_map(v3);
+        let v4 = builder.ins().iconst(ir::types::I64, 4);
+        builder.declare_value_needs_stack_map(v4);
+        builder.ins().call(func_ref, &[]);
+        builder.ins().jump(block3, &[v3, v3]);
+
+        builder.switch_to_block(block3);
+        builder.append_block_param(block3, ir::types::I64);
+        builder.append_block_param(block3, ir::types::I64);
+        builder.ins().call(func_ref, &[]);
+        // NB: Our simplistic liveness analysis conservatively treats any use of
+        // a value as keeping it live, regardless if the use has side effects or
+        // is otherwise itself live, so an `iadd_imm` suffices to keep `v1` live
+        // here.
+        builder.ins().iadd_imm(v1, 0);
+        builder.ins().return_(&[]);
+
+        builder.seal_all_blocks();
+        builder.finalize();
+
+        assert_eq_output!(
+            func.display().to_string(),
+            r#"
+function %sample(i32) system_v {
+    ss0 = explicit_slot 8, align = 8
+    ss1 = explicit_slot 8, align = 8
+    sig0 = () system_v
+    fn0 = colocated u0:0 sig0
+
+block0(v0: i32):
+    brif v0, block1, block2
+
+block1:
+    v1 = iconst.i64 1
+    stack_store v1, ss0  ; v1 = 1
+    v2 = iconst.i64 2
+    stack_store v2, ss1  ; v2 = 2
+    call fn0(), stack_map=[i64 @ ss0+0, i64 @ ss1+0]
+    v9 = stack_load.i64 ss0
+    v10 = stack_load.i64 ss1
+    jump block3(v9, v10)
+
+block2:
+    v3 = iconst.i64 3
+    stack_store v3, ss0  ; v3 = 3
+    v4 = iconst.i64 4
+    call fn0(), stack_map=[i64 @ ss0+0, i64 @ ss0+0]
+    v11 = stack_load.i64 ss0
+    v12 = stack_load.i64 ss0
+    jump block3(v11, v12)
+
+block3(v5: i64, v6: i64):
+    call fn0(), stack_map=[i64 @ ss0+0]
+    v8 = stack_load.i64 ss0
+    v7 = iadd_imm v8, 0
+    return
+}
+            "#
+        );
+    }
+
+    #[test]
+    fn needs_stack_map_and_heterogeneous_types() {
+        let _ = env_logger::try_init();
+
+        let mut sig = Signature::new(CallConv::SystemV);
+        for ty in [
+            ir::types::I8,
+            ir::types::I16,
+            ir::types::I32,
+            ir::types::I64,
+            ir::types::I128,
+            ir::types::F32,
+            ir::types::F64,
+            ir::types::I8X16,
+            ir::types::I16X8,
+        ] {
+            sig.params.push(AbiParam::new(ty));
+            sig.returns.push(AbiParam::new(ty));
+        }
+
+        let mut fn_ctx = FunctionBuilderContext::new();
+        let mut func = Function::with_name_signature(ir::UserFuncName::testcase("sample"), sig);
+        let mut builder = FunctionBuilder::new(&mut func, &mut fn_ctx);
+
+        let name = builder
+            .func
+            .declare_imported_user_function(ir::UserExternalName {
+                namespace: 0,
+                index: 0,
+            });
+        let signature = builder
+            .func
+            .import_signature(Signature::new(CallConv::SystemV));
+        let func_ref = builder.import_function(ir::ExtFuncData {
+            name: ir::ExternalName::user(name),
+            signature,
+            colocated: true,
+        });
+
+        // Test that we support stack maps of heterogeneous types and properly
+        // coalesce types into stack slots based on their size.
+        //
+        //     block0(v0, v1, v2, v3, v4, v5, v6, v7, v8):
+        //       call $foo()
+        //       return v0, v1, v2, v3, v4, v5, v6, v7, v8
+        let block0 = builder.create_block();
+        builder.append_block_params_for_function_params(block0);
+
+        builder.switch_to_block(block0);
+        let params = builder.func.dfg.block_params(block0).to_vec();
+        for val in &params {
+            builder.declare_value_needs_stack_map(*val);
+        }
+        builder.ins().call(func_ref, &[]);
+        builder.ins().return_(&params);
+
+        builder.seal_all_blocks();
+        builder.finalize();
+
+        assert_eq_output!(
+            func.display().to_string(),
+            r#"
+function %sample(i8, i16, i32, i64, i128, f32, f64, i8x16, i16x8) -> i8, i16, i32, i64, i128, f32, f64, i8x16, i16x8 system_v {
+    ss0 = explicit_slot 1
+    ss1 = explicit_slot 2, align = 2
+    ss2 = explicit_slot 4, align = 4
+    ss3 = explicit_slot 8, align = 8
+    ss4 = explicit_slot 16, align = 16
+    ss5 = explicit_slot 4, align = 4
+    ss6 = explicit_slot 8, align = 8
+    ss7 = explicit_slot 16, align = 16
+    ss8 = explicit_slot 16, align = 16
+    sig0 = () system_v
+    fn0 = colocated u0:0 sig0
+
+block0(v0: i8, v1: i16, v2: i32, v3: i64, v4: i128, v5: f32, v6: f64, v7: i8x16, v8: i16x8):
+    stack_store v0, ss0
+    stack_store v1, ss1
+    stack_store v2, ss2
+    stack_store v3, ss3
+    stack_store v4, ss4
+    stack_store v5, ss5
+    stack_store v6, ss6
+    stack_store v7, ss7
+    stack_store v8, ss8
+    call fn0(), stack_map=[i8 @ ss0+0, i16 @ ss1+0, i32 @ ss2+0, i64 @ ss3+0, i128 @ ss4+0, f32 @ ss5+0, f64 @ ss6+0, i8x16 @ ss7+0, i16x8 @ ss8+0]
+    v9 = stack_load.i8 ss0
+    v10 = stack_load.i16 ss1
+    v11 = stack_load.i32 ss2
+    v12 = stack_load.i64 ss3
+    v13 = stack_load.i128 ss4
+    v14 = stack_load.f32 ss5
+    v15 = stack_load.f64 ss6
+    v16 = stack_load.i8x16 ss7
+    v17 = stack_load.i16x8 ss8
+    return v9, v10, v11, v12, v13, v14, v15, v16, v17
+}
+            "#
+        );
+    }
+
+    #[test]
+    fn series_of_non_overlapping_live_ranges_needs_stack_map() {
+        let sig = Signature::new(CallConv::SystemV);
+
+        let mut fn_ctx = FunctionBuilderContext::new();
+        let mut func = Function::with_name_signature(ir::UserFuncName::testcase("sample"), sig);
+        let mut builder = FunctionBuilder::new(&mut func, &mut fn_ctx);
+
+        let name = builder
+            .func
+            .declare_imported_user_function(ir::UserExternalName {
+                namespace: 0,
+                index: 0,
+            });
+        let signature = builder
+            .func
+            .import_signature(Signature::new(CallConv::SystemV));
+        let foo_func_ref = builder.import_function(ir::ExtFuncData {
+            name: ir::ExternalName::user(name),
+            signature,
+            colocated: true,
+        });
+
+        let name = builder
+            .func
+            .declare_imported_user_function(ir::UserExternalName {
+                namespace: 0,
+                index: 1,
+            });
+        let mut sig = Signature::new(CallConv::SystemV);
+        sig.params.push(AbiParam::new(ir::types::I32));
+        let signature = builder.func.import_signature(sig);
+        let consume_func_ref = builder.import_function(ir::ExtFuncData {
+            name: ir::ExternalName::user(name),
+            signature,
+            colocated: true,
+        });
+
+        // Create a series of needs-stack-map values that do not have
+        // overlapping live ranges, but which do appear in stack maps for calls
+        // to `$foo`:
+        //
+        //     block0:
+        //       v0 = needs stack map
+        //       call $foo()
+        //       call consume(v0)
+        //       v1 = needs stack map
+        //       call $foo()
+        //       call consume(v1)
+        //       v2 = needs stack map
+        //       call $foo()
+        //       call consume(v2)
+        //       v3 = needs stack map
+        //       call $foo()
+        //       call consume(v3)
+        //       return
+        let block0 = builder.create_block();
+        builder.append_block_params_for_function_params(block0);
+        builder.switch_to_block(block0);
+        let v0 = builder.ins().iconst(ir::types::I32, 0);
+        builder.declare_value_needs_stack_map(v0);
+        builder.ins().call(foo_func_ref, &[]);
+        builder.ins().call(consume_func_ref, &[v0]);
+        let v1 = builder.ins().iconst(ir::types::I32, 1);
+        builder.declare_value_needs_stack_map(v1);
+        builder.ins().call(foo_func_ref, &[]);
+        builder.ins().call(consume_func_ref, &[v1]);
+        let v2 = builder.ins().iconst(ir::types::I32, 2);
+        builder.declare_value_needs_stack_map(v2);
+        builder.ins().call(foo_func_ref, &[]);
+        builder.ins().call(consume_func_ref, &[v2]);
+        let v3 = builder.ins().iconst(ir::types::I32, 3);
+        builder.declare_value_needs_stack_map(v3);
+        builder.ins().call(foo_func_ref, &[]);
+        builder.ins().call(consume_func_ref, &[v3]);
+        builder.ins().return_(&[]);
+        builder.seal_all_blocks();
+        builder.finalize();
+
+        assert_eq_output!(
+            func.display().to_string(),
+            r#"
+function %sample() system_v {
+    ss0 = explicit_slot 4, align = 4
+    sig0 = () system_v
+    sig1 = (i32) system_v
+    fn0 = colocated u0:0 sig0
+    fn1 = colocated u0:1 sig1
+
+block0:
+    v0 = iconst.i32 0
+    stack_store v0, ss0  ; v0 = 0
+    call fn0(), stack_map=[i32 @ ss0+0]
+    v7 = stack_load.i32 ss0
+    call fn1(v7)
+    v1 = iconst.i32 1
+    stack_store v1, ss0  ; v1 = 1
+    call fn0(), stack_map=[i32 @ ss0+0]
+    v6 = stack_load.i32 ss0
+    call fn1(v6)
+    v2 = iconst.i32 2
+    stack_store v2, ss0  ; v2 = 2
+    call fn0(), stack_map=[i32 @ ss0+0]
+    v5 = stack_load.i32 ss0
+    call fn1(v5)
+    v3 = iconst.i32 3
+    stack_store v3, ss0  ; v3 = 3
+    call fn0(), stack_map=[i32 @ ss0+0]
+    v4 = stack_load.i32 ss0
+    call fn1(v4)
+    return
+}
+            "#
+        );
+    }
+
+    #[test]
+    fn vars_block_params_and_needs_stack_map() {
+        let _ = env_logger::try_init();
+
+        let mut sig = Signature::new(CallConv::SystemV);
+        sig.params.push(AbiParam::new(ir::types::I32));
+        sig.returns.push(AbiParam::new(ir::types::I32));
+
+        let mut fn_ctx = FunctionBuilderContext::new();
+        let mut func = Function::with_name_signature(ir::UserFuncName::testcase("sample"), sig);
+        let mut builder = FunctionBuilder::new(&mut func, &mut fn_ctx);
+
+        let name = builder
+            .func
+            .declare_imported_user_function(ir::UserExternalName {
+                namespace: 0,
+                index: 0,
+            });
+        let mut sig = Signature::new(CallConv::SystemV);
+        sig.params.push(AbiParam::new(ir::types::I32));
+        let signature = builder.func.import_signature(sig);
+        let func_ref = builder.import_function(ir::ExtFuncData {
+            name: ir::ExternalName::user(name),
+            signature,
+            colocated: true,
+        });
+
+        // Use a variable, create a control flow diamond so that the variable
+        // forces a block parameter on the control join point, and make sure
+        // that we get stack maps for all the appropriate uses of the variable
+        // in all blocks, as well as that we are reusing stack slots for each of
+        // the values.
+        //
+        //                        block0:
+        //                          x := needs stack map
+        //                          call $foo(x)
+        //                          br_if v0, block1, block2
+        //
+        //
+        //     block1:                                     block2:
+        //       call $foo(x)                                call $foo(x)
+        //       call $foo(x)                                call $foo(x)
+        //       x := new needs stack map                    x := new needs stack map
+        //       call $foo(x)                                call $foo(x)
+        //       jump block3                                 jump block3
+        //
+        //
+        //                        block3:
+        //                          call $foo(x)
+        //                          return x
+
+        let x = Variable::from_u32(0);
+        builder.declare_var(x, ir::types::I32);
+        builder.declare_var_needs_stack_map(x);
+
+        let block0 = builder.create_block();
+        let block1 = builder.create_block();
+        let block2 = builder.create_block();
+        let block3 = builder.create_block();
+
+        builder.append_block_params_for_function_params(block0);
+        builder.switch_to_block(block0);
+        let v0 = builder.func.dfg.block_params(block0)[0];
+        let val = builder.ins().iconst(ir::types::I32, 42);
+        builder.def_var(x, val);
+        {
+            let x = builder.use_var(x);
+            builder.ins().call(func_ref, &[x]);
+        }
+        builder.ins().brif(v0, block1, &[], block2, &[]);
+
+        builder.switch_to_block(block1);
+        {
+            let x = builder.use_var(x);
+            builder.ins().call(func_ref, &[x]);
+            builder.ins().call(func_ref, &[x]);
+        }
+        let val = builder.ins().iconst(ir::types::I32, 36);
+        builder.def_var(x, val);
+        {
+            let x = builder.use_var(x);
+            builder.ins().call(func_ref, &[x]);
+        }
+        builder.ins().jump(block3, &[]);
+
+        builder.switch_to_block(block2);
+        {
+            let x = builder.use_var(x);
+            builder.ins().call(func_ref, &[x]);
+            builder.ins().call(func_ref, &[x]);
+        }
+        let val = builder.ins().iconst(ir::types::I32, 36);
+        builder.def_var(x, val);
+        {
+            let x = builder.use_var(x);
+            builder.ins().call(func_ref, &[x]);
+        }
+        builder.ins().jump(block3, &[]);
+
+        builder.switch_to_block(block3);
+        let x = builder.use_var(x);
+        builder.ins().call(func_ref, &[x]);
+        builder.ins().return_(&[x]);
+
+        builder.seal_all_blocks();
+        builder.finalize();
+
+        assert_eq_output!(
+            func.display().to_string(),
+            r#"
+function %sample(i32) -> i32 system_v {
+    ss0 = explicit_slot 4, align = 4
+    ss1 = explicit_slot 4, align = 4
+    sig0 = (i32) system_v
+    fn0 = colocated u0:0 sig0
+
+block0(v0: i32):
+    v1 = iconst.i32 42
+    v2 -> v1
+    v4 -> v1
+    stack_store v1, ss0  ; v1 = 42
+    v13 = stack_load.i32 ss0
+    call fn0(v13), stack_map=[i32 @ ss0+0]
+    brif v0, block1, block2
+
+block1:
+    call fn0(v2), stack_map=[i32 @ ss0+0]  ; v2 = 42
+    call fn0(v2)  ; v2 = 42
+    v3 = iconst.i32 36
+    stack_store v3, ss0  ; v3 = 36
+    v10 = stack_load.i32 ss0
+    call fn0(v10), stack_map=[i32 @ ss0+0]
+    v9 = stack_load.i32 ss0
+    jump block3(v9)
+
+block2:
+    call fn0(v4), stack_map=[i32 @ ss0+0]  ; v4 = 42
+    call fn0(v4)  ; v4 = 42
+    v5 = iconst.i32 36
+    stack_store v5, ss1  ; v5 = 36
+    v12 = stack_load.i32 ss1
+    call fn0(v12), stack_map=[i32 @ ss1+0]
+    v11 = stack_load.i32 ss1
+    jump block3(v11)
+
+block3(v6: i32):
+    stack_store v6, ss0
+    v8 = stack_load.i32 ss0
+    call fn0(v8), stack_map=[i32 @ ss0+0]
+    v7 = stack_load.i32 ss0
+    return v7
+}
+            "#
+        );
+    }
+
+    #[test]
+    fn var_needs_stack_map() {
+        let mut sig = Signature::new(CallConv::SystemV);
+        sig.params
+            .push(AbiParam::new(cranelift_codegen::ir::types::I32));
+        sig.returns
+            .push(AbiParam::new(cranelift_codegen::ir::types::I32));
+
+        let mut fn_ctx = FunctionBuilderContext::new();
+        let mut func = Function::with_name_signature(ir::UserFuncName::testcase("sample"), sig);
+        let mut builder = FunctionBuilder::new(&mut func, &mut fn_ctx);
+
+        let var = Variable::from_u32(0);
+        builder.declare_var(var, cranelift_codegen::ir::types::I32);
+        builder.declare_var_needs_stack_map(var);
+
+        let name = builder
+            .func
+            .declare_imported_user_function(ir::UserExternalName {
+                namespace: 0,
+                index: 0,
+            });
+        let signature = builder
+            .func
+            .import_signature(Signature::new(CallConv::SystemV));
+        let func_ref = builder.import_function(ir::ExtFuncData {
+            name: ir::ExternalName::user(name),
+            signature,
+            colocated: true,
+        });
+
+        let block0 = builder.create_block();
+        builder.append_block_params_for_function_params(block0);
+        builder.switch_to_block(block0);
+
+        let arg = builder.func.dfg.block_params(block0)[0];
+        builder.def_var(var, arg);
+
+        builder.ins().call(func_ref, &[]);
+
+        let val = builder.use_var(var);
+        builder.ins().return_(&[val]);
+
+        builder.seal_all_blocks();
+        builder.finalize();
+
+        assert_eq_output!(
+            func.display().to_string(),
+            r#"
+function %sample(i32) -> i32 system_v {
+    ss0 = explicit_slot 4, align = 4
+    sig0 = () system_v
+    fn0 = colocated u0:0 sig0
+
+block0(v0: i32):
+    stack_store v0, ss0
+    call fn0(), stack_map=[i32 @ ss0+0]
+    v1 = stack_load.i32 ss0
+    return v1
+}
+            "#
+        );
+    }
+
+    #[test]
+    fn first_inst_defines_needs_stack_map() {
+        let mut sig = Signature::new(CallConv::SystemV);
+        sig.params
+            .push(AbiParam::new(cranelift_codegen::ir::types::I32));
+        sig.returns
+            .push(AbiParam::new(cranelift_codegen::ir::types::I32));
+        sig.returns
+            .push(AbiParam::new(cranelift_codegen::ir::types::I32));
+
+        let mut fn_ctx = FunctionBuilderContext::new();
+        let mut func = Function::with_name_signature(ir::UserFuncName::testcase("sample"), sig);
+        let mut builder = FunctionBuilder::new(&mut func, &mut fn_ctx);
+
+        let name = builder
+            .func
+            .declare_imported_user_function(ir::UserExternalName {
+                namespace: 0,
+                index: 0,
+            });
+        let signature = builder
+            .func
+            .import_signature(Signature::new(CallConv::SystemV));
+        let func_ref = builder.import_function(ir::ExtFuncData {
+            name: ir::ExternalName::user(name),
+            signature,
+            colocated: true,
+        });
+
+        // Regression test found via fuzzing in
+        // https://github.com/bytecodealliance/wasmtime/pull/8941 involving the
+        // combination of cursor positions after we have block parameters that
+        // need inclusion in stack maps and when the first instruction in a
+        // block defines a value that needs inclusion in stack maps.
+        //
+        // block0(v0: i32):
+        //   v1 = iconst.i32 42
+        //   call $foo()
+        //   return v0, v1
+
+        let block0 = builder.create_block();
+        builder.append_block_params_for_function_params(block0);
+        builder.switch_to_block(block0);
+
+        let arg = builder.func.dfg.block_params(block0)[0];
+        builder.declare_value_needs_stack_map(arg);
+
+        let val = builder.ins().iconst(ir::types::I32, 42);
+        builder.declare_value_needs_stack_map(val);
+
+        builder.ins().call(func_ref, &[]);
+
+        builder.ins().return_(&[arg, val]);
+
+        builder.seal_all_blocks();
+        builder.finalize();
+
+        assert_eq_output!(
+            func.display().to_string(),
+            r#"
+function %sample(i32) -> i32, i32 system_v {
+    ss0 = explicit_slot 4, align = 4
+    ss1 = explicit_slot 4, align = 4
+    sig0 = () system_v
+    fn0 = colocated u0:0 sig0
+
+block0(v0: i32):
+    stack_store v0, ss0
+    v1 = iconst.i32 42
+    stack_store v1, ss1  ; v1 = 42
+    call fn0(), stack_map=[i32 @ ss0+0, i32 @ ss1+0]
+    v2 = stack_load.i32 ss0
+    v3 = stack_load.i32 ss1
+    return v2, v3
+}
+            "#
+        );
+    }
+
+    #[test]
+    fn needs_stack_map_and_loops_and_partially_live_values() {
+        let _ = env_logger::try_init();
+
+        let mut sig = Signature::new(CallConv::SystemV);
+        sig.params.push(AbiParam::new(ir::types::I32));
+
+        let mut fn_ctx = FunctionBuilderContext::new();
+        let mut func =
+            Function::with_name_signature(ir::UserFuncName::testcase("sample"), sig.clone());
+        let mut builder = FunctionBuilder::new(&mut func, &mut fn_ctx);
+
+        let name = builder
+            .func
+            .declare_imported_user_function(ir::UserExternalName {
+                namespace: 0,
+                index: 0,
+            });
+        let signature = builder
+            .func
+            .import_signature(Signature::new(CallConv::SystemV));
+        let foo_func_ref = builder.import_function(ir::ExtFuncData {
+            name: ir::ExternalName::user(name),
+            signature,
+            colocated: true,
+        });
+
+        let name = builder
+            .func
+            .declare_imported_user_function(ir::UserExternalName {
+                namespace: 1,
+                index: 1,
+            });
+        let signature = builder.func.import_signature(sig);
+        let bar_func_ref = builder.import_function(ir::ExtFuncData {
+            name: ir::ExternalName::user(name),
+            signature,
+            colocated: true,
+        });
+
+        // Test that we support stack maps in loops and that we properly handle
+        // value that are only live for part of the loop body on each iteration,
+        // but are live across the whole loop because they will be used again
+        // the next iteration. Note that `v0` below, which is a GC value, is not
+        // live *within a single iteration of the loop* after the call to `bar`,
+        // but is actually live across the whole loop because it will be used
+        // again in the *next iteration of the loop*:
+        //
+        //     block0(v0: i32):
+        //       jump block1
+        //
+        //     block1:
+        //       call $foo()
+        //       call $bar(v0)
+        //       call $foo()
+        //       jump block1
+        let block0 = builder.create_block();
+        let block1 = builder.create_block();
+        builder.append_block_params_for_function_params(block0);
+
+        builder.switch_to_block(block0);
+        builder.ins().jump(block1, &[]);
+
+        builder.switch_to_block(block1);
+        let v0 = builder.func.dfg.block_params(block0)[0];
+        builder.declare_value_needs_stack_map(v0);
+        builder.ins().call(foo_func_ref, &[]);
+        builder.ins().call(bar_func_ref, &[v0]);
+        builder.ins().call(foo_func_ref, &[]);
+        builder.ins().jump(block1, &[]);
+
+        builder.seal_all_blocks();
+        builder.finalize();
+
+        assert_eq_output!(
+            func.display().to_string(),
+            r#"
+function %sample(i32) system_v {
+    ss0 = explicit_slot 4, align = 4
+    sig0 = () system_v
+    sig1 = (i32) system_v
+    fn0 = colocated u0:0 sig0
+    fn1 = colocated u1:1 sig1
+
+block0(v0: i32):
+    stack_store v0, ss0
+    jump block1
+
+block1:
+    call fn0(), stack_map=[i32 @ ss0+0]
+    v1 = stack_load.i32 ss0
+    call fn1(v1), stack_map=[i32 @ ss0+0]
+    call fn0(), stack_map=[i32 @ ss0+0]
+    jump block1
+}
+            "#,
+        );
+    }
+
+    #[test]
+    fn needs_stack_map_and_irreducible_loops() {
+        let _ = env_logger::try_init();
+
+        let mut sig = Signature::new(CallConv::SystemV);
+        sig.params.push(AbiParam::new(ir::types::I32));
+        sig.params.push(AbiParam::new(ir::types::I32));
+
+        let mut fn_ctx = FunctionBuilderContext::new();
+        let mut func = Function::with_name_signature(ir::UserFuncName::testcase("sample"), sig);
+        let mut builder = FunctionBuilder::new(&mut func, &mut fn_ctx);
+
+        let name = builder
+            .func
+            .declare_imported_user_function(ir::UserExternalName {
+                namespace: 0,
+                index: 0,
+            });
+        let signature = builder
+            .func
+            .import_signature(Signature::new(CallConv::SystemV));
+        let foo_func_ref = builder.import_function(ir::ExtFuncData {
+            name: ir::ExternalName::user(name),
+            signature,
+            colocated: true,
+        });
+
+        let name = builder
+            .func
+            .declare_imported_user_function(ir::UserExternalName {
+                namespace: 1,
+                index: 1,
+            });
+        let mut sig = Signature::new(CallConv::SystemV);
+        sig.params.push(AbiParam::new(ir::types::I32));
+        let signature = builder.func.import_signature(sig);
+        let bar_func_ref = builder.import_function(ir::ExtFuncData {
+            name: ir::ExternalName::user(name),
+            signature,
+            colocated: true,
+        });
+
+        // Test an irreducible loop with multiple entry points, both block1 and
+        // block2, in this case:
+        //
+        //     block0(v0: i32, v1: i32):
+        //       brif v0, block1, block2
+        //
+        //     block1:
+        //       jump block3
+        //
+        //     block2:
+        //       jump block4
+        //
+        //     block3:
+        //       call $foo()
+        //       call $bar(v1)
+        //       call $foo()
+        //       jump block2
+        //
+        //     block4:
+        //       call $foo()
+        //       call $bar(v1)
+        //       call $foo()
+        //       jump block1
+        let block0 = builder.create_block();
+        let block1 = builder.create_block();
+        let block2 = builder.create_block();
+        let block3 = builder.create_block();
+        let block4 = builder.create_block();
+        builder.append_block_params_for_function_params(block0);
+
+        builder.switch_to_block(block0);
+        let v0 = builder.func.dfg.block_params(block0)[0];
+        let v1 = builder.func.dfg.block_params(block0)[1];
+        builder.declare_value_needs_stack_map(v1);
+        builder.ins().brif(v0, block1, &[], block2, &[]);
+
+        builder.switch_to_block(block1);
+        builder.ins().jump(block3, &[]);
+
+        builder.switch_to_block(block2);
+        builder.ins().jump(block4, &[]);
+
+        builder.switch_to_block(block3);
+        builder.ins().call(foo_func_ref, &[]);
+        builder.ins().call(bar_func_ref, &[v1]);
+        builder.ins().call(foo_func_ref, &[]);
+        builder.ins().jump(block2, &[]);
+
+        builder.switch_to_block(block4);
+        builder.ins().call(foo_func_ref, &[]);
+        builder.ins().call(bar_func_ref, &[v1]);
+        builder.ins().call(foo_func_ref, &[]);
+        builder.ins().jump(block1, &[]);
+
+        builder.seal_all_blocks();
+        builder.finalize();
+
+        assert_eq_output!(
+            func.display().to_string(),
+            r#"
+function %sample(i32, i32) system_v {
+    ss0 = explicit_slot 4, align = 4
+    sig0 = () system_v
+    sig1 = (i32) system_v
+    fn0 = colocated u0:0 sig0
+    fn1 = colocated u1:1 sig1
+
+block0(v0: i32, v1: i32):
+    stack_store v1, ss0
+    brif v0, block1, block2
+
+block1:
+    jump block3
+
+block2:
+    jump block4
+
+block3:
+    call fn0(), stack_map=[i32 @ ss0+0]
+    v3 = stack_load.i32 ss0
+    call fn1(v3), stack_map=[i32 @ ss0+0]
+    call fn0(), stack_map=[i32 @ ss0+0]
+    jump block2
+
+block4:
+    call fn0(), stack_map=[i32 @ ss0+0]
+    v2 = stack_load.i32 ss0
+    call fn1(v2), stack_map=[i32 @ ss0+0]
+    call fn0(), stack_map=[i32 @ ss0+0]
+    jump block1
+}
+            "#,
+        );
+    }
+
+    #[test]
+    fn needs_stack_map_and_back_edge_to_back_edge() {
+        let _ = env_logger::try_init();
+
+        let mut sig = Signature::new(CallConv::SystemV);
+        sig.params.push(AbiParam::new(ir::types::I32));
+        sig.params.push(AbiParam::new(ir::types::I32));
+        sig.params.push(AbiParam::new(ir::types::I32));
+        sig.params.push(AbiParam::new(ir::types::I32));
+
+        let mut fn_ctx = FunctionBuilderContext::new();
+        let mut func = Function::with_name_signature(ir::UserFuncName::testcase("sample"), sig);
+        let mut builder = FunctionBuilder::new(&mut func, &mut fn_ctx);
+
+        let name = builder
+            .func
+            .declare_imported_user_function(ir::UserExternalName {
+                namespace: 0,
+                index: 0,
+            });
+        let signature = builder
+            .func
+            .import_signature(Signature::new(CallConv::SystemV));
+        let foo_func_ref = builder.import_function(ir::ExtFuncData {
+            name: ir::ExternalName::user(name),
+            signature,
+            colocated: true,
+        });
+
+        let name = builder
+            .func
+            .declare_imported_user_function(ir::UserExternalName {
+                namespace: 1,
+                index: 1,
+            });
+        let mut sig = Signature::new(CallConv::SystemV);
+        sig.params.push(AbiParam::new(ir::types::I32));
+        let signature = builder.func.import_signature(sig);
+        let bar_func_ref = builder.import_function(ir::ExtFuncData {
+            name: ir::ExternalName::user(name),
+            signature,
+            colocated: true,
+        });
+
+        // Test that we detect the `block1 -> block2 -> block3 -> block2 ->
+        // block1` loop in our liveness analysis and keep `v{0,1,2}` live across
+        // the whole loop body.
+        //
+        //     block0(v0, v1, v2, v3):
+        //       jump block1(v3)
+        //
+        //     block1(v4):
+        //       call foo_func_ref()
+        //       call bar_func_ref(v0)
+        //       call foo_func_ref()
+        //       jump block2
+        //
+        //     block2:
+        //       call foo_func_ref()
+        //       call bar_func_ref(v1)
+        //       call foo_func_ref()
+        //       v5 = iadd_imm v4, -1
+        //       brif v4, block1(v5), block3
+        //
+        //     block3:
+        //       call foo_func_ref()
+        //       call bar_func_ref(v2)
+        //       call foo_func_ref()
+        //       jump block2
+
+        let block0 = builder.create_block();
+        let block1 = builder.create_block();
+        let block2 = builder.create_block();
+        let block3 = builder.create_block();
+
+        builder.append_block_params_for_function_params(block0);
+
+        builder.switch_to_block(block0);
+
+        let v0 = builder.func.dfg.block_params(block0)[0];
+        builder.declare_value_needs_stack_map(v0);
+        let v1 = builder.func.dfg.block_params(block0)[1];
+        builder.declare_value_needs_stack_map(v1);
+        let v2 = builder.func.dfg.block_params(block0)[2];
+        builder.declare_value_needs_stack_map(v2);
+        let v3 = builder.func.dfg.block_params(block0)[3];
+
+        builder.ins().jump(block1, &[v3]);
+
+        builder.switch_to_block(block1);
+        let v4 = builder.append_block_param(block1, ir::types::I32);
+        builder.ins().call(foo_func_ref, &[]);
+        builder.ins().call(bar_func_ref, &[v0]);
+        builder.ins().call(foo_func_ref, &[]);
+        builder.ins().jump(block2, &[]);
+
+        builder.switch_to_block(block2);
+        builder.ins().call(foo_func_ref, &[]);
+        builder.ins().call(bar_func_ref, &[v1]);
+        builder.ins().call(foo_func_ref, &[]);
+        let v5 = builder.ins().iadd_imm(v4, -1);
+        builder.ins().brif(v4, block1, &[v5], block3, &[]);
+
+        builder.switch_to_block(block3);
+        builder.ins().call(foo_func_ref, &[]);
+        builder.ins().call(bar_func_ref, &[v2]);
+        builder.ins().call(foo_func_ref, &[]);
+        builder.ins().jump(block2, &[]);
+
+        builder.seal_all_blocks();
+        builder.finalize();
+
+        assert_eq_output!(
+            func.display().to_string(),
+            r#"
+function %sample(i32, i32, i32, i32) system_v {
+    ss0 = explicit_slot 4, align = 4
+    ss1 = explicit_slot 4, align = 4
+    ss2 = explicit_slot 4, align = 4
+    sig0 = () system_v
+    sig1 = (i32) system_v
+    fn0 = colocated u0:0 sig0
+    fn1 = colocated u1:1 sig1
+
+block0(v0: i32, v1: i32, v2: i32, v3: i32):
+    stack_store v0, ss0
+    stack_store v1, ss1
+    stack_store v2, ss2
+    jump block1(v3)
+
+block1(v4: i32):
+    call fn0(), stack_map=[i32 @ ss0+0, i32 @ ss1+0, i32 @ ss2+0]
+    v8 = stack_load.i32 ss0
+    call fn1(v8), stack_map=[i32 @ ss0+0, i32 @ ss1+0, i32 @ ss2+0]
+    call fn0(), stack_map=[i32 @ ss0+0, i32 @ ss1+0, i32 @ ss2+0]
+    jump block2
+
+block2:
+    call fn0(), stack_map=[i32 @ ss0+0, i32 @ ss1+0, i32 @ ss2+0]
+    v7 = stack_load.i32 ss1
+    call fn1(v7), stack_map=[i32 @ ss0+0, i32 @ ss1+0, i32 @ ss2+0]
+    call fn0(), stack_map=[i32 @ ss0+0, i32 @ ss1+0, i32 @ ss2+0]
+    v5 = iadd_imm.i32 v4, -1
+    brif.i32 v4, block1(v5), block3
+
+block3:
+    call fn0(), stack_map=[i32 @ ss0+0, i32 @ ss1+0, i32 @ ss2+0]
+    v6 = stack_load.i32 ss2
+    call fn1(v6), stack_map=[i32 @ ss0+0, i32 @ ss1+0, i32 @ ss2+0]
+    call fn0(), stack_map=[i32 @ ss0+0, i32 @ ss1+0, i32 @ ss2+0]
+    jump block2
+}
+            "#,
+        );
+    }
+}
diff --git a/cranelift/frontend/src/lib.rs b/cranelift/frontend/src/lib.rs
index 5eaf50e903ff..b70a934f3325 100644
--- a/cranelift/frontend/src/lib.rs
+++ b/cranelift/frontend/src/lib.rs
@@ -4,38 +4,36 @@
 //! corresponding to your source program written in another language.
 //!
 //! To get started, create an [`FunctionBuilderContext`](struct.FunctionBuilderContext.html) and
-//! pass it as an argument to a [`FunctionBuilder`](struct.FunctionBuilder.html).
+//! pass it as an argument to a [`FunctionBuilder`].
 //!
 //! # Mutable variables and Cranelift IR values
 //!
 //! The most interesting feature of this API is that it provides a single way to deal with all your
-//! variable problems. Indeed, the [`FunctionBuilder`](struct.FunctionBuilder.html) struct has a
+//! variable problems. Indeed, the [`FunctionBuilder`] struct has a
 //! type `Variable` that should be an index of your source language variables. Then, through
 //! calling the functions
-//! [`declare_var`](struct.FunctionBuilder.html#method.declare_var),
-//! [`def_var`](struct.FunctionBuilder.html#method.def_var) and
-//! [`use_var`](struct.FunctionBuilder.html#method.use_var), the
-//! [`FunctionBuilder`](struct.FunctionBuilder.html) will create for you all the Cranelift IR
-//! values corresponding to your variables.
+//! [`declare_var`](FunctionBuilder::declare_var), [`def_var`](FunctionBuilder::def_var) and
+//! [`use_var`](FunctionBuilder::use_var), the [`FunctionBuilder`] will create for you all the
+//! Cranelift IR values corresponding to your variables.
 //!
 //! This API has been designed to help you translate your mutable variables into
 //! [`SSA`](https://en.wikipedia.org/wiki/Static_single_assignment_form) form.
-//! [`use_var`](struct.FunctionBuilder.html#method.use_var) will return the Cranelift IR value
+//! [`use_var`](FunctionBuilder::use_var) will return the Cranelift IR value
 //! that corresponds to your mutable variable at a precise point in the program. However, if you know
 //! beforehand that one of your variables is defined only once, for instance if it is the result
 //! of an intermediate expression in an expression-based language, then you can translate it
 //! directly by the Cranelift IR value returned by the instruction builder. Using the
-//! [`use_var`](struct.FunctionBuilder.html#method.use_var) API for such an immutable variable
+//! [`use_var`](FunctionBuilder::use_var) API for such an immutable variable
 //! would also work but with a slight additional overhead (the SSA algorithm does not know
 //! beforehand if a variable is immutable or not).
 //!
 //! The moral is that you should use these three functions to handle all your mutable variables,
 //! even those that are not present in the source code but artifacts of the translation. It is up
-//! to you to keep a mapping between the mutable variables of your language and their `Variable`
-//! index that is used by Cranelift. Caution: as the `Variable` is used by Cranelift to index an
-//! array containing information about your mutable variables, when you create a new `Variable`
-//! with [`Variable::new(var_index)`] you should make sure that `var_index` is provided by a
-//! counter incremented by 1 each time you encounter a new mutable variable.
+//! to you to keep a mapping between the mutable variables of your language and their [`Variable`]
+//! index that is used by Cranelift. Caution: as the [`Variable`] is used by Cranelift to index an
+//! array containing information about your mutable variables, when you create a new [`Variable`]
+//! with `Variable::new(var_index)` you should make sure that `var_index`
+//! is provided by a counter incremented by 1 each time you encounter a new mutable variable.
 //!
 //! # Example
 //!
@@ -60,12 +58,9 @@
 //! }
 //! ```
 //!
-//! Here is how you build the corresponding Cranelift IR function using `FunctionBuilderContext`:
+//! Here is how you build the corresponding Cranelift IR function using [`FunctionBuilderContext`]:
 //!
 //! ```rust
-//! extern crate cranelift_codegen;
-//! extern crate cranelift_frontend;
-//!
 //! use cranelift_codegen::entity::EntityRef;
 //! use cranelift_codegen::ir::types::*;
 //! use cranelift_codegen::ir::{AbiParam, UserFuncName, Function, InstBuilder, Signature};
@@ -160,9 +155,7 @@
 //! }
 //! ```
 
-#![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)]
-#![warn(unused_import_braces)]
-#![cfg_attr(feature = "std", deny(unstable_features))]
+#![deny(missing_docs)]
 #![no_std]
 
 #[allow(unused_imports)] // #[macro_use] is required for no_std
@@ -174,14 +167,42 @@ extern crate alloc;
 extern crate std;
 
 #[cfg(not(feature = "std"))]
-use hashbrown::HashMap;
+use hashbrown::{HashMap, HashSet};
 #[cfg(feature = "std")]
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 
 pub use crate::frontend::{FuncInstBuilder, FunctionBuilder, FunctionBuilderContext};
 pub use crate::switch::Switch;
 pub use crate::variable::Variable;
 
+#[cfg(test)]
+macro_rules! assert_eq_output {
+    ( $left:expr, $right:expr $(,)? ) => {{
+        let left = $left;
+        let left = left.trim();
+
+        let right = $right;
+        let right = right.trim();
+
+        assert_eq!(
+            left,
+            right,
+            "assertion failed, output not equal:\n\
+             \n\
+             =========== Diff ===========\n\
+             {}\n\
+             =========== Left ===========\n\
+             {left}\n\
+             =========== Right ===========\n\
+             {right}\n\
+             ",
+            similar::TextDiff::from_lines(left, right)
+                .unified_diff()
+                .header("left", "right")
+        )
+    }};
+}
+
 mod frontend;
 mod ssa;
 mod switch;
diff --git a/cranelift/frontend/src/ssa.rs b/cranelift/frontend/src/ssa.rs
index 584e6cc96e1b..694e467b0b20 100644
--- a/cranelift/frontend/src/ssa.rs
+++ b/cranelift/frontend/src/ssa.rs
@@ -9,7 +9,6 @@
 
 use crate::Variable;
 use alloc::vec::Vec;
-use core::convert::TryInto;
 use core::mem;
 use cranelift_codegen::cursor::{Cursor, FuncCursor};
 use cranelift_codegen::entity::{EntityList, EntitySet, ListPool, SecondaryMap};
@@ -20,7 +19,7 @@ use cranelift_codegen::packed_option::PackedOption;
 
 /// Structure containing the data relevant the construction of SSA for a given function.
 ///
-/// The parameter struct `Variable` corresponds to the way variables are represented in the
+/// The parameter struct [`Variable`] corresponds to the way variables are represented in the
 /// non-SSA language you're translating from.
 ///
 /// The SSA building relies on information about the variables used and defined.
@@ -143,8 +142,6 @@ fn emit_zero(ty: Type, mut cur: FuncCursor) -> Value {
         cur.ins().f32const(Ieee32::with_bits(0))
     } else if ty == F64 {
         cur.ins().f64const(Ieee64::with_bits(0))
-    } else if ty.is_ref() {
-        cur.ins().null(ty)
     } else if ty.is_vector() {
         let scalar_ty = ty.lane_type();
         if scalar_ty.is_int() {
@@ -161,10 +158,10 @@ fn emit_zero(ty: Type, mut cur: FuncCursor) -> Value {
             let scalar = cur.ins().f64const(Ieee64::with_bits(0));
             cur.ins().splat(ty, scalar)
         } else {
-            panic!("unimplemented scalar type: {:?}", ty)
+            panic!("unimplemented scalar type: {ty:?}")
         }
     } else {
-        panic!("unimplemented type: {:?}", ty)
+        panic!("unimplemented type: {ty:?}")
     }
 }
 
@@ -381,8 +378,7 @@ impl SSABuilder {
     pub fn seal_block(&mut self, block: Block, func: &mut Function) -> SideEffects {
         debug_assert!(
             !self.is_sealed(block),
-            "Attempting to seal {} which is already sealed.",
-            block
+            "Attempting to seal {block} which is already sealed."
         );
         self.seal_one_block(block, func);
         mem::take(&mut self.side_effects)
diff --git a/cranelift/frontend/src/switch.rs b/cranelift/frontend/src/switch.rs
index ab09c2c21fe4..24d0fb714bac 100644
--- a/cranelift/frontend/src/switch.rs
+++ b/cranelift/frontend/src/switch.rs
@@ -1,7 +1,6 @@
 use super::HashMap;
 use crate::frontend::FunctionBuilder;
 use alloc::vec::Vec;
-use core::convert::TryFrom;
 use cranelift_codegen::ir::condcodes::IntCC;
 use cranelift_codegen::ir::*;
 
@@ -55,11 +54,7 @@ impl Switch {
     /// Set a switch entry
     pub fn set_entry(&mut self, index: EntryIndex, block: Block) {
         let prev = self.cases.insert(index, block);
-        assert!(
-            prev.is_none(),
-            "Tried to set the same entry {} twice",
-            index
-        );
+        assert!(prev.is_none(), "Tried to set the same entry {index} twice");
     }
 
     /// Get a reference to all existing entries
@@ -278,10 +273,7 @@ impl Switch {
         let val_ty = bx.func.dfg.value_type(val);
         let val_ty_max = val_ty.bounds(false).1;
         if max > val_ty_max {
-            panic!(
-                "The index type {} does not fit the maximum switch entry of {}",
-                val_ty, max
-            );
+            panic!("The index type {val_ty} does not fit the maximum switch entry of {max}");
         }
 
         let contiguous_case_ranges = self.collect_contiguous_case_ranges();
@@ -290,8 +282,11 @@ impl Switch {
 }
 
 fn icmp_imm_u128(bx: &mut FunctionBuilder, cond: IntCC, x: Value, y: u128) -> Value {
-    if let Ok(index) = u64::try_from(y) {
-        bx.ins().icmp_imm(cond, x, index as i64)
+    if bx.func.dfg.value_type(x) != types::I128 {
+        assert!(u64::try_from(y).is_ok());
+        bx.ins().icmp_imm(cond, x, y as i64)
+    } else if let Ok(index) = i64::try_from(y) {
+        bx.ins().icmp_imm(cond, x, index)
     } else {
         let (lsb, msb) = (y as u64, (y >> 64) as u64);
         let lsb = bx.ins().iconst(types::I64, lsb as i64);
@@ -343,7 +338,6 @@ mod tests {
     use super::*;
     use crate::frontend::FunctionBuilderContext;
     use alloc::string::ToString;
-    use cranelift_codegen::ir::Function;
 
     macro_rules! setup {
         ($default:expr, [$($index:expr,)*]) => {{
@@ -370,19 +364,6 @@ mod tests {
         }};
     }
 
-    macro_rules! assert_eq_output {
-        ($actual:ident, $expected:literal) => {
-            assert_eq!(
-                $actual,
-                $expected,
-                "\n{}",
-                similar::TextDiff::from_lines($expected, &$actual)
-                    .unified_diff()
-                    .header("expected", "actual")
-            )
-        };
-    }
-
     #[test]
     fn switch_empty() {
         let func = setup!(42, []);
@@ -484,7 +465,7 @@ block12:
             func,
             "block0:
     v0 = iconst.i8 0
-    v1 = icmp_imm eq v0, 128  ; v0 = 0
+    v1 = icmp_imm eq v0, -128  ; v0 = 0
     brif v1, block1, block3
 
 block3:
@@ -516,7 +497,7 @@ block3:
             func,
             "block0:
     v0 = iconst.i8 0
-    v1 = icmp_imm eq v0, 255  ; v0 = 0
+    v1 = icmp_imm eq v0, -1  ; v0 = 0
     brif v1, block1, block4
 
 block4:
@@ -543,7 +524,7 @@ block4:
 
         for case in cases {
             for typ in &[types::I8, types::I16, types::I32, types::I64, types::I128] {
-                eprintln!("Testing {:?} with keys: {:?}", typ, case);
+                eprintln!("Testing {typ:?} with keys: {case:?}");
                 do_case(case, *typ);
             }
         }
@@ -653,4 +634,43 @@ block4:
     br_table v3, block3, [block2, block1]"
         );
     }
+
+    #[test]
+    fn switch_128bit_max_u64() {
+        let mut func = Function::new();
+        let mut func_ctx = FunctionBuilderContext::new();
+        {
+            let mut bx = FunctionBuilder::new(&mut func, &mut func_ctx);
+            let block0 = bx.create_block();
+            bx.switch_to_block(block0);
+            let val = bx.ins().iconst(types::I64, 0);
+            let val = bx.ins().uextend(types::I128, val);
+            let mut switch = Switch::new();
+            let block1 = bx.create_block();
+            switch.set_entry(u64::MAX.into(), block1);
+            let block2 = bx.create_block();
+            switch.set_entry(0, block2);
+            let block3 = bx.create_block();
+            switch.emit(&mut bx, val, block3);
+        }
+        let func = func
+            .to_string()
+            .trim_start_matches("function u0:0() fast {\n")
+            .trim_end_matches("\n}\n")
+            .to_string();
+        assert_eq_output!(
+            func,
+            "block0:
+    v0 = iconst.i64 0
+    v1 = uextend.i128 v0  ; v0 = 0
+    v2 = iconst.i64 -1
+    v3 = iconst.i64 0
+    v4 = iconcat v2, v3  ; v2 = -1, v3 = 0
+    v5 = icmp eq v1, v4
+    brif v5, block1, block4
+
+block4:
+    brif.i128 v1, block3, block2"
+        );
+    }
 }
diff --git a/cranelift/frontend/src/variable.rs b/cranelift/frontend/src/variable.rs
index 6d24b647ea68..60b1e7ce74e0 100644
--- a/cranelift/frontend/src/variable.rs
+++ b/cranelift/frontend/src/variable.rs
@@ -16,11 +16,3 @@ use cranelift_codegen::entity::entity_impl;
 pub struct Variable(u32);
 
 entity_impl!(Variable, "var");
-
-impl Variable {
-    /// Create a new Variable with the given index.
-    #[deprecated = "Use Variable::from_u32 instead"]
-    pub fn with_u32(index: u32) -> Self {
-        Variable::from_u32(index)
-    }
-}
diff --git a/cranelift/fuzzgen/Cargo.toml b/cranelift/fuzzgen/Cargo.toml
index 014d0f076a8b..856828b2b5f9 100644
--- a/cranelift/fuzzgen/Cargo.toml
+++ b/cranelift/fuzzgen/Cargo.toml
@@ -7,14 +7,17 @@ license = "Apache-2.0 WITH LLVM-exception"
 repository = "https://github.com/bytecodealliance/wasmtime"
 readme = "README.md"
 edition.workspace = true
+rust-version.workspace = true
 publish = false
 
+[lints]
+workspace = true
 
 [dependencies]
 cranelift = { workspace = true }
 cranelift-native = { workspace = true }
 
 anyhow = { workspace = true }
-arbitrary = "1.0.0"
+arbitrary = { workspace = true }
 once_cell = { workspace = true }
 target-lexicon = { workspace = true, features = ["std"] }
diff --git a/cranelift/fuzzgen/src/config.rs b/cranelift/fuzzgen/src/config.rs
index a444766ae1cc..8be5b5a47a95 100644
--- a/cranelift/fuzzgen/src/config.rs
+++ b/cranelift/fuzzgen/src/config.rs
@@ -37,6 +37,8 @@ pub struct Config {
     pub static_stack_slots_per_function: RangeInclusive<usize>,
     /// Size in bytes
     pub static_stack_slot_size: RangeInclusive<usize>,
+    /// Stack slot alignment as a power of 2
+    pub stack_slot_alignment_log2: RangeInclusive<usize>,
     /// Allowed stack probe sizes
     pub stack_probe_size_log2: RangeInclusive<usize>,
 
@@ -86,6 +88,7 @@ impl Default for Config {
             switch_max_range_size: 2..=32,
             static_stack_slots_per_function: 0..=8,
             static_stack_slot_size: 0..=128,
+            stack_slot_alignment_log2: 0..=10,
             // We need the mix of sizes that allows us to:
             //  * not generates any stack probes
             //  * generate unrolled stack probes
diff --git a/cranelift/fuzzgen/src/cranelift_arbitrary.rs b/cranelift/fuzzgen/src/cranelift_arbitrary.rs
index 9de4d162c7b9..888c2e2c201c 100644
--- a/cranelift/fuzzgen/src/cranelift_arbitrary.rs
+++ b/cranelift/fuzzgen/src/cranelift_arbitrary.rs
@@ -2,7 +2,7 @@ use crate::codegen::ir::{ArgumentExtension, ArgumentPurpose};
 use anyhow::Result;
 use cranelift::codegen::data_value::DataValue;
 use cranelift::codegen::ir::types::*;
-use cranelift::codegen::ir::{AbiParam, Signature, Type};
+use cranelift::codegen::ir::{AbiParam, Signature};
 use cranelift::codegen::isa::CallConv;
 
 use arbitrary::Unstructured;
@@ -43,7 +43,12 @@ impl<'a> CraneliftArbitrary for &mut Unstructured<'a> {
 
     fn callconv(&mut self, architecture: Architecture) -> Result<CallConv> {
         // These are implemented and should work on all backends
-        let mut allowed_callconvs = vec![CallConv::Fast, CallConv::Cold, CallConv::SystemV];
+        let mut allowed_callconvs = vec![
+            CallConv::Fast,
+            CallConv::Cold,
+            CallConv::SystemV,
+            CallConv::Tail,
+        ];
 
         // Fastcall is supposed to work on x86 and aarch64
         if matches!(
@@ -58,10 +63,9 @@ impl<'a> CraneliftArbitrary for &mut Unstructured<'a> {
             allowed_callconvs.push(CallConv::AppleAarch64);
         }
 
-        // TODO(#6530): The `tail` calling convention is not supported on s390x
-        // yet.
-        if !matches!(architecture, Architecture::S390x) {
-            allowed_callconvs.push(CallConv::Tail);
+        // The winch calling convention is supposed to work on x64.
+        if matches!(architecture, Architecture::X86_64) {
+            allowed_callconvs.push(CallConv::Winch);
         }
 
         Ok(*self.choose(&allowed_callconvs[..])?)
@@ -90,12 +94,19 @@ impl<'a> CraneliftArbitrary for &mut Unstructured<'a> {
 
     fn signature(
         &mut self,
-        simd_enabled: bool,
+        mut simd_enabled: bool,
         architecture: Architecture,
         max_params: usize,
         max_rets: usize,
     ) -> Result<Signature> {
         let callconv = self.callconv(architecture)?;
+
+        // Winch doesn't support SIMD yet
+        // https://github.com/bytecodealliance/wasmtime/issues/8093
+        if callconv == CallConv::Winch {
+            simd_enabled = false;
+        }
+
         let mut sig = Signature::new(callconv);
 
         for _ in 0..max_params {
diff --git a/cranelift/fuzzgen/src/function_generator.rs b/cranelift/fuzzgen/src/function_generator.rs
index a264155cad68..b7b1049ae3cc 100644
--- a/cranelift/fuzzgen/src/function_generator.rs
+++ b/cranelift/fuzzgen/src/function_generator.rs
@@ -9,8 +9,8 @@ use cranelift::codegen::ir::instructions::{InstructionFormat, ResolvedConstraint
 use cranelift::codegen::ir::stackslot::StackSize;
 
 use cranelift::codegen::ir::{
-    types::*, AtomicRmwOp, Block, ConstantData, Endianness, ExternalName, FuncRef, Function,
-    LibCall, Opcode, SigRef, Signature, StackSlot, Type, UserExternalName, UserFuncName, Value,
+    types::*, AliasRegion, AtomicRmwOp, Block, ConstantData, Endianness, ExternalName, FuncRef,
+    Function, LibCall, Opcode, SigRef, Signature, StackSlot, UserExternalName, UserFuncName, Value,
 };
 use cranelift::codegen::isa::CallConv;
 use cranelift::frontend::{FunctionBuilder, FunctionBuilderContext, Switch, Variable};
@@ -22,6 +22,7 @@ use cranelift::prelude::{
 use once_cell::sync::Lazy;
 use std::collections::HashMap;
 use std::ops::RangeInclusive;
+use std::str::FromStr;
 use target_lexicon::{Architecture, Triple};
 
 type BlockSignature = Vec<Type>;
@@ -131,7 +132,14 @@ fn insert_stack_load(
 ) -> Result<()> {
     let typevar = rets[0];
     let type_size = typevar.bytes();
-    let (slot, slot_size) = fgen.stack_slot_with_size(type_size)?;
+    let (slot, slot_size, _align, category) = fgen.stack_slot_with_size(type_size)?;
+
+    // `stack_load` doesn't support setting MemFlags, and it does not set any
+    // alias analysis bits, so we can only emit it for `Other` slots.
+    if category != AACategory::Other {
+        return Err(arbitrary::Error::IncorrectFormat.into());
+    }
+
     let offset = fgen.u.int_in_range(0..=(slot_size - type_size))? as i32;
 
     let val = builder.ins().stack_load(typevar, slot, offset);
@@ -150,7 +158,15 @@ fn insert_stack_store(
 ) -> Result<()> {
     let typevar = args[0];
     let type_size = typevar.bytes();
-    let (slot, slot_size) = fgen.stack_slot_with_size(type_size)?;
+
+    let (slot, slot_size, _align, category) = fgen.stack_slot_with_size(type_size)?;
+
+    // `stack_store` doesn't support setting MemFlags, and it does not set any
+    // alias analysis bits, so we can only emit it for `Other` slots.
+    if category != AACategory::Other {
+        return Err(arbitrary::Error::IncorrectFormat.into());
+    }
+
     let offset = fgen.u.int_in_range(0..=(slot_size - type_size))? as i32;
 
     let arg0 = fgen.get_variable_of_type(typevar)?;
@@ -507,14 +523,10 @@ fn valid_for_target(triple: &Triple, op: Opcode, args: &[Type], rets: &[Type]) -
                 rets,
                 (Opcode::UmulOverflow | Opcode::SmulOverflow, &[I128, I128]),
                 (Opcode::Imul, &[I8X16, I8X16]),
-                // https://github.com/bytecodealliance/wasmtime/issues/5468
-                (Opcode::Smulhi | Opcode::Umulhi, &[I8, I8]),
                 // https://github.com/bytecodealliance/wasmtime/issues/4756
                 (Opcode::Udiv | Opcode::Sdiv, &[I128, I128]),
                 // https://github.com/bytecodealliance/wasmtime/issues/5474
                 (Opcode::Urem | Opcode::Srem, &[I128, I128]),
-                // https://github.com/bytecodealliance/wasmtime/issues/5466
-                (Opcode::Iabs, &[I128]),
                 // https://github.com/bytecodealliance/wasmtime/issues/3370
                 (
                     Opcode::Smin | Opcode::Umin | Opcode::Smax | Opcode::Umax,
@@ -614,8 +626,6 @@ fn valid_for_target(triple: &Triple, op: Opcode, args: &[Type], rets: &[Type]) -
                 (Opcode::Udiv | Opcode::Sdiv, &[I128, I128]),
                 // https://github.com/bytecodealliance/wasmtime/issues/5472
                 (Opcode::Urem | Opcode::Srem, &[I128, I128]),
-                // https://github.com/bytecodealliance/wasmtime/issues/5467
-                (Opcode::Iabs, &[I128]),
                 // https://github.com/bytecodealliance/wasmtime/issues/4313
                 (
                     Opcode::Smin | Opcode::Umin | Opcode::Smax | Opcode::Umax,
@@ -640,7 +650,8 @@ fn valid_for_target(triple: &Triple, op: Opcode, args: &[Type], rets: &[Type]) -
                         | Opcode::FcvtToUintSat
                         | Opcode::FcvtToSint
                         | Opcode::FcvtToSintSat,
-                    &[F32 | F64]
+                    &[F32 | F64],
+                    &[I128]
                 ),
                 // https://github.com/bytecodealliance/wasmtime/issues/4933
                 (
@@ -745,7 +756,7 @@ fn valid_for_target(triple: &Triple, op: Opcode, args: &[Type], rets: &[Type]) -
                 (
                     Opcode::FcvtToUintSat | Opcode::FcvtToSintSat,
                     &[F32 | F64],
-                    &[I8 | I16 | I128]
+                    &[I128]
                 ),
                 // https://github.com/bytecodealliance/wasmtime/issues/5528
                 (
@@ -753,9 +764,6 @@ fn valid_for_target(triple: &Triple, op: Opcode, args: &[Type], rets: &[Type]) -
                     &[I128],
                     &[F32 | F64]
                 ),
-                // https://github.com/bytecodealliance/wasmtime/issues/6104
-                (Opcode::Bitcast, &[I128], &[_]),
-                (Opcode::Bitcast, &[_], &[I128]),
                 // TODO
                 (
                     Opcode::SelectSpectreGuard,
@@ -785,6 +793,17 @@ static OPCODE_SIGNATURES: Lazy<Vec<OpcodeSignature>> = Lazy::new(|| {
         F32X4, F64X2, // SIMD Floats
     ];
 
+    // When this env variable is passed, we only generate instructions for the opcodes listed in
+    // the comma-separated list. This is useful for debugging, as it allows us to focus on a few
+    // specific opcodes.
+    let allowed_opcodes = std::env::var("FUZZGEN_ALLOWED_OPS").ok().map(|s| {
+        s.split(',')
+            .map(|s| s.trim())
+            .filter(|s| !s.is_empty())
+            .map(|s| Opcode::from_str(s).expect("Unrecoginzed opcode"))
+            .collect::<Vec<_>>()
+    });
+
     Opcode::all()
         .iter()
         .filter(|op| {
@@ -800,7 +819,7 @@ static OPCODE_SIGNATURES: Lazy<Vec<OpcodeSignature>> = Lazy::new(|| {
                 // Constants are generated outside of `generate_instructions`
                 Opcode::Iconst => false,
 
-                // TODO: extract_vector raises exceptions during return type generation becuase it
+                // TODO: extract_vector raises exceptions during return type generation because it
                 // uses dynamic vectors.
                 Opcode::ExtractVector => false,
 
@@ -869,9 +888,7 @@ static OPCODE_SIGNATURES: Lazy<Vec<OpcodeSignature>> = Lazy::new(|| {
                 (Opcode::Debugtrap),
                 (Opcode::Trap),
                 (Opcode::Trapz),
-                (Opcode::ResumableTrap),
                 (Opcode::Trapnz),
-                (Opcode::ResumableTrapnz),
                 (Opcode::CallIndirect, &[I32]),
                 (Opcode::FuncAddr),
                 (Opcode::X86Pshufb),
@@ -894,8 +911,6 @@ static OPCODE_SIGNATURES: Lazy<Vec<OpcodeSignature>> = Lazy::new(|| {
                 (Opcode::GetFramePointer),
                 (Opcode::GetStackPointer),
                 (Opcode::GetReturnAddress),
-                (Opcode::TableAddr),
-                (Opcode::Null),
                 (Opcode::X86Blendv),
                 (Opcode::IcmpImm),
                 (Opcode::X86Pmulhrsw),
@@ -919,8 +934,6 @@ static OPCODE_SIGNATURES: Lazy<Vec<OpcodeSignature>> = Lazy::new(|| {
                 (Opcode::IshlImm),
                 (Opcode::UshrImm),
                 (Opcode::SshrImm),
-                (Opcode::IsNull),
-                (Opcode::IsInvalid),
                 (Opcode::ScalarToVector),
                 (Opcode::X86Pmaddubsw),
                 (Opcode::X86Cvtt2dq),
@@ -1036,6 +1049,11 @@ static OPCODE_SIGNATURES: Lazy<Vec<OpcodeSignature>> = Lazy::new(|| {
                 (Opcode::FcvtFromSint, &[I32X4], &[F64X2]),
             )
         })
+        .filter(|(op, ..)| {
+            allowed_opcodes
+                .as_ref()
+                .map_or(true, |opcodes| opcodes.contains(op))
+        })
         .collect()
 });
 
@@ -1064,13 +1082,13 @@ fn inserter_for_format(fmt: InstructionFormat) -> OpcodeInserter {
         InstructionFormat::StackStore => insert_stack_store,
         InstructionFormat::Store => insert_load_store,
         InstructionFormat::StoreNoOffset => insert_load_store,
-        InstructionFormat::TableAddr => todo!(),
         InstructionFormat::Ternary => insert_opcode,
         InstructionFormat::TernaryImm8 => insert_ins_ext_lane,
         InstructionFormat::Trap => todo!(),
         InstructionFormat::Unary => insert_opcode,
         InstructionFormat::UnaryConst => insert_const,
         InstructionFormat::UnaryGlobalValue => todo!(),
+        InstructionFormat::UnaryIeee16 => insert_const,
         InstructionFormat::UnaryIeee32 => insert_const,
         InstructionFormat::UnaryIeee64 => insert_const,
         InstructionFormat::UnaryImm => insert_const,
@@ -1079,10 +1097,7 @@ fn inserter_for_format(fmt: InstructionFormat) -> OpcodeInserter {
         | InstructionFormat::Brif
         | InstructionFormat::Jump
         | InstructionFormat::MultiAry => {
-            panic!(
-                "Control-flow instructions should be handled by 'insert_terminator': {:?}",
-                fmt
-            )
+            panic!("Control-flow instructions should be handled by 'insert_terminator': {fmt:?}")
         }
     }
 }
@@ -1121,6 +1136,47 @@ enum BlockTerminatorKind {
     TailCallIndirect,
 }
 
+/// Alias Analysis Category
+///
+/// Our alias analysis pass supports 4 categories of accesses to distinguish
+/// different regions. The "Other" region is the general case, and is the default
+/// Although they have highly suggestive names there is no difference between any
+/// of the categories.
+///
+/// We assign each stack slot a category when we first generate them, and then
+/// ensure that all accesses to that stack slot are correctly tagged. We already
+/// ensure that memory accesses never cross stack slots, so there is no risk
+/// of a memory access being tagged with the wrong category.
+#[derive(Debug, PartialEq, Clone, Copy)]
+enum AACategory {
+    Other,
+    Heap,
+    Table,
+    VmCtx,
+}
+
+impl AACategory {
+    pub fn all() -> &'static [Self] {
+        &[
+            AACategory::Other,
+            AACategory::Heap,
+            AACategory::Table,
+            AACategory::VmCtx,
+        ]
+    }
+
+    pub fn update_memflags(&self, flags: &mut MemFlags) {
+        flags.set_alias_region(match self {
+            AACategory::Other => None,
+            AACategory::Heap => Some(AliasRegion::Heap),
+            AACategory::Table => Some(AliasRegion::Table),
+            AACategory::VmCtx => Some(AliasRegion::Vmctx),
+        })
+    }
+}
+
+pub type StackAlignment = StackSize;
+
 #[derive(Default)]
 struct Resources {
     vars: HashMap<Type, Vec<Variable>>,
@@ -1128,7 +1184,10 @@ struct Resources {
     blocks_without_params: Vec<Block>,
     block_terminators: Vec<BlockTerminator>,
     func_refs: Vec<(Signature, SigRef, FuncRef)>,
-    stack_slots: Vec<(StackSlot, StackSize)>,
+    /// This field is required to be sorted by stack slot size at all times.
+    /// We use this invariant when searching for stack slots with a given size.
+    /// See [FunctionGenerator::stack_slot_with_size]
+    stack_slots: Vec<(StackSlot, StackSize, StackAlignment, AACategory)>,
     usercalls: Vec<(UserExternalName, Signature)>,
     libcalls: Vec<LibCall>,
 }
@@ -1211,11 +1270,14 @@ where
     }
 
     /// Finds a stack slot with size of at least n bytes
-    fn stack_slot_with_size(&mut self, n: u32) -> Result<(StackSlot, StackSize)> {
+    fn stack_slot_with_size(
+        &mut self,
+        n: u32,
+    ) -> Result<(StackSlot, StackSize, StackAlignment, AACategory)> {
         let first = self
             .resources
             .stack_slots
-            .partition_point(|&(_slot, size)| size < n);
+            .partition_point(|&(_slot, size, _align, _category)| size < n);
         Ok(*self.u.choose(&self.resources.stack_slots[first..])?)
     }
 
@@ -1236,11 +1298,11 @@ where
         builder: &mut FunctionBuilder,
         min_size: u32,
         aligned: bool,
-    ) -> Result<(Value, u32)> {
+    ) -> Result<(Value, u32, AACategory)> {
         // TODO: Currently our only source of addresses is stack_addr, but we
         // should add global_value, symbol_value eventually
-        let (addr, available_size) = {
-            let (ss, slot_size) = self.stack_slot_with_size(min_size)?;
+        let (addr, available_size, category) = {
+            let (ss, slot_size, _align, category) = self.stack_slot_with_size(min_size)?;
 
             // stack_slot_with_size guarantees that slot_size >= min_size
             let max_offset = slot_size - min_size;
@@ -1252,7 +1314,7 @@ where
 
             let base_addr = builder.ins().stack_addr(I64, ss, offset as i32);
             let available_size = slot_size.saturating_sub(offset);
-            (base_addr, available_size)
+            (base_addr, available_size, category)
         };
 
         // TODO: Insert a bunch of amode opcodes here to modify the address!
@@ -1260,7 +1322,7 @@ where
         // Now that we have an address and a size, we just choose a random offset to return to the
         // caller. Preserving min_size bytes.
         let max_offset = available_size.saturating_sub(min_size);
-        Ok((addr, max_offset))
+        Ok((addr, max_offset, category))
     }
 
     // Generates an address and memflags for a load or store.
@@ -1300,7 +1362,11 @@ where
             flags.set_notrap();
         }
 
-        let (address, max_offset) = self.generate_load_store_address(builder, min_size, aligned)?;
+        let (address, max_offset, category) =
+            self.generate_load_store_address(builder, min_size, aligned)?;
+
+        // Set the Alias Analysis bits on the memflags
+        category.update_memflags(&mut flags);
 
         // Pick an offset to pass into the load/store.
         let offset = if aligned {
@@ -1326,14 +1392,19 @@ where
             DataValue::I8(i) => builder.ins().iconst(ty, i as u8 as i64),
             DataValue::I16(i) => builder.ins().iconst(ty, i as u16 as i64),
             DataValue::I32(i) => builder.ins().iconst(ty, i as u32 as i64),
-            DataValue::I64(i) => builder.ins().iconst(ty, i as i64),
+            DataValue::I64(i) => builder.ins().iconst(ty, i),
             DataValue::I128(i) => {
                 let hi = builder.ins().iconst(I64, (i >> 64) as i64);
                 let lo = builder.ins().iconst(I64, i as i64);
                 builder.ins().iconcat(lo, hi)
             }
+            DataValue::F16(f) => builder.ins().f16const(f),
             DataValue::F32(f) => builder.ins().f32const(f),
             DataValue::F64(f) => builder.ins().f64const(f),
+            DataValue::F128(f) => {
+                let handle = builder.func.dfg.constants.insert(f.into());
+                builder.ins().f128const(handle)
+            }
             DataValue::V128(bytes) => {
                 let data = bytes.to_vec().into();
                 let handle = builder.func.dfg.constants.insert(data);
@@ -1534,14 +1605,23 @@ where
     fn generate_stack_slots(&mut self, builder: &mut FunctionBuilder) -> Result<()> {
         for _ in 0..self.param(&self.config.static_stack_slots_per_function)? {
             let bytes = self.param(&self.config.static_stack_slot_size)? as u32;
-            let ss_data = StackSlotData::new(StackSlotKind::ExplicitSlot, bytes);
+            let alignment = self.param(&self.config.stack_slot_alignment_log2)? as u8;
+            let alignment_bytes = 1 << alignment;
+
+            let ss_data = StackSlotData::new(StackSlotKind::ExplicitSlot, bytes, alignment);
             let slot = builder.create_sized_stack_slot(ss_data);
-            self.resources.stack_slots.push((slot, bytes));
+
+            // Generate one Alias Analysis Category for each slot
+            let category = *self.u.choose(AACategory::all())?;
+
+            self.resources
+                .stack_slots
+                .push((slot, bytes, alignment_bytes, category));
         }
 
         self.resources
             .stack_slots
-            .sort_unstable_by_key(|&(_slot, bytes)| bytes);
+            .sort_unstable_by_key(|&(_slot, bytes, _align, _category)| bytes);
 
         Ok(())
     }
@@ -1554,7 +1634,7 @@ where
         let i64_zero = builder.ins().iconst(I64, 0);
         let i128_zero = builder.ins().uextend(I128, i64_zero);
 
-        for &(slot, init_size) in self.resources.stack_slots.iter() {
+        for &(slot, init_size, _align, category) in self.resources.stack_slots.iter() {
             let mut size = init_size;
 
             // Insert the largest available store for the remaining size.
@@ -1567,7 +1647,16 @@ where
                     sz if sz / 2 > 0 => (i16_zero, 2),
                     _ => (i8_zero, 1),
                 };
-                builder.ins().stack_store(val, slot, offset);
+                let addr = builder.ins().stack_addr(I64, slot, offset);
+
+                // Each stack slot has an associated category, that means we have to set the
+                // correct memflags for it. So we can't use `stack_store` directly.
+                let mut flags = MemFlags::new();
+                flags.set_notrap();
+                category.update_memflags(&mut flags);
+
+                builder.ins().store(flags, val, addr, 0);
+
                 size -= filled;
             }
         }
@@ -1803,6 +1892,14 @@ where
             let var = Variable::new(id);
             builder.declare_var(var, ty);
             builder.def_var(var, value);
+
+            // Randomly declare variables as needing a stack map.
+            // We limit these to only types that have fewer than 16 bytes
+            // since the stack map mechanism does not support larger types.
+            if ty.bytes() <= 16 && self.u.arbitrary()? {
+                builder.declare_var_needs_stack_map(var);
+            }
+
             self.resources
                 .vars
                 .entry(ty)
diff --git a/cranelift/fuzzgen/src/lib.rs b/cranelift/fuzzgen/src/lib.rs
index d71658182492..675eb2a61b79 100644
--- a/cranelift/fuzzgen/src/lib.rs
+++ b/cranelift/fuzzgen/src/lib.rs
@@ -4,9 +4,9 @@ use crate::settings::{Flags, OptLevel};
 use anyhow::Result;
 use arbitrary::{Arbitrary, Unstructured};
 use cranelift::codegen::data_value::DataValue;
-use cranelift::codegen::ir::{types::*, UserExternalName, UserFuncName};
 use cranelift::codegen::ir::{Function, LibCall};
-use cranelift::codegen::isa::{self, Builder};
+use cranelift::codegen::ir::{UserExternalName, UserFuncName};
+use cranelift::codegen::isa::Builder;
 use cranelift::codegen::Context;
 use cranelift::prelude::isa::{OwnedTargetIsa, TargetIsa};
 use cranelift::prelude::settings::SettingKind;
@@ -98,7 +98,7 @@ where
         Ok(inputs)
     }
 
-    fn run_func_passes(&mut self, func: Function) -> Result<Function> {
+    fn run_func_passes(&mut self, func: Function, isa: &dyn TargetIsa) -> Result<Function> {
         // Do a NaN Canonicalization pass on the generated function.
         //
         // Both IEEE754 and the Wasm spec are somewhat loose about what is allowed
@@ -115,7 +115,7 @@ where
         // the interpreter won't get that version, so call that pass manually here.
 
         let mut ctx = Context::for_function(func);
-        // Assume that we are generating this function for the current ISA.
+
         // We disable the verifier here, since if it fails it prevents a test case from
         // being generated and formatted by `cargo fuzz fmt`.
         // We run the verifier before compiling the code, so it always gets verified.
@@ -125,11 +125,13 @@ where
             builder
         });
 
-        let isa = builder_with_options(false)
-            .expect("Unable to build a TargetIsa for the current host")
+        // Create a new TargetISA from the given ISA, this ensures that we copy all ISA
+        // flags, which may have an effect on the code generated by the passes below.
+        let isa = Builder::from_target_isa(isa)
             .finish(flags)
             .expect("Failed to build TargetISA");
 
+        // Finally run the NaN canonicalization pass
         ctx.canonicalize_nans(isa.as_ref())
             .expect("Failed NaN canonicalization pass");
 
@@ -156,7 +158,7 @@ where
         let func = FunctionGenerator::new(
             &mut self.u,
             &self.config,
-            isa,
+            isa.clone(),
             name,
             sig,
             usercalls,
@@ -164,7 +166,7 @@ where
         )
         .generate()?;
 
-        self.run_func_passes(func)
+        self.run_func_passes(func, &*isa)
     }
 
     /// Generate a random set of cranelift flags.
@@ -173,7 +175,7 @@ where
         let mut builder = settings::builder();
 
         let opt = self.u.choose(OptLevel::all())?;
-        builder.set("opt_level", &format!("{}", opt)[..])?;
+        builder.set("opt_level", &format!("{opt}")[..])?;
 
         // Boolean flags
         // TODO: enable_pinned_reg does not work with our current trampolines. See: #4376
@@ -200,7 +202,7 @@ where
                 .map(|&(num, denum)| self.u.ratio(num, denum))
                 .unwrap_or_else(|| bool::arbitrary(self.u))?;
 
-            let value = format!("{}", enabled);
+            let value = format!("{enabled}");
             builder.set(flag_name, value.as_str())?;
         }
 
@@ -220,14 +222,14 @@ where
             let size = self
                 .u
                 .int_in_range(self.config.stack_probe_size_log2.clone())?;
-            builder.set("probestack_size_log2", &format!("{}", size))?;
+            builder.set("probestack_size_log2", &format!("{size}"))?;
         }
 
         // Generate random basic block padding
         let bb_padding = self
             .u
             .int_in_range(self.config.bb_padding_log2_size.clone())?;
-        builder.set("bb_padding_log2_minus_one", &format!("{}", bb_padding))?;
+        builder.set("bb_padding_log2_minus_one", &format!("{bb_padding}"))?;
 
         // Fixed settings
 
@@ -287,7 +289,7 @@ where
             IsaFlagGen::Host => builder_with_options(true)
                 .expect("Unable to build a TargetIsa for the current host"),
         };
-        // Cranelift has a somwhat weird API for this, but we need to build the final `TargetIsa` to be able
+        // Cranelift has a somewhat weird API for this, but we need to build the final `TargetIsa` to be able
         // to extract the values for the ISA flags. We need that to use the `string_value()` that formats
         // the values so that we can pass it into the builder again.
         let max_isa = max_builder.finish(Flags::new(settings::builder()))?;
diff --git a/cranelift/fuzzgen/src/passes/fcvt.rs b/cranelift/fuzzgen/src/passes/fcvt.rs
index 106c83e423f8..fd7ed05d347f 100644
--- a/cranelift/fuzzgen/src/passes/fcvt.rs
+++ b/cranelift/fuzzgen/src/passes/fcvt.rs
@@ -1,4 +1,4 @@
-use crate::{FuzzGen, Type};
+use crate::FuzzGen;
 use anyhow::Result;
 use cranelift::codegen::cursor::{Cursor, FuncCursor};
 use cranelift::codegen::ir::{Function, Inst, Opcode};
diff --git a/cranelift/fuzzgen/src/print.rs b/cranelift/fuzzgen/src/print.rs
index 238f92fcffa2..e4b18f946380 100644
--- a/cranelift/fuzzgen/src/print.rs
+++ b/cranelift/fuzzgen/src/print.rs
@@ -1,6 +1,6 @@
 use cranelift::codegen::data_value::DataValue;
 use cranelift::codegen::ir::Function;
-use cranelift::prelude::settings::{self, SettingKind};
+use cranelift::prelude::settings::SettingKind;
 use cranelift::prelude::*;
 use std::fmt;
 
@@ -77,7 +77,7 @@ impl<'a> fmt::Debug for PrintableTestCase<'a> {
         // Print the functions backwards, so that the main function is printed last
         // and near the test inputs for run test cases.
         for func in self.functions.iter().rev() {
-            writeln!(f, "{}\n", func)?;
+            writeln!(f, "{func}\n")?;
         }
 
         if !self.inputs.is_empty() {
@@ -93,20 +93,20 @@ impl<'a> fmt::Debug for PrintableTestCase<'a> {
             let placeholder_output = returns
                 .iter()
                 .map(|param| DataValue::read_from_slice_ne(&[0; 16][..], param.value_type))
-                .map(|val| format!("{}", val))
+                .map(|val| format!("{val}"))
                 .collect::<Vec<_>>()
                 .join(", ");
 
             // If we have no output, we don't need the == condition
             let test_condition = match returns.len() {
                 0 => String::new(),
-                1 => format!(" == {}", placeholder_output),
-                _ => format!(" == [{}]", placeholder_output),
+                1 => format!(" == {placeholder_output}"),
+                _ => format!(" == [{placeholder_output}]"),
             };
 
             let args = input
                 .iter()
-                .map(|val| format!("{}", val))
+                .map(|val| format!("{val}"))
                 .collect::<Vec<_>>()
                 .join(", ");
 
diff --git a/cranelift/interpreter/Cargo.toml b/cranelift/interpreter/Cargo.toml
index 01da71ed791e..c914823974a4 100644
--- a/cranelift/interpreter/Cargo.toml
+++ b/cranelift/interpreter/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "cranelift-interpreter"
-version = "0.101.0"
+version = "0.112.0"
 authors = ["The Cranelift Project Developers"]
 description = "Interpret Cranelift IR"
 repository = "https://github.com/bytecodealliance/wasmtime"
@@ -9,6 +9,10 @@ categories = ["no-std"]
 license = "Apache-2.0 WITH LLVM-exception"
 readme = "README.md"
 edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
 
 [dependencies]
 cranelift-codegen = { workspace = true }
diff --git a/cranelift/interpreter/src/address.rs b/cranelift/interpreter/src/address.rs
index 126945517e60..f782a7a236b4 100644
--- a/cranelift/interpreter/src/address.rs
+++ b/cranelift/interpreter/src/address.rs
@@ -9,7 +9,7 @@
 //! "region" refers to the type of memory that this address points to.
 //! "entry" refers to which instance of this memory the address points to (e.g table1 would be
 //! "entry" 1 of a `Table` region address).
-//! The last field is the "offset", which refers to the offset within the entry.  
+//! The last field is the "offset", which refers to the offset within the entry.
 //!
 //! The address has the "region" field as the 2 most significant bits. The following bits
 //! are the "entry" field, the amount of "entry" bits depends on the size of the address and
@@ -35,7 +35,6 @@
 use crate::state::MemoryError;
 use cranelift_codegen::data_value::DataValue;
 use cranelift_codegen::ir::{types, Type};
-use std::convert::TryFrom;
 
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub enum AddressSize {
@@ -243,7 +242,6 @@ impl From<u64> for AddressFunctionEntry {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::convert::TryInto;
 
     #[test]
     fn address_region_roundtrip_encode_decode() {
diff --git a/cranelift/interpreter/src/environment.rs b/cranelift/interpreter/src/environment.rs
index ab10dc9dba05..63cd61d8e317 100644
--- a/cranelift/interpreter/src/environment.rs
+++ b/cranelift/interpreter/src/environment.rs
@@ -10,7 +10,7 @@ pub struct FunctionStore<'a> {
     function_names: HashMap<String, FuncIndex>,
 }
 
-/// An opaque reference to a [`Function`](Function) stored in the [FunctionStore].
+/// An opaque reference to a [`Function`] stored in the [FunctionStore].
 #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct FuncIndex(u32);
 entity_impl!(FuncIndex, "fn");
diff --git a/cranelift/interpreter/src/frame.rs b/cranelift/interpreter/src/frame.rs
index c675168231eb..d503b6a32196 100644
--- a/cranelift/interpreter/src/frame.rs
+++ b/cranelift/interpreter/src/frame.rs
@@ -38,7 +38,7 @@ impl<'a> Frame<'a> {
         &self
             .registers
             .get(name.index())
-            .unwrap_or_else(|| panic!("unknown value: {}", name))
+            .unwrap_or_else(|| panic!("unknown value: {name}"))
             .as_ref()
             .or_else(|| {
                 // We couldn't find the `name` value directly in `registers`, but it is still
@@ -53,10 +53,10 @@ impl<'a> Frame<'a> {
                 let alias = self.function.dfg.resolve_aliases(name);
                 self.registers
                     .get(alias.index())
-                    .unwrap_or_else(|| panic!("unknown value: {}", alias))
+                    .unwrap_or_else(|| panic!("unknown value: {alias}"))
                     .as_ref()
             })
-            .unwrap_or_else(|| panic!("empty slot: {}", name))
+            .unwrap_or_else(|| panic!("empty slot: {name}"))
     }
 
     /// Retrieve multiple SSA references; see `get`.
@@ -110,7 +110,6 @@ impl<'a> Frame<'a> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use cranelift_codegen::data_value::DataValue;
     use cranelift_codegen::ir::immediates::{Ieee32, Ieee64};
     use cranelift_codegen::ir::InstBuilder;
     use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext};
diff --git a/cranelift/interpreter/src/instruction.rs b/cranelift/interpreter/src/instruction.rs
index 993584ce17aa..b3c12997c213 100644
--- a/cranelift/interpreter/src/instruction.rs
+++ b/cranelift/interpreter/src/instruction.rs
@@ -25,7 +25,7 @@ impl<'a> DfgInstructionContext<'a> {
 
 impl InstructionContext for DfgInstructionContext<'_> {
     fn data(&self) -> InstructionData {
-        self.1.insts[self.0].clone()
+        self.1.insts[self.0]
     }
 
     fn args(&self) -> &[Value] {
diff --git a/cranelift/interpreter/src/interpreter.rs b/cranelift/interpreter/src/interpreter.rs
index c685f0df1b1f..01ad602467b8 100644
--- a/cranelift/interpreter/src/interpreter.rs
+++ b/cranelift/interpreter/src/interpreter.rs
@@ -16,7 +16,6 @@ use cranelift_codegen::ir::{
 };
 use log::trace;
 use smallvec::SmallVec;
-use std::convert::TryFrom;
 use std::fmt::Debug;
 use std::iter;
 use thiserror::Error;
@@ -127,7 +126,7 @@ impl<'a> Interpreter<'a> {
                         }
                         ControlFlow::Trap(trap) => return Ok(ControlFlow::Trap(trap)),
                         cf => {
-                            panic!("invalid control flow after call: {:?}", cf)
+                            panic!("invalid control flow after call: {cf:?}")
                         }
                     }
                 }
@@ -138,7 +137,7 @@ impl<'a> Interpreter<'a> {
                         ControlFlow::Return(rets) => Ok(ControlFlow::Return(rets)),
                         ControlFlow::Trap(trap) => Ok(ControlFlow::Trap(trap)),
                         cf => {
-                            panic!("invalid control flow after return_call: {:?}", cf)
+                            panic!("invalid control flow after return_call: {cf:?}")
                         }
                     };
                 }
@@ -332,7 +331,11 @@ impl<'a> State<'a> for InterpreterState<'a> {
         let src = match addr.region {
             AddressRegion::Stack => {
                 if addr_end > self.stack.len() {
-                    return Err(MemoryError::OutOfBoundsLoad { addr, load_size });
+                    return Err(MemoryError::OutOfBoundsLoad {
+                        addr,
+                        load_size,
+                        mem_flags,
+                    });
                 }
 
                 &self.stack[addr_start..addr_end]
@@ -364,7 +367,11 @@ impl<'a> State<'a> for InterpreterState<'a> {
         let dst = match addr.region {
             AddressRegion::Stack => {
                 if addr_end > self.stack.len() {
-                    return Err(MemoryError::OutOfBoundsStore { addr, store_size });
+                    return Err(MemoryError::OutOfBoundsStore {
+                        addr,
+                        store_size,
+                        mem_flags,
+                    });
                 }
 
                 &mut self.stack[addr_start..addr_end]
@@ -556,7 +563,6 @@ mod tests {
     use super::*;
     use crate::step::CraneliftTrap;
     use cranelift_codegen::ir::immediates::Ieee32;
-    use cranelift_codegen::ir::TrapCode;
     use cranelift_reader::parse_functions;
     use smallvec::smallvec;
 
@@ -622,7 +628,7 @@ mod tests {
 
         match result {
             ControlFlow::Trap(CraneliftTrap::User(TrapCode::IntegerOverflow)) => {}
-            _ => panic!("Unexpected ControlFlow: {:?}", result),
+            _ => panic!("Unexpected ControlFlow: {result:?}"),
         }
     }
 
@@ -686,7 +692,7 @@ mod tests {
             .call_by_name("%test", &[]);
         match result {
             Err(InterpreterError::FuelExhausted) => {}
-            _ => panic!("Expected Err(FuelExhausted), but got {:?}", result),
+            _ => panic!("Expected Err(FuelExhausted), but got {result:?}"),
         }
 
         // With 3 fuel, we should be able to execute the return instruction, and complete the test
diff --git a/cranelift/interpreter/src/state.rs b/cranelift/interpreter/src/state.rs
index 5c5d7a685be3..7b9c6b5baa43 100644
--- a/cranelift/interpreter/src/state.rs
+++ b/cranelift/interpreter/src/state.rs
@@ -16,16 +16,16 @@ use thiserror::Error;
 /// all of the ways a Cranelift interpreter can interact with its virtual state. This makes it
 /// possible to use the [Interpreter](crate::interpreter::Interpreter) in a range of situations:
 /// - when interpretation needs to happen in a way isolated from the host a state which keeps a
-/// stack and bound checks memory accesses can be used, like
-/// [InterpreterState](crate::interpreter::InterpreterState).
+///   stack and bound checks memory accesses can be used, like
+///   [InterpreterState](crate::interpreter::InterpreterState).
 /// - when interpretation needs to have access to the host a state which allows direct access to the
-/// host memory and native functions can be used.
+///   host memory and native functions can be used.
 pub trait State<'a> {
     /// Retrieve a reference to a [Function].
     fn get_function(&self, func_ref: FuncRef) -> Option<&'a Function>;
     /// Retrieve a reference to the currently executing [Function].
     fn get_current_function(&self) -> &'a Function;
-    /// Retrieve the handler callback for a [LibCall](cranelift_codegen::ir::LibCall)
+    /// Retrieve the handler callback for a [LibCall]
     fn get_libcall_handler(&self) -> LibCallHandler;
 
     /// Record that an interpreter has called into a new [Function].
@@ -125,9 +125,17 @@ pub enum MemoryError {
     #[error("Requested an offset of {offset} but max was {max}")]
     InvalidOffset { offset: u64, max: u64 },
     #[error("Load of {load_size} bytes is larger than available size at address {addr:?}")]
-    OutOfBoundsLoad { addr: Address, load_size: usize },
+    OutOfBoundsLoad {
+        addr: Address,
+        load_size: usize,
+        mem_flags: MemFlags,
+    },
     #[error("Store of {store_size} bytes is larger than available size at address {addr:?}")]
-    OutOfBoundsStore { addr: Address, store_size: usize },
+    OutOfBoundsStore {
+        addr: Address,
+        store_size: usize,
+        mem_flags: MemFlags,
+    },
     #[error("Load of {load_size} bytes is misaligned at address {addr:?}")]
     MisalignedLoad { addr: Address, load_size: usize },
     #[error("Store of {store_size} bytes is misaligned at address {addr:?}")]
diff --git a/cranelift/interpreter/src/step.rs b/cranelift/interpreter/src/step.rs
index 8f437587e11d..ed5e6177293a 100644
--- a/cranelift/interpreter/src/step.rs
+++ b/cranelift/interpreter/src/step.rs
@@ -12,7 +12,6 @@ use cranelift_codegen::ir::{
 };
 use log::trace;
 use smallvec::{smallvec, SmallVec};
-use std::convert::{TryFrom, TryInto};
 use std::fmt::Debug;
 use std::ops::RangeFrom;
 use thiserror::Error;
@@ -59,7 +58,7 @@ where
         if ctrl_ty.is_invalid() {
             String::new()
         } else {
-            format!(".{}", ctrl_ty)
+            format!(".{ctrl_ty}")
         }
     );
 
@@ -84,18 +83,19 @@ where
     let imm = || -> DataValue {
         DataValue::from(match inst {
             InstructionData::UnaryConst {
-                constant_handle, ..
+                constant_handle,
+                opcode,
             } => {
                 let buffer = state
                     .get_current_function()
                     .dfg
                     .constants
-                    .get(constant_handle.clone())
-                    .as_slice();
-                match ctrl_ty.bytes() {
-                    16 => DataValue::V128(buffer.try_into().expect("a 16-byte data buffer")),
-                    8 => DataValue::V64(buffer.try_into().expect("an 8-byte data buffer")),
-                    length => panic!("unexpected UnaryConst buffer length {}", length),
+                    .get(constant_handle);
+                match (ctrl_ty.bytes(), opcode) {
+                    (_, Opcode::F128const) => DataValue::F128(buffer.try_into().expect("a 16-byte data buffer")),
+                    (16, Opcode::Vconst) => DataValue::V128(buffer.as_slice().try_into().expect("a 16-byte data buffer")),
+                    (8, Opcode::Vconst) => DataValue::V64(buffer.as_slice().try_into().expect("an 8-byte data buffer")),
+                    (length, opcode) => panic!("unexpected UnaryConst controlling type size {length} for opcode {opcode:?}"),
                 }
             }
             InstructionData::Shuffle { imm, .. } => {
@@ -116,13 +116,14 @@ where
             InstructionData::BinaryImm8 { imm, .. } | InstructionData::TernaryImm8 { imm, .. } => {
                 DataValue::from(imm as i8) // Note the switch from unsigned to signed.
             }
+            // 16-bit
+            InstructionData::UnaryIeee16 { imm, .. } => DataValue::from(imm),
             // 32-bit
             InstructionData::UnaryIeee32 { imm, .. } => DataValue::from(imm),
             InstructionData::Load { offset, .. }
             | InstructionData::Store { offset, .. }
             | InstructionData::StackLoad { offset, .. }
-            | InstructionData::StackStore { offset, .. }
-            | InstructionData::TableAddr { offset, .. } => DataValue::from(offset),
+            | InstructionData::StackStore { offset, .. } => DataValue::from(offset),
             // 64-bit.
             InstructionData::UnaryImm { imm, .. }
             | InstructionData::BinaryImm64 { imm, .. }
@@ -162,8 +163,12 @@ where
         MemoryError::InvalidAddressType(_) => TrapCode::HeapOutOfBounds,
         MemoryError::InvalidOffset { .. } => TrapCode::HeapOutOfBounds,
         MemoryError::InvalidEntry { .. } => TrapCode::HeapOutOfBounds,
-        MemoryError::OutOfBoundsStore { .. } => TrapCode::HeapOutOfBounds,
-        MemoryError::OutOfBoundsLoad { .. } => TrapCode::HeapOutOfBounds,
+        MemoryError::OutOfBoundsStore { mem_flags, .. } => mem_flags
+            .trap_code()
+            .expect("store with notrap flag should not trap"),
+        MemoryError::OutOfBoundsLoad { mem_flags, .. } => mem_flags
+            .trap_code()
+            .expect("load with notrap flag should not trap"),
         MemoryError::MisalignedLoad { .. } => TrapCode::HeapMisaligned,
         MemoryError::MisalignedStore { .. } => TrapCode::HeapMisaligned,
     };
@@ -351,10 +356,8 @@ where
         }
         Opcode::Trap => ControlFlow::Trap(CraneliftTrap::User(trap_code())),
         Opcode::Debugtrap => ControlFlow::Trap(CraneliftTrap::Debug),
-        Opcode::ResumableTrap => ControlFlow::Trap(CraneliftTrap::Resumable),
         Opcode::Trapz => trap_when(!arg(0).into_bool()?, CraneliftTrap::User(trap_code())),
         Opcode::Trapnz => trap_when(arg(0).into_bool()?, CraneliftTrap::User(trap_code())),
-        Opcode::ResumableTrapnz => trap_when(arg(0).into_bool()?, CraneliftTrap::Resumable),
         Opcode::Return => ControlFlow::Return(args()),
         Opcode::Call | Opcode::ReturnCall => {
             let func_ref = if let InstructionData::Call { func_ref, .. } = inst {
@@ -551,33 +554,12 @@ where
             state.set_pinned_reg(arg0);
             ControlFlow::Continue
         }
-        Opcode::TableAddr => {
-            if let InstructionData::TableAddr { table, offset, .. } = inst {
-                let table = &state.get_current_function().tables[table];
-                let base = state.resolve_global_value(table.base_gv)?;
-                let bound = state.resolve_global_value(table.bound_gv)?;
-                let index_ty = table.index_type;
-                let element_size = DataValue::int(u64::from(table.element_size) as i128, index_ty)?;
-                let inst_offset = DataValue::int(i32::from(offset) as i128, index_ty)?;
-
-                let byte_offset = arg(0).mul(element_size.clone())?.add(inst_offset)?;
-                let bound_bytes = bound.mul(element_size)?;
-                if byte_offset > bound_bytes {
-                    return Ok(ControlFlow::Trap(CraneliftTrap::User(
-                        TrapCode::HeapOutOfBounds,
-                    )));
-                }
-
-                assign(base.add(byte_offset)?)
-            } else {
-                unreachable!()
-            }
-        }
         Opcode::Iconst => assign(DataValueExt::int(imm().into_int_signed()?, ctrl_ty)?),
+        Opcode::F16const => assign(imm()),
         Opcode::F32const => assign(imm()),
         Opcode::F64const => assign(imm()),
+        Opcode::F128const => assign(imm()),
         Opcode::Vconst => assign(imm()),
-        Opcode::Null => unimplemented!("Null"),
         Opcode::Nop => ControlFlow::Continue,
         Opcode::Select | Opcode::SelectSpectreGuard => choose(arg(0).into_bool()?, arg(1), arg(2)),
         Opcode::Bitselect => assign(bitselect(arg(0), arg(1), arg(2))?),
@@ -890,8 +872,6 @@ where
         Opcode::Floor => unary(DataValueExt::floor, arg(0))?,
         Opcode::Trunc => unary(DataValueExt::trunc, arg(0))?,
         Opcode::Nearest => unary(DataValueExt::nearest, arg(0))?,
-        Opcode::IsNull => unimplemented!("IsNull"),
-        Opcode::IsInvalid => unimplemented!("IsInvalid"),
         Opcode::Bitcast | Opcode::ScalarToVector => {
             let input_ty = inst_context.type_of(inst_context.args()[0]).unwrap();
             let lanes = &if input_ty.is_vector() {
@@ -1075,7 +1055,7 @@ where
             let overflow = if is_signed {
                 x < (min as i128) || x > (max as i128)
             } else {
-                x < 0 || (x as u128) > (max as u128)
+                x < 0 || (x as u128) > max
             };
             // bounds check
             if overflow {
@@ -1102,7 +1082,7 @@ where
                         x
                     } else {
                         let x = if x < 0 { 0 } else { x };
-                        let x = u128::min(x as u128, max as u128);
+                        let x = u128::min(x as u128, max);
                         x as i128
                     };
 
@@ -1303,6 +1283,7 @@ where
         Opcode::X86Pmulhrsw => unimplemented!("X86Pmulhrsw"),
         Opcode::X86Pmaddubsw => unimplemented!("X86Pmaddubsw"),
         Opcode::X86Cvtt2dq => unimplemented!("X86Cvtt2dq"),
+        Opcode::StackSwitch => unimplemented!("StackSwitch"),
     })
 }
 
@@ -1350,8 +1331,6 @@ pub enum CraneliftTrap {
     User(TrapCode),
     #[error("user debug")]
     Debug,
-    #[error("resumable")]
-    Resumable,
 }
 
 /// Compare two values using the given integer condition `code`.
@@ -1443,7 +1422,7 @@ pub(crate) fn extractlanes(
 
     let iterations = match lane_type {
         types::I8 => 1,
-        types::I16 => 2,
+        types::I16 | types::F16 => 2,
         types::I32 | types::F32 => 4,
         types::I64 | types::F64 => 8,
         _ => unimplemented!("vectors with lanes wider than 64-bits are currently unsupported."),
@@ -1482,7 +1461,7 @@ fn vectorizelanes_all(x: &[DataValue], vector_type: types::Type) -> ValueResult<
     let lane_type = vector_type.lane_type();
     let iterations = match lane_type {
         types::I8 => 1,
-        types::I16 => 2,
+        types::I16 | types::F16 => 2,
         types::I32 | types::F32 => 4,
         types::I64 | types::F64 => 8,
         _ => unimplemented!("vectors with lanes wider than 64-bits are currently unsupported."),
diff --git a/cranelift/interpreter/src/value.rs b/cranelift/interpreter/src/value.rs
index 49a6bfe7a226..bfb4cace49f4 100644
--- a/cranelift/interpreter/src/value.rs
+++ b/cranelift/interpreter/src/value.rs
@@ -1,10 +1,12 @@
 //! The [DataValueExt] trait is an extension trait for [DataValue]. It provides a lot of functions
 //! used by the rest of the interpreter.
 
-use core::convert::TryFrom;
+#![allow(trivial_numeric_casts)]
+
 use core::fmt::{self, Display, Formatter};
+use core::ops::Neg;
 use cranelift_codegen::data_value::{DataValue, DataValueCastFailure};
-use cranelift_codegen::ir::immediates::{Ieee32, Ieee64};
+use cranelift_codegen::ir::immediates::{Ieee128, Ieee16, Ieee32, Ieee64};
 use cranelift_codegen::ir::{types, Type};
 use thiserror::Error;
 
@@ -317,7 +319,7 @@ impl DataValueExt for DataValue {
 
     fn is_float(&self) -> bool {
         match self {
-            DataValue::F32(_) | DataValue::F64(_) => true,
+            DataValue::F16(_) | DataValue::F32(_) | DataValue::F64(_) | DataValue::F128(_) => true,
             _ => false,
         }
     }
@@ -398,10 +400,14 @@ impl DataValueExt for DataValue {
                 (val, ty) if val.ty().is_int() && ty.is_int() => {
                     DataValue::from_integer(val.into_int_signed()?, ty)?
                 }
+                (DataValue::I16(n), types::F16) => DataValue::F16(Ieee16::with_bits(n as u16)),
                 (DataValue::I32(n), types::F32) => DataValue::F32(f32::from_bits(n as u32).into()),
                 (DataValue::I64(n), types::F64) => DataValue::F64(f64::from_bits(n as u64).into()),
+                (DataValue::I128(n), types::F128) => DataValue::F128(Ieee128::with_bits(n as u128)),
+                (DataValue::F16(n), types::I16) => DataValue::I16(n.bits() as i16),
                 (DataValue::F32(n), types::I32) => DataValue::I32(n.bits() as i32),
                 (DataValue::F64(n), types::I64) => DataValue::I64(n.bits() as i64),
+                (DataValue::F128(n), types::I128) => DataValue::I128(n.bits() as i128),
                 (DataValue::F32(n), types::F64) => DataValue::F64((n.as_f32() as f64).into()),
                 (dv, t) if (t.is_int() || t.is_float()) && dv.ty() == t => dv,
                 (dv, _) => unimplemented!("conversion: {} -> {:?}", dv.ty(), kind),
@@ -501,8 +507,10 @@ impl DataValueExt for DataValue {
             DataValue::I32(f) => Ok(*f == 0),
             DataValue::I64(f) => Ok(*f == 0),
             DataValue::I128(f) => Ok(*f == 0),
+            DataValue::F16(f) => Ok(f.is_zero()),
             DataValue::F32(f) => Ok(f.is_zero()),
             DataValue::F64(f) => Ok(f.is_zero()),
+            DataValue::F128(f) => Ok(f.is_zero()),
             DataValue::V64(_) | DataValue::V128(_) => {
                 Err(ValueError::InvalidType(ValueTypeClass::Float, self.ty()))
             }
@@ -793,12 +801,11 @@ impl DataValueExt for DataValue {
             DataValue::I128(a) => DataValue::I128(!a),
             DataValue::F32(a) => DataValue::F32(!a),
             DataValue::F64(a) => DataValue::F64(!a),
-            DataValue::V128(a) => {
-                let mut a2 = a.clone();
-                for a in a2.iter_mut() {
-                    *a = !*a;
+            DataValue::V128(mut a) => {
+                for byte in a.iter_mut() {
+                    *byte = !*byte;
                 }
-                DataValue::V128(a2)
+                DataValue::V128(a)
             }
             _ => unimplemented!(),
         })
diff --git a/cranelift/isle/docs/language-reference.md b/cranelift/isle/docs/language-reference.md
index 8f0f346c159b..112935aac0ce 100644
--- a/cranelift/isle/docs/language-reference.md
+++ b/cranelift/isle/docs/language-reference.md
@@ -27,7 +27,7 @@ instructions. For example:
   immediate.
 
 One could write something like the following in ISLE (simplified from
-the real code [here](../codegen/src/isa/x64/lower.isle)):
+the real code [here](https://github.com/bytecodealliance/wasmtime/blob/main/cranelift/codegen/src/isa/x64/lower.isle)):
 
 ```lisp
 ;; Add two registers.
@@ -568,7 +568,7 @@ functions).
 
 The universe of types is very simple: there are *primitives*, which
 can be integers or symbolic constants (imported from the Rust
-embedding), and *enums*, which correspond direclty to Rust enums with
+embedding), and *enums*, which correspond directly to Rust enums with
 variants that have named fields. There is no subtyping. Some examples
 of type definitions are:
 
diff --git a/cranelift/isle/fuzz/Cargo.toml b/cranelift/isle/fuzz/Cargo.toml
index 086257bff6dc..9a2b073d714c 100644
--- a/cranelift/isle/fuzz/Cargo.toml
+++ b/cranelift/isle/fuzz/Cargo.toml
@@ -4,6 +4,7 @@ version = "0.0.0"
 authors = ["Automatically generated"]
 publish = false
 edition.workspace = true
+rust-version.workspace = true
 
 [package.metadata]
 cargo-fuzz = true
diff --git a/cranelift/isle/fuzz/fuzz_targets/compile.rs b/cranelift/isle/fuzz/fuzz_targets/compile.rs
index b98a5a37b5a7..3150cfab179c 100644
--- a/cranelift/isle/fuzz/fuzz_targets/compile.rs
+++ b/cranelift/isle/fuzz/fuzz_targets/compile.rs
@@ -1,12 +1,14 @@
 #![no_main]
 
+use std::sync::Arc;
+
+use cranelift_isle::files::Files;
 use libfuzzer_sys::fuzz_target;
-use std::default::Default;
 
-fuzz_target!(|s: &str| {
+fuzz_target!(|src: &str| {
     let _ = env_logger::try_init();
 
-    let lexer = cranelift_isle::lexer::Lexer::from_str(s, "fuzz-input.isle");
+    let lexer = cranelift_isle::lexer::Lexer::new(0, src);
     log::debug!("lexer = {:?}", lexer);
     let lexer = match lexer {
         Ok(l) => l,
@@ -20,7 +22,12 @@ fuzz_target!(|s: &str| {
         Err(_) => return,
     };
 
-    let code = cranelift_isle::compile::compile(&defs, &Default::default());
+    let files = Arc::new(Files::from_names_and_contents([(
+        "fuzz-input.isle".to_string(),
+        src.to_string(),
+    )]));
+
+    let code = cranelift_isle::compile::compile(files, &defs, &Default::default());
     log::debug!("code = {:?}", code);
     let code = match code {
         Ok(c) => c,
diff --git a/cranelift/isle/isle/Cargo.toml b/cranelift/isle/isle/Cargo.toml
index db802bf0f06d..629853ef1421 100644
--- a/cranelift/isle/isle/Cargo.toml
+++ b/cranelift/isle/isle/Cargo.toml
@@ -2,15 +2,24 @@
 authors = ["The Cranelift Project Developers"]
 description = "ISLE: Instruction Selection and Lowering Expressions. A domain-specific language for instruction selection in Cranelift."
 edition.workspace = true
+rust-version.workspace = true
 license = "Apache-2.0 WITH LLVM-exception"
 name = "cranelift-isle"
 readme = "../README.md"
 repository = "https://github.com/bytecodealliance/wasmtime/tree/main/cranelift/isle"
-version = "0.101.0"
+version = "0.112.0"
+
+[[test]]
+name = "printer_tests"
+required-features = ["printer"]
+
+[lints]
+workspace = true
 
 [dependencies]
 codespan-reporting = { version = "0.11.1", optional = true }
 log = { workspace = true, optional = true }
+pretty = { version = "0.12", optional = true }
 
 [dev-dependencies]
 tempfile = "3"
@@ -20,3 +29,4 @@ default = []
 
 logging = ["log"]
 fancy-errors = ["codespan-reporting"]
+printer = ["pretty"]
diff --git a/cranelift/isle/isle/build.rs b/cranelift/isle/isle/build.rs
index 96aa9ec06d44..8f600051c16a 100644
--- a/cranelift/isle/isle/build.rs
+++ b/cranelift/isle/isle/build.rs
@@ -1,4 +1,4 @@
-use std::fmt::Write;
+use std::{fmt::Write, path::PathBuf};
 
 fn main() {
     println!("cargo:rerun-if-changed=build.rs");
@@ -8,6 +8,11 @@ fn main() {
         std::env::var_os("OUT_DIR").expect("The OUT_DIR environment variable must be set"),
     );
 
+    isle_tests(&out_dir);
+    isle_printer_tests(&out_dir);
+}
+
+fn isle_tests(out_dir: &std::path::PathBuf) {
     let mut out = String::new();
 
     emit_tests(&mut out, "isle_examples/pass", "run_pass");
@@ -19,7 +24,24 @@ fn main() {
     std::fs::write(output, out).unwrap();
 }
 
+fn isle_printer_tests(out_dir: &std::path::PathBuf) {
+    let mut out = String::new();
+
+    emit_tests(&mut out, "isle_examples/pass", "run_print");
+    emit_tests(&mut out, "../veri/veri/filetests/pass", "run_print");
+    emit_tests(&mut out, "../../codegen/src", "run_print");
+    emit_tests(&mut out, "../../codegen/src/opts", "run_print");
+    emit_tests(&mut out, "../../codegen/src/isa/x64", "run_print");
+    emit_tests(&mut out, "../../codegen/src/isa/aarch64", "run_print");
+    emit_tests(&mut out, "../../codegen/src/isa/riscv64", "run_print");
+
+    let output = out_dir.join("isle_printer_tests.rs");
+    std::fs::write(output, out).unwrap();
+}
+
 fn emit_tests(out: &mut String, dir_name: &str, runner_func: &str) {
+    let dir_path = PathBuf::from(dir_name);
+    let test_name = dir_path.file_name().unwrap().to_string_lossy();
     for test_file in std::fs::read_dir(dir_name).unwrap() {
         let test_file = test_file.unwrap().file_name().into_string().unwrap();
         if !test_file.ends_with(".isle") {
@@ -28,8 +50,12 @@ fn emit_tests(out: &mut String, dir_name: &str, runner_func: &str) {
         let test_file_base = test_file.replace(".isle", "");
 
         writeln!(out, "#[test]").unwrap();
-        writeln!(out, "fn test_{}_{}() {{", runner_func, test_file_base).unwrap();
-        writeln!(out, "    {}(\"{}/{}\");", runner_func, dir_name, test_file).unwrap();
+        writeln!(
+            out,
+            "fn test_{runner_func}_{test_name}_{test_file_base}() {{"
+        )
+        .unwrap();
+        writeln!(out, "    {runner_func}(\"{dir_name}/{test_file}\");").unwrap();
         writeln!(out, "}}").unwrap();
     }
 }
diff --git a/cranelift/isle/isle/isle_examples/link/multi_constructor_main.rs b/cranelift/isle/isle/isle_examples/link/multi_constructor_main.rs
index 16725e36cedc..3c05532ce077 100644
--- a/cranelift/isle/isle/isle_examples/link/multi_constructor_main.rs
+++ b/cranelift/isle/isle/isle_examples/link/multi_constructor_main.rs
@@ -1,15 +1,17 @@
 mod multi_constructor;
-
-pub(crate) type ConstructorVec<T> = Vec<T>;
+use multi_constructor::{ContextIter, IntoContextIter};
 
 struct Context;
 
+const MAX_ISLE_RETURNS: usize = 100;
+
+#[derive(Default)]
 struct It {
     i: u32,
     limit: u32,
 }
 
-impl multi_constructor::ContextIter for It {
+impl ContextIter for It {
     type Context = Context;
     type Output = u32;
     fn next(&mut self, _ctx: &mut Self::Context) -> Option<u32> {
@@ -23,15 +25,25 @@ impl multi_constructor::ContextIter for It {
     }
 }
 
+impl IntoContextIter for It {
+    type Context = Context;
+    type Output = u32;
+    type IntoIter = It;
+    fn into_context_iter(self) -> It {
+        self
+    }
+}
+
 impl multi_constructor::Context for Context {
-    type etor_C_iter = It;
-    fn etor_C(&mut self, value: u32) -> It {
-        It { i: 0, limit: value }
+    type etor_C_returns = It;
+    fn etor_C(&mut self, value: u32, returns: &mut It) {
+        returns.i = 0;
+        returns.limit = value;
     }
 
-    type ctor_B_iter = multi_constructor::ContextIterWrapper<u32, std::vec::IntoIter<u32>, Context>;
-    fn ctor_B(&mut self, value: u32) -> Self::ctor_B_iter {
-        (0..value).rev().collect::<Vec<_>>().into_iter().into()
+    type ctor_B_returns = multi_constructor::ContextIterWrapper<Vec<u32>, Context>;
+    fn ctor_B(&mut self, value: u32, returns: &mut Self::ctor_B_returns) {
+        returns.extend((0..value).rev());
     }
 }
 
@@ -55,16 +67,21 @@ impl<'a, Item, I: multi_constructor::ContextIter<Output = Item, Context = Contex
 
 fn main() {
     let mut ctx = Context;
-    let l1 = multi_constructor::constructor_A(&mut ctx, 10);
-    let l2 = multi_constructor::constructor_D(&mut ctx, 5);
+
+    let mut l1 = multi_constructor::ContextIterWrapper::<Vec<_>, _>::default();
+    multi_constructor::constructor_A(&mut ctx, 10, &mut l1);
+
+    let mut l2 = multi_constructor::ContextIterWrapper::<Vec<_>, _>::default();
+    multi_constructor::constructor_D(&mut ctx, 5, &mut l2);
+
     let l1 = IterWithContext {
         ctx: &mut ctx,
-        it: l1,
+        it: l1.into_context_iter(),
     }
     .collect::<Vec<_>>();
     let l2 = IterWithContext {
         ctx: &mut ctx,
-        it: l2,
+        it: l2.into_context_iter(),
     }
     .collect::<Vec<_>>();
     println!("l1 = {:?} l2 = {:?}", l1, l2);
diff --git a/cranelift/isle/isle/isle_examples/link/multi_extractor_main.rs b/cranelift/isle/isle/isle_examples/link/multi_extractor_main.rs
index 90a730b7c039..ebfa38e30fdf 100644
--- a/cranelift/isle/isle/isle_examples/link/multi_extractor_main.rs
+++ b/cranelift/isle/isle/isle_examples/link/multi_extractor_main.rs
@@ -1,8 +1,8 @@
 mod multi_extractor;
 
-use multi_extractor::ContextIter;
+use multi_extractor::{ContextIter, IntoContextIter};
 
-pub(crate) type ConstructorVec<T> = Vec<T>;
+const MAX_ISLE_RETURNS: usize = 100;
 
 #[derive(Clone)]
 pub enum A {
@@ -10,12 +10,13 @@ pub enum A {
     C,
 }
 
+#[derive(Default)]
 struct It {
     i: u32,
     arg: u32,
 }
 
-impl multi_extractor::ContextIter for It {
+impl ContextIter for It {
     type Context = Context;
     type Output = (A, u32);
     fn next(&mut self, _ctx: &mut Self::Context) -> Option<Self::Output> {
@@ -34,17 +35,29 @@ impl multi_extractor::ContextIter for It {
     }
 }
 
+impl IntoContextIter for It {
+    type Context = Context;
+    type IntoIter = It;
+    type Output = (A, u32);
+    fn into_context_iter(self) -> It {
+        self
+    }
+}
+
 struct Context;
 impl multi_extractor::Context for Context {
-    type e1_etor_iter = It;
-    fn e1_etor(&mut self, arg0: u32) -> It {
-        It { i: 0, arg: arg0 }
+    type e1_etor_returns = It;
+    fn e1_etor(&mut self, arg0: u32, returns: &mut It) {
+        returns.i = 0;
+        returns.arg = arg0;
     }
 }
 
 fn main() {
     let mut ctx = Context;
-    let x = multi_extractor::constructor_Rule(&mut ctx, 0xf0).next(&mut ctx);
-    let y = multi_extractor::constructor_Rule(&mut ctx, 0).next(&mut ctx);
+    let mut x = vec![];
+    multi_extractor::constructor_Rule(&mut ctx, 0xf0, &mut x);
+    let mut y = vec![];
+    multi_extractor::constructor_Rule(&mut ctx, 0, &mut y);
     println!("x = {:?} y = {:?}", x, y);
 }
diff --git a/cranelift/isle/isle/src/ast.rs b/cranelift/isle/isle/src/ast.rs
index a94c85659a6a..92f653a1c3f3 100644
--- a/cranelift/isle/isle/src/ast.rs
+++ b/cranelift/isle/isle/src/ast.rs
@@ -4,15 +4,6 @@
 
 use crate::lexer::Pos;
 use crate::log;
-use std::sync::Arc;
-
-/// The parsed form of an ISLE file.
-#[derive(Clone, PartialEq, Eq, Debug)]
-pub struct Defs {
-    pub defs: Vec<Def>,
-    pub filenames: Vec<Arc<str>>,
-    pub file_texts: Vec<Arc<str>>,
-}
 
 /// One toplevel form in an ISLE file.
 #[derive(Clone, PartialEq, Eq, Debug)]
@@ -22,6 +13,13 @@ pub enum Def {
     Rule(Rule),
     Extractor(Extractor),
     Decl(Decl),
+    Attr(Attr),
+    Spec(Spec),
+    SpecMacro(SpecMacro),
+    Model(Model),
+    State(State),
+    Form(Form),
+    Instantiation(Instantiation),
     Extern(Extern),
     Converter(Converter),
 }
@@ -63,6 +61,15 @@ pub struct Variant {
     pub pos: Pos,
 }
 
+impl Variant {
+    pub fn full_name(enum_name: &Ident, variant_name: &Ident) -> Ident {
+        Ident(
+            format!("{}.{}", enum_name.0, variant_name.0),
+            variant_name.1,
+        )
+    }
+}
+
 /// One field of an enum variant.
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct Field {
@@ -88,6 +95,434 @@ pub struct Decl {
     pub pos: Pos,
 }
 
+/// An attribute applied to a declaration.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct Attr {
+    pub target: AttrTarget,
+    pub kinds: Vec<AttrKind>,
+    pub pos: Pos,
+}
+
+/// Object an attribute applies to.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum AttrTarget {
+    Term(Ident),
+    Rule(Ident),
+}
+
+/// A kind of attribute that can be applied to a term declaration or rule.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum AttrKind {
+    /// In verification, apply rule chaining to this term.
+    ///
+    /// A term marked for chaining may omit a specification. Instead, all
+    /// possible applications of rules to this term will be generated and
+    /// verified.
+    Chain,
+
+    /// In verification, declare that the correctness of lower priority rules
+    /// depends on this rule not matching.
+    ///
+    /// During rule expansion, any higher-priority overlapping rules that have
+    /// the priority tag will have their match conditions negated and added to
+    /// the verification conditions.
+    ///
+    /// Note that care must be taken when using this tag: if the specification
+    /// for the match conditions of the higher priority rule are an
+    /// over-approximation of reality, then the assumptions made by lower
+    /// priority rules will be an under-approximation. In an extreme case this
+    /// may cause the verifier to determine the lower priority rule never
+    /// applies. In a more subtle case, it could cause bugs to be missed.
+    Priority,
+
+    /// Tag allows for categorizing terms and rules.
+    Tag(Ident),
+}
+
+/// An expression used to specify term semantics, similar to SMT-LIB syntax.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum SpecExpr {
+    /// An operator that matches a constant integer value.
+    ConstInt {
+        val: i128,
+        pos: Pos,
+    },
+    /// An operator that matches a constant bitvector value.
+    ConstBitVec {
+        val: u128,
+        width: usize,
+        pos: Pos,
+    },
+    /// An operator that matches a constant boolean value.
+    ConstBool {
+        val: bool,
+        pos: Pos,
+    },
+    // A variable
+    Var {
+        var: Ident,
+        pos: Pos,
+    },
+    // As expression specifies the intended type of the expression. Functionally
+    // it is the identity. Analogous to qualified identifiers in SMT-LIB.
+    As {
+        x: Box<SpecExpr>,
+        ty: ModelType,
+        pos: Pos,
+    },
+    /// Struct field access.
+    Field {
+        field: Ident,
+        x: Box<SpecExpr>,
+        pos: Pos,
+    },
+    /// Discriminator is a predicate that tests the variant of an enum value.
+    Discriminator {
+        variant: Ident,
+        x: Box<SpecExpr>,
+        pos: Pos,
+    },
+    /// An application of a type variant or term.
+    Op {
+        op: SpecOp,
+        args: Vec<SpecExpr>,
+        pos: Pos,
+    },
+    /// Enum pattern matching.
+    Match {
+        x: Box<SpecExpr>,
+        arms: Vec<Arm>,
+        pos: Pos,
+    },
+    /// Let bindings.
+    Let {
+        defs: Vec<(Ident, SpecExpr)>,
+        body: Box<SpecExpr>,
+        pos: Pos,
+    },
+    /// Introduce new uninitialized variables.
+    With {
+        decls: Vec<Ident>,
+        body: Box<SpecExpr>,
+        pos: Pos,
+    },
+    /// Inline macro definition, or lambda.
+    Macro {
+        /// Parameter names.
+        params: Vec<Ident>,
+        /// Macro expansion.
+        body: Box<SpecExpr>,
+        pos: Pos,
+    },
+    /// Macro expansion.
+    Expand {
+        name: Ident,
+        args: Vec<SpecExpr>,
+        pos: Pos,
+    },
+    /// Pairs, currently used for switch statements.
+    Pair {
+        l: Box<SpecExpr>,
+        r: Box<SpecExpr>,
+        pos: Pos,
+    },
+    /// Construct enum variant.
+    Enum {
+        name: Ident,
+        variant: Ident,
+        args: Vec<SpecExpr>,
+        pos: Pos,
+    },
+    /// Construct struct value.
+    Struct {
+        fields: Vec<FieldInit>,
+        pos: Pos,
+    },
+}
+
+impl SpecExpr {
+    pub fn pos(&self) -> Pos {
+        match self {
+            &Self::ConstInt { pos, .. }
+            | &Self::ConstBitVec { pos, .. }
+            | &Self::ConstBool { pos, .. }
+            | &Self::Var { pos, .. }
+            | &Self::As { pos, .. }
+            | &Self::Field { pos, .. }
+            | &Self::Discriminator { pos, .. }
+            | &Self::Op { pos, .. }
+            | &Self::Match { pos, .. }
+            | &Self::Let { pos, .. }
+            | &Self::With { pos, .. }
+            | &Self::Macro { pos, .. }
+            | &Self::Expand { pos, .. }
+            | &Self::Pair { pos, .. }
+            | &Self::Enum { pos, .. }
+            | &Self::Struct { pos, .. } => pos,
+        }
+    }
+}
+
+/// An operation used to specify term semantics, similar to SMT-LIB syntax.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum SpecOp {
+    // Boolean operations
+    Eq,
+    And,
+    Or,
+    Not,
+    Imp,
+
+    // Integer arithmetic operations
+    Add,
+    Sub,
+    Mul,
+
+    // Integer comparisons
+    Lt,
+    Lte,
+    Gt,
+    Gte,
+
+    // Bitwise bitvector operations (directly SMT-LIB)
+    BVNot,
+    BVAnd,
+    BVOr,
+    BVXor,
+
+    // Bitvector arithmetic operations  (directly SMT-LIB)
+    BVNeg,
+    BVAdd,
+    BVSub,
+    BVMul,
+    BVUdiv,
+    BVUrem,
+    BVSdiv,
+    BVSrem,
+    BVShl,
+    BVLshr,
+    BVAshr,
+
+    // Bitvector comparison operations  (directly SMT-LIB)
+    BVUle,
+    BVUlt,
+    BVUgt,
+    BVUge,
+    BVSlt,
+    BVSle,
+    BVSgt,
+    BVSge,
+
+    // Bitvector overflow checks (SMT-LIB pending standardization)
+    BVSaddo,
+
+    // Desugared bitvector arithmetic operations
+    Rotr,
+    Rotl,
+    Extract,
+    ZeroExt,
+    SignExt,
+    Concat,
+    Replicate,
+
+    // Floating point (IEEE 754-2008)
+    FPEq,
+    FPNe,
+    FPLt,
+    FPGt,
+    FPLe,
+    FPGe,
+    FPPositiveInfinity,
+    FPNegativeInfinity,
+    FPPositiveZero,
+    FPNegativeZero,
+    FPNaN,
+    FPAdd,
+    FPSub,
+    FPMul,
+    FPDiv,
+    FPMin,
+    FPMax,
+    FPNeg,
+    FPCeil,
+    FPFloor,
+    FPSqrt,
+    FPTrunc,
+    FPNearest,
+    FPIsZero,
+    FPIsInfinite,
+    FPIsNaN,
+    FPIsNegative,
+    FPIsPositive,
+
+    // Custom encodings
+    Popcnt,
+    Clz,
+    Cls,
+    Rev,
+
+    // Conversion operations
+    ConvTo,
+    Int2BV,
+    BV2Nat,
+    ToFP,
+    ToFPUnsigned,
+    ToFPFromFP,
+    FPToUBV,
+    FPToSBV,
+    WidthOf,
+
+    // Control operations
+    If,
+    Switch,
+}
+
+/// Arm of a spec match expression.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct Arm {
+    pub variant: Ident,
+    pub args: Vec<Ident>,
+    pub body: SpecExpr,
+    pub pos: Pos,
+}
+
+/// Field initializer in a struct constructor.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct FieldInit {
+    pub name: Ident,
+    pub value: Box<SpecExpr>,
+    pub pos: Pos,
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct SpecMacro {
+    /// Macro name.
+    pub name: Ident,
+    /// Parameter names.
+    pub params: Vec<Ident>,
+    /// Macro expansion.
+    pub body: SpecExpr,
+    pub pos: Pos,
+}
+
+/// State modification clause.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct Modifies {
+    pub state: Ident,
+    pub cond: Option<Ident>,
+}
+
+/// A specification of the semantics of a term.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct Spec {
+    /// The term name (must match a (decl ...))
+    pub term: Ident,
+    /// Argument names
+    pub args: Vec<Ident>,
+    /// Provide statements, which give the semantics of the produces value
+    pub provides: Vec<SpecExpr>,
+    /// Require statements, which express preconditions on the term
+    pub requires: Vec<SpecExpr>,
+    /// Match conditions, which specify when a partial term returns a value.
+    pub matches: Vec<SpecExpr>,
+    /// State variables modified by the term.
+    pub modifies: Vec<Modifies>,
+    pub pos: Pos,
+}
+
+/// A model of an SMT-LIB type.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum ModelType {
+    /// Unspecified type.
+    ///
+    /// Unlike an auto-derived type, unspecified is a concrete type. However,
+    /// values of this type cannot be used for anything non-trivial. It is
+    /// intended to be used as a placeholder for a type that is not yet known,
+    /// but only appears in rules that are not yet covered by verification.
+    Unspecified,
+    /// Automatically deduced primitive type, left to type-inference to determine.
+    Auto,
+    /// SMT-LIB Int
+    Int,
+    /// SMT-LIB Int
+    Bool,
+    /// Unit type.
+    Unit,
+    /// SMT-LIB bitvector, but with a potentially-polymorphic width
+    BitVec(Option<usize>),
+    /// Structured type.
+    Struct(Vec<ModelField>),
+    /// Same model as the named type.
+    Named(Ident),
+    ExtEnum(Vec<ModelVariant>),
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct ModelVariant {
+    pub name: Ident,
+    pub fields: Vec<ModelField>,
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct ModelField {
+    pub name: Ident,
+    pub ty: ModelType,
+}
+
+/// A construct's value in SMT-LIB
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum ModelValue {
+    /// Correspond to ISLE types
+    TypeValue(ModelType),
+    /// Corresponds to ISLE external constants.
+    ConstValue(SpecExpr),
+    // New ExtEnum model value 
+    ExtEnumValue(Vec<ModelField>),
+}
+
+/// A model of a construct into SMT-LIB (currently, types or enums)
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct Model {
+    /// The name of the type or enum
+    pub name: Ident,
+    /// The value of the type or enum (potentially multiple values)
+    pub val: ModelValue,
+}
+
+/// Declare an element of global state accessible by verification specs.
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct State {
+    /// Name of the state element.
+    pub name: Ident,
+    /// Type of the state element.
+    pub ty: ModelType,
+    /// Default specification, applied if the state is not modified.
+    pub default: SpecExpr,
+    pub pos: Pos,
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct Signature {
+    pub args: Vec<ModelType>,
+    pub ret: ModelType,
+    pub pos: Pos,
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct Form {
+    pub name: Ident,
+    pub signatures: Vec<Signature>,
+    pub pos: Pos,
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct Instantiation {
+    pub term: Ident,
+    pub form: Option<Ident>,
+    pub signatures: Vec<Signature>,
+    pub pos: Pos,
+}
+
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct Rule {
     pub pattern: Pattern,
@@ -95,6 +530,7 @@ pub struct Rule {
     pub expr: Expr,
     pub pos: Pos,
     pub prio: Option<i64>,
+    pub name: Option<Ident>,
 }
 
 #[derive(Clone, PartialEq, Eq, Debug)]
diff --git a/cranelift/isle/isle/src/codegen.rs b/cranelift/isle/isle/src/codegen.rs
index d55ca3eaa4f6..7ddca72ccadf 100644
--- a/cranelift/isle/isle/src/codegen.rs
+++ b/cranelift/isle/isle/src/codegen.rs
@@ -1,10 +1,13 @@
 //! Generate Rust code from a series of Sequences.
 
+use crate::files::Files;
 use crate::sema::{ExternalSig, ReturnKind, Sym, Term, TermEnv, TermId, Type, TypeEnv, TypeId};
 use crate::serialize::{Block, ControlFlow, EvalStep, MatchArm};
+use crate::stablemapset::StableSet;
 use crate::trie_again::{Binding, BindingId, Constraint, RuleSet};
-use crate::StableSet;
 use std::fmt::Write;
+use std::slice::Iter;
+use std::sync::Arc;
 
 /// Options for code generation.
 #[derive(Clone, Debug, Default)]
@@ -12,25 +15,35 @@ pub struct CodegenOptions {
     /// Do not include the `#![allow(...)]` pragmas in the generated
     /// source. Useful if it must be include!()'d elsewhere.
     pub exclude_global_allow_pragmas: bool,
+
+    /// Emit trace logs when rules fire.
+    pub rule_trace: bool,
 }
 
 /// Emit Rust source code for the given type and term environments.
 pub fn codegen(
+    files: Arc<Files>,
     typeenv: &TypeEnv,
     termenv: &TermEnv,
     terms: &[(TermId, RuleSet)],
     options: &CodegenOptions,
 ) -> String {
-    Codegen::compile(typeenv, termenv, terms).generate_rust(options)
+    Codegen::compile(files, typeenv, termenv, terms).generate_rust(options)
 }
 
 #[derive(Clone, Debug)]
 struct Codegen<'a> {
+    files: Arc<Files>,
     typeenv: &'a TypeEnv,
     termenv: &'a TermEnv,
     terms: &'a [(TermId, RuleSet)],
 }
 
+enum Nested<'a> {
+    Cases(Iter<'a, EvalStep>),
+    Arms(BindingId, Iter<'a, MatchArm>),
+}
+
 struct BodyContext<'a, W> {
     out: &'a mut W,
     ruleset: &'a RuleSet,
@@ -60,7 +73,10 @@ impl<'a, W: Write> BodyContext<'a, W> {
         writeln!(self.out, " {{")
     }
 
-    fn end_block(&mut self, scope: StableSet<BindingId>) -> std::fmt::Result {
+    fn end_block(&mut self, last_line: &str, scope: StableSet<BindingId>) -> std::fmt::Result {
+        if !last_line.is_empty() {
+            writeln!(self.out, "{}{}", &self.indent, last_line)?;
+        }
         self.is_bound = scope;
         self.end_block_without_newline()?;
         writeln!(self.out)
@@ -82,11 +98,13 @@ impl<'a, W: Write> BodyContext<'a, W> {
 
 impl<'a> Codegen<'a> {
     fn compile(
+        files: Arc<Files>,
         typeenv: &'a TypeEnv,
         termenv: &'a TermEnv,
         terms: &'a [(TermId, RuleSet)],
     ) -> Codegen<'a> {
         Codegen {
+            files,
             typeenv,
             termenv,
             terms,
@@ -99,7 +117,8 @@ impl<'a> Codegen<'a> {
         self.generate_header(&mut code, options);
         self.generate_ctx_trait(&mut code);
         self.generate_internal_types(&mut code);
-        self.generate_internal_term_constructors(&mut code).unwrap();
+        self.generate_internal_term_constructors(&mut code, options)
+            .unwrap();
 
         code
     }
@@ -112,8 +131,8 @@ impl<'a> Codegen<'a> {
             "// Generated automatically from the instruction-selection DSL code in:",
         )
         .unwrap();
-        for file in &self.typeenv.filenames {
-            writeln!(code, "// - {}", file).unwrap();
+        for file in &self.files.file_names {
+            writeln!(code, "// - {file}").unwrap();
         }
 
         if !options.exclude_global_allow_pragmas {
@@ -135,6 +154,7 @@ impl<'a> Codegen<'a> {
         }
 
         writeln!(code, "\nuse super::*;  // Pulls in all external types.").unwrap();
+        writeln!(code, "#[cfg(feature = \"trace-log\")]\nuse crate::trace;").unwrap();
         writeln!(code, "use std::marker::PhantomData;").unwrap();
     }
 
@@ -154,7 +174,7 @@ impl<'a> Codegen<'a> {
         if sig.ret_kind == ReturnKind::Iterator {
             writeln!(
                 code,
-                "{indent}type {name}_iter: ContextIter<Context = Self, Output = {output}>;",
+                "{indent}type {name}_returns: Default + IntoContextIter<Context = Self, Output = {output}>;",
                 indent = indent,
                 name = sig.func_name,
                 output = ret_tuple,
@@ -164,8 +184,8 @@ impl<'a> Codegen<'a> {
 
         let ret_ty = match sig.ret_kind {
             ReturnKind::Plain => ret_tuple,
-            ReturnKind::Option => format!("Option<{}>", ret_tuple),
-            ReturnKind::Iterator => format!("Self::{}_iter", sig.func_name),
+            ReturnKind::Option => format!("Option<{ret_tuple}>"),
+            ReturnKind::Iterator => format!("()"),
         };
 
         writeln!(
@@ -178,6 +198,11 @@ impl<'a> Codegen<'a> {
                 .iter()
                 .enumerate()
                 .map(|(i, &ty)| format!("arg{}: {}", i, self.type_name(ty, /* by_ref = */ true)))
+                .chain(if sig.ret_kind == ReturnKind::Iterator {
+                    Some(format!("returns: &mut Self::{}_returns", sig.func_name))
+                } else {
+                    None
+                })
                 .collect::<Vec<_>>()
                 .join(", "),
             ret_ty = ret_ty,
@@ -217,31 +242,92 @@ impl<'a> Codegen<'a> {
         writeln!(
             code,
             r#"
-           pub trait ContextIter {{
-               type Context;
-               type Output;
-               fn next(&mut self, ctx: &mut Self::Context) -> Option<Self::Output>;
-           }}
-
-           pub struct ContextIterWrapper<Item, I: Iterator < Item = Item>, C: Context> {{
-               iter: I,
-               _ctx: PhantomData<C>,
-           }}
-           impl<Item, I: Iterator<Item = Item>, C: Context> From<I> for ContextIterWrapper<Item, I, C> {{
-               fn from(iter: I) -> Self {{
-                   Self {{ iter, _ctx: PhantomData }}
-               }}
-           }}
-           impl<Item, I: Iterator<Item = Item>, C: Context> ContextIter for ContextIterWrapper<Item, I, C> {{
-               type Context = C;
-               type Output = Item;
-               fn next(&mut self, _ctx: &mut Self::Context) -> Option<Self::Output> {{
-                   self.iter.next()
-               }}
-           }}
+pub trait ContextIter {{
+    type Context;
+    type Output;
+    fn next(&mut self, ctx: &mut Self::Context) -> Option<Self::Output>;
+    fn size_hint(&self) -> (usize, Option<usize>) {{ (0, None) }}
+}}
+
+pub trait IntoContextIter {{
+    type Context;
+    type Output;
+    type IntoIter: ContextIter<Context = Self::Context, Output = Self::Output>;
+    fn into_context_iter(self) -> Self::IntoIter;
+}}
+
+pub trait Length {{
+    fn len(&self) -> usize;
+}}
+
+impl<T> Length for std::vec::Vec<T> {{
+    fn len(&self) -> usize {{
+        std::vec::Vec::len(self)
+    }}
+}}
+
+pub struct ContextIterWrapper<I, C> {{
+    iter: I,
+    _ctx: std::marker::PhantomData<C>,
+}}
+impl<I: Default, C> Default for ContextIterWrapper<I, C> {{
+    fn default() -> Self {{
+        ContextIterWrapper {{
+            iter: I::default(),
+            _ctx: std::marker::PhantomData
+        }}
+    }}
+}}
+impl<I, C> std::ops::Deref for ContextIterWrapper<I, C> {{
+    type Target = I;
+    fn deref(&self) -> &I {{
+        &self.iter
+    }}
+}}
+impl<I, C> std::ops::DerefMut for ContextIterWrapper<I, C> {{
+    fn deref_mut(&mut self) -> &mut I {{
+        &mut self.iter
+    }}
+}}
+impl<I: Iterator, C: Context> From<I> for ContextIterWrapper<I, C> {{
+    fn from(iter: I) -> Self {{
+        Self {{ iter, _ctx: std::marker::PhantomData }}
+    }}
+}}
+impl<I: Iterator, C: Context> ContextIter for ContextIterWrapper<I, C> {{
+    type Context = C;
+    type Output = I::Item;
+    fn next(&mut self, _ctx: &mut Self::Context) -> Option<Self::Output> {{
+        self.iter.next()
+    }}
+    fn size_hint(&self) -> (usize, Option<usize>) {{
+        self.iter.size_hint()
+    }}
+}}
+impl<I: IntoIterator, C: Context> IntoContextIter for ContextIterWrapper<I, C> {{
+    type Context = C;
+    type Output = I::Item;
+    type IntoIter = ContextIterWrapper<I::IntoIter, C>;
+    fn into_context_iter(self) -> Self::IntoIter {{
+        ContextIterWrapper {{
+            iter: self.iter.into_iter(),
+            _ctx: std::marker::PhantomData
+        }}
+    }}
+}}
+impl<T, E: Extend<T>, C> Extend<T> for ContextIterWrapper<E, C> {{
+    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {{
+        self.iter.extend(iter);
+    }}
+}}
+impl<L: Length, C> Length for ContextIterWrapper<L, C> {{
+    fn len(&self) -> usize {{
+        self.iter.len()
+    }}
+}}
            "#,
         )
-            .unwrap();
+        .unwrap();
     }
 
     fn generate_internal_types(&self, code: &mut String) {
@@ -260,35 +346,31 @@ impl<'a> Codegen<'a> {
                         code,
                         "\n/// Internal type {}: defined at {}.",
                         name,
-                        pos.pretty_print_line(&self.typeenv.filenames[..])
+                        pos.pretty_print_line(&self.files)
                     )
                     .unwrap();
 
                     // Generate the `derive`s.
                     let debug_derive = if is_nodebug { "" } else { ", Debug" };
                     if variants.iter().all(|v| v.fields.is_empty()) {
-                        writeln!(
-                            code,
-                            "#[derive(Copy, Clone, PartialEq, Eq{})]",
-                            debug_derive
-                        )
-                        .unwrap();
+                        writeln!(code, "#[derive(Copy, Clone, PartialEq, Eq{debug_derive})]")
+                            .unwrap();
                     } else {
-                        writeln!(code, "#[derive(Clone{})]", debug_derive).unwrap();
+                        writeln!(code, "#[derive(Clone{debug_derive})]").unwrap();
                     }
 
-                    writeln!(code, "pub enum {} {{", name).unwrap();
+                    writeln!(code, "pub enum {name} {{").unwrap();
                     for variant in variants {
                         let name = &self.typeenv.syms[variant.name.index()];
                         if variant.fields.is_empty() {
-                            writeln!(code, "    {},", name).unwrap();
+                            writeln!(code, "    {name},").unwrap();
                         } else {
-                            writeln!(code, "    {} {{", name).unwrap();
+                            writeln!(code, "    {name} {{").unwrap();
                             for field in &variant.fields {
                                 let name = &self.typeenv.syms[field.name.index()];
                                 let ty_name =
                                     self.typeenv.types[field.ty.index()].name(self.typeenv);
-                                writeln!(code, "        {}: {},", name, ty_name).unwrap();
+                                writeln!(code, "        {name}: {ty_name},").unwrap();
                             }
                             writeln!(code, "    }},").unwrap();
                         }
@@ -310,7 +392,11 @@ impl<'a> Codegen<'a> {
         }
     }
 
-    fn generate_internal_term_constructors(&self, code: &mut String) -> std::fmt::Result {
+    fn generate_internal_term_constructors(
+        &self,
+        code: &mut String,
+        options: &CodegenOptions,
+    ) -> std::fmt::Result {
         for &(termid, ref ruleset) in self.terms.iter() {
             let root = crate::serialize::serialize(ruleset);
             let mut ctx = BodyContext::new(code, ruleset);
@@ -349,56 +435,47 @@ impl<'a> Codegen<'a> {
                 writeln!(ctx.out, ",")?;
             }
 
-            write!(ctx.out, "{}) -> ", &ctx.indent)?;
             let (_, ret) = self.ty(sig.ret_tys[0]);
             let ret = &self.typeenv.syms[ret.index()];
-            match sig.ret_kind {
-                ReturnKind::Iterator => {
-                    write!(ctx.out, "impl ContextIter<Context = C, Output = {}>", ret)?
-                }
-                ReturnKind::Option => write!(ctx.out, "Option<{}>", ret)?,
-                ReturnKind::Plain => write!(ctx.out, "{}", ret)?,
-            };
-
-            let scope = ctx.enter_scope();
-            ctx.begin_block()?;
 
-            if sig.ret_kind == ReturnKind::Iterator {
+            if let ReturnKind::Iterator = sig.ret_kind {
                 writeln!(
                     ctx.out,
-                    "{}let mut returns = ConstructorVec::new();",
-                    &ctx.indent
+                    "{}    returns: &mut (impl Extend<{}> + Length),",
+                    &ctx.indent, ret
                 )?;
             }
 
-            self.emit_block(&mut ctx, &root, sig.ret_kind)?;
+            write!(ctx.out, "{}) -> ", &ctx.indent)?;
+            match sig.ret_kind {
+                ReturnKind::Iterator => write!(ctx.out, "()")?,
+                ReturnKind::Option => write!(ctx.out, "Option<{ret}>")?,
+                ReturnKind::Plain => write!(ctx.out, "{ret}")?,
+            };
 
-            match (sig.ret_kind, root.steps.last()) {
-                    (ReturnKind::Iterator, _) => {
-                        writeln!(
-                            ctx.out,
-                            "{}return ContextIterWrapper::from(returns.into_iter());",
-                            &ctx.indent
-                        )?;
-                    }
-                    (_, Some(EvalStep { check: ControlFlow::Return { .. }, .. })) => {
-                        // If there's an outermost fallback, no need for another `return` statement.
-                    }
-                    (ReturnKind::Option, _) => {
-                        writeln!(ctx.out, "{}None", &ctx.indent)?
-                    }
-                    (ReturnKind::Plain, _) => {
-                        writeln!(ctx.out,
-                                "unreachable!(\"no rule matched for term {{}} at {{}}; should it be partial?\", {:?}, {:?})",
-                                term_name,
-                                termdata
-                                    .decl_pos
-                                    .pretty_print_line(&self.typeenv.filenames[..])
-                        )?
-                    }
+            let last_expr = if let Some(EvalStep {
+                check: ControlFlow::Return { .. },
+                ..
+            }) = root.steps.last()
+            {
+                // If there's an outermost fallback, no need for another `return` statement.
+                String::new()
+            } else {
+                match sig.ret_kind {
+                    ReturnKind::Iterator => String::new(),
+                    ReturnKind::Option => "None".to_string(),
+                    ReturnKind::Plain => format!(
+                        "unreachable!(\"no rule matched for term {{}} at {{}}; should it be partial?\", {:?}, {:?})",
+                        term_name,
+                        termdata
+                            .decl_pos
+                            .pretty_print_line(&self.files)
+                    ),
                 }
+            };
 
-            ctx.end_block(scope)?;
+            let scope = ctx.enter_scope();
+            self.emit_block(&mut ctx, &root, sig.ret_kind, &last_expr, scope, options)?;
         }
         Ok(())
     }
@@ -410,12 +487,7 @@ impl<'a> Codegen<'a> {
         }
     }
 
-    fn emit_block<W: Write>(
-        &self,
-        ctx: &mut BodyContext<W>,
-        block: &Block,
-        ret_kind: ReturnKind,
-    ) -> std::fmt::Result {
+    fn validate_block(ret_kind: ReturnKind, block: &Block) -> Nested {
         if !matches!(ret_kind, ReturnKind::Iterator) {
             // Loops are only allowed if we're returning an iterator.
             assert!(!block
@@ -434,115 +506,215 @@ impl<'a> Codegen<'a> {
             }
         }
 
-        for case in block.steps.iter() {
-            for &expr in case.bind_order.iter() {
-                write!(ctx.out, "{}let v{} = ", &ctx.indent, expr.index())?;
-                self.emit_expr(ctx, expr)?;
-                writeln!(ctx.out, ";")?;
-                ctx.is_bound.insert(expr);
-            }
+        Nested::Cases(block.steps.iter())
+    }
 
-            match &case.check {
-                // Use a shorthand notation if there's only one match arm.
-                ControlFlow::Match { source, arms } if arms.len() == 1 => {
-                    let arm = &arms[0];
-                    let scope = ctx.enter_scope();
-                    match arm.constraint {
-                        Constraint::ConstInt { .. } | Constraint::ConstPrim { .. } => {
+    fn emit_block<W: Write>(
+        &self,
+        ctx: &mut BodyContext<W>,
+        block: &Block,
+        ret_kind: ReturnKind,
+        last_expr: &str,
+        scope: StableSet<BindingId>,
+        options: &CodegenOptions,
+    ) -> std::fmt::Result {
+        let mut stack = Vec::new();
+        ctx.begin_block()?;
+        stack.push((Self::validate_block(ret_kind, block), last_expr, scope));
+
+        while let Some((mut nested, last_line, scope)) = stack.pop() {
+            match &mut nested {
+                Nested::Cases(cases) => {
+                    let Some(case) = cases.next() else {
+                        ctx.end_block(last_line, scope)?;
+                        continue;
+                    };
+                    // Iterator isn't done, put it back on the stack.
+                    stack.push((nested, last_line, scope));
+
+                    for &expr in case.bind_order.iter() {
+                        let iter_return = match &ctx.ruleset.bindings[expr.index()] {
+                            Binding::Extractor { term, .. } => {
+                                let termdata = &self.termenv.terms[term.index()];
+                                let sig = termdata.extractor_sig(self.typeenv).unwrap();
+                                if sig.ret_kind == ReturnKind::Iterator {
+                                    if termdata.has_external_extractor() {
+                                        Some(format!("C::{}_returns", sig.func_name))
+                                    } else {
+                                        Some(format!("ContextIterWrapper::<ConstructorVec<_>, _>"))
+                                    }
+                                } else {
+                                    None
+                                }
+                            }
+                            Binding::Constructor { term, .. } => {
+                                let termdata = &self.termenv.terms[term.index()];
+                                let sig = termdata.constructor_sig(self.typeenv).unwrap();
+                                if sig.ret_kind == ReturnKind::Iterator {
+                                    if termdata.has_external_constructor() {
+                                        Some(format!("C::{}_returns", sig.func_name))
+                                    } else {
+                                        Some(format!("ContextIterWrapper::<ConstructorVec<_>, _>"))
+                                    }
+                                } else {
+                                    None
+                                }
+                            }
+                            _ => None,
+                        };
+                        if let Some(ty) = iter_return {
+                            writeln!(
+                                ctx.out,
+                                "{}let mut v{} = {}::default();",
+                                &ctx.indent,
+                                expr.index(),
+                                ty
+                            )?;
+                            write!(ctx.out, "{}", &ctx.indent)?;
+                        } else {
+                            write!(ctx.out, "{}let v{} = ", &ctx.indent, expr.index())?;
+                        }
+                        self.emit_expr(ctx, expr)?;
+                        writeln!(ctx.out, ";")?;
+                        ctx.is_bound.insert(expr);
+                    }
+
+                    match &case.check {
+                        // Use a shorthand notation if there's only one match arm.
+                        ControlFlow::Match { source, arms } if arms.len() == 1 => {
+                            let arm = &arms[0];
+                            let scope = ctx.enter_scope();
+                            match arm.constraint {
+                                Constraint::ConstInt { .. } | Constraint::ConstPrim { .. } => {
+                                    write!(ctx.out, "{}if ", &ctx.indent)?;
+                                    self.emit_expr(ctx, *source)?;
+                                    write!(ctx.out, " == ")?;
+                                    self.emit_constraint(ctx, *source, arm)?;
+                                }
+                                Constraint::Variant { .. } | Constraint::Some => {
+                                    write!(ctx.out, "{}if let ", &ctx.indent)?;
+                                    self.emit_constraint(ctx, *source, arm)?;
+                                    write!(ctx.out, " = ")?;
+                                    self.emit_source(ctx, *source, arm.constraint)?;
+                                }
+                            }
+                            ctx.begin_block()?;
+                            stack.push((Self::validate_block(ret_kind, &arm.body), "", scope));
+                        }
+
+                        ControlFlow::Match { source, arms } => {
+                            let scope = ctx.enter_scope();
+                            write!(ctx.out, "{}match ", &ctx.indent)?;
+                            self.emit_source(ctx, *source, arms[0].constraint)?;
+                            ctx.begin_block()?;
+
+                            // Always add a catchall arm, because we
+                            // don't do exhaustiveness checking on the
+                            // match arms.
+                            stack.push((Nested::Arms(*source, arms.iter()), "_ => {}", scope));
+                        }
+
+                        ControlFlow::Equal { a, b, body } => {
+                            let scope = ctx.enter_scope();
                             write!(ctx.out, "{}if ", &ctx.indent)?;
-                            self.emit_expr(ctx, *source)?;
+                            self.emit_expr(ctx, *a)?;
                             write!(ctx.out, " == ")?;
-                            self.emit_constraint(ctx, *source, arm)?;
+                            self.emit_expr(ctx, *b)?;
+                            ctx.begin_block()?;
+                            stack.push((Self::validate_block(ret_kind, body), "", scope));
                         }
-                        Constraint::Variant { .. } | Constraint::Some => {
-                            write!(ctx.out, "{}if let ", &ctx.indent)?;
-                            self.emit_constraint(ctx, *source, arm)?;
-                            write!(ctx.out, " = ")?;
-                            self.emit_source(ctx, *source, arm.constraint)?;
+
+                        ControlFlow::Loop { result, body } => {
+                            let source = match &ctx.ruleset.bindings[result.index()] {
+                                Binding::Iterator { source } => source,
+                                _ => unreachable!("Loop from a non-Iterator"),
+                            };
+                            let scope = ctx.enter_scope();
+
+                            writeln!(
+                                ctx.out,
+                                "{}let mut v{} = v{}.into_context_iter();",
+                                &ctx.indent,
+                                source.index(),
+                                source.index(),
+                            )?;
+
+                            write!(
+                                ctx.out,
+                                "{}while let Some(v{}) = v{}.next(ctx)",
+                                &ctx.indent,
+                                result.index(),
+                                source.index()
+                            )?;
+                            ctx.is_bound.insert(*result);
+                            ctx.begin_block()?;
+                            stack.push((Self::validate_block(ret_kind, body), "", scope));
                         }
-                    }
-                    ctx.begin_block()?;
-                    self.emit_block(ctx, &arm.body, ret_kind)?;
-                    ctx.end_block(scope)?;
-                }
 
-                ControlFlow::Match { source, arms } => {
-                    let scope = ctx.enter_scope();
-                    write!(ctx.out, "{}match ", &ctx.indent)?;
-                    self.emit_source(ctx, *source, arms[0].constraint)?;
-                    ctx.begin_block()?;
-                    for arm in arms.iter() {
-                        let scope = ctx.enter_scope();
-                        write!(ctx.out, "{}", &ctx.indent)?;
-                        self.emit_constraint(ctx, *source, arm)?;
-                        write!(ctx.out, " =>")?;
-                        ctx.begin_block()?;
-                        self.emit_block(ctx, &arm.body, ret_kind)?;
-                        ctx.end_block(scope)?;
+                        &ControlFlow::Return { pos, result, name } => {
+                            writeln!(
+                                ctx.out,
+                                "{}// Rule at {}.",
+                                &ctx.indent,
+                                pos.pretty_print_line(&self.files)
+                            )?;
+                            // Log the rule firing.
+                            if options.rule_trace {
+                                writeln!(
+                                ctx.out,
+                                "{}#[cfg(feature = \"trace-log\")] trace!(target: \"isle_rule_trace\", \"rule: {},{}\");",
+                                &ctx.indent,
+                                name.map_or("".to_string(), |sym| self.typeenv.syms[sym.index()]
+                                    .clone()),
+                                pos.pretty_print_line(&self.files)
+                            )
+                            .unwrap();
+                            }
+                            write!(ctx.out, "{}", &ctx.indent)?;
+                            match ret_kind {
+                                ReturnKind::Plain | ReturnKind::Option => {
+                                    write!(ctx.out, "return ")?
+                                }
+                                ReturnKind::Iterator => write!(ctx.out, "returns.extend(Some(")?,
+                            }
+                            self.emit_expr(ctx, result)?;
+                            if ctx.is_ref.contains(&result) {
+                                write!(ctx.out, ".clone()")?;
+                            }
+                            match ret_kind {
+                                ReturnKind::Plain | ReturnKind::Option => writeln!(ctx.out, ";")?,
+                                ReturnKind::Iterator => {
+                                    writeln!(ctx.out, "));")?;
+                                    writeln!(
+                                        ctx.out,
+                                        "{}if returns.len() >= MAX_ISLE_RETURNS {{ return; }}",
+                                        ctx.indent
+                                    )?;
+                                }
+                            }
+                        }
                     }
-                    // Always add a catchall, because we don't do exhaustiveness checking on the
-                    // match arms.
-                    writeln!(ctx.out, "{}_ => {{}}", &ctx.indent)?;
-                    ctx.end_block(scope)?;
                 }
 
-                ControlFlow::Equal { a, b, body } => {
-                    let scope = ctx.enter_scope();
-                    write!(ctx.out, "{}if ", &ctx.indent)?;
-                    self.emit_expr(ctx, *a)?;
-                    write!(ctx.out, " == ")?;
-                    self.emit_expr(ctx, *b)?;
-                    ctx.begin_block()?;
-                    self.emit_block(ctx, body, ret_kind)?;
-                    ctx.end_block(scope)?;
-                }
-
-                ControlFlow::Loop { result, body } => {
-                    let source = match &ctx.ruleset.bindings[result.index()] {
-                        Binding::Iterator { source } => source,
-                        _ => unreachable!("Loop from a non-Iterator"),
+                Nested::Arms(source, arms) => {
+                    let Some(arm) = arms.next() else {
+                        ctx.end_block(last_line, scope)?;
+                        continue;
                     };
-                    let scope = ctx.enter_scope();
-                    write!(ctx.out, "{}let mut v{} = ", &ctx.indent, source.index())?;
-                    self.emit_expr(ctx, *source)?;
-                    writeln!(ctx.out, ";")?;
-                    write!(
-                        ctx.out,
-                        "{}while let Some(v{}) = v{}.next(ctx)",
-                        &ctx.indent,
-                        result.index(),
-                        source.index()
-                    )?;
-                    ctx.is_bound.insert(*result);
-                    ctx.begin_block()?;
-                    self.emit_block(ctx, body, ret_kind)?;
-                    ctx.end_block(scope)?;
-                }
+                    let source = *source;
+                    // Iterator isn't done, put it back on the stack.
+                    stack.push((nested, last_line, scope));
 
-                &ControlFlow::Return { pos, result } => {
-                    writeln!(
-                        ctx.out,
-                        "{}// Rule at {}.",
-                        &ctx.indent,
-                        pos.pretty_print_line(&self.typeenv.filenames)
-                    )?;
+                    let scope = ctx.enter_scope();
                     write!(ctx.out, "{}", &ctx.indent)?;
-                    match ret_kind {
-                        ReturnKind::Plain => write!(ctx.out, "return ")?,
-                        ReturnKind::Option => write!(ctx.out, "return Some(")?,
-                        ReturnKind::Iterator => write!(ctx.out, "returns.push(")?,
-                    }
-                    self.emit_expr(ctx, result)?;
-                    if ctx.is_ref.contains(&result) {
-                        write!(ctx.out, ".clone()")?;
-                    }
-                    match ret_kind {
-                        ReturnKind::Plain => writeln!(ctx.out, ";")?,
-                        ReturnKind::Option | ReturnKind::Iterator => writeln!(ctx.out, ");")?,
-                    }
+                    self.emit_constraint(ctx, source, arm)?;
+                    write!(ctx.out, " =>")?;
+                    ctx.begin_block()?;
+                    stack.push((Self::validate_block(ret_kind, &arm.body), "", scope));
                 }
             }
         }
+
         Ok(())
     }
 
@@ -556,6 +728,7 @@ impl<'a> Codegen<'a> {
         let mut call =
             |term: TermId,
              parameters: &[BindingId],
+
              get_sig: fn(&Term, &TypeEnv) -> Option<ExternalSig>| {
                 let termdata = &self.termenv.terms[term.index()];
                 let sig = get_sig(termdata, self.typeenv).unwrap();
@@ -576,9 +749,12 @@ impl<'a> Codegen<'a> {
                         (true, false) => ("&", ""),
                         _ => ("", ""),
                     };
-                    write!(ctx.out, "{}", before)?;
+                    write!(ctx.out, "{before}")?;
                     self.emit_expr(ctx, parameter)?;
-                    write!(ctx.out, "{}", after)?;
+                    write!(ctx.out, "{after}")?;
+                }
+                if let ReturnKind::Iterator = sig.ret_kind {
+                    write!(ctx.out, ", &mut v{}", result.index())?;
                 }
                 write!(ctx.out, ")")
             };
@@ -630,6 +806,11 @@ impl<'a> Codegen<'a> {
                 Ok(())
             }
 
+            &Binding::MakeSome { inner } => {
+                write!(ctx.out, "Some(")?;
+                self.emit_expr(ctx, inner)?;
+                write!(ctx.out, ")")
+            }
             &Binding::MatchSome { source } => {
                 self.emit_expr(ctx, source)?;
                 write!(ctx.out, "?")
@@ -757,7 +938,7 @@ impl<'a> Codegen<'a> {
         {
             write!(ctx.out, "-{:#X}", -val)
         } else {
-            write!(ctx.out, "{:#X}", val)
+            write!(ctx.out, "{val:#X}")
         }
     }
 }
diff --git a/cranelift/isle/isle/src/compile.rs b/cranelift/isle/isle/src/compile.rs
index ab340e302dc6..434019d9b68e 100644
--- a/cranelift/isle/isle/src/compile.rs
+++ b/cranelift/isle/isle/src/compile.rs
@@ -1,16 +1,38 @@
 //! Compilation process, from AST to Sema to Sequences of Insts.
 
 use std::path::Path;
+use std::sync::Arc;
 
 use crate::error::Errors;
-use crate::{ast, codegen, sema};
+use crate::files::Files;
+use crate::{ast, codegen, overlap, sema};
 
 /// Compile the given AST definitions into Rust source code.
-pub fn compile(defs: &ast::Defs, options: &codegen::CodegenOptions) -> Result<String, Errors> {
-    let mut typeenv = sema::TypeEnv::from_ast(defs)?;
-    let termenv = sema::TermEnv::from_ast(&mut typeenv, defs)?;
-    let terms = crate::overlap::check(&typeenv, &termenv)?;
-    Ok(codegen::codegen(&typeenv, &termenv, &terms, options))
+pub fn compile(
+    files: Arc<Files>,
+    defs: &[ast::Def],
+    options: &codegen::CodegenOptions,
+) -> Result<String, Errors> {
+    let mut type_env = match sema::TypeEnv::from_ast(defs) {
+        Ok(type_env) => type_env,
+        Err(errs) => return Err(Errors::new(errs, files)),
+    };
+    let term_env = match sema::TermEnv::from_ast(
+        &mut type_env,
+        defs,
+        /*expand_internal_extractors*/ true,
+    ) {
+        Ok(term_env) => term_env,
+        Err(errs) => return Err(Errors::new(errs, files)),
+    };
+    let terms = match overlap::check(&term_env) {
+        Ok(terms) => terms,
+        Err(errs) => return Err(Errors::new(errs, files)),
+    };
+
+    Ok(codegen::codegen(
+        files, &type_env, &term_env, &terms, options,
+    ))
 }
 
 /// Compile the given files into Rust source code.
@@ -18,7 +40,30 @@ pub fn from_files<P: AsRef<Path>>(
     inputs: impl IntoIterator<Item = P>,
     options: &codegen::CodegenOptions,
 ) -> Result<String, Errors> {
-    let lexer = crate::lexer::Lexer::from_files(inputs)?;
-    let defs = crate::parser::parse(lexer)?;
-    compile(&defs, options)
+    let files = match Files::from_paths(inputs) {
+        Ok(files) => files,
+        Err((path, err)) => {
+            return Err(Errors::from_io(
+                err,
+                format!("cannot read file {}", path.display()),
+            ))
+        }
+    };
+
+    let files = Arc::new(files);
+
+    let mut defs = Vec::new();
+    for (file, src) in files.file_texts.iter().enumerate() {
+        let lexer = match crate::lexer::Lexer::new(file, src) {
+            Ok(lexer) => lexer,
+            Err(err) => return Err(Errors::new(vec![err], files)),
+        };
+
+        match crate::parser::parse(lexer, files.clone()) {
+            Ok(mut ds) => defs.append(&mut ds),
+            Err(err) => return Err(Errors::new(vec![err], files)),
+        }
+    }
+
+    compile(files, &defs, options)
 }
diff --git a/cranelift/isle/isle/src/disjointsets.rs b/cranelift/isle/isle/src/disjointsets.rs
new file mode 100644
index 000000000000..f8064b86cae9
--- /dev/null
+++ b/cranelift/isle/isle/src/disjointsets.rs
@@ -0,0 +1,169 @@
+//! Implementation of [`DisjointSets`], to store disjoint sets and provide efficient operations to
+//! merge sets
+
+use std::collections::HashMap;
+use std::hash::Hash;
+
+/// Stores disjoint sets and provides efficient operations to merge two sets, and to find a
+/// representative member of a set given any member of that set. In this implementation, sets always
+/// have at least two members, and can only be formed by the `merge` operation.
+#[derive(Clone, Debug, Default)]
+pub struct DisjointSets<T> {
+    parent: HashMap<T, (T, u8)>,
+}
+
+impl<T: Copy + std::fmt::Debug + Eq + Hash> DisjointSets<T> {
+    /// Find a representative member of the set containing `x`. If `x` has not been merged with any
+    /// other items using `merge`, returns `None`. This method updates the data structure to make
+    /// future queries faster, and takes amortized constant time.
+    ///
+    /// ```
+    /// let mut sets = cranelift_isle::disjointsets::DisjointSets::default();
+    /// sets.merge(1, 2);
+    /// sets.merge(1, 3);
+    /// sets.merge(2, 4);
+    /// assert_eq!(sets.find_mut(3).unwrap(), sets.find_mut(4).unwrap());
+    /// assert_eq!(sets.find_mut(10), None);
+    /// ```
+    pub fn find_mut(&mut self, mut x: T) -> Option<T> {
+        while let Some(node) = self.parent.get(&x) {
+            if node.0 == x {
+                return Some(x);
+            }
+            let grandparent = self.parent[&node.0].0;
+            // Re-do the lookup but take a mutable borrow this time
+            self.parent.get_mut(&x).unwrap().0 = grandparent;
+            x = grandparent;
+        }
+        None
+    }
+
+    /// Find a representative member of the set containing `x`. If `x` has not been merged with any
+    /// other items using `merge`, returns `None`. This method does not update the data structure to
+    /// make future queries faster, so `find_mut` should be preferred.
+    ///
+    /// ```
+    /// let mut sets = cranelift_isle::disjointsets::DisjointSets::default();
+    /// sets.merge(1, 2);
+    /// sets.merge(1, 3);
+    /// sets.merge(2, 4);
+    /// assert_eq!(sets.find(3).unwrap(), sets.find(4).unwrap());
+    /// assert_eq!(sets.find(10), None);
+    /// ```
+    pub fn find(&self, mut x: T) -> Option<T> {
+        while let Some(node) = self.parent.get(&x) {
+            if node.0 == x {
+                return Some(x);
+            }
+            x = node.0;
+        }
+        None
+    }
+
+    /// Merge the set containing `x` with the set containing `y`. This method takes amortized
+    /// constant time.
+    pub fn merge(&mut self, x: T, y: T) {
+        assert_ne!(x, y);
+        let mut x = if let Some(x) = self.find_mut(x) {
+            self.parent[&x]
+        } else {
+            self.parent.insert(x, (x, 0));
+            (x, 0)
+        };
+        let mut y = if let Some(y) = self.find_mut(y) {
+            self.parent[&y]
+        } else {
+            self.parent.insert(y, (y, 0));
+            (y, 0)
+        };
+
+        if x == y {
+            return;
+        }
+
+        if x.1 < y.1 {
+            std::mem::swap(&mut x, &mut y);
+        }
+
+        self.parent.get_mut(&y.0).unwrap().0 = x.0;
+        if x.1 == y.1 {
+            let x_rank = &mut self.parent.get_mut(&x.0).unwrap().1;
+            *x_rank = x_rank.saturating_add(1);
+        }
+    }
+
+    /// Returns whether the given items have both been merged into the same set. If either is not
+    /// part of any set, returns `false`.
+    ///
+    /// ```
+    /// let mut sets = cranelift_isle::disjointsets::DisjointSets::default();
+    /// sets.merge(1, 2);
+    /// sets.merge(1, 3);
+    /// sets.merge(2, 4);
+    /// sets.merge(5, 6);
+    /// assert!(sets.in_same_set(2, 3));
+    /// assert!(sets.in_same_set(1, 4));
+    /// assert!(sets.in_same_set(3, 4));
+    /// assert!(!sets.in_same_set(4, 5));
+    /// ```
+    pub fn in_same_set(&self, x: T, y: T) -> bool {
+        let x = self.find(x);
+        let y = self.find(y);
+        x.zip(y).filter(|(x, y)| x == y).is_some()
+    }
+
+    /// Remove the set containing the given item, and return all members of that set. The set is
+    /// returned in sorted order. This method takes time linear in the total size of all sets.
+    ///
+    /// ```
+    /// let mut sets = cranelift_isle::disjointsets::DisjointSets::default();
+    /// sets.merge(1, 2);
+    /// sets.merge(1, 3);
+    /// sets.merge(2, 4);
+    /// assert_eq!(sets.remove_set_of(4), &[1, 2, 3, 4]);
+    /// assert_eq!(sets.remove_set_of(1), &[]);
+    /// assert!(sets.is_empty());
+    /// ```
+    pub fn remove_set_of(&mut self, x: T) -> Vec<T>
+    where
+        T: Ord,
+    {
+        let mut set = Vec::new();
+        if let Some(x) = self.find_mut(x) {
+            set.extend(self.parent.keys().copied());
+            // It's important to use `find_mut` here to avoid quadratic worst-case time.
+            set.retain(|&y| self.find_mut(y).unwrap() == x);
+            for y in set.iter() {
+                self.parent.remove(y);
+            }
+            set.sort_unstable();
+        }
+        set
+    }
+
+    /// Returns true if there are no sets. This method takes constant time.
+    ///
+    /// ```
+    /// let mut sets = cranelift_isle::disjointsets::DisjointSets::default();
+    /// assert!(sets.is_empty());
+    /// sets.merge(1, 2);
+    /// assert!(!sets.is_empty());
+    /// ```
+    pub fn is_empty(&self) -> bool {
+        self.parent.is_empty()
+    }
+
+    /// Returns the total number of elements in all sets. This method takes constant time.
+    ///
+    /// ```
+    /// let mut sets = cranelift_isle::disjointsets::DisjointSets::default();
+    /// sets.merge(1, 2);
+    /// assert_eq!(sets.len(), 2);
+    /// sets.merge(3, 4);
+    /// sets.merge(3, 5);
+    /// assert_eq!(sets.len(), 5);
+    /// ```
+    pub fn len(&self) -> usize {
+        self.parent.len()
+    }
+}
diff --git a/cranelift/isle/isle/src/error.rs b/cranelift/isle/isle/src/error.rs
index f9c8468c8aec..c11dc33e500b 100644
--- a/cranelift/isle/isle/src/error.rs
+++ b/cranelift/isle/isle/src/error.rs
@@ -2,17 +2,19 @@
 
 use std::sync::Arc;
 
-use crate::lexer::Pos;
+use crate::{files::Files, lexer::Pos};
 
 /// A collection of errors from attempting to compile some ISLE source files.
+#[derive(Debug)]
 pub struct Errors {
     /// The individual errors.
     pub errors: Vec<Error>,
-    pub(crate) filenames: Vec<Arc<str>>,
-    pub(crate) file_texts: Vec<Arc<str>>,
+    pub(crate) files: Arc<Files>,
 }
 
-impl std::fmt::Debug for Errors {
+impl std::error::Error for Errors {}
+
+impl std::fmt::Display for Errors {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         if self.errors.is_empty() {
             return Ok(());
@@ -20,10 +22,10 @@ impl std::fmt::Debug for Errors {
         let diagnostics = Vec::from_iter(self.errors.iter().map(|e| {
             let message = match e {
                 Error::IoError { context, .. } => context.clone(),
-                Error::ParseError { msg, .. } => format!("parse error: {}", msg),
-                Error::TypeError { msg, .. } => format!("type error: {}", msg),
-                Error::UnreachableError { msg, .. } => format!("unreachable rule: {}", msg),
-                Error::OverlapError { msg, .. } => format!("overlap error: {}", msg),
+                Error::ParseError { msg, .. } => format!("parse error: {msg}"),
+                Error::TypeError { msg, .. } => format!("type error: {msg}"),
+                Error::UnreachableError { msg, .. } => format!("unreachable rule: {msg}"),
+                Error::OverlapError { msg, .. } => format!("overlap error: {msg}"),
                 Error::ShadowedError { .. } => {
                     "more general higher-priority rule shadows other rules".to_string()
                 }
@@ -62,7 +64,7 @@ impl std::fmt::Debug for Errors {
             let mut sources = Vec::new();
             let mut source = e.source();
             while let Some(e) = source {
-                sources.push(format!("{:?}", e));
+                sources.push(format!("{e:?}"));
                 source = std::error::Error::source(e);
             }
 
@@ -139,6 +141,11 @@ pub enum Error {
 }
 
 impl Errors {
+    /// Create new Errors
+    pub fn new(errors: Vec<Error>, files: Arc<Files>) -> Self {
+        Self { errors, files }
+    }
+
     /// Create `isle::Errors` from the given I/O error and context.
     pub fn from_io(error: std::io::Error, context: impl Into<String>) -> Self {
         Errors {
@@ -146,8 +153,7 @@ impl Errors {
                 error,
                 context: context.into(),
             }],
-            filenames: Vec::new(),
-            file_texts: Vec::new(),
+            files: Arc::new(Files::default()),
         }
     }
 
@@ -161,7 +167,12 @@ impl Errors {
         let w = termcolor::BufferWriter::stderr(termcolor::ColorChoice::Auto);
         let mut b = w.buffer();
         let mut files = codespan_reporting::files::SimpleFiles::new();
-        for (name, source) in self.filenames.iter().zip(self.file_texts.iter()) {
+        for (name, source) in self
+            .files
+            .file_names
+            .iter()
+            .zip(self.files.file_texts.iter())
+        {
             files.add(name, source);
         }
         for diagnostic in diagnostics {
@@ -179,21 +190,16 @@ impl Errors {
         f: &mut std::fmt::Formatter,
         diagnostics: Vec<Diagnostic<usize>>,
     ) -> std::fmt::Result {
-        let line_ends: Vec<Vec<_>> = self
-            .file_texts
-            .iter()
-            .map(|text| text.match_indices('\n').map(|(i, _)| i + 1).collect())
-            .collect();
         let pos = |file_id: usize, offset| {
-            let ends = &line_ends[file_id];
-            let line0 = ends.partition_point(|&end| end <= offset);
-            let text = &self.file_texts[file_id];
+            let ends = self.files.file_line_map(file_id).unwrap();
+            let line0 = ends.line(offset);
+            let text = &self.files.file_texts[file_id];
             let start = line0.checked_sub(1).map_or(0, |prev| ends[prev]);
             let end = ends.get(line0).copied().unwrap_or(text.len());
             let col = offset - start + 1;
             format!(
                 "{}:{}:{}: {}",
-                self.filenames[file_id],
+                self.files.file_names[file_id],
                 line0 + 1,
                 col,
                 &text[start..end]
@@ -205,7 +211,7 @@ impl Errors {
                 f.write_str(&pos(label.file_id, label.range.start))?;
             }
             for note in diagnostic.notes {
-                writeln!(f, "{}", note)?;
+                writeln!(f, "{note}")?;
             }
             writeln!(f)?;
         }
@@ -213,6 +219,41 @@ impl Errors {
     }
 }
 
+/// Builder for the `isle::Errors`.
+pub struct ErrorsBuilder(Errors);
+
+impl ErrorsBuilder {
+    /// Start building an [Errors] object.
+    pub fn new() -> Self {
+        Self(Errors {
+            errors: Vec::new(),
+            files: Arc::new(Files::default()),
+        })
+    }
+
+    /// Return the built [Errors] object.
+    pub fn build(self) -> Errors {
+        self.0
+    }
+
+    /// Set the `errors` field of the under-construction [Errors] object.
+    pub fn errors(mut self, errors: Vec<Error>) -> Self {
+        self.0.errors = errors;
+        self
+    }
+
+    /// Set the `errors` field of the under-construction [Errors] object to a single error.
+    pub fn error(self, error: Error) -> Self {
+        self.errors(vec![error])
+    }
+
+    /// Set the [Errors::files] field of the under-construction [Errors] object.
+    pub fn files(mut self, files: Arc<Files>) -> Self {
+        self.0.files = files;
+        self
+    }
+}
+
 impl Error {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         match self {
@@ -243,8 +284,6 @@ impl Span {
             to: Pos {
                 file: pos.file,
                 offset: pos.offset + 1,
-                line: pos.line,
-                col: pos.col + 1,
             },
         }
     }
diff --git a/cranelift/isle/isle/src/files.rs b/cranelift/isle/isle/src/files.rs
new file mode 100644
index 000000000000..703e19f04c87
--- /dev/null
+++ b/cranelift/isle/isle/src/files.rs
@@ -0,0 +1,133 @@
+#![allow(missing_docs)]
+
+use std::ops::Index;
+use std::path::{Path, PathBuf};
+
+#[derive(Default, Clone, PartialEq, Eq, Debug)]
+pub struct Files {
+    /// Arena of filenames from the input source.
+    ///
+    /// Indexed via `Pos::file`.
+    pub file_names: Vec<String>,
+
+    /// Arena of file source texts.
+    ///
+    /// Indexed via `Pos::file`.
+    pub file_texts: Vec<String>,
+
+    /// Arena of file line maps.
+    ///
+    /// Indexed via `Pos::file`.
+    pub file_line_maps: Vec<LineMap>,
+}
+
+#[derive(Default, Clone, PartialEq, Eq, Debug)]
+pub struct LineMap {
+    /// Mapping from line number to starting byte position.
+    line_ends: Vec<usize>,
+}
+
+impl Index<usize> for LineMap {
+    type Output = usize;
+
+    fn index(&self, index: usize) -> &Self::Output {
+        &self.line_ends[index]
+    }
+}
+
+impl LineMap {
+    pub fn from_str(text: &str) -> Self {
+        let line_ends = text.match_indices('\n').map(|(i, _)| i + 1).collect();
+        Self { line_ends }
+    }
+
+    /// Get the line on which `pos` occurs
+    pub fn line(&self, pos: usize) -> usize {
+        self.line_ends.partition_point(|&end| end <= pos)
+    }
+
+    /// Get the starting byte position of `line`.
+    pub fn get(&self, line: usize) -> Option<&usize> {
+        self.line_ends.get(line)
+    }
+}
+
+impl Files {
+    pub fn from_paths<P: AsRef<Path>>(
+        paths: impl IntoIterator<Item = P>,
+    ) -> Result<Self, (PathBuf, std::io::Error)> {
+        let mut file_names = Vec::new();
+        let mut file_texts = Vec::new();
+        let mut file_line_maps = Vec::new();
+
+        for path in paths {
+            let path = path.as_ref();
+            let contents =
+                std::fs::read_to_string(path).map_err(|err| (path.to_path_buf(), err))?;
+            let name = path.display().to_string();
+
+            file_line_maps.push(LineMap::from_str(&contents));
+            file_names.push(name);
+            file_texts.push(contents);
+        }
+
+        Ok(Self {
+            file_names,
+            file_texts,
+            file_line_maps,
+        })
+    }
+
+    pub fn from_names_and_contents(files: impl IntoIterator<Item = (String, String)>) -> Self {
+        let mut file_names = Vec::new();
+        let mut file_texts = Vec::new();
+        let mut file_line_maps = Vec::new();
+
+        for (name, contents) in files {
+            file_line_maps.push(LineMap::from_str(&contents));
+            file_names.push(name);
+            file_texts.push(contents);
+        }
+
+        Self {
+            file_names,
+            file_texts,
+            file_line_maps,
+        }
+    }
+
+    pub fn file_name(&self, file: usize) -> Option<&str> {
+        self.file_names.get(file).map(|x| x.as_str())
+    }
+
+    pub fn file_text(&self, file: usize) -> Option<&str> {
+        self.file_texts.get(file).map(|x| x.as_str())
+    }
+
+    pub fn file_line_map(&self, file: usize) -> Option<&LineMap> {
+        self.file_line_maps.get(file)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn line_map() {
+        let line_map = LineMap::from_str("");
+        assert_eq!(line_map.line_ends, &[]);
+        assert_eq!(line_map.line(0), 0);
+        assert_eq!(line_map.line(100), 0);
+
+        let line_map = LineMap::from_str("line 0");
+        assert_eq!(line_map.line_ends, &[]);
+        assert_eq!(line_map.line(0), 0);
+        assert_eq!(line_map.line(100), 0);
+
+        let line_map = LineMap::from_str("line 0\nline 1");
+        assert_eq!(line_map.line_ends, &[7]);
+        assert_eq!(line_map.line(0), 0);
+        assert_eq!(line_map.line(100), 1);
+    }
+}
diff --git a/cranelift/isle/isle/src/lexer.rs b/cranelift/isle/isle/src/lexer.rs
index 6a41ee21e179..4133b45c441b 100644
--- a/cranelift/isle/isle/src/lexer.rs
+++ b/cranelift/isle/isle/src/lexer.rs
@@ -1,29 +1,18 @@
 //! Lexer for the ISLE language.
 
-use crate::error::{Error, Errors, Span};
 use std::borrow::Cow;
-use std::path::{Path, PathBuf};
-use std::sync::Arc;
 
-type Result<T> = std::result::Result<T, Errors>;
+use crate::error::{Error, Span};
+use crate::files::Files;
+
+type Result<T> = std::result::Result<T, Error>;
 
 /// The lexer.
 ///
 /// Breaks source text up into a sequence of tokens (with source positions).
 #[derive(Clone, Debug)]
-pub struct Lexer<'a> {
-    /// Arena of filenames from the input source.
-    ///
-    /// Indexed via `Pos::file`.
-    pub filenames: Vec<Arc<str>>,
-
-    /// Arena of file source texts.
-    ///
-    /// Indexed via `Pos::file`.
-    pub file_texts: Vec<Arc<str>>,
-
-    file_starts: Vec<usize>,
-    buf: Cow<'a, [u8]>,
+pub struct Lexer<'src> {
+    src: &'src str,
     pos: Pos,
     lookahead: Option<(Pos, Token)>,
 }
@@ -38,16 +27,26 @@ pub struct Pos {
     pub file: usize,
     /// This source position's byte offset in the file.
     pub offset: usize,
-    /// This source position's line number in the file.
-    pub line: usize,
-    /// This source position's column number in the file.
-    pub col: usize,
 }
 
 impl Pos {
+    /// Create a new `Pos`.
+    pub fn new(file: usize, offset: usize) -> Self {
+        Self { file, offset }
+    }
+
+    /// Report whether the position is unknown.
+    pub fn is_unknown(&self) -> bool {
+        *self == Self::default()
+    }
+
     /// Print this source position as `file.isle line 12`.
-    pub fn pretty_print_line(&self, filenames: &[Arc<str>]) -> String {
-        format!("{} line {}", filenames[self.file], self.line)
+    pub fn pretty_print_line(&self, files: &Files) -> String {
+        format!(
+            "{} line {}",
+            files.file_name(self.file).unwrap(),
+            files.file_line_map(self.file).unwrap().line(self.offset)
+        )
     }
 }
 
@@ -66,69 +65,12 @@ pub enum Token {
     At,
 }
 
-impl<'a> Lexer<'a> {
-    /// Create a new lexer for the given source contents and filename.
-    pub fn from_str(s: &'a str, filename: &'a str) -> Result<Lexer<'a>> {
+impl<'src> Lexer<'src> {
+    /// Create a new lexer for the given source contents
+    pub fn new(file: usize, src: &'src str) -> Result<Lexer<'src>> {
         let mut l = Lexer {
-            filenames: vec![filename.into()],
-            file_texts: vec![s.into()],
-            file_starts: vec![0],
-            buf: Cow::Borrowed(s.as_bytes()),
-            pos: Pos {
-                file: 0,
-                offset: 0,
-                line: 1,
-                col: 0,
-            },
-            lookahead: None,
-        };
-        l.reload()?;
-        Ok(l)
-    }
-
-    /// Create a new lexer from the given files.
-    pub fn from_files<P>(file_paths: impl IntoIterator<Item = P>) -> Result<Lexer<'a>>
-    where
-        P: AsRef<Path>,
-    {
-        let mut files = vec![];
-        for f in file_paths.into_iter() {
-            let f = f.as_ref().to_path_buf();
-            let s = std::fs::read_to_string(f.as_path())
-                .map_err(|e| Errors::from_io(e, format!("failed to read file: {}", f.display())))?;
-            files.push((f, s));
-        }
-        Self::from_file_contents(files)
-    }
-
-    /// Create a new lexer from the given files and contents.
-    pub fn from_file_contents(files: Vec<(PathBuf, String)>) -> Result<Lexer<'a>> {
-        let mut filenames = Vec::<Arc<str>>::new();
-        let mut file_texts = Vec::<Arc<str>>::new();
-        for (f, content) in files.iter() {
-            filenames.push(f.display().to_string().into());
-
-            file_texts.push(content.as_str().into());
-        }
-        assert!(!filenames.is_empty());
-        let mut file_starts = vec![];
-        let mut buf = String::new();
-        for text in &file_texts {
-            file_starts.push(buf.len());
-            buf += text;
-            buf += "\n";
-        }
-        let mut l = Lexer {
-            filenames,
-            file_texts,
-            buf: Cow::Owned(buf.into_bytes()),
-            file_starts,
-            pos: Pos {
-                file: 0,
-                offset: 0,
-                line: 1,
-                col: 0,
-            },
+            src,
+            pos: Pos::new(file, 0),
             lookahead: None,
         };
         l.reload()?;
@@ -137,79 +79,57 @@ impl<'a> Lexer<'a> {
 
     /// Get the lexer's current source position.
     pub fn pos(&self) -> Pos {
-        Pos {
-            file: self.pos.file,
-            offset: self.pos.offset - self.file_starts[self.pos.file],
-            line: self.pos.line,
-            col: self.pos.col,
-        }
+        self.pos
     }
 
     fn advance_pos(&mut self) {
-        self.pos.col += 1;
-        if self.buf[self.pos.offset] == b'\n' {
-            self.pos.line += 1;
-            self.pos.col = 0;
-        }
         self.pos.offset += 1;
-        if self.pos.file + 1 < self.file_starts.len() {
-            let next_start = self.file_starts[self.pos.file + 1];
-            if self.pos.offset >= next_start {
-                assert!(self.pos.offset == next_start);
-                self.pos.file += 1;
-                self.pos.line = 1;
-            }
-        }
     }
 
-    fn error(&self, pos: Pos, msg: impl Into<String>) -> Errors {
-        Errors {
-            errors: vec![Error::ParseError {
-                msg: msg.into(),
-                span: Span::new_single(pos),
-            }],
-            filenames: self.filenames.clone(),
-            file_texts: self.file_texts.clone(),
+    fn error(&self, pos: Pos, msg: impl Into<String>) -> Error {
+        Error::ParseError {
+            msg: msg.into(),
+            span: Span::new_single(pos),
         }
     }
 
     fn next_token(&mut self) -> Result<Option<(Pos, Token)>> {
         fn is_sym_first_char(c: u8) -> bool {
             match c {
-                b'-' | b'0'..=b'9' | b'(' | b')' | b';' | b'<' | b'>' => false,
+                b'-' | b'0'..=b'9' | b'(' | b')' | b';' => false,
                 c if c.is_ascii_whitespace() => false,
                 _ => true,
             }
         }
         fn is_sym_other_char(c: u8) -> bool {
             match c {
-                b'(' | b')' | b';' | b'@' | b'<' => false,
+                b'(' | b')' | b';' | b'@' => false,
                 c if c.is_ascii_whitespace() => false,
                 _ => true,
             }
         }
 
         // Skip any whitespace and any comments.
-        while self.pos.offset < self.buf.len() {
-            if self.buf[self.pos.offset].is_ascii_whitespace() {
-                self.advance_pos();
-                continue;
-            }
-            if self.buf[self.pos.offset] == b';' {
-                while self.pos.offset < self.buf.len() && self.buf[self.pos.offset] != b'\n' {
-                    self.advance_pos();
+        while let Some(c) = self.peek_byte() {
+            match c {
+                c if c.is_ascii_whitespace() => self.advance_pos(),
+                b';' => {
+                    while let Some(c) = self.peek_byte() {
+                        match c {
+                            b'\n' => break,
+                            _ => self.advance_pos(),
+                        }
+                    }
                 }
-                continue;
+                _ => break,
             }
-            break;
         }
 
-        if self.pos.offset == self.buf.len() {
+        let Some(c) = self.peek_byte() else {
             return Ok(None);
-        }
-
+        };
         let char_pos = self.pos();
-        match self.buf[self.pos.offset] {
+        match c {
             b'(' => {
                 self.advance_pos();
                 Ok(Some((char_pos, Token::LParen)))
@@ -225,44 +145,43 @@ impl<'a> Lexer<'a> {
             c if is_sym_first_char(c) => {
                 let start = self.pos.offset;
                 let start_pos = self.pos();
-                while self.pos.offset < self.buf.len()
-                    && is_sym_other_char(self.buf[self.pos.offset])
-                {
-                    self.advance_pos();
+                while let Some(c) = self.peek_byte() {
+                    match c {
+                        c if is_sym_other_char(c) => self.advance_pos(),
+                        _ => break,
+                    }
                 }
                 let end = self.pos.offset;
-                let s = std::str::from_utf8(&self.buf[start..end])
-                    .expect("Only ASCII characters, should be UTF-8");
+                let s = &self.src[start..end];
                 debug_assert!(!s.is_empty());
                 Ok(Some((start_pos, Token::Symbol(s.to_string()))))
             }
             c @ (b'0'..=b'9' | b'-') => {
                 let start_pos = self.pos();
-                let neg = if c == b'-' {
+                let mut neg = false;
+                if c == b'-' {
                     self.advance_pos();
-                    true
-                } else {
-                    false
-                };
+                    neg = true;
+                }
 
                 let mut radix = 10;
 
                 // Check for prefixed literals.
                 match (
-                    self.buf.get(self.pos.offset),
-                    self.buf.get(self.pos.offset + 1),
+                    self.src.as_bytes().get(self.pos.offset),
+                    self.src.as_bytes().get(self.pos.offset + 1),
                 ) {
-                    (Some(b'0'), Some(b'x')) | (Some(b'0'), Some(b'X')) => {
+                    (Some(b'0'), Some(b'x' | b'X')) => {
                         self.advance_pos();
                         self.advance_pos();
                         radix = 16;
                     }
-                    (Some(b'0'), Some(b'o')) => {
+                    (Some(b'0'), Some(b'o' | b'O')) => {
                         self.advance_pos();
                         self.advance_pos();
                         radix = 8;
                     }
-                    (Some(b'0'), Some(b'b')) => {
+                    (Some(b'0'), Some(b'b' | b'B')) => {
                         self.advance_pos();
                         self.advance_pos();
                         radix = 2;
@@ -273,35 +192,40 @@ impl<'a> Lexer<'a> {
                 // Find the range in the buffer for this integer literal. We'll
                 // pass this range to `i64::from_str_radix` to do the actual
                 // string-to-integer conversion.
-                let mut s = vec![];
-                while self.pos.offset < self.buf.len()
-                    && ((radix <= 10 && self.buf[self.pos.offset].is_ascii_digit())
-                        || (radix == 16 && self.buf[self.pos.offset].is_ascii_hexdigit())
-                        || self.buf[self.pos.offset] == b'_')
-                {
-                    if self.buf[self.pos.offset] != b'_' {
-                        s.push(self.buf[self.pos.offset]);
+                let start = self.pos.offset;
+                while let Some(c) = self.peek_byte() {
+                    match c {
+                        b'0'..=b'9' | b'a'..=b'f' | b'A'..=b'F' | b'_' => self.advance_pos(),
+                        _ => break,
                     }
-                    self.advance_pos();
                 }
-                let s_utf8 = std::str::from_utf8(&s[..]).unwrap();
+                let end = self.pos.offset;
+                let s = &self.src[start..end];
+                let s = if s.contains('_') {
+                    Cow::Owned(s.replace('_', ""))
+                } else {
+                    Cow::Borrowed(s)
+                };
 
                 // Support either signed range (-2^127..2^127) or
                 // unsigned range (0..2^128).
-                let num = i128::from_str_radix(s_utf8, radix)
-                    .or_else(|_| u128::from_str_radix(s_utf8, radix).map(|val| val as i128))
-                    .map_err(|e| self.error(start_pos, e.to_string()))?;
-
-                let tok = if neg {
-                    Token::Int(num.checked_neg().ok_or_else(|| {
-                        self.error(start_pos, "integer literal cannot fit in i128")
-                    })?)
-                } else {
-                    Token::Int(num)
+                let num = match u128::from_str_radix(&s, radix) {
+                    Ok(num) => num,
+                    Err(err) => return Err(self.error(start_pos, err.to_string())),
                 };
+
+                let num = match (neg, num) {
+                    (true, 0x80000000000000000000000000000000) => {
+                        return Err(self.error(start_pos, "integer literal cannot fit in i128"))
+                    }
+                    (true, _) => -(num as i128),
+                    (false, _) => num as i128,
+                };
+                let tok = Token::Int(num);
+
                 Ok(Some((start_pos, tok)))
             }
-            c => Err(self.error(self.pos, format!("Unexpected character '{}'", c))),
+            c => Err(self.error(self.pos, format!("Unexpected character '{c}'"))),
         }
     }
 
@@ -313,7 +237,7 @@ impl<'a> Lexer<'a> {
     }
 
     fn reload(&mut self) -> Result<()> {
-        if self.lookahead.is_none() && self.pos.offset < self.buf.len() {
+        if self.lookahead.is_none() && self.pos.offset < self.src.len() {
             self.lookahead = self.next_token()?;
         }
         Ok(())
@@ -328,6 +252,10 @@ impl<'a> Lexer<'a> {
     pub fn eof(&self) -> bool {
         self.lookahead.is_none()
     }
+
+    fn peek_byte(&self) -> Option<u8> {
+        self.src.as_bytes().get(self.pos.offset).copied()
+    }
 }
 
 impl Token {
@@ -346,9 +274,10 @@ impl Token {
 mod test {
     use super::*;
 
-    fn lex(s: &str, file: &str) -> Vec<Token> {
+    #[track_caller]
+    fn lex(src: &str) -> Vec<Token> {
         let mut toks = vec![];
-        let mut lexer = Lexer::from_str(s, file).unwrap();
+        let mut lexer = Lexer::new(0, src).unwrap();
         while let Some((_, tok)) = lexer.next().unwrap() {
             toks.push(tok);
         }
@@ -358,11 +287,8 @@ mod test {
     #[test]
     fn lexer_basic() {
         assert_eq!(
-            lex(
-                ";; comment\n; another\r\n   \t(one two three 23 -568  )\n",
-                "lexer_basic"
-            ),
-            vec![
+            lex(";; comment\n; another\r\n   \t(one two three 23 -568  )\n"),
+            [
                 Token::LParen,
                 Token::Symbol("one".to_string()),
                 Token::Symbol("two".to_string()),
@@ -376,22 +302,19 @@ mod test {
 
     #[test]
     fn ends_with_sym() {
-        assert_eq!(
-            lex("asdf", "ends_with_sym"),
-            vec![Token::Symbol("asdf".to_string()),]
-        );
+        assert_eq!(lex("asdf"), [Token::Symbol("asdf".to_string())]);
     }
 
     #[test]
     fn ends_with_num() {
-        assert_eq!(lex("23", "ends_with_num"), vec![Token::Int(23)],);
+        assert_eq!(lex("23"), [Token::Int(23)]);
     }
 
     #[test]
     fn weird_syms() {
         assert_eq!(
-            lex("(+ [] => !! _test!;comment\n)", "weird_syms"),
-            vec![
+            lex("(+ [] => !! _test!;comment\n)"),
+            [
                 Token::LParen,
                 Token::Symbol("+".to_string()),
                 Token::Symbol("[]".to_string()),
@@ -402,4 +325,24 @@ mod test {
             ]
         );
     }
+
+    #[test]
+    fn integers() {
+        assert_eq!(
+            lex("0 1 -1"),
+            [Token::Int(0), Token::Int(1), Token::Int(-1)]
+        );
+
+        assert_eq!(
+            lex("340_282_366_920_938_463_463_374_607_431_768_211_455"),
+            [Token::Int(-1)]
+        );
+
+        assert_eq!(
+            lex("170_141_183_460_469_231_731_687_303_715_884_105_727"),
+            [Token::Int(i128::MAX)]
+        );
+
+        assert!(Lexer::new(0, "-170_141_183_460_469_231_731_687_303_715_884_105_728").is_err())
+    }
 }
diff --git a/cranelift/isle/isle/src/lib.rs b/cranelift/isle/isle/src/lib.rs
index a01d5a8da0ac..b1574119b840 100644
--- a/cranelift/isle/isle/src/lib.rs
+++ b/cranelift/isle/isle/src/lib.rs
@@ -1,10 +1,7 @@
 #![doc = include_str!("../README.md")]
 #![deny(missing_docs)]
 
-use std::collections::hash_map::Entry;
-use std::collections::{HashMap, HashSet};
-use std::hash::Hash;
-use std::ops::Index;
+// QUESTION(mbm): is it okay to derive Default for ID types?
 
 macro_rules! declare_id {
     (
@@ -12,7 +9,7 @@ macro_rules! declare_id {
             $name:ident
     ) => {
         $(#[$attr])*
-            #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+            #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
         pub struct $name(pub usize);
         impl $name {
             /// Get the index of this id.
@@ -23,249 +20,19 @@ macro_rules! declare_id {
     };
 }
 
-/// A wrapper around a [HashSet] which prevents accidentally observing the non-deterministic
-/// iteration order.
-#[derive(Clone, Debug, Default)]
-pub struct StableSet<T>(HashSet<T>);
-
-impl<T> StableSet<T> {
-    fn new() -> Self {
-        StableSet(HashSet::new())
-    }
-}
-
-impl<T: Hash + Eq> StableSet<T> {
-    /// Adds a value to the set. Returns whether the value was newly inserted.
-    pub fn insert(&mut self, val: T) -> bool {
-        self.0.insert(val)
-    }
-
-    /// Returns true if the set contains a value.
-    pub fn contains(&self, val: &T) -> bool {
-        self.0.contains(val)
-    }
-}
-
-/// A wrapper around a [HashMap] which prevents accidentally observing the non-deterministic
-/// iteration order.
-#[derive(Clone, Debug)]
-pub struct StableMap<K, V>(HashMap<K, V>);
-
-impl<K, V> StableMap<K, V> {
-    fn new() -> Self {
-        StableMap(HashMap::new())
-    }
-
-    fn len(&self) -> usize {
-        self.0.len()
-    }
-}
-
-// NOTE: Can't auto-derive this
-impl<K, V> Default for StableMap<K, V> {
-    fn default() -> Self {
-        StableMap(HashMap::new())
-    }
-}
-
-impl<K: Hash + Eq, V> StableMap<K, V> {
-    fn insert(&mut self, k: K, v: V) -> Option<V> {
-        self.0.insert(k, v)
-    }
-
-    fn contains_key(&self, k: &K) -> bool {
-        self.0.contains_key(k)
-    }
-
-    fn get(&self, k: &K) -> Option<&V> {
-        self.0.get(k)
-    }
-
-    fn entry(&mut self, k: K) -> Entry<K, V> {
-        self.0.entry(k)
-    }
-}
-
-impl<K: Hash + Eq, V> Index<&K> for StableMap<K, V> {
-    type Output = V;
-
-    fn index(&self, index: &K) -> &Self::Output {
-        self.0.index(index)
-    }
-}
-
-/// Stores disjoint sets and provides efficient operations to merge two sets, and to find a
-/// representative member of a set given any member of that set. In this implementation, sets always
-/// have at least two members, and can only be formed by the `merge` operation.
-#[derive(Clone, Debug, Default)]
-pub struct DisjointSets<T> {
-    parent: HashMap<T, (T, u8)>,
-}
-
-impl<T: Copy + std::fmt::Debug + Eq + Hash> DisjointSets<T> {
-    /// Find a representative member of the set containing `x`. If `x` has not been merged with any
-    /// other items using `merge`, returns `None`. This method updates the data structure to make
-    /// future queries faster, and takes amortized constant time.
-    ///
-    /// ```
-    /// let mut sets = cranelift_isle::DisjointSets::default();
-    /// sets.merge(1, 2);
-    /// sets.merge(1, 3);
-    /// sets.merge(2, 4);
-    /// assert_eq!(sets.find_mut(3).unwrap(), sets.find_mut(4).unwrap());
-    /// assert_eq!(sets.find_mut(10), None);
-    /// ```
-    pub fn find_mut(&mut self, mut x: T) -> Option<T> {
-        while let Some(node) = self.parent.get(&x) {
-            if node.0 == x {
-                return Some(x);
-            }
-            let grandparent = self.parent[&node.0].0;
-            // Re-do the lookup but take a mutable borrow this time
-            self.parent.get_mut(&x).unwrap().0 = grandparent;
-            x = grandparent;
-        }
-        None
-    }
-
-    /// Find a representative member of the set containing `x`. If `x` has not been merged with any
-    /// other items using `merge`, returns `None`. This method does not update the data structure to
-    /// make future queries faster, so `find_mut` should be preferred.
-    ///
-    /// ```
-    /// let mut sets = cranelift_isle::DisjointSets::default();
-    /// sets.merge(1, 2);
-    /// sets.merge(1, 3);
-    /// sets.merge(2, 4);
-    /// assert_eq!(sets.find(3).unwrap(), sets.find(4).unwrap());
-    /// assert_eq!(sets.find(10), None);
-    /// ```
-    pub fn find(&self, mut x: T) -> Option<T> {
-        while let Some(node) = self.parent.get(&x) {
-            if node.0 == x {
-                return Some(x);
-            }
-            x = node.0;
-        }
-        None
-    }
-
-    /// Merge the set containing `x` with the set containing `y`. This method takes amortized
-    /// constant time.
-    pub fn merge(&mut self, x: T, y: T) {
-        assert_ne!(x, y);
-        let mut x = if let Some(x) = self.find_mut(x) {
-            self.parent[&x]
-        } else {
-            self.parent.insert(x, (x, 0));
-            (x, 0)
-        };
-        let mut y = if let Some(y) = self.find_mut(y) {
-            self.parent[&y]
-        } else {
-            self.parent.insert(y, (y, 0));
-            (y, 0)
-        };
-
-        if x == y {
-            return;
-        }
-
-        if x.1 < y.1 {
-            std::mem::swap(&mut x, &mut y);
-        }
-
-        self.parent.get_mut(&y.0).unwrap().0 = x.0;
-        if x.1 == y.1 {
-            let x_rank = &mut self.parent.get_mut(&x.0).unwrap().1;
-            *x_rank = x_rank.saturating_add(1);
-        }
-    }
-
-    /// Returns whether the given items have both been merged into the same set. If either is not
-    /// part of any set, returns `false`.
-    ///
-    /// ```
-    /// let mut sets = cranelift_isle::DisjointSets::default();
-    /// sets.merge(1, 2);
-    /// sets.merge(1, 3);
-    /// sets.merge(2, 4);
-    /// sets.merge(5, 6);
-    /// assert!(sets.in_same_set(2, 3));
-    /// assert!(sets.in_same_set(1, 4));
-    /// assert!(sets.in_same_set(3, 4));
-    /// assert!(!sets.in_same_set(4, 5));
-    /// ```
-    pub fn in_same_set(&self, x: T, y: T) -> bool {
-        let x = self.find(x);
-        let y = self.find(y);
-        x.zip(y).filter(|(x, y)| x == y).is_some()
-    }
-
-    /// Remove the set containing the given item, and return all members of that set. The set is
-    /// returned in sorted order. This method takes time linear in the total size of all sets.
-    ///
-    /// ```
-    /// let mut sets = cranelift_isle::DisjointSets::default();
-    /// sets.merge(1, 2);
-    /// sets.merge(1, 3);
-    /// sets.merge(2, 4);
-    /// assert_eq!(sets.remove_set_of(4), &[1, 2, 3, 4]);
-    /// assert_eq!(sets.remove_set_of(1), &[]);
-    /// assert!(sets.is_empty());
-    /// ```
-    pub fn remove_set_of(&mut self, x: T) -> Vec<T>
-    where
-        T: Ord,
-    {
-        let mut set = Vec::new();
-        if let Some(x) = self.find_mut(x) {
-            set.extend(self.parent.keys().copied());
-            // It's important to use `find_mut` here to avoid quadratic worst-case time.
-            set.retain(|&y| self.find_mut(y).unwrap() == x);
-            for y in set.iter() {
-                self.parent.remove(y);
-            }
-            set.sort_unstable();
-        }
-        set
-    }
-
-    /// Returns true if there are no sets. This method takes constant time.
-    ///
-    /// ```
-    /// let mut sets = cranelift_isle::DisjointSets::default();
-    /// assert!(sets.is_empty());
-    /// sets.merge(1, 2);
-    /// assert!(!sets.is_empty());
-    /// ```
-    pub fn is_empty(&self) -> bool {
-        self.parent.is_empty()
-    }
-
-    /// Returns the total number of elements in all sets. This method takes constant time.
-    ///
-    /// ```
-    /// let mut sets = cranelift_isle::DisjointSets::default();
-    /// sets.merge(1, 2);
-    /// assert_eq!(sets.len(), 2);
-    /// sets.merge(3, 4);
-    /// sets.merge(3, 5);
-    /// assert_eq!(sets.len(), 5);
-    /// ```
-    pub fn len(&self) -> usize {
-        self.parent.len()
-    }
-}
-
 pub mod ast;
 pub mod codegen;
 pub mod compile;
+pub mod disjointsets;
 pub mod error;
+pub mod files;
 pub mod lexer;
 mod log;
 pub mod overlap;
 pub mod parser;
+#[cfg(feature = "printer")]
+pub mod printer;
 pub mod sema;
 pub mod serialize;
+pub mod stablemapset;
 pub mod trie_again;
diff --git a/cranelift/isle/isle/src/overlap.rs b/cranelift/isle/isle/src/overlap.rs
index d5fb4396d6b7..3ce946a30214 100644
--- a/cranelift/isle/isle/src/overlap.rs
+++ b/cranelift/isle/isle/src/overlap.rs
@@ -3,27 +3,20 @@
 use std::collections::hash_map::Entry;
 use std::collections::{HashMap, HashSet};
 
-use crate::error::{self, Error, Span};
+use crate::error::{Error, Span};
 use crate::lexer::Pos;
-use crate::sema::{TermEnv, TermId, TermKind, TypeEnv};
+use crate::sema::{TermEnv, TermId, TermKind};
 use crate::trie_again;
 
 /// Check for overlap.
-pub fn check(
-    tyenv: &TypeEnv,
-    termenv: &TermEnv,
-) -> Result<Vec<(TermId, trie_again::RuleSet)>, error::Errors> {
+pub fn check(termenv: &TermEnv) -> Result<Vec<(TermId, trie_again::RuleSet)>, Vec<Error>> {
     let (terms, mut errors) = trie_again::build(termenv);
     errors.append(&mut check_overlaps(&terms, termenv).report());
 
     if errors.is_empty() {
         Ok(terms)
     } else {
-        Err(error::Errors {
-            errors,
-            filenames: tyenv.filenames.clone(),
-            file_texts: tyenv.file_texts.clone(),
-        })
+        Err(errors)
     }
 }
 
diff --git a/cranelift/isle/isle/src/parser.rs b/cranelift/isle/isle/src/parser.rs
index b613e65c5c75..5fe74ee051c6 100644
--- a/cranelift/isle/isle/src/parser.rs
+++ b/cranelift/isle/isle/src/parser.rs
@@ -1,14 +1,27 @@
 //! Parser for ISLE language.
 
-use crate::ast::*;
-use crate::error::{Error, Errors, Span};
+#![allow(missing_docs)]
+
+use crate::error::{Error, Span};
+use crate::files::Files;
 use crate::lexer::{Lexer, Pos, Token};
+use crate::{ast::*, log};
+use std::sync::Arc;
 
-type Result<T> = std::result::Result<T, Errors>;
+type Result<T> = std::result::Result<T, Error>;
 
 /// Parse the top-level ISLE definitions and return their AST.
-pub fn parse(lexer: Lexer) -> Result<Defs> {
-    let parser = Parser::new(lexer);
+pub fn parse(lexer: Lexer, files: Arc<Files>) -> Result<Vec<Def>> {
+    let mut parser = Parser::new(lexer, files);
+    let result = parser.parse_defs()?;
+    Ok(result)
+}
+
+/// Parse without positional information. Provided mainly to support testing, to
+/// enable equality testing on structure alone.
+pub fn parse_without_pos(lexer: Lexer, files: Arc<Files>) -> Result<Vec<Def>> {
+    let mut parser = Parser::new(lexer, files);
+    parser.disable_pos();
     parser.parse_defs()
 }
 
@@ -16,8 +29,10 @@ pub fn parse(lexer: Lexer) -> Result<Defs> {
 ///
 /// Takes in a lexer and creates an AST.
 #[derive(Clone, Debug)]
-struct Parser<'a> {
+pub struct Parser<'a> {
     lexer: Lexer<'a>,
+    files: Arc<Files>,
+    disable_pos: bool,
 }
 
 /// Used during parsing a `(rule ...)` to encapsulate some form that
@@ -30,25 +45,29 @@ enum IfLetOrExpr {
 
 impl<'a> Parser<'a> {
     /// Construct a new parser from the given lexer.
-    pub fn new(lexer: Lexer<'a>) -> Parser<'a> {
-        Parser { lexer }
+    pub fn new(lexer: Lexer<'a>, files: Arc<Files>) -> Parser<'a> {
+        Parser {
+            lexer,
+            files,
+            disable_pos: false,
+        }
     }
 
-    fn error(&self, pos: Pos, msg: String) -> Errors {
-        Errors {
-            errors: vec![Error::ParseError {
-                msg,
-                span: Span::new_single(pos),
-            }],
-            filenames: self.lexer.filenames.clone(),
-            file_texts: self.lexer.file_texts.clone(),
+    pub fn disable_pos(&mut self) {
+        self.disable_pos = true;
+    }
+
+    fn error(&self, pos: Pos, msg: String) -> Error {
+        Error::ParseError {
+            msg,
+            span: Span::new_single(pos),
         }
     }
 
     fn expect<F: Fn(&Token) -> bool>(&mut self, f: F) -> Result<Token> {
         if let Some(&(pos, ref peek)) = self.lexer.peek() {
             if !f(peek) {
-                return Err(self.error(pos, format!("Unexpected token {:?}", peek)));
+                return Err(self.error(pos, format!("Unexpected token {peek:?}")));
             }
             Ok(self.lexer.next()?.unwrap().1)
         } else {
@@ -76,9 +95,13 @@ impl<'a> Parser<'a> {
     }
 
     fn pos(&self) -> Pos {
-        self.lexer
-            .peek()
-            .map_or_else(|| self.lexer.pos(), |(pos, _)| *pos)
+        if !self.disable_pos {
+            self.lexer
+                .peek()
+                .map_or_else(|| self.lexer.pos(), |(pos, _)| *pos)
+        } else {
+            Pos::default()
+        }
     }
 
     fn is_lparen(&self) -> bool {
@@ -104,6 +127,20 @@ impl<'a> Parser<'a> {
         })
     }
 
+    fn is_spec_bit_vector(&self) -> bool {
+        self.is(|tok| match tok {
+            Token::Symbol(tok_s) if tok_s.starts_with("#x") || tok_s.starts_with("#b") => true,
+            _ => false,
+        })
+    }
+
+    fn is_spec_bool(&self) -> bool {
+        self.is(|tok| match tok {
+            Token::Symbol(tok_s) if tok_s == "true" || tok_s == "false" => true,
+            _ => false,
+        })
+    }
+
     fn expect_lparen(&mut self) -> Result<()> {
         self.expect(|tok| *tok == Token::LParen).map(|_| ())
     }
@@ -136,16 +173,12 @@ impl<'a> Parser<'a> {
         }
     }
 
-    fn parse_defs(mut self) -> Result<Defs> {
+    fn parse_defs(&mut self) -> Result<Vec<Def>> {
         let mut defs = vec![];
         while !self.lexer.eof() {
             defs.push(self.parse_def()?);
         }
-        Ok(Defs {
-            defs,
-            filenames: self.lexer.filenames,
-            file_texts: self.lexer.file_texts,
-        })
+        Ok(defs)
     }
 
     fn parse_def(&mut self) -> Result<Def> {
@@ -155,14 +188,22 @@ impl<'a> Parser<'a> {
             "pragma" => Def::Pragma(self.parse_pragma()?),
             "type" => Def::Type(self.parse_type()?),
             "decl" => Def::Decl(self.parse_decl()?),
+            "attr" => Def::Attr(self.parse_attr()?),
+            "spec" => Def::Spec(self.parse_spec()?),
+            "macro" => Def::SpecMacro(self.parse_spec_macro()?),
+            "state" => Def::State(self.parse_state()?),
+            "model" => Def::Model(self.parse_model()?),
+            "form" => Def::Form(self.parse_form()?),
+            "instantiate" => Def::Instantiation(self.parse_instantiation()?),
             "rule" => Def::Rule(self.parse_rule()?),
             "extractor" => Def::Extractor(self.parse_etor()?),
             "extern" => Def::Extern(self.parse_extern()?),
             "convert" => Def::Converter(self.parse_converter()?),
             s => {
-                return Err(self.error(pos, format!("Unexpected identifier: {}", s)));
+                return Err(self.error(pos, format!("Unexpected identifier: {s}")));
             }
         };
+        self.count_lines(pos, &def);
         self.expect_rparen()?;
         Ok(def)
     }
@@ -175,7 +216,7 @@ impl<'a> Parser<'a> {
         if !first.is_alphabetic() && first != '_' && first != '$' {
             return Err(self.error(
                 pos,
-                format!("Identifier '{}' does not start with letter or _ or $", s),
+                format!("Identifier '{s}' does not start with letter or _ or $"),
             ));
         }
         if s.chars()
@@ -184,10 +225,7 @@ impl<'a> Parser<'a> {
         {
             return Err(self.error(
                 pos,
-                format!(
-                    "Identifier '{}' contains invalid character (not a-z, A-Z, 0-9, _, ., $)",
-                    s
-                ),
+                format!("Identifier '{s}' contains invalid character (not a-z, A-Z, 0-9, _, ., $)"),
             ));
         }
         Ok(Ident(s.to_string(), pos))
@@ -216,7 +254,7 @@ impl<'a> Parser<'a> {
         let ident = self.parse_ident()?;
         // currently, no pragmas are defined, but the infrastructure is useful to keep around
         let pragma = ident.0.as_str();
-        Err(self.error(ident.1, format!("Unknown pragma '{}'", pragma)))
+        Err(self.error(ident.1, format!("Unknown pragma '{pragma}'")))
     }
 
     fn parse_type(&mut self) -> Result<Type> {
@@ -235,7 +273,7 @@ impl<'a> Parser<'a> {
             } else {
                 return Err(self.error(
                     self.pos(),
-                    format!("unknown type declaration modifier: {}", sym),
+                    format!("unknown type declaration modifier: {sym}"),
                 ));
             }
         }
@@ -330,6 +368,623 @@ impl<'a> Parser<'a> {
         })
     }
 
+    fn parse_attr(&mut self) -> Result<Attr> {
+        let pos = self.pos();
+        let rule = self.eat_sym_str("rule")?;
+        let name = self.parse_ident()?;
+        let target = if rule {
+            AttrTarget::Rule(name)
+        } else {
+            AttrTarget::Term(name)
+        };
+        let mut kinds = Vec::new();
+        while !self.is_rparen() {
+            kinds.push(self.parse_attr_kind()?);
+        }
+        Ok(Attr { target, kinds, pos })
+    }
+
+    fn parse_attr_kind(&mut self) -> Result<AttrKind> {
+        self.expect_lparen()?;
+        let pos = self.pos();
+        let kind = match &self.expect_symbol()?[..] {
+            "veri" => self.parse_attr_kind_veri()?,
+            "tag" => AttrKind::Tag(self.parse_ident()?),
+            x => return Err(self.error(pos, format!("Not a valid attribute: {x}"))),
+        };
+        self.expect_rparen()?;
+        Ok(kind)
+    }
+
+    fn parse_attr_kind_veri(&mut self) -> Result<AttrKind> {
+        let pos = self.pos();
+        match &self.expect_symbol()?[..] {
+            "chain" => Ok(AttrKind::Chain),
+            "priority" => Ok(AttrKind::Priority),
+            x => Err(self.error(pos, format!("Not a valid verification attribute: {x}"))),
+        }
+    }
+
+    fn parse_spec(&mut self) -> Result<Spec> {
+        let pos = self.pos();
+        self.expect_lparen()?; // term with args: (spec (<term> <args>) (provide ...) ...)
+        let term = self.parse_ident()?;
+        let mut args = vec![];
+        while !self.is_rparen() {
+            args.push(self.parse_ident()?);
+        }
+        self.expect_rparen()?; // end term with args
+
+        let mut provides = Vec::new();
+        let mut requires = Vec::new();
+        let mut matches = Vec::new();
+        let mut modifies = Vec::new();
+        while self.is_lparen() {
+            self.expect_lparen()?;
+            match &self.expect_symbol()?[..] {
+                "provide" => {
+                    while !self.is_rparen() {
+                        provides.push(self.parse_spec_expr()?);
+                    }
+                }
+                "require" => {
+                    while !self.is_rparen() {
+                        requires.push(self.parse_spec_expr()?);
+                    }
+                }
+                "match" => {
+                    while !self.is_rparen() {
+                        matches.push(self.parse_spec_expr()?);
+                    }
+                }
+                "modifies" => {
+                    let state = self.parse_ident()?;
+                    let cond = if self.is_sym() {
+                        Some(self.parse_ident().map_err(|err| {
+                            self.error(pos, format!("Invalid modifies condition: {err:?}"))
+                        })?)
+                    } else {
+                        None
+                    };
+                    modifies.push(Modifies { state, cond });
+                }
+                field => {
+                    return Err(self.error(
+                        pos,
+                        format!("Invalid spec: unexpected field {field}. Expect (provide ...), (require ...) or (match ...)"),
+                    ));
+                }
+            }
+            self.expect_rparen()?;
+        }
+
+        Ok(Spec {
+            term,
+            args,
+            provides,
+            requires,
+            matches,
+            modifies,
+            pos,
+        })
+    }
+
+    fn parse_spec_macro(&mut self) -> Result<SpecMacro> {
+        let pos = self.pos();
+
+        // Signature.
+        self.expect_lparen()?;
+        let name = self.parse_ident()?;
+        let mut params = vec![];
+        while !self.is_rparen() {
+            params.push(self.parse_ident()?);
+        }
+        self.expect_rparen()?;
+
+        // Body.
+        let body = self.parse_spec_expr()?;
+
+        Ok(SpecMacro {
+            name,
+            params,
+            body,
+            pos,
+        })
+    }
+
+    fn parse_spec_expr(&mut self) -> Result<SpecExpr> {
+        let pos = self.pos();
+        if self.is_spec_bit_vector() {
+            let (val, width) = self.parse_spec_bit_vector()?;
+            Ok(SpecExpr::ConstBitVec { val, width, pos })
+        } else if self.is_int() {
+            Ok(SpecExpr::ConstInt {
+                val: self.expect_int()?,
+                pos,
+            })
+        } else if self.is_spec_bool() {
+            let val = self.parse_spec_bool()?;
+            Ok(SpecExpr::ConstBool { val, pos })
+        } else if self.is_sym() {
+            let var = self.parse_ident()?;
+            Ok(SpecExpr::Var { var, pos })
+        } else if self.is_lparen() {
+            self.expect_lparen()?;
+            if self.eat_sym_str("switch")? {
+                let mut args = vec![];
+                args.push(self.parse_spec_expr()?);
+                while !(self.is_rparen()) {
+                    self.expect_lparen()?;
+                    let pos = self.pos();
+                    let l = Box::new(self.parse_spec_expr()?);
+                    let r = Box::new(self.parse_spec_expr()?);
+                    self.expect_rparen()?;
+                    args.push(SpecExpr::Pair { l, r, pos });
+                }
+                self.expect_rparen()?;
+                Ok(SpecExpr::Op {
+                    op: SpecOp::Switch,
+                    args,
+                    pos,
+                })
+            } else if self.eat_sym_str("let")? {
+                let mut defs = Vec::new();
+                self.expect_lparen()?;
+                while !(self.is_rparen()) {
+                    self.expect_lparen()?;
+                    let ident = self.parse_ident()?;
+                    let x = self.parse_spec_expr()?;
+                    self.expect_rparen()?;
+                    defs.push((ident, x));
+                }
+                self.expect_rparen()?;
+                let body = Box::new(self.parse_spec_expr()?);
+                self.expect_rparen()?;
+                Ok(SpecExpr::Let { defs, body, pos })
+            } else if self.eat_sym_str("with")? {
+                let mut decls = Vec::new();
+                self.expect_lparen()?;
+                while !(self.is_rparen()) {
+                    let ident = self.parse_ident()?;
+                    decls.push(ident);
+                }
+                self.expect_rparen()?;
+                let body = Box::new(self.parse_spec_expr()?);
+                self.expect_rparen()?;
+                Ok(SpecExpr::With { decls, body, pos })
+            } else if self.eat_sym_str("match")? {
+                let x = Box::new(self.parse_spec_expr()?);
+                let mut arms = Vec::new();
+                while !(self.is_rparen()) {
+                    let arm = self.parse_arm()?;
+                    arms.push(arm);
+                }
+                self.expect_rparen()?;
+                Ok(SpecExpr::Match { x, arms, pos })
+            } else if self.eat_sym_str("struct")? {
+                let mut fields = Vec::new();
+                while !(self.is_rparen()) {
+                    let field = self.parse_field_init()?;
+                    fields.push(field);
+                }
+                self.expect_rparen()?;
+                Ok(SpecExpr::Struct { fields, pos })
+            } else if self.eat_sym_str("macro")? {
+                self.expect_lparen()?;
+                let mut params = vec![];
+                while !self.is_rparen() {
+                    params.push(self.parse_ident()?);
+                }
+                self.expect_rparen()?;
+                let body = Box::new(self.parse_spec_expr()?);
+                self.expect_rparen()?;
+                Ok(SpecExpr::Macro { params, body, pos })
+            } else if self.eat_sym_str("as")? {
+                let x = Box::new(self.parse_spec_expr()?);
+                let ty = self.parse_model_type()?;
+                self.expect_rparen()?;
+                Ok(SpecExpr::As { x, ty, pos })
+            } else if self.is_sym() && !self.is_spec_bit_vector() {
+                let sym_pos = self.pos();
+                let sym = self.expect_symbol()?;
+                if let Some(variant) = sym.strip_suffix('?') {
+                    let variant = self.str_to_ident(sym_pos, variant)?;
+                    let x = Box::new(self.parse_spec_expr()?);
+                    self.expect_rparen()?;
+                    Ok(SpecExpr::Discriminator { variant, x, pos })
+                } else if let Some(name) = sym.strip_suffix('!') {
+                    let name = self.str_to_ident(sym_pos, name)?;
+                    let mut args: Vec<SpecExpr> = vec![];
+                    while !self.is_rparen() {
+                        args.push(self.parse_spec_expr()?);
+                    }
+                    self.expect_rparen()?;
+                    Ok(SpecExpr::Expand { name, args, pos })
+                } else if let Ok(op) = self.parse_spec_op(sym.as_str()) {
+                    let mut args: Vec<SpecExpr> = vec![];
+                    while !self.is_rparen() {
+                        args.push(self.parse_spec_expr()?);
+                    }
+                    self.expect_rparen()?;
+                    Ok(SpecExpr::Op { op, args, pos })
+                } else if let Some(field) = sym.strip_prefix(':') {
+                    let field = self.str_to_ident(sym_pos, field)?;
+                    let x = Box::new(self.parse_spec_expr()?);
+                    self.expect_rparen()?;
+                    Ok(SpecExpr::Field { field, x, pos })
+                } else if let Some((name, variant)) = sym.split_once('.') {
+                    let name = self.str_to_ident(pos, &name)?;
+                    let variant = self.str_to_ident(pos, &variant)?;
+                    let mut args: Vec<SpecExpr> = vec![];
+                    while !self.is_rparen() {
+                        args.push(self.parse_spec_expr()?);
+                    }
+                    self.expect_rparen()?;
+                    Ok(SpecExpr::Enum {
+                        name,
+                        variant,
+                        args,
+                        pos,
+                    })
+                } else {
+                    Err(self.error(pos, "Unexpected spec expression".into()))
+                }
+            } else {
+                // TODO(mbm): support Unit
+                Err(self.error(pos, "Unexpected spec expression".into()))
+            }
+        } else {
+            Err(self.error(pos, "Unexpected spec expression".into()))
+        }
+    }
+
+    fn parse_spec_op(&mut self, s: &str) -> Result<SpecOp> {
+        let pos = self.pos();
+        match s {
+            "=" => Ok(SpecOp::Eq),
+            "and" => Ok(SpecOp::And),
+            "not" => Ok(SpecOp::Not),
+            "=>" => Ok(SpecOp::Imp),
+            "or" => Ok(SpecOp::Or),
+            "+" => Ok(SpecOp::Add),
+            "-" => Ok(SpecOp::Sub),
+            "*" => Ok(SpecOp::Mul),
+            "<=" => Ok(SpecOp::Lte),
+            "<" => Ok(SpecOp::Lt),
+            ">=" => Ok(SpecOp::Gte),
+            ">" => Ok(SpecOp::Gt),
+            "bvnot" => Ok(SpecOp::BVNot),
+            "bvand" => Ok(SpecOp::BVAnd),
+            "bvor" => Ok(SpecOp::BVOr),
+            "bvxor" => Ok(SpecOp::BVXor),
+            "bvneg" => Ok(SpecOp::BVNeg),
+            "bvadd" => Ok(SpecOp::BVAdd),
+            "bvsub" => Ok(SpecOp::BVSub),
+            "bvmul" => Ok(SpecOp::BVMul),
+            "bvudiv" => Ok(SpecOp::BVUdiv),
+            "bvurem" => Ok(SpecOp::BVUrem),
+            "bvsdiv" => Ok(SpecOp::BVSdiv),
+            "bvsrem" => Ok(SpecOp::BVSrem),
+            "bvshl" => Ok(SpecOp::BVShl),
+            "bvlshr" => Ok(SpecOp::BVLshr),
+            "bvashr" => Ok(SpecOp::BVAshr),
+            "bvsaddo" => Ok(SpecOp::BVSaddo),
+            "bvule" => Ok(SpecOp::BVUle),
+            "bvult" => Ok(SpecOp::BVUlt),
+            "bvugt" => Ok(SpecOp::BVUgt),
+            "bvuge" => Ok(SpecOp::BVUge),
+            "bvslt" => Ok(SpecOp::BVSlt),
+            "bvsle" => Ok(SpecOp::BVSle),
+            "bvsgt" => Ok(SpecOp::BVSgt),
+            "bvsge" => Ok(SpecOp::BVSge),
+            "rotr" => Ok(SpecOp::Rotr),
+            "rotl" => Ok(SpecOp::Rotl),
+            "extract" => Ok(SpecOp::Extract),
+            "zero_ext" => Ok(SpecOp::ZeroExt),
+            "sign_ext" => Ok(SpecOp::SignExt),
+            "concat" => Ok(SpecOp::Concat),
+            "replicate" => Ok(SpecOp::Replicate),
+            "conv_to" => Ok(SpecOp::ConvTo),
+            "int2bv" => Ok(SpecOp::Int2BV),
+            "bv2nat" => Ok(SpecOp::BV2Nat),
+            "widthof" => Ok(SpecOp::WidthOf),
+            "if" => Ok(SpecOp::If),
+            "switch" => Ok(SpecOp::Switch),
+            "popcnt" => Ok(SpecOp::Popcnt),
+            "rev" => Ok(SpecOp::Rev),
+            "cls" => Ok(SpecOp::Cls),
+            "clz" => Ok(SpecOp::Clz),
+            "to_fp" => Ok(SpecOp::ToFP),
+            "fp.to_ubv" => Ok(SpecOp::FPToUBV),
+            "fp.to_sbv" => Ok(SpecOp::FPToSBV),
+            "to_fp_unsigned" => Ok(SpecOp::ToFPUnsigned),
+            "to_fp_from_fp" => Ok(SpecOp::ToFPFromFP),
+            "fp.+oo" => Ok(SpecOp::FPPositiveInfinity),
+            "fp.-oo" => Ok(SpecOp::FPNegativeInfinity),
+            "fp.+zero" => Ok(SpecOp::FPPositiveZero),
+            "fp.-zero" => Ok(SpecOp::FPNegativeZero),
+            "fp.NaN" => Ok(SpecOp::FPNaN),
+            "fp.eq" => Ok(SpecOp::FPEq),
+            "fp.ne" => Ok(SpecOp::FPNe),
+            "fp.lt" => Ok(SpecOp::FPLt),
+            "fp.gt" => Ok(SpecOp::FPGt),
+            "fp.le" => Ok(SpecOp::FPLe),
+            "fp.ge" => Ok(SpecOp::FPGe),
+            "fp.add" => Ok(SpecOp::FPAdd),
+            "fp.sub" => Ok(SpecOp::FPSub),
+            "fp.mul" => Ok(SpecOp::FPMul),
+            "fp.div" => Ok(SpecOp::FPDiv),
+            "fp.min" => Ok(SpecOp::FPMin),
+            "fp.max" => Ok(SpecOp::FPMax),
+            "fp.neg" => Ok(SpecOp::FPNeg),
+            "fp.ceil" => Ok(SpecOp::FPCeil),
+            "fp.floor" => Ok(SpecOp::FPFloor),
+            "fp.sqrt" => Ok(SpecOp::FPSqrt),
+            "fp.trunc" => Ok(SpecOp::FPTrunc),
+            "fp.nearest" => Ok(SpecOp::FPNearest),
+            "fp.isZero" => Ok(SpecOp::FPIsZero),
+            "fp.isInfinite" => Ok(SpecOp::FPIsInfinite),
+            "fp.isNaN" => Ok(SpecOp::FPIsNaN),
+            "fp.isNegative" => Ok(SpecOp::FPIsNegative),
+            "fp.isPositive" => Ok(SpecOp::FPIsPositive),
+            x => Err(self.error(pos, format!("Not a valid spec operator: {x}"))),
+        }
+    }
+
+    fn parse_arm(&mut self) -> Result<Arm> {
+        self.expect_lparen()?;
+        let pos = self.pos();
+        self.expect_lparen()?;
+        let variant = self.parse_ident()?;
+        let mut args = Vec::new();
+        while !self.is_rparen() {
+            args.push(self.parse_ident()?);
+        }
+        self.expect_rparen()?;
+        let body = self.parse_spec_expr()?;
+        self.expect_rparen()?;
+        Ok(Arm {
+            variant,
+            args,
+            body,
+            pos,
+        })
+    }
+
+    fn parse_field_init(&mut self) -> Result<FieldInit> {
+        self.expect_lparen()?;
+        let pos = self.pos();
+        let name = self.parse_ident()?;
+        let value = Box::new(self.parse_spec_expr()?);
+        self.expect_rparen()?;
+        Ok(FieldInit { name, value, pos })
+    }
+
+    fn parse_spec_bit_vector(&mut self) -> Result<(u128, usize)> {
+        let pos = self.pos();
+        let s = self.expect_symbol()?;
+        if let Some(s) = s.strip_prefix("#b") {
+            match u128::from_str_radix(s, 2) {
+                Ok(i) => Ok((i, s.len())),
+                Err(_) => Err(self.error(pos, "Not a constant binary bit vector".to_string())),
+            }
+        } else if let Some(s) = s.strip_prefix("#x") {
+            match u128::from_str_radix(s, 16) {
+                Ok(i) => Ok((i, s.len() * 4)),
+                Err(_) => Err(self.error(pos, "Not a constant hex bit vector".to_string())),
+            }
+        } else {
+            Err(self.error(
+                pos,
+                "Not a constant bit vector; must start with `#x` (hex) or `#b` (binary)"
+                    .to_string(),
+            ))
+        }
+    }
+
+    fn parse_spec_bool(&mut self) -> Result<bool> {
+        let pos = self.pos();
+        let s = self.expect_symbol()?;
+        match s.as_str() {
+            "true" => Ok(true),
+            "false" => Ok(false),
+            x => Err(self.error(pos, format!("Not a valid spec boolean: {x}"))),
+        }
+    }
+
+    fn parse_model(&mut self) -> Result<Model> {
+        let pos = self.pos();
+        let name = self.parse_ident()?;
+        self.expect_lparen()?; // body
+        let val = if self.eat_sym_str("type")? {
+            let ty = self.parse_model_type()?;
+            ModelValue::TypeValue(ty)
+        } else if self.eat_sym_str("const")? {
+            let val = self.parse_spec_expr()?;
+            ModelValue::ConstValue(val)
+        } else if self.eat_sym_str("type-ext-enum")? {
+            // Now we should be sitting right before (struct …)
+            self.expect_lparen()?;
+            if !self.eat_sym_str("struct")? {
+                return Err(self.error(pos, "expected (struct ...) inside type-ext-enum".to_string()));
+            }
+
+            let mut fields = Vec::new();
+            while !self.is_rparen() {
+                self.expect_lparen()?;
+                let fname = self.parse_ident()?;
+                let fty   = self.parse_model_type()?;
+                self.expect_rparen()?;
+                fields.push(ModelField { name: fname, ty: fty });
+            }
+            self.expect_rparen()?; 
+
+            ModelValue::ExtEnumValue(fields) 
+        } else {
+            return Err(self.error(pos, "Model must be a type, enum, type-ext-enum, or const".to_string()));
+        };
+
+        self.expect_rparen()?; // end body
+        Ok(Model { name, val })
+    }
+
+    fn parse_model_type(&mut self) -> Result<ModelType> {
+        let pos = self.pos();
+        if self.eat_sym_str("!")? {
+            Ok(ModelType::Unspecified)
+        } else if self.eat_sym_str("_")? {
+            Ok(ModelType::Auto)
+        } else if self.eat_sym_str("Bool")? {
+            Ok(ModelType::Bool)
+        } else if self.eat_sym_str("Int")? {
+            Ok(ModelType::Int)
+        } else if self.eat_sym_str("Unit")? {
+            Ok(ModelType::Unit)
+        } else if self.is_lparen() {
+            self.expect_lparen()?;
+            if self.eat_sym_str("bv")? {
+                let width = if self.is_rparen() {
+                    None
+                } else if self.is_int() {
+                    Some(usize::try_from(self.expect_int()?).map_err(|err| {
+                        self.error(pos, format!("Invalid BitVector width: {err}"))
+                    })?)
+                } else {
+                    return Err(self.error(pos, "Badly formed BitVector (bv ...)".to_string()));
+                };
+                self.expect_rparen()?;
+                Ok(ModelType::BitVec(width))
+            } else if self.eat_sym_str("struct")? {
+                let mut fields = Vec::new();
+                while !self.is_rparen() {
+                    self.expect_lparen()?;
+                    let name = self.parse_ident()?;
+                    let ty = self.parse_model_type()?;
+                    self.expect_rparen()?;
+                    fields.push(ModelField { name, ty });
+                }
+                self.expect_rparen()?;
+                Ok(ModelType::Struct(fields))
+            } else if self.eat_sym_str("named")? {
+                let name = self.parse_ident()?;
+                self.expect_rparen()?;
+                Ok(ModelType::Named(name))
+            } else {
+                Err(self.error(
+                    pos,
+                    "Badly formed model: should be BitVector (bv ...) or Struct (struct ...)"
+                        .to_string(),
+                ))
+            }
+        } else {
+            Err(self.error(
+                pos,
+                "Model type be a Bool, Int, BitVector (bv ...) or Struct (struct ...)".to_string(),
+            ))
+        }
+    }
+
+    fn parse_state(&mut self) -> Result<State> {
+        let pos = self.pos();
+        let name = self.parse_ident()?;
+        let ty = self.parse_tagged_type("type")?;
+
+        self.expect_lparen()?;
+        if !self.eat_sym_str("default")? {
+            return Err(self.error(
+                self.pos(),
+                format!("Invalid default: expected (default <expr>)"),
+            ));
+        };
+        let default = self.parse_spec_expr()?;
+        self.expect_rparen()?;
+
+        Ok(State {
+            name,
+            ty,
+            default,
+            pos,
+        })
+    }
+
+    fn parse_form(&mut self) -> Result<Form> {
+        let pos = self.pos();
+        let name = self.parse_ident()?;
+        let signatures = self.parse_signatures()?;
+        Ok(Form {
+            name,
+            signatures,
+            pos,
+        })
+    }
+
+    fn parse_signatures(&mut self) -> Result<Vec<Signature>> {
+        let mut signatures = vec![];
+        while !self.is_rparen() {
+            signatures.push(self.parse_signature()?);
+        }
+        Ok(signatures)
+    }
+
+    fn parse_signature(&mut self) -> Result<Signature> {
+        self.expect_lparen()?;
+        let pos = self.pos();
+        let args = self.parse_tagged_types("args")?;
+        let ret = self.parse_tagged_type("ret")?;
+        self.expect_rparen()?;
+        Ok(Signature { args, ret, pos })
+    }
+
+    fn parse_tagged_types(&mut self, tag: &str) -> Result<Vec<ModelType>> {
+        self.expect_lparen()?;
+        let pos = self.pos();
+        if !self.eat_sym_str(tag)? {
+            return Err(self.error(pos, format!("Invalid {tag}: expected ({tag} <arg> ...)")));
+        };
+        let mut params = vec![];
+        while !self.is_rparen() {
+            params.push(self.parse_model_type()?);
+        }
+        self.expect_rparen()?;
+        Ok(params)
+    }
+
+    fn parse_tagged_type(&mut self, tag: &str) -> Result<ModelType> {
+        self.expect_lparen()?;
+        let pos = self.pos();
+        if !self.eat_sym_str(tag)? {
+            return Err(self.error(pos, format!("Invalid {tag}: expected ({tag} <arg>)")));
+        };
+        let ty = self.parse_model_type()?;
+        self.expect_rparen()?;
+        Ok(ty)
+    }
+
+    fn parse_instantiation(&mut self) -> Result<Instantiation> {
+        let pos = self.pos();
+        let term = self.parse_ident()?;
+        // Instantiation either has an explicit signatures list, which would
+        // open with a left paren. Or it has an identifier referencing a
+        // predefined set of signatures.
+        if self.is_lparen() {
+            let signatures = self.parse_signatures()?;
+            Ok(Instantiation {
+                term,
+                form: None,
+                signatures,
+                pos,
+            })
+        } else {
+            let form = self.parse_ident()?;
+            Ok(Instantiation {
+                term,
+                form: Some(form),
+                signatures: vec![],
+                pos,
+            })
+        }
+    }
+
     fn parse_extern(&mut self) -> Result<Extern> {
         let pos = self.pos();
         if self.eat_sym_str("constructor")? {
@@ -356,7 +1011,7 @@ impl<'a> Parser<'a> {
         } else {
             Err(self.error(
                 pos,
-                "Invalid extern: must be (extern constructor ...) or (extern extractor ...)"
+                "Invalid extern: must be (extern constructor ...), (extern extractor ...) or (extern const ...)"
                     .to_string(),
             ))
         }
@@ -382,10 +1037,18 @@ impl<'a> Parser<'a> {
 
     fn parse_rule(&mut self) -> Result<Rule> {
         let pos = self.pos();
+        let name = if self.is_sym() {
+            Some(
+                self.parse_ident()
+                    .map_err(|err| self.error(pos, format!("Invalid rule name: {err:?}")))?,
+            )
+        } else {
+            None
+        };
         let prio = if self.is_int() {
             Some(
                 i64::try_from(self.expect_int()?)
-                    .map_err(|err| self.error(pos, format!("Invalid rule priority: {}", err)))?,
+                    .map_err(|err| self.error(pos, format!("Invalid rule priority: {err}")))?,
             )
         } else {
             None
@@ -404,6 +1067,7 @@ impl<'a> Parser<'a> {
                         expr,
                         pos,
                         prio,
+                        name,
                     });
                 }
             }
@@ -559,4 +1223,46 @@ impl<'a> Parser<'a> {
             pos,
         })
     }
+
+    fn count_lines(&mut self, start_pos: Pos, def: &Def) {
+        // Compute lines between start and end positions.
+        let end_pos = self.pos();
+        assert_eq!(start_pos.file, end_pos.file);
+        let map = self.files.file_line_map(start_pos.file).unwrap();
+        let file_name = self.files.file_name(start_pos.file).unwrap();
+        let start_line = map.line(start_pos.offset);
+        let end_line = map.line(end_pos.offset);
+        let lines = (end_line - start_line) + 1;
+
+        // Categorize the definition.
+        let category = match def {
+            // Spec
+            Def::Attr(_) => "attr",
+            Def::Spec(spec) => &format!("spec/{}", spec.term.0),
+            Def::SpecMacro(_) => "macro",
+            Def::Model(_) => "model",
+            Def::State(_) => "state",
+            Def::Form(_) => "form",
+            Def::Instantiation(_) => "instantiation",
+
+            // ISLE
+            Def::Rule(rule) => {
+                let root_term = rule.pattern.root_term().unwrap();
+                match &rule.name {
+                    Some(name) => &format!("rule/{}/{}", root_term.0, name.0),
+                    None => &format!("rule/{}", root_term.0),
+                }
+            }
+
+            Def::Extern(_)
+            | Def::Converter(_)
+            | Def::Pragma(_)
+            | Def::Type(_)
+            | Def::Extractor(_)
+            | Def::Decl(_) => "isle",
+        };
+
+        // Report
+        log!(target: "isle_spec_lines", "SPEC_LINES\t{lines}\t{category}\t{file_name}\t{start_line}");
+    }
 }
diff --git a/cranelift/isle/isle/src/printer.rs b/cranelift/isle/isle/src/printer.rs
new file mode 100644
index 000000000000..24a713b16ae9
--- /dev/null
+++ b/cranelift/isle/isle/src/printer.rs
@@ -0,0 +1,606 @@
+//! Printer for ISLE language.
+
+use crate::ast::*;
+use crate::error::Errors;
+use pretty::{Doc, Pretty, RcAllocator, RcDoc};
+use std::io::Write;
+
+/// Printable is a trait satisfied by AST nodes that can be printed.
+pub trait Printable {
+    /// Map the node to a pretty document.
+    fn to_doc(&self) -> RcDoc<()>;
+}
+
+/// Print the given AST node with specified line width.
+pub fn print<N, W>(node: &N, width: usize, out: &mut W) -> Result<(), Errors>
+where
+    N: Printable,
+    W: ?Sized + Write,
+{
+    node.to_doc()
+        .render(width, out)
+        .map_err(|e| Errors::from_io(e, "failed to print isle"))
+}
+
+/// Dump AST node to standard output.
+pub fn dump<N: Printable>(node: &N) -> Result<(), Errors> {
+    let mut stdout = std::io::stdout();
+    print(node, 78, &mut stdout)
+}
+
+impl<P: Printable> Printable for Vec<P> {
+    fn to_doc(&self) -> RcDoc<()> {
+        let sep = RcDoc::hardline().append(Doc::hardline());
+        RcDoc::intersperse(self.iter().map(|d| d.to_doc()), sep).append(Doc::hardline())
+    }
+}
+
+impl Printable for Def {
+    fn to_doc(&self) -> RcDoc<()> {
+        match self {
+            Def::Pragma(_) => unimplemented!("pragmas not supported"),
+            Def::Type(ref t) => {
+                let mut parts = vec![RcDoc::text("type")];
+                parts.push(t.name.to_doc());
+                if t.is_extern {
+                    parts.push(RcDoc::text("extern"));
+                }
+                if t.is_nodebug {
+                    parts.push(RcDoc::text("nodebug"));
+                }
+                parts.push(t.ty.to_doc());
+                sexp(parts)
+            }
+            Def::Rule(ref r) => {
+                let mut parts = Vec::new();
+                parts.push(RcDoc::text("rule"));
+                if let Some(name) = &r.name {
+                    parts.push(name.to_doc());
+                }
+                if let Some(prio) = &r.prio {
+                    parts.push(RcDoc::as_string(prio));
+                }
+                parts.push(r.pattern.to_doc());
+                parts.extend(r.iflets.iter().map(|il| il.to_doc()));
+                parts.push(r.expr.to_doc());
+                sexp(parts)
+            }
+            Def::Extractor(ref e) => sexp(vec![
+                RcDoc::text("extractor"),
+                sexp(
+                    Vec::from([e.term.to_doc()])
+                        .into_iter()
+                        .chain(e.args.iter().map(|v| v.to_doc())),
+                ),
+                e.template.to_doc(),
+            ]),
+            Def::Decl(ref d) => {
+                let mut parts = Vec::new();
+                parts.push(RcDoc::text("decl"));
+                if d.pure {
+                    parts.push(RcDoc::text("pure"));
+                }
+                if d.multi {
+                    parts.push(RcDoc::text("multi"));
+                }
+                if d.partial {
+                    parts.push(RcDoc::text("partial"));
+                }
+                parts.push(d.term.to_doc());
+                parts.push(sexp(d.arg_tys.iter().map(|ty| ty.to_doc())));
+                parts.push(d.ret_ty.to_doc());
+                sexp(parts)
+            }
+            Def::Attr(ref a) => a.to_doc(),
+            Def::Spec(ref s) => s.to_doc(),
+            Def::SpecMacro(ref m) => m.to_doc(),
+            Def::State(ref s) => s.to_doc(),
+            Def::Model(ref m) => sexp(vec![RcDoc::text("model"), m.name.to_doc(), m.val.to_doc()]),
+            Def::Form(ref f) => {
+                let mut parts = vec![RcDoc::text("form")];
+                parts.push(f.name.to_doc());
+                parts.extend(f.signatures.iter().map(|s| s.to_doc()));
+                sexp(parts)
+            }
+            Def::Instantiation(ref i) => {
+                let mut parts = vec![RcDoc::text("instantiate"), i.term.to_doc()];
+                if let Some(form) = &i.form {
+                    parts.push(form.to_doc());
+                } else {
+                    parts.extend(i.signatures.iter().map(|s| s.to_doc()));
+                }
+                sexp(parts)
+            }
+            Def::Extern(ref e) => e.to_doc(),
+            Def::Converter(ref c) => sexp(vec![
+                RcDoc::text("convert"),
+                c.inner_ty.to_doc(),
+                c.outer_ty.to_doc(),
+                c.term.to_doc(),
+            ]),
+        }
+    }
+}
+
+impl Printable for Ident {
+    fn to_doc(&self) -> RcDoc<()> {
+        RcDoc::text(self.0.clone())
+    }
+}
+
+impl Printable for TypeValue {
+    fn to_doc(&self) -> RcDoc<()> {
+        match self {
+            TypeValue::Primitive(ref name, _) => {
+                sexp(vec![RcDoc::text("primitive"), name.to_doc()])
+            }
+            TypeValue::Enum(ref variants, _) => sexp(
+                // TODO(mbm): convenience for sexp with a fixed first element
+                Vec::from([RcDoc::text("enum")])
+                    .into_iter()
+                    .chain(variants.iter().map(|v| v.to_doc())),
+            ),
+        }
+    }
+}
+
+impl Printable for Variant {
+    fn to_doc(&self) -> RcDoc<()> {
+        sexp(
+            // TODO(mbm): convenience for sexp with a fixed first element
+            Vec::from([self.name.to_doc()])
+                .into_iter()
+                .chain(self.fields.iter().map(|f| f.to_doc())),
+        )
+    }
+}
+
+impl Printable for Field {
+    fn to_doc(&self) -> RcDoc<()> {
+        sexp(vec![self.name.to_doc(), self.ty.to_doc()])
+    }
+}
+
+impl Printable for Attr {
+    fn to_doc(&self) -> RcDoc<()> {
+        let mut parts = vec![RcDoc::text("attr")];
+        match &self.target {
+            AttrTarget::Term(name) => parts.push(name.to_doc()),
+            AttrTarget::Rule(name) => {
+                parts.push(RcDoc::text("rule"));
+                parts.push(name.to_doc());
+            }
+        }
+        parts.extend(self.kinds.iter().map(Printable::to_doc));
+        sexp(parts)
+    }
+}
+
+impl Printable for AttrKind {
+    fn to_doc(&self) -> RcDoc<()> {
+        match self {
+            AttrKind::Chain => sexp(vec![RcDoc::text("veri"), RcDoc::text("chain")]),
+            AttrKind::Priority => sexp(vec![RcDoc::text("veri"), RcDoc::text("priority")]),
+            AttrKind::Tag(tag) => sexp(vec![RcDoc::text("tag"), tag.to_doc()]),
+        }
+    }
+}
+
+impl Printable for ModelValue {
+    fn to_doc(&self) -> RcDoc<()> {
+        match self {
+            ModelValue::TypeValue(ref mt) => sexp(vec![RcDoc::text("type"), mt.to_doc()]),
+            ModelValue::ConstValue(ref c) => sexp(vec![RcDoc::text("const"), c.to_doc()]),
+        }
+    }
+}
+
+impl Printable for ModelType {
+    fn to_doc(&self) -> RcDoc<()> {
+        match self {
+            ModelType::Unspecified => RcDoc::text("!"),
+            ModelType::Auto => RcDoc::text("_"),
+            ModelType::Unit => RcDoc::text("Unit"),
+            ModelType::Int => RcDoc::text("Int"),
+            ModelType::Bool => RcDoc::text("Bool"),
+            ModelType::BitVec(Some(size)) => sexp(vec![RcDoc::text("bv"), RcDoc::as_string(size)]),
+            ModelType::BitVec(None) => sexp(vec![RcDoc::text("bv")]),
+            ModelType::Struct(fields) => sexp(
+                vec![RcDoc::text("struct")]
+                    .into_iter()
+                    .chain(fields.iter().map(|f| f.to_doc())),
+            ),
+            ModelType::Named(name) => sexp(vec![RcDoc::text("named"), name.to_doc()]),
+        }
+    }
+}
+
+impl Printable for ModelField {
+    fn to_doc(&self) -> RcDoc<()> {
+        sexp(vec![self.name.to_doc(), self.ty.to_doc()])
+    }
+}
+
+impl Printable for Signature {
+    fn to_doc(&self) -> RcDoc<()> {
+        sexp(vec![
+            sexp(
+                Vec::from([RcDoc::text("args")])
+                    .into_iter()
+                    .chain(self.args.iter().map(|a| a.to_doc())),
+            ),
+            sexp(vec![RcDoc::text("ret"), self.ret.to_doc()]),
+        ])
+    }
+}
+
+impl Printable for SpecExpr {
+    fn to_doc(&self) -> RcDoc<()> {
+        match self {
+            SpecExpr::ConstInt { val, .. } => RcDoc::as_string(val),
+            SpecExpr::ConstBitVec { val, width, .. } => RcDoc::text(if width % 4 == 0 {
+                format!("#x{val:0width$x}", width = *width / 4)
+            } else {
+                format!("#b{val:0width$b}", width = *width)
+            }),
+            SpecExpr::ConstBool { val, .. } => RcDoc::text(if *val { "true" } else { "false" }),
+            SpecExpr::Var { var, .. } => var.to_doc(),
+            SpecExpr::As { x, ty, pos: _ } => {
+                sexp(vec![RcDoc::text("as"), x.to_doc(), ty.to_doc()])
+            }
+            SpecExpr::Op { op, args, .. } => sexp(
+                Vec::from([op.to_doc()])
+                    .into_iter()
+                    .chain(args.iter().map(|a| a.to_doc())),
+            ),
+            SpecExpr::Pair { l, r, .. } => sexp(vec![l.to_doc(), r.to_doc()]),
+            SpecExpr::Enum {
+                name,
+                variant,
+                args,
+                pos: _,
+            } => sexp(
+                Vec::from([RcDoc::text(format!("{}.{}", name.0, variant.0))])
+                    .into_iter()
+                    .chain(args.iter().map(|a| a.to_doc())),
+            ),
+            SpecExpr::Field { field, x, pos: _ } => {
+                sexp(vec![RcDoc::text(format!(":{}", field.0)), x.to_doc()])
+            }
+            SpecExpr::Discriminator { variant, x, pos: _ } => {
+                sexp(vec![RcDoc::text(format!("{}?", variant.0)), x.to_doc()])
+            }
+            SpecExpr::Match { x, arms, pos: _ } => sexp(
+                Vec::from([RcDoc::text("match"), x.to_doc()])
+                    .into_iter()
+                    .chain(arms.iter().map(|arm| arm.to_doc())),
+            ),
+            SpecExpr::Let { defs, body, pos: _ } => sexp(vec![
+                RcDoc::text("let"),
+                sexp(defs.iter().map(|(n, e)| sexp(vec![n.to_doc(), e.to_doc()]))),
+                body.to_doc(),
+            ]),
+            SpecExpr::With {
+                decls,
+                body,
+                pos: _,
+            } => sexp(vec![
+                RcDoc::text("with"),
+                sexp(decls.iter().map(Printable::to_doc)),
+                body.to_doc(),
+            ]),
+            SpecExpr::Macro {
+                params,
+                body,
+                pos: _,
+            } => sexp(vec![
+                RcDoc::text("macro"),
+                sexp(params.iter().map(Printable::to_doc)),
+                body.to_doc(),
+            ]),
+            SpecExpr::Expand { name, args, pos: _ } => sexp(
+                Vec::from([RcDoc::text(format!("{}!", name.0))])
+                    .into_iter()
+                    .chain(args.iter().map(Printable::to_doc)),
+            ),
+            SpecExpr::Struct { fields, pos: _ } => sexp(
+                Vec::from([RcDoc::text("struct")])
+                    .into_iter()
+                    .chain(fields.iter().map(Printable::to_doc)),
+            ),
+        }
+    }
+}
+
+impl Printable for SpecOp {
+    fn to_doc(&self) -> RcDoc<()> {
+        RcDoc::text(match self {
+            SpecOp::Eq => "=",
+            SpecOp::And => "and",
+            SpecOp::Not => "not",
+            SpecOp::Imp => "=>",
+            SpecOp::Or => "or",
+            SpecOp::Add => "+",
+            SpecOp::Sub => "-",
+            SpecOp::Mul => "*",
+            SpecOp::Lte => "<=",
+            SpecOp::Lt => "<",
+            SpecOp::Gte => ">=",
+            SpecOp::Gt => ">",
+            SpecOp::BVNot => "bvnot",
+            SpecOp::BVAnd => "bvand",
+            SpecOp::BVOr => "bvor",
+            SpecOp::BVXor => "bvxor",
+            SpecOp::BVNeg => "bvneg",
+            SpecOp::BVAdd => "bvadd",
+            SpecOp::BVSub => "bvsub",
+            SpecOp::BVMul => "bvmul",
+            SpecOp::BVUdiv => "bvudiv",
+            SpecOp::BVUrem => "bvurem",
+            SpecOp::BVSdiv => "bvsdiv",
+            SpecOp::BVSrem => "bvsrem",
+            SpecOp::BVShl => "bvshl",
+            SpecOp::BVLshr => "bvlshr",
+            SpecOp::BVAshr => "bvashr",
+            SpecOp::BVSaddo => "bvsaddo",
+            SpecOp::BVUle => "bvule",
+            SpecOp::BVUlt => "bvult",
+            SpecOp::BVUgt => "bvugt",
+            SpecOp::BVUge => "bvuge",
+            SpecOp::BVSlt => "bvslt",
+            SpecOp::BVSle => "bvsle",
+            SpecOp::BVSgt => "bvsgt",
+            SpecOp::BVSge => "bvsge",
+            SpecOp::Rotr => "rotr",
+            SpecOp::Rotl => "rotl",
+            SpecOp::Extract => "extract",
+            SpecOp::ZeroExt => "zero_ext",
+            SpecOp::SignExt => "sign_ext",
+            SpecOp::Concat => "concat",
+            SpecOp::Replicate => "replicate",
+            SpecOp::ConvTo => "conv_to",
+            SpecOp::Int2BV => "int2bv",
+            SpecOp::BV2Nat => "bv2nat",
+            SpecOp::ToFP => "to_fp",
+            SpecOp::FPToUBV => "fp.to_ubv",
+            SpecOp::FPToSBV => "fp.to_sbv",
+            SpecOp::ToFPUnsigned => "to_fp_unsigned",
+            SpecOp::ToFPFromFP => "to_fp_from_fp",
+            SpecOp::WidthOf => "widthof",
+            SpecOp::If => "if",
+            SpecOp::Switch => "switch",
+            SpecOp::Popcnt => "popcnt",
+            SpecOp::Rev => "rev",
+            SpecOp::Cls => "cls",
+            SpecOp::Clz => "clz",
+            SpecOp::FPPositiveInfinity => "fp.+oo",
+            SpecOp::FPNegativeInfinity => "fp.-oo",
+            SpecOp::FPPositiveZero => "fp.+zero",
+            SpecOp::FPNegativeZero => "fp.-zero",
+            SpecOp::FPNaN => "fp.NaN",
+            SpecOp::FPEq => "fp.eq",
+            SpecOp::FPNe => "fp.ne",
+            SpecOp::FPLt => "fp.lt",
+            SpecOp::FPGt => "fp.gt",
+            SpecOp::FPLe => "fp.le",
+            SpecOp::FPGe => "fp.ge",
+            SpecOp::FPAdd => "fp.add",
+            SpecOp::FPSub => "fp.sub",
+            SpecOp::FPMul => "fp.mul",
+            SpecOp::FPDiv => "fp.div",
+            SpecOp::FPMin => "fp.min",
+            SpecOp::FPMax => "fp.max",
+            SpecOp::FPNeg => "fp.neg",
+            SpecOp::FPCeil => "fp.ceil",
+            SpecOp::FPFloor => "fp.floor",
+            SpecOp::FPSqrt => "fp.sqrt",
+            SpecOp::FPTrunc => "fp.trunc",
+            SpecOp::FPNearest => "fp.nearest",
+            SpecOp::FPIsZero => "fp.isZero",
+            SpecOp::FPIsInfinite => "fp.isInfinite",
+            SpecOp::FPIsNaN => "fp.isNaN",
+            SpecOp::FPIsNegative => "fp.isNegative",
+            SpecOp::FPIsPositive => "fp.isPositive",
+        })
+    }
+}
+
+impl Printable for Arm {
+    fn to_doc(&self) -> RcDoc<()> {
+        sexp(vec![
+            sexp(
+                Vec::from([self.variant.to_doc()])
+                    .into_iter()
+                    .chain(self.args.iter().map(|a| a.to_doc())),
+            ),
+            self.body.to_doc(),
+        ])
+    }
+}
+
+impl Printable for FieldInit {
+    fn to_doc(&self) -> RcDoc<()> {
+        sexp(vec![self.name.to_doc(), self.value.to_doc()])
+    }
+}
+
+impl Printable for SpecMacro {
+    fn to_doc(&self) -> RcDoc<()> {
+        let mut parts = vec![RcDoc::text("macro")];
+        parts.push(sexp(
+            Vec::from([self.name.to_doc()])
+                .into_iter()
+                .chain(self.params.iter().map(|a| a.to_doc())),
+        ));
+        parts.push(self.body.to_doc());
+        sexp(parts)
+    }
+}
+
+impl Printable for Modifies {
+    fn to_doc(&self) -> RcDoc<()> {
+        let mut parts = vec![RcDoc::text("modifies"), self.state.to_doc()];
+        if let Some(cond) = &self.cond {
+            parts.push(cond.to_doc());
+        }
+        sexp(parts)
+    }
+}
+
+impl Printable for Spec {
+    fn to_doc(&self) -> RcDoc<()> {
+        let mut parts = vec![RcDoc::text("spec")];
+        parts.push(sexp(
+            Vec::from([self.term.to_doc()])
+                .into_iter()
+                .chain(self.args.iter().map(|a| a.to_doc())),
+        ));
+        for modifies in &self.modifies {
+            parts.push(modifies.to_doc());
+        }
+        if !self.provides.is_empty() {
+            parts.push(sexp(
+                Vec::from([RcDoc::text("provide")])
+                    .into_iter()
+                    .chain(self.provides.iter().map(|e| e.to_doc())),
+            ));
+        }
+        if !self.requires.is_empty() {
+            parts.push(sexp(
+                Vec::from([RcDoc::text("require")])
+                    .into_iter()
+                    .chain(self.requires.iter().map(|e| e.to_doc())),
+            ));
+        }
+        if !self.matches.is_empty() {
+            parts.push(sexp(
+                Vec::from([RcDoc::text("match")])
+                    .into_iter()
+                    .chain(self.matches.iter().map(|e| e.to_doc())),
+            ));
+        }
+        sexp(parts)
+    }
+}
+
+impl Printable for State {
+    fn to_doc(&self) -> RcDoc<()> {
+        sexp(vec![
+            RcDoc::text("state"),
+            self.name.to_doc(),
+            sexp(vec![RcDoc::text("type"), self.ty.to_doc()]),
+            sexp(vec![RcDoc::text("default"), self.default.to_doc()]),
+        ])
+    }
+}
+
+impl Printable for Pattern {
+    fn to_doc(&self) -> RcDoc<()> {
+        match self {
+            Pattern::Var { var, .. } => var.to_doc(),
+            Pattern::BindPattern { var, subpat, .. } => RcDoc::intersperse(
+                vec![var.to_doc(), RcDoc::text("@"), subpat.to_doc()],
+                Doc::space(),
+            ),
+            Pattern::ConstInt { val, .. } => RcDoc::as_string(val),
+            Pattern::ConstPrim { val, .. } => RcDoc::text("$").append(val.to_doc()),
+            Pattern::Wildcard { .. } => RcDoc::text("_"),
+            Pattern::Term { sym, args, .. } => sexp(
+                // TODO(mbm): convenience for sexp with a fixed first element
+                Vec::from([sym.to_doc()])
+                    .into_iter()
+                    .chain(args.iter().map(|f| f.to_doc())),
+            ),
+            Pattern::And { subpats, .. } => sexp(
+                Vec::from([RcDoc::text("and")])
+                    .into_iter()
+                    .chain(subpats.iter().map(|p| p.to_doc())),
+            ),
+            Pattern::MacroArg { .. } => unimplemented!("macro arguments are for internal use only"),
+        }
+    }
+}
+
+impl Printable for IfLet {
+    fn to_doc(&self) -> RcDoc<()> {
+        // TODO(mbm): `if` shorthand when pattern is wildcard
+        sexp(vec![
+            RcDoc::text("if-let"),
+            self.pattern.to_doc(),
+            self.expr.to_doc(),
+        ])
+    }
+}
+
+impl Printable for Expr {
+    fn to_doc(&self) -> RcDoc<()> {
+        match self {
+            Expr::Term { sym, args, .. } => sexp(
+                // TODO(mbm): convenience for sexp with a fixed first element
+                Vec::from([sym.to_doc()])
+                    .into_iter()
+                    .chain(args.iter().map(|f| f.to_doc())),
+            ),
+            Expr::Var { name, .. } => name.to_doc(),
+            Expr::ConstInt { val, .. } => RcDoc::as_string(val),
+            Expr::ConstPrim { val, .. } => RcDoc::text("$").append(val.to_doc()),
+            Expr::Let { defs, body, .. } => {
+                let mut parts = Vec::new();
+                parts.push(RcDoc::text("let"));
+                parts.push(sexp(defs.iter().map(|d| d.to_doc())));
+                parts.push(body.to_doc());
+                sexp(parts)
+            }
+        }
+    }
+}
+
+impl Printable for LetDef {
+    fn to_doc(&self) -> RcDoc<()> {
+        sexp(vec![self.var.to_doc(), self.ty.to_doc(), self.val.to_doc()])
+    }
+}
+
+impl Printable for Extern {
+    fn to_doc(&self) -> RcDoc<()> {
+        match self {
+            Extern::Extractor {
+                term,
+                func,
+                pos: _,
+                infallible,
+            } => {
+                let mut parts = vec![RcDoc::text("extern"), RcDoc::text("extractor")];
+                if *infallible {
+                    parts.push(RcDoc::text("infallible"));
+                }
+                parts.push(term.to_doc());
+                parts.push(func.to_doc());
+                sexp(parts)
+            }
+            Extern::Constructor { term, func, .. } => sexp(vec![
+                RcDoc::text("extern"),
+                RcDoc::text("constructor"),
+                term.to_doc(),
+                func.to_doc(),
+            ]),
+            Extern::Const { name, ty, .. } => sexp(vec![
+                RcDoc::text("extern"),
+                RcDoc::text("const"),
+                RcDoc::text("$").append(name.to_doc()),
+                ty.to_doc(),
+            ]),
+        }
+    }
+}
+
+fn sexp<'a, I, A>(docs: I) -> RcDoc<'a, A>
+where
+    I: IntoIterator,
+    I::Item: Pretty<'a, RcAllocator, A>,
+    A: Clone,
+{
+    RcDoc::text("(")
+        .append(RcDoc::intersperse(docs, Doc::line()).nest(4).group())
+        .append(RcDoc::text(")"))
+}
diff --git a/cranelift/isle/isle/src/sema.rs b/cranelift/isle/isle/src/sema.rs
index 11a6a1ad1acb..fab1dab46f48 100644
--- a/cranelift/isle/isle/src/sema.rs
+++ b/cranelift/isle/isle/src/sema.rs
@@ -9,20 +9,20 @@
 //! unification or anything like that.
 //!
 //! The term environment is constructed from both the AST and type
-//! envionment. It is sort of a typed and reorganized AST that more directly
+//! environment. It is sort of a typed and reorganized AST that more directly
 //! reflects ISLE semantics than the input ISLE source code (where as the AST is
 //! the opposite).
 
 use crate::ast;
 use crate::error::*;
+use crate::files::Files;
 use crate::lexer::Pos;
 use crate::log;
-use crate::{StableMap, StableSet};
+use crate::stablemapset::{StableMap, StableSet};
 use std::collections::hash_map::Entry;
 use std::collections::BTreeMap;
 use std::collections::BTreeSet;
 use std::collections::HashMap;
-use std::sync::Arc;
 
 declare_id!(
     /// The id of an interned symbol.
@@ -58,16 +58,6 @@ declare_id!(
 /// Keeps track of which symbols and rules have which types.
 #[derive(Debug)]
 pub struct TypeEnv {
-    /// Arena of input ISLE source filenames.
-    ///
-    /// We refer to these indirectly through the `Pos::file` indices.
-    pub filenames: Vec<Arc<str>>,
-
-    /// Arena of input ISLE source contents.
-    ///
-    /// We refer to these indirectly through the `Pos::file` indices.
-    pub file_texts: Vec<Arc<str>>,
-
     /// Arena of interned symbol names.
     ///
     /// Referred to indirectly via `Sym` indices.
@@ -125,6 +115,13 @@ pub enum Type {
 }
 
 impl Type {
+    /// Get the ID of this `Type`.
+    pub fn id(&self) -> TypeId {
+        match self {
+            Self::Primitive(id, _, _) | Self::Enum { id, .. } => *id,
+        }
+    }
+
     /// Get the name of this `Type`.
     pub fn name<'a>(&self, tyenv: &'a TypeEnv) -> &'a str {
         match self {
@@ -163,6 +160,9 @@ pub struct Variant {
 
     /// The data fields of this enum variant.
     pub fields: Vec<Field>,
+
+    /// The ISLE source position where this variant is defined.
+    pub pos: Pos,
 }
 
 /// A field of a `Variant`.
@@ -196,10 +196,17 @@ pub struct TermEnv {
     /// This is indexed by `RuleId`.
     pub rules: Vec<Rule>,
 
+    /// A map from an interned `Rule`'s name to its `RuleId`.
+    pub rule_map: StableMap<Sym, RuleId>,
+
     /// Map from (inner_ty, outer_ty) pairs to term IDs, giving the
     /// defined implicit type-converter terms we can try to use to fit
     /// types together.
     pub converters: StableMap<(TypeId, TypeId), TermId>,
+
+    /// Flag for whether to expand internal extractors in the
+    /// translation from the AST to sema.
+    pub expand_internal_extractors: bool,
 }
 
 /// A term.
@@ -339,6 +346,17 @@ impl Term {
         matches!(self.kind, TermKind::EnumVariant { .. })
     }
 
+    /// Is this term partial?
+    pub fn is_partial(&self) -> bool {
+        matches!(
+            self.kind,
+            TermKind::Decl {
+                flags: TermFlags { partial: true, .. },
+                ..
+            }
+        )
+    }
+
     /// Does this term have a constructor?
     pub fn has_constructor(&self) -> bool {
         matches!(
@@ -385,27 +403,51 @@ impl Term {
         )
     }
 
+    /// Is this term's constructor internal?
+    pub fn has_internal_constructor(&self) -> bool {
+        matches!(
+            self.kind,
+            TermKind::Decl {
+                constructor_kind: Some(ConstructorKind::InternalConstructor { .. }),
+                ..
+            }
+        )
+    }
+
     /// Get this term's extractor's external function signature, if any.
     pub fn extractor_sig(&self, tyenv: &TypeEnv) -> Option<ExternalSig> {
         match &self.kind {
             TermKind::Decl {
                 flags,
-                extractor_kind:
-                    Some(ExtractorKind::ExternalExtractor {
-                        name, infallible, ..
-                    }),
+                extractor_kind: Some(kind),
                 ..
             } => {
+                let (func_name, full_name, infallible) = match kind {
+                    ExtractorKind::InternalExtractor { .. } => {
+                        // TODO(mbm): what's the correct signature for an internal extractor?
+                        // TODO(mbm): is an internal extractor fallible?
+                        // TODO(mbm): do we need to consider the pattern field of an internal extractor?
+                        let name = format!("extractor_{}", tyenv.syms[self.name.index()]);
+                        (name.clone(), name, false)
+                    }
+                    ExtractorKind::ExternalExtractor {
+                        name, infallible, ..
+                    } => (
+                        tyenv.syms[name.index()].clone(),
+                        format!("C::{}", tyenv.syms[name.index()]),
+                        *infallible,
+                    ),
+                };
                 let ret_kind = if flags.multi {
                     ReturnKind::Iterator
-                } else if *infallible {
+                } else if infallible {
                     ReturnKind::Plain
                 } else {
                     ReturnKind::Option
                 };
                 Some(ExternalSig {
-                    func_name: tyenv.syms[name.index()].clone(),
-                    full_name: format!("C::{}", tyenv.syms[name.index()]),
+                    func_name,
+                    full_name,
                     param_tys: vec![self.ret_ty],
                     ret_tys: self.arg_tys.clone(),
                     ret_kind,
@@ -471,6 +513,8 @@ pub struct Rule {
     pub vars: Vec<BoundVar>,
     /// The priority of this rule, defaulted to 0 if it was missing in the source.
     pub prio: i64,
+    /// Rule name.
+    pub name: Option<Sym>,
     /// The source position where this rule is defined.
     pub pos: Pos,
 }
@@ -644,27 +688,29 @@ impl Pattern {
                     } => {
                         panic!("Pattern invocation of undefined term body")
                     }
-                    TermKind::Decl {
-                        extractor_kind: Some(ExtractorKind::InternalExtractor { .. }),
-                        ..
-                    } => {
-                        panic!("Should have been expanded away")
-                    }
                     TermKind::Decl {
                         flags,
-                        extractor_kind: Some(ExtractorKind::ExternalExtractor { infallible, .. }),
+                        extractor_kind,
                         ..
                     } => {
                         // Evaluate all `input` args.
                         let output_tys = args.iter().map(|arg| arg.ty()).collect();
 
+                        // TODO(mbm): is an internal extractor fallible?
+                        let infallible = match extractor_kind {
+                            Some(ExtractorKind::ExternalExtractor { infallible, .. }) => {
+                                *infallible
+                            }
+                            _ => false,
+                        };
+
                         // Invoke the extractor.
                         visitor.add_extract(
                             input,
                             termdata.ret_ty,
                             output_tys,
                             term,
-                            *infallible && !flags.multi,
+                            infallible && !flags.multi,
                             flags.multi,
                         )
                     }
@@ -881,6 +927,14 @@ impl Rule {
         // Visit the rule's right-hand side, making use of the bound variables from the pattern.
         self.rhs.visit_in_rule(visitor, termenv, &vars)
     }
+
+    /// Identifier is a name or position for referring to the rule.
+    pub fn identifier(&self, tyenv: &TypeEnv, files: &Files) -> String {
+        match self.name {
+            Some(sym) => tyenv.syms[sym.index()].clone(),
+            None => self.pos.pretty_print_line(files),
+        }
+    }
 }
 
 /// Given an `Option<T>`, unwrap the inner `T` value, or `continue` if it is
@@ -901,10 +955,8 @@ macro_rules! unwrap_or_continue {
 
 impl TypeEnv {
     /// Construct the type environment from the AST.
-    pub fn from_ast(defs: &ast::Defs) -> Result<TypeEnv, Errors> {
+    pub fn from_ast(defs: &[ast::Def]) -> Result<TypeEnv, Vec<Error>> {
         let mut tyenv = TypeEnv {
-            filenames: defs.filenames.clone(),
-            file_texts: defs.file_texts.clone(),
             syms: vec![],
             sym_map: StableMap::new(),
             types: vec![],
@@ -915,7 +967,7 @@ impl TypeEnv {
 
         // Traverse defs, assigning type IDs to type names. We'll fill
         // in types on a second pass.
-        for def in &defs.defs {
+        for def in defs {
             match def {
                 &ast::Def::Type(ref td) => {
                     let tid = TypeId(tyenv.type_map.len());
@@ -943,7 +995,7 @@ impl TypeEnv {
         // Now lower AST nodes to type definitions, raising errors
         // where typenames of fields are undefined or field names are
         // duplicated.
-        for def in &defs.defs {
+        for def in defs {
             match def {
                 &ast::Def::Type(ref td) => {
                     let tid = tyenv.types.len();
@@ -956,7 +1008,7 @@ impl TypeEnv {
         }
 
         // Now collect types for extern constants.
-        for def in &defs.defs {
+        for def in defs {
             if let &ast::Def::Extern(ast::Extern::Const {
                 ref name,
                 ref ty,
@@ -980,15 +1032,11 @@ impl TypeEnv {
         Ok(tyenv)
     }
 
-    fn return_errors(&mut self) -> Result<(), Errors> {
+    fn return_errors(&mut self) -> Result<(), Vec<Error>> {
         if self.errors.is_empty() {
             Ok(())
         } else {
-            Err(Errors {
-                errors: std::mem::take(&mut self.errors),
-                filenames: self.filenames.clone(),
-                file_texts: self.file_texts.clone(),
-            })
+            Err(std::mem::take(&mut self.errors))
         }
     }
 
@@ -1014,8 +1062,7 @@ impl TypeEnv {
 
                 let mut variants = vec![];
                 for variant in ty_variants {
-                    let combined_ident =
-                        ast::Ident(format!("{}.{}", ty.name.0, variant.name.0), variant.name.1);
+                    let combined_ident = ast::Variant::full_name(&ty.name, &variant.name);
                     let fullname = self.intern_mut(&combined_ident);
                     let name = self.intern_mut(&variant.name);
                     let id = VariantId(variants.len());
@@ -1063,6 +1110,7 @@ impl TypeEnv {
                         fullname,
                         id,
                         fields,
+                        pos: variant.pos,
                     });
                 }
                 Some(Type::Enum {
@@ -1100,15 +1148,26 @@ impl TypeEnv {
         }
     }
 
-    fn intern(&self, ident: &ast::Ident) -> Option<Sym> {
+    /// Lookup symbol ID for the given identifier.
+    pub fn intern(&self, ident: &ast::Ident) -> Option<Sym> {
         self.sym_map.get(&ident.0).copied()
     }
 
-    fn get_type_by_name(&self, sym: &ast::Ident) -> Option<TypeId> {
+    /// Lookup type by name.
+    pub fn get_type_by_name(&self, sym: &ast::Ident) -> Option<TypeId> {
         self.intern(sym)
             .and_then(|sym| self.type_map.get(&sym))
             .copied()
     }
+
+    /// Lookup the term corresponding to the given enum variant.
+    pub fn get_variant(&self, ty: TypeId, variant: VariantId) -> &Variant {
+        let ty = &self.types[ty.index()];
+        let Type::Enum { variants, .. } = ty else {
+            unreachable!("provided type must be an enum")
+        };
+        &variants[variant.index()]
+    }
 }
 
 #[derive(Clone, Debug, Default)]
@@ -1158,12 +1217,18 @@ impl Bindings {
 
 impl TermEnv {
     /// Construct the term environment from the AST and the type environment.
-    pub fn from_ast(tyenv: &mut TypeEnv, defs: &ast::Defs) -> Result<TermEnv, Errors> {
+    pub fn from_ast(
+        tyenv: &mut TypeEnv,
+        defs: &[ast::Def],
+        expand_internal_extractors: bool,
+    ) -> Result<TermEnv, Vec<Error>> {
         let mut env = TermEnv {
             terms: vec![],
             term_map: StableMap::new(),
             rules: vec![],
+            rule_map: StableMap::new(),
             converters: StableMap::new(),
+            expand_internal_extractors,
         };
 
         env.collect_pragmas(defs);
@@ -1185,13 +1250,13 @@ impl TermEnv {
         Ok(env)
     }
 
-    fn collect_pragmas(&mut self, _: &ast::Defs) {
+    fn collect_pragmas(&mut self, _: &[ast::Def]) {
         // currently, no pragmas are defined, but the infrastructure is useful to keep around
         return;
     }
 
-    fn collect_term_sigs(&mut self, tyenv: &mut TypeEnv, defs: &ast::Defs) {
-        for def in &defs.defs {
+    fn collect_term_sigs(&mut self, tyenv: &mut TypeEnv, defs: &[ast::Def]) {
+        for def in defs {
             match def {
                 &ast::Def::Decl(ref decl) => {
                     let name = tyenv.intern_mut(&decl.term);
@@ -1279,7 +1344,7 @@ impl TermEnv {
                             let variant_name = tyenv.syms[variant.fullname.index()].clone();
                             tyenv.report_error(
                                 pos,
-                                format!("Duplicate enum variant constructor: '{}'", variant_name,),
+                                format!("Duplicate enum variant constructor: '{variant_name}'",),
                             );
                             continue 'types;
                         }
@@ -1288,7 +1353,7 @@ impl TermEnv {
                         let ret_ty = id;
                         self.terms.push(Term {
                             id: tid,
-                            decl_pos: pos,
+                            decl_pos: variant.pos,
                             name: variant.fullname,
                             arg_tys,
                             ret_ty,
@@ -1304,8 +1369,8 @@ impl TermEnv {
         }
     }
 
-    fn collect_constructors(&mut self, tyenv: &mut TypeEnv, defs: &ast::Defs) {
-        for def in &defs.defs {
+    fn collect_constructors(&mut self, tyenv: &mut TypeEnv, defs: &[ast::Def]) {
+        for def in defs {
             log!("collect_constructors from def: {:?}", def);
             match def {
                 &ast::Def::Rule(ref rule) => {
@@ -1367,10 +1432,10 @@ impl TermEnv {
         }
     }
 
-    fn collect_extractor_templates(&mut self, tyenv: &mut TypeEnv, defs: &ast::Defs) {
+    fn collect_extractor_templates(&mut self, tyenv: &mut TypeEnv, defs: &[ast::Def]) {
         let mut extractor_call_graph = BTreeMap::new();
 
-        for def in &defs.defs {
+        for def in defs {
             if let &ast::Def::Extractor(ref ext) = def {
                 let term = match self.get_term_by_name(tyenv, &ext.term) {
                     Some(x) => x,
@@ -1491,8 +1556,8 @@ impl TermEnv {
         }
     }
 
-    fn collect_converters(&mut self, tyenv: &mut TypeEnv, defs: &ast::Defs) {
-        for def in &defs.defs {
+    fn collect_converters(&mut self, tyenv: &mut TypeEnv, defs: &[ast::Def]) {
+        for def in defs {
             match def {
                 &ast::Def::Converter(ast::Converter {
                     ref term,
@@ -1554,8 +1619,8 @@ impl TermEnv {
         }
     }
 
-    fn collect_externs(&mut self, tyenv: &mut TypeEnv, defs: &ast::Defs) {
-        for def in &defs.defs {
+    fn collect_externs(&mut self, tyenv: &mut TypeEnv, defs: &[ast::Def]) {
+        for def in defs {
             match def {
                 &ast::Def::Extern(ast::Extern::Constructor {
                     ref term,
@@ -1677,8 +1742,8 @@ impl TermEnv {
         }
     }
 
-    fn collect_rules(&mut self, tyenv: &mut TypeEnv, defs: &ast::Defs) {
-        for def in &defs.defs {
+    fn collect_rules(&mut self, tyenv: &mut TypeEnv, defs: &[ast::Def]) {
+        for def in defs {
             match def {
                 &ast::Def::Rule(ref rule) => {
                     let pos = rule.pos;
@@ -1762,16 +1827,55 @@ impl TermEnv {
                         rhs,
                         vars: bindings.seen,
                         prio,
+                        name: rule.name.as_ref().map(|i| tyenv.intern_mut(i)),
                         pos,
                     });
                 }
                 _ => {}
             }
         }
+
+        // Populate default rule names.
+        //
+        // Unnamed rules that are the only rule for their root term adopt the
+        // name of the root term.
+        let mut term_rule_count: HashMap<TermId, usize> = HashMap::new();
+        for rule in &self.rules {
+            *term_rule_count.entry(rule.root_term).or_default() += 1;
+        }
+
+        for rule in &mut self.rules {
+            if rule.name.is_none()
+                && term_rule_count
+                    .get(&rule.root_term)
+                    .copied()
+                    .unwrap_or_default()
+                    == 1
+            {
+                let term = &self.terms[rule.root_term.index()];
+                rule.name = Some(term.name);
+            }
+        }
+
+        // Populate rule name map.
+        for rule in &self.rules {
+            let Some(name) = rule.name else { continue };
+            match self.rule_map.entry(name) {
+                Entry::Vacant(e) => {
+                    e.insert(rule.id);
+                }
+                Entry::Occupied(_) => {
+                    tyenv.report_error(
+                        rule.pos,
+                        format!("Duplicate rule name: '{}'", tyenv.syms[name.index()]),
+                    );
+                }
+            }
+        }
     }
 
-    fn check_for_undefined_decls(&self, tyenv: &mut TypeEnv, defs: &ast::Defs) {
-        for def in &defs.defs {
+    fn check_for_undefined_decls(&self, tyenv: &mut TypeEnv, defs: &[ast::Def]) {
+        for def in defs {
             if let ast::Def::Decl(decl) = def {
                 let term = self.get_term_by_name(tyenv, &decl.term).unwrap();
                 let term = &self.terms[term.index()];
@@ -1788,8 +1892,8 @@ impl TermEnv {
         }
     }
 
-    fn check_for_expr_terms_without_constructors(&self, tyenv: &mut TypeEnv, defs: &ast::Defs) {
-        for def in &defs.defs {
+    fn check_for_expr_terms_without_constructors(&self, tyenv: &mut TypeEnv, defs: &[ast::Def]) {
+        for def in defs {
             if let ast::Def::Rule(rule) = def {
                 rule.expr.terms(&mut |pos, ident| {
                     let term = match self.get_term_by_name(tyenv, ident) {
@@ -2017,13 +2121,15 @@ impl TermEnv {
                         extractor_kind: Some(ExtractorKind::InternalExtractor { ref template }),
                         ..
                     } => {
-                        // Expand the extractor macro! We create a map
-                        // from macro args to AST pattern trees and
-                        // then evaluate the template with these
-                        // substitutions.
-                        log!("internal extractor macro args = {:?}", args);
-                        let pat = template.subst_macro_args(&args)?;
-                        return self.translate_pattern(tyenv, &pat, expected_ty, bindings);
+                        if self.expand_internal_extractors {
+                            // Expand the extractor macro! We create a map
+                            // from macro args to AST pattern trees and
+                            // then evaluate the template with these
+                            // substitutions.
+                            log!("internal extractor macro args = {:?}", args);
+                            let pat = template.subst_macro_args(&args)?;
+                            return self.translate_pattern(tyenv, &pat, expected_ty, bindings);
+                        }
                     }
                     TermKind::Decl {
                         extractor_kind: None,
@@ -2378,20 +2484,36 @@ impl TermEnv {
         Some(IfLet { lhs, rhs })
     }
 
-    fn get_term_by_name(&self, tyenv: &TypeEnv, sym: &ast::Ident) -> Option<TermId> {
+    /// Lookup term by name.
+    pub fn get_term_by_name(&self, tyenv: &TypeEnv, sym: &ast::Ident) -> Option<TermId> {
         tyenv
             .intern(sym)
             .and_then(|sym| self.term_map.get(&sym))
             .copied()
     }
+
+    /// Lookup rule by name.
+    pub fn get_rule_by_name(&self, tyenv: &TypeEnv, sym: &ast::Ident) -> Option<RuleId> {
+        tyenv
+            .intern(sym)
+            .and_then(|sym| self.rule_map.get(&sym))
+            .copied()
+    }
+
+    /// Lookup the term corresponding to the given enum variant.
+    pub fn get_variant_term(&self, tyenv: &TypeEnv, ty: TypeId, variant: VariantId) -> TermId {
+        let variant = tyenv.get_variant(ty, variant);
+        self.term_map[&variant.fullname]
+    }
 }
 
 #[cfg(test)]
 mod test {
     use super::*;
     use crate::ast::Ident;
-    use crate::lexer::{Lexer, Pos};
+    use crate::lexer::Lexer;
     use crate::parser::parse;
+    use std::sync::Arc;
 
     #[test]
     fn build_type_env() {
@@ -2399,7 +2521,11 @@ mod test {
             (type u32 (primitive u32))
             (type A extern (enum (B (f1 u32) (f2 u32)) (C (f1 u32))))
         ";
-        let ast = parse(Lexer::from_str(text, "file.isle").unwrap()).expect("should parse");
+        let files = Arc::new(Files::from_names_and_contents(vec![(
+            "test.isle".to_string(),
+            text.to_string(),
+        )]));
+        let ast = parse(Lexer::new(0, text).unwrap(), files).expect("should parse");
         let tyenv = TypeEnv::from_ast(&ast).expect("should not have type-definition errors");
 
         let sym_a = tyenv
@@ -2437,8 +2563,6 @@ mod test {
                 Pos {
                     file: 0,
                     offset: 19,
-                    line: 2,
-                    col: 18,
                 },
             ),
             Type::Enum {
@@ -2463,6 +2587,10 @@ mod test {
                                 ty: TypeId(0),
                             },
                         ],
+                        pos: Pos {
+                            file: 0,
+                            offset: 73,
+                        },
                     },
                     Variant {
                         name: sym_c,
@@ -2473,20 +2601,22 @@ mod test {
                             id: FieldId(0),
                             ty: TypeId(0),
                         }],
+                        pos: Pos {
+                            file: 0,
+                            offset: 95,
+                        },
                     },
                 ],
                 pos: Pos {
                     file: 0,
                     offset: 58,
-                    line: 3,
-                    col: 18,
                 },
             },
         ];
 
         assert_eq!(tyenv.types.len(), expected_types.len());
         for (i, (actual, expected)) in tyenv.types.iter().zip(&expected_types).enumerate() {
-            assert_eq!(expected, actual, "`{}`th type is not equal!", i);
+            assert_eq!(expected, actual, "`{i}`th type is not equal!");
         }
     }
 }
diff --git a/cranelift/isle/isle/src/serialize.rs b/cranelift/isle/isle/src/serialize.rs
index 34728759bfa2..12c8feeb8d32 100644
--- a/cranelift/isle/isle/src/serialize.rs
+++ b/cranelift/isle/isle/src/serialize.rs
@@ -20,9 +20,10 @@
 //! it.
 use std::cmp::Reverse;
 
+use crate::disjointsets::DisjointSets;
 use crate::lexer::Pos;
+use crate::sema::Sym;
 use crate::trie_again::{Binding, BindingId, Constraint, Rule, RuleSet};
-use crate::DisjointSets;
 
 /// Decomposes the rule-set into a tree of [Block]s.
 pub fn serialize(rules: &RuleSet) -> Block {
@@ -107,6 +108,8 @@ pub enum ControlFlow {
         /// What is the result expression which should be returned if this
         /// rule matched?
         result: BindingId,
+        /// Name of the rule that matched.
+        name: Option<Sym>,
     },
 }
 
@@ -482,6 +485,7 @@ impl<'a> Decomposition<'a> {
                 pos,
                 result,
                 ref impure,
+                name,
                 ..
             } = &self.rules.rules[idx];
 
@@ -492,7 +496,7 @@ impl<'a> Decomposition<'a> {
             }
             self.use_expr(result);
 
-            let check = ControlFlow::Return { pos, result };
+            let check = ControlFlow::Return { pos, result, name };
             let bind_order = std::mem::take(&mut self.bind_order);
             self.block.steps.push(EvalStep { bind_order, check });
         }
diff --git a/cranelift/isle/isle/src/stablemapset.rs b/cranelift/isle/isle/src/stablemapset.rs
new file mode 100644
index 000000000000..75be3550a9c7
--- /dev/null
+++ b/cranelift/isle/isle/src/stablemapset.rs
@@ -0,0 +1,84 @@
+//! Implementations of hashmap and hashset that asvoid observing non-determinism
+//! in iteration order. In a separate module so the compiler can prevent access to the internal
+//! implementation details.
+
+use std::collections::hash_map::Entry;
+use std::collections::{HashMap, HashSet};
+use std::hash::Hash;
+use std::ops::Index;
+
+/// A wrapper around a [HashSet] which prevents accidentally observing the non-deterministic
+/// iteration order.
+#[derive(Clone, Debug, Default)]
+pub struct StableSet<T>(HashSet<T>);
+
+impl<T> StableSet<T> {
+    pub(crate) fn new() -> Self {
+        StableSet(HashSet::new())
+    }
+}
+
+impl<T: Hash + Eq> StableSet<T> {
+    /// Adds a value to the set. Returns whether the value was newly inserted.
+    pub fn insert(&mut self, val: T) -> bool {
+        self.0.insert(val)
+    }
+
+    /// Returns true if the set contains a value.
+    pub fn contains(&self, val: &T) -> bool {
+        self.0.contains(val)
+    }
+
+    /// Returns the number of elements in the set.
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+}
+
+/// A wrapper around a [HashMap] which prevents accidentally observing the non-deterministic
+/// iteration order.
+#[derive(Clone, Debug)]
+pub struct StableMap<K, V>(HashMap<K, V>);
+
+impl<K, V> StableMap<K, V> {
+    pub(crate) fn new() -> Self {
+        StableMap(HashMap::new())
+    }
+
+    pub(crate) fn len(&self) -> usize {
+        self.0.len()
+    }
+}
+
+// NOTE: Can't auto-derive this
+impl<K, V> Default for StableMap<K, V> {
+    fn default() -> Self {
+        StableMap(HashMap::new())
+    }
+}
+
+impl<K: Hash + Eq, V> StableMap<K, V> {
+    pub(crate) fn insert(&mut self, k: K, v: V) -> Option<V> {
+        self.0.insert(k, v)
+    }
+
+    pub(crate) fn contains_key(&self, k: &K) -> bool {
+        self.0.contains_key(k)
+    }
+
+    pub(crate) fn get(&self, k: &K) -> Option<&V> {
+        self.0.get(k)
+    }
+
+    pub(crate) fn entry(&mut self, k: K) -> Entry<K, V> {
+        self.0.entry(k)
+    }
+}
+
+impl<K: Hash + Eq, V> Index<&K> for StableMap<K, V> {
+    type Output = V;
+
+    fn index(&self, index: &K) -> &Self::Output {
+        self.0.index(index)
+    }
+}
diff --git a/cranelift/isle/isle/src/trie_again.rs b/cranelift/isle/isle/src/trie_again.rs
index 1e846288d56c..a45aeaa9a17e 100644
--- a/cranelift/isle/isle/src/trie_again.rs
+++ b/cranelift/isle/isle/src/trie_again.rs
@@ -1,9 +1,10 @@
 //! A strongly-normalizing intermediate representation for ISLE rules. This representation is chosen
 //! to closely reflect the operations we can implement in Rust, to make code generation easy.
+use crate::disjointsets::DisjointSets;
 use crate::error::{Error, Span};
 use crate::lexer::Pos;
-use crate::sema;
-use crate::{DisjointSets, StableSet};
+use crate::sema::{self, RuleId, TermEnv, TermId, TypeEnv};
+use crate::stablemapset::StableSet;
 use std::collections::{hash_map::Entry, HashMap};
 
 /// A field index in a tuple or an enum variant.
@@ -110,6 +111,11 @@ pub enum Binding {
         /// get the field names.
         field: TupleIndex,
     },
+    /// The result of constructing an Option::Some variant.
+    MakeSome {
+        /// Contained expression.
+        inner: BindingId,
+    },
     /// Pattern-match one of the previous bindings against `Option::Some` and produce a new binding
     /// from its contents. There must be a corresponding [Constraint::Some] for each `source` that
     /// appears in a `MatchSome` binding. (This currently only happens with external extractors.)
@@ -163,6 +169,8 @@ pub enum Constraint {
 /// contains this rule.
 #[derive(Debug, Default)]
 pub struct Rule {
+    /// Identifier of the source rule.
+    pub id: RuleId,
     /// Where was this rule defined?
     pub pos: Pos,
     /// All of these bindings must match the given constraints for this rule to apply. Note that
@@ -176,6 +184,8 @@ pub struct Rule {
     /// If other rules apply along with this one, the one with the highest numeric priority is
     /// evaluated. If multiple applicable rules have the same priority, that's an overlap error.
     pub prio: i64,
+    /// Rule name. Used for tracing.
+    pub name: Option<sema::Sym>,
     /// If this rule applies, these side effects should be evaluated before returning.
     pub impure: Vec<BindingId>,
     /// If this rule applies, the top-level term should evaluate to this expression.
@@ -249,10 +259,32 @@ impl Binding {
             Binding::Iterator { source } => std::slice::from_ref(source),
             Binding::MakeVariant { fields, .. } => &fields[..],
             Binding::MatchVariant { source, .. } => std::slice::from_ref(source),
+            Binding::MakeSome { inner } => std::slice::from_ref(inner),
             Binding::MatchSome { source } => std::slice::from_ref(source),
             Binding::MatchTuple { source, .. } => std::slice::from_ref(source),
         }
     }
+
+    /// Returns the term referenced by this binding.
+    // QUESTION(mbm): does Binding::term method make sense here?
+    pub fn term(&self, tyenv: &TypeEnv, termenv: &TermEnv) -> Option<TermId> {
+        match self {
+            Binding::ConstInt { .. } => None,
+            Binding::ConstPrim { .. } => None,
+            Binding::Argument { .. } => None,
+            Binding::Extractor { term, .. } => Some(*term),
+            Binding::Constructor { term, .. } => Some(*term),
+            Binding::Iterator { .. } => None,
+            Binding::MakeVariant { ty, variant, .. } => {
+                // QUESTION(mbm): include variant terms in Binding::term output?
+                Some(termenv.get_variant_term(tyenv, *ty, *variant))
+            }
+            Binding::MatchVariant { .. } => None,
+            Binding::MakeSome { .. } => None,
+            Binding::MatchSome { .. } => None,
+            Binding::MatchTuple { .. } => None,
+        }
+    }
 }
 
 impl Constraint {
@@ -274,6 +306,28 @@ impl Constraint {
                 .collect(),
         }
     }
+
+    /// Determine if this constraint could be compatible with a given binding.
+    pub fn compatible(&self, binding: &Binding) -> bool {
+        match (self, binding) {
+            (
+                Constraint::Variant {
+                    ty: tc,
+                    variant: vc,
+                    ..
+                },
+                Binding::MakeVariant {
+                    ty: tb,
+                    variant: vb,
+                    ..
+                },
+            ) => tb == tc && vb == vc,
+            (Constraint::ConstInt { val: vc, ty: tc }, Binding::ConstInt { val: vb, ty: tb }) => {
+                vc == vb && tc == tb
+            }
+            _ => true,
+        }
+    }
 }
 
 impl Rule {
@@ -380,9 +434,16 @@ struct RuleSetBuilder {
 impl RuleSetBuilder {
     fn add_rule(&mut self, rule: &sema::Rule, termenv: &sema::TermEnv, errors: &mut Vec<Error>) {
         self.impure_instance = 0;
+        self.current_rule.id = rule.id;
         self.current_rule.pos = rule.pos;
         self.current_rule.prio = rule.prio;
+        self.current_rule.name = rule.name;
         self.current_rule.result = rule.visit(self, termenv);
+        if termenv.terms[rule.root_term.index()].is_partial() {
+            self.current_rule.result = self.dedup_binding(Binding::MakeSome {
+                inner: self.current_rule.result,
+            });
+        }
         self.normalize_equivalence_classes();
         let rule = std::mem::take(&mut self.current_rule);
 
@@ -413,6 +474,7 @@ impl RuleSetBuilder {
     /// copy the constraint and push the equality inside it. For example:
     /// - `(term x @ 2 x)` is rewritten to `(term 2 2)`
     /// - `(term x @ (T.A _ _) x)` is rewritten to `(term (T.A y z) (T.A y z))`
+    ///
     /// In the latter case, note that every field of `T.A` has been replaced with a fresh variable
     /// and each of the copies are set equal.
     ///
diff --git a/cranelift/isle/isle/tests/printer_tests.rs b/cranelift/isle/isle/tests/printer_tests.rs
new file mode 100644
index 000000000000..82bf9c0127bf
--- /dev/null
+++ b/cranelift/isle/isle/tests/printer_tests.rs
@@ -0,0 +1,43 @@
+//! Auto-generated ISLE printer tests.
+
+use cranelift_isle::files::Files;
+use cranelift_isle::lexer;
+use cranelift_isle::parser;
+use cranelift_isle::printer;
+use std::io::BufWriter;
+use std::iter::zip;
+use std::sync::Arc;
+
+pub fn run_print(isle_filename: &str) {
+    // Parse.
+    let original_src = std::fs::read_to_string(isle_filename).unwrap();
+    let lexer = lexer::Lexer::new(0, &original_src).unwrap();
+    let files = Arc::new(Files::from_names_and_contents(vec![(
+        isle_filename.to_string(),
+        original_src.clone(),
+    )]));
+    let original = parser::parse_without_pos(lexer, files).unwrap();
+
+    // Print.
+    let mut buf = BufWriter::new(Vec::new());
+    printer::print(&original, 78, &mut buf).unwrap();
+    let bytes = buf.into_inner().unwrap();
+    let printed_src = String::from_utf8(bytes).unwrap();
+
+    // Round trip.
+    let lexer = lexer::Lexer::new(0, &printed_src).unwrap();
+    let files = Arc::new(Files::from_names_and_contents(vec![(
+        isle_filename.to_string(),
+        printed_src.clone(),
+    )]));
+    let round_trip = parser::parse_without_pos(lexer, files).unwrap();
+
+    // Ensure equal.
+    assert_eq!(original.len(), round_trip.len());
+    for (orig, rt) in zip(original, round_trip) {
+        assert_eq!(orig, rt);
+    }
+}
+
+// Generated by build.rs.
+include!(concat!(env!("OUT_DIR"), "/isle_printer_tests.rs"));
diff --git a/cranelift/isle/isle/tests/run_tests.rs b/cranelift/isle/isle/tests/run_tests.rs
index 1b347b9454ce..5fbabdca75ed 100644
--- a/cranelift/isle/isle/tests/run_tests.rs
+++ b/cranelift/isle/isle/tests/run_tests.rs
@@ -2,7 +2,6 @@
 
 use cranelift_isle::compile;
 use cranelift_isle::error::Errors;
-use std::default::Default;
 
 fn build(filename: &str) -> Result<String, Errors> {
     compile::from_files(&[filename], &Default::default())
@@ -10,16 +9,16 @@ fn build(filename: &str) -> Result<String, Errors> {
 
 pub fn run_pass(filename: &str) {
     if let Err(err) = build(filename) {
-        panic!("pass test failed:\n{:?}", err);
+        panic!("pass test failed:\n{err:?}");
     }
 }
 
 pub fn run_fail(filename: &str) {
     match build(filename) {
-        Ok(_) => panic!("test {} passed unexpectedly", filename),
+        Ok(_) => panic!("test {filename} passed unexpectedly"),
         Err(err) => {
             // Log the actual errors for use with `cargo test -- --nocapture`
-            println!("failed, as expected:\n{:?}", err);
+            println!("failed, as expected:\n{err:?}");
         }
     }
 }
@@ -43,7 +42,7 @@ fn build_and_link_isle(isle_filename: &str) -> (tempfile::TempDir, std::path::Pa
     let rust_filename = isle_filename.replace(".isle", "").to_string() + "_main.rs";
     let rust_filename_base = std::path::Path::new(&rust_filename).file_name().unwrap();
     let rust_driver = tempdir.path().to_path_buf().join(&rust_filename_base);
-    println!("copying {} to {:?}", rust_filename, rust_driver);
+    println!("copying {rust_filename} to {rust_driver:?}");
     std::fs::copy(&rust_filename, &rust_driver).unwrap();
 
     let output = tempdir.path().to_path_buf().join("out");
diff --git a/cranelift/isle/islec/Cargo.toml b/cranelift/isle/islec/Cargo.toml
index 96dee85792e7..4b2f6b70a589 100644
--- a/cranelift/isle/islec/Cargo.toml
+++ b/cranelift/isle/islec/Cargo.toml
@@ -3,10 +3,11 @@ name = "islec"
 version = "0.0.0"
 authors = ["The Cranelift Project Developers"]
 edition.workspace = true
+rust-version.workspace = true
 license = "Apache-2.0 WITH LLVM-exception"
 publish = false
 
 [dependencies]
-cranelift-isle = { version = "*", path = "../isle/", features = ["fancy-errors", "logging"] }
+cranelift-isle = { version = "*", path = "../isle/", features = ["fancy-errors", "logging", "printer"] }
 env_logger = { workspace = true }
-clap = { workspace = true }
+clap = { workspace = true, features = ['default'] }
diff --git a/cranelift/isle/islec/src/main.rs b/cranelift/isle/islec/src/main.rs
index f934e71ae666..d4cbabb65972 100644
--- a/cranelift/isle/islec/src/main.rs
+++ b/cranelift/isle/islec/src/main.rs
@@ -2,7 +2,6 @@ use clap::Parser;
 use cranelift_isle::compile;
 use cranelift_isle::error::Errors;
 use std::{
-    default::Default,
     fs,
     io::{self, Write},
     path::PathBuf,
@@ -12,11 +11,11 @@ use std::{
 struct Opts {
     /// The output file to write the generated Rust code to. `stdout` is used if
     /// this is not given.
-    #[clap(short, long)]
+    #[arg(short, long)]
     output: Option<PathBuf>,
 
     /// The input ISLE DSL source files.
-    #[clap(required = true)]
+    #[arg(required = true)]
     inputs: Vec<PathBuf>,
 }
 
diff --git a/cranelift/isle/veri/README.md b/cranelift/isle/veri/README.md
new file mode 100644
index 000000000000..c2ba02f9918c
--- /dev/null
+++ b/cranelift/isle/veri/README.md
@@ -0,0 +1,86 @@
+# VeriISLE
+
+VeriISLE is an in-development research prototype verifier for the ISLE language.
+It builds upon the Crocus verifier, adding support for automatic rule chaining
+and authoritative ISA semantics.
+
+## Dependencies
+
+To run the verifier you will need a backend SMT2 solver installed. The `cvc5`
+solver is currently preferred.
+
+On MacOS, you can install via homebrew:
+
+```
+brew install cvc5/homebrew-cvc5/cvc5
+```
+
+Alternatively, on Linux or MacOS you can install from Github release with:
+
+```
+./veri/script/install/cvc5.sh -i <install_path>
+```
+
+If you use this method, ensure that `<install_path>/bin` is on your `$PATH`.
+
+## Running
+
+To run the verifier, from the `cranelift/isle/veri/veri` directory run:
+
+```
+./script/veri.sh
+```
+
+This will run verification on the default AArch64 backend. To run on the X64
+backend, add the `-a x64` option.  The tool uses the presence of rule names as
+an indication of whether to attempt verification.  Specifically, it will run
+verification for all rule expansions such that the first expanded rule has a
+name.
+
+During development you may want to focus on a subset of expansions, for example
+those starting with a given rule of interest.  First add a name to the rule, and
+then the following command can be used to limit to all expansions involving it:
+
+```
+./script/veri.sh -- --filter rule:<rule>
+```
+
+## ISA Specifications
+
+Where possible we derive ISA specifications in VeriISLE format from
+authoritative specifications distributed by vendors. Currently this is only
+possible for the AArch64 backend, with specifications derived from ARM's Machine
+Readable Specification in Architecture Specification Language (ASL). We rely on
+the [ASLp](https://github.com/UQ-PAC/aslp) tool to assist with distilling down
+the original verbose specifications to usable semantics for verification.
+
+The resulting ISA specifications are checked in to the repository, so there is
+no requirement to install ASLp unless you want to alter existing or derive more
+specifications with it.
+
+### Generating ISA Specifications
+
+To run ISA specification generation, you will first need to install ASLp:
+
+1.  [Install `opam`](https://opam.ocaml.org/doc/Install.html), the OCaml Package
+    Manager. The "Binary distribution" method is recommended.
+2.  Install ASLp with `./veri/script/install/aslp.sh -i <aslp_install_path>`.
+3.  Ensure ASLp tools are available by adding `<aslp_install_path>/bin` to your
+    `PATH`.
+
+To run ISA specification generation, from the `isaspec` directory run:
+
+```
+./script/generate.sh -l
+```
+
+This will:
+
+1.  Launch an instance of the `aslp-server`. Communicating with ASLp over a
+    server connection allows us to pay the initialization cost of reading the
+    large ASL specification once.
+2.  Build and execute the `isaspec` tool.
+3.  Write outputs to the `cranelift/codegen/src/isa/aarch64/spec/` directory.
+
+On a clean checkout this should be a no-op, and in fact we have CI tests that
+verify this.
diff --git a/cranelift/isle/veri/aslp/Cargo.toml b/cranelift/isle/veri/aslp/Cargo.toml
new file mode 100644
index 000000000000..fb708f7e90e4
--- /dev/null
+++ b/cranelift/isle/veri/aslp/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "cranelift-isle-veri-aslp"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[dependencies]
+pest = "2.7.8"
+pest_derive = "2.7.8"
+enquote = "1.1.0"
+clap = { workspace = true }
+anyhow = { workspace = true, features = ['std', 'backtrace'] }
+tracing = { workspace = true }
+tracing-subscriber = { workspace = true }
+cranelift-isle-veri-test-macros = { path = "../test-macros" }
+reqwest = { workspace = true, features = ["blocking", "json"] }
+serde = { workspace = true, features = ["derive"] }
diff --git a/cranelift/isle/veri/aslp/src/aslt.pest b/cranelift/isle/veri/aslp/src/aslt.pest
new file mode 100644
index 000000000000..d05f5ae6aa50
--- /dev/null
+++ b/cranelift/isle/veri/aslp/src/aslt.pest
@@ -0,0 +1,118 @@
+aslt = _{ SOI ~ (stmt ~ (NEWLINE ~ stmt)* ~ NEWLINE?)? ~ EOI }
+
+// Statements
+
+stmt = {
+    stmt_assign
+  | stmt_constdecl
+  | stmt_vardecl
+  | stmt_vardeclsnoinit
+  | stmt_assert
+  | stmt_if
+  | stmt_tcall
+}
+
+stmt_assign         = { "Stmt_Assign(" ~ lexpr ~ "," ~ expr ~ ")" }
+stmt_constdecl      = { "Stmt_ConstDecl(" ~ ty ~ "," ~ ident ~ "," ~ expr ~ ")" }
+stmt_vardecl        = { "Stmt_VarDecl(" ~ ty ~ "," ~ ident ~ "," ~ expr ~ ")" }
+stmt_vardeclsnoinit = { "Stmt_VarDeclsNoInit(" ~ ty ~ "," ~ vars ~ ")" }
+stmt_assert         = { "Stmt_Assert(" ~ expr ~ ")" }
+stmt_if             = { "Stmt_If(" ~ expr ~ "," ~ stmts ~ "," ~ stmts ~ "," ~ stmts ~ ")" }
+stmt_tcall          = { "Stmt_TCall(" ~ func_ident ~ "," ~ exprs ~ "," ~ exprs ~ ")" }
+
+stmts = { "[" ~ (NEWLINE ~ stmt ~ (";" ~ NEWLINE ~ stmt)* ~ NEWLINE)? ~ "]" }
+
+// Left-hand-side Expressions
+
+lexpr = {
+    lexpr_array
+  | lexpr_field
+  | lexpr_var
+}
+
+lexpr_array = { "LExpr_Array(" ~ lexpr ~ "," ~ expr ~ ")" }
+lexpr_field = { "LExpr_Field(" ~ lexpr ~ "," ~ ident ~ ")" }
+lexpr_var   = { "LExpr_Var(" ~ var ~ ")" }
+
+// Expressions
+
+expr = {
+    expr_paren
+  | expr_array
+  | expr_field
+  | expr_var
+  | expr_tapply
+  | expr_slices
+  | expr_litint
+  | expr_litbits
+}
+
+expr_paren   = _{ "(" ~ expr ~ ")" }
+expr_array   =  { "Expr_Array(" ~ expr ~ "," ~ expr ~ ")" }
+expr_field   =  { "Expr_Field(" ~ expr ~ "," ~ ident ~ ")" }
+expr_var     =  { "Expr_Var(" ~ var ~ ")" }
+expr_tapply  =  { "Expr_TApply(" ~ func_ident ~ "," ~ exprs ~ "," ~ exprs ~ ")" }
+expr_slices  =  { "Expr_Slices(" ~ expr ~ "," ~ slices ~ ")" }
+expr_litint  =  { integer }
+expr_litbits =  { bits }
+
+exprs = { "[" ~ (expr ~ (";" ~ expr)*)? ~ "]" }
+
+// Slices
+
+slice = {
+    slice_paren
+  | slice_lowd
+}
+
+slice_paren = _{ "(" ~ slice ~ ")" }
+slice_lowd  =  { "Slice_LoWd(" ~ expr ~ "," ~ expr ~ ")" }
+
+slices = { "[" ~ (slice ~ (";" ~ slice)*)? ~ "]" }
+
+// Types
+
+ty = {
+    ty_bits
+  | ty_boolean
+}
+
+ty_bits    = { "Type_Bits(" ~ expr ~ ")" }
+ty_boolean = { "Type_Constructor(\"boolean\")" }
+
+// Variables
+
+var = {
+    var_paren
+  | var_ident
+}
+
+var_paren = _{ "(" ~ var ~ ")" }
+var_ident =  { ident }
+
+vars = { "[" ~ (var ~ (";" ~ var)*)? ~ "]" }
+
+// Identifiers
+
+func_ident = ${ "\"" ~ id ~ "." ~ decimal ~ "\"" }
+
+ident = @{ "\"" ~ id ~ "\"" }
+
+id = @{
+    name ~ "." ~ name
+  | name
+}
+
+name = @{
+    (ASCII_ALPHA | "_") ~ (ASCII_ALPHANUMERIC | "_")*
+}
+
+// Literals
+
+integer = @{ decimal }
+
+bits = @{ "\'" ~ binary ~ "\'" }
+
+decimal = @{ ASCII_DIGIT+ }
+
+binary = @{ ASCII_BIN_DIGIT+ }
diff --git a/cranelift/isle/veri/aslp/src/ast.rs b/cranelift/isle/veri/aslp/src/ast.rs
new file mode 100644
index 000000000000..de4399db5444
--- /dev/null
+++ b/cranelift/isle/veri/aslp/src/ast.rs
@@ -0,0 +1,97 @@
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct Block {
+    pub stmts: Vec<Stmt>,
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum Stmt {
+    ConstDecl {
+        ty: Type,
+        name: String,
+        rhs: Expr,
+    },
+    VarDecl {
+        ty: Type,
+        name: String,
+        rhs: Expr,
+    },
+    VarDeclsNoInit {
+        ty: Type,
+        names: Vec<String>,
+    },
+    Assign {
+        lhs: LExpr,
+        rhs: Expr,
+    },
+    Assert {
+        cond: Expr,
+    },
+    If {
+        cond: Expr,
+        then_block: Block,
+        // TODO(mbm): else if
+        else_block: Block,
+    },
+    Call {
+        func: Func,
+        types: Vec<Expr>,
+        args: Vec<Expr>,
+    },
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum LExpr {
+    ArrayIndex { array: Box<LExpr>, index: Box<Expr> },
+    Field { x: Box<LExpr>, name: String },
+    Var(String),
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum Expr {
+    Apply {
+        func: Func,
+        types: Vec<Expr>,
+        args: Vec<Expr>,
+    },
+    ArrayIndex {
+        array: Box<Expr>,
+        index: Box<Expr>,
+    },
+    Field {
+        x: Box<Expr>,
+        name: String,
+    },
+    Slices {
+        x: Box<Expr>,
+        slices: Vec<Slice>,
+    },
+    Var(String),
+    LitInt(String),
+    LitBits(String),
+}
+
+impl Expr {
+    pub fn as_lit_int(&self) -> Option<&String> {
+        match self {
+            Expr::LitInt(i) => Some(i),
+            _ => None,
+        }
+    }
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum Slice {
+    LowWidth(Box<Expr>, Box<Expr>),
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct Func {
+    pub name: String,
+    pub id: usize,
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum Type {
+    Bits(Box<Expr>),
+    Bool,
+}
diff --git a/cranelift/isle/veri/aslp/src/client.rs b/cranelift/isle/veri/aslp/src/client.rs
new file mode 100644
index 000000000000..736ba2aa1e70
--- /dev/null
+++ b/cranelift/isle/veri/aslp/src/client.rs
@@ -0,0 +1,50 @@
+use anyhow::{bail, Result};
+use reqwest::IntoUrl;
+use serde::Deserialize;
+use tracing::debug;
+
+use crate::{ast::Block, opcode::Opcode, parser};
+
+pub struct Client<'a> {
+    client: &'a reqwest::blocking::Client,
+    server_url: reqwest::Url,
+}
+
+impl<'a> Client<'a> {
+    pub fn new<U: IntoUrl>(client: &'a reqwest::blocking::Client, server_url: U) -> Result<Self> {
+        Ok(Self {
+            client,
+            server_url: server_url.into_url()?,
+        })
+    }
+
+    pub fn opcode(&self, opcode: Opcode) -> Result<Block> {
+        // Model for response JSON data.
+        #[derive(Deserialize, Debug)]
+        struct Response {
+            instruction: String,
+            semantics: String,
+        }
+
+        // Issue GET request.
+        let opcode = opcode.to_string();
+        let res: Response = self
+            .client
+            .get(self.server_url.clone())
+            .query(&[("opcode", &opcode)])
+            .send()?
+            .json()?;
+
+        debug!(%res.semantics);
+
+        // Ensure response instruction matches.
+        if res.instruction != opcode {
+            bail!("response opcode mismatch");
+        }
+
+        // Parse semantics.
+        let block = parser::parse(&res.semantics)?;
+
+        Ok(block)
+    }
+}
diff --git a/cranelift/isle/veri/aslp/src/lib.rs b/cranelift/isle/veri/aslp/src/lib.rs
new file mode 100644
index 000000000000..6ce9c5b2c92a
--- /dev/null
+++ b/cranelift/isle/veri/aslp/src/lib.rs
@@ -0,0 +1,4 @@
+pub mod ast;
+pub mod client;
+pub mod opcode;
+pub mod parser;
diff --git a/cranelift/isle/veri/aslp/src/main.rs b/cranelift/isle/veri/aslp/src/main.rs
new file mode 100644
index 000000000000..a6f4be420d6f
--- /dev/null
+++ b/cranelift/isle/veri/aslp/src/main.rs
@@ -0,0 +1,38 @@
+use anyhow::Result;
+use clap::Parser as ClapParser;
+use cranelift_isle_veri_aslp::parser;
+use std::{fs, path::PathBuf};
+
+#[derive(ClapParser)]
+#[command(version, about)]
+struct Args {
+    /// Input file to be formatted
+    file: PathBuf,
+
+    /// Print debugging output (repeat for more detail)
+    #[arg(short = 'd', long = "debug", action = clap::ArgAction::Count)]
+    debug_level: u8,
+}
+
+fn main() -> Result<()> {
+    let args = Args::parse();
+
+    tracing_subscriber::fmt()
+        .with_timer(tracing_subscriber::fmt::time::uptime())
+        .with_level(true)
+        .with_target(false)
+        .with_max_level(match args.debug_level {
+            0 => tracing::Level::WARN,
+            1 => tracing::Level::INFO,
+            2 => tracing::Level::DEBUG,
+            _ => tracing::Level::TRACE,
+        })
+        .init();
+
+    let src = fs::read_to_string(args.file).unwrap();
+
+    let block = parser::parse(&src)?;
+    println!("ast = {block:?}");
+
+    Ok(())
+}
diff --git a/cranelift/isle/veri/aslp/src/opcode.rs b/cranelift/isle/veri/aslp/src/opcode.rs
new file mode 100644
index 000000000000..245c29eddd85
--- /dev/null
+++ b/cranelift/isle/veri/aslp/src/opcode.rs
@@ -0,0 +1,55 @@
+pub struct Opcode {
+    pub segments: Vec<Segment>,
+}
+
+impl Opcode {
+    pub fn from_u32(x: u32) -> Self {
+        Opcode {
+            segments: vec![Segment::from_u32(x)],
+        }
+    }
+}
+
+impl std::fmt::Display for Opcode {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            self.segments
+                .iter()
+                .rev()
+                .map(|s| s.to_string())
+                .collect::<Vec<_>>()
+                .join("|")
+        )
+    }
+}
+
+pub enum Segment {
+    Symbolic(String, usize),
+    Constant(u32, usize),
+}
+
+impl Segment {
+    pub fn from_u32(x: u32) -> Self {
+        Segment::Constant(x, 32)
+    }
+
+    pub fn width(&self) -> usize {
+        match self {
+            Segment::Symbolic(_, w) | Segment::Constant(_, w) => *w,
+        }
+    }
+}
+
+impl std::fmt::Display for Segment {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Segment::Symbolic(s, w) => write!(f, "{s}:{w}"),
+            Segment::Constant(c, w) if w % 4 == 0 => {
+                write!(f, "0x{c:0>nibbles$x}", nibbles = w / 4)
+            }
+            Segment::Constant(c, w) => write!(f, "{c:#x}:{w}"),
+        }
+    }
+}
diff --git a/cranelift/isle/veri/aslp/src/parser.rs b/cranelift/isle/veri/aslp/src/parser.rs
new file mode 100644
index 000000000000..cc82e7d8f3ad
--- /dev/null
+++ b/cranelift/isle/veri/aslp/src/parser.rs
@@ -0,0 +1,276 @@
+use anyhow::Result;
+use enquote::unquote;
+use pest::{
+    iterators::{Pair, Pairs},
+    Parser,
+};
+use pest_derive::Parser;
+use tracing::debug;
+
+use crate::ast::{Block, Expr, Func, LExpr, Slice, Stmt, Type};
+
+#[derive(Parser)]
+#[grammar = "aslt.pest"]
+struct ASLTParser;
+
+pub fn parse(src: &str) -> Result<Block> {
+    let pairs = ASLTParser::parse(Rule::aslt, src)?;
+    parse_block(pairs)
+}
+
+fn parse_block(pairs: Pairs<Rule>) -> Result<Block> {
+    let stmts = parse_stmts(pairs)?;
+    Ok(Block { stmts })
+}
+
+fn parse_stmts(pairs: Pairs<Rule>) -> Result<Vec<Stmt>> {
+    let mut stmts = Vec::new();
+    for pair in pairs {
+        let rule = pair.as_rule();
+        debug!(?rule, "parse stmts");
+        match rule {
+            Rule::stmt => stmts.push(parse_stmt(pair)?),
+            Rule::EOI => break,
+            _ => unreachable!("unexpected statement: {pair}"),
+        }
+    }
+    Ok(stmts)
+}
+
+fn parse_stmt(pair: Pair<Rule>) -> Result<Stmt> {
+    let rule = pair.as_rule();
+    debug!(?rule, "parse stmt");
+    match rule {
+        Rule::stmt => parse_stmt(pair.into_inner().next().unwrap()),
+        Rule::stmt_assign => {
+            let mut pairs = pair.into_inner();
+            let lhs = parse_lexpr(pairs.next().unwrap())?;
+            let rhs = parse_expr(pairs.next().unwrap())?;
+            Ok(Stmt::Assign { lhs, rhs })
+        }
+        Rule::stmt_constdecl => {
+            let mut pairs = pair.into_inner();
+            let ty = parse_type(pairs.next().unwrap())?;
+            let name = parse_ident(pairs.next().unwrap())?;
+            let rhs = parse_expr(pairs.next().unwrap())?;
+            Ok(Stmt::ConstDecl { ty, name, rhs })
+        }
+        Rule::stmt_vardecl => {
+            let mut pairs = pair.into_inner();
+            let ty = parse_type(pairs.next().unwrap())?;
+            let name = parse_ident(pairs.next().unwrap())?;
+            let rhs = parse_expr(pairs.next().unwrap())?;
+            Ok(Stmt::VarDecl { ty, name, rhs })
+        }
+        Rule::stmt_vardeclsnoinit => {
+            let mut pairs = pair.into_inner();
+            let ty = parse_type(pairs.next().unwrap())?;
+            let names = parse_vars(pairs.next().unwrap().into_inner())?;
+            Ok(Stmt::VarDeclsNoInit { ty, names })
+        }
+        Rule::stmt_assert => {
+            let cond = parse_expr(pair.into_inner().next().unwrap())?;
+            Ok(Stmt::Assert { cond })
+        }
+        Rule::stmt_if => {
+            let mut pairs = pair.into_inner();
+            let cond = parse_expr(pairs.next().unwrap())?;
+            let then_block = parse_block(pairs.next().unwrap().into_inner())?;
+            let elseif_block = parse_block(pairs.next().unwrap().into_inner())?;
+            if !elseif_block.stmts.is_empty() {
+                todo!("else if");
+            }
+            let else_block = parse_block(pairs.next().unwrap().into_inner())?;
+            Ok(Stmt::If {
+                cond,
+                then_block,
+                else_block,
+            })
+        }
+        Rule::stmt_tcall => {
+            let mut pairs = pair.into_inner();
+            let func = parse_func_ident(pairs.next().unwrap())?;
+            let types = parse_exprs(pairs.next().unwrap().into_inner())?;
+            let args = parse_exprs(pairs.next().unwrap().into_inner())?;
+            Ok(Stmt::Call { func, types, args })
+        }
+        _ => unreachable!("unexpected statement: {rule:?}"),
+    }
+}
+
+fn parse_lexpr(pair: Pair<Rule>) -> Result<LExpr> {
+    let rule = pair.as_rule();
+    debug!(?rule, "parse lexpr");
+    match rule {
+        Rule::lexpr => parse_lexpr(pair.into_inner().next().unwrap()),
+        Rule::lexpr_array => {
+            let mut pairs = pair.into_inner();
+            let array = Box::new(parse_lexpr(pairs.next().unwrap())?);
+            let index = Box::new(parse_expr(pairs.next().unwrap())?);
+            Ok(LExpr::ArrayIndex { array, index })
+        }
+        Rule::lexpr_field => {
+            let mut pairs = pair.into_inner();
+            let x = Box::new(parse_lexpr(pairs.next().unwrap())?);
+            let name = parse_ident(pairs.next().unwrap())?;
+            Ok(LExpr::Field { x, name })
+        }
+        Rule::lexpr_var => {
+            let var = parse_var(pair.into_inner().next().unwrap())?;
+            Ok(LExpr::Var(var))
+        }
+        _ => unreachable!("unexpected lexpr: {rule:?}"),
+    }
+}
+
+fn parse_expr(pair: Pair<Rule>) -> Result<Expr> {
+    let rule = pair.as_rule();
+    debug!(?rule, "parse expr");
+    match rule {
+        Rule::expr => parse_expr(pair.into_inner().next().unwrap()),
+        Rule::expr_array => {
+            let mut pairs = pair.into_inner();
+            let array = Box::new(parse_expr(pairs.next().unwrap())?);
+            let index = Box::new(parse_expr(pairs.next().unwrap())?);
+            Ok(Expr::ArrayIndex { array, index })
+        }
+        Rule::expr_tapply => {
+            let mut pairs = pair.into_inner();
+            let func = parse_func_ident(pairs.next().unwrap())?;
+            let types = parse_exprs(pairs.next().unwrap().into_inner())?;
+            let args = parse_exprs(pairs.next().unwrap().into_inner())?;
+            Ok(Expr::Apply { func, types, args })
+        }
+        Rule::expr_slices => {
+            let mut pairs = pair.into_inner();
+            let x = Box::new(parse_expr(pairs.next().unwrap())?);
+            let slices = parse_slices(pairs.next().unwrap().into_inner())?;
+            Ok(Expr::Slices { x, slices })
+        }
+        Rule::expr_field => {
+            let mut pairs = pair.into_inner();
+            let x = Box::new(parse_expr(pairs.next().unwrap())?);
+            let name = parse_ident(pairs.next().unwrap())?;
+            Ok(Expr::Field { x, name })
+        }
+        Rule::expr_var => {
+            let var = parse_var(pair.into_inner().next().unwrap())?;
+            Ok(Expr::Var(var))
+        }
+        Rule::expr_litint => {
+            let digits = parse_literal(pair.into_inner().next().unwrap())?;
+            Ok(Expr::LitInt(digits))
+        }
+        Rule::expr_litbits => {
+            let bits = parse_literal(pair.into_inner().next().unwrap())?;
+            Ok(Expr::LitBits(bits))
+        }
+        _ => unreachable!("unexpected expr: {rule:?}"),
+    }
+}
+
+fn parse_exprs(pairs: Pairs<Rule>) -> Result<Vec<Expr>> {
+    let mut exprs = Vec::new();
+    for pair in pairs {
+        let rule = pair.as_rule();
+        debug!(?rule, "parse exprs");
+        match rule {
+            Rule::expr => exprs.push(parse_expr(pair)?),
+            _ => unreachable!("unexpected expression: {rule:?}"),
+        }
+    }
+    Ok(exprs)
+}
+
+fn parse_slice(pair: Pair<Rule>) -> Result<Slice> {
+    let rule = pair.as_rule();
+    debug!(?rule, "parse slice");
+    match rule {
+        Rule::slice => parse_slice(pair.into_inner().next().unwrap()),
+        Rule::slice_lowd => {
+            let mut pairs = pair.into_inner();
+            let low = Box::new(parse_expr(pairs.next().unwrap())?);
+            let width = Box::new(parse_expr(pairs.next().unwrap())?);
+            Ok(Slice::LowWidth(low, width))
+        }
+        _ => unreachable!("unexpected slice: {rule:?}"),
+    }
+}
+
+fn parse_slices(pairs: Pairs<Rule>) -> Result<Vec<Slice>> {
+    let mut slices = Vec::new();
+    for pair in pairs {
+        let rule = pair.as_rule();
+        debug!(?rule, "parse slices");
+        match rule {
+            Rule::slice => slices.push(parse_slice(pair)?),
+            _ => unreachable!("unexpected slice: {rule:?}"),
+        }
+    }
+    Ok(slices)
+}
+
+fn parse_type(pair: Pair<Rule>) -> Result<Type> {
+    let rule = pair.as_rule();
+    debug!(?rule, "parse type");
+    match rule {
+        Rule::ty => parse_type(pair.into_inner().next().unwrap()),
+        Rule::ty_bits => {
+            let width = Box::new(parse_expr(pair.into_inner().next().unwrap())?);
+            Ok(Type::Bits(width))
+        }
+        Rule::ty_boolean => Ok(Type::Bool),
+        _ => unreachable!("unexpected type: {rule:?}"),
+    }
+}
+
+fn parse_var(pair: Pair<Rule>) -> Result<String> {
+    let rule = pair.as_rule();
+    debug!(?rule, "parse var");
+    match rule {
+        Rule::var => parse_var(pair.into_inner().next().unwrap()),
+        Rule::var_ident => parse_ident(pair),
+        _ => unreachable!("unexpected var: {rule:?}"),
+    }
+}
+
+fn parse_vars(pairs: Pairs<Rule>) -> Result<Vec<String>> {
+    let mut vars = Vec::new();
+    for pair in pairs {
+        let rule = pair.as_rule();
+        debug!(?rule, "parse vars");
+        match rule {
+            Rule::var => vars.push(parse_var(pair)?),
+            _ => unreachable!("unexpected var: {rule:?}"),
+        }
+    }
+    Ok(vars)
+}
+
+fn parse_func_ident(pair: Pair<Rule>) -> Result<Func> {
+    let rule = pair.as_rule();
+    debug!(?rule, "parse func ident");
+    match rule {
+        Rule::func_ident => {
+            let mut pairs = pair.into_inner();
+            let name = pairs.next().unwrap().as_str().to_string();
+            let id = pairs.next().unwrap().as_str().parse()?;
+            Ok(Func { name, id })
+        }
+        _ => unreachable!("unexpected func ident: {rule:?}"),
+    }
+}
+
+fn parse_ident(pair: Pair<Rule>) -> Result<String> {
+    Ok(unquote(pair.as_str())?)
+}
+
+fn parse_literal(pair: Pair<Rule>) -> Result<String> {
+    let rule = pair.as_rule();
+    debug!(?rule, "parse literal");
+    match rule {
+        Rule::integer => Ok(pair.as_str().to_string()),
+        Rule::bits => Ok(unquote(pair.as_str())?),
+        _ => unreachable!("unexpected literal: {rule:?}"),
+    }
+}
diff --git a/cranelift/isle/veri/aslp/tests/data/add.aslt b/cranelift/isle/veri/aslp/tests/data/add.aslt
new file mode 100644
index 000000000000..61d51785c6dc
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/add.aslt
@@ -0,0 +1 @@
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),4),Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),5);Expr_Array(Expr_Var("_R"),6)]))
diff --git a/cranelift/isle/veri/aslp/tests/data/add32.aslt b/cranelift/isle/veri/aslp/tests/data/add32.aslt
new file mode 100644
index 000000000000..e416b4cdef7c
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/add32.aslt
@@ -0,0 +1 @@
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),4),Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("add_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_R"),5),[Slice_LoWd(0,32)]);Expr_Slices(Expr_Array(Expr_Var("_R"),6),[Slice_LoWd(0,32)])]);64]))
diff --git a/cranelift/isle/veri/aslp/tests/data/add_extend.aslt b/cranelift/isle/veri/aslp/tests/data/add_extend.aslt
new file mode 100644
index 000000000000..79f9e0a2148a
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/add_extend.aslt
@@ -0,0 +1 @@
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),15),Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),16);Expr_Array(Expr_Var("_R"),17)]))
diff --git a/cranelift/isle/veri/aslp/tests/data/add_imm.aslt b/cranelift/isle/veri/aslp/tests/data/add_imm.aslt
new file mode 100644
index 000000000000..b3e66dd32905
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/add_imm.aslt
@@ -0,0 +1 @@
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),7),Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),8);'0000000000000000000000000000000000000000000000000000000100100011']))
diff --git a/cranelift/isle/veri/aslp/tests/data/add_shift.aslt b/cranelift/isle/veri/aslp/tests/data/add_shift.aslt
new file mode 100644
index 000000000000..75594510902d
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/add_shift.aslt
@@ -0,0 +1 @@
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),1),Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),2);Expr_TApply("append_bits.0",[60;4],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(0,60)]);'0000'])]))
diff --git a/cranelift/isle/veri/aslp/tests/data/addc.aslt b/cranelift/isle/veri/aslp/tests/data/addc.aslt
new file mode 100644
index 000000000000..abc0285a79a6
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/addc.aslt
@@ -0,0 +1 @@
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),4),Expr_TApply("add_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),5);Expr_Array(Expr_Var("_R"),6)]);Expr_TApply("ZeroExtend.0",[1;64],[Expr_Slices(Expr_Field(Expr_Var("PSTATE"),"C"),[Slice_LoWd(0,1)]);64])]))
diff --git a/cranelift/isle/veri/aslp/tests/data/adds.aslt b/cranelift/isle/veri/aslp/tests/data/adds.aslt
new file mode 100644
index 000000000000..ba28761581df
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/adds.aslt
@@ -0,0 +1,6 @@
+Stmt_ConstDecl(Type_Bits(64),"Cse0__5",Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),2);Expr_Array(Expr_Var("_R"),3)]))
+Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("SignExtend.0",[64;128],[Expr_Var("Cse0__5");128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("SignExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),2);128]);Expr_TApply("SignExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),3);128])])])])]))
+Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_Var("Cse0__5");128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),2);128]);Expr_TApply("ZeroExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),3);128])])])])]))
+Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000000'])]))
+Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_Slices(Expr_Var("Cse0__5"),[Slice_LoWd(63,1)]))
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),1),Expr_Var("Cse0__5"))
diff --git a/cranelift/isle/veri/aslp/tests/data/ccmp.aslt b/cranelift/isle/veri/aslp/tests/data/ccmp.aslt
new file mode 100644
index 000000000000..658d6d299eaf
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/ccmp.aslt
@@ -0,0 +1,13 @@
+Stmt_ConstDecl(Type_Bits(64),"Cse2__5",Expr_TApply("not_bits.0",[64],[Expr_Array(Expr_Var("_R"),1)]))
+Stmt_ConstDecl(Type_Bits(64),"Cse0__5",Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),22);Expr_TApply("not_bits.0",[64],[Expr_Array(Expr_Var("_R"),1)])]))
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"Z");'1']),[
+Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("SignExtend.0",[64;128],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("add_bits.0",[128],[Expr_TApply("SignExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),22);128]);Expr_TApply("SignExtend.0",[64;128],[Expr_Var("Cse2__5");128])]);'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001'])])])]));
+Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("add_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),22);128]);Expr_TApply("ZeroExtend.0",[64;128],[Expr_Var("Cse2__5");128])]);'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001'])])])]));
+Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);'0000000000000000000000000000000000000000000000000000000000000000'])]));
+Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_Slices(Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']),[Slice_LoWd(63,1)]))
+],[],[
+Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),'1');
+Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),'0');
+Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),'1');
+Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),'1')
+])
diff --git a/cranelift/isle/veri/aslp/tests/data/clz.aslt b/cranelift/isle/veri/aslp/tests/data/clz.aslt
new file mode 100644
index 000000000000..31be61b281e7
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/clz.aslt
@@ -0,0 +1,259 @@
+Stmt_VarDeclsNoInit(Type_Bits(16),["HighestSetBit6__6"])
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(63,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000111111')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(62,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000111110')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(61,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000111101')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(60,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000111100')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(59,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000111011')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(58,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000111010')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(57,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000111001')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(56,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000111000')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(55,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000110111')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(54,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000110110')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(53,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000110101')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(52,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000110100')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(51,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000110011')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(50,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000110010')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(49,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000110001')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(48,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000110000')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(47,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000101111')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(46,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000101110')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(45,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000101101')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(44,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000101100')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(43,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000101011')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(42,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000101010')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(41,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000101001')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(40,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000101000')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(39,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000100111')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(38,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000100110')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(37,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000100101')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(36,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000100100')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(35,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000100011')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(34,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000100010')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(33,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000100001')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(32,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000100000')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(31,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000011111')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(30,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000011110')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(29,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000011101')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(28,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000011100')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(27,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000011011')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(26,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000011010')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(25,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000011001')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(24,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000011000')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(23,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000010111')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(22,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000010110')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(21,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000010101')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(20,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000010100')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(19,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000010011')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(18,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000010010')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(17,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000010001')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(16,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000010000')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(15,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000001111')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(14,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000001110')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(13,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000001101')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(12,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000001100')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(11,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000001011')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(10,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000001010')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(9,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000001001')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(8,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000001000')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(7,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000000111')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(6,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000000110')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(5,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000000101')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(4,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000000100')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(3,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000000011')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(2,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000000010')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(1,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000000001')
+],[],[
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(0,1)]);'1']),[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'0000000000000000')
+],[],[
+Stmt_Assign(LExpr_Var("HighestSetBit6__6"),'1111111111111111')
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+])
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),15),Expr_TApply("SignExtend.0",[16;64],[Expr_TApply("sub_bits.0",[16],['0000000001000000';Expr_TApply("add_bits.0",[16],[Expr_Var("HighestSetBit6__6");'0000000000000001'])]);64]))
diff --git a/cranelift/isle/veri/aslp/tests/data/csel.aslt b/cranelift/isle/veri/aslp/tests/data/csel.aslt
new file mode 100644
index 000000000000..4932d0d967cc
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/csel.aslt
@@ -0,0 +1,5 @@
+Stmt_If(Expr_TApply("eq_bits.0",[1],[Expr_Field(Expr_Var("PSTATE"),"C");'1']),[
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),10),Expr_Array(Expr_Var("_R"),12))
+],[],[
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),10),Expr_Array(Expr_Var("_R"),14))
+])
diff --git a/cranelift/isle/veri/aslp/tests/data/generate.sh b/cranelift/isle/veri/aslp/tests/data/generate.sh
new file mode 100755
index 000000000000..436b3d08da3e
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/generate.sh
@@ -0,0 +1,84 @@
+#!/usr/bin/env bash
+
+set -euxo pipefail
+
+# Assemble AArch64 assembly to 32-bit hex opcode.
+function assemble() {
+    local asm="$1"
+
+    echo "${asm}" \
+        | clang -x assembler --target=aarch64 -march=armv8-a+sha2 - -c -o /dev/stdout \
+        | llvm-objdump - -d --section=.text \
+        | tail -n1 \
+        | awk '/0:/ { print $2 }'
+}
+
+# Generate semantics for opcode in ASLT form.
+function aslt() {
+    local opcode="$1"
+
+    {
+        echo ':set impdef "Has SHA1 Crypto instructions" = TRUE'
+        echo ":ast A64 0x${opcode}"
+    } | asli
+}
+
+# Generate named testcase for a given assembly instruction.
+function testcase() {
+    local name="$1"
+    local asm="$2"
+
+    opcode=$(assemble "${asm}")
+    aslt "${opcode}" > "${name}.aslt"
+}
+
+# Testcases.
+# Arithmetic.
+testcase    "add"           "add x4, x5, x6"
+testcase    "add32"         "add w4, w5, w6"
+testcase    "add_imm"       "add x7, x8, #291"
+testcase    "add_shift"     "add x1, x2, x3, lsl 4"
+testcase    "add_extend"    "add x15, x16, x17, uxtx"
+testcase    "addc"          "adc x4, x5, x6"
+testcase    "adds"          "adds x1, x2, x3"
+testcase    "subs"          "subs x10, x11, x12, lsl 23"
+testcase    "subsp"         "sub sp, sp, #32"
+
+# 8-bit loads.
+testcase    "ldrb"                      "ldrb w1, [x2]"
+testcase    "ldrb_reg_reg"              "ldrb w1, [x2, x3]"
+testcase    "ldrb_reg_scale"            "ldrb w1, [x2, x3, lsl #0]"
+testcase    "ldrb_reg_scale_ext_uxtw"   "ldrb w1, [x2, w3, uxtw #0]"
+testcase    "ldrb_reg_scale_ext_sxtw"   "ldrb w1, [x2, w3, sxtw #0]"
+testcase    "ldrb_reg_scale_ext_sxtx"   "ldrb w1, [x2, x3, sxtx #0]"
+
+# 16-bit loads.
+testcase    "ldrh"                      "ldrh w1, [x2]"
+testcase    "ldrh_reg_reg"              "ldrh w1, [x2, x3]"
+testcase    "ldrh_reg_scale"            "ldrh w1, [x2, x3, lsl #0]"
+testcase    "ldrh_reg_scale1"           "ldrh w1, [x2, x3, lsl #1]"
+testcase    "ldrh_reg_scale_ext_uxtw"   "ldrh w1, [x2, w3, uxtw #0]"
+testcase    "ldrh_reg_scale_ext_sxtw"   "ldrh w1, [x2, w3, sxtw #0]"
+testcase    "ldrh_reg_scale_ext_sxtx"   "ldrh w1, [x2, x3, sxtx #0]"
+
+# 32-bit loads.
+testcase    "ldrsw_reg_reg"              "ldrsw x1, [x2, x3]"
+testcase    "ldrsw_reg_scale"            "ldrsw x1, [x2, x3, lsl #0]"
+testcase    "ldrsw_reg_scale2"           "ldrsw x1, [x2, x3, lsl #2]"
+testcase    "ldrsw_reg_scale_ext_uxtw"   "ldrsw x1, [x2, w3, uxtw #0]"
+testcase    "ldrsw_reg_scale_ext_sxtw"   "ldrsw x1, [x2, w3, sxtw #0]"
+testcase    "ldrsw_reg_scale_ext_sxtx"   "ldrsw x1, [x2, x3, sxtx #0]"
+
+# Misc.
+testcase    "csel"          "csel x10, x12, x14, hs"
+testcase    "ccmp"          "ccmp x22, x1, 13, eq"
+testcase    "clz"           "clz x15, x3"
+testcase    "ldp"           "ldp x1, x2, [x3], #128"
+testcase    "stp"           "stp x1, x2, [x3], #128"
+testcase    "ucvtf"         "ucvtf d0, w2"
+testcase    "sha1h"         "sha1h s17, s6"
+testcase    "sha1su1"       "sha1su1 v2.4s, v1.4s"
+testcase    "sha1su0"       "sha1su0 v3.4s, v0.4s, v1.4s"
+testcase    "mrs"           "mrs x0, nzcv"
+testcase    "tbl"           "tbl v0.8b, {v0.16b}, v0.8b"
+testcase    "uqsub"         "uqsub v3.4s, v1.4s, v2.4s"
diff --git a/cranelift/isle/veri/aslp/tests/data/ldp.aslt b/cranelift/isle/veri/aslp/tests/data/ldp.aslt
new file mode 100644
index 000000000000..1f30e7d28c30
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/ldp.aslt
@@ -0,0 +1,3 @@
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),1),Expr_TApply("Mem.read.0",[8],[Expr_Array(Expr_Var("_R"),3);8;0]))
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),2),Expr_TApply("Mem.read.0",[8],[Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),3);'0000000000000000000000000000000000000000000000000000000000001000']);8;0]))
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),3),Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),3);'0000000000000000000000000000000000000000000000000000000010000000']))
diff --git a/cranelift/isle/veri/aslp/tests/data/ldrb.aslt b/cranelift/isle/veri/aslp/tests/data/ldrb.aslt
new file mode 100644
index 000000000000..dbf1921593e6
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/ldrb.aslt
@@ -0,0 +1 @@
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),1),Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("ZeroExtend.0",[8;32],[Expr_TApply("Mem.read.0",[1],[Expr_Array(Expr_Var("_R"),2);1;0]);32]);64]))
diff --git a/cranelift/isle/veri/aslp/tests/data/ldrb_reg_reg.aslt b/cranelift/isle/veri/aslp/tests/data/ldrb_reg_reg.aslt
new file mode 100644
index 000000000000..d5cc003630ec
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/ldrb_reg_reg.aslt
@@ -0,0 +1 @@
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),1),Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("ZeroExtend.0",[8;32],[Expr_TApply("Mem.read.0",[1],[Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),2);Expr_Array(Expr_Var("_R"),3)]);1;0]);32]);64]))
diff --git a/cranelift/isle/veri/aslp/tests/data/ldrb_reg_scale.aslt b/cranelift/isle/veri/aslp/tests/data/ldrb_reg_scale.aslt
new file mode 100644
index 000000000000..d5cc003630ec
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/ldrb_reg_scale.aslt
@@ -0,0 +1 @@
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),1),Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("ZeroExtend.0",[8;32],[Expr_TApply("Mem.read.0",[1],[Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),2);Expr_Array(Expr_Var("_R"),3)]);1;0]);32]);64]))
diff --git a/cranelift/isle/veri/aslp/tests/data/ldrb_reg_scale_ext_sxtw.aslt b/cranelift/isle/veri/aslp/tests/data/ldrb_reg_scale_ext_sxtw.aslt
new file mode 100644
index 000000000000..c3ec225c8e4f
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/ldrb_reg_scale_ext_sxtw.aslt
@@ -0,0 +1 @@
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),1),Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("ZeroExtend.0",[8;32],[Expr_TApply("Mem.read.0",[1],[Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),2);Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(0,32)]);64])]);1;0]);32]);64]))
diff --git a/cranelift/isle/veri/aslp/tests/data/ldrb_reg_scale_ext_sxtx.aslt b/cranelift/isle/veri/aslp/tests/data/ldrb_reg_scale_ext_sxtx.aslt
new file mode 100644
index 000000000000..8d603874cf7a
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/ldrb_reg_scale_ext_sxtx.aslt
@@ -0,0 +1 @@
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),1),Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("ZeroExtend.0",[8;32],[Expr_TApply("Mem.read.0",[1],[Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),2);Expr_TApply("SignExtend.0",[64;64],[Expr_Array(Expr_Var("_R"),3);64])]);1;0]);32]);64]))
diff --git a/cranelift/isle/veri/aslp/tests/data/ldrb_reg_scale_ext_uxtw.aslt b/cranelift/isle/veri/aslp/tests/data/ldrb_reg_scale_ext_uxtw.aslt
new file mode 100644
index 000000000000..f6e9c46e835c
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/ldrb_reg_scale_ext_uxtw.aslt
@@ -0,0 +1 @@
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),1),Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("ZeroExtend.0",[8;32],[Expr_TApply("Mem.read.0",[1],[Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),2);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(0,32)]);64])]);1;0]);32]);64]))
diff --git a/cranelift/isle/veri/aslp/tests/data/ldrh.aslt b/cranelift/isle/veri/aslp/tests/data/ldrh.aslt
new file mode 100644
index 000000000000..d412023d70d7
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/ldrh.aslt
@@ -0,0 +1 @@
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),1),Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("ZeroExtend.0",[16;32],[Expr_TApply("Mem.read.0",[2],[Expr_Array(Expr_Var("_R"),2);2;0]);32]);64]))
diff --git a/cranelift/isle/veri/aslp/tests/data/ldrh_reg_reg.aslt b/cranelift/isle/veri/aslp/tests/data/ldrh_reg_reg.aslt
new file mode 100644
index 000000000000..378cdd47795a
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/ldrh_reg_reg.aslt
@@ -0,0 +1 @@
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),1),Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("ZeroExtend.0",[16;32],[Expr_TApply("Mem.read.0",[2],[Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),2);Expr_Array(Expr_Var("_R"),3)]);2;0]);32]);64]))
diff --git a/cranelift/isle/veri/aslp/tests/data/ldrh_reg_scale.aslt b/cranelift/isle/veri/aslp/tests/data/ldrh_reg_scale.aslt
new file mode 100644
index 000000000000..378cdd47795a
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/ldrh_reg_scale.aslt
@@ -0,0 +1 @@
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),1),Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("ZeroExtend.0",[16;32],[Expr_TApply("Mem.read.0",[2],[Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),2);Expr_Array(Expr_Var("_R"),3)]);2;0]);32]);64]))
diff --git a/cranelift/isle/veri/aslp/tests/data/ldrh_reg_scale1.aslt b/cranelift/isle/veri/aslp/tests/data/ldrh_reg_scale1.aslt
new file mode 100644
index 000000000000..951e3a8e4d55
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/ldrh_reg_scale1.aslt
@@ -0,0 +1 @@
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),1),Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("ZeroExtend.0",[16;32],[Expr_TApply("Mem.read.0",[2],[Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),2);Expr_TApply("append_bits.0",[63;1],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(0,63)]);'0'])]);2;0]);32]);64]))
diff --git a/cranelift/isle/veri/aslp/tests/data/ldrh_reg_scale_ext_sxtw.aslt b/cranelift/isle/veri/aslp/tests/data/ldrh_reg_scale_ext_sxtw.aslt
new file mode 100644
index 000000000000..fdcbc74744ca
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/ldrh_reg_scale_ext_sxtw.aslt
@@ -0,0 +1 @@
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),1),Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("ZeroExtend.0",[16;32],[Expr_TApply("Mem.read.0",[2],[Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),2);Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(0,32)]);64])]);2;0]);32]);64]))
diff --git a/cranelift/isle/veri/aslp/tests/data/ldrh_reg_scale_ext_sxtx.aslt b/cranelift/isle/veri/aslp/tests/data/ldrh_reg_scale_ext_sxtx.aslt
new file mode 100644
index 000000000000..60e1fb3dc348
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/ldrh_reg_scale_ext_sxtx.aslt
@@ -0,0 +1 @@
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),1),Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("ZeroExtend.0",[16;32],[Expr_TApply("Mem.read.0",[2],[Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),2);Expr_TApply("SignExtend.0",[64;64],[Expr_Array(Expr_Var("_R"),3);64])]);2;0]);32]);64]))
diff --git a/cranelift/isle/veri/aslp/tests/data/ldrh_reg_scale_ext_uxtw.aslt b/cranelift/isle/veri/aslp/tests/data/ldrh_reg_scale_ext_uxtw.aslt
new file mode 100644
index 000000000000..61fe3bdf96c8
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/ldrh_reg_scale_ext_uxtw.aslt
@@ -0,0 +1 @@
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),1),Expr_TApply("ZeroExtend.0",[32;64],[Expr_TApply("ZeroExtend.0",[16;32],[Expr_TApply("Mem.read.0",[2],[Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),2);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(0,32)]);64])]);2;0]);32]);64]))
diff --git a/cranelift/isle/veri/aslp/tests/data/ldrsw_reg_reg.aslt b/cranelift/isle/veri/aslp/tests/data/ldrsw_reg_reg.aslt
new file mode 100644
index 000000000000..a45921964412
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/ldrsw_reg_reg.aslt
@@ -0,0 +1 @@
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),1),Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("Mem.read.0",[4],[Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),2);Expr_Array(Expr_Var("_R"),3)]);4;0]);64]))
diff --git a/cranelift/isle/veri/aslp/tests/data/ldrsw_reg_scale.aslt b/cranelift/isle/veri/aslp/tests/data/ldrsw_reg_scale.aslt
new file mode 100644
index 000000000000..a45921964412
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/ldrsw_reg_scale.aslt
@@ -0,0 +1 @@
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),1),Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("Mem.read.0",[4],[Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),2);Expr_Array(Expr_Var("_R"),3)]);4;0]);64]))
diff --git a/cranelift/isle/veri/aslp/tests/data/ldrsw_reg_scale2.aslt b/cranelift/isle/veri/aslp/tests/data/ldrsw_reg_scale2.aslt
new file mode 100644
index 000000000000..000a5dc8fd61
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/ldrsw_reg_scale2.aslt
@@ -0,0 +1 @@
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),1),Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("Mem.read.0",[4],[Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),2);Expr_TApply("append_bits.0",[62;2],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(0,62)]);'00'])]);4;0]);64]))
diff --git a/cranelift/isle/veri/aslp/tests/data/ldrsw_reg_scale_ext_sxtw.aslt b/cranelift/isle/veri/aslp/tests/data/ldrsw_reg_scale_ext_sxtw.aslt
new file mode 100644
index 000000000000..819d476cfc46
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/ldrsw_reg_scale_ext_sxtw.aslt
@@ -0,0 +1 @@
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),1),Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("Mem.read.0",[4],[Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),2);Expr_TApply("SignExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(0,32)]);64])]);4;0]);64]))
diff --git a/cranelift/isle/veri/aslp/tests/data/ldrsw_reg_scale_ext_sxtx.aslt b/cranelift/isle/veri/aslp/tests/data/ldrsw_reg_scale_ext_sxtx.aslt
new file mode 100644
index 000000000000..5177f8418ab2
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/ldrsw_reg_scale_ext_sxtx.aslt
@@ -0,0 +1 @@
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),1),Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("Mem.read.0",[4],[Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),2);Expr_TApply("SignExtend.0",[64;64],[Expr_Array(Expr_Var("_R"),3);64])]);4;0]);64]))
diff --git a/cranelift/isle/veri/aslp/tests/data/ldrsw_reg_scale_ext_uxtw.aslt b/cranelift/isle/veri/aslp/tests/data/ldrsw_reg_scale_ext_uxtw.aslt
new file mode 100644
index 000000000000..a3ef5e0d1f53
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/ldrsw_reg_scale_ext_uxtw.aslt
@@ -0,0 +1 @@
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),1),Expr_TApply("SignExtend.0",[32;64],[Expr_TApply("Mem.read.0",[4],[Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),2);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),3),[Slice_LoWd(0,32)]);64])]);4;0]);64]))
diff --git a/cranelift/isle/veri/aslp/tests/data/mrs.aslt b/cranelift/isle/veri/aslp/tests/data/mrs.aslt
new file mode 100644
index 000000000000..2ad746f40ac2
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/mrs.aslt
@@ -0,0 +1 @@
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),0),Expr_TApply("append_bits.0",[36;28],[Expr_TApply("ZeroExtend.0",[4;36],[Expr_TApply("append_bits.0",[3;1],[Expr_TApply("append_bits.0",[2;1],[Expr_TApply("append_bits.0",[1;1],[Expr_Field(Expr_Var("PSTATE"),"N");Expr_Field(Expr_Var("PSTATE"),"Z")]);Expr_Field(Expr_Var("PSTATE"),"C")]);Expr_Field(Expr_Var("PSTATE"),"V")]);36]);'0000000000000000000000000000']))
diff --git a/cranelift/isle/veri/aslp/tests/data/sha1h.aslt b/cranelift/isle/veri/aslp/tests/data/sha1h.aslt
new file mode 100644
index 000000000000..f96ab7260799
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/sha1h.aslt
@@ -0,0 +1 @@
+Stmt_Assign(LExpr_Array(LExpr_Var("_Z"),17),Expr_TApply("ZeroExtend.0",[32;128],[Expr_TApply("append_bits.0",[2;30],[Expr_Slices(Expr_Array(Expr_Var("_Z"),6),[Slice_LoWd(0,2)]);Expr_Slices(Expr_Array(Expr_Var("_Z"),6),[Slice_LoWd(2,30)])]);128]))
diff --git a/cranelift/isle/veri/aslp/tests/data/sha1su0.aslt b/cranelift/isle/veri/aslp/tests/data/sha1su0.aslt
new file mode 100644
index 000000000000..9bdfbbe89a1a
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/sha1su0.aslt
@@ -0,0 +1 @@
+Stmt_Assign(LExpr_Array(LExpr_Var("_Z"),3),Expr_TApply("eor_bits.0",[128],[Expr_TApply("eor_bits.0",[128],[Expr_TApply("append_bits.0",[64;64],[Expr_Slices(Expr_Array(Expr_Var("_Z"),0),[Slice_LoWd(0,64)]);Expr_Slices(Expr_Array(Expr_Var("_Z"),3),[Slice_LoWd(64,64)])]);Expr_Array(Expr_Var("_Z"),3)]);Expr_Array(Expr_Var("_Z"),1)]))
diff --git a/cranelift/isle/veri/aslp/tests/data/sha1su1.aslt b/cranelift/isle/veri/aslp/tests/data/sha1su1.aslt
new file mode 100644
index 000000000000..c6668056b666
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/sha1su1.aslt
@@ -0,0 +1,2 @@
+Stmt_ConstDecl(Type_Bits(128),"Cse0__5",Expr_TApply("ZeroExtend.0",[96;128],[Expr_Slices(Expr_Array(Expr_Var("_Z"),1),[Slice_LoWd(32,96)]);128]))
+Stmt_Assign(LExpr_Array(LExpr_Var("_Z"),2),Expr_TApply("append_bits.0",[32;96],[Expr_TApply("eor_bits.0",[32],[Expr_TApply("append_bits.0",[31;1],[Expr_Slices(Expr_Slices(Expr_TApply("eor_bits.0",[128],[Expr_Array(Expr_Var("_Z"),2);Expr_Var("Cse0__5")]),[Slice_LoWd(0,127)]),[Slice_LoWd(96,31)]);Expr_Slices(Expr_TApply("eor_bits.0",[128],[Expr_Array(Expr_Var("_Z"),2);Expr_Var("Cse0__5")]),[Slice_LoWd(127,1)])]);Expr_TApply("append_bits.0",[30;2],[Expr_Slices(Expr_TApply("eor_bits.0",[128],[Expr_Array(Expr_Var("_Z"),2);Expr_Var("Cse0__5")]),[Slice_LoWd(0,30)]);Expr_Slices(Expr_Slices(Expr_TApply("eor_bits.0",[128],[Expr_Array(Expr_Var("_Z"),2);Expr_Var("Cse0__5")]),[Slice_LoWd(0,32)]),[Slice_LoWd(30,2)])])]);Expr_TApply("append_bits.0",[32;64],[Expr_TApply("append_bits.0",[31;1],[Expr_Slices(Expr_Slices(Expr_TApply("eor_bits.0",[128],[Expr_Array(Expr_Var("_Z"),2);Expr_Var("Cse0__5")]),[Slice_LoWd(0,95)]),[Slice_LoWd(64,31)]);Expr_Slices(Expr_Slices(Expr_TApply("eor_bits.0",[128],[Expr_Array(Expr_Var("_Z"),2);Expr_Var("Cse0__5")]),[Slice_LoWd(0,96)]),[Slice_LoWd(95,1)])]);Expr_TApply("append_bits.0",[32;32],[Expr_TApply("append_bits.0",[31;1],[Expr_Slices(Expr_Slices(Expr_TApply("eor_bits.0",[128],[Expr_Array(Expr_Var("_Z"),2);Expr_Var("Cse0__5")]),[Slice_LoWd(0,63)]),[Slice_LoWd(32,31)]);Expr_Slices(Expr_Slices(Expr_TApply("eor_bits.0",[128],[Expr_Array(Expr_Var("_Z"),2);Expr_Var("Cse0__5")]),[Slice_LoWd(0,64)]),[Slice_LoWd(63,1)])]);Expr_TApply("append_bits.0",[31;1],[Expr_Slices(Expr_TApply("eor_bits.0",[128],[Expr_Array(Expr_Var("_Z"),2);Expr_Var("Cse0__5")]),[Slice_LoWd(0,31)]);Expr_Slices(Expr_Slices(Expr_TApply("eor_bits.0",[128],[Expr_Array(Expr_Var("_Z"),2);Expr_Var("Cse0__5")]),[Slice_LoWd(0,32)]),[Slice_LoWd(31,1)])])])])]))
diff --git a/cranelift/isle/veri/aslp/tests/data/stp.aslt b/cranelift/isle/veri/aslp/tests/data/stp.aslt
new file mode 100644
index 000000000000..4951a9231acb
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/stp.aslt
@@ -0,0 +1,3 @@
+Stmt_TCall("Mem.set.0",[8],[Expr_Array(Expr_Var("_R"),3);8;0;Expr_Array(Expr_Var("_R"),1)])
+Stmt_TCall("Mem.set.0",[8],[Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),3);'0000000000000000000000000000000000000000000000000000000000001000']);8;0;Expr_Array(Expr_Var("_R"),2)])
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),3),Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),3);'0000000000000000000000000000000000000000000000000000000010000000']))
diff --git a/cranelift/isle/veri/aslp/tests/data/subs.aslt b/cranelift/isle/veri/aslp/tests/data/subs.aslt
new file mode 100644
index 000000000000..e95f85865a3d
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/subs.aslt
@@ -0,0 +1,7 @@
+Stmt_ConstDecl(Type_Bits(64),"Cse2__5",Expr_TApply("append_bits.0",[41;23],[Expr_Slices(Expr_Array(Expr_Var("_R"),12),[Slice_LoWd(0,41)]);'00000000000000000000000']))
+Stmt_ConstDecl(Type_Bits(64),"Cse0__5",Expr_TApply("add_bits.0",[64],[Expr_Array(Expr_Var("_R"),11);Expr_TApply("not_bits.0",[64],[Expr_TApply("append_bits.0",[41;23],[Expr_Slices(Expr_Array(Expr_Var("_R"),12),[Slice_LoWd(0,41)]);'00000000000000000000000'])])]))
+Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"V"),Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("SignExtend.0",[64;128],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("add_bits.0",[128],[Expr_TApply("SignExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),11);128]);Expr_TApply("SignExtend.0",[64;128],[Expr_TApply("not_bits.0",[64],[Expr_Var("Cse2__5")]);128])]);'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001'])])])]))
+Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"C"),Expr_TApply("not_bits.0",[1],[Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);128]);Expr_TApply("add_bits.0",[128],[Expr_TApply("add_bits.0",[128],[Expr_TApply("ZeroExtend.0",[64;128],[Expr_Array(Expr_Var("_R"),11);128]);Expr_TApply("ZeroExtend.0",[64;128],[Expr_TApply("not_bits.0",[64],[Expr_Var("Cse2__5")]);128])]);'00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001'])])])]))
+Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"Z"),Expr_TApply("cvt_bool_bv.0",[],[Expr_TApply("eq_bits.0",[64],[Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']);'0000000000000000000000000000000000000000000000000000000000000000'])]))
+Stmt_Assign(LExpr_Field(LExpr_Var("PSTATE"),"N"),Expr_Slices(Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']),[Slice_LoWd(63,1)]))
+Stmt_Assign(LExpr_Array(LExpr_Var("_R"),10),Expr_TApply("add_bits.0",[64],[Expr_Var("Cse0__5");'0000000000000000000000000000000000000000000000000000000000000001']))
diff --git a/cranelift/isle/veri/aslp/tests/data/subsp.aslt b/cranelift/isle/veri/aslp/tests/data/subsp.aslt
new file mode 100644
index 000000000000..90de7e729a9d
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/subsp.aslt
@@ -0,0 +1 @@
+Stmt_Assign(LExpr_Var("SP_EL0"),Expr_TApply("add_bits.0",[64],[Expr_Var("SP_EL0");'1111111111111111111111111111111111111111111111111111111111100000']))
diff --git a/cranelift/isle/veri/aslp/tests/data/tbl.aslt b/cranelift/isle/veri/aslp/tests/data/tbl.aslt
new file mode 100644
index 000000000000..0f8d27548a0c
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/tbl.aslt
@@ -0,0 +1,51 @@
+Stmt_ConstDecl(Type_Bits(16),"Cse15__5",Expr_TApply("ZeroExtend.0",[8;16],[Expr_Slices(Expr_Array(Expr_Var("_Z"),0),[Slice_LoWd(0,8)]);16]))
+Stmt_ConstDecl(Type_Bits(16),"Cse14__5",Expr_TApply("mul_bits.0",[16],[Expr_TApply("ZeroExtend.0",[8;16],[Expr_Slices(Expr_Array(Expr_Var("_Z"),0),[Slice_LoWd(0,8)]);16]);'0000000000001000']))
+Stmt_ConstDecl(Type_Bits(16),"Cse13__5",Expr_TApply("ZeroExtend.0",[8;16],[Expr_Slices(Expr_Array(Expr_Var("_Z"),0),[Slice_LoWd(8,8)]);16]))
+Stmt_ConstDecl(Type_Bits(16),"Cse12__5",Expr_TApply("mul_bits.0",[16],[Expr_TApply("ZeroExtend.0",[8;16],[Expr_Slices(Expr_Array(Expr_Var("_Z"),0),[Slice_LoWd(8,8)]);16]);'0000000000001000']))
+Stmt_ConstDecl(Type_Bits(16),"Cse11__5",Expr_TApply("ZeroExtend.0",[8;16],[Expr_Slices(Expr_Array(Expr_Var("_Z"),0),[Slice_LoWd(16,8)]);16]))
+Stmt_ConstDecl(Type_Bits(16),"Cse10__5",Expr_TApply("mul_bits.0",[16],[Expr_TApply("ZeroExtend.0",[8;16],[Expr_Slices(Expr_Array(Expr_Var("_Z"),0),[Slice_LoWd(16,8)]);16]);'0000000000001000']))
+Stmt_ConstDecl(Type_Bits(16),"Cse9__5",Expr_TApply("ZeroExtend.0",[8;16],[Expr_Slices(Expr_Array(Expr_Var("_Z"),0),[Slice_LoWd(24,8)]);16]))
+Stmt_ConstDecl(Type_Bits(16),"Cse8__5",Expr_TApply("mul_bits.0",[16],[Expr_TApply("ZeroExtend.0",[8;16],[Expr_Slices(Expr_Array(Expr_Var("_Z"),0),[Slice_LoWd(24,8)]);16]);'0000000000001000']))
+Stmt_ConstDecl(Type_Bits(16),"Cse7__5",Expr_TApply("ZeroExtend.0",[8;16],[Expr_Slices(Expr_Array(Expr_Var("_Z"),0),[Slice_LoWd(32,8)]);16]))
+Stmt_ConstDecl(Type_Bits(16),"Cse6__5",Expr_TApply("mul_bits.0",[16],[Expr_TApply("ZeroExtend.0",[8;16],[Expr_Slices(Expr_Array(Expr_Var("_Z"),0),[Slice_LoWd(32,8)]);16]);'0000000000001000']))
+Stmt_ConstDecl(Type_Bits(16),"Cse5__5",Expr_TApply("ZeroExtend.0",[8;16],[Expr_Slices(Expr_Array(Expr_Var("_Z"),0),[Slice_LoWd(40,8)]);16]))
+Stmt_ConstDecl(Type_Bits(16),"Cse4__5",Expr_TApply("mul_bits.0",[16],[Expr_TApply("ZeroExtend.0",[8;16],[Expr_Slices(Expr_Array(Expr_Var("_Z"),0),[Slice_LoWd(40,8)]);16]);'0000000000001000']))
+Stmt_ConstDecl(Type_Bits(16),"Cse3__5",Expr_TApply("ZeroExtend.0",[8;16],[Expr_Slices(Expr_Array(Expr_Var("_Z"),0),[Slice_LoWd(48,8)]);16]))
+Stmt_ConstDecl(Type_Bits(16),"Cse2__5",Expr_TApply("mul_bits.0",[16],[Expr_TApply("ZeroExtend.0",[8;16],[Expr_Slices(Expr_Array(Expr_Var("_Z"),0),[Slice_LoWd(48,8)]);16]);'0000000000001000']))
+Stmt_ConstDecl(Type_Bits(16),"Cse1__5",Expr_TApply("ZeroExtend.0",[8;16],[Expr_Slices(Expr_Array(Expr_Var("_Z"),0),[Slice_LoWd(56,8)]);16]))
+Stmt_ConstDecl(Type_Bits(16),"Cse0__5",Expr_TApply("mul_bits.0",[16],[Expr_TApply("ZeroExtend.0",[8;16],[Expr_Slices(Expr_Array(Expr_Var("_Z"),0),[Slice_LoWd(56,8)]);16]);'0000000000001000']))
+Stmt_VarDeclsNoInit(Type_Bits(64),["result__4"])
+Stmt_Assign(LExpr_Var("result__4"),'0000000000000000000000000000000000000000000000000000000000000000')
+Stmt_If(Expr_TApply("slt_bits.0",[16],[Expr_Var("Cse15__5");'0000000000010000']),[
+Stmt_Assert(Expr_TApply("and_bool.0",[],[Expr_Var("TRUE");Expr_TApply("sle_bits.0",[32],[Expr_TApply("ZeroExtend.0",[16;32],[Expr_TApply("add_bits.0",[16],[Expr_Var("Cse14__5");'0000000000001000']);32]);'00000000000000000000000010000000'])]));
+Stmt_Assign(LExpr_Var("result__4"),Expr_TApply("ZeroExtend.0",[8;64],[Expr_Slices(Expr_TApply("lsr_bits.0",[128;32],[Expr_Array(Expr_Var("_Z"),0);Expr_TApply("ZeroExtend.0",[16;32],[Expr_Var("Cse14__5");32])]),[Slice_LoWd(0,8)]);64]))
+],[],[])
+Stmt_If(Expr_TApply("slt_bits.0",[16],[Expr_Var("Cse13__5");'0000000000010000']),[
+Stmt_Assert(Expr_TApply("and_bool.0",[],[Expr_Var("TRUE");Expr_TApply("sle_bits.0",[32],[Expr_TApply("ZeroExtend.0",[16;32],[Expr_TApply("add_bits.0",[16],[Expr_Var("Cse12__5");'0000000000001000']);32]);'00000000000000000000000010000000'])]));
+Stmt_Assign(LExpr_Var("result__4"),Expr_TApply("append_bits.0",[48;16],[Expr_Slices(Expr_Var("result__4"),[Slice_LoWd(16,48)]);Expr_TApply("append_bits.0",[8;8],[Expr_Slices(Expr_TApply("lsr_bits.0",[128;32],[Expr_Array(Expr_Var("_Z"),0);Expr_TApply("ZeroExtend.0",[16;32],[Expr_Var("Cse12__5");32])]),[Slice_LoWd(0,8)]);Expr_Slices(Expr_Var("result__4"),[Slice_LoWd(0,8)])])]))
+],[],[])
+Stmt_If(Expr_TApply("slt_bits.0",[16],[Expr_Var("Cse11__5");'0000000000010000']),[
+Stmt_Assert(Expr_TApply("and_bool.0",[],[Expr_Var("TRUE");Expr_TApply("sle_bits.0",[32],[Expr_TApply("ZeroExtend.0",[16;32],[Expr_TApply("add_bits.0",[16],[Expr_Var("Cse10__5");'0000000000001000']);32]);'00000000000000000000000010000000'])]));
+Stmt_Assign(LExpr_Var("result__4"),Expr_TApply("append_bits.0",[40;24],[Expr_Slices(Expr_Var("result__4"),[Slice_LoWd(24,40)]);Expr_TApply("append_bits.0",[8;16],[Expr_Slices(Expr_TApply("lsr_bits.0",[128;32],[Expr_Array(Expr_Var("_Z"),0);Expr_TApply("ZeroExtend.0",[16;32],[Expr_Var("Cse10__5");32])]),[Slice_LoWd(0,8)]);Expr_Slices(Expr_Var("result__4"),[Slice_LoWd(0,16)])])]))
+],[],[])
+Stmt_If(Expr_TApply("slt_bits.0",[16],[Expr_Var("Cse9__5");'0000000000010000']),[
+Stmt_Assert(Expr_TApply("and_bool.0",[],[Expr_Var("TRUE");Expr_TApply("sle_bits.0",[32],[Expr_TApply("ZeroExtend.0",[16;32],[Expr_TApply("add_bits.0",[16],[Expr_Var("Cse8__5");'0000000000001000']);32]);'00000000000000000000000010000000'])]));
+Stmt_Assign(LExpr_Var("result__4"),Expr_TApply("append_bits.0",[32;32],[Expr_Slices(Expr_Var("result__4"),[Slice_LoWd(32,32)]);Expr_TApply("append_bits.0",[8;24],[Expr_Slices(Expr_TApply("lsr_bits.0",[128;32],[Expr_Array(Expr_Var("_Z"),0);Expr_TApply("ZeroExtend.0",[16;32],[Expr_Var("Cse8__5");32])]),[Slice_LoWd(0,8)]);Expr_Slices(Expr_Var("result__4"),[Slice_LoWd(0,24)])])]))
+],[],[])
+Stmt_If(Expr_TApply("slt_bits.0",[16],[Expr_Var("Cse7__5");'0000000000010000']),[
+Stmt_Assert(Expr_TApply("and_bool.0",[],[Expr_Var("TRUE");Expr_TApply("sle_bits.0",[32],[Expr_TApply("ZeroExtend.0",[16;32],[Expr_TApply("add_bits.0",[16],[Expr_Var("Cse6__5");'0000000000001000']);32]);'00000000000000000000000010000000'])]));
+Stmt_Assign(LExpr_Var("result__4"),Expr_TApply("append_bits.0",[24;40],[Expr_Slices(Expr_Var("result__4"),[Slice_LoWd(40,24)]);Expr_TApply("append_bits.0",[8;32],[Expr_Slices(Expr_TApply("lsr_bits.0",[128;32],[Expr_Array(Expr_Var("_Z"),0);Expr_TApply("ZeroExtend.0",[16;32],[Expr_Var("Cse6__5");32])]),[Slice_LoWd(0,8)]);Expr_Slices(Expr_Var("result__4"),[Slice_LoWd(0,32)])])]))
+],[],[])
+Stmt_If(Expr_TApply("slt_bits.0",[16],[Expr_Var("Cse5__5");'0000000000010000']),[
+Stmt_Assert(Expr_TApply("and_bool.0",[],[Expr_Var("TRUE");Expr_TApply("sle_bits.0",[32],[Expr_TApply("ZeroExtend.0",[16;32],[Expr_TApply("add_bits.0",[16],[Expr_Var("Cse4__5");'0000000000001000']);32]);'00000000000000000000000010000000'])]));
+Stmt_Assign(LExpr_Var("result__4"),Expr_TApply("append_bits.0",[16;48],[Expr_Slices(Expr_Var("result__4"),[Slice_LoWd(48,16)]);Expr_TApply("append_bits.0",[8;40],[Expr_Slices(Expr_TApply("lsr_bits.0",[128;32],[Expr_Array(Expr_Var("_Z"),0);Expr_TApply("ZeroExtend.0",[16;32],[Expr_Var("Cse4__5");32])]),[Slice_LoWd(0,8)]);Expr_Slices(Expr_Var("result__4"),[Slice_LoWd(0,40)])])]))
+],[],[])
+Stmt_If(Expr_TApply("slt_bits.0",[16],[Expr_Var("Cse3__5");'0000000000010000']),[
+Stmt_Assert(Expr_TApply("and_bool.0",[],[Expr_Var("TRUE");Expr_TApply("sle_bits.0",[32],[Expr_TApply("ZeroExtend.0",[16;32],[Expr_TApply("add_bits.0",[16],[Expr_Var("Cse2__5");'0000000000001000']);32]);'00000000000000000000000010000000'])]));
+Stmt_Assign(LExpr_Var("result__4"),Expr_TApply("append_bits.0",[8;56],[Expr_Slices(Expr_Var("result__4"),[Slice_LoWd(56,8)]);Expr_TApply("append_bits.0",[8;48],[Expr_Slices(Expr_TApply("lsr_bits.0",[128;32],[Expr_Array(Expr_Var("_Z"),0);Expr_TApply("ZeroExtend.0",[16;32],[Expr_Var("Cse2__5");32])]),[Slice_LoWd(0,8)]);Expr_Slices(Expr_Var("result__4"),[Slice_LoWd(0,48)])])]))
+],[],[])
+Stmt_If(Expr_TApply("slt_bits.0",[16],[Expr_Var("Cse1__5");'0000000000010000']),[
+Stmt_Assert(Expr_TApply("and_bool.0",[],[Expr_Var("TRUE");Expr_TApply("sle_bits.0",[32],[Expr_TApply("ZeroExtend.0",[16;32],[Expr_TApply("add_bits.0",[16],[Expr_Var("Cse0__5");'0000000000001000']);32]);'00000000000000000000000010000000'])]));
+Stmt_Assign(LExpr_Var("result__4"),Expr_TApply("append_bits.0",[8;56],[Expr_Slices(Expr_TApply("lsr_bits.0",[128;32],[Expr_Array(Expr_Var("_Z"),0);Expr_TApply("ZeroExtend.0",[16;32],[Expr_Var("Cse0__5");32])]),[Slice_LoWd(0,8)]);Expr_Slices(Expr_Var("result__4"),[Slice_LoWd(0,56)])]))
+],[],[])
+Stmt_Assign(LExpr_Array(LExpr_Var("_Z"),0),Expr_TApply("ZeroExtend.0",[64;128],[Expr_Var("result__4");128]))
diff --git a/cranelift/isle/veri/aslp/tests/data/ucvtf.aslt b/cranelift/isle/veri/aslp/tests/data/ucvtf.aslt
new file mode 100644
index 000000000000..bb89eb8faa8c
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/ucvtf.aslt
@@ -0,0 +1,4 @@
+Stmt_VarDeclsNoInit(Type_Bits(4),["FPDecodeRounding5__5"])
+Stmt_Assign(LExpr_Var("FPDecodeRounding5__5"),Expr_TApply("ZeroExtend.0",[2;4],[Expr_Slices(Expr_Var("FPCR"),[Slice_LoWd(22,2)]);4]))
+Stmt_ConstDecl(Type_Bits(64),"Exp9__5",Expr_TApply("FixedToFP.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_R"),2),[Slice_LoWd(0,32)]);0;Expr_Var("TRUE");Expr_Var("FPCR");Expr_TApply("cvt_bits_uint.0",[4],[Expr_Var("FPDecodeRounding5__5")])]))
+Stmt_Assign(LExpr_Array(LExpr_Var("_Z"),0),Expr_TApply("ZeroExtend.0",[64;128],[Expr_Var("Exp9__5");128]))
diff --git a/cranelift/isle/veri/aslp/tests/data/uqsub.aslt b/cranelift/isle/veri/aslp/tests/data/uqsub.aslt
new file mode 100644
index 000000000000..1a12a3cccc6c
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/data/uqsub.aslt
@@ -0,0 +1,49 @@
+Stmt_VarDeclsNoInit(Type_Bits(32),["UnsignedSatQ18__6"])
+Stmt_VarDeclsNoInit(Type_Constructor("boolean"),["UnsignedSatQ19__6"])
+Stmt_If(Expr_TApply("slt_bits.0",[64],[Expr_TApply("sub_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_Z"),1),[Slice_LoWd(0,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_Z"),2),[Slice_LoWd(0,32)]);64])]);'0000000000000000000000000000000000000000000000000000000000000000']),[
+Stmt_Assign(LExpr_Var("UnsignedSatQ18__6"),'00000000000000000000000000000000');
+Stmt_Assign(LExpr_Var("UnsignedSatQ19__6"),Expr_Var("TRUE"))
+],[],[
+Stmt_Assign(LExpr_Var("UnsignedSatQ18__6"),Expr_TApply("sub_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_Z"),1),[Slice_LoWd(0,32)]);Expr_Slices(Expr_Array(Expr_Var("_Z"),2),[Slice_LoWd(0,32)])]));
+Stmt_Assign(LExpr_Var("UnsignedSatQ19__6"),Expr_Var("FALSE"))
+])
+Stmt_If(Expr_Var("UnsignedSatQ19__6"),[
+Stmt_Assign(LExpr_Var("FPSR"),Expr_TApply("append_bits.0",[4;28],[Expr_Slices(Expr_Var("FPSR"),[Slice_LoWd(28,4)]);Expr_TApply("append_bits.0",[1;27],['1';Expr_Slices(Expr_Var("FPSR"),[Slice_LoWd(0,27)])])]))
+],[],[])
+Stmt_VarDeclsNoInit(Type_Bits(32),["UnsignedSatQ35__6"])
+Stmt_VarDeclsNoInit(Type_Constructor("boolean"),["UnsignedSatQ36__6"])
+Stmt_If(Expr_TApply("slt_bits.0",[64],[Expr_TApply("sub_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_Z"),1),[Slice_LoWd(32,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_Z"),2),[Slice_LoWd(32,32)]);64])]);'0000000000000000000000000000000000000000000000000000000000000000']),[
+Stmt_Assign(LExpr_Var("UnsignedSatQ35__6"),'00000000000000000000000000000000');
+Stmt_Assign(LExpr_Var("UnsignedSatQ36__6"),Expr_Var("TRUE"))
+],[],[
+Stmt_Assign(LExpr_Var("UnsignedSatQ35__6"),Expr_TApply("sub_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_Z"),1),[Slice_LoWd(32,32)]);Expr_Slices(Expr_Array(Expr_Var("_Z"),2),[Slice_LoWd(32,32)])]));
+Stmt_Assign(LExpr_Var("UnsignedSatQ36__6"),Expr_Var("FALSE"))
+])
+Stmt_If(Expr_Var("UnsignedSatQ36__6"),[
+Stmt_Assign(LExpr_Var("FPSR"),Expr_TApply("append_bits.0",[4;28],[Expr_Slices(Expr_Var("FPSR"),[Slice_LoWd(28,4)]);Expr_TApply("append_bits.0",[1;27],['1';Expr_Slices(Expr_Var("FPSR"),[Slice_LoWd(0,27)])])]))
+],[],[])
+Stmt_VarDeclsNoInit(Type_Bits(32),["UnsignedSatQ51__6"])
+Stmt_VarDeclsNoInit(Type_Constructor("boolean"),["UnsignedSatQ52__6"])
+Stmt_If(Expr_TApply("slt_bits.0",[64],[Expr_TApply("sub_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_Z"),1),[Slice_LoWd(64,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_Z"),2),[Slice_LoWd(64,32)]);64])]);'0000000000000000000000000000000000000000000000000000000000000000']),[
+Stmt_Assign(LExpr_Var("UnsignedSatQ51__6"),'00000000000000000000000000000000');
+Stmt_Assign(LExpr_Var("UnsignedSatQ52__6"),Expr_Var("TRUE"))
+],[],[
+Stmt_Assign(LExpr_Var("UnsignedSatQ51__6"),Expr_TApply("sub_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_Z"),1),[Slice_LoWd(64,32)]);Expr_Slices(Expr_Array(Expr_Var("_Z"),2),[Slice_LoWd(64,32)])]));
+Stmt_Assign(LExpr_Var("UnsignedSatQ52__6"),Expr_Var("FALSE"))
+])
+Stmt_If(Expr_Var("UnsignedSatQ52__6"),[
+Stmt_Assign(LExpr_Var("FPSR"),Expr_TApply("append_bits.0",[4;28],[Expr_Slices(Expr_Var("FPSR"),[Slice_LoWd(28,4)]);Expr_TApply("append_bits.0",[1;27],['1';Expr_Slices(Expr_Var("FPSR"),[Slice_LoWd(0,27)])])]))
+],[],[])
+Stmt_VarDeclsNoInit(Type_Bits(32),["UnsignedSatQ67__6"])
+Stmt_VarDeclsNoInit(Type_Constructor("boolean"),["UnsignedSatQ68__6"])
+Stmt_If(Expr_TApply("slt_bits.0",[64],[Expr_TApply("sub_bits.0",[64],[Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_Z"),1),[Slice_LoWd(96,32)]);64]);Expr_TApply("ZeroExtend.0",[32;64],[Expr_Slices(Expr_Array(Expr_Var("_Z"),2),[Slice_LoWd(96,32)]);64])]);'0000000000000000000000000000000000000000000000000000000000000000']),[
+Stmt_Assign(LExpr_Var("UnsignedSatQ67__6"),'00000000000000000000000000000000');
+Stmt_Assign(LExpr_Var("UnsignedSatQ68__6"),Expr_Var("TRUE"))
+],[],[
+Stmt_Assign(LExpr_Var("UnsignedSatQ67__6"),Expr_TApply("sub_bits.0",[32],[Expr_Slices(Expr_Array(Expr_Var("_Z"),1),[Slice_LoWd(96,32)]);Expr_Slices(Expr_Array(Expr_Var("_Z"),2),[Slice_LoWd(96,32)])]));
+Stmt_Assign(LExpr_Var("UnsignedSatQ68__6"),Expr_Var("FALSE"))
+])
+Stmt_If(Expr_Var("UnsignedSatQ68__6"),[
+Stmt_Assign(LExpr_Var("FPSR"),Expr_TApply("append_bits.0",[4;28],[Expr_Slices(Expr_Var("FPSR"),[Slice_LoWd(28,4)]);Expr_TApply("append_bits.0",[1;27],['1';Expr_Slices(Expr_Var("FPSR"),[Slice_LoWd(0,27)])])]))
+],[],[])
+Stmt_Assign(LExpr_Array(LExpr_Var("_Z"),3),Expr_TApply("append_bits.0",[32;96],[Expr_Var("UnsignedSatQ67__6");Expr_TApply("append_bits.0",[32;64],[Expr_Var("UnsignedSatQ51__6");Expr_TApply("append_bits.0",[32;32],[Expr_Var("UnsignedSatQ35__6");Expr_Var("UnsignedSatQ18__6")])])]))
diff --git a/cranelift/isle/veri/aslp/tests/parse.rs b/cranelift/isle/veri/aslp/tests/parse.rs
new file mode 100644
index 000000000000..ee7a02125f03
--- /dev/null
+++ b/cranelift/isle/veri/aslp/tests/parse.rs
@@ -0,0 +1,9 @@
+use std::fs;
+
+use cranelift_isle_veri_test_macros::file_tests;
+
+#[file_tests(path = "tests/data", ext = "aslt")]
+fn parse(test_file: &str) {
+    let src = fs::read_to_string(test_file).unwrap();
+    cranelift_isle_veri_aslp::parser::parse(&src).unwrap();
+}
diff --git a/cranelift/isle/veri/docs/language.md b/cranelift/isle/veri/docs/language.md
new file mode 100644
index 000000000000..0b7d15aca3c3
--- /dev/null
+++ b/cranelift/isle/veri/docs/language.md
@@ -0,0 +1,391 @@
+# Specification Language
+
+Description of specification language.
+
+## Types
+
+ISLE types have a corresponding _model_ in the verification domain:
+
+```
+(model <isle_type> (type <type>))
+```
+
+Verification types `<type>` may be primitives, named, or compound types.
+
+_Primitives_:
+
+* Integer: `Int`
+* Boolean: `Bool`
+* Bit-vector: unknown width `(bv)`, fixed width `(bv <n>)`
+* Unit: `Unit`
+* Unspecified: `!`
+* Auto: `_`, a primitive type to be deduced by type inference
+
+> [!NOTE]
+> The unspecified type exists to allow placeholder type specifications when a
+> type must be specified to proceed, but it is irrelevant to the problem at hand.
+> For example, an enum type may bring into scope variants with new types that are
+> not important but need some specification.
+
+_Named_ type references resolve to the same verification domain type model as
+`<isle_type>`:
+
+```
+(named <isle_type>)
+```
+
+_Structs_ are purely structurally typed:
+
+```
+(struct
+    (<field1> <type1>)
+    (<field2> <type2>)
+    ...
+)
+```
+
+_Enum_ types exist in the verification domain but may only be inferred from
+corresponding ISLE enum types. Custom enum types cannot be declared by users,
+though it is allowed to override the inferred enum type for an ISLE enum with a
+custom non-enum model.
+
+## Specifications
+
+Term specifications take the form:
+
+```
+(spec (<term> <params...>)
+    (modifies <state> <cond>?)
+    (provide <expr...>)
+    (require <expr...>)
+    (match <expr...>)
+)
+```
+
+All `<expr...>` lists in the specification must be boolean and for each clause
+multiple expressions are wrapped in an implicit `(and <exprs...>)`.
+
+`(modifies <state> <cond>?)`:
+concerns state modification, discussed in the "State" section below.
+
+`(provide <expr...>)`:
+post-conditions for the term. Post-conditions are assumed when the term appears
+as a callee, and asserted when as a caller (root of rule expansion).
+
+`(require <expr...>)`:
+pre-conditions for the term. Pre-conditions are asserted when the term appears
+as a callee, and assumed when as a caller (root of rule expansion).
+
+`(match <expr...>)`:
+may only be present on specs for _partial_ terms: non-infallible extractors or
+partial constructors.  Partial terms may be thought of as implicitly returning
+an `Option` type, and the match clause specifies the conditions under which the
+return is `Some(..)`. In this case, the provide specification is conditioned on
+the match specification holding.
+
+Variables accessible to spec expressions depend on the term type and the clause.
+For a term with parameters `(<term> <params...>)` and implicit result in special
+`result` variable:
+
+* Constructor: inputs are `[<params...>]`, outputs are `[result]`
+* Extractor: inputs are `[result]`, inputs are `[<params...>]`
+
+Variables in scope:
+
+* Term inputs are available to all clauses.
+* Term outputs are only available to the `provide` clause.
+* State variables are global and available to all clauses.
+* Modifies condition variables are available to all clauses.
+
+### Expressions
+
+Specification expressions may be:
+
+**Constants:**
+integer `<decimal>`, bitvector `#b<binary>` or `#x<hex>`, and booleans
+`true`/`false`.
+
+**Variables:**
+plain identifiers refer to in-scope variables. Variables may refer to: term
+parameters, the implicit `result` of a term, let or with bindings, macro
+arguments, declared state, and state modification path conditions.
+
+**Operators:**
+operator applications of the form `(<op> <args...>)`. Available operators are
+listed in the next section.
+
+**Let bindings:**
+let bindings introduce new variables with expression initializers, and evaluate
+to a body expression that may reference the new variables brought into scope.
+```
+(let
+    (
+        (<v1> <init1>)
+        (<v2> <init2>)
+        ...
+    )
+    <body>
+)
+```
+Let bindings may not shadow variables in the outer scope.
+
+**With bindings:**
+`with` expressions evaluate an expression with new _uninitialized_ variables
+brought into scope.
+```
+(with (<v1> <v2> ...)
+    <body>
+)
+```
+
+**Field Access:**
+the expression `(:<field> <x>)` accesses field `<field>` of the struct-valued expression `<x>`.
+
+**Discriminator:**
+expression `(?<variant> <x>)` evaluates to true if the enum-valued expression
+`<x>` has the given variant.
+
+**Variant Constructor:**
+`(<enum>.<variant> <fields...>)` constructs an enum value with the given variant
+and (optional) fields.
+
+**Struct Constructor:**
+`(struct (<field> <value>) ...)` constructs a struct value with the given fields.
+
+**Match:**
+the match operator pattern matches on enum types.
+
+```
+(match <on>
+    ((<enum1>.<variant1> <fields1...>) <body1>)
+    ((<enum2>.<variant2> <fields2...>) <body2>)
+    ...
+)
+```
+
+The value of the expression is the body of the arm that matches `<on>`,
+evaluated with the fields brought into scope. If no arm matches the value is
+undefined.
+
+> [!WARNING]
+> Under the hood `match` and `switch` are treated differently. Match is a
+> top-level expression type, while `switch` is an operator. This makes no sense
+> and should be fixed. It makes no difference to the user, however.
+
+**Macro Expansion:**
+`(<macro>! <args...>)` evaluates macro `<macro>` with the given arguments.
+
+**Qualified Expressions:**
+`(as <x> <ty>)` evaluates to `<x>` and provides a type inference annotation that
+`<x>` must have type `<ty>`.
+
+### Operators
+
+Spec expression operators:
+
+```
+    // Boolean operations
+    Eq,
+    And,
+    Or,
+    Not,
+    Imp,
+
+    // Integer comparisons
+    Lt,
+    Lte,
+    Gt,
+    Gte,
+
+    // Bitwise bitvector operations (directly SMT-LIB)
+    BVNot,
+    BVAnd,
+    BVOr,
+    BVXor,
+
+    // Bitvector arithmetic operations  (directly SMT-LIB)
+    BVNeg,
+    BVAdd,
+    BVSub,
+    BVMul,
+    BVUdiv,
+    BVUrem,
+    BVSdiv,
+    BVSrem,
+    BVShl,
+    BVLshr,
+    BVAshr,
+
+    // Bitvector comparison operations  (directly SMT-LIB)
+    BVUle,
+    BVUlt,
+    BVUgt,
+    BVUge,
+    BVSlt,
+    BVSle,
+    BVSgt,
+    BVSge,
+
+    // Bitvector overflow checks (SMT-LIB pending standardization)
+    BVSaddo,
+
+    // Desugared bitvector arithmetic operations
+    Rotr,
+    Rotl,
+    Extract,
+    ZeroExt,
+    SignExt,
+    Concat,
+
+    // Floating point (IEEE 754-2008)
+    FPPositiveInfinity,
+    FPNegativeInfinity,
+    FPPositiveZero,
+    FPNegativeZero,
+    FPNaN,
+    FPAdd,
+    FPSub,
+    FPMul,
+    FPDiv,
+    FPMin,
+    FPMax,
+    FPNeg,
+    FPSqrt,
+    FPIsZero,
+    FPIsInfinite,
+    FPIsNaN,
+    FPIsNegative,
+    FPIsPositive,
+
+    // Custom encodings
+    Popcnt,
+    Clz,
+    Cls,
+    Rev,
+
+    // Conversion operations
+    ConvTo,
+    Int2BV,
+    BV2Nat,
+    WidthOf,
+
+    // Control operations
+    If,
+    Switch,
+```
+
+### Macros
+
+Spec macros may be declared:
+
+```
+(macro (<name> <params...>) <body>)
+```
+
+Macro expansions are of the form `(<name>! <args...>)`. The body of the macro is
+evaluated in a scope with paramters set to argument values, and the result
+substituted for the expansion expression.
+
+## Type Instantiation
+
+Possible type signatures for a term may be enumerated with `instantiate`:
+
+```
+(instantiate <term> <sigs...>)
+```
+
+where term signatures are of the form:
+
+```
+((args <types...>) (ret <type>))
+```
+
+Since some type instantiations are common, sets of signatures may be declared as `form`s:
+
+```
+(form <name> <sigs...>)
+```
+
+and then referenced as short-hand in an `instantiate` declaration:
+
+```
+(instantiate <term> <form>)
+```
+
+In verification, the cartesian product of all type instantantiations for all
+present terms is considered. Many of the combinations will be ruled out by type
+inference before proceeding to verification.
+
+## State
+
+State variables are declared with a type and default specification:
+
+```
+(state <name>
+    (type <type>)
+    (default <default>)
+)
+```
+
+The `<type>` is a verification domain type as discussed above. The default spec
+is an expression that must have boolean value. It is evaluated in a scope with
+the state variable bound to variable `<name>`.
+
+State variables are accessible as global variables from specs. The `modifies`
+clause on specs determines the conditions under which the default spec is
+applied:
+
+`(modifies <state>)`:
+declare that a spec unconditionally modifies the state variable `<state>`. The
+default spec for `<state>` is disabled.
+
+`(modifies <state> <cond>)`:
+conditionally modify `<state>` with conditional variable `<cond>`.  In this
+case, the corresponding spec must provide constraints that define when `<cond>`
+holds, and implied constraints on `<state>` if it does.  The default spec for
+`<state>` will only apply if `<cond>` is false. Unconditional state modification
+is equivalent to conditional state modification with an assertion that `<cond>`
+is always true.
+
+In verification, all the conditional variables for a given state are collected `<cond1>`, `<cond2>` and the default spec is conditionally assumed:
+
+```
+(=> (not (or <cond1> <cond2> ...)) <default>)
+```
+
+## Attributes
+
+Attributes may be applied to terms and rules:
+
+```
+(attr rule? <name> <kind>)
+```
+
+Without the `rule` keyword, it is assumed to be a term attribute.
+
+Attribute kinds:
+
+`(attr <term> (veri chain))`:
+In verification, apply rule chaining to this term.  A term marked for chaining
+may omit a specification. Instead, all possible applications of rules to this
+term will be generated and verified.
+
+`(attr rule <rule> (veri priority))`:
+In verification, declare that the correctness of lower priority rules depends on
+this rule not matching.
+
+During rule expansion, any higher-priority overlapping rules that have the
+priority tag will have their match conditions negated and added to the
+verification conditions.
+
+Note that care must be taken when using this tag: if the specification for the
+match conditions of the higher priority rule are an over-approximation of
+reality, then the assumptions made by lower priority rules will be an
+under-approximation. In an extreme case this may cause the verifier to determine
+the lower priority rule never applies. In a more subtle case, it could cause
+bugs to be missed.
+
+`(attr rule? <name> (tag <tag>))`:
+Tag attributes allow for categorizing terms and rules. They have no semantic
+meaning but are useful for filtering verification in the command-line and
+presenting aggregate verification status.
diff --git a/cranelift/isle/veri/isaspec/Cargo.toml b/cranelift/isle/veri/isaspec/Cargo.toml
new file mode 100644
index 000000000000..54c9b506bdd2
--- /dev/null
+++ b/cranelift/isle/veri/isaspec/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "cranelift-isle-veri-isaspec"
+version = "0.1.0"
+publish = false
+edition.workspace = true
+
+[dependencies]
+cranelift-isle-veri-aslp = { path = "../aslp" }
+cranelift-isle = { path = "../../isle", features = ["printer"] }
+cranelift-codegen = { workspace = true, features = ["all-arch"] }
+reqwest = { workspace = true }
+anyhow = { workspace = true, features = ['std', 'backtrace'] }
+clap = { workspace = true, features = ['default'] }
+tracing = { workspace = true }
+tracing-subscriber = { workspace = true }
+itertools = "0.12.0"
diff --git a/cranelift/isle/veri/isaspec/script/generate.sh b/cranelift/isle/veri/isaspec/script/generate.sh
new file mode 100755
index 000000000000..5740482e2256
--- /dev/null
+++ b/cranelift/isle/veri/isaspec/script/generate.sh
@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+
+set -exuo pipefail
+
+# Options
+function usage() {
+    echo "Usage: ${0} [-h] [-l] [-a <aslp_server_host>] [-p <aslp_server_port>] [-o <output_path>]"
+    exit 2
+}
+
+launch_server="false"
+aslp_server_host="${ASLP_SERVER_HOST:-127.0.0.1}"
+aslp_server_port="${ASLP_SERVER_PORT:-4207}"
+output_path="../../../codegen/src/isa/aarch64/spec/"
+while getopts "la:p:o:h" opt; do
+    case "${opt}" in
+        l) launch_server="true" ;;
+        a) aslp_server_host="${OPTARG}" ;;
+        p) aslp_server_port="${OPTARG}" ;;
+        o) output_path="${OPTARG}" ;;
+        h) usage ;;
+        *) usage ;;
+    esac
+done
+
+# Floating-point constant specs.
+cargo run --bin fpconst > "${output_path}/fp_const.isle"
+
+# Launch server
+if [[ "${launch_server}" == "true" ]]; then
+    aslp-server --host "${aslp_server_host}" --port "${aslp_server_port}" &
+    aslp_server_pid=$!
+    trap 'kill "${aslp_server_pid}"' EXIT
+fi
+
+# Generate
+aslp_server_url="http://${aslp_server_host}:${aslp_server_port}"
+cargo run --bin isaspec \
+    -- \
+    --server "${aslp_server_url}" \
+    --output "${output_path}"
diff --git a/cranelift/isle/veri/isaspec/src/aarch64.rs b/cranelift/isle/veri/isaspec/src/aarch64.rs
new file mode 100644
index 000000000000..09df9f00ecb1
--- /dev/null
+++ b/cranelift/isle/veri/isaspec/src/aarch64.rs
@@ -0,0 +1,112 @@
+use cranelift_codegen::{
+    isa::aarch64::inst::{
+        emit::{EmitInfo, EmitState},
+        Inst,
+    },
+    settings, MachBuffer, MachInstEmit,
+};
+
+use crate::{
+    constraints::{Scope, Target},
+    memory::{ReadEffect, SetEffect},
+};
+
+pub fn gpreg(i: usize) -> Target {
+    let r = Target::Var("_R".to_string());
+    Target::Index(Box::new(r), i)
+}
+
+pub fn vreg(i: usize) -> Target {
+    let z = Target::Var("_Z".to_string());
+    Target::Index(Box::new(z), i)
+}
+
+pub fn literal(s: &str) -> Target {
+    Target::Var(s.to_string())
+}
+
+pub fn pstate() -> Target {
+    Target::Var("PSTATE".to_string())
+}
+
+pub fn pstate_field(name: &str) -> Target {
+    Target::Field(Box::new(pstate()), name.to_string())
+}
+
+pub fn fpcr() -> Target {
+    Target::Var("FPCR".to_string())
+}
+
+pub fn state() -> Scope {
+    let mut scope = Scope::new();
+
+    // Boolean literals
+    for lit in ["FALSE", "TRUE"] {
+        scope.global(literal(lit));
+    }
+
+    // Memory effects.
+    let read_effect = ReadEffect::new();
+    for target in read_effect.targets() {
+        scope.global(target.clone());
+    }
+
+    let set_effect = SetEffect::new();
+    for target in set_effect.targets() {
+        scope.global(target.clone());
+    }
+
+    // General purpose register file.
+    for i in 0..31 {
+        scope.global(gpreg(i));
+    }
+
+    // Vector register file.
+    for i in 0..31 {
+        scope.global(vreg(i));
+    }
+
+    // NZCV
+    for field in &["N", "Z", "C", "V"] {
+        scope.global(pstate_field(field));
+    }
+
+    // FPCR
+    scope.global(fpcr());
+
+    scope
+}
+
+/// Assemble the instruction to machine code bytes.
+pub fn assemble(inst: &Inst) -> Vec<u8> {
+    let flags = settings::Flags::new(settings::builder());
+    let emit_info = EmitInfo::new(flags);
+    let mut buffer = MachBuffer::new();
+    inst.emit(&mut buffer, &emit_info, &mut Default::default());
+    let buffer = buffer.finish(&Default::default(), &mut Default::default());
+    return buffer.data().to_vec();
+}
+
+/// Assemble the instruction and partition into opcodes.
+pub fn opcodes(inst: &Inst) -> Vec<u32> {
+    let machine_code = assemble(inst);
+    let mut opcodes = Vec::new();
+    for opcode_bytes in machine_code.chunks(4) {
+        assert_eq!(opcode_bytes.len(), 4);
+        opcodes.push(u32::from_le_bytes(opcode_bytes.try_into().unwrap()));
+    }
+    opcodes
+}
+
+/// Assemble the instruction and returns the single opcode. Errors if the
+/// instruction is not represented by a single opcode.
+pub fn opcode(inst: &Inst) -> u32 {
+    let opcodes = opcodes(inst);
+    assert_eq!(opcodes.len(), 1);
+    opcodes[0]
+}
+
+/// Assembly for the given instruction.
+pub fn assembly(inst: &Inst) -> String {
+    inst.print_with_state(&mut EmitState::default())
+}
diff --git a/cranelift/isle/veri/isaspec/src/bin/constraints.rs b/cranelift/isle/veri/isaspec/src/bin/constraints.rs
new file mode 100644
index 000000000000..1e5b9ca8fabc
--- /dev/null
+++ b/cranelift/isle/veri/isaspec/src/bin/constraints.rs
@@ -0,0 +1,410 @@
+use std::vec;
+
+use anyhow::Result;
+use clap::Parser as ClapParser;
+use cranelift_codegen::ir::types::I64;
+use cranelift_codegen::isa::aarch64::inst::{
+    vreg, writable_vreg, writable_xreg, xreg, ALUOp, ALUOp3, BitOp, Cond, FPUOp1, FPUOp2, Imm12,
+    ImmLogic, ImmShift, Inst, MoveWideConst, MoveWideOp, OperandSize, ScalarSize, ShiftOp,
+    ShiftOpAndAmt, ShiftOpShiftImm, VecALUOp, VecMisc2, VectorSize, NZCV,
+};
+use cranelift_isle::printer;
+use cranelift_isle_veri_aslp::ast::Block;
+use cranelift_isle_veri_aslp::client::Client;
+use tracing::debug;
+
+use cranelift_isle_veri_isaspec::aarch64;
+use cranelift_isle_veri_isaspec::constraints::Translator;
+use cranelift_isle_veri_isaspec::semantics::inst_semantics;
+
+#[derive(ClapParser)]
+#[command(version, about)]
+struct Args {
+    /// Server URL
+    #[arg(long = "server", required = true)]
+    server: String,
+
+    /// Print debugging output (repeat for more detail)
+    #[arg(short = 'd', long = "debug", action = clap::ArgAction::Count)]
+    debug_level: u8,
+}
+
+fn main() -> Result<()> {
+    let args = Args::parse();
+
+    // Setup tracing output.
+    tracing_subscriber::fmt()
+        .with_timer(tracing_subscriber::fmt::time::uptime())
+        .with_level(true)
+        .with_target(false)
+        .with_max_level(match args.debug_level {
+            0 => tracing::Level::WARN,
+            1 => tracing::Level::INFO,
+            2 => tracing::Level::DEBUG,
+            _ => tracing::Level::TRACE,
+        })
+        .init();
+
+    // ASLp client.
+    let http_client = reqwest::blocking::Client::new();
+    let client = Client::new(&http_client, args.server)?;
+
+    // Conversion.
+    let insts = define_insts();
+    for inst in &insts {
+        println!("-------------------------------------");
+        let opcode = aarch64::opcode(inst);
+        let asm = aarch64::assembly(inst);
+        println!("inst = {inst:#?}");
+        println!("opcode = {opcode:08x}");
+        println!("asm = {asm}");
+        println!("----");
+        let block = inst_semantics(inst, &client)?;
+        convert_block(&block)?;
+        println!("-------------------------------------");
+    }
+
+    Ok(())
+}
+
+// Define instructions to test.
+fn define_insts() -> Vec<Inst> {
+    let mut insts = Vec::new();
+
+    // OperandSize
+    let sizes = [OperandSize::Size32, OperandSize::Size64];
+
+    // AluRRR
+    let alu_ops = vec![
+        ALUOp::Add,
+        ALUOp::Sub,
+        ALUOp::Orr,
+        ALUOp::OrrNot,
+        ALUOp::And,
+        ALUOp::AndNot,
+        ALUOp::Eor,
+        ALUOp::EorNot,
+        ALUOp::AddS,
+        ALUOp::SubS,
+        ALUOp::SMulH,
+        ALUOp::UMulH,
+        ALUOp::Adc,
+        ALUOp::Sbc,
+        ALUOp::AdcS,
+        ALUOp::SbcS,
+        ALUOp::Lsr,
+        ALUOp::Asr,
+        ALUOp::Lsl,
+        ALUOp::RotR,
+        ALUOp::SDiv,
+        ALUOp::UDiv,
+    ];
+    for alu_op in alu_ops {
+        insts.push(Inst::AluRRR {
+            alu_op,
+            size: OperandSize::Size64,
+            rd: writable_xreg(4),
+            rn: xreg(5),
+            rm: xreg(6),
+        });
+    }
+
+    // AluRRImm12
+    let alu_ops_imm12 = [ALUOp::Add, ALUOp::Sub, ALUOp::AddS, ALUOp::SubS];
+    let imm12_vals = [0x000123u64, 0x123000u64];
+    for alu_op in alu_ops_imm12 {
+        for imm12_val in imm12_vals {
+            let imm12 = Imm12::maybe_from_u64(imm12_val).unwrap();
+            insts.push(Inst::AluRRImm12 {
+                alu_op,
+                size: OperandSize::Size64,
+                rd: writable_xreg(4),
+                rn: xreg(5),
+                imm12,
+            });
+        }
+    }
+
+    // AluRRImmLogic
+    let alu_ops_imml = [ALUOp::And, ALUOp::EorNot];
+    let imml_vals = [0xf003fffff003ffffu64, 0xffffffffff000000u64];
+    for alu_op in alu_ops_imml {
+        for imml_val in imml_vals {
+            let imml = ImmLogic::maybe_from_u64(imml_val, I64).unwrap();
+            insts.push(Inst::AluRRImmLogic {
+                alu_op,
+                size: OperandSize::Size64,
+                rd: writable_xreg(4),
+                rn: xreg(5),
+                imml,
+            });
+        }
+    }
+
+    // AluRRImmShift
+    let alu_ops_immshift = [ALUOp::Lsr, ALUOp::Lsl];
+    let immshift_vals = [13u64, 62];
+    for alu_op in alu_ops_immshift {
+        for immshift_val in immshift_vals {
+            let immshift = ImmShift::maybe_from_u64(immshift_val).unwrap();
+            insts.push(Inst::AluRRImmShift {
+                alu_op,
+                size: OperandSize::Size64,
+                rd: writable_xreg(4),
+                rn: xreg(5),
+                immshift,
+            });
+        }
+    }
+
+    // AluRRRShift
+    let alu_ops_rrr_shift = [ALUOp::Add, ALUOp::And];
+    let shiftops = [ShiftOp::LSL, ShiftOp::ASR];
+    let amts = [13u64, 63];
+    for alu_op in alu_ops_rrr_shift {
+        for shiftop in shiftops {
+            for amt in amts {
+                let shiftop =
+                    ShiftOpAndAmt::new(shiftop, ShiftOpShiftImm::maybe_from_shift(amt).unwrap());
+                insts.push(Inst::AluRRRShift {
+                    alu_op,
+                    size: OperandSize::Size64,
+                    rd: writable_xreg(4),
+                    rn: xreg(5),
+                    rm: xreg(6),
+                    shiftop,
+                });
+            }
+        }
+    }
+
+    // AluRRRR
+    let alu_ops = vec![ALUOp3::MAdd, ALUOp3::MSub, ALUOp3::UMAddL, ALUOp3::SMAddL];
+    for alu_op in alu_ops {
+        insts.push(Inst::AluRRRR {
+            alu_op,
+            size: OperandSize::Size32,
+            rd: writable_xreg(4),
+            rn: xreg(1),
+            rm: xreg(2),
+            ra: xreg(3),
+        });
+    }
+
+    // BitRR
+    let ops = vec![
+        BitOp::RBit,
+        BitOp::Clz,
+        BitOp::Cls,
+        BitOp::Rev16,
+        BitOp::Rev32,
+        BitOp::Rev64,
+    ];
+    for op in ops {
+        insts.push(Inst::BitRR {
+            op,
+            size: OperandSize::Size64,
+            rd: writable_xreg(2),
+            rn: xreg(1),
+        });
+    }
+
+    // MovWide
+    let mov_wide_ops = [MoveWideOp::MovN, MoveWideOp::MovZ];
+    let values = [0x00001234u64, 0x12340000u64];
+    for mov_wide_op in mov_wide_ops {
+        for size in sizes {
+            for value in values {
+                insts.push(Inst::MovWide {
+                    op: mov_wide_op,
+                    rd: writable_xreg(4),
+                    imm: MoveWideConst::maybe_from_u64(value).unwrap(),
+                    size,
+                });
+            }
+        }
+    }
+
+    // CSel
+    let conds = vec![
+        Cond::Eq,
+        Cond::Ne,
+        Cond::Hs,
+        Cond::Lo,
+        Cond::Mi,
+        Cond::Pl,
+        Cond::Vs,
+        Cond::Vc,
+        Cond::Hi,
+        Cond::Ls,
+        Cond::Ge,
+        Cond::Lt,
+        Cond::Gt,
+        Cond::Le,
+        Cond::Al,
+        Cond::Nv,
+    ];
+    for cond in conds.clone() {
+        insts.push(Inst::CSel {
+            rd: writable_xreg(3),
+            cond,
+            rn: xreg(1),
+            rm: xreg(2),
+        });
+    }
+
+    // CSNeg
+    for cond in conds.clone() {
+        insts.push(Inst::CSNeg {
+            rd: writable_xreg(3),
+            cond,
+            rn: xreg(1),
+            rm: xreg(2),
+        });
+    }
+
+    // CCmp
+    for cond in conds.clone() {
+        insts.push(Inst::CCmp {
+            size: OperandSize::Size64,
+            rn: xreg(1),
+            rm: xreg(2),
+            nzcv: NZCV::new(true, false, true, false),
+            cond,
+        });
+    }
+
+    // FpuCmp
+    insts.push(Inst::FpuCmp {
+        size: ScalarSize::Size64,
+        rn: vreg(1),
+        rm: vreg(2),
+    });
+
+    // FpuRR
+    let fpu_op1s = [FPUOp1::Neg];
+    for fpu_op1 in fpu_op1s {
+        insts.push(Inst::FpuRR {
+            fpu_op: fpu_op1,
+            size: ScalarSize::Size64,
+            rd: writable_vreg(1),
+            rn: vreg(2),
+        });
+    }
+
+    // FpuRRR
+    let fpu_op2s = [FPUOp2::Add, FPUOp2::Sub];
+    for fpu_op2 in fpu_op2s {
+        insts.push(Inst::FpuRRR {
+            fpu_op: fpu_op2,
+            size: ScalarSize::Size64,
+            rd: writable_vreg(1),
+            rn: vreg(2),
+            rm: vreg(3),
+        });
+    }
+
+    // VecRRR
+    let alu_ops = vec![
+        VecALUOp::Cmeq,
+        VecALUOp::Cmge,
+        VecALUOp::Cmgt,
+        VecALUOp::Cmhs,
+        VecALUOp::Cmhi,
+        VecALUOp::And,
+        VecALUOp::Bic,
+        VecALUOp::Orr,
+        VecALUOp::Umaxp,
+        VecALUOp::Add,
+        VecALUOp::Sub,
+        VecALUOp::Mul,
+        VecALUOp::Sshl,
+        VecALUOp::Ushl,
+        VecALUOp::Umin,
+        VecALUOp::Smin,
+        VecALUOp::Umax,
+        VecALUOp::Smax,
+        VecALUOp::Urhadd,
+        VecALUOp::Addp,
+        VecALUOp::Zip1,
+        VecALUOp::Zip2,
+        VecALUOp::Uzp1,
+        VecALUOp::Uzp2,
+        VecALUOp::Trn1,
+        VecALUOp::Trn2,
+        // TODO: 128-bit bitvector literal
+        // VecALUOp::Eor,
+        // TODO: boolean literals
+        // VecALUOp::Sqadd,
+        // VecALUOp::Uqadd,
+        // VecALUOp::Sqsub,
+        // VecALUOp::Uqsub,
+        // VecALUOp::Sqrdmulh,
+        // TODO: floating point.
+        // VecALUOp::Fcmeq,
+        // VecALUOp::Fcmgt,
+        // VecALUOp::Fcmge,
+        // VecALUOp::Fadd,
+        // VecALUOp::Fsub,
+        // VecALUOp::Fdiv,
+        // VecALUOp::Fmax,
+        // VecALUOp::Fmin,
+        // VecALUOp::Fmul,
+    ];
+    for alu_op in alu_ops {
+        insts.push(Inst::VecRRR {
+            alu_op,
+            rd: writable_vreg(3),
+            rn: vreg(1),
+            rm: vreg(2),
+            size: VectorSize::Size32x4,
+        });
+    }
+
+    // VecMisc
+    let vec_misc2s = vec![VecMisc2::Cnt];
+    for vec_misc2 in vec_misc2s {
+        insts.push(Inst::VecMisc {
+            op: vec_misc2,
+            rd: writable_vreg(3),
+            rn: vreg(1),
+            size: VectorSize::Size8x8,
+        });
+    }
+
+    insts
+}
+
+// Convert a semantics block and print the result.
+fn convert_block(block: &Block) -> Result<()> {
+    // Translation.
+    let mut translator = Translator::new(aarch64::state(), "v".to_string());
+    translator.translate(block)?;
+
+    // Report.
+    let global = translator.global();
+    debug!("scope: {global:#?}");
+
+    let init = global.init();
+    let bindings = global.bindings();
+
+    for r in global.reads() {
+        println!("read:\t{r}\t{}", init[r]);
+    }
+
+    for w in global.writes() {
+        println!(
+            "write:\t{w}\t{}",
+            bindings[w].as_var().expect("binding should be variable")
+        );
+    }
+
+    println!();
+
+    for constraint in global.constraints() {
+        printer::dump(constraint).unwrap();
+        println!();
+    }
+
+    Ok(())
+}
diff --git a/cranelift/isle/veri/isaspec/src/bin/fpconst.rs b/cranelift/isle/veri/isaspec/src/bin/fpconst.rs
new file mode 100644
index 000000000000..152b4b1ec62d
--- /dev/null
+++ b/cranelift/isle/veri/isaspec/src/bin/fpconst.rs
@@ -0,0 +1,121 @@
+struct Case {
+    in_bits: u8,
+    signed: bool,
+    out_bits: u8,
+    bits: u64,
+}
+
+impl Case {
+    fn from_f32(signed: bool, out_bits: u8, x: f32) -> Self {
+        Self {
+            in_bits: 32,
+            signed,
+            out_bits,
+            bits: x.to_bits() as u64,
+        }
+    }
+
+    fn from_f64(signed: bool, out_bits: u8, x: f64) -> Self {
+        Self {
+            in_bits: 64,
+            signed,
+            out_bits,
+            bits: x.to_bits(),
+        }
+    }
+
+    fn cond(&self) -> String {
+        format!(
+            "(and (= in #x{:02x}) (= signed {}) (= out #x{:02x}))",
+            self.in_bits, self.signed, self.out_bits,
+        )
+    }
+}
+
+fn print_spec(name: &str, cases: Vec<Case>) {
+    println!("(spec ({name} signed in out)");
+
+    println!("\t(provide");
+    for case in &cases {
+        println!("\t\t(=> {} (= result #x{:016x}))", case.cond(), case.bits);
+    }
+    println!("\t)");
+
+    println!("\t(require (or");
+    for case in &cases {
+        println!("\t\t{}", case.cond());
+    }
+    println!("\t))");
+
+    println!(")");
+}
+
+fn min_fp_value() {
+    print_spec(
+        "min_fp_value",
+        vec![
+            // f32 signed
+            Case::from_f32(true, 8, i8::MIN as f32 - 1.),
+            Case::from_f32(true, 16, i16::MIN as f32 - 1.),
+            Case::from_f32(true, 32, i32::MIN as f32),
+            Case::from_f32(true, 64, i64::MIN as f32),
+            // f32 unsigned
+            Case::from_f32(false, 8, -1.0),
+            Case::from_f32(false, 16, -1.0),
+            Case::from_f32(false, 32, -1.0),
+            Case::from_f32(false, 64, -1.0),
+            // f64 signed
+            Case::from_f64(true, 8, i8::MIN as f64 - 1.),
+            Case::from_f64(true, 16, i16::MIN as f64 - 1.),
+            Case::from_f64(true, 32, i32::MIN as f64 - 1.),
+            Case::from_f64(true, 64, i64::MIN as f64),
+            // f64 unsigned
+            Case::from_f64(false, 8, -1.0),
+            Case::from_f64(false, 16, -1.0),
+            Case::from_f64(false, 32, -1.0),
+            Case::from_f64(false, 64, -1.0),
+        ],
+    );
+}
+
+fn max_fp_value() {
+    print_spec(
+        "max_fp_value",
+        vec![
+            // f32 signed
+            Case::from_f32(true, 8, i8::MAX as f32 + 1.),
+            Case::from_f32(true, 16, i16::MAX as f32 + 1.),
+            Case::from_f32(true, 32, (i32::MAX as u64 + 1) as f32),
+            Case::from_f32(true, 64, (i64::MAX as u64 + 1) as f32),
+            // f32 unsigned
+            Case::from_f32(false, 8, u8::MAX as f32 + 1.),
+            Case::from_f32(false, 16, u16::MAX as f32 + 1.),
+            Case::from_f32(false, 32, (u32::MAX as u64 + 1) as f32),
+            Case::from_f32(false, 64, (u64::MAX as u128 + 1) as f32),
+            // f64 signed
+            Case::from_f64(true, 8, i8::MAX as f64 + 1.),
+            Case::from_f64(true, 16, i16::MAX as f64 + 1.),
+            Case::from_f64(true, 32, i32::MAX as f64 + 1.),
+            Case::from_f64(true, 64, (i64::MAX as u64 + 1) as f64),
+            // f64 unsigned
+            Case::from_f64(false, 8, u8::MAX as f64 + 1.),
+            Case::from_f64(false, 16, u16::MAX as f64 + 1.),
+            Case::from_f64(false, 32, u32::MAX as f64 + 1.),
+            Case::from_f64(false, 64, (u64::MAX as u128 + 1) as f64),
+        ],
+    );
+}
+
+fn generate() {
+    println!(";; GENERATED BY `fpconst`. DO NOT EDIT!!!");
+
+    println!();
+    min_fp_value();
+
+    println!();
+    max_fp_value();
+}
+
+pub fn main() {
+    generate();
+}
diff --git a/cranelift/isle/veri/isaspec/src/bin/isaspec.rs b/cranelift/isle/veri/isaspec/src/bin/isaspec.rs
new file mode 100644
index 000000000000..98428dbb10ae
--- /dev/null
+++ b/cranelift/isle/veri/isaspec/src/bin/isaspec.rs
@@ -0,0 +1,97 @@
+use std::io::Write;
+use std::path::{Path, PathBuf};
+use std::{io, vec};
+
+use anyhow::Result;
+use clap::Parser as ClapParser;
+
+use cranelift_isle::{
+    ast::{Attr, AttrKind, AttrTarget, Def},
+    printer,
+};
+use cranelift_isle_veri_aslp::client::Client;
+use cranelift_isle_veri_isaspec::{builder::Builder, instructions, spec::spec_ident};
+
+#[derive(ClapParser)]
+#[command(version, about)]
+struct Args {
+    /// Server URL
+    #[arg(long = "server", required = true)]
+    server: String,
+
+    // Output directory.
+    #[arg(long, required = true)]
+    output: PathBuf,
+
+    // Maximum line width.
+    #[arg(long, default_value = "120")]
+    width: usize,
+
+    /// Print debugging output (repeat for more detail)
+    #[arg(short = 'd', long = "debug", action = clap::ArgAction::Count)]
+    debug_level: u8,
+}
+
+fn main() -> Result<()> {
+    let args = Args::parse();
+
+    // Setup tracing output.
+    tracing_subscriber::fmt()
+        .with_writer(io::stderr)
+        .with_timer(tracing_subscriber::fmt::time::uptime())
+        .with_level(true)
+        .with_target(false)
+        .with_max_level(match args.debug_level {
+            0 => tracing::Level::WARN,
+            1 => tracing::Level::INFO,
+            2 => tracing::Level::DEBUG,
+            _ => tracing::Level::TRACE,
+        })
+        .init();
+
+    // ASLp client.
+    let http_client = reqwest::blocking::Client::new();
+    let client = Client::new(&http_client, args.server)?;
+
+    // Conversion.
+    let file_configs = instructions::define()?;
+    for file_config in file_configs {
+        // Generate specs.
+        let mut defs = Vec::new();
+        for spec_config in file_config.specs {
+            // Tag the term as generated.
+            defs.push(Def::Attr(generated_attribute(&spec_config.term)));
+            // Build and output the spec.
+            let builder = Builder::new(spec_config, &client);
+            let def = builder.build()?;
+            defs.push(def);
+        }
+
+        // Output.
+        let path = args.output.join(file_config.name);
+        write_spec(&path, &defs, args.width)?;
+    }
+
+    Ok(())
+}
+
+fn generated_attribute(term: &str) -> Attr {
+    Attr {
+        target: AttrTarget::Term(spec_ident(term.to_string())),
+        kinds: vec![AttrKind::Tag(spec_ident("isaspec_generated".to_string()))],
+        pos: Default::default(),
+    }
+}
+
+fn write_spec(path: &Path, defs: &Vec<Def>, width: usize) -> Result<()> {
+    let mut output = std::fs::File::create(path)?;
+
+    // Code generation warning.
+    writeln!(output, ";; GENERATED BY `isaspec`. DO NOT EDIT!!!")?;
+    writeln!(output)?;
+
+    // Format with ISLE printer.
+    printer::print(defs, width, &mut output)?;
+
+    Ok(())
+}
diff --git a/cranelift/isle/veri/isaspec/src/bits.rs b/cranelift/isle/veri/isaspec/src/bits.rs
new file mode 100644
index 000000000000..6e6d7cee539d
--- /dev/null
+++ b/cranelift/isle/veri/isaspec/src/bits.rs
@@ -0,0 +1,241 @@
+use std::{collections::HashMap, ops::Range};
+
+use anyhow::{bail, format_err, Result};
+use cranelift_isle_veri_aslp::opcode::{self, Opcode};
+
+#[derive(Clone)]
+pub struct Bits {
+    pub segments: Vec<Segment>,
+}
+
+impl Bits {
+    pub fn empty() -> Self {
+        Bits {
+            segments: Vec::new(),
+        }
+    }
+
+    pub fn from_u32(x: u32) -> Self {
+        Bits {
+            segments: vec![Segment::from_u32(x)],
+        }
+    }
+
+    pub fn is_symbolic(&self) -> bool {
+        self.segments.iter().any(|s| s.is_symbolic())
+    }
+
+    pub fn width(&self) -> usize {
+        self.segments.iter().map(|s| s.width()).sum()
+    }
+
+    /// Evaluate the bitvector template with the given assignment.
+    pub fn eval(&self, assignment: &HashMap<String, u32>) -> Result<u32> {
+        let mut result = 0u32;
+        let mut offset = 0usize;
+        for segment in &self.segments {
+            let value = match segment {
+                Segment::Symbolic(name, _) => assignment.get(name).ok_or(format_err!(
+                    "missing assignment for symbolic segment: {}",
+                    name
+                ))?,
+                Segment::Constant(c, _) => c,
+            };
+            result |= value << offset;
+            offset += segment.width()
+        }
+        Ok(result)
+    }
+
+    pub fn splice(base: &Bits, insert: &Bits, offset: usize) -> Result<Bits> {
+        let mut result = Bits::empty();
+        if offset > 0 {
+            let prefix = base.extract(0, offset)?;
+            result.append(prefix);
+        }
+        result.append(insert.clone());
+        if result.width() < base.width() {
+            let suffix = base.extract(result.width(), base.width())?;
+            result.append(suffix);
+        }
+        Ok(result)
+    }
+
+    pub fn append(&mut self, other: Bits) {
+        self.segments.extend(other.segments);
+    }
+
+    pub fn extract(&self, lo: usize, hi: usize) -> Result<Bits> {
+        let mut result = Bits::empty();
+        let mut offset = 0usize;
+        for segment in &self.segments {
+            // Intersection of this interval with extraction interval.
+            let start = std::cmp::max(lo, offset);
+            let end = std::cmp::min(hi, offset + segment.width());
+
+            // If the intersection is non-empty, add a segment.
+            if start < end {
+                result
+                    .segments
+                    .push(segment.extract(start - offset, end - offset)?);
+            }
+
+            // Advance offset.
+            offset += segment.width();
+        }
+        Ok(result)
+    }
+}
+
+impl std::fmt::Display for Bits {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            self.segments
+                .iter()
+                .rev()
+                .map(|s| s.to_string())
+                .collect::<Vec<_>>()
+                .join(" ")
+        )
+    }
+}
+
+impl From<Bits> for opcode::Opcode {
+    fn from(bits: Bits) -> Self {
+        Opcode {
+            segments: bits.segments.into_iter().map(Into::into).collect(),
+        }
+    }
+}
+
+/// Concrete assignment of symbolic bits in a bitvector template.
+pub struct Concrete {
+    pub assignment: HashMap<String, u32>,
+    pub template: Bits,
+}
+
+impl Concrete {
+    pub fn eval(&self) -> Result<u32> {
+        self.template.eval(&self.assignment)
+    }
+}
+
+pub struct ConcreteIterator {
+    fields: Vec<(String, u32)>,
+    bits: Range<u32>,
+    template: Bits,
+}
+
+impl ConcreteIterator {
+    fn new(template: Bits) -> Self {
+        let mut fields = Vec::new();
+        let mut n = 1;
+        for segment in &template.segments {
+            match segment {
+                Segment::Symbolic(name, width) => {
+                    fields.push((name.clone(), (*width).try_into().unwrap()));
+                    n <<= width;
+                }
+                Segment::Constant(_, _) => {}
+            }
+        }
+
+        ConcreteIterator {
+            fields,
+            bits: 0..n,
+            template,
+        }
+    }
+}
+
+impl Iterator for ConcreteIterator {
+    type Item = Concrete;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        // Advance to next assignment of all symbolic bits.
+        let mut bits = self.bits.next()?;
+
+        // Divide into individual fields.
+        let mut assignment = HashMap::new();
+        for (name, width) in &self.fields {
+            let mask = (1 << width) - 1;
+            assignment.insert(name.clone(), bits & mask);
+            bits >>= width;
+        }
+
+        Some(Concrete {
+            assignment,
+            template: self.template.clone(),
+        })
+    }
+}
+
+impl IntoIterator for &Bits {
+    type Item = Concrete;
+    type IntoIter = ConcreteIterator;
+
+    fn into_iter(self) -> Self::IntoIter {
+        ConcreteIterator::new(self.clone())
+    }
+}
+
+#[derive(Clone)]
+pub enum Segment {
+    Symbolic(String, usize),
+    Constant(u32, usize),
+}
+
+impl Segment {
+    pub fn from_u32(x: u32) -> Self {
+        Segment::Constant(x, 32)
+    }
+
+    pub fn is_symbolic(&self) -> bool {
+        matches!(self, Segment::Symbolic(_, _))
+    }
+
+    pub fn width(&self) -> usize {
+        match self {
+            Segment::Symbolic(_, w) | Segment::Constant(_, w) => *w,
+        }
+    }
+
+    pub fn extract(&self, lo: usize, hi: usize) -> Result<Segment> {
+        match *self {
+            Segment::Symbolic(_, w) => {
+                if !(lo == 0 && hi == w) {
+                    bail!("symbolic segments must remain whole");
+                }
+                Ok(self.clone())
+            }
+            Segment::Constant(c, w) => {
+                if !(lo < hi && hi <= w) {
+                    bail!("invalid extraction interval");
+                }
+                let w = hi - lo;
+                let mask = (1 << w) - 1;
+                Ok(Segment::Constant((c >> lo) & mask, w))
+            }
+        }
+    }
+}
+
+impl std::fmt::Display for Segment {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Segment::Symbolic(s, w) => write!(f, "{s}:{w}"),
+            Segment::Constant(c, w) => write!(f, "{c:#x}:{w}"),
+        }
+    }
+}
+
+impl From<Segment> for opcode::Segment {
+    fn from(segment: Segment) -> Self {
+        match segment {
+            Segment::Symbolic(name, width) => opcode::Segment::Symbolic(name, width),
+            Segment::Constant(value, width) => opcode::Segment::Constant(value, width),
+        }
+    }
+}
diff --git a/cranelift/isle/veri/isaspec/src/builder.rs b/cranelift/isle/veri/isaspec/src/builder.rs
new file mode 100644
index 000000000000..c56738fefee2
--- /dev/null
+++ b/cranelift/isle/veri/isaspec/src/builder.rs
@@ -0,0 +1,349 @@
+//! Construction of VeriISLE specifications from ASLp semantics.
+
+use std::collections::{HashMap, HashSet};
+use std::vec;
+
+use anyhow::{bail, Result};
+use itertools::Itertools;
+
+use cranelift_codegen::isa::aarch64::inst::Inst;
+use cranelift_isle::ast::{self, Def, Modifies, Spec, SpecExpr};
+use cranelift_isle::lexer::Pos;
+use cranelift_isle_veri_aslp::client::Client;
+
+use crate::bits::Bits;
+use crate::constraints::{Binding, Scope, Target, Translator};
+use crate::spec::spec_field;
+use crate::{
+    aarch64,
+    spec::{spec_all, spec_ident, spec_idents, spec_var, spec_with, substitute, Conditions},
+};
+
+pub struct SpecConfig {
+    pub term: String,
+    pub args: Vec<String>,
+    pub cases: Cases,
+}
+
+pub enum Cases {
+    Instruction(InstConfig),
+    Cases(Vec<Case>),
+    Match(Match),
+}
+
+pub struct Case {
+    pub conds: Vec<SpecExpr>,
+    pub cases: Cases,
+}
+
+pub struct Match {
+    pub on: SpecExpr,
+    pub arms: Vec<Arm>,
+}
+
+pub struct Arm {
+    pub variant: String,
+    pub args: Vec<String>,
+    pub body: Cases,
+}
+
+#[derive(Clone)]
+pub enum Expectation {
+    Require,
+    Allow,
+}
+
+#[derive(Clone)]
+pub struct Mapping {
+    expr: SpecExpr,
+    expect: Expectation,
+    modifies: Vec<String>,
+}
+
+impl Mapping {
+    pub fn new(expr: SpecExpr, expect: Expectation) -> Self {
+        Self {
+            expr,
+            expect,
+            modifies: Vec::new(),
+        }
+    }
+
+    pub fn require(expr: SpecExpr) -> Self {
+        Self::new(expr, Expectation::Require)
+    }
+
+    pub fn allow(expr: SpecExpr) -> Self {
+        Self::new(expr, Expectation::Allow)
+    }
+}
+
+#[derive(Clone)]
+pub struct MappingBuilder(Mapping);
+
+impl MappingBuilder {
+    pub fn new(expr: SpecExpr) -> Self {
+        Self(Mapping::new(expr, Expectation::Require))
+    }
+
+    pub fn var(name: &str) -> Self {
+        Self::new(spec_var(name.to_string()))
+    }
+
+    pub fn state(name: &str) -> Self {
+        Self::new(spec_var(name.to_string())).modifies(name)
+    }
+
+    pub fn field(mut self, field: &str) -> Self {
+        self.0.expr = spec_field(field.to_string(), self.0.expr);
+        self
+    }
+
+    pub fn allow(mut self) -> Self {
+        self.0.expect = Expectation::Allow;
+        self
+    }
+
+    pub fn modifies(mut self, state: &str) -> Self {
+        self.0.modifies.push(state.to_string());
+        self
+    }
+
+    pub fn build(self) -> Mapping {
+        self.0
+    }
+}
+
+#[derive(Clone, Default)]
+pub struct Mappings {
+    pub reads: HashMap<Target, Mapping>,
+    pub writes: HashMap<Target, Mapping>,
+}
+
+impl Mappings {
+    fn required_reads(&self) -> HashSet<Target> {
+        Self::required_targets(&self.reads)
+    }
+
+    fn required_writes(&self) -> HashSet<Target> {
+        Self::required_targets(&self.writes)
+    }
+
+    fn required_targets(target_mapping: &HashMap<Target, Mapping>) -> HashSet<Target> {
+        target_mapping
+            .iter()
+            .filter_map(|(target, mapping)| match mapping.expect {
+                Expectation::Require => Some(target.clone()),
+                Expectation::Allow => None,
+            })
+            .collect()
+    }
+}
+
+pub enum Opcodes {
+    Instruction(Inst),
+    Template(Bits),
+}
+
+impl Opcodes {
+    pub fn bits(&self) -> Bits {
+        match self {
+            Opcodes::Instruction(inst) => {
+                let opcode = aarch64::opcode(inst);
+                Bits::from_u32(opcode)
+            }
+            Opcodes::Template(bits) => bits.clone(),
+        }
+    }
+}
+
+pub struct InstConfig {
+    pub opcodes: Opcodes,
+    pub scope: Scope,
+    pub mappings: Mappings,
+}
+
+pub struct Builder<'a> {
+    cfg: SpecConfig,
+    client: &'a Client<'a>,
+}
+
+impl<'a> Builder<'a> {
+    pub fn new(cfg: SpecConfig, client: &'a Client<'a>) -> Self {
+        Self { cfg, client }
+    }
+
+    pub fn build(&self) -> Result<Def> {
+        let spec = self.spec()?;
+        let def = Def::Spec(spec);
+        Ok(def)
+    }
+
+    fn spec(&self) -> Result<Spec> {
+        let cond = self.cases(&self.cfg.cases)?;
+        let modifies = spec_idents(&cond.modifies.iter().sorted().cloned().collect::<Vec<_>>());
+        let spec = Spec {
+            term: spec_ident(self.cfg.term.clone()),
+            args: spec_idents(&self.cfg.args),
+            requires: cond.requires,
+            provides: cond.provides,
+            matches: Vec::new(),
+            modifies: modifies
+                .into_iter()
+                .map(|state| Modifies { state, cond: None })
+                .collect(),
+            pos: Pos::default(),
+        };
+        Ok(spec)
+    }
+
+    fn cases(&self, cases: &Cases) -> Result<Conditions> {
+        match cases {
+            Cases::Instruction(case) => self.case(case),
+            Cases::Cases(cases) => {
+                let conds = cases
+                    .iter()
+                    .map(|case| {
+                        let mut cond = self.cases(&case.cases)?;
+                        cond.requires.extend(case.conds.clone());
+                        Ok(cond)
+                    })
+                    .collect::<Result<Vec<_>>>()?;
+                Ok(Conditions::merge(conds))
+            }
+            Cases::Match(m) => {
+                let mut require_arms = Vec::new();
+                let mut arms = Vec::new();
+                let mut modifies = HashSet::new();
+                for arm in &m.arms {
+                    // Build conditions for the arm body.
+                    let cond = self.cases(&arm.body)?;
+
+                    // Provides form the body of the arm.
+                    arms.push(ast::Arm {
+                        variant: spec_ident(arm.variant.clone()),
+                        args: spec_idents(&arm.args),
+                        body: spec_all(cond.provides),
+                        pos: Pos::default(),
+                    });
+
+                    // This arm requires a match on the variant, as well as
+                    // requirements from the body.
+                    require_arms.push(ast::Arm {
+                        variant: spec_ident(arm.variant.clone()),
+                        args: spec_idents(&arm.args),
+                        body: spec_all(cond.requires),
+                        pos: Pos::default(),
+                    });
+
+                    // Merge modifies.
+                    modifies.extend(cond.modifies);
+                }
+
+                Ok(Conditions {
+                    requires: vec![SpecExpr::Match {
+                        x: Box::new(m.on.clone()),
+                        arms: require_arms,
+                        pos: Pos::default(),
+                    }],
+                    provides: vec![SpecExpr::Match {
+                        x: Box::new(m.on.clone()),
+                        arms,
+                        pos: Pos::default(),
+                    }],
+                    modifies,
+                })
+            }
+        }
+    }
+
+    fn case(&self, case: &InstConfig) -> Result<Conditions> {
+        // Semantics.
+        let opcode_bits = case.opcodes.bits();
+        let block = self.client.opcode(opcode_bits.into())?;
+
+        // Translation.
+        let mut translator = Translator::new(case.scope.clone(), "t".to_string());
+        translator.translate(&block)?;
+
+        let global = translator.global();
+
+        // Reads mapping.
+        let mut substitutions = HashMap::new();
+        let mut modifies = HashSet::new();
+        let reads = global.reads();
+        let init = global.init();
+        for target in reads.iter().sorted() {
+            // Expect mapping for the read.
+            let Some(mapping) = case.mappings.reads.get(target) else {
+                bail!("read of {target} is unmapped");
+            };
+
+            // Lookup variable holding the initial read value.
+            let v = &init[target];
+
+            // Substitute variable for mapped expression.
+            substitutions.insert(v.clone(), mapping.expr.clone());
+
+            // Read operations should not modify state.
+            if !mapping.modifies.is_empty() {
+                bail!("read of {target} should not modify state");
+            }
+        }
+
+        if let Some(target) = case.mappings.required_reads().difference(reads).next() {
+            bail!("{target} should have been read");
+        }
+
+        // Writes mapping.
+        let writes = global.writes();
+        let bindings = global.bindings();
+        for target in writes.iter().sorted() {
+            // Expect mapping for the write.
+            let Some(mapping) = case.mappings.writes.get(target) else {
+                bail!("write to {target} is unmapped");
+            };
+
+            // Lookup bound variable.
+            let Some(Binding::Var(v)) = bindings.get(target) else {
+                bail!("{target} not bound to variable");
+            };
+
+            // Substitute variable for mapped expression.
+            substitutions.insert(v.clone(), mapping.expr.clone());
+
+            // Update modifies list.
+            modifies.extend(mapping.modifies.clone());
+        }
+
+        if let Some(target) = case.mappings.required_writes().difference(writes).next() {
+            bail!("{target} should have been written");
+        }
+
+        // Finalize provided constraints.
+        let mut provides = Vec::new();
+        for constraint in global.constraints() {
+            provides.push(substitute(constraint.clone(), &substitutions)?);
+        }
+
+        // Determine remaining temporaries and encapsulate in a scope.
+        let temporaries: Vec<_> = global
+            .vars()
+            .iter()
+            .filter(|v| !substitutions.contains_key(*v))
+            .sorted()
+            .cloned()
+            .collect();
+        if !temporaries.is_empty() {
+            let with_scope = spec_with(spec_idents(&temporaries), spec_all(provides));
+            provides = vec![with_scope];
+        }
+
+        // Conditions.
+        Ok(Conditions {
+            requires: Vec::new(),
+            provides,
+            modifies,
+        })
+    }
+}
diff --git a/cranelift/isle/veri/isaspec/src/configure.rs b/cranelift/isle/veri/isaspec/src/configure.rs
new file mode 100644
index 000000000000..c6638a452259
--- /dev/null
+++ b/cranelift/isle/veri/isaspec/src/configure.rs
@@ -0,0 +1,246 @@
+use std::collections::HashMap;
+
+use anyhow::{bail, Result};
+use cranelift_codegen::{isa::aarch64::inst::Inst, Reg, RegClass};
+
+use crate::{
+    aarch64::{self, pstate_field},
+    bits::Bits,
+    builder::{MappingBuilder, Mappings},
+    constraints::Target,
+    spec::{spec_as_bit_vector_width, spec_conv_to, spec_var},
+};
+use cranelift_isle::ast::SpecExpr;
+
+#[macro_export(local_inner_macros)]
+macro_rules! spec_config {
+    (($family:ident $($arg:ident)+) { $($conf:tt)* }) => {
+        __mappings! { @init mappings $($conf)* };
+        SpecConfig {
+            term: std::concat!("MInst.", std::stringify!($family)).to_string(),
+            args: [$(std::stringify!($arg),)+]
+                .map(String::from)
+                .to_vec(),
+            cases: __cases! {
+                (
+                    family: $family,
+                    args: ($($arg)+),
+                    mappings: mappings
+                ),
+                $($conf)*
+            },
+        }
+    };
+}
+
+#[macro_export(local_inner_macros)]
+macro_rules! __mappings {
+    (@init $mappings:ident $($conf:tt)*) => {
+        let mut $mappings = Mappings::default();
+        // TODO: move boolean literals to a library function.
+        $mappings
+            .reads
+            .insert(aarch64::literal("TRUE"), Mapping::allow(spec_true()));
+        $mappings
+            .reads
+            .insert(aarch64::literal("FALSE"), Mapping::allow(spec_false()));
+        __mappings! { @conf $mappings $($conf)* }
+    };
+
+    // Read and write mappings for general-purpose registers.
+    (@conf $mappings:ident register ($name:ident, read, gp, $id:literal); $($conf:tt)*) => {
+        $mappings.reads.insert(
+            aarch64::gpreg($id),
+            Mapping::require(spec_var(std::stringify!($name).to_string())),
+        );
+        let $name = xreg($id);
+        __mappings! { @conf $mappings $($conf)* }
+    };
+
+    (@conf $mappings:ident register ($name:ident, read, gp64, $id:literal); $($conf:tt)*) => {
+        $mappings.reads.insert(
+            aarch64::gpreg($id),
+            Mapping::require(spec_as_bit_vector_width(spec_var(std::stringify!($name).to_string()), 64)),
+        );
+        let $name = xreg($id);
+        __mappings! { @conf $mappings $($conf)* }
+    };
+
+    (@conf $mappings:ident register ($name:ident, write, gp, $id:literal); $($conf:tt)*) => {
+        $mappings.writes.insert(
+            aarch64::gpreg($id),
+            Mapping::require(spec_var(std::stringify!($name).to_string())),
+        );
+        let $name = writable_xreg($id);
+        __mappings! { @conf $mappings $($conf)* }
+    };
+
+    // Read and write mappings for floating-point registers.
+    (@conf $mappings:ident register ($name:ident, read, fp, $id:literal); $($conf:tt)*) => {
+        $mappings.reads.insert(
+            aarch64::vreg($id),
+            Mapping::require($crate::configure::spec_fp_reg(std::stringify!($name))),
+        );
+        let $name = vreg($id);
+        __mappings! { @conf $mappings $($conf)* }
+    };
+
+    (@conf $mappings:ident register ($name:ident, write, fp, $id:literal); $($conf:tt)*) => {
+        $mappings.writes.insert(
+            aarch64::vreg($id),
+            Mapping::require($crate::configure::spec_fp_reg(std::stringify!($name))),
+        );
+        let $name = writable_vreg($id);
+        __mappings! { @conf $mappings $($conf)* }
+    };
+
+    (@conf $mappings:ident fpcr (); $($conf:tt)*) => {
+        $mappings
+            .reads
+            .insert(aarch64::fpcr(), MappingBuilder::var("fpcr").allow().build());
+        __mappings! { @conf $mappings $($conf)* }
+    };
+
+    // Read and write mappings for full vector/floating-point registers.
+    (@conf $mappings:ident register ($name:ident, read, vec, $id:literal); $($conf:tt)*) => {
+        $mappings.reads.insert(
+            aarch64::vreg($id),
+            Mapping::require(spec_var(std::stringify!($name).to_string())),
+        );
+        let $name = vreg($id);
+        __mappings! { @conf $mappings $($conf)* }
+    };
+
+    (@conf $mappings:ident register ($name:ident, write, vec, $id:literal); $($conf:tt)*) => {
+        $mappings.writes.insert(
+            aarch64::vreg($id),
+            Mapping::require(spec_var(std::stringify!($name).to_string())),
+        );
+        let $name = writable_vreg($id);
+        __mappings! { @conf $mappings $($conf)* }
+    };
+
+    // Flags mappings.
+    (@conf $mappings:ident flags (); $($conf:tt)*) => {
+        $crate::configure::configure_flags_mappings(&mut $mappings);
+        __mappings! { @conf $mappings $($conf)* }
+    };
+
+    (@conf $mappings:ident $directive:ident $args:tt; $($conf:tt)*) => {
+        __mappings! { @conf $mappings $($conf)* }
+    };
+
+    (@conf $mappings:ident) => {};
+}
+
+#[macro_export(local_inner_macros)]
+macro_rules! __cases {
+    ($meta:tt, enumerate ($it:ident, $arms:ident); $($tt:tt)+) => {
+        Cases::Match(Match {
+            on: spec_var(std::stringify!($it).to_string()),
+            arms: $arms
+                .iter()
+                .copied()
+                .flat_map(|$it| {
+                    let body = __cases! { $meta, $($tt)* };
+                    Some(Arm {
+                    variant: std::format!("{:?}", $it),
+                    args: Vec::new(),
+                    body,
+                })
+            }).collect(),
+        })
+    };
+
+    ($meta:tt, filter ($expr:expr); $($tt:tt)+) => {
+        if $expr {
+            __cases! { $meta, $($tt)* }
+        } else {
+            return None;
+        }
+    };
+
+    ((family: $family:ident, args: ($($arg:ident)+), mappings: $mappings:ident), instruction ();) => {
+        Cases::Instruction(InstConfig {
+            opcodes: Opcodes::Instruction(Inst::$family{
+                $($arg,)+
+            }),
+            scope: aarch64::state(),
+            mappings: $mappings.clone(),
+        })
+    };
+
+    ($meta:tt, $directive:ident $args:tt; $($tt:tt)*) => {
+        __cases! { $meta, $($tt)* }
+    };
+}
+
+pub fn flags_mappings() -> Mappings {
+    let mut mappings = Mappings::default();
+    configure_flags_mappings(&mut mappings);
+    mappings
+}
+
+pub fn configure_flags_mappings(mappings: &mut Mappings) {
+    // Instruction model is the MInst value itself, which is considered the result of the variant term.
+    let inst = MappingBuilder::var("result").allow();
+
+    // Input and output flags of the instruction are fields of the MInst model.
+    let flags_in = inst.clone().field("flags_in");
+    let flags_out = inst.clone().field("flags_out");
+
+    // Construct read and write mappings for each NZCV field.
+    for field in &["N", "Z", "C", "V"] {
+        // Read
+        mappings
+            .reads
+            .insert(pstate_field(field), flags_in.clone().field(field).build());
+
+        // Write
+        mappings
+            .writes
+            .insert(pstate_field(field), flags_out.clone().field(field).build());
+    }
+}
+
+// Spec expression for the lower 64 bits of a 128-bit floating-point register.
+pub fn spec_fp_reg(name: &str) -> SpecExpr {
+    spec_conv_to(
+        128,
+        spec_as_bit_vector_width(spec_var(name.to_string()), 64),
+    )
+}
+
+// Compare an opcode template against the instruction we expect it to represent.
+pub fn verify_opcode_template<F>(template: &Bits, expect: F) -> Result<()>
+where
+    F: Fn(&HashMap<String, u32>) -> Result<Inst>,
+{
+    // Iterate over all template values.
+    for concrete in template.into_iter() {
+        let inst = expect(&concrete.assignment)?;
+        let opcode = aarch64::opcode(&inst);
+        let got = concrete.eval()?;
+        if got != opcode {
+            bail!(
+                "template mismatch: opcode {:#x}, template {:#x}",
+                opcode,
+                got,
+            );
+        }
+    }
+    Ok(())
+}
+
+// Convert a Cranelift register to the corresponding element of AArch64 state in
+// ASLp.
+pub fn reg_target(reg: Reg) -> Result<Target> {
+    let Some(preg) = reg.to_real_reg() else {
+        bail!("not physical register")
+    };
+    let index = preg.hw_enc().into();
+    Ok(match preg.class() {
+        RegClass::Int => aarch64::gpreg(index),
+        RegClass::Float | RegClass::Vector => aarch64::vreg(index),
+    })
+}
diff --git a/cranelift/isle/veri/isaspec/src/constraints.rs b/cranelift/isle/veri/isaspec/src/constraints.rs
new file mode 100644
index 000000000000..897c8983ab7e
--- /dev/null
+++ b/cranelift/isle/veri/isaspec/src/constraints.rs
@@ -0,0 +1,750 @@
+//! Translation of ASLp semantics to constraints.
+
+use core::{fmt, panic};
+use std::cmp::Ordering;
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+use std::vec;
+
+use anyhow::{bail, format_err, Result};
+use cranelift_isle::ast::{SpecExpr, SpecOp};
+use cranelift_isle::lexer::Pos;
+use cranelift_isle_veri_aslp::ast::{Block, Expr, Func, LExpr, Slice, Stmt};
+use tracing::debug;
+
+use crate::memory::{ReadEffect, SetEffect};
+use crate::spec::*;
+
+#[derive(Debug, PartialEq, Eq, Hash, Clone, PartialOrd, Ord)]
+pub enum Target {
+    Var(String),
+    Index(Box<Target>, usize),
+    Field(Box<Target>, String),
+}
+
+impl fmt::Display for Target {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Var(v) => write!(f, "{v}"),
+            Self::Index(a, i) => write!(f, "{a}[{i}]"),
+            Self::Field(s, field) => write!(f, "{s}.{field}"),
+        }
+    }
+}
+
+impl TryFrom<&LExpr> for Target {
+    type Error = anyhow::Error;
+
+    fn try_from(lexpr: &LExpr) -> Result<Self> {
+        match lexpr {
+            LExpr::Var(v) => Ok(Target::Var(v.clone())),
+            LExpr::ArrayIndex { array, index } => {
+                let array = Box::new(array.as_ref().try_into()?);
+                let index = index
+                    .as_lit_int()
+                    .ok_or(format_err!("array index must be literal integer"))?
+                    .parse()?;
+                Ok(Target::Index(array, index))
+            }
+            LExpr::Field { x, name } => {
+                let x = Box::new(x.as_ref().try_into()?);
+                Ok(Target::Field(x, name.clone()))
+            }
+        }
+    }
+}
+
+impl TryFrom<&Expr> for Target {
+    type Error = anyhow::Error;
+
+    fn try_from(expr: &Expr) -> Result<Self> {
+        match expr {
+            Expr::Var(v) => Ok(Target::Var(v.clone())),
+            Expr::ArrayIndex { array, index } => {
+                let array = Box::new(array.as_ref().try_into()?);
+                let index = index
+                    .as_lit_int()
+                    .ok_or(format_err!("array index must be literal integer"))?
+                    .parse()?;
+                Ok(Target::Index(array, index))
+            }
+            Expr::Field { x, name } => {
+                let x = Box::new(x.as_ref().try_into()?);
+                Ok(Target::Field(x, name.clone()))
+            }
+            _ => todo!("target expr: {expr:?}"),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum Binding {
+    Uninitialized,
+    Global,
+    Var(String),
+}
+
+impl Binding {
+    pub fn as_var(&self) -> Option<&String> {
+        match self {
+            Binding::Var(v) => Some(v),
+            _ => None,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Scope {
+    constraints: Vec<SpecExpr>,
+    vars: HashSet<String>,
+    decls: HashSet<Target>,
+    bindings: BTreeMap<Target, Binding>,
+    init: HashMap<Target, String>,
+    reads: HashSet<Target>,
+    writes: HashSet<Target>,
+}
+
+impl Scope {
+    pub fn new() -> Self {
+        Self {
+            constraints: Vec::new(),
+            vars: HashSet::new(),
+            decls: HashSet::new(),
+            bindings: BTreeMap::new(),
+            init: HashMap::new(),
+            reads: HashSet::new(),
+            writes: HashSet::new(),
+        }
+    }
+
+    pub fn constraints(&self) -> &Vec<SpecExpr> {
+        &self.constraints
+    }
+
+    fn constrain(&mut self, constraint: SpecExpr) {
+        self.constraints.push(constraint);
+    }
+
+    pub fn vars(&self) -> &HashSet<String> {
+        &self.vars
+    }
+
+    pub fn reads(&self) -> &HashSet<Target> {
+        &self.reads
+    }
+
+    pub fn writes(&self) -> &HashSet<Target> {
+        &self.writes
+    }
+
+    pub fn init(&self) -> &HashMap<Target, String> {
+        &self.init
+    }
+
+    pub fn bindings(&self) -> &BTreeMap<Target, Binding> {
+        &self.bindings
+    }
+
+    fn bind(&mut self, target: Target, b: Binding) {
+        self.bindings.insert(target.clone(), b);
+    }
+
+    fn decl(&mut self, target: Target) {
+        self.decls.insert(target.clone());
+        self.bind(target, Binding::Uninitialized);
+    }
+
+    pub fn global(&mut self, target: Target) {
+        self.decls.insert(target.clone());
+        self.bind(target, Binding::Global);
+    }
+
+    fn add_var(&mut self, v: String) {
+        self.vars.insert(v);
+    }
+
+    fn bind_var(&mut self, target: Target, v: String) {
+        self.add_var(v.clone());
+        self.bind(target, Binding::Var(v));
+    }
+
+    fn init_var(&mut self, target: Target, v: String) {
+        assert!(!self.init.contains_key(&target));
+        self.init.insert(target.clone(), v.clone());
+        self.bind_var(target, v);
+    }
+
+    fn write(&mut self, target: Target, v: String) {
+        self.writes.insert(target.clone());
+        self.bind_var(target, v);
+    }
+
+    fn read(&mut self, target: &Target) -> Option<&Binding> {
+        if let Some(b) = self.bindings.get(target) {
+            debug!(?target, "scope read");
+            self.reads.insert(target.clone());
+            return Some(b);
+        }
+        None
+    }
+
+    fn update(&mut self, child: &Self) {
+        self.constraints.extend(child.constraints.iter().cloned());
+        self.vars.extend(child.vars.iter().cloned());
+        for target in &child.writes {
+            if !child.decls.contains(target) {
+                self.bind(target.clone(), child.bindings[target].clone());
+                self.writes.insert(target.clone());
+            }
+        }
+    }
+}
+
+struct VariableAllocator {
+    index: usize,
+    prefix: String,
+}
+
+impl VariableAllocator {
+    fn new(prefix: String) -> Self {
+        Self { index: 0, prefix }
+    }
+
+    fn alloc(&mut self) -> String {
+        let index = self.index;
+        self.index += 1;
+        format!("{}{}", self.prefix, index)
+    }
+}
+
+pub struct Translator {
+    stack: Vec<Scope>,
+    vars: VariableAllocator,
+}
+
+impl Translator {
+    pub fn new(global: Scope, prefix: String) -> Self {
+        Self {
+            stack: vec![global],
+            vars: VariableAllocator::new(prefix),
+        }
+    }
+
+    pub fn global(&self) -> &Scope {
+        self.stack.first().expect("stack must be non-empty")
+    }
+
+    fn enter(&mut self) {
+        debug!("enter scope");
+        self.stack.push(Scope::new())
+    }
+
+    fn exit(&mut self) {
+        let scope = self.pop();
+        debug!(?scope, "exit scope");
+        self.scope_mut().update(&scope);
+    }
+
+    fn pop(&mut self) -> Scope {
+        self.stack.pop().expect("stack must be non-empty")
+    }
+
+    fn scope_mut(&mut self) -> &mut Scope {
+        self.stack.last_mut().expect("stack must be non-empty")
+    }
+
+    fn constrain(&mut self, constraint: SpecExpr) {
+        self.scope_mut().constrain(constraint)
+    }
+
+    fn write(&mut self, target: &Target, v: &str) {
+        self.scope_mut().write(target.clone(), v.to_string());
+    }
+
+    fn read(&mut self, target: &Target) -> Result<String> {
+        // Read from innermost scope.
+        for scope in self.stack.iter_mut().rev() {
+            match scope.read(target) {
+                None => continue,
+                Some(Binding::Var(v)) => return Ok(v.clone()),
+                Some(Binding::Uninitialized) => bail!("uninitialized read: {target}"),
+                Some(Binding::Global) => {
+                    let v = self.vars.alloc();
+                    scope.init_var(target.clone(), v.clone());
+                    return Ok(v);
+                }
+            };
+        }
+        let scope = self.scope_mut();
+        debug!(?scope, "scope");
+        bail!("undefined read: {target}")
+    }
+
+    pub fn translate(&mut self, block: &Block) -> Result<()> {
+        self.enter();
+        self.block(block)?;
+        self.exit();
+        Ok(())
+    }
+
+    fn block(&mut self, block: &Block) -> Result<()> {
+        for stmt in &block.stmts {
+            self.stmt(stmt)?;
+        }
+        Ok(())
+    }
+
+    fn stmt(&mut self, stmt: &Stmt) -> Result<()> {
+        match stmt {
+            Stmt::Assign { lhs, rhs } => {
+                let target = lhs.try_into()?;
+                let rhs = self.expr(rhs)?;
+                self.assign(&target, rhs)
+            }
+            Stmt::ConstDecl { name, rhs, .. } | Stmt::VarDecl { name, rhs, .. } => {
+                let target = Target::Var(name.clone());
+                self.scope_mut().decl(target.clone());
+                let rhs = self.expr(rhs)?;
+                self.assign(&target, rhs)
+            }
+            Stmt::VarDeclsNoInit { names, .. } => {
+                for name in names {
+                    let target = Target::Var(name.clone());
+                    self.scope_mut().decl(target);
+                }
+                Ok(())
+            }
+            Stmt::Assert { cond } => {
+                let constraint = self.expr(cond)?;
+                self.constrain(constraint);
+                Ok(())
+            }
+            Stmt::If {
+                cond,
+                then_block,
+                else_block,
+            } => {
+                self.enter();
+
+                // Assign the conditional to a variable.
+                let cond = self.expr(cond)?;
+                let c = self.bind(cond)?;
+                let cond = spec_var(c);
+
+                // Execute then. Pop off the scope.
+                self.enter();
+                self.block(then_block)?;
+                let then_scope = self.pop();
+
+                // Execute else. Pop off the scope.
+                self.enter();
+                self.block(else_block)?;
+                let else_scope = self.pop();
+
+                // Join blocks.
+                self.constrain(spec_if(
+                    cond.clone(),
+                    spec_all(then_scope.constraints),
+                    spec_all(else_scope.constraints),
+                ));
+
+                // Merge target bindings.
+                let mut targets = BTreeSet::new();
+                targets.extend(then_scope.bindings.keys());
+                targets.extend(else_scope.bindings.keys());
+                for target in targets {
+                    let (t, e) = match (
+                        then_scope.bindings.get(target),
+                        else_scope.bindings.get(target),
+                    ) {
+                        (Some(Binding::Var(t)), Some(Binding::Var(e))) => (t.clone(), e.clone()),
+                        (Some(Binding::Var(t)), None) => (t.clone(), self.read(target)?),
+                        (None, Some(Binding::Var(e))) => (self.read(target)?, e.clone()),
+                        _ => bail!("unable to merge conditional scopes"),
+                    };
+                    let phi = spec_if(cond.clone(), spec_var(t.clone()), spec_var(e.clone()));
+                    self.assign(target, phi)?;
+                }
+
+                // Merge additional scope metadata.
+                let joined = self.scope_mut();
+                joined.vars.extend(then_scope.vars.iter().cloned());
+                joined.vars.extend(else_scope.vars.iter().cloned());
+
+                joined.reads.extend(then_scope.reads.iter().cloned());
+                joined.reads.extend(else_scope.reads.iter().cloned());
+
+                joined.writes.extend(then_scope.writes.iter().cloned());
+                joined.writes.extend(else_scope.writes.iter().cloned());
+
+                // Exit if scope.
+                self.exit();
+
+                Ok(())
+            }
+            Stmt::Call {
+                func,
+                types: _,
+                args,
+            } => self.call(func, args),
+        }
+    }
+
+    fn assign(&mut self, target: &Target, rhs: SpecExpr) -> Result<()> {
+        // Bind the expression to a variable.
+        let v = self.bind(rhs)?;
+
+        // Write variable to the target.
+        self.write(target, &v);
+
+        Ok(())
+    }
+
+    // Bind expression to a variable and return it.
+    fn bind(&mut self, expr: SpecExpr) -> Result<String> {
+        let v = self.vars.alloc();
+        self.scope_mut().add_var(v.clone());
+        let lhs = spec_var(v.clone());
+        self.constrain(spec_eq(lhs, expr));
+        Ok(v)
+    }
+
+    fn expr(&mut self, expr: &Expr) -> Result<SpecExpr> {
+        match expr {
+            Expr::Apply { func, types, args } => self.func(func, types, args),
+            Expr::Var(..) | Expr::ArrayIndex { .. } | Expr::Field { .. } => {
+                let target: Target = expr.try_into()?;
+                Ok(spec_var(self.read(&target)?))
+            }
+            Expr::Slices { x, slices } => {
+                let slice = expect_unary(slices)?;
+                Ok(self.slice(x, slice)?)
+            }
+            Expr::LitBits(bits) => {
+                let val = u128::from_str_radix(bits, 2)?;
+                let width = bits.len();
+                Ok(spec_const_bit_vector(val, width))
+            }
+            Expr::LitInt(v) => {
+                let val = v.parse()?;
+                Ok(spec_const_int(val))
+            }
+        }
+    }
+
+    fn func(&mut self, func: &Func, types: &[Expr], args: &[Expr]) -> Result<SpecExpr> {
+        match func.name.as_str() {
+            "ZeroExtend" => {
+                let (x, w) = expect_binary(args)?;
+                let x = self.expr(x)?;
+                let w = expect_lit_int_as_usize(w)?;
+                Ok(spec_zero_ext(w, x))
+            }
+            "SignExtend" => {
+                let (x, w) = expect_binary(args)?;
+                let x = self.expr(x)?;
+                let w = expect_lit_int_as_usize(w)?;
+                Ok(spec_sign_ext(w, x))
+            }
+            "not_bool" => {
+                let x = expect_unary(args)?;
+                let x = self.expr(x)?;
+                Ok(spec_unary(SpecOp::Not, x))
+            }
+            "append_bits" => {
+                let (x, y) = expect_binary(args)?;
+                let x = self.expr(x)?;
+                let y = self.expr(y)?;
+                Ok(spec_binary(SpecOp::Concat, x, y))
+            }
+            "replicate_bits" => {
+                let (x, n) = expect_binary(args)?;
+                let x = self.expr(x)?;
+                let n = expect_lit_int_as_usize(n)?;
+                Ok(spec_binary(
+                    SpecOp::Replicate,
+                    x,
+                    spec_const_int(n.try_into()?),
+                ))
+            }
+            "not_bits" => {
+                let x = expect_unary(args)?;
+                let x = self.expr(x)?;
+                Ok(spec_unary(SpecOp::BVNot, x))
+            }
+            "cvt_bool_bv" => {
+                let b = expect_unary(args)?;
+                let b = self.expr(b)?;
+                Ok(spec_if(
+                    b,
+                    spec_const_bit_vector(1, 1),
+                    spec_const_bit_vector(0, 1),
+                ))
+            }
+            "cvt_bits_uint" => {
+                let x = expect_unary(args)?;
+                let x = self.expr(x)?;
+                Ok(spec_bv2nat(x))
+            }
+            "ite" => {
+                let (c, t, e) = expect_ternary(args)?;
+                Ok(spec_if(self.expr(c)?, self.expr(t)?, self.expr(e)?))
+            }
+            "and_bool" => {
+                // TODO(mbm): binary op helper
+                let (lhs, rhs) = expect_binary(args)?;
+                let lhs = self.expr(lhs)?;
+                let rhs = self.expr(rhs)?;
+                Ok(spec_binary(SpecOp::And, lhs, rhs))
+            }
+            "eq_bits" => {
+                // TODO(mbm): binary op helper
+                let (lhs, rhs) = expect_binary(args)?;
+                let lhs = self.expr(lhs)?;
+                let rhs = self.expr(rhs)?;
+                Ok(spec_binary(SpecOp::Eq, lhs, rhs))
+            }
+            "ne_bits" => {
+                // TODO(mbm): binary op helper
+                let (lhs, rhs) = expect_binary(args)?;
+                let lhs = self.expr(lhs)?;
+                let rhs = self.expr(rhs)?;
+                Ok(spec_unary(SpecOp::Not, spec_binary(SpecOp::Eq, lhs, rhs)))
+            }
+            "add_bits" => {
+                // TODO(mbm): binary op helper
+                // TODO(mbm): check type annotation on function matches type of operands?
+                let (lhs, rhs) = expect_binary(args)?;
+                let lhs = self.expr(lhs)?;
+                let rhs = self.expr(rhs)?;
+                Ok(spec_binary(SpecOp::BVAdd, lhs, rhs))
+            }
+            "sub_bits" => {
+                // TODO(mbm): binary op helper
+                // TODO(mbm): check type annotation on function matches type of operands?
+                let (lhs, rhs) = expect_binary(args)?;
+                let lhs = self.expr(lhs)?;
+                let rhs = self.expr(rhs)?;
+                Ok(spec_binary(SpecOp::BVSub, lhs, rhs))
+            }
+            "or_bits" => {
+                // TODO(mbm): binary op helper
+                let (lhs, rhs) = expect_binary(args)?;
+                let lhs = self.expr(lhs)?;
+                let rhs = self.expr(rhs)?;
+                Ok(spec_binary(SpecOp::BVOr, lhs, rhs))
+            }
+            "and_bits" => {
+                // TODO(mbm): binary op helper
+                let (lhs, rhs) = expect_binary(args)?;
+                let lhs = self.expr(lhs)?;
+                let rhs = self.expr(rhs)?;
+                Ok(spec_binary(SpecOp::BVAnd, lhs, rhs))
+            }
+            "eor_bits" => {
+                // TODO(mbm): binary op helper
+                let (lhs, rhs) = expect_binary(args)?;
+                let lhs = self.expr(lhs)?;
+                let rhs = self.expr(rhs)?;
+                Ok(spec_binary(SpecOp::BVXor, lhs, rhs))
+            }
+            "mul_bits" => {
+                // TODO(mbm): binary op helper
+                let (lhs, rhs) = expect_binary(args)?;
+                let lhs = self.expr(lhs)?;
+                let rhs = self.expr(rhs)?;
+                Ok(spec_binary(SpecOp::BVMul, lhs, rhs))
+            }
+            "sdiv_bits" => {
+                // TODO(mbm): binary op helper
+                let (lhs, rhs) = expect_binary(args)?;
+                let lhs = self.expr(lhs)?;
+                let rhs = self.expr(rhs)?;
+                Ok(spec_binary(SpecOp::BVSdiv, lhs, rhs))
+            }
+            "lsr_bits" => self.shift(SpecOp::BVLshr, types, args),
+            "asr_bits" => self.shift(SpecOp::BVAshr, types, args),
+            "lsl_bits" => self.shift(SpecOp::BVShl, types, args),
+            "sle_bits" => {
+                // TODO(mbm): binary op helper
+                let (lhs, rhs) = expect_binary(args)?;
+                let lhs = self.expr(lhs)?;
+                let rhs = self.expr(rhs)?;
+                Ok(spec_binary(SpecOp::BVSle, lhs, rhs))
+            }
+            "slt_bits" => {
+                // TODO(mbm): binary op helper
+                let (lhs, rhs) = expect_binary(args)?;
+                let lhs = self.expr(lhs)?;
+                let rhs = self.expr(rhs)?;
+                Ok(spec_binary(SpecOp::BVSlt, lhs, rhs))
+            }
+            "Mem.read" => {
+                let (addr, size, access) = expect_ternary(args)?;
+                self.mem_read(addr, size, access)
+            }
+            "FPAdd" | "FPSub" | "FPMul" | "FPDiv" | "FPMin" | "FPMax" | "FPCompare" | "FPSqrt"
+            | "FPRoundInt" => self.primitive(&func.name, args),
+            "FPConvert" | "FixedToFP" | "FPToFixed" => {
+                self.primitive_with_types(&func.name, types, args)
+            }
+            unexpected => todo!("func: {unexpected}"),
+        }
+    }
+
+    fn call(&mut self, func: &Func, args: &[Expr]) -> Result<()> {
+        match func.name.as_str() {
+            "Mem.set" => {
+                let (addr, size, access, value) = expect_quaternary(args)?;
+                self.mem_set(addr, size, access, value)
+            }
+            unexpected => todo!("call: {unexpected}"),
+        }
+    }
+
+    fn slice(&mut self, x: &Expr, slice: &Slice) -> Result<SpecExpr> {
+        match slice {
+            Slice::LowWidth(l, w) => {
+                let l = expect_lit_int_as_usize(l)?;
+                let w = expect_lit_int_as_usize(w)?;
+                let h = l + w - 1;
+                let x = self.expr(x)?;
+                Ok(spec_extract(h, l, x))
+            }
+        }
+    }
+
+    fn shift(&mut self, op: SpecOp, types: &[Expr], args: &[Expr]) -> Result<SpecExpr> {
+        // Map input and shift to spec expressions.
+        let (x, s) = expect_binary(args)?;
+        let x = self.expr(x)?;
+        let mut s = self.expr(s)?;
+
+        // ASLp maps the shift amount to a bit vector in an integer conversion
+        // pass, which can result in the shift argument being a different width
+        // than the input. If so, extend the shift to match.
+        let (xw, sw) = expect_binary_types(types)?;
+        match xw.cmp(&sw) {
+            Ordering::Greater => s = spec_zero_ext(xw, s),
+            Ordering::Equal => {}
+            Ordering::Less => panic!("shift argument wider than input"),
+        }
+
+        Ok(spec_binary(op, x, s))
+    }
+
+    fn mem_read(&mut self, addr: &Expr, size: &Expr, access: &Expr) -> Result<SpecExpr> {
+        // Map parameters to spec expressions.
+        let addr = self.expr(addr)?;
+        let size_bytes = expect_lit_int_as_usize(size)?;
+        let size_bits = 8 * size_bytes;
+        Self::check_supported_mem_access(access)?;
+
+        // Memory read operation modifies read effect variables.
+        let read_effect = ReadEffect::new();
+        self.assign(&read_effect.active, spec_true())?;
+        self.assign(
+            &read_effect.size_bits,
+            spec_const_int(size_bits.try_into()?),
+        )?;
+        self.assign(&read_effect.addr, addr)?;
+
+        let value = self.read(&read_effect.value)?;
+        Ok(spec_var(value))
+    }
+
+    fn mem_set(&mut self, addr: &Expr, size: &Expr, access: &Expr, value: &Expr) -> Result<()> {
+        // Map parameters to spec expressions.
+        let addr = self.expr(addr)?;
+        let size_bytes = expect_lit_int_as_usize(size)?;
+        let size_bits = 8 * size_bytes;
+        Self::check_supported_mem_access(access)?;
+        let value = self.expr(value)?;
+
+        // Memory set operation modifies set effect variables.
+        let set_effect = SetEffect::new();
+        self.assign(&set_effect.active, spec_true())?;
+        self.assign(&set_effect.size_bits, spec_const_int(size_bits.try_into()?))?;
+        self.assign(&set_effect.addr, addr)?;
+        self.assign(&set_effect.value, value)?;
+
+        Ok(())
+    }
+
+    fn check_supported_mem_access(access: &Expr) -> Result<()> {
+        // Should be a constant integer.
+        let access = expect_lit_int_as_usize(access)?;
+
+        // Access flags not fully implemented: error on unexpected value.
+        //
+        // First two access types: AccType_NORMAL, AccType_VEC.
+        if access > 1 {
+            bail!("unsupported memory read access type");
+        }
+        Ok(())
+    }
+
+    fn primitive(&mut self, name: &str, args: &[Expr]) -> Result<SpecExpr> {
+        Ok(SpecExpr::Expand {
+            name: spec_ident(name.to_string()),
+            args: args
+                .iter()
+                .map(|arg| self.expr(arg))
+                .collect::<Result<_>>()?,
+            pos: Pos::default(),
+        })
+    }
+
+    fn primitive_with_types(
+        &mut self,
+        name: &str,
+        types: &[Expr],
+        args: &[Expr],
+    ) -> Result<SpecExpr> {
+        let all_args = args.iter().chain(types);
+        Ok(SpecExpr::Expand {
+            name: spec_ident(name.to_string()),
+            args: all_args.map(|arg| self.expr(arg)).collect::<Result<_>>()?,
+            pos: Pos::default(),
+        })
+    }
+}
+
+fn expect_unary<T>(xs: &[T]) -> Result<&T> {
+    if xs.len() != 1 {
+        bail!("expected unary");
+    }
+    Ok(&xs[0])
+}
+
+fn expect_binary<T>(xs: &[T]) -> Result<(&T, &T)> {
+    if xs.len() != 2 {
+        bail!("expected binary");
+    }
+    Ok((&xs[0], &xs[1]))
+}
+
+fn expect_ternary<T>(xs: &[T]) -> Result<(&T, &T, &T)> {
+    if xs.len() != 3 {
+        bail!("expected ternary");
+    }
+    Ok((&xs[0], &xs[1], &xs[2]))
+}
+
+fn expect_quaternary<T>(xs: &[T]) -> Result<(&T, &T, &T, &T)> {
+    if xs.len() != 4 {
+        bail!("expected quaternary");
+    }
+    Ok((&xs[0], &xs[1], &xs[2], &xs[3]))
+}
+
+fn expect_binary_types(types: &[Expr]) -> Result<(usize, usize)> {
+    let (t1, t2) = expect_binary(types)?;
+    Ok((expect_lit_int_as_usize(t1)?, expect_lit_int_as_usize(t2)?))
+}
+
+fn expect_lit_int_as_usize(expr: &Expr) -> Result<usize> {
+    Ok(expr
+        .as_lit_int()
+        .ok_or(format_err!("expected literal integer"))?
+        .parse()?)
+}
diff --git a/cranelift/isle/veri/isaspec/src/instructions.rs b/cranelift/isle/veri/isaspec/src/instructions.rs
new file mode 100644
index 000000000000..b35c517fbbb5
--- /dev/null
+++ b/cranelift/isle/veri/isaspec/src/instructions.rs
@@ -0,0 +1,2318 @@
+use crate::{
+    aarch64,
+    bits::{Bits, Segment},
+    builder::{
+        Arm, Case, Cases, InstConfig, Mapping, MappingBuilder, Mappings, Match, Opcodes, SpecConfig,
+    },
+    configure::{flags_mappings, reg_target, spec_fp_reg, verify_opcode_template},
+    constraints::Target,
+    memory::{ReadEffect, SetEffect},
+    spec::{
+        spec_as_bit_vector_width, spec_binary, spec_const_bit_vector, spec_const_int,
+        spec_discriminator, spec_eq, spec_eq_bool, spec_extract, spec_false, spec_field, spec_true,
+        spec_var,
+    },
+    spec_config,
+};
+use anyhow::Result;
+use cranelift_codegen::{
+    ir::{types::I8, MemFlags},
+    isa::aarch64::inst::{
+        vreg, writable_vreg, writable_xreg, xreg, ALUOp, ALUOp3, AMode, ASIMDFPModImm,
+        ASIMDMovModImm, BitOp, Cond, ExtendOp, FPULeftShiftImm, FPUOp1, FPUOp2, FPUOpRI,
+        FPUOpRIMod, FPURightShiftImm, FpuRoundMode, FpuToIntOp, Imm12, Inst, IntToFpuOp,
+        MoveWideConst, MoveWideOp, OperandSize, SImm9, ScalarSize, ShiftOp, ShiftOpAndAmt,
+        ShiftOpShiftImm, UImm12Scaled, UImm5, VecALUOp, VecLanesOp, VecMisc2, VectorSize, NZCV,
+    },
+    Reg, Writable,
+};
+use cranelift_isle::ast::{SpecExpr, SpecOp};
+use itertools::Itertools;
+use std::collections::HashMap;
+use std::path::PathBuf;
+use std::vec;
+
+/// Configuration for an ISLE specification file to generate.
+pub struct FileConfig {
+    pub name: PathBuf,
+    pub specs: Vec<SpecConfig>,
+}
+
+/// Define specifications to generate.
+pub fn define() -> Result<Vec<FileConfig>> {
+    Ok(vec![
+        FileConfig {
+            name: "alu_rrr.isle".into(),
+            specs: vec![define_alu_rrr()],
+        },
+        FileConfig {
+            name: "alu_rrrr.isle".into(),
+            specs: vec![define_alu_rrrr()],
+        },
+        FileConfig {
+            name: "alu_rr_imm12.isle".into(),
+            specs: vec![define_alu_rr_imm12()?],
+        },
+        FileConfig {
+            name: "alu_rrr_shift.isle".into(),
+            specs: vec![define_alu_rrr_shift()?],
+        },
+        FileConfig {
+            name: "alu_rrr_extend.isle".into(),
+            specs: vec![define_alu_rrr_extend()],
+        },
+        FileConfig {
+            name: "bit_rr.isle".into(),
+            specs: vec![define_bit_rr()],
+        },
+        FileConfig {
+            name: "loads.isle".into(),
+            specs: define_loads()?,
+        },
+        FileConfig {
+            name: "stores.isle".into(),
+            specs: define_stores()?,
+        },
+        FileConfig {
+            name: "mov_wide.isle".into(),
+            specs: vec![define_mov_wide()?],
+        },
+        FileConfig {
+            name: "extend.isle".into(),
+            specs: vec![define_extend()],
+        },
+        FileConfig {
+            name: "conds.isle".into(),
+            specs: define_conds()?,
+        },
+        FileConfig {
+            name: "fpu_move_imm.isle".into(),
+            specs: vec![define_fpu_move_imm()],
+        },
+        FileConfig {
+            name: "fpu_cmp.isle".into(),
+            specs: vec![define_fpu_cmp()],
+        },
+        FileConfig {
+            name: "fpu_rr.isle".into(),
+            specs: vec![define_fpu_rr()],
+        },
+        FileConfig {
+            name: "fpu_round.isle".into(),
+            specs: vec![define_fpu_round()],
+        },
+        FileConfig {
+            name: "fpu_rri.isle".into(),
+            specs: vec![define_fpu_rri()],
+        },
+        FileConfig {
+            name: "fpu_rrimod.isle".into(),
+            specs: vec![define_fpu_rrimod()],
+        },
+        FileConfig {
+            name: "fpu_rrr.isle".into(),
+            specs: vec![define_fpu_rrr()],
+        },
+        FileConfig {
+            name: "mov_to_fpu.isle".into(),
+            specs: vec![define_mov_to_fpu()],
+        },
+        FileConfig {
+            name: "int_to_fpu.isle".into(),
+            specs: vec![define_int_to_fpu()],
+        },
+        FileConfig {
+            name: "fpu_to_int.isle".into(),
+            specs: vec![define_fpu_to_int()],
+        },
+        FileConfig {
+            name: "mov_from_vec.isle".into(),
+            specs: vec![define_mov_from_vec()],
+        },
+        FileConfig {
+            name: "vec_dup_imm.isle".into(),
+            specs: vec![define_vec_dup_imm()?],
+        },
+        FileConfig {
+            name: "vec_rrr.isle".into(),
+            specs: vec![define_vec_rrr()],
+        },
+        FileConfig {
+            name: "vec_misc.isle".into(),
+            specs: vec![define_vec_misc()],
+        },
+        FileConfig {
+            name: "vec_lanes.isle".into(),
+            specs: vec![define_vec_lanes()],
+        },
+    ])
+}
+
+// MInst.AluRRR specification configuration.
+fn define_alu_rrr() -> SpecConfig {
+    let sizes = [OperandSize::Size64, OperandSize::Size32];
+    let alu_ops = [
+        ALUOp::Add,
+        ALUOp::Sub,
+        ALUOp::Orr,
+        ALUOp::OrrNot,
+        ALUOp::And,
+        ALUOp::AndNot,
+        ALUOp::Eor,
+        ALUOp::EorNot,
+        ALUOp::AddS,
+        ALUOp::SubS,
+        ALUOp::SMulH,
+        ALUOp::UMulH,
+        ALUOp::SDiv,
+        ALUOp::UDiv,
+        ALUOp::RotR,
+        ALUOp::Lsr,
+        ALUOp::Asr,
+        ALUOp::Lsl,
+        ALUOp::Adc,
+        // Flag ops not required yet:
+        // ALUOp::Sbc,
+        // ALUOp::AdcS,
+        // ALUOp::SbcS,
+    ];
+
+    spec_config! {
+        (AluRRR alu_op size rd rn rm)
+        {
+            enumerate   (size, sizes);
+            enumerate   (alu_op, alu_ops);
+            register    (rd, write, gp, 4);
+            register    (rn, read,  gp, 5);
+            register    (rm, read,  gp, 6);
+            filter      (is_alu_op_size_supported(alu_op, size));
+            flags       ();
+            instruction ();
+        }
+    }
+}
+
+fn is_alu_op_size_supported(alu_op: ALUOp, size: OperandSize) -> bool {
+    match alu_op {
+        ALUOp::SMulH | ALUOp::UMulH | ALUOp::SDiv | ALUOp::UDiv => size == OperandSize::Size64,
+        _ => true,
+    }
+}
+
+// MInst.AluRRRR specification configuration.
+fn define_alu_rrrr() -> SpecConfig {
+    let sizes = [OperandSize::Size64, OperandSize::Size32];
+    let alu3_ops = [ALUOp3::MAdd, ALUOp3::MSub, ALUOp3::UMAddL, ALUOp3::SMAddL];
+    spec_config! {
+        (AluRRRR alu_op size rd rn rm ra)
+        {
+            enumerate   (size, sizes);
+            enumerate   (alu_op, alu3_ops);
+            register    (rd, write, gp, 4);
+            register    (rn, read,  gp, 5);
+            register    (rm, read,  gp, 6);
+            register    (ra, read,  gp, 7);
+            filter      (is_alu3_op_size_supported(alu_op, size));
+            instruction ();
+        }
+    }
+}
+
+fn is_alu3_op_size_supported(alu3_op: ALUOp3, size: OperandSize) -> bool {
+    match alu3_op {
+        ALUOp3::UMAddL | ALUOp3::SMAddL => size == OperandSize::Size32,
+        _ => true,
+    }
+}
+
+// MInst.AluRRImm12 specification configuration.
+fn define_alu_rr_imm12() -> Result<SpecConfig> {
+    // ALUOps supported by AluRRImm12.
+    let alu_ops = [ALUOp::Add, ALUOp::Sub, ALUOp::AddS, ALUOp::SubS];
+
+    // OperandSize
+    let sizes = [OperandSize::Size32, OperandSize::Size64];
+
+    // Imm12.shift12
+    let shift12s = [false, true];
+
+    // Execution scope: define opcode template fields.
+    let mut scope = aarch64::state();
+    let imm12_bits = Target::Var("bits".to_string());
+    scope.global(imm12_bits.clone());
+
+    // Mappings
+    let mut mappings = flags_mappings();
+    mappings.writes.insert(
+        aarch64::gpreg(4),
+        Mapping::require(spec_var("rd".to_string())),
+    );
+    mappings.reads.insert(
+        aarch64::gpreg(5),
+        Mapping::require(spec_var("rn".to_string())),
+    );
+    mappings.reads.insert(
+        imm12_bits.clone(),
+        MappingBuilder::var("imm12").field("bits").build(),
+    );
+
+    Ok(SpecConfig {
+        term: "MInst.AluRRImm12".to_string(),
+        args: ["alu_op", "size", "rd", "rn", "imm12"]
+            .map(String::from)
+            .to_vec(),
+        cases: Cases::Match(Match {
+            on: spec_var("size".to_string()),
+            arms: sizes
+                .iter()
+                .rev()
+                .map(|size| {
+                    Ok(Arm {
+                        variant: format!("{size:?}"),
+                        args: Vec::new(),
+                        body: Cases::Match(Match {
+                            on: spec_var("alu_op".to_string()),
+                            arms: alu_ops
+                                .iter()
+                                .map(|alu_op| {
+                                    Ok(Arm {
+                                        variant: format!("{alu_op:?}"),
+                                        args: Vec::new(),
+                                        body: Cases::Cases(
+                                            shift12s
+                                                .iter()
+                                                .map(|shift12| {
+                                                    let template = alu_rr_imm12_template(
+                                                        *alu_op,
+                                                        *size,
+                                                        writable_xreg(4),
+                                                        xreg(5),
+                                                        *shift12,
+                                                    )?;
+                                                    Ok(Case {
+                                                        conds: vec![spec_eq_bool(
+                                                            spec_field(
+                                                                "shift12".to_string(),
+                                                                spec_var("imm12".to_string()),
+                                                            ),
+                                                            *shift12,
+                                                        )],
+                                                        cases: Cases::Instruction(InstConfig {
+                                                            opcodes: Opcodes::Template(template),
+                                                            scope: scope.clone(),
+                                                            mappings: mappings.clone(),
+                                                        }),
+                                                    })
+                                                })
+                                                .collect::<Result<_>>()?,
+                                        ),
+                                    })
+                                })
+                                .collect::<Result<_>>()?,
+                        }),
+                    })
+                })
+                .collect::<Result<_>>()?,
+        }),
+    })
+}
+
+fn alu_rr_imm12_template(
+    alu_op: ALUOp,
+    size: OperandSize,
+    rd: Writable<Reg>,
+    rn: Reg,
+    shift12: bool,
+) -> Result<Bits> {
+    // Assemble a base instruction with a placeholder for the imm12 field.
+    let placeholder = Imm12 { bits: 0, shift12 };
+    let base = Inst::AluRRImm12 {
+        alu_op,
+        size,
+        rd,
+        rn,
+        imm12: placeholder,
+    };
+    let opcode = aarch64::opcode(&base);
+    let bits = Bits::from_u32(opcode);
+
+    // Splice in symbolic immediate fields.
+    let imm = Bits {
+        segments: vec![Segment::Symbolic("bits".to_string(), 12)],
+    };
+    let template = Bits::splice(&bits, &imm, 10)?;
+
+    // Verify template against the assembler.
+    verify_opcode_template(&template, |assignment: &HashMap<String, u32>| {
+        let bits = assignment.get("bits").unwrap();
+        let imm12 = Imm12 {
+            bits: (*bits).try_into().unwrap(),
+            shift12,
+        };
+        Ok(Inst::AluRRImm12 {
+            alu_op,
+            size,
+            rd,
+            rn,
+            imm12,
+        })
+    })?;
+
+    Ok(template)
+}
+
+// MInst.AluRRRShift specification configuration.
+fn define_alu_rrr_shift() -> Result<SpecConfig> {
+    // ALUOps supported by AluRRImm12.
+    let alu_ops = [
+        ALUOp::Add,
+        ALUOp::Sub,
+        ALUOp::Orr,
+        ALUOp::And,
+        ALUOp::Eor,
+        ALUOp::OrrNot,
+        ALUOp::EorNot,
+        ALUOp::AndNot,
+        // Flags:
+        // ALUOp::AddS,
+        // ALUOp::SubS,
+        // ALUOp::AndS,
+    ];
+
+    // OperandSize
+    let sizes = [OperandSize::Size32, OperandSize::Size64];
+
+    // ShiftOp
+    let shiftops = [
+        ShiftOp::LSL,
+        ShiftOp::LSR,
+        ShiftOp::ASR,
+        // ShiftOp::ROR is defined variant but actually not a valid opcode
+    ];
+
+    Ok(SpecConfig {
+        term: "MInst.AluRRRShift".to_string(),
+        args: ["alu_op", "size", "rd", "rn", "rm", "shiftop"]
+            .map(String::from)
+            .to_vec(),
+        cases: Cases::Match(Match {
+            on: spec_var("alu_op".to_string()),
+            arms: alu_ops
+                .iter()
+                .map(|alu_op| {
+                    Ok(Arm {
+                        variant: format!("{alu_op:?}"),
+                        args: Vec::new(),
+
+                        // Shift operation cases.
+                        //
+                        // Note that the `ShiftOpAndAmt` model actually uses
+                        // `ALUOp` to represent the shift operation.  ISLE does
+                        // not actually materialize the ShiftOp type itself, and
+                        // without support for ghost types, we cannot represent
+                        // it.  Therefore, co-opting ALUOp for the purpose is
+                        // the best we can do.
+                        body: Cases::Match(Match {
+                            on: spec_field("op".to_string(), spec_var("shiftop".to_string())),
+                            arms: shiftops
+                                .iter()
+                                .map(|shiftop| {
+                                    // Map shift operation to the correspondong ALUOp.
+                                    let alu_shift_op = alu_op_from_shiftop(*shiftop);
+                                    Ok(Arm {
+                                        variant: format!("{alu_shift_op:?}"),
+                                        args: Vec::new(),
+                                        body: Cases::Cases(
+                                            sizes
+                                                .iter()
+                                                .rev()
+                                                .map(|size| {
+                                                    alu_rrr_shift_size_case(
+                                                        *alu_op, *size, *shiftop,
+                                                    )
+                                                })
+                                                .collect::<Result<_>>()?,
+                                        ),
+                                    })
+                                })
+                                .collect::<Result<_>>()?,
+                        }),
+                    })
+                })
+                .collect::<Result<_>>()?,
+        }),
+    })
+}
+
+fn alu_rrr_shift_size_case(alu_op: ALUOp, size: OperandSize, op: ShiftOp) -> Result<Case> {
+    // Shift amount field depends on operand size.
+    let amt_width = match size {
+        OperandSize::Size32 => 5,
+        OperandSize::Size64 => 6,
+    };
+    let amt_var = format!("amt{}", amt_width);
+
+    // Setup scope with shift amount variable.
+    let amt_target = Target::Var(amt_var.clone());
+    let mut scope = aarch64::state();
+    scope.global(amt_target.clone());
+
+    // Expressions for the shift amount.
+    //
+    // The model of the shift amount is an 8 bit value, but the instruction
+    // representations only allow 5 or 6 bits (depending on operand size).  We
+    // extract the shift bits from the operand, and require that the higher bits
+    // are zero.
+    static FULL_AMT_WIDTH: usize = 8;
+    let full_amt_expr = spec_field("amt".to_string(), spec_var("shiftop".to_string()));
+    let amt_expr = spec_extract(amt_width - 1, 0, full_amt_expr.clone());
+    let amt_overflow_expr = spec_extract(FULL_AMT_WIDTH - 1, amt_width, full_amt_expr.clone());
+    let amt_overflow_width = FULL_AMT_WIDTH - amt_width;
+    let no_amt_overflow = spec_eq(
+        amt_overflow_expr,
+        spec_const_bit_vector(0, amt_overflow_width),
+    );
+
+    // Mappings
+    let mut mappings = flags_mappings();
+    mappings.writes.insert(
+        aarch64::gpreg(4),
+        Mapping::require(spec_var("rd".to_string())),
+    );
+    mappings.reads.insert(
+        aarch64::gpreg(5),
+        Mapping::require(spec_var("rn".to_string())),
+    );
+    mappings.reads.insert(
+        aarch64::gpreg(6),
+        Mapping::require(spec_var("rm".to_string())),
+    );
+    mappings
+        .reads
+        .insert(amt_target.clone(), Mapping::require(amt_expr.clone()));
+
+    // Opcode template
+    //
+    // Assemble a base instruction with a placeholder for the shift amount.
+    let placeholder = ShiftOpShiftImm::maybe_from_shift(0).unwrap();
+    let rd = writable_xreg(4);
+    let rn = xreg(5);
+    let rm = xreg(6);
+    let shiftop = ShiftOpAndAmt::new(op, placeholder);
+    let base = Inst::AluRRRShift {
+        alu_op,
+        size,
+        rd,
+        rn,
+        rm,
+        shiftop,
+    };
+    let opcode = aarch64::opcode(&base);
+    let bits = Bits::from_u32(opcode);
+
+    // Splice in symbolic shift amount.
+    //
+    // The shift amount is 6 bits in the 64-bit case, and 5 bits in the 32-bit
+    // case.  Note that in the 32-bit case, the instruction is explicitly
+    // undefined when bit 5 is 1. Therefore, we must ensure that the symbolic
+    // field variable is only 5 bits.
+    let amt = Bits {
+        segments: vec![Segment::Symbolic(amt_var.to_string(), amt_width)],
+    };
+    let template = Bits::splice(&bits, &amt, 10)?;
+
+    // Verify template against the assembler.
+    verify_opcode_template(&template, |assignment: &HashMap<String, u32>| {
+        let amt = assignment.get(&amt_var).unwrap();
+        let shift = ShiftOpShiftImm::maybe_from_shift((*amt).into()).unwrap();
+        let shiftop = ShiftOpAndAmt::new(op, shift);
+        Ok(Inst::AluRRRShift {
+            alu_op,
+            size,
+            rd,
+            rn,
+            rm,
+            shiftop,
+        })
+    })?;
+
+    Ok(Case {
+        conds: vec![
+            spec_discriminator(format!("{size:?}"), spec_var("size".to_string())),
+            no_amt_overflow,
+        ],
+        cases: Cases::Instruction(InstConfig {
+            opcodes: Opcodes::Template(template),
+            scope: scope.clone(),
+            mappings: mappings.clone(),
+        }),
+    })
+}
+
+fn alu_op_from_shiftop(op: ShiftOp) -> ALUOp {
+    match op {
+        ShiftOp::LSL => ALUOp::Lsl,
+        ShiftOp::LSR => ALUOp::Lsr,
+        ShiftOp::ASR => ALUOp::Asr,
+        ShiftOp::ROR => ALUOp::RotR,
+    }
+}
+
+// MInst.AluRRRExtend specification configuration.
+fn define_alu_rrr_extend() -> SpecConfig {
+    // ALUOps supported by AluRRRExtend.
+    let alu_ops = [ALUOp::Add, ALUOp::Sub, ALUOp::AddS, ALUOp::SubS];
+
+    // OperandSize
+    let sizes = [OperandSize::Size64, OperandSize::Size32];
+
+    // ExtendOp
+    let extendops = [
+        ExtendOp::UXTB,
+        ExtendOp::UXTH,
+        ExtendOp::UXTW,
+        ExtendOp::UXTX,
+        ExtendOp::SXTB,
+        ExtendOp::SXTH,
+        ExtendOp::SXTW,
+        ExtendOp::SXTX,
+    ];
+
+    spec_config! {
+        (AluRRRExtend alu_op size rd rn rm extendop)
+        {
+            enumerate   (size, sizes);
+            enumerate   (alu_op, alu_ops);
+            register    (rd, write, gp, 4);
+            register    (rn, read,  gp, 5);
+            register    (rm, read,  gp, 6);
+            enumerate   (extendop, extendops);
+            flags       ();
+            instruction ();
+        }
+    }
+}
+
+// MInst.BitRR specification configuration.
+fn define_bit_rr() -> SpecConfig {
+    // BitRR
+    let bit_ops = [
+        BitOp::Cls,
+        BitOp::RBit,
+        BitOp::Clz,
+        // --------------
+        // BitOp::Rev16,
+        // BitOp::Rev32,
+        // BitOp::Rev64,
+    ];
+
+    // OperandSize
+    let sizes = [OperandSize::Size64, OperandSize::Size32];
+
+    spec_config! {
+        (BitRR op size rd rn)
+        {
+            enumerate   (size, sizes);
+            enumerate   (op, bit_ops);
+            register    (rd, write, gp, 4);
+            register    (rn, read,  gp64, 5);
+            instruction ();
+        }
+    }
+}
+
+// MInst.MovWide specification configuration.
+fn define_mov_wide() -> Result<SpecConfig> {
+    // MovWideOps
+    let mov_wide_ops = [MoveWideOp::MovZ, MoveWideOp::MovN];
+
+    // OperandSize
+    let sizes = [OperandSize::Size32, OperandSize::Size64];
+
+    // Execution scope: define opcode template fields.
+    let mut scope = aarch64::state();
+    let mov_wide_const_bits = Target::Var("bits".to_string());
+    scope.global(mov_wide_const_bits.clone());
+
+    // Mappings
+    let mut mappings = Mappings::default();
+    mappings.writes.insert(
+        aarch64::gpreg(4),
+        Mapping::require(spec_var("rd".to_string())),
+    );
+    mappings.reads.insert(
+        mov_wide_const_bits.clone(),
+        MappingBuilder::var("imm").field("bits").build(),
+    );
+
+    Ok(SpecConfig {
+        term: "MInst.MovWide".to_string(),
+        args: ["op", "rd", "imm", "size"].map(String::from).to_vec(),
+        cases: Cases::Match(Match {
+            on: spec_var("size".to_string()),
+            arms: sizes
+                .iter()
+                .rev()
+                .map(|size| {
+                    let max_shift = size.bits() / 16;
+                    Ok(Arm {
+                        variant: format!("{size:?}"),
+                        args: Vec::new(),
+                        body: Cases::Match(Match {
+                            on: spec_var("op".to_string()),
+                            arms: mov_wide_ops
+                                .iter()
+                                .map(|mov_wide_op| {
+                                    Ok(Arm {
+                                        variant: format!("{mov_wide_op:?}"),
+                                        args: Vec::new(),
+                                        body: Cases::Cases(
+                                            (0..max_shift)
+                                                .map(|shift| {
+                                                    let template = mov_wide_template(
+                                                        *mov_wide_op,
+                                                        writable_xreg(4),
+                                                        shift,
+                                                        *size,
+                                                    )?;
+                                                    Ok(Case {
+                                                        conds: vec![spec_eq(
+                                                            spec_field(
+                                                                "shift".to_string(),
+                                                                spec_var("imm".to_string()),
+                                                            ),
+                                                            spec_const_bit_vector(shift.into(), 2),
+                                                        )],
+                                                        cases: Cases::Instruction(InstConfig {
+                                                            opcodes: Opcodes::Template(template),
+                                                            scope: scope.clone(),
+                                                            mappings: mappings.clone(),
+                                                        }),
+                                                    })
+                                                })
+                                                .collect::<Result<_>>()?,
+                                        ),
+                                    })
+                                })
+                                .collect::<Result<_>>()?,
+                        }),
+                    })
+                })
+                .collect::<Result<_>>()?,
+        }),
+    })
+}
+
+fn mov_wide_template(
+    op: MoveWideOp,
+    rd: Writable<Reg>,
+    shift: u8,
+    size: OperandSize,
+) -> Result<Bits> {
+    // Assemble a base instruction with a placeholder for the immediate bits field.
+    let placeholder = MoveWideConst { bits: 0, shift };
+    let base = Inst::MovWide {
+        op,
+        rd,
+        imm: placeholder,
+        size,
+    };
+    let opcode = aarch64::opcode(&base);
+    let bits = Bits::from_u32(opcode);
+
+    // Splice in symbolic immediate fields.
+    let imm = Bits {
+        segments: vec![Segment::Symbolic("bits".to_string(), 16)],
+    };
+    let template = Bits::splice(&bits, &imm, 5)?;
+
+    // Verify template against the assembler.
+    verify_opcode_template(&template, |assignment: &HashMap<String, u32>| {
+        let bits = assignment.get("bits").unwrap();
+        let imm = MoveWideConst {
+            bits: (*bits).try_into().unwrap(),
+            shift,
+        };
+        Ok(Inst::MovWide { op, rd, imm, size })
+    })?;
+
+    Ok(template)
+}
+
+fn define_extend() -> SpecConfig {
+    // Extend
+    let signed = [false, true];
+    let bits = [8u8, 16u8, 32u8, 64u8];
+
+    let mut mappings = Mappings::default();
+    mappings.writes.insert(
+        aarch64::gpreg(4),
+        Mapping::require(spec_var("rd".to_string())),
+    );
+    mappings.reads.insert(
+        aarch64::gpreg(5),
+        Mapping::require(spec_as_bit_vector_width(spec_var("rn".to_string()), 64)),
+    );
+
+    SpecConfig {
+        // Spec signature.
+        term: "MInst.Extend".to_string(),
+        args: ["rd", "rn", "signed", "from_bits", "to_bits"]
+            .map(String::from)
+            .to_vec(),
+        cases: Cases::Cases(
+            bits.iter()
+                .cartesian_product(&bits)
+                .filter(|(from_bits, to_bits)| from_bits <= to_bits && **from_bits < 64)
+                .cartesian_product(&signed)
+                .map(|((from_bits, to_bits), signed)| Case {
+                    conds: vec![
+                        spec_eq_bool(spec_var("signed".to_string()), *signed),
+                        spec_eq(
+                            spec_var("from_bits".to_string()),
+                            spec_const_bit_vector((*from_bits).into(), 8),
+                        ),
+                        spec_eq(
+                            spec_var("to_bits".to_string()),
+                            spec_const_bit_vector((*to_bits).into(), 8),
+                        ),
+                    ],
+                    cases: Cases::Instruction(InstConfig {
+                        // Instruction to generate specification from.
+                        opcodes: Opcodes::Instruction(Inst::Extend {
+                            rd: writable_xreg(4),
+                            rn: xreg(5),
+                            signed: *signed,
+                            from_bits: *from_bits,
+                            to_bits: *to_bits,
+                        }),
+                        scope: aarch64::state(),
+                        mappings: mappings.clone(),
+                    }),
+                })
+                .collect(),
+        ),
+    }
+}
+
+fn define_loads() -> Result<Vec<SpecConfig>> {
+    // Destination register for general-purpose loads.
+    let dst = writable_xreg(4);
+    let rd = spec_var("rd".to_string());
+
+    // ULoad8
+    let uload8 = define_load("MInst.ULoad8", 8, dst, &rd, |rd, mem, flags| Inst::ULoad8 {
+        rd,
+        mem,
+        flags,
+    })?;
+
+    // SLoad8
+    let sload8 = define_load("MInst.SLoad8", 8, dst, &rd, |rd, mem, flags| Inst::SLoad8 {
+        rd,
+        mem,
+        flags,
+    })?;
+
+    // ULoad16
+    let uload16 = define_load("MInst.ULoad16", 16, dst, &rd, |rd, mem, flags| {
+        Inst::ULoad16 { rd, mem, flags }
+    })?;
+
+    // SLoad16
+    let sload16 = define_load("MInst.SLoad16", 16, dst, &rd, |rd, mem, flags| {
+        Inst::SLoad16 { rd, mem, flags }
+    })?;
+
+    // ULoad32
+    let uload32 = define_load("MInst.ULoad32", 32, dst, &rd, |rd, mem, flags| {
+        Inst::ULoad32 { rd, mem, flags }
+    })?;
+
+    // SLoad32
+    let sload32 = define_load("MInst.SLoad32", 32, dst, &rd, |rd, mem, flags| {
+        Inst::SLoad32 { rd, mem, flags }
+    })?;
+
+    // ULoad64
+    let uload64 = define_load("MInst.ULoad64", 64, dst, &rd, |rd, mem, flags| {
+        Inst::ULoad64 { rd, mem, flags }
+    })?;
+
+    // Destination register for floating-point loads.
+    let dst = writable_vreg(4);
+    let rd = spec_fp_reg("rd");
+
+    // FpuLoad32
+    let fpu_load32 = define_load("MInst.FpuLoad32", 32, dst, &rd, |rd, mem, flags| {
+        Inst::FpuLoad32 { rd, mem, flags }
+    })?;
+
+    // FpuLoad64
+    let fpu_load64 = define_load("MInst.FpuLoad64", 64, dst, &rd, |rd, mem, flags| {
+        Inst::FpuLoad64 { rd, mem, flags }
+    })?;
+
+    Ok(vec![
+        uload8, sload8, uload16, sload16, uload32, sload32, uload64, fpu_load32, fpu_load64,
+    ])
+}
+
+fn define_load<F>(
+    term: &str,
+    size_bits: usize,
+    dst: Writable<Reg>,
+    rd: &SpecExpr,
+    inst: F,
+) -> Result<SpecConfig>
+where
+    F: Fn(Writable<Reg>, AMode, MemFlags) -> Inst,
+{
+    // Mappings.
+    let mut mappings = Mappings::default();
+
+    // Destination register.
+    mappings
+        .writes
+        .insert(reg_target(dst.to_reg())?, Mapping::require(rd.clone()));
+
+    // ISA load state mapped to read effect.
+    let read_effect = ReadEffect::new();
+    static ISA_LOAD: &str = "isa_load";
+    static LOADED_VALUE: &str = "loaded_value";
+    mappings.writes.insert(
+        read_effect.active,
+        MappingBuilder::state(ISA_LOAD).field("active").build(),
+    );
+    mappings.writes.insert(
+        read_effect.addr,
+        MappingBuilder::state(ISA_LOAD).field("addr").build(),
+    );
+    mappings.writes.insert(
+        read_effect.size_bits,
+        MappingBuilder::state(ISA_LOAD).field("size_bits").build(),
+    );
+    mappings.reads.insert(
+        read_effect.value,
+        Mapping::require(spec_binary(
+            SpecOp::ConvTo,
+            spec_const_int(size_bits.try_into().unwrap()),
+            spec_var(LOADED_VALUE.to_string()),
+        )),
+    );
+
+    // Enumerate AModes.
+    let arms = amode_cases(&mappings, |mem, flags| inst(dst, mem, flags))?;
+
+    Ok(SpecConfig {
+        term: term.to_string(),
+        args: ["rd", "mem", "flags"].map(String::from).to_vec(),
+        cases: Cases::Match(Match {
+            on: spec_var("mem".to_string()),
+            arms,
+        }),
+    })
+}
+
+fn define_stores() -> Result<Vec<SpecConfig>> {
+    // Source register for general-purpose loads.
+    let src = xreg(4);
+    let rd = spec_as_bit_vector_width(spec_var("rd".to_string()), 64);
+
+    // Store8
+    let store8 = define_store("MInst.Store8", 8, src, &rd, |rd, mem, flags| Inst::Store8 {
+        rd,
+        mem,
+        flags,
+    })?;
+
+    // Store16
+    let store16 = define_store("MInst.Store16", 16, src, &rd, |rd, mem, flags| {
+        Inst::Store16 { rd, mem, flags }
+    })?;
+
+    // Store32
+    let store32 = define_store("MInst.Store32", 32, src, &rd, |rd, mem, flags| {
+        Inst::Store32 { rd, mem, flags }
+    })?;
+
+    // Store64
+    let store64 = define_store("MInst.Store64", 64, src, &rd, |rd, mem, flags| {
+        Inst::Store64 { rd, mem, flags }
+    })?;
+
+    // Source register for floating-point stores.
+    let src = vreg(4);
+    let rd = spec_fp_reg("rd");
+
+    // FpuStore32
+    let fpu_store32 = define_store("MInst.FpuStore32", 32, src, &rd, |rd, mem, flags| {
+        Inst::FpuStore32 { rd, mem, flags }
+    })?;
+
+    // FpuStore64
+    let fpu_store64 = define_store("MInst.FpuStore64", 64, src, &rd, |rd, mem, flags| {
+        Inst::FpuStore64 { rd, mem, flags }
+    })?;
+
+    Ok(vec![
+        store8,
+        store16,
+        store32,
+        store64,
+        fpu_store32,
+        fpu_store64,
+    ])
+}
+
+fn define_store<F>(
+    term: &str,
+    size_bits: usize,
+    src: Reg,
+    rd: &SpecExpr,
+    inst: F,
+) -> Result<SpecConfig>
+where
+    F: Fn(Reg, AMode, MemFlags) -> Inst,
+{
+    // Mappings.
+    let mut mappings = Mappings::default();
+
+    // Source register.
+    mappings
+        .reads
+        .insert(reg_target(src)?, Mapping::require(rd.clone()));
+
+    // ISA store state mapped to memory set effect.
+    let set_effect = SetEffect::new();
+    static ISA_STORE: &str = "isa_store";
+    mappings.writes.insert(
+        set_effect.active,
+        MappingBuilder::state(ISA_STORE).field("active").build(),
+    );
+    mappings.writes.insert(
+        set_effect.addr,
+        MappingBuilder::state(ISA_STORE).field("addr").build(),
+    );
+    mappings.writes.insert(
+        set_effect.size_bits,
+        MappingBuilder::state(ISA_STORE).field("size_bits").build(),
+    );
+    mappings.writes.insert(
+        set_effect.value,
+        MappingBuilder::new(spec_binary(
+            SpecOp::ConvTo,
+            spec_const_int(size_bits.try_into().unwrap()),
+            spec_field("value".to_string(), spec_var(ISA_STORE.to_string())),
+        ))
+        .modifies(ISA_STORE)
+        .build(),
+    );
+
+    // Enumerate AModes.
+    let arms = amode_cases(&mappings, |mem, flags| inst(src, mem, flags))?;
+
+    Ok(SpecConfig {
+        term: term.to_string(),
+        args: ["rd", "mem", "flags"].map(String::from).to_vec(),
+        cases: Cases::Match(Match {
+            on: spec_var("mem".to_string()),
+            arms,
+        }),
+    })
+}
+
+fn amode_cases<F>(mappings: &Mappings, inst: F) -> Result<Vec<Arm>>
+where
+    F: Fn(AMode, MemFlags) -> Inst,
+{
+    // RegReg
+    let mut reg_reg_mappings = mappings.clone();
+    reg_reg_mappings.reads.insert(
+        aarch64::gpreg(5),
+        Mapping::require(spec_var("rn".to_string())),
+    );
+    reg_reg_mappings.reads.insert(
+        aarch64::gpreg(6),
+        Mapping::require(spec_var("rm".to_string())),
+    );
+
+    let reg_reg = Arm {
+        variant: "RegReg".to_string(),
+        args: ["rn", "rm"].map(String::from).to_vec(),
+        body: Cases::Instruction(InstConfig {
+            opcodes: Opcodes::Instruction(inst(
+                AMode::RegReg {
+                    rn: xreg(5),
+                    rm: xreg(6),
+                },
+                MemFlags::new(),
+            )),
+            scope: aarch64::state(),
+            mappings: reg_reg_mappings,
+        }),
+    };
+
+    // RegScaled
+    let mut reg_scaled_mappings = mappings.clone();
+    reg_scaled_mappings.reads.insert(
+        aarch64::gpreg(5),
+        Mapping::require(spec_var("rn".to_string())),
+    );
+    reg_scaled_mappings.reads.insert(
+        aarch64::gpreg(6),
+        Mapping::require(spec_var("rm".to_string())),
+    );
+
+    let reg_scaled = Arm {
+        variant: "RegScaled".to_string(),
+        args: ["rn", "rm"].map(String::from).to_vec(),
+        body: Cases::Instruction(InstConfig {
+            opcodes: Opcodes::Instruction(inst(
+                AMode::RegScaled {
+                    rn: xreg(5),
+                    rm: xreg(6),
+                },
+                MemFlags::new(),
+            )),
+            scope: aarch64::state(),
+            mappings: reg_scaled_mappings,
+        }),
+    };
+
+    // RegScaledExtended
+    let extendops = [
+        // Not supported by assembler: UXTB, UXTH, UXTX, SXTB, SXTH
+        ExtendOp::UXTW,
+        ExtendOp::SXTW,
+        ExtendOp::SXTX,
+    ];
+    let mut reg_scaled_extended_mappings = mappings.clone();
+    reg_scaled_extended_mappings.reads.insert(
+        aarch64::gpreg(5),
+        Mapping::require(spec_var("rn".to_string())),
+    );
+    reg_scaled_extended_mappings.reads.insert(
+        aarch64::gpreg(6),
+        Mapping::require(spec_var("rm".to_string())),
+    );
+
+    let reg_scaled_extended = Arm {
+        variant: "RegScaledExtended".to_string(),
+        args: ["rn", "rm", "extendop"].map(String::from).to_vec(),
+        body: Cases::Match(Match {
+            on: spec_var("extendop".to_string()),
+            arms: extendops
+                .into_iter()
+                .map(|extendop| Arm {
+                    variant: format!("{extendop:?}"),
+                    args: Vec::new(),
+                    body: Cases::Instruction(InstConfig {
+                        opcodes: Opcodes::Instruction(inst(
+                            AMode::RegScaledExtended {
+                                rn: xreg(5),
+                                rm: xreg(6),
+                                extendop,
+                            },
+                            MemFlags::new(),
+                        )),
+                        scope: aarch64::state(),
+                        mappings: reg_scaled_extended_mappings.clone(),
+                    }),
+                })
+                .collect(),
+        }),
+    };
+
+    // RegExtended
+    let mut reg_extended_mappings = mappings.clone();
+    reg_extended_mappings.reads.insert(
+        aarch64::gpreg(5),
+        Mapping::require(spec_var("rn".to_string())),
+    );
+    reg_extended_mappings.reads.insert(
+        aarch64::gpreg(6),
+        Mapping::require(spec_var("rm".to_string())),
+    );
+
+    let reg_extended = Arm {
+        variant: "RegExtended".to_string(),
+        args: ["rn", "rm", "extendop"].map(String::from).to_vec(),
+        body: Cases::Match(Match {
+            on: spec_var("extendop".to_string()),
+            arms: extendops
+                .into_iter()
+                .map(|extendop| Arm {
+                    variant: format!("{extendop:?}"),
+                    args: Vec::new(),
+                    body: Cases::Instruction(InstConfig {
+                        opcodes: Opcodes::Instruction(inst(
+                            AMode::RegExtended {
+                                rn: xreg(5),
+                                rm: xreg(6),
+                                extendop,
+                            },
+                            MemFlags::new(),
+                        )),
+                        scope: aarch64::state(),
+                        mappings: reg_extended_mappings.clone(),
+                    }),
+                })
+                .collect(),
+        }),
+    };
+
+    // Unscaled
+    let mut unscaled_scope = aarch64::state();
+    let simm9 = Target::Var("simm9".to_string());
+    unscaled_scope.global(simm9.clone());
+
+    let mut unscaled_mappings = mappings.clone();
+    unscaled_mappings.reads.insert(
+        aarch64::gpreg(5),
+        Mapping::require(spec_var("rn".to_string())),
+    );
+    unscaled_mappings
+        .reads
+        .insert(simm9, Mapping::require(spec_var("simm9".to_string())));
+
+    let unscaled_template = amode_unscaled_template(xreg(5), |amode| inst(amode, MemFlags::new()))?;
+
+    let unscaled = Arm {
+        variant: "Unscaled".to_string(),
+        args: ["rn", "simm9"].map(String::from).to_vec(),
+        body: Cases::Instruction(InstConfig {
+            opcodes: Opcodes::Template(unscaled_template),
+            scope: unscaled_scope,
+            mappings: unscaled_mappings.clone(),
+        }),
+    };
+
+    // UnsignedOffset
+    let mut unsigned_offset_scope = aarch64::state();
+    let uimm12 = Target::Var("uimm12".to_string());
+    unsigned_offset_scope.global(uimm12.clone());
+
+    let mut unsigned_offset_mappings = mappings.clone();
+    unsigned_offset_mappings.reads.insert(
+        aarch64::gpreg(5),
+        Mapping::require(spec_var("rn".to_string())),
+    );
+    unsigned_offset_mappings
+        .reads
+        .insert(uimm12, Mapping::require(spec_var("uimm12".to_string())));
+
+    let unsigned_offset_template =
+        amode_unsigned_offset_template(xreg(5), |amode| inst(amode, MemFlags::new()))?;
+
+    let unsigned_offset = Arm {
+        variant: "UnsignedOffset".to_string(),
+        args: ["rn", "uimm12"].map(String::from).to_vec(),
+        body: Cases::Instruction(InstConfig {
+            opcodes: Opcodes::Template(unsigned_offset_template),
+            scope: unsigned_offset_scope,
+            mappings: unsigned_offset_mappings,
+        }),
+    };
+
+    Ok(vec![
+        reg_reg,
+        reg_scaled,
+        reg_scaled_extended,
+        reg_extended,
+        unscaled,
+        unsigned_offset,
+    ])
+}
+
+fn amode_unscaled_template<F>(rn: Reg, inst: F) -> Result<Bits>
+where
+    F: Fn(AMode) -> Inst,
+{
+    // Assemble a base instruction with a placeholder for the immediate bits field.
+    let placeholder = SImm9::maybe_from_i64(0).unwrap();
+    let base = inst(AMode::Unscaled {
+        rn,
+        simm9: placeholder,
+    });
+    let opcode = aarch64::opcode(&base);
+    let bits = Bits::from_u32(opcode);
+
+    // Splice in symbolic immediate fields.
+    let imm = Bits {
+        segments: vec![Segment::Symbolic("simm9".to_string(), 9)],
+    };
+    let template = Bits::splice(&bits, &imm, 12)?;
+
+    // Verify template against the assembler.
+    verify_opcode_template(&template, |assignment: &HashMap<String, u32>| {
+        let bits = assignment.get("simm9").unwrap();
+        let imm = SImm9 {
+            value: (*bits).try_into().unwrap(),
+        };
+        Ok(inst(AMode::Unscaled { rn, simm9: imm }))
+    })?;
+
+    Ok(template)
+}
+
+fn amode_unsigned_offset_template<F>(rn: Reg, inst: F) -> Result<Bits>
+where
+    F: Fn(AMode) -> Inst,
+{
+    // Assemble a base instruction with a placeholder for the immediate bits field.
+    let placeholder = UImm12Scaled::zero(I8);
+    let base = inst(AMode::UnsignedOffset {
+        rn,
+        uimm12: placeholder,
+    });
+    let opcode = aarch64::opcode(&base);
+    let bits = Bits::from_u32(opcode);
+
+    // Splice in symbolic immediate fields.
+    let imm = Bits {
+        segments: vec![Segment::Symbolic("uimm12".to_string(), 12)],
+    };
+    let template = Bits::splice(&bits, &imm, 10)?;
+
+    // Verify template against the assembler.
+    verify_opcode_template(&template, |assignment: &HashMap<String, u32>| {
+        let bits = assignment.get("uimm12").unwrap();
+        let uimm12 = UImm12Scaled::maybe_from_i64((*bits).try_into().unwrap(), I8).unwrap();
+        Ok(inst(AMode::UnsignedOffset { rn, uimm12 }))
+    })?;
+
+    Ok(template)
+}
+
+fn define_conds() -> Result<Vec<SpecConfig>> {
+    // CSel
+    let csel = define_csel("MInst.CSel", |rd, cond, rn, rm| Inst::CSel {
+        rd,
+        cond,
+        rn,
+        rm,
+    });
+
+    // CSNeg
+    let csneg = define_csel("MInst.CSNeg", |rd, cond, rn, rm| Inst::CSNeg {
+        rd,
+        cond,
+        rn,
+        rm,
+    });
+
+    // CSet
+    let cset = define_cset("MInst.CSet", |rd, cond| Inst::CSet { rd, cond });
+
+    // CSetm
+    let csetm = define_cset("MInst.CSetm", |rd, cond| Inst::CSetm { rd, cond });
+
+    // CCmp
+    let ccmp = define_ccmp()?;
+
+    // CCmpImm
+    let ccmp_imm = define_ccmp_imm()?;
+
+    Ok(vec![csel, csneg, cset, csetm, ccmp, ccmp_imm])
+}
+
+fn define_csel<F>(term: &str, inst: F) -> SpecConfig
+where
+    F: Fn(Writable<Reg>, Cond, Reg, Reg) -> Inst,
+{
+    // Flags and register mappings.
+    let mut mappings = flags_mappings();
+    mappings.writes.insert(
+        aarch64::gpreg(4),
+        Mapping::require(spec_var("rd".to_string())),
+    );
+    mappings.reads.insert(
+        aarch64::gpreg(5),
+        Mapping::require(spec_var("rn".to_string())),
+    );
+    mappings.reads.insert(
+        aarch64::gpreg(6),
+        Mapping::require(spec_var("rm".to_string())),
+    );
+
+    SpecConfig {
+        term: term.to_string(),
+        args: ["rd", "cond", "rn", "rm"].map(String::from).to_vec(),
+
+        cases: Cases::Match(Match {
+            on: spec_var("cond".to_string()),
+            arms: conds()
+                .iter()
+                .rev()
+                .map(|cond| Arm {
+                    variant: format!("{cond:?}"),
+                    args: Vec::new(),
+                    body: Cases::Instruction(InstConfig {
+                        opcodes: Opcodes::Instruction(inst(
+                            writable_xreg(4),
+                            *cond,
+                            xreg(5),
+                            xreg(6),
+                        )),
+                        scope: aarch64::state(),
+                        mappings: mappings.clone(),
+                    }),
+                })
+                .collect(),
+        }),
+    }
+}
+
+fn define_cset<F>(term: &str, inst: F) -> SpecConfig
+where
+    F: Fn(Writable<Reg>, Cond) -> Inst,
+{
+    // Flags and register mappings.
+    let mut mappings = flags_mappings();
+    mappings.writes.insert(
+        aarch64::gpreg(4),
+        Mapping::require(spec_var("rd".to_string())),
+    );
+
+    SpecConfig {
+        term: term.to_string(),
+        args: ["rd", "cond"].map(String::from).to_vec(),
+
+        cases: Cases::Match(Match {
+            on: spec_var("cond".to_string()),
+            arms: conds()
+                .iter()
+                .rev()
+                .map(|cond| Arm {
+                    variant: format!("{cond:?}"),
+                    args: Vec::new(),
+                    body: Cases::Instruction(InstConfig {
+                        opcodes: Opcodes::Instruction(inst(writable_xreg(4), *cond)),
+                        scope: aarch64::state(),
+                        mappings: mappings.clone(),
+                    }),
+                })
+                .collect(),
+        }),
+    }
+}
+
+fn define_ccmp() -> Result<SpecConfig> {
+    // OperandSize
+    let sizes = [OperandSize::Size32, OperandSize::Size64];
+
+    // Execution scope: define opcode template fields.
+    let mut scope = aarch64::state();
+    for flag in &["n", "z", "c", "v"] {
+        scope.global(Target::Var(flag.to_string()));
+    }
+
+    // Flags and register mappings.
+    let mut mappings = flags_mappings();
+    mappings.reads.insert(
+        aarch64::gpreg(5),
+        Mapping::require(spec_var("rn".to_string())),
+    );
+    mappings.reads.insert(
+        aarch64::gpreg(6),
+        Mapping::require(spec_var("rm".to_string())),
+    );
+    for flag in &["n", "z", "c", "v"] {
+        mappings.reads.insert(
+            Target::Var(flag.to_string()),
+            MappingBuilder::var("nzcv")
+                .field(&flag.to_uppercase())
+                .build(),
+        );
+    }
+
+    Ok(SpecConfig {
+        term: "MInst.CCmp".to_string(),
+        args: ["size", "rn", "rm", "nzcv", "cond"]
+            .map(String::from)
+            .to_vec(),
+
+        cases: Cases::Match(Match {
+            on: spec_var("size".to_string()),
+            arms: sizes
+                .iter()
+                .rev()
+                .map(|size| {
+                    Ok(Arm {
+                        variant: format!("{size:?}"),
+                        args: Vec::new(),
+                        body: Cases::Match(Match {
+                            on: spec_var("cond".to_string()),
+                            arms: conds()
+                                .iter()
+                                .rev()
+                                .map(|cond| {
+                                    let template = ccmp_template(*size, xreg(5), xreg(6), *cond)?;
+                                    Ok(Arm {
+                                        variant: format!("{cond:?}"),
+                                        args: Vec::new(),
+                                        body: Cases::Instruction(InstConfig {
+                                            opcodes: Opcodes::Template(template),
+                                            scope: scope.clone(),
+                                            mappings: mappings.clone(),
+                                        }),
+                                    })
+                                })
+                                .collect::<Result<_>>()?,
+                        }),
+                    })
+                })
+                .collect::<Result<_>>()?,
+        }),
+    })
+}
+
+fn ccmp_template(size: OperandSize, rn: Reg, rm: Reg, cond: Cond) -> Result<Bits> {
+    // Assemble a base instruction with a placeholder for the NZCV field.
+    let placeholder = NZCV::new(false, false, false, false);
+    let base = Inst::CCmp {
+        size,
+        rn,
+        rm,
+        nzcv: placeholder,
+        cond,
+    };
+    let opcode = aarch64::opcode(&base);
+    let bits = Bits::from_u32(opcode);
+
+    // Splice in symbolic immediate fields.
+    let nzcv = Bits {
+        segments: vec![
+            Segment::Symbolic("v".to_string(), 1),
+            Segment::Symbolic("c".to_string(), 1),
+            Segment::Symbolic("z".to_string(), 1),
+            Segment::Symbolic("n".to_string(), 1),
+        ],
+    };
+    let template = Bits::splice(&bits, &nzcv, 0)?;
+
+    // Verify template against the assembler.
+    verify_opcode_template(&template, |assignment: &HashMap<String, u32>| {
+        let nzcv = NZCV::new(
+            assignment["n"] != 0,
+            assignment["z"] != 0,
+            assignment["c"] != 0,
+            assignment["v"] != 0,
+        );
+        Ok(Inst::CCmp {
+            size,
+            rn,
+            rm,
+            nzcv,
+            cond,
+        })
+    })?;
+
+    Ok(template)
+}
+
+fn define_ccmp_imm() -> Result<SpecConfig> {
+    // OperandSize
+    let sizes = [OperandSize::Size32, OperandSize::Size64];
+
+    // Execution scope: define opcode template fields.
+    let mut scope = aarch64::state();
+    let imm_var = Target::Var("imm".to_string());
+    scope.global(imm_var.clone());
+    for flag in &["n", "z", "c", "v"] {
+        scope.global(Target::Var(flag.to_string()));
+    }
+
+    // Flags and register mappings.
+    let mut mappings = flags_mappings();
+    mappings.reads.insert(
+        aarch64::gpreg(5),
+        Mapping::require(spec_var("rn".to_string())),
+    );
+    mappings
+        .reads
+        .insert(imm_var, Mapping::require(spec_var("imm".to_string())));
+    for flag in &["n", "z", "c", "v"] {
+        mappings.reads.insert(
+            Target::Var(flag.to_string()),
+            MappingBuilder::var("nzcv")
+                .field(&flag.to_uppercase())
+                .build(),
+        );
+    }
+
+    Ok(SpecConfig {
+        term: "MInst.CCmpImm".to_string(),
+        args: ["size", "rn", "imm", "nzcv", "cond"]
+            .map(String::from)
+            .to_vec(),
+
+        cases: Cases::Match(Match {
+            on: spec_var("size".to_string()),
+            arms: sizes
+                .iter()
+                .rev()
+                .map(|size| {
+                    Ok(Arm {
+                        variant: format!("{size:?}"),
+                        args: Vec::new(),
+                        body: Cases::Match(Match {
+                            on: spec_var("cond".to_string()),
+                            arms: conds()
+                                .iter()
+                                .rev()
+                                .map(|cond| {
+                                    let template = ccmp_imm_template(*size, xreg(5), *cond)?;
+                                    Ok(Arm {
+                                        variant: format!("{cond:?}"),
+                                        args: Vec::new(),
+                                        body: Cases::Instruction(InstConfig {
+                                            opcodes: Opcodes::Template(template),
+                                            scope: scope.clone(),
+                                            mappings: mappings.clone(),
+                                        }),
+                                    })
+                                })
+                                .collect::<Result<_>>()?,
+                        }),
+                    })
+                })
+                .collect::<Result<_>>()?,
+        }),
+    })
+}
+
+fn ccmp_imm_template(size: OperandSize, rn: Reg, cond: Cond) -> Result<Bits> {
+    // Assemble a base instruction with a placeholder for the immediate and NZCV fields.
+    let imm_placeholder = UImm5::maybe_from_u8(0).unwrap();
+    let nzcv_placeholder = NZCV::new(false, false, false, false);
+    let base = Inst::CCmpImm {
+        size,
+        rn,
+        imm: imm_placeholder,
+        nzcv: nzcv_placeholder,
+        cond,
+    };
+    let opcode = aarch64::opcode(&base);
+    let bits = Bits::from_u32(opcode);
+
+    // Splice in symbolic immediate fields.
+    let nzcv = Bits {
+        segments: vec![
+            Segment::Symbolic("v".to_string(), 1),
+            Segment::Symbolic("c".to_string(), 1),
+            Segment::Symbolic("z".to_string(), 1),
+            Segment::Symbolic("n".to_string(), 1),
+        ],
+    };
+    let template = Bits::splice(&bits, &nzcv, 0)?;
+    let imm = Bits {
+        segments: vec![Segment::Symbolic("imm".to_string(), 5)],
+    };
+    let template = Bits::splice(&template, &imm, 16)?;
+
+    // Verify template against the assembler.
+    verify_opcode_template(&template, |assignment: &HashMap<String, u32>| {
+        let imm = UImm5::maybe_from_u8(assignment["imm"].try_into()?).unwrap();
+        let nzcv = NZCV::new(
+            assignment["n"] != 0,
+            assignment["z"] != 0,
+            assignment["c"] != 0,
+            assignment["v"] != 0,
+        );
+        Ok(Inst::CCmpImm {
+            size,
+            rn,
+            imm,
+            nzcv,
+            cond,
+        })
+    })?;
+
+    Ok(template)
+}
+
+/// All condition codes.
+fn conds() -> Vec<Cond> {
+    vec![
+        Cond::Eq,
+        Cond::Ne,
+        Cond::Hs,
+        Cond::Lo,
+        Cond::Mi,
+        Cond::Pl,
+        Cond::Vs,
+        Cond::Vc,
+        Cond::Hi,
+        Cond::Ls,
+        Cond::Ge,
+        Cond::Lt,
+        Cond::Gt,
+        Cond::Le,
+    ]
+}
+
+// MInst.FpuRRR specification configuration.
+fn define_fpu_rrr() -> SpecConfig {
+    // FPUOp2
+    let fpu_op2s = [
+        FPUOp2::Add,
+        FPUOp2::Sub,
+        FPUOp2::Mul,
+        FPUOp2::Div,
+        FPUOp2::Min,
+        FPUOp2::Max,
+    ];
+
+    // ScalarSize
+    let sizes = [ScalarSize::Size64, ScalarSize::Size32];
+
+    spec_config! {
+        (FpuRRR fpu_op size rd rn rm)
+        {
+            enumerate   (size, sizes);
+            enumerate   (fpu_op, fpu_op2s);
+            register    (rd, write, fp, 4);
+            register    (rn, read,  fp, 5);
+            register    (rm, read,  fp, 6);
+            fpcr        ();
+            instruction ();
+        }
+    }
+}
+
+// MInst.FpuRR specification configuration.
+fn define_fpu_rr() -> SpecConfig {
+    // FPUOp1
+    let fpu_op1s = [
+        FPUOp1::Neg,
+        FPUOp1::Abs,
+        FPUOp1::Sqrt,
+        FPUOp1::Cvt64To32,
+        FPUOp1::Cvt32To64,
+    ];
+
+    // ScalarSize
+    let sizes = [ScalarSize::Size64, ScalarSize::Size32];
+
+    spec_config! {
+        (FpuRR fpu_op size rd rn)
+        {
+            enumerate   (size, sizes);
+            enumerate   (fpu_op, fpu_op1s);
+            register    (rd, write, fp, 4);
+            register    (rn, read,  fp, 5);
+            filter      (is_fpu_op1_size_supported(fpu_op, size));
+            fpcr        ();
+            instruction ();
+        }
+    }
+}
+
+fn is_fpu_op1_size_supported(fpu_op1: FPUOp1, size: ScalarSize) -> bool {
+    match fpu_op1 {
+        FPUOp1::Cvt64To32 => size == ScalarSize::Size64,
+        FPUOp1::Cvt32To64 => size == ScalarSize::Size32,
+        _ => true,
+    }
+}
+
+fn define_fpu_move_imm() -> SpecConfig {
+    // ScalarSize
+    let sizes = [ScalarSize::Size32, ScalarSize::Size64];
+
+    // Execution scope: define opcode template fields.
+    let mut scope = aarch64::state();
+    let imm_bits = Target::Var("bits".to_string());
+    scope.global(imm_bits.clone());
+
+    // Mappings
+    let mut mappings = flags_mappings();
+    mappings.writes.insert(
+        aarch64::vreg(4),
+        Mapping::require(spec_var("rd".to_string())),
+    );
+    mappings.reads.insert(
+        imm_bits.clone(),
+        MappingBuilder::var("imm").field("imm").build(),
+    );
+
+    SpecConfig {
+        term: "MInst.FpuMoveFPImm".to_string(),
+        args: ["rd", "imm", "size"].map(String::from).to_vec(),
+        cases: Cases::Match(Match {
+            on: spec_var("size".to_string()),
+            arms: sizes
+                .iter()
+                .rev()
+                .map(|size| Arm {
+                    variant: format!("{size:?}"),
+                    args: Vec::new(),
+                    body: Cases::Instruction({
+                        InstConfig {
+                            opcodes: Opcodes::Template(
+                                fpu_move_imm_template(*size, writable_vreg(4)).unwrap(),
+                            ),
+                            scope: scope.clone(),
+                            mappings: mappings.clone(),
+                        }
+                    }),
+                })
+                .collect(),
+        }),
+    }
+}
+
+fn fpu_move_imm_template(size: ScalarSize, rd: Writable<Reg>) -> Result<Bits> {
+    // Assemble a base instruction with a placeholder for the imm12 field.
+    let placeholder = ASIMDFPModImm { imm: 0, size };
+    let base = Inst::FpuMoveFPImm {
+        rd,
+        imm: placeholder,
+        size,
+    };
+    let opcode = aarch64::opcode(&base);
+    let bits = Bits::from_u32(opcode);
+    // Splice in symbolic immediate fields.
+    let imm = Bits {
+        segments: vec![Segment::Symbolic("bits".to_string(), 8)],
+    };
+    let template = Bits::splice(&bits, &imm, 13)?;
+
+    // Verify template against the assembler.
+    verify_opcode_template(&template, |assignment: &HashMap<String, u32>| {
+        let bits = assignment.get("bits").unwrap();
+        let imm = ASIMDFPModImm {
+            imm: (*bits).try_into().unwrap(),
+            size,
+        };
+        Ok(Inst::FpuMoveFPImm { rd, imm, size })
+    })?;
+
+    Ok(template)
+}
+
+fn define_fpu_cmp() -> SpecConfig {
+    // ScalarSize
+    let sizes = [ScalarSize::Size64, ScalarSize::Size32];
+
+    spec_config! {
+        (FpuCmp size rn rm)
+        {
+            enumerate   (size, sizes);
+            register    (rn, read, fp, 4);
+            register    (rm, read,  fp, 5);
+            fpcr        ();
+            flags       ();
+            instruction ();
+        }
+    }
+}
+
+// MInst.MovToFpu specification configuration.
+fn define_mov_to_fpu() -> SpecConfig {
+    // ScalarSize
+    let sizes = [ScalarSize::Size64, ScalarSize::Size32, ScalarSize::Size16];
+
+    spec_config! {
+        (MovToFpu rd rn size)
+        {
+            enumerate   (size, sizes);
+            register    (rd, write, vec, 4);
+            register    (rn, read,  gp64, 5);
+            instruction ();
+        }
+    }
+}
+
+// ;; Conversion: integer -> FP.
+// MInst.IntToFpu specification configuration.
+fn define_int_to_fpu() -> SpecConfig {
+    let ops: [IntToFpuOp; 8] = [
+        IntToFpuOp::I64ToF64,
+        IntToFpuOp::U64ToF64,
+        IntToFpuOp::I64ToF32,
+        IntToFpuOp::U64ToF32,
+        IntToFpuOp::I32ToF64,
+        IntToFpuOp::U32ToF64,
+        IntToFpuOp::I32ToF32,
+        IntToFpuOp::U32ToF32,
+    ];
+
+    spec_config! {
+        (IntToFpu op rd rn)
+        {
+            enumerate   (op, ops);
+            register    (rd, write, vec, 4);
+            register    (rn, read,  gp, 5);
+            fpcr        ();
+            flags       ();
+            instruction ();
+        }
+    }
+}
+
+// ;; Conversion: integer -> FP.
+// MInst.FpuToInt specification configuration.
+fn define_fpu_to_int() -> SpecConfig {
+    let ops: [FpuToIntOp; 8] = [
+        FpuToIntOp::F64ToI64,
+        FpuToIntOp::F64ToU64,
+        FpuToIntOp::F64ToI32,
+        FpuToIntOp::F64ToU32,
+        FpuToIntOp::F32ToI64,
+        FpuToIntOp::F32ToU64,
+        FpuToIntOp::F32ToI32,
+        FpuToIntOp::F32ToU32,
+    ];
+
+    spec_config! {
+        (FpuToInt op rd rn)
+        {
+            enumerate   (op, ops);
+            register    (rd, write, gp, 4);
+            register    (rn, read,  vec, 5);
+            fpcr        ();
+            flags       ();
+            instruction ();
+        }
+    }
+}
+
+fn define_fpu_round() -> SpecConfig {
+    // FpuRoundMode
+    let modes = [
+        FpuRoundMode::Nearest64,
+        FpuRoundMode::Nearest32,
+        FpuRoundMode::Zero64,
+        FpuRoundMode::Zero32,
+        FpuRoundMode::Plus64,
+        FpuRoundMode::Plus32,
+        FpuRoundMode::Minus64,
+        FpuRoundMode::Minus32,
+    ];
+
+    spec_config! {
+        (FpuRound op rd rn)
+        {
+            enumerate   (op, modes);
+            register    (rd, write, fp, 4);
+            register    (rn, read,  fp, 5);
+            fpcr        ();
+            instruction ();
+        }
+    }
+}
+
+fn define_fpu_rri() -> SpecConfig {
+    let ops = [
+        (
+            32,
+            FPUOpRI::UShr32(FPURightShiftImm {
+                amount: 31,
+                lane_size_in_bits: 32,
+            }),
+        ),
+        (
+            64,
+            FPUOpRI::UShr64(FPURightShiftImm {
+                amount: 63,
+                lane_size_in_bits: 64,
+            }),
+        ),
+    ];
+    // FpuRRI
+    let mut mappings = Mappings::default();
+    mappings
+        .writes
+        .insert(aarch64::vreg(4), Mapping::require(spec_fp_reg("rd")));
+    mappings
+        .reads
+        .insert(aarch64::vreg(5), Mapping::require(spec_fp_reg("rn")));
+
+    SpecConfig {
+        term: "MInst.FpuRRI".to_string(),
+        args: ["fpu_op", "rd", "rn"].map(String::from).to_vec(),
+
+        cases: Cases::Cases(
+            ops.iter()
+                .rev()
+                .map(|(size, fpu_op)| Case {
+                    conds: vec![spec_eq(
+                        spec_field(
+                            "lane_size_in_bits".to_string(),
+                            spec_var("fpu_op".to_string()),
+                        ),
+                        spec_const_bit_vector(*size, 8),
+                    )],
+                    cases: Cases::Instruction(InstConfig {
+                        opcodes: Opcodes::Instruction(Inst::FpuRRI {
+                            fpu_op: *fpu_op,
+                            rd: writable_vreg(4),
+                            rn: vreg(5),
+                        }),
+                        scope: aarch64::state(),
+                        mappings: mappings.clone(),
+                    }),
+                })
+                .collect(),
+        ),
+    }
+}
+
+// ;; Variant of FpuRRI that modifies its `rd`
+fn define_fpu_rrimod() -> SpecConfig {
+    let ops = [
+        (
+            32,
+            FPUOpRIMod::Sli32(FPULeftShiftImm {
+                amount: 31,
+                lane_size_in_bits: 32,
+            }),
+        ),
+        (
+            64,
+            FPUOpRIMod::Sli64(FPULeftShiftImm {
+                amount: 63,
+                lane_size_in_bits: 64,
+            }),
+        ),
+    ];
+    // FpuRRIMod
+    let mut mappings = Mappings::default();
+    mappings
+        .writes
+        .insert(aarch64::vreg(4), Mapping::require(spec_fp_reg("rd")));
+    mappings
+        .reads
+        .insert(aarch64::vreg(4), Mapping::require(spec_fp_reg("ri")));
+    mappings
+        .reads
+        .insert(aarch64::vreg(5), Mapping::require(spec_fp_reg("rn")));
+
+    SpecConfig {
+        term: "MInst.FpuRRIMod".to_string(),
+        args: ["fpu_op", "rd", "ri", "rn"].map(String::from).to_vec(),
+
+        cases: Cases::Cases(
+            ops.iter()
+                .rev()
+                .map(|(size, fpu_op)| Case {
+                    conds: vec![spec_eq(
+                        spec_field(
+                            "lane_size_in_bits".to_string(),
+                            spec_var("fpu_op".to_string()),
+                        ),
+                        spec_const_bit_vector(*size, 8),
+                    )],
+                    cases: Cases::Instruction(InstConfig {
+                        opcodes: Opcodes::Instruction(Inst::FpuRRIMod {
+                            fpu_op: *fpu_op,
+                            rd: writable_vreg(4),
+                            ri: vreg(4),
+                            rn: vreg(5),
+                        }),
+                        scope: aarch64::state(),
+                        mappings: mappings.clone(),
+                    }),
+                })
+                .collect(),
+        ),
+    }
+}
+
+// MInst.MovFromVec specification configuration.
+fn define_mov_from_vec() -> SpecConfig {
+    // ScalarSize
+    let sizes = [
+        ScalarSize::Size8,
+        ScalarSize::Size16,
+        ScalarSize::Size32,
+        ScalarSize::Size64,
+    ];
+
+    // MovFromVec
+    let mut mappings = Mappings::default();
+    mappings.writes.insert(
+        aarch64::gpreg(4),
+        Mapping::require(spec_var("rd".to_string())),
+    );
+    mappings.reads.insert(
+        aarch64::vreg(5),
+        Mapping::require(spec_as_bit_vector_width(spec_var("rn".to_string()), 128)),
+    );
+
+    SpecConfig {
+        term: "MInst.MovFromVec".to_string(),
+        args: ["rd", "rn", "idx", "size"].map(String::from).to_vec(),
+
+        cases: Cases::Match(Match {
+            on: spec_var("size".to_string()),
+            arms: sizes
+                .iter()
+                .rev()
+                .map(|size| {
+                    let lanes = 128 / size.ty().bits();
+                    Arm {
+                        variant: format!("{size:?}"),
+                        args: Vec::new(),
+                        body: Cases::Cases(
+                            (0..lanes)
+                                .map(|idx| Case {
+                                    conds: vec![spec_eq(
+                                        spec_var("idx".to_string()),
+                                        spec_const_bit_vector(idx.into(), 8),
+                                    )],
+                                    cases: Cases::Instruction(InstConfig {
+                                        opcodes: Opcodes::Instruction(Inst::MovFromVec {
+                                            rd: writable_xreg(4),
+                                            rn: vreg(5),
+                                            idx: idx.try_into().unwrap(),
+                                            size: *size,
+                                        }),
+                                        scope: aarch64::state(),
+                                        mappings: mappings.clone(),
+                                    }),
+                                })
+                                .collect(),
+                        ),
+                    }
+                })
+                .collect(),
+        }),
+    }
+}
+
+// MInst.VecDupImm specification configuration.
+//
+// Note this specification only handles the 8-bit immediate field of ASIMDMovModImm.
+// This is sufficient to handle the limited uses of VecDupImm right now.
+//
+// TODO: handle all ASIMDMovModImm parameters
+fn define_vec_dup_imm() -> Result<SpecConfig> {
+    // VectorSize
+    let sizes = [VectorSize::Size32x2];
+
+    // Invert
+    let inverts = [false, true];
+
+    // Execution scope: define opcode template fields.
+    let mut scope = aarch64::state();
+    let abc_bits = Target::Var("abc".to_string());
+    let defgh_bits = Target::Var("defgh".to_string());
+    scope.global(abc_bits.clone());
+    scope.global(defgh_bits.clone());
+
+    // Mappings
+    let mut mappings = flags_mappings();
+    mappings.writes.insert(
+        aarch64::vreg(4),
+        Mapping::require(spec_var("rd".to_string())),
+    );
+    let imm = spec_field("imm".to_string(), spec_var("imm".to_string()));
+    mappings.reads.insert(
+        abc_bits.clone(),
+        Mapping::require(spec_extract(7, 5, imm.clone())),
+    );
+    mappings.reads.insert(
+        defgh_bits.clone(),
+        Mapping::require(spec_extract(4, 0, imm.clone())),
+    );
+
+    Ok(SpecConfig {
+        term: "MInst.VecDupImm".to_string(),
+        args: ["rd", "imm", "invert", "size"].map(String::from).to_vec(),
+        cases: Cases::Match(Match {
+            on: spec_var("size".to_string()),
+            arms: sizes
+                .iter()
+                .rev()
+                .map(|size| {
+                    Ok(Arm {
+                        variant: format!("{size:?}"),
+                        args: Vec::new(),
+                        body: Cases::Cases(
+                            inverts
+                                .iter()
+                                .map(|invert| {
+                                    Ok(Case {
+                                        conds: vec![spec_eq_bool(
+                                            spec_var("invert".to_string()),
+                                            *invert,
+                                        )],
+                                        cases: Cases::Instruction(InstConfig {
+                                            opcodes: Opcodes::Template(vec_dup_imm_template(
+                                                writable_vreg(4),
+                                                *invert,
+                                                *size,
+                                            )?),
+                                            scope: scope.clone(),
+                                            mappings: mappings.clone(),
+                                        }),
+                                    })
+                                })
+                                .collect::<Result<_>>()?,
+                        ),
+                    })
+                })
+                .collect::<Result<_>>()?,
+        }),
+    })
+}
+
+fn vec_dup_imm_template(rd: Writable<Reg>, invert: bool, size: VectorSize) -> Result<Bits> {
+    // Assemble a base instruction with a placeholder for the immediate field.
+    // TODO: handle all ASIMDMovModImm parameters shift, is_64bit, and shift_ones.
+    let placeholder = ASIMDMovModImm {
+        imm: 0,
+        shift: 0,
+        is_64bit: false,
+        shift_ones: false,
+    };
+    let base = Inst::VecDupImm {
+        rd,
+        imm: placeholder,
+        invert,
+        size,
+    };
+    let opcode = aarch64::opcode(&base);
+    let bits = Bits::from_u32(opcode);
+
+    // Splice in symbolic immediate fields.
+    let abc = Bits {
+        segments: vec![Segment::Symbolic("abc".to_string(), 3)],
+    };
+    let template = Bits::splice(&bits, &abc, 16)?;
+
+    let defgh = Bits {
+        segments: vec![Segment::Symbolic("defgh".to_string(), 5)],
+    };
+    let template = Bits::splice(&template, &defgh, 5)?;
+
+    // Verify template against the assembler.
+    verify_opcode_template(&template, |assignment: &HashMap<String, u32>| {
+        let abc = assignment.get("abc").unwrap();
+        let defgh = assignment.get("defgh").unwrap();
+        let bits = (abc << 5) | defgh;
+
+        let imm = ASIMDMovModImm {
+            imm: bits.try_into().unwrap(),
+            shift: 0,
+            is_64bit: false,
+            shift_ones: false,
+        };
+        Ok(Inst::VecDupImm {
+            rd,
+            imm,
+            invert,
+            size,
+        })
+    })?;
+
+    Ok(template)
+}
+
+// MInst.VecRRR specification configuration.
+fn define_vec_rrr() -> SpecConfig {
+    // VecALUOp
+    let vec_alu_ops = [VecALUOp::Addp];
+
+    // VectorSize
+    let sizes = [VectorSize::Size8x16, VectorSize::Size8x8];
+
+    spec_config! {
+        (VecRRR alu_op rd rn rm size)
+        {
+            enumerate   (size, sizes);
+            enumerate   (alu_op, vec_alu_ops);
+            register    (rd, write, vec, 4);
+            register    (rn, read,  vec, 5);
+            register    (rm, read,  vec, 6);
+            instruction ();
+        }
+    }
+}
+
+// MInst.VecMisc specification configuration.
+fn define_vec_misc() -> SpecConfig {
+    // VecMisc2
+    let ops = [VecMisc2::Cnt];
+
+    // VectorSize
+    let sizes = [VectorSize::Size8x16, VectorSize::Size8x8];
+
+    spec_config! {
+        (VecMisc op rd rn size)
+        {
+            enumerate   (size, sizes);
+            enumerate   (op, ops);
+            register    (rd, write, vec, 4);
+            register    (rn, read,  vec, 5);
+            instruction ();
+        }
+    }
+}
+
+// MInst.VecLanes specification configuration.
+fn define_vec_lanes() -> SpecConfig {
+    // VecLanesOp
+    let vec_lanes_ops = [VecLanesOp::Uminv, VecLanesOp::Addv];
+
+    // VectorSize
+    let sizes = [
+        VectorSize::Size8x8,
+        VectorSize::Size8x16,
+        VectorSize::Size16x4,
+        VectorSize::Size16x8,
+        VectorSize::Size32x4,
+    ];
+
+    // VecLanes
+    let mut mappings = Mappings::default();
+    mappings.writes.insert(
+        aarch64::vreg(4),
+        Mapping::require(spec_var("rd".to_string())),
+    );
+    mappings.reads.insert(
+        aarch64::vreg(5),
+        Mapping::require(spec_var("rn".to_string())),
+    );
+
+    SpecConfig {
+        term: "MInst.VecLanes".to_string(),
+        args: ["op", "rd", "rn", "size"].map(String::from).to_vec(),
+
+        cases: Cases::Match(Match {
+            on: spec_var("size".to_string()),
+            arms: sizes
+                .iter()
+                .rev()
+                .map(|size| Arm {
+                    variant: format!("{size:?}"),
+                    args: Vec::new(),
+                    body: Cases::Match(Match {
+                        on: spec_var("op".to_string()),
+                        arms: vec_lanes_ops
+                            .iter()
+                            .map(|op| Arm {
+                                variant: format!("{op:?}"),
+                                args: Vec::new(),
+                                body: Cases::Instruction(InstConfig {
+                                    opcodes: Opcodes::Instruction(Inst::VecLanes {
+                                        op: *op,
+                                        rd: writable_vreg(4),
+                                        rn: vreg(5),
+                                        size: *size,
+                                    }),
+                                    scope: aarch64::state(),
+                                    mappings: mappings.clone(),
+                                }),
+                            })
+                            .collect(),
+                    }),
+                })
+                .collect(),
+        }),
+    }
+}
diff --git a/cranelift/isle/veri/isaspec/src/lib.rs b/cranelift/isle/veri/isaspec/src/lib.rs
new file mode 100644
index 000000000000..399a031d1332
--- /dev/null
+++ b/cranelift/isle/veri/isaspec/src/lib.rs
@@ -0,0 +1,9 @@
+pub mod aarch64;
+pub mod bits;
+pub mod builder;
+pub mod configure;
+pub mod constraints;
+pub mod instructions;
+pub mod memory;
+pub mod semantics;
+pub mod spec;
diff --git a/cranelift/isle/veri/isaspec/src/memory.rs b/cranelift/isle/veri/isaspec/src/memory.rs
new file mode 100644
index 000000000000..74cde8791e6d
--- /dev/null
+++ b/cranelift/isle/veri/isaspec/src/memory.rs
@@ -0,0 +1,53 @@
+use crate::constraints::Target;
+
+pub struct ReadEffect {
+    pub active: Target,
+    pub addr: Target,
+    pub size_bits: Target,
+    pub value: Target,
+}
+
+impl ReadEffect {
+    pub fn new() -> Self {
+        Self {
+            active: Target::Field(Box::new(Self::variable()), "ACTIVE".to_string()),
+            addr: Target::Field(Box::new(Self::variable()), "ADDR".to_string()),
+            size_bits: Target::Field(Box::new(Self::variable()), "SIZE_BITS".to_string()),
+            value: Target::Field(Box::new(Self::variable()), "VALUE".to_string()),
+        }
+    }
+
+    fn variable() -> Target {
+        Target::Var("MEMORY_READ_EFFECT".to_string())
+    }
+
+    pub fn targets(&self) -> Vec<&Target> {
+        vec![&self.active, &self.addr, &self.size_bits, &self.value]
+    }
+}
+
+pub struct SetEffect {
+    pub active: Target,
+    pub addr: Target,
+    pub size_bits: Target,
+    pub value: Target,
+}
+
+impl SetEffect {
+    pub fn new() -> Self {
+        Self {
+            active: Target::Field(Box::new(Self::variable()), "ACTIVE".to_string()),
+            addr: Target::Field(Box::new(Self::variable()), "ADDR".to_string()),
+            size_bits: Target::Field(Box::new(Self::variable()), "SIZE_BITS".to_string()),
+            value: Target::Field(Box::new(Self::variable()), "VALUE".to_string()),
+        }
+    }
+
+    fn variable() -> Target {
+        Target::Var("MEMORY_SET_EFFECT".to_string())
+    }
+
+    pub fn targets(&self) -> Vec<&Target> {
+        vec![&self.active, &self.addr, &self.size_bits, &self.value]
+    }
+}
diff --git a/cranelift/isle/veri/isaspec/src/semantics.rs b/cranelift/isle/veri/isaspec/src/semantics.rs
new file mode 100644
index 000000000000..ebca140560ac
--- /dev/null
+++ b/cranelift/isle/veri/isaspec/src/semantics.rs
@@ -0,0 +1,23 @@
+use anyhow::Result;
+use cranelift_codegen::isa::aarch64::inst::Inst;
+use cranelift_isle_veri_aslp::{ast::Block, client::Client, opcode::Opcode};
+use tracing::debug;
+
+use crate::aarch64;
+
+// Fetch semantics for the given Cranelift instruction.
+pub fn inst_semantics(inst: &Inst, client: &Client) -> Result<Block> {
+    // Assemble instruction.
+    let opcode = aarch64::opcode(inst);
+
+    // Debugging.
+    let asm = aarch64::assembly(inst);
+
+    debug!("inst = {inst:#?}");
+    debug!("opcode = {opcode:08x}");
+    debug!("asm = {asm}");
+
+    // Fetch semantics.
+    let opcode_bits = Opcode::from_u32(opcode);
+    client.opcode(opcode_bits)
+}
diff --git a/cranelift/isle/veri/isaspec/src/spec.rs b/cranelift/isle/veri/isaspec/src/spec.rs
new file mode 100644
index 000000000000..157cfef98fa6
--- /dev/null
+++ b/cranelift/isle/veri/isaspec/src/spec.rs
@@ -0,0 +1,388 @@
+use std::collections::{HashMap, HashSet};
+
+use anyhow::{bail, Result};
+
+use cranelift_isle::ast::{Arm, FieldInit, Ident, ModelType, SpecExpr, SpecOp};
+use cranelift_isle::lexer::Pos;
+
+pub fn spec_const_int(val: i128) -> SpecExpr {
+    SpecExpr::ConstInt {
+        val,
+        pos: Pos::default(),
+    }
+}
+
+pub fn spec_const_bool(val: bool) -> SpecExpr {
+    SpecExpr::ConstBool {
+        val,
+        pos: Pos::default(),
+    }
+}
+
+pub fn spec_true() -> SpecExpr {
+    spec_const_bool(true)
+}
+
+pub fn spec_false() -> SpecExpr {
+    spec_const_bool(false)
+}
+
+pub fn spec_const_bit_vector(val: u128, width: usize) -> SpecExpr {
+    assert!(width > 0);
+    SpecExpr::ConstBitVec {
+        val,
+        width,
+        pos: Pos::default(),
+    }
+}
+
+pub fn spec_unary(op: SpecOp, x: SpecExpr) -> SpecExpr {
+    spec_op(op, vec![x])
+}
+
+pub fn spec_binary(op: SpecOp, x: SpecExpr, y: SpecExpr) -> SpecExpr {
+    spec_op(op, vec![x, y])
+}
+
+pub fn spec_ternary(op: SpecOp, x: SpecExpr, y: SpecExpr, z: SpecExpr) -> SpecExpr {
+    spec_op(op, vec![x, y, z])
+}
+
+pub fn spec_not(x: SpecExpr) -> SpecExpr {
+    spec_unary(SpecOp::Not, x)
+}
+
+pub fn spec_if(c: SpecExpr, t: SpecExpr, e: SpecExpr) -> SpecExpr {
+    spec_ternary(SpecOp::If, c, t, e)
+}
+
+pub fn spec_eq(x: SpecExpr, y: SpecExpr) -> SpecExpr {
+    spec_binary(SpecOp::Eq, x, y)
+}
+
+pub fn spec_eq_bool(x: SpecExpr, val: bool) -> SpecExpr {
+    if val {
+        x
+    } else {
+        spec_not(x)
+    }
+}
+
+pub fn spec_or(args: Vec<SpecExpr>) -> SpecExpr {
+    spec_op(SpecOp::Or, args)
+}
+
+pub fn spec_any(xs: Vec<SpecExpr>) -> SpecExpr {
+    match xs.len() {
+        0 => spec_false(),
+        1 => xs[0].clone(),
+        _ => spec_or(xs),
+    }
+}
+
+pub fn spec_and(args: Vec<SpecExpr>) -> SpecExpr {
+    spec_op(SpecOp::And, args)
+}
+
+pub fn spec_all(xs: Vec<SpecExpr>) -> SpecExpr {
+    match xs.len() {
+        0 => spec_true(),
+        1 => xs[0].clone(),
+        _ => spec_and(xs),
+    }
+}
+
+pub fn spec_extract(h: usize, l: usize, x: SpecExpr) -> SpecExpr {
+    spec_ternary(
+        SpecOp::Extract,
+        spec_const_int(h.try_into().unwrap()),
+        spec_const_int(l.try_into().unwrap()),
+        x,
+    )
+}
+
+pub fn spec_conv_to(w: usize, x: SpecExpr) -> SpecExpr {
+    spec_binary(SpecOp::ConvTo, spec_const_int(w.try_into().unwrap()), x)
+}
+
+pub fn spec_bv2nat(x: SpecExpr) -> SpecExpr {
+    spec_unary(SpecOp::BV2Nat, x)
+}
+
+pub fn spec_zero_ext(w: usize, x: SpecExpr) -> SpecExpr {
+    spec_ext(SpecOp::ZeroExt, w, x)
+}
+
+pub fn spec_sign_ext(w: usize, x: SpecExpr) -> SpecExpr {
+    spec_ext(SpecOp::SignExt, w, x)
+}
+
+fn spec_ext(ext_op: SpecOp, w: usize, x: SpecExpr) -> SpecExpr {
+    // Simplify nested extensions.
+    if let SpecExpr::Op {
+        ref op,
+        ref args,
+        pos: _,
+    } = x
+    {
+        if *op == ext_op {
+            if let [SpecExpr::ConstInt { val, .. }, n] = args.as_slice() {
+                let nw: usize = (*val).try_into().unwrap();
+                if w >= nw {
+                    return spec_zero_ext(w, n.clone());
+                }
+            }
+        }
+    }
+
+    // Base case just constructs zero extension operator.
+    spec_binary(ext_op, spec_const_int(w.try_into().unwrap()), x)
+}
+
+pub fn spec_op(op: SpecOp, args: Vec<SpecExpr>) -> SpecExpr {
+    SpecExpr::Op {
+        op,
+        args,
+        pos: Pos::default(),
+    }
+}
+
+pub fn spec_enum(name: String, variant: String, args: Vec<SpecExpr>) -> SpecExpr {
+    SpecExpr::Enum {
+        name: spec_ident(name),
+        variant: spec_ident(variant),
+        args,
+        pos: Pos::default(),
+    }
+}
+
+pub fn spec_enum_unit(name: String, variant: String) -> SpecExpr {
+    spec_enum(name, variant, Vec::new())
+}
+
+pub fn spec_as_bit_vector_width(x: SpecExpr, width: usize) -> SpecExpr {
+    SpecExpr::As {
+        x: Box::new(x),
+        ty: ModelType::BitVec(Some(width)),
+        pos: Pos::default(),
+    }
+}
+
+pub fn spec_field(field: String, x: SpecExpr) -> SpecExpr {
+    SpecExpr::Field {
+        field: spec_ident(field),
+        x: Box::new(x),
+        pos: Pos::default(),
+    }
+}
+
+pub fn spec_discriminator(variant: String, x: SpecExpr) -> SpecExpr {
+    SpecExpr::Discriminator {
+        variant: spec_ident(variant),
+        x: Box::new(x),
+        pos: Pos::default(),
+    }
+}
+
+pub fn spec_var(id: String) -> SpecExpr {
+    SpecExpr::Var {
+        var: spec_ident(id),
+        pos: Pos::default(),
+    }
+}
+
+pub fn spec_with(decls: Vec<Ident>, body: SpecExpr) -> SpecExpr {
+    SpecExpr::With {
+        decls,
+        body: Box::new(body),
+        pos: Pos::default(),
+    }
+}
+
+pub fn spec_idents(ids: &[String]) -> Vec<Ident> {
+    ids.iter().cloned().map(spec_ident).collect()
+}
+
+pub fn spec_ident(id: String) -> Ident {
+    Ident(id, Pos::default())
+}
+
+#[derive(Clone)]
+pub struct Conditions {
+    pub requires: Vec<SpecExpr>,
+    pub provides: Vec<SpecExpr>,
+    pub modifies: HashSet<String>,
+}
+
+impl Conditions {
+    pub fn new() -> Self {
+        Self {
+            requires: Vec::new(),
+            provides: Vec::new(),
+            modifies: HashSet::new(),
+        }
+    }
+
+    pub fn merge(cs: Vec<Self>) -> Self {
+        match cs.len() {
+            0 => Self::new(),
+            1 => cs[0].clone(),
+            _ => Self {
+                requires: vec![spec_or(
+                    cs.iter().map(|c| spec_all(c.requires.clone())).collect(),
+                )],
+                provides: cs
+                    .iter()
+                    .map(|c| {
+                        spec_binary(
+                            SpecOp::Imp,
+                            spec_all(c.requires.clone()),
+                            spec_all(c.provides.clone()),
+                        )
+                    })
+                    .collect(),
+                modifies: cs.iter().fold(HashSet::new(), |acc, c| &acc | &c.modifies),
+            },
+        }
+    }
+}
+
+pub fn substitute(expr: SpecExpr, substitutions: &HashMap<String, SpecExpr>) -> Result<SpecExpr> {
+    Ok(match expr {
+        // Variable
+        SpecExpr::Var { ref var, pos: _ } => {
+            if let Some(substitution) = substitutions.get(&var.0) {
+                substitution.clone()
+            } else {
+                expr
+            }
+        }
+
+        // Constants are unchanged.
+        SpecExpr::ConstInt { .. } | SpecExpr::ConstBitVec { .. } | SpecExpr::ConstBool { .. } => {
+            expr
+        }
+
+        // Inline macro introduces a new scope.
+        SpecExpr::Macro { .. } => expr,
+
+        // Scopes require care to ensure we are not replacing introduced variables.
+        SpecExpr::Match { x, arms, pos } => SpecExpr::Match {
+            x: Box::new(substitute(*x, substitutions)?),
+            arms: arms
+                .into_iter()
+                .map(
+                    |Arm {
+                         variant,
+                         args,
+                         body,
+                         pos,
+                     }| {
+                        for arg in &args {
+                            if substitutions.contains_key(&arg.0) {
+                                bail!("substituted variable collides with match arm");
+                            }
+                        }
+                        Ok(Arm {
+                            variant,
+                            args,
+                            body: substitute(body, substitutions)?,
+                            pos,
+                        })
+                    },
+                )
+                .collect::<Result<_>>()?,
+            pos,
+        },
+        SpecExpr::Let { defs, body, pos } => SpecExpr::Let {
+            defs: defs
+                .into_iter()
+                .map(|(var, expr)| {
+                    if substitutions.contains_key(&var.0) {
+                        bail!("substituted variable collides with let binding");
+                    }
+                    Ok((var, substitute(expr, substitutions)?))
+                })
+                .collect::<Result<_>>()?,
+            body: Box::new(substitute(*body, substitutions)?),
+            pos,
+        },
+        SpecExpr::With { decls, body, pos } => {
+            for decl in &decls {
+                if substitutions.contains_key(&decl.0) {
+                    bail!("substituted variable collides with with scope");
+                }
+            }
+            SpecExpr::With {
+                decls,
+                body: Box::new(substitute(*body, substitutions)?),
+                pos,
+            }
+        }
+
+        // Recurse into child expressions.
+        SpecExpr::As { x, ty, pos } => SpecExpr::As {
+            x: Box::new(substitute(*x, substitutions)?),
+            ty,
+            pos,
+        },
+        SpecExpr::Field { field, x, pos } => SpecExpr::Field {
+            field,
+            x: Box::new(substitute(*x, substitutions)?),
+            pos,
+        },
+        SpecExpr::Discriminator { variant, x, pos } => SpecExpr::Discriminator {
+            variant,
+            x: Box::new(substitute(*x, substitutions)?),
+            pos,
+        },
+        SpecExpr::Op { op, args, pos } => SpecExpr::Op {
+            op,
+            args: args
+                .into_iter()
+                .map(|arg| substitute(arg, substitutions))
+                .collect::<Result<_>>()?,
+            pos,
+        },
+        SpecExpr::Pair { l, r, pos } => SpecExpr::Pair {
+            l: Box::new(substitute(*l, substitutions)?),
+            r: Box::new(substitute(*r, substitutions)?),
+            pos,
+        },
+        SpecExpr::Enum {
+            name,
+            variant,
+            args,
+            pos,
+        } => SpecExpr::Enum {
+            name,
+            variant,
+            args: args
+                .into_iter()
+                .map(|arg| substitute(arg, substitutions))
+                .collect::<Result<_>>()?,
+            pos,
+        },
+        SpecExpr::Expand { name, args, pos } => SpecExpr::Expand {
+            name,
+            args: args
+                .into_iter()
+                .map(|arg| substitute(arg, substitutions))
+                .collect::<Result<_>>()?,
+            pos,
+        },
+        SpecExpr::Struct { fields, pos } => SpecExpr::Struct {
+            fields: fields
+                .into_iter()
+                .map(|f| {
+                    Ok(FieldInit {
+                        name: f.name,
+                        value: Box::new(substitute(*f.value, substitutions)?),
+                        pos: f.pos,
+                    })
+                })
+                .collect::<Result<_>>()?,
+            pos,
+        },
+    })
+}
diff --git a/cranelift/isle/veri/meta/Cargo.toml b/cranelift/isle/veri/meta/Cargo.toml
new file mode 100644
index 000000000000..0ed6710e8771
--- /dev/null
+++ b/cranelift/isle/veri/meta/Cargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "cranelift-isle-veri-meta"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[dependencies]
+wasmparser = { workspace = true }
diff --git a/cranelift/isle/veri/meta/data/cliftags.json b/cranelift/isle/veri/meta/data/cliftags.json
new file mode 100644
index 000000000000..42da1b9dae53
--- /dev/null
+++ b/cranelift/isle/veri/meta/data/cliftags.json
@@ -0,0 +1,254 @@
+{
+	"select": [
+		"wasm_category_stack",
+		"wasm_proposal_mvp"
+	],
+	"icmp": [
+		"wasm_category_comparison",
+		"wasm_category_loads",
+		"wasm_category_stores",
+		"wasm_proposal_mvp"
+	],
+	"iconst": [
+		"wasm_category_const",
+		"wasm_category_loads",
+		"wasm_category_stores",
+		"wasm_proposal_mvp"
+	],
+	"isub": [
+		"wasm_category_binary",
+		"wasm_category_loads",
+		"wasm_category_stores",
+		"wasm_proposal_mvp"
+	],
+	"uadd_overflow_trap": [
+		"wasm_category_loads",
+		"wasm_category_stores",
+		"wasm_proposal_mvp"
+	],
+	"uload8": [
+		"wasm_category_loads",
+		"wasm_proposal_mvp"
+	],
+	"uload16": [
+		"wasm_category_loads",
+		"wasm_proposal_mvp"
+	],
+	"sload8": [
+		"wasm_category_loads",
+		"wasm_proposal_mvp"
+	],
+	"sload16": [
+		"wasm_category_loads",
+		"wasm_proposal_mvp"
+	],
+	"sload32": [
+		"wasm_category_loads",
+		"wasm_proposal_mvp"
+	],
+	"uload32": [
+		"wasm_category_loads",
+		"wasm_proposal_mvp"
+	],
+	"load": [
+		"wasm_category_loads",
+		"wasm_proposal_mvp"
+	],
+	"store": [
+		"wasm_category_stores",
+		"wasm_proposal_mvp"
+	],
+	"istore8": [
+		"wasm_category_stores",
+		"wasm_proposal_mvp"
+	],
+	"istore16": [
+		"wasm_category_stores",
+		"wasm_proposal_mvp"
+	],
+	"istore32": [
+		"wasm_category_stores",
+		"wasm_proposal_mvp"
+	],
+	"f32const": [
+		"wasm_category_const",
+		"wasm_proposal_mvp"
+	],
+	"f64const": [
+		"wasm_category_const",
+		"wasm_proposal_mvp"
+	],
+	"clz": [
+		"wasm_category_unary",
+		"wasm_proposal_mvp"
+	],
+	"ctz": [
+		"wasm_category_unary",
+		"wasm_proposal_mvp"
+	],
+	"popcnt": [
+		"wasm_category_unary",
+		"wasm_proposal_mvp"
+	],
+	"sextend": [
+		"wasm_category_unary",
+		"wasm_proposal_mvp"
+	],
+	"uextend": [
+		"wasm_category_comparison",
+		"wasm_category_unary",
+		"wasm_proposal_mvp"
+	],
+	"ireduce": [
+		"wasm_category_unary",
+		"wasm_proposal_mvp"
+	],
+	"sqrt": [
+		"wasm_category_unary",
+		"wasm_proposal_mvp"
+	],
+	"ceil": [
+		"wasm_category_unary",
+		"wasm_proposal_mvp"
+	],
+	"floor": [
+		"wasm_category_unary",
+		"wasm_proposal_mvp"
+	],
+	"trunc": [
+		"wasm_category_unary",
+		"wasm_proposal_mvp"
+	],
+	"nearest": [
+		"wasm_category_unary",
+		"wasm_proposal_mvp"
+	],
+	"fabs": [
+		"wasm_category_unary",
+		"wasm_proposal_mvp"
+	],
+	"fneg": [
+		"wasm_category_unary",
+		"wasm_proposal_mvp"
+	],
+	"fcvt_from_uint": [
+		"wasm_category_unary",
+		"wasm_proposal_mvp"
+	],
+	"fcvt_from_sint": [
+		"wasm_category_unary",
+		"wasm_proposal_mvp"
+	],
+	"fpromote": [
+		"wasm_category_unary",
+		"wasm_proposal_mvp"
+	],
+	"fdemote": [
+		"wasm_category_unary",
+		"wasm_proposal_mvp"
+	],
+	"fcvt_to_sint": [
+		"wasm_category_unary",
+		"wasm_proposal_mvp"
+	],
+	"fcvt_to_uint": [
+		"wasm_category_unary",
+		"wasm_proposal_mvp"
+	],
+	"bitcast": [
+		"wasm_category_unary",
+		"wasm_proposal_mvp"
+	],
+	"iadd": [
+		"wasm_category_binary",
+		"wasm_proposal_mvp"
+	],
+	"band": [
+		"wasm_category_binary",
+		"wasm_proposal_mvp"
+	],
+	"bor": [
+		"wasm_category_binary",
+		"wasm_proposal_mvp"
+	],
+	"bxor": [
+		"wasm_category_binary",
+		"wasm_proposal_mvp"
+	],
+	"ishl": [
+		"wasm_category_binary",
+		"wasm_proposal_mvp"
+	],
+	"sshr": [
+		"wasm_category_binary",
+		"wasm_proposal_mvp"
+	],
+	"ushr": [
+		"wasm_category_binary",
+		"wasm_proposal_mvp"
+	],
+	"rotl": [
+		"wasm_category_binary",
+		"wasm_proposal_mvp"
+	],
+	"rotr": [
+		"wasm_category_binary",
+		"wasm_proposal_mvp"
+	],
+	"fadd": [
+		"wasm_category_binary",
+		"wasm_proposal_mvp"
+	],
+	"fsub": [
+		"wasm_category_binary",
+		"wasm_proposal_mvp"
+	],
+	"imul": [
+		"wasm_category_binary",
+		"wasm_proposal_mvp"
+	],
+	"fmul": [
+		"wasm_category_binary",
+		"wasm_proposal_mvp"
+	],
+	"fdiv": [
+		"wasm_category_binary",
+		"wasm_proposal_mvp"
+	],
+	"sdiv": [
+		"wasm_category_binary",
+		"wasm_proposal_mvp"
+	],
+	"udiv": [
+		"wasm_category_binary",
+		"wasm_proposal_mvp"
+	],
+	"srem": [
+		"wasm_category_binary",
+		"wasm_proposal_mvp"
+	],
+	"urem": [
+		"wasm_category_binary",
+		"wasm_proposal_mvp"
+	],
+	"fmin": [
+		"wasm_category_binary",
+		"wasm_proposal_mvp"
+	],
+	"fmax": [
+		"wasm_category_binary",
+		"wasm_proposal_mvp"
+	],
+	"fcopysign": [
+		"wasm_category_binary",
+		"wasm_proposal_mvp"
+	],
+	"icmp_imm": [
+		"wasm_category_comparison",
+		"wasm_proposal_mvp"
+	],
+	"fcmp": [
+		"wasm_category_comparison",
+		"wasm_proposal_mvp"
+	]
+}
diff --git a/cranelift/isle/veri/meta/data/wasm2clif.json b/cranelift/isle/veri/meta/data/wasm2clif.json
new file mode 100644
index 000000000000..bab3afa745b3
--- /dev/null
+++ b/cranelift/isle/veri/meta/data/wasm2clif.json
@@ -0,0 +1,5436 @@
+{
+	"operators": [
+		{
+			"op": "Unreachable",
+			"proposal": "mvp"
+		},
+		{
+			"op": "Nop",
+			"proposal": "mvp"
+		},
+		{
+			"op": "Block",
+			"proposal": "mvp"
+		},
+		{
+			"op": "Loop",
+			"proposal": "mvp"
+		},
+		{
+			"op": "If",
+			"proposal": "mvp"
+		},
+		{
+			"op": "Else",
+			"proposal": "mvp"
+		},
+		{
+			"op": "TryTable",
+			"proposal": "exceptions"
+		},
+		{
+			"op": "Throw",
+			"proposal": "exceptions"
+		},
+		{
+			"op": "ThrowRef",
+			"proposal": "exceptions"
+		},
+		{
+			"op": "Try",
+			"proposal": "legacy_exceptions"
+		},
+		{
+			"op": "Catch",
+			"proposal": "legacy_exceptions"
+		},
+		{
+			"op": "Rethrow",
+			"proposal": "legacy_exceptions"
+		},
+		{
+			"op": "Delegate",
+			"proposal": "legacy_exceptions"
+		},
+		{
+			"op": "CatchAll",
+			"proposal": "legacy_exceptions"
+		},
+		{
+			"op": "End",
+			"proposal": "mvp"
+		},
+		{
+			"op": "Br",
+			"proposal": "mvp"
+		},
+		{
+			"op": "BrIf",
+			"proposal": "mvp"
+		},
+		{
+			"op": "BrTable",
+			"proposal": "mvp"
+		},
+		{
+			"op": "Return",
+			"proposal": "mvp"
+		},
+		{
+			"op": "Call",
+			"proposal": "mvp"
+		},
+		{
+			"op": "CallIndirect",
+			"proposal": "mvp"
+		},
+		{
+			"op": "ReturnCall",
+			"proposal": "tail_call"
+		},
+		{
+			"op": "ReturnCallIndirect",
+			"proposal": "tail_call"
+		},
+		{
+			"op": "Drop",
+			"proposal": "mvp"
+		},
+		{
+			"op": "Select",
+			"proposal": "mvp"
+		},
+		{
+			"op": "TypedSelect",
+			"proposal": "reference_types"
+		},
+		{
+			"op": "LocalGet",
+			"proposal": "mvp"
+		},
+		{
+			"op": "LocalSet",
+			"proposal": "mvp"
+		},
+		{
+			"op": "LocalTee",
+			"proposal": "mvp"
+		},
+		{
+			"op": "GlobalGet",
+			"proposal": "mvp"
+		},
+		{
+			"op": "GlobalSet",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32Load",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64Load",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F32Load",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F64Load",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32Load8S",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32Load8U",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32Load16S",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32Load16U",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64Load8S",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64Load8U",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64Load16S",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64Load16U",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64Load32S",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64Load32U",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32Store",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64Store",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F32Store",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F64Store",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32Store8",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32Store16",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64Store8",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64Store16",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64Store32",
+			"proposal": "mvp"
+		},
+		{
+			"op": "MemorySize",
+			"proposal": "mvp"
+		},
+		{
+			"op": "MemoryGrow",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32Const",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64Const",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F32Const",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F64Const",
+			"proposal": "mvp"
+		},
+		{
+			"op": "RefNull",
+			"proposal": "reference_types"
+		},
+		{
+			"op": "RefIsNull",
+			"proposal": "reference_types"
+		},
+		{
+			"op": "RefFunc",
+			"proposal": "reference_types"
+		},
+		{
+			"op": "RefEq",
+			"proposal": "gc"
+		},
+		{
+			"op": "I32Eqz",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32Eq",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32Ne",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32LtS",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32LtU",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32GtS",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32GtU",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32LeS",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32LeU",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32GeS",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32GeU",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64Eqz",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64Eq",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64Ne",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64LtS",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64LtU",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64GtS",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64GtU",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64LeS",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64LeU",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64GeS",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64GeU",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F32Eq",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F32Ne",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F32Lt",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F32Gt",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F32Le",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F32Ge",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F64Eq",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F64Ne",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F64Lt",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F64Gt",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F64Le",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F64Ge",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32Clz",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32Ctz",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32Popcnt",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32Add",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32Sub",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32Mul",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32DivS",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32DivU",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32RemS",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32RemU",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32And",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32Or",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32Xor",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32Shl",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32ShrS",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32ShrU",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32Rotl",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32Rotr",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64Clz",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64Ctz",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64Popcnt",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64Add",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64Sub",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64Mul",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64DivS",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64DivU",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64RemS",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64RemU",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64And",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64Or",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64Xor",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64Shl",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64ShrS",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64ShrU",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64Rotl",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64Rotr",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F32Abs",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F32Neg",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F32Ceil",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F32Floor",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F32Trunc",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F32Nearest",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F32Sqrt",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F32Add",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F32Sub",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F32Mul",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F32Div",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F32Min",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F32Max",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F32Copysign",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F64Abs",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F64Neg",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F64Ceil",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F64Floor",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F64Trunc",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F64Nearest",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F64Sqrt",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F64Add",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F64Sub",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F64Mul",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F64Div",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F64Min",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F64Max",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F64Copysign",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32WrapI64",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32TruncF32S",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32TruncF32U",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32TruncF64S",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32TruncF64U",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64ExtendI32S",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64ExtendI32U",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64TruncF32S",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64TruncF32U",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64TruncF64S",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64TruncF64U",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F32ConvertI32S",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F32ConvertI32U",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F32ConvertI64S",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F32ConvertI64U",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F32DemoteF64",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F64ConvertI32S",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F64ConvertI32U",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F64ConvertI64S",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F64ConvertI64U",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F64PromoteF32",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32ReinterpretF32",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I64ReinterpretF64",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F32ReinterpretI32",
+			"proposal": "mvp"
+		},
+		{
+			"op": "F64ReinterpretI64",
+			"proposal": "mvp"
+		},
+		{
+			"op": "I32Extend8S",
+			"proposal": "sign_extension"
+		},
+		{
+			"op": "I32Extend16S",
+			"proposal": "sign_extension"
+		},
+		{
+			"op": "I64Extend8S",
+			"proposal": "sign_extension"
+		},
+		{
+			"op": "I64Extend16S",
+			"proposal": "sign_extension"
+		},
+		{
+			"op": "I64Extend32S",
+			"proposal": "sign_extension"
+		},
+		{
+			"op": "StructNew",
+			"proposal": "gc"
+		},
+		{
+			"op": "StructNewDefault",
+			"proposal": "gc"
+		},
+		{
+			"op": "StructGet",
+			"proposal": "gc"
+		},
+		{
+			"op": "StructGetS",
+			"proposal": "gc"
+		},
+		{
+			"op": "StructGetU",
+			"proposal": "gc"
+		},
+		{
+			"op": "StructSet",
+			"proposal": "gc"
+		},
+		{
+			"op": "ArrayNew",
+			"proposal": "gc"
+		},
+		{
+			"op": "ArrayNewDefault",
+			"proposal": "gc"
+		},
+		{
+			"op": "ArrayNewFixed",
+			"proposal": "gc"
+		},
+		{
+			"op": "ArrayNewData",
+			"proposal": "gc"
+		},
+		{
+			"op": "ArrayNewElem",
+			"proposal": "gc"
+		},
+		{
+			"op": "ArrayGet",
+			"proposal": "gc"
+		},
+		{
+			"op": "ArrayGetS",
+			"proposal": "gc"
+		},
+		{
+			"op": "ArrayGetU",
+			"proposal": "gc"
+		},
+		{
+			"op": "ArraySet",
+			"proposal": "gc"
+		},
+		{
+			"op": "ArrayLen",
+			"proposal": "gc"
+		},
+		{
+			"op": "ArrayFill",
+			"proposal": "gc"
+		},
+		{
+			"op": "ArrayCopy",
+			"proposal": "gc"
+		},
+		{
+			"op": "ArrayInitData",
+			"proposal": "gc"
+		},
+		{
+			"op": "ArrayInitElem",
+			"proposal": "gc"
+		},
+		{
+			"op": "RefTestNonNull",
+			"proposal": "gc"
+		},
+		{
+			"op": "RefTestNullable",
+			"proposal": "gc"
+		},
+		{
+			"op": "RefCastNonNull",
+			"proposal": "gc"
+		},
+		{
+			"op": "RefCastNullable",
+			"proposal": "gc"
+		},
+		{
+			"op": "BrOnCast",
+			"proposal": "gc"
+		},
+		{
+			"op": "BrOnCastFail",
+			"proposal": "gc"
+		},
+		{
+			"op": "AnyConvertExtern",
+			"proposal": "gc"
+		},
+		{
+			"op": "ExternConvertAny",
+			"proposal": "gc"
+		},
+		{
+			"op": "RefI31",
+			"proposal": "gc"
+		},
+		{
+			"op": "I31GetS",
+			"proposal": "gc"
+		},
+		{
+			"op": "I31GetU",
+			"proposal": "gc"
+		},
+		{
+			"op": "I32TruncSatF32S",
+			"proposal": "saturating_float_to_int"
+		},
+		{
+			"op": "I32TruncSatF32U",
+			"proposal": "saturating_float_to_int"
+		},
+		{
+			"op": "I32TruncSatF64S",
+			"proposal": "saturating_float_to_int"
+		},
+		{
+			"op": "I32TruncSatF64U",
+			"proposal": "saturating_float_to_int"
+		},
+		{
+			"op": "I64TruncSatF32S",
+			"proposal": "saturating_float_to_int"
+		},
+		{
+			"op": "I64TruncSatF32U",
+			"proposal": "saturating_float_to_int"
+		},
+		{
+			"op": "I64TruncSatF64S",
+			"proposal": "saturating_float_to_int"
+		},
+		{
+			"op": "I64TruncSatF64U",
+			"proposal": "saturating_float_to_int"
+		},
+		{
+			"op": "MemoryInit",
+			"proposal": "bulk_memory"
+		},
+		{
+			"op": "DataDrop",
+			"proposal": "bulk_memory"
+		},
+		{
+			"op": "MemoryCopy",
+			"proposal": "bulk_memory"
+		},
+		{
+			"op": "MemoryFill",
+			"proposal": "bulk_memory"
+		},
+		{
+			"op": "TableInit",
+			"proposal": "bulk_memory"
+		},
+		{
+			"op": "ElemDrop",
+			"proposal": "bulk_memory"
+		},
+		{
+			"op": "TableCopy",
+			"proposal": "bulk_memory"
+		},
+		{
+			"op": "TableFill",
+			"proposal": "reference_types"
+		},
+		{
+			"op": "TableGet",
+			"proposal": "reference_types"
+		},
+		{
+			"op": "TableSet",
+			"proposal": "reference_types"
+		},
+		{
+			"op": "TableGrow",
+			"proposal": "reference_types"
+		},
+		{
+			"op": "TableSize",
+			"proposal": "reference_types"
+		},
+		{
+			"op": "MemoryDiscard",
+			"proposal": "memory_control"
+		},
+		{
+			"op": "MemoryAtomicNotify",
+			"proposal": "threads"
+		},
+		{
+			"op": "MemoryAtomicWait32",
+			"proposal": "threads"
+		},
+		{
+			"op": "MemoryAtomicWait64",
+			"proposal": "threads"
+		},
+		{
+			"op": "AtomicFence",
+			"proposal": "threads"
+		},
+		{
+			"op": "I32AtomicLoad",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicLoad",
+			"proposal": "threads"
+		},
+		{
+			"op": "I32AtomicLoad8U",
+			"proposal": "threads"
+		},
+		{
+			"op": "I32AtomicLoad16U",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicLoad8U",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicLoad16U",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicLoad32U",
+			"proposal": "threads"
+		},
+		{
+			"op": "I32AtomicStore",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicStore",
+			"proposal": "threads"
+		},
+		{
+			"op": "I32AtomicStore8",
+			"proposal": "threads"
+		},
+		{
+			"op": "I32AtomicStore16",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicStore8",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicStore16",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicStore32",
+			"proposal": "threads"
+		},
+		{
+			"op": "I32AtomicRmwAdd",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicRmwAdd",
+			"proposal": "threads"
+		},
+		{
+			"op": "I32AtomicRmw8AddU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I32AtomicRmw16AddU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicRmw8AddU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicRmw16AddU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicRmw32AddU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I32AtomicRmwSub",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicRmwSub",
+			"proposal": "threads"
+		},
+		{
+			"op": "I32AtomicRmw8SubU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I32AtomicRmw16SubU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicRmw8SubU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicRmw16SubU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicRmw32SubU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I32AtomicRmwAnd",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicRmwAnd",
+			"proposal": "threads"
+		},
+		{
+			"op": "I32AtomicRmw8AndU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I32AtomicRmw16AndU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicRmw8AndU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicRmw16AndU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicRmw32AndU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I32AtomicRmwOr",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicRmwOr",
+			"proposal": "threads"
+		},
+		{
+			"op": "I32AtomicRmw8OrU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I32AtomicRmw16OrU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicRmw8OrU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicRmw16OrU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicRmw32OrU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I32AtomicRmwXor",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicRmwXor",
+			"proposal": "threads"
+		},
+		{
+			"op": "I32AtomicRmw8XorU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I32AtomicRmw16XorU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicRmw8XorU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicRmw16XorU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicRmw32XorU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I32AtomicRmwXchg",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicRmwXchg",
+			"proposal": "threads"
+		},
+		{
+			"op": "I32AtomicRmw8XchgU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I32AtomicRmw16XchgU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicRmw8XchgU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicRmw16XchgU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicRmw32XchgU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I32AtomicRmwCmpxchg",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicRmwCmpxchg",
+			"proposal": "threads"
+		},
+		{
+			"op": "I32AtomicRmw8CmpxchgU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I32AtomicRmw16CmpxchgU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicRmw8CmpxchgU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicRmw16CmpxchgU",
+			"proposal": "threads"
+		},
+		{
+			"op": "I64AtomicRmw32CmpxchgU",
+			"proposal": "threads"
+		},
+		{
+			"op": "GlobalAtomicGet",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "GlobalAtomicSet",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "GlobalAtomicRmwAdd",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "GlobalAtomicRmwSub",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "GlobalAtomicRmwAnd",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "GlobalAtomicRmwOr",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "GlobalAtomicRmwXor",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "GlobalAtomicRmwXchg",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "GlobalAtomicRmwCmpxchg",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "TableAtomicGet",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "TableAtomicSet",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "TableAtomicRmwXchg",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "TableAtomicRmwCmpxchg",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "StructAtomicGet",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "StructAtomicGetS",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "StructAtomicGetU",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "StructAtomicSet",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "StructAtomicRmwAdd",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "StructAtomicRmwSub",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "StructAtomicRmwAnd",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "StructAtomicRmwOr",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "StructAtomicRmwXor",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "StructAtomicRmwXchg",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "StructAtomicRmwCmpxchg",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "ArrayAtomicGet",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "ArrayAtomicGetS",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "ArrayAtomicGetU",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "ArrayAtomicSet",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "ArrayAtomicRmwAdd",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "ArrayAtomicRmwSub",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "ArrayAtomicRmwAnd",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "ArrayAtomicRmwOr",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "ArrayAtomicRmwXor",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "ArrayAtomicRmwXchg",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "ArrayAtomicRmwCmpxchg",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "RefI31Shared",
+			"proposal": "shared_everything_threads"
+		},
+		{
+			"op": "V128Load",
+			"proposal": "simd"
+		},
+		{
+			"op": "V128Load8x8S",
+			"proposal": "simd"
+		},
+		{
+			"op": "V128Load8x8U",
+			"proposal": "simd"
+		},
+		{
+			"op": "V128Load16x4S",
+			"proposal": "simd"
+		},
+		{
+			"op": "V128Load16x4U",
+			"proposal": "simd"
+		},
+		{
+			"op": "V128Load32x2S",
+			"proposal": "simd"
+		},
+		{
+			"op": "V128Load32x2U",
+			"proposal": "simd"
+		},
+		{
+			"op": "V128Load8Splat",
+			"proposal": "simd"
+		},
+		{
+			"op": "V128Load16Splat",
+			"proposal": "simd"
+		},
+		{
+			"op": "V128Load32Splat",
+			"proposal": "simd"
+		},
+		{
+			"op": "V128Load64Splat",
+			"proposal": "simd"
+		},
+		{
+			"op": "V128Load32Zero",
+			"proposal": "simd"
+		},
+		{
+			"op": "V128Load64Zero",
+			"proposal": "simd"
+		},
+		{
+			"op": "V128Store",
+			"proposal": "simd"
+		},
+		{
+			"op": "V128Load8Lane",
+			"proposal": "simd"
+		},
+		{
+			"op": "V128Load16Lane",
+			"proposal": "simd"
+		},
+		{
+			"op": "V128Load32Lane",
+			"proposal": "simd"
+		},
+		{
+			"op": "V128Load64Lane",
+			"proposal": "simd"
+		},
+		{
+			"op": "V128Store8Lane",
+			"proposal": "simd"
+		},
+		{
+			"op": "V128Store16Lane",
+			"proposal": "simd"
+		},
+		{
+			"op": "V128Store32Lane",
+			"proposal": "simd"
+		},
+		{
+			"op": "V128Store64Lane",
+			"proposal": "simd"
+		},
+		{
+			"op": "V128Const",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16Shuffle",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16ExtractLaneS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16ExtractLaneU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16ReplaceLane",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8ExtractLaneS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8ExtractLaneU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8ReplaceLane",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4ExtractLane",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4ReplaceLane",
+			"proposal": "simd"
+		},
+		{
+			"op": "I64x2ExtractLane",
+			"proposal": "simd"
+		},
+		{
+			"op": "I64x2ReplaceLane",
+			"proposal": "simd"
+		},
+		{
+			"op": "F32x4ExtractLane",
+			"proposal": "simd"
+		},
+		{
+			"op": "F32x4ReplaceLane",
+			"proposal": "simd"
+		},
+		{
+			"op": "F64x2ExtractLane",
+			"proposal": "simd"
+		},
+		{
+			"op": "F64x2ReplaceLane",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16Swizzle",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16Splat",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8Splat",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4Splat",
+			"proposal": "simd"
+		},
+		{
+			"op": "I64x2Splat",
+			"proposal": "simd"
+		},
+		{
+			"op": "F32x4Splat",
+			"proposal": "simd"
+		},
+		{
+			"op": "F64x2Splat",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16Eq",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16Ne",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16LtS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16LtU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16GtS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16GtU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16LeS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16LeU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16GeS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16GeU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8Eq",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8Ne",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8LtS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8LtU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8GtS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8GtU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8LeS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8LeU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8GeS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8GeU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4Eq",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4Ne",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4LtS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4LtU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4GtS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4GtU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4LeS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4LeU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4GeS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4GeU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I64x2Eq",
+			"proposal": "simd"
+		},
+		{
+			"op": "I64x2Ne",
+			"proposal": "simd"
+		},
+		{
+			"op": "I64x2LtS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I64x2GtS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I64x2LeS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I64x2GeS",
+			"proposal": "simd"
+		},
+		{
+			"op": "F32x4Eq",
+			"proposal": "simd"
+		},
+		{
+			"op": "F32x4Ne",
+			"proposal": "simd"
+		},
+		{
+			"op": "F32x4Lt",
+			"proposal": "simd"
+		},
+		{
+			"op": "F32x4Gt",
+			"proposal": "simd"
+		},
+		{
+			"op": "F32x4Le",
+			"proposal": "simd"
+		},
+		{
+			"op": "F32x4Ge",
+			"proposal": "simd"
+		},
+		{
+			"op": "F64x2Eq",
+			"proposal": "simd"
+		},
+		{
+			"op": "F64x2Ne",
+			"proposal": "simd"
+		},
+		{
+			"op": "F64x2Lt",
+			"proposal": "simd"
+		},
+		{
+			"op": "F64x2Gt",
+			"proposal": "simd"
+		},
+		{
+			"op": "F64x2Le",
+			"proposal": "simd"
+		},
+		{
+			"op": "F64x2Ge",
+			"proposal": "simd"
+		},
+		{
+			"op": "V128Not",
+			"proposal": "simd"
+		},
+		{
+			"op": "V128And",
+			"proposal": "simd"
+		},
+		{
+			"op": "V128AndNot",
+			"proposal": "simd"
+		},
+		{
+			"op": "V128Or",
+			"proposal": "simd"
+		},
+		{
+			"op": "V128Xor",
+			"proposal": "simd"
+		},
+		{
+			"op": "V128Bitselect",
+			"proposal": "simd"
+		},
+		{
+			"op": "V128AnyTrue",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16Abs",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16Neg",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16Popcnt",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16AllTrue",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16Bitmask",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16NarrowI16x8S",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16NarrowI16x8U",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16Shl",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16ShrS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16ShrU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16Add",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16AddSatS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16AddSatU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16Sub",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16SubSatS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16SubSatU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16MinS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16MinU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16MaxS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16MaxU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16AvgrU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8ExtAddPairwiseI8x16S",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8ExtAddPairwiseI8x16U",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8Abs",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8Neg",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8Q15MulrSatS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8AllTrue",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8Bitmask",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8NarrowI32x4S",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8NarrowI32x4U",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8ExtendLowI8x16S",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8ExtendHighI8x16S",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8ExtendLowI8x16U",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8ExtendHighI8x16U",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8Shl",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8ShrS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8ShrU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8Add",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8AddSatS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8AddSatU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8Sub",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8SubSatS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8SubSatU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8Mul",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8MinS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8MinU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8MaxS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8MaxU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8AvgrU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8ExtMulLowI8x16S",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8ExtMulHighI8x16S",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8ExtMulLowI8x16U",
+			"proposal": "simd"
+		},
+		{
+			"op": "I16x8ExtMulHighI8x16U",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4ExtAddPairwiseI16x8S",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4ExtAddPairwiseI16x8U",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4Abs",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4Neg",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4AllTrue",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4Bitmask",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4ExtendLowI16x8S",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4ExtendHighI16x8S",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4ExtendLowI16x8U",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4ExtendHighI16x8U",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4Shl",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4ShrS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4ShrU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4Add",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4Sub",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4Mul",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4MinS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4MinU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4MaxS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4MaxU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4DotI16x8S",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4ExtMulLowI16x8S",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4ExtMulHighI16x8S",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4ExtMulLowI16x8U",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4ExtMulHighI16x8U",
+			"proposal": "simd"
+		},
+		{
+			"op": "I64x2Abs",
+			"proposal": "simd"
+		},
+		{
+			"op": "I64x2Neg",
+			"proposal": "simd"
+		},
+		{
+			"op": "I64x2AllTrue",
+			"proposal": "simd"
+		},
+		{
+			"op": "I64x2Bitmask",
+			"proposal": "simd"
+		},
+		{
+			"op": "I64x2ExtendLowI32x4S",
+			"proposal": "simd"
+		},
+		{
+			"op": "I64x2ExtendHighI32x4S",
+			"proposal": "simd"
+		},
+		{
+			"op": "I64x2ExtendLowI32x4U",
+			"proposal": "simd"
+		},
+		{
+			"op": "I64x2ExtendHighI32x4U",
+			"proposal": "simd"
+		},
+		{
+			"op": "I64x2Shl",
+			"proposal": "simd"
+		},
+		{
+			"op": "I64x2ShrS",
+			"proposal": "simd"
+		},
+		{
+			"op": "I64x2ShrU",
+			"proposal": "simd"
+		},
+		{
+			"op": "I64x2Add",
+			"proposal": "simd"
+		},
+		{
+			"op": "I64x2Sub",
+			"proposal": "simd"
+		},
+		{
+			"op": "I64x2Mul",
+			"proposal": "simd"
+		},
+		{
+			"op": "I64x2ExtMulLowI32x4S",
+			"proposal": "simd"
+		},
+		{
+			"op": "I64x2ExtMulHighI32x4S",
+			"proposal": "simd"
+		},
+		{
+			"op": "I64x2ExtMulLowI32x4U",
+			"proposal": "simd"
+		},
+		{
+			"op": "I64x2ExtMulHighI32x4U",
+			"proposal": "simd"
+		},
+		{
+			"op": "F32x4Ceil",
+			"proposal": "simd"
+		},
+		{
+			"op": "F32x4Floor",
+			"proposal": "simd"
+		},
+		{
+			"op": "F32x4Trunc",
+			"proposal": "simd"
+		},
+		{
+			"op": "F32x4Nearest",
+			"proposal": "simd"
+		},
+		{
+			"op": "F32x4Abs",
+			"proposal": "simd"
+		},
+		{
+			"op": "F32x4Neg",
+			"proposal": "simd"
+		},
+		{
+			"op": "F32x4Sqrt",
+			"proposal": "simd"
+		},
+		{
+			"op": "F32x4Add",
+			"proposal": "simd"
+		},
+		{
+			"op": "F32x4Sub",
+			"proposal": "simd"
+		},
+		{
+			"op": "F32x4Mul",
+			"proposal": "simd"
+		},
+		{
+			"op": "F32x4Div",
+			"proposal": "simd"
+		},
+		{
+			"op": "F32x4Min",
+			"proposal": "simd"
+		},
+		{
+			"op": "F32x4Max",
+			"proposal": "simd"
+		},
+		{
+			"op": "F32x4PMin",
+			"proposal": "simd"
+		},
+		{
+			"op": "F32x4PMax",
+			"proposal": "simd"
+		},
+		{
+			"op": "F64x2Ceil",
+			"proposal": "simd"
+		},
+		{
+			"op": "F64x2Floor",
+			"proposal": "simd"
+		},
+		{
+			"op": "F64x2Trunc",
+			"proposal": "simd"
+		},
+		{
+			"op": "F64x2Nearest",
+			"proposal": "simd"
+		},
+		{
+			"op": "F64x2Abs",
+			"proposal": "simd"
+		},
+		{
+			"op": "F64x2Neg",
+			"proposal": "simd"
+		},
+		{
+			"op": "F64x2Sqrt",
+			"proposal": "simd"
+		},
+		{
+			"op": "F64x2Add",
+			"proposal": "simd"
+		},
+		{
+			"op": "F64x2Sub",
+			"proposal": "simd"
+		},
+		{
+			"op": "F64x2Mul",
+			"proposal": "simd"
+		},
+		{
+			"op": "F64x2Div",
+			"proposal": "simd"
+		},
+		{
+			"op": "F64x2Min",
+			"proposal": "simd"
+		},
+		{
+			"op": "F64x2Max",
+			"proposal": "simd"
+		},
+		{
+			"op": "F64x2PMin",
+			"proposal": "simd"
+		},
+		{
+			"op": "F64x2PMax",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4TruncSatF32x4S",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4TruncSatF32x4U",
+			"proposal": "simd"
+		},
+		{
+			"op": "F32x4ConvertI32x4S",
+			"proposal": "simd"
+		},
+		{
+			"op": "F32x4ConvertI32x4U",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4TruncSatF64x2SZero",
+			"proposal": "simd"
+		},
+		{
+			"op": "I32x4TruncSatF64x2UZero",
+			"proposal": "simd"
+		},
+		{
+			"op": "F64x2ConvertLowI32x4S",
+			"proposal": "simd"
+		},
+		{
+			"op": "F64x2ConvertLowI32x4U",
+			"proposal": "simd"
+		},
+		{
+			"op": "F32x4DemoteF64x2Zero",
+			"proposal": "simd"
+		},
+		{
+			"op": "F64x2PromoteLowF32x4",
+			"proposal": "simd"
+		},
+		{
+			"op": "I8x16RelaxedSwizzle",
+			"proposal": "relaxed_simd"
+		},
+		{
+			"op": "I32x4RelaxedTruncF32x4S",
+			"proposal": "relaxed_simd"
+		},
+		{
+			"op": "I32x4RelaxedTruncF32x4U",
+			"proposal": "relaxed_simd"
+		},
+		{
+			"op": "I32x4RelaxedTruncF64x2SZero",
+			"proposal": "relaxed_simd"
+		},
+		{
+			"op": "I32x4RelaxedTruncF64x2UZero",
+			"proposal": "relaxed_simd"
+		},
+		{
+			"op": "F32x4RelaxedMadd",
+			"proposal": "relaxed_simd"
+		},
+		{
+			"op": "F32x4RelaxedNmadd",
+			"proposal": "relaxed_simd"
+		},
+		{
+			"op": "F64x2RelaxedMadd",
+			"proposal": "relaxed_simd"
+		},
+		{
+			"op": "F64x2RelaxedNmadd",
+			"proposal": "relaxed_simd"
+		},
+		{
+			"op": "I8x16RelaxedLaneselect",
+			"proposal": "relaxed_simd"
+		},
+		{
+			"op": "I16x8RelaxedLaneselect",
+			"proposal": "relaxed_simd"
+		},
+		{
+			"op": "I32x4RelaxedLaneselect",
+			"proposal": "relaxed_simd"
+		},
+		{
+			"op": "I64x2RelaxedLaneselect",
+			"proposal": "relaxed_simd"
+		},
+		{
+			"op": "F32x4RelaxedMin",
+			"proposal": "relaxed_simd"
+		},
+		{
+			"op": "F32x4RelaxedMax",
+			"proposal": "relaxed_simd"
+		},
+		{
+			"op": "F64x2RelaxedMin",
+			"proposal": "relaxed_simd"
+		},
+		{
+			"op": "F64x2RelaxedMax",
+			"proposal": "relaxed_simd"
+		},
+		{
+			"op": "I16x8RelaxedQ15mulrS",
+			"proposal": "relaxed_simd"
+		},
+		{
+			"op": "I16x8RelaxedDotI8x16I7x16S",
+			"proposal": "relaxed_simd"
+		},
+		{
+			"op": "I32x4RelaxedDotI8x16I7x16AddS",
+			"proposal": "relaxed_simd"
+		},
+		{
+			"op": "CallRef",
+			"proposal": "function_references"
+		},
+		{
+			"op": "ReturnCallRef",
+			"proposal": "function_references"
+		},
+		{
+			"op": "RefAsNonNull",
+			"proposal": "function_references"
+		},
+		{
+			"op": "BrOnNull",
+			"proposal": "function_references"
+		},
+		{
+			"op": "BrOnNonNull",
+			"proposal": "function_references"
+		}
+	],
+	"translations": [
+		{
+			"operators": [
+				"LocalGet"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"LocalSet"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"LocalTee"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"GlobalGet"
+			],
+			"instructions": [
+				"global_value",
+				"load"
+			]
+		},
+		{
+			"operators": [
+				"GlobalSet"
+			],
+			"instructions": [
+				"global_value",
+				"store"
+			]
+		},
+		{
+			"operators": [
+				"Drop"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"Select"
+			],
+			"instructions": [
+				"select"
+			]
+		},
+		{
+			"operators": [
+				"TypedSelect"
+			],
+			"instructions": [
+				"select"
+			]
+		},
+		{
+			"operators": [
+				"Nop"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"Unreachable"
+			],
+			"instructions": [
+				"trap"
+			]
+		},
+		{
+			"operators": [
+				"Block"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"Loop"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"If"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"Else"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"End"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"Br"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"BrIf"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"BrTable"
+			],
+			"instructions": [
+				"br_table"
+			]
+		},
+		{
+			"operators": [
+				"Return"
+			],
+			"instructions": [
+				"return_"
+			]
+		},
+		{
+			"operators": [
+				"Try",
+				"Catch",
+				"Throw",
+				"Rethrow",
+				"Delegate",
+				"CatchAll"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"Call"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"CallIndirect"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"ReturnCall"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"ReturnCallIndirect"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"ReturnCallRef"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"MemoryGrow"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"MemorySize"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I32Load8U"
+			],
+			"instructions": [
+				"icmp",
+				"iconst",
+				"isub",
+				"uadd_overflow_trap",
+				"uload8"
+			]
+		},
+		{
+			"operators": [
+				"I32Load16U"
+			],
+			"instructions": [
+				"icmp",
+				"iconst",
+				"isub",
+				"uadd_overflow_trap",
+				"uload16"
+			]
+		},
+		{
+			"operators": [
+				"I32Load8S"
+			],
+			"instructions": [
+				"icmp",
+				"iconst",
+				"isub",
+				"sload8",
+				"uadd_overflow_trap"
+			]
+		},
+		{
+			"operators": [
+				"I32Load16S"
+			],
+			"instructions": [
+				"icmp",
+				"iconst",
+				"isub",
+				"sload16",
+				"uadd_overflow_trap"
+			]
+		},
+		{
+			"operators": [
+				"I64Load8U"
+			],
+			"instructions": [
+				"icmp",
+				"iconst",
+				"isub",
+				"uadd_overflow_trap",
+				"uload8"
+			]
+		},
+		{
+			"operators": [
+				"I64Load16U"
+			],
+			"instructions": [
+				"icmp",
+				"iconst",
+				"isub",
+				"uadd_overflow_trap",
+				"uload16"
+			]
+		},
+		{
+			"operators": [
+				"I64Load8S"
+			],
+			"instructions": [
+				"icmp",
+				"iconst",
+				"isub",
+				"sload8",
+				"uadd_overflow_trap"
+			]
+		},
+		{
+			"operators": [
+				"I64Load16S"
+			],
+			"instructions": [
+				"icmp",
+				"iconst",
+				"isub",
+				"sload16",
+				"uadd_overflow_trap"
+			]
+		},
+		{
+			"operators": [
+				"I64Load32S"
+			],
+			"instructions": [
+				"icmp",
+				"iconst",
+				"isub",
+				"sload32",
+				"uadd_overflow_trap"
+			]
+		},
+		{
+			"operators": [
+				"I64Load32U"
+			],
+			"instructions": [
+				"icmp",
+				"iconst",
+				"isub",
+				"uadd_overflow_trap",
+				"uload32"
+			]
+		},
+		{
+			"operators": [
+				"I32Load"
+			],
+			"instructions": [
+				"icmp",
+				"iconst",
+				"isub",
+				"load",
+				"uadd_overflow_trap"
+			]
+		},
+		{
+			"operators": [
+				"F32Load"
+			],
+			"instructions": [
+				"icmp",
+				"iconst",
+				"isub",
+				"load",
+				"uadd_overflow_trap"
+			]
+		},
+		{
+			"operators": [
+				"I64Load"
+			],
+			"instructions": [
+				"icmp",
+				"iconst",
+				"isub",
+				"load",
+				"uadd_overflow_trap"
+			]
+		},
+		{
+			"operators": [
+				"F64Load"
+			],
+			"instructions": [
+				"icmp",
+				"iconst",
+				"isub",
+				"load",
+				"uadd_overflow_trap"
+			]
+		},
+		{
+			"operators": [
+				"V128Load"
+			],
+			"instructions": [
+				"icmp",
+				"iconst",
+				"isub",
+				"load",
+				"uadd_overflow_trap"
+			]
+		},
+		{
+			"operators": [
+				"V128Load8x8S"
+			],
+			"instructions": [
+				"sload8x8"
+			]
+		},
+		{
+			"operators": [
+				"V128Load8x8U"
+			],
+			"instructions": [
+				"uload8x8"
+			]
+		},
+		{
+			"operators": [
+				"V128Load16x4S"
+			],
+			"instructions": [
+				"sload16x4"
+			]
+		},
+		{
+			"operators": [
+				"V128Load16x4U"
+			],
+			"instructions": [
+				"uload16x4"
+			]
+		},
+		{
+			"operators": [
+				"V128Load32x2S"
+			],
+			"instructions": [
+				"sload32x2"
+			]
+		},
+		{
+			"operators": [
+				"V128Load32x2U"
+			],
+			"instructions": [
+				"uload32x2"
+			]
+		},
+		{
+			"operators": [
+				"I32Store",
+				"I64Store",
+				"F32Store",
+				"F64Store"
+			],
+			"instructions": [
+				"icmp",
+				"iconst",
+				"isub",
+				"store",
+				"uadd_overflow_trap"
+			]
+		},
+		{
+			"operators": [
+				"I32Store8",
+				"I64Store8"
+			],
+			"instructions": [
+				"icmp",
+				"iconst",
+				"istore8",
+				"isub",
+				"uadd_overflow_trap"
+			]
+		},
+		{
+			"operators": [
+				"I32Store16",
+				"I64Store16"
+			],
+			"instructions": [
+				"icmp",
+				"iconst",
+				"istore16",
+				"isub",
+				"uadd_overflow_trap"
+			]
+		},
+		{
+			"operators": [
+				"I64Store32"
+			],
+			"instructions": [
+				"icmp",
+				"iconst",
+				"istore32",
+				"isub",
+				"uadd_overflow_trap"
+			]
+		},
+		{
+			"operators": [
+				"V128Store"
+			],
+			"instructions": [
+				"icmp",
+				"iconst",
+				"isub",
+				"store",
+				"uadd_overflow_trap"
+			]
+		},
+		{
+			"operators": [
+				"I32Const"
+			],
+			"instructions": [
+				"iconst"
+			]
+		},
+		{
+			"operators": [
+				"I64Const"
+			],
+			"instructions": [
+				"iconst"
+			]
+		},
+		{
+			"operators": [
+				"F32Const"
+			],
+			"instructions": [
+				"f32const"
+			]
+		},
+		{
+			"operators": [
+				"F64Const"
+			],
+			"instructions": [
+				"f64const"
+			]
+		},
+		{
+			"operators": [
+				"I32Clz",
+				"I64Clz"
+			],
+			"instructions": [
+				"clz"
+			]
+		},
+		{
+			"operators": [
+				"I32Ctz",
+				"I64Ctz"
+			],
+			"instructions": [
+				"ctz"
+			]
+		},
+		{
+			"operators": [
+				"I32Popcnt",
+				"I64Popcnt"
+			],
+			"instructions": [
+				"popcnt"
+			]
+		},
+		{
+			"operators": [
+				"I64ExtendI32S"
+			],
+			"instructions": [
+				"sextend"
+			]
+		},
+		{
+			"operators": [
+				"I64ExtendI32U"
+			],
+			"instructions": [
+				"uextend"
+			]
+		},
+		{
+			"operators": [
+				"I32WrapI64"
+			],
+			"instructions": [
+				"ireduce"
+			]
+		},
+		{
+			"operators": [
+				"F32Sqrt",
+				"F64Sqrt"
+			],
+			"instructions": [
+				"sqrt"
+			]
+		},
+		{
+			"operators": [
+				"F32Ceil",
+				"F64Ceil"
+			],
+			"instructions": [
+				"ceil"
+			]
+		},
+		{
+			"operators": [
+				"F32Floor",
+				"F64Floor"
+			],
+			"instructions": [
+				"floor"
+			]
+		},
+		{
+			"operators": [
+				"F32Trunc",
+				"F64Trunc"
+			],
+			"instructions": [
+				"trunc"
+			]
+		},
+		{
+			"operators": [
+				"F32Nearest",
+				"F64Nearest"
+			],
+			"instructions": [
+				"nearest"
+			]
+		},
+		{
+			"operators": [
+				"F32Abs",
+				"F64Abs"
+			],
+			"instructions": [
+				"fabs"
+			]
+		},
+		{
+			"operators": [
+				"F32Neg",
+				"F64Neg"
+			],
+			"instructions": [
+				"fneg"
+			]
+		},
+		{
+			"operators": [
+				"F64ConvertI64U",
+				"F64ConvertI32U"
+			],
+			"instructions": [
+				"fcvt_from_uint"
+			]
+		},
+		{
+			"operators": [
+				"F64ConvertI64S",
+				"F64ConvertI32S"
+			],
+			"instructions": [
+				"fcvt_from_sint"
+			]
+		},
+		{
+			"operators": [
+				"F32ConvertI64S",
+				"F32ConvertI32S"
+			],
+			"instructions": [
+				"fcvt_from_sint"
+			]
+		},
+		{
+			"operators": [
+				"F32ConvertI64U",
+				"F32ConvertI32U"
+			],
+			"instructions": [
+				"fcvt_from_uint"
+			]
+		},
+		{
+			"operators": [
+				"F64PromoteF32"
+			],
+			"instructions": [
+				"fpromote"
+			]
+		},
+		{
+			"operators": [
+				"F32DemoteF64"
+			],
+			"instructions": [
+				"fdemote"
+			]
+		},
+		{
+			"operators": [
+				"I64TruncF64S",
+				"I64TruncF32S"
+			],
+			"instructions": [
+				"fcvt_to_sint"
+			]
+		},
+		{
+			"operators": [
+				"I32TruncF64S",
+				"I32TruncF32S"
+			],
+			"instructions": [
+				"fcvt_to_sint"
+			]
+		},
+		{
+			"operators": [
+				"I64TruncF64U",
+				"I64TruncF32U"
+			],
+			"instructions": [
+				"fcvt_to_uint"
+			]
+		},
+		{
+			"operators": [
+				"I32TruncF64U",
+				"I32TruncF32U"
+			],
+			"instructions": [
+				"fcvt_to_uint"
+			]
+		},
+		{
+			"operators": [
+				"I64TruncSatF64S",
+				"I64TruncSatF32S"
+			],
+			"instructions": [
+				"fcvt_to_sint_sat"
+			]
+		},
+		{
+			"operators": [
+				"I32TruncSatF64S",
+				"I32TruncSatF32S"
+			],
+			"instructions": [
+				"fcvt_to_sint_sat"
+			]
+		},
+		{
+			"operators": [
+				"I64TruncSatF64U",
+				"I64TruncSatF32U"
+			],
+			"instructions": [
+				"fcvt_to_uint_sat"
+			]
+		},
+		{
+			"operators": [
+				"I32TruncSatF64U",
+				"I32TruncSatF32U"
+			],
+			"instructions": [
+				"fcvt_to_uint_sat"
+			]
+		},
+		{
+			"operators": [
+				"F32ReinterpretI32"
+			],
+			"instructions": [
+				"bitcast"
+			]
+		},
+		{
+			"operators": [
+				"F64ReinterpretI64"
+			],
+			"instructions": [
+				"bitcast"
+			]
+		},
+		{
+			"operators": [
+				"I32ReinterpretF32"
+			],
+			"instructions": [
+				"bitcast"
+			]
+		},
+		{
+			"operators": [
+				"I64ReinterpretF64"
+			],
+			"instructions": [
+				"bitcast"
+			]
+		},
+		{
+			"operators": [
+				"I32Extend8S"
+			],
+			"instructions": [
+				"ireduce",
+				"sextend"
+			]
+		},
+		{
+			"operators": [
+				"I32Extend16S"
+			],
+			"instructions": [
+				"ireduce",
+				"sextend"
+			]
+		},
+		{
+			"operators": [
+				"I64Extend8S"
+			],
+			"instructions": [
+				"ireduce",
+				"sextend"
+			]
+		},
+		{
+			"operators": [
+				"I64Extend16S"
+			],
+			"instructions": [
+				"ireduce",
+				"sextend"
+			]
+		},
+		{
+			"operators": [
+				"I64Extend32S"
+			],
+			"instructions": [
+				"ireduce",
+				"sextend"
+			]
+		},
+		{
+			"operators": [
+				"I32Add",
+				"I64Add"
+			],
+			"instructions": [
+				"iadd"
+			]
+		},
+		{
+			"operators": [
+				"I32And",
+				"I64And"
+			],
+			"instructions": [
+				"band"
+			]
+		},
+		{
+			"operators": [
+				"I32Or",
+				"I64Or"
+			],
+			"instructions": [
+				"bor"
+			]
+		},
+		{
+			"operators": [
+				"I32Xor",
+				"I64Xor"
+			],
+			"instructions": [
+				"bxor"
+			]
+		},
+		{
+			"operators": [
+				"I32Shl",
+				"I64Shl"
+			],
+			"instructions": [
+				"ishl"
+			]
+		},
+		{
+			"operators": [
+				"I32ShrS",
+				"I64ShrS"
+			],
+			"instructions": [
+				"sshr"
+			]
+		},
+		{
+			"operators": [
+				"I32ShrU",
+				"I64ShrU"
+			],
+			"instructions": [
+				"ushr"
+			]
+		},
+		{
+			"operators": [
+				"I32Rotl",
+				"I64Rotl"
+			],
+			"instructions": [
+				"rotl"
+			]
+		},
+		{
+			"operators": [
+				"I32Rotr",
+				"I64Rotr"
+			],
+			"instructions": [
+				"rotr"
+			]
+		},
+		{
+			"operators": [
+				"F32Add",
+				"F64Add"
+			],
+			"instructions": [
+				"fadd"
+			]
+		},
+		{
+			"operators": [
+				"I32Sub",
+				"I64Sub"
+			],
+			"instructions": [
+				"isub"
+			]
+		},
+		{
+			"operators": [
+				"F32Sub",
+				"F64Sub"
+			],
+			"instructions": [
+				"fsub"
+			]
+		},
+		{
+			"operators": [
+				"I32Mul",
+				"I64Mul"
+			],
+			"instructions": [
+				"imul"
+			]
+		},
+		{
+			"operators": [
+				"F32Mul",
+				"F64Mul"
+			],
+			"instructions": [
+				"fmul"
+			]
+		},
+		{
+			"operators": [
+				"F32Div",
+				"F64Div"
+			],
+			"instructions": [
+				"fdiv"
+			]
+		},
+		{
+			"operators": [
+				"I32DivS",
+				"I64DivS"
+			],
+			"instructions": [
+				"sdiv"
+			]
+		},
+		{
+			"operators": [
+				"I32DivU",
+				"I64DivU"
+			],
+			"instructions": [
+				"udiv"
+			]
+		},
+		{
+			"operators": [
+				"I32RemS",
+				"I64RemS"
+			],
+			"instructions": [
+				"srem"
+			]
+		},
+		{
+			"operators": [
+				"I32RemU",
+				"I64RemU"
+			],
+			"instructions": [
+				"urem"
+			]
+		},
+		{
+			"operators": [
+				"F32Min",
+				"F64Min"
+			],
+			"instructions": [
+				"fmin"
+			]
+		},
+		{
+			"operators": [
+				"F32Max",
+				"F64Max"
+			],
+			"instructions": [
+				"fmax"
+			]
+		},
+		{
+			"operators": [
+				"F32Copysign",
+				"F64Copysign"
+			],
+			"instructions": [
+				"fcopysign"
+			]
+		},
+		{
+			"operators": [
+				"I32LtS",
+				"I64LtS"
+			],
+			"instructions": [
+				"icmp",
+				"uextend"
+			]
+		},
+		{
+			"operators": [
+				"I32LtU",
+				"I64LtU"
+			],
+			"instructions": [
+				"icmp",
+				"uextend"
+			]
+		},
+		{
+			"operators": [
+				"I32LeS",
+				"I64LeS"
+			],
+			"instructions": [
+				"icmp",
+				"uextend"
+			]
+		},
+		{
+			"operators": [
+				"I32LeU",
+				"I64LeU"
+			],
+			"instructions": [
+				"icmp",
+				"uextend"
+			]
+		},
+		{
+			"operators": [
+				"I32GtS",
+				"I64GtS"
+			],
+			"instructions": [
+				"icmp",
+				"uextend"
+			]
+		},
+		{
+			"operators": [
+				"I32GtU",
+				"I64GtU"
+			],
+			"instructions": [
+				"icmp",
+				"uextend"
+			]
+		},
+		{
+			"operators": [
+				"I32GeS",
+				"I64GeS"
+			],
+			"instructions": [
+				"icmp",
+				"uextend"
+			]
+		},
+		{
+			"operators": [
+				"I32GeU",
+				"I64GeU"
+			],
+			"instructions": [
+				"icmp",
+				"uextend"
+			]
+		},
+		{
+			"operators": [
+				"I32Eqz",
+				"I64Eqz"
+			],
+			"instructions": [
+				"icmp_imm",
+				"uextend"
+			]
+		},
+		{
+			"operators": [
+				"I32Eq",
+				"I64Eq"
+			],
+			"instructions": [
+				"icmp",
+				"uextend"
+			]
+		},
+		{
+			"operators": [
+				"F32Eq",
+				"F64Eq"
+			],
+			"instructions": [
+				"fcmp",
+				"uextend"
+			]
+		},
+		{
+			"operators": [
+				"I32Ne",
+				"I64Ne"
+			],
+			"instructions": [
+				"icmp",
+				"uextend"
+			]
+		},
+		{
+			"operators": [
+				"F32Ne",
+				"F64Ne"
+			],
+			"instructions": [
+				"fcmp",
+				"uextend"
+			]
+		},
+		{
+			"operators": [
+				"F32Gt",
+				"F64Gt"
+			],
+			"instructions": [
+				"fcmp",
+				"uextend"
+			]
+		},
+		{
+			"operators": [
+				"F32Ge",
+				"F64Ge"
+			],
+			"instructions": [
+				"fcmp",
+				"uextend"
+			]
+		},
+		{
+			"operators": [
+				"F32Lt",
+				"F64Lt"
+			],
+			"instructions": [
+				"fcmp",
+				"uextend"
+			]
+		},
+		{
+			"operators": [
+				"F32Le",
+				"F64Le"
+			],
+			"instructions": [
+				"fcmp",
+				"uextend"
+			]
+		},
+		{
+			"operators": [
+				"RefNull"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"RefIsNull"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"RefFunc"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"MemoryAtomicWait32",
+				"MemoryAtomicWait64"
+			],
+			"instructions": [
+				"iconst"
+			]
+		},
+		{
+			"operators": [
+				"MemoryAtomicNotify"
+			],
+			"instructions": [
+				"iconst"
+			]
+		},
+		{
+			"operators": [
+				"I32AtomicLoad"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicLoad"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I32AtomicLoad8U"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I32AtomicLoad16U"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicLoad8U"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicLoad16U"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicLoad32U"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I32AtomicStore"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicStore"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I32AtomicStore8"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I32AtomicStore16"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicStore8"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicStore16"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicStore32"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I32AtomicRmwAdd"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicRmwAdd"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I32AtomicRmw8AddU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I32AtomicRmw16AddU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicRmw8AddU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicRmw16AddU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicRmw32AddU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I32AtomicRmwSub"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicRmwSub"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I32AtomicRmw8SubU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I32AtomicRmw16SubU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicRmw8SubU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicRmw16SubU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicRmw32SubU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I32AtomicRmwAnd"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicRmwAnd"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I32AtomicRmw8AndU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I32AtomicRmw16AndU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicRmw8AndU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicRmw16AndU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicRmw32AndU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I32AtomicRmwOr"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicRmwOr"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I32AtomicRmw8OrU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I32AtomicRmw16OrU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicRmw8OrU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicRmw16OrU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicRmw32OrU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I32AtomicRmwXor"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicRmwXor"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I32AtomicRmw8XorU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I32AtomicRmw16XorU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicRmw8XorU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicRmw16XorU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicRmw32XorU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I32AtomicRmwXchg"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicRmwXchg"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I32AtomicRmw8XchgU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I32AtomicRmw16XchgU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicRmw8XchgU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicRmw16XchgU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicRmw32XchgU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I32AtomicRmwCmpxchg"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicRmwCmpxchg"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I32AtomicRmw8CmpxchgU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I32AtomicRmw16CmpxchgU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicRmw8CmpxchgU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicRmw16CmpxchgU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I64AtomicRmw32CmpxchgU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"AtomicFence"
+			],
+			"instructions": [
+				"fence"
+			]
+		},
+		{
+			"operators": [
+				"MemoryCopy"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"MemoryFill"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"MemoryInit"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"DataDrop"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"TableSize"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"TableGrow"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"TableGet"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"TableSet"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"TableCopy"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"TableFill"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"TableInit"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"ElemDrop"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"V128Const"
+			],
+			"instructions": [
+				"vconst"
+			]
+		},
+		{
+			"operators": [
+				"I8x16Splat",
+				"I16x8Splat"
+			],
+			"instructions": [
+				"ireduce",
+				"splat"
+			]
+		},
+		{
+			"operators": [
+				"I32x4Splat",
+				"I64x2Splat",
+				"F32x4Splat",
+				"F64x2Splat"
+			],
+			"instructions": [
+				"splat"
+			]
+		},
+		{
+			"operators": [
+				"V128Load8Splat",
+				"V128Load16Splat",
+				"V128Load32Splat",
+				"V128Load64Splat"
+			],
+			"instructions": [
+				"icmp",
+				"iconst",
+				"isub",
+				"load",
+				"splat",
+				"uadd_overflow_trap"
+			]
+		},
+		{
+			"operators": [
+				"V128Load32Zero",
+				"V128Load64Zero"
+			],
+			"instructions": [
+				"icmp",
+				"iconst",
+				"isub",
+				"load",
+				"scalar_to_vector",
+				"uadd_overflow_trap"
+			]
+		},
+		{
+			"operators": [
+				"V128Load8Lane",
+				"V128Load16Lane",
+				"V128Load32Lane",
+				"V128Load64Lane"
+			],
+			"instructions": [
+				"icmp",
+				"iconst",
+				"insertlane",
+				"isub",
+				"load",
+				"uadd_overflow_trap"
+			]
+		},
+		{
+			"operators": [
+				"V128Store8Lane",
+				"V128Store16Lane",
+				"V128Store32Lane",
+				"V128Store64Lane"
+			],
+			"instructions": [
+				"extractlane",
+				"icmp",
+				"iconst",
+				"isub",
+				"store",
+				"uadd_overflow_trap"
+			]
+		},
+		{
+			"operators": [
+				"I8x16ExtractLaneS",
+				"I16x8ExtractLaneS"
+			],
+			"instructions": [
+				"extractlane",
+				"sextend"
+			]
+		},
+		{
+			"operators": [
+				"I8x16ExtractLaneU",
+				"I16x8ExtractLaneU"
+			],
+			"instructions": [
+				"extractlane",
+				"uextend"
+			]
+		},
+		{
+			"operators": [
+				"I32x4ExtractLane",
+				"I64x2ExtractLane",
+				"F32x4ExtractLane",
+				"F64x2ExtractLane"
+			],
+			"instructions": [
+				"extractlane"
+			]
+		},
+		{
+			"operators": [
+				"I8x16ReplaceLane",
+				"I16x8ReplaceLane"
+			],
+			"instructions": [
+				"insertlane",
+				"ireduce"
+			]
+		},
+		{
+			"operators": [
+				"I32x4ReplaceLane",
+				"I64x2ReplaceLane",
+				"F32x4ReplaceLane",
+				"F64x2ReplaceLane"
+			],
+			"instructions": [
+				"insertlane"
+			]
+		},
+		{
+			"operators": [
+				"I8x16Shuffle"
+			],
+			"instructions": [
+				"shuffle"
+			]
+		},
+		{
+			"operators": [
+				"I8x16Swizzle"
+			],
+			"instructions": [
+				"swizzle"
+			]
+		},
+		{
+			"operators": [
+				"I8x16Add",
+				"I16x8Add",
+				"I32x4Add",
+				"I64x2Add"
+			],
+			"instructions": [
+				"iadd"
+			]
+		},
+		{
+			"operators": [
+				"I8x16AddSatS",
+				"I16x8AddSatS"
+			],
+			"instructions": [
+				"sadd_sat"
+			]
+		},
+		{
+			"operators": [
+				"I8x16AddSatU",
+				"I16x8AddSatU"
+			],
+			"instructions": [
+				"uadd_sat"
+			]
+		},
+		{
+			"operators": [
+				"I8x16Sub",
+				"I16x8Sub",
+				"I32x4Sub",
+				"I64x2Sub"
+			],
+			"instructions": [
+				"isub"
+			]
+		},
+		{
+			"operators": [
+				"I8x16SubSatS",
+				"I16x8SubSatS"
+			],
+			"instructions": [
+				"ssub_sat"
+			]
+		},
+		{
+			"operators": [
+				"I8x16SubSatU",
+				"I16x8SubSatU"
+			],
+			"instructions": [
+				"usub_sat"
+			]
+		},
+		{
+			"operators": [
+				"I8x16MinS",
+				"I16x8MinS",
+				"I32x4MinS"
+			],
+			"instructions": [
+				"smin"
+			]
+		},
+		{
+			"operators": [
+				"I8x16MinU",
+				"I16x8MinU",
+				"I32x4MinU"
+			],
+			"instructions": [
+				"umin"
+			]
+		},
+		{
+			"operators": [
+				"I8x16MaxS",
+				"I16x8MaxS",
+				"I32x4MaxS"
+			],
+			"instructions": [
+				"smax"
+			]
+		},
+		{
+			"operators": [
+				"I8x16MaxU",
+				"I16x8MaxU",
+				"I32x4MaxU"
+			],
+			"instructions": [
+				"umax"
+			]
+		},
+		{
+			"operators": [
+				"I8x16AvgrU",
+				"I16x8AvgrU"
+			],
+			"instructions": [
+				"avg_round"
+			]
+		},
+		{
+			"operators": [
+				"I8x16Neg",
+				"I16x8Neg",
+				"I32x4Neg",
+				"I64x2Neg"
+			],
+			"instructions": [
+				"ineg"
+			]
+		},
+		{
+			"operators": [
+				"I8x16Abs",
+				"I16x8Abs",
+				"I32x4Abs",
+				"I64x2Abs"
+			],
+			"instructions": [
+				"iabs"
+			]
+		},
+		{
+			"operators": [
+				"I16x8Mul",
+				"I32x4Mul",
+				"I64x2Mul"
+			],
+			"instructions": [
+				"imul"
+			]
+		},
+		{
+			"operators": [
+				"V128Or"
+			],
+			"instructions": [
+				"bor"
+			]
+		},
+		{
+			"operators": [
+				"V128Xor"
+			],
+			"instructions": [
+				"bxor"
+			]
+		},
+		{
+			"operators": [
+				"V128And"
+			],
+			"instructions": [
+				"band"
+			]
+		},
+		{
+			"operators": [
+				"V128AndNot"
+			],
+			"instructions": [
+				"band_not"
+			]
+		},
+		{
+			"operators": [
+				"V128Not"
+			],
+			"instructions": [
+				"bnot"
+			]
+		},
+		{
+			"operators": [
+				"I8x16Shl",
+				"I16x8Shl",
+				"I32x4Shl",
+				"I64x2Shl"
+			],
+			"instructions": [
+				"ishl"
+			]
+		},
+		{
+			"operators": [
+				"I8x16ShrU",
+				"I16x8ShrU",
+				"I32x4ShrU",
+				"I64x2ShrU"
+			],
+			"instructions": [
+				"ushr"
+			]
+		},
+		{
+			"operators": [
+				"I8x16ShrS",
+				"I16x8ShrS",
+				"I32x4ShrS",
+				"I64x2ShrS"
+			],
+			"instructions": [
+				"sshr"
+			]
+		},
+		{
+			"operators": [
+				"V128Bitselect"
+			],
+			"instructions": [
+				"bitselect"
+			]
+		},
+		{
+			"operators": [
+				"V128AnyTrue"
+			],
+			"instructions": [
+				"uextend",
+				"vany_true"
+			]
+		},
+		{
+			"operators": [
+				"I8x16AllTrue",
+				"I16x8AllTrue",
+				"I32x4AllTrue",
+				"I64x2AllTrue"
+			],
+			"instructions": [
+				"uextend",
+				"vall_true"
+			]
+		},
+		{
+			"operators": [
+				"I8x16Bitmask",
+				"I16x8Bitmask",
+				"I32x4Bitmask",
+				"I64x2Bitmask"
+			],
+			"instructions": [
+				"vhigh_bits"
+			]
+		},
+		{
+			"operators": [
+				"I8x16Eq",
+				"I16x8Eq",
+				"I32x4Eq",
+				"I64x2Eq"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I8x16Ne",
+				"I16x8Ne",
+				"I32x4Ne",
+				"I64x2Ne"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I8x16GtS",
+				"I16x8GtS",
+				"I32x4GtS",
+				"I64x2GtS"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I8x16LtS",
+				"I16x8LtS",
+				"I32x4LtS",
+				"I64x2LtS"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I8x16GtU",
+				"I16x8GtU",
+				"I32x4GtU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I8x16LtU",
+				"I16x8LtU",
+				"I32x4LtU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I8x16GeS",
+				"I16x8GeS",
+				"I32x4GeS",
+				"I64x2GeS"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I8x16LeS",
+				"I16x8LeS",
+				"I32x4LeS",
+				"I64x2LeS"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I8x16GeU",
+				"I16x8GeU",
+				"I32x4GeU",
+				"I8x16LeU",
+				"I16x8LeU",
+				"I32x4LeU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"F32x4Eq",
+				"F64x2Eq"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"F32x4Ne",
+				"F64x2Ne"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"F32x4Lt",
+				"F64x2Lt"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"F32x4Gt",
+				"F64x2Gt"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"F32x4Le",
+				"F64x2Le"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"F32x4Ge",
+				"F64x2Ge"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"F32x4Add",
+				"F64x2Add"
+			],
+			"instructions": [
+				"fadd"
+			]
+		},
+		{
+			"operators": [
+				"F32x4Sub",
+				"F64x2Sub"
+			],
+			"instructions": [
+				"fsub"
+			]
+		},
+		{
+			"operators": [
+				"F32x4Mul",
+				"F64x2Mul"
+			],
+			"instructions": [
+				"fmul"
+			]
+		},
+		{
+			"operators": [
+				"F32x4Div",
+				"F64x2Div"
+			],
+			"instructions": [
+				"fdiv"
+			]
+		},
+		{
+			"operators": [
+				"F32x4Max",
+				"F64x2Max"
+			],
+			"instructions": [
+				"fmax"
+			]
+		},
+		{
+			"operators": [
+				"F32x4Min",
+				"F64x2Min"
+			],
+			"instructions": [
+				"fmin"
+			]
+		},
+		{
+			"operators": [
+				"F32x4PMax",
+				"F64x2PMax"
+			],
+			"instructions": [
+				"bitselect",
+				"fcmp"
+			]
+		},
+		{
+			"operators": [
+				"F32x4PMin",
+				"F64x2PMin"
+			],
+			"instructions": [
+				"bitselect",
+				"fcmp"
+			]
+		},
+		{
+			"operators": [
+				"F32x4Sqrt",
+				"F64x2Sqrt"
+			],
+			"instructions": [
+				"sqrt"
+			]
+		},
+		{
+			"operators": [
+				"F32x4Neg",
+				"F64x2Neg"
+			],
+			"instructions": [
+				"fneg"
+			]
+		},
+		{
+			"operators": [
+				"F32x4Abs",
+				"F64x2Abs"
+			],
+			"instructions": [
+				"fabs"
+			]
+		},
+		{
+			"operators": [
+				"F32x4ConvertI32x4S"
+			],
+			"instructions": [
+				"fcvt_from_sint"
+			]
+		},
+		{
+			"operators": [
+				"F32x4ConvertI32x4U"
+			],
+			"instructions": [
+				"fcvt_from_uint"
+			]
+		},
+		{
+			"operators": [
+				"F64x2ConvertLowI32x4S"
+			],
+			"instructions": [
+				"fcvt_from_sint",
+				"swiden_low"
+			]
+		},
+		{
+			"operators": [
+				"F64x2ConvertLowI32x4U"
+			],
+			"instructions": [
+				"fcvt_from_uint",
+				"uwiden_low"
+			]
+		},
+		{
+			"operators": [
+				"F64x2PromoteLowF32x4"
+			],
+			"instructions": [
+				"fvpromote_low"
+			]
+		},
+		{
+			"operators": [
+				"F32x4DemoteF64x2Zero"
+			],
+			"instructions": [
+				"fvdemote"
+			]
+		},
+		{
+			"operators": [
+				"I32x4TruncSatF32x4S"
+			],
+			"instructions": [
+				"fcvt_to_sint_sat"
+			]
+		},
+		{
+			"operators": [
+				"I32x4TruncSatF64x2SZero"
+			],
+			"instructions": [
+				"fcvt_to_sint_sat",
+				"snarrow",
+				"vconst"
+			]
+		},
+		{
+			"operators": [
+				"I32x4RelaxedTruncF32x4U",
+				"I32x4TruncSatF32x4U"
+			],
+			"instructions": [
+				"fcvt_to_uint_sat"
+			]
+		},
+		{
+			"operators": [
+				"I32x4RelaxedTruncF64x2UZero",
+				"I32x4TruncSatF64x2UZero"
+			],
+			"instructions": [
+				"fcvt_to_uint_sat",
+				"uunarrow",
+				"vconst"
+			]
+		},
+		{
+			"operators": [
+				"I8x16NarrowI16x8S"
+			],
+			"instructions": [
+				"snarrow"
+			]
+		},
+		{
+			"operators": [
+				"I16x8NarrowI32x4S"
+			],
+			"instructions": [
+				"snarrow"
+			]
+		},
+		{
+			"operators": [
+				"I8x16NarrowI16x8U"
+			],
+			"instructions": [
+				"unarrow"
+			]
+		},
+		{
+			"operators": [
+				"I16x8NarrowI32x4U"
+			],
+			"instructions": [
+				"unarrow"
+			]
+		},
+		{
+			"operators": [
+				"I16x8ExtendLowI8x16S"
+			],
+			"instructions": [
+				"swiden_low"
+			]
+		},
+		{
+			"operators": [
+				"I16x8ExtendHighI8x16S"
+			],
+			"instructions": [
+				"swiden_high"
+			]
+		},
+		{
+			"operators": [
+				"I16x8ExtendLowI8x16U"
+			],
+			"instructions": [
+				"uwiden_low"
+			]
+		},
+		{
+			"operators": [
+				"I16x8ExtendHighI8x16U"
+			],
+			"instructions": [
+				"uwiden_high"
+			]
+		},
+		{
+			"operators": [
+				"I32x4ExtendLowI16x8S"
+			],
+			"instructions": [
+				"swiden_low"
+			]
+		},
+		{
+			"operators": [
+				"I32x4ExtendHighI16x8S"
+			],
+			"instructions": [
+				"swiden_high"
+			]
+		},
+		{
+			"operators": [
+				"I32x4ExtendLowI16x8U"
+			],
+			"instructions": [
+				"uwiden_low"
+			]
+		},
+		{
+			"operators": [
+				"I32x4ExtendHighI16x8U"
+			],
+			"instructions": [
+				"uwiden_high"
+			]
+		},
+		{
+			"operators": [
+				"I64x2ExtendLowI32x4S"
+			],
+			"instructions": [
+				"swiden_low"
+			]
+		},
+		{
+			"operators": [
+				"I64x2ExtendHighI32x4S"
+			],
+			"instructions": [
+				"swiden_high"
+			]
+		},
+		{
+			"operators": [
+				"I64x2ExtendLowI32x4U"
+			],
+			"instructions": [
+				"uwiden_low"
+			]
+		},
+		{
+			"operators": [
+				"I64x2ExtendHighI32x4U"
+			],
+			"instructions": [
+				"uwiden_high"
+			]
+		},
+		{
+			"operators": [
+				"I16x8ExtAddPairwiseI8x16S"
+			],
+			"instructions": [
+				"iadd_pairwise",
+				"swiden_high",
+				"swiden_low"
+			]
+		},
+		{
+			"operators": [
+				"I32x4ExtAddPairwiseI16x8S"
+			],
+			"instructions": [
+				"iadd_pairwise",
+				"swiden_high",
+				"swiden_low"
+			]
+		},
+		{
+			"operators": [
+				"I16x8ExtAddPairwiseI8x16U"
+			],
+			"instructions": [
+				"iadd_pairwise",
+				"uwiden_high",
+				"uwiden_low"
+			]
+		},
+		{
+			"operators": [
+				"I32x4ExtAddPairwiseI16x8U"
+			],
+			"instructions": [
+				"iadd_pairwise",
+				"uwiden_high",
+				"uwiden_low"
+			]
+		},
+		{
+			"operators": [
+				"F32x4Ceil",
+				"F64x2Ceil"
+			],
+			"instructions": [
+				"ceil"
+			]
+		},
+		{
+			"operators": [
+				"F32x4Floor",
+				"F64x2Floor"
+			],
+			"instructions": [
+				"floor"
+			]
+		},
+		{
+			"operators": [
+				"F32x4Trunc",
+				"F64x2Trunc"
+			],
+			"instructions": [
+				"trunc"
+			]
+		},
+		{
+			"operators": [
+				"F32x4Nearest",
+				"F64x2Nearest"
+			],
+			"instructions": [
+				"nearest"
+			]
+		},
+		{
+			"operators": [
+				"I32x4DotI16x8S"
+			],
+			"instructions": [
+				"iadd_pairwise",
+				"imul",
+				"swiden_high",
+				"swiden_low"
+			]
+		},
+		{
+			"operators": [
+				"I8x16Popcnt"
+			],
+			"instructions": [
+				"popcnt"
+			]
+		},
+		{
+			"operators": [
+				"I16x8Q15MulrSatS"
+			],
+			"instructions": [
+				"sqmul_round_sat"
+			]
+		},
+		{
+			"operators": [
+				"I16x8ExtMulLowI8x16S"
+			],
+			"instructions": [
+				"imul",
+				"swiden_low"
+			]
+		},
+		{
+			"operators": [
+				"I16x8ExtMulHighI8x16S"
+			],
+			"instructions": [
+				"imul",
+				"swiden_high"
+			]
+		},
+		{
+			"operators": [
+				"I16x8ExtMulLowI8x16U"
+			],
+			"instructions": [
+				"imul",
+				"uwiden_low"
+			]
+		},
+		{
+			"operators": [
+				"I16x8ExtMulHighI8x16U"
+			],
+			"instructions": [
+				"imul",
+				"uwiden_high"
+			]
+		},
+		{
+			"operators": [
+				"I32x4ExtMulLowI16x8S"
+			],
+			"instructions": [
+				"imul",
+				"swiden_low"
+			]
+		},
+		{
+			"operators": [
+				"I32x4ExtMulHighI16x8S"
+			],
+			"instructions": [
+				"imul",
+				"swiden_high"
+			]
+		},
+		{
+			"operators": [
+				"I32x4ExtMulLowI16x8U"
+			],
+			"instructions": [
+				"imul",
+				"uwiden_low"
+			]
+		},
+		{
+			"operators": [
+				"I32x4ExtMulHighI16x8U"
+			],
+			"instructions": [
+				"imul",
+				"uwiden_high"
+			]
+		},
+		{
+			"operators": [
+				"I64x2ExtMulLowI32x4S"
+			],
+			"instructions": [
+				"imul",
+				"swiden_low"
+			]
+		},
+		{
+			"operators": [
+				"I64x2ExtMulHighI32x4S"
+			],
+			"instructions": [
+				"imul",
+				"swiden_high"
+			]
+		},
+		{
+			"operators": [
+				"I64x2ExtMulLowI32x4U"
+			],
+			"instructions": [
+				"imul",
+				"uwiden_low"
+			]
+		},
+		{
+			"operators": [
+				"I64x2ExtMulHighI32x4U"
+			],
+			"instructions": [
+				"imul",
+				"uwiden_high"
+			]
+		},
+		{
+			"operators": [
+				"MemoryDiscard"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"F32x4RelaxedMax",
+				"F64x2RelaxedMax"
+			],
+			"instructions": [
+				"bitselect",
+				"fcmp",
+				"fmax"
+			]
+		},
+		{
+			"operators": [
+				"F32x4RelaxedMin",
+				"F64x2RelaxedMin"
+			],
+			"instructions": [
+				"bitselect",
+				"fcmp",
+				"fmin"
+			]
+		},
+		{
+			"operators": [
+				"I8x16RelaxedSwizzle"
+			],
+			"instructions": [
+				"swizzle",
+				"x86_pshufb"
+			]
+		},
+		{
+			"operators": [
+				"F32x4RelaxedMadd",
+				"F64x2RelaxedMadd"
+			],
+			"instructions": [
+				"fadd",
+				"fma",
+				"fmul"
+			]
+		},
+		{
+			"operators": [
+				"F32x4RelaxedNmadd",
+				"F64x2RelaxedNmadd"
+			],
+			"instructions": [
+				"fadd",
+				"fma",
+				"fmul",
+				"fneg"
+			]
+		},
+		{
+			"operators": [
+				"I8x16RelaxedLaneselect",
+				"I16x8RelaxedLaneselect",
+				"I32x4RelaxedLaneselect",
+				"I64x2RelaxedLaneselect"
+			],
+			"instructions": [
+				"bitselect",
+				"x86_blendv"
+			]
+		},
+		{
+			"operators": [
+				"I32x4RelaxedTruncF32x4S"
+			],
+			"instructions": [
+				"fcvt_to_sint_sat",
+				"x86_cvtt2dq"
+			]
+		},
+		{
+			"operators": [
+				"I32x4RelaxedTruncF64x2SZero"
+			],
+			"instructions": [
+				"fcvt_to_sint_sat",
+				"snarrow",
+				"vconst",
+				"x86_cvtt2dq"
+			]
+		},
+		{
+			"operators": [
+				"I16x8RelaxedQ15mulrS"
+			],
+			"instructions": [
+				"sqmul_round_sat",
+				"x86_pmulhrsw"
+			]
+		},
+		{
+			"operators": [
+				"I16x8RelaxedDotI8x16I7x16S"
+			],
+			"instructions": [
+				"iadd_pairwise",
+				"imul",
+				"swiden_high",
+				"swiden_low",
+				"x86_pmaddubsw"
+			]
+		},
+		{
+			"operators": [
+				"I32x4RelaxedDotI8x16I7x16AddS"
+			],
+			"instructions": [
+				"iadd",
+				"iadd_pairwise",
+				"imul",
+				"swiden_high",
+				"swiden_low",
+				"x86_pmaddubsw"
+			]
+		},
+		{
+			"operators": [
+				"BrOnNull"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"BrOnNonNull"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"CallRef"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"RefAsNonNull"
+			],
+			"instructions": [
+				"trapnz"
+			]
+		},
+		{
+			"operators": [
+				"RefI31"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I31GetS"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"I31GetU"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"TryTable",
+				"ThrowRef"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"RefEq",
+				"RefTestNonNull",
+				"RefTestNullable",
+				"RefCastNonNull",
+				"RefCastNullable",
+				"BrOnCast",
+				"BrOnCastFail",
+				"AnyConvertExtern",
+				"ExternConvertAny",
+				"ArrayNew",
+				"ArrayNewDefault",
+				"ArrayNewFixed",
+				"ArrayNewData",
+				"ArrayNewElem",
+				"ArrayGet",
+				"ArrayGetU",
+				"ArrayGetS",
+				"ArraySet",
+				"ArrayLen",
+				"ArrayFill",
+				"ArrayCopy",
+				"ArrayInitData",
+				"ArrayInitElem",
+				"StructNew",
+				"StructNewDefault",
+				"StructGetS",
+				"StructGetU",
+				"StructSet",
+				"StructGet"
+			],
+			"instructions": []
+		},
+		{
+			"operators": [
+				"GlobalAtomicGet",
+				"GlobalAtomicSet",
+				"GlobalAtomicRmwAdd",
+				"GlobalAtomicRmwSub",
+				"GlobalAtomicRmwOr",
+				"GlobalAtomicRmwXor",
+				"GlobalAtomicRmwAnd",
+				"GlobalAtomicRmwXchg",
+				"GlobalAtomicRmwCmpxchg",
+				"TableAtomicGet",
+				"TableAtomicSet",
+				"TableAtomicRmwXchg",
+				"TableAtomicRmwCmpxchg",
+				"StructAtomicGet",
+				"StructAtomicGetS",
+				"StructAtomicGetU",
+				"StructAtomicSet",
+				"StructAtomicRmwAdd",
+				"StructAtomicRmwSub",
+				"StructAtomicRmwOr",
+				"StructAtomicRmwXor",
+				"StructAtomicRmwAnd",
+				"StructAtomicRmwXchg",
+				"StructAtomicRmwCmpxchg",
+				"ArrayAtomicGet",
+				"ArrayAtomicGetS",
+				"ArrayAtomicGetU",
+				"ArrayAtomicSet",
+				"ArrayAtomicRmwAdd",
+				"ArrayAtomicRmwSub",
+				"ArrayAtomicRmwOr",
+				"ArrayAtomicRmwXor",
+				"ArrayAtomicRmwAnd",
+				"ArrayAtomicRmwXchg",
+				"ArrayAtomicRmwCmpxchg",
+				"RefI31Shared"
+			],
+			"instructions": []
+		}
+	]
+}
diff --git a/cranelift/isle/veri/meta/data/wasmoperators.csv b/cranelift/isle/veri/meta/data/wasmoperators.csv
new file mode 100644
index 000000000000..2ae1e088885b
--- /dev/null
+++ b/cranelift/isle/veri/meta/data/wasmoperators.csv
@@ -0,0 +1,608 @@
+Unreachable,mvp
+Nop,mvp
+Block,mvp
+Loop,mvp
+If,mvp
+Else,mvp
+TryTable,exceptions
+Throw,exceptions
+ThrowRef,exceptions
+Try,legacy_exceptions
+Catch,legacy_exceptions
+Rethrow,legacy_exceptions
+Delegate,legacy_exceptions
+CatchAll,legacy_exceptions
+End,mvp
+Br,mvp
+BrIf,mvp
+BrTable,mvp
+Return,mvp
+Call,mvp
+CallIndirect,mvp
+ReturnCall,tail_call
+ReturnCallIndirect,tail_call
+Drop,mvp
+Select,mvp
+TypedSelect,reference_types
+LocalGet,mvp
+LocalSet,mvp
+LocalTee,mvp
+GlobalGet,mvp
+GlobalSet,mvp
+I32Load,mvp
+I64Load,mvp
+F32Load,mvp
+F64Load,mvp
+I32Load8S,mvp
+I32Load8U,mvp
+I32Load16S,mvp
+I32Load16U,mvp
+I64Load8S,mvp
+I64Load8U,mvp
+I64Load16S,mvp
+I64Load16U,mvp
+I64Load32S,mvp
+I64Load32U,mvp
+I32Store,mvp
+I64Store,mvp
+F32Store,mvp
+F64Store,mvp
+I32Store8,mvp
+I32Store16,mvp
+I64Store8,mvp
+I64Store16,mvp
+I64Store32,mvp
+MemorySize,mvp
+MemoryGrow,mvp
+I32Const,mvp
+I64Const,mvp
+F32Const,mvp
+F64Const,mvp
+RefNull,reference_types
+RefIsNull,reference_types
+RefFunc,reference_types
+RefEq,gc
+I32Eqz,mvp
+I32Eq,mvp
+I32Ne,mvp
+I32LtS,mvp
+I32LtU,mvp
+I32GtS,mvp
+I32GtU,mvp
+I32LeS,mvp
+I32LeU,mvp
+I32GeS,mvp
+I32GeU,mvp
+I64Eqz,mvp
+I64Eq,mvp
+I64Ne,mvp
+I64LtS,mvp
+I64LtU,mvp
+I64GtS,mvp
+I64GtU,mvp
+I64LeS,mvp
+I64LeU,mvp
+I64GeS,mvp
+I64GeU,mvp
+F32Eq,mvp
+F32Ne,mvp
+F32Lt,mvp
+F32Gt,mvp
+F32Le,mvp
+F32Ge,mvp
+F64Eq,mvp
+F64Ne,mvp
+F64Lt,mvp
+F64Gt,mvp
+F64Le,mvp
+F64Ge,mvp
+I32Clz,mvp
+I32Ctz,mvp
+I32Popcnt,mvp
+I32Add,mvp
+I32Sub,mvp
+I32Mul,mvp
+I32DivS,mvp
+I32DivU,mvp
+I32RemS,mvp
+I32RemU,mvp
+I32And,mvp
+I32Or,mvp
+I32Xor,mvp
+I32Shl,mvp
+I32ShrS,mvp
+I32ShrU,mvp
+I32Rotl,mvp
+I32Rotr,mvp
+I64Clz,mvp
+I64Ctz,mvp
+I64Popcnt,mvp
+I64Add,mvp
+I64Sub,mvp
+I64Mul,mvp
+I64DivS,mvp
+I64DivU,mvp
+I64RemS,mvp
+I64RemU,mvp
+I64And,mvp
+I64Or,mvp
+I64Xor,mvp
+I64Shl,mvp
+I64ShrS,mvp
+I64ShrU,mvp
+I64Rotl,mvp
+I64Rotr,mvp
+F32Abs,mvp
+F32Neg,mvp
+F32Ceil,mvp
+F32Floor,mvp
+F32Trunc,mvp
+F32Nearest,mvp
+F32Sqrt,mvp
+F32Add,mvp
+F32Sub,mvp
+F32Mul,mvp
+F32Div,mvp
+F32Min,mvp
+F32Max,mvp
+F32Copysign,mvp
+F64Abs,mvp
+F64Neg,mvp
+F64Ceil,mvp
+F64Floor,mvp
+F64Trunc,mvp
+F64Nearest,mvp
+F64Sqrt,mvp
+F64Add,mvp
+F64Sub,mvp
+F64Mul,mvp
+F64Div,mvp
+F64Min,mvp
+F64Max,mvp
+F64Copysign,mvp
+I32WrapI64,mvp
+I32TruncF32S,mvp
+I32TruncF32U,mvp
+I32TruncF64S,mvp
+I32TruncF64U,mvp
+I64ExtendI32S,mvp
+I64ExtendI32U,mvp
+I64TruncF32S,mvp
+I64TruncF32U,mvp
+I64TruncF64S,mvp
+I64TruncF64U,mvp
+F32ConvertI32S,mvp
+F32ConvertI32U,mvp
+F32ConvertI64S,mvp
+F32ConvertI64U,mvp
+F32DemoteF64,mvp
+F64ConvertI32S,mvp
+F64ConvertI32U,mvp
+F64ConvertI64S,mvp
+F64ConvertI64U,mvp
+F64PromoteF32,mvp
+I32ReinterpretF32,mvp
+I64ReinterpretF64,mvp
+F32ReinterpretI32,mvp
+F64ReinterpretI64,mvp
+I32Extend8S,sign_extension
+I32Extend16S,sign_extension
+I64Extend8S,sign_extension
+I64Extend16S,sign_extension
+I64Extend32S,sign_extension
+StructNew,gc
+StructNewDefault,gc
+StructGet,gc
+StructGetS,gc
+StructGetU,gc
+StructSet,gc
+ArrayNew,gc
+ArrayNewDefault,gc
+ArrayNewFixed,gc
+ArrayNewData,gc
+ArrayNewElem,gc
+ArrayGet,gc
+ArrayGetS,gc
+ArrayGetU,gc
+ArraySet,gc
+ArrayLen,gc
+ArrayFill,gc
+ArrayCopy,gc
+ArrayInitData,gc
+ArrayInitElem,gc
+RefTestNonNull,gc
+RefTestNullable,gc
+RefCastNonNull,gc
+RefCastNullable,gc
+BrOnCast,gc
+BrOnCastFail,gc
+AnyConvertExtern,gc
+ExternConvertAny,gc
+RefI31,gc
+I31GetS,gc
+I31GetU,gc
+I32TruncSatF32S,saturating_float_to_int
+I32TruncSatF32U,saturating_float_to_int
+I32TruncSatF64S,saturating_float_to_int
+I32TruncSatF64U,saturating_float_to_int
+I64TruncSatF32S,saturating_float_to_int
+I64TruncSatF32U,saturating_float_to_int
+I64TruncSatF64S,saturating_float_to_int
+I64TruncSatF64U,saturating_float_to_int
+MemoryInit,bulk_memory
+DataDrop,bulk_memory
+MemoryCopy,bulk_memory
+MemoryFill,bulk_memory
+TableInit,bulk_memory
+ElemDrop,bulk_memory
+TableCopy,bulk_memory
+TableFill,reference_types
+TableGet,reference_types
+TableSet,reference_types
+TableGrow,reference_types
+TableSize,reference_types
+MemoryDiscard,memory_control
+MemoryAtomicNotify,threads
+MemoryAtomicWait32,threads
+MemoryAtomicWait64,threads
+AtomicFence,threads
+I32AtomicLoad,threads
+I64AtomicLoad,threads
+I32AtomicLoad8U,threads
+I32AtomicLoad16U,threads
+I64AtomicLoad8U,threads
+I64AtomicLoad16U,threads
+I64AtomicLoad32U,threads
+I32AtomicStore,threads
+I64AtomicStore,threads
+I32AtomicStore8,threads
+I32AtomicStore16,threads
+I64AtomicStore8,threads
+I64AtomicStore16,threads
+I64AtomicStore32,threads
+I32AtomicRmwAdd,threads
+I64AtomicRmwAdd,threads
+I32AtomicRmw8AddU,threads
+I32AtomicRmw16AddU,threads
+I64AtomicRmw8AddU,threads
+I64AtomicRmw16AddU,threads
+I64AtomicRmw32AddU,threads
+I32AtomicRmwSub,threads
+I64AtomicRmwSub,threads
+I32AtomicRmw8SubU,threads
+I32AtomicRmw16SubU,threads
+I64AtomicRmw8SubU,threads
+I64AtomicRmw16SubU,threads
+I64AtomicRmw32SubU,threads
+I32AtomicRmwAnd,threads
+I64AtomicRmwAnd,threads
+I32AtomicRmw8AndU,threads
+I32AtomicRmw16AndU,threads
+I64AtomicRmw8AndU,threads
+I64AtomicRmw16AndU,threads
+I64AtomicRmw32AndU,threads
+I32AtomicRmwOr,threads
+I64AtomicRmwOr,threads
+I32AtomicRmw8OrU,threads
+I32AtomicRmw16OrU,threads
+I64AtomicRmw8OrU,threads
+I64AtomicRmw16OrU,threads
+I64AtomicRmw32OrU,threads
+I32AtomicRmwXor,threads
+I64AtomicRmwXor,threads
+I32AtomicRmw8XorU,threads
+I32AtomicRmw16XorU,threads
+I64AtomicRmw8XorU,threads
+I64AtomicRmw16XorU,threads
+I64AtomicRmw32XorU,threads
+I32AtomicRmwXchg,threads
+I64AtomicRmwXchg,threads
+I32AtomicRmw8XchgU,threads
+I32AtomicRmw16XchgU,threads
+I64AtomicRmw8XchgU,threads
+I64AtomicRmw16XchgU,threads
+I64AtomicRmw32XchgU,threads
+I32AtomicRmwCmpxchg,threads
+I64AtomicRmwCmpxchg,threads
+I32AtomicRmw8CmpxchgU,threads
+I32AtomicRmw16CmpxchgU,threads
+I64AtomicRmw8CmpxchgU,threads
+I64AtomicRmw16CmpxchgU,threads
+I64AtomicRmw32CmpxchgU,threads
+GlobalAtomicGet,shared_everything_threads
+GlobalAtomicSet,shared_everything_threads
+GlobalAtomicRmwAdd,shared_everything_threads
+GlobalAtomicRmwSub,shared_everything_threads
+GlobalAtomicRmwAnd,shared_everything_threads
+GlobalAtomicRmwOr,shared_everything_threads
+GlobalAtomicRmwXor,shared_everything_threads
+GlobalAtomicRmwXchg,shared_everything_threads
+GlobalAtomicRmwCmpxchg,shared_everything_threads
+TableAtomicGet,shared_everything_threads
+TableAtomicSet,shared_everything_threads
+TableAtomicRmwXchg,shared_everything_threads
+TableAtomicRmwCmpxchg,shared_everything_threads
+StructAtomicGet,shared_everything_threads
+StructAtomicGetS,shared_everything_threads
+StructAtomicGetU,shared_everything_threads
+StructAtomicSet,shared_everything_threads
+StructAtomicRmwAdd,shared_everything_threads
+StructAtomicRmwSub,shared_everything_threads
+StructAtomicRmwAnd,shared_everything_threads
+StructAtomicRmwOr,shared_everything_threads
+StructAtomicRmwXor,shared_everything_threads
+StructAtomicRmwXchg,shared_everything_threads
+StructAtomicRmwCmpxchg,shared_everything_threads
+ArrayAtomicGet,shared_everything_threads
+ArrayAtomicGetS,shared_everything_threads
+ArrayAtomicGetU,shared_everything_threads
+ArrayAtomicSet,shared_everything_threads
+ArrayAtomicRmwAdd,shared_everything_threads
+ArrayAtomicRmwSub,shared_everything_threads
+ArrayAtomicRmwAnd,shared_everything_threads
+ArrayAtomicRmwOr,shared_everything_threads
+ArrayAtomicRmwXor,shared_everything_threads
+ArrayAtomicRmwXchg,shared_everything_threads
+ArrayAtomicRmwCmpxchg,shared_everything_threads
+RefI31Shared,shared_everything_threads
+V128Load,simd
+V128Load8x8S,simd
+V128Load8x8U,simd
+V128Load16x4S,simd
+V128Load16x4U,simd
+V128Load32x2S,simd
+V128Load32x2U,simd
+V128Load8Splat,simd
+V128Load16Splat,simd
+V128Load32Splat,simd
+V128Load64Splat,simd
+V128Load32Zero,simd
+V128Load64Zero,simd
+V128Store,simd
+V128Load8Lane,simd
+V128Load16Lane,simd
+V128Load32Lane,simd
+V128Load64Lane,simd
+V128Store8Lane,simd
+V128Store16Lane,simd
+V128Store32Lane,simd
+V128Store64Lane,simd
+V128Const,simd
+I8x16Shuffle,simd
+I8x16ExtractLaneS,simd
+I8x16ExtractLaneU,simd
+I8x16ReplaceLane,simd
+I16x8ExtractLaneS,simd
+I16x8ExtractLaneU,simd
+I16x8ReplaceLane,simd
+I32x4ExtractLane,simd
+I32x4ReplaceLane,simd
+I64x2ExtractLane,simd
+I64x2ReplaceLane,simd
+F32x4ExtractLane,simd
+F32x4ReplaceLane,simd
+F64x2ExtractLane,simd
+F64x2ReplaceLane,simd
+I8x16Swizzle,simd
+I8x16Splat,simd
+I16x8Splat,simd
+I32x4Splat,simd
+I64x2Splat,simd
+F32x4Splat,simd
+F64x2Splat,simd
+I8x16Eq,simd
+I8x16Ne,simd
+I8x16LtS,simd
+I8x16LtU,simd
+I8x16GtS,simd
+I8x16GtU,simd
+I8x16LeS,simd
+I8x16LeU,simd
+I8x16GeS,simd
+I8x16GeU,simd
+I16x8Eq,simd
+I16x8Ne,simd
+I16x8LtS,simd
+I16x8LtU,simd
+I16x8GtS,simd
+I16x8GtU,simd
+I16x8LeS,simd
+I16x8LeU,simd
+I16x8GeS,simd
+I16x8GeU,simd
+I32x4Eq,simd
+I32x4Ne,simd
+I32x4LtS,simd
+I32x4LtU,simd
+I32x4GtS,simd
+I32x4GtU,simd
+I32x4LeS,simd
+I32x4LeU,simd
+I32x4GeS,simd
+I32x4GeU,simd
+I64x2Eq,simd
+I64x2Ne,simd
+I64x2LtS,simd
+I64x2GtS,simd
+I64x2LeS,simd
+I64x2GeS,simd
+F32x4Eq,simd
+F32x4Ne,simd
+F32x4Lt,simd
+F32x4Gt,simd
+F32x4Le,simd
+F32x4Ge,simd
+F64x2Eq,simd
+F64x2Ne,simd
+F64x2Lt,simd
+F64x2Gt,simd
+F64x2Le,simd
+F64x2Ge,simd
+V128Not,simd
+V128And,simd
+V128AndNot,simd
+V128Or,simd
+V128Xor,simd
+V128Bitselect,simd
+V128AnyTrue,simd
+I8x16Abs,simd
+I8x16Neg,simd
+I8x16Popcnt,simd
+I8x16AllTrue,simd
+I8x16Bitmask,simd
+I8x16NarrowI16x8S,simd
+I8x16NarrowI16x8U,simd
+I8x16Shl,simd
+I8x16ShrS,simd
+I8x16ShrU,simd
+I8x16Add,simd
+I8x16AddSatS,simd
+I8x16AddSatU,simd
+I8x16Sub,simd
+I8x16SubSatS,simd
+I8x16SubSatU,simd
+I8x16MinS,simd
+I8x16MinU,simd
+I8x16MaxS,simd
+I8x16MaxU,simd
+I8x16AvgrU,simd
+I16x8ExtAddPairwiseI8x16S,simd
+I16x8ExtAddPairwiseI8x16U,simd
+I16x8Abs,simd
+I16x8Neg,simd
+I16x8Q15MulrSatS,simd
+I16x8AllTrue,simd
+I16x8Bitmask,simd
+I16x8NarrowI32x4S,simd
+I16x8NarrowI32x4U,simd
+I16x8ExtendLowI8x16S,simd
+I16x8ExtendHighI8x16S,simd
+I16x8ExtendLowI8x16U,simd
+I16x8ExtendHighI8x16U,simd
+I16x8Shl,simd
+I16x8ShrS,simd
+I16x8ShrU,simd
+I16x8Add,simd
+I16x8AddSatS,simd
+I16x8AddSatU,simd
+I16x8Sub,simd
+I16x8SubSatS,simd
+I16x8SubSatU,simd
+I16x8Mul,simd
+I16x8MinS,simd
+I16x8MinU,simd
+I16x8MaxS,simd
+I16x8MaxU,simd
+I16x8AvgrU,simd
+I16x8ExtMulLowI8x16S,simd
+I16x8ExtMulHighI8x16S,simd
+I16x8ExtMulLowI8x16U,simd
+I16x8ExtMulHighI8x16U,simd
+I32x4ExtAddPairwiseI16x8S,simd
+I32x4ExtAddPairwiseI16x8U,simd
+I32x4Abs,simd
+I32x4Neg,simd
+I32x4AllTrue,simd
+I32x4Bitmask,simd
+I32x4ExtendLowI16x8S,simd
+I32x4ExtendHighI16x8S,simd
+I32x4ExtendLowI16x8U,simd
+I32x4ExtendHighI16x8U,simd
+I32x4Shl,simd
+I32x4ShrS,simd
+I32x4ShrU,simd
+I32x4Add,simd
+I32x4Sub,simd
+I32x4Mul,simd
+I32x4MinS,simd
+I32x4MinU,simd
+I32x4MaxS,simd
+I32x4MaxU,simd
+I32x4DotI16x8S,simd
+I32x4ExtMulLowI16x8S,simd
+I32x4ExtMulHighI16x8S,simd
+I32x4ExtMulLowI16x8U,simd
+I32x4ExtMulHighI16x8U,simd
+I64x2Abs,simd
+I64x2Neg,simd
+I64x2AllTrue,simd
+I64x2Bitmask,simd
+I64x2ExtendLowI32x4S,simd
+I64x2ExtendHighI32x4S,simd
+I64x2ExtendLowI32x4U,simd
+I64x2ExtendHighI32x4U,simd
+I64x2Shl,simd
+I64x2ShrS,simd
+I64x2ShrU,simd
+I64x2Add,simd
+I64x2Sub,simd
+I64x2Mul,simd
+I64x2ExtMulLowI32x4S,simd
+I64x2ExtMulHighI32x4S,simd
+I64x2ExtMulLowI32x4U,simd
+I64x2ExtMulHighI32x4U,simd
+F32x4Ceil,simd
+F32x4Floor,simd
+F32x4Trunc,simd
+F32x4Nearest,simd
+F32x4Abs,simd
+F32x4Neg,simd
+F32x4Sqrt,simd
+F32x4Add,simd
+F32x4Sub,simd
+F32x4Mul,simd
+F32x4Div,simd
+F32x4Min,simd
+F32x4Max,simd
+F32x4PMin,simd
+F32x4PMax,simd
+F64x2Ceil,simd
+F64x2Floor,simd
+F64x2Trunc,simd
+F64x2Nearest,simd
+F64x2Abs,simd
+F64x2Neg,simd
+F64x2Sqrt,simd
+F64x2Add,simd
+F64x2Sub,simd
+F64x2Mul,simd
+F64x2Div,simd
+F64x2Min,simd
+F64x2Max,simd
+F64x2PMin,simd
+F64x2PMax,simd
+I32x4TruncSatF32x4S,simd
+I32x4TruncSatF32x4U,simd
+F32x4ConvertI32x4S,simd
+F32x4ConvertI32x4U,simd
+I32x4TruncSatF64x2SZero,simd
+I32x4TruncSatF64x2UZero,simd
+F64x2ConvertLowI32x4S,simd
+F64x2ConvertLowI32x4U,simd
+F32x4DemoteF64x2Zero,simd
+F64x2PromoteLowF32x4,simd
+I8x16RelaxedSwizzle,relaxed_simd
+I32x4RelaxedTruncF32x4S,relaxed_simd
+I32x4RelaxedTruncF32x4U,relaxed_simd
+I32x4RelaxedTruncF64x2SZero,relaxed_simd
+I32x4RelaxedTruncF64x2UZero,relaxed_simd
+F32x4RelaxedMadd,relaxed_simd
+F32x4RelaxedNmadd,relaxed_simd
+F64x2RelaxedMadd,relaxed_simd
+F64x2RelaxedNmadd,relaxed_simd
+I8x16RelaxedLaneselect,relaxed_simd
+I16x8RelaxedLaneselect,relaxed_simd
+I32x4RelaxedLaneselect,relaxed_simd
+I64x2RelaxedLaneselect,relaxed_simd
+F32x4RelaxedMin,relaxed_simd
+F32x4RelaxedMax,relaxed_simd
+F64x2RelaxedMin,relaxed_simd
+F64x2RelaxedMax,relaxed_simd
+I16x8RelaxedQ15mulrS,relaxed_simd
+I16x8RelaxedDotI8x16I7x16S,relaxed_simd
+I32x4RelaxedDotI8x16I7x16AddS,relaxed_simd
+CallRef,function_references
+ReturnCallRef,function_references
+RefAsNonNull,function_references
+BrOnNull,function_references
+BrOnNonNull,function_references
diff --git a/cranelift/isle/veri/meta/script/cliftags.py b/cranelift/isle/veri/meta/script/cliftags.py
new file mode 100755
index 000000000000..22238718de07
--- /dev/null
+++ b/cranelift/isle/veri/meta/script/cliftags.py
@@ -0,0 +1,256 @@
+#!/usr/bin/env python3
+
+import sys
+import argparse
+import json
+import logging
+
+CATEGORIES = {
+    # Stack
+    "Drop": "stack",
+    "Select": "stack",
+    "TypedSelect": "stack",
+
+    # Control flow
+    "Nop": "control_flow",
+    "Unreachable": "control_flow",
+    "Block": "control_flow",
+    "Loop": "control_flow",
+    "If": "control_flow",
+    "Else": "control_flow",
+    "End": "control_flow",
+    "Br": "control_flow",
+    "BrIf": "control_flow",
+    "BrTable": "control_flow",
+    "Return": "control_flow",
+
+    # Calls
+    "Call": "calls",
+    "CallIndirect": "calls",
+
+    # Memory
+    "MemoryGrow": "memory_management",
+    "MemorySize": "memory_management",
+
+    # Unary
+    "I32Clz": "unary",
+    "I64Clz": "unary",
+    "I32Ctz": "unary",
+    "I64Ctz": "unary",
+    "I32Popcnt": "unary",
+    "I64Popcnt": "unary",
+    "I64ExtendI32S": "unary",
+    "I64ExtendI32U": "unary",
+    "I32WrapI64": "unary",
+    "F32Sqrt": "unary",
+    "F64Sqrt": "unary",
+    "F32Ceil": "unary",
+    "F64Ceil": "unary",
+    "F32Floor": "unary",
+    "F64Floor": "unary",
+    "F32Trunc": "unary",
+    "F64Trunc": "unary",
+    "F32Nearest": "unary",
+    "F64Nearest": "unary",
+    "F32Abs": "unary",
+    "F64Abs": "unary",
+    "F32Neg": "unary",
+    "F64Neg": "unary",
+    "F64ConvertI64U": "unary",
+    "F64ConvertI32U": "unary",
+    "F64ConvertI64S": "unary",
+    "F64ConvertI32S": "unary",
+    "F32ConvertI64S": "unary",
+    "F32ConvertI32S": "unary",
+    "F32ConvertI64U": "unary",
+    "F32ConvertI32U": "unary",
+    "F64PromoteF32": "unary",
+    "F32DemoteF64": "unary",
+    "I64TruncF64S": "unary",
+    "I64TruncF32S": "unary",
+    "I32TruncF64S": "unary",
+    "I32TruncF32S": "unary",
+    "I64TruncF64U": "unary",
+    "I64TruncF32U": "unary",
+    "I32TruncF64U": "unary",
+    "I32TruncF32U": "unary",
+    "I64TruncSatF64S": "unary",
+    "I64TruncSatF32S": "unary",
+    "I32TruncSatF64S": "unary",
+    "I32TruncSatF32S": "unary",
+    "I64TruncSatF64U": "unary",
+    "I64TruncSatF32U": "unary",
+    "I32TruncSatF64U": "unary",
+    "I32TruncSatF32U": "unary",
+    "F32ReinterpretI32": "unary",
+    "F64ReinterpretI64": "unary",
+    "I32ReinterpretF32": "unary",
+    "I64ReinterpretF64": "unary",
+    "I32Extend8S": "unary",
+    "I32Extend16S": "unary",
+    "I64Extend8S": "unary",
+    "I64Extend16S": "unary",
+    "I64Extend32S": "unary",
+
+    # Binary
+    "I32Add": "binary",
+    "I64Add": "binary",
+    "I32And": "binary",
+    "I64And": "binary",
+    "I32Or": "binary",
+    "I64Or": "binary",
+    "I32Xor": "binary",
+    "I64Xor": "binary",
+    "I32Shl": "binary",
+    "I64Shl": "binary",
+    "I32ShrS": "binary",
+    "I64ShrS": "binary",
+    "I32ShrU": "binary",
+    "I64ShrU": "binary",
+    "I32Rotl": "binary",
+    "I64Rotl": "binary",
+    "I32Rotr": "binary",
+    "I64Rotr": "binary",
+    "F32Add": "binary",
+    "F64Add": "binary",
+    "I32Sub": "binary",
+    "I64Sub": "binary",
+    "F32Sub": "binary",
+    "F64Sub": "binary",
+    "I32Mul": "binary",
+    "I64Mul": "binary",
+    "F32Mul": "binary",
+    "F64Mul": "binary",
+    "F32Div": "binary",
+    "F64Div": "binary",
+    "I32DivS": "binary",
+    "I64DivS": "binary",
+    "I32DivU": "binary",
+    "I64DivU": "binary",
+    "I32RemS": "binary",
+    "I64RemS": "binary",
+    "I32RemU": "binary",
+    "I64RemU": "binary",
+    "F32Min": "binary",
+    "F64Min": "binary",
+    "F32Max": "binary",
+    "F64Max": "binary",
+    "F32Copysign": "binary",
+    "F64Copysign": "binary",
+
+    # Comparisons
+    "I32LtS": "comparison",
+    "I64LtS": "comparison",
+    "I32LtU": "comparison",
+    "I64LtU": "comparison",
+    "I32LeS": "comparison",
+    "I64LeS": "comparison",
+    "I32LeU": "comparison",
+    "I64LeU": "comparison",
+    "I32GtS": "comparison",
+    "I64GtS": "comparison",
+    "I32GtU": "comparison",
+    "I64GtU": "comparison",
+    "I32GeS": "comparison",
+    "I64GeS": "comparison",
+    "I32GeU": "comparison",
+    "I64GeU": "comparison",
+    "I32Eqz": "comparison",
+    "I64Eqz": "comparison",
+    "I32Eq": "comparison",
+    "I64Eq": "comparison",
+    "F32Eq": "comparison",
+    "F64Eq": "comparison",
+    "I32Ne": "comparison",
+    "I64Ne": "comparison",
+    "F32Ne": "comparison",
+    "F64Ne": "comparison",
+    "F32Gt": "comparison",
+    "F64Gt": "comparison",
+    "F32Ge": "comparison",
+    "F64Ge": "comparison",
+    "F32Lt": "comparison",
+    "F64Lt": "comparison",
+    "F32Le": "comparison",
+    "F64Le": "comparison",
+}
+
+def op_category(op):
+    if op.startswith("Local"):
+        return "locals"
+    if op.startswith("Global"):
+        return "globals"
+    if "Load" in op:
+        return "loads"
+    if "Store" in op:
+        return "stores"
+    if op.endswith("Const"):
+        return "const"
+    return CATEGORIES.get(op, None)
+
+
+ALLOW_NO_INSTRUCTIONS = {
+    "Drop",
+}
+
+def build_clif_tags(data, in_scope_proposals, ignore_categories=None):
+    ignore_categories = ignore_categories or set()
+    op_proposal = {op["op"]: op["proposal"] for op in data["operators"]}
+
+    clif_tags = dict()
+    for translation in data["translations"]:
+        for op in translation["operators"]:
+            # Check proposal
+            proposal = op_proposal[op]
+            if proposal not in in_scope_proposals:
+                logging.debug(f"{op} proposal not in scope")
+                continue
+            category = op_category(op)
+
+            # Check category
+            assert category is not None, f"no category for {op}"
+            if category in ignore_categories:
+                logging.debug(f"{op} category not in scope")
+                continue
+
+            # Expect corresponding CLIF instructions
+            instructions = translation["instructions"]
+            assert op in ALLOW_NO_INSTRUCTIONS or len(instructions) > 0, f"no instructions for {op}"
+            for instruction in instructions:
+                tags = clif_tags.setdefault(instruction, set())
+                tags.add(f"wasm_proposal_{proposal}")
+                tags.add(f"wasm_category_{category}")
+
+    return {inst: list(sorted(tags)) for inst, tags in clif_tags.items()}
+
+
+def main(args):
+    # Options.
+    parser = argparse.ArgumentParser(description='Derive WASM to CLIF mapping')
+    parser.add_argument('--data', required=True, type=argparse.FileType('r'), help="wasm to clif data file")
+    parser.add_argument('--output', type=argparse.FileType('w'), default=sys.stdout)
+    parser.add_argument('--log-level', default="info")
+    opts = parser.parse_args(args)
+    logging.basicConfig(level=opts.log_level.upper())
+
+    # Read WASM to CLIF data.
+    data = json.load(opts.data)
+
+    # Build tags.
+    in_scope_proposals = set(["mvp"])
+    ignore_categories = set([
+        "locals",
+        "globals",
+        "control_flow",
+        "calls",
+        "memory_management",
+    ])
+    clif_tags = build_clif_tags(data, in_scope_proposals, ignore_categories)
+
+    # Write
+    json.dump(clif_tags, opts.output, indent="\t")
+    opts.output.write("\n")
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])
diff --git a/cranelift/isle/veri/meta/script/generate.sh b/cranelift/isle/veri/meta/script/generate.sh
new file mode 100755
index 000000000000..911b09bc324b
--- /dev/null
+++ b/cranelift/isle/veri/meta/script/generate.sh
@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+
+set -euxo pipefail
+
+# Float constants
+cargo run --bin fpconst >"../../../codegen/src/fpconst.isle"
+
+# Wasm operators
+wasmops="data/wasmoperators.csv"
+cargo run --bin wasmoperators >"${wasmops}"
+
+# Translation
+wasm2clif="data/wasm2clif.json"
+./script/wasm2clif.py --wasm-ops "${wasmops}" --output "${wasm2clif}"
+
+# Tagging
+cliftags="data/cliftags.json"
+./script/cliftags.py --data "${wasm2clif}" --output "${cliftags}"
+
+# ISLE tags
+./script/isletags.py --data "${cliftags}" --output "../../../codegen/src/inst_tags.isle"
diff --git a/cranelift/isle/veri/meta/script/isletags.py b/cranelift/isle/veri/meta/script/isletags.py
new file mode 100755
index 000000000000..b8657423f7a7
--- /dev/null
+++ b/cranelift/isle/veri/meta/script/isletags.py
@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+
+import sys
+import argparse
+import json
+import logging
+import pathlib
+
+
+def write_isle_tags(data, output):
+    self_path = pathlib.Path(__file__)
+    print(f";; GENERATED BY `{self_path.stem}`. DO NOT EDIT!!!", file=output);
+    for (term, tags) in data.items():
+        print("", file=output)
+        print(f"(attr {term}", file=output)
+        for tag in tags:
+            print(f"    (tag {tag})", file=output)
+        print(")", file=output)
+
+
+def main(args):
+    # Options.
+    parser = argparse.ArgumentParser(description='Generate ISLE tags for CLIF terms')
+    parser.add_argument('--data', required=True, type=argparse.FileType('r'), help="clif tags JSON file")
+    parser.add_argument('--output', type=argparse.FileType('w'), default=sys.stdout)
+    parser.add_argument('--log-level', default="info")
+    opts = parser.parse_args(args)
+    logging.basicConfig(level=opts.log_level.upper())
+
+    # Read CLIF tags.
+    data = json.load(opts.data)
+
+    # Write ISLE.
+    write_isle_tags(data, opts.output)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])
diff --git a/cranelift/isle/veri/meta/script/trace/collect.sh b/cranelift/isle/veri/meta/script/trace/collect.sh
new file mode 100755
index 000000000000..ab9d06640b6a
--- /dev/null
+++ b/cranelift/isle/veri/meta/script/trace/collect.sh
@@ -0,0 +1,32 @@
+#!/bin/bash
+
+set -exuo pipefail
+
+tests_directory="$1"
+trace_directory="$2"
+
+# Build.
+cargo build \
+    --bin wasmtime \
+    --release \
+    --no-default-features \
+    --features wast \
+    --features logging \
+    --features cranelift \
+    --features threads \
+    --features 'wasmtime-cranelift/trace-log'
+
+# Run.
+for test in "${tests_directory}"/*.wast ; do
+    test_name=$(basename "${test}")
+    log_prefix="${trace_directory}/${test_name}."
+    RUST_LOG='isle_rule_trace=trace' \
+        ./target/release/wasmtime wast \
+        --codegen compiler=cranelift \
+        --codegen cache=no \
+        --codegen parallel-compilation=no \
+        --wasm multi-memory=n \
+        --debug log-to-files=y \
+        --debug log-prefix="${log_prefix}" \
+        "${test}"
+done
diff --git a/cranelift/isle/veri/meta/script/trace/report.py b/cranelift/isle/veri/meta/script/trace/report.py
new file mode 100755
index 000000000000..a051ee10e1ff
--- /dev/null
+++ b/cranelift/isle/veri/meta/script/trace/report.py
@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+
+import sys
+from collections import Counter, namedtuple
+
+TOP_K = 32
+
+# Trace events.
+class EventInstruction(namedtuple("TraceInstruction", ["opcode", "output_types", "input_types", "features"])):
+    def is_ctrl(self):
+        return self.has_any_feature("terminator", "branch", "call")
+
+    def is_mem(self):
+        return self.has_any_feature("load", "store")
+
+    def is_fp(self):
+        return self.has_any_type("f32", "f64")
+
+    def has_type(self, ty):
+        return ty in self.output_types or ty in self.input_types
+
+    def has_any_type(self, *tys):
+        return any(self.has_type(ty) for ty in tys)
+
+    def has_feature(self, feature):
+        return (feature in self.features)
+
+    def has_any_feature(self, *features):
+        return any(self.has_feature(feature) for feature in features)
+
+
+class EventRule(namedtuple("TraceRule", ["name", "pos"])):
+    pass
+
+# Trace parsing.
+
+def parse_trace(lines):
+    trace = []
+    for line in lines:
+        parts = line.rstrip().split(None, 3)
+        if len(parts) == 0 or parts[0] != "TRACE":
+            continue
+        assert len(parts) == 4
+        assert parts[1] == "-"
+        typ = parts[2].rstrip(":")
+        fields = parts[3].split(",")
+        # TRACE - inst: trap
+        if typ == "inst":
+            assert len(fields) == 4
+            trace.append(EventInstruction(
+                opcode=fields[0],
+                output_types=fields[1].split(":"),
+                input_types=fields[2].split(":"),
+                features=fields[3].split(":"),
+            ))
+        # TRACE - rule: ,src/isa/x64/inst.isle line 4101
+        elif typ == "rule":
+            assert len(fields) == 2
+            trace.append(EventRule(
+                name=fields[0],
+                pos=fields[1],
+            ))
+        else:
+            assert False, f"unknown trace type: {typ}"
+    return trace
+
+
+# Report generation.
+
+def rule_stats(exclude_fp=False, exclude_mem=False, exclude_ctrl=False):
+    counts = Counter()
+    names = {}
+
+    # Ingest the trace.
+    exclude = False
+    for event in parse_trace(sys.stdin):
+        # Instruction event: starting a new lowering.
+        if isinstance(event, EventInstruction):
+            # Should we exclude this instruction?
+            exclude = False
+            if exclude_fp:
+                exclude |= event.is_fp()
+            if exclude_mem:
+                exclude |= event.is_mem()
+            if exclude_ctrl:
+                exclude |= event.is_ctrl()
+            continue
+
+        # Rule event: ISLE rule fired in lowering.
+        elif isinstance(event, EventRule):
+            if exclude:
+                continue
+            counts[event.pos] += 1
+            names.setdefault(event.pos, event.name)
+
+        else:
+            assert False, "unknown trace event"
+
+    # How many uses (times a rule was triggered) were of named rules?
+    named_uses = sum(n for (pos, n) in counts.items() if names.get(pos))
+    total_uses = sum(counts.values())
+    print(f'\nNamed uses: {named_uses}/{total_uses} = '
+          f'{named_uses/total_uses:.1%}')
+
+    # How many covered rules (used at least once) were named?
+    named_covered = sum(1 for (i, c) in counts.items() if names.get(i))
+    total_covered = len(counts)
+    print(f'\nNamed covered: {named_covered}/{total_covered} = '
+          f'{named_covered/total_covered:.1%}')
+
+    # Print the most frequently triggered rules, for fun.
+    print(f'Top {TOP_K} most commonly used rules:')
+    for pos, count in counts.most_common(TOP_K):
+        print(count, pos, names[pos])
+
+
+
+if __name__ == "__main__":
+    rule_stats(
+        '--no-fp' in sys.argv[1:],
+        '--no-mem' in sys.argv[1:],
+        '--no-ctrl' in sys.argv[1:],
+    )
diff --git a/cranelift/isle/veri/meta/script/trace/run.sh b/cranelift/isle/veri/meta/script/trace/run.sh
new file mode 100755
index 000000000000..2f9e942ac061
--- /dev/null
+++ b/cranelift/isle/veri/meta/script/trace/run.sh
@@ -0,0 +1,29 @@
+#!/bin/bash
+
+set -exuo pipefail
+
+script_directory=$(dirname -- "${BASH_SOURCE[0]}")
+working_directory=$(mktemp -d)
+
+# Tests.
+tests_directory="${working_directory}/tests"
+mkdir -p "${tests_directory}"
+
+"${script_directory}/tests.sh" "${tests_directory}"
+
+# Collect traces.
+traces_directory="${working_directory}/traces"
+mkdir -p "${traces_directory}"
+
+"${script_directory}/collect.sh" "${tests_directory}" "${traces_directory}"
+
+trace_file="${working_directory}/trace.txt"
+cat "${traces_directory}/"* > "${trace_file}"
+
+# Report.
+report_file="${working_directory}/report.txt"
+"${script_directory}/report.py" "$@" < "${trace_file}" > "${report_file}"
+
+# Wrap.
+cat "${report_file}"
+echo "${working_directory}"
diff --git a/cranelift/isle/veri/meta/script/trace/tests.sh b/cranelift/isle/veri/meta/script/trace/tests.sh
new file mode 100755
index 000000000000..9dbaf9092ff6
--- /dev/null
+++ b/cranelift/isle/veri/meta/script/trace/tests.sh
@@ -0,0 +1,29 @@
+#!/bin/bash
+
+set -exuo pipefail
+
+tests_directory="$1"
+
+# Copy to tests_directory directory.
+#
+# Exclude:
+# simd*: All SIMD is out of scope.
+# table-sub, table_copy, table_init, bulk, memory_fill, memory_copy:
+#   bulk memory ops extension
+# binary: limited to binary parsing tests
+# binary-leb128: Uses `trunc_sat_*` instructions, and seems to be mostly about
+#   parsing the binary format anyway.
+shopt -s extglob
+cp tests/spec_testsuite/!(simd*|table-sub|table_copy|table_init|bulk|memory_fill|memory_copy|binary|binary-leb128).wast "${tests_directory}"
+
+# Remove `i(32|64).extend(8|16|32)_s` instructions and the tests that use
+# them, which are part of the sign-extending operators extension.
+sed -i.bak '/extend[0-9][0-9]*_s/d' "${tests_directory}/i32.wast"
+sed -i.bak '/extend[0-9][0-9]*_s/d' "${tests_directory}/i64.wast"
+
+# Same with `trunc_sat_f(32|64)_(s|u)` instructions, which are part of the
+# non-trapping float-to-int extension.
+sed -i.bak '/trunc_sat_/d' "${tests_directory}/conversions.wast"
+
+# Clean.
+rm "${tests_directory}"/*.bak
diff --git a/cranelift/isle/veri/meta/script/wasm2clif.py b/cranelift/isle/veri/meta/script/wasm2clif.py
new file mode 100755
index 000000000000..3d00cd3224a2
--- /dev/null
+++ b/cranelift/isle/veri/meta/script/wasm2clif.py
@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+
+import sys
+import pathlib
+import itertools
+import logging
+import collections
+import re
+import csv
+import argparse
+import json
+
+
+INDENT = 4*" "
+
+Operator = collections.namedtuple("Operator", ["op", "proposal"])
+
+def read_wasm_operators_csv(f):
+    r = csv.reader(f)
+    ops = []
+    for row in r:
+        assert len(row) == 2
+        op = Operator(row[0], row[1])
+        ops.append(op)
+    return ops
+
+
+Arm = collections.namedtuple("Arm", ["pattern", "body"])
+
+class Parser:
+    def __init__(self, lines):
+        self.lines = lines
+
+    def parse(self):
+        # Find function start
+        self.skip_to("pub fn translate_operator")
+
+        # Find switch start
+        self.skip_to(f"{INDENT}match op {{")
+
+        # Parse arms.
+        translations = []
+        while True:
+            arm = self.parse_arm()
+            if arm is None:
+                break
+
+            logging.debug(f"pattern: {arm.pattern}")
+            assert len(arm.pattern) > 0
+            logging.debug(f"body: {arm.body}")
+            assert len(arm.body) > 0
+
+            translation = derive_arm_translation(arm)
+            translations.append(translation)
+
+        return translations
+
+    @staticmethod
+    def is_comment(line):
+        trim = line.lstrip()
+        return trim.startswith("/*") or trim.startswith("//") or trim.startswith("*")
+
+    def parse_arm(self):
+        # Collect pattern
+        pattern = ""
+        for line in self.lines:
+            single_line = self.parse_arm_single_line(line)
+            if single_line is not None:
+                return single_line
+            if line.startswith(f"{INDENT}}};"):
+                return None
+            pattern += line
+            if line.endswith("=> {\n"):
+                break
+
+        # Collect body
+        body = ""
+        for line in self.lines:
+            body += line
+            if line.startswith(f"{INDENT}{INDENT}}}"):
+                break
+
+        return Arm(pattern, body)
+
+    @staticmethod
+    def parse_arm_single_line(line):
+        if "Operator::" not in line:
+            return None
+        if " => " not in line:
+            return None
+        if not line.endswith(",\n"):
+            return None
+        parts = line.split(" => ")
+        assert len(parts) == 2
+        return Arm(parts[0], parts[1])
+
+    def skip_to(self, target):
+        for line in self.lines:
+            if line.startswith(target):
+                logging.debug(f"found target: {target}")
+                return
+        raise ValueError(f"could not find target: {target}")
+
+
+Translation = collections.namedtuple("Translation", ["operators", "instructions"])
+
+def derive_arm_translation(arm):
+    # Parse operators
+    operators = re.findall(r'Operator::(\w+)', arm.pattern, flags=re.MULTILINE)
+
+    # Parse instructions.
+    instructions = re.findall(r'builder\.ins\(\)\.(\w+)\(', arm.body, flags=re.MULTILINE)
+
+    # Parse opcodes.
+    opcodes = re.findall(r'ir::Opcode::(\w+)', arm.body, flags=re.MULTILINE)
+    instructions.extend(opcode.lower() for opcode in opcodes)
+
+    # Special cases
+    if "translate_icmp(" in arm.body:
+        instructions.append("icmp")
+        instructions.append("uextend")
+    if "translate_fcmp(" in arm.body:
+        instructions.append("fcmp")
+        instructions.append("uextend")
+    if "translate_store(" in arm.body or "translate_load(" in arm.body:
+        # prepare_addr
+        instructions.append("uadd_overflow_trap")
+        # bounds_checks::bounds_check_and_compute_addr
+        instructions.append("icmp")
+        instructions.append("isub")
+        instructions.append("iconst")
+
+    # Deduplicate and sort
+    instructions = sorted(list(set(instructions)))
+
+    return Translation(operators, instructions)
+
+
+def build_wasm_to_clif(ops, translations):
+    data = {
+        "operators": list(op._asdict() for op in ops),
+        "translations": list(t._asdict() for t in translations),
+    }
+    return data
+
+
+def code_translator_path():
+    self_dir = pathlib.Path(__file__).parent.resolve()
+    rel_path = "../../../../wasm/src/code_translator.rs"
+    return self_dir.joinpath(rel_path)
+
+
+def main(args):
+    # Options.
+    parser = argparse.ArgumentParser(description='Derive WASM to CLIF mapping')
+    parser.add_argument('--wasm-ops', required=True, type=argparse.FileType('r'), help="wasm operators csv file")
+    parser.add_argument('--output', type=argparse.FileType('w'), default=sys.stdout)
+    parser.add_argument('--log-level', default="info")
+    opts = parser.parse_args(args)
+    logging.basicConfig(level=opts.log_level.upper())
+
+    # Read WASM operators.
+    ops = read_wasm_operators_csv(opts.wasm_ops)
+
+    # Parse code translator.
+    path = code_translator_path()
+    with open(path) as lines:
+        parser = Parser(lines)
+        translations = parser.parse()
+
+    # Build and write dataset.
+    data = build_wasm_to_clif(ops, translations)
+    json.dump(data, opts.output, indent="\t")
+    opts.output.write("\n")
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])
diff --git a/cranelift/isle/veri/meta/src/bin/fpconst.rs b/cranelift/isle/veri/meta/src/bin/fpconst.rs
new file mode 100644
index 000000000000..ba69cf99327a
--- /dev/null
+++ b/cranelift/isle/veri/meta/src/bin/fpconst.rs
@@ -0,0 +1,45 @@
+fn fp_const_macro(name: &str, x32: f32, x64: f64, desc: &str) {
+    println!(
+        "
+; Build {desc} as a floating-point of the given width.
+(macro ({name} w)
+    (conv_to w
+        (switch w
+            (32 #x{:016x})
+            (64 #x{:016x})
+       )
+    )
+)",
+        x32.to_bits(),
+        x64.to_bits()
+    );
+}
+
+fn fp_const_macros(name: &str, x32: f32, x64: f64, desc: &str) {
+    fp_const_macro(&format!("fp_{name}"), x32, x64, desc);
+    fp_const_macro(
+        &format!("fp_minus_{name}"),
+        -x32,
+        -x64,
+        &format!("negative {desc}"),
+    );
+}
+
+fn main() {
+    println!(";; GENERATED BY `fpconst`. DO NOT EDIT!!!");
+
+    fp_const_macros("one", 1.0, 1.0, "one");
+    fp_const_macros("half", 0.5, 0.5, "half");
+    fp_const_macros(
+        "i32_min",
+        i32::MIN as f32,
+        i32::MIN as f64,
+        "32-bit integer minimum",
+    );
+    fp_const_macros(
+        "i64_min",
+        i64::MIN as f32,
+        i64::MIN as f64,
+        "64-bit integer minimum",
+    );
+}
diff --git a/cranelift/isle/veri/meta/src/bin/wasmoperators.rs b/cranelift/isle/veri/meta/src/bin/wasmoperators.rs
new file mode 100644
index 000000000000..199b46835fe2
--- /dev/null
+++ b/cranelift/isle/veri/meta/src/bin/wasmoperators.rs
@@ -0,0 +1,16 @@
+use wasmparser::for_each_operator;
+
+macro_rules! print_operator {
+    ($( @$proposal:ident $op:ident $({ $($arg:ident: $argty:ty),* })? => $visit:ident)*) => {
+        $(
+            println!("{},{}",
+                stringify!($op),
+                stringify!($proposal),
+            );
+        )*
+    }
+}
+
+pub fn main() {
+    for_each_operator!(print_operator);
+}
diff --git a/cranelift/isle/veri/test-macros/Cargo.toml b/cranelift/isle/veri/test-macros/Cargo.toml
new file mode 100644
index 000000000000..3ba3e83df2f8
--- /dev/null
+++ b/cranelift/isle/veri/test-macros/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "cranelift-isle-veri-test-macros"
+version = "0.1.0"
+publish = false
+edition.workspace = true
+
+[lib]
+proc-macro = true
+
+[dependencies]
+quote = "1.0"
+syn = { workspace = true, features = ["full"]}
+proc-macro2 = "1.0"
+proc-macro-error = "1.0"
diff --git a/cranelift/isle/veri/test-macros/src/lib.rs b/cranelift/isle/veri/test-macros/src/lib.rs
new file mode 100644
index 000000000000..029cc2ba61e8
--- /dev/null
+++ b/cranelift/isle/veri/test-macros/src/lib.rs
@@ -0,0 +1,101 @@
+extern crate proc_macro;
+
+use std::{collections::HashMap, env, ffi::OsStr, fs, path::PathBuf, str::FromStr};
+
+use proc_macro::TokenStream;
+use proc_macro_error::{abort_call_site, proc_macro_error};
+use quote::quote;
+use syn::{parse_macro_input, punctuated::Punctuated, Expr, ExprLit, ItemFn, Lit, Meta};
+
+#[proc_macro_error]
+#[proc_macro_attribute]
+pub fn file_tests(attrs: TokenStream, input: TokenStream) -> TokenStream {
+    // Parse attributes.
+    let metas = parse_macro_input!(attrs with Punctuated::<Meta, syn::Token![,]>::parse_terminated);
+    let mut attrs = parse_attrs(&metas);
+
+    let relative_path = attrs.remove("path").unwrap_or(".".to_string());
+    let ext = attrs.remove("ext").unwrap_or("test".to_string());
+    if !attrs.is_empty() {
+        let keys: String = attrs.keys().cloned().collect::<Vec<_>>().join(", ");
+        abort_call_site!(format!("unknown keys: {keys}"));
+    }
+
+    // Parse the input as a function.
+    let input = proc_macro2::TokenStream::from(input);
+
+    let func_ast: ItemFn =
+        syn::parse(input.clone().into()).expect("should be able to parse tokens as function");
+
+    let func_ident = &func_ast.sig.ident;
+    let func_name = func_ident.to_string();
+
+    // Locate test data directory.
+    let crate_dir = PathBuf::from_str(
+        &env::var("CARGO_MANIFEST_DIR")
+            .expect("CARGO_MANIFEST_DIR environment variable must be set"),
+    )
+    .expect("CARGO_MANIFEST_DIR should be a valid path");
+    let test_data_dir = crate_dir.join(relative_path);
+
+    // Collect files with requested extension.
+    let mut paths = Vec::new();
+    for entry in fs::read_dir(test_data_dir).expect("should be able to read test data directory") {
+        let entry = entry.expect("invalid directory entry");
+        if entry.path().extension() == Some(OsStr::new(&ext)) {
+            paths.push(entry.path());
+        }
+    }
+
+    if paths.is_empty() {
+        abort_call_site!("no test case files found");
+    }
+
+    // Generate one test case per file.
+    let test_cases = paths.iter().map(|path| {
+        let full = path
+            .to_str()
+            .expect("test file path should be valid string");
+        let test_case_name = path
+            .file_stem()
+            .expect("test data path should have a file name")
+            .to_str()
+            .expect("test file name should be valid string");
+        let test_name = format!("{func_name}_{test_case_name}");
+        let test_ident =
+            proc_macro2::Ident::new(test_name.as_str(), proc_macro2::Span::call_site());
+        quote! {
+            #[test]
+            fn #test_ident() {
+                #func_ident(#full);
+            }
+        }
+    });
+
+    // Combining the function and test cases.
+    let output = quote! {
+        #input
+
+        #(#test_cases)*
+    };
+
+    output.into()
+}
+
+fn parse_attrs(metas: &Punctuated<Meta, syn::Token![,]>) -> HashMap<String, String> {
+    let mut attrs = HashMap::new();
+    for meta in metas.iter() {
+        if let Meta::NameValue(n) = meta {
+            let key = n.path.get_ident().unwrap().to_string();
+            match &n.value {
+                Expr::Lit(ExprLit {
+                    lit: Lit::Str(s), ..
+                }) => {
+                    attrs.insert(key, s.value());
+                }
+                _ => abort_call_site!("attribute values must be string"),
+            }
+        }
+    }
+    attrs
+}
diff --git a/cranelift/isle/veri/veri/Cargo.toml b/cranelift/isle/veri/veri/Cargo.toml
new file mode 100644
index 000000000000..48f0030230ee
--- /dev/null
+++ b/cranelift/isle/veri/veri/Cargo.toml
@@ -0,0 +1,22 @@
+[package]
+name = "cranelift-isle-veri"
+version = "0.1.0"
+edition.workspace = true
+
+[dependencies]
+cranelift-isle = { version = "*", path = "../../isle/", features = ["fancy-errors", "logging"] }
+cranelift-codegen-meta = { version = "*", path = "../../../codegen/meta" }
+log = { workspace = true }
+env_logger = { workspace = true }
+anyhow = { workspace = true, features = ['std', 'backtrace'] }
+clap = { workspace = true, features = ['default', 'env'] }
+serde = { workspace = true, features = ['derive'] }
+serde_json = { workspace = true }
+num-bigint = "0.4"
+num-traits = "0.2"
+easy-smt = "0.2.4"
+rayon = "1"
+
+[dev-dependencies]
+tempfile = { workspace = true }
+cranelift-isle-veri-test-macros = { path = "../test-macros" }
diff --git a/cranelift/isle/veri/veri/build.rs b/cranelift/isle/veri/veri/build.rs
new file mode 100644
index 000000000000..5271753ad4fe
--- /dev/null
+++ b/cranelift/isle/veri/veri/build.rs
@@ -0,0 +1,38 @@
+use std::env;
+
+fn write_build_meta() {
+    let out_dir = env::var("OUT_DIR").expect("The OUT_DIR environment variable must be set");
+
+    // Profile: debug, release, ...
+    let build_profile = env::var("PROFILE").expect("The PROFILE environment variable must be set");
+
+    // Git hash
+    let output = std::process::Command::new("git")
+        .arg("describe")
+        .arg("--always")
+        .arg("--dirty")
+        .arg("--abbrev=12")
+        .arg("--exclude")
+        .arg("*")
+        .output()
+        .expect("Failed to execute git describe");
+    let output = String::from_utf8(output.stdout).unwrap();
+    let git_version = output.trim();
+
+    std::fs::write(
+        std::path::Path::new(&out_dir).join("meta.rs"),
+        format!(
+            "pub const BUILD_PROFILE: &str = \"{build_profile}\";\n\
+            pub const GIT_VERSION: &str = \"{git_version}\";\n\
+            "
+        ),
+    )
+    .unwrap();
+}
+
+fn main() {
+    println!("cargo:rerun-if-changed=build.rs");
+    println!("cargo:rerun-if-changed=filetests");
+
+    write_build_meta();
+}
diff --git a/cranelift/isle/veri/veri/filetests/broken/add_double.isle b/cranelift/isle/veri/veri/filetests/broken/add_double.isle
new file mode 100644
index 000000000000..a2e15ad88d4d
--- /dev/null
+++ b/cranelift/isle/veri/veri/filetests/broken/add_double.isle
@@ -0,0 +1,20 @@
+; 8-bit value type
+(type Value (primitive Value))
+(model Value (type (bv 8)))
+
+; Top-level test term asserts equality
+(decl test (Value) Value)
+(spec (test arg) (provide (= result arg)))
+
+; Add
+(decl add (Value Value) Value)
+(extern extractor add add)
+(spec (add x y) (provide (= result (bvadd x y))))
+
+; Double x
+(decl double (Value) Value)
+(extern constructor double double)
+(spec (double x) (provide (= result (bvadd x x))))
+
+; Broken rule maps add to double.
+(rule test (test (add x y)) (double x))
diff --git a/cranelift/isle/veri/veri/filetests/pass/add_commutative.isle b/cranelift/isle/veri/veri/filetests/pass/add_commutative.isle
new file mode 100644
index 000000000000..13c58422768b
--- /dev/null
+++ b/cranelift/isle/veri/veri/filetests/pass/add_commutative.isle
@@ -0,0 +1,20 @@
+; 8-bit value type
+(type Value (primitive Value))
+(model Value (type (bv 8)))
+
+; Top-level test term asserts equality
+(decl test (Value) Value)
+(spec (test arg) (provide (= result arg)))
+
+; Add x + y
+(decl add_xy (Value Value) Value)
+(extern extractor add_xy add_xy)
+(spec (add_xy x y) (provide (= result (bvadd x y))))
+
+; Add y + x
+(decl add_yx (Value Value) Value)
+(extern constructor add_yx add_yx)
+(spec (add_yx x y) (provide (= result (bvadd y x))))
+
+; Test rule commutes addition operands
+(rule test (test (add_xy x y)) (add_yx x y))
diff --git a/cranelift/isle/veri/veri/filetests/pass/enum_exhaustive.isle b/cranelift/isle/veri/veri/filetests/pass/enum_exhaustive.isle
new file mode 100644
index 000000000000..d19f2b915cb9
--- /dev/null
+++ b/cranelift/isle/veri/veri/filetests/pass/enum_exhaustive.isle
@@ -0,0 +1,40 @@
+; Test case that relies on the assumption that enum types must equal one of the
+; variants.
+
+; 8-bit value type
+(type Value (primitive Value))
+(model Value (type (bv 8)))
+
+; Operation type.
+(type Op (enum (Add) (Mul)))
+
+; Top-level test term asserts equality
+(decl test (Value) Value)
+(spec (test arg) (provide (= result arg)))
+
+; op(x, y)
+(decl op_xy (Op Value Value) Value)
+(extern extractor op_xy op_xy)
+(spec (op_xy op x y)
+    (provide
+        (= result (match op
+            ((Add) (bvadd x y))
+            ((Mul) (bvmul x y))
+        ))
+    )
+)
+
+; op(y, x)
+(decl op_yx (Op Value Value) Value)
+(extern constructor op_yx op_yx)
+(spec (op_yx op x y)
+    (provide
+        (= result (match op
+            ((Add) (bvadd y x))
+            ((Mul) (bvmul y x))
+        ))
+    )
+)
+
+; Test rule commutes operands
+(rule test (test (op_xy op x y)) (op_yx op x y))
diff --git a/cranelift/isle/veri/veri/filetests/pass/enum_variant_instantiation.isle b/cranelift/isle/veri/veri/filetests/pass/enum_variant_instantiation.isle
new file mode 100644
index 000000000000..52a7aa211d48
--- /dev/null
+++ b/cranelift/isle/veri/veri/filetests/pass/enum_variant_instantiation.isle
@@ -0,0 +1,45 @@
+; Test case that requires type instantiation for enum variants.
+
+; Value type of unspecified bit-vector width.
+(type Value (primitive Value))
+(model Value (type (bv)))
+
+; Top-level test term asserts equality
+(decl test (Value) Value)
+(spec (test arg) (provide (= result arg)))
+
+; Add 42.
+(decl add42 (Value) Value)
+(extern extractor add42 add42)
+(spec (add42 x) (provide (= result (bvadd x #x2a))))
+
+; Operation type.
+(type Op
+    (enum
+        ; Addition of 42.
+        (Add42)
+
+        ; Deliberately unused variant. Type inference has no way to infer the
+        ; widths of the Value fields.
+        (Unused (val Value))
+    )
+)
+
+; Provide instantiations for the unused variant.
+(instantiate Op.Unused
+    ((args (bv 8)) (ret (named Op)))
+)
+
+; Evaluate operation on a value.
+(decl eval (Op Value) Value)
+(extern constructor eval eval)
+(spec (eval op x)
+    (provide
+        (= result (match op
+            ((Add42) (bvadd #x2a x))
+        ))
+    )
+)
+
+; Test rule lowers addition to an operation evaluation.
+(rule test (test (add42 x)) (eval (Op.Add42) x))
diff --git a/cranelift/isle/veri/veri/filetests/pass/macro_calls_macro.isle b/cranelift/isle/veri/veri/filetests/pass/macro_calls_macro.isle
new file mode 100644
index 000000000000..45ffe1fb7d75
--- /dev/null
+++ b/cranelift/isle/veri/veri/filetests/pass/macro_calls_macro.isle
@@ -0,0 +1,22 @@
+; 8-bit value type
+(type Value (primitive Value))
+(model Value (type (bv 8)))
+
+; Top-level test term asserts equality
+(decl test (Value) Value)
+(spec (test arg) (provide (= result arg)))
+
+; Add using plain bvadd spec.
+(decl add_plain (Value Value) Value)
+(extern extractor add_plain add_plain)
+(spec (add_plain x y) (provide (= result (bvadd x y))))
+
+; Add using a nested macro.
+(macro (apply_op op x y) (op! x y))
+
+(decl add_with_macro (Value Value) Value)
+(extern constructor add_with_macro add_with_macro)
+(spec (add_with_macro x y) (provide (= result (apply_op! (macro (a b) (bvadd a b)) x y))))
+
+; Test rule checks plain and macro specs are equivalent.
+(rule test (test (add_plain x y)) (add_with_macro x y))
diff --git a/cranelift/isle/veri/veri/filetests/pass/priority_operand_size.isle b/cranelift/isle/veri/veri/filetests/pass/priority_operand_size.isle
new file mode 100644
index 000000000000..4d785c1c2686
--- /dev/null
+++ b/cranelift/isle/veri/veri/filetests/pass/priority_operand_size.isle
@@ -0,0 +1,29 @@
+;; Type of a value, modeled as its bit-width.
+(type Type (primitive Type))
+(model Type (type Int))
+
+;; Operand size of an instruction.
+(type OperandSize (enum Size32 Size64))
+
+;; An extractor that only matches types that can fit in 64 bits.
+(decl fits_in_32 (Type) Type)
+(extern extractor fits_in_32 fits_in_32)
+(spec (fits_in_32 ty) (provide (= result ty)) (match (<= result 32)))
+
+;; An extractor that only matches types that can fit in 64 bits.
+(decl fits_in_64 (Type) Type)
+(extern extractor fits_in_64 fits_in_64)
+(spec (fits_in_64 ty) (provide (= result ty)) (match (<= result 64)))
+
+;; Helper for calculating the `OperandSize` corresponding to a type.
+(decl test (Type) OperandSize)
+(spec (test ty)
+      (provide
+            (= result (if (<= ty 32) (OperandSize.Size32) (OperandSize.Size64))))
+      (require
+            (or (= ty 8) (= ty 16) (= ty 32) (= ty 64))))
+
+;; Helper rules depend upon priority.
+(rule operand_size_32 1 (test (fits_in_32 ty)) (OperandSize.Size32))
+(rule operand_size_64 (test (fits_in_64 ty)) (OperandSize.Size64))
+(attr rule operand_size_32 (veri priority))
diff --git a/cranelift/isle/veri/veri/filetests/pass/provide_only_if_match.isle b/cranelift/isle/veri/veri/filetests/pass/provide_only_if_match.isle
new file mode 100644
index 000000000000..60c2d82c3c89
--- /dev/null
+++ b/cranelift/isle/veri/veri/filetests/pass/provide_only_if_match.isle
@@ -0,0 +1,38 @@
+; Test case that the provides of a partial function are assumed only on match.
+;
+; Contrived regression test for incorrect extractor semantics.
+
+; 8-bit value type
+(type Value (primitive Value))
+(model Value (type (bv 8)))
+
+; Coin flip result.
+(type Coin (enum Heads Tails))
+
+; Top-level test term selects a result based on parity.
+(decl test (Value) Coin)
+(spec (test v) (provide
+        (= result
+            (if (= (extract 0 0 v) #b1)
+                (Coin.Heads)
+                (Coin.Tails)
+            )
+        )
+    )
+)
+
+; Contrived extractor matches on odd and provides it must be 73.
+(decl odd73 () Value)
+(extern extractor odd73 odd73)
+(spec (odd73)
+    (match (= (extract 0 0 result) #b1))
+    (provide (= result #x41))
+)
+
+; Lowering to heads when odd73 matches should still be correct.
+(rule test_odd73_heads 1 (test (odd73)) (Coin.Heads))
+
+; Accounting for priority should negate the matches of odd73, but not the
+; provides.
+(rule test_tails (test v) (Coin.Tails))
+(attr rule test_odd73_heads (veri priority))
diff --git a/cranelift/isle/veri/veri/filetests/pass/type_qualifier.isle b/cranelift/isle/veri/veri/filetests/pass/type_qualifier.isle
new file mode 100644
index 000000000000..383aec6712c0
--- /dev/null
+++ b/cranelift/isle/veri/veri/filetests/pass/type_qualifier.isle
@@ -0,0 +1,25 @@
+; Test case that requires type qualifier to satisfy type inference.
+
+; Value type of unspecified bit-vector width.
+(type Value (primitive Value))
+(model Value (type (bv)))
+
+; Top-level test term asserts equality
+(decl test (Value) Value)
+(spec (test arg) (provide (= result arg)))
+
+; Add then mask low byte.
+;
+; Note the (as ...) type qualifier. Without it, this test case would have
+; underconstrained type inference.
+(decl add_then_mask (Value Value) Value)
+(extern extractor add_then_mask add_then_mask)
+(spec (add_then_mask x y) (provide (= result (extract 7 0 (bvadd x (as y (bv 16)))))))
+
+; Mask low byte then add.
+(decl mask_then_add (Value Value) Value)
+(extern constructor mask_then_add mask_then_add)
+(spec (mask_then_add x y) (provide (= result (bvadd (extract 7 0 x) (extract 7 0 y)))))
+
+; Test rule swaps mask order.
+(rule test (test (add_then_mask x y)) (mask_then_add x y))
diff --git a/cranelift/isle/veri/veri/script/count.sh b/cranelift/isle/veri/veri/script/count.sh
new file mode 100755
index 000000000000..cef60465cd69
--- /dev/null
+++ b/cranelift/isle/veri/veri/script/count.sh
@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+
+set -exuo pipefail
+
+function count() {
+    cargo run --bin count -- \
+        --codegen-crate-dir ../../../codegen/ \
+        --work-dir /tmp \
+        "$@"
+}
+
+rm -f output/*.count
+
+count \
+    --name "aarch64" \
+    --term-name lower \
+    --max-rules 3 \
+    --exclude-chain operand_size \
+    > "output/aarch64_lower.count"
diff --git a/cranelift/isle/veri/veri/script/expand.sh b/cranelift/isle/veri/veri/script/expand.sh
new file mode 100755
index 000000000000..b1a441ccd9a6
--- /dev/null
+++ b/cranelift/isle/veri/veri/script/expand.sh
@@ -0,0 +1,106 @@
+#!/usr/bin/env bash
+
+set -exuo pipefail
+
+function expand() {
+    cargo run --bin expand -- \
+        --codegen-crate-dir ../../../codegen/ \
+        --work-dir /tmp \
+        "$@"
+}
+
+rm -f output/*.out
+
+expand \
+    --name aarch64 \
+    --term-name sink_load_into_addr \
+    > output/sink_load_into_addr.out
+
+expand \
+    --name aarch64 \
+    --term-name sink_load_into_addr \
+    --chain add_imm_to_addr \
+    > output/sink_load_into_addr_inline_add_imm_to_addr.out
+
+expand \
+    --name aarch64 \
+    --term-name sink_load_into_addr \
+    --chain add_imm_to_addr \
+    --chain add_imm \
+    > output/sink_load_into_addr_inline_add_imm_to_addr_add_imm.out
+
+expand \
+    --name aarch64 \
+    --term-name sink_load_into_addr \
+    --maximal-chaining \
+    > output/sink_load_into_addr_maximal_inlining.out
+
+expand \
+    --name aarch64 \
+    --term-name lower \
+    > output/lower.out
+
+expand \
+    --name aarch64 \
+    --term-name lower \
+    --no-expand-internal-extractors \
+    > output/lower_internal_extractors.out
+
+expand \
+    --name aarch64 \
+    --term-name lower \
+    --no-expand-internal-extractors \
+    --maximal-chaining \
+    --max-rules 1 \
+    > output/lower_internal_extractors_maximal_inline_1.out
+
+expand \
+    --name aarch64 \
+    --term-name lower \
+    --no-expand-internal-extractors \
+    --maximal-chaining \
+    --max-rules 2 \
+    --exclude-chain operand_size \
+    > output/lower_internal_extractors_maximal_inline_2.out
+
+expand \
+    --name aarch64 \
+    --term-name lower \
+    --no-expand-internal-extractors \
+    --maximal-chaining \
+    --max-rules 3 \
+    --exclude-chain operand_size \
+    > output/lower_internal_extractors_maximal_inline_3.out
+
+expand \
+    --name aarch64 \
+    --term-name lower \
+    --no-expand-internal-extractors \
+    --maximal-chaining \
+    --max-rules 3 \
+    --exclude-chain operand_size \
+    --no-prune-infeasible \
+    > output/lower_internal_extractors_no_prune_maximal_inline_3.out
+
+expand \
+    --name aarch64 \
+    --term-name lower \
+    --no-expand-internal-extractors \
+    --maximal-chaining \
+    --max-rules 6 \
+    --exclude-chain operand_size \
+    > output/lower_internal_extractors_maximal_inline_6.out
+
+expand \
+    --name x64 \
+    --term-name lower \
+    --no-expand-internal-extractors \
+    > output/x64_lower_internal_extractors.out
+
+expand \
+    --name x64 \
+    --term-name lower \
+    --no-expand-internal-extractors \
+    --chain to_amode_add \
+    --chain amode_imm_reg_reg_shift \
+    > output/x64_lower_internal_extractors_amode_inlining.out
diff --git a/cranelift/isle/veri/veri/script/explorer.sh b/cranelift/isle/veri/veri/script/explorer.sh
new file mode 100755
index 000000000000..7121aadd7722
--- /dev/null
+++ b/cranelift/isle/veri/veri/script/explorer.sh
@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+
+set -exuo pipefail
+
+export RUST_LOG=info
+
+# Options
+function usage() {
+    echo "Usage: ${0} [-h] [-o <output_dir>]"
+    exit 2
+}
+
+output_dir="${ISLE_EXPLORER_OUTPUT_DIR:-}"
+while getopts "o:h" opt; do
+    case "${opt}" in
+        o) output_dir="${OPTARG}" ;;
+        h) usage ;;
+        *) usage ;;
+    esac
+done
+
+# Setup output.
+if [[ -z "${output_dir}" ]]; then
+    echo "output directory not set"
+    exit 2
+fi
+mkdir -p "${output_dir}"
+
+# Generate explorer.
+for arch in aarch64 x64; do
+    arch_dir="${output_dir:?}/${arch:?}"
+    rm -rf "${arch_dir}"
+    cargo run --bin explorer -- \
+        --codegen-crate-dir ../../../codegen/ \
+        --work-dir /tmp \
+        --name "${arch}" \
+        --output-dir "${arch_dir}"
+done
diff --git a/cranelift/isle/veri/veri/script/generated_isle_files.sh b/cranelift/isle/veri/veri/script/generated_isle_files.sh
new file mode 100755
index 000000000000..ff2962dc4444
--- /dev/null
+++ b/cranelift/isle/veri/veri/script/generated_isle_files.sh
@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+
+set -exuo pipefail
+
+find ../../.. -name '*.isle' | xargs grep -l 'GENERATED BY'
diff --git a/cranelift/isle/veri/veri/script/graph.sh b/cranelift/isle/veri/veri/script/graph.sh
new file mode 100755
index 000000000000..811bf1d6602c
--- /dev/null
+++ b/cranelift/isle/veri/veri/script/graph.sh
@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+
+set -exuo pipefail
+
+# Clean.
+rm -f output/*.{dot,svg}
+
+# Rules.
+arch="aarch64"
+rules=(
+    "iadd_base_case"
+    "iadd_imm12_right"
+    "iadd_imm12_left"
+    "iadd_i128"
+)
+
+for rule in "${rules[@]}"; do
+    name="${arch}_${rule}"
+
+    # Generate dot.
+    dot_path="output/${name}.dot"
+    cargo run --bin graph -- \
+        --codegen-crate-dir ../../../codegen/ \
+        --work-dir /tmp \
+        --name "${arch}" \
+        --rule "${rule}" \
+        | tee "output/${name}.dot"
+
+    # Render.
+    svg_path="output/${name}.svg"
+    dot -Tsvg "${dot_path}" >"${svg_path}"
+done
diff --git a/cranelift/isle/veri/veri/script/install/aslp.sh b/cranelift/isle/veri/veri/script/install/aslp.sh
new file mode 100755
index 000000000000..6d926bc40e49
--- /dev/null
+++ b/cranelift/isle/veri/veri/script/install/aslp.sh
@@ -0,0 +1,75 @@
+#!/usr/bin/env bash
+
+set -euxo pipefail
+
+# Defaults.
+repo="mmcloughlin/aslp"
+version="8ca39c0f1b7f4b588fc840aa1a9fbbc5b9085ad0"
+ocaml_compiler="4.14.2"
+
+# Options
+function usage() {
+    echo "Usage: ${0} -i <install_dir> [-h] [-r <repo>] [-v <version>] [-c <ocaml_compiler>] [-t <tmp_dir>]"
+    exit 2
+}
+
+install_dir=""
+tmp_dir=""
+while getopts "r:v:c:i:t:h" opt; do
+    case "${opt}" in
+        r) repo="${OPTARG}" ;;
+        v) version="${OPTARG}" ;;
+        c) ocaml_compiler="${OPTARG}" ;;
+        i) install_dir="${OPTARG}" ;;
+        t) tmp_dir="${OPTARG}" ;;
+        h) usage ;;
+        *) usage ;;
+    esac
+done
+shift $((OPTIND-1))
+
+# Check install directory.
+if [[ ! -d "${install_dir}" ]]; then
+    echo "install directory does not exist"
+    exit 1
+fi
+
+# Setup temp directory.
+if [[ -z "${tmp_dir}" ]]; then
+    tmp_dir=$(mktemp -d)
+fi
+
+if [[ ! -d "${tmp_dir}" ]]; then
+    echo "temporary directory does not exist"
+    exit 1
+fi
+
+pushd "${tmp_dir}"
+
+# Ensure opam is installed.
+if ! command -v opam &> /dev/null; then
+    echo "opam is not installed"
+    exit 1
+fi
+
+# # Setup opam root.
+export OPAMROOT="${install_dir}/.opam"
+export OPAMYES="true"
+opam init --compiler="${ocaml_compiler}"
+
+eval $(opam env)
+
+# Download and extract ASLp.
+archive_name="${version}.tar.gz"
+archive_url="https://github.com/${repo}/archive/${version}.tar.gz"
+wget --quiet "${archive_url}"
+
+tar xvzf \
+    "${archive_name}" \
+    --strip-components=1
+
+# Install.
+export DUNE_INSTALL_PREFIX="${install_dir}"
+opam install . --deps-only --with-test
+opam exec -- dune build
+opam exec -- dune install
diff --git a/cranelift/isle/veri/veri/script/install/cvc5.sh b/cranelift/isle/veri/veri/script/install/cvc5.sh
new file mode 100755
index 000000000000..74c4009a9c1e
--- /dev/null
+++ b/cranelift/isle/veri/veri/script/install/cvc5.sh
@@ -0,0 +1,68 @@
+#!/usr/bin/env bash
+
+set -euxo pipefail
+
+# Options
+function usage() {
+    echo "Usage: ${0} -i <install_dir> [-h] [-v <version>] [-t <tmp_dir>]"
+    exit 2
+}
+
+version="1.2.0"
+install_dir=""
+tmp_dir=""
+while getopts "v:i:t:h" opt; do
+    case "${opt}" in
+        v) version="${OPTARG}" ;;
+        i) install_dir="${OPTARG}" ;;
+        t) tmp_dir="${OPTARG}" ;;
+        h) usage ;;
+        *) usage ;;
+    esac
+done
+shift $((OPTIND-1))
+
+# Check install directory.
+if [[ ! -d "${install_dir}" ]]; then
+    echo "install directory does not exist"
+    exit 1
+fi
+
+# Setup temp directory.
+if [[ -z "${tmp_dir}" ]]; then
+    tmp_dir=$(mktemp -d)
+fi
+
+if [[ ! -d "${tmp_dir}" ]]; then
+    echo "temporary directory does not exist"
+    exit 1
+fi
+
+pushd "${tmp_dir}"
+
+# Determine which release build.
+platform=$(uname -sm)
+if [[ "${platform}" == "Darwin arm64" ]]; then
+    arch="arm64"
+    os="macOS"
+    mode="shared"
+elif [[ "${platform}" == "Linux x86_64" ]]; then
+    arch="x86_64"
+    os="Linux"
+    mode="static"
+else
+    echo "unsupported platform ${platform}"
+    exit 1
+fi
+
+# Download.
+archive_stem="cvc5-${os}-${arch}-${mode}"
+archive_name="${archive_stem}.zip"
+url="https://github.com/cvc5/cvc5/releases/download/cvc5-${version}/${archive_name}"
+wget --quiet -O "${archive_name}" "${url}"
+
+# Extract.
+unzip "${archive_name}"
+
+# Install.
+cp -r "${archive_stem}"/* "${install_dir}/"
diff --git a/cranelift/isle/veri/veri/script/install/z3.sh b/cranelift/isle/veri/veri/script/install/z3.sh
new file mode 100755
index 000000000000..360131200fd1
--- /dev/null
+++ b/cranelift/isle/veri/veri/script/install/z3.sh
@@ -0,0 +1,66 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+# Options
+function usage() {
+    echo "Usage: ${0} -b <bin_dir> [-h] [-v <version>] [-t <tmp_dir>]"
+    exit 2
+}
+
+version="4.13.0"
+bin_dir=""
+tmp_dir=""
+while getopts "v:b:t:h" opt; do
+    case "${opt}" in
+        v) version="${OPTARG}" ;;
+        b) bin_dir="${OPTARG}" ;;
+        t) tmp_dir="${OPTARG}" ;;
+        h) usage ;;
+        *) usage ;;
+    esac
+done
+shift $((OPTIND-1))
+
+# Check binary install directory.
+if [[ ! -d "${bin_dir}" ]]; then
+    echo "binary install directory does not exist"
+    exit 1
+fi
+
+# Setup temp directory.
+if [[ -z "${tmp_dir}" ]]; then
+    tmp_dir=$(mktemp -d)
+fi
+
+if [[ ! -d "${tmp_dir}" ]]; then
+    echo "temporary directory does not exist"
+    exit 1
+fi
+
+pushd "${tmp_dir}"
+
+# Determine which release build.
+platform=$(uname -sm)
+if [[ "${platform}" == "Darwin arm64" ]]; then
+    arch="arm64"
+    os="osx-11.0"
+elif [[ "${platform}" == "Linux x86_64" ]]; then
+    arch="x64"
+    os="glibc-2.31"
+else
+    echo "unsupported platform ${platform}"
+    exit 1
+fi
+
+# Download.
+archive_stem="z3-${version}-${arch}-${os}"
+archive_name="${archive_stem}.zip"
+url="https://github.com/Z3Prover/z3/releases/download/z3-${version}/${archive_name}"
+wget --quiet -O "${archive_name}" "${url}"
+
+# Extract.
+unzip "${archive_name}"
+
+# Install.
+cp "${archive_stem}/bin/z3" "${bin_dir}"
diff --git a/cranelift/isle/veri/veri/script/reachable.sh b/cranelift/isle/veri/veri/script/reachable.sh
new file mode 100755
index 000000000000..b13b79cc7d78
--- /dev/null
+++ b/cranelift/isle/veri/veri/script/reachable.sh
@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+
+set -exuo pipefail
+
+function reachable() {
+    local arch=$1
+    cargo run --bin reachable -- \
+        --codegen-crate-dir ../../../codegen/ \
+        --work-dir /tmp \
+        --name "${arch}" \
+        > "output/${arch}.reachable"
+}
+
+rm -f output/*.reachable
+
+reachable "aarch64"
+reachable "x64"
diff --git a/cranelift/isle/veri/veri/script/rule_stats.sh b/cranelift/isle/veri/veri/script/rule_stats.sh
new file mode 100755
index 000000000000..04c25f256778
--- /dev/null
+++ b/cranelift/isle/veri/veri/script/rule_stats.sh
@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+
+set -exuo pipefail
+
+function rule_stats() {
+    local arch=$1
+    cargo run --bin rule_stats -- \
+        --codegen-crate-dir ../../../codegen/ \
+        --work-dir /tmp \
+        --name "${arch}" \
+        > "output/${arch}.stats"
+}
+
+rule_stats "aarch64"
+rule_stats "x64"
diff --git a/cranelift/isle/veri/veri/script/serve.sh b/cranelift/isle/veri/veri/script/serve.sh
new file mode 100755
index 000000000000..6fae25f3bfa6
--- /dev/null
+++ b/cranelift/isle/veri/veri/script/serve.sh
@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+
+set -exuo pipefail
+
+# Options
+function usage() {
+    echo "Usage: ${0} [-h] [-o <output_dir>] [-p <port>]"
+    exit 2
+}
+
+output_dir="${ISLE_EXPLORER_OUTPUT_DIR:-}"
+port="5050"
+while getopts "o:p:h" opt; do
+    case "${opt}" in
+        o) output_dir="${OPTARG}" ;;
+        p) port="${OPTARG}" ;;
+        h) usage ;;
+        *) usage ;;
+    esac
+done
+
+if [[ ! -d "${output_dir}" ]]; then
+    echo "output directory does not exist"
+    exit 1
+fi
+
+# Serve.
+miniserve \
+    --port "${port}" \
+    --index index.html \
+    --disable-indexing \
+    --verbose \
+    "${output_dir}"
diff --git a/cranelift/isle/veri/veri/script/spec_lines.sh b/cranelift/isle/veri/veri/script/spec_lines.sh
new file mode 100755
index 000000000000..f87a4b78f85a
--- /dev/null
+++ b/cranelift/isle/veri/veri/script/spec_lines.sh
@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+
+set -exuo pipefail
+
+RUST_LOG=isle_spec_lines=trace cargo run --bin spec_lines -- \
+    --codegen-crate-dir ../../../codegen/ \
+    --work-dir /tmp \
+    --name aarch64 \
+    2>&1 | grep SPEC_LINES
diff --git a/cranelift/isle/veri/veri/script/status.sh b/cranelift/isle/veri/veri/script/status.sh
new file mode 100755
index 000000000000..249c262cb619
--- /dev/null
+++ b/cranelift/isle/veri/veri/script/status.sh
@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+cargo run --bin status -- \
+    --codegen-crate-dir ../../../codegen/ \
+    --work-dir /tmp \
+    "$@"
diff --git a/cranelift/isle/veri/veri/script/trie_dump.sh b/cranelift/isle/veri/veri/script/trie_dump.sh
new file mode 100755
index 000000000000..16feaf42b481
--- /dev/null
+++ b/cranelift/isle/veri/veri/script/trie_dump.sh
@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+
+set -exuo pipefail
+
+function trie_dump() {
+    local arch=$1
+    cargo run --bin trie_dump -- \
+        --codegen-crate-dir ../../../codegen/ \
+        --work-dir /tmp \
+        --name "${arch}" \
+        > "output/${arch}.trie"
+}
+
+trie_dump "aarch64"
+trie_dump "x64"
diff --git a/cranelift/isle/veri/veri/script/veri.sh b/cranelift/isle/veri/veri/script/veri.sh
new file mode 100755
index 000000000000..12eb5436022f
--- /dev/null
+++ b/cranelift/isle/veri/veri/script/veri.sh
@@ -0,0 +1,57 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+# Options
+function usage() {
+    echo "Usage: ${0} [-h] [-a <arch>] [-t <tmp_dir>] [-o <output_dir>] [-p <profile>]"
+    exit 2
+}
+
+arch="aarch64"
+tmp_dir=""
+output_dir="output"
+profile="dev"
+while getopts "a:t:o:p:h" opt; do
+    case "${opt}" in
+        a) arch="${OPTARG}" ;;
+        t) tmp_dir="${OPTARG}" ;;
+        o) output_dir="${OPTARG}" ;;
+        p) profile="${OPTARG}" ;;
+        h) usage ;;
+        *) usage ;;
+    esac
+done
+shift $((OPTIND-1))
+
+# Setup output.
+mkdir -p "${output_dir}"
+
+# Setup temp directory.
+if [[ -z "${tmp_dir}" ]]; then
+    tmp_dir=$(mktemp -d)
+fi
+
+if [[ ! -d "${tmp_dir}" ]]; then
+    echo "temporary directory does not exist"
+    exit 1
+fi
+
+# Standalone file mode
+# Detect --file in arguments and forward directly to cargo run
+if echo "$@" | grep -q -- "--file"; then
+  echo "[veri.sh] Running in file mode with args: $@"
+  # Write results to output/filemode.veri instead of arch-specific logs
+  cargo run --bin veri --profile "${profile}" -- "$@" \
+    | tee "${output_dir}/filemode.veri"
+else
+    # Normal arch-based single-rule mode 
+  echo "[veri.sh] Running in normal mode with arch=${arch}"
+    cargo run --bin veri --profile "${profile}" -- \
+        --codegen-crate-dir ../../../codegen/ \
+        --work-dir "${tmp_dir}" \
+        --name "${arch}" \
+        --log-dir "${output_dir}/log" \
+        "$@" \
+        | tee "${output_dir}/${arch}.veri"
+fi
diff --git a/cranelift/isle/veri/veri/script/verify/ci.sh b/cranelift/isle/veri/veri/script/verify/ci.sh
new file mode 100755
index 000000000000..1dacec1506b0
--- /dev/null
+++ b/cranelift/isle/veri/veri/script/verify/ci.sh
@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+RUST_LOG=info ./script/veri.sh "$@" -- \
+    --num-threads 0 \
+    --results-to-log-dir \
+    --ignore-solver-tags \
+    --filter include:first-rule-named \
+    --filter exclude:tag:vector \
+    --filter exclude:tag:slow \
+    --filter exclude:tag:i128 \
+    --filter exclude:tag:atomics \
+    --filter exclude:tag:narrowfloat \
+    --filter exclude:tag:amode_const \
+    ;
diff --git a/cranelift/isle/veri/veri/script/verify/eval.sh b/cranelift/isle/veri/veri/script/verify/eval.sh
new file mode 100755
index 000000000000..f7503fc67d4b
--- /dev/null
+++ b/cranelift/isle/veri/veri/script/verify/eval.sh
@@ -0,0 +1,103 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+# Options.
+function usage() {
+    echo "Usage: ${0} -n <name> -t <timeout>"
+    exit 2
+}
+
+name="adhoc"
+timeout=60
+mode="full"
+while getopts "n:t:c" opt; do
+    case "${opt}" in
+        n) name="${OPTARG}" ;;
+        t) timeout="${OPTARG}" ;;
+        c) mode="ci" ;;
+        *) usage ;;
+    esac
+done
+
+[[ -n "${name}" ]]
+[[ -n "${EVAL_DATA_DIR}" ]]
+
+# Metadata helpers.
+function json_new() {
+    local file="${1}"
+    echo '{}' >"${file}"
+}
+
+function json_set() {
+    local file="${1}"
+    local key="${2}"
+    local value="${3}"
+    jq '. += $ARGS.named' --arg "${key}" "${value}" "${file}" | sponge "${file}"
+}
+
+# Setup temporary directory.
+tmp_dir=$(mktemp -d)
+
+# Setup results directory.
+timestamp=$(date -u '+%Y-%m-%dT%T')
+output_dir="${EVAL_DATA_DIR}/run/${timestamp}-${name}"
+mkdir -p "${output_dir}"
+
+# Save metadata
+metadata_file="${output_dir}/metadata.json"
+json_new "${metadata_file}"
+json_set "${metadata_file}" "name" "${name}"
+json_set "${metadata_file}" "timestamp" "${timestamp}"
+json_set "${metadata_file}" "timeout" "${timeout}"
+json_set "${metadata_file}" "hostname" "$(hostname)"
+
+z3_version=$(z3 --version)
+json_set "${metadata_file}" "z3_version" "${z3_version}"
+
+cvc5_version=$(cvc5 --version | head -n 1)
+json_set "${metadata_file}" "cvc5_version" "${cvc5_version}"
+
+# System information.
+system_dir="${output_dir}/sys/"
+mkdir -p "${system_dir}"
+lscpu >"${system_dir}/lscpu.out"
+cp /proc/cpuinfo "${system_dir}/cpuinfo"
+
+# Clean build
+cargo clean
+
+# Eval
+extra_args=()
+case "${mode}" in
+    "ci") extra_args+=("--ignore-solver-tags") ;;
+esac
+
+RUST_LOG=info \
+cargo run --bin veri --release -- \
+    --codegen-crate-dir ../../../codegen/ \
+    --work-dir "${tmp_dir}" \
+    --name aarch64 \
+    --log-dir "${output_dir}/log" \
+    --results-to-log-dir \
+    --timeout "${timeout}" \
+    --num-threads 0 \
+    --no-skip-todo \
+    "${extra_args[@]}" \
+    \
+    --filter include:tag:wasm_proposal_mvp \
+    --filter exclude:tag:wasm_category_stack \
+    --filter exclude:not:root:lower \
+    --filter exclude:tag:vector \
+    --filter exclude:tag:atomics \
+    --filter exclude:tag:spectre \
+    --filter exclude:tag:narrowfloat \
+    --filter include:tag:clif_popcnt \
+    --filter exclude:tag:amode_const \
+    --filter exclude:tag:i128 \
+    \
+    --filter include:root:emit_side_effect \
+    --filter include:root:operand_size \
+    --filter include:root:scalar_size \
+    --filter include:root:size_from_ty \
+    ;
diff --git a/cranelift/isle/veri/veri/src/assets/style.css b/cranelift/isle/veri/veri/src/assets/style.css
new file mode 100644
index 000000000000..69e55b7f7825
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/assets/style.css
@@ -0,0 +1,143 @@
+:root {
+    font-size: 15px;
+
+    --invert-font-color: #fff;
+    --primary-color: #00a0ad;
+    --light-color: #bbb;
+}
+
+body {
+    width: 100%;
+    margin: 2em 0;
+    line-height: 1.6;
+    font-family: monospace;
+    font-size: 1rem;
+}
+
+body>header,
+body>main,
+body>footer {
+    width: 100%;
+    margin-right: auto;
+    margin-left: auto;
+    max-width: 950px;
+}
+
+h1,
+h2,
+h3,
+h4,
+h5,
+h6 {
+    font-family: sans-serif;
+    font-weight: 700;
+}
+
+h1 {
+    font-size: 2rem;
+    line-height: 1.125;
+}
+
+h2 {
+    font-size: 1.75rem;
+    line-height: 1.15;
+}
+
+h3 {
+    font-size: 1.5rem;
+    line-height: 1.175;
+}
+
+h4 {
+    font-size: 1.25rem;
+    line-height: 1.2;
+}
+
+h5 {
+    font-size: 1.125rem;
+    line-height: 1.225;
+}
+
+h6 {
+    font-size: 1rem;
+    line-height: 1.25;
+}
+
+a {
+    color: var(--primary-color);
+    text-decoration: underline;
+}
+
+a:hover {
+    background-color: var(--primary-color);
+    color: var(--invert-font-color);
+    text-decoration: none;
+}
+
+menu {
+    margin: 0;
+    padding: 0;
+    border-top: 1px solid var(--light-color);
+}
+
+menu li {
+    list-style-type: none;
+    margin: 0;
+    padding: 0;
+    border-bottom: 1px solid var(--light-color);
+}
+
+menu a {
+    display: block;
+    padding: 1rem;
+}
+
+table {
+    width: 100%;
+    border-collapse: collapse;
+}
+
+td,
+th {
+    padding: .2rem;
+    border-bottom: 1px solid var(--light-color);
+}
+
+th {
+    text-align: left;
+}
+
+table .id {
+    text-align: right;
+    width: 1em;
+    white-space: nowrap;
+}
+
+pre {
+    counter-reset: line;
+}
+
+pre code {
+    counter-increment: line;
+    position: relative;
+}
+
+pre code::before {
+    content: counter(line);
+    user-select: none;
+    color: var(--light-color);
+    display: inline-block;
+    position: absolute;
+    left: -5em;
+    width: 4em;
+    text-align: right;
+}
+
+pre code:target::before {
+    color: var(--primary-color);
+    font-weight: bold;
+}
+
+.id {
+    color: var(--light-color);
+}
diff --git a/cranelift/isle/veri/veri/src/bin/count.rs b/cranelift/isle/veri/veri/src/bin/count.rs
new file mode 100644
index 000000000000..4c8dd6289dce
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/bin/count.rs
@@ -0,0 +1,248 @@
+use std::collections::{BTreeSet, HashMap, HashSet};
+
+use anyhow::{format_err, Result};
+use clap::Parser;
+use cranelift_codegen_meta::{generate_isle, isle::get_isle_compilations};
+use cranelift_isle::{
+    sema::TermId,
+    trie_again::{BindingId, Rule, RuleSet},
+};
+use cranelift_isle_veri::{
+    program::Program,
+    reachability::{self, Reachability},
+};
+
+#[derive(Parser)]
+struct Opts {
+    /// Name of the ISLE compilation.
+    #[arg(long, required = true)]
+    name: String,
+
+    /// Path to codegen crate directory.
+    #[arg(long, required = true)]
+    codegen_crate_dir: std::path::PathBuf,
+
+    /// Working directory.
+    #[arg(long, required = true)]
+    work_dir: std::path::PathBuf,
+
+    /// Whether to disable expansion of internal extractors.
+    #[arg(long)]
+    no_expand_internal_extractors: bool,
+
+    /// Term to count.
+    #[arg(long, required = true)]
+    term_name: String,
+
+    /// Maximum rules: only expand terms with at most this many rules.
+    #[arg(long, default_value = "0")]
+    max_rules: usize,
+
+    /// Terms to exclude from chaining.
+    #[arg(long, value_name = "TERM_NAME")]
+    exclude_chain: Vec<String>,
+}
+
+impl Opts {
+    fn isle_input_files(&self) -> Result<Vec<std::path::PathBuf>> {
+        // Generate ISLE files.
+        let gen_dir = &self.work_dir;
+        generate_isle(gen_dir)?;
+
+        // Lookup ISLE compilations.
+        let compilations = get_isle_compilations(&self.codegen_crate_dir, gen_dir);
+
+        // Return inputs from the matching compilation, if any.
+        Ok(compilations
+            .lookup(&self.name)
+            .ok_or(format_err!("unknown ISLE compilation: {}", self.name))?
+            .paths()?)
+    }
+}
+
+fn main() -> Result<()> {
+    let opts = Opts::parse();
+
+    // Read ISLE inputs.
+    let inputs = opts.isle_input_files()?;
+    let prog = Program::from_files(&inputs, !opts.no_expand_internal_extractors)?;
+
+    // Derive rule sets.
+    let term_rule_sets: HashMap<_, _> = prog.build_trie()?.into_iter().collect();
+
+    // Lookup term to count.
+    let root_term_id = prog
+        .get_term_by_name(opts.term_name.as_str())
+        .ok_or(format_err!("unknown term {}", opts.term_name))?;
+    println!("term = {}", opts.term_name);
+    println!("id = {}", root_term_id.index());
+
+    // Count expansions.
+    let mut expansion_counter = ExpansionCounter::new(&prog, &term_rule_sets);
+    expansion_counter.enable_expansion(root_term_id);
+    if opts.max_rules > 0 {
+        expansion_counter.set_max_rules(opts.max_rules);
+    }
+    for exclude_term_name in &opts.exclude_chain {
+        let exclude_term_id = prog
+            .get_term_by_name(exclude_term_name)
+            .ok_or(format_err!("unknown term {exclude_term_name}"))?;
+        expansion_counter.disable_expansion(exclude_term_id);
+    }
+
+    let n = expansion_counter.term(root_term_id, "");
+    println!("expansions = {n}");
+
+    Ok(())
+}
+
+struct ExpansionCounter<'a> {
+    prog: &'a Program,
+    term_rule_sets: &'a HashMap<TermId, RuleSet>,
+    reach: Reachability,
+
+    enable_expansion: HashSet<TermId>,
+    disable_expansion: HashSet<TermId>,
+    max_rules: usize,
+}
+
+impl<'a> ExpansionCounter<'a> {
+    fn new(prog: &'a Program, term_rule_sets: &'a HashMap<TermId, RuleSet>) -> Self {
+        Self {
+            prog,
+            term_rule_sets,
+            reach: Reachability::build(term_rule_sets),
+
+            enable_expansion: HashSet::new(),
+            disable_expansion: HashSet::new(),
+            max_rules: usize::MAX,
+        }
+    }
+
+    fn term(&mut self, term_id: TermId, indent: &str) -> usize {
+        println!(
+            "{indent}> {term_name}",
+            term_name = self.prog.term_name(term_id)
+        );
+
+        let n = if !self.may_expand(term_id) {
+            1
+        } else {
+            let rule_set = &self.term_rule_sets[&term_id];
+            self.rule_set(rule_set, indent)
+        };
+
+        if n > 1 {
+            println!(
+                "{indent}< {term_name} = {n}",
+                term_name = self.prog.term_name(term_id)
+            );
+        }
+
+        n
+    }
+
+    fn enable_expansion(&mut self, term_id: TermId) {
+        self.enable_expansion.insert(term_id);
+    }
+
+    fn disable_expansion(&mut self, term_id: TermId) {
+        self.disable_expansion.insert(term_id);
+    }
+
+    fn set_max_rules(&mut self, max_rules: usize) {
+        self.max_rules = max_rules;
+    }
+
+    fn may_expand(&mut self, term_id: TermId) -> bool {
+        if !self.term_rule_sets.contains_key(&term_id) {
+            return false;
+        }
+
+        if self.reach.is_cyclic(term_id) {
+            return false;
+        }
+
+        if self.enable_expansion.contains(&term_id) {
+            return true;
+        }
+
+        if self.disable_expansion.contains(&term_id) {
+            return false;
+        }
+
+        let rule_set = &self.term_rule_sets[&term_id];
+        if rule_set.rules.len() > self.max_rules {
+            return false;
+        }
+
+        true
+    }
+
+    fn rule_set(&mut self, rule_set: &RuleSet, indent: &str) -> usize {
+        let mut n = 0;
+        for rule in &rule_set.rules {
+            let r = self.rule(rule_set, rule, indent);
+            n += r;
+            println!(
+                "{indent}n={n} r={r} rule={}",
+                rule.pos.pretty_print_line(&self.prog.files)
+            );
+        }
+        n
+    }
+
+    fn rule(&mut self, rule_set: &RuleSet, rule: &Rule, indent: &str) -> usize {
+        let binding_ids = rule_bindings(rule_set, rule);
+        let mut n = 1;
+        for binding_id in binding_ids {
+            let binding = &rule_set.bindings[binding_id.index()];
+            if let Some(term_id) = reachability::binding_used_term(binding) {
+                n *= self.term(term_id, &format!("{indent}.\t"));
+            }
+        }
+        n
+    }
+}
+
+fn rule_bindings(rule_set: &RuleSet, rule: &Rule) -> BTreeSet<BindingId> {
+    // TODO(mbm): duplicates logic in expand::Application
+
+    // Initialize stack of bindings used directly by the rule.
+    let mut stack = Vec::new();
+
+    // Result binding.
+    stack.push(rule.result);
+
+    // Constraints and equality.
+    for i in 0..rule_set.bindings.len() {
+        let binding_id = i.try_into().unwrap();
+
+        if rule.get_constraint(binding_id).is_some() {
+            stack.push(binding_id);
+        }
+
+        if let Some(equal_binding_id) = rule.equals.find(binding_id) {
+            stack.push(equal_binding_id);
+        }
+    }
+
+    // TODO(mbm): iterators, prio?
+
+    // Impure.
+    stack.extend(&rule.impure);
+
+    // Collect dependencies.
+    let mut binding_ids = BTreeSet::new();
+    while let Some(binding_id) = stack.pop() {
+        if binding_ids.contains(&binding_id) {
+            continue;
+        }
+        binding_ids.insert(binding_id);
+
+        let binding = &rule_set.bindings[binding_id.index()];
+        stack.extend(binding.sources());
+    }
+
+    binding_ids
+}
diff --git a/cranelift/isle/veri/veri/src/bin/expand.rs b/cranelift/isle/veri/veri/src/bin/expand.rs
new file mode 100644
index 000000000000..693c6549afe2
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/bin/expand.rs
@@ -0,0 +1,99 @@
+use std::collections::HashMap;
+
+use anyhow::{format_err, Result};
+use clap::Parser;
+use cranelift_codegen_meta::{generate_isle, isle::get_isle_compilations};
+use cranelift_isle_veri::debug::print_expansion;
+use cranelift_isle_veri::expand::{Chaining, Expander};
+use cranelift_isle_veri::program::Program;
+
+#[derive(Parser)]
+struct Opts {
+    /// Name of the ISLE compilation.
+    #[arg(long, required = true)]
+    name: String,
+
+    /// Path to codegen crate directory.
+    #[arg(long, required = true)]
+    codegen_crate_dir: std::path::PathBuf,
+
+    /// Working directory.
+    #[arg(long, required = true)]
+    work_dir: std::path::PathBuf,
+
+    /// Whether to disable expansion of internal extractors.
+    #[arg(long)]
+    no_expand_internal_extractors: bool,
+
+    /// Term to expand.
+    #[arg(long, required = true)]
+    term_name: String,
+
+    /// Whether to disable pruning of infeasible expansions.
+    #[arg(long)]
+    no_prune_infeasible: bool,
+
+    /// Term names to chain.
+    #[arg(long, value_name = "TERM_NAME")]
+    chain: Vec<String>,
+
+    /// Whether to enable maximal chaining.
+    #[arg(long)]
+    maximal_chaining: bool,
+
+    /// Maximum rules: only chain terms with at most this many rules.
+    #[arg(long, default_value = "0")]
+    max_rules: usize,
+
+    /// Terms to exclude from chaining.
+    #[arg(long, value_name = "TERM_NAME")]
+    exclude_chain: Vec<String>,
+}
+
+impl Opts {
+    fn isle_input_files(&self) -> Result<Vec<std::path::PathBuf>> {
+        // Generate ISLE files.
+        let gen_dir = &self.work_dir;
+        generate_isle(gen_dir)?;
+
+        // Lookup ISLE compilations.
+        let compilations = get_isle_compilations(&self.codegen_crate_dir, gen_dir);
+
+        // Return inputs from the matching compilation, if any.
+        Ok(compilations
+            .lookup(&self.name)
+            .ok_or(format_err!("unknown ISLE compilation: {}", self.name))?
+            .paths()?)
+    }
+}
+
+fn main() -> Result<()> {
+    let opts = Opts::parse();
+
+    // Read ISLE inputs.
+    let inputs = opts.isle_input_files()?;
+    let prog = Program::from_files(&inputs, !opts.no_expand_internal_extractors)?;
+
+    // Configure chaining.
+    let term_rule_sets: HashMap<_, _> = prog.build_trie()?.into_iter().collect();
+    let mut chaining = Chaining::new(&prog, &term_rule_sets)?;
+    chaining.chain_terms(&opts.chain)?;
+    chaining.set_default(opts.maximal_chaining);
+    chaining.set_max_rules(opts.max_rules);
+    chaining.exclude_chain_terms(&opts.exclude_chain)?;
+
+    // Build expansions.
+    let mut expander = Expander::new(&prog, &term_rule_sets, chaining);
+    expander.add_root_term_name(&opts.term_name)?;
+    expander.set_prune_infeasible(!opts.no_prune_infeasible);
+    expander.expand();
+
+    // Report.
+    let expansions = expander.expansions();
+    println!("expansions = {}", expansions.len());
+    for expansion in expansions {
+        print_expansion(&prog, expansion);
+    }
+
+    Ok(())
+}
diff --git a/cranelift/isle/veri/veri/src/bin/explorer.rs b/cranelift/isle/veri/veri/src/bin/explorer.rs
new file mode 100644
index 000000000000..3af4cf725de0
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/bin/explorer.rs
@@ -0,0 +1,88 @@
+use anyhow::{format_err, Result};
+use clap::Parser;
+use cranelift_codegen_meta::{generate_isle, isle::get_isle_compilations};
+use cranelift_isle_veri::{
+    expand::{Chaining, Expander},
+    explorer::ExplorerWriter,
+    program::Program,
+};
+use std::collections::HashMap;
+
+#[derive(Parser)]
+struct Opts {
+    /// Name of the ISLE compilation.
+    #[arg(long, required = true)]
+    name: String,
+
+    /// Path to codegen crate directory.
+    #[arg(long, required = true)]
+    codegen_crate_dir: std::path::PathBuf,
+
+    /// Working directory.
+    #[arg(long, required = true)]
+    work_dir: std::path::PathBuf,
+
+    /// Output directory for explorer files.
+    #[arg(long, required = true)]
+    output_dir: std::path::PathBuf,
+
+    /// Whether to enable graph generation.
+    #[arg(long, env = "ISLE_EXPLORER_GRAPHS")]
+    graphs: bool,
+}
+
+impl Opts {
+    fn isle_input_files(&self) -> Result<Vec<std::path::PathBuf>> {
+        // Generate ISLE files.
+        let gen_dir = &self.work_dir;
+        generate_isle(gen_dir)?;
+
+        // Lookup ISLE compilations.
+        let compilations = get_isle_compilations(&self.codegen_crate_dir, gen_dir);
+
+        // Return inputs from the matching compilation, if any.
+        Ok(compilations
+            .lookup(&self.name)
+            .ok_or(format_err!("unknown ISLE compilation: {}", self.name))?
+            .paths()?)
+    }
+}
+
+fn main() -> Result<()> {
+    let _ = env_logger::try_init();
+    let opts = Opts::parse();
+
+    // Read ISLE inputs.
+    let inputs = opts.isle_input_files()?;
+    let root_term = if opts.name != "opt" {
+        "lower"
+    } else {
+        "simplify"
+    };
+
+    let expand_internal_extractors = false;
+    let prog = Program::from_files(&inputs, expand_internal_extractors)?;
+    let term_rule_sets: HashMap<_, _> = prog.build_trie()?.into_iter().collect();
+
+    // Generate expansions.
+    // TODO(mbm): don't hardcode the expansion configuration
+    let chaining = Chaining::new(&prog, &term_rule_sets)?;
+    let mut expander = Expander::new(&prog, &term_rule_sets, chaining);
+    expander.add_root_term_name(root_term)?;
+    expander.set_prune_infeasible(true);
+    expander.expand();
+
+    // Generate explorer.
+    let mut explorer_writer = ExplorerWriter::new(
+        opts.output_dir,
+        &prog,
+        expander.chaining(),
+        expander.expansions(),
+    );
+    if opts.graphs {
+        explorer_writer.enable_graphs();
+    }
+    explorer_writer.write()?;
+
+    Ok(())
+}
diff --git a/cranelift/isle/veri/veri/src/bin/graph.rs b/cranelift/isle/veri/veri/src/bin/graph.rs
new file mode 100644
index 000000000000..240a42751b20
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/bin/graph.rs
@@ -0,0 +1,115 @@
+use anyhow::{format_err, Result};
+use clap::Parser;
+use cranelift_codegen_meta::{generate_isle, isle::get_isle_compilations};
+use cranelift_isle::trie_again::BindingId;
+use cranelift_isle_veri::{
+    debug::binding_string,
+    expand::{Chaining, Expander, Expansion},
+    program::Program,
+};
+use std::collections::HashMap;
+
+#[derive(Parser)]
+struct Opts {
+    /// Name of the ISLE compilation.
+    #[arg(long, required = true)]
+    name: String,
+
+    /// Path to codegen crate directory.
+    #[arg(long, required = true)]
+    codegen_crate_dir: std::path::PathBuf,
+
+    /// Working directory.
+    #[arg(long, required = true)]
+    work_dir: std::path::PathBuf,
+
+    /// Filter to expansions involving this rule.
+    #[arg(long, required = true)]
+    rule: String,
+}
+
+impl Opts {
+    fn isle_input_files(&self) -> Result<Vec<std::path::PathBuf>> {
+        // Generate ISLE files.
+        let gen_dir = &self.work_dir;
+        generate_isle(gen_dir)?;
+
+        // Lookup ISLE compilations.
+        let compilations = get_isle_compilations(&self.codegen_crate_dir, gen_dir);
+
+        // Return inputs from the matching compilation, if any.
+        Ok(compilations
+            .lookup(&self.name)
+            .ok_or(format_err!("unknown ISLE compilation: {}", self.name))?
+            .paths()?)
+    }
+}
+
+fn main() -> Result<()> {
+    let _ = env_logger::try_init();
+    let opts = Opts::parse();
+
+    // Read ISLE inputs.
+    let inputs = opts.isle_input_files()?;
+    let root_term = if opts.name != "opt" {
+        "lower"
+    } else {
+        "simplify"
+    };
+    let expand_internal_extractors = false;
+    let prog = Program::from_files(&inputs, expand_internal_extractors)?;
+    let term_rule_sets: HashMap<_, _> = prog.build_trie()?.into_iter().collect();
+
+    // Lookup target rule.
+    let rule = prog.get_rule_by_identifier(&opts.rule).ok_or(format_err!(
+        "unknown rule: {rule_name}",
+        rule_name = opts.rule
+    ))?;
+
+    // Generate expansions.
+    // TODO(mbm): don't hardcode the expansion configuration
+    let chaining = Chaining::new(&prog, &term_rule_sets)?;
+    let mut expander = Expander::new(&prog, &term_rule_sets, chaining);
+    expander.add_root_term_name(root_term)?;
+    expander.set_prune_infeasible(true);
+    expander.expand();
+
+    // Process expansions.
+    for expansion in expander.expansions() {
+        if !expansion.rules.contains(&rule.id) {
+            continue;
+        }
+        expansion_graph(expansion, &prog);
+    }
+
+    Ok(())
+}
+
+fn expansion_graph(expansion: &Expansion, prog: &Program) {
+    // Header.
+    println!("graph {{");
+    println!("\tnode [shape=box, fontname=monospace];");
+
+    // Binding nodes.
+    let lookup_binding =
+        |binding_id: BindingId| expansion.bindings[binding_id.index()].clone().unwrap();
+    for (i, binding) in expansion.bindings.iter().enumerate() {
+        if let Some(binding) = binding {
+            println!(
+                "\tb{i} [label=\"{i}: {}\"];",
+                binding_string(binding, expansion.term, prog, lookup_binding)
+            );
+        }
+    }
+
+    // Edges.
+    for (i, binding) in expansion.bindings.iter().enumerate() {
+        if let Some(binding) = binding {
+            for source in binding.sources() {
+                println!("\tb{i} -- b{j};", j = source.index());
+            }
+        }
+    }
+
+    println!("}}");
+}
diff --git a/cranelift/isle/veri/veri/src/bin/reachable.rs b/cranelift/isle/veri/veri/src/bin/reachable.rs
new file mode 100644
index 000000000000..5883fa589eed
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/bin/reachable.rs
@@ -0,0 +1,72 @@
+use std::collections::HashMap;
+
+use anyhow::{format_err, Result};
+use clap::Parser;
+use cranelift_codegen_meta::{generate_isle, isle::get_isle_compilations};
+use cranelift_isle_veri::{program::Program, reachability::Reachability};
+
+#[derive(Parser)]
+struct Opts {
+    /// Name of the ISLE compilation.
+    #[arg(long, required = true)]
+    name: String,
+
+    /// Path to codegen crate directory.
+    #[arg(long, required = true)]
+    codegen_crate_dir: std::path::PathBuf,
+
+    /// Working directory.
+    #[arg(long, required = true)]
+    work_dir: std::path::PathBuf,
+
+    /// Whether to disable expansion of internal extractors.
+    #[arg(long)]
+    no_expand_internal_extractors: bool,
+}
+
+impl Opts {
+    fn isle_input_files(&self) -> Result<Vec<std::path::PathBuf>> {
+        // Generate ISLE files.
+        let gen_dir = &self.work_dir;
+        generate_isle(gen_dir)?;
+
+        // Lookup ISLE compilations.
+        let compilations = get_isle_compilations(&self.codegen_crate_dir, gen_dir);
+
+        // Return inputs from the matching compilation, if any.
+        Ok(compilations
+            .lookup(&self.name)
+            .ok_or(format_err!("unknown ISLE compilation: {}", self.name))?
+            .paths()?)
+    }
+}
+
+fn main() -> Result<()> {
+    let opts = Opts::parse();
+
+    // Read ISLE inputs.
+    let inputs = opts.isle_input_files()?;
+    let prog = Program::from_files(&inputs, !opts.no_expand_internal_extractors)?;
+
+    // Derive rule sets.
+    let term_rule_sets: HashMap<_, _> = prog.build_trie()?.into_iter().collect();
+    println!("#term_rule_sets = {}", term_rule_sets.len());
+
+    // Construct reachability.
+    let reach = Reachability::build(&term_rule_sets);
+
+    for (term_id, rule_set) in &term_rule_sets {
+        let cyclic = reach.is_cyclic(*term_id);
+        let reachable = reach.reachable(*term_id);
+
+        println!("term = {}", prog.term_name(*term_id));
+        println!("\tcyclic = {cyclic}");
+        println!("\t#rules = {}", rule_set.rules.len());
+        println!("\t#reachable = {}", reachable.len());
+        for reach_term_id in reachable {
+            println!("\treachable = {}", prog.term_name(*reach_term_id));
+        }
+    }
+
+    Ok(())
+}
diff --git a/cranelift/isle/veri/veri/src/bin/rule_stats.rs b/cranelift/isle/veri/veri/src/bin/rule_stats.rs
new file mode 100644
index 000000000000..15afe33957b9
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/bin/rule_stats.rs
@@ -0,0 +1,116 @@
+use anyhow::{format_err, Result};
+use clap::Parser;
+use cranelift_codegen_meta::{generate_isle, isle::get_isle_compilations};
+use cranelift_isle::sema::{Pattern, Rule, RuleId, Term};
+use cranelift_isle_veri::program::Program;
+use std::collections::HashMap;
+
+#[derive(Parser)]
+struct Opts {
+    /// Name of the ISLE compilation.
+    #[arg(long, required = true)]
+    name: String,
+
+    /// Path to codegen crate directory.
+    #[arg(long, required = true)]
+    codegen_crate_dir: std::path::PathBuf,
+
+    /// Working directory.
+    #[arg(long, required = true)]
+    work_dir: std::path::PathBuf,
+}
+
+impl Opts {
+    fn isle_input_files(&self) -> Result<Vec<std::path::PathBuf>> {
+        // Generate ISLE files.
+        let gen_dir = &self.work_dir;
+        generate_isle(gen_dir)?;
+
+        // Lookup ISLE compilations.
+        let compilations = get_isle_compilations(&self.codegen_crate_dir, gen_dir);
+
+        // Return inputs from the matching compilation, if any.
+        Ok(compilations
+            .lookup(&self.name)
+            .ok_or(format_err!("unknown ISLE compilation: {}", self.name))?
+            .paths()?)
+    }
+}
+
+fn main() -> Result<()> {
+    let opts = Opts::parse();
+
+    // Read ISLE inputs.
+    let inputs = opts.isle_input_files()?;
+    let expand_internal_extractors = false;
+    let prog = Program::from_files(&inputs, expand_internal_extractors)?;
+
+    // Stats.
+    let rules = prog.rules_by_term();
+    let mut total_num_terms = 0;
+    let mut total_num_rules = 0;
+    let mut term_class_counts: HashMap<String, usize> = HashMap::new();
+    for term in &prog.termenv.terms {
+        let rule_ids = rules.get(&term.id).cloned().unwrap_or_default();
+        let class = classify_term(&prog, term, &rule_ids);
+        *term_class_counts.entry(class.clone()).or_default() += 1;
+
+        total_num_terms += 1;
+        total_num_rules += rule_ids.len();
+
+        println!("{}\t{}\t{}", prog.term_name(term.id), class, rule_ids.len());
+    }
+
+    println!();
+    println!("TOTAL: num_terms = {total_num_terms}",);
+    println!("TOTAL: num_rules = {total_num_rules}");
+    for (class, count) in term_class_counts {
+        println!("TOTAL: class:{class} = {count}");
+    }
+
+    Ok(())
+}
+
+fn classify_term(prog: &Program, term: &Term, rule_ids: &[RuleId]) -> String {
+    if term.is_enum_variant() {
+        return "enum_variant".to_string();
+    }
+
+    if term.has_external_constructor() || term.has_external_extractor() {
+        return "external".to_string();
+    }
+
+    if term.has_extractor() {
+        return "extractor".to_string();
+    }
+
+    assert!(term.has_constructor());
+
+    if rule_ids.len() == 1 && is_macro_rule(prog.rule(rule_ids[0])) {
+        return "macro".to_string();
+    }
+
+    "constructor".to_string()
+}
+
+fn is_macro_rule(rule: &Rule) -> bool {
+    if !rule.iflets.is_empty() {
+        return false;
+    }
+
+    for arg in &rule.args {
+        if !is_any_pattern(arg) {
+            return false;
+        }
+    }
+
+    true
+}
+
+fn is_any_pattern(pattern: &Pattern) -> bool {
+    match pattern {
+        Pattern::BindPattern(_, _, subpat) => is_any_pattern(subpat),
+        Pattern::Wildcard(_) => true,
+        _ => false,
+    }
+}
diff --git a/cranelift/isle/veri/veri/src/bin/spec_lines.rs b/cranelift/isle/veri/veri/src/bin/spec_lines.rs
new file mode 100644
index 000000000000..7f889547b315
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/bin/spec_lines.rs
@@ -0,0 +1,77 @@
+use std::sync::Arc;
+
+use anyhow::{bail, format_err, Result};
+use clap::Parser;
+use cranelift_codegen_meta::{generate_isle, isle::get_isle_compilations};
+use cranelift_isle::{error::Errors, files::Files, lexer, parser};
+
+#[derive(Parser)]
+struct Opts {
+    /// Name of the ISLE compilation.
+    #[arg(long, required = true)]
+    name: String,
+
+    /// Path to codegen crate directory.
+    #[arg(long, required = true)]
+    codegen_crate_dir: std::path::PathBuf,
+
+    /// Working directory.
+    #[arg(long, required = true)]
+    work_dir: std::path::PathBuf,
+}
+
+impl Opts {
+    fn isle_input_files(&self) -> Result<Vec<std::path::PathBuf>> {
+        // Generate ISLE files.
+        let gen_dir = &self.work_dir;
+        generate_isle(gen_dir)?;
+
+        // Lookup ISLE compilations.
+        let compilations = get_isle_compilations(&self.codegen_crate_dir, gen_dir);
+
+        // Return inputs from the matching compilation, if any.
+        Ok(compilations
+            .lookup(&self.name)
+            .ok_or(format_err!("unknown ISLE compilation: {}", self.name))?
+            .paths()?)
+    }
+}
+
+fn main() -> Result<()> {
+    env_logger::builder()
+        .format_level(false)
+        .format_timestamp(None)
+        .format_target(false)
+        .init();
+    let opts = Opts::parse();
+
+    // Read ISLE inputs.
+    let inputs = opts.isle_input_files()?;
+
+    let files = match Files::from_paths(inputs) {
+        Ok(files) => files,
+        Err((path, err)) => {
+            bail!(Errors::from_io(
+                err,
+                format!("cannot read file {}", path.display()),
+            ))
+        }
+    };
+
+    let files = Arc::new(files);
+
+    let mut defs = Vec::new();
+    for (file, src) in files.file_texts.iter().enumerate() {
+        let lexer = match lexer::Lexer::new(file, src) {
+            Ok(lexer) => lexer,
+            Err(err) => bail!(Errors::new(vec![err], files)),
+        };
+
+        match parser::parse(lexer, files.clone()) {
+            Ok(mut ds) => defs.append(&mut ds),
+            Err(err) => bail!(Errors::new(vec![err], files)),
+        }
+    }
+
+    Ok(())
+}
diff --git a/cranelift/isle/veri/veri/src/bin/status.rs b/cranelift/isle/veri/veri/src/bin/status.rs
new file mode 100644
index 000000000000..dc174958d22b
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/bin/status.rs
@@ -0,0 +1,181 @@
+use std::collections::{HashMap, HashSet};
+
+use anyhow::{format_err, Result};
+use clap::Parser;
+use cranelift_codegen_meta::{generate_isle, isle::get_isle_compilations};
+use cranelift_isle::sema::TermId;
+use cranelift_isle_veri::expand::{Chaining, Expander, Expansion};
+use cranelift_isle_veri::program::Program;
+
+#[derive(Parser)]
+struct Opts {
+    /// Name of the ISLE compilation.
+    #[arg(long, required = true)]
+    name: String,
+
+    /// Path to codegen crate directory.
+    #[arg(long, required = true)]
+    codegen_crate_dir: std::path::PathBuf,
+
+    /// Working directory.
+    #[arg(long, required = true)]
+    work_dir: std::path::PathBuf,
+
+    /// Tag defining in-scope expansions.
+    #[arg(long = "include-tag", value_name = "TAG")]
+    include_tag: String,
+
+    /// Skip expansions containing terms with this tag.
+    #[arg(long = "skip-tag", value_name = "TAG")]
+    skip_tags: Vec<String>,
+}
+
+impl Opts {
+    fn isle_input_files(&self) -> Result<Vec<std::path::PathBuf>> {
+        // Generate ISLE files.
+        let gen_dir = &self.work_dir;
+        generate_isle(gen_dir)?;
+
+        // Lookup ISLE compilations.
+        let compilations = get_isle_compilations(&self.codegen_crate_dir, gen_dir);
+
+        // Return inputs from the matching compilation, if any.
+        Ok(compilations
+            .lookup(&self.name)
+            .ok_or(format_err!("unknown ISLE compilation: {}", self.name))?
+            .paths()?)
+    }
+}
+
+fn main() -> Result<()> {
+    let opts = Opts::parse();
+
+    // Read ISLE inputs.
+    let inputs = opts.isle_input_files()?;
+    let root_term = if opts.name != "opt" {
+        "lower"
+    } else {
+        "simplify"
+    };
+    let expand_internal_extractors = false;
+    let prog = Program::from_files(&inputs, expand_internal_extractors)?;
+    let term_rule_sets: HashMap<_, _> = prog.build_trie()?.into_iter().collect();
+
+    // Generate expansions.
+    let chaining = Chaining::new(&prog, &term_rule_sets)?;
+    let mut expander = Expander::new(&prog, &term_rule_sets, chaining);
+    expander.add_root_term_name(root_term)?;
+    expander.set_prune_infeasible(true);
+    expander.expand();
+
+    // Show status.
+    status(
+        expander.expansions(),
+        opts.include_tag,
+        &opts.skip_tags,
+        &prog,
+    );
+
+    Ok(())
+}
+
+fn status(expansions: &Vec<Expansion>, include_tag: String, skip_tags: &[String], prog: &Program) {
+    // Report config
+    println!("CONFIG");
+    println!("include_tag\t{include_tag}");
+    println!("skip_tags\t{skip_tags}", skip_tags = skip_tags.join(","));
+    println!();
+
+    // Collect status
+    let mut total = 0usize;
+    let mut num_out_of_scope = 0usize;
+    let mut num_specified = 0usize;
+    let mut term_unspecified_counts: HashMap<TermId, isize> = HashMap::new();
+    let mut internal_constructors = HashSet::new();
+    for expansion in expansions {
+        total += 1;
+
+        if !expansion_in_scope(expansion, &include_tag, skip_tags, prog) {
+            num_out_of_scope += 1;
+            continue;
+        }
+
+        let unspecified = unspecified_terms(expansion, prog);
+        if unspecified.is_empty() {
+            num_specified += 1;
+        }
+        for term_id in unspecified {
+            *term_unspecified_counts.entry(term_id).or_default() += 1;
+        }
+
+        internal_constructors.extend(expansion_internal_constructors(expansion, prog));
+    }
+
+    // Summary
+    println!("SUMMARY");
+
+    let num_in_scope = total - num_out_of_scope;
+    let coverage = (num_specified as f64 / num_in_scope as f64) * 100.0;
+
+    println!("total\t{total}");
+    println!("out_of_scope\t{num_out_of_scope}");
+    println!("in_scope\t{num_in_scope}");
+    println!("specified\t{num_specified}");
+    println!("coverage\t{coverage:.2}");
+    println!();
+
+    // Unspecified terms
+    println!("UNSPECIFIED");
+
+    let mut term_unspecified_counts: Vec<_> = term_unspecified_counts.into_iter().collect();
+    term_unspecified_counts.sort_by_key(|(_, count)| -*count);
+    for (term_id, count) in term_unspecified_counts {
+        println!("{term}\t{count}", term = prog.term_name(term_id));
+    }
+
+    // Internal constructors
+    println!();
+    println!("INTERNAL CONSTRUCTORS");
+    for term_id in internal_constructors {
+        println!("{term}", term = prog.term_name(term_id));
+    }
+}
+
+fn expansion_in_scope(
+    expansion: &Expansion,
+    include_tag: &String,
+    skip_tags: &[String],
+    prog: &Program,
+) -> bool {
+    let tags = expansion.tags(prog);
+    if !tags.contains(include_tag) {
+        return false;
+    }
+    for tag in skip_tags {
+        if tags.contains(tag) {
+            return false;
+        }
+    }
+    true
+}
+
+fn unspecified_terms(expansion: &Expansion, prog: &Program) -> Vec<TermId> {
+    expansion
+        .terms(prog)
+        .iter()
+        .copied()
+        .filter(|term_id| !prog.specenv.has_spec(*term_id))
+        .collect()
+}
+
+fn expansion_internal_constructors(expansion: &Expansion, prog: &Program) -> Vec<TermId> {
+    expansion
+        .terms(prog)
+        .iter()
+        .copied()
+        .filter(|term_id| {
+            let term = prog.term(*term_id);
+            term.has_internal_constructor()
+        })
+        .collect()
+}
diff --git a/cranelift/isle/veri/veri/src/bin/trie_dump.rs b/cranelift/isle/veri/veri/src/bin/trie_dump.rs
new file mode 100644
index 000000000000..95fcfb675b2d
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/bin/trie_dump.rs
@@ -0,0 +1,56 @@
+use anyhow::{format_err, Result};
+use clap::Parser;
+use cranelift_codegen_meta::{generate_isle, isle::get_isle_compilations};
+use cranelift_isle_veri::{debug::print_rule_set, program::Program};
+
+#[derive(Parser)]
+struct Opts {
+    /// Name of the ISLE compilation.
+    #[arg(long, required = true)]
+    name: String,
+
+    /// Path to codegen crate directory.
+    #[arg(long, required = true)]
+    codegen_crate_dir: std::path::PathBuf,
+
+    /// Working directory.
+    #[arg(long, required = true)]
+    work_dir: std::path::PathBuf,
+
+    /// Whether to disable expansion of internal extractors.
+    #[arg(long)]
+    no_expand_internal_extractors: bool,
+}
+
+impl Opts {
+    fn isle_input_files(&self) -> Result<Vec<std::path::PathBuf>> {
+        // Generate ISLE files.
+        let gen_dir = &self.work_dir;
+        generate_isle(gen_dir)?;
+
+        // Lookup ISLE compilations.
+        let compilations = get_isle_compilations(&self.codegen_crate_dir, gen_dir);
+
+        // Return inputs from the matching compilation, if any.
+        Ok(compilations
+            .lookup(&self.name)
+            .ok_or(format_err!("unknown ISLE compilation: {}", self.name))?
+            .paths()?)
+    }
+}
+
+fn main() -> Result<()> {
+    let opts = Opts::parse();
+
+    // Read ISLE inputs.
+    let inputs = opts.isle_input_files()?;
+    let prog = Program::from_files(&inputs, !opts.no_expand_internal_extractors)?;
+
+    // Dump rule sets.
+    let term_rule_sets = prog.build_trie()?;
+    for (term_id, rule_set) in &term_rule_sets {
+        print_rule_set(&prog, term_id, rule_set);
+    }
+
+    Ok(())
+}
diff --git a/cranelift/isle/veri/veri/src/bin/veri.rs b/cranelift/isle/veri/veri/src/bin/veri.rs
new file mode 100644
index 000000000000..1932d2790914
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/bin/veri.rs
@@ -0,0 +1,181 @@
+use std::time::Duration;
+
+use anyhow::{format_err, Result};
+use clap::{ArgAction, Parser};
+use cranelift_codegen_meta::{generate_isle, isle::get_isle_compilations};
+use cranelift_isle_veri::runner::{Filter, Runner, SolverBackend, SolverRule};
+
+#[derive(Parser)]
+struct Opts {
+    /// Name of the ISLE compilation.
+    #[arg(long, required = true)]
+    name: Option<String>,
+
+    /// Path to codegen crate directory.
+    #[arg(long, required = true)]
+    codegen_crate_dir: Option<std::path::PathBuf>,
+
+    /// Working directory.
+    #[arg(long, required = true)]
+    work_dir: Option<std::path::PathBuf>,
+
+    // run verifier on a standalone ISLE file
+    #[arg(long, conflicts_with_all = ["name", "codegen_crate_dir", "work_dir"])]
+    file: Option<std::path::PathBuf>,
+
+    /// Filter expansions.
+    #[arg(long = "filter", value_name = "FILTER")]
+    filters: Vec<Filter>,
+
+    /// Don't skip expansions tagged TODO.
+    #[arg(long = "no-skip-todo", action = ArgAction::SetFalse)]
+    skip_todo: bool,
+
+    /// Solver backend to use.
+    #[arg(long = "solver", default_value = "cvc5", env = "ISLE_VERI_SOLVER")]
+    solver_backend: SolverBackend,
+
+    /// Solver selection rule of the form `<solver>=<predicate>`. Earlier rules take precedence.
+    #[arg(long = "solver-rule")]
+    solver_rules: Vec<SolverRule>,
+
+    /// Ignore explicit solver selection tags `solver_<solver>`.
+    #[arg(long)]
+    ignore_solver_tags: bool,
+
+    /// Per-query timeout, in seconds.
+    #[arg(long, default_value = "30", env = "ISLE_VERI_TIMEOUT")]
+    timeout: u64,
+
+    /// Number of threads to use.
+    #[arg(long, default_value = "1")]
+    num_threads: usize,
+
+    /// Log directory.
+    #[arg(long)]
+    log_dir: Option<std::path::PathBuf>,
+
+    /// Write results to files under log directory. (Use 0 to select automatically.)
+    #[arg(long)]
+    results_to_log_dir: bool,
+
+    /// Skip solver.
+    #[arg(long, env = "ISLE_VERI_SKIP_SOLVER")]
+    skip_solver: bool,
+
+    /// Dump debug output.
+    #[arg(long)]
+    debug: bool,
+}
+
+impl Opts {
+    fn isle_input_files(&self) -> Result<Vec<std::path::PathBuf>> {
+        let name = self.name.as_ref().expect("missing ISLE compilation name");
+
+        let codegen_dir = self
+            .codegen_crate_dir
+            .as_ref()
+            .expect("missing codegen crate directory");
+
+        let work_dir = self.work_dir.as_ref().expect("missing working directory");
+
+        // Generate ISLE files into work_dir
+        // let gen_dir = &self.work_dir;
+        generate_isle(work_dir)?;
+
+        // Lookup ISLE compilations.
+        let compilations = get_isle_compilations(codegen_dir, work_dir);
+
+        // Return inputs from the matching compilation, if any.
+        Ok(compilations
+            .lookup(name)
+            .ok_or_else(|| format_err!("unknown ISLE compilation: {}", name))?
+            .paths()?)
+    }
+}
+
+fn main() -> Result<()> {
+    env_logger::builder().format_target(false).init();
+    let opts = Opts::parse();
+    // Setup thread pool.
+    rayon::ThreadPoolBuilder::new()
+        .num_threads(opts.num_threads)
+        .build_global()?;
+    log::info!("num theads: {}", rayon::current_num_threads());
+
+    // standalone file mode
+    if let Some(file) = opts.file {
+        println!("Running standalone mode on {:?}", file);
+        let inputs = vec![file];
+        let mut runner = Runner::from_files(&inputs, "test")?;
+        runner.include_first_rule_named();
+
+        // Configure runner
+        if !opts.filters.is_empty() {
+            runner.filters(&opts.filters);
+        } else {
+            runner.include_first_rule_named();
+        }
+        if opts.skip_todo {
+            runner.skip_tag("TODO");
+        }
+
+        runner.set_default_solver_backend(opts.solver_backend.into());
+        if !opts.ignore_solver_tags {
+            runner.add_solver_tag_rules();
+        }
+        for solver_rule in opts.solver_rules {
+            runner.add_solver_rule(solver_rule);
+        }
+
+        runner.set_timeout(Duration::from_secs(opts.timeout));
+        if let Some(log_dir) = opts.log_dir {
+            runner.set_log_dir(log_dir);
+        }
+        runner.set_results_to_log_dir(opts.results_to_log_dir);
+        runner.skip_solver(opts.skip_solver);
+        runner.debug(opts.debug);
+
+        return runner.run();
+    }
+
+    // Normal mode -- not standalone file mode
+    // Read ISLE inputs.
+    let inputs = opts.isle_input_files()?;
+    // unwrap before comparing
+    let root_term = if opts.name.as_deref() != Some("opt") {
+        "lower"
+    } else {
+        "simplify"
+    };
+    let mut runner = Runner::from_files(&inputs, root_term)?;
+
+    // Configure runner.
+    if !opts.filters.is_empty() {
+        runner.filters(&opts.filters);
+    } else {
+        runner.include_first_rule_named();
+    }
+    if opts.skip_todo {
+        runner.skip_tag("TODO");
+    }
+
+    runner.set_default_solver_backend(opts.solver_backend.into());
+    if !opts.ignore_solver_tags {
+        runner.add_solver_tag_rules();
+    }
+    for solver_rule in opts.solver_rules {
+        runner.add_solver_rule(solver_rule);
+    }
+
+    runner.set_timeout(Duration::from_secs(opts.timeout));
+    if let Some(log_dir) = opts.log_dir {
+        runner.set_log_dir(log_dir);
+    }
+    runner.set_results_to_log_dir(opts.results_to_log_dir);
+    runner.skip_solver(opts.skip_solver);
+    runner.debug(opts.debug);
+
+    // Run.
+    runner.run()
+}
diff --git a/cranelift/isle/veri/veri/src/debug.rs b/cranelift/isle/veri/veri/src/debug.rs
new file mode 100644
index 000000000000..87a2c5ddc191
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/debug.rs
@@ -0,0 +1,283 @@
+use crate::{
+    expand::{Constrain, Expansion},
+    program::Program,
+    trie::{binding_type, BindingType},
+};
+use cranelift_isle::{
+    sema::{TermId, Type, TypeEnv},
+    trie_again::{Binding, BindingId, Constraint, RuleSet},
+};
+
+pub fn print_expansion(prog: &Program, expansion: &Expansion) {
+    println!("expansion {{");
+
+    // Term.
+    println!("\tterm = {}", prog.term_name(expansion.term));
+
+    // Rules.
+    println!("\trules = [");
+    for rule_id in &expansion.rules {
+        let rule = &prog.termenv.rules[rule_id.index()];
+        println!("\t\t{}", rule.identifier(&prog.tyenv, &prog.files));
+    }
+    println!("\t]");
+
+    // Negated rules.
+    println!("\tnegated = [");
+    for rule_id in &expansion.negated {
+        let rule = &prog.termenv.rules[rule_id.index()];
+        println!("\t\t{}", rule.identifier(&prog.tyenv, &prog.files));
+    }
+    println!("\t]");
+
+    // Bindings.
+    let lookup_binding =
+        |binding_id: BindingId| expansion.bindings[binding_id.index()].clone().unwrap();
+    println!("\tbindings = [");
+    for (i, binding) in expansion.bindings.iter().enumerate() {
+        if let Some(binding) = binding {
+            let ty = binding_type(binding, expansion.term, prog, lookup_binding);
+            println!(
+                "\t\t{i}: {}\t{}",
+                ty.display(&prog.tyenv),
+                binding_string(binding, expansion.term, prog, lookup_binding),
+            );
+        }
+    }
+    println!("\t]");
+
+    // Constraints.
+    println!("\tconstraints = [");
+    for constrain in &expansion.constraints {
+        println!("\t\t{}", constrain_string(constrain, &prog.tyenv));
+    }
+    println!("\t]");
+
+    // Equals.
+    if !expansion.equals.is_empty() {
+        println!("\tequals = [");
+        for (left, right) in expansion.equalities() {
+            println!("\t\t{} == {}", left.index(), right.index());
+        }
+        println!("\t]");
+    }
+
+    // Parameters.
+    println!("\tparameters = [");
+    for binding_id in &expansion.parameters {
+        println!("\t\t{}", binding_id.index());
+    }
+    println!("\t]");
+
+    // Result.
+    println!("\tresult = {}", expansion.result.index());
+
+    // Feasibility.
+    println!("\tfeasible = {}", expansion.is_feasible());
+
+    println!("}}");
+}
+
+pub fn print_rule_set(prog: &Program, term_id: &TermId, rule_set: &RuleSet) {
+    println!("term {{");
+    println!("\tname = {}", prog.term_name(*term_id));
+
+    // Bindings.
+    let lookup_binding = |binding_id: BindingId| rule_set.bindings[binding_id.index()].clone();
+    println!("\tbindings = [");
+    for (i, binding) in rule_set.bindings.iter().enumerate() {
+        let ty = binding_type(binding, *term_id, prog, lookup_binding);
+        println!(
+            "\t\t{i}: {}\t{}",
+            ty.display(&prog.tyenv),
+            binding_string(binding, *term_id, prog, lookup_binding),
+        );
+    }
+    println!("\t]");
+
+    // Rules.
+    println!("\trules = [");
+    for rule in &rule_set.rules {
+        assert_eq!(rule.iterators.len(), 0);
+        println!("\t\t{{");
+        println!("\t\t\tpos = {}", rule.pos.pretty_print_line(&prog.files));
+        println!("\t\t\tconstraints = [");
+        for i in 0..rule_set.bindings.len() {
+            if let Some(constraint) = rule.get_constraint(i.try_into().unwrap()) {
+                println!(
+                    "\t\t\t\t{}:\t{}",
+                    i,
+                    constraint_string(&constraint, &prog.tyenv)
+                );
+            }
+        }
+        println!("\t\t\t]");
+        if !rule.equals.is_empty() {
+            println!("\t\t\tequals = [");
+            for i in 0..rule_set.bindings.len() {
+                let binding_id = i.try_into().unwrap();
+                if let Some(eq) = rule.equals.find(binding_id) {
+                    if eq != binding_id {
+                        println!("\t\t\t\t{} == {}", binding_id.index(), eq.index());
+                    }
+                }
+            }
+            println!("\t\t\t]");
+        }
+        println!("\t\t\tprio = {}", rule.prio);
+        println!("\t\t\tresult = {}", rule.result.index());
+        if !rule.impure.is_empty() {
+            println!(
+                "\t\t\timpure = {impure:?}",
+                impure = rule
+                    .impure
+                    .iter()
+                    .copied()
+                    .map(BindingId::index)
+                    .collect::<Vec<_>>()
+            );
+        }
+        println!("\t\t}}");
+    }
+    println!("\t]");
+
+    println!("}}");
+}
+
+pub fn binding_string(
+    binding: &Binding,
+    term_id: TermId,
+    prog: &Program,
+    lookup_binding: impl Fn(BindingId) -> Binding,
+) -> String {
+    match binding {
+        Binding::Argument { index } => format!("argument({})", index.index()),
+        Binding::ConstInt { val, ty } => {
+            let ty = &prog.tyenv.types[ty.index()];
+            format!("const_int({val}, {name})", name = ty.name(&prog.tyenv))
+        }
+        Binding::ConstPrim { val } => format!("const_prim({})", prog.tyenv.syms[val.index()]),
+        Binding::Constructor {
+            term,
+            parameters,
+            instance,
+        } => {
+            let name = prog.term_name(*term);
+            format!(
+                "constructor({name}, {parameters:?}, {instance})",
+                parameters = parameters
+                    .iter()
+                    .copied()
+                    .map(BindingId::index)
+                    .collect::<Vec<_>>()
+            )
+        }
+        Binding::Extractor { term, parameter } => {
+            let name = prog.term_name(*term);
+            format!(
+                "extractor({name}, {parameter})",
+                parameter = parameter.index()
+            )
+        }
+        Binding::MatchVariant {
+            source,
+            variant,
+            field,
+        } => {
+            let source_binding = lookup_binding(*source);
+            let source_type = binding_type(&source_binding, term_id, prog, lookup_binding);
+            let BindingType::Base(source_type_id) = source_type else {
+                unreachable!("source of match variant should be a base type")
+            };
+
+            // Lookup variant.
+            let enum_ty = &prog.tyenv.types[source_type_id.index()];
+            let enum_name = enum_ty.name(&prog.tyenv);
+            let variant = match enum_ty {
+                Type::Enum { variants, .. } => &variants[variant.index()],
+                _ => unreachable!("source match variant should be an enum"),
+            };
+            let variant_name = &prog.tyenv.syms[variant.name.index()];
+
+            // Field.
+            let field = &variant.fields[field.index()];
+            let field_name = &prog.tyenv.syms[field.name.index()];
+
+            format!(
+                "match_variant({source}, {enum_name}::{variant_name}, {field_name})",
+                source = source.index(),
+            )
+        }
+        Binding::MakeVariant {
+            ty,
+            variant,
+            fields,
+        } => {
+            let ty = &prog.tyenv.types[ty.index()];
+            let Type::Enum { variants, .. } = ty else {
+                unreachable!("source match variant should be an enum")
+            };
+            let variant = &variants[variant.index()];
+            let variant_name = &prog.tyenv.syms[variant.name.index()];
+            format!(
+                "make_variant({ty}::{variant_name}, {fields:?})",
+                ty = ty.name(&prog.tyenv),
+                fields = fields
+                    .iter()
+                    .copied()
+                    .map(BindingId::index)
+                    .collect::<Vec<_>>()
+            )
+        }
+        Binding::MakeSome { inner } => format!("some({inner})", inner = inner.index()),
+        Binding::MatchSome { source } => format!("match_some({source})", source = source.index()),
+        Binding::MatchTuple { source, field } => format!(
+            "match_tuple({source}, {field})",
+            source = source.index(),
+            field = field.index()
+        ),
+        Binding::Iterator { .. } => unimplemented!("iterator bindings unsupported"),
+    }
+}
+
+pub fn constrain_string(constrain: &Constrain, tyenv: &TypeEnv) -> String {
+    match constrain {
+        Constrain::Match(binding_id, constraint) => format!(
+            "{}: {}",
+            binding_id.index(),
+            constraint_string(constraint, tyenv)
+        ),
+        Constrain::NotAll(constraints) => {
+            format!(
+                "not_all({constraints})",
+                constraints = constraints
+                    .iter()
+                    .map(|c| constrain_string(c, tyenv))
+                    .collect::<Vec<_>>()
+                    .join(", "),
+            )
+        }
+    }
+}
+
+pub fn constraint_string(constraint: &Constraint, tyenv: &TypeEnv) -> String {
+    match constraint {
+        Constraint::Variant { ty, variant, .. } => {
+            let ty = &tyenv.types[ty.index()];
+            match ty {
+                Type::Primitive(_, sym, _) => {
+                    format!("variant({})", tyenv.syms[sym.index()].clone())
+                }
+                Type::Enum { name, variants, .. } => {
+                    let name = &tyenv.syms[name.index()];
+                    let variant = &variants[variant.index()];
+                    let variant_name = &tyenv.syms[variant.name.index()];
+                    format!("variant({name}::{variant_name})")
+                }
+            }
+        }
+        Constraint::ConstInt { val, .. } => format!("const_int({val})"),
+        Constraint::ConstPrim { val } => format!("const_prim({})", tyenv.syms[val.index()]),
+        Constraint::Some => "some".to_string(),
+    }
+}
diff --git a/cranelift/isle/veri/veri/src/encoded/cls.rs b/cranelift/isle/veri/veri/src/encoded/cls.rs
new file mode 100644
index 000000000000..5dd89e6e81e0
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/encoded/cls.rs
@@ -0,0 +1,2384 @@
+// Adapted from https://stackoverflow.com/questions/23856596/how-to-count-leading-zeros-in-a-32-bit-unsigned-integer
+use easy_smt::*;
+
+fn declare(smt: &mut Context, name: String, val: SExpr) -> SExpr {
+    smt.declare_const(name.clone(), val).unwrap();
+    smt.atom(name)
+}
+
+pub fn cls64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
+    // Generated code.
+    // total zeros counter
+    let zret0 = declare(
+        smt,
+        format!("zret0_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.eq(
+        zret0,
+        smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+    ));
+    // round 1
+    let zret1 = declare(
+        smt,
+        format!("zret1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let zy32 = declare(
+        smt,
+        format!("zy32_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let zx32 = declare(
+        smt,
+        format!("zx32_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.eq(zy32, smt.bvlshr(x, smt.atom("#x0000000000000020"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy32,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+            ),
+        ]),
+        smt.eq(zret1, zret0),
+        smt.eq(
+            zret1,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                zret0,
+                smt.list(vec![smt.atoms().und, smt.atom("bv32"), smt.numeral(64)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy32,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+            ),
+        ]),
+        smt.eq(zx32, zy32),
+        smt.eq(zx32, x),
+    ]));
+    // round 2
+    let zret2 = declare(
+        smt,
+        format!("zret2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let zy16 = declare(
+        smt,
+        format!("zy16_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let zx16 = declare(
+        smt,
+        format!("zx16_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.eq(zy16, smt.bvlshr(zx32, smt.atom("#x0000000000000010"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy16,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+            ),
+        ]),
+        smt.eq(zret2, zret1),
+        smt.eq(
+            zret2,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                zret1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv16"), smt.numeral(64)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy16,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+            ),
+        ]),
+        smt.eq(zx16, zy16),
+        smt.eq(zx16, zx32),
+    ]));
+    // round 3
+    let zret3 = declare(
+        smt,
+        format!("zret3_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let zy8 = declare(
+        smt,
+        format!("zy8_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let zx8 = declare(
+        smt,
+        format!("zx8_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.eq(zy8, smt.bvlshr(zx16, smt.atom("#x0000000000000008"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy8,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+            ),
+        ]),
+        smt.eq(zret3, zret2),
+        smt.eq(
+            zret3,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                zret2,
+                smt.list(vec![smt.atoms().und, smt.atom("bv8"), smt.numeral(64)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy8,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+            ),
+        ]),
+        smt.eq(zx8, zy8),
+        smt.eq(zx8, zx16),
+    ]));
+    // round 4
+    let zret4 = declare(
+        smt,
+        format!("zret4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let zy4 = declare(
+        smt,
+        format!("zy4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let zx4 = declare(
+        smt,
+        format!("zx4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.eq(zy4, smt.bvlshr(zx8, smt.atom("#x0000000000000004"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+            ),
+        ]),
+        smt.eq(zret4, zret3),
+        smt.eq(
+            zret4,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                zret3,
+                smt.list(vec![smt.atoms().und, smt.atom("bv4"), smt.numeral(64)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+            ),
+        ]),
+        smt.eq(zx4, zy4),
+        smt.eq(zx4, zx8),
+    ]));
+    // round 5
+    let zret5 = declare(
+        smt,
+        format!("zret5_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let zy2 = declare(
+        smt,
+        format!("zy2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let zx2 = declare(
+        smt,
+        format!("zx2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.eq(zy2, smt.bvlshr(zx4, smt.atom("#x0000000000000002"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy2,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+            ),
+        ]),
+        smt.eq(zret5, zret4),
+        smt.eq(
+            zret5,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                zret4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv2"), smt.numeral(64)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy2,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+            ),
+        ]),
+        smt.eq(zx2, zy2),
+        smt.eq(zx2, zx4),
+    ]));
+    // round 6
+    let zret6 = declare(
+        smt,
+        format!("zret6_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let zy1 = declare(
+        smt,
+        format!("zy1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let zx1 = declare(
+        smt,
+        format!("zx1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.eq(zy1, smt.bvlshr(zx2, smt.atom("#x0000000000000001"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+            ),
+        ]),
+        smt.eq(zret6, zret5),
+        smt.eq(
+            zret6,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                zret5,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(64)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+            ),
+        ]),
+        smt.eq(zx1, zy1),
+        smt.eq(zx1, zx2),
+    ]));
+    // last round
+    let zret7 = declare(
+        smt,
+        format!("zret7_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zx1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+            ),
+        ]),
+        smt.eq(zret7, zret6),
+        smt.eq(
+            zret7,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                zret6,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(64)]),
+            ]),
+        ),
+    ]));
+    let clzret = declare(
+        smt,
+        format!("clzret_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.eq(
+            zret7,
+            smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+        ),
+        smt.eq(clzret, zret7),
+        smt.eq(
+            clzret,
+            smt.list(vec![
+                smt.atom("bvsub"),
+                zret7,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(64)]),
+            ]),
+        ),
+    ]));
+    // total zeros counter
+    let sret0 = declare(
+        smt,
+        format!("sret0_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.eq(
+        sret0,
+        smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+    ));
+    // round 1
+    let sret1 = declare(
+        smt,
+        format!("sret1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let sy32 = declare(
+        smt,
+        format!("sy32_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let sx32 = declare(
+        smt,
+        format!("sx32_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.eq(sy32, smt.bvashr(x, smt.atom("#x0000000000000020"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy32,
+                smt.list(vec![
+                    smt.atoms().und,
+                    smt.atom("bv18446744073709551615"),
+                    smt.numeral(64),
+                ]),
+            ),
+        ]),
+        smt.eq(sret1, sret0),
+        smt.eq(
+            sret1,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                sret0,
+                smt.list(vec![smt.atoms().und, smt.atom("bv32"), smt.numeral(64)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy32,
+                smt.list(vec![
+                    smt.atoms().und,
+                    smt.atom("bv18446744073709551615"),
+                    smt.numeral(64),
+                ]),
+            ),
+        ]),
+        smt.eq(sx32, sy32),
+        smt.eq(sx32, x),
+    ]));
+    // round 2
+    let sret2 = declare(
+        smt,
+        format!("sret2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let sy16 = declare(
+        smt,
+        format!("sy16_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let sx16 = declare(
+        smt,
+        format!("sx16_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.eq(sy16, smt.bvashr(sx32, smt.atom("#x0000000000000010"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy16,
+                smt.list(vec![
+                    smt.atoms().und,
+                    smt.atom("bv18446744073709551615"),
+                    smt.numeral(64),
+                ]),
+            ),
+        ]),
+        smt.eq(sret2, sret1),
+        smt.eq(
+            sret2,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                sret1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv16"), smt.numeral(64)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy16,
+                smt.list(vec![
+                    smt.atoms().und,
+                    smt.atom("bv18446744073709551615"),
+                    smt.numeral(64),
+                ]),
+            ),
+        ]),
+        smt.eq(sx16, sy16),
+        smt.eq(sx16, sx32),
+    ]));
+    // round 3
+    let sret3 = declare(
+        smt,
+        format!("sret3_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let sy8 = declare(
+        smt,
+        format!("sy8_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let sx8 = declare(
+        smt,
+        format!("sx8_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.eq(sy8, smt.bvashr(sx16, smt.atom("#x0000000000000008"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy8,
+                smt.list(vec![
+                    smt.atoms().und,
+                    smt.atom("bv18446744073709551615"),
+                    smt.numeral(64),
+                ]),
+            ),
+        ]),
+        smt.eq(sret3, sret2),
+        smt.eq(
+            sret3,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                sret2,
+                smt.list(vec![smt.atoms().und, smt.atom("bv8"), smt.numeral(64)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy8,
+                smt.list(vec![
+                    smt.atoms().und,
+                    smt.atom("bv18446744073709551615"),
+                    smt.numeral(64),
+                ]),
+            ),
+        ]),
+        smt.eq(sx8, sy8),
+        smt.eq(sx8, sx16),
+    ]));
+    // round 4
+    let sret4 = declare(
+        smt,
+        format!("sret4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let sy4 = declare(
+        smt,
+        format!("sy4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let sx4 = declare(
+        smt,
+        format!("sx4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.eq(sy4, smt.bvashr(sx8, smt.atom("#x0000000000000004"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy4,
+                smt.list(vec![
+                    smt.atoms().und,
+                    smt.atom("bv18446744073709551615"),
+                    smt.numeral(64),
+                ]),
+            ),
+        ]),
+        smt.eq(sret4, sret3),
+        smt.eq(
+            sret4,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                sret3,
+                smt.list(vec![smt.atoms().und, smt.atom("bv4"), smt.numeral(64)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy4,
+                smt.list(vec![
+                    smt.atoms().und,
+                    smt.atom("bv18446744073709551615"),
+                    smt.numeral(64),
+                ]),
+            ),
+        ]),
+        smt.eq(sx4, sy4),
+        smt.eq(sx4, sx8),
+    ]));
+    // round 5
+    let sret5 = declare(
+        smt,
+        format!("sret5_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let sy2 = declare(
+        smt,
+        format!("sy2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let sx2 = declare(
+        smt,
+        format!("sx2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.eq(sy2, smt.bvashr(sx4, smt.atom("#x0000000000000002"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy2,
+                smt.list(vec![
+                    smt.atoms().und,
+                    smt.atom("bv18446744073709551615"),
+                    smt.numeral(64),
+                ]),
+            ),
+        ]),
+        smt.eq(sret5, sret4),
+        smt.eq(
+            sret5,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                sret4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv2"), smt.numeral(64)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy2,
+                smt.list(vec![
+                    smt.atoms().und,
+                    smt.atom("bv18446744073709551615"),
+                    smt.numeral(64),
+                ]),
+            ),
+        ]),
+        smt.eq(sx2, sy2),
+        smt.eq(sx2, sx4),
+    ]));
+    // round 6
+    let sret6 = declare(
+        smt,
+        format!("sret6_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let sy1 = declare(
+        smt,
+        format!("sy1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let sx1 = declare(
+        smt,
+        format!("sx1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.eq(sy1, smt.bvashr(sx2, smt.atom("#x0000000000000001"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy1,
+                smt.list(vec![
+                    smt.atoms().und,
+                    smt.atom("bv18446744073709551615"),
+                    smt.numeral(64),
+                ]),
+            ),
+        ]),
+        smt.eq(sret6, sret5),
+        smt.eq(
+            sret6,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                sret5,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(64)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy1,
+                smt.list(vec![
+                    smt.atoms().und,
+                    smt.atom("bv18446744073709551615"),
+                    smt.numeral(64),
+                ]),
+            ),
+        ]),
+        smt.eq(sx1, sy1),
+        smt.eq(sx1, sx2),
+    ]));
+    // last round
+    let sret7 = declare(
+        smt,
+        format!("sret7_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sx1,
+                smt.list(vec![
+                    smt.atoms().und,
+                    smt.atom("bv18446744073709551615"),
+                    smt.numeral(64),
+                ]),
+            ),
+        ]),
+        smt.eq(sret7, sret6),
+        smt.eq(
+            sret7,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                sret6,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(64)]),
+            ]),
+        ),
+    ]));
+    let clsret = declare(
+        smt,
+        format!("clsret_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.eq(
+            sret7,
+            smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+        ),
+        smt.eq(clsret, sret7),
+        smt.eq(
+            clsret,
+            smt.list(vec![
+                smt.atom("bvsub"),
+                sret7,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(64)]),
+            ]),
+        ),
+    ]));
+    let cls64ret = declare(
+        smt,
+        format!("cls64ret_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("bvsle"),
+            smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+            x,
+        ]),
+        smt.eq(cls64ret, clzret),
+        smt.eq(cls64ret, clsret),
+    ]));
+
+    cls64ret
+}
+
+pub fn cls32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
+    let x = smt.extract(31, 0, x);
+
+    // Generated code.
+    // total zeros counter
+    let zret0 = declare(
+        smt,
+        format!("zret0_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let _ = smt.assert(smt.eq(
+        zret0,
+        smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(32)]),
+    ));
+    // round 1
+    let zret2 = declare(
+        smt,
+        format!("zret2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let zy16 = declare(
+        smt,
+        format!("zy16_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let zx16 = declare(
+        smt,
+        format!("zx16_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let _ = smt.assert(smt.eq(zy16, smt.bvlshr(x, smt.atom("#x00000010"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy16,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(32)]),
+            ),
+        ]),
+        smt.eq(zret2, zret0),
+        smt.eq(
+            zret2,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                zret0,
+                smt.list(vec![smt.atoms().und, smt.atom("bv16"), smt.numeral(32)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy16,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(32)]),
+            ),
+        ]),
+        smt.eq(zx16, zy16),
+        smt.eq(zx16, x),
+    ]));
+    // round 2
+    let zret3 = declare(
+        smt,
+        format!("zret3_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let zy8 = declare(
+        smt,
+        format!("zy8_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let zx8 = declare(
+        smt,
+        format!("zx8_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let _ = smt.assert(smt.eq(zy8, smt.bvlshr(zx16, smt.atom("#x00000008"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy8,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(32)]),
+            ),
+        ]),
+        smt.eq(zret3, zret2),
+        smt.eq(
+            zret3,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                zret2,
+                smt.list(vec![smt.atoms().und, smt.atom("bv8"), smt.numeral(32)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy8,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(32)]),
+            ),
+        ]),
+        smt.eq(zx8, zy8),
+        smt.eq(zx8, zx16),
+    ]));
+    // round 3
+    let zret4 = declare(
+        smt,
+        format!("zret4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let zy4 = declare(
+        smt,
+        format!("zy4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let zx4 = declare(
+        smt,
+        format!("zx4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let _ = smt.assert(smt.eq(zy4, smt.bvlshr(zx8, smt.atom("#x00000004"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(32)]),
+            ),
+        ]),
+        smt.eq(zret4, zret3),
+        smt.eq(
+            zret4,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                zret3,
+                smt.list(vec![smt.atoms().und, smt.atom("bv4"), smt.numeral(32)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(32)]),
+            ),
+        ]),
+        smt.eq(zx4, zy4),
+        smt.eq(zx4, zx8),
+    ]));
+    // round 4
+    let zret5 = declare(
+        smt,
+        format!("zret5_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let zy2 = declare(
+        smt,
+        format!("zy2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let zx2 = declare(
+        smt,
+        format!("zx2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let _ = smt.assert(smt.eq(zy2, smt.bvlshr(zx4, smt.atom("#x00000002"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy2,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(32)]),
+            ),
+        ]),
+        smt.eq(zret5, zret4),
+        smt.eq(
+            zret5,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                zret4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv2"), smt.numeral(32)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy2,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(32)]),
+            ),
+        ]),
+        smt.eq(zx2, zy2),
+        smt.eq(zx2, zx4),
+    ]));
+    // round 5
+    let zret6 = declare(
+        smt,
+        format!("zret6_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let zy1 = declare(
+        smt,
+        format!("zy1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let zx1 = declare(
+        smt,
+        format!("zx1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let _ = smt.assert(smt.eq(zy1, smt.bvlshr(zx2, smt.atom("#x00000001"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(32)]),
+            ),
+        ]),
+        smt.eq(zret6, zret5),
+        smt.eq(
+            zret6,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                zret5,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(32)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(32)]),
+            ),
+        ]),
+        smt.eq(zx1, zy1),
+        smt.eq(zx1, zx2),
+    ]));
+    // last round
+    let zret7 = declare(
+        smt,
+        format!("zret7_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zx1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(32)]),
+            ),
+        ]),
+        smt.eq(zret7, zret6),
+        smt.eq(
+            zret7,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                zret6,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(32)]),
+            ]),
+        ),
+    ]));
+    let clzret = declare(
+        smt,
+        format!("clzret_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.eq(
+            zret7,
+            smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(32)]),
+        ),
+        smt.eq(clzret, zret7),
+        smt.eq(
+            clzret,
+            smt.list(vec![
+                smt.atom("bvsub"),
+                zret7,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(32)]),
+            ]),
+        ),
+    ]));
+    // total zeros counter
+    let sret0 = declare(
+        smt,
+        format!("sret0_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let _ = smt.assert(smt.eq(
+        sret0,
+        smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(32)]),
+    ));
+    // round 1
+    let sret2 = declare(
+        smt,
+        format!("sret2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let sy16 = declare(
+        smt,
+        format!("sy16_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let sx16 = declare(
+        smt,
+        format!("sx16_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let _ = smt.assert(smt.eq(sy16, smt.bvashr(x, smt.atom("#x00000010"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy16,
+                smt.list(vec![
+                    smt.atoms().und,
+                    smt.atom("bv4294967295"),
+                    smt.numeral(32),
+                ]),
+            ),
+        ]),
+        smt.eq(sret2, sret0),
+        smt.eq(
+            sret2,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                sret0,
+                smt.list(vec![smt.atoms().und, smt.atom("bv16"), smt.numeral(32)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy16,
+                smt.list(vec![
+                    smt.atoms().und,
+                    smt.atom("bv4294967295"),
+                    smt.numeral(32),
+                ]),
+            ),
+        ]),
+        smt.eq(sx16, sy16),
+        smt.eq(sx16, x),
+    ]));
+    // round 2
+    let sret3 = declare(
+        smt,
+        format!("sret3_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let sy8 = declare(
+        smt,
+        format!("sy8_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let sx8 = declare(
+        smt,
+        format!("sx8_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let _ = smt.assert(smt.eq(sy8, smt.bvashr(sx16, smt.atom("#x00000008"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy8,
+                smt.list(vec![
+                    smt.atoms().und,
+                    smt.atom("bv4294967295"),
+                    smt.numeral(32),
+                ]),
+            ),
+        ]),
+        smt.eq(sret3, sret2),
+        smt.eq(
+            sret3,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                sret2,
+                smt.list(vec![smt.atoms().und, smt.atom("bv8"), smt.numeral(32)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy8,
+                smt.list(vec![
+                    smt.atoms().und,
+                    smt.atom("bv4294967295"),
+                    smt.numeral(32),
+                ]),
+            ),
+        ]),
+        smt.eq(sx8, sy8),
+        smt.eq(sx8, sx16),
+    ]));
+    // round 3
+    let sret4 = declare(
+        smt,
+        format!("sret4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let sy4 = declare(
+        smt,
+        format!("sy4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let sx4 = declare(
+        smt,
+        format!("sx4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let _ = smt.assert(smt.eq(sy4, smt.bvashr(sx8, smt.atom("#x00000004"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy4,
+                smt.list(vec![
+                    smt.atoms().und,
+                    smt.atom("bv4294967295"),
+                    smt.numeral(32),
+                ]),
+            ),
+        ]),
+        smt.eq(sret4, sret3),
+        smt.eq(
+            sret4,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                sret3,
+                smt.list(vec![smt.atoms().und, smt.atom("bv4"), smt.numeral(32)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy4,
+                smt.list(vec![
+                    smt.atoms().und,
+                    smt.atom("bv4294967295"),
+                    smt.numeral(32),
+                ]),
+            ),
+        ]),
+        smt.eq(sx4, sy4),
+        smt.eq(sx4, sx8),
+    ]));
+    // round 4
+    let sret5 = declare(
+        smt,
+        format!("sret5_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let sy2 = declare(
+        smt,
+        format!("sy2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let sx2 = declare(
+        smt,
+        format!("sx2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let _ = smt.assert(smt.eq(sy2, smt.bvashr(sx4, smt.atom("#x00000002"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy2,
+                smt.list(vec![
+                    smt.atoms().und,
+                    smt.atom("bv4294967295"),
+                    smt.numeral(32),
+                ]),
+            ),
+        ]),
+        smt.eq(sret5, sret4),
+        smt.eq(
+            sret5,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                sret4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv2"), smt.numeral(32)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy2,
+                smt.list(vec![
+                    smt.atoms().und,
+                    smt.atom("bv4294967295"),
+                    smt.numeral(32),
+                ]),
+            ),
+        ]),
+        smt.eq(sx2, sy2),
+        smt.eq(sx2, sx4),
+    ]));
+    // round 5
+    let sret6 = declare(
+        smt,
+        format!("sret6_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let sy1 = declare(
+        smt,
+        format!("sy1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let sx1 = declare(
+        smt,
+        format!("sx1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let _ = smt.assert(smt.eq(sy1, smt.bvashr(sx2, smt.atom("#x00000001"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy1,
+                smt.list(vec![
+                    smt.atoms().und,
+                    smt.atom("bv4294967295"),
+                    smt.numeral(32),
+                ]),
+            ),
+        ]),
+        smt.eq(sret6, sret5),
+        smt.eq(
+            sret6,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                sret5,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(32)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy1,
+                smt.list(vec![
+                    smt.atoms().und,
+                    smt.atom("bv4294967295"),
+                    smt.numeral(32),
+                ]),
+            ),
+        ]),
+        smt.eq(sx1, sy1),
+        smt.eq(sx1, sx2),
+    ]));
+    // last round
+    let sret7 = declare(
+        smt,
+        format!("sret7_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sx1,
+                smt.list(vec![
+                    smt.atoms().und,
+                    smt.atom("bv4294967295"),
+                    smt.numeral(32),
+                ]),
+            ),
+        ]),
+        smt.eq(sret7, sret6),
+        smt.eq(
+            sret7,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                sret6,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(32)]),
+            ]),
+        ),
+    ]));
+    let clsret = declare(
+        smt,
+        format!("clsret_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.eq(
+            sret7,
+            smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(32)]),
+        ),
+        smt.eq(clsret, sret7),
+        smt.eq(
+            clsret,
+            smt.list(vec![
+                smt.atom("bvsub"),
+                sret7,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(32)]),
+            ]),
+        ),
+    ]));
+    let cls32ret = declare(
+        smt,
+        format!("cls32ret_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("bvsle"),
+            smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(32)]),
+            x,
+        ]),
+        smt.eq(cls32ret, clzret),
+        smt.eq(cls32ret, clsret),
+    ]));
+
+    cls32ret
+}
+
+pub fn cls16(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
+    let x = smt.extract(15, 0, x);
+
+    // Generated code.
+    // total zeros counter
+    let zret0 = declare(
+        smt,
+        format!("zret0_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let _ = smt.assert(smt.eq(
+        zret0,
+        smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(16)]),
+    ));
+    // round 1
+    let zret3 = declare(
+        smt,
+        format!("zret3_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let zy8 = declare(
+        smt,
+        format!("zy8_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let zx8 = declare(
+        smt,
+        format!("zx8_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let _ = smt.assert(smt.eq(zy8, smt.bvlshr(x, smt.atom("#x0008"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy8,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(16)]),
+            ),
+        ]),
+        smt.eq(zret3, zret0),
+        smt.eq(
+            zret3,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                zret0,
+                smt.list(vec![smt.atoms().und, smt.atom("bv8"), smt.numeral(16)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy8,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(16)]),
+            ),
+        ]),
+        smt.eq(zx8, zy8),
+        smt.eq(zx8, x),
+    ]));
+    // round 2
+    let zret4 = declare(
+        smt,
+        format!("zret4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let zy4 = declare(
+        smt,
+        format!("zy4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let zx4 = declare(
+        smt,
+        format!("zx4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let _ = smt.assert(smt.eq(zy4, smt.bvlshr(zx8, smt.atom("#x0004"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(16)]),
+            ),
+        ]),
+        smt.eq(zret4, zret3),
+        smt.eq(
+            zret4,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                zret3,
+                smt.list(vec![smt.atoms().und, smt.atom("bv4"), smt.numeral(16)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(16)]),
+            ),
+        ]),
+        smt.eq(zx4, zy4),
+        smt.eq(zx4, zx8),
+    ]));
+    // round 3
+    let zret5 = declare(
+        smt,
+        format!("zret5_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let zy2 = declare(
+        smt,
+        format!("zy2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let zx2 = declare(
+        smt,
+        format!("zx2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let _ = smt.assert(smt.eq(zy2, smt.bvlshr(zx4, smt.atom("#x0002"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy2,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(16)]),
+            ),
+        ]),
+        smt.eq(zret5, zret4),
+        smt.eq(
+            zret5,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                zret4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv2"), smt.numeral(16)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy2,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(16)]),
+            ),
+        ]),
+        smt.eq(zx2, zy2),
+        smt.eq(zx2, zx4),
+    ]));
+    // round 4
+    let zret6 = declare(
+        smt,
+        format!("zret6_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let zy1 = declare(
+        smt,
+        format!("zy1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let zx1 = declare(
+        smt,
+        format!("zx1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let _ = smt.assert(smt.eq(zy1, smt.bvlshr(zx2, smt.atom("#x0001"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(16)]),
+            ),
+        ]),
+        smt.eq(zret6, zret5),
+        smt.eq(
+            zret6,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                zret5,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(16)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(16)]),
+            ),
+        ]),
+        smt.eq(zx1, zy1),
+        smt.eq(zx1, zx2),
+    ]));
+    // last round
+    let zret7 = declare(
+        smt,
+        format!("zret7_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zx1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(16)]),
+            ),
+        ]),
+        smt.eq(zret7, zret6),
+        smt.eq(
+            zret7,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                zret6,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(16)]),
+            ]),
+        ),
+    ]));
+    let clzret = declare(
+        smt,
+        format!("clzret_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.eq(
+            zret7,
+            smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(16)]),
+        ),
+        smt.eq(clzret, zret7),
+        smt.eq(
+            clzret,
+            smt.list(vec![
+                smt.atom("bvsub"),
+                zret7,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(16)]),
+            ]),
+        ),
+    ]));
+    // total zeros counter
+    let sret0 = declare(
+        smt,
+        format!("sret0_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let _ = smt.assert(smt.eq(
+        sret0,
+        smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(16)]),
+    ));
+    // round 1
+    let sret3 = declare(
+        smt,
+        format!("sret3_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let sy8 = declare(
+        smt,
+        format!("sy8_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let sx8 = declare(
+        smt,
+        format!("sx8_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let _ = smt.assert(smt.eq(sy8, smt.bvashr(x, smt.atom("#x0008"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy8,
+                smt.list(vec![smt.atoms().und, smt.atom("bv65535"), smt.numeral(16)]),
+            ),
+        ]),
+        smt.eq(sret3, sret0),
+        smt.eq(
+            sret3,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                sret0,
+                smt.list(vec![smt.atoms().und, smt.atom("bv8"), smt.numeral(16)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy8,
+                smt.list(vec![smt.atoms().und, smt.atom("bv65535"), smt.numeral(16)]),
+            ),
+        ]),
+        smt.eq(sx8, sy8),
+        smt.eq(sx8, x),
+    ]));
+    // round 2
+    let sret4 = declare(
+        smt,
+        format!("sret4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let sy4 = declare(
+        smt,
+        format!("sy4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let sx4 = declare(
+        smt,
+        format!("sx4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let _ = smt.assert(smt.eq(sy4, smt.bvashr(sx8, smt.atom("#x0004"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv65535"), smt.numeral(16)]),
+            ),
+        ]),
+        smt.eq(sret4, sret3),
+        smt.eq(
+            sret4,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                sret3,
+                smt.list(vec![smt.atoms().und, smt.atom("bv4"), smt.numeral(16)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv65535"), smt.numeral(16)]),
+            ),
+        ]),
+        smt.eq(sx4, sy4),
+        smt.eq(sx4, sx8),
+    ]));
+    // round 3
+    let sret5 = declare(
+        smt,
+        format!("sret5_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let sy2 = declare(
+        smt,
+        format!("sy2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let sx2 = declare(
+        smt,
+        format!("sx2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let _ = smt.assert(smt.eq(sy2, smt.bvashr(sx4, smt.atom("#x0002"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy2,
+                smt.list(vec![smt.atoms().und, smt.atom("bv65535"), smt.numeral(16)]),
+            ),
+        ]),
+        smt.eq(sret5, sret4),
+        smt.eq(
+            sret5,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                sret4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv2"), smt.numeral(16)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy2,
+                smt.list(vec![smt.atoms().und, smt.atom("bv65535"), smt.numeral(16)]),
+            ),
+        ]),
+        smt.eq(sx2, sy2),
+        smt.eq(sx2, sx4),
+    ]));
+    // round 4
+    let sret6 = declare(
+        smt,
+        format!("sret6_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let sy1 = declare(
+        smt,
+        format!("sy1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let sx1 = declare(
+        smt,
+        format!("sx1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let _ = smt.assert(smt.eq(sy1, smt.bvashr(sx2, smt.atom("#x0001"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv65535"), smt.numeral(16)]),
+            ),
+        ]),
+        smt.eq(sret6, sret5),
+        smt.eq(
+            sret6,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                sret5,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(16)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv65535"), smt.numeral(16)]),
+            ),
+        ]),
+        smt.eq(sx1, sy1),
+        smt.eq(sx1, sx2),
+    ]));
+    // last round
+    let sret7 = declare(
+        smt,
+        format!("sret7_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sx1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv65535"), smt.numeral(16)]),
+            ),
+        ]),
+        smt.eq(sret7, sret6),
+        smt.eq(
+            sret7,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                sret6,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(16)]),
+            ]),
+        ),
+    ]));
+    let clsret = declare(
+        smt,
+        format!("clsret_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.eq(
+            sret7,
+            smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(16)]),
+        ),
+        smt.eq(clsret, sret7),
+        smt.eq(
+            clsret,
+            smt.list(vec![
+                smt.atom("bvsub"),
+                sret7,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(16)]),
+            ]),
+        ),
+    ]));
+    let cls16ret = declare(
+        smt,
+        format!("cls16ret_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("bvsle"),
+            smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(16)]),
+            x,
+        ]),
+        smt.eq(cls16ret, clzret),
+        smt.eq(cls16ret, clsret),
+    ]));
+
+    cls16ret
+}
+
+pub fn cls8(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
+    let x = smt.extract(7, 0, x);
+
+    // Generated code.
+    // total zeros counter
+    let zret0 = declare(
+        smt,
+        format!("zret0_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let _ = smt.assert(smt.eq(
+        zret0,
+        smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(8)]),
+    ));
+    // round 1
+    let zret4 = declare(
+        smt,
+        format!("zret4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let zy4 = declare(
+        smt,
+        format!("zy4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let zx4 = declare(
+        smt,
+        format!("zx4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let _ = smt.assert(smt.eq(zy4, smt.bvlshr(x, smt.atom("#x04"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(8)]),
+            ),
+        ]),
+        smt.eq(zret4, zret0),
+        smt.eq(
+            zret4,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                zret0,
+                smt.list(vec![smt.atoms().und, smt.atom("bv4"), smt.numeral(8)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(8)]),
+            ),
+        ]),
+        smt.eq(zx4, zy4),
+        smt.eq(zx4, x),
+    ]));
+    // round 2
+    let zret5 = declare(
+        smt,
+        format!("zret5_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let zy2 = declare(
+        smt,
+        format!("zy2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let zx2 = declare(
+        smt,
+        format!("zx2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let _ = smt.assert(smt.eq(zy2, smt.bvlshr(zx4, smt.atom("#x02"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy2,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(8)]),
+            ),
+        ]),
+        smt.eq(zret5, zret4),
+        smt.eq(
+            zret5,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                zret4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv2"), smt.numeral(8)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy2,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(8)]),
+            ),
+        ]),
+        smt.eq(zx2, zy2),
+        smt.eq(zx2, zx4),
+    ]));
+    // round 3
+    let zret6 = declare(
+        smt,
+        format!("zret6_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let zy1 = declare(
+        smt,
+        format!("zy1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let zx1 = declare(
+        smt,
+        format!("zx1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let _ = smt.assert(smt.eq(zy1, smt.bvlshr(zx2, smt.atom("#x01"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(8)]),
+            ),
+        ]),
+        smt.eq(zret6, zret5),
+        smt.eq(
+            zret6,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                zret5,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(8)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zy1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(8)]),
+            ),
+        ]),
+        smt.eq(zx1, zy1),
+        smt.eq(zx1, zx2),
+    ]));
+    // last round
+    let zret7 = declare(
+        smt,
+        format!("zret7_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                zx1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(8)]),
+            ),
+        ]),
+        smt.eq(zret7, zret6),
+        smt.eq(
+            zret7,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                zret6,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(8)]),
+            ]),
+        ),
+    ]));
+    let clzret = declare(
+        smt,
+        format!("clzret_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.eq(
+            zret7,
+            smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(8)]),
+        ),
+        smt.eq(clzret, zret7),
+        smt.eq(
+            clzret,
+            smt.list(vec![
+                smt.atom("bvsub"),
+                zret7,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(8)]),
+            ]),
+        ),
+    ]));
+    // total zeros counter
+    let sret0 = declare(
+        smt,
+        format!("sret0_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let _ = smt.assert(smt.eq(
+        sret0,
+        smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(8)]),
+    ));
+    // round 1
+    let sret4 = declare(
+        smt,
+        format!("sret4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let sy4 = declare(
+        smt,
+        format!("sy4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let sx4 = declare(
+        smt,
+        format!("sx4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let _ = smt.assert(smt.eq(sy4, smt.bvashr(x, smt.atom("#x04"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv255"), smt.numeral(8)]),
+            ),
+        ]),
+        smt.eq(sret4, sret0),
+        smt.eq(
+            sret4,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                sret0,
+                smt.list(vec![smt.atoms().und, smt.atom("bv4"), smt.numeral(8)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv255"), smt.numeral(8)]),
+            ),
+        ]),
+        smt.eq(sx4, sy4),
+        smt.eq(sx4, x),
+    ]));
+    // round 2
+    let sret5 = declare(
+        smt,
+        format!("sret5_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let sy2 = declare(
+        smt,
+        format!("sy2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let sx2 = declare(
+        smt,
+        format!("sx2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let _ = smt.assert(smt.eq(sy2, smt.bvashr(sx4, smt.atom("#x02"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy2,
+                smt.list(vec![smt.atoms().und, smt.atom("bv255"), smt.numeral(8)]),
+            ),
+        ]),
+        smt.eq(sret5, sret4),
+        smt.eq(
+            sret5,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                sret4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv2"), smt.numeral(8)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy2,
+                smt.list(vec![smt.atoms().und, smt.atom("bv255"), smt.numeral(8)]),
+            ),
+        ]),
+        smt.eq(sx2, sy2),
+        smt.eq(sx2, sx4),
+    ]));
+    // round 3
+    let sret6 = declare(
+        smt,
+        format!("sret6_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let sy1 = declare(
+        smt,
+        format!("sy1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let sx1 = declare(
+        smt,
+        format!("sx1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let _ = smt.assert(smt.eq(sy1, smt.bvashr(sx2, smt.atom("#x01"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv255"), smt.numeral(8)]),
+            ),
+        ]),
+        smt.eq(sret6, sret5),
+        smt.eq(
+            sret6,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                sret5,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(8)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sy1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv255"), smt.numeral(8)]),
+            ),
+        ]),
+        smt.eq(sx1, sy1),
+        smt.eq(sx1, sx2),
+    ]));
+    // last round
+    let sret7 = declare(
+        smt,
+        format!("sret7_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                sx1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv255"), smt.numeral(8)]),
+            ),
+        ]),
+        smt.eq(sret7, sret6),
+        smt.eq(
+            sret7,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                sret6,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(8)]),
+            ]),
+        ),
+    ]));
+    let clsret = declare(
+        smt,
+        format!("clsret_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.eq(
+            sret7,
+            smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(8)]),
+        ),
+        smt.eq(clsret, sret7),
+        smt.eq(
+            clsret,
+            smt.list(vec![
+                smt.atom("bvsub"),
+                sret7,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(8)]),
+            ]),
+        ),
+    ]));
+    let cls8ret = declare(
+        smt,
+        format!("cls8ret_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("bvsle"),
+            smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(8)]),
+            x,
+        ]),
+        smt.eq(cls8ret, clzret),
+        smt.eq(cls8ret, clsret),
+    ]));
+
+    cls8ret
+}
+
+pub fn cls1(smt: &mut Context, id: usize) -> SExpr {
+    // Generated code.
+    let cls1ret = declare(
+        smt,
+        format!("cls1ret_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(1)]),
+    );
+    let _ = smt.assert(smt.eq(
+        cls1ret,
+        smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(1)]),
+    ));
+
+    cls1ret
+}
diff --git a/cranelift/isle/veri/veri/src/encoded/clz.rs b/cranelift/isle/veri/veri/src/encoded/clz.rs
new file mode 100644
index 000000000000..d54588cf4920
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/encoded/clz.rs
@@ -0,0 +1,1056 @@
+// Adapted from https://stackoverflow.com/questions/23856596/how-to-count-leading-zeros-in-a-32-bit-unsigned-integer
+use easy_smt::*;
+
+fn declare(smt: &mut Context, name: String, val: SExpr) -> SExpr {
+    smt.declare_const(name.clone(), val).unwrap();
+    smt.atom(name)
+}
+
+pub fn clz64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
+    // Generated code.
+    // total zeros counter
+    let ret0 = declare(
+        smt,
+        format!("ret0_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.eq(
+        ret0,
+        smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+    ));
+    // round 1
+    let ret1 = declare(
+        smt,
+        format!("ret1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let y32 = declare(
+        smt,
+        format!("y32_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let x32 = declare(
+        smt,
+        format!("x32_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.eq(y32, smt.bvlshr(x, smt.atom("#x0000000000000020"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y32,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+            ),
+        ]),
+        smt.eq(ret1, ret0),
+        smt.eq(
+            ret1,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                ret0,
+                smt.list(vec![smt.atoms().und, smt.atom("bv32"), smt.numeral(64)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y32,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+            ),
+        ]),
+        smt.eq(x32, y32),
+        smt.eq(x32, x),
+    ]));
+    // round 2
+    let ret2 = declare(
+        smt,
+        format!("ret2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let y16 = declare(
+        smt,
+        format!("y16_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let x16 = declare(
+        smt,
+        format!("x16_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.eq(y16, smt.bvlshr(x32, smt.atom("#x0000000000000010"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y16,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+            ),
+        ]),
+        smt.eq(ret2, ret1),
+        smt.eq(
+            ret2,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                ret1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv16"), smt.numeral(64)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y16,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+            ),
+        ]),
+        smt.eq(x16, y16),
+        smt.eq(x16, x32),
+    ]));
+    // round 3
+    let ret3 = declare(
+        smt,
+        format!("ret3_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let y8 = declare(
+        smt,
+        format!("y8_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let x8 = declare(
+        smt,
+        format!("x8_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.eq(y8, smt.bvlshr(x16, smt.atom("#x0000000000000008"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y8,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+            ),
+        ]),
+        smt.eq(ret3, ret2),
+        smt.eq(
+            ret3,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                ret2,
+                smt.list(vec![smt.atoms().und, smt.atom("bv8"), smt.numeral(64)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y8,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+            ),
+        ]),
+        smt.eq(x8, y8),
+        smt.eq(x8, x16),
+    ]));
+    // round 4
+    let ret4 = declare(
+        smt,
+        format!("ret4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let y4 = declare(
+        smt,
+        format!("y4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let x4 = declare(
+        smt,
+        format!("x4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.eq(y4, smt.bvlshr(x8, smt.atom("#x0000000000000004"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+            ),
+        ]),
+        smt.eq(ret4, ret3),
+        smt.eq(
+            ret4,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                ret3,
+                smt.list(vec![smt.atoms().und, smt.atom("bv4"), smt.numeral(64)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+            ),
+        ]),
+        smt.eq(x4, y4),
+        smt.eq(x4, x8),
+    ]));
+    // round 5
+    let ret5 = declare(
+        smt,
+        format!("ret5_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let y2 = declare(
+        smt,
+        format!("y2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let x2 = declare(
+        smt,
+        format!("x2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.eq(y2, smt.bvlshr(x4, smt.atom("#x0000000000000002"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y2,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+            ),
+        ]),
+        smt.eq(ret5, ret4),
+        smt.eq(
+            ret5,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                ret4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv2"), smt.numeral(64)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y2,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+            ),
+        ]),
+        smt.eq(x2, y2),
+        smt.eq(x2, x4),
+    ]));
+    // round 6
+    let ret6 = declare(
+        smt,
+        format!("ret6_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let y1 = declare(
+        smt,
+        format!("y1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let x1 = declare(
+        smt,
+        format!("x1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.eq(y1, smt.bvlshr(x2, smt.atom("#x0000000000000001"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+            ),
+        ]),
+        smt.eq(ret6, ret5),
+        smt.eq(
+            ret6,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                ret5,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(64)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+            ),
+        ]),
+        smt.eq(x1, y1),
+        smt.eq(x1, x2),
+    ]));
+
+    // last round
+    let ret7 = declare(
+        smt,
+        format!("ret7_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                x1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(64)]),
+            ),
+        ]),
+        smt.eq(ret7, ret6),
+        smt.eq(
+            ret7,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                ret6,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(64)]),
+            ]),
+        ),
+    ]));
+
+    ret7
+}
+
+pub fn clz32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
+    let x = smt.extract(31, 0, x);
+
+    // Generated code.
+    // total zeros counter
+    let ret0 = declare(
+        smt,
+        format!("ret0_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let _ = smt.assert(smt.eq(
+        ret0,
+        smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(32)]),
+    ));
+    // round 1
+    let ret1 = declare(
+        smt,
+        format!("ret1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let y16 = declare(
+        smt,
+        format!("y16_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let x16 = declare(
+        smt,
+        format!("x16_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let _ = smt.assert(smt.eq(y16, smt.bvlshr(x, smt.atom("#x00000010"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y16,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(32)]),
+            ),
+        ]),
+        smt.eq(ret1, ret0),
+        smt.eq(
+            ret1,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                ret0,
+                smt.list(vec![smt.atoms().und, smt.atom("bv16"), smt.numeral(32)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y16,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(32)]),
+            ),
+        ]),
+        smt.eq(x16, y16),
+        smt.eq(x16, x),
+    ]));
+    // round 2
+    let ret2 = declare(
+        smt,
+        format!("ret2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let y8 = declare(
+        smt,
+        format!("y8_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let x8 = declare(
+        smt,
+        format!("x8_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let _ = smt.assert(smt.eq(y8, smt.bvlshr(x16, smt.atom("#x00000008"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y8,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(32)]),
+            ),
+        ]),
+        smt.eq(ret2, ret1),
+        smt.eq(
+            ret2,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                ret1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv8"), smt.numeral(32)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y8,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(32)]),
+            ),
+        ]),
+        smt.eq(x8, y8),
+        smt.eq(x8, x16),
+    ]));
+    // round 3
+    let ret3 = declare(
+        smt,
+        format!("ret3_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let y4 = declare(
+        smt,
+        format!("y4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let x4 = declare(
+        smt,
+        format!("x4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let _ = smt.assert(smt.eq(y4, smt.bvlshr(x8, smt.atom("#x00000004"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(32)]),
+            ),
+        ]),
+        smt.eq(ret3, ret2),
+        smt.eq(
+            ret3,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                ret2,
+                smt.list(vec![smt.atoms().und, smt.atom("bv4"), smt.numeral(32)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(32)]),
+            ),
+        ]),
+        smt.eq(x4, y4),
+        smt.eq(x4, x8),
+    ]));
+    // round 4
+    let ret4 = declare(
+        smt,
+        format!("ret4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let y2 = declare(
+        smt,
+        format!("y2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let x2 = declare(
+        smt,
+        format!("x2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let _ = smt.assert(smt.eq(y2, smt.bvlshr(x4, smt.atom("#x00000002"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y2,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(32)]),
+            ),
+        ]),
+        smt.eq(ret4, ret3),
+        smt.eq(
+            ret4,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                ret3,
+                smt.list(vec![smt.atoms().und, smt.atom("bv2"), smt.numeral(32)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y2,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(32)]),
+            ),
+        ]),
+        smt.eq(x2, y2),
+        smt.eq(x2, x4),
+    ]));
+    // round 5
+    let ret5 = declare(
+        smt,
+        format!("ret5_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let y1 = declare(
+        smt,
+        format!("y1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let x1 = declare(
+        smt,
+        format!("x1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let _ = smt.assert(smt.eq(y1, smt.bvlshr(x2, smt.atom("#x00000001"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(32)]),
+            ),
+        ]),
+        smt.eq(ret5, ret4),
+        smt.eq(
+            ret5,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                ret4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(32)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(32)]),
+            ),
+        ]),
+        smt.eq(x1, y1),
+        smt.eq(x1, x2),
+    ]));
+
+    // last round
+    let ret6 = declare(
+        smt,
+        format!("ret6_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                x1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(32)]),
+            ),
+        ]),
+        smt.eq(ret6, ret5),
+        smt.eq(
+            ret6,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                ret5,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(32)]),
+            ]),
+        ),
+    ]));
+    ret6
+}
+
+pub fn clz16(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
+    let x = smt.extract(15, 0, x);
+
+    // Generated code.
+    // total zeros counter
+    let ret1 = declare(
+        smt,
+        format!("ret1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let _ = smt.assert(smt.eq(
+        ret1,
+        smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(16)]),
+    ));
+    // round 1
+    let ret2 = declare(
+        smt,
+        format!("ret2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let y8 = declare(
+        smt,
+        format!("y8_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let x8 = declare(
+        smt,
+        format!("x8_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let _ = smt.assert(smt.eq(y8, smt.bvlshr(x, smt.atom("#x0008"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y8,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(16)]),
+            ),
+        ]),
+        smt.eq(ret2, ret1),
+        smt.eq(
+            ret2,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                ret1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv8"), smt.numeral(16)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y8,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(16)]),
+            ),
+        ]),
+        smt.eq(x8, y8),
+        smt.eq(x8, x),
+    ]));
+    // round 2
+    let ret3 = declare(
+        smt,
+        format!("ret3_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let y4 = declare(
+        smt,
+        format!("y4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let x4 = declare(
+        smt,
+        format!("x4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let _ = smt.assert(smt.eq(y4, smt.bvlshr(x8, smt.atom("#x0004"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(16)]),
+            ),
+        ]),
+        smt.eq(ret3, ret2),
+        smt.eq(
+            ret3,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                ret2,
+                smt.list(vec![smt.atoms().und, smt.atom("bv4"), smt.numeral(16)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(16)]),
+            ),
+        ]),
+        smt.eq(x4, y4),
+        smt.eq(x4, x8),
+    ]));
+    // round 3
+    let ret4 = declare(
+        smt,
+        format!("ret4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let y2 = declare(
+        smt,
+        format!("y2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let x2 = declare(
+        smt,
+        format!("x2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let _ = smt.assert(smt.eq(y2, smt.bvlshr(x4, smt.atom("#x0002"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y2,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(16)]),
+            ),
+        ]),
+        smt.eq(ret4, ret3),
+        smt.eq(
+            ret4,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                ret3,
+                smt.list(vec![smt.atoms().und, smt.atom("bv2"), smt.numeral(16)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y2,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(16)]),
+            ),
+        ]),
+        smt.eq(x2, y2),
+        smt.eq(x2, x4),
+    ]));
+    // round 4
+    let ret5 = declare(
+        smt,
+        format!("ret5_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let y1 = declare(
+        smt,
+        format!("y1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let x1 = declare(
+        smt,
+        format!("x1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let _ = smt.assert(smt.eq(y1, smt.bvlshr(x2, smt.atom("#x0001"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(16)]),
+            ),
+        ]),
+        smt.eq(ret5, ret4),
+        smt.eq(
+            ret5,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                ret4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(16)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(16)]),
+            ),
+        ]),
+        smt.eq(x1, y1),
+        smt.eq(x1, x2),
+    ]));
+
+    // last round
+    let ret6 = declare(
+        smt,
+        format!("ret6_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                x1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(16)]),
+            ),
+        ]),
+        smt.eq(ret6, ret5),
+        smt.eq(
+            ret6,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                ret5,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(16)]),
+            ]),
+        ),
+    ]));
+    ret6
+}
+
+pub fn clz8(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
+    let x = smt.extract(7, 0, x);
+
+    // Generated code.
+    // total zeros counter
+    let ret0 = declare(
+        smt,
+        format!("ret0_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let _ = smt.assert(smt.eq(
+        ret0,
+        smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(8)]),
+    ));
+    // round 1
+    let ret3 = declare(
+        smt,
+        format!("ret3_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let y4 = declare(
+        smt,
+        format!("y4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let x4 = declare(
+        smt,
+        format!("x4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let _ = smt.assert(smt.eq(y4, smt.bvlshr(x, smt.atom("#x04"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(8)]),
+            ),
+        ]),
+        smt.eq(ret3, ret0),
+        smt.eq(
+            ret3,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                ret0,
+                smt.list(vec![smt.atoms().und, smt.atom("bv4"), smt.numeral(8)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(8)]),
+            ),
+        ]),
+        smt.eq(x4, y4),
+        smt.eq(x4, x),
+    ]));
+    // round 2
+    let ret4 = declare(
+        smt,
+        format!("ret4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let y2 = declare(
+        smt,
+        format!("y2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let x2 = declare(
+        smt,
+        format!("x2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let _ = smt.assert(smt.eq(y2, smt.bvlshr(x4, smt.atom("#x02"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y2,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(8)]),
+            ),
+        ]),
+        smt.eq(ret4, ret3),
+        smt.eq(
+            ret4,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                ret3,
+                smt.list(vec![smt.atoms().und, smt.atom("bv2"), smt.numeral(8)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y2,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(8)]),
+            ),
+        ]),
+        smt.eq(x2, y2),
+        smt.eq(x2, x4),
+    ]));
+    // round 3
+    let ret5 = declare(
+        smt,
+        format!("ret5_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let y1 = declare(
+        smt,
+        format!("y1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let x1 = declare(
+        smt,
+        format!("x1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let _ = smt.assert(smt.eq(y1, smt.bvlshr(x2, smt.atom("#x01"))));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(8)]),
+            ),
+        ]),
+        smt.eq(ret5, ret4),
+        smt.eq(
+            ret5,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                ret4,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(8)]),
+            ]),
+        ),
+    ]));
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                y1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(8)]),
+            ),
+        ]),
+        smt.eq(x1, y1),
+        smt.eq(x1, x2),
+    ]));
+    // last round
+    let ret6 = declare(
+        smt,
+        format!("ret6_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let _ = smt.assert(smt.list(vec![
+        smt.atom("ite"),
+        smt.list(vec![
+            smt.atom("not"),
+            smt.eq(
+                x1,
+                smt.list(vec![smt.atoms().und, smt.atom("bv0"), smt.numeral(8)]),
+            ),
+        ]),
+        smt.eq(ret6, ret5),
+        smt.eq(
+            ret6,
+            smt.list(vec![
+                smt.atom("bvadd"),
+                ret5,
+                smt.list(vec![smt.atoms().und, smt.atom("bv1"), smt.numeral(8)]),
+            ]),
+        ),
+    ]));
+
+    ret6
+}
+
+pub fn clz1(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
+    let x = smt.extract(0, 0, x);
+
+    // Generated code.
+    let clz1ret = declare(
+        smt,
+        format!("clz1ret_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(1)]),
+    );
+    let _ = smt.assert(smt.eq(clz1ret, smt.list(vec![smt.atom("bvnot"), x])));
+
+    clz1ret
+}
diff --git a/cranelift/isle/veri/veri/src/encoded/mod.rs b/cranelift/isle/veri/veri/src/encoded/mod.rs
new file mode 100644
index 000000000000..3f837fccd35d
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/encoded/mod.rs
@@ -0,0 +1,4 @@
+pub mod cls;
+pub mod clz;
+pub mod popcnt;
+pub mod rev;
diff --git a/cranelift/isle/veri/veri/src/encoded/popcnt.rs b/cranelift/isle/veri/veri/src/encoded/popcnt.rs
new file mode 100644
index 000000000000..47f27c3cd55b
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/encoded/popcnt.rs
@@ -0,0 +1,46 @@
+use easy_smt::*;
+
+fn declare(smt: &mut Context, name: String, val: SExpr) -> SExpr {
+    smt.declare_const(name.clone(), val).unwrap();
+    smt.atom(name)
+}
+
+fn zero_extend(smt: &mut Context, padding: usize, value: SExpr) -> SExpr {
+    if padding == 0 {
+        return value;
+    }
+    smt.list(vec![
+        smt.list(vec![
+            smt.atoms().und,
+            smt.atom("zero_extend"),
+            smt.numeral(padding),
+        ]),
+        value,
+    ])
+}
+
+pub fn popcnt(smt: &mut Context, ty: usize, x: SExpr, id: usize) -> SExpr {
+    log::debug!("popcnt encoding: {ty}");
+    // Only use the number of bits necessary to calculate the result
+    // max = 2^(n-1) - 1; n = floor(log_2(n)) + 1
+    let bits_for_result: usize = ty.ilog2().try_into().unwrap();
+    let bits_for_result = bits_for_result + 1;
+    let mut bits: Vec<_> = (0..ty)
+        .map(|i| zero_extend(smt, bits_for_result - 1, smt.extract(i as i32, i as i32, x)))
+        .collect();
+    let initial = bits.pop().unwrap();
+    let r = bits.iter().fold(initial, |a, b| smt.bvadd(a, *b));
+
+    let id = format!("{ty}_{id}");
+    let result = declare(
+        smt,
+        format!("popcnt_{id}"),
+        smt.list(vec![
+            smt.atoms().und,
+            smt.atom("BitVec"),
+            smt.numeral(bits_for_result),
+        ]),
+    );
+    smt.assert(smt.eq(result, r)).unwrap();
+    zero_extend(smt, ty - bits_for_result, result)
+}
diff --git a/cranelift/isle/veri/veri/src/encoded/rev.rs b/cranelift/isle/veri/veri/src/encoded/rev.rs
new file mode 100644
index 000000000000..98b30952fdd6
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/encoded/rev.rs
@@ -0,0 +1,326 @@
+use easy_smt::*;
+
+fn declare(smt: &mut Context, name: String, val: SExpr) -> SExpr {
+    smt.declare_const(name.clone(), val).unwrap();
+    smt.atom(name)
+}
+
+pub fn rev64(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
+    // Generated code.
+    let x1 = declare(
+        smt,
+        format!("x1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.eq(
+        x1,
+        smt.bvor(
+            smt.bvlshr(x, smt.atom("#x0000000000000020")),
+            smt.bvshl(x, smt.atom("#x0000000000000020")),
+        ),
+    ));
+    let x2 = declare(
+        smt,
+        format!("x2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.eq(
+        x2,
+        smt.bvor(
+            smt.bvlshr(
+                smt.bvand(x1, smt.atom("#xffff0000ffff0000")),
+                smt.atom("#x0000000000000010"),
+            ),
+            smt.bvshl(
+                smt.bvand(x1, smt.atom("#x0000ffff0000ffff")),
+                smt.atom("#x0000000000000010"),
+            ),
+        ),
+    ));
+    let x3 = declare(
+        smt,
+        format!("x3_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.eq(
+        x3,
+        smt.bvor(
+            smt.bvlshr(
+                smt.bvand(x2, smt.atom("#xff00ff00ff00ff00")),
+                smt.atom("#x0000000000000008"),
+            ),
+            smt.bvshl(
+                smt.bvand(x2, smt.atom("#x00ff00ff00ff00ff")),
+                smt.atom("#x0000000000000008"),
+            ),
+        ),
+    ));
+    let x4 = declare(
+        smt,
+        format!("x4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.eq(
+        x4,
+        smt.bvor(
+            smt.bvlshr(
+                smt.bvand(x3, smt.atom("#xf0f0f0f0f0f0f0f0")),
+                smt.atom("#x0000000000000004"),
+            ),
+            smt.bvshl(
+                smt.bvand(x3, smt.atom("#x0f0f0f0f0f0f0f0f")),
+                smt.atom("#x0000000000000004"),
+            ),
+        ),
+    ));
+    let x5 = declare(
+        smt,
+        format!("x5_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.eq(
+        x5,
+        smt.bvor(
+            smt.bvlshr(
+                smt.bvand(x4, smt.atom("#xcccccccccccccccc")),
+                smt.atom("#x0000000000000002"),
+            ),
+            smt.bvshl(
+                smt.bvand(x4, smt.atom("#x3333333333333333")),
+                smt.atom("#x0000000000000002"),
+            ),
+        ),
+    ));
+    let rev64ret = declare(
+        smt,
+        format!("rev64ret_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(64)]),
+    );
+    let _ = smt.assert(smt.eq(
+        rev64ret,
+        smt.bvor(
+            smt.bvlshr(
+                smt.bvand(x5, smt.atom("#xaaaaaaaaaaaaaaaa")),
+                smt.atom("#x0000000000000001"),
+            ),
+            smt.bvshl(
+                smt.bvand(x5, smt.atom("#x5555555555555555")),
+                smt.atom("#x0000000000000001"),
+            ),
+        ),
+    ));
+
+    rev64ret
+}
+
+pub fn rev32(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
+    let x = smt.extract(31, 0, x);
+
+    // Generated code.
+    let x1 = declare(
+        smt,
+        format!("x1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let _ = smt.assert(smt.eq(
+        x1,
+        smt.bvor(
+            smt.bvlshr(x, smt.atom("#x00000010")),
+            smt.bvshl(x, smt.atom("#x00000010")),
+        ),
+    ));
+    let x2 = declare(
+        smt,
+        format!("x2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let _ = smt.assert(smt.eq(
+        x2,
+        smt.bvor(
+            smt.bvlshr(
+                smt.bvand(x1, smt.atom("#xff00ff00")),
+                smt.atom("#x00000008"),
+            ),
+            smt.bvshl(
+                smt.bvand(x1, smt.atom("#x00ff00ff")),
+                smt.atom("#x00000008"),
+            ),
+        ),
+    ));
+    let x3 = declare(
+        smt,
+        format!("x3_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let _ = smt.assert(smt.eq(
+        x3,
+        smt.bvor(
+            smt.bvlshr(
+                smt.bvand(x2, smt.atom("#xf0f0f0f0")),
+                smt.atom("#x00000004"),
+            ),
+            smt.bvshl(
+                smt.bvand(x2, smt.atom("#x0f0f0f0f")),
+                smt.atom("#x00000004"),
+            ),
+        ),
+    ));
+    let x4 = declare(
+        smt,
+        format!("x4_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let _ = smt.assert(smt.eq(
+        x4,
+        smt.bvor(
+            smt.bvlshr(
+                smt.bvand(x3, smt.atom("#xcccccccc")),
+                smt.atom("#x00000002"),
+            ),
+            smt.bvshl(
+                smt.bvand(x3, smt.atom("#x33333333")),
+                smt.atom("#x00000002"),
+            ),
+        ),
+    ));
+    let rev32ret = declare(
+        smt,
+        format!("rev32ret_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(32)]),
+    );
+    let _ = smt.assert(smt.eq(
+        rev32ret,
+        smt.bvor(
+            smt.bvlshr(
+                smt.bvand(x4, smt.atom("#xaaaaaaaa")),
+                smt.atom("#x00000001"),
+            ),
+            smt.bvshl(
+                smt.bvand(x4, smt.atom("#x55555555")),
+                smt.atom("#x00000001"),
+            ),
+        ),
+    ));
+
+    rev32ret
+}
+
+pub fn rev16(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
+    let x = smt.extract(15, 0, x);
+
+    // Generated code.
+    let x1 = declare(
+        smt,
+        format!("x1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let _ = smt.assert(smt.eq(
+        x1,
+        smt.bvor(
+            smt.bvlshr(x, smt.atom("#x0008")),
+            smt.bvshl(x, smt.atom("#x0008")),
+        ),
+    ));
+    let x2 = declare(
+        smt,
+        format!("x2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let _ = smt.assert(smt.eq(
+        x2,
+        smt.bvor(
+            smt.bvlshr(smt.bvand(x1, smt.atom("#xf0f0")), smt.atom("#x0004")),
+            smt.bvshl(smt.bvand(x1, smt.atom("#x0f0f")), smt.atom("#x0004")),
+        ),
+    ));
+    let x3 = declare(
+        smt,
+        format!("x3_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let _ = smt.assert(smt.eq(
+        x3,
+        smt.bvor(
+            smt.bvlshr(smt.bvand(x2, smt.atom("#xcccc")), smt.atom("#x0002")),
+            smt.bvshl(smt.bvand(x2, smt.atom("#x3333")), smt.atom("#x0002")),
+        ),
+    ));
+    let rev16ret = declare(
+        smt,
+        format!("rev16ret_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(16)]),
+    );
+    let _ = smt.assert(smt.eq(
+        rev16ret,
+        smt.bvor(
+            smt.bvlshr(smt.bvand(x3, smt.atom("#xaaaa")), smt.atom("#x0001")),
+            smt.bvshl(smt.bvand(x3, smt.atom("#x5555")), smt.atom("#x0001")),
+        ),
+    ));
+
+    // let padding = smt.new_fresh_bits(smt.bitwidth - 16);
+    // smt.concat(padding, rev16ret)
+    rev16ret
+}
+
+pub fn rev8(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
+    let x = smt.extract(7, 0, x);
+
+    // Generated code.
+    let x1 = declare(
+        smt,
+        format!("x1_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let _ = smt.assert(smt.eq(
+        x1,
+        smt.bvor(
+            smt.bvlshr(x, smt.atom("#x04")),
+            smt.bvshl(x, smt.atom("#x04")),
+        ),
+    ));
+    let x2 = declare(
+        smt,
+        format!("x2_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let _ = smt.assert(smt.eq(
+        x2,
+        smt.bvor(
+            smt.bvlshr(smt.bvand(x1, smt.atom("#xcc")), smt.atom("#x02")),
+            smt.bvshl(smt.bvand(x1, smt.atom("#x33")), smt.atom("#x02")),
+        ),
+    ));
+    let rev8ret = declare(
+        smt,
+        format!("rev8ret_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(8)]),
+    );
+    let _ = smt.assert(smt.eq(
+        rev8ret,
+        smt.bvor(
+            smt.bvlshr(smt.bvand(x2, smt.atom("#xaa")), smt.atom("#x01")),
+            smt.bvshl(smt.bvand(x2, smt.atom("#x55")), smt.atom("#x01")),
+        ),
+    ));
+
+    // let padding = smt.new_fresh_bits(smt.bitwidth - 8);
+    // smt.concat(padding, rev8ret)
+    rev8ret
+}
+
+pub fn rev1(smt: &mut Context, x: SExpr, id: usize) -> SExpr {
+    let x = smt.extract(0, 0, x);
+
+    // Generated code.
+    let rev1ret = declare(
+        smt,
+        format!("rev1ret_{id}", id = id),
+        smt.list(vec![smt.atoms().und, smt.atom("BitVec"), smt.numeral(1)]),
+    );
+    let _ = smt.assert(smt.eq(rev1ret, x));
+
+    // let padding = smt.new_fresh_bits(smt.bitwidth - 1);
+    // smt.concat(padding, rev1ret)
+    rev1ret
+}
diff --git a/cranelift/isle/veri/veri/src/expand.rs b/cranelift/isle/veri/veri/src/expand.rs
new file mode 100644
index 000000000000..6b28776855aa
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/expand.rs
@@ -0,0 +1,878 @@
+use crate::{program::Program, reachability::Reachability};
+use anyhow::{bail, format_err, Result};
+use cranelift_isle::{
+    disjointsets::DisjointSets,
+    sema::{RuleId, TermId},
+    trie_again::{Binding, BindingId, Constraint, Rule, RuleSet},
+};
+use std::collections::{HashMap, HashSet};
+
+#[derive(Debug, Clone)]
+pub enum Constrain {
+    Match(BindingId, Constraint),
+    NotAll(Vec<Constrain>),
+}
+
+impl Constrain {
+    fn bindings(&self) -> Vec<BindingId> {
+        match self {
+            Constrain::Match(binding_id, _) => vec![*binding_id],
+            Constrain::NotAll(constrains) => constrains.iter().flat_map(|c| c.bindings()).collect(),
+        }
+    }
+
+    fn substitute(&self, reindex: &Reindex) -> Self {
+        match self {
+            Constrain::Match(binding_id, constraint) => {
+                Constrain::Match(reindex.id(*binding_id), *constraint)
+            }
+            Constrain::NotAll(constrains) => {
+                Constrain::NotAll(constrains.iter().map(|c| c.substitute(reindex)).collect())
+            }
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Expansion {
+    pub term: TermId,
+    pub rules: Vec<RuleId>,
+    pub negated: Vec<RuleId>,
+    pub bindings: Vec<Option<Binding>>,
+    // QUESTION(mbm): are multiple constraints per binding necessary?
+    pub constraints: Vec<Constrain>,
+    pub equals: DisjointSets<BindingId>,
+    pub parameters: Vec<BindingId>,
+    pub result: BindingId,
+}
+
+impl Expansion {
+    /// Check basic feasibility of the expansion.
+    ///
+    /// A false return value means the expansion is known to never be viable.
+    /// However, a successful feasibility check leaves open the possibility that
+    /// the expansion is inapplicable for other reasons.
+    pub fn is_feasible(&self) -> bool {
+        // Assert data structure invariants.
+        self.validate();
+
+        // Check if any constraints are incompatible.
+        for constrain in &self.constraints {
+            match constrain {
+                Constrain::Match(binding_id, constraint) => {
+                    let binding = self.bindings[binding_id.index()]
+                        .as_ref()
+                        .expect("constrained binding must be defined");
+                    if !constraint.compatible(binding) {
+                        return false;
+                    }
+                }
+                Constrain::NotAll(_) => {
+                    // Conservatively assume negated constraints can be met.
+                    continue;
+                }
+            }
+        }
+
+        true
+    }
+
+    fn constrain(&mut self, constrain: Constrain) {
+        self.constraints.push(constrain);
+    }
+
+    fn add_match(&mut self, binding_id: BindingId, constraint: Constraint) {
+        self.constrain(Constrain::Match(binding_id, constraint));
+    }
+
+    fn push_binding(&mut self, binding: Binding) -> BindingId {
+        let binding_id = self.bindings.len().try_into().unwrap();
+        self.bindings.push(Some(binding));
+        binding_id
+    }
+
+    fn validate(&self) {
+        // TODO(mbm): return errors in expansion validation rather than assert?
+
+        // Bindings: all references should be valid.
+        for binding in self.bindings.iter().flatten() {
+            for source in binding.sources() {
+                assert!(self.is_defined(*source));
+            }
+        }
+
+        // Constraints: should refer to defined bindings.
+        for constrain in &self.constraints {
+            for binding_id in constrain.bindings() {
+                assert!(self.is_defined(binding_id));
+            }
+        }
+
+        // Parameters: should be defined argument bindings.
+        for binding in &self.parameters {
+            assert!(matches!(
+                self.binding(*binding),
+                Some(Binding::Argument { .. })
+            ));
+        }
+
+        // Result: should be defined.
+        assert!(self.is_defined(self.result));
+    }
+
+    fn is_defined(&self, binding_id: BindingId) -> bool {
+        self.binding(binding_id).is_some()
+    }
+
+    pub fn binding(&self, binding_id: BindingId) -> Option<&Binding> {
+        self.bindings.get(binding_id.index())?.as_ref()
+    }
+
+    pub fn equalities(&self) -> Vec<(BindingId, BindingId)> {
+        let mut eqs = Vec::new();
+        for (i, binding) in self.bindings.iter().enumerate() {
+            if binding.is_none() {
+                continue;
+            }
+            let binding_id = i.try_into().unwrap();
+            if let Some(eq) = self.equals.find(binding_id) {
+                if eq != binding_id {
+                    eqs.push((binding_id, eq));
+                }
+            }
+        }
+        eqs
+    }
+
+    pub fn terms(&self, prog: &Program) -> Vec<TermId> {
+        let mut terms: Vec<_> = self
+            .bindings
+            .iter()
+            .flatten()
+            .filter_map(|b| b.term(&prog.tyenv, &prog.termenv))
+            .collect();
+        // TODO(mbm): dedupe and preserve order
+        terms.sort();
+        terms.dedup();
+        terms
+    }
+
+    /// Tags that appear on rules and term in the expansion.
+    pub fn tags(&self, prog: &Program) -> HashSet<String> {
+        let mut tags = HashSet::new();
+
+        // Root term
+        if let Some(term_tags) = prog.specenv.term_tags.get(&self.term) {
+            tags = &tags | term_tags;
+        }
+
+        // Rules
+        for rule_id in &self.rules {
+            if let Some(rule_tags) = prog.specenv.rule_tags.get(rule_id) {
+                tags = &tags | rule_tags;
+            }
+        }
+
+        // Terms
+        for term_id in self.terms(prog) {
+            if let Some(term_tags) = prog.specenv.term_tags.get(&term_id) {
+                tags = &tags | term_tags;
+            }
+        }
+
+        tags
+    }
+
+    fn constructor_bindings(&self) -> Vec<(BindingId, TermId)> {
+        self.bindings
+            .iter()
+            .enumerate()
+            .flat_map(|(i, binding)| match binding {
+                Some(Binding::Constructor { term, .. }) => Some((i.try_into().unwrap(), *term)),
+                _ => None,
+            })
+            .collect()
+    }
+
+    fn substitute(&mut self, target: BindingId, replace: BindingId) {
+        // Reindex bindings.
+        let mut reindex = Reindex::new();
+        reindex.map(target, replace);
+        for binding in self.bindings.iter_mut().flatten() {
+            *binding = reindex.binding(binding);
+        }
+
+        // Delete the target binding.
+        self.bindings[target.index()] = None;
+
+        // Constraints.
+        self.constraints = self
+            .constraints
+            .iter()
+            .map(|c| c.substitute(&reindex))
+            .collect();
+
+        // Result.
+        self.result = reindex.id(self.result);
+    }
+}
+
+/// Chaining configuration.
+pub struct Chaining<'a> {
+    prog: &'a Program,
+    term_rule_sets: &'a HashMap<TermId, RuleSet>,
+    reach: Reachability,
+    exclude: HashSet<TermId>,
+    include: HashSet<TermId>,
+    include_macros: bool,
+    max_rules: usize,
+    default: bool,
+}
+
+impl<'a> Chaining<'a> {
+    pub fn new(prog: &'a Program, term_rule_sets: &'a HashMap<TermId, RuleSet>) -> Result<Self> {
+        Ok(Self {
+            prog,
+            term_rule_sets,
+            reach: Reachability::build(term_rule_sets),
+            include: HashSet::new(),
+            exclude: HashSet::new(),
+            include_macros: true,
+            max_rules: 0,
+            default: false,
+        })
+    }
+
+    pub fn chain_term(&mut self, term_name: &str) -> Result<()> {
+        let term_id = self
+            .prog
+            .get_term_by_name(term_name)
+            .ok_or(format_err!("unknown term {term_name}"))?;
+        self.include.insert(term_id);
+        Ok(())
+    }
+
+    pub fn chain_terms(&mut self, term_names: &Vec<String>) -> Result<()> {
+        for term_name in term_names {
+            self.chain_term(term_name)?;
+        }
+        Ok(())
+    }
+
+    /// Set whether to chain "macro" terms. Macro terms are wrapper terms with
+    /// only one rule that has no constraints.
+    pub fn chain_macros(&mut self, enabled: bool) {
+        self.include_macros = enabled;
+    }
+
+    pub fn set_max_rules(&mut self, max_rules: usize) {
+        self.max_rules = max_rules;
+    }
+
+    pub fn exclude_chain_term(&mut self, term_name: &str) -> Result<()> {
+        let term_id = self
+            .prog
+            .get_term_by_name(term_name)
+            .ok_or(format_err!("unknown term {term_name}"))?;
+        self.exclude.insert(term_id);
+        Ok(())
+    }
+
+    pub fn exclude_chain_terms(&mut self, term_names: &Vec<String>) -> Result<()> {
+        for term_name in term_names {
+            self.exclude_chain_term(term_name)?;
+        }
+        Ok(())
+    }
+
+    /// Configure whether terms should be considered for chaining by default, if
+    /// no other rules apply.
+    pub fn set_default(&mut self, default: bool) {
+        self.default = default;
+    }
+
+    /// Report whether the term has expansions.
+    ///
+    /// From the point of view of the expansion graph, this means the term is
+    /// not a leaf node.  Therefore, we can either apply chaining or produce
+    /// expansions rooted at this term.
+    pub fn is_expandable(&self, term_id: TermId) -> bool {
+        // Is it an internal constructor?
+        let term = self.prog.term(term_id);
+        if !term.has_internal_constructor() {
+            return false;
+        }
+
+        // Term should have rules.
+        if self.num_rules(term_id) == 0 {
+            return false;
+        }
+
+        true
+    }
+
+    /// Reports whether the given term can be chained.
+    ///
+    /// Terms can be chained if they are expandable and acyclic.
+    pub fn is_chainable(&self, term_id: TermId) -> bool {
+        // At minimum, it should be a term that has expansions.
+        if !self.is_expandable(term_id) {
+            return false;
+        }
+
+        // Cyclic terms cannot be chained.
+        if self.reach.is_cyclic(term_id) {
+            return false;
+        }
+
+        true
+    }
+
+    /// Validate chaining configuration.
+    pub fn validate(&self) -> Result<()> {
+        for term_id in (0..self.prog.termenv.terms.len()).map(TermId) {
+            if self.has_chain_attribute(term_id) && !self.is_chainable(term_id) {
+                bail!(
+                    "term '{name}' has chain attribute but is not chainable",
+                    name = self.prog.term_name(term_id)
+                );
+            }
+        }
+        Ok(())
+    }
+
+    pub fn should_chain(&self, term_id: TermId) -> bool {
+        // Check baseline requirements.
+        if !self.is_chainable(term_id) {
+            return false;
+        }
+
+        // Terms with specs should not be chained.
+        if self.prog.specenv.has_spec(term_id) {
+            return false;
+        }
+
+        // Explicit exclusions.
+        if self.exclude.contains(&term_id) {
+            return false;
+        }
+
+        // Explicit inclusions.
+        if self.include.contains(&term_id) {
+            return true;
+        }
+
+        // Marked with chaining attribute.
+        if self.prog.specenv.chain.contains(&term_id) {
+            return true;
+        }
+
+        // Chain macros, if configured.
+        if self.include_macros && self.is_macro(term_id) {
+            return true;
+        }
+
+        // Max rules threshold, if set.
+        if self.max_rules > 0 && self.num_rules(term_id) > self.max_rules {
+            return false;
+        }
+
+        // Default fallback.
+        self.default
+    }
+
+    fn has_chain_attribute(&self, term_id: TermId) -> bool {
+        self.prog.specenv.chain.contains(&term_id)
+    }
+
+    fn num_rules(&self, term_id: TermId) -> usize {
+        self.term_rule_sets
+            .get(&term_id)
+            .map(|rule_set| rule_set.rules.len())
+            .unwrap_or_default()
+    }
+
+    fn is_macro(&self, term_id: TermId) -> bool {
+        // "Macro" terms have only one rule.
+        if self.num_rules(term_id) != 1 {
+            return false;
+        }
+
+        // Rule should be "trivial".
+        let rule = &self.term_rule_sets[&term_id].rules[0];
+        rule.total_constraints() == 0
+    }
+}
+
+/// Partially completed expansion.
+struct Partial {
+    /// Current state of the expansion.
+    expansion: Expansion,
+
+    /// Stack of bindings to apply chaining to. May be non-exhaustive.
+    chain_candidates: Vec<BindingId>,
+}
+
+pub struct Expander<'a> {
+    prog: &'a Program,
+    term_rule_sets: &'a HashMap<TermId, RuleSet>,
+
+    /// Chaining configuration: which terms should be chained.
+    chaining: Chaining<'a>,
+
+    /// Whether to drop expansions as soon as they are deemed to be infeasible.
+    prune_infeasible: bool,
+
+    /// Expansions under construction.
+    stack: Vec<Partial>,
+
+    /// Root terms expansion has been initiated for.
+    roots: HashSet<TermId>,
+
+    /// Completed expansions.
+    complete: Vec<Expansion>,
+}
+
+impl<'a> Expander<'a> {
+    pub fn new(
+        prog: &'a Program,
+        term_rule_sets: &'a HashMap<TermId, RuleSet>,
+        chaining: Chaining<'a>,
+    ) -> Self {
+        Self {
+            prog,
+            term_rule_sets,
+            chaining,
+            prune_infeasible: true,
+            stack: Vec::new(),
+            roots: HashSet::new(),
+            complete: Vec::new(),
+        }
+    }
+
+    /// Add the given named term as an expansion root.
+    pub fn add_root_term_name(&mut self, term_name: &str) -> Result<()> {
+        let term_id = self
+            .prog
+            .get_term_by_name(term_name)
+            .ok_or(format_err!("unknown term {term_name}"))?;
+        self.add_root(term_id);
+        Ok(())
+    }
+
+    /// Add the given term as an expansion root. That is, start expanding rules
+    /// from this point.
+    pub fn add_root(&mut self, term_id: TermId) {
+        // Skip if the root has already been added.
+        if self.roots.contains(&term_id) {
+            return;
+        }
+
+        // Initialize an expansion at this root.
+        self.constructor(term_id);
+
+        // Record root.
+        self.roots.insert(term_id);
+    }
+
+    // Push an initial expansion for a constructor call of the given term.
+    fn constructor(&mut self, term_id: TermId) {
+        // Lookup term.
+        let term = self.prog.term(term_id);
+        assert!(term.has_constructor());
+
+        // Push argument bindings.
+        let sig = term
+            .constructor_sig(&self.prog.tyenv)
+            .expect("should have constructor signature");
+        let mut bindings = Vec::new();
+        let mut parameters = Vec::new();
+        for i in 0..sig.param_tys.len() {
+            let parameter = bindings.len().try_into().unwrap();
+            bindings.push(Some(Binding::Argument {
+                index: i.try_into().unwrap(),
+            }));
+            parameters.push(parameter);
+        }
+
+        // Binding for the constructor call.
+        let result = bindings.len().try_into().unwrap();
+        bindings.push(Some(Binding::Constructor {
+            term: term_id,
+            parameters: parameters.clone().into(),
+            instance: 0,
+        }));
+
+        // Root constructor call should be the first term to be expanded.
+        let chain_candidates = vec![result];
+
+        // Store.
+        let expansion = Expansion {
+            term: term_id,
+            rules: Vec::new(),
+            negated: Vec::new(),
+            bindings,
+            constraints: Vec::new(),
+            equals: DisjointSets::default(),
+            parameters,
+            result,
+        };
+        assert!(expansion.is_feasible());
+        self.stack.push(Partial {
+            expansion,
+            chain_candidates,
+        });
+    }
+
+    /// Set whether to prune infeasible expansions. If enabled, expansions will
+    /// be dropped as soon as they are deemed to be not feasible.
+    pub fn set_prune_infeasible(&mut self, enabled: bool) {
+        self.prune_infeasible = enabled;
+    }
+
+    fn finish(&mut self, expansion: Expansion) {
+        // Cascade into any remaining constructors.
+        //
+        // Any remaining constructor calls could not be chained. Therefore, in
+        // order to consider rules that apply to these terms, we need to
+        // initiate expansion from them as root terms.
+        for (_, term_id) in expansion.constructor_bindings() {
+            if self.chaining.is_expandable(term_id) {
+                self.add_root(term_id);
+            }
+        }
+
+        // Add to completed list.
+        //
+        // As an internal consistency check, ensure we have produced a valid
+        // result.
+        expansion.validate();
+        self.complete.push(expansion);
+    }
+
+    pub fn chaining(&self) -> &Chaining {
+        &self.chaining
+    }
+
+    pub fn expansions(&self) -> &Vec<Expansion> {
+        &self.complete
+    }
+
+    pub fn expand(&mut self) {
+        while let Some(partial) = self.stack.pop() {
+            self.extend(partial);
+        }
+    }
+
+    fn extend(&mut self, partial: Partial) {
+        let Partial {
+            expansion,
+            chain_candidates,
+        } = partial;
+
+        // Determine candidates for chaining.
+        //
+        // If we have pre-existing candidates at this stage, we'll process
+        // those. Otherwise, revisit the expansion and see if previous chain
+        // applications have produced more candidates.
+        let mut chain_candidates = if !chain_candidates.is_empty() {
+            chain_candidates
+        } else {
+            self.chain_candidates(&expansion)
+        };
+
+        // Select a candidate to chain. If none, we're done.
+        let Some(chain_binding_id) = chain_candidates.pop() else {
+            self.finish(expansion);
+            return;
+        };
+
+        // Chain constructor.
+        let binding = &expansion.bindings[chain_binding_id.index()];
+        let Some(Binding::Constructor {
+            term, parameters, ..
+        }) = binding
+        else {
+            unreachable!("expect constructor binding")
+        };
+
+        let rule_set = &self.term_rule_sets[term];
+        assert!(!rule_set.rules.is_empty());
+        for rule in rule_set.rules.iter().rev() {
+            // Apply rule.
+            let mut apply = Application::new(expansion.clone());
+            apply.rule(rule_set, rule, parameters, chain_binding_id);
+
+            // Apply negations of higher-priority overlapping rules that are
+            // tagged to indicate priority is significant.
+            if let Some(overlaps) = self.prog.overlaps.get(&rule.id) {
+                for other in rule_set.rules.iter().rev() {
+                    let priority_significant = self.prog.specenv.priority.contains(&other.id);
+                    if priority_significant && overlaps.contains(&other.id) {
+                        apply.negation(rule_set, other);
+                    }
+                }
+            }
+
+            // Finalize the chaining application.
+            let chained = apply.build();
+
+            // Push onto stack for further expansion, optionally checking if the
+            // current partial state is feasible.
+            if !self.prune_infeasible || chained.is_feasible() {
+                self.stack.push(Partial {
+                    expansion: chained,
+                    chain_candidates: chain_candidates.clone(),
+                });
+            }
+        }
+    }
+
+    // Identify bindings that could be chained.
+    fn chain_candidates(&mut self, expansion: &Expansion) -> Vec<BindingId> {
+        expansion
+            .constructor_bindings()
+            .iter()
+            .filter_map(|(binding_id, term_id)| {
+                if self.chaining.should_chain(*term_id) {
+                    Some(*binding_id)
+                } else {
+                    None
+                }
+            })
+            .collect()
+    }
+}
+
+struct Substitution {
+    target: BindingId,
+    replace: BindingId,
+}
+
+struct Application {
+    expansion: Expansion,
+    substitutions: Vec<Substitution>,
+    import_reindex: Reindex,
+}
+
+impl Application {
+    fn new(expansion: Expansion) -> Self {
+        Self {
+            expansion,
+            substitutions: Vec::new(),
+            import_reindex: Reindex::new(),
+        }
+    }
+
+    fn rule(
+        &mut self,
+        rule_set: &RuleSet,
+        rule: &Rule,
+        parameters: &[BindingId],
+        call_site: BindingId,
+    ) {
+        // Record the application of this rule.
+        self.expansion.rules.push(rule.id);
+
+        // Arguments.
+        for (i, parameter) in parameters.iter().enumerate() {
+            // Lookup binding ID from the source rule.
+            let arg = Binding::Argument {
+                index: i.try_into().unwrap(),
+            };
+            let binding_id = rule_set
+                .find_binding(&arg)
+                .expect("should have argument binding");
+
+            // Import into expansion.
+            let arg_binding_id = self.add_binding(rule_set, binding_id);
+
+            // Substitute argument with the parameter.
+            self.substitutions.push(Substitution {
+                target: arg_binding_id,
+                replace: *parameter,
+            });
+        }
+
+        // Constraints.
+        for i in 0..rule_set.bindings.len() {
+            let binding_id = i.try_into().unwrap();
+            if let Some(constraint) = rule.get_constraint(binding_id) {
+                let expansion_binding_id = self.add_binding(rule_set, binding_id);
+                self.expansion.add_match(expansion_binding_id, constraint);
+            }
+        }
+
+        // Equals.
+        for i in 0..rule_set.bindings.len() {
+            let binding_id = i.try_into().unwrap();
+            if let Some(equal_binding_id) = rule.equals.find(binding_id) {
+                if equal_binding_id != binding_id {
+                    let expansion_binding_id = self.add_binding(rule_set, binding_id);
+                    let expansion_equal_binding_id = self.add_binding(rule_set, equal_binding_id);
+                    self.expansion
+                        .equals
+                        .merge(expansion_binding_id, expansion_equal_binding_id);
+                }
+            }
+        }
+
+        // TODO: iterators, prio?
+
+        // Impure.
+        for impure_binding_id in &rule.impure {
+            self.add_binding(rule_set, *impure_binding_id);
+        }
+
+        // Result.
+        //
+        // Once imported, the callsite should be substituted for the result binding.
+        let result_binding_id = self.add_binding(rule_set, rule.result);
+        self.substitutions.push(Substitution {
+            target: call_site,
+            replace: result_binding_id,
+        });
+    }
+
+    fn build(mut self) -> Expansion {
+        // Process substitutions.
+        for substitution in self.substitutions.iter().rev() {
+            self.expansion
+                .substitute(substitution.target, substitution.replace);
+        }
+
+        // Return expanded rule.
+        self.expansion
+    }
+
+    fn negation(&mut self, rule_set: &RuleSet, rule: &Rule) {
+        // Record negation.
+        self.expansion.negated.push(rule.id);
+
+        // Collect the constraints required.
+        let mut constraints = Vec::new();
+        for i in 0..rule_set.bindings.len() {
+            let binding_id = i.try_into().unwrap();
+            if let Some(constraint) = rule.get_constraint(binding_id) {
+                let expansion_binding_id = self.add_binding(rule_set, binding_id);
+                constraints.push(Constrain::Match(expansion_binding_id, constraint));
+            }
+        }
+
+        // Require their negation.
+        self.expansion.constrain(Constrain::NotAll(constraints));
+
+        // TODO(mbm): negation of equality constraints
+    }
+
+    fn add_binding(&mut self, rule_set: &RuleSet, binding_id: BindingId) -> BindingId {
+        // Check if it has already been added.
+        if self.import_reindex.is_mapped(binding_id) {
+            return self.import_reindex.id(binding_id);
+        }
+
+        // Add dependencies first.
+        let binding = &rule_set.bindings[binding_id.index()];
+        for source in binding.sources() {
+            self.add_binding(rule_set, *source);
+        }
+
+        // Reindex this binding.
+        let reindexed = self.import_reindex.binding(binding);
+
+        // Insert into expansion bindings list.
+        let expansion_binding_id = self.expansion.push_binding(reindexed);
+
+        // Record binding mapping.
+        self.import_reindex.map(binding_id, expansion_binding_id);
+        expansion_binding_id
+    }
+}
+
+/// Reindexing binding IDs.
+struct Reindex {
+    to: HashMap<BindingId, BindingId>,
+}
+
+impl Reindex {
+    fn new() -> Self {
+        Self { to: HashMap::new() }
+    }
+
+    fn is_mapped(&self, binding_id: BindingId) -> bool {
+        self.to.contains_key(&binding_id)
+    }
+
+    fn map(&mut self, from: BindingId, to: BindingId) {
+        self.to.insert(from, to);
+    }
+
+    fn id(&self, binding_id: BindingId) -> BindingId {
+        self.to.get(&binding_id).copied().unwrap_or(binding_id)
+    }
+
+    fn ids(&self, binding_ids: &[BindingId]) -> Box<[BindingId]> {
+        binding_ids
+            .iter()
+            .map(|binding_id| self.id(*binding_id))
+            .collect()
+    }
+
+    fn binding(&self, binding: &Binding) -> Binding {
+        match binding {
+            Binding::Argument { .. } | Binding::ConstInt { .. } | Binding::ConstPrim { .. } => {
+                binding.clone()
+            }
+
+            Binding::Extractor { term, parameter } => Binding::Extractor {
+                term: *term,
+                parameter: self.id(*parameter),
+            },
+
+            Binding::Constructor {
+                term,
+                parameters,
+                instance,
+            } => Binding::Constructor {
+                term: *term,
+                parameters: self.ids(parameters),
+                instance: *instance,
+            },
+
+            Binding::MakeVariant {
+                ty,
+                variant,
+                fields,
+            } => Binding::MakeVariant {
+                ty: *ty,
+                variant: *variant,
+                fields: self.ids(fields),
+            },
+
+            Binding::MatchVariant {
+                source,
+                variant,
+                field,
+            } => Binding::MatchVariant {
+                source: self.id(*source),
+                variant: *variant,
+                field: *field,
+            },
+
+            Binding::MakeSome { inner } => Binding::MakeSome {
+                inner: self.id(*inner),
+            },
+
+            Binding::MatchSome { source } => Binding::MatchSome {
+                source: self.id(*source),
+            },
+
+            Binding::MatchTuple { source, field } => Binding::MatchTuple {
+                source: self.id(*source),
+                field: *field,
+            },
+
+            Binding::Iterator { .. } => unimplemented!("iterator bindings not supported"),
+        }
+    }
+}
diff --git a/cranelift/isle/veri/veri/src/explorer.rs b/cranelift/isle/veri/veri/src/explorer.rs
new file mode 100644
index 000000000000..d998454dd78a
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/explorer.rs
@@ -0,0 +1,804 @@
+use anyhow::{bail, Result};
+use cranelift_isle::{
+    lexer::Pos,
+    sema::{RuleId, TermId, TypeId},
+    trie_again::BindingId,
+};
+
+use crate::{
+    debug::{binding_string, constrain_string},
+    expand::{Chaining, Expansion},
+    program::Program,
+    trie::{binding_type, BindingType},
+};
+use std::{
+    fs::File,
+    io::{self, Write},
+    path::{Component, Path, PathBuf},
+};
+
+pub struct ExplorerWriter<'a> {
+    prog: &'a Program,
+    chaining: &'a Chaining<'a>,
+    expansions: &'a Vec<Expansion>,
+
+    root: std::path::PathBuf,
+    base: std::path::PathBuf,
+    graphs: bool,
+    dev: bool,
+}
+
+impl<'a> ExplorerWriter<'a> {
+    pub fn new(
+        root: std::path::PathBuf,
+        prog: &'a Program,
+        chaining: &'a Chaining<'a>,
+        expansions: &'a Vec<Expansion>,
+    ) -> Self {
+        Self {
+            prog,
+            chaining,
+            expansions,
+            root,
+            base: PathBuf::new(),
+            graphs: false,
+            dev: true, // TODO(mbm): configurable dev mode
+        }
+    }
+
+    pub fn enable_graphs(&mut self) {
+        self.graphs = true;
+    }
+
+    pub fn write(&mut self) -> Result<()> {
+        self.init()?;
+        self.write_assets()?;
+        self.write_index()?;
+        self.write_files()?;
+        self.write_types()?;
+        self.write_terms()?;
+        self.write_rules()?;
+        self.write_expansions()?;
+        Ok(())
+    }
+
+    fn init(&self) -> Result<()> {
+        std::fs::create_dir_all(&self.root)?;
+        Ok(())
+    }
+
+    fn write_assets(&mut self) -> Result<()> {
+        // In development mode, setup a symlink.
+        if self.dev {
+            let crate_root = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+            // TODO(mbm): platform-independent symlink
+            let original = crate_root.join("src/assets");
+            let link_path = self.abs(&self.assets_dir());
+            std::os::unix::fs::symlink(original, link_path)?;
+            return Ok(());
+        }
+
+        // CSS.
+        let style_css = include_bytes!("./assets/style.css");
+        let mut output = self.create(&self.style_path())?;
+        output.write_all(style_css)?;
+
+        Ok(())
+    }
+
+    fn write_index(&mut self) -> Result<()> {
+        let mut output = self.create(&PathBuf::from("index.html"))?;
+        self.header(&mut output, "ISLE Explorer")?;
+        writeln!(
+            output,
+            r#"
+        <menu>
+            <li><a href="{files_href}">Files</a></li>
+            <li><a href="{types_href}">Types</a></li>
+            <li><a href="{terms_href}">Terms</a></li>
+            <li><a href="{rules_href}">Rules</a></li>
+            <li><a href="{expansions_href}">Expansions</a></li>
+        </menu>
+        "#,
+            files_href = self.link(&self.file_dir()),
+            types_href = self.link(&self.types_dir()),
+            terms_href = self.link(&self.terms_dir()),
+            rules_href = self.link(&self.rules_dir()),
+            expansions_href = self.link(&self.expansions_dir()),
+        )?;
+        self.footer(&mut output)?;
+        Ok(())
+    }
+
+    fn write_files(&mut self) -> Result<()> {
+        self.write_files_index()?;
+        for id in 0..self.prog.files.file_names.len() {
+            self.write_file(id)?;
+        }
+        Ok(())
+    }
+
+    fn write_files_index(&mut self) -> Result<()> {
+        let mut output = self.create(&self.file_dir().join("index.html"))?;
+        self.header(&mut output, "Files")?;
+
+        // Files.
+        writeln!(output, "<ul>")?;
+        for (id, filename) in self.prog.files.file_names.iter().enumerate() {
+            writeln!(
+                output,
+                r#"<li><a href="{link}">{filename}</a></li>"#,
+                link = self.link(&self.file_path(id)),
+            )?;
+        }
+        writeln!(output, "</ul>")?;
+
+        self.footer(&mut output)?;
+        Ok(())
+    }
+
+    fn write_file(&mut self, id: usize) -> Result<()> {
+        let mut output = self.create(&self.file_path(id))?;
+
+        // Header.
+        let filename = &self.prog.files.file_names[id];
+        let title = format!("File: {filename}");
+        self.header(&mut output, &title)?;
+
+        // Source code.
+        let file_text = &self.prog.files.file_texts[id];
+
+        writeln!(&mut output, "<pre>")?;
+        for (i, line) in file_text.lines().enumerate() {
+            let n = i + 1;
+            writeln!(
+                &mut output,
+                r#"<code id="{fragment}">{line}</code>"#,
+                fragment = self.line_url_fragment(n)
+            )?;
+        }
+        writeln!(&mut output, "</pre>")?;
+
+        // Footer.
+        self.footer(&mut output)?;
+
+        Ok(())
+    }
+
+    fn write_types(&mut self) -> Result<()> {
+        let mut output = self.create(&self.types_dir().join("index.html"))?;
+        self.header(&mut output, "Types")?;
+
+        // Types.
+        writeln!(
+            output,
+            r#"
+        <table>
+            <thead>
+                <tr>
+                    <th class="id">&num;</th>
+                    <th>Name</th>
+                    <th>Location</th>
+                    <th>Model</th>
+                </tr>
+            </thead>
+            <tbody>
+        "#
+        )?;
+        for ty in &self.prog.tyenv.types {
+            writeln!(output, "<tr>")?;
+            writeln!(output, r#"<td class="id">{id}</td>"#, id = ty.id().index())?;
+
+            // Name.
+            writeln!(output, r"<td>{name}</td>", name = ty.name(&self.prog.tyenv))?;
+
+            // Location.
+            writeln!(output, "<td>{pos}</td>", pos = self.pos(ty.pos()))?;
+
+            // Model.
+            if let Some(model) = self.prog.specenv.type_model.get(&ty.id()) {
+                // TODO(mbm): link type model to source position
+                writeln!(output, "<td>{model}</td>")?;
+            } else {
+                writeln!(output, "<td></td>")?;
+            }
+
+            writeln!(output, "</tr>")?;
+        }
+        writeln!(
+            output,
+            r#"
+            </tbody>
+        </table>
+        "#
+        )?;
+
+        self.footer(&mut output)?;
+        Ok(())
+    }
+
+    fn write_terms(&mut self) -> Result<()> {
+        let mut output = self.create(&self.terms_dir().join("index.html"))?;
+        self.header(&mut output, "Terms")?;
+
+        // Terms.
+        let term_ids = (0..self.prog.termenv.terms.len()).map(TermId);
+        self.write_terms_list(&mut output, term_ids)?;
+
+        self.footer(&mut output)?;
+        Ok(())
+    }
+
+    fn write_terms_list(
+        &self,
+        output: &mut dyn Write,
+        term_ids: impl Iterator<Item = TermId>,
+    ) -> Result<()> {
+        writeln!(
+            output,
+            r#"
+        <table>
+            <thead>
+                <tr>
+                    <th class="id">&num;</th>
+                    <th>Name</th>
+                    <th>Location</th>
+                    <th>Spec</th>
+                </tr>
+            </thead>
+            <tbody>
+        "#
+        )?;
+        for term_id in term_ids {
+            let term = self.prog.term(term_id);
+
+            writeln!(output, "<tr>")?;
+            writeln!(output, r#"<td class="id">{id}</td>"#, id = term.id.index())?;
+
+            // Name.
+            writeln!(
+                output,
+                r"<td>{name}</td>",
+                name = self.prog.term_name(term.id)
+            )?;
+
+            // Location.
+            writeln!(output, "<td>{pos}</td>", pos = self.pos(term.decl_pos))?;
+
+            // Spec.
+            if let Some(spec) = self.prog.specenv.term_spec.get(&term.id) {
+                writeln!(output, "<td>{pos}</td>", pos = self.pos(spec.pos))?;
+            } else if self.chaining.should_chain(term_id) {
+                writeln!(output, "<td>chained</td>")?;
+            } else {
+                writeln!(output, "<td></td>")?;
+            }
+
+            writeln!(output, "</tr>")?;
+        }
+        writeln!(
+            output,
+            r#"
+            </tbody>
+        </table>
+        "#
+        )?;
+        Ok(())
+    }
+
+    fn write_rules(&mut self) -> Result<()> {
+        let mut output = self.create(&self.rules_dir().join("index.html"))?;
+        self.header(&mut output, "Rules")?;
+
+        // Rules.
+        let rule_ids = (0..self.prog.termenv.rules.len()).map(RuleId);
+        self.write_rules_list(&mut output, rule_ids)?;
+
+        self.footer(&mut output)?;
+        Ok(())
+    }
+
+    fn write_rules_list(
+        &self,
+        output: &mut dyn Write,
+        rule_ids: impl Iterator<Item = RuleId>,
+    ) -> Result<()> {
+        writeln!(
+            output,
+            r#"
+        <table>
+            <thead>
+                <tr>
+                    <th class="id">&num;</th>
+                    <th>Identifier</th>
+                </tr>
+            </thead>
+            <tbody>
+        "#
+        )?;
+
+        for rule_id in rule_ids {
+            writeln!(output, "<tr>")?;
+            writeln!(output, r#"<td class="id">{id}</td>"#, id = rule_id.index())?;
+            writeln!(
+                output,
+                "<td>{rule_ref}</td>",
+                rule_ref = self.rule_ref(rule_id)
+            )?;
+            writeln!(output, "</tr>")?;
+        }
+
+        writeln!(
+            output,
+            r#"
+            </tbody>
+        </table>
+        "#
+        )?;
+        Ok(())
+    }
+
+    fn write_expansions(&mut self) -> Result<()> {
+        self.write_expansions_index()?;
+        for (id, expansion) in self.expansions.iter().enumerate() {
+            self.write_expansion(id, expansion)?;
+        }
+        Ok(())
+    }
+
+    fn write_expansions_index(&mut self) -> Result<()> {
+        let mut output = self.create(&self.expansions_dir().join("index.html"))?;
+        self.header(&mut output, "Expansions")?;
+
+        // Expansions.
+        writeln!(
+            output,
+            r#"
+        <table>
+            <thead>
+                <tr>
+                    <th>&num;</th>
+                    <th>Root</th>
+                    <th>First Rule</th>
+                    <th>Tags</th>
+                </tr>
+            </thead>
+            <tbody>
+        "#
+        )?;
+        for (id, expansion) in self.expansions.iter().enumerate() {
+            writeln!(output, "<tr>")?;
+
+            // ID
+            writeln!(
+                output,
+                r#"<td><a href="{link}">&num;{id}</a></td>"#,
+                link = self.link(&self.expansion_path(id))
+            )?;
+
+            // Root
+            writeln!(
+                output,
+                "<td>{term_ref}</td>",
+                term_ref = self.term_ref(expansion.term)
+            )?;
+
+            // First Rule
+            let rule_id = expansion
+                .rules
+                .first()
+                .expect("expansion must have at least one rule");
+            writeln!(
+                output,
+                "<td>{rule_ref}</td>",
+                rule_ref = self.rule_ref(*rule_id)
+            )?;
+
+            // Tags
+            let mut tags: Vec<String> = expansion.tags(self.prog).iter().cloned().collect();
+            tags.sort();
+            writeln!(output, "<td>{tags}</td>", tags = tags.join(", "))?;
+
+            writeln!(output, "</tr>")?;
+        }
+        writeln!(
+            output,
+            r#"
+            </tbody>
+        </table>
+        "#
+        )?;
+
+        self.footer(&mut output)?;
+        Ok(())
+    }
+
+    fn write_expansion(&mut self, id: usize, expansion: &Expansion) -> Result<()> {
+        self.write_expansion_index(id, expansion)?;
+        if self.graphs {
+            self.write_expansion_graph(id, expansion)?;
+        }
+        Ok(())
+    }
+
+    fn write_expansion_index(&mut self, id: usize, expansion: &Expansion) -> Result<()> {
+        let mut output = self.create(&self.expansion_path(id))?;
+
+        // Header.
+        let title = format!("Expansion: &num;{id}");
+        self.header(&mut output, &title)?;
+
+        // Term.
+        writeln!(
+            output,
+            "<p>Term: {term_ref}</p>",
+            term_ref = self.term_ref(expansion.term)
+        )?;
+
+        // Rules
+        writeln!(output, "<h2>Rules</h2>")?;
+        self.write_rules_list(&mut output, expansion.rules.iter().copied())?;
+
+        // Negated Rules
+        if !expansion.negated.is_empty() {
+            writeln!(output, "<h2>Negated</h2>")?;
+            self.write_rules_list(&mut output, expansion.negated.iter().copied())?;
+        }
+
+        // Terms
+        writeln!(output, "<h2>Terms</h2>")?;
+        let terms = expansion.terms(self.prog);
+        self.write_terms_list(&mut output, terms.into_iter())?;
+
+        // Bindings
+        writeln!(output, "<h2>Bindings</h2>")?;
+        if self.graphs {
+            writeln!(
+                output,
+                r#"<p>Graph: <a href="{svg_href}">SVG</a>, <a href="{dot_href}">DOT</a>.</p>"#,
+                svg_href = self.link(&self.expansion_graph_svg_path(id)),
+                dot_href = self.link(&self.expansion_graph_dot_path(id)),
+            )?;
+        }
+
+        writeln!(
+            output,
+            r#"
+        <table>
+            <thead>
+                <tr>
+                    <th>&num;</th>
+        "#
+        )?;
+        if !expansion.equals.is_empty() {
+            writeln!(output, "<th>&equals;</th>")?;
+        }
+        writeln!(
+            output,
+            r#"
+                    <th>Type</th>
+                    <th>Binding</th>
+                </tr>
+            </thead>
+            <tbody>
+        "#
+        )?;
+        let lookup_binding =
+            |binding_id: BindingId| expansion.bindings[binding_id.index()].clone().unwrap();
+        for (i, binding) in expansion.bindings.iter().enumerate() {
+            let id: BindingId = i.try_into().unwrap();
+            if let Some(binding) = binding {
+                writeln!(output, "<tr>")?;
+                let ty = binding_type(binding, expansion.term, self.prog, lookup_binding);
+
+                // ID
+                writeln!(output, "<td>{id}</td>", id = id.index())?;
+
+                // Equals
+                if let Some(eq) = expansion.equals.find(id) {
+                    if id != eq {
+                        write!(output, "<td>&equals; {}</td>", eq.index())?;
+                    }
+                }
+
+                // Type
+                writeln!(output, "<td>{ty}</td>", ty = self.binding_type(&ty))?;
+
+                // Binding
+                writeln!(
+                    output,
+                    "<td>{binding}</td>",
+                    binding = binding_string(binding, expansion.term, self.prog, lookup_binding)
+                )?;
+
+                writeln!(output, "</tr>")?;
+            }
+        }
+
+        // TODO(mbm): Parameters
+        // TODO(mbm): Result
+
+        writeln!(
+            output,
+            r#"
+            </tbody>
+        </table>
+        "#
+        )?;
+
+        // Constraints
+        writeln!(output, "<h2>Constraints</h2>")?;
+        writeln!(output, "<ul>")?;
+        for constrain in &expansion.constraints {
+            writeln!(
+                output,
+                "<li>{constrain}</li>",
+                constrain = constrain_string(constrain, &self.prog.tyenv)
+            )?;
+        }
+        writeln!(output, "</ul>")?;
+
+        // Footer.
+        self.footer(&mut output)?;
+
+        Ok(())
+    }
+
+    fn write_expansion_graph(&mut self, id: usize, expansion: &Expansion) -> Result<()> {
+        self.write_expansion_graph_dot(id, expansion)?;
+        self.generate_expansion_graph_svg(id)?;
+        Ok(())
+    }
+
+    fn write_expansion_graph_dot(&mut self, id: usize, expansion: &Expansion) -> Result<()> {
+        let mut output = self.create(&self.expansion_graph_dot_path(id))?;
+
+        // Header.
+        writeln!(&mut output, "digraph {{")?;
+        writeln!(&mut output, "\tnode [shape=box, fontname=monospace];")?;
+
+        // Binding nodes.
+        let lookup_binding =
+            |binding_id: BindingId| expansion.bindings[binding_id.index()].clone().unwrap();
+        for (i, binding) in expansion.bindings.iter().enumerate() {
+            if let Some(binding) = binding {
+                writeln!(
+                    &mut output,
+                    "\tb{i} [label=\"{i}: {}\"];",
+                    binding_string(binding, expansion.term, self.prog, lookup_binding)
+                )?;
+            }
+        }
+
+        // Edges.
+        for (i, binding) in expansion.bindings.iter().enumerate() {
+            if let Some(binding) = binding {
+                for source in binding.sources() {
+                    writeln!(&mut output, "\tb{i} -> b{j};", j = source.index())?;
+                }
+            }
+        }
+
+        writeln!(&mut output, "}}")?;
+
+        Ok(())
+    }
+
+    fn generate_expansion_graph_svg(&self, id: usize) -> Result<()> {
+        let dot_path = self.expansion_graph_dot_path(id);
+        let svg_path = self.expansion_graph_svg_path(id);
+
+        // Invoke graphviz.
+        let status = std::process::Command::new("dot")
+            .current_dir(&self.root)
+            .arg("-Tsvg")
+            .arg("-o")
+            .arg(svg_path)
+            .arg(dot_path)
+            .status()?;
+
+        if !status.success() {
+            bail!("dot exit status: {status}");
+        }
+
+        Ok(())
+    }
+
+    fn header(&self, output: &mut dyn Write, title: &str) -> io::Result<()> {
+        write!(
+            output,
+            r#"
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>{title}</title>
+    <link rel="stylesheet" href="{style_path}" />
+  </head>
+  <body>
+    <main>
+      <h1>{title}</h1>
+        "#,
+            style_path = self.link(&self.style_path())
+        )
+    }
+
+    fn footer(&self, output: &mut dyn Write) -> io::Result<()> {
+        write!(
+            output,
+            r#"
+    </main>
+  </body>
+</html>
+        "#
+        )
+    }
+
+    fn binding_type(&self, ty: &BindingType) -> String {
+        match ty {
+            BindingType::Base(type_id) => self.type_ref(*type_id),
+            BindingType::Option(inner) => format!("Option({})", self.binding_type(inner)),
+            BindingType::Tuple(inners) => format!(
+                "({inners})",
+                inners = inners
+                    .iter()
+                    .map(|inner| self.binding_type(inner))
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            ),
+        }
+    }
+
+    fn type_ref(&self, type_id: TypeId) -> String {
+        let ty = self.prog.ty(type_id);
+        format!(
+            r#"<a href="{href}">{name}</a>"#,
+            href = self.pos_href(ty.pos()),
+            name = self.prog.type_name(ty.id())
+        )
+    }
+
+    fn term_ref(&self, term_id: TermId) -> String {
+        let term = self.prog.term(term_id);
+        format!(
+            r#"<a href="{href}">{name}</a>"#,
+            href = self.pos_href(term.decl_pos),
+            name = self.prog.term_name(term_id)
+        )
+    }
+
+    fn rule_ref(&self, rule_id: RuleId) -> String {
+        let rule = self.prog.rule(rule_id);
+        format!(
+            r#"<a href="{href}">{identifier}</a>"#,
+            href = self.pos_href(rule.pos),
+            identifier = rule.identifier(&self.prog.tyenv, &self.prog.files)
+        )
+    }
+
+    fn pos(&self, pos: Pos) -> String {
+        if pos.is_unknown() {
+            "&lt;unknown&gt;".to_string()
+        } else {
+            format!(
+                r#"<a href="{href}">{loc}</a>"#,
+                href = self.pos_href(pos),
+                loc = self.loc(pos)
+            )
+        }
+    }
+
+    fn loc(&self, pos: Pos) -> String {
+        let path = PathBuf::from(&self.prog.files.file_names[pos.file]);
+        format!(
+            "{}:{}",
+            path.file_name().unwrap().to_string_lossy(),
+            self.line(pos)
+        )
+    }
+
+    fn pos_href(&self, pos: Pos) -> String {
+        format!(
+            "{}#{}",
+            self.link(&self.file_path(pos.file)),
+            self.line_url_fragment(self.line(pos))
+        )
+    }
+
+    fn line_url_fragment(&self, n: usize) -> String {
+        format!("L{n}")
+    }
+
+    fn line(&self, pos: Pos) -> usize {
+        self.prog
+            .files
+            .file_line_map(pos.file)
+            .unwrap()
+            .line(pos.offset)
+    }
+
+    fn types_dir(&self) -> PathBuf {
+        PathBuf::from("type")
+    }
+
+    fn terms_dir(&self) -> PathBuf {
+        PathBuf::from("term")
+    }
+
+    fn rules_dir(&self) -> PathBuf {
+        PathBuf::from("rule")
+    }
+
+    fn expansions_dir(&self) -> PathBuf {
+        PathBuf::from("expansion")
+    }
+
+    fn expansion_dir(&self, id: usize) -> PathBuf {
+        self.expansions_dir().join(id.to_string())
+    }
+
+    fn expansion_path(&self, id: usize) -> PathBuf {
+        self.expansion_dir(id).join("index.html")
+    }
+
+    fn expansion_graph_dot_path(&self, id: usize) -> PathBuf {
+        self.expansion_dir(id).join("graph.dot")
+    }
+
+    fn expansion_graph_svg_path(&self, id: usize) -> PathBuf {
+        self.expansion_dir(id).join("graph.svg")
+    }
+
+    fn file_dir(&self) -> PathBuf {
+        PathBuf::from("file")
+    }
+
+    fn file_path(&self, id: usize) -> PathBuf {
+        self.file_dir().join(format!("{id}.html"))
+    }
+
+    fn assets_dir(&self) -> PathBuf {
+        PathBuf::from("assets")
+    }
+
+    fn asset_path(&self, name: &str) -> PathBuf {
+        self.assets_dir().join(name)
+    }
+
+    fn style_path(&self) -> PathBuf {
+        self.asset_path("style.css")
+    }
+
+    fn abs(&self, path: &Path) -> PathBuf {
+        self.root.join(path)
+    }
+
+    fn link(&self, path: &Path) -> String {
+        assert!(path.is_relative());
+        assert!(self.base.is_relative());
+
+        let mut comps = Vec::new();
+        for _ in self.base.components() {
+            comps.push(Component::ParentDir);
+        }
+        comps.extend(path.components());
+        let rel: PathBuf = comps.iter().map(|c| c.as_os_str()).collect();
+        rel.display().to_string()
+    }
+
+    fn create(&mut self, path: &Path) -> io::Result<File> {
+        // Path expected to be relative to site root.
+        assert!(path.is_relative());
+
+        // Update base directory for relative links.
+        self.base = path.parent().expect("should have parent path").into();
+
+        // Create the file, and any parent directories if necessary.
+        log::info!("create: {}", path.display());
+        let path = self.abs(path);
+        if let Some(parent) = path.parent() {
+            std::fs::create_dir_all(parent)?;
+        }
+        File::create(&path)
+    }
+}
diff --git a/cranelift/isle/veri/veri/src/lib.rs b/cranelift/isle/veri/veri/src/lib.rs
new file mode 100644
index 000000000000..1d58ca862faf
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/lib.rs
@@ -0,0 +1,36 @@
+// TODO(mbm): declare_id is copied from ISLE crate. move it to a common location?
+macro_rules! declare_id {
+    (
+        $(#[$attr:meta])*
+            $name:ident
+    ) => {
+        $(#[$attr])*
+            #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+        pub struct $name(pub usize);
+        impl $name {
+            /// Get the index of this id.
+            pub fn index(self) -> usize {
+                self.0
+            }
+        }
+    };
+}
+
+pub mod debug;
+pub mod encoded;
+pub mod expand;
+pub mod explorer;
+pub mod program;
+pub mod reachability;
+pub mod runner;
+pub mod solver;
+pub mod spec;
+pub mod trie;
+pub mod type_inference;
+pub mod types;
+pub mod veri;
+
+#[cfg(test)]
+pub mod testing;
+
+include!(concat!(env!("OUT_DIR"), "/meta.rs"));
diff --git a/cranelift/isle/veri/veri/src/program.rs b/cranelift/isle/veri/veri/src/program.rs
new file mode 100644
index 000000000000..920b5b8f8362
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/program.rs
@@ -0,0 +1,192 @@
+use crate::spec::{self, SpecEnv};
+use crate::trie;
+use anyhow::{bail, Result};
+use cranelift_isle::ast::{Def, Ident};
+use cranelift_isle::error::{self, Errors, Span};
+use cranelift_isle::files::Files;
+use cranelift_isle::lexer::Pos;
+use cranelift_isle::sema::{
+    self, Rule, RuleId, Term, TermEnv, TermId, Type, TypeEnv, TypeId, VariantId,
+};
+use cranelift_isle::trie_again::{Overlap, RuleSet};
+use cranelift_isle::{lexer, parser};
+use std::collections::{HashMap, HashSet};
+use std::sync::Arc;
+
+pub struct Program {
+    pub files: Arc<Files>,
+    pub tyenv: TypeEnv,
+    pub termenv: TermEnv,
+    pub specenv: SpecEnv,
+    pub overlaps: HashMap<RuleId, HashSet<RuleId>>,
+}
+
+impl Program {
+    pub fn from_files(
+        paths: &Vec<std::path::PathBuf>,
+        expand_internal_extractors: bool,
+    ) -> Result<Self> {
+        let files = match Files::from_paths(paths) {
+            Ok(files) => files,
+            Err((path, err)) => {
+                bail!(Errors::from_io(
+                    err,
+                    format!("cannot read file {}", path.display()),
+                ))
+            }
+        };
+
+        let files = Arc::new(files);
+
+        let mut defs = Vec::new();
+        for (file, src) in files.file_texts.iter().enumerate() {
+            let lexer = match lexer::Lexer::new(file, src) {
+                Ok(lexer) => lexer,
+                Err(err) => bail!(Errors::new(vec![err], files)),
+            };
+
+            match parser::parse(lexer, files.clone()) {
+                Ok(mut ds) => defs.append(&mut ds),
+                Err(err) => bail!(Errors::new(vec![err], files)),
+            }
+        }
+
+        let mut tyenv = match sema::TypeEnv::from_ast(&defs) {
+            Ok(type_env) => type_env,
+            Err(errs) => bail!(Errors::new(errs, files)),
+        };
+
+        let termenv = match sema::TermEnv::from_ast(&mut tyenv, &defs, expand_internal_extractors) {
+            Ok(term_env) => term_env,
+            Err(errs) => bail!(Errors::new(errs, files)),
+        };
+
+        let specenv = spec::SpecEnv::from_ast(&defs, &termenv, &tyenv)?;
+
+        let overlaps = Self::build_overlaps(&defs, files.clone())?;
+
+        Ok(Self {
+            files,
+            tyenv,
+            termenv,
+            specenv,
+            overlaps,
+        })
+    }
+
+    pub fn ty(&self, type_id: TypeId) -> &Type {
+        self.tyenv
+            .types
+            .get(type_id.index())
+            .expect("invalid type id")
+    }
+
+    pub fn type_name(&self, type_id: TypeId) -> &str {
+        self.ty(type_id).name(&self.tyenv)
+    }
+
+    pub fn term(&self, term_id: TermId) -> &Term {
+        self.termenv
+            .terms
+            .get(term_id.index())
+            .expect("invalid term id")
+    }
+
+    pub fn term_name(&self, term_id: TermId) -> &str {
+        let term = self.term(term_id);
+        &self.tyenv.syms[term.name.index()]
+    }
+
+    pub fn get_variant_term(&self, ty: TypeId, variant: VariantId) -> TermId {
+        self.termenv.get_variant_term(&self.tyenv, ty, variant)
+    }
+
+    pub fn rule(&self, rule_id: RuleId) -> &Rule {
+        self.termenv
+            .rules
+            .get(rule_id.index())
+            .expect("invalid rule id")
+    }
+
+    pub fn rule_identifer(&self, rule_id: RuleId) -> String {
+        let rule = self.rule(rule_id);
+        rule.identifier(&self.tyenv, &self.files)
+    }
+
+    pub fn rules_by_term(&self) -> HashMap<TermId, Vec<RuleId>> {
+        let mut rules: HashMap<TermId, Vec<RuleId>> = HashMap::new();
+        for rule in &self.termenv.rules {
+            rules.entry(rule.root_term).or_default().push(rule.id);
+        }
+        rules
+    }
+
+    pub fn get_rule_by_identifier(&self, id: &str) -> Option<&Rule> {
+        self.termenv
+            .rules
+            .iter()
+            .find(|r| r.identifier(&self.tyenv, &self.files) == id)
+    }
+
+    pub fn get_term_by_name(&self, name: &str) -> Option<TermId> {
+        let sym = Ident(name.to_string(), Pos::default());
+        self.termenv.get_term_by_name(&self.tyenv, &sym)
+    }
+
+    pub fn build_trie(&self) -> Result<Vec<(TermId, RuleSet)>, Errors> {
+        trie::build_trie(&self.termenv, self.files.clone())
+    }
+
+    pub(crate) fn error_at_pos(&self, pos: Pos, msg: impl Into<String>) -> Errors {
+        // In order to piggy back off the existing diagnostic error reporting in
+        // ISLE, we shoehorn our error type into one of the existing error
+        // categories.
+        //
+        // TODO(mbm): cleaner positional error reporting for the verifier
+        let err = error::Error::TypeError {
+            msg: msg.into(),
+            span: Span::new_single(pos),
+        };
+        Errors::new(vec![err], self.files.clone())
+    }
+
+    fn build_overlaps(defs: &[Def], files: Arc<Files>) -> Result<HashMap<RuleId, HashSet<RuleId>>> {
+        // Overlap checking relies on term environment constructed with internal
+        // extractor expansion enabled, so we need to generate it again.
+        let mut tyenv = match sema::TypeEnv::from_ast(defs) {
+            Ok(type_env) => type_env,
+            Err(errs) => bail!(Errors::new(errs, files)),
+        };
+
+        let expand_internal_extractors = true;
+        let termenv = match sema::TermEnv::from_ast(&mut tyenv, defs, expand_internal_extractors) {
+            Ok(term_env) => term_env,
+            Err(errs) => bail!(Errors::new(errs, files)),
+        };
+
+        // Check all pairs of rules for overlap.
+        let term_rule_sets = trie::build_trie(&termenv, files.clone())?;
+        let mut overlaps: HashMap<RuleId, HashSet<RuleId>> = HashMap::new();
+        for (_, rule_set) in &term_rule_sets {
+            for rule in &rule_set.rules {
+                for other in &rule_set.rules {
+                    // Ignore same or higher priority rules.
+                    if other.prio <= rule.prio {
+                        continue;
+                    }
+
+                    // Check for overlap.
+                    let overlap = rule.may_overlap(other);
+                    if overlap == Overlap::No {
+                        continue;
+                    }
+
+                    // Record overlap.
+                    overlaps.entry(rule.id).or_default().insert(other.id);
+                }
+            }
+        }
+
+        Ok(overlaps)
+    }
+}
diff --git a/cranelift/isle/veri/veri/src/reachability.rs b/cranelift/isle/veri/veri/src/reachability.rs
new file mode 100644
index 000000000000..4f8060f56e31
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/reachability.rs
@@ -0,0 +1,69 @@
+use std::collections::{HashMap, HashSet};
+
+use cranelift_isle::{
+    sema::TermId,
+    trie_again::{Binding, RuleSet},
+};
+
+pub struct Reachability {
+    reachable: HashMap<TermId, HashSet<TermId>>,
+}
+
+impl Reachability {
+    pub fn build(term_rule_sets: &HashMap<TermId, RuleSet>) -> Self {
+        let mut reachable = HashMap::new();
+        for term_id in term_rule_sets.keys() {
+            reachable.insert(*term_id, search(*term_id, term_rule_sets));
+        }
+        Self { reachable }
+    }
+
+    /// Set of terms reachable from the the given source.
+    pub fn reachable(&self, source: TermId) -> &HashSet<TermId> {
+        &self.reachable[&source]
+    }
+
+    /// Report whether the term is included in a cycle.
+    pub fn is_cyclic(&self, term_id: TermId) -> bool {
+        self.reachable(term_id).contains(&term_id)
+    }
+}
+
+/// Search for all terms reachable from the source.
+fn search(source: TermId, term_rule_sets: &HashMap<TermId, RuleSet>) -> HashSet<TermId> {
+    let mut reachable = HashSet::new();
+    let mut stack = vec![source];
+
+    while let Some(term_id) = stack.pop() {
+        if !term_rule_sets.contains_key(&term_id) {
+            continue;
+        }
+
+        let used = used_terms(&term_rule_sets[&term_id]);
+        for used_term_id in used {
+            if reachable.contains(&used_term_id) {
+                continue;
+            }
+            reachable.insert(used_term_id);
+            stack.push(used_term_id);
+        }
+    }
+
+    reachable
+}
+
+pub fn used_terms(rule_set: &RuleSet) -> HashSet<TermId> {
+    rule_set
+        .bindings
+        .iter()
+        .filter_map(binding_used_term)
+        .collect()
+}
+
+pub fn binding_used_term(binding: &Binding) -> Option<TermId> {
+    match binding {
+        Binding::Constructor { term, .. } | Binding::Extractor { term, .. } => Some(*term),
+        // TODO(mbm): make variant uses the variant constructor term?
+        _ => None,
+    }
+}
diff --git a/cranelift/isle/veri/veri/src/runner.rs b/cranelift/isle/veri/veri/src/runner.rs
new file mode 100644
index 000000000000..e5c61e41d6e5
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/runner.rs
@@ -0,0 +1,831 @@
+use std::{
+    collections::{BTreeSet, HashMap},
+    fs::File,
+    io::Write,
+    path::{Path, PathBuf},
+    str::FromStr,
+    time::{self, Duration},
+};
+
+use anyhow::{bail, format_err, Context as _, Error, Result};
+use cranelift_isle::{
+    sema::{Term, TermId},
+    trie_again::RuleSet,
+};
+use rayon::prelude::*;
+use serde::Serialize;
+
+use crate::{
+    debug::print_expansion,
+    expand::{Chaining, Expander, Expansion},
+    program::Program,
+    solver::{Applicability, Dialect, Solver, Verification},
+    type_inference::{self, type_constraint_system, Assignment, Choice},
+    veri::Conditions,
+    BUILD_PROFILE, GIT_VERSION,
+};
+
+const LOG_DIR: &str = ".veriisle";
+
+#[derive(Debug, Clone, Copy)]
+pub enum SolverBackend {
+    Z3,
+    CVC5,
+}
+
+impl SolverBackend {
+    fn prog(&self) -> &str {
+        match self {
+            SolverBackend::Z3 => "z3",
+            SolverBackend::CVC5 => "cvc5",
+        }
+    }
+
+    fn all() -> Vec<Self> {
+        vec![SolverBackend::Z3, SolverBackend::CVC5]
+    }
+
+    fn dialect(&self) -> Dialect {
+        match self {
+            SolverBackend::Z3 => Dialect::Z3,
+            SolverBackend::CVC5 => Dialect::SMTLIB2,
+        }
+    }
+
+    fn args(&self, timeout: Duration) -> Vec<String> {
+        match self {
+            SolverBackend::Z3 => vec![
+                "-smt2".to_string(),
+                "-in".to_string(),
+                format!("-t:{}", timeout.as_millis()),
+            ],
+            SolverBackend::CVC5 => vec![
+                "--incremental".to_string(),
+                "--print-success".to_string(),
+                format!("--tlimit-per={ms}", ms = timeout.as_millis()),
+                "-".to_string(),
+            ],
+        }
+    }
+}
+
+impl std::fmt::Display for SolverBackend {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.prog())
+    }
+}
+
+impl FromStr for SolverBackend {
+    type Err = Error;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        Ok(match s {
+            "z3" => SolverBackend::Z3,
+            "cvc5" => SolverBackend::CVC5,
+            _ => bail!("unknown solver backend"),
+        })
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum ExpansionPredicate {
+    FirstRuleNamed,
+    Specified,
+    Tagged(String),
+    Root(String),
+    ContainsRule(String),
+    Not(Box<ExpansionPredicate>),
+    And(Box<ExpansionPredicate>, Box<ExpansionPredicate>),
+}
+
+impl FromStr for ExpansionPredicate {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self> {
+        Ok(if let Some((p, q)) = s.split_once(',') {
+            ExpansionPredicate::And(Box::new(p.parse()?), Box::new(q.parse()?))
+        } else if let Some(p) = s.strip_prefix("not:") {
+            ExpansionPredicate::Not(Box::new(p.parse()?))
+        } else if s == "first-rule-named" {
+            ExpansionPredicate::FirstRuleNamed
+        } else if s == "specified" {
+            ExpansionPredicate::Specified
+        } else if let Some(tag) = s.strip_prefix("tag:") {
+            ExpansionPredicate::Tagged(tag.to_string())
+        } else if let Some(term) = s.strip_prefix("root:") {
+            ExpansionPredicate::Root(term.to_string())
+        } else if let Some(rule) = s.strip_prefix("rule:") {
+            ExpansionPredicate::ContainsRule(rule.to_string())
+        } else {
+            bail!("invalid expansion predicate")
+        })
+    }
+}
+
+impl std::fmt::Display for ExpansionPredicate {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ExpansionPredicate::FirstRuleNamed => write!(f, "first-rule-named"),
+            ExpansionPredicate::Specified => write!(f, "specified"),
+            ExpansionPredicate::Tagged(tag) => write!(f, "tag:{tag}"),
+            ExpansionPredicate::Root(term) => write!(f, "root:{term}"),
+            ExpansionPredicate::ContainsRule(rule) => write!(f, "rule:{rule}"),
+            ExpansionPredicate::Not(p) => write!(f, "not:{p}"),
+            ExpansionPredicate::And(p, q) => write!(f, "{p},{q}"),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Filter {
+    include: bool,
+    predicate: ExpansionPredicate,
+}
+
+impl Filter {
+    fn new(include: bool, predicate: ExpansionPredicate) -> Self {
+        Self { include, predicate }
+    }
+
+    fn include(predicate: ExpansionPredicate) -> Self {
+        Self::new(true, predicate)
+    }
+
+    fn exclude(predicate: ExpansionPredicate) -> Self {
+        Self::new(false, predicate)
+    }
+}
+
+impl FromStr for Filter {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self> {
+        let (include, p) = if let Some(p) = s.strip_prefix("include:") {
+            (true, p)
+        } else if let Some(p) = s.strip_prefix("exclude:") {
+            (false, p)
+        } else {
+            (true, s)
+        };
+        Ok(Filter::new(include, p.parse()?))
+    }
+}
+
+impl std::fmt::Display for Filter {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let include = if self.include { "include" } else { "exclude" };
+        write!(
+            f,
+            "{include}:{predicate}",
+            include = include,
+            predicate = self.predicate
+        )
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct SolverRule {
+    predicate: ExpansionPredicate,
+    solver_backend: SolverBackend,
+}
+
+impl SolverRule {
+    /// Build a rule that selects the solver backend for expansions with an
+    /// explicit `solver_<name>` tag.
+    fn solver_tag(solver_backend: SolverBackend) -> Self {
+        let tag = format!("solver_{}", solver_backend);
+        Self {
+            predicate: ExpansionPredicate::Tagged(tag),
+            solver_backend,
+        }
+    }
+
+    /// Build rules for explicit selection of all solver backends.
+    fn solver_tag_rules() -> Vec<Self> {
+        SolverBackend::all()
+            .iter()
+            .map(|backend| Self::solver_tag(*backend))
+            .collect()
+    }
+}
+
+impl FromStr for SolverRule {
+    type Err = Error;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        if let Some((backend, predicate)) = s.split_once('=') {
+            Ok(Self {
+                predicate: predicate.parse()?,
+                solver_backend: backend.parse()?,
+            })
+        } else {
+            bail!("invalid solver rule")
+        }
+    }
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "snake_case")]
+pub enum Verdict {
+    Inapplicable,
+    Success,
+    Unknown,
+}
+
+#[derive(Serialize)]
+pub struct VerifyReport {
+    pub verdict: Verdict,
+
+    pub init_time: Duration,
+    pub applicable_time: Duration,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub verify_time: Option<Duration>,
+}
+
+#[derive(Serialize)]
+pub struct TypeInstantationReport {
+    pub choices: Vec<String>,
+    pub verify: VerifyReport,
+    pub duration: Duration,
+}
+
+#[derive(Serialize)]
+pub struct ExpansionReport {
+    pub id: usize,
+    pub description: String,
+    pub root: String,
+    pub rules: Vec<String>,
+    pub chained: Vec<String>,
+    pub terms: Vec<String>,
+    pub tags: Vec<String>,
+    pub solver: String,
+    /// Count of type instantiations that failed at type inference.
+    pub failed_type_inference: usize,
+    /// Solver reports from type instantiations.
+    pub type_instantiations: Vec<TypeInstantationReport>,
+    pub duration: Duration,
+}
+
+impl ExpansionReport {
+    fn from_expansion(id: usize, expansion: &Expansion, prog: &Program) -> Result<Self> {
+        // Description
+        let description = expansion_description(expansion, prog)?;
+
+        // Root term.
+        let root = prog.term_name(expansion.term).to_string();
+
+        // Tags
+        let mut tags: Vec<_> = expansion.tags(prog).iter().cloned().collect();
+        tags.sort();
+
+        // Rules
+        let mut rules = Vec::new();
+        let mut chained = BTreeSet::new();
+        for rule_id in &expansion.rules {
+            let rule = prog.rule(*rule_id);
+            rules.push(rule.identifier(&prog.tyenv, &prog.files));
+
+            if rule.root_term != expansion.term {
+                let root_term = prog.term_name(rule.root_term);
+                if !chained.contains(&root_term) {
+                    chained.insert(root_term);
+                }
+            }
+        }
+
+        // Terms
+        let terms: BTreeSet<_> = expansion
+            .terms(prog)
+            .iter()
+            .map(|term_id| prog.term_name(*term_id))
+            .collect();
+
+        Ok(Self {
+            id,
+            root,
+            description,
+            rules,
+            chained: chained.iter().map(ToString::to_string).collect(),
+            terms: terms.iter().map(ToString::to_string).collect(),
+            tags,
+            solver: Default::default(),
+            failed_type_inference: 0,
+            type_instantiations: Vec::new(),
+            duration: Default::default(),
+        })
+    }
+}
+
+#[derive(Serialize)]
+pub struct TermMetadata {
+    pub name: String,
+    pub class: String,
+    pub has_spec: bool,
+    pub tags: Vec<String>,
+}
+
+impl TermMetadata {
+    fn from_term(term: &Term, prog: &Program) -> Self {
+        let name = prog.term_name(term.id).to_string();
+        let class = Self::classify_term(term);
+        let has_spec = prog.specenv.has_spec(term.id);
+
+        let tags_set = prog
+            .specenv
+            .term_tags
+            .get(&term.id)
+            .cloned()
+            .unwrap_or_default();
+        let mut tags: Vec<_> = tags_set.iter().cloned().collect();
+        tags.sort();
+
+        Self {
+            name,
+            class,
+            has_spec,
+            tags,
+        }
+    }
+
+    fn from_prog(prog: &Program) -> Vec<Self> {
+        let mut terms = Vec::new();
+        for term in &prog.termenv.terms {
+            terms.push(Self::from_term(term, prog));
+        }
+        terms
+    }
+
+    fn classify_term(term: &Term) -> String {
+        if term.is_enum_variant() {
+            return "enum_variant".to_string();
+        }
+
+        if term.has_external_constructor() || term.has_external_extractor() {
+            return "external".to_string();
+        }
+
+        if term.has_extractor() {
+            return "extractor".to_string();
+        }
+
+        assert!(term.has_constructor());
+
+        "constructor".to_string()
+    }
+}
+
+#[derive(Serialize)]
+pub struct Report {
+    build_profile: String,
+    git_version: String,
+    args: Vec<String>,
+    filters: Vec<String>,
+    default_solver: String,
+    timeout: Duration,
+    duration: Duration,
+    num_threads: usize,
+    terms: Vec<TermMetadata>,
+    expansions: Vec<ExpansionReport>,
+}
+
+/// Runner orchestrates execution of the verification process over a set of
+/// expansions.
+pub struct Runner {
+    prog: Program,
+    term_rule_sets: HashMap<TermId, RuleSet>,
+
+    root_term: String,
+    filters: Vec<Filter>,
+    default_solver_backend: SolverBackend,
+    solver_rules: Vec<SolverRule>,
+    timeout: Duration,
+    log_dir: PathBuf,
+    skip_solver: bool,
+    results_to_log_dir: bool,
+    debug: bool,
+}
+
+impl Runner {
+    pub fn from_files(inputs: &Vec<PathBuf>, root_term: &str) -> Result<Self> {
+        let expand_internal_extractors = false;
+        let prog = Program::from_files(inputs, expand_internal_extractors)?;
+        let term_rule_sets: HashMap<_, _> = prog.build_trie()?.into_iter().collect();
+        Ok(Self {
+            prog,
+            term_rule_sets,
+            root_term: root_term.to_string(),
+            filters: Vec::new(),
+            default_solver_backend: SolverBackend::CVC5,
+            solver_rules: Vec::new(),
+            timeout: Duration::from_secs(5),
+            log_dir: PathBuf::from(LOG_DIR),
+            results_to_log_dir: false,
+            skip_solver: false,
+            debug: false,
+        })
+    }
+
+    pub fn set_root_term(&mut self, term: &str) {
+        self.root_term = term.to_string();
+    }
+
+    pub fn filter(&mut self, filter: Filter) {
+        self.filters.push(filter);
+    }
+
+    pub fn filters(&mut self, filters: &[Filter]) {
+        self.filters.extend(filters.iter().cloned());
+    }
+
+    pub fn include_first_rule_named(&mut self) {
+        self.filters
+            .push(Filter::include(ExpansionPredicate::FirstRuleNamed));
+    }
+
+    pub fn skip_tag(&mut self, tag: &str) {
+        self.filters
+            .push(Filter::exclude(ExpansionPredicate::Tagged(tag.to_string())));
+    }
+
+    pub fn target_rule(&mut self, id: &str) -> Result<()> {
+        self.filters
+            .push(Filter::include(ExpansionPredicate::ContainsRule(
+                id.to_string(),
+            )));
+        Ok(())
+    }
+
+    // Configure the default solver to use if no solver rules apply.
+    pub fn set_default_solver_backend(&mut self, solver_backend: SolverBackend) {
+        self.default_solver_backend = solver_backend;
+    }
+
+    // Use the given solver backend for expansions that satisfy the given
+    // predicate.  If multiple rules match, the earlier one is used. If none
+    // match, the default is used.
+    pub fn add_solver_rule(&mut self, solver_rule: SolverRule) {
+        self.solver_rules.push(solver_rule);
+    }
+
+    // Configure rules for explicit solver selection based on `solver_<name>` tags.
+    pub fn add_solver_tag_rules(&mut self) {
+        self.solver_rules.extend(SolverRule::solver_tag_rules());
+    }
+
+    pub fn set_timeout(&mut self, timeout: Duration) {
+        self.timeout = timeout;
+    }
+
+    pub fn set_log_dir(&mut self, path: PathBuf) {
+        self.log_dir = path;
+    }
+
+    pub fn set_results_to_log_dir(&mut self, enabled: bool) {
+        self.results_to_log_dir = enabled;
+    }
+
+    pub fn skip_solver(&mut self, skip: bool) {
+        self.skip_solver = skip;
+    }
+
+    pub fn debug(&mut self, debug: bool) {
+        self.debug = debug;
+    }
+
+    pub fn run(&self) -> Result<()> {
+        // Clean log directory.
+        if self.log_dir.exists() {
+            std::fs::remove_dir_all(&self.log_dir)?;
+        }
+
+        // Start timer.
+        let num_threads = rayon::current_num_threads();
+        let start = time::Instant::now();
+
+        // Generate expansions.
+        // TODO(mbm): don't hardcode the expansion configuration
+        let chaining = Chaining::new(&self.prog, &self.term_rule_sets)?;
+        chaining.validate()?;
+        let mut expander = Expander::new(&self.prog, &self.term_rule_sets, chaining);
+        expander.add_root_term_name(&self.root_term)?;
+        expander.set_prune_infeasible(true);
+        expander.expand();
+
+        // Process expansions.
+        let expansions = expander.expansions();
+        log::info!("expansions: {n}", n = expansions.len());
+
+        let mut expansion_reports = expansions
+            .par_iter()
+            .enumerate()
+            .map(|(i, expansion)| -> Result<Option<ExpansionReport>> {
+                // Skip?
+                if !self.should_verify(expansion)? {
+                    return Ok(None);
+                }
+
+                // Verify
+                let expansion_log_dir = self.log_dir.join("expansions").join(format!("{:05}", i));
+                let report = self.verify_expansion(expansion, i, expansion_log_dir.clone())?;
+
+                Ok(Some(report))
+            })
+            .collect::<Result<Vec<_>>>()?
+            .into_iter()
+            .flatten()
+            .collect::<Vec<_>>();
+
+        // End timer.
+        let duration = start.elapsed();
+
+        // Prepare report
+        expansion_reports.sort_by(|a, b| a.id.cmp(&b.id));
+        let terms = TermMetadata::from_prog(&self.prog);
+        let report = Report {
+            build_profile: BUILD_PROFILE.to_string(),
+            git_version: GIT_VERSION.to_string(),
+            args: std::env::args().collect(),
+            filters: self.filters.iter().map(ToString::to_string).collect(),
+            default_solver: self.default_solver_backend.prog().to_string(),
+            timeout: self.timeout,
+            num_threads,
+            duration,
+            terms,
+            expansions: expansion_reports,
+        };
+
+        // Write
+        let output = Self::open_log_file(self.log_dir.clone(), "report.json")?;
+        serde_json::to_writer_pretty(output, &report)?;
+
+        Ok(())
+    }
+
+    fn should_verify(&self, expansion: &Expansion) -> Result<bool> {
+        let mut verdict = None;
+        for filter in self.filters.iter() {
+            verdict = self.eval_filter(filter, expansion)?.or(verdict);
+        }
+        Ok(verdict.unwrap_or(false))
+    }
+
+    fn eval_filter(&self, filter: &Filter, expansion: &Expansion) -> Result<Option<bool>> {
+        Ok(if self.eval_predicate(&filter.predicate, expansion)? {
+            Some(filter.include)
+        } else {
+            None
+        })
+    }
+
+    fn eval_predicate(
+        &self,
+        predicate: &ExpansionPredicate,
+        expansion: &Expansion,
+    ) -> Result<bool> {
+        Ok(match predicate {
+            ExpansionPredicate::FirstRuleNamed => {
+                let rule_id = expansion
+                    .rules
+                    .first()
+                    .ok_or(format_err!("expansion should have at least one rule"))?;
+                let rule = self.prog.rule(*rule_id);
+                rule.name.is_some()
+            }
+            ExpansionPredicate::Specified => expansion
+                .terms(&self.prog)
+                .iter()
+                .all(|term_id| self.prog.specenv.has_spec(*term_id)),
+            ExpansionPredicate::Tagged(tag) => {
+                let tags = expansion.tags(&self.prog);
+                tags.contains(tag)
+            }
+            ExpansionPredicate::Root(term) => self.prog.term_name(expansion.term) == term,
+            ExpansionPredicate::ContainsRule(identifier) => {
+                let rule = self
+                    .prog
+                    .get_rule_by_identifier(&identifier)
+                    .ok_or(format_err!("unknown rule '{identifier}'"))?;
+                expansion.rules.contains(&rule.id)
+            }
+            ExpansionPredicate::Not(p) => !self.eval_predicate(p, expansion)?,
+            ExpansionPredicate::And(p, q) => {
+                self.eval_predicate(p, expansion)? && self.eval_predicate(q, expansion)?
+            }
+        })
+    }
+
+    fn verify_expansion(
+        &self,
+        expansion: &Expansion,
+        id: usize,
+        log_dir: std::path::PathBuf,
+    ) -> Result<ExpansionReport> {
+        let description = expansion_description(expansion, &self.prog)?;
+        let start = time::Instant::now();
+
+        // Results output.
+        let mut output: Box<dyn Write> = if self.results_to_log_dir {
+            log::info!("#{id}\t{description}");
+            Box::new(Self::open_log_file(log_dir.clone(), "results.out")?)
+        } else {
+            Box::new(std::io::stdout())
+        };
+
+        writeln!(output, "#{id}\t{description}")?;
+        if self.debug {
+            print_expansion(&self.prog, expansion);
+        }
+
+        // Verification conditions.
+        let conditions = Conditions::from_expansion(expansion, &self.prog)?;
+        if self.debug {
+            conditions.pretty_print(&self.prog);
+        }
+
+        // Type constraints.
+        let system = type_constraint_system(&conditions);
+        if self.debug {
+            system.pretty_print();
+        }
+
+        // Infer types.
+        let type_solver = type_inference::Solver::new();
+        let solutions = type_solver.solve(&system);
+
+        // Initialize report.
+        let mut report = ExpansionReport::from_expansion(id, expansion, &self.prog)?;
+
+        // Select solver.
+        let solver_backend = self.select_solver_backend(expansion)?;
+        report.solver = solver_backend.to_string();
+
+        for (i, solution) in solutions.iter().enumerate() {
+            let start_solution = time::Instant::now();
+
+            // Show type assignment.
+            let mut choices = Vec::new();
+            for choice in &solution.choices {
+                let choice = match choice {
+                    Choice::TermInstantiation(term_id, sig) => {
+                        format!("{term}{sig}", term = self.prog.term_name(*term_id))
+                    }
+                };
+                writeln!(output, "\t{choice}")?;
+                choices.push(choice);
+            }
+            writeln!(output, "\t\ttype solution status = {}", solution.status)?;
+            if self.debug {
+                println!("type assignment:");
+                solution.assignment.pretty_print(&conditions);
+            }
+
+            match &solution.status {
+                type_inference::Status::Solved => (),
+                type_inference::Status::Inapplicable(conflict) => {
+                    log::debug!(
+                        "inapplicable type inference: {diagnostic}",
+                        diagnostic = conflict.diagnostic(&conditions, &self.prog.files)
+                    );
+                    report.failed_type_inference += 1;
+                    continue;
+                }
+                type_inference::Status::Underconstrained => {
+                    bail!("underconstrained type inference")
+                }
+                type_inference::Status::TypeError(confict) => {
+                    return Err(conditions.error_at_expr(
+                        &self.prog,
+                        confict.x,
+                        confict.reason.clone(),
+                    ));
+                }
+            }
+
+            // Verify.
+            if self.skip_solver {
+                println!("skip solver");
+                continue;
+            }
+
+            let solution_log_dir = log_dir.join(format!("{:03}", i));
+            let verify_report = self
+                .verify_expansion_type_instantiation(
+                    &conditions,
+                    &solution.assignment,
+                    solver_backend,
+                    solution_log_dir,
+                    &mut output,
+                )
+                .context(format!("verify expansion: {id}"))?;
+
+            // Append to report.
+            let duration = start_solution.elapsed();
+            report.type_instantiations.push(TypeInstantationReport {
+                choices,
+                verify: verify_report,
+                duration,
+            });
+        }
+
+        // End timer
+        report.duration = start.elapsed();
+
+        Ok(report)
+    }
+
+    fn select_solver_backend(&self, expansion: &Expansion) -> Result<SolverBackend> {
+        for solver_rule in &self.solver_rules {
+            if self.eval_predicate(&solver_rule.predicate, expansion)? {
+                return Ok(solver_rule.solver_backend);
+            }
+        }
+        Ok(self.default_solver_backend)
+    }
+
+    fn verify_expansion_type_instantiation(
+        &self,
+        conditions: &Conditions,
+        assignment: &Assignment,
+        solver_backend: SolverBackend,
+        log_dir: std::path::PathBuf,
+        output: &mut dyn Write,
+    ) -> Result<VerifyReport> {
+        let start = time::Instant::now();
+
+        // Solve.
+        let binary = solver_backend.prog();
+        let args = solver_backend.args(self.timeout);
+        let replay_file = Self::open_log_file(log_dir, "solver.smt2")?;
+        let smt = easy_smt::ContextBuilder::new()
+            .solver(binary, &args)
+            .replay_file(Some(replay_file))
+            .build()?;
+
+        let mut solver = Solver::new(smt, &self.prog, conditions, assignment)?;
+        solver.set_dialect(solver_backend.dialect());
+        solver.encode()?;
+        let init_time = start.elapsed();
+
+        // Applicability check.
+        let start = time::Instant::now();
+        let applicability = solver.check_assumptions_feasibility()?;
+        let applicable_time = start.elapsed();
+
+        writeln!(output, "\t\tapplicability = {applicability}")?;
+        match applicability {
+            Applicability::Applicable => (),
+            Applicability::Inapplicable => {
+                return Ok(VerifyReport {
+                    verdict: Verdict::Inapplicable,
+                    init_time,
+                    applicable_time,
+                    verify_time: None,
+                })
+            }
+            Applicability::Unknown => bail!("could not prove applicability"),
+        };
+
+        // Verify.
+        let start = time::Instant::now();
+        let verification = solver.check_verification_condition()?;
+        let verify_time = Some(start.elapsed());
+
+        writeln!(output, "\t\tverification = {verification}")?;
+        Ok(match verification {
+            Verification::Failure(model) => {
+                println!("model:");
+                conditions.print_model(&model, &self.prog)?;
+                bail!("verification failed");
+            }
+            Verification::Success => VerifyReport {
+                verdict: Verdict::Success,
+                init_time,
+                applicable_time,
+                verify_time,
+            },
+            Verification::Unknown => VerifyReport {
+                verdict: Verdict::Unknown,
+                init_time,
+                applicable_time,
+                verify_time,
+            },
+        })
+    }
+
+    fn open_log_file<P: AsRef<Path>>(log_dir: std::path::PathBuf, name: P) -> Result<File> {
+        std::fs::create_dir_all(&log_dir)?;
+        let path = log_dir.join(name);
+        let file = File::create(&path)?;
+        Ok(file)
+    }
+}
+
+/// Human-readable description of an expansion.
+fn expansion_description(expansion: &Expansion, prog: &Program) -> Result<String> {
+    let rule_id = expansion
+        .rules
+        .first()
+        .ok_or(format_err!("expansion should have at least one rule"))?;
+    let rule = prog.rule(*rule_id);
+    Ok(rule.identifier(&prog.tyenv, &prog.files))
+}
diff --git a/cranelift/isle/veri/veri/src/solver.rs b/cranelift/isle/veri/veri/src/solver.rs
new file mode 100644
index 000000000000..41aec640f203
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/solver.rs
@@ -0,0 +1,1006 @@
+use std::{cmp::Ordering, iter::zip};
+
+use anyhow::{bail, format_err, Context as _, Error, Result};
+use easy_smt::{Context, Response, SExpr, SExprData};
+use num_bigint::BigUint;
+use num_traits::Num as _;
+
+use crate::{
+    program::Program,
+    type_inference::Assignment,
+    types::{Const, Type, Width},
+    veri::{Conditions, Expr, ExprId, Model},
+};
+
+use crate::encoded::cls::*;
+use crate::encoded::clz::*;
+use crate::encoded::popcnt::*;
+use crate::encoded::rev::*;
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum Applicability {
+    Applicable,
+    Inapplicable,
+    Unknown,
+}
+
+impl std::fmt::Display for Applicability {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.write_str(match self {
+            Applicability::Applicable => "applicable",
+            Applicability::Inapplicable => "inapplicable",
+            Applicability::Unknown => "unknown",
+        })
+    }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum Verification {
+    Success,
+    Failure(Model),
+    Unknown,
+}
+
+impl std::fmt::Display for Verification {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.write_str(match self {
+            Verification::Success => "success",
+            Verification::Failure(_) => "failure",
+            Verification::Unknown => "unknown",
+        })
+    }
+}
+
+enum RotationDirection {
+    Left,
+    Right,
+}
+
+static UNSPECIFIED_SORT: &str = "Unspecified";
+static UNIT_SORT: &str = "Unit";
+
+static ROUND_NEAREST_TIES_TO_EVEN: &str = "roundNearestTiesToEven";
+static ROUND_TOWARD_ZERO: &str = "roundTowardZero";
+static ROUND_TOWARD_POSITIVE: &str = "roundTowardPositive";
+static ROUND_TOWARD_NEGATIVE: &str = "roundTowardNegative";
+static ROUNDING_MODE: &str = ROUND_NEAREST_TIES_TO_EVEN;
+
+/// SMT Dialect.
+#[derive(Default, Debug, Clone, Copy)]
+pub enum Dialect {
+    /// SMT-LIB2 standard.
+    #[default]
+    SMTLIB2,
+    /// SMT-LIB2 with Z3 extensions.
+    Z3,
+}
+
+pub struct Solver<'a> {
+    smt: Context,
+    dialect: Dialect,
+    prog: &'a Program,
+    conditions: &'a Conditions,
+    assignment: &'a Assignment,
+    tmp_idx: usize,
+}
+
+impl Drop for Solver<'_> {
+    fn drop(&mut self) {
+        // Attempt clean exit.
+        let _ = self.exit();
+    }
+}
+
+impl<'a> Solver<'a> {
+    pub fn new(
+        smt: Context,
+        prog: &'a Program,
+        conditions: &'a Conditions,
+        assignment: &'a Assignment,
+    ) -> Result<Self> {
+        let mut solver = Self {
+            smt,
+            dialect: Dialect::default(),
+            prog,
+            conditions,
+            assignment,
+            tmp_idx: 0,
+        };
+        solver.prelude()?;
+        Ok(solver)
+    }
+
+    pub fn set_dialect(&mut self, dialect: Dialect) {
+        self.dialect = dialect;
+    }
+
+    fn prelude(&mut self) -> Result<()> {
+        // Set logic. Required for some SMT solvers.
+        self.smt.set_logic("ALL")?;
+
+        // Declare sorts for special-case types.
+        self.smt.declare_sort(UNSPECIFIED_SORT, 0)?;
+        self.smt.declare_sort(UNIT_SORT, 0)?;
+
+        Ok(())
+    }
+
+    pub fn encode(&mut self) -> Result<()> {
+        // Expressions
+        for (i, expr) in self.conditions.exprs.iter().enumerate() {
+            let x = ExprId(i);
+            self.declare_expr(x)?;
+            if !expr.is_variable() {
+                self.assign_expr(x, expr)?;
+            }
+        }
+
+        Ok(())
+    }
+
+    pub fn check_assumptions_feasibility(&mut self) -> Result<Applicability> {
+        // Enter solver context frame.
+        self.smt.push()?;
+
+        // Assumptions
+        let assumptions = self.all(&self.conditions.assumptions);
+        self.smt.assert(assumptions)?;
+
+        // Check
+        let verdict = match self.check()? {
+            Response::Sat => Applicability::Applicable,
+            Response::Unsat => Applicability::Inapplicable,
+            Response::Unknown => Applicability::Unknown,
+        };
+
+        // Leave solver context frame.
+        self.smt.pop()?;
+
+        Ok(verdict)
+    }
+
+    pub fn check_verification_condition(&mut self) -> Result<Verification> {
+        // Enter solver context frame.
+        self.smt.push()?;
+
+        // Verification Condition
+        self.verification_condition()?;
+
+        // Check
+        let verdict = match self.check()? {
+            Response::Sat => Verification::Failure(self.model()?),
+            Response::Unsat => Verification::Success,
+            Response::Unknown => Verification::Unknown,
+        };
+
+        // Leave solver context frame.
+        self.smt.pop()?;
+
+        Ok(verdict)
+    }
+
+    fn check(&mut self) -> Result<Response> {
+        // Send check-sat command. Prefer (check-sat-using default) for Z3.
+        let cmd = self.smt.list(match self.dialect {
+            Dialect::SMTLIB2 => vec![self.smt.atoms().check_sat],
+            Dialect::Z3 => vec![self.smt.atom("check-sat-using"), self.smt.atom("default")],
+        });
+
+        self.smt.raw_send(cmd)?;
+
+        // Parse response.
+        let resp = self.smt.raw_recv()?;
+        let atoms = self.smt.atoms();
+        if resp == atoms.sat {
+            Ok(Response::Sat)
+        } else if resp == atoms.unsat {
+            Ok(Response::Unsat)
+        } else if resp == atoms.unknown {
+            Ok(Response::Unknown)
+        } else {
+            bail!("bad solver check response: {}", self.smt.display(resp))
+        }
+    }
+
+    pub fn exit(&mut self) -> Result<()> {
+        // Send (exit) command.
+        let exit = self.smt.list(vec![self.smt.atom("exit")]);
+        self.smt.raw_send(exit)?;
+
+        // Expect success response.
+        let resp = self.smt.raw_recv()?;
+        let atoms = self.smt.atoms();
+        if resp != atoms.success {
+            bail!("bad solver exit: {}", self.smt.display(resp))
+        }
+        Ok(())
+    }
+
+    pub fn model(&mut self) -> Result<Model> {
+        let xs: Vec<_> = (0..self.conditions.exprs.len()).map(ExprId).collect();
+        let expr_atoms = xs.iter().map(|x| self.expr_atom(*x)).collect();
+        let values = self.smt.get_value(expr_atoms)?;
+        let consts = values
+            .iter()
+            .map(|(_, v)| self.const_from_sexpr(*v))
+            .collect::<Result<Vec<_>>>()?;
+        Ok(zip(xs, consts).collect())
+    }
+
+    fn declare_expr(&mut self, x: ExprId) -> Result<()> {
+        // Determine expression type value.
+        let tv = self.assignment.try_assignment(x)?;
+
+        // Map to corresponding SMT2 type.
+        let sort = self.type_to_sort(&tv.ty())?;
+
+        // Declare.
+        self.smt.declare_const(self.expr_name(x), sort)?;
+
+        Ok(())
+    }
+
+    fn type_to_sort(&self, ty: &Type) -> Result<SExpr> {
+        match *ty {
+            Type::BitVector(Width::Bits(width)) => {
+                Ok(self.smt.bit_vec_sort(self.smt.numeral(width)))
+            }
+            Type::Int => Ok(self.smt.int_sort()),
+            Type::Bool => Ok(self.smt.bool_sort()),
+            Type::Unspecified => Ok(self.smt.atom(UNSPECIFIED_SORT)),
+            Type::Unit => Ok(self.smt.atom(UNIT_SORT)),
+            Type::Unknown | Type::BitVector(Width::Unknown) => {
+                bail!("no smt2 sort for non-concrete type {ty}")
+            }
+        }
+    }
+
+    fn assign_expr(&mut self, x: ExprId, expr: &Expr) -> Result<()> {
+        let lhs = self.smt.atom(self.expr_name(x));
+        let rhs = self
+            .expr_to_smt(expr)
+            .map_err(|err| self.error(x, err.to_string()))?;
+        Ok(self.smt.assert(
+            self.smt
+                .named(format!("expr{}", x.index()), self.smt.eq(lhs, rhs)),
+        )?)
+    }
+
+    fn expr_to_smt(&mut self, expr: &Expr) -> Result<SExpr> {
+        match *expr {
+            Expr::Variable(_) => unreachable!("variables have no corresponding expression"),
+            Expr::Const(ref c) => Ok(self.constant(c)),
+            Expr::Not(x) => Ok(self.smt.not(self.expr_atom(x))),
+            Expr::And(x, y) => Ok(self.smt.and(self.expr_atom(x), self.expr_atom(y))),
+            Expr::Or(x, y) => Ok(self.smt.or(self.expr_atom(x), self.expr_atom(y))),
+            Expr::Imp(x, y) => Ok(self.smt.imp(self.expr_atom(x), self.expr_atom(y))),
+            Expr::Eq(x, y) => Ok(self.smt.eq(self.expr_atom(x), self.expr_atom(y))),
+            Expr::Lt(x, y) => Ok(self.smt.lt(self.expr_atom(x), self.expr_atom(y))),
+            Expr::Lte(x, y) => Ok(self.smt.lte(self.expr_atom(x), self.expr_atom(y))),
+            Expr::BVUgt(x, y) => Ok(self.smt.bvugt(self.expr_atom(x), self.expr_atom(y))),
+            Expr::BVUge(x, y) => Ok(self.smt.bvuge(self.expr_atom(x), self.expr_atom(y))),
+            Expr::BVUlt(x, y) => Ok(self.smt.bvult(self.expr_atom(x), self.expr_atom(y))),
+            Expr::BVUle(x, y) => Ok(self.smt.bvule(self.expr_atom(x), self.expr_atom(y))),
+            Expr::BVSgt(x, y) => Ok(self.smt.bvsgt(self.expr_atom(x), self.expr_atom(y))),
+            Expr::BVSge(x, y) => Ok(self.smt.bvsge(self.expr_atom(x), self.expr_atom(y))),
+            Expr::BVSlt(x, y) => Ok(self.smt.bvslt(self.expr_atom(x), self.expr_atom(y))),
+            Expr::BVSle(x, y) => Ok(self.smt.bvsle(self.expr_atom(x), self.expr_atom(y))),
+            Expr::BVSaddo(x, y) => Ok(self.smt.list(vec![
+                self.smt.atom("bvsaddo"),
+                self.expr_atom(x),
+                self.expr_atom(y),
+            ])),
+            Expr::BVNot(x) => Ok(self.smt.bvnot(self.expr_atom(x))),
+            Expr::Cls(x) => {
+                let width = self
+                    .assignment
+                    .try_bit_vector_width(x)
+                    .context("cls semantics require known width")?;
+                let xe = self.expr_atom(x);
+                let id = x.index();
+                match width {
+                    8 => Ok(cls8(&mut self.smt, xe, id)),
+                    16 => Ok(cls16(&mut self.smt, xe, id)),
+                    32 => Ok(cls32(&mut self.smt, xe, id)),
+                    64 => Ok(cls64(&mut self.smt, xe, id)),
+                    _ => unimplemented!("unexpected CLS width"),
+                }
+            }
+            Expr::Clz(x) => {
+                let width = self
+                    .assignment
+                    .try_bit_vector_width(x)
+                    .context("clz semantics require known width")?;
+                let xe = self.expr_atom(x);
+                let id: usize = x.index();
+                match width {
+                    1 => Ok(clz1(&mut self.smt, xe, id)),
+                    8 => Ok(clz8(&mut self.smt, xe, id)),
+                    16 => Ok(clz16(&mut self.smt, xe, id)),
+                    32 => Ok(clz32(&mut self.smt, xe, id)),
+                    64 => Ok(clz64(&mut self.smt, xe, id)),
+                    _ => unimplemented!("unexpected CLZ width"),
+                }
+            }
+            Expr::Rev(x) => {
+                let width = self
+                    .assignment
+                    .try_bit_vector_width(x)
+                    .context("cls semantics require known width")?;
+                let xe = self.expr_atom(x);
+                let id: usize = x.index();
+                match width {
+                    1 => Ok(rev1(&mut self.smt, xe, id)),
+                    8 => Ok(rev8(&mut self.smt, xe, id)),
+                    16 => Ok(rev16(&mut self.smt, xe, id)),
+                    32 => Ok(rev32(&mut self.smt, xe, id)),
+                    64 => Ok(rev64(&mut self.smt, xe, id)),
+                    _ => unimplemented!("unexpected CLS width"),
+                }
+            }
+            Expr::Popcnt(x) => {
+                let width = self
+                    .assignment
+                    .try_bit_vector_width(x)
+                    .context("popcnt semantics require known width")?;
+                let xe = self.expr_atom(x);
+                let id = x.index();
+                match width {
+                    8 | 16 | 32 | 64 => Ok(popcnt(&mut self.smt, width, xe, id)),
+                    _ => unimplemented!("unexpected Popcnt width"),
+                }
+            }
+
+            Expr::Add(x, y) => Ok(self.smt.plus(self.expr_atom(x), self.expr_atom(y))),
+            Expr::Sub(x, y) => Ok(self.smt.sub(self.expr_atom(x), self.expr_atom(y))),
+            Expr::Mul(x, y) => Ok(self.smt.times(self.expr_atom(x), self.expr_atom(y))),
+
+            Expr::BVNeg(x) => Ok(self.smt.bvneg(self.expr_atom(x))),
+            Expr::BVAdd(x, y) => Ok(self.smt.bvadd(self.expr_atom(x), self.expr_atom(y))),
+            Expr::BVOr(x, y) => Ok(self.smt.bvor(self.expr_atom(x), self.expr_atom(y))),
+            Expr::BVXor(x, y) => Ok(self.smt.bvxor(self.expr_atom(x), self.expr_atom(y))),
+            Expr::BVSub(x, y) => Ok(self.smt.bvsub(self.expr_atom(x), self.expr_atom(y))),
+            Expr::BVMul(x, y) => Ok(self.smt.bvmul(self.expr_atom(x), self.expr_atom(y))),
+            Expr::BVSDiv(x, y) => Ok(self.smt.list(vec![
+                self.smt.atom("bvsdiv"),
+                self.expr_atom(x),
+                self.expr_atom(y),
+            ])),
+            Expr::BVUDiv(x, y) => Ok(self.smt.bvudiv(self.expr_atom(x), self.expr_atom(y))),
+            Expr::BVSRem(x, y) => Ok(self.smt.bvsrem(self.expr_atom(x), self.expr_atom(y))),
+            Expr::BVURem(x, y) => Ok(self.smt.bvurem(self.expr_atom(x), self.expr_atom(y))),
+            Expr::BVAnd(x, y) => Ok(self.smt.bvand(self.expr_atom(x), self.expr_atom(y))),
+            Expr::BVShl(x, y) => Ok(self.smt.bvshl(self.expr_atom(x), self.expr_atom(y))),
+            Expr::BVLShr(x, y) => Ok(self.smt.bvlshr(self.expr_atom(x), self.expr_atom(y))),
+            Expr::BVAShr(x, y) => Ok(self.smt.bvashr(self.expr_atom(x), self.expr_atom(y))),
+            Expr::BVRotl(x, y) => {
+                let width = self
+                    .assignment
+                    .try_bit_vector_width(x)
+                    .context("target of rotl expression should be a bit-vector of known width")?;
+                let xs = self.expr_atom(x);
+                let ys = self.expr_atom(y);
+                Ok(self.encode_rotate(RotationDirection::Left, xs, ys, width))
+            }
+            Expr::BVRotr(x, y) => {
+                let width = self
+                    .assignment
+                    .try_bit_vector_width(x)
+                    .context("target of rotr expression should be a bit-vector of known width")?;
+                let xs = self.expr_atom(x);
+                let ys = self.expr_atom(y);
+                Ok(self.encode_rotate(RotationDirection::Right, xs, ys, width))
+            }
+            Expr::Conditional(c, t, e) => {
+                Ok(self
+                    .smt
+                    .ite(self.expr_atom(c), self.expr_atom(t), self.expr_atom(e)))
+            }
+            Expr::BVZeroExt(w, x) => self.bv_zero_ext(w, x),
+            Expr::BVSignExt(w, x) => self.bv_sign_ext(w, x),
+            Expr::BVConvTo(w, x) => self.bv_conv_to(w, x),
+            Expr::BVExtract(h, l, x) => Ok(self.extract(h, l, self.expr_atom(x))),
+            Expr::BVConcat(x, y) => Ok(self.smt.concat(self.expr_atom(x), self.expr_atom(y))),
+            Expr::Int2BV(w, x) => self.int_to_bv(w, x),
+            Expr::BV2Nat(x) => Ok(self
+                .smt
+                .list(vec![self.smt.atom("bv2nat"), self.expr_atom(x)])),
+            Expr::ToFP(w, x) => self.to_fp_from_expr(w, x, true),
+            Expr::ToFPUnsigned(w, x) => self.to_fp_from_expr(w, x, false),
+            Expr::ToFPFromFP(w, x) => self.to_fp_from_fp(w, x),
+            Expr::FPToUBV(w, x) => self.fp_to_bv(w, x, false),
+            Expr::FPToSBV(w, x) => self.fp_to_bv(w, x, true),
+            Expr::WidthOf(x) => self.width_of(x),
+            Expr::FPPositiveInfinity(x) => Ok(self.fp_value("+oo", x)?),
+            Expr::FPNegativeInfinity(x) => Ok(self.fp_value("-oo", x)?),
+            Expr::FPPositiveZero(x) => Ok(self.fp_value("+zero", x)?),
+            Expr::FPNegativeZero(x) => Ok(self.fp_value("-zero", x)?),
+            Expr::FPNaN(x) => Ok(self.fp_value("NaN", x)?),
+            Expr::FPEq(x, y) => Ok(self.fp_test("fp.eq", x, y)?),
+            Expr::FPNe(x, y) => {
+                let test_eq = self.fp_test("fp.eq", x, y)?;
+                Ok(self.smt.not(test_eq))
+            }
+            Expr::FPLt(x, y) => Ok(self.fp_test("fp.lt", x, y)?),
+            Expr::FPGt(x, y) => Ok(self.fp_test("fp.gt", x, y)?),
+            Expr::FPLe(x, y) => Ok(self.fp_test("fp.leq", x, y)?),
+            Expr::FPGe(x, y) => Ok(self.fp_test("fp.geq", x, y)?),
+            Expr::FPAdd(x, y) => Ok(self.fp_rounding_binary("fp.add", x, y)?),
+            Expr::FPSub(x, y) => Ok(self.fp_rounding_binary("fp.sub", x, y)?),
+            Expr::FPMul(x, y) => Ok(self.fp_rounding_binary("fp.mul", x, y)?),
+            Expr::FPDiv(x, y) => Ok(self.fp_rounding_binary("fp.div", x, y)?),
+            Expr::FPMin(x, y) => Ok(self.fp_binary("fp.min", x, y)?),
+            Expr::FPMax(x, y) => Ok(self.fp_binary("fp.max", x, y)?),
+            Expr::FPNeg(x) => Ok(self.fp_unary("fp.neg", x)?),
+            Expr::FPCeil(x) => {
+                Ok(self.fp_rounding_unary("fp.roundToIntegral", ROUND_TOWARD_POSITIVE, x)?)
+            }
+            Expr::FPFloor(x) => {
+                Ok(self.fp_rounding_unary("fp.roundToIntegral", ROUND_TOWARD_NEGATIVE, x)?)
+            }
+            Expr::FPSqrt(x) => {
+                Ok(self.fp_rounding_unary("fp.sqrt", ROUND_NEAREST_TIES_TO_EVEN, x)?)
+            }
+            Expr::FPTrunc(x) => {
+                Ok(self.fp_rounding_unary("fp.roundToIntegral", ROUND_TOWARD_ZERO, x)?)
+            }
+            Expr::FPNearest(x) => {
+                Ok(self.fp_rounding_unary("fp.roundToIntegral", ROUND_NEAREST_TIES_TO_EVEN, x)?)
+            }
+            Expr::FPIsZero(x) => Ok(self.fp_unary_predicate("fp.isZero", x)?),
+            Expr::FPIsInfinite(x) => Ok(self.fp_unary_predicate("fp.isInfinite", x)?),
+            Expr::FPIsNaN(x) => Ok(self.fp_unary_predicate("fp.isNaN", x)?),
+            Expr::FPIsNegative(x) => Ok(self.fp_unary_predicate("fp.isNegative", x)?),
+            Expr::FPIsPositive(x) => Ok(self.fp_unary_predicate("fp.isPositive", x)?),
+        }
+    }
+
+    fn constant(&self, constant: &Const) -> SExpr {
+        match *constant {
+            Const::Bool(true) => self.smt.true_(),
+            Const::Bool(false) => self.smt.false_(),
+            Const::Int(v) => self.smt.numeral(v),
+            Const::BitVector(w, ref v) => self.smt.atom(format!("#b{v:0>w$b}")),
+            Const::Unspecified => unimplemented!("constant of unspecified type"),
+        }
+    }
+
+    fn bv_zero_ext(&self, w: ExprId, x: ExprId) -> Result<SExpr> {
+        // TODO(mbm): dedupe logic with bv_sign_ext and bv_conv_to?
+
+        // Destination width expression should have known integer value.
+        let dst: usize = self
+            .assignment
+            .try_int_value(w)
+            .context("destination width of zero_ext expression should have known integer value")?
+            .try_into()
+            .expect("width should be representable as usize");
+
+        // Expression type should be a bit-vector of known width.
+        let src = self
+            .assignment
+            .try_bit_vector_width(x)
+            .context("source of zero_ext expression should be a bit-vector of known width")?;
+
+        // Build zero_extend expression.
+        let padding = dst
+            .checked_sub(src)
+            .ok_or(format_err!("cannot zero extend to smaller width"))?;
+        Ok(self.zero_extend(padding, self.expr_atom(x)))
+    }
+
+    fn bv_sign_ext(&self, w: ExprId, x: ExprId) -> Result<SExpr> {
+        // TODO(mbm): dedupe logic with bv_conv_to?
+
+        // Destination width expression should have known integer value.
+        let dst: usize = self
+            .assignment
+            .try_int_value(w)
+            .context("destination width of sign_ext expression should have known integer value")?
+            .try_into()
+            .expect("width should be representable as usize");
+
+        // Expression type should be a bit-vector of known width.
+        let src = self
+            .assignment
+            .try_bit_vector_width(x)
+            .context("source of sign_ext expression should be a bit-vector of known width")?;
+
+        // Build sign_extend expression.
+        let padding = dst
+            .checked_sub(src)
+            .ok_or(format_err!("cannot sign extend to smaller width"))?;
+        Ok(self.sign_extend(padding, self.expr_atom(x)))
+    }
+
+    fn bv_conv_to(&mut self, w: ExprId, x: ExprId) -> Result<SExpr> {
+        // Destination width expression should have known integer value.
+        let dst: usize = self
+            .assignment
+            .try_int_value(w)
+            .context("destination width of conv_to expression should have known integer value")?
+            .try_into()
+            .expect("width should be representable as usize");
+
+        // Expression type should be a bit-vector of known width.
+        let src = self
+            .assignment
+            .try_bit_vector_width(x)
+            .context("source of conv_to expression should be a bit-vector of known width")?;
+
+        // Handle depending on source and destination widths.
+        match dst.cmp(&src) {
+            Ordering::Greater => {
+                let padding = self.declare_bit_vec("conv_to_padding", dst - src)?;
+                Ok(self.smt.concat(padding, self.expr_atom(x)))
+            }
+            Ordering::Less => {
+                // QUESTION(mbm): conv_to smaller destination: safe to discard high bits?
+                let high_bit = dst.checked_sub(1).unwrap();
+                Ok(self.extract(high_bit, 0, self.expr_atom(x)))
+            }
+            Ordering::Equal => Ok(self.expr_atom(x)),
+        }
+    }
+
+    fn int_to_bv(&self, w: ExprId, x: ExprId) -> Result<SExpr> {
+        // Destination width expression should have known integer value.
+        let width: usize = self
+            .assignment
+            .try_int_value(w)
+            .context("destination width of int2bv expression should have known integer value")?
+            .try_into()
+            .expect("width should be representable as usize");
+
+        // Build int2bv expression.
+        Ok(self.int2bv(width, self.expr_atom(x)))
+    }
+
+    fn width_of(&self, x: ExprId) -> Result<SExpr> {
+        // QUESTION(mbm): should width_of expressions be elided or replaced after type inference?
+
+        // Expression type should be a bit-vector of known width.
+        let width = self
+            .assignment
+            .try_bit_vector_width(x)
+            .context("target of width_of expression should be a bit-vector of known width")?;
+
+        // Substitute known constant width.
+        Ok(self.smt.numeral(width))
+    }
+
+    fn verification_condition(&mut self) -> Result<()> {
+        // (not (<assumptions> => <assertions>))
+        let assumptions = self.all(&self.conditions.assumptions);
+        let assertions = self.all(&self.conditions.assertions);
+        let vc = self.smt.imp(assumptions, assertions);
+        self.smt.assert(self.smt.not(vc))?;
+        Ok(())
+    }
+
+    /// Zero-extend an SMT bit vector to a wider bit vector by adding `padding`
+    /// zeroes to the front.
+    fn zero_extend(&self, padding: usize, v: SExpr) -> SExpr {
+        if padding == 0 {
+            return v;
+        }
+        self.smt.list(vec![
+            self.smt.list(vec![
+                self.smt.atoms().und,
+                self.smt.atom("zero_extend"),
+                self.smt.numeral(padding),
+            ]),
+            v,
+        ])
+    }
+
+    /// Sign-extend an SMT bit vector to a wider bit vector.
+    fn sign_extend(&self, padding: usize, v: SExpr) -> SExpr {
+        if padding == 0 {
+            return v;
+        }
+        self.smt.list(vec![
+            self.smt.list(vec![
+                self.smt.atoms().und,
+                self.smt.atom("sign_extend"),
+                self.smt.numeral(padding),
+            ]),
+            v,
+        ])
+    }
+
+    fn extract(&self, high_bit: usize, low_bit: usize, v: SExpr) -> SExpr {
+        assert!(low_bit <= high_bit);
+        self.smt
+            .extract(high_bit.try_into().unwrap(), low_bit.try_into().unwrap(), v)
+    }
+
+    /// Convert an SMT integer to a bit vector of a given width.
+    fn int2bv(&self, width: usize, value: SExpr) -> SExpr {
+        self.smt.list(vec![
+            self.smt.list(vec![
+                self.smt.atoms().und,
+                self.smt.atom("int2bv"),
+                self.smt.numeral(width),
+            ]),
+            value,
+        ])
+    }
+
+    /// Floating point special values.
+    fn fp_value(&mut self, op: &str, w: ExprId) -> Result<SExpr> {
+        let width = self
+            .assignment
+            .try_int_value(w)
+            .context("floating point constant width should have known integer value")?
+            .try_into()?;
+        let (eb, sb) = Self::fp_exponent_significand_bits(width)?;
+        let result_fp = self.smt.list(vec![
+            self.smt.atoms().und,
+            self.smt.atom(op),
+            self.smt.numeral(eb),
+            self.smt.numeral(sb),
+        ]);
+
+        // Return bit-vector that's equal to the expression as a floating point.
+        let result = self.declare_bit_vec(op, width)?;
+        let result_as_fp = self.to_fp(result, width)?;
+        self.smt.assert(self.smt.eq(result_as_fp, result_fp))?;
+
+        Ok(result)
+    }
+
+    /// Floating point unary operand without rounding.
+    fn fp_unary(&mut self, op: &str, x: ExprId) -> Result<SExpr> {
+        // Convert to floating point.
+        let width = self
+            .assignment
+            .try_bit_vector_width(x)
+            .context("floating point expression must be a bit-vector of known width")?;
+
+        let x = self.to_fp(self.expr_atom(x), width)?;
+
+        // Unary expression.
+        let result_fp = self.smt.list(vec![self.smt.atom(op), x]);
+
+        // Return bit-vector that's equal to the expression as a floating point.
+        let result = self.declare_bit_vec(op, width)?;
+        let result_as_fp = self.to_fp(result, width)?;
+        self.smt.assert(self.smt.eq(result_as_fp, result_fp))?;
+
+        Ok(result)
+    }
+
+    /// Floating point test operation without rounding, to boolean.
+    fn fp_test(&mut self, op: &str, x: ExprId, y: ExprId) -> Result<SExpr> {
+        // Convert to floating point.
+        let width = self
+            .assignment
+            .try_bit_vector_width(x)
+            .context("floating point expression must be a bit-vector of known width")?;
+
+        let x = self.to_fp(self.expr_atom(x), width)?;
+        let y = self.to_fp(self.expr_atom(y), width)?;
+
+        // Binary result, no conversion needed after test
+        Ok(self.smt.list(vec![self.smt.atom(op), x, y]))
+    }
+
+    /// Floating point binary operand without rounding.
+    fn fp_binary(&mut self, op: &str, x: ExprId, y: ExprId) -> Result<SExpr> {
+        // Convert to floating point.
+        let width = self
+            .assignment
+            .try_bit_vector_width(x)
+            .context("floating point expression must be a bit-vector of known width")?;
+
+        let x = self.to_fp(self.expr_atom(x), width)?;
+        let y = self.to_fp(self.expr_atom(y), width)?;
+
+        // Binary expression.
+        let result_fp = self.smt.list(vec![self.smt.atom(op), x, y]);
+
+        // Return bit-vector that's equal to the expression as a floating point.
+        let result = self.declare_bit_vec(op, width)?;
+        let result_as_fp = self.to_fp(result, width)?;
+        self.smt.assert(self.smt.eq(result_as_fp, result_fp))?;
+
+        Ok(result)
+    }
+
+    /// Floating point unary operand with rounding.
+    fn fp_rounding_unary(&mut self, op: &str, rounding_mode: &str, x: ExprId) -> Result<SExpr> {
+        // Convert to floating point.
+        let width = self
+            .assignment
+            .try_bit_vector_width(x)
+            .context("floating point expression must be a bit-vector of known width")?;
+
+        let x = self.to_fp(self.expr_atom(x), width)?;
+
+        // Unary expression.
+        let result_fp = self
+            .smt
+            .list(vec![self.smt.atom(op), self.smt.atom(rounding_mode), x]);
+
+        // Return bit-vector that's equal to the expression as a floating point.
+        let result = self.declare_bit_vec(op, width)?;
+        let result_as_fp = self.to_fp(result, width)?;
+        self.smt.assert(self.smt.eq(result_as_fp, result_fp))?;
+
+        Ok(result)
+    }
+
+    /// Floating point binary operand with rounding.
+    fn fp_rounding_binary(&mut self, op: &str, x: ExprId, y: ExprId) -> Result<SExpr> {
+        // Convert to floating point.
+        let width = self
+            .assignment
+            .try_bit_vector_width(x)
+            .context("floating point expression must be a bit-vector of known width")?;
+
+        let x = self.to_fp(self.expr_atom(x), width)?;
+        let y = self.to_fp(self.expr_atom(y), width)?;
+
+        // Binary expression.
+        let result_fp = self
+            .smt
+            .list(vec![self.smt.atom(op), self.smt.atom(ROUNDING_MODE), x, y]);
+
+        // Return bit-vector that's equal to the expression as a floating point.
+        let result = self.declare_bit_vec(op, width)?;
+        let result_as_fp = self.to_fp(result, width)?;
+        self.smt.assert(self.smt.eq(result_as_fp, result_fp))?;
+
+        Ok(result)
+    }
+
+    /// Floating point unary predicate.
+    fn fp_unary_predicate(&mut self, op: &str, x: ExprId) -> Result<SExpr> {
+        // Convert operand to floating point.
+        let width = self
+            .assignment
+            .try_bit_vector_width(x)
+            .context("floating point expression must be a bit-vector of known width")?;
+
+        let x = self.to_fp(self.expr_atom(x), width)?;
+
+        // Emit expression.
+        Ok(self.smt.list(vec![self.smt.atom(op), x]))
+    }
+
+    /// Represent an expression in SMT-LIB floating-point type.
+    fn to_fp(&self, x: SExpr, width: usize) -> Result<SExpr> {
+        let (eb, sb) = Self::fp_exponent_significand_bits(width)?;
+        Ok(self.smt.list(vec![
+            self.smt.list(vec![
+                self.smt.atoms().und,
+                self.smt.atom("to_fp"),
+                self.smt.numeral(eb),
+                self.smt.numeral(sb),
+            ]),
+            x,
+        ]))
+    }
+
+    fn to_fp_from_expr(&mut self, w: ExprId, xid: ExprId, signed: bool) -> Result<SExpr> {
+        // Destination width expression should have known integer value.
+        let width: usize = self
+            .assignment
+            .try_int_value(w)
+            .context("destination width of to_fp expression should have known integer value")?
+            .try_into()
+            .expect("width should be representable as usize");
+
+        let x = self.expr_atom(xid);
+        let (eb, sb) = Self::fp_exponent_significand_bits(width)?;
+        let fp = self.smt.list(vec![
+            self.smt.list(vec![
+                self.smt.atoms().und,
+                self.smt
+                    .atom(if signed { "to_fp" } else { "to_fp_unsigned" }),
+                self.smt.numeral(eb),
+                self.smt.numeral(sb),
+            ]),
+            self.smt.atom(ROUNDING_MODE),
+            x,
+        ]);
+        // Return bit-vector that's equal to the expression as a floating point.
+        let result = self.declare_bit_vec("conv", width)?;
+        let result_as_fp = self.to_fp(result, width)?;
+        self.smt.assert(self.smt.eq(result_as_fp, fp))?;
+
+        Ok(result)
+    }
+
+    fn fp_to_bv(&mut self, w: ExprId, x: ExprId, signed: bool) -> Result<SExpr> {
+        // Destination width expression should have known integer value.
+        let width: usize = self
+            .assignment
+            .try_int_value(w)
+            .context("destination width of fp_to_bv expression should have known integer value")?
+            .try_into()
+            .expect("width should be representable as usize");
+
+        let x = self.to_fp(self.expr_atom(x), width)?;
+
+        let fp: SExpr = self.smt.list(vec![
+            self.smt.list(vec![
+                self.smt.atoms().und,
+                self.smt
+                    .atom(if signed { "fp.to_sbv" } else { "fp.to_ubv" }),
+                self.smt.numeral(width),
+            ]),
+            self.smt.atom(ROUNDING_MODE),
+            x,
+        ]);
+
+        Ok(fp)
+    }
+
+    fn to_fp_from_fp(&mut self, w: ExprId, xid: ExprId) -> Result<SExpr> {
+        // Destination width expression should have known integer value.
+        let new_width: usize = self
+            .assignment
+            .try_int_value(w)
+            .context(
+                "destination width of to_fp_from_fp expression should have known integer value",
+            )?
+            .try_into()
+            .expect("width should be representable as usize");
+
+        // Convert operand to floating point.
+        let width = self
+            .assignment
+            .try_bit_vector_width(xid)
+            .context("floating point expression must be a bit-vector of known width")?;
+        let x = self.to_fp(self.expr_atom(xid), width)?;
+
+        let (eb, sb) = Self::fp_exponent_significand_bits(new_width)?;
+        let fp = self.smt.list(vec![
+            self.smt.list(vec![
+                self.smt.atoms().und,
+                self.smt.atom("to_fp"),
+                self.smt.numeral(eb),
+                self.smt.numeral(sb),
+            ]),
+            self.smt.atom(ROUNDING_MODE),
+            x,
+        ]);
+        // Return bit-vector that's equal to the expression as a floating point.
+        let result = self.declare_bit_vec("conv", new_width)?;
+        let result_as_fp = self.to_fp(result, new_width)?;
+        self.smt.assert(self.smt.eq(result_as_fp, fp))?;
+
+        Ok(result)
+    }
+
+    fn fp_exponent_significand_bits(width: usize) -> Result<(usize, usize)> {
+        Ok(match width {
+            32 => (8, 24),
+            64 => (11, 53),
+            _ => bail!("unsupported floating-point width"),
+        })
+    }
+
+    /// Parse a constant SMT expression.
+    fn const_from_sexpr(&self, sexpr: SExpr) -> Result<Const> {
+        match self.smt.get(sexpr) {
+            SExprData::Atom(a) => Self::const_from_literal(a),
+            SExprData::List(exprs) => self.const_from_qualified_abstract_value(exprs),
+        }
+    }
+
+    /// Parse a constant from an SMT literal.
+    fn const_from_literal(atom: &str) -> Result<Const> {
+        if atom == "true" {
+            Ok(Const::Bool(true))
+        } else if atom == "false" {
+            Ok(Const::Bool(false))
+        } else if let Some(x) = atom.strip_prefix("#x") {
+            Ok(Const::BitVector(
+                x.len() * 4,
+                BigUint::from_str_radix(x, 16)?,
+            ))
+        } else if let Some(x) = atom.strip_prefix("#b") {
+            Ok(Const::BitVector(x.len(), BigUint::from_str_radix(x, 2)?))
+        } else if atom.starts_with(|c: char| c.is_ascii_digit()) {
+            Ok(Const::Int(atom.parse()?))
+        } else {
+            bail!("unsupported smt literal: {atom}")
+        }
+    }
+
+    /// Parse a constant value of a declared sort from an SMT qualified abstract value.
+    fn const_from_qualified_abstract_value(&self, exprs: &[SExpr]) -> Result<Const> {
+        // This logic is specific to CVC5's representation of declared sort
+        // abstract values. Z3 uses a different format.  This function is
+        // therefore careful to check for the exact format it expects from CVC5.
+
+        // Expect a list of atoms.
+        let atoms = exprs
+            .iter()
+            .map(|e| match self.smt.get(*e) {
+                SExprData::Atom(a) => Ok(a),
+                SExprData::List(_) => bail!("expected atom in qualified identifier"),
+            })
+            .collect::<Result<Vec<_>>>()?;
+
+        // Expect the list to be of the form (as @<abstract_value> <sort>).
+        let ["as", value, sort] = atoms.as_slice() else {
+            bail!("unsupported qualified identifier: {atoms:?}");
+        };
+
+        // Expect an abstract value.
+        if !value.starts_with('@') {
+            bail!("expected qualified identifier constant to have abstract value");
+        }
+
+        // Construct constant based on the sort.
+        if sort == &UNSPECIFIED_SORT {
+            Ok(Const::Unspecified)
+        } else if sort == &UNIT_SORT {
+            todo!("unit sort")
+        } else {
+            bail!("unknown sort: '{sort}'");
+        }
+    }
+
+    fn all(&self, xs: &[ExprId]) -> SExpr {
+        self.smt.and_many(xs.iter().map(|x| self.expr_atom(*x)))
+    }
+
+    fn expr_atom(&self, x: ExprId) -> SExpr {
+        self.smt.atom(self.expr_name(x))
+    }
+
+    fn expr_name(&self, x: ExprId) -> String {
+        let expr = &self.conditions.exprs[x.index()];
+        if let Expr::Variable(v) = expr {
+            format!(
+                "{}_{}",
+                self.conditions.variables[v.index()].name,
+                x.index()
+            )
+        } else {
+            format!("e{}", x.index())
+        }
+    }
+
+    fn declare_bit_vec(&mut self, name: &str, n: usize) -> Result<SExpr> {
+        let name = format!("${name}{}", self.tmp_idx);
+        self.tmp_idx += 1;
+        let sort = self.smt.bit_vec_sort(self.smt.numeral(n));
+        self.smt.declare_const(&name, sort)?;
+        Ok(self.smt.atom(name))
+    }
+
+    fn encode_rotate(
+        &self,
+        op: RotationDirection,
+        source: SExpr,
+        amount: SExpr,
+        width: usize,
+    ) -> SExpr {
+        // SMT bitvector rotate_left requires that the rotate amount be
+        // statically specified. Instead, to use a dynamic amount, desugar
+        // to shifts and bit arithmetic.
+        let width_as_bv = self.smt.binary(width.try_into().unwrap(), width);
+        let wrapped_amount = self.smt.bvurem(amount, width_as_bv);
+        let wrapped_delta = self.smt.bvsub(width_as_bv, wrapped_amount);
+        match op {
+            RotationDirection::Left => self.smt.bvor(
+                self.smt.bvshl(source, wrapped_amount),
+                self.smt.bvlshr(source, wrapped_delta),
+            ),
+            RotationDirection::Right => self.smt.bvor(
+                self.smt.bvshl(source, wrapped_delta),
+                self.smt.bvlshr(source, wrapped_amount),
+            ),
+        }
+    }
+
+    fn error(&self, x: ExprId, msg: impl Into<String>) -> Error {
+        self.conditions.error_at_expr(self.prog, x, msg)
+    }
+}
diff --git a/cranelift/isle/veri/veri/src/spec.rs b/cranelift/isle/veri/veri/src/spec.rs
new file mode 100644
index 000000000000..e18a75bb29a7
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/spec.rs
@@ -0,0 +1,1109 @@
+use anyhow::{bail, format_err, Ok, Result};
+use cranelift_isle::{
+    ast::{self, AttrKind, AttrTarget, Def, Ident, Model, ModelType, Modifies, SpecOp},
+    lexer::Pos,
+    sema::{ReturnKind, RuleId, Sym, Term, TermEnv, TermId, TypeEnv, TypeId},
+};
+use std::{
+    collections::{hash_map::Entry, HashMap, HashSet},
+    fmt::Debug,
+};
+
+use crate::types::Field;
+use crate::types::Enum;
+use crate::types::{Compound, Const};
+
+// QUESTION(mbm): do we need this layer independent of AST spec types and Veri-IR?
+
+/// Positioned attaches positional information to a wrapped object.
+#[derive(Clone)]
+pub struct Positioned<X> {
+    pub pos: Pos,
+    pub x: X,
+}
+
+impl<X> Positioned<X> {
+    fn new(pos: Pos, x: X) -> Box<Self> {
+        Box::new(Self { pos, x })
+    }
+}
+
+impl<X: Debug> Debug for Positioned<X> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("Positioned")
+            .field(&self.pos)
+            .field(&self.x)
+            .finish()
+    }
+}
+
+pub type Expr = Box<Positioned<ExprKind>>;
+
+/// Spec expression.
+#[derive(Debug, Clone)]
+pub enum ExprKind {
+    // TODO(mbm): plumb positional information through spec expressions
+
+    // Terminal nodes
+    Var(Ident),
+    Const(Const),
+    As(Expr, Compound),
+    Constructor(Constructor),
+    Field(Ident, Expr),
+    Discriminator(Ident, Expr),
+
+    // Get the width of a bitvector
+    WidthOf(Expr),
+
+    // Boolean operations
+    // QUESTION(mbm): would it be preferable to use the Binary(Opcode, ExprBox, ExprBox) form instead?
+    Not(Expr),
+    And(Vec<Expr>),
+    Or(Vec<Expr>),
+    Imp(Expr, Expr),
+    Eq(Expr, Expr),
+    Lt(Expr, Expr),
+    Lte(Expr, Expr),
+    Gt(Expr, Expr),
+    Gte(Expr, Expr),
+
+    BVSgt(Expr, Expr),
+    BVSge(Expr, Expr),
+    BVSlt(Expr, Expr),
+    BVSle(Expr, Expr),
+    BVUgt(Expr, Expr),
+    BVUge(Expr, Expr),
+    BVUlt(Expr, Expr),
+    BVUle(Expr, Expr),
+
+    BVSaddo(Expr, Expr),
+
+    // Integer arithmetic
+    Add(Expr, Expr),
+    Sub(Expr, Expr),
+    Mul(Expr, Expr),
+
+    // Bitvector operations
+
+    // Unary operators
+    BVNeg(Expr),
+    BVNot(Expr),
+    Cls(Expr),
+    Clz(Expr),
+    Rev(Expr),
+    Popcnt(Expr),
+
+    // Binary operators
+    BVAdd(Expr, Expr),
+    BVSub(Expr, Expr),
+    BVMul(Expr, Expr),
+    BVUDiv(Expr, Expr),
+    BVSDiv(Expr, Expr),
+    BVURem(Expr, Expr),
+    BVSRem(Expr, Expr),
+    BVAnd(Expr, Expr),
+    BVOr(Expr, Expr),
+    BVXor(Expr, Expr),
+    BVRotl(Expr, Expr),
+    BVRotr(Expr, Expr),
+    BVShl(Expr, Expr),
+    BVLShr(Expr, Expr),
+    BVAShr(Expr, Expr),
+
+    // Conversions
+    BVZeroExt(Expr, Expr),
+    BVSignExt(Expr, Expr),
+    // Conversion to wider/narrower bits, without an explicit extend.
+    BVConvTo(Expr, Expr),
+    ToFP(Expr, Expr),
+    ToFPUnsigned(Expr, Expr),
+    ToFPFromFP(Expr, Expr),
+    FPToUBV(Expr, Expr),
+    FPToSBV(Expr, Expr),
+
+    // Extract specified bits
+    BVExtract(usize, usize, Expr),
+
+    // Concatenate bitvectors.
+    BVConcat(Vec<Expr>),
+    BVReplicate(Expr, usize),
+
+    // Convert between integers and bitvector.
+    Int2BV(Expr, Expr),
+    BV2Nat(Expr),
+
+    // Floating point.
+    FPPositiveInfinity(Expr),
+    FPNegativeInfinity(Expr),
+    FPPositiveZero(Expr),
+    FPNegativeZero(Expr),
+    FPNaN(Expr),
+    FPEq(Expr, Expr),
+    FPNe(Expr, Expr),
+    FPLt(Expr, Expr),
+    FPGt(Expr, Expr),
+    FPLe(Expr, Expr),
+    FPGe(Expr, Expr),
+    FPAdd(Expr, Expr),
+    FPSub(Expr, Expr),
+    FPMul(Expr, Expr),
+    FPDiv(Expr, Expr),
+    FPMin(Expr, Expr),
+    FPMax(Expr, Expr),
+    FPNeg(Expr),
+    FPCeil(Expr),
+    FPFloor(Expr),
+    FPSqrt(Expr),
+    FPTrunc(Expr),
+    FPNearest(Expr),
+    FPIsZero(Expr),
+    FPIsInfinite(Expr),
+    FPIsNaN(Expr),
+    FPIsNegative(Expr),
+    FPIsPositive(Expr),
+
+    // Conditional if-then-else
+    Conditional(Expr, Expr, Expr),
+    // Switch
+    Switch(Expr, Vec<(Expr, Expr)>),
+    // Match
+    Match(Expr, Vec<Arm>),
+    // Let bindings
+    Let(Vec<(Ident, Expr)>, Expr),
+    // With scope.
+    With(Vec<Ident>, Expr),
+    // Macro definition.
+    Macro(Vec<Ident>, Expr),
+    // Macro expansion.
+    Expand(Ident, Vec<Expr>),
+}
+
+macro_rules! unary_expr {
+    ($expr:path, $args:ident, $pos:ident) => {{
+        // TODO(mbm): return error instead of assert
+        assert_eq!(
+            $args.len(),
+            1,
+            "Unexpected number of args for unary operator at {:?}",
+            $pos
+        );
+        $expr(expr_from_ast(&$args[0]))
+    }};
+}
+
+macro_rules! binary_expr {
+    ($expr:path, $args:ident, $pos:ident) => {{
+        // TODO(mbm): return error instead of assert
+        assert_eq!(
+            $args.len(),
+            2,
+            "Unexpected number of args for binary operator at {:?}",
+            $pos
+        );
+        $expr(expr_from_ast(&$args[0]), expr_from_ast(&$args[1]))
+    }};
+}
+
+macro_rules! ternary_expr {
+    ($expr:path, $args:ident, $pos:ident) => {{
+        // TODO(mbm): return error instead of assert
+        assert_eq!(
+            $args.len(),
+            3,
+            "Unexpected number of args for ternary operator at {:?}",
+            $pos
+        );
+        $expr(
+            expr_from_ast(&$args[0]),
+            expr_from_ast(&$args[1]),
+            expr_from_ast(&$args[2]),
+        )
+    }};
+}
+
+macro_rules! variadic_expr {
+    ($expr:path, $args:ident, $pos:ident) => {{
+        // TODO(mbm): return error instead of assert
+        assert!(
+            $args.len() >= 1,
+            "Unexpected number of args for variadic binary operator {:?}",
+            $pos
+        );
+        $expr(exprs_from_ast($args))
+    }};
+}
+
+fn expr_from_ast(expr: &ast::SpecExpr) -> Expr {
+    Positioned::new(expr.pos(), ExprKind::from_ast(expr))
+}
+
+fn exprs_from_ast(exprs: &[ast::SpecExpr]) -> Vec<Expr> {
+    exprs.iter().map(expr_from_ast).collect()
+}
+
+fn var_from_ident(ident: Ident) -> Expr {
+    Positioned::new(ident.1, ExprKind::Var(ident))
+}
+
+impl ExprKind {
+    fn from_ast(expr: &ast::SpecExpr) -> ExprKind {
+        match expr {
+            ast::SpecExpr::ConstInt { val, pos: _ } => ExprKind::Const(Const::Int(*val)),
+            ast::SpecExpr::ConstBool { val, pos: _ } => ExprKind::Const(Const::Bool(*val)),
+            ast::SpecExpr::ConstBitVec { val, width, pos: _ } => {
+                ExprKind::Const(Const::BitVector(*width, (*val).into()))
+            }
+            ast::SpecExpr::Var { var, pos: _ } => ExprKind::Var(var.clone()),
+            ast::SpecExpr::As { x, ty, pos: _ } => {
+                ExprKind::As(expr_from_ast(x), Compound::from_ast(ty))
+            }
+            ast::SpecExpr::Field { field, x, pos: _ } => {
+                ExprKind::Field(field.clone(), expr_from_ast(x))
+            }
+            ast::SpecExpr::Discriminator { variant, x, pos: _ } => {
+                ExprKind::Discriminator(variant.clone(), expr_from_ast(x))
+            }
+            ast::SpecExpr::Op { op, args, pos } => match op {
+                // Unary
+                SpecOp::Not => unary_expr!(ExprKind::Not, args, pos),
+                SpecOp::BVNot => unary_expr!(ExprKind::BVNot, args, pos),
+                SpecOp::BVNeg => unary_expr!(ExprKind::BVNeg, args, pos),
+                SpecOp::Cls => unary_expr!(ExprKind::Cls, args, pos),
+                SpecOp::Rev => unary_expr!(ExprKind::Rev, args, pos),
+                SpecOp::Clz => unary_expr!(ExprKind::Clz, args, pos),
+                SpecOp::Popcnt => unary_expr!(ExprKind::Popcnt, args, pos),
+
+                // Variadic binops
+                SpecOp::And => variadic_expr!(ExprKind::And, args, pos),
+                SpecOp::Or => variadic_expr!(ExprKind::Or, args, pos),
+
+                // Binary
+                SpecOp::Eq => binary_expr!(ExprKind::Eq, args, pos),
+                SpecOp::Lt => binary_expr!(ExprKind::Lt, args, pos),
+                SpecOp::Lte => binary_expr!(ExprKind::Lte, args, pos),
+                SpecOp::Gt => binary_expr!(ExprKind::Gt, args, pos),
+                SpecOp::Gte => binary_expr!(ExprKind::Gte, args, pos),
+                SpecOp::Imp => binary_expr!(ExprKind::Imp, args, pos),
+                SpecOp::Add => binary_expr!(ExprKind::Add, args, pos),
+                SpecOp::Sub => binary_expr!(ExprKind::Sub, args, pos),
+                SpecOp::Mul => binary_expr!(ExprKind::Mul, args, pos),
+                SpecOp::BVAnd => binary_expr!(ExprKind::BVAnd, args, pos),
+                SpecOp::BVOr => binary_expr!(ExprKind::BVOr, args, pos),
+                SpecOp::BVXor => binary_expr!(ExprKind::BVXor, args, pos),
+                SpecOp::BVAdd => binary_expr!(ExprKind::BVAdd, args, pos),
+                SpecOp::BVSub => binary_expr!(ExprKind::BVSub, args, pos),
+                SpecOp::BVMul => binary_expr!(ExprKind::BVMul, args, pos),
+                SpecOp::BVSdiv => binary_expr!(ExprKind::BVSDiv, args, pos),
+                SpecOp::BVUdiv => binary_expr!(ExprKind::BVUDiv, args, pos),
+                SpecOp::BVUrem => binary_expr!(ExprKind::BVURem, args, pos),
+                SpecOp::BVSrem => binary_expr!(ExprKind::BVSRem, args, pos),
+                SpecOp::BVShl => binary_expr!(ExprKind::BVShl, args, pos),
+                SpecOp::BVLshr => binary_expr!(ExprKind::BVLShr, args, pos),
+                SpecOp::BVAshr => binary_expr!(ExprKind::BVAShr, args, pos),
+                SpecOp::BVUle => binary_expr!(ExprKind::BVUle, args, pos),
+                SpecOp::BVUlt => binary_expr!(ExprKind::BVUlt, args, pos),
+                SpecOp::BVUgt => binary_expr!(ExprKind::BVUgt, args, pos),
+                SpecOp::BVUge => binary_expr!(ExprKind::BVUge, args, pos),
+                SpecOp::BVSlt => binary_expr!(ExprKind::BVSlt, args, pos),
+                SpecOp::BVSle => binary_expr!(ExprKind::BVSle, args, pos),
+                SpecOp::BVSgt => binary_expr!(ExprKind::BVSgt, args, pos),
+                SpecOp::BVSge => binary_expr!(ExprKind::BVSge, args, pos),
+                SpecOp::BVSaddo => binary_expr!(ExprKind::BVSaddo, args, pos),
+                SpecOp::Rotr => binary_expr!(ExprKind::BVRotr, args, pos),
+                SpecOp::Rotl => binary_expr!(ExprKind::BVRotl, args, pos),
+
+                // Conversions
+                SpecOp::ZeroExt => binary_expr!(ExprKind::BVZeroExt, args, pos),
+                SpecOp::SignExt => binary_expr!(ExprKind::BVSignExt, args, pos),
+                SpecOp::ConvTo => binary_expr!(ExprKind::BVConvTo, args, pos),
+                SpecOp::Concat => variadic_expr!(ExprKind::BVConcat, args, pos),
+                SpecOp::Replicate => {
+                    // TODO(mbm): return error instead of assert
+                    assert_eq!(
+                        args.len(),
+                        2,
+                        "Unexpected number of args for extract operator at {pos:?}",
+                    );
+                    let repeat = spec_expr_to_usize(&args[1]).unwrap();
+                    assert!(
+                        repeat > 0,
+                        "Unexpected repeat count for replicate operator at {pos:?}",
+                    );
+                    ExprKind::BVReplicate(expr_from_ast(&args[0]), repeat)
+                }
+                SpecOp::Extract => {
+                    // TODO(mbm): return error instead of assert
+                    assert_eq!(
+                        args.len(),
+                        3,
+                        "Unexpected number of args for extract operator at {pos:?}",
+                    );
+                    ExprKind::BVExtract(
+                        spec_expr_to_usize(&args[0]).unwrap(),
+                        spec_expr_to_usize(&args[1]).unwrap(),
+                        expr_from_ast(&args[2]),
+                    )
+                }
+                SpecOp::Int2BV => binary_expr!(ExprKind::Int2BV, args, pos),
+                SpecOp::BV2Nat => unary_expr!(ExprKind::BV2Nat, args, pos),
+                SpecOp::WidthOf => unary_expr!(ExprKind::WidthOf, args, pos),
+                SpecOp::ToFP => binary_expr!(ExprKind::ToFP, args, pos),
+                SpecOp::ToFPUnsigned => binary_expr!(ExprKind::ToFPUnsigned, args, pos),
+                SpecOp::ToFPFromFP => binary_expr!(ExprKind::ToFPFromFP, args, pos),
+                SpecOp::FPToUBV => binary_expr!(ExprKind::FPToUBV, args, pos),
+                SpecOp::FPToSBV => binary_expr!(ExprKind::FPToSBV, args, pos),
+
+                // Floating point (IEEE)
+                SpecOp::FPPositiveInfinity => unary_expr!(ExprKind::FPPositiveInfinity, args, pos),
+                SpecOp::FPNegativeInfinity => unary_expr!(ExprKind::FPNegativeInfinity, args, pos),
+                SpecOp::FPPositiveZero => unary_expr!(ExprKind::FPPositiveZero, args, pos),
+                SpecOp::FPNegativeZero => unary_expr!(ExprKind::FPNegativeZero, args, pos),
+                SpecOp::FPNaN => unary_expr!(ExprKind::FPNaN, args, pos),
+                SpecOp::FPEq => binary_expr!(ExprKind::FPEq, args, pos),
+                SpecOp::FPNe => binary_expr!(ExprKind::FPNe, args, pos),
+                SpecOp::FPLt => binary_expr!(ExprKind::FPLt, args, pos),
+                SpecOp::FPGt => binary_expr!(ExprKind::FPGt, args, pos),
+                SpecOp::FPLe => binary_expr!(ExprKind::FPLe, args, pos),
+                SpecOp::FPGe => binary_expr!(ExprKind::FPGe, args, pos),
+                SpecOp::FPAdd => binary_expr!(ExprKind::FPAdd, args, pos),
+                SpecOp::FPSub => binary_expr!(ExprKind::FPSub, args, pos),
+                SpecOp::FPMul => binary_expr!(ExprKind::FPMul, args, pos),
+                SpecOp::FPDiv => binary_expr!(ExprKind::FPDiv, args, pos),
+                SpecOp::FPMin => binary_expr!(ExprKind::FPMin, args, pos),
+                SpecOp::FPMax => binary_expr!(ExprKind::FPMax, args, pos),
+                SpecOp::FPNeg => unary_expr!(ExprKind::FPNeg, args, pos),
+                SpecOp::FPCeil => unary_expr!(ExprKind::FPCeil, args, pos),
+                SpecOp::FPFloor => unary_expr!(ExprKind::FPFloor, args, pos),
+                SpecOp::FPSqrt => unary_expr!(ExprKind::FPSqrt, args, pos),
+                SpecOp::FPTrunc => unary_expr!(ExprKind::FPTrunc, args, pos),
+                SpecOp::FPNearest => unary_expr!(ExprKind::FPNearest, args, pos),
+                SpecOp::FPIsZero => unary_expr!(ExprKind::FPIsZero, args, pos),
+                SpecOp::FPIsInfinite => unary_expr!(ExprKind::FPIsInfinite, args, pos),
+                SpecOp::FPIsNaN => unary_expr!(ExprKind::FPIsNaN, args, pos),
+                SpecOp::FPIsNegative => unary_expr!(ExprKind::FPIsNegative, args, pos),
+                SpecOp::FPIsPositive => unary_expr!(ExprKind::FPIsPositive, args, pos),
+
+                // Conditionals
+                SpecOp::If => ternary_expr!(ExprKind::Conditional, args, pos),
+                SpecOp::Switch => {
+                    assert!(
+                        args.len() > 1,
+                        "Unexpected number of args for switch operator {pos:?}",
+                    );
+                    let on = expr_from_ast(&args[0]);
+                    let arms: Vec<_> = args[1..]
+                        .iter()
+                        .map(|p| match p {
+                            ast::SpecExpr::Pair { l, r, pos: _ } => {
+                                (expr_from_ast(l), expr_from_ast(r))
+                            }
+                            // TODO(mbm): error rather than panic for non-pair in switch, since it's not actually unreachable
+                            _ => unreachable!("switch expression arguments must be pairs"),
+                        })
+                        .collect();
+                    ExprKind::Switch(on, arms)
+                }
+            },
+            ast::SpecExpr::Match { x, arms, pos: _ } => {
+                let x = expr_from_ast(x);
+                let arms = arms
+                    .iter()
+                    .map(|arm| Arm {
+                        variant: arm.variant.clone(),
+                        args: arm.args.clone(),
+                        body: expr_from_ast(&arm.body),
+                    })
+                    .collect();
+                ExprKind::Match(x, arms)
+            }
+            ast::SpecExpr::Let { defs, body, pos: _ } => {
+                let defs = defs
+                    .iter()
+                    .map(|(ident, x)| (ident.clone(), expr_from_ast(x)))
+                    .collect();
+                let body = expr_from_ast(body);
+                ExprKind::Let(defs, body)
+            }
+            ast::SpecExpr::With {
+                decls,
+                body,
+                pos: _,
+            } => {
+                let decls = decls.clone();
+                let body = expr_from_ast(body);
+                ExprKind::With(decls, body)
+            }
+            ast::SpecExpr::Pair { l, r, pos: _ } => {
+                // QUESTION(mbm): is there a cleaner way to handle switch statements without the pair type?
+                unreachable!(
+                    "pairs must only occur in switch expressions, {:?} {:?}",
+                    l, r
+                )
+            }
+            ast::SpecExpr::Enum {
+                name,
+                variant,
+                args,
+                pos: _,
+            } => ExprKind::Constructor(Constructor::Enum {
+                name: name.clone(),
+                variant: variant.clone(),
+                args: exprs_from_ast(args),
+            }),
+            ast::SpecExpr::Struct { fields, pos: _ } => {
+                ExprKind::Constructor(Constructor::Struct {
+                    fields: fields.iter().map(FieldInit::from_ast).collect(),
+                })
+            }
+            ast::SpecExpr::Macro {
+                params,
+                body,
+                pos: _,
+            } => ExprKind::Macro(params.clone(), expr_from_ast(body)),
+            ast::SpecExpr::Expand { name, args, pos: _ } => {
+                ExprKind::Expand(name.clone(), exprs_from_ast(args))
+            }
+        }
+    }
+}
+
+fn spec_expr_to_usize(expr: &ast::SpecExpr) -> Option<usize> {
+    match expr {
+        &ast::SpecExpr::ConstInt { val, pos: _ } => {
+            // TODO(mbm): return error rather than unwrap
+            Some(val.try_into().expect("constant should be unsigned size"))
+        }
+        _ => None,
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum Constructor {
+    Enum {
+        // TODO(mbm): Enum identifiers should be mapped to TermId?
+        name: Ident,
+        variant: Ident,
+        args: Vec<Expr>,
+    },
+    Struct {
+        fields: Vec<FieldInit>,
+    },
+}
+
+#[derive(Debug, Clone)]
+pub struct Arm {
+    pub variant: Ident,
+    pub args: Vec<Ident>,
+    pub body: Expr,
+}
+
+#[derive(Debug, Clone)]
+pub struct FieldInit {
+    pub name: Ident,
+    pub value: Expr,
+}
+
+impl FieldInit {
+    fn from_ast(field: &ast::FieldInit) -> Self {
+        Self {
+            name: field.name.clone(),
+            value: expr_from_ast(&field.value),
+        }
+    }
+}
+
+// QUESTION(mbm): should we make the result explicit in the spec syntax?
+static RESULT: &str = "result";
+
+#[derive(Clone)]
+pub struct Spec {
+    pub args: Vec<Ident>,
+    pub ret: Ident,
+    pub provides: Vec<Expr>,
+    pub requires: Vec<Expr>,
+    pub matches: Vec<Expr>,
+    pub modifies: Vec<Modifies>,
+    pub pos: Pos,
+}
+
+impl Spec {
+    fn new() -> Self {
+        Self {
+            args: Vec::new(),
+            ret: Self::result_ident(),
+            provides: Vec::new(),
+            requires: Vec::new(),
+            matches: Vec::new(),
+            modifies: Vec::new(),
+            pos: Pos::default(),
+        }
+    }
+
+    fn from_ast(spec: &ast::Spec) -> Self {
+        Self {
+            args: spec.args.clone(),
+            ret: Self::result_ident(),
+            provides: exprs_from_ast(&spec.provides),
+            requires: exprs_from_ast(&spec.requires),
+            matches: exprs_from_ast(&spec.matches),
+            modifies: spec.modifies.clone(),
+            pos: spec.pos,
+        }
+    }
+
+    fn result_ident() -> Ident {
+        Ident(RESULT.to_string(), Pos::default())
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct State {
+    pub name: Ident,
+    pub ty: Compound,
+    pub default: Expr,
+}
+
+#[derive(Debug, Clone)]
+pub struct Signature {
+    pub args: Vec<Compound>,
+    pub ret: Compound,
+}
+
+impl Signature {
+    fn from_ast(sig: &ast::Signature) -> Self {
+        Self {
+            args: sig.args.iter().map(Compound::from_ast).collect(),
+            ret: Compound::from_ast(&sig.ret),
+        }
+    }
+}
+
+impl std::fmt::Display for Signature {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "({args}) -> {ret}",
+            args = self
+                .args
+                .iter()
+                .map(ToString::to_string)
+                .collect::<Vec<_>>()
+                .join(", "),
+            ret = self.ret
+        )
+    }
+}
+
+pub struct Macro {
+    pub name: Ident,
+    pub params: Vec<Ident>,
+    pub body: Expr,
+}
+
+pub struct SpecEnv {
+    /// Specification for the given term.
+    pub term_spec: HashMap<TermId, Spec>,
+
+    /// State elements.
+    pub state: Vec<State>,
+
+    /// Terms that should be chained.
+    pub chain: HashSet<TermId>,
+
+    /// Tags applied to each term.
+    pub term_tags: HashMap<TermId, HashSet<String>>,
+
+    // Type instantiations for the given term.
+    pub term_instantiations: HashMap<TermId, Vec<Signature>>,
+
+    /// Rules for which priority is significant.
+    pub priority: HashSet<RuleId>,
+
+    /// Tags applied to each rule.
+    pub rule_tags: HashMap<RuleId, HashSet<String>>,
+
+    /// Model for the given type.
+    pub type_model: HashMap<TypeId, Compound>,
+
+    // Track which types are derived (auto-generated)
+    pub derived_types: HashSet<TypeId>,
+
+    /// Value for the given constant.
+    pub const_value: HashMap<Sym, Expr>,
+
+    /// Macro definitions.
+    pub macros: HashMap<String, Macro>,
+}
+
+impl SpecEnv {
+
+
+    pub fn from_ast(defs: &[Def], termenv: &TermEnv, tyenv: &TypeEnv) -> Result<Self> {
+        let mut env = Self {
+            term_spec: HashMap::new(),
+            state: Vec::new(),
+            chain: HashSet::new(),
+            term_tags: HashMap::new(),
+            term_instantiations: HashMap::new(),
+            priority: HashSet::new(),
+            rule_tags: HashMap::new(),
+            type_model: HashMap::new(),
+            derived_types: HashSet::new(),
+            const_value: HashMap::new(),
+            macros: HashMap::new(),
+        };
+
+        env.derive_type_models(tyenv)?;
+        env.collect_models(defs, tyenv);
+        env.derive_enum_variant_specs(termenv, tyenv)?;
+        env.collect_state(defs)?;
+        env.collect_instantiations(defs, termenv, tyenv);
+        env.collect_specs(defs, termenv, tyenv)?;
+        env.collect_attrs(defs, termenv, tyenv)?;
+        env.collect_macros(defs);
+        env.check_option_return_term_specs_uses_matches(termenv, tyenv)?;
+        env.check_for_chained_terms_with_spec();
+
+        Ok(env)
+    }
+
+    // helper function for ExtEnum
+    /// Borrow the base enum for a TypeId if present.
+    fn get_enum_from_typeid(&self, tid: TypeId) -> Option<&crate::types::Enum> {
+        match self.type_model.get(&tid)? {
+            crate::types::Compound::Enum(e) => Some(e),
+            crate::types::Compound::ExtEnum { base, .. } => Some(base),
+            _ => None,
+        }
+    }
+
+    /// Clone out an owned Enum for a TypeId (useful when constructing ExtEnum).
+    fn clone_enum_from_typeid(&self, tid: TypeId) -> Option<crate::types::Enum> {
+        self.get_enum_from_typeid(tid).cloned()
+    }
+
+    fn collect_models(&mut self, defs: &[Def], tyenv: &TypeEnv) {
+        for def in defs {
+            if let ast::Def::Model(Model { name, val }) = def {
+                match val {
+                    ast::ModelValue::TypeValue(model_type) => {
+                        // only insert if this name hasn't been seen yet 
+                        let tid = tyenv.get_type_by_name(name).expect("type should exist");
+                        
+                        // new model compound 
+                        let new_model = Compound::from_ast(model_type);
+
+                        if let Some(_existing) = self.type_model.get(&tid) {
+                            // --- CASE 1: ext-enum ---
+                            if let Compound::ExtEnum { .. } = new_model {
+                                if self.derived_types.contains(&tid) {
+                                    // good: upgrade derived enum → ext-enum
+                                    self.type_model.insert(tid, new_model);
+                                    self.derived_types.remove(&tid);
+                                    continue;
+                                } else {
+                                    panic!("cannot ext-enum a non-enum type: {}", name.0);
+                                }
+                            }
+
+                            // --- CASE 2: replacing a derived enum ---
+                            if self.derived_types.contains(&tid) {
+                                self.type_model.insert(tid, new_model);
+                                self.derived_types.remove(&tid);
+                                continue;
+                            }
+
+                            // --- CASE 3: any other duplicate ---
+                            panic!("duplicate type model: {}", name.0);
+                        } else {
+                            // first definition
+                            self.type_model.insert(tid, new_model);
+                        }
+
+
+                    }
+                    ast::ModelValue::ConstValue(val) => {
+                        // TODO(mbm): error on missing constant name rather than panic
+                        let sym = tyenv.intern(name).expect("constant name should be defined");
+                        // TODO(mbm): enforce that the expression is constant.
+                        // TODO(mbm): ensure the type of the expression matches the type of the
+                        self.const_value.insert(sym, expr_from_ast(val));
+                    }
+                    ast::ModelValue::ExtEnumValue(fields) => {
+                        // 1) Resolve the base type to a TypeId.
+                        let base_tid = tyenv
+                            .get_type_by_name(name)
+                            .expect("ext-enum base type should exist");
+
+                        // 2) Clone the existing base enum compound.
+                        let base_enum = self
+                            .clone_enum_from_typeid(base_tid)
+                            .expect("expected base enum to be defined for type-ext-enum");
+
+                        // 3) Lower the extra fields to veri types::Field.
+                        let extra: Vec<Field> = fields
+                            .iter()
+                            .map(|mf| Field {
+                                name: mf.name.clone(),
+                                ty: Compound::from_ast(&mf.ty),
+                            })
+                            .collect();
+
+                        // 4) Build Compound::ExtEnum and overwrite the entry for this TypeId.
+                        let compound = Compound::ExtEnum { base: base_enum, extra };
+                        self.type_model.insert(base_tid, compound);
+                    }
+                }
+            }
+        }
+    }
+
+    fn derive_type_models(&mut self, tyenv: &TypeEnv) -> Result<()> {
+        for ty in &tyenv.types {
+            // Has an explicit model already been specified?
+            if self.has_model(ty.id()) {
+                continue;
+            }
+
+            // Derive a model from ISLE type, if possible.
+            if let Some(derived_type) = Compound::from_isle(ty, tyenv) {
+                // register derived type and mark derived
+                self.type_model.insert(ty.id(), derived_type);
+                self.derived_types.insert(ty.id());
+            };
+        }
+        Ok(())
+    }
+
+    fn derive_enum_variant_specs(&mut self, termenv: &TermEnv, tyenv: &TypeEnv) -> Result<()> {
+        for model in self.type_model.values() {
+
+            // handle both Enum and ExtEnum 
+            let enum_ref: Option<&Enum> = match model {
+                Compound::Enum(e) => Some(e),
+                Compound::ExtEnum { base, .. } => Some(base),
+                _ => None,
+            };
+
+            if let Some(e) = enum_ref {
+                for variant in &e.variants {
+                    // Lookup the corresponding term.
+                    let full_name = ast::Variant::full_name(&e.name, &variant.name);
+                    let term_id =
+                        termenv
+                            .get_term_by_name(tyenv, &full_name)
+                            .ok_or(format_err!(
+                                "could not find variant term {name}",
+                                name = full_name.0
+                            ))?;
+                    
+                    // if user wrote a spec already, do not autogenerate 
+                    if self.term_spec.contains_key(&term_id) {
+                                        continue;
+                                    } 
+
+                    // build a fresh synthesize spec for the variant.
+                    let pos = variant.name.1;
+                    let args: Vec<Ident> = variant.fields.iter().map(|f| f.name.clone()).collect();
+                    let constructor = Positioned::new(
+                        pos,
+                        ExprKind::Constructor(Constructor::Enum {
+                            name: e.name.clone(),
+                            variant: variant.name.clone(),
+                            args: args.iter().cloned().map(var_from_ident).collect(),
+                        }),
+                    );
+
+                    let mut spec = Spec::new();
+                    spec.args = args.clone();
+                    let ret = var_from_ident(spec.ret.clone());
+                    spec.provides
+                        .push(Positioned::new(pos, ExprKind::Eq(ret, constructor)));
+                    self.term_tags
+                        .entry(term_id)
+                        .or_default()
+                        .insert("internal_derived_spec".to_string());
+                }
+            }
+        }
+        Ok(())
+    }
+
+    // fn set_model_type(&mut self, name: &Ident, model_type: &ModelType, tyenv: &TypeEnv) {
+    //     // TODO(mbm): error on missing type rather than panic
+    //     let type_id = tyenv
+    //         .get_type_by_name(name)
+    //         .expect("type name should be defined");
+    //     // TODO(mbm): error on duplicate model
+    //     let compound = Compound::from_ast(model_type);
+
+    //     if let Some(existing) = self.type_model.get(&type_id) {
+    //         match (existing, &compound) {
+    //             (Compound::Enum(_), Compound::ExtEnum { .. }) => {
+    //                 // replace Enum with ExtEnum
+    //                 self.type_model.insert(type_id, compound);
+    //                 return;
+    //             }
+    //             // if already enum and the new one is also enum -> error 
+    //             (Compound::Enum(_), Compound::Enum(_)) =>{
+    //                 panic!("duplicate enum model: {}", name.0);
+    //             }
+    //             (Compound::ExtEnum{..}, Compound::ExtEnum{..}) =>{
+    //                 panic!("duplicate extenum model: {}", name.0);
+    //             }
+    //             // otherwise: real conflict 
+    //             _ => {
+    //                 panic!("duplicate type model: {}", name.0);
+    //             }
+    //         }
+    //     } else {
+    //         self.type_model.insert(type_id, compound);
+    //     }
+    // }
+
+    fn collect_state(&mut self, defs: &[Def]) -> Result<()> {
+        // Collect states.
+        for def in defs {
+            if let ast::Def::State(ast::State {
+                name,
+                ty,
+                default,
+                pos: _,
+            }) = def
+            {
+                let ty = Compound::from_ast(ty);
+                let default = expr_from_ast(default);
+                self.state.push(State {
+                    name: name.clone(),
+                    ty,
+                    default,
+                });
+            }
+        }
+
+        // Check for duplicates.
+        let mut names = HashSet::new();
+        for state in &self.state {
+            let name = &state.name.0;
+            if names.contains(name) {
+                bail!("duplicate state {name}");
+            }
+            names.insert(name);
+        }
+
+        Ok(())
+    }
+
+    fn collect_instantiations(&mut self, defs: &[Def], termenv: &TermEnv, tyenv: &TypeEnv) {
+        // Collect form signatures first, as they may be referenced by instantiations.
+        let mut form_signature = HashMap::new();
+        for def in defs {
+            if let ast::Def::Form(form) = def {
+                let signatures: Vec<_> = form.signatures.iter().map(Signature::from_ast).collect();
+                form_signature.insert(form.name.0.clone(), signatures);
+            }
+        }
+
+        // Collect instantiations.
+        for def in defs {
+            if let ast::Def::Instantiation(inst) = def {
+                let term_id = termenv.get_term_by_name(tyenv, &inst.term).unwrap();
+                let sigs = match &inst.form {
+                    Some(form) => form_signature[&form.0].clone(),
+                    None => inst.signatures.iter().map(Signature::from_ast).collect(),
+                };
+                self.term_instantiations.insert(term_id, sigs);
+            }
+        }
+    }
+
+    fn collect_specs(&mut self, defs: &[Def], termenv: &TermEnv, tyenv: &TypeEnv) -> Result<()> {
+        for def in defs {
+            if let ast::Def::Spec(spec) = def {
+                let term_id = termenv
+                    .get_term_by_name(tyenv, &spec.term)
+                    .ok_or(format_err!(
+                        "spec for unknown term {name}",
+                        name = spec.term.0
+                    ))?;
+                match self.term_spec.entry(term_id) {
+                    Entry::Occupied(_) => {
+                        bail!("duplicate spec for term {name}", name = spec.term.0)
+                    }
+                    Entry::Vacant(e) => {
+                        e.insert(Spec::from_ast(spec));
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn collect_attrs(&mut self, defs: &[Def], termenv: &TermEnv, tyenv: &TypeEnv) -> Result<()> {
+        for def in defs {
+            if let ast::Def::Attr(attr) = def {
+                match &attr.target {
+                    AttrTarget::Term(name) => {
+                        let term_id = termenv.get_term_by_name(tyenv, name).ok_or(format_err!(
+                            "attr term '{name}' should exist",
+                            name = name.0
+                        ))?;
+                        for kind in &attr.kinds {
+                            match kind {
+                                AttrKind::Chain => {
+                                    self.chain.insert(term_id);
+                                }
+                                AttrKind::Tag(tag) => {
+                                    self.term_tags
+                                        .entry(term_id)
+                                        .or_default()
+                                        .insert(tag.0.clone());
+                                }
+                                AttrKind::Priority => {
+                                    bail!("priority attribute cannot be applied to terms");
+                                }
+                            }
+                        }
+                    }
+                    AttrTarget::Rule(name) => {
+                        let rule_id = termenv
+                            .get_rule_by_name(tyenv, name)
+                            .ok_or(format_err!("attr rule '{}' does not exist", name.0))?;
+                        for kind in &attr.kinds {
+                            match kind {
+                                AttrKind::Priority => {
+                                    self.priority.insert(rule_id);
+                                }
+                                AttrKind::Tag(tag) => {
+                                    self.rule_tags
+                                        .entry(rule_id)
+                                        .or_default()
+                                        .insert(tag.0.clone());
+                                }
+                                AttrKind::Chain => {
+                                    bail!("chain attribute cannot be applied to rule");
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn collect_macros(&mut self, defs: &[Def]) {
+        for def in defs {
+            if let ast::Def::SpecMacro(spec_macro) = def {
+                let body = expr_from_ast(&spec_macro.body);
+                self.macros.insert(
+                    spec_macro.name.0.clone(),
+                    Macro {
+                        name: spec_macro.name.clone(),
+                        params: spec_macro.params.clone(),
+                        body,
+                    },
+                );
+            }
+        }
+    }
+
+    fn check_option_return_term_specs_uses_matches(
+        &self,
+        termenv: &TermEnv,
+        tyenv: &TypeEnv,
+    ) -> Result<()> {
+        for (term_id, spec) in &self.term_spec {
+            let term = &termenv.terms[term_id.index()];
+            if !Self::term_returns_option(term, tyenv) {
+                continue;
+            }
+            if !spec.requires.is_empty() {
+                bail!(
+                    "term '{name}' requires should be match",
+                    name = tyenv.syms[term.name.index()],
+                );
+            }
+        }
+        Ok(())
+    }
+
+    fn term_returns_option(term: &Term, tyenv: &TypeEnv) -> bool {
+        // Constructor
+        if term.has_constructor() {
+            return term.is_partial();
+        }
+
+        // External extractor
+        if let Some(sig) = term.extractor_sig(&tyenv) {
+            return sig.ret_kind == ReturnKind::Option;
+        }
+
+        // Extractor
+        if term.has_extractor() {
+            return true;
+        }
+
+        false
+    }
+
+    fn check_for_chained_terms_with_spec(&self) {
+        for term_id in &self.chain {
+            // TODO(mbm): error rather than panic
+            assert!(
+                !self.term_spec.contains_key(term_id),
+                "chained term should not have spec"
+            );
+        }
+    }
+
+    /// Resolve any named types in the given compound type.
+    pub fn resolve_type(&self, ty: &Compound, tyenv: &TypeEnv) -> Result<Compound> {
+        ty.resolve(&mut |name| {
+            let type_id = tyenv
+                .get_type_by_name(name)
+                .ok_or(format_err!("unknown type {}", name.0))?;
+            let ty = self
+                .type_model
+                .get(&type_id)
+                .ok_or(format_err!("unspecified model for type {}", name.0))?;
+            Ok(ty.clone())
+        })
+    }
+
+    /// Resolve any named types in the given term signature.
+    pub fn resolve_signature(&self, sig: &Signature, tyenv: &TypeEnv) -> Result<Signature> {
+        Ok(Signature {
+            args: sig
+                .args
+                .iter()
+                .map(|arg| self.resolve_type(arg, tyenv))
+                .collect::<Result<_>>()?,
+            ret: self.resolve_type(&sig.ret, tyenv)?,
+        })
+    }
+
+    /// Lookup instantiations for the given term, with any named types resolved.
+    pub fn resolve_term_instantiations(
+        &self,
+        term_id: &TermId,
+        tyenv: &TypeEnv,
+    ) -> Result<Vec<Signature>> {
+        let Some(sigs) = self.term_instantiations.get(term_id) else {
+            return Ok(Vec::new());
+        };
+
+        sigs.iter()
+            .map(|sig| self.resolve_signature(sig, tyenv))
+            .collect::<Result<_>>()
+    }
+
+    /// Report whether the given term has a specification.
+    pub fn has_spec(&self, term_id: TermId) -> bool {
+        self.term_spec.contains_key(&term_id)
+    }
+
+    pub fn has_model(&self, type_id: TypeId) -> bool {
+        self.type_model.contains_key(&type_id)
+    }
+}
diff --git a/cranelift/isle/veri/veri/src/testing.rs b/cranelift/isle/veri/veri/src/testing.rs
new file mode 100644
index 000000000000..308a5da1ff0b
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/testing.rs
@@ -0,0 +1,43 @@
+use std::{cmp::Ordering, fmt::Debug};
+
+pub fn assert_strictly_increasing<T>(elements: &[T])
+where
+    T: PartialOrd + Debug,
+{
+    elements.windows(2).for_each(|p| assert!(p[0] < p[1]));
+}
+
+pub fn assert_partial_order_properties<T>(elements: &[T])
+where
+    T: PartialOrd + Debug,
+{
+    // Equality
+    for a in elements {
+        for b in elements {
+            assert_eq!(
+                a == b,
+                a.partial_cmp(b) == Some(Ordering::Equal),
+                "equality property failed: a={a:?} b={b:?}"
+            );
+        }
+    }
+
+    // Transitivity
+    for a in elements {
+        for b in elements {
+            for c in elements {
+                assert!(
+                    !(a < b && b < c && !(a < c)),
+                    "transitivity property failed: a={a:?} b={b:?} c={c:?}"
+                );
+            }
+        }
+    }
+
+    // Duality
+    for a in elements {
+        for b in elements {
+            assert_eq!(a < b, b > a, "duality property failed: a={a:?} b={b:?}");
+        }
+    }
+}
diff --git a/cranelift/isle/veri/veri/src/trie.rs b/cranelift/isle/veri/veri/src/trie.rs
new file mode 100644
index 000000000000..f0127418993e
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/trie.rs
@@ -0,0 +1,153 @@
+use std::sync::Arc;
+
+use crate::program::Program;
+use cranelift_isle::{
+    error::{Errors, ErrorsBuilder},
+    files::Files,
+    sema::{ExternalSig, ReturnKind, TermEnv, TermId, Type, TypeEnv, TypeId},
+    trie_again::{self, Binding, BindingId, RuleSet},
+};
+
+pub fn build_trie(termenv: &TermEnv, files: Arc<Files>) -> Result<Vec<(TermId, RuleSet)>, Errors> {
+    let (terms, errors) = trie_again::build(termenv);
+    if errors.is_empty() {
+        Ok(terms)
+    } else {
+        Err(ErrorsBuilder::new()
+            .errors(errors)
+            .files(files.clone())
+            .build())
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum BindingType {
+    Base(TypeId),
+    Option(Box<BindingType>),
+    Tuple(Vec<BindingType>),
+}
+
+impl BindingType {
+    pub fn display(&self, tyenv: &TypeEnv) -> String {
+        match self {
+            BindingType::Base(type_id) => {
+                let ty = &tyenv.types[type_id.index()];
+                ty.name(tyenv).to_string()
+            }
+            BindingType::Option(inner) => format!("Option({})", inner.display(tyenv)),
+            BindingType::Tuple(inners) => format!(
+                "({inners})",
+                inners = inners
+                    .iter()
+                    .map(|inner| inner.display(tyenv))
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            ),
+        }
+    }
+}
+
+/// Determine the type of a given binding.
+pub fn binding_type(
+    binding: &Binding,
+    term_id: TermId,
+    prog: &Program,
+    // TODO(mbm): is there a less ugly way to do binding lookup here?
+    lookup_binding: impl Fn(BindingId) -> Binding,
+) -> BindingType {
+    match binding {
+        Binding::ConstInt { ty, .. } | Binding::MakeVariant { ty, .. } => BindingType::Base(*ty),
+
+        Binding::ConstPrim { val } => BindingType::Base(prog.tyenv.const_types[val]),
+
+        Binding::Argument { index } => {
+            let term = &prog.termenv.terms[term_id.index()];
+            BindingType::Base(term.arg_tys[index.index()])
+        }
+
+        Binding::Extractor { term, .. } => {
+            // Determine the extractor signature.
+            let term = &prog.termenv.terms[term.index()];
+            let sig = term
+                .extractor_sig(&prog.tyenv)
+                .expect("term should have extractor signature");
+            external_sig_return_type(&sig)
+        }
+
+        Binding::Constructor { term, .. } => {
+            // Determine the constructor signature.
+            let term = &prog.termenv.terms[term.index()];
+            let sig = term
+                .constructor_sig(&prog.tyenv)
+                .expect("term should have constructor signature");
+            external_sig_return_type(&sig)
+        }
+
+        Binding::MakeSome { inner } => {
+            let inner_binding = lookup_binding(*inner);
+            let inner_ty = binding_type(&inner_binding, term_id, prog, lookup_binding);
+            BindingType::Option(Box::new(inner_ty))
+        }
+
+        Binding::MatchSome { source } => {
+            let source_binding = lookup_binding(*source);
+            let source_ty = binding_type(&source_binding, term_id, prog, lookup_binding);
+            match source_ty {
+                BindingType::Option(ty) => *ty,
+                _ => unreachable!("source of match some should be an option"),
+            }
+        }
+
+        Binding::MatchVariant {
+            source,
+            variant,
+            field,
+        } => {
+            // Lookup type ID for the underlying enum.
+            let source_binding = lookup_binding(*source);
+            let source_ty = binding_type(&source_binding, term_id, prog, lookup_binding);
+            let source_type_id = match source_ty {
+                BindingType::Base(type_id) => type_id,
+                _ => unreachable!("source of match variant should be a base type"),
+            };
+
+            // Lookup variant.
+            let enum_ty = &prog.tyenv.types[source_type_id.index()];
+            let variant = match enum_ty {
+                Type::Enum { variants, .. } => &variants[variant.index()],
+                _ => unreachable!("source match variant should be an enum"),
+            };
+
+            // Lookup field type.
+            let field = &variant.fields[field.index()];
+            BindingType::Base(field.ty)
+        }
+
+        Binding::MatchTuple { source, field } => {
+            let source_binding = lookup_binding(*source);
+            let source_ty = binding_type(&source_binding, term_id, prog, lookup_binding);
+            match source_ty {
+                BindingType::Tuple(tys) => tys[field.index()].clone(),
+                _ => unreachable!("source type should be a tuple"),
+            }
+        }
+
+        Binding::Iterator { .. } => unimplemented!("iterator bindings not supported"),
+    }
+}
+
+fn external_sig_return_type(sig: &ExternalSig) -> BindingType {
+    // Multiple return types are represented as a tuple.
+    let ty = if sig.ret_tys.len() == 1 {
+        BindingType::Base(sig.ret_tys[0])
+    } else {
+        BindingType::Tuple(sig.ret_tys.iter().copied().map(BindingType::Base).collect())
+    };
+
+    // Fallible terms return option type.
+    match sig.ret_kind {
+        ReturnKind::Option => BindingType::Option(Box::new(ty)),
+        ReturnKind::Plain => ty,
+        ReturnKind::Iterator => unimplemented!("extractor iterator return"),
+    }
+}
diff --git a/cranelift/isle/veri/veri/src/type_inference.rs b/cranelift/isle/veri/veri/src/type_inference.rs
new file mode 100644
index 000000000000..062ea33afd62
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/type_inference.rs
@@ -0,0 +1,1231 @@
+use std::{
+    cmp::Ordering,
+    collections::{hash_map::Entry, HashMap},
+    iter::zip,
+    vec,
+};
+
+use anyhow::{bail, format_err, Result};
+use cranelift_isle::{files::Files, sema::TermId};
+
+use crate::{
+    spec::Signature,
+    types::{Compound, Const, Type, Width},
+    veri::{Call, Conditions, Expr, ExprId, Qualifier, Symbolic},
+};
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum TypeValue {
+    Type(Type),
+    Value(Const),
+}
+
+impl TypeValue {
+    pub fn ty(&self) -> Type {
+        match self {
+            TypeValue::Type(ty) => ty.clone(),
+            TypeValue::Value(c) => c.ty(),
+        }
+    }
+
+    fn as_value(&self) -> Option<&Const> {
+        match self {
+            TypeValue::Value(c) => Some(c),
+            _ => None,
+        }
+    }
+
+    pub fn refines_type(&self, ty: &Type) -> bool {
+        self >= &Self::Type(ty.clone())
+    }
+
+    pub fn merge(left: &Self, right: &Self) -> Option<Self> {
+        match left.partial_cmp(right) {
+            Some(Ordering::Greater) => Some(left.clone()),
+            Some(Ordering::Less | Ordering::Equal) => Some(right.clone()),
+            None => None,
+        }
+    }
+}
+
+impl PartialOrd for TypeValue {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        match (self, other) {
+            (TypeValue::Type(l), TypeValue::Type(r)) => l.partial_cmp(r),
+            (TypeValue::Type(ty), TypeValue::Value(v)) if ty <= &v.ty() => Some(Ordering::Less),
+            (TypeValue::Value(v), TypeValue::Type(ty)) if &v.ty() >= ty => Some(Ordering::Greater),
+            (TypeValue::Value(l), TypeValue::Value(r)) if l == r => Some(Ordering::Equal),
+            _ => None,
+        }
+    }
+}
+
+impl std::fmt::Display for TypeValue {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            TypeValue::Type(ty) => ty.fmt(f),
+            TypeValue::Value(c) => c.fmt(f),
+        }
+    }
+}
+
+/// Boolean expression or its negation.
+#[derive(Debug, Clone)]
+pub enum Literal {
+    Var(ExprId),
+    Not(ExprId),
+}
+
+impl std::fmt::Display for Literal {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Literal::Var(x) => write!(f, "{}", x.index()),
+            Literal::Not(x) => write!(f, "\u{00AC}{}", x.index()),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum Constraint {
+    /// Expression x has the given type.
+    Type { x: ExprId, ty: Type },
+    /// Expressions have the same type.
+    SameType { x: ExprId, y: ExprId },
+    /// Expressions have the same type and value.
+    Identical { x: ExprId, y: ExprId },
+    /// Expression x is a bitvector with width given by the integer expression w.
+    WidthOf { x: ExprId, w: ExprId },
+    /// Bitvector x is the concatenation bitvectors l and r.
+    Concat { x: ExprId, l: ExprId, r: ExprId },
+    /// Expression x has known constant value v.
+    Value { x: ExprId, c: Const },
+    /// Constraint conditioned on a boolean.
+    Implies { c: ExprId, then: Box<Constraint> },
+    /// Clause is a disjunction that must hold.
+    Clause { literals: Vec<Literal> },
+}
+
+impl std::fmt::Display for Constraint {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            Constraint::Type { x, ty } => write!(f, "type({}) = {ty}", x.index()),
+            Constraint::SameType { x, y } => {
+                write!(f, "type({}) == type({})", x.index(), y.index())
+            }
+            Constraint::Identical { x, y } => write!(f, "{} == {}", x.index(), y.index()),
+            Constraint::WidthOf { x, w } => write!(f, "{} = width_of({})", w.index(), x.index()),
+            Constraint::Concat { x, l, r } => {
+                write!(f, "{} = {}:{}", x.index(), l.index(), r.index())
+            }
+            Constraint::Value { x, c } => write!(f, "{} = value({c})", x.index()),
+            Constraint::Implies { c, then } => write!(f, "{} => {then}", c.index()),
+            Constraint::Clause { literals } => write!(
+                f,
+                "clause({})",
+                literals
+                    .iter()
+                    .map(ToString::to_string)
+                    .collect::<Vec<_>>()
+                    .join(" \u{2228} ")
+            ),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub enum Choice {
+    TermInstantiation(TermId, Signature),
+}
+
+impl std::fmt::Display for Choice {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Choice::TermInstantiation(term_id, sig) => {
+                write!(f, "term_instantiation({}, {sig})", term_id.index())
+            }
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct Arm {
+    choice: Choice,
+    constraints: Vec<Constraint>,
+}
+
+#[derive(Default, Clone)]
+pub struct Branch {
+    arms: Vec<Arm>,
+}
+
+#[derive(Default)]
+pub struct System {
+    choices: Vec<Choice>,
+    constraints: Vec<Constraint>,
+    branches: Vec<Branch>,
+}
+
+impl System {
+    fn fork(&self) -> Vec<System> {
+        let mut branches = self.branches.clone();
+        let branch = branches.pop().expect("should have at least one branch");
+
+        let mut children = Vec::new();
+        for arm in &branch.arms {
+            let mut constraints = self.constraints.clone();
+            constraints.extend(arm.constraints.iter().cloned());
+
+            let mut choices = self.choices.clone();
+            // Only record the choice if there are multiple branches.
+            if branch.arms.len() > 1 {
+                choices.push(arm.choice.clone());
+            }
+
+            children.push(System {
+                constraints,
+                choices,
+                branches: branches.clone(),
+            })
+        }
+
+        children
+    }
+
+    pub fn pretty_print(&self) {
+        println!("system {{");
+
+        // Choices
+        println!("\tchoices = [");
+        for choice in &self.choices {
+            println!("\t\t{choice}");
+        }
+        println!("\t]");
+
+        // Constraints
+        println!("\tconstraints = [");
+        for constraint in &self.constraints {
+            println!("\t\t{constraint}");
+        }
+        println!("\t]");
+
+        // Branches
+        for branch in &self.branches {
+            println!("\tbranch {{");
+            for arm in &branch.arms {
+                println!("\t\t{choice} => [", choice = arm.choice);
+                for constraint in &arm.constraints {
+                    println!("\t\t\t{constraint}");
+                }
+                println!("\t\t]");
+            }
+            println!("\t}}");
+        }
+
+        println!("}}");
+    }
+}
+
+pub fn type_constraint_system(conditions: &Conditions) -> System {
+    let builder = SystemBuilder::new(conditions);
+    builder.build()
+}
+
+struct SystemBuilder<'a> {
+    conditions: &'a Conditions,
+
+    system: System,
+    arm: Option<Arm>,
+}
+
+impl<'a> SystemBuilder<'a> {
+    fn new(conditions: &'a Conditions) -> Self {
+        Self {
+            conditions,
+            system: System::default(),
+            arm: None,
+        }
+    }
+
+    fn build(mut self) -> System {
+        // Expression constraints.
+        for (i, expr) in self.conditions.exprs.iter().enumerate() {
+            self.veri_expr(ExprId(i), expr);
+        }
+
+        // Assumptions.
+        for a in &self.conditions.assumptions {
+            self.boolean_value(*a, true);
+        }
+
+        // Assertions.
+        for a in &self.conditions.assertions {
+            self.boolean(*a);
+        }
+
+        // Calls.
+        for call in &self.conditions.calls {
+            self.call(call);
+        }
+
+        // Qualifiers.
+        for qualifier in &self.conditions.qualifiers {
+            self.qualifier(qualifier);
+        }
+
+        self.system
+    }
+
+    fn veri_expr(&mut self, x: ExprId, expr: &Expr) {
+        match expr {
+            Expr::Const(c) => {
+                self.value(x, c.clone());
+            }
+            Expr::Variable(v) => {
+                let ty = self.conditions.variables[v.index()].ty.clone();
+                self.ty(x, ty);
+            }
+            Expr::Not(y) => {
+                self.boolean(x);
+                self.boolean(*y);
+
+                // ((NOT X) OR (NOT Y))
+                self.clause(vec![Literal::Not(x), Literal::Not(*y)]);
+                // (X OR Y)
+                self.clause(vec![Literal::Var(x), Literal::Var(*y)]);
+            }
+            Expr::And(y, z) => {
+                // TODO(mbm): clause implies boolean
+                self.boolean(x);
+                self.boolean(*y);
+                self.boolean(*z);
+
+                // ((NOT X) OR Y)
+                self.clause(vec![Literal::Not(x), Literal::Var(*y)]);
+                // ((NOT X) OR Z)
+                self.clause(vec![Literal::Not(x), Literal::Var(*z)]);
+                // (X OR (NOT Y) OR (NOT Z))
+                self.clause(vec![Literal::Var(x), Literal::Not(*y), Literal::Not(*z)]);
+            }
+            Expr::Or(y, z) => {
+                self.boolean(x);
+                self.boolean(*y);
+                self.boolean(*z);
+
+                // ((NOT X) OR Y OR Z)
+                self.clause(vec![Literal::Not(x), Literal::Var(*y), Literal::Var(*z)]);
+                // (X OR (NOT Y))
+                self.clause(vec![Literal::Var(x), Literal::Not(*y)]);
+                // (X OR (NOT Z))
+                self.clause(vec![Literal::Var(x), Literal::Not(*z)]);
+            }
+            Expr::Imp(y, z) => {
+                self.boolean(x);
+                self.boolean(*y);
+                self.boolean(*z);
+
+                // ((NOT X) OR (NOT Y) OR Z)
+                self.clause(vec![Literal::Not(x), Literal::Not(*y), Literal::Var(*z)]);
+                // (X OR Y)
+                self.clause(vec![Literal::Var(x), Literal::Var(*y)]);
+                // (X OR (NOT Z))
+                self.clause(vec![Literal::Var(x), Literal::Not(*y)]);
+            }
+            Expr::Eq(y, z) => {
+                self.boolean(x);
+                self.same_type(*y, *z);
+                self.constraint(Constraint::Implies {
+                    c: x,
+                    then: Box::new(Constraint::Identical { x: *y, y: *z }),
+                });
+            }
+            Expr::Lt(y, z) | Expr::Lte(y, z) => {
+                self.boolean(x);
+                self.integer(*y);
+                self.integer(*z);
+            }
+            Expr::BVUgt(y, z)
+            | Expr::BVUge(y, z)
+            | Expr::BVUlt(y, z)
+            | Expr::BVUle(y, z)
+            | Expr::BVSgt(y, z)
+            | Expr::BVSge(y, z)
+            | Expr::BVSlt(y, z)
+            | Expr::BVSle(y, z)
+            | Expr::FPEq(y, z)
+            | Expr::FPNe(y, z)
+            | Expr::FPLt(y, z)
+            | Expr::FPGt(y, z)
+            | Expr::FPLe(y, z)
+            | Expr::FPGe(y, z)
+            | Expr::BVSaddo(y, z) => {
+                self.boolean(x);
+                self.bit_vector(*y);
+                self.bit_vector(*z);
+
+                self.same_type(*y, *z);
+            }
+            Expr::BVNot(y) | Expr::BVNeg(y) => {
+                self.bit_vector(x);
+                self.bit_vector(*y);
+
+                self.same_type(x, *y);
+            }
+            Expr::Cls(y) | Expr::Clz(y) | Expr::Rev(y) | Expr::Popcnt(y) => {
+                self.bit_vector(x);
+                self.bit_vector(*y);
+
+                self.same_type(x, *y);
+            }
+            Expr::Add(y, z) | Expr::Sub(y, z) | Expr::Mul(y, z) => {
+                self.integer(x);
+                self.integer(*y);
+                self.integer(*z);
+            }
+            Expr::BVAdd(y, z)
+            | Expr::BVSub(y, z)
+            | Expr::BVMul(y, z)
+            | Expr::BVSDiv(y, z)
+            | Expr::BVUDiv(y, z)
+            | Expr::BVSRem(y, z)
+            | Expr::BVURem(y, z)
+            | Expr::BVAnd(y, z)
+            | Expr::BVOr(y, z)
+            | Expr::BVXor(y, z)
+            | Expr::BVShl(y, z)
+            | Expr::BVLShr(y, z)
+            | Expr::BVAShr(y, z)
+            | Expr::BVRotl(y, z)
+            | Expr::BVRotr(y, z)
+            | Expr::FPAdd(y, z)
+            | Expr::FPSub(y, z)
+            | Expr::FPMul(y, z)
+            | Expr::FPDiv(y, z)
+            | Expr::FPMin(y, z)
+            | Expr::FPMax(y, z) => {
+                self.bit_vector(x);
+                self.bit_vector(*y);
+                self.bit_vector(*z);
+
+                self.same_type(x, *y);
+                self.same_type(x, *z);
+            }
+            Expr::FPNeg(y)
+            | Expr::FPSqrt(y)
+            | Expr::FPCeil(y)
+            | Expr::FPFloor(y)
+            | Expr::FPNearest(y)
+            | Expr::FPTrunc(y) => {
+                self.bit_vector(x);
+                self.bit_vector(*y);
+
+                self.same_type(x, *y);
+            }
+            // QUESTION(mbm): should we assert in type inference that FP ops are 32 or 64-bit?
+            Expr::FPIsZero(y)
+            | Expr::FPIsInfinite(y)
+            | Expr::FPIsNaN(y)
+            | Expr::FPIsNegative(y)
+            | Expr::FPIsPositive(y) => {
+                self.boolean(x);
+                self.bit_vector(*y);
+            }
+            Expr::Conditional(c, t, e) => {
+                self.boolean(*c);
+                self.same_type(x, *t);
+                self.same_type(x, *e);
+            }
+            Expr::BVZeroExt(w, y) | Expr::BVSignExt(w, y) | Expr::BVConvTo(w, y) => {
+                self.bit_vector(x);
+                self.integer(*w);
+                self.bit_vector(*y);
+                self.width_of(x, *w);
+            }
+            Expr::BVExtract(h, l, y) => {
+                let width = 1 + h
+                    .checked_sub(*l)
+                    .expect("high bit should not be less than low bit");
+                self.bit_vector_of_width(x, width);
+                self.bit_vector(*y);
+            }
+            Expr::BVConcat(y, z) => {
+                self.bit_vector(x);
+                self.bit_vector(*y);
+                self.bit_vector(*z);
+                self.concat(x, *y, *z);
+            }
+            Expr::Int2BV(w, y) => {
+                self.bit_vector(x);
+                self.integer(*w);
+                self.integer(*y);
+                self.width_of(x, *w);
+            }
+            Expr::BV2Nat(y) => {
+                self.integer(x);
+                self.bit_vector(*y);
+            }
+            Expr::ToFP(w, y) | Expr::ToFPUnsigned(w, y) => {
+                self.integer(*w);
+                self.bit_vector(*y);
+                self.bit_vector(x);
+                self.width_of(x, *w);
+                self.width_of(*y, *w);
+            }
+            Expr::FPToUBV(w, y) | Expr::FPToSBV(w, y) => {
+                self.integer(*w);
+                self.bit_vector(*y);
+                self.bit_vector(x);
+                self.width_of(x, *w);
+            }
+            Expr::ToFPFromFP(w, y) => {
+                self.integer(*w);
+                self.bit_vector(*y);
+                self.bit_vector(x);
+                self.width_of(x, *w);
+            }
+            Expr::WidthOf(y) => {
+                self.integer(x);
+                self.bit_vector(*y);
+                self.width_of(*y, x);
+            }
+            Expr::FPPositiveInfinity(w)
+            | Expr::FPNegativeInfinity(w)
+            | Expr::FPPositiveZero(w)
+            | Expr::FPNegativeZero(w)
+            | Expr::FPNaN(w) => {
+                self.bit_vector(x);
+                self.integer(*w);
+                self.width_of(x, *w);
+            }
+        }
+    }
+
+    fn call(&mut self, call: &Call) {
+        if call.signatures.is_empty() {
+            return;
+        }
+
+        // Branch for the choice of term signature.
+        //
+        // We do this even for the case of a single signature, since it will
+        // preserve metadata about where the type assignment came from.
+        self.branch();
+
+        for sig in &call.signatures {
+            // Branch arm for
+            self.push_arm(Choice::TermInstantiation(call.term, sig.clone()));
+
+            // Arguments.
+            assert_eq!(call.args.len(), sig.args.len());
+            for (a, ty) in zip(&call.args, &sig.args) {
+                self.symbolic(a, ty.clone());
+            }
+
+            // Return.
+            self.symbolic(&call.ret, sig.ret.clone());
+
+            // Pop branch arm.
+            self.pop();
+        }
+    }
+
+    fn qualifier(&mut self, qualifier: &Qualifier) {
+        self.symbolic(&qualifier.value, qualifier.ty.clone());
+    }
+
+    fn symbolic(&mut self, v: &Symbolic, ty: Compound) {
+        match (v, ty) {
+            (Symbolic::Scalar(x), Compound::Primitive(ty)) => self.ty(*x, ty),
+            (Symbolic::Struct(fields), Compound::Struct(field_tys)) => {
+                assert_eq!(fields.len(), field_tys.len());
+                for (field, field_ty) in zip(fields, field_tys) {
+                    assert_eq!(field.name, field_ty.name.0);
+                    self.symbolic(&field.value, field_ty.ty);
+                }
+            }
+            (Symbolic::Enum(e), Compound::Enum(enum_ty)) => {
+                assert_eq!(e.ty, enum_ty.id);
+                // Discriminant is an integer.
+                self.integer(e.discriminant);
+                // Variant types.
+                assert_eq!(e.variants.len(), enum_ty.variants.len());
+                for (variant, variant_ty) in zip(&e.variants, &enum_ty.variants) {
+                    assert_eq!(variant.id, variant_ty.id);
+                    self.symbolic(&variant.value, variant_ty.ty());
+                }
+            }
+            // QUESTION(mbm): should Option and Tuple be in a different enum so they don't appear in type inference?
+            (Symbolic::Option(_), _) => unimplemented!("option types unsupported"),
+            (Symbolic::Tuple(_), _) => unimplemented!("tuple types unsupported"),
+            (v, ty) => unreachable!("type mismatch: {v} of type {ty}"),
+        }
+    }
+
+    fn bit_vector_of_width(&mut self, x: ExprId, width: usize) {
+        self.ty(x, Type::BitVector(Width::Bits(width)));
+    }
+
+    fn bit_vector(&mut self, x: ExprId) {
+        self.ty(x, Type::BitVector(Width::Unknown));
+    }
+
+    fn integer(&mut self, x: ExprId) {
+        self.ty(x, Type::Int);
+    }
+
+    fn boolean(&mut self, x: ExprId) {
+        self.ty(x, Type::Bool);
+    }
+
+    fn ty(&mut self, x: ExprId, ty: Type) {
+        self.constraint(Constraint::Type { x, ty });
+    }
+
+    fn same_type(&mut self, x: ExprId, y: ExprId) {
+        self.constraint(Constraint::SameType { x, y });
+    }
+
+    fn width_of(&mut self, x: ExprId, w: ExprId) {
+        self.constraint(Constraint::WidthOf { x, w });
+    }
+
+    fn concat(&mut self, x: ExprId, l: ExprId, r: ExprId) {
+        self.constraint(Constraint::Concat { x, l, r });
+    }
+
+    fn boolean_value(&mut self, x: ExprId, b: bool) {
+        self.value(x, Const::Bool(b));
+    }
+
+    fn value(&mut self, x: ExprId, c: Const) {
+        self.constraint(Constraint::Value { x, c });
+    }
+
+    fn clause(&mut self, literals: Vec<Literal>) {
+        self.constraint(Constraint::Clause { literals })
+    }
+
+    fn constraint(&mut self, constraint: Constraint) {
+        let current = match self.arm.as_mut() {
+            Some(arm) => &mut arm.constraints,
+            None => &mut self.system.constraints,
+        };
+        current.push(constraint)
+    }
+
+    fn branch(&mut self) {
+        self.system.branches.push(Branch::default());
+    }
+
+    fn push_arm(&mut self, choice: Choice) {
+        assert!(self.arm.is_none());
+        self.arm = Some(Arm {
+            choice,
+            constraints: Vec::new(),
+        });
+    }
+
+    fn pop(&mut self) {
+        let arm = self.arm.take().expect("must have arm");
+        self.system
+            .branches
+            .last_mut()
+            .expect("should have branch")
+            .arms
+            .push(arm);
+    }
+}
+
+#[derive(Default, Clone)]
+pub struct Assignment {
+    pub expr_type_value: HashMap<ExprId, TypeValue>,
+}
+
+impl Assignment {
+    pub fn new() -> Self {
+        Self {
+            expr_type_value: HashMap::new(),
+        }
+    }
+
+    pub fn is_concrete(&self) -> bool {
+        self.expr_type_value
+            .values()
+            .all(|tv| tv.ty().is_concrete())
+    }
+
+    pub fn satisfies_constraints(&self, constraints: &[Constraint]) -> Result<()> {
+        constraints
+            .iter()
+            .try_for_each(|c| self.satisfies_constraint(c))
+    }
+
+    pub fn satisfies_constraint(&self, constraint: &Constraint) -> Result<()> {
+        match *constraint {
+            Constraint::Type { x, ref ty } => self.expect_expr_type_refinement(x, ty),
+            Constraint::SameType { x, y } => self.expect_same_type(x, y),
+            Constraint::Identical { x, y } => self.expect_identical(x, y),
+            Constraint::WidthOf { x, w } => self.expect_width_of(x, w),
+            Constraint::Concat { x, l, r } => self.expect_concat(x, l, r),
+            Constraint::Value { x, ref c } => self.expect_value(x, c),
+            Constraint::Implies { c, ref then } => self.expect_implies(c, then),
+            Constraint::Clause { ref literals } => self.expect_clause(literals),
+        }
+    }
+
+    pub fn assignment(&self, x: ExprId) -> Option<&TypeValue> {
+        self.expr_type_value.get(&x)
+    }
+
+    pub fn try_assignment(&self, x: ExprId) -> Result<&TypeValue> {
+        self.assignment(x).ok_or(format_err!(
+            "expression {x} missing assignment",
+            x = x.index()
+        ))
+    }
+
+    pub fn value(&self, x: ExprId) -> Option<&Const> {
+        self.assignment(x)?.as_value()
+    }
+
+    pub fn try_value(&self, x: ExprId) -> Result<&Const> {
+        self.value(x).ok_or(format_err!(
+            "expression {x} should be a known value",
+            x = x.index()
+        ))
+    }
+
+    pub fn bool_value(&self, x: ExprId) -> Option<bool> {
+        self.value(x)?.as_bool()
+    }
+
+    pub fn int_value(&self, x: ExprId) -> Option<i128> {
+        self.value(x)?.as_int()
+    }
+
+    pub fn try_int_value(&self, x: ExprId) -> Result<i128> {
+        self.int_value(x).ok_or(format_err!(
+            "expression {x} should be a known integer value",
+            x = x.index()
+        ))
+    }
+
+    pub fn literal(&self, lit: &Literal) -> Option<bool> {
+        match *lit {
+            Literal::Var(x) => self.bool_value(x),
+            Literal::Not(x) => Some(!self.bool_value(x)?),
+        }
+    }
+
+    fn expect_expr_type_refinement(&self, x: ExprId, base: &Type) -> Result<()> {
+        let tv = self.try_assignment(x)?;
+        if !tv.refines_type(base) {
+            bail!("expected type {tv} to be refinement of {base}")
+        }
+        Ok(())
+    }
+
+    fn expect_same_type(&self, x: ExprId, y: ExprId) -> Result<()> {
+        let tx = self.try_assignment(x)?.ty();
+        let ty = self.try_assignment(y)?.ty();
+        if tx != ty {
+            bail!(
+                "expressions {x} and {y} should have same type: got {tx} and {ty}",
+                x = x.index(),
+                y = y.index()
+            )
+        }
+        Ok(())
+    }
+
+    fn expect_identical(&self, x: ExprId, y: ExprId) -> Result<()> {
+        let tvx = self.try_assignment(x)?;
+        let tvy = self.try_assignment(y)?;
+        if tvx != tvy {
+            bail!(
+                "expressions {x} and {y} should be identical: got {tvx} and {tvy}",
+                x = x.index(),
+                y = y.index()
+            )
+        }
+        Ok(())
+    }
+
+    pub fn bit_vector_width(&self, x: ExprId) -> Option<usize> {
+        self.assignment(x)?.ty().as_bit_vector_width()?.as_bits()
+    }
+
+    pub fn try_bit_vector_width(&self, x: ExprId) -> Result<usize> {
+        self.bit_vector_width(x).ok_or(format_err!(
+            "expression {x} should be a bit-vector of known width",
+            x = x.index()
+        ))
+    }
+
+    fn expect_width_of(&self, x: ExprId, w: ExprId) -> Result<()> {
+        // Expression x should be a concrete bitvector.
+        let width = self.try_bit_vector_width(x)?;
+
+        // Expression w should be an integer equal to the width.
+        self.expect_value(w, &Const::Int(width.try_into().unwrap()))?;
+
+        Ok(())
+    }
+
+    fn expect_concat(&self, x: ExprId, l: ExprId, r: ExprId) -> Result<()> {
+        // All inputs should be bitvectors of known width.
+        let x_width = self.try_bit_vector_width(x)?;
+        let l_width = self.try_bit_vector_width(l)?;
+        let r_width = self.try_bit_vector_width(r)?;
+
+        // Verify x width is the sum of input widths.
+        let concat_width = l_width
+            .checked_add(r_width)
+            .expect("concat width should not overflow");
+        if x_width != concat_width {
+            bail!(
+                "expression {x} should be the concatenation of {l} and {r}",
+                x = x.index(),
+                l = l.index(),
+                r = r.index()
+            );
+        }
+
+        Ok(())
+    }
+
+    fn expect_value(&self, x: ExprId, expect: &Const) -> Result<()> {
+        let got = self.try_value(x)?;
+        if got != expect {
+            bail!("expected value {expect}; got {got}");
+        }
+        Ok(())
+    }
+
+    fn expect_implies(&self, c: ExprId, then: &Constraint) -> Result<()> {
+        if self.bool_value(c) == Some(true) {
+            self.satisfies_constraint(then)
+        } else {
+            Ok(())
+        }
+    }
+
+    fn expect_clause(&self, literals: &[Literal]) -> Result<()> {
+        for literal in literals {
+            match self.literal(literal) {
+                Some(true) | None => {
+                    return Ok(());
+                }
+                Some(false) => {
+                    continue;
+                }
+            }
+        }
+        bail!("false clause");
+    }
+
+    pub fn pretty_print(&self, conditions: &Conditions) {
+        for (i, expr) in conditions.exprs.iter().enumerate() {
+            print!("{i}:\t");
+            match self.expr_type_value.get(&ExprId(i)) {
+                None => print!("false\t-"),
+                Some(tv) => print!("{}\t{tv}", tv.ty().is_concrete()),
+            }
+            println!("\t{expr}");
+        }
+    }
+}
+
+pub struct Conflict {
+    pub x: ExprId,
+    pub reason: String,
+}
+
+impl Conflict {
+    fn new(x: ExprId, reason: String) -> Self {
+        Self { x, reason }
+    }
+
+    pub fn diagnostic(&self, conditions: &Conditions, files: &Files) -> String {
+        if let Some(pos) = conditions.pos.get(&self.x) {
+            format!(
+                "{position}: {reason}",
+                position = pos.pretty_print_line(files),
+                reason = self.reason
+            )
+        } else {
+            self.reason.clone()
+        }
+    }
+}
+
+pub enum Status {
+    Solved,
+    Inapplicable(Conflict),
+    Underconstrained,
+    TypeError(Conflict),
+}
+
+impl std::fmt::Display for Status {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Status::Solved => write!(f, "solved"),
+            Status::Inapplicable(..) => write!(f, "inapplicable"),
+            Status::Underconstrained => write!(f, "underconstrained"),
+            Status::TypeError(..) => write!(f, "type error"),
+        }
+    }
+}
+
+pub struct Solution {
+    pub status: Status,
+    pub choices: Vec<Choice>,
+    pub assignment: Assignment,
+}
+
+#[derive(Clone)]
+pub struct Solver {
+    assignment: Assignment,
+}
+
+impl Solver {
+    pub fn new() -> Self {
+        Self {
+            assignment: Assignment::new(),
+        }
+    }
+
+    pub fn solve(mut self, system: &System) -> Vec<Solution> {
+        // Deduce assignments from constraints.
+        let result = self.propagate(&system.constraints);
+        if let Err(status) = result {
+            return vec![Solution {
+                status,
+                choices: system.choices.clone(),
+                assignment: self.assignment,
+            }];
+        }
+
+        // Done?
+        if system.branches.is_empty() {
+            let status = if self.assignment.is_concrete() {
+                Status::Solved
+            } else {
+                Status::Underconstrained
+            };
+            return vec![Solution {
+                status,
+                choices: system.choices.clone(),
+                assignment: self.assignment,
+            }];
+        };
+
+        // Fork.
+        let mut solutions = Vec::new();
+        for child in system.fork() {
+            let sub = self.clone();
+            solutions.extend(sub.solve(&child));
+        }
+
+        solutions
+    }
+
+    fn propagate(&mut self, constraints: &[Constraint]) -> Result<(), Status> {
+        // Iterate until no changes.
+        while self.iterate(constraints)? {}
+        Ok(())
+    }
+
+    fn iterate(&mut self, constraints: &[Constraint]) -> Result<bool, Status> {
+        let mut change = false;
+        for constraint in constraints {
+            // TODO(mbm): remove satisfied constraints from list
+            change |= self.constraint(constraint)?;
+        }
+        Ok(change)
+    }
+
+    fn constraint(&mut self, constraint: &Constraint) -> Result<bool, Status> {
+        log::trace!("process type constraint: {constraint}");
+        match constraint {
+            Constraint::Type { x, ty } => self.set_type(*x, ty.clone()),
+            Constraint::SameType { x, y } => self.same_type(*x, *y),
+            Constraint::Identical { x, y } => self.identical(*x, *y),
+            Constraint::WidthOf { x, w } => self.width_of(*x, *w),
+            Constraint::Concat { x, l, r } => self.concat(*x, *l, *r),
+            Constraint::Value { x, c } => self.set_value(*x, c.clone()),
+            Constraint::Implies { c, then } => self.implies(*c, then),
+            Constraint::Clause { literals } => self.clause(literals),
+        }
+    }
+
+    fn set_type_value(&mut self, x: ExprId, tv: TypeValue) -> Result<bool, Status> {
+        log::trace!("set type value: {x:?} = {tv:?}");
+
+        // If we don't have an assignment for the expression, record it.
+        if let Entry::Vacant(e) = self.assignment.expr_type_value.entry(x) {
+            e.insert(tv);
+            return Ok(true);
+        }
+
+        // If we do, merge this type value with the existing one.
+        let existing = &self.assignment.expr_type_value[&x];
+        let merged = TypeValue::merge(existing, &tv).ok_or_else(|| {
+            if !existing.ty().is_compatible_with(&tv.ty()) {
+                Status::TypeError(Conflict::new(
+                    x,
+                    format!("concrete type error between types:\n\t{existing}\n\t{tv}"),
+                ))
+            } else {
+                Status::Inapplicable(Conflict::new(
+                    x,
+                    format!("inapplicable set type value: {existing:?} = {tv:?}"),
+                ))
+            }
+        })?;
+        if merged != *existing {
+            self.assignment.expr_type_value.insert(x, merged);
+            return Ok(true);
+        }
+
+        // No change.
+        Ok(false)
+    }
+
+    fn set_type(&mut self, x: ExprId, ty: Type) -> Result<bool, Status> {
+        self.set_type_value(x, TypeValue::Type(ty))
+    }
+
+    fn set_bit_vector_width(&mut self, x: ExprId, bits: usize) -> Result<bool, Status> {
+        self.set_type(x, Type::BitVector(Width::Bits(bits)))
+    }
+
+    fn same_type(&mut self, x: ExprId, y: ExprId) -> Result<bool, Status> {
+        // TODO(mbm): union find
+        // TODO(mbm): simplify by initializing all expression types to unknown
+        match (
+            self.assignment.expr_type_value.get(&x).cloned(),
+            self.assignment.expr_type_value.get(&y).cloned(),
+        ) {
+            (None, None) => Ok(false),
+            (Some(tvx), None) => self.set_type(y, tvx.ty()),
+            (None, Some(tvy)) => self.set_type(x, tvy.ty()),
+            (Some(tvx), Some(tvy)) => Ok(self.set_type(x, tvy.ty())? | self.set_type(y, tvx.ty())?),
+        }
+    }
+
+    fn identical(&mut self, x: ExprId, y: ExprId) -> Result<bool, Status> {
+        match (
+            self.assignment.expr_type_value.get(&x).cloned(),
+            self.assignment.expr_type_value.get(&y).cloned(),
+        ) {
+            (None, None) => Ok(false),
+            (Some(tvx), None) => self.set_type_value(y, tvx),
+            (None, Some(tvy)) => self.set_type_value(x, tvy),
+            (Some(tvx), Some(tvy)) => {
+                Ok(self.set_type_value(x, tvy)? | self.set_type_value(y, tvx)?)
+            }
+        }
+    }
+
+    fn width_of(&mut self, x: ExprId, w: ExprId) -> Result<bool, Status> {
+        match (
+            self.assignment.expr_type_value.get(&x),
+            self.assignment.expr_type_value.get(&w),
+        ) {
+            (
+                Some(
+                    &TypeValue::Type(Type::BitVector(Width::Bits(width)))
+                    | &TypeValue::Value(Const::BitVector(width, _)),
+                ),
+                _,
+            ) => self.set_int_value(w, width.try_into().unwrap()),
+            (_, Some(&TypeValue::Value(Const::Int(v)))) => {
+                self.set_bit_vector_width(x, v.try_into().unwrap())
+            }
+            _ => Ok(false),
+        }
+    }
+
+    fn concat(&mut self, x: ExprId, l: ExprId, r: ExprId) -> Result<bool, Status> {
+        match (
+            self.assignment.bit_vector_width(x),
+            self.assignment.bit_vector_width(l),
+            self.assignment.bit_vector_width(r),
+        ) {
+            // Two known: we can infer the third.
+            (None, Some(lw), Some(rw)) => {
+                // Width equation: |x| = |l| + |r|
+                self.set_bit_vector_width(x, lw + rw)
+            }
+            (Some(xw), None, Some(rw)) => {
+                // Width equation: |l| = |x| - |r|
+                self.set_bit_vector_width(
+                    l,
+                    xw.checked_sub(rw).ok_or_else(|| {
+                        Status::Inapplicable(Conflict::new(
+                            l,
+                            format!("inapplicable concat xw - rw: {l:?} = {r:?}"),
+                        ))
+                    })?,
+                )
+            }
+            (Some(xw), Some(lw), None) => {
+                // Width equation: |r| = |x| - |l|
+                self.set_bit_vector_width(
+                    r,
+                    xw.checked_sub(lw).ok_or_else(|| {
+                        Status::Inapplicable(Conflict::new(
+                            r,
+                            format!("inapplicable concat xw - lw: {l:?} = {r:?}"),
+                        ))
+                    })?,
+                )
+            }
+
+            // Zero or one known: cannot deduce anything.
+            (None, None, None)
+            | (None, None, Some(_))
+            | (None, Some(_), None)
+            | (Some(_), None, None) => Ok(false),
+
+            // All known: verify correctness.
+            (Some(xw), Some(lw), Some(rw)) => {
+                if xw != lw + rw {
+                    Err(Status::Inapplicable(Conflict::new(
+                        x,
+                        format!("inapplicable concat known: {l:?} = {r:?}"),
+                    )))
+                } else {
+                    Ok(false)
+                }
+            }
+        }
+    }
+
+    fn implies(&mut self, c: ExprId, then: &Constraint) -> Result<bool, Status> {
+        if self.assignment.bool_value(c) == Some(true) {
+            self.constraint(then)
+        } else {
+            Ok(false)
+        }
+    }
+
+    fn clause(&mut self, literals: &[Literal]) -> Result<bool, Status> {
+        // Check if we can propogate the value of a single unknown literal.
+        let mut unknown = None;
+        for literal in literals {
+            match (self.assignment.literal(literal), unknown) {
+                // One disjunction is known true. Can't deduce anything else.
+                (Some(true), _) => {
+                    return Ok(false);
+                }
+                // Known false: also deduce nothing.
+                (Some(false), _) => {
+                    continue;
+                }
+                // First unknown literal.
+                (None, None) => {
+                    unknown = Some(literal);
+                }
+                // More than one unknown literal: deduce nothing.
+                (None, Some(_)) => {
+                    return Ok(false);
+                }
+            }
+        }
+
+        // Assign true.
+        match unknown {
+            Some(lit) => self.set_literal(lit, true),
+            None => Ok(false),
+        }
+    }
+
+    fn set_literal(&mut self, lit: &Literal, b: bool) -> Result<bool, Status> {
+        match *lit {
+            Literal::Var(x) => self.set_bool_value(x, b),
+            Literal::Not(x) => self.set_bool_value(x, !b),
+        }
+    }
+
+    fn set_bool_value(&mut self, x: ExprId, b: bool) -> Result<bool, Status> {
+        self.set_value(x, Const::Bool(b))
+    }
+
+    fn set_int_value(&mut self, x: ExprId, v: i128) -> Result<bool, Status> {
+        self.set_value(x, Const::Int(v))
+    }
+
+    fn set_value(&mut self, x: ExprId, c: Const) -> Result<bool, Status> {
+        self.set_type_value(x, TypeValue::Value(c))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::testing::{assert_partial_order_properties, assert_strictly_increasing};
+
+    #[test]
+    fn test_type_value_partial_order_bit_vector() {
+        assert_strictly_increasing(&[
+            TypeValue::Type(Type::Unknown),
+            TypeValue::Type(Type::BitVector(Width::Unknown)),
+            TypeValue::Type(Type::BitVector(Width::Bits(64))),
+            TypeValue::Value(Const::BitVector(64, 42u8.into())),
+        ]);
+    }
+
+    #[test]
+    fn test_type_value_partial_order_int() {
+        assert_strictly_increasing(&[
+            TypeValue::Type(Type::Unknown),
+            TypeValue::Type(Type::Int),
+            TypeValue::Value(Const::Int(42)),
+        ]);
+    }
+
+    #[test]
+    fn test_type_value_partial_order_bool() {
+        assert_strictly_increasing(&[
+            TypeValue::Type(Type::Unknown),
+            TypeValue::Type(Type::Bool),
+            TypeValue::Value(Const::Bool(true)),
+        ]);
+    }
+
+    #[test]
+    fn test_type_value_partial_order_unspecified() {
+        assert_strictly_increasing(&[
+            TypeValue::Type(Type::Unspecified),
+            TypeValue::Value(Const::Unspecified),
+        ]);
+    }
+
+    #[test]
+    fn test_type_value_partial_order_properties() {
+        assert_partial_order_properties(&[
+            // Unknown
+            TypeValue::Type(Type::Unknown),
+            // BitVectors
+            TypeValue::Type(Type::BitVector(Width::Unknown)),
+            TypeValue::Type(Type::BitVector(Width::Bits(32))),
+            TypeValue::Value(Const::BitVector(32, 42u8.into())),
+            TypeValue::Value(Const::BitVector(32, 43u8.into())),
+            TypeValue::Type(Type::BitVector(Width::Bits(64))),
+            TypeValue::Value(Const::BitVector(64, 42u8.into())),
+            TypeValue::Value(Const::BitVector(64, 43u8.into())),
+            // Int
+            TypeValue::Type(Type::Int),
+            TypeValue::Value(Const::Int(42)),
+            TypeValue::Value(Const::Int(43)),
+            // Bool
+            TypeValue::Type(Type::Bool),
+            TypeValue::Value(Const::Bool(false)),
+            TypeValue::Value(Const::Bool(true)),
+            // Unspecified
+            TypeValue::Type(Type::Unspecified),
+            TypeValue::Value(Const::Unspecified),
+        ]);
+    }
+}
diff --git a/cranelift/isle/veri/veri/src/types.rs b/cranelift/isle/veri/veri/src/types.rs
new file mode 100644
index 000000000000..c1b89d7c0dad
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/types.rs
@@ -0,0 +1,488 @@
+use std::cmp::Ordering;
+
+use anyhow::Result;
+use cranelift_isle::{
+    ast::{Ident, ModelType},
+    lexer::Pos,
+    sema::{self, Sym, TypeEnv, TypeId, VariantId},
+};
+use num_bigint::BigUint;
+
+/// Width of a bit vector.
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+pub enum Width {
+    Unknown,
+    Bits(usize),
+}
+
+impl Width {
+    pub fn as_bits(&self) -> Option<usize> {
+        match self {
+            Width::Unknown => None,
+            Width::Bits(bits) => Some(*bits),
+        }
+    }
+}
+
+impl PartialOrd for Width {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        match (self, other) {
+            (Width::Unknown, Width::Unknown) => Some(Ordering::Equal),
+            (Width::Unknown, Width::Bits(_)) => Some(Ordering::Less),
+            (Width::Bits(_), Width::Unknown) => Some(Ordering::Greater),
+            (Width::Bits(l), Width::Bits(r)) if l == r => Some(Ordering::Equal),
+            (Width::Bits(_), Width::Bits(_)) => None,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+pub enum Type {
+    Unspecified,
+    Unknown,
+    BitVector(Width),
+    Int,
+    Bool,
+    Unit,
+}
+
+impl Type {
+    pub fn is_concrete(&self) -> bool {
+        match self {
+            Type::Unspecified => true,
+            Type::Unknown | Type::BitVector(Width::Unknown) => false,
+            Type::BitVector(Width::Bits(_)) | Type::Int | Type::Bool | Type::Unit => true,
+        }
+    }
+
+    pub fn as_bit_vector_width(&self) -> Option<&Width> {
+        match self {
+            Type::BitVector(w) => Some(w),
+            _ => None,
+        }
+    }
+
+    pub fn is_compatible_with(&self, other: &Type) -> bool {
+        match (self, other) {
+            (Type::Unknown, _)
+            | (_, Type::Unknown)
+            | (Type::Unspecified, Type::Unspecified)
+            | (Type::Unit, Type::Unit)
+            | (Type::Bool, Type::Bool)
+            | (Type::Int, Type::Int)
+            | (Type::BitVector(_), Type::BitVector(_)) => true,
+            _ => false,
+        }
+    }
+}
+
+impl std::fmt::Display for Type {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            Type::Unspecified => write!(f, "\u{2a33}"),
+            Type::Unknown => write!(f, "unk"),
+            Type::BitVector(Width::Bits(w)) => write!(f, "bv {w}"),
+            Type::BitVector(Width::Unknown) => write!(f, "bv _"),
+            Type::Int => write!(f, "int"),
+            Type::Bool => write!(f, "bool"),
+            Type::Unit => write!(f, "unit"),
+        }
+    }
+}
+
+impl PartialOrd for Type {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        match (self, other) {
+            // Unspecified is equal to itself, but otherwise incomparible.
+            (Type::Unspecified, Type::Unspecified) => Some(Ordering::Equal),
+            (Type::Unspecified, _) | (_, Type::Unspecified) => None,
+
+            (Type::Unknown, Type::Unknown) => Some(Ordering::Equal),
+            (Type::Unknown, _) => Some(Ordering::Less),
+            (_, Type::Unknown) => Some(Ordering::Greater),
+            (Type::BitVector(l), Type::BitVector(r)) => l.partial_cmp(r),
+            (Type::Int, Type::Int) => Some(Ordering::Equal),
+            (Type::Bool, Type::Bool) => Some(Ordering::Equal),
+            (Type::Unit, Type::Unit) => Some(Ordering::Equal),
+            (_, _) => None,
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum Compound {
+    Primitive(Type),
+    Struct(Vec<Field>),
+    Enum(Enum),
+    ExtEnum{base: Enum, extra: Vec<Field>},  // new compound type: ExtEnum
+    // TODO(mbm): intern name identifier
+    Named(Ident),
+}
+
+#[derive(Debug, Clone)]
+pub struct Field {
+    // TODO(mbm): intern name identifier
+    pub name: Ident,
+    pub ty: Compound,
+}
+
+impl Field {
+    fn from_isle(field: &sema::Field, tyenv: &TypeEnv) -> Self {
+        let ty = &tyenv.types[field.ty.index()];
+        Self {
+            name: Ident(tyenv.syms[field.name.index()].clone(), Pos::default()),
+            ty: Compound::named_from_isle(ty, tyenv),
+        }
+    }
+
+    /// Resolve any named types.
+    pub fn resolve<F>(&self, lookup: &mut F) -> Result<Self>
+    where
+        F: FnMut(&Ident) -> Result<Compound>,
+    {
+        Ok(Field {
+            name: self.name.clone(),
+            ty: self.ty.resolve(lookup)?,
+        })
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Variant {
+    pub name: Ident,
+    pub id: VariantId,
+    pub fields: Vec<Field>,
+}
+
+impl Variant {
+    fn from_isle(variant: &sema::Variant, tyenv: &TypeEnv) -> Self {
+        Self {
+            name: Ident(tyenv.syms[variant.name.index()].clone(), variant.pos),
+            id: variant.id,
+            fields: variant
+                .fields
+                .iter()
+                .map(|f| Field::from_isle(f, tyenv))
+                .collect(),
+        }
+    }
+
+    pub fn is_unit(&self) -> bool {
+        self.fields.is_empty()
+    }
+
+    pub fn ty(&self) -> Compound {
+        Compound::Struct(self.fields.clone())
+    }
+
+    /// Resolve any named types.
+    pub fn resolve<F>(&self, lookup: &mut F) -> Result<Self>
+    where
+        F: FnMut(&Ident) -> Result<Compound>,
+    {
+        Ok(Variant {
+            name: self.name.clone(),
+            id: self.id,
+            fields: self
+                .fields
+                .iter()
+                .map(|f| f.resolve(lookup))
+                .collect::<Result<_>>()?,
+        })
+    }
+}
+
+impl std::fmt::Display for Variant {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if self.is_unit() {
+            write!(f, "{name}", name = self.name.0)
+        } else {
+            write!(f, "{name} {ty}", name = self.name.0, ty = self.ty())
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Enum {
+    pub name: Ident,
+    pub id: TypeId,
+    pub variants: Vec<Variant>,
+}
+
+impl Enum {
+    pub fn from_isle(
+        name: Sym,
+        id: TypeId,
+        variants: &[sema::Variant],
+        pos: Pos,
+        tyenv: &TypeEnv,
+    ) -> Self {
+        Self {
+            name: Ident(tyenv.syms[name.index()].clone(), pos),
+            id,
+            variants: variants
+                .iter()
+                .map(|v| Variant::from_isle(v, tyenv))
+                .collect(),
+        }
+    }
+
+    /// Resolve any named types.
+    pub fn resolve<F>(&self, lookup: &mut F) -> Result<Self>
+    where
+        F: FnMut(&Ident) -> Result<Compound>,
+    {
+        Ok(Self {
+            name: self.name.clone(),
+            id: self.id,
+            variants: self
+                .variants
+                .iter()
+                .map(|v| v.resolve(lookup))
+                .collect::<Result<_>>()?,
+        })
+    }
+}
+
+impl Compound {
+    pub fn from_ast(model: &ModelType) -> Self {
+        match model {
+            ModelType::Unspecified => Self::Primitive(Type::Unspecified),
+            ModelType::Auto => Self::Primitive(Type::Unknown),
+            ModelType::Int => Self::Primitive(Type::Int),
+            ModelType::Bool => Self::Primitive(Type::Bool),
+            ModelType::Unit => Self::Primitive(Type::Unit),
+            ModelType::BitVec(None) => Self::Primitive(Type::BitVector(Width::Unknown)),
+            ModelType::BitVec(Some(bits)) => Self::Primitive(Type::BitVector(Width::Bits(*bits))),
+            ModelType::Struct(fields) => Self::Struct(
+                fields
+                    .iter()
+                    .map(|m| Field {
+                        name: m.name.clone(),
+                        ty: Self::from_ast(&m.ty),
+                    })
+                    .collect(),
+            ),
+            ModelType::Named(name) => Self::Named(name.clone()),
+            ModelType::ExtEnum(variants) => {
+                // Build `types::Variant`s
+                let lowered_variants: Vec<Variant> = variants
+                    .iter()
+                    .enumerate()
+                    .map(|(i, mv)| {
+                        let fields = mv.fields
+                            .iter()
+                            .map(|mf| Field {
+                                name: mf.name.clone(),
+                                ty: Self::from_ast(&mf.ty),
+                            })
+                            .collect();
+
+                        Variant {
+                            name: mv.name.clone(),
+                            id: VariantId(i),
+                            fields,
+                        }
+                    })
+                    .collect();
+
+                // Wrap in our Compound::ExtEnum
+                Self::ExtEnum {
+                    base: Enum {
+                        id: TypeId(0), // placeholder, depends on type assignment
+                        name: Ident("anon_extenum".to_string(), Pos::default()), // minimal Ident
+                        variants: lowered_variants,
+                    },
+                    extra: vec![], // can fill later if ExtEnum carries extras
+                }
+            }
+        }
+    }
+
+    /// Derive a type corresponding to the given ISLE type, if possible. For
+    /// ISLE internal enumerations, this will build the corresponding VeriISLE
+    /// enum representation.
+    pub fn from_isle(ty: &sema::Type, tyenv: &TypeEnv) -> Option<Self> {
+        match ty {
+            sema::Type::Enum {
+                name,
+                id,
+                variants,
+                pos,
+                ..
+            } if !variants.is_empty() => Some(Self::Enum(Enum::from_isle(
+                *name, *id, variants, *pos, tyenv,
+            ))),
+            _ => None,
+        }
+    }
+
+    /// Build a named reference to the given ISLE type.
+    pub fn named_from_isle(ty: &sema::Type, tyenv: &TypeEnv) -> Self {
+        Self::Named(Ident(ty.name(tyenv).to_string(), ty.pos()))
+    }
+
+    pub fn as_primitive(&self) -> Option<&Type> {
+        match self {
+            Compound::Primitive(ty) => Some(ty),
+            _ => None,
+        }
+    }
+
+    pub fn as_enum(&self) -> Option<&Enum> {
+        match self {
+            Compound::Enum(e) => Some(e),
+            Compound::ExtEnum { base, .. } => Some(base),
+            _ => None,
+        }
+    }
+
+    /// Resolve any named types.
+    pub fn resolve<F>(&self, lookup: &mut F) -> Result<Self>
+    where
+        F: FnMut(&Ident) -> Result<Compound>,
+    {
+        match self {
+            Compound::Primitive(_) => Ok(self.clone()),
+            Compound::Struct(fields) => Ok(Compound::Struct(
+                fields
+                    .iter()
+                    .map(|f| f.resolve(lookup))
+                    .collect::<Result<_>>()?,
+            )),
+            Compound::Enum(e) => Ok(Compound::Enum(e.resolve(lookup)?)),
+            Compound::ExtEnum { base, extra } => {
+                let base = base.resolve(lookup)?;
+                let extra = extra.iter().map(|f| f.resolve(lookup)).collect::<Result<_>>()?;
+                Ok(Compound::ExtEnum { base, extra })
+            }
+            Compound::Named(name) => {
+                // TODO(mbm): named type model cycle detection
+                let ty = lookup(name)?;
+                ty.resolve(lookup)
+            }
+        }
+    }
+}
+
+impl std::fmt::Display for Compound {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Compound::Primitive(ty) => ty.fmt(f),
+            Compound::Struct(fields) => write!(
+                f,
+                "{{{fields}}}",
+                fields = fields
+                    .iter()
+                    .map(|f| format!("{}: {}", f.name.0, f.ty))
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            ),
+            Compound::Enum(e) => {
+                write!(f, "enum({name})", name = e.name.0,)
+            }
+            Compound::ExtEnum { base, extra } => {
+                // format: "extenum(EnumName { ...extra fields... })"
+                write!(
+                    f,
+                    "extenum({} + [{}])",
+                    base.name.0,
+                    extra.iter()
+                        .map(|f| format!("{}: {}", f.name.0, f.ty))
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                )
+            }
+            Compound::Named(name) => write!(f, "{}", name.0),
+        }
+    }
+}
+
+// QUESTION(mbm): can this be deduped with the corresponding spec constant type?
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+pub enum Const {
+    Bool(bool),
+    Int(i128),
+    BitVector(usize, BigUint),
+    Unspecified,
+}
+
+impl Const {
+    pub fn ty(&self) -> Type {
+        match self {
+            Const::Bool(_) => Type::Bool,
+            Const::Int(_) => Type::Int,
+            Const::BitVector(w, _) => Type::BitVector(Width::Bits(*w)),
+            Const::Unspecified => Type::Unspecified,
+        }
+    }
+
+    pub fn as_bool(&self) -> Option<bool> {
+        match self {
+            Const::Bool(b) => Some(*b),
+            _ => None,
+        }
+    }
+
+    pub fn as_int(&self) -> Option<i128> {
+        match self {
+            Const::Int(v) => Some(*v),
+            _ => None,
+        }
+    }
+}
+
+impl std::fmt::Display for Const {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            Const::Bool(b) => write!(f, "{b}"),
+            Const::Int(v) => write!(f, "{v}"),
+            Const::BitVector(bits, v) => {
+                if bits % 4 == 0 {
+                    write!(f, "#x{v:0>nibbles$x}", nibbles = bits / 4)
+                } else {
+                    write!(f, "#b{v:0>bits$b}")
+                }
+            }
+            Const::Unspecified => write!(f, "\u{2a33}"),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::testing::assert_partial_order_properties;
+
+    #[test]
+    fn test_width_partial_order_less_than() {
+        assert!(Width::Unknown < Width::Bits(64));
+    }
+
+    #[test]
+    fn test_width_partial_order_properties() {
+        assert_partial_order_properties(&[Width::Unknown, Width::Bits(32), Width::Bits(64)]);
+    }
+
+    #[test]
+    fn test_type_partial_order_less_than() {
+        assert!(Type::Unknown < Type::BitVector(Width::Unknown));
+        assert!(Type::BitVector(Width::Unknown) < Type::BitVector(Width::Bits(64)));
+        assert!(Type::Unknown < Type::Int);
+        assert!(Type::Unknown < Type::Bool);
+    }
+
+    #[test]
+    fn test_type_partial_order_properties() {
+        assert_partial_order_properties(&[
+            Type::Unspecified,
+            Type::Unknown,
+            Type::BitVector(Width::Unknown),
+            Type::BitVector(Width::Bits(32)),
+            Type::BitVector(Width::Bits(64)),
+            Type::Int,
+            Type::Bool,
+            Type::Unit,
+        ]);
+    }
+}
diff --git a/cranelift/isle/veri/veri/src/veri.rs b/cranelift/isle/veri/veri/src/veri.rs
new file mode 100644
index 000000000000..9f05c4add706
--- /dev/null
+++ b/cranelift/isle/veri/veri/src/veri.rs
@@ -0,0 +1,2515 @@
+use crate::{
+    expand::{Constrain, Expansion},
+    program::Program,
+    spec::{self, Arm, Constructor, Signature, State},
+    trie::{binding_type, BindingType},
+    types::{Compound, Const, Type, Variant, Width},
+};
+use anyhow::{bail, format_err, Context, Error, Result};
+use cranelift_isle::{
+    ast::Ident,
+    lexer::Pos,
+    sema::{Sym, TermId, TypeId, VariantId},
+    trie_again::{Binding, BindingId, Constraint, TupleIndex},
+};
+use std::{
+    collections::{hash_map::Entry, HashMap, HashSet},
+    iter::zip,
+};
+
+declare_id!(
+    /// The id of an expression within verification Conditions.
+    #[must_use]
+    ExprId
+);
+
+declare_id!(
+    /// The id of a variable within verification Conditions.
+    VariableId
+);
+
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+pub enum Expr {
+    // Terminals.
+    Const(Const),
+    Variable(VariableId),
+
+    // Boolean.
+    Not(ExprId),
+    And(ExprId, ExprId),
+    Or(ExprId, ExprId),
+    Imp(ExprId, ExprId),
+    Eq(ExprId, ExprId),
+    Lt(ExprId, ExprId),
+    Lte(ExprId, ExprId),
+
+    BVUgt(ExprId, ExprId),
+    BVUge(ExprId, ExprId),
+    BVUlt(ExprId, ExprId),
+    BVUle(ExprId, ExprId),
+
+    BVSgt(ExprId, ExprId),
+    BVSge(ExprId, ExprId),
+    BVSlt(ExprId, ExprId),
+    BVSle(ExprId, ExprId),
+
+    BVSaddo(ExprId, ExprId),
+
+    // Unary.
+    BVNot(ExprId),
+    BVNeg(ExprId),
+    Cls(ExprId),
+    Clz(ExprId),
+    Rev(ExprId),
+    Popcnt(ExprId),
+
+    // Binary.
+    Add(ExprId, ExprId),
+    Sub(ExprId, ExprId),
+    Mul(ExprId, ExprId),
+    BVAdd(ExprId, ExprId),
+    BVSub(ExprId, ExprId),
+    BVMul(ExprId, ExprId),
+    BVSDiv(ExprId, ExprId),
+    BVUDiv(ExprId, ExprId),
+    BVSRem(ExprId, ExprId),
+    BVURem(ExprId, ExprId),
+    BVAnd(ExprId, ExprId),
+    BVOr(ExprId, ExprId),
+    BVXor(ExprId, ExprId),
+    BVShl(ExprId, ExprId),
+    BVLShr(ExprId, ExprId),
+    BVAShr(ExprId, ExprId),
+    BVRotl(ExprId, ExprId),
+    BVRotr(ExprId, ExprId),
+
+    // ITE
+    Conditional(ExprId, ExprId, ExprId),
+
+    // Bitwidth conversion.
+    BVZeroExt(ExprId, ExprId),
+    BVSignExt(ExprId, ExprId),
+    BVConvTo(ExprId, ExprId),
+
+    // Extract specified bit range.
+    BVExtract(usize, usize, ExprId),
+
+    // Concatenate bitvectors.
+    BVConcat(ExprId, ExprId),
+
+    // Integer conversion.
+    Int2BV(ExprId, ExprId),
+    BV2Nat(ExprId),
+
+    // Bitwidth.
+    WidthOf(ExprId),
+
+    // Floating point conversion.
+    ToFP(ExprId, ExprId),
+    ToFPUnsigned(ExprId, ExprId),
+    ToFPFromFP(ExprId, ExprId),
+    FPToUBV(ExprId, ExprId),
+    FPToSBV(ExprId, ExprId),
+
+    // Floating point.
+    FPPositiveInfinity(ExprId),
+    FPNegativeInfinity(ExprId),
+    FPPositiveZero(ExprId),
+    FPNegativeZero(ExprId),
+    FPNaN(ExprId),
+    FPEq(ExprId, ExprId),
+    FPNe(ExprId, ExprId),
+    FPLt(ExprId, ExprId),
+    FPGt(ExprId, ExprId),
+    FPLe(ExprId, ExprId),
+    FPGe(ExprId, ExprId),
+    FPAdd(ExprId, ExprId),
+    FPSub(ExprId, ExprId),
+    FPMul(ExprId, ExprId),
+    FPDiv(ExprId, ExprId),
+    FPMin(ExprId, ExprId),
+    FPMax(ExprId, ExprId),
+    FPNeg(ExprId),
+    FPCeil(ExprId),
+    FPFloor(ExprId),
+    FPSqrt(ExprId),
+    FPTrunc(ExprId),
+    FPNearest(ExprId),
+    FPIsZero(ExprId),
+    FPIsInfinite(ExprId),
+    FPIsNaN(ExprId),
+    FPIsNegative(ExprId),
+    FPIsPositive(ExprId),
+}
+
+impl Expr {
+    pub fn is_variable(&self) -> bool {
+        matches!(self, Self::Variable(_))
+    }
+
+    pub fn pure(&self) -> bool {
+        match self {
+            Expr::BVConvTo(..) => false,
+            _ => true,
+        }
+    }
+
+    pub fn sources(&self) -> Vec<ExprId> {
+        match self {
+            Expr::Const(_) | Expr::Variable(_) => Vec::new(),
+            // Unary
+            Expr::Not(x)
+            | Expr::BVNot(x)
+            | Expr::BVNeg(x)
+            | Expr::BVExtract(_, _, x)
+            | Expr::BV2Nat(x)
+            | Expr::Cls(x)
+            | Expr::Clz(x)
+            | Expr::Rev(x)
+            | Expr::Popcnt(x)
+            | Expr::WidthOf(x)
+            | Expr::FPPositiveInfinity(x)
+            | Expr::FPNegativeInfinity(x)
+            | Expr::FPPositiveZero(x)
+            | Expr::FPNegativeZero(x)
+            | Expr::FPNaN(x)
+            | Expr::FPNeg(x)
+            | Expr::FPCeil(x)
+            | Expr::FPFloor(x)
+            | Expr::FPSqrt(x)
+            | Expr::FPTrunc(x)
+            | Expr::FPNearest(x)
+            | Expr::FPIsZero(x)
+            | Expr::FPIsInfinite(x)
+            | Expr::FPIsNaN(x)
+            | Expr::FPIsNegative(x)
+            | Expr::FPIsPositive(x) => vec![*x],
+
+            // Binary
+            Expr::And(x, y)
+            | Expr::Or(x, y)
+            | Expr::Imp(x, y)
+            | Expr::Eq(x, y)
+            | Expr::Lt(x, y)
+            | Expr::Lte(x, y)
+            | Expr::Add(x, y)
+            | Expr::Sub(x, y)
+            | Expr::Mul(x, y)
+            | Expr::BVUgt(x, y)
+            | Expr::BVUge(x, y)
+            | Expr::BVUlt(x, y)
+            | Expr::BVUle(x, y)
+            | Expr::BVSgt(x, y)
+            | Expr::BVSge(x, y)
+            | Expr::BVSlt(x, y)
+            | Expr::BVSle(x, y)
+            | Expr::BVSaddo(x, y)
+            | Expr::BVAdd(x, y)
+            | Expr::BVSub(x, y)
+            | Expr::BVMul(x, y)
+            | Expr::BVSDiv(x, y)
+            | Expr::BVUDiv(x, y)
+            | Expr::BVSRem(x, y)
+            | Expr::BVURem(x, y)
+            | Expr::BVAnd(x, y)
+            | Expr::BVOr(x, y)
+            | Expr::BVXor(x, y)
+            | Expr::BVShl(x, y)
+            | Expr::BVLShr(x, y)
+            | Expr::BVAShr(x, y)
+            | Expr::BVRotl(x, y)
+            | Expr::BVRotr(x, y)
+            | Expr::BVZeroExt(x, y)
+            | Expr::BVSignExt(x, y)
+            | Expr::BVConvTo(x, y)
+            | Expr::Int2BV(x, y)
+            | Expr::ToFP(x, y)
+            | Expr::ToFPUnsigned(x, y)
+            | Expr::ToFPFromFP(x, y)
+            | Expr::FPToUBV(x, y)
+            | Expr::FPToSBV(x, y)
+            | Expr::BVConcat(x, y)
+            | Expr::FPEq(x, y)
+            | Expr::FPNe(x, y)
+            | Expr::FPLt(x, y)
+            | Expr::FPGt(x, y)
+            | Expr::FPLe(x, y)
+            | Expr::FPGe(x, y)
+            | Expr::FPAdd(x, y)
+            | Expr::FPSub(x, y)
+            | Expr::FPMul(x, y)
+            | Expr::FPDiv(x, y)
+            | Expr::FPMin(x, y)
+            | Expr::FPMax(x, y) => vec![*x, *y],
+
+            // Ternary
+            Expr::Conditional(c, t, e) => vec![*c, *t, *e],
+        }
+    }
+}
+
+impl std::fmt::Display for Expr {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            Expr::Const(c) => write!(f, "const({c})"),
+            Expr::Variable(v) => write!(f, "var({})", v.index()),
+            Expr::Not(x) => write!(f, "!{}", x.index()),
+            Expr::And(x, y) => write!(f, "{} && {}", x.index(), y.index()),
+            Expr::Or(x, y) => write!(f, "{} || {}", x.index(), y.index()),
+            Expr::Imp(x, y) => write!(f, "{} => {}", x.index(), y.index()),
+            Expr::Eq(x, y) => write!(f, "{} == {}", x.index(), y.index()),
+            Expr::Lt(x, y) => write!(f, "{} < {}", x.index(), y.index()),
+            Expr::Lte(x, y) => write!(f, "{} <= {}", x.index(), y.index()),
+            Expr::Add(x, y) => write!(f, "{} + {}", x.index(), y.index()),
+            Expr::Sub(x, y) => write!(f, "{} - {}", x.index(), y.index()),
+            Expr::Mul(x, y) => write!(f, "{} * {}", x.index(), y.index()),
+            Expr::BVUgt(x, y) => write!(f, "bvugt({}, {})", x.index(), y.index()),
+            Expr::BVUge(x, y) => write!(f, "bvuge({}, {})", x.index(), y.index()),
+            Expr::BVUlt(x, y) => write!(f, "bvult({}, {})", x.index(), y.index()),
+            Expr::BVUle(x, y) => write!(f, "bvule({}, {})", x.index(), y.index()),
+            Expr::BVSgt(x, y) => write!(f, "bvsgt({}, {})", x.index(), y.index()),
+            Expr::BVSge(x, y) => write!(f, "bvsge({}, {})", x.index(), y.index()),
+            Expr::BVSlt(x, y) => write!(f, "bvslt({}, {})", x.index(), y.index()),
+            Expr::BVSle(x, y) => write!(f, "bvsle({}, {})", x.index(), y.index()),
+            Expr::BVSaddo(x, y) => write!(f, "bvsaddo({}, {})", x.index(), y.index()),
+            Expr::BVNot(x) => write!(f, "bvnot({})", x.index()),
+            Expr::BVNeg(x) => write!(f, "bvneg({})", x.index()),
+            Expr::Cls(x) => write!(f, "cls({})", x.index()),
+            Expr::Clz(x) => write!(f, "clz({})", x.index()),
+            Expr::Rev(x) => write!(f, "rev({})", x.index()),
+            Expr::Popcnt(x) => write!(f, "popcnt({})", x.index()),
+            Expr::BVAdd(x, y) => write!(f, "bvadd({}, {})", x.index(), y.index()),
+            Expr::BVSub(x, y) => write!(f, "bvsub({}, {})", x.index(), y.index()),
+            Expr::BVMul(x, y) => write!(f, "bvmul({}, {})", x.index(), y.index()),
+            Expr::BVSDiv(x, y) => write!(f, "bvsdiv({}, {})", x.index(), y.index()),
+            Expr::BVUDiv(x, y) => write!(f, "bvudiv({}, {})", x.index(), y.index()),
+            Expr::BVSRem(x, y) => write!(f, "bvsrem({}, {})", x.index(), y.index()),
+            Expr::BVURem(x, y) => write!(f, "bvurem({}, {})", x.index(), y.index()),
+            Expr::BVAnd(x, y) => write!(f, "bvand({}, {})", x.index(), y.index()),
+            Expr::BVOr(x, y) => write!(f, "bvor({}, {})", x.index(), y.index()),
+            Expr::BVXor(x, y) => write!(f, "bvxor({}, {})", x.index(), y.index()),
+            Expr::BVShl(x, y) => write!(f, "bvshl({}, {})", x.index(), y.index()),
+            Expr::BVLShr(x, y) => write!(f, "bvlshr({}, {})", x.index(), y.index()),
+            Expr::BVAShr(x, y) => write!(f, "bvashr({}, {})", x.index(), y.index()),
+            Expr::BVRotl(x, y) => write!(f, "bvrotl({}, {})", x.index(), y.index()),
+            Expr::BVRotr(x, y) => write!(f, "bvrotr({}, {})", x.index(), y.index()),
+            Expr::Conditional(c, t, e) => {
+                write!(f, "{} ? {} : {}", c.index(), t.index(), e.index())
+            }
+            Expr::BVZeroExt(w, x) => write!(f, "bv_zero_ext({}, {})", w.index(), x.index()),
+            Expr::BVSignExt(w, x) => write!(f, "bv_zero_ext({}, {})", w.index(), x.index()),
+            Expr::BVConvTo(w, x) => write!(f, "bv_conv_to({}, {})", w.index(), x.index()),
+            Expr::BVExtract(h, l, x) => write!(f, "bv_extract({h}, {l}, {})", x.index()),
+            Expr::BVConcat(x, y) => write!(f, "bv_concat({}, {})", x.index(), y.index()),
+            Expr::Int2BV(w, x) => write!(f, "int2bv({}, {})", w.index(), x.index()),
+            Expr::ToFP(w, x) => write!(f, "to_fp({}, {})", w.index(), x.index()),
+            Expr::ToFPUnsigned(w, x) => write!(f, "to_fp_unsigned({}, {})", w.index(), x.index()),
+            Expr::ToFPFromFP(w, x) => write!(f, "to_fp_from_fp({}, {})", w.index(), x.index()),
+            Expr::FPToUBV(w, x) => write!(f, "fp.to_ubv({}, {})", w.index(), x.index()),
+            Expr::FPToSBV(w, x) => write!(f, "fp.to_sbv({}, {})", w.index(), x.index()),
+            Expr::BV2Nat(x) => write!(f, "bv2nat({})", x.index()),
+            Expr::WidthOf(x) => write!(f, "width_of({})", x.index()),
+            Expr::FPPositiveInfinity(x) => write!(f, "fp.+oo({})", x.index()),
+            Expr::FPNegativeInfinity(x) => write!(f, "fp.-oo({})", x.index()),
+            Expr::FPPositiveZero(x) => write!(f, "fp.+zero({})", x.index()),
+            Expr::FPNegativeZero(x) => write!(f, "fp.-zero({})", x.index()),
+            Expr::FPNaN(x) => write!(f, "fp.NaN({})", x.index()),
+            Expr::FPEq(x, y) => write!(f, "fp.eq({}, {})", x.index(), y.index()),
+            Expr::FPNe(x, y) => write!(f, "fp.ne({}, {})", x.index(), y.index()),
+            Expr::FPLt(x, y) => write!(f, "fp.lt({}, {})", x.index(), y.index()),
+            Expr::FPGt(x, y) => write!(f, "fp.gt({}, {})", x.index(), y.index()),
+            Expr::FPLe(x, y) => write!(f, "fp.le({}, {})", x.index(), y.index()),
+            Expr::FPGe(x, y) => write!(f, "fp.ge({}, {})", x.index(), y.index()),
+            Expr::FPAdd(x, y) => write!(f, "fp.add({}, {})", x.index(), y.index()),
+            Expr::FPSub(x, y) => write!(f, "fp.sub({}, {})", x.index(), y.index()),
+            Expr::FPMul(x, y) => write!(f, "fp.mul({}, {})", x.index(), y.index()),
+            Expr::FPDiv(x, y) => write!(f, "fp.div({}, {})", x.index(), y.index()),
+            Expr::FPMin(x, y) => write!(f, "fp.min({}, {})", x.index(), y.index()),
+            Expr::FPMax(x, y) => write!(f, "fp.max({}, {})", x.index(), y.index()),
+            Expr::FPNeg(x) => write!(f, "fp.neg({})", x.index()),
+            Expr::FPCeil(x) => write!(f, "fp.ceil({})", x.index()),
+            Expr::FPFloor(x) => write!(f, "fp.floor({})", x.index()),
+            Expr::FPSqrt(x) => write!(f, "fp.sqrt({})", x.index()),
+            Expr::FPTrunc(x) => write!(f, "fp.trunc({})", x.index()),
+            Expr::FPNearest(x) => write!(f, "fp.nearest({})", x.index()),
+            Expr::FPIsZero(x) => write!(f, "fp.isZero({})", x.index()),
+            Expr::FPIsInfinite(x) => write!(f, "fp.isInfinite({})", x.index()),
+            Expr::FPIsNaN(x) => write!(f, "fp.isNaN({})", x.index()),
+            Expr::FPIsNegative(x) => write!(f, "fp.isNegative({})", x.index()),
+            Expr::FPIsPositive(x) => write!(f, "fp.isPositive({})", x.index()),
+        }
+    }
+}
+
+// QUESTION(mbm): can we merge `Model` and `Assignment` from type inference?
+pub type Model = HashMap<ExprId, Const>;
+
+// QUESTION(mbm): does the distinction between expressions and variables make sense?
+#[derive(Debug)]
+pub struct Variable {
+    pub ty: Type,
+    pub name: String,
+}
+
+impl Variable {
+    fn component_name(prefix: &str, field: &str) -> String {
+        format!("{prefix}_{field}")
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct SymbolicOption {
+    some: ExprId,
+    inner: Box<Symbolic>,
+}
+
+#[derive(Debug, Clone)]
+pub struct SymbolicField {
+    pub name: String,
+    pub value: Symbolic,
+}
+
+impl SymbolicField {
+    fn eval(&self, model: &Model) -> Result<FieldValue> {
+        Ok(FieldValue {
+            name: self.name.clone(),
+            value: self.value.eval(model)?,
+        })
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct SymbolicEnum {
+    pub ty: TypeId,
+    pub discriminant: ExprId,
+    pub variants: Vec<SymbolicVariant>,
+}
+
+impl SymbolicEnum {
+    fn try_variant_by_name(&self, name: &str) -> Result<&SymbolicVariant> {
+        self.variants
+            .iter()
+            .find(|v| v.name == name)
+            .ok_or(format_err!("no variant with name {name}"))
+    }
+
+    fn validate(&self) -> Result<()> {
+        // Expect the variants to have distinct discriminants in the range [0, num_variants).
+        for (expect, variant) in self.variants.iter().enumerate() {
+            if variant.discriminant != expect {
+                bail!(
+                    "variant '{name}' has unexpected discriminant",
+                    name = variant.name
+                );
+            }
+        }
+        Ok(())
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct SymbolicVariant {
+    pub name: String,
+    pub id: VariantId,
+    pub discriminant: usize,
+    pub value: Symbolic,
+}
+
+impl SymbolicVariant {
+    fn try_field_by_name(&self, name: &str) -> Result<&SymbolicField> {
+        self.fields()?
+            .iter()
+            .find(|f| f.name == name)
+            .ok_or(format_err!("no field with name {name}"))
+    }
+
+    fn field_values(&self) -> Result<Vec<Symbolic>> {
+        Ok(self.fields()?.iter().map(|f| f.value.clone()).collect())
+    }
+
+    fn fields(&self) -> Result<&Vec<SymbolicField>> {
+        self.value
+            .as_struct()
+            .ok_or(format_err!("variant value is not a struct"))
+    }
+}
+
+impl std::fmt::Display for SymbolicVariant {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{name} {value}", name = self.name, value = self.value)
+    }
+}
+
+/// Inline spec expression macro.
+///
+/// Note that at this stage the spec expressions are preserved as
+/// [`spec::Expr`]. Generation of [`Expr`] objects from them is deferred until
+/// macro expansion.
+#[derive(Debug, Clone)]
+pub struct Macro {
+    pub params: Vec<Ident>,
+    pub body: spec::Expr,
+}
+
+#[derive(Debug, Clone)]
+pub enum Symbolic {
+    Scalar(ExprId),
+    Struct(Vec<SymbolicField>),
+    Enum(SymbolicEnum),
+    ExtEnum(SymbolicEnum, Vec<SymbolicField>), // ext enum with extra fields 
+    Option(SymbolicOption),
+    Tuple(Vec<Symbolic>),
+    Macro(Macro),
+}
+
+impl Symbolic {
+    fn as_scalar(&self) -> Option<ExprId> {
+        match self {
+            Self::Scalar(x) => Some(*x),
+            _ => None,
+        }
+    }
+
+    fn as_struct(&self) -> Option<&Vec<SymbolicField>> {
+        match self {
+            Self::Struct(fields) => Some(fields),
+            // Self::ExtEnum(_, fields) => Some (fields),
+            _ => None,
+        }
+    }
+
+    fn as_enum(&self) -> Option<&SymbolicEnum> {
+        match self {
+            Self::Enum(e) => Some(e),
+            Self::ExtEnum(e, _) => Some(e), 
+            _ => None,
+        }
+    }
+
+    fn as_option(&self) -> Option<&SymbolicOption> {
+        match self {
+            Self::Option(opt) => Some(opt),
+            _ => None,
+        }
+    }
+
+    fn as_tuple(&self) -> Option<&Vec<Symbolic>> {
+        match self {
+            Self::Tuple(fields) => Some(fields),
+            _ => None,
+        }
+    }
+
+    fn elements(&self) -> &[Symbolic] {
+        match self {
+            Self::Tuple(fields) => &fields[..],
+            v => std::slice::from_ref(v),
+        }
+    }
+
+    fn eval(&self, model: &Model) -> Result<Value> {
+        match self {
+            Symbolic::Scalar(x) => Ok(Value::Const(
+                model
+                    .get(x)
+                    .ok_or(format_err!("undefined expression in model"))?
+                    .clone(),
+            )),
+            Symbolic::Struct(fields) => Ok(Value::Struct(
+                fields
+                    .iter()
+                    .map(|f| f.eval(model))
+                    .collect::<Result<_>>()?,
+            )),
+            Symbolic::Enum(e) => {
+                // Determine the enum variant by looking up the discriminant.
+                let discriminant: usize = model
+                    .get(&e.discriminant)
+                    .ok_or(format_err!("undefined discriminant in model"))?
+                    .as_int()
+                    .ok_or(format_err!(
+                        "model value for discriminant is not an integer"
+                    ))?
+                    .try_into()
+                    .unwrap();
+                let variant = e
+                    .variants
+                    .iter()
+                    .find(|v| v.discriminant == discriminant)
+                    .ok_or(format_err!("no variant with discriminant {discriminant}"))?;
+                Ok(Value::Enum(Box::new(VariantValue {
+                    name: variant.name.clone(),
+                    value: variant.value.eval(model)?,
+                })))
+            }
+            Symbolic::ExtEnum(e, extra) => {
+                // 1. Same as Enum: resolve discriminant and variant
+                let discriminant: usize = model
+                    .get(&e.discriminant)
+                    .ok_or(format_err!("undefined discriminant in model"))?
+                    .as_int()
+                    .ok_or(format_err!(
+                        "model value for discriminant is not an integer"
+                    ))?
+                    .try_into()
+                    .unwrap();
+                let variant = e
+                    .variants
+                    .iter()
+                    .find(|v| v.discriminant == discriminant)
+                    .ok_or(format_err!("no variant with discriminant {discriminant}"))?;
+
+                let base_value = Value::Enum(Box::new(VariantValue {
+                    name: variant.name.clone(),
+                    value: variant.value.eval(model)?,
+                }));
+
+                // 2. Evaluate extra fields like a struct
+                let extra_values = extra
+                    .iter()
+                    .map(|f| f.eval(model))
+                    .collect::<Result<Vec<_>>>()?;
+
+                // 3. Wrap into a new Value variant (you’ll need a `Value::ExtEnum` to store this)
+                Ok(Value::ExtEnum {
+                    base: Box::new(base_value),
+                    extra: extra_values,
+                })
+            }
+
+            Symbolic::Option(opt) => match model.get(&opt.some) {
+                Some(Const::Bool(true)) => {
+                    Ok(Value::Option(Some(Box::new(opt.inner.eval(model)?))))
+                }
+                Some(Const::Bool(false)) => Ok(Value::Option(None)),
+                Some(_) => bail!("model value for option some is not boolean"),
+                None => bail!("undefined expression in model"),
+            },
+            Symbolic::Tuple(elements) => Ok(Value::Tuple(
+                elements
+                    .iter()
+                    .map(|s| s.eval(model))
+                    .collect::<Result<_>>()?,
+            )),
+            Symbolic::Macro(_) => bail!("cannot evaluate macro"),
+        }
+    }
+
+    // Build a new value by applying the given map function to all constituent
+    // scalars in this symbolic value.
+    fn scalar_map<F>(&self, f: &mut F) -> Symbolic
+    where
+        F: FnMut(ExprId) -> ExprId,
+    {
+        match self {
+            Symbolic::Scalar(x) => Symbolic::Scalar(f(*x)),
+            Symbolic::Struct(fields) => Symbolic::Struct(
+                fields
+                    .iter()
+                    .map(|field| SymbolicField {
+                        name: field.name.clone(),
+                        value: field.value.scalar_map(f),
+                    })
+                    .collect(),
+            ),
+            Symbolic::Enum(e) => Symbolic::Enum(SymbolicEnum {
+                ty: e.ty,
+                discriminant: f(e.discriminant),
+                variants: e
+                    .variants
+                    .iter()
+                    .map(|v| SymbolicVariant {
+                        id: v.id,
+                        name: v.name.clone(),
+                        discriminant: v.discriminant,
+                        value: v.value.scalar_map(f),
+                    })
+                    .collect(),
+            }),
+            v => todo!("scalar map: {v:?}"),
+        }
+    }
+
+    fn merge<F>(a: &Symbolic, b: &Symbolic, merge: &mut F) -> Result<Symbolic>
+    where
+        F: FnMut(ExprId, ExprId) -> ExprId,
+    {
+        if std::mem::discriminant(a) != std::mem::discriminant(b) {
+            bail!("conditional arms have incompatible types");
+        }
+        match (a, b) {
+            (Symbolic::Scalar(a), Symbolic::Scalar(b)) => Ok(merge(*a, *b).into()),
+            (Symbolic::Struct(a_fields), Symbolic::Struct(b_fields)) => {
+                assert_eq!(a_fields.len(), b_fields.len());
+                Ok(Symbolic::Struct(
+                    zip(a_fields, b_fields)
+                        .map(|(a, b)| {
+                            assert_eq!(a.name, b.name);
+                            Ok(SymbolicField {
+                                name: a.name.clone(),
+                                value: Symbolic::merge(&a.value, &b.value, merge)?,
+                            })
+                        })
+                        .collect::<Result<_>>()?,
+                ))
+            }
+            (Symbolic::Enum(a), Symbolic::Enum(b)) => {
+                assert_eq!(a.ty, b.ty);
+                let ty = a.ty;
+                let discriminant = merge(a.discriminant, b.discriminant);
+                assert_eq!(a.variants.len(), b.variants.len());
+                let variants = zip(&a.variants, &b.variants)
+                    .map(|(a, b)| {
+                        assert_eq!(a.name, b.name);
+                        assert_eq!(a.id, b.id);
+                        assert_eq!(a.discriminant, b.discriminant);
+                        Ok(SymbolicVariant {
+                            name: a.name.clone(),
+                            id: a.id,
+                            discriminant: a.discriminant,
+                            value: Symbolic::merge(&a.value, &b.value, merge)?,
+                        })
+                    })
+                    .collect::<Result<_>>()?;
+                Ok(Symbolic::Enum(SymbolicEnum {
+                    ty,
+                    discriminant,
+                    variants,
+                }))
+            }
+            case => todo!("symbolic merge types: {case:?}"),
+        }
+    }
+}
+
+impl From<ExprId> for Symbolic {
+    fn from(x: ExprId) -> Self {
+        Symbolic::Scalar(x)
+    }
+}
+
+impl std::fmt::Display for Symbolic {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Symbolic::Scalar(x) => write!(f, "{}", x.index()),
+            Symbolic::Struct(fields) => write!(
+                f,
+                "{{{fields}}}",
+                fields = fields
+                    .iter()
+                    .map(|f| format!("{}: {}", f.name, f.value))
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            ),
+            Symbolic::Enum(e) => write!(
+                f,
+                "{{{discriminant}, {variants}}}",
+                discriminant = e.discriminant.index(),
+                variants = e
+                    .variants
+                    .iter()
+                    .map(|v| v.to_string())
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            ),
+            Symbolic::ExtEnum(base_enum, extra_fields) => {
+                write!(
+                    f,
+                    "extenum({discriminant}, {variants}, extras: {{{extras}}})",
+                    discriminant = base_enum.discriminant.index(),
+                    variants = base_enum
+                        .variants
+                        .iter()
+                        .map(|v| v.to_string())
+                        .collect::<Vec<_>>()
+                        .join(", "),
+                    extras = extra_fields
+                        .iter()
+                        .map(|f| format!("{}: {}", f.name, f.value))
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                )
+            }
+            Symbolic::Option(SymbolicOption { some, inner }) => {
+                write!(f, "Option{{some: {}, inner: {inner}}}", some.index())
+            }
+            Symbolic::Tuple(vs) => write!(
+                f,
+                "({vs})",
+                vs = vs
+                    .iter()
+                    .map(|v| v.to_string())
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            ),
+            Symbolic::Macro(_) => write!(f, "macro"),
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum Value {
+    Const(Const),
+    Struct(Vec<FieldValue>),
+    Enum(Box<VariantValue>),
+    ExtEnum {
+        base: Box<Value>, // base enum value
+        extra: Vec<FieldValue>, // evaluated extra fields 
+    }, 
+    Option(Option<Box<Value>>),
+    Tuple(Vec<Value>),
+}
+
+#[derive(Debug, Clone)]
+pub struct FieldValue {
+    name: String,
+    value: Value,
+}
+
+#[derive(Debug, Clone)]
+pub struct VariantValue {
+    name: String,
+    value: Value,
+}
+
+impl std::fmt::Display for Value {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Value::Const(c) => c.fmt(f),
+            Value::Struct(fields) => write!(
+                f,
+                "{{{fields}}}",
+                fields = fields
+                    .iter()
+                    .map(|f| format!("{}: {}", f.name, f.value))
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            ),
+            Value::Enum(v) => write!(f, "{name} {value}", name = v.name, value = v.value),
+            Value::ExtEnum { base, extra } => {
+                write!(
+                    f,
+                    "extenum({base}, extras: {{{extras}}})",
+                    base = base,
+                    extras = extra
+                        .iter()
+                        .map(|f| format!("{}: {}", f.name, f.value))
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                )
+            }
+            Value::Option(Some(v)) => write!(f, "Some({v})"),
+            Value::Option(None) => write!(f, "None"),
+            Value::Tuple(elements) => write!(
+                f,
+                "({})",
+                elements
+                    .iter()
+                    .map(|v| v.to_string())
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            ),
+        }
+    }
+}
+
+// QUESTION(mbm): is `Call` the right name? consider `Term`, `TermInstance`, ...?
+#[derive(Debug)]
+pub struct Call {
+    pub term: TermId,
+    pub args: Vec<Symbolic>,
+    pub ret: Symbolic,
+    pub signatures: Vec<Signature>,
+}
+
+// Type qualifier, for example derived from an `(as ...)` expression.
+#[derive(Debug)]
+pub struct Qualifier {
+    pub value: Symbolic,
+    pub ty: Compound,
+}
+
+/// Verification conditions for an expansion.
+#[derive(Debug, Default)]
+pub struct Conditions {
+    pub exprs: Vec<Expr>,
+    pub assumptions: Vec<ExprId>,
+    pub assertions: Vec<ExprId>,
+    pub variables: Vec<Variable>,
+    pub state: Variables,
+    pub calls: Vec<Call>,
+    pub qualifiers: Vec<Qualifier>,
+    pub pos: HashMap<ExprId, Pos>,
+}
+
+impl Conditions {
+    pub fn from_expansion(expansion: &Expansion, prog: &Program) -> Result<Self> {
+        let builder = ConditionsBuilder::new(expansion, prog);
+        builder.build()
+    }
+
+    pub fn pretty_print(&self, prog: &Program) {
+        println!("conditions {{");
+
+        // Expressions
+        println!("\texprs = [");
+        for (i, expr) in self.exprs.iter().enumerate() {
+            println!("\t\t{i}:\t{expr}");
+        }
+        println!("\t]");
+
+        // Assumptions
+        println!("\tassumptions = [");
+        for expr_id in &self.assumptions {
+            println!("\t\t{}", expr_id.index());
+        }
+        println!("\t]");
+
+        // Assertions
+        println!("\tassertions = [");
+        for expr_id in &self.assertions {
+            println!("\t\t{}", expr_id.index());
+        }
+        println!("\t]");
+
+        // Variables
+        println!("\tvariables = [");
+        for (i, v) in self.variables.iter().enumerate() {
+            println!("\t\t{i}:\t{ty}\t{name}", ty = v.ty, name = v.name);
+        }
+        println!("\t]");
+
+        // Calls
+        // TODO(mbm): prettier pretty printing code
+        println!("\tcalls = [");
+        for call in &self.calls {
+            println!("\t\tcall {{");
+            println!("\t\t\tterm = {}", prog.term_name(call.term));
+            if !call.args.is_empty() {
+                println!("\t\t\targs = [");
+                for arg in &call.args {
+                    println!("\t\t\t\t{}", arg);
+                }
+                println!("\t\t\t]");
+            }
+            println!("\t\t\tret = {}", call.ret);
+            if !call.signatures.is_empty() {
+                println!("\t\t\tsignatures = [");
+                for sig in &call.signatures {
+                    println!("\t\t\t\tsignature {{");
+                    if !sig.args.is_empty() {
+                        println!("\t\t\t\t\targs = [");
+                        for arg in &sig.args {
+                            println!("\t\t\t\t\t\t{arg}");
+                        }
+                        println!("\t\t\t\t\t]");
+                    }
+                    println!("\t\t\t\t\tret = {}", sig.ret);
+                    println!("\t\t\t\t}}");
+                }
+                println!("\t\t\t]");
+            }
+            println!("\t\t}}");
+        }
+        println!("\t]");
+
+        println!("}}");
+    }
+
+    pub fn validate(&self) -> Result<()> {
+        // Ensure there are no dangling expressions.
+        let reachable = self.reachable();
+        for x in (0..self.exprs.len()).map(ExprId) {
+            if self.exprs[x.index()].is_variable() {
+                continue;
+            }
+            if !reachable.contains(&x) {
+                bail!("expression {x} is unreachable", x = x.index());
+            }
+        }
+
+        Ok(())
+    }
+
+    fn reachable(&self) -> HashSet<ExprId> {
+        let mut reach = HashSet::new();
+
+        let mut stack: Vec<ExprId> = Vec::new();
+        stack.extend(&self.assumptions);
+        stack.extend(&self.assertions);
+
+        while let Some(x) = stack.pop() {
+            if reach.contains(&x) {
+                continue;
+            }
+
+            reach.insert(x);
+            let expr = &self.exprs[x.index()];
+            stack.extend(expr.sources());
+        }
+
+        reach
+    }
+
+    pub fn print_model(&self, model: &Model, prog: &Program) -> Result<()> {
+        // State
+        for (name, value) in &self.state.0 {
+            println!("state: {name} = {}", value.eval(model)?);
+        }
+
+        // Calls
+        for call in &self.calls {
+            // Skip unit enum variant terms, which may occur frequently and are
+            // rarely informative.
+            let term = prog.term(call.term);
+            if term.is_enum_variant() && call.args.is_empty() {
+                continue;
+            }
+
+            println!(
+                "{term_name}({args}) -> {ret}",
+                term_name = prog.term_name(call.term),
+                args = call
+                    .args
+                    .iter()
+                    .map(|a| Ok(a.eval(model)?.to_string()))
+                    .collect::<Result<Vec<_>>>()?
+                    .join(", "),
+                ret = call.ret.eval(model)?
+            );
+        }
+
+        Ok(())
+    }
+
+    pub fn error_at_expr(&self, prog: &Program, x: ExprId, msg: impl Into<String>) -> Error {
+        if let Some(pos) = self.pos.get(&x) {
+            prog.error_at_pos(*pos, msg).into()
+        } else {
+            Error::msg(msg.into())
+        }
+    }
+}
+
+enum TermKind {
+    Constructor,
+    Extractor,
+}
+
+#[derive(Copy, Clone)]
+enum Invocation {
+    Caller,
+    Callee,
+}
+
+#[derive(Copy, Clone)]
+enum Domain {
+    Total,
+    Partial(ExprId),
+}
+
+impl Domain {
+    fn from_return_value(value: &Symbolic) -> (Self, Symbolic) {
+        match value {
+            Symbolic::Option(opt) => (Self::Partial(opt.some), (*opt.inner).clone()),
+            v => (Self::Total, v.clone()),
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct Variables(HashMap<String, Symbolic>);
+
+impl Variables {
+    fn new() -> Self {
+        Self(HashMap::new())
+    }
+
+    fn get(&self, name: &String) -> Option<&Symbolic> {
+        self.0.get(name)
+    }
+
+    fn expect(&self, name: &String) -> Result<&Symbolic> {
+        self.get(name)
+            .ok_or(format_err!("undefined variable {name}"))
+    }
+
+    fn set(&mut self, name: String, value: Symbolic) -> Result<()> {
+        match self.0.entry(name) {
+            Entry::Occupied(e) => {
+                bail!("redefinition of variable {name}", name = e.key());
+            }
+            Entry::Vacant(e) => {
+                e.insert(value);
+                Ok(())
+            }
+        }
+    }
+}
+
+struct ConditionsBuilder<'a> {
+    expansion: &'a Expansion,
+    prog: &'a Program,
+
+    state_modification_conds: HashMap<String, Vec<ExprId>>,
+    binding_value: HashMap<BindingId, Symbolic>,
+    expr_map: HashMap<Expr, ExprId>,
+    conditions: Conditions,
+    position_stack: Vec<Pos>,
+}
+
+impl<'a> ConditionsBuilder<'a> {
+    fn new(expansion: &'a Expansion, prog: &'a Program) -> Self {
+        Self {
+            expansion,
+            prog,
+            state_modification_conds: HashMap::new(),
+            binding_value: HashMap::new(),
+            expr_map: HashMap::new(),
+            conditions: Conditions::default(),
+            position_stack: Vec::new(),
+        }
+    }
+
+    fn build(mut self) -> Result<Conditions> {
+        // State initialization.
+        for state in &self.prog.specenv.state {
+            self.init_state(state)?;
+        }
+
+        // Bindings.
+        for (i, binding) in self.expansion.bindings.iter().enumerate() {
+            if let Some(binding) = binding {
+                self.add_binding(i.try_into().unwrap(), binding)?;
+            }
+        }
+
+        // Callee contract for the term under expansion.
+        self.constructor(
+            self.expansion.result,
+            self.expansion.term,
+            &self.expansion.parameters,
+            Invocation::Callee,
+        )?;
+
+        // Constraints.
+        for constrain in &self.expansion.constraints {
+            let holds = self.constrain(constrain)?;
+            self.conditions.assumptions.push(holds);
+        }
+
+        // Equals.
+        for (a, b) in self.expansion.equalities() {
+            let eq = self.bindings_equal(a, b)?;
+            self.conditions.assumptions.push(eq);
+        }
+
+        // State defaults.
+        for state in &self.prog.specenv.state {
+            self.state_default(state)?;
+        }
+
+        // Validate
+        self.conditions.validate()?;
+
+        Ok(self.conditions)
+    }
+
+    fn init_state(&mut self, state: &State) -> Result<()> {
+        let name = &state.name.0;
+        let value = self.alloc_value(&state.ty, name.clone())?;
+        self.conditions.state.set(name.clone(), value)?;
+        Ok(())
+    }
+
+    fn state_default(&mut self, state: &State) -> anyhow::Result<()> {
+        // Evaluate the default spec expression in a scope that only defines
+        // the state variable itself.
+        let mut vars = Variables::new();
+        let name = &state.name.0;
+        vars.set(name.clone(), self.conditions.state.expect(name)?.clone())?;
+        let mut default = self.spec_expr(&state.default, &vars)?;
+
+        // Other specs may have declared conditions under which they modify the
+        // state. The default only applies when none of them are true.
+        if let Some(conds) = self.state_modification_conds.get(name) {
+            let modified = self.any(conds.clone());
+            let not_modified = self.dedup_expr(Expr::Not(modified));
+            default = self.scalar(Expr::Imp(not_modified, self.as_scalar(default)?));
+        }
+
+        // The expression should define an assumption about the state variable,
+        // so should be a scalar boolean.
+        self.conditions.assumptions.push(self.as_scalar(default)?);
+
+        Ok(())
+    }
+
+    fn add_binding(&mut self, id: BindingId, binding: &Binding) -> Result<()> {
+        // Exit if already added.
+        if self.binding_value.contains_key(&id) {
+            return Ok(());
+        }
+
+        // Allocate a value.
+        let binding_type = self.binding_type(binding);
+        let name = format!("b{}", id.index());
+        let value = self.alloc_binding(&binding_type, name)?;
+        self.binding_value.insert(id, value);
+
+        // Ensure dependencies have been added.
+        for source in binding.sources() {
+            let source_binding = self
+                .expansion
+                .binding(*source)
+                .expect("source binding should be defined");
+            self.add_binding(*source, source_binding)?;
+        }
+
+        // Generate conditions depending on binding type.
+        match binding {
+            Binding::ConstInt { val, ty } => self.const_int(id, *val, *ty),
+
+            Binding::ConstPrim { val } => self.const_prim(id, *val),
+
+            // Argument binding has no associated constraints.
+            Binding::Argument { .. } => Ok(()),
+
+            Binding::Extractor { term, parameter } => self.extractor(id, *term, *parameter),
+
+            Binding::Constructor {
+                term, parameters, ..
+            } => self.constructor(id, *term, parameters, Invocation::Caller),
+
+            Binding::Iterator { .. } => unimplemented!("iterator bindings"),
+
+            Binding::MakeVariant {
+                ty,
+                variant,
+                fields,
+            } => self.make_variant(id, *ty, *variant, fields),
+
+            Binding::MatchVariant {
+                source,
+                variant,
+                field,
+            } => self.match_variant(id, *source, *variant, *field),
+
+            Binding::MakeSome { inner } => self.make_some(id, *inner),
+
+            Binding::MatchSome { source } => self.match_some(id, *source),
+
+            Binding::MatchTuple { source, field } => self.match_tuple(id, *source, *field),
+        }
+    }
+
+    fn const_int(&mut self, id: BindingId, val: i128, ty: TypeId) -> Result<()> {
+        let eq = self.equals_const_int(id, val, ty)?;
+        self.conditions.assumptions.push(eq);
+        Ok(())
+    }
+
+    fn equals_const_int(&mut self, id: BindingId, val: i128, ty: TypeId) -> Result<ExprId> {
+        // Determine modeled type.
+        let ty_name = self.prog.type_name(ty);
+        let ty = self
+            .prog
+            .specenv
+            .type_model
+            .get(&ty)
+            .ok_or(self.error(format!("no model for type {ty_name}")))?
+            .as_primitive()
+            .ok_or(self.error("constant must have basic type"))?;
+
+        // Construct value of the determined type.
+        let value = self.spec_typed_value(val, ty)?.into();
+
+        // Destination binding equals constant value.
+        let eq = self.values_equal(self.binding_value[&id].clone(), value)?;
+        Ok(eq)
+    }
+
+    fn const_prim(&mut self, id: BindingId, val: Sym) -> Result<()> {
+        let eq = self.equals_const_prim(id, val)?;
+        self.conditions.assumptions.push(eq);
+        Ok(())
+    }
+
+    fn equals_const_prim(&mut self, id: BindingId, val: Sym) -> Result<ExprId> {
+        // Lookup value.
+        let spec_value = self
+            .prog
+            .specenv
+            .const_value
+            .get(&val)
+            .ok_or(self.error(format!(
+                "value of constant {const_name} is unspecified",
+                const_name = self.prog.tyenv.syms[val.index()]
+            )))?;
+        let value = self.spec_expr_no_vars(spec_value)?;
+
+        // Destination binding equals constant value.
+        let eq = self.values_equal(self.binding_value[&id].clone(), value)?;
+        Ok(eq)
+    }
+
+    fn extractor(&mut self, id: BindingId, term: TermId, parameter: BindingId) -> Result<()> {
+        // Arguments are the actually the return values of an
+        // extractor, possibly wrapped in an Option<..> type.
+        let (domain, ret) = Domain::from_return_value(&self.binding_value[&id]);
+        let args = ret.elements();
+
+        // Result maps to the parameter of an extractor.
+        let result = self.binding_value[&parameter].clone();
+
+        // Call extractor.
+        self.call(
+            term,
+            TermKind::Extractor,
+            args,
+            result,
+            Invocation::Caller,
+            domain,
+        )
+        .with_context(|| {
+            format!(
+                "expanding extractor '{name}'",
+                name = self.prog.term_name(term)
+            )
+        })
+    }
+
+    fn constructor(
+        &mut self,
+        id: BindingId,
+        term: TermId,
+        parameters: &[BindingId],
+        invocation: Invocation,
+    ) -> Result<()> {
+        // Arguments.
+        let mut args = Vec::new();
+        for parameter_binding_id in parameters {
+            let x = self
+                .binding_value
+                .get(parameter_binding_id)
+                .expect("parameter binding should be defined")
+                .clone();
+            args.push(x);
+        }
+
+        // Return value.
+        let (domain, result) = Domain::from_return_value(&self.binding_value[&id]);
+
+        // Call constructor.
+        self.call(
+            term,
+            TermKind::Constructor,
+            &args,
+            result,
+            invocation,
+            domain,
+        )
+        .with_context(|| {
+            format!(
+                "expanding constructor '{name}'",
+                name = self.prog.term_name(term)
+            )
+        })
+    }
+
+    fn call(
+        &mut self,
+        term: TermId,
+        kind: TermKind,
+        args: &[Symbolic],
+        ret: Symbolic,
+        invocation: Invocation,
+        domain: Domain,
+    ) -> Result<()> {
+        // Lookup spec.
+        let term_name = self.prog.term_name(term);
+        let term_spec = self
+            .prog
+            .specenv
+            .term_spec
+            .get(&term)
+            .ok_or(self.error(format!("no spec for term {term_name}",)))?;
+
+        // We are provided the arguments and return value as they appear
+        // syntactically in the term declaration and specification. However,
+        // whether these are the actual inputs and outputs of the corresponding
+        // function depends on the term kind.
+        if term_spec.args.len() != args.len() {
+            bail!("incorrect number of arguments for term {term_name}");
+        }
+        let arguments: Vec<_> = zip(&term_spec.args, args).collect();
+        let result = (&term_spec.ret, &ret);
+        let (inputs, outputs) = match kind {
+            TermKind::Constructor => (arguments.as_slice(), std::slice::from_ref(&result)),
+            TermKind::Extractor => (std::slice::from_ref(&result), arguments.as_slice()),
+        };
+
+        // Scope for spec expression evaluation. State variables are always available.
+        let mut vars = self.conditions.state.clone();
+
+        // State modification conditions.
+        for modifies in &term_spec.modifies {
+            let cond = if let Some(cond_name) = &modifies.cond {
+                // Allocate new boolean for the modification condition.
+                let cond = self.alloc_variable(
+                    Type::Bool,
+                    format!("{name}_modification_cond", name = modifies.state.0),
+                );
+                // Bring into spec scope.
+                vars.set(cond_name.0.clone(), cond.into())?;
+                cond
+            } else {
+                // TODO(mbm): warn when state is both conditionally and unconditionaly modified.
+                self.boolean(true)
+            };
+
+            // Record condition to determine when the default spec applies.
+            self.state_modification_conds
+                .entry(modifies.state.0.clone())
+                .or_default()
+                .push(cond);
+        }
+
+        // Inputs are available to the requires and matches clauses.
+        for (name, input) in inputs {
+            vars.set(name.0.clone(), (*input).clone())?;
+        }
+
+        // Requires.
+        let mut requires: Vec<ExprId> = Vec::new();
+        for require in &term_spec.requires {
+            let require = self.spec_expr(require, &vars)?;
+            requires.push(self.as_scalar(require)?);
+        }
+
+        // Matches.
+        let mut matches: Vec<ExprId> = Vec::new();
+        for m in &term_spec.matches {
+            let m = self.spec_expr(m, &vars)?;
+            matches.push(self.as_scalar(m)?);
+        }
+
+        // Outputs: only in scope for provides.
+        for (name, output) in outputs {
+            vars.set(name.0.clone(), (*output).clone())?;
+        }
+
+        // Provides.
+        let mut provides: Vec<ExprId> = Vec::new();
+        for provide in &term_spec.provides {
+            let provide = self.spec_expr(provide, &vars)?;
+            provides.push(self.as_scalar(provide)?);
+        }
+
+        // Partial function.
+        // REVIEW(mbm): pin down semantics for partial function specifications.
+        if let Domain::Partial(p) = domain {
+            // Matches describe when the function applies.
+            let all_matches = self.all(matches);
+            let eq = self.exprs_equal(p, all_matches);
+            self.conditions.assumptions.push(eq);
+
+            // Provides are conditioned on the match.
+            let all_provides = self.all(provides);
+            let provide = self.dedup_expr(Expr::Imp(all_matches, all_provides));
+            provides = vec![provide];
+        } else if !matches.is_empty() {
+            bail!("spec matches on non-partial function");
+        }
+
+        // Assert/assume depending on caller or callee.
+        match invocation {
+            Invocation::Caller => {
+                self.conditions.assertions.extend(requires);
+                self.conditions.assumptions.extend(provides);
+            }
+            Invocation::Callee => {
+                self.conditions.assumptions.extend(requires);
+                self.conditions.assertions.extend(provides);
+            }
+        }
+
+        // Record callsite.
+        self.record_term_instantiation(term, args.to_vec(), ret)?;
+
+        Ok(())
+    }
+
+    fn record_term_instantiation(
+        &mut self,
+        term: TermId,
+        args: Vec<Symbolic>,
+        ret: Symbolic,
+    ) -> Result<()> {
+        let signatures = self
+            .prog
+            .specenv
+            .resolve_term_instantiations(&term, &self.prog.tyenv)?;
+        self.conditions.calls.push(Call {
+            term,
+            args,
+            ret,
+            signatures,
+        });
+        Ok(())
+    }
+
+    fn make_variant(
+        &mut self,
+        id: BindingId,
+        ty: TypeId,
+        variant: VariantId,
+        fields: &[BindingId],
+    ) -> Result<()> {
+        // Lookup term corresponding to variant.
+        let variant_term_id = self.prog.get_variant_term(ty, variant);
+
+        // Invoke as a constructor.
+        self.constructor(id, variant_term_id, fields, Invocation::Caller)?;
+
+        Ok(())
+    }
+
+    fn match_variant(
+        &mut self,
+        id: BindingId,
+        source: BindingId,
+        variant: VariantId,
+        field: TupleIndex,
+    ) -> Result<()> {
+        // Source binding should be an enum.
+        let e = self.binding_value[&source]
+            .as_enum()
+            .ok_or(self.error("target of variant constraint should be an enum"))?
+            .clone();
+
+        // Lookup enum type via corresponding constriant,
+        let tys: Vec<_> = self
+            .expansion
+            .constraints
+            .iter()
+            .flat_map(|c| match c {
+                Constrain::Match(id, Constraint::Variant { ty, variant: v, .. })
+                    if *id == source && *v == variant =>
+                {
+                    Some(ty)
+                }
+                _ => None,
+            })
+            .collect();
+        if tys.len() != 1 {
+            bail!("expected exactly one variant constraint for match variant binding");
+        }
+        let ty = tys[0];
+
+        // Lookup variant and field.
+        let variant_type = self.prog.tyenv.get_variant(*ty, variant);
+        let variant_name = self.prog.tyenv.syms[variant_type.name.index()].as_str();
+
+        let field_sym = variant_type.fields[field.index()].name;
+        let field_name = &self.prog.tyenv.syms[field_sym.index()];
+
+        // Destination binding.
+        let v = self.binding_value[&id].clone();
+
+        // Assumption: if the variant matches then the destination binding
+        // equals the projected field.
+        let variant = e.try_variant_by_name(variant_name)?;
+        let field = variant.try_field_by_name(field_name)?;
+
+        let discriminator = self.discriminator(&e, variant);
+        let eq = self.values_equal(v, field.value.clone())?;
+        let constraint = self.dedup_expr(Expr::Imp(discriminator, eq));
+        self.conditions.assumptions.push(constraint);
+
+        Ok(())
+    }
+
+    fn make_some(&mut self, id: BindingId, inner: BindingId) -> Result<()> {
+        // Destination binding should be an option.
+        let opt = self.binding_value[&id]
+            .as_option()
+            .expect("destination of make_some binding should be an option")
+            .clone();
+
+        // Inner binding.
+        let inner = self.binding_value[&inner].clone();
+
+        // Assumption: option is Some.
+        self.conditions.assumptions.push(opt.some);
+
+        // Assumption: option value is equal to this binding.
+        let eq = self.values_equal(inner, (*opt.inner).clone())?;
+        self.conditions.assumptions.push(eq);
+
+        Ok(())
+    }
+
+    fn match_some(&mut self, id: BindingId, source: BindingId) -> Result<()> {
+        // Source should be an option.
+        let opt = self.binding_value[&source]
+            .as_option()
+            .expect("source of match_some binding should be an option")
+            .clone();
+
+        // Destination binding.
+        let v = self.binding_value[&id].clone();
+
+        // Assumption: if the option is some, then the inner value
+        // equals this binding.
+        let eq = self.values_equal(v, (*opt.inner).clone())?;
+        let constraint = self.dedup_expr(Expr::Imp(opt.some, eq));
+        self.conditions.assumptions.push(constraint);
+
+        Ok(())
+    }
+
+    fn match_tuple(&mut self, id: BindingId, source: BindingId, field: TupleIndex) -> Result<()> {
+        // Source should be a tuple. Access its fields.
+        let fields = self.binding_value[&source]
+            .as_tuple()
+            .expect("source of match_tuple binding should be a tuple")
+            .clone();
+
+        // Destination binding.
+        let v = self.binding_value[&id].clone();
+
+        // Assumption: indexed field should equal this binding.
+        let eq = self.values_equal(v, fields[field.index()].clone())?;
+        self.conditions.assumptions.push(eq);
+
+        Ok(())
+    }
+
+    fn constrain(&mut self, constrain: &Constrain) -> Result<ExprId> {
+        match constrain {
+            Constrain::Match(binding_id, constraint) => self.constraint(*binding_id, constraint),
+            Constrain::NotAll(constrains) => {
+                let cs = constrains
+                    .iter()
+                    .map(|c| self.constrain(c))
+                    .collect::<Result<_>>()?;
+                let all = self.all(cs);
+                let not_all = self.dedup_expr(Expr::Not(all));
+                Ok(not_all)
+            }
+        }
+    }
+
+    fn constraint(&mut self, binding_id: BindingId, constraint: &Constraint) -> Result<ExprId> {
+        match constraint {
+            Constraint::Some => self.constraint_some(binding_id),
+            Constraint::ConstPrim { val } => self.equals_const_prim(binding_id, *val),
+            Constraint::ConstInt { val, ty } => self.equals_const_int(binding_id, *val, *ty),
+            Constraint::Variant {
+                ty,
+                variant,
+                fields: _,
+            } => self.constraint_variant(binding_id, *ty, *variant),
+        }
+    }
+
+    fn constraint_some(&mut self, binding_id: BindingId) -> Result<ExprId> {
+        // Constrained binding should be an option.
+        let opt = self.binding_value[&binding_id]
+            .as_option()
+            .expect("target of some constraint should be an option")
+            .clone();
+
+        // Constraint: option is Some.
+        Ok(opt.some)
+    }
+
+    fn constraint_variant(
+        &mut self,
+        binding_id: BindingId,
+        ty: TypeId,
+        variant: VariantId,
+    ) -> Result<ExprId> {
+        // Constrained binding should be an enum.
+        let e = self.binding_value[&binding_id]
+            .as_enum()
+            .ok_or(self.error("target of variant constraint should be an enum"))?
+            .clone();
+
+        // TODO(mbm): check the enum type is correct?
+
+        // Lookup variant.
+        let variant_type = self.prog.tyenv.get_variant(ty, variant);
+        let variant_name = self.prog.tyenv.syms[variant_type.name.index()].as_str();
+
+        // Assumption: discriminant equals variant.
+        let variant = e.try_variant_by_name(variant_name)?;
+        let discriminator = self.discriminator(&e, variant);
+        Ok(discriminator)
+    }
+
+    fn spec_expr(&mut self, expr: &spec::Expr, vars: &Variables) -> Result<Symbolic> {
+        self.position_stack.push(expr.pos);
+        let result = self.spec_expr_kind(&expr.x, vars);
+        self.position_stack.pop();
+        result
+    }
+
+    fn spec_expr_kind(&mut self, expr: &spec::ExprKind, vars: &Variables) -> Result<Symbolic> {
+        macro_rules! unary_expr {
+            ($expr:path, $x:ident) => {{
+                let $x = self.spec_expr($x, vars)?;
+                Ok(self.scalar($expr(self.as_scalar($x)?)))
+            }};
+        }
+
+        macro_rules! binary_expr {
+            ($expr:path, $x:ident, $y:ident) => {{
+                let $x = self.spec_expr($x, vars)?;
+                let $y = self.spec_expr($y, vars)?;
+                Ok(self.scalar($expr(self.as_scalar($x)?, self.as_scalar($y)?)))
+            }};
+        }
+
+        macro_rules! variadic_expr {
+            ($expr:path, $xs:ident) => {{
+                let exprs: Vec<ExprId> = $xs
+                    .iter()
+                    .map(|x| {
+                        let x = self.spec_expr(x, vars)?;
+                        self.as_scalar(x)
+                    })
+                    .collect::<Result<Vec<_>>>()?;
+                Ok(Symbolic::Scalar(
+                    exprs
+                        .into_iter()
+                        .rev()
+                        .reduce(|acc, e| self.dedup_expr($expr(e, acc)))
+                        .ok_or(self.error("empty variadic expression"))?,
+                ))
+            }};
+        }
+
+        match expr {
+            spec::ExprKind::Var(v) => {
+                let v = vars.expect(&v.0)?;
+                Ok(v.clone())
+            }
+
+            spec::ExprKind::Const(c) => Ok(self.constant(c.clone()).into()),
+
+            spec::ExprKind::Constructor(constructor) => self.construct(constructor, vars),
+
+            spec::ExprKind::Field(name, x) => {
+                let x = self.spec_expr(x, vars)?;
+                self.spec_field(name, x)
+            }
+
+            spec::ExprKind::Discriminator(variant, x) => {
+                let x = self.spec_expr(x, vars)?;
+                self.spec_discriminator(variant, x)
+            }
+
+            spec::ExprKind::Not(x) => unary_expr!(Expr::Not, x),
+            spec::ExprKind::And(xs) => variadic_expr!(Expr::And, xs),
+            spec::ExprKind::Or(xs) => variadic_expr!(Expr::Or, xs),
+            spec::ExprKind::Imp(x, y) => binary_expr!(Expr::Imp, x, y),
+
+            spec::ExprKind::Eq(x, y) => {
+                let x = self.spec_expr(x, vars)?;
+                let y = self.spec_expr(y, vars)?;
+                Ok(self.values_equal(x, y)?.into())
+            }
+
+            spec::ExprKind::Lt(x, y) => binary_expr!(Expr::Lt, x, y),
+            spec::ExprKind::Lte(x, y) => binary_expr!(Expr::Lte, x, y),
+            spec::ExprKind::Gt(x, y) => binary_expr!(Expr::Lt, y, x),
+            spec::ExprKind::Gte(x, y) => binary_expr!(Expr::Lte, y, x),
+            spec::ExprKind::BVUlt(x, y) => binary_expr!(Expr::BVUlt, x, y),
+            spec::ExprKind::BVUle(x, y) => binary_expr!(Expr::BVUle, x, y),
+            spec::ExprKind::BVSge(x, y) => binary_expr!(Expr::BVSge, x, y),
+            spec::ExprKind::BVSlt(x, y) => binary_expr!(Expr::BVSlt, x, y),
+            spec::ExprKind::BVSle(x, y) => binary_expr!(Expr::BVSle, x, y),
+            spec::ExprKind::BVSgt(x, y) => binary_expr!(Expr::BVSgt, x, y),
+            spec::ExprKind::BVUgt(x, y) => binary_expr!(Expr::BVUgt, x, y),
+            spec::ExprKind::BVUge(x, y) => binary_expr!(Expr::BVUge, x, y),
+            spec::ExprKind::BVSaddo(x, y) => binary_expr!(Expr::BVSaddo, x, y),
+            spec::ExprKind::BVNot(x) => unary_expr!(Expr::BVNot, x),
+            spec::ExprKind::BVNeg(x) => unary_expr!(Expr::BVNeg, x),
+            spec::ExprKind::Cls(x) => unary_expr!(Expr::Cls, x),
+            spec::ExprKind::Clz(x) => unary_expr!(Expr::Clz, x),
+            spec::ExprKind::Rev(x) => unary_expr!(Expr::Rev, x),
+            spec::ExprKind::Popcnt(x) => unary_expr!(Expr::Popcnt, x),
+            spec::ExprKind::Add(x, y) => binary_expr!(Expr::Add, x, y),
+            spec::ExprKind::Sub(x, y) => binary_expr!(Expr::Sub, x, y),
+            spec::ExprKind::Mul(x, y) => binary_expr!(Expr::Mul, x, y),
+            spec::ExprKind::BVAdd(x, y) => binary_expr!(Expr::BVAdd, x, y),
+            spec::ExprKind::BVSub(x, y) => binary_expr!(Expr::BVSub, x, y),
+            spec::ExprKind::BVMul(x, y) => binary_expr!(Expr::BVMul, x, y),
+            spec::ExprKind::BVSDiv(x, y) => binary_expr!(Expr::BVSDiv, x, y),
+            spec::ExprKind::BVAnd(x, y) => binary_expr!(Expr::BVAnd, x, y),
+            spec::ExprKind::BVOr(x, y) => binary_expr!(Expr::BVOr, x, y),
+            spec::ExprKind::BVXor(x, y) => binary_expr!(Expr::BVXor, x, y),
+            spec::ExprKind::BVShl(x, y) => binary_expr!(Expr::BVShl, x, y),
+            spec::ExprKind::BVLShr(x, y) => binary_expr!(Expr::BVLShr, x, y),
+            spec::ExprKind::BVAShr(x, y) => binary_expr!(Expr::BVAShr, x, y),
+            spec::ExprKind::BVUDiv(x, y) => binary_expr!(Expr::BVUDiv, x, y),
+            spec::ExprKind::BVURem(x, y) => binary_expr!(Expr::BVURem, x, y),
+            spec::ExprKind::BVSRem(x, y) => binary_expr!(Expr::BVSRem, x, y),
+            spec::ExprKind::BVRotl(x, y) => binary_expr!(Expr::BVRotl, x, y),
+            spec::ExprKind::BVRotr(x, y) => binary_expr!(Expr::BVRotr, x, y),
+
+            spec::ExprKind::Conditional(c, t, e) => {
+                let c = self.spec_expr(c, vars)?;
+                let t = self.spec_expr(t, vars)?;
+                let e = self.spec_expr(e, vars)?;
+                self.conditional(self.as_scalar(c)?, t, e)
+            }
+
+            spec::ExprKind::Switch(on, arms) => self.spec_switch(on, arms, vars),
+
+            spec::ExprKind::Match(on, arms) => self.spec_match(on, arms, vars),
+
+            spec::ExprKind::Let(defs, body) => self.spec_let(defs, body, vars),
+
+            spec::ExprKind::With(decls, body) => self.spec_with(decls, body, vars),
+
+            spec::ExprKind::Expand(ident, args) => self.spec_expand(ident, args, vars),
+
+            spec::ExprKind::BVZeroExt(w, x) => binary_expr!(Expr::BVZeroExt, w, x),
+            spec::ExprKind::BVSignExt(w, x) => binary_expr!(Expr::BVSignExt, w, x),
+            spec::ExprKind::BVConvTo(w, x) => binary_expr!(Expr::BVConvTo, w, x),
+
+            spec::ExprKind::BVExtract(h, l, x) => {
+                let x = self.spec_expr(x, vars)?;
+                Ok(self.scalar(Expr::BVExtract(*h, *l, self.as_scalar(x)?)))
+            }
+
+            spec::ExprKind::BVConcat(xs) => variadic_expr!(Expr::BVConcat, xs),
+            spec::ExprKind::BVReplicate(x, n) => {
+                let x = self.spec_expr(x, vars)?;
+                let r = self.replicate(self.as_scalar(x)?, *n)?;
+                Ok(Symbolic::Scalar(r))
+            }
+            spec::ExprKind::Int2BV(w, x) => binary_expr!(Expr::Int2BV, w, x),
+            spec::ExprKind::BV2Nat(x) => unary_expr!(Expr::BV2Nat, x),
+            spec::ExprKind::ToFP(w, x) => binary_expr!(Expr::ToFP, w, x),
+            spec::ExprKind::ToFPUnsigned(w, x) => binary_expr!(Expr::ToFPUnsigned, w, x),
+            spec::ExprKind::ToFPFromFP(w, x) => binary_expr!(Expr::ToFPFromFP, w, x),
+            spec::ExprKind::FPToUBV(w, x) => binary_expr!(Expr::FPToUBV, w, x),
+            spec::ExprKind::FPToSBV(w, x) => binary_expr!(Expr::FPToSBV, w, x),
+            spec::ExprKind::WidthOf(x) => unary_expr!(Expr::WidthOf, x),
+
+            spec::ExprKind::As(x, ty) => {
+                let x = self.spec_expr(x, vars)?;
+                self.conditions.qualifiers.push(Qualifier {
+                    value: x.clone(),
+                    ty: ty.clone(),
+                });
+                Ok(x)
+            }
+
+            spec::ExprKind::FPPositiveInfinity(x) => unary_expr!(Expr::FPPositiveInfinity, x),
+            spec::ExprKind::FPNegativeInfinity(x) => unary_expr!(Expr::FPNegativeInfinity, x),
+            spec::ExprKind::FPPositiveZero(x) => unary_expr!(Expr::FPPositiveZero, x),
+            spec::ExprKind::FPNegativeZero(x) => unary_expr!(Expr::FPNegativeZero, x),
+            spec::ExprKind::FPNaN(x) => unary_expr!(Expr::FPNaN, x),
+            spec::ExprKind::FPEq(x, y) => binary_expr!(Expr::FPEq, x, y),
+            spec::ExprKind::FPNe(x, y) => binary_expr!(Expr::FPNe, x, y),
+            spec::ExprKind::FPLt(x, y) => binary_expr!(Expr::FPLt, x, y),
+            spec::ExprKind::FPGt(x, y) => binary_expr!(Expr::FPGt, x, y),
+            spec::ExprKind::FPLe(x, y) => binary_expr!(Expr::FPLe, x, y),
+            spec::ExprKind::FPGe(x, y) => binary_expr!(Expr::FPGe, x, y),
+            spec::ExprKind::FPAdd(x, y) => binary_expr!(Expr::FPAdd, x, y),
+            spec::ExprKind::FPSub(x, y) => binary_expr!(Expr::FPSub, x, y),
+            spec::ExprKind::FPMul(x, y) => binary_expr!(Expr::FPMul, x, y),
+            spec::ExprKind::FPDiv(x, y) => binary_expr!(Expr::FPDiv, x, y),
+            spec::ExprKind::FPMin(x, y) => binary_expr!(Expr::FPMin, x, y),
+            spec::ExprKind::FPMax(x, y) => binary_expr!(Expr::FPMax, x, y),
+            spec::ExprKind::FPNeg(x) => unary_expr!(Expr::FPNeg, x),
+            spec::ExprKind::FPCeil(x) => unary_expr!(Expr::FPCeil, x),
+            spec::ExprKind::FPFloor(x) => unary_expr!(Expr::FPFloor, x),
+            spec::ExprKind::FPSqrt(x) => unary_expr!(Expr::FPSqrt, x),
+            spec::ExprKind::FPTrunc(x) => unary_expr!(Expr::FPTrunc, x),
+            spec::ExprKind::FPNearest(x) => unary_expr!(Expr::FPNearest, x),
+            spec::ExprKind::FPIsZero(x) => unary_expr!(Expr::FPIsZero, x),
+            spec::ExprKind::FPIsInfinite(x) => unary_expr!(Expr::FPIsInfinite, x),
+            spec::ExprKind::FPIsNaN(x) => unary_expr!(Expr::FPIsNaN, x),
+            spec::ExprKind::FPIsNegative(x) => unary_expr!(Expr::FPIsNegative, x),
+            spec::ExprKind::FPIsPositive(x) => unary_expr!(Expr::FPIsPositive, x),
+
+            spec::ExprKind::Macro(params, body) => Ok(Symbolic::Macro(Macro {
+                params: params.clone(),
+                body: body.clone(),
+            })),
+        }
+    }
+
+    fn spec_expr_no_vars(&mut self, expr: &spec::Expr) -> Result<Symbolic> {
+        let no_vars = Variables::new();
+        self.spec_expr(expr, &no_vars)
+    }
+
+    fn spec_typed_value(&mut self, val: i128, ty: &Type) -> Result<ExprId> {
+        match ty {
+            Type::Bool => Ok(self.boolean(match val {
+                0 => false,
+                1 => true,
+                _ => bail!("boolean value must be zero or one"),
+            })),
+            Type::Int => Ok(self.constant(Const::Int(val))),
+            Type::BitVector(Width::Bits(w)) => {
+                Ok(self.constant(Const::BitVector(*w, val.try_into()?)))
+            }
+            _ => bail!("cannot construct constant of type {ty}"),
+        }
+    }
+
+    fn construct(&mut self, constructor: &Constructor, vars: &Variables) -> Result<Symbolic> {
+        match constructor {
+            Constructor::Enum {
+                name,
+                variant,
+                args,
+            } => {
+                // Lookup ISLE type by name.
+                let type_id = self
+                    .prog
+                    .tyenv
+                    .get_type_by_name(name)
+                    .ok_or(self.error(format!("unknown enum type {name}", name = name.0)))?;
+
+                // Determine type model.
+                let model = self.prog.specenv.type_model.get(&type_id).ok_or(
+                    self.error(format!("unspecified model for type {name}", name = name.0)),
+                )?;
+
+                // Should be an enum.
+                let e = model.as_enum().ok_or(
+                    self.error(format!("{name} expected to have enum type", name = name.0)),
+                )?;
+
+                // Lookup variant.
+                let variant =
+                    e.variants.iter().find(|v| v.name.0 == variant.0).ok_or(
+                        self.error(format!("unknown variant {variant}", variant = variant.0)),
+                    )?;
+
+                // Discriminant: constant value since we are constructing a known variant.
+                let discriminant = self.constant(Const::Int(variant.id.index().try_into()?));
+
+                // Variants: undefined except for the variant under construction.
+                let variants = e
+                    .variants
+                    .iter()
+                    .map(|v| {
+                        // For all except the variant under construction, allocate an undefined variant.
+                        if v.id != variant.id {
+                            // QUESTION(mbm): use undef variant or IfThen and fresh bits in solver?
+                            return self.alloc_variant(v, "undef".to_string());
+                        }
+
+                        // Construct a variant provided arguments.
+                        assert_eq!(args.len(), v.fields.len());
+                        let fields = zip(&v.fields, args)
+                            .map(|(f, a)| {
+                                Ok(SymbolicField {
+                                    name: f.name.0.clone(),
+                                    value: self.spec_expr(a, vars)?,
+                                })
+                            })
+                            .collect::<Result<_>>()?;
+                        Ok(SymbolicVariant {
+                            name: v.name.0.clone(),
+                            id: v.id,
+                            discriminant: v.id.index(),
+                            value: Symbolic::Struct(fields),
+                        })
+                    })
+                    .collect::<Result<_>>()?;
+
+                Ok(self.new_enum(type_id, discriminant, variants)?)
+            }
+            Constructor::Struct { fields } => Ok(Symbolic::Struct(
+                fields
+                    .iter()
+                    .map(|f| {
+                        Ok(SymbolicField {
+                            name: f.name.0.clone(),
+                            value: self.spec_expr(&f.value, vars)?,
+                        })
+                    })
+                    .collect::<Result<_>>()?,
+            )),
+        }
+    }
+
+    fn spec_field(&mut self, name: &Ident, v: Symbolic) -> Result<Symbolic> {
+        log::trace!("access field {} from {}", name.0, v);
+
+        // 1. If ExtEnum: check extra fields FIRST
+        if let Symbolic::ExtEnum(_base_enum, extra_fields) = &v {
+            if let Some(f) = extra_fields.iter().find(|f| f.name == name.0) {
+                return Ok(f.value.clone());
+            }
+
+            // 2. If not found, fall through to base enum variant payload
+            if let Some(e) = v.as_enum() {
+                for variant in &e.variants {
+                    if let Ok(fields) = variant.fields() {
+                        if let Some(f) = fields.iter().find(|f| f.name == name.0) {
+                            return Ok(f.value.clone());
+                        }
+                    }
+                }
+            }
+
+            // 3. Otherwise: truly nonexistent
+            return Err(self.error(format!(
+                "attempt to access nonexistent field: {}",
+                name.0
+            )));
+        }
+
+        // Normal struct case
+        if let Some(fields) = v.as_struct() {
+            if let Some(f) = fields.iter().find(|f| f.name == name.0) {
+                return Ok(f.value.clone());
+            } else {
+                return Err(self.error(format!(
+                    "attempt to access nonexistent struct field: {}",
+                    name.0
+                )));
+            }
+        }
+
+        Err(self.error(format!(
+            "field access from non-struct value: {}",
+            name.0
+        )))
+    }
+
+
+    fn spec_discriminator(&mut self, name: &Ident, v: Symbolic) -> Result<Symbolic> {
+        let e = v
+            .as_enum()
+            .ok_or(self.error("discriminator for non-enum value"))?;
+        let variant = e.try_variant_by_name(&name.0)?;
+        let discriminator = self.discriminator(e, variant);
+        Ok(discriminator.into())
+    }
+
+    fn discriminator(&mut self, e: &SymbolicEnum, variant: &SymbolicVariant) -> ExprId {
+        let discriminant = self.constant(Const::Int(variant.discriminant.try_into().unwrap()));
+        self.exprs_equal(e.discriminant, discriminant)
+    }
+
+    fn spec_switch(
+        &mut self,
+        on: &spec::Expr,
+        arms: &[(spec::Expr, spec::Expr)],
+        vars: &Variables,
+    ) -> Result<Symbolic> {
+        // Generate branch arms.
+        let on = self.spec_expr(on, vars)?;
+        let cases = arms
+            .iter()
+            .map(|(value, then)| {
+                let value = self.spec_expr(value, vars)?;
+                let cond = self.values_equal(on.clone(), value)?;
+                Ok((cond, self.spec_expr(then, vars)?))
+            })
+            .collect::<Result<Vec<_>>>()?;
+
+        // Build an expression splitting over cases.
+        self.cases(&cases)
+    }
+
+    fn spec_match(&mut self, on: &spec::Expr, arms: &[Arm], vars: &Variables) -> Result<Symbolic> {
+        // Generate the enum value to match on.
+        let on = self.spec_expr(on, vars)?;
+        let e = on.as_enum().ok_or(self.error("match on non-enum value"))?;
+
+        // Generate cases.
+        let mut cases = Vec::new();
+        for arm in arms {
+            // Lookup the variant.
+            let variant = e.try_variant_by_name(&arm.variant.0)?;
+
+            // Arm condition is that the discriminant matches the variant.
+            let cond = self.discriminator(e, variant);
+
+            // Arm value is the result of the body expression, evaluated with
+            // the variants fields brought into scope.
+            let Some(fields) = variant.value.as_struct() else {
+                bail!("variant {name} must have struct value", name = variant.name);
+            };
+            if arm.args.len() != fields.len() {
+                bail!(
+                    "incorrect number of arguments for variant {name}",
+                    name = variant.name
+                );
+            }
+            let mut arm_vars = vars.clone();
+            for (arg, field) in zip(&arm.args, fields) {
+                arm_vars.set(arg.0.clone(), field.value.clone())?;
+            }
+            let body = self.spec_expr(&arm.body, &arm_vars)?;
+
+            // Add case for this match arm.
+            cases.push((cond, body));
+        }
+
+        // Build an expression splitting over cases.
+        self.cases(&cases)
+    }
+
+    fn cases(&mut self, cases: &[(ExprId, Symbolic)]) -> Result<Symbolic> {
+        // Build an undefined fallback value.
+        let Some((_, value)) = cases.last() else {
+            bail!("must have at least one case");
+        };
+        let fallback = value.scalar_map(&mut |_| self.undef_variable());
+
+        // Represent as nested conditionals.
+        cases
+            .iter()
+            .rev()
+            .cloned()
+            .try_fold(fallback, |acc, (cond, then)| {
+                self.conditional(cond, then, acc)
+            })
+    }
+
+    fn spec_let(
+        &mut self,
+        defs: &[(Ident, spec::Expr)],
+        body: &spec::Expr,
+        vars: &Variables,
+    ) -> Result<Symbolic> {
+        // Evaluate let defs.
+        let mut let_vars = vars.clone();
+        for (name, expr) in defs {
+            let expr = self.spec_expr(expr, &let_vars)?;
+            let_vars.set(name.0.clone(), expr)?;
+        }
+
+        // Evaluate body in let-binding scope.
+        self.spec_expr(body, &let_vars)
+    }
+
+    fn spec_with(
+        &mut self,
+        decls: &[Ident],
+        body: &spec::Expr,
+        vars: &Variables,
+    ) -> Result<Symbolic> {
+        // Declare new variables.
+        let mut with_vars = vars.clone();
+        for name in decls {
+            // QUESTION(mbm): allow with scopes to optionally specify types?
+            let expr = Symbolic::Scalar(self.alloc_variable(Type::Unknown, name.0.clone()));
+            with_vars.set(name.0.clone(), expr)?;
+        }
+
+        // Evaluate body in new scope.
+        self.spec_expr(body, &with_vars)
+    }
+
+    fn spec_expand(
+        &mut self,
+        name: &Ident,
+        args: &[spec::Expr],
+        vars: &Variables,
+    ) -> Result<Symbolic> {
+        // Lookup macro.
+        //
+        // Could be an inline macro in a local variable, or a macro defined at global scope.
+        let (params, body) = if let Some(v) = vars.get(&name.0) {
+            let Symbolic::Macro(m) = v else {
+                bail!("variable {name} is not a macro", name = name.0);
+            };
+            (&m.params, &m.body)
+        } else {
+            let defn = self
+                .prog
+                .specenv
+                .macros
+                .get(&name.0)
+                .ok_or(self.error(format!("unknown macro {name}", name = name.0)))?;
+            (&defn.params, &defn.body)
+        };
+
+        // Build macro expansion scope.
+        // QUESTION(mbm): should macros be able to access global state?
+        let mut macro_vars = Variables::new();
+        if params.len() != args.len() {
+            bail!(
+                "incorrect number of arguments for macro {name}",
+                name = name.0
+            );
+        }
+        for (param, arg) in zip(params, args) {
+            let arg = self.spec_expr(arg, vars)?;
+            macro_vars.set(param.0.clone(), arg)?;
+        }
+
+        // Evaluate macro body.
+        self.spec_expr(&body, &macro_vars)
+    }
+
+    fn replicate(&mut self, x: ExprId, n: usize) -> Result<ExprId> {
+        match n {
+            0 => bail!("cannot replicate zero times"),
+            1 => Ok(x),
+            _ => {
+                let h = n / 2;
+                let l = self.replicate(x, h)?;
+                let r = self.replicate(x, n - h)?;
+                Ok(self.dedup_expr(Expr::BVConcat(l, r)))
+            }
+        }
+    }
+
+    fn conditional(&mut self, c: ExprId, t: Symbolic, e: Symbolic) -> Result<Symbolic> {
+        Symbolic::merge(&t, &e, &mut |t, e| {
+            self.dedup_expr(Expr::Conditional(c, t, e))
+        })
+    }
+
+    fn bindings_equal(&mut self, a: BindingId, b: BindingId) -> Result<ExprId> {
+        // TODO(mbm): can this be done without clones?
+        let a = self.binding_value[&a].clone();
+        let b = self.binding_value[&b].clone();
+        self.values_equal(a, b)
+    }
+
+    fn values_equal(&mut self, a: Symbolic, b: Symbolic) -> Result<ExprId> {
+        if std::mem::discriminant(&a) != std::mem::discriminant(&b) {
+            return Err(self.error("equality on different symbolic types"));
+        }
+        match (a, b) {
+            (Symbolic::Scalar(u), Symbolic::Scalar(v)) => Ok(self.exprs_equal(u, v)),
+
+            (Symbolic::Struct(us), Symbolic::Struct(vs)) => {
+                // Field-wise equality.
+                // TODO(mbm): can we expect that structs are the same length?
+                assert_eq!(us.len(), vs.len(), "field length mismatch");
+                let fields_eq = zip(us, vs)
+                    .map(|(fu, fv)| {
+                        assert_eq!(fu.name, fv.name, "field name mismatch");
+                        self.values_equal(fu.value, fv.value)
+                    })
+                    .collect::<Result<_>>()?;
+
+                // All fields must be equal.
+                Ok(self.all(fields_eq))
+            }
+
+            (Symbolic::Enum(u), Symbolic::Enum(v)) => {
+                // Discriminant equality.
+                let discriminants_eq = self.exprs_equal(u.discriminant, v.discriminant);
+                let mut equalities = vec![discriminants_eq];
+
+                // Variant equality conditions.
+                assert_eq!(u.variants.len(), v.variants.len(), "variant count mismatch");
+                let variants_eq = zip(&u.variants, &v.variants)
+                    .map(|(uv, vv)| {
+                        assert_eq!(uv.name, vv.name, "variant name mismatch");
+                        let ud = self.discriminator(&u, uv);
+                        let eq = self.values_equal(uv.value.clone(), vv.value.clone())?;
+                        Ok(self.dedup_expr(Expr::Imp(ud, eq)))
+                    })
+                    .collect::<Result<Vec<_>>>()?;
+                equalities.extend(variants_eq);
+
+                // Combine discriminant and variant conditions.
+                Ok(self.all(equalities))
+            }
+
+            (Symbolic::Enum(u), Symbolic::ExtEnum(v, _extra))
+            | (Symbolic::ExtEnum(v, _extra), Symbolic::Enum(u)) => {
+                // Discriminant equality
+                let discriminants_eq = self.exprs_equal(u.discriminant, v.discriminant);
+                let mut equalities = vec![discriminants_eq];
+
+                // Compare only the base variant payloads
+                assert_eq!(u.variants.len(), v.variants.len());
+                let variants_eq = zip(&u.variants, &v.variants)
+                    .map(|(uv, vv)| {
+                        assert_eq!(uv.name, vv.name);
+                        let ud = self.discriminator(&u, uv);
+                        let eq = self.values_equal(uv.value.clone(), vv.value.clone())?;
+                        Ok(self.dedup_expr(Expr::Imp(ud, eq)))
+                    })
+                    .collect::<Result<Vec<_>>>()?;
+
+                equalities.extend(variants_eq);
+                Ok(self.all(equalities))
+            }
+
+
+            (Symbolic::Tuple(us), Symbolic::Tuple(vs)) => {
+                // Field-wise equality.
+                // TODO(mbm): can we expect that tuples are the same length?
+                assert_eq!(us.len(), vs.len(), "tuple length mismatch");
+                let fields_eq = zip(us, vs)
+                    .map(|(u, v)| self.values_equal(u, v))
+                    .collect::<Result<_>>()?;
+
+                // All fields must be equal.
+                Ok(self.all(fields_eq))
+            }
+
+            ref c => todo!("values equal: {c:?}"),
+        }
+    }
+
+    fn exprs_equal(&mut self, lhs: ExprId, rhs: ExprId) -> ExprId {
+        self.dedup_expr(Expr::Eq(lhs, rhs))
+    }
+
+    fn all(&mut self, exprs: Vec<ExprId>) -> ExprId {
+        exprs
+            .into_iter()
+            .reduce(|acc, e| self.dedup_expr(Expr::And(acc, e)))
+            .unwrap_or_else(|| self.boolean(true))
+    }
+
+    fn any(&mut self, exprs: Vec<ExprId>) -> ExprId {
+        exprs
+            .into_iter()
+            .reduce(|acc, e| self.dedup_expr(Expr::Or(acc, e)))
+            .unwrap_or_else(|| self.boolean(false))
+    }
+
+    fn boolean(&mut self, value: bool) -> ExprId {
+        self.constant(Const::Bool(value))
+    }
+
+    fn constant(&mut self, c: Const) -> ExprId {
+        self.dedup_expr(Expr::Const(c))
+    }
+
+    /// Determine the type of the given binding in the context of the
+    /// [Expansion] we are constructing verification conditions for.
+    fn binding_type(&self, binding: &Binding) -> BindingType {
+        binding_type(
+            binding,
+            self.expansion.term,
+            self.prog,
+            |binding_id: BindingId| self.expansion.bindings[binding_id.index()].clone().unwrap(),
+        )
+    }
+
+    fn alloc_binding(&mut self, binding_type: &BindingType, name: String) -> Result<Symbolic> {
+        match binding_type {
+            BindingType::Base(type_id) => self.alloc_model(*type_id, name),
+            BindingType::Option(inner_type) => {
+                let some = self.alloc_variable(Type::Bool, Variable::component_name(&name, "some"));
+                let inner = Box::new(
+                    self.alloc_binding(inner_type, Variable::component_name(&name, "inner"))?,
+                );
+                Ok(Symbolic::Option(SymbolicOption { some, inner }))
+            }
+            BindingType::Tuple(inners) => {
+                let inners = inners
+                    .iter()
+                    .enumerate()
+                    .map(|(i, inner_type)| {
+                        self.alloc_binding(
+                            inner_type,
+                            Variable::component_name(&name, &i.to_string()),
+                        )
+                    })
+                    .collect::<Result<_>>()?;
+                Ok(Symbolic::Tuple(inners))
+            }
+        }
+    }
+
+    fn alloc_value(&mut self, ty: &Compound, name: String) -> Result<Symbolic> {
+        match ty {
+            Compound::Primitive(ty) => Ok(Symbolic::Scalar(self.alloc_variable(ty.clone(), name))),
+            Compound::Struct(fields) => Ok(Symbolic::Struct(
+                fields
+                    .iter()
+                    .map(|f| {
+                        Ok(SymbolicField {
+                            name: f.name.0.clone(),
+                            value: self
+                                .alloc_value(&f.ty, Variable::component_name(&name, &f.name.0))?,
+                        })
+                    })
+                    .collect::<Result<_>>()?,
+            )),
+            Compound::Enum(e) => {
+                let discriminant =
+                    self.alloc_variable(Type::Int, Variable::component_name(&name, "discriminant"));
+                let variants = e
+                    .variants
+                    .iter()
+                    .map(|v| self.alloc_variant(v, name.clone()))
+                    .collect::<Result<_>>()?;
+                Ok(self.new_enum(e.id, discriminant, variants)?)
+            }
+            Compound::ExtEnum { base, extra } => {
+                // Build the SymbolicEnum exactly like the `Enum` arm does.
+
+                // 1) discriminator variable for the enum
+                let discriminant = self.alloc_variable(
+                    Type::Int,
+                    Variable::component_name(&name, "discriminant"),
+                );
+
+                // 2) per-variant payloads
+                let variants = base
+                    .variants
+                    .iter()
+                    .map(|v| self.alloc_variant(v, name.clone()))
+                    .collect::<Result<_>>()?;
+
+                // 3) assemble a SymbolicEnum (same fields your `Enum` arm uses)
+                let sym_enum = SymbolicEnum {
+                    ty: base.id,
+                    discriminant,
+                    variants,
+                };
+
+                // Now allocate the extra struct-like fields.
+                let extra_syms = extra
+                    .iter()
+                    .map(|f| {
+                        Ok(SymbolicField {
+                            name: f.name.0.clone(),
+                            value: self.alloc_value(
+                                &f.ty,
+                                Variable::component_name(&name, &f.name.0),
+                            )?,
+                        })
+                    })
+                    .collect::<Result<Vec<_>>>()?;
+
+                // `Symbolic::ExtEnum` is a *tuple* variant: (SymbolicEnum, Vec<SymbolicField>)
+                Ok(Symbolic::ExtEnum(sym_enum, extra_syms))
+            }
+
+
+            Compound::Named(_) => {
+                let ty = self.prog.specenv.resolve_type(ty, &self.prog.tyenv)?;
+                self.alloc_value(&ty, name)
+            }
+        }
+    }
+
+    fn new_enum(
+        &mut self,
+        ty: TypeId,
+        discriminant: ExprId,
+        variants: Vec<SymbolicVariant>,
+    ) -> Result<Symbolic> {
+        // Construct symbolic enum and ensure it's valid.
+        let e = SymbolicEnum {
+            ty,
+            discriminant,
+            variants,
+        };
+        e.validate()?;
+
+        // Assume discriminant invariant: positive integer less than number of
+        // variants.
+        let zero = self.constant(Const::Int(0));
+        let num_variants = self.constant(Const::Int(e.variants.len().try_into()?));
+        let discriminant_positive = self.dedup_expr(Expr::Lte(zero, discriminant));
+        let discriminant_less_than_num_variants =
+            self.dedup_expr(Expr::Lt(discriminant, num_variants));
+        let discriminant_in_range = self.dedup_expr(Expr::And(
+            discriminant_positive,
+            discriminant_less_than_num_variants,
+        ));
+        self.conditions.assumptions.push(discriminant_in_range);
+
+        // Variant term instantiations.
+        let ret = Symbolic::Enum(e.clone());
+        for variant in &e.variants {
+            let term = self.prog.get_variant_term(e.ty, variant.id);
+            let args = variant.field_values()?;
+            self.record_term_instantiation(term, args, ret.clone())?;
+        }
+
+        Ok(ret)
+    }
+
+    fn alloc_variant(&mut self, variant: &Variant, name: String) -> Result<SymbolicVariant> {
+        let name = Variable::component_name(&name, &variant.name.0);
+        Ok(SymbolicVariant {
+            name: variant.name.0.clone(),
+            id: variant.id,
+            discriminant: variant.id.index(),
+            value: self.alloc_value(&variant.ty(), name)?,
+        })
+    }
+
+    fn alloc_model(&mut self, type_id: TypeId, name: String) -> Result<Symbolic> {
+        let type_name = self.prog.type_name(type_id);
+        let ty = self
+            .prog
+            .specenv
+            .type_model
+            .get(&type_id)
+            .ok_or(self.error(format!("unspecified model for type {type_name}")))?;
+        self.alloc_value(ty, name)
+    }
+
+    fn undef_variable(&mut self) -> ExprId {
+        self.alloc_variable(Type::Unknown, "undef".to_string())
+    }
+
+    fn alloc_variable(&mut self, ty: Type, name: String) -> ExprId {
+        let v = VariableId(self.conditions.variables.len());
+        self.conditions.variables.push(Variable { ty, name });
+        self.dedup_expr(Expr::Variable(v))
+    }
+
+    fn scalar(&mut self, expr: Expr) -> Symbolic {
+        Symbolic::Scalar(self.dedup_expr(expr))
+    }
+
+    fn as_scalar(&self, v: Symbolic) -> Result<ExprId> {
+        v.as_scalar().ok_or(self.error("expected scalar value"))
+    }
+
+    fn dedup_expr(&mut self, expr: Expr) -> ExprId {
+        // Dedupe, if pure.
+        let maybe_id = if expr.pure() {
+            self.expr_map.get(&expr)
+        } else {
+            None
+        };
+
+        // Otherwise, allocate new one.
+        let id = if let Some(id) = maybe_id {
+            *id
+        } else {
+            let id = ExprId(self.conditions.exprs.len());
+            self.conditions.exprs.push(expr.clone());
+            self.expr_map.insert(expr, id);
+            id
+        };
+
+        if let Some(pos) = self.position_stack.last() {
+            self.conditions.pos.insert(id, *pos);
+        }
+
+        id
+    }
+
+    fn error(&self, msg: impl Into<String>) -> Error {
+        if let Some(pos) = self.position_stack.last() {
+            self.prog.error_at_pos(*pos, msg).into()
+        } else {
+            Error::msg(msg.into())
+        }
+    }
+}
diff --git a/cranelift/isle/veri/veri/tests/filetests.rs b/cranelift/isle/veri/veri/tests/filetests.rs
new file mode 100644
index 000000000000..91bf9973df08
--- /dev/null
+++ b/cranelift/isle/veri/veri/tests/filetests.rs
@@ -0,0 +1,27 @@
+use std::path::PathBuf;
+
+use cranelift_isle_veri::runner::Runner;
+use cranelift_isle_veri_test_macros::file_tests;
+use tempfile::tempdir;
+
+#[file_tests(path = "filetests/pass", ext = "isle")]
+fn pass(test_file: &str) {
+    let inputs = vec![PathBuf::from(test_file)];
+    let mut runner = Runner::from_files(&inputs, "test").expect("should be able to create runner");
+    let temp_dir = tempdir().expect("should be able to create temporary log directory");
+    runner.set_log_dir(temp_dir.path().join("log"));
+    runner.include_first_rule_named();
+    runner.set_root_term("test");
+    runner.run().expect("verification should pass");
+}
+
+#[file_tests(path = "filetests/broken", ext = "isle")]
+fn broken(test_file: &str) {
+    let inputs = vec![PathBuf::from(test_file)];
+    let mut runner = Runner::from_files(&inputs, "test").expect("should be able to create runner");
+    let temp_dir = tempdir().expect("should be able to create temporary log directory");
+    runner.set_log_dir(temp_dir.path().join("log"));
+    runner.include_first_rule_named();
+    runner.set_root_term("test");
+    runner.run().expect_err("verification should fail");
+}
diff --git a/cranelift/jit/Cargo.toml b/cranelift/jit/Cargo.toml
index 0d367c7a32cd..28ea982991cc 100644
--- a/cranelift/jit/Cargo.toml
+++ b/cranelift/jit/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "cranelift-jit"
-version = "0.101.0"
+version = "0.112.0"
 authors = ["The Cranelift Project Developers"]
 description = "A JIT library backed by Cranelift"
 repository = "https://github.com/bytecodealliance/wasmtime"
@@ -8,6 +8,10 @@ documentation = "https://docs.rs/cranelift-jit"
 license = "Apache-2.0 WITH LLVM-exception"
 readme = "README.md"
 edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
 
 [dependencies]
 cranelift-module = { workspace = true }
@@ -17,7 +21,7 @@ cranelift-entity = { workspace = true }
 cranelift-control = { workspace = true }
 anyhow = { workspace = true }
 region = "2.2.0"
-libc = { version = "0.2.42" }
+libc = { workspace = true }
 target-lexicon = { workspace = true }
 memmap2 = { version = "0.2.1", optional = true }
 log = { workspace = true }
@@ -36,6 +40,6 @@ selinux-fix = ['memmap2']
 default = []
 
 [dev-dependencies]
-cranelift = { workspace = true }
+cranelift = { path = "../umbrella" }
 cranelift-frontend = { workspace = true }
 cranelift-entity = { workspace = true }
diff --git a/cranelift/jit/examples/jit-minimal.rs b/cranelift/jit/examples/jit-minimal.rs
index 3ebf7536f9c3..f806929bc153 100644
--- a/cranelift/jit/examples/jit-minimal.rs
+++ b/cranelift/jit/examples/jit-minimal.rs
@@ -1,6 +1,5 @@
 use codegen::ir::UserFuncName;
 use cranelift::prelude::*;
-use cranelift_codegen::settings::{self, Configurable};
 use cranelift_jit::{JITBuilder, JITModule};
 use cranelift_module::{default_libcall_names, Linkage, Module};
 use std::mem;
@@ -11,7 +10,7 @@ fn main() {
     // FIXME set back to true once the x64 backend supports it.
     flag_builder.set("is_pic", "false").unwrap();
     let isa_builder = cranelift_native::builder().unwrap_or_else(|msg| {
-        panic!("host machine is not supported: {}", msg);
+        panic!("host machine is not supported: {msg}");
     });
     let isa = isa_builder
         .finish(settings::Flags::new(flag_builder))
@@ -68,7 +67,7 @@ fn main() {
         let value = {
             let results = bcx.inst_results(call);
             assert_eq!(results.len(), 1);
-            results[0].clone()
+            results[0]
         };
         bcx.ins().return_(&[value]);
         bcx.seal_all_blocks();
diff --git a/cranelift/jit/src/backend.rs b/cranelift/jit/src/backend.rs
index 438c60d49e27..8f95a30b5a7a 100644
--- a/cranelift/jit/src/backend.rs
+++ b/cranelift/jit/src/backend.rs
@@ -4,7 +4,7 @@ use crate::{compiled_blob::CompiledBlob, memory::BranchProtection, memory::Memor
 use cranelift_codegen::binemit::Reloc;
 use cranelift_codegen::isa::{OwnedTargetIsa, TargetIsa};
 use cranelift_codegen::settings::Configurable;
-use cranelift_codegen::{self, ir, settings, FinalizedMachReloc};
+use cranelift_codegen::{ir, settings, FinalizedMachReloc};
 use cranelift_control::ControlPlane;
 use cranelift_entity::SecondaryMap;
 use cranelift_module::{
@@ -14,7 +14,6 @@ use cranelift_module::{
 use log::info;
 use std::cell::RefCell;
 use std::collections::HashMap;
-use std::convert::{TryFrom, TryInto};
 use std::ffi::CString;
 use std::io::Write;
 use std::ptr;
@@ -28,8 +27,8 @@ const READONLY_DATA_ALIGNMENT: u64 = 0x1;
 /// A builder for `JITModule`.
 pub struct JITBuilder {
     isa: OwnedTargetIsa,
-    symbols: HashMap<String, *const u8>,
-    lookup_symbols: Vec<Box<dyn Fn(&str) -> Option<*const u8>>>,
+    symbols: HashMap<String, SendWrapper<*const u8>>,
+    lookup_symbols: Vec<Box<dyn Fn(&str) -> Option<*const u8> + Send>>,
     libcall_names: Box<dyn Fn(ir::LibCall) -> String + Send + Sync>,
     hotswap_enabled: bool,
 }
@@ -68,7 +67,7 @@ impl JITBuilder {
         flag_builder.set("use_colocated_libcalls", "false").unwrap();
         flag_builder.set("is_pic", "true").unwrap();
         let isa_builder = cranelift_native::builder().unwrap_or_else(|msg| {
-            panic!("host machine is not supported: {}", msg);
+            panic!("host machine is not supported: {msg}");
         });
         let isa = isa_builder.finish(settings::Flags::new(flag_builder))?;
         Ok(Self::with_isa(isa, libcall_names))
@@ -117,7 +116,7 @@ impl JITBuilder {
     where
         K: Into<String>,
     {
-        self.symbols.insert(name.into(), ptr);
+        self.symbols.insert(name.into(), SendWrapper(ptr));
         self
     }
 
@@ -130,7 +129,7 @@ impl JITBuilder {
         K: Into<String>,
     {
         for (name, ptr) in symbols {
-            self.symbols.insert(name.into(), ptr);
+            self.symbols.insert(name.into(), SendWrapper(ptr));
         }
         self
     }
@@ -141,7 +140,7 @@ impl JITBuilder {
     /// symbol table. Symbol lookup fn's are called in reverse of the order in which they were added.
     pub fn symbol_lookup_fn(
         &mut self,
-        symbol_lookup_fn: Box<dyn Fn(&str) -> Option<*const u8>>,
+        symbol_lookup_fn: Box<dyn Fn(&str) -> Option<*const u8> + Send>,
     ) -> &mut Self {
         self.lookup_symbols.push(symbol_lookup_fn);
         self
@@ -166,6 +165,15 @@ struct GotUpdate {
     ptr: *const u8,
 }
 
+unsafe impl Send for GotUpdate {}
+
+/// A wrapper that impls Send for the contents.
+///
+/// SAFETY: This must not be used for any types where it would be UB for them to be Send
+#[derive(Copy, Clone)]
+struct SendWrapper<T>(T);
+unsafe impl<T> Send for SendWrapper<T> {}
+
 /// A `JITModule` implements `Module` and emits code and data into memory where it can be
 /// directly called and accessed.
 ///
@@ -173,16 +181,16 @@ struct GotUpdate {
 pub struct JITModule {
     isa: OwnedTargetIsa,
     hotswap_enabled: bool,
-    symbols: RefCell<HashMap<String, *const u8>>,
-    lookup_symbols: Vec<Box<dyn Fn(&str) -> Option<*const u8>>>,
-    libcall_names: Box<dyn Fn(ir::LibCall) -> String>,
+    symbols: RefCell<HashMap<String, SendWrapper<*const u8>>>,
+    lookup_symbols: Vec<Box<dyn Fn(&str) -> Option<*const u8> + Send>>,
+    libcall_names: Box<dyn Fn(ir::LibCall) -> String + Send + Sync>,
     memory: MemoryHandle,
     declarations: ModuleDeclarations,
-    function_got_entries: SecondaryMap<FuncId, Option<NonNull<AtomicPtr<u8>>>>,
-    function_plt_entries: SecondaryMap<FuncId, Option<NonNull<[u8; 16]>>>,
-    data_object_got_entries: SecondaryMap<DataId, Option<NonNull<AtomicPtr<u8>>>>,
-    libcall_got_entries: HashMap<ir::LibCall, NonNull<AtomicPtr<u8>>>,
-    libcall_plt_entries: HashMap<ir::LibCall, NonNull<[u8; 16]>>,
+    function_got_entries: SecondaryMap<FuncId, Option<SendWrapper<NonNull<AtomicPtr<u8>>>>>,
+    function_plt_entries: SecondaryMap<FuncId, Option<SendWrapper<NonNull<[u8; 16]>>>>,
+    data_object_got_entries: SecondaryMap<DataId, Option<SendWrapper<NonNull<AtomicPtr<u8>>>>>,
+    libcall_got_entries: HashMap<ir::LibCall, SendWrapper<NonNull<AtomicPtr<u8>>>>,
+    libcall_plt_entries: HashMap<ir::LibCall, SendWrapper<NonNull<[u8; 16]>>>,
     compiled_functions: SecondaryMap<FuncId, Option<CompiledBlob>>,
     compiled_data_objects: SecondaryMap<DataId, Option<CompiledBlob>>,
     functions_to_finalize: Vec<FuncId>,
@@ -204,7 +212,7 @@ impl JITModule {
     ///
     /// # Safety
     ///
-    /// Because this function invalidates any pointers retrived from the
+    /// Because this function invalidates any pointers retrieved from the
     /// corresponding module, it should only be used when none of the functions
     /// from that module are currently executing and none of the `fn` pointers
     /// are called afterwards.
@@ -216,7 +224,7 @@ impl JITModule {
 
     fn lookup_symbol(&self, name: &str) -> Option<*const u8> {
         match self.symbols.borrow_mut().entry(name.to_owned()) {
-            std::collections::hash_map::Entry::Occupied(occ) => Some(*occ.get()),
+            std::collections::hash_map::Entry::Occupied(occ) => Some(occ.get().0),
             std::collections::hash_map::Entry::Vacant(vac) => {
                 let ptr = self
                     .lookup_symbols
@@ -224,7 +232,7 @@ impl JITModule {
                     .rev() // Try last lookup function first
                     .find_map(|lookup| lookup(name));
                 if let Some(ptr) = ptr {
-                    vac.insert(ptr);
+                    vac.insert(SendWrapper(ptr));
                 }
                 ptr
             }
@@ -267,7 +275,7 @@ impl JITModule {
 
     fn new_func_plt_entry(&mut self, id: FuncId, val: *const u8) {
         let got_entry = self.new_got_entry(val);
-        self.function_got_entries[id] = Some(got_entry);
+        self.function_got_entries[id] = Some(SendWrapper(got_entry));
         let plt_entry = self.new_plt_entry(got_entry);
         self.record_function_for_perf(
             plt_entry.as_ptr().cast(),
@@ -277,12 +285,12 @@ impl JITModule {
                 self.declarations.get_function_decl(id).linkage_name(id)
             ),
         );
-        self.function_plt_entries[id] = Some(plt_entry);
+        self.function_plt_entries[id] = Some(SendWrapper(plt_entry));
     }
 
     fn new_data_got_entry(&mut self, id: DataId, val: *const u8) {
         let got_entry = self.new_got_entry(val);
-        self.data_object_got_entries[id] = Some(got_entry);
+        self.data_object_got_entries[id] = Some(SendWrapper(got_entry));
     }
 
     unsafe fn write_plt_entry_bytes(plt_ptr: *mut [u8; 16], got_ptr: NonNull<AtomicPtr<u8>>) {
@@ -334,13 +342,13 @@ impl JITModule {
                 } else if linkage == Linkage::Preemptible {
                     0 as *const u8
                 } else {
-                    panic!("can't resolve symbol {}", name);
+                    panic!("can't resolve symbol {name}");
                 }
             }
             ModuleRelocTarget::LibCall(ref libcall) => {
                 let sym = (self.libcall_names)(*libcall);
                 self.lookup_symbol(&sym)
-                    .unwrap_or_else(|| panic!("can't resolve libcall {}", sym))
+                    .unwrap_or_else(|| panic!("can't resolve libcall {sym}"))
             }
             _ => panic!("invalid name"),
         }
@@ -351,7 +359,7 @@ impl JITModule {
     /// Panics if there's no entry in the table for the given function.
     pub fn read_got_entry(&self, func_id: FuncId) -> *const u8 {
         let got_entry = self.function_got_entries[func_id].unwrap();
-        unsafe { got_entry.as_ref() }.load(Ordering::SeqCst)
+        unsafe { got_entry.0.as_ref() }.load(Ordering::SeqCst)
     }
 
     fn get_got_address(&self, name: &ModuleRelocTarget) -> NonNull<AtomicPtr<u8>> {
@@ -359,16 +367,18 @@ impl JITModule {
             ModuleRelocTarget::User { .. } => {
                 if ModuleDeclarations::is_function(name) {
                     let func_id = FuncId::from_name(name);
-                    self.function_got_entries[func_id].unwrap()
+                    self.function_got_entries[func_id].unwrap().0
                 } else {
                     let data_id = DataId::from_name(name);
-                    self.data_object_got_entries[data_id].unwrap()
+                    self.data_object_got_entries[data_id].unwrap().0
                 }
             }
-            ModuleRelocTarget::LibCall(ref libcall) => *self
-                .libcall_got_entries
-                .get(libcall)
-                .unwrap_or_else(|| panic!("can't resolve libcall {}", libcall)),
+            ModuleRelocTarget::LibCall(ref libcall) => {
+                self.libcall_got_entries
+                    .get(libcall)
+                    .unwrap_or_else(|| panic!("can't resolve libcall {libcall}"))
+                    .0
+            }
             _ => panic!("invalid name"),
         }
     }
@@ -380,6 +390,7 @@ impl JITModule {
                     let func_id = FuncId::from_name(name);
                     self.function_plt_entries[func_id]
                         .unwrap()
+                        .0
                         .as_ptr()
                         .cast::<u8>()
                 } else {
@@ -389,7 +400,8 @@ impl JITModule {
             ModuleRelocTarget::LibCall(ref libcall) => self
                 .libcall_plt_entries
                 .get(libcall)
-                .unwrap_or_else(|| panic!("can't resolve libcall {}", libcall))
+                .unwrap_or_else(|| panic!("can't resolve libcall {libcall}"))
+                .0
                 .as_ptr()
                 .cast::<u8>(),
             _ => panic!("invalid name"),
@@ -544,9 +556,13 @@ impl JITModule {
                 continue;
             };
             let got_entry = module.new_got_entry(addr);
-            module.libcall_got_entries.insert(libcall, got_entry);
+            module
+                .libcall_got_entries
+                .insert(libcall, SendWrapper(got_entry));
             let plt_entry = module.new_plt_entry(got_entry);
-            module.libcall_plt_entries.insert(libcall, plt_entry);
+            module
+                .libcall_plt_entries
+                .insert(libcall, SendWrapper(plt_entry));
         }
 
         module
@@ -712,7 +728,7 @@ impl Module for JITModule {
             .buffer
             .relocs()
             .iter()
-            .map(|reloc| ModuleReloc::from_mach_reloc(reloc, &ctx.func))
+            .map(|reloc| ModuleReloc::from_mach_reloc(reloc, &ctx.func, id))
             .collect();
 
         self.record_function_for_perf(ptr, size, &decl.linkage_name(id));
@@ -720,7 +736,7 @@ impl Module for JITModule {
 
         if self.isa.flags().is_pic() {
             self.pending_got_updates.push(GotUpdate {
-                entry: self.function_got_entries[id].unwrap(),
+                entry: self.function_got_entries[id].unwrap().0,
                 ptr,
             })
         }
@@ -737,7 +753,8 @@ impl Module for JITModule {
                         ModuleRelocTarget::LibCall(ref libcall) => self
                             .libcall_plt_entries
                             .get(libcall)
-                            .unwrap_or_else(|| panic!("can't resolve libcall {}", libcall))
+                            .unwrap_or_else(|| panic!("can't resolve libcall {libcall}"))
+                            .0
                             .as_ptr()
                             .cast::<u8>(),
                         _ => panic!("invalid name"),
@@ -797,13 +814,13 @@ impl Module for JITModule {
             size,
             relocs: relocs
                 .iter()
-                .map(|reloc| ModuleReloc::from_mach_reloc(reloc, func))
+                .map(|reloc| ModuleReloc::from_mach_reloc(reloc, func, id))
                 .collect(),
         });
 
         if self.isa.flags().is_pic() {
             self.pending_got_updates.push(GotUpdate {
-                entry: self.function_got_entries[id].unwrap(),
+                entry: self.function_got_entries[id].unwrap().0,
                 ptr,
             })
         }
@@ -851,7 +868,11 @@ impl Module for JITModule {
         } = data;
 
         let size = init.size();
-        let ptr = if decl.writable {
+        let ptr = if size == 0 {
+            // Return a correctly aligned non-null pointer to avoid UB in write_bytes and
+            // copy_nonoverlapping.
+            usize::try_from(align.unwrap_or(WRITABLE_DATA_ALIGNMENT)).unwrap() as *mut u8
+        } else if decl.writable {
             self.memory
                 .writable
                 .allocate(size, align.unwrap_or(WRITABLE_DATA_ALIGNMENT))
@@ -869,6 +890,17 @@ impl Module for JITModule {
                 })?
         };
 
+        if ptr.is_null() {
+            // FIXME pass a Layout to allocate and only compute the layout once.
+            std::alloc::handle_alloc_error(
+                std::alloc::Layout::from_size_align(
+                    size,
+                    align.unwrap_or(READONLY_DATA_ALIGNMENT).try_into().unwrap(),
+                )
+                .unwrap(),
+            );
+        }
+
         match *init {
             Init::Uninitialized => {
                 panic!("data is not initialized yet");
@@ -893,7 +925,7 @@ impl Module for JITModule {
         self.data_objects_to_finalize.push(id);
         if self.isa.flags().is_pic() {
             self.pending_got_updates.push(GotUpdate {
-                entry: self.data_object_got_entries[id].unwrap(),
+                entry: self.data_object_got_entries[id].unwrap().0,
                 ptr,
             })
         }
diff --git a/cranelift/jit/src/compiled_blob.rs b/cranelift/jit/src/compiled_blob.rs
index de01855c6d7b..4eab207ff011 100644
--- a/cranelift/jit/src/compiled_blob.rs
+++ b/cranelift/jit/src/compiled_blob.rs
@@ -1,7 +1,6 @@
 use cranelift_codegen::binemit::Reloc;
 use cranelift_module::ModuleReloc;
 use cranelift_module::ModuleRelocTarget;
-use std::convert::TryFrom;
 
 /// Reads a 32bit instruction at `iptr`, and writes it again after
 /// being altered by `modifier`
@@ -18,6 +17,8 @@ pub(crate) struct CompiledBlob {
     pub(crate) relocs: Vec<ModuleReloc>,
 }
 
+unsafe impl Send for CompiledBlob {}
+
 impl CompiledBlob {
     pub(crate) fn perform_relocations(
         &self,
@@ -93,8 +94,37 @@ impl CompiledBlob {
                     let imm26 = (diff as u32) << chop >> chop;
                     unsafe { modify_inst32(iptr, |inst| inst | imm26) };
                 }
-                Reloc::RiscvCall => {
-                    // A R_RISCV_CALL relocation expects auipc+jalr instruction pair.
+                Reloc::Aarch64AdrGotPage21 => {
+                    // Set the immediate value of an ADRP to bits [32:12] of X; check that –2^32 <= X < 2^32
+                    assert_eq!(addend, 0, "addend affects the address looked up in get_got_entry, which is currently only called with a symbol");
+                    let what = get_got_entry(name);
+                    let what_page = (what as usize) & !0xfff;
+                    let at_page = (at as usize) & !0xfff;
+                    let pcrel = (what_page as isize).checked_sub(at_page as isize).unwrap();
+                    assert!(
+                        (-1 << 32) <= pcrel && pcrel < (1 << 32),
+                        "can't reach GOT page with ±4GB `adrp` instruction"
+                    );
+                    let val = pcrel >> 12;
+
+                    let immlo = ((val as u32) & 0b11) << 29;
+                    let immhi = (((val as u32) >> 2) & &0x7ffff) << 5;
+                    let mask = !((0x7ffff << 5) | (0b11 << 29));
+                    unsafe { modify_inst32(at as *mut u32, |adrp| (adrp & mask) | immlo | immhi) };
+                }
+                Reloc::Aarch64Ld64GotLo12Nc => {
+                    // Set the LD/ST immediate field to bits 11:3 of X. No overflow check; check that X&7 = 0
+                    assert_eq!(addend, 0);
+                    let base = get_got_entry(name);
+                    let what = base as u32;
+                    assert_eq!(what & 0b111, 0);
+                    let val = what >> 3;
+                    let imm9 = (val & 0x1ff) << 10;
+                    let mask = !(0x1ff << 10);
+                    unsafe { modify_inst32(at as *mut u32, |ldr| (ldr & mask) | imm9) };
+                }
+                Reloc::RiscvCallPlt => {
+                    // A R_RISCV_CALL_PLT relocation expects auipc+jalr instruction pair.
                     // It is the equivalent of two relocations:
                     // 1. R_RISCV_PCREL_HI20 on the `auipc`
                     // 2. R_RISCV_PCREL_LO12_I on the `jalr`
diff --git a/cranelift/jit/src/lib.rs b/cranelift/jit/src/lib.rs
index 1565bb5bcf15..a7e4190cd12f 100644
--- a/cranelift/jit/src/lib.rs
+++ b/cranelift/jit/src/lib.rs
@@ -3,14 +3,7 @@
 //! There is an [example project](https://github.com/bytecodealliance/cranelift-jit-demo/)
 //! which shows how to use some of the features of `cranelift_jit`.
 
-#![deny(
-    missing_docs,
-    trivial_numeric_casts,
-    unused_extern_crates,
-    unstable_features,
-    unreachable_pub
-)]
-#![warn(unused_import_braces)]
+#![deny(missing_docs, unreachable_pub)]
 
 mod backend;
 mod compiled_blob;
diff --git a/cranelift/jit/src/memory.rs b/cranelift/jit/src/memory.rs
index 6fa369b73294..abbb513c663f 100644
--- a/cranelift/jit/src/memory.rs
+++ b/cranelift/jit/src/memory.rs
@@ -5,7 +5,6 @@ use memmap2::MmapMut;
 
 #[cfg(not(any(feature = "selinux-fix", windows)))]
 use std::alloc;
-use std::convert::TryFrom;
 use std::ffi::c_void;
 use std::io;
 use std::mem;
@@ -133,6 +132,8 @@ pub(crate) struct Memory {
     branch_protection: BranchProtection,
 }
 
+unsafe impl Send for Memory {}
+
 impl Memory {
     pub(crate) fn new(branch_protection: BranchProtection) -> Self {
         Self {
diff --git a/cranelift/jit/tests/basic.rs b/cranelift/jit/tests/basic.rs
index a6e5a04641a7..6220782c7d9d 100644
--- a/cranelift/jit/tests/basic.rs
+++ b/cranelift/jit/tests/basic.rs
@@ -14,7 +14,7 @@ fn error_on_incompatible_sig_in_declare_function() {
     // FIXME set back to true once the x64 backend supports it.
     flag_builder.set("is_pic", "false").unwrap();
     let isa_builder = cranelift_native::builder().unwrap_or_else(|msg| {
-        panic!("host machine is not supported: {}", msg);
+        panic!("host machine is not supported: {msg}");
     });
     let isa = isa_builder
         .finish(settings::Flags::new(flag_builder))
@@ -70,7 +70,7 @@ fn panic_on_define_after_finalize() {
     // FIXME set back to true once the x64 backend supports it.
     flag_builder.set("is_pic", "false").unwrap();
     let isa_builder = cranelift_native::builder().unwrap_or_else(|msg| {
-        panic!("host machine is not supported: {}", msg);
+        panic!("host machine is not supported: {msg}");
     });
     let isa = isa_builder
         .finish(settings::Flags::new(flag_builder))
@@ -101,7 +101,7 @@ fn switch_error() {
         let bb1 = bcx.create_block();
         let bb2 = bcx.create_block();
         let bb3 = bcx.create_block();
-        println!("{} {} {} {} {}", start, bb0, bb1, bb2, bb3);
+        println!("{start} {bb0} {bb1} {bb2} {bb3}");
 
         bcx.declare_var(Variable::new(0), types::I32);
         bcx.declare_var(Variable::new(1), types::I32);
@@ -149,7 +149,7 @@ fn switch_error() {
         Err(err) => {
             let pretty_error =
                 cranelift_codegen::print_errors::pretty_verifier_error(&func, None, err);
-            panic!("pretty_error:\n{}", pretty_error);
+            panic!("pretty_error:\n{pretty_error}");
         }
     }
 }
@@ -161,7 +161,7 @@ fn libcall_function() {
     // FIXME set back to true once the x64 backend supports it.
     flag_builder.set("is_pic", "false").unwrap();
     let isa_builder = cranelift_native::builder().unwrap_or_else(|msg| {
-        panic!("host machine is not supported: {}", msg);
+        panic!("host machine is not supported: {msg}");
     });
     let isa = isa_builder
         .finish(settings::Flags::new(flag_builder))
@@ -213,3 +213,27 @@ fn libcall_function() {
 
     module.finalize_definitions().unwrap();
 }
+
+// This used to cause UB. See https://github.com/bytecodealliance/wasmtime/issues/7918.
+#[test]
+fn empty_data_object() {
+    let mut flag_builder = settings::builder();
+    flag_builder.set("use_colocated_libcalls", "false").unwrap();
+    // FIXME set back to true once the x64 backend supports it.
+    flag_builder.set("is_pic", "false").unwrap();
+    let isa_builder = cranelift_native::builder().unwrap_or_else(|msg| {
+        panic!("host machine is not supported: {msg}");
+    });
+    let isa = isa_builder
+        .finish(settings::Flags::new(flag_builder))
+        .unwrap();
+    let mut module = JITModule::new(JITBuilder::with_isa(isa, default_libcall_names()));
+
+    let data_id = module
+        .declare_data("empty", Linkage::Export, false, false)
+        .unwrap();
+
+    let mut data = DataDescription::new();
+    data.define(Box::new([]));
+    module.define_data(data_id, &data).unwrap();
+}
diff --git a/cranelift/module/Cargo.toml b/cranelift/module/Cargo.toml
index e89a1e20ed61..7cd0a4bf7a92 100644
--- a/cranelift/module/Cargo.toml
+++ b/cranelift/module/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "cranelift-module"
-version = "0.101.0"
+version = "0.112.0"
 authors = ["The Cranelift Project Developers"]
 description = "Support for linking functions and data with Cranelift"
 repository = "https://github.com/bytecodealliance/wasmtime"
@@ -9,14 +9,18 @@ categories = ["no-std"]
 license = "Apache-2.0 WITH LLVM-exception"
 readme = "README.md"
 edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
 
 [dependencies]
 cranelift-codegen = { workspace = true }
 cranelift-control = { workspace = true }
 hashbrown = { workspace = true, optional = true }
-anyhow = { workspace = true }
-serde = { version = "1.0.188", optional = true }
-serde_derive = { version = "1.0.188", optional = true }
+anyhow = { workspace = true, features = ['std'] }
+serde = { workspace = true, optional = true }
+serde_derive = { workspace = true, optional = true }
 
 [features]
 default = ["std"]
diff --git a/cranelift/module/src/lib.rs b/cranelift/module/src/lib.rs
index 88313c3a224b..7528ad67caad 100644
--- a/cranelift/module/src/lib.rs
+++ b/cranelift/module/src/lib.rs
@@ -1,8 +1,6 @@
 //! Top-level lib.rs for `cranelift_module`.
 
-#![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)]
-#![warn(unused_import_braces)]
-#![cfg_attr(feature = "std", deny(unstable_features))]
+#![deny(missing_docs)]
 #![no_std]
 
 #[cfg(not(feature = "std"))]
diff --git a/cranelift/module/src/module.rs b/cranelift/module/src/module.rs
index cae49ef17e97..d9494b851ed2 100644
--- a/cranelift/module/src/module.rs
+++ b/cranelift/module/src/module.rs
@@ -11,13 +11,14 @@ use core::fmt::Display;
 use cranelift_codegen::binemit::{CodeOffset, Reloc};
 use cranelift_codegen::entity::{entity_impl, PrimaryMap};
 use cranelift_codegen::ir::function::{Function, VersionMarker};
-use cranelift_codegen::ir::{ExternalName, UserFuncName};
+use cranelift_codegen::ir::ExternalName;
 use cranelift_codegen::settings::SetError;
 use cranelift_codegen::{
     ir, isa, CodegenError, CompileError, Context, FinalizedMachReloc, FinalizedRelocTarget,
 };
 use cranelift_control::ControlPlane;
 use std::borrow::{Cow, ToOwned};
+use std::boxed::Box;
 use std::string::String;
 
 /// A module relocation.
@@ -36,7 +37,11 @@ pub struct ModuleReloc {
 
 impl ModuleReloc {
     /// Converts a `FinalizedMachReloc` produced from a `Function` into a `ModuleReloc`.
-    pub fn from_mach_reloc(mach_reloc: &FinalizedMachReloc, func: &Function) -> Self {
+    pub fn from_mach_reloc(
+        mach_reloc: &FinalizedMachReloc,
+        func: &Function,
+        func_id: FuncId,
+    ) -> Self {
         let name = match mach_reloc.target {
             FinalizedRelocTarget::ExternalName(ExternalName::User(reff)) => {
                 let name = &func.params.user_named_funcs()[reff];
@@ -50,7 +55,7 @@ impl ModuleReloc {
                 ModuleRelocTarget::KnownSymbol(ks)
             }
             FinalizedRelocTarget::Func(offset) => {
-                ModuleRelocTarget::FunctionOffset(func.name.clone(), offset)
+                ModuleRelocTarget::FunctionOffset(func_id, offset)
             }
         };
         Self {
@@ -321,36 +326,34 @@ impl std::fmt::Display for ModuleError {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             Self::Undeclared(name) => {
-                write!(f, "Undeclared identifier: {}", name)
+                write!(f, "Undeclared identifier: {name}")
             }
             Self::IncompatibleDeclaration(name) => {
-                write!(f, "Incompatible declaration of identifier: {}", name,)
+                write!(f, "Incompatible declaration of identifier: {name}",)
             }
             Self::IncompatibleSignature(name, prev_sig, new_sig) => {
                 write!(
                     f,
-                    "Function {} signature {:?} is incompatible with previous declaration {:?}",
-                    name, new_sig, prev_sig,
+                    "Function {name} signature {new_sig:?} is incompatible with previous declaration {prev_sig:?}",
                 )
             }
             Self::DuplicateDefinition(name) => {
-                write!(f, "Duplicate definition of identifier: {}", name)
+                write!(f, "Duplicate definition of identifier: {name}")
             }
             Self::InvalidImportDefinition(name) => {
                 write!(
                     f,
-                    "Invalid to define identifier declared as an import: {}",
-                    name,
+                    "Invalid to define identifier declared as an import: {name}",
                 )
             }
             Self::Compilation(err) => {
-                write!(f, "Compilation error: {}", err)
+                write!(f, "Compilation error: {err}")
             }
             Self::Allocation { message, err } => {
-                write!(f, "Allocation error: {}: {}", message, err)
+                write!(f, "Allocation error: {message}: {err}")
             }
-            Self::Backend(err) => write!(f, "Backend error: {}", err),
-            Self::Flag(err) => write!(f, "Flag error: {}", err),
+            Self::Backend(err) => write!(f, "Backend error: {err}"),
+            Self::Flag(err) => write!(f, "Flag error: {err}"),
         }
     }
 }
@@ -430,7 +433,7 @@ pub enum ModuleRelocTarget {
     /// Symbols known to the linker.
     KnownSymbol(ir::KnownSymbol),
     /// A offset inside a function
-    FunctionOffset(UserFuncName, CodeOffset),
+    FunctionOffset(FuncId, CodeOffset),
 }
 
 impl ModuleRelocTarget {
@@ -443,9 +446,9 @@ impl ModuleRelocTarget {
 impl Display for ModuleRelocTarget {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {
-            Self::User { namespace, index } => write!(f, "u{}:{}", namespace, index),
-            Self::LibCall(lc) => write!(f, "%{}", lc),
-            Self::KnownSymbol(ks) => write!(f, "{}", ks),
+            Self::User { namespace, index } => write!(f, "u{namespace}:{index}"),
+            Self::LibCall(lc) => write!(f, "%{lc}"),
+            Self::KnownSymbol(ks) => write!(f, "{ks}"),
             Self::FunctionOffset(fname, offset) => write!(f, "{fname}+{offset}"),
         }
     }
@@ -986,7 +989,112 @@ pub trait Module {
     fn define_data(&mut self, data_id: DataId, data: &DataDescription) -> ModuleResult<()>;
 }
 
-impl<M: Module> Module for &mut M {
+impl<M: Module + ?Sized> Module for &mut M {
+    fn isa(&self) -> &dyn isa::TargetIsa {
+        (**self).isa()
+    }
+
+    fn declarations(&self) -> &ModuleDeclarations {
+        (**self).declarations()
+    }
+
+    fn get_name(&self, name: &str) -> Option<FuncOrDataId> {
+        (**self).get_name(name)
+    }
+
+    fn target_config(&self) -> isa::TargetFrontendConfig {
+        (**self).target_config()
+    }
+
+    fn make_context(&self) -> Context {
+        (**self).make_context()
+    }
+
+    fn clear_context(&self, ctx: &mut Context) {
+        (**self).clear_context(ctx)
+    }
+
+    fn make_signature(&self) -> ir::Signature {
+        (**self).make_signature()
+    }
+
+    fn clear_signature(&self, sig: &mut ir::Signature) {
+        (**self).clear_signature(sig)
+    }
+
+    fn declare_function(
+        &mut self,
+        name: &str,
+        linkage: Linkage,
+        signature: &ir::Signature,
+    ) -> ModuleResult<FuncId> {
+        (**self).declare_function(name, linkage, signature)
+    }
+
+    fn declare_anonymous_function(&mut self, signature: &ir::Signature) -> ModuleResult<FuncId> {
+        (**self).declare_anonymous_function(signature)
+    }
+
+    fn declare_data(
+        &mut self,
+        name: &str,
+        linkage: Linkage,
+        writable: bool,
+        tls: bool,
+    ) -> ModuleResult<DataId> {
+        (**self).declare_data(name, linkage, writable, tls)
+    }
+
+    fn declare_anonymous_data(&mut self, writable: bool, tls: bool) -> ModuleResult<DataId> {
+        (**self).declare_anonymous_data(writable, tls)
+    }
+
+    fn declare_func_in_func(&mut self, func: FuncId, in_func: &mut ir::Function) -> ir::FuncRef {
+        (**self).declare_func_in_func(func, in_func)
+    }
+
+    fn declare_data_in_func(&self, data: DataId, func: &mut ir::Function) -> ir::GlobalValue {
+        (**self).declare_data_in_func(data, func)
+    }
+
+    fn declare_func_in_data(&self, func_id: FuncId, data: &mut DataDescription) -> ir::FuncRef {
+        (**self).declare_func_in_data(func_id, data)
+    }
+
+    fn declare_data_in_data(&self, data_id: DataId, data: &mut DataDescription) -> ir::GlobalValue {
+        (**self).declare_data_in_data(data_id, data)
+    }
+
+    fn define_function(&mut self, func: FuncId, ctx: &mut Context) -> ModuleResult<()> {
+        (**self).define_function(func, ctx)
+    }
+
+    fn define_function_with_control_plane(
+        &mut self,
+        func: FuncId,
+        ctx: &mut Context,
+        ctrl_plane: &mut ControlPlane,
+    ) -> ModuleResult<()> {
+        (**self).define_function_with_control_plane(func, ctx, ctrl_plane)
+    }
+
+    fn define_function_bytes(
+        &mut self,
+        func_id: FuncId,
+        func: &ir::Function,
+        alignment: u64,
+        bytes: &[u8],
+        relocs: &[FinalizedMachReloc],
+    ) -> ModuleResult<()> {
+        (**self).define_function_bytes(func_id, func, alignment, bytes, relocs)
+    }
+
+    fn define_data(&mut self, data_id: DataId, data: &DataDescription) -> ModuleResult<()> {
+        (**self).define_data(data_id, data)
+    }
+}
+
+impl<M: Module + ?Sized> Module for Box<M> {
     fn isa(&self) -> &dyn isa::TargetIsa {
         (**self).isa()
     }
diff --git a/cranelift/native/Cargo.toml b/cranelift/native/Cargo.toml
index b9556a8c589d..599536d27517 100644
--- a/cranelift/native/Cargo.toml
+++ b/cranelift/native/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "cranelift-native"
-version = "0.101.0"
+version = "0.112.0"
 authors = ["The Cranelift Project Developers"]
 description = "Support for targeting the host with Cranelift"
 documentation = "https://docs.rs/cranelift-native"
@@ -9,13 +9,14 @@ categories = ["no-std"]
 license = "Apache-2.0 WITH LLVM-exception"
 readme = "README.md"
 edition.workspace = true
+rust-version.workspace = true
 
 [dependencies]
 cranelift-codegen = { workspace = true }
 target-lexicon = { workspace = true }
 
 [target.'cfg(any(target_arch = "s390x", target_arch = "riscv64"))'.dependencies]
-libc = "0.2.95"
+libc = { workspace = true }
 
 [features]
 default = ["std"]
diff --git a/cranelift/native/src/lib.rs b/cranelift/native/src/lib.rs
index 42d20a326191..a9d638b188ba 100644
--- a/cranelift/native/src/lib.rs
+++ b/cranelift/native/src/lib.rs
@@ -1,13 +1,7 @@
 //! Performs autodetection of the host for the purposes of running
 //! Cranelift to generate code to run on the same machine.
 
-#![deny(
-    missing_docs,
-    trivial_numeric_casts,
-    unused_extern_crates,
-    unstable_features
-)]
-#![warn(unused_import_braces)]
+#![deny(missing_docs)]
 
 use cranelift_codegen::isa;
 use cranelift_codegen::settings::Configurable;
@@ -28,7 +22,7 @@ pub fn builder() -> Result<isa::Builder, &'static str> {
 /// in the current configuration.
 ///
 /// Selects the given backend variant specifically; this is
-/// useful when more than oen backend exists for a given target
+/// useful when more than one backend exists for a given target
 /// (e.g., on x86-64).
 pub fn builder_with_options(infer_native_flags: bool) -> Result<isa::Builder, &'static str> {
     let mut isa_builder = isa::lookup(Triple::host()).map_err(|err| match err {
@@ -46,7 +40,7 @@ pub fn builder_with_options(infer_native_flags: bool) -> Result<isa::Builder, &'
 /// in the current configuration.
 ///
 /// Selects the given backend variant specifically; this is
-/// useful when more than oen backend exists for a given target
+/// useful when more than one backend exists for a given target
 /// (e.g., on x86-64).
 pub fn infer_native_flags(isa_builder: &mut dyn Configurable) -> Result<(), &'static str> {
     #[cfg(target_arch = "x86_64")]
@@ -115,6 +109,10 @@ pub fn infer_native_flags(isa_builder: &mut dyn Configurable) -> Result<(), &'st
             isa_builder.enable("has_pauth").unwrap();
         }
 
+        if std::arch::is_aarch64_feature_detected!("fp16") {
+            isa_builder.enable("has_fp16").unwrap();
+        }
+
         if cfg!(target_os = "macos") {
             // Pointer authentication is always available on Apple Silicon.
             isa_builder.enable("sign_return_address").unwrap();
@@ -150,9 +148,16 @@ pub fn infer_native_flags(isa_builder: &mut dyn Configurable) -> Result<(), &'st
         // the cpuinfo interface, so we can't rely on it being present for now.
         let _ = riscv::cpuinfo_detect(isa_builder);
     }
+
+    // On all other architectures (e.g. wasm32) we won't infer any native flags,
+    // but still need to use the `isa_builder` to avoid compiler warnings.
+    let _ = isa_builder;
     Ok(())
 }
 
+/// Version number of this crate.
+pub const VERSION: &str = env!("CARGO_PKG_VERSION");
+
 #[cfg(test)]
 mod tests {
     use super::builder;
@@ -169,7 +174,7 @@ mod tests {
 
             if cfg!(all(target_os = "macos", target_arch = "aarch64")) {
                 assert_eq!(isa.default_call_conv(), CallConv::AppleAarch64);
-            } else if cfg!(any(unix, target_os = "nebulet")) {
+            } else if cfg!(unix) {
                 assert_eq!(isa.default_call_conv(), CallConv::SystemV);
             } else if cfg!(windows) {
                 assert_eq!(isa.default_call_conv(), CallConv::WindowsFastcall);
@@ -185,6 +190,3 @@ mod tests {
         }
     }
 }
-
-/// Version number of this crate.
-pub const VERSION: &str = env!("CARGO_PKG_VERSION");
diff --git a/cranelift/native/src/riscv.rs b/cranelift/native/src/riscv.rs
index edcf306cf70a..4152816f7ab1 100644
--- a/cranelift/native/src/riscv.rs
+++ b/cranelift/native/src/riscv.rs
@@ -50,7 +50,7 @@ pub fn hwcap_detect(isa_builder: &mut dyn Configurable) -> Result<(), &'static s
 /// Read the /proc/cpuinfo file and detect the extensions.
 ///
 /// We are looking for the isa line string, which contains the extensions.
-/// The format for this string is specifid in the linux user space ABI for RISC-V:
+/// The format for this string is specified in the linux user space ABI for RISC-V:
 /// https://github.com/torvalds/linux/blob/09a9639e56c01c7a00d6c0ca63f4c7c41abe075d/Documentation/riscv/uabi.rst
 ///
 /// The format is fairly similar to the one specified in the RISC-V ISA manual, but
diff --git a/cranelift/object/Cargo.toml b/cranelift/object/Cargo.toml
index 5b3260dc950f..bbacba0d3122 100644
--- a/cranelift/object/Cargo.toml
+++ b/cranelift/object/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "cranelift-object"
-version = "0.101.0"
+version = "0.112.0"
 authors = ["The Cranelift Project Developers"]
 description = "Emit Cranelift output to native object files with `object`"
 repository = "https://github.com/bytecodealliance/wasmtime"
@@ -8,12 +8,16 @@ documentation = "https://docs.rs/cranelift-object"
 license = "Apache-2.0 WITH LLVM-exception"
 readme = "README.md"
 edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
 
 [dependencies]
 cranelift-module = { workspace = true }
 cranelift-codegen = { workspace = true, features = ["std"] }
 cranelift-control = { workspace = true }
-object = { workspace = true, features = ["write"] }
+object = { workspace = true, features = ["write", "std"] }
 target-lexicon = { workspace = true }
 anyhow = { workspace = true }
 log = { workspace = true }
diff --git a/cranelift/object/src/backend.rs b/cranelift/object/src/backend.rs
index d083d84ce12f..2d48e9b613f1 100644
--- a/cranelift/object/src/backend.rs
+++ b/cranelift/object/src/backend.rs
@@ -3,9 +3,8 @@
 use anyhow::anyhow;
 use cranelift_codegen::binemit::{Addend, CodeOffset, Reloc};
 use cranelift_codegen::entity::SecondaryMap;
-use cranelift_codegen::ir::UserFuncName;
 use cranelift_codegen::isa::{OwnedTargetIsa, TargetIsa};
-use cranelift_codegen::{self, ir, FinalizedMachReloc};
+use cranelift_codegen::{ir, FinalizedMachReloc};
 use cranelift_control::ControlPlane;
 use cranelift_module::{
     DataDescription, DataId, FuncId, Init, Linkage, Module, ModuleDeclarations, ModuleError,
@@ -16,7 +15,8 @@ use object::write::{
     Object, Relocation, SectionId, StandardSection, Symbol, SymbolId, SymbolSection,
 };
 use object::{
-    RelocationEncoding, RelocationKind, SectionKind, SymbolFlags, SymbolKind, SymbolScope,
+    RelocationEncoding, RelocationFlags, RelocationKind, SectionKind, SymbolFlags, SymbolKind,
+    SymbolScope,
 };
 use std::collections::hash_map::Entry;
 use std::collections::HashMap;
@@ -39,10 +39,10 @@ impl ObjectBuilder {
     /// Create a new `ObjectBuilder` using the given Cranelift target, that
     /// can be passed to [`ObjectModule::new`].
     ///
-    /// The `libcall_names` function provides a way to translate `cranelift_codegen`'s [ir::LibCall]
+    /// The `libcall_names` function provides a way to translate `cranelift_codegen`'s [`ir::LibCall`]
     /// enum to symbols. LibCalls are inserted in the IR as part of the legalization for certain
     /// floating point instructions, and for stack probes. If you don't know what to use for this
-    /// argument, use [cranelift_module::default_libcall_names]().
+    /// argument, use [`cranelift_module::default_libcall_names`].
     pub fn new<V: Into<Vec<u8>>>(
         isa: OwnedTargetIsa,
         name: V,
@@ -80,11 +80,24 @@ impl ObjectBuilder {
                         binary_format,
                     )));
                 }
-                // FIXME(#4994) get the right variant from the TargetIsa
+
+                // FIXME(#4994): Get the right float ABI variant from the TargetIsa
+                let mut eflags = object::elf::EF_RISCV_FLOAT_ABI_DOUBLE;
+
+                // Set the RVC eflag if we have the C extension enabled.
+                let has_c = isa
+                    .isa_flags()
+                    .iter()
+                    .filter(|f| f.name == "has_zca" || f.name == "has_zcd")
+                    .all(|f| f.as_bool().unwrap_or_default());
+                if has_c {
+                    eflags |= object::elf::EF_RISCV_RVC;
+                }
+
                 file_flags = object::FileFlags::Elf {
                     os_abi: object::elf::ELFOSABI_NONE,
                     abi_version: 0,
-                    e_flags: object::elf::EF_RISCV_RVC | object::elf::EF_RISCV_FLOAT_ABI_DOUBLE,
+                    e_flags: eflags,
                 };
                 object::Architecture::Riscv64
             }
@@ -132,7 +145,7 @@ pub struct ObjectModule {
     libcalls: HashMap<ir::LibCall, SymbolId>,
     libcall_names: Box<dyn Fn(ir::LibCall) -> String + Send + Sync>,
     known_symbols: HashMap<ir::KnownSymbol, SymbolId>,
-    known_labels: HashMap<(UserFuncName, CodeOffset), SymbolId>,
+    known_labels: HashMap<(FuncId, CodeOffset), SymbolId>,
     per_function_section: bool,
 }
 
@@ -141,6 +154,7 @@ impl ObjectModule {
     pub fn new(builder: ObjectBuilder) -> Self {
         let mut object = Object::new(builder.binary_format, builder.architecture, builder.endian);
         object.flags = builder.flags;
+        object.set_subsections_via_symbols();
         object.add_file_symbol(builder.name);
         Self {
             isa: builder.isa,
@@ -355,24 +369,21 @@ impl Module for ObjectModule {
         let align = alignment
             .max(self.isa.function_alignment().minimum.into())
             .max(self.isa.symbol_alignment());
-        let (section, offset) = if self.per_function_section {
+        let section = if self.per_function_section {
             let symbol_name = self.object.symbol(symbol).name.clone();
-            let (section, offset) =
-                self.object
-                    .add_subsection(StandardSection::Text, &symbol_name, bytes, align);
-            self.object.symbol_mut(symbol).section = SymbolSection::Section(section);
-            self.object.symbol_mut(symbol).value = offset;
-            (section, offset)
+            self.object
+                .add_subsection(StandardSection::Text, &symbol_name)
         } else {
-            let section = self.object.section_id(StandardSection::Text);
-            let offset = self.object.add_symbol_data(symbol, section, bytes, align);
-            (section, offset)
+            self.object.section_id(StandardSection::Text)
         };
+        let offset = self.object.add_symbol_data(symbol, section, bytes, align);
 
         if !relocs.is_empty() {
             let relocs = relocs
                 .iter()
-                .map(|record| self.process_reloc(&ModuleReloc::from_mach_reloc(&record, func)))
+                .map(|record| {
+                    self.process_reloc(&ModuleReloc::from_mach_reloc(&record, func, func_id))
+                })
                 .collect();
             self.relocs.push(SymbolRelocs {
                 section,
@@ -488,9 +499,7 @@ impl ObjectModule {
             for &ObjectRelocRecord {
                 offset,
                 ref name,
-                kind,
-                encoding,
-                size,
+                flags,
                 addend,
             } in &symbol.relocs
             {
@@ -500,9 +509,7 @@ impl ObjectModule {
                         symbol.section,
                         Relocation {
                             offset: symbol.offset + u64::from(offset),
-                            size,
-                            kind,
-                            encoding,
+                            flags,
                             symbol: target_symbol,
                             addend,
                         },
@@ -594,15 +601,10 @@ impl ObjectModule {
                 }
             }
 
-            ModuleRelocTarget::FunctionOffset(ref fname, offset) => {
-                match self.known_labels.entry((fname.clone(), offset)) {
+            ModuleRelocTarget::FunctionOffset(func_id, offset) => {
+                match self.known_labels.entry((func_id, offset)) {
                     Entry::Occupied(o) => *o.get(),
                     Entry::Vacant(v) => {
-                        let func_user_name = fname.get_user().unwrap();
-                        let func_id = FuncId::from_name(&ModuleRelocTarget::user(
-                            func_user_name.namespace,
-                            func_user_name.index,
-                        ));
                         let func_symbol_id = self.functions[func_id].unwrap().0;
                         let func_symbol = self.object.symbol(func_symbol_id);
 
@@ -627,41 +629,58 @@ impl ObjectModule {
     }
 
     fn process_reloc(&self, record: &ModuleReloc) -> ObjectRelocRecord {
-        let mut addend = record.addend;
-        let (kind, encoding, size) = match record.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),
+        let flags = match record.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,
+            },
             // TODO: Get Cranelift to tell us when we can use
             // R_X86_64_GOTPCRELX/R_X86_64_REX_GOTPCRELX.
-            Reloc::X86CallPLTRel4 => (
-                RelocationKind::PltRelative,
-                RelocationEncoding::X86Branch,
-                32,
-            ),
-            Reloc::X86SecRel => (
-                RelocationKind::SectionOffset,
-                RelocationEncoding::Generic,
-                32,
-            ),
-            Reloc::X86GOTPCRel4 => (RelocationKind::GotRelative, RelocationEncoding::Generic, 32),
-            Reloc::Arm64Call => (
-                RelocationKind::Relative,
-                RelocationEncoding::AArch64Call,
-                26,
-            ),
+            Reloc::X86CallPLTRel4 => RelocationFlags::Generic {
+                kind: RelocationKind::PltRelative,
+                encoding: RelocationEncoding::X86Branch,
+                size: 32,
+            },
+            Reloc::X86SecRel => RelocationFlags::Generic {
+                kind: RelocationKind::SectionOffset,
+                encoding: RelocationEncoding::Generic,
+                size: 32,
+            },
+            Reloc::X86GOTPCRel4 => RelocationFlags::Generic {
+                kind: RelocationKind::GotRelative,
+                encoding: RelocationEncoding::Generic,
+                size: 32,
+            },
+            Reloc::Arm64Call => RelocationFlags::Generic {
+                kind: RelocationKind::Relative,
+                encoding: RelocationEncoding::AArch64Call,
+                size: 26,
+            },
             Reloc::ElfX86_64TlsGd => {
                 assert_eq!(
                     self.object.format(),
                     object::BinaryFormat::Elf,
                     "ElfX86_64TlsGd is not supported for this file format"
                 );
-                (
-                    RelocationKind::Elf(object::elf::R_X86_64_TLSGD),
-                    RelocationEncoding::Generic,
-                    32,
-                )
+                RelocationFlags::Elf {
+                    r_type: object::elf::R_X86_64_TLSGD,
+                }
             }
             Reloc::MachOX86_64Tlv => {
                 assert_eq!(
@@ -669,15 +688,11 @@ impl ObjectModule {
                     object::BinaryFormat::MachO,
                     "MachOX86_64Tlv is not supported for this file format"
                 );
-                addend += 4; // X86_64_RELOC_TLV has an implicit addend of -4
-                (
-                    RelocationKind::MachO {
-                        value: object::macho::X86_64_RELOC_TLV,
-                        relative: true,
-                    },
-                    RelocationEncoding::Generic,
-                    32,
-                )
+                RelocationFlags::MachO {
+                    r_type: object::macho::X86_64_RELOC_TLV,
+                    r_pcrel: true,
+                    r_length: 2,
+                }
             }
             Reloc::MachOAarch64TlsAdrPage21 => {
                 assert_eq!(
@@ -685,14 +700,11 @@ impl ObjectModule {
                     object::BinaryFormat::MachO,
                     "MachOAarch64TlsAdrPage21 is not supported for this file format"
                 );
-                (
-                    RelocationKind::MachO {
-                        value: object::macho::ARM64_RELOC_TLVP_LOAD_PAGE21,
-                        relative: true,
-                    },
-                    RelocationEncoding::Generic,
-                    21,
-                )
+                RelocationFlags::MachO {
+                    r_type: object::macho::ARM64_RELOC_TLVP_LOAD_PAGE21,
+                    r_pcrel: true,
+                    r_length: 2,
+                }
             }
             Reloc::MachOAarch64TlsAdrPageOff12 => {
                 assert_eq!(
@@ -700,88 +712,94 @@ impl ObjectModule {
                     object::BinaryFormat::MachO,
                     "MachOAarch64TlsAdrPageOff12 is not supported for this file format"
                 );
-                (
-                    RelocationKind::MachO {
-                        value: object::macho::ARM64_RELOC_TLVP_LOAD_PAGEOFF12,
-                        relative: false,
-                    },
-                    RelocationEncoding::Generic,
-                    12,
-                )
+                RelocationFlags::MachO {
+                    r_type: object::macho::ARM64_RELOC_TLVP_LOAD_PAGEOFF12,
+                    r_pcrel: false,
+                    r_length: 2,
+                }
+            }
+            Reloc::Aarch64TlsDescAdrPage21 => {
+                assert_eq!(
+                    self.object.format(),
+                    object::BinaryFormat::Elf,
+                    "Aarch64TlsDescAdrPage21 is not supported for this file format"
+                );
+                RelocationFlags::Elf {
+                    r_type: object::elf::R_AARCH64_TLSDESC_ADR_PAGE21,
+                }
+            }
+            Reloc::Aarch64TlsDescLd64Lo12 => {
+                assert_eq!(
+                    self.object.format(),
+                    object::BinaryFormat::Elf,
+                    "Aarch64TlsDescLd64Lo12 is not supported for this file format"
+                );
+                RelocationFlags::Elf {
+                    r_type: object::elf::R_AARCH64_TLSDESC_LD64_LO12,
+                }
             }
-            Reloc::Aarch64TlsGdAdrPage21 => {
+            Reloc::Aarch64TlsDescAddLo12 => {
                 assert_eq!(
                     self.object.format(),
                     object::BinaryFormat::Elf,
-                    "Aarch64TlsGdAdrPrel21 is not supported for this file format"
+                    "Aarch64TlsDescAddLo12 is not supported for this file format"
                 );
-                (
-                    RelocationKind::Elf(object::elf::R_AARCH64_TLSGD_ADR_PAGE21),
-                    RelocationEncoding::Generic,
-                    21,
-                )
+                RelocationFlags::Elf {
+                    r_type: object::elf::R_AARCH64_TLSDESC_ADD_LO12,
+                }
             }
-            Reloc::Aarch64TlsGdAddLo12Nc => {
+            Reloc::Aarch64TlsDescCall => {
                 assert_eq!(
                     self.object.format(),
                     object::BinaryFormat::Elf,
-                    "Aarch64TlsGdAddLo12Nc is not supported for this file format"
+                    "Aarch64TlsDescCall is not supported for this file format"
                 );
-                (
-                    RelocationKind::Elf(object::elf::R_AARCH64_TLSGD_ADD_LO12_NC),
-                    RelocationEncoding::Generic,
-                    12,
-                )
+                RelocationFlags::Elf {
+                    r_type: object::elf::R_AARCH64_TLSDESC_CALL,
+                }
             }
+
             Reloc::Aarch64AdrGotPage21 => match self.object.format() {
-                object::BinaryFormat::Elf => (
-                    RelocationKind::Elf(object::elf::R_AARCH64_ADR_GOT_PAGE),
-                    RelocationEncoding::Generic,
-                    21,
-                ),
-                object::BinaryFormat::MachO => (
-                    RelocationKind::MachO {
-                        value: object::macho::ARM64_RELOC_GOT_LOAD_PAGE21,
-                        relative: true,
-                    },
-                    RelocationEncoding::Generic,
-                    21,
-                ),
+                object::BinaryFormat::Elf => RelocationFlags::Elf {
+                    r_type: object::elf::R_AARCH64_ADR_GOT_PAGE,
+                },
+                object::BinaryFormat::MachO => RelocationFlags::MachO {
+                    r_type: object::macho::ARM64_RELOC_GOT_LOAD_PAGE21,
+                    r_pcrel: true,
+                    r_length: 2,
+                },
                 _ => unimplemented!("Aarch64AdrGotPage21 is not supported for this file format"),
             },
             Reloc::Aarch64Ld64GotLo12Nc => match self.object.format() {
-                object::BinaryFormat::Elf => (
-                    RelocationKind::Elf(object::elf::R_AARCH64_LD64_GOT_LO12_NC),
-                    RelocationEncoding::Generic,
-                    12,
-                ),
-                object::BinaryFormat::MachO => (
-                    RelocationKind::MachO {
-                        value: object::macho::ARM64_RELOC_GOT_LOAD_PAGEOFF12,
-                        relative: false,
-                    },
-                    RelocationEncoding::Generic,
-                    12,
-                ),
+                object::BinaryFormat::Elf => RelocationFlags::Elf {
+                    r_type: object::elf::R_AARCH64_LD64_GOT_LO12_NC,
+                },
+                object::BinaryFormat::MachO => RelocationFlags::MachO {
+                    r_type: object::macho::ARM64_RELOC_GOT_LOAD_PAGEOFF12,
+                    r_pcrel: false,
+                    r_length: 2,
+                },
                 _ => unimplemented!("Aarch64Ld64GotLo12Nc is not supported for this file format"),
             },
-            Reloc::S390xPCRel32Dbl => (RelocationKind::Relative, RelocationEncoding::S390xDbl, 32),
-            Reloc::S390xPLTRel32Dbl => (
-                RelocationKind::PltRelative,
-                RelocationEncoding::S390xDbl,
-                32,
-            ),
+            Reloc::S390xPCRel32Dbl => RelocationFlags::Generic {
+                kind: RelocationKind::Relative,
+                encoding: RelocationEncoding::S390xDbl,
+                size: 32,
+            },
+            Reloc::S390xPLTRel32Dbl => RelocationFlags::Generic {
+                kind: RelocationKind::PltRelative,
+                encoding: RelocationEncoding::S390xDbl,
+                size: 32,
+            },
             Reloc::S390xTlsGd64 => {
                 assert_eq!(
                     self.object.format(),
                     object::BinaryFormat::Elf,
                     "S390xTlsGd64 is not supported for this file format"
                 );
-                (
-                    RelocationKind::Elf(object::elf::R_390_TLS_GD64),
-                    RelocationEncoding::Generic,
-                    64,
-                )
+                RelocationFlags::Elf {
+                    r_type: object::elf::R_390_TLS_GD64,
+                }
             }
             Reloc::S390xTlsGdCall => {
                 assert_eq!(
@@ -789,23 +807,19 @@ impl ObjectModule {
                     object::BinaryFormat::Elf,
                     "S390xTlsGdCall is not supported for this file format"
                 );
-                (
-                    RelocationKind::Elf(object::elf::R_390_TLS_GDCALL),
-                    RelocationEncoding::Generic,
-                    0,
-                )
+                RelocationFlags::Elf {
+                    r_type: object::elf::R_390_TLS_GDCALL,
+                }
             }
-            Reloc::RiscvCall => {
+            Reloc::RiscvCallPlt => {
                 assert_eq!(
                     self.object.format(),
                     object::BinaryFormat::Elf,
-                    "RiscvCall is not supported for this file format"
+                    "RiscvCallPlt is not supported for this file format"
                 );
-                (
-                    RelocationKind::Elf(object::elf::R_RISCV_CALL),
-                    RelocationEncoding::Generic,
-                    0,
-                )
+                RelocationFlags::Elf {
+                    r_type: object::elf::R_RISCV_CALL_PLT,
+                }
             }
             Reloc::RiscvTlsGdHi20 => {
                 assert_eq!(
@@ -813,11 +827,9 @@ impl ObjectModule {
                     object::BinaryFormat::Elf,
                     "RiscvTlsGdHi20 is not supported for this file format"
                 );
-                (
-                    RelocationKind::Elf(object::elf::R_RISCV_TLS_GD_HI20),
-                    RelocationEncoding::Generic,
-                    0,
-                )
+                RelocationFlags::Elf {
+                    r_type: object::elf::R_RISCV_TLS_GD_HI20,
+                }
             }
             Reloc::RiscvPCRelLo12I => {
                 assert_eq!(
@@ -825,11 +837,19 @@ impl ObjectModule {
                     object::BinaryFormat::Elf,
                     "RiscvPCRelLo12I is not supported for this file format"
                 );
-                (
-                    RelocationKind::Elf(object::elf::R_RISCV_PCREL_LO12_I),
-                    RelocationEncoding::Generic,
-                    0,
-                )
+                RelocationFlags::Elf {
+                    r_type: object::elf::R_RISCV_PCREL_LO12_I,
+                }
+            }
+            Reloc::RiscvGotHi20 => {
+                assert_eq!(
+                    self.object.format(),
+                    object::BinaryFormat::Elf,
+                    "RiscvGotHi20 is not supported for this file format"
+                );
+                RelocationFlags::Elf {
+                    r_type: object::elf::R_RISCV_GOT_HI20,
+                }
             }
             // FIXME
             reloc => unimplemented!("{:?}", reloc),
@@ -838,10 +858,8 @@ impl ObjectModule {
         ObjectRelocRecord {
             offset: record.offset,
             name: record.name.clone(),
-            kind,
-            encoding,
-            size,
-            addend,
+            flags,
+            addend: record.addend,
         }
     }
 }
@@ -902,8 +920,6 @@ struct SymbolRelocs {
 struct ObjectRelocRecord {
     offset: CodeOffset,
     name: ModuleRelocTarget,
-    kind: RelocationKind,
-    encoding: RelocationEncoding,
-    size: u8,
+    flags: RelocationFlags,
     addend: Addend,
 }
diff --git a/cranelift/object/src/lib.rs b/cranelift/object/src/lib.rs
index dd934af63765..6967f890df4f 100644
--- a/cranelift/object/src/lib.rs
+++ b/cranelift/object/src/lib.rs
@@ -2,13 +2,7 @@
 //!
 //! This re-exports `object` so you don't have to explicitly keep the versions in sync.
 
-#![deny(
-    missing_docs,
-    trivial_numeric_casts,
-    unused_extern_crates,
-    unstable_features
-)]
-#![warn(unused_import_braces)]
+#![deny(missing_docs)]
 
 mod backend;
 
diff --git a/cranelift/object/tests/basic.rs b/cranelift/object/tests/basic.rs
index d918f55e343d..51b500dc8d3e 100644
--- a/cranelift/object/tests/basic.rs
+++ b/cranelift/object/tests/basic.rs
@@ -91,7 +91,7 @@ fn switch_error() {
         let bb1 = bcx.create_block();
         let bb2 = bcx.create_block();
         let bb3 = bcx.create_block();
-        println!("{} {} {} {} {}", start, bb0, bb1, bb2, bb3);
+        println!("{start} {bb0} {bb1} {bb2} {bb3}");
 
         bcx.declare_var(Variable::new(0), types::I32);
         bcx.declare_var(Variable::new(1), types::I32);
@@ -139,7 +139,7 @@ fn switch_error() {
         Err(err) => {
             let pretty_error =
                 cranelift_codegen::print_errors::pretty_verifier_error(&func, None, err);
-            panic!("pretty_error:\n{}", pretty_error);
+            panic!("pretty_error:\n{pretty_error}");
         }
     }
 }
diff --git a/cranelift/reader/Cargo.toml b/cranelift/reader/Cargo.toml
index 36f77d6cb7fb..29579bc8aa72 100644
--- a/cranelift/reader/Cargo.toml
+++ b/cranelift/reader/Cargo.toml
@@ -1,16 +1,20 @@
 [package]
 authors = ["The Cranelift Project Developers"]
 name = "cranelift-reader"
-version = "0.101.0"
+version = "0.112.0"
 description = "Cranelift textual IR reader"
 license = "Apache-2.0 WITH LLVM-exception"
 documentation = "https://docs.rs/cranelift-reader"
 repository = "https://github.com/bytecodealliance/wasmtime"
 readme = "README.md"
 edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
 
 [dependencies]
-anyhow.workspace = true
+anyhow = { workspace = true, features = ['std'] }
 cranelift-codegen = { workspace = true }
 smallvec = { workspace = true }
-target-lexicon = { workspace = true }
+target-lexicon = { workspace = true, features = ['std'] }
diff --git a/cranelift/reader/src/isaspec.rs b/cranelift/reader/src/isaspec.rs
index c27743a382c5..4fe7d27ffb9d 100644
--- a/cranelift/reader/src/isaspec.rs
+++ b/cranelift/reader/src/isaspec.rs
@@ -64,12 +64,12 @@ impl From<ParseOptionError> for ParseError {
             ParseOptionError::Generic(err) => err,
             ParseOptionError::UnknownFlag { loc, name } => Self {
                 location: loc,
-                message: format!("unknown setting '{}'", name),
+                message: format!("unknown setting '{name}'"),
                 is_warning: false,
             },
             ParseOptionError::UnknownValue { loc, name, value } => Self {
                 location: loc,
-                message: format!("unknown setting '{}={}'", name, value),
+                message: format!("unknown setting '{name}={value}'"),
                 is_warning: false,
             },
         }
diff --git a/cranelift/reader/src/lexer.rs b/cranelift/reader/src/lexer.rs
index e2c80cf93db9..28d75feb5137 100644
--- a/cranelift/reader/src/lexer.rs
+++ b/cranelift/reader/src/lexer.rs
@@ -28,11 +28,12 @@ pub enum Token<'a> {
     Dot,                   // '.'
     Colon,                 // ':'
     Equal,                 // '='
-    Not,                   // '!'
+    Bang,                  // '!'
+    At,                    // '@'
     Arrow,                 // '->'
     Float(&'a str),        // Floating point immediate
     Integer(&'a str),      // Integer immediate
-    Type(types::Type),     // i32, f32, b32x4, ...
+    Type(types::Type),     // i32, f32, i32x4, ...
     DynamicType(u32),      // dt5
     Value(Value),          // v12, v7
     Block(Block),          // block3
@@ -40,7 +41,7 @@ pub enum Token<'a> {
     StackSlot(u32),        // ss3
     DynamicStackSlot(u32), // dss4
     GlobalValue(u32),      // gv3
-    Table(u32),            // table2
+    MemoryType(u32),       // mt0
     Constant(u32),         // const2
     FuncRef(u32),          // fn2
     SigRef(u32),           // sig2
@@ -344,7 +345,7 @@ impl<'a> Lexer<'a> {
             "dss" => Some(Token::DynamicStackSlot(number)),
             "dt" => Some(Token::DynamicType(number)),
             "gv" => Some(Token::GlobalValue(number)),
-            "table" => Some(Token::Table(number)),
+            "mt" => Some(Token::MemoryType(number)),
             "const" => Some(Token::Constant(number)),
             "fn" => Some(Token::FuncRef(number)),
             "sig" => Some(Token::SigRef(number)),
@@ -368,10 +369,10 @@ impl<'a> Lexer<'a> {
             "i32" => types::I32,
             "i64" => types::I64,
             "i128" => types::I128,
+            "f16" => types::F16,
             "f32" => types::F32,
             "f64" => types::F64,
-            "r32" => types::R32,
-            "r64" => types::R64,
+            "f128" => types::F128,
             _ => return None,
         };
         if is_vector {
@@ -439,12 +440,17 @@ impl<'a> Lexer<'a> {
         token(Token::HexSequence(&self.source[begin..end]), loc)
     }
 
-    fn scan_srcloc(&mut self) -> Result<LocatedToken<'a>, LocatedError> {
-        let loc = self.loc();
-        let begin = self.pos + 1;
-
-        assert_eq!(self.lookahead, Some('@'));
+    /// Given that we've consumed an `@` character, are we looking at a source
+    /// location?
+    fn looking_at_srcloc(&self) -> bool {
+        match self.lookahead {
+            Some(c) => char::is_digit(c, 16),
+            _ => false,
+        }
+    }
 
+    fn scan_srcloc(&mut self, pos: usize, loc: Location) -> Result<LocatedToken<'a>, LocatedError> {
+        let begin = pos + 1;
         while let Some(c) = self.next_ch() {
             if !char::is_digit(c, 16) {
                 break;
@@ -474,7 +480,7 @@ impl<'a> Lexer<'a> {
                 Some('.') => Some(self.scan_char(Token::Dot)),
                 Some(':') => Some(self.scan_char(Token::Colon)),
                 Some('=') => Some(self.scan_char(Token::Equal)),
-                Some('!') => Some(self.scan_char(Token::Not)),
+                Some('!') => Some(self.scan_char(Token::Bang)),
                 Some('+') => Some(self.scan_number()),
                 Some('*') => Some(self.scan_char(Token::Multiply)),
                 Some('-') => {
@@ -495,7 +501,16 @@ impl<'a> Lexer<'a> {
                 Some('%') => Some(self.scan_name()),
                 Some('"') => Some(self.scan_string()),
                 Some('#') => Some(self.scan_hex_sequence()),
-                Some('@') => Some(self.scan_srcloc()),
+                Some('@') => {
+                    let pos = self.pos;
+                    let loc = self.loc();
+                    self.next_ch();
+                    if self.looking_at_srcloc() {
+                        Some(self.scan_srcloc(pos, loc))
+                    } else {
+                        Some(token(Token::At, loc))
+                    }
+                }
                 // all ascii whitespace
                 Some(' ') | Some('\x09'..='\x0d') => {
                     self.next_ch();
@@ -513,11 +528,7 @@ impl<'a> Lexer<'a> {
 
 #[cfg(test)]
 mod tests {
-    use super::trailing_digits;
     use super::*;
-    use crate::error::Location;
-    use cranelift_codegen::ir::types;
-    use cranelift_codegen::ir::{Block, Value};
 
     #[test]
     fn digits() {
@@ -615,7 +626,7 @@ mod tests {
     fn lex_identifiers() {
         let mut lex = Lexer::new(
             "v0 v00 vx01 block1234567890 block5234567890 v1x vx1 vxvx4 \
-             function0 function i8 i32x4 f32x5",
+             function0 function i8 i32x4 f32x5 f16 f128",
         );
         assert_eq!(
             lex.next(),
@@ -636,6 +647,8 @@ mod tests {
         assert_eq!(lex.next(), token(Token::Type(types::I8), 1));
         assert_eq!(lex.next(), token(Token::Type(types::I32X4), 1));
         assert_eq!(lex.next(), token(Token::Identifier("f32x5"), 1));
+        assert_eq!(lex.next(), token(Token::Type(types::F16), 1));
+        assert_eq!(lex.next(), token(Token::Type(types::F128), 1));
         assert_eq!(lex.next(), None);
     }
 
diff --git a/cranelift/reader/src/lib.rs b/cranelift/reader/src/lib.rs
index c54435d80044..2ac7570eb269 100644
--- a/cranelift/reader/src/lib.rs
+++ b/cranelift/reader/src/lib.rs
@@ -3,13 +3,7 @@
 //! The `cranelift_reader` library supports reading .clif files. This functionality is needed for
 //! testing Cranelift, but is not essential for a JIT compiler.
 
-#![deny(
-    missing_docs,
-    trivial_numeric_casts,
-    unused_extern_crates,
-    unstable_features
-)]
-#![warn(unused_import_braces)]
+#![deny(missing_docs)]
 
 pub use crate::error::{Location, ParseError, ParseResult};
 pub use crate::isaspec::{parse_option, parse_options, IsaSpec, ParseOptionError};
@@ -64,7 +58,7 @@ pub fn parse_sets_and_triple(flag_set: &[String], flag_triple: &str) -> Result<O
                 unknown_settings.push(name);
             }
             Err(ParseOptionError::UnknownValue { name, value, .. }) => {
-                unknown_settings.push(format!("{}={}", name, value));
+                unknown_settings.push(format!("{name}={value}"));
             }
             Err(ParseOptionError::Generic(err)) => return Err(err.into()),
             Ok(()) => {}
diff --git a/cranelift/reader/src/parser.rs b/cranelift/reader/src/parser.rs
index 28b6ae18600c..a4160305a726 100644
--- a/cranelift/reader/src/parser.rs
+++ b/cranelift/reader/src/parser.rs
@@ -9,18 +9,20 @@ use crate::testcommand::TestCommand;
 use crate::testfile::{Comment, Details, Feature, TestFile};
 use cranelift_codegen::data_value::DataValue;
 use cranelift_codegen::entity::{EntityRef, PrimaryMap};
-use cranelift_codegen::ir::entities::{AnyEntity, DynamicType};
-use cranelift_codegen::ir::immediates::{Ieee32, Ieee64, Imm64, Offset32, Uimm32, Uimm64};
+use cranelift_codegen::ir::entities::{AnyEntity, DynamicType, MemoryType};
+use cranelift_codegen::ir::immediates::{
+    Ieee128, Ieee16, Ieee32, Ieee64, Imm64, Offset32, Uimm32, Uimm64,
+};
 use cranelift_codegen::ir::instructions::{InstructionData, InstructionFormat, VariableArgs};
+use cranelift_codegen::ir::pcc::{BaseExpr, Expr, Fact};
 use cranelift_codegen::ir::types;
-use cranelift_codegen::ir::types::INVALID;
 use cranelift_codegen::ir::types::*;
 use cranelift_codegen::ir::{self, UserExternalNameRef};
 use cranelift_codegen::ir::{
     AbiParam, ArgumentExtension, ArgumentPurpose, Block, Constant, ConstantData, DynamicStackSlot,
     DynamicStackSlotData, DynamicTypeData, ExtFuncData, ExternalName, FuncRef, Function,
-    GlobalValue, GlobalValueData, JumpTableData, MemFlags, Opcode, SigRef, Signature, StackSlot,
-    StackSlotData, StackSlotKind, Table, TableData, Type, UserFuncName, Value,
+    GlobalValue, GlobalValueData, JumpTableData, MemFlags, MemoryTypeData, MemoryTypeField, Opcode,
+    SigRef, Signature, StackSlot, StackSlotData, StackSlotKind, UserFuncName, Value,
 };
 use cranelift_codegen::isa::{self, CallConv};
 use cranelift_codegen::packed_option::ReservedValue;
@@ -179,7 +181,7 @@ pub fn parse_test<'a>(text: &'a str, options: ParseOptions<'a>) -> ParseResult<T
 ///    or `print`
 ///  - `Ok(Some(command))` if the comment is intended as a `RunCommand` and can be parsed to one
 ///  - `Err` otherwise.
-pub fn parse_run_command<'a>(text: &str, signature: &Signature) -> ParseResult<Option<RunCommand>> {
+pub fn parse_run_command(text: &str, signature: &Signature) -> ParseResult<Option<RunCommand>> {
     let _tt = timing::parse_text();
     // We remove leading spaces and semi-colons for convenience here instead of at the call sites
     // since this function will be attempting to parse a RunCommand from a CLIF comment.
@@ -245,8 +247,11 @@ impl Context {
     fn add_ss(&mut self, ss: StackSlot, data: StackSlotData, loc: Location) -> ParseResult<()> {
         self.map.def_ss(ss, loc)?;
         while self.function.sized_stack_slots.next_key().index() <= ss.index() {
-            self.function
-                .create_sized_stack_slot(StackSlotData::new(StackSlotKind::ExplicitSlot, 0));
+            self.function.create_sized_stack_slot(StackSlotData::new(
+                StackSlotKind::ExplicitSlot,
+                0,
+                0,
+            ));
         }
         self.function.sized_stack_slots[ss] = data;
         Ok(())
@@ -303,7 +308,13 @@ impl Context {
     }
 
     // Allocate a global value slot.
-    fn add_gv(&mut self, gv: GlobalValue, data: GlobalValueData, loc: Location) -> ParseResult<()> {
+    fn add_gv(
+        &mut self,
+        gv: GlobalValue,
+        data: GlobalValueData,
+        maybe_fact: Option<Fact>,
+        loc: Location,
+    ) -> ParseResult<()> {
         self.map.def_gv(gv, loc)?;
         while self.function.global_values.next_key().index() <= gv.index() {
             self.function.create_global_value(GlobalValueData::Symbol {
@@ -314,6 +325,19 @@ impl Context {
             });
         }
         self.function.global_values[gv] = data;
+        if let Some(fact) = maybe_fact {
+            self.function.global_value_facts[gv] = Some(fact);
+        }
+        Ok(())
+    }
+
+    // Allocate a memory-type slot.
+    fn add_mt(&mut self, mt: MemoryType, data: MemoryTypeData, loc: Location) -> ParseResult<()> {
+        self.map.def_mt(mt, loc)?;
+        while self.function.memory_types.next_key().index() <= mt.index() {
+            self.function.create_memory_type(MemoryTypeData::default());
+        }
+        self.function.memory_types[mt] = data;
         Ok(())
     }
 
@@ -326,30 +350,6 @@ impl Context {
         }
     }
 
-    // Allocate a table slot.
-    fn add_table(&mut self, table: Table, data: TableData, loc: Location) -> ParseResult<()> {
-        while self.function.tables.next_key().index() <= table.index() {
-            self.function.create_table(TableData {
-                base_gv: GlobalValue::reserved_value(),
-                min_size: Uimm64::new(0),
-                bound_gv: GlobalValue::reserved_value(),
-                element_size: Uimm64::new(0),
-                index_type: INVALID,
-            });
-        }
-        self.function.tables[table] = data;
-        self.map.def_table(table, loc)
-    }
-
-    // Resolve a reference to a table.
-    fn check_table(&self, table: Table, loc: Location) -> ParseResult<()> {
-        if !self.map.contains_table(table) {
-            err!(loc, "undefined table {}", table)
-        } else {
-            Ok(())
-        }
-    }
-
     // Allocate a new signature.
     fn add_sig(
         &mut self,
@@ -644,12 +644,12 @@ impl<'a> Parser<'a> {
         err!(self.loc, err_msg)
     }
 
-    // Match and consume a table reference.
-    fn match_table(&mut self, err_msg: &str) -> ParseResult<Table> {
-        if let Some(Token::Table(table)) = self.token() {
+    // Match and consume a memory-type reference.
+    fn match_mt(&mut self, err_msg: &str) -> ParseResult<MemoryType> {
+        if let Some(Token::MemoryType(mt)) = self.token() {
             self.consume();
-            if let Some(table) = Table::with_number(table) {
-                return Ok(table);
+            if let Some(mt) = MemoryType::with_number(mt) {
+                return Ok(mt);
             }
         }
         err!(self.loc, err_msg)
@@ -721,8 +721,7 @@ impl<'a> Parser<'a> {
             self.consume();
             text.parse().map_err(|e| {
                 self.error(&format!(
-                    "expected hexadecimal immediate, failed to parse: {}",
-                    e
+                    "expected hexadecimal immediate, failed to parse: {e}"
                 ))
             })
         } else {
@@ -751,8 +750,7 @@ impl<'a> Parser<'a> {
             Ok(constant_data)
         } else {
             Err(self.error(&format!(
-                "expected parsed constant to have {} bytes",
-                expected_size
+                "expected parsed constant to have {expected_size} bytes"
             )))
         }
     }
@@ -788,9 +786,9 @@ impl<'a> Parser<'a> {
         if let Some(Token::Integer(text)) = self.token() {
             self.consume();
             // Lexer just gives us raw text that looks like an integer.
-            if text.starts_with("0x") {
+            if let Some(num) = text.strip_prefix("0x") {
                 // Parse it as a u8 in hexadecimal form.
-                u8::from_str_radix(&text[2..], 16)
+                u8::from_str_radix(num, 16)
                     .map_err(|_| self.error("unable to parse u8 as a hexadecimal immediate"))
             } else {
                 // Parse it as a u8 to check for overflow and other issues.
@@ -857,6 +855,18 @@ impl<'a> Parser<'a> {
         Ok(Imm64::new(0))
     }
 
+    // Match and consume an Ieee16 immediate.
+    fn match_ieee16(&mut self, err_msg: &str) -> ParseResult<Ieee16> {
+        if let Some(Token::Float(text)) = self.token() {
+            self.consume();
+            // Lexer just gives us raw text that looks like a float.
+            // Parse it as an Ieee16 to check for the right number of digits and other issues.
+            text.parse().map_err(|e| self.error(e))
+        } else {
+            err!(self.loc, err_msg)
+        }
+    }
+
     // Match and consume an Ieee32 immediate.
     fn match_ieee32(&mut self, err_msg: &str) -> ParseResult<Ieee32> {
         if let Some(Token::Float(text)) = self.token() {
@@ -881,6 +891,18 @@ impl<'a> Parser<'a> {
         }
     }
 
+    // Match and consume an Ieee128 immediate.
+    fn match_ieee128(&mut self, err_msg: &str) -> ParseResult<Ieee128> {
+        if let Some(Token::Float(text)) = self.token() {
+            self.consume();
+            // Lexer just gives us raw text that looks like a float.
+            // Parse it as an Ieee128 to check for the right number of digits and other issues.
+            text.parse().map_err(|e| self.error(e))
+        } else {
+            err!(self.loc, err_msg)
+        }
+    }
+
     // Match and consume an enumerated immediate, like one of the condition codes.
     fn match_enum<T: FromStr>(&mut self, err_msg: &str) -> ParseResult<T> {
         if let Some(Token::Identifier(text)) = self.token() {
@@ -892,16 +914,18 @@ impl<'a> Parser<'a> {
     }
 
     // Match and a consume a possibly empty sequence of memory operation flags.
-    fn optional_memflags(&mut self) -> MemFlags {
+    fn optional_memflags(&mut self) -> ParseResult<MemFlags> {
         let mut flags = MemFlags::new();
         while let Some(Token::Identifier(text)) = self.token() {
-            if flags.set_by_name(text) {
-                self.consume();
-            } else {
-                break;
+            match flags.set_by_name(text) {
+                Ok(true) => {
+                    self.consume();
+                }
+                Ok(false) => break,
+                Err(msg) => return err!(self.loc, msg),
             }
         }
-        flags
+        Ok(flags)
     }
 
     // Match and consume an identifier.
@@ -1013,7 +1037,7 @@ impl<'a> Parser<'a> {
                     .finish(settings::Flags::new(flag_builder.clone()))
                     .map_err(|e| ParseError {
                         location: loc,
-                        message: format!("invalid ISA flags for '{}': {:?}", targ, e),
+                        message: format!("invalid ISA flags for '{targ}': {e:?}"),
                         is_warning: false,
                     })?,
             );
@@ -1105,10 +1129,7 @@ impl<'a> Parser<'a> {
                             .finish(settings::Flags::new(flag_builder.clone()))
                             .map_err(|e| ParseError {
                                 location: loc,
-                                message: format!(
-                                    "invalid ISA flags for '{}': {:?}",
-                                    target_name, e
-                                ),
+                                message: format!("invalid ISA flags for '{target_name}': {e:?}"),
                                 is_warning: false,
                             })?,
                     );
@@ -1135,7 +1156,7 @@ impl<'a> Parser<'a> {
         let mut list = Vec::new();
         while self.token() == Some(Token::Identifier("feature")) {
             self.consume();
-            let has = !self.optional(Token::Not);
+            let has = !self.optional(Token::Bang);
             match (self.token(), has) {
                 (Some(Token::String(flag)), true) => list.push(Feature::With(flag)),
                 (Some(Token::String(flag)), false) => list.push(Feature::Without(flag)),
@@ -1347,14 +1368,20 @@ impl<'a> Parser<'a> {
         }
 
         // The calling convention is optional.
-        if let Some(Token::Identifier(text)) = self.token() {
-            match text.parse() {
+        match self.token() {
+            Some(Token::Identifier(text)) => match text.parse() {
                 Ok(cc) => {
                     self.consume();
                     sig.call_conv = cc;
                 }
                 _ => return err!(self.loc, "unknown calling convention: {}", text),
+            },
+
+            Some(Token::Cold) => {
+                self.consume();
+                sig.call_conv = CallConv::Cold;
             }
+            _ => {}
         }
 
         Ok(sig)
@@ -1445,12 +1472,12 @@ impl<'a> Parser<'a> {
                 Some(Token::GlobalValue(..)) => {
                     self.start_gathering_comments();
                     self.parse_global_value_decl()
-                        .and_then(|(gv, dat)| ctx.add_gv(gv, dat, self.loc))
+                        .and_then(|(gv, dat, maybe_fact)| ctx.add_gv(gv, dat, maybe_fact, self.loc))
                 }
-                Some(Token::Table(..)) => {
+                Some(Token::MemoryType(..)) => {
                     self.start_gathering_comments();
-                    self.parse_table_decl()
-                        .and_then(|(table, dat)| ctx.add_table(table, dat, self.loc))
+                    self.parse_memory_type_decl()
+                        .and_then(|(mt, dat)| ctx.add_mt(mt, dat, self.loc))
                 }
                 Some(Token::SigRef(..)) => {
                     self.start_gathering_comments();
@@ -1486,6 +1513,7 @@ impl<'a> Parser<'a> {
     //                   | "spill_slot"
     //                   | "incoming_arg"
     //                   | "outgoing_arg"
+    // stack-slot-flag ::= "align" "=" Bytes
     fn parse_stack_slot_decl(&mut self) -> ParseResult<(StackSlot, StackSlotData)> {
         let ss = self.match_ss("expected stack slot number: ss«n»")?;
         self.match_token(Token::Equal, "expected '=' in stack slot declaration")?;
@@ -1501,7 +1529,30 @@ impl<'a> Parser<'a> {
         if bytes > i64::from(u32::MAX) {
             return err!(self.loc, "stack slot too large");
         }
-        let data = StackSlotData::new(kind, bytes as u32);
+
+        // Parse flags.
+        let align = if self.token() == Some(Token::Comma) {
+            self.consume();
+            self.match_token(
+                Token::Identifier("align"),
+                "expected a valid stack-slot flag (currently only `align`)",
+            )?;
+            self.match_token(Token::Equal, "expected `=` after flag")?;
+            let align: i64 = self
+                .match_imm64("expected alignment-size after `align` flag")?
+                .into();
+            u32::try_from(align)
+                .map_err(|_| self.error("alignment must be a 32-bit unsigned integer"))?
+        } else {
+            1
+        };
+
+        if !align.is_power_of_two() {
+            return err!(self.loc, "stack slot alignment is not a power of two");
+        }
+        let align_shift = u8::try_from(align.ilog2()).unwrap(); // Always succeeds: range 0..=31.
+
+        let data = StackSlotData::new(kind, bytes as u32, align_shift);
 
         // Collect any trailing comments.
         self.token();
@@ -1546,16 +1597,25 @@ impl<'a> Parser<'a> {
 
     // Parse a global value decl.
     //
-    // global-val-decl ::= * GlobalValue(gv) "=" global-val-desc
+    // global-val-decl ::= * GlobalValue(gv) [ "!" fact ] "=" global-val-desc
     // global-val-desc ::= "vmctx"
     //                   | "load" "." type "notrap" "aligned" GlobalValue(base) [offset]
     //                   | "iadd_imm" "(" GlobalValue(base) ")" imm64
     //                   | "symbol" ["colocated"] name + imm64
     //                   | "dyn_scale_target_const" "." type
     //
-    fn parse_global_value_decl(&mut self) -> ParseResult<(GlobalValue, GlobalValueData)> {
+    fn parse_global_value_decl(
+        &mut self,
+    ) -> ParseResult<(GlobalValue, GlobalValueData, Option<Fact>)> {
         let gv = self.match_gv("expected global value number: gv«n»")?;
 
+        let fact = if self.token() == Some(Token::Bang) {
+            self.consume();
+            Some(self.parse_fact()?)
+        } else {
+            None
+        };
+
         self.match_token(Token::Equal, "expected '=' in global value declaration")?;
 
         let data = match self.match_any_identifier("expected global value kind")? {
@@ -1566,7 +1626,7 @@ impl<'a> Parser<'a> {
                     "expected '.' followed by type in load global value decl",
                 )?;
                 let global_type = self.match_type("expected load type")?;
-                let flags = self.optional_memflags();
+                let flags = self.optional_memflags()?;
                 let base = self.match_gv("expected global value: gv«n»")?;
                 let offset = self.optional_offset32()?;
 
@@ -1577,7 +1637,7 @@ impl<'a> Parser<'a> {
                     base,
                     offset,
                     global_type,
-                    readonly: flags.readonly(),
+                    flags,
                 }
             }
             "iadd_imm" => {
@@ -1626,72 +1686,114 @@ impl<'a> Parser<'a> {
         self.token();
         self.claim_gathered_comments(gv);
 
-        Ok((gv, data))
+        Ok((gv, data, fact))
     }
 
-    // Parse a table decl.
-    //
-    // table-decl ::= * Table(table) "=" table-desc
-    // table-desc ::= table-style table-base { "," table-attr }
-    // table-style ::= "dynamic"
-    // table-base ::= GlobalValue(base)
-    // table-attr ::= "min" Imm64(bytes)
-    //              | "bound" Imm64(bytes)
-    //              | "element_size" Imm64(bytes)
-    //              | "index_type" type
+    // Parse one field definition in a memory-type struct decl.
     //
-    fn parse_table_decl(&mut self) -> ParseResult<(Table, TableData)> {
-        let table = self.match_table("expected table number: table«n»")?;
-        self.match_token(Token::Equal, "expected '=' in table declaration")?;
-
-        let style_name = self.match_any_identifier("expected 'static' or 'dynamic'")?;
-
-        // table-desc ::= table-style * table-base { "," table-attr }
-        // table-base ::= * GlobalValue(base)
-        let base = match self.token() {
-            Some(Token::GlobalValue(base_num)) => match GlobalValue::with_number(base_num) {
-                Some(gv) => gv,
-                None => return err!(self.loc, "invalid global value number for table base"),
-            },
-            _ => return err!(self.loc, "expected table base"),
+    // memory-type-field ::=  offset ":" type ["readonly"] [ "!" fact ]
+    // offset ::= uimm64
+    fn parse_memory_type_field(&mut self) -> ParseResult<MemoryTypeField> {
+        let offset: u64 = self
+            .match_uimm64(
+                "expected u64 constant value for field offset in struct memory-type declaration",
+            )?
+            .into();
+        self.match_token(
+            Token::Colon,
+            "expected colon after field offset in struct memory-type declaration",
+        )?;
+        let ty = self.match_type("expected type for field in struct memory-type declaration")?;
+        let readonly = if self.token() == Some(Token::Identifier("readonly")) {
+            self.consume();
+            true
+        } else {
+            false
         };
-        self.consume();
-
-        let mut data = TableData {
-            base_gv: base,
-            min_size: 0.into(),
-            bound_gv: GlobalValue::reserved_value(),
-            element_size: 0.into(),
-            index_type: ir::types::I32,
+        let fact = if self.token() == Some(Token::Bang) {
+            self.consume();
+            let fact = self.parse_fact()?;
+            Some(fact)
+        } else {
+            None
         };
+        Ok(MemoryTypeField {
+            offset,
+            ty,
+            readonly,
+            fact,
+        })
+    }
 
-        // table-desc ::= * { "," table-attr }
-        while self.optional(Token::Comma) {
-            match self.match_any_identifier("expected table attribute name")? {
-                "min" => {
-                    data.min_size = self.match_uimm64("expected integer min size")?;
-                }
-                "bound" => {
-                    data.bound_gv = match style_name {
-                        "dynamic" => self.match_gv("expected gv bound")?,
-                        t => return err!(self.loc, "unknown table style '{}'", t),
-                    };
-                }
-                "element_size" => {
-                    data.element_size = self.match_uimm64("expected integer element size")?;
-                }
-                "index_type" => {
-                    data.index_type = self.match_type("expected index type")?;
+    // Parse a memory-type decl.
+    //
+    // memory-type-decl ::= MemoryType(mt) "=" memory-type-desc
+    // memory-type-desc ::= "struct" size "{" memory-type-field,* "}"
+    //                    | "memory" size
+    //                    | "dynamic_memory" GlobalValue "+" offset
+    //                    | "empty"
+    // size ::= uimm64
+    // offset ::= uimm64
+    fn parse_memory_type_decl(&mut self) -> ParseResult<(MemoryType, MemoryTypeData)> {
+        let mt = self.match_mt("expected memory type number: mt«n»")?;
+        self.match_token(Token::Equal, "expected '=' in memory type declaration")?;
+
+        let data = match self.token() {
+            Some(Token::Identifier("struct")) => {
+                self.consume();
+                let size: u64 = self.match_uimm64("expected u64 constant value for struct size in struct memory-type declaration")?.into();
+                self.match_token(Token::LBrace, "expected opening brace to start struct fields in struct memory-type declaration")?;
+                let mut fields = vec![];
+                while self.token() != Some(Token::RBrace) {
+                    let field = self.parse_memory_type_field()?;
+                    fields.push(field);
+                    if self.token() == Some(Token::Comma) {
+                        self.consume();
+                    } else {
+                        break;
+                    }
                 }
-                t => return err!(self.loc, "unknown table attribute '{}'", t),
+                self.match_token(
+                    Token::RBrace,
+                    "expected closing brace after struct fields in struct memory-type declaration",
+                )?;
+                MemoryTypeData::Struct { size, fields }
             }
-        }
+            Some(Token::Identifier("memory")) => {
+                self.consume();
+                let size: u64 = self.match_uimm64("expected u64 constant value for size in static-memory memory-type declaration")?.into();
+                MemoryTypeData::Memory { size }
+            }
+            Some(Token::Identifier("dynamic_memory")) => {
+                self.consume();
+                let gv = self.match_gv(
+                    "expected a global value for `dynamic_memory` memory-type declaration",
+                )?;
+                self.match_token(
+                    Token::Plus,
+                    "expected `+` after global value in `dynamic_memory` memory-type declaration",
+                )?;
+                let size: u64 = self.match_uimm64("expected u64 constant value for size offset in `dynamic_memory` memory-type declaration")?.into();
+                MemoryTypeData::DynamicMemory { gv, size }
+            }
+            Some(Token::Identifier("empty")) => {
+                self.consume();
+                MemoryTypeData::Empty
+            }
+            other => {
+                return err!(
+                    self.loc,
+                    "Unknown memory type declaration kind '{:?}'",
+                    other
+                )
+            }
+        };
 
         // Collect any trailing comments.
         self.token();
-        self.claim_gathered_comments(table);
+        self.claim_gathered_comments(mt);
 
-        Ok((table, data))
+        Ok((mt, data))
     }
 
     // Parse a signature decl.
@@ -1943,7 +2045,7 @@ impl<'a> Parser<'a> {
             // between the parsing of value aliases and the parsing of instructions.
             //
             // inst-results ::= Value(v) { "," Value(v) }
-            let results = self.parse_inst_results()?;
+            let results = self.parse_inst_results(ctx)?;
 
             for result in &results {
                 while ctx.function.dfg.num_values() <= result.index() {
@@ -1968,14 +2070,19 @@ impl<'a> Parser<'a> {
         Ok(())
     }
 
-    // Parse parenthesized list of block parameters. Returns a vector of (u32, Type) pairs with the
-    // value numbers of the defined values and the defined types.
+    // Parse parenthesized list of block parameters.
     //
-    // block-params ::= * "(" block-param { "," block-param } ")"
+    // block-params ::= * "(" ( block-param { "," block-param } )? ")"
     fn parse_block_params(&mut self, ctx: &mut Context, block: Block) -> ParseResult<()> {
-        // block-params ::= * "(" block-param { "," block-param } ")"
+        // block-params ::= * "(" ( block-param { "," block-param } )? ")"
         self.match_token(Token::LPar, "expected '(' before block parameters")?;
 
+        // block-params ::= "(" * ")"
+        if self.token() == Some(Token::RPar) {
+            self.consume();
+            return Ok(());
+        }
+
         // block-params ::= "(" * block-param { "," block-param } ")"
         self.parse_block_param(ctx, block)?;
 
@@ -1993,16 +2100,23 @@ impl<'a> Parser<'a> {
 
     // Parse a single block parameter declaration, and append it to `block`.
     //
-    // block-param ::= * Value(v) ":" Type(t) arg-loc?
+    // block-param ::= * Value(v) [ "!" fact ]  ":" Type(t) arg-loc?
     // arg-loc ::= "[" value-location "]"
     //
     fn parse_block_param(&mut self, ctx: &mut Context, block: Block) -> ParseResult<()> {
-        // block-param ::= * Value(v) ":" Type(t) arg-loc?
+        // block-param ::= * Value(v) [ "!" fact ] ":" Type(t) arg-loc?
         let v = self.match_value("block argument must be a value")?;
         let v_location = self.loc;
-        // block-param ::= Value(v) * ":" Type(t) arg-loc?
+        // block-param ::= Value(v) * [ "!" fact ]  ":" Type(t) arg-loc?
+        let fact = if self.token() == Some(Token::Bang) {
+            self.consume();
+            // block-param ::= Value(v) [ "!" * fact ]  ":" Type(t) arg-loc?
+            Some(self.parse_fact()?)
+        } else {
+            None
+        };
         self.match_token(Token::Colon, "expected ':' after block argument")?;
-        // block-param ::= Value(v) ":" * Type(t) arg-loc?
+        // block-param ::= Value(v) [ "!" fact ] ":" * Type(t) arg-loc?
 
         while ctx.function.dfg.num_values() <= v.index() {
             ctx.function.dfg.make_invalid_value_for_parser();
@@ -2012,15 +2126,246 @@ impl<'a> Parser<'a> {
         // Allocate the block argument.
         ctx.function.dfg.append_block_param_for_parser(block, t, v);
         ctx.map.def_value(v, v_location)?;
+        ctx.function.dfg.facts[v] = fact;
 
         Ok(())
     }
 
+    // Parse a "fact" for proof-carrying code, attached to a value.
+    //
+    // fact ::= "range" "(" bit-width "," min-value "," max-value ")"
+    //        | "dynamic_range" "(" bit-width "," expr "," expr ")"
+    //        | "mem" "(" memory-type "," mt-offset "," mt-offset [ "," "nullable" ] ")"
+    //        | "dynamic_mem" "(" memory-type "," expr "," expr [ "," "nullable" ] ")"
+    //        | "conflict"
+    // bit-width ::= uimm64
+    // min-value ::= uimm64
+    // max-value ::= uimm64
+    // valid-range ::= uimm64
+    // mt-offset ::= uimm64
+    fn parse_fact(&mut self) -> ParseResult<Fact> {
+        match self.token() {
+            Some(Token::Identifier("range")) => {
+                self.consume();
+                self.match_token(Token::LPar, "`range` fact needs an opening `(`")?;
+                let bit_width: u64 = self
+                    .match_uimm64("expected a bit-width value for `range` fact")?
+                    .into();
+                self.match_token(Token::Comma, "expected a comma")?;
+                let min: u64 = self
+                    .match_uimm64("expected a min value for `range` fact")?
+                    .into();
+                self.match_token(Token::Comma, "expected a comma")?;
+                let max: u64 = self
+                    .match_uimm64("expected a max value for `range` fact")?
+                    .into();
+                self.match_token(Token::RPar, "`range` fact needs a closing `)`")?;
+                let bit_width_max = match bit_width {
+                    x if x > 64 => {
+                        return Err(self.error("bitwidth must be <= 64 bits on a `range` fact"));
+                    }
+                    64 => u64::MAX,
+                    x => (1u64 << x) - 1,
+                };
+                if min > max {
+                    return Err(self.error(
+                        "min value must be less than or equal to max value on a `range` fact",
+                    ));
+                }
+                if max > bit_width_max {
+                    return Err(
+                        self.error("max value is out of range for bitwidth on a `range` fact")
+                    );
+                }
+                Ok(Fact::Range {
+                    bit_width: u16::try_from(bit_width).unwrap(),
+                    min: min.into(),
+                    max: max.into(),
+                })
+            }
+            Some(Token::Identifier("dynamic_range")) => {
+                self.consume();
+                self.match_token(Token::LPar, "`dynamic_range` fact needs an opening `(`")?;
+                let bit_width: u64 = self
+                    .match_uimm64("expected a bit-width value for `dynamic_range` fact")?
+                    .into();
+                self.match_token(Token::Comma, "expected a comma")?;
+                let min = self.parse_expr()?;
+                self.match_token(Token::Comma, "expected a comma")?;
+                let max = self.parse_expr()?;
+                self.match_token(Token::RPar, "`dynamic_range` fact needs a closing `)`")?;
+                Ok(Fact::DynamicRange {
+                    bit_width: u16::try_from(bit_width).unwrap(),
+                    min,
+                    max,
+                })
+            }
+            Some(Token::Identifier("mem")) => {
+                self.consume();
+                self.match_token(Token::LPar, "expected a `(`")?;
+                let ty = self.match_mt("expected a memory type for `mem` fact")?;
+                self.match_token(
+                    Token::Comma,
+                    "expected a comma after memory type in `mem` fact",
+                )?;
+                let min_offset: u64 = self
+                    .match_uimm64("expected a uimm64 minimum pointer offset for `mem` fact")?
+                    .into();
+                self.match_token(Token::Comma, "expected a comma after offset in `mem` fact")?;
+                let max_offset: u64 = self
+                    .match_uimm64("expected a uimm64 maximum pointer offset for `mem` fact")?
+                    .into();
+                let nullable = if self.token() == Some(Token::Comma) {
+                    self.consume();
+                    self.match_token(
+                        Token::Identifier("nullable"),
+                        "expected `nullable` in last optional field of `dynamic_mem`",
+                    )?;
+                    true
+                } else {
+                    false
+                };
+                self.match_token(Token::RPar, "expected a `)`")?;
+                Ok(Fact::Mem {
+                    ty,
+                    min_offset,
+                    max_offset,
+                    nullable,
+                })
+            }
+            Some(Token::Identifier("dynamic_mem")) => {
+                self.consume();
+                self.match_token(Token::LPar, "expected a `(`")?;
+                let ty = self.match_mt("expected a memory type for `dynamic_mem` fact")?;
+                self.match_token(
+                    Token::Comma,
+                    "expected a comma after memory type in `dynamic_mem` fact",
+                )?;
+                let min = self.parse_expr()?;
+                self.match_token(
+                    Token::Comma,
+                    "expected a comma after offset in `dynamic_mem` fact",
+                )?;
+                let max = self.parse_expr()?;
+                let nullable = if self.token() == Some(Token::Comma) {
+                    self.consume();
+                    self.match_token(
+                        Token::Identifier("nullable"),
+                        "expected `nullable` in last optional field of `dynamic_mem`",
+                    )?;
+                    true
+                } else {
+                    false
+                };
+                self.match_token(Token::RPar, "expected a `)`")?;
+                Ok(Fact::DynamicMem {
+                    ty,
+                    min,
+                    max,
+                    nullable,
+                })
+            }
+            Some(Token::Identifier("def")) => {
+                self.consume();
+                self.match_token(Token::LPar, "expected a `(`")?;
+                let value = self.match_value("expected a value number in `def` fact")?;
+                self.match_token(Token::RPar, "expected a `)`")?;
+                Ok(Fact::Def { value })
+            }
+            Some(Token::Identifier("compare")) => {
+                self.consume();
+                self.match_token(Token::LPar, "expected a `(`")?;
+                let kind = self.match_enum("expected intcc condition code in `compare` fact")?;
+                self.match_token(
+                    Token::Comma,
+                    "expected comma in `compare` fact after condition code",
+                )?;
+                let lhs = self.parse_expr()?;
+                self.match_token(Token::Comma, "expected comma in `compare` fact after LHS")?;
+                let rhs = self.parse_expr()?;
+                self.match_token(Token::RPar, "expected a `)`")?;
+                Ok(Fact::Compare { kind, lhs, rhs })
+            }
+            Some(Token::Identifier("conflict")) => {
+                self.consume();
+                Ok(Fact::Conflict)
+            }
+            _ => Err(self.error(
+                "expected a `range`, 'dynamic_range', `mem`, `dynamic_mem`, `def`, `compare` or `conflict` fact",
+            )),
+        }
+    }
+
+    // Parse a dynamic expression used in some kinds of PCC facts.
+    //
+    // expr ::= base-expr
+    //        | base-expr + uimm64  // but in-range for imm64
+    //        | base-expr - uimm64  // but in-range for imm64
+    //        | imm64
+    fn parse_expr(&mut self) -> ParseResult<Expr> {
+        if let Some(Token::Integer(_)) = self.token() {
+            let offset: i64 = self
+                .match_imm64("expected imm64 for dynamic expression")?
+                .into();
+            Ok(Expr {
+                base: BaseExpr::None,
+                offset,
+            })
+        } else {
+            let base = self.parse_base_expr()?;
+            match self.token() {
+                Some(Token::Plus) => {
+                    self.consume();
+                    let offset: u64 = self
+                        .match_uimm64(
+                            "expected uimm64 in imm64 range for offset in dynamic expression",
+                        )?
+                        .into();
+                    let offset: i64 = i64::try_from(offset).map_err(|_| {
+                        self.error("integer offset in dynamic expression is out of range")
+                    })?;
+                    Ok(Expr { base, offset })
+                }
+                Some(Token::Integer(x)) if x.starts_with("-") => {
+                    let offset: i64 = self
+                        .match_imm64("expected an imm64 range for offset in dynamic expression")?
+                        .into();
+                    Ok(Expr { base, offset })
+                }
+                _ => Ok(Expr { base, offset: 0 }),
+            }
+        }
+    }
+
+    // Parse the base part of a dynamic expression, used in some PCC facts.
+    //
+    // base-expr ::= GlobalValue(base)
+    //             | Value(base)
+    //             | "max"
+    //             | (epsilon)
+    fn parse_base_expr(&mut self) -> ParseResult<BaseExpr> {
+        match self.token() {
+            Some(Token::Identifier("max")) => {
+                self.consume();
+                Ok(BaseExpr::Max)
+            }
+            Some(Token::GlobalValue(..)) => {
+                let gv = self.match_gv("expected global value")?;
+                Ok(BaseExpr::GlobalValue(gv))
+            }
+            Some(Token::Value(..)) => {
+                let value = self.match_value("expected value")?;
+                Ok(BaseExpr::Value(value))
+            }
+            _ => Ok(BaseExpr::None),
+        }
+    }
+
     // Parse instruction results and return them.
     //
     // inst-results ::= Value(v) { "," Value(v) }
     //
-    fn parse_inst_results(&mut self) -> ParseResult<SmallVec<[Value; 1]>> {
+    fn parse_inst_results(&mut self, ctx: &mut Context) -> ParseResult<SmallVec<[Value; 1]>> {
         // Result value numbers.
         let mut results = SmallVec::new();
 
@@ -2031,10 +2376,29 @@ impl<'a> Parser<'a> {
 
             results.push(v);
 
+            let fact = if self.token() == Some(Token::Bang) {
+                self.consume();
+                // block-param ::= Value(v) [ "!" * fact ]  ":" Type(t) arg-loc?
+                Some(self.parse_fact()?)
+            } else {
+                None
+            };
+            ctx.function.dfg.facts[v] = fact;
+
             // inst-results ::= Value(v) * { "," Value(v) }
             while self.optional(Token::Comma) {
                 // inst-results ::= Value(v) { "," * Value(v) }
-                results.push(self.match_value("expected result value")?);
+                let v = self.match_value("expected result value")?;
+                results.push(v);
+
+                let fact = if self.token() == Some(Token::Bang) {
+                    self.consume();
+                    // block-param ::= Value(v) [ "!" * fact ]  ":" Type(t) arg-loc?
+                    Some(self.parse_fact()?)
+                } else {
+                    None
+                };
+                ctx.function.dfg.facts[v] = fact;
             }
         }
 
@@ -2129,13 +2493,40 @@ impl<'a> Parser<'a> {
         // instruction ::=  [inst-results "="] Opcode(opc) ["." Type] * ...
         let inst_data = self.parse_inst_operands(ctx, opcode, explicit_ctrl_type)?;
 
-        // We're done parsing the instruction now.
+        // We're done parsing the instruction data itself.
         //
-        // We still need to check that the number of result values in the source matches the opcode
-        // or function call signature. We also need to create values with the right type for all
-        // the instruction results.
+        // We still need to check that the number of result values in the source
+        // matches the opcode or function call signature. We also need to create
+        // values with the right type for all the instruction results and parse
+        // and attach stack map entries, if present.
         let ctrl_typevar = self.infer_typevar(ctx, opcode, explicit_ctrl_type, &inst_data)?;
         let inst = ctx.function.dfg.make_inst(inst_data);
+        if opcode.is_call() && !opcode.is_return() && self.optional(Token::Comma) {
+            self.match_identifier("stack_map", "expected `stack_map = [...]`")?;
+            self.match_token(Token::Equal, "expected `= [...]`")?;
+            self.match_token(Token::LBracket, "expected `[...]`")?;
+            while !self.optional(Token::RBracket) {
+                let ty = self.match_type("expected `<type> @ <slot> + <offset>`")?;
+                self.match_token(Token::At, "expected `@ <slot> + <offset>`")?;
+                let slot = self.match_ss("expected `<slot> + <offset>`")?;
+                let offset: u32 = match self.token() {
+                    Some(Token::Integer(s)) if s.starts_with('+') => {
+                        self.match_uimm32("expected a u32 offset")?.into()
+                    }
+                    _ => {
+                        self.match_token(Token::Plus, "expected `+ <offset>`")?;
+                        self.match_uimm32("expected a u32 offset")?.into()
+                    }
+                };
+                ctx.function
+                    .dfg
+                    .append_user_stack_map_entry(inst, ir::UserStackMapEntry { ty, slot, offset });
+                if !self.optional(Token::Comma) {
+                    self.match_token(Token::RBracket, "expected `,` or `]`")?;
+                    break;
+                }
+            }
+        }
         let num_results =
             ctx.function
                 .dfg
@@ -2368,7 +2759,7 @@ impl<'a> Parser<'a> {
         if self.optional(Token::Equal) {
             self.match_token(Token::Equal, "expected another =")?;
             Ok(Comparison::Equals)
-        } else if self.optional(Token::Not) {
+        } else if self.optional(Token::Bang) {
             self.match_token(Token::Equal, "expected a =")?;
             Ok(Comparison::NotEquals)
         } else {
@@ -2423,8 +2814,10 @@ impl<'a> Parser<'a> {
             I32 => DataValue::from(self.match_imm32("expected an i32")?),
             I64 => DataValue::from(Into::<i64>::into(self.match_imm64("expected an i64")?)),
             I128 => DataValue::from(self.match_imm128("expected an i128")?),
+            F16 => DataValue::from(self.match_ieee16("expected an f16")?),
             F32 => DataValue::from(self.match_ieee32("expected an f32")?),
             F64 => DataValue::from(self.match_ieee64("expected an f64")?),
+            F128 => DataValue::from(self.match_ieee128("expected an f128")?),
             _ if (ty.is_vector() || ty.is_dynamic_vector()) => {
                 let as_vec = self.match_uimm128(ty)?.into_vec();
                 if as_vec.len() == 16 {
@@ -2439,7 +2832,7 @@ impl<'a> Parser<'a> {
                     return Err(self.error("only 128-bit vectors are currently supported"));
                 }
             }
-            _ => return Err(self.error(&format!("don't know how to parse data values of: {}", ty))),
+            _ => return Err(self.error(&format!("don't know how to parse data values of: {ty}"))),
         };
         Ok(dv)
     }
@@ -2476,6 +2869,10 @@ impl<'a> Parser<'a> {
                     imm: Imm64::new(unsigned),
                 }
             }
+            InstructionFormat::UnaryIeee16 => InstructionData::UnaryIeee16 {
+                opcode,
+                imm: self.match_ieee16("expected immediate 16-bit float operand")?,
+            },
             InstructionFormat::UnaryIeee32 => InstructionData::UnaryIeee32 {
                 opcode,
                 imm: self.match_ieee32("expected immediate 32-bit float operand")?,
@@ -2490,6 +2887,9 @@ impl<'a> Parser<'a> {
                     let c = self.match_constant()?;
                     ctx.check_constant(c, self.loc)?;
                     c
+                } else if opcode == Opcode::F128const {
+                    let ieee128 = self.match_ieee128("expected immediate 128-bit float operand")?;
+                    ctx.function.dfg.constants.insert(ieee128.into())
                 } else if let Some(controlling_type) = explicit_control_type {
                     // If an explicit control type is present, we expect a sized value and insert
                     // it in the constant pool.
@@ -2732,21 +3132,8 @@ impl<'a> Parser<'a> {
                     dynamic_stack_slot: dss,
                 }
             }
-            InstructionFormat::TableAddr => {
-                let table = self.match_table("expected table identifier")?;
-                ctx.check_table(table, self.loc)?;
-                self.match_token(Token::Comma, "expected ',' between operands")?;
-                let arg = self.match_value("expected SSA value table address")?;
-                let offset = self.optional_offset32()?;
-                InstructionData::TableAddr {
-                    opcode,
-                    table,
-                    arg,
-                    offset,
-                }
-            }
             InstructionFormat::Load => {
-                let flags = self.optional_memflags();
+                let flags = self.optional_memflags()?;
                 let addr = self.match_value("expected SSA value address")?;
                 let offset = self.optional_offset32()?;
                 InstructionData::Load {
@@ -2757,7 +3144,7 @@ impl<'a> Parser<'a> {
                 }
             }
             InstructionFormat::Store => {
-                let flags = self.optional_memflags();
+                let flags = self.optional_memflags()?;
                 let arg = self.match_value("expected SSA value operand")?;
                 self.match_token(Token::Comma, "expected ',' between operands")?;
                 let addr = self.match_value("expected SSA value address")?;
@@ -2780,7 +3167,7 @@ impl<'a> Parser<'a> {
                 InstructionData::CondTrap { opcode, arg, code }
             }
             InstructionFormat::AtomicCas => {
-                let flags = self.optional_memflags();
+                let flags = self.optional_memflags()?;
                 let addr = self.match_value("expected SSA value address")?;
                 self.match_token(Token::Comma, "expected ',' between operands")?;
                 let expected = self.match_value("expected SSA value address")?;
@@ -2793,7 +3180,7 @@ impl<'a> Parser<'a> {
                 }
             }
             InstructionFormat::AtomicRmw => {
-                let flags = self.optional_memflags();
+                let flags = self.optional_memflags()?;
                 let op = self.match_enum("expected AtomicRmwOp")?;
                 let addr = self.match_value("expected SSA value address")?;
                 self.match_token(Token::Comma, "expected ',' between operands")?;
@@ -2806,7 +3193,7 @@ impl<'a> Parser<'a> {
                 }
             }
             InstructionFormat::LoadNoOffset => {
-                let flags = self.optional_memflags();
+                let flags = self.optional_memflags()?;
                 let addr = self.match_value("expected SSA value address")?;
                 InstructionData::LoadNoOffset {
                     opcode,
@@ -2815,7 +3202,7 @@ impl<'a> Parser<'a> {
                 }
             }
             InstructionFormat::StoreNoOffset => {
-                let flags = self.optional_memflags();
+                let flags = self.optional_memflags()?;
                 let arg = self.match_value("expected SSA value operand")?;
                 self.match_token(Token::Comma, "expected ',' between operands")?;
                 let addr = self.match_value("expected SSA value address")?;
@@ -2845,14 +3232,7 @@ impl<'a> Parser<'a> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::error::ParseError;
     use crate::isaspec::IsaSpec;
-    use crate::testfile::{Comment, Details};
-    use cranelift_codegen::ir::entities::AnyEntity;
-    use cranelift_codegen::ir::types;
-    use cranelift_codegen::ir::StackSlotKind;
-    use cranelift_codegen::ir::{ArgumentExtension, ArgumentPurpose};
-    use cranelift_codegen::isa::CallConv;
 
     #[test]
     fn argument_type() {
@@ -2893,7 +3273,7 @@ mod tests {
                 let aliased_to = func.dfg.resolve_aliases(v3);
                 assert_eq!(aliased_to.to_string(), "v4");
             }
-            _ => panic!("expected value: {}", v3),
+            _ => panic!("expected value: {v3}"),
         }
     }
 
@@ -2904,12 +3284,13 @@ mod tests {
         assert_eq!(sig.returns.len(), 0);
         assert_eq!(sig.call_conv, CallConv::SystemV);
 
-        let sig2 = Parser::new("(i8 uext, f32, f64, i32 sret) -> i32 sext, f64 system_v")
-            .parse_signature()
-            .unwrap();
+        let sig2 =
+            Parser::new("(i8 uext, f16, f32, f64, f128, i32 sret) -> i32 sext, f64 system_v")
+                .parse_signature()
+                .unwrap();
         assert_eq!(
             sig2.to_string(),
-            "(i8 uext, f32, f64, i32 sret) -> i32 sext, f64 system_v"
+            "(i8 uext, f16, f32, f64, f128, i32 sret) -> i32 sext, f64 system_v"
         );
         assert_eq!(sig2.call_conv, CallConv::SystemV);
 
@@ -3494,7 +3875,7 @@ mod tests {
             "print: %default()"
         );
 
-        // Demonstrate some unparseable cases.
+        // Demonstrate some unparsable cases.
         assert!(parse("print", &sig(&[I32], &[I32])).is_err());
         assert!(parse("print:", &sig(&[], &[])).is_err());
         assert!(parse("run: ", &sig(&[], &[])).is_err());
@@ -3515,8 +3896,13 @@ mod tests {
             "1512366032949150931280199141537564007"
         );
         assert_eq!(parse("1234567", I128).to_string(), "1234567");
+        assert_eq!(parse("0x16.1", F16).to_string(), "0x1.610p4");
         assert_eq!(parse("0x32.32", F32).to_string(), "0x1.919000p5");
         assert_eq!(parse("0x64.64", F64).to_string(), "0x1.9190000000000p6");
+        assert_eq!(
+            parse("0x128.128", F128).to_string(),
+            "0x1.2812800000000000000000000000p8"
+        );
         assert_eq!(
             parse("[0 1 2 3]", I32X4).to_string(),
             "0x00000003000000020000000100000000"
diff --git a/cranelift/reader/src/run_command.rs b/cranelift/reader/src/run_command.rs
index 643ceaeee77b..0c1b2876d362 100644
--- a/cranelift/reader/src/run_command.rs
+++ b/cranelift/reader/src/run_command.rs
@@ -42,7 +42,7 @@ impl RunCommand {
                 let matched = Self::compare_results(compare, &actual, expected);
                 if !matched {
                     let actual = DisplayDataValues(&actual);
-                    return Err(format!("Failed test: {}, actual: {}", self, actual));
+                    return Err(format!("Failed test: {self}, actual: {actual}"));
                 }
             }
         }
@@ -70,10 +70,10 @@ impl RunCommand {
 impl Display for RunCommand {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         match self {
-            RunCommand::Print(invocation) => write!(f, "print: {}", invocation),
+            RunCommand::Print(invocation) => write!(f, "print: {invocation}"),
             RunCommand::Run(invocation, comparison, expected) => {
                 let expected = DisplayDataValues(expected);
-                write!(f, "run: {} {} {}", invocation, comparison, expected)
+                write!(f, "run: {invocation} {comparison} {expected}")
             }
         }
     }
diff --git a/cranelift/reader/src/sourcemap.rs b/cranelift/reader/src/sourcemap.rs
index d8c21ebb10b5..36b10f1c8d91 100644
--- a/cranelift/reader/src/sourcemap.rs
+++ b/cranelift/reader/src/sourcemap.rs
@@ -10,8 +10,8 @@ use crate::error::{Location, ParseResult};
 use crate::lexer::split_entity_name;
 use cranelift_codegen::ir::entities::{AnyEntity, DynamicType};
 use cranelift_codegen::ir::{
-    Block, Constant, DynamicStackSlot, FuncRef, GlobalValue, JumpTable, SigRef, StackSlot, Table,
-    Value,
+    Block, Constant, DynamicStackSlot, FuncRef, GlobalValue, JumpTable, MemoryType, SigRef,
+    StackSlot, Value,
 };
 use std::collections::HashMap;
 
@@ -49,11 +49,6 @@ impl SourceMap {
         self.locations.contains_key(&gv.into())
     }
 
-    /// Look up a table entity.
-    pub fn contains_table(&self, table: Table) -> bool {
-        self.locations.contains_key(&table.into())
-    }
-
     /// Look up a signature entity.
     pub fn contains_sig(&self, sig: SigRef) -> bool {
         self.locations.contains_key(&sig.into())
@@ -106,13 +101,6 @@ impl SourceMap {
                     Some(gv.into())
                 }
             }),
-            "table" => Table::with_number(num).and_then(|table| {
-                if !self.contains_table(table) {
-                    None
-                } else {
-                    Some(table.into())
-                }
-            }),
             "sig" => SigRef::with_number(num).and_then(|sig| {
                 if !self.contains_sig(sig) {
                     None
@@ -182,8 +170,8 @@ impl SourceMap {
         self.def_entity(entity.into(), loc)
     }
 
-    /// Define the table `entity`.
-    pub fn def_table(&mut self, entity: Table, loc: Location) -> ParseResult<()> {
+    /// Define the memory type `entity`.
+    pub fn def_mt(&mut self, entity: MemoryType, loc: Location) -> ParseResult<()> {
         self.def_entity(entity.into(), loc)
     }
 
diff --git a/cranelift/reader/src/testcommand.rs b/cranelift/reader/src/testcommand.rs
index 17896a070c02..1ed598b042d0 100644
--- a/cranelift/reader/src/testcommand.rs
+++ b/cranelift/reader/src/testcommand.rs
@@ -4,7 +4,7 @@
 //! The general syntax is:
 //!
 //! <pre>
-//! test <i>&lt;command&gt;</i> </i>[options]</i>...
+//! test <i>&lt;command&gt;</i> <i>[options]</i>...
 //! </pre>
 //!
 //! The options are either a single identifier flag, or setting values like `identifier=value`.
@@ -52,7 +52,7 @@ impl<'a> Display for TestCommand<'a> {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         write!(f, "{}", self.command)?;
         for opt in &self.options {
-            write!(f, " {}", opt)?;
+            write!(f, " {opt}")?;
         }
         writeln!(f)
     }
@@ -72,8 +72,8 @@ impl<'a> TestOption<'a> {
 impl<'a> Display for TestOption<'a> {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         match *self {
-            TestOption::Flag(s) => write!(f, "{}", s),
-            TestOption::Value(s, v) => write!(f, "{}={}", s, v),
+            TestOption::Flag(s) => write!(f, "{s}"),
+            TestOption::Value(s, v) => write!(f, "{s}={v}"),
         }
     }
 }
diff --git a/cranelift/run-souper.sh b/cranelift/run-souper.sh
new file mode 100755
index 000000000000..8643379f0f19
--- /dev/null
+++ b/cranelift/run-souper.sh
@@ -0,0 +1,109 @@
+#!/usr/bin/env bash
+
+# Runs Souper on the LHSes that were harvested by `clif-util
+# souper-harvest`.
+#
+# This script takes two inputs:
+#
+# 1. The `souper-check` binary, and
+# 2. The  directory of harvested  left-hand sides  (aka the `-o  $directory` you
+#    specified to `clif-util souper-harvest`).
+#
+# For a left-hand side file `foo` that Souper successfully synthesized a
+# right-hand side for, this script will write the whole optimization to a
+# sibling file named `foo.result`.
+#
+# The left-hand sides are processed in smallest-to-largest order. This helps
+# give you initial results more quickly, but does mean that progress will slow
+# down as we encounter larger and larger left-hand sides.
+#
+# Usage:
+#
+#     run-souper.sh path/to/souper-check path/to/left-hand-sides
+
+set -e
+
+# Knobs for configuring how large of right-hand sides Souper should try to
+# generate and how much time we give it to synthesize a result. Feel free to
+# play with these!
+MAX_INSTS=3
+TIMEOUT=5s
+
+# Run Souper on one left-hand side.
+function run_one {
+    local souper=$1
+    local lhs=$2
+    local rhs="$lhs".result
+
+    if [[ -f "$rhs" ]]; then
+        return
+    fi
+
+    local temp=$(mktemp)
+    local cmd="taskset --cpu-list 0-3 $souper --infer-rhs -souper-enumerative-synthesis-max-instructions=$MAX_INSTS $lhs > $temp"
+
+    set +e
+    $(which timeout) --foreground --kill-after=1s $TIMEOUT bash -c "$cmd"
+    local exit_code="$?"
+    set -e
+
+    case "$exit_code" in
+        "0")
+            # Success! Copy the RHS to its final destination.
+            cp $lhs $rhs
+            cat "$temp" >> "$rhs"
+            ;;
+
+        # SIGINT. Exit this whole script.
+        "130")
+            exit 1
+            ;;
+
+        # Timeout (regular).
+        "124")
+            return
+            ;;
+
+        # Timeout (with SIGKILL).
+        "137")
+            return
+            ;;
+
+        # Something else.
+        *)
+            exit 1
+    esac
+
+}
+
+# Run Souper on all the left-hand sides.
+function main {
+    local souper=$1
+    local lhs_dir=$2
+    local lhs_count=$(ls -1 $lhs_dir | grep -v result | wc -l)
+
+    echo "Processing $lhs_count left-hand sides."
+
+    cd "$lhs_dir"
+
+    local i=0;
+    for lhs in $(ls -1S $lhs_dir); do
+        # Ignore '.result' files.
+        if $(echo "$lhs" | grep -q result); then
+            continue;
+        fi
+
+        i=$(( $i + 1 ))
+        if (( $i % 5 == 0 )); then
+            local percent=$(( $i * 100 / $lhs_count ))
+            echo "$i / $lhs_count ($percent%)"
+        fi
+
+        run_one "$souper" "$lhs"
+    done
+
+    echo "Done!"
+}
+
+# Kick everything off!
+main $1 $2
diff --git a/cranelift/serde/Cargo.toml b/cranelift/serde/Cargo.toml
index e19cdfaa6826..f37986220b73 100644
--- a/cranelift/serde/Cargo.toml
+++ b/cranelift/serde/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "cranelift-serde"
-version = "0.101.0"
+version = "0.112.0"
 authors = ["The Cranelift Project Developers"]
 description = "Serializer/Deserializer for Cranelift IR"
 repository = "https://github.com/bytecodealliance/wasmtime"
@@ -8,6 +8,10 @@ license = "Apache-2.0 WITH LLVM-exception"
 readme = "README.md"
 keywords = ["webassembly", "serde"]
 edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
 
 [[bin]]
 name = "clif-json"
@@ -15,6 +19,6 @@ path = "src/clif-json.rs"
 
 [dependencies]
 clap = { workspace = true }
-serde_json = "1.0.26"
+serde_json = { workspace = true }
 cranelift-codegen = { workspace = true, features = ["enable-serde"] }
 cranelift-reader = { workspace = true }
diff --git a/cranelift/serde/src/clif-json.rs b/cranelift/serde/src/clif-json.rs
index 7c3c7dcf0e55..2881b0fb64d7 100644
--- a/cranelift/serde/src/clif-json.rs
+++ b/cranelift/serde/src/clif-json.rs
@@ -1,19 +1,13 @@
 //! Utility for `cranelift_serde`.
 
-#![deny(
-    missing_docs,
-    trivial_numeric_casts,
-    unused_extern_crates,
-    unstable_features
-)]
-#![warn(unused_import_braces)]
+#![deny(missing_docs)]
 
 use clap::Parser;
 use cranelift_codegen::ir::Function;
 use cranelift_reader::parse_functions;
 use std::fs::File;
+use std::io;
 use std::io::prelude::*;
-use std::io::{self, Write};
 use std::process;
 
 fn call_ser(file: &str, pretty: bool) -> Result<(), String> {
@@ -25,7 +19,7 @@ fn call_ser(file: &str, pretty: bool) -> Result<(), String> {
             } else {
                 serde_json::to_string(&funcs).unwrap()
             };
-            println!("{}", ser_str);
+            println!("{ser_str}");
             Ok(())
         }
         Err(_pe) => Err("There was a parsing error".to_string()),
@@ -37,18 +31,18 @@ fn call_de(file: &File) -> Result<(), String> {
         Result::Ok(val) => val,
         Result::Err(err) => panic!("{}", err),
     };
-    println!("{:?}", de);
+    println!("{de:?}");
     Ok(())
 }
 
 /// Cranelift JSON serializer/deserializer utility
 #[derive(Parser, Debug)]
-#[clap(about)]
+#[command(about)]
 enum Args {
     /// Serializes Cranelift IR into JSON
     Serialize {
         /// Generate pretty json
-        #[clap(long, short)]
+        #[arg(long, short)]
         pretty: bool,
 
         /// Input file for serialization
diff --git a/cranelift/src/bugpoint.rs b/cranelift/src/bugpoint.rs
index d7a52343291b..bc186d47588b 100644
--- a/cranelift/src/bugpoint.rs
+++ b/cranelift/src/bugpoint.rs
@@ -26,14 +26,14 @@ pub struct Options {
     file: PathBuf,
 
     /// Configure Cranelift settings
-    #[clap(long = "set")]
+    #[arg(long = "set")]
     settings: Vec<String>,
 
     /// Specify the target architecture.
     target: String,
 
     /// Be more verbose
-    #[clap(short, long)]
+    #[arg(short, long)]
     verbose: bool,
 }
 
@@ -62,8 +62,8 @@ pub fn run(options: &Options) -> Result<()> {
 
         match reduce(isa, func, options.verbose) {
             Ok((func, crash_msg)) => {
-                println!("Crash message: {}", crash_msg);
-                println!("\n{}", func);
+                println!("Crash message: {crash_msg}");
+                println!("\n{func}");
                 println!(
                     "{} blocks {} insts -> {} blocks {} insts",
                     orig_block_count,
@@ -72,7 +72,7 @@ pub fn run(options: &Options) -> Result<()> {
                     inst_count(&func)
                 );
             }
-            Err(err) => println!("Warning: {}", err),
+            Err(err) => println!("Warning: {err}"),
         }
     }
 
@@ -134,9 +134,9 @@ impl Mutator for RemoveInst {
             let msg = if func.layout.block_insts(prev_block).next().is_none() {
                 // Make sure empty blocks are removed, as `next_inst_ret_prev` depends on non empty blocks
                 func.layout.remove_block(prev_block);
-                format!("Remove inst {} and empty block {}", prev_inst, prev_block)
+                format!("Remove inst {prev_inst} and empty block {prev_block}")
             } else {
-                format!("Remove inst {}", prev_inst)
+                format!("Remove inst {prev_inst}")
             };
             (func, msg, ProgressStatus::ExpandedOrShrinked)
         })
@@ -272,11 +272,7 @@ impl Mutator for ReplaceInstWithTrap {
                     func.dfg.replace(prev_inst).trap(TrapCode::User(0));
                     ProgressStatus::Changed
                 };
-                (
-                    func,
-                    format!("Replace inst {} with trap", prev_inst),
-                    status,
-                )
+                (func, format!("Replace inst {prev_inst} with trap"), status)
             },
         )
     }
@@ -316,7 +312,7 @@ impl Mutator for MoveInstToEntryBlock {
             if first_block == prev_block || self.block != prev_block {
                 return (
                     func,
-                    format!("did nothing for {}", prev_inst),
+                    format!("did nothing for {prev_inst}"),
                     ProgressStatus::Skip,
                 );
             }
@@ -327,7 +323,7 @@ impl Mutator for MoveInstToEntryBlock {
 
             (
                 func,
-                format!("Move inst {} to entry block", prev_inst),
+                format!("Move inst {prev_inst} to entry block"),
                 ProgressStatus::ExpandedOrShrinked,
             )
         })
@@ -365,7 +361,7 @@ impl Mutator for RemoveBlock {
             func.layout.remove_block(self.block);
             (
                 func,
-                format!("Remove block {}", next_block),
+                format!("Remove block {next_block}"),
                 ProgressStatus::ExpandedOrShrinked,
             )
         })
@@ -701,7 +697,7 @@ impl Mutator for MergeBlocks {
         if cfg.pred_iter(block).count() != 1 {
             return Some((
                 func,
-                format!("did nothing for {}", block),
+                format!("did nothing for {block}"),
                 ProgressStatus::Skip,
             ));
         }
@@ -714,7 +710,7 @@ impl Mutator for MergeBlocks {
         if branch_dests.len() != 1 {
             return Some((
                 func,
-                format!("did nothing for {}", block),
+                format!("did nothing for {block}"),
                 ProgressStatus::Skip,
             ));
         }
@@ -774,9 +770,6 @@ fn replace_with_const(pos: &mut FuncCursor, param: Value) -> &'static str {
     } else if ty == F64 {
         pos.ins().with_result(param).f64const(0.0);
         "f64const"
-    } else if ty.is_ref() {
-        pos.ins().with_result(param).null(ty);
-        "null"
     } else if ty.is_vector() {
         let zero_data = vec![0; ty.bytes() as usize].into();
         let zero_handle = pos.func.dfg.constants.insert(zero_data);
@@ -822,23 +815,24 @@ fn inst_count(func: &Function) -> usize {
         .sum()
 }
 
-fn resolve_aliases(func: &mut Function) {
-    for block in func.stencil.layout.blocks() {
-        for inst in func.stencil.layout.block_insts(block) {
-            func.stencil.dfg.resolve_aliases_in_arguments(inst);
-        }
-    }
-}
-
 /// Resolve aliases only if function still crashes after this.
 fn try_resolve_aliases(context: &mut CrashCheckContext, func: &mut Function) {
     let mut func_with_resolved_aliases = func.clone();
-    resolve_aliases(&mut func_with_resolved_aliases);
+    func_with_resolved_aliases.dfg.resolve_all_aliases();
     if let CheckResult::Crash(_) = context.check_for_crash(&func_with_resolved_aliases) {
         *func = func_with_resolved_aliases;
     }
 }
 
+/// Remove sourcelocs if the function still crashes after they are removed, to make the reduced clif IR easier to read.
+fn try_remove_srclocs(context: &mut CrashCheckContext, func: &mut Function) {
+    let mut func_with_removed_sourcelocs = func.clone();
+    func_with_removed_sourcelocs.srclocs.clear();
+    if let CheckResult::Crash(_) = context.check_for_crash(&func_with_removed_sourcelocs) {
+        *func = func_with_removed_sourcelocs;
+    }
+}
+
 fn reduce(isa: &dyn TargetIsa, mut func: Function, verbose: bool) -> Result<(Function, String)> {
     let mut context = CrashCheckContext::new(isa);
 
@@ -847,6 +841,7 @@ fn reduce(isa: &dyn TargetIsa, mut func: Function, verbose: bool) -> Result<(Fun
     }
 
     try_resolve_aliases(&mut context, &mut func);
+    try_remove_srclocs(&mut context, &mut func);
 
     let progress_bar = ProgressBar::with_draw_target(0, ProgressDrawTarget::stdout());
     progress_bar.set_style(
@@ -916,7 +911,7 @@ fn reduce(isa: &dyn TargetIsa, mut func: Function, verbose: bool) -> Result<(Fun
                             ProgressStatus::Skip => unreachable!(),
                         };
                         if verbose {
-                            progress_bar.println(format!("{}: {}", msg, verb));
+                            progress_bar.println(format!("{msg}: {verb}"));
                         }
                     }
                 }
@@ -1059,7 +1054,6 @@ impl<'a> CrashCheckContext<'a> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use cranelift_reader::ParseOptions;
 
     fn run_test(test_str: &str, expected_str: &str) {
         let test_file = parse_test(test_str, ParseOptions::default()).unwrap();
@@ -1088,13 +1082,11 @@ mod tests {
                 "reduction wasn't maximal for insts"
             );
 
-            let actual_ir = format!("{}", reduced_func);
+            let actual_ir = format!("{reduced_func}");
             let expected_ir = expected_str.replace("\r\n", "\n");
             assert!(
                 expected_ir == actual_ir,
-                "Expected:\n{}\nGot:\n{}",
-                expected_ir,
-                actual_ir,
+                "Expected:\n{expected_ir}\nGot:\n{actual_ir}",
             );
         }
     }
diff --git a/cranelift/src/cat.rs b/cranelift/src/cat.rs
index 167d768aa5d4..c90f3105a06c 100644
--- a/cranelift/src/cat.rs
+++ b/cranelift/src/cat.rs
@@ -13,7 +13,7 @@ use std::path::{Path, PathBuf};
 #[derive(Parser)]
 pub struct Options {
     /// Specify input file(s) to be used. Use '-' for stdin.
-    #[clap(required = true)]
+    #[arg(required = true)]
     files: Vec<PathBuf>,
 }
 
@@ -36,7 +36,7 @@ fn cat_one(path: &Path) -> Result<()> {
         if idx != 0 {
             println!();
         }
-        print!("{}", func);
+        print!("{func}");
     }
 
     Ok(())
diff --git a/cranelift/src/clif-util.rs b/cranelift/src/clif-util.rs
index 98da1cfb4dc6..da3e164bc14e 100644
--- a/cranelift/src/clif-util.rs
+++ b/cranelift/src/clif-util.rs
@@ -1,6 +1,3 @@
-#![deny(trivial_numeric_casts)]
-#![warn(unused_import_braces, unstable_features, unused_extern_crates)]
-
 use clap::Parser;
 use std::path::PathBuf;
 
@@ -16,9 +13,6 @@ mod utils;
 #[cfg(feature = "souper-harvest")]
 mod souper_harvest;
 
-#[cfg(feature = "wasm")]
-mod wasm;
-
 /// Cranelift code generator utility.
 #[derive(Parser)]
 enum Commands {
@@ -31,11 +25,6 @@ enum Commands {
     Pass(PassOptions),
     Bugpoint(bugpoint::Options),
 
-    #[cfg(feature = "wasm")]
-    Wasm(wasm::Options),
-    #[cfg(not(feature = "wasm"))]
-    Wasm(CompiledWithoutSupportOptions),
-
     #[cfg(feature = "souper-harvest")]
     SouperHarvest(souper_harvest::Options),
     #[cfg(not(feature = "souper-harvest"))]
@@ -46,15 +35,15 @@ enum Commands {
 #[derive(Parser)]
 struct TestOptions {
     /// Be more verbose
-    #[clap(short, long)]
+    #[arg(short, long)]
     verbose: bool,
 
     /// Print pass timing report for test
-    #[clap(short = 'T')]
+    #[arg(short = 'T')]
     time_passes: bool,
 
     /// Specify an input file to be used. Use '-' for stdin.
-    #[clap(required = true)]
+    #[arg(required = true)]
     files: Vec<PathBuf>,
 }
 
@@ -62,11 +51,11 @@ struct TestOptions {
 #[derive(Parser)]
 struct PassOptions {
     /// Be more verbose
-    #[clap(short, long)]
+    #[arg(short, long)]
     verbose: bool,
 
     /// Print pass timing report for test
-    #[clap(short = 'T')]
+    #[arg(short = 'T')]
     time_passes: bool,
 
     /// Specify an input file to be used. Use '-' for stdin.
@@ -76,7 +65,7 @@ struct PassOptions {
     target: String,
 
     /// Specify pass(es) to be run on the input file
-    #[clap(required = true)]
+    #[arg(required = true)]
     passes: Vec<String>,
 }
 
@@ -95,11 +84,6 @@ fn main() -> anyhow::Result<()> {
         Commands::Compile(c) => compile::run(&c)?,
         Commands::Bugpoint(b) => bugpoint::run(&b)?,
 
-        #[cfg(feature = "wasm")]
-        Commands::Wasm(w) => wasm::run(&w)?,
-        #[cfg(not(feature = "wasm"))]
-        Commands::Wasm(_) => anyhow::bail!("Error: clif-util was compiled without wasm support."),
-
         #[cfg(feature = "souper-harvest")]
         Commands::SouperHarvest(s) => souper_harvest::run(&s)?,
         #[cfg(not(feature = "souper-harvest"))]
diff --git a/cranelift/src/compile.rs b/cranelift/src/compile.rs
index 0df3f3fa68d4..65aa223d2056 100644
--- a/cranelift/src/compile.rs
+++ b/cranelift/src/compile.rs
@@ -17,30 +17,30 @@ use std::path::PathBuf;
 #[derive(Parser)]
 pub struct Options {
     /// Print the resulting Cranelift IR
-    #[clap(short)]
+    #[arg(short)]
     print: bool,
 
     /// Print pass timing report
-    #[clap(short = 'T')]
+    #[arg(short = 'T')]
     report_times: bool,
 
     /// Print machine code disassembly
-    #[clap(short = 'D', long)]
+    #[arg(short = 'D', long)]
     disasm: bool,
 
     /// Configure Cranelift settings
-    #[clap(long = "set")]
+    #[arg(long = "set")]
     settings: Vec<String>,
 
     /// Specify the Cranelift target
-    #[clap(long = "target")]
+    #[arg(long = "target")]
     target: String,
 
     /// Specify an input file to be used. Use '-' for stdin.
     files: Vec<PathBuf>,
 
     /// Output object file
-    #[clap(short = 'o', long = "output")]
+    #[arg(short = 'o', long = "output")]
     output: Option<PathBuf>,
 }
 
@@ -84,7 +84,7 @@ fn handle_module(
 ) -> Result<()> {
     let buffer = read_to_string(&path)?;
     let test_file = parse_test(&buffer, ParseOptions::default())
-        .with_context(|| format!("failed to parse {}", name))?;
+        .with_context(|| format!("failed to parse {name}"))?;
 
     // If we have an isa from the command-line, use that. Otherwise if the
     // file contains a unique isa, use that.
@@ -128,13 +128,12 @@ fn handle_module(
             let result = context.compiled_code().unwrap();
             print_all(
                 isa,
-                &context.func.params,
+                &context.func,
                 &mem,
                 code_info.total_size,
                 options.print,
                 result.buffer.relocs(),
                 result.buffer.traps(),
-                result.buffer.stack_maps(),
             )?;
         }
     }
diff --git a/cranelift/src/disasm.rs b/cranelift/src/disasm.rs
index 0b0235b67959..6947a5b977a9 100644
--- a/cranelift/src/disasm.rs
+++ b/cranelift/src/disasm.rs
@@ -1,8 +1,9 @@
 use anyhow::Result;
 use cfg_if::cfg_if;
 use cranelift_codegen::ir::function::FunctionParameters;
+use cranelift_codegen::ir::Function;
 use cranelift_codegen::isa::TargetIsa;
-use cranelift_codegen::{FinalizedMachReloc, MachStackMap, MachTrap};
+use cranelift_codegen::{FinalizedMachReloc, MachTrap};
 use std::fmt::Write;
 
 fn print_relocs(func_params: &FunctionParameters, relocs: &[FinalizedMachReloc]) -> String {
@@ -35,44 +36,12 @@ pub fn print_traps(traps: &[MachTrap]) -> String {
     text
 }
 
-pub fn print_stack_maps(traps: &[MachStackMap]) -> String {
-    let mut text = String::new();
-    for MachStackMap {
-        offset,
-        offset_end,
-        stack_map,
-    } in traps
-    {
-        writeln!(
-            text,
-            "add_stack_map at {offset:#x}-{offset_end:#x} mapped_words={}",
-            stack_map.mapped_words()
-        )
-        .unwrap();
-
-        write!(text, "    entries: ").unwrap();
-        let mut first = true;
-        for i in 0..stack_map.mapped_words() {
-            if !stack_map.get_bit(i as usize) {
-                continue;
-            }
-            if !first {
-                write!(text, ", ").unwrap();
-            } else {
-                first = false;
-            }
-            write!(text, "{i}").unwrap();
-        }
-    }
-    text
-}
-
 cfg_if! {
     if #[cfg(feature = "disas")] {
-        pub fn print_disassembly(isa: &dyn TargetIsa, mem: &[u8]) -> Result<()> {
+        pub fn print_disassembly(func: &Function, isa: &dyn TargetIsa, mem: &[u8]) -> Result<()> {
             let cs = isa.to_capstone().map_err(|e| anyhow::format_err!("{}", e))?;
 
-            println!("\nDisassembly of {} bytes:", mem.len());
+            println!("\nDisassembly of {} bytes <{}>:", mem.len(), func.name);
             let insns = cs.disasm_all(&mem, 0x0).unwrap();
             for i in insns.iter() {
                 let mut line = String::new();
@@ -86,29 +55,29 @@ cfg_if! {
                     if !first {
                         write!(&mut bytes_str, " ").unwrap();
                     }
-                    write!(&mut bytes_str, "{:02x}", b).unwrap();
+                    write!(&mut bytes_str, "{b:02x}").unwrap();
                     len += 1;
                     first = false;
                 }
-                write!(&mut line, "{:21}\t", bytes_str).unwrap();
+                write!(&mut line, "{bytes_str:21}\t").unwrap();
                 if len > 8 {
                     write!(&mut line, "\n\t\t\t\t").unwrap();
                 }
 
                 if let Some(s) = i.mnemonic() {
-                    write!(&mut line, "{}\t", s).unwrap();
+                    write!(&mut line, "{s}\t").unwrap();
                 }
 
                 if let Some(s) = i.op_str() {
-                    write!(&mut line, "{}", s).unwrap();
+                    write!(&mut line, "{s}").unwrap();
                 }
 
-                println!("{}", line);
+                println!("{line}");
             }
             Ok(())
         }
     } else {
-        pub fn print_disassembly(_: &dyn TargetIsa, _: &[u8]) -> Result<()> {
+        pub fn print_disassembly(_: &Function, _: &dyn TargetIsa, _: &[u8]) -> Result<()> {
             println!("\nNo disassembly available.");
             Ok(())
         }
@@ -117,22 +86,20 @@ cfg_if! {
 
 pub fn print_all(
     isa: &dyn TargetIsa,
-    func_params: &FunctionParameters,
+    func: &Function,
     mem: &[u8],
     code_size: u32,
     print: bool,
     relocs: &[FinalizedMachReloc],
     traps: &[MachTrap],
-    stack_maps: &[MachStackMap],
 ) -> Result<()> {
     print_bytes(&mem);
-    print_disassembly(isa, &mem[0..code_size as usize])?;
+    print_disassembly(func, isa, &mem[0..code_size as usize])?;
     if print {
         println!(
-            "\n{}\n{}\n{}",
-            print_relocs(func_params, relocs),
+            "\n{}\n{}",
+            print_relocs(&func.params, relocs),
             print_traps(traps),
-            print_stack_maps(stack_maps)
         );
     }
     Ok(())
@@ -147,7 +114,7 @@ pub fn print_bytes(mem: &[u8]) {
         } else {
             print!(", ");
         }
-        print!("{}", byte);
+        print!("{byte}");
     }
     println!();
 }
diff --git a/cranelift/src/interpret.rs b/cranelift/src/interpret.rs
index a752d692dac9..d0fce058a759 100644
--- a/cranelift/src/interpret.rs
+++ b/cranelift/src/interpret.rs
@@ -14,11 +14,11 @@ use thiserror::Error;
 #[derive(Parser)]
 pub struct Options {
     /// Specify an input file to be used. Use '-' for stdin.
-    #[clap(required = true)]
+    #[arg(required = true)]
     files: Vec<PathBuf>,
 
     /// Be more verbose
-    #[clap(short, long)]
+    #[arg(short, long)]
     verbose: bool,
 }
 
@@ -48,7 +48,7 @@ pub fn run(options: &Options) -> anyhow::Result<()> {
         match total {
             0 => println!("0 files"),
             1 => println!("1 file"),
-            n => println!("{} files", n),
+            n => println!("{n} files"),
         }
     }
 
@@ -122,7 +122,7 @@ impl FileInterpreter {
             command
                 .run(|func_name, args| {
                     // Because we have stored function names with a leading %, we need to re-add it.
-                    let func_name = &format!("%{}", func_name);
+                    let func_name = &format!("%{func_name}");
                     let state = InterpreterState::default().with_function_store(env.clone());
                     match Interpreter::new(state).call_by_name(func_name, args) {
                         Ok(ControlFlow::Return(results)) => Ok(results.to_vec()),
diff --git a/cranelift/src/print_cfg.rs b/cranelift/src/print_cfg.rs
index fa7027c42bcc..cadb61c760f4 100644
--- a/cranelift/src/print_cfg.rs
+++ b/cranelift/src/print_cfg.rs
@@ -14,7 +14,7 @@ use std::path::{Path, PathBuf};
 #[derive(Parser)]
 pub struct Options {
     /// Specify an input file to be used. Use '-' for stdin.
-    #[clap(required = true)]
+    #[arg(required = true)]
     files: Vec<PathBuf>,
 }
 
diff --git a/cranelift/src/run.rs b/cranelift/src/run.rs
index 5564736e3b68..bc9048688fd0 100644
--- a/cranelift/src/run.rs
+++ b/cranelift/src/run.rs
@@ -8,17 +8,17 @@ use cranelift_filetests::TestFileCompiler;
 use cranelift_native::builder as host_isa_builder;
 use cranelift_reader::{parse_run_command, parse_test, Details, IsaSpec, ParseOptions};
 use std::path::{Path, PathBuf};
-use target_lexicon::Triple;
+use target_lexicon::{Triple, HOST};
 
 /// Execute clif code and verify with test expressions
 #[derive(Parser)]
 pub struct Options {
     /// Specify an input file to be used. Use '-' for stdin.
-    #[clap(required = true)]
+    #[arg(required = true)]
     files: Vec<PathBuf>,
 
     /// Be more verbose
-    #[clap(short, long)]
+    #[arg(short, long)]
     verbose: bool,
 }
 
@@ -61,7 +61,7 @@ pub fn run(options: &Options) -> Result<()> {
         match total {
             0 => println!("0 files"),
             1 => println!("1 file"),
-            n => println!("{} files", n),
+            n => println!("{n} files"),
         }
     }
 
@@ -106,15 +106,22 @@ fn run_file_contents(file_contents: String) -> Result<()> {
 
 /// Build an ISA based on the current machine running this code (the host)
 fn create_target_isa(isa_spec: &IsaSpec) -> Result<OwnedTargetIsa> {
-    if let IsaSpec::None(flags) = isa_spec {
-        // build an ISA for the current machine
-        let builder = host_isa_builder().map_err(|s| anyhow::anyhow!("{}", s))?;
-        Ok(builder.finish(flags.clone())?)
-    } else {
-        anyhow::bail!(
-            "A target ISA was specified in the file but should not have been--only \
-             the host ISA can be used for running CLIF files"
-        )
+    let builder = host_isa_builder().map_err(|s| anyhow::anyhow!("{}", s))?;
+    match *isa_spec {
+        IsaSpec::None(ref flags) => {
+            // build an ISA for the current machine
+            Ok(builder.finish(flags.clone())?)
+        }
+        IsaSpec::Some(ref isas) => {
+            for isa in isas {
+                if isa.triple().architecture == HOST.architecture {
+                    return Ok(builder.finish(isa.flags().clone())?);
+                }
+            }
+            anyhow::bail!(
+                "The target ISA specified in the file is not compatible with the host ISA"
+            )
+        }
     }
 }
 
diff --git a/cranelift/src/souper_harvest.rs b/cranelift/src/souper_harvest.rs
index a8490f842ae4..d8a559c437c7 100644
--- a/cranelift/src/souper_harvest.rs
+++ b/cranelift/src/souper_harvest.rs
@@ -1,16 +1,17 @@
+use crate::utils::{iterate_files, read_to_string};
 use anyhow::{Context as _, Result};
 use clap::Parser;
+use cranelift_codegen::control::ControlPlane;
+use cranelift_codegen::ir::Function;
 use cranelift_codegen::Context;
 use cranelift_reader::parse_sets_and_triple;
-use cranelift_wasm::DummyEnvironment;
-use rayon::iter::{IntoParallelIterator, ParallelIterator};
+use rayon::iter::{IntoParallelIterator, ParallelBridge, ParallelIterator};
 use std::collections::HashSet;
+use std::hash::{BuildHasher, BuildHasherDefault};
 use std::io::Write;
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 use std::{fs, io};
 
-static WASM_MAGIC: &[u8] = &[0x00, 0x61, 0x73, 0x6D];
-
 /// Harvest candidates for superoptimization from a Wasm or Clif file.
 ///
 /// Candidates are emitted in Souper's text format:
@@ -18,25 +19,25 @@ static WASM_MAGIC: &[u8] = &[0x00, 0x61, 0x73, 0x6D];
 #[derive(Parser)]
 pub struct Options {
     /// Specify an input file to be used. Use '-' for stdin.
-    input: PathBuf,
+    input: Vec<PathBuf>,
 
     /// Specify the directory where harvested left-hand side files should be
     /// written to.
-    #[clap(short, long)]
+    #[arg(short, long)]
     output_dir: PathBuf,
 
     /// Configure Cranelift settings
-    #[clap(long = "set")]
+    #[arg(long = "set")]
     settings: Vec<String>,
 
     /// Specify the Cranelift target
-    #[clap(long = "target")]
+    #[arg(long = "target")]
     target: String,
 
     /// Add a comment from which CLIF variable and function each left-hand side
     /// was harvested from. This prevents deduplicating harvested left-hand
     /// sides.
-    #[clap(long)]
+    #[arg(long)]
     add_harvest_source: bool,
 }
 
@@ -47,16 +48,7 @@ pub fn run(options: &Options) -> Result<()> {
         anyhow::bail!("`souper-harvest` requires a target isa");
     }
 
-    let stdin = io::stdin();
-    let mut input: Box<dyn io::BufRead> = if options.input == Path::new("-") {
-        Box::new(stdin.lock())
-    } else {
-        Box::new(io::BufReader::new(
-            fs::File::open(&options.input).context("failed to open input file")?,
-        ))
-    };
-
-    match std::fs::create_dir_all(&options.output_dir) {
+    match fs::create_dir_all(&options.output_dir) {
         Ok(_) => {}
         Err(e)
             if e.kind() == io::ErrorKind::AlreadyExists
@@ -76,26 +68,6 @@ pub fn run(options: &Options) -> Result<()> {
         }
     }
 
-    let mut contents = vec![];
-    input
-        .read_to_end(&mut contents)
-        .context("failed to read input file")?;
-
-    let funcs = if &contents[..WASM_MAGIC.len()] == WASM_MAGIC {
-        let mut dummy_environ = DummyEnvironment::new(fisa.isa.unwrap().frontend_config());
-        cranelift_wasm::translate_module(&contents, &mut dummy_environ)
-            .context("failed to translate Wasm module to clif")?;
-        dummy_environ
-            .info
-            .function_bodies
-            .iter()
-            .map(|(_, f)| f.clone())
-            .collect()
-    } else {
-        let contents = String::from_utf8(contents)?;
-        cranelift_reader::parse_functions(&contents)?
-    };
-
     let (send, recv) = std::sync::mpsc::channel::<String>();
 
     let writing_thread = std::thread::spawn({
@@ -111,7 +83,7 @@ pub fn run(options: &Options) -> Result<()> {
                     let i = lhs.find('\n').unwrap();
                     &lhs[i + 1..]
                 };
-                let hash = fxhash::hash(lhs.as_bytes());
+                let hash = hash(lhs.as_bytes());
                 if already_harvested.insert(hash) {
                     let output_path = output_dir.join(hash.to_string());
                     let mut output =
@@ -127,20 +99,31 @@ pub fn run(options: &Options) -> Result<()> {
         }
     });
 
-    funcs
-        .into_par_iter()
-        .map_with(send, move |send, func| {
-            let mut ctx = Context::new();
-            ctx.func = func;
+    iterate_files(&options.input)
+        .par_bridge()
+        .flat_map(|path| {
+            parse_input(path)
+                .unwrap_or_else(|e| {
+                    println!("{e:?}");
+                    Vec::new()
+                })
+                .into_par_iter()
+        })
+        .map_init(
+            move || (send.clone(), Context::new()),
+            move |(send, ctx), func| {
+                ctx.clear();
+                ctx.func = func;
 
-            ctx.optimize(fisa.isa.unwrap())
-                .context("failed to run optimizations")?;
+                ctx.optimize(fisa.isa.unwrap(), &mut ControlPlane::default())
+                    .context("failed to run optimizations")?;
 
-            ctx.souper_harvest(send)
-                .context("failed to run souper harvester")?;
+                ctx.souper_harvest(send)
+                    .context("failed to run souper harvester")?;
 
-            Ok(())
-        })
+                Ok(())
+            },
+        )
         .collect::<Result<()>>()?;
 
     match writing_thread.join() {
@@ -150,3 +133,16 @@ pub fn run(options: &Options) -> Result<()> {
 
     Ok(())
 }
+
+fn parse_input(path: PathBuf) -> Result<Vec<Function>> {
+    let contents = read_to_string(&path)?;
+    let funcs = cranelift_reader::parse_functions(&contents)
+        .with_context(|| format!("parse error in {}", path.display()))?;
+    Ok(funcs)
+}
+
+/// A convenience function for a quick usize hash
+#[inline]
+pub fn hash<T: std::hash::Hash + ?Sized>(v: &T) -> usize {
+    BuildHasherDefault::<rustc_hash::FxHasher>::default().hash_one(v) as usize
+}
diff --git a/cranelift/src/utils.rs b/cranelift/src/utils.rs
index b1645534543a..5fed6e24629a 100644
--- a/cranelift/src/utils.rs
+++ b/cranelift/src/utils.rs
@@ -37,7 +37,7 @@ pub fn iterate_files<'a>(files: &'a [PathBuf]) -> impl Iterator<Item = PathBuf>
                     && !d.file_type().is_dir()
             }
             Err(e) => {
-                println!("Unable to read file: {}", e);
+                println!("Unable to read file: {e}");
                 false
             }
         })
diff --git a/cranelift/src/wasm.rs b/cranelift/src/wasm.rs
deleted file mode 100644
index 8a5e2102b461..000000000000
--- a/cranelift/src/wasm.rs
+++ /dev/null
@@ -1,321 +0,0 @@
-//! CLI tool to use the functions provided by the [cranelift-wasm](../cranelift_wasm/index.html)
-//! crate.
-//!
-//! Reads Wasm binary/text files, translates the functions' code to Cranelift IR.
-
-use crate::disasm::print_all;
-use anyhow::{Context as _, Result};
-use clap::Parser;
-use cranelift_codegen::print_errors::{pretty_error, pretty_verifier_error};
-use cranelift_codegen::settings::FlagsOrIsa;
-use cranelift_codegen::timing;
-use cranelift_codegen::Context;
-use cranelift_entity::EntityRef;
-use cranelift_reader::parse_sets_and_triple;
-use cranelift_wasm::{translate_module, DummyEnvironment, FuncIndex};
-use std::io::Read;
-use std::path::Path;
-use std::path::PathBuf;
-use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};
-
-/// For verbose printing: only print if the `$x` expression is true.
-macro_rules! vprintln {
-    ($x: expr, $($tts:tt)*) => {
-        if $x {
-            println!($($tts)*);
-        }
-    };
-}
-/// For verbose printing: prints in color if the `$x` expression is true.
-macro_rules! vcprintln {
-    ($x: expr, $use_color: expr, $term: ident, $color: expr, $($tts:tt)*) => {
-        if $x {
-            if $use_color {
-                $term.set_color(ColorSpec::new().set_fg(Some($color)))?;
-            }
-            println!($($tts)*);
-            if $use_color {
-                $term.reset()?;
-            }
-        }
-    };
-}
-/// For verbose printing: prints in color (without an appended newline) if the `$x` expression is true.
-macro_rules! vcprint {
-    ($x: expr, $use_color: expr, $term: ident, $color: expr, $($tts:tt)*) => {
-        if $x {
-            if $use_color {
-                $term.set_color(ColorSpec::new().set_fg(Some($color)))?;
-            }
-            print!($($tts)*);
-            if $use_color {
-                $term.reset()?;
-            }
-        }
-    };
-}
-
-/// Compiles Wasm binary/text into Cranelift IR and then into target language
-#[derive(Parser)]
-pub struct Options {
-    /// Be more verbose
-    #[clap(short, long)]
-    verbose: bool,
-
-    /// Print the resulting Cranelift IR
-    #[clap(short)]
-    print: bool,
-
-    /// Print pass timing report
-    #[clap(short = 'T')]
-    report_times: bool,
-
-    /// Print machine code disassembly
-    #[clap(short = 'D', long)]
-    disasm: bool,
-
-    /// Configure Cranelift settings
-    #[clap(long = "set")]
-    settings: Vec<String>,
-
-    /// Specify the Cranelift target
-    #[clap(long = "target")]
-    target: String,
-
-    /// Specify an input file to be used. Use '-' for stdin.
-    files: Vec<PathBuf>,
-
-    /// Print bytecode size
-    #[clap(short = 'X')]
-    print_size: bool,
-
-    /// Just decode Wasm into Cranelift IR, don't compile it to native code
-    #[clap(short = 't')]
-    just_decode: bool,
-
-    /// Just checks the correctness of Cranelift IR translated from Wasm
-    #[clap(short = 'c')]
-    check_translation: bool,
-
-    /// Use colors in output? [options: auto/never/always; default: auto]
-    #[clap(long = "color", default_value("auto"))]
-    color: ColorOpt,
-}
-
-#[derive(PartialEq, Eq, Clone)]
-enum ColorOpt {
-    Auto,
-    Never,
-    Always,
-}
-
-impl std::str::FromStr for ColorOpt {
-    type Err = String;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let s = s.to_lowercase();
-        match s.as_str() {
-            "auto" => Ok(ColorOpt::Auto),
-            "never" => Ok(ColorOpt::Never),
-            "always" => Ok(ColorOpt::Always),
-            _ => Err(format!("expected auto/never/always, found: {}", s)),
-        }
-    }
-}
-
-pub fn run(options: &Options) -> Result<()> {
-    let parsed = parse_sets_and_triple(&options.settings, &options.target)?;
-    for path in &options.files {
-        let name = String::from(path.as_os_str().to_string_lossy());
-        handle_module(options, path, &name, parsed.as_fisa())?;
-    }
-    Ok(())
-}
-
-fn handle_module(options: &Options, path: &Path, name: &str, fisa: FlagsOrIsa) -> Result<()> {
-    let color_choice = match options.color {
-        ColorOpt::Auto => ColorChoice::Auto,
-        ColorOpt::Always => ColorChoice::Always,
-        ColorOpt::Never => ColorChoice::Never,
-    };
-    let mut terminal = StandardStream::stdout(color_choice);
-    let use_color = terminal.supports_color() && options.color == ColorOpt::Auto
-        || options.color == ColorOpt::Always;
-    vcprint!(
-        options.verbose,
-        use_color,
-        terminal,
-        Color::Yellow,
-        "Handling: "
-    );
-    vprintln!(options.verbose, "\"{}\"", name);
-    vcprint!(
-        options.verbose,
-        use_color,
-        terminal,
-        Color::Magenta,
-        "Translating... "
-    );
-
-    let module_binary = if path.to_str() == Some("-") {
-        let stdin = std::io::stdin();
-        let mut buf = Vec::new();
-        stdin
-            .lock()
-            .read_to_end(&mut buf)
-            .context("failed to read stdin")?;
-        wat::parse_bytes(&buf)?.into()
-    } else {
-        wat::parse_file(path)?
-    };
-
-    let isa = match fisa.isa {
-        Some(isa) => isa,
-        None => {
-            anyhow::bail!("Error: the wasm command requires an explicit isa.");
-        }
-    };
-
-    let mut dummy_environ = DummyEnvironment::new(isa.frontend_config());
-    translate_module(&module_binary, &mut dummy_environ)?;
-
-    vcprintln!(options.verbose, use_color, terminal, Color::Green, "ok");
-
-    if options.just_decode {
-        if !options.print {
-            return Ok(());
-        }
-
-        let num_func_imports = dummy_environ.get_num_func_imports();
-        for (def_index, func) in dummy_environ.info.function_bodies.iter() {
-            let func_index = num_func_imports + def_index.index();
-            let mut context = Context::new();
-            context.func = func.clone();
-            if let Some(start_func) = dummy_environ.info.start_func {
-                if func_index == start_func.index() {
-                    println!("; Selected as wasm start function");
-                }
-            }
-            vprintln!(options.verbose, "");
-            for export_name in
-                &dummy_environ.info.functions[FuncIndex::new(func_index)].export_names
-            {
-                println!("; Exported as \"{}\"", export_name);
-            }
-            println!("{}", context.func.display());
-            vprintln!(options.verbose, "");
-        }
-        let _ = terminal.reset();
-        return Ok(());
-    }
-
-    if options.check_translation {
-        vcprint!(
-            options.verbose,
-            use_color,
-            terminal,
-            Color::Magenta,
-            "Checking... "
-        );
-    } else {
-        vcprint!(
-            options.verbose,
-            use_color,
-            terminal,
-            Color::Magenta,
-            "Compiling... "
-        );
-    }
-
-    if options.print_size {
-        vprintln!(options.verbose, "");
-    }
-
-    let num_func_imports = dummy_environ.get_num_func_imports();
-    let mut total_module_code_size = 0;
-    let mut context = Context::new();
-    for (def_index, func) in dummy_environ.info.function_bodies.iter() {
-        context.func = func.clone();
-
-        let mut saved_size = None;
-        let func_index = num_func_imports + def_index.index();
-        let mut mem = vec![];
-        let (relocs, traps, stack_maps) = if options.check_translation {
-            if let Err(errors) = context.verify(fisa) {
-                anyhow::bail!("{}", pretty_verifier_error(&context.func, None, errors));
-            }
-            (vec![], vec![], vec![])
-        } else {
-            let compiled_code = context
-                .compile_and_emit(isa, &mut mem, &mut Default::default())
-                .map_err(|err| anyhow::anyhow!("{}", pretty_error(&err.func, err.inner)))?;
-            let code_info = compiled_code.code_info();
-
-            if options.print_size {
-                println!(
-                    "Function #{} code size: {} bytes",
-                    func_index, code_info.total_size,
-                );
-                total_module_code_size += code_info.total_size;
-                println!(
-                    "Function #{} bytecode size: {} bytes",
-                    func_index,
-                    dummy_environ.func_bytecode_sizes[def_index.index()]
-                );
-            }
-
-            if options.disasm {
-                saved_size = Some(code_info.total_size);
-            }
-            (
-                compiled_code.buffer.relocs().to_vec(),
-                compiled_code.buffer.traps().to_vec(),
-                compiled_code.buffer.stack_maps().to_vec(),
-            )
-        };
-
-        if options.print {
-            vprintln!(options.verbose, "");
-            if let Some(start_func) = dummy_environ.info.start_func {
-                if func_index == start_func.index() {
-                    println!("; Selected as wasm start function");
-                }
-            }
-            for export_name in
-                &dummy_environ.info.functions[FuncIndex::new(func_index)].export_names
-            {
-                println!("; Exported as \"{}\"", export_name);
-            }
-            println!("{}", context.func.display());
-            vprintln!(options.verbose, "");
-        }
-
-        if let Some(total_size) = saved_size {
-            print_all(
-                isa,
-                &context.func.params,
-                &mem,
-                total_size,
-                options.print,
-                &relocs,
-                &traps,
-                &stack_maps,
-            )?;
-        }
-
-        context.clear();
-    }
-
-    if !options.check_translation && options.print_size {
-        println!("Total module code size: {} bytes", total_module_code_size);
-        let total_bytecode_size: usize = dummy_environ.func_bytecode_sizes.iter().sum();
-        println!("Total module bytecode size: {} bytes", total_bytecode_size);
-    }
-
-    if options.report_times {
-        println!("{}", timing::take_current());
-    }
-
-    vcprintln!(options.verbose, use_color, terminal, Color::Green, "ok");
-    Ok(())
-}
diff --git a/cranelift/tests/bugpoint_consts.clif b/cranelift/tests/bugpoint_consts.clif
index 449b53ebbe9b..2234123e4b25 100644
--- a/cranelift/tests/bugpoint_consts.clif
+++ b/cranelift/tests/bugpoint_consts.clif
@@ -2,13 +2,13 @@ test compile
 target x86_64
 
 function u0:0() {
-    sig0 = (f32, f64, i8, i16, i32, i64, i128, i8, i8, i128, r32, r64, i8x16, i16x4, f32x16)
+    sig0 = (f32, f64, i8, i16, i32, i64, i128, i8, i8, i128, i8x16, i16x4, f32x16)
     fn0 = u0:1 sig0
 
 block0:
     trap user0
 
-block1(v0: f32, v1: f64, v2: i8, v3: i16, v4: i32, v5: i64, v6: i128, v7: i8, v8: i8, v9: i128, v10: r32, v11: r64, v12: i8x16, v13: i16x4, v14: f32x16):
-    call fn0(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14)
+block1(v0: f32, v1: f64, v2: i8, v3: i16, v4: i32, v5: i64, v6: i128, v7: i8, v8: i8, v9: i128, v12: i8x16, v13: i16x4, v14: f32x16):
+    call fn0(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v12, v13, v14)
     trap user0
 }
diff --git a/cranelift/tests/bugpoint_consts_expected.clif b/cranelift/tests/bugpoint_consts_expected.clif
index c344f484f6e4..bf95789f1a20 100644
--- a/cranelift/tests/bugpoint_consts_expected.clif
+++ b/cranelift/tests/bugpoint_consts_expected.clif
@@ -1,5 +1,5 @@
 function u0:0() fast {
-    sig0 = (f32, f64, i8, i16, i32, i64, i128, i8, i8, i128, r32, r64, i8x16, i16x4, f32x16) fast
+    sig0 = (f32, f64, i8, i16, i32, i64, i128, i8, i8, i128, i8x16, i16x4, f32x16) fast
     fn0 = u0:1 sig0
     const0 = 0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
     const1 = 0x0000000000000000
@@ -18,11 +18,9 @@ block1:
     v8 = iconst.i8 0
     v15 = iconst.i64 0
     v9 = uextend.i128 v15  ; v15 = 0
-    v10 = null.r32 
-    v11 = null.r64 
     v12 = vconst.i8x16 const2
     v13 = vconst.i16x4 const1
     v14 = vconst.f32x16 const0
-    call fn0(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14)  ; v0 = 0.0, v1 = 0.0, v2 = 0, v3 = 0, v4 = 0, v5 = 0, v7 = 0, v8 = 0, v12 = const2, v13 = const1, v14 = const0
+    call fn0(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v12, v13, v14)  ; v0 = 0.0, v1 = 0.0, v2 = 0, v3 = 0, v4 = 0, v5 = 0, v7 = 0, v8 = 0, v12 = const2, v13 = const1, v14 = const0
     trap user0
 }
diff --git a/cranelift/tests/bugpoint_test.clif b/cranelift/tests/bugpoint_test.clif
index 47bcb734adba..757bdfc2b298 100644
--- a/cranelift/tests/bugpoint_test.clif
+++ b/cranelift/tests/bugpoint_test.clif
@@ -300,12 +300,12 @@ block0(v0: i64, v1: i64, v2: i64):
     v241 -> v1
     v256 -> v1
     v262 -> v1
-    v3 = imul v0, v1
+    @0001 v3 = imul v0, v1
     v4 = imul v1, v2
     store aligned v4, v3
     v5 = load.i64 aligned v2+8
     store aligned v5, v3+8
-    v6 = stack_addr.i64 ss1
+    @0002 v6 = stack_addr.i64 ss1
     v7 = stack_addr.i64 ss2
     v8 = stack_addr.i64 ss3
     v9 = stack_addr.i64 ss4
@@ -366,7 +366,7 @@ block0(v0: i64, v1: i64, v2: i64):
     v64 = stack_addr.i64 ss59
     v65 = stack_addr.i64 ss60
     v66 = stack_addr.i64 ss61
-    v67 = stack_addr.i64 ss62
+    @0003 v67 = stack_addr.i64 ss62
     v68 = stack_addr.i64 ss63
     v69 = stack_addr.i64 ss64
     v70 = stack_addr.i64 ss65
diff --git a/cranelift/tests/bugpoint_test_expected.clif b/cranelift/tests/bugpoint_test_expected.clif
index 982fcb001188..cc83b54bf151 100644
--- a/cranelift/tests/bugpoint_test_expected.clif
+++ b/cranelift/tests/bugpoint_test_expected.clif
@@ -6,30 +6,11 @@ block0:
     v0 = iconst.i64 0
     v105 = iconst.i64 0
     v829 = iconst.i64 0
-    v935 -> v829
-    v962 -> v829
-    v992 -> v829
-    v1036 -> v829
-    v1049 -> v829
     v842 = iconst.i64 0
-    v976 -> v842
-    v989 -> v842
-    v1038 -> v842
-    v1061 -> v842
     v883 = iconst.i64 0
-    v934 -> v883
-    v961 -> v883
-    v991 -> v883
-    v1005 -> v883
-    v1048 -> v883
     v951 = iconst.i64 0
-    v988 -> v951
     v987 = iconst.i64 0
     v1052 = iconst.i16 0
-    v960 -> v1052
-    v990 -> v1052
-    v1051 -> v1052
-    v1055 -> v1052
     call fn0(v0, v105, v1052, v883, v829, v987, v951, v842)  ; v0 = 0, v105 = 0, v1052 = 0, v883 = 0, v829 = 0, v987 = 0, v951 = 0, v842 = 0
     trap user0
 }
diff --git a/cranelift/tests/filetests.rs b/cranelift/tests/filetests.rs
index 72fbe7494c83..7eb509ff86cc 100644
--- a/cranelift/tests/filetests.rs
+++ b/cranelift/tests/filetests.rs
@@ -1,4 +1,5 @@
-fn main() -> anyhow::Result<()> {
+#[test]
+fn filetests() -> anyhow::Result<()> {
     // Run all the filetests in the following directories.
     cranelift_filetests::run(false, false, &["filetests".into(), "docs".into()])?;
     Ok(())
diff --git a/cranelift/umbrella/Cargo.toml b/cranelift/umbrella/Cargo.toml
index b3ed56f1404c..8da764de751a 100644
--- a/cranelift/umbrella/Cargo.toml
+++ b/cranelift/umbrella/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 authors = ["The Cranelift Project Developers"]
 name = "cranelift"
-version = "0.101.0"
+version = "0.112.0"
 description = "Umbrella for commonly-used cranelift crates"
 license = "Apache-2.0 WITH LLVM-exception"
 documentation = "https://docs.rs/cranelift"
@@ -10,12 +10,32 @@ categories = ["no-std"]
 readme = "README.md"
 keywords = ["compile", "compiler", "jit"]
 edition.workspace = true
+rust-version.workspace = true
 
 [dependencies]
 cranelift-codegen = { workspace = true }
-cranelift-frontend = { workspace = true }
+cranelift-frontend = { workspace = true, optional = true }
+cranelift-interpreter = { workspace = true, optional = true }
+cranelift-jit = { workspace = true, optional = true }
+cranelift-module = { workspace = true, optional = true }
+cranelift-native = { workspace = true, optional = true }
+cranelift-object = { workspace = true, optional = true }
 
 [features]
-default = ["std"]
-std = ["cranelift-codegen/std", "cranelift-frontend/std"]
-core = ["cranelift-codegen/core", "cranelift-frontend/core"]
+default = ["std", "frontend"]
+frontend = ["dep:cranelift-frontend"]
+interpreter = ["dep:cranelift-interpreter"]
+jit = ["dep:cranelift-jit"]
+module = ["dep:cranelift-module"]
+native = ["dep:cranelift-native"]
+object = ["dep:cranelift-object"]
+std = [
+    "cranelift-codegen/std",
+    "cranelift-frontend?/std",
+    "cranelift-module?/std",
+]
+core = [
+    "cranelift-codegen/core",
+    "cranelift-frontend?/core",
+    "cranelift-module?/core",
+]
diff --git a/cranelift/umbrella/src/lib.rs b/cranelift/umbrella/src/lib.rs
index 033b44e8ec21..cfda269c735f 100644
--- a/cranelift/umbrella/src/lib.rs
+++ b/cranelift/umbrella/src/lib.rs
@@ -1,17 +1,22 @@
 //! Cranelift umbrella crate, providing a convenient one-line dependency.
 
-#![deny(
-    missing_docs,
-    trivial_numeric_casts,
-    unused_extern_crates,
-    unstable_features
-)]
-#![warn(unused_import_braces)]
+#![deny(missing_docs)]
 #![no_std]
 
 /// Provide these crates, renamed to reduce stutter.
 pub use cranelift_codegen as codegen;
+#[cfg(feature = "frontend")]
 pub use cranelift_frontend as frontend;
+#[cfg(feature = "interpreter")]
+pub use cranelift_interpreter as interpreter;
+#[cfg(feature = "jit")]
+pub use cranelift_jit as jit;
+#[cfg(feature = "module")]
+pub use cranelift_module as module;
+#[cfg(feature = "native")]
+pub use cranelift_native as native;
+#[cfg(feature = "object")]
+pub use cranelift_object as object;
 
 /// A prelude providing convenient access to commonly-used cranelift features. Use
 /// as `use cranelift::prelude::*`.
@@ -28,6 +33,7 @@ pub mod prelude {
     pub use crate::codegen::isa;
     pub use crate::codegen::settings::{self, Configurable};
 
+    #[cfg(feature = "frontend")]
     pub use crate::frontend::{FunctionBuilder, FunctionBuilderContext, Variable};
 }
 
diff --git a/cranelift/wasm/Cargo.toml b/cranelift/wasm/Cargo.toml
index fcac5021bcc5..79d84ee4aaa3 100644
--- a/cranelift/wasm/Cargo.toml
+++ b/cranelift/wasm/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "cranelift-wasm"
-version = "0.101.0"
+version = "0.112.0"
 authors = ["The Cranelift Project Developers"]
 description = "Translator from WebAssembly to Cranelift IR"
 documentation = "https://docs.rs/cranelift-wasm"
@@ -10,18 +10,22 @@ categories = ["no-std", "wasm"]
 readme = "README.md"
 keywords = ["webassembly", "wasm"]
 edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
 
 [dependencies]
-wasmparser = { workspace = true }
+wasmparser = { workspace = true, features = ['validate'] }
 cranelift-codegen = { workspace = true }
 cranelift-entity = { workspace = true }
 cranelift-frontend = { workspace = true }
 wasmtime-types = { workspace = true }
 hashbrown = { workspace = true, optional = true }
-itertools = "0.10.0"
+itertools = "0.12.0"
 log = { workspace = true }
-serde = { version = "1.0.188", optional = true }
-serde_derive = { version = "1.0.188", optional = true }
+serde = { workspace = true, optional = true }
+serde_derive = { workspace = true, optional = true }
 smallvec = { workspace = true }
 
 [dev-dependencies]
@@ -32,4 +36,4 @@ target-lexicon = { workspace = true }
 default = ["std"]
 std = ["cranelift-codegen/std", "cranelift-frontend/std"]
 core = ["hashbrown", "cranelift-codegen/core", "cranelift-frontend/core"]
-enable-serde = ["serde", "serde_derive"]
+enable-serde = ["serde", "serde_derive", "cranelift-codegen/enable-serde"]
diff --git a/cranelift/wasm/src/code_translator.rs b/cranelift/wasm/src/code_translator.rs
index 6a0090c10089..5506c66728df 100644
--- a/cranelift/wasm/src/code_translator.rs
+++ b/cranelift/wasm/src/code_translator.rs
@@ -92,7 +92,6 @@ use cranelift_codegen::packed_option::ReservedValue;
 use cranelift_frontend::{FunctionBuilder, Variable};
 use itertools::Itertools;
 use smallvec::SmallVec;
-use std::convert::TryFrom;
 use std::vec::Vec;
 use wasmparser::{FuncValidator, MemArg, Operator, WasmModuleResources};
 
@@ -178,13 +177,11 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
                     let addr = builder.ins().global_value(environ.pointer_type(), gv);
                     let mut flags = ir::MemFlags::trusted();
                     // Put globals in the "table" abstract heap category as well.
-                    flags.set_table();
+                    flags.set_alias_region(Some(ir::AliasRegion::Table));
                     builder.ins().load(ty, flags, addr, offset)
                 }
-                GlobalVariable::Custom => environ.translate_custom_global_get(
-                    builder.cursor(),
-                    GlobalIndex::from_u32(*global_index),
-                )?,
+                GlobalVariable::Custom => environ
+                    .translate_custom_global_get(builder, GlobalIndex::from_u32(*global_index))?,
             };
             state.push1(val);
         }
@@ -195,7 +192,7 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
                     let addr = builder.ins().global_value(environ.pointer_type(), gv);
                     let mut flags = ir::MemFlags::trusted();
                     // Put globals in the "table" abstract heap category as well.
-                    flags.set_table();
+                    flags.set_alias_region(Some(ir::AliasRegion::Table));
                     let mut val = state.pop1();
                     // Ensure SIMD values are cast to their default Cranelift type, I8x16.
                     if ty.is_vector() {
@@ -208,7 +205,7 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
                 GlobalVariable::Custom => {
                     let val = state.pop1();
                     environ.translate_custom_global_set(
-                        builder.cursor(),
+                        builder,
                         GlobalIndex::from_u32(*global_index),
                         val,
                     )?;
@@ -640,13 +637,11 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
         Operator::CallIndirect {
             type_index,
             table_index,
-            table_byte: _,
         } => {
             // `type_index` is the index of the function's signature and
             // `table_index` is the index of the table to search the function
             // in.
             let (sigref, num_args) = state.get_indirect_sig(builder.func, *type_index, environ)?;
-            let table = state.get_or_create_table(builder.func, *table_index, environ)?;
             let callee = state.pop1();
 
             // Bitcast any vector arguments to their default type, I8X16, before calling.
@@ -656,12 +651,18 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
             let call = environ.translate_call_indirect(
                 builder,
                 TableIndex::from_u32(*table_index),
-                table,
                 TypeIndex::from_u32(*type_index),
                 sigref,
                 callee,
                 state.peekn(num_args),
             )?;
+            let call = match call {
+                Some(call) => call,
+                None => {
+                    state.reachable = false;
+                    return Ok(());
+                }
+            };
             let inst_results = builder.inst_results(call);
             debug_assert_eq!(
                 inst_results.len(),
@@ -708,7 +709,6 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
             // `table_index` is the index of the table to search the function
             // in.
             let (sigref, num_args) = state.get_indirect_sig(builder.func, *type_index, environ)?;
-            let table = state.get_or_create_table(builder.func, *table_index, environ)?;
             let callee = state.pop1();
 
             // Bitcast any vector arguments to their default type, I8X16, before calling.
@@ -718,7 +718,6 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
             environ.translate_return_call_indirect(
                 builder,
                 TableIndex::from_u32(*table_index),
-                table,
                 TypeIndex::from_u32(*type_index),
                 sigref,
                 callee,
@@ -748,7 +747,7 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
          * Memory management is handled by environment. It is usually translated into calls to
          * special functions.
          ************************************************************************************/
-        Operator::MemoryGrow { mem, mem_byte: _ } => {
+        Operator::MemoryGrow { mem } => {
             // The WebAssembly MVP only supports one linear memory, but we expect the reserved
             // argument to be a memory index.
             let heap_index = MemoryIndex::from_u32(*mem);
@@ -757,7 +756,7 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
             environ.before_memory_grow(builder, val, heap_index);
             state.push1(environ.translate_memory_grow(builder.cursor(), heap_index, heap, val)?)
         }
-        Operator::MemorySize { mem, mem_byte: _ } => {
+        Operator::MemorySize { mem } => {
             let heap_index = MemoryIndex::from_u32(*mem);
             let heap = state.get_heap(builder.func, *mem, environ)?;
             state.push1(environ.translate_memory_size(builder.cursor(), heap_index, heap)?);
@@ -1543,54 +1542,43 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
             environ.translate_data_drop(builder.cursor(), *data_index)?;
         }
         Operator::TableSize { table: index } => {
-            let table = state.get_or_create_table(builder.func, *index, environ)?;
-            state.push1(environ.translate_table_size(
-                builder.cursor(),
-                TableIndex::from_u32(*index),
-                table,
-            )?);
+            state.push1(
+                environ.translate_table_size(builder.cursor(), TableIndex::from_u32(*index))?,
+            );
         }
         Operator::TableGrow { table: index } => {
             let table_index = TableIndex::from_u32(*index);
-            let table = state.get_or_create_table(builder.func, *index, environ)?;
             let delta = state.pop1();
             let init_value = state.pop1();
             state.push1(environ.translate_table_grow(
                 builder.cursor(),
                 table_index,
-                table,
                 delta,
                 init_value,
             )?);
         }
         Operator::TableGet { table: index } => {
             let table_index = TableIndex::from_u32(*index);
-            let table = state.get_or_create_table(builder.func, *index, environ)?;
             let index = state.pop1();
-            state.push1(environ.translate_table_get(builder, table_index, table, index)?);
+            state.push1(environ.translate_table_get(builder, table_index, index)?);
         }
         Operator::TableSet { table: index } => {
             let table_index = TableIndex::from_u32(*index);
-            let table = state.get_or_create_table(builder.func, *index, environ)?;
             let value = state.pop1();
             let index = state.pop1();
-            environ.translate_table_set(builder, table_index, table, value, index)?;
+            environ.translate_table_set(builder, table_index, value, index)?;
         }
         Operator::TableCopy {
             dst_table: dst_table_index,
             src_table: src_table_index,
         } => {
-            let dst_table = state.get_or_create_table(builder.func, *dst_table_index, environ)?;
-            let src_table = state.get_or_create_table(builder.func, *src_table_index, environ)?;
             let len = state.pop1();
             let src = state.pop1();
             let dest = state.pop1();
             environ.translate_table_copy(
                 builder.cursor(),
                 TableIndex::from_u32(*dst_table_index),
-                dst_table,
                 TableIndex::from_u32(*src_table_index),
-                src_table,
                 dest,
                 src,
                 len,
@@ -1607,7 +1595,6 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
             elem_index,
             table: table_index,
         } => {
-            let table = state.get_or_create_table(builder.func, *table_index, environ)?;
             let len = state.pop1();
             let src = state.pop1();
             let dest = state.pop1();
@@ -1615,7 +1602,6 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
                 builder.cursor(),
                 *elem_index,
                 TableIndex::from_u32(*table_index),
-                table,
                 dest,
                 src,
                 len,
@@ -1701,17 +1687,17 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
         | Operator::V128Store32Lane { memarg, lane }
         | Operator::V128Store64Lane { memarg, lane } => {
             let vector = pop1_with_bitcast(state, type_of(op), builder);
-            state.push1(builder.ins().extractlane(vector, lane.clone()));
+            state.push1(builder.ins().extractlane(vector, *lane));
             translate_store(memarg, ir::Opcode::Store, builder, state, environ)?;
         }
         Operator::I8x16ExtractLaneS { lane } | Operator::I16x8ExtractLaneS { lane } => {
             let vector = pop1_with_bitcast(state, type_of(op), builder);
-            let extracted = builder.ins().extractlane(vector, lane.clone());
+            let extracted = builder.ins().extractlane(vector, *lane);
             state.push1(builder.ins().sextend(I32, extracted))
         }
         Operator::I8x16ExtractLaneU { lane } | Operator::I16x8ExtractLaneU { lane } => {
             let vector = pop1_with_bitcast(state, type_of(op), builder);
-            let extracted = builder.ins().extractlane(vector, lane.clone());
+            let extracted = builder.ins().extractlane(vector, *lane);
             state.push1(builder.ins().uextend(I32, extracted));
             // On x86, PEXTRB zeroes the upper bits of the destination register of extractlane so
             // uextend could be elided; for now, uextend is needed for Cranelift's type checks to
@@ -1722,7 +1708,7 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
         | Operator::F32x4ExtractLane { lane }
         | Operator::F64x2ExtractLane { lane } => {
             let vector = pop1_with_bitcast(state, type_of(op), builder);
-            state.push1(builder.ins().extractlane(vector, lane.clone()))
+            state.push1(builder.ins().extractlane(vector, *lane))
         }
         Operator::I8x16ReplaceLane { lane } | Operator::I16x8ReplaceLane { lane } => {
             let (vector, replacement) = state.pop2();
@@ -2503,8 +2489,99 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
             state.push1(r);
         }
 
-        Operator::RefI31 | Operator::I31GetS | Operator::I31GetU => {
-            unimplemented!("GC operators not yet implemented")
+        Operator::RefI31 => {
+            let val = state.pop1();
+            let i31ref = environ.translate_ref_i31(builder.cursor(), val)?;
+            state.push1(i31ref);
+        }
+        Operator::I31GetS => {
+            let i31ref = state.pop1();
+            let val = environ.translate_i31_get_s(builder.cursor(), i31ref)?;
+            state.push1(val);
+        }
+        Operator::I31GetU => {
+            let i31ref = state.pop1();
+            let val = environ.translate_i31_get_u(builder.cursor(), i31ref)?;
+            state.push1(val);
+        }
+
+        Operator::TryTable { .. } | Operator::ThrowRef => {
+            return Err(wasm_unsupported!(
+                "exception operators are not yet implemented"
+            ));
+        }
+
+        Operator::RefEq
+        | Operator::RefTestNonNull { .. }
+        | Operator::RefTestNullable { .. }
+        | Operator::RefCastNonNull { .. }
+        | Operator::RefCastNullable { .. }
+        | Operator::BrOnCast { .. }
+        | Operator::BrOnCastFail { .. }
+        | Operator::AnyConvertExtern
+        | Operator::ExternConvertAny
+        | Operator::ArrayNew { .. }
+        | Operator::ArrayNewDefault { .. }
+        | Operator::ArrayNewFixed { .. }
+        | Operator::ArrayNewData { .. }
+        | Operator::ArrayNewElem { .. }
+        | Operator::ArrayGet { .. }
+        | Operator::ArrayGetU { .. }
+        | Operator::ArrayGetS { .. }
+        | Operator::ArraySet { .. }
+        | Operator::ArrayLen { .. }
+        | Operator::ArrayFill { .. }
+        | Operator::ArrayCopy { .. }
+        | Operator::ArrayInitData { .. }
+        | Operator::ArrayInitElem { .. }
+        | Operator::StructNew { .. }
+        | Operator::StructNewDefault { .. }
+        | Operator::StructGetS { .. }
+        | Operator::StructGetU { .. }
+        | Operator::StructSet { .. }
+        | Operator::StructGet { .. } => {
+            return Err(wasm_unsupported!("GC operators are not yet implemented"));
+        }
+
+        Operator::GlobalAtomicGet { .. }
+        | Operator::GlobalAtomicSet { .. }
+        | Operator::GlobalAtomicRmwAdd { .. }
+        | Operator::GlobalAtomicRmwSub { .. }
+        | Operator::GlobalAtomicRmwOr { .. }
+        | Operator::GlobalAtomicRmwXor { .. }
+        | Operator::GlobalAtomicRmwAnd { .. }
+        | Operator::GlobalAtomicRmwXchg { .. }
+        | Operator::GlobalAtomicRmwCmpxchg { .. }
+        | Operator::TableAtomicGet { .. }
+        | Operator::TableAtomicSet { .. }
+        | Operator::TableAtomicRmwXchg { .. }
+        | Operator::TableAtomicRmwCmpxchg { .. }
+        | Operator::StructAtomicGet { .. }
+        | Operator::StructAtomicGetS { .. }
+        | Operator::StructAtomicGetU { .. }
+        | Operator::StructAtomicSet { .. }
+        | Operator::StructAtomicRmwAdd { .. }
+        | Operator::StructAtomicRmwSub { .. }
+        | Operator::StructAtomicRmwOr { .. }
+        | Operator::StructAtomicRmwXor { .. }
+        | Operator::StructAtomicRmwAnd { .. }
+        | Operator::StructAtomicRmwXchg { .. }
+        | Operator::StructAtomicRmwCmpxchg { .. }
+        | Operator::ArrayAtomicGet { .. }
+        | Operator::ArrayAtomicGetS { .. }
+        | Operator::ArrayAtomicGetU { .. }
+        | Operator::ArrayAtomicSet { .. }
+        | Operator::ArrayAtomicRmwAdd { .. }
+        | Operator::ArrayAtomicRmwSub { .. }
+        | Operator::ArrayAtomicRmwOr { .. }
+        | Operator::ArrayAtomicRmwXor { .. }
+        | Operator::ArrayAtomicRmwAnd { .. }
+        | Operator::ArrayAtomicRmwXchg { .. }
+        | Operator::ArrayAtomicRmwCmpxchg { .. }
+        | Operator::RefI31Shared { .. } => {
+            return Err(wasm_unsupported!(
+                "shared-everything-threads operators are not yet implemented"
+            ));
         }
     };
     Ok(())
@@ -2685,7 +2762,7 @@ where
     // `addr32 + offset` to `addr32 + offset + width` (not inclusive). In this
     // scenario our adjusted offset that we're checking is `memarg.offset +
     // access_size`. Note that we do saturating arithmetic here to avoid
-    // overflow. THe addition here is in the 64-bit space, which means that
+    // overflow. The addition here is in the 64-bit space, which means that
     // we'll never overflow for 32-bit wasm but for 64-bit this is an issue. If
     // our effective offset is u64::MAX though then it's impossible for for
     // that to actually be a valid offset because otherwise the wasm linear
@@ -2736,7 +2813,7 @@ where
     //   legalization of `heap_addr`, eliding the bounds check entirely.
     //
     // * For wasm64 offsets <=2gb will generate a single `heap_addr`
-    //   instruction, but at this time all heaps are "dyanmic" which means that
+    //   instruction, but at this time all heaps are "dynamic" which means that
     //   a single bounds check is forced. Ideally we'd do better here, but
     //   that's the current state of affairs.
     //
@@ -2811,11 +2888,16 @@ where
     let mut flags = MemFlags::new();
     flags.set_endianness(ir::Endianness::Little);
 
+    if heap.memory_type.is_some() {
+        // Proof-carrying code is enabled; check this memory access.
+        flags.set_checked();
+    }
+
     // The access occurs to the `heap` disjoint category of abstract
     // state. This may allow alias analysis to merge redundant loads,
     // etc. when heap accesses occur interleaved with other (table,
     // vmctx, stack) accesses.
-    flags.set_heap();
+    flags.set_alias_region(Some(ir::AliasRegion::Heap));
 
     Ok(Reachability::Reachable((flags, index, addr)))
 }
@@ -2943,7 +3025,7 @@ fn mem_op_size(opcode: ir::Opcode, ty: Type) -> u8 {
         ir::Opcode::Istore16 | ir::Opcode::Sload16 | ir::Opcode::Uload16 => 2,
         ir::Opcode::Istore32 | ir::Opcode::Sload32 | ir::Opcode::Uload32 => 4,
         ir::Opcode::Store | ir::Opcode::Load => u8::try_from(ty.bytes()).unwrap(),
-        _ => panic!("unknown size of mem op for {:?}", opcode),
+        _ => panic!("unknown size of mem op for {opcode:?}"),
     }
 }
 
diff --git a/cranelift/wasm/src/code_translator/bounds_checks.rs b/cranelift/wasm/src/code_translator/bounds_checks.rs
index 5b4d48e03cb2..c66eb8001acb 100644
--- a/cranelift/wasm/src/code_translator/bounds_checks.rs
+++ b/cranelift/wasm/src/code_translator/bounds_checks.rs
@@ -24,6 +24,7 @@ use crate::{FuncEnvironment, HeapData, HeapStyle};
 use cranelift_codegen::{
     cursor::{Cursor, FuncCursor},
     ir::{self, condcodes::IntCC, InstBuilder, RelSourceLoc},
+    ir::{Expr, Fact},
 };
 use cranelift_frontend::FunctionBuilder;
 use wasmtime_types::WasmResult;
@@ -48,14 +49,73 @@ pub fn bounds_check_and_compute_addr<Env>(
 where
     Env: FuncEnvironment + ?Sized,
 {
+    let pointer_bit_width = u16::try_from(env.pointer_type().bits()).unwrap();
+    let orig_index = index;
     let index = cast_index_to_pointer_ty(
         index,
         heap.index_type,
         env.pointer_type(),
+        heap.memory_type.is_some(),
         &mut builder.cursor(),
     );
     let offset_and_size = offset_plus_size(offset, access_size);
     let spectre_mitigations_enabled = env.heap_access_spectre_mitigation();
+    let pcc = env.proof_carrying_code();
+
+    let host_page_size_log2 = env.target_config().page_size_align_log2;
+    let can_use_virtual_memory = heap.page_size_log2 >= host_page_size_log2;
+
+    let make_compare = |builder: &mut FunctionBuilder,
+                        compare_kind: IntCC,
+                        lhs: ir::Value,
+                        lhs_off: Option<i64>,
+                        rhs: ir::Value,
+                        rhs_off: Option<i64>| {
+        let result = builder.ins().icmp(compare_kind, lhs, rhs);
+        if pcc {
+            // Name the original value as a def of the SSA value;
+            // if the value was extended, name that as well with a
+            // dynamic range, overwriting the basic full-range
+            // fact that we previously put on the uextend.
+            builder.func.dfg.facts[orig_index] = Some(Fact::Def { value: orig_index });
+            if index != orig_index {
+                builder.func.dfg.facts[index] = Some(Fact::value(pointer_bit_width, orig_index));
+            }
+
+            // Create a fact on the LHS that is a "trivial symbolic
+            // fact": v1 has range v1+LHS_off..=v1+LHS_off
+            builder.func.dfg.facts[lhs] = Some(Fact::value_offset(
+                pointer_bit_width,
+                orig_index,
+                lhs_off.unwrap(),
+            ));
+            // If the RHS is a symbolic value (v1 or gv1), we can
+            // emit a Compare fact.
+            if let Some(rhs) = builder.func.dfg.facts[rhs]
+                .as_ref()
+                .and_then(|f| f.as_symbol())
+            {
+                builder.func.dfg.facts[result] = Some(Fact::Compare {
+                    kind: compare_kind,
+                    lhs: Expr::offset(&Expr::value(orig_index), lhs_off.unwrap()).unwrap(),
+                    rhs: Expr::offset(rhs, rhs_off.unwrap()).unwrap(),
+                });
+            }
+            // Likewise, if the RHS is a constant, we can emit a
+            // Compare fact.
+            if let Some(k) = builder.func.dfg.facts[rhs]
+                .as_ref()
+                .and_then(|f| f.as_const(pointer_bit_width))
+            {
+                builder.func.dfg.facts[result] = Some(Fact::Compare {
+                    kind: compare_kind,
+                    lhs: Expr::offset(&Expr::value(orig_index), lhs_off.unwrap()).unwrap(),
+                    rhs: Expr::constant((k as i64).checked_add(rhs_off.unwrap()).unwrap()),
+                });
+            }
+        }
+        result
+    };
 
     // We need to emit code that will trap (or compute an address that will trap
     // when accessed) if
@@ -84,17 +144,24 @@ where
         //            index + 1 > bound
         //        ==> index >= bound
         HeapStyle::Dynamic { bound_gv } if offset_and_size == 1 => {
-            let bound = builder.ins().global_value(env.pointer_type(), bound_gv);
-            let oob = builder
-                .ins()
-                .icmp(IntCC::UnsignedGreaterThanOrEqual, index, bound);
+            let bound = get_dynamic_heap_bound(builder, env, heap);
+            let oob = make_compare(
+                builder,
+                IntCC::UnsignedGreaterThanOrEqual,
+                index,
+                Some(0),
+                bound,
+                Some(0),
+            );
             Reachable(explicit_check_oob_condition_and_compute_addr(
                 &mut builder.cursor(),
                 heap,
                 env.pointer_type(),
                 index,
                 offset,
+                access_size,
                 spectre_mitigations_enabled,
+                AddrPcc::dynamic(heap.memory_type, bound_gv),
                 oob,
             ))
         }
@@ -124,16 +191,27 @@ where
         //    offset immediates -- which is a common code pattern when accessing
         //    multiple fields in the same struct that is in linear memory --
         //    will all emit the same `index > bound` check, which we can GVN.
-        HeapStyle::Dynamic { bound_gv } if offset_and_size <= heap.offset_guard_size => {
-            let bound = builder.ins().global_value(env.pointer_type(), bound_gv);
-            let oob = builder.ins().icmp(IntCC::UnsignedGreaterThan, index, bound);
+        HeapStyle::Dynamic { bound_gv }
+            if can_use_virtual_memory && offset_and_size <= heap.offset_guard_size =>
+        {
+            let bound = get_dynamic_heap_bound(builder, env, heap);
+            let oob = make_compare(
+                builder,
+                IntCC::UnsignedGreaterThan,
+                index,
+                Some(0),
+                bound,
+                Some(0),
+            );
             Reachable(explicit_check_oob_condition_and_compute_addr(
                 &mut builder.cursor(),
                 heap,
                 env.pointer_type(),
                 index,
                 offset,
+                access_size,
                 spectre_mitigations_enabled,
+                AddrPcc::dynamic(heap.memory_type, bound_gv),
                 oob,
             ))
         }
@@ -146,18 +224,38 @@ where
         //            index + offset + access_size > bound
         //        ==> index > bound - (offset + access_size)
         HeapStyle::Dynamic { bound_gv } if offset_and_size <= heap.min_size.into() => {
-            let bound = builder.ins().global_value(env.pointer_type(), bound_gv);
-            let adjusted_bound = builder.ins().iadd_imm(bound, -(offset_and_size as i64));
-            let oob = builder
-                .ins()
-                .icmp(IntCC::UnsignedGreaterThan, index, adjusted_bound);
+            let bound = get_dynamic_heap_bound(builder, env, heap);
+            let adjustment = offset_and_size as i64;
+            let adjustment_value = builder.ins().iconst(env.pointer_type(), adjustment);
+            if pcc {
+                builder.func.dfg.facts[adjustment_value] =
+                    Some(Fact::constant(pointer_bit_width, offset_and_size));
+            }
+            let adjusted_bound = builder.ins().isub(bound, adjustment_value);
+            if pcc {
+                builder.func.dfg.facts[adjusted_bound] = Some(Fact::global_value_offset(
+                    pointer_bit_width,
+                    bound_gv,
+                    -adjustment,
+                ));
+            }
+            let oob = make_compare(
+                builder,
+                IntCC::UnsignedGreaterThan,
+                index,
+                Some(0),
+                adjusted_bound,
+                Some(adjustment),
+            );
             Reachable(explicit_check_oob_condition_and_compute_addr(
                 &mut builder.cursor(),
                 heap,
                 env.pointer_type(),
                 index,
                 offset,
+                access_size,
                 spectre_mitigations_enabled,
+                AddrPcc::dynamic(heap.memory_type, bound_gv),
                 oob,
             ))
         }
@@ -170,23 +268,43 @@ where
         HeapStyle::Dynamic { bound_gv } => {
             let access_size_val = builder
                 .ins()
+                // Explicit cast from u64 to i64: we just want the raw
+                // bits, and iconst takes an `Imm64`.
                 .iconst(env.pointer_type(), offset_and_size as i64);
+            if pcc {
+                builder.func.dfg.facts[access_size_val] =
+                    Some(Fact::constant(pointer_bit_width, offset_and_size));
+            }
             let adjusted_index = builder.ins().uadd_overflow_trap(
                 index,
                 access_size_val,
                 ir::TrapCode::HeapOutOfBounds,
             );
-            let bound = builder.ins().global_value(env.pointer_type(), bound_gv);
-            let oob = builder
-                .ins()
-                .icmp(IntCC::UnsignedGreaterThan, adjusted_index, bound);
+            if pcc {
+                builder.func.dfg.facts[adjusted_index] = Some(Fact::value_offset(
+                    pointer_bit_width,
+                    index,
+                    i64::try_from(offset_and_size).unwrap(),
+                ));
+            }
+            let bound = get_dynamic_heap_bound(builder, env, heap);
+            let oob = make_compare(
+                builder,
+                IntCC::UnsignedGreaterThan,
+                adjusted_index,
+                i64::try_from(offset_and_size).ok(),
+                bound,
+                Some(0),
+            );
             Reachable(explicit_check_oob_condition_and_compute_addr(
                 &mut builder.cursor(),
                 heap,
                 env.pointer_type(),
                 index,
                 offset,
+                access_size,
                 spectre_mitigations_enabled,
+                AddrPcc::dynamic(heap.memory_type, bound_gv),
                 oob,
             ))
         }
@@ -200,6 +318,10 @@ where
         //    bound`, since we will end up being out-of-bounds regardless of the
         //    given `index`.
         HeapStyle::Static { bound } if offset_and_size > bound.into() => {
+            assert!(
+                can_use_virtual_memory,
+                "static memories require the ability to use virtual memory"
+            );
             env.before_unconditionally_trapping_memory_access(builder)?;
             builder.ins().trap(ir::TrapCode::HeapOutOfBounds);
             Unreachable
@@ -244,16 +366,25 @@ where
         //    within the guard page region, neither of which require emitting an
         //    explicit bounds check.
         HeapStyle::Static { bound }
-            if heap.index_type == ir::types::I32
+            if can_use_virtual_memory
+                && heap.index_type == ir::types::I32
                 && u64::from(u32::MAX)
                     <= u64::from(bound) + u64::from(heap.offset_guard_size) - offset_and_size =>
         {
+            assert!(
+                can_use_virtual_memory,
+                "static memories require the ability to use virtual memory"
+            );
             Reachable(compute_addr(
                 &mut builder.cursor(),
                 heap,
                 env.pointer_type(),
                 index,
                 offset,
+                AddrPcc::static32(
+                    heap.memory_type,
+                    u64::from(bound) + u64::from(heap.offset_guard_size),
+                ),
             ))
         }
 
@@ -269,30 +400,98 @@ where
         //    precise, not rely on the virtual memory subsystem at all, and not
         //    factor in the guard pages here.
         HeapStyle::Static { bound } => {
+            assert!(
+                can_use_virtual_memory,
+                "static memories require the ability to use virtual memory"
+            );
             // NB: this subtraction cannot wrap because we didn't hit the first
             // special case.
             let adjusted_bound = u64::from(bound) - offset_and_size;
-            let oob =
-                builder
-                    .ins()
-                    .icmp_imm(IntCC::UnsignedGreaterThan, index, adjusted_bound as i64);
+            let adjusted_bound_value = builder
+                .ins()
+                .iconst(env.pointer_type(), adjusted_bound as i64);
+            if pcc {
+                builder.func.dfg.facts[adjusted_bound_value] =
+                    Some(Fact::constant(pointer_bit_width, adjusted_bound));
+            }
+            let oob = make_compare(
+                builder,
+                IntCC::UnsignedGreaterThan,
+                index,
+                Some(0),
+                adjusted_bound_value,
+                Some(0),
+            );
             Reachable(explicit_check_oob_condition_and_compute_addr(
                 &mut builder.cursor(),
                 heap,
                 env.pointer_type(),
                 index,
                 offset,
+                access_size,
                 spectre_mitigations_enabled,
+                AddrPcc::static32(heap.memory_type, u64::from(bound)),
                 oob,
             ))
         }
     })
 }
 
+/// Get the bound of a dynamic heap as an `ir::Value`.
+fn get_dynamic_heap_bound<Env>(
+    builder: &mut FunctionBuilder,
+    env: &mut Env,
+    heap: &HeapData,
+) -> ir::Value
+where
+    Env: FuncEnvironment + ?Sized,
+{
+    let enable_pcc = heap.memory_type.is_some();
+
+    let (value, gv) = match (heap.max_size, &heap.style) {
+        // The heap has a constant size, no need to actually load the
+        // bound.  TODO: this is currently disabled for PCC because we
+        // can't easily prove that the GV load indeed results in a
+        // constant (that information is lost in the CLIF). We'll want
+        // to create an `iconst` GV expression kind to reify this fact
+        // in the GV, then re-enable this opt. (Or, alternately,
+        // compile such memories with a static-bound memtype and
+        // facts.)
+        (Some(max_size), HeapStyle::Dynamic { bound_gv })
+            if heap.min_size == max_size && !enable_pcc =>
+        {
+            (
+                builder.ins().iconst(env.pointer_type(), max_size as i64),
+                *bound_gv,
+            )
+        }
+
+        // Load the heap bound from its global variable.
+        (_, HeapStyle::Dynamic { bound_gv }) => (
+            builder.ins().global_value(env.pointer_type(), *bound_gv),
+            *bound_gv,
+        ),
+
+        (_, HeapStyle::Static { .. }) => unreachable!("not a dynamic heap"),
+    };
+
+    // If proof-carrying code is enabled, apply a fact to the range to
+    // tie it to the GV.
+    if enable_pcc {
+        builder.func.dfg.facts[value] = Some(Fact::global_value(
+            u16::try_from(env.pointer_type().bits()).unwrap(),
+            gv,
+        ));
+    }
+
+    value
+}
+
 fn cast_index_to_pointer_ty(
     index: ir::Value,
     index_ty: ir::Type,
     pointer_ty: ir::Type,
+    pcc: bool,
     pos: &mut FuncCursor,
 ) -> ir::Value {
     if index_ty == pointer_ty {
@@ -307,6 +506,14 @@ fn cast_index_to_pointer_ty(
     // Convert `index` to `addr_ty`.
     let extended_index = pos.ins().uextend(pointer_ty, index);
 
+    // Add a range fact on the extended value.
+    if pcc {
+        pos.func.dfg.facts[extended_index] = Some(Fact::max_range_for_width_extended(
+            u16::try_from(index_ty.bits()).unwrap(),
+            u16::try_from(pointer_ty.bits()).unwrap(),
+        ));
+    }
+
     // Add debug value-label alias so that debuginfo can name the extended
     // value as the address
     let loc = pos.srcloc();
@@ -319,6 +526,25 @@ fn cast_index_to_pointer_ty(
     extended_index
 }
 
+/// Which facts do we want to emit for proof-carrying code, if any, on
+/// address computations?
+#[derive(Clone, Copy, Debug)]
+enum AddrPcc {
+    /// A 32-bit static memory with the given size.
+    Static32(ir::MemoryType, u64),
+    /// Dynamic bounds-check, with actual memory size (the `GlobalValue`)
+    /// expressed symbolically.
+    Dynamic(ir::MemoryType, ir::GlobalValue),
+}
+impl AddrPcc {
+    fn static32(memory_type: Option<ir::MemoryType>, size: u64) -> Option<Self> {
+        memory_type.map(|ty| AddrPcc::Static32(ty, size))
+    }
+    fn dynamic(memory_type: Option<ir::MemoryType>, bound: ir::GlobalValue) -> Option<Self> {
+        memory_type.map(|ty| AddrPcc::Dynamic(ty, bound))
+    }
+}
+
 /// Emit explicit checks on the given out-of-bounds condition for the Wasm
 /// address and return the native address.
 ///
@@ -330,8 +556,11 @@ fn explicit_check_oob_condition_and_compute_addr(
     addr_ty: ir::Type,
     index: ir::Value,
     offset: u32,
+    access_size: u8,
     // Whether Spectre mitigations are enabled for heap accesses.
     spectre_mitigations_enabled: bool,
+    // Whether we're emitting PCC facts.
+    pcc: Option<AddrPcc>,
     // The `i8` boolean value that is non-zero when the heap access is out of
     // bounds (and therefore we should trap) and is zero when the heap access is
     // in bounds (and therefore we can proceed).
@@ -342,11 +571,42 @@ fn explicit_check_oob_condition_and_compute_addr(
             .trapnz(oob_condition, ir::TrapCode::HeapOutOfBounds);
     }
 
-    let mut addr = compute_addr(pos, heap, addr_ty, index, offset);
+    let mut addr = compute_addr(pos, heap, addr_ty, index, offset, pcc);
 
     if spectre_mitigations_enabled {
         let null = pos.ins().iconst(addr_ty, 0);
         addr = pos.ins().select_spectre_guard(oob_condition, null, addr);
+
+        match pcc {
+            None => {}
+            Some(AddrPcc::Static32(ty, size)) => {
+                pos.func.dfg.facts[null] =
+                    Some(Fact::constant(u16::try_from(addr_ty.bits()).unwrap(), 0));
+                pos.func.dfg.facts[addr] = Some(Fact::Mem {
+                    ty,
+                    min_offset: 0,
+                    max_offset: size.checked_sub(u64::from(access_size)).unwrap(),
+                    nullable: true,
+                });
+            }
+            Some(AddrPcc::Dynamic(ty, gv)) => {
+                pos.func.dfg.facts[null] =
+                    Some(Fact::constant(u16::try_from(addr_ty.bits()).unwrap(), 0));
+                pos.func.dfg.facts[addr] = Some(Fact::DynamicMem {
+                    ty,
+                    min: Expr::constant(0),
+                    max: Expr::offset(
+                        &Expr::global_value(gv),
+                        i64::try_from(heap.offset_guard_size)
+                            .unwrap()
+                            .checked_sub(i64::from(access_size))
+                            .unwrap(),
+                    )
+                    .unwrap(),
+                    nullable: true,
+                });
+            }
+        }
     }
 
     addr
@@ -364,11 +624,54 @@ fn compute_addr(
     addr_ty: ir::Type,
     index: ir::Value,
     offset: u32,
+    pcc: Option<AddrPcc>,
 ) -> ir::Value {
     debug_assert_eq!(pos.func.dfg.value_type(index), addr_ty);
 
     let heap_base = pos.ins().global_value(addr_ty, heap.base);
+
+    match pcc {
+        None => {}
+        Some(AddrPcc::Static32(ty, _size)) => {
+            pos.func.dfg.facts[heap_base] = Some(Fact::Mem {
+                ty,
+                min_offset: 0,
+                max_offset: 0,
+                nullable: false,
+            });
+        }
+        Some(AddrPcc::Dynamic(ty, _limit)) => {
+            pos.func.dfg.facts[heap_base] = Some(Fact::dynamic_base_ptr(ty));
+        }
+    }
+
     let base_and_index = pos.ins().iadd(heap_base, index);
+
+    match pcc {
+        None => {}
+        Some(AddrPcc::Static32(ty, _) | AddrPcc::Dynamic(ty, _)) => {
+            if let Some(idx) = pos.func.dfg.facts[index]
+                .as_ref()
+                .and_then(|f| f.as_symbol())
+                .cloned()
+            {
+                pos.func.dfg.facts[base_and_index] = Some(Fact::DynamicMem {
+                    ty,
+                    min: idx.clone(),
+                    max: idx,
+                    nullable: false,
+                });
+            } else {
+                pos.func.dfg.facts[base_and_index] = Some(Fact::Mem {
+                    ty,
+                    min_offset: 0,
+                    max_offset: u64::from(u32::MAX),
+                    nullable: false,
+                });
+            }
+        }
+    }
+
     if offset == 0 {
         base_and_index
     } else {
@@ -376,7 +679,48 @@ fn compute_addr(
         // `select_spectre_guard`, if any. If it happens after, then we
         // potentially are letting speculative execution read the whole first
         // 4GiB of memory.
-        pos.ins().iadd_imm(base_and_index, offset as i64)
+        let offset_val = pos.ins().iconst(addr_ty, i64::from(offset));
+
+        if pcc.is_some() {
+            pos.func.dfg.facts[offset_val] = Some(Fact::constant(
+                u16::try_from(addr_ty.bits()).unwrap(),
+                u64::from(offset),
+            ));
+        }
+
+        let result = pos.ins().iadd(base_and_index, offset_val);
+
+        match pcc {
+            None => {}
+            Some(AddrPcc::Static32(ty, _) | AddrPcc::Dynamic(ty, _)) => {
+                if let Some(idx) = pos.func.dfg.facts[index]
+                    .as_ref()
+                    .and_then(|f| f.as_symbol())
+                {
+                    pos.func.dfg.facts[result] = Some(Fact::DynamicMem {
+                        ty,
+                        min: idx.clone(),
+                        // Safety: adding an offset to an expression with
+                        // zero offset -- add cannot wrap, so `unwrap()`
+                        // cannot fail.
+                        max: Expr::offset(idx, i64::from(offset)).unwrap(),
+                        nullable: false,
+                    });
+                } else {
+                    pos.func.dfg.facts[result] = Some(Fact::Mem {
+                        ty,
+                        min_offset: u64::from(offset),
+                        // Safety: can't overflow -- two u32s summed in a
+                        // 64-bit add. TODO: when memory64 is supported here,
+                        // `u32::MAX` is no longer true, and we'll need to
+                        // handle overflow here.
+                        max_offset: u64::from(u32::MAX) + u64::from(offset),
+                        nullable: false,
+                    });
+                }
+            }
+        }
+        result
     }
 }
 
diff --git a/cranelift/wasm/src/environ/dummy.rs b/cranelift/wasm/src/environ/dummy.rs
index 95f9fecece62..cb4b09bcec44 100644
--- a/cranelift/wasm/src/environ/dummy.rs
+++ b/cranelift/wasm/src/environ/dummy.rs
@@ -7,16 +7,14 @@
 
 use crate::environ::{FuncEnvironment, GlobalVariable, ModuleEnvironment, TargetEnvironment};
 use crate::func_translator::FuncTranslator;
-use crate::state::FuncTranslationState;
-use crate::WasmType;
 use crate::{
     DataIndex, DefinedFuncIndex, ElemIndex, FuncIndex, Global, GlobalIndex, GlobalInit, Heap,
-    HeapData, HeapStyle, Memory, MemoryIndex, Table, TableIndex, TypeConvert, TypeIndex,
+    HeapData, HeapStyle, Memory, MemoryIndex, Table, TableIndex, TableSize, TypeConvert, TypeIndex,
     WasmFuncType, WasmHeapType, WasmResult,
 };
-use core::convert::TryFrom;
+use crate::{TableData, WasmValType};
 use cranelift_codegen::cursor::FuncCursor;
-use cranelift_codegen::ir::immediates::{Offset32, Uimm64};
+use cranelift_codegen::ir::immediates::Offset32;
 use cranelift_codegen::ir::{self, InstBuilder};
 use cranelift_codegen::ir::{types::*, UserFuncName};
 use cranelift_codegen::isa::{CallConv, TargetFrontendConfig};
@@ -25,7 +23,8 @@ use cranelift_frontend::FunctionBuilder;
 use std::boxed::Box;
 use std::string::String;
 use std::vec::Vec;
-use wasmparser::{FuncValidator, FunctionBody, Operator, ValidatorResources, WasmFeatures};
+use wasmparser::{FuncValidator, FunctionBody, ValidatorResources, WasmFeatures};
+use wasmtime_types::wasm_unsupported;
 
 /// A collection of names under which a given entity is exported.
 pub struct Exportable<T> {
@@ -106,31 +105,6 @@ impl DummyModuleInfo {
     }
 }
 
-/// State for tracking and checking reachability at each operator. Used for unit testing with the
-/// `DummyEnvironment`.
-#[derive(Clone)]
-pub struct ExpectedReachability {
-    /// Before- and after-reachability
-    reachability: Vec<(bool, bool)>,
-    before_idx: usize,
-    after_idx: usize,
-}
-
-impl ExpectedReachability {
-    fn check_before(&mut self, reachable: bool) {
-        assert_eq!(reachable, self.reachability[self.before_idx].0);
-        self.before_idx += 1;
-    }
-    fn check_after(&mut self, reachable: bool) {
-        assert_eq!(reachable, self.reachability[self.after_idx].1);
-        self.after_idx += 1;
-    }
-    fn check_end(&self) {
-        assert_eq!(self.before_idx, self.reachability.len());
-        assert_eq!(self.after_idx, self.reachability.len());
-    }
-}
-
 /// This `ModuleEnvironment` implementation is a "naïve" one, doing essentially nothing and
 /// emitting placeholders when forced to. Don't try to execute code translated for this
 /// environment, essentially here for translation debug purposes.
@@ -149,10 +123,6 @@ pub struct DummyEnvironment {
 
     /// Function names.
     function_names: SecondaryMap<FuncIndex, String>,
-
-    /// Expected reachability data (before/after for each op) to assert. This is used for testing.
-    #[doc(hidden)]
-    pub expected_reachability: Option<ExpectedReachability>,
 }
 
 impl DummyEnvironment {
@@ -164,14 +134,13 @@ impl DummyEnvironment {
             func_bytecode_sizes: Vec::new(),
             module_name: None,
             function_names: SecondaryMap::new(),
-            expected_reachability: None,
         }
     }
 
     /// Return a `DummyFuncEnvironment` for translating functions within this
     /// `DummyEnvironment`.
     pub fn func_env(&self) -> DummyFuncEnvironment {
-        DummyFuncEnvironment::new(&self.info, self.expected_reachability.clone())
+        DummyFuncEnvironment::new(&self.info)
     }
 
     /// Get the type for the function at the given index.
@@ -189,17 +158,6 @@ impl DummyEnvironment {
     pub fn get_func_name(&self, func_index: FuncIndex) -> Option<&str> {
         self.function_names.get(func_index).map(String::as_ref)
     }
-
-    /// Test reachability bits before and after every opcode during translation, as provided by the
-    /// `FuncTranslationState`. This is generally used only for unit tests. This is applied to
-    /// every function in the module (so is likely only useful for test modules with one function).
-    pub fn test_expected_reachability(&mut self, reachability: Vec<(bool, bool)>) {
-        self.expected_reachability = Some(ExpectedReachability {
-            reachability,
-            before_idx: 0,
-            after_idx: 0,
-        });
-    }
 }
 
 /// The `FuncEnvironment` implementation for use by the `DummyEnvironment`.
@@ -207,23 +165,20 @@ pub struct DummyFuncEnvironment<'dummy_environment> {
     /// This function environment's module info.
     pub mod_info: &'dummy_environment DummyModuleInfo,
 
-    /// Expected reachability data (before/after for each op) to assert. This is used for testing.
-    expected_reachability: Option<ExpectedReachability>,
-
     /// Heaps we have created to implement Wasm linear memories.
     pub heaps: PrimaryMap<Heap, HeapData>,
+
+    /// Cranelift tables we have created to implement Wasm tables.
+    tables: SecondaryMap<TableIndex, Option<TableData>>,
 }
 
 impl<'dummy_environment> DummyFuncEnvironment<'dummy_environment> {
     /// Construct a new `DummyFuncEnvironment`.
-    pub fn new(
-        mod_info: &'dummy_environment DummyModuleInfo,
-        expected_reachability: Option<ExpectedReachability>,
-    ) -> Self {
+    pub fn new(mod_info: &'dummy_environment DummyModuleInfo) -> Self {
         Self {
             mod_info,
-            expected_reachability,
             heaps: Default::default(),
+            tables: Default::default(),
         }
     }
 
@@ -239,16 +194,51 @@ impl<'dummy_environment> DummyFuncEnvironment<'dummy_environment> {
     }
 
     fn reference_type(&self) -> ir::Type {
-        match self.pointer_type() {
-            ir::types::I32 => ir::types::R32,
-            ir::types::I64 => ir::types::R64,
-            _ => panic!("unsupported pointer type"),
+        self.pointer_type()
+    }
+
+    fn ensure_table_exists(&mut self, func: &mut ir::Function, index: TableIndex) {
+        if self.tables[index].is_some() {
+            return;
         }
+
+        // Create a table whose base address is stored at `vmctx+0`.
+        let vmctx = func.create_global_value(ir::GlobalValueData::VMContext);
+        let base_gv = func.create_global_value(ir::GlobalValueData::Load {
+            base: vmctx,
+            offset: Offset32::new(0),
+            global_type: self.pointer_type(),
+            // When tables in wasm become "growable", revisit whether this can be readonly or not.
+            flags: ir::MemFlags::trusted().with_readonly(),
+        });
+
+        let table = &self.mod_info.tables[index].entity;
+
+        let bound = if Some(table.minimum) == table.maximum {
+            TableSize::Static {
+                bound: table.minimum,
+            }
+        } else {
+            TableSize::Dynamic {
+                bound_gv: func.create_global_value(ir::GlobalValueData::Load {
+                    base: vmctx,
+                    offset: Offset32::new(0),
+                    global_type: I32,
+                    flags: ir::MemFlags::trusted().with_readonly(),
+                }),
+            }
+        };
+
+        self.tables[index] = Some(TableData {
+            base_gv,
+            bound,
+            element_size: u32::from(self.pointer_bytes()) * 2,
+        });
     }
 }
 
 impl<'dummy_environment> TypeConvert for DummyFuncEnvironment<'dummy_environment> {
-    fn lookup_heap_type(&self, _index: TypeIndex) -> WasmHeapType {
+    fn lookup_heap_type(&self, _index: wasmparser::UnpackedIndex) -> WasmHeapType {
         unimplemented!()
     }
 }
@@ -261,6 +251,10 @@ impl<'dummy_environment> TargetEnvironment for DummyFuncEnvironment<'dummy_envir
     fn heap_access_spectre_mitigation(&self) -> bool {
         false
     }
+
+    fn proof_carrying_code(&self) -> bool {
+        false
+    }
 }
 
 impl<'dummy_environment> FuncEnvironment for DummyFuncEnvironment<'dummy_environment> {
@@ -276,12 +270,12 @@ impl<'dummy_environment> FuncEnvironment for DummyFuncEnvironment<'dummy_environ
             gv: vmctx,
             offset,
             ty: match self.mod_info.globals[index].entity.wasm_ty {
-                WasmType::I32 => ir::types::I32,
-                WasmType::I64 => ir::types::I64,
-                WasmType::F32 => ir::types::F32,
-                WasmType::F64 => ir::types::F64,
-                WasmType::V128 => ir::types::I8X16,
-                WasmType::Ref(_) => ir::types::R64,
+                WasmValType::I32 => ir::types::I32,
+                WasmValType::I64 => ir::types::I64,
+                WasmValType::F32 => ir::types::F32,
+                WasmValType::F64 => ir::types::F64,
+                WasmValType::V128 => ir::types::I8X16,
+                WasmValType::Ref(_) => self.pointer_type(),
             },
         })
     }
@@ -297,42 +291,19 @@ impl<'dummy_environment> FuncEnvironment for DummyFuncEnvironment<'dummy_environ
             base: addr,
             offset: Offset32::new(0),
             global_type: self.pointer_type(),
-            readonly: true,
+            flags: ir::MemFlags::trusted().with_readonly(),
         });
 
         Ok(self.heaps.push(HeapData {
             base: gv,
             min_size: 0,
+            max_size: None,
             offset_guard_size: 0x8000_0000,
             style: HeapStyle::Static {
                 bound: 0x1_0000_0000,
             },
             index_type: I32,
-        }))
-    }
-
-    fn make_table(&mut self, func: &mut ir::Function, _index: TableIndex) -> WasmResult<ir::Table> {
-        // Create a table whose base address is stored at `vmctx+0`.
-        let vmctx = func.create_global_value(ir::GlobalValueData::VMContext);
-        let base_gv = func.create_global_value(ir::GlobalValueData::Load {
-            base: vmctx,
-            offset: Offset32::new(0),
-            global_type: self.pointer_type(),
-            readonly: true, // when tables in wasm become "growable", revisit whether this can be readonly or not.
-        });
-        let bound_gv = func.create_global_value(ir::GlobalValueData::Load {
-            base: vmctx,
-            offset: Offset32::new(0),
-            global_type: I32,
-            readonly: true,
-        });
-
-        Ok(func.create_table(ir::TableData {
-            base_gv,
-            min_size: Uimm64::new(0),
-            bound_gv,
-            element_size: Uimm64::from(u64::from(self.pointer_bytes()) * 2),
-            index_type: I32,
+            memory_type: None,
         }))
     }
 
@@ -367,51 +338,15 @@ impl<'dummy_environment> FuncEnvironment for DummyFuncEnvironment<'dummy_environ
         }))
     }
 
-    fn before_translate_operator(
-        &mut self,
-        _op: &Operator,
-        _builder: &mut FunctionBuilder,
-        state: &FuncTranslationState,
-    ) -> WasmResult<()> {
-        if let Some(ref mut r) = &mut self.expected_reachability {
-            r.check_before(state.reachable());
-        }
-        Ok(())
-    }
-
-    fn after_translate_operator(
-        &mut self,
-        _op: &Operator,
-        _builder: &mut FunctionBuilder,
-        state: &FuncTranslationState,
-    ) -> WasmResult<()> {
-        if let Some(ref mut r) = &mut self.expected_reachability {
-            r.check_after(state.reachable());
-        }
-        Ok(())
-    }
-
-    fn after_translate_function(
-        &mut self,
-        _builder: &mut FunctionBuilder,
-        _state: &FuncTranslationState,
-    ) -> WasmResult<()> {
-        if let Some(ref mut r) = &mut self.expected_reachability {
-            r.check_end();
-        }
-        Ok(())
-    }
-
     fn translate_call_indirect(
         &mut self,
         builder: &mut FunctionBuilder,
         _table_index: TableIndex,
-        _table: ir::Table,
         _sig_index: TypeIndex,
         sig_ref: ir::SigRef,
         callee: ir::Value,
         call_args: &[ir::Value],
-    ) -> WasmResult<ir::Inst> {
+    ) -> WasmResult<Option<ir::Inst>> {
         // Pass the current function's vmctx parameter on to the callee.
         let vmctx = builder
             .func
@@ -438,17 +373,18 @@ impl<'dummy_environment> FuncEnvironment for DummyFuncEnvironment<'dummy_environ
         args.extend(call_args.iter().cloned(), &mut builder.func.dfg.value_lists);
         args.push(vmctx, &mut builder.func.dfg.value_lists);
 
-        Ok(builder
-            .ins()
-            .CallIndirect(ir::Opcode::CallIndirect, INVALID, sig_ref, args)
-            .0)
+        Ok(Some(
+            builder
+                .ins()
+                .CallIndirect(ir::Opcode::CallIndirect, INVALID, sig_ref, args)
+                .0,
+        ))
     }
 
     fn translate_return_call_indirect(
         &mut self,
         _builder: &mut FunctionBuilder,
         _table_index: TableIndex,
-        _table: ir::Table,
         _sig_index: TypeIndex,
         _sig_ref: ir::SigRef,
         _callee: ir::Value,
@@ -568,7 +504,6 @@ impl<'dummy_environment> FuncEnvironment for DummyFuncEnvironment<'dummy_environ
         &mut self,
         mut pos: FuncCursor,
         _index: TableIndex,
-        _table: ir::Table,
     ) -> WasmResult<ir::Value> {
         Ok(pos.ins().iconst(I32, -1i32 as u32 as i64))
     }
@@ -577,7 +512,6 @@ impl<'dummy_environment> FuncEnvironment for DummyFuncEnvironment<'dummy_environ
         &mut self,
         mut pos: FuncCursor,
         _table_index: TableIndex,
-        _table: ir::Table,
         _delta: ir::Value,
         _init_value: ir::Value,
     ) -> WasmResult<ir::Value> {
@@ -587,21 +521,33 @@ impl<'dummy_environment> FuncEnvironment for DummyFuncEnvironment<'dummy_environ
     fn translate_table_get(
         &mut self,
         builder: &mut FunctionBuilder,
-        _table_index: TableIndex,
-        _table: ir::Table,
-        _index: ir::Value,
+        table_index: TableIndex,
+        index: ir::Value,
     ) -> WasmResult<ir::Value> {
-        Ok(builder.ins().null(self.reference_type()))
+        let pointer_type = self.pointer_type();
+        self.ensure_table_exists(builder.func, table_index);
+        let table = self.tables[table_index].as_ref().unwrap();
+        let (table_entry_addr, flags) =
+            table.prepare_table_addr(builder, index, pointer_type, true);
+        let value = builder
+            .ins()
+            .load(self.reference_type(), flags, table_entry_addr, 0);
+        Ok(value)
     }
 
     fn translate_table_set(
         &mut self,
-        _builder: &mut FunctionBuilder,
-        _table_index: TableIndex,
-        _table: ir::Table,
-        _value: ir::Value,
-        _index: ir::Value,
+        builder: &mut FunctionBuilder,
+        table_index: TableIndex,
+        value: ir::Value,
+        index: ir::Value,
     ) -> WasmResult<()> {
+        let pointer_type = self.pointer_type();
+        self.ensure_table_exists(builder.func, table_index);
+        let table = self.tables[table_index].as_ref().unwrap();
+        let (table_entry_addr, flags) =
+            table.prepare_table_addr(builder, index, pointer_type, true);
+        builder.ins().store(flags, value, table_entry_addr, 0);
         Ok(())
     }
 
@@ -609,9 +555,7 @@ impl<'dummy_environment> FuncEnvironment for DummyFuncEnvironment<'dummy_environ
         &mut self,
         _pos: FuncCursor,
         _dst_index: TableIndex,
-        _dst_table: ir::Table,
         _src_index: TableIndex,
-        _src_table: ir::Table,
         _dst: ir::Value,
         _src: ir::Value,
         _len: ir::Value,
@@ -635,7 +579,6 @@ impl<'dummy_environment> FuncEnvironment for DummyFuncEnvironment<'dummy_environ
         _pos: FuncCursor,
         _seg_index: u32,
         _table_index: TableIndex,
-        _table: ir::Table,
         _dst: ir::Value,
         _src: ir::Value,
         _len: ir::Value,
@@ -694,10 +637,30 @@ impl<'dummy_environment> FuncEnvironment for DummyFuncEnvironment<'dummy_environ
     ) -> WasmResult<ir::Value> {
         Ok(pos.ins().iconst(I32, 0))
     }
+
+    fn translate_ref_i31(&mut self, _pos: FuncCursor, _val: ir::Value) -> WasmResult<ir::Value> {
+        Err(wasm_unsupported!("ref.i31"))
+    }
+
+    fn translate_i31_get_s(
+        &mut self,
+        _pos: FuncCursor,
+        _i31ref: ir::Value,
+    ) -> WasmResult<ir::Value> {
+        Err(wasm_unsupported!("i31.get_s"))
+    }
+
+    fn translate_i31_get_u(
+        &mut self,
+        _pos: FuncCursor,
+        _i31ref: ir::Value,
+    ) -> WasmResult<ir::Value> {
+        Err(wasm_unsupported!("i31.get_u"))
+    }
 }
 
 impl TypeConvert for DummyEnvironment {
-    fn lookup_heap_type(&self, _index: TypeIndex) -> WasmHeapType {
+    fn lookup_heap_type(&self, _index: wasmparser::UnpackedIndex) -> WasmHeapType {
         unimplemented!()
     }
 }
@@ -710,24 +673,23 @@ impl TargetEnvironment for DummyEnvironment {
     fn heap_access_spectre_mitigation(&self) -> bool {
         false
     }
+
+    fn proof_carrying_code(&self) -> bool {
+        false
+    }
 }
 
 impl<'data> ModuleEnvironment<'data> for DummyEnvironment {
     fn declare_type_func(&mut self, wasm: WasmFuncType) -> WasmResult<()> {
         let mut sig = ir::Signature::new(CallConv::Fast);
-        let mut cvt = |ty: &WasmType| {
-            let reference_type = match self.pointer_type() {
-                ir::types::I32 => ir::types::R32,
-                ir::types::I64 => ir::types::R64,
-                _ => panic!("unsupported pointer type"),
-            };
+        let mut cvt = |ty: &WasmValType| {
             ir::AbiParam::new(match ty {
-                WasmType::I32 => ir::types::I32,
-                WasmType::I64 => ir::types::I64,
-                WasmType::F32 => ir::types::F32,
-                WasmType::F64 => ir::types::F64,
-                WasmType::V128 => ir::types::I8X16,
-                WasmType::Ref(_) => reference_type,
+                WasmValType::I32 => ir::types::I32,
+                WasmValType::I64 => ir::types::I64,
+                WasmValType::F32 => ir::types::F32,
+                WasmValType::F64 => ir::types::F64,
+                WasmValType::V128 => ir::types::I8X16,
+                WasmValType::Ref(_) => self.pointer_type(),
             })
         };
         sig.params.extend(wasm.params().iter().map(&mut cvt));
@@ -905,8 +867,7 @@ impl<'data> ModuleEnvironment<'data> for DummyEnvironment {
         self.func_bytecode_sizes
             .push(body.get_binary_reader().bytes_remaining());
         let func = {
-            let mut func_environ =
-                DummyFuncEnvironment::new(&self.info, self.expected_reachability.clone());
+            let mut func_environ = DummyFuncEnvironment::new(&self.info);
             let func_index =
                 FuncIndex::new(self.get_num_func_imports() + self.info.function_bodies.len());
 
@@ -931,12 +892,6 @@ impl<'data> ModuleEnvironment<'data> for DummyEnvironment {
     }
 
     fn wasm_features(&self) -> WasmFeatures {
-        WasmFeatures {
-            multi_value: true,
-            simd: true,
-            reference_types: true,
-            bulk_memory: true,
-            ..WasmFeatures::default()
-        }
+        WasmFeatures::default()
     }
 }
diff --git a/cranelift/wasm/src/environ/mod.rs b/cranelift/wasm/src/environ/mod.rs
index 34d930ac60d8..665a17a9d5f9 100644
--- a/cranelift/wasm/src/environ/mod.rs
+++ b/cranelift/wasm/src/environ/mod.rs
@@ -1,12 +1,8 @@
 //! Support for configurable wasm translation.
 
-mod dummy;
 #[macro_use]
 mod spec;
 
-pub use crate::environ::dummy::{
-    DummyEnvironment, DummyFuncEnvironment, DummyModuleInfo, ExpectedReachability,
-};
 pub use crate::environ::spec::{
     FuncEnvironment, GlobalVariable, ModuleEnvironment, TargetEnvironment,
 };
diff --git a/cranelift/wasm/src/environ/spec.rs b/cranelift/wasm/src/environ/spec.rs
index 5d7c82ff3cdd..61c272dbcf7b 100644
--- a/cranelift/wasm/src/environ/spec.rs
+++ b/cranelift/wasm/src/environ/spec.rs
@@ -8,11 +8,10 @@
 
 use crate::state::FuncTranslationState;
 use crate::{
-    DataIndex, ElemIndex, FuncIndex, Global, GlobalIndex, GlobalInit, Heap, HeapData, Memory,
-    MemoryIndex, SignatureIndex, Table, TableIndex, Tag, TagIndex, TypeConvert, TypeIndex,
-    WasmError, WasmFuncType, WasmHeapType, WasmResult,
+    DataIndex, ElemIndex, FuncIndex, Global, GlobalIndex, Heap, HeapData, Memory, MemoryIndex,
+    Table, TableIndex, Tag, TagIndex, TypeConvert, TypeIndex, WasmError, WasmFuncType,
+    WasmHeapType, WasmResult,
 };
-use core::convert::From;
 use cranelift_codegen::cursor::FuncCursor;
 use cranelift_codegen::ir::immediates::Offset32;
 use cranelift_codegen::ir::{self, InstBuilder, Type};
@@ -22,6 +21,7 @@ use cranelift_frontend::FunctionBuilder;
 use std::boxed::Box;
 use std::string::ToString;
 use wasmparser::{FuncValidator, FunctionBody, Operator, ValidatorResources, WasmFeatures};
+use wasmtime_types::{ConstExpr, ModuleInternedTypeIndex};
 
 /// The value of a WebAssembly global variable.
 #[derive(Clone, Copy)]
@@ -51,6 +51,9 @@ pub trait TargetEnvironment: TypeConvert {
     /// Whether to enable Spectre mitigations for heap accesses.
     fn heap_access_spectre_mitigation(&self) -> bool;
 
+    /// Whether to add proof-carrying-code facts to verify memory accesses.
+    fn proof_carrying_code(&self) -> bool;
+
     /// Get the Cranelift integer type to use for native pointers.
     ///
     /// This returns `I64` for 64-bit architectures and `I32` for 32-bit architectures.
@@ -66,18 +69,9 @@ pub trait TargetEnvironment: TypeConvert {
     /// Get the Cranelift reference type to use for the given Wasm reference
     /// type.
     ///
-    /// By default, this returns `R64` for 64-bit architectures and `R32` for
-    /// 32-bit architectures. If you override this, then you should also
-    /// override `FuncEnvironment::{translate_ref_null, translate_ref_is_null}`
-    /// as well.
-    fn reference_type(&self, ty: WasmHeapType) -> ir::Type {
-        let _ = ty;
-        match self.pointer_type() {
-            ir::types::I32 => ir::types::R32,
-            ir::types::I64 => ir::types::R64,
-            _ => panic!("unsupported pointer type"),
-        }
-    }
+    /// Returns a pair of the CLIF reference type to use and a boolean that
+    /// describes whether the value should be included in GC stack maps or not.
+    fn reference_type(&self, ty: WasmHeapType) -> (ir::Type, bool);
 }
 
 /// Environment affecting the translation of a single WebAssembly function.
@@ -92,6 +86,20 @@ pub trait FuncEnvironment: TargetEnvironment {
         signature.params[index].purpose == ir::ArgumentPurpose::Normal
     }
 
+    /// Does the given parameter require inclusion in stack maps?
+    fn param_needs_stack_map(&self, signature: &ir::Signature, index: usize) -> bool;
+
+    /// Does the given result require inclusion in stack maps?
+    fn sig_ref_result_needs_stack_map(&self, sig_ref: ir::SigRef, index: usize) -> bool;
+
+    /// Does the given result require inclusion in stack maps?
+    fn func_ref_result_needs_stack_map(
+        &self,
+        func: &ir::Function,
+        func_ref: ir::FuncRef,
+        index: usize,
+    ) -> bool;
+
     /// Is the given return of the given function a wasm-level parameter, as
     /// opposed to a hidden parameter added for use by the implementation?
     fn is_wasm_return(&self, signature: &ir::Signature, index: usize) -> bool {
@@ -132,12 +140,6 @@ pub trait FuncEnvironment: TargetEnvironment {
     /// The index space covers both imported and locally declared memories.
     fn make_heap(&mut self, func: &mut ir::Function, index: MemoryIndex) -> WasmResult<Heap>;
 
-    /// Set up the necessary preamble definitions in `func` to access the table identified
-    /// by `index`.
-    ///
-    /// The index space covers both imported and locally declared tables.
-    fn make_table(&mut self, func: &mut ir::Function, index: TableIndex) -> WasmResult<ir::Table>;
-
     /// Set up a signature definition in the preamble of `func` that can be used for an indirect
     /// call with signature `index`.
     ///
@@ -196,16 +198,17 @@ pub trait FuncEnvironment: TargetEnvironment {
     /// The signature `sig_ref` was previously created by `make_indirect_sig()`.
     ///
     /// Return the call instruction whose results are the WebAssembly return values.
+    /// Returns `None` if this statically traps instead of creating a call
+    /// instruction.
     fn translate_call_indirect(
         &mut self,
         builder: &mut FunctionBuilder,
         table_index: TableIndex,
-        table: ir::Table,
         sig_index: TypeIndex,
         sig_ref: ir::SigRef,
         callee: ir::Value,
         call_args: &[ir::Value],
-    ) -> WasmResult<ir::Inst>;
+    ) -> WasmResult<Option<ir::Inst>>;
 
     /// Translate a `return_call` WebAssembly instruction at the builder's
     /// current position.
@@ -240,7 +243,6 @@ pub trait FuncEnvironment: TargetEnvironment {
         &mut self,
         builder: &mut FunctionBuilder,
         table_index: TableIndex,
-        table: ir::Table,
         sig_index: TypeIndex,
         sig_ref: ir::SigRef,
         callee: ir::Value,
@@ -362,19 +364,14 @@ pub trait FuncEnvironment: TargetEnvironment {
     fn translate_data_drop(&mut self, pos: FuncCursor, seg_index: u32) -> WasmResult<()>;
 
     /// Translate a `table.size` WebAssembly instruction.
-    fn translate_table_size(
-        &mut self,
-        pos: FuncCursor,
-        index: TableIndex,
-        table: ir::Table,
-    ) -> WasmResult<ir::Value>;
+    fn translate_table_size(&mut self, pos: FuncCursor, index: TableIndex)
+        -> WasmResult<ir::Value>;
 
     /// Translate a `table.grow` WebAssembly instruction.
     fn translate_table_grow(
         &mut self,
         pos: FuncCursor,
         table_index: TableIndex,
-        table: ir::Table,
         delta: ir::Value,
         init_value: ir::Value,
     ) -> WasmResult<ir::Value>;
@@ -384,7 +381,6 @@ pub trait FuncEnvironment: TargetEnvironment {
         &mut self,
         builder: &mut FunctionBuilder,
         table_index: TableIndex,
-        table: ir::Table,
         index: ir::Value,
     ) -> WasmResult<ir::Value>;
 
@@ -393,7 +389,6 @@ pub trait FuncEnvironment: TargetEnvironment {
         &mut self,
         builder: &mut FunctionBuilder,
         table_index: TableIndex,
-        table: ir::Table,
         value: ir::Value,
         index: ir::Value,
     ) -> WasmResult<()>;
@@ -403,9 +398,7 @@ pub trait FuncEnvironment: TargetEnvironment {
         &mut self,
         pos: FuncCursor,
         dst_table_index: TableIndex,
-        dst_table: ir::Table,
         src_table_index: TableIndex,
-        src_table: ir::Table,
         dst: ir::Value,
         src: ir::Value,
         len: ir::Value,
@@ -427,7 +420,6 @@ pub trait FuncEnvironment: TargetEnvironment {
         pos: FuncCursor,
         seg_index: u32,
         table_index: TableIndex,
-        table: ir::Table,
         dst: ir::Value,
         src: ir::Value,
         len: ir::Value,
@@ -437,39 +429,11 @@ pub trait FuncEnvironment: TargetEnvironment {
     fn translate_elem_drop(&mut self, pos: FuncCursor, seg_index: u32) -> WasmResult<()>;
 
     /// Translate a `ref.null T` WebAssembly instruction.
-    ///
-    /// By default, translates into a null reference type.
-    ///
-    /// Override this if you don't use Cranelift reference types for all Wasm
-    /// reference types (e.g. you use a raw pointer for `funcref`s) or if the
-    /// 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,
-        mut pos: FuncCursor,
-        ty: WasmHeapType,
-    ) -> WasmResult<ir::Value> {
-        let _ = ty;
-        Ok(pos.ins().null(self.reference_type(ty)))
-    }
+    fn translate_ref_null(&mut self, pos: FuncCursor, ty: WasmHeapType) -> WasmResult<ir::Value>;
 
     /// Translate a `ref.is_null` WebAssembly instruction.
-    ///
-    /// By default, assumes that `value` is a Cranelift reference type, and that
-    /// a null Cranelift reference type is the null value for all Wasm reference
-    /// types.
-    ///
-    /// If you override this method, you probably also want to override
-    /// `translate_ref_null` as well.
-    fn translate_ref_is_null(
-        &mut self,
-        mut pos: FuncCursor,
-        value: ir::Value,
-    ) -> WasmResult<ir::Value> {
-        let is_null = pos.ins().is_null(value);
-        Ok(pos.ins().uextend(ir::types::I32, is_null))
-    }
+    fn translate_ref_is_null(&mut self, pos: FuncCursor, value: ir::Value)
+        -> WasmResult<ir::Value>;
 
     /// Translate a `ref.func` WebAssembly instruction.
     fn translate_ref_func(
@@ -482,7 +446,7 @@ pub trait FuncEnvironment: TargetEnvironment {
     /// that is custom.
     fn translate_custom_global_get(
         &mut self,
-        pos: FuncCursor,
+        builder: &mut FunctionBuilder,
         global_index: GlobalIndex,
     ) -> WasmResult<ir::Value>;
 
@@ -490,7 +454,7 @@ pub trait FuncEnvironment: TargetEnvironment {
     /// that is custom.
     fn translate_custom_global_set(
         &mut self,
-        pos: FuncCursor,
+        builder: &mut FunctionBuilder,
         global_index: GlobalIndex,
         val: ir::Value,
     ) -> WasmResult<()>;
@@ -535,6 +499,15 @@ pub trait FuncEnvironment: TargetEnvironment {
         count: ir::Value,
     ) -> WasmResult<ir::Value>;
 
+    /// Translate an `i32` value into an `i31ref`.
+    fn translate_ref_i31(&mut self, pos: FuncCursor, val: ir::Value) -> WasmResult<ir::Value>;
+
+    /// Sign-extend an `i31ref` into an `i32`.
+    fn translate_i31_get_s(&mut self, pos: FuncCursor, i31ref: ir::Value) -> WasmResult<ir::Value>;
+
+    /// Zero-extend an `i31ref` into an `i32`.
+    fn translate_i31_get_u(&mut self, pos: FuncCursor, i31ref: ir::Value) -> WasmResult<ir::Value>;
+
     /// Emit code at the beginning of every wasm loop.
     ///
     /// This can be used to insert explicit interrupt or safepoint checking at
@@ -701,7 +674,7 @@ pub trait ModuleEnvironment<'data>: TypeConvert {
 
     /// Translates a type index to its signature index, only called for type
     /// indices which point to functions.
-    fn type_to_signature(&self, index: TypeIndex) -> WasmResult<SignatureIndex> {
+    fn type_to_signature(&self, index: TypeIndex) -> WasmResult<ModuleInternedTypeIndex> {
         let _ = index;
         Err(WasmError::Unsupported("module linking".to_string()))
     }
@@ -806,7 +779,7 @@ pub trait ModuleEnvironment<'data>: TypeConvert {
     }
 
     /// Declares a global to the environment.
-    fn declare_global(&mut self, global: Global, init: GlobalInit) -> WasmResult<()>;
+    fn declare_global(&mut self, global: Global, init: ConstExpr) -> WasmResult<()>;
 
     /// Provides the number of exports up front. By default this does nothing, but
     /// implementations can use this to preallocate memory if desired.
diff --git a/cranelift/wasm/src/func_translator.rs b/cranelift/wasm/src/func_translator.rs
index ed666cdef982..d55d7fb38662 100644
--- a/cranelift/wasm/src/func_translator.rs
+++ b/cranelift/wasm/src/func_translator.rs
@@ -13,7 +13,7 @@ use cranelift_codegen::entity::EntityRef;
 use cranelift_codegen::ir::{self, Block, InstBuilder, ValueLabel};
 use cranelift_codegen::timing;
 use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext, Variable};
-use wasmparser::{self, BinaryReader, FuncValidator, FunctionBody, WasmModuleResources};
+use wasmparser::{BinaryReader, FuncValidator, FunctionBody, WasmModuleResources};
 
 /// WebAssembly to Cranelift IR function translator.
 ///
@@ -40,14 +40,7 @@ impl FuncTranslator {
         &mut self.func_ctx
     }
 
-    /// Translate a binary WebAssembly function.
-    ///
-    /// The `code` slice contains the binary WebAssembly *function code* as it appears in the code
-    /// section of a WebAssembly module, not including the initial size of the function code. The
-    /// slice is expected to contain two parts:
-    ///
-    /// - The declaration of *locals*, and
-    /// - The function *body* as an expression.
+    /// Translate a binary WebAssembly function from a `FunctionBody`.
     ///
     /// See [the WebAssembly specification][wasm].
     ///
@@ -57,24 +50,6 @@ impl FuncTranslator {
     /// and `func.name` fields. The signature may contain special-purpose arguments which are not
     /// regarded as WebAssembly local variables. Any signature arguments marked as
     /// `ArgumentPurpose::Normal` are made accessible as WebAssembly local variables.
-    ///
-    pub fn translate<FE: FuncEnvironment + ?Sized>(
-        &mut self,
-        validator: &mut FuncValidator<impl WasmModuleResources>,
-        code: &[u8],
-        code_offset: usize,
-        func: &mut ir::Function,
-        environ: &mut FE,
-    ) -> WasmResult<()> {
-        self.translate_body(
-            validator,
-            FunctionBody::new(code_offset, code),
-            func,
-            environ,
-        )
-    }
-
-    /// Translate a binary WebAssembly function from a `FunctionBody`.
     pub fn translate_body<FE: FuncEnvironment + ?Sized>(
         &mut self,
         validator: &mut FuncValidator<impl WasmModuleResources>,
@@ -141,6 +116,10 @@ fn declare_wasm_parameters<FE: FuncEnvironment + ?Sized>(
             builder.declare_var(local, param_type.value_type);
             next_local += 1;
 
+            if environ.param_needs_stack_map(&builder.func.signature, i) {
+                builder.declare_var_needs_stack_map(local);
+            }
+
             let param_value = builder.block_params(entry_block)[i];
             builder.def_var(local, param_value);
         }
@@ -192,45 +171,53 @@ fn declare_locals<FE: FuncEnvironment + ?Sized>(
 ) -> WasmResult<()> {
     // All locals are initialized to 0.
     use wasmparser::ValType::*;
-    let (ty, init) = match wasm_type {
+    let (ty, init, needs_stack_map) = match wasm_type {
         I32 => (
             ir::types::I32,
             Some(builder.ins().iconst(ir::types::I32, 0)),
+            false,
         ),
         I64 => (
             ir::types::I64,
             Some(builder.ins().iconst(ir::types::I64, 0)),
+            false,
         ),
         F32 => (
             ir::types::F32,
             Some(builder.ins().f32const(ir::immediates::Ieee32::with_bits(0))),
+            false,
         ),
         F64 => (
             ir::types::F64,
             Some(builder.ins().f64const(ir::immediates::Ieee64::with_bits(0))),
+            false,
         ),
         V128 => {
             let constant_handle = builder.func.dfg.constants.insert([0; 16].to_vec().into());
             (
                 ir::types::I8X16,
                 Some(builder.ins().vconst(ir::types::I8X16, constant_handle)),
+                false,
             )
         }
         Ref(rt) => {
             let hty = environ.convert_heap_type(rt.heap_type());
-            let ty = environ.reference_type(hty);
+            let (ty, needs_stack_map) = environ.reference_type(hty);
             let init = if rt.is_nullable() {
                 Some(environ.translate_ref_null(builder.cursor(), hty)?)
             } else {
                 None
             };
-            (ty, init)
+            (ty, init, needs_stack_map)
         }
     };
 
     for _ in 0..count {
         let local = Variable::new(*next_local);
         builder.declare_var(local, ty);
+        if needs_stack_map {
+            builder.declare_var_needs_stack_map(local);
+        }
         if let Some(init) = init {
             builder.def_var(local, init);
             builder.set_val_label(init, ValueLabel::new(*next_local));
@@ -294,139 +281,3 @@ fn cur_srcloc(reader: &BinaryReader) -> ir::SourceLoc {
     // This will wrap around if byte code is larger than 4 GB.
     ir::SourceLoc::new(reader.original_position() as u32)
 }
-
-#[cfg(test)]
-mod tests {
-    use super::FuncTranslator;
-    use crate::environ::DummyEnvironment;
-    use cranelift_codegen::ir::types::I32;
-    use cranelift_codegen::{ir, isa, settings, Context};
-    use log::debug;
-    use target_lexicon::PointerWidth;
-    use wasmparser::{
-        FuncValidator, FunctionBody, Parser, ValidPayload, Validator, ValidatorResources,
-    };
-
-    #[test]
-    fn small1() {
-        // Implicit return.
-        let wasm = wat::parse_str(
-            "
-                (module
-                    (func $small2 (param i32) (result i32)
-                        (i32.add (local.get 0) (i32.const 1))
-                    )
-                )
-            ",
-        )
-        .unwrap();
-
-        let mut trans = FuncTranslator::new();
-        let flags = settings::Flags::new(settings::builder());
-        let runtime = DummyEnvironment::new(isa::TargetFrontendConfig {
-            default_call_conv: isa::CallConv::Fast,
-            pointer_width: PointerWidth::U64,
-        });
-
-        let mut ctx = Context::new();
-
-        ctx.func.name = ir::UserFuncName::testcase("small1");
-        ctx.func.signature.params.push(ir::AbiParam::new(I32));
-        ctx.func.signature.returns.push(ir::AbiParam::new(I32));
-
-        let (body, mut validator) = extract_func(&wasm);
-        trans
-            .translate_body(&mut validator, body, &mut ctx.func, &mut runtime.func_env())
-            .unwrap();
-        debug!("{}", ctx.func.display());
-        ctx.verify(&flags).unwrap();
-    }
-
-    #[test]
-    fn small2() {
-        // Same as above, but with an explicit return instruction.
-        let wasm = wat::parse_str(
-            "
-                (module
-                    (func $small2 (param i32) (result i32)
-                        (return (i32.add (local.get 0) (i32.const 1)))
-                    )
-                )
-            ",
-        )
-        .unwrap();
-
-        let mut trans = FuncTranslator::new();
-        let flags = settings::Flags::new(settings::builder());
-        let runtime = DummyEnvironment::new(isa::TargetFrontendConfig {
-            default_call_conv: isa::CallConv::Fast,
-            pointer_width: PointerWidth::U64,
-        });
-
-        let mut ctx = Context::new();
-
-        ctx.func.name = ir::UserFuncName::testcase("small2");
-        ctx.func.signature.params.push(ir::AbiParam::new(I32));
-        ctx.func.signature.returns.push(ir::AbiParam::new(I32));
-
-        let (body, mut validator) = extract_func(&wasm);
-        trans
-            .translate_body(&mut validator, body, &mut ctx.func, &mut runtime.func_env())
-            .unwrap();
-        debug!("{}", ctx.func.display());
-        ctx.verify(&flags).unwrap();
-    }
-
-    #[test]
-    fn infloop() {
-        // An infinite loop, no return instructions.
-        let wasm = wat::parse_str(
-            "
-                (module
-                    (func $infloop (result i32)
-                        (local i32)
-                        (loop (result i32)
-                            (i32.add (local.get 0) (i32.const 1))
-                            (local.set 0)
-                            (br 0)
-                        )
-                    )
-                )
-            ",
-        )
-        .unwrap();
-
-        let mut trans = FuncTranslator::new();
-        let flags = settings::Flags::new(settings::builder());
-        let runtime = DummyEnvironment::new(isa::TargetFrontendConfig {
-            default_call_conv: isa::CallConv::Fast,
-            pointer_width: PointerWidth::U64,
-        });
-
-        let mut ctx = Context::new();
-
-        ctx.func.name = ir::UserFuncName::testcase("infloop");
-        ctx.func.signature.returns.push(ir::AbiParam::new(I32));
-
-        let (body, mut validator) = extract_func(&wasm);
-        trans
-            .translate_body(&mut validator, body, &mut ctx.func, &mut runtime.func_env())
-            .unwrap();
-        debug!("{}", ctx.func.display());
-        ctx.verify(&flags).unwrap();
-    }
-
-    fn extract_func(wat: &[u8]) -> (FunctionBody<'_>, FuncValidator<ValidatorResources>) {
-        let mut validator = Validator::new();
-        for payload in Parser::new(0).parse_all(wat) {
-            match validator.payload(&payload.unwrap()).unwrap() {
-                ValidPayload::Func(validator, body) => {
-                    let validator = validator.into_validator(Default::default());
-                    return (body, validator);
-                }
-                _ => {}
-            }
-        }
-        panic!("failed to find function");
-    }
-}
diff --git a/cranelift/wasm/src/heap.rs b/cranelift/wasm/src/heap.rs
index b253c62dcee0..c8adc66727e3 100644
--- a/cranelift/wasm/src/heap.rs
+++ b/cranelift/wasm/src/heap.rs
@@ -1,6 +1,6 @@
 //! Heaps to implement WebAssembly linear memories.
 
-use cranelift_codegen::ir::{GlobalValue, Type};
+use cranelift_codegen::ir::{GlobalValue, MemoryType, Type};
 use cranelift_entity::entity_impl;
 
 /// An opaque reference to a [`HeapData`][crate::HeapData].
@@ -74,6 +74,11 @@ pub struct HeapData {
     /// don't need bounds checking.
     pub min_size: u64,
 
+    /// The maximum heap size in bytes.
+    ///
+    /// Heap accesses larger than this will always trap.
+    pub max_size: Option<u64>,
+
     /// Size in bytes of the offset-guard pages following the heap.
     pub offset_guard_size: u64,
 
@@ -82,6 +87,12 @@ pub struct HeapData {
 
     /// The index type for the heap.
     pub index_type: Type,
+
+    /// The memory type for the pointed-to memory, if using proof-carrying code.
+    pub memory_type: Option<MemoryType>,
+
+    /// The log2 of this memory's page size.
+    pub page_size_log2: u8,
 }
 
 /// Style of heap including style-specific information.
diff --git a/cranelift/wasm/src/lib.rs b/cranelift/wasm/src/lib.rs
index ecb9f8f391e6..bd3092fa3418 100644
--- a/cranelift/wasm/src/lib.rs
+++ b/cranelift/wasm/src/lib.rs
@@ -4,14 +4,9 @@
 //! [`ModuleEnvironment`](trait.ModuleEnvironment.html)
 //! trait to deal with tables, globals and linear memory.
 //!
-//! The crate provides a `DummyEnvironment` struct that will allow to translate the code of the
-//! functions but will fail at execution.
-//!
 //! The main function of this module is [`translate_module`](fn.translate_module.html).
 
-#![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)]
-#![warn(unused_import_braces)]
-#![cfg_attr(feature = "std", deny(unstable_features))]
+#![deny(missing_docs)]
 #![no_std]
 
 #[cfg(not(feature = "std"))]
@@ -41,16 +36,15 @@ mod heap;
 mod module_translator;
 mod sections_translator;
 mod state;
+mod table;
 mod translation_utils;
 
-pub use crate::environ::{
-    DummyEnvironment, DummyFuncEnvironment, DummyModuleInfo, ExpectedReachability, FuncEnvironment,
-    GlobalVariable, ModuleEnvironment, TargetEnvironment,
-};
+pub use crate::environ::{FuncEnvironment, GlobalVariable, ModuleEnvironment, TargetEnvironment};
 pub use crate::func_translator::FuncTranslator;
 pub use crate::heap::{Heap, HeapData, HeapStyle};
 pub use crate::module_translator::translate_module;
 pub use crate::state::FuncTranslationState;
+pub use crate::table::{TableData, TableSize};
 pub use crate::translation_utils::*;
 pub use cranelift_frontend::FunctionBuilder;
 pub use wasmtime_types::*;
diff --git a/cranelift/wasm/src/module_translator.rs b/cranelift/wasm/src/module_translator.rs
index 6da7d0b5b0fb..e78c90d49cd0 100644
--- a/cranelift/wasm/src/module_translator.rs
+++ b/cranelift/wasm/src/module_translator.rs
@@ -3,13 +3,13 @@
 use crate::environ::ModuleEnvironment;
 use crate::sections_translator::{
     parse_data_section, parse_element_section, parse_export_section, parse_function_section,
-    parse_global_section, parse_import_section, parse_memory_section, parse_name_section,
-    parse_start_section, parse_table_section, parse_tag_section, parse_type_section,
+    parse_global_section, parse_import_section, parse_memory_section, parse_start_section,
+    parse_table_section, parse_tag_section, parse_type_section,
 };
 use crate::WasmResult;
 use cranelift_codegen::timing;
 use std::prelude::v1::*;
-use wasmparser::{NameSectionReader, Parser, Payload, Validator};
+use wasmparser::{Parser, Payload, Validator};
 
 /// Translate a sequence of bytes forming a valid Wasm binary into a list of valid Cranelift IR
 /// [`Function`](cranelift_codegen::ir::Function).
@@ -107,19 +107,11 @@ pub fn translate_module<'data>(
                 environ.reserve_passive_data(count)?;
             }
 
-            Payload::CustomSection(s) if s.name() == "name" => {
-                let result =
-                    parse_name_section(NameSectionReader::new(s.data(), s.data_offset()), environ);
-                if let Err(e) = result {
-                    log::warn!("failed to parse name section {:?}", e);
-                }
-            }
-
             Payload::CustomSection(s) => environ.custom_section(s.name(), s.data())?,
 
             other => {
                 validator.payload(&other)?;
-                panic!("unimplemented section {:?}", other);
+                panic!("unimplemented section {other:?}");
             }
         }
     }
diff --git a/cranelift/wasm/src/sections_translator.rs b/cranelift/wasm/src/sections_translator.rs
index e38b1327787b..e033f13db0be 100644
--- a/cranelift/wasm/src/sections_translator.rs
+++ b/cranelift/wasm/src/sections_translator.rs
@@ -10,28 +10,20 @@
 use crate::environ::ModuleEnvironment;
 use crate::wasm_unsupported;
 use crate::{
-    DataIndex, ElemIndex, FuncIndex, GlobalIndex, GlobalInit, Memory, MemoryIndex, TableIndex, Tag,
-    TagIndex, TypeIndex, WasmError, WasmResult,
+    DataIndex, ElemIndex, FuncIndex, GlobalIndex, MemoryIndex, TableIndex, Tag, TagIndex,
+    TypeIndex, WasmError, WasmResult,
 };
 use cranelift_entity::packed_option::ReservedValue;
 use cranelift_entity::EntityRef;
 use std::boxed::Box;
 use std::vec::Vec;
 use wasmparser::{
-    self, Data, DataKind, DataSectionReader, Element, ElementItems, ElementKind,
-    ElementSectionReader, Export, ExportSectionReader, ExternalKind, FunctionSectionReader,
-    GlobalSectionReader, ImportSectionReader, MemorySectionReader, MemoryType, NameSectionReader,
-    Naming, Operator, TableSectionReader, TagSectionReader, TagType, TypeRef, TypeSectionReader,
+    Data, DataKind, DataSectionReader, Element, ElementItems, ElementKind, ElementSectionReader,
+    Export, ExportSectionReader, ExternalKind, FunctionSectionReader, GlobalSectionReader,
+    ImportSectionReader, MemorySectionReader, Operator, TableSectionReader, TagSectionReader,
+    TagType, TypeRef, TypeSectionReader,
 };
-
-fn memory(ty: MemoryType) -> Memory {
-    Memory {
-        minimum: ty.initial,
-        maximum: ty.maximum,
-        shared: ty.shared,
-        memory64: ty.memory64,
-    }
-}
+use wasmtime_types::ConstExpr;
 
 fn tag(e: TagType) -> Tag {
     match e.kind {
@@ -74,7 +66,7 @@ pub fn parse_import_section<'data>(
                 )?;
             }
             TypeRef::Memory(ty) => {
-                environ.declare_memory_import(memory(ty), import.module, import.name)?;
+                environ.declare_memory_import(ty.into(), import.module, import.name)?;
             }
             TypeRef::Tag(e) => {
                 environ.declare_tag_import(tag(e), import.module, import.name)?;
@@ -84,7 +76,7 @@ pub fn parse_import_section<'data>(
                 environ.declare_global_import(ty, import.module, import.name)?;
             }
             TypeRef::Table(ty) => {
-                let ty = environ.convert_table_type(&ty);
+                let ty = environ.convert_table_type(&ty)?;
                 environ.declare_table_import(ty, import.module, import.name)?;
             }
         }
@@ -123,7 +115,7 @@ pub fn parse_table_section(
     environ.reserve_tables(tables.count())?;
 
     for entry in tables {
-        let ty = environ.convert_table_type(&entry?.ty);
+        let ty = environ.convert_table_type(&entry?.ty)?;
         environ.declare_table(ty)?;
     }
 
@@ -138,8 +130,7 @@ pub fn parse_memory_section(
     environ.reserve_memories(memories.count())?;
 
     for entry in memories {
-        let memory = memory(entry?);
-        environ.declare_memory(memory)?;
+        environ.declare_memory(entry?.into())?;
     }
 
     Ok(())
@@ -169,29 +160,7 @@ pub fn parse_global_section(
 
     for entry in globals {
         let wasmparser::Global { ty, init_expr } = entry?;
-        let mut init_expr_reader = init_expr.get_binary_reader();
-        let initializer = match init_expr_reader.read_operator()? {
-            Operator::I32Const { value } => GlobalInit::I32Const(value),
-            Operator::I64Const { value } => GlobalInit::I64Const(value),
-            Operator::F32Const { value } => GlobalInit::F32Const(value.bits()),
-            Operator::F64Const { value } => GlobalInit::F64Const(value.bits()),
-            Operator::V128Const { value } => {
-                GlobalInit::V128Const(u128::from_le_bytes(*value.bytes()))
-            }
-            Operator::RefNull { hty: _ } => GlobalInit::RefNullConst,
-            Operator::RefFunc { function_index } => {
-                GlobalInit::RefFunc(FuncIndex::from_u32(function_index))
-            }
-            Operator::GlobalGet { global_index } => {
-                GlobalInit::GetGlobal(GlobalIndex::from_u32(global_index))
-            }
-            ref s => {
-                return Err(wasm_unsupported!(
-                    "unsupported init expr in global section: {:?}",
-                    s
-                ));
-            }
-        };
+        let (initializer, _escaped) = ConstExpr::from_wasmparser(init_expr)?;
         let ty = environ.convert_global_type(&ty);
         environ.declare_global(ty, initializer)?;
     }
@@ -251,8 +220,7 @@ fn read_elems(items: &ElementItems) -> WasmResult<Box<[FuncIndex]>> {
                     Operator::RefFunc { function_index } => FuncIndex::from_u32(function_index),
                     s => {
                         return Err(WasmError::Unsupported(format!(
-                            "unsupported init expr in element section: {:?}",
-                            s
+                            "unsupported init expr in element section: {s:?}"
                         )));
                     }
                 };
@@ -362,47 +330,3 @@ pub fn parse_data_section<'data>(
 
     Ok(())
 }
-
-/// Parses the Name section of the wasm module.
-pub fn parse_name_section<'data>(
-    names: NameSectionReader<'data>,
-    environ: &mut dyn ModuleEnvironment<'data>,
-) -> WasmResult<()> {
-    for subsection in names {
-        match subsection? {
-            wasmparser::Name::Function(names) => {
-                for name in names {
-                    let Naming { index, name } = name?;
-                    // We reserve `u32::MAX` for our own use in cranelift-entity.
-                    if index != u32::max_value() {
-                        environ.declare_func_name(FuncIndex::from_u32(index), name);
-                    }
-                }
-            }
-            wasmparser::Name::Module { name, .. } => {
-                environ.declare_module_name(name);
-            }
-            wasmparser::Name::Local(reader) => {
-                for f in reader {
-                    let f = f?;
-                    if f.index == u32::max_value() {
-                        continue;
-                    }
-                    for name in f.names {
-                        let Naming { index, name } = name?;
-                        environ.declare_local_name(FuncIndex::from_u32(f.index), index, name)
-                    }
-                }
-            }
-            wasmparser::Name::Label(_)
-            | wasmparser::Name::Type(_)
-            | wasmparser::Name::Table(_)
-            | wasmparser::Name::Global(_)
-            | wasmparser::Name::Memory(_)
-            | wasmparser::Name::Element(_)
-            | wasmparser::Name::Data(_)
-            | wasmparser::Name::Unknown { .. } => {}
-        }
-    }
-    Ok(())
-}
diff --git a/cranelift/wasm/src/state.rs b/cranelift/wasm/src/state.rs
index 3d775e05ec1a..d788157f84c7 100644
--- a/cranelift/wasm/src/state.rs
+++ b/cranelift/wasm/src/state.rs
@@ -4,7 +4,7 @@
 //! value and control stacks during the translation of a single function.
 
 use crate::environ::{FuncEnvironment, GlobalVariable};
-use crate::{FuncIndex, GlobalIndex, Heap, MemoryIndex, TableIndex, TypeIndex, WasmResult};
+use crate::{FuncIndex, GlobalIndex, Heap, MemoryIndex, TypeIndex, WasmResult};
 use crate::{HashMap, Occupied, Vacant};
 use cranelift_codegen::ir::{self, Block, Inst, Value};
 use std::vec::Vec;
@@ -194,7 +194,7 @@ impl ControlStackFrame {
         // (see also `FuncTranslationState::push_if`).
         // Yet, the original_stack_size member accounts for them only once, so that the else
         // block can see the same number of parameters as the consequent block. As a matter of
-        // fact, we need to substract an extra number of parameter values for if blocks.
+        // fact, we need to subtract an extra number of parameter values for if blocks.
         let num_duplicated_params = match self {
             &ControlStackFrame::If {
                 num_param_values, ..
@@ -229,9 +229,6 @@ pub struct FuncTranslationState {
     // Map of heaps that have been created by `FuncEnvironment::make_heap`.
     memory_to_heap: HashMap<MemoryIndex, Heap>,
 
-    // Map of tables that have been created by `FuncEnvironment::make_table`.
-    pub(crate) tables: HashMap<TableIndex, ir::Table>,
-
     // Map of indirect call signatures that have been created by
     // `FuncEnvironment::make_indirect_sig()`.
     // Stores both the signature reference and the number of WebAssembly arguments
@@ -261,7 +258,6 @@ impl FuncTranslationState {
             reachable: true,
             globals: HashMap::new(),
             memory_to_heap: HashMap::new(),
-            tables: HashMap::new(),
             signatures: HashMap::new(),
             functions: HashMap::new(),
         }
@@ -273,7 +269,6 @@ impl FuncTranslationState {
         self.reachable = true;
         self.globals.clear();
         self.memory_to_heap.clear();
-        self.tables.clear();
         self.signatures.clear();
         self.functions.clear();
     }
@@ -334,7 +329,7 @@ impl FuncTranslationState {
         (v1, v2, v3)
     }
 
-    /// Helper to ensure the the stack size is at least as big as `n`; note that due to
+    /// Helper to ensure the stack size is at least as big as `n`; note that due to
     /// `debug_assert` this will not execute in non-optimized builds.
     #[inline]
     fn ensure_length_is_at_least(&self, n: usize) {
@@ -472,21 +467,6 @@ impl FuncTranslationState {
         }
     }
 
-    /// Get the `Table` reference that should be used to access table `index`.
-    /// Create the reference if necessary.
-    pub(crate) fn get_or_create_table<FE: FuncEnvironment + ?Sized>(
-        &mut self,
-        func: &mut ir::Function,
-        index: u32,
-        environ: &mut FE,
-    ) -> WasmResult<ir::Table> {
-        let index = TableIndex::from_u32(index);
-        match self.tables.entry(index) {
-            Occupied(entry) => Ok(*entry.get()),
-            Vacant(entry) => Ok(*entry.insert(environ.make_table(func, index)?)),
-        }
-    }
-
     /// Get the `SigRef` reference that should be used to make an indirect call with signature
     /// `index`. Also return the number of WebAssembly arguments in the signature.
     ///
diff --git a/cranelift/wasm/src/table.rs b/cranelift/wasm/src/table.rs
new file mode 100644
index 000000000000..bb5466670696
--- /dev/null
+++ b/cranelift/wasm/src/table.rs
@@ -0,0 +1,104 @@
+use cranelift_codegen::cursor::FuncCursor;
+use cranelift_codegen::ir::{self, condcodes::IntCC, immediates::Imm64, InstBuilder};
+use cranelift_frontend::FunctionBuilder;
+
+/// Size of a WebAssembly table, in elements.
+#[derive(Clone)]
+pub enum TableSize {
+    /// Non-resizable table.
+    Static {
+        /// Non-resizable tables have a constant size known at compile time.
+        bound: u32,
+    },
+    /// Resizable table.
+    Dynamic {
+        /// Resizable tables declare a Cranelift global value to load the
+        /// current size from.
+        bound_gv: ir::GlobalValue,
+    },
+}
+
+impl TableSize {
+    /// Get a CLIF value representing the current bounds of this table.
+    pub fn bound(&self, mut pos: FuncCursor, index_ty: ir::Type) -> ir::Value {
+        match *self {
+            TableSize::Static { bound } => pos.ins().iconst(index_ty, Imm64::new(i64::from(bound))),
+            TableSize::Dynamic { bound_gv } => pos.ins().global_value(index_ty, bound_gv),
+        }
+    }
+}
+
+/// An implementation of a WebAssembly table.
+#[derive(Clone)]
+pub struct TableData {
+    /// Global value giving the address of the start of the table.
+    pub base_gv: ir::GlobalValue,
+
+    /// The size of the table, in elements.
+    pub bound: TableSize,
+
+    /// The size of a table element, in bytes.
+    pub element_size: u32,
+}
+
+impl TableData {
+    /// Return a CLIF value containing a native pointer to the beginning of the
+    /// given index within this table.
+    pub fn prepare_table_addr(
+        &self,
+        pos: &mut FunctionBuilder,
+        mut index: ir::Value,
+        addr_ty: ir::Type,
+        enable_table_access_spectre_mitigation: bool,
+    ) -> (ir::Value, ir::MemFlags) {
+        let index_ty = pos.func.dfg.value_type(index);
+
+        // Start with the bounds check. Trap if `index + 1 > bound`.
+        let bound = self.bound.bound(pos.cursor(), index_ty);
+
+        // `index > bound - 1` is the same as `index >= bound`.
+        let oob = pos
+            .ins()
+            .icmp(IntCC::UnsignedGreaterThanOrEqual, index, bound);
+
+        if !enable_table_access_spectre_mitigation {
+            pos.ins().trapnz(oob, ir::TrapCode::TableOutOfBounds);
+        }
+
+        // Convert `index` to `addr_ty`.
+        if index_ty != addr_ty {
+            index = pos.ins().uextend(addr_ty, index);
+        }
+
+        // Add the table base address base
+        let base = pos.ins().global_value(addr_ty, self.base_gv);
+
+        let element_size = self.element_size;
+        let offset = if element_size == 1 {
+            index
+        } else if element_size.is_power_of_two() {
+            pos.ins()
+                .ishl_imm(index, i64::from(element_size.trailing_zeros()))
+        } else {
+            pos.ins().imul_imm(index, element_size as i64)
+        };
+
+        let element_addr = pos.ins().iadd(base, offset);
+
+        let base_flags = ir::MemFlags::new()
+            .with_aligned()
+            .with_alias_region(Some(ir::AliasRegion::Table));
+        if enable_table_access_spectre_mitigation {
+            // Short-circuit the computed table element address to a null pointer
+            // when out-of-bounds. The consumer of this address will trap when
+            // trying to access it.
+            let zero = pos.ins().iconst(addr_ty, 0);
+            (
+                pos.ins().select_spectre_guard(oob, zero, element_addr),
+                base_flags.with_trap_code(Some(ir::TrapCode::TableOutOfBounds)),
+            )
+        } else {
+            (element_addr, base_flags.with_trap_code(None))
+        }
+    }
+}
diff --git a/cranelift/wasm/src/translation_utils.rs b/cranelift/wasm/src/translation_utils.rs
index 8a6ceb2c73fa..588cfa5c3fce 100644
--- a/cranelift/wasm/src/translation_utils.rs
+++ b/cranelift/wasm/src/translation_utils.rs
@@ -4,7 +4,7 @@ use crate::WasmResult;
 use core::u32;
 use cranelift_codegen::ir;
 use cranelift_frontend::FunctionBuilder;
-use wasmparser::{FuncValidator, WasmFuncType, WasmModuleResources};
+use wasmparser::{FuncValidator, WasmModuleResources};
 
 /// Get the parameter and result types for the given Wasm blocktype.
 pub fn blocktype_params_results<'a, T>(
@@ -18,30 +18,24 @@ where
     T: WasmModuleResources,
 {
     return Ok(match ty {
-        wasmparser::BlockType::Empty => {
-            let params: &'static [wasmparser::ValType] = &[];
-            let results: std::vec::Vec<wasmparser::ValType> = vec![];
-            (
-                itertools::Either::Left(params.iter().copied()),
-                itertools::Either::Left(results.into_iter()),
-            )
-        }
-        wasmparser::BlockType::Type(ty) => {
-            let params: &'static [wasmparser::ValType] = &[];
-            let results: std::vec::Vec<wasmparser::ValType> = vec![ty.clone()];
-            (
-                itertools::Either::Left(params.iter().copied()),
-                itertools::Either::Left(results.into_iter()),
-            )
-        }
+        wasmparser::BlockType::Empty => (
+            itertools::Either::Left(std::iter::empty()),
+            itertools::Either::Left(None.into_iter()),
+        ),
+        wasmparser::BlockType::Type(ty) => (
+            itertools::Either::Left(std::iter::empty()),
+            itertools::Either::Left(Some(ty).into_iter()),
+        ),
         wasmparser::BlockType::FuncType(ty_index) => {
             let ty = validator
                 .resources()
-                .func_type_at(ty_index)
-                .expect("should be valid");
+                .sub_type_at(ty_index)
+                .expect("should be valid")
+                .unwrap_func();
+
             (
-                itertools::Either::Right(ty.inputs()),
-                itertools::Either::Right(ty.outputs()),
+                itertools::Either::Right(ty.params().iter().copied()),
+                itertools::Either::Right(ty.results().iter().copied()),
             )
         }
     });
@@ -70,7 +64,11 @@ pub fn block_with_params<PE: TargetEnvironment + ?Sized>(
             }
             wasmparser::ValType::Ref(rt) => {
                 let hty = environ.convert_heap_type(rt.heap_type());
-                builder.append_block_param(block, environ.reference_type(hty));
+                let (ty, needs_stack_map) = environ.reference_type(hty);
+                let val = builder.append_block_param(block, ty);
+                if needs_stack_map {
+                    builder.declare_value_needs_stack_map(val);
+                }
             }
             wasmparser::ValType::V128 => {
                 builder.append_block_param(block, ir::types::I8X16);
diff --git a/cranelift/wasm/tests/wasm_testsuite.rs b/cranelift/wasm/tests/wasm_testsuite.rs
deleted file mode 100644
index 311b879b0b55..000000000000
--- a/cranelift/wasm/tests/wasm_testsuite.rs
+++ /dev/null
@@ -1,153 +0,0 @@
-use cranelift_codegen::isa::{CallConv, TargetFrontendConfig};
-use cranelift_codegen::print_errors::pretty_verifier_error;
-use cranelift_codegen::settings::{self, Flags};
-use cranelift_codegen::verifier;
-use cranelift_wasm::{translate_module, DummyEnvironment, FuncIndex};
-use std::fs;
-use std::path::Path;
-use target_lexicon::PointerWidth;
-
-#[test]
-fn testsuite() {
-    let mut paths: Vec<_> = fs::read_dir("./wasmtests")
-        .unwrap()
-        .map(|r| r.unwrap())
-        .filter(|p| {
-            // Ignore files starting with `.`, which could be editor temporary files
-            if let Some(stem) = p.path().file_stem() {
-                if let Some(stemstr) = stem.to_str() {
-                    return !stemstr.starts_with('.');
-                }
-            }
-            false
-        })
-        .collect();
-    paths.sort_by_key(|dir| dir.path());
-    let flags = Flags::new(settings::builder());
-    for path in paths {
-        let path = path.path();
-        println!("=== {} ===", path.display());
-        let data = read_module(&path);
-        handle_module(data, &flags);
-    }
-}
-
-#[test]
-fn use_name_section() {
-    let data = wat::parse_str(
-        r#"
-        (module $module_name
-            (func $func_name (local $loc_name i32)
-            )
-        )"#,
-    )
-    .unwrap();
-
-    let mut dummy_environ = DummyEnvironment::new(TargetFrontendConfig {
-        default_call_conv: CallConv::SystemV,
-        pointer_width: PointerWidth::U32,
-    });
-
-    translate_module(data.as_ref(), &mut dummy_environ).unwrap();
-
-    assert_eq!(
-        dummy_environ.get_func_name(FuncIndex::from_u32(0)).unwrap(),
-        "func_name"
-    );
-}
-
-fn read_module(path: &Path) -> Vec<u8> {
-    match path.extension() {
-        None => {
-            panic!("the file extension is not wasm or wat");
-        }
-        Some(ext) => match ext.to_str() {
-            Some("wasm") => std::fs::read(path).expect("error reading wasm file"),
-            Some("wat") => wat::parse_file(path)
-                .map_err(|e| e.to_string())
-                .expect("failed to parse wat"),
-            None | Some(&_) => panic!("the file extension for {:?} is not wasm or wat", path),
-        },
-    }
-}
-
-fn handle_module(data: Vec<u8>, flags: &Flags) {
-    let mut dummy_environ = DummyEnvironment::new(TargetFrontendConfig {
-        default_call_conv: CallConv::SystemV,
-        pointer_width: PointerWidth::U64,
-    });
-
-    translate_module(&data, &mut dummy_environ).unwrap();
-
-    for func in dummy_environ.info.function_bodies.values() {
-        verifier::verify_function(func, flags)
-            .map_err(|errors| panic!("{}", pretty_verifier_error(func, None, errors)))
-            .unwrap();
-    }
-}
-
-#[test]
-fn reachability_is_correct() {
-    let tests = vec![
-        (
-            r#"
-        (module (func (param i32)
-         (loop
-          (block
-           local.get 0
-           br_if 0
-           br 1))))"#,
-            vec![
-                (true, true),  // Loop
-                (true, true),  // Block
-                (true, true),  // LocalGet
-                (true, true),  // BrIf
-                (true, false), // Br
-                (false, true), // End
-                (true, true),  // End
-                (true, true),  // End
-            ],
-        ),
-        (
-            r#"
-        (module (func (param i32)
-         (loop
-          (block
-           br 1
-           nop))))"#,
-            vec![
-                (true, true),   // Loop
-                (true, true),   // Block
-                (true, false),  // Br
-                (false, false), // Nop
-                (false, false), // Nop
-                (false, false), // Nop
-                (false, false), // End
-            ],
-        ),
-        (
-            r#"
-        (module (func (param i32) (result i32)
-          i32.const 1
-          return
-          i32.const 42))"#,
-            vec![
-                (true, true),   // I32Const
-                (true, false),  // Return
-                (false, false), // I32Const
-                (false, false), // End
-            ],
-        ),
-    ];
-
-    for (wat, expected_reachability) in tests {
-        println!("testing wat:\n{}", wat);
-        let mut env = DummyEnvironment::new(TargetFrontendConfig {
-            default_call_conv: CallConv::SystemV,
-            pointer_width: PointerWidth::U64,
-        });
-        env.test_expected_reachability(expected_reachability);
-        let data = wat::parse_str(wat).unwrap();
-        translate_module(data.as_ref(), &mut env).unwrap();
-    }
-}
diff --git a/cranelift/wasm/wasmtests/arith.wat b/cranelift/wasm/wasmtests/arith.wat
deleted file mode 100644
index 80005a6742de..000000000000
--- a/cranelift/wasm/wasmtests/arith.wat
+++ /dev/null
@@ -1,13 +0,0 @@
-(module
-  (memory 1)
-  (func $main (local i32)
-      (local.set 0 (i32.sub (i32.const 4) (i32.const 4)))
-      (if
-          (local.get 0)
-          (then unreachable)
-          (else (drop (i32.mul (i32.const 6) (local.get 0))))
-       )
-  )
-  (start $main)
-  (data (i32.const 0) "abcdefgh")
-)
diff --git a/cranelift/wasm/wasmtests/br_table.wat b/cranelift/wasm/wasmtests/br_table.wat
deleted file mode 100644
index 75444fa49c4c..000000000000
--- a/cranelift/wasm/wasmtests/br_table.wat
+++ /dev/null
@@ -1,30 +0,0 @@
-(module
-  (func (result i32)
-    (block (result i32)
-      (block (result i32)
-        (block (result i32)
-          (br_table 0 1 2 3 (i32.const 42) (i32.const 0))
-        )
-      )
-    )
-  )
-  (func (result i32)
-    (block (result i32)
-      (block (result i32)
-        (block (result i32)
-          (br_table 3 2 1 0 (i32.const 42) (i32.const 0))
-        )
-      )
-    )
-  )
-  (func (result i32)
-    (block (result i32)
-      (br_table 0 0 1 1 (i32.const 42) (i32.const 0))
-    )
-  )
-  (func (result i32)
-    (block (result i32)
-      (br_table 1 1 0 0 (i32.const 42) (i32.const 0))
-    )
-  )
-)
diff --git a/cranelift/wasm/wasmtests/call-simd.wat b/cranelift/wasm/wasmtests/call-simd.wat
deleted file mode 100644
index 61834d86bdfc..000000000000
--- a/cranelift/wasm/wasmtests/call-simd.wat
+++ /dev/null
@@ -1,14 +0,0 @@
-(module
-  (func $main
-    (v128.const i32x4 1 2 3 4)
-    (v128.const i32x4 1 2 3 4)
-    (call $add)
-    drop
-  )
-  (func $add (param $a v128) (param $b v128) (result v128)
-    (local.get $a)
-    (local.get $b)
-    (i32x4.add)
-  )
-  (start $main)
-)
diff --git a/cranelift/wasm/wasmtests/call.wat b/cranelift/wasm/wasmtests/call.wat
deleted file mode 100644
index d6d75cb5c9c7..000000000000
--- a/cranelift/wasm/wasmtests/call.wat
+++ /dev/null
@@ -1,10 +0,0 @@
-(module
-  (func $main (local i32)
-    (local.set 0 (i32.const 0))
-    (drop (call $inc))
-  )
-  (func $inc (result i32)
-    (i32.const 1)
-  )
-  (start $main)
-)
diff --git a/cranelift/wasm/wasmtests/embenchen_fannkuch.wat b/cranelift/wasm/wasmtests/embenchen_fannkuch.wat
deleted file mode 100644
index 391fdcd55b71..000000000000
--- a/cranelift/wasm/wasmtests/embenchen_fannkuch.wat
+++ /dev/null
@@ -1,12180 +0,0 @@
-(module
-  (type $0 (;0;) (func (param i32 i32 i32) (result i32)))
-  (type $1 (;1;) (func (param i32) (result i32)))
-  (type $2 (;2;) (func (param i32)))
-  (type $3 (;3;) (func (result i32)))
-  (type $4 (;4;) (func (param i32 i32) (result i32)))
-  (type $5 (;5;) (func (param i32 i32)))
-  (type $6 (;6;) (func))
-  (type $7 (;7;) (func (param i32 i32 i32 i32 i32) (result i32)))
-  (type $8 (;8;) (func (param i32 i32 i32)))
-  (type $9 (;9;) (func (param i64 i32) (result i32)))
-  (type $10 (;10;) (func (param i32 i32 i32 i32 i32)))
-  (type $11 (;11;) (func (param f64 i32) (result f64)))
-  (type $12 (;12;) (func (param i32 i32 i32 i32) (result i32)))
-  (import "env" "memory" (memory $16 (;0;) 2048 2048))
-  (import "env" "table" (table $timport$17 (;0;) 8 8 funcref))
-  (import "env" "DYNAMICTOP_PTR" (global $gimport$0 (;0;) i32))
-  (import "env" "STACKTOP" (global $gimport$1 (;1;) i32))
-  (import "env" "STACK_MAX" (global $gimport$2 (;2;) i32))
-  (import "env" "memoryBase" (global $gimport$18 (;3;) i32))
-  (import "env" "tableBase" (global $gimport$19 (;4;) i32))
-  (import "env" "abort" (func $fimport$3 (;0;) (type $2)))
-  (import "env" "enlargeMemory" (func $fimport$4 (;1;) (type $3)))
-  (import "env" "getTotalMemory" (func $fimport$5 (;2;) (type $3)))
-  (import "env" "abortOnCannotGrowMemory" (func $fimport$6 (;3;) (type $3)))
-  (import "env" "_pthread_cleanup_pop" (func $fimport$7 (;4;) (type $2)))
-  (import "env" "___syscall6" (func $fimport$8 (;5;) (type $4)))
-  (import "env" "_pthread_cleanup_push" (func $fimport$9 (;6;) (type $5)))
-  (import "env" "_abort" (func $fimport$10 (;7;) (type $6)))
-  (import "env" "___setErrNo" (func $fimport$11 (;8;) (type $2)))
-  (import "env" "_emscripten_memcpy_big" (func $fimport$12 (;9;) (type $0)))
-  (import "env" "___syscall54" (func $fimport$13 (;10;) (type $4)))
-  (import "env" "___syscall140" (func $fimport$14 (;11;) (type $4)))
-  (import "env" "___syscall146" (func $fimport$15 (;12;) (type $4)))
-  (func $0 (;13;) (type $1) (param $0 i32) (result i32)
-    (local $1 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $1
-      global.get $global$1
-      local.get $0
-      i32.add
-      global.set $global$1
-      global.get $global$1
-      i32.const 15
-      i32.add
-      i32.const -16
-      i32.and
-      global.set $global$1
-      local.get $1
-    end
-  )
-  (func $1 (;14;) (type $3) (result i32)
-    global.get $global$1
-  )
-  (func $2 (;15;) (type $2) (param $0 i32)
-    local.get $0
-    global.set $global$1
-  )
-  (func $3 (;16;) (type $5) (param $0 i32) (param $1 i32)
-    block $label$1 ;; label = @1
-      local.get $0
-      global.set $global$1
-      local.get $1
-      global.set $global$2
-    end
-  )
-  (func $4 (;17;) (type $5) (param $0 i32) (param $1 i32)
-    global.get $global$3
-    i32.eqz
-    if ;; label = @1
-      block ;; label = @2
-        local.get $0
-        global.set $global$3
-        local.get $1
-        global.set $global$4
-      end
-    end
-  )
-  (func $5 (;18;) (type $2) (param $0 i32)
-    local.get $0
-    global.set $global$5
-  )
-  (func $6 (;19;) (type $3) (result i32)
-    global.get $global$5
-  )
-  (func $7 (;20;) (type $1) (param $0 i32) (result i32)
-    (local $1 i32) (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32) (local $15 i32) (local $16 i32) (local $17 i32)
-    block $label$1 (result i32) ;; label = @1
-      local.get $0
-      i32.load offset=4
-      local.tee $4
-      i32.const 2
-      i32.shl
-      local.tee $15
-      call $35
-      local.set $3
-      local.get $15
-      call $35
-      local.set $6
-      local.get $15
-      call $35
-      local.set $10
-      local.get $4
-      i32.const 0
-      i32.gt_s
-      local.tee $2
-      if ;; label = @2
-        block ;; label = @3
-          i32.const 0
-          local.set $1
-          loop $label$3 ;; label = @4
-            local.get $3
-            local.get $1
-            i32.const 2
-            i32.shl
-            i32.add
-            local.get $1
-            i32.store
-            local.get $1
-            i32.const 1
-            i32.add
-            local.tee $1
-            local.get $4
-            i32.ne
-            br_if 0 (;@4;)
-          end
-          local.get $3
-          local.get $0
-          i32.load
-          local.tee $0
-          i32.const 2
-          i32.shl
-          i32.add
-          local.get $4
-          i32.const -1
-          i32.add
-          local.tee $11
-          i32.store
-          local.get $3
-          local.get $11
-          i32.const 2
-          i32.shl
-          i32.add
-          local.tee $14
-          local.get $0
-          i32.store
-          local.get $2
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 0
-              local.set $0
-              local.get $4
-              local.set $1
-              loop $label$5 ;; label = @6
-                block $label$6 ;; label = @7
-                  local.get $1
-                  i32.const 1
-                  i32.gt_s
-                  if ;; label = @8
-                    loop $label$8 ;; label = @9
-                      local.get $10
-                      local.get $1
-                      i32.const -1
-                      i32.add
-                      local.tee $2
-                      i32.const 2
-                      i32.shl
-                      i32.add
-                      local.get $1
-                      i32.store
-                      local.get $2
-                      i32.const 1
-                      i32.gt_s
-                      if ;; label = @10
-                        block ;; label = @11
-                          local.get $2
-                          local.set $1
-                          br 2 (;@9;)
-                        end
-                      else
-                        i32.const 1
-                        local.set $2
-                      end
-                    end
-                  else
-                    local.get $1
-                    local.set $2
-                  end
-                  local.get $3
-                  i32.load
-                  local.tee $7
-                  if ;; label = @8
-                    local.get $14
-                    i32.load
-                    local.get $11
-                    i32.ne
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $6
-                        local.get $3
-                        local.get $15
-                        call $40
-                        drop
-                        i32.const 0
-                        local.set $8
-                        local.get $6
-                        i32.load
-                        local.set $9
-                        loop $label$14 ;; label = @11
-                          local.get $9
-                          i32.const -1
-                          i32.add
-                          local.tee $1
-                          i32.const 1
-                          i32.gt_s
-                          if ;; label = @12
-                            block ;; label = @13
-                              i32.const 1
-                              local.set $5
-                              loop $label$16 ;; label = @14
-                                local.get $6
-                                local.get $5
-                                i32.const 2
-                                i32.shl
-                                i32.add
-                                local.tee $12
-                                i32.load
-                                local.set $17
-                                local.get $12
-                                local.get $6
-                                local.get $1
-                                i32.const 2
-                                i32.shl
-                                i32.add
-                                local.tee $12
-                                i32.load
-                                i32.store
-                                local.get $12
-                                local.get $17
-                                i32.store
-                                local.get $5
-                                i32.const 1
-                                i32.add
-                                local.tee $5
-                                local.get $1
-                                i32.const -1
-                                i32.add
-                                local.tee $1
-                                i32.lt_s
-                                br_if 0 (;@14;)
-                              end
-                            end
-                          end
-                          local.get $8
-                          i32.const 1
-                          i32.add
-                          local.set $5
-                          local.get $6
-                          local.get $9
-                          i32.const 2
-                          i32.shl
-                          i32.add
-                          local.tee $12
-                          i32.load
-                          local.set $1
-                          local.get $12
-                          local.get $9
-                          i32.store
-                          local.get $1
-                          if ;; label = @12
-                            block ;; label = @13
-                              local.get $5
-                              local.set $8
-                              local.get $1
-                              local.set $9
-                              br 2 (;@11;)
-                            end
-                          end
-                        end
-                        local.get $0
-                        local.get $8
-                        i32.le_s
-                        if ;; label = @11
-                          local.get $5
-                          local.set $0
-                        end
-                      end
-                    end
-                  end
-                  local.get $2
-                  local.get $11
-                  i32.lt_s
-                  if ;; label = @8
-                    local.get $2
-                    local.set $1
-                  else
-                    block ;; label = @9
-                      i32.const 31
-                      local.set $1
-                      br 2 (;@7;)
-                    end
-                  end
-                  loop $label$21 ;; label = @8
-                    local.get $1
-                    i32.const 0
-                    i32.gt_s
-                    if ;; label = @9
-                      block ;; label = @10
-                        i32.const 0
-                        local.set $2
-                        loop $label$23 ;; label = @11
-                          local.get $3
-                          local.get $2
-                          i32.const 2
-                          i32.shl
-                          i32.add
-                          local.get $3
-                          local.get $2
-                          i32.const 1
-                          i32.add
-                          local.tee $2
-                          i32.const 2
-                          i32.shl
-                          i32.add
-                          i32.load
-                          i32.store
-                          local.get $2
-                          local.get $1
-                          i32.lt_s
-                          br_if 0 (;@11;)
-                          local.get $1
-                          local.set $2
-                        end
-                      end
-                    else
-                      i32.const 0
-                      local.set $2
-                    end
-                    local.get $3
-                    local.get $2
-                    i32.const 2
-                    i32.shl
-                    i32.add
-                    local.get $7
-                    i32.store
-                    local.get $10
-                    local.get $1
-                    i32.const 2
-                    i32.shl
-                    i32.add
-                    local.tee $2
-                    i32.load
-                    local.set $5
-                    local.get $2
-                    local.get $5
-                    i32.const -1
-                    i32.add
-                    i32.store
-                    local.get $5
-                    i32.const 1
-                    i32.gt_s
-                    br_if 2 (;@6;)
-                    local.get $1
-                    i32.const 1
-                    i32.add
-                    local.tee $1
-                    local.get $11
-                    i32.lt_s
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $3
-                        i32.load
-                        local.set $7
-                        br 2 (;@8;)
-                      end
-                    else
-                      block ;; label = @10
-                        i32.const 31
-                        local.set $1
-                        br 3 (;@7;)
-                      end
-                    end
-                  end
-                end
-              end
-              local.get $1
-              i32.const 31
-              i32.eq
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $3
-                  call $36
-                  local.get $6
-                  call $36
-                  local.get $10
-                  call $36
-                  local.get $0
-                  return
-                end
-              end
-            end
-          else
-            block ;; label = @5
-              local.get $14
-              local.set $16
-              local.get $11
-              local.set $13
-            end
-          end
-        end
-      else
-        block ;; label = @3
-          local.get $3
-          local.get $0
-          i32.load
-          local.tee $0
-          i32.const 2
-          i32.shl
-          i32.add
-          local.get $4
-          i32.const -1
-          i32.add
-          local.tee $13
-          i32.store
-          local.get $3
-          local.get $13
-          i32.const 2
-          i32.shl
-          i32.add
-          local.tee $16
-          local.get $0
-          i32.store
-        end
-      end
-      i32.const 0
-      local.set $0
-      local.get $4
-      local.set $1
-      loop $label$30 ;; label = @2
-        block $label$31 ;; label = @3
-          local.get $1
-          i32.const 1
-          i32.gt_s
-          if ;; label = @4
-            loop $label$33 ;; label = @5
-              local.get $10
-              local.get $1
-              i32.const -1
-              i32.add
-              local.tee $2
-              i32.const 2
-              i32.shl
-              i32.add
-              local.get $1
-              i32.store
-              local.get $2
-              i32.const 1
-              i32.gt_s
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $2
-                  local.set $1
-                  br 2 (;@5;)
-                end
-              else
-                i32.const 1
-                local.set $2
-              end
-            end
-          else
-            local.get $1
-            local.set $2
-          end
-          local.get $3
-          i32.load
-          local.tee $9
-          if ;; label = @4
-            local.get $16
-            i32.load
-            local.get $13
-            i32.ne
-            if ;; label = @5
-              block ;; label = @6
-                i32.const 0
-                local.set $5
-                local.get $6
-                i32.load
-                local.set $8
-                loop $label$39 ;; label = @7
-                  local.get $8
-                  i32.const -1
-                  i32.add
-                  local.tee $1
-                  i32.const 1
-                  i32.gt_s
-                  if ;; label = @8
-                    block ;; label = @9
-                      i32.const 1
-                      local.set $4
-                      loop $label$41 ;; label = @10
-                        local.get $6
-                        local.get $4
-                        i32.const 2
-                        i32.shl
-                        i32.add
-                        local.tee $7
-                        i32.load
-                        local.set $14
-                        local.get $7
-                        local.get $6
-                        local.get $1
-                        i32.const 2
-                        i32.shl
-                        i32.add
-                        local.tee $7
-                        i32.load
-                        i32.store
-                        local.get $7
-                        local.get $14
-                        i32.store
-                        local.get $4
-                        i32.const 1
-                        i32.add
-                        local.tee $4
-                        local.get $1
-                        i32.const -1
-                        i32.add
-                        local.tee $1
-                        i32.lt_s
-                        br_if 0 (;@10;)
-                      end
-                    end
-                  end
-                  local.get $5
-                  i32.const 1
-                  i32.add
-                  local.set $4
-                  local.get $6
-                  local.get $8
-                  i32.const 2
-                  i32.shl
-                  i32.add
-                  local.tee $7
-                  i32.load
-                  local.set $1
-                  local.get $7
-                  local.get $8
-                  i32.store
-                  local.get $1
-                  if ;; label = @8
-                    block ;; label = @9
-                      local.get $4
-                      local.set $5
-                      local.get $1
-                      local.set $8
-                      br 2 (;@7;)
-                    end
-                  end
-                end
-                local.get $0
-                local.get $5
-                i32.le_s
-                if ;; label = @7
-                  local.get $4
-                  local.set $0
-                end
-              end
-            end
-          end
-          local.get $2
-          local.get $13
-          i32.lt_s
-          if ;; label = @4
-            local.get $2
-            local.set $1
-          else
-            block ;; label = @5
-              i32.const 31
-              local.set $1
-              br 2 (;@3;)
-            end
-          end
-          loop $label$46 ;; label = @4
-            local.get $1
-            i32.const 0
-            i32.gt_s
-            if ;; label = @5
-              block ;; label = @6
-                i32.const 0
-                local.set $2
-                loop $label$48 ;; label = @7
-                  local.get $3
-                  local.get $2
-                  i32.const 2
-                  i32.shl
-                  i32.add
-                  local.get $3
-                  local.get $2
-                  i32.const 1
-                  i32.add
-                  local.tee $2
-                  i32.const 2
-                  i32.shl
-                  i32.add
-                  i32.load
-                  i32.store
-                  local.get $2
-                  local.get $1
-                  i32.lt_s
-                  br_if 0 (;@7;)
-                  local.get $1
-                  local.set $2
-                end
-              end
-            else
-              i32.const 0
-              local.set $2
-            end
-            local.get $3
-            local.get $2
-            i32.const 2
-            i32.shl
-            i32.add
-            local.get $9
-            i32.store
-            local.get $10
-            local.get $1
-            i32.const 2
-            i32.shl
-            i32.add
-            local.tee $2
-            i32.load
-            local.set $4
-            local.get $2
-            local.get $4
-            i32.const -1
-            i32.add
-            i32.store
-            local.get $4
-            i32.const 1
-            i32.gt_s
-            br_if 2 (;@2;)
-            local.get $1
-            i32.const 1
-            i32.add
-            local.tee $1
-            local.get $13
-            i32.lt_s
-            if ;; label = @5
-              block ;; label = @6
-                local.get $3
-                i32.load
-                local.set $9
-                br 2 (;@4;)
-              end
-            else
-              block ;; label = @6
-                i32.const 31
-                local.set $1
-                br 3 (;@3;)
-              end
-            end
-          end
-        end
-      end
-      local.get $1
-      i32.const 31
-      i32.eq
-      if ;; label = @2
-        block ;; label = @3
-          local.get $3
-          call $36
-          local.get $6
-          call $36
-          local.get $10
-          call $36
-          local.get $0
-          return
-        end
-      end
-      i32.const 0
-    end
-  )
-  (func $8 (;21;) (type $4) (param $0 i32) (param $1 i32) (result i32)
-    (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $5
-      global.get $global$1
-      i32.const 32
-      i32.add
-      global.set $global$1
-      local.get $5
-      i32.const 16
-      i32.add
-      local.set $7
-      local.get $5
-      i32.const 8
-      i32.add
-      local.set $10
-      local.get $5
-      local.set $2
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          local.get $0
-          i32.const 1
-          i32.le_s
-          br_if 0 (;@3;)
-          block $label$4 ;; label = @4
-            block $label$5 ;; label = @5
-              block $label$6 ;; label = @6
-                block $label$7 ;; label = @7
-                  block $label$8 ;; label = @8
-                    block $label$9 ;; label = @9
-                      block $label$10 ;; label = @10
-                        local.get $1
-                        i32.load offset=4
-                        i32.load8_s
-                        local.tee $0
-                        i32.const 48
-                        i32.sub
-                        br_table 5 (;@5;) 0 (;@10;) 2 (;@8;) 1 (;@9;) 3 (;@7;) 4 (;@6;) 6 (;@4;)
-                      end
-                      i32.const 9
-                      local.set $3
-                      br 7 (;@2;)
-                    end
-                    br 5 (;@3;)
-                  end
-                  i32.const 10
-                  local.set $3
-                  br 5 (;@2;)
-                end
-                i32.const 11
-                local.set $3
-                br 4 (;@2;)
-              end
-              i32.const 12
-              local.set $3
-              br 3 (;@2;)
-            end
-            local.get $5
-            global.set $global$1
-            i32.const 0
-            return
-          end
-          local.get $2
-          local.get $0
-          i32.const -48
-          i32.add
-          i32.store
-          i32.const 1140
-          local.get $2
-          call $33
-          drop
-          local.get $5
-          global.set $global$1
-          i32.const -1
-          return
-        end
-        i32.const 11
-        local.set $3
-      end
-      local.get $3
-      i32.const -1
-      i32.add
-      local.set $6
-      i32.const 0
-      local.set $2
-      i32.const 0
-      local.set $0
-      loop $label$11 ;; label = @2
-        i32.const 12
-        call $35
-        local.tee $1
-        local.get $0
-        i32.store
-        local.get $1
-        local.get $3
-        i32.store offset=4
-        local.get $1
-        local.get $2
-        i32.store offset=8
-        local.get $0
-        i32.const 1
-        i32.add
-        local.tee $0
-        local.get $6
-        i32.ne
-        if ;; label = @3
-          block ;; label = @4
-            local.get $1
-            local.set $2
-            br 2 (;@2;)
-          end
-        end
-      end
-      local.get $3
-      i32.const 2
-      i32.shl
-      local.tee $0
-      call $35
-      local.set $4
-      local.get $0
-      call $35
-      local.set $8
-      i32.const 0
-      local.set $0
-      loop $label$13 ;; label = @2
-        local.get $4
-        local.get $0
-        i32.const 2
-        i32.shl
-        i32.add
-        local.get $0
-        i32.store
-        local.get $0
-        i32.const 1
-        i32.add
-        local.tee $0
-        local.get $3
-        i32.ne
-        br_if 0 (;@2;)
-      end
-      local.get $3
-      local.set $0
-      i32.const 30
-      local.set $6
-      loop $label$14 ;; label = @2
-        block $label$15 ;; label = @3
-          i32.const 0
-          local.set $2
-          loop $label$16 ;; label = @4
-            local.get $10
-            local.get $4
-            local.get $2
-            i32.const 2
-            i32.shl
-            i32.add
-            i32.load
-            i32.const 1
-            i32.add
-            i32.store
-            i32.const 1174
-            local.get $10
-            call $33
-            drop
-            local.get $2
-            i32.const 1
-            i32.add
-            local.tee $2
-            local.get $3
-            i32.ne
-            br_if 0 (;@4;)
-          end
-          i32.const 10
-          call $34
-          drop
-          local.get $0
-          i32.const 1
-          i32.gt_s
-          if ;; label = @4
-            loop $label$18 ;; label = @5
-              local.get $8
-              local.get $0
-              i32.const -1
-              i32.add
-              local.tee $2
-              i32.const 2
-              i32.shl
-              i32.add
-              local.get $0
-              i32.store
-              local.get $2
-              i32.const 1
-              i32.gt_s
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $2
-                  local.set $0
-                  br 2 (;@5;)
-                end
-              else
-                i32.const 1
-                local.set $0
-              end
-            end
-          else
-            local.get $0
-            local.get $3
-            i32.eq
-            br_if 1 (;@3;)
-          end
-          local.get $6
-          i32.const -1
-          i32.add
-          local.set $6
-          loop $label$22 ;; label = @4
-            block $label$23 ;; label = @5
-              local.get $4
-              i32.load
-              local.set $9
-              local.get $0
-              i32.const 0
-              i32.gt_s
-              if ;; label = @6
-                block ;; label = @7
-                  i32.const 0
-                  local.set $2
-                  loop $label$25 ;; label = @8
-                    local.get $4
-                    local.get $2
-                    i32.const 2
-                    i32.shl
-                    i32.add
-                    local.get $4
-                    local.get $2
-                    i32.const 1
-                    i32.add
-                    local.tee $2
-                    i32.const 2
-                    i32.shl
-                    i32.add
-                    i32.load
-                    i32.store
-                    local.get $2
-                    local.get $0
-                    i32.lt_s
-                    br_if 0 (;@8;)
-                    local.get $0
-                    local.set $2
-                  end
-                end
-              else
-                i32.const 0
-                local.set $2
-              end
-              local.get $4
-              local.get $2
-              i32.const 2
-              i32.shl
-              i32.add
-              local.get $9
-              i32.store
-              local.get $8
-              local.get $0
-              i32.const 2
-              i32.shl
-              i32.add
-              local.tee $9
-              i32.load
-              local.set $2
-              local.get $9
-              local.get $2
-              i32.const -1
-              i32.add
-              i32.store
-              local.get $2
-              i32.const 1
-              i32.gt_s
-              br_if 0 (;@5;)
-              local.get $0
-              i32.const 1
-              i32.add
-              local.tee $0
-              local.get $3
-              i32.ne
-              br_if 1 (;@4;)
-              br 2 (;@3;)
-            end
-          end
-          local.get $6
-          br_if 1 (;@2;)
-        end
-      end
-      local.get $4
-      call $36
-      local.get $8
-      call $36
-      local.get $1
-      if ;; label = @2
-        block ;; label = @3
-          i32.const 0
-          local.set $0
-          loop $label$28 ;; label = @4
-            local.get $0
-            local.get $1
-            call $7
-            local.tee $2
-            i32.lt_s
-            if ;; label = @5
-              local.get $2
-              local.set $0
-            end
-            local.get $1
-            i32.load offset=8
-            local.set $2
-            local.get $1
-            call $36
-            local.get $2
-            if ;; label = @5
-              block ;; label = @6
-                local.get $2
-                local.set $1
-                br 2 (;@4;)
-              end
-            end
-          end
-        end
-      else
-        i32.const 0
-        local.set $0
-      end
-      local.get $7
-      local.get $3
-      i32.store
-      local.get $7
-      local.get $0
-      i32.store offset=4
-      i32.const 1151
-      local.get $7
-      call $33
-      drop
-      local.get $5
-      global.set $global$1
-      i32.const 0
-    end
-  )
-  (func $9 (;22;) (type $1) (param $0 i32) (result i32)
-    (local $1 i32) (local $2 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $1
-      global.get $global$1
-      i32.const 16
-      i32.add
-      global.set $global$1
-      local.get $1
-      local.tee $2
-      local.get $0
-      i32.load offset=60
-      i32.store
-      i32.const 6
-      local.get $2
-      call $fimport$8
-      call $11
-      local.set $0
-      local.get $1
-      global.set $global$1
-      local.get $0
-    end
-  )
-  (func $10 (;23;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32) (local $4 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $4
-      global.get $global$1
-      i32.const 32
-      i32.add
-      global.set $global$1
-      local.get $4
-      local.tee $3
-      local.get $0
-      i32.load offset=60
-      i32.store
-      local.get $3
-      i32.const 0
-      i32.store offset=4
-      local.get $3
-      local.get $1
-      i32.store offset=8
-      local.get $3
-      local.get $4
-      i32.const 20
-      i32.add
-      local.tee $0
-      i32.store offset=12
-      local.get $3
-      local.get $2
-      i32.store offset=16
-      i32.const 140
-      local.get $3
-      call $fimport$14
-      call $11
-      i32.const 0
-      i32.lt_s
-      if (result i32) ;; label = @2
-        block (result i32) ;; label = @3
-          local.get $0
-          i32.const -1
-          i32.store
-          i32.const -1
-        end
-      else
-        local.get $0
-        i32.load
-      end
-      local.set $0
-      local.get $4
-      global.set $global$1
-      local.get $0
-    end
-  )
-  (func $11 (;24;) (type $1) (param $0 i32) (result i32)
-    local.get $0
-    i32.const -4096
-    i32.gt_u
-    if (result i32) ;; label = @1
-      block (result i32) ;; label = @2
-        call $12
-        i32.const 0
-        local.get $0
-        i32.sub
-        i32.store
-        i32.const -1
-      end
-    else
-      local.get $0
-    end
-  )
-  (func $12 (;25;) (type $3) (result i32)
-    i32.const 3648
-  )
-  (func $13 (;26;) (type $2) (param $0 i32)
-    nop
-  )
-  (func $14 (;27;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32) (local $4 i32) (local $5 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $4
-      global.get $global$1
-      i32.const 80
-      i32.add
-      global.set $global$1
-      local.get $4
-      local.set $3
-      local.get $4
-      i32.const 12
-      i32.add
-      local.set $5
-      local.get $0
-      i32.const 3
-      i32.store offset=36
-      local.get $0
-      i32.load
-      i32.const 64
-      i32.and
-      i32.eqz
-      if ;; label = @2
-        block ;; label = @3
-          local.get $3
-          local.get $0
-          i32.load offset=60
-          i32.store
-          local.get $3
-          i32.const 21505
-          i32.store offset=4
-          local.get $3
-          local.get $5
-          i32.store offset=8
-          i32.const 54
-          local.get $3
-          call $fimport$13
-          if ;; label = @4
-            local.get $0
-            i32.const -1
-            i32.store8 offset=75
-          end
-        end
-      end
-      local.get $0
-      local.get $1
-      local.get $2
-      call $15
-      local.set $0
-      local.get $4
-      global.set $global$1
-      local.get $0
-    end
-  )
-  (func $15 (;28;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $8
-      global.get $global$1
-      i32.const 48
-      i32.add
-      global.set $global$1
-      local.get $8
-      i32.const 16
-      i32.add
-      local.set $9
-      local.get $8
-      local.set $10
-      local.get $8
-      i32.const 32
-      i32.add
-      local.tee $3
-      local.get $0
-      i32.const 28
-      i32.add
-      local.tee $6
-      i32.load
-      local.tee $4
-      i32.store
-      local.get $3
-      local.get $0
-      i32.const 20
-      i32.add
-      local.tee $11
-      i32.load
-      local.get $4
-      i32.sub
-      local.tee $5
-      i32.store offset=4
-      local.get $3
-      local.get $1
-      i32.store offset=8
-      local.get $3
-      local.get $2
-      i32.store offset=12
-      local.get $0
-      i32.const 60
-      i32.add
-      local.set $13
-      local.get $0
-      i32.const 44
-      i32.add
-      local.set $14
-      local.get $3
-      local.set $1
-      i32.const 2
-      local.set $4
-      local.get $5
-      local.get $2
-      i32.add
-      local.set $12
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          block $label$4 ;; label = @4
-            loop $label$5 ;; label = @5
-              i32.const 3604
-              i32.load
-              if ;; label = @6
-                block ;; label = @7
-                  i32.const 1
-                  local.get $0
-                  call $fimport$9
-                  local.get $10
-                  local.get $13
-                  i32.load
-                  i32.store
-                  local.get $10
-                  local.get $1
-                  i32.store offset=4
-                  local.get $10
-                  local.get $4
-                  i32.store offset=8
-                  i32.const 146
-                  local.get $10
-                  call $fimport$15
-                  call $11
-                  local.set $3
-                  i32.const 0
-                  call $fimport$7
-                end
-              else
-                block ;; label = @7
-                  local.get $9
-                  local.get $13
-                  i32.load
-                  i32.store
-                  local.get $9
-                  local.get $1
-                  i32.store offset=4
-                  local.get $9
-                  local.get $4
-                  i32.store offset=8
-                  i32.const 146
-                  local.get $9
-                  call $fimport$15
-                  call $11
-                  local.set $3
-                end
-              end
-              local.get $12
-              local.get $3
-              i32.eq
-              br_if 1 (;@4;)
-              local.get $3
-              i32.const 0
-              i32.lt_s
-              br_if 2 (;@3;)
-              local.get $3
-              local.get $1
-              i32.load offset=4
-              local.tee $5
-              i32.gt_u
-              if (result i32) ;; label = @6
-                block (result i32) ;; label = @7
-                  local.get $6
-                  local.get $14
-                  i32.load
-                  local.tee $7
-                  i32.store
-                  local.get $11
-                  local.get $7
-                  i32.store
-                  local.get $1
-                  i32.load offset=12
-                  local.set $7
-                  local.get $1
-                  i32.const 8
-                  i32.add
-                  local.set $1
-                  local.get $4
-                  i32.const -1
-                  i32.add
-                  local.set $4
-                  local.get $3
-                  local.get $5
-                  i32.sub
-                end
-              else
-                local.get $4
-                i32.const 2
-                i32.eq
-                if (result i32) ;; label = @7
-                  block (result i32) ;; label = @8
-                    local.get $6
-                    local.get $6
-                    i32.load
-                    local.get $3
-                    i32.add
-                    i32.store
-                    local.get $5
-                    local.set $7
-                    i32.const 2
-                    local.set $4
-                    local.get $3
-                  end
-                else
-                  block (result i32) ;; label = @8
-                    local.get $5
-                    local.set $7
-                    local.get $3
-                  end
-                end
-              end
-              local.set $5
-              local.get $1
-              local.get $1
-              i32.load
-              local.get $5
-              i32.add
-              i32.store
-              local.get $1
-              local.get $7
-              local.get $5
-              i32.sub
-              i32.store offset=4
-              local.get $12
-              local.get $3
-              i32.sub
-              local.set $12
-              br 0 (;@5;)
-            end
-          end
-          local.get $0
-          local.get $14
-          i32.load
-          local.tee $1
-          local.get $0
-          i32.load offset=48
-          i32.add
-          i32.store offset=16
-          local.get $6
-          local.get $1
-          i32.store
-          local.get $11
-          local.get $1
-          i32.store
-          br 1 (;@2;)
-        end
-        local.get $0
-        i32.const 0
-        i32.store offset=16
-        local.get $6
-        i32.const 0
-        i32.store
-        local.get $11
-        i32.const 0
-        i32.store
-        local.get $0
-        local.get $0
-        i32.load
-        i32.const 32
-        i32.or
-        i32.store
-        local.get $4
-        i32.const 2
-        i32.eq
-        if (result i32) ;; label = @3
-          i32.const 0
-        else
-          local.get $2
-          local.get $1
-          i32.load offset=4
-          i32.sub
-        end
-        local.set $2
-      end
-      local.get $8
-      global.set $global$1
-      local.get $2
-    end
-  )
-  (func $16 (;29;) (type $2) (param $0 i32)
-    local.get $0
-    i32.load offset=68
-    i32.eqz
-    if ;; label = @1
-      local.get $0
-      call $13
-    end
-  )
-  (func $17 (;30;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32) (local $4 i32) (local $5 i32)
-    block $label$1 (result i32) ;; label = @1
-      local.get $1
-      i32.const 255
-      i32.and
-      local.set $5
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          block $label$4 ;; label = @4
-            local.get $2
-            i32.const 0
-            i32.ne
-            local.tee $4
-            local.get $0
-            i32.const 3
-            i32.and
-            i32.const 0
-            i32.ne
-            i32.and
-            if ;; label = @5
-              block ;; label = @6
-                local.get $1
-                i32.const 255
-                i32.and
-                local.set $4
-                local.get $2
-                local.set $3
-                local.get $0
-                local.set $2
-                loop $label$6 ;; label = @7
-                  local.get $2
-                  i32.load8_s
-                  local.get $4
-                  i32.const 24
-                  i32.shl
-                  i32.const 24
-                  i32.shr_s
-                  i32.eq
-                  if ;; label = @8
-                    block ;; label = @9
-                      local.get $3
-                      local.set $0
-                      br 6 (;@3;)
-                    end
-                  end
-                  local.get $3
-                  i32.const -1
-                  i32.add
-                  local.tee $3
-                  i32.const 0
-                  i32.ne
-                  local.tee $0
-                  local.get $2
-                  i32.const 1
-                  i32.add
-                  local.tee $2
-                  i32.const 3
-                  i32.and
-                  i32.const 0
-                  i32.ne
-                  i32.and
-                  br_if 0 (;@7;)
-                  br 3 (;@4;)
-                end
-              end
-            else
-              block ;; label = @6
-                local.get $2
-                local.set $3
-                local.get $0
-                local.set $2
-                local.get $4
-                local.set $0
-              end
-            end
-          end
-          local.get $0
-          if ;; label = @4
-            block ;; label = @5
-              local.get $3
-              local.set $0
-              br 2 (;@3;)
-            end
-          else
-            i32.const 0
-            local.set $0
-          end
-          br 1 (;@2;)
-        end
-        local.get $2
-        i32.load8_s
-        local.get $1
-        i32.const 255
-        i32.and
-        local.tee $1
-        i32.const 24
-        i32.shl
-        i32.const 24
-        i32.shr_s
-        i32.ne
-        if ;; label = @3
-          block ;; label = @4
-            local.get $5
-            i32.const 16843009
-            i32.mul
-            local.set $3
-            block $label$12 ;; label = @5
-              block $label$13 ;; label = @6
-                local.get $0
-                i32.const 3
-                i32.le_u
-                br_if 0 (;@6;)
-                loop $label$14 ;; label = @7
-                  local.get $2
-                  i32.load
-                  local.get $3
-                  i32.xor
-                  local.tee $4
-                  i32.const -2139062144
-                  i32.and
-                  i32.const -2139062144
-                  i32.xor
-                  local.get $4
-                  i32.const -16843009
-                  i32.add
-                  i32.and
-                  i32.eqz
-                  if ;; label = @8
-                    block ;; label = @9
-                      local.get $2
-                      i32.const 4
-                      i32.add
-                      local.set $2
-                      local.get $0
-                      i32.const -4
-                      i32.add
-                      local.tee $0
-                      i32.const 3
-                      i32.gt_u
-                      br_if 2 (;@7;)
-                      br 3 (;@6;)
-                    end
-                  end
-                end
-                br 1 (;@5;)
-              end
-              local.get $0
-              i32.eqz
-              if ;; label = @6
-                block ;; label = @7
-                  i32.const 0
-                  local.set $0
-                  br 5 (;@2;)
-                end
-              end
-            end
-            loop $label$17 ;; label = @5
-              local.get $2
-              i32.load8_s
-              local.get $1
-              i32.const 24
-              i32.shl
-              i32.const 24
-              i32.shr_s
-              i32.eq
-              br_if 3 (;@2;)
-              local.get $2
-              i32.const 1
-              i32.add
-              local.set $2
-              local.get $0
-              i32.const -1
-              i32.add
-              local.tee $0
-              br_if 0 (;@5;)
-              i32.const 0
-              local.set $0
-            end
-          end
-        end
-      end
-      local.get $0
-      if (result i32) ;; label = @2
-        local.get $2
-      else
-        i32.const 0
-      end
-    end
-  )
-  (func $18 (;31;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $4
-      global.get $global$1
-      i32.const 224
-      i32.add
-      global.set $global$1
-      local.get $4
-      i32.const 136
-      i32.add
-      local.set $5
-      local.get $4
-      i32.const 80
-      i32.add
-      local.tee $3
-      i64.const 0
-      i64.store align=4
-      local.get $3
-      i64.const 0
-      i64.store offset=8 align=4
-      local.get $3
-      i64.const 0
-      i64.store offset=16 align=4
-      local.get $3
-      i64.const 0
-      i64.store offset=24 align=4
-      local.get $3
-      i64.const 0
-      i64.store offset=32 align=4
-      local.get $4
-      i32.const 120
-      i32.add
-      local.tee $6
-      local.get $2
-      i32.load
-      i32.store
-      i32.const 0
-      local.get $1
-      local.get $6
-      local.get $4
-      local.tee $2
-      local.get $3
-      call $19
-      i32.const 0
-      i32.lt_s
-      if ;; label = @2
-        i32.const -1
-        local.set $1
-      else
-        block ;; label = @3
-          local.get $0
-          i32.load offset=76
-          i32.const -1
-          i32.gt_s
-          if (result i32) ;; label = @4
-            local.get $0
-            call $20
-          else
-            i32.const 0
-          end
-          local.set $12
-          local.get $0
-          i32.load
-          local.set $7
-          local.get $0
-          i32.load8_s offset=74
-          i32.const 1
-          i32.lt_s
-          if ;; label = @4
-            local.get $0
-            local.get $7
-            i32.const -33
-            i32.and
-            i32.store
-          end
-          local.get $0
-          i32.const 48
-          i32.add
-          local.tee $8
-          i32.load
-          if ;; label = @4
-            local.get $0
-            local.get $1
-            local.get $6
-            local.get $2
-            local.get $3
-            call $19
-            local.set $1
-          else
-            block ;; label = @5
-              local.get $0
-              i32.const 44
-              i32.add
-              local.tee $9
-              i32.load
-              local.set $10
-              local.get $9
-              local.get $5
-              i32.store
-              local.get $0
-              i32.const 28
-              i32.add
-              local.tee $13
-              local.get $5
-              i32.store
-              local.get $0
-              i32.const 20
-              i32.add
-              local.tee $11
-              local.get $5
-              i32.store
-              local.get $8
-              i32.const 80
-              i32.store
-              local.get $0
-              i32.const 16
-              i32.add
-              local.tee $14
-              local.get $5
-              i32.const 80
-              i32.add
-              i32.store
-              local.get $0
-              local.get $1
-              local.get $6
-              local.get $2
-              local.get $3
-              call $19
-              local.set $1
-              local.get $10
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $0
-                  i32.const 0
-                  i32.const 0
-                  local.get $0
-                  i32.load offset=36
-                  i32.const 3
-                  i32.and
-                  i32.const 2
-                  i32.add
-                  call_indirect (type $0)
-                  drop
-                  local.get $11
-                  i32.load
-                  i32.eqz
-                  if ;; label = @8
-                    i32.const -1
-                    local.set $1
-                  end
-                  local.get $9
-                  local.get $10
-                  i32.store
-                  local.get $8
-                  i32.const 0
-                  i32.store
-                  local.get $14
-                  i32.const 0
-                  i32.store
-                  local.get $13
-                  i32.const 0
-                  i32.store
-                  local.get $11
-                  i32.const 0
-                  i32.store
-                end
-              end
-            end
-          end
-          local.get $0
-          local.get $0
-          i32.load
-          local.tee $2
-          local.get $7
-          i32.const 32
-          i32.and
-          i32.or
-          i32.store
-          local.get $12
-          if ;; label = @4
-            local.get $0
-            call $13
-          end
-          local.get $2
-          i32.const 32
-          i32.and
-          if ;; label = @4
-            i32.const -1
-            local.set $1
-          end
-        end
-      end
-      local.get $4
-      global.set $global$1
-      local.get $1
-    end
-  )
-  (func $19 (;32;) (type $7) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32) (result i32)
-    (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32) (local $15 i32) (local $16 i32) (local $17 i32) (local $18 i32) (local $19 i32) (local $20 i32) (local $21 i32) (local $22 i32) (local $23 i32) (local $24 i32) (local $25 i32) (local $26 i32) (local $27 i32) (local $28 i32) (local $29 i32) (local $30 i32) (local $31 i32) (local $32 i32) (local $33 i32) (local $34 i32) (local $35 i32) (local $36 i32) (local $37 i32) (local $38 i32) (local $39 i32) (local $40 i32) (local $41 i32) (local $42 i32) (local $43 i32) (local $44 i32) (local $45 i32) (local $46 i32) (local $47 i32) (local $48 i32) (local $49 i32) (local $50 i64) (local $51 i64) (local $52 f64) (local $53 f64)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $23
-      global.get $global$1
-      i32.const 624
-      i32.add
-      global.set $global$1
-      local.get $23
-      i32.const 16
-      i32.add
-      local.set $20
-      local.get $23
-      local.set $16
-      local.get $23
-      i32.const 528
-      i32.add
-      local.set $36
-      local.get $0
-      i32.const 0
-      i32.ne
-      local.set $30
-      local.get $23
-      i32.const 536
-      i32.add
-      local.tee $17
-      i32.const 40
-      i32.add
-      local.tee $21
-      local.set $38
-      local.get $17
-      i32.const 39
-      i32.add
-      local.set $39
-      local.get $23
-      i32.const 8
-      i32.add
-      local.tee $37
-      i32.const 4
-      i32.add
-      local.set $42
-      i32.const 0
-      local.get $23
-      i32.const 588
-      i32.add
-      local.tee $19
-      local.tee $27
-      i32.sub
-      local.set $43
-      local.get $23
-      i32.const 576
-      i32.add
-      local.tee $17
-      i32.const 12
-      i32.add
-      local.set $33
-      local.get $17
-      i32.const 11
-      i32.add
-      local.set $40
-      local.get $33
-      local.tee $28
-      local.get $27
-      i32.sub
-      local.set $44
-      i32.const -2
-      local.get $27
-      i32.sub
-      local.set $45
-      local.get $28
-      i32.const 2
-      i32.add
-      local.set $46
-      local.get $23
-      i32.const 24
-      i32.add
-      local.tee $47
-      i32.const 288
-      i32.add
-      local.set $48
-      local.get $19
-      i32.const 9
-      i32.add
-      local.tee $31
-      local.set $41
-      local.get $19
-      i32.const 8
-      i32.add
-      local.set $34
-      i32.const 0
-      local.set $15
-      i32.const 0
-      local.set $10
-      i32.const 0
-      local.set $17
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          loop $label$4 ;; label = @4
-            block $label$5 ;; label = @5
-              local.get $15
-              i32.const -1
-              i32.gt_s
-              if ;; label = @6
-                local.get $10
-                i32.const 2147483647
-                local.get $15
-                i32.sub
-                i32.gt_s
-                if (result i32) ;; label = @7
-                  block (result i32) ;; label = @8
-                    call $12
-                    i32.const 75
-                    i32.store
-                    i32.const -1
-                  end
-                else
-                  local.get $10
-                  local.get $15
-                  i32.add
-                end
-                local.set $15
-              end
-              local.get $1
-              i32.load8_s
-              local.tee $5
-              i32.const 24
-              i32.shl
-              i32.const 24
-              i32.shr_s
-              i32.eqz
-              br_if 2 (;@3;)
-              local.get $1
-              local.set $11
-              block $label$9 ;; label = @6
-                block $label$10 ;; label = @7
-                  loop $label$11 ;; label = @8
-                    block $label$12 ;; label = @9
-                      block $label$13 ;; label = @10
-                        block $label$14 ;; label = @11
-                          block $label$15 ;; label = @12
-                            local.get $5
-                            i32.const 24
-                            i32.shl
-                            i32.const 24
-                            i32.shr_s
-                            i32.const 0
-                            i32.sub
-                            br_table 1 (;@11;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 0 (;@12;) 2 (;@10;)
-                          end
-                          local.get $11
-                          local.set $5
-                          br 4 (;@7;)
-                        end
-                        local.get $11
-                        local.set $5
-                        br 1 (;@9;)
-                      end
-                      local.get $11
-                      i32.const 1
-                      i32.add
-                      local.tee $11
-                      i32.load8_s
-                      local.set $5
-                      br 1 (;@8;)
-                    end
-                  end
-                  br 1 (;@6;)
-                end
-                loop $label$16 ;; label = @7
-                  local.get $5
-                  i32.load8_s offset=1
-                  i32.const 37
-                  i32.ne
-                  br_if 1 (;@6;)
-                  local.get $11
-                  i32.const 1
-                  i32.add
-                  local.set $11
-                  local.get $5
-                  i32.const 2
-                  i32.add
-                  local.tee $5
-                  i32.load8_s
-                  i32.const 37
-                  i32.eq
-                  br_if 0 (;@7;)
-                end
-              end
-              local.get $11
-              local.get $1
-              i32.sub
-              local.set $10
-              local.get $30
-              if ;; label = @6
-                local.get $0
-                i32.load
-                i32.const 32
-                i32.and
-                i32.eqz
-                if ;; label = @7
-                  local.get $1
-                  local.get $10
-                  local.get $0
-                  call $21
-                  drop
-                end
-              end
-              local.get $10
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $5
-                  local.set $1
-                  br 3 (;@4;)
-                end
-              end
-              local.get $5
-              i32.const 1
-              i32.add
-              local.tee $11
-              i32.load8_s
-              local.tee $10
-              i32.const 24
-              i32.shl
-              i32.const 24
-              i32.shr_s
-              i32.const -48
-              i32.add
-              local.tee $9
-              i32.const 10
-              i32.lt_u
-              if (result i32) ;; label = @6
-                block (result i32) ;; label = @7
-                  local.get $5
-                  i32.const 3
-                  i32.add
-                  local.set $10
-                  local.get $5
-                  i32.load8_s offset=2
-                  i32.const 36
-                  i32.eq
-                  local.tee $12
-                  if ;; label = @8
-                    local.get $10
-                    local.set $11
-                  end
-                  local.get $12
-                  if ;; label = @8
-                    i32.const 1
-                    local.set $17
-                  end
-                  local.get $11
-                  i32.load8_s
-                  local.set $5
-                  local.get $12
-                  i32.eqz
-                  if ;; label = @8
-                    i32.const -1
-                    local.set $9
-                  end
-                  local.get $17
-                end
-              else
-                block (result i32) ;; label = @7
-                  local.get $10
-                  local.set $5
-                  i32.const -1
-                  local.set $9
-                  local.get $17
-                end
-              end
-              local.set $10
-              block $label$25 ;; label = @6
-                local.get $5
-                i32.const 24
-                i32.shl
-                i32.const 24
-                i32.shr_s
-                i32.const -32
-                i32.add
-                local.tee $12
-                i32.const 32
-                i32.lt_u
-                if ;; label = @7
-                  block ;; label = @8
-                    i32.const 0
-                    local.set $17
-                    loop $label$27 ;; label = @9
-                      i32.const 1
-                      local.get $12
-                      i32.shl
-                      i32.const 75913
-                      i32.and
-                      i32.eqz
-                      br_if 3 (;@6;)
-                      i32.const 1
-                      local.get $5
-                      i32.const 24
-                      i32.shl
-                      i32.const 24
-                      i32.shr_s
-                      i32.const -32
-                      i32.add
-                      i32.shl
-                      local.get $17
-                      i32.or
-                      local.set $17
-                      local.get $11
-                      i32.const 1
-                      i32.add
-                      local.tee $11
-                      i32.load8_s
-                      local.tee $5
-                      i32.const 24
-                      i32.shl
-                      i32.const 24
-                      i32.shr_s
-                      i32.const -32
-                      i32.add
-                      local.tee $12
-                      i32.const 32
-                      i32.lt_u
-                      br_if 0 (;@9;)
-                    end
-                  end
-                else
-                  i32.const 0
-                  local.set $17
-                end
-              end
-              block $label$29 ;; label = @6
-                local.get $5
-                i32.const 24
-                i32.shl
-                i32.const 24
-                i32.shr_s
-                i32.const 42
-                i32.eq
-                if ;; label = @7
-                  block ;; label = @8
-                    block $label$31 (result i32) ;; label = @9
-                      block $label$32 ;; label = @10
-                        local.get $11
-                        i32.const 1
-                        i32.add
-                        local.tee $7
-                        i32.load8_s
-                        local.tee $5
-                        i32.const 24
-                        i32.shl
-                        i32.const 24
-                        i32.shr_s
-                        i32.const -48
-                        i32.add
-                        local.tee $12
-                        i32.const 10
-                        i32.ge_u
-                        br_if 0 (;@10;)
-                        local.get $11
-                        i32.load8_s offset=2
-                        i32.const 36
-                        i32.ne
-                        br_if 0 (;@10;)
-                        local.get $4
-                        local.get $12
-                        i32.const 2
-                        i32.shl
-                        i32.add
-                        i32.const 10
-                        i32.store
-                        i32.const 1
-                        local.set $8
-                        local.get $3
-                        local.get $7
-                        i32.load8_s
-                        i32.const -48
-                        i32.add
-                        i32.const 3
-                        i32.shl
-                        i32.add
-                        i64.load
-                        i32.wrap_i64
-                        local.set $10
-                        local.get $11
-                        i32.const 3
-                        i32.add
-                        br 1 (;@9;)
-                      end
-                      local.get $10
-                      if ;; label = @10
-                        block ;; label = @11
-                          i32.const -1
-                          local.set $15
-                          br 6 (;@5;)
-                        end
-                      end
-                      local.get $30
-                      i32.eqz
-                      if ;; label = @10
-                        block ;; label = @11
-                          local.get $17
-                          local.set $12
-                          i32.const 0
-                          local.set $17
-                          local.get $7
-                          local.set $11
-                          i32.const 0
-                          local.set $10
-                          br 5 (;@6;)
-                        end
-                      end
-                      local.get $2
-                      i32.load
-                      i32.const 3
-                      i32.add
-                      i32.const -4
-                      i32.and
-                      local.tee $11
-                      i32.load
-                      local.set $10
-                      local.get $2
-                      local.get $11
-                      i32.const 4
-                      i32.add
-                      i32.store
-                      i32.const 0
-                      local.set $8
-                      local.get $7
-                    end
-                    local.set $11
-                    local.get $17
-                    i32.const 8192
-                    i32.or
-                    local.set $12
-                    i32.const 0
-                    local.get $10
-                    i32.sub
-                    local.set $7
-                    local.get $11
-                    i32.load8_s
-                    local.set $5
-                    local.get $10
-                    i32.const 0
-                    i32.lt_s
-                    local.tee $6
-                    i32.eqz
-                    if ;; label = @9
-                      local.get $17
-                      local.set $12
-                    end
-                    local.get $8
-                    local.set $17
-                    local.get $6
-                    if ;; label = @9
-                      local.get $7
-                      local.set $10
-                    end
-                  end
-                else
-                  local.get $5
-                  i32.const 24
-                  i32.shl
-                  i32.const 24
-                  i32.shr_s
-                  i32.const -48
-                  i32.add
-                  local.tee $12
-                  i32.const 10
-                  i32.lt_u
-                  if ;; label = @8
-                    block ;; label = @9
-                      i32.const 0
-                      local.set $7
-                      local.get $12
-                      local.set $5
-                      loop $label$39 ;; label = @10
-                        local.get $7
-                        i32.const 10
-                        i32.mul
-                        local.get $5
-                        i32.add
-                        local.set $7
-                        local.get $11
-                        i32.const 1
-                        i32.add
-                        local.tee $11
-                        i32.load8_s
-                        local.tee $12
-                        i32.const 24
-                        i32.shl
-                        i32.const 24
-                        i32.shr_s
-                        i32.const -48
-                        i32.add
-                        local.tee $5
-                        i32.const 10
-                        i32.lt_u
-                        br_if 0 (;@10;)
-                      end
-                      local.get $7
-                      i32.const 0
-                      i32.lt_s
-                      if ;; label = @10
-                        block ;; label = @11
-                          i32.const -1
-                          local.set $15
-                          br 6 (;@5;)
-                        end
-                      else
-                        block ;; label = @11
-                          local.get $12
-                          local.set $5
-                          local.get $17
-                          local.set $12
-                          local.get $10
-                          local.set $17
-                          local.get $7
-                          local.set $10
-                        end
-                      end
-                    end
-                  else
-                    block ;; label = @9
-                      local.get $17
-                      local.set $12
-                      local.get $10
-                      local.set $17
-                      i32.const 0
-                      local.set $10
-                    end
-                  end
-                end
-              end
-              block $label$43 ;; label = @6
-                local.get $5
-                i32.const 24
-                i32.shl
-                i32.const 24
-                i32.shr_s
-                i32.const 46
-                i32.eq
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $11
-                    i32.const 1
-                    i32.add
-                    local.tee $7
-                    i32.load8_s
-                    local.tee $5
-                    i32.const 24
-                    i32.shl
-                    i32.const 24
-                    i32.shr_s
-                    i32.const 42
-                    i32.ne
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $5
-                        i32.const 24
-                        i32.shl
-                        i32.const 24
-                        i32.shr_s
-                        i32.const -48
-                        i32.add
-                        local.tee $5
-                        i32.const 10
-                        i32.lt_u
-                        if ;; label = @11
-                          block ;; label = @12
-                            local.get $7
-                            local.set $11
-                            i32.const 0
-                            local.set $7
-                          end
-                        else
-                          block ;; label = @12
-                            i32.const 0
-                            local.set $5
-                            local.get $7
-                            local.set $11
-                            br 6 (;@6;)
-                          end
-                        end
-                        loop $label$48 ;; label = @11
-                          local.get $7
-                          i32.const 10
-                          i32.mul
-                          local.get $5
-                          i32.add
-                          local.set $5
-                          local.get $11
-                          i32.const 1
-                          i32.add
-                          local.tee $11
-                          i32.load8_s
-                          i32.const -48
-                          i32.add
-                          local.tee $8
-                          i32.const 10
-                          i32.ge_u
-                          br_if 5 (;@6;)
-                          local.get $5
-                          local.set $7
-                          local.get $8
-                          local.set $5
-                          br 0 (;@11;)
-                        end
-                      end
-                    end
-                    local.get $11
-                    i32.const 2
-                    i32.add
-                    local.tee $7
-                    i32.load8_s
-                    i32.const -48
-                    i32.add
-                    local.tee $5
-                    i32.const 10
-                    i32.lt_u
-                    if ;; label = @9
-                      local.get $11
-                      i32.load8_s offset=3
-                      i32.const 36
-                      i32.eq
-                      if ;; label = @10
-                        block ;; label = @11
-                          local.get $4
-                          local.get $5
-                          i32.const 2
-                          i32.shl
-                          i32.add
-                          i32.const 10
-                          i32.store
-                          local.get $3
-                          local.get $7
-                          i32.load8_s
-                          i32.const -48
-                          i32.add
-                          i32.const 3
-                          i32.shl
-                          i32.add
-                          i64.load
-                          i32.wrap_i64
-                          local.set $5
-                          local.get $11
-                          i32.const 4
-                          i32.add
-                          local.set $11
-                          br 5 (;@6;)
-                        end
-                      end
-                    end
-                    local.get $17
-                    if ;; label = @9
-                      block ;; label = @10
-                        i32.const -1
-                        local.set $15
-                        br 5 (;@5;)
-                      end
-                    end
-                    local.get $30
-                    if (result i32) ;; label = @9
-                      block (result i32) ;; label = @10
-                        local.get $2
-                        i32.load
-                        i32.const 3
-                        i32.add
-                        i32.const -4
-                        i32.and
-                        local.tee $11
-                        i32.load
-                        local.set $5
-                        local.get $2
-                        local.get $11
-                        i32.const 4
-                        i32.add
-                        i32.store
-                        local.get $7
-                      end
-                    else
-                      block (result i32) ;; label = @10
-                        i32.const 0
-                        local.set $5
-                        local.get $7
-                      end
-                    end
-                    local.set $11
-                  end
-                else
-                  i32.const -1
-                  local.set $5
-                end
-              end
-              local.get $11
-              local.set $7
-              i32.const 0
-              local.set $8
-              loop $label$55 ;; label = @6
-                local.get $7
-                i32.load8_s
-                i32.const -65
-                i32.add
-                local.tee $6
-                i32.const 57
-                i32.gt_u
-                if ;; label = @7
-                  block ;; label = @8
-                    i32.const -1
-                    local.set $15
-                    br 3 (;@5;)
-                  end
-                end
-                local.get $7
-                i32.const 1
-                i32.add
-                local.set $11
-                local.get $8
-                i32.const 58
-                i32.mul
-                i32.const 1177
-                i32.add
-                local.get $6
-                i32.add
-                i32.load8_s
-                local.tee $13
-                i32.const 255
-                i32.and
-                local.tee $6
-                i32.const -1
-                i32.add
-                i32.const 8
-                i32.lt_u
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $11
-                    local.set $7
-                    local.get $6
-                    local.set $8
-                    br 2 (;@6;)
-                  end
-                end
-              end
-              local.get $13
-              i32.const 24
-              i32.shl
-              i32.const 24
-              i32.shr_s
-              i32.eqz
-              if ;; label = @6
-                block ;; label = @7
-                  i32.const -1
-                  local.set $15
-                  br 2 (;@5;)
-                end
-              end
-              local.get $9
-              i32.const -1
-              i32.gt_s
-              local.set $14
-              block $label$59 ;; label = @6
-                block $label$60 ;; label = @7
-                  local.get $13
-                  i32.const 24
-                  i32.shl
-                  i32.const 24
-                  i32.shr_s
-                  i32.const 19
-                  i32.eq
-                  if ;; label = @8
-                    local.get $14
-                    if ;; label = @9
-                      block ;; label = @10
-                        i32.const -1
-                        local.set $15
-                        br 5 (;@5;)
-                      end
-                    else
-                      br 2 (;@7;)
-                    end
-                  else
-                    block ;; label = @9
-                      local.get $14
-                      if ;; label = @10
-                        block ;; label = @11
-                          local.get $4
-                          local.get $9
-                          i32.const 2
-                          i32.shl
-                          i32.add
-                          local.get $6
-                          i32.store
-                          local.get $16
-                          local.get $3
-                          local.get $9
-                          i32.const 3
-                          i32.shl
-                          i32.add
-                          i64.load
-                          i64.store
-                          br 4 (;@7;)
-                        end
-                      end
-                      local.get $30
-                      i32.eqz
-                      if ;; label = @10
-                        block ;; label = @11
-                          i32.const 0
-                          local.set $15
-                          br 6 (;@5;)
-                        end
-                      end
-                      local.get $16
-                      local.get $6
-                      local.get $2
-                      call $22
-                    end
-                  end
-                  br 1 (;@6;)
-                end
-                local.get $30
-                i32.eqz
-                if ;; label = @7
-                  block ;; label = @8
-                    i32.const 0
-                    local.set $10
-                    local.get $11
-                    local.set $1
-                    br 4 (;@4;)
-                  end
-                end
-              end
-              local.get $7
-              i32.load8_s
-              local.tee $7
-              i32.const -33
-              i32.and
-              local.set $9
-              local.get $8
-              i32.const 0
-              i32.ne
-              local.get $7
-              i32.const 15
-              i32.and
-              i32.const 3
-              i32.eq
-              i32.and
-              i32.eqz
-              if ;; label = @6
-                local.get $7
-                local.set $9
-              end
-              local.get $12
-              i32.const -65537
-              i32.and
-              local.set $7
-              local.get $12
-              i32.const 8192
-              i32.and
-              if ;; label = @6
-                local.get $7
-                local.set $12
-              end
-              block $label$70 ;; label = @6
-                block $label$71 ;; label = @7
-                  block $label$72 ;; label = @8
-                    block $label$73 ;; label = @9
-                      block $label$74 ;; label = @10
-                        block $label$75 ;; label = @11
-                          block $label$76 ;; label = @12
-                            block $label$77 ;; label = @13
-                              block $label$78 ;; label = @14
-                                block $label$79 ;; label = @15
-                                  block $label$80 ;; label = @16
-                                    block $label$81 ;; label = @17
-                                      block $label$82 ;; label = @18
-                                        block $label$83 ;; label = @19
-                                          block $label$84 ;; label = @20
-                                            block $label$85 ;; label = @21
-                                              block $label$86 ;; label = @22
-                                                block $label$87 ;; label = @23
-                                                  block $label$88 ;; label = @24
-                                                    block $label$89 ;; label = @25
-                                                      local.get $9
-                                                      i32.const 65
-                                                      i32.sub
-                                                      br_table 11 (;@14;) 12 (;@13;) 9 (;@16;) 12 (;@13;) 11 (;@14;) 11 (;@14;) 11 (;@14;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 10 (;@15;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 2 (;@23;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 11 (;@14;) 12 (;@13;) 6 (;@19;) 4 (;@21;) 11 (;@14;) 11 (;@14;) 11 (;@14;) 12 (;@13;) 4 (;@21;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 7 (;@18;) 0 (;@25;) 3 (;@22;) 1 (;@24;) 12 (;@13;) 12 (;@13;) 8 (;@17;) 12 (;@13;) 5 (;@20;) 12 (;@13;) 12 (;@13;) 2 (;@23;) 12 (;@13;)
-                                                    end
-                                                    block $label$90 ;; label = @25
-                                                      block $label$91 ;; label = @26
-                                                        block $label$92 ;; label = @27
-                                                          block $label$93 ;; label = @28
-                                                            block $label$94 ;; label = @29
-                                                              block $label$95 ;; label = @30
-                                                                block $label$96 ;; label = @31
-                                                                  block $label$97 ;; label = @32
-                                                                    local.get $8
-                                                                    i32.const 255
-                                                                    i32.and
-                                                                    i32.const 24
-                                                                    i32.shl
-                                                                    i32.const 24
-                                                                    i32.shr_s
-                                                                    i32.const 0
-                                                                    i32.sub
-                                                                    br_table 0 (;@32;) 1 (;@31;) 2 (;@30;) 3 (;@29;) 4 (;@28;) 7 (;@25;) 5 (;@27;) 6 (;@26;) 7 (;@25;)
-                                                                  end
-                                                                  local.get $16
-                                                                  i32.load
-                                                                  local.get $15
-                                                                  i32.store
-                                                                  i32.const 0
-                                                                  local.set $10
-                                                                  local.get $11
-                                                                  local.set $1
-                                                                  br 27 (;@4;)
-                                                                end
-                                                                local.get $16
-                                                                i32.load
-                                                                local.get $15
-                                                                i32.store
-                                                                i32.const 0
-                                                                local.set $10
-                                                                local.get $11
-                                                                local.set $1
-                                                                br 26 (;@4;)
-                                                              end
-                                                              local.get $16
-                                                              i32.load
-                                                              local.get $15
-                                                              i64.extend_i32_s
-                                                              i64.store
-                                                              i32.const 0
-                                                              local.set $10
-                                                              local.get $11
-                                                              local.set $1
-                                                              br 25 (;@4;)
-                                                            end
-                                                            local.get $16
-                                                            i32.load
-                                                            local.get $15
-                                                            i32.store16
-                                                            i32.const 0
-                                                            local.set $10
-                                                            local.get $11
-                                                            local.set $1
-                                                            br 24 (;@4;)
-                                                          end
-                                                          local.get $16
-                                                          i32.load
-                                                          local.get $15
-                                                          i32.store8
-                                                          i32.const 0
-                                                          local.set $10
-                                                          local.get $11
-                                                          local.set $1
-                                                          br 23 (;@4;)
-                                                        end
-                                                        local.get $16
-                                                        i32.load
-                                                        local.get $15
-                                                        i32.store
-                                                        i32.const 0
-                                                        local.set $10
-                                                        local.get $11
-                                                        local.set $1
-                                                        br 22 (;@4;)
-                                                      end
-                                                      local.get $16
-                                                      i32.load
-                                                      local.get $15
-                                                      i64.extend_i32_s
-                                                      i64.store
-                                                      i32.const 0
-                                                      local.set $10
-                                                      local.get $11
-                                                      local.set $1
-                                                      br 21 (;@4;)
-                                                    end
-                                                    i32.const 0
-                                                    local.set $10
-                                                    local.get $11
-                                                    local.set $1
-                                                    br 20 (;@4;)
-                                                  end
-                                                  local.get $12
-                                                  i32.const 8
-                                                  i32.or
-                                                  local.set $12
-                                                  local.get $5
-                                                  i32.const 8
-                                                  i32.le_u
-                                                  if ;; label = @24
-                                                    i32.const 8
-                                                    local.set $5
-                                                  end
-                                                  i32.const 120
-                                                  local.set $9
-                                                  br 11 (;@12;)
-                                                end
-                                                br 10 (;@12;)
-                                              end
-                                              local.get $16
-                                              i64.load
-                                              local.tee $50
-                                              i64.const 0
-                                              i64.eq
-                                              if ;; label = @22
-                                                local.get $21
-                                                local.set $7
-                                              else
-                                                block ;; label = @23
-                                                  local.get $21
-                                                  local.set $1
-                                                  loop $label$101 ;; label = @24
-                                                    local.get $1
-                                                    i32.const -1
-                                                    i32.add
-                                                    local.tee $1
-                                                    local.get $50
-                                                    i64.const 7
-                                                    i64.and
-                                                    i64.const 48
-                                                    i64.or
-                                                    i64.store8
-                                                    local.get $50
-                                                    i64.const 3
-                                                    i64.shr_u
-                                                    local.tee $50
-                                                    i64.const 0
-                                                    i64.ne
-                                                    br_if 0 (;@24;)
-                                                    local.get $1
-                                                    local.set $7
-                                                  end
-                                                end
-                                              end
-                                              local.get $12
-                                              i32.const 8
-                                              i32.and
-                                              if ;; label = @22
-                                                block ;; label = @23
-                                                  local.get $38
-                                                  local.get $7
-                                                  i32.sub
-                                                  local.tee $1
-                                                  i32.const 1
-                                                  i32.add
-                                                  local.set $8
-                                                  local.get $5
-                                                  local.get $1
-                                                  i32.le_s
-                                                  if ;; label = @24
-                                                    local.get $8
-                                                    local.set $5
-                                                  end
-                                                  i32.const 0
-                                                  local.set $6
-                                                  i32.const 1657
-                                                  local.set $8
-                                                  br 16 (;@7;)
-                                                end
-                                              else
-                                                block ;; label = @23
-                                                  i32.const 0
-                                                  local.set $6
-                                                  i32.const 1657
-                                                  local.set $8
-                                                  br 16 (;@7;)
-                                                end
-                                              end
-                                            end
-                                            local.get $16
-                                            i64.load
-                                            local.tee $50
-                                            i64.const 0
-                                            i64.lt_s
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                local.get $16
-                                                i64.const 0
-                                                local.get $50
-                                                i64.sub
-                                                local.tee $50
-                                                i64.store
-                                                i32.const 1
-                                                local.set $6
-                                                i32.const 1657
-                                                local.set $8
-                                                br 11 (;@11;)
-                                              end
-                                            end
-                                            local.get $12
-                                            i32.const 2048
-                                            i32.and
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                i32.const 1
-                                                local.set $6
-                                                i32.const 1658
-                                                local.set $8
-                                                br 11 (;@11;)
-                                              end
-                                            else
-                                              block ;; label = @22
-                                                local.get $12
-                                                i32.const 1
-                                                i32.and
-                                                local.tee $1
-                                                local.set $6
-                                                local.get $1
-                                                if (result i32) ;; label = @23
-                                                  i32.const 1659
-                                                else
-                                                  i32.const 1657
-                                                end
-                                                local.set $8
-                                                br 11 (;@11;)
-                                              end
-                                            end
-                                          end
-                                          local.get $16
-                                          i64.load
-                                          local.set $50
-                                          i32.const 0
-                                          local.set $6
-                                          i32.const 1657
-                                          local.set $8
-                                          br 8 (;@11;)
-                                        end
-                                        local.get $39
-                                        local.get $16
-                                        i64.load
-                                        i64.store8
-                                        local.get $39
-                                        local.set $1
-                                        local.get $7
-                                        local.set $12
-                                        i32.const 1
-                                        local.set $7
-                                        i32.const 0
-                                        local.set $6
-                                        i32.const 1657
-                                        local.set $8
-                                        local.get $21
-                                        local.set $5
-                                        br 12 (;@6;)
-                                      end
-                                      call $12
-                                      i32.load
-                                      call $24
-                                      local.set $1
-                                      br 7 (;@10;)
-                                    end
-                                    local.get $16
-                                    i32.load
-                                    local.tee $1
-                                    i32.eqz
-                                    if ;; label = @17
-                                      i32.const 1667
-                                      local.set $1
-                                    end
-                                    br 6 (;@10;)
-                                  end
-                                  local.get $37
-                                  local.get $16
-                                  i64.load
-                                  i64.store32
-                                  local.get $42
-                                  i32.const 0
-                                  i32.store
-                                  local.get $16
-                                  local.get $37
-                                  i32.store
-                                  local.get $37
-                                  local.set $7
-                                  i32.const -1
-                                  local.set $6
-                                  br 6 (;@9;)
-                                end
-                                local.get $16
-                                i32.load
-                                local.set $7
-                                local.get $5
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $5
-                                    local.set $6
-                                    br 7 (;@9;)
-                                  end
-                                else
-                                  block ;; label = @16
-                                    local.get $0
-                                    i32.const 32
-                                    local.get $10
-                                    i32.const 0
-                                    local.get $12
-                                    call $25
-                                    i32.const 0
-                                    local.set $1
-                                    br 8 (;@8;)
-                                  end
-                                end
-                              end
-                              local.get $16
-                              f64.load
-                              local.set $52
-                              local.get $20
-                              i32.const 0
-                              i32.store
-                              local.get $52
-                              i64.reinterpret_f64
-                              i64.const 0
-                              i64.lt_s
-                              if (result i32) ;; label = @14
-                                block (result i32) ;; label = @15
-                                  i32.const 1
-                                  local.set $24
-                                  local.get $52
-                                  f64.neg
-                                  local.set $52
-                                  i32.const 1674
-                                end
-                              else
-                                block (result i32) ;; label = @15
-                                  local.get $12
-                                  i32.const 1
-                                  i32.and
-                                  local.set $1
-                                  local.get $12
-                                  i32.const 2048
-                                  i32.and
-                                  if (result i32) ;; label = @16
-                                    block (result i32) ;; label = @17
-                                      i32.const 1
-                                      local.set $24
-                                      i32.const 1677
-                                    end
-                                  else
-                                    block (result i32) ;; label = @17
-                                      local.get $1
-                                      local.set $24
-                                      local.get $1
-                                      if (result i32) ;; label = @18
-                                        i32.const 1680
-                                      else
-                                        i32.const 1675
-                                      end
-                                    end
-                                  end
-                                end
-                              end
-                              local.set $26
-                              block $label$119 ;; label = @14
-                                local.get $52
-                                i64.reinterpret_f64
-                                i64.const 9218868437227405312
-                                i64.and
-                                i64.const 9218868437227405312
-                                i64.lt_u
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $52
-                                    local.get $20
-                                    call $27
-                                    f64.const 0x1p+1 (;=2;)
-                                    f64.mul
-                                    local.tee $52
-                                    f64.const 0x0p+0 (;=0;)
-                                    f64.ne
-                                    local.tee $1
-                                    if ;; label = @17
-                                      local.get $20
-                                      local.get $20
-                                      i32.load
-                                      i32.const -1
-                                      i32.add
-                                      i32.store
-                                    end
-                                    local.get $9
-                                    i32.const 32
-                                    i32.or
-                                    local.tee $22
-                                    i32.const 97
-                                    i32.eq
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        local.get $26
-                                        i32.const 9
-                                        i32.add
-                                        local.set $1
-                                        local.get $9
-                                        i32.const 32
-                                        i32.and
-                                        local.tee $6
-                                        if ;; label = @19
-                                          local.get $1
-                                          local.set $26
-                                        end
-                                        local.get $5
-                                        i32.const 11
-                                        i32.gt_u
-                                        i32.const 12
-                                        local.get $5
-                                        i32.sub
-                                        local.tee $1
-                                        i32.eqz
-                                        i32.or
-                                        i32.eqz
-                                        if ;; label = @19
-                                          block ;; label = @20
-                                            f64.const 0x1p+3 (;=8;)
-                                            local.set $53
-                                            loop $label$125 ;; label = @21
-                                              local.get $53
-                                              f64.const 0x1p+4 (;=16;)
-                                              f64.mul
-                                              local.set $53
-                                              local.get $1
-                                              i32.const -1
-                                              i32.add
-                                              local.tee $1
-                                              br_if 0 (;@21;)
-                                            end
-                                            local.get $26
-                                            i32.load8_s
-                                            i32.const 45
-                                            i32.eq
-                                            if (result f64) ;; label = @21
-                                              local.get $53
-                                              local.get $52
-                                              f64.neg
-                                              local.get $53
-                                              f64.sub
-                                              f64.add
-                                              f64.neg
-                                            else
-                                              local.get $52
-                                              local.get $53
-                                              f64.add
-                                              local.get $53
-                                              f64.sub
-                                            end
-                                            local.set $52
-                                          end
-                                        end
-                                        i32.const 0
-                                        local.get $20
-                                        i32.load
-                                        local.tee $7
-                                        i32.sub
-                                        local.set $1
-                                        local.get $7
-                                        i32.const 0
-                                        i32.lt_s
-                                        if (result i32) ;; label = @19
-                                          local.get $1
-                                        else
-                                          local.get $7
-                                        end
-                                        i64.extend_i32_s
-                                        local.get $33
-                                        call $23
-                                        local.tee $1
-                                        local.get $33
-                                        i32.eq
-                                        if ;; label = @19
-                                          block ;; label = @20
-                                            local.get $40
-                                            i32.const 48
-                                            i32.store8
-                                            local.get $40
-                                            local.set $1
-                                          end
-                                        end
-                                        local.get $24
-                                        i32.const 2
-                                        i32.or
-                                        local.set $13
-                                        local.get $1
-                                        i32.const -1
-                                        i32.add
-                                        local.get $7
-                                        i32.const 31
-                                        i32.shr_s
-                                        i32.const 2
-                                        i32.and
-                                        i32.const 43
-                                        i32.add
-                                        i32.store8
-                                        local.get $1
-                                        i32.const -2
-                                        i32.add
-                                        local.tee $8
-                                        local.get $9
-                                        i32.const 15
-                                        i32.add
-                                        i32.store8
-                                        local.get $5
-                                        i32.const 1
-                                        i32.lt_s
-                                        local.set $9
-                                        local.get $12
-                                        i32.const 8
-                                        i32.and
-                                        i32.eqz
-                                        local.set $14
-                                        local.get $19
-                                        local.set $1
-                                        loop $label$131 ;; label = @19
-                                          local.get $1
-                                          local.get $52
-                                          i32.trunc_f64_s
-                                          local.tee $7
-                                          i32.const 1641
-                                          i32.add
-                                          i32.load8_u
-                                          local.get $6
-                                          i32.or
-                                          i32.store8
-                                          local.get $52
-                                          local.get $7
-                                          f64.convert_i32_s
-                                          f64.sub
-                                          f64.const 0x1p+4 (;=16;)
-                                          f64.mul
-                                          local.set $52
-                                          block $label$132 (result i32) ;; label = @20
-                                            local.get $1
-                                            i32.const 1
-                                            i32.add
-                                            local.tee $7
-                                            local.get $27
-                                            i32.sub
-                                            i32.const 1
-                                            i32.eq
-                                            if (result i32) ;; label = @21
-                                              block (result i32) ;; label = @22
-                                                local.get $7
-                                                local.get $14
-                                                local.get $9
-                                                local.get $52
-                                                f64.const 0x0p+0 (;=0;)
-                                                f64.eq
-                                                i32.and
-                                                i32.and
-                                                br_if 2 (;@20;)
-                                                drop
-                                                local.get $7
-                                                i32.const 46
-                                                i32.store8
-                                                local.get $1
-                                                i32.const 2
-                                                i32.add
-                                              end
-                                            else
-                                              local.get $7
-                                            end
-                                          end
-                                          local.set $1
-                                          local.get $52
-                                          f64.const 0x0p+0 (;=0;)
-                                          f64.ne
-                                          br_if 0 (;@19;)
-                                        end
-                                        local.get $46
-                                        local.get $5
-                                        i32.add
-                                        local.get $8
-                                        local.tee $7
-                                        i32.sub
-                                        local.set $6
-                                        local.get $44
-                                        local.get $7
-                                        i32.sub
-                                        local.get $1
-                                        i32.add
-                                        local.set $9
-                                        local.get $0
-                                        i32.const 32
-                                        local.get $10
-                                        local.get $5
-                                        i32.const 0
-                                        i32.ne
-                                        local.get $45
-                                        local.get $1
-                                        i32.add
-                                        local.get $5
-                                        i32.lt_s
-                                        i32.and
-                                        if (result i32) ;; label = @19
-                                          local.get $6
-                                        else
-                                          local.get $9
-                                          local.tee $6
-                                        end
-                                        local.get $13
-                                        i32.add
-                                        local.tee $5
-                                        local.get $12
-                                        call $25
-                                        local.get $0
-                                        i32.load
-                                        i32.const 32
-                                        i32.and
-                                        i32.eqz
-                                        if ;; label = @19
-                                          local.get $26
-                                          local.get $13
-                                          local.get $0
-                                          call $21
-                                          drop
-                                        end
-                                        local.get $0
-                                        i32.const 48
-                                        local.get $10
-                                        local.get $5
-                                        local.get $12
-                                        i32.const 65536
-                                        i32.xor
-                                        call $25
-                                        local.get $1
-                                        local.get $27
-                                        i32.sub
-                                        local.set $1
-                                        local.get $0
-                                        i32.load
-                                        i32.const 32
-                                        i32.and
-                                        i32.eqz
-                                        if ;; label = @19
-                                          local.get $19
-                                          local.get $1
-                                          local.get $0
-                                          call $21
-                                          drop
-                                        end
-                                        local.get $0
-                                        i32.const 48
-                                        local.get $6
-                                        local.get $1
-                                        local.get $28
-                                        local.get $7
-                                        i32.sub
-                                        local.tee $1
-                                        i32.add
-                                        i32.sub
-                                        i32.const 0
-                                        i32.const 0
-                                        call $25
-                                        local.get $0
-                                        i32.load
-                                        i32.const 32
-                                        i32.and
-                                        i32.eqz
-                                        if ;; label = @19
-                                          local.get $8
-                                          local.get $1
-                                          local.get $0
-                                          call $21
-                                          drop
-                                        end
-                                        local.get $0
-                                        i32.const 32
-                                        local.get $10
-                                        local.get $5
-                                        local.get $12
-                                        i32.const 8192
-                                        i32.xor
-                                        call $25
-                                        local.get $5
-                                        local.get $10
-                                        i32.ge_s
-                                        if ;; label = @19
-                                          local.get $5
-                                          local.set $10
-                                        end
-                                        br 4 (;@14;)
-                                      end
-                                    end
-                                    local.get $1
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        local.get $20
-                                        local.get $20
-                                        i32.load
-                                        i32.const -28
-                                        i32.add
-                                        local.tee $6
-                                        i32.store
-                                        local.get $52
-                                        f64.const 0x1p+28 (;=268435456;)
-                                        f64.mul
-                                        local.set $52
-                                      end
-                                    else
-                                      local.get $20
-                                      i32.load
-                                      local.set $6
-                                    end
-                                    local.get $6
-                                    i32.const 0
-                                    i32.lt_s
-                                    if (result i32) ;; label = @17
-                                      local.get $47
-                                    else
-                                      local.get $48
-                                    end
-                                    local.tee $7
-                                    local.set $8
-                                    loop $label$145 ;; label = @17
-                                      local.get $8
-                                      local.get $52
-                                      i32.trunc_f64_s
-                                      local.tee $1
-                                      i32.store
-                                      local.get $8
-                                      i32.const 4
-                                      i32.add
-                                      local.set $8
-                                      local.get $52
-                                      local.get $1
-                                      f64.convert_i32_u
-                                      f64.sub
-                                      f64.const 0x1.dcd65p+29 (;=1000000000;)
-                                      f64.mul
-                                      local.tee $52
-                                      f64.const 0x0p+0 (;=0;)
-                                      f64.ne
-                                      br_if 0 (;@17;)
-                                    end
-                                    local.get $6
-                                    i32.const 0
-                                    i32.gt_s
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        local.get $7
-                                        local.set $1
-                                        loop $label$147 ;; label = @19
-                                          local.get $6
-                                          i32.const 29
-                                          i32.gt_s
-                                          if (result i32) ;; label = @20
-                                            i32.const 29
-                                          else
-                                            local.get $6
-                                          end
-                                          local.set $14
-                                          block $label$150 ;; label = @20
-                                            local.get $8
-                                            i32.const -4
-                                            i32.add
-                                            local.tee $6
-                                            local.get $1
-                                            i32.ge_u
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                local.get $14
-                                                i64.extend_i32_u
-                                                local.set $50
-                                                i32.const 0
-                                                local.set $13
-                                                loop $label$152 ;; label = @23
-                                                  local.get $6
-                                                  local.get $6
-                                                  i32.load
-                                                  i64.extend_i32_u
-                                                  local.get $50
-                                                  i64.shl
-                                                  local.get $13
-                                                  i64.extend_i32_u
-                                                  i64.add
-                                                  local.tee $51
-                                                  i64.const 1000000000
-                                                  i64.rem_u
-                                                  i64.store32
-                                                  local.get $51
-                                                  i64.const 1000000000
-                                                  i64.div_u
-                                                  i32.wrap_i64
-                                                  local.set $13
-                                                  local.get $6
-                                                  i32.const -4
-                                                  i32.add
-                                                  local.tee $6
-                                                  local.get $1
-                                                  i32.ge_u
-                                                  br_if 0 (;@23;)
-                                                end
-                                                local.get $13
-                                                i32.eqz
-                                                br_if 2 (;@20;)
-                                                local.get $1
-                                                i32.const -4
-                                                i32.add
-                                                local.tee $1
-                                                local.get $13
-                                                i32.store
-                                              end
-                                            end
-                                          end
-                                          loop $label$153 ;; label = @20
-                                            local.get $8
-                                            local.get $1
-                                            i32.gt_u
-                                            if ;; label = @21
-                                              local.get $8
-                                              i32.const -4
-                                              i32.add
-                                              local.tee $6
-                                              i32.load
-                                              i32.eqz
-                                              if ;; label = @22
-                                                block ;; label = @23
-                                                  local.get $6
-                                                  local.set $8
-                                                  br 3 (;@20;)
-                                                end
-                                              end
-                                            end
-                                          end
-                                          local.get $20
-                                          local.get $20
-                                          i32.load
-                                          local.get $14
-                                          i32.sub
-                                          local.tee $6
-                                          i32.store
-                                          local.get $6
-                                          i32.const 0
-                                          i32.gt_s
-                                          br_if 0 (;@19;)
-                                        end
-                                      end
-                                    else
-                                      local.get $7
-                                      local.set $1
-                                    end
-                                    local.get $5
-                                    i32.const 0
-                                    i32.lt_s
-                                    if (result i32) ;; label = @17
-                                      i32.const 6
-                                    else
-                                      local.get $5
-                                    end
-                                    local.set $18
-                                    local.get $6
-                                    i32.const 0
-                                    i32.lt_s
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        local.get $18
-                                        i32.const 25
-                                        i32.add
-                                        i32.const 9
-                                        i32.div_s
-                                        i32.const 1
-                                        i32.add
-                                        local.set $14
-                                        local.get $22
-                                        i32.const 102
-                                        i32.eq
-                                        local.set $25
-                                        local.get $8
-                                        local.set $5
-                                        loop $label$160 ;; label = @19
-                                          i32.const 0
-                                          local.get $6
-                                          i32.sub
-                                          local.tee $13
-                                          i32.const 9
-                                          i32.gt_s
-                                          if ;; label = @20
-                                            i32.const 9
-                                            local.set $13
-                                          end
-                                          block $label$162 ;; label = @20
-                                            local.get $1
-                                            local.get $5
-                                            i32.lt_u
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                i32.const 1
-                                                local.get $13
-                                                i32.shl
-                                                i32.const -1
-                                                i32.add
-                                                local.set $29
-                                                i32.const 1000000000
-                                                local.get $13
-                                                i32.shr_u
-                                                local.set $35
-                                                i32.const 0
-                                                local.set $6
-                                                local.get $1
-                                                local.set $8
-                                                loop $label$164 ;; label = @23
-                                                  local.get $8
-                                                  local.get $8
-                                                  i32.load
-                                                  local.tee $32
-                                                  local.get $13
-                                                  i32.shr_u
-                                                  local.get $6
-                                                  i32.add
-                                                  i32.store
-                                                  local.get $32
-                                                  local.get $29
-                                                  i32.and
-                                                  local.get $35
-                                                  i32.mul
-                                                  local.set $6
-                                                  local.get $8
-                                                  i32.const 4
-                                                  i32.add
-                                                  local.tee $8
-                                                  local.get $5
-                                                  i32.lt_u
-                                                  br_if 0 (;@23;)
-                                                end
-                                                local.get $1
-                                                i32.const 4
-                                                i32.add
-                                                local.set $8
-                                                local.get $1
-                                                i32.load
-                                                i32.eqz
-                                                if ;; label = @23
-                                                  local.get $8
-                                                  local.set $1
-                                                end
-                                                local.get $6
-                                                i32.eqz
-                                                br_if 2 (;@20;)
-                                                local.get $5
-                                                local.get $6
-                                                i32.store
-                                                local.get $5
-                                                i32.const 4
-                                                i32.add
-                                                local.set $5
-                                              end
-                                            else
-                                              block ;; label = @22
-                                                local.get $1
-                                                i32.const 4
-                                                i32.add
-                                                local.set $8
-                                                local.get $1
-                                                i32.load
-                                                i32.eqz
-                                                if ;; label = @23
-                                                  local.get $8
-                                                  local.set $1
-                                                end
-                                              end
-                                            end
-                                          end
-                                          local.get $25
-                                          if (result i32) ;; label = @20
-                                            local.get $7
-                                          else
-                                            local.get $1
-                                          end
-                                          local.tee $8
-                                          local.get $14
-                                          i32.const 2
-                                          i32.shl
-                                          i32.add
-                                          local.set $6
-                                          local.get $5
-                                          local.get $8
-                                          i32.sub
-                                          i32.const 2
-                                          i32.shr_s
-                                          local.get $14
-                                          i32.gt_s
-                                          if ;; label = @20
-                                            local.get $6
-                                            local.set $5
-                                          end
-                                          local.get $20
-                                          local.get $20
-                                          i32.load
-                                          local.get $13
-                                          i32.add
-                                          local.tee $6
-                                          i32.store
-                                          local.get $6
-                                          i32.const 0
-                                          i32.lt_s
-                                          br_if 0 (;@19;)
-                                          local.get $5
-                                          local.set $13
-                                        end
-                                      end
-                                    else
-                                      local.get $8
-                                      local.set $13
-                                    end
-                                    local.get $7
-                                    local.set $25
-                                    block $label$172 ;; label = @17
-                                      local.get $1
-                                      local.get $13
-                                      i32.lt_u
-                                      if ;; label = @18
-                                        block ;; label = @19
-                                          local.get $25
-                                          local.get $1
-                                          i32.sub
-                                          i32.const 2
-                                          i32.shr_s
-                                          i32.const 9
-                                          i32.mul
-                                          local.set $5
-                                          local.get $1
-                                          i32.load
-                                          local.tee $6
-                                          i32.const 10
-                                          i32.lt_u
-                                          br_if 2 (;@17;)
-                                          i32.const 10
-                                          local.set $8
-                                          loop $label$174 ;; label = @20
-                                            local.get $5
-                                            i32.const 1
-                                            i32.add
-                                            local.set $5
-                                            local.get $6
-                                            local.get $8
-                                            i32.const 10
-                                            i32.mul
-                                            local.tee $8
-                                            i32.ge_u
-                                            br_if 0 (;@20;)
-                                          end
-                                        end
-                                      else
-                                        i32.const 0
-                                        local.set $5
-                                      end
-                                    end
-                                    local.get $22
-                                    i32.const 103
-                                    i32.eq
-                                    local.set $29
-                                    local.get $18
-                                    i32.const 0
-                                    i32.ne
-                                    local.set $35
-                                    local.get $18
-                                    local.get $22
-                                    i32.const 102
-                                    i32.ne
-                                    if (result i32) ;; label = @17
-                                      local.get $5
-                                    else
-                                      i32.const 0
-                                    end
-                                    i32.sub
-                                    local.get $35
-                                    local.get $29
-                                    i32.and
-                                    i32.const 31
-                                    i32.shl
-                                    i32.const 31
-                                    i32.shr_s
-                                    i32.add
-                                    local.tee $8
-                                    local.get $13
-                                    local.get $25
-                                    i32.sub
-                                    i32.const 2
-                                    i32.shr_s
-                                    i32.const 9
-                                    i32.mul
-                                    i32.const -9
-                                    i32.add
-                                    i32.lt_s
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        local.get $8
-                                        i32.const 9216
-                                        i32.add
-                                        local.tee $14
-                                        i32.const 9
-                                        i32.rem_s
-                                        i32.const 1
-                                        i32.add
-                                        local.tee $8
-                                        i32.const 9
-                                        i32.lt_s
-                                        if ;; label = @19
-                                          block ;; label = @20
-                                            i32.const 10
-                                            local.set $6
-                                            loop $label$180 ;; label = @21
-                                              local.get $6
-                                              i32.const 10
-                                              i32.mul
-                                              local.set $6
-                                              local.get $8
-                                              i32.const 1
-                                              i32.add
-                                              local.tee $8
-                                              i32.const 9
-                                              i32.ne
-                                              br_if 0 (;@21;)
-                                            end
-                                          end
-                                        else
-                                          i32.const 10
-                                          local.set $6
-                                        end
-                                        local.get $7
-                                        i32.const 4
-                                        i32.add
-                                        local.get $14
-                                        i32.const 9
-                                        i32.div_s
-                                        i32.const -1024
-                                        i32.add
-                                        i32.const 2
-                                        i32.shl
-                                        i32.add
-                                        local.tee $8
-                                        i32.load
-                                        local.tee $22
-                                        local.get $6
-                                        i32.rem_u
-                                        local.set $14
-                                        block $label$182 ;; label = @19
-                                          local.get $8
-                                          i32.const 4
-                                          i32.add
-                                          local.get $13
-                                          i32.eq
-                                          local.tee $32
-                                          local.get $14
-                                          i32.eqz
-                                          i32.and
-                                          i32.eqz
-                                          if ;; label = @20
-                                            block ;; label = @21
-                                              local.get $14
-                                              local.get $6
-                                              i32.const 2
-                                              i32.div_s
-                                              local.tee $49
-                                              i32.lt_u
-                                              if (result f64) ;; label = @22
-                                                f64.const 0x1p-1 (;=0.5;)
-                                              else
-                                                local.get $32
-                                                local.get $14
-                                                local.get $49
-                                                i32.eq
-                                                i32.and
-                                                if (result f64) ;; label = @23
-                                                  f64.const 0x1p+0 (;=1;)
-                                                else
-                                                  f64.const 0x1.8p+0 (;=1.5;)
-                                                end
-                                              end
-                                              local.set $52
-                                              local.get $22
-                                              local.get $6
-                                              i32.div_u
-                                              i32.const 1
-                                              i32.and
-                                              if (result f64) ;; label = @22
-                                                f64.const 0x1.0000000000001p+53 (;=9007199254740994;)
-                                              else
-                                                f64.const 0x1p+53 (;=9007199254740992;)
-                                              end
-                                              local.set $53
-                                              block $label$190 ;; label = @22
-                                                local.get $24
-                                                if ;; label = @23
-                                                  block ;; label = @24
-                                                    local.get $26
-                                                    i32.load8_s
-                                                    i32.const 45
-                                                    i32.ne
-                                                    br_if 2 (;@22;)
-                                                    local.get $53
-                                                    f64.neg
-                                                    local.set $53
-                                                    local.get $52
-                                                    f64.neg
-                                                    local.set $52
-                                                  end
-                                                end
-                                              end
-                                              local.get $8
-                                              local.get $22
-                                              local.get $14
-                                              i32.sub
-                                              local.tee $14
-                                              i32.store
-                                              local.get $53
-                                              local.get $52
-                                              f64.add
-                                              local.get $53
-                                              f64.eq
-                                              br_if 2 (;@19;)
-                                              local.get $8
-                                              local.get $14
-                                              local.get $6
-                                              i32.add
-                                              local.tee $5
-                                              i32.store
-                                              local.get $5
-                                              i32.const 999999999
-                                              i32.gt_u
-                                              if ;; label = @22
-                                                loop $label$193 ;; label = @23
-                                                  local.get $8
-                                                  i32.const 0
-                                                  i32.store
-                                                  local.get $8
-                                                  i32.const -4
-                                                  i32.add
-                                                  local.tee $8
-                                                  local.get $1
-                                                  i32.lt_u
-                                                  if ;; label = @24
-                                                    local.get $1
-                                                    i32.const -4
-                                                    i32.add
-                                                    local.tee $1
-                                                    i32.const 0
-                                                    i32.store
-                                                  end
-                                                  local.get $8
-                                                  local.get $8
-                                                  i32.load
-                                                  i32.const 1
-                                                  i32.add
-                                                  local.tee $5
-                                                  i32.store
-                                                  local.get $5
-                                                  i32.const 999999999
-                                                  i32.gt_u
-                                                  br_if 0 (;@23;)
-                                                end
-                                              end
-                                              local.get $25
-                                              local.get $1
-                                              i32.sub
-                                              i32.const 2
-                                              i32.shr_s
-                                              i32.const 9
-                                              i32.mul
-                                              local.set $5
-                                              local.get $1
-                                              i32.load
-                                              local.tee $14
-                                              i32.const 10
-                                              i32.lt_u
-                                              br_if 2 (;@19;)
-                                              i32.const 10
-                                              local.set $6
-                                              loop $label$195 ;; label = @22
-                                                local.get $5
-                                                i32.const 1
-                                                i32.add
-                                                local.set $5
-                                                local.get $14
-                                                local.get $6
-                                                i32.const 10
-                                                i32.mul
-                                                local.tee $6
-                                                i32.ge_u
-                                                br_if 0 (;@22;)
-                                              end
-                                            end
-                                          end
-                                        end
-                                        local.get $1
-                                        local.set $14
-                                        local.get $5
-                                        local.set $6
-                                        local.get $13
-                                        local.get $8
-                                        i32.const 4
-                                        i32.add
-                                        local.tee $8
-                                        i32.le_u
-                                        if ;; label = @19
-                                          local.get $13
-                                          local.set $8
-                                        end
-                                      end
-                                    else
-                                      block ;; label = @18
-                                        local.get $1
-                                        local.set $14
-                                        local.get $5
-                                        local.set $6
-                                        local.get $13
-                                        local.set $8
-                                      end
-                                    end
-                                    i32.const 0
-                                    local.get $6
-                                    i32.sub
-                                    local.set $32
-                                    loop $label$198 ;; label = @17
-                                      block $label$199 ;; label = @18
-                                        local.get $8
-                                        local.get $14
-                                        i32.le_u
-                                        if ;; label = @19
-                                          block ;; label = @20
-                                            i32.const 0
-                                            local.set $22
-                                            br 2 (;@18;)
-                                          end
-                                        end
-                                        local.get $8
-                                        i32.const -4
-                                        i32.add
-                                        local.tee $1
-                                        i32.load
-                                        if ;; label = @19
-                                          i32.const 1
-                                          local.set $22
-                                        else
-                                          block ;; label = @20
-                                            local.get $1
-                                            local.set $8
-                                            br 3 (;@17;)
-                                          end
-                                        end
-                                      end
-                                    end
-                                    block $label$203 ;; label = @17
-                                      local.get $29
-                                      if ;; label = @18
-                                        block ;; label = @19
-                                          local.get $35
-                                          i32.const 1
-                                          i32.and
-                                          i32.const 1
-                                          i32.xor
-                                          local.get $18
-                                          i32.add
-                                          local.tee $1
-                                          local.get $6
-                                          i32.gt_s
-                                          local.get $6
-                                          i32.const -5
-                                          i32.gt_s
-                                          i32.and
-                                          if (result i32) ;; label = @20
-                                            block (result i32) ;; label = @21
-                                              local.get $9
-                                              i32.const -1
-                                              i32.add
-                                              local.set $5
-                                              local.get $1
-                                              i32.const -1
-                                              i32.add
-                                              local.get $6
-                                              i32.sub
-                                            end
-                                          else
-                                            block (result i32) ;; label = @21
-                                              local.get $9
-                                              i32.const -2
-                                              i32.add
-                                              local.set $5
-                                              local.get $1
-                                              i32.const -1
-                                              i32.add
-                                            end
-                                          end
-                                          local.set $1
-                                          local.get $12
-                                          i32.const 8
-                                          i32.and
-                                          local.tee $13
-                                          br_if 2 (;@17;)
-                                          block $label$207 ;; label = @20
-                                            local.get $22
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                local.get $8
-                                                i32.const -4
-                                                i32.add
-                                                i32.load
-                                                local.tee $18
-                                                i32.eqz
-                                                if ;; label = @23
-                                                  block ;; label = @24
-                                                    i32.const 9
-                                                    local.set $9
-                                                    br 4 (;@20;)
-                                                  end
-                                                end
-                                                local.get $18
-                                                i32.const 10
-                                                i32.rem_u
-                                                if ;; label = @23
-                                                  block ;; label = @24
-                                                    i32.const 0
-                                                    local.set $9
-                                                    br 4 (;@20;)
-                                                  end
-                                                else
-                                                  block ;; label = @24
-                                                    i32.const 10
-                                                    local.set $13
-                                                    i32.const 0
-                                                    local.set $9
-                                                  end
-                                                end
-                                                loop $label$212 ;; label = @23
-                                                  local.get $9
-                                                  i32.const 1
-                                                  i32.add
-                                                  local.set $9
-                                                  local.get $18
-                                                  local.get $13
-                                                  i32.const 10
-                                                  i32.mul
-                                                  local.tee $13
-                                                  i32.rem_u
-                                                  i32.eqz
-                                                  br_if 0 (;@23;)
-                                                end
-                                              end
-                                            else
-                                              i32.const 9
-                                              local.set $9
-                                            end
-                                          end
-                                          local.get $8
-                                          local.get $25
-                                          i32.sub
-                                          i32.const 2
-                                          i32.shr_s
-                                          i32.const 9
-                                          i32.mul
-                                          i32.const -9
-                                          i32.add
-                                          local.set $18
-                                          local.get $5
-                                          i32.const 32
-                                          i32.or
-                                          i32.const 102
-                                          i32.eq
-                                          if ;; label = @20
-                                            block ;; label = @21
-                                              i32.const 0
-                                              local.set $13
-                                              local.get $1
-                                              local.get $18
-                                              local.get $9
-                                              i32.sub
-                                              local.tee $9
-                                              i32.const 0
-                                              i32.lt_s
-                                              if (result i32) ;; label = @22
-                                                i32.const 0
-                                                local.tee $9
-                                              else
-                                                local.get $9
-                                              end
-                                              i32.ge_s
-                                              if ;; label = @22
-                                                local.get $9
-                                                local.set $1
-                                              end
-                                            end
-                                          else
-                                            block ;; label = @21
-                                              i32.const 0
-                                              local.set $13
-                                              local.get $1
-                                              local.get $18
-                                              local.get $6
-                                              i32.add
-                                              local.get $9
-                                              i32.sub
-                                              local.tee $9
-                                              i32.const 0
-                                              i32.lt_s
-                                              if (result i32) ;; label = @22
-                                                i32.const 0
-                                                local.tee $9
-                                              else
-                                                local.get $9
-                                              end
-                                              i32.ge_s
-                                              if ;; label = @22
-                                                local.get $9
-                                                local.set $1
-                                              end
-                                            end
-                                          end
-                                        end
-                                      else
-                                        block ;; label = @19
-                                          local.get $12
-                                          i32.const 8
-                                          i32.and
-                                          local.set $13
-                                          local.get $18
-                                          local.set $1
-                                          local.get $9
-                                          local.set $5
-                                        end
-                                      end
-                                    end
-                                    local.get $5
-                                    i32.const 32
-                                    i32.or
-                                    i32.const 102
-                                    i32.eq
-                                    local.tee $25
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        i32.const 0
-                                        local.set $9
-                                        local.get $6
-                                        i32.const 0
-                                        i32.le_s
-                                        if ;; label = @19
-                                          i32.const 0
-                                          local.set $6
-                                        end
-                                      end
-                                    else
-                                      block ;; label = @18
-                                        local.get $28
-                                        local.get $6
-                                        i32.const 0
-                                        i32.lt_s
-                                        if (result i32) ;; label = @19
-                                          local.get $32
-                                        else
-                                          local.get $6
-                                        end
-                                        i64.extend_i32_s
-                                        local.get $33
-                                        call $23
-                                        local.tee $9
-                                        i32.sub
-                                        i32.const 2
-                                        i32.lt_s
-                                        if ;; label = @19
-                                          loop $label$229 ;; label = @20
-                                            local.get $9
-                                            i32.const -1
-                                            i32.add
-                                            local.tee $9
-                                            i32.const 48
-                                            i32.store8
-                                            local.get $28
-                                            local.get $9
-                                            i32.sub
-                                            i32.const 2
-                                            i32.lt_s
-                                            br_if 0 (;@20;)
-                                          end
-                                        end
-                                        local.get $9
-                                        i32.const -1
-                                        i32.add
-                                        local.get $6
-                                        i32.const 31
-                                        i32.shr_s
-                                        i32.const 2
-                                        i32.and
-                                        i32.const 43
-                                        i32.add
-                                        i32.store8
-                                        local.get $9
-                                        i32.const -2
-                                        i32.add
-                                        local.tee $6
-                                        local.get $5
-                                        i32.store8
-                                        local.get $6
-                                        local.set $9
-                                        local.get $28
-                                        local.get $6
-                                        i32.sub
-                                        local.set $6
-                                      end
-                                    end
-                                    local.get $0
-                                    i32.const 32
-                                    local.get $10
-                                    local.get $24
-                                    i32.const 1
-                                    i32.add
-                                    local.get $1
-                                    i32.add
-                                    local.get $1
-                                    local.get $13
-                                    i32.or
-                                    local.tee $29
-                                    i32.const 0
-                                    i32.ne
-                                    i32.add
-                                    local.get $6
-                                    i32.add
-                                    local.tee $18
-                                    local.get $12
-                                    call $25
-                                    local.get $0
-                                    i32.load
-                                    i32.const 32
-                                    i32.and
-                                    i32.eqz
-                                    if ;; label = @17
-                                      local.get $26
-                                      local.get $24
-                                      local.get $0
-                                      call $21
-                                      drop
-                                    end
-                                    local.get $0
-                                    i32.const 48
-                                    local.get $10
-                                    local.get $18
-                                    local.get $12
-                                    i32.const 65536
-                                    i32.xor
-                                    call $25
-                                    block $label$231 ;; label = @17
-                                      local.get $25
-                                      if ;; label = @18
-                                        block ;; label = @19
-                                          local.get $14
-                                          local.get $7
-                                          i32.gt_u
-                                          if (result i32) ;; label = @20
-                                            local.get $7
-                                          else
-                                            local.get $14
-                                          end
-                                          local.tee $9
-                                          local.set $6
-                                          loop $label$235 ;; label = @20
-                                            local.get $6
-                                            i32.load
-                                            i64.extend_i32_u
-                                            local.get $31
-                                            call $23
-                                            local.set $5
-                                            block $label$236 ;; label = @21
-                                              local.get $6
-                                              local.get $9
-                                              i32.eq
-                                              if ;; label = @22
-                                                block ;; label = @23
-                                                  local.get $5
-                                                  local.get $31
-                                                  i32.ne
-                                                  br_if 2 (;@21;)
-                                                  local.get $34
-                                                  i32.const 48
-                                                  i32.store8
-                                                  local.get $34
-                                                  local.set $5
-                                                end
-                                              else
-                                                block ;; label = @23
-                                                  local.get $5
-                                                  local.get $19
-                                                  i32.le_u
-                                                  br_if 2 (;@21;)
-                                                  local.get $19
-                                                  i32.const 48
-                                                  local.get $5
-                                                  local.get $27
-                                                  i32.sub
-                                                  call $39
-                                                  drop
-                                                  loop $label$239 ;; label = @24
-                                                    local.get $5
-                                                    i32.const -1
-                                                    i32.add
-                                                    local.tee $5
-                                                    local.get $19
-                                                    i32.gt_u
-                                                    br_if 0 (;@24;)
-                                                  end
-                                                end
-                                              end
-                                            end
-                                            local.get $0
-                                            i32.load
-                                            i32.const 32
-                                            i32.and
-                                            i32.eqz
-                                            if ;; label = @21
-                                              local.get $5
-                                              local.get $41
-                                              local.get $5
-                                              i32.sub
-                                              local.get $0
-                                              call $21
-                                              drop
-                                            end
-                                            local.get $6
-                                            i32.const 4
-                                            i32.add
-                                            local.tee $5
-                                            local.get $7
-                                            i32.le_u
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                local.get $5
-                                                local.set $6
-                                                br 2 (;@20;)
-                                              end
-                                            end
-                                          end
-                                          block $label$242 ;; label = @20
-                                            local.get $29
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                local.get $0
-                                                i32.load
-                                                i32.const 32
-                                                i32.and
-                                                br_if 2 (;@20;)
-                                                i32.const 1709
-                                                i32.const 1
-                                                local.get $0
-                                                call $21
-                                                drop
-                                              end
-                                            end
-                                          end
-                                          local.get $1
-                                          i32.const 0
-                                          i32.gt_s
-                                          local.get $5
-                                          local.get $8
-                                          i32.lt_u
-                                          i32.and
-                                          if ;; label = @20
-                                            loop $label$245 ;; label = @21
-                                              local.get $5
-                                              i32.load
-                                              i64.extend_i32_u
-                                              local.get $31
-                                              call $23
-                                              local.tee $7
-                                              local.get $19
-                                              i32.gt_u
-                                              if ;; label = @22
-                                                block ;; label = @23
-                                                  local.get $19
-                                                  i32.const 48
-                                                  local.get $7
-                                                  local.get $27
-                                                  i32.sub
-                                                  call $39
-                                                  drop
-                                                  loop $label$247 ;; label = @24
-                                                    local.get $7
-                                                    i32.const -1
-                                                    i32.add
-                                                    local.tee $7
-                                                    local.get $19
-                                                    i32.gt_u
-                                                    br_if 0 (;@24;)
-                                                  end
-                                                end
-                                              end
-                                              local.get $0
-                                              i32.load
-                                              i32.const 32
-                                              i32.and
-                                              i32.eqz
-                                              if ;; label = @22
-                                                local.get $7
-                                                local.get $1
-                                                i32.const 9
-                                                i32.gt_s
-                                                if (result i32) ;; label = @23
-                                                  i32.const 9
-                                                else
-                                                  local.get $1
-                                                end
-                                                local.get $0
-                                                call $21
-                                                drop
-                                              end
-                                              local.get $1
-                                              i32.const -9
-                                              i32.add
-                                              local.set $7
-                                              local.get $1
-                                              i32.const 9
-                                              i32.gt_s
-                                              local.get $5
-                                              i32.const 4
-                                              i32.add
-                                              local.tee $5
-                                              local.get $8
-                                              i32.lt_u
-                                              i32.and
-                                              if ;; label = @22
-                                                block ;; label = @23
-                                                  local.get $7
-                                                  local.set $1
-                                                  br 2 (;@21;)
-                                                end
-                                              else
-                                                local.get $7
-                                                local.set $1
-                                              end
-                                            end
-                                          end
-                                          local.get $0
-                                          i32.const 48
-                                          local.get $1
-                                          i32.const 9
-                                          i32.add
-                                          i32.const 9
-                                          i32.const 0
-                                          call $25
-                                        end
-                                      else
-                                        block ;; label = @19
-                                          local.get $14
-                                          i32.const 4
-                                          i32.add
-                                          local.set $5
-                                          local.get $22
-                                          i32.eqz
-                                          if ;; label = @20
-                                            local.get $5
-                                            local.set $8
-                                          end
-                                          local.get $1
-                                          i32.const -1
-                                          i32.gt_s
-                                          if ;; label = @20
-                                            block ;; label = @21
-                                              local.get $13
-                                              i32.eqz
-                                              local.set $13
-                                              local.get $14
-                                              local.set $7
-                                              local.get $1
-                                              local.set $5
-                                              loop $label$256 ;; label = @22
-                                                local.get $7
-                                                i32.load
-                                                i64.extend_i32_u
-                                                local.get $31
-                                                call $23
-                                                local.tee $1
-                                                local.get $31
-                                                i32.eq
-                                                if ;; label = @23
-                                                  block ;; label = @24
-                                                    local.get $34
-                                                    i32.const 48
-                                                    i32.store8
-                                                    local.get $34
-                                                    local.set $1
-                                                  end
-                                                end
-                                                block $label$258 ;; label = @23
-                                                  local.get $7
-                                                  local.get $14
-                                                  i32.eq
-                                                  if ;; label = @24
-                                                    block ;; label = @25
-                                                      local.get $0
-                                                      i32.load
-                                                      i32.const 32
-                                                      i32.and
-                                                      i32.eqz
-                                                      if ;; label = @26
-                                                        local.get $1
-                                                        i32.const 1
-                                                        local.get $0
-                                                        call $21
-                                                        drop
-                                                      end
-                                                      local.get $1
-                                                      i32.const 1
-                                                      i32.add
-                                                      local.set $1
-                                                      local.get $13
-                                                      local.get $5
-                                                      i32.const 1
-                                                      i32.lt_s
-                                                      i32.and
-                                                      br_if 2 (;@23;)
-                                                      local.get $0
-                                                      i32.load
-                                                      i32.const 32
-                                                      i32.and
-                                                      br_if 2 (;@23;)
-                                                      i32.const 1709
-                                                      i32.const 1
-                                                      local.get $0
-                                                      call $21
-                                                      drop
-                                                    end
-                                                  else
-                                                    block ;; label = @25
-                                                      local.get $1
-                                                      local.get $19
-                                                      i32.le_u
-                                                      br_if 2 (;@23;)
-                                                      local.get $19
-                                                      i32.const 48
-                                                      local.get $1
-                                                      local.get $43
-                                                      i32.add
-                                                      call $39
-                                                      drop
-                                                      loop $label$262 ;; label = @26
-                                                        local.get $1
-                                                        i32.const -1
-                                                        i32.add
-                                                        local.tee $1
-                                                        local.get $19
-                                                        i32.gt_u
-                                                        br_if 0 (;@26;)
-                                                      end
-                                                    end
-                                                  end
-                                                end
-                                                local.get $41
-                                                local.get $1
-                                                i32.sub
-                                                local.set $6
-                                                local.get $0
-                                                i32.load
-                                                i32.const 32
-                                                i32.and
-                                                i32.eqz
-                                                if ;; label = @23
-                                                  local.get $1
-                                                  local.get $5
-                                                  local.get $6
-                                                  i32.gt_s
-                                                  if (result i32) ;; label = @24
-                                                    local.get $6
-                                                  else
-                                                    local.get $5
-                                                  end
-                                                  local.get $0
-                                                  call $21
-                                                  drop
-                                                end
-                                                local.get $7
-                                                i32.const 4
-                                                i32.add
-                                                local.tee $7
-                                                local.get $8
-                                                i32.lt_u
-                                                local.get $5
-                                                local.get $6
-                                                i32.sub
-                                                local.tee $5
-                                                i32.const -1
-                                                i32.gt_s
-                                                i32.and
-                                                br_if 0 (;@22;)
-                                                local.get $5
-                                                local.set $1
-                                              end
-                                            end
-                                          end
-                                          local.get $0
-                                          i32.const 48
-                                          local.get $1
-                                          i32.const 18
-                                          i32.add
-                                          i32.const 18
-                                          i32.const 0
-                                          call $25
-                                          local.get $0
-                                          i32.load
-                                          i32.const 32
-                                          i32.and
-                                          br_if 2 (;@17;)
-                                          local.get $9
-                                          local.get $28
-                                          local.get $9
-                                          i32.sub
-                                          local.get $0
-                                          call $21
-                                          drop
-                                        end
-                                      end
-                                    end
-                                    local.get $0
-                                    i32.const 32
-                                    local.get $10
-                                    local.get $18
-                                    local.get $12
-                                    i32.const 8192
-                                    i32.xor
-                                    call $25
-                                    local.get $18
-                                    local.get $10
-                                    i32.ge_s
-                                    if ;; label = @17
-                                      local.get $18
-                                      local.set $10
-                                    end
-                                  end
-                                else
-                                  block ;; label = @16
-                                    local.get $0
-                                    i32.const 32
-                                    local.get $10
-                                    local.get $52
-                                    local.get $52
-                                    f64.ne
-                                    i32.const 0
-                                    i32.or
-                                    local.tee $6
-                                    if (result i32) ;; label = @17
-                                      i32.const 0
-                                      local.tee $24
-                                    else
-                                      local.get $24
-                                    end
-                                    i32.const 3
-                                    i32.add
-                                    local.tee $8
-                                    local.get $7
-                                    call $25
-                                    local.get $0
-                                    i32.load
-                                    local.tee $1
-                                    i32.const 32
-                                    i32.and
-                                    i32.eqz
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        local.get $26
-                                        local.get $24
-                                        local.get $0
-                                        call $21
-                                        drop
-                                        local.get $0
-                                        i32.load
-                                        local.set $1
-                                      end
-                                    end
-                                    local.get $9
-                                    i32.const 32
-                                    i32.and
-                                    i32.const 0
-                                    i32.ne
-                                    local.tee $5
-                                    if (result i32) ;; label = @17
-                                      i32.const 1693
-                                    else
-                                      i32.const 1697
-                                    end
-                                    local.set $7
-                                    local.get $5
-                                    if (result i32) ;; label = @17
-                                      i32.const 1701
-                                    else
-                                      i32.const 1705
-                                    end
-                                    local.set $5
-                                    local.get $6
-                                    i32.eqz
-                                    if ;; label = @17
-                                      local.get $7
-                                      local.set $5
-                                    end
-                                    local.get $1
-                                    i32.const 32
-                                    i32.and
-                                    i32.eqz
-                                    if ;; label = @17
-                                      local.get $5
-                                      i32.const 3
-                                      local.get $0
-                                      call $21
-                                      drop
-                                    end
-                                    local.get $0
-                                    i32.const 32
-                                    local.get $10
-                                    local.get $8
-                                    local.get $12
-                                    i32.const 8192
-                                    i32.xor
-                                    call $25
-                                    local.get $8
-                                    local.get $10
-                                    i32.ge_s
-                                    if ;; label = @17
-                                      local.get $8
-                                      local.set $10
-                                    end
-                                  end
-                                end
-                              end
-                              local.get $11
-                              local.set $1
-                              br 9 (;@4;)
-                            end
-                            local.get $5
-                            local.set $7
-                            i32.const 0
-                            local.set $6
-                            i32.const 1657
-                            local.set $8
-                            local.get $21
-                            local.set $5
-                            br 6 (;@6;)
-                          end
-                          local.get $9
-                          i32.const 32
-                          i32.and
-                          local.set $7
-                          local.get $16
-                          i64.load
-                          local.tee $50
-                          i64.const 0
-                          i64.eq
-                          if (result i32) ;; label = @12
-                            block (result i32) ;; label = @13
-                              i64.const 0
-                              local.set $50
-                              local.get $21
-                            end
-                          else
-                            block (result i32) ;; label = @13
-                              local.get $21
-                              local.set $1
-                              loop $label$280 ;; label = @14
-                                local.get $1
-                                i32.const -1
-                                i32.add
-                                local.tee $1
-                                local.get $50
-                                i32.wrap_i64
-                                i32.const 15
-                                i32.and
-                                i32.const 1641
-                                i32.add
-                                i32.load8_u
-                                local.get $7
-                                i32.or
-                                i32.store8
-                                local.get $50
-                                i64.const 4
-                                i64.shr_u
-                                local.tee $50
-                                i64.const 0
-                                i64.ne
-                                br_if 0 (;@14;)
-                              end
-                              local.get $16
-                              i64.load
-                              local.set $50
-                              local.get $1
-                            end
-                          end
-                          local.set $7
-                          local.get $9
-                          i32.const 4
-                          i32.shr_s
-                          i32.const 1657
-                          i32.add
-                          local.set $8
-                          local.get $12
-                          i32.const 8
-                          i32.and
-                          i32.eqz
-                          local.get $50
-                          i64.const 0
-                          i64.eq
-                          i32.or
-                          local.tee $1
-                          if ;; label = @12
-                            i32.const 1657
-                            local.set $8
-                          end
-                          local.get $1
-                          if (result i32) ;; label = @12
-                            i32.const 0
-                          else
-                            i32.const 2
-                          end
-                          local.set $6
-                          br 4 (;@7;)
-                        end
-                        local.get $50
-                        local.get $21
-                        call $23
-                        local.set $7
-                        br 3 (;@7;)
-                      end
-                      local.get $1
-                      i32.const 0
-                      local.get $5
-                      call $17
-                      local.tee $13
-                      i32.eqz
-                      local.set $14
-                      local.get $13
-                      local.get $1
-                      i32.sub
-                      local.set $8
-                      local.get $1
-                      local.get $5
-                      i32.add
-                      local.set $9
-                      local.get $7
-                      local.set $12
-                      local.get $14
-                      if (result i32) ;; label = @10
-                        local.get $5
-                      else
-                        local.get $8
-                      end
-                      local.set $7
-                      i32.const 0
-                      local.set $6
-                      i32.const 1657
-                      local.set $8
-                      local.get $14
-                      if (result i32) ;; label = @10
-                        local.get $9
-                      else
-                        local.get $13
-                      end
-                      local.set $5
-                      br 3 (;@6;)
-                    end
-                    i32.const 0
-                    local.set $1
-                    i32.const 0
-                    local.set $5
-                    local.get $7
-                    local.set $8
-                    loop $label$288 ;; label = @9
-                      block $label$289 ;; label = @10
-                        local.get $8
-                        i32.load
-                        local.tee $9
-                        i32.eqz
-                        br_if 0 (;@10;)
-                        local.get $36
-                        local.get $9
-                        call $26
-                        local.tee $5
-                        i32.const 0
-                        i32.lt_s
-                        local.get $5
-                        local.get $6
-                        local.get $1
-                        i32.sub
-                        i32.gt_u
-                        i32.or
-                        br_if 0 (;@10;)
-                        local.get $8
-                        i32.const 4
-                        i32.add
-                        local.set $8
-                        local.get $6
-                        local.get $5
-                        local.get $1
-                        i32.add
-                        local.tee $1
-                        i32.gt_u
-                        br_if 1 (;@9;)
-                      end
-                    end
-                    local.get $5
-                    i32.const 0
-                    i32.lt_s
-                    if ;; label = @9
-                      block ;; label = @10
-                        i32.const -1
-                        local.set $15
-                        br 5 (;@5;)
-                      end
-                    end
-                    local.get $0
-                    i32.const 32
-                    local.get $10
-                    local.get $1
-                    local.get $12
-                    call $25
-                    local.get $1
-                    if ;; label = @9
-                      block ;; label = @10
-                        i32.const 0
-                        local.set $5
-                        loop $label$292 ;; label = @11
-                          local.get $7
-                          i32.load
-                          local.tee $8
-                          i32.eqz
-                          br_if 3 (;@8;)
-                          local.get $36
-                          local.get $8
-                          call $26
-                          local.tee $8
-                          local.get $5
-                          i32.add
-                          local.tee $5
-                          local.get $1
-                          i32.gt_s
-                          br_if 3 (;@8;)
-                          local.get $0
-                          i32.load
-                          i32.const 32
-                          i32.and
-                          i32.eqz
-                          if ;; label = @12
-                            local.get $36
-                            local.get $8
-                            local.get $0
-                            call $21
-                            drop
-                          end
-                          local.get $7
-                          i32.const 4
-                          i32.add
-                          local.set $7
-                          local.get $5
-                          local.get $1
-                          i32.lt_u
-                          br_if 0 (;@11;)
-                          br 3 (;@8;)
-                        end
-                      end
-                    else
-                      block ;; label = @10
-                        i32.const 0
-                        local.set $1
-                        br 2 (;@8;)
-                      end
-                    end
-                  end
-                  local.get $0
-                  i32.const 32
-                  local.get $10
-                  local.get $1
-                  local.get $12
-                  i32.const 8192
-                  i32.xor
-                  call $25
-                  local.get $10
-                  local.get $1
-                  i32.le_s
-                  if ;; label = @8
-                    local.get $1
-                    local.set $10
-                  end
-                  local.get $11
-                  local.set $1
-                  br 3 (;@4;)
-                end
-                local.get $12
-                i32.const -65537
-                i32.and
-                local.set $1
-                local.get $5
-                i32.const -1
-                i32.gt_s
-                if ;; label = @7
-                  local.get $1
-                  local.set $12
-                end
-                local.get $5
-                local.get $16
-                i64.load
-                i64.const 0
-                i64.ne
-                local.tee $9
-                i32.or
-                if (result i32) ;; label = @7
-                  block (result i32) ;; label = @8
-                    local.get $7
-                    local.set $1
-                    local.get $5
-                    local.get $9
-                    i32.const 1
-                    i32.and
-                    i32.const 1
-                    i32.xor
-                    local.get $38
-                    local.get $7
-                    i32.sub
-                    i32.add
-                    local.tee $7
-                    i32.gt_s
-                    if ;; label = @9
-                      local.get $5
-                      local.set $7
-                    end
-                    local.get $21
-                  end
-                else
-                  block (result i32) ;; label = @8
-                    local.get $21
-                    local.set $1
-                    i32.const 0
-                    local.set $7
-                    local.get $21
-                  end
-                end
-                local.set $5
-              end
-              local.get $0
-              i32.const 32
-              local.get $10
-              local.get $7
-              local.get $5
-              local.get $1
-              i32.sub
-              local.tee $9
-              i32.lt_s
-              if (result i32) ;; label = @6
-                local.get $9
-                local.tee $7
-              else
-                local.get $7
-              end
-              local.get $6
-              i32.add
-              local.tee $5
-              i32.lt_s
-              if (result i32) ;; label = @6
-                local.get $5
-                local.tee $10
-              else
-                local.get $10
-              end
-              local.get $5
-              local.get $12
-              call $25
-              local.get $0
-              i32.load
-              i32.const 32
-              i32.and
-              i32.eqz
-              if ;; label = @6
-                local.get $8
-                local.get $6
-                local.get $0
-                call $21
-                drop
-              end
-              local.get $0
-              i32.const 48
-              local.get $10
-              local.get $5
-              local.get $12
-              i32.const 65536
-              i32.xor
-              call $25
-              local.get $0
-              i32.const 48
-              local.get $7
-              local.get $9
-              i32.const 0
-              call $25
-              local.get $0
-              i32.load
-              i32.const 32
-              i32.and
-              i32.eqz
-              if ;; label = @6
-                local.get $1
-                local.get $9
-                local.get $0
-                call $21
-                drop
-              end
-              local.get $0
-              i32.const 32
-              local.get $10
-              local.get $5
-              local.get $12
-              i32.const 8192
-              i32.xor
-              call $25
-              local.get $11
-              local.set $1
-              br 1 (;@4;)
-            end
-          end
-          br 1 (;@2;)
-        end
-        local.get $0
-        i32.eqz
-        if ;; label = @3
-          local.get $17
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 1
-              local.set $0
-              loop $label$308 ;; label = @6
-                local.get $4
-                local.get $0
-                i32.const 2
-                i32.shl
-                i32.add
-                i32.load
-                local.tee $1
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $3
-                    local.get $0
-                    i32.const 3
-                    i32.shl
-                    i32.add
-                    local.get $1
-                    local.get $2
-                    call $22
-                    local.get $0
-                    i32.const 1
-                    i32.add
-                    local.tee $0
-                    i32.const 10
-                    i32.lt_s
-                    br_if 2 (;@6;)
-                    i32.const 1
-                    local.set $15
-                    br 6 (;@2;)
-                  end
-                end
-              end
-              loop $label$310 ;; label = @6
-                local.get $4
-                local.get $0
-                i32.const 2
-                i32.shl
-                i32.add
-                i32.load
-                if ;; label = @7
-                  block ;; label = @8
-                    i32.const -1
-                    local.set $15
-                    br 6 (;@2;)
-                  end
-                end
-                local.get $0
-                i32.const 1
-                i32.add
-                local.tee $0
-                i32.const 10
-                i32.lt_s
-                br_if 0 (;@6;)
-                i32.const 1
-                local.set $15
-              end
-            end
-          else
-            i32.const 0
-            local.set $15
-          end
-        end
-      end
-      local.get $23
-      global.set $global$1
-      local.get $15
-    end
-  )
-  (func $20 (;33;) (type $1) (param $0 i32) (result i32)
-    i32.const 0
-  )
-  (func $21 (;34;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32)
-    block $label$1 (result i32) ;; label = @1
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          local.get $2
-          i32.const 16
-          i32.add
-          local.tee $4
-          i32.load
-          local.tee $3
-          br_if 0 (;@3;)
-          local.get $2
-          call $30
-          if ;; label = @4
-            i32.const 0
-            local.set $3
-          else
-            block ;; label = @5
-              local.get $4
-              i32.load
-              local.set $3
-              br 2 (;@3;)
-            end
-          end
-          br 1 (;@2;)
-        end
-        local.get $3
-        local.get $2
-        i32.const 20
-        i32.add
-        local.tee $5
-        i32.load
-        local.tee $4
-        i32.sub
-        local.get $1
-        i32.lt_u
-        if ;; label = @3
-          block ;; label = @4
-            local.get $2
-            local.get $0
-            local.get $1
-            local.get $2
-            i32.load offset=36
-            i32.const 3
-            i32.and
-            i32.const 2
-            i32.add
-            call_indirect (type $0)
-            local.set $3
-            br 2 (;@2;)
-          end
-        end
-        block $label$7 (result i32) ;; label = @3
-          local.get $2
-          i32.load8_s offset=75
-          i32.const -1
-          i32.gt_s
-          if (result i32) ;; label = @4
-            block (result i32) ;; label = @5
-              local.get $1
-              local.set $3
-              loop $label$9 ;; label = @6
-                i32.const 0
-                local.get $3
-                i32.eqz
-                br_if 3 (;@3;)
-                drop
-                local.get $0
-                local.get $3
-                i32.const -1
-                i32.add
-                local.tee $6
-                i32.add
-                i32.load8_s
-                i32.const 10
-                i32.ne
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $6
-                    local.set $3
-                    br 2 (;@6;)
-                  end
-                end
-              end
-              local.get $2
-              local.get $0
-              local.get $3
-              local.get $2
-              i32.load offset=36
-              i32.const 3
-              i32.and
-              i32.const 2
-              i32.add
-              call_indirect (type $0)
-              local.get $3
-              i32.lt_u
-              br_if 3 (;@2;)
-              local.get $5
-              i32.load
-              local.set $4
-              local.get $1
-              local.get $3
-              i32.sub
-              local.set $1
-              local.get $0
-              local.get $3
-              i32.add
-              local.set $0
-              local.get $3
-            end
-          else
-            i32.const 0
-          end
-        end
-        local.set $2
-        local.get $4
-        local.get $0
-        local.get $1
-        call $40
-        drop
-        local.get $5
-        local.get $5
-        i32.load
-        local.get $1
-        i32.add
-        i32.store
-        local.get $2
-        local.get $1
-        i32.add
-        local.set $3
-      end
-      local.get $3
-    end
-  )
-  (func $22 (;35;) (type $8) (param $0 i32) (param $1 i32) (param $2 i32)
-    (local $3 i32) (local $4 i64) (local $5 f64)
-    block $label$1 ;; label = @1
-      local.get $1
-      i32.const 20
-      i32.le_u
-      if ;; label = @2
-        block $label$3 ;; label = @3
-          block $label$4 ;; label = @4
-            block $label$5 ;; label = @5
-              block $label$6 ;; label = @6
-                block $label$7 ;; label = @7
-                  block $label$8 ;; label = @8
-                    block $label$9 ;; label = @9
-                      block $label$10 ;; label = @10
-                        block $label$11 ;; label = @11
-                          block $label$12 ;; label = @12
-                            block $label$13 ;; label = @13
-                              local.get $1
-                              i32.const 9
-                              i32.sub
-                              br_table 0 (;@13;) 1 (;@12;) 2 (;@11;) 3 (;@10;) 4 (;@9;) 5 (;@8;) 6 (;@7;) 7 (;@6;) 8 (;@5;) 9 (;@4;) 10 (;@3;)
-                            end
-                            local.get $2
-                            i32.load
-                            i32.const 3
-                            i32.add
-                            i32.const -4
-                            i32.and
-                            local.tee $1
-                            i32.load
-                            local.set $3
-                            local.get $2
-                            local.get $1
-                            i32.const 4
-                            i32.add
-                            i32.store
-                            local.get $0
-                            local.get $3
-                            i32.store
-                            br 11 (;@1;)
-                          end
-                          local.get $2
-                          i32.load
-                          i32.const 3
-                          i32.add
-                          i32.const -4
-                          i32.and
-                          local.tee $1
-                          i32.load
-                          local.set $3
-                          local.get $2
-                          local.get $1
-                          i32.const 4
-                          i32.add
-                          i32.store
-                          local.get $0
-                          local.get $3
-                          i64.extend_i32_s
-                          i64.store
-                          br 10 (;@1;)
-                        end
-                        local.get $2
-                        i32.load
-                        i32.const 3
-                        i32.add
-                        i32.const -4
-                        i32.and
-                        local.tee $1
-                        i32.load
-                        local.set $3
-                        local.get $2
-                        local.get $1
-                        i32.const 4
-                        i32.add
-                        i32.store
-                        local.get $0
-                        local.get $3
-                        i64.extend_i32_u
-                        i64.store
-                        br 9 (;@1;)
-                      end
-                      local.get $2
-                      i32.load
-                      i32.const 7
-                      i32.add
-                      i32.const -8
-                      i32.and
-                      local.tee $1
-                      i64.load
-                      local.set $4
-                      local.get $2
-                      local.get $1
-                      i32.const 8
-                      i32.add
-                      i32.store
-                      local.get $0
-                      local.get $4
-                      i64.store
-                      br 8 (;@1;)
-                    end
-                    local.get $2
-                    i32.load
-                    i32.const 3
-                    i32.add
-                    i32.const -4
-                    i32.and
-                    local.tee $1
-                    i32.load
-                    local.set $3
-                    local.get $2
-                    local.get $1
-                    i32.const 4
-                    i32.add
-                    i32.store
-                    local.get $0
-                    local.get $3
-                    i32.const 65535
-                    i32.and
-                    i32.const 16
-                    i32.shl
-                    i32.const 16
-                    i32.shr_s
-                    i64.extend_i32_s
-                    i64.store
-                    br 7 (;@1;)
-                  end
-                  local.get $2
-                  i32.load
-                  i32.const 3
-                  i32.add
-                  i32.const -4
-                  i32.and
-                  local.tee $1
-                  i32.load
-                  local.set $3
-                  local.get $2
-                  local.get $1
-                  i32.const 4
-                  i32.add
-                  i32.store
-                  local.get $0
-                  local.get $3
-                  i32.const 65535
-                  i32.and
-                  i64.extend_i32_u
-                  i64.store
-                  br 6 (;@1;)
-                end
-                local.get $2
-                i32.load
-                i32.const 3
-                i32.add
-                i32.const -4
-                i32.and
-                local.tee $1
-                i32.load
-                local.set $3
-                local.get $2
-                local.get $1
-                i32.const 4
-                i32.add
-                i32.store
-                local.get $0
-                local.get $3
-                i32.const 255
-                i32.and
-                i32.const 24
-                i32.shl
-                i32.const 24
-                i32.shr_s
-                i64.extend_i32_s
-                i64.store
-                br 5 (;@1;)
-              end
-              local.get $2
-              i32.load
-              i32.const 3
-              i32.add
-              i32.const -4
-              i32.and
-              local.tee $1
-              i32.load
-              local.set $3
-              local.get $2
-              local.get $1
-              i32.const 4
-              i32.add
-              i32.store
-              local.get $0
-              local.get $3
-              i32.const 255
-              i32.and
-              i64.extend_i32_u
-              i64.store
-              br 4 (;@1;)
-            end
-            local.get $2
-            i32.load
-            i32.const 7
-            i32.add
-            i32.const -8
-            i32.and
-            local.tee $1
-            f64.load
-            local.set $5
-            local.get $2
-            local.get $1
-            i32.const 8
-            i32.add
-            i32.store
-            local.get $0
-            local.get $5
-            f64.store
-            br 3 (;@1;)
-          end
-          local.get $2
-          i32.load
-          i32.const 7
-          i32.add
-          i32.const -8
-          i32.and
-          local.tee $1
-          f64.load
-          local.set $5
-          local.get $2
-          local.get $1
-          i32.const 8
-          i32.add
-          i32.store
-          local.get $0
-          local.get $5
-          f64.store
-        end
-      end
-    end
-  )
-  (func $23 (;36;) (type $9) (param $0 i64) (param $1 i32) (result i32)
-    (local $2 i32) (local $3 i32) (local $4 i64)
-    block $label$1 (result i32) ;; label = @1
-      local.get $0
-      i32.wrap_i64
-      local.set $2
-      local.get $0
-      i64.const 4294967295
-      i64.gt_u
-      if ;; label = @2
-        block ;; label = @3
-          loop $label$3 ;; label = @4
-            local.get $1
-            i32.const -1
-            i32.add
-            local.tee $1
-            local.get $0
-            i64.const 10
-            i64.rem_u
-            i64.const 48
-            i64.or
-            i64.store8
-            local.get $0
-            i64.const 10
-            i64.div_u
-            local.set $4
-            local.get $0
-            i64.const 42949672959
-            i64.gt_u
-            if ;; label = @5
-              block ;; label = @6
-                local.get $4
-                local.set $0
-                br 2 (;@4;)
-              end
-            end
-          end
-          local.get $4
-          i32.wrap_i64
-          local.set $2
-        end
-      end
-      local.get $2
-      if ;; label = @2
-        loop $label$6 ;; label = @3
-          local.get $1
-          i32.const -1
-          i32.add
-          local.tee $1
-          local.get $2
-          i32.const 10
-          i32.rem_u
-          i32.const 48
-          i32.or
-          i32.store8
-          local.get $2
-          i32.const 10
-          i32.div_u
-          local.set $3
-          local.get $2
-          i32.const 10
-          i32.ge_u
-          if ;; label = @4
-            block ;; label = @5
-              local.get $3
-              local.set $2
-              br 2 (;@3;)
-            end
-          end
-        end
-      end
-      local.get $1
-    end
-  )
-  (func $24 (;37;) (type $1) (param $0 i32) (result i32)
-    (local $1 i32) (local $2 i32)
-    block $label$1 (result i32) ;; label = @1
-      i32.const 0
-      local.set $1
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          block $label$4 ;; label = @4
-            loop $label$5 ;; label = @5
-              local.get $1
-              i32.const 1711
-              i32.add
-              i32.load8_u
-              local.get $0
-              i32.eq
-              br_if 1 (;@4;)
-              local.get $1
-              i32.const 1
-              i32.add
-              local.tee $1
-              i32.const 87
-              i32.ne
-              br_if 0 (;@5;)
-              i32.const 87
-              local.set $1
-              i32.const 1799
-              local.set $0
-              br 2 (;@3;)
-            end
-          end
-          local.get $1
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 1799
-              local.set $0
-              br 2 (;@3;)
-            end
-          else
-            i32.const 1799
-            local.set $0
-          end
-          br 1 (;@2;)
-        end
-        loop $label$8 ;; label = @3
-          local.get $0
-          local.set $2
-          loop $label$9 ;; label = @4
-            local.get $2
-            i32.const 1
-            i32.add
-            local.set $0
-            local.get $2
-            i32.load8_s
-            if ;; label = @5
-              block ;; label = @6
-                local.get $0
-                local.set $2
-                br 2 (;@4;)
-              end
-            end
-          end
-          local.get $1
-          i32.const -1
-          i32.add
-          local.tee $1
-          br_if 0 (;@3;)
-        end
-      end
-      local.get $0
-    end
-  )
-  (func $25 (;38;) (type $10) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32)
-    (local $5 i32) (local $6 i32) (local $7 i32)
-    block $label$1 ;; label = @1
-      global.get $global$1
-      local.set $7
-      global.get $global$1
-      i32.const 256
-      i32.add
-      global.set $global$1
-      local.get $7
-      local.set $6
-      block $label$2 ;; label = @2
-        local.get $2
-        local.get $3
-        i32.gt_s
-        local.get $4
-        i32.const 73728
-        i32.and
-        i32.eqz
-        i32.and
-        if ;; label = @3
-          block ;; label = @4
-            local.get $6
-            local.get $1
-            local.get $2
-            local.get $3
-            i32.sub
-            local.tee $5
-            i32.const 256
-            i32.gt_u
-            if (result i32) ;; label = @5
-              i32.const 256
-            else
-              local.get $5
-            end
-            call $39
-            drop
-            local.get $0
-            i32.load
-            local.tee $1
-            i32.const 32
-            i32.and
-            i32.eqz
-            local.set $4
-            local.get $5
-            i32.const 255
-            i32.gt_u
-            if ;; label = @5
-              block ;; label = @6
-                loop $label$7 ;; label = @7
-                  local.get $4
-                  if ;; label = @8
-                    block ;; label = @9
-                      local.get $6
-                      i32.const 256
-                      local.get $0
-                      call $21
-                      drop
-                      local.get $0
-                      i32.load
-                      local.set $1
-                    end
-                  end
-                  local.get $1
-                  i32.const 32
-                  i32.and
-                  i32.eqz
-                  local.set $4
-                  local.get $5
-                  i32.const -256
-                  i32.add
-                  local.tee $5
-                  i32.const 255
-                  i32.gt_u
-                  br_if 0 (;@7;)
-                end
-                local.get $4
-                i32.eqz
-                br_if 4 (;@2;)
-                local.get $2
-                local.get $3
-                i32.sub
-                i32.const 255
-                i32.and
-                local.set $5
-              end
-            else
-              local.get $4
-              i32.eqz
-              br_if 3 (;@2;)
-            end
-            local.get $6
-            local.get $5
-            local.get $0
-            call $21
-            drop
-          end
-        end
-      end
-      local.get $7
-      global.set $global$1
-    end
-  )
-  (func $26 (;39;) (type $4) (param $0 i32) (param $1 i32) (result i32)
-    local.get $0
-    if (result i32) ;; label = @1
-      local.get $0
-      local.get $1
-      i32.const 0
-      call $29
-    else
-      i32.const 0
-    end
-  )
-  (func $27 (;40;) (type $11) (param $0 f64) (param $1 i32) (result f64)
-    local.get $0
-    local.get $1
-    call $28
-  )
-  (func $28 (;41;) (type $11) (param $0 f64) (param $1 i32) (result f64)
-    (local $2 i64) (local $3 i64)
-    block $label$1 (result f64) ;; label = @1
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          block $label$4 ;; label = @4
-            block $label$5 ;; label = @5
-              local.get $0
-              i64.reinterpret_f64
-              local.tee $2
-              i64.const 52
-              i64.shr_u
-              local.tee $3
-              i32.wrap_i64
-              i32.const 65535
-              i32.and
-              i32.const 2047
-              i32.and
-              i32.const 16
-              i32.shl
-              i32.const 16
-              i32.shr_s
-              i32.const 0
-              i32.sub
-              br_table 0 (;@5;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 1 (;@4;) 2 (;@3;)
-            end
-            local.get $1
-            local.get $0
-            f64.const 0x0p+0 (;=0;)
-            f64.ne
-            if (result i32) ;; label = @5
-              block (result i32) ;; label = @6
-                local.get $0
-                f64.const 0x1p+64 (;=18446744073709552000;)
-                f64.mul
-                local.get $1
-                call $28
-                local.set $0
-                local.get $1
-                i32.load
-                i32.const -64
-                i32.add
-              end
-            else
-              i32.const 0
-            end
-            i32.store
-            br 2 (;@2;)
-          end
-          br 1 (;@2;)
-        end
-        local.get $1
-        local.get $3
-        i32.wrap_i64
-        i32.const 2047
-        i32.and
-        i32.const -1022
-        i32.add
-        i32.store
-        local.get $2
-        i64.const -9218868437227405313
-        i64.and
-        i64.const 4602678819172646912
-        i64.or
-        f64.reinterpret_i64
-        local.set $0
-      end
-      local.get $0
-    end
-  )
-  (func $29 (;42;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    block $label$1 (result i32) ;; label = @1
-      local.get $0
-      if (result i32) ;; label = @2
-        block (result i32) ;; label = @3
-          local.get $1
-          i32.const 128
-          i32.lt_u
-          if ;; label = @4
-            block ;; label = @5
-              local.get $0
-              local.get $1
-              i32.store8
-              i32.const 1
-              br 4 (;@1;)
-            end
-          end
-          local.get $1
-          i32.const 2048
-          i32.lt_u
-          if ;; label = @4
-            block ;; label = @5
-              local.get $0
-              local.get $1
-              i32.const 6
-              i32.shr_u
-              i32.const 192
-              i32.or
-              i32.store8
-              local.get $0
-              local.get $1
-              i32.const 63
-              i32.and
-              i32.const 128
-              i32.or
-              i32.store8 offset=1
-              i32.const 2
-              br 4 (;@1;)
-            end
-          end
-          local.get $1
-          i32.const 55296
-          i32.lt_u
-          local.get $1
-          i32.const -8192
-          i32.and
-          i32.const 57344
-          i32.eq
-          i32.or
-          if ;; label = @4
-            block ;; label = @5
-              local.get $0
-              local.get $1
-              i32.const 12
-              i32.shr_u
-              i32.const 224
-              i32.or
-              i32.store8
-              local.get $0
-              local.get $1
-              i32.const 6
-              i32.shr_u
-              i32.const 63
-              i32.and
-              i32.const 128
-              i32.or
-              i32.store8 offset=1
-              local.get $0
-              local.get $1
-              i32.const 63
-              i32.and
-              i32.const 128
-              i32.or
-              i32.store8 offset=2
-              i32.const 3
-              br 4 (;@1;)
-            end
-          end
-          local.get $1
-          i32.const -65536
-          i32.add
-          i32.const 1048576
-          i32.lt_u
-          if (result i32) ;; label = @4
-            block (result i32) ;; label = @5
-              local.get $0
-              local.get $1
-              i32.const 18
-              i32.shr_u
-              i32.const 240
-              i32.or
-              i32.store8
-              local.get $0
-              local.get $1
-              i32.const 12
-              i32.shr_u
-              i32.const 63
-              i32.and
-              i32.const 128
-              i32.or
-              i32.store8 offset=1
-              local.get $0
-              local.get $1
-              i32.const 6
-              i32.shr_u
-              i32.const 63
-              i32.and
-              i32.const 128
-              i32.or
-              i32.store8 offset=2
-              local.get $0
-              local.get $1
-              i32.const 63
-              i32.and
-              i32.const 128
-              i32.or
-              i32.store8 offset=3
-              i32.const 4
-            end
-          else
-            block (result i32) ;; label = @5
-              call $12
-              i32.const 84
-              i32.store
-              i32.const -1
-            end
-          end
-        end
-      else
-        i32.const 1
-      end
-    end
-  )
-  (func $30 (;43;) (type $1) (param $0 i32) (result i32)
-    (local $1 i32) (local $2 i32)
-    block $label$1 (result i32) ;; label = @1
-      local.get $0
-      i32.const 74
-      i32.add
-      local.tee $2
-      i32.load8_s
-      local.set $1
-      local.get $2
-      local.get $1
-      i32.const 255
-      i32.add
-      local.get $1
-      i32.or
-      i32.store8
-      local.get $0
-      i32.load
-      local.tee $1
-      i32.const 8
-      i32.and
-      if (result i32) ;; label = @2
-        block (result i32) ;; label = @3
-          local.get $0
-          local.get $1
-          i32.const 32
-          i32.or
-          i32.store
-          i32.const -1
-        end
-      else
-        block (result i32) ;; label = @3
-          local.get $0
-          i32.const 0
-          i32.store offset=8
-          local.get $0
-          i32.const 0
-          i32.store offset=4
-          local.get $0
-          local.get $0
-          i32.load offset=44
-          local.tee $1
-          i32.store offset=28
-          local.get $0
-          local.get $1
-          i32.store offset=20
-          local.get $0
-          local.get $1
-          local.get $0
-          i32.load offset=48
-          i32.add
-          i32.store offset=16
-          i32.const 0
-        end
-      end
-      local.tee $0
-    end
-  )
-  (func $31 (;44;) (type $4) (param $0 i32) (param $1 i32) (result i32)
-    (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $3
-      global.get $global$1
-      i32.const 16
-      i32.add
-      global.set $global$1
-      local.get $3
-      local.tee $4
-      local.get $1
-      i32.const 255
-      i32.and
-      local.tee $7
-      i32.store8
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          local.get $0
-          i32.const 16
-          i32.add
-          local.tee $2
-          i32.load
-          local.tee $5
-          br_if 0 (;@3;)
-          local.get $0
-          call $30
-          if ;; label = @4
-            i32.const -1
-            local.set $1
-          else
-            block ;; label = @5
-              local.get $2
-              i32.load
-              local.set $5
-              br 2 (;@3;)
-            end
-          end
-          br 1 (;@2;)
-        end
-        local.get $0
-        i32.const 20
-        i32.add
-        local.tee $2
-        i32.load
-        local.tee $6
-        local.get $5
-        i32.lt_u
-        if ;; label = @3
-          local.get $1
-          i32.const 255
-          i32.and
-          local.tee $1
-          local.get $0
-          i32.load8_s offset=75
-          i32.ne
-          if ;; label = @4
-            block ;; label = @5
-              local.get $2
-              local.get $6
-              i32.const 1
-              i32.add
-              i32.store
-              local.get $6
-              local.get $7
-              i32.store8
-              br 3 (;@2;)
-            end
-          end
-        end
-        local.get $0
-        local.get $4
-        i32.const 1
-        local.get $0
-        i32.load offset=36
-        i32.const 3
-        i32.and
-        i32.const 2
-        i32.add
-        call_indirect (type $0)
-        i32.const 1
-        i32.eq
-        if (result i32) ;; label = @3
-          local.get $4
-          i32.load8_u
-        else
-          i32.const -1
-        end
-        local.set $1
-      end
-      local.get $3
-      global.set $global$1
-      local.get $1
-    end
-  )
-  (func $32 (;45;) (type $4) (param $0 i32) (param $1 i32) (result i32)
-    (local $2 i32) (local $3 i32)
-    block $label$1 (result i32) ;; label = @1
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          local.get $1
-          i32.load offset=76
-          i32.const 0
-          i32.lt_s
-          br_if 0 (;@3;)
-          local.get $1
-          call $20
-          i32.eqz
-          br_if 0 (;@3;)
-          block $label$4 (result i32) ;; label = @4
-            block $label$5 ;; label = @5
-              local.get $1
-              i32.load8_s offset=75
-              local.get $0
-              i32.eq
-              br_if 0 (;@5;)
-              local.get $1
-              i32.const 20
-              i32.add
-              local.tee $3
-              i32.load
-              local.tee $2
-              local.get $1
-              i32.load offset=16
-              i32.ge_u
-              br_if 0 (;@5;)
-              local.get $3
-              local.get $2
-              i32.const 1
-              i32.add
-              i32.store
-              local.get $2
-              local.get $0
-              i32.store8
-              local.get $0
-              i32.const 255
-              i32.and
-              br 1 (;@4;)
-            end
-            local.get $1
-            local.get $0
-            call $31
-          end
-          local.set $0
-          local.get $1
-          call $13
-          br 1 (;@2;)
-        end
-        local.get $1
-        i32.load8_s offset=75
-        local.get $0
-        i32.ne
-        if ;; label = @3
-          local.get $1
-          i32.const 20
-          i32.add
-          local.tee $3
-          i32.load
-          local.tee $2
-          local.get $1
-          i32.load offset=16
-          i32.lt_u
-          if ;; label = @4
-            block ;; label = @5
-              local.get $3
-              local.get $2
-              i32.const 1
-              i32.add
-              i32.store
-              local.get $2
-              local.get $0
-              i32.store8
-              local.get $0
-              i32.const 255
-              i32.and
-              local.set $0
-              br 3 (;@2;)
-            end
-          end
-        end
-        local.get $1
-        local.get $0
-        call $31
-        local.set $0
-      end
-      local.get $0
-    end
-  )
-  (func $33 (;46;) (type $4) (param $0 i32) (param $1 i32) (result i32)
-    (local $2 i32) (local $3 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $2
-      global.get $global$1
-      i32.const 16
-      i32.add
-      global.set $global$1
-      local.get $2
-      local.tee $3
-      local.get $1
-      i32.store
-      i32.const 1024
-      i32.load
-      local.get $0
-      local.get $3
-      call $18
-      local.set $0
-      local.get $2
-      global.set $global$1
-      local.get $0
-    end
-  )
-  (func $34 (;47;) (type $1) (param $0 i32) (result i32)
-    local.get $0
-    i32.const 1024
-    i32.load
-    call $32
-  )
-  (func $35 (;48;) (type $1) (param $0 i32) (result i32)
-    (local $1 i32) (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32) (local $15 i32) (local $16 i32) (local $17 i32) (local $18 i32) (local $19 i32) (local $20 i32) (local $21 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $14
-      global.get $global$1
-      i32.const 16
-      i32.add
-      global.set $global$1
-      local.get $14
-      local.set $18
-      block $label$2 ;; label = @2
-        local.get $0
-        i32.const 245
-        i32.lt_u
-        if ;; label = @3
-          block ;; label = @4
-            local.get $0
-            i32.const 11
-            i32.add
-            i32.const -8
-            i32.and
-            local.set $3
-            i32.const 3652
-            i32.load
-            local.tee $8
-            local.get $0
-            i32.const 11
-            i32.lt_u
-            if (result i32) ;; label = @5
-              i32.const 16
-              local.tee $3
-            else
-              local.get $3
-            end
-            i32.const 3
-            i32.shr_u
-            local.tee $2
-            i32.shr_u
-            local.tee $0
-            i32.const 3
-            i32.and
-            if ;; label = @5
-              block ;; label = @6
-                local.get $0
-                i32.const 1
-                i32.and
-                i32.const 1
-                i32.xor
-                local.get $2
-                i32.add
-                local.tee $5
-                i32.const 1
-                i32.shl
-                i32.const 2
-                i32.shl
-                i32.const 3692
-                i32.add
-                local.tee $2
-                i32.const 8
-                i32.add
-                local.tee $3
-                i32.load
-                local.tee $7
-                i32.const 8
-                i32.add
-                local.tee $1
-                i32.load
-                local.set $4
-                local.get $2
-                local.get $4
-                i32.eq
-                if ;; label = @7
-                  i32.const 3652
-                  local.get $8
-                  i32.const 1
-                  local.get $5
-                  i32.shl
-                  i32.const -1
-                  i32.xor
-                  i32.and
-                  i32.store
-                else
-                  block ;; label = @8
-                    local.get $4
-                    i32.const 3668
-                    i32.load
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                    local.get $4
-                    i32.const 12
-                    i32.add
-                    local.tee $0
-                    i32.load
-                    local.get $7
-                    i32.eq
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $0
-                        local.get $2
-                        i32.store
-                        local.get $3
-                        local.get $4
-                        i32.store
-                      end
-                    else
-                      call $fimport$10
-                    end
-                  end
-                end
-                local.get $7
-                local.get $5
-                i32.const 3
-                i32.shl
-                local.tee $0
-                i32.const 3
-                i32.or
-                i32.store offset=4
-                local.get $7
-                local.get $0
-                i32.add
-                i32.const 4
-                i32.add
-                local.tee $0
-                local.get $0
-                i32.load
-                i32.const 1
-                i32.or
-                i32.store
-                local.get $14
-                global.set $global$1
-                local.get $1
-                return
-              end
-            end
-            local.get $3
-            i32.const 3660
-            i32.load
-            local.tee $16
-            i32.gt_u
-            if ;; label = @5
-              block ;; label = @6
-                local.get $0
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $0
-                    local.get $2
-                    i32.shl
-                    i32.const 2
-                    local.get $2
-                    i32.shl
-                    local.tee $0
-                    i32.const 0
-                    local.get $0
-                    i32.sub
-                    i32.or
-                    i32.and
-                    local.tee $0
-                    i32.const 0
-                    local.get $0
-                    i32.sub
-                    i32.and
-                    i32.const -1
-                    i32.add
-                    local.tee $0
-                    i32.const 12
-                    i32.shr_u
-                    i32.const 16
-                    i32.and
-                    local.set $5
-                    local.get $0
-                    local.get $5
-                    i32.shr_u
-                    local.tee $2
-                    i32.const 5
-                    i32.shr_u
-                    i32.const 8
-                    i32.and
-                    local.tee $0
-                    local.get $5
-                    i32.or
-                    local.get $2
-                    local.get $0
-                    i32.shr_u
-                    local.tee $2
-                    i32.const 2
-                    i32.shr_u
-                    i32.const 4
-                    i32.and
-                    local.tee $0
-                    i32.or
-                    local.get $2
-                    local.get $0
-                    i32.shr_u
-                    local.tee $2
-                    i32.const 1
-                    i32.shr_u
-                    i32.const 2
-                    i32.and
-                    local.tee $0
-                    i32.or
-                    local.get $2
-                    local.get $0
-                    i32.shr_u
-                    local.tee $2
-                    i32.const 1
-                    i32.shr_u
-                    i32.const 1
-                    i32.and
-                    local.tee $0
-                    i32.or
-                    local.get $2
-                    local.get $0
-                    i32.shr_u
-                    i32.add
-                    local.tee $11
-                    i32.const 1
-                    i32.shl
-                    i32.const 2
-                    i32.shl
-                    i32.const 3692
-                    i32.add
-                    local.tee $4
-                    i32.const 8
-                    i32.add
-                    local.tee $2
-                    i32.load
-                    local.tee $9
-                    i32.const 8
-                    i32.add
-                    local.tee $5
-                    i32.load
-                    local.set $12
-                    local.get $4
-                    local.get $12
-                    i32.eq
-                    if ;; label = @9
-                      i32.const 3652
-                      local.get $8
-                      i32.const 1
-                      local.get $11
-                      i32.shl
-                      i32.const -1
-                      i32.xor
-                      i32.and
-                      local.tee $7
-                      i32.store
-                    else
-                      block ;; label = @10
-                        local.get $12
-                        i32.const 3668
-                        i32.load
-                        i32.lt_u
-                        if ;; label = @11
-                          call $fimport$10
-                        end
-                        local.get $12
-                        i32.const 12
-                        i32.add
-                        local.tee $0
-                        i32.load
-                        local.get $9
-                        i32.eq
-                        if ;; label = @11
-                          block ;; label = @12
-                            local.get $0
-                            local.get $4
-                            i32.store
-                            local.get $2
-                            local.get $12
-                            i32.store
-                            local.get $8
-                            local.set $7
-                          end
-                        else
-                          call $fimport$10
-                        end
-                      end
-                    end
-                    local.get $9
-                    local.get $3
-                    i32.const 3
-                    i32.or
-                    i32.store offset=4
-                    local.get $9
-                    local.get $3
-                    i32.add
-                    local.tee $4
-                    local.get $11
-                    i32.const 3
-                    i32.shl
-                    local.get $3
-                    i32.sub
-                    local.tee $11
-                    i32.const 1
-                    i32.or
-                    i32.store offset=4
-                    local.get $4
-                    local.get $11
-                    i32.add
-                    local.get $11
-                    i32.store
-                    local.get $16
-                    if ;; label = @9
-                      block ;; label = @10
-                        i32.const 3672
-                        i32.load
-                        local.set $9
-                        local.get $16
-                        i32.const 3
-                        i32.shr_u
-                        local.tee $0
-                        i32.const 1
-                        i32.shl
-                        i32.const 2
-                        i32.shl
-                        i32.const 3692
-                        i32.add
-                        local.set $2
-                        local.get $7
-                        i32.const 1
-                        local.get $0
-                        i32.shl
-                        local.tee $0
-                        i32.and
-                        if ;; label = @11
-                          local.get $2
-                          i32.const 8
-                          i32.add
-                          local.tee $3
-                          i32.load
-                          local.tee $0
-                          i32.const 3668
-                          i32.load
-                          i32.lt_u
-                          if ;; label = @12
-                            call $fimport$10
-                          else
-                            block ;; label = @13
-                              local.get $3
-                              local.set $6
-                              local.get $0
-                              local.set $1
-                            end
-                          end
-                        else
-                          block ;; label = @12
-                            i32.const 3652
-                            local.get $7
-                            local.get $0
-                            i32.or
-                            i32.store
-                            local.get $2
-                            i32.const 8
-                            i32.add
-                            local.set $6
-                            local.get $2
-                            local.set $1
-                          end
-                        end
-                        local.get $6
-                        local.get $9
-                        i32.store
-                        local.get $1
-                        local.get $9
-                        i32.store offset=12
-                        local.get $9
-                        local.get $1
-                        i32.store offset=8
-                        local.get $9
-                        local.get $2
-                        i32.store offset=12
-                      end
-                    end
-                    i32.const 3660
-                    local.get $11
-                    i32.store
-                    i32.const 3672
-                    local.get $4
-                    i32.store
-                    local.get $14
-                    global.set $global$1
-                    local.get $5
-                    return
-                  end
-                end
-                i32.const 3656
-                i32.load
-                local.tee $6
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $6
-                    i32.const 0
-                    local.get $6
-                    i32.sub
-                    i32.and
-                    i32.const -1
-                    i32.add
-                    local.tee $0
-                    i32.const 12
-                    i32.shr_u
-                    i32.const 16
-                    i32.and
-                    local.set $2
-                    local.get $0
-                    local.get $2
-                    i32.shr_u
-                    local.tee $1
-                    i32.const 5
-                    i32.shr_u
-                    i32.const 8
-                    i32.and
-                    local.tee $0
-                    local.get $2
-                    i32.or
-                    local.get $1
-                    local.get $0
-                    i32.shr_u
-                    local.tee $1
-                    i32.const 2
-                    i32.shr_u
-                    i32.const 4
-                    i32.and
-                    local.tee $0
-                    i32.or
-                    local.get $1
-                    local.get $0
-                    i32.shr_u
-                    local.tee $1
-                    i32.const 1
-                    i32.shr_u
-                    i32.const 2
-                    i32.and
-                    local.tee $0
-                    i32.or
-                    local.get $1
-                    local.get $0
-                    i32.shr_u
-                    local.tee $1
-                    i32.const 1
-                    i32.shr_u
-                    i32.const 1
-                    i32.and
-                    local.tee $0
-                    i32.or
-                    local.get $1
-                    local.get $0
-                    i32.shr_u
-                    i32.add
-                    i32.const 2
-                    i32.shl
-                    i32.const 3956
-                    i32.add
-                    i32.load
-                    local.tee $2
-                    i32.load offset=4
-                    i32.const -8
-                    i32.and
-                    local.get $3
-                    i32.sub
-                    local.set $9
-                    local.get $2
-                    local.set $1
-                    loop $label$25 ;; label = @9
-                      block $label$26 ;; label = @10
-                        local.get $1
-                        i32.load offset=16
-                        local.tee $0
-                        i32.eqz
-                        if ;; label = @11
-                          local.get $1
-                          i32.load offset=20
-                          local.tee $0
-                          i32.eqz
-                          br_if 1 (;@10;)
-                        end
-                        local.get $0
-                        i32.load offset=4
-                        i32.const -8
-                        i32.and
-                        local.get $3
-                        i32.sub
-                        local.tee $1
-                        local.get $9
-                        i32.lt_u
-                        local.tee $7
-                        if ;; label = @11
-                          local.get $1
-                          local.set $9
-                        end
-                        local.get $0
-                        local.set $1
-                        local.get $7
-                        if ;; label = @11
-                          local.get $0
-                          local.set $2
-                        end
-                        br 1 (;@9;)
-                      end
-                    end
-                    local.get $2
-                    i32.const 3668
-                    i32.load
-                    local.tee $12
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                    local.get $2
-                    local.get $2
-                    local.get $3
-                    i32.add
-                    local.tee $13
-                    i32.ge_u
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                    local.get $2
-                    i32.load offset=24
-                    local.set $15
-                    block $label$32 ;; label = @9
-                      local.get $2
-                      i32.load offset=12
-                      local.tee $0
-                      local.get $2
-                      i32.eq
-                      if ;; label = @10
-                        block ;; label = @11
-                          local.get $2
-                          i32.const 20
-                          i32.add
-                          local.tee $1
-                          i32.load
-                          local.tee $0
-                          i32.eqz
-                          if ;; label = @12
-                            local.get $2
-                            i32.const 16
-                            i32.add
-                            local.tee $1
-                            i32.load
-                            local.tee $0
-                            i32.eqz
-                            if ;; label = @13
-                              block ;; label = @14
-                                i32.const 0
-                                local.set $4
-                                br 5 (;@9;)
-                              end
-                            end
-                          end
-                          loop $label$36 ;; label = @12
-                            local.get $0
-                            i32.const 20
-                            i32.add
-                            local.tee $11
-                            i32.load
-                            local.tee $7
-                            if ;; label = @13
-                              block ;; label = @14
-                                local.get $7
-                                local.set $0
-                                local.get $11
-                                local.set $1
-                                br 2 (;@12;)
-                              end
-                            end
-                            local.get $0
-                            i32.const 16
-                            i32.add
-                            local.tee $11
-                            i32.load
-                            local.tee $7
-                            if ;; label = @13
-                              block ;; label = @14
-                                local.get $7
-                                local.set $0
-                                local.get $11
-                                local.set $1
-                                br 2 (;@12;)
-                              end
-                            end
-                          end
-                          local.get $1
-                          local.get $12
-                          i32.lt_u
-                          if ;; label = @12
-                            call $fimport$10
-                          else
-                            block ;; label = @13
-                              local.get $1
-                              i32.const 0
-                              i32.store
-                              local.get $0
-                              local.set $4
-                            end
-                          end
-                        end
-                      else
-                        block ;; label = @11
-                          local.get $2
-                          i32.load offset=8
-                          local.tee $11
-                          local.get $12
-                          i32.lt_u
-                          if ;; label = @12
-                            call $fimport$10
-                          end
-                          local.get $11
-                          i32.const 12
-                          i32.add
-                          local.tee $7
-                          i32.load
-                          local.get $2
-                          i32.ne
-                          if ;; label = @12
-                            call $fimport$10
-                          end
-                          local.get $0
-                          i32.const 8
-                          i32.add
-                          local.tee $1
-                          i32.load
-                          local.get $2
-                          i32.eq
-                          if ;; label = @12
-                            block ;; label = @13
-                              local.get $7
-                              local.get $0
-                              i32.store
-                              local.get $1
-                              local.get $11
-                              i32.store
-                              local.get $0
-                              local.set $4
-                            end
-                          else
-                            call $fimport$10
-                          end
-                        end
-                      end
-                    end
-                    block $label$46 ;; label = @9
-                      local.get $15
-                      if ;; label = @10
-                        block ;; label = @11
-                          local.get $2
-                          local.get $2
-                          i32.load offset=28
-                          local.tee $1
-                          i32.const 2
-                          i32.shl
-                          i32.const 3956
-                          i32.add
-                          local.tee $0
-                          i32.load
-                          i32.eq
-                          if ;; label = @12
-                            block ;; label = @13
-                              local.get $0
-                              local.get $4
-                              i32.store
-                              local.get $4
-                              i32.eqz
-                              if ;; label = @14
-                                block ;; label = @15
-                                  i32.const 3656
-                                  local.get $6
-                                  i32.const 1
-                                  local.get $1
-                                  i32.shl
-                                  i32.const -1
-                                  i32.xor
-                                  i32.and
-                                  i32.store
-                                  br 6 (;@9;)
-                                end
-                              end
-                            end
-                          else
-                            block ;; label = @13
-                              local.get $15
-                              i32.const 3668
-                              i32.load
-                              i32.lt_u
-                              if ;; label = @14
-                                call $fimport$10
-                              end
-                              local.get $15
-                              i32.const 16
-                              i32.add
-                              local.tee $0
-                              i32.load
-                              local.get $2
-                              i32.eq
-                              if ;; label = @14
-                                local.get $0
-                                local.get $4
-                                i32.store
-                              else
-                                local.get $15
-                                local.get $4
-                                i32.store offset=20
-                              end
-                              local.get $4
-                              i32.eqz
-                              br_if 4 (;@9;)
-                            end
-                          end
-                          local.get $4
-                          i32.const 3668
-                          i32.load
-                          local.tee $0
-                          i32.lt_u
-                          if ;; label = @12
-                            call $fimport$10
-                          end
-                          local.get $4
-                          local.get $15
-                          i32.store offset=24
-                          local.get $2
-                          i32.load offset=16
-                          local.tee $1
-                          if ;; label = @12
-                            local.get $1
-                            local.get $0
-                            i32.lt_u
-                            if ;; label = @13
-                              call $fimport$10
-                            else
-                              block ;; label = @14
-                                local.get $4
-                                local.get $1
-                                i32.store offset=16
-                                local.get $1
-                                local.get $4
-                                i32.store offset=24
-                              end
-                            end
-                          end
-                          local.get $2
-                          i32.load offset=20
-                          local.tee $0
-                          if ;; label = @12
-                            local.get $0
-                            i32.const 3668
-                            i32.load
-                            i32.lt_u
-                            if ;; label = @13
-                              call $fimport$10
-                            else
-                              block ;; label = @14
-                                local.get $4
-                                local.get $0
-                                i32.store offset=20
-                                local.get $0
-                                local.get $4
-                                i32.store offset=24
-                              end
-                            end
-                          end
-                        end
-                      end
-                    end
-                    local.get $9
-                    i32.const 16
-                    i32.lt_u
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $2
-                        local.get $9
-                        local.get $3
-                        i32.add
-                        local.tee $0
-                        i32.const 3
-                        i32.or
-                        i32.store offset=4
-                        local.get $2
-                        local.get $0
-                        i32.add
-                        i32.const 4
-                        i32.add
-                        local.tee $0
-                        local.get $0
-                        i32.load
-                        i32.const 1
-                        i32.or
-                        i32.store
-                      end
-                    else
-                      block ;; label = @10
-                        local.get $2
-                        local.get $3
-                        i32.const 3
-                        i32.or
-                        i32.store offset=4
-                        local.get $13
-                        local.get $9
-                        i32.const 1
-                        i32.or
-                        i32.store offset=4
-                        local.get $13
-                        local.get $9
-                        i32.add
-                        local.get $9
-                        i32.store
-                        local.get $16
-                        if ;; label = @11
-                          block ;; label = @12
-                            i32.const 3672
-                            i32.load
-                            local.set $7
-                            local.get $16
-                            i32.const 3
-                            i32.shr_u
-                            local.tee $0
-                            i32.const 1
-                            i32.shl
-                            i32.const 2
-                            i32.shl
-                            i32.const 3692
-                            i32.add
-                            local.set $3
-                            local.get $8
-                            i32.const 1
-                            local.get $0
-                            i32.shl
-                            local.tee $0
-                            i32.and
-                            if ;; label = @13
-                              local.get $3
-                              i32.const 8
-                              i32.add
-                              local.tee $1
-                              i32.load
-                              local.tee $0
-                              i32.const 3668
-                              i32.load
-                              i32.lt_u
-                              if ;; label = @14
-                                call $fimport$10
-                              else
-                                block ;; label = @15
-                                  local.get $1
-                                  local.set $10
-                                  local.get $0
-                                  local.set $5
-                                end
-                              end
-                            else
-                              block ;; label = @14
-                                i32.const 3652
-                                local.get $8
-                                local.get $0
-                                i32.or
-                                i32.store
-                                local.get $3
-                                i32.const 8
-                                i32.add
-                                local.set $10
-                                local.get $3
-                                local.set $5
-                              end
-                            end
-                            local.get $10
-                            local.get $7
-                            i32.store
-                            local.get $5
-                            local.get $7
-                            i32.store offset=12
-                            local.get $7
-                            local.get $5
-                            i32.store offset=8
-                            local.get $7
-                            local.get $3
-                            i32.store offset=12
-                          end
-                        end
-                        i32.const 3660
-                        local.get $9
-                        i32.store
-                        i32.const 3672
-                        local.get $13
-                        i32.store
-                      end
-                    end
-                    local.get $14
-                    global.set $global$1
-                    local.get $2
-                    i32.const 8
-                    i32.add
-                    return
-                  end
-                else
-                  local.get $3
-                  local.set $0
-                end
-              end
-            else
-              local.get $3
-              local.set $0
-            end
-          end
-        else
-          local.get $0
-          i32.const -65
-          i32.gt_u
-          if ;; label = @4
-            i32.const -1
-            local.set $0
-          else
-            block ;; label = @5
-              local.get $0
-              i32.const 11
-              i32.add
-              local.tee $0
-              i32.const -8
-              i32.and
-              local.set $7
-              i32.const 3656
-              i32.load
-              local.tee $5
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $0
-                  i32.const 8
-                  i32.shr_u
-                  local.tee $0
-                  if (result i32) ;; label = @8
-                    local.get $7
-                    i32.const 16777215
-                    i32.gt_u
-                    if (result i32) ;; label = @9
-                      i32.const 31
-                    else
-                      local.get $7
-                      i32.const 14
-                      local.get $0
-                      local.get $0
-                      i32.const 1048320
-                      i32.add
-                      i32.const 16
-                      i32.shr_u
-                      i32.const 8
-                      i32.and
-                      local.tee $3
-                      i32.shl
-                      local.tee $1
-                      i32.const 520192
-                      i32.add
-                      i32.const 16
-                      i32.shr_u
-                      i32.const 4
-                      i32.and
-                      local.tee $0
-                      local.get $3
-                      i32.or
-                      local.get $1
-                      local.get $0
-                      i32.shl
-                      local.tee $1
-                      i32.const 245760
-                      i32.add
-                      i32.const 16
-                      i32.shr_u
-                      i32.const 2
-                      i32.and
-                      local.tee $0
-                      i32.or
-                      i32.sub
-                      local.get $1
-                      local.get $0
-                      i32.shl
-                      i32.const 15
-                      i32.shr_u
-                      i32.add
-                      local.tee $0
-                      i32.const 7
-                      i32.add
-                      i32.shr_u
-                      i32.const 1
-                      i32.and
-                      local.get $0
-                      i32.const 1
-                      i32.shl
-                      i32.or
-                    end
-                  else
-                    i32.const 0
-                  end
-                  local.set $17
-                  i32.const 0
-                  local.get $7
-                  i32.sub
-                  local.set $3
-                  block $label$78 ;; label = @8
-                    block $label$79 ;; label = @9
-                      block $label$80 ;; label = @10
-                        local.get $17
-                        i32.const 2
-                        i32.shl
-                        i32.const 3956
-                        i32.add
-                        i32.load
-                        local.tee $1
-                        if ;; label = @11
-                          block ;; label = @12
-                            i32.const 25
-                            local.get $17
-                            i32.const 1
-                            i32.shr_u
-                            i32.sub
-                            local.set $0
-                            i32.const 0
-                            local.set $4
-                            local.get $7
-                            local.get $17
-                            i32.const 31
-                            i32.eq
-                            if (result i32) ;; label = @13
-                              i32.const 0
-                            else
-                              local.get $0
-                            end
-                            i32.shl
-                            local.set $10
-                            i32.const 0
-                            local.set $0
-                            loop $label$84 ;; label = @13
-                              local.get $1
-                              i32.load offset=4
-                              i32.const -8
-                              i32.and
-                              local.get $7
-                              i32.sub
-                              local.tee $6
-                              local.get $3
-                              i32.lt_u
-                              if ;; label = @14
-                                local.get $6
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $6
-                                    local.set $3
-                                    local.get $1
-                                    local.set $0
-                                  end
-                                else
-                                  block ;; label = @16
-                                    i32.const 0
-                                    local.set $3
-                                    local.get $1
-                                    local.set $0
-                                    br 7 (;@9;)
-                                  end
-                                end
-                              end
-                              local.get $1
-                              i32.load offset=20
-                              local.tee $19
-                              i32.eqz
-                              local.get $19
-                              local.get $1
-                              i32.const 16
-                              i32.add
-                              local.get $10
-                              i32.const 31
-                              i32.shr_u
-                              i32.const 2
-                              i32.shl
-                              i32.add
-                              i32.load
-                              local.tee $6
-                              i32.eq
-                              i32.or
-                              if (result i32) ;; label = @14
-                                local.get $4
-                              else
-                                local.get $19
-                              end
-                              local.set $1
-                              local.get $10
-                              local.get $6
-                              i32.eqz
-                              local.tee $4
-                              i32.const 1
-                              i32.and
-                              i32.const 1
-                              i32.xor
-                              i32.shl
-                              local.set $10
-                              local.get $4
-                              if ;; label = @14
-                                block ;; label = @15
-                                  local.get $1
-                                  local.set $4
-                                  local.get $0
-                                  local.set $1
-                                  br 5 (;@10;)
-                                end
-                              else
-                                block ;; label = @15
-                                  local.get $1
-                                  local.set $4
-                                  local.get $6
-                                  local.set $1
-                                  br 2 (;@13;)
-                                end
-                              end
-                            end
-                          end
-                        else
-                          block ;; label = @12
-                            i32.const 0
-                            local.set $4
-                            i32.const 0
-                            local.set $1
-                          end
-                        end
-                      end
-                      local.get $4
-                      i32.eqz
-                      local.get $1
-                      i32.eqz
-                      i32.and
-                      if (result i32) ;; label = @10
-                        block (result i32) ;; label = @11
-                          local.get $5
-                          i32.const 2
-                          local.get $17
-                          i32.shl
-                          local.tee $0
-                          i32.const 0
-                          local.get $0
-                          i32.sub
-                          i32.or
-                          i32.and
-                          local.tee $0
-                          i32.eqz
-                          if ;; label = @12
-                            block ;; label = @13
-                              local.get $7
-                              local.set $0
-                              br 11 (;@2;)
-                            end
-                          end
-                          local.get $0
-                          i32.const 0
-                          local.get $0
-                          i32.sub
-                          i32.and
-                          i32.const -1
-                          i32.add
-                          local.tee $0
-                          i32.const 12
-                          i32.shr_u
-                          i32.const 16
-                          i32.and
-                          local.set $10
-                          local.get $0
-                          local.get $10
-                          i32.shr_u
-                          local.tee $4
-                          i32.const 5
-                          i32.shr_u
-                          i32.const 8
-                          i32.and
-                          local.tee $0
-                          local.get $10
-                          i32.or
-                          local.get $4
-                          local.get $0
-                          i32.shr_u
-                          local.tee $4
-                          i32.const 2
-                          i32.shr_u
-                          i32.const 4
-                          i32.and
-                          local.tee $0
-                          i32.or
-                          local.get $4
-                          local.get $0
-                          i32.shr_u
-                          local.tee $4
-                          i32.const 1
-                          i32.shr_u
-                          i32.const 2
-                          i32.and
-                          local.tee $0
-                          i32.or
-                          local.get $4
-                          local.get $0
-                          i32.shr_u
-                          local.tee $4
-                          i32.const 1
-                          i32.shr_u
-                          i32.const 1
-                          i32.and
-                          local.tee $0
-                          i32.or
-                          local.get $4
-                          local.get $0
-                          i32.shr_u
-                          i32.add
-                          i32.const 2
-                          i32.shl
-                          i32.const 3956
-                          i32.add
-                          i32.load
-                        end
-                      else
-                        local.get $4
-                      end
-                      local.tee $0
-                      br_if 0 (;@9;)
-                      local.get $1
-                      local.set $4
-                      br 1 (;@8;)
-                    end
-                    loop $label$96 ;; label = @9
-                      local.get $0
-                      i32.load offset=4
-                      i32.const -8
-                      i32.and
-                      local.get $7
-                      i32.sub
-                      local.tee $4
-                      local.get $3
-                      i32.lt_u
-                      local.tee $10
-                      if ;; label = @10
-                        local.get $4
-                        local.set $3
-                      end
-                      local.get $10
-                      if ;; label = @10
-                        local.get $0
-                        local.set $1
-                      end
-                      local.get $0
-                      i32.load offset=16
-                      local.tee $4
-                      if ;; label = @10
-                        block ;; label = @11
-                          local.get $4
-                          local.set $0
-                          br 2 (;@9;)
-                        end
-                      end
-                      local.get $0
-                      i32.load offset=20
-                      local.tee $0
-                      br_if 0 (;@9;)
-                      local.get $1
-                      local.set $4
-                    end
-                  end
-                  local.get $4
-                  if ;; label = @8
-                    local.get $3
-                    i32.const 3660
-                    i32.load
-                    local.get $7
-                    i32.sub
-                    i32.lt_u
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $4
-                        i32.const 3668
-                        i32.load
-                        local.tee $12
-                        i32.lt_u
-                        if ;; label = @11
-                          call $fimport$10
-                        end
-                        local.get $4
-                        local.get $4
-                        local.get $7
-                        i32.add
-                        local.tee $6
-                        i32.ge_u
-                        if ;; label = @11
-                          call $fimport$10
-                        end
-                        local.get $4
-                        i32.load offset=24
-                        local.set $10
-                        block $label$104 ;; label = @11
-                          local.get $4
-                          i32.load offset=12
-                          local.tee $0
-                          local.get $4
-                          i32.eq
-                          if ;; label = @12
-                            block ;; label = @13
-                              local.get $4
-                              i32.const 20
-                              i32.add
-                              local.tee $1
-                              i32.load
-                              local.tee $0
-                              i32.eqz
-                              if ;; label = @14
-                                local.get $4
-                                i32.const 16
-                                i32.add
-                                local.tee $1
-                                i32.load
-                                local.tee $0
-                                i32.eqz
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    i32.const 0
-                                    local.set $13
-                                    br 5 (;@11;)
-                                  end
-                                end
-                              end
-                              loop $label$108 ;; label = @14
-                                local.get $0
-                                i32.const 20
-                                i32.add
-                                local.tee $9
-                                i32.load
-                                local.tee $11
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $11
-                                    local.set $0
-                                    local.get $9
-                                    local.set $1
-                                    br 2 (;@14;)
-                                  end
-                                end
-                                local.get $0
-                                i32.const 16
-                                i32.add
-                                local.tee $9
-                                i32.load
-                                local.tee $11
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $11
-                                    local.set $0
-                                    local.get $9
-                                    local.set $1
-                                    br 2 (;@14;)
-                                  end
-                                end
-                              end
-                              local.get $1
-                              local.get $12
-                              i32.lt_u
-                              if ;; label = @14
-                                call $fimport$10
-                              else
-                                block ;; label = @15
-                                  local.get $1
-                                  i32.const 0
-                                  i32.store
-                                  local.get $0
-                                  local.set $13
-                                end
-                              end
-                            end
-                          else
-                            block ;; label = @13
-                              local.get $4
-                              i32.load offset=8
-                              local.tee $9
-                              local.get $12
-                              i32.lt_u
-                              if ;; label = @14
-                                call $fimport$10
-                              end
-                              local.get $9
-                              i32.const 12
-                              i32.add
-                              local.tee $11
-                              i32.load
-                              local.get $4
-                              i32.ne
-                              if ;; label = @14
-                                call $fimport$10
-                              end
-                              local.get $0
-                              i32.const 8
-                              i32.add
-                              local.tee $1
-                              i32.load
-                              local.get $4
-                              i32.eq
-                              if ;; label = @14
-                                block ;; label = @15
-                                  local.get $11
-                                  local.get $0
-                                  i32.store
-                                  local.get $1
-                                  local.get $9
-                                  i32.store
-                                  local.get $0
-                                  local.set $13
-                                end
-                              else
-                                call $fimport$10
-                              end
-                            end
-                          end
-                        end
-                        block $label$118 ;; label = @11
-                          local.get $10
-                          if ;; label = @12
-                            block ;; label = @13
-                              local.get $4
-                              local.get $4
-                              i32.load offset=28
-                              local.tee $1
-                              i32.const 2
-                              i32.shl
-                              i32.const 3956
-                              i32.add
-                              local.tee $0
-                              i32.load
-                              i32.eq
-                              if ;; label = @14
-                                block ;; label = @15
-                                  local.get $0
-                                  local.get $13
-                                  i32.store
-                                  local.get $13
-                                  i32.eqz
-                                  if ;; label = @16
-                                    block ;; label = @17
-                                      i32.const 3656
-                                      local.get $5
-                                      i32.const 1
-                                      local.get $1
-                                      i32.shl
-                                      i32.const -1
-                                      i32.xor
-                                      i32.and
-                                      local.tee $2
-                                      i32.store
-                                      br 6 (;@11;)
-                                    end
-                                  end
-                                end
-                              else
-                                block ;; label = @15
-                                  local.get $10
-                                  i32.const 3668
-                                  i32.load
-                                  i32.lt_u
-                                  if ;; label = @16
-                                    call $fimport$10
-                                  end
-                                  local.get $10
-                                  i32.const 16
-                                  i32.add
-                                  local.tee $0
-                                  i32.load
-                                  local.get $4
-                                  i32.eq
-                                  if ;; label = @16
-                                    local.get $0
-                                    local.get $13
-                                    i32.store
-                                  else
-                                    local.get $10
-                                    local.get $13
-                                    i32.store offset=20
-                                  end
-                                  local.get $13
-                                  i32.eqz
-                                  if ;; label = @16
-                                    block ;; label = @17
-                                      local.get $5
-                                      local.set $2
-                                      br 6 (;@11;)
-                                    end
-                                  end
-                                end
-                              end
-                              local.get $13
-                              i32.const 3668
-                              i32.load
-                              local.tee $0
-                              i32.lt_u
-                              if ;; label = @14
-                                call $fimport$10
-                              end
-                              local.get $13
-                              local.get $10
-                              i32.store offset=24
-                              local.get $4
-                              i32.load offset=16
-                              local.tee $1
-                              if ;; label = @14
-                                local.get $1
-                                local.get $0
-                                i32.lt_u
-                                if ;; label = @15
-                                  call $fimport$10
-                                else
-                                  block ;; label = @16
-                                    local.get $13
-                                    local.get $1
-                                    i32.store offset=16
-                                    local.get $1
-                                    local.get $13
-                                    i32.store offset=24
-                                  end
-                                end
-                              end
-                              local.get $4
-                              i32.load offset=20
-                              local.tee $0
-                              if ;; label = @14
-                                local.get $0
-                                i32.const 3668
-                                i32.load
-                                i32.lt_u
-                                if ;; label = @15
-                                  call $fimport$10
-                                else
-                                  block ;; label = @16
-                                    local.get $13
-                                    local.get $0
-                                    i32.store offset=20
-                                    local.get $0
-                                    local.get $13
-                                    i32.store offset=24
-                                    local.get $5
-                                    local.set $2
-                                  end
-                                end
-                              else
-                                local.get $5
-                                local.set $2
-                              end
-                            end
-                          else
-                            local.get $5
-                            local.set $2
-                          end
-                        end
-                        block $label$136 ;; label = @11
-                          local.get $3
-                          i32.const 16
-                          i32.lt_u
-                          if ;; label = @12
-                            block ;; label = @13
-                              local.get $4
-                              local.get $3
-                              local.get $7
-                              i32.add
-                              local.tee $0
-                              i32.const 3
-                              i32.or
-                              i32.store offset=4
-                              local.get $4
-                              local.get $0
-                              i32.add
-                              i32.const 4
-                              i32.add
-                              local.tee $0
-                              local.get $0
-                              i32.load
-                              i32.const 1
-                              i32.or
-                              i32.store
-                            end
-                          else
-                            block ;; label = @13
-                              local.get $4
-                              local.get $7
-                              i32.const 3
-                              i32.or
-                              i32.store offset=4
-                              local.get $6
-                              local.get $3
-                              i32.const 1
-                              i32.or
-                              i32.store offset=4
-                              local.get $6
-                              local.get $3
-                              i32.add
-                              local.get $3
-                              i32.store
-                              local.get $3
-                              i32.const 3
-                              i32.shr_u
-                              local.set $0
-                              local.get $3
-                              i32.const 256
-                              i32.lt_u
-                              if ;; label = @14
-                                block ;; label = @15
-                                  local.get $0
-                                  i32.const 1
-                                  i32.shl
-                                  i32.const 2
-                                  i32.shl
-                                  i32.const 3692
-                                  i32.add
-                                  local.set $3
-                                  i32.const 3652
-                                  i32.load
-                                  local.tee $1
-                                  i32.const 1
-                                  local.get $0
-                                  i32.shl
-                                  local.tee $0
-                                  i32.and
-                                  if ;; label = @16
-                                    local.get $3
-                                    i32.const 8
-                                    i32.add
-                                    local.tee $1
-                                    i32.load
-                                    local.tee $0
-                                    i32.const 3668
-                                    i32.load
-                                    i32.lt_u
-                                    if ;; label = @17
-                                      call $fimport$10
-                                    else
-                                      block ;; label = @18
-                                        local.get $1
-                                        local.set $16
-                                        local.get $0
-                                        local.set $8
-                                      end
-                                    end
-                                  else
-                                    block ;; label = @17
-                                      i32.const 3652
-                                      local.get $1
-                                      local.get $0
-                                      i32.or
-                                      i32.store
-                                      local.get $3
-                                      i32.const 8
-                                      i32.add
-                                      local.set $16
-                                      local.get $3
-                                      local.set $8
-                                    end
-                                  end
-                                  local.get $16
-                                  local.get $6
-                                  i32.store
-                                  local.get $8
-                                  local.get $6
-                                  i32.store offset=12
-                                  local.get $6
-                                  local.get $8
-                                  i32.store offset=8
-                                  local.get $6
-                                  local.get $3
-                                  i32.store offset=12
-                                  br 4 (;@11;)
-                                end
-                              end
-                              local.get $3
-                              i32.const 8
-                              i32.shr_u
-                              local.tee $0
-                              if (result i32) ;; label = @14
-                                local.get $3
-                                i32.const 16777215
-                                i32.gt_u
-                                if (result i32) ;; label = @15
-                                  i32.const 31
-                                else
-                                  local.get $3
-                                  i32.const 14
-                                  local.get $0
-                                  local.get $0
-                                  i32.const 1048320
-                                  i32.add
-                                  i32.const 16
-                                  i32.shr_u
-                                  i32.const 8
-                                  i32.and
-                                  local.tee $5
-                                  i32.shl
-                                  local.tee $1
-                                  i32.const 520192
-                                  i32.add
-                                  i32.const 16
-                                  i32.shr_u
-                                  i32.const 4
-                                  i32.and
-                                  local.tee $0
-                                  local.get $5
-                                  i32.or
-                                  local.get $1
-                                  local.get $0
-                                  i32.shl
-                                  local.tee $1
-                                  i32.const 245760
-                                  i32.add
-                                  i32.const 16
-                                  i32.shr_u
-                                  i32.const 2
-                                  i32.and
-                                  local.tee $0
-                                  i32.or
-                                  i32.sub
-                                  local.get $1
-                                  local.get $0
-                                  i32.shl
-                                  i32.const 15
-                                  i32.shr_u
-                                  i32.add
-                                  local.tee $0
-                                  i32.const 7
-                                  i32.add
-                                  i32.shr_u
-                                  i32.const 1
-                                  i32.and
-                                  local.get $0
-                                  i32.const 1
-                                  i32.shl
-                                  i32.or
-                                end
-                              else
-                                i32.const 0
-                              end
-                              local.tee $5
-                              i32.const 2
-                              i32.shl
-                              i32.const 3956
-                              i32.add
-                              local.set $1
-                              local.get $6
-                              local.get $5
-                              i32.store offset=28
-                              local.get $6
-                              i32.const 16
-                              i32.add
-                              local.tee $0
-                              i32.const 0
-                              i32.store offset=4
-                              local.get $0
-                              i32.const 0
-                              i32.store
-                              local.get $2
-                              i32.const 1
-                              local.get $5
-                              i32.shl
-                              local.tee $0
-                              i32.and
-                              i32.eqz
-                              if ;; label = @14
-                                block ;; label = @15
-                                  i32.const 3656
-                                  local.get $2
-                                  local.get $0
-                                  i32.or
-                                  i32.store
-                                  local.get $1
-                                  local.get $6
-                                  i32.store
-                                  local.get $6
-                                  local.get $1
-                                  i32.store offset=24
-                                  local.get $6
-                                  local.get $6
-                                  i32.store offset=12
-                                  local.get $6
-                                  local.get $6
-                                  i32.store offset=8
-                                  br 4 (;@11;)
-                                end
-                              end
-                              local.get $1
-                              i32.load
-                              local.set $0
-                              i32.const 25
-                              local.get $5
-                              i32.const 1
-                              i32.shr_u
-                              i32.sub
-                              local.set $1
-                              local.get $3
-                              local.get $5
-                              i32.const 31
-                              i32.eq
-                              if (result i32) ;; label = @14
-                                i32.const 0
-                              else
-                                local.get $1
-                              end
-                              i32.shl
-                              local.set $5
-                              block $label$151 ;; label = @14
-                                block $label$152 ;; label = @15
-                                  block $label$153 ;; label = @16
-                                    loop $label$154 ;; label = @17
-                                      local.get $0
-                                      i32.load offset=4
-                                      i32.const -8
-                                      i32.and
-                                      local.get $3
-                                      i32.eq
-                                      br_if 2 (;@15;)
-                                      local.get $5
-                                      i32.const 1
-                                      i32.shl
-                                      local.set $2
-                                      local.get $0
-                                      i32.const 16
-                                      i32.add
-                                      local.get $5
-                                      i32.const 31
-                                      i32.shr_u
-                                      i32.const 2
-                                      i32.shl
-                                      i32.add
-                                      local.tee $5
-                                      i32.load
-                                      local.tee $1
-                                      i32.eqz
-                                      br_if 1 (;@16;)
-                                      local.get $2
-                                      local.set $5
-                                      local.get $1
-                                      local.set $0
-                                      br 0 (;@17;)
-                                    end
-                                  end
-                                  local.get $5
-                                  i32.const 3668
-                                  i32.load
-                                  i32.lt_u
-                                  if ;; label = @16
-                                    call $fimport$10
-                                  else
-                                    block ;; label = @17
-                                      local.get $5
-                                      local.get $6
-                                      i32.store
-                                      local.get $6
-                                      local.get $0
-                                      i32.store offset=24
-                                      local.get $6
-                                      local.get $6
-                                      i32.store offset=12
-                                      local.get $6
-                                      local.get $6
-                                      i32.store offset=8
-                                      br 6 (;@11;)
-                                    end
-                                  end
-                                  br 1 (;@14;)
-                                end
-                                local.get $0
-                                i32.const 8
-                                i32.add
-                                local.tee $3
-                                i32.load
-                                local.tee $2
-                                i32.const 3668
-                                i32.load
-                                local.tee $1
-                                i32.ge_u
-                                local.get $0
-                                local.get $1
-                                i32.ge_u
-                                i32.and
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $2
-                                    local.get $6
-                                    i32.store offset=12
-                                    local.get $3
-                                    local.get $6
-                                    i32.store
-                                    local.get $6
-                                    local.get $2
-                                    i32.store offset=8
-                                    local.get $6
-                                    local.get $0
-                                    i32.store offset=12
-                                    local.get $6
-                                    i32.const 0
-                                    i32.store offset=24
-                                  end
-                                else
-                                  call $fimport$10
-                                end
-                              end
-                            end
-                          end
-                        end
-                        local.get $14
-                        global.set $global$1
-                        local.get $4
-                        i32.const 8
-                        i32.add
-                        return
-                      end
-                    else
-                      local.get $7
-                      local.set $0
-                    end
-                  else
-                    local.get $7
-                    local.set $0
-                  end
-                end
-              else
-                local.get $7
-                local.set $0
-              end
-            end
-          end
-        end
-      end
-      i32.const 3660
-      i32.load
-      local.tee $1
-      local.get $0
-      i32.ge_u
-      if ;; label = @2
-        block ;; label = @3
-          i32.const 3672
-          i32.load
-          local.set $2
-          local.get $1
-          local.get $0
-          i32.sub
-          local.tee $3
-          i32.const 15
-          i32.gt_u
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 3672
-              local.get $2
-              local.get $0
-              i32.add
-              local.tee $1
-              i32.store
-              i32.const 3660
-              local.get $3
-              i32.store
-              local.get $1
-              local.get $3
-              i32.const 1
-              i32.or
-              i32.store offset=4
-              local.get $1
-              local.get $3
-              i32.add
-              local.get $3
-              i32.store
-              local.get $2
-              local.get $0
-              i32.const 3
-              i32.or
-              i32.store offset=4
-            end
-          else
-            block ;; label = @5
-              i32.const 3660
-              i32.const 0
-              i32.store
-              i32.const 3672
-              i32.const 0
-              i32.store
-              local.get $2
-              local.get $1
-              i32.const 3
-              i32.or
-              i32.store offset=4
-              local.get $2
-              local.get $1
-              i32.add
-              i32.const 4
-              i32.add
-              local.tee $0
-              local.get $0
-              i32.load
-              i32.const 1
-              i32.or
-              i32.store
-            end
-          end
-          local.get $14
-          global.set $global$1
-          local.get $2
-          i32.const 8
-          i32.add
-          return
-        end
-      end
-      i32.const 3664
-      i32.load
-      local.tee $10
-      local.get $0
-      i32.gt_u
-      if ;; label = @2
-        block ;; label = @3
-          i32.const 3664
-          local.get $10
-          local.get $0
-          i32.sub
-          local.tee $3
-          i32.store
-          i32.const 3676
-          i32.const 3676
-          i32.load
-          local.tee $2
-          local.get $0
-          i32.add
-          local.tee $1
-          i32.store
-          local.get $1
-          local.get $3
-          i32.const 1
-          i32.or
-          i32.store offset=4
-          local.get $2
-          local.get $0
-          i32.const 3
-          i32.or
-          i32.store offset=4
-          local.get $14
-          global.set $global$1
-          local.get $2
-          i32.const 8
-          i32.add
-          return
-        end
-      end
-      i32.const 4124
-      i32.load
-      if (result i32) ;; label = @2
-        i32.const 4132
-        i32.load
-      else
-        block (result i32) ;; label = @3
-          i32.const 4132
-          i32.const 4096
-          i32.store
-          i32.const 4128
-          i32.const 4096
-          i32.store
-          i32.const 4136
-          i32.const -1
-          i32.store
-          i32.const 4140
-          i32.const -1
-          i32.store
-          i32.const 4144
-          i32.const 0
-          i32.store
-          i32.const 4096
-          i32.const 0
-          i32.store
-          local.get $18
-          local.get $18
-          i32.const -16
-          i32.and
-          i32.const 1431655768
-          i32.xor
-          local.tee $1
-          i32.store
-          i32.const 4124
-          local.get $1
-          i32.store
-          i32.const 4096
-        end
-      end
-      local.tee $1
-      local.get $0
-      i32.const 47
-      i32.add
-      local.tee $13
-      i32.add
-      local.tee $8
-      i32.const 0
-      local.get $1
-      i32.sub
-      local.tee $4
-      i32.and
-      local.tee $6
-      local.get $0
-      i32.le_u
-      if ;; label = @2
-        block ;; label = @3
-          local.get $14
-          global.set $global$1
-          i32.const 0
-          return
-        end
-      end
-      i32.const 4092
-      i32.load
-      local.tee $2
-      if ;; label = @2
-        i32.const 4084
-        i32.load
-        local.tee $3
-        local.get $6
-        i32.add
-        local.tee $1
-        local.get $3
-        i32.le_u
-        local.get $1
-        local.get $2
-        i32.gt_u
-        i32.or
-        if ;; label = @3
-          block ;; label = @4
-            local.get $14
-            global.set $global$1
-            i32.const 0
-            return
-          end
-        end
-      end
-      local.get $0
-      i32.const 48
-      i32.add
-      local.set $7
-      block $label$171 ;; label = @2
-        block $label$172 ;; label = @3
-          i32.const 4096
-          i32.load
-          i32.const 4
-          i32.and
-          i32.eqz
-          if ;; label = @4
-            block ;; label = @5
-              block $label$174 ;; label = @6
-                block $label$175 ;; label = @7
-                  block $label$176 ;; label = @8
-                    i32.const 3676
-                    i32.load
-                    local.tee $3
-                    i32.eqz
-                    br_if 0 (;@8;)
-                    i32.const 4100
-                    local.set $2
-                    loop $label$177 ;; label = @9
-                      block $label$178 ;; label = @10
-                        local.get $2
-                        i32.load
-                        local.tee $1
-                        local.get $3
-                        i32.le_u
-                        if ;; label = @11
-                          local.get $1
-                          local.get $2
-                          i32.const 4
-                          i32.add
-                          local.tee $5
-                          i32.load
-                          i32.add
-                          local.get $3
-                          i32.gt_u
-                          br_if 1 (;@10;)
-                        end
-                        local.get $2
-                        i32.load offset=8
-                        local.tee $1
-                        i32.eqz
-                        br_if 2 (;@8;)
-                        local.get $1
-                        local.set $2
-                        br 1 (;@9;)
-                      end
-                    end
-                    local.get $8
-                    local.get $10
-                    i32.sub
-                    local.get $4
-                    i32.and
-                    local.tee $3
-                    i32.const 2147483647
-                    i32.lt_u
-                    if ;; label = @9
-                      local.get $3
-                      call $38
-                      local.tee $1
-                      local.get $2
-                      i32.load
-                      local.get $5
-                      i32.load
-                      i32.add
-                      i32.eq
-                      if ;; label = @10
-                        local.get $1
-                        i32.const -1
-                        i32.ne
-                        br_if 7 (;@3;)
-                      else
-                        block ;; label = @11
-                          local.get $1
-                          local.set $2
-                          local.get $3
-                          local.set $1
-                          br 4 (;@7;)
-                        end
-                      end
-                    end
-                    br 2 (;@6;)
-                  end
-                  i32.const 0
-                  call $38
-                  local.tee $1
-                  i32.const -1
-                  i32.ne
-                  if ;; label = @8
-                    block ;; label = @9
-                      i32.const 4128
-                      i32.load
-                      local.tee $2
-                      i32.const -1
-                      i32.add
-                      local.tee $5
-                      local.get $1
-                      local.tee $3
-                      i32.add
-                      i32.const 0
-                      local.get $2
-                      i32.sub
-                      i32.and
-                      local.get $3
-                      i32.sub
-                      local.set $2
-                      local.get $5
-                      local.get $3
-                      i32.and
-                      if (result i32) ;; label = @10
-                        local.get $2
-                      else
-                        i32.const 0
-                      end
-                      local.get $6
-                      i32.add
-                      local.tee $3
-                      i32.const 4084
-                      i32.load
-                      local.tee $5
-                      i32.add
-                      local.set $4
-                      local.get $3
-                      local.get $0
-                      i32.gt_u
-                      local.get $3
-                      i32.const 2147483647
-                      i32.lt_u
-                      i32.and
-                      if ;; label = @10
-                        block ;; label = @11
-                          i32.const 4092
-                          i32.load
-                          local.tee $2
-                          if ;; label = @12
-                            local.get $4
-                            local.get $5
-                            i32.le_u
-                            local.get $4
-                            local.get $2
-                            i32.gt_u
-                            i32.or
-                            br_if 6 (;@6;)
-                          end
-                          local.get $3
-                          call $38
-                          local.tee $2
-                          local.get $1
-                          i32.eq
-                          br_if 8 (;@3;)
-                          local.get $3
-                          local.set $1
-                          br 4 (;@7;)
-                        end
-                      end
-                    end
-                  end
-                  br 1 (;@6;)
-                end
-                i32.const 0
-                local.get $1
-                i32.sub
-                local.set $5
-                local.get $7
-                local.get $1
-                i32.gt_u
-                local.get $1
-                i32.const 2147483647
-                i32.lt_u
-                local.get $2
-                i32.const -1
-                i32.ne
-                i32.and
-                i32.and
-                if ;; label = @7
-                  local.get $13
-                  local.get $1
-                  i32.sub
-                  i32.const 4132
-                  i32.load
-                  local.tee $3
-                  i32.add
-                  i32.const 0
-                  local.get $3
-                  i32.sub
-                  i32.and
-                  local.tee $3
-                  i32.const 2147483647
-                  i32.lt_u
-                  if ;; label = @8
-                    local.get $3
-                    call $38
-                    i32.const -1
-                    i32.eq
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $5
-                        call $38
-                        drop
-                        br 4 (;@6;)
-                      end
-                    else
-                      local.get $3
-                      local.get $1
-                      i32.add
-                      local.set $3
-                    end
-                  else
-                    local.get $1
-                    local.set $3
-                  end
-                else
-                  local.get $1
-                  local.set $3
-                end
-                local.get $2
-                i32.const -1
-                i32.ne
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $2
-                    local.set $1
-                    br 5 (;@3;)
-                  end
-                end
-              end
-              i32.const 4096
-              i32.const 4096
-              i32.load
-              i32.const 4
-              i32.or
-              i32.store
-            end
-          end
-          local.get $6
-          i32.const 2147483647
-          i32.lt_u
-          if ;; label = @4
-            local.get $6
-            call $38
-            local.tee $1
-            i32.const 0
-            call $38
-            local.tee $3
-            i32.lt_u
-            local.get $1
-            i32.const -1
-            i32.ne
-            local.get $3
-            i32.const -1
-            i32.ne
-            i32.and
-            i32.and
-            if ;; label = @5
-              local.get $3
-              local.get $1
-              i32.sub
-              local.tee $3
-              local.get $0
-              i32.const 40
-              i32.add
-              i32.gt_u
-              br_if 2 (;@3;)
-            end
-          end
-          br 1 (;@2;)
-        end
-        i32.const 4084
-        i32.const 4084
-        i32.load
-        local.get $3
-        i32.add
-        local.tee $2
-        i32.store
-        local.get $2
-        i32.const 4088
-        i32.load
-        i32.gt_u
-        if ;; label = @3
-          i32.const 4088
-          local.get $2
-          i32.store
-        end
-        block $label$198 ;; label = @3
-          i32.const 3676
-          i32.load
-          local.tee $8
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 4100
-              local.set $2
-              block $label$200 ;; label = @6
-                block $label$201 ;; label = @7
-                  loop $label$202 ;; label = @8
-                    local.get $1
-                    local.get $2
-                    i32.load
-                    local.tee $4
-                    local.get $2
-                    i32.const 4
-                    i32.add
-                    local.tee $7
-                    i32.load
-                    local.tee $5
-                    i32.add
-                    i32.eq
-                    br_if 1 (;@7;)
-                    local.get $2
-                    i32.load offset=8
-                    local.tee $2
-                    br_if 0 (;@8;)
-                  end
-                  br 1 (;@6;)
-                end
-                local.get $2
-                i32.load offset=12
-                i32.const 8
-                i32.and
-                i32.eqz
-                if ;; label = @7
-                  local.get $8
-                  local.get $1
-                  i32.lt_u
-                  local.get $8
-                  local.get $4
-                  i32.ge_u
-                  i32.and
-                  if ;; label = @8
-                    block ;; label = @9
-                      local.get $7
-                      local.get $5
-                      local.get $3
-                      i32.add
-                      i32.store
-                      i32.const 3664
-                      i32.load
-                      local.set $5
-                      i32.const 0
-                      local.get $8
-                      i32.const 8
-                      i32.add
-                      local.tee $2
-                      i32.sub
-                      i32.const 7
-                      i32.and
-                      local.set $1
-                      i32.const 3676
-                      local.get $8
-                      local.get $2
-                      i32.const 7
-                      i32.and
-                      if (result i32) ;; label = @10
-                        local.get $1
-                      else
-                        i32.const 0
-                        local.tee $1
-                      end
-                      i32.add
-                      local.tee $2
-                      i32.store
-                      i32.const 3664
-                      local.get $3
-                      local.get $1
-                      i32.sub
-                      local.get $5
-                      i32.add
-                      local.tee $1
-                      i32.store
-                      local.get $2
-                      local.get $1
-                      i32.const 1
-                      i32.or
-                      i32.store offset=4
-                      local.get $2
-                      local.get $1
-                      i32.add
-                      i32.const 40
-                      i32.store offset=4
-                      i32.const 3680
-                      i32.const 4140
-                      i32.load
-                      i32.store
-                      br 6 (;@3;)
-                    end
-                  end
-                end
-              end
-              local.get $1
-              i32.const 3668
-              i32.load
-              local.tee $2
-              i32.lt_u
-              if ;; label = @6
-                block ;; label = @7
-                  i32.const 3668
-                  local.get $1
-                  i32.store
-                  local.get $1
-                  local.set $2
-                end
-              end
-              local.get $1
-              local.get $3
-              i32.add
-              local.set $10
-              i32.const 4100
-              local.set $5
-              block $label$208 ;; label = @6
-                block $label$209 ;; label = @7
-                  loop $label$210 ;; label = @8
-                    local.get $5
-                    i32.load
-                    local.get $10
-                    i32.eq
-                    br_if 1 (;@7;)
-                    local.get $5
-                    i32.load offset=8
-                    local.tee $5
-                    br_if 0 (;@8;)
-                    i32.const 4100
-                    local.set $5
-                  end
-                  br 1 (;@6;)
-                end
-                local.get $5
-                i32.load offset=12
-                i32.const 8
-                i32.and
-                if ;; label = @7
-                  i32.const 4100
-                  local.set $5
-                else
-                  block ;; label = @8
-                    local.get $5
-                    local.get $1
-                    i32.store
-                    local.get $5
-                    i32.const 4
-                    i32.add
-                    local.tee $5
-                    local.get $5
-                    i32.load
-                    local.get $3
-                    i32.add
-                    i32.store
-                    i32.const 0
-                    local.get $1
-                    i32.const 8
-                    i32.add
-                    local.tee $4
-                    i32.sub
-                    i32.const 7
-                    i32.and
-                    local.set $7
-                    i32.const 0
-                    local.get $10
-                    i32.const 8
-                    i32.add
-                    local.tee $5
-                    i32.sub
-                    i32.const 7
-                    i32.and
-                    local.set $3
-                    local.get $1
-                    local.get $4
-                    i32.const 7
-                    i32.and
-                    if (result i32) ;; label = @9
-                      local.get $7
-                    else
-                      i32.const 0
-                    end
-                    i32.add
-                    local.tee $13
-                    local.get $0
-                    i32.add
-                    local.set $6
-                    local.get $10
-                    local.get $5
-                    i32.const 7
-                    i32.and
-                    if (result i32) ;; label = @9
-                      local.get $3
-                    else
-                      i32.const 0
-                    end
-                    i32.add
-                    local.tee $4
-                    local.get $13
-                    i32.sub
-                    local.get $0
-                    i32.sub
-                    local.set $7
-                    local.get $13
-                    local.get $0
-                    i32.const 3
-                    i32.or
-                    i32.store offset=4
-                    block $label$217 ;; label = @9
-                      local.get $4
-                      local.get $8
-                      i32.eq
-                      if ;; label = @10
-                        block ;; label = @11
-                          i32.const 3664
-                          i32.const 3664
-                          i32.load
-                          local.get $7
-                          i32.add
-                          local.tee $0
-                          i32.store
-                          i32.const 3676
-                          local.get $6
-                          i32.store
-                          local.get $6
-                          local.get $0
-                          i32.const 1
-                          i32.or
-                          i32.store offset=4
-                        end
-                      else
-                        block ;; label = @11
-                          local.get $4
-                          i32.const 3672
-                          i32.load
-                          i32.eq
-                          if ;; label = @12
-                            block ;; label = @13
-                              i32.const 3660
-                              i32.const 3660
-                              i32.load
-                              local.get $7
-                              i32.add
-                              local.tee $0
-                              i32.store
-                              i32.const 3672
-                              local.get $6
-                              i32.store
-                              local.get $6
-                              local.get $0
-                              i32.const 1
-                              i32.or
-                              i32.store offset=4
-                              local.get $6
-                              local.get $0
-                              i32.add
-                              local.get $0
-                              i32.store
-                              br 4 (;@9;)
-                            end
-                          end
-                          local.get $4
-                          i32.load offset=4
-                          local.tee $0
-                          i32.const 3
-                          i32.and
-                          i32.const 1
-                          i32.eq
-                          if (result i32) ;; label = @12
-                            block (result i32) ;; label = @13
-                              local.get $0
-                              i32.const -8
-                              i32.and
-                              local.set $11
-                              local.get $0
-                              i32.const 3
-                              i32.shr_u
-                              local.set $1
-                              block $label$222 ;; label = @14
-                                local.get $0
-                                i32.const 256
-                                i32.lt_u
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $4
-                                    i32.load offset=12
-                                    local.set $5
-                                    block $label$224 ;; label = @17
-                                      local.get $4
-                                      i32.load offset=8
-                                      local.tee $3
-                                      local.get $1
-                                      i32.const 1
-                                      i32.shl
-                                      i32.const 2
-                                      i32.shl
-                                      i32.const 3692
-                                      i32.add
-                                      local.tee $0
-                                      i32.ne
-                                      if ;; label = @18
-                                        block ;; label = @19
-                                          local.get $3
-                                          local.get $2
-                                          i32.lt_u
-                                          if ;; label = @20
-                                            call $fimport$10
-                                          end
-                                          local.get $3
-                                          i32.load offset=12
-                                          local.get $4
-                                          i32.eq
-                                          br_if 2 (;@17;)
-                                          call $fimport$10
-                                        end
-                                      end
-                                    end
-                                    local.get $5
-                                    local.get $3
-                                    i32.eq
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        i32.const 3652
-                                        i32.const 3652
-                                        i32.load
-                                        i32.const 1
-                                        local.get $1
-                                        i32.shl
-                                        i32.const -1
-                                        i32.xor
-                                        i32.and
-                                        i32.store
-                                        br 4 (;@14;)
-                                      end
-                                    end
-                                    block $label$228 ;; label = @17
-                                      local.get $5
-                                      local.get $0
-                                      i32.eq
-                                      if ;; label = @18
-                                        local.get $5
-                                        i32.const 8
-                                        i32.add
-                                        local.set $20
-                                      else
-                                        block ;; label = @19
-                                          local.get $5
-                                          local.get $2
-                                          i32.lt_u
-                                          if ;; label = @20
-                                            call $fimport$10
-                                          end
-                                          local.get $5
-                                          i32.const 8
-                                          i32.add
-                                          local.tee $0
-                                          i32.load
-                                          local.get $4
-                                          i32.eq
-                                          if ;; label = @20
-                                            block ;; label = @21
-                                              local.get $0
-                                              local.set $20
-                                              br 4 (;@17;)
-                                            end
-                                          end
-                                          call $fimport$10
-                                        end
-                                      end
-                                    end
-                                    local.get $3
-                                    local.get $5
-                                    i32.store offset=12
-                                    local.get $20
-                                    local.get $3
-                                    i32.store
-                                  end
-                                else
-                                  block ;; label = @16
-                                    local.get $4
-                                    i32.load offset=24
-                                    local.set $8
-                                    block $label$234 ;; label = @17
-                                      local.get $4
-                                      i32.load offset=12
-                                      local.tee $0
-                                      local.get $4
-                                      i32.eq
-                                      if ;; label = @18
-                                        block ;; label = @19
-                                          local.get $4
-                                          i32.const 16
-                                          i32.add
-                                          local.tee $3
-                                          i32.const 4
-                                          i32.add
-                                          local.tee $1
-                                          i32.load
-                                          local.tee $0
-                                          i32.eqz
-                                          if ;; label = @20
-                                            local.get $3
-                                            i32.load
-                                            local.tee $0
-                                            if ;; label = @21
-                                              local.get $3
-                                              local.set $1
-                                            else
-                                              block ;; label = @22
-                                                i32.const 0
-                                                local.set $12
-                                                br 5 (;@17;)
-                                              end
-                                            end
-                                          end
-                                          loop $label$239 ;; label = @20
-                                            local.get $0
-                                            i32.const 20
-                                            i32.add
-                                            local.tee $5
-                                            i32.load
-                                            local.tee $3
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                local.get $3
-                                                local.set $0
-                                                local.get $5
-                                                local.set $1
-                                                br 2 (;@20;)
-                                              end
-                                            end
-                                            local.get $0
-                                            i32.const 16
-                                            i32.add
-                                            local.tee $5
-                                            i32.load
-                                            local.tee $3
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                local.get $3
-                                                local.set $0
-                                                local.get $5
-                                                local.set $1
-                                                br 2 (;@20;)
-                                              end
-                                            end
-                                          end
-                                          local.get $1
-                                          local.get $2
-                                          i32.lt_u
-                                          if ;; label = @20
-                                            call $fimport$10
-                                          else
-                                            block ;; label = @21
-                                              local.get $1
-                                              i32.const 0
-                                              i32.store
-                                              local.get $0
-                                              local.set $12
-                                            end
-                                          end
-                                        end
-                                      else
-                                        block ;; label = @19
-                                          local.get $4
-                                          i32.load offset=8
-                                          local.tee $5
-                                          local.get $2
-                                          i32.lt_u
-                                          if ;; label = @20
-                                            call $fimport$10
-                                          end
-                                          local.get $5
-                                          i32.const 12
-                                          i32.add
-                                          local.tee $3
-                                          i32.load
-                                          local.get $4
-                                          i32.ne
-                                          if ;; label = @20
-                                            call $fimport$10
-                                          end
-                                          local.get $0
-                                          i32.const 8
-                                          i32.add
-                                          local.tee $1
-                                          i32.load
-                                          local.get $4
-                                          i32.eq
-                                          if ;; label = @20
-                                            block ;; label = @21
-                                              local.get $3
-                                              local.get $0
-                                              i32.store
-                                              local.get $1
-                                              local.get $5
-                                              i32.store
-                                              local.get $0
-                                              local.set $12
-                                            end
-                                          else
-                                            call $fimport$10
-                                          end
-                                        end
-                                      end
-                                    end
-                                    local.get $8
-                                    i32.eqz
-                                    br_if 2 (;@14;)
-                                    block $label$249 ;; label = @17
-                                      local.get $4
-                                      local.get $4
-                                      i32.load offset=28
-                                      local.tee $1
-                                      i32.const 2
-                                      i32.shl
-                                      i32.const 3956
-                                      i32.add
-                                      local.tee $0
-                                      i32.load
-                                      i32.eq
-                                      if ;; label = @18
-                                        block ;; label = @19
-                                          local.get $0
-                                          local.get $12
-                                          i32.store
-                                          local.get $12
-                                          br_if 2 (;@17;)
-                                          i32.const 3656
-                                          i32.const 3656
-                                          i32.load
-                                          i32.const 1
-                                          local.get $1
-                                          i32.shl
-                                          i32.const -1
-                                          i32.xor
-                                          i32.and
-                                          i32.store
-                                          br 5 (;@14;)
-                                        end
-                                      else
-                                        block ;; label = @19
-                                          local.get $8
-                                          i32.const 3668
-                                          i32.load
-                                          i32.lt_u
-                                          if ;; label = @20
-                                            call $fimport$10
-                                          end
-                                          local.get $8
-                                          i32.const 16
-                                          i32.add
-                                          local.tee $0
-                                          i32.load
-                                          local.get $4
-                                          i32.eq
-                                          if ;; label = @20
-                                            local.get $0
-                                            local.get $12
-                                            i32.store
-                                          else
-                                            local.get $8
-                                            local.get $12
-                                            i32.store offset=20
-                                          end
-                                          local.get $12
-                                          i32.eqz
-                                          br_if 5 (;@14;)
-                                        end
-                                      end
-                                    end
-                                    local.get $12
-                                    i32.const 3668
-                                    i32.load
-                                    local.tee $1
-                                    i32.lt_u
-                                    if ;; label = @17
-                                      call $fimport$10
-                                    end
-                                    local.get $12
-                                    local.get $8
-                                    i32.store offset=24
-                                    local.get $4
-                                    i32.const 16
-                                    i32.add
-                                    local.tee $0
-                                    i32.load
-                                    local.tee $3
-                                    if ;; label = @17
-                                      local.get $3
-                                      local.get $1
-                                      i32.lt_u
-                                      if ;; label = @18
-                                        call $fimport$10
-                                      else
-                                        block ;; label = @19
-                                          local.get $12
-                                          local.get $3
-                                          i32.store offset=16
-                                          local.get $3
-                                          local.get $12
-                                          i32.store offset=24
-                                        end
-                                      end
-                                    end
-                                    local.get $0
-                                    i32.load offset=4
-                                    local.tee $0
-                                    i32.eqz
-                                    br_if 2 (;@14;)
-                                    local.get $0
-                                    i32.const 3668
-                                    i32.load
-                                    i32.lt_u
-                                    if ;; label = @17
-                                      call $fimport$10
-                                    else
-                                      block ;; label = @18
-                                        local.get $12
-                                        local.get $0
-                                        i32.store offset=20
-                                        local.get $0
-                                        local.get $12
-                                        i32.store offset=24
-                                      end
-                                    end
-                                  end
-                                end
-                              end
-                              local.get $11
-                              local.get $7
-                              i32.add
-                              local.set $7
-                              local.get $4
-                              local.get $11
-                              i32.add
-                            end
-                          else
-                            local.get $4
-                          end
-                          local.tee $0
-                          i32.const 4
-                          i32.add
-                          local.tee $0
-                          local.get $0
-                          i32.load
-                          i32.const -2
-                          i32.and
-                          i32.store
-                          local.get $6
-                          local.get $7
-                          i32.const 1
-                          i32.or
-                          i32.store offset=4
-                          local.get $6
-                          local.get $7
-                          i32.add
-                          local.get $7
-                          i32.store
-                          local.get $7
-                          i32.const 3
-                          i32.shr_u
-                          local.set $0
-                          local.get $7
-                          i32.const 256
-                          i32.lt_u
-                          if ;; label = @12
-                            block ;; label = @13
-                              local.get $0
-                              i32.const 1
-                              i32.shl
-                              i32.const 2
-                              i32.shl
-                              i32.const 3692
-                              i32.add
-                              local.set $3
-                              block $label$263 ;; label = @14
-                                i32.const 3652
-                                i32.load
-                                local.tee $1
-                                i32.const 1
-                                local.get $0
-                                i32.shl
-                                local.tee $0
-                                i32.and
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $3
-                                    i32.const 8
-                                    i32.add
-                                    local.tee $1
-                                    i32.load
-                                    local.tee $0
-                                    i32.const 3668
-                                    i32.load
-                                    i32.ge_u
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        local.get $1
-                                        local.set $21
-                                        local.get $0
-                                        local.set $9
-                                        br 4 (;@14;)
-                                      end
-                                    end
-                                    call $fimport$10
-                                  end
-                                else
-                                  block ;; label = @16
-                                    i32.const 3652
-                                    local.get $1
-                                    local.get $0
-                                    i32.or
-                                    i32.store
-                                    local.get $3
-                                    i32.const 8
-                                    i32.add
-                                    local.set $21
-                                    local.get $3
-                                    local.set $9
-                                  end
-                                end
-                              end
-                              local.get $21
-                              local.get $6
-                              i32.store
-                              local.get $9
-                              local.get $6
-                              i32.store offset=12
-                              local.get $6
-                              local.get $9
-                              i32.store offset=8
-                              local.get $6
-                              local.get $3
-                              i32.store offset=12
-                              br 4 (;@9;)
-                            end
-                          end
-                          block $label$267 (result i32) ;; label = @12
-                            local.get $7
-                            i32.const 8
-                            i32.shr_u
-                            local.tee $0
-                            if (result i32) ;; label = @13
-                              block (result i32) ;; label = @14
-                                i32.const 31
-                                local.get $7
-                                i32.const 16777215
-                                i32.gt_u
-                                br_if 2 (;@12;)
-                                drop
-                                local.get $7
-                                i32.const 14
-                                local.get $0
-                                local.get $0
-                                i32.const 1048320
-                                i32.add
-                                i32.const 16
-                                i32.shr_u
-                                i32.const 8
-                                i32.and
-                                local.tee $3
-                                i32.shl
-                                local.tee $1
-                                i32.const 520192
-                                i32.add
-                                i32.const 16
-                                i32.shr_u
-                                i32.const 4
-                                i32.and
-                                local.tee $0
-                                local.get $3
-                                i32.or
-                                local.get $1
-                                local.get $0
-                                i32.shl
-                                local.tee $1
-                                i32.const 245760
-                                i32.add
-                                i32.const 16
-                                i32.shr_u
-                                i32.const 2
-                                i32.and
-                                local.tee $0
-                                i32.or
-                                i32.sub
-                                local.get $1
-                                local.get $0
-                                i32.shl
-                                i32.const 15
-                                i32.shr_u
-                                i32.add
-                                local.tee $0
-                                i32.const 7
-                                i32.add
-                                i32.shr_u
-                                i32.const 1
-                                i32.and
-                                local.get $0
-                                i32.const 1
-                                i32.shl
-                                i32.or
-                              end
-                            else
-                              i32.const 0
-                            end
-                          end
-                          local.tee $2
-                          i32.const 2
-                          i32.shl
-                          i32.const 3956
-                          i32.add
-                          local.set $3
-                          local.get $6
-                          local.get $2
-                          i32.store offset=28
-                          local.get $6
-                          i32.const 16
-                          i32.add
-                          local.tee $0
-                          i32.const 0
-                          i32.store offset=4
-                          local.get $0
-                          i32.const 0
-                          i32.store
-                          i32.const 3656
-                          i32.load
-                          local.tee $1
-                          i32.const 1
-                          local.get $2
-                          i32.shl
-                          local.tee $0
-                          i32.and
-                          i32.eqz
-                          if ;; label = @12
-                            block ;; label = @13
-                              i32.const 3656
-                              local.get $1
-                              local.get $0
-                              i32.or
-                              i32.store
-                              local.get $3
-                              local.get $6
-                              i32.store
-                              local.get $6
-                              local.get $3
-                              i32.store offset=24
-                              local.get $6
-                              local.get $6
-                              i32.store offset=12
-                              local.get $6
-                              local.get $6
-                              i32.store offset=8
-                              br 4 (;@9;)
-                            end
-                          end
-                          local.get $3
-                          i32.load
-                          local.set $0
-                          i32.const 25
-                          local.get $2
-                          i32.const 1
-                          i32.shr_u
-                          i32.sub
-                          local.set $1
-                          local.get $7
-                          local.get $2
-                          i32.const 31
-                          i32.eq
-                          if (result i32) ;; label = @12
-                            i32.const 0
-                          else
-                            local.get $1
-                          end
-                          i32.shl
-                          local.set $2
-                          block $label$273 ;; label = @12
-                            block $label$274 ;; label = @13
-                              block $label$275 ;; label = @14
-                                loop $label$276 ;; label = @15
-                                  local.get $0
-                                  i32.load offset=4
-                                  i32.const -8
-                                  i32.and
-                                  local.get $7
-                                  i32.eq
-                                  br_if 2 (;@13;)
-                                  local.get $2
-                                  i32.const 1
-                                  i32.shl
-                                  local.set $3
-                                  local.get $0
-                                  i32.const 16
-                                  i32.add
-                                  local.get $2
-                                  i32.const 31
-                                  i32.shr_u
-                                  i32.const 2
-                                  i32.shl
-                                  i32.add
-                                  local.tee $2
-                                  i32.load
-                                  local.tee $1
-                                  i32.eqz
-                                  br_if 1 (;@14;)
-                                  local.get $3
-                                  local.set $2
-                                  local.get $1
-                                  local.set $0
-                                  br 0 (;@15;)
-                                end
-                              end
-                              local.get $2
-                              i32.const 3668
-                              i32.load
-                              i32.lt_u
-                              if ;; label = @14
-                                call $fimport$10
-                              else
-                                block ;; label = @15
-                                  local.get $2
-                                  local.get $6
-                                  i32.store
-                                  local.get $6
-                                  local.get $0
-                                  i32.store offset=24
-                                  local.get $6
-                                  local.get $6
-                                  i32.store offset=12
-                                  local.get $6
-                                  local.get $6
-                                  i32.store offset=8
-                                  br 6 (;@9;)
-                                end
-                              end
-                              br 1 (;@12;)
-                            end
-                            local.get $0
-                            i32.const 8
-                            i32.add
-                            local.tee $3
-                            i32.load
-                            local.tee $2
-                            i32.const 3668
-                            i32.load
-                            local.tee $1
-                            i32.ge_u
-                            local.get $0
-                            local.get $1
-                            i32.ge_u
-                            i32.and
-                            if ;; label = @13
-                              block ;; label = @14
-                                local.get $2
-                                local.get $6
-                                i32.store offset=12
-                                local.get $3
-                                local.get $6
-                                i32.store
-                                local.get $6
-                                local.get $2
-                                i32.store offset=8
-                                local.get $6
-                                local.get $0
-                                i32.store offset=12
-                                local.get $6
-                                i32.const 0
-                                i32.store offset=24
-                              end
-                            else
-                              call $fimport$10
-                            end
-                          end
-                        end
-                      end
-                    end
-                    local.get $14
-                    global.set $global$1
-                    local.get $13
-                    i32.const 8
-                    i32.add
-                    return
-                  end
-                end
-              end
-              loop $label$281 ;; label = @6
-                block $label$282 ;; label = @7
-                  local.get $5
-                  i32.load
-                  local.tee $2
-                  local.get $8
-                  i32.le_u
-                  if ;; label = @8
-                    local.get $2
-                    local.get $5
-                    i32.load offset=4
-                    i32.add
-                    local.tee $13
-                    local.get $8
-                    i32.gt_u
-                    br_if 1 (;@7;)
-                  end
-                  local.get $5
-                  i32.load offset=8
-                  local.set $5
-                  br 1 (;@6;)
-                end
-              end
-              i32.const 0
-              local.get $13
-              i32.const -47
-              i32.add
-              local.tee $7
-              i32.const 8
-              i32.add
-              local.tee $5
-              i32.sub
-              i32.const 7
-              i32.and
-              local.set $2
-              local.get $7
-              local.get $5
-              i32.const 7
-              i32.and
-              if (result i32) ;; label = @6
-                local.get $2
-              else
-                i32.const 0
-              end
-              i32.add
-              local.tee $2
-              local.get $8
-              i32.const 16
-              i32.add
-              local.tee $12
-              i32.lt_u
-              if (result i32) ;; label = @6
-                local.get $8
-              else
-                local.get $2
-              end
-              local.tee $7
-              i32.const 8
-              i32.add
-              local.set $10
-              local.get $7
-              i32.const 24
-              i32.add
-              local.set $5
-              local.get $3
-              i32.const -40
-              i32.add
-              local.set $9
-              i32.const 0
-              local.get $1
-              i32.const 8
-              i32.add
-              local.tee $4
-              i32.sub
-              i32.const 7
-              i32.and
-              local.set $2
-              i32.const 3676
-              local.get $1
-              local.get $4
-              i32.const 7
-              i32.and
-              if (result i32) ;; label = @6
-                local.get $2
-              else
-                i32.const 0
-                local.tee $2
-              end
-              i32.add
-              local.tee $4
-              i32.store
-              i32.const 3664
-              local.get $9
-              local.get $2
-              i32.sub
-              local.tee $2
-              i32.store
-              local.get $4
-              local.get $2
-              i32.const 1
-              i32.or
-              i32.store offset=4
-              local.get $4
-              local.get $2
-              i32.add
-              i32.const 40
-              i32.store offset=4
-              i32.const 3680
-              i32.const 4140
-              i32.load
-              i32.store
-              local.get $7
-              i32.const 4
-              i32.add
-              local.tee $2
-              i32.const 27
-              i32.store
-              local.get $10
-              i32.const 4100
-              i64.load align=4
-              i64.store align=4
-              local.get $10
-              i32.const 4108
-              i64.load align=4
-              i64.store offset=8 align=4
-              i32.const 4100
-              local.get $1
-              i32.store
-              i32.const 4104
-              local.get $3
-              i32.store
-              i32.const 4112
-              i32.const 0
-              i32.store
-              i32.const 4108
-              local.get $10
-              i32.store
-              local.get $5
-              local.set $1
-              loop $label$290 ;; label = @6
-                local.get $1
-                i32.const 4
-                i32.add
-                local.tee $1
-                i32.const 7
-                i32.store
-                local.get $1
-                i32.const 4
-                i32.add
-                local.get $13
-                i32.lt_u
-                br_if 0 (;@6;)
-              end
-              local.get $7
-              local.get $8
-              i32.ne
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $2
-                  local.get $2
-                  i32.load
-                  i32.const -2
-                  i32.and
-                  i32.store
-                  local.get $8
-                  local.get $7
-                  local.get $8
-                  i32.sub
-                  local.tee $4
-                  i32.const 1
-                  i32.or
-                  i32.store offset=4
-                  local.get $7
-                  local.get $4
-                  i32.store
-                  local.get $4
-                  i32.const 3
-                  i32.shr_u
-                  local.set $1
-                  local.get $4
-                  i32.const 256
-                  i32.lt_u
-                  if ;; label = @8
-                    block ;; label = @9
-                      local.get $1
-                      i32.const 1
-                      i32.shl
-                      i32.const 2
-                      i32.shl
-                      i32.const 3692
-                      i32.add
-                      local.set $2
-                      i32.const 3652
-                      i32.load
-                      local.tee $3
-                      i32.const 1
-                      local.get $1
-                      i32.shl
-                      local.tee $1
-                      i32.and
-                      if ;; label = @10
-                        local.get $2
-                        i32.const 8
-                        i32.add
-                        local.tee $3
-                        i32.load
-                        local.tee $1
-                        i32.const 3668
-                        i32.load
-                        i32.lt_u
-                        if ;; label = @11
-                          call $fimport$10
-                        else
-                          block ;; label = @12
-                            local.get $3
-                            local.set $15
-                            local.get $1
-                            local.set $11
-                          end
-                        end
-                      else
-                        block ;; label = @11
-                          i32.const 3652
-                          local.get $3
-                          local.get $1
-                          i32.or
-                          i32.store
-                          local.get $2
-                          i32.const 8
-                          i32.add
-                          local.set $15
-                          local.get $2
-                          local.set $11
-                        end
-                      end
-                      local.get $15
-                      local.get $8
-                      i32.store
-                      local.get $11
-                      local.get $8
-                      i32.store offset=12
-                      local.get $8
-                      local.get $11
-                      i32.store offset=8
-                      local.get $8
-                      local.get $2
-                      i32.store offset=12
-                      br 6 (;@3;)
-                    end
-                  end
-                  local.get $4
-                  i32.const 8
-                  i32.shr_u
-                  local.tee $1
-                  if (result i32) ;; label = @8
-                    local.get $4
-                    i32.const 16777215
-                    i32.gt_u
-                    if (result i32) ;; label = @9
-                      i32.const 31
-                    else
-                      local.get $4
-                      i32.const 14
-                      local.get $1
-                      local.get $1
-                      i32.const 1048320
-                      i32.add
-                      i32.const 16
-                      i32.shr_u
-                      i32.const 8
-                      i32.and
-                      local.tee $2
-                      i32.shl
-                      local.tee $3
-                      i32.const 520192
-                      i32.add
-                      i32.const 16
-                      i32.shr_u
-                      i32.const 4
-                      i32.and
-                      local.tee $1
-                      local.get $2
-                      i32.or
-                      local.get $3
-                      local.get $1
-                      i32.shl
-                      local.tee $3
-                      i32.const 245760
-                      i32.add
-                      i32.const 16
-                      i32.shr_u
-                      i32.const 2
-                      i32.and
-                      local.tee $1
-                      i32.or
-                      i32.sub
-                      local.get $3
-                      local.get $1
-                      i32.shl
-                      i32.const 15
-                      i32.shr_u
-                      i32.add
-                      local.tee $1
-                      i32.const 7
-                      i32.add
-                      i32.shr_u
-                      i32.const 1
-                      i32.and
-                      local.get $1
-                      i32.const 1
-                      i32.shl
-                      i32.or
-                    end
-                  else
-                    i32.const 0
-                  end
-                  local.tee $5
-                  i32.const 2
-                  i32.shl
-                  i32.const 3956
-                  i32.add
-                  local.set $2
-                  local.get $8
-                  local.get $5
-                  i32.store offset=28
-                  local.get $8
-                  i32.const 0
-                  i32.store offset=20
-                  local.get $12
-                  i32.const 0
-                  i32.store
-                  i32.const 3656
-                  i32.load
-                  local.tee $3
-                  i32.const 1
-                  local.get $5
-                  i32.shl
-                  local.tee $1
-                  i32.and
-                  i32.eqz
-                  if ;; label = @8
-                    block ;; label = @9
-                      i32.const 3656
-                      local.get $3
-                      local.get $1
-                      i32.or
-                      i32.store
-                      local.get $2
-                      local.get $8
-                      i32.store
-                      local.get $8
-                      local.get $2
-                      i32.store offset=24
-                      local.get $8
-                      local.get $8
-                      i32.store offset=12
-                      local.get $8
-                      local.get $8
-                      i32.store offset=8
-                      br 6 (;@3;)
-                    end
-                  end
-                  local.get $2
-                  i32.load
-                  local.set $1
-                  i32.const 25
-                  local.get $5
-                  i32.const 1
-                  i32.shr_u
-                  i32.sub
-                  local.set $3
-                  local.get $4
-                  local.get $5
-                  i32.const 31
-                  i32.eq
-                  if (result i32) ;; label = @8
-                    i32.const 0
-                  else
-                    local.get $3
-                  end
-                  i32.shl
-                  local.set $5
-                  block $label$304 ;; label = @8
-                    block $label$305 ;; label = @9
-                      block $label$306 ;; label = @10
-                        loop $label$307 ;; label = @11
-                          local.get $1
-                          i32.load offset=4
-                          i32.const -8
-                          i32.and
-                          local.get $4
-                          i32.eq
-                          br_if 2 (;@9;)
-                          local.get $5
-                          i32.const 1
-                          i32.shl
-                          local.set $2
-                          local.get $1
-                          i32.const 16
-                          i32.add
-                          local.get $5
-                          i32.const 31
-                          i32.shr_u
-                          i32.const 2
-                          i32.shl
-                          i32.add
-                          local.tee $5
-                          i32.load
-                          local.tee $3
-                          i32.eqz
-                          br_if 1 (;@10;)
-                          local.get $2
-                          local.set $5
-                          local.get $3
-                          local.set $1
-                          br 0 (;@11;)
-                        end
-                      end
-                      local.get $5
-                      i32.const 3668
-                      i32.load
-                      i32.lt_u
-                      if ;; label = @10
-                        call $fimport$10
-                      else
-                        block ;; label = @11
-                          local.get $5
-                          local.get $8
-                          i32.store
-                          local.get $8
-                          local.get $1
-                          i32.store offset=24
-                          local.get $8
-                          local.get $8
-                          i32.store offset=12
-                          local.get $8
-                          local.get $8
-                          i32.store offset=8
-                          br 8 (;@3;)
-                        end
-                      end
-                      br 1 (;@8;)
-                    end
-                    local.get $1
-                    i32.const 8
-                    i32.add
-                    local.tee $2
-                    i32.load
-                    local.tee $5
-                    i32.const 3668
-                    i32.load
-                    local.tee $3
-                    i32.ge_u
-                    local.get $1
-                    local.get $3
-                    i32.ge_u
-                    i32.and
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $5
-                        local.get $8
-                        i32.store offset=12
-                        local.get $2
-                        local.get $8
-                        i32.store
-                        local.get $8
-                        local.get $5
-                        i32.store offset=8
-                        local.get $8
-                        local.get $1
-                        i32.store offset=12
-                        local.get $8
-                        i32.const 0
-                        i32.store offset=24
-                      end
-                    else
-                      call $fimport$10
-                    end
-                  end
-                end
-              end
-            end
-          else
-            block ;; label = @5
-              i32.const 3668
-              i32.load
-              local.tee $2
-              i32.eqz
-              local.get $1
-              local.get $2
-              i32.lt_u
-              i32.or
-              if ;; label = @6
-                i32.const 3668
-                local.get $1
-                i32.store
-              end
-              i32.const 4100
-              local.get $1
-              i32.store
-              i32.const 4104
-              local.get $3
-              i32.store
-              i32.const 4112
-              i32.const 0
-              i32.store
-              i32.const 3688
-              i32.const 4124
-              i32.load
-              i32.store
-              i32.const 3684
-              i32.const -1
-              i32.store
-              i32.const 0
-              local.set $2
-              loop $label$314 ;; label = @6
-                local.get $2
-                i32.const 1
-                i32.shl
-                i32.const 2
-                i32.shl
-                i32.const 3692
-                i32.add
-                local.tee $5
-                local.get $5
-                i32.store offset=12
-                local.get $5
-                local.get $5
-                i32.store offset=8
-                local.get $2
-                i32.const 1
-                i32.add
-                local.tee $2
-                i32.const 32
-                i32.ne
-                br_if 0 (;@6;)
-              end
-              local.get $3
-              i32.const -40
-              i32.add
-              local.set $5
-              i32.const 0
-              local.get $1
-              i32.const 8
-              i32.add
-              local.tee $2
-              i32.sub
-              i32.const 7
-              i32.and
-              local.set $3
-              i32.const 3676
-              local.get $1
-              local.get $2
-              i32.const 7
-              i32.and
-              if (result i32) ;; label = @6
-                local.get $3
-              else
-                i32.const 0
-              end
-              local.tee $1
-              i32.add
-              local.tee $3
-              i32.store
-              i32.const 3664
-              local.get $5
-              local.get $1
-              i32.sub
-              local.tee $1
-              i32.store
-              local.get $3
-              local.get $1
-              i32.const 1
-              i32.or
-              i32.store offset=4
-              local.get $3
-              local.get $1
-              i32.add
-              i32.const 40
-              i32.store offset=4
-              i32.const 3680
-              i32.const 4140
-              i32.load
-              i32.store
-            end
-          end
-        end
-        i32.const 3664
-        i32.load
-        local.tee $1
-        local.get $0
-        i32.gt_u
-        if ;; label = @3
-          block ;; label = @4
-            i32.const 3664
-            local.get $1
-            local.get $0
-            i32.sub
-            local.tee $3
-            i32.store
-            i32.const 3676
-            i32.const 3676
-            i32.load
-            local.tee $2
-            local.get $0
-            i32.add
-            local.tee $1
-            i32.store
-            local.get $1
-            local.get $3
-            i32.const 1
-            i32.or
-            i32.store offset=4
-            local.get $2
-            local.get $0
-            i32.const 3
-            i32.or
-            i32.store offset=4
-            local.get $14
-            global.set $global$1
-            local.get $2
-            i32.const 8
-            i32.add
-            return
-          end
-        end
-      end
-      call $12
-      i32.const 12
-      i32.store
-      local.get $14
-      global.set $global$1
-      i32.const 0
-    end
-  )
-  (func $36 (;49;) (type $2) (param $0 i32)
-    (local $1 i32) (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32) (local $15 i32)
-    block $label$1 ;; label = @1
-      local.get $0
-      i32.eqz
-      if ;; label = @2
-        return
-      end
-      local.get $0
-      i32.const -8
-      i32.add
-      local.tee $1
-      i32.const 3668
-      i32.load
-      local.tee $11
-      i32.lt_u
-      if ;; label = @2
-        call $fimport$10
-      end
-      local.get $0
-      i32.const -4
-      i32.add
-      i32.load
-      local.tee $0
-      i32.const 3
-      i32.and
-      local.tee $8
-      i32.const 1
-      i32.eq
-      if ;; label = @2
-        call $fimport$10
-      end
-      local.get $1
-      local.get $0
-      i32.const -8
-      i32.and
-      local.tee $4
-      i32.add
-      local.set $6
-      block $label$5 ;; label = @2
-        local.get $0
-        i32.const 1
-        i32.and
-        if ;; label = @3
-          block ;; label = @4
-            local.get $1
-            local.set $3
-            local.get $4
-            local.set $2
-          end
-        else
-          block ;; label = @4
-            local.get $8
-            i32.eqz
-            if ;; label = @5
-              return
-            end
-            local.get $1
-            i32.const 0
-            local.get $1
-            i32.load
-            local.tee $8
-            i32.sub
-            i32.add
-            local.tee $0
-            local.get $11
-            i32.lt_u
-            if ;; label = @5
-              call $fimport$10
-            end
-            local.get $8
-            local.get $4
-            i32.add
-            local.set $1
-            local.get $0
-            i32.const 3672
-            i32.load
-            i32.eq
-            if ;; label = @5
-              block ;; label = @6
-                local.get $6
-                i32.const 4
-                i32.add
-                local.tee $2
-                i32.load
-                local.tee $3
-                i32.const 3
-                i32.and
-                i32.const 3
-                i32.ne
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $0
-                    local.set $3
-                    local.get $1
-                    local.set $2
-                    br 6 (;@2;)
-                  end
-                end
-                i32.const 3660
-                local.get $1
-                i32.store
-                local.get $2
-                local.get $3
-                i32.const -2
-                i32.and
-                i32.store
-                local.get $0
-                local.get $1
-                i32.const 1
-                i32.or
-                i32.store offset=4
-                local.get $0
-                local.get $1
-                i32.add
-                local.get $1
-                i32.store
-                return
-              end
-            end
-            local.get $8
-            i32.const 3
-            i32.shr_u
-            local.set $10
-            local.get $8
-            i32.const 256
-            i32.lt_u
-            if ;; label = @5
-              block ;; label = @6
-                local.get $0
-                i32.load offset=12
-                local.set $3
-                local.get $0
-                i32.load offset=8
-                local.tee $4
-                local.get $10
-                i32.const 1
-                i32.shl
-                i32.const 2
-                i32.shl
-                i32.const 3692
-                i32.add
-                local.tee $2
-                i32.ne
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $4
-                    local.get $11
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                    local.get $4
-                    i32.load offset=12
-                    local.get $0
-                    i32.ne
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                  end
-                end
-                local.get $3
-                local.get $4
-                i32.eq
-                if ;; label = @7
-                  block ;; label = @8
-                    i32.const 3652
-                    i32.const 3652
-                    i32.load
-                    i32.const 1
-                    local.get $10
-                    i32.shl
-                    i32.const -1
-                    i32.xor
-                    i32.and
-                    i32.store
-                    local.get $0
-                    local.set $3
-                    local.get $1
-                    local.set $2
-                    br 6 (;@2;)
-                  end
-                end
-                local.get $3
-                local.get $2
-                i32.eq
-                if ;; label = @7
-                  local.get $3
-                  i32.const 8
-                  i32.add
-                  local.set $5
-                else
-                  block ;; label = @8
-                    local.get $3
-                    local.get $11
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                    local.get $3
-                    i32.const 8
-                    i32.add
-                    local.tee $2
-                    i32.load
-                    local.get $0
-                    i32.eq
-                    if ;; label = @9
-                      local.get $2
-                      local.set $5
-                    else
-                      call $fimport$10
-                    end
-                  end
-                end
-                local.get $4
-                local.get $3
-                i32.store offset=12
-                local.get $5
-                local.get $4
-                i32.store
-                local.get $0
-                local.set $3
-                local.get $1
-                local.set $2
-                br 4 (;@2;)
-              end
-            end
-            local.get $0
-            i32.load offset=24
-            local.set $12
-            block $label$22 ;; label = @5
-              local.get $0
-              i32.load offset=12
-              local.tee $4
-              local.get $0
-              i32.eq
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $0
-                  i32.const 16
-                  i32.add
-                  local.tee $5
-                  i32.const 4
-                  i32.add
-                  local.tee $8
-                  i32.load
-                  local.tee $4
-                  if ;; label = @8
-                    local.get $8
-                    local.set $5
-                  else
-                    local.get $5
-                    i32.load
-                    local.tee $4
-                    i32.eqz
-                    if ;; label = @9
-                      block ;; label = @10
-                        i32.const 0
-                        local.set $7
-                        br 5 (;@5;)
-                      end
-                    end
-                  end
-                  loop $label$27 ;; label = @8
-                    local.get $4
-                    i32.const 20
-                    i32.add
-                    local.tee $8
-                    i32.load
-                    local.tee $10
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $10
-                        local.set $4
-                        local.get $8
-                        local.set $5
-                        br 2 (;@8;)
-                      end
-                    end
-                    local.get $4
-                    i32.const 16
-                    i32.add
-                    local.tee $8
-                    i32.load
-                    local.tee $10
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $10
-                        local.set $4
-                        local.get $8
-                        local.set $5
-                        br 2 (;@8;)
-                      end
-                    end
-                  end
-                  local.get $5
-                  local.get $11
-                  i32.lt_u
-                  if ;; label = @8
-                    call $fimport$10
-                  else
-                    block ;; label = @9
-                      local.get $5
-                      i32.const 0
-                      i32.store
-                      local.get $4
-                      local.set $7
-                    end
-                  end
-                end
-              else
-                block ;; label = @7
-                  local.get $0
-                  i32.load offset=8
-                  local.tee $5
-                  local.get $11
-                  i32.lt_u
-                  if ;; label = @8
-                    call $fimport$10
-                  end
-                  local.get $5
-                  i32.const 12
-                  i32.add
-                  local.tee $8
-                  i32.load
-                  local.get $0
-                  i32.ne
-                  if ;; label = @8
-                    call $fimport$10
-                  end
-                  local.get $4
-                  i32.const 8
-                  i32.add
-                  local.tee $10
-                  i32.load
-                  local.get $0
-                  i32.eq
-                  if ;; label = @8
-                    block ;; label = @9
-                      local.get $8
-                      local.get $4
-                      i32.store
-                      local.get $10
-                      local.get $5
-                      i32.store
-                      local.get $4
-                      local.set $7
-                    end
-                  else
-                    call $fimport$10
-                  end
-                end
-              end
-            end
-            local.get $12
-            if ;; label = @5
-              block ;; label = @6
-                local.get $0
-                local.get $0
-                i32.load offset=28
-                local.tee $4
-                i32.const 2
-                i32.shl
-                i32.const 3956
-                i32.add
-                local.tee $5
-                i32.load
-                i32.eq
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $5
-                    local.get $7
-                    i32.store
-                    local.get $7
-                    i32.eqz
-                    if ;; label = @9
-                      block ;; label = @10
-                        i32.const 3656
-                        i32.const 3656
-                        i32.load
-                        i32.const 1
-                        local.get $4
-                        i32.shl
-                        i32.const -1
-                        i32.xor
-                        i32.and
-                        i32.store
-                        local.get $0
-                        local.set $3
-                        local.get $1
-                        local.set $2
-                        br 8 (;@2;)
-                      end
-                    end
-                  end
-                else
-                  block ;; label = @8
-                    local.get $12
-                    i32.const 3668
-                    i32.load
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                    local.get $12
-                    i32.const 16
-                    i32.add
-                    local.tee $4
-                    i32.load
-                    local.get $0
-                    i32.eq
-                    if ;; label = @9
-                      local.get $4
-                      local.get $7
-                      i32.store
-                    else
-                      local.get $12
-                      local.get $7
-                      i32.store offset=20
-                    end
-                    local.get $7
-                    i32.eqz
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $0
-                        local.set $3
-                        local.get $1
-                        local.set $2
-                        br 8 (;@2;)
-                      end
-                    end
-                  end
-                end
-                local.get $7
-                i32.const 3668
-                i32.load
-                local.tee $5
-                i32.lt_u
-                if ;; label = @7
-                  call $fimport$10
-                end
-                local.get $7
-                local.get $12
-                i32.store offset=24
-                local.get $0
-                i32.const 16
-                i32.add
-                local.tee $8
-                i32.load
-                local.tee $4
-                if ;; label = @7
-                  local.get $4
-                  local.get $5
-                  i32.lt_u
-                  if ;; label = @8
-                    call $fimport$10
-                  else
-                    block ;; label = @9
-                      local.get $7
-                      local.get $4
-                      i32.store offset=16
-                      local.get $4
-                      local.get $7
-                      i32.store offset=24
-                    end
-                  end
-                end
-                local.get $8
-                i32.load offset=4
-                local.tee $4
-                if ;; label = @7
-                  local.get $4
-                  i32.const 3668
-                  i32.load
-                  i32.lt_u
-                  if ;; label = @8
-                    call $fimport$10
-                  else
-                    block ;; label = @9
-                      local.get $7
-                      local.get $4
-                      i32.store offset=20
-                      local.get $4
-                      local.get $7
-                      i32.store offset=24
-                      local.get $0
-                      local.set $3
-                      local.get $1
-                      local.set $2
-                    end
-                  end
-                else
-                  block ;; label = @8
-                    local.get $0
-                    local.set $3
-                    local.get $1
-                    local.set $2
-                  end
-                end
-              end
-            else
-              block ;; label = @6
-                local.get $0
-                local.set $3
-                local.get $1
-                local.set $2
-              end
-            end
-          end
-        end
-      end
-      local.get $3
-      local.get $6
-      i32.ge_u
-      if ;; label = @2
-        call $fimport$10
-      end
-      local.get $6
-      i32.const 4
-      i32.add
-      local.tee $1
-      i32.load
-      local.tee $0
-      i32.const 1
-      i32.and
-      i32.eqz
-      if ;; label = @2
-        call $fimport$10
-      end
-      local.get $0
-      i32.const 2
-      i32.and
-      if ;; label = @2
-        block ;; label = @3
-          local.get $1
-          local.get $0
-          i32.const -2
-          i32.and
-          i32.store
-          local.get $3
-          local.get $2
-          i32.const 1
-          i32.or
-          i32.store offset=4
-          local.get $3
-          local.get $2
-          i32.add
-          local.get $2
-          i32.store
-        end
-      else
-        block ;; label = @3
-          local.get $6
-          i32.const 3676
-          i32.load
-          i32.eq
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 3664
-              i32.const 3664
-              i32.load
-              local.get $2
-              i32.add
-              local.tee $0
-              i32.store
-              i32.const 3676
-              local.get $3
-              i32.store
-              local.get $3
-              local.get $0
-              i32.const 1
-              i32.or
-              i32.store offset=4
-              local.get $3
-              i32.const 3672
-              i32.load
-              i32.ne
-              if ;; label = @6
-                return
-              end
-              i32.const 3672
-              i32.const 0
-              i32.store
-              i32.const 3660
-              i32.const 0
-              i32.store
-              return
-            end
-          end
-          local.get $6
-          i32.const 3672
-          i32.load
-          i32.eq
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 3660
-              i32.const 3660
-              i32.load
-              local.get $2
-              i32.add
-              local.tee $0
-              i32.store
-              i32.const 3672
-              local.get $3
-              i32.store
-              local.get $3
-              local.get $0
-              i32.const 1
-              i32.or
-              i32.store offset=4
-              local.get $3
-              local.get $0
-              i32.add
-              local.get $0
-              i32.store
-              return
-            end
-          end
-          local.get $0
-          i32.const -8
-          i32.and
-          local.get $2
-          i32.add
-          local.set $5
-          local.get $0
-          i32.const 3
-          i32.shr_u
-          local.set $4
-          block $label$61 ;; label = @4
-            local.get $0
-            i32.const 256
-            i32.lt_u
-            if ;; label = @5
-              block ;; label = @6
-                local.get $6
-                i32.load offset=12
-                local.set $2
-                local.get $6
-                i32.load offset=8
-                local.tee $1
-                local.get $4
-                i32.const 1
-                i32.shl
-                i32.const 2
-                i32.shl
-                i32.const 3692
-                i32.add
-                local.tee $0
-                i32.ne
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $1
-                    i32.const 3668
-                    i32.load
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                    local.get $1
-                    i32.load offset=12
-                    local.get $6
-                    i32.ne
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                  end
-                end
-                local.get $2
-                local.get $1
-                i32.eq
-                if ;; label = @7
-                  block ;; label = @8
-                    i32.const 3652
-                    i32.const 3652
-                    i32.load
-                    i32.const 1
-                    local.get $4
-                    i32.shl
-                    i32.const -1
-                    i32.xor
-                    i32.and
-                    i32.store
-                    br 4 (;@4;)
-                  end
-                end
-                local.get $2
-                local.get $0
-                i32.eq
-                if ;; label = @7
-                  local.get $2
-                  i32.const 8
-                  i32.add
-                  local.set $14
-                else
-                  block ;; label = @8
-                    local.get $2
-                    i32.const 3668
-                    i32.load
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                    local.get $2
-                    i32.const 8
-                    i32.add
-                    local.tee $0
-                    i32.load
-                    local.get $6
-                    i32.eq
-                    if ;; label = @9
-                      local.get $0
-                      local.set $14
-                    else
-                      call $fimport$10
-                    end
-                  end
-                end
-                local.get $1
-                local.get $2
-                i32.store offset=12
-                local.get $14
-                local.get $1
-                i32.store
-              end
-            else
-              block ;; label = @6
-                local.get $6
-                i32.load offset=24
-                local.set $7
-                block $label$73 ;; label = @7
-                  local.get $6
-                  i32.load offset=12
-                  local.tee $0
-                  local.get $6
-                  i32.eq
-                  if ;; label = @8
-                    block ;; label = @9
-                      local.get $6
-                      i32.const 16
-                      i32.add
-                      local.tee $2
-                      i32.const 4
-                      i32.add
-                      local.tee $1
-                      i32.load
-                      local.tee $0
-                      if ;; label = @10
-                        local.get $1
-                        local.set $2
-                      else
-                        local.get $2
-                        i32.load
-                        local.tee $0
-                        i32.eqz
-                        if ;; label = @11
-                          block ;; label = @12
-                            i32.const 0
-                            local.set $9
-                            br 5 (;@7;)
-                          end
-                        end
-                      end
-                      loop $label$78 ;; label = @10
-                        local.get $0
-                        i32.const 20
-                        i32.add
-                        local.tee $1
-                        i32.load
-                        local.tee $4
-                        if ;; label = @11
-                          block ;; label = @12
-                            local.get $4
-                            local.set $0
-                            local.get $1
-                            local.set $2
-                            br 2 (;@10;)
-                          end
-                        end
-                        local.get $0
-                        i32.const 16
-                        i32.add
-                        local.tee $1
-                        i32.load
-                        local.tee $4
-                        if ;; label = @11
-                          block ;; label = @12
-                            local.get $4
-                            local.set $0
-                            local.get $1
-                            local.set $2
-                            br 2 (;@10;)
-                          end
-                        end
-                      end
-                      local.get $2
-                      i32.const 3668
-                      i32.load
-                      i32.lt_u
-                      if ;; label = @10
-                        call $fimport$10
-                      else
-                        block ;; label = @11
-                          local.get $2
-                          i32.const 0
-                          i32.store
-                          local.get $0
-                          local.set $9
-                        end
-                      end
-                    end
-                  else
-                    block ;; label = @9
-                      local.get $6
-                      i32.load offset=8
-                      local.tee $2
-                      i32.const 3668
-                      i32.load
-                      i32.lt_u
-                      if ;; label = @10
-                        call $fimport$10
-                      end
-                      local.get $2
-                      i32.const 12
-                      i32.add
-                      local.tee $1
-                      i32.load
-                      local.get $6
-                      i32.ne
-                      if ;; label = @10
-                        call $fimport$10
-                      end
-                      local.get $0
-                      i32.const 8
-                      i32.add
-                      local.tee $4
-                      i32.load
-                      local.get $6
-                      i32.eq
-                      if ;; label = @10
-                        block ;; label = @11
-                          local.get $1
-                          local.get $0
-                          i32.store
-                          local.get $4
-                          local.get $2
-                          i32.store
-                          local.get $0
-                          local.set $9
-                        end
-                      else
-                        call $fimport$10
-                      end
-                    end
-                  end
-                end
-                local.get $7
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $6
-                    local.get $6
-                    i32.load offset=28
-                    local.tee $0
-                    i32.const 2
-                    i32.shl
-                    i32.const 3956
-                    i32.add
-                    local.tee $2
-                    i32.load
-                    i32.eq
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $2
-                        local.get $9
-                        i32.store
-                        local.get $9
-                        i32.eqz
-                        if ;; label = @11
-                          block ;; label = @12
-                            i32.const 3656
-                            i32.const 3656
-                            i32.load
-                            i32.const 1
-                            local.get $0
-                            i32.shl
-                            i32.const -1
-                            i32.xor
-                            i32.and
-                            i32.store
-                            br 8 (;@4;)
-                          end
-                        end
-                      end
-                    else
-                      block ;; label = @10
-                        local.get $7
-                        i32.const 3668
-                        i32.load
-                        i32.lt_u
-                        if ;; label = @11
-                          call $fimport$10
-                        end
-                        local.get $7
-                        i32.const 16
-                        i32.add
-                        local.tee $0
-                        i32.load
-                        local.get $6
-                        i32.eq
-                        if ;; label = @11
-                          local.get $0
-                          local.get $9
-                          i32.store
-                        else
-                          local.get $7
-                          local.get $9
-                          i32.store offset=20
-                        end
-                        local.get $9
-                        i32.eqz
-                        br_if 6 (;@4;)
-                      end
-                    end
-                    local.get $9
-                    i32.const 3668
-                    i32.load
-                    local.tee $2
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                    local.get $9
-                    local.get $7
-                    i32.store offset=24
-                    local.get $6
-                    i32.const 16
-                    i32.add
-                    local.tee $1
-                    i32.load
-                    local.tee $0
-                    if ;; label = @9
-                      local.get $0
-                      local.get $2
-                      i32.lt_u
-                      if ;; label = @10
-                        call $fimport$10
-                      else
-                        block ;; label = @11
-                          local.get $9
-                          local.get $0
-                          i32.store offset=16
-                          local.get $0
-                          local.get $9
-                          i32.store offset=24
-                        end
-                      end
-                    end
-                    local.get $1
-                    i32.load offset=4
-                    local.tee $0
-                    if ;; label = @9
-                      local.get $0
-                      i32.const 3668
-                      i32.load
-                      i32.lt_u
-                      if ;; label = @10
-                        call $fimport$10
-                      else
-                        block ;; label = @11
-                          local.get $9
-                          local.get $0
-                          i32.store offset=20
-                          local.get $0
-                          local.get $9
-                          i32.store offset=24
-                        end
-                      end
-                    end
-                  end
-                end
-              end
-            end
-          end
-          local.get $3
-          local.get $5
-          i32.const 1
-          i32.or
-          i32.store offset=4
-          local.get $3
-          local.get $5
-          i32.add
-          local.get $5
-          i32.store
-          local.get $3
-          i32.const 3672
-          i32.load
-          i32.eq
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 3660
-              local.get $5
-              i32.store
-              return
-            end
-          else
-            local.get $5
-            local.set $2
-          end
-        end
-      end
-      local.get $2
-      i32.const 3
-      i32.shr_u
-      local.set $1
-      local.get $2
-      i32.const 256
-      i32.lt_u
-      if ;; label = @2
-        block ;; label = @3
-          local.get $1
-          i32.const 1
-          i32.shl
-          i32.const 2
-          i32.shl
-          i32.const 3692
-          i32.add
-          local.set $0
-          i32.const 3652
-          i32.load
-          local.tee $2
-          i32.const 1
-          local.get $1
-          i32.shl
-          local.tee $1
-          i32.and
-          if ;; label = @4
-            local.get $0
-            i32.const 8
-            i32.add
-            local.tee $2
-            i32.load
-            local.tee $1
-            i32.const 3668
-            i32.load
-            i32.lt_u
-            if ;; label = @5
-              call $fimport$10
-            else
-              block ;; label = @6
-                local.get $2
-                local.set $15
-                local.get $1
-                local.set $13
-              end
-            end
-          else
-            block ;; label = @5
-              i32.const 3652
-              local.get $2
-              local.get $1
-              i32.or
-              i32.store
-              local.get $0
-              i32.const 8
-              i32.add
-              local.set $15
-              local.get $0
-              local.set $13
-            end
-          end
-          local.get $15
-          local.get $3
-          i32.store
-          local.get $13
-          local.get $3
-          i32.store offset=12
-          local.get $3
-          local.get $13
-          i32.store offset=8
-          local.get $3
-          local.get $0
-          i32.store offset=12
-          return
-        end
-      end
-      local.get $2
-      i32.const 8
-      i32.shr_u
-      local.tee $0
-      if (result i32) ;; label = @2
-        local.get $2
-        i32.const 16777215
-        i32.gt_u
-        if (result i32) ;; label = @3
-          i32.const 31
-        else
-          local.get $2
-          i32.const 14
-          local.get $0
-          local.get $0
-          i32.const 1048320
-          i32.add
-          i32.const 16
-          i32.shr_u
-          i32.const 8
-          i32.and
-          local.tee $0
-          i32.shl
-          local.tee $1
-          i32.const 520192
-          i32.add
-          i32.const 16
-          i32.shr_u
-          i32.const 4
-          i32.and
-          local.tee $4
-          local.get $0
-          i32.or
-          local.get $1
-          local.get $4
-          i32.shl
-          local.tee $0
-          i32.const 245760
-          i32.add
-          i32.const 16
-          i32.shr_u
-          i32.const 2
-          i32.and
-          local.tee $1
-          i32.or
-          i32.sub
-          local.get $0
-          local.get $1
-          i32.shl
-          i32.const 15
-          i32.shr_u
-          i32.add
-          local.tee $0
-          i32.const 7
-          i32.add
-          i32.shr_u
-          i32.const 1
-          i32.and
-          local.get $0
-          i32.const 1
-          i32.shl
-          i32.or
-        end
-      else
-        i32.const 0
-      end
-      local.tee $1
-      i32.const 2
-      i32.shl
-      i32.const 3956
-      i32.add
-      local.set $0
-      local.get $3
-      local.get $1
-      i32.store offset=28
-      local.get $3
-      i32.const 0
-      i32.store offset=20
-      local.get $3
-      i32.const 0
-      i32.store offset=16
-      block $label$113 ;; label = @2
-        i32.const 3656
-        i32.load
-        local.tee $4
-        i32.const 1
-        local.get $1
-        i32.shl
-        local.tee $5
-        i32.and
-        if ;; label = @3
-          block ;; label = @4
-            local.get $0
-            i32.load
-            local.set $0
-            i32.const 25
-            local.get $1
-            i32.const 1
-            i32.shr_u
-            i32.sub
-            local.set $4
-            local.get $2
-            local.get $1
-            i32.const 31
-            i32.eq
-            if (result i32) ;; label = @5
-              i32.const 0
-            else
-              local.get $4
-            end
-            i32.shl
-            local.set $1
-            block $label$117 ;; label = @5
-              block $label$118 ;; label = @6
-                block $label$119 ;; label = @7
-                  loop $label$120 ;; label = @8
-                    local.get $0
-                    i32.load offset=4
-                    i32.const -8
-                    i32.and
-                    local.get $2
-                    i32.eq
-                    br_if 2 (;@6;)
-                    local.get $1
-                    i32.const 1
-                    i32.shl
-                    local.set $4
-                    local.get $0
-                    i32.const 16
-                    i32.add
-                    local.get $1
-                    i32.const 31
-                    i32.shr_u
-                    i32.const 2
-                    i32.shl
-                    i32.add
-                    local.tee $1
-                    i32.load
-                    local.tee $5
-                    i32.eqz
-                    br_if 1 (;@7;)
-                    local.get $4
-                    local.set $1
-                    local.get $5
-                    local.set $0
-                    br 0 (;@8;)
-                  end
-                end
-                local.get $1
-                i32.const 3668
-                i32.load
-                i32.lt_u
-                if ;; label = @7
-                  call $fimport$10
-                else
-                  block ;; label = @8
-                    local.get $1
-                    local.get $3
-                    i32.store
-                    local.get $3
-                    local.get $0
-                    i32.store offset=24
-                    local.get $3
-                    local.get $3
-                    i32.store offset=12
-                    local.get $3
-                    local.get $3
-                    i32.store offset=8
-                    br 6 (;@2;)
-                  end
-                end
-                br 1 (;@5;)
-              end
-              local.get $0
-              i32.const 8
-              i32.add
-              local.tee $1
-              i32.load
-              local.tee $2
-              i32.const 3668
-              i32.load
-              local.tee $4
-              i32.ge_u
-              local.get $0
-              local.get $4
-              i32.ge_u
-              i32.and
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $2
-                  local.get $3
-                  i32.store offset=12
-                  local.get $1
-                  local.get $3
-                  i32.store
-                  local.get $3
-                  local.get $2
-                  i32.store offset=8
-                  local.get $3
-                  local.get $0
-                  i32.store offset=12
-                  local.get $3
-                  i32.const 0
-                  i32.store offset=24
-                end
-              else
-                call $fimport$10
-              end
-            end
-          end
-        else
-          block ;; label = @4
-            i32.const 3656
-            local.get $4
-            local.get $5
-            i32.or
-            i32.store
-            local.get $0
-            local.get $3
-            i32.store
-            local.get $3
-            local.get $0
-            i32.store offset=24
-            local.get $3
-            local.get $3
-            i32.store offset=12
-            local.get $3
-            local.get $3
-            i32.store offset=8
-          end
-        end
-      end
-      i32.const 3684
-      i32.const 3684
-      i32.load
-      i32.const -1
-      i32.add
-      local.tee $0
-      i32.store
-      local.get $0
-      if ;; label = @2
-        return
-      else
-        i32.const 4108
-        local.set $0
-      end
-      loop $label$128 ;; label = @2
-        local.get $0
-        i32.load
-        local.tee $2
-        i32.const 8
-        i32.add
-        local.set $0
-        local.get $2
-        br_if 0 (;@2;)
-      end
-      i32.const 3684
-      i32.const -1
-      i32.store
-    end
-  )
-  (func $37 (;50;) (type $6)
-    nop
-  )
-  (func $38 (;51;) (type $1) (param $0 i32) (result i32)
-    (local $1 i32) (local $2 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$0
-      i32.load
-      local.tee $2
-      local.get $0
-      i32.const 15
-      i32.add
-      i32.const -16
-      i32.and
-      local.tee $0
-      i32.add
-      local.set $1
-      local.get $0
-      i32.const 0
-      i32.gt_s
-      local.get $1
-      local.get $2
-      i32.lt_s
-      i32.and
-      local.get $1
-      i32.const 0
-      i32.lt_s
-      i32.or
-      if ;; label = @2
-        block ;; label = @3
-          call $fimport$6
-          drop
-          i32.const 12
-          call $fimport$11
-          i32.const -1
-          return
-        end
-      end
-      global.get $global$0
-      local.get $1
-      i32.store
-      local.get $1
-      call $fimport$5
-      i32.gt_s
-      if ;; label = @2
-        call $fimport$4
-        i32.eqz
-        if ;; label = @3
-          block ;; label = @4
-            i32.const 12
-            call $fimport$11
-            global.get $global$0
-            local.get $2
-            i32.store
-            i32.const -1
-            return
-          end
-        end
-      end
-      local.get $2
-    end
-  )
-  (func $39 (;52;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32) (local $4 i32) (local $5 i32)
-    block $label$1 (result i32) ;; label = @1
-      local.get $0
-      local.get $2
-      i32.add
-      local.set $4
-      local.get $2
-      i32.const 20
-      i32.ge_s
-      if ;; label = @2
-        block ;; label = @3
-          local.get $1
-          i32.const 255
-          i32.and
-          local.set $1
-          local.get $0
-          i32.const 3
-          i32.and
-          local.tee $3
-          if ;; label = @4
-            block ;; label = @5
-              local.get $0
-              i32.const 4
-              i32.add
-              local.get $3
-              i32.sub
-              local.set $3
-              loop $label$4 ;; label = @6
-                local.get $0
-                local.get $3
-                i32.lt_s
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $0
-                    local.get $1
-                    i32.store8
-                    local.get $0
-                    i32.const 1
-                    i32.add
-                    local.set $0
-                    br 2 (;@6;)
-                  end
-                end
-              end
-            end
-          end
-          local.get $1
-          local.get $1
-          i32.const 8
-          i32.shl
-          i32.or
-          local.get $1
-          i32.const 16
-          i32.shl
-          i32.or
-          local.get $1
-          i32.const 24
-          i32.shl
-          i32.or
-          local.set $3
-          local.get $4
-          i32.const -4
-          i32.and
-          local.set $5
-          loop $label$6 ;; label = @4
-            local.get $0
-            local.get $5
-            i32.lt_s
-            if ;; label = @5
-              block ;; label = @6
-                local.get $0
-                local.get $3
-                i32.store
-                local.get $0
-                i32.const 4
-                i32.add
-                local.set $0
-                br 2 (;@4;)
-              end
-            end
-          end
-        end
-      end
-      loop $label$8 ;; label = @2
-        local.get $0
-        local.get $4
-        i32.lt_s
-        if ;; label = @3
-          block ;; label = @4
-            local.get $0
-            local.get $1
-            i32.store8
-            local.get $0
-            i32.const 1
-            i32.add
-            local.set $0
-            br 2 (;@2;)
-          end
-        end
-      end
-      local.get $0
-      local.get $2
-      i32.sub
-    end
-  )
-  (func $40 (;53;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32)
-    block $label$1 (result i32) ;; label = @1
-      local.get $2
-      i32.const 4096
-      i32.ge_s
-      if ;; label = @2
-        local.get $0
-        local.get $1
-        local.get $2
-        call $fimport$12
-        return
-      end
-      local.get $0
-      local.set $3
-      local.get $0
-      i32.const 3
-      i32.and
-      local.get $1
-      i32.const 3
-      i32.and
-      i32.eq
-      if ;; label = @2
-        block ;; label = @3
-          loop $label$4 ;; label = @4
-            local.get $0
-            i32.const 3
-            i32.and
-            if ;; label = @5
-              block ;; label = @6
-                local.get $2
-                i32.eqz
-                if ;; label = @7
-                  local.get $3
-                  return
-                end
-                local.get $0
-                local.get $1
-                i32.load8_s
-                i32.store8
-                local.get $0
-                i32.const 1
-                i32.add
-                local.set $0
-                local.get $1
-                i32.const 1
-                i32.add
-                local.set $1
-                local.get $2
-                i32.const 1
-                i32.sub
-                local.set $2
-                br 2 (;@4;)
-              end
-            end
-          end
-          loop $label$7 ;; label = @4
-            local.get $2
-            i32.const 4
-            i32.ge_s
-            if ;; label = @5
-              block ;; label = @6
-                local.get $0
-                local.get $1
-                i32.load
-                i32.store
-                local.get $0
-                i32.const 4
-                i32.add
-                local.set $0
-                local.get $1
-                i32.const 4
-                i32.add
-                local.set $1
-                local.get $2
-                i32.const 4
-                i32.sub
-                local.set $2
-                br 2 (;@4;)
-              end
-            end
-          end
-        end
-      end
-      loop $label$9 ;; label = @2
-        local.get $2
-        i32.const 0
-        i32.gt_s
-        if ;; label = @3
-          block ;; label = @4
-            local.get $0
-            local.get $1
-            i32.load8_s
-            i32.store8
-            local.get $0
-            i32.const 1
-            i32.add
-            local.set $0
-            local.get $1
-            i32.const 1
-            i32.add
-            local.set $1
-            local.get $2
-            i32.const 1
-            i32.sub
-            local.set $2
-            br 2 (;@2;)
-          end
-        end
-      end
-      local.get $3
-    end
-  )
-  (func $41 (;54;) (type $3) (result i32)
-    i32.const 0
-  )
-  (func $42 (;55;) (type $4) (param $0 i32) (param $1 i32) (result i32)
-    local.get $1
-    local.get $0
-    i32.const 1
-    i32.and
-    i32.const 0
-    i32.add
-    call_indirect (type $1)
-  )
-  (func $43 (;56;) (type $12) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32)
-    local.get $1
-    local.get $2
-    local.get $3
-    local.get $0
-    i32.const 3
-    i32.and
-    i32.const 2
-    i32.add
-    call_indirect (type $0)
-  )
-  (func $44 (;57;) (type $5) (param $0 i32) (param $1 i32)
-    local.get $1
-    local.get $0
-    i32.const 1
-    i32.and
-    i32.const 6
-    i32.add
-    call_indirect (type $2)
-  )
-  (func $45 (;58;) (type $1) (param $0 i32) (result i32)
-    block $label$1 (result i32) ;; label = @1
-      i32.const 0
-      call $fimport$3
-      i32.const 0
-    end
-  )
-  (func $46 (;59;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    block $label$1 (result i32) ;; label = @1
-      i32.const 1
-      call $fimport$3
-      i32.const 0
-    end
-  )
-  (func $47 (;60;) (type $2) (param $0 i32)
-    i32.const 2
-    call $fimport$3
-  )
-  (global $global$0 (;5;) (mut i32) global.get $gimport$0)
-  (global $global$1 (;6;) (mut i32) global.get $gimport$1)
-  (global $global$2 (;7;) (mut i32) global.get $gimport$2)
-  (global $global$3 (;8;) (mut i32) i32.const 0)
-  (global $global$4 (;9;) (mut i32) i32.const 0)
-  (global $global$5 (;10;) (mut i32) i32.const 0)
-  (export "_sbrk" (func $38))
-  (export "_free" (func $36))
-  (export "_main" (func $8))
-  (export "_pthread_self" (func $41))
-  (export "_memset" (func $39))
-  (export "_malloc" (func $35))
-  (export "_memcpy" (func $40))
-  (export "___errno_location" (func $12))
-  (export "runPostSets" (func $37))
-  (export "stackAlloc" (func $0))
-  (export "stackSave" (func $1))
-  (export "stackRestore" (func $2))
-  (export "establishStackSpace" (func $3))
-  (export "setThrew" (func $4))
-  (export "setTempRet0" (func $5))
-  (export "getTempRet0" (func $6))
-  (export "dynCall_ii" (func $42))
-  (export "dynCall_iiii" (func $43))
-  (export "dynCall_vi" (func $44))
-  (elem (;0;) (global.get $gimport$19) func $45 $9 $46 $14 $10 $15 $47 $16)
-  (data (;0;) (i32.const 1024) "\04\04\00\00\05")
-  (data (;1;) (i32.const 1040) "\01")
-  (data (;2;) (i32.const 1064) "\01\00\00\00\02\00\00\00<\10\00\00\00\04")
-  (data (;3;) (i32.const 1088) "\01")
-  (data (;4;) (i32.const 1103) "\0a\ff\ff\ff\ff")
-  (data (;5;) (i32.const 1140) "error: %d\0a\00Pfannkuchen(%d) = %d.\0a\00%d\00\11\00\0a\00\11\11\11\00\00\00\00\05\00\00\00\00\00\00\09\00\00\00\00\0b")
-  (data (;6;) (i32.const 1209) "\11\00\0f\0a\11\11\11\03\0a\07\00\01\13\09\0b\0b\00\00\09\06\0b\00\00\0b\00\06\11\00\00\00\11\11\11")
-  (data (;7;) (i32.const 1258) "\0b")
-  (data (;8;) (i32.const 1267) "\11\00\0a\0a\11\11\11\00\0a\00\00\02\00\09\0b\00\00\00\09\00\0b\00\00\0b")
-  (data (;9;) (i32.const 1316) "\0c")
-  (data (;10;) (i32.const 1328) "\0c\00\00\00\00\0c\00\00\00\00\09\0c\00\00\00\00\00\0c\00\00\0c")
-  (data (;11;) (i32.const 1374) "\0e")
-  (data (;12;) (i32.const 1386) "\0d\00\00\00\04\0d\00\00\00\00\09\0e\00\00\00\00\00\0e\00\00\0e")
-  (data (;13;) (i32.const 1432) "\10")
-  (data (;14;) (i32.const 1444) "\0f\00\00\00\00\0f\00\00\00\00\09\10\00\00\00\00\00\10\00\00\10\00\00\12\00\00\00\12\12\12")
-  (data (;15;) (i32.const 1499) "\12\00\00\00\12\12\12\00\00\00\00\00\00\09")
-  (data (;16;) (i32.const 1548) "\0b")
-  (data (;17;) (i32.const 1560) "\0a\00\00\00\00\0a\00\00\00\00\09\0b\00\00\00\00\00\0b\00\00\0b")
-  (data (;18;) (i32.const 1606) "\0c")
-  (data (;19;) (i32.const 1618) "\0c\00\00\00\00\0c\00\00\00\00\09\0c\00\00\00\00\00\0c\00\00\0c\00\000123456789ABCDEF-+   0X0x\00(null)\00-0X+0X 0X-0x+0x 0x\00inf\00INF\00nan\00NAN\00.\00T!\22\19\0d\01\02\03\11K\1c\0c\10\04\0b\1d\12\1e'hnopqb \05\06\0f\13\14\15\1a\08\16\07($\17\18\09\0a\0e\1b\1f%#\83\82}&*+<=>?CGJMXYZ[\5c]^_`acdefgijklrstyz{|\00Illegal byte sequence\00Domain error\00Result not representable\00Not a tty\00Permission denied\00Operation not permitted\00No such file or directory\00No such process\00File exists\00Value too large for data type\00No space left on device\00Out of memory\00Resource busy\00Interrupted system call\00Resource temporarily unavailable\00Invalid seek\00Cross-device link\00Read-only file system\00Directory not empty\00Connection reset by peer\00Operation timed out\00Connection refused\00Host is down\00Host is unreachable\00Address in use\00Broken pipe\00I/O error\00No such device or address\00Block device required\00No such device\00Not a directory\00Is a directory\00Text file busy\00Exec format error\00Invalid argument\00Argument list too long\00Symbolic link loop\00Filename too long\00Too many open files in system\00No file descriptors available\00Bad file descriptor\00No child process\00Bad address\00File too large\00Too many links\00No locks available\00Resource deadlock would occur\00State not recoverable\00Previous owner died\00Operation canceled\00Function not implemented\00No message of desired type\00Identifier removed\00Device not a stream\00No data available\00Device timeout\00Out of streams resources\00Link has been severed\00Protocol error\00Bad message\00File descriptor in bad state\00Not a socket\00Destination address required\00Message too large\00Protocol wrong type for socket\00Protocol not available\00Protocol not supported\00Socket type not supported\00Not supported\00Protocol family not supported\00Address family not supported by protocol\00Address not available\00Network is down\00Network unreachable\00Connection reset by network\00Connection aborted\00No buffer space available\00Socket is connected\00Socket not connected\00Cannot send after socket shutdown\00Operation already in progress\00Operation in progress\00Stale file handle\00Remote I/O error\00Quota exceeded\00No medium found\00Wrong medium type\00No error information")
-)
\ No newline at end of file
diff --git a/cranelift/wasm/wasmtests/embenchen_fasta.wat b/cranelift/wasm/wasmtests/embenchen_fasta.wat
deleted file mode 100644
index 028615e9f3d4..000000000000
--- a/cranelift/wasm/wasmtests/embenchen_fasta.wat
+++ /dev/null
@@ -1,12056 +0,0 @@
-(module
-  (type $0 (;0;) (func (param i32 i32 i32) (result i32)))
-  (type $1 (;1;) (func))
-  (type $2 (;2;) (func (param i32) (result i32)))
-  (type $3 (;3;) (func (param i32)))
-  (type $4 (;4;) (func (result i32)))
-  (type $5 (;5;) (func (param i32 i32)))
-  (type $6 (;6;) (func (param i32 i32) (result i32)))
-  (type $7 (;7;) (func (param i32 i32 i32 i32 i32) (result i32)))
-  (type $8 (;8;) (func (param i32 i32 i32)))
-  (type $9 (;9;) (func (param i64 i32) (result i32)))
-  (type $10 (;10;) (func (param i32 i32 i32 i32 i32)))
-  (type $11 (;11;) (func (param f64 i32) (result f64)))
-  (type $12 (;12;) (func (param i32 i32 i32 i32) (result i32)))
-  (import "env" "memory" (memory $16 (;0;) 2048 2048))
-  (import "env" "table" (table $timport$17 (;0;) 9 9 funcref))
-  (import "env" "DYNAMICTOP_PTR" (global $gimport$0 (;0;) i32))
-  (import "env" "STACKTOP" (global $gimport$1 (;1;) i32))
-  (import "env" "STACK_MAX" (global $gimport$2 (;2;) i32))
-  (import "env" "memoryBase" (global $gimport$18 (;3;) i32))
-  (import "env" "tableBase" (global $gimport$19 (;4;) i32))
-  (import "env" "abort" (func $fimport$3 (;0;) (type $3)))
-  (import "env" "enlargeMemory" (func $fimport$4 (;1;) (type $4)))
-  (import "env" "getTotalMemory" (func $fimport$5 (;2;) (type $4)))
-  (import "env" "abortOnCannotGrowMemory" (func $fimport$6 (;3;) (type $4)))
-  (import "env" "_pthread_cleanup_pop" (func $fimport$7 (;4;) (type $3)))
-  (import "env" "_abort" (func $fimport$8 (;5;) (type $1)))
-  (import "env" "_pthread_cleanup_push" (func $fimport$9 (;6;) (type $5)))
-  (import "env" "___syscall6" (func $fimport$10 (;7;) (type $6)))
-  (import "env" "___setErrNo" (func $fimport$11 (;8;) (type $3)))
-  (import "env" "_emscripten_memcpy_big" (func $fimport$12 (;9;) (type $0)))
-  (import "env" "___syscall54" (func $fimport$13 (;10;) (type $6)))
-  (import "env" "___syscall140" (func $fimport$14 (;11;) (type $6)))
-  (import "env" "___syscall146" (func $fimport$15 (;12;) (type $6)))
-  (func $0 (;13;) (type $2) (param $0 i32) (result i32)
-    (local $1 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $1
-      global.get $global$1
-      local.get $0
-      i32.add
-      global.set $global$1
-      global.get $global$1
-      i32.const 15
-      i32.add
-      i32.const -16
-      i32.and
-      global.set $global$1
-      local.get $1
-    end
-  )
-  (func $1 (;14;) (type $4) (result i32)
-    global.get $global$1
-  )
-  (func $2 (;15;) (type $3) (param $0 i32)
-    local.get $0
-    global.set $global$1
-  )
-  (func $3 (;16;) (type $5) (param $0 i32) (param $1 i32)
-    block $label$1 ;; label = @1
-      local.get $0
-      global.set $global$1
-      local.get $1
-      global.set $global$2
-    end
-  )
-  (func $4 (;17;) (type $5) (param $0 i32) (param $1 i32)
-    global.get $global$3
-    i32.eqz
-    if ;; label = @1
-      block ;; label = @2
-        local.get $0
-        global.set $global$3
-        local.get $1
-        global.set $global$4
-      end
-    end
-  )
-  (func $5 (;18;) (type $3) (param $0 i32)
-    local.get $0
-    global.set $global$5
-  )
-  (func $6 (;19;) (type $4) (result i32)
-    global.get $global$5
-  )
-  (func $7 (;20;) (type $6) (param $0 i32) (param $1 i32) (result i32)
-    (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 f32) (local $12 f32) (local $13 f64)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $5
-      global.get $global$1
-      i32.const 4256
-      i32.add
-      global.set $global$1
-      local.get $5
-      local.set $3
-      local.get $5
-      i32.const 2128
-      i32.add
-      local.set $6
-      local.get $5
-      i32.const 8
-      i32.add
-      local.set $7
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          local.get $0
-          i32.const 1
-          i32.le_s
-          br_if 0 (;@3;)
-          block $label$4 ;; label = @4
-            block $label$5 ;; label = @5
-              block $label$6 ;; label = @6
-                block $label$7 ;; label = @7
-                  block $label$8 ;; label = @8
-                    block $label$9 ;; label = @9
-                      block $label$10 ;; label = @10
-                        local.get $1
-                        i32.load offset=4
-                        i32.load8_s
-                        local.tee $0
-                        i32.const 48
-                        i32.sub
-                        br_table 5 (;@5;) 0 (;@10;) 2 (;@8;) 1 (;@9;) 3 (;@7;) 4 (;@6;) 6 (;@4;)
-                      end
-                      i32.const 950000
-                      local.set $4
-                      br 7 (;@2;)
-                    end
-                    br 5 (;@3;)
-                  end
-                  i32.const 9500000
-                  local.set $4
-                  br 5 (;@2;)
-                end
-                i32.const 95000000
-                local.set $4
-                br 4 (;@2;)
-              end
-              i32.const 190000000
-              local.set $4
-              br 3 (;@2;)
-            end
-            local.get $5
-            global.set $global$1
-            i32.const 0
-            return
-          end
-          local.get $3
-          local.get $0
-          i32.const -48
-          i32.add
-          i32.store
-          i32.const 1400
-          local.get $3
-          call $34
-          drop
-          local.get $5
-          global.set $global$1
-          i32.const -1
-          return
-        end
-        i32.const 19000000
-        local.set $4
-      end
-      i32.const 347
-      call $40
-      local.tee $8
-      i32.const 1411
-      i32.const 287
-      call $47
-      drop
-      local.get $8
-      i32.const 287
-      i32.add
-      local.tee $0
-      i32.const 1411
-      i64.load align=1
-      i64.store align=1
-      local.get $0
-      i32.const 1419
-      i64.load align=1
-      i64.store offset=8 align=1
-      local.get $0
-      i32.const 1427
-      i64.load align=1
-      i64.store offset=16 align=1
-      local.get $0
-      i32.const 1435
-      i64.load align=1
-      i64.store offset=24 align=1
-      local.get $0
-      i32.const 1443
-      i64.load align=1
-      i64.store offset=32 align=1
-      local.get $0
-      i32.const 1451
-      i64.load align=1
-      i64.store offset=40 align=1
-      local.get $0
-      i32.const 1459
-      i64.load align=1
-      i64.store offset=48 align=1
-      local.get $0
-      i32.const 1467
-      i32.load align=1
-      i32.store offset=56 align=1
-      local.get $4
-      i32.const 1
-      i32.shl
-      local.set $0
-      i32.const 0
-      local.set $1
-      loop $label$11 ;; label = @2
-        local.get $0
-        i32.const 60
-        i32.lt_u
-        if (result i32) ;; label = @3
-          local.get $0
-        else
-          i32.const 60
-        end
-        local.tee $3
-        i32.const 2
-        i32.add
-        call $40
-        local.tee $2
-        local.get $8
-        local.get $1
-        i32.add
-        local.get $3
-        call $47
-        drop
-        local.get $2
-        local.get $3
-        i32.add
-        i32.const 0
-        i32.store8
-        local.get $2
-        call $31
-        local.tee $10
-        i32.const 1024
-        i32.load
-        local.tee $9
-        i32.gt_s
-        if ;; label = @3
-          local.get $9
-          i32.const 0
-          i32.gt_s
-          if ;; label = @4
-            block ;; label = @5
-              local.get $2
-              local.get $9
-              i32.add
-              i32.const 0
-              i32.store8
-              local.get $2
-              call $35
-              drop
-              i32.const 1024
-              i32.const 0
-              i32.store
-            end
-          end
-        else
-          block ;; label = @4
-            local.get $2
-            call $35
-            drop
-            i32.const 1024
-            i32.const 1024
-            i32.load
-            local.get $10
-            i32.sub
-            i32.store
-          end
-        end
-        local.get $2
-        call $41
-        local.get $3
-        local.get $1
-        i32.add
-        local.tee $2
-        i32.const -287
-        i32.add
-        local.set $1
-        local.get $2
-        i32.const 287
-        i32.le_u
-        if ;; label = @3
-          local.get $2
-          local.set $1
-        end
-        local.get $0
-        local.get $3
-        i32.sub
-        local.tee $0
-        br_if 0 (;@2;)
-      end
-      local.get $8
-      call $42
-      i32.const 1028
-      i32.load
-      if ;; label = @2
-        block ;; label = @3
-          i32.const 1028
-          local.set $0
-          f32.const 0x0p+0 (;=0;)
-          local.set $11
-          loop $label$19 ;; label = @4
-            local.get $11
-            local.get $0
-            i32.const 4
-            i32.add
-            local.tee $1
-            f32.load
-            f32.add
-            local.tee $11
-            f64.promote_f32
-            local.tee $13
-            f64.const 0x1p+0 (;=1;)
-            f64.lt
-            if (result f64) ;; label = @5
-              local.get $13
-            else
-              f64.const 0x1p+0 (;=1;)
-            end
-            f32.demote_f64
-            local.set $12
-            local.get $1
-            local.get $12
-            f32.store
-            local.get $0
-            local.get $12
-            f32.const 0x1p+9 (;=512;)
-            f32.mul
-            i32.trunc_f32_s
-            i32.store offset=8
-            local.get $0
-            i32.const 12
-            i32.add
-            local.tee $0
-            i32.load
-            br_if 0 (;@4;)
-            i32.const 0
-            local.set $1
-            i32.const 1028
-            local.set $0
-          end
-        end
-      else
-        block ;; label = @3
-          i32.const 0
-          local.set $1
-          i32.const 1028
-          local.set $0
-        end
-      end
-      loop $label$23 ;; label = @2
-        loop $label$24 ;; label = @3
-          local.get $0
-          i32.const 12
-          i32.add
-          local.set $3
-          local.get $1
-          local.get $0
-          i32.load offset=8
-          local.tee $2
-          i32.gt_u
-          local.get $2
-          i32.const 0
-          i32.ne
-          i32.and
-          if ;; label = @4
-            block ;; label = @5
-              local.get $3
-              local.set $0
-              br 2 (;@3;)
-            end
-          end
-        end
-        local.get $6
-        local.get $1
-        i32.const 2
-        i32.shl
-        i32.add
-        local.get $0
-        i32.store
-        local.get $1
-        i32.const 1
-        i32.add
-        local.tee $1
-        i32.const 513
-        i32.ne
-        br_if 0 (;@2;)
-      end
-      local.get $6
-      i32.const 2116
-      i32.add
-      i32.const 0
-      i32.store
-      local.get $4
-      i32.const 3
-      i32.mul
-      local.set $0
-      loop $label$26 ;; label = @2
-        local.get $6
-        local.get $0
-        i32.const 60
-        i32.lt_u
-        if (result i32) ;; label = @3
-          local.get $0
-        else
-          i32.const 60
-        end
-        local.tee $1
-        call $8
-        local.get $0
-        local.get $1
-        i32.sub
-        local.tee $0
-        br_if 0 (;@2;)
-      end
-      i32.const 1220
-      i32.load
-      if ;; label = @2
-        block ;; label = @3
-          i32.const 1220
-          local.set $0
-          f32.const 0x0p+0 (;=0;)
-          local.set $11
-          loop $label$30 ;; label = @4
-            local.get $11
-            local.get $0
-            i32.const 4
-            i32.add
-            local.tee $1
-            f32.load
-            f32.add
-            local.tee $11
-            f64.promote_f32
-            local.tee $13
-            f64.const 0x1p+0 (;=1;)
-            f64.lt
-            if (result f64) ;; label = @5
-              local.get $13
-            else
-              f64.const 0x1p+0 (;=1;)
-            end
-            f32.demote_f64
-            local.set $12
-            local.get $1
-            local.get $12
-            f32.store
-            local.get $0
-            local.get $12
-            f32.const 0x1p+9 (;=512;)
-            f32.mul
-            i32.trunc_f32_s
-            i32.store offset=8
-            local.get $0
-            i32.const 12
-            i32.add
-            local.tee $0
-            i32.load
-            br_if 0 (;@4;)
-            i32.const 0
-            local.set $1
-            i32.const 1220
-            local.set $0
-          end
-        end
-      else
-        block ;; label = @3
-          i32.const 0
-          local.set $1
-          i32.const 1220
-          local.set $0
-        end
-      end
-      loop $label$34 ;; label = @2
-        loop $label$35 ;; label = @3
-          local.get $0
-          i32.const 12
-          i32.add
-          local.set $3
-          local.get $1
-          local.get $0
-          i32.load offset=8
-          local.tee $2
-          i32.gt_u
-          local.get $2
-          i32.const 0
-          i32.ne
-          i32.and
-          if ;; label = @4
-            block ;; label = @5
-              local.get $3
-              local.set $0
-              br 2 (;@3;)
-            end
-          end
-        end
-        local.get $7
-        local.get $1
-        i32.const 2
-        i32.shl
-        i32.add
-        local.get $0
-        i32.store
-        local.get $1
-        i32.const 1
-        i32.add
-        local.tee $1
-        i32.const 513
-        i32.ne
-        br_if 0 (;@2;)
-      end
-      local.get $7
-      i32.const 2116
-      i32.add
-      i32.const 0
-      i32.store
-      local.get $4
-      i32.const 5
-      i32.mul
-      local.set $0
-      loop $label$37 ;; label = @2
-        local.get $7
-        local.get $0
-        i32.const 60
-        i32.lt_u
-        if (result i32) ;; label = @3
-          local.get $0
-        else
-          i32.const 60
-        end
-        local.tee $1
-        call $8
-        local.get $0
-        local.get $1
-        i32.sub
-        local.tee $0
-        br_if 0 (;@2;)
-        i32.const 0
-        local.set $0
-      end
-      local.get $5
-      global.set $global$1
-      local.get $0
-    end
-  )
-  (func $8 (;21;) (type $5) (param $0 i32) (param $1 i32)
-    (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 f32)
-    block $label$1 ;; label = @1
-      local.get $1
-      if ;; label = @2
-        block ;; label = @3
-          i32.const 0
-          local.set $3
-          i32.const 1396
-          i32.load
-          local.set $2
-          loop $label$3 ;; label = @4
-            local.get $0
-            local.get $2
-            i32.const 3877
-            i32.mul
-            i32.const 29573
-            i32.add
-            i32.const 139968
-            i32.rem_u
-            local.tee $4
-            f32.convert_i32_u
-            f32.const 0x1.116p+17 (;=139968;)
-            f32.div
-            local.tee $6
-            f32.const 0x1p+9 (;=512;)
-            f32.mul
-            i32.trunc_f32_s
-            i32.const 2
-            i32.shl
-            i32.add
-            i32.load
-            local.set $2
-            loop $label$4 ;; label = @5
-              local.get $2
-              i32.const 12
-              i32.add
-              local.set $5
-              local.get $2
-              f32.load offset=4
-              local.get $6
-              f32.lt
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $5
-                  local.set $2
-                  br 2 (;@5;)
-                end
-              end
-            end
-            local.get $0
-            i32.const 2052
-            i32.add
-            local.get $3
-            i32.add
-            local.get $2
-            i32.load
-            i32.store8
-            local.get $3
-            i32.const 1
-            i32.add
-            local.tee $3
-            local.get $1
-            i32.ne
-            if ;; label = @5
-              block ;; label = @6
-                local.get $4
-                local.set $2
-                br 2 (;@4;)
-              end
-            end
-          end
-          i32.const 1396
-          local.get $4
-          i32.store
-        end
-      end
-      local.get $0
-      i32.const 2052
-      i32.add
-      local.get $1
-      i32.add
-      i32.const 10
-      i32.store8
-      local.get $0
-      i32.const 2052
-      i32.add
-      local.get $1
-      i32.const 1
-      i32.add
-      local.tee $1
-      i32.add
-      i32.const 0
-      i32.store8
-      local.get $0
-      i32.const 2116
-      i32.add
-      local.get $1
-      i32.store
-      local.get $0
-      i32.const 2052
-      i32.add
-      local.tee $1
-      call $31
-      local.tee $3
-      i32.const 1024
-      i32.load
-      local.tee $2
-      i32.le_s
-      if ;; label = @2
-        block ;; label = @3
-          local.get $1
-          call $35
-          drop
-          i32.const 1024
-          i32.const 1024
-          i32.load
-          local.get $3
-          i32.sub
-          i32.store
-          return
-        end
-      end
-      local.get $2
-      i32.const 0
-      i32.le_s
-      if ;; label = @2
-        return
-      end
-      local.get $0
-      i32.const 2052
-      i32.add
-      local.get $2
-      i32.add
-      i32.const 0
-      i32.store8
-      local.get $1
-      call $35
-      drop
-      local.get $0
-      i32.const 2052
-      i32.add
-      i32.const 1024
-      i32.load
-      i32.add
-      i32.const 122
-      i32.store8
-      i32.const 1024
-      i32.const 0
-      i32.store
-    end
-  )
-  (func $9 (;22;) (type $2) (param $0 i32) (result i32)
-    (local $1 i32) (local $2 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $1
-      global.get $global$1
-      i32.const 16
-      i32.add
-      global.set $global$1
-      local.get $1
-      local.tee $2
-      local.get $0
-      i32.load offset=60
-      i32.store
-      i32.const 6
-      local.get $2
-      call $fimport$10
-      call $11
-      local.set $0
-      local.get $1
-      global.set $global$1
-      local.get $0
-    end
-  )
-  (func $10 (;23;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32) (local $4 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $4
-      global.get $global$1
-      i32.const 32
-      i32.add
-      global.set $global$1
-      local.get $4
-      local.tee $3
-      local.get $0
-      i32.load offset=60
-      i32.store
-      local.get $3
-      i32.const 0
-      i32.store offset=4
-      local.get $3
-      local.get $1
-      i32.store offset=8
-      local.get $3
-      local.get $4
-      i32.const 20
-      i32.add
-      local.tee $0
-      i32.store offset=12
-      local.get $3
-      local.get $2
-      i32.store offset=16
-      i32.const 140
-      local.get $3
-      call $fimport$14
-      call $11
-      i32.const 0
-      i32.lt_s
-      if (result i32) ;; label = @2
-        block (result i32) ;; label = @3
-          local.get $0
-          i32.const -1
-          i32.store
-          i32.const -1
-        end
-      else
-        local.get $0
-        i32.load
-      end
-      local.set $0
-      local.get $4
-      global.set $global$1
-      local.get $0
-    end
-  )
-  (func $11 (;24;) (type $2) (param $0 i32) (result i32)
-    local.get $0
-    i32.const -4096
-    i32.gt_u
-    if (result i32) ;; label = @1
-      block (result i32) ;; label = @2
-        call $12
-        i32.const 0
-        local.get $0
-        i32.sub
-        i32.store
-        i32.const -1
-      end
-    else
-      local.get $0
-    end
-  )
-  (func $12 (;25;) (type $4) (result i32)
-    i32.const 4172
-  )
-  (func $13 (;26;) (type $3) (param $0 i32)
-    nop
-  )
-  (func $14 (;27;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32) (local $4 i32) (local $5 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $4
-      global.get $global$1
-      i32.const 80
-      i32.add
-      global.set $global$1
-      local.get $4
-      local.set $3
-      local.get $4
-      i32.const 12
-      i32.add
-      local.set $5
-      local.get $0
-      i32.const 3
-      i32.store offset=36
-      local.get $0
-      i32.load
-      i32.const 64
-      i32.and
-      i32.eqz
-      if ;; label = @2
-        block ;; label = @3
-          local.get $3
-          local.get $0
-          i32.load offset=60
-          i32.store
-          local.get $3
-          i32.const 21505
-          i32.store offset=4
-          local.get $3
-          local.get $5
-          i32.store offset=8
-          i32.const 54
-          local.get $3
-          call $fimport$13
-          if ;; label = @4
-            local.get $0
-            i32.const -1
-            i32.store8 offset=75
-          end
-        end
-      end
-      local.get $0
-      local.get $1
-      local.get $2
-      call $15
-      local.set $0
-      local.get $4
-      global.set $global$1
-      local.get $0
-    end
-  )
-  (func $15 (;28;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $8
-      global.get $global$1
-      i32.const 48
-      i32.add
-      global.set $global$1
-      local.get $8
-      i32.const 16
-      i32.add
-      local.set $9
-      local.get $8
-      local.set $10
-      local.get $8
-      i32.const 32
-      i32.add
-      local.tee $3
-      local.get $0
-      i32.const 28
-      i32.add
-      local.tee $6
-      i32.load
-      local.tee $4
-      i32.store
-      local.get $3
-      local.get $0
-      i32.const 20
-      i32.add
-      local.tee $11
-      i32.load
-      local.get $4
-      i32.sub
-      local.tee $5
-      i32.store offset=4
-      local.get $3
-      local.get $1
-      i32.store offset=8
-      local.get $3
-      local.get $2
-      i32.store offset=12
-      local.get $0
-      i32.const 60
-      i32.add
-      local.set $13
-      local.get $0
-      i32.const 44
-      i32.add
-      local.set $14
-      local.get $3
-      local.set $1
-      i32.const 2
-      local.set $4
-      local.get $5
-      local.get $2
-      i32.add
-      local.set $12
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          block $label$4 ;; label = @4
-            loop $label$5 ;; label = @5
-              i32.const 4128
-              i32.load
-              if ;; label = @6
-                block ;; label = @7
-                  i32.const 1
-                  local.get $0
-                  call $fimport$9
-                  local.get $10
-                  local.get $13
-                  i32.load
-                  i32.store
-                  local.get $10
-                  local.get $1
-                  i32.store offset=4
-                  local.get $10
-                  local.get $4
-                  i32.store offset=8
-                  i32.const 146
-                  local.get $10
-                  call $fimport$15
-                  call $11
-                  local.set $3
-                  i32.const 0
-                  call $fimport$7
-                end
-              else
-                block ;; label = @7
-                  local.get $9
-                  local.get $13
-                  i32.load
-                  i32.store
-                  local.get $9
-                  local.get $1
-                  i32.store offset=4
-                  local.get $9
-                  local.get $4
-                  i32.store offset=8
-                  i32.const 146
-                  local.get $9
-                  call $fimport$15
-                  call $11
-                  local.set $3
-                end
-              end
-              local.get $12
-              local.get $3
-              i32.eq
-              br_if 1 (;@4;)
-              local.get $3
-              i32.const 0
-              i32.lt_s
-              br_if 2 (;@3;)
-              local.get $3
-              local.get $1
-              i32.load offset=4
-              local.tee $5
-              i32.gt_u
-              if (result i32) ;; label = @6
-                block (result i32) ;; label = @7
-                  local.get $6
-                  local.get $14
-                  i32.load
-                  local.tee $7
-                  i32.store
-                  local.get $11
-                  local.get $7
-                  i32.store
-                  local.get $1
-                  i32.load offset=12
-                  local.set $7
-                  local.get $1
-                  i32.const 8
-                  i32.add
-                  local.set $1
-                  local.get $4
-                  i32.const -1
-                  i32.add
-                  local.set $4
-                  local.get $3
-                  local.get $5
-                  i32.sub
-                end
-              else
-                local.get $4
-                i32.const 2
-                i32.eq
-                if (result i32) ;; label = @7
-                  block (result i32) ;; label = @8
-                    local.get $6
-                    local.get $6
-                    i32.load
-                    local.get $3
-                    i32.add
-                    i32.store
-                    local.get $5
-                    local.set $7
-                    i32.const 2
-                    local.set $4
-                    local.get $3
-                  end
-                else
-                  block (result i32) ;; label = @8
-                    local.get $5
-                    local.set $7
-                    local.get $3
-                  end
-                end
-              end
-              local.set $5
-              local.get $1
-              local.get $1
-              i32.load
-              local.get $5
-              i32.add
-              i32.store
-              local.get $1
-              local.get $7
-              local.get $5
-              i32.sub
-              i32.store offset=4
-              local.get $12
-              local.get $3
-              i32.sub
-              local.set $12
-              br 0 (;@5;)
-            end
-          end
-          local.get $0
-          local.get $14
-          i32.load
-          local.tee $1
-          local.get $0
-          i32.load offset=48
-          i32.add
-          i32.store offset=16
-          local.get $6
-          local.get $1
-          i32.store
-          local.get $11
-          local.get $1
-          i32.store
-          br 1 (;@2;)
-        end
-        local.get $0
-        i32.const 0
-        i32.store offset=16
-        local.get $6
-        i32.const 0
-        i32.store
-        local.get $11
-        i32.const 0
-        i32.store
-        local.get $0
-        local.get $0
-        i32.load
-        i32.const 32
-        i32.or
-        i32.store
-        local.get $4
-        i32.const 2
-        i32.eq
-        if (result i32) ;; label = @3
-          i32.const 0
-        else
-          local.get $2
-          local.get $1
-          i32.load offset=4
-          i32.sub
-        end
-        local.set $2
-      end
-      local.get $8
-      global.set $global$1
-      local.get $2
-    end
-  )
-  (func $16 (;29;) (type $3) (param $0 i32)
-    local.get $0
-    i32.load offset=68
-    i32.eqz
-    if ;; label = @1
-      local.get $0
-      call $13
-    end
-  )
-  (func $17 (;30;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32) (local $4 i32) (local $5 i32)
-    block $label$1 (result i32) ;; label = @1
-      local.get $1
-      i32.const 255
-      i32.and
-      local.set $5
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          block $label$4 ;; label = @4
-            local.get $2
-            i32.const 0
-            i32.ne
-            local.tee $4
-            local.get $0
-            i32.const 3
-            i32.and
-            i32.const 0
-            i32.ne
-            i32.and
-            if ;; label = @5
-              block ;; label = @6
-                local.get $1
-                i32.const 255
-                i32.and
-                local.set $4
-                local.get $2
-                local.set $3
-                local.get $0
-                local.set $2
-                loop $label$6 ;; label = @7
-                  local.get $2
-                  i32.load8_s
-                  local.get $4
-                  i32.const 24
-                  i32.shl
-                  i32.const 24
-                  i32.shr_s
-                  i32.eq
-                  if ;; label = @8
-                    block ;; label = @9
-                      local.get $3
-                      local.set $0
-                      br 6 (;@3;)
-                    end
-                  end
-                  local.get $3
-                  i32.const -1
-                  i32.add
-                  local.tee $3
-                  i32.const 0
-                  i32.ne
-                  local.tee $0
-                  local.get $2
-                  i32.const 1
-                  i32.add
-                  local.tee $2
-                  i32.const 3
-                  i32.and
-                  i32.const 0
-                  i32.ne
-                  i32.and
-                  br_if 0 (;@7;)
-                  br 3 (;@4;)
-                end
-              end
-            else
-              block ;; label = @6
-                local.get $2
-                local.set $3
-                local.get $0
-                local.set $2
-                local.get $4
-                local.set $0
-              end
-            end
-          end
-          local.get $0
-          if ;; label = @4
-            block ;; label = @5
-              local.get $3
-              local.set $0
-              br 2 (;@3;)
-            end
-          else
-            i32.const 0
-            local.set $0
-          end
-          br 1 (;@2;)
-        end
-        local.get $2
-        i32.load8_s
-        local.get $1
-        i32.const 255
-        i32.and
-        local.tee $1
-        i32.const 24
-        i32.shl
-        i32.const 24
-        i32.shr_s
-        i32.ne
-        if ;; label = @3
-          block ;; label = @4
-            local.get $5
-            i32.const 16843009
-            i32.mul
-            local.set $3
-            block $label$12 ;; label = @5
-              block $label$13 ;; label = @6
-                local.get $0
-                i32.const 3
-                i32.le_u
-                br_if 0 (;@6;)
-                loop $label$14 ;; label = @7
-                  local.get $2
-                  i32.load
-                  local.get $3
-                  i32.xor
-                  local.tee $4
-                  i32.const -2139062144
-                  i32.and
-                  i32.const -2139062144
-                  i32.xor
-                  local.get $4
-                  i32.const -16843009
-                  i32.add
-                  i32.and
-                  i32.eqz
-                  if ;; label = @8
-                    block ;; label = @9
-                      local.get $2
-                      i32.const 4
-                      i32.add
-                      local.set $2
-                      local.get $0
-                      i32.const -4
-                      i32.add
-                      local.tee $0
-                      i32.const 3
-                      i32.gt_u
-                      br_if 2 (;@7;)
-                      br 3 (;@6;)
-                    end
-                  end
-                end
-                br 1 (;@5;)
-              end
-              local.get $0
-              i32.eqz
-              if ;; label = @6
-                block ;; label = @7
-                  i32.const 0
-                  local.set $0
-                  br 5 (;@2;)
-                end
-              end
-            end
-            loop $label$17 ;; label = @5
-              local.get $2
-              i32.load8_s
-              local.get $1
-              i32.const 24
-              i32.shl
-              i32.const 24
-              i32.shr_s
-              i32.eq
-              br_if 3 (;@2;)
-              local.get $2
-              i32.const 1
-              i32.add
-              local.set $2
-              local.get $0
-              i32.const -1
-              i32.add
-              local.tee $0
-              br_if 0 (;@5;)
-              i32.const 0
-              local.set $0
-            end
-          end
-        end
-      end
-      local.get $0
-      if (result i32) ;; label = @2
-        local.get $2
-      else
-        i32.const 0
-      end
-    end
-  )
-  (func $18 (;31;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $4
-      global.get $global$1
-      i32.const 224
-      i32.add
-      global.set $global$1
-      local.get $4
-      i32.const 136
-      i32.add
-      local.set $5
-      local.get $4
-      i32.const 80
-      i32.add
-      local.tee $3
-      i64.const 0
-      i64.store align=4
-      local.get $3
-      i64.const 0
-      i64.store offset=8 align=4
-      local.get $3
-      i64.const 0
-      i64.store offset=16 align=4
-      local.get $3
-      i64.const 0
-      i64.store offset=24 align=4
-      local.get $3
-      i64.const 0
-      i64.store offset=32 align=4
-      local.get $4
-      i32.const 120
-      i32.add
-      local.tee $6
-      local.get $2
-      i32.load
-      i32.store
-      i32.const 0
-      local.get $1
-      local.get $6
-      local.get $4
-      local.tee $2
-      local.get $3
-      call $19
-      i32.const 0
-      i32.lt_s
-      if ;; label = @2
-        i32.const -1
-        local.set $1
-      else
-        block ;; label = @3
-          local.get $0
-          i32.load offset=76
-          i32.const -1
-          i32.gt_s
-          if (result i32) ;; label = @4
-            local.get $0
-            call $20
-          else
-            i32.const 0
-          end
-          local.set $12
-          local.get $0
-          i32.load
-          local.set $7
-          local.get $0
-          i32.load8_s offset=74
-          i32.const 1
-          i32.lt_s
-          if ;; label = @4
-            local.get $0
-            local.get $7
-            i32.const -33
-            i32.and
-            i32.store
-          end
-          local.get $0
-          i32.const 48
-          i32.add
-          local.tee $8
-          i32.load
-          if ;; label = @4
-            local.get $0
-            local.get $1
-            local.get $6
-            local.get $2
-            local.get $3
-            call $19
-            local.set $1
-          else
-            block ;; label = @5
-              local.get $0
-              i32.const 44
-              i32.add
-              local.tee $9
-              i32.load
-              local.set $10
-              local.get $9
-              local.get $5
-              i32.store
-              local.get $0
-              i32.const 28
-              i32.add
-              local.tee $13
-              local.get $5
-              i32.store
-              local.get $0
-              i32.const 20
-              i32.add
-              local.tee $11
-              local.get $5
-              i32.store
-              local.get $8
-              i32.const 80
-              i32.store
-              local.get $0
-              i32.const 16
-              i32.add
-              local.tee $14
-              local.get $5
-              i32.const 80
-              i32.add
-              i32.store
-              local.get $0
-              local.get $1
-              local.get $6
-              local.get $2
-              local.get $3
-              call $19
-              local.set $1
-              local.get $10
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $0
-                  i32.const 0
-                  i32.const 0
-                  local.get $0
-                  i32.load offset=36
-                  i32.const 3
-                  i32.and
-                  i32.const 2
-                  i32.add
-                  call_indirect (type $0)
-                  drop
-                  local.get $11
-                  i32.load
-                  i32.eqz
-                  if ;; label = @8
-                    i32.const -1
-                    local.set $1
-                  end
-                  local.get $9
-                  local.get $10
-                  i32.store
-                  local.get $8
-                  i32.const 0
-                  i32.store
-                  local.get $14
-                  i32.const 0
-                  i32.store
-                  local.get $13
-                  i32.const 0
-                  i32.store
-                  local.get $11
-                  i32.const 0
-                  i32.store
-                end
-              end
-            end
-          end
-          local.get $0
-          local.get $0
-          i32.load
-          local.tee $2
-          local.get $7
-          i32.const 32
-          i32.and
-          i32.or
-          i32.store
-          local.get $12
-          if ;; label = @4
-            local.get $0
-            call $13
-          end
-          local.get $2
-          i32.const 32
-          i32.and
-          if ;; label = @4
-            i32.const -1
-            local.set $1
-          end
-        end
-      end
-      local.get $4
-      global.set $global$1
-      local.get $1
-    end
-  )
-  (func $19 (;32;) (type $7) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32) (result i32)
-    (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32) (local $15 i32) (local $16 i32) (local $17 i32) (local $18 i32) (local $19 i32) (local $20 i32) (local $21 i32) (local $22 i32) (local $23 i32) (local $24 i32) (local $25 i32) (local $26 i32) (local $27 i32) (local $28 i32) (local $29 i32) (local $30 i32) (local $31 i32) (local $32 i32) (local $33 i32) (local $34 i32) (local $35 i32) (local $36 i32) (local $37 i32) (local $38 i32) (local $39 i32) (local $40 i32) (local $41 i32) (local $42 i32) (local $43 i32) (local $44 i32) (local $45 i32) (local $46 i32) (local $47 i32) (local $48 i32) (local $49 i32) (local $50 i64) (local $51 i64) (local $52 f64) (local $53 f64)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $23
-      global.get $global$1
-      i32.const 624
-      i32.add
-      global.set $global$1
-      local.get $23
-      i32.const 16
-      i32.add
-      local.set $20
-      local.get $23
-      local.set $16
-      local.get $23
-      i32.const 528
-      i32.add
-      local.set $36
-      local.get $0
-      i32.const 0
-      i32.ne
-      local.set $30
-      local.get $23
-      i32.const 536
-      i32.add
-      local.tee $17
-      i32.const 40
-      i32.add
-      local.tee $21
-      local.set $38
-      local.get $17
-      i32.const 39
-      i32.add
-      local.set $39
-      local.get $23
-      i32.const 8
-      i32.add
-      local.tee $37
-      i32.const 4
-      i32.add
-      local.set $42
-      i32.const 0
-      local.get $23
-      i32.const 588
-      i32.add
-      local.tee $19
-      local.tee $27
-      i32.sub
-      local.set $43
-      local.get $23
-      i32.const 576
-      i32.add
-      local.tee $17
-      i32.const 12
-      i32.add
-      local.set $33
-      local.get $17
-      i32.const 11
-      i32.add
-      local.set $40
-      local.get $33
-      local.tee $28
-      local.get $27
-      i32.sub
-      local.set $44
-      i32.const -2
-      local.get $27
-      i32.sub
-      local.set $45
-      local.get $28
-      i32.const 2
-      i32.add
-      local.set $46
-      local.get $23
-      i32.const 24
-      i32.add
-      local.tee $47
-      i32.const 288
-      i32.add
-      local.set $48
-      local.get $19
-      i32.const 9
-      i32.add
-      local.tee $31
-      local.set $41
-      local.get $19
-      i32.const 8
-      i32.add
-      local.set $34
-      i32.const 0
-      local.set $15
-      i32.const 0
-      local.set $10
-      i32.const 0
-      local.set $17
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          loop $label$4 ;; label = @4
-            block $label$5 ;; label = @5
-              local.get $15
-              i32.const -1
-              i32.gt_s
-              if ;; label = @6
-                local.get $10
-                i32.const 2147483647
-                local.get $15
-                i32.sub
-                i32.gt_s
-                if (result i32) ;; label = @7
-                  block (result i32) ;; label = @8
-                    call $12
-                    i32.const 75
-                    i32.store
-                    i32.const -1
-                  end
-                else
-                  local.get $10
-                  local.get $15
-                  i32.add
-                end
-                local.set $15
-              end
-              local.get $1
-              i32.load8_s
-              local.tee $5
-              i32.const 24
-              i32.shl
-              i32.const 24
-              i32.shr_s
-              i32.eqz
-              br_if 2 (;@3;)
-              local.get $1
-              local.set $11
-              block $label$9 ;; label = @6
-                block $label$10 ;; label = @7
-                  loop $label$11 ;; label = @8
-                    block $label$12 ;; label = @9
-                      block $label$13 ;; label = @10
-                        block $label$14 ;; label = @11
-                          block $label$15 ;; label = @12
-                            local.get $5
-                            i32.const 24
-                            i32.shl
-                            i32.const 24
-                            i32.shr_s
-                            i32.const 0
-                            i32.sub
-                            br_table 1 (;@11;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 0 (;@12;) 2 (;@10;)
-                          end
-                          local.get $11
-                          local.set $5
-                          br 4 (;@7;)
-                        end
-                        local.get $11
-                        local.set $5
-                        br 1 (;@9;)
-                      end
-                      local.get $11
-                      i32.const 1
-                      i32.add
-                      local.tee $11
-                      i32.load8_s
-                      local.set $5
-                      br 1 (;@8;)
-                    end
-                  end
-                  br 1 (;@6;)
-                end
-                loop $label$16 ;; label = @7
-                  local.get $5
-                  i32.load8_s offset=1
-                  i32.const 37
-                  i32.ne
-                  br_if 1 (;@6;)
-                  local.get $11
-                  i32.const 1
-                  i32.add
-                  local.set $11
-                  local.get $5
-                  i32.const 2
-                  i32.add
-                  local.tee $5
-                  i32.load8_s
-                  i32.const 37
-                  i32.eq
-                  br_if 0 (;@7;)
-                end
-              end
-              local.get $11
-              local.get $1
-              i32.sub
-              local.set $10
-              local.get $30
-              if ;; label = @6
-                local.get $0
-                i32.load
-                i32.const 32
-                i32.and
-                i32.eqz
-                if ;; label = @7
-                  local.get $1
-                  local.get $10
-                  local.get $0
-                  call $21
-                  drop
-                end
-              end
-              local.get $10
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $5
-                  local.set $1
-                  br 3 (;@4;)
-                end
-              end
-              local.get $5
-              i32.const 1
-              i32.add
-              local.tee $11
-              i32.load8_s
-              local.tee $10
-              i32.const 24
-              i32.shl
-              i32.const 24
-              i32.shr_s
-              i32.const -48
-              i32.add
-              local.tee $9
-              i32.const 10
-              i32.lt_u
-              if (result i32) ;; label = @6
-                block (result i32) ;; label = @7
-                  local.get $5
-                  i32.const 3
-                  i32.add
-                  local.set $10
-                  local.get $5
-                  i32.load8_s offset=2
-                  i32.const 36
-                  i32.eq
-                  local.tee $12
-                  if ;; label = @8
-                    local.get $10
-                    local.set $11
-                  end
-                  local.get $12
-                  if ;; label = @8
-                    i32.const 1
-                    local.set $17
-                  end
-                  local.get $11
-                  i32.load8_s
-                  local.set $5
-                  local.get $12
-                  i32.eqz
-                  if ;; label = @8
-                    i32.const -1
-                    local.set $9
-                  end
-                  local.get $17
-                end
-              else
-                block (result i32) ;; label = @7
-                  local.get $10
-                  local.set $5
-                  i32.const -1
-                  local.set $9
-                  local.get $17
-                end
-              end
-              local.set $10
-              block $label$25 ;; label = @6
-                local.get $5
-                i32.const 24
-                i32.shl
-                i32.const 24
-                i32.shr_s
-                i32.const -32
-                i32.add
-                local.tee $12
-                i32.const 32
-                i32.lt_u
-                if ;; label = @7
-                  block ;; label = @8
-                    i32.const 0
-                    local.set $17
-                    loop $label$27 ;; label = @9
-                      i32.const 1
-                      local.get $12
-                      i32.shl
-                      i32.const 75913
-                      i32.and
-                      i32.eqz
-                      br_if 3 (;@6;)
-                      i32.const 1
-                      local.get $5
-                      i32.const 24
-                      i32.shl
-                      i32.const 24
-                      i32.shr_s
-                      i32.const -32
-                      i32.add
-                      i32.shl
-                      local.get $17
-                      i32.or
-                      local.set $17
-                      local.get $11
-                      i32.const 1
-                      i32.add
-                      local.tee $11
-                      i32.load8_s
-                      local.tee $5
-                      i32.const 24
-                      i32.shl
-                      i32.const 24
-                      i32.shr_s
-                      i32.const -32
-                      i32.add
-                      local.tee $12
-                      i32.const 32
-                      i32.lt_u
-                      br_if 0 (;@9;)
-                    end
-                  end
-                else
-                  i32.const 0
-                  local.set $17
-                end
-              end
-              block $label$29 ;; label = @6
-                local.get $5
-                i32.const 24
-                i32.shl
-                i32.const 24
-                i32.shr_s
-                i32.const 42
-                i32.eq
-                if ;; label = @7
-                  block ;; label = @8
-                    block $label$31 (result i32) ;; label = @9
-                      block $label$32 ;; label = @10
-                        local.get $11
-                        i32.const 1
-                        i32.add
-                        local.tee $7
-                        i32.load8_s
-                        local.tee $5
-                        i32.const 24
-                        i32.shl
-                        i32.const 24
-                        i32.shr_s
-                        i32.const -48
-                        i32.add
-                        local.tee $12
-                        i32.const 10
-                        i32.ge_u
-                        br_if 0 (;@10;)
-                        local.get $11
-                        i32.load8_s offset=2
-                        i32.const 36
-                        i32.ne
-                        br_if 0 (;@10;)
-                        local.get $4
-                        local.get $12
-                        i32.const 2
-                        i32.shl
-                        i32.add
-                        i32.const 10
-                        i32.store
-                        i32.const 1
-                        local.set $8
-                        local.get $3
-                        local.get $7
-                        i32.load8_s
-                        i32.const -48
-                        i32.add
-                        i32.const 3
-                        i32.shl
-                        i32.add
-                        i64.load
-                        i32.wrap_i64
-                        local.set $10
-                        local.get $11
-                        i32.const 3
-                        i32.add
-                        br 1 (;@9;)
-                      end
-                      local.get $10
-                      if ;; label = @10
-                        block ;; label = @11
-                          i32.const -1
-                          local.set $15
-                          br 6 (;@5;)
-                        end
-                      end
-                      local.get $30
-                      i32.eqz
-                      if ;; label = @10
-                        block ;; label = @11
-                          local.get $17
-                          local.set $12
-                          i32.const 0
-                          local.set $17
-                          local.get $7
-                          local.set $11
-                          i32.const 0
-                          local.set $10
-                          br 5 (;@6;)
-                        end
-                      end
-                      local.get $2
-                      i32.load
-                      i32.const 3
-                      i32.add
-                      i32.const -4
-                      i32.and
-                      local.tee $11
-                      i32.load
-                      local.set $10
-                      local.get $2
-                      local.get $11
-                      i32.const 4
-                      i32.add
-                      i32.store
-                      i32.const 0
-                      local.set $8
-                      local.get $7
-                    end
-                    local.set $11
-                    local.get $17
-                    i32.const 8192
-                    i32.or
-                    local.set $12
-                    i32.const 0
-                    local.get $10
-                    i32.sub
-                    local.set $7
-                    local.get $11
-                    i32.load8_s
-                    local.set $5
-                    local.get $10
-                    i32.const 0
-                    i32.lt_s
-                    local.tee $6
-                    i32.eqz
-                    if ;; label = @9
-                      local.get $17
-                      local.set $12
-                    end
-                    local.get $8
-                    local.set $17
-                    local.get $6
-                    if ;; label = @9
-                      local.get $7
-                      local.set $10
-                    end
-                  end
-                else
-                  local.get $5
-                  i32.const 24
-                  i32.shl
-                  i32.const 24
-                  i32.shr_s
-                  i32.const -48
-                  i32.add
-                  local.tee $12
-                  i32.const 10
-                  i32.lt_u
-                  if ;; label = @8
-                    block ;; label = @9
-                      i32.const 0
-                      local.set $7
-                      local.get $12
-                      local.set $5
-                      loop $label$39 ;; label = @10
-                        local.get $7
-                        i32.const 10
-                        i32.mul
-                        local.get $5
-                        i32.add
-                        local.set $7
-                        local.get $11
-                        i32.const 1
-                        i32.add
-                        local.tee $11
-                        i32.load8_s
-                        local.tee $12
-                        i32.const 24
-                        i32.shl
-                        i32.const 24
-                        i32.shr_s
-                        i32.const -48
-                        i32.add
-                        local.tee $5
-                        i32.const 10
-                        i32.lt_u
-                        br_if 0 (;@10;)
-                      end
-                      local.get $7
-                      i32.const 0
-                      i32.lt_s
-                      if ;; label = @10
-                        block ;; label = @11
-                          i32.const -1
-                          local.set $15
-                          br 6 (;@5;)
-                        end
-                      else
-                        block ;; label = @11
-                          local.get $12
-                          local.set $5
-                          local.get $17
-                          local.set $12
-                          local.get $10
-                          local.set $17
-                          local.get $7
-                          local.set $10
-                        end
-                      end
-                    end
-                  else
-                    block ;; label = @9
-                      local.get $17
-                      local.set $12
-                      local.get $10
-                      local.set $17
-                      i32.const 0
-                      local.set $10
-                    end
-                  end
-                end
-              end
-              block $label$43 ;; label = @6
-                local.get $5
-                i32.const 24
-                i32.shl
-                i32.const 24
-                i32.shr_s
-                i32.const 46
-                i32.eq
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $11
-                    i32.const 1
-                    i32.add
-                    local.tee $7
-                    i32.load8_s
-                    local.tee $5
-                    i32.const 24
-                    i32.shl
-                    i32.const 24
-                    i32.shr_s
-                    i32.const 42
-                    i32.ne
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $5
-                        i32.const 24
-                        i32.shl
-                        i32.const 24
-                        i32.shr_s
-                        i32.const -48
-                        i32.add
-                        local.tee $5
-                        i32.const 10
-                        i32.lt_u
-                        if ;; label = @11
-                          block ;; label = @12
-                            local.get $7
-                            local.set $11
-                            i32.const 0
-                            local.set $7
-                          end
-                        else
-                          block ;; label = @12
-                            i32.const 0
-                            local.set $5
-                            local.get $7
-                            local.set $11
-                            br 6 (;@6;)
-                          end
-                        end
-                        loop $label$48 ;; label = @11
-                          local.get $7
-                          i32.const 10
-                          i32.mul
-                          local.get $5
-                          i32.add
-                          local.set $5
-                          local.get $11
-                          i32.const 1
-                          i32.add
-                          local.tee $11
-                          i32.load8_s
-                          i32.const -48
-                          i32.add
-                          local.tee $8
-                          i32.const 10
-                          i32.ge_u
-                          br_if 5 (;@6;)
-                          local.get $5
-                          local.set $7
-                          local.get $8
-                          local.set $5
-                          br 0 (;@11;)
-                        end
-                      end
-                    end
-                    local.get $11
-                    i32.const 2
-                    i32.add
-                    local.tee $7
-                    i32.load8_s
-                    i32.const -48
-                    i32.add
-                    local.tee $5
-                    i32.const 10
-                    i32.lt_u
-                    if ;; label = @9
-                      local.get $11
-                      i32.load8_s offset=3
-                      i32.const 36
-                      i32.eq
-                      if ;; label = @10
-                        block ;; label = @11
-                          local.get $4
-                          local.get $5
-                          i32.const 2
-                          i32.shl
-                          i32.add
-                          i32.const 10
-                          i32.store
-                          local.get $3
-                          local.get $7
-                          i32.load8_s
-                          i32.const -48
-                          i32.add
-                          i32.const 3
-                          i32.shl
-                          i32.add
-                          i64.load
-                          i32.wrap_i64
-                          local.set $5
-                          local.get $11
-                          i32.const 4
-                          i32.add
-                          local.set $11
-                          br 5 (;@6;)
-                        end
-                      end
-                    end
-                    local.get $17
-                    if ;; label = @9
-                      block ;; label = @10
-                        i32.const -1
-                        local.set $15
-                        br 5 (;@5;)
-                      end
-                    end
-                    local.get $30
-                    if (result i32) ;; label = @9
-                      block (result i32) ;; label = @10
-                        local.get $2
-                        i32.load
-                        i32.const 3
-                        i32.add
-                        i32.const -4
-                        i32.and
-                        local.tee $11
-                        i32.load
-                        local.set $5
-                        local.get $2
-                        local.get $11
-                        i32.const 4
-                        i32.add
-                        i32.store
-                        local.get $7
-                      end
-                    else
-                      block (result i32) ;; label = @10
-                        i32.const 0
-                        local.set $5
-                        local.get $7
-                      end
-                    end
-                    local.set $11
-                  end
-                else
-                  i32.const -1
-                  local.set $5
-                end
-              end
-              local.get $11
-              local.set $7
-              i32.const 0
-              local.set $8
-              loop $label$55 ;; label = @6
-                local.get $7
-                i32.load8_s
-                i32.const -65
-                i32.add
-                local.tee $6
-                i32.const 57
-                i32.gt_u
-                if ;; label = @7
-                  block ;; label = @8
-                    i32.const -1
-                    local.set $15
-                    br 3 (;@5;)
-                  end
-                end
-                local.get $7
-                i32.const 1
-                i32.add
-                local.set $11
-                local.get $8
-                i32.const 58
-                i32.mul
-                i32.const 1699
-                i32.add
-                local.get $6
-                i32.add
-                i32.load8_s
-                local.tee $13
-                i32.const 255
-                i32.and
-                local.tee $6
-                i32.const -1
-                i32.add
-                i32.const 8
-                i32.lt_u
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $11
-                    local.set $7
-                    local.get $6
-                    local.set $8
-                    br 2 (;@6;)
-                  end
-                end
-              end
-              local.get $13
-              i32.const 24
-              i32.shl
-              i32.const 24
-              i32.shr_s
-              i32.eqz
-              if ;; label = @6
-                block ;; label = @7
-                  i32.const -1
-                  local.set $15
-                  br 2 (;@5;)
-                end
-              end
-              local.get $9
-              i32.const -1
-              i32.gt_s
-              local.set $14
-              block $label$59 ;; label = @6
-                block $label$60 ;; label = @7
-                  local.get $13
-                  i32.const 24
-                  i32.shl
-                  i32.const 24
-                  i32.shr_s
-                  i32.const 19
-                  i32.eq
-                  if ;; label = @8
-                    local.get $14
-                    if ;; label = @9
-                      block ;; label = @10
-                        i32.const -1
-                        local.set $15
-                        br 5 (;@5;)
-                      end
-                    else
-                      br 2 (;@7;)
-                    end
-                  else
-                    block ;; label = @9
-                      local.get $14
-                      if ;; label = @10
-                        block ;; label = @11
-                          local.get $4
-                          local.get $9
-                          i32.const 2
-                          i32.shl
-                          i32.add
-                          local.get $6
-                          i32.store
-                          local.get $16
-                          local.get $3
-                          local.get $9
-                          i32.const 3
-                          i32.shl
-                          i32.add
-                          i64.load
-                          i64.store
-                          br 4 (;@7;)
-                        end
-                      end
-                      local.get $30
-                      i32.eqz
-                      if ;; label = @10
-                        block ;; label = @11
-                          i32.const 0
-                          local.set $15
-                          br 6 (;@5;)
-                        end
-                      end
-                      local.get $16
-                      local.get $6
-                      local.get $2
-                      call $22
-                    end
-                  end
-                  br 1 (;@6;)
-                end
-                local.get $30
-                i32.eqz
-                if ;; label = @7
-                  block ;; label = @8
-                    i32.const 0
-                    local.set $10
-                    local.get $11
-                    local.set $1
-                    br 4 (;@4;)
-                  end
-                end
-              end
-              local.get $7
-              i32.load8_s
-              local.tee $7
-              i32.const -33
-              i32.and
-              local.set $9
-              local.get $8
-              i32.const 0
-              i32.ne
-              local.get $7
-              i32.const 15
-              i32.and
-              i32.const 3
-              i32.eq
-              i32.and
-              i32.eqz
-              if ;; label = @6
-                local.get $7
-                local.set $9
-              end
-              local.get $12
-              i32.const -65537
-              i32.and
-              local.set $7
-              local.get $12
-              i32.const 8192
-              i32.and
-              if ;; label = @6
-                local.get $7
-                local.set $12
-              end
-              block $label$70 ;; label = @6
-                block $label$71 ;; label = @7
-                  block $label$72 ;; label = @8
-                    block $label$73 ;; label = @9
-                      block $label$74 ;; label = @10
-                        block $label$75 ;; label = @11
-                          block $label$76 ;; label = @12
-                            block $label$77 ;; label = @13
-                              block $label$78 ;; label = @14
-                                block $label$79 ;; label = @15
-                                  block $label$80 ;; label = @16
-                                    block $label$81 ;; label = @17
-                                      block $label$82 ;; label = @18
-                                        block $label$83 ;; label = @19
-                                          block $label$84 ;; label = @20
-                                            block $label$85 ;; label = @21
-                                              block $label$86 ;; label = @22
-                                                block $label$87 ;; label = @23
-                                                  block $label$88 ;; label = @24
-                                                    block $label$89 ;; label = @25
-                                                      local.get $9
-                                                      i32.const 65
-                                                      i32.sub
-                                                      br_table 11 (;@14;) 12 (;@13;) 9 (;@16;) 12 (;@13;) 11 (;@14;) 11 (;@14;) 11 (;@14;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 10 (;@15;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 2 (;@23;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 11 (;@14;) 12 (;@13;) 6 (;@19;) 4 (;@21;) 11 (;@14;) 11 (;@14;) 11 (;@14;) 12 (;@13;) 4 (;@21;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 7 (;@18;) 0 (;@25;) 3 (;@22;) 1 (;@24;) 12 (;@13;) 12 (;@13;) 8 (;@17;) 12 (;@13;) 5 (;@20;) 12 (;@13;) 12 (;@13;) 2 (;@23;) 12 (;@13;)
-                                                    end
-                                                    block $label$90 ;; label = @25
-                                                      block $label$91 ;; label = @26
-                                                        block $label$92 ;; label = @27
-                                                          block $label$93 ;; label = @28
-                                                            block $label$94 ;; label = @29
-                                                              block $label$95 ;; label = @30
-                                                                block $label$96 ;; label = @31
-                                                                  block $label$97 ;; label = @32
-                                                                    local.get $8
-                                                                    i32.const 255
-                                                                    i32.and
-                                                                    i32.const 24
-                                                                    i32.shl
-                                                                    i32.const 24
-                                                                    i32.shr_s
-                                                                    i32.const 0
-                                                                    i32.sub
-                                                                    br_table 0 (;@32;) 1 (;@31;) 2 (;@30;) 3 (;@29;) 4 (;@28;) 7 (;@25;) 5 (;@27;) 6 (;@26;) 7 (;@25;)
-                                                                  end
-                                                                  local.get $16
-                                                                  i32.load
-                                                                  local.get $15
-                                                                  i32.store
-                                                                  i32.const 0
-                                                                  local.set $10
-                                                                  local.get $11
-                                                                  local.set $1
-                                                                  br 27 (;@4;)
-                                                                end
-                                                                local.get $16
-                                                                i32.load
-                                                                local.get $15
-                                                                i32.store
-                                                                i32.const 0
-                                                                local.set $10
-                                                                local.get $11
-                                                                local.set $1
-                                                                br 26 (;@4;)
-                                                              end
-                                                              local.get $16
-                                                              i32.load
-                                                              local.get $15
-                                                              i64.extend_i32_s
-                                                              i64.store
-                                                              i32.const 0
-                                                              local.set $10
-                                                              local.get $11
-                                                              local.set $1
-                                                              br 25 (;@4;)
-                                                            end
-                                                            local.get $16
-                                                            i32.load
-                                                            local.get $15
-                                                            i32.store16
-                                                            i32.const 0
-                                                            local.set $10
-                                                            local.get $11
-                                                            local.set $1
-                                                            br 24 (;@4;)
-                                                          end
-                                                          local.get $16
-                                                          i32.load
-                                                          local.get $15
-                                                          i32.store8
-                                                          i32.const 0
-                                                          local.set $10
-                                                          local.get $11
-                                                          local.set $1
-                                                          br 23 (;@4;)
-                                                        end
-                                                        local.get $16
-                                                        i32.load
-                                                        local.get $15
-                                                        i32.store
-                                                        i32.const 0
-                                                        local.set $10
-                                                        local.get $11
-                                                        local.set $1
-                                                        br 22 (;@4;)
-                                                      end
-                                                      local.get $16
-                                                      i32.load
-                                                      local.get $15
-                                                      i64.extend_i32_s
-                                                      i64.store
-                                                      i32.const 0
-                                                      local.set $10
-                                                      local.get $11
-                                                      local.set $1
-                                                      br 21 (;@4;)
-                                                    end
-                                                    i32.const 0
-                                                    local.set $10
-                                                    local.get $11
-                                                    local.set $1
-                                                    br 20 (;@4;)
-                                                  end
-                                                  local.get $12
-                                                  i32.const 8
-                                                  i32.or
-                                                  local.set $12
-                                                  local.get $5
-                                                  i32.const 8
-                                                  i32.le_u
-                                                  if ;; label = @24
-                                                    i32.const 8
-                                                    local.set $5
-                                                  end
-                                                  i32.const 120
-                                                  local.set $9
-                                                  br 11 (;@12;)
-                                                end
-                                                br 10 (;@12;)
-                                              end
-                                              local.get $16
-                                              i64.load
-                                              local.tee $50
-                                              i64.const 0
-                                              i64.eq
-                                              if ;; label = @22
-                                                local.get $21
-                                                local.set $7
-                                              else
-                                                block ;; label = @23
-                                                  local.get $21
-                                                  local.set $1
-                                                  loop $label$101 ;; label = @24
-                                                    local.get $1
-                                                    i32.const -1
-                                                    i32.add
-                                                    local.tee $1
-                                                    local.get $50
-                                                    i64.const 7
-                                                    i64.and
-                                                    i64.const 48
-                                                    i64.or
-                                                    i64.store8
-                                                    local.get $50
-                                                    i64.const 3
-                                                    i64.shr_u
-                                                    local.tee $50
-                                                    i64.const 0
-                                                    i64.ne
-                                                    br_if 0 (;@24;)
-                                                    local.get $1
-                                                    local.set $7
-                                                  end
-                                                end
-                                              end
-                                              local.get $12
-                                              i32.const 8
-                                              i32.and
-                                              if ;; label = @22
-                                                block ;; label = @23
-                                                  local.get $38
-                                                  local.get $7
-                                                  i32.sub
-                                                  local.tee $1
-                                                  i32.const 1
-                                                  i32.add
-                                                  local.set $8
-                                                  local.get $5
-                                                  local.get $1
-                                                  i32.le_s
-                                                  if ;; label = @24
-                                                    local.get $8
-                                                    local.set $5
-                                                  end
-                                                  i32.const 0
-                                                  local.set $6
-                                                  i32.const 2179
-                                                  local.set $8
-                                                  br 16 (;@7;)
-                                                end
-                                              else
-                                                block ;; label = @23
-                                                  i32.const 0
-                                                  local.set $6
-                                                  i32.const 2179
-                                                  local.set $8
-                                                  br 16 (;@7;)
-                                                end
-                                              end
-                                            end
-                                            local.get $16
-                                            i64.load
-                                            local.tee $50
-                                            i64.const 0
-                                            i64.lt_s
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                local.get $16
-                                                i64.const 0
-                                                local.get $50
-                                                i64.sub
-                                                local.tee $50
-                                                i64.store
-                                                i32.const 1
-                                                local.set $6
-                                                i32.const 2179
-                                                local.set $8
-                                                br 11 (;@11;)
-                                              end
-                                            end
-                                            local.get $12
-                                            i32.const 2048
-                                            i32.and
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                i32.const 1
-                                                local.set $6
-                                                i32.const 2180
-                                                local.set $8
-                                                br 11 (;@11;)
-                                              end
-                                            else
-                                              block ;; label = @22
-                                                local.get $12
-                                                i32.const 1
-                                                i32.and
-                                                local.tee $1
-                                                local.set $6
-                                                local.get $1
-                                                if (result i32) ;; label = @23
-                                                  i32.const 2181
-                                                else
-                                                  i32.const 2179
-                                                end
-                                                local.set $8
-                                                br 11 (;@11;)
-                                              end
-                                            end
-                                          end
-                                          local.get $16
-                                          i64.load
-                                          local.set $50
-                                          i32.const 0
-                                          local.set $6
-                                          i32.const 2179
-                                          local.set $8
-                                          br 8 (;@11;)
-                                        end
-                                        local.get $39
-                                        local.get $16
-                                        i64.load
-                                        i64.store8
-                                        local.get $39
-                                        local.set $1
-                                        local.get $7
-                                        local.set $12
-                                        i32.const 1
-                                        local.set $7
-                                        i32.const 0
-                                        local.set $6
-                                        i32.const 2179
-                                        local.set $8
-                                        local.get $21
-                                        local.set $5
-                                        br 12 (;@6;)
-                                      end
-                                      call $12
-                                      i32.load
-                                      call $24
-                                      local.set $1
-                                      br 7 (;@10;)
-                                    end
-                                    local.get $16
-                                    i32.load
-                                    local.tee $1
-                                    i32.eqz
-                                    if ;; label = @17
-                                      i32.const 2189
-                                      local.set $1
-                                    end
-                                    br 6 (;@10;)
-                                  end
-                                  local.get $37
-                                  local.get $16
-                                  i64.load
-                                  i64.store32
-                                  local.get $42
-                                  i32.const 0
-                                  i32.store
-                                  local.get $16
-                                  local.get $37
-                                  i32.store
-                                  local.get $37
-                                  local.set $7
-                                  i32.const -1
-                                  local.set $6
-                                  br 6 (;@9;)
-                                end
-                                local.get $16
-                                i32.load
-                                local.set $7
-                                local.get $5
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $5
-                                    local.set $6
-                                    br 7 (;@9;)
-                                  end
-                                else
-                                  block ;; label = @16
-                                    local.get $0
-                                    i32.const 32
-                                    local.get $10
-                                    i32.const 0
-                                    local.get $12
-                                    call $25
-                                    i32.const 0
-                                    local.set $1
-                                    br 8 (;@8;)
-                                  end
-                                end
-                              end
-                              local.get $16
-                              f64.load
-                              local.set $52
-                              local.get $20
-                              i32.const 0
-                              i32.store
-                              local.get $52
-                              i64.reinterpret_f64
-                              i64.const 0
-                              i64.lt_s
-                              if (result i32) ;; label = @14
-                                block (result i32) ;; label = @15
-                                  i32.const 1
-                                  local.set $24
-                                  local.get $52
-                                  f64.neg
-                                  local.set $52
-                                  i32.const 2196
-                                end
-                              else
-                                block (result i32) ;; label = @15
-                                  local.get $12
-                                  i32.const 1
-                                  i32.and
-                                  local.set $1
-                                  local.get $12
-                                  i32.const 2048
-                                  i32.and
-                                  if (result i32) ;; label = @16
-                                    block (result i32) ;; label = @17
-                                      i32.const 1
-                                      local.set $24
-                                      i32.const 2199
-                                    end
-                                  else
-                                    block (result i32) ;; label = @17
-                                      local.get $1
-                                      local.set $24
-                                      local.get $1
-                                      if (result i32) ;; label = @18
-                                        i32.const 2202
-                                      else
-                                        i32.const 2197
-                                      end
-                                    end
-                                  end
-                                end
-                              end
-                              local.set $26
-                              block $label$119 ;; label = @14
-                                local.get $52
-                                i64.reinterpret_f64
-                                i64.const 9218868437227405312
-                                i64.and
-                                i64.const 9218868437227405312
-                                i64.lt_u
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $52
-                                    local.get $20
-                                    call $27
-                                    f64.const 0x1p+1 (;=2;)
-                                    f64.mul
-                                    local.tee $52
-                                    f64.const 0x0p+0 (;=0;)
-                                    f64.ne
-                                    local.tee $1
-                                    if ;; label = @17
-                                      local.get $20
-                                      local.get $20
-                                      i32.load
-                                      i32.const -1
-                                      i32.add
-                                      i32.store
-                                    end
-                                    local.get $9
-                                    i32.const 32
-                                    i32.or
-                                    local.tee $22
-                                    i32.const 97
-                                    i32.eq
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        local.get $26
-                                        i32.const 9
-                                        i32.add
-                                        local.set $1
-                                        local.get $9
-                                        i32.const 32
-                                        i32.and
-                                        local.tee $6
-                                        if ;; label = @19
-                                          local.get $1
-                                          local.set $26
-                                        end
-                                        local.get $5
-                                        i32.const 11
-                                        i32.gt_u
-                                        i32.const 12
-                                        local.get $5
-                                        i32.sub
-                                        local.tee $1
-                                        i32.eqz
-                                        i32.or
-                                        i32.eqz
-                                        if ;; label = @19
-                                          block ;; label = @20
-                                            f64.const 0x1p+3 (;=8;)
-                                            local.set $53
-                                            loop $label$125 ;; label = @21
-                                              local.get $53
-                                              f64.const 0x1p+4 (;=16;)
-                                              f64.mul
-                                              local.set $53
-                                              local.get $1
-                                              i32.const -1
-                                              i32.add
-                                              local.tee $1
-                                              br_if 0 (;@21;)
-                                            end
-                                            local.get $26
-                                            i32.load8_s
-                                            i32.const 45
-                                            i32.eq
-                                            if (result f64) ;; label = @21
-                                              local.get $53
-                                              local.get $52
-                                              f64.neg
-                                              local.get $53
-                                              f64.sub
-                                              f64.add
-                                              f64.neg
-                                            else
-                                              local.get $52
-                                              local.get $53
-                                              f64.add
-                                              local.get $53
-                                              f64.sub
-                                            end
-                                            local.set $52
-                                          end
-                                        end
-                                        i32.const 0
-                                        local.get $20
-                                        i32.load
-                                        local.tee $7
-                                        i32.sub
-                                        local.set $1
-                                        local.get $7
-                                        i32.const 0
-                                        i32.lt_s
-                                        if (result i32) ;; label = @19
-                                          local.get $1
-                                        else
-                                          local.get $7
-                                        end
-                                        i64.extend_i32_s
-                                        local.get $33
-                                        call $23
-                                        local.tee $1
-                                        local.get $33
-                                        i32.eq
-                                        if ;; label = @19
-                                          block ;; label = @20
-                                            local.get $40
-                                            i32.const 48
-                                            i32.store8
-                                            local.get $40
-                                            local.set $1
-                                          end
-                                        end
-                                        local.get $24
-                                        i32.const 2
-                                        i32.or
-                                        local.set $13
-                                        local.get $1
-                                        i32.const -1
-                                        i32.add
-                                        local.get $7
-                                        i32.const 31
-                                        i32.shr_s
-                                        i32.const 2
-                                        i32.and
-                                        i32.const 43
-                                        i32.add
-                                        i32.store8
-                                        local.get $1
-                                        i32.const -2
-                                        i32.add
-                                        local.tee $8
-                                        local.get $9
-                                        i32.const 15
-                                        i32.add
-                                        i32.store8
-                                        local.get $5
-                                        i32.const 1
-                                        i32.lt_s
-                                        local.set $9
-                                        local.get $12
-                                        i32.const 8
-                                        i32.and
-                                        i32.eqz
-                                        local.set $14
-                                        local.get $19
-                                        local.set $1
-                                        loop $label$131 ;; label = @19
-                                          local.get $1
-                                          local.get $52
-                                          i32.trunc_f64_s
-                                          local.tee $7
-                                          i32.const 2163
-                                          i32.add
-                                          i32.load8_u
-                                          local.get $6
-                                          i32.or
-                                          i32.store8
-                                          local.get $52
-                                          local.get $7
-                                          f64.convert_i32_s
-                                          f64.sub
-                                          f64.const 0x1p+4 (;=16;)
-                                          f64.mul
-                                          local.set $52
-                                          block $label$132 (result i32) ;; label = @20
-                                            local.get $1
-                                            i32.const 1
-                                            i32.add
-                                            local.tee $7
-                                            local.get $27
-                                            i32.sub
-                                            i32.const 1
-                                            i32.eq
-                                            if (result i32) ;; label = @21
-                                              block (result i32) ;; label = @22
-                                                local.get $7
-                                                local.get $14
-                                                local.get $9
-                                                local.get $52
-                                                f64.const 0x0p+0 (;=0;)
-                                                f64.eq
-                                                i32.and
-                                                i32.and
-                                                br_if 2 (;@20;)
-                                                drop
-                                                local.get $7
-                                                i32.const 46
-                                                i32.store8
-                                                local.get $1
-                                                i32.const 2
-                                                i32.add
-                                              end
-                                            else
-                                              local.get $7
-                                            end
-                                          end
-                                          local.set $1
-                                          local.get $52
-                                          f64.const 0x0p+0 (;=0;)
-                                          f64.ne
-                                          br_if 0 (;@19;)
-                                        end
-                                        local.get $46
-                                        local.get $5
-                                        i32.add
-                                        local.get $8
-                                        local.tee $7
-                                        i32.sub
-                                        local.set $6
-                                        local.get $44
-                                        local.get $7
-                                        i32.sub
-                                        local.get $1
-                                        i32.add
-                                        local.set $9
-                                        local.get $0
-                                        i32.const 32
-                                        local.get $10
-                                        local.get $5
-                                        i32.const 0
-                                        i32.ne
-                                        local.get $45
-                                        local.get $1
-                                        i32.add
-                                        local.get $5
-                                        i32.lt_s
-                                        i32.and
-                                        if (result i32) ;; label = @19
-                                          local.get $6
-                                        else
-                                          local.get $9
-                                          local.tee $6
-                                        end
-                                        local.get $13
-                                        i32.add
-                                        local.tee $5
-                                        local.get $12
-                                        call $25
-                                        local.get $0
-                                        i32.load
-                                        i32.const 32
-                                        i32.and
-                                        i32.eqz
-                                        if ;; label = @19
-                                          local.get $26
-                                          local.get $13
-                                          local.get $0
-                                          call $21
-                                          drop
-                                        end
-                                        local.get $0
-                                        i32.const 48
-                                        local.get $10
-                                        local.get $5
-                                        local.get $12
-                                        i32.const 65536
-                                        i32.xor
-                                        call $25
-                                        local.get $1
-                                        local.get $27
-                                        i32.sub
-                                        local.set $1
-                                        local.get $0
-                                        i32.load
-                                        i32.const 32
-                                        i32.and
-                                        i32.eqz
-                                        if ;; label = @19
-                                          local.get $19
-                                          local.get $1
-                                          local.get $0
-                                          call $21
-                                          drop
-                                        end
-                                        local.get $0
-                                        i32.const 48
-                                        local.get $6
-                                        local.get $1
-                                        local.get $28
-                                        local.get $7
-                                        i32.sub
-                                        local.tee $1
-                                        i32.add
-                                        i32.sub
-                                        i32.const 0
-                                        i32.const 0
-                                        call $25
-                                        local.get $0
-                                        i32.load
-                                        i32.const 32
-                                        i32.and
-                                        i32.eqz
-                                        if ;; label = @19
-                                          local.get $8
-                                          local.get $1
-                                          local.get $0
-                                          call $21
-                                          drop
-                                        end
-                                        local.get $0
-                                        i32.const 32
-                                        local.get $10
-                                        local.get $5
-                                        local.get $12
-                                        i32.const 8192
-                                        i32.xor
-                                        call $25
-                                        local.get $5
-                                        local.get $10
-                                        i32.ge_s
-                                        if ;; label = @19
-                                          local.get $5
-                                          local.set $10
-                                        end
-                                        br 4 (;@14;)
-                                      end
-                                    end
-                                    local.get $1
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        local.get $20
-                                        local.get $20
-                                        i32.load
-                                        i32.const -28
-                                        i32.add
-                                        local.tee $6
-                                        i32.store
-                                        local.get $52
-                                        f64.const 0x1p+28 (;=268435456;)
-                                        f64.mul
-                                        local.set $52
-                                      end
-                                    else
-                                      local.get $20
-                                      i32.load
-                                      local.set $6
-                                    end
-                                    local.get $6
-                                    i32.const 0
-                                    i32.lt_s
-                                    if (result i32) ;; label = @17
-                                      local.get $47
-                                    else
-                                      local.get $48
-                                    end
-                                    local.tee $7
-                                    local.set $8
-                                    loop $label$145 ;; label = @17
-                                      local.get $8
-                                      local.get $52
-                                      i32.trunc_f64_s
-                                      local.tee $1
-                                      i32.store
-                                      local.get $8
-                                      i32.const 4
-                                      i32.add
-                                      local.set $8
-                                      local.get $52
-                                      local.get $1
-                                      f64.convert_i32_u
-                                      f64.sub
-                                      f64.const 0x1.dcd65p+29 (;=1000000000;)
-                                      f64.mul
-                                      local.tee $52
-                                      f64.const 0x0p+0 (;=0;)
-                                      f64.ne
-                                      br_if 0 (;@17;)
-                                    end
-                                    local.get $6
-                                    i32.const 0
-                                    i32.gt_s
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        local.get $7
-                                        local.set $1
-                                        loop $label$147 ;; label = @19
-                                          local.get $6
-                                          i32.const 29
-                                          i32.gt_s
-                                          if (result i32) ;; label = @20
-                                            i32.const 29
-                                          else
-                                            local.get $6
-                                          end
-                                          local.set $14
-                                          block $label$150 ;; label = @20
-                                            local.get $8
-                                            i32.const -4
-                                            i32.add
-                                            local.tee $6
-                                            local.get $1
-                                            i32.ge_u
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                local.get $14
-                                                i64.extend_i32_u
-                                                local.set $50
-                                                i32.const 0
-                                                local.set $13
-                                                loop $label$152 ;; label = @23
-                                                  local.get $6
-                                                  local.get $6
-                                                  i32.load
-                                                  i64.extend_i32_u
-                                                  local.get $50
-                                                  i64.shl
-                                                  local.get $13
-                                                  i64.extend_i32_u
-                                                  i64.add
-                                                  local.tee $51
-                                                  i64.const 1000000000
-                                                  i64.rem_u
-                                                  i64.store32
-                                                  local.get $51
-                                                  i64.const 1000000000
-                                                  i64.div_u
-                                                  i32.wrap_i64
-                                                  local.set $13
-                                                  local.get $6
-                                                  i32.const -4
-                                                  i32.add
-                                                  local.tee $6
-                                                  local.get $1
-                                                  i32.ge_u
-                                                  br_if 0 (;@23;)
-                                                end
-                                                local.get $13
-                                                i32.eqz
-                                                br_if 2 (;@20;)
-                                                local.get $1
-                                                i32.const -4
-                                                i32.add
-                                                local.tee $1
-                                                local.get $13
-                                                i32.store
-                                              end
-                                            end
-                                          end
-                                          loop $label$153 ;; label = @20
-                                            local.get $8
-                                            local.get $1
-                                            i32.gt_u
-                                            if ;; label = @21
-                                              local.get $8
-                                              i32.const -4
-                                              i32.add
-                                              local.tee $6
-                                              i32.load
-                                              i32.eqz
-                                              if ;; label = @22
-                                                block ;; label = @23
-                                                  local.get $6
-                                                  local.set $8
-                                                  br 3 (;@20;)
-                                                end
-                                              end
-                                            end
-                                          end
-                                          local.get $20
-                                          local.get $20
-                                          i32.load
-                                          local.get $14
-                                          i32.sub
-                                          local.tee $6
-                                          i32.store
-                                          local.get $6
-                                          i32.const 0
-                                          i32.gt_s
-                                          br_if 0 (;@19;)
-                                        end
-                                      end
-                                    else
-                                      local.get $7
-                                      local.set $1
-                                    end
-                                    local.get $5
-                                    i32.const 0
-                                    i32.lt_s
-                                    if (result i32) ;; label = @17
-                                      i32.const 6
-                                    else
-                                      local.get $5
-                                    end
-                                    local.set $18
-                                    local.get $6
-                                    i32.const 0
-                                    i32.lt_s
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        local.get $18
-                                        i32.const 25
-                                        i32.add
-                                        i32.const 9
-                                        i32.div_s
-                                        i32.const 1
-                                        i32.add
-                                        local.set $14
-                                        local.get $22
-                                        i32.const 102
-                                        i32.eq
-                                        local.set $25
-                                        local.get $8
-                                        local.set $5
-                                        loop $label$160 ;; label = @19
-                                          i32.const 0
-                                          local.get $6
-                                          i32.sub
-                                          local.tee $13
-                                          i32.const 9
-                                          i32.gt_s
-                                          if ;; label = @20
-                                            i32.const 9
-                                            local.set $13
-                                          end
-                                          block $label$162 ;; label = @20
-                                            local.get $1
-                                            local.get $5
-                                            i32.lt_u
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                i32.const 1
-                                                local.get $13
-                                                i32.shl
-                                                i32.const -1
-                                                i32.add
-                                                local.set $29
-                                                i32.const 1000000000
-                                                local.get $13
-                                                i32.shr_u
-                                                local.set $35
-                                                i32.const 0
-                                                local.set $6
-                                                local.get $1
-                                                local.set $8
-                                                loop $label$164 ;; label = @23
-                                                  local.get $8
-                                                  local.get $8
-                                                  i32.load
-                                                  local.tee $32
-                                                  local.get $13
-                                                  i32.shr_u
-                                                  local.get $6
-                                                  i32.add
-                                                  i32.store
-                                                  local.get $32
-                                                  local.get $29
-                                                  i32.and
-                                                  local.get $35
-                                                  i32.mul
-                                                  local.set $6
-                                                  local.get $8
-                                                  i32.const 4
-                                                  i32.add
-                                                  local.tee $8
-                                                  local.get $5
-                                                  i32.lt_u
-                                                  br_if 0 (;@23;)
-                                                end
-                                                local.get $1
-                                                i32.const 4
-                                                i32.add
-                                                local.set $8
-                                                local.get $1
-                                                i32.load
-                                                i32.eqz
-                                                if ;; label = @23
-                                                  local.get $8
-                                                  local.set $1
-                                                end
-                                                local.get $6
-                                                i32.eqz
-                                                br_if 2 (;@20;)
-                                                local.get $5
-                                                local.get $6
-                                                i32.store
-                                                local.get $5
-                                                i32.const 4
-                                                i32.add
-                                                local.set $5
-                                              end
-                                            else
-                                              block ;; label = @22
-                                                local.get $1
-                                                i32.const 4
-                                                i32.add
-                                                local.set $8
-                                                local.get $1
-                                                i32.load
-                                                i32.eqz
-                                                if ;; label = @23
-                                                  local.get $8
-                                                  local.set $1
-                                                end
-                                              end
-                                            end
-                                          end
-                                          local.get $25
-                                          if (result i32) ;; label = @20
-                                            local.get $7
-                                          else
-                                            local.get $1
-                                          end
-                                          local.tee $8
-                                          local.get $14
-                                          i32.const 2
-                                          i32.shl
-                                          i32.add
-                                          local.set $6
-                                          local.get $5
-                                          local.get $8
-                                          i32.sub
-                                          i32.const 2
-                                          i32.shr_s
-                                          local.get $14
-                                          i32.gt_s
-                                          if ;; label = @20
-                                            local.get $6
-                                            local.set $5
-                                          end
-                                          local.get $20
-                                          local.get $20
-                                          i32.load
-                                          local.get $13
-                                          i32.add
-                                          local.tee $6
-                                          i32.store
-                                          local.get $6
-                                          i32.const 0
-                                          i32.lt_s
-                                          br_if 0 (;@19;)
-                                          local.get $5
-                                          local.set $13
-                                        end
-                                      end
-                                    else
-                                      local.get $8
-                                      local.set $13
-                                    end
-                                    local.get $7
-                                    local.set $25
-                                    block $label$172 ;; label = @17
-                                      local.get $1
-                                      local.get $13
-                                      i32.lt_u
-                                      if ;; label = @18
-                                        block ;; label = @19
-                                          local.get $25
-                                          local.get $1
-                                          i32.sub
-                                          i32.const 2
-                                          i32.shr_s
-                                          i32.const 9
-                                          i32.mul
-                                          local.set $5
-                                          local.get $1
-                                          i32.load
-                                          local.tee $6
-                                          i32.const 10
-                                          i32.lt_u
-                                          br_if 2 (;@17;)
-                                          i32.const 10
-                                          local.set $8
-                                          loop $label$174 ;; label = @20
-                                            local.get $5
-                                            i32.const 1
-                                            i32.add
-                                            local.set $5
-                                            local.get $6
-                                            local.get $8
-                                            i32.const 10
-                                            i32.mul
-                                            local.tee $8
-                                            i32.ge_u
-                                            br_if 0 (;@20;)
-                                          end
-                                        end
-                                      else
-                                        i32.const 0
-                                        local.set $5
-                                      end
-                                    end
-                                    local.get $22
-                                    i32.const 103
-                                    i32.eq
-                                    local.set $29
-                                    local.get $18
-                                    i32.const 0
-                                    i32.ne
-                                    local.set $35
-                                    local.get $18
-                                    local.get $22
-                                    i32.const 102
-                                    i32.ne
-                                    if (result i32) ;; label = @17
-                                      local.get $5
-                                    else
-                                      i32.const 0
-                                    end
-                                    i32.sub
-                                    local.get $35
-                                    local.get $29
-                                    i32.and
-                                    i32.const 31
-                                    i32.shl
-                                    i32.const 31
-                                    i32.shr_s
-                                    i32.add
-                                    local.tee $8
-                                    local.get $13
-                                    local.get $25
-                                    i32.sub
-                                    i32.const 2
-                                    i32.shr_s
-                                    i32.const 9
-                                    i32.mul
-                                    i32.const -9
-                                    i32.add
-                                    i32.lt_s
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        local.get $8
-                                        i32.const 9216
-                                        i32.add
-                                        local.tee $14
-                                        i32.const 9
-                                        i32.rem_s
-                                        i32.const 1
-                                        i32.add
-                                        local.tee $8
-                                        i32.const 9
-                                        i32.lt_s
-                                        if ;; label = @19
-                                          block ;; label = @20
-                                            i32.const 10
-                                            local.set $6
-                                            loop $label$180 ;; label = @21
-                                              local.get $6
-                                              i32.const 10
-                                              i32.mul
-                                              local.set $6
-                                              local.get $8
-                                              i32.const 1
-                                              i32.add
-                                              local.tee $8
-                                              i32.const 9
-                                              i32.ne
-                                              br_if 0 (;@21;)
-                                            end
-                                          end
-                                        else
-                                          i32.const 10
-                                          local.set $6
-                                        end
-                                        local.get $7
-                                        i32.const 4
-                                        i32.add
-                                        local.get $14
-                                        i32.const 9
-                                        i32.div_s
-                                        i32.const -1024
-                                        i32.add
-                                        i32.const 2
-                                        i32.shl
-                                        i32.add
-                                        local.tee $8
-                                        i32.load
-                                        local.tee $22
-                                        local.get $6
-                                        i32.rem_u
-                                        local.set $14
-                                        block $label$182 ;; label = @19
-                                          local.get $8
-                                          i32.const 4
-                                          i32.add
-                                          local.get $13
-                                          i32.eq
-                                          local.tee $32
-                                          local.get $14
-                                          i32.eqz
-                                          i32.and
-                                          i32.eqz
-                                          if ;; label = @20
-                                            block ;; label = @21
-                                              local.get $14
-                                              local.get $6
-                                              i32.const 2
-                                              i32.div_s
-                                              local.tee $49
-                                              i32.lt_u
-                                              if (result f64) ;; label = @22
-                                                f64.const 0x1p-1 (;=0.5;)
-                                              else
-                                                local.get $32
-                                                local.get $14
-                                                local.get $49
-                                                i32.eq
-                                                i32.and
-                                                if (result f64) ;; label = @23
-                                                  f64.const 0x1p+0 (;=1;)
-                                                else
-                                                  f64.const 0x1.8p+0 (;=1.5;)
-                                                end
-                                              end
-                                              local.set $52
-                                              local.get $22
-                                              local.get $6
-                                              i32.div_u
-                                              i32.const 1
-                                              i32.and
-                                              if (result f64) ;; label = @22
-                                                f64.const 0x1.0000000000001p+53 (;=9007199254740994;)
-                                              else
-                                                f64.const 0x1p+53 (;=9007199254740992;)
-                                              end
-                                              local.set $53
-                                              block $label$190 ;; label = @22
-                                                local.get $24
-                                                if ;; label = @23
-                                                  block ;; label = @24
-                                                    local.get $26
-                                                    i32.load8_s
-                                                    i32.const 45
-                                                    i32.ne
-                                                    br_if 2 (;@22;)
-                                                    local.get $53
-                                                    f64.neg
-                                                    local.set $53
-                                                    local.get $52
-                                                    f64.neg
-                                                    local.set $52
-                                                  end
-                                                end
-                                              end
-                                              local.get $8
-                                              local.get $22
-                                              local.get $14
-                                              i32.sub
-                                              local.tee $14
-                                              i32.store
-                                              local.get $53
-                                              local.get $52
-                                              f64.add
-                                              local.get $53
-                                              f64.eq
-                                              br_if 2 (;@19;)
-                                              local.get $8
-                                              local.get $14
-                                              local.get $6
-                                              i32.add
-                                              local.tee $5
-                                              i32.store
-                                              local.get $5
-                                              i32.const 999999999
-                                              i32.gt_u
-                                              if ;; label = @22
-                                                loop $label$193 ;; label = @23
-                                                  local.get $8
-                                                  i32.const 0
-                                                  i32.store
-                                                  local.get $8
-                                                  i32.const -4
-                                                  i32.add
-                                                  local.tee $8
-                                                  local.get $1
-                                                  i32.lt_u
-                                                  if ;; label = @24
-                                                    local.get $1
-                                                    i32.const -4
-                                                    i32.add
-                                                    local.tee $1
-                                                    i32.const 0
-                                                    i32.store
-                                                  end
-                                                  local.get $8
-                                                  local.get $8
-                                                  i32.load
-                                                  i32.const 1
-                                                  i32.add
-                                                  local.tee $5
-                                                  i32.store
-                                                  local.get $5
-                                                  i32.const 999999999
-                                                  i32.gt_u
-                                                  br_if 0 (;@23;)
-                                                end
-                                              end
-                                              local.get $25
-                                              local.get $1
-                                              i32.sub
-                                              i32.const 2
-                                              i32.shr_s
-                                              i32.const 9
-                                              i32.mul
-                                              local.set $5
-                                              local.get $1
-                                              i32.load
-                                              local.tee $14
-                                              i32.const 10
-                                              i32.lt_u
-                                              br_if 2 (;@19;)
-                                              i32.const 10
-                                              local.set $6
-                                              loop $label$195 ;; label = @22
-                                                local.get $5
-                                                i32.const 1
-                                                i32.add
-                                                local.set $5
-                                                local.get $14
-                                                local.get $6
-                                                i32.const 10
-                                                i32.mul
-                                                local.tee $6
-                                                i32.ge_u
-                                                br_if 0 (;@22;)
-                                              end
-                                            end
-                                          end
-                                        end
-                                        local.get $1
-                                        local.set $14
-                                        local.get $5
-                                        local.set $6
-                                        local.get $13
-                                        local.get $8
-                                        i32.const 4
-                                        i32.add
-                                        local.tee $8
-                                        i32.le_u
-                                        if ;; label = @19
-                                          local.get $13
-                                          local.set $8
-                                        end
-                                      end
-                                    else
-                                      block ;; label = @18
-                                        local.get $1
-                                        local.set $14
-                                        local.get $5
-                                        local.set $6
-                                        local.get $13
-                                        local.set $8
-                                      end
-                                    end
-                                    i32.const 0
-                                    local.get $6
-                                    i32.sub
-                                    local.set $32
-                                    loop $label$198 ;; label = @17
-                                      block $label$199 ;; label = @18
-                                        local.get $8
-                                        local.get $14
-                                        i32.le_u
-                                        if ;; label = @19
-                                          block ;; label = @20
-                                            i32.const 0
-                                            local.set $22
-                                            br 2 (;@18;)
-                                          end
-                                        end
-                                        local.get $8
-                                        i32.const -4
-                                        i32.add
-                                        local.tee $1
-                                        i32.load
-                                        if ;; label = @19
-                                          i32.const 1
-                                          local.set $22
-                                        else
-                                          block ;; label = @20
-                                            local.get $1
-                                            local.set $8
-                                            br 3 (;@17;)
-                                          end
-                                        end
-                                      end
-                                    end
-                                    block $label$203 ;; label = @17
-                                      local.get $29
-                                      if ;; label = @18
-                                        block ;; label = @19
-                                          local.get $35
-                                          i32.const 1
-                                          i32.and
-                                          i32.const 1
-                                          i32.xor
-                                          local.get $18
-                                          i32.add
-                                          local.tee $1
-                                          local.get $6
-                                          i32.gt_s
-                                          local.get $6
-                                          i32.const -5
-                                          i32.gt_s
-                                          i32.and
-                                          if (result i32) ;; label = @20
-                                            block (result i32) ;; label = @21
-                                              local.get $9
-                                              i32.const -1
-                                              i32.add
-                                              local.set $5
-                                              local.get $1
-                                              i32.const -1
-                                              i32.add
-                                              local.get $6
-                                              i32.sub
-                                            end
-                                          else
-                                            block (result i32) ;; label = @21
-                                              local.get $9
-                                              i32.const -2
-                                              i32.add
-                                              local.set $5
-                                              local.get $1
-                                              i32.const -1
-                                              i32.add
-                                            end
-                                          end
-                                          local.set $1
-                                          local.get $12
-                                          i32.const 8
-                                          i32.and
-                                          local.tee $13
-                                          br_if 2 (;@17;)
-                                          block $label$207 ;; label = @20
-                                            local.get $22
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                local.get $8
-                                                i32.const -4
-                                                i32.add
-                                                i32.load
-                                                local.tee $18
-                                                i32.eqz
-                                                if ;; label = @23
-                                                  block ;; label = @24
-                                                    i32.const 9
-                                                    local.set $9
-                                                    br 4 (;@20;)
-                                                  end
-                                                end
-                                                local.get $18
-                                                i32.const 10
-                                                i32.rem_u
-                                                if ;; label = @23
-                                                  block ;; label = @24
-                                                    i32.const 0
-                                                    local.set $9
-                                                    br 4 (;@20;)
-                                                  end
-                                                else
-                                                  block ;; label = @24
-                                                    i32.const 10
-                                                    local.set $13
-                                                    i32.const 0
-                                                    local.set $9
-                                                  end
-                                                end
-                                                loop $label$212 ;; label = @23
-                                                  local.get $9
-                                                  i32.const 1
-                                                  i32.add
-                                                  local.set $9
-                                                  local.get $18
-                                                  local.get $13
-                                                  i32.const 10
-                                                  i32.mul
-                                                  local.tee $13
-                                                  i32.rem_u
-                                                  i32.eqz
-                                                  br_if 0 (;@23;)
-                                                end
-                                              end
-                                            else
-                                              i32.const 9
-                                              local.set $9
-                                            end
-                                          end
-                                          local.get $8
-                                          local.get $25
-                                          i32.sub
-                                          i32.const 2
-                                          i32.shr_s
-                                          i32.const 9
-                                          i32.mul
-                                          i32.const -9
-                                          i32.add
-                                          local.set $18
-                                          local.get $5
-                                          i32.const 32
-                                          i32.or
-                                          i32.const 102
-                                          i32.eq
-                                          if ;; label = @20
-                                            block ;; label = @21
-                                              i32.const 0
-                                              local.set $13
-                                              local.get $1
-                                              local.get $18
-                                              local.get $9
-                                              i32.sub
-                                              local.tee $9
-                                              i32.const 0
-                                              i32.lt_s
-                                              if (result i32) ;; label = @22
-                                                i32.const 0
-                                                local.tee $9
-                                              else
-                                                local.get $9
-                                              end
-                                              i32.ge_s
-                                              if ;; label = @22
-                                                local.get $9
-                                                local.set $1
-                                              end
-                                            end
-                                          else
-                                            block ;; label = @21
-                                              i32.const 0
-                                              local.set $13
-                                              local.get $1
-                                              local.get $18
-                                              local.get $6
-                                              i32.add
-                                              local.get $9
-                                              i32.sub
-                                              local.tee $9
-                                              i32.const 0
-                                              i32.lt_s
-                                              if (result i32) ;; label = @22
-                                                i32.const 0
-                                                local.tee $9
-                                              else
-                                                local.get $9
-                                              end
-                                              i32.ge_s
-                                              if ;; label = @22
-                                                local.get $9
-                                                local.set $1
-                                              end
-                                            end
-                                          end
-                                        end
-                                      else
-                                        block ;; label = @19
-                                          local.get $12
-                                          i32.const 8
-                                          i32.and
-                                          local.set $13
-                                          local.get $18
-                                          local.set $1
-                                          local.get $9
-                                          local.set $5
-                                        end
-                                      end
-                                    end
-                                    local.get $5
-                                    i32.const 32
-                                    i32.or
-                                    i32.const 102
-                                    i32.eq
-                                    local.tee $25
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        i32.const 0
-                                        local.set $9
-                                        local.get $6
-                                        i32.const 0
-                                        i32.le_s
-                                        if ;; label = @19
-                                          i32.const 0
-                                          local.set $6
-                                        end
-                                      end
-                                    else
-                                      block ;; label = @18
-                                        local.get $28
-                                        local.get $6
-                                        i32.const 0
-                                        i32.lt_s
-                                        if (result i32) ;; label = @19
-                                          local.get $32
-                                        else
-                                          local.get $6
-                                        end
-                                        i64.extend_i32_s
-                                        local.get $33
-                                        call $23
-                                        local.tee $9
-                                        i32.sub
-                                        i32.const 2
-                                        i32.lt_s
-                                        if ;; label = @19
-                                          loop $label$229 ;; label = @20
-                                            local.get $9
-                                            i32.const -1
-                                            i32.add
-                                            local.tee $9
-                                            i32.const 48
-                                            i32.store8
-                                            local.get $28
-                                            local.get $9
-                                            i32.sub
-                                            i32.const 2
-                                            i32.lt_s
-                                            br_if 0 (;@20;)
-                                          end
-                                        end
-                                        local.get $9
-                                        i32.const -1
-                                        i32.add
-                                        local.get $6
-                                        i32.const 31
-                                        i32.shr_s
-                                        i32.const 2
-                                        i32.and
-                                        i32.const 43
-                                        i32.add
-                                        i32.store8
-                                        local.get $9
-                                        i32.const -2
-                                        i32.add
-                                        local.tee $6
-                                        local.get $5
-                                        i32.store8
-                                        local.get $6
-                                        local.set $9
-                                        local.get $28
-                                        local.get $6
-                                        i32.sub
-                                        local.set $6
-                                      end
-                                    end
-                                    local.get $0
-                                    i32.const 32
-                                    local.get $10
-                                    local.get $24
-                                    i32.const 1
-                                    i32.add
-                                    local.get $1
-                                    i32.add
-                                    local.get $1
-                                    local.get $13
-                                    i32.or
-                                    local.tee $29
-                                    i32.const 0
-                                    i32.ne
-                                    i32.add
-                                    local.get $6
-                                    i32.add
-                                    local.tee $18
-                                    local.get $12
-                                    call $25
-                                    local.get $0
-                                    i32.load
-                                    i32.const 32
-                                    i32.and
-                                    i32.eqz
-                                    if ;; label = @17
-                                      local.get $26
-                                      local.get $24
-                                      local.get $0
-                                      call $21
-                                      drop
-                                    end
-                                    local.get $0
-                                    i32.const 48
-                                    local.get $10
-                                    local.get $18
-                                    local.get $12
-                                    i32.const 65536
-                                    i32.xor
-                                    call $25
-                                    block $label$231 ;; label = @17
-                                      local.get $25
-                                      if ;; label = @18
-                                        block ;; label = @19
-                                          local.get $14
-                                          local.get $7
-                                          i32.gt_u
-                                          if (result i32) ;; label = @20
-                                            local.get $7
-                                          else
-                                            local.get $14
-                                          end
-                                          local.tee $9
-                                          local.set $6
-                                          loop $label$235 ;; label = @20
-                                            local.get $6
-                                            i32.load
-                                            i64.extend_i32_u
-                                            local.get $31
-                                            call $23
-                                            local.set $5
-                                            block $label$236 ;; label = @21
-                                              local.get $6
-                                              local.get $9
-                                              i32.eq
-                                              if ;; label = @22
-                                                block ;; label = @23
-                                                  local.get $5
-                                                  local.get $31
-                                                  i32.ne
-                                                  br_if 2 (;@21;)
-                                                  local.get $34
-                                                  i32.const 48
-                                                  i32.store8
-                                                  local.get $34
-                                                  local.set $5
-                                                end
-                                              else
-                                                block ;; label = @23
-                                                  local.get $5
-                                                  local.get $19
-                                                  i32.le_u
-                                                  br_if 2 (;@21;)
-                                                  local.get $19
-                                                  i32.const 48
-                                                  local.get $5
-                                                  local.get $27
-                                                  i32.sub
-                                                  call $46
-                                                  drop
-                                                  loop $label$239 ;; label = @24
-                                                    local.get $5
-                                                    i32.const -1
-                                                    i32.add
-                                                    local.tee $5
-                                                    local.get $19
-                                                    i32.gt_u
-                                                    br_if 0 (;@24;)
-                                                  end
-                                                end
-                                              end
-                                            end
-                                            local.get $0
-                                            i32.load
-                                            i32.const 32
-                                            i32.and
-                                            i32.eqz
-                                            if ;; label = @21
-                                              local.get $5
-                                              local.get $41
-                                              local.get $5
-                                              i32.sub
-                                              local.get $0
-                                              call $21
-                                              drop
-                                            end
-                                            local.get $6
-                                            i32.const 4
-                                            i32.add
-                                            local.tee $5
-                                            local.get $7
-                                            i32.le_u
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                local.get $5
-                                                local.set $6
-                                                br 2 (;@20;)
-                                              end
-                                            end
-                                          end
-                                          block $label$242 ;; label = @20
-                                            local.get $29
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                local.get $0
-                                                i32.load
-                                                i32.const 32
-                                                i32.and
-                                                br_if 2 (;@20;)
-                                                i32.const 2231
-                                                i32.const 1
-                                                local.get $0
-                                                call $21
-                                                drop
-                                              end
-                                            end
-                                          end
-                                          local.get $1
-                                          i32.const 0
-                                          i32.gt_s
-                                          local.get $5
-                                          local.get $8
-                                          i32.lt_u
-                                          i32.and
-                                          if ;; label = @20
-                                            loop $label$245 ;; label = @21
-                                              local.get $5
-                                              i32.load
-                                              i64.extend_i32_u
-                                              local.get $31
-                                              call $23
-                                              local.tee $7
-                                              local.get $19
-                                              i32.gt_u
-                                              if ;; label = @22
-                                                block ;; label = @23
-                                                  local.get $19
-                                                  i32.const 48
-                                                  local.get $7
-                                                  local.get $27
-                                                  i32.sub
-                                                  call $46
-                                                  drop
-                                                  loop $label$247 ;; label = @24
-                                                    local.get $7
-                                                    i32.const -1
-                                                    i32.add
-                                                    local.tee $7
-                                                    local.get $19
-                                                    i32.gt_u
-                                                    br_if 0 (;@24;)
-                                                  end
-                                                end
-                                              end
-                                              local.get $0
-                                              i32.load
-                                              i32.const 32
-                                              i32.and
-                                              i32.eqz
-                                              if ;; label = @22
-                                                local.get $7
-                                                local.get $1
-                                                i32.const 9
-                                                i32.gt_s
-                                                if (result i32) ;; label = @23
-                                                  i32.const 9
-                                                else
-                                                  local.get $1
-                                                end
-                                                local.get $0
-                                                call $21
-                                                drop
-                                              end
-                                              local.get $1
-                                              i32.const -9
-                                              i32.add
-                                              local.set $7
-                                              local.get $1
-                                              i32.const 9
-                                              i32.gt_s
-                                              local.get $5
-                                              i32.const 4
-                                              i32.add
-                                              local.tee $5
-                                              local.get $8
-                                              i32.lt_u
-                                              i32.and
-                                              if ;; label = @22
-                                                block ;; label = @23
-                                                  local.get $7
-                                                  local.set $1
-                                                  br 2 (;@21;)
-                                                end
-                                              else
-                                                local.get $7
-                                                local.set $1
-                                              end
-                                            end
-                                          end
-                                          local.get $0
-                                          i32.const 48
-                                          local.get $1
-                                          i32.const 9
-                                          i32.add
-                                          i32.const 9
-                                          i32.const 0
-                                          call $25
-                                        end
-                                      else
-                                        block ;; label = @19
-                                          local.get $14
-                                          i32.const 4
-                                          i32.add
-                                          local.set $5
-                                          local.get $22
-                                          i32.eqz
-                                          if ;; label = @20
-                                            local.get $5
-                                            local.set $8
-                                          end
-                                          local.get $1
-                                          i32.const -1
-                                          i32.gt_s
-                                          if ;; label = @20
-                                            block ;; label = @21
-                                              local.get $13
-                                              i32.eqz
-                                              local.set $13
-                                              local.get $14
-                                              local.set $7
-                                              local.get $1
-                                              local.set $5
-                                              loop $label$256 ;; label = @22
-                                                local.get $7
-                                                i32.load
-                                                i64.extend_i32_u
-                                                local.get $31
-                                                call $23
-                                                local.tee $1
-                                                local.get $31
-                                                i32.eq
-                                                if ;; label = @23
-                                                  block ;; label = @24
-                                                    local.get $34
-                                                    i32.const 48
-                                                    i32.store8
-                                                    local.get $34
-                                                    local.set $1
-                                                  end
-                                                end
-                                                block $label$258 ;; label = @23
-                                                  local.get $7
-                                                  local.get $14
-                                                  i32.eq
-                                                  if ;; label = @24
-                                                    block ;; label = @25
-                                                      local.get $0
-                                                      i32.load
-                                                      i32.const 32
-                                                      i32.and
-                                                      i32.eqz
-                                                      if ;; label = @26
-                                                        local.get $1
-                                                        i32.const 1
-                                                        local.get $0
-                                                        call $21
-                                                        drop
-                                                      end
-                                                      local.get $1
-                                                      i32.const 1
-                                                      i32.add
-                                                      local.set $1
-                                                      local.get $13
-                                                      local.get $5
-                                                      i32.const 1
-                                                      i32.lt_s
-                                                      i32.and
-                                                      br_if 2 (;@23;)
-                                                      local.get $0
-                                                      i32.load
-                                                      i32.const 32
-                                                      i32.and
-                                                      br_if 2 (;@23;)
-                                                      i32.const 2231
-                                                      i32.const 1
-                                                      local.get $0
-                                                      call $21
-                                                      drop
-                                                    end
-                                                  else
-                                                    block ;; label = @25
-                                                      local.get $1
-                                                      local.get $19
-                                                      i32.le_u
-                                                      br_if 2 (;@23;)
-                                                      local.get $19
-                                                      i32.const 48
-                                                      local.get $1
-                                                      local.get $43
-                                                      i32.add
-                                                      call $46
-                                                      drop
-                                                      loop $label$262 ;; label = @26
-                                                        local.get $1
-                                                        i32.const -1
-                                                        i32.add
-                                                        local.tee $1
-                                                        local.get $19
-                                                        i32.gt_u
-                                                        br_if 0 (;@26;)
-                                                      end
-                                                    end
-                                                  end
-                                                end
-                                                local.get $41
-                                                local.get $1
-                                                i32.sub
-                                                local.set $6
-                                                local.get $0
-                                                i32.load
-                                                i32.const 32
-                                                i32.and
-                                                i32.eqz
-                                                if ;; label = @23
-                                                  local.get $1
-                                                  local.get $5
-                                                  local.get $6
-                                                  i32.gt_s
-                                                  if (result i32) ;; label = @24
-                                                    local.get $6
-                                                  else
-                                                    local.get $5
-                                                  end
-                                                  local.get $0
-                                                  call $21
-                                                  drop
-                                                end
-                                                local.get $7
-                                                i32.const 4
-                                                i32.add
-                                                local.tee $7
-                                                local.get $8
-                                                i32.lt_u
-                                                local.get $5
-                                                local.get $6
-                                                i32.sub
-                                                local.tee $5
-                                                i32.const -1
-                                                i32.gt_s
-                                                i32.and
-                                                br_if 0 (;@22;)
-                                                local.get $5
-                                                local.set $1
-                                              end
-                                            end
-                                          end
-                                          local.get $0
-                                          i32.const 48
-                                          local.get $1
-                                          i32.const 18
-                                          i32.add
-                                          i32.const 18
-                                          i32.const 0
-                                          call $25
-                                          local.get $0
-                                          i32.load
-                                          i32.const 32
-                                          i32.and
-                                          br_if 2 (;@17;)
-                                          local.get $9
-                                          local.get $28
-                                          local.get $9
-                                          i32.sub
-                                          local.get $0
-                                          call $21
-                                          drop
-                                        end
-                                      end
-                                    end
-                                    local.get $0
-                                    i32.const 32
-                                    local.get $10
-                                    local.get $18
-                                    local.get $12
-                                    i32.const 8192
-                                    i32.xor
-                                    call $25
-                                    local.get $18
-                                    local.get $10
-                                    i32.ge_s
-                                    if ;; label = @17
-                                      local.get $18
-                                      local.set $10
-                                    end
-                                  end
-                                else
-                                  block ;; label = @16
-                                    local.get $0
-                                    i32.const 32
-                                    local.get $10
-                                    local.get $52
-                                    local.get $52
-                                    f64.ne
-                                    i32.const 0
-                                    i32.or
-                                    local.tee $6
-                                    if (result i32) ;; label = @17
-                                      i32.const 0
-                                      local.tee $24
-                                    else
-                                      local.get $24
-                                    end
-                                    i32.const 3
-                                    i32.add
-                                    local.tee $8
-                                    local.get $7
-                                    call $25
-                                    local.get $0
-                                    i32.load
-                                    local.tee $1
-                                    i32.const 32
-                                    i32.and
-                                    i32.eqz
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        local.get $26
-                                        local.get $24
-                                        local.get $0
-                                        call $21
-                                        drop
-                                        local.get $0
-                                        i32.load
-                                        local.set $1
-                                      end
-                                    end
-                                    local.get $9
-                                    i32.const 32
-                                    i32.and
-                                    i32.const 0
-                                    i32.ne
-                                    local.tee $5
-                                    if (result i32) ;; label = @17
-                                      i32.const 2215
-                                    else
-                                      i32.const 2219
-                                    end
-                                    local.set $7
-                                    local.get $5
-                                    if (result i32) ;; label = @17
-                                      i32.const 2223
-                                    else
-                                      i32.const 2227
-                                    end
-                                    local.set $5
-                                    local.get $6
-                                    i32.eqz
-                                    if ;; label = @17
-                                      local.get $7
-                                      local.set $5
-                                    end
-                                    local.get $1
-                                    i32.const 32
-                                    i32.and
-                                    i32.eqz
-                                    if ;; label = @17
-                                      local.get $5
-                                      i32.const 3
-                                      local.get $0
-                                      call $21
-                                      drop
-                                    end
-                                    local.get $0
-                                    i32.const 32
-                                    local.get $10
-                                    local.get $8
-                                    local.get $12
-                                    i32.const 8192
-                                    i32.xor
-                                    call $25
-                                    local.get $8
-                                    local.get $10
-                                    i32.ge_s
-                                    if ;; label = @17
-                                      local.get $8
-                                      local.set $10
-                                    end
-                                  end
-                                end
-                              end
-                              local.get $11
-                              local.set $1
-                              br 9 (;@4;)
-                            end
-                            local.get $5
-                            local.set $7
-                            i32.const 0
-                            local.set $6
-                            i32.const 2179
-                            local.set $8
-                            local.get $21
-                            local.set $5
-                            br 6 (;@6;)
-                          end
-                          local.get $9
-                          i32.const 32
-                          i32.and
-                          local.set $7
-                          local.get $16
-                          i64.load
-                          local.tee $50
-                          i64.const 0
-                          i64.eq
-                          if (result i32) ;; label = @12
-                            block (result i32) ;; label = @13
-                              i64.const 0
-                              local.set $50
-                              local.get $21
-                            end
-                          else
-                            block (result i32) ;; label = @13
-                              local.get $21
-                              local.set $1
-                              loop $label$280 ;; label = @14
-                                local.get $1
-                                i32.const -1
-                                i32.add
-                                local.tee $1
-                                local.get $50
-                                i32.wrap_i64
-                                i32.const 15
-                                i32.and
-                                i32.const 2163
-                                i32.add
-                                i32.load8_u
-                                local.get $7
-                                i32.or
-                                i32.store8
-                                local.get $50
-                                i64.const 4
-                                i64.shr_u
-                                local.tee $50
-                                i64.const 0
-                                i64.ne
-                                br_if 0 (;@14;)
-                              end
-                              local.get $16
-                              i64.load
-                              local.set $50
-                              local.get $1
-                            end
-                          end
-                          local.set $7
-                          local.get $9
-                          i32.const 4
-                          i32.shr_s
-                          i32.const 2179
-                          i32.add
-                          local.set $8
-                          local.get $12
-                          i32.const 8
-                          i32.and
-                          i32.eqz
-                          local.get $50
-                          i64.const 0
-                          i64.eq
-                          i32.or
-                          local.tee $1
-                          if ;; label = @12
-                            i32.const 2179
-                            local.set $8
-                          end
-                          local.get $1
-                          if (result i32) ;; label = @12
-                            i32.const 0
-                          else
-                            i32.const 2
-                          end
-                          local.set $6
-                          br 4 (;@7;)
-                        end
-                        local.get $50
-                        local.get $21
-                        call $23
-                        local.set $7
-                        br 3 (;@7;)
-                      end
-                      local.get $1
-                      i32.const 0
-                      local.get $5
-                      call $17
-                      local.tee $13
-                      i32.eqz
-                      local.set $14
-                      local.get $13
-                      local.get $1
-                      i32.sub
-                      local.set $8
-                      local.get $1
-                      local.get $5
-                      i32.add
-                      local.set $9
-                      local.get $7
-                      local.set $12
-                      local.get $14
-                      if (result i32) ;; label = @10
-                        local.get $5
-                      else
-                        local.get $8
-                      end
-                      local.set $7
-                      i32.const 0
-                      local.set $6
-                      i32.const 2179
-                      local.set $8
-                      local.get $14
-                      if (result i32) ;; label = @10
-                        local.get $9
-                      else
-                        local.get $13
-                      end
-                      local.set $5
-                      br 3 (;@6;)
-                    end
-                    i32.const 0
-                    local.set $1
-                    i32.const 0
-                    local.set $5
-                    local.get $7
-                    local.set $8
-                    loop $label$288 ;; label = @9
-                      block $label$289 ;; label = @10
-                        local.get $8
-                        i32.load
-                        local.tee $9
-                        i32.eqz
-                        br_if 0 (;@10;)
-                        local.get $36
-                        local.get $9
-                        call $26
-                        local.tee $5
-                        i32.const 0
-                        i32.lt_s
-                        local.get $5
-                        local.get $6
-                        local.get $1
-                        i32.sub
-                        i32.gt_u
-                        i32.or
-                        br_if 0 (;@10;)
-                        local.get $8
-                        i32.const 4
-                        i32.add
-                        local.set $8
-                        local.get $6
-                        local.get $5
-                        local.get $1
-                        i32.add
-                        local.tee $1
-                        i32.gt_u
-                        br_if 1 (;@9;)
-                      end
-                    end
-                    local.get $5
-                    i32.const 0
-                    i32.lt_s
-                    if ;; label = @9
-                      block ;; label = @10
-                        i32.const -1
-                        local.set $15
-                        br 5 (;@5;)
-                      end
-                    end
-                    local.get $0
-                    i32.const 32
-                    local.get $10
-                    local.get $1
-                    local.get $12
-                    call $25
-                    local.get $1
-                    if ;; label = @9
-                      block ;; label = @10
-                        i32.const 0
-                        local.set $5
-                        loop $label$292 ;; label = @11
-                          local.get $7
-                          i32.load
-                          local.tee $8
-                          i32.eqz
-                          br_if 3 (;@8;)
-                          local.get $36
-                          local.get $8
-                          call $26
-                          local.tee $8
-                          local.get $5
-                          i32.add
-                          local.tee $5
-                          local.get $1
-                          i32.gt_s
-                          br_if 3 (;@8;)
-                          local.get $0
-                          i32.load
-                          i32.const 32
-                          i32.and
-                          i32.eqz
-                          if ;; label = @12
-                            local.get $36
-                            local.get $8
-                            local.get $0
-                            call $21
-                            drop
-                          end
-                          local.get $7
-                          i32.const 4
-                          i32.add
-                          local.set $7
-                          local.get $5
-                          local.get $1
-                          i32.lt_u
-                          br_if 0 (;@11;)
-                          br 3 (;@8;)
-                        end
-                      end
-                    else
-                      block ;; label = @10
-                        i32.const 0
-                        local.set $1
-                        br 2 (;@8;)
-                      end
-                    end
-                  end
-                  local.get $0
-                  i32.const 32
-                  local.get $10
-                  local.get $1
-                  local.get $12
-                  i32.const 8192
-                  i32.xor
-                  call $25
-                  local.get $10
-                  local.get $1
-                  i32.le_s
-                  if ;; label = @8
-                    local.get $1
-                    local.set $10
-                  end
-                  local.get $11
-                  local.set $1
-                  br 3 (;@4;)
-                end
-                local.get $12
-                i32.const -65537
-                i32.and
-                local.set $1
-                local.get $5
-                i32.const -1
-                i32.gt_s
-                if ;; label = @7
-                  local.get $1
-                  local.set $12
-                end
-                local.get $5
-                local.get $16
-                i64.load
-                i64.const 0
-                i64.ne
-                local.tee $9
-                i32.or
-                if (result i32) ;; label = @7
-                  block (result i32) ;; label = @8
-                    local.get $7
-                    local.set $1
-                    local.get $5
-                    local.get $9
-                    i32.const 1
-                    i32.and
-                    i32.const 1
-                    i32.xor
-                    local.get $38
-                    local.get $7
-                    i32.sub
-                    i32.add
-                    local.tee $7
-                    i32.gt_s
-                    if ;; label = @9
-                      local.get $5
-                      local.set $7
-                    end
-                    local.get $21
-                  end
-                else
-                  block (result i32) ;; label = @8
-                    local.get $21
-                    local.set $1
-                    i32.const 0
-                    local.set $7
-                    local.get $21
-                  end
-                end
-                local.set $5
-              end
-              local.get $0
-              i32.const 32
-              local.get $10
-              local.get $7
-              local.get $5
-              local.get $1
-              i32.sub
-              local.tee $9
-              i32.lt_s
-              if (result i32) ;; label = @6
-                local.get $9
-                local.tee $7
-              else
-                local.get $7
-              end
-              local.get $6
-              i32.add
-              local.tee $5
-              i32.lt_s
-              if (result i32) ;; label = @6
-                local.get $5
-                local.tee $10
-              else
-                local.get $10
-              end
-              local.get $5
-              local.get $12
-              call $25
-              local.get $0
-              i32.load
-              i32.const 32
-              i32.and
-              i32.eqz
-              if ;; label = @6
-                local.get $8
-                local.get $6
-                local.get $0
-                call $21
-                drop
-              end
-              local.get $0
-              i32.const 48
-              local.get $10
-              local.get $5
-              local.get $12
-              i32.const 65536
-              i32.xor
-              call $25
-              local.get $0
-              i32.const 48
-              local.get $7
-              local.get $9
-              i32.const 0
-              call $25
-              local.get $0
-              i32.load
-              i32.const 32
-              i32.and
-              i32.eqz
-              if ;; label = @6
-                local.get $1
-                local.get $9
-                local.get $0
-                call $21
-                drop
-              end
-              local.get $0
-              i32.const 32
-              local.get $10
-              local.get $5
-              local.get $12
-              i32.const 8192
-              i32.xor
-              call $25
-              local.get $11
-              local.set $1
-              br 1 (;@4;)
-            end
-          end
-          br 1 (;@2;)
-        end
-        local.get $0
-        i32.eqz
-        if ;; label = @3
-          local.get $17
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 1
-              local.set $0
-              loop $label$308 ;; label = @6
-                local.get $4
-                local.get $0
-                i32.const 2
-                i32.shl
-                i32.add
-                i32.load
-                local.tee $1
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $3
-                    local.get $0
-                    i32.const 3
-                    i32.shl
-                    i32.add
-                    local.get $1
-                    local.get $2
-                    call $22
-                    local.get $0
-                    i32.const 1
-                    i32.add
-                    local.tee $0
-                    i32.const 10
-                    i32.lt_s
-                    br_if 2 (;@6;)
-                    i32.const 1
-                    local.set $15
-                    br 6 (;@2;)
-                  end
-                end
-              end
-              loop $label$310 ;; label = @6
-                local.get $4
-                local.get $0
-                i32.const 2
-                i32.shl
-                i32.add
-                i32.load
-                if ;; label = @7
-                  block ;; label = @8
-                    i32.const -1
-                    local.set $15
-                    br 6 (;@2;)
-                  end
-                end
-                local.get $0
-                i32.const 1
-                i32.add
-                local.tee $0
-                i32.const 10
-                i32.lt_s
-                br_if 0 (;@6;)
-                i32.const 1
-                local.set $15
-              end
-            end
-          else
-            i32.const 0
-            local.set $15
-          end
-        end
-      end
-      local.get $23
-      global.set $global$1
-      local.get $15
-    end
-  )
-  (func $20 (;33;) (type $2) (param $0 i32) (result i32)
-    i32.const 0
-  )
-  (func $21 (;34;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32)
-    block $label$1 (result i32) ;; label = @1
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          local.get $2
-          i32.const 16
-          i32.add
-          local.tee $4
-          i32.load
-          local.tee $3
-          br_if 0 (;@3;)
-          local.get $2
-          call $30
-          if ;; label = @4
-            i32.const 0
-            local.set $3
-          else
-            block ;; label = @5
-              local.get $4
-              i32.load
-              local.set $3
-              br 2 (;@3;)
-            end
-          end
-          br 1 (;@2;)
-        end
-        local.get $3
-        local.get $2
-        i32.const 20
-        i32.add
-        local.tee $5
-        i32.load
-        local.tee $4
-        i32.sub
-        local.get $1
-        i32.lt_u
-        if ;; label = @3
-          block ;; label = @4
-            local.get $2
-            local.get $0
-            local.get $1
-            local.get $2
-            i32.load offset=36
-            i32.const 3
-            i32.and
-            i32.const 2
-            i32.add
-            call_indirect (type $0)
-            local.set $3
-            br 2 (;@2;)
-          end
-        end
-        block $label$7 (result i32) ;; label = @3
-          local.get $2
-          i32.load8_s offset=75
-          i32.const -1
-          i32.gt_s
-          if (result i32) ;; label = @4
-            block (result i32) ;; label = @5
-              local.get $1
-              local.set $3
-              loop $label$9 ;; label = @6
-                i32.const 0
-                local.get $3
-                i32.eqz
-                br_if 3 (;@3;)
-                drop
-                local.get $0
-                local.get $3
-                i32.const -1
-                i32.add
-                local.tee $6
-                i32.add
-                i32.load8_s
-                i32.const 10
-                i32.ne
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $6
-                    local.set $3
-                    br 2 (;@6;)
-                  end
-                end
-              end
-              local.get $2
-              local.get $0
-              local.get $3
-              local.get $2
-              i32.load offset=36
-              i32.const 3
-              i32.and
-              i32.const 2
-              i32.add
-              call_indirect (type $0)
-              local.get $3
-              i32.lt_u
-              br_if 3 (;@2;)
-              local.get $5
-              i32.load
-              local.set $4
-              local.get $1
-              local.get $3
-              i32.sub
-              local.set $1
-              local.get $0
-              local.get $3
-              i32.add
-              local.set $0
-              local.get $3
-            end
-          else
-            i32.const 0
-          end
-        end
-        local.set $2
-        local.get $4
-        local.get $0
-        local.get $1
-        call $47
-        drop
-        local.get $5
-        local.get $5
-        i32.load
-        local.get $1
-        i32.add
-        i32.store
-        local.get $2
-        local.get $1
-        i32.add
-        local.set $3
-      end
-      local.get $3
-    end
-  )
-  (func $22 (;35;) (type $8) (param $0 i32) (param $1 i32) (param $2 i32)
-    (local $3 i32) (local $4 i64) (local $5 f64)
-    block $label$1 ;; label = @1
-      local.get $1
-      i32.const 20
-      i32.le_u
-      if ;; label = @2
-        block $label$3 ;; label = @3
-          block $label$4 ;; label = @4
-            block $label$5 ;; label = @5
-              block $label$6 ;; label = @6
-                block $label$7 ;; label = @7
-                  block $label$8 ;; label = @8
-                    block $label$9 ;; label = @9
-                      block $label$10 ;; label = @10
-                        block $label$11 ;; label = @11
-                          block $label$12 ;; label = @12
-                            block $label$13 ;; label = @13
-                              local.get $1
-                              i32.const 9
-                              i32.sub
-                              br_table 0 (;@13;) 1 (;@12;) 2 (;@11;) 3 (;@10;) 4 (;@9;) 5 (;@8;) 6 (;@7;) 7 (;@6;) 8 (;@5;) 9 (;@4;) 10 (;@3;)
-                            end
-                            local.get $2
-                            i32.load
-                            i32.const 3
-                            i32.add
-                            i32.const -4
-                            i32.and
-                            local.tee $1
-                            i32.load
-                            local.set $3
-                            local.get $2
-                            local.get $1
-                            i32.const 4
-                            i32.add
-                            i32.store
-                            local.get $0
-                            local.get $3
-                            i32.store
-                            br 11 (;@1;)
-                          end
-                          local.get $2
-                          i32.load
-                          i32.const 3
-                          i32.add
-                          i32.const -4
-                          i32.and
-                          local.tee $1
-                          i32.load
-                          local.set $3
-                          local.get $2
-                          local.get $1
-                          i32.const 4
-                          i32.add
-                          i32.store
-                          local.get $0
-                          local.get $3
-                          i64.extend_i32_s
-                          i64.store
-                          br 10 (;@1;)
-                        end
-                        local.get $2
-                        i32.load
-                        i32.const 3
-                        i32.add
-                        i32.const -4
-                        i32.and
-                        local.tee $1
-                        i32.load
-                        local.set $3
-                        local.get $2
-                        local.get $1
-                        i32.const 4
-                        i32.add
-                        i32.store
-                        local.get $0
-                        local.get $3
-                        i64.extend_i32_u
-                        i64.store
-                        br 9 (;@1;)
-                      end
-                      local.get $2
-                      i32.load
-                      i32.const 7
-                      i32.add
-                      i32.const -8
-                      i32.and
-                      local.tee $1
-                      i64.load
-                      local.set $4
-                      local.get $2
-                      local.get $1
-                      i32.const 8
-                      i32.add
-                      i32.store
-                      local.get $0
-                      local.get $4
-                      i64.store
-                      br 8 (;@1;)
-                    end
-                    local.get $2
-                    i32.load
-                    i32.const 3
-                    i32.add
-                    i32.const -4
-                    i32.and
-                    local.tee $1
-                    i32.load
-                    local.set $3
-                    local.get $2
-                    local.get $1
-                    i32.const 4
-                    i32.add
-                    i32.store
-                    local.get $0
-                    local.get $3
-                    i32.const 65535
-                    i32.and
-                    i32.const 16
-                    i32.shl
-                    i32.const 16
-                    i32.shr_s
-                    i64.extend_i32_s
-                    i64.store
-                    br 7 (;@1;)
-                  end
-                  local.get $2
-                  i32.load
-                  i32.const 3
-                  i32.add
-                  i32.const -4
-                  i32.and
-                  local.tee $1
-                  i32.load
-                  local.set $3
-                  local.get $2
-                  local.get $1
-                  i32.const 4
-                  i32.add
-                  i32.store
-                  local.get $0
-                  local.get $3
-                  i32.const 65535
-                  i32.and
-                  i64.extend_i32_u
-                  i64.store
-                  br 6 (;@1;)
-                end
-                local.get $2
-                i32.load
-                i32.const 3
-                i32.add
-                i32.const -4
-                i32.and
-                local.tee $1
-                i32.load
-                local.set $3
-                local.get $2
-                local.get $1
-                i32.const 4
-                i32.add
-                i32.store
-                local.get $0
-                local.get $3
-                i32.const 255
-                i32.and
-                i32.const 24
-                i32.shl
-                i32.const 24
-                i32.shr_s
-                i64.extend_i32_s
-                i64.store
-                br 5 (;@1;)
-              end
-              local.get $2
-              i32.load
-              i32.const 3
-              i32.add
-              i32.const -4
-              i32.and
-              local.tee $1
-              i32.load
-              local.set $3
-              local.get $2
-              local.get $1
-              i32.const 4
-              i32.add
-              i32.store
-              local.get $0
-              local.get $3
-              i32.const 255
-              i32.and
-              i64.extend_i32_u
-              i64.store
-              br 4 (;@1;)
-            end
-            local.get $2
-            i32.load
-            i32.const 7
-            i32.add
-            i32.const -8
-            i32.and
-            local.tee $1
-            f64.load
-            local.set $5
-            local.get $2
-            local.get $1
-            i32.const 8
-            i32.add
-            i32.store
-            local.get $0
-            local.get $5
-            f64.store
-            br 3 (;@1;)
-          end
-          local.get $2
-          i32.load
-          i32.const 7
-          i32.add
-          i32.const -8
-          i32.and
-          local.tee $1
-          f64.load
-          local.set $5
-          local.get $2
-          local.get $1
-          i32.const 8
-          i32.add
-          i32.store
-          local.get $0
-          local.get $5
-          f64.store
-        end
-      end
-    end
-  )
-  (func $23 (;36;) (type $9) (param $0 i64) (param $1 i32) (result i32)
-    (local $2 i32) (local $3 i32) (local $4 i64)
-    block $label$1 (result i32) ;; label = @1
-      local.get $0
-      i32.wrap_i64
-      local.set $2
-      local.get $0
-      i64.const 4294967295
-      i64.gt_u
-      if ;; label = @2
-        block ;; label = @3
-          loop $label$3 ;; label = @4
-            local.get $1
-            i32.const -1
-            i32.add
-            local.tee $1
-            local.get $0
-            i64.const 10
-            i64.rem_u
-            i64.const 48
-            i64.or
-            i64.store8
-            local.get $0
-            i64.const 10
-            i64.div_u
-            local.set $4
-            local.get $0
-            i64.const 42949672959
-            i64.gt_u
-            if ;; label = @5
-              block ;; label = @6
-                local.get $4
-                local.set $0
-                br 2 (;@4;)
-              end
-            end
-          end
-          local.get $4
-          i32.wrap_i64
-          local.set $2
-        end
-      end
-      local.get $2
-      if ;; label = @2
-        loop $label$6 ;; label = @3
-          local.get $1
-          i32.const -1
-          i32.add
-          local.tee $1
-          local.get $2
-          i32.const 10
-          i32.rem_u
-          i32.const 48
-          i32.or
-          i32.store8
-          local.get $2
-          i32.const 10
-          i32.div_u
-          local.set $3
-          local.get $2
-          i32.const 10
-          i32.ge_u
-          if ;; label = @4
-            block ;; label = @5
-              local.get $3
-              local.set $2
-              br 2 (;@3;)
-            end
-          end
-        end
-      end
-      local.get $1
-    end
-  )
-  (func $24 (;37;) (type $2) (param $0 i32) (result i32)
-    (local $1 i32) (local $2 i32)
-    block $label$1 (result i32) ;; label = @1
-      i32.const 0
-      local.set $1
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          block $label$4 ;; label = @4
-            loop $label$5 ;; label = @5
-              local.get $1
-              i32.const 2233
-              i32.add
-              i32.load8_u
-              local.get $0
-              i32.eq
-              br_if 1 (;@4;)
-              local.get $1
-              i32.const 1
-              i32.add
-              local.tee $1
-              i32.const 87
-              i32.ne
-              br_if 0 (;@5;)
-              i32.const 87
-              local.set $1
-              i32.const 2321
-              local.set $0
-              br 2 (;@3;)
-            end
-          end
-          local.get $1
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 2321
-              local.set $0
-              br 2 (;@3;)
-            end
-          else
-            i32.const 2321
-            local.set $0
-          end
-          br 1 (;@2;)
-        end
-        loop $label$8 ;; label = @3
-          local.get $0
-          local.set $2
-          loop $label$9 ;; label = @4
-            local.get $2
-            i32.const 1
-            i32.add
-            local.set $0
-            local.get $2
-            i32.load8_s
-            if ;; label = @5
-              block ;; label = @6
-                local.get $0
-                local.set $2
-                br 2 (;@4;)
-              end
-            end
-          end
-          local.get $1
-          i32.const -1
-          i32.add
-          local.tee $1
-          br_if 0 (;@3;)
-        end
-      end
-      local.get $0
-    end
-  )
-  (func $25 (;38;) (type $10) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32)
-    (local $5 i32) (local $6 i32) (local $7 i32)
-    block $label$1 ;; label = @1
-      global.get $global$1
-      local.set $7
-      global.get $global$1
-      i32.const 256
-      i32.add
-      global.set $global$1
-      local.get $7
-      local.set $6
-      block $label$2 ;; label = @2
-        local.get $2
-        local.get $3
-        i32.gt_s
-        local.get $4
-        i32.const 73728
-        i32.and
-        i32.eqz
-        i32.and
-        if ;; label = @3
-          block ;; label = @4
-            local.get $6
-            local.get $1
-            local.get $2
-            local.get $3
-            i32.sub
-            local.tee $5
-            i32.const 256
-            i32.gt_u
-            if (result i32) ;; label = @5
-              i32.const 256
-            else
-              local.get $5
-            end
-            call $46
-            drop
-            local.get $0
-            i32.load
-            local.tee $1
-            i32.const 32
-            i32.and
-            i32.eqz
-            local.set $4
-            local.get $5
-            i32.const 255
-            i32.gt_u
-            if ;; label = @5
-              block ;; label = @6
-                loop $label$7 ;; label = @7
-                  local.get $4
-                  if ;; label = @8
-                    block ;; label = @9
-                      local.get $6
-                      i32.const 256
-                      local.get $0
-                      call $21
-                      drop
-                      local.get $0
-                      i32.load
-                      local.set $1
-                    end
-                  end
-                  local.get $1
-                  i32.const 32
-                  i32.and
-                  i32.eqz
-                  local.set $4
-                  local.get $5
-                  i32.const -256
-                  i32.add
-                  local.tee $5
-                  i32.const 255
-                  i32.gt_u
-                  br_if 0 (;@7;)
-                end
-                local.get $4
-                i32.eqz
-                br_if 4 (;@2;)
-                local.get $2
-                local.get $3
-                i32.sub
-                i32.const 255
-                i32.and
-                local.set $5
-              end
-            else
-              local.get $4
-              i32.eqz
-              br_if 3 (;@2;)
-            end
-            local.get $6
-            local.get $5
-            local.get $0
-            call $21
-            drop
-          end
-        end
-      end
-      local.get $7
-      global.set $global$1
-    end
-  )
-  (func $26 (;39;) (type $6) (param $0 i32) (param $1 i32) (result i32)
-    local.get $0
-    if (result i32) ;; label = @1
-      local.get $0
-      local.get $1
-      i32.const 0
-      call $29
-    else
-      i32.const 0
-    end
-  )
-  (func $27 (;40;) (type $11) (param $0 f64) (param $1 i32) (result f64)
-    local.get $0
-    local.get $1
-    call $28
-  )
-  (func $28 (;41;) (type $11) (param $0 f64) (param $1 i32) (result f64)
-    (local $2 i64) (local $3 i64)
-    block $label$1 (result f64) ;; label = @1
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          block $label$4 ;; label = @4
-            block $label$5 ;; label = @5
-              local.get $0
-              i64.reinterpret_f64
-              local.tee $2
-              i64.const 52
-              i64.shr_u
-              local.tee $3
-              i32.wrap_i64
-              i32.const 65535
-              i32.and
-              i32.const 2047
-              i32.and
-              i32.const 16
-              i32.shl
-              i32.const 16
-              i32.shr_s
-              i32.const 0
-              i32.sub
-              br_table 0 (;@5;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 1 (;@4;) 2 (;@3;)
-            end
-            local.get $1
-            local.get $0
-            f64.const 0x0p+0 (;=0;)
-            f64.ne
-            if (result i32) ;; label = @5
-              block (result i32) ;; label = @6
-                local.get $0
-                f64.const 0x1p+64 (;=18446744073709552000;)
-                f64.mul
-                local.get $1
-                call $28
-                local.set $0
-                local.get $1
-                i32.load
-                i32.const -64
-                i32.add
-              end
-            else
-              i32.const 0
-            end
-            i32.store
-            br 2 (;@2;)
-          end
-          br 1 (;@2;)
-        end
-        local.get $1
-        local.get $3
-        i32.wrap_i64
-        i32.const 2047
-        i32.and
-        i32.const -1022
-        i32.add
-        i32.store
-        local.get $2
-        i64.const -9218868437227405313
-        i64.and
-        i64.const 4602678819172646912
-        i64.or
-        f64.reinterpret_i64
-        local.set $0
-      end
-      local.get $0
-    end
-  )
-  (func $29 (;42;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    block $label$1 (result i32) ;; label = @1
-      local.get $0
-      if (result i32) ;; label = @2
-        block (result i32) ;; label = @3
-          local.get $1
-          i32.const 128
-          i32.lt_u
-          if ;; label = @4
-            block ;; label = @5
-              local.get $0
-              local.get $1
-              i32.store8
-              i32.const 1
-              br 4 (;@1;)
-            end
-          end
-          local.get $1
-          i32.const 2048
-          i32.lt_u
-          if ;; label = @4
-            block ;; label = @5
-              local.get $0
-              local.get $1
-              i32.const 6
-              i32.shr_u
-              i32.const 192
-              i32.or
-              i32.store8
-              local.get $0
-              local.get $1
-              i32.const 63
-              i32.and
-              i32.const 128
-              i32.or
-              i32.store8 offset=1
-              i32.const 2
-              br 4 (;@1;)
-            end
-          end
-          local.get $1
-          i32.const 55296
-          i32.lt_u
-          local.get $1
-          i32.const -8192
-          i32.and
-          i32.const 57344
-          i32.eq
-          i32.or
-          if ;; label = @4
-            block ;; label = @5
-              local.get $0
-              local.get $1
-              i32.const 12
-              i32.shr_u
-              i32.const 224
-              i32.or
-              i32.store8
-              local.get $0
-              local.get $1
-              i32.const 6
-              i32.shr_u
-              i32.const 63
-              i32.and
-              i32.const 128
-              i32.or
-              i32.store8 offset=1
-              local.get $0
-              local.get $1
-              i32.const 63
-              i32.and
-              i32.const 128
-              i32.or
-              i32.store8 offset=2
-              i32.const 3
-              br 4 (;@1;)
-            end
-          end
-          local.get $1
-          i32.const -65536
-          i32.add
-          i32.const 1048576
-          i32.lt_u
-          if (result i32) ;; label = @4
-            block (result i32) ;; label = @5
-              local.get $0
-              local.get $1
-              i32.const 18
-              i32.shr_u
-              i32.const 240
-              i32.or
-              i32.store8
-              local.get $0
-              local.get $1
-              i32.const 12
-              i32.shr_u
-              i32.const 63
-              i32.and
-              i32.const 128
-              i32.or
-              i32.store8 offset=1
-              local.get $0
-              local.get $1
-              i32.const 6
-              i32.shr_u
-              i32.const 63
-              i32.and
-              i32.const 128
-              i32.or
-              i32.store8 offset=2
-              local.get $0
-              local.get $1
-              i32.const 63
-              i32.and
-              i32.const 128
-              i32.or
-              i32.store8 offset=3
-              i32.const 4
-            end
-          else
-            block (result i32) ;; label = @5
-              call $12
-              i32.const 84
-              i32.store
-              i32.const -1
-            end
-          end
-        end
-      else
-        i32.const 1
-      end
-    end
-  )
-  (func $30 (;43;) (type $2) (param $0 i32) (result i32)
-    (local $1 i32) (local $2 i32)
-    block $label$1 (result i32) ;; label = @1
-      local.get $0
-      i32.const 74
-      i32.add
-      local.tee $2
-      i32.load8_s
-      local.set $1
-      local.get $2
-      local.get $1
-      i32.const 255
-      i32.add
-      local.get $1
-      i32.or
-      i32.store8
-      local.get $0
-      i32.load
-      local.tee $1
-      i32.const 8
-      i32.and
-      if (result i32) ;; label = @2
-        block (result i32) ;; label = @3
-          local.get $0
-          local.get $1
-          i32.const 32
-          i32.or
-          i32.store
-          i32.const -1
-        end
-      else
-        block (result i32) ;; label = @3
-          local.get $0
-          i32.const 0
-          i32.store offset=8
-          local.get $0
-          i32.const 0
-          i32.store offset=4
-          local.get $0
-          local.get $0
-          i32.load offset=44
-          local.tee $1
-          i32.store offset=28
-          local.get $0
-          local.get $1
-          i32.store offset=20
-          local.get $0
-          local.get $1
-          local.get $0
-          i32.load offset=48
-          i32.add
-          i32.store offset=16
-          i32.const 0
-        end
-      end
-      local.tee $0
-    end
-  )
-  (func $31 (;44;) (type $2) (param $0 i32) (result i32)
-    (local $1 i32) (local $2 i32) (local $3 i32)
-    block $label$1 (result i32) ;; label = @1
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          local.get $0
-          local.tee $2
-          i32.const 3
-          i32.and
-          i32.eqz
-          br_if 0 (;@3;)
-          local.get $2
-          local.set $1
-          loop $label$4 ;; label = @4
-            local.get $0
-            i32.load8_s
-            i32.eqz
-            if ;; label = @5
-              block ;; label = @6
-                local.get $1
-                local.set $0
-                br 4 (;@2;)
-              end
-            end
-            local.get $0
-            i32.const 1
-            i32.add
-            local.tee $0
-            local.tee $1
-            i32.const 3
-            i32.and
-            br_if 0 (;@4;)
-            br 1 (;@3;)
-          end
-        end
-        loop $label$6 ;; label = @3
-          local.get $0
-          i32.const 4
-          i32.add
-          local.set $1
-          local.get $0
-          i32.load
-          local.tee $3
-          i32.const -2139062144
-          i32.and
-          i32.const -2139062144
-          i32.xor
-          local.get $3
-          i32.const -16843009
-          i32.add
-          i32.and
-          i32.eqz
-          if ;; label = @4
-            block ;; label = @5
-              local.get $1
-              local.set $0
-              br 2 (;@3;)
-            end
-          end
-        end
-        local.get $3
-        i32.const 255
-        i32.and
-        i32.const 24
-        i32.shl
-        i32.const 24
-        i32.shr_s
-        if ;; label = @3
-          loop $label$9 ;; label = @4
-            local.get $0
-            i32.const 1
-            i32.add
-            local.tee $0
-            i32.load8_s
-            br_if 0 (;@4;)
-          end
-        end
-      end
-      local.get $0
-      local.get $2
-      i32.sub
-    end
-  )
-  (func $32 (;45;) (type $6) (param $0 i32) (param $1 i32) (result i32)
-    (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $3
-      global.get $global$1
-      i32.const 16
-      i32.add
-      global.set $global$1
-      local.get $3
-      local.tee $4
-      local.get $1
-      i32.const 255
-      i32.and
-      local.tee $7
-      i32.store8
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          local.get $0
-          i32.const 16
-          i32.add
-          local.tee $2
-          i32.load
-          local.tee $5
-          br_if 0 (;@3;)
-          local.get $0
-          call $30
-          if ;; label = @4
-            i32.const -1
-            local.set $1
-          else
-            block ;; label = @5
-              local.get $2
-              i32.load
-              local.set $5
-              br 2 (;@3;)
-            end
-          end
-          br 1 (;@2;)
-        end
-        local.get $0
-        i32.const 20
-        i32.add
-        local.tee $2
-        i32.load
-        local.tee $6
-        local.get $5
-        i32.lt_u
-        if ;; label = @3
-          local.get $1
-          i32.const 255
-          i32.and
-          local.tee $1
-          local.get $0
-          i32.load8_s offset=75
-          i32.ne
-          if ;; label = @4
-            block ;; label = @5
-              local.get $2
-              local.get $6
-              i32.const 1
-              i32.add
-              i32.store
-              local.get $6
-              local.get $7
-              i32.store8
-              br 3 (;@2;)
-            end
-          end
-        end
-        local.get $0
-        local.get $4
-        i32.const 1
-        local.get $0
-        i32.load offset=36
-        i32.const 3
-        i32.and
-        i32.const 2
-        i32.add
-        call_indirect (type $0)
-        i32.const 1
-        i32.eq
-        if (result i32) ;; label = @3
-          local.get $4
-          i32.load8_u
-        else
-          i32.const -1
-        end
-        local.set $1
-      end
-      local.get $3
-      global.set $global$1
-      local.get $1
-    end
-  )
-  (func $33 (;46;) (type $12) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32)
-    (local $4 i32) (local $5 i32)
-    block $label$1 (result i32) ;; label = @1
-      local.get $2
-      local.get $1
-      i32.mul
-      local.set $4
-      local.get $3
-      i32.load offset=76
-      i32.const -1
-      i32.gt_s
-      if ;; label = @2
-        block ;; label = @3
-          local.get $3
-          call $20
-          i32.eqz
-          local.set $5
-          local.get $0
-          local.get $4
-          local.get $3
-          call $21
-          local.set $0
-          local.get $5
-          i32.eqz
-          if ;; label = @4
-            local.get $3
-            call $13
-          end
-        end
-      else
-        local.get $0
-        local.get $4
-        local.get $3
-        call $21
-        local.set $0
-      end
-      local.get $0
-      local.get $4
-      i32.ne
-      if ;; label = @2
-        local.get $0
-        local.get $1
-        i32.div_u
-        local.set $2
-      end
-      local.get $2
-    end
-  )
-  (func $34 (;47;) (type $6) (param $0 i32) (param $1 i32) (result i32)
-    (local $2 i32) (local $3 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $2
-      global.get $global$1
-      i32.const 16
-      i32.add
-      global.set $global$1
-      local.get $2
-      local.tee $3
-      local.get $1
-      i32.store
-      i32.const 1280
-      i32.load
-      local.get $0
-      local.get $3
-      call $18
-      local.set $0
-      local.get $2
-      global.set $global$1
-      local.get $0
-    end
-  )
-  (func $35 (;48;) (type $2) (param $0 i32) (result i32)
-    (local $1 i32) (local $2 i32) (local $3 i32)
-    block $label$1 (result i32) ;; label = @1
-      i32.const 1280
-      i32.load
-      local.tee $1
-      i32.load offset=76
-      i32.const -1
-      i32.gt_s
-      if (result i32) ;; label = @2
-        local.get $1
-        call $20
-      else
-        i32.const 0
-      end
-      local.set $2
-      block $label$4 (result i32) ;; label = @2
-        local.get $0
-        local.get $1
-        call $36
-        i32.const 0
-        i32.lt_s
-        if (result i32) ;; label = @3
-          i32.const 1
-        else
-          block (result i32) ;; label = @4
-            local.get $1
-            i32.load8_s offset=75
-            i32.const 10
-            i32.ne
-            if ;; label = @5
-              local.get $1
-              i32.const 20
-              i32.add
-              local.tee $3
-              i32.load
-              local.tee $0
-              local.get $1
-              i32.load offset=16
-              i32.lt_u
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $3
-                  local.get $0
-                  i32.const 1
-                  i32.add
-                  i32.store
-                  local.get $0
-                  i32.const 10
-                  i32.store8
-                  i32.const 0
-                  br 5 (;@2;)
-                end
-              end
-            end
-            local.get $1
-            i32.const 10
-            call $32
-            i32.const 0
-            i32.lt_s
-          end
-        end
-      end
-      local.set $0
-      local.get $2
-      if ;; label = @2
-        local.get $1
-        call $13
-      end
-      local.get $0
-      i32.const 31
-      i32.shl
-      i32.const 31
-      i32.shr_s
-    end
-  )
-  (func $36 (;49;) (type $6) (param $0 i32) (param $1 i32) (result i32)
-    local.get $0
-    local.get $0
-    call $31
-    i32.const 1
-    local.get $1
-    call $33
-    i32.const -1
-    i32.add
-  )
-  (func $37 (;50;) (type $2) (param $0 i32) (result i32)
-    (local $1 i32) (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32) (local $15 i32) (local $16 i32) (local $17 i32) (local $18 i32) (local $19 i32) (local $20 i32) (local $21 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $14
-      global.get $global$1
-      i32.const 16
-      i32.add
-      global.set $global$1
-      local.get $14
-      local.set $18
-      block $label$2 ;; label = @2
-        local.get $0
-        i32.const 245
-        i32.lt_u
-        if ;; label = @3
-          block ;; label = @4
-            local.get $0
-            i32.const 11
-            i32.add
-            i32.const -8
-            i32.and
-            local.set $3
-            i32.const 4176
-            i32.load
-            local.tee $8
-            local.get $0
-            i32.const 11
-            i32.lt_u
-            if (result i32) ;; label = @5
-              i32.const 16
-              local.tee $3
-            else
-              local.get $3
-            end
-            i32.const 3
-            i32.shr_u
-            local.tee $2
-            i32.shr_u
-            local.tee $0
-            i32.const 3
-            i32.and
-            if ;; label = @5
-              block ;; label = @6
-                local.get $0
-                i32.const 1
-                i32.and
-                i32.const 1
-                i32.xor
-                local.get $2
-                i32.add
-                local.tee $5
-                i32.const 1
-                i32.shl
-                i32.const 2
-                i32.shl
-                i32.const 4216
-                i32.add
-                local.tee $2
-                i32.const 8
-                i32.add
-                local.tee $3
-                i32.load
-                local.tee $7
-                i32.const 8
-                i32.add
-                local.tee $1
-                i32.load
-                local.set $4
-                local.get $2
-                local.get $4
-                i32.eq
-                if ;; label = @7
-                  i32.const 4176
-                  local.get $8
-                  i32.const 1
-                  local.get $5
-                  i32.shl
-                  i32.const -1
-                  i32.xor
-                  i32.and
-                  i32.store
-                else
-                  block ;; label = @8
-                    local.get $4
-                    i32.const 4192
-                    i32.load
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$8
-                    end
-                    local.get $4
-                    i32.const 12
-                    i32.add
-                    local.tee $0
-                    i32.load
-                    local.get $7
-                    i32.eq
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $0
-                        local.get $2
-                        i32.store
-                        local.get $3
-                        local.get $4
-                        i32.store
-                      end
-                    else
-                      call $fimport$8
-                    end
-                  end
-                end
-                local.get $7
-                local.get $5
-                i32.const 3
-                i32.shl
-                local.tee $0
-                i32.const 3
-                i32.or
-                i32.store offset=4
-                local.get $7
-                local.get $0
-                i32.add
-                i32.const 4
-                i32.add
-                local.tee $0
-                local.get $0
-                i32.load
-                i32.const 1
-                i32.or
-                i32.store
-                local.get $14
-                global.set $global$1
-                local.get $1
-                return
-              end
-            end
-            local.get $3
-            i32.const 4184
-            i32.load
-            local.tee $16
-            i32.gt_u
-            if ;; label = @5
-              block ;; label = @6
-                local.get $0
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $0
-                    local.get $2
-                    i32.shl
-                    i32.const 2
-                    local.get $2
-                    i32.shl
-                    local.tee $0
-                    i32.const 0
-                    local.get $0
-                    i32.sub
-                    i32.or
-                    i32.and
-                    local.tee $0
-                    i32.const 0
-                    local.get $0
-                    i32.sub
-                    i32.and
-                    i32.const -1
-                    i32.add
-                    local.tee $0
-                    i32.const 12
-                    i32.shr_u
-                    i32.const 16
-                    i32.and
-                    local.set $5
-                    local.get $0
-                    local.get $5
-                    i32.shr_u
-                    local.tee $2
-                    i32.const 5
-                    i32.shr_u
-                    i32.const 8
-                    i32.and
-                    local.tee $0
-                    local.get $5
-                    i32.or
-                    local.get $2
-                    local.get $0
-                    i32.shr_u
-                    local.tee $2
-                    i32.const 2
-                    i32.shr_u
-                    i32.const 4
-                    i32.and
-                    local.tee $0
-                    i32.or
-                    local.get $2
-                    local.get $0
-                    i32.shr_u
-                    local.tee $2
-                    i32.const 1
-                    i32.shr_u
-                    i32.const 2
-                    i32.and
-                    local.tee $0
-                    i32.or
-                    local.get $2
-                    local.get $0
-                    i32.shr_u
-                    local.tee $2
-                    i32.const 1
-                    i32.shr_u
-                    i32.const 1
-                    i32.and
-                    local.tee $0
-                    i32.or
-                    local.get $2
-                    local.get $0
-                    i32.shr_u
-                    i32.add
-                    local.tee $11
-                    i32.const 1
-                    i32.shl
-                    i32.const 2
-                    i32.shl
-                    i32.const 4216
-                    i32.add
-                    local.tee $4
-                    i32.const 8
-                    i32.add
-                    local.tee $2
-                    i32.load
-                    local.tee $9
-                    i32.const 8
-                    i32.add
-                    local.tee $5
-                    i32.load
-                    local.set $12
-                    local.get $4
-                    local.get $12
-                    i32.eq
-                    if ;; label = @9
-                      i32.const 4176
-                      local.get $8
-                      i32.const 1
-                      local.get $11
-                      i32.shl
-                      i32.const -1
-                      i32.xor
-                      i32.and
-                      local.tee $7
-                      i32.store
-                    else
-                      block ;; label = @10
-                        local.get $12
-                        i32.const 4192
-                        i32.load
-                        i32.lt_u
-                        if ;; label = @11
-                          call $fimport$8
-                        end
-                        local.get $12
-                        i32.const 12
-                        i32.add
-                        local.tee $0
-                        i32.load
-                        local.get $9
-                        i32.eq
-                        if ;; label = @11
-                          block ;; label = @12
-                            local.get $0
-                            local.get $4
-                            i32.store
-                            local.get $2
-                            local.get $12
-                            i32.store
-                            local.get $8
-                            local.set $7
-                          end
-                        else
-                          call $fimport$8
-                        end
-                      end
-                    end
-                    local.get $9
-                    local.get $3
-                    i32.const 3
-                    i32.or
-                    i32.store offset=4
-                    local.get $9
-                    local.get $3
-                    i32.add
-                    local.tee $4
-                    local.get $11
-                    i32.const 3
-                    i32.shl
-                    local.get $3
-                    i32.sub
-                    local.tee $11
-                    i32.const 1
-                    i32.or
-                    i32.store offset=4
-                    local.get $4
-                    local.get $11
-                    i32.add
-                    local.get $11
-                    i32.store
-                    local.get $16
-                    if ;; label = @9
-                      block ;; label = @10
-                        i32.const 4196
-                        i32.load
-                        local.set $9
-                        local.get $16
-                        i32.const 3
-                        i32.shr_u
-                        local.tee $0
-                        i32.const 1
-                        i32.shl
-                        i32.const 2
-                        i32.shl
-                        i32.const 4216
-                        i32.add
-                        local.set $2
-                        local.get $7
-                        i32.const 1
-                        local.get $0
-                        i32.shl
-                        local.tee $0
-                        i32.and
-                        if ;; label = @11
-                          local.get $2
-                          i32.const 8
-                          i32.add
-                          local.tee $3
-                          i32.load
-                          local.tee $0
-                          i32.const 4192
-                          i32.load
-                          i32.lt_u
-                          if ;; label = @12
-                            call $fimport$8
-                          else
-                            block ;; label = @13
-                              local.get $3
-                              local.set $6
-                              local.get $0
-                              local.set $1
-                            end
-                          end
-                        else
-                          block ;; label = @12
-                            i32.const 4176
-                            local.get $7
-                            local.get $0
-                            i32.or
-                            i32.store
-                            local.get $2
-                            i32.const 8
-                            i32.add
-                            local.set $6
-                            local.get $2
-                            local.set $1
-                          end
-                        end
-                        local.get $6
-                        local.get $9
-                        i32.store
-                        local.get $1
-                        local.get $9
-                        i32.store offset=12
-                        local.get $9
-                        local.get $1
-                        i32.store offset=8
-                        local.get $9
-                        local.get $2
-                        i32.store offset=12
-                      end
-                    end
-                    i32.const 4184
-                    local.get $11
-                    i32.store
-                    i32.const 4196
-                    local.get $4
-                    i32.store
-                    local.get $14
-                    global.set $global$1
-                    local.get $5
-                    return
-                  end
-                end
-                i32.const 4180
-                i32.load
-                local.tee $6
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $6
-                    i32.const 0
-                    local.get $6
-                    i32.sub
-                    i32.and
-                    i32.const -1
-                    i32.add
-                    local.tee $0
-                    i32.const 12
-                    i32.shr_u
-                    i32.const 16
-                    i32.and
-                    local.set $2
-                    local.get $0
-                    local.get $2
-                    i32.shr_u
-                    local.tee $1
-                    i32.const 5
-                    i32.shr_u
-                    i32.const 8
-                    i32.and
-                    local.tee $0
-                    local.get $2
-                    i32.or
-                    local.get $1
-                    local.get $0
-                    i32.shr_u
-                    local.tee $1
-                    i32.const 2
-                    i32.shr_u
-                    i32.const 4
-                    i32.and
-                    local.tee $0
-                    i32.or
-                    local.get $1
-                    local.get $0
-                    i32.shr_u
-                    local.tee $1
-                    i32.const 1
-                    i32.shr_u
-                    i32.const 2
-                    i32.and
-                    local.tee $0
-                    i32.or
-                    local.get $1
-                    local.get $0
-                    i32.shr_u
-                    local.tee $1
-                    i32.const 1
-                    i32.shr_u
-                    i32.const 1
-                    i32.and
-                    local.tee $0
-                    i32.or
-                    local.get $1
-                    local.get $0
-                    i32.shr_u
-                    i32.add
-                    i32.const 2
-                    i32.shl
-                    i32.const 4480
-                    i32.add
-                    i32.load
-                    local.tee $2
-                    i32.load offset=4
-                    i32.const -8
-                    i32.and
-                    local.get $3
-                    i32.sub
-                    local.set $9
-                    local.get $2
-                    local.set $1
-                    loop $label$25 ;; label = @9
-                      block $label$26 ;; label = @10
-                        local.get $1
-                        i32.load offset=16
-                        local.tee $0
-                        i32.eqz
-                        if ;; label = @11
-                          local.get $1
-                          i32.load offset=20
-                          local.tee $0
-                          i32.eqz
-                          br_if 1 (;@10;)
-                        end
-                        local.get $0
-                        i32.load offset=4
-                        i32.const -8
-                        i32.and
-                        local.get $3
-                        i32.sub
-                        local.tee $1
-                        local.get $9
-                        i32.lt_u
-                        local.tee $7
-                        if ;; label = @11
-                          local.get $1
-                          local.set $9
-                        end
-                        local.get $0
-                        local.set $1
-                        local.get $7
-                        if ;; label = @11
-                          local.get $0
-                          local.set $2
-                        end
-                        br 1 (;@9;)
-                      end
-                    end
-                    local.get $2
-                    i32.const 4192
-                    i32.load
-                    local.tee $12
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$8
-                    end
-                    local.get $2
-                    local.get $2
-                    local.get $3
-                    i32.add
-                    local.tee $13
-                    i32.ge_u
-                    if ;; label = @9
-                      call $fimport$8
-                    end
-                    local.get $2
-                    i32.load offset=24
-                    local.set $15
-                    block $label$32 ;; label = @9
-                      local.get $2
-                      i32.load offset=12
-                      local.tee $0
-                      local.get $2
-                      i32.eq
-                      if ;; label = @10
-                        block ;; label = @11
-                          local.get $2
-                          i32.const 20
-                          i32.add
-                          local.tee $1
-                          i32.load
-                          local.tee $0
-                          i32.eqz
-                          if ;; label = @12
-                            local.get $2
-                            i32.const 16
-                            i32.add
-                            local.tee $1
-                            i32.load
-                            local.tee $0
-                            i32.eqz
-                            if ;; label = @13
-                              block ;; label = @14
-                                i32.const 0
-                                local.set $4
-                                br 5 (;@9;)
-                              end
-                            end
-                          end
-                          loop $label$36 ;; label = @12
-                            local.get $0
-                            i32.const 20
-                            i32.add
-                            local.tee $11
-                            i32.load
-                            local.tee $7
-                            if ;; label = @13
-                              block ;; label = @14
-                                local.get $7
-                                local.set $0
-                                local.get $11
-                                local.set $1
-                                br 2 (;@12;)
-                              end
-                            end
-                            local.get $0
-                            i32.const 16
-                            i32.add
-                            local.tee $11
-                            i32.load
-                            local.tee $7
-                            if ;; label = @13
-                              block ;; label = @14
-                                local.get $7
-                                local.set $0
-                                local.get $11
-                                local.set $1
-                                br 2 (;@12;)
-                              end
-                            end
-                          end
-                          local.get $1
-                          local.get $12
-                          i32.lt_u
-                          if ;; label = @12
-                            call $fimport$8
-                          else
-                            block ;; label = @13
-                              local.get $1
-                              i32.const 0
-                              i32.store
-                              local.get $0
-                              local.set $4
-                            end
-                          end
-                        end
-                      else
-                        block ;; label = @11
-                          local.get $2
-                          i32.load offset=8
-                          local.tee $11
-                          local.get $12
-                          i32.lt_u
-                          if ;; label = @12
-                            call $fimport$8
-                          end
-                          local.get $11
-                          i32.const 12
-                          i32.add
-                          local.tee $7
-                          i32.load
-                          local.get $2
-                          i32.ne
-                          if ;; label = @12
-                            call $fimport$8
-                          end
-                          local.get $0
-                          i32.const 8
-                          i32.add
-                          local.tee $1
-                          i32.load
-                          local.get $2
-                          i32.eq
-                          if ;; label = @12
-                            block ;; label = @13
-                              local.get $7
-                              local.get $0
-                              i32.store
-                              local.get $1
-                              local.get $11
-                              i32.store
-                              local.get $0
-                              local.set $4
-                            end
-                          else
-                            call $fimport$8
-                          end
-                        end
-                      end
-                    end
-                    block $label$46 ;; label = @9
-                      local.get $15
-                      if ;; label = @10
-                        block ;; label = @11
-                          local.get $2
-                          local.get $2
-                          i32.load offset=28
-                          local.tee $1
-                          i32.const 2
-                          i32.shl
-                          i32.const 4480
-                          i32.add
-                          local.tee $0
-                          i32.load
-                          i32.eq
-                          if ;; label = @12
-                            block ;; label = @13
-                              local.get $0
-                              local.get $4
-                              i32.store
-                              local.get $4
-                              i32.eqz
-                              if ;; label = @14
-                                block ;; label = @15
-                                  i32.const 4180
-                                  local.get $6
-                                  i32.const 1
-                                  local.get $1
-                                  i32.shl
-                                  i32.const -1
-                                  i32.xor
-                                  i32.and
-                                  i32.store
-                                  br 6 (;@9;)
-                                end
-                              end
-                            end
-                          else
-                            block ;; label = @13
-                              local.get $15
-                              i32.const 4192
-                              i32.load
-                              i32.lt_u
-                              if ;; label = @14
-                                call $fimport$8
-                              end
-                              local.get $15
-                              i32.const 16
-                              i32.add
-                              local.tee $0
-                              i32.load
-                              local.get $2
-                              i32.eq
-                              if ;; label = @14
-                                local.get $0
-                                local.get $4
-                                i32.store
-                              else
-                                local.get $15
-                                local.get $4
-                                i32.store offset=20
-                              end
-                              local.get $4
-                              i32.eqz
-                              br_if 4 (;@9;)
-                            end
-                          end
-                          local.get $4
-                          i32.const 4192
-                          i32.load
-                          local.tee $0
-                          i32.lt_u
-                          if ;; label = @12
-                            call $fimport$8
-                          end
-                          local.get $4
-                          local.get $15
-                          i32.store offset=24
-                          local.get $2
-                          i32.load offset=16
-                          local.tee $1
-                          if ;; label = @12
-                            local.get $1
-                            local.get $0
-                            i32.lt_u
-                            if ;; label = @13
-                              call $fimport$8
-                            else
-                              block ;; label = @14
-                                local.get $4
-                                local.get $1
-                                i32.store offset=16
-                                local.get $1
-                                local.get $4
-                                i32.store offset=24
-                              end
-                            end
-                          end
-                          local.get $2
-                          i32.load offset=20
-                          local.tee $0
-                          if ;; label = @12
-                            local.get $0
-                            i32.const 4192
-                            i32.load
-                            i32.lt_u
-                            if ;; label = @13
-                              call $fimport$8
-                            else
-                              block ;; label = @14
-                                local.get $4
-                                local.get $0
-                                i32.store offset=20
-                                local.get $0
-                                local.get $4
-                                i32.store offset=24
-                              end
-                            end
-                          end
-                        end
-                      end
-                    end
-                    local.get $9
-                    i32.const 16
-                    i32.lt_u
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $2
-                        local.get $9
-                        local.get $3
-                        i32.add
-                        local.tee $0
-                        i32.const 3
-                        i32.or
-                        i32.store offset=4
-                        local.get $2
-                        local.get $0
-                        i32.add
-                        i32.const 4
-                        i32.add
-                        local.tee $0
-                        local.get $0
-                        i32.load
-                        i32.const 1
-                        i32.or
-                        i32.store
-                      end
-                    else
-                      block ;; label = @10
-                        local.get $2
-                        local.get $3
-                        i32.const 3
-                        i32.or
-                        i32.store offset=4
-                        local.get $13
-                        local.get $9
-                        i32.const 1
-                        i32.or
-                        i32.store offset=4
-                        local.get $13
-                        local.get $9
-                        i32.add
-                        local.get $9
-                        i32.store
-                        local.get $16
-                        if ;; label = @11
-                          block ;; label = @12
-                            i32.const 4196
-                            i32.load
-                            local.set $7
-                            local.get $16
-                            i32.const 3
-                            i32.shr_u
-                            local.tee $0
-                            i32.const 1
-                            i32.shl
-                            i32.const 2
-                            i32.shl
-                            i32.const 4216
-                            i32.add
-                            local.set $3
-                            local.get $8
-                            i32.const 1
-                            local.get $0
-                            i32.shl
-                            local.tee $0
-                            i32.and
-                            if ;; label = @13
-                              local.get $3
-                              i32.const 8
-                              i32.add
-                              local.tee $1
-                              i32.load
-                              local.tee $0
-                              i32.const 4192
-                              i32.load
-                              i32.lt_u
-                              if ;; label = @14
-                                call $fimport$8
-                              else
-                                block ;; label = @15
-                                  local.get $1
-                                  local.set $10
-                                  local.get $0
-                                  local.set $5
-                                end
-                              end
-                            else
-                              block ;; label = @14
-                                i32.const 4176
-                                local.get $8
-                                local.get $0
-                                i32.or
-                                i32.store
-                                local.get $3
-                                i32.const 8
-                                i32.add
-                                local.set $10
-                                local.get $3
-                                local.set $5
-                              end
-                            end
-                            local.get $10
-                            local.get $7
-                            i32.store
-                            local.get $5
-                            local.get $7
-                            i32.store offset=12
-                            local.get $7
-                            local.get $5
-                            i32.store offset=8
-                            local.get $7
-                            local.get $3
-                            i32.store offset=12
-                          end
-                        end
-                        i32.const 4184
-                        local.get $9
-                        i32.store
-                        i32.const 4196
-                        local.get $13
-                        i32.store
-                      end
-                    end
-                    local.get $14
-                    global.set $global$1
-                    local.get $2
-                    i32.const 8
-                    i32.add
-                    return
-                  end
-                else
-                  local.get $3
-                  local.set $0
-                end
-              end
-            else
-              local.get $3
-              local.set $0
-            end
-          end
-        else
-          local.get $0
-          i32.const -65
-          i32.gt_u
-          if ;; label = @4
-            i32.const -1
-            local.set $0
-          else
-            block ;; label = @5
-              local.get $0
-              i32.const 11
-              i32.add
-              local.tee $0
-              i32.const -8
-              i32.and
-              local.set $7
-              i32.const 4180
-              i32.load
-              local.tee $5
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $0
-                  i32.const 8
-                  i32.shr_u
-                  local.tee $0
-                  if (result i32) ;; label = @8
-                    local.get $7
-                    i32.const 16777215
-                    i32.gt_u
-                    if (result i32) ;; label = @9
-                      i32.const 31
-                    else
-                      local.get $7
-                      i32.const 14
-                      local.get $0
-                      local.get $0
-                      i32.const 1048320
-                      i32.add
-                      i32.const 16
-                      i32.shr_u
-                      i32.const 8
-                      i32.and
-                      local.tee $3
-                      i32.shl
-                      local.tee $1
-                      i32.const 520192
-                      i32.add
-                      i32.const 16
-                      i32.shr_u
-                      i32.const 4
-                      i32.and
-                      local.tee $0
-                      local.get $3
-                      i32.or
-                      local.get $1
-                      local.get $0
-                      i32.shl
-                      local.tee $1
-                      i32.const 245760
-                      i32.add
-                      i32.const 16
-                      i32.shr_u
-                      i32.const 2
-                      i32.and
-                      local.tee $0
-                      i32.or
-                      i32.sub
-                      local.get $1
-                      local.get $0
-                      i32.shl
-                      i32.const 15
-                      i32.shr_u
-                      i32.add
-                      local.tee $0
-                      i32.const 7
-                      i32.add
-                      i32.shr_u
-                      i32.const 1
-                      i32.and
-                      local.get $0
-                      i32.const 1
-                      i32.shl
-                      i32.or
-                    end
-                  else
-                    i32.const 0
-                  end
-                  local.set $17
-                  i32.const 0
-                  local.get $7
-                  i32.sub
-                  local.set $3
-                  block $label$78 ;; label = @8
-                    block $label$79 ;; label = @9
-                      block $label$80 ;; label = @10
-                        local.get $17
-                        i32.const 2
-                        i32.shl
-                        i32.const 4480
-                        i32.add
-                        i32.load
-                        local.tee $1
-                        if ;; label = @11
-                          block ;; label = @12
-                            i32.const 25
-                            local.get $17
-                            i32.const 1
-                            i32.shr_u
-                            i32.sub
-                            local.set $0
-                            i32.const 0
-                            local.set $4
-                            local.get $7
-                            local.get $17
-                            i32.const 31
-                            i32.eq
-                            if (result i32) ;; label = @13
-                              i32.const 0
-                            else
-                              local.get $0
-                            end
-                            i32.shl
-                            local.set $10
-                            i32.const 0
-                            local.set $0
-                            loop $label$84 ;; label = @13
-                              local.get $1
-                              i32.load offset=4
-                              i32.const -8
-                              i32.and
-                              local.get $7
-                              i32.sub
-                              local.tee $6
-                              local.get $3
-                              i32.lt_u
-                              if ;; label = @14
-                                local.get $6
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $6
-                                    local.set $3
-                                    local.get $1
-                                    local.set $0
-                                  end
-                                else
-                                  block ;; label = @16
-                                    i32.const 0
-                                    local.set $3
-                                    local.get $1
-                                    local.set $0
-                                    br 7 (;@9;)
-                                  end
-                                end
-                              end
-                              local.get $1
-                              i32.load offset=20
-                              local.tee $19
-                              i32.eqz
-                              local.get $19
-                              local.get $1
-                              i32.const 16
-                              i32.add
-                              local.get $10
-                              i32.const 31
-                              i32.shr_u
-                              i32.const 2
-                              i32.shl
-                              i32.add
-                              i32.load
-                              local.tee $6
-                              i32.eq
-                              i32.or
-                              if (result i32) ;; label = @14
-                                local.get $4
-                              else
-                                local.get $19
-                              end
-                              local.set $1
-                              local.get $10
-                              local.get $6
-                              i32.eqz
-                              local.tee $4
-                              i32.const 1
-                              i32.and
-                              i32.const 1
-                              i32.xor
-                              i32.shl
-                              local.set $10
-                              local.get $4
-                              if ;; label = @14
-                                block ;; label = @15
-                                  local.get $1
-                                  local.set $4
-                                  local.get $0
-                                  local.set $1
-                                  br 5 (;@10;)
-                                end
-                              else
-                                block ;; label = @15
-                                  local.get $1
-                                  local.set $4
-                                  local.get $6
-                                  local.set $1
-                                  br 2 (;@13;)
-                                end
-                              end
-                            end
-                          end
-                        else
-                          block ;; label = @12
-                            i32.const 0
-                            local.set $4
-                            i32.const 0
-                            local.set $1
-                          end
-                        end
-                      end
-                      local.get $4
-                      i32.eqz
-                      local.get $1
-                      i32.eqz
-                      i32.and
-                      if (result i32) ;; label = @10
-                        block (result i32) ;; label = @11
-                          local.get $5
-                          i32.const 2
-                          local.get $17
-                          i32.shl
-                          local.tee $0
-                          i32.const 0
-                          local.get $0
-                          i32.sub
-                          i32.or
-                          i32.and
-                          local.tee $0
-                          i32.eqz
-                          if ;; label = @12
-                            block ;; label = @13
-                              local.get $7
-                              local.set $0
-                              br 11 (;@2;)
-                            end
-                          end
-                          local.get $0
-                          i32.const 0
-                          local.get $0
-                          i32.sub
-                          i32.and
-                          i32.const -1
-                          i32.add
-                          local.tee $0
-                          i32.const 12
-                          i32.shr_u
-                          i32.const 16
-                          i32.and
-                          local.set $10
-                          local.get $0
-                          local.get $10
-                          i32.shr_u
-                          local.tee $4
-                          i32.const 5
-                          i32.shr_u
-                          i32.const 8
-                          i32.and
-                          local.tee $0
-                          local.get $10
-                          i32.or
-                          local.get $4
-                          local.get $0
-                          i32.shr_u
-                          local.tee $4
-                          i32.const 2
-                          i32.shr_u
-                          i32.const 4
-                          i32.and
-                          local.tee $0
-                          i32.or
-                          local.get $4
-                          local.get $0
-                          i32.shr_u
-                          local.tee $4
-                          i32.const 1
-                          i32.shr_u
-                          i32.const 2
-                          i32.and
-                          local.tee $0
-                          i32.or
-                          local.get $4
-                          local.get $0
-                          i32.shr_u
-                          local.tee $4
-                          i32.const 1
-                          i32.shr_u
-                          i32.const 1
-                          i32.and
-                          local.tee $0
-                          i32.or
-                          local.get $4
-                          local.get $0
-                          i32.shr_u
-                          i32.add
-                          i32.const 2
-                          i32.shl
-                          i32.const 4480
-                          i32.add
-                          i32.load
-                        end
-                      else
-                        local.get $4
-                      end
-                      local.tee $0
-                      br_if 0 (;@9;)
-                      local.get $1
-                      local.set $4
-                      br 1 (;@8;)
-                    end
-                    loop $label$96 ;; label = @9
-                      local.get $0
-                      i32.load offset=4
-                      i32.const -8
-                      i32.and
-                      local.get $7
-                      i32.sub
-                      local.tee $4
-                      local.get $3
-                      i32.lt_u
-                      local.tee $10
-                      if ;; label = @10
-                        local.get $4
-                        local.set $3
-                      end
-                      local.get $10
-                      if ;; label = @10
-                        local.get $0
-                        local.set $1
-                      end
-                      local.get $0
-                      i32.load offset=16
-                      local.tee $4
-                      if ;; label = @10
-                        block ;; label = @11
-                          local.get $4
-                          local.set $0
-                          br 2 (;@9;)
-                        end
-                      end
-                      local.get $0
-                      i32.load offset=20
-                      local.tee $0
-                      br_if 0 (;@9;)
-                      local.get $1
-                      local.set $4
-                    end
-                  end
-                  local.get $4
-                  if ;; label = @8
-                    local.get $3
-                    i32.const 4184
-                    i32.load
-                    local.get $7
-                    i32.sub
-                    i32.lt_u
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $4
-                        i32.const 4192
-                        i32.load
-                        local.tee $12
-                        i32.lt_u
-                        if ;; label = @11
-                          call $fimport$8
-                        end
-                        local.get $4
-                        local.get $4
-                        local.get $7
-                        i32.add
-                        local.tee $6
-                        i32.ge_u
-                        if ;; label = @11
-                          call $fimport$8
-                        end
-                        local.get $4
-                        i32.load offset=24
-                        local.set $10
-                        block $label$104 ;; label = @11
-                          local.get $4
-                          i32.load offset=12
-                          local.tee $0
-                          local.get $4
-                          i32.eq
-                          if ;; label = @12
-                            block ;; label = @13
-                              local.get $4
-                              i32.const 20
-                              i32.add
-                              local.tee $1
-                              i32.load
-                              local.tee $0
-                              i32.eqz
-                              if ;; label = @14
-                                local.get $4
-                                i32.const 16
-                                i32.add
-                                local.tee $1
-                                i32.load
-                                local.tee $0
-                                i32.eqz
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    i32.const 0
-                                    local.set $13
-                                    br 5 (;@11;)
-                                  end
-                                end
-                              end
-                              loop $label$108 ;; label = @14
-                                local.get $0
-                                i32.const 20
-                                i32.add
-                                local.tee $9
-                                i32.load
-                                local.tee $11
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $11
-                                    local.set $0
-                                    local.get $9
-                                    local.set $1
-                                    br 2 (;@14;)
-                                  end
-                                end
-                                local.get $0
-                                i32.const 16
-                                i32.add
-                                local.tee $9
-                                i32.load
-                                local.tee $11
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $11
-                                    local.set $0
-                                    local.get $9
-                                    local.set $1
-                                    br 2 (;@14;)
-                                  end
-                                end
-                              end
-                              local.get $1
-                              local.get $12
-                              i32.lt_u
-                              if ;; label = @14
-                                call $fimport$8
-                              else
-                                block ;; label = @15
-                                  local.get $1
-                                  i32.const 0
-                                  i32.store
-                                  local.get $0
-                                  local.set $13
-                                end
-                              end
-                            end
-                          else
-                            block ;; label = @13
-                              local.get $4
-                              i32.load offset=8
-                              local.tee $9
-                              local.get $12
-                              i32.lt_u
-                              if ;; label = @14
-                                call $fimport$8
-                              end
-                              local.get $9
-                              i32.const 12
-                              i32.add
-                              local.tee $11
-                              i32.load
-                              local.get $4
-                              i32.ne
-                              if ;; label = @14
-                                call $fimport$8
-                              end
-                              local.get $0
-                              i32.const 8
-                              i32.add
-                              local.tee $1
-                              i32.load
-                              local.get $4
-                              i32.eq
-                              if ;; label = @14
-                                block ;; label = @15
-                                  local.get $11
-                                  local.get $0
-                                  i32.store
-                                  local.get $1
-                                  local.get $9
-                                  i32.store
-                                  local.get $0
-                                  local.set $13
-                                end
-                              else
-                                call $fimport$8
-                              end
-                            end
-                          end
-                        end
-                        block $label$118 ;; label = @11
-                          local.get $10
-                          if ;; label = @12
-                            block ;; label = @13
-                              local.get $4
-                              local.get $4
-                              i32.load offset=28
-                              local.tee $1
-                              i32.const 2
-                              i32.shl
-                              i32.const 4480
-                              i32.add
-                              local.tee $0
-                              i32.load
-                              i32.eq
-                              if ;; label = @14
-                                block ;; label = @15
-                                  local.get $0
-                                  local.get $13
-                                  i32.store
-                                  local.get $13
-                                  i32.eqz
-                                  if ;; label = @16
-                                    block ;; label = @17
-                                      i32.const 4180
-                                      local.get $5
-                                      i32.const 1
-                                      local.get $1
-                                      i32.shl
-                                      i32.const -1
-                                      i32.xor
-                                      i32.and
-                                      local.tee $2
-                                      i32.store
-                                      br 6 (;@11;)
-                                    end
-                                  end
-                                end
-                              else
-                                block ;; label = @15
-                                  local.get $10
-                                  i32.const 4192
-                                  i32.load
-                                  i32.lt_u
-                                  if ;; label = @16
-                                    call $fimport$8
-                                  end
-                                  local.get $10
-                                  i32.const 16
-                                  i32.add
-                                  local.tee $0
-                                  i32.load
-                                  local.get $4
-                                  i32.eq
-                                  if ;; label = @16
-                                    local.get $0
-                                    local.get $13
-                                    i32.store
-                                  else
-                                    local.get $10
-                                    local.get $13
-                                    i32.store offset=20
-                                  end
-                                  local.get $13
-                                  i32.eqz
-                                  if ;; label = @16
-                                    block ;; label = @17
-                                      local.get $5
-                                      local.set $2
-                                      br 6 (;@11;)
-                                    end
-                                  end
-                                end
-                              end
-                              local.get $13
-                              i32.const 4192
-                              i32.load
-                              local.tee $0
-                              i32.lt_u
-                              if ;; label = @14
-                                call $fimport$8
-                              end
-                              local.get $13
-                              local.get $10
-                              i32.store offset=24
-                              local.get $4
-                              i32.load offset=16
-                              local.tee $1
-                              if ;; label = @14
-                                local.get $1
-                                local.get $0
-                                i32.lt_u
-                                if ;; label = @15
-                                  call $fimport$8
-                                else
-                                  block ;; label = @16
-                                    local.get $13
-                                    local.get $1
-                                    i32.store offset=16
-                                    local.get $1
-                                    local.get $13
-                                    i32.store offset=24
-                                  end
-                                end
-                              end
-                              local.get $4
-                              i32.load offset=20
-                              local.tee $0
-                              if ;; label = @14
-                                local.get $0
-                                i32.const 4192
-                                i32.load
-                                i32.lt_u
-                                if ;; label = @15
-                                  call $fimport$8
-                                else
-                                  block ;; label = @16
-                                    local.get $13
-                                    local.get $0
-                                    i32.store offset=20
-                                    local.get $0
-                                    local.get $13
-                                    i32.store offset=24
-                                    local.get $5
-                                    local.set $2
-                                  end
-                                end
-                              else
-                                local.get $5
-                                local.set $2
-                              end
-                            end
-                          else
-                            local.get $5
-                            local.set $2
-                          end
-                        end
-                        block $label$136 ;; label = @11
-                          local.get $3
-                          i32.const 16
-                          i32.lt_u
-                          if ;; label = @12
-                            block ;; label = @13
-                              local.get $4
-                              local.get $3
-                              local.get $7
-                              i32.add
-                              local.tee $0
-                              i32.const 3
-                              i32.or
-                              i32.store offset=4
-                              local.get $4
-                              local.get $0
-                              i32.add
-                              i32.const 4
-                              i32.add
-                              local.tee $0
-                              local.get $0
-                              i32.load
-                              i32.const 1
-                              i32.or
-                              i32.store
-                            end
-                          else
-                            block ;; label = @13
-                              local.get $4
-                              local.get $7
-                              i32.const 3
-                              i32.or
-                              i32.store offset=4
-                              local.get $6
-                              local.get $3
-                              i32.const 1
-                              i32.or
-                              i32.store offset=4
-                              local.get $6
-                              local.get $3
-                              i32.add
-                              local.get $3
-                              i32.store
-                              local.get $3
-                              i32.const 3
-                              i32.shr_u
-                              local.set $0
-                              local.get $3
-                              i32.const 256
-                              i32.lt_u
-                              if ;; label = @14
-                                block ;; label = @15
-                                  local.get $0
-                                  i32.const 1
-                                  i32.shl
-                                  i32.const 2
-                                  i32.shl
-                                  i32.const 4216
-                                  i32.add
-                                  local.set $3
-                                  i32.const 4176
-                                  i32.load
-                                  local.tee $1
-                                  i32.const 1
-                                  local.get $0
-                                  i32.shl
-                                  local.tee $0
-                                  i32.and
-                                  if ;; label = @16
-                                    local.get $3
-                                    i32.const 8
-                                    i32.add
-                                    local.tee $1
-                                    i32.load
-                                    local.tee $0
-                                    i32.const 4192
-                                    i32.load
-                                    i32.lt_u
-                                    if ;; label = @17
-                                      call $fimport$8
-                                    else
-                                      block ;; label = @18
-                                        local.get $1
-                                        local.set $16
-                                        local.get $0
-                                        local.set $8
-                                      end
-                                    end
-                                  else
-                                    block ;; label = @17
-                                      i32.const 4176
-                                      local.get $1
-                                      local.get $0
-                                      i32.or
-                                      i32.store
-                                      local.get $3
-                                      i32.const 8
-                                      i32.add
-                                      local.set $16
-                                      local.get $3
-                                      local.set $8
-                                    end
-                                  end
-                                  local.get $16
-                                  local.get $6
-                                  i32.store
-                                  local.get $8
-                                  local.get $6
-                                  i32.store offset=12
-                                  local.get $6
-                                  local.get $8
-                                  i32.store offset=8
-                                  local.get $6
-                                  local.get $3
-                                  i32.store offset=12
-                                  br 4 (;@11;)
-                                end
-                              end
-                              local.get $3
-                              i32.const 8
-                              i32.shr_u
-                              local.tee $0
-                              if (result i32) ;; label = @14
-                                local.get $3
-                                i32.const 16777215
-                                i32.gt_u
-                                if (result i32) ;; label = @15
-                                  i32.const 31
-                                else
-                                  local.get $3
-                                  i32.const 14
-                                  local.get $0
-                                  local.get $0
-                                  i32.const 1048320
-                                  i32.add
-                                  i32.const 16
-                                  i32.shr_u
-                                  i32.const 8
-                                  i32.and
-                                  local.tee $5
-                                  i32.shl
-                                  local.tee $1
-                                  i32.const 520192
-                                  i32.add
-                                  i32.const 16
-                                  i32.shr_u
-                                  i32.const 4
-                                  i32.and
-                                  local.tee $0
-                                  local.get $5
-                                  i32.or
-                                  local.get $1
-                                  local.get $0
-                                  i32.shl
-                                  local.tee $1
-                                  i32.const 245760
-                                  i32.add
-                                  i32.const 16
-                                  i32.shr_u
-                                  i32.const 2
-                                  i32.and
-                                  local.tee $0
-                                  i32.or
-                                  i32.sub
-                                  local.get $1
-                                  local.get $0
-                                  i32.shl
-                                  i32.const 15
-                                  i32.shr_u
-                                  i32.add
-                                  local.tee $0
-                                  i32.const 7
-                                  i32.add
-                                  i32.shr_u
-                                  i32.const 1
-                                  i32.and
-                                  local.get $0
-                                  i32.const 1
-                                  i32.shl
-                                  i32.or
-                                end
-                              else
-                                i32.const 0
-                              end
-                              local.tee $5
-                              i32.const 2
-                              i32.shl
-                              i32.const 4480
-                              i32.add
-                              local.set $1
-                              local.get $6
-                              local.get $5
-                              i32.store offset=28
-                              local.get $6
-                              i32.const 16
-                              i32.add
-                              local.tee $0
-                              i32.const 0
-                              i32.store offset=4
-                              local.get $0
-                              i32.const 0
-                              i32.store
-                              local.get $2
-                              i32.const 1
-                              local.get $5
-                              i32.shl
-                              local.tee $0
-                              i32.and
-                              i32.eqz
-                              if ;; label = @14
-                                block ;; label = @15
-                                  i32.const 4180
-                                  local.get $2
-                                  local.get $0
-                                  i32.or
-                                  i32.store
-                                  local.get $1
-                                  local.get $6
-                                  i32.store
-                                  local.get $6
-                                  local.get $1
-                                  i32.store offset=24
-                                  local.get $6
-                                  local.get $6
-                                  i32.store offset=12
-                                  local.get $6
-                                  local.get $6
-                                  i32.store offset=8
-                                  br 4 (;@11;)
-                                end
-                              end
-                              local.get $1
-                              i32.load
-                              local.set $0
-                              i32.const 25
-                              local.get $5
-                              i32.const 1
-                              i32.shr_u
-                              i32.sub
-                              local.set $1
-                              local.get $3
-                              local.get $5
-                              i32.const 31
-                              i32.eq
-                              if (result i32) ;; label = @14
-                                i32.const 0
-                              else
-                                local.get $1
-                              end
-                              i32.shl
-                              local.set $5
-                              block $label$151 ;; label = @14
-                                block $label$152 ;; label = @15
-                                  block $label$153 ;; label = @16
-                                    loop $label$154 ;; label = @17
-                                      local.get $0
-                                      i32.load offset=4
-                                      i32.const -8
-                                      i32.and
-                                      local.get $3
-                                      i32.eq
-                                      br_if 2 (;@15;)
-                                      local.get $5
-                                      i32.const 1
-                                      i32.shl
-                                      local.set $2
-                                      local.get $0
-                                      i32.const 16
-                                      i32.add
-                                      local.get $5
-                                      i32.const 31
-                                      i32.shr_u
-                                      i32.const 2
-                                      i32.shl
-                                      i32.add
-                                      local.tee $5
-                                      i32.load
-                                      local.tee $1
-                                      i32.eqz
-                                      br_if 1 (;@16;)
-                                      local.get $2
-                                      local.set $5
-                                      local.get $1
-                                      local.set $0
-                                      br 0 (;@17;)
-                                    end
-                                  end
-                                  local.get $5
-                                  i32.const 4192
-                                  i32.load
-                                  i32.lt_u
-                                  if ;; label = @16
-                                    call $fimport$8
-                                  else
-                                    block ;; label = @17
-                                      local.get $5
-                                      local.get $6
-                                      i32.store
-                                      local.get $6
-                                      local.get $0
-                                      i32.store offset=24
-                                      local.get $6
-                                      local.get $6
-                                      i32.store offset=12
-                                      local.get $6
-                                      local.get $6
-                                      i32.store offset=8
-                                      br 6 (;@11;)
-                                    end
-                                  end
-                                  br 1 (;@14;)
-                                end
-                                local.get $0
-                                i32.const 8
-                                i32.add
-                                local.tee $3
-                                i32.load
-                                local.tee $2
-                                i32.const 4192
-                                i32.load
-                                local.tee $1
-                                i32.ge_u
-                                local.get $0
-                                local.get $1
-                                i32.ge_u
-                                i32.and
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $2
-                                    local.get $6
-                                    i32.store offset=12
-                                    local.get $3
-                                    local.get $6
-                                    i32.store
-                                    local.get $6
-                                    local.get $2
-                                    i32.store offset=8
-                                    local.get $6
-                                    local.get $0
-                                    i32.store offset=12
-                                    local.get $6
-                                    i32.const 0
-                                    i32.store offset=24
-                                  end
-                                else
-                                  call $fimport$8
-                                end
-                              end
-                            end
-                          end
-                        end
-                        local.get $14
-                        global.set $global$1
-                        local.get $4
-                        i32.const 8
-                        i32.add
-                        return
-                      end
-                    else
-                      local.get $7
-                      local.set $0
-                    end
-                  else
-                    local.get $7
-                    local.set $0
-                  end
-                end
-              else
-                local.get $7
-                local.set $0
-              end
-            end
-          end
-        end
-      end
-      i32.const 4184
-      i32.load
-      local.tee $1
-      local.get $0
-      i32.ge_u
-      if ;; label = @2
-        block ;; label = @3
-          i32.const 4196
-          i32.load
-          local.set $2
-          local.get $1
-          local.get $0
-          i32.sub
-          local.tee $3
-          i32.const 15
-          i32.gt_u
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 4196
-              local.get $2
-              local.get $0
-              i32.add
-              local.tee $1
-              i32.store
-              i32.const 4184
-              local.get $3
-              i32.store
-              local.get $1
-              local.get $3
-              i32.const 1
-              i32.or
-              i32.store offset=4
-              local.get $1
-              local.get $3
-              i32.add
-              local.get $3
-              i32.store
-              local.get $2
-              local.get $0
-              i32.const 3
-              i32.or
-              i32.store offset=4
-            end
-          else
-            block ;; label = @5
-              i32.const 4184
-              i32.const 0
-              i32.store
-              i32.const 4196
-              i32.const 0
-              i32.store
-              local.get $2
-              local.get $1
-              i32.const 3
-              i32.or
-              i32.store offset=4
-              local.get $2
-              local.get $1
-              i32.add
-              i32.const 4
-              i32.add
-              local.tee $0
-              local.get $0
-              i32.load
-              i32.const 1
-              i32.or
-              i32.store
-            end
-          end
-          local.get $14
-          global.set $global$1
-          local.get $2
-          i32.const 8
-          i32.add
-          return
-        end
-      end
-      i32.const 4188
-      i32.load
-      local.tee $10
-      local.get $0
-      i32.gt_u
-      if ;; label = @2
-        block ;; label = @3
-          i32.const 4188
-          local.get $10
-          local.get $0
-          i32.sub
-          local.tee $3
-          i32.store
-          i32.const 4200
-          i32.const 4200
-          i32.load
-          local.tee $2
-          local.get $0
-          i32.add
-          local.tee $1
-          i32.store
-          local.get $1
-          local.get $3
-          i32.const 1
-          i32.or
-          i32.store offset=4
-          local.get $2
-          local.get $0
-          i32.const 3
-          i32.or
-          i32.store offset=4
-          local.get $14
-          global.set $global$1
-          local.get $2
-          i32.const 8
-          i32.add
-          return
-        end
-      end
-      i32.const 4648
-      i32.load
-      if (result i32) ;; label = @2
-        i32.const 4656
-        i32.load
-      else
-        block (result i32) ;; label = @3
-          i32.const 4656
-          i32.const 4096
-          i32.store
-          i32.const 4652
-          i32.const 4096
-          i32.store
-          i32.const 4660
-          i32.const -1
-          i32.store
-          i32.const 4664
-          i32.const -1
-          i32.store
-          i32.const 4668
-          i32.const 0
-          i32.store
-          i32.const 4620
-          i32.const 0
-          i32.store
-          local.get $18
-          local.get $18
-          i32.const -16
-          i32.and
-          i32.const 1431655768
-          i32.xor
-          local.tee $1
-          i32.store
-          i32.const 4648
-          local.get $1
-          i32.store
-          i32.const 4096
-        end
-      end
-      local.tee $1
-      local.get $0
-      i32.const 47
-      i32.add
-      local.tee $13
-      i32.add
-      local.tee $8
-      i32.const 0
-      local.get $1
-      i32.sub
-      local.tee $4
-      i32.and
-      local.tee $6
-      local.get $0
-      i32.le_u
-      if ;; label = @2
-        block ;; label = @3
-          local.get $14
-          global.set $global$1
-          i32.const 0
-          return
-        end
-      end
-      i32.const 4616
-      i32.load
-      local.tee $2
-      if ;; label = @2
-        i32.const 4608
-        i32.load
-        local.tee $3
-        local.get $6
-        i32.add
-        local.tee $1
-        local.get $3
-        i32.le_u
-        local.get $1
-        local.get $2
-        i32.gt_u
-        i32.or
-        if ;; label = @3
-          block ;; label = @4
-            local.get $14
-            global.set $global$1
-            i32.const 0
-            return
-          end
-        end
-      end
-      local.get $0
-      i32.const 48
-      i32.add
-      local.set $7
-      block $label$171 ;; label = @2
-        block $label$172 ;; label = @3
-          i32.const 4620
-          i32.load
-          i32.const 4
-          i32.and
-          i32.eqz
-          if ;; label = @4
-            block ;; label = @5
-              block $label$174 ;; label = @6
-                block $label$175 ;; label = @7
-                  block $label$176 ;; label = @8
-                    i32.const 4200
-                    i32.load
-                    local.tee $3
-                    i32.eqz
-                    br_if 0 (;@8;)
-                    i32.const 4624
-                    local.set $2
-                    loop $label$177 ;; label = @9
-                      block $label$178 ;; label = @10
-                        local.get $2
-                        i32.load
-                        local.tee $1
-                        local.get $3
-                        i32.le_u
-                        if ;; label = @11
-                          local.get $1
-                          local.get $2
-                          i32.const 4
-                          i32.add
-                          local.tee $5
-                          i32.load
-                          i32.add
-                          local.get $3
-                          i32.gt_u
-                          br_if 1 (;@10;)
-                        end
-                        local.get $2
-                        i32.load offset=8
-                        local.tee $1
-                        i32.eqz
-                        br_if 2 (;@8;)
-                        local.get $1
-                        local.set $2
-                        br 1 (;@9;)
-                      end
-                    end
-                    local.get $8
-                    local.get $10
-                    i32.sub
-                    local.get $4
-                    i32.and
-                    local.tee $3
-                    i32.const 2147483647
-                    i32.lt_u
-                    if ;; label = @9
-                      local.get $3
-                      call $45
-                      local.tee $1
-                      local.get $2
-                      i32.load
-                      local.get $5
-                      i32.load
-                      i32.add
-                      i32.eq
-                      if ;; label = @10
-                        local.get $1
-                        i32.const -1
-                        i32.ne
-                        br_if 7 (;@3;)
-                      else
-                        block ;; label = @11
-                          local.get $1
-                          local.set $2
-                          local.get $3
-                          local.set $1
-                          br 4 (;@7;)
-                        end
-                      end
-                    end
-                    br 2 (;@6;)
-                  end
-                  i32.const 0
-                  call $45
-                  local.tee $1
-                  i32.const -1
-                  i32.ne
-                  if ;; label = @8
-                    block ;; label = @9
-                      i32.const 4652
-                      i32.load
-                      local.tee $2
-                      i32.const -1
-                      i32.add
-                      local.tee $5
-                      local.get $1
-                      local.tee $3
-                      i32.add
-                      i32.const 0
-                      local.get $2
-                      i32.sub
-                      i32.and
-                      local.get $3
-                      i32.sub
-                      local.set $2
-                      local.get $5
-                      local.get $3
-                      i32.and
-                      if (result i32) ;; label = @10
-                        local.get $2
-                      else
-                        i32.const 0
-                      end
-                      local.get $6
-                      i32.add
-                      local.tee $3
-                      i32.const 4608
-                      i32.load
-                      local.tee $5
-                      i32.add
-                      local.set $4
-                      local.get $3
-                      local.get $0
-                      i32.gt_u
-                      local.get $3
-                      i32.const 2147483647
-                      i32.lt_u
-                      i32.and
-                      if ;; label = @10
-                        block ;; label = @11
-                          i32.const 4616
-                          i32.load
-                          local.tee $2
-                          if ;; label = @12
-                            local.get $4
-                            local.get $5
-                            i32.le_u
-                            local.get $4
-                            local.get $2
-                            i32.gt_u
-                            i32.or
-                            br_if 6 (;@6;)
-                          end
-                          local.get $3
-                          call $45
-                          local.tee $2
-                          local.get $1
-                          i32.eq
-                          br_if 8 (;@3;)
-                          local.get $3
-                          local.set $1
-                          br 4 (;@7;)
-                        end
-                      end
-                    end
-                  end
-                  br 1 (;@6;)
-                end
-                i32.const 0
-                local.get $1
-                i32.sub
-                local.set $5
-                local.get $7
-                local.get $1
-                i32.gt_u
-                local.get $1
-                i32.const 2147483647
-                i32.lt_u
-                local.get $2
-                i32.const -1
-                i32.ne
-                i32.and
-                i32.and
-                if ;; label = @7
-                  local.get $13
-                  local.get $1
-                  i32.sub
-                  i32.const 4656
-                  i32.load
-                  local.tee $3
-                  i32.add
-                  i32.const 0
-                  local.get $3
-                  i32.sub
-                  i32.and
-                  local.tee $3
-                  i32.const 2147483647
-                  i32.lt_u
-                  if ;; label = @8
-                    local.get $3
-                    call $45
-                    i32.const -1
-                    i32.eq
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $5
-                        call $45
-                        drop
-                        br 4 (;@6;)
-                      end
-                    else
-                      local.get $3
-                      local.get $1
-                      i32.add
-                      local.set $3
-                    end
-                  else
-                    local.get $1
-                    local.set $3
-                  end
-                else
-                  local.get $1
-                  local.set $3
-                end
-                local.get $2
-                i32.const -1
-                i32.ne
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $2
-                    local.set $1
-                    br 5 (;@3;)
-                  end
-                end
-              end
-              i32.const 4620
-              i32.const 4620
-              i32.load
-              i32.const 4
-              i32.or
-              i32.store
-            end
-          end
-          local.get $6
-          i32.const 2147483647
-          i32.lt_u
-          if ;; label = @4
-            local.get $6
-            call $45
-            local.tee $1
-            i32.const 0
-            call $45
-            local.tee $3
-            i32.lt_u
-            local.get $1
-            i32.const -1
-            i32.ne
-            local.get $3
-            i32.const -1
-            i32.ne
-            i32.and
-            i32.and
-            if ;; label = @5
-              local.get $3
-              local.get $1
-              i32.sub
-              local.tee $3
-              local.get $0
-              i32.const 40
-              i32.add
-              i32.gt_u
-              br_if 2 (;@3;)
-            end
-          end
-          br 1 (;@2;)
-        end
-        i32.const 4608
-        i32.const 4608
-        i32.load
-        local.get $3
-        i32.add
-        local.tee $2
-        i32.store
-        local.get $2
-        i32.const 4612
-        i32.load
-        i32.gt_u
-        if ;; label = @3
-          i32.const 4612
-          local.get $2
-          i32.store
-        end
-        block $label$198 ;; label = @3
-          i32.const 4200
-          i32.load
-          local.tee $8
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 4624
-              local.set $2
-              block $label$200 ;; label = @6
-                block $label$201 ;; label = @7
-                  loop $label$202 ;; label = @8
-                    local.get $1
-                    local.get $2
-                    i32.load
-                    local.tee $4
-                    local.get $2
-                    i32.const 4
-                    i32.add
-                    local.tee $7
-                    i32.load
-                    local.tee $5
-                    i32.add
-                    i32.eq
-                    br_if 1 (;@7;)
-                    local.get $2
-                    i32.load offset=8
-                    local.tee $2
-                    br_if 0 (;@8;)
-                  end
-                  br 1 (;@6;)
-                end
-                local.get $2
-                i32.load offset=12
-                i32.const 8
-                i32.and
-                i32.eqz
-                if ;; label = @7
-                  local.get $8
-                  local.get $1
-                  i32.lt_u
-                  local.get $8
-                  local.get $4
-                  i32.ge_u
-                  i32.and
-                  if ;; label = @8
-                    block ;; label = @9
-                      local.get $7
-                      local.get $5
-                      local.get $3
-                      i32.add
-                      i32.store
-                      i32.const 4188
-                      i32.load
-                      local.set $5
-                      i32.const 0
-                      local.get $8
-                      i32.const 8
-                      i32.add
-                      local.tee $2
-                      i32.sub
-                      i32.const 7
-                      i32.and
-                      local.set $1
-                      i32.const 4200
-                      local.get $8
-                      local.get $2
-                      i32.const 7
-                      i32.and
-                      if (result i32) ;; label = @10
-                        local.get $1
-                      else
-                        i32.const 0
-                        local.tee $1
-                      end
-                      i32.add
-                      local.tee $2
-                      i32.store
-                      i32.const 4188
-                      local.get $3
-                      local.get $1
-                      i32.sub
-                      local.get $5
-                      i32.add
-                      local.tee $1
-                      i32.store
-                      local.get $2
-                      local.get $1
-                      i32.const 1
-                      i32.or
-                      i32.store offset=4
-                      local.get $2
-                      local.get $1
-                      i32.add
-                      i32.const 40
-                      i32.store offset=4
-                      i32.const 4204
-                      i32.const 4664
-                      i32.load
-                      i32.store
-                      br 6 (;@3;)
-                    end
-                  end
-                end
-              end
-              local.get $1
-              i32.const 4192
-              i32.load
-              local.tee $2
-              i32.lt_u
-              if ;; label = @6
-                block ;; label = @7
-                  i32.const 4192
-                  local.get $1
-                  i32.store
-                  local.get $1
-                  local.set $2
-                end
-              end
-              local.get $1
-              local.get $3
-              i32.add
-              local.set $10
-              i32.const 4624
-              local.set $5
-              block $label$208 ;; label = @6
-                block $label$209 ;; label = @7
-                  loop $label$210 ;; label = @8
-                    local.get $5
-                    i32.load
-                    local.get $10
-                    i32.eq
-                    br_if 1 (;@7;)
-                    local.get $5
-                    i32.load offset=8
-                    local.tee $5
-                    br_if 0 (;@8;)
-                    i32.const 4624
-                    local.set $5
-                  end
-                  br 1 (;@6;)
-                end
-                local.get $5
-                i32.load offset=12
-                i32.const 8
-                i32.and
-                if ;; label = @7
-                  i32.const 4624
-                  local.set $5
-                else
-                  block ;; label = @8
-                    local.get $5
-                    local.get $1
-                    i32.store
-                    local.get $5
-                    i32.const 4
-                    i32.add
-                    local.tee $5
-                    local.get $5
-                    i32.load
-                    local.get $3
-                    i32.add
-                    i32.store
-                    i32.const 0
-                    local.get $1
-                    i32.const 8
-                    i32.add
-                    local.tee $4
-                    i32.sub
-                    i32.const 7
-                    i32.and
-                    local.set $7
-                    i32.const 0
-                    local.get $10
-                    i32.const 8
-                    i32.add
-                    local.tee $5
-                    i32.sub
-                    i32.const 7
-                    i32.and
-                    local.set $3
-                    local.get $1
-                    local.get $4
-                    i32.const 7
-                    i32.and
-                    if (result i32) ;; label = @9
-                      local.get $7
-                    else
-                      i32.const 0
-                    end
-                    i32.add
-                    local.tee $13
-                    local.get $0
-                    i32.add
-                    local.set $6
-                    local.get $10
-                    local.get $5
-                    i32.const 7
-                    i32.and
-                    if (result i32) ;; label = @9
-                      local.get $3
-                    else
-                      i32.const 0
-                    end
-                    i32.add
-                    local.tee $4
-                    local.get $13
-                    i32.sub
-                    local.get $0
-                    i32.sub
-                    local.set $7
-                    local.get $13
-                    local.get $0
-                    i32.const 3
-                    i32.or
-                    i32.store offset=4
-                    block $label$217 ;; label = @9
-                      local.get $4
-                      local.get $8
-                      i32.eq
-                      if ;; label = @10
-                        block ;; label = @11
-                          i32.const 4188
-                          i32.const 4188
-                          i32.load
-                          local.get $7
-                          i32.add
-                          local.tee $0
-                          i32.store
-                          i32.const 4200
-                          local.get $6
-                          i32.store
-                          local.get $6
-                          local.get $0
-                          i32.const 1
-                          i32.or
-                          i32.store offset=4
-                        end
-                      else
-                        block ;; label = @11
-                          local.get $4
-                          i32.const 4196
-                          i32.load
-                          i32.eq
-                          if ;; label = @12
-                            block ;; label = @13
-                              i32.const 4184
-                              i32.const 4184
-                              i32.load
-                              local.get $7
-                              i32.add
-                              local.tee $0
-                              i32.store
-                              i32.const 4196
-                              local.get $6
-                              i32.store
-                              local.get $6
-                              local.get $0
-                              i32.const 1
-                              i32.or
-                              i32.store offset=4
-                              local.get $6
-                              local.get $0
-                              i32.add
-                              local.get $0
-                              i32.store
-                              br 4 (;@9;)
-                            end
-                          end
-                          local.get $4
-                          i32.load offset=4
-                          local.tee $0
-                          i32.const 3
-                          i32.and
-                          i32.const 1
-                          i32.eq
-                          if (result i32) ;; label = @12
-                            block (result i32) ;; label = @13
-                              local.get $0
-                              i32.const -8
-                              i32.and
-                              local.set $11
-                              local.get $0
-                              i32.const 3
-                              i32.shr_u
-                              local.set $1
-                              block $label$222 ;; label = @14
-                                local.get $0
-                                i32.const 256
-                                i32.lt_u
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $4
-                                    i32.load offset=12
-                                    local.set $5
-                                    block $label$224 ;; label = @17
-                                      local.get $4
-                                      i32.load offset=8
-                                      local.tee $3
-                                      local.get $1
-                                      i32.const 1
-                                      i32.shl
-                                      i32.const 2
-                                      i32.shl
-                                      i32.const 4216
-                                      i32.add
-                                      local.tee $0
-                                      i32.ne
-                                      if ;; label = @18
-                                        block ;; label = @19
-                                          local.get $3
-                                          local.get $2
-                                          i32.lt_u
-                                          if ;; label = @20
-                                            call $fimport$8
-                                          end
-                                          local.get $3
-                                          i32.load offset=12
-                                          local.get $4
-                                          i32.eq
-                                          br_if 2 (;@17;)
-                                          call $fimport$8
-                                        end
-                                      end
-                                    end
-                                    local.get $5
-                                    local.get $3
-                                    i32.eq
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        i32.const 4176
-                                        i32.const 4176
-                                        i32.load
-                                        i32.const 1
-                                        local.get $1
-                                        i32.shl
-                                        i32.const -1
-                                        i32.xor
-                                        i32.and
-                                        i32.store
-                                        br 4 (;@14;)
-                                      end
-                                    end
-                                    block $label$228 ;; label = @17
-                                      local.get $5
-                                      local.get $0
-                                      i32.eq
-                                      if ;; label = @18
-                                        local.get $5
-                                        i32.const 8
-                                        i32.add
-                                        local.set $20
-                                      else
-                                        block ;; label = @19
-                                          local.get $5
-                                          local.get $2
-                                          i32.lt_u
-                                          if ;; label = @20
-                                            call $fimport$8
-                                          end
-                                          local.get $5
-                                          i32.const 8
-                                          i32.add
-                                          local.tee $0
-                                          i32.load
-                                          local.get $4
-                                          i32.eq
-                                          if ;; label = @20
-                                            block ;; label = @21
-                                              local.get $0
-                                              local.set $20
-                                              br 4 (;@17;)
-                                            end
-                                          end
-                                          call $fimport$8
-                                        end
-                                      end
-                                    end
-                                    local.get $3
-                                    local.get $5
-                                    i32.store offset=12
-                                    local.get $20
-                                    local.get $3
-                                    i32.store
-                                  end
-                                else
-                                  block ;; label = @16
-                                    local.get $4
-                                    i32.load offset=24
-                                    local.set $8
-                                    block $label$234 ;; label = @17
-                                      local.get $4
-                                      i32.load offset=12
-                                      local.tee $0
-                                      local.get $4
-                                      i32.eq
-                                      if ;; label = @18
-                                        block ;; label = @19
-                                          local.get $4
-                                          i32.const 16
-                                          i32.add
-                                          local.tee $3
-                                          i32.const 4
-                                          i32.add
-                                          local.tee $1
-                                          i32.load
-                                          local.tee $0
-                                          i32.eqz
-                                          if ;; label = @20
-                                            local.get $3
-                                            i32.load
-                                            local.tee $0
-                                            if ;; label = @21
-                                              local.get $3
-                                              local.set $1
-                                            else
-                                              block ;; label = @22
-                                                i32.const 0
-                                                local.set $12
-                                                br 5 (;@17;)
-                                              end
-                                            end
-                                          end
-                                          loop $label$239 ;; label = @20
-                                            local.get $0
-                                            i32.const 20
-                                            i32.add
-                                            local.tee $5
-                                            i32.load
-                                            local.tee $3
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                local.get $3
-                                                local.set $0
-                                                local.get $5
-                                                local.set $1
-                                                br 2 (;@20;)
-                                              end
-                                            end
-                                            local.get $0
-                                            i32.const 16
-                                            i32.add
-                                            local.tee $5
-                                            i32.load
-                                            local.tee $3
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                local.get $3
-                                                local.set $0
-                                                local.get $5
-                                                local.set $1
-                                                br 2 (;@20;)
-                                              end
-                                            end
-                                          end
-                                          local.get $1
-                                          local.get $2
-                                          i32.lt_u
-                                          if ;; label = @20
-                                            call $fimport$8
-                                          else
-                                            block ;; label = @21
-                                              local.get $1
-                                              i32.const 0
-                                              i32.store
-                                              local.get $0
-                                              local.set $12
-                                            end
-                                          end
-                                        end
-                                      else
-                                        block ;; label = @19
-                                          local.get $4
-                                          i32.load offset=8
-                                          local.tee $5
-                                          local.get $2
-                                          i32.lt_u
-                                          if ;; label = @20
-                                            call $fimport$8
-                                          end
-                                          local.get $5
-                                          i32.const 12
-                                          i32.add
-                                          local.tee $3
-                                          i32.load
-                                          local.get $4
-                                          i32.ne
-                                          if ;; label = @20
-                                            call $fimport$8
-                                          end
-                                          local.get $0
-                                          i32.const 8
-                                          i32.add
-                                          local.tee $1
-                                          i32.load
-                                          local.get $4
-                                          i32.eq
-                                          if ;; label = @20
-                                            block ;; label = @21
-                                              local.get $3
-                                              local.get $0
-                                              i32.store
-                                              local.get $1
-                                              local.get $5
-                                              i32.store
-                                              local.get $0
-                                              local.set $12
-                                            end
-                                          else
-                                            call $fimport$8
-                                          end
-                                        end
-                                      end
-                                    end
-                                    local.get $8
-                                    i32.eqz
-                                    br_if 2 (;@14;)
-                                    block $label$249 ;; label = @17
-                                      local.get $4
-                                      local.get $4
-                                      i32.load offset=28
-                                      local.tee $1
-                                      i32.const 2
-                                      i32.shl
-                                      i32.const 4480
-                                      i32.add
-                                      local.tee $0
-                                      i32.load
-                                      i32.eq
-                                      if ;; label = @18
-                                        block ;; label = @19
-                                          local.get $0
-                                          local.get $12
-                                          i32.store
-                                          local.get $12
-                                          br_if 2 (;@17;)
-                                          i32.const 4180
-                                          i32.const 4180
-                                          i32.load
-                                          i32.const 1
-                                          local.get $1
-                                          i32.shl
-                                          i32.const -1
-                                          i32.xor
-                                          i32.and
-                                          i32.store
-                                          br 5 (;@14;)
-                                        end
-                                      else
-                                        block ;; label = @19
-                                          local.get $8
-                                          i32.const 4192
-                                          i32.load
-                                          i32.lt_u
-                                          if ;; label = @20
-                                            call $fimport$8
-                                          end
-                                          local.get $8
-                                          i32.const 16
-                                          i32.add
-                                          local.tee $0
-                                          i32.load
-                                          local.get $4
-                                          i32.eq
-                                          if ;; label = @20
-                                            local.get $0
-                                            local.get $12
-                                            i32.store
-                                          else
-                                            local.get $8
-                                            local.get $12
-                                            i32.store offset=20
-                                          end
-                                          local.get $12
-                                          i32.eqz
-                                          br_if 5 (;@14;)
-                                        end
-                                      end
-                                    end
-                                    local.get $12
-                                    i32.const 4192
-                                    i32.load
-                                    local.tee $1
-                                    i32.lt_u
-                                    if ;; label = @17
-                                      call $fimport$8
-                                    end
-                                    local.get $12
-                                    local.get $8
-                                    i32.store offset=24
-                                    local.get $4
-                                    i32.const 16
-                                    i32.add
-                                    local.tee $0
-                                    i32.load
-                                    local.tee $3
-                                    if ;; label = @17
-                                      local.get $3
-                                      local.get $1
-                                      i32.lt_u
-                                      if ;; label = @18
-                                        call $fimport$8
-                                      else
-                                        block ;; label = @19
-                                          local.get $12
-                                          local.get $3
-                                          i32.store offset=16
-                                          local.get $3
-                                          local.get $12
-                                          i32.store offset=24
-                                        end
-                                      end
-                                    end
-                                    local.get $0
-                                    i32.load offset=4
-                                    local.tee $0
-                                    i32.eqz
-                                    br_if 2 (;@14;)
-                                    local.get $0
-                                    i32.const 4192
-                                    i32.load
-                                    i32.lt_u
-                                    if ;; label = @17
-                                      call $fimport$8
-                                    else
-                                      block ;; label = @18
-                                        local.get $12
-                                        local.get $0
-                                        i32.store offset=20
-                                        local.get $0
-                                        local.get $12
-                                        i32.store offset=24
-                                      end
-                                    end
-                                  end
-                                end
-                              end
-                              local.get $11
-                              local.get $7
-                              i32.add
-                              local.set $7
-                              local.get $4
-                              local.get $11
-                              i32.add
-                            end
-                          else
-                            local.get $4
-                          end
-                          local.tee $0
-                          i32.const 4
-                          i32.add
-                          local.tee $0
-                          local.get $0
-                          i32.load
-                          i32.const -2
-                          i32.and
-                          i32.store
-                          local.get $6
-                          local.get $7
-                          i32.const 1
-                          i32.or
-                          i32.store offset=4
-                          local.get $6
-                          local.get $7
-                          i32.add
-                          local.get $7
-                          i32.store
-                          local.get $7
-                          i32.const 3
-                          i32.shr_u
-                          local.set $0
-                          local.get $7
-                          i32.const 256
-                          i32.lt_u
-                          if ;; label = @12
-                            block ;; label = @13
-                              local.get $0
-                              i32.const 1
-                              i32.shl
-                              i32.const 2
-                              i32.shl
-                              i32.const 4216
-                              i32.add
-                              local.set $3
-                              block $label$263 ;; label = @14
-                                i32.const 4176
-                                i32.load
-                                local.tee $1
-                                i32.const 1
-                                local.get $0
-                                i32.shl
-                                local.tee $0
-                                i32.and
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $3
-                                    i32.const 8
-                                    i32.add
-                                    local.tee $1
-                                    i32.load
-                                    local.tee $0
-                                    i32.const 4192
-                                    i32.load
-                                    i32.ge_u
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        local.get $1
-                                        local.set $21
-                                        local.get $0
-                                        local.set $9
-                                        br 4 (;@14;)
-                                      end
-                                    end
-                                    call $fimport$8
-                                  end
-                                else
-                                  block ;; label = @16
-                                    i32.const 4176
-                                    local.get $1
-                                    local.get $0
-                                    i32.or
-                                    i32.store
-                                    local.get $3
-                                    i32.const 8
-                                    i32.add
-                                    local.set $21
-                                    local.get $3
-                                    local.set $9
-                                  end
-                                end
-                              end
-                              local.get $21
-                              local.get $6
-                              i32.store
-                              local.get $9
-                              local.get $6
-                              i32.store offset=12
-                              local.get $6
-                              local.get $9
-                              i32.store offset=8
-                              local.get $6
-                              local.get $3
-                              i32.store offset=12
-                              br 4 (;@9;)
-                            end
-                          end
-                          block $label$267 (result i32) ;; label = @12
-                            local.get $7
-                            i32.const 8
-                            i32.shr_u
-                            local.tee $0
-                            if (result i32) ;; label = @13
-                              block (result i32) ;; label = @14
-                                i32.const 31
-                                local.get $7
-                                i32.const 16777215
-                                i32.gt_u
-                                br_if 2 (;@12;)
-                                drop
-                                local.get $7
-                                i32.const 14
-                                local.get $0
-                                local.get $0
-                                i32.const 1048320
-                                i32.add
-                                i32.const 16
-                                i32.shr_u
-                                i32.const 8
-                                i32.and
-                                local.tee $3
-                                i32.shl
-                                local.tee $1
-                                i32.const 520192
-                                i32.add
-                                i32.const 16
-                                i32.shr_u
-                                i32.const 4
-                                i32.and
-                                local.tee $0
-                                local.get $3
-                                i32.or
-                                local.get $1
-                                local.get $0
-                                i32.shl
-                                local.tee $1
-                                i32.const 245760
-                                i32.add
-                                i32.const 16
-                                i32.shr_u
-                                i32.const 2
-                                i32.and
-                                local.tee $0
-                                i32.or
-                                i32.sub
-                                local.get $1
-                                local.get $0
-                                i32.shl
-                                i32.const 15
-                                i32.shr_u
-                                i32.add
-                                local.tee $0
-                                i32.const 7
-                                i32.add
-                                i32.shr_u
-                                i32.const 1
-                                i32.and
-                                local.get $0
-                                i32.const 1
-                                i32.shl
-                                i32.or
-                              end
-                            else
-                              i32.const 0
-                            end
-                          end
-                          local.tee $2
-                          i32.const 2
-                          i32.shl
-                          i32.const 4480
-                          i32.add
-                          local.set $3
-                          local.get $6
-                          local.get $2
-                          i32.store offset=28
-                          local.get $6
-                          i32.const 16
-                          i32.add
-                          local.tee $0
-                          i32.const 0
-                          i32.store offset=4
-                          local.get $0
-                          i32.const 0
-                          i32.store
-                          i32.const 4180
-                          i32.load
-                          local.tee $1
-                          i32.const 1
-                          local.get $2
-                          i32.shl
-                          local.tee $0
-                          i32.and
-                          i32.eqz
-                          if ;; label = @12
-                            block ;; label = @13
-                              i32.const 4180
-                              local.get $1
-                              local.get $0
-                              i32.or
-                              i32.store
-                              local.get $3
-                              local.get $6
-                              i32.store
-                              local.get $6
-                              local.get $3
-                              i32.store offset=24
-                              local.get $6
-                              local.get $6
-                              i32.store offset=12
-                              local.get $6
-                              local.get $6
-                              i32.store offset=8
-                              br 4 (;@9;)
-                            end
-                          end
-                          local.get $3
-                          i32.load
-                          local.set $0
-                          i32.const 25
-                          local.get $2
-                          i32.const 1
-                          i32.shr_u
-                          i32.sub
-                          local.set $1
-                          local.get $7
-                          local.get $2
-                          i32.const 31
-                          i32.eq
-                          if (result i32) ;; label = @12
-                            i32.const 0
-                          else
-                            local.get $1
-                          end
-                          i32.shl
-                          local.set $2
-                          block $label$273 ;; label = @12
-                            block $label$274 ;; label = @13
-                              block $label$275 ;; label = @14
-                                loop $label$276 ;; label = @15
-                                  local.get $0
-                                  i32.load offset=4
-                                  i32.const -8
-                                  i32.and
-                                  local.get $7
-                                  i32.eq
-                                  br_if 2 (;@13;)
-                                  local.get $2
-                                  i32.const 1
-                                  i32.shl
-                                  local.set $3
-                                  local.get $0
-                                  i32.const 16
-                                  i32.add
-                                  local.get $2
-                                  i32.const 31
-                                  i32.shr_u
-                                  i32.const 2
-                                  i32.shl
-                                  i32.add
-                                  local.tee $2
-                                  i32.load
-                                  local.tee $1
-                                  i32.eqz
-                                  br_if 1 (;@14;)
-                                  local.get $3
-                                  local.set $2
-                                  local.get $1
-                                  local.set $0
-                                  br 0 (;@15;)
-                                end
-                              end
-                              local.get $2
-                              i32.const 4192
-                              i32.load
-                              i32.lt_u
-                              if ;; label = @14
-                                call $fimport$8
-                              else
-                                block ;; label = @15
-                                  local.get $2
-                                  local.get $6
-                                  i32.store
-                                  local.get $6
-                                  local.get $0
-                                  i32.store offset=24
-                                  local.get $6
-                                  local.get $6
-                                  i32.store offset=12
-                                  local.get $6
-                                  local.get $6
-                                  i32.store offset=8
-                                  br 6 (;@9;)
-                                end
-                              end
-                              br 1 (;@12;)
-                            end
-                            local.get $0
-                            i32.const 8
-                            i32.add
-                            local.tee $3
-                            i32.load
-                            local.tee $2
-                            i32.const 4192
-                            i32.load
-                            local.tee $1
-                            i32.ge_u
-                            local.get $0
-                            local.get $1
-                            i32.ge_u
-                            i32.and
-                            if ;; label = @13
-                              block ;; label = @14
-                                local.get $2
-                                local.get $6
-                                i32.store offset=12
-                                local.get $3
-                                local.get $6
-                                i32.store
-                                local.get $6
-                                local.get $2
-                                i32.store offset=8
-                                local.get $6
-                                local.get $0
-                                i32.store offset=12
-                                local.get $6
-                                i32.const 0
-                                i32.store offset=24
-                              end
-                            else
-                              call $fimport$8
-                            end
-                          end
-                        end
-                      end
-                    end
-                    local.get $14
-                    global.set $global$1
-                    local.get $13
-                    i32.const 8
-                    i32.add
-                    return
-                  end
-                end
-              end
-              loop $label$281 ;; label = @6
-                block $label$282 ;; label = @7
-                  local.get $5
-                  i32.load
-                  local.tee $2
-                  local.get $8
-                  i32.le_u
-                  if ;; label = @8
-                    local.get $2
-                    local.get $5
-                    i32.load offset=4
-                    i32.add
-                    local.tee $13
-                    local.get $8
-                    i32.gt_u
-                    br_if 1 (;@7;)
-                  end
-                  local.get $5
-                  i32.load offset=8
-                  local.set $5
-                  br 1 (;@6;)
-                end
-              end
-              i32.const 0
-              local.get $13
-              i32.const -47
-              i32.add
-              local.tee $7
-              i32.const 8
-              i32.add
-              local.tee $5
-              i32.sub
-              i32.const 7
-              i32.and
-              local.set $2
-              local.get $7
-              local.get $5
-              i32.const 7
-              i32.and
-              if (result i32) ;; label = @6
-                local.get $2
-              else
-                i32.const 0
-              end
-              i32.add
-              local.tee $2
-              local.get $8
-              i32.const 16
-              i32.add
-              local.tee $12
-              i32.lt_u
-              if (result i32) ;; label = @6
-                local.get $8
-              else
-                local.get $2
-              end
-              local.tee $7
-              i32.const 8
-              i32.add
-              local.set $10
-              local.get $7
-              i32.const 24
-              i32.add
-              local.set $5
-              local.get $3
-              i32.const -40
-              i32.add
-              local.set $9
-              i32.const 0
-              local.get $1
-              i32.const 8
-              i32.add
-              local.tee $4
-              i32.sub
-              i32.const 7
-              i32.and
-              local.set $2
-              i32.const 4200
-              local.get $1
-              local.get $4
-              i32.const 7
-              i32.and
-              if (result i32) ;; label = @6
-                local.get $2
-              else
-                i32.const 0
-                local.tee $2
-              end
-              i32.add
-              local.tee $4
-              i32.store
-              i32.const 4188
-              local.get $9
-              local.get $2
-              i32.sub
-              local.tee $2
-              i32.store
-              local.get $4
-              local.get $2
-              i32.const 1
-              i32.or
-              i32.store offset=4
-              local.get $4
-              local.get $2
-              i32.add
-              i32.const 40
-              i32.store offset=4
-              i32.const 4204
-              i32.const 4664
-              i32.load
-              i32.store
-              local.get $7
-              i32.const 4
-              i32.add
-              local.tee $2
-              i32.const 27
-              i32.store
-              local.get $10
-              i32.const 4624
-              i64.load align=4
-              i64.store align=4
-              local.get $10
-              i32.const 4632
-              i64.load align=4
-              i64.store offset=8 align=4
-              i32.const 4624
-              local.get $1
-              i32.store
-              i32.const 4628
-              local.get $3
-              i32.store
-              i32.const 4636
-              i32.const 0
-              i32.store
-              i32.const 4632
-              local.get $10
-              i32.store
-              local.get $5
-              local.set $1
-              loop $label$290 ;; label = @6
-                local.get $1
-                i32.const 4
-                i32.add
-                local.tee $1
-                i32.const 7
-                i32.store
-                local.get $1
-                i32.const 4
-                i32.add
-                local.get $13
-                i32.lt_u
-                br_if 0 (;@6;)
-              end
-              local.get $7
-              local.get $8
-              i32.ne
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $2
-                  local.get $2
-                  i32.load
-                  i32.const -2
-                  i32.and
-                  i32.store
-                  local.get $8
-                  local.get $7
-                  local.get $8
-                  i32.sub
-                  local.tee $4
-                  i32.const 1
-                  i32.or
-                  i32.store offset=4
-                  local.get $7
-                  local.get $4
-                  i32.store
-                  local.get $4
-                  i32.const 3
-                  i32.shr_u
-                  local.set $1
-                  local.get $4
-                  i32.const 256
-                  i32.lt_u
-                  if ;; label = @8
-                    block ;; label = @9
-                      local.get $1
-                      i32.const 1
-                      i32.shl
-                      i32.const 2
-                      i32.shl
-                      i32.const 4216
-                      i32.add
-                      local.set $2
-                      i32.const 4176
-                      i32.load
-                      local.tee $3
-                      i32.const 1
-                      local.get $1
-                      i32.shl
-                      local.tee $1
-                      i32.and
-                      if ;; label = @10
-                        local.get $2
-                        i32.const 8
-                        i32.add
-                        local.tee $3
-                        i32.load
-                        local.tee $1
-                        i32.const 4192
-                        i32.load
-                        i32.lt_u
-                        if ;; label = @11
-                          call $fimport$8
-                        else
-                          block ;; label = @12
-                            local.get $3
-                            local.set $15
-                            local.get $1
-                            local.set $11
-                          end
-                        end
-                      else
-                        block ;; label = @11
-                          i32.const 4176
-                          local.get $3
-                          local.get $1
-                          i32.or
-                          i32.store
-                          local.get $2
-                          i32.const 8
-                          i32.add
-                          local.set $15
-                          local.get $2
-                          local.set $11
-                        end
-                      end
-                      local.get $15
-                      local.get $8
-                      i32.store
-                      local.get $11
-                      local.get $8
-                      i32.store offset=12
-                      local.get $8
-                      local.get $11
-                      i32.store offset=8
-                      local.get $8
-                      local.get $2
-                      i32.store offset=12
-                      br 6 (;@3;)
-                    end
-                  end
-                  local.get $4
-                  i32.const 8
-                  i32.shr_u
-                  local.tee $1
-                  if (result i32) ;; label = @8
-                    local.get $4
-                    i32.const 16777215
-                    i32.gt_u
-                    if (result i32) ;; label = @9
-                      i32.const 31
-                    else
-                      local.get $4
-                      i32.const 14
-                      local.get $1
-                      local.get $1
-                      i32.const 1048320
-                      i32.add
-                      i32.const 16
-                      i32.shr_u
-                      i32.const 8
-                      i32.and
-                      local.tee $2
-                      i32.shl
-                      local.tee $3
-                      i32.const 520192
-                      i32.add
-                      i32.const 16
-                      i32.shr_u
-                      i32.const 4
-                      i32.and
-                      local.tee $1
-                      local.get $2
-                      i32.or
-                      local.get $3
-                      local.get $1
-                      i32.shl
-                      local.tee $3
-                      i32.const 245760
-                      i32.add
-                      i32.const 16
-                      i32.shr_u
-                      i32.const 2
-                      i32.and
-                      local.tee $1
-                      i32.or
-                      i32.sub
-                      local.get $3
-                      local.get $1
-                      i32.shl
-                      i32.const 15
-                      i32.shr_u
-                      i32.add
-                      local.tee $1
-                      i32.const 7
-                      i32.add
-                      i32.shr_u
-                      i32.const 1
-                      i32.and
-                      local.get $1
-                      i32.const 1
-                      i32.shl
-                      i32.or
-                    end
-                  else
-                    i32.const 0
-                  end
-                  local.tee $5
-                  i32.const 2
-                  i32.shl
-                  i32.const 4480
-                  i32.add
-                  local.set $2
-                  local.get $8
-                  local.get $5
-                  i32.store offset=28
-                  local.get $8
-                  i32.const 0
-                  i32.store offset=20
-                  local.get $12
-                  i32.const 0
-                  i32.store
-                  i32.const 4180
-                  i32.load
-                  local.tee $3
-                  i32.const 1
-                  local.get $5
-                  i32.shl
-                  local.tee $1
-                  i32.and
-                  i32.eqz
-                  if ;; label = @8
-                    block ;; label = @9
-                      i32.const 4180
-                      local.get $3
-                      local.get $1
-                      i32.or
-                      i32.store
-                      local.get $2
-                      local.get $8
-                      i32.store
-                      local.get $8
-                      local.get $2
-                      i32.store offset=24
-                      local.get $8
-                      local.get $8
-                      i32.store offset=12
-                      local.get $8
-                      local.get $8
-                      i32.store offset=8
-                      br 6 (;@3;)
-                    end
-                  end
-                  local.get $2
-                  i32.load
-                  local.set $1
-                  i32.const 25
-                  local.get $5
-                  i32.const 1
-                  i32.shr_u
-                  i32.sub
-                  local.set $3
-                  local.get $4
-                  local.get $5
-                  i32.const 31
-                  i32.eq
-                  if (result i32) ;; label = @8
-                    i32.const 0
-                  else
-                    local.get $3
-                  end
-                  i32.shl
-                  local.set $5
-                  block $label$304 ;; label = @8
-                    block $label$305 ;; label = @9
-                      block $label$306 ;; label = @10
-                        loop $label$307 ;; label = @11
-                          local.get $1
-                          i32.load offset=4
-                          i32.const -8
-                          i32.and
-                          local.get $4
-                          i32.eq
-                          br_if 2 (;@9;)
-                          local.get $5
-                          i32.const 1
-                          i32.shl
-                          local.set $2
-                          local.get $1
-                          i32.const 16
-                          i32.add
-                          local.get $5
-                          i32.const 31
-                          i32.shr_u
-                          i32.const 2
-                          i32.shl
-                          i32.add
-                          local.tee $5
-                          i32.load
-                          local.tee $3
-                          i32.eqz
-                          br_if 1 (;@10;)
-                          local.get $2
-                          local.set $5
-                          local.get $3
-                          local.set $1
-                          br 0 (;@11;)
-                        end
-                      end
-                      local.get $5
-                      i32.const 4192
-                      i32.load
-                      i32.lt_u
-                      if ;; label = @10
-                        call $fimport$8
-                      else
-                        block ;; label = @11
-                          local.get $5
-                          local.get $8
-                          i32.store
-                          local.get $8
-                          local.get $1
-                          i32.store offset=24
-                          local.get $8
-                          local.get $8
-                          i32.store offset=12
-                          local.get $8
-                          local.get $8
-                          i32.store offset=8
-                          br 8 (;@3;)
-                        end
-                      end
-                      br 1 (;@8;)
-                    end
-                    local.get $1
-                    i32.const 8
-                    i32.add
-                    local.tee $2
-                    i32.load
-                    local.tee $5
-                    i32.const 4192
-                    i32.load
-                    local.tee $3
-                    i32.ge_u
-                    local.get $1
-                    local.get $3
-                    i32.ge_u
-                    i32.and
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $5
-                        local.get $8
-                        i32.store offset=12
-                        local.get $2
-                        local.get $8
-                        i32.store
-                        local.get $8
-                        local.get $5
-                        i32.store offset=8
-                        local.get $8
-                        local.get $1
-                        i32.store offset=12
-                        local.get $8
-                        i32.const 0
-                        i32.store offset=24
-                      end
-                    else
-                      call $fimport$8
-                    end
-                  end
-                end
-              end
-            end
-          else
-            block ;; label = @5
-              i32.const 4192
-              i32.load
-              local.tee $2
-              i32.eqz
-              local.get $1
-              local.get $2
-              i32.lt_u
-              i32.or
-              if ;; label = @6
-                i32.const 4192
-                local.get $1
-                i32.store
-              end
-              i32.const 4624
-              local.get $1
-              i32.store
-              i32.const 4628
-              local.get $3
-              i32.store
-              i32.const 4636
-              i32.const 0
-              i32.store
-              i32.const 4212
-              i32.const 4648
-              i32.load
-              i32.store
-              i32.const 4208
-              i32.const -1
-              i32.store
-              i32.const 0
-              local.set $2
-              loop $label$314 ;; label = @6
-                local.get $2
-                i32.const 1
-                i32.shl
-                i32.const 2
-                i32.shl
-                i32.const 4216
-                i32.add
-                local.tee $5
-                local.get $5
-                i32.store offset=12
-                local.get $5
-                local.get $5
-                i32.store offset=8
-                local.get $2
-                i32.const 1
-                i32.add
-                local.tee $2
-                i32.const 32
-                i32.ne
-                br_if 0 (;@6;)
-              end
-              local.get $3
-              i32.const -40
-              i32.add
-              local.set $5
-              i32.const 0
-              local.get $1
-              i32.const 8
-              i32.add
-              local.tee $2
-              i32.sub
-              i32.const 7
-              i32.and
-              local.set $3
-              i32.const 4200
-              local.get $1
-              local.get $2
-              i32.const 7
-              i32.and
-              if (result i32) ;; label = @6
-                local.get $3
-              else
-                i32.const 0
-              end
-              local.tee $1
-              i32.add
-              local.tee $3
-              i32.store
-              i32.const 4188
-              local.get $5
-              local.get $1
-              i32.sub
-              local.tee $1
-              i32.store
-              local.get $3
-              local.get $1
-              i32.const 1
-              i32.or
-              i32.store offset=4
-              local.get $3
-              local.get $1
-              i32.add
-              i32.const 40
-              i32.store offset=4
-              i32.const 4204
-              i32.const 4664
-              i32.load
-              i32.store
-            end
-          end
-        end
-        i32.const 4188
-        i32.load
-        local.tee $1
-        local.get $0
-        i32.gt_u
-        if ;; label = @3
-          block ;; label = @4
-            i32.const 4188
-            local.get $1
-            local.get $0
-            i32.sub
-            local.tee $3
-            i32.store
-            i32.const 4200
-            i32.const 4200
-            i32.load
-            local.tee $2
-            local.get $0
-            i32.add
-            local.tee $1
-            i32.store
-            local.get $1
-            local.get $3
-            i32.const 1
-            i32.or
-            i32.store offset=4
-            local.get $2
-            local.get $0
-            i32.const 3
-            i32.or
-            i32.store offset=4
-            local.get $14
-            global.set $global$1
-            local.get $2
-            i32.const 8
-            i32.add
-            return
-          end
-        end
-      end
-      call $12
-      i32.const 12
-      i32.store
-      local.get $14
-      global.set $global$1
-      i32.const 0
-    end
-  )
-  (func $38 (;51;) (type $3) (param $0 i32)
-    (local $1 i32) (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32) (local $15 i32)
-    block $label$1 ;; label = @1
-      local.get $0
-      i32.eqz
-      if ;; label = @2
-        return
-      end
-      local.get $0
-      i32.const -8
-      i32.add
-      local.tee $1
-      i32.const 4192
-      i32.load
-      local.tee $11
-      i32.lt_u
-      if ;; label = @2
-        call $fimport$8
-      end
-      local.get $0
-      i32.const -4
-      i32.add
-      i32.load
-      local.tee $0
-      i32.const 3
-      i32.and
-      local.tee $8
-      i32.const 1
-      i32.eq
-      if ;; label = @2
-        call $fimport$8
-      end
-      local.get $1
-      local.get $0
-      i32.const -8
-      i32.and
-      local.tee $4
-      i32.add
-      local.set $6
-      block $label$5 ;; label = @2
-        local.get $0
-        i32.const 1
-        i32.and
-        if ;; label = @3
-          block ;; label = @4
-            local.get $1
-            local.set $3
-            local.get $4
-            local.set $2
-          end
-        else
-          block ;; label = @4
-            local.get $8
-            i32.eqz
-            if ;; label = @5
-              return
-            end
-            local.get $1
-            i32.const 0
-            local.get $1
-            i32.load
-            local.tee $8
-            i32.sub
-            i32.add
-            local.tee $0
-            local.get $11
-            i32.lt_u
-            if ;; label = @5
-              call $fimport$8
-            end
-            local.get $8
-            local.get $4
-            i32.add
-            local.set $1
-            local.get $0
-            i32.const 4196
-            i32.load
-            i32.eq
-            if ;; label = @5
-              block ;; label = @6
-                local.get $6
-                i32.const 4
-                i32.add
-                local.tee $2
-                i32.load
-                local.tee $3
-                i32.const 3
-                i32.and
-                i32.const 3
-                i32.ne
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $0
-                    local.set $3
-                    local.get $1
-                    local.set $2
-                    br 6 (;@2;)
-                  end
-                end
-                i32.const 4184
-                local.get $1
-                i32.store
-                local.get $2
-                local.get $3
-                i32.const -2
-                i32.and
-                i32.store
-                local.get $0
-                local.get $1
-                i32.const 1
-                i32.or
-                i32.store offset=4
-                local.get $0
-                local.get $1
-                i32.add
-                local.get $1
-                i32.store
-                return
-              end
-            end
-            local.get $8
-            i32.const 3
-            i32.shr_u
-            local.set $10
-            local.get $8
-            i32.const 256
-            i32.lt_u
-            if ;; label = @5
-              block ;; label = @6
-                local.get $0
-                i32.load offset=12
-                local.set $3
-                local.get $0
-                i32.load offset=8
-                local.tee $4
-                local.get $10
-                i32.const 1
-                i32.shl
-                i32.const 2
-                i32.shl
-                i32.const 4216
-                i32.add
-                local.tee $2
-                i32.ne
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $4
-                    local.get $11
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$8
-                    end
-                    local.get $4
-                    i32.load offset=12
-                    local.get $0
-                    i32.ne
-                    if ;; label = @9
-                      call $fimport$8
-                    end
-                  end
-                end
-                local.get $3
-                local.get $4
-                i32.eq
-                if ;; label = @7
-                  block ;; label = @8
-                    i32.const 4176
-                    i32.const 4176
-                    i32.load
-                    i32.const 1
-                    local.get $10
-                    i32.shl
-                    i32.const -1
-                    i32.xor
-                    i32.and
-                    i32.store
-                    local.get $0
-                    local.set $3
-                    local.get $1
-                    local.set $2
-                    br 6 (;@2;)
-                  end
-                end
-                local.get $3
-                local.get $2
-                i32.eq
-                if ;; label = @7
-                  local.get $3
-                  i32.const 8
-                  i32.add
-                  local.set $5
-                else
-                  block ;; label = @8
-                    local.get $3
-                    local.get $11
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$8
-                    end
-                    local.get $3
-                    i32.const 8
-                    i32.add
-                    local.tee $2
-                    i32.load
-                    local.get $0
-                    i32.eq
-                    if ;; label = @9
-                      local.get $2
-                      local.set $5
-                    else
-                      call $fimport$8
-                    end
-                  end
-                end
-                local.get $4
-                local.get $3
-                i32.store offset=12
-                local.get $5
-                local.get $4
-                i32.store
-                local.get $0
-                local.set $3
-                local.get $1
-                local.set $2
-                br 4 (;@2;)
-              end
-            end
-            local.get $0
-            i32.load offset=24
-            local.set $12
-            block $label$22 ;; label = @5
-              local.get $0
-              i32.load offset=12
-              local.tee $4
-              local.get $0
-              i32.eq
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $0
-                  i32.const 16
-                  i32.add
-                  local.tee $5
-                  i32.const 4
-                  i32.add
-                  local.tee $8
-                  i32.load
-                  local.tee $4
-                  if ;; label = @8
-                    local.get $8
-                    local.set $5
-                  else
-                    local.get $5
-                    i32.load
-                    local.tee $4
-                    i32.eqz
-                    if ;; label = @9
-                      block ;; label = @10
-                        i32.const 0
-                        local.set $7
-                        br 5 (;@5;)
-                      end
-                    end
-                  end
-                  loop $label$27 ;; label = @8
-                    local.get $4
-                    i32.const 20
-                    i32.add
-                    local.tee $8
-                    i32.load
-                    local.tee $10
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $10
-                        local.set $4
-                        local.get $8
-                        local.set $5
-                        br 2 (;@8;)
-                      end
-                    end
-                    local.get $4
-                    i32.const 16
-                    i32.add
-                    local.tee $8
-                    i32.load
-                    local.tee $10
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $10
-                        local.set $4
-                        local.get $8
-                        local.set $5
-                        br 2 (;@8;)
-                      end
-                    end
-                  end
-                  local.get $5
-                  local.get $11
-                  i32.lt_u
-                  if ;; label = @8
-                    call $fimport$8
-                  else
-                    block ;; label = @9
-                      local.get $5
-                      i32.const 0
-                      i32.store
-                      local.get $4
-                      local.set $7
-                    end
-                  end
-                end
-              else
-                block ;; label = @7
-                  local.get $0
-                  i32.load offset=8
-                  local.tee $5
-                  local.get $11
-                  i32.lt_u
-                  if ;; label = @8
-                    call $fimport$8
-                  end
-                  local.get $5
-                  i32.const 12
-                  i32.add
-                  local.tee $8
-                  i32.load
-                  local.get $0
-                  i32.ne
-                  if ;; label = @8
-                    call $fimport$8
-                  end
-                  local.get $4
-                  i32.const 8
-                  i32.add
-                  local.tee $10
-                  i32.load
-                  local.get $0
-                  i32.eq
-                  if ;; label = @8
-                    block ;; label = @9
-                      local.get $8
-                      local.get $4
-                      i32.store
-                      local.get $10
-                      local.get $5
-                      i32.store
-                      local.get $4
-                      local.set $7
-                    end
-                  else
-                    call $fimport$8
-                  end
-                end
-              end
-            end
-            local.get $12
-            if ;; label = @5
-              block ;; label = @6
-                local.get $0
-                local.get $0
-                i32.load offset=28
-                local.tee $4
-                i32.const 2
-                i32.shl
-                i32.const 4480
-                i32.add
-                local.tee $5
-                i32.load
-                i32.eq
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $5
-                    local.get $7
-                    i32.store
-                    local.get $7
-                    i32.eqz
-                    if ;; label = @9
-                      block ;; label = @10
-                        i32.const 4180
-                        i32.const 4180
-                        i32.load
-                        i32.const 1
-                        local.get $4
-                        i32.shl
-                        i32.const -1
-                        i32.xor
-                        i32.and
-                        i32.store
-                        local.get $0
-                        local.set $3
-                        local.get $1
-                        local.set $2
-                        br 8 (;@2;)
-                      end
-                    end
-                  end
-                else
-                  block ;; label = @8
-                    local.get $12
-                    i32.const 4192
-                    i32.load
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$8
-                    end
-                    local.get $12
-                    i32.const 16
-                    i32.add
-                    local.tee $4
-                    i32.load
-                    local.get $0
-                    i32.eq
-                    if ;; label = @9
-                      local.get $4
-                      local.get $7
-                      i32.store
-                    else
-                      local.get $12
-                      local.get $7
-                      i32.store offset=20
-                    end
-                    local.get $7
-                    i32.eqz
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $0
-                        local.set $3
-                        local.get $1
-                        local.set $2
-                        br 8 (;@2;)
-                      end
-                    end
-                  end
-                end
-                local.get $7
-                i32.const 4192
-                i32.load
-                local.tee $5
-                i32.lt_u
-                if ;; label = @7
-                  call $fimport$8
-                end
-                local.get $7
-                local.get $12
-                i32.store offset=24
-                local.get $0
-                i32.const 16
-                i32.add
-                local.tee $8
-                i32.load
-                local.tee $4
-                if ;; label = @7
-                  local.get $4
-                  local.get $5
-                  i32.lt_u
-                  if ;; label = @8
-                    call $fimport$8
-                  else
-                    block ;; label = @9
-                      local.get $7
-                      local.get $4
-                      i32.store offset=16
-                      local.get $4
-                      local.get $7
-                      i32.store offset=24
-                    end
-                  end
-                end
-                local.get $8
-                i32.load offset=4
-                local.tee $4
-                if ;; label = @7
-                  local.get $4
-                  i32.const 4192
-                  i32.load
-                  i32.lt_u
-                  if ;; label = @8
-                    call $fimport$8
-                  else
-                    block ;; label = @9
-                      local.get $7
-                      local.get $4
-                      i32.store offset=20
-                      local.get $4
-                      local.get $7
-                      i32.store offset=24
-                      local.get $0
-                      local.set $3
-                      local.get $1
-                      local.set $2
-                    end
-                  end
-                else
-                  block ;; label = @8
-                    local.get $0
-                    local.set $3
-                    local.get $1
-                    local.set $2
-                  end
-                end
-              end
-            else
-              block ;; label = @6
-                local.get $0
-                local.set $3
-                local.get $1
-                local.set $2
-              end
-            end
-          end
-        end
-      end
-      local.get $3
-      local.get $6
-      i32.ge_u
-      if ;; label = @2
-        call $fimport$8
-      end
-      local.get $6
-      i32.const 4
-      i32.add
-      local.tee $1
-      i32.load
-      local.tee $0
-      i32.const 1
-      i32.and
-      i32.eqz
-      if ;; label = @2
-        call $fimport$8
-      end
-      local.get $0
-      i32.const 2
-      i32.and
-      if ;; label = @2
-        block ;; label = @3
-          local.get $1
-          local.get $0
-          i32.const -2
-          i32.and
-          i32.store
-          local.get $3
-          local.get $2
-          i32.const 1
-          i32.or
-          i32.store offset=4
-          local.get $3
-          local.get $2
-          i32.add
-          local.get $2
-          i32.store
-        end
-      else
-        block ;; label = @3
-          local.get $6
-          i32.const 4200
-          i32.load
-          i32.eq
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 4188
-              i32.const 4188
-              i32.load
-              local.get $2
-              i32.add
-              local.tee $0
-              i32.store
-              i32.const 4200
-              local.get $3
-              i32.store
-              local.get $3
-              local.get $0
-              i32.const 1
-              i32.or
-              i32.store offset=4
-              local.get $3
-              i32.const 4196
-              i32.load
-              i32.ne
-              if ;; label = @6
-                return
-              end
-              i32.const 4196
-              i32.const 0
-              i32.store
-              i32.const 4184
-              i32.const 0
-              i32.store
-              return
-            end
-          end
-          local.get $6
-          i32.const 4196
-          i32.load
-          i32.eq
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 4184
-              i32.const 4184
-              i32.load
-              local.get $2
-              i32.add
-              local.tee $0
-              i32.store
-              i32.const 4196
-              local.get $3
-              i32.store
-              local.get $3
-              local.get $0
-              i32.const 1
-              i32.or
-              i32.store offset=4
-              local.get $3
-              local.get $0
-              i32.add
-              local.get $0
-              i32.store
-              return
-            end
-          end
-          local.get $0
-          i32.const -8
-          i32.and
-          local.get $2
-          i32.add
-          local.set $5
-          local.get $0
-          i32.const 3
-          i32.shr_u
-          local.set $4
-          block $label$61 ;; label = @4
-            local.get $0
-            i32.const 256
-            i32.lt_u
-            if ;; label = @5
-              block ;; label = @6
-                local.get $6
-                i32.load offset=12
-                local.set $2
-                local.get $6
-                i32.load offset=8
-                local.tee $1
-                local.get $4
-                i32.const 1
-                i32.shl
-                i32.const 2
-                i32.shl
-                i32.const 4216
-                i32.add
-                local.tee $0
-                i32.ne
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $1
-                    i32.const 4192
-                    i32.load
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$8
-                    end
-                    local.get $1
-                    i32.load offset=12
-                    local.get $6
-                    i32.ne
-                    if ;; label = @9
-                      call $fimport$8
-                    end
-                  end
-                end
-                local.get $2
-                local.get $1
-                i32.eq
-                if ;; label = @7
-                  block ;; label = @8
-                    i32.const 4176
-                    i32.const 4176
-                    i32.load
-                    i32.const 1
-                    local.get $4
-                    i32.shl
-                    i32.const -1
-                    i32.xor
-                    i32.and
-                    i32.store
-                    br 4 (;@4;)
-                  end
-                end
-                local.get $2
-                local.get $0
-                i32.eq
-                if ;; label = @7
-                  local.get $2
-                  i32.const 8
-                  i32.add
-                  local.set $14
-                else
-                  block ;; label = @8
-                    local.get $2
-                    i32.const 4192
-                    i32.load
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$8
-                    end
-                    local.get $2
-                    i32.const 8
-                    i32.add
-                    local.tee $0
-                    i32.load
-                    local.get $6
-                    i32.eq
-                    if ;; label = @9
-                      local.get $0
-                      local.set $14
-                    else
-                      call $fimport$8
-                    end
-                  end
-                end
-                local.get $1
-                local.get $2
-                i32.store offset=12
-                local.get $14
-                local.get $1
-                i32.store
-              end
-            else
-              block ;; label = @6
-                local.get $6
-                i32.load offset=24
-                local.set $7
-                block $label$73 ;; label = @7
-                  local.get $6
-                  i32.load offset=12
-                  local.tee $0
-                  local.get $6
-                  i32.eq
-                  if ;; label = @8
-                    block ;; label = @9
-                      local.get $6
-                      i32.const 16
-                      i32.add
-                      local.tee $2
-                      i32.const 4
-                      i32.add
-                      local.tee $1
-                      i32.load
-                      local.tee $0
-                      if ;; label = @10
-                        local.get $1
-                        local.set $2
-                      else
-                        local.get $2
-                        i32.load
-                        local.tee $0
-                        i32.eqz
-                        if ;; label = @11
-                          block ;; label = @12
-                            i32.const 0
-                            local.set $9
-                            br 5 (;@7;)
-                          end
-                        end
-                      end
-                      loop $label$78 ;; label = @10
-                        local.get $0
-                        i32.const 20
-                        i32.add
-                        local.tee $1
-                        i32.load
-                        local.tee $4
-                        if ;; label = @11
-                          block ;; label = @12
-                            local.get $4
-                            local.set $0
-                            local.get $1
-                            local.set $2
-                            br 2 (;@10;)
-                          end
-                        end
-                        local.get $0
-                        i32.const 16
-                        i32.add
-                        local.tee $1
-                        i32.load
-                        local.tee $4
-                        if ;; label = @11
-                          block ;; label = @12
-                            local.get $4
-                            local.set $0
-                            local.get $1
-                            local.set $2
-                            br 2 (;@10;)
-                          end
-                        end
-                      end
-                      local.get $2
-                      i32.const 4192
-                      i32.load
-                      i32.lt_u
-                      if ;; label = @10
-                        call $fimport$8
-                      else
-                        block ;; label = @11
-                          local.get $2
-                          i32.const 0
-                          i32.store
-                          local.get $0
-                          local.set $9
-                        end
-                      end
-                    end
-                  else
-                    block ;; label = @9
-                      local.get $6
-                      i32.load offset=8
-                      local.tee $2
-                      i32.const 4192
-                      i32.load
-                      i32.lt_u
-                      if ;; label = @10
-                        call $fimport$8
-                      end
-                      local.get $2
-                      i32.const 12
-                      i32.add
-                      local.tee $1
-                      i32.load
-                      local.get $6
-                      i32.ne
-                      if ;; label = @10
-                        call $fimport$8
-                      end
-                      local.get $0
-                      i32.const 8
-                      i32.add
-                      local.tee $4
-                      i32.load
-                      local.get $6
-                      i32.eq
-                      if ;; label = @10
-                        block ;; label = @11
-                          local.get $1
-                          local.get $0
-                          i32.store
-                          local.get $4
-                          local.get $2
-                          i32.store
-                          local.get $0
-                          local.set $9
-                        end
-                      else
-                        call $fimport$8
-                      end
-                    end
-                  end
-                end
-                local.get $7
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $6
-                    local.get $6
-                    i32.load offset=28
-                    local.tee $0
-                    i32.const 2
-                    i32.shl
-                    i32.const 4480
-                    i32.add
-                    local.tee $2
-                    i32.load
-                    i32.eq
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $2
-                        local.get $9
-                        i32.store
-                        local.get $9
-                        i32.eqz
-                        if ;; label = @11
-                          block ;; label = @12
-                            i32.const 4180
-                            i32.const 4180
-                            i32.load
-                            i32.const 1
-                            local.get $0
-                            i32.shl
-                            i32.const -1
-                            i32.xor
-                            i32.and
-                            i32.store
-                            br 8 (;@4;)
-                          end
-                        end
-                      end
-                    else
-                      block ;; label = @10
-                        local.get $7
-                        i32.const 4192
-                        i32.load
-                        i32.lt_u
-                        if ;; label = @11
-                          call $fimport$8
-                        end
-                        local.get $7
-                        i32.const 16
-                        i32.add
-                        local.tee $0
-                        i32.load
-                        local.get $6
-                        i32.eq
-                        if ;; label = @11
-                          local.get $0
-                          local.get $9
-                          i32.store
-                        else
-                          local.get $7
-                          local.get $9
-                          i32.store offset=20
-                        end
-                        local.get $9
-                        i32.eqz
-                        br_if 6 (;@4;)
-                      end
-                    end
-                    local.get $9
-                    i32.const 4192
-                    i32.load
-                    local.tee $2
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$8
-                    end
-                    local.get $9
-                    local.get $7
-                    i32.store offset=24
-                    local.get $6
-                    i32.const 16
-                    i32.add
-                    local.tee $1
-                    i32.load
-                    local.tee $0
-                    if ;; label = @9
-                      local.get $0
-                      local.get $2
-                      i32.lt_u
-                      if ;; label = @10
-                        call $fimport$8
-                      else
-                        block ;; label = @11
-                          local.get $9
-                          local.get $0
-                          i32.store offset=16
-                          local.get $0
-                          local.get $9
-                          i32.store offset=24
-                        end
-                      end
-                    end
-                    local.get $1
-                    i32.load offset=4
-                    local.tee $0
-                    if ;; label = @9
-                      local.get $0
-                      i32.const 4192
-                      i32.load
-                      i32.lt_u
-                      if ;; label = @10
-                        call $fimport$8
-                      else
-                        block ;; label = @11
-                          local.get $9
-                          local.get $0
-                          i32.store offset=20
-                          local.get $0
-                          local.get $9
-                          i32.store offset=24
-                        end
-                      end
-                    end
-                  end
-                end
-              end
-            end
-          end
-          local.get $3
-          local.get $5
-          i32.const 1
-          i32.or
-          i32.store offset=4
-          local.get $3
-          local.get $5
-          i32.add
-          local.get $5
-          i32.store
-          local.get $3
-          i32.const 4196
-          i32.load
-          i32.eq
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 4184
-              local.get $5
-              i32.store
-              return
-            end
-          else
-            local.get $5
-            local.set $2
-          end
-        end
-      end
-      local.get $2
-      i32.const 3
-      i32.shr_u
-      local.set $1
-      local.get $2
-      i32.const 256
-      i32.lt_u
-      if ;; label = @2
-        block ;; label = @3
-          local.get $1
-          i32.const 1
-          i32.shl
-          i32.const 2
-          i32.shl
-          i32.const 4216
-          i32.add
-          local.set $0
-          i32.const 4176
-          i32.load
-          local.tee $2
-          i32.const 1
-          local.get $1
-          i32.shl
-          local.tee $1
-          i32.and
-          if ;; label = @4
-            local.get $0
-            i32.const 8
-            i32.add
-            local.tee $2
-            i32.load
-            local.tee $1
-            i32.const 4192
-            i32.load
-            i32.lt_u
-            if ;; label = @5
-              call $fimport$8
-            else
-              block ;; label = @6
-                local.get $2
-                local.set $15
-                local.get $1
-                local.set $13
-              end
-            end
-          else
-            block ;; label = @5
-              i32.const 4176
-              local.get $2
-              local.get $1
-              i32.or
-              i32.store
-              local.get $0
-              i32.const 8
-              i32.add
-              local.set $15
-              local.get $0
-              local.set $13
-            end
-          end
-          local.get $15
-          local.get $3
-          i32.store
-          local.get $13
-          local.get $3
-          i32.store offset=12
-          local.get $3
-          local.get $13
-          i32.store offset=8
-          local.get $3
-          local.get $0
-          i32.store offset=12
-          return
-        end
-      end
-      local.get $2
-      i32.const 8
-      i32.shr_u
-      local.tee $0
-      if (result i32) ;; label = @2
-        local.get $2
-        i32.const 16777215
-        i32.gt_u
-        if (result i32) ;; label = @3
-          i32.const 31
-        else
-          local.get $2
-          i32.const 14
-          local.get $0
-          local.get $0
-          i32.const 1048320
-          i32.add
-          i32.const 16
-          i32.shr_u
-          i32.const 8
-          i32.and
-          local.tee $0
-          i32.shl
-          local.tee $1
-          i32.const 520192
-          i32.add
-          i32.const 16
-          i32.shr_u
-          i32.const 4
-          i32.and
-          local.tee $4
-          local.get $0
-          i32.or
-          local.get $1
-          local.get $4
-          i32.shl
-          local.tee $0
-          i32.const 245760
-          i32.add
-          i32.const 16
-          i32.shr_u
-          i32.const 2
-          i32.and
-          local.tee $1
-          i32.or
-          i32.sub
-          local.get $0
-          local.get $1
-          i32.shl
-          i32.const 15
-          i32.shr_u
-          i32.add
-          local.tee $0
-          i32.const 7
-          i32.add
-          i32.shr_u
-          i32.const 1
-          i32.and
-          local.get $0
-          i32.const 1
-          i32.shl
-          i32.or
-        end
-      else
-        i32.const 0
-      end
-      local.tee $1
-      i32.const 2
-      i32.shl
-      i32.const 4480
-      i32.add
-      local.set $0
-      local.get $3
-      local.get $1
-      i32.store offset=28
-      local.get $3
-      i32.const 0
-      i32.store offset=20
-      local.get $3
-      i32.const 0
-      i32.store offset=16
-      block $label$113 ;; label = @2
-        i32.const 4180
-        i32.load
-        local.tee $4
-        i32.const 1
-        local.get $1
-        i32.shl
-        local.tee $5
-        i32.and
-        if ;; label = @3
-          block ;; label = @4
-            local.get $0
-            i32.load
-            local.set $0
-            i32.const 25
-            local.get $1
-            i32.const 1
-            i32.shr_u
-            i32.sub
-            local.set $4
-            local.get $2
-            local.get $1
-            i32.const 31
-            i32.eq
-            if (result i32) ;; label = @5
-              i32.const 0
-            else
-              local.get $4
-            end
-            i32.shl
-            local.set $1
-            block $label$117 ;; label = @5
-              block $label$118 ;; label = @6
-                block $label$119 ;; label = @7
-                  loop $label$120 ;; label = @8
-                    local.get $0
-                    i32.load offset=4
-                    i32.const -8
-                    i32.and
-                    local.get $2
-                    i32.eq
-                    br_if 2 (;@6;)
-                    local.get $1
-                    i32.const 1
-                    i32.shl
-                    local.set $4
-                    local.get $0
-                    i32.const 16
-                    i32.add
-                    local.get $1
-                    i32.const 31
-                    i32.shr_u
-                    i32.const 2
-                    i32.shl
-                    i32.add
-                    local.tee $1
-                    i32.load
-                    local.tee $5
-                    i32.eqz
-                    br_if 1 (;@7;)
-                    local.get $4
-                    local.set $1
-                    local.get $5
-                    local.set $0
-                    br 0 (;@8;)
-                  end
-                end
-                local.get $1
-                i32.const 4192
-                i32.load
-                i32.lt_u
-                if ;; label = @7
-                  call $fimport$8
-                else
-                  block ;; label = @8
-                    local.get $1
-                    local.get $3
-                    i32.store
-                    local.get $3
-                    local.get $0
-                    i32.store offset=24
-                    local.get $3
-                    local.get $3
-                    i32.store offset=12
-                    local.get $3
-                    local.get $3
-                    i32.store offset=8
-                    br 6 (;@2;)
-                  end
-                end
-                br 1 (;@5;)
-              end
-              local.get $0
-              i32.const 8
-              i32.add
-              local.tee $1
-              i32.load
-              local.tee $2
-              i32.const 4192
-              i32.load
-              local.tee $4
-              i32.ge_u
-              local.get $0
-              local.get $4
-              i32.ge_u
-              i32.and
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $2
-                  local.get $3
-                  i32.store offset=12
-                  local.get $1
-                  local.get $3
-                  i32.store
-                  local.get $3
-                  local.get $2
-                  i32.store offset=8
-                  local.get $3
-                  local.get $0
-                  i32.store offset=12
-                  local.get $3
-                  i32.const 0
-                  i32.store offset=24
-                end
-              else
-                call $fimport$8
-              end
-            end
-          end
-        else
-          block ;; label = @4
-            i32.const 4180
-            local.get $4
-            local.get $5
-            i32.or
-            i32.store
-            local.get $0
-            local.get $3
-            i32.store
-            local.get $3
-            local.get $0
-            i32.store offset=24
-            local.get $3
-            local.get $3
-            i32.store offset=12
-            local.get $3
-            local.get $3
-            i32.store offset=8
-          end
-        end
-      end
-      i32.const 4208
-      i32.const 4208
-      i32.load
-      i32.const -1
-      i32.add
-      local.tee $0
-      i32.store
-      local.get $0
-      if ;; label = @2
-        return
-      else
-        i32.const 4632
-        local.set $0
-      end
-      loop $label$128 ;; label = @2
-        local.get $0
-        i32.load
-        local.tee $2
-        i32.const 8
-        i32.add
-        local.set $0
-        local.get $2
-        br_if 0 (;@2;)
-      end
-      i32.const 4208
-      i32.const -1
-      i32.store
-    end
-  )
-  (func $39 (;52;) (type $2) (param $0 i32) (result i32)
-    (local $1 i32)
-    block $label$1 (result i32) ;; label = @1
-      local.get $0
-      i32.eqz
-      if ;; label = @2
-        i32.const 1
-        local.set $0
-      end
-      loop $label$3 ;; label = @2
-        block $label$4 ;; label = @3
-          local.get $0
-          call $37
-          local.tee $1
-          if ;; label = @4
-            block ;; label = @5
-              local.get $1
-              local.set $0
-              br 2 (;@3;)
-            end
-          end
-          call $43
-          local.tee $1
-          if ;; label = @4
-            block ;; label = @5
-              local.get $1
-              i32.const 0
-              i32.and
-              i32.const 8
-              i32.add
-              call_indirect (type $1)
-              br 3 (;@2;)
-            end
-          else
-            i32.const 0
-            local.set $0
-          end
-        end
-      end
-      local.get $0
-    end
-  )
-  (func $40 (;53;) (type $2) (param $0 i32) (result i32)
-    local.get $0
-    call $39
-  )
-  (func $41 (;54;) (type $3) (param $0 i32)
-    local.get $0
-    call $38
-  )
-  (func $42 (;55;) (type $3) (param $0 i32)
-    local.get $0
-    call $41
-  )
-  (func $43 (;56;) (type $4) (result i32)
-    (local $0 i32)
-    block $label$1 (result i32) ;; label = @1
-      i32.const 4672
-      i32.const 4672
-      i32.load
-      local.tee $0
-      i32.const 0
-      i32.add
-      i32.store
-      local.get $0
-    end
-  )
-  (func $44 (;57;) (type $1)
-    nop
-  )
-  (func $45 (;58;) (type $2) (param $0 i32) (result i32)
-    (local $1 i32) (local $2 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$0
-      i32.load
-      local.tee $2
-      local.get $0
-      i32.const 15
-      i32.add
-      i32.const -16
-      i32.and
-      local.tee $0
-      i32.add
-      local.set $1
-      local.get $0
-      i32.const 0
-      i32.gt_s
-      local.get $1
-      local.get $2
-      i32.lt_s
-      i32.and
-      local.get $1
-      i32.const 0
-      i32.lt_s
-      i32.or
-      if ;; label = @2
-        block ;; label = @3
-          call $fimport$6
-          drop
-          i32.const 12
-          call $fimport$11
-          i32.const -1
-          return
-        end
-      end
-      global.get $global$0
-      local.get $1
-      i32.store
-      local.get $1
-      call $fimport$5
-      i32.gt_s
-      if ;; label = @2
-        call $fimport$4
-        i32.eqz
-        if ;; label = @3
-          block ;; label = @4
-            i32.const 12
-            call $fimport$11
-            global.get $global$0
-            local.get $2
-            i32.store
-            i32.const -1
-            return
-          end
-        end
-      end
-      local.get $2
-    end
-  )
-  (func $46 (;59;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32) (local $4 i32) (local $5 i32)
-    block $label$1 (result i32) ;; label = @1
-      local.get $0
-      local.get $2
-      i32.add
-      local.set $4
-      local.get $2
-      i32.const 20
-      i32.ge_s
-      if ;; label = @2
-        block ;; label = @3
-          local.get $1
-          i32.const 255
-          i32.and
-          local.set $1
-          local.get $0
-          i32.const 3
-          i32.and
-          local.tee $3
-          if ;; label = @4
-            block ;; label = @5
-              local.get $0
-              i32.const 4
-              i32.add
-              local.get $3
-              i32.sub
-              local.set $3
-              loop $label$4 ;; label = @6
-                local.get $0
-                local.get $3
-                i32.lt_s
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $0
-                    local.get $1
-                    i32.store8
-                    local.get $0
-                    i32.const 1
-                    i32.add
-                    local.set $0
-                    br 2 (;@6;)
-                  end
-                end
-              end
-            end
-          end
-          local.get $1
-          local.get $1
-          i32.const 8
-          i32.shl
-          i32.or
-          local.get $1
-          i32.const 16
-          i32.shl
-          i32.or
-          local.get $1
-          i32.const 24
-          i32.shl
-          i32.or
-          local.set $3
-          local.get $4
-          i32.const -4
-          i32.and
-          local.set $5
-          loop $label$6 ;; label = @4
-            local.get $0
-            local.get $5
-            i32.lt_s
-            if ;; label = @5
-              block ;; label = @6
-                local.get $0
-                local.get $3
-                i32.store
-                local.get $0
-                i32.const 4
-                i32.add
-                local.set $0
-                br 2 (;@4;)
-              end
-            end
-          end
-        end
-      end
-      loop $label$8 ;; label = @2
-        local.get $0
-        local.get $4
-        i32.lt_s
-        if ;; label = @3
-          block ;; label = @4
-            local.get $0
-            local.get $1
-            i32.store8
-            local.get $0
-            i32.const 1
-            i32.add
-            local.set $0
-            br 2 (;@2;)
-          end
-        end
-      end
-      local.get $0
-      local.get $2
-      i32.sub
-    end
-  )
-  (func $47 (;60;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32)
-    block $label$1 (result i32) ;; label = @1
-      local.get $2
-      i32.const 4096
-      i32.ge_s
-      if ;; label = @2
-        local.get $0
-        local.get $1
-        local.get $2
-        call $fimport$12
-        return
-      end
-      local.get $0
-      local.set $3
-      local.get $0
-      i32.const 3
-      i32.and
-      local.get $1
-      i32.const 3
-      i32.and
-      i32.eq
-      if ;; label = @2
-        block ;; label = @3
-          loop $label$4 ;; label = @4
-            local.get $0
-            i32.const 3
-            i32.and
-            if ;; label = @5
-              block ;; label = @6
-                local.get $2
-                i32.eqz
-                if ;; label = @7
-                  local.get $3
-                  return
-                end
-                local.get $0
-                local.get $1
-                i32.load8_s
-                i32.store8
-                local.get $0
-                i32.const 1
-                i32.add
-                local.set $0
-                local.get $1
-                i32.const 1
-                i32.add
-                local.set $1
-                local.get $2
-                i32.const 1
-                i32.sub
-                local.set $2
-                br 2 (;@4;)
-              end
-            end
-          end
-          loop $label$7 ;; label = @4
-            local.get $2
-            i32.const 4
-            i32.ge_s
-            if ;; label = @5
-              block ;; label = @6
-                local.get $0
-                local.get $1
-                i32.load
-                i32.store
-                local.get $0
-                i32.const 4
-                i32.add
-                local.set $0
-                local.get $1
-                i32.const 4
-                i32.add
-                local.set $1
-                local.get $2
-                i32.const 4
-                i32.sub
-                local.set $2
-                br 2 (;@4;)
-              end
-            end
-          end
-        end
-      end
-      loop $label$9 ;; label = @2
-        local.get $2
-        i32.const 0
-        i32.gt_s
-        if ;; label = @3
-          block ;; label = @4
-            local.get $0
-            local.get $1
-            i32.load8_s
-            i32.store8
-            local.get $0
-            i32.const 1
-            i32.add
-            local.set $0
-            local.get $1
-            i32.const 1
-            i32.add
-            local.set $1
-            local.get $2
-            i32.const 1
-            i32.sub
-            local.set $2
-            br 2 (;@2;)
-          end
-        end
-      end
-      local.get $3
-    end
-  )
-  (func $48 (;61;) (type $4) (result i32)
-    i32.const 0
-  )
-  (func $49 (;62;) (type $6) (param $0 i32) (param $1 i32) (result i32)
-    local.get $1
-    local.get $0
-    i32.const 1
-    i32.and
-    i32.const 0
-    i32.add
-    call_indirect (type $2)
-  )
-  (func $50 (;63;) (type $12) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32)
-    local.get $1
-    local.get $2
-    local.get $3
-    local.get $0
-    i32.const 3
-    i32.and
-    i32.const 2
-    i32.add
-    call_indirect (type $0)
-  )
-  (func $51 (;64;) (type $5) (param $0 i32) (param $1 i32)
-    local.get $1
-    local.get $0
-    i32.const 1
-    i32.and
-    i32.const 6
-    i32.add
-    call_indirect (type $3)
-  )
-  (func $52 (;65;) (type $3) (param $0 i32)
-    local.get $0
-    i32.const 0
-    i32.and
-    i32.const 8
-    i32.add
-    call_indirect (type $1)
-  )
-  (func $53 (;66;) (type $2) (param $0 i32) (result i32)
-    block $label$1 (result i32) ;; label = @1
-      i32.const 0
-      call $fimport$3
-      i32.const 0
-    end
-  )
-  (func $54 (;67;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    block $label$1 (result i32) ;; label = @1
-      i32.const 1
-      call $fimport$3
-      i32.const 0
-    end
-  )
-  (func $55 (;68;) (type $3) (param $0 i32)
-    i32.const 2
-    call $fimport$3
-  )
-  (func $56 (;69;) (type $1)
-    i32.const 3
-    call $fimport$3
-  )
-  (global $global$0 (;5;) (mut i32) global.get $gimport$0)
-  (global $global$1 (;6;) (mut i32) global.get $gimport$1)
-  (global $global$2 (;7;) (mut i32) global.get $gimport$2)
-  (global $global$3 (;8;) (mut i32) i32.const 0)
-  (global $global$4 (;9;) (mut i32) i32.const 0)
-  (global $global$5 (;10;) (mut i32) i32.const 0)
-  (export "_sbrk" (func $45))
-  (export "_free" (func $38))
-  (export "_main" (func $7))
-  (export "_pthread_self" (func $48))
-  (export "_memset" (func $46))
-  (export "_malloc" (func $37))
-  (export "_memcpy" (func $47))
-  (export "___errno_location" (func $12))
-  (export "runPostSets" (func $44))
-  (export "stackAlloc" (func $0))
-  (export "stackSave" (func $1))
-  (export "stackRestore" (func $2))
-  (export "establishStackSpace" (func $3))
-  (export "setThrew" (func $4))
-  (export "setTempRet0" (func $5))
-  (export "getTempRet0" (func $6))
-  (export "dynCall_ii" (func $49))
-  (export "dynCall_iiii" (func $50))
-  (export "dynCall_vi" (func $51))
-  (export "dynCall_v" (func $52))
-  (elem (;0;) (global.get $gimport$19) func $53 $9 $54 $14 $10 $15 $55 $16 $56)
-  (data (;0;) (i32.const 1024) "&\02\00\00a\00\00\00q=\8a>\00\00\00\00c\00\00\00\8f\c2\f5=\00\00\00\00g\00\00\00\8f\c2\f5=\00\00\00\00t\00\00\00q=\8a>\00\00\00\00B\00\00\00\0a\d7\a3<\00\00\00\00D\00\00\00\0a\d7\a3<\00\00\00\00H\00\00\00\0a\d7\a3<\00\00\00\00K\00\00\00\0a\d7\a3<\00\00\00\00M\00\00\00\0a\d7\a3<\00\00\00\00N\00\00\00\0a\d7\a3<\00\00\00\00R\00\00\00\0a\d7\a3<\00\00\00\00S\00\00\00\0a\d7\a3<\00\00\00\00V\00\00\00\0a\d7\a3<\00\00\00\00W\00\00\00\0a\d7\a3<\00\00\00\00Y\00\00\00\0a\d7\a3<")
-  (data (;1;) (i32.const 1220) "a\00\00\00\e9\1c\9b>\00\00\00\00c\00\00\00r\bdJ>\00\00\00\00g\00\00\00\d7IJ>\00\00\00\00t\00\00\00r_\9a>")
-  (data (;2;) (i32.const 1280) "\04\05\00\00\05")
-  (data (;3;) (i32.const 1296) "\01")
-  (data (;4;) (i32.const 1320) "\01\00\00\00\02\00\00\00L\12\00\00\00\04")
-  (data (;5;) (i32.const 1344) "\01")
-  (data (;6;) (i32.const 1359) "\0a\ff\ff\ff\ff")
-  (data (;7;) (i32.const 1396) "*\00\00\00error: %d\0a\00GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA\00\11\00\0a\00\11\11\11\00\00\00\00\05\00\00\00\00\00\00\09\00\00\00\00\0b")
-  (data (;8;) (i32.const 1731) "\11\00\0f\0a\11\11\11\03\0a\07\00\01\13\09\0b\0b\00\00\09\06\0b\00\00\0b\00\06\11\00\00\00\11\11\11")
-  (data (;9;) (i32.const 1780) "\0b")
-  (data (;10;) (i32.const 1789) "\11\00\0a\0a\11\11\11\00\0a\00\00\02\00\09\0b\00\00\00\09\00\0b\00\00\0b")
-  (data (;11;) (i32.const 1838) "\0c")
-  (data (;12;) (i32.const 1850) "\0c\00\00\00\00\0c\00\00\00\00\09\0c\00\00\00\00\00\0c\00\00\0c")
-  (data (;13;) (i32.const 1896) "\0e")
-  (data (;14;) (i32.const 1908) "\0d\00\00\00\04\0d\00\00\00\00\09\0e\00\00\00\00\00\0e\00\00\0e")
-  (data (;15;) (i32.const 1954) "\10")
-  (data (;16;) (i32.const 1966) "\0f\00\00\00\00\0f\00\00\00\00\09\10\00\00\00\00\00\10\00\00\10\00\00\12\00\00\00\12\12\12")
-  (data (;17;) (i32.const 2021) "\12\00\00\00\12\12\12\00\00\00\00\00\00\09")
-  (data (;18;) (i32.const 2070) "\0b")
-  (data (;19;) (i32.const 2082) "\0a\00\00\00\00\0a\00\00\00\00\09\0b\00\00\00\00\00\0b\00\00\0b")
-  (data (;20;) (i32.const 2128) "\0c")
-  (data (;21;) (i32.const 2140) "\0c\00\00\00\00\0c\00\00\00\00\09\0c\00\00\00\00\00\0c\00\00\0c\00\000123456789ABCDEF-+   0X0x\00(null)\00-0X+0X 0X-0x+0x 0x\00inf\00INF\00nan\00NAN\00.\00T!\22\19\0d\01\02\03\11K\1c\0c\10\04\0b\1d\12\1e'hnopqb \05\06\0f\13\14\15\1a\08\16\07($\17\18\09\0a\0e\1b\1f%#\83\82}&*+<=>?CGJMXYZ[\5c]^_`acdefgijklrstyz{|\00Illegal byte sequence\00Domain error\00Result not representable\00Not a tty\00Permission denied\00Operation not permitted\00No such file or directory\00No such process\00File exists\00Value too large for data type\00No space left on device\00Out of memory\00Resource busy\00Interrupted system call\00Resource temporarily unavailable\00Invalid seek\00Cross-device link\00Read-only file system\00Directory not empty\00Connection reset by peer\00Operation timed out\00Connection refused\00Host is down\00Host is unreachable\00Address in use\00Broken pipe\00I/O error\00No such device or address\00Block device required\00No such device\00Not a directory\00Is a directory\00Text file busy\00Exec format error\00Invalid argument\00Argument list too long\00Symbolic link loop\00Filename too long\00Too many open files in system\00No file descriptors available\00Bad file descriptor\00No child process\00Bad address\00File too large\00Too many links\00No locks available\00Resource deadlock would occur\00State not recoverable\00Previous owner died\00Operation canceled\00Function not implemented\00No message of desired type\00Identifier removed\00Device not a stream\00No data available\00Device timeout\00Out of streams resources\00Link has been severed\00Protocol error\00Bad message\00File descriptor in bad state\00Not a socket\00Destination address required\00Message too large\00Protocol wrong type for socket\00Protocol not available\00Protocol not supported\00Socket type not supported\00Not supported\00Protocol family not supported\00Address family not supported by protocol\00Address not available\00Network is down\00Network unreachable\00Connection reset by network\00Connection aborted\00No buffer space available\00Socket is connected\00Socket not connected\00Cannot send after socket shutdown\00Operation already in progress\00Operation in progress\00Stale file handle\00Remote I/O error\00Quota exceeded\00No medium found\00Wrong medium type\00No error information")
-)
\ No newline at end of file
diff --git a/cranelift/wasm/wasmtests/embenchen_ifs.wat b/cranelift/wasm/wasmtests/embenchen_ifs.wat
deleted file mode 100644
index dc466513c7e6..000000000000
--- a/cranelift/wasm/wasmtests/embenchen_ifs.wat
+++ /dev/null
@@ -1,11505 +0,0 @@
-(module
-  (type $0 (;0;) (func (param i32 i32 i32) (result i32)))
-  (type $1 (;1;) (func (param i32) (result i32)))
-  (type $2 (;2;) (func (param i32)))
-  (type $3 (;3;) (func (result i32)))
-  (type $4 (;4;) (func (param i32 i32) (result i32)))
-  (type $5 (;5;) (func (param i32 i32)))
-  (type $6 (;6;) (func))
-  (type $7 (;7;) (func (param i32 i32 i32 i32 i32) (result i32)))
-  (type $8 (;8;) (func (param i32 i32 i32)))
-  (type $9 (;9;) (func (param i64 i32) (result i32)))
-  (type $10 (;10;) (func (param i32 i32 i32 i32 i32)))
-  (type $11 (;11;) (func (param f64 i32) (result f64)))
-  (type $12 (;12;) (func (param i32 i32 i32 i32) (result i32)))
-  (import "env" "memory" (memory $16 (;0;) 2048 2048))
-  (import "env" "table" (table $timport$17 (;0;) 8 8 funcref))
-  (import "env" "DYNAMICTOP_PTR" (global $gimport$0 (;0;) i32))
-  (import "env" "STACKTOP" (global $gimport$1 (;1;) i32))
-  (import "env" "STACK_MAX" (global $gimport$2 (;2;) i32))
-  (import "env" "memoryBase" (global $gimport$18 (;3;) i32))
-  (import "env" "tableBase" (global $gimport$19 (;4;) i32))
-  (import "env" "abort" (func $fimport$3 (;0;) (type $2)))
-  (import "env" "enlargeMemory" (func $fimport$4 (;1;) (type $3)))
-  (import "env" "getTotalMemory" (func $fimport$5 (;2;) (type $3)))
-  (import "env" "abortOnCannotGrowMemory" (func $fimport$6 (;3;) (type $3)))
-  (import "env" "_pthread_cleanup_pop" (func $fimport$7 (;4;) (type $2)))
-  (import "env" "___syscall6" (func $fimport$8 (;5;) (type $4)))
-  (import "env" "_pthread_cleanup_push" (func $fimport$9 (;6;) (type $5)))
-  (import "env" "_abort" (func $fimport$10 (;7;) (type $6)))
-  (import "env" "___setErrNo" (func $fimport$11 (;8;) (type $2)))
-  (import "env" "_emscripten_memcpy_big" (func $fimport$12 (;9;) (type $0)))
-  (import "env" "___syscall54" (func $fimport$13 (;10;) (type $4)))
-  (import "env" "___syscall140" (func $fimport$14 (;11;) (type $4)))
-  (import "env" "___syscall146" (func $fimport$15 (;12;) (type $4)))
-  (func $0 (;13;) (type $1) (param $0 i32) (result i32)
-    (local $1 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $1
-      global.get $global$1
-      local.get $0
-      i32.add
-      global.set $global$1
-      global.get $global$1
-      i32.const 15
-      i32.add
-      i32.const -16
-      i32.and
-      global.set $global$1
-      local.get $1
-    end
-  )
-  (func $1 (;14;) (type $3) (result i32)
-    global.get $global$1
-  )
-  (func $2 (;15;) (type $2) (param $0 i32)
-    local.get $0
-    global.set $global$1
-  )
-  (func $3 (;16;) (type $5) (param $0 i32) (param $1 i32)
-    block $label$1 ;; label = @1
-      local.get $0
-      global.set $global$1
-      local.get $1
-      global.set $global$2
-    end
-  )
-  (func $4 (;17;) (type $5) (param $0 i32) (param $1 i32)
-    global.get $global$3
-    i32.eqz
-    if ;; label = @1
-      block ;; label = @2
-        local.get $0
-        global.set $global$3
-        local.get $1
-        global.set $global$4
-      end
-    end
-  )
-  (func $5 (;18;) (type $2) (param $0 i32)
-    local.get $0
-    global.set $global$5
-  )
-  (func $6 (;19;) (type $3) (result i32)
-    global.get $global$5
-  )
-  (func $7 (;20;) (type $3) (result i32)
-    (local $0 i32)
-    block $label$1 (result i32) ;; label = @1
-      i32.const 3584
-      i32.const 3584
-      i32.load
-      local.tee $0
-      i32.const 1
-      i32.add
-      i32.store
-      local.get $0
-      i32.const 16384
-      i32.and
-    end
-  )
-  (func $8 (;21;) (type $4) (param $0 i32) (param $1 i32) (result i32)
-    (local $2 i32) (local $3 i32) (local $4 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $4
-      global.get $global$1
-      i32.const 16
-      i32.add
-      global.set $global$1
-      local.get $4
-      local.set $2
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          local.get $0
-          i32.const 1
-          i32.le_s
-          br_if 0 (;@3;)
-          block $label$4 ;; label = @4
-            block $label$5 ;; label = @5
-              block $label$6 ;; label = @6
-                block $label$7 ;; label = @7
-                  block $label$8 ;; label = @8
-                    block $label$9 ;; label = @9
-                      block $label$10 ;; label = @10
-                        local.get $1
-                        i32.load offset=4
-                        i32.load8_s
-                        local.tee $0
-                        i32.const 48
-                        i32.sub
-                        br_table 5 (;@5;) 0 (;@10;) 2 (;@8;) 1 (;@9;) 3 (;@7;) 4 (;@6;) 6 (;@4;)
-                      end
-                      i32.const 75
-                      local.set $3
-                      br 7 (;@2;)
-                    end
-                    br 5 (;@3;)
-                  end
-                  i32.const 625
-                  local.set $3
-                  br 5 (;@2;)
-                end
-                i32.const 6250
-                local.set $3
-                br 4 (;@2;)
-              end
-              i32.const 12500
-              local.set $3
-              br 3 (;@2;)
-            end
-            local.get $4
-            global.set $global$1
-            i32.const 0
-            return
-          end
-          local.get $2
-          local.get $0
-          i32.const -48
-          i32.add
-          i32.store
-          i32.const 1140
-          local.get $2
-          call $34
-          drop
-          local.get $4
-          global.set $global$1
-          i32.const -1
-          return
-        end
-        i32.const 1250
-        local.set $3
-      end
-      i32.const 0
-      local.set $1
-      i32.const 0
-      local.set $0
-      loop $label$11 ;; label = @2
-        i32.const 0
-        local.set $2
-        loop $label$12 ;; label = @3
-          block $label$13 (result i32) ;; label = @4
-            block $label$14 ;; label = @5
-              call $7
-              i32.eqz
-              br_if 0 (;@5;)
-              call $7
-              i32.eqz
-              br_if 0 (;@5;)
-              local.get $0
-              i32.const 17
-              i32.add
-              br 1 (;@4;)
-            end
-            local.get $0
-            i32.const 19
-            i32.add
-          end
-          local.set $0
-          block $label$15 ;; label = @4
-            block $label$16 ;; label = @5
-              call $7
-              br_if 0 (;@5;)
-              call $7
-              br_if 0 (;@5;)
-              br 1 (;@4;)
-            end
-            local.get $0
-            i32.const 23
-            i32.add
-            local.set $0
-          end
-          local.get $2
-          i32.const 1
-          i32.add
-          local.tee $2
-          local.get $3
-          i32.lt_s
-          br_if 0 (;@3;)
-        end
-        local.get $1
-        i32.const 1
-        i32.add
-        local.tee $1
-        i32.const 27000
-        i32.ne
-        br_if 0 (;@2;)
-      end
-      i32.const 1152
-      call $35
-      drop
-      local.get $4
-      global.set $global$1
-      local.get $0
-    end
-  )
-  (func $9 (;22;) (type $1) (param $0 i32) (result i32)
-    (local $1 i32) (local $2 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $1
-      global.get $global$1
-      i32.const 16
-      i32.add
-      global.set $global$1
-      local.get $1
-      local.tee $2
-      local.get $0
-      i32.load offset=60
-      i32.store
-      i32.const 6
-      local.get $2
-      call $fimport$8
-      call $11
-      local.set $0
-      local.get $1
-      global.set $global$1
-      local.get $0
-    end
-  )
-  (func $10 (;23;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32) (local $4 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $4
-      global.get $global$1
-      i32.const 32
-      i32.add
-      global.set $global$1
-      local.get $4
-      local.tee $3
-      local.get $0
-      i32.load offset=60
-      i32.store
-      local.get $3
-      i32.const 0
-      i32.store offset=4
-      local.get $3
-      local.get $1
-      i32.store offset=8
-      local.get $3
-      local.get $4
-      i32.const 20
-      i32.add
-      local.tee $0
-      i32.store offset=12
-      local.get $3
-      local.get $2
-      i32.store offset=16
-      i32.const 140
-      local.get $3
-      call $fimport$14
-      call $11
-      i32.const 0
-      i32.lt_s
-      if (result i32) ;; label = @2
-        block (result i32) ;; label = @3
-          local.get $0
-          i32.const -1
-          i32.store
-          i32.const -1
-        end
-      else
-        local.get $0
-        i32.load
-      end
-      local.set $0
-      local.get $4
-      global.set $global$1
-      local.get $0
-    end
-  )
-  (func $11 (;24;) (type $1) (param $0 i32) (result i32)
-    local.get $0
-    i32.const -4096
-    i32.gt_u
-    if (result i32) ;; label = @1
-      block (result i32) ;; label = @2
-        call $12
-        i32.const 0
-        local.get $0
-        i32.sub
-        i32.store
-        i32.const -1
-      end
-    else
-      local.get $0
-    end
-  )
-  (func $12 (;25;) (type $3) (result i32)
-    i32.const 3632
-  )
-  (func $13 (;26;) (type $2) (param $0 i32)
-    nop
-  )
-  (func $14 (;27;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32) (local $4 i32) (local $5 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $4
-      global.get $global$1
-      i32.const 80
-      i32.add
-      global.set $global$1
-      local.get $4
-      local.set $3
-      local.get $4
-      i32.const 12
-      i32.add
-      local.set $5
-      local.get $0
-      i32.const 3
-      i32.store offset=36
-      local.get $0
-      i32.load
-      i32.const 64
-      i32.and
-      i32.eqz
-      if ;; label = @2
-        block ;; label = @3
-          local.get $3
-          local.get $0
-          i32.load offset=60
-          i32.store
-          local.get $3
-          i32.const 21505
-          i32.store offset=4
-          local.get $3
-          local.get $5
-          i32.store offset=8
-          i32.const 54
-          local.get $3
-          call $fimport$13
-          if ;; label = @4
-            local.get $0
-            i32.const -1
-            i32.store8 offset=75
-          end
-        end
-      end
-      local.get $0
-      local.get $1
-      local.get $2
-      call $15
-      local.set $0
-      local.get $4
-      global.set $global$1
-      local.get $0
-    end
-  )
-  (func $15 (;28;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $8
-      global.get $global$1
-      i32.const 48
-      i32.add
-      global.set $global$1
-      local.get $8
-      i32.const 16
-      i32.add
-      local.set $9
-      local.get $8
-      local.set $10
-      local.get $8
-      i32.const 32
-      i32.add
-      local.tee $3
-      local.get $0
-      i32.const 28
-      i32.add
-      local.tee $6
-      i32.load
-      local.tee $4
-      i32.store
-      local.get $3
-      local.get $0
-      i32.const 20
-      i32.add
-      local.tee $11
-      i32.load
-      local.get $4
-      i32.sub
-      local.tee $5
-      i32.store offset=4
-      local.get $3
-      local.get $1
-      i32.store offset=8
-      local.get $3
-      local.get $2
-      i32.store offset=12
-      local.get $0
-      i32.const 60
-      i32.add
-      local.set $13
-      local.get $0
-      i32.const 44
-      i32.add
-      local.set $14
-      local.get $3
-      local.set $1
-      i32.const 2
-      local.set $4
-      local.get $5
-      local.get $2
-      i32.add
-      local.set $12
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          block $label$4 ;; label = @4
-            loop $label$5 ;; label = @5
-              i32.const 3588
-              i32.load
-              if ;; label = @6
-                block ;; label = @7
-                  i32.const 1
-                  local.get $0
-                  call $fimport$9
-                  local.get $10
-                  local.get $13
-                  i32.load
-                  i32.store
-                  local.get $10
-                  local.get $1
-                  i32.store offset=4
-                  local.get $10
-                  local.get $4
-                  i32.store offset=8
-                  i32.const 146
-                  local.get $10
-                  call $fimport$15
-                  call $11
-                  local.set $3
-                  i32.const 0
-                  call $fimport$7
-                end
-              else
-                block ;; label = @7
-                  local.get $9
-                  local.get $13
-                  i32.load
-                  i32.store
-                  local.get $9
-                  local.get $1
-                  i32.store offset=4
-                  local.get $9
-                  local.get $4
-                  i32.store offset=8
-                  i32.const 146
-                  local.get $9
-                  call $fimport$15
-                  call $11
-                  local.set $3
-                end
-              end
-              local.get $12
-              local.get $3
-              i32.eq
-              br_if 1 (;@4;)
-              local.get $3
-              i32.const 0
-              i32.lt_s
-              br_if 2 (;@3;)
-              local.get $3
-              local.get $1
-              i32.load offset=4
-              local.tee $5
-              i32.gt_u
-              if (result i32) ;; label = @6
-                block (result i32) ;; label = @7
-                  local.get $6
-                  local.get $14
-                  i32.load
-                  local.tee $7
-                  i32.store
-                  local.get $11
-                  local.get $7
-                  i32.store
-                  local.get $1
-                  i32.load offset=12
-                  local.set $7
-                  local.get $1
-                  i32.const 8
-                  i32.add
-                  local.set $1
-                  local.get $4
-                  i32.const -1
-                  i32.add
-                  local.set $4
-                  local.get $3
-                  local.get $5
-                  i32.sub
-                end
-              else
-                local.get $4
-                i32.const 2
-                i32.eq
-                if (result i32) ;; label = @7
-                  block (result i32) ;; label = @8
-                    local.get $6
-                    local.get $6
-                    i32.load
-                    local.get $3
-                    i32.add
-                    i32.store
-                    local.get $5
-                    local.set $7
-                    i32.const 2
-                    local.set $4
-                    local.get $3
-                  end
-                else
-                  block (result i32) ;; label = @8
-                    local.get $5
-                    local.set $7
-                    local.get $3
-                  end
-                end
-              end
-              local.set $5
-              local.get $1
-              local.get $1
-              i32.load
-              local.get $5
-              i32.add
-              i32.store
-              local.get $1
-              local.get $7
-              local.get $5
-              i32.sub
-              i32.store offset=4
-              local.get $12
-              local.get $3
-              i32.sub
-              local.set $12
-              br 0 (;@5;)
-            end
-          end
-          local.get $0
-          local.get $14
-          i32.load
-          local.tee $1
-          local.get $0
-          i32.load offset=48
-          i32.add
-          i32.store offset=16
-          local.get $6
-          local.get $1
-          i32.store
-          local.get $11
-          local.get $1
-          i32.store
-          br 1 (;@2;)
-        end
-        local.get $0
-        i32.const 0
-        i32.store offset=16
-        local.get $6
-        i32.const 0
-        i32.store
-        local.get $11
-        i32.const 0
-        i32.store
-        local.get $0
-        local.get $0
-        i32.load
-        i32.const 32
-        i32.or
-        i32.store
-        local.get $4
-        i32.const 2
-        i32.eq
-        if (result i32) ;; label = @3
-          i32.const 0
-        else
-          local.get $2
-          local.get $1
-          i32.load offset=4
-          i32.sub
-        end
-        local.set $2
-      end
-      local.get $8
-      global.set $global$1
-      local.get $2
-    end
-  )
-  (func $16 (;29;) (type $2) (param $0 i32)
-    local.get $0
-    i32.load offset=68
-    i32.eqz
-    if ;; label = @1
-      local.get $0
-      call $13
-    end
-  )
-  (func $17 (;30;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32) (local $4 i32) (local $5 i32)
-    block $label$1 (result i32) ;; label = @1
-      local.get $1
-      i32.const 255
-      i32.and
-      local.set $5
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          block $label$4 ;; label = @4
-            local.get $2
-            i32.const 0
-            i32.ne
-            local.tee $4
-            local.get $0
-            i32.const 3
-            i32.and
-            i32.const 0
-            i32.ne
-            i32.and
-            if ;; label = @5
-              block ;; label = @6
-                local.get $1
-                i32.const 255
-                i32.and
-                local.set $4
-                local.get $2
-                local.set $3
-                local.get $0
-                local.set $2
-                loop $label$6 ;; label = @7
-                  local.get $2
-                  i32.load8_s
-                  local.get $4
-                  i32.const 24
-                  i32.shl
-                  i32.const 24
-                  i32.shr_s
-                  i32.eq
-                  if ;; label = @8
-                    block ;; label = @9
-                      local.get $3
-                      local.set $0
-                      br 6 (;@3;)
-                    end
-                  end
-                  local.get $3
-                  i32.const -1
-                  i32.add
-                  local.tee $3
-                  i32.const 0
-                  i32.ne
-                  local.tee $0
-                  local.get $2
-                  i32.const 1
-                  i32.add
-                  local.tee $2
-                  i32.const 3
-                  i32.and
-                  i32.const 0
-                  i32.ne
-                  i32.and
-                  br_if 0 (;@7;)
-                  br 3 (;@4;)
-                end
-              end
-            else
-              block ;; label = @6
-                local.get $2
-                local.set $3
-                local.get $0
-                local.set $2
-                local.get $4
-                local.set $0
-              end
-            end
-          end
-          local.get $0
-          if ;; label = @4
-            block ;; label = @5
-              local.get $3
-              local.set $0
-              br 2 (;@3;)
-            end
-          else
-            i32.const 0
-            local.set $0
-          end
-          br 1 (;@2;)
-        end
-        local.get $2
-        i32.load8_s
-        local.get $1
-        i32.const 255
-        i32.and
-        local.tee $1
-        i32.const 24
-        i32.shl
-        i32.const 24
-        i32.shr_s
-        i32.ne
-        if ;; label = @3
-          block ;; label = @4
-            local.get $5
-            i32.const 16843009
-            i32.mul
-            local.set $3
-            block $label$12 ;; label = @5
-              block $label$13 ;; label = @6
-                local.get $0
-                i32.const 3
-                i32.le_u
-                br_if 0 (;@6;)
-                loop $label$14 ;; label = @7
-                  local.get $2
-                  i32.load
-                  local.get $3
-                  i32.xor
-                  local.tee $4
-                  i32.const -2139062144
-                  i32.and
-                  i32.const -2139062144
-                  i32.xor
-                  local.get $4
-                  i32.const -16843009
-                  i32.add
-                  i32.and
-                  i32.eqz
-                  if ;; label = @8
-                    block ;; label = @9
-                      local.get $2
-                      i32.const 4
-                      i32.add
-                      local.set $2
-                      local.get $0
-                      i32.const -4
-                      i32.add
-                      local.tee $0
-                      i32.const 3
-                      i32.gt_u
-                      br_if 2 (;@7;)
-                      br 3 (;@6;)
-                    end
-                  end
-                end
-                br 1 (;@5;)
-              end
-              local.get $0
-              i32.eqz
-              if ;; label = @6
-                block ;; label = @7
-                  i32.const 0
-                  local.set $0
-                  br 5 (;@2;)
-                end
-              end
-            end
-            loop $label$17 ;; label = @5
-              local.get $2
-              i32.load8_s
-              local.get $1
-              i32.const 24
-              i32.shl
-              i32.const 24
-              i32.shr_s
-              i32.eq
-              br_if 3 (;@2;)
-              local.get $2
-              i32.const 1
-              i32.add
-              local.set $2
-              local.get $0
-              i32.const -1
-              i32.add
-              local.tee $0
-              br_if 0 (;@5;)
-              i32.const 0
-              local.set $0
-            end
-          end
-        end
-      end
-      local.get $0
-      if (result i32) ;; label = @2
-        local.get $2
-      else
-        i32.const 0
-      end
-    end
-  )
-  (func $18 (;31;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $4
-      global.get $global$1
-      i32.const 224
-      i32.add
-      global.set $global$1
-      local.get $4
-      i32.const 136
-      i32.add
-      local.set $5
-      local.get $4
-      i32.const 80
-      i32.add
-      local.tee $3
-      i64.const 0
-      i64.store align=4
-      local.get $3
-      i64.const 0
-      i64.store offset=8 align=4
-      local.get $3
-      i64.const 0
-      i64.store offset=16 align=4
-      local.get $3
-      i64.const 0
-      i64.store offset=24 align=4
-      local.get $3
-      i64.const 0
-      i64.store offset=32 align=4
-      local.get $4
-      i32.const 120
-      i32.add
-      local.tee $6
-      local.get $2
-      i32.load
-      i32.store
-      i32.const 0
-      local.get $1
-      local.get $6
-      local.get $4
-      local.tee $2
-      local.get $3
-      call $19
-      i32.const 0
-      i32.lt_s
-      if ;; label = @2
-        i32.const -1
-        local.set $1
-      else
-        block ;; label = @3
-          local.get $0
-          i32.load offset=76
-          i32.const -1
-          i32.gt_s
-          if (result i32) ;; label = @4
-            local.get $0
-            call $20
-          else
-            i32.const 0
-          end
-          local.set $12
-          local.get $0
-          i32.load
-          local.set $7
-          local.get $0
-          i32.load8_s offset=74
-          i32.const 1
-          i32.lt_s
-          if ;; label = @4
-            local.get $0
-            local.get $7
-            i32.const -33
-            i32.and
-            i32.store
-          end
-          local.get $0
-          i32.const 48
-          i32.add
-          local.tee $8
-          i32.load
-          if ;; label = @4
-            local.get $0
-            local.get $1
-            local.get $6
-            local.get $2
-            local.get $3
-            call $19
-            local.set $1
-          else
-            block ;; label = @5
-              local.get $0
-              i32.const 44
-              i32.add
-              local.tee $9
-              i32.load
-              local.set $10
-              local.get $9
-              local.get $5
-              i32.store
-              local.get $0
-              i32.const 28
-              i32.add
-              local.tee $13
-              local.get $5
-              i32.store
-              local.get $0
-              i32.const 20
-              i32.add
-              local.tee $11
-              local.get $5
-              i32.store
-              local.get $8
-              i32.const 80
-              i32.store
-              local.get $0
-              i32.const 16
-              i32.add
-              local.tee $14
-              local.get $5
-              i32.const 80
-              i32.add
-              i32.store
-              local.get $0
-              local.get $1
-              local.get $6
-              local.get $2
-              local.get $3
-              call $19
-              local.set $1
-              local.get $10
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $0
-                  i32.const 0
-                  i32.const 0
-                  local.get $0
-                  i32.load offset=36
-                  i32.const 3
-                  i32.and
-                  i32.const 2
-                  i32.add
-                  call_indirect (type $0)
-                  drop
-                  local.get $11
-                  i32.load
-                  i32.eqz
-                  if ;; label = @8
-                    i32.const -1
-                    local.set $1
-                  end
-                  local.get $9
-                  local.get $10
-                  i32.store
-                  local.get $8
-                  i32.const 0
-                  i32.store
-                  local.get $14
-                  i32.const 0
-                  i32.store
-                  local.get $13
-                  i32.const 0
-                  i32.store
-                  local.get $11
-                  i32.const 0
-                  i32.store
-                end
-              end
-            end
-          end
-          local.get $0
-          local.get $0
-          i32.load
-          local.tee $2
-          local.get $7
-          i32.const 32
-          i32.and
-          i32.or
-          i32.store
-          local.get $12
-          if ;; label = @4
-            local.get $0
-            call $13
-          end
-          local.get $2
-          i32.const 32
-          i32.and
-          if ;; label = @4
-            i32.const -1
-            local.set $1
-          end
-        end
-      end
-      local.get $4
-      global.set $global$1
-      local.get $1
-    end
-  )
-  (func $19 (;32;) (type $7) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32) (result i32)
-    (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32) (local $15 i32) (local $16 i32) (local $17 i32) (local $18 i32) (local $19 i32) (local $20 i32) (local $21 i32) (local $22 i32) (local $23 i32) (local $24 i32) (local $25 i32) (local $26 i32) (local $27 i32) (local $28 i32) (local $29 i32) (local $30 i32) (local $31 i32) (local $32 i32) (local $33 i32) (local $34 i32) (local $35 i32) (local $36 i32) (local $37 i32) (local $38 i32) (local $39 i32) (local $40 i32) (local $41 i32) (local $42 i32) (local $43 i32) (local $44 i32) (local $45 i32) (local $46 i32) (local $47 i32) (local $48 i32) (local $49 i32) (local $50 i64) (local $51 i64) (local $52 f64) (local $53 f64)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $23
-      global.get $global$1
-      i32.const 624
-      i32.add
-      global.set $global$1
-      local.get $23
-      i32.const 16
-      i32.add
-      local.set $20
-      local.get $23
-      local.set $16
-      local.get $23
-      i32.const 528
-      i32.add
-      local.set $36
-      local.get $0
-      i32.const 0
-      i32.ne
-      local.set $30
-      local.get $23
-      i32.const 536
-      i32.add
-      local.tee $17
-      i32.const 40
-      i32.add
-      local.tee $21
-      local.set $38
-      local.get $17
-      i32.const 39
-      i32.add
-      local.set $39
-      local.get $23
-      i32.const 8
-      i32.add
-      local.tee $37
-      i32.const 4
-      i32.add
-      local.set $42
-      i32.const 0
-      local.get $23
-      i32.const 588
-      i32.add
-      local.tee $19
-      local.tee $27
-      i32.sub
-      local.set $43
-      local.get $23
-      i32.const 576
-      i32.add
-      local.tee $17
-      i32.const 12
-      i32.add
-      local.set $33
-      local.get $17
-      i32.const 11
-      i32.add
-      local.set $40
-      local.get $33
-      local.tee $28
-      local.get $27
-      i32.sub
-      local.set $44
-      i32.const -2
-      local.get $27
-      i32.sub
-      local.set $45
-      local.get $28
-      i32.const 2
-      i32.add
-      local.set $46
-      local.get $23
-      i32.const 24
-      i32.add
-      local.tee $47
-      i32.const 288
-      i32.add
-      local.set $48
-      local.get $19
-      i32.const 9
-      i32.add
-      local.tee $31
-      local.set $41
-      local.get $19
-      i32.const 8
-      i32.add
-      local.set $34
-      i32.const 0
-      local.set $15
-      i32.const 0
-      local.set $10
-      i32.const 0
-      local.set $17
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          loop $label$4 ;; label = @4
-            block $label$5 ;; label = @5
-              local.get $15
-              i32.const -1
-              i32.gt_s
-              if ;; label = @6
-                local.get $10
-                i32.const 2147483647
-                local.get $15
-                i32.sub
-                i32.gt_s
-                if (result i32) ;; label = @7
-                  block (result i32) ;; label = @8
-                    call $12
-                    i32.const 75
-                    i32.store
-                    i32.const -1
-                  end
-                else
-                  local.get $10
-                  local.get $15
-                  i32.add
-                end
-                local.set $15
-              end
-              local.get $1
-              i32.load8_s
-              local.tee $5
-              i32.const 24
-              i32.shl
-              i32.const 24
-              i32.shr_s
-              i32.eqz
-              br_if 2 (;@3;)
-              local.get $1
-              local.set $11
-              block $label$9 ;; label = @6
-                block $label$10 ;; label = @7
-                  loop $label$11 ;; label = @8
-                    block $label$12 ;; label = @9
-                      block $label$13 ;; label = @10
-                        block $label$14 ;; label = @11
-                          block $label$15 ;; label = @12
-                            local.get $5
-                            i32.const 24
-                            i32.shl
-                            i32.const 24
-                            i32.shr_s
-                            i32.const 0
-                            i32.sub
-                            br_table 1 (;@11;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 0 (;@12;) 2 (;@10;)
-                          end
-                          local.get $11
-                          local.set $5
-                          br 4 (;@7;)
-                        end
-                        local.get $11
-                        local.set $5
-                        br 1 (;@9;)
-                      end
-                      local.get $11
-                      i32.const 1
-                      i32.add
-                      local.tee $11
-                      i32.load8_s
-                      local.set $5
-                      br 1 (;@8;)
-                    end
-                  end
-                  br 1 (;@6;)
-                end
-                loop $label$16 ;; label = @7
-                  local.get $5
-                  i32.load8_s offset=1
-                  i32.const 37
-                  i32.ne
-                  br_if 1 (;@6;)
-                  local.get $11
-                  i32.const 1
-                  i32.add
-                  local.set $11
-                  local.get $5
-                  i32.const 2
-                  i32.add
-                  local.tee $5
-                  i32.load8_s
-                  i32.const 37
-                  i32.eq
-                  br_if 0 (;@7;)
-                end
-              end
-              local.get $11
-              local.get $1
-              i32.sub
-              local.set $10
-              local.get $30
-              if ;; label = @6
-                local.get $0
-                i32.load
-                i32.const 32
-                i32.and
-                i32.eqz
-                if ;; label = @7
-                  local.get $1
-                  local.get $10
-                  local.get $0
-                  call $21
-                  drop
-                end
-              end
-              local.get $10
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $5
-                  local.set $1
-                  br 3 (;@4;)
-                end
-              end
-              local.get $5
-              i32.const 1
-              i32.add
-              local.tee $11
-              i32.load8_s
-              local.tee $10
-              i32.const 24
-              i32.shl
-              i32.const 24
-              i32.shr_s
-              i32.const -48
-              i32.add
-              local.tee $9
-              i32.const 10
-              i32.lt_u
-              if (result i32) ;; label = @6
-                block (result i32) ;; label = @7
-                  local.get $5
-                  i32.const 3
-                  i32.add
-                  local.set $10
-                  local.get $5
-                  i32.load8_s offset=2
-                  i32.const 36
-                  i32.eq
-                  local.tee $12
-                  if ;; label = @8
-                    local.get $10
-                    local.set $11
-                  end
-                  local.get $12
-                  if ;; label = @8
-                    i32.const 1
-                    local.set $17
-                  end
-                  local.get $11
-                  i32.load8_s
-                  local.set $5
-                  local.get $12
-                  i32.eqz
-                  if ;; label = @8
-                    i32.const -1
-                    local.set $9
-                  end
-                  local.get $17
-                end
-              else
-                block (result i32) ;; label = @7
-                  local.get $10
-                  local.set $5
-                  i32.const -1
-                  local.set $9
-                  local.get $17
-                end
-              end
-              local.set $10
-              block $label$25 ;; label = @6
-                local.get $5
-                i32.const 24
-                i32.shl
-                i32.const 24
-                i32.shr_s
-                i32.const -32
-                i32.add
-                local.tee $12
-                i32.const 32
-                i32.lt_u
-                if ;; label = @7
-                  block ;; label = @8
-                    i32.const 0
-                    local.set $17
-                    loop $label$27 ;; label = @9
-                      i32.const 1
-                      local.get $12
-                      i32.shl
-                      i32.const 75913
-                      i32.and
-                      i32.eqz
-                      br_if 3 (;@6;)
-                      i32.const 1
-                      local.get $5
-                      i32.const 24
-                      i32.shl
-                      i32.const 24
-                      i32.shr_s
-                      i32.const -32
-                      i32.add
-                      i32.shl
-                      local.get $17
-                      i32.or
-                      local.set $17
-                      local.get $11
-                      i32.const 1
-                      i32.add
-                      local.tee $11
-                      i32.load8_s
-                      local.tee $5
-                      i32.const 24
-                      i32.shl
-                      i32.const 24
-                      i32.shr_s
-                      i32.const -32
-                      i32.add
-                      local.tee $12
-                      i32.const 32
-                      i32.lt_u
-                      br_if 0 (;@9;)
-                    end
-                  end
-                else
-                  i32.const 0
-                  local.set $17
-                end
-              end
-              block $label$29 ;; label = @6
-                local.get $5
-                i32.const 24
-                i32.shl
-                i32.const 24
-                i32.shr_s
-                i32.const 42
-                i32.eq
-                if ;; label = @7
-                  block ;; label = @8
-                    block $label$31 (result i32) ;; label = @9
-                      block $label$32 ;; label = @10
-                        local.get $11
-                        i32.const 1
-                        i32.add
-                        local.tee $7
-                        i32.load8_s
-                        local.tee $5
-                        i32.const 24
-                        i32.shl
-                        i32.const 24
-                        i32.shr_s
-                        i32.const -48
-                        i32.add
-                        local.tee $12
-                        i32.const 10
-                        i32.ge_u
-                        br_if 0 (;@10;)
-                        local.get $11
-                        i32.load8_s offset=2
-                        i32.const 36
-                        i32.ne
-                        br_if 0 (;@10;)
-                        local.get $4
-                        local.get $12
-                        i32.const 2
-                        i32.shl
-                        i32.add
-                        i32.const 10
-                        i32.store
-                        i32.const 1
-                        local.set $8
-                        local.get $3
-                        local.get $7
-                        i32.load8_s
-                        i32.const -48
-                        i32.add
-                        i32.const 3
-                        i32.shl
-                        i32.add
-                        i64.load
-                        i32.wrap_i64
-                        local.set $10
-                        local.get $11
-                        i32.const 3
-                        i32.add
-                        br 1 (;@9;)
-                      end
-                      local.get $10
-                      if ;; label = @10
-                        block ;; label = @11
-                          i32.const -1
-                          local.set $15
-                          br 6 (;@5;)
-                        end
-                      end
-                      local.get $30
-                      i32.eqz
-                      if ;; label = @10
-                        block ;; label = @11
-                          local.get $17
-                          local.set $12
-                          i32.const 0
-                          local.set $17
-                          local.get $7
-                          local.set $11
-                          i32.const 0
-                          local.set $10
-                          br 5 (;@6;)
-                        end
-                      end
-                      local.get $2
-                      i32.load
-                      i32.const 3
-                      i32.add
-                      i32.const -4
-                      i32.and
-                      local.tee $11
-                      i32.load
-                      local.set $10
-                      local.get $2
-                      local.get $11
-                      i32.const 4
-                      i32.add
-                      i32.store
-                      i32.const 0
-                      local.set $8
-                      local.get $7
-                    end
-                    local.set $11
-                    local.get $17
-                    i32.const 8192
-                    i32.or
-                    local.set $12
-                    i32.const 0
-                    local.get $10
-                    i32.sub
-                    local.set $7
-                    local.get $11
-                    i32.load8_s
-                    local.set $5
-                    local.get $10
-                    i32.const 0
-                    i32.lt_s
-                    local.tee $6
-                    i32.eqz
-                    if ;; label = @9
-                      local.get $17
-                      local.set $12
-                    end
-                    local.get $8
-                    local.set $17
-                    local.get $6
-                    if ;; label = @9
-                      local.get $7
-                      local.set $10
-                    end
-                  end
-                else
-                  local.get $5
-                  i32.const 24
-                  i32.shl
-                  i32.const 24
-                  i32.shr_s
-                  i32.const -48
-                  i32.add
-                  local.tee $12
-                  i32.const 10
-                  i32.lt_u
-                  if ;; label = @8
-                    block ;; label = @9
-                      i32.const 0
-                      local.set $7
-                      local.get $12
-                      local.set $5
-                      loop $label$39 ;; label = @10
-                        local.get $7
-                        i32.const 10
-                        i32.mul
-                        local.get $5
-                        i32.add
-                        local.set $7
-                        local.get $11
-                        i32.const 1
-                        i32.add
-                        local.tee $11
-                        i32.load8_s
-                        local.tee $12
-                        i32.const 24
-                        i32.shl
-                        i32.const 24
-                        i32.shr_s
-                        i32.const -48
-                        i32.add
-                        local.tee $5
-                        i32.const 10
-                        i32.lt_u
-                        br_if 0 (;@10;)
-                      end
-                      local.get $7
-                      i32.const 0
-                      i32.lt_s
-                      if ;; label = @10
-                        block ;; label = @11
-                          i32.const -1
-                          local.set $15
-                          br 6 (;@5;)
-                        end
-                      else
-                        block ;; label = @11
-                          local.get $12
-                          local.set $5
-                          local.get $17
-                          local.set $12
-                          local.get $10
-                          local.set $17
-                          local.get $7
-                          local.set $10
-                        end
-                      end
-                    end
-                  else
-                    block ;; label = @9
-                      local.get $17
-                      local.set $12
-                      local.get $10
-                      local.set $17
-                      i32.const 0
-                      local.set $10
-                    end
-                  end
-                end
-              end
-              block $label$43 ;; label = @6
-                local.get $5
-                i32.const 24
-                i32.shl
-                i32.const 24
-                i32.shr_s
-                i32.const 46
-                i32.eq
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $11
-                    i32.const 1
-                    i32.add
-                    local.tee $7
-                    i32.load8_s
-                    local.tee $5
-                    i32.const 24
-                    i32.shl
-                    i32.const 24
-                    i32.shr_s
-                    i32.const 42
-                    i32.ne
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $5
-                        i32.const 24
-                        i32.shl
-                        i32.const 24
-                        i32.shr_s
-                        i32.const -48
-                        i32.add
-                        local.tee $5
-                        i32.const 10
-                        i32.lt_u
-                        if ;; label = @11
-                          block ;; label = @12
-                            local.get $7
-                            local.set $11
-                            i32.const 0
-                            local.set $7
-                          end
-                        else
-                          block ;; label = @12
-                            i32.const 0
-                            local.set $5
-                            local.get $7
-                            local.set $11
-                            br 6 (;@6;)
-                          end
-                        end
-                        loop $label$48 ;; label = @11
-                          local.get $7
-                          i32.const 10
-                          i32.mul
-                          local.get $5
-                          i32.add
-                          local.set $5
-                          local.get $11
-                          i32.const 1
-                          i32.add
-                          local.tee $11
-                          i32.load8_s
-                          i32.const -48
-                          i32.add
-                          local.tee $8
-                          i32.const 10
-                          i32.ge_u
-                          br_if 5 (;@6;)
-                          local.get $5
-                          local.set $7
-                          local.get $8
-                          local.set $5
-                          br 0 (;@11;)
-                        end
-                      end
-                    end
-                    local.get $11
-                    i32.const 2
-                    i32.add
-                    local.tee $7
-                    i32.load8_s
-                    i32.const -48
-                    i32.add
-                    local.tee $5
-                    i32.const 10
-                    i32.lt_u
-                    if ;; label = @9
-                      local.get $11
-                      i32.load8_s offset=3
-                      i32.const 36
-                      i32.eq
-                      if ;; label = @10
-                        block ;; label = @11
-                          local.get $4
-                          local.get $5
-                          i32.const 2
-                          i32.shl
-                          i32.add
-                          i32.const 10
-                          i32.store
-                          local.get $3
-                          local.get $7
-                          i32.load8_s
-                          i32.const -48
-                          i32.add
-                          i32.const 3
-                          i32.shl
-                          i32.add
-                          i64.load
-                          i32.wrap_i64
-                          local.set $5
-                          local.get $11
-                          i32.const 4
-                          i32.add
-                          local.set $11
-                          br 5 (;@6;)
-                        end
-                      end
-                    end
-                    local.get $17
-                    if ;; label = @9
-                      block ;; label = @10
-                        i32.const -1
-                        local.set $15
-                        br 5 (;@5;)
-                      end
-                    end
-                    local.get $30
-                    if (result i32) ;; label = @9
-                      block (result i32) ;; label = @10
-                        local.get $2
-                        i32.load
-                        i32.const 3
-                        i32.add
-                        i32.const -4
-                        i32.and
-                        local.tee $11
-                        i32.load
-                        local.set $5
-                        local.get $2
-                        local.get $11
-                        i32.const 4
-                        i32.add
-                        i32.store
-                        local.get $7
-                      end
-                    else
-                      block (result i32) ;; label = @10
-                        i32.const 0
-                        local.set $5
-                        local.get $7
-                      end
-                    end
-                    local.set $11
-                  end
-                else
-                  i32.const -1
-                  local.set $5
-                end
-              end
-              local.get $11
-              local.set $7
-              i32.const 0
-              local.set $8
-              loop $label$55 ;; label = @6
-                local.get $7
-                i32.load8_s
-                i32.const -65
-                i32.add
-                local.tee $6
-                i32.const 57
-                i32.gt_u
-                if ;; label = @7
-                  block ;; label = @8
-                    i32.const -1
-                    local.set $15
-                    br 3 (;@5;)
-                  end
-                end
-                local.get $7
-                i32.const 1
-                i32.add
-                local.set $11
-                local.get $8
-                i32.const 58
-                i32.mul
-                i32.const 1155
-                i32.add
-                local.get $6
-                i32.add
-                i32.load8_s
-                local.tee $13
-                i32.const 255
-                i32.and
-                local.tee $6
-                i32.const -1
-                i32.add
-                i32.const 8
-                i32.lt_u
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $11
-                    local.set $7
-                    local.get $6
-                    local.set $8
-                    br 2 (;@6;)
-                  end
-                end
-              end
-              local.get $13
-              i32.const 24
-              i32.shl
-              i32.const 24
-              i32.shr_s
-              i32.eqz
-              if ;; label = @6
-                block ;; label = @7
-                  i32.const -1
-                  local.set $15
-                  br 2 (;@5;)
-                end
-              end
-              local.get $9
-              i32.const -1
-              i32.gt_s
-              local.set $14
-              block $label$59 ;; label = @6
-                block $label$60 ;; label = @7
-                  local.get $13
-                  i32.const 24
-                  i32.shl
-                  i32.const 24
-                  i32.shr_s
-                  i32.const 19
-                  i32.eq
-                  if ;; label = @8
-                    local.get $14
-                    if ;; label = @9
-                      block ;; label = @10
-                        i32.const -1
-                        local.set $15
-                        br 5 (;@5;)
-                      end
-                    else
-                      br 2 (;@7;)
-                    end
-                  else
-                    block ;; label = @9
-                      local.get $14
-                      if ;; label = @10
-                        block ;; label = @11
-                          local.get $4
-                          local.get $9
-                          i32.const 2
-                          i32.shl
-                          i32.add
-                          local.get $6
-                          i32.store
-                          local.get $16
-                          local.get $3
-                          local.get $9
-                          i32.const 3
-                          i32.shl
-                          i32.add
-                          i64.load
-                          i64.store
-                          br 4 (;@7;)
-                        end
-                      end
-                      local.get $30
-                      i32.eqz
-                      if ;; label = @10
-                        block ;; label = @11
-                          i32.const 0
-                          local.set $15
-                          br 6 (;@5;)
-                        end
-                      end
-                      local.get $16
-                      local.get $6
-                      local.get $2
-                      call $22
-                    end
-                  end
-                  br 1 (;@6;)
-                end
-                local.get $30
-                i32.eqz
-                if ;; label = @7
-                  block ;; label = @8
-                    i32.const 0
-                    local.set $10
-                    local.get $11
-                    local.set $1
-                    br 4 (;@4;)
-                  end
-                end
-              end
-              local.get $7
-              i32.load8_s
-              local.tee $7
-              i32.const -33
-              i32.and
-              local.set $9
-              local.get $8
-              i32.const 0
-              i32.ne
-              local.get $7
-              i32.const 15
-              i32.and
-              i32.const 3
-              i32.eq
-              i32.and
-              i32.eqz
-              if ;; label = @6
-                local.get $7
-                local.set $9
-              end
-              local.get $12
-              i32.const -65537
-              i32.and
-              local.set $7
-              local.get $12
-              i32.const 8192
-              i32.and
-              if ;; label = @6
-                local.get $7
-                local.set $12
-              end
-              block $label$70 ;; label = @6
-                block $label$71 ;; label = @7
-                  block $label$72 ;; label = @8
-                    block $label$73 ;; label = @9
-                      block $label$74 ;; label = @10
-                        block $label$75 ;; label = @11
-                          block $label$76 ;; label = @12
-                            block $label$77 ;; label = @13
-                              block $label$78 ;; label = @14
-                                block $label$79 ;; label = @15
-                                  block $label$80 ;; label = @16
-                                    block $label$81 ;; label = @17
-                                      block $label$82 ;; label = @18
-                                        block $label$83 ;; label = @19
-                                          block $label$84 ;; label = @20
-                                            block $label$85 ;; label = @21
-                                              block $label$86 ;; label = @22
-                                                block $label$87 ;; label = @23
-                                                  block $label$88 ;; label = @24
-                                                    block $label$89 ;; label = @25
-                                                      local.get $9
-                                                      i32.const 65
-                                                      i32.sub
-                                                      br_table 11 (;@14;) 12 (;@13;) 9 (;@16;) 12 (;@13;) 11 (;@14;) 11 (;@14;) 11 (;@14;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 10 (;@15;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 2 (;@23;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 11 (;@14;) 12 (;@13;) 6 (;@19;) 4 (;@21;) 11 (;@14;) 11 (;@14;) 11 (;@14;) 12 (;@13;) 4 (;@21;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 7 (;@18;) 0 (;@25;) 3 (;@22;) 1 (;@24;) 12 (;@13;) 12 (;@13;) 8 (;@17;) 12 (;@13;) 5 (;@20;) 12 (;@13;) 12 (;@13;) 2 (;@23;) 12 (;@13;)
-                                                    end
-                                                    block $label$90 ;; label = @25
-                                                      block $label$91 ;; label = @26
-                                                        block $label$92 ;; label = @27
-                                                          block $label$93 ;; label = @28
-                                                            block $label$94 ;; label = @29
-                                                              block $label$95 ;; label = @30
-                                                                block $label$96 ;; label = @31
-                                                                  block $label$97 ;; label = @32
-                                                                    local.get $8
-                                                                    i32.const 255
-                                                                    i32.and
-                                                                    i32.const 24
-                                                                    i32.shl
-                                                                    i32.const 24
-                                                                    i32.shr_s
-                                                                    i32.const 0
-                                                                    i32.sub
-                                                                    br_table 0 (;@32;) 1 (;@31;) 2 (;@30;) 3 (;@29;) 4 (;@28;) 7 (;@25;) 5 (;@27;) 6 (;@26;) 7 (;@25;)
-                                                                  end
-                                                                  local.get $16
-                                                                  i32.load
-                                                                  local.get $15
-                                                                  i32.store
-                                                                  i32.const 0
-                                                                  local.set $10
-                                                                  local.get $11
-                                                                  local.set $1
-                                                                  br 27 (;@4;)
-                                                                end
-                                                                local.get $16
-                                                                i32.load
-                                                                local.get $15
-                                                                i32.store
-                                                                i32.const 0
-                                                                local.set $10
-                                                                local.get $11
-                                                                local.set $1
-                                                                br 26 (;@4;)
-                                                              end
-                                                              local.get $16
-                                                              i32.load
-                                                              local.get $15
-                                                              i64.extend_i32_s
-                                                              i64.store
-                                                              i32.const 0
-                                                              local.set $10
-                                                              local.get $11
-                                                              local.set $1
-                                                              br 25 (;@4;)
-                                                            end
-                                                            local.get $16
-                                                            i32.load
-                                                            local.get $15
-                                                            i32.store16
-                                                            i32.const 0
-                                                            local.set $10
-                                                            local.get $11
-                                                            local.set $1
-                                                            br 24 (;@4;)
-                                                          end
-                                                          local.get $16
-                                                          i32.load
-                                                          local.get $15
-                                                          i32.store8
-                                                          i32.const 0
-                                                          local.set $10
-                                                          local.get $11
-                                                          local.set $1
-                                                          br 23 (;@4;)
-                                                        end
-                                                        local.get $16
-                                                        i32.load
-                                                        local.get $15
-                                                        i32.store
-                                                        i32.const 0
-                                                        local.set $10
-                                                        local.get $11
-                                                        local.set $1
-                                                        br 22 (;@4;)
-                                                      end
-                                                      local.get $16
-                                                      i32.load
-                                                      local.get $15
-                                                      i64.extend_i32_s
-                                                      i64.store
-                                                      i32.const 0
-                                                      local.set $10
-                                                      local.get $11
-                                                      local.set $1
-                                                      br 21 (;@4;)
-                                                    end
-                                                    i32.const 0
-                                                    local.set $10
-                                                    local.get $11
-                                                    local.set $1
-                                                    br 20 (;@4;)
-                                                  end
-                                                  local.get $12
-                                                  i32.const 8
-                                                  i32.or
-                                                  local.set $12
-                                                  local.get $5
-                                                  i32.const 8
-                                                  i32.le_u
-                                                  if ;; label = @24
-                                                    i32.const 8
-                                                    local.set $5
-                                                  end
-                                                  i32.const 120
-                                                  local.set $9
-                                                  br 11 (;@12;)
-                                                end
-                                                br 10 (;@12;)
-                                              end
-                                              local.get $16
-                                              i64.load
-                                              local.tee $50
-                                              i64.const 0
-                                              i64.eq
-                                              if ;; label = @22
-                                                local.get $21
-                                                local.set $7
-                                              else
-                                                block ;; label = @23
-                                                  local.get $21
-                                                  local.set $1
-                                                  loop $label$101 ;; label = @24
-                                                    local.get $1
-                                                    i32.const -1
-                                                    i32.add
-                                                    local.tee $1
-                                                    local.get $50
-                                                    i64.const 7
-                                                    i64.and
-                                                    i64.const 48
-                                                    i64.or
-                                                    i64.store8
-                                                    local.get $50
-                                                    i64.const 3
-                                                    i64.shr_u
-                                                    local.tee $50
-                                                    i64.const 0
-                                                    i64.ne
-                                                    br_if 0 (;@24;)
-                                                    local.get $1
-                                                    local.set $7
-                                                  end
-                                                end
-                                              end
-                                              local.get $12
-                                              i32.const 8
-                                              i32.and
-                                              if ;; label = @22
-                                                block ;; label = @23
-                                                  local.get $38
-                                                  local.get $7
-                                                  i32.sub
-                                                  local.tee $1
-                                                  i32.const 1
-                                                  i32.add
-                                                  local.set $8
-                                                  local.get $5
-                                                  local.get $1
-                                                  i32.le_s
-                                                  if ;; label = @24
-                                                    local.get $8
-                                                    local.set $5
-                                                  end
-                                                  i32.const 0
-                                                  local.set $6
-                                                  i32.const 1635
-                                                  local.set $8
-                                                  br 16 (;@7;)
-                                                end
-                                              else
-                                                block ;; label = @23
-                                                  i32.const 0
-                                                  local.set $6
-                                                  i32.const 1635
-                                                  local.set $8
-                                                  br 16 (;@7;)
-                                                end
-                                              end
-                                            end
-                                            local.get $16
-                                            i64.load
-                                            local.tee $50
-                                            i64.const 0
-                                            i64.lt_s
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                local.get $16
-                                                i64.const 0
-                                                local.get $50
-                                                i64.sub
-                                                local.tee $50
-                                                i64.store
-                                                i32.const 1
-                                                local.set $6
-                                                i32.const 1635
-                                                local.set $8
-                                                br 11 (;@11;)
-                                              end
-                                            end
-                                            local.get $12
-                                            i32.const 2048
-                                            i32.and
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                i32.const 1
-                                                local.set $6
-                                                i32.const 1636
-                                                local.set $8
-                                                br 11 (;@11;)
-                                              end
-                                            else
-                                              block ;; label = @22
-                                                local.get $12
-                                                i32.const 1
-                                                i32.and
-                                                local.tee $1
-                                                local.set $6
-                                                local.get $1
-                                                if (result i32) ;; label = @23
-                                                  i32.const 1637
-                                                else
-                                                  i32.const 1635
-                                                end
-                                                local.set $8
-                                                br 11 (;@11;)
-                                              end
-                                            end
-                                          end
-                                          local.get $16
-                                          i64.load
-                                          local.set $50
-                                          i32.const 0
-                                          local.set $6
-                                          i32.const 1635
-                                          local.set $8
-                                          br 8 (;@11;)
-                                        end
-                                        local.get $39
-                                        local.get $16
-                                        i64.load
-                                        i64.store8
-                                        local.get $39
-                                        local.set $1
-                                        local.get $7
-                                        local.set $12
-                                        i32.const 1
-                                        local.set $7
-                                        i32.const 0
-                                        local.set $6
-                                        i32.const 1635
-                                        local.set $8
-                                        local.get $21
-                                        local.set $5
-                                        br 12 (;@6;)
-                                      end
-                                      call $12
-                                      i32.load
-                                      call $24
-                                      local.set $1
-                                      br 7 (;@10;)
-                                    end
-                                    local.get $16
-                                    i32.load
-                                    local.tee $1
-                                    i32.eqz
-                                    if ;; label = @17
-                                      i32.const 1645
-                                      local.set $1
-                                    end
-                                    br 6 (;@10;)
-                                  end
-                                  local.get $37
-                                  local.get $16
-                                  i64.load
-                                  i64.store32
-                                  local.get $42
-                                  i32.const 0
-                                  i32.store
-                                  local.get $16
-                                  local.get $37
-                                  i32.store
-                                  local.get $37
-                                  local.set $7
-                                  i32.const -1
-                                  local.set $6
-                                  br 6 (;@9;)
-                                end
-                                local.get $16
-                                i32.load
-                                local.set $7
-                                local.get $5
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $5
-                                    local.set $6
-                                    br 7 (;@9;)
-                                  end
-                                else
-                                  block ;; label = @16
-                                    local.get $0
-                                    i32.const 32
-                                    local.get $10
-                                    i32.const 0
-                                    local.get $12
-                                    call $25
-                                    i32.const 0
-                                    local.set $1
-                                    br 8 (;@8;)
-                                  end
-                                end
-                              end
-                              local.get $16
-                              f64.load
-                              local.set $52
-                              local.get $20
-                              i32.const 0
-                              i32.store
-                              local.get $52
-                              i64.reinterpret_f64
-                              i64.const 0
-                              i64.lt_s
-                              if (result i32) ;; label = @14
-                                block (result i32) ;; label = @15
-                                  i32.const 1
-                                  local.set $24
-                                  local.get $52
-                                  f64.neg
-                                  local.set $52
-                                  i32.const 1652
-                                end
-                              else
-                                block (result i32) ;; label = @15
-                                  local.get $12
-                                  i32.const 1
-                                  i32.and
-                                  local.set $1
-                                  local.get $12
-                                  i32.const 2048
-                                  i32.and
-                                  if (result i32) ;; label = @16
-                                    block (result i32) ;; label = @17
-                                      i32.const 1
-                                      local.set $24
-                                      i32.const 1655
-                                    end
-                                  else
-                                    block (result i32) ;; label = @17
-                                      local.get $1
-                                      local.set $24
-                                      local.get $1
-                                      if (result i32) ;; label = @18
-                                        i32.const 1658
-                                      else
-                                        i32.const 1653
-                                      end
-                                    end
-                                  end
-                                end
-                              end
-                              local.set $26
-                              block $label$119 ;; label = @14
-                                local.get $52
-                                i64.reinterpret_f64
-                                i64.const 9218868437227405312
-                                i64.and
-                                i64.const 9218868437227405312
-                                i64.lt_u
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $52
-                                    local.get $20
-                                    call $27
-                                    f64.const 0x1p+1 (;=2;)
-                                    f64.mul
-                                    local.tee $52
-                                    f64.const 0x0p+0 (;=0;)
-                                    f64.ne
-                                    local.tee $1
-                                    if ;; label = @17
-                                      local.get $20
-                                      local.get $20
-                                      i32.load
-                                      i32.const -1
-                                      i32.add
-                                      i32.store
-                                    end
-                                    local.get $9
-                                    i32.const 32
-                                    i32.or
-                                    local.tee $22
-                                    i32.const 97
-                                    i32.eq
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        local.get $26
-                                        i32.const 9
-                                        i32.add
-                                        local.set $1
-                                        local.get $9
-                                        i32.const 32
-                                        i32.and
-                                        local.tee $6
-                                        if ;; label = @19
-                                          local.get $1
-                                          local.set $26
-                                        end
-                                        local.get $5
-                                        i32.const 11
-                                        i32.gt_u
-                                        i32.const 12
-                                        local.get $5
-                                        i32.sub
-                                        local.tee $1
-                                        i32.eqz
-                                        i32.or
-                                        i32.eqz
-                                        if ;; label = @19
-                                          block ;; label = @20
-                                            f64.const 0x1p+3 (;=8;)
-                                            local.set $53
-                                            loop $label$125 ;; label = @21
-                                              local.get $53
-                                              f64.const 0x1p+4 (;=16;)
-                                              f64.mul
-                                              local.set $53
-                                              local.get $1
-                                              i32.const -1
-                                              i32.add
-                                              local.tee $1
-                                              br_if 0 (;@21;)
-                                            end
-                                            local.get $26
-                                            i32.load8_s
-                                            i32.const 45
-                                            i32.eq
-                                            if (result f64) ;; label = @21
-                                              local.get $53
-                                              local.get $52
-                                              f64.neg
-                                              local.get $53
-                                              f64.sub
-                                              f64.add
-                                              f64.neg
-                                            else
-                                              local.get $52
-                                              local.get $53
-                                              f64.add
-                                              local.get $53
-                                              f64.sub
-                                            end
-                                            local.set $52
-                                          end
-                                        end
-                                        i32.const 0
-                                        local.get $20
-                                        i32.load
-                                        local.tee $7
-                                        i32.sub
-                                        local.set $1
-                                        local.get $7
-                                        i32.const 0
-                                        i32.lt_s
-                                        if (result i32) ;; label = @19
-                                          local.get $1
-                                        else
-                                          local.get $7
-                                        end
-                                        i64.extend_i32_s
-                                        local.get $33
-                                        call $23
-                                        local.tee $1
-                                        local.get $33
-                                        i32.eq
-                                        if ;; label = @19
-                                          block ;; label = @20
-                                            local.get $40
-                                            i32.const 48
-                                            i32.store8
-                                            local.get $40
-                                            local.set $1
-                                          end
-                                        end
-                                        local.get $24
-                                        i32.const 2
-                                        i32.or
-                                        local.set $13
-                                        local.get $1
-                                        i32.const -1
-                                        i32.add
-                                        local.get $7
-                                        i32.const 31
-                                        i32.shr_s
-                                        i32.const 2
-                                        i32.and
-                                        i32.const 43
-                                        i32.add
-                                        i32.store8
-                                        local.get $1
-                                        i32.const -2
-                                        i32.add
-                                        local.tee $8
-                                        local.get $9
-                                        i32.const 15
-                                        i32.add
-                                        i32.store8
-                                        local.get $5
-                                        i32.const 1
-                                        i32.lt_s
-                                        local.set $9
-                                        local.get $12
-                                        i32.const 8
-                                        i32.and
-                                        i32.eqz
-                                        local.set $14
-                                        local.get $19
-                                        local.set $1
-                                        loop $label$131 ;; label = @19
-                                          local.get $1
-                                          local.get $52
-                                          i32.trunc_f64_s
-                                          local.tee $7
-                                          i32.const 1619
-                                          i32.add
-                                          i32.load8_u
-                                          local.get $6
-                                          i32.or
-                                          i32.store8
-                                          local.get $52
-                                          local.get $7
-                                          f64.convert_i32_s
-                                          f64.sub
-                                          f64.const 0x1p+4 (;=16;)
-                                          f64.mul
-                                          local.set $52
-                                          block $label$132 (result i32) ;; label = @20
-                                            local.get $1
-                                            i32.const 1
-                                            i32.add
-                                            local.tee $7
-                                            local.get $27
-                                            i32.sub
-                                            i32.const 1
-                                            i32.eq
-                                            if (result i32) ;; label = @21
-                                              block (result i32) ;; label = @22
-                                                local.get $7
-                                                local.get $14
-                                                local.get $9
-                                                local.get $52
-                                                f64.const 0x0p+0 (;=0;)
-                                                f64.eq
-                                                i32.and
-                                                i32.and
-                                                br_if 2 (;@20;)
-                                                drop
-                                                local.get $7
-                                                i32.const 46
-                                                i32.store8
-                                                local.get $1
-                                                i32.const 2
-                                                i32.add
-                                              end
-                                            else
-                                              local.get $7
-                                            end
-                                          end
-                                          local.set $1
-                                          local.get $52
-                                          f64.const 0x0p+0 (;=0;)
-                                          f64.ne
-                                          br_if 0 (;@19;)
-                                        end
-                                        local.get $46
-                                        local.get $5
-                                        i32.add
-                                        local.get $8
-                                        local.tee $7
-                                        i32.sub
-                                        local.set $6
-                                        local.get $44
-                                        local.get $7
-                                        i32.sub
-                                        local.get $1
-                                        i32.add
-                                        local.set $9
-                                        local.get $0
-                                        i32.const 32
-                                        local.get $10
-                                        local.get $5
-                                        i32.const 0
-                                        i32.ne
-                                        local.get $45
-                                        local.get $1
-                                        i32.add
-                                        local.get $5
-                                        i32.lt_s
-                                        i32.and
-                                        if (result i32) ;; label = @19
-                                          local.get $6
-                                        else
-                                          local.get $9
-                                          local.tee $6
-                                        end
-                                        local.get $13
-                                        i32.add
-                                        local.tee $5
-                                        local.get $12
-                                        call $25
-                                        local.get $0
-                                        i32.load
-                                        i32.const 32
-                                        i32.and
-                                        i32.eqz
-                                        if ;; label = @19
-                                          local.get $26
-                                          local.get $13
-                                          local.get $0
-                                          call $21
-                                          drop
-                                        end
-                                        local.get $0
-                                        i32.const 48
-                                        local.get $10
-                                        local.get $5
-                                        local.get $12
-                                        i32.const 65536
-                                        i32.xor
-                                        call $25
-                                        local.get $1
-                                        local.get $27
-                                        i32.sub
-                                        local.set $1
-                                        local.get $0
-                                        i32.load
-                                        i32.const 32
-                                        i32.and
-                                        i32.eqz
-                                        if ;; label = @19
-                                          local.get $19
-                                          local.get $1
-                                          local.get $0
-                                          call $21
-                                          drop
-                                        end
-                                        local.get $0
-                                        i32.const 48
-                                        local.get $6
-                                        local.get $1
-                                        local.get $28
-                                        local.get $7
-                                        i32.sub
-                                        local.tee $1
-                                        i32.add
-                                        i32.sub
-                                        i32.const 0
-                                        i32.const 0
-                                        call $25
-                                        local.get $0
-                                        i32.load
-                                        i32.const 32
-                                        i32.and
-                                        i32.eqz
-                                        if ;; label = @19
-                                          local.get $8
-                                          local.get $1
-                                          local.get $0
-                                          call $21
-                                          drop
-                                        end
-                                        local.get $0
-                                        i32.const 32
-                                        local.get $10
-                                        local.get $5
-                                        local.get $12
-                                        i32.const 8192
-                                        i32.xor
-                                        call $25
-                                        local.get $5
-                                        local.get $10
-                                        i32.ge_s
-                                        if ;; label = @19
-                                          local.get $5
-                                          local.set $10
-                                        end
-                                        br 4 (;@14;)
-                                      end
-                                    end
-                                    local.get $1
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        local.get $20
-                                        local.get $20
-                                        i32.load
-                                        i32.const -28
-                                        i32.add
-                                        local.tee $6
-                                        i32.store
-                                        local.get $52
-                                        f64.const 0x1p+28 (;=268435456;)
-                                        f64.mul
-                                        local.set $52
-                                      end
-                                    else
-                                      local.get $20
-                                      i32.load
-                                      local.set $6
-                                    end
-                                    local.get $6
-                                    i32.const 0
-                                    i32.lt_s
-                                    if (result i32) ;; label = @17
-                                      local.get $47
-                                    else
-                                      local.get $48
-                                    end
-                                    local.tee $7
-                                    local.set $8
-                                    loop $label$145 ;; label = @17
-                                      local.get $8
-                                      local.get $52
-                                      i32.trunc_f64_s
-                                      local.tee $1
-                                      i32.store
-                                      local.get $8
-                                      i32.const 4
-                                      i32.add
-                                      local.set $8
-                                      local.get $52
-                                      local.get $1
-                                      f64.convert_i32_u
-                                      f64.sub
-                                      f64.const 0x1.dcd65p+29 (;=1000000000;)
-                                      f64.mul
-                                      local.tee $52
-                                      f64.const 0x0p+0 (;=0;)
-                                      f64.ne
-                                      br_if 0 (;@17;)
-                                    end
-                                    local.get $6
-                                    i32.const 0
-                                    i32.gt_s
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        local.get $7
-                                        local.set $1
-                                        loop $label$147 ;; label = @19
-                                          local.get $6
-                                          i32.const 29
-                                          i32.gt_s
-                                          if (result i32) ;; label = @20
-                                            i32.const 29
-                                          else
-                                            local.get $6
-                                          end
-                                          local.set $14
-                                          block $label$150 ;; label = @20
-                                            local.get $8
-                                            i32.const -4
-                                            i32.add
-                                            local.tee $6
-                                            local.get $1
-                                            i32.ge_u
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                local.get $14
-                                                i64.extend_i32_u
-                                                local.set $50
-                                                i32.const 0
-                                                local.set $13
-                                                loop $label$152 ;; label = @23
-                                                  local.get $6
-                                                  local.get $6
-                                                  i32.load
-                                                  i64.extend_i32_u
-                                                  local.get $50
-                                                  i64.shl
-                                                  local.get $13
-                                                  i64.extend_i32_u
-                                                  i64.add
-                                                  local.tee $51
-                                                  i64.const 1000000000
-                                                  i64.rem_u
-                                                  i64.store32
-                                                  local.get $51
-                                                  i64.const 1000000000
-                                                  i64.div_u
-                                                  i32.wrap_i64
-                                                  local.set $13
-                                                  local.get $6
-                                                  i32.const -4
-                                                  i32.add
-                                                  local.tee $6
-                                                  local.get $1
-                                                  i32.ge_u
-                                                  br_if 0 (;@23;)
-                                                end
-                                                local.get $13
-                                                i32.eqz
-                                                br_if 2 (;@20;)
-                                                local.get $1
-                                                i32.const -4
-                                                i32.add
-                                                local.tee $1
-                                                local.get $13
-                                                i32.store
-                                              end
-                                            end
-                                          end
-                                          loop $label$153 ;; label = @20
-                                            local.get $8
-                                            local.get $1
-                                            i32.gt_u
-                                            if ;; label = @21
-                                              local.get $8
-                                              i32.const -4
-                                              i32.add
-                                              local.tee $6
-                                              i32.load
-                                              i32.eqz
-                                              if ;; label = @22
-                                                block ;; label = @23
-                                                  local.get $6
-                                                  local.set $8
-                                                  br 3 (;@20;)
-                                                end
-                                              end
-                                            end
-                                          end
-                                          local.get $20
-                                          local.get $20
-                                          i32.load
-                                          local.get $14
-                                          i32.sub
-                                          local.tee $6
-                                          i32.store
-                                          local.get $6
-                                          i32.const 0
-                                          i32.gt_s
-                                          br_if 0 (;@19;)
-                                        end
-                                      end
-                                    else
-                                      local.get $7
-                                      local.set $1
-                                    end
-                                    local.get $5
-                                    i32.const 0
-                                    i32.lt_s
-                                    if (result i32) ;; label = @17
-                                      i32.const 6
-                                    else
-                                      local.get $5
-                                    end
-                                    local.set $18
-                                    local.get $6
-                                    i32.const 0
-                                    i32.lt_s
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        local.get $18
-                                        i32.const 25
-                                        i32.add
-                                        i32.const 9
-                                        i32.div_s
-                                        i32.const 1
-                                        i32.add
-                                        local.set $14
-                                        local.get $22
-                                        i32.const 102
-                                        i32.eq
-                                        local.set $25
-                                        local.get $8
-                                        local.set $5
-                                        loop $label$160 ;; label = @19
-                                          i32.const 0
-                                          local.get $6
-                                          i32.sub
-                                          local.tee $13
-                                          i32.const 9
-                                          i32.gt_s
-                                          if ;; label = @20
-                                            i32.const 9
-                                            local.set $13
-                                          end
-                                          block $label$162 ;; label = @20
-                                            local.get $1
-                                            local.get $5
-                                            i32.lt_u
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                i32.const 1
-                                                local.get $13
-                                                i32.shl
-                                                i32.const -1
-                                                i32.add
-                                                local.set $29
-                                                i32.const 1000000000
-                                                local.get $13
-                                                i32.shr_u
-                                                local.set $35
-                                                i32.const 0
-                                                local.set $6
-                                                local.get $1
-                                                local.set $8
-                                                loop $label$164 ;; label = @23
-                                                  local.get $8
-                                                  local.get $8
-                                                  i32.load
-                                                  local.tee $32
-                                                  local.get $13
-                                                  i32.shr_u
-                                                  local.get $6
-                                                  i32.add
-                                                  i32.store
-                                                  local.get $32
-                                                  local.get $29
-                                                  i32.and
-                                                  local.get $35
-                                                  i32.mul
-                                                  local.set $6
-                                                  local.get $8
-                                                  i32.const 4
-                                                  i32.add
-                                                  local.tee $8
-                                                  local.get $5
-                                                  i32.lt_u
-                                                  br_if 0 (;@23;)
-                                                end
-                                                local.get $1
-                                                i32.const 4
-                                                i32.add
-                                                local.set $8
-                                                local.get $1
-                                                i32.load
-                                                i32.eqz
-                                                if ;; label = @23
-                                                  local.get $8
-                                                  local.set $1
-                                                end
-                                                local.get $6
-                                                i32.eqz
-                                                br_if 2 (;@20;)
-                                                local.get $5
-                                                local.get $6
-                                                i32.store
-                                                local.get $5
-                                                i32.const 4
-                                                i32.add
-                                                local.set $5
-                                              end
-                                            else
-                                              block ;; label = @22
-                                                local.get $1
-                                                i32.const 4
-                                                i32.add
-                                                local.set $8
-                                                local.get $1
-                                                i32.load
-                                                i32.eqz
-                                                if ;; label = @23
-                                                  local.get $8
-                                                  local.set $1
-                                                end
-                                              end
-                                            end
-                                          end
-                                          local.get $25
-                                          if (result i32) ;; label = @20
-                                            local.get $7
-                                          else
-                                            local.get $1
-                                          end
-                                          local.tee $8
-                                          local.get $14
-                                          i32.const 2
-                                          i32.shl
-                                          i32.add
-                                          local.set $6
-                                          local.get $5
-                                          local.get $8
-                                          i32.sub
-                                          i32.const 2
-                                          i32.shr_s
-                                          local.get $14
-                                          i32.gt_s
-                                          if ;; label = @20
-                                            local.get $6
-                                            local.set $5
-                                          end
-                                          local.get $20
-                                          local.get $20
-                                          i32.load
-                                          local.get $13
-                                          i32.add
-                                          local.tee $6
-                                          i32.store
-                                          local.get $6
-                                          i32.const 0
-                                          i32.lt_s
-                                          br_if 0 (;@19;)
-                                          local.get $5
-                                          local.set $13
-                                        end
-                                      end
-                                    else
-                                      local.get $8
-                                      local.set $13
-                                    end
-                                    local.get $7
-                                    local.set $25
-                                    block $label$172 ;; label = @17
-                                      local.get $1
-                                      local.get $13
-                                      i32.lt_u
-                                      if ;; label = @18
-                                        block ;; label = @19
-                                          local.get $25
-                                          local.get $1
-                                          i32.sub
-                                          i32.const 2
-                                          i32.shr_s
-                                          i32.const 9
-                                          i32.mul
-                                          local.set $5
-                                          local.get $1
-                                          i32.load
-                                          local.tee $6
-                                          i32.const 10
-                                          i32.lt_u
-                                          br_if 2 (;@17;)
-                                          i32.const 10
-                                          local.set $8
-                                          loop $label$174 ;; label = @20
-                                            local.get $5
-                                            i32.const 1
-                                            i32.add
-                                            local.set $5
-                                            local.get $6
-                                            local.get $8
-                                            i32.const 10
-                                            i32.mul
-                                            local.tee $8
-                                            i32.ge_u
-                                            br_if 0 (;@20;)
-                                          end
-                                        end
-                                      else
-                                        i32.const 0
-                                        local.set $5
-                                      end
-                                    end
-                                    local.get $22
-                                    i32.const 103
-                                    i32.eq
-                                    local.set $29
-                                    local.get $18
-                                    i32.const 0
-                                    i32.ne
-                                    local.set $35
-                                    local.get $18
-                                    local.get $22
-                                    i32.const 102
-                                    i32.ne
-                                    if (result i32) ;; label = @17
-                                      local.get $5
-                                    else
-                                      i32.const 0
-                                    end
-                                    i32.sub
-                                    local.get $35
-                                    local.get $29
-                                    i32.and
-                                    i32.const 31
-                                    i32.shl
-                                    i32.const 31
-                                    i32.shr_s
-                                    i32.add
-                                    local.tee $8
-                                    local.get $13
-                                    local.get $25
-                                    i32.sub
-                                    i32.const 2
-                                    i32.shr_s
-                                    i32.const 9
-                                    i32.mul
-                                    i32.const -9
-                                    i32.add
-                                    i32.lt_s
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        local.get $8
-                                        i32.const 9216
-                                        i32.add
-                                        local.tee $14
-                                        i32.const 9
-                                        i32.rem_s
-                                        i32.const 1
-                                        i32.add
-                                        local.tee $8
-                                        i32.const 9
-                                        i32.lt_s
-                                        if ;; label = @19
-                                          block ;; label = @20
-                                            i32.const 10
-                                            local.set $6
-                                            loop $label$180 ;; label = @21
-                                              local.get $6
-                                              i32.const 10
-                                              i32.mul
-                                              local.set $6
-                                              local.get $8
-                                              i32.const 1
-                                              i32.add
-                                              local.tee $8
-                                              i32.const 9
-                                              i32.ne
-                                              br_if 0 (;@21;)
-                                            end
-                                          end
-                                        else
-                                          i32.const 10
-                                          local.set $6
-                                        end
-                                        local.get $7
-                                        i32.const 4
-                                        i32.add
-                                        local.get $14
-                                        i32.const 9
-                                        i32.div_s
-                                        i32.const -1024
-                                        i32.add
-                                        i32.const 2
-                                        i32.shl
-                                        i32.add
-                                        local.tee $8
-                                        i32.load
-                                        local.tee $22
-                                        local.get $6
-                                        i32.rem_u
-                                        local.set $14
-                                        block $label$182 ;; label = @19
-                                          local.get $8
-                                          i32.const 4
-                                          i32.add
-                                          local.get $13
-                                          i32.eq
-                                          local.tee $32
-                                          local.get $14
-                                          i32.eqz
-                                          i32.and
-                                          i32.eqz
-                                          if ;; label = @20
-                                            block ;; label = @21
-                                              local.get $14
-                                              local.get $6
-                                              i32.const 2
-                                              i32.div_s
-                                              local.tee $49
-                                              i32.lt_u
-                                              if (result f64) ;; label = @22
-                                                f64.const 0x1p-1 (;=0.5;)
-                                              else
-                                                local.get $32
-                                                local.get $14
-                                                local.get $49
-                                                i32.eq
-                                                i32.and
-                                                if (result f64) ;; label = @23
-                                                  f64.const 0x1p+0 (;=1;)
-                                                else
-                                                  f64.const 0x1.8p+0 (;=1.5;)
-                                                end
-                                              end
-                                              local.set $52
-                                              local.get $22
-                                              local.get $6
-                                              i32.div_u
-                                              i32.const 1
-                                              i32.and
-                                              if (result f64) ;; label = @22
-                                                f64.const 0x1.0000000000001p+53 (;=9007199254740994;)
-                                              else
-                                                f64.const 0x1p+53 (;=9007199254740992;)
-                                              end
-                                              local.set $53
-                                              block $label$190 ;; label = @22
-                                                local.get $24
-                                                if ;; label = @23
-                                                  block ;; label = @24
-                                                    local.get $26
-                                                    i32.load8_s
-                                                    i32.const 45
-                                                    i32.ne
-                                                    br_if 2 (;@22;)
-                                                    local.get $53
-                                                    f64.neg
-                                                    local.set $53
-                                                    local.get $52
-                                                    f64.neg
-                                                    local.set $52
-                                                  end
-                                                end
-                                              end
-                                              local.get $8
-                                              local.get $22
-                                              local.get $14
-                                              i32.sub
-                                              local.tee $14
-                                              i32.store
-                                              local.get $53
-                                              local.get $52
-                                              f64.add
-                                              local.get $53
-                                              f64.eq
-                                              br_if 2 (;@19;)
-                                              local.get $8
-                                              local.get $14
-                                              local.get $6
-                                              i32.add
-                                              local.tee $5
-                                              i32.store
-                                              local.get $5
-                                              i32.const 999999999
-                                              i32.gt_u
-                                              if ;; label = @22
-                                                loop $label$193 ;; label = @23
-                                                  local.get $8
-                                                  i32.const 0
-                                                  i32.store
-                                                  local.get $8
-                                                  i32.const -4
-                                                  i32.add
-                                                  local.tee $8
-                                                  local.get $1
-                                                  i32.lt_u
-                                                  if ;; label = @24
-                                                    local.get $1
-                                                    i32.const -4
-                                                    i32.add
-                                                    local.tee $1
-                                                    i32.const 0
-                                                    i32.store
-                                                  end
-                                                  local.get $8
-                                                  local.get $8
-                                                  i32.load
-                                                  i32.const 1
-                                                  i32.add
-                                                  local.tee $5
-                                                  i32.store
-                                                  local.get $5
-                                                  i32.const 999999999
-                                                  i32.gt_u
-                                                  br_if 0 (;@23;)
-                                                end
-                                              end
-                                              local.get $25
-                                              local.get $1
-                                              i32.sub
-                                              i32.const 2
-                                              i32.shr_s
-                                              i32.const 9
-                                              i32.mul
-                                              local.set $5
-                                              local.get $1
-                                              i32.load
-                                              local.tee $14
-                                              i32.const 10
-                                              i32.lt_u
-                                              br_if 2 (;@19;)
-                                              i32.const 10
-                                              local.set $6
-                                              loop $label$195 ;; label = @22
-                                                local.get $5
-                                                i32.const 1
-                                                i32.add
-                                                local.set $5
-                                                local.get $14
-                                                local.get $6
-                                                i32.const 10
-                                                i32.mul
-                                                local.tee $6
-                                                i32.ge_u
-                                                br_if 0 (;@22;)
-                                              end
-                                            end
-                                          end
-                                        end
-                                        local.get $1
-                                        local.set $14
-                                        local.get $5
-                                        local.set $6
-                                        local.get $13
-                                        local.get $8
-                                        i32.const 4
-                                        i32.add
-                                        local.tee $8
-                                        i32.le_u
-                                        if ;; label = @19
-                                          local.get $13
-                                          local.set $8
-                                        end
-                                      end
-                                    else
-                                      block ;; label = @18
-                                        local.get $1
-                                        local.set $14
-                                        local.get $5
-                                        local.set $6
-                                        local.get $13
-                                        local.set $8
-                                      end
-                                    end
-                                    i32.const 0
-                                    local.get $6
-                                    i32.sub
-                                    local.set $32
-                                    loop $label$198 ;; label = @17
-                                      block $label$199 ;; label = @18
-                                        local.get $8
-                                        local.get $14
-                                        i32.le_u
-                                        if ;; label = @19
-                                          block ;; label = @20
-                                            i32.const 0
-                                            local.set $22
-                                            br 2 (;@18;)
-                                          end
-                                        end
-                                        local.get $8
-                                        i32.const -4
-                                        i32.add
-                                        local.tee $1
-                                        i32.load
-                                        if ;; label = @19
-                                          i32.const 1
-                                          local.set $22
-                                        else
-                                          block ;; label = @20
-                                            local.get $1
-                                            local.set $8
-                                            br 3 (;@17;)
-                                          end
-                                        end
-                                      end
-                                    end
-                                    block $label$203 ;; label = @17
-                                      local.get $29
-                                      if ;; label = @18
-                                        block ;; label = @19
-                                          local.get $35
-                                          i32.const 1
-                                          i32.and
-                                          i32.const 1
-                                          i32.xor
-                                          local.get $18
-                                          i32.add
-                                          local.tee $1
-                                          local.get $6
-                                          i32.gt_s
-                                          local.get $6
-                                          i32.const -5
-                                          i32.gt_s
-                                          i32.and
-                                          if (result i32) ;; label = @20
-                                            block (result i32) ;; label = @21
-                                              local.get $9
-                                              i32.const -1
-                                              i32.add
-                                              local.set $5
-                                              local.get $1
-                                              i32.const -1
-                                              i32.add
-                                              local.get $6
-                                              i32.sub
-                                            end
-                                          else
-                                            block (result i32) ;; label = @21
-                                              local.get $9
-                                              i32.const -2
-                                              i32.add
-                                              local.set $5
-                                              local.get $1
-                                              i32.const -1
-                                              i32.add
-                                            end
-                                          end
-                                          local.set $1
-                                          local.get $12
-                                          i32.const 8
-                                          i32.and
-                                          local.tee $13
-                                          br_if 2 (;@17;)
-                                          block $label$207 ;; label = @20
-                                            local.get $22
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                local.get $8
-                                                i32.const -4
-                                                i32.add
-                                                i32.load
-                                                local.tee $18
-                                                i32.eqz
-                                                if ;; label = @23
-                                                  block ;; label = @24
-                                                    i32.const 9
-                                                    local.set $9
-                                                    br 4 (;@20;)
-                                                  end
-                                                end
-                                                local.get $18
-                                                i32.const 10
-                                                i32.rem_u
-                                                if ;; label = @23
-                                                  block ;; label = @24
-                                                    i32.const 0
-                                                    local.set $9
-                                                    br 4 (;@20;)
-                                                  end
-                                                else
-                                                  block ;; label = @24
-                                                    i32.const 10
-                                                    local.set $13
-                                                    i32.const 0
-                                                    local.set $9
-                                                  end
-                                                end
-                                                loop $label$212 ;; label = @23
-                                                  local.get $9
-                                                  i32.const 1
-                                                  i32.add
-                                                  local.set $9
-                                                  local.get $18
-                                                  local.get $13
-                                                  i32.const 10
-                                                  i32.mul
-                                                  local.tee $13
-                                                  i32.rem_u
-                                                  i32.eqz
-                                                  br_if 0 (;@23;)
-                                                end
-                                              end
-                                            else
-                                              i32.const 9
-                                              local.set $9
-                                            end
-                                          end
-                                          local.get $8
-                                          local.get $25
-                                          i32.sub
-                                          i32.const 2
-                                          i32.shr_s
-                                          i32.const 9
-                                          i32.mul
-                                          i32.const -9
-                                          i32.add
-                                          local.set $18
-                                          local.get $5
-                                          i32.const 32
-                                          i32.or
-                                          i32.const 102
-                                          i32.eq
-                                          if ;; label = @20
-                                            block ;; label = @21
-                                              i32.const 0
-                                              local.set $13
-                                              local.get $1
-                                              local.get $18
-                                              local.get $9
-                                              i32.sub
-                                              local.tee $9
-                                              i32.const 0
-                                              i32.lt_s
-                                              if (result i32) ;; label = @22
-                                                i32.const 0
-                                                local.tee $9
-                                              else
-                                                local.get $9
-                                              end
-                                              i32.ge_s
-                                              if ;; label = @22
-                                                local.get $9
-                                                local.set $1
-                                              end
-                                            end
-                                          else
-                                            block ;; label = @21
-                                              i32.const 0
-                                              local.set $13
-                                              local.get $1
-                                              local.get $18
-                                              local.get $6
-                                              i32.add
-                                              local.get $9
-                                              i32.sub
-                                              local.tee $9
-                                              i32.const 0
-                                              i32.lt_s
-                                              if (result i32) ;; label = @22
-                                                i32.const 0
-                                                local.tee $9
-                                              else
-                                                local.get $9
-                                              end
-                                              i32.ge_s
-                                              if ;; label = @22
-                                                local.get $9
-                                                local.set $1
-                                              end
-                                            end
-                                          end
-                                        end
-                                      else
-                                        block ;; label = @19
-                                          local.get $12
-                                          i32.const 8
-                                          i32.and
-                                          local.set $13
-                                          local.get $18
-                                          local.set $1
-                                          local.get $9
-                                          local.set $5
-                                        end
-                                      end
-                                    end
-                                    local.get $5
-                                    i32.const 32
-                                    i32.or
-                                    i32.const 102
-                                    i32.eq
-                                    local.tee $25
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        i32.const 0
-                                        local.set $9
-                                        local.get $6
-                                        i32.const 0
-                                        i32.le_s
-                                        if ;; label = @19
-                                          i32.const 0
-                                          local.set $6
-                                        end
-                                      end
-                                    else
-                                      block ;; label = @18
-                                        local.get $28
-                                        local.get $6
-                                        i32.const 0
-                                        i32.lt_s
-                                        if (result i32) ;; label = @19
-                                          local.get $32
-                                        else
-                                          local.get $6
-                                        end
-                                        i64.extend_i32_s
-                                        local.get $33
-                                        call $23
-                                        local.tee $9
-                                        i32.sub
-                                        i32.const 2
-                                        i32.lt_s
-                                        if ;; label = @19
-                                          loop $label$229 ;; label = @20
-                                            local.get $9
-                                            i32.const -1
-                                            i32.add
-                                            local.tee $9
-                                            i32.const 48
-                                            i32.store8
-                                            local.get $28
-                                            local.get $9
-                                            i32.sub
-                                            i32.const 2
-                                            i32.lt_s
-                                            br_if 0 (;@20;)
-                                          end
-                                        end
-                                        local.get $9
-                                        i32.const -1
-                                        i32.add
-                                        local.get $6
-                                        i32.const 31
-                                        i32.shr_s
-                                        i32.const 2
-                                        i32.and
-                                        i32.const 43
-                                        i32.add
-                                        i32.store8
-                                        local.get $9
-                                        i32.const -2
-                                        i32.add
-                                        local.tee $6
-                                        local.get $5
-                                        i32.store8
-                                        local.get $6
-                                        local.set $9
-                                        local.get $28
-                                        local.get $6
-                                        i32.sub
-                                        local.set $6
-                                      end
-                                    end
-                                    local.get $0
-                                    i32.const 32
-                                    local.get $10
-                                    local.get $24
-                                    i32.const 1
-                                    i32.add
-                                    local.get $1
-                                    i32.add
-                                    local.get $1
-                                    local.get $13
-                                    i32.or
-                                    local.tee $29
-                                    i32.const 0
-                                    i32.ne
-                                    i32.add
-                                    local.get $6
-                                    i32.add
-                                    local.tee $18
-                                    local.get $12
-                                    call $25
-                                    local.get $0
-                                    i32.load
-                                    i32.const 32
-                                    i32.and
-                                    i32.eqz
-                                    if ;; label = @17
-                                      local.get $26
-                                      local.get $24
-                                      local.get $0
-                                      call $21
-                                      drop
-                                    end
-                                    local.get $0
-                                    i32.const 48
-                                    local.get $10
-                                    local.get $18
-                                    local.get $12
-                                    i32.const 65536
-                                    i32.xor
-                                    call $25
-                                    block $label$231 ;; label = @17
-                                      local.get $25
-                                      if ;; label = @18
-                                        block ;; label = @19
-                                          local.get $14
-                                          local.get $7
-                                          i32.gt_u
-                                          if (result i32) ;; label = @20
-                                            local.get $7
-                                          else
-                                            local.get $14
-                                          end
-                                          local.tee $9
-                                          local.set $6
-                                          loop $label$235 ;; label = @20
-                                            local.get $6
-                                            i32.load
-                                            i64.extend_i32_u
-                                            local.get $31
-                                            call $23
-                                            local.set $5
-                                            block $label$236 ;; label = @21
-                                              local.get $6
-                                              local.get $9
-                                              i32.eq
-                                              if ;; label = @22
-                                                block ;; label = @23
-                                                  local.get $5
-                                                  local.get $31
-                                                  i32.ne
-                                                  br_if 2 (;@21;)
-                                                  local.get $34
-                                                  i32.const 48
-                                                  i32.store8
-                                                  local.get $34
-                                                  local.set $5
-                                                end
-                                              else
-                                                block ;; label = @23
-                                                  local.get $5
-                                                  local.get $19
-                                                  i32.le_u
-                                                  br_if 2 (;@21;)
-                                                  local.get $19
-                                                  i32.const 48
-                                                  local.get $5
-                                                  local.get $27
-                                                  i32.sub
-                                                  call $41
-                                                  drop
-                                                  loop $label$239 ;; label = @24
-                                                    local.get $5
-                                                    i32.const -1
-                                                    i32.add
-                                                    local.tee $5
-                                                    local.get $19
-                                                    i32.gt_u
-                                                    br_if 0 (;@24;)
-                                                  end
-                                                end
-                                              end
-                                            end
-                                            local.get $0
-                                            i32.load
-                                            i32.const 32
-                                            i32.and
-                                            i32.eqz
-                                            if ;; label = @21
-                                              local.get $5
-                                              local.get $41
-                                              local.get $5
-                                              i32.sub
-                                              local.get $0
-                                              call $21
-                                              drop
-                                            end
-                                            local.get $6
-                                            i32.const 4
-                                            i32.add
-                                            local.tee $5
-                                            local.get $7
-                                            i32.le_u
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                local.get $5
-                                                local.set $6
-                                                br 2 (;@20;)
-                                              end
-                                            end
-                                          end
-                                          block $label$242 ;; label = @20
-                                            local.get $29
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                local.get $0
-                                                i32.load
-                                                i32.const 32
-                                                i32.and
-                                                br_if 2 (;@20;)
-                                                i32.const 1687
-                                                i32.const 1
-                                                local.get $0
-                                                call $21
-                                                drop
-                                              end
-                                            end
-                                          end
-                                          local.get $1
-                                          i32.const 0
-                                          i32.gt_s
-                                          local.get $5
-                                          local.get $8
-                                          i32.lt_u
-                                          i32.and
-                                          if ;; label = @20
-                                            loop $label$245 ;; label = @21
-                                              local.get $5
-                                              i32.load
-                                              i64.extend_i32_u
-                                              local.get $31
-                                              call $23
-                                              local.tee $7
-                                              local.get $19
-                                              i32.gt_u
-                                              if ;; label = @22
-                                                block ;; label = @23
-                                                  local.get $19
-                                                  i32.const 48
-                                                  local.get $7
-                                                  local.get $27
-                                                  i32.sub
-                                                  call $41
-                                                  drop
-                                                  loop $label$247 ;; label = @24
-                                                    local.get $7
-                                                    i32.const -1
-                                                    i32.add
-                                                    local.tee $7
-                                                    local.get $19
-                                                    i32.gt_u
-                                                    br_if 0 (;@24;)
-                                                  end
-                                                end
-                                              end
-                                              local.get $0
-                                              i32.load
-                                              i32.const 32
-                                              i32.and
-                                              i32.eqz
-                                              if ;; label = @22
-                                                local.get $7
-                                                local.get $1
-                                                i32.const 9
-                                                i32.gt_s
-                                                if (result i32) ;; label = @23
-                                                  i32.const 9
-                                                else
-                                                  local.get $1
-                                                end
-                                                local.get $0
-                                                call $21
-                                                drop
-                                              end
-                                              local.get $1
-                                              i32.const -9
-                                              i32.add
-                                              local.set $7
-                                              local.get $1
-                                              i32.const 9
-                                              i32.gt_s
-                                              local.get $5
-                                              i32.const 4
-                                              i32.add
-                                              local.tee $5
-                                              local.get $8
-                                              i32.lt_u
-                                              i32.and
-                                              if ;; label = @22
-                                                block ;; label = @23
-                                                  local.get $7
-                                                  local.set $1
-                                                  br 2 (;@21;)
-                                                end
-                                              else
-                                                local.get $7
-                                                local.set $1
-                                              end
-                                            end
-                                          end
-                                          local.get $0
-                                          i32.const 48
-                                          local.get $1
-                                          i32.const 9
-                                          i32.add
-                                          i32.const 9
-                                          i32.const 0
-                                          call $25
-                                        end
-                                      else
-                                        block ;; label = @19
-                                          local.get $14
-                                          i32.const 4
-                                          i32.add
-                                          local.set $5
-                                          local.get $22
-                                          i32.eqz
-                                          if ;; label = @20
-                                            local.get $5
-                                            local.set $8
-                                          end
-                                          local.get $1
-                                          i32.const -1
-                                          i32.gt_s
-                                          if ;; label = @20
-                                            block ;; label = @21
-                                              local.get $13
-                                              i32.eqz
-                                              local.set $13
-                                              local.get $14
-                                              local.set $7
-                                              local.get $1
-                                              local.set $5
-                                              loop $label$256 ;; label = @22
-                                                local.get $7
-                                                i32.load
-                                                i64.extend_i32_u
-                                                local.get $31
-                                                call $23
-                                                local.tee $1
-                                                local.get $31
-                                                i32.eq
-                                                if ;; label = @23
-                                                  block ;; label = @24
-                                                    local.get $34
-                                                    i32.const 48
-                                                    i32.store8
-                                                    local.get $34
-                                                    local.set $1
-                                                  end
-                                                end
-                                                block $label$258 ;; label = @23
-                                                  local.get $7
-                                                  local.get $14
-                                                  i32.eq
-                                                  if ;; label = @24
-                                                    block ;; label = @25
-                                                      local.get $0
-                                                      i32.load
-                                                      i32.const 32
-                                                      i32.and
-                                                      i32.eqz
-                                                      if ;; label = @26
-                                                        local.get $1
-                                                        i32.const 1
-                                                        local.get $0
-                                                        call $21
-                                                        drop
-                                                      end
-                                                      local.get $1
-                                                      i32.const 1
-                                                      i32.add
-                                                      local.set $1
-                                                      local.get $13
-                                                      local.get $5
-                                                      i32.const 1
-                                                      i32.lt_s
-                                                      i32.and
-                                                      br_if 2 (;@23;)
-                                                      local.get $0
-                                                      i32.load
-                                                      i32.const 32
-                                                      i32.and
-                                                      br_if 2 (;@23;)
-                                                      i32.const 1687
-                                                      i32.const 1
-                                                      local.get $0
-                                                      call $21
-                                                      drop
-                                                    end
-                                                  else
-                                                    block ;; label = @25
-                                                      local.get $1
-                                                      local.get $19
-                                                      i32.le_u
-                                                      br_if 2 (;@23;)
-                                                      local.get $19
-                                                      i32.const 48
-                                                      local.get $1
-                                                      local.get $43
-                                                      i32.add
-                                                      call $41
-                                                      drop
-                                                      loop $label$262 ;; label = @26
-                                                        local.get $1
-                                                        i32.const -1
-                                                        i32.add
-                                                        local.tee $1
-                                                        local.get $19
-                                                        i32.gt_u
-                                                        br_if 0 (;@26;)
-                                                      end
-                                                    end
-                                                  end
-                                                end
-                                                local.get $41
-                                                local.get $1
-                                                i32.sub
-                                                local.set $6
-                                                local.get $0
-                                                i32.load
-                                                i32.const 32
-                                                i32.and
-                                                i32.eqz
-                                                if ;; label = @23
-                                                  local.get $1
-                                                  local.get $5
-                                                  local.get $6
-                                                  i32.gt_s
-                                                  if (result i32) ;; label = @24
-                                                    local.get $6
-                                                  else
-                                                    local.get $5
-                                                  end
-                                                  local.get $0
-                                                  call $21
-                                                  drop
-                                                end
-                                                local.get $7
-                                                i32.const 4
-                                                i32.add
-                                                local.tee $7
-                                                local.get $8
-                                                i32.lt_u
-                                                local.get $5
-                                                local.get $6
-                                                i32.sub
-                                                local.tee $5
-                                                i32.const -1
-                                                i32.gt_s
-                                                i32.and
-                                                br_if 0 (;@22;)
-                                                local.get $5
-                                                local.set $1
-                                              end
-                                            end
-                                          end
-                                          local.get $0
-                                          i32.const 48
-                                          local.get $1
-                                          i32.const 18
-                                          i32.add
-                                          i32.const 18
-                                          i32.const 0
-                                          call $25
-                                          local.get $0
-                                          i32.load
-                                          i32.const 32
-                                          i32.and
-                                          br_if 2 (;@17;)
-                                          local.get $9
-                                          local.get $28
-                                          local.get $9
-                                          i32.sub
-                                          local.get $0
-                                          call $21
-                                          drop
-                                        end
-                                      end
-                                    end
-                                    local.get $0
-                                    i32.const 32
-                                    local.get $10
-                                    local.get $18
-                                    local.get $12
-                                    i32.const 8192
-                                    i32.xor
-                                    call $25
-                                    local.get $18
-                                    local.get $10
-                                    i32.ge_s
-                                    if ;; label = @17
-                                      local.get $18
-                                      local.set $10
-                                    end
-                                  end
-                                else
-                                  block ;; label = @16
-                                    local.get $0
-                                    i32.const 32
-                                    local.get $10
-                                    local.get $52
-                                    local.get $52
-                                    f64.ne
-                                    i32.const 0
-                                    i32.or
-                                    local.tee $6
-                                    if (result i32) ;; label = @17
-                                      i32.const 0
-                                      local.tee $24
-                                    else
-                                      local.get $24
-                                    end
-                                    i32.const 3
-                                    i32.add
-                                    local.tee $8
-                                    local.get $7
-                                    call $25
-                                    local.get $0
-                                    i32.load
-                                    local.tee $1
-                                    i32.const 32
-                                    i32.and
-                                    i32.eqz
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        local.get $26
-                                        local.get $24
-                                        local.get $0
-                                        call $21
-                                        drop
-                                        local.get $0
-                                        i32.load
-                                        local.set $1
-                                      end
-                                    end
-                                    local.get $9
-                                    i32.const 32
-                                    i32.and
-                                    i32.const 0
-                                    i32.ne
-                                    local.tee $5
-                                    if (result i32) ;; label = @17
-                                      i32.const 1671
-                                    else
-                                      i32.const 1675
-                                    end
-                                    local.set $7
-                                    local.get $5
-                                    if (result i32) ;; label = @17
-                                      i32.const 1679
-                                    else
-                                      i32.const 1683
-                                    end
-                                    local.set $5
-                                    local.get $6
-                                    i32.eqz
-                                    if ;; label = @17
-                                      local.get $7
-                                      local.set $5
-                                    end
-                                    local.get $1
-                                    i32.const 32
-                                    i32.and
-                                    i32.eqz
-                                    if ;; label = @17
-                                      local.get $5
-                                      i32.const 3
-                                      local.get $0
-                                      call $21
-                                      drop
-                                    end
-                                    local.get $0
-                                    i32.const 32
-                                    local.get $10
-                                    local.get $8
-                                    local.get $12
-                                    i32.const 8192
-                                    i32.xor
-                                    call $25
-                                    local.get $8
-                                    local.get $10
-                                    i32.ge_s
-                                    if ;; label = @17
-                                      local.get $8
-                                      local.set $10
-                                    end
-                                  end
-                                end
-                              end
-                              local.get $11
-                              local.set $1
-                              br 9 (;@4;)
-                            end
-                            local.get $5
-                            local.set $7
-                            i32.const 0
-                            local.set $6
-                            i32.const 1635
-                            local.set $8
-                            local.get $21
-                            local.set $5
-                            br 6 (;@6;)
-                          end
-                          local.get $9
-                          i32.const 32
-                          i32.and
-                          local.set $7
-                          local.get $16
-                          i64.load
-                          local.tee $50
-                          i64.const 0
-                          i64.eq
-                          if (result i32) ;; label = @12
-                            block (result i32) ;; label = @13
-                              i64.const 0
-                              local.set $50
-                              local.get $21
-                            end
-                          else
-                            block (result i32) ;; label = @13
-                              local.get $21
-                              local.set $1
-                              loop $label$280 ;; label = @14
-                                local.get $1
-                                i32.const -1
-                                i32.add
-                                local.tee $1
-                                local.get $50
-                                i32.wrap_i64
-                                i32.const 15
-                                i32.and
-                                i32.const 1619
-                                i32.add
-                                i32.load8_u
-                                local.get $7
-                                i32.or
-                                i32.store8
-                                local.get $50
-                                i64.const 4
-                                i64.shr_u
-                                local.tee $50
-                                i64.const 0
-                                i64.ne
-                                br_if 0 (;@14;)
-                              end
-                              local.get $16
-                              i64.load
-                              local.set $50
-                              local.get $1
-                            end
-                          end
-                          local.set $7
-                          local.get $9
-                          i32.const 4
-                          i32.shr_s
-                          i32.const 1635
-                          i32.add
-                          local.set $8
-                          local.get $12
-                          i32.const 8
-                          i32.and
-                          i32.eqz
-                          local.get $50
-                          i64.const 0
-                          i64.eq
-                          i32.or
-                          local.tee $1
-                          if ;; label = @12
-                            i32.const 1635
-                            local.set $8
-                          end
-                          local.get $1
-                          if (result i32) ;; label = @12
-                            i32.const 0
-                          else
-                            i32.const 2
-                          end
-                          local.set $6
-                          br 4 (;@7;)
-                        end
-                        local.get $50
-                        local.get $21
-                        call $23
-                        local.set $7
-                        br 3 (;@7;)
-                      end
-                      local.get $1
-                      i32.const 0
-                      local.get $5
-                      call $17
-                      local.tee $13
-                      i32.eqz
-                      local.set $14
-                      local.get $13
-                      local.get $1
-                      i32.sub
-                      local.set $8
-                      local.get $1
-                      local.get $5
-                      i32.add
-                      local.set $9
-                      local.get $7
-                      local.set $12
-                      local.get $14
-                      if (result i32) ;; label = @10
-                        local.get $5
-                      else
-                        local.get $8
-                      end
-                      local.set $7
-                      i32.const 0
-                      local.set $6
-                      i32.const 1635
-                      local.set $8
-                      local.get $14
-                      if (result i32) ;; label = @10
-                        local.get $9
-                      else
-                        local.get $13
-                      end
-                      local.set $5
-                      br 3 (;@6;)
-                    end
-                    i32.const 0
-                    local.set $1
-                    i32.const 0
-                    local.set $5
-                    local.get $7
-                    local.set $8
-                    loop $label$288 ;; label = @9
-                      block $label$289 ;; label = @10
-                        local.get $8
-                        i32.load
-                        local.tee $9
-                        i32.eqz
-                        br_if 0 (;@10;)
-                        local.get $36
-                        local.get $9
-                        call $26
-                        local.tee $5
-                        i32.const 0
-                        i32.lt_s
-                        local.get $5
-                        local.get $6
-                        local.get $1
-                        i32.sub
-                        i32.gt_u
-                        i32.or
-                        br_if 0 (;@10;)
-                        local.get $8
-                        i32.const 4
-                        i32.add
-                        local.set $8
-                        local.get $6
-                        local.get $5
-                        local.get $1
-                        i32.add
-                        local.tee $1
-                        i32.gt_u
-                        br_if 1 (;@9;)
-                      end
-                    end
-                    local.get $5
-                    i32.const 0
-                    i32.lt_s
-                    if ;; label = @9
-                      block ;; label = @10
-                        i32.const -1
-                        local.set $15
-                        br 5 (;@5;)
-                      end
-                    end
-                    local.get $0
-                    i32.const 32
-                    local.get $10
-                    local.get $1
-                    local.get $12
-                    call $25
-                    local.get $1
-                    if ;; label = @9
-                      block ;; label = @10
-                        i32.const 0
-                        local.set $5
-                        loop $label$292 ;; label = @11
-                          local.get $7
-                          i32.load
-                          local.tee $8
-                          i32.eqz
-                          br_if 3 (;@8;)
-                          local.get $36
-                          local.get $8
-                          call $26
-                          local.tee $8
-                          local.get $5
-                          i32.add
-                          local.tee $5
-                          local.get $1
-                          i32.gt_s
-                          br_if 3 (;@8;)
-                          local.get $0
-                          i32.load
-                          i32.const 32
-                          i32.and
-                          i32.eqz
-                          if ;; label = @12
-                            local.get $36
-                            local.get $8
-                            local.get $0
-                            call $21
-                            drop
-                          end
-                          local.get $7
-                          i32.const 4
-                          i32.add
-                          local.set $7
-                          local.get $5
-                          local.get $1
-                          i32.lt_u
-                          br_if 0 (;@11;)
-                          br 3 (;@8;)
-                        end
-                      end
-                    else
-                      block ;; label = @10
-                        i32.const 0
-                        local.set $1
-                        br 2 (;@8;)
-                      end
-                    end
-                  end
-                  local.get $0
-                  i32.const 32
-                  local.get $10
-                  local.get $1
-                  local.get $12
-                  i32.const 8192
-                  i32.xor
-                  call $25
-                  local.get $10
-                  local.get $1
-                  i32.le_s
-                  if ;; label = @8
-                    local.get $1
-                    local.set $10
-                  end
-                  local.get $11
-                  local.set $1
-                  br 3 (;@4;)
-                end
-                local.get $12
-                i32.const -65537
-                i32.and
-                local.set $1
-                local.get $5
-                i32.const -1
-                i32.gt_s
-                if ;; label = @7
-                  local.get $1
-                  local.set $12
-                end
-                local.get $5
-                local.get $16
-                i64.load
-                i64.const 0
-                i64.ne
-                local.tee $9
-                i32.or
-                if (result i32) ;; label = @7
-                  block (result i32) ;; label = @8
-                    local.get $7
-                    local.set $1
-                    local.get $5
-                    local.get $9
-                    i32.const 1
-                    i32.and
-                    i32.const 1
-                    i32.xor
-                    local.get $38
-                    local.get $7
-                    i32.sub
-                    i32.add
-                    local.tee $7
-                    i32.gt_s
-                    if ;; label = @9
-                      local.get $5
-                      local.set $7
-                    end
-                    local.get $21
-                  end
-                else
-                  block (result i32) ;; label = @8
-                    local.get $21
-                    local.set $1
-                    i32.const 0
-                    local.set $7
-                    local.get $21
-                  end
-                end
-                local.set $5
-              end
-              local.get $0
-              i32.const 32
-              local.get $10
-              local.get $7
-              local.get $5
-              local.get $1
-              i32.sub
-              local.tee $9
-              i32.lt_s
-              if (result i32) ;; label = @6
-                local.get $9
-                local.tee $7
-              else
-                local.get $7
-              end
-              local.get $6
-              i32.add
-              local.tee $5
-              i32.lt_s
-              if (result i32) ;; label = @6
-                local.get $5
-                local.tee $10
-              else
-                local.get $10
-              end
-              local.get $5
-              local.get $12
-              call $25
-              local.get $0
-              i32.load
-              i32.const 32
-              i32.and
-              i32.eqz
-              if ;; label = @6
-                local.get $8
-                local.get $6
-                local.get $0
-                call $21
-                drop
-              end
-              local.get $0
-              i32.const 48
-              local.get $10
-              local.get $5
-              local.get $12
-              i32.const 65536
-              i32.xor
-              call $25
-              local.get $0
-              i32.const 48
-              local.get $7
-              local.get $9
-              i32.const 0
-              call $25
-              local.get $0
-              i32.load
-              i32.const 32
-              i32.and
-              i32.eqz
-              if ;; label = @6
-                local.get $1
-                local.get $9
-                local.get $0
-                call $21
-                drop
-              end
-              local.get $0
-              i32.const 32
-              local.get $10
-              local.get $5
-              local.get $12
-              i32.const 8192
-              i32.xor
-              call $25
-              local.get $11
-              local.set $1
-              br 1 (;@4;)
-            end
-          end
-          br 1 (;@2;)
-        end
-        local.get $0
-        i32.eqz
-        if ;; label = @3
-          local.get $17
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 1
-              local.set $0
-              loop $label$308 ;; label = @6
-                local.get $4
-                local.get $0
-                i32.const 2
-                i32.shl
-                i32.add
-                i32.load
-                local.tee $1
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $3
-                    local.get $0
-                    i32.const 3
-                    i32.shl
-                    i32.add
-                    local.get $1
-                    local.get $2
-                    call $22
-                    local.get $0
-                    i32.const 1
-                    i32.add
-                    local.tee $0
-                    i32.const 10
-                    i32.lt_s
-                    br_if 2 (;@6;)
-                    i32.const 1
-                    local.set $15
-                    br 6 (;@2;)
-                  end
-                end
-              end
-              loop $label$310 ;; label = @6
-                local.get $4
-                local.get $0
-                i32.const 2
-                i32.shl
-                i32.add
-                i32.load
-                if ;; label = @7
-                  block ;; label = @8
-                    i32.const -1
-                    local.set $15
-                    br 6 (;@2;)
-                  end
-                end
-                local.get $0
-                i32.const 1
-                i32.add
-                local.tee $0
-                i32.const 10
-                i32.lt_s
-                br_if 0 (;@6;)
-                i32.const 1
-                local.set $15
-              end
-            end
-          else
-            i32.const 0
-            local.set $15
-          end
-        end
-      end
-      local.get $23
-      global.set $global$1
-      local.get $15
-    end
-  )
-  (func $20 (;33;) (type $1) (param $0 i32) (result i32)
-    i32.const 0
-  )
-  (func $21 (;34;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32)
-    block $label$1 (result i32) ;; label = @1
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          local.get $2
-          i32.const 16
-          i32.add
-          local.tee $4
-          i32.load
-          local.tee $3
-          br_if 0 (;@3;)
-          local.get $2
-          call $30
-          if ;; label = @4
-            i32.const 0
-            local.set $3
-          else
-            block ;; label = @5
-              local.get $4
-              i32.load
-              local.set $3
-              br 2 (;@3;)
-            end
-          end
-          br 1 (;@2;)
-        end
-        local.get $3
-        local.get $2
-        i32.const 20
-        i32.add
-        local.tee $5
-        i32.load
-        local.tee $4
-        i32.sub
-        local.get $1
-        i32.lt_u
-        if ;; label = @3
-          block ;; label = @4
-            local.get $2
-            local.get $0
-            local.get $1
-            local.get $2
-            i32.load offset=36
-            i32.const 3
-            i32.and
-            i32.const 2
-            i32.add
-            call_indirect (type $0)
-            local.set $3
-            br 2 (;@2;)
-          end
-        end
-        block $label$7 (result i32) ;; label = @3
-          local.get $2
-          i32.load8_s offset=75
-          i32.const -1
-          i32.gt_s
-          if (result i32) ;; label = @4
-            block (result i32) ;; label = @5
-              local.get $1
-              local.set $3
-              loop $label$9 ;; label = @6
-                i32.const 0
-                local.get $3
-                i32.eqz
-                br_if 3 (;@3;)
-                drop
-                local.get $0
-                local.get $3
-                i32.const -1
-                i32.add
-                local.tee $6
-                i32.add
-                i32.load8_s
-                i32.const 10
-                i32.ne
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $6
-                    local.set $3
-                    br 2 (;@6;)
-                  end
-                end
-              end
-              local.get $2
-              local.get $0
-              local.get $3
-              local.get $2
-              i32.load offset=36
-              i32.const 3
-              i32.and
-              i32.const 2
-              i32.add
-              call_indirect (type $0)
-              local.get $3
-              i32.lt_u
-              br_if 3 (;@2;)
-              local.get $5
-              i32.load
-              local.set $4
-              local.get $1
-              local.get $3
-              i32.sub
-              local.set $1
-              local.get $0
-              local.get $3
-              i32.add
-              local.set $0
-              local.get $3
-            end
-          else
-            i32.const 0
-          end
-        end
-        local.set $2
-        local.get $4
-        local.get $0
-        local.get $1
-        call $42
-        drop
-        local.get $5
-        local.get $5
-        i32.load
-        local.get $1
-        i32.add
-        i32.store
-        local.get $2
-        local.get $1
-        i32.add
-        local.set $3
-      end
-      local.get $3
-    end
-  )
-  (func $22 (;35;) (type $8) (param $0 i32) (param $1 i32) (param $2 i32)
-    (local $3 i32) (local $4 i64) (local $5 f64)
-    block $label$1 ;; label = @1
-      local.get $1
-      i32.const 20
-      i32.le_u
-      if ;; label = @2
-        block $label$3 ;; label = @3
-          block $label$4 ;; label = @4
-            block $label$5 ;; label = @5
-              block $label$6 ;; label = @6
-                block $label$7 ;; label = @7
-                  block $label$8 ;; label = @8
-                    block $label$9 ;; label = @9
-                      block $label$10 ;; label = @10
-                        block $label$11 ;; label = @11
-                          block $label$12 ;; label = @12
-                            block $label$13 ;; label = @13
-                              local.get $1
-                              i32.const 9
-                              i32.sub
-                              br_table 0 (;@13;) 1 (;@12;) 2 (;@11;) 3 (;@10;) 4 (;@9;) 5 (;@8;) 6 (;@7;) 7 (;@6;) 8 (;@5;) 9 (;@4;) 10 (;@3;)
-                            end
-                            local.get $2
-                            i32.load
-                            i32.const 3
-                            i32.add
-                            i32.const -4
-                            i32.and
-                            local.tee $1
-                            i32.load
-                            local.set $3
-                            local.get $2
-                            local.get $1
-                            i32.const 4
-                            i32.add
-                            i32.store
-                            local.get $0
-                            local.get $3
-                            i32.store
-                            br 11 (;@1;)
-                          end
-                          local.get $2
-                          i32.load
-                          i32.const 3
-                          i32.add
-                          i32.const -4
-                          i32.and
-                          local.tee $1
-                          i32.load
-                          local.set $3
-                          local.get $2
-                          local.get $1
-                          i32.const 4
-                          i32.add
-                          i32.store
-                          local.get $0
-                          local.get $3
-                          i64.extend_i32_s
-                          i64.store
-                          br 10 (;@1;)
-                        end
-                        local.get $2
-                        i32.load
-                        i32.const 3
-                        i32.add
-                        i32.const -4
-                        i32.and
-                        local.tee $1
-                        i32.load
-                        local.set $3
-                        local.get $2
-                        local.get $1
-                        i32.const 4
-                        i32.add
-                        i32.store
-                        local.get $0
-                        local.get $3
-                        i64.extend_i32_u
-                        i64.store
-                        br 9 (;@1;)
-                      end
-                      local.get $2
-                      i32.load
-                      i32.const 7
-                      i32.add
-                      i32.const -8
-                      i32.and
-                      local.tee $1
-                      i64.load
-                      local.set $4
-                      local.get $2
-                      local.get $1
-                      i32.const 8
-                      i32.add
-                      i32.store
-                      local.get $0
-                      local.get $4
-                      i64.store
-                      br 8 (;@1;)
-                    end
-                    local.get $2
-                    i32.load
-                    i32.const 3
-                    i32.add
-                    i32.const -4
-                    i32.and
-                    local.tee $1
-                    i32.load
-                    local.set $3
-                    local.get $2
-                    local.get $1
-                    i32.const 4
-                    i32.add
-                    i32.store
-                    local.get $0
-                    local.get $3
-                    i32.const 65535
-                    i32.and
-                    i32.const 16
-                    i32.shl
-                    i32.const 16
-                    i32.shr_s
-                    i64.extend_i32_s
-                    i64.store
-                    br 7 (;@1;)
-                  end
-                  local.get $2
-                  i32.load
-                  i32.const 3
-                  i32.add
-                  i32.const -4
-                  i32.and
-                  local.tee $1
-                  i32.load
-                  local.set $3
-                  local.get $2
-                  local.get $1
-                  i32.const 4
-                  i32.add
-                  i32.store
-                  local.get $0
-                  local.get $3
-                  i32.const 65535
-                  i32.and
-                  i64.extend_i32_u
-                  i64.store
-                  br 6 (;@1;)
-                end
-                local.get $2
-                i32.load
-                i32.const 3
-                i32.add
-                i32.const -4
-                i32.and
-                local.tee $1
-                i32.load
-                local.set $3
-                local.get $2
-                local.get $1
-                i32.const 4
-                i32.add
-                i32.store
-                local.get $0
-                local.get $3
-                i32.const 255
-                i32.and
-                i32.const 24
-                i32.shl
-                i32.const 24
-                i32.shr_s
-                i64.extend_i32_s
-                i64.store
-                br 5 (;@1;)
-              end
-              local.get $2
-              i32.load
-              i32.const 3
-              i32.add
-              i32.const -4
-              i32.and
-              local.tee $1
-              i32.load
-              local.set $3
-              local.get $2
-              local.get $1
-              i32.const 4
-              i32.add
-              i32.store
-              local.get $0
-              local.get $3
-              i32.const 255
-              i32.and
-              i64.extend_i32_u
-              i64.store
-              br 4 (;@1;)
-            end
-            local.get $2
-            i32.load
-            i32.const 7
-            i32.add
-            i32.const -8
-            i32.and
-            local.tee $1
-            f64.load
-            local.set $5
-            local.get $2
-            local.get $1
-            i32.const 8
-            i32.add
-            i32.store
-            local.get $0
-            local.get $5
-            f64.store
-            br 3 (;@1;)
-          end
-          local.get $2
-          i32.load
-          i32.const 7
-          i32.add
-          i32.const -8
-          i32.and
-          local.tee $1
-          f64.load
-          local.set $5
-          local.get $2
-          local.get $1
-          i32.const 8
-          i32.add
-          i32.store
-          local.get $0
-          local.get $5
-          f64.store
-        end
-      end
-    end
-  )
-  (func $23 (;36;) (type $9) (param $0 i64) (param $1 i32) (result i32)
-    (local $2 i32) (local $3 i32) (local $4 i64)
-    block $label$1 (result i32) ;; label = @1
-      local.get $0
-      i32.wrap_i64
-      local.set $2
-      local.get $0
-      i64.const 4294967295
-      i64.gt_u
-      if ;; label = @2
-        block ;; label = @3
-          loop $label$3 ;; label = @4
-            local.get $1
-            i32.const -1
-            i32.add
-            local.tee $1
-            local.get $0
-            i64.const 10
-            i64.rem_u
-            i64.const 48
-            i64.or
-            i64.store8
-            local.get $0
-            i64.const 10
-            i64.div_u
-            local.set $4
-            local.get $0
-            i64.const 42949672959
-            i64.gt_u
-            if ;; label = @5
-              block ;; label = @6
-                local.get $4
-                local.set $0
-                br 2 (;@4;)
-              end
-            end
-          end
-          local.get $4
-          i32.wrap_i64
-          local.set $2
-        end
-      end
-      local.get $2
-      if ;; label = @2
-        loop $label$6 ;; label = @3
-          local.get $1
-          i32.const -1
-          i32.add
-          local.tee $1
-          local.get $2
-          i32.const 10
-          i32.rem_u
-          i32.const 48
-          i32.or
-          i32.store8
-          local.get $2
-          i32.const 10
-          i32.div_u
-          local.set $3
-          local.get $2
-          i32.const 10
-          i32.ge_u
-          if ;; label = @4
-            block ;; label = @5
-              local.get $3
-              local.set $2
-              br 2 (;@3;)
-            end
-          end
-        end
-      end
-      local.get $1
-    end
-  )
-  (func $24 (;37;) (type $1) (param $0 i32) (result i32)
-    (local $1 i32) (local $2 i32)
-    block $label$1 (result i32) ;; label = @1
-      i32.const 0
-      local.set $1
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          block $label$4 ;; label = @4
-            loop $label$5 ;; label = @5
-              local.get $1
-              i32.const 1689
-              i32.add
-              i32.load8_u
-              local.get $0
-              i32.eq
-              br_if 1 (;@4;)
-              local.get $1
-              i32.const 1
-              i32.add
-              local.tee $1
-              i32.const 87
-              i32.ne
-              br_if 0 (;@5;)
-              i32.const 87
-              local.set $1
-              i32.const 1777
-              local.set $0
-              br 2 (;@3;)
-            end
-          end
-          local.get $1
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 1777
-              local.set $0
-              br 2 (;@3;)
-            end
-          else
-            i32.const 1777
-            local.set $0
-          end
-          br 1 (;@2;)
-        end
-        loop $label$8 ;; label = @3
-          local.get $0
-          local.set $2
-          loop $label$9 ;; label = @4
-            local.get $2
-            i32.const 1
-            i32.add
-            local.set $0
-            local.get $2
-            i32.load8_s
-            if ;; label = @5
-              block ;; label = @6
-                local.get $0
-                local.set $2
-                br 2 (;@4;)
-              end
-            end
-          end
-          local.get $1
-          i32.const -1
-          i32.add
-          local.tee $1
-          br_if 0 (;@3;)
-        end
-      end
-      local.get $0
-    end
-  )
-  (func $25 (;38;) (type $10) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32)
-    (local $5 i32) (local $6 i32) (local $7 i32)
-    block $label$1 ;; label = @1
-      global.get $global$1
-      local.set $7
-      global.get $global$1
-      i32.const 256
-      i32.add
-      global.set $global$1
-      local.get $7
-      local.set $6
-      block $label$2 ;; label = @2
-        local.get $2
-        local.get $3
-        i32.gt_s
-        local.get $4
-        i32.const 73728
-        i32.and
-        i32.eqz
-        i32.and
-        if ;; label = @3
-          block ;; label = @4
-            local.get $6
-            local.get $1
-            local.get $2
-            local.get $3
-            i32.sub
-            local.tee $5
-            i32.const 256
-            i32.gt_u
-            if (result i32) ;; label = @5
-              i32.const 256
-            else
-              local.get $5
-            end
-            call $41
-            drop
-            local.get $0
-            i32.load
-            local.tee $1
-            i32.const 32
-            i32.and
-            i32.eqz
-            local.set $4
-            local.get $5
-            i32.const 255
-            i32.gt_u
-            if ;; label = @5
-              block ;; label = @6
-                loop $label$7 ;; label = @7
-                  local.get $4
-                  if ;; label = @8
-                    block ;; label = @9
-                      local.get $6
-                      i32.const 256
-                      local.get $0
-                      call $21
-                      drop
-                      local.get $0
-                      i32.load
-                      local.set $1
-                    end
-                  end
-                  local.get $1
-                  i32.const 32
-                  i32.and
-                  i32.eqz
-                  local.set $4
-                  local.get $5
-                  i32.const -256
-                  i32.add
-                  local.tee $5
-                  i32.const 255
-                  i32.gt_u
-                  br_if 0 (;@7;)
-                end
-                local.get $4
-                i32.eqz
-                br_if 4 (;@2;)
-                local.get $2
-                local.get $3
-                i32.sub
-                i32.const 255
-                i32.and
-                local.set $5
-              end
-            else
-              local.get $4
-              i32.eqz
-              br_if 3 (;@2;)
-            end
-            local.get $6
-            local.get $5
-            local.get $0
-            call $21
-            drop
-          end
-        end
-      end
-      local.get $7
-      global.set $global$1
-    end
-  )
-  (func $26 (;39;) (type $4) (param $0 i32) (param $1 i32) (result i32)
-    local.get $0
-    if (result i32) ;; label = @1
-      local.get $0
-      local.get $1
-      i32.const 0
-      call $29
-    else
-      i32.const 0
-    end
-  )
-  (func $27 (;40;) (type $11) (param $0 f64) (param $1 i32) (result f64)
-    local.get $0
-    local.get $1
-    call $28
-  )
-  (func $28 (;41;) (type $11) (param $0 f64) (param $1 i32) (result f64)
-    (local $2 i64) (local $3 i64)
-    block $label$1 (result f64) ;; label = @1
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          block $label$4 ;; label = @4
-            block $label$5 ;; label = @5
-              local.get $0
-              i64.reinterpret_f64
-              local.tee $2
-              i64.const 52
-              i64.shr_u
-              local.tee $3
-              i32.wrap_i64
-              i32.const 65535
-              i32.and
-              i32.const 2047
-              i32.and
-              i32.const 16
-              i32.shl
-              i32.const 16
-              i32.shr_s
-              i32.const 0
-              i32.sub
-              br_table 0 (;@5;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 1 (;@4;) 2 (;@3;)
-            end
-            local.get $1
-            local.get $0
-            f64.const 0x0p+0 (;=0;)
-            f64.ne
-            if (result i32) ;; label = @5
-              block (result i32) ;; label = @6
-                local.get $0
-                f64.const 0x1p+64 (;=18446744073709552000;)
-                f64.mul
-                local.get $1
-                call $28
-                local.set $0
-                local.get $1
-                i32.load
-                i32.const -64
-                i32.add
-              end
-            else
-              i32.const 0
-            end
-            i32.store
-            br 2 (;@2;)
-          end
-          br 1 (;@2;)
-        end
-        local.get $1
-        local.get $3
-        i32.wrap_i64
-        i32.const 2047
-        i32.and
-        i32.const -1022
-        i32.add
-        i32.store
-        local.get $2
-        i64.const -9218868437227405313
-        i64.and
-        i64.const 4602678819172646912
-        i64.or
-        f64.reinterpret_i64
-        local.set $0
-      end
-      local.get $0
-    end
-  )
-  (func $29 (;42;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    block $label$1 (result i32) ;; label = @1
-      local.get $0
-      if (result i32) ;; label = @2
-        block (result i32) ;; label = @3
-          local.get $1
-          i32.const 128
-          i32.lt_u
-          if ;; label = @4
-            block ;; label = @5
-              local.get $0
-              local.get $1
-              i32.store8
-              i32.const 1
-              br 4 (;@1;)
-            end
-          end
-          local.get $1
-          i32.const 2048
-          i32.lt_u
-          if ;; label = @4
-            block ;; label = @5
-              local.get $0
-              local.get $1
-              i32.const 6
-              i32.shr_u
-              i32.const 192
-              i32.or
-              i32.store8
-              local.get $0
-              local.get $1
-              i32.const 63
-              i32.and
-              i32.const 128
-              i32.or
-              i32.store8 offset=1
-              i32.const 2
-              br 4 (;@1;)
-            end
-          end
-          local.get $1
-          i32.const 55296
-          i32.lt_u
-          local.get $1
-          i32.const -8192
-          i32.and
-          i32.const 57344
-          i32.eq
-          i32.or
-          if ;; label = @4
-            block ;; label = @5
-              local.get $0
-              local.get $1
-              i32.const 12
-              i32.shr_u
-              i32.const 224
-              i32.or
-              i32.store8
-              local.get $0
-              local.get $1
-              i32.const 6
-              i32.shr_u
-              i32.const 63
-              i32.and
-              i32.const 128
-              i32.or
-              i32.store8 offset=1
-              local.get $0
-              local.get $1
-              i32.const 63
-              i32.and
-              i32.const 128
-              i32.or
-              i32.store8 offset=2
-              i32.const 3
-              br 4 (;@1;)
-            end
-          end
-          local.get $1
-          i32.const -65536
-          i32.add
-          i32.const 1048576
-          i32.lt_u
-          if (result i32) ;; label = @4
-            block (result i32) ;; label = @5
-              local.get $0
-              local.get $1
-              i32.const 18
-              i32.shr_u
-              i32.const 240
-              i32.or
-              i32.store8
-              local.get $0
-              local.get $1
-              i32.const 12
-              i32.shr_u
-              i32.const 63
-              i32.and
-              i32.const 128
-              i32.or
-              i32.store8 offset=1
-              local.get $0
-              local.get $1
-              i32.const 6
-              i32.shr_u
-              i32.const 63
-              i32.and
-              i32.const 128
-              i32.or
-              i32.store8 offset=2
-              local.get $0
-              local.get $1
-              i32.const 63
-              i32.and
-              i32.const 128
-              i32.or
-              i32.store8 offset=3
-              i32.const 4
-            end
-          else
-            block (result i32) ;; label = @5
-              call $12
-              i32.const 84
-              i32.store
-              i32.const -1
-            end
-          end
-        end
-      else
-        i32.const 1
-      end
-    end
-  )
-  (func $30 (;43;) (type $1) (param $0 i32) (result i32)
-    (local $1 i32) (local $2 i32)
-    block $label$1 (result i32) ;; label = @1
-      local.get $0
-      i32.const 74
-      i32.add
-      local.tee $2
-      i32.load8_s
-      local.set $1
-      local.get $2
-      local.get $1
-      i32.const 255
-      i32.add
-      local.get $1
-      i32.or
-      i32.store8
-      local.get $0
-      i32.load
-      local.tee $1
-      i32.const 8
-      i32.and
-      if (result i32) ;; label = @2
-        block (result i32) ;; label = @3
-          local.get $0
-          local.get $1
-          i32.const 32
-          i32.or
-          i32.store
-          i32.const -1
-        end
-      else
-        block (result i32) ;; label = @3
-          local.get $0
-          i32.const 0
-          i32.store offset=8
-          local.get $0
-          i32.const 0
-          i32.store offset=4
-          local.get $0
-          local.get $0
-          i32.load offset=44
-          local.tee $1
-          i32.store offset=28
-          local.get $0
-          local.get $1
-          i32.store offset=20
-          local.get $0
-          local.get $1
-          local.get $0
-          i32.load offset=48
-          i32.add
-          i32.store offset=16
-          i32.const 0
-        end
-      end
-      local.tee $0
-    end
-  )
-  (func $31 (;44;) (type $1) (param $0 i32) (result i32)
-    (local $1 i32) (local $2 i32) (local $3 i32)
-    block $label$1 (result i32) ;; label = @1
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          local.get $0
-          local.tee $2
-          i32.const 3
-          i32.and
-          i32.eqz
-          br_if 0 (;@3;)
-          local.get $2
-          local.set $1
-          loop $label$4 ;; label = @4
-            local.get $0
-            i32.load8_s
-            i32.eqz
-            if ;; label = @5
-              block ;; label = @6
-                local.get $1
-                local.set $0
-                br 4 (;@2;)
-              end
-            end
-            local.get $0
-            i32.const 1
-            i32.add
-            local.tee $0
-            local.tee $1
-            i32.const 3
-            i32.and
-            br_if 0 (;@4;)
-            br 1 (;@3;)
-          end
-        end
-        loop $label$6 ;; label = @3
-          local.get $0
-          i32.const 4
-          i32.add
-          local.set $1
-          local.get $0
-          i32.load
-          local.tee $3
-          i32.const -2139062144
-          i32.and
-          i32.const -2139062144
-          i32.xor
-          local.get $3
-          i32.const -16843009
-          i32.add
-          i32.and
-          i32.eqz
-          if ;; label = @4
-            block ;; label = @5
-              local.get $1
-              local.set $0
-              br 2 (;@3;)
-            end
-          end
-        end
-        local.get $3
-        i32.const 255
-        i32.and
-        i32.const 24
-        i32.shl
-        i32.const 24
-        i32.shr_s
-        if ;; label = @3
-          loop $label$9 ;; label = @4
-            local.get $0
-            i32.const 1
-            i32.add
-            local.tee $0
-            i32.load8_s
-            br_if 0 (;@4;)
-          end
-        end
-      end
-      local.get $0
-      local.get $2
-      i32.sub
-    end
-  )
-  (func $32 (;45;) (type $4) (param $0 i32) (param $1 i32) (result i32)
-    (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $3
-      global.get $global$1
-      i32.const 16
-      i32.add
-      global.set $global$1
-      local.get $3
-      local.tee $4
-      local.get $1
-      i32.const 255
-      i32.and
-      local.tee $7
-      i32.store8
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          local.get $0
-          i32.const 16
-          i32.add
-          local.tee $2
-          i32.load
-          local.tee $5
-          br_if 0 (;@3;)
-          local.get $0
-          call $30
-          if ;; label = @4
-            i32.const -1
-            local.set $1
-          else
-            block ;; label = @5
-              local.get $2
-              i32.load
-              local.set $5
-              br 2 (;@3;)
-            end
-          end
-          br 1 (;@2;)
-        end
-        local.get $0
-        i32.const 20
-        i32.add
-        local.tee $2
-        i32.load
-        local.tee $6
-        local.get $5
-        i32.lt_u
-        if ;; label = @3
-          local.get $1
-          i32.const 255
-          i32.and
-          local.tee $1
-          local.get $0
-          i32.load8_s offset=75
-          i32.ne
-          if ;; label = @4
-            block ;; label = @5
-              local.get $2
-              local.get $6
-              i32.const 1
-              i32.add
-              i32.store
-              local.get $6
-              local.get $7
-              i32.store8
-              br 3 (;@2;)
-            end
-          end
-        end
-        local.get $0
-        local.get $4
-        i32.const 1
-        local.get $0
-        i32.load offset=36
-        i32.const 3
-        i32.and
-        i32.const 2
-        i32.add
-        call_indirect (type $0)
-        i32.const 1
-        i32.eq
-        if (result i32) ;; label = @3
-          local.get $4
-          i32.load8_u
-        else
-          i32.const -1
-        end
-        local.set $1
-      end
-      local.get $3
-      global.set $global$1
-      local.get $1
-    end
-  )
-  (func $33 (;46;) (type $12) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32)
-    (local $4 i32) (local $5 i32)
-    block $label$1 (result i32) ;; label = @1
-      local.get $2
-      local.get $1
-      i32.mul
-      local.set $4
-      local.get $3
-      i32.load offset=76
-      i32.const -1
-      i32.gt_s
-      if ;; label = @2
-        block ;; label = @3
-          local.get $3
-          call $20
-          i32.eqz
-          local.set $5
-          local.get $0
-          local.get $4
-          local.get $3
-          call $21
-          local.set $0
-          local.get $5
-          i32.eqz
-          if ;; label = @4
-            local.get $3
-            call $13
-          end
-        end
-      else
-        local.get $0
-        local.get $4
-        local.get $3
-        call $21
-        local.set $0
-      end
-      local.get $0
-      local.get $4
-      i32.ne
-      if ;; label = @2
-        local.get $0
-        local.get $1
-        i32.div_u
-        local.set $2
-      end
-      local.get $2
-    end
-  )
-  (func $34 (;47;) (type $4) (param $0 i32) (param $1 i32) (result i32)
-    (local $2 i32) (local $3 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $2
-      global.get $global$1
-      i32.const 16
-      i32.add
-      global.set $global$1
-      local.get $2
-      local.tee $3
-      local.get $1
-      i32.store
-      i32.const 1024
-      i32.load
-      local.get $0
-      local.get $3
-      call $18
-      local.set $0
-      local.get $2
-      global.set $global$1
-      local.get $0
-    end
-  )
-  (func $35 (;48;) (type $1) (param $0 i32) (result i32)
-    (local $1 i32) (local $2 i32) (local $3 i32)
-    block $label$1 (result i32) ;; label = @1
-      i32.const 1024
-      i32.load
-      local.tee $1
-      i32.load offset=76
-      i32.const -1
-      i32.gt_s
-      if (result i32) ;; label = @2
-        local.get $1
-        call $20
-      else
-        i32.const 0
-      end
-      local.set $2
-      block $label$4 (result i32) ;; label = @2
-        local.get $0
-        local.get $1
-        call $36
-        i32.const 0
-        i32.lt_s
-        if (result i32) ;; label = @3
-          i32.const 1
-        else
-          block (result i32) ;; label = @4
-            local.get $1
-            i32.load8_s offset=75
-            i32.const 10
-            i32.ne
-            if ;; label = @5
-              local.get $1
-              i32.const 20
-              i32.add
-              local.tee $3
-              i32.load
-              local.tee $0
-              local.get $1
-              i32.load offset=16
-              i32.lt_u
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $3
-                  local.get $0
-                  i32.const 1
-                  i32.add
-                  i32.store
-                  local.get $0
-                  i32.const 10
-                  i32.store8
-                  i32.const 0
-                  br 5 (;@2;)
-                end
-              end
-            end
-            local.get $1
-            i32.const 10
-            call $32
-            i32.const 0
-            i32.lt_s
-          end
-        end
-      end
-      local.set $0
-      local.get $2
-      if ;; label = @2
-        local.get $1
-        call $13
-      end
-      local.get $0
-      i32.const 31
-      i32.shl
-      i32.const 31
-      i32.shr_s
-    end
-  )
-  (func $36 (;49;) (type $4) (param $0 i32) (param $1 i32) (result i32)
-    local.get $0
-    local.get $0
-    call $31
-    i32.const 1
-    local.get $1
-    call $33
-    i32.const -1
-    i32.add
-  )
-  (func $37 (;50;) (type $1) (param $0 i32) (result i32)
-    (local $1 i32) (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32) (local $15 i32) (local $16 i32) (local $17 i32) (local $18 i32) (local $19 i32) (local $20 i32) (local $21 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $14
-      global.get $global$1
-      i32.const 16
-      i32.add
-      global.set $global$1
-      local.get $14
-      local.set $18
-      block $label$2 ;; label = @2
-        local.get $0
-        i32.const 245
-        i32.lt_u
-        if ;; label = @3
-          block ;; label = @4
-            local.get $0
-            i32.const 11
-            i32.add
-            i32.const -8
-            i32.and
-            local.set $3
-            i32.const 3636
-            i32.load
-            local.tee $8
-            local.get $0
-            i32.const 11
-            i32.lt_u
-            if (result i32) ;; label = @5
-              i32.const 16
-              local.tee $3
-            else
-              local.get $3
-            end
-            i32.const 3
-            i32.shr_u
-            local.tee $2
-            i32.shr_u
-            local.tee $0
-            i32.const 3
-            i32.and
-            if ;; label = @5
-              block ;; label = @6
-                local.get $0
-                i32.const 1
-                i32.and
-                i32.const 1
-                i32.xor
-                local.get $2
-                i32.add
-                local.tee $5
-                i32.const 1
-                i32.shl
-                i32.const 2
-                i32.shl
-                i32.const 3676
-                i32.add
-                local.tee $2
-                i32.const 8
-                i32.add
-                local.tee $3
-                i32.load
-                local.tee $7
-                i32.const 8
-                i32.add
-                local.tee $1
-                i32.load
-                local.set $4
-                local.get $2
-                local.get $4
-                i32.eq
-                if ;; label = @7
-                  i32.const 3636
-                  local.get $8
-                  i32.const 1
-                  local.get $5
-                  i32.shl
-                  i32.const -1
-                  i32.xor
-                  i32.and
-                  i32.store
-                else
-                  block ;; label = @8
-                    local.get $4
-                    i32.const 3652
-                    i32.load
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                    local.get $4
-                    i32.const 12
-                    i32.add
-                    local.tee $0
-                    i32.load
-                    local.get $7
-                    i32.eq
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $0
-                        local.get $2
-                        i32.store
-                        local.get $3
-                        local.get $4
-                        i32.store
-                      end
-                    else
-                      call $fimport$10
-                    end
-                  end
-                end
-                local.get $7
-                local.get $5
-                i32.const 3
-                i32.shl
-                local.tee $0
-                i32.const 3
-                i32.or
-                i32.store offset=4
-                local.get $7
-                local.get $0
-                i32.add
-                i32.const 4
-                i32.add
-                local.tee $0
-                local.get $0
-                i32.load
-                i32.const 1
-                i32.or
-                i32.store
-                local.get $14
-                global.set $global$1
-                local.get $1
-                return
-              end
-            end
-            local.get $3
-            i32.const 3644
-            i32.load
-            local.tee $16
-            i32.gt_u
-            if ;; label = @5
-              block ;; label = @6
-                local.get $0
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $0
-                    local.get $2
-                    i32.shl
-                    i32.const 2
-                    local.get $2
-                    i32.shl
-                    local.tee $0
-                    i32.const 0
-                    local.get $0
-                    i32.sub
-                    i32.or
-                    i32.and
-                    local.tee $0
-                    i32.const 0
-                    local.get $0
-                    i32.sub
-                    i32.and
-                    i32.const -1
-                    i32.add
-                    local.tee $0
-                    i32.const 12
-                    i32.shr_u
-                    i32.const 16
-                    i32.and
-                    local.set $5
-                    local.get $0
-                    local.get $5
-                    i32.shr_u
-                    local.tee $2
-                    i32.const 5
-                    i32.shr_u
-                    i32.const 8
-                    i32.and
-                    local.tee $0
-                    local.get $5
-                    i32.or
-                    local.get $2
-                    local.get $0
-                    i32.shr_u
-                    local.tee $2
-                    i32.const 2
-                    i32.shr_u
-                    i32.const 4
-                    i32.and
-                    local.tee $0
-                    i32.or
-                    local.get $2
-                    local.get $0
-                    i32.shr_u
-                    local.tee $2
-                    i32.const 1
-                    i32.shr_u
-                    i32.const 2
-                    i32.and
-                    local.tee $0
-                    i32.or
-                    local.get $2
-                    local.get $0
-                    i32.shr_u
-                    local.tee $2
-                    i32.const 1
-                    i32.shr_u
-                    i32.const 1
-                    i32.and
-                    local.tee $0
-                    i32.or
-                    local.get $2
-                    local.get $0
-                    i32.shr_u
-                    i32.add
-                    local.tee $11
-                    i32.const 1
-                    i32.shl
-                    i32.const 2
-                    i32.shl
-                    i32.const 3676
-                    i32.add
-                    local.tee $4
-                    i32.const 8
-                    i32.add
-                    local.tee $2
-                    i32.load
-                    local.tee $9
-                    i32.const 8
-                    i32.add
-                    local.tee $5
-                    i32.load
-                    local.set $12
-                    local.get $4
-                    local.get $12
-                    i32.eq
-                    if ;; label = @9
-                      i32.const 3636
-                      local.get $8
-                      i32.const 1
-                      local.get $11
-                      i32.shl
-                      i32.const -1
-                      i32.xor
-                      i32.and
-                      local.tee $7
-                      i32.store
-                    else
-                      block ;; label = @10
-                        local.get $12
-                        i32.const 3652
-                        i32.load
-                        i32.lt_u
-                        if ;; label = @11
-                          call $fimport$10
-                        end
-                        local.get $12
-                        i32.const 12
-                        i32.add
-                        local.tee $0
-                        i32.load
-                        local.get $9
-                        i32.eq
-                        if ;; label = @11
-                          block ;; label = @12
-                            local.get $0
-                            local.get $4
-                            i32.store
-                            local.get $2
-                            local.get $12
-                            i32.store
-                            local.get $8
-                            local.set $7
-                          end
-                        else
-                          call $fimport$10
-                        end
-                      end
-                    end
-                    local.get $9
-                    local.get $3
-                    i32.const 3
-                    i32.or
-                    i32.store offset=4
-                    local.get $9
-                    local.get $3
-                    i32.add
-                    local.tee $4
-                    local.get $11
-                    i32.const 3
-                    i32.shl
-                    local.get $3
-                    i32.sub
-                    local.tee $11
-                    i32.const 1
-                    i32.or
-                    i32.store offset=4
-                    local.get $4
-                    local.get $11
-                    i32.add
-                    local.get $11
-                    i32.store
-                    local.get $16
-                    if ;; label = @9
-                      block ;; label = @10
-                        i32.const 3656
-                        i32.load
-                        local.set $9
-                        local.get $16
-                        i32.const 3
-                        i32.shr_u
-                        local.tee $0
-                        i32.const 1
-                        i32.shl
-                        i32.const 2
-                        i32.shl
-                        i32.const 3676
-                        i32.add
-                        local.set $2
-                        local.get $7
-                        i32.const 1
-                        local.get $0
-                        i32.shl
-                        local.tee $0
-                        i32.and
-                        if ;; label = @11
-                          local.get $2
-                          i32.const 8
-                          i32.add
-                          local.tee $3
-                          i32.load
-                          local.tee $0
-                          i32.const 3652
-                          i32.load
-                          i32.lt_u
-                          if ;; label = @12
-                            call $fimport$10
-                          else
-                            block ;; label = @13
-                              local.get $3
-                              local.set $6
-                              local.get $0
-                              local.set $1
-                            end
-                          end
-                        else
-                          block ;; label = @12
-                            i32.const 3636
-                            local.get $7
-                            local.get $0
-                            i32.or
-                            i32.store
-                            local.get $2
-                            i32.const 8
-                            i32.add
-                            local.set $6
-                            local.get $2
-                            local.set $1
-                          end
-                        end
-                        local.get $6
-                        local.get $9
-                        i32.store
-                        local.get $1
-                        local.get $9
-                        i32.store offset=12
-                        local.get $9
-                        local.get $1
-                        i32.store offset=8
-                        local.get $9
-                        local.get $2
-                        i32.store offset=12
-                      end
-                    end
-                    i32.const 3644
-                    local.get $11
-                    i32.store
-                    i32.const 3656
-                    local.get $4
-                    i32.store
-                    local.get $14
-                    global.set $global$1
-                    local.get $5
-                    return
-                  end
-                end
-                i32.const 3640
-                i32.load
-                local.tee $6
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $6
-                    i32.const 0
-                    local.get $6
-                    i32.sub
-                    i32.and
-                    i32.const -1
-                    i32.add
-                    local.tee $0
-                    i32.const 12
-                    i32.shr_u
-                    i32.const 16
-                    i32.and
-                    local.set $2
-                    local.get $0
-                    local.get $2
-                    i32.shr_u
-                    local.tee $1
-                    i32.const 5
-                    i32.shr_u
-                    i32.const 8
-                    i32.and
-                    local.tee $0
-                    local.get $2
-                    i32.or
-                    local.get $1
-                    local.get $0
-                    i32.shr_u
-                    local.tee $1
-                    i32.const 2
-                    i32.shr_u
-                    i32.const 4
-                    i32.and
-                    local.tee $0
-                    i32.or
-                    local.get $1
-                    local.get $0
-                    i32.shr_u
-                    local.tee $1
-                    i32.const 1
-                    i32.shr_u
-                    i32.const 2
-                    i32.and
-                    local.tee $0
-                    i32.or
-                    local.get $1
-                    local.get $0
-                    i32.shr_u
-                    local.tee $1
-                    i32.const 1
-                    i32.shr_u
-                    i32.const 1
-                    i32.and
-                    local.tee $0
-                    i32.or
-                    local.get $1
-                    local.get $0
-                    i32.shr_u
-                    i32.add
-                    i32.const 2
-                    i32.shl
-                    i32.const 3940
-                    i32.add
-                    i32.load
-                    local.tee $2
-                    i32.load offset=4
-                    i32.const -8
-                    i32.and
-                    local.get $3
-                    i32.sub
-                    local.set $9
-                    local.get $2
-                    local.set $1
-                    loop $label$25 ;; label = @9
-                      block $label$26 ;; label = @10
-                        local.get $1
-                        i32.load offset=16
-                        local.tee $0
-                        i32.eqz
-                        if ;; label = @11
-                          local.get $1
-                          i32.load offset=20
-                          local.tee $0
-                          i32.eqz
-                          br_if 1 (;@10;)
-                        end
-                        local.get $0
-                        i32.load offset=4
-                        i32.const -8
-                        i32.and
-                        local.get $3
-                        i32.sub
-                        local.tee $1
-                        local.get $9
-                        i32.lt_u
-                        local.tee $7
-                        if ;; label = @11
-                          local.get $1
-                          local.set $9
-                        end
-                        local.get $0
-                        local.set $1
-                        local.get $7
-                        if ;; label = @11
-                          local.get $0
-                          local.set $2
-                        end
-                        br 1 (;@9;)
-                      end
-                    end
-                    local.get $2
-                    i32.const 3652
-                    i32.load
-                    local.tee $12
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                    local.get $2
-                    local.get $2
-                    local.get $3
-                    i32.add
-                    local.tee $13
-                    i32.ge_u
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                    local.get $2
-                    i32.load offset=24
-                    local.set $15
-                    block $label$32 ;; label = @9
-                      local.get $2
-                      i32.load offset=12
-                      local.tee $0
-                      local.get $2
-                      i32.eq
-                      if ;; label = @10
-                        block ;; label = @11
-                          local.get $2
-                          i32.const 20
-                          i32.add
-                          local.tee $1
-                          i32.load
-                          local.tee $0
-                          i32.eqz
-                          if ;; label = @12
-                            local.get $2
-                            i32.const 16
-                            i32.add
-                            local.tee $1
-                            i32.load
-                            local.tee $0
-                            i32.eqz
-                            if ;; label = @13
-                              block ;; label = @14
-                                i32.const 0
-                                local.set $4
-                                br 5 (;@9;)
-                              end
-                            end
-                          end
-                          loop $label$36 ;; label = @12
-                            local.get $0
-                            i32.const 20
-                            i32.add
-                            local.tee $11
-                            i32.load
-                            local.tee $7
-                            if ;; label = @13
-                              block ;; label = @14
-                                local.get $7
-                                local.set $0
-                                local.get $11
-                                local.set $1
-                                br 2 (;@12;)
-                              end
-                            end
-                            local.get $0
-                            i32.const 16
-                            i32.add
-                            local.tee $11
-                            i32.load
-                            local.tee $7
-                            if ;; label = @13
-                              block ;; label = @14
-                                local.get $7
-                                local.set $0
-                                local.get $11
-                                local.set $1
-                                br 2 (;@12;)
-                              end
-                            end
-                          end
-                          local.get $1
-                          local.get $12
-                          i32.lt_u
-                          if ;; label = @12
-                            call $fimport$10
-                          else
-                            block ;; label = @13
-                              local.get $1
-                              i32.const 0
-                              i32.store
-                              local.get $0
-                              local.set $4
-                            end
-                          end
-                        end
-                      else
-                        block ;; label = @11
-                          local.get $2
-                          i32.load offset=8
-                          local.tee $11
-                          local.get $12
-                          i32.lt_u
-                          if ;; label = @12
-                            call $fimport$10
-                          end
-                          local.get $11
-                          i32.const 12
-                          i32.add
-                          local.tee $7
-                          i32.load
-                          local.get $2
-                          i32.ne
-                          if ;; label = @12
-                            call $fimport$10
-                          end
-                          local.get $0
-                          i32.const 8
-                          i32.add
-                          local.tee $1
-                          i32.load
-                          local.get $2
-                          i32.eq
-                          if ;; label = @12
-                            block ;; label = @13
-                              local.get $7
-                              local.get $0
-                              i32.store
-                              local.get $1
-                              local.get $11
-                              i32.store
-                              local.get $0
-                              local.set $4
-                            end
-                          else
-                            call $fimport$10
-                          end
-                        end
-                      end
-                    end
-                    block $label$46 ;; label = @9
-                      local.get $15
-                      if ;; label = @10
-                        block ;; label = @11
-                          local.get $2
-                          local.get $2
-                          i32.load offset=28
-                          local.tee $1
-                          i32.const 2
-                          i32.shl
-                          i32.const 3940
-                          i32.add
-                          local.tee $0
-                          i32.load
-                          i32.eq
-                          if ;; label = @12
-                            block ;; label = @13
-                              local.get $0
-                              local.get $4
-                              i32.store
-                              local.get $4
-                              i32.eqz
-                              if ;; label = @14
-                                block ;; label = @15
-                                  i32.const 3640
-                                  local.get $6
-                                  i32.const 1
-                                  local.get $1
-                                  i32.shl
-                                  i32.const -1
-                                  i32.xor
-                                  i32.and
-                                  i32.store
-                                  br 6 (;@9;)
-                                end
-                              end
-                            end
-                          else
-                            block ;; label = @13
-                              local.get $15
-                              i32.const 3652
-                              i32.load
-                              i32.lt_u
-                              if ;; label = @14
-                                call $fimport$10
-                              end
-                              local.get $15
-                              i32.const 16
-                              i32.add
-                              local.tee $0
-                              i32.load
-                              local.get $2
-                              i32.eq
-                              if ;; label = @14
-                                local.get $0
-                                local.get $4
-                                i32.store
-                              else
-                                local.get $15
-                                local.get $4
-                                i32.store offset=20
-                              end
-                              local.get $4
-                              i32.eqz
-                              br_if 4 (;@9;)
-                            end
-                          end
-                          local.get $4
-                          i32.const 3652
-                          i32.load
-                          local.tee $0
-                          i32.lt_u
-                          if ;; label = @12
-                            call $fimport$10
-                          end
-                          local.get $4
-                          local.get $15
-                          i32.store offset=24
-                          local.get $2
-                          i32.load offset=16
-                          local.tee $1
-                          if ;; label = @12
-                            local.get $1
-                            local.get $0
-                            i32.lt_u
-                            if ;; label = @13
-                              call $fimport$10
-                            else
-                              block ;; label = @14
-                                local.get $4
-                                local.get $1
-                                i32.store offset=16
-                                local.get $1
-                                local.get $4
-                                i32.store offset=24
-                              end
-                            end
-                          end
-                          local.get $2
-                          i32.load offset=20
-                          local.tee $0
-                          if ;; label = @12
-                            local.get $0
-                            i32.const 3652
-                            i32.load
-                            i32.lt_u
-                            if ;; label = @13
-                              call $fimport$10
-                            else
-                              block ;; label = @14
-                                local.get $4
-                                local.get $0
-                                i32.store offset=20
-                                local.get $0
-                                local.get $4
-                                i32.store offset=24
-                              end
-                            end
-                          end
-                        end
-                      end
-                    end
-                    local.get $9
-                    i32.const 16
-                    i32.lt_u
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $2
-                        local.get $9
-                        local.get $3
-                        i32.add
-                        local.tee $0
-                        i32.const 3
-                        i32.or
-                        i32.store offset=4
-                        local.get $2
-                        local.get $0
-                        i32.add
-                        i32.const 4
-                        i32.add
-                        local.tee $0
-                        local.get $0
-                        i32.load
-                        i32.const 1
-                        i32.or
-                        i32.store
-                      end
-                    else
-                      block ;; label = @10
-                        local.get $2
-                        local.get $3
-                        i32.const 3
-                        i32.or
-                        i32.store offset=4
-                        local.get $13
-                        local.get $9
-                        i32.const 1
-                        i32.or
-                        i32.store offset=4
-                        local.get $13
-                        local.get $9
-                        i32.add
-                        local.get $9
-                        i32.store
-                        local.get $16
-                        if ;; label = @11
-                          block ;; label = @12
-                            i32.const 3656
-                            i32.load
-                            local.set $7
-                            local.get $16
-                            i32.const 3
-                            i32.shr_u
-                            local.tee $0
-                            i32.const 1
-                            i32.shl
-                            i32.const 2
-                            i32.shl
-                            i32.const 3676
-                            i32.add
-                            local.set $3
-                            local.get $8
-                            i32.const 1
-                            local.get $0
-                            i32.shl
-                            local.tee $0
-                            i32.and
-                            if ;; label = @13
-                              local.get $3
-                              i32.const 8
-                              i32.add
-                              local.tee $1
-                              i32.load
-                              local.tee $0
-                              i32.const 3652
-                              i32.load
-                              i32.lt_u
-                              if ;; label = @14
-                                call $fimport$10
-                              else
-                                block ;; label = @15
-                                  local.get $1
-                                  local.set $10
-                                  local.get $0
-                                  local.set $5
-                                end
-                              end
-                            else
-                              block ;; label = @14
-                                i32.const 3636
-                                local.get $8
-                                local.get $0
-                                i32.or
-                                i32.store
-                                local.get $3
-                                i32.const 8
-                                i32.add
-                                local.set $10
-                                local.get $3
-                                local.set $5
-                              end
-                            end
-                            local.get $10
-                            local.get $7
-                            i32.store
-                            local.get $5
-                            local.get $7
-                            i32.store offset=12
-                            local.get $7
-                            local.get $5
-                            i32.store offset=8
-                            local.get $7
-                            local.get $3
-                            i32.store offset=12
-                          end
-                        end
-                        i32.const 3644
-                        local.get $9
-                        i32.store
-                        i32.const 3656
-                        local.get $13
-                        i32.store
-                      end
-                    end
-                    local.get $14
-                    global.set $global$1
-                    local.get $2
-                    i32.const 8
-                    i32.add
-                    return
-                  end
-                else
-                  local.get $3
-                  local.set $0
-                end
-              end
-            else
-              local.get $3
-              local.set $0
-            end
-          end
-        else
-          local.get $0
-          i32.const -65
-          i32.gt_u
-          if ;; label = @4
-            i32.const -1
-            local.set $0
-          else
-            block ;; label = @5
-              local.get $0
-              i32.const 11
-              i32.add
-              local.tee $0
-              i32.const -8
-              i32.and
-              local.set $7
-              i32.const 3640
-              i32.load
-              local.tee $5
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $0
-                  i32.const 8
-                  i32.shr_u
-                  local.tee $0
-                  if (result i32) ;; label = @8
-                    local.get $7
-                    i32.const 16777215
-                    i32.gt_u
-                    if (result i32) ;; label = @9
-                      i32.const 31
-                    else
-                      local.get $7
-                      i32.const 14
-                      local.get $0
-                      local.get $0
-                      i32.const 1048320
-                      i32.add
-                      i32.const 16
-                      i32.shr_u
-                      i32.const 8
-                      i32.and
-                      local.tee $3
-                      i32.shl
-                      local.tee $1
-                      i32.const 520192
-                      i32.add
-                      i32.const 16
-                      i32.shr_u
-                      i32.const 4
-                      i32.and
-                      local.tee $0
-                      local.get $3
-                      i32.or
-                      local.get $1
-                      local.get $0
-                      i32.shl
-                      local.tee $1
-                      i32.const 245760
-                      i32.add
-                      i32.const 16
-                      i32.shr_u
-                      i32.const 2
-                      i32.and
-                      local.tee $0
-                      i32.or
-                      i32.sub
-                      local.get $1
-                      local.get $0
-                      i32.shl
-                      i32.const 15
-                      i32.shr_u
-                      i32.add
-                      local.tee $0
-                      i32.const 7
-                      i32.add
-                      i32.shr_u
-                      i32.const 1
-                      i32.and
-                      local.get $0
-                      i32.const 1
-                      i32.shl
-                      i32.or
-                    end
-                  else
-                    i32.const 0
-                  end
-                  local.set $17
-                  i32.const 0
-                  local.get $7
-                  i32.sub
-                  local.set $3
-                  block $label$78 ;; label = @8
-                    block $label$79 ;; label = @9
-                      block $label$80 ;; label = @10
-                        local.get $17
-                        i32.const 2
-                        i32.shl
-                        i32.const 3940
-                        i32.add
-                        i32.load
-                        local.tee $1
-                        if ;; label = @11
-                          block ;; label = @12
-                            i32.const 25
-                            local.get $17
-                            i32.const 1
-                            i32.shr_u
-                            i32.sub
-                            local.set $0
-                            i32.const 0
-                            local.set $4
-                            local.get $7
-                            local.get $17
-                            i32.const 31
-                            i32.eq
-                            if (result i32) ;; label = @13
-                              i32.const 0
-                            else
-                              local.get $0
-                            end
-                            i32.shl
-                            local.set $10
-                            i32.const 0
-                            local.set $0
-                            loop $label$84 ;; label = @13
-                              local.get $1
-                              i32.load offset=4
-                              i32.const -8
-                              i32.and
-                              local.get $7
-                              i32.sub
-                              local.tee $6
-                              local.get $3
-                              i32.lt_u
-                              if ;; label = @14
-                                local.get $6
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $6
-                                    local.set $3
-                                    local.get $1
-                                    local.set $0
-                                  end
-                                else
-                                  block ;; label = @16
-                                    i32.const 0
-                                    local.set $3
-                                    local.get $1
-                                    local.set $0
-                                    br 7 (;@9;)
-                                  end
-                                end
-                              end
-                              local.get $1
-                              i32.load offset=20
-                              local.tee $19
-                              i32.eqz
-                              local.get $19
-                              local.get $1
-                              i32.const 16
-                              i32.add
-                              local.get $10
-                              i32.const 31
-                              i32.shr_u
-                              i32.const 2
-                              i32.shl
-                              i32.add
-                              i32.load
-                              local.tee $6
-                              i32.eq
-                              i32.or
-                              if (result i32) ;; label = @14
-                                local.get $4
-                              else
-                                local.get $19
-                              end
-                              local.set $1
-                              local.get $10
-                              local.get $6
-                              i32.eqz
-                              local.tee $4
-                              i32.const 1
-                              i32.and
-                              i32.const 1
-                              i32.xor
-                              i32.shl
-                              local.set $10
-                              local.get $4
-                              if ;; label = @14
-                                block ;; label = @15
-                                  local.get $1
-                                  local.set $4
-                                  local.get $0
-                                  local.set $1
-                                  br 5 (;@10;)
-                                end
-                              else
-                                block ;; label = @15
-                                  local.get $1
-                                  local.set $4
-                                  local.get $6
-                                  local.set $1
-                                  br 2 (;@13;)
-                                end
-                              end
-                            end
-                          end
-                        else
-                          block ;; label = @12
-                            i32.const 0
-                            local.set $4
-                            i32.const 0
-                            local.set $1
-                          end
-                        end
-                      end
-                      local.get $4
-                      i32.eqz
-                      local.get $1
-                      i32.eqz
-                      i32.and
-                      if (result i32) ;; label = @10
-                        block (result i32) ;; label = @11
-                          local.get $5
-                          i32.const 2
-                          local.get $17
-                          i32.shl
-                          local.tee $0
-                          i32.const 0
-                          local.get $0
-                          i32.sub
-                          i32.or
-                          i32.and
-                          local.tee $0
-                          i32.eqz
-                          if ;; label = @12
-                            block ;; label = @13
-                              local.get $7
-                              local.set $0
-                              br 11 (;@2;)
-                            end
-                          end
-                          local.get $0
-                          i32.const 0
-                          local.get $0
-                          i32.sub
-                          i32.and
-                          i32.const -1
-                          i32.add
-                          local.tee $0
-                          i32.const 12
-                          i32.shr_u
-                          i32.const 16
-                          i32.and
-                          local.set $10
-                          local.get $0
-                          local.get $10
-                          i32.shr_u
-                          local.tee $4
-                          i32.const 5
-                          i32.shr_u
-                          i32.const 8
-                          i32.and
-                          local.tee $0
-                          local.get $10
-                          i32.or
-                          local.get $4
-                          local.get $0
-                          i32.shr_u
-                          local.tee $4
-                          i32.const 2
-                          i32.shr_u
-                          i32.const 4
-                          i32.and
-                          local.tee $0
-                          i32.or
-                          local.get $4
-                          local.get $0
-                          i32.shr_u
-                          local.tee $4
-                          i32.const 1
-                          i32.shr_u
-                          i32.const 2
-                          i32.and
-                          local.tee $0
-                          i32.or
-                          local.get $4
-                          local.get $0
-                          i32.shr_u
-                          local.tee $4
-                          i32.const 1
-                          i32.shr_u
-                          i32.const 1
-                          i32.and
-                          local.tee $0
-                          i32.or
-                          local.get $4
-                          local.get $0
-                          i32.shr_u
-                          i32.add
-                          i32.const 2
-                          i32.shl
-                          i32.const 3940
-                          i32.add
-                          i32.load
-                        end
-                      else
-                        local.get $4
-                      end
-                      local.tee $0
-                      br_if 0 (;@9;)
-                      local.get $1
-                      local.set $4
-                      br 1 (;@8;)
-                    end
-                    loop $label$96 ;; label = @9
-                      local.get $0
-                      i32.load offset=4
-                      i32.const -8
-                      i32.and
-                      local.get $7
-                      i32.sub
-                      local.tee $4
-                      local.get $3
-                      i32.lt_u
-                      local.tee $10
-                      if ;; label = @10
-                        local.get $4
-                        local.set $3
-                      end
-                      local.get $10
-                      if ;; label = @10
-                        local.get $0
-                        local.set $1
-                      end
-                      local.get $0
-                      i32.load offset=16
-                      local.tee $4
-                      if ;; label = @10
-                        block ;; label = @11
-                          local.get $4
-                          local.set $0
-                          br 2 (;@9;)
-                        end
-                      end
-                      local.get $0
-                      i32.load offset=20
-                      local.tee $0
-                      br_if 0 (;@9;)
-                      local.get $1
-                      local.set $4
-                    end
-                  end
-                  local.get $4
-                  if ;; label = @8
-                    local.get $3
-                    i32.const 3644
-                    i32.load
-                    local.get $7
-                    i32.sub
-                    i32.lt_u
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $4
-                        i32.const 3652
-                        i32.load
-                        local.tee $12
-                        i32.lt_u
-                        if ;; label = @11
-                          call $fimport$10
-                        end
-                        local.get $4
-                        local.get $4
-                        local.get $7
-                        i32.add
-                        local.tee $6
-                        i32.ge_u
-                        if ;; label = @11
-                          call $fimport$10
-                        end
-                        local.get $4
-                        i32.load offset=24
-                        local.set $10
-                        block $label$104 ;; label = @11
-                          local.get $4
-                          i32.load offset=12
-                          local.tee $0
-                          local.get $4
-                          i32.eq
-                          if ;; label = @12
-                            block ;; label = @13
-                              local.get $4
-                              i32.const 20
-                              i32.add
-                              local.tee $1
-                              i32.load
-                              local.tee $0
-                              i32.eqz
-                              if ;; label = @14
-                                local.get $4
-                                i32.const 16
-                                i32.add
-                                local.tee $1
-                                i32.load
-                                local.tee $0
-                                i32.eqz
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    i32.const 0
-                                    local.set $13
-                                    br 5 (;@11;)
-                                  end
-                                end
-                              end
-                              loop $label$108 ;; label = @14
-                                local.get $0
-                                i32.const 20
-                                i32.add
-                                local.tee $9
-                                i32.load
-                                local.tee $11
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $11
-                                    local.set $0
-                                    local.get $9
-                                    local.set $1
-                                    br 2 (;@14;)
-                                  end
-                                end
-                                local.get $0
-                                i32.const 16
-                                i32.add
-                                local.tee $9
-                                i32.load
-                                local.tee $11
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $11
-                                    local.set $0
-                                    local.get $9
-                                    local.set $1
-                                    br 2 (;@14;)
-                                  end
-                                end
-                              end
-                              local.get $1
-                              local.get $12
-                              i32.lt_u
-                              if ;; label = @14
-                                call $fimport$10
-                              else
-                                block ;; label = @15
-                                  local.get $1
-                                  i32.const 0
-                                  i32.store
-                                  local.get $0
-                                  local.set $13
-                                end
-                              end
-                            end
-                          else
-                            block ;; label = @13
-                              local.get $4
-                              i32.load offset=8
-                              local.tee $9
-                              local.get $12
-                              i32.lt_u
-                              if ;; label = @14
-                                call $fimport$10
-                              end
-                              local.get $9
-                              i32.const 12
-                              i32.add
-                              local.tee $11
-                              i32.load
-                              local.get $4
-                              i32.ne
-                              if ;; label = @14
-                                call $fimport$10
-                              end
-                              local.get $0
-                              i32.const 8
-                              i32.add
-                              local.tee $1
-                              i32.load
-                              local.get $4
-                              i32.eq
-                              if ;; label = @14
-                                block ;; label = @15
-                                  local.get $11
-                                  local.get $0
-                                  i32.store
-                                  local.get $1
-                                  local.get $9
-                                  i32.store
-                                  local.get $0
-                                  local.set $13
-                                end
-                              else
-                                call $fimport$10
-                              end
-                            end
-                          end
-                        end
-                        block $label$118 ;; label = @11
-                          local.get $10
-                          if ;; label = @12
-                            block ;; label = @13
-                              local.get $4
-                              local.get $4
-                              i32.load offset=28
-                              local.tee $1
-                              i32.const 2
-                              i32.shl
-                              i32.const 3940
-                              i32.add
-                              local.tee $0
-                              i32.load
-                              i32.eq
-                              if ;; label = @14
-                                block ;; label = @15
-                                  local.get $0
-                                  local.get $13
-                                  i32.store
-                                  local.get $13
-                                  i32.eqz
-                                  if ;; label = @16
-                                    block ;; label = @17
-                                      i32.const 3640
-                                      local.get $5
-                                      i32.const 1
-                                      local.get $1
-                                      i32.shl
-                                      i32.const -1
-                                      i32.xor
-                                      i32.and
-                                      local.tee $2
-                                      i32.store
-                                      br 6 (;@11;)
-                                    end
-                                  end
-                                end
-                              else
-                                block ;; label = @15
-                                  local.get $10
-                                  i32.const 3652
-                                  i32.load
-                                  i32.lt_u
-                                  if ;; label = @16
-                                    call $fimport$10
-                                  end
-                                  local.get $10
-                                  i32.const 16
-                                  i32.add
-                                  local.tee $0
-                                  i32.load
-                                  local.get $4
-                                  i32.eq
-                                  if ;; label = @16
-                                    local.get $0
-                                    local.get $13
-                                    i32.store
-                                  else
-                                    local.get $10
-                                    local.get $13
-                                    i32.store offset=20
-                                  end
-                                  local.get $13
-                                  i32.eqz
-                                  if ;; label = @16
-                                    block ;; label = @17
-                                      local.get $5
-                                      local.set $2
-                                      br 6 (;@11;)
-                                    end
-                                  end
-                                end
-                              end
-                              local.get $13
-                              i32.const 3652
-                              i32.load
-                              local.tee $0
-                              i32.lt_u
-                              if ;; label = @14
-                                call $fimport$10
-                              end
-                              local.get $13
-                              local.get $10
-                              i32.store offset=24
-                              local.get $4
-                              i32.load offset=16
-                              local.tee $1
-                              if ;; label = @14
-                                local.get $1
-                                local.get $0
-                                i32.lt_u
-                                if ;; label = @15
-                                  call $fimport$10
-                                else
-                                  block ;; label = @16
-                                    local.get $13
-                                    local.get $1
-                                    i32.store offset=16
-                                    local.get $1
-                                    local.get $13
-                                    i32.store offset=24
-                                  end
-                                end
-                              end
-                              local.get $4
-                              i32.load offset=20
-                              local.tee $0
-                              if ;; label = @14
-                                local.get $0
-                                i32.const 3652
-                                i32.load
-                                i32.lt_u
-                                if ;; label = @15
-                                  call $fimport$10
-                                else
-                                  block ;; label = @16
-                                    local.get $13
-                                    local.get $0
-                                    i32.store offset=20
-                                    local.get $0
-                                    local.get $13
-                                    i32.store offset=24
-                                    local.get $5
-                                    local.set $2
-                                  end
-                                end
-                              else
-                                local.get $5
-                                local.set $2
-                              end
-                            end
-                          else
-                            local.get $5
-                            local.set $2
-                          end
-                        end
-                        block $label$136 ;; label = @11
-                          local.get $3
-                          i32.const 16
-                          i32.lt_u
-                          if ;; label = @12
-                            block ;; label = @13
-                              local.get $4
-                              local.get $3
-                              local.get $7
-                              i32.add
-                              local.tee $0
-                              i32.const 3
-                              i32.or
-                              i32.store offset=4
-                              local.get $4
-                              local.get $0
-                              i32.add
-                              i32.const 4
-                              i32.add
-                              local.tee $0
-                              local.get $0
-                              i32.load
-                              i32.const 1
-                              i32.or
-                              i32.store
-                            end
-                          else
-                            block ;; label = @13
-                              local.get $4
-                              local.get $7
-                              i32.const 3
-                              i32.or
-                              i32.store offset=4
-                              local.get $6
-                              local.get $3
-                              i32.const 1
-                              i32.or
-                              i32.store offset=4
-                              local.get $6
-                              local.get $3
-                              i32.add
-                              local.get $3
-                              i32.store
-                              local.get $3
-                              i32.const 3
-                              i32.shr_u
-                              local.set $0
-                              local.get $3
-                              i32.const 256
-                              i32.lt_u
-                              if ;; label = @14
-                                block ;; label = @15
-                                  local.get $0
-                                  i32.const 1
-                                  i32.shl
-                                  i32.const 2
-                                  i32.shl
-                                  i32.const 3676
-                                  i32.add
-                                  local.set $3
-                                  i32.const 3636
-                                  i32.load
-                                  local.tee $1
-                                  i32.const 1
-                                  local.get $0
-                                  i32.shl
-                                  local.tee $0
-                                  i32.and
-                                  if ;; label = @16
-                                    local.get $3
-                                    i32.const 8
-                                    i32.add
-                                    local.tee $1
-                                    i32.load
-                                    local.tee $0
-                                    i32.const 3652
-                                    i32.load
-                                    i32.lt_u
-                                    if ;; label = @17
-                                      call $fimport$10
-                                    else
-                                      block ;; label = @18
-                                        local.get $1
-                                        local.set $16
-                                        local.get $0
-                                        local.set $8
-                                      end
-                                    end
-                                  else
-                                    block ;; label = @17
-                                      i32.const 3636
-                                      local.get $1
-                                      local.get $0
-                                      i32.or
-                                      i32.store
-                                      local.get $3
-                                      i32.const 8
-                                      i32.add
-                                      local.set $16
-                                      local.get $3
-                                      local.set $8
-                                    end
-                                  end
-                                  local.get $16
-                                  local.get $6
-                                  i32.store
-                                  local.get $8
-                                  local.get $6
-                                  i32.store offset=12
-                                  local.get $6
-                                  local.get $8
-                                  i32.store offset=8
-                                  local.get $6
-                                  local.get $3
-                                  i32.store offset=12
-                                  br 4 (;@11;)
-                                end
-                              end
-                              local.get $3
-                              i32.const 8
-                              i32.shr_u
-                              local.tee $0
-                              if (result i32) ;; label = @14
-                                local.get $3
-                                i32.const 16777215
-                                i32.gt_u
-                                if (result i32) ;; label = @15
-                                  i32.const 31
-                                else
-                                  local.get $3
-                                  i32.const 14
-                                  local.get $0
-                                  local.get $0
-                                  i32.const 1048320
-                                  i32.add
-                                  i32.const 16
-                                  i32.shr_u
-                                  i32.const 8
-                                  i32.and
-                                  local.tee $5
-                                  i32.shl
-                                  local.tee $1
-                                  i32.const 520192
-                                  i32.add
-                                  i32.const 16
-                                  i32.shr_u
-                                  i32.const 4
-                                  i32.and
-                                  local.tee $0
-                                  local.get $5
-                                  i32.or
-                                  local.get $1
-                                  local.get $0
-                                  i32.shl
-                                  local.tee $1
-                                  i32.const 245760
-                                  i32.add
-                                  i32.const 16
-                                  i32.shr_u
-                                  i32.const 2
-                                  i32.and
-                                  local.tee $0
-                                  i32.or
-                                  i32.sub
-                                  local.get $1
-                                  local.get $0
-                                  i32.shl
-                                  i32.const 15
-                                  i32.shr_u
-                                  i32.add
-                                  local.tee $0
-                                  i32.const 7
-                                  i32.add
-                                  i32.shr_u
-                                  i32.const 1
-                                  i32.and
-                                  local.get $0
-                                  i32.const 1
-                                  i32.shl
-                                  i32.or
-                                end
-                              else
-                                i32.const 0
-                              end
-                              local.tee $5
-                              i32.const 2
-                              i32.shl
-                              i32.const 3940
-                              i32.add
-                              local.set $1
-                              local.get $6
-                              local.get $5
-                              i32.store offset=28
-                              local.get $6
-                              i32.const 16
-                              i32.add
-                              local.tee $0
-                              i32.const 0
-                              i32.store offset=4
-                              local.get $0
-                              i32.const 0
-                              i32.store
-                              local.get $2
-                              i32.const 1
-                              local.get $5
-                              i32.shl
-                              local.tee $0
-                              i32.and
-                              i32.eqz
-                              if ;; label = @14
-                                block ;; label = @15
-                                  i32.const 3640
-                                  local.get $2
-                                  local.get $0
-                                  i32.or
-                                  i32.store
-                                  local.get $1
-                                  local.get $6
-                                  i32.store
-                                  local.get $6
-                                  local.get $1
-                                  i32.store offset=24
-                                  local.get $6
-                                  local.get $6
-                                  i32.store offset=12
-                                  local.get $6
-                                  local.get $6
-                                  i32.store offset=8
-                                  br 4 (;@11;)
-                                end
-                              end
-                              local.get $1
-                              i32.load
-                              local.set $0
-                              i32.const 25
-                              local.get $5
-                              i32.const 1
-                              i32.shr_u
-                              i32.sub
-                              local.set $1
-                              local.get $3
-                              local.get $5
-                              i32.const 31
-                              i32.eq
-                              if (result i32) ;; label = @14
-                                i32.const 0
-                              else
-                                local.get $1
-                              end
-                              i32.shl
-                              local.set $5
-                              block $label$151 ;; label = @14
-                                block $label$152 ;; label = @15
-                                  block $label$153 ;; label = @16
-                                    loop $label$154 ;; label = @17
-                                      local.get $0
-                                      i32.load offset=4
-                                      i32.const -8
-                                      i32.and
-                                      local.get $3
-                                      i32.eq
-                                      br_if 2 (;@15;)
-                                      local.get $5
-                                      i32.const 1
-                                      i32.shl
-                                      local.set $2
-                                      local.get $0
-                                      i32.const 16
-                                      i32.add
-                                      local.get $5
-                                      i32.const 31
-                                      i32.shr_u
-                                      i32.const 2
-                                      i32.shl
-                                      i32.add
-                                      local.tee $5
-                                      i32.load
-                                      local.tee $1
-                                      i32.eqz
-                                      br_if 1 (;@16;)
-                                      local.get $2
-                                      local.set $5
-                                      local.get $1
-                                      local.set $0
-                                      br 0 (;@17;)
-                                    end
-                                  end
-                                  local.get $5
-                                  i32.const 3652
-                                  i32.load
-                                  i32.lt_u
-                                  if ;; label = @16
-                                    call $fimport$10
-                                  else
-                                    block ;; label = @17
-                                      local.get $5
-                                      local.get $6
-                                      i32.store
-                                      local.get $6
-                                      local.get $0
-                                      i32.store offset=24
-                                      local.get $6
-                                      local.get $6
-                                      i32.store offset=12
-                                      local.get $6
-                                      local.get $6
-                                      i32.store offset=8
-                                      br 6 (;@11;)
-                                    end
-                                  end
-                                  br 1 (;@14;)
-                                end
-                                local.get $0
-                                i32.const 8
-                                i32.add
-                                local.tee $3
-                                i32.load
-                                local.tee $2
-                                i32.const 3652
-                                i32.load
-                                local.tee $1
-                                i32.ge_u
-                                local.get $0
-                                local.get $1
-                                i32.ge_u
-                                i32.and
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $2
-                                    local.get $6
-                                    i32.store offset=12
-                                    local.get $3
-                                    local.get $6
-                                    i32.store
-                                    local.get $6
-                                    local.get $2
-                                    i32.store offset=8
-                                    local.get $6
-                                    local.get $0
-                                    i32.store offset=12
-                                    local.get $6
-                                    i32.const 0
-                                    i32.store offset=24
-                                  end
-                                else
-                                  call $fimport$10
-                                end
-                              end
-                            end
-                          end
-                        end
-                        local.get $14
-                        global.set $global$1
-                        local.get $4
-                        i32.const 8
-                        i32.add
-                        return
-                      end
-                    else
-                      local.get $7
-                      local.set $0
-                    end
-                  else
-                    local.get $7
-                    local.set $0
-                  end
-                end
-              else
-                local.get $7
-                local.set $0
-              end
-            end
-          end
-        end
-      end
-      i32.const 3644
-      i32.load
-      local.tee $1
-      local.get $0
-      i32.ge_u
-      if ;; label = @2
-        block ;; label = @3
-          i32.const 3656
-          i32.load
-          local.set $2
-          local.get $1
-          local.get $0
-          i32.sub
-          local.tee $3
-          i32.const 15
-          i32.gt_u
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 3656
-              local.get $2
-              local.get $0
-              i32.add
-              local.tee $1
-              i32.store
-              i32.const 3644
-              local.get $3
-              i32.store
-              local.get $1
-              local.get $3
-              i32.const 1
-              i32.or
-              i32.store offset=4
-              local.get $1
-              local.get $3
-              i32.add
-              local.get $3
-              i32.store
-              local.get $2
-              local.get $0
-              i32.const 3
-              i32.or
-              i32.store offset=4
-            end
-          else
-            block ;; label = @5
-              i32.const 3644
-              i32.const 0
-              i32.store
-              i32.const 3656
-              i32.const 0
-              i32.store
-              local.get $2
-              local.get $1
-              i32.const 3
-              i32.or
-              i32.store offset=4
-              local.get $2
-              local.get $1
-              i32.add
-              i32.const 4
-              i32.add
-              local.tee $0
-              local.get $0
-              i32.load
-              i32.const 1
-              i32.or
-              i32.store
-            end
-          end
-          local.get $14
-          global.set $global$1
-          local.get $2
-          i32.const 8
-          i32.add
-          return
-        end
-      end
-      i32.const 3648
-      i32.load
-      local.tee $10
-      local.get $0
-      i32.gt_u
-      if ;; label = @2
-        block ;; label = @3
-          i32.const 3648
-          local.get $10
-          local.get $0
-          i32.sub
-          local.tee $3
-          i32.store
-          i32.const 3660
-          i32.const 3660
-          i32.load
-          local.tee $2
-          local.get $0
-          i32.add
-          local.tee $1
-          i32.store
-          local.get $1
-          local.get $3
-          i32.const 1
-          i32.or
-          i32.store offset=4
-          local.get $2
-          local.get $0
-          i32.const 3
-          i32.or
-          i32.store offset=4
-          local.get $14
-          global.set $global$1
-          local.get $2
-          i32.const 8
-          i32.add
-          return
-        end
-      end
-      i32.const 4108
-      i32.load
-      if (result i32) ;; label = @2
-        i32.const 4116
-        i32.load
-      else
-        block (result i32) ;; label = @3
-          i32.const 4116
-          i32.const 4096
-          i32.store
-          i32.const 4112
-          i32.const 4096
-          i32.store
-          i32.const 4120
-          i32.const -1
-          i32.store
-          i32.const 4124
-          i32.const -1
-          i32.store
-          i32.const 4128
-          i32.const 0
-          i32.store
-          i32.const 4080
-          i32.const 0
-          i32.store
-          local.get $18
-          local.get $18
-          i32.const -16
-          i32.and
-          i32.const 1431655768
-          i32.xor
-          local.tee $1
-          i32.store
-          i32.const 4108
-          local.get $1
-          i32.store
-          i32.const 4096
-        end
-      end
-      local.tee $1
-      local.get $0
-      i32.const 47
-      i32.add
-      local.tee $13
-      i32.add
-      local.tee $8
-      i32.const 0
-      local.get $1
-      i32.sub
-      local.tee $4
-      i32.and
-      local.tee $6
-      local.get $0
-      i32.le_u
-      if ;; label = @2
-        block ;; label = @3
-          local.get $14
-          global.set $global$1
-          i32.const 0
-          return
-        end
-      end
-      i32.const 4076
-      i32.load
-      local.tee $2
-      if ;; label = @2
-        i32.const 4068
-        i32.load
-        local.tee $3
-        local.get $6
-        i32.add
-        local.tee $1
-        local.get $3
-        i32.le_u
-        local.get $1
-        local.get $2
-        i32.gt_u
-        i32.or
-        if ;; label = @3
-          block ;; label = @4
-            local.get $14
-            global.set $global$1
-            i32.const 0
-            return
-          end
-        end
-      end
-      local.get $0
-      i32.const 48
-      i32.add
-      local.set $7
-      block $label$171 ;; label = @2
-        block $label$172 ;; label = @3
-          i32.const 4080
-          i32.load
-          i32.const 4
-          i32.and
-          i32.eqz
-          if ;; label = @4
-            block ;; label = @5
-              block $label$174 ;; label = @6
-                block $label$175 ;; label = @7
-                  block $label$176 ;; label = @8
-                    i32.const 3660
-                    i32.load
-                    local.tee $3
-                    i32.eqz
-                    br_if 0 (;@8;)
-                    i32.const 4084
-                    local.set $2
-                    loop $label$177 ;; label = @9
-                      block $label$178 ;; label = @10
-                        local.get $2
-                        i32.load
-                        local.tee $1
-                        local.get $3
-                        i32.le_u
-                        if ;; label = @11
-                          local.get $1
-                          local.get $2
-                          i32.const 4
-                          i32.add
-                          local.tee $5
-                          i32.load
-                          i32.add
-                          local.get $3
-                          i32.gt_u
-                          br_if 1 (;@10;)
-                        end
-                        local.get $2
-                        i32.load offset=8
-                        local.tee $1
-                        i32.eqz
-                        br_if 2 (;@8;)
-                        local.get $1
-                        local.set $2
-                        br 1 (;@9;)
-                      end
-                    end
-                    local.get $8
-                    local.get $10
-                    i32.sub
-                    local.get $4
-                    i32.and
-                    local.tee $3
-                    i32.const 2147483647
-                    i32.lt_u
-                    if ;; label = @9
-                      local.get $3
-                      call $40
-                      local.tee $1
-                      local.get $2
-                      i32.load
-                      local.get $5
-                      i32.load
-                      i32.add
-                      i32.eq
-                      if ;; label = @10
-                        local.get $1
-                        i32.const -1
-                        i32.ne
-                        br_if 7 (;@3;)
-                      else
-                        block ;; label = @11
-                          local.get $1
-                          local.set $2
-                          local.get $3
-                          local.set $1
-                          br 4 (;@7;)
-                        end
-                      end
-                    end
-                    br 2 (;@6;)
-                  end
-                  i32.const 0
-                  call $40
-                  local.tee $1
-                  i32.const -1
-                  i32.ne
-                  if ;; label = @8
-                    block ;; label = @9
-                      i32.const 4112
-                      i32.load
-                      local.tee $2
-                      i32.const -1
-                      i32.add
-                      local.tee $5
-                      local.get $1
-                      local.tee $3
-                      i32.add
-                      i32.const 0
-                      local.get $2
-                      i32.sub
-                      i32.and
-                      local.get $3
-                      i32.sub
-                      local.set $2
-                      local.get $5
-                      local.get $3
-                      i32.and
-                      if (result i32) ;; label = @10
-                        local.get $2
-                      else
-                        i32.const 0
-                      end
-                      local.get $6
-                      i32.add
-                      local.tee $3
-                      i32.const 4068
-                      i32.load
-                      local.tee $5
-                      i32.add
-                      local.set $4
-                      local.get $3
-                      local.get $0
-                      i32.gt_u
-                      local.get $3
-                      i32.const 2147483647
-                      i32.lt_u
-                      i32.and
-                      if ;; label = @10
-                        block ;; label = @11
-                          i32.const 4076
-                          i32.load
-                          local.tee $2
-                          if ;; label = @12
-                            local.get $4
-                            local.get $5
-                            i32.le_u
-                            local.get $4
-                            local.get $2
-                            i32.gt_u
-                            i32.or
-                            br_if 6 (;@6;)
-                          end
-                          local.get $3
-                          call $40
-                          local.tee $2
-                          local.get $1
-                          i32.eq
-                          br_if 8 (;@3;)
-                          local.get $3
-                          local.set $1
-                          br 4 (;@7;)
-                        end
-                      end
-                    end
-                  end
-                  br 1 (;@6;)
-                end
-                i32.const 0
-                local.get $1
-                i32.sub
-                local.set $5
-                local.get $7
-                local.get $1
-                i32.gt_u
-                local.get $1
-                i32.const 2147483647
-                i32.lt_u
-                local.get $2
-                i32.const -1
-                i32.ne
-                i32.and
-                i32.and
-                if ;; label = @7
-                  local.get $13
-                  local.get $1
-                  i32.sub
-                  i32.const 4116
-                  i32.load
-                  local.tee $3
-                  i32.add
-                  i32.const 0
-                  local.get $3
-                  i32.sub
-                  i32.and
-                  local.tee $3
-                  i32.const 2147483647
-                  i32.lt_u
-                  if ;; label = @8
-                    local.get $3
-                    call $40
-                    i32.const -1
-                    i32.eq
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $5
-                        call $40
-                        drop
-                        br 4 (;@6;)
-                      end
-                    else
-                      local.get $3
-                      local.get $1
-                      i32.add
-                      local.set $3
-                    end
-                  else
-                    local.get $1
-                    local.set $3
-                  end
-                else
-                  local.get $1
-                  local.set $3
-                end
-                local.get $2
-                i32.const -1
-                i32.ne
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $2
-                    local.set $1
-                    br 5 (;@3;)
-                  end
-                end
-              end
-              i32.const 4080
-              i32.const 4080
-              i32.load
-              i32.const 4
-              i32.or
-              i32.store
-            end
-          end
-          local.get $6
-          i32.const 2147483647
-          i32.lt_u
-          if ;; label = @4
-            local.get $6
-            call $40
-            local.tee $1
-            i32.const 0
-            call $40
-            local.tee $3
-            i32.lt_u
-            local.get $1
-            i32.const -1
-            i32.ne
-            local.get $3
-            i32.const -1
-            i32.ne
-            i32.and
-            i32.and
-            if ;; label = @5
-              local.get $3
-              local.get $1
-              i32.sub
-              local.tee $3
-              local.get $0
-              i32.const 40
-              i32.add
-              i32.gt_u
-              br_if 2 (;@3;)
-            end
-          end
-          br 1 (;@2;)
-        end
-        i32.const 4068
-        i32.const 4068
-        i32.load
-        local.get $3
-        i32.add
-        local.tee $2
-        i32.store
-        local.get $2
-        i32.const 4072
-        i32.load
-        i32.gt_u
-        if ;; label = @3
-          i32.const 4072
-          local.get $2
-          i32.store
-        end
-        block $label$198 ;; label = @3
-          i32.const 3660
-          i32.load
-          local.tee $8
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 4084
-              local.set $2
-              block $label$200 ;; label = @6
-                block $label$201 ;; label = @7
-                  loop $label$202 ;; label = @8
-                    local.get $1
-                    local.get $2
-                    i32.load
-                    local.tee $4
-                    local.get $2
-                    i32.const 4
-                    i32.add
-                    local.tee $7
-                    i32.load
-                    local.tee $5
-                    i32.add
-                    i32.eq
-                    br_if 1 (;@7;)
-                    local.get $2
-                    i32.load offset=8
-                    local.tee $2
-                    br_if 0 (;@8;)
-                  end
-                  br 1 (;@6;)
-                end
-                local.get $2
-                i32.load offset=12
-                i32.const 8
-                i32.and
-                i32.eqz
-                if ;; label = @7
-                  local.get $8
-                  local.get $1
-                  i32.lt_u
-                  local.get $8
-                  local.get $4
-                  i32.ge_u
-                  i32.and
-                  if ;; label = @8
-                    block ;; label = @9
-                      local.get $7
-                      local.get $5
-                      local.get $3
-                      i32.add
-                      i32.store
-                      i32.const 3648
-                      i32.load
-                      local.set $5
-                      i32.const 0
-                      local.get $8
-                      i32.const 8
-                      i32.add
-                      local.tee $2
-                      i32.sub
-                      i32.const 7
-                      i32.and
-                      local.set $1
-                      i32.const 3660
-                      local.get $8
-                      local.get $2
-                      i32.const 7
-                      i32.and
-                      if (result i32) ;; label = @10
-                        local.get $1
-                      else
-                        i32.const 0
-                        local.tee $1
-                      end
-                      i32.add
-                      local.tee $2
-                      i32.store
-                      i32.const 3648
-                      local.get $3
-                      local.get $1
-                      i32.sub
-                      local.get $5
-                      i32.add
-                      local.tee $1
-                      i32.store
-                      local.get $2
-                      local.get $1
-                      i32.const 1
-                      i32.or
-                      i32.store offset=4
-                      local.get $2
-                      local.get $1
-                      i32.add
-                      i32.const 40
-                      i32.store offset=4
-                      i32.const 3664
-                      i32.const 4124
-                      i32.load
-                      i32.store
-                      br 6 (;@3;)
-                    end
-                  end
-                end
-              end
-              local.get $1
-              i32.const 3652
-              i32.load
-              local.tee $2
-              i32.lt_u
-              if ;; label = @6
-                block ;; label = @7
-                  i32.const 3652
-                  local.get $1
-                  i32.store
-                  local.get $1
-                  local.set $2
-                end
-              end
-              local.get $1
-              local.get $3
-              i32.add
-              local.set $10
-              i32.const 4084
-              local.set $5
-              block $label$208 ;; label = @6
-                block $label$209 ;; label = @7
-                  loop $label$210 ;; label = @8
-                    local.get $5
-                    i32.load
-                    local.get $10
-                    i32.eq
-                    br_if 1 (;@7;)
-                    local.get $5
-                    i32.load offset=8
-                    local.tee $5
-                    br_if 0 (;@8;)
-                    i32.const 4084
-                    local.set $5
-                  end
-                  br 1 (;@6;)
-                end
-                local.get $5
-                i32.load offset=12
-                i32.const 8
-                i32.and
-                if ;; label = @7
-                  i32.const 4084
-                  local.set $5
-                else
-                  block ;; label = @8
-                    local.get $5
-                    local.get $1
-                    i32.store
-                    local.get $5
-                    i32.const 4
-                    i32.add
-                    local.tee $5
-                    local.get $5
-                    i32.load
-                    local.get $3
-                    i32.add
-                    i32.store
-                    i32.const 0
-                    local.get $1
-                    i32.const 8
-                    i32.add
-                    local.tee $4
-                    i32.sub
-                    i32.const 7
-                    i32.and
-                    local.set $7
-                    i32.const 0
-                    local.get $10
-                    i32.const 8
-                    i32.add
-                    local.tee $5
-                    i32.sub
-                    i32.const 7
-                    i32.and
-                    local.set $3
-                    local.get $1
-                    local.get $4
-                    i32.const 7
-                    i32.and
-                    if (result i32) ;; label = @9
-                      local.get $7
-                    else
-                      i32.const 0
-                    end
-                    i32.add
-                    local.tee $13
-                    local.get $0
-                    i32.add
-                    local.set $6
-                    local.get $10
-                    local.get $5
-                    i32.const 7
-                    i32.and
-                    if (result i32) ;; label = @9
-                      local.get $3
-                    else
-                      i32.const 0
-                    end
-                    i32.add
-                    local.tee $4
-                    local.get $13
-                    i32.sub
-                    local.get $0
-                    i32.sub
-                    local.set $7
-                    local.get $13
-                    local.get $0
-                    i32.const 3
-                    i32.or
-                    i32.store offset=4
-                    block $label$217 ;; label = @9
-                      local.get $4
-                      local.get $8
-                      i32.eq
-                      if ;; label = @10
-                        block ;; label = @11
-                          i32.const 3648
-                          i32.const 3648
-                          i32.load
-                          local.get $7
-                          i32.add
-                          local.tee $0
-                          i32.store
-                          i32.const 3660
-                          local.get $6
-                          i32.store
-                          local.get $6
-                          local.get $0
-                          i32.const 1
-                          i32.or
-                          i32.store offset=4
-                        end
-                      else
-                        block ;; label = @11
-                          local.get $4
-                          i32.const 3656
-                          i32.load
-                          i32.eq
-                          if ;; label = @12
-                            block ;; label = @13
-                              i32.const 3644
-                              i32.const 3644
-                              i32.load
-                              local.get $7
-                              i32.add
-                              local.tee $0
-                              i32.store
-                              i32.const 3656
-                              local.get $6
-                              i32.store
-                              local.get $6
-                              local.get $0
-                              i32.const 1
-                              i32.or
-                              i32.store offset=4
-                              local.get $6
-                              local.get $0
-                              i32.add
-                              local.get $0
-                              i32.store
-                              br 4 (;@9;)
-                            end
-                          end
-                          local.get $4
-                          i32.load offset=4
-                          local.tee $0
-                          i32.const 3
-                          i32.and
-                          i32.const 1
-                          i32.eq
-                          if (result i32) ;; label = @12
-                            block (result i32) ;; label = @13
-                              local.get $0
-                              i32.const -8
-                              i32.and
-                              local.set $11
-                              local.get $0
-                              i32.const 3
-                              i32.shr_u
-                              local.set $1
-                              block $label$222 ;; label = @14
-                                local.get $0
-                                i32.const 256
-                                i32.lt_u
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $4
-                                    i32.load offset=12
-                                    local.set $5
-                                    block $label$224 ;; label = @17
-                                      local.get $4
-                                      i32.load offset=8
-                                      local.tee $3
-                                      local.get $1
-                                      i32.const 1
-                                      i32.shl
-                                      i32.const 2
-                                      i32.shl
-                                      i32.const 3676
-                                      i32.add
-                                      local.tee $0
-                                      i32.ne
-                                      if ;; label = @18
-                                        block ;; label = @19
-                                          local.get $3
-                                          local.get $2
-                                          i32.lt_u
-                                          if ;; label = @20
-                                            call $fimport$10
-                                          end
-                                          local.get $3
-                                          i32.load offset=12
-                                          local.get $4
-                                          i32.eq
-                                          br_if 2 (;@17;)
-                                          call $fimport$10
-                                        end
-                                      end
-                                    end
-                                    local.get $5
-                                    local.get $3
-                                    i32.eq
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        i32.const 3636
-                                        i32.const 3636
-                                        i32.load
-                                        i32.const 1
-                                        local.get $1
-                                        i32.shl
-                                        i32.const -1
-                                        i32.xor
-                                        i32.and
-                                        i32.store
-                                        br 4 (;@14;)
-                                      end
-                                    end
-                                    block $label$228 ;; label = @17
-                                      local.get $5
-                                      local.get $0
-                                      i32.eq
-                                      if ;; label = @18
-                                        local.get $5
-                                        i32.const 8
-                                        i32.add
-                                        local.set $20
-                                      else
-                                        block ;; label = @19
-                                          local.get $5
-                                          local.get $2
-                                          i32.lt_u
-                                          if ;; label = @20
-                                            call $fimport$10
-                                          end
-                                          local.get $5
-                                          i32.const 8
-                                          i32.add
-                                          local.tee $0
-                                          i32.load
-                                          local.get $4
-                                          i32.eq
-                                          if ;; label = @20
-                                            block ;; label = @21
-                                              local.get $0
-                                              local.set $20
-                                              br 4 (;@17;)
-                                            end
-                                          end
-                                          call $fimport$10
-                                        end
-                                      end
-                                    end
-                                    local.get $3
-                                    local.get $5
-                                    i32.store offset=12
-                                    local.get $20
-                                    local.get $3
-                                    i32.store
-                                  end
-                                else
-                                  block ;; label = @16
-                                    local.get $4
-                                    i32.load offset=24
-                                    local.set $8
-                                    block $label$234 ;; label = @17
-                                      local.get $4
-                                      i32.load offset=12
-                                      local.tee $0
-                                      local.get $4
-                                      i32.eq
-                                      if ;; label = @18
-                                        block ;; label = @19
-                                          local.get $4
-                                          i32.const 16
-                                          i32.add
-                                          local.tee $3
-                                          i32.const 4
-                                          i32.add
-                                          local.tee $1
-                                          i32.load
-                                          local.tee $0
-                                          i32.eqz
-                                          if ;; label = @20
-                                            local.get $3
-                                            i32.load
-                                            local.tee $0
-                                            if ;; label = @21
-                                              local.get $3
-                                              local.set $1
-                                            else
-                                              block ;; label = @22
-                                                i32.const 0
-                                                local.set $12
-                                                br 5 (;@17;)
-                                              end
-                                            end
-                                          end
-                                          loop $label$239 ;; label = @20
-                                            local.get $0
-                                            i32.const 20
-                                            i32.add
-                                            local.tee $5
-                                            i32.load
-                                            local.tee $3
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                local.get $3
-                                                local.set $0
-                                                local.get $5
-                                                local.set $1
-                                                br 2 (;@20;)
-                                              end
-                                            end
-                                            local.get $0
-                                            i32.const 16
-                                            i32.add
-                                            local.tee $5
-                                            i32.load
-                                            local.tee $3
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                local.get $3
-                                                local.set $0
-                                                local.get $5
-                                                local.set $1
-                                                br 2 (;@20;)
-                                              end
-                                            end
-                                          end
-                                          local.get $1
-                                          local.get $2
-                                          i32.lt_u
-                                          if ;; label = @20
-                                            call $fimport$10
-                                          else
-                                            block ;; label = @21
-                                              local.get $1
-                                              i32.const 0
-                                              i32.store
-                                              local.get $0
-                                              local.set $12
-                                            end
-                                          end
-                                        end
-                                      else
-                                        block ;; label = @19
-                                          local.get $4
-                                          i32.load offset=8
-                                          local.tee $5
-                                          local.get $2
-                                          i32.lt_u
-                                          if ;; label = @20
-                                            call $fimport$10
-                                          end
-                                          local.get $5
-                                          i32.const 12
-                                          i32.add
-                                          local.tee $3
-                                          i32.load
-                                          local.get $4
-                                          i32.ne
-                                          if ;; label = @20
-                                            call $fimport$10
-                                          end
-                                          local.get $0
-                                          i32.const 8
-                                          i32.add
-                                          local.tee $1
-                                          i32.load
-                                          local.get $4
-                                          i32.eq
-                                          if ;; label = @20
-                                            block ;; label = @21
-                                              local.get $3
-                                              local.get $0
-                                              i32.store
-                                              local.get $1
-                                              local.get $5
-                                              i32.store
-                                              local.get $0
-                                              local.set $12
-                                            end
-                                          else
-                                            call $fimport$10
-                                          end
-                                        end
-                                      end
-                                    end
-                                    local.get $8
-                                    i32.eqz
-                                    br_if 2 (;@14;)
-                                    block $label$249 ;; label = @17
-                                      local.get $4
-                                      local.get $4
-                                      i32.load offset=28
-                                      local.tee $1
-                                      i32.const 2
-                                      i32.shl
-                                      i32.const 3940
-                                      i32.add
-                                      local.tee $0
-                                      i32.load
-                                      i32.eq
-                                      if ;; label = @18
-                                        block ;; label = @19
-                                          local.get $0
-                                          local.get $12
-                                          i32.store
-                                          local.get $12
-                                          br_if 2 (;@17;)
-                                          i32.const 3640
-                                          i32.const 3640
-                                          i32.load
-                                          i32.const 1
-                                          local.get $1
-                                          i32.shl
-                                          i32.const -1
-                                          i32.xor
-                                          i32.and
-                                          i32.store
-                                          br 5 (;@14;)
-                                        end
-                                      else
-                                        block ;; label = @19
-                                          local.get $8
-                                          i32.const 3652
-                                          i32.load
-                                          i32.lt_u
-                                          if ;; label = @20
-                                            call $fimport$10
-                                          end
-                                          local.get $8
-                                          i32.const 16
-                                          i32.add
-                                          local.tee $0
-                                          i32.load
-                                          local.get $4
-                                          i32.eq
-                                          if ;; label = @20
-                                            local.get $0
-                                            local.get $12
-                                            i32.store
-                                          else
-                                            local.get $8
-                                            local.get $12
-                                            i32.store offset=20
-                                          end
-                                          local.get $12
-                                          i32.eqz
-                                          br_if 5 (;@14;)
-                                        end
-                                      end
-                                    end
-                                    local.get $12
-                                    i32.const 3652
-                                    i32.load
-                                    local.tee $1
-                                    i32.lt_u
-                                    if ;; label = @17
-                                      call $fimport$10
-                                    end
-                                    local.get $12
-                                    local.get $8
-                                    i32.store offset=24
-                                    local.get $4
-                                    i32.const 16
-                                    i32.add
-                                    local.tee $0
-                                    i32.load
-                                    local.tee $3
-                                    if ;; label = @17
-                                      local.get $3
-                                      local.get $1
-                                      i32.lt_u
-                                      if ;; label = @18
-                                        call $fimport$10
-                                      else
-                                        block ;; label = @19
-                                          local.get $12
-                                          local.get $3
-                                          i32.store offset=16
-                                          local.get $3
-                                          local.get $12
-                                          i32.store offset=24
-                                        end
-                                      end
-                                    end
-                                    local.get $0
-                                    i32.load offset=4
-                                    local.tee $0
-                                    i32.eqz
-                                    br_if 2 (;@14;)
-                                    local.get $0
-                                    i32.const 3652
-                                    i32.load
-                                    i32.lt_u
-                                    if ;; label = @17
-                                      call $fimport$10
-                                    else
-                                      block ;; label = @18
-                                        local.get $12
-                                        local.get $0
-                                        i32.store offset=20
-                                        local.get $0
-                                        local.get $12
-                                        i32.store offset=24
-                                      end
-                                    end
-                                  end
-                                end
-                              end
-                              local.get $11
-                              local.get $7
-                              i32.add
-                              local.set $7
-                              local.get $4
-                              local.get $11
-                              i32.add
-                            end
-                          else
-                            local.get $4
-                          end
-                          local.tee $0
-                          i32.const 4
-                          i32.add
-                          local.tee $0
-                          local.get $0
-                          i32.load
-                          i32.const -2
-                          i32.and
-                          i32.store
-                          local.get $6
-                          local.get $7
-                          i32.const 1
-                          i32.or
-                          i32.store offset=4
-                          local.get $6
-                          local.get $7
-                          i32.add
-                          local.get $7
-                          i32.store
-                          local.get $7
-                          i32.const 3
-                          i32.shr_u
-                          local.set $0
-                          local.get $7
-                          i32.const 256
-                          i32.lt_u
-                          if ;; label = @12
-                            block ;; label = @13
-                              local.get $0
-                              i32.const 1
-                              i32.shl
-                              i32.const 2
-                              i32.shl
-                              i32.const 3676
-                              i32.add
-                              local.set $3
-                              block $label$263 ;; label = @14
-                                i32.const 3636
-                                i32.load
-                                local.tee $1
-                                i32.const 1
-                                local.get $0
-                                i32.shl
-                                local.tee $0
-                                i32.and
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $3
-                                    i32.const 8
-                                    i32.add
-                                    local.tee $1
-                                    i32.load
-                                    local.tee $0
-                                    i32.const 3652
-                                    i32.load
-                                    i32.ge_u
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        local.get $1
-                                        local.set $21
-                                        local.get $0
-                                        local.set $9
-                                        br 4 (;@14;)
-                                      end
-                                    end
-                                    call $fimport$10
-                                  end
-                                else
-                                  block ;; label = @16
-                                    i32.const 3636
-                                    local.get $1
-                                    local.get $0
-                                    i32.or
-                                    i32.store
-                                    local.get $3
-                                    i32.const 8
-                                    i32.add
-                                    local.set $21
-                                    local.get $3
-                                    local.set $9
-                                  end
-                                end
-                              end
-                              local.get $21
-                              local.get $6
-                              i32.store
-                              local.get $9
-                              local.get $6
-                              i32.store offset=12
-                              local.get $6
-                              local.get $9
-                              i32.store offset=8
-                              local.get $6
-                              local.get $3
-                              i32.store offset=12
-                              br 4 (;@9;)
-                            end
-                          end
-                          block $label$267 (result i32) ;; label = @12
-                            local.get $7
-                            i32.const 8
-                            i32.shr_u
-                            local.tee $0
-                            if (result i32) ;; label = @13
-                              block (result i32) ;; label = @14
-                                i32.const 31
-                                local.get $7
-                                i32.const 16777215
-                                i32.gt_u
-                                br_if 2 (;@12;)
-                                drop
-                                local.get $7
-                                i32.const 14
-                                local.get $0
-                                local.get $0
-                                i32.const 1048320
-                                i32.add
-                                i32.const 16
-                                i32.shr_u
-                                i32.const 8
-                                i32.and
-                                local.tee $3
-                                i32.shl
-                                local.tee $1
-                                i32.const 520192
-                                i32.add
-                                i32.const 16
-                                i32.shr_u
-                                i32.const 4
-                                i32.and
-                                local.tee $0
-                                local.get $3
-                                i32.or
-                                local.get $1
-                                local.get $0
-                                i32.shl
-                                local.tee $1
-                                i32.const 245760
-                                i32.add
-                                i32.const 16
-                                i32.shr_u
-                                i32.const 2
-                                i32.and
-                                local.tee $0
-                                i32.or
-                                i32.sub
-                                local.get $1
-                                local.get $0
-                                i32.shl
-                                i32.const 15
-                                i32.shr_u
-                                i32.add
-                                local.tee $0
-                                i32.const 7
-                                i32.add
-                                i32.shr_u
-                                i32.const 1
-                                i32.and
-                                local.get $0
-                                i32.const 1
-                                i32.shl
-                                i32.or
-                              end
-                            else
-                              i32.const 0
-                            end
-                          end
-                          local.tee $2
-                          i32.const 2
-                          i32.shl
-                          i32.const 3940
-                          i32.add
-                          local.set $3
-                          local.get $6
-                          local.get $2
-                          i32.store offset=28
-                          local.get $6
-                          i32.const 16
-                          i32.add
-                          local.tee $0
-                          i32.const 0
-                          i32.store offset=4
-                          local.get $0
-                          i32.const 0
-                          i32.store
-                          i32.const 3640
-                          i32.load
-                          local.tee $1
-                          i32.const 1
-                          local.get $2
-                          i32.shl
-                          local.tee $0
-                          i32.and
-                          i32.eqz
-                          if ;; label = @12
-                            block ;; label = @13
-                              i32.const 3640
-                              local.get $1
-                              local.get $0
-                              i32.or
-                              i32.store
-                              local.get $3
-                              local.get $6
-                              i32.store
-                              local.get $6
-                              local.get $3
-                              i32.store offset=24
-                              local.get $6
-                              local.get $6
-                              i32.store offset=12
-                              local.get $6
-                              local.get $6
-                              i32.store offset=8
-                              br 4 (;@9;)
-                            end
-                          end
-                          local.get $3
-                          i32.load
-                          local.set $0
-                          i32.const 25
-                          local.get $2
-                          i32.const 1
-                          i32.shr_u
-                          i32.sub
-                          local.set $1
-                          local.get $7
-                          local.get $2
-                          i32.const 31
-                          i32.eq
-                          if (result i32) ;; label = @12
-                            i32.const 0
-                          else
-                            local.get $1
-                          end
-                          i32.shl
-                          local.set $2
-                          block $label$273 ;; label = @12
-                            block $label$274 ;; label = @13
-                              block $label$275 ;; label = @14
-                                loop $label$276 ;; label = @15
-                                  local.get $0
-                                  i32.load offset=4
-                                  i32.const -8
-                                  i32.and
-                                  local.get $7
-                                  i32.eq
-                                  br_if 2 (;@13;)
-                                  local.get $2
-                                  i32.const 1
-                                  i32.shl
-                                  local.set $3
-                                  local.get $0
-                                  i32.const 16
-                                  i32.add
-                                  local.get $2
-                                  i32.const 31
-                                  i32.shr_u
-                                  i32.const 2
-                                  i32.shl
-                                  i32.add
-                                  local.tee $2
-                                  i32.load
-                                  local.tee $1
-                                  i32.eqz
-                                  br_if 1 (;@14;)
-                                  local.get $3
-                                  local.set $2
-                                  local.get $1
-                                  local.set $0
-                                  br 0 (;@15;)
-                                end
-                              end
-                              local.get $2
-                              i32.const 3652
-                              i32.load
-                              i32.lt_u
-                              if ;; label = @14
-                                call $fimport$10
-                              else
-                                block ;; label = @15
-                                  local.get $2
-                                  local.get $6
-                                  i32.store
-                                  local.get $6
-                                  local.get $0
-                                  i32.store offset=24
-                                  local.get $6
-                                  local.get $6
-                                  i32.store offset=12
-                                  local.get $6
-                                  local.get $6
-                                  i32.store offset=8
-                                  br 6 (;@9;)
-                                end
-                              end
-                              br 1 (;@12;)
-                            end
-                            local.get $0
-                            i32.const 8
-                            i32.add
-                            local.tee $3
-                            i32.load
-                            local.tee $2
-                            i32.const 3652
-                            i32.load
-                            local.tee $1
-                            i32.ge_u
-                            local.get $0
-                            local.get $1
-                            i32.ge_u
-                            i32.and
-                            if ;; label = @13
-                              block ;; label = @14
-                                local.get $2
-                                local.get $6
-                                i32.store offset=12
-                                local.get $3
-                                local.get $6
-                                i32.store
-                                local.get $6
-                                local.get $2
-                                i32.store offset=8
-                                local.get $6
-                                local.get $0
-                                i32.store offset=12
-                                local.get $6
-                                i32.const 0
-                                i32.store offset=24
-                              end
-                            else
-                              call $fimport$10
-                            end
-                          end
-                        end
-                      end
-                    end
-                    local.get $14
-                    global.set $global$1
-                    local.get $13
-                    i32.const 8
-                    i32.add
-                    return
-                  end
-                end
-              end
-              loop $label$281 ;; label = @6
-                block $label$282 ;; label = @7
-                  local.get $5
-                  i32.load
-                  local.tee $2
-                  local.get $8
-                  i32.le_u
-                  if ;; label = @8
-                    local.get $2
-                    local.get $5
-                    i32.load offset=4
-                    i32.add
-                    local.tee $13
-                    local.get $8
-                    i32.gt_u
-                    br_if 1 (;@7;)
-                  end
-                  local.get $5
-                  i32.load offset=8
-                  local.set $5
-                  br 1 (;@6;)
-                end
-              end
-              i32.const 0
-              local.get $13
-              i32.const -47
-              i32.add
-              local.tee $7
-              i32.const 8
-              i32.add
-              local.tee $5
-              i32.sub
-              i32.const 7
-              i32.and
-              local.set $2
-              local.get $7
-              local.get $5
-              i32.const 7
-              i32.and
-              if (result i32) ;; label = @6
-                local.get $2
-              else
-                i32.const 0
-              end
-              i32.add
-              local.tee $2
-              local.get $8
-              i32.const 16
-              i32.add
-              local.tee $12
-              i32.lt_u
-              if (result i32) ;; label = @6
-                local.get $8
-              else
-                local.get $2
-              end
-              local.tee $7
-              i32.const 8
-              i32.add
-              local.set $10
-              local.get $7
-              i32.const 24
-              i32.add
-              local.set $5
-              local.get $3
-              i32.const -40
-              i32.add
-              local.set $9
-              i32.const 0
-              local.get $1
-              i32.const 8
-              i32.add
-              local.tee $4
-              i32.sub
-              i32.const 7
-              i32.and
-              local.set $2
-              i32.const 3660
-              local.get $1
-              local.get $4
-              i32.const 7
-              i32.and
-              if (result i32) ;; label = @6
-                local.get $2
-              else
-                i32.const 0
-                local.tee $2
-              end
-              i32.add
-              local.tee $4
-              i32.store
-              i32.const 3648
-              local.get $9
-              local.get $2
-              i32.sub
-              local.tee $2
-              i32.store
-              local.get $4
-              local.get $2
-              i32.const 1
-              i32.or
-              i32.store offset=4
-              local.get $4
-              local.get $2
-              i32.add
-              i32.const 40
-              i32.store offset=4
-              i32.const 3664
-              i32.const 4124
-              i32.load
-              i32.store
-              local.get $7
-              i32.const 4
-              i32.add
-              local.tee $2
-              i32.const 27
-              i32.store
-              local.get $10
-              i32.const 4084
-              i64.load align=4
-              i64.store align=4
-              local.get $10
-              i32.const 4092
-              i64.load align=4
-              i64.store offset=8 align=4
-              i32.const 4084
-              local.get $1
-              i32.store
-              i32.const 4088
-              local.get $3
-              i32.store
-              i32.const 4096
-              i32.const 0
-              i32.store
-              i32.const 4092
-              local.get $10
-              i32.store
-              local.get $5
-              local.set $1
-              loop $label$290 ;; label = @6
-                local.get $1
-                i32.const 4
-                i32.add
-                local.tee $1
-                i32.const 7
-                i32.store
-                local.get $1
-                i32.const 4
-                i32.add
-                local.get $13
-                i32.lt_u
-                br_if 0 (;@6;)
-              end
-              local.get $7
-              local.get $8
-              i32.ne
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $2
-                  local.get $2
-                  i32.load
-                  i32.const -2
-                  i32.and
-                  i32.store
-                  local.get $8
-                  local.get $7
-                  local.get $8
-                  i32.sub
-                  local.tee $4
-                  i32.const 1
-                  i32.or
-                  i32.store offset=4
-                  local.get $7
-                  local.get $4
-                  i32.store
-                  local.get $4
-                  i32.const 3
-                  i32.shr_u
-                  local.set $1
-                  local.get $4
-                  i32.const 256
-                  i32.lt_u
-                  if ;; label = @8
-                    block ;; label = @9
-                      local.get $1
-                      i32.const 1
-                      i32.shl
-                      i32.const 2
-                      i32.shl
-                      i32.const 3676
-                      i32.add
-                      local.set $2
-                      i32.const 3636
-                      i32.load
-                      local.tee $3
-                      i32.const 1
-                      local.get $1
-                      i32.shl
-                      local.tee $1
-                      i32.and
-                      if ;; label = @10
-                        local.get $2
-                        i32.const 8
-                        i32.add
-                        local.tee $3
-                        i32.load
-                        local.tee $1
-                        i32.const 3652
-                        i32.load
-                        i32.lt_u
-                        if ;; label = @11
-                          call $fimport$10
-                        else
-                          block ;; label = @12
-                            local.get $3
-                            local.set $15
-                            local.get $1
-                            local.set $11
-                          end
-                        end
-                      else
-                        block ;; label = @11
-                          i32.const 3636
-                          local.get $3
-                          local.get $1
-                          i32.or
-                          i32.store
-                          local.get $2
-                          i32.const 8
-                          i32.add
-                          local.set $15
-                          local.get $2
-                          local.set $11
-                        end
-                      end
-                      local.get $15
-                      local.get $8
-                      i32.store
-                      local.get $11
-                      local.get $8
-                      i32.store offset=12
-                      local.get $8
-                      local.get $11
-                      i32.store offset=8
-                      local.get $8
-                      local.get $2
-                      i32.store offset=12
-                      br 6 (;@3;)
-                    end
-                  end
-                  local.get $4
-                  i32.const 8
-                  i32.shr_u
-                  local.tee $1
-                  if (result i32) ;; label = @8
-                    local.get $4
-                    i32.const 16777215
-                    i32.gt_u
-                    if (result i32) ;; label = @9
-                      i32.const 31
-                    else
-                      local.get $4
-                      i32.const 14
-                      local.get $1
-                      local.get $1
-                      i32.const 1048320
-                      i32.add
-                      i32.const 16
-                      i32.shr_u
-                      i32.const 8
-                      i32.and
-                      local.tee $2
-                      i32.shl
-                      local.tee $3
-                      i32.const 520192
-                      i32.add
-                      i32.const 16
-                      i32.shr_u
-                      i32.const 4
-                      i32.and
-                      local.tee $1
-                      local.get $2
-                      i32.or
-                      local.get $3
-                      local.get $1
-                      i32.shl
-                      local.tee $3
-                      i32.const 245760
-                      i32.add
-                      i32.const 16
-                      i32.shr_u
-                      i32.const 2
-                      i32.and
-                      local.tee $1
-                      i32.or
-                      i32.sub
-                      local.get $3
-                      local.get $1
-                      i32.shl
-                      i32.const 15
-                      i32.shr_u
-                      i32.add
-                      local.tee $1
-                      i32.const 7
-                      i32.add
-                      i32.shr_u
-                      i32.const 1
-                      i32.and
-                      local.get $1
-                      i32.const 1
-                      i32.shl
-                      i32.or
-                    end
-                  else
-                    i32.const 0
-                  end
-                  local.tee $5
-                  i32.const 2
-                  i32.shl
-                  i32.const 3940
-                  i32.add
-                  local.set $2
-                  local.get $8
-                  local.get $5
-                  i32.store offset=28
-                  local.get $8
-                  i32.const 0
-                  i32.store offset=20
-                  local.get $12
-                  i32.const 0
-                  i32.store
-                  i32.const 3640
-                  i32.load
-                  local.tee $3
-                  i32.const 1
-                  local.get $5
-                  i32.shl
-                  local.tee $1
-                  i32.and
-                  i32.eqz
-                  if ;; label = @8
-                    block ;; label = @9
-                      i32.const 3640
-                      local.get $3
-                      local.get $1
-                      i32.or
-                      i32.store
-                      local.get $2
-                      local.get $8
-                      i32.store
-                      local.get $8
-                      local.get $2
-                      i32.store offset=24
-                      local.get $8
-                      local.get $8
-                      i32.store offset=12
-                      local.get $8
-                      local.get $8
-                      i32.store offset=8
-                      br 6 (;@3;)
-                    end
-                  end
-                  local.get $2
-                  i32.load
-                  local.set $1
-                  i32.const 25
-                  local.get $5
-                  i32.const 1
-                  i32.shr_u
-                  i32.sub
-                  local.set $3
-                  local.get $4
-                  local.get $5
-                  i32.const 31
-                  i32.eq
-                  if (result i32) ;; label = @8
-                    i32.const 0
-                  else
-                    local.get $3
-                  end
-                  i32.shl
-                  local.set $5
-                  block $label$304 ;; label = @8
-                    block $label$305 ;; label = @9
-                      block $label$306 ;; label = @10
-                        loop $label$307 ;; label = @11
-                          local.get $1
-                          i32.load offset=4
-                          i32.const -8
-                          i32.and
-                          local.get $4
-                          i32.eq
-                          br_if 2 (;@9;)
-                          local.get $5
-                          i32.const 1
-                          i32.shl
-                          local.set $2
-                          local.get $1
-                          i32.const 16
-                          i32.add
-                          local.get $5
-                          i32.const 31
-                          i32.shr_u
-                          i32.const 2
-                          i32.shl
-                          i32.add
-                          local.tee $5
-                          i32.load
-                          local.tee $3
-                          i32.eqz
-                          br_if 1 (;@10;)
-                          local.get $2
-                          local.set $5
-                          local.get $3
-                          local.set $1
-                          br 0 (;@11;)
-                        end
-                      end
-                      local.get $5
-                      i32.const 3652
-                      i32.load
-                      i32.lt_u
-                      if ;; label = @10
-                        call $fimport$10
-                      else
-                        block ;; label = @11
-                          local.get $5
-                          local.get $8
-                          i32.store
-                          local.get $8
-                          local.get $1
-                          i32.store offset=24
-                          local.get $8
-                          local.get $8
-                          i32.store offset=12
-                          local.get $8
-                          local.get $8
-                          i32.store offset=8
-                          br 8 (;@3;)
-                        end
-                      end
-                      br 1 (;@8;)
-                    end
-                    local.get $1
-                    i32.const 8
-                    i32.add
-                    local.tee $2
-                    i32.load
-                    local.tee $5
-                    i32.const 3652
-                    i32.load
-                    local.tee $3
-                    i32.ge_u
-                    local.get $1
-                    local.get $3
-                    i32.ge_u
-                    i32.and
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $5
-                        local.get $8
-                        i32.store offset=12
-                        local.get $2
-                        local.get $8
-                        i32.store
-                        local.get $8
-                        local.get $5
-                        i32.store offset=8
-                        local.get $8
-                        local.get $1
-                        i32.store offset=12
-                        local.get $8
-                        i32.const 0
-                        i32.store offset=24
-                      end
-                    else
-                      call $fimport$10
-                    end
-                  end
-                end
-              end
-            end
-          else
-            block ;; label = @5
-              i32.const 3652
-              i32.load
-              local.tee $2
-              i32.eqz
-              local.get $1
-              local.get $2
-              i32.lt_u
-              i32.or
-              if ;; label = @6
-                i32.const 3652
-                local.get $1
-                i32.store
-              end
-              i32.const 4084
-              local.get $1
-              i32.store
-              i32.const 4088
-              local.get $3
-              i32.store
-              i32.const 4096
-              i32.const 0
-              i32.store
-              i32.const 3672
-              i32.const 4108
-              i32.load
-              i32.store
-              i32.const 3668
-              i32.const -1
-              i32.store
-              i32.const 0
-              local.set $2
-              loop $label$314 ;; label = @6
-                local.get $2
-                i32.const 1
-                i32.shl
-                i32.const 2
-                i32.shl
-                i32.const 3676
-                i32.add
-                local.tee $5
-                local.get $5
-                i32.store offset=12
-                local.get $5
-                local.get $5
-                i32.store offset=8
-                local.get $2
-                i32.const 1
-                i32.add
-                local.tee $2
-                i32.const 32
-                i32.ne
-                br_if 0 (;@6;)
-              end
-              local.get $3
-              i32.const -40
-              i32.add
-              local.set $5
-              i32.const 0
-              local.get $1
-              i32.const 8
-              i32.add
-              local.tee $2
-              i32.sub
-              i32.const 7
-              i32.and
-              local.set $3
-              i32.const 3660
-              local.get $1
-              local.get $2
-              i32.const 7
-              i32.and
-              if (result i32) ;; label = @6
-                local.get $3
-              else
-                i32.const 0
-              end
-              local.tee $1
-              i32.add
-              local.tee $3
-              i32.store
-              i32.const 3648
-              local.get $5
-              local.get $1
-              i32.sub
-              local.tee $1
-              i32.store
-              local.get $3
-              local.get $1
-              i32.const 1
-              i32.or
-              i32.store offset=4
-              local.get $3
-              local.get $1
-              i32.add
-              i32.const 40
-              i32.store offset=4
-              i32.const 3664
-              i32.const 4124
-              i32.load
-              i32.store
-            end
-          end
-        end
-        i32.const 3648
-        i32.load
-        local.tee $1
-        local.get $0
-        i32.gt_u
-        if ;; label = @3
-          block ;; label = @4
-            i32.const 3648
-            local.get $1
-            local.get $0
-            i32.sub
-            local.tee $3
-            i32.store
-            i32.const 3660
-            i32.const 3660
-            i32.load
-            local.tee $2
-            local.get $0
-            i32.add
-            local.tee $1
-            i32.store
-            local.get $1
-            local.get $3
-            i32.const 1
-            i32.or
-            i32.store offset=4
-            local.get $2
-            local.get $0
-            i32.const 3
-            i32.or
-            i32.store offset=4
-            local.get $14
-            global.set $global$1
-            local.get $2
-            i32.const 8
-            i32.add
-            return
-          end
-        end
-      end
-      call $12
-      i32.const 12
-      i32.store
-      local.get $14
-      global.set $global$1
-      i32.const 0
-    end
-  )
-  (func $38 (;51;) (type $2) (param $0 i32)
-    (local $1 i32) (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32) (local $15 i32)
-    block $label$1 ;; label = @1
-      local.get $0
-      i32.eqz
-      if ;; label = @2
-        return
-      end
-      local.get $0
-      i32.const -8
-      i32.add
-      local.tee $1
-      i32.const 3652
-      i32.load
-      local.tee $11
-      i32.lt_u
-      if ;; label = @2
-        call $fimport$10
-      end
-      local.get $0
-      i32.const -4
-      i32.add
-      i32.load
-      local.tee $0
-      i32.const 3
-      i32.and
-      local.tee $8
-      i32.const 1
-      i32.eq
-      if ;; label = @2
-        call $fimport$10
-      end
-      local.get $1
-      local.get $0
-      i32.const -8
-      i32.and
-      local.tee $4
-      i32.add
-      local.set $6
-      block $label$5 ;; label = @2
-        local.get $0
-        i32.const 1
-        i32.and
-        if ;; label = @3
-          block ;; label = @4
-            local.get $1
-            local.set $3
-            local.get $4
-            local.set $2
-          end
-        else
-          block ;; label = @4
-            local.get $8
-            i32.eqz
-            if ;; label = @5
-              return
-            end
-            local.get $1
-            i32.const 0
-            local.get $1
-            i32.load
-            local.tee $8
-            i32.sub
-            i32.add
-            local.tee $0
-            local.get $11
-            i32.lt_u
-            if ;; label = @5
-              call $fimport$10
-            end
-            local.get $8
-            local.get $4
-            i32.add
-            local.set $1
-            local.get $0
-            i32.const 3656
-            i32.load
-            i32.eq
-            if ;; label = @5
-              block ;; label = @6
-                local.get $6
-                i32.const 4
-                i32.add
-                local.tee $2
-                i32.load
-                local.tee $3
-                i32.const 3
-                i32.and
-                i32.const 3
-                i32.ne
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $0
-                    local.set $3
-                    local.get $1
-                    local.set $2
-                    br 6 (;@2;)
-                  end
-                end
-                i32.const 3644
-                local.get $1
-                i32.store
-                local.get $2
-                local.get $3
-                i32.const -2
-                i32.and
-                i32.store
-                local.get $0
-                local.get $1
-                i32.const 1
-                i32.or
-                i32.store offset=4
-                local.get $0
-                local.get $1
-                i32.add
-                local.get $1
-                i32.store
-                return
-              end
-            end
-            local.get $8
-            i32.const 3
-            i32.shr_u
-            local.set $10
-            local.get $8
-            i32.const 256
-            i32.lt_u
-            if ;; label = @5
-              block ;; label = @6
-                local.get $0
-                i32.load offset=12
-                local.set $3
-                local.get $0
-                i32.load offset=8
-                local.tee $4
-                local.get $10
-                i32.const 1
-                i32.shl
-                i32.const 2
-                i32.shl
-                i32.const 3676
-                i32.add
-                local.tee $2
-                i32.ne
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $4
-                    local.get $11
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                    local.get $4
-                    i32.load offset=12
-                    local.get $0
-                    i32.ne
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                  end
-                end
-                local.get $3
-                local.get $4
-                i32.eq
-                if ;; label = @7
-                  block ;; label = @8
-                    i32.const 3636
-                    i32.const 3636
-                    i32.load
-                    i32.const 1
-                    local.get $10
-                    i32.shl
-                    i32.const -1
-                    i32.xor
-                    i32.and
-                    i32.store
-                    local.get $0
-                    local.set $3
-                    local.get $1
-                    local.set $2
-                    br 6 (;@2;)
-                  end
-                end
-                local.get $3
-                local.get $2
-                i32.eq
-                if ;; label = @7
-                  local.get $3
-                  i32.const 8
-                  i32.add
-                  local.set $5
-                else
-                  block ;; label = @8
-                    local.get $3
-                    local.get $11
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                    local.get $3
-                    i32.const 8
-                    i32.add
-                    local.tee $2
-                    i32.load
-                    local.get $0
-                    i32.eq
-                    if ;; label = @9
-                      local.get $2
-                      local.set $5
-                    else
-                      call $fimport$10
-                    end
-                  end
-                end
-                local.get $4
-                local.get $3
-                i32.store offset=12
-                local.get $5
-                local.get $4
-                i32.store
-                local.get $0
-                local.set $3
-                local.get $1
-                local.set $2
-                br 4 (;@2;)
-              end
-            end
-            local.get $0
-            i32.load offset=24
-            local.set $12
-            block $label$22 ;; label = @5
-              local.get $0
-              i32.load offset=12
-              local.tee $4
-              local.get $0
-              i32.eq
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $0
-                  i32.const 16
-                  i32.add
-                  local.tee $5
-                  i32.const 4
-                  i32.add
-                  local.tee $8
-                  i32.load
-                  local.tee $4
-                  if ;; label = @8
-                    local.get $8
-                    local.set $5
-                  else
-                    local.get $5
-                    i32.load
-                    local.tee $4
-                    i32.eqz
-                    if ;; label = @9
-                      block ;; label = @10
-                        i32.const 0
-                        local.set $7
-                        br 5 (;@5;)
-                      end
-                    end
-                  end
-                  loop $label$27 ;; label = @8
-                    local.get $4
-                    i32.const 20
-                    i32.add
-                    local.tee $8
-                    i32.load
-                    local.tee $10
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $10
-                        local.set $4
-                        local.get $8
-                        local.set $5
-                        br 2 (;@8;)
-                      end
-                    end
-                    local.get $4
-                    i32.const 16
-                    i32.add
-                    local.tee $8
-                    i32.load
-                    local.tee $10
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $10
-                        local.set $4
-                        local.get $8
-                        local.set $5
-                        br 2 (;@8;)
-                      end
-                    end
-                  end
-                  local.get $5
-                  local.get $11
-                  i32.lt_u
-                  if ;; label = @8
-                    call $fimport$10
-                  else
-                    block ;; label = @9
-                      local.get $5
-                      i32.const 0
-                      i32.store
-                      local.get $4
-                      local.set $7
-                    end
-                  end
-                end
-              else
-                block ;; label = @7
-                  local.get $0
-                  i32.load offset=8
-                  local.tee $5
-                  local.get $11
-                  i32.lt_u
-                  if ;; label = @8
-                    call $fimport$10
-                  end
-                  local.get $5
-                  i32.const 12
-                  i32.add
-                  local.tee $8
-                  i32.load
-                  local.get $0
-                  i32.ne
-                  if ;; label = @8
-                    call $fimport$10
-                  end
-                  local.get $4
-                  i32.const 8
-                  i32.add
-                  local.tee $10
-                  i32.load
-                  local.get $0
-                  i32.eq
-                  if ;; label = @8
-                    block ;; label = @9
-                      local.get $8
-                      local.get $4
-                      i32.store
-                      local.get $10
-                      local.get $5
-                      i32.store
-                      local.get $4
-                      local.set $7
-                    end
-                  else
-                    call $fimport$10
-                  end
-                end
-              end
-            end
-            local.get $12
-            if ;; label = @5
-              block ;; label = @6
-                local.get $0
-                local.get $0
-                i32.load offset=28
-                local.tee $4
-                i32.const 2
-                i32.shl
-                i32.const 3940
-                i32.add
-                local.tee $5
-                i32.load
-                i32.eq
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $5
-                    local.get $7
-                    i32.store
-                    local.get $7
-                    i32.eqz
-                    if ;; label = @9
-                      block ;; label = @10
-                        i32.const 3640
-                        i32.const 3640
-                        i32.load
-                        i32.const 1
-                        local.get $4
-                        i32.shl
-                        i32.const -1
-                        i32.xor
-                        i32.and
-                        i32.store
-                        local.get $0
-                        local.set $3
-                        local.get $1
-                        local.set $2
-                        br 8 (;@2;)
-                      end
-                    end
-                  end
-                else
-                  block ;; label = @8
-                    local.get $12
-                    i32.const 3652
-                    i32.load
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                    local.get $12
-                    i32.const 16
-                    i32.add
-                    local.tee $4
-                    i32.load
-                    local.get $0
-                    i32.eq
-                    if ;; label = @9
-                      local.get $4
-                      local.get $7
-                      i32.store
-                    else
-                      local.get $12
-                      local.get $7
-                      i32.store offset=20
-                    end
-                    local.get $7
-                    i32.eqz
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $0
-                        local.set $3
-                        local.get $1
-                        local.set $2
-                        br 8 (;@2;)
-                      end
-                    end
-                  end
-                end
-                local.get $7
-                i32.const 3652
-                i32.load
-                local.tee $5
-                i32.lt_u
-                if ;; label = @7
-                  call $fimport$10
-                end
-                local.get $7
-                local.get $12
-                i32.store offset=24
-                local.get $0
-                i32.const 16
-                i32.add
-                local.tee $8
-                i32.load
-                local.tee $4
-                if ;; label = @7
-                  local.get $4
-                  local.get $5
-                  i32.lt_u
-                  if ;; label = @8
-                    call $fimport$10
-                  else
-                    block ;; label = @9
-                      local.get $7
-                      local.get $4
-                      i32.store offset=16
-                      local.get $4
-                      local.get $7
-                      i32.store offset=24
-                    end
-                  end
-                end
-                local.get $8
-                i32.load offset=4
-                local.tee $4
-                if ;; label = @7
-                  local.get $4
-                  i32.const 3652
-                  i32.load
-                  i32.lt_u
-                  if ;; label = @8
-                    call $fimport$10
-                  else
-                    block ;; label = @9
-                      local.get $7
-                      local.get $4
-                      i32.store offset=20
-                      local.get $4
-                      local.get $7
-                      i32.store offset=24
-                      local.get $0
-                      local.set $3
-                      local.get $1
-                      local.set $2
-                    end
-                  end
-                else
-                  block ;; label = @8
-                    local.get $0
-                    local.set $3
-                    local.get $1
-                    local.set $2
-                  end
-                end
-              end
-            else
-              block ;; label = @6
-                local.get $0
-                local.set $3
-                local.get $1
-                local.set $2
-              end
-            end
-          end
-        end
-      end
-      local.get $3
-      local.get $6
-      i32.ge_u
-      if ;; label = @2
-        call $fimport$10
-      end
-      local.get $6
-      i32.const 4
-      i32.add
-      local.tee $1
-      i32.load
-      local.tee $0
-      i32.const 1
-      i32.and
-      i32.eqz
-      if ;; label = @2
-        call $fimport$10
-      end
-      local.get $0
-      i32.const 2
-      i32.and
-      if ;; label = @2
-        block ;; label = @3
-          local.get $1
-          local.get $0
-          i32.const -2
-          i32.and
-          i32.store
-          local.get $3
-          local.get $2
-          i32.const 1
-          i32.or
-          i32.store offset=4
-          local.get $3
-          local.get $2
-          i32.add
-          local.get $2
-          i32.store
-        end
-      else
-        block ;; label = @3
-          local.get $6
-          i32.const 3660
-          i32.load
-          i32.eq
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 3648
-              i32.const 3648
-              i32.load
-              local.get $2
-              i32.add
-              local.tee $0
-              i32.store
-              i32.const 3660
-              local.get $3
-              i32.store
-              local.get $3
-              local.get $0
-              i32.const 1
-              i32.or
-              i32.store offset=4
-              local.get $3
-              i32.const 3656
-              i32.load
-              i32.ne
-              if ;; label = @6
-                return
-              end
-              i32.const 3656
-              i32.const 0
-              i32.store
-              i32.const 3644
-              i32.const 0
-              i32.store
-              return
-            end
-          end
-          local.get $6
-          i32.const 3656
-          i32.load
-          i32.eq
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 3644
-              i32.const 3644
-              i32.load
-              local.get $2
-              i32.add
-              local.tee $0
-              i32.store
-              i32.const 3656
-              local.get $3
-              i32.store
-              local.get $3
-              local.get $0
-              i32.const 1
-              i32.or
-              i32.store offset=4
-              local.get $3
-              local.get $0
-              i32.add
-              local.get $0
-              i32.store
-              return
-            end
-          end
-          local.get $0
-          i32.const -8
-          i32.and
-          local.get $2
-          i32.add
-          local.set $5
-          local.get $0
-          i32.const 3
-          i32.shr_u
-          local.set $4
-          block $label$61 ;; label = @4
-            local.get $0
-            i32.const 256
-            i32.lt_u
-            if ;; label = @5
-              block ;; label = @6
-                local.get $6
-                i32.load offset=12
-                local.set $2
-                local.get $6
-                i32.load offset=8
-                local.tee $1
-                local.get $4
-                i32.const 1
-                i32.shl
-                i32.const 2
-                i32.shl
-                i32.const 3676
-                i32.add
-                local.tee $0
-                i32.ne
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $1
-                    i32.const 3652
-                    i32.load
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                    local.get $1
-                    i32.load offset=12
-                    local.get $6
-                    i32.ne
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                  end
-                end
-                local.get $2
-                local.get $1
-                i32.eq
-                if ;; label = @7
-                  block ;; label = @8
-                    i32.const 3636
-                    i32.const 3636
-                    i32.load
-                    i32.const 1
-                    local.get $4
-                    i32.shl
-                    i32.const -1
-                    i32.xor
-                    i32.and
-                    i32.store
-                    br 4 (;@4;)
-                  end
-                end
-                local.get $2
-                local.get $0
-                i32.eq
-                if ;; label = @7
-                  local.get $2
-                  i32.const 8
-                  i32.add
-                  local.set $14
-                else
-                  block ;; label = @8
-                    local.get $2
-                    i32.const 3652
-                    i32.load
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                    local.get $2
-                    i32.const 8
-                    i32.add
-                    local.tee $0
-                    i32.load
-                    local.get $6
-                    i32.eq
-                    if ;; label = @9
-                      local.get $0
-                      local.set $14
-                    else
-                      call $fimport$10
-                    end
-                  end
-                end
-                local.get $1
-                local.get $2
-                i32.store offset=12
-                local.get $14
-                local.get $1
-                i32.store
-              end
-            else
-              block ;; label = @6
-                local.get $6
-                i32.load offset=24
-                local.set $7
-                block $label$73 ;; label = @7
-                  local.get $6
-                  i32.load offset=12
-                  local.tee $0
-                  local.get $6
-                  i32.eq
-                  if ;; label = @8
-                    block ;; label = @9
-                      local.get $6
-                      i32.const 16
-                      i32.add
-                      local.tee $2
-                      i32.const 4
-                      i32.add
-                      local.tee $1
-                      i32.load
-                      local.tee $0
-                      if ;; label = @10
-                        local.get $1
-                        local.set $2
-                      else
-                        local.get $2
-                        i32.load
-                        local.tee $0
-                        i32.eqz
-                        if ;; label = @11
-                          block ;; label = @12
-                            i32.const 0
-                            local.set $9
-                            br 5 (;@7;)
-                          end
-                        end
-                      end
-                      loop $label$78 ;; label = @10
-                        local.get $0
-                        i32.const 20
-                        i32.add
-                        local.tee $1
-                        i32.load
-                        local.tee $4
-                        if ;; label = @11
-                          block ;; label = @12
-                            local.get $4
-                            local.set $0
-                            local.get $1
-                            local.set $2
-                            br 2 (;@10;)
-                          end
-                        end
-                        local.get $0
-                        i32.const 16
-                        i32.add
-                        local.tee $1
-                        i32.load
-                        local.tee $4
-                        if ;; label = @11
-                          block ;; label = @12
-                            local.get $4
-                            local.set $0
-                            local.get $1
-                            local.set $2
-                            br 2 (;@10;)
-                          end
-                        end
-                      end
-                      local.get $2
-                      i32.const 3652
-                      i32.load
-                      i32.lt_u
-                      if ;; label = @10
-                        call $fimport$10
-                      else
-                        block ;; label = @11
-                          local.get $2
-                          i32.const 0
-                          i32.store
-                          local.get $0
-                          local.set $9
-                        end
-                      end
-                    end
-                  else
-                    block ;; label = @9
-                      local.get $6
-                      i32.load offset=8
-                      local.tee $2
-                      i32.const 3652
-                      i32.load
-                      i32.lt_u
-                      if ;; label = @10
-                        call $fimport$10
-                      end
-                      local.get $2
-                      i32.const 12
-                      i32.add
-                      local.tee $1
-                      i32.load
-                      local.get $6
-                      i32.ne
-                      if ;; label = @10
-                        call $fimport$10
-                      end
-                      local.get $0
-                      i32.const 8
-                      i32.add
-                      local.tee $4
-                      i32.load
-                      local.get $6
-                      i32.eq
-                      if ;; label = @10
-                        block ;; label = @11
-                          local.get $1
-                          local.get $0
-                          i32.store
-                          local.get $4
-                          local.get $2
-                          i32.store
-                          local.get $0
-                          local.set $9
-                        end
-                      else
-                        call $fimport$10
-                      end
-                    end
-                  end
-                end
-                local.get $7
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $6
-                    local.get $6
-                    i32.load offset=28
-                    local.tee $0
-                    i32.const 2
-                    i32.shl
-                    i32.const 3940
-                    i32.add
-                    local.tee $2
-                    i32.load
-                    i32.eq
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $2
-                        local.get $9
-                        i32.store
-                        local.get $9
-                        i32.eqz
-                        if ;; label = @11
-                          block ;; label = @12
-                            i32.const 3640
-                            i32.const 3640
-                            i32.load
-                            i32.const 1
-                            local.get $0
-                            i32.shl
-                            i32.const -1
-                            i32.xor
-                            i32.and
-                            i32.store
-                            br 8 (;@4;)
-                          end
-                        end
-                      end
-                    else
-                      block ;; label = @10
-                        local.get $7
-                        i32.const 3652
-                        i32.load
-                        i32.lt_u
-                        if ;; label = @11
-                          call $fimport$10
-                        end
-                        local.get $7
-                        i32.const 16
-                        i32.add
-                        local.tee $0
-                        i32.load
-                        local.get $6
-                        i32.eq
-                        if ;; label = @11
-                          local.get $0
-                          local.get $9
-                          i32.store
-                        else
-                          local.get $7
-                          local.get $9
-                          i32.store offset=20
-                        end
-                        local.get $9
-                        i32.eqz
-                        br_if 6 (;@4;)
-                      end
-                    end
-                    local.get $9
-                    i32.const 3652
-                    i32.load
-                    local.tee $2
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                    local.get $9
-                    local.get $7
-                    i32.store offset=24
-                    local.get $6
-                    i32.const 16
-                    i32.add
-                    local.tee $1
-                    i32.load
-                    local.tee $0
-                    if ;; label = @9
-                      local.get $0
-                      local.get $2
-                      i32.lt_u
-                      if ;; label = @10
-                        call $fimport$10
-                      else
-                        block ;; label = @11
-                          local.get $9
-                          local.get $0
-                          i32.store offset=16
-                          local.get $0
-                          local.get $9
-                          i32.store offset=24
-                        end
-                      end
-                    end
-                    local.get $1
-                    i32.load offset=4
-                    local.tee $0
-                    if ;; label = @9
-                      local.get $0
-                      i32.const 3652
-                      i32.load
-                      i32.lt_u
-                      if ;; label = @10
-                        call $fimport$10
-                      else
-                        block ;; label = @11
-                          local.get $9
-                          local.get $0
-                          i32.store offset=20
-                          local.get $0
-                          local.get $9
-                          i32.store offset=24
-                        end
-                      end
-                    end
-                  end
-                end
-              end
-            end
-          end
-          local.get $3
-          local.get $5
-          i32.const 1
-          i32.or
-          i32.store offset=4
-          local.get $3
-          local.get $5
-          i32.add
-          local.get $5
-          i32.store
-          local.get $3
-          i32.const 3656
-          i32.load
-          i32.eq
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 3644
-              local.get $5
-              i32.store
-              return
-            end
-          else
-            local.get $5
-            local.set $2
-          end
-        end
-      end
-      local.get $2
-      i32.const 3
-      i32.shr_u
-      local.set $1
-      local.get $2
-      i32.const 256
-      i32.lt_u
-      if ;; label = @2
-        block ;; label = @3
-          local.get $1
-          i32.const 1
-          i32.shl
-          i32.const 2
-          i32.shl
-          i32.const 3676
-          i32.add
-          local.set $0
-          i32.const 3636
-          i32.load
-          local.tee $2
-          i32.const 1
-          local.get $1
-          i32.shl
-          local.tee $1
-          i32.and
-          if ;; label = @4
-            local.get $0
-            i32.const 8
-            i32.add
-            local.tee $2
-            i32.load
-            local.tee $1
-            i32.const 3652
-            i32.load
-            i32.lt_u
-            if ;; label = @5
-              call $fimport$10
-            else
-              block ;; label = @6
-                local.get $2
-                local.set $15
-                local.get $1
-                local.set $13
-              end
-            end
-          else
-            block ;; label = @5
-              i32.const 3636
-              local.get $2
-              local.get $1
-              i32.or
-              i32.store
-              local.get $0
-              i32.const 8
-              i32.add
-              local.set $15
-              local.get $0
-              local.set $13
-            end
-          end
-          local.get $15
-          local.get $3
-          i32.store
-          local.get $13
-          local.get $3
-          i32.store offset=12
-          local.get $3
-          local.get $13
-          i32.store offset=8
-          local.get $3
-          local.get $0
-          i32.store offset=12
-          return
-        end
-      end
-      local.get $2
-      i32.const 8
-      i32.shr_u
-      local.tee $0
-      if (result i32) ;; label = @2
-        local.get $2
-        i32.const 16777215
-        i32.gt_u
-        if (result i32) ;; label = @3
-          i32.const 31
-        else
-          local.get $2
-          i32.const 14
-          local.get $0
-          local.get $0
-          i32.const 1048320
-          i32.add
-          i32.const 16
-          i32.shr_u
-          i32.const 8
-          i32.and
-          local.tee $0
-          i32.shl
-          local.tee $1
-          i32.const 520192
-          i32.add
-          i32.const 16
-          i32.shr_u
-          i32.const 4
-          i32.and
-          local.tee $4
-          local.get $0
-          i32.or
-          local.get $1
-          local.get $4
-          i32.shl
-          local.tee $0
-          i32.const 245760
-          i32.add
-          i32.const 16
-          i32.shr_u
-          i32.const 2
-          i32.and
-          local.tee $1
-          i32.or
-          i32.sub
-          local.get $0
-          local.get $1
-          i32.shl
-          i32.const 15
-          i32.shr_u
-          i32.add
-          local.tee $0
-          i32.const 7
-          i32.add
-          i32.shr_u
-          i32.const 1
-          i32.and
-          local.get $0
-          i32.const 1
-          i32.shl
-          i32.or
-        end
-      else
-        i32.const 0
-      end
-      local.tee $1
-      i32.const 2
-      i32.shl
-      i32.const 3940
-      i32.add
-      local.set $0
-      local.get $3
-      local.get $1
-      i32.store offset=28
-      local.get $3
-      i32.const 0
-      i32.store offset=20
-      local.get $3
-      i32.const 0
-      i32.store offset=16
-      block $label$113 ;; label = @2
-        i32.const 3640
-        i32.load
-        local.tee $4
-        i32.const 1
-        local.get $1
-        i32.shl
-        local.tee $5
-        i32.and
-        if ;; label = @3
-          block ;; label = @4
-            local.get $0
-            i32.load
-            local.set $0
-            i32.const 25
-            local.get $1
-            i32.const 1
-            i32.shr_u
-            i32.sub
-            local.set $4
-            local.get $2
-            local.get $1
-            i32.const 31
-            i32.eq
-            if (result i32) ;; label = @5
-              i32.const 0
-            else
-              local.get $4
-            end
-            i32.shl
-            local.set $1
-            block $label$117 ;; label = @5
-              block $label$118 ;; label = @6
-                block $label$119 ;; label = @7
-                  loop $label$120 ;; label = @8
-                    local.get $0
-                    i32.load offset=4
-                    i32.const -8
-                    i32.and
-                    local.get $2
-                    i32.eq
-                    br_if 2 (;@6;)
-                    local.get $1
-                    i32.const 1
-                    i32.shl
-                    local.set $4
-                    local.get $0
-                    i32.const 16
-                    i32.add
-                    local.get $1
-                    i32.const 31
-                    i32.shr_u
-                    i32.const 2
-                    i32.shl
-                    i32.add
-                    local.tee $1
-                    i32.load
-                    local.tee $5
-                    i32.eqz
-                    br_if 1 (;@7;)
-                    local.get $4
-                    local.set $1
-                    local.get $5
-                    local.set $0
-                    br 0 (;@8;)
-                  end
-                end
-                local.get $1
-                i32.const 3652
-                i32.load
-                i32.lt_u
-                if ;; label = @7
-                  call $fimport$10
-                else
-                  block ;; label = @8
-                    local.get $1
-                    local.get $3
-                    i32.store
-                    local.get $3
-                    local.get $0
-                    i32.store offset=24
-                    local.get $3
-                    local.get $3
-                    i32.store offset=12
-                    local.get $3
-                    local.get $3
-                    i32.store offset=8
-                    br 6 (;@2;)
-                  end
-                end
-                br 1 (;@5;)
-              end
-              local.get $0
-              i32.const 8
-              i32.add
-              local.tee $1
-              i32.load
-              local.tee $2
-              i32.const 3652
-              i32.load
-              local.tee $4
-              i32.ge_u
-              local.get $0
-              local.get $4
-              i32.ge_u
-              i32.and
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $2
-                  local.get $3
-                  i32.store offset=12
-                  local.get $1
-                  local.get $3
-                  i32.store
-                  local.get $3
-                  local.get $2
-                  i32.store offset=8
-                  local.get $3
-                  local.get $0
-                  i32.store offset=12
-                  local.get $3
-                  i32.const 0
-                  i32.store offset=24
-                end
-              else
-                call $fimport$10
-              end
-            end
-          end
-        else
-          block ;; label = @4
-            i32.const 3640
-            local.get $4
-            local.get $5
-            i32.or
-            i32.store
-            local.get $0
-            local.get $3
-            i32.store
-            local.get $3
-            local.get $0
-            i32.store offset=24
-            local.get $3
-            local.get $3
-            i32.store offset=12
-            local.get $3
-            local.get $3
-            i32.store offset=8
-          end
-        end
-      end
-      i32.const 3668
-      i32.const 3668
-      i32.load
-      i32.const -1
-      i32.add
-      local.tee $0
-      i32.store
-      local.get $0
-      if ;; label = @2
-        return
-      else
-        i32.const 4092
-        local.set $0
-      end
-      loop $label$128 ;; label = @2
-        local.get $0
-        i32.load
-        local.tee $2
-        i32.const 8
-        i32.add
-        local.set $0
-        local.get $2
-        br_if 0 (;@2;)
-      end
-      i32.const 3668
-      i32.const -1
-      i32.store
-    end
-  )
-  (func $39 (;52;) (type $6)
-    nop
-  )
-  (func $40 (;53;) (type $1) (param $0 i32) (result i32)
-    (local $1 i32) (local $2 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$0
-      i32.load
-      local.tee $2
-      local.get $0
-      i32.const 15
-      i32.add
-      i32.const -16
-      i32.and
-      local.tee $0
-      i32.add
-      local.set $1
-      local.get $0
-      i32.const 0
-      i32.gt_s
-      local.get $1
-      local.get $2
-      i32.lt_s
-      i32.and
-      local.get $1
-      i32.const 0
-      i32.lt_s
-      i32.or
-      if ;; label = @2
-        block ;; label = @3
-          call $fimport$6
-          drop
-          i32.const 12
-          call $fimport$11
-          i32.const -1
-          return
-        end
-      end
-      global.get $global$0
-      local.get $1
-      i32.store
-      local.get $1
-      call $fimport$5
-      i32.gt_s
-      if ;; label = @2
-        call $fimport$4
-        i32.eqz
-        if ;; label = @3
-          block ;; label = @4
-            i32.const 12
-            call $fimport$11
-            global.get $global$0
-            local.get $2
-            i32.store
-            i32.const -1
-            return
-          end
-        end
-      end
-      local.get $2
-    end
-  )
-  (func $41 (;54;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32) (local $4 i32) (local $5 i32)
-    block $label$1 (result i32) ;; label = @1
-      local.get $0
-      local.get $2
-      i32.add
-      local.set $4
-      local.get $2
-      i32.const 20
-      i32.ge_s
-      if ;; label = @2
-        block ;; label = @3
-          local.get $1
-          i32.const 255
-          i32.and
-          local.set $1
-          local.get $0
-          i32.const 3
-          i32.and
-          local.tee $3
-          if ;; label = @4
-            block ;; label = @5
-              local.get $0
-              i32.const 4
-              i32.add
-              local.get $3
-              i32.sub
-              local.set $3
-              loop $label$4 ;; label = @6
-                local.get $0
-                local.get $3
-                i32.lt_s
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $0
-                    local.get $1
-                    i32.store8
-                    local.get $0
-                    i32.const 1
-                    i32.add
-                    local.set $0
-                    br 2 (;@6;)
-                  end
-                end
-              end
-            end
-          end
-          local.get $1
-          local.get $1
-          i32.const 8
-          i32.shl
-          i32.or
-          local.get $1
-          i32.const 16
-          i32.shl
-          i32.or
-          local.get $1
-          i32.const 24
-          i32.shl
-          i32.or
-          local.set $3
-          local.get $4
-          i32.const -4
-          i32.and
-          local.set $5
-          loop $label$6 ;; label = @4
-            local.get $0
-            local.get $5
-            i32.lt_s
-            if ;; label = @5
-              block ;; label = @6
-                local.get $0
-                local.get $3
-                i32.store
-                local.get $0
-                i32.const 4
-                i32.add
-                local.set $0
-                br 2 (;@4;)
-              end
-            end
-          end
-        end
-      end
-      loop $label$8 ;; label = @2
-        local.get $0
-        local.get $4
-        i32.lt_s
-        if ;; label = @3
-          block ;; label = @4
-            local.get $0
-            local.get $1
-            i32.store8
-            local.get $0
-            i32.const 1
-            i32.add
-            local.set $0
-            br 2 (;@2;)
-          end
-        end
-      end
-      local.get $0
-      local.get $2
-      i32.sub
-    end
-  )
-  (func $42 (;55;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32)
-    block $label$1 (result i32) ;; label = @1
-      local.get $2
-      i32.const 4096
-      i32.ge_s
-      if ;; label = @2
-        local.get $0
-        local.get $1
-        local.get $2
-        call $fimport$12
-        return
-      end
-      local.get $0
-      local.set $3
-      local.get $0
-      i32.const 3
-      i32.and
-      local.get $1
-      i32.const 3
-      i32.and
-      i32.eq
-      if ;; label = @2
-        block ;; label = @3
-          loop $label$4 ;; label = @4
-            local.get $0
-            i32.const 3
-            i32.and
-            if ;; label = @5
-              block ;; label = @6
-                local.get $2
-                i32.eqz
-                if ;; label = @7
-                  local.get $3
-                  return
-                end
-                local.get $0
-                local.get $1
-                i32.load8_s
-                i32.store8
-                local.get $0
-                i32.const 1
-                i32.add
-                local.set $0
-                local.get $1
-                i32.const 1
-                i32.add
-                local.set $1
-                local.get $2
-                i32.const 1
-                i32.sub
-                local.set $2
-                br 2 (;@4;)
-              end
-            end
-          end
-          loop $label$7 ;; label = @4
-            local.get $2
-            i32.const 4
-            i32.ge_s
-            if ;; label = @5
-              block ;; label = @6
-                local.get $0
-                local.get $1
-                i32.load
-                i32.store
-                local.get $0
-                i32.const 4
-                i32.add
-                local.set $0
-                local.get $1
-                i32.const 4
-                i32.add
-                local.set $1
-                local.get $2
-                i32.const 4
-                i32.sub
-                local.set $2
-                br 2 (;@4;)
-              end
-            end
-          end
-        end
-      end
-      loop $label$9 ;; label = @2
-        local.get $2
-        i32.const 0
-        i32.gt_s
-        if ;; label = @3
-          block ;; label = @4
-            local.get $0
-            local.get $1
-            i32.load8_s
-            i32.store8
-            local.get $0
-            i32.const 1
-            i32.add
-            local.set $0
-            local.get $1
-            i32.const 1
-            i32.add
-            local.set $1
-            local.get $2
-            i32.const 1
-            i32.sub
-            local.set $2
-            br 2 (;@2;)
-          end
-        end
-      end
-      local.get $3
-    end
-  )
-  (func $43 (;56;) (type $3) (result i32)
-    i32.const 0
-  )
-  (func $44 (;57;) (type $4) (param $0 i32) (param $1 i32) (result i32)
-    local.get $1
-    local.get $0
-    i32.const 1
-    i32.and
-    i32.const 0
-    i32.add
-    call_indirect (type $1)
-  )
-  (func $45 (;58;) (type $12) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32)
-    local.get $1
-    local.get $2
-    local.get $3
-    local.get $0
-    i32.const 3
-    i32.and
-    i32.const 2
-    i32.add
-    call_indirect (type $0)
-  )
-  (func $46 (;59;) (type $5) (param $0 i32) (param $1 i32)
-    local.get $1
-    local.get $0
-    i32.const 1
-    i32.and
-    i32.const 6
-    i32.add
-    call_indirect (type $2)
-  )
-  (func $47 (;60;) (type $1) (param $0 i32) (result i32)
-    block $label$1 (result i32) ;; label = @1
-      i32.const 0
-      call $fimport$3
-      i32.const 0
-    end
-  )
-  (func $48 (;61;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    block $label$1 (result i32) ;; label = @1
-      i32.const 1
-      call $fimport$3
-      i32.const 0
-    end
-  )
-  (func $49 (;62;) (type $2) (param $0 i32)
-    i32.const 2
-    call $fimport$3
-  )
-  (global $global$0 (;5;) (mut i32) global.get $gimport$0)
-  (global $global$1 (;6;) (mut i32) global.get $gimport$1)
-  (global $global$2 (;7;) (mut i32) global.get $gimport$2)
-  (global $global$3 (;8;) (mut i32) i32.const 0)
-  (global $global$4 (;9;) (mut i32) i32.const 0)
-  (global $global$5 (;10;) (mut i32) i32.const 0)
-  (export "_sbrk" (func $40))
-  (export "_free" (func $38))
-  (export "_main" (func $8))
-  (export "_pthread_self" (func $43))
-  (export "_memset" (func $41))
-  (export "_malloc" (func $37))
-  (export "_memcpy" (func $42))
-  (export "___errno_location" (func $12))
-  (export "runPostSets" (func $39))
-  (export "stackAlloc" (func $0))
-  (export "stackSave" (func $1))
-  (export "stackRestore" (func $2))
-  (export "establishStackSpace" (func $3))
-  (export "setThrew" (func $4))
-  (export "setTempRet0" (func $5))
-  (export "getTempRet0" (func $6))
-  (export "dynCall_ii" (func $44))
-  (export "dynCall_iiii" (func $45))
-  (export "dynCall_vi" (func $46))
-  (elem (;0;) (global.get $gimport$19) func $47 $9 $48 $14 $10 $15 $49 $16)
-  (data (;0;) (i32.const 1024) "\04\04\00\00\05")
-  (data (;1;) (i32.const 1040) "\01")
-  (data (;2;) (i32.const 1064) "\01\00\00\00\02\00\00\00,\10\00\00\00\04")
-  (data (;3;) (i32.const 1088) "\01")
-  (data (;4;) (i32.const 1103) "\0a\ff\ff\ff\ff")
-  (data (;5;) (i32.const 1140) "error: %d\5cn\00ok\00\11\00\0a\00\11\11\11\00\00\00\00\05\00\00\00\00\00\00\09\00\00\00\00\0b")
-  (data (;6;) (i32.const 1187) "\11\00\0f\0a\11\11\11\03\0a\07\00\01\13\09\0b\0b\00\00\09\06\0b\00\00\0b\00\06\11\00\00\00\11\11\11")
-  (data (;7;) (i32.const 1236) "\0b")
-  (data (;8;) (i32.const 1245) "\11\00\0a\0a\11\11\11\00\0a\00\00\02\00\09\0b\00\00\00\09\00\0b\00\00\0b")
-  (data (;9;) (i32.const 1294) "\0c")
-  (data (;10;) (i32.const 1306) "\0c\00\00\00\00\0c\00\00\00\00\09\0c\00\00\00\00\00\0c\00\00\0c")
-  (data (;11;) (i32.const 1352) "\0e")
-  (data (;12;) (i32.const 1364) "\0d\00\00\00\04\0d\00\00\00\00\09\0e\00\00\00\00\00\0e\00\00\0e")
-  (data (;13;) (i32.const 1410) "\10")
-  (data (;14;) (i32.const 1422) "\0f\00\00\00\00\0f\00\00\00\00\09\10\00\00\00\00\00\10\00\00\10\00\00\12\00\00\00\12\12\12")
-  (data (;15;) (i32.const 1477) "\12\00\00\00\12\12\12\00\00\00\00\00\00\09")
-  (data (;16;) (i32.const 1526) "\0b")
-  (data (;17;) (i32.const 1538) "\0a\00\00\00\00\0a\00\00\00\00\09\0b\00\00\00\00\00\0b\00\00\0b")
-  (data (;18;) (i32.const 1584) "\0c")
-  (data (;19;) (i32.const 1596) "\0c\00\00\00\00\0c\00\00\00\00\09\0c\00\00\00\00\00\0c\00\00\0c\00\000123456789ABCDEF-+   0X0x\00(null)\00-0X+0X 0X-0x+0x 0x\00inf\00INF\00nan\00NAN\00.\00T!\22\19\0d\01\02\03\11K\1c\0c\10\04\0b\1d\12\1e'hnopqb \05\06\0f\13\14\15\1a\08\16\07($\17\18\09\0a\0e\1b\1f%#\83\82}&*+<=>?CGJMXYZ[\5c]^_`acdefgijklrstyz{|\00Illegal byte sequence\00Domain error\00Result not representable\00Not a tty\00Permission denied\00Operation not permitted\00No such file or directory\00No such process\00File exists\00Value too large for data type\00No space left on device\00Out of memory\00Resource busy\00Interrupted system call\00Resource temporarily unavailable\00Invalid seek\00Cross-device link\00Read-only file system\00Directory not empty\00Connection reset by peer\00Operation timed out\00Connection refused\00Host is down\00Host is unreachable\00Address in use\00Broken pipe\00I/O error\00No such device or address\00Block device required\00No such device\00Not a directory\00Is a directory\00Text file busy\00Exec format error\00Invalid argument\00Argument list too long\00Symbolic link loop\00Filename too long\00Too many open files in system\00No file descriptors available\00Bad file descriptor\00No child process\00Bad address\00File too large\00Too many links\00No locks available\00Resource deadlock would occur\00State not recoverable\00Previous owner died\00Operation canceled\00Function not implemented\00No message of desired type\00Identifier removed\00Device not a stream\00No data available\00Device timeout\00Out of streams resources\00Link has been severed\00Protocol error\00Bad message\00File descriptor in bad state\00Not a socket\00Destination address required\00Message too large\00Protocol wrong type for socket\00Protocol not available\00Protocol not supported\00Socket type not supported\00Not supported\00Protocol family not supported\00Address family not supported by protocol\00Address not available\00Network is down\00Network unreachable\00Connection reset by network\00Connection aborted\00No buffer space available\00Socket is connected\00Socket not connected\00Cannot send after socket shutdown\00Operation already in progress\00Operation in progress\00Stale file handle\00Remote I/O error\00Quota exceeded\00No medium found\00Wrong medium type\00No error information")
-)
\ No newline at end of file
diff --git a/cranelift/wasm/wasmtests/embenchen_primes.wat b/cranelift/wasm/wasmtests/embenchen_primes.wat
deleted file mode 100644
index 1bdf443ae581..000000000000
--- a/cranelift/wasm/wasmtests/embenchen_primes.wat
+++ /dev/null
@@ -1,11185 +0,0 @@
-(module
-  (type $0 (;0;) (func (param i32 i32 i32) (result i32)))
-  (type $1 (;1;) (func (param i32) (result i32)))
-  (type $2 (;2;) (func (param i32)))
-  (type $3 (;3;) (func (result i32)))
-  (type $4 (;4;) (func (param i32 i32) (result i32)))
-  (type $5 (;5;) (func (param i32 i32)))
-  (type $6 (;6;) (func))
-  (type $7 (;7;) (func (param i32 i32 i32 i32 i32) (result i32)))
-  (type $8 (;8;) (func (param i32 i32 i32)))
-  (type $9 (;9;) (func (param i64 i32) (result i32)))
-  (type $10 (;10;) (func (param i32 i32 i32 i32 i32)))
-  (type $11 (;11;) (func (param f64 i32) (result f64)))
-  (type $12 (;12;) (func (param i32 i32 i32 i32) (result i32)))
-  (import "env" "memory" (memory $16 (;0;) 2048 2048))
-  (import "env" "table" (table $timport$17 (;0;) 8 8 funcref))
-  (import "env" "DYNAMICTOP_PTR" (global $gimport$0 (;0;) i32))
-  (import "env" "STACKTOP" (global $gimport$1 (;1;) i32))
-  (import "env" "STACK_MAX" (global $gimport$2 (;2;) i32))
-  (import "env" "memoryBase" (global $gimport$18 (;3;) i32))
-  (import "env" "tableBase" (global $gimport$19 (;4;) i32))
-  (import "env" "abort" (func $fimport$3 (;0;) (type $2)))
-  (import "env" "enlargeMemory" (func $fimport$4 (;1;) (type $3)))
-  (import "env" "getTotalMemory" (func $fimport$5 (;2;) (type $3)))
-  (import "env" "abortOnCannotGrowMemory" (func $fimport$6 (;3;) (type $3)))
-  (import "env" "_pthread_cleanup_pop" (func $fimport$7 (;4;) (type $2)))
-  (import "env" "___syscall6" (func $fimport$8 (;5;) (type $4)))
-  (import "env" "_pthread_cleanup_push" (func $fimport$9 (;6;) (type $5)))
-  (import "env" "_abort" (func $fimport$10 (;7;) (type $6)))
-  (import "env" "___setErrNo" (func $fimport$11 (;8;) (type $2)))
-  (import "env" "_emscripten_memcpy_big" (func $fimport$12 (;9;) (type $0)))
-  (import "env" "___syscall54" (func $fimport$13 (;10;) (type $4)))
-  (import "env" "___syscall140" (func $fimport$14 (;11;) (type $4)))
-  (import "env" "___syscall146" (func $fimport$15 (;12;) (type $4)))
-  (func $0 (;13;) (type $1) (param $0 i32) (result i32)
-    (local $1 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $1
-      global.get $global$1
-      local.get $0
-      i32.add
-      global.set $global$1
-      global.get $global$1
-      i32.const 15
-      i32.add
-      i32.const -16
-      i32.and
-      global.set $global$1
-      local.get $1
-    end
-  )
-  (func $1 (;14;) (type $3) (result i32)
-    global.get $global$1
-  )
-  (func $2 (;15;) (type $2) (param $0 i32)
-    local.get $0
-    global.set $global$1
-  )
-  (func $3 (;16;) (type $5) (param $0 i32) (param $1 i32)
-    block $label$1 ;; label = @1
-      local.get $0
-      global.set $global$1
-      local.get $1
-      global.set $global$2
-    end
-  )
-  (func $4 (;17;) (type $5) (param $0 i32) (param $1 i32)
-    global.get $global$3
-    i32.eqz
-    if ;; label = @1
-      block ;; label = @2
-        local.get $0
-        global.set $global$3
-        local.get $1
-        global.set $global$4
-      end
-    end
-  )
-  (func $5 (;18;) (type $2) (param $0 i32)
-    local.get $0
-    global.set $global$5
-  )
-  (func $6 (;19;) (type $3) (result i32)
-    global.get $global$5
-  )
-  (func $7 (;20;) (type $4) (param $0 i32) (param $1 i32) (result i32)
-    (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 f32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $3
-      global.get $global$1
-      i32.const 16
-      i32.add
-      global.set $global$1
-      local.get $3
-      i32.const 8
-      i32.add
-      local.set $5
-      local.get $3
-      local.set $2
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          local.get $0
-          i32.const 1
-          i32.le_s
-          br_if 0 (;@3;)
-          block $label$4 ;; label = @4
-            block $label$5 ;; label = @5
-              block $label$6 ;; label = @6
-                block $label$7 ;; label = @7
-                  block $label$8 ;; label = @8
-                    block $label$9 ;; label = @9
-                      block $label$10 ;; label = @10
-                        local.get $1
-                        i32.load offset=4
-                        i32.load8_s
-                        local.tee $0
-                        i32.const 48
-                        i32.sub
-                        br_table 5 (;@5;) 0 (;@10;) 2 (;@8;) 1 (;@9;) 3 (;@7;) 4 (;@6;) 6 (;@4;)
-                      end
-                      i32.const 33000
-                      local.set $4
-                      br 7 (;@2;)
-                    end
-                    br 5 (;@3;)
-                  end
-                  i32.const 130000
-                  local.set $4
-                  br 5 (;@2;)
-                end
-                i32.const 610000
-                local.set $4
-                br 4 (;@2;)
-              end
-              i32.const 1010000
-              local.set $4
-              br 3 (;@2;)
-            end
-            local.get $3
-            global.set $global$1
-            i32.const 0
-            return
-          end
-          local.get $2
-          local.get $0
-          i32.const -48
-          i32.add
-          i32.store
-          i32.const 1140
-          local.get $2
-          call $30
-          drop
-          local.get $3
-          global.set $global$1
-          i32.const -1
-          return
-        end
-        i32.const 220000
-        local.set $4
-      end
-      i32.const 2
-      local.set $1
-      i32.const 0
-      local.set $0
-      loop $label$11 ;; label = @2
-        block $label$12 ;; label = @3
-          block $label$13 ;; label = @4
-            local.get $1
-            f32.convert_i32_s
-            f32.sqrt
-            local.tee $6
-            f32.const 0x1p+1 (;=2;)
-            f32.gt
-            i32.eqz
-            br_if 0 (;@4;)
-            i32.const 2
-            local.set $2
-            loop $label$14 ;; label = @5
-              local.get $1
-              local.get $2
-              i32.rem_s
-              i32.eqz
-              br_if 2 (;@3;)
-              local.get $2
-              i32.const 1
-              i32.add
-              local.tee $2
-              f32.convert_i32_s
-              local.get $6
-              f32.lt
-              br_if 0 (;@5;)
-              br 1 (;@4;)
-            end
-          end
-          local.get $0
-          i32.const 1
-          i32.add
-          local.set $0
-        end
-        local.get $1
-        i32.const 1
-        i32.add
-        local.set $2
-        local.get $0
-        local.get $4
-        i32.lt_s
-        if ;; label = @3
-          block ;; label = @4
-            local.get $2
-            local.set $1
-            br 2 (;@2;)
-          end
-        end
-      end
-      local.get $5
-      local.get $1
-      i32.store
-      i32.const 1152
-      local.get $5
-      call $30
-      drop
-      local.get $3
-      global.set $global$1
-      i32.const 0
-    end
-  )
-  (func $8 (;21;) (type $1) (param $0 i32) (result i32)
-    (local $1 i32) (local $2 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $1
-      global.get $global$1
-      i32.const 16
-      i32.add
-      global.set $global$1
-      local.get $1
-      local.tee $2
-      local.get $0
-      i32.load offset=60
-      i32.store
-      i32.const 6
-      local.get $2
-      call $fimport$8
-      call $10
-      local.set $0
-      local.get $1
-      global.set $global$1
-      local.get $0
-    end
-  )
-  (func $9 (;22;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32) (local $4 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $4
-      global.get $global$1
-      i32.const 32
-      i32.add
-      global.set $global$1
-      local.get $4
-      local.tee $3
-      local.get $0
-      i32.load offset=60
-      i32.store
-      local.get $3
-      i32.const 0
-      i32.store offset=4
-      local.get $3
-      local.get $1
-      i32.store offset=8
-      local.get $3
-      local.get $4
-      i32.const 20
-      i32.add
-      local.tee $0
-      i32.store offset=12
-      local.get $3
-      local.get $2
-      i32.store offset=16
-      i32.const 140
-      local.get $3
-      call $fimport$14
-      call $10
-      i32.const 0
-      i32.lt_s
-      if (result i32) ;; label = @2
-        block (result i32) ;; label = @3
-          local.get $0
-          i32.const -1
-          i32.store
-          i32.const -1
-        end
-      else
-        local.get $0
-        i32.load
-      end
-      local.set $0
-      local.get $4
-      global.set $global$1
-      local.get $0
-    end
-  )
-  (func $10 (;23;) (type $1) (param $0 i32) (result i32)
-    local.get $0
-    i32.const -4096
-    i32.gt_u
-    if (result i32) ;; label = @1
-      block (result i32) ;; label = @2
-        call $11
-        i32.const 0
-        local.get $0
-        i32.sub
-        i32.store
-        i32.const -1
-      end
-    else
-      local.get $0
-    end
-  )
-  (func $11 (;24;) (type $3) (result i32)
-    i32.const 3640
-  )
-  (func $12 (;25;) (type $2) (param $0 i32)
-    nop
-  )
-  (func $13 (;26;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32) (local $4 i32) (local $5 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $4
-      global.get $global$1
-      i32.const 80
-      i32.add
-      global.set $global$1
-      local.get $4
-      local.set $3
-      local.get $4
-      i32.const 12
-      i32.add
-      local.set $5
-      local.get $0
-      i32.const 3
-      i32.store offset=36
-      local.get $0
-      i32.load
-      i32.const 64
-      i32.and
-      i32.eqz
-      if ;; label = @2
-        block ;; label = @3
-          local.get $3
-          local.get $0
-          i32.load offset=60
-          i32.store
-          local.get $3
-          i32.const 21505
-          i32.store offset=4
-          local.get $3
-          local.get $5
-          i32.store offset=8
-          i32.const 54
-          local.get $3
-          call $fimport$13
-          if ;; label = @4
-            local.get $0
-            i32.const -1
-            i32.store8 offset=75
-          end
-        end
-      end
-      local.get $0
-      local.get $1
-      local.get $2
-      call $14
-      local.set $0
-      local.get $4
-      global.set $global$1
-      local.get $0
-    end
-  )
-  (func $14 (;27;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $8
-      global.get $global$1
-      i32.const 48
-      i32.add
-      global.set $global$1
-      local.get $8
-      i32.const 16
-      i32.add
-      local.set $9
-      local.get $8
-      local.set $10
-      local.get $8
-      i32.const 32
-      i32.add
-      local.tee $3
-      local.get $0
-      i32.const 28
-      i32.add
-      local.tee $6
-      i32.load
-      local.tee $4
-      i32.store
-      local.get $3
-      local.get $0
-      i32.const 20
-      i32.add
-      local.tee $11
-      i32.load
-      local.get $4
-      i32.sub
-      local.tee $5
-      i32.store offset=4
-      local.get $3
-      local.get $1
-      i32.store offset=8
-      local.get $3
-      local.get $2
-      i32.store offset=12
-      local.get $0
-      i32.const 60
-      i32.add
-      local.set $13
-      local.get $0
-      i32.const 44
-      i32.add
-      local.set $14
-      local.get $3
-      local.set $1
-      i32.const 2
-      local.set $4
-      local.get $5
-      local.get $2
-      i32.add
-      local.set $12
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          block $label$4 ;; label = @4
-            loop $label$5 ;; label = @5
-              i32.const 3596
-              i32.load
-              if ;; label = @6
-                block ;; label = @7
-                  i32.const 1
-                  local.get $0
-                  call $fimport$9
-                  local.get $10
-                  local.get $13
-                  i32.load
-                  i32.store
-                  local.get $10
-                  local.get $1
-                  i32.store offset=4
-                  local.get $10
-                  local.get $4
-                  i32.store offset=8
-                  i32.const 146
-                  local.get $10
-                  call $fimport$15
-                  call $10
-                  local.set $3
-                  i32.const 0
-                  call $fimport$7
-                end
-              else
-                block ;; label = @7
-                  local.get $9
-                  local.get $13
-                  i32.load
-                  i32.store
-                  local.get $9
-                  local.get $1
-                  i32.store offset=4
-                  local.get $9
-                  local.get $4
-                  i32.store offset=8
-                  i32.const 146
-                  local.get $9
-                  call $fimport$15
-                  call $10
-                  local.set $3
-                end
-              end
-              local.get $12
-              local.get $3
-              i32.eq
-              br_if 1 (;@4;)
-              local.get $3
-              i32.const 0
-              i32.lt_s
-              br_if 2 (;@3;)
-              local.get $3
-              local.get $1
-              i32.load offset=4
-              local.tee $5
-              i32.gt_u
-              if (result i32) ;; label = @6
-                block (result i32) ;; label = @7
-                  local.get $6
-                  local.get $14
-                  i32.load
-                  local.tee $7
-                  i32.store
-                  local.get $11
-                  local.get $7
-                  i32.store
-                  local.get $1
-                  i32.load offset=12
-                  local.set $7
-                  local.get $1
-                  i32.const 8
-                  i32.add
-                  local.set $1
-                  local.get $4
-                  i32.const -1
-                  i32.add
-                  local.set $4
-                  local.get $3
-                  local.get $5
-                  i32.sub
-                end
-              else
-                local.get $4
-                i32.const 2
-                i32.eq
-                if (result i32) ;; label = @7
-                  block (result i32) ;; label = @8
-                    local.get $6
-                    local.get $6
-                    i32.load
-                    local.get $3
-                    i32.add
-                    i32.store
-                    local.get $5
-                    local.set $7
-                    i32.const 2
-                    local.set $4
-                    local.get $3
-                  end
-                else
-                  block (result i32) ;; label = @8
-                    local.get $5
-                    local.set $7
-                    local.get $3
-                  end
-                end
-              end
-              local.set $5
-              local.get $1
-              local.get $1
-              i32.load
-              local.get $5
-              i32.add
-              i32.store
-              local.get $1
-              local.get $7
-              local.get $5
-              i32.sub
-              i32.store offset=4
-              local.get $12
-              local.get $3
-              i32.sub
-              local.set $12
-              br 0 (;@5;)
-            end
-          end
-          local.get $0
-          local.get $14
-          i32.load
-          local.tee $1
-          local.get $0
-          i32.load offset=48
-          i32.add
-          i32.store offset=16
-          local.get $6
-          local.get $1
-          i32.store
-          local.get $11
-          local.get $1
-          i32.store
-          br 1 (;@2;)
-        end
-        local.get $0
-        i32.const 0
-        i32.store offset=16
-        local.get $6
-        i32.const 0
-        i32.store
-        local.get $11
-        i32.const 0
-        i32.store
-        local.get $0
-        local.get $0
-        i32.load
-        i32.const 32
-        i32.or
-        i32.store
-        local.get $4
-        i32.const 2
-        i32.eq
-        if (result i32) ;; label = @3
-          i32.const 0
-        else
-          local.get $2
-          local.get $1
-          i32.load offset=4
-          i32.sub
-        end
-        local.set $2
-      end
-      local.get $8
-      global.set $global$1
-      local.get $2
-    end
-  )
-  (func $15 (;28;) (type $2) (param $0 i32)
-    local.get $0
-    i32.load offset=68
-    i32.eqz
-    if ;; label = @1
-      local.get $0
-      call $12
-    end
-  )
-  (func $16 (;29;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32) (local $4 i32) (local $5 i32)
-    block $label$1 (result i32) ;; label = @1
-      local.get $1
-      i32.const 255
-      i32.and
-      local.set $5
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          block $label$4 ;; label = @4
-            local.get $2
-            i32.const 0
-            i32.ne
-            local.tee $4
-            local.get $0
-            i32.const 3
-            i32.and
-            i32.const 0
-            i32.ne
-            i32.and
-            if ;; label = @5
-              block ;; label = @6
-                local.get $1
-                i32.const 255
-                i32.and
-                local.set $4
-                local.get $2
-                local.set $3
-                local.get $0
-                local.set $2
-                loop $label$6 ;; label = @7
-                  local.get $2
-                  i32.load8_s
-                  local.get $4
-                  i32.const 24
-                  i32.shl
-                  i32.const 24
-                  i32.shr_s
-                  i32.eq
-                  if ;; label = @8
-                    block ;; label = @9
-                      local.get $3
-                      local.set $0
-                      br 6 (;@3;)
-                    end
-                  end
-                  local.get $3
-                  i32.const -1
-                  i32.add
-                  local.tee $3
-                  i32.const 0
-                  i32.ne
-                  local.tee $0
-                  local.get $2
-                  i32.const 1
-                  i32.add
-                  local.tee $2
-                  i32.const 3
-                  i32.and
-                  i32.const 0
-                  i32.ne
-                  i32.and
-                  br_if 0 (;@7;)
-                  br 3 (;@4;)
-                end
-              end
-            else
-              block ;; label = @6
-                local.get $2
-                local.set $3
-                local.get $0
-                local.set $2
-                local.get $4
-                local.set $0
-              end
-            end
-          end
-          local.get $0
-          if ;; label = @4
-            block ;; label = @5
-              local.get $3
-              local.set $0
-              br 2 (;@3;)
-            end
-          else
-            i32.const 0
-            local.set $0
-          end
-          br 1 (;@2;)
-        end
-        local.get $2
-        i32.load8_s
-        local.get $1
-        i32.const 255
-        i32.and
-        local.tee $1
-        i32.const 24
-        i32.shl
-        i32.const 24
-        i32.shr_s
-        i32.ne
-        if ;; label = @3
-          block ;; label = @4
-            local.get $5
-            i32.const 16843009
-            i32.mul
-            local.set $3
-            block $label$12 ;; label = @5
-              block $label$13 ;; label = @6
-                local.get $0
-                i32.const 3
-                i32.le_u
-                br_if 0 (;@6;)
-                loop $label$14 ;; label = @7
-                  local.get $2
-                  i32.load
-                  local.get $3
-                  i32.xor
-                  local.tee $4
-                  i32.const -2139062144
-                  i32.and
-                  i32.const -2139062144
-                  i32.xor
-                  local.get $4
-                  i32.const -16843009
-                  i32.add
-                  i32.and
-                  i32.eqz
-                  if ;; label = @8
-                    block ;; label = @9
-                      local.get $2
-                      i32.const 4
-                      i32.add
-                      local.set $2
-                      local.get $0
-                      i32.const -4
-                      i32.add
-                      local.tee $0
-                      i32.const 3
-                      i32.gt_u
-                      br_if 2 (;@7;)
-                      br 3 (;@6;)
-                    end
-                  end
-                end
-                br 1 (;@5;)
-              end
-              local.get $0
-              i32.eqz
-              if ;; label = @6
-                block ;; label = @7
-                  i32.const 0
-                  local.set $0
-                  br 5 (;@2;)
-                end
-              end
-            end
-            loop $label$17 ;; label = @5
-              local.get $2
-              i32.load8_s
-              local.get $1
-              i32.const 24
-              i32.shl
-              i32.const 24
-              i32.shr_s
-              i32.eq
-              br_if 3 (;@2;)
-              local.get $2
-              i32.const 1
-              i32.add
-              local.set $2
-              local.get $0
-              i32.const -1
-              i32.add
-              local.tee $0
-              br_if 0 (;@5;)
-              i32.const 0
-              local.set $0
-            end
-          end
-        end
-      end
-      local.get $0
-      if (result i32) ;; label = @2
-        local.get $2
-      else
-        i32.const 0
-      end
-    end
-  )
-  (func $17 (;30;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $4
-      global.get $global$1
-      i32.const 224
-      i32.add
-      global.set $global$1
-      local.get $4
-      i32.const 136
-      i32.add
-      local.set $5
-      local.get $4
-      i32.const 80
-      i32.add
-      local.tee $3
-      i64.const 0
-      i64.store align=4
-      local.get $3
-      i64.const 0
-      i64.store offset=8 align=4
-      local.get $3
-      i64.const 0
-      i64.store offset=16 align=4
-      local.get $3
-      i64.const 0
-      i64.store offset=24 align=4
-      local.get $3
-      i64.const 0
-      i64.store offset=32 align=4
-      local.get $4
-      i32.const 120
-      i32.add
-      local.tee $6
-      local.get $2
-      i32.load
-      i32.store
-      i32.const 0
-      local.get $1
-      local.get $6
-      local.get $4
-      local.tee $2
-      local.get $3
-      call $18
-      i32.const 0
-      i32.lt_s
-      if ;; label = @2
-        i32.const -1
-        local.set $1
-      else
-        block ;; label = @3
-          local.get $0
-          i32.load offset=76
-          i32.const -1
-          i32.gt_s
-          if (result i32) ;; label = @4
-            local.get $0
-            call $19
-          else
-            i32.const 0
-          end
-          local.set $12
-          local.get $0
-          i32.load
-          local.set $7
-          local.get $0
-          i32.load8_s offset=74
-          i32.const 1
-          i32.lt_s
-          if ;; label = @4
-            local.get $0
-            local.get $7
-            i32.const -33
-            i32.and
-            i32.store
-          end
-          local.get $0
-          i32.const 48
-          i32.add
-          local.tee $8
-          i32.load
-          if ;; label = @4
-            local.get $0
-            local.get $1
-            local.get $6
-            local.get $2
-            local.get $3
-            call $18
-            local.set $1
-          else
-            block ;; label = @5
-              local.get $0
-              i32.const 44
-              i32.add
-              local.tee $9
-              i32.load
-              local.set $10
-              local.get $9
-              local.get $5
-              i32.store
-              local.get $0
-              i32.const 28
-              i32.add
-              local.tee $13
-              local.get $5
-              i32.store
-              local.get $0
-              i32.const 20
-              i32.add
-              local.tee $11
-              local.get $5
-              i32.store
-              local.get $8
-              i32.const 80
-              i32.store
-              local.get $0
-              i32.const 16
-              i32.add
-              local.tee $14
-              local.get $5
-              i32.const 80
-              i32.add
-              i32.store
-              local.get $0
-              local.get $1
-              local.get $6
-              local.get $2
-              local.get $3
-              call $18
-              local.set $1
-              local.get $10
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $0
-                  i32.const 0
-                  i32.const 0
-                  local.get $0
-                  i32.load offset=36
-                  i32.const 3
-                  i32.and
-                  i32.const 2
-                  i32.add
-                  call_indirect (type $0)
-                  drop
-                  local.get $11
-                  i32.load
-                  i32.eqz
-                  if ;; label = @8
-                    i32.const -1
-                    local.set $1
-                  end
-                  local.get $9
-                  local.get $10
-                  i32.store
-                  local.get $8
-                  i32.const 0
-                  i32.store
-                  local.get $14
-                  i32.const 0
-                  i32.store
-                  local.get $13
-                  i32.const 0
-                  i32.store
-                  local.get $11
-                  i32.const 0
-                  i32.store
-                end
-              end
-            end
-          end
-          local.get $0
-          local.get $0
-          i32.load
-          local.tee $2
-          local.get $7
-          i32.const 32
-          i32.and
-          i32.or
-          i32.store
-          local.get $12
-          if ;; label = @4
-            local.get $0
-            call $12
-          end
-          local.get $2
-          i32.const 32
-          i32.and
-          if ;; label = @4
-            i32.const -1
-            local.set $1
-          end
-        end
-      end
-      local.get $4
-      global.set $global$1
-      local.get $1
-    end
-  )
-  (func $18 (;31;) (type $7) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32) (result i32)
-    (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32) (local $15 i32) (local $16 i32) (local $17 i32) (local $18 i32) (local $19 i32) (local $20 i32) (local $21 i32) (local $22 i32) (local $23 i32) (local $24 i32) (local $25 i32) (local $26 i32) (local $27 i32) (local $28 i32) (local $29 i32) (local $30 i32) (local $31 i32) (local $32 i32) (local $33 i32) (local $34 i32) (local $35 i32) (local $36 i32) (local $37 i32) (local $38 i32) (local $39 i32) (local $40 i32) (local $41 i32) (local $42 i32) (local $43 i32) (local $44 i32) (local $45 i32) (local $46 i32) (local $47 i32) (local $48 i32) (local $49 i32) (local $50 i64) (local $51 i64) (local $52 f64) (local $53 f64)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $23
-      global.get $global$1
-      i32.const 624
-      i32.add
-      global.set $global$1
-      local.get $23
-      i32.const 16
-      i32.add
-      local.set $20
-      local.get $23
-      local.set $16
-      local.get $23
-      i32.const 528
-      i32.add
-      local.set $36
-      local.get $0
-      i32.const 0
-      i32.ne
-      local.set $30
-      local.get $23
-      i32.const 536
-      i32.add
-      local.tee $17
-      i32.const 40
-      i32.add
-      local.tee $21
-      local.set $38
-      local.get $17
-      i32.const 39
-      i32.add
-      local.set $39
-      local.get $23
-      i32.const 8
-      i32.add
-      local.tee $37
-      i32.const 4
-      i32.add
-      local.set $42
-      i32.const 0
-      local.get $23
-      i32.const 588
-      i32.add
-      local.tee $19
-      local.tee $27
-      i32.sub
-      local.set $43
-      local.get $23
-      i32.const 576
-      i32.add
-      local.tee $17
-      i32.const 12
-      i32.add
-      local.set $33
-      local.get $17
-      i32.const 11
-      i32.add
-      local.set $40
-      local.get $33
-      local.tee $28
-      local.get $27
-      i32.sub
-      local.set $44
-      i32.const -2
-      local.get $27
-      i32.sub
-      local.set $45
-      local.get $28
-      i32.const 2
-      i32.add
-      local.set $46
-      local.get $23
-      i32.const 24
-      i32.add
-      local.tee $47
-      i32.const 288
-      i32.add
-      local.set $48
-      local.get $19
-      i32.const 9
-      i32.add
-      local.tee $31
-      local.set $41
-      local.get $19
-      i32.const 8
-      i32.add
-      local.set $34
-      i32.const 0
-      local.set $15
-      i32.const 0
-      local.set $10
-      i32.const 0
-      local.set $17
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          loop $label$4 ;; label = @4
-            block $label$5 ;; label = @5
-              local.get $15
-              i32.const -1
-              i32.gt_s
-              if ;; label = @6
-                local.get $10
-                i32.const 2147483647
-                local.get $15
-                i32.sub
-                i32.gt_s
-                if (result i32) ;; label = @7
-                  block (result i32) ;; label = @8
-                    call $11
-                    i32.const 75
-                    i32.store
-                    i32.const -1
-                  end
-                else
-                  local.get $10
-                  local.get $15
-                  i32.add
-                end
-                local.set $15
-              end
-              local.get $1
-              i32.load8_s
-              local.tee $5
-              i32.const 24
-              i32.shl
-              i32.const 24
-              i32.shr_s
-              i32.eqz
-              br_if 2 (;@3;)
-              local.get $1
-              local.set $11
-              block $label$9 ;; label = @6
-                block $label$10 ;; label = @7
-                  loop $label$11 ;; label = @8
-                    block $label$12 ;; label = @9
-                      block $label$13 ;; label = @10
-                        block $label$14 ;; label = @11
-                          block $label$15 ;; label = @12
-                            local.get $5
-                            i32.const 24
-                            i32.shl
-                            i32.const 24
-                            i32.shr_s
-                            i32.const 0
-                            i32.sub
-                            br_table 1 (;@11;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 0 (;@12;) 2 (;@10;)
-                          end
-                          local.get $11
-                          local.set $5
-                          br 4 (;@7;)
-                        end
-                        local.get $11
-                        local.set $5
-                        br 1 (;@9;)
-                      end
-                      local.get $11
-                      i32.const 1
-                      i32.add
-                      local.tee $11
-                      i32.load8_s
-                      local.set $5
-                      br 1 (;@8;)
-                    end
-                  end
-                  br 1 (;@6;)
-                end
-                loop $label$16 ;; label = @7
-                  local.get $5
-                  i32.load8_s offset=1
-                  i32.const 37
-                  i32.ne
-                  br_if 1 (;@6;)
-                  local.get $11
-                  i32.const 1
-                  i32.add
-                  local.set $11
-                  local.get $5
-                  i32.const 2
-                  i32.add
-                  local.tee $5
-                  i32.load8_s
-                  i32.const 37
-                  i32.eq
-                  br_if 0 (;@7;)
-                end
-              end
-              local.get $11
-              local.get $1
-              i32.sub
-              local.set $10
-              local.get $30
-              if ;; label = @6
-                local.get $0
-                i32.load
-                i32.const 32
-                i32.and
-                i32.eqz
-                if ;; label = @7
-                  local.get $1
-                  local.get $10
-                  local.get $0
-                  call $20
-                  drop
-                end
-              end
-              local.get $10
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $5
-                  local.set $1
-                  br 3 (;@4;)
-                end
-              end
-              local.get $5
-              i32.const 1
-              i32.add
-              local.tee $11
-              i32.load8_s
-              local.tee $10
-              i32.const 24
-              i32.shl
-              i32.const 24
-              i32.shr_s
-              i32.const -48
-              i32.add
-              local.tee $9
-              i32.const 10
-              i32.lt_u
-              if (result i32) ;; label = @6
-                block (result i32) ;; label = @7
-                  local.get $5
-                  i32.const 3
-                  i32.add
-                  local.set $10
-                  local.get $5
-                  i32.load8_s offset=2
-                  i32.const 36
-                  i32.eq
-                  local.tee $12
-                  if ;; label = @8
-                    local.get $10
-                    local.set $11
-                  end
-                  local.get $12
-                  if ;; label = @8
-                    i32.const 1
-                    local.set $17
-                  end
-                  local.get $11
-                  i32.load8_s
-                  local.set $5
-                  local.get $12
-                  i32.eqz
-                  if ;; label = @8
-                    i32.const -1
-                    local.set $9
-                  end
-                  local.get $17
-                end
-              else
-                block (result i32) ;; label = @7
-                  local.get $10
-                  local.set $5
-                  i32.const -1
-                  local.set $9
-                  local.get $17
-                end
-              end
-              local.set $10
-              block $label$25 ;; label = @6
-                local.get $5
-                i32.const 24
-                i32.shl
-                i32.const 24
-                i32.shr_s
-                i32.const -32
-                i32.add
-                local.tee $12
-                i32.const 32
-                i32.lt_u
-                if ;; label = @7
-                  block ;; label = @8
-                    i32.const 0
-                    local.set $17
-                    loop $label$27 ;; label = @9
-                      i32.const 1
-                      local.get $12
-                      i32.shl
-                      i32.const 75913
-                      i32.and
-                      i32.eqz
-                      br_if 3 (;@6;)
-                      i32.const 1
-                      local.get $5
-                      i32.const 24
-                      i32.shl
-                      i32.const 24
-                      i32.shr_s
-                      i32.const -32
-                      i32.add
-                      i32.shl
-                      local.get $17
-                      i32.or
-                      local.set $17
-                      local.get $11
-                      i32.const 1
-                      i32.add
-                      local.tee $11
-                      i32.load8_s
-                      local.tee $5
-                      i32.const 24
-                      i32.shl
-                      i32.const 24
-                      i32.shr_s
-                      i32.const -32
-                      i32.add
-                      local.tee $12
-                      i32.const 32
-                      i32.lt_u
-                      br_if 0 (;@9;)
-                    end
-                  end
-                else
-                  i32.const 0
-                  local.set $17
-                end
-              end
-              block $label$29 ;; label = @6
-                local.get $5
-                i32.const 24
-                i32.shl
-                i32.const 24
-                i32.shr_s
-                i32.const 42
-                i32.eq
-                if ;; label = @7
-                  block ;; label = @8
-                    block $label$31 (result i32) ;; label = @9
-                      block $label$32 ;; label = @10
-                        local.get $11
-                        i32.const 1
-                        i32.add
-                        local.tee $7
-                        i32.load8_s
-                        local.tee $5
-                        i32.const 24
-                        i32.shl
-                        i32.const 24
-                        i32.shr_s
-                        i32.const -48
-                        i32.add
-                        local.tee $12
-                        i32.const 10
-                        i32.ge_u
-                        br_if 0 (;@10;)
-                        local.get $11
-                        i32.load8_s offset=2
-                        i32.const 36
-                        i32.ne
-                        br_if 0 (;@10;)
-                        local.get $4
-                        local.get $12
-                        i32.const 2
-                        i32.shl
-                        i32.add
-                        i32.const 10
-                        i32.store
-                        i32.const 1
-                        local.set $8
-                        local.get $3
-                        local.get $7
-                        i32.load8_s
-                        i32.const -48
-                        i32.add
-                        i32.const 3
-                        i32.shl
-                        i32.add
-                        i64.load
-                        i32.wrap_i64
-                        local.set $10
-                        local.get $11
-                        i32.const 3
-                        i32.add
-                        br 1 (;@9;)
-                      end
-                      local.get $10
-                      if ;; label = @10
-                        block ;; label = @11
-                          i32.const -1
-                          local.set $15
-                          br 6 (;@5;)
-                        end
-                      end
-                      local.get $30
-                      i32.eqz
-                      if ;; label = @10
-                        block ;; label = @11
-                          local.get $17
-                          local.set $12
-                          i32.const 0
-                          local.set $17
-                          local.get $7
-                          local.set $11
-                          i32.const 0
-                          local.set $10
-                          br 5 (;@6;)
-                        end
-                      end
-                      local.get $2
-                      i32.load
-                      i32.const 3
-                      i32.add
-                      i32.const -4
-                      i32.and
-                      local.tee $11
-                      i32.load
-                      local.set $10
-                      local.get $2
-                      local.get $11
-                      i32.const 4
-                      i32.add
-                      i32.store
-                      i32.const 0
-                      local.set $8
-                      local.get $7
-                    end
-                    local.set $11
-                    local.get $17
-                    i32.const 8192
-                    i32.or
-                    local.set $12
-                    i32.const 0
-                    local.get $10
-                    i32.sub
-                    local.set $7
-                    local.get $11
-                    i32.load8_s
-                    local.set $5
-                    local.get $10
-                    i32.const 0
-                    i32.lt_s
-                    local.tee $6
-                    i32.eqz
-                    if ;; label = @9
-                      local.get $17
-                      local.set $12
-                    end
-                    local.get $8
-                    local.set $17
-                    local.get $6
-                    if ;; label = @9
-                      local.get $7
-                      local.set $10
-                    end
-                  end
-                else
-                  local.get $5
-                  i32.const 24
-                  i32.shl
-                  i32.const 24
-                  i32.shr_s
-                  i32.const -48
-                  i32.add
-                  local.tee $12
-                  i32.const 10
-                  i32.lt_u
-                  if ;; label = @8
-                    block ;; label = @9
-                      i32.const 0
-                      local.set $7
-                      local.get $12
-                      local.set $5
-                      loop $label$39 ;; label = @10
-                        local.get $7
-                        i32.const 10
-                        i32.mul
-                        local.get $5
-                        i32.add
-                        local.set $7
-                        local.get $11
-                        i32.const 1
-                        i32.add
-                        local.tee $11
-                        i32.load8_s
-                        local.tee $12
-                        i32.const 24
-                        i32.shl
-                        i32.const 24
-                        i32.shr_s
-                        i32.const -48
-                        i32.add
-                        local.tee $5
-                        i32.const 10
-                        i32.lt_u
-                        br_if 0 (;@10;)
-                      end
-                      local.get $7
-                      i32.const 0
-                      i32.lt_s
-                      if ;; label = @10
-                        block ;; label = @11
-                          i32.const -1
-                          local.set $15
-                          br 6 (;@5;)
-                        end
-                      else
-                        block ;; label = @11
-                          local.get $12
-                          local.set $5
-                          local.get $17
-                          local.set $12
-                          local.get $10
-                          local.set $17
-                          local.get $7
-                          local.set $10
-                        end
-                      end
-                    end
-                  else
-                    block ;; label = @9
-                      local.get $17
-                      local.set $12
-                      local.get $10
-                      local.set $17
-                      i32.const 0
-                      local.set $10
-                    end
-                  end
-                end
-              end
-              block $label$43 ;; label = @6
-                local.get $5
-                i32.const 24
-                i32.shl
-                i32.const 24
-                i32.shr_s
-                i32.const 46
-                i32.eq
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $11
-                    i32.const 1
-                    i32.add
-                    local.tee $7
-                    i32.load8_s
-                    local.tee $5
-                    i32.const 24
-                    i32.shl
-                    i32.const 24
-                    i32.shr_s
-                    i32.const 42
-                    i32.ne
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $5
-                        i32.const 24
-                        i32.shl
-                        i32.const 24
-                        i32.shr_s
-                        i32.const -48
-                        i32.add
-                        local.tee $5
-                        i32.const 10
-                        i32.lt_u
-                        if ;; label = @11
-                          block ;; label = @12
-                            local.get $7
-                            local.set $11
-                            i32.const 0
-                            local.set $7
-                          end
-                        else
-                          block ;; label = @12
-                            i32.const 0
-                            local.set $5
-                            local.get $7
-                            local.set $11
-                            br 6 (;@6;)
-                          end
-                        end
-                        loop $label$48 ;; label = @11
-                          local.get $7
-                          i32.const 10
-                          i32.mul
-                          local.get $5
-                          i32.add
-                          local.set $5
-                          local.get $11
-                          i32.const 1
-                          i32.add
-                          local.tee $11
-                          i32.load8_s
-                          i32.const -48
-                          i32.add
-                          local.tee $8
-                          i32.const 10
-                          i32.ge_u
-                          br_if 5 (;@6;)
-                          local.get $5
-                          local.set $7
-                          local.get $8
-                          local.set $5
-                          br 0 (;@11;)
-                        end
-                      end
-                    end
-                    local.get $11
-                    i32.const 2
-                    i32.add
-                    local.tee $7
-                    i32.load8_s
-                    i32.const -48
-                    i32.add
-                    local.tee $5
-                    i32.const 10
-                    i32.lt_u
-                    if ;; label = @9
-                      local.get $11
-                      i32.load8_s offset=3
-                      i32.const 36
-                      i32.eq
-                      if ;; label = @10
-                        block ;; label = @11
-                          local.get $4
-                          local.get $5
-                          i32.const 2
-                          i32.shl
-                          i32.add
-                          i32.const 10
-                          i32.store
-                          local.get $3
-                          local.get $7
-                          i32.load8_s
-                          i32.const -48
-                          i32.add
-                          i32.const 3
-                          i32.shl
-                          i32.add
-                          i64.load
-                          i32.wrap_i64
-                          local.set $5
-                          local.get $11
-                          i32.const 4
-                          i32.add
-                          local.set $11
-                          br 5 (;@6;)
-                        end
-                      end
-                    end
-                    local.get $17
-                    if ;; label = @9
-                      block ;; label = @10
-                        i32.const -1
-                        local.set $15
-                        br 5 (;@5;)
-                      end
-                    end
-                    local.get $30
-                    if (result i32) ;; label = @9
-                      block (result i32) ;; label = @10
-                        local.get $2
-                        i32.load
-                        i32.const 3
-                        i32.add
-                        i32.const -4
-                        i32.and
-                        local.tee $11
-                        i32.load
-                        local.set $5
-                        local.get $2
-                        local.get $11
-                        i32.const 4
-                        i32.add
-                        i32.store
-                        local.get $7
-                      end
-                    else
-                      block (result i32) ;; label = @10
-                        i32.const 0
-                        local.set $5
-                        local.get $7
-                      end
-                    end
-                    local.set $11
-                  end
-                else
-                  i32.const -1
-                  local.set $5
-                end
-              end
-              local.get $11
-              local.set $7
-              i32.const 0
-              local.set $8
-              loop $label$55 ;; label = @6
-                local.get $7
-                i32.load8_s
-                i32.const -65
-                i32.add
-                local.tee $6
-                i32.const 57
-                i32.gt_u
-                if ;; label = @7
-                  block ;; label = @8
-                    i32.const -1
-                    local.set $15
-                    br 3 (;@5;)
-                  end
-                end
-                local.get $7
-                i32.const 1
-                i32.add
-                local.set $11
-                local.get $8
-                i32.const 58
-                i32.mul
-                i32.const 1168
-                i32.add
-                local.get $6
-                i32.add
-                i32.load8_s
-                local.tee $13
-                i32.const 255
-                i32.and
-                local.tee $6
-                i32.const -1
-                i32.add
-                i32.const 8
-                i32.lt_u
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $11
-                    local.set $7
-                    local.get $6
-                    local.set $8
-                    br 2 (;@6;)
-                  end
-                end
-              end
-              local.get $13
-              i32.const 24
-              i32.shl
-              i32.const 24
-              i32.shr_s
-              i32.eqz
-              if ;; label = @6
-                block ;; label = @7
-                  i32.const -1
-                  local.set $15
-                  br 2 (;@5;)
-                end
-              end
-              local.get $9
-              i32.const -1
-              i32.gt_s
-              local.set $14
-              block $label$59 ;; label = @6
-                block $label$60 ;; label = @7
-                  local.get $13
-                  i32.const 24
-                  i32.shl
-                  i32.const 24
-                  i32.shr_s
-                  i32.const 19
-                  i32.eq
-                  if ;; label = @8
-                    local.get $14
-                    if ;; label = @9
-                      block ;; label = @10
-                        i32.const -1
-                        local.set $15
-                        br 5 (;@5;)
-                      end
-                    else
-                      br 2 (;@7;)
-                    end
-                  else
-                    block ;; label = @9
-                      local.get $14
-                      if ;; label = @10
-                        block ;; label = @11
-                          local.get $4
-                          local.get $9
-                          i32.const 2
-                          i32.shl
-                          i32.add
-                          local.get $6
-                          i32.store
-                          local.get $16
-                          local.get $3
-                          local.get $9
-                          i32.const 3
-                          i32.shl
-                          i32.add
-                          i64.load
-                          i64.store
-                          br 4 (;@7;)
-                        end
-                      end
-                      local.get $30
-                      i32.eqz
-                      if ;; label = @10
-                        block ;; label = @11
-                          i32.const 0
-                          local.set $15
-                          br 6 (;@5;)
-                        end
-                      end
-                      local.get $16
-                      local.get $6
-                      local.get $2
-                      call $21
-                    end
-                  end
-                  br 1 (;@6;)
-                end
-                local.get $30
-                i32.eqz
-                if ;; label = @7
-                  block ;; label = @8
-                    i32.const 0
-                    local.set $10
-                    local.get $11
-                    local.set $1
-                    br 4 (;@4;)
-                  end
-                end
-              end
-              local.get $7
-              i32.load8_s
-              local.tee $7
-              i32.const -33
-              i32.and
-              local.set $9
-              local.get $8
-              i32.const 0
-              i32.ne
-              local.get $7
-              i32.const 15
-              i32.and
-              i32.const 3
-              i32.eq
-              i32.and
-              i32.eqz
-              if ;; label = @6
-                local.get $7
-                local.set $9
-              end
-              local.get $12
-              i32.const -65537
-              i32.and
-              local.set $7
-              local.get $12
-              i32.const 8192
-              i32.and
-              if ;; label = @6
-                local.get $7
-                local.set $12
-              end
-              block $label$70 ;; label = @6
-                block $label$71 ;; label = @7
-                  block $label$72 ;; label = @8
-                    block $label$73 ;; label = @9
-                      block $label$74 ;; label = @10
-                        block $label$75 ;; label = @11
-                          block $label$76 ;; label = @12
-                            block $label$77 ;; label = @13
-                              block $label$78 ;; label = @14
-                                block $label$79 ;; label = @15
-                                  block $label$80 ;; label = @16
-                                    block $label$81 ;; label = @17
-                                      block $label$82 ;; label = @18
-                                        block $label$83 ;; label = @19
-                                          block $label$84 ;; label = @20
-                                            block $label$85 ;; label = @21
-                                              block $label$86 ;; label = @22
-                                                block $label$87 ;; label = @23
-                                                  block $label$88 ;; label = @24
-                                                    block $label$89 ;; label = @25
-                                                      local.get $9
-                                                      i32.const 65
-                                                      i32.sub
-                                                      br_table 11 (;@14;) 12 (;@13;) 9 (;@16;) 12 (;@13;) 11 (;@14;) 11 (;@14;) 11 (;@14;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 10 (;@15;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 2 (;@23;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 11 (;@14;) 12 (;@13;) 6 (;@19;) 4 (;@21;) 11 (;@14;) 11 (;@14;) 11 (;@14;) 12 (;@13;) 4 (;@21;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 7 (;@18;) 0 (;@25;) 3 (;@22;) 1 (;@24;) 12 (;@13;) 12 (;@13;) 8 (;@17;) 12 (;@13;) 5 (;@20;) 12 (;@13;) 12 (;@13;) 2 (;@23;) 12 (;@13;)
-                                                    end
-                                                    block $label$90 ;; label = @25
-                                                      block $label$91 ;; label = @26
-                                                        block $label$92 ;; label = @27
-                                                          block $label$93 ;; label = @28
-                                                            block $label$94 ;; label = @29
-                                                              block $label$95 ;; label = @30
-                                                                block $label$96 ;; label = @31
-                                                                  block $label$97 ;; label = @32
-                                                                    local.get $8
-                                                                    i32.const 255
-                                                                    i32.and
-                                                                    i32.const 24
-                                                                    i32.shl
-                                                                    i32.const 24
-                                                                    i32.shr_s
-                                                                    i32.const 0
-                                                                    i32.sub
-                                                                    br_table 0 (;@32;) 1 (;@31;) 2 (;@30;) 3 (;@29;) 4 (;@28;) 7 (;@25;) 5 (;@27;) 6 (;@26;) 7 (;@25;)
-                                                                  end
-                                                                  local.get $16
-                                                                  i32.load
-                                                                  local.get $15
-                                                                  i32.store
-                                                                  i32.const 0
-                                                                  local.set $10
-                                                                  local.get $11
-                                                                  local.set $1
-                                                                  br 27 (;@4;)
-                                                                end
-                                                                local.get $16
-                                                                i32.load
-                                                                local.get $15
-                                                                i32.store
-                                                                i32.const 0
-                                                                local.set $10
-                                                                local.get $11
-                                                                local.set $1
-                                                                br 26 (;@4;)
-                                                              end
-                                                              local.get $16
-                                                              i32.load
-                                                              local.get $15
-                                                              i64.extend_i32_s
-                                                              i64.store
-                                                              i32.const 0
-                                                              local.set $10
-                                                              local.get $11
-                                                              local.set $1
-                                                              br 25 (;@4;)
-                                                            end
-                                                            local.get $16
-                                                            i32.load
-                                                            local.get $15
-                                                            i32.store16
-                                                            i32.const 0
-                                                            local.set $10
-                                                            local.get $11
-                                                            local.set $1
-                                                            br 24 (;@4;)
-                                                          end
-                                                          local.get $16
-                                                          i32.load
-                                                          local.get $15
-                                                          i32.store8
-                                                          i32.const 0
-                                                          local.set $10
-                                                          local.get $11
-                                                          local.set $1
-                                                          br 23 (;@4;)
-                                                        end
-                                                        local.get $16
-                                                        i32.load
-                                                        local.get $15
-                                                        i32.store
-                                                        i32.const 0
-                                                        local.set $10
-                                                        local.get $11
-                                                        local.set $1
-                                                        br 22 (;@4;)
-                                                      end
-                                                      local.get $16
-                                                      i32.load
-                                                      local.get $15
-                                                      i64.extend_i32_s
-                                                      i64.store
-                                                      i32.const 0
-                                                      local.set $10
-                                                      local.get $11
-                                                      local.set $1
-                                                      br 21 (;@4;)
-                                                    end
-                                                    i32.const 0
-                                                    local.set $10
-                                                    local.get $11
-                                                    local.set $1
-                                                    br 20 (;@4;)
-                                                  end
-                                                  local.get $12
-                                                  i32.const 8
-                                                  i32.or
-                                                  local.set $12
-                                                  local.get $5
-                                                  i32.const 8
-                                                  i32.le_u
-                                                  if ;; label = @24
-                                                    i32.const 8
-                                                    local.set $5
-                                                  end
-                                                  i32.const 120
-                                                  local.set $9
-                                                  br 11 (;@12;)
-                                                end
-                                                br 10 (;@12;)
-                                              end
-                                              local.get $16
-                                              i64.load
-                                              local.tee $50
-                                              i64.const 0
-                                              i64.eq
-                                              if ;; label = @22
-                                                local.get $21
-                                                local.set $7
-                                              else
-                                                block ;; label = @23
-                                                  local.get $21
-                                                  local.set $1
-                                                  loop $label$101 ;; label = @24
-                                                    local.get $1
-                                                    i32.const -1
-                                                    i32.add
-                                                    local.tee $1
-                                                    local.get $50
-                                                    i64.const 7
-                                                    i64.and
-                                                    i64.const 48
-                                                    i64.or
-                                                    i64.store8
-                                                    local.get $50
-                                                    i64.const 3
-                                                    i64.shr_u
-                                                    local.tee $50
-                                                    i64.const 0
-                                                    i64.ne
-                                                    br_if 0 (;@24;)
-                                                    local.get $1
-                                                    local.set $7
-                                                  end
-                                                end
-                                              end
-                                              local.get $12
-                                              i32.const 8
-                                              i32.and
-                                              if ;; label = @22
-                                                block ;; label = @23
-                                                  local.get $38
-                                                  local.get $7
-                                                  i32.sub
-                                                  local.tee $1
-                                                  i32.const 1
-                                                  i32.add
-                                                  local.set $8
-                                                  local.get $5
-                                                  local.get $1
-                                                  i32.le_s
-                                                  if ;; label = @24
-                                                    local.get $8
-                                                    local.set $5
-                                                  end
-                                                  i32.const 0
-                                                  local.set $6
-                                                  i32.const 1648
-                                                  local.set $8
-                                                  br 16 (;@7;)
-                                                end
-                                              else
-                                                block ;; label = @23
-                                                  i32.const 0
-                                                  local.set $6
-                                                  i32.const 1648
-                                                  local.set $8
-                                                  br 16 (;@7;)
-                                                end
-                                              end
-                                            end
-                                            local.get $16
-                                            i64.load
-                                            local.tee $50
-                                            i64.const 0
-                                            i64.lt_s
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                local.get $16
-                                                i64.const 0
-                                                local.get $50
-                                                i64.sub
-                                                local.tee $50
-                                                i64.store
-                                                i32.const 1
-                                                local.set $6
-                                                i32.const 1648
-                                                local.set $8
-                                                br 11 (;@11;)
-                                              end
-                                            end
-                                            local.get $12
-                                            i32.const 2048
-                                            i32.and
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                i32.const 1
-                                                local.set $6
-                                                i32.const 1649
-                                                local.set $8
-                                                br 11 (;@11;)
-                                              end
-                                            else
-                                              block ;; label = @22
-                                                local.get $12
-                                                i32.const 1
-                                                i32.and
-                                                local.tee $1
-                                                local.set $6
-                                                local.get $1
-                                                if (result i32) ;; label = @23
-                                                  i32.const 1650
-                                                else
-                                                  i32.const 1648
-                                                end
-                                                local.set $8
-                                                br 11 (;@11;)
-                                              end
-                                            end
-                                          end
-                                          local.get $16
-                                          i64.load
-                                          local.set $50
-                                          i32.const 0
-                                          local.set $6
-                                          i32.const 1648
-                                          local.set $8
-                                          br 8 (;@11;)
-                                        end
-                                        local.get $39
-                                        local.get $16
-                                        i64.load
-                                        i64.store8
-                                        local.get $39
-                                        local.set $1
-                                        local.get $7
-                                        local.set $12
-                                        i32.const 1
-                                        local.set $7
-                                        i32.const 0
-                                        local.set $6
-                                        i32.const 1648
-                                        local.set $8
-                                        local.get $21
-                                        local.set $5
-                                        br 12 (;@6;)
-                                      end
-                                      call $11
-                                      i32.load
-                                      call $23
-                                      local.set $1
-                                      br 7 (;@10;)
-                                    end
-                                    local.get $16
-                                    i32.load
-                                    local.tee $1
-                                    i32.eqz
-                                    if ;; label = @17
-                                      i32.const 1658
-                                      local.set $1
-                                    end
-                                    br 6 (;@10;)
-                                  end
-                                  local.get $37
-                                  local.get $16
-                                  i64.load
-                                  i64.store32
-                                  local.get $42
-                                  i32.const 0
-                                  i32.store
-                                  local.get $16
-                                  local.get $37
-                                  i32.store
-                                  local.get $37
-                                  local.set $7
-                                  i32.const -1
-                                  local.set $6
-                                  br 6 (;@9;)
-                                end
-                                local.get $16
-                                i32.load
-                                local.set $7
-                                local.get $5
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $5
-                                    local.set $6
-                                    br 7 (;@9;)
-                                  end
-                                else
-                                  block ;; label = @16
-                                    local.get $0
-                                    i32.const 32
-                                    local.get $10
-                                    i32.const 0
-                                    local.get $12
-                                    call $24
-                                    i32.const 0
-                                    local.set $1
-                                    br 8 (;@8;)
-                                  end
-                                end
-                              end
-                              local.get $16
-                              f64.load
-                              local.set $52
-                              local.get $20
-                              i32.const 0
-                              i32.store
-                              local.get $52
-                              i64.reinterpret_f64
-                              i64.const 0
-                              i64.lt_s
-                              if (result i32) ;; label = @14
-                                block (result i32) ;; label = @15
-                                  i32.const 1
-                                  local.set $24
-                                  local.get $52
-                                  f64.neg
-                                  local.set $52
-                                  i32.const 1665
-                                end
-                              else
-                                block (result i32) ;; label = @15
-                                  local.get $12
-                                  i32.const 1
-                                  i32.and
-                                  local.set $1
-                                  local.get $12
-                                  i32.const 2048
-                                  i32.and
-                                  if (result i32) ;; label = @16
-                                    block (result i32) ;; label = @17
-                                      i32.const 1
-                                      local.set $24
-                                      i32.const 1668
-                                    end
-                                  else
-                                    block (result i32) ;; label = @17
-                                      local.get $1
-                                      local.set $24
-                                      local.get $1
-                                      if (result i32) ;; label = @18
-                                        i32.const 1671
-                                      else
-                                        i32.const 1666
-                                      end
-                                    end
-                                  end
-                                end
-                              end
-                              local.set $26
-                              block $label$119 ;; label = @14
-                                local.get $52
-                                i64.reinterpret_f64
-                                i64.const 9218868437227405312
-                                i64.and
-                                i64.const 9218868437227405312
-                                i64.lt_u
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $52
-                                    local.get $20
-                                    call $26
-                                    f64.const 0x1p+1 (;=2;)
-                                    f64.mul
-                                    local.tee $52
-                                    f64.const 0x0p+0 (;=0;)
-                                    f64.ne
-                                    local.tee $1
-                                    if ;; label = @17
-                                      local.get $20
-                                      local.get $20
-                                      i32.load
-                                      i32.const -1
-                                      i32.add
-                                      i32.store
-                                    end
-                                    local.get $9
-                                    i32.const 32
-                                    i32.or
-                                    local.tee $22
-                                    i32.const 97
-                                    i32.eq
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        local.get $26
-                                        i32.const 9
-                                        i32.add
-                                        local.set $1
-                                        local.get $9
-                                        i32.const 32
-                                        i32.and
-                                        local.tee $6
-                                        if ;; label = @19
-                                          local.get $1
-                                          local.set $26
-                                        end
-                                        local.get $5
-                                        i32.const 11
-                                        i32.gt_u
-                                        i32.const 12
-                                        local.get $5
-                                        i32.sub
-                                        local.tee $1
-                                        i32.eqz
-                                        i32.or
-                                        i32.eqz
-                                        if ;; label = @19
-                                          block ;; label = @20
-                                            f64.const 0x1p+3 (;=8;)
-                                            local.set $53
-                                            loop $label$125 ;; label = @21
-                                              local.get $53
-                                              f64.const 0x1p+4 (;=16;)
-                                              f64.mul
-                                              local.set $53
-                                              local.get $1
-                                              i32.const -1
-                                              i32.add
-                                              local.tee $1
-                                              br_if 0 (;@21;)
-                                            end
-                                            local.get $26
-                                            i32.load8_s
-                                            i32.const 45
-                                            i32.eq
-                                            if (result f64) ;; label = @21
-                                              local.get $53
-                                              local.get $52
-                                              f64.neg
-                                              local.get $53
-                                              f64.sub
-                                              f64.add
-                                              f64.neg
-                                            else
-                                              local.get $52
-                                              local.get $53
-                                              f64.add
-                                              local.get $53
-                                              f64.sub
-                                            end
-                                            local.set $52
-                                          end
-                                        end
-                                        i32.const 0
-                                        local.get $20
-                                        i32.load
-                                        local.tee $7
-                                        i32.sub
-                                        local.set $1
-                                        local.get $7
-                                        i32.const 0
-                                        i32.lt_s
-                                        if (result i32) ;; label = @19
-                                          local.get $1
-                                        else
-                                          local.get $7
-                                        end
-                                        i64.extend_i32_s
-                                        local.get $33
-                                        call $22
-                                        local.tee $1
-                                        local.get $33
-                                        i32.eq
-                                        if ;; label = @19
-                                          block ;; label = @20
-                                            local.get $40
-                                            i32.const 48
-                                            i32.store8
-                                            local.get $40
-                                            local.set $1
-                                          end
-                                        end
-                                        local.get $24
-                                        i32.const 2
-                                        i32.or
-                                        local.set $13
-                                        local.get $1
-                                        i32.const -1
-                                        i32.add
-                                        local.get $7
-                                        i32.const 31
-                                        i32.shr_s
-                                        i32.const 2
-                                        i32.and
-                                        i32.const 43
-                                        i32.add
-                                        i32.store8
-                                        local.get $1
-                                        i32.const -2
-                                        i32.add
-                                        local.tee $8
-                                        local.get $9
-                                        i32.const 15
-                                        i32.add
-                                        i32.store8
-                                        local.get $5
-                                        i32.const 1
-                                        i32.lt_s
-                                        local.set $9
-                                        local.get $12
-                                        i32.const 8
-                                        i32.and
-                                        i32.eqz
-                                        local.set $14
-                                        local.get $19
-                                        local.set $1
-                                        loop $label$131 ;; label = @19
-                                          local.get $1
-                                          local.get $52
-                                          i32.trunc_f64_s
-                                          local.tee $7
-                                          i32.const 1632
-                                          i32.add
-                                          i32.load8_u
-                                          local.get $6
-                                          i32.or
-                                          i32.store8
-                                          local.get $52
-                                          local.get $7
-                                          f64.convert_i32_s
-                                          f64.sub
-                                          f64.const 0x1p+4 (;=16;)
-                                          f64.mul
-                                          local.set $52
-                                          block $label$132 (result i32) ;; label = @20
-                                            local.get $1
-                                            i32.const 1
-                                            i32.add
-                                            local.tee $7
-                                            local.get $27
-                                            i32.sub
-                                            i32.const 1
-                                            i32.eq
-                                            if (result i32) ;; label = @21
-                                              block (result i32) ;; label = @22
-                                                local.get $7
-                                                local.get $14
-                                                local.get $9
-                                                local.get $52
-                                                f64.const 0x0p+0 (;=0;)
-                                                f64.eq
-                                                i32.and
-                                                i32.and
-                                                br_if 2 (;@20;)
-                                                drop
-                                                local.get $7
-                                                i32.const 46
-                                                i32.store8
-                                                local.get $1
-                                                i32.const 2
-                                                i32.add
-                                              end
-                                            else
-                                              local.get $7
-                                            end
-                                          end
-                                          local.set $1
-                                          local.get $52
-                                          f64.const 0x0p+0 (;=0;)
-                                          f64.ne
-                                          br_if 0 (;@19;)
-                                        end
-                                        local.get $46
-                                        local.get $5
-                                        i32.add
-                                        local.get $8
-                                        local.tee $7
-                                        i32.sub
-                                        local.set $6
-                                        local.get $44
-                                        local.get $7
-                                        i32.sub
-                                        local.get $1
-                                        i32.add
-                                        local.set $9
-                                        local.get $0
-                                        i32.const 32
-                                        local.get $10
-                                        local.get $5
-                                        i32.const 0
-                                        i32.ne
-                                        local.get $45
-                                        local.get $1
-                                        i32.add
-                                        local.get $5
-                                        i32.lt_s
-                                        i32.and
-                                        if (result i32) ;; label = @19
-                                          local.get $6
-                                        else
-                                          local.get $9
-                                          local.tee $6
-                                        end
-                                        local.get $13
-                                        i32.add
-                                        local.tee $5
-                                        local.get $12
-                                        call $24
-                                        local.get $0
-                                        i32.load
-                                        i32.const 32
-                                        i32.and
-                                        i32.eqz
-                                        if ;; label = @19
-                                          local.get $26
-                                          local.get $13
-                                          local.get $0
-                                          call $20
-                                          drop
-                                        end
-                                        local.get $0
-                                        i32.const 48
-                                        local.get $10
-                                        local.get $5
-                                        local.get $12
-                                        i32.const 65536
-                                        i32.xor
-                                        call $24
-                                        local.get $1
-                                        local.get $27
-                                        i32.sub
-                                        local.set $1
-                                        local.get $0
-                                        i32.load
-                                        i32.const 32
-                                        i32.and
-                                        i32.eqz
-                                        if ;; label = @19
-                                          local.get $19
-                                          local.get $1
-                                          local.get $0
-                                          call $20
-                                          drop
-                                        end
-                                        local.get $0
-                                        i32.const 48
-                                        local.get $6
-                                        local.get $1
-                                        local.get $28
-                                        local.get $7
-                                        i32.sub
-                                        local.tee $1
-                                        i32.add
-                                        i32.sub
-                                        i32.const 0
-                                        i32.const 0
-                                        call $24
-                                        local.get $0
-                                        i32.load
-                                        i32.const 32
-                                        i32.and
-                                        i32.eqz
-                                        if ;; label = @19
-                                          local.get $8
-                                          local.get $1
-                                          local.get $0
-                                          call $20
-                                          drop
-                                        end
-                                        local.get $0
-                                        i32.const 32
-                                        local.get $10
-                                        local.get $5
-                                        local.get $12
-                                        i32.const 8192
-                                        i32.xor
-                                        call $24
-                                        local.get $5
-                                        local.get $10
-                                        i32.ge_s
-                                        if ;; label = @19
-                                          local.get $5
-                                          local.set $10
-                                        end
-                                        br 4 (;@14;)
-                                      end
-                                    end
-                                    local.get $1
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        local.get $20
-                                        local.get $20
-                                        i32.load
-                                        i32.const -28
-                                        i32.add
-                                        local.tee $6
-                                        i32.store
-                                        local.get $52
-                                        f64.const 0x1p+28 (;=268435456;)
-                                        f64.mul
-                                        local.set $52
-                                      end
-                                    else
-                                      local.get $20
-                                      i32.load
-                                      local.set $6
-                                    end
-                                    local.get $6
-                                    i32.const 0
-                                    i32.lt_s
-                                    if (result i32) ;; label = @17
-                                      local.get $47
-                                    else
-                                      local.get $48
-                                    end
-                                    local.tee $7
-                                    local.set $8
-                                    loop $label$145 ;; label = @17
-                                      local.get $8
-                                      local.get $52
-                                      i32.trunc_f64_s
-                                      local.tee $1
-                                      i32.store
-                                      local.get $8
-                                      i32.const 4
-                                      i32.add
-                                      local.set $8
-                                      local.get $52
-                                      local.get $1
-                                      f64.convert_i32_u
-                                      f64.sub
-                                      f64.const 0x1.dcd65p+29 (;=1000000000;)
-                                      f64.mul
-                                      local.tee $52
-                                      f64.const 0x0p+0 (;=0;)
-                                      f64.ne
-                                      br_if 0 (;@17;)
-                                    end
-                                    local.get $6
-                                    i32.const 0
-                                    i32.gt_s
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        local.get $7
-                                        local.set $1
-                                        loop $label$147 ;; label = @19
-                                          local.get $6
-                                          i32.const 29
-                                          i32.gt_s
-                                          if (result i32) ;; label = @20
-                                            i32.const 29
-                                          else
-                                            local.get $6
-                                          end
-                                          local.set $14
-                                          block $label$150 ;; label = @20
-                                            local.get $8
-                                            i32.const -4
-                                            i32.add
-                                            local.tee $6
-                                            local.get $1
-                                            i32.ge_u
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                local.get $14
-                                                i64.extend_i32_u
-                                                local.set $50
-                                                i32.const 0
-                                                local.set $13
-                                                loop $label$152 ;; label = @23
-                                                  local.get $6
-                                                  local.get $6
-                                                  i32.load
-                                                  i64.extend_i32_u
-                                                  local.get $50
-                                                  i64.shl
-                                                  local.get $13
-                                                  i64.extend_i32_u
-                                                  i64.add
-                                                  local.tee $51
-                                                  i64.const 1000000000
-                                                  i64.rem_u
-                                                  i64.store32
-                                                  local.get $51
-                                                  i64.const 1000000000
-                                                  i64.div_u
-                                                  i32.wrap_i64
-                                                  local.set $13
-                                                  local.get $6
-                                                  i32.const -4
-                                                  i32.add
-                                                  local.tee $6
-                                                  local.get $1
-                                                  i32.ge_u
-                                                  br_if 0 (;@23;)
-                                                end
-                                                local.get $13
-                                                i32.eqz
-                                                br_if 2 (;@20;)
-                                                local.get $1
-                                                i32.const -4
-                                                i32.add
-                                                local.tee $1
-                                                local.get $13
-                                                i32.store
-                                              end
-                                            end
-                                          end
-                                          loop $label$153 ;; label = @20
-                                            local.get $8
-                                            local.get $1
-                                            i32.gt_u
-                                            if ;; label = @21
-                                              local.get $8
-                                              i32.const -4
-                                              i32.add
-                                              local.tee $6
-                                              i32.load
-                                              i32.eqz
-                                              if ;; label = @22
-                                                block ;; label = @23
-                                                  local.get $6
-                                                  local.set $8
-                                                  br 3 (;@20;)
-                                                end
-                                              end
-                                            end
-                                          end
-                                          local.get $20
-                                          local.get $20
-                                          i32.load
-                                          local.get $14
-                                          i32.sub
-                                          local.tee $6
-                                          i32.store
-                                          local.get $6
-                                          i32.const 0
-                                          i32.gt_s
-                                          br_if 0 (;@19;)
-                                        end
-                                      end
-                                    else
-                                      local.get $7
-                                      local.set $1
-                                    end
-                                    local.get $5
-                                    i32.const 0
-                                    i32.lt_s
-                                    if (result i32) ;; label = @17
-                                      i32.const 6
-                                    else
-                                      local.get $5
-                                    end
-                                    local.set $18
-                                    local.get $6
-                                    i32.const 0
-                                    i32.lt_s
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        local.get $18
-                                        i32.const 25
-                                        i32.add
-                                        i32.const 9
-                                        i32.div_s
-                                        i32.const 1
-                                        i32.add
-                                        local.set $14
-                                        local.get $22
-                                        i32.const 102
-                                        i32.eq
-                                        local.set $25
-                                        local.get $8
-                                        local.set $5
-                                        loop $label$160 ;; label = @19
-                                          i32.const 0
-                                          local.get $6
-                                          i32.sub
-                                          local.tee $13
-                                          i32.const 9
-                                          i32.gt_s
-                                          if ;; label = @20
-                                            i32.const 9
-                                            local.set $13
-                                          end
-                                          block $label$162 ;; label = @20
-                                            local.get $1
-                                            local.get $5
-                                            i32.lt_u
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                i32.const 1
-                                                local.get $13
-                                                i32.shl
-                                                i32.const -1
-                                                i32.add
-                                                local.set $29
-                                                i32.const 1000000000
-                                                local.get $13
-                                                i32.shr_u
-                                                local.set $35
-                                                i32.const 0
-                                                local.set $6
-                                                local.get $1
-                                                local.set $8
-                                                loop $label$164 ;; label = @23
-                                                  local.get $8
-                                                  local.get $8
-                                                  i32.load
-                                                  local.tee $32
-                                                  local.get $13
-                                                  i32.shr_u
-                                                  local.get $6
-                                                  i32.add
-                                                  i32.store
-                                                  local.get $32
-                                                  local.get $29
-                                                  i32.and
-                                                  local.get $35
-                                                  i32.mul
-                                                  local.set $6
-                                                  local.get $8
-                                                  i32.const 4
-                                                  i32.add
-                                                  local.tee $8
-                                                  local.get $5
-                                                  i32.lt_u
-                                                  br_if 0 (;@23;)
-                                                end
-                                                local.get $1
-                                                i32.const 4
-                                                i32.add
-                                                local.set $8
-                                                local.get $1
-                                                i32.load
-                                                i32.eqz
-                                                if ;; label = @23
-                                                  local.get $8
-                                                  local.set $1
-                                                end
-                                                local.get $6
-                                                i32.eqz
-                                                br_if 2 (;@20;)
-                                                local.get $5
-                                                local.get $6
-                                                i32.store
-                                                local.get $5
-                                                i32.const 4
-                                                i32.add
-                                                local.set $5
-                                              end
-                                            else
-                                              block ;; label = @22
-                                                local.get $1
-                                                i32.const 4
-                                                i32.add
-                                                local.set $8
-                                                local.get $1
-                                                i32.load
-                                                i32.eqz
-                                                if ;; label = @23
-                                                  local.get $8
-                                                  local.set $1
-                                                end
-                                              end
-                                            end
-                                          end
-                                          local.get $25
-                                          if (result i32) ;; label = @20
-                                            local.get $7
-                                          else
-                                            local.get $1
-                                          end
-                                          local.tee $8
-                                          local.get $14
-                                          i32.const 2
-                                          i32.shl
-                                          i32.add
-                                          local.set $6
-                                          local.get $5
-                                          local.get $8
-                                          i32.sub
-                                          i32.const 2
-                                          i32.shr_s
-                                          local.get $14
-                                          i32.gt_s
-                                          if ;; label = @20
-                                            local.get $6
-                                            local.set $5
-                                          end
-                                          local.get $20
-                                          local.get $20
-                                          i32.load
-                                          local.get $13
-                                          i32.add
-                                          local.tee $6
-                                          i32.store
-                                          local.get $6
-                                          i32.const 0
-                                          i32.lt_s
-                                          br_if 0 (;@19;)
-                                          local.get $5
-                                          local.set $13
-                                        end
-                                      end
-                                    else
-                                      local.get $8
-                                      local.set $13
-                                    end
-                                    local.get $7
-                                    local.set $25
-                                    block $label$172 ;; label = @17
-                                      local.get $1
-                                      local.get $13
-                                      i32.lt_u
-                                      if ;; label = @18
-                                        block ;; label = @19
-                                          local.get $25
-                                          local.get $1
-                                          i32.sub
-                                          i32.const 2
-                                          i32.shr_s
-                                          i32.const 9
-                                          i32.mul
-                                          local.set $5
-                                          local.get $1
-                                          i32.load
-                                          local.tee $6
-                                          i32.const 10
-                                          i32.lt_u
-                                          br_if 2 (;@17;)
-                                          i32.const 10
-                                          local.set $8
-                                          loop $label$174 ;; label = @20
-                                            local.get $5
-                                            i32.const 1
-                                            i32.add
-                                            local.set $5
-                                            local.get $6
-                                            local.get $8
-                                            i32.const 10
-                                            i32.mul
-                                            local.tee $8
-                                            i32.ge_u
-                                            br_if 0 (;@20;)
-                                          end
-                                        end
-                                      else
-                                        i32.const 0
-                                        local.set $5
-                                      end
-                                    end
-                                    local.get $22
-                                    i32.const 103
-                                    i32.eq
-                                    local.set $29
-                                    local.get $18
-                                    i32.const 0
-                                    i32.ne
-                                    local.set $35
-                                    local.get $18
-                                    local.get $22
-                                    i32.const 102
-                                    i32.ne
-                                    if (result i32) ;; label = @17
-                                      local.get $5
-                                    else
-                                      i32.const 0
-                                    end
-                                    i32.sub
-                                    local.get $35
-                                    local.get $29
-                                    i32.and
-                                    i32.const 31
-                                    i32.shl
-                                    i32.const 31
-                                    i32.shr_s
-                                    i32.add
-                                    local.tee $8
-                                    local.get $13
-                                    local.get $25
-                                    i32.sub
-                                    i32.const 2
-                                    i32.shr_s
-                                    i32.const 9
-                                    i32.mul
-                                    i32.const -9
-                                    i32.add
-                                    i32.lt_s
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        local.get $8
-                                        i32.const 9216
-                                        i32.add
-                                        local.tee $14
-                                        i32.const 9
-                                        i32.rem_s
-                                        i32.const 1
-                                        i32.add
-                                        local.tee $8
-                                        i32.const 9
-                                        i32.lt_s
-                                        if ;; label = @19
-                                          block ;; label = @20
-                                            i32.const 10
-                                            local.set $6
-                                            loop $label$180 ;; label = @21
-                                              local.get $6
-                                              i32.const 10
-                                              i32.mul
-                                              local.set $6
-                                              local.get $8
-                                              i32.const 1
-                                              i32.add
-                                              local.tee $8
-                                              i32.const 9
-                                              i32.ne
-                                              br_if 0 (;@21;)
-                                            end
-                                          end
-                                        else
-                                          i32.const 10
-                                          local.set $6
-                                        end
-                                        local.get $7
-                                        i32.const 4
-                                        i32.add
-                                        local.get $14
-                                        i32.const 9
-                                        i32.div_s
-                                        i32.const -1024
-                                        i32.add
-                                        i32.const 2
-                                        i32.shl
-                                        i32.add
-                                        local.tee $8
-                                        i32.load
-                                        local.tee $22
-                                        local.get $6
-                                        i32.rem_u
-                                        local.set $14
-                                        block $label$182 ;; label = @19
-                                          local.get $8
-                                          i32.const 4
-                                          i32.add
-                                          local.get $13
-                                          i32.eq
-                                          local.tee $32
-                                          local.get $14
-                                          i32.eqz
-                                          i32.and
-                                          i32.eqz
-                                          if ;; label = @20
-                                            block ;; label = @21
-                                              local.get $14
-                                              local.get $6
-                                              i32.const 2
-                                              i32.div_s
-                                              local.tee $49
-                                              i32.lt_u
-                                              if (result f64) ;; label = @22
-                                                f64.const 0x1p-1 (;=0.5;)
-                                              else
-                                                local.get $32
-                                                local.get $14
-                                                local.get $49
-                                                i32.eq
-                                                i32.and
-                                                if (result f64) ;; label = @23
-                                                  f64.const 0x1p+0 (;=1;)
-                                                else
-                                                  f64.const 0x1.8p+0 (;=1.5;)
-                                                end
-                                              end
-                                              local.set $52
-                                              local.get $22
-                                              local.get $6
-                                              i32.div_u
-                                              i32.const 1
-                                              i32.and
-                                              if (result f64) ;; label = @22
-                                                f64.const 0x1.0000000000001p+53 (;=9007199254740994;)
-                                              else
-                                                f64.const 0x1p+53 (;=9007199254740992;)
-                                              end
-                                              local.set $53
-                                              block $label$190 ;; label = @22
-                                                local.get $24
-                                                if ;; label = @23
-                                                  block ;; label = @24
-                                                    local.get $26
-                                                    i32.load8_s
-                                                    i32.const 45
-                                                    i32.ne
-                                                    br_if 2 (;@22;)
-                                                    local.get $53
-                                                    f64.neg
-                                                    local.set $53
-                                                    local.get $52
-                                                    f64.neg
-                                                    local.set $52
-                                                  end
-                                                end
-                                              end
-                                              local.get $8
-                                              local.get $22
-                                              local.get $14
-                                              i32.sub
-                                              local.tee $14
-                                              i32.store
-                                              local.get $53
-                                              local.get $52
-                                              f64.add
-                                              local.get $53
-                                              f64.eq
-                                              br_if 2 (;@19;)
-                                              local.get $8
-                                              local.get $14
-                                              local.get $6
-                                              i32.add
-                                              local.tee $5
-                                              i32.store
-                                              local.get $5
-                                              i32.const 999999999
-                                              i32.gt_u
-                                              if ;; label = @22
-                                                loop $label$193 ;; label = @23
-                                                  local.get $8
-                                                  i32.const 0
-                                                  i32.store
-                                                  local.get $8
-                                                  i32.const -4
-                                                  i32.add
-                                                  local.tee $8
-                                                  local.get $1
-                                                  i32.lt_u
-                                                  if ;; label = @24
-                                                    local.get $1
-                                                    i32.const -4
-                                                    i32.add
-                                                    local.tee $1
-                                                    i32.const 0
-                                                    i32.store
-                                                  end
-                                                  local.get $8
-                                                  local.get $8
-                                                  i32.load
-                                                  i32.const 1
-                                                  i32.add
-                                                  local.tee $5
-                                                  i32.store
-                                                  local.get $5
-                                                  i32.const 999999999
-                                                  i32.gt_u
-                                                  br_if 0 (;@23;)
-                                                end
-                                              end
-                                              local.get $25
-                                              local.get $1
-                                              i32.sub
-                                              i32.const 2
-                                              i32.shr_s
-                                              i32.const 9
-                                              i32.mul
-                                              local.set $5
-                                              local.get $1
-                                              i32.load
-                                              local.tee $14
-                                              i32.const 10
-                                              i32.lt_u
-                                              br_if 2 (;@19;)
-                                              i32.const 10
-                                              local.set $6
-                                              loop $label$195 ;; label = @22
-                                                local.get $5
-                                                i32.const 1
-                                                i32.add
-                                                local.set $5
-                                                local.get $14
-                                                local.get $6
-                                                i32.const 10
-                                                i32.mul
-                                                local.tee $6
-                                                i32.ge_u
-                                                br_if 0 (;@22;)
-                                              end
-                                            end
-                                          end
-                                        end
-                                        local.get $1
-                                        local.set $14
-                                        local.get $5
-                                        local.set $6
-                                        local.get $13
-                                        local.get $8
-                                        i32.const 4
-                                        i32.add
-                                        local.tee $8
-                                        i32.le_u
-                                        if ;; label = @19
-                                          local.get $13
-                                          local.set $8
-                                        end
-                                      end
-                                    else
-                                      block ;; label = @18
-                                        local.get $1
-                                        local.set $14
-                                        local.get $5
-                                        local.set $6
-                                        local.get $13
-                                        local.set $8
-                                      end
-                                    end
-                                    i32.const 0
-                                    local.get $6
-                                    i32.sub
-                                    local.set $32
-                                    loop $label$198 ;; label = @17
-                                      block $label$199 ;; label = @18
-                                        local.get $8
-                                        local.get $14
-                                        i32.le_u
-                                        if ;; label = @19
-                                          block ;; label = @20
-                                            i32.const 0
-                                            local.set $22
-                                            br 2 (;@18;)
-                                          end
-                                        end
-                                        local.get $8
-                                        i32.const -4
-                                        i32.add
-                                        local.tee $1
-                                        i32.load
-                                        if ;; label = @19
-                                          i32.const 1
-                                          local.set $22
-                                        else
-                                          block ;; label = @20
-                                            local.get $1
-                                            local.set $8
-                                            br 3 (;@17;)
-                                          end
-                                        end
-                                      end
-                                    end
-                                    block $label$203 ;; label = @17
-                                      local.get $29
-                                      if ;; label = @18
-                                        block ;; label = @19
-                                          local.get $35
-                                          i32.const 1
-                                          i32.and
-                                          i32.const 1
-                                          i32.xor
-                                          local.get $18
-                                          i32.add
-                                          local.tee $1
-                                          local.get $6
-                                          i32.gt_s
-                                          local.get $6
-                                          i32.const -5
-                                          i32.gt_s
-                                          i32.and
-                                          if (result i32) ;; label = @20
-                                            block (result i32) ;; label = @21
-                                              local.get $9
-                                              i32.const -1
-                                              i32.add
-                                              local.set $5
-                                              local.get $1
-                                              i32.const -1
-                                              i32.add
-                                              local.get $6
-                                              i32.sub
-                                            end
-                                          else
-                                            block (result i32) ;; label = @21
-                                              local.get $9
-                                              i32.const -2
-                                              i32.add
-                                              local.set $5
-                                              local.get $1
-                                              i32.const -1
-                                              i32.add
-                                            end
-                                          end
-                                          local.set $1
-                                          local.get $12
-                                          i32.const 8
-                                          i32.and
-                                          local.tee $13
-                                          br_if 2 (;@17;)
-                                          block $label$207 ;; label = @20
-                                            local.get $22
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                local.get $8
-                                                i32.const -4
-                                                i32.add
-                                                i32.load
-                                                local.tee $18
-                                                i32.eqz
-                                                if ;; label = @23
-                                                  block ;; label = @24
-                                                    i32.const 9
-                                                    local.set $9
-                                                    br 4 (;@20;)
-                                                  end
-                                                end
-                                                local.get $18
-                                                i32.const 10
-                                                i32.rem_u
-                                                if ;; label = @23
-                                                  block ;; label = @24
-                                                    i32.const 0
-                                                    local.set $9
-                                                    br 4 (;@20;)
-                                                  end
-                                                else
-                                                  block ;; label = @24
-                                                    i32.const 10
-                                                    local.set $13
-                                                    i32.const 0
-                                                    local.set $9
-                                                  end
-                                                end
-                                                loop $label$212 ;; label = @23
-                                                  local.get $9
-                                                  i32.const 1
-                                                  i32.add
-                                                  local.set $9
-                                                  local.get $18
-                                                  local.get $13
-                                                  i32.const 10
-                                                  i32.mul
-                                                  local.tee $13
-                                                  i32.rem_u
-                                                  i32.eqz
-                                                  br_if 0 (;@23;)
-                                                end
-                                              end
-                                            else
-                                              i32.const 9
-                                              local.set $9
-                                            end
-                                          end
-                                          local.get $8
-                                          local.get $25
-                                          i32.sub
-                                          i32.const 2
-                                          i32.shr_s
-                                          i32.const 9
-                                          i32.mul
-                                          i32.const -9
-                                          i32.add
-                                          local.set $18
-                                          local.get $5
-                                          i32.const 32
-                                          i32.or
-                                          i32.const 102
-                                          i32.eq
-                                          if ;; label = @20
-                                            block ;; label = @21
-                                              i32.const 0
-                                              local.set $13
-                                              local.get $1
-                                              local.get $18
-                                              local.get $9
-                                              i32.sub
-                                              local.tee $9
-                                              i32.const 0
-                                              i32.lt_s
-                                              if (result i32) ;; label = @22
-                                                i32.const 0
-                                                local.tee $9
-                                              else
-                                                local.get $9
-                                              end
-                                              i32.ge_s
-                                              if ;; label = @22
-                                                local.get $9
-                                                local.set $1
-                                              end
-                                            end
-                                          else
-                                            block ;; label = @21
-                                              i32.const 0
-                                              local.set $13
-                                              local.get $1
-                                              local.get $18
-                                              local.get $6
-                                              i32.add
-                                              local.get $9
-                                              i32.sub
-                                              local.tee $9
-                                              i32.const 0
-                                              i32.lt_s
-                                              if (result i32) ;; label = @22
-                                                i32.const 0
-                                                local.tee $9
-                                              else
-                                                local.get $9
-                                              end
-                                              i32.ge_s
-                                              if ;; label = @22
-                                                local.get $9
-                                                local.set $1
-                                              end
-                                            end
-                                          end
-                                        end
-                                      else
-                                        block ;; label = @19
-                                          local.get $12
-                                          i32.const 8
-                                          i32.and
-                                          local.set $13
-                                          local.get $18
-                                          local.set $1
-                                          local.get $9
-                                          local.set $5
-                                        end
-                                      end
-                                    end
-                                    local.get $5
-                                    i32.const 32
-                                    i32.or
-                                    i32.const 102
-                                    i32.eq
-                                    local.tee $25
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        i32.const 0
-                                        local.set $9
-                                        local.get $6
-                                        i32.const 0
-                                        i32.le_s
-                                        if ;; label = @19
-                                          i32.const 0
-                                          local.set $6
-                                        end
-                                      end
-                                    else
-                                      block ;; label = @18
-                                        local.get $28
-                                        local.get $6
-                                        i32.const 0
-                                        i32.lt_s
-                                        if (result i32) ;; label = @19
-                                          local.get $32
-                                        else
-                                          local.get $6
-                                        end
-                                        i64.extend_i32_s
-                                        local.get $33
-                                        call $22
-                                        local.tee $9
-                                        i32.sub
-                                        i32.const 2
-                                        i32.lt_s
-                                        if ;; label = @19
-                                          loop $label$229 ;; label = @20
-                                            local.get $9
-                                            i32.const -1
-                                            i32.add
-                                            local.tee $9
-                                            i32.const 48
-                                            i32.store8
-                                            local.get $28
-                                            local.get $9
-                                            i32.sub
-                                            i32.const 2
-                                            i32.lt_s
-                                            br_if 0 (;@20;)
-                                          end
-                                        end
-                                        local.get $9
-                                        i32.const -1
-                                        i32.add
-                                        local.get $6
-                                        i32.const 31
-                                        i32.shr_s
-                                        i32.const 2
-                                        i32.and
-                                        i32.const 43
-                                        i32.add
-                                        i32.store8
-                                        local.get $9
-                                        i32.const -2
-                                        i32.add
-                                        local.tee $6
-                                        local.get $5
-                                        i32.store8
-                                        local.get $6
-                                        local.set $9
-                                        local.get $28
-                                        local.get $6
-                                        i32.sub
-                                        local.set $6
-                                      end
-                                    end
-                                    local.get $0
-                                    i32.const 32
-                                    local.get $10
-                                    local.get $24
-                                    i32.const 1
-                                    i32.add
-                                    local.get $1
-                                    i32.add
-                                    local.get $1
-                                    local.get $13
-                                    i32.or
-                                    local.tee $29
-                                    i32.const 0
-                                    i32.ne
-                                    i32.add
-                                    local.get $6
-                                    i32.add
-                                    local.tee $18
-                                    local.get $12
-                                    call $24
-                                    local.get $0
-                                    i32.load
-                                    i32.const 32
-                                    i32.and
-                                    i32.eqz
-                                    if ;; label = @17
-                                      local.get $26
-                                      local.get $24
-                                      local.get $0
-                                      call $20
-                                      drop
-                                    end
-                                    local.get $0
-                                    i32.const 48
-                                    local.get $10
-                                    local.get $18
-                                    local.get $12
-                                    i32.const 65536
-                                    i32.xor
-                                    call $24
-                                    block $label$231 ;; label = @17
-                                      local.get $25
-                                      if ;; label = @18
-                                        block ;; label = @19
-                                          local.get $14
-                                          local.get $7
-                                          i32.gt_u
-                                          if (result i32) ;; label = @20
-                                            local.get $7
-                                          else
-                                            local.get $14
-                                          end
-                                          local.tee $9
-                                          local.set $6
-                                          loop $label$235 ;; label = @20
-                                            local.get $6
-                                            i32.load
-                                            i64.extend_i32_u
-                                            local.get $31
-                                            call $22
-                                            local.set $5
-                                            block $label$236 ;; label = @21
-                                              local.get $6
-                                              local.get $9
-                                              i32.eq
-                                              if ;; label = @22
-                                                block ;; label = @23
-                                                  local.get $5
-                                                  local.get $31
-                                                  i32.ne
-                                                  br_if 2 (;@21;)
-                                                  local.get $34
-                                                  i32.const 48
-                                                  i32.store8
-                                                  local.get $34
-                                                  local.set $5
-                                                end
-                                              else
-                                                block ;; label = @23
-                                                  local.get $5
-                                                  local.get $19
-                                                  i32.le_u
-                                                  br_if 2 (;@21;)
-                                                  local.get $19
-                                                  i32.const 48
-                                                  local.get $5
-                                                  local.get $27
-                                                  i32.sub
-                                                  call $35
-                                                  drop
-                                                  loop $label$239 ;; label = @24
-                                                    local.get $5
-                                                    i32.const -1
-                                                    i32.add
-                                                    local.tee $5
-                                                    local.get $19
-                                                    i32.gt_u
-                                                    br_if 0 (;@24;)
-                                                  end
-                                                end
-                                              end
-                                            end
-                                            local.get $0
-                                            i32.load
-                                            i32.const 32
-                                            i32.and
-                                            i32.eqz
-                                            if ;; label = @21
-                                              local.get $5
-                                              local.get $41
-                                              local.get $5
-                                              i32.sub
-                                              local.get $0
-                                              call $20
-                                              drop
-                                            end
-                                            local.get $6
-                                            i32.const 4
-                                            i32.add
-                                            local.tee $5
-                                            local.get $7
-                                            i32.le_u
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                local.get $5
-                                                local.set $6
-                                                br 2 (;@20;)
-                                              end
-                                            end
-                                          end
-                                          block $label$242 ;; label = @20
-                                            local.get $29
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                local.get $0
-                                                i32.load
-                                                i32.const 32
-                                                i32.and
-                                                br_if 2 (;@20;)
-                                                i32.const 1700
-                                                i32.const 1
-                                                local.get $0
-                                                call $20
-                                                drop
-                                              end
-                                            end
-                                          end
-                                          local.get $1
-                                          i32.const 0
-                                          i32.gt_s
-                                          local.get $5
-                                          local.get $8
-                                          i32.lt_u
-                                          i32.and
-                                          if ;; label = @20
-                                            loop $label$245 ;; label = @21
-                                              local.get $5
-                                              i32.load
-                                              i64.extend_i32_u
-                                              local.get $31
-                                              call $22
-                                              local.tee $7
-                                              local.get $19
-                                              i32.gt_u
-                                              if ;; label = @22
-                                                block ;; label = @23
-                                                  local.get $19
-                                                  i32.const 48
-                                                  local.get $7
-                                                  local.get $27
-                                                  i32.sub
-                                                  call $35
-                                                  drop
-                                                  loop $label$247 ;; label = @24
-                                                    local.get $7
-                                                    i32.const -1
-                                                    i32.add
-                                                    local.tee $7
-                                                    local.get $19
-                                                    i32.gt_u
-                                                    br_if 0 (;@24;)
-                                                  end
-                                                end
-                                              end
-                                              local.get $0
-                                              i32.load
-                                              i32.const 32
-                                              i32.and
-                                              i32.eqz
-                                              if ;; label = @22
-                                                local.get $7
-                                                local.get $1
-                                                i32.const 9
-                                                i32.gt_s
-                                                if (result i32) ;; label = @23
-                                                  i32.const 9
-                                                else
-                                                  local.get $1
-                                                end
-                                                local.get $0
-                                                call $20
-                                                drop
-                                              end
-                                              local.get $1
-                                              i32.const -9
-                                              i32.add
-                                              local.set $7
-                                              local.get $1
-                                              i32.const 9
-                                              i32.gt_s
-                                              local.get $5
-                                              i32.const 4
-                                              i32.add
-                                              local.tee $5
-                                              local.get $8
-                                              i32.lt_u
-                                              i32.and
-                                              if ;; label = @22
-                                                block ;; label = @23
-                                                  local.get $7
-                                                  local.set $1
-                                                  br 2 (;@21;)
-                                                end
-                                              else
-                                                local.get $7
-                                                local.set $1
-                                              end
-                                            end
-                                          end
-                                          local.get $0
-                                          i32.const 48
-                                          local.get $1
-                                          i32.const 9
-                                          i32.add
-                                          i32.const 9
-                                          i32.const 0
-                                          call $24
-                                        end
-                                      else
-                                        block ;; label = @19
-                                          local.get $14
-                                          i32.const 4
-                                          i32.add
-                                          local.set $5
-                                          local.get $22
-                                          i32.eqz
-                                          if ;; label = @20
-                                            local.get $5
-                                            local.set $8
-                                          end
-                                          local.get $1
-                                          i32.const -1
-                                          i32.gt_s
-                                          if ;; label = @20
-                                            block ;; label = @21
-                                              local.get $13
-                                              i32.eqz
-                                              local.set $13
-                                              local.get $14
-                                              local.set $7
-                                              local.get $1
-                                              local.set $5
-                                              loop $label$256 ;; label = @22
-                                                local.get $7
-                                                i32.load
-                                                i64.extend_i32_u
-                                                local.get $31
-                                                call $22
-                                                local.tee $1
-                                                local.get $31
-                                                i32.eq
-                                                if ;; label = @23
-                                                  block ;; label = @24
-                                                    local.get $34
-                                                    i32.const 48
-                                                    i32.store8
-                                                    local.get $34
-                                                    local.set $1
-                                                  end
-                                                end
-                                                block $label$258 ;; label = @23
-                                                  local.get $7
-                                                  local.get $14
-                                                  i32.eq
-                                                  if ;; label = @24
-                                                    block ;; label = @25
-                                                      local.get $0
-                                                      i32.load
-                                                      i32.const 32
-                                                      i32.and
-                                                      i32.eqz
-                                                      if ;; label = @26
-                                                        local.get $1
-                                                        i32.const 1
-                                                        local.get $0
-                                                        call $20
-                                                        drop
-                                                      end
-                                                      local.get $1
-                                                      i32.const 1
-                                                      i32.add
-                                                      local.set $1
-                                                      local.get $13
-                                                      local.get $5
-                                                      i32.const 1
-                                                      i32.lt_s
-                                                      i32.and
-                                                      br_if 2 (;@23;)
-                                                      local.get $0
-                                                      i32.load
-                                                      i32.const 32
-                                                      i32.and
-                                                      br_if 2 (;@23;)
-                                                      i32.const 1700
-                                                      i32.const 1
-                                                      local.get $0
-                                                      call $20
-                                                      drop
-                                                    end
-                                                  else
-                                                    block ;; label = @25
-                                                      local.get $1
-                                                      local.get $19
-                                                      i32.le_u
-                                                      br_if 2 (;@23;)
-                                                      local.get $19
-                                                      i32.const 48
-                                                      local.get $1
-                                                      local.get $43
-                                                      i32.add
-                                                      call $35
-                                                      drop
-                                                      loop $label$262 ;; label = @26
-                                                        local.get $1
-                                                        i32.const -1
-                                                        i32.add
-                                                        local.tee $1
-                                                        local.get $19
-                                                        i32.gt_u
-                                                        br_if 0 (;@26;)
-                                                      end
-                                                    end
-                                                  end
-                                                end
-                                                local.get $41
-                                                local.get $1
-                                                i32.sub
-                                                local.set $6
-                                                local.get $0
-                                                i32.load
-                                                i32.const 32
-                                                i32.and
-                                                i32.eqz
-                                                if ;; label = @23
-                                                  local.get $1
-                                                  local.get $5
-                                                  local.get $6
-                                                  i32.gt_s
-                                                  if (result i32) ;; label = @24
-                                                    local.get $6
-                                                  else
-                                                    local.get $5
-                                                  end
-                                                  local.get $0
-                                                  call $20
-                                                  drop
-                                                end
-                                                local.get $7
-                                                i32.const 4
-                                                i32.add
-                                                local.tee $7
-                                                local.get $8
-                                                i32.lt_u
-                                                local.get $5
-                                                local.get $6
-                                                i32.sub
-                                                local.tee $5
-                                                i32.const -1
-                                                i32.gt_s
-                                                i32.and
-                                                br_if 0 (;@22;)
-                                                local.get $5
-                                                local.set $1
-                                              end
-                                            end
-                                          end
-                                          local.get $0
-                                          i32.const 48
-                                          local.get $1
-                                          i32.const 18
-                                          i32.add
-                                          i32.const 18
-                                          i32.const 0
-                                          call $24
-                                          local.get $0
-                                          i32.load
-                                          i32.const 32
-                                          i32.and
-                                          br_if 2 (;@17;)
-                                          local.get $9
-                                          local.get $28
-                                          local.get $9
-                                          i32.sub
-                                          local.get $0
-                                          call $20
-                                          drop
-                                        end
-                                      end
-                                    end
-                                    local.get $0
-                                    i32.const 32
-                                    local.get $10
-                                    local.get $18
-                                    local.get $12
-                                    i32.const 8192
-                                    i32.xor
-                                    call $24
-                                    local.get $18
-                                    local.get $10
-                                    i32.ge_s
-                                    if ;; label = @17
-                                      local.get $18
-                                      local.set $10
-                                    end
-                                  end
-                                else
-                                  block ;; label = @16
-                                    local.get $0
-                                    i32.const 32
-                                    local.get $10
-                                    local.get $52
-                                    local.get $52
-                                    f64.ne
-                                    i32.const 0
-                                    i32.or
-                                    local.tee $6
-                                    if (result i32) ;; label = @17
-                                      i32.const 0
-                                      local.tee $24
-                                    else
-                                      local.get $24
-                                    end
-                                    i32.const 3
-                                    i32.add
-                                    local.tee $8
-                                    local.get $7
-                                    call $24
-                                    local.get $0
-                                    i32.load
-                                    local.tee $1
-                                    i32.const 32
-                                    i32.and
-                                    i32.eqz
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        local.get $26
-                                        local.get $24
-                                        local.get $0
-                                        call $20
-                                        drop
-                                        local.get $0
-                                        i32.load
-                                        local.set $1
-                                      end
-                                    end
-                                    local.get $9
-                                    i32.const 32
-                                    i32.and
-                                    i32.const 0
-                                    i32.ne
-                                    local.tee $5
-                                    if (result i32) ;; label = @17
-                                      i32.const 1684
-                                    else
-                                      i32.const 1688
-                                    end
-                                    local.set $7
-                                    local.get $5
-                                    if (result i32) ;; label = @17
-                                      i32.const 1692
-                                    else
-                                      i32.const 1696
-                                    end
-                                    local.set $5
-                                    local.get $6
-                                    i32.eqz
-                                    if ;; label = @17
-                                      local.get $7
-                                      local.set $5
-                                    end
-                                    local.get $1
-                                    i32.const 32
-                                    i32.and
-                                    i32.eqz
-                                    if ;; label = @17
-                                      local.get $5
-                                      i32.const 3
-                                      local.get $0
-                                      call $20
-                                      drop
-                                    end
-                                    local.get $0
-                                    i32.const 32
-                                    local.get $10
-                                    local.get $8
-                                    local.get $12
-                                    i32.const 8192
-                                    i32.xor
-                                    call $24
-                                    local.get $8
-                                    local.get $10
-                                    i32.ge_s
-                                    if ;; label = @17
-                                      local.get $8
-                                      local.set $10
-                                    end
-                                  end
-                                end
-                              end
-                              local.get $11
-                              local.set $1
-                              br 9 (;@4;)
-                            end
-                            local.get $5
-                            local.set $7
-                            i32.const 0
-                            local.set $6
-                            i32.const 1648
-                            local.set $8
-                            local.get $21
-                            local.set $5
-                            br 6 (;@6;)
-                          end
-                          local.get $9
-                          i32.const 32
-                          i32.and
-                          local.set $7
-                          local.get $16
-                          i64.load
-                          local.tee $50
-                          i64.const 0
-                          i64.eq
-                          if (result i32) ;; label = @12
-                            block (result i32) ;; label = @13
-                              i64.const 0
-                              local.set $50
-                              local.get $21
-                            end
-                          else
-                            block (result i32) ;; label = @13
-                              local.get $21
-                              local.set $1
-                              loop $label$280 ;; label = @14
-                                local.get $1
-                                i32.const -1
-                                i32.add
-                                local.tee $1
-                                local.get $50
-                                i32.wrap_i64
-                                i32.const 15
-                                i32.and
-                                i32.const 1632
-                                i32.add
-                                i32.load8_u
-                                local.get $7
-                                i32.or
-                                i32.store8
-                                local.get $50
-                                i64.const 4
-                                i64.shr_u
-                                local.tee $50
-                                i64.const 0
-                                i64.ne
-                                br_if 0 (;@14;)
-                              end
-                              local.get $16
-                              i64.load
-                              local.set $50
-                              local.get $1
-                            end
-                          end
-                          local.set $7
-                          local.get $9
-                          i32.const 4
-                          i32.shr_s
-                          i32.const 1648
-                          i32.add
-                          local.set $8
-                          local.get $12
-                          i32.const 8
-                          i32.and
-                          i32.eqz
-                          local.get $50
-                          i64.const 0
-                          i64.eq
-                          i32.or
-                          local.tee $1
-                          if ;; label = @12
-                            i32.const 1648
-                            local.set $8
-                          end
-                          local.get $1
-                          if (result i32) ;; label = @12
-                            i32.const 0
-                          else
-                            i32.const 2
-                          end
-                          local.set $6
-                          br 4 (;@7;)
-                        end
-                        local.get $50
-                        local.get $21
-                        call $22
-                        local.set $7
-                        br 3 (;@7;)
-                      end
-                      local.get $1
-                      i32.const 0
-                      local.get $5
-                      call $16
-                      local.tee $13
-                      i32.eqz
-                      local.set $14
-                      local.get $13
-                      local.get $1
-                      i32.sub
-                      local.set $8
-                      local.get $1
-                      local.get $5
-                      i32.add
-                      local.set $9
-                      local.get $7
-                      local.set $12
-                      local.get $14
-                      if (result i32) ;; label = @10
-                        local.get $5
-                      else
-                        local.get $8
-                      end
-                      local.set $7
-                      i32.const 0
-                      local.set $6
-                      i32.const 1648
-                      local.set $8
-                      local.get $14
-                      if (result i32) ;; label = @10
-                        local.get $9
-                      else
-                        local.get $13
-                      end
-                      local.set $5
-                      br 3 (;@6;)
-                    end
-                    i32.const 0
-                    local.set $1
-                    i32.const 0
-                    local.set $5
-                    local.get $7
-                    local.set $8
-                    loop $label$288 ;; label = @9
-                      block $label$289 ;; label = @10
-                        local.get $8
-                        i32.load
-                        local.tee $9
-                        i32.eqz
-                        br_if 0 (;@10;)
-                        local.get $36
-                        local.get $9
-                        call $25
-                        local.tee $5
-                        i32.const 0
-                        i32.lt_s
-                        local.get $5
-                        local.get $6
-                        local.get $1
-                        i32.sub
-                        i32.gt_u
-                        i32.or
-                        br_if 0 (;@10;)
-                        local.get $8
-                        i32.const 4
-                        i32.add
-                        local.set $8
-                        local.get $6
-                        local.get $5
-                        local.get $1
-                        i32.add
-                        local.tee $1
-                        i32.gt_u
-                        br_if 1 (;@9;)
-                      end
-                    end
-                    local.get $5
-                    i32.const 0
-                    i32.lt_s
-                    if ;; label = @9
-                      block ;; label = @10
-                        i32.const -1
-                        local.set $15
-                        br 5 (;@5;)
-                      end
-                    end
-                    local.get $0
-                    i32.const 32
-                    local.get $10
-                    local.get $1
-                    local.get $12
-                    call $24
-                    local.get $1
-                    if ;; label = @9
-                      block ;; label = @10
-                        i32.const 0
-                        local.set $5
-                        loop $label$292 ;; label = @11
-                          local.get $7
-                          i32.load
-                          local.tee $8
-                          i32.eqz
-                          br_if 3 (;@8;)
-                          local.get $36
-                          local.get $8
-                          call $25
-                          local.tee $8
-                          local.get $5
-                          i32.add
-                          local.tee $5
-                          local.get $1
-                          i32.gt_s
-                          br_if 3 (;@8;)
-                          local.get $0
-                          i32.load
-                          i32.const 32
-                          i32.and
-                          i32.eqz
-                          if ;; label = @12
-                            local.get $36
-                            local.get $8
-                            local.get $0
-                            call $20
-                            drop
-                          end
-                          local.get $7
-                          i32.const 4
-                          i32.add
-                          local.set $7
-                          local.get $5
-                          local.get $1
-                          i32.lt_u
-                          br_if 0 (;@11;)
-                          br 3 (;@8;)
-                        end
-                      end
-                    else
-                      block ;; label = @10
-                        i32.const 0
-                        local.set $1
-                        br 2 (;@8;)
-                      end
-                    end
-                  end
-                  local.get $0
-                  i32.const 32
-                  local.get $10
-                  local.get $1
-                  local.get $12
-                  i32.const 8192
-                  i32.xor
-                  call $24
-                  local.get $10
-                  local.get $1
-                  i32.le_s
-                  if ;; label = @8
-                    local.get $1
-                    local.set $10
-                  end
-                  local.get $11
-                  local.set $1
-                  br 3 (;@4;)
-                end
-                local.get $12
-                i32.const -65537
-                i32.and
-                local.set $1
-                local.get $5
-                i32.const -1
-                i32.gt_s
-                if ;; label = @7
-                  local.get $1
-                  local.set $12
-                end
-                local.get $5
-                local.get $16
-                i64.load
-                i64.const 0
-                i64.ne
-                local.tee $9
-                i32.or
-                if (result i32) ;; label = @7
-                  block (result i32) ;; label = @8
-                    local.get $7
-                    local.set $1
-                    local.get $5
-                    local.get $9
-                    i32.const 1
-                    i32.and
-                    i32.const 1
-                    i32.xor
-                    local.get $38
-                    local.get $7
-                    i32.sub
-                    i32.add
-                    local.tee $7
-                    i32.gt_s
-                    if ;; label = @9
-                      local.get $5
-                      local.set $7
-                    end
-                    local.get $21
-                  end
-                else
-                  block (result i32) ;; label = @8
-                    local.get $21
-                    local.set $1
-                    i32.const 0
-                    local.set $7
-                    local.get $21
-                  end
-                end
-                local.set $5
-              end
-              local.get $0
-              i32.const 32
-              local.get $10
-              local.get $7
-              local.get $5
-              local.get $1
-              i32.sub
-              local.tee $9
-              i32.lt_s
-              if (result i32) ;; label = @6
-                local.get $9
-                local.tee $7
-              else
-                local.get $7
-              end
-              local.get $6
-              i32.add
-              local.tee $5
-              i32.lt_s
-              if (result i32) ;; label = @6
-                local.get $5
-                local.tee $10
-              else
-                local.get $10
-              end
-              local.get $5
-              local.get $12
-              call $24
-              local.get $0
-              i32.load
-              i32.const 32
-              i32.and
-              i32.eqz
-              if ;; label = @6
-                local.get $8
-                local.get $6
-                local.get $0
-                call $20
-                drop
-              end
-              local.get $0
-              i32.const 48
-              local.get $10
-              local.get $5
-              local.get $12
-              i32.const 65536
-              i32.xor
-              call $24
-              local.get $0
-              i32.const 48
-              local.get $7
-              local.get $9
-              i32.const 0
-              call $24
-              local.get $0
-              i32.load
-              i32.const 32
-              i32.and
-              i32.eqz
-              if ;; label = @6
-                local.get $1
-                local.get $9
-                local.get $0
-                call $20
-                drop
-              end
-              local.get $0
-              i32.const 32
-              local.get $10
-              local.get $5
-              local.get $12
-              i32.const 8192
-              i32.xor
-              call $24
-              local.get $11
-              local.set $1
-              br 1 (;@4;)
-            end
-          end
-          br 1 (;@2;)
-        end
-        local.get $0
-        i32.eqz
-        if ;; label = @3
-          local.get $17
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 1
-              local.set $0
-              loop $label$308 ;; label = @6
-                local.get $4
-                local.get $0
-                i32.const 2
-                i32.shl
-                i32.add
-                i32.load
-                local.tee $1
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $3
-                    local.get $0
-                    i32.const 3
-                    i32.shl
-                    i32.add
-                    local.get $1
-                    local.get $2
-                    call $21
-                    local.get $0
-                    i32.const 1
-                    i32.add
-                    local.tee $0
-                    i32.const 10
-                    i32.lt_s
-                    br_if 2 (;@6;)
-                    i32.const 1
-                    local.set $15
-                    br 6 (;@2;)
-                  end
-                end
-              end
-              loop $label$310 ;; label = @6
-                local.get $4
-                local.get $0
-                i32.const 2
-                i32.shl
-                i32.add
-                i32.load
-                if ;; label = @7
-                  block ;; label = @8
-                    i32.const -1
-                    local.set $15
-                    br 6 (;@2;)
-                  end
-                end
-                local.get $0
-                i32.const 1
-                i32.add
-                local.tee $0
-                i32.const 10
-                i32.lt_s
-                br_if 0 (;@6;)
-                i32.const 1
-                local.set $15
-              end
-            end
-          else
-            i32.const 0
-            local.set $15
-          end
-        end
-      end
-      local.get $23
-      global.set $global$1
-      local.get $15
-    end
-  )
-  (func $19 (;32;) (type $1) (param $0 i32) (result i32)
-    i32.const 0
-  )
-  (func $20 (;33;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32)
-    block $label$1 (result i32) ;; label = @1
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          local.get $2
-          i32.const 16
-          i32.add
-          local.tee $4
-          i32.load
-          local.tee $3
-          br_if 0 (;@3;)
-          local.get $2
-          call $29
-          if ;; label = @4
-            i32.const 0
-            local.set $3
-          else
-            block ;; label = @5
-              local.get $4
-              i32.load
-              local.set $3
-              br 2 (;@3;)
-            end
-          end
-          br 1 (;@2;)
-        end
-        local.get $3
-        local.get $2
-        i32.const 20
-        i32.add
-        local.tee $5
-        i32.load
-        local.tee $4
-        i32.sub
-        local.get $1
-        i32.lt_u
-        if ;; label = @3
-          block ;; label = @4
-            local.get $2
-            local.get $0
-            local.get $1
-            local.get $2
-            i32.load offset=36
-            i32.const 3
-            i32.and
-            i32.const 2
-            i32.add
-            call_indirect (type $0)
-            local.set $3
-            br 2 (;@2;)
-          end
-        end
-        block $label$7 (result i32) ;; label = @3
-          local.get $2
-          i32.load8_s offset=75
-          i32.const -1
-          i32.gt_s
-          if (result i32) ;; label = @4
-            block (result i32) ;; label = @5
-              local.get $1
-              local.set $3
-              loop $label$9 ;; label = @6
-                i32.const 0
-                local.get $3
-                i32.eqz
-                br_if 3 (;@3;)
-                drop
-                local.get $0
-                local.get $3
-                i32.const -1
-                i32.add
-                local.tee $6
-                i32.add
-                i32.load8_s
-                i32.const 10
-                i32.ne
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $6
-                    local.set $3
-                    br 2 (;@6;)
-                  end
-                end
-              end
-              local.get $2
-              local.get $0
-              local.get $3
-              local.get $2
-              i32.load offset=36
-              i32.const 3
-              i32.and
-              i32.const 2
-              i32.add
-              call_indirect (type $0)
-              local.get $3
-              i32.lt_u
-              br_if 3 (;@2;)
-              local.get $5
-              i32.load
-              local.set $4
-              local.get $1
-              local.get $3
-              i32.sub
-              local.set $1
-              local.get $0
-              local.get $3
-              i32.add
-              local.set $0
-              local.get $3
-            end
-          else
-            i32.const 0
-          end
-        end
-        local.set $2
-        local.get $4
-        local.get $0
-        local.get $1
-        call $36
-        drop
-        local.get $5
-        local.get $5
-        i32.load
-        local.get $1
-        i32.add
-        i32.store
-        local.get $2
-        local.get $1
-        i32.add
-        local.set $3
-      end
-      local.get $3
-    end
-  )
-  (func $21 (;34;) (type $8) (param $0 i32) (param $1 i32) (param $2 i32)
-    (local $3 i32) (local $4 i64) (local $5 f64)
-    block $label$1 ;; label = @1
-      local.get $1
-      i32.const 20
-      i32.le_u
-      if ;; label = @2
-        block $label$3 ;; label = @3
-          block $label$4 ;; label = @4
-            block $label$5 ;; label = @5
-              block $label$6 ;; label = @6
-                block $label$7 ;; label = @7
-                  block $label$8 ;; label = @8
-                    block $label$9 ;; label = @9
-                      block $label$10 ;; label = @10
-                        block $label$11 ;; label = @11
-                          block $label$12 ;; label = @12
-                            block $label$13 ;; label = @13
-                              local.get $1
-                              i32.const 9
-                              i32.sub
-                              br_table 0 (;@13;) 1 (;@12;) 2 (;@11;) 3 (;@10;) 4 (;@9;) 5 (;@8;) 6 (;@7;) 7 (;@6;) 8 (;@5;) 9 (;@4;) 10 (;@3;)
-                            end
-                            local.get $2
-                            i32.load
-                            i32.const 3
-                            i32.add
-                            i32.const -4
-                            i32.and
-                            local.tee $1
-                            i32.load
-                            local.set $3
-                            local.get $2
-                            local.get $1
-                            i32.const 4
-                            i32.add
-                            i32.store
-                            local.get $0
-                            local.get $3
-                            i32.store
-                            br 11 (;@1;)
-                          end
-                          local.get $2
-                          i32.load
-                          i32.const 3
-                          i32.add
-                          i32.const -4
-                          i32.and
-                          local.tee $1
-                          i32.load
-                          local.set $3
-                          local.get $2
-                          local.get $1
-                          i32.const 4
-                          i32.add
-                          i32.store
-                          local.get $0
-                          local.get $3
-                          i64.extend_i32_s
-                          i64.store
-                          br 10 (;@1;)
-                        end
-                        local.get $2
-                        i32.load
-                        i32.const 3
-                        i32.add
-                        i32.const -4
-                        i32.and
-                        local.tee $1
-                        i32.load
-                        local.set $3
-                        local.get $2
-                        local.get $1
-                        i32.const 4
-                        i32.add
-                        i32.store
-                        local.get $0
-                        local.get $3
-                        i64.extend_i32_u
-                        i64.store
-                        br 9 (;@1;)
-                      end
-                      local.get $2
-                      i32.load
-                      i32.const 7
-                      i32.add
-                      i32.const -8
-                      i32.and
-                      local.tee $1
-                      i64.load
-                      local.set $4
-                      local.get $2
-                      local.get $1
-                      i32.const 8
-                      i32.add
-                      i32.store
-                      local.get $0
-                      local.get $4
-                      i64.store
-                      br 8 (;@1;)
-                    end
-                    local.get $2
-                    i32.load
-                    i32.const 3
-                    i32.add
-                    i32.const -4
-                    i32.and
-                    local.tee $1
-                    i32.load
-                    local.set $3
-                    local.get $2
-                    local.get $1
-                    i32.const 4
-                    i32.add
-                    i32.store
-                    local.get $0
-                    local.get $3
-                    i32.const 65535
-                    i32.and
-                    i32.const 16
-                    i32.shl
-                    i32.const 16
-                    i32.shr_s
-                    i64.extend_i32_s
-                    i64.store
-                    br 7 (;@1;)
-                  end
-                  local.get $2
-                  i32.load
-                  i32.const 3
-                  i32.add
-                  i32.const -4
-                  i32.and
-                  local.tee $1
-                  i32.load
-                  local.set $3
-                  local.get $2
-                  local.get $1
-                  i32.const 4
-                  i32.add
-                  i32.store
-                  local.get $0
-                  local.get $3
-                  i32.const 65535
-                  i32.and
-                  i64.extend_i32_u
-                  i64.store
-                  br 6 (;@1;)
-                end
-                local.get $2
-                i32.load
-                i32.const 3
-                i32.add
-                i32.const -4
-                i32.and
-                local.tee $1
-                i32.load
-                local.set $3
-                local.get $2
-                local.get $1
-                i32.const 4
-                i32.add
-                i32.store
-                local.get $0
-                local.get $3
-                i32.const 255
-                i32.and
-                i32.const 24
-                i32.shl
-                i32.const 24
-                i32.shr_s
-                i64.extend_i32_s
-                i64.store
-                br 5 (;@1;)
-              end
-              local.get $2
-              i32.load
-              i32.const 3
-              i32.add
-              i32.const -4
-              i32.and
-              local.tee $1
-              i32.load
-              local.set $3
-              local.get $2
-              local.get $1
-              i32.const 4
-              i32.add
-              i32.store
-              local.get $0
-              local.get $3
-              i32.const 255
-              i32.and
-              i64.extend_i32_u
-              i64.store
-              br 4 (;@1;)
-            end
-            local.get $2
-            i32.load
-            i32.const 7
-            i32.add
-            i32.const -8
-            i32.and
-            local.tee $1
-            f64.load
-            local.set $5
-            local.get $2
-            local.get $1
-            i32.const 8
-            i32.add
-            i32.store
-            local.get $0
-            local.get $5
-            f64.store
-            br 3 (;@1;)
-          end
-          local.get $2
-          i32.load
-          i32.const 7
-          i32.add
-          i32.const -8
-          i32.and
-          local.tee $1
-          f64.load
-          local.set $5
-          local.get $2
-          local.get $1
-          i32.const 8
-          i32.add
-          i32.store
-          local.get $0
-          local.get $5
-          f64.store
-        end
-      end
-    end
-  )
-  (func $22 (;35;) (type $9) (param $0 i64) (param $1 i32) (result i32)
-    (local $2 i32) (local $3 i32) (local $4 i64)
-    block $label$1 (result i32) ;; label = @1
-      local.get $0
-      i32.wrap_i64
-      local.set $2
-      local.get $0
-      i64.const 4294967295
-      i64.gt_u
-      if ;; label = @2
-        block ;; label = @3
-          loop $label$3 ;; label = @4
-            local.get $1
-            i32.const -1
-            i32.add
-            local.tee $1
-            local.get $0
-            i64.const 10
-            i64.rem_u
-            i64.const 48
-            i64.or
-            i64.store8
-            local.get $0
-            i64.const 10
-            i64.div_u
-            local.set $4
-            local.get $0
-            i64.const 42949672959
-            i64.gt_u
-            if ;; label = @5
-              block ;; label = @6
-                local.get $4
-                local.set $0
-                br 2 (;@4;)
-              end
-            end
-          end
-          local.get $4
-          i32.wrap_i64
-          local.set $2
-        end
-      end
-      local.get $2
-      if ;; label = @2
-        loop $label$6 ;; label = @3
-          local.get $1
-          i32.const -1
-          i32.add
-          local.tee $1
-          local.get $2
-          i32.const 10
-          i32.rem_u
-          i32.const 48
-          i32.or
-          i32.store8
-          local.get $2
-          i32.const 10
-          i32.div_u
-          local.set $3
-          local.get $2
-          i32.const 10
-          i32.ge_u
-          if ;; label = @4
-            block ;; label = @5
-              local.get $3
-              local.set $2
-              br 2 (;@3;)
-            end
-          end
-        end
-      end
-      local.get $1
-    end
-  )
-  (func $23 (;36;) (type $1) (param $0 i32) (result i32)
-    (local $1 i32) (local $2 i32)
-    block $label$1 (result i32) ;; label = @1
-      i32.const 0
-      local.set $1
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          block $label$4 ;; label = @4
-            loop $label$5 ;; label = @5
-              local.get $1
-              i32.const 1702
-              i32.add
-              i32.load8_u
-              local.get $0
-              i32.eq
-              br_if 1 (;@4;)
-              local.get $1
-              i32.const 1
-              i32.add
-              local.tee $1
-              i32.const 87
-              i32.ne
-              br_if 0 (;@5;)
-              i32.const 87
-              local.set $1
-              i32.const 1790
-              local.set $0
-              br 2 (;@3;)
-            end
-          end
-          local.get $1
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 1790
-              local.set $0
-              br 2 (;@3;)
-            end
-          else
-            i32.const 1790
-            local.set $0
-          end
-          br 1 (;@2;)
-        end
-        loop $label$8 ;; label = @3
-          local.get $0
-          local.set $2
-          loop $label$9 ;; label = @4
-            local.get $2
-            i32.const 1
-            i32.add
-            local.set $0
-            local.get $2
-            i32.load8_s
-            if ;; label = @5
-              block ;; label = @6
-                local.get $0
-                local.set $2
-                br 2 (;@4;)
-              end
-            end
-          end
-          local.get $1
-          i32.const -1
-          i32.add
-          local.tee $1
-          br_if 0 (;@3;)
-        end
-      end
-      local.get $0
-    end
-  )
-  (func $24 (;37;) (type $10) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32)
-    (local $5 i32) (local $6 i32) (local $7 i32)
-    block $label$1 ;; label = @1
-      global.get $global$1
-      local.set $7
-      global.get $global$1
-      i32.const 256
-      i32.add
-      global.set $global$1
-      local.get $7
-      local.set $6
-      block $label$2 ;; label = @2
-        local.get $2
-        local.get $3
-        i32.gt_s
-        local.get $4
-        i32.const 73728
-        i32.and
-        i32.eqz
-        i32.and
-        if ;; label = @3
-          block ;; label = @4
-            local.get $6
-            local.get $1
-            local.get $2
-            local.get $3
-            i32.sub
-            local.tee $5
-            i32.const 256
-            i32.gt_u
-            if (result i32) ;; label = @5
-              i32.const 256
-            else
-              local.get $5
-            end
-            call $35
-            drop
-            local.get $0
-            i32.load
-            local.tee $1
-            i32.const 32
-            i32.and
-            i32.eqz
-            local.set $4
-            local.get $5
-            i32.const 255
-            i32.gt_u
-            if ;; label = @5
-              block ;; label = @6
-                loop $label$7 ;; label = @7
-                  local.get $4
-                  if ;; label = @8
-                    block ;; label = @9
-                      local.get $6
-                      i32.const 256
-                      local.get $0
-                      call $20
-                      drop
-                      local.get $0
-                      i32.load
-                      local.set $1
-                    end
-                  end
-                  local.get $1
-                  i32.const 32
-                  i32.and
-                  i32.eqz
-                  local.set $4
-                  local.get $5
-                  i32.const -256
-                  i32.add
-                  local.tee $5
-                  i32.const 255
-                  i32.gt_u
-                  br_if 0 (;@7;)
-                end
-                local.get $4
-                i32.eqz
-                br_if 4 (;@2;)
-                local.get $2
-                local.get $3
-                i32.sub
-                i32.const 255
-                i32.and
-                local.set $5
-              end
-            else
-              local.get $4
-              i32.eqz
-              br_if 3 (;@2;)
-            end
-            local.get $6
-            local.get $5
-            local.get $0
-            call $20
-            drop
-          end
-        end
-      end
-      local.get $7
-      global.set $global$1
-    end
-  )
-  (func $25 (;38;) (type $4) (param $0 i32) (param $1 i32) (result i32)
-    local.get $0
-    if (result i32) ;; label = @1
-      local.get $0
-      local.get $1
-      i32.const 0
-      call $28
-    else
-      i32.const 0
-    end
-  )
-  (func $26 (;39;) (type $11) (param $0 f64) (param $1 i32) (result f64)
-    local.get $0
-    local.get $1
-    call $27
-  )
-  (func $27 (;40;) (type $11) (param $0 f64) (param $1 i32) (result f64)
-    (local $2 i64) (local $3 i64)
-    block $label$1 (result f64) ;; label = @1
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          block $label$4 ;; label = @4
-            block $label$5 ;; label = @5
-              local.get $0
-              i64.reinterpret_f64
-              local.tee $2
-              i64.const 52
-              i64.shr_u
-              local.tee $3
-              i32.wrap_i64
-              i32.const 65535
-              i32.and
-              i32.const 2047
-              i32.and
-              i32.const 16
-              i32.shl
-              i32.const 16
-              i32.shr_s
-              i32.const 0
-              i32.sub
-              br_table 0 (;@5;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 1 (;@4;) 2 (;@3;)
-            end
-            local.get $1
-            local.get $0
-            f64.const 0x0p+0 (;=0;)
-            f64.ne
-            if (result i32) ;; label = @5
-              block (result i32) ;; label = @6
-                local.get $0
-                f64.const 0x1p+64 (;=18446744073709552000;)
-                f64.mul
-                local.get $1
-                call $27
-                local.set $0
-                local.get $1
-                i32.load
-                i32.const -64
-                i32.add
-              end
-            else
-              i32.const 0
-            end
-            i32.store
-            br 2 (;@2;)
-          end
-          br 1 (;@2;)
-        end
-        local.get $1
-        local.get $3
-        i32.wrap_i64
-        i32.const 2047
-        i32.and
-        i32.const -1022
-        i32.add
-        i32.store
-        local.get $2
-        i64.const -9218868437227405313
-        i64.and
-        i64.const 4602678819172646912
-        i64.or
-        f64.reinterpret_i64
-        local.set $0
-      end
-      local.get $0
-    end
-  )
-  (func $28 (;41;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    block $label$1 (result i32) ;; label = @1
-      local.get $0
-      if (result i32) ;; label = @2
-        block (result i32) ;; label = @3
-          local.get $1
-          i32.const 128
-          i32.lt_u
-          if ;; label = @4
-            block ;; label = @5
-              local.get $0
-              local.get $1
-              i32.store8
-              i32.const 1
-              br 4 (;@1;)
-            end
-          end
-          local.get $1
-          i32.const 2048
-          i32.lt_u
-          if ;; label = @4
-            block ;; label = @5
-              local.get $0
-              local.get $1
-              i32.const 6
-              i32.shr_u
-              i32.const 192
-              i32.or
-              i32.store8
-              local.get $0
-              local.get $1
-              i32.const 63
-              i32.and
-              i32.const 128
-              i32.or
-              i32.store8 offset=1
-              i32.const 2
-              br 4 (;@1;)
-            end
-          end
-          local.get $1
-          i32.const 55296
-          i32.lt_u
-          local.get $1
-          i32.const -8192
-          i32.and
-          i32.const 57344
-          i32.eq
-          i32.or
-          if ;; label = @4
-            block ;; label = @5
-              local.get $0
-              local.get $1
-              i32.const 12
-              i32.shr_u
-              i32.const 224
-              i32.or
-              i32.store8
-              local.get $0
-              local.get $1
-              i32.const 6
-              i32.shr_u
-              i32.const 63
-              i32.and
-              i32.const 128
-              i32.or
-              i32.store8 offset=1
-              local.get $0
-              local.get $1
-              i32.const 63
-              i32.and
-              i32.const 128
-              i32.or
-              i32.store8 offset=2
-              i32.const 3
-              br 4 (;@1;)
-            end
-          end
-          local.get $1
-          i32.const -65536
-          i32.add
-          i32.const 1048576
-          i32.lt_u
-          if (result i32) ;; label = @4
-            block (result i32) ;; label = @5
-              local.get $0
-              local.get $1
-              i32.const 18
-              i32.shr_u
-              i32.const 240
-              i32.or
-              i32.store8
-              local.get $0
-              local.get $1
-              i32.const 12
-              i32.shr_u
-              i32.const 63
-              i32.and
-              i32.const 128
-              i32.or
-              i32.store8 offset=1
-              local.get $0
-              local.get $1
-              i32.const 6
-              i32.shr_u
-              i32.const 63
-              i32.and
-              i32.const 128
-              i32.or
-              i32.store8 offset=2
-              local.get $0
-              local.get $1
-              i32.const 63
-              i32.and
-              i32.const 128
-              i32.or
-              i32.store8 offset=3
-              i32.const 4
-            end
-          else
-            block (result i32) ;; label = @5
-              call $11
-              i32.const 84
-              i32.store
-              i32.const -1
-            end
-          end
-        end
-      else
-        i32.const 1
-      end
-    end
-  )
-  (func $29 (;42;) (type $1) (param $0 i32) (result i32)
-    (local $1 i32) (local $2 i32)
-    block $label$1 (result i32) ;; label = @1
-      local.get $0
-      i32.const 74
-      i32.add
-      local.tee $2
-      i32.load8_s
-      local.set $1
-      local.get $2
-      local.get $1
-      i32.const 255
-      i32.add
-      local.get $1
-      i32.or
-      i32.store8
-      local.get $0
-      i32.load
-      local.tee $1
-      i32.const 8
-      i32.and
-      if (result i32) ;; label = @2
-        block (result i32) ;; label = @3
-          local.get $0
-          local.get $1
-          i32.const 32
-          i32.or
-          i32.store
-          i32.const -1
-        end
-      else
-        block (result i32) ;; label = @3
-          local.get $0
-          i32.const 0
-          i32.store offset=8
-          local.get $0
-          i32.const 0
-          i32.store offset=4
-          local.get $0
-          local.get $0
-          i32.load offset=44
-          local.tee $1
-          i32.store offset=28
-          local.get $0
-          local.get $1
-          i32.store offset=20
-          local.get $0
-          local.get $1
-          local.get $0
-          i32.load offset=48
-          i32.add
-          i32.store offset=16
-          i32.const 0
-        end
-      end
-      local.tee $0
-    end
-  )
-  (func $30 (;43;) (type $4) (param $0 i32) (param $1 i32) (result i32)
-    (local $2 i32) (local $3 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $2
-      global.get $global$1
-      i32.const 16
-      i32.add
-      global.set $global$1
-      local.get $2
-      local.tee $3
-      local.get $1
-      i32.store
-      i32.const 1024
-      i32.load
-      local.get $0
-      local.get $3
-      call $17
-      local.set $0
-      local.get $2
-      global.set $global$1
-      local.get $0
-    end
-  )
-  (func $31 (;44;) (type $1) (param $0 i32) (result i32)
-    (local $1 i32) (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32) (local $15 i32) (local $16 i32) (local $17 i32) (local $18 i32) (local $19 i32) (local $20 i32) (local $21 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$1
-      local.set $14
-      global.get $global$1
-      i32.const 16
-      i32.add
-      global.set $global$1
-      local.get $14
-      local.set $18
-      block $label$2 ;; label = @2
-        local.get $0
-        i32.const 245
-        i32.lt_u
-        if ;; label = @3
-          block ;; label = @4
-            local.get $0
-            i32.const 11
-            i32.add
-            i32.const -8
-            i32.and
-            local.set $3
-            i32.const 3644
-            i32.load
-            local.tee $8
-            local.get $0
-            i32.const 11
-            i32.lt_u
-            if (result i32) ;; label = @5
-              i32.const 16
-              local.tee $3
-            else
-              local.get $3
-            end
-            i32.const 3
-            i32.shr_u
-            local.tee $2
-            i32.shr_u
-            local.tee $0
-            i32.const 3
-            i32.and
-            if ;; label = @5
-              block ;; label = @6
-                local.get $0
-                i32.const 1
-                i32.and
-                i32.const 1
-                i32.xor
-                local.get $2
-                i32.add
-                local.tee $5
-                i32.const 1
-                i32.shl
-                i32.const 2
-                i32.shl
-                i32.const 3684
-                i32.add
-                local.tee $2
-                i32.const 8
-                i32.add
-                local.tee $3
-                i32.load
-                local.tee $7
-                i32.const 8
-                i32.add
-                local.tee $1
-                i32.load
-                local.set $4
-                local.get $2
-                local.get $4
-                i32.eq
-                if ;; label = @7
-                  i32.const 3644
-                  local.get $8
-                  i32.const 1
-                  local.get $5
-                  i32.shl
-                  i32.const -1
-                  i32.xor
-                  i32.and
-                  i32.store
-                else
-                  block ;; label = @8
-                    local.get $4
-                    i32.const 3660
-                    i32.load
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                    local.get $4
-                    i32.const 12
-                    i32.add
-                    local.tee $0
-                    i32.load
-                    local.get $7
-                    i32.eq
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $0
-                        local.get $2
-                        i32.store
-                        local.get $3
-                        local.get $4
-                        i32.store
-                      end
-                    else
-                      call $fimport$10
-                    end
-                  end
-                end
-                local.get $7
-                local.get $5
-                i32.const 3
-                i32.shl
-                local.tee $0
-                i32.const 3
-                i32.or
-                i32.store offset=4
-                local.get $7
-                local.get $0
-                i32.add
-                i32.const 4
-                i32.add
-                local.tee $0
-                local.get $0
-                i32.load
-                i32.const 1
-                i32.or
-                i32.store
-                local.get $14
-                global.set $global$1
-                local.get $1
-                return
-              end
-            end
-            local.get $3
-            i32.const 3652
-            i32.load
-            local.tee $16
-            i32.gt_u
-            if ;; label = @5
-              block ;; label = @6
-                local.get $0
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $0
-                    local.get $2
-                    i32.shl
-                    i32.const 2
-                    local.get $2
-                    i32.shl
-                    local.tee $0
-                    i32.const 0
-                    local.get $0
-                    i32.sub
-                    i32.or
-                    i32.and
-                    local.tee $0
-                    i32.const 0
-                    local.get $0
-                    i32.sub
-                    i32.and
-                    i32.const -1
-                    i32.add
-                    local.tee $0
-                    i32.const 12
-                    i32.shr_u
-                    i32.const 16
-                    i32.and
-                    local.set $5
-                    local.get $0
-                    local.get $5
-                    i32.shr_u
-                    local.tee $2
-                    i32.const 5
-                    i32.shr_u
-                    i32.const 8
-                    i32.and
-                    local.tee $0
-                    local.get $5
-                    i32.or
-                    local.get $2
-                    local.get $0
-                    i32.shr_u
-                    local.tee $2
-                    i32.const 2
-                    i32.shr_u
-                    i32.const 4
-                    i32.and
-                    local.tee $0
-                    i32.or
-                    local.get $2
-                    local.get $0
-                    i32.shr_u
-                    local.tee $2
-                    i32.const 1
-                    i32.shr_u
-                    i32.const 2
-                    i32.and
-                    local.tee $0
-                    i32.or
-                    local.get $2
-                    local.get $0
-                    i32.shr_u
-                    local.tee $2
-                    i32.const 1
-                    i32.shr_u
-                    i32.const 1
-                    i32.and
-                    local.tee $0
-                    i32.or
-                    local.get $2
-                    local.get $0
-                    i32.shr_u
-                    i32.add
-                    local.tee $11
-                    i32.const 1
-                    i32.shl
-                    i32.const 2
-                    i32.shl
-                    i32.const 3684
-                    i32.add
-                    local.tee $4
-                    i32.const 8
-                    i32.add
-                    local.tee $2
-                    i32.load
-                    local.tee $9
-                    i32.const 8
-                    i32.add
-                    local.tee $5
-                    i32.load
-                    local.set $12
-                    local.get $4
-                    local.get $12
-                    i32.eq
-                    if ;; label = @9
-                      i32.const 3644
-                      local.get $8
-                      i32.const 1
-                      local.get $11
-                      i32.shl
-                      i32.const -1
-                      i32.xor
-                      i32.and
-                      local.tee $7
-                      i32.store
-                    else
-                      block ;; label = @10
-                        local.get $12
-                        i32.const 3660
-                        i32.load
-                        i32.lt_u
-                        if ;; label = @11
-                          call $fimport$10
-                        end
-                        local.get $12
-                        i32.const 12
-                        i32.add
-                        local.tee $0
-                        i32.load
-                        local.get $9
-                        i32.eq
-                        if ;; label = @11
-                          block ;; label = @12
-                            local.get $0
-                            local.get $4
-                            i32.store
-                            local.get $2
-                            local.get $12
-                            i32.store
-                            local.get $8
-                            local.set $7
-                          end
-                        else
-                          call $fimport$10
-                        end
-                      end
-                    end
-                    local.get $9
-                    local.get $3
-                    i32.const 3
-                    i32.or
-                    i32.store offset=4
-                    local.get $9
-                    local.get $3
-                    i32.add
-                    local.tee $4
-                    local.get $11
-                    i32.const 3
-                    i32.shl
-                    local.get $3
-                    i32.sub
-                    local.tee $11
-                    i32.const 1
-                    i32.or
-                    i32.store offset=4
-                    local.get $4
-                    local.get $11
-                    i32.add
-                    local.get $11
-                    i32.store
-                    local.get $16
-                    if ;; label = @9
-                      block ;; label = @10
-                        i32.const 3664
-                        i32.load
-                        local.set $9
-                        local.get $16
-                        i32.const 3
-                        i32.shr_u
-                        local.tee $0
-                        i32.const 1
-                        i32.shl
-                        i32.const 2
-                        i32.shl
-                        i32.const 3684
-                        i32.add
-                        local.set $2
-                        local.get $7
-                        i32.const 1
-                        local.get $0
-                        i32.shl
-                        local.tee $0
-                        i32.and
-                        if ;; label = @11
-                          local.get $2
-                          i32.const 8
-                          i32.add
-                          local.tee $3
-                          i32.load
-                          local.tee $0
-                          i32.const 3660
-                          i32.load
-                          i32.lt_u
-                          if ;; label = @12
-                            call $fimport$10
-                          else
-                            block ;; label = @13
-                              local.get $3
-                              local.set $6
-                              local.get $0
-                              local.set $1
-                            end
-                          end
-                        else
-                          block ;; label = @12
-                            i32.const 3644
-                            local.get $7
-                            local.get $0
-                            i32.or
-                            i32.store
-                            local.get $2
-                            i32.const 8
-                            i32.add
-                            local.set $6
-                            local.get $2
-                            local.set $1
-                          end
-                        end
-                        local.get $6
-                        local.get $9
-                        i32.store
-                        local.get $1
-                        local.get $9
-                        i32.store offset=12
-                        local.get $9
-                        local.get $1
-                        i32.store offset=8
-                        local.get $9
-                        local.get $2
-                        i32.store offset=12
-                      end
-                    end
-                    i32.const 3652
-                    local.get $11
-                    i32.store
-                    i32.const 3664
-                    local.get $4
-                    i32.store
-                    local.get $14
-                    global.set $global$1
-                    local.get $5
-                    return
-                  end
-                end
-                i32.const 3648
-                i32.load
-                local.tee $6
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $6
-                    i32.const 0
-                    local.get $6
-                    i32.sub
-                    i32.and
-                    i32.const -1
-                    i32.add
-                    local.tee $0
-                    i32.const 12
-                    i32.shr_u
-                    i32.const 16
-                    i32.and
-                    local.set $2
-                    local.get $0
-                    local.get $2
-                    i32.shr_u
-                    local.tee $1
-                    i32.const 5
-                    i32.shr_u
-                    i32.const 8
-                    i32.and
-                    local.tee $0
-                    local.get $2
-                    i32.or
-                    local.get $1
-                    local.get $0
-                    i32.shr_u
-                    local.tee $1
-                    i32.const 2
-                    i32.shr_u
-                    i32.const 4
-                    i32.and
-                    local.tee $0
-                    i32.or
-                    local.get $1
-                    local.get $0
-                    i32.shr_u
-                    local.tee $1
-                    i32.const 1
-                    i32.shr_u
-                    i32.const 2
-                    i32.and
-                    local.tee $0
-                    i32.or
-                    local.get $1
-                    local.get $0
-                    i32.shr_u
-                    local.tee $1
-                    i32.const 1
-                    i32.shr_u
-                    i32.const 1
-                    i32.and
-                    local.tee $0
-                    i32.or
-                    local.get $1
-                    local.get $0
-                    i32.shr_u
-                    i32.add
-                    i32.const 2
-                    i32.shl
-                    i32.const 3948
-                    i32.add
-                    i32.load
-                    local.tee $2
-                    i32.load offset=4
-                    i32.const -8
-                    i32.and
-                    local.get $3
-                    i32.sub
-                    local.set $9
-                    local.get $2
-                    local.set $1
-                    loop $label$25 ;; label = @9
-                      block $label$26 ;; label = @10
-                        local.get $1
-                        i32.load offset=16
-                        local.tee $0
-                        i32.eqz
-                        if ;; label = @11
-                          local.get $1
-                          i32.load offset=20
-                          local.tee $0
-                          i32.eqz
-                          br_if 1 (;@10;)
-                        end
-                        local.get $0
-                        i32.load offset=4
-                        i32.const -8
-                        i32.and
-                        local.get $3
-                        i32.sub
-                        local.tee $1
-                        local.get $9
-                        i32.lt_u
-                        local.tee $7
-                        if ;; label = @11
-                          local.get $1
-                          local.set $9
-                        end
-                        local.get $0
-                        local.set $1
-                        local.get $7
-                        if ;; label = @11
-                          local.get $0
-                          local.set $2
-                        end
-                        br 1 (;@9;)
-                      end
-                    end
-                    local.get $2
-                    i32.const 3660
-                    i32.load
-                    local.tee $12
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                    local.get $2
-                    local.get $2
-                    local.get $3
-                    i32.add
-                    local.tee $13
-                    i32.ge_u
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                    local.get $2
-                    i32.load offset=24
-                    local.set $15
-                    block $label$32 ;; label = @9
-                      local.get $2
-                      i32.load offset=12
-                      local.tee $0
-                      local.get $2
-                      i32.eq
-                      if ;; label = @10
-                        block ;; label = @11
-                          local.get $2
-                          i32.const 20
-                          i32.add
-                          local.tee $1
-                          i32.load
-                          local.tee $0
-                          i32.eqz
-                          if ;; label = @12
-                            local.get $2
-                            i32.const 16
-                            i32.add
-                            local.tee $1
-                            i32.load
-                            local.tee $0
-                            i32.eqz
-                            if ;; label = @13
-                              block ;; label = @14
-                                i32.const 0
-                                local.set $4
-                                br 5 (;@9;)
-                              end
-                            end
-                          end
-                          loop $label$36 ;; label = @12
-                            local.get $0
-                            i32.const 20
-                            i32.add
-                            local.tee $11
-                            i32.load
-                            local.tee $7
-                            if ;; label = @13
-                              block ;; label = @14
-                                local.get $7
-                                local.set $0
-                                local.get $11
-                                local.set $1
-                                br 2 (;@12;)
-                              end
-                            end
-                            local.get $0
-                            i32.const 16
-                            i32.add
-                            local.tee $11
-                            i32.load
-                            local.tee $7
-                            if ;; label = @13
-                              block ;; label = @14
-                                local.get $7
-                                local.set $0
-                                local.get $11
-                                local.set $1
-                                br 2 (;@12;)
-                              end
-                            end
-                          end
-                          local.get $1
-                          local.get $12
-                          i32.lt_u
-                          if ;; label = @12
-                            call $fimport$10
-                          else
-                            block ;; label = @13
-                              local.get $1
-                              i32.const 0
-                              i32.store
-                              local.get $0
-                              local.set $4
-                            end
-                          end
-                        end
-                      else
-                        block ;; label = @11
-                          local.get $2
-                          i32.load offset=8
-                          local.tee $11
-                          local.get $12
-                          i32.lt_u
-                          if ;; label = @12
-                            call $fimport$10
-                          end
-                          local.get $11
-                          i32.const 12
-                          i32.add
-                          local.tee $7
-                          i32.load
-                          local.get $2
-                          i32.ne
-                          if ;; label = @12
-                            call $fimport$10
-                          end
-                          local.get $0
-                          i32.const 8
-                          i32.add
-                          local.tee $1
-                          i32.load
-                          local.get $2
-                          i32.eq
-                          if ;; label = @12
-                            block ;; label = @13
-                              local.get $7
-                              local.get $0
-                              i32.store
-                              local.get $1
-                              local.get $11
-                              i32.store
-                              local.get $0
-                              local.set $4
-                            end
-                          else
-                            call $fimport$10
-                          end
-                        end
-                      end
-                    end
-                    block $label$46 ;; label = @9
-                      local.get $15
-                      if ;; label = @10
-                        block ;; label = @11
-                          local.get $2
-                          local.get $2
-                          i32.load offset=28
-                          local.tee $1
-                          i32.const 2
-                          i32.shl
-                          i32.const 3948
-                          i32.add
-                          local.tee $0
-                          i32.load
-                          i32.eq
-                          if ;; label = @12
-                            block ;; label = @13
-                              local.get $0
-                              local.get $4
-                              i32.store
-                              local.get $4
-                              i32.eqz
-                              if ;; label = @14
-                                block ;; label = @15
-                                  i32.const 3648
-                                  local.get $6
-                                  i32.const 1
-                                  local.get $1
-                                  i32.shl
-                                  i32.const -1
-                                  i32.xor
-                                  i32.and
-                                  i32.store
-                                  br 6 (;@9;)
-                                end
-                              end
-                            end
-                          else
-                            block ;; label = @13
-                              local.get $15
-                              i32.const 3660
-                              i32.load
-                              i32.lt_u
-                              if ;; label = @14
-                                call $fimport$10
-                              end
-                              local.get $15
-                              i32.const 16
-                              i32.add
-                              local.tee $0
-                              i32.load
-                              local.get $2
-                              i32.eq
-                              if ;; label = @14
-                                local.get $0
-                                local.get $4
-                                i32.store
-                              else
-                                local.get $15
-                                local.get $4
-                                i32.store offset=20
-                              end
-                              local.get $4
-                              i32.eqz
-                              br_if 4 (;@9;)
-                            end
-                          end
-                          local.get $4
-                          i32.const 3660
-                          i32.load
-                          local.tee $0
-                          i32.lt_u
-                          if ;; label = @12
-                            call $fimport$10
-                          end
-                          local.get $4
-                          local.get $15
-                          i32.store offset=24
-                          local.get $2
-                          i32.load offset=16
-                          local.tee $1
-                          if ;; label = @12
-                            local.get $1
-                            local.get $0
-                            i32.lt_u
-                            if ;; label = @13
-                              call $fimport$10
-                            else
-                              block ;; label = @14
-                                local.get $4
-                                local.get $1
-                                i32.store offset=16
-                                local.get $1
-                                local.get $4
-                                i32.store offset=24
-                              end
-                            end
-                          end
-                          local.get $2
-                          i32.load offset=20
-                          local.tee $0
-                          if ;; label = @12
-                            local.get $0
-                            i32.const 3660
-                            i32.load
-                            i32.lt_u
-                            if ;; label = @13
-                              call $fimport$10
-                            else
-                              block ;; label = @14
-                                local.get $4
-                                local.get $0
-                                i32.store offset=20
-                                local.get $0
-                                local.get $4
-                                i32.store offset=24
-                              end
-                            end
-                          end
-                        end
-                      end
-                    end
-                    local.get $9
-                    i32.const 16
-                    i32.lt_u
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $2
-                        local.get $9
-                        local.get $3
-                        i32.add
-                        local.tee $0
-                        i32.const 3
-                        i32.or
-                        i32.store offset=4
-                        local.get $2
-                        local.get $0
-                        i32.add
-                        i32.const 4
-                        i32.add
-                        local.tee $0
-                        local.get $0
-                        i32.load
-                        i32.const 1
-                        i32.or
-                        i32.store
-                      end
-                    else
-                      block ;; label = @10
-                        local.get $2
-                        local.get $3
-                        i32.const 3
-                        i32.or
-                        i32.store offset=4
-                        local.get $13
-                        local.get $9
-                        i32.const 1
-                        i32.or
-                        i32.store offset=4
-                        local.get $13
-                        local.get $9
-                        i32.add
-                        local.get $9
-                        i32.store
-                        local.get $16
-                        if ;; label = @11
-                          block ;; label = @12
-                            i32.const 3664
-                            i32.load
-                            local.set $7
-                            local.get $16
-                            i32.const 3
-                            i32.shr_u
-                            local.tee $0
-                            i32.const 1
-                            i32.shl
-                            i32.const 2
-                            i32.shl
-                            i32.const 3684
-                            i32.add
-                            local.set $3
-                            local.get $8
-                            i32.const 1
-                            local.get $0
-                            i32.shl
-                            local.tee $0
-                            i32.and
-                            if ;; label = @13
-                              local.get $3
-                              i32.const 8
-                              i32.add
-                              local.tee $1
-                              i32.load
-                              local.tee $0
-                              i32.const 3660
-                              i32.load
-                              i32.lt_u
-                              if ;; label = @14
-                                call $fimport$10
-                              else
-                                block ;; label = @15
-                                  local.get $1
-                                  local.set $10
-                                  local.get $0
-                                  local.set $5
-                                end
-                              end
-                            else
-                              block ;; label = @14
-                                i32.const 3644
-                                local.get $8
-                                local.get $0
-                                i32.or
-                                i32.store
-                                local.get $3
-                                i32.const 8
-                                i32.add
-                                local.set $10
-                                local.get $3
-                                local.set $5
-                              end
-                            end
-                            local.get $10
-                            local.get $7
-                            i32.store
-                            local.get $5
-                            local.get $7
-                            i32.store offset=12
-                            local.get $7
-                            local.get $5
-                            i32.store offset=8
-                            local.get $7
-                            local.get $3
-                            i32.store offset=12
-                          end
-                        end
-                        i32.const 3652
-                        local.get $9
-                        i32.store
-                        i32.const 3664
-                        local.get $13
-                        i32.store
-                      end
-                    end
-                    local.get $14
-                    global.set $global$1
-                    local.get $2
-                    i32.const 8
-                    i32.add
-                    return
-                  end
-                else
-                  local.get $3
-                  local.set $0
-                end
-              end
-            else
-              local.get $3
-              local.set $0
-            end
-          end
-        else
-          local.get $0
-          i32.const -65
-          i32.gt_u
-          if ;; label = @4
-            i32.const -1
-            local.set $0
-          else
-            block ;; label = @5
-              local.get $0
-              i32.const 11
-              i32.add
-              local.tee $0
-              i32.const -8
-              i32.and
-              local.set $7
-              i32.const 3648
-              i32.load
-              local.tee $5
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $0
-                  i32.const 8
-                  i32.shr_u
-                  local.tee $0
-                  if (result i32) ;; label = @8
-                    local.get $7
-                    i32.const 16777215
-                    i32.gt_u
-                    if (result i32) ;; label = @9
-                      i32.const 31
-                    else
-                      local.get $7
-                      i32.const 14
-                      local.get $0
-                      local.get $0
-                      i32.const 1048320
-                      i32.add
-                      i32.const 16
-                      i32.shr_u
-                      i32.const 8
-                      i32.and
-                      local.tee $3
-                      i32.shl
-                      local.tee $1
-                      i32.const 520192
-                      i32.add
-                      i32.const 16
-                      i32.shr_u
-                      i32.const 4
-                      i32.and
-                      local.tee $0
-                      local.get $3
-                      i32.or
-                      local.get $1
-                      local.get $0
-                      i32.shl
-                      local.tee $1
-                      i32.const 245760
-                      i32.add
-                      i32.const 16
-                      i32.shr_u
-                      i32.const 2
-                      i32.and
-                      local.tee $0
-                      i32.or
-                      i32.sub
-                      local.get $1
-                      local.get $0
-                      i32.shl
-                      i32.const 15
-                      i32.shr_u
-                      i32.add
-                      local.tee $0
-                      i32.const 7
-                      i32.add
-                      i32.shr_u
-                      i32.const 1
-                      i32.and
-                      local.get $0
-                      i32.const 1
-                      i32.shl
-                      i32.or
-                    end
-                  else
-                    i32.const 0
-                  end
-                  local.set $17
-                  i32.const 0
-                  local.get $7
-                  i32.sub
-                  local.set $3
-                  block $label$78 ;; label = @8
-                    block $label$79 ;; label = @9
-                      block $label$80 ;; label = @10
-                        local.get $17
-                        i32.const 2
-                        i32.shl
-                        i32.const 3948
-                        i32.add
-                        i32.load
-                        local.tee $1
-                        if ;; label = @11
-                          block ;; label = @12
-                            i32.const 25
-                            local.get $17
-                            i32.const 1
-                            i32.shr_u
-                            i32.sub
-                            local.set $0
-                            i32.const 0
-                            local.set $4
-                            local.get $7
-                            local.get $17
-                            i32.const 31
-                            i32.eq
-                            if (result i32) ;; label = @13
-                              i32.const 0
-                            else
-                              local.get $0
-                            end
-                            i32.shl
-                            local.set $10
-                            i32.const 0
-                            local.set $0
-                            loop $label$84 ;; label = @13
-                              local.get $1
-                              i32.load offset=4
-                              i32.const -8
-                              i32.and
-                              local.get $7
-                              i32.sub
-                              local.tee $6
-                              local.get $3
-                              i32.lt_u
-                              if ;; label = @14
-                                local.get $6
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $6
-                                    local.set $3
-                                    local.get $1
-                                    local.set $0
-                                  end
-                                else
-                                  block ;; label = @16
-                                    i32.const 0
-                                    local.set $3
-                                    local.get $1
-                                    local.set $0
-                                    br 7 (;@9;)
-                                  end
-                                end
-                              end
-                              local.get $1
-                              i32.load offset=20
-                              local.tee $19
-                              i32.eqz
-                              local.get $19
-                              local.get $1
-                              i32.const 16
-                              i32.add
-                              local.get $10
-                              i32.const 31
-                              i32.shr_u
-                              i32.const 2
-                              i32.shl
-                              i32.add
-                              i32.load
-                              local.tee $6
-                              i32.eq
-                              i32.or
-                              if (result i32) ;; label = @14
-                                local.get $4
-                              else
-                                local.get $19
-                              end
-                              local.set $1
-                              local.get $10
-                              local.get $6
-                              i32.eqz
-                              local.tee $4
-                              i32.const 1
-                              i32.and
-                              i32.const 1
-                              i32.xor
-                              i32.shl
-                              local.set $10
-                              local.get $4
-                              if ;; label = @14
-                                block ;; label = @15
-                                  local.get $1
-                                  local.set $4
-                                  local.get $0
-                                  local.set $1
-                                  br 5 (;@10;)
-                                end
-                              else
-                                block ;; label = @15
-                                  local.get $1
-                                  local.set $4
-                                  local.get $6
-                                  local.set $1
-                                  br 2 (;@13;)
-                                end
-                              end
-                            end
-                          end
-                        else
-                          block ;; label = @12
-                            i32.const 0
-                            local.set $4
-                            i32.const 0
-                            local.set $1
-                          end
-                        end
-                      end
-                      local.get $4
-                      i32.eqz
-                      local.get $1
-                      i32.eqz
-                      i32.and
-                      if (result i32) ;; label = @10
-                        block (result i32) ;; label = @11
-                          local.get $5
-                          i32.const 2
-                          local.get $17
-                          i32.shl
-                          local.tee $0
-                          i32.const 0
-                          local.get $0
-                          i32.sub
-                          i32.or
-                          i32.and
-                          local.tee $0
-                          i32.eqz
-                          if ;; label = @12
-                            block ;; label = @13
-                              local.get $7
-                              local.set $0
-                              br 11 (;@2;)
-                            end
-                          end
-                          local.get $0
-                          i32.const 0
-                          local.get $0
-                          i32.sub
-                          i32.and
-                          i32.const -1
-                          i32.add
-                          local.tee $0
-                          i32.const 12
-                          i32.shr_u
-                          i32.const 16
-                          i32.and
-                          local.set $10
-                          local.get $0
-                          local.get $10
-                          i32.shr_u
-                          local.tee $4
-                          i32.const 5
-                          i32.shr_u
-                          i32.const 8
-                          i32.and
-                          local.tee $0
-                          local.get $10
-                          i32.or
-                          local.get $4
-                          local.get $0
-                          i32.shr_u
-                          local.tee $4
-                          i32.const 2
-                          i32.shr_u
-                          i32.const 4
-                          i32.and
-                          local.tee $0
-                          i32.or
-                          local.get $4
-                          local.get $0
-                          i32.shr_u
-                          local.tee $4
-                          i32.const 1
-                          i32.shr_u
-                          i32.const 2
-                          i32.and
-                          local.tee $0
-                          i32.or
-                          local.get $4
-                          local.get $0
-                          i32.shr_u
-                          local.tee $4
-                          i32.const 1
-                          i32.shr_u
-                          i32.const 1
-                          i32.and
-                          local.tee $0
-                          i32.or
-                          local.get $4
-                          local.get $0
-                          i32.shr_u
-                          i32.add
-                          i32.const 2
-                          i32.shl
-                          i32.const 3948
-                          i32.add
-                          i32.load
-                        end
-                      else
-                        local.get $4
-                      end
-                      local.tee $0
-                      br_if 0 (;@9;)
-                      local.get $1
-                      local.set $4
-                      br 1 (;@8;)
-                    end
-                    loop $label$96 ;; label = @9
-                      local.get $0
-                      i32.load offset=4
-                      i32.const -8
-                      i32.and
-                      local.get $7
-                      i32.sub
-                      local.tee $4
-                      local.get $3
-                      i32.lt_u
-                      local.tee $10
-                      if ;; label = @10
-                        local.get $4
-                        local.set $3
-                      end
-                      local.get $10
-                      if ;; label = @10
-                        local.get $0
-                        local.set $1
-                      end
-                      local.get $0
-                      i32.load offset=16
-                      local.tee $4
-                      if ;; label = @10
-                        block ;; label = @11
-                          local.get $4
-                          local.set $0
-                          br 2 (;@9;)
-                        end
-                      end
-                      local.get $0
-                      i32.load offset=20
-                      local.tee $0
-                      br_if 0 (;@9;)
-                      local.get $1
-                      local.set $4
-                    end
-                  end
-                  local.get $4
-                  if ;; label = @8
-                    local.get $3
-                    i32.const 3652
-                    i32.load
-                    local.get $7
-                    i32.sub
-                    i32.lt_u
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $4
-                        i32.const 3660
-                        i32.load
-                        local.tee $12
-                        i32.lt_u
-                        if ;; label = @11
-                          call $fimport$10
-                        end
-                        local.get $4
-                        local.get $4
-                        local.get $7
-                        i32.add
-                        local.tee $6
-                        i32.ge_u
-                        if ;; label = @11
-                          call $fimport$10
-                        end
-                        local.get $4
-                        i32.load offset=24
-                        local.set $10
-                        block $label$104 ;; label = @11
-                          local.get $4
-                          i32.load offset=12
-                          local.tee $0
-                          local.get $4
-                          i32.eq
-                          if ;; label = @12
-                            block ;; label = @13
-                              local.get $4
-                              i32.const 20
-                              i32.add
-                              local.tee $1
-                              i32.load
-                              local.tee $0
-                              i32.eqz
-                              if ;; label = @14
-                                local.get $4
-                                i32.const 16
-                                i32.add
-                                local.tee $1
-                                i32.load
-                                local.tee $0
-                                i32.eqz
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    i32.const 0
-                                    local.set $13
-                                    br 5 (;@11;)
-                                  end
-                                end
-                              end
-                              loop $label$108 ;; label = @14
-                                local.get $0
-                                i32.const 20
-                                i32.add
-                                local.tee $9
-                                i32.load
-                                local.tee $11
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $11
-                                    local.set $0
-                                    local.get $9
-                                    local.set $1
-                                    br 2 (;@14;)
-                                  end
-                                end
-                                local.get $0
-                                i32.const 16
-                                i32.add
-                                local.tee $9
-                                i32.load
-                                local.tee $11
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $11
-                                    local.set $0
-                                    local.get $9
-                                    local.set $1
-                                    br 2 (;@14;)
-                                  end
-                                end
-                              end
-                              local.get $1
-                              local.get $12
-                              i32.lt_u
-                              if ;; label = @14
-                                call $fimport$10
-                              else
-                                block ;; label = @15
-                                  local.get $1
-                                  i32.const 0
-                                  i32.store
-                                  local.get $0
-                                  local.set $13
-                                end
-                              end
-                            end
-                          else
-                            block ;; label = @13
-                              local.get $4
-                              i32.load offset=8
-                              local.tee $9
-                              local.get $12
-                              i32.lt_u
-                              if ;; label = @14
-                                call $fimport$10
-                              end
-                              local.get $9
-                              i32.const 12
-                              i32.add
-                              local.tee $11
-                              i32.load
-                              local.get $4
-                              i32.ne
-                              if ;; label = @14
-                                call $fimport$10
-                              end
-                              local.get $0
-                              i32.const 8
-                              i32.add
-                              local.tee $1
-                              i32.load
-                              local.get $4
-                              i32.eq
-                              if ;; label = @14
-                                block ;; label = @15
-                                  local.get $11
-                                  local.get $0
-                                  i32.store
-                                  local.get $1
-                                  local.get $9
-                                  i32.store
-                                  local.get $0
-                                  local.set $13
-                                end
-                              else
-                                call $fimport$10
-                              end
-                            end
-                          end
-                        end
-                        block $label$118 ;; label = @11
-                          local.get $10
-                          if ;; label = @12
-                            block ;; label = @13
-                              local.get $4
-                              local.get $4
-                              i32.load offset=28
-                              local.tee $1
-                              i32.const 2
-                              i32.shl
-                              i32.const 3948
-                              i32.add
-                              local.tee $0
-                              i32.load
-                              i32.eq
-                              if ;; label = @14
-                                block ;; label = @15
-                                  local.get $0
-                                  local.get $13
-                                  i32.store
-                                  local.get $13
-                                  i32.eqz
-                                  if ;; label = @16
-                                    block ;; label = @17
-                                      i32.const 3648
-                                      local.get $5
-                                      i32.const 1
-                                      local.get $1
-                                      i32.shl
-                                      i32.const -1
-                                      i32.xor
-                                      i32.and
-                                      local.tee $2
-                                      i32.store
-                                      br 6 (;@11;)
-                                    end
-                                  end
-                                end
-                              else
-                                block ;; label = @15
-                                  local.get $10
-                                  i32.const 3660
-                                  i32.load
-                                  i32.lt_u
-                                  if ;; label = @16
-                                    call $fimport$10
-                                  end
-                                  local.get $10
-                                  i32.const 16
-                                  i32.add
-                                  local.tee $0
-                                  i32.load
-                                  local.get $4
-                                  i32.eq
-                                  if ;; label = @16
-                                    local.get $0
-                                    local.get $13
-                                    i32.store
-                                  else
-                                    local.get $10
-                                    local.get $13
-                                    i32.store offset=20
-                                  end
-                                  local.get $13
-                                  i32.eqz
-                                  if ;; label = @16
-                                    block ;; label = @17
-                                      local.get $5
-                                      local.set $2
-                                      br 6 (;@11;)
-                                    end
-                                  end
-                                end
-                              end
-                              local.get $13
-                              i32.const 3660
-                              i32.load
-                              local.tee $0
-                              i32.lt_u
-                              if ;; label = @14
-                                call $fimport$10
-                              end
-                              local.get $13
-                              local.get $10
-                              i32.store offset=24
-                              local.get $4
-                              i32.load offset=16
-                              local.tee $1
-                              if ;; label = @14
-                                local.get $1
-                                local.get $0
-                                i32.lt_u
-                                if ;; label = @15
-                                  call $fimport$10
-                                else
-                                  block ;; label = @16
-                                    local.get $13
-                                    local.get $1
-                                    i32.store offset=16
-                                    local.get $1
-                                    local.get $13
-                                    i32.store offset=24
-                                  end
-                                end
-                              end
-                              local.get $4
-                              i32.load offset=20
-                              local.tee $0
-                              if ;; label = @14
-                                local.get $0
-                                i32.const 3660
-                                i32.load
-                                i32.lt_u
-                                if ;; label = @15
-                                  call $fimport$10
-                                else
-                                  block ;; label = @16
-                                    local.get $13
-                                    local.get $0
-                                    i32.store offset=20
-                                    local.get $0
-                                    local.get $13
-                                    i32.store offset=24
-                                    local.get $5
-                                    local.set $2
-                                  end
-                                end
-                              else
-                                local.get $5
-                                local.set $2
-                              end
-                            end
-                          else
-                            local.get $5
-                            local.set $2
-                          end
-                        end
-                        block $label$136 ;; label = @11
-                          local.get $3
-                          i32.const 16
-                          i32.lt_u
-                          if ;; label = @12
-                            block ;; label = @13
-                              local.get $4
-                              local.get $3
-                              local.get $7
-                              i32.add
-                              local.tee $0
-                              i32.const 3
-                              i32.or
-                              i32.store offset=4
-                              local.get $4
-                              local.get $0
-                              i32.add
-                              i32.const 4
-                              i32.add
-                              local.tee $0
-                              local.get $0
-                              i32.load
-                              i32.const 1
-                              i32.or
-                              i32.store
-                            end
-                          else
-                            block ;; label = @13
-                              local.get $4
-                              local.get $7
-                              i32.const 3
-                              i32.or
-                              i32.store offset=4
-                              local.get $6
-                              local.get $3
-                              i32.const 1
-                              i32.or
-                              i32.store offset=4
-                              local.get $6
-                              local.get $3
-                              i32.add
-                              local.get $3
-                              i32.store
-                              local.get $3
-                              i32.const 3
-                              i32.shr_u
-                              local.set $0
-                              local.get $3
-                              i32.const 256
-                              i32.lt_u
-                              if ;; label = @14
-                                block ;; label = @15
-                                  local.get $0
-                                  i32.const 1
-                                  i32.shl
-                                  i32.const 2
-                                  i32.shl
-                                  i32.const 3684
-                                  i32.add
-                                  local.set $3
-                                  i32.const 3644
-                                  i32.load
-                                  local.tee $1
-                                  i32.const 1
-                                  local.get $0
-                                  i32.shl
-                                  local.tee $0
-                                  i32.and
-                                  if ;; label = @16
-                                    local.get $3
-                                    i32.const 8
-                                    i32.add
-                                    local.tee $1
-                                    i32.load
-                                    local.tee $0
-                                    i32.const 3660
-                                    i32.load
-                                    i32.lt_u
-                                    if ;; label = @17
-                                      call $fimport$10
-                                    else
-                                      block ;; label = @18
-                                        local.get $1
-                                        local.set $16
-                                        local.get $0
-                                        local.set $8
-                                      end
-                                    end
-                                  else
-                                    block ;; label = @17
-                                      i32.const 3644
-                                      local.get $1
-                                      local.get $0
-                                      i32.or
-                                      i32.store
-                                      local.get $3
-                                      i32.const 8
-                                      i32.add
-                                      local.set $16
-                                      local.get $3
-                                      local.set $8
-                                    end
-                                  end
-                                  local.get $16
-                                  local.get $6
-                                  i32.store
-                                  local.get $8
-                                  local.get $6
-                                  i32.store offset=12
-                                  local.get $6
-                                  local.get $8
-                                  i32.store offset=8
-                                  local.get $6
-                                  local.get $3
-                                  i32.store offset=12
-                                  br 4 (;@11;)
-                                end
-                              end
-                              local.get $3
-                              i32.const 8
-                              i32.shr_u
-                              local.tee $0
-                              if (result i32) ;; label = @14
-                                local.get $3
-                                i32.const 16777215
-                                i32.gt_u
-                                if (result i32) ;; label = @15
-                                  i32.const 31
-                                else
-                                  local.get $3
-                                  i32.const 14
-                                  local.get $0
-                                  local.get $0
-                                  i32.const 1048320
-                                  i32.add
-                                  i32.const 16
-                                  i32.shr_u
-                                  i32.const 8
-                                  i32.and
-                                  local.tee $5
-                                  i32.shl
-                                  local.tee $1
-                                  i32.const 520192
-                                  i32.add
-                                  i32.const 16
-                                  i32.shr_u
-                                  i32.const 4
-                                  i32.and
-                                  local.tee $0
-                                  local.get $5
-                                  i32.or
-                                  local.get $1
-                                  local.get $0
-                                  i32.shl
-                                  local.tee $1
-                                  i32.const 245760
-                                  i32.add
-                                  i32.const 16
-                                  i32.shr_u
-                                  i32.const 2
-                                  i32.and
-                                  local.tee $0
-                                  i32.or
-                                  i32.sub
-                                  local.get $1
-                                  local.get $0
-                                  i32.shl
-                                  i32.const 15
-                                  i32.shr_u
-                                  i32.add
-                                  local.tee $0
-                                  i32.const 7
-                                  i32.add
-                                  i32.shr_u
-                                  i32.const 1
-                                  i32.and
-                                  local.get $0
-                                  i32.const 1
-                                  i32.shl
-                                  i32.or
-                                end
-                              else
-                                i32.const 0
-                              end
-                              local.tee $5
-                              i32.const 2
-                              i32.shl
-                              i32.const 3948
-                              i32.add
-                              local.set $1
-                              local.get $6
-                              local.get $5
-                              i32.store offset=28
-                              local.get $6
-                              i32.const 16
-                              i32.add
-                              local.tee $0
-                              i32.const 0
-                              i32.store offset=4
-                              local.get $0
-                              i32.const 0
-                              i32.store
-                              local.get $2
-                              i32.const 1
-                              local.get $5
-                              i32.shl
-                              local.tee $0
-                              i32.and
-                              i32.eqz
-                              if ;; label = @14
-                                block ;; label = @15
-                                  i32.const 3648
-                                  local.get $2
-                                  local.get $0
-                                  i32.or
-                                  i32.store
-                                  local.get $1
-                                  local.get $6
-                                  i32.store
-                                  local.get $6
-                                  local.get $1
-                                  i32.store offset=24
-                                  local.get $6
-                                  local.get $6
-                                  i32.store offset=12
-                                  local.get $6
-                                  local.get $6
-                                  i32.store offset=8
-                                  br 4 (;@11;)
-                                end
-                              end
-                              local.get $1
-                              i32.load
-                              local.set $0
-                              i32.const 25
-                              local.get $5
-                              i32.const 1
-                              i32.shr_u
-                              i32.sub
-                              local.set $1
-                              local.get $3
-                              local.get $5
-                              i32.const 31
-                              i32.eq
-                              if (result i32) ;; label = @14
-                                i32.const 0
-                              else
-                                local.get $1
-                              end
-                              i32.shl
-                              local.set $5
-                              block $label$151 ;; label = @14
-                                block $label$152 ;; label = @15
-                                  block $label$153 ;; label = @16
-                                    loop $label$154 ;; label = @17
-                                      local.get $0
-                                      i32.load offset=4
-                                      i32.const -8
-                                      i32.and
-                                      local.get $3
-                                      i32.eq
-                                      br_if 2 (;@15;)
-                                      local.get $5
-                                      i32.const 1
-                                      i32.shl
-                                      local.set $2
-                                      local.get $0
-                                      i32.const 16
-                                      i32.add
-                                      local.get $5
-                                      i32.const 31
-                                      i32.shr_u
-                                      i32.const 2
-                                      i32.shl
-                                      i32.add
-                                      local.tee $5
-                                      i32.load
-                                      local.tee $1
-                                      i32.eqz
-                                      br_if 1 (;@16;)
-                                      local.get $2
-                                      local.set $5
-                                      local.get $1
-                                      local.set $0
-                                      br 0 (;@17;)
-                                    end
-                                  end
-                                  local.get $5
-                                  i32.const 3660
-                                  i32.load
-                                  i32.lt_u
-                                  if ;; label = @16
-                                    call $fimport$10
-                                  else
-                                    block ;; label = @17
-                                      local.get $5
-                                      local.get $6
-                                      i32.store
-                                      local.get $6
-                                      local.get $0
-                                      i32.store offset=24
-                                      local.get $6
-                                      local.get $6
-                                      i32.store offset=12
-                                      local.get $6
-                                      local.get $6
-                                      i32.store offset=8
-                                      br 6 (;@11;)
-                                    end
-                                  end
-                                  br 1 (;@14;)
-                                end
-                                local.get $0
-                                i32.const 8
-                                i32.add
-                                local.tee $3
-                                i32.load
-                                local.tee $2
-                                i32.const 3660
-                                i32.load
-                                local.tee $1
-                                i32.ge_u
-                                local.get $0
-                                local.get $1
-                                i32.ge_u
-                                i32.and
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $2
-                                    local.get $6
-                                    i32.store offset=12
-                                    local.get $3
-                                    local.get $6
-                                    i32.store
-                                    local.get $6
-                                    local.get $2
-                                    i32.store offset=8
-                                    local.get $6
-                                    local.get $0
-                                    i32.store offset=12
-                                    local.get $6
-                                    i32.const 0
-                                    i32.store offset=24
-                                  end
-                                else
-                                  call $fimport$10
-                                end
-                              end
-                            end
-                          end
-                        end
-                        local.get $14
-                        global.set $global$1
-                        local.get $4
-                        i32.const 8
-                        i32.add
-                        return
-                      end
-                    else
-                      local.get $7
-                      local.set $0
-                    end
-                  else
-                    local.get $7
-                    local.set $0
-                  end
-                end
-              else
-                local.get $7
-                local.set $0
-              end
-            end
-          end
-        end
-      end
-      i32.const 3652
-      i32.load
-      local.tee $1
-      local.get $0
-      i32.ge_u
-      if ;; label = @2
-        block ;; label = @3
-          i32.const 3664
-          i32.load
-          local.set $2
-          local.get $1
-          local.get $0
-          i32.sub
-          local.tee $3
-          i32.const 15
-          i32.gt_u
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 3664
-              local.get $2
-              local.get $0
-              i32.add
-              local.tee $1
-              i32.store
-              i32.const 3652
-              local.get $3
-              i32.store
-              local.get $1
-              local.get $3
-              i32.const 1
-              i32.or
-              i32.store offset=4
-              local.get $1
-              local.get $3
-              i32.add
-              local.get $3
-              i32.store
-              local.get $2
-              local.get $0
-              i32.const 3
-              i32.or
-              i32.store offset=4
-            end
-          else
-            block ;; label = @5
-              i32.const 3652
-              i32.const 0
-              i32.store
-              i32.const 3664
-              i32.const 0
-              i32.store
-              local.get $2
-              local.get $1
-              i32.const 3
-              i32.or
-              i32.store offset=4
-              local.get $2
-              local.get $1
-              i32.add
-              i32.const 4
-              i32.add
-              local.tee $0
-              local.get $0
-              i32.load
-              i32.const 1
-              i32.or
-              i32.store
-            end
-          end
-          local.get $14
-          global.set $global$1
-          local.get $2
-          i32.const 8
-          i32.add
-          return
-        end
-      end
-      i32.const 3656
-      i32.load
-      local.tee $10
-      local.get $0
-      i32.gt_u
-      if ;; label = @2
-        block ;; label = @3
-          i32.const 3656
-          local.get $10
-          local.get $0
-          i32.sub
-          local.tee $3
-          i32.store
-          i32.const 3668
-          i32.const 3668
-          i32.load
-          local.tee $2
-          local.get $0
-          i32.add
-          local.tee $1
-          i32.store
-          local.get $1
-          local.get $3
-          i32.const 1
-          i32.or
-          i32.store offset=4
-          local.get $2
-          local.get $0
-          i32.const 3
-          i32.or
-          i32.store offset=4
-          local.get $14
-          global.set $global$1
-          local.get $2
-          i32.const 8
-          i32.add
-          return
-        end
-      end
-      i32.const 4116
-      i32.load
-      if (result i32) ;; label = @2
-        i32.const 4124
-        i32.load
-      else
-        block (result i32) ;; label = @3
-          i32.const 4124
-          i32.const 4096
-          i32.store
-          i32.const 4120
-          i32.const 4096
-          i32.store
-          i32.const 4128
-          i32.const -1
-          i32.store
-          i32.const 4132
-          i32.const -1
-          i32.store
-          i32.const 4136
-          i32.const 0
-          i32.store
-          i32.const 4088
-          i32.const 0
-          i32.store
-          local.get $18
-          local.get $18
-          i32.const -16
-          i32.and
-          i32.const 1431655768
-          i32.xor
-          local.tee $1
-          i32.store
-          i32.const 4116
-          local.get $1
-          i32.store
-          i32.const 4096
-        end
-      end
-      local.tee $1
-      local.get $0
-      i32.const 47
-      i32.add
-      local.tee $13
-      i32.add
-      local.tee $8
-      i32.const 0
-      local.get $1
-      i32.sub
-      local.tee $4
-      i32.and
-      local.tee $6
-      local.get $0
-      i32.le_u
-      if ;; label = @2
-        block ;; label = @3
-          local.get $14
-          global.set $global$1
-          i32.const 0
-          return
-        end
-      end
-      i32.const 4084
-      i32.load
-      local.tee $2
-      if ;; label = @2
-        i32.const 4076
-        i32.load
-        local.tee $3
-        local.get $6
-        i32.add
-        local.tee $1
-        local.get $3
-        i32.le_u
-        local.get $1
-        local.get $2
-        i32.gt_u
-        i32.or
-        if ;; label = @3
-          block ;; label = @4
-            local.get $14
-            global.set $global$1
-            i32.const 0
-            return
-          end
-        end
-      end
-      local.get $0
-      i32.const 48
-      i32.add
-      local.set $7
-      block $label$171 ;; label = @2
-        block $label$172 ;; label = @3
-          i32.const 4088
-          i32.load
-          i32.const 4
-          i32.and
-          i32.eqz
-          if ;; label = @4
-            block ;; label = @5
-              block $label$174 ;; label = @6
-                block $label$175 ;; label = @7
-                  block $label$176 ;; label = @8
-                    i32.const 3668
-                    i32.load
-                    local.tee $3
-                    i32.eqz
-                    br_if 0 (;@8;)
-                    i32.const 4092
-                    local.set $2
-                    loop $label$177 ;; label = @9
-                      block $label$178 ;; label = @10
-                        local.get $2
-                        i32.load
-                        local.tee $1
-                        local.get $3
-                        i32.le_u
-                        if ;; label = @11
-                          local.get $1
-                          local.get $2
-                          i32.const 4
-                          i32.add
-                          local.tee $5
-                          i32.load
-                          i32.add
-                          local.get $3
-                          i32.gt_u
-                          br_if 1 (;@10;)
-                        end
-                        local.get $2
-                        i32.load offset=8
-                        local.tee $1
-                        i32.eqz
-                        br_if 2 (;@8;)
-                        local.get $1
-                        local.set $2
-                        br 1 (;@9;)
-                      end
-                    end
-                    local.get $8
-                    local.get $10
-                    i32.sub
-                    local.get $4
-                    i32.and
-                    local.tee $3
-                    i32.const 2147483647
-                    i32.lt_u
-                    if ;; label = @9
-                      local.get $3
-                      call $34
-                      local.tee $1
-                      local.get $2
-                      i32.load
-                      local.get $5
-                      i32.load
-                      i32.add
-                      i32.eq
-                      if ;; label = @10
-                        local.get $1
-                        i32.const -1
-                        i32.ne
-                        br_if 7 (;@3;)
-                      else
-                        block ;; label = @11
-                          local.get $1
-                          local.set $2
-                          local.get $3
-                          local.set $1
-                          br 4 (;@7;)
-                        end
-                      end
-                    end
-                    br 2 (;@6;)
-                  end
-                  i32.const 0
-                  call $34
-                  local.tee $1
-                  i32.const -1
-                  i32.ne
-                  if ;; label = @8
-                    block ;; label = @9
-                      i32.const 4120
-                      i32.load
-                      local.tee $2
-                      i32.const -1
-                      i32.add
-                      local.tee $5
-                      local.get $1
-                      local.tee $3
-                      i32.add
-                      i32.const 0
-                      local.get $2
-                      i32.sub
-                      i32.and
-                      local.get $3
-                      i32.sub
-                      local.set $2
-                      local.get $5
-                      local.get $3
-                      i32.and
-                      if (result i32) ;; label = @10
-                        local.get $2
-                      else
-                        i32.const 0
-                      end
-                      local.get $6
-                      i32.add
-                      local.tee $3
-                      i32.const 4076
-                      i32.load
-                      local.tee $5
-                      i32.add
-                      local.set $4
-                      local.get $3
-                      local.get $0
-                      i32.gt_u
-                      local.get $3
-                      i32.const 2147483647
-                      i32.lt_u
-                      i32.and
-                      if ;; label = @10
-                        block ;; label = @11
-                          i32.const 4084
-                          i32.load
-                          local.tee $2
-                          if ;; label = @12
-                            local.get $4
-                            local.get $5
-                            i32.le_u
-                            local.get $4
-                            local.get $2
-                            i32.gt_u
-                            i32.or
-                            br_if 6 (;@6;)
-                          end
-                          local.get $3
-                          call $34
-                          local.tee $2
-                          local.get $1
-                          i32.eq
-                          br_if 8 (;@3;)
-                          local.get $3
-                          local.set $1
-                          br 4 (;@7;)
-                        end
-                      end
-                    end
-                  end
-                  br 1 (;@6;)
-                end
-                i32.const 0
-                local.get $1
-                i32.sub
-                local.set $5
-                local.get $7
-                local.get $1
-                i32.gt_u
-                local.get $1
-                i32.const 2147483647
-                i32.lt_u
-                local.get $2
-                i32.const -1
-                i32.ne
-                i32.and
-                i32.and
-                if ;; label = @7
-                  local.get $13
-                  local.get $1
-                  i32.sub
-                  i32.const 4124
-                  i32.load
-                  local.tee $3
-                  i32.add
-                  i32.const 0
-                  local.get $3
-                  i32.sub
-                  i32.and
-                  local.tee $3
-                  i32.const 2147483647
-                  i32.lt_u
-                  if ;; label = @8
-                    local.get $3
-                    call $34
-                    i32.const -1
-                    i32.eq
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $5
-                        call $34
-                        drop
-                        br 4 (;@6;)
-                      end
-                    else
-                      local.get $3
-                      local.get $1
-                      i32.add
-                      local.set $3
-                    end
-                  else
-                    local.get $1
-                    local.set $3
-                  end
-                else
-                  local.get $1
-                  local.set $3
-                end
-                local.get $2
-                i32.const -1
-                i32.ne
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $2
-                    local.set $1
-                    br 5 (;@3;)
-                  end
-                end
-              end
-              i32.const 4088
-              i32.const 4088
-              i32.load
-              i32.const 4
-              i32.or
-              i32.store
-            end
-          end
-          local.get $6
-          i32.const 2147483647
-          i32.lt_u
-          if ;; label = @4
-            local.get $6
-            call $34
-            local.tee $1
-            i32.const 0
-            call $34
-            local.tee $3
-            i32.lt_u
-            local.get $1
-            i32.const -1
-            i32.ne
-            local.get $3
-            i32.const -1
-            i32.ne
-            i32.and
-            i32.and
-            if ;; label = @5
-              local.get $3
-              local.get $1
-              i32.sub
-              local.tee $3
-              local.get $0
-              i32.const 40
-              i32.add
-              i32.gt_u
-              br_if 2 (;@3;)
-            end
-          end
-          br 1 (;@2;)
-        end
-        i32.const 4076
-        i32.const 4076
-        i32.load
-        local.get $3
-        i32.add
-        local.tee $2
-        i32.store
-        local.get $2
-        i32.const 4080
-        i32.load
-        i32.gt_u
-        if ;; label = @3
-          i32.const 4080
-          local.get $2
-          i32.store
-        end
-        block $label$198 ;; label = @3
-          i32.const 3668
-          i32.load
-          local.tee $8
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 4092
-              local.set $2
-              block $label$200 ;; label = @6
-                block $label$201 ;; label = @7
-                  loop $label$202 ;; label = @8
-                    local.get $1
-                    local.get $2
-                    i32.load
-                    local.tee $4
-                    local.get $2
-                    i32.const 4
-                    i32.add
-                    local.tee $7
-                    i32.load
-                    local.tee $5
-                    i32.add
-                    i32.eq
-                    br_if 1 (;@7;)
-                    local.get $2
-                    i32.load offset=8
-                    local.tee $2
-                    br_if 0 (;@8;)
-                  end
-                  br 1 (;@6;)
-                end
-                local.get $2
-                i32.load offset=12
-                i32.const 8
-                i32.and
-                i32.eqz
-                if ;; label = @7
-                  local.get $8
-                  local.get $1
-                  i32.lt_u
-                  local.get $8
-                  local.get $4
-                  i32.ge_u
-                  i32.and
-                  if ;; label = @8
-                    block ;; label = @9
-                      local.get $7
-                      local.get $5
-                      local.get $3
-                      i32.add
-                      i32.store
-                      i32.const 3656
-                      i32.load
-                      local.set $5
-                      i32.const 0
-                      local.get $8
-                      i32.const 8
-                      i32.add
-                      local.tee $2
-                      i32.sub
-                      i32.const 7
-                      i32.and
-                      local.set $1
-                      i32.const 3668
-                      local.get $8
-                      local.get $2
-                      i32.const 7
-                      i32.and
-                      if (result i32) ;; label = @10
-                        local.get $1
-                      else
-                        i32.const 0
-                        local.tee $1
-                      end
-                      i32.add
-                      local.tee $2
-                      i32.store
-                      i32.const 3656
-                      local.get $3
-                      local.get $1
-                      i32.sub
-                      local.get $5
-                      i32.add
-                      local.tee $1
-                      i32.store
-                      local.get $2
-                      local.get $1
-                      i32.const 1
-                      i32.or
-                      i32.store offset=4
-                      local.get $2
-                      local.get $1
-                      i32.add
-                      i32.const 40
-                      i32.store offset=4
-                      i32.const 3672
-                      i32.const 4132
-                      i32.load
-                      i32.store
-                      br 6 (;@3;)
-                    end
-                  end
-                end
-              end
-              local.get $1
-              i32.const 3660
-              i32.load
-              local.tee $2
-              i32.lt_u
-              if ;; label = @6
-                block ;; label = @7
-                  i32.const 3660
-                  local.get $1
-                  i32.store
-                  local.get $1
-                  local.set $2
-                end
-              end
-              local.get $1
-              local.get $3
-              i32.add
-              local.set $10
-              i32.const 4092
-              local.set $5
-              block $label$208 ;; label = @6
-                block $label$209 ;; label = @7
-                  loop $label$210 ;; label = @8
-                    local.get $5
-                    i32.load
-                    local.get $10
-                    i32.eq
-                    br_if 1 (;@7;)
-                    local.get $5
-                    i32.load offset=8
-                    local.tee $5
-                    br_if 0 (;@8;)
-                    i32.const 4092
-                    local.set $5
-                  end
-                  br 1 (;@6;)
-                end
-                local.get $5
-                i32.load offset=12
-                i32.const 8
-                i32.and
-                if ;; label = @7
-                  i32.const 4092
-                  local.set $5
-                else
-                  block ;; label = @8
-                    local.get $5
-                    local.get $1
-                    i32.store
-                    local.get $5
-                    i32.const 4
-                    i32.add
-                    local.tee $5
-                    local.get $5
-                    i32.load
-                    local.get $3
-                    i32.add
-                    i32.store
-                    i32.const 0
-                    local.get $1
-                    i32.const 8
-                    i32.add
-                    local.tee $4
-                    i32.sub
-                    i32.const 7
-                    i32.and
-                    local.set $7
-                    i32.const 0
-                    local.get $10
-                    i32.const 8
-                    i32.add
-                    local.tee $5
-                    i32.sub
-                    i32.const 7
-                    i32.and
-                    local.set $3
-                    local.get $1
-                    local.get $4
-                    i32.const 7
-                    i32.and
-                    if (result i32) ;; label = @9
-                      local.get $7
-                    else
-                      i32.const 0
-                    end
-                    i32.add
-                    local.tee $13
-                    local.get $0
-                    i32.add
-                    local.set $6
-                    local.get $10
-                    local.get $5
-                    i32.const 7
-                    i32.and
-                    if (result i32) ;; label = @9
-                      local.get $3
-                    else
-                      i32.const 0
-                    end
-                    i32.add
-                    local.tee $4
-                    local.get $13
-                    i32.sub
-                    local.get $0
-                    i32.sub
-                    local.set $7
-                    local.get $13
-                    local.get $0
-                    i32.const 3
-                    i32.or
-                    i32.store offset=4
-                    block $label$217 ;; label = @9
-                      local.get $4
-                      local.get $8
-                      i32.eq
-                      if ;; label = @10
-                        block ;; label = @11
-                          i32.const 3656
-                          i32.const 3656
-                          i32.load
-                          local.get $7
-                          i32.add
-                          local.tee $0
-                          i32.store
-                          i32.const 3668
-                          local.get $6
-                          i32.store
-                          local.get $6
-                          local.get $0
-                          i32.const 1
-                          i32.or
-                          i32.store offset=4
-                        end
-                      else
-                        block ;; label = @11
-                          local.get $4
-                          i32.const 3664
-                          i32.load
-                          i32.eq
-                          if ;; label = @12
-                            block ;; label = @13
-                              i32.const 3652
-                              i32.const 3652
-                              i32.load
-                              local.get $7
-                              i32.add
-                              local.tee $0
-                              i32.store
-                              i32.const 3664
-                              local.get $6
-                              i32.store
-                              local.get $6
-                              local.get $0
-                              i32.const 1
-                              i32.or
-                              i32.store offset=4
-                              local.get $6
-                              local.get $0
-                              i32.add
-                              local.get $0
-                              i32.store
-                              br 4 (;@9;)
-                            end
-                          end
-                          local.get $4
-                          i32.load offset=4
-                          local.tee $0
-                          i32.const 3
-                          i32.and
-                          i32.const 1
-                          i32.eq
-                          if (result i32) ;; label = @12
-                            block (result i32) ;; label = @13
-                              local.get $0
-                              i32.const -8
-                              i32.and
-                              local.set $11
-                              local.get $0
-                              i32.const 3
-                              i32.shr_u
-                              local.set $1
-                              block $label$222 ;; label = @14
-                                local.get $0
-                                i32.const 256
-                                i32.lt_u
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $4
-                                    i32.load offset=12
-                                    local.set $5
-                                    block $label$224 ;; label = @17
-                                      local.get $4
-                                      i32.load offset=8
-                                      local.tee $3
-                                      local.get $1
-                                      i32.const 1
-                                      i32.shl
-                                      i32.const 2
-                                      i32.shl
-                                      i32.const 3684
-                                      i32.add
-                                      local.tee $0
-                                      i32.ne
-                                      if ;; label = @18
-                                        block ;; label = @19
-                                          local.get $3
-                                          local.get $2
-                                          i32.lt_u
-                                          if ;; label = @20
-                                            call $fimport$10
-                                          end
-                                          local.get $3
-                                          i32.load offset=12
-                                          local.get $4
-                                          i32.eq
-                                          br_if 2 (;@17;)
-                                          call $fimport$10
-                                        end
-                                      end
-                                    end
-                                    local.get $5
-                                    local.get $3
-                                    i32.eq
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        i32.const 3644
-                                        i32.const 3644
-                                        i32.load
-                                        i32.const 1
-                                        local.get $1
-                                        i32.shl
-                                        i32.const -1
-                                        i32.xor
-                                        i32.and
-                                        i32.store
-                                        br 4 (;@14;)
-                                      end
-                                    end
-                                    block $label$228 ;; label = @17
-                                      local.get $5
-                                      local.get $0
-                                      i32.eq
-                                      if ;; label = @18
-                                        local.get $5
-                                        i32.const 8
-                                        i32.add
-                                        local.set $20
-                                      else
-                                        block ;; label = @19
-                                          local.get $5
-                                          local.get $2
-                                          i32.lt_u
-                                          if ;; label = @20
-                                            call $fimport$10
-                                          end
-                                          local.get $5
-                                          i32.const 8
-                                          i32.add
-                                          local.tee $0
-                                          i32.load
-                                          local.get $4
-                                          i32.eq
-                                          if ;; label = @20
-                                            block ;; label = @21
-                                              local.get $0
-                                              local.set $20
-                                              br 4 (;@17;)
-                                            end
-                                          end
-                                          call $fimport$10
-                                        end
-                                      end
-                                    end
-                                    local.get $3
-                                    local.get $5
-                                    i32.store offset=12
-                                    local.get $20
-                                    local.get $3
-                                    i32.store
-                                  end
-                                else
-                                  block ;; label = @16
-                                    local.get $4
-                                    i32.load offset=24
-                                    local.set $8
-                                    block $label$234 ;; label = @17
-                                      local.get $4
-                                      i32.load offset=12
-                                      local.tee $0
-                                      local.get $4
-                                      i32.eq
-                                      if ;; label = @18
-                                        block ;; label = @19
-                                          local.get $4
-                                          i32.const 16
-                                          i32.add
-                                          local.tee $3
-                                          i32.const 4
-                                          i32.add
-                                          local.tee $1
-                                          i32.load
-                                          local.tee $0
-                                          i32.eqz
-                                          if ;; label = @20
-                                            local.get $3
-                                            i32.load
-                                            local.tee $0
-                                            if ;; label = @21
-                                              local.get $3
-                                              local.set $1
-                                            else
-                                              block ;; label = @22
-                                                i32.const 0
-                                                local.set $12
-                                                br 5 (;@17;)
-                                              end
-                                            end
-                                          end
-                                          loop $label$239 ;; label = @20
-                                            local.get $0
-                                            i32.const 20
-                                            i32.add
-                                            local.tee $5
-                                            i32.load
-                                            local.tee $3
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                local.get $3
-                                                local.set $0
-                                                local.get $5
-                                                local.set $1
-                                                br 2 (;@20;)
-                                              end
-                                            end
-                                            local.get $0
-                                            i32.const 16
-                                            i32.add
-                                            local.tee $5
-                                            i32.load
-                                            local.tee $3
-                                            if ;; label = @21
-                                              block ;; label = @22
-                                                local.get $3
-                                                local.set $0
-                                                local.get $5
-                                                local.set $1
-                                                br 2 (;@20;)
-                                              end
-                                            end
-                                          end
-                                          local.get $1
-                                          local.get $2
-                                          i32.lt_u
-                                          if ;; label = @20
-                                            call $fimport$10
-                                          else
-                                            block ;; label = @21
-                                              local.get $1
-                                              i32.const 0
-                                              i32.store
-                                              local.get $0
-                                              local.set $12
-                                            end
-                                          end
-                                        end
-                                      else
-                                        block ;; label = @19
-                                          local.get $4
-                                          i32.load offset=8
-                                          local.tee $5
-                                          local.get $2
-                                          i32.lt_u
-                                          if ;; label = @20
-                                            call $fimport$10
-                                          end
-                                          local.get $5
-                                          i32.const 12
-                                          i32.add
-                                          local.tee $3
-                                          i32.load
-                                          local.get $4
-                                          i32.ne
-                                          if ;; label = @20
-                                            call $fimport$10
-                                          end
-                                          local.get $0
-                                          i32.const 8
-                                          i32.add
-                                          local.tee $1
-                                          i32.load
-                                          local.get $4
-                                          i32.eq
-                                          if ;; label = @20
-                                            block ;; label = @21
-                                              local.get $3
-                                              local.get $0
-                                              i32.store
-                                              local.get $1
-                                              local.get $5
-                                              i32.store
-                                              local.get $0
-                                              local.set $12
-                                            end
-                                          else
-                                            call $fimport$10
-                                          end
-                                        end
-                                      end
-                                    end
-                                    local.get $8
-                                    i32.eqz
-                                    br_if 2 (;@14;)
-                                    block $label$249 ;; label = @17
-                                      local.get $4
-                                      local.get $4
-                                      i32.load offset=28
-                                      local.tee $1
-                                      i32.const 2
-                                      i32.shl
-                                      i32.const 3948
-                                      i32.add
-                                      local.tee $0
-                                      i32.load
-                                      i32.eq
-                                      if ;; label = @18
-                                        block ;; label = @19
-                                          local.get $0
-                                          local.get $12
-                                          i32.store
-                                          local.get $12
-                                          br_if 2 (;@17;)
-                                          i32.const 3648
-                                          i32.const 3648
-                                          i32.load
-                                          i32.const 1
-                                          local.get $1
-                                          i32.shl
-                                          i32.const -1
-                                          i32.xor
-                                          i32.and
-                                          i32.store
-                                          br 5 (;@14;)
-                                        end
-                                      else
-                                        block ;; label = @19
-                                          local.get $8
-                                          i32.const 3660
-                                          i32.load
-                                          i32.lt_u
-                                          if ;; label = @20
-                                            call $fimport$10
-                                          end
-                                          local.get $8
-                                          i32.const 16
-                                          i32.add
-                                          local.tee $0
-                                          i32.load
-                                          local.get $4
-                                          i32.eq
-                                          if ;; label = @20
-                                            local.get $0
-                                            local.get $12
-                                            i32.store
-                                          else
-                                            local.get $8
-                                            local.get $12
-                                            i32.store offset=20
-                                          end
-                                          local.get $12
-                                          i32.eqz
-                                          br_if 5 (;@14;)
-                                        end
-                                      end
-                                    end
-                                    local.get $12
-                                    i32.const 3660
-                                    i32.load
-                                    local.tee $1
-                                    i32.lt_u
-                                    if ;; label = @17
-                                      call $fimport$10
-                                    end
-                                    local.get $12
-                                    local.get $8
-                                    i32.store offset=24
-                                    local.get $4
-                                    i32.const 16
-                                    i32.add
-                                    local.tee $0
-                                    i32.load
-                                    local.tee $3
-                                    if ;; label = @17
-                                      local.get $3
-                                      local.get $1
-                                      i32.lt_u
-                                      if ;; label = @18
-                                        call $fimport$10
-                                      else
-                                        block ;; label = @19
-                                          local.get $12
-                                          local.get $3
-                                          i32.store offset=16
-                                          local.get $3
-                                          local.get $12
-                                          i32.store offset=24
-                                        end
-                                      end
-                                    end
-                                    local.get $0
-                                    i32.load offset=4
-                                    local.tee $0
-                                    i32.eqz
-                                    br_if 2 (;@14;)
-                                    local.get $0
-                                    i32.const 3660
-                                    i32.load
-                                    i32.lt_u
-                                    if ;; label = @17
-                                      call $fimport$10
-                                    else
-                                      block ;; label = @18
-                                        local.get $12
-                                        local.get $0
-                                        i32.store offset=20
-                                        local.get $0
-                                        local.get $12
-                                        i32.store offset=24
-                                      end
-                                    end
-                                  end
-                                end
-                              end
-                              local.get $11
-                              local.get $7
-                              i32.add
-                              local.set $7
-                              local.get $4
-                              local.get $11
-                              i32.add
-                            end
-                          else
-                            local.get $4
-                          end
-                          local.tee $0
-                          i32.const 4
-                          i32.add
-                          local.tee $0
-                          local.get $0
-                          i32.load
-                          i32.const -2
-                          i32.and
-                          i32.store
-                          local.get $6
-                          local.get $7
-                          i32.const 1
-                          i32.or
-                          i32.store offset=4
-                          local.get $6
-                          local.get $7
-                          i32.add
-                          local.get $7
-                          i32.store
-                          local.get $7
-                          i32.const 3
-                          i32.shr_u
-                          local.set $0
-                          local.get $7
-                          i32.const 256
-                          i32.lt_u
-                          if ;; label = @12
-                            block ;; label = @13
-                              local.get $0
-                              i32.const 1
-                              i32.shl
-                              i32.const 2
-                              i32.shl
-                              i32.const 3684
-                              i32.add
-                              local.set $3
-                              block $label$263 ;; label = @14
-                                i32.const 3644
-                                i32.load
-                                local.tee $1
-                                i32.const 1
-                                local.get $0
-                                i32.shl
-                                local.tee $0
-                                i32.and
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $3
-                                    i32.const 8
-                                    i32.add
-                                    local.tee $1
-                                    i32.load
-                                    local.tee $0
-                                    i32.const 3660
-                                    i32.load
-                                    i32.ge_u
-                                    if ;; label = @17
-                                      block ;; label = @18
-                                        local.get $1
-                                        local.set $21
-                                        local.get $0
-                                        local.set $9
-                                        br 4 (;@14;)
-                                      end
-                                    end
-                                    call $fimport$10
-                                  end
-                                else
-                                  block ;; label = @16
-                                    i32.const 3644
-                                    local.get $1
-                                    local.get $0
-                                    i32.or
-                                    i32.store
-                                    local.get $3
-                                    i32.const 8
-                                    i32.add
-                                    local.set $21
-                                    local.get $3
-                                    local.set $9
-                                  end
-                                end
-                              end
-                              local.get $21
-                              local.get $6
-                              i32.store
-                              local.get $9
-                              local.get $6
-                              i32.store offset=12
-                              local.get $6
-                              local.get $9
-                              i32.store offset=8
-                              local.get $6
-                              local.get $3
-                              i32.store offset=12
-                              br 4 (;@9;)
-                            end
-                          end
-                          block $label$267 (result i32) ;; label = @12
-                            local.get $7
-                            i32.const 8
-                            i32.shr_u
-                            local.tee $0
-                            if (result i32) ;; label = @13
-                              block (result i32) ;; label = @14
-                                i32.const 31
-                                local.get $7
-                                i32.const 16777215
-                                i32.gt_u
-                                br_if 2 (;@12;)
-                                drop
-                                local.get $7
-                                i32.const 14
-                                local.get $0
-                                local.get $0
-                                i32.const 1048320
-                                i32.add
-                                i32.const 16
-                                i32.shr_u
-                                i32.const 8
-                                i32.and
-                                local.tee $3
-                                i32.shl
-                                local.tee $1
-                                i32.const 520192
-                                i32.add
-                                i32.const 16
-                                i32.shr_u
-                                i32.const 4
-                                i32.and
-                                local.tee $0
-                                local.get $3
-                                i32.or
-                                local.get $1
-                                local.get $0
-                                i32.shl
-                                local.tee $1
-                                i32.const 245760
-                                i32.add
-                                i32.const 16
-                                i32.shr_u
-                                i32.const 2
-                                i32.and
-                                local.tee $0
-                                i32.or
-                                i32.sub
-                                local.get $1
-                                local.get $0
-                                i32.shl
-                                i32.const 15
-                                i32.shr_u
-                                i32.add
-                                local.tee $0
-                                i32.const 7
-                                i32.add
-                                i32.shr_u
-                                i32.const 1
-                                i32.and
-                                local.get $0
-                                i32.const 1
-                                i32.shl
-                                i32.or
-                              end
-                            else
-                              i32.const 0
-                            end
-                          end
-                          local.tee $2
-                          i32.const 2
-                          i32.shl
-                          i32.const 3948
-                          i32.add
-                          local.set $3
-                          local.get $6
-                          local.get $2
-                          i32.store offset=28
-                          local.get $6
-                          i32.const 16
-                          i32.add
-                          local.tee $0
-                          i32.const 0
-                          i32.store offset=4
-                          local.get $0
-                          i32.const 0
-                          i32.store
-                          i32.const 3648
-                          i32.load
-                          local.tee $1
-                          i32.const 1
-                          local.get $2
-                          i32.shl
-                          local.tee $0
-                          i32.and
-                          i32.eqz
-                          if ;; label = @12
-                            block ;; label = @13
-                              i32.const 3648
-                              local.get $1
-                              local.get $0
-                              i32.or
-                              i32.store
-                              local.get $3
-                              local.get $6
-                              i32.store
-                              local.get $6
-                              local.get $3
-                              i32.store offset=24
-                              local.get $6
-                              local.get $6
-                              i32.store offset=12
-                              local.get $6
-                              local.get $6
-                              i32.store offset=8
-                              br 4 (;@9;)
-                            end
-                          end
-                          local.get $3
-                          i32.load
-                          local.set $0
-                          i32.const 25
-                          local.get $2
-                          i32.const 1
-                          i32.shr_u
-                          i32.sub
-                          local.set $1
-                          local.get $7
-                          local.get $2
-                          i32.const 31
-                          i32.eq
-                          if (result i32) ;; label = @12
-                            i32.const 0
-                          else
-                            local.get $1
-                          end
-                          i32.shl
-                          local.set $2
-                          block $label$273 ;; label = @12
-                            block $label$274 ;; label = @13
-                              block $label$275 ;; label = @14
-                                loop $label$276 ;; label = @15
-                                  local.get $0
-                                  i32.load offset=4
-                                  i32.const -8
-                                  i32.and
-                                  local.get $7
-                                  i32.eq
-                                  br_if 2 (;@13;)
-                                  local.get $2
-                                  i32.const 1
-                                  i32.shl
-                                  local.set $3
-                                  local.get $0
-                                  i32.const 16
-                                  i32.add
-                                  local.get $2
-                                  i32.const 31
-                                  i32.shr_u
-                                  i32.const 2
-                                  i32.shl
-                                  i32.add
-                                  local.tee $2
-                                  i32.load
-                                  local.tee $1
-                                  i32.eqz
-                                  br_if 1 (;@14;)
-                                  local.get $3
-                                  local.set $2
-                                  local.get $1
-                                  local.set $0
-                                  br 0 (;@15;)
-                                end
-                              end
-                              local.get $2
-                              i32.const 3660
-                              i32.load
-                              i32.lt_u
-                              if ;; label = @14
-                                call $fimport$10
-                              else
-                                block ;; label = @15
-                                  local.get $2
-                                  local.get $6
-                                  i32.store
-                                  local.get $6
-                                  local.get $0
-                                  i32.store offset=24
-                                  local.get $6
-                                  local.get $6
-                                  i32.store offset=12
-                                  local.get $6
-                                  local.get $6
-                                  i32.store offset=8
-                                  br 6 (;@9;)
-                                end
-                              end
-                              br 1 (;@12;)
-                            end
-                            local.get $0
-                            i32.const 8
-                            i32.add
-                            local.tee $3
-                            i32.load
-                            local.tee $2
-                            i32.const 3660
-                            i32.load
-                            local.tee $1
-                            i32.ge_u
-                            local.get $0
-                            local.get $1
-                            i32.ge_u
-                            i32.and
-                            if ;; label = @13
-                              block ;; label = @14
-                                local.get $2
-                                local.get $6
-                                i32.store offset=12
-                                local.get $3
-                                local.get $6
-                                i32.store
-                                local.get $6
-                                local.get $2
-                                i32.store offset=8
-                                local.get $6
-                                local.get $0
-                                i32.store offset=12
-                                local.get $6
-                                i32.const 0
-                                i32.store offset=24
-                              end
-                            else
-                              call $fimport$10
-                            end
-                          end
-                        end
-                      end
-                    end
-                    local.get $14
-                    global.set $global$1
-                    local.get $13
-                    i32.const 8
-                    i32.add
-                    return
-                  end
-                end
-              end
-              loop $label$281 ;; label = @6
-                block $label$282 ;; label = @7
-                  local.get $5
-                  i32.load
-                  local.tee $2
-                  local.get $8
-                  i32.le_u
-                  if ;; label = @8
-                    local.get $2
-                    local.get $5
-                    i32.load offset=4
-                    i32.add
-                    local.tee $13
-                    local.get $8
-                    i32.gt_u
-                    br_if 1 (;@7;)
-                  end
-                  local.get $5
-                  i32.load offset=8
-                  local.set $5
-                  br 1 (;@6;)
-                end
-              end
-              i32.const 0
-              local.get $13
-              i32.const -47
-              i32.add
-              local.tee $7
-              i32.const 8
-              i32.add
-              local.tee $5
-              i32.sub
-              i32.const 7
-              i32.and
-              local.set $2
-              local.get $7
-              local.get $5
-              i32.const 7
-              i32.and
-              if (result i32) ;; label = @6
-                local.get $2
-              else
-                i32.const 0
-              end
-              i32.add
-              local.tee $2
-              local.get $8
-              i32.const 16
-              i32.add
-              local.tee $12
-              i32.lt_u
-              if (result i32) ;; label = @6
-                local.get $8
-              else
-                local.get $2
-              end
-              local.tee $7
-              i32.const 8
-              i32.add
-              local.set $10
-              local.get $7
-              i32.const 24
-              i32.add
-              local.set $5
-              local.get $3
-              i32.const -40
-              i32.add
-              local.set $9
-              i32.const 0
-              local.get $1
-              i32.const 8
-              i32.add
-              local.tee $4
-              i32.sub
-              i32.const 7
-              i32.and
-              local.set $2
-              i32.const 3668
-              local.get $1
-              local.get $4
-              i32.const 7
-              i32.and
-              if (result i32) ;; label = @6
-                local.get $2
-              else
-                i32.const 0
-                local.tee $2
-              end
-              i32.add
-              local.tee $4
-              i32.store
-              i32.const 3656
-              local.get $9
-              local.get $2
-              i32.sub
-              local.tee $2
-              i32.store
-              local.get $4
-              local.get $2
-              i32.const 1
-              i32.or
-              i32.store offset=4
-              local.get $4
-              local.get $2
-              i32.add
-              i32.const 40
-              i32.store offset=4
-              i32.const 3672
-              i32.const 4132
-              i32.load
-              i32.store
-              local.get $7
-              i32.const 4
-              i32.add
-              local.tee $2
-              i32.const 27
-              i32.store
-              local.get $10
-              i32.const 4092
-              i64.load align=4
-              i64.store align=4
-              local.get $10
-              i32.const 4100
-              i64.load align=4
-              i64.store offset=8 align=4
-              i32.const 4092
-              local.get $1
-              i32.store
-              i32.const 4096
-              local.get $3
-              i32.store
-              i32.const 4104
-              i32.const 0
-              i32.store
-              i32.const 4100
-              local.get $10
-              i32.store
-              local.get $5
-              local.set $1
-              loop $label$290 ;; label = @6
-                local.get $1
-                i32.const 4
-                i32.add
-                local.tee $1
-                i32.const 7
-                i32.store
-                local.get $1
-                i32.const 4
-                i32.add
-                local.get $13
-                i32.lt_u
-                br_if 0 (;@6;)
-              end
-              local.get $7
-              local.get $8
-              i32.ne
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $2
-                  local.get $2
-                  i32.load
-                  i32.const -2
-                  i32.and
-                  i32.store
-                  local.get $8
-                  local.get $7
-                  local.get $8
-                  i32.sub
-                  local.tee $4
-                  i32.const 1
-                  i32.or
-                  i32.store offset=4
-                  local.get $7
-                  local.get $4
-                  i32.store
-                  local.get $4
-                  i32.const 3
-                  i32.shr_u
-                  local.set $1
-                  local.get $4
-                  i32.const 256
-                  i32.lt_u
-                  if ;; label = @8
-                    block ;; label = @9
-                      local.get $1
-                      i32.const 1
-                      i32.shl
-                      i32.const 2
-                      i32.shl
-                      i32.const 3684
-                      i32.add
-                      local.set $2
-                      i32.const 3644
-                      i32.load
-                      local.tee $3
-                      i32.const 1
-                      local.get $1
-                      i32.shl
-                      local.tee $1
-                      i32.and
-                      if ;; label = @10
-                        local.get $2
-                        i32.const 8
-                        i32.add
-                        local.tee $3
-                        i32.load
-                        local.tee $1
-                        i32.const 3660
-                        i32.load
-                        i32.lt_u
-                        if ;; label = @11
-                          call $fimport$10
-                        else
-                          block ;; label = @12
-                            local.get $3
-                            local.set $15
-                            local.get $1
-                            local.set $11
-                          end
-                        end
-                      else
-                        block ;; label = @11
-                          i32.const 3644
-                          local.get $3
-                          local.get $1
-                          i32.or
-                          i32.store
-                          local.get $2
-                          i32.const 8
-                          i32.add
-                          local.set $15
-                          local.get $2
-                          local.set $11
-                        end
-                      end
-                      local.get $15
-                      local.get $8
-                      i32.store
-                      local.get $11
-                      local.get $8
-                      i32.store offset=12
-                      local.get $8
-                      local.get $11
-                      i32.store offset=8
-                      local.get $8
-                      local.get $2
-                      i32.store offset=12
-                      br 6 (;@3;)
-                    end
-                  end
-                  local.get $4
-                  i32.const 8
-                  i32.shr_u
-                  local.tee $1
-                  if (result i32) ;; label = @8
-                    local.get $4
-                    i32.const 16777215
-                    i32.gt_u
-                    if (result i32) ;; label = @9
-                      i32.const 31
-                    else
-                      local.get $4
-                      i32.const 14
-                      local.get $1
-                      local.get $1
-                      i32.const 1048320
-                      i32.add
-                      i32.const 16
-                      i32.shr_u
-                      i32.const 8
-                      i32.and
-                      local.tee $2
-                      i32.shl
-                      local.tee $3
-                      i32.const 520192
-                      i32.add
-                      i32.const 16
-                      i32.shr_u
-                      i32.const 4
-                      i32.and
-                      local.tee $1
-                      local.get $2
-                      i32.or
-                      local.get $3
-                      local.get $1
-                      i32.shl
-                      local.tee $3
-                      i32.const 245760
-                      i32.add
-                      i32.const 16
-                      i32.shr_u
-                      i32.const 2
-                      i32.and
-                      local.tee $1
-                      i32.or
-                      i32.sub
-                      local.get $3
-                      local.get $1
-                      i32.shl
-                      i32.const 15
-                      i32.shr_u
-                      i32.add
-                      local.tee $1
-                      i32.const 7
-                      i32.add
-                      i32.shr_u
-                      i32.const 1
-                      i32.and
-                      local.get $1
-                      i32.const 1
-                      i32.shl
-                      i32.or
-                    end
-                  else
-                    i32.const 0
-                  end
-                  local.tee $5
-                  i32.const 2
-                  i32.shl
-                  i32.const 3948
-                  i32.add
-                  local.set $2
-                  local.get $8
-                  local.get $5
-                  i32.store offset=28
-                  local.get $8
-                  i32.const 0
-                  i32.store offset=20
-                  local.get $12
-                  i32.const 0
-                  i32.store
-                  i32.const 3648
-                  i32.load
-                  local.tee $3
-                  i32.const 1
-                  local.get $5
-                  i32.shl
-                  local.tee $1
-                  i32.and
-                  i32.eqz
-                  if ;; label = @8
-                    block ;; label = @9
-                      i32.const 3648
-                      local.get $3
-                      local.get $1
-                      i32.or
-                      i32.store
-                      local.get $2
-                      local.get $8
-                      i32.store
-                      local.get $8
-                      local.get $2
-                      i32.store offset=24
-                      local.get $8
-                      local.get $8
-                      i32.store offset=12
-                      local.get $8
-                      local.get $8
-                      i32.store offset=8
-                      br 6 (;@3;)
-                    end
-                  end
-                  local.get $2
-                  i32.load
-                  local.set $1
-                  i32.const 25
-                  local.get $5
-                  i32.const 1
-                  i32.shr_u
-                  i32.sub
-                  local.set $3
-                  local.get $4
-                  local.get $5
-                  i32.const 31
-                  i32.eq
-                  if (result i32) ;; label = @8
-                    i32.const 0
-                  else
-                    local.get $3
-                  end
-                  i32.shl
-                  local.set $5
-                  block $label$304 ;; label = @8
-                    block $label$305 ;; label = @9
-                      block $label$306 ;; label = @10
-                        loop $label$307 ;; label = @11
-                          local.get $1
-                          i32.load offset=4
-                          i32.const -8
-                          i32.and
-                          local.get $4
-                          i32.eq
-                          br_if 2 (;@9;)
-                          local.get $5
-                          i32.const 1
-                          i32.shl
-                          local.set $2
-                          local.get $1
-                          i32.const 16
-                          i32.add
-                          local.get $5
-                          i32.const 31
-                          i32.shr_u
-                          i32.const 2
-                          i32.shl
-                          i32.add
-                          local.tee $5
-                          i32.load
-                          local.tee $3
-                          i32.eqz
-                          br_if 1 (;@10;)
-                          local.get $2
-                          local.set $5
-                          local.get $3
-                          local.set $1
-                          br 0 (;@11;)
-                        end
-                      end
-                      local.get $5
-                      i32.const 3660
-                      i32.load
-                      i32.lt_u
-                      if ;; label = @10
-                        call $fimport$10
-                      else
-                        block ;; label = @11
-                          local.get $5
-                          local.get $8
-                          i32.store
-                          local.get $8
-                          local.get $1
-                          i32.store offset=24
-                          local.get $8
-                          local.get $8
-                          i32.store offset=12
-                          local.get $8
-                          local.get $8
-                          i32.store offset=8
-                          br 8 (;@3;)
-                        end
-                      end
-                      br 1 (;@8;)
-                    end
-                    local.get $1
-                    i32.const 8
-                    i32.add
-                    local.tee $2
-                    i32.load
-                    local.tee $5
-                    i32.const 3660
-                    i32.load
-                    local.tee $3
-                    i32.ge_u
-                    local.get $1
-                    local.get $3
-                    i32.ge_u
-                    i32.and
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $5
-                        local.get $8
-                        i32.store offset=12
-                        local.get $2
-                        local.get $8
-                        i32.store
-                        local.get $8
-                        local.get $5
-                        i32.store offset=8
-                        local.get $8
-                        local.get $1
-                        i32.store offset=12
-                        local.get $8
-                        i32.const 0
-                        i32.store offset=24
-                      end
-                    else
-                      call $fimport$10
-                    end
-                  end
-                end
-              end
-            end
-          else
-            block ;; label = @5
-              i32.const 3660
-              i32.load
-              local.tee $2
-              i32.eqz
-              local.get $1
-              local.get $2
-              i32.lt_u
-              i32.or
-              if ;; label = @6
-                i32.const 3660
-                local.get $1
-                i32.store
-              end
-              i32.const 4092
-              local.get $1
-              i32.store
-              i32.const 4096
-              local.get $3
-              i32.store
-              i32.const 4104
-              i32.const 0
-              i32.store
-              i32.const 3680
-              i32.const 4116
-              i32.load
-              i32.store
-              i32.const 3676
-              i32.const -1
-              i32.store
-              i32.const 0
-              local.set $2
-              loop $label$314 ;; label = @6
-                local.get $2
-                i32.const 1
-                i32.shl
-                i32.const 2
-                i32.shl
-                i32.const 3684
-                i32.add
-                local.tee $5
-                local.get $5
-                i32.store offset=12
-                local.get $5
-                local.get $5
-                i32.store offset=8
-                local.get $2
-                i32.const 1
-                i32.add
-                local.tee $2
-                i32.const 32
-                i32.ne
-                br_if 0 (;@6;)
-              end
-              local.get $3
-              i32.const -40
-              i32.add
-              local.set $5
-              i32.const 0
-              local.get $1
-              i32.const 8
-              i32.add
-              local.tee $2
-              i32.sub
-              i32.const 7
-              i32.and
-              local.set $3
-              i32.const 3668
-              local.get $1
-              local.get $2
-              i32.const 7
-              i32.and
-              if (result i32) ;; label = @6
-                local.get $3
-              else
-                i32.const 0
-              end
-              local.tee $1
-              i32.add
-              local.tee $3
-              i32.store
-              i32.const 3656
-              local.get $5
-              local.get $1
-              i32.sub
-              local.tee $1
-              i32.store
-              local.get $3
-              local.get $1
-              i32.const 1
-              i32.or
-              i32.store offset=4
-              local.get $3
-              local.get $1
-              i32.add
-              i32.const 40
-              i32.store offset=4
-              i32.const 3672
-              i32.const 4132
-              i32.load
-              i32.store
-            end
-          end
-        end
-        i32.const 3656
-        i32.load
-        local.tee $1
-        local.get $0
-        i32.gt_u
-        if ;; label = @3
-          block ;; label = @4
-            i32.const 3656
-            local.get $1
-            local.get $0
-            i32.sub
-            local.tee $3
-            i32.store
-            i32.const 3668
-            i32.const 3668
-            i32.load
-            local.tee $2
-            local.get $0
-            i32.add
-            local.tee $1
-            i32.store
-            local.get $1
-            local.get $3
-            i32.const 1
-            i32.or
-            i32.store offset=4
-            local.get $2
-            local.get $0
-            i32.const 3
-            i32.or
-            i32.store offset=4
-            local.get $14
-            global.set $global$1
-            local.get $2
-            i32.const 8
-            i32.add
-            return
-          end
-        end
-      end
-      call $11
-      i32.const 12
-      i32.store
-      local.get $14
-      global.set $global$1
-      i32.const 0
-    end
-  )
-  (func $32 (;45;) (type $2) (param $0 i32)
-    (local $1 i32) (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32) (local $15 i32)
-    block $label$1 ;; label = @1
-      local.get $0
-      i32.eqz
-      if ;; label = @2
-        return
-      end
-      local.get $0
-      i32.const -8
-      i32.add
-      local.tee $1
-      i32.const 3660
-      i32.load
-      local.tee $11
-      i32.lt_u
-      if ;; label = @2
-        call $fimport$10
-      end
-      local.get $0
-      i32.const -4
-      i32.add
-      i32.load
-      local.tee $0
-      i32.const 3
-      i32.and
-      local.tee $8
-      i32.const 1
-      i32.eq
-      if ;; label = @2
-        call $fimport$10
-      end
-      local.get $1
-      local.get $0
-      i32.const -8
-      i32.and
-      local.tee $4
-      i32.add
-      local.set $6
-      block $label$5 ;; label = @2
-        local.get $0
-        i32.const 1
-        i32.and
-        if ;; label = @3
-          block ;; label = @4
-            local.get $1
-            local.set $3
-            local.get $4
-            local.set $2
-          end
-        else
-          block ;; label = @4
-            local.get $8
-            i32.eqz
-            if ;; label = @5
-              return
-            end
-            local.get $1
-            i32.const 0
-            local.get $1
-            i32.load
-            local.tee $8
-            i32.sub
-            i32.add
-            local.tee $0
-            local.get $11
-            i32.lt_u
-            if ;; label = @5
-              call $fimport$10
-            end
-            local.get $8
-            local.get $4
-            i32.add
-            local.set $1
-            local.get $0
-            i32.const 3664
-            i32.load
-            i32.eq
-            if ;; label = @5
-              block ;; label = @6
-                local.get $6
-                i32.const 4
-                i32.add
-                local.tee $2
-                i32.load
-                local.tee $3
-                i32.const 3
-                i32.and
-                i32.const 3
-                i32.ne
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $0
-                    local.set $3
-                    local.get $1
-                    local.set $2
-                    br 6 (;@2;)
-                  end
-                end
-                i32.const 3652
-                local.get $1
-                i32.store
-                local.get $2
-                local.get $3
-                i32.const -2
-                i32.and
-                i32.store
-                local.get $0
-                local.get $1
-                i32.const 1
-                i32.or
-                i32.store offset=4
-                local.get $0
-                local.get $1
-                i32.add
-                local.get $1
-                i32.store
-                return
-              end
-            end
-            local.get $8
-            i32.const 3
-            i32.shr_u
-            local.set $10
-            local.get $8
-            i32.const 256
-            i32.lt_u
-            if ;; label = @5
-              block ;; label = @6
-                local.get $0
-                i32.load offset=12
-                local.set $3
-                local.get $0
-                i32.load offset=8
-                local.tee $4
-                local.get $10
-                i32.const 1
-                i32.shl
-                i32.const 2
-                i32.shl
-                i32.const 3684
-                i32.add
-                local.tee $2
-                i32.ne
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $4
-                    local.get $11
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                    local.get $4
-                    i32.load offset=12
-                    local.get $0
-                    i32.ne
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                  end
-                end
-                local.get $3
-                local.get $4
-                i32.eq
-                if ;; label = @7
-                  block ;; label = @8
-                    i32.const 3644
-                    i32.const 3644
-                    i32.load
-                    i32.const 1
-                    local.get $10
-                    i32.shl
-                    i32.const -1
-                    i32.xor
-                    i32.and
-                    i32.store
-                    local.get $0
-                    local.set $3
-                    local.get $1
-                    local.set $2
-                    br 6 (;@2;)
-                  end
-                end
-                local.get $3
-                local.get $2
-                i32.eq
-                if ;; label = @7
-                  local.get $3
-                  i32.const 8
-                  i32.add
-                  local.set $5
-                else
-                  block ;; label = @8
-                    local.get $3
-                    local.get $11
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                    local.get $3
-                    i32.const 8
-                    i32.add
-                    local.tee $2
-                    i32.load
-                    local.get $0
-                    i32.eq
-                    if ;; label = @9
-                      local.get $2
-                      local.set $5
-                    else
-                      call $fimport$10
-                    end
-                  end
-                end
-                local.get $4
-                local.get $3
-                i32.store offset=12
-                local.get $5
-                local.get $4
-                i32.store
-                local.get $0
-                local.set $3
-                local.get $1
-                local.set $2
-                br 4 (;@2;)
-              end
-            end
-            local.get $0
-            i32.load offset=24
-            local.set $12
-            block $label$22 ;; label = @5
-              local.get $0
-              i32.load offset=12
-              local.tee $4
-              local.get $0
-              i32.eq
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $0
-                  i32.const 16
-                  i32.add
-                  local.tee $5
-                  i32.const 4
-                  i32.add
-                  local.tee $8
-                  i32.load
-                  local.tee $4
-                  if ;; label = @8
-                    local.get $8
-                    local.set $5
-                  else
-                    local.get $5
-                    i32.load
-                    local.tee $4
-                    i32.eqz
-                    if ;; label = @9
-                      block ;; label = @10
-                        i32.const 0
-                        local.set $7
-                        br 5 (;@5;)
-                      end
-                    end
-                  end
-                  loop $label$27 ;; label = @8
-                    local.get $4
-                    i32.const 20
-                    i32.add
-                    local.tee $8
-                    i32.load
-                    local.tee $10
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $10
-                        local.set $4
-                        local.get $8
-                        local.set $5
-                        br 2 (;@8;)
-                      end
-                    end
-                    local.get $4
-                    i32.const 16
-                    i32.add
-                    local.tee $8
-                    i32.load
-                    local.tee $10
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $10
-                        local.set $4
-                        local.get $8
-                        local.set $5
-                        br 2 (;@8;)
-                      end
-                    end
-                  end
-                  local.get $5
-                  local.get $11
-                  i32.lt_u
-                  if ;; label = @8
-                    call $fimport$10
-                  else
-                    block ;; label = @9
-                      local.get $5
-                      i32.const 0
-                      i32.store
-                      local.get $4
-                      local.set $7
-                    end
-                  end
-                end
-              else
-                block ;; label = @7
-                  local.get $0
-                  i32.load offset=8
-                  local.tee $5
-                  local.get $11
-                  i32.lt_u
-                  if ;; label = @8
-                    call $fimport$10
-                  end
-                  local.get $5
-                  i32.const 12
-                  i32.add
-                  local.tee $8
-                  i32.load
-                  local.get $0
-                  i32.ne
-                  if ;; label = @8
-                    call $fimport$10
-                  end
-                  local.get $4
-                  i32.const 8
-                  i32.add
-                  local.tee $10
-                  i32.load
-                  local.get $0
-                  i32.eq
-                  if ;; label = @8
-                    block ;; label = @9
-                      local.get $8
-                      local.get $4
-                      i32.store
-                      local.get $10
-                      local.get $5
-                      i32.store
-                      local.get $4
-                      local.set $7
-                    end
-                  else
-                    call $fimport$10
-                  end
-                end
-              end
-            end
-            local.get $12
-            if ;; label = @5
-              block ;; label = @6
-                local.get $0
-                local.get $0
-                i32.load offset=28
-                local.tee $4
-                i32.const 2
-                i32.shl
-                i32.const 3948
-                i32.add
-                local.tee $5
-                i32.load
-                i32.eq
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $5
-                    local.get $7
-                    i32.store
-                    local.get $7
-                    i32.eqz
-                    if ;; label = @9
-                      block ;; label = @10
-                        i32.const 3648
-                        i32.const 3648
-                        i32.load
-                        i32.const 1
-                        local.get $4
-                        i32.shl
-                        i32.const -1
-                        i32.xor
-                        i32.and
-                        i32.store
-                        local.get $0
-                        local.set $3
-                        local.get $1
-                        local.set $2
-                        br 8 (;@2;)
-                      end
-                    end
-                  end
-                else
-                  block ;; label = @8
-                    local.get $12
-                    i32.const 3660
-                    i32.load
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                    local.get $12
-                    i32.const 16
-                    i32.add
-                    local.tee $4
-                    i32.load
-                    local.get $0
-                    i32.eq
-                    if ;; label = @9
-                      local.get $4
-                      local.get $7
-                      i32.store
-                    else
-                      local.get $12
-                      local.get $7
-                      i32.store offset=20
-                    end
-                    local.get $7
-                    i32.eqz
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $0
-                        local.set $3
-                        local.get $1
-                        local.set $2
-                        br 8 (;@2;)
-                      end
-                    end
-                  end
-                end
-                local.get $7
-                i32.const 3660
-                i32.load
-                local.tee $5
-                i32.lt_u
-                if ;; label = @7
-                  call $fimport$10
-                end
-                local.get $7
-                local.get $12
-                i32.store offset=24
-                local.get $0
-                i32.const 16
-                i32.add
-                local.tee $8
-                i32.load
-                local.tee $4
-                if ;; label = @7
-                  local.get $4
-                  local.get $5
-                  i32.lt_u
-                  if ;; label = @8
-                    call $fimport$10
-                  else
-                    block ;; label = @9
-                      local.get $7
-                      local.get $4
-                      i32.store offset=16
-                      local.get $4
-                      local.get $7
-                      i32.store offset=24
-                    end
-                  end
-                end
-                local.get $8
-                i32.load offset=4
-                local.tee $4
-                if ;; label = @7
-                  local.get $4
-                  i32.const 3660
-                  i32.load
-                  i32.lt_u
-                  if ;; label = @8
-                    call $fimport$10
-                  else
-                    block ;; label = @9
-                      local.get $7
-                      local.get $4
-                      i32.store offset=20
-                      local.get $4
-                      local.get $7
-                      i32.store offset=24
-                      local.get $0
-                      local.set $3
-                      local.get $1
-                      local.set $2
-                    end
-                  end
-                else
-                  block ;; label = @8
-                    local.get $0
-                    local.set $3
-                    local.get $1
-                    local.set $2
-                  end
-                end
-              end
-            else
-              block ;; label = @6
-                local.get $0
-                local.set $3
-                local.get $1
-                local.set $2
-              end
-            end
-          end
-        end
-      end
-      local.get $3
-      local.get $6
-      i32.ge_u
-      if ;; label = @2
-        call $fimport$10
-      end
-      local.get $6
-      i32.const 4
-      i32.add
-      local.tee $1
-      i32.load
-      local.tee $0
-      i32.const 1
-      i32.and
-      i32.eqz
-      if ;; label = @2
-        call $fimport$10
-      end
-      local.get $0
-      i32.const 2
-      i32.and
-      if ;; label = @2
-        block ;; label = @3
-          local.get $1
-          local.get $0
-          i32.const -2
-          i32.and
-          i32.store
-          local.get $3
-          local.get $2
-          i32.const 1
-          i32.or
-          i32.store offset=4
-          local.get $3
-          local.get $2
-          i32.add
-          local.get $2
-          i32.store
-        end
-      else
-        block ;; label = @3
-          local.get $6
-          i32.const 3668
-          i32.load
-          i32.eq
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 3656
-              i32.const 3656
-              i32.load
-              local.get $2
-              i32.add
-              local.tee $0
-              i32.store
-              i32.const 3668
-              local.get $3
-              i32.store
-              local.get $3
-              local.get $0
-              i32.const 1
-              i32.or
-              i32.store offset=4
-              local.get $3
-              i32.const 3664
-              i32.load
-              i32.ne
-              if ;; label = @6
-                return
-              end
-              i32.const 3664
-              i32.const 0
-              i32.store
-              i32.const 3652
-              i32.const 0
-              i32.store
-              return
-            end
-          end
-          local.get $6
-          i32.const 3664
-          i32.load
-          i32.eq
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 3652
-              i32.const 3652
-              i32.load
-              local.get $2
-              i32.add
-              local.tee $0
-              i32.store
-              i32.const 3664
-              local.get $3
-              i32.store
-              local.get $3
-              local.get $0
-              i32.const 1
-              i32.or
-              i32.store offset=4
-              local.get $3
-              local.get $0
-              i32.add
-              local.get $0
-              i32.store
-              return
-            end
-          end
-          local.get $0
-          i32.const -8
-          i32.and
-          local.get $2
-          i32.add
-          local.set $5
-          local.get $0
-          i32.const 3
-          i32.shr_u
-          local.set $4
-          block $label$61 ;; label = @4
-            local.get $0
-            i32.const 256
-            i32.lt_u
-            if ;; label = @5
-              block ;; label = @6
-                local.get $6
-                i32.load offset=12
-                local.set $2
-                local.get $6
-                i32.load offset=8
-                local.tee $1
-                local.get $4
-                i32.const 1
-                i32.shl
-                i32.const 2
-                i32.shl
-                i32.const 3684
-                i32.add
-                local.tee $0
-                i32.ne
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $1
-                    i32.const 3660
-                    i32.load
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                    local.get $1
-                    i32.load offset=12
-                    local.get $6
-                    i32.ne
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                  end
-                end
-                local.get $2
-                local.get $1
-                i32.eq
-                if ;; label = @7
-                  block ;; label = @8
-                    i32.const 3644
-                    i32.const 3644
-                    i32.load
-                    i32.const 1
-                    local.get $4
-                    i32.shl
-                    i32.const -1
-                    i32.xor
-                    i32.and
-                    i32.store
-                    br 4 (;@4;)
-                  end
-                end
-                local.get $2
-                local.get $0
-                i32.eq
-                if ;; label = @7
-                  local.get $2
-                  i32.const 8
-                  i32.add
-                  local.set $14
-                else
-                  block ;; label = @8
-                    local.get $2
-                    i32.const 3660
-                    i32.load
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                    local.get $2
-                    i32.const 8
-                    i32.add
-                    local.tee $0
-                    i32.load
-                    local.get $6
-                    i32.eq
-                    if ;; label = @9
-                      local.get $0
-                      local.set $14
-                    else
-                      call $fimport$10
-                    end
-                  end
-                end
-                local.get $1
-                local.get $2
-                i32.store offset=12
-                local.get $14
-                local.get $1
-                i32.store
-              end
-            else
-              block ;; label = @6
-                local.get $6
-                i32.load offset=24
-                local.set $7
-                block $label$73 ;; label = @7
-                  local.get $6
-                  i32.load offset=12
-                  local.tee $0
-                  local.get $6
-                  i32.eq
-                  if ;; label = @8
-                    block ;; label = @9
-                      local.get $6
-                      i32.const 16
-                      i32.add
-                      local.tee $2
-                      i32.const 4
-                      i32.add
-                      local.tee $1
-                      i32.load
-                      local.tee $0
-                      if ;; label = @10
-                        local.get $1
-                        local.set $2
-                      else
-                        local.get $2
-                        i32.load
-                        local.tee $0
-                        i32.eqz
-                        if ;; label = @11
-                          block ;; label = @12
-                            i32.const 0
-                            local.set $9
-                            br 5 (;@7;)
-                          end
-                        end
-                      end
-                      loop $label$78 ;; label = @10
-                        local.get $0
-                        i32.const 20
-                        i32.add
-                        local.tee $1
-                        i32.load
-                        local.tee $4
-                        if ;; label = @11
-                          block ;; label = @12
-                            local.get $4
-                            local.set $0
-                            local.get $1
-                            local.set $2
-                            br 2 (;@10;)
-                          end
-                        end
-                        local.get $0
-                        i32.const 16
-                        i32.add
-                        local.tee $1
-                        i32.load
-                        local.tee $4
-                        if ;; label = @11
-                          block ;; label = @12
-                            local.get $4
-                            local.set $0
-                            local.get $1
-                            local.set $2
-                            br 2 (;@10;)
-                          end
-                        end
-                      end
-                      local.get $2
-                      i32.const 3660
-                      i32.load
-                      i32.lt_u
-                      if ;; label = @10
-                        call $fimport$10
-                      else
-                        block ;; label = @11
-                          local.get $2
-                          i32.const 0
-                          i32.store
-                          local.get $0
-                          local.set $9
-                        end
-                      end
-                    end
-                  else
-                    block ;; label = @9
-                      local.get $6
-                      i32.load offset=8
-                      local.tee $2
-                      i32.const 3660
-                      i32.load
-                      i32.lt_u
-                      if ;; label = @10
-                        call $fimport$10
-                      end
-                      local.get $2
-                      i32.const 12
-                      i32.add
-                      local.tee $1
-                      i32.load
-                      local.get $6
-                      i32.ne
-                      if ;; label = @10
-                        call $fimport$10
-                      end
-                      local.get $0
-                      i32.const 8
-                      i32.add
-                      local.tee $4
-                      i32.load
-                      local.get $6
-                      i32.eq
-                      if ;; label = @10
-                        block ;; label = @11
-                          local.get $1
-                          local.get $0
-                          i32.store
-                          local.get $4
-                          local.get $2
-                          i32.store
-                          local.get $0
-                          local.set $9
-                        end
-                      else
-                        call $fimport$10
-                      end
-                    end
-                  end
-                end
-                local.get $7
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $6
-                    local.get $6
-                    i32.load offset=28
-                    local.tee $0
-                    i32.const 2
-                    i32.shl
-                    i32.const 3948
-                    i32.add
-                    local.tee $2
-                    i32.load
-                    i32.eq
-                    if ;; label = @9
-                      block ;; label = @10
-                        local.get $2
-                        local.get $9
-                        i32.store
-                        local.get $9
-                        i32.eqz
-                        if ;; label = @11
-                          block ;; label = @12
-                            i32.const 3648
-                            i32.const 3648
-                            i32.load
-                            i32.const 1
-                            local.get $0
-                            i32.shl
-                            i32.const -1
-                            i32.xor
-                            i32.and
-                            i32.store
-                            br 8 (;@4;)
-                          end
-                        end
-                      end
-                    else
-                      block ;; label = @10
-                        local.get $7
-                        i32.const 3660
-                        i32.load
-                        i32.lt_u
-                        if ;; label = @11
-                          call $fimport$10
-                        end
-                        local.get $7
-                        i32.const 16
-                        i32.add
-                        local.tee $0
-                        i32.load
-                        local.get $6
-                        i32.eq
-                        if ;; label = @11
-                          local.get $0
-                          local.get $9
-                          i32.store
-                        else
-                          local.get $7
-                          local.get $9
-                          i32.store offset=20
-                        end
-                        local.get $9
-                        i32.eqz
-                        br_if 6 (;@4;)
-                      end
-                    end
-                    local.get $9
-                    i32.const 3660
-                    i32.load
-                    local.tee $2
-                    i32.lt_u
-                    if ;; label = @9
-                      call $fimport$10
-                    end
-                    local.get $9
-                    local.get $7
-                    i32.store offset=24
-                    local.get $6
-                    i32.const 16
-                    i32.add
-                    local.tee $1
-                    i32.load
-                    local.tee $0
-                    if ;; label = @9
-                      local.get $0
-                      local.get $2
-                      i32.lt_u
-                      if ;; label = @10
-                        call $fimport$10
-                      else
-                        block ;; label = @11
-                          local.get $9
-                          local.get $0
-                          i32.store offset=16
-                          local.get $0
-                          local.get $9
-                          i32.store offset=24
-                        end
-                      end
-                    end
-                    local.get $1
-                    i32.load offset=4
-                    local.tee $0
-                    if ;; label = @9
-                      local.get $0
-                      i32.const 3660
-                      i32.load
-                      i32.lt_u
-                      if ;; label = @10
-                        call $fimport$10
-                      else
-                        block ;; label = @11
-                          local.get $9
-                          local.get $0
-                          i32.store offset=20
-                          local.get $0
-                          local.get $9
-                          i32.store offset=24
-                        end
-                      end
-                    end
-                  end
-                end
-              end
-            end
-          end
-          local.get $3
-          local.get $5
-          i32.const 1
-          i32.or
-          i32.store offset=4
-          local.get $3
-          local.get $5
-          i32.add
-          local.get $5
-          i32.store
-          local.get $3
-          i32.const 3664
-          i32.load
-          i32.eq
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 3652
-              local.get $5
-              i32.store
-              return
-            end
-          else
-            local.get $5
-            local.set $2
-          end
-        end
-      end
-      local.get $2
-      i32.const 3
-      i32.shr_u
-      local.set $1
-      local.get $2
-      i32.const 256
-      i32.lt_u
-      if ;; label = @2
-        block ;; label = @3
-          local.get $1
-          i32.const 1
-          i32.shl
-          i32.const 2
-          i32.shl
-          i32.const 3684
-          i32.add
-          local.set $0
-          i32.const 3644
-          i32.load
-          local.tee $2
-          i32.const 1
-          local.get $1
-          i32.shl
-          local.tee $1
-          i32.and
-          if ;; label = @4
-            local.get $0
-            i32.const 8
-            i32.add
-            local.tee $2
-            i32.load
-            local.tee $1
-            i32.const 3660
-            i32.load
-            i32.lt_u
-            if ;; label = @5
-              call $fimport$10
-            else
-              block ;; label = @6
-                local.get $2
-                local.set $15
-                local.get $1
-                local.set $13
-              end
-            end
-          else
-            block ;; label = @5
-              i32.const 3644
-              local.get $2
-              local.get $1
-              i32.or
-              i32.store
-              local.get $0
-              i32.const 8
-              i32.add
-              local.set $15
-              local.get $0
-              local.set $13
-            end
-          end
-          local.get $15
-          local.get $3
-          i32.store
-          local.get $13
-          local.get $3
-          i32.store offset=12
-          local.get $3
-          local.get $13
-          i32.store offset=8
-          local.get $3
-          local.get $0
-          i32.store offset=12
-          return
-        end
-      end
-      local.get $2
-      i32.const 8
-      i32.shr_u
-      local.tee $0
-      if (result i32) ;; label = @2
-        local.get $2
-        i32.const 16777215
-        i32.gt_u
-        if (result i32) ;; label = @3
-          i32.const 31
-        else
-          local.get $2
-          i32.const 14
-          local.get $0
-          local.get $0
-          i32.const 1048320
-          i32.add
-          i32.const 16
-          i32.shr_u
-          i32.const 8
-          i32.and
-          local.tee $0
-          i32.shl
-          local.tee $1
-          i32.const 520192
-          i32.add
-          i32.const 16
-          i32.shr_u
-          i32.const 4
-          i32.and
-          local.tee $4
-          local.get $0
-          i32.or
-          local.get $1
-          local.get $4
-          i32.shl
-          local.tee $0
-          i32.const 245760
-          i32.add
-          i32.const 16
-          i32.shr_u
-          i32.const 2
-          i32.and
-          local.tee $1
-          i32.or
-          i32.sub
-          local.get $0
-          local.get $1
-          i32.shl
-          i32.const 15
-          i32.shr_u
-          i32.add
-          local.tee $0
-          i32.const 7
-          i32.add
-          i32.shr_u
-          i32.const 1
-          i32.and
-          local.get $0
-          i32.const 1
-          i32.shl
-          i32.or
-        end
-      else
-        i32.const 0
-      end
-      local.tee $1
-      i32.const 2
-      i32.shl
-      i32.const 3948
-      i32.add
-      local.set $0
-      local.get $3
-      local.get $1
-      i32.store offset=28
-      local.get $3
-      i32.const 0
-      i32.store offset=20
-      local.get $3
-      i32.const 0
-      i32.store offset=16
-      block $label$113 ;; label = @2
-        i32.const 3648
-        i32.load
-        local.tee $4
-        i32.const 1
-        local.get $1
-        i32.shl
-        local.tee $5
-        i32.and
-        if ;; label = @3
-          block ;; label = @4
-            local.get $0
-            i32.load
-            local.set $0
-            i32.const 25
-            local.get $1
-            i32.const 1
-            i32.shr_u
-            i32.sub
-            local.set $4
-            local.get $2
-            local.get $1
-            i32.const 31
-            i32.eq
-            if (result i32) ;; label = @5
-              i32.const 0
-            else
-              local.get $4
-            end
-            i32.shl
-            local.set $1
-            block $label$117 ;; label = @5
-              block $label$118 ;; label = @6
-                block $label$119 ;; label = @7
-                  loop $label$120 ;; label = @8
-                    local.get $0
-                    i32.load offset=4
-                    i32.const -8
-                    i32.and
-                    local.get $2
-                    i32.eq
-                    br_if 2 (;@6;)
-                    local.get $1
-                    i32.const 1
-                    i32.shl
-                    local.set $4
-                    local.get $0
-                    i32.const 16
-                    i32.add
-                    local.get $1
-                    i32.const 31
-                    i32.shr_u
-                    i32.const 2
-                    i32.shl
-                    i32.add
-                    local.tee $1
-                    i32.load
-                    local.tee $5
-                    i32.eqz
-                    br_if 1 (;@7;)
-                    local.get $4
-                    local.set $1
-                    local.get $5
-                    local.set $0
-                    br 0 (;@8;)
-                  end
-                end
-                local.get $1
-                i32.const 3660
-                i32.load
-                i32.lt_u
-                if ;; label = @7
-                  call $fimport$10
-                else
-                  block ;; label = @8
-                    local.get $1
-                    local.get $3
-                    i32.store
-                    local.get $3
-                    local.get $0
-                    i32.store offset=24
-                    local.get $3
-                    local.get $3
-                    i32.store offset=12
-                    local.get $3
-                    local.get $3
-                    i32.store offset=8
-                    br 6 (;@2;)
-                  end
-                end
-                br 1 (;@5;)
-              end
-              local.get $0
-              i32.const 8
-              i32.add
-              local.tee $1
-              i32.load
-              local.tee $2
-              i32.const 3660
-              i32.load
-              local.tee $4
-              i32.ge_u
-              local.get $0
-              local.get $4
-              i32.ge_u
-              i32.and
-              if ;; label = @6
-                block ;; label = @7
-                  local.get $2
-                  local.get $3
-                  i32.store offset=12
-                  local.get $1
-                  local.get $3
-                  i32.store
-                  local.get $3
-                  local.get $2
-                  i32.store offset=8
-                  local.get $3
-                  local.get $0
-                  i32.store offset=12
-                  local.get $3
-                  i32.const 0
-                  i32.store offset=24
-                end
-              else
-                call $fimport$10
-              end
-            end
-          end
-        else
-          block ;; label = @4
-            i32.const 3648
-            local.get $4
-            local.get $5
-            i32.or
-            i32.store
-            local.get $0
-            local.get $3
-            i32.store
-            local.get $3
-            local.get $0
-            i32.store offset=24
-            local.get $3
-            local.get $3
-            i32.store offset=12
-            local.get $3
-            local.get $3
-            i32.store offset=8
-          end
-        end
-      end
-      i32.const 3676
-      i32.const 3676
-      i32.load
-      i32.const -1
-      i32.add
-      local.tee $0
-      i32.store
-      local.get $0
-      if ;; label = @2
-        return
-      else
-        i32.const 4100
-        local.set $0
-      end
-      loop $label$128 ;; label = @2
-        local.get $0
-        i32.load
-        local.tee $2
-        i32.const 8
-        i32.add
-        local.set $0
-        local.get $2
-        br_if 0 (;@2;)
-      end
-      i32.const 3676
-      i32.const -1
-      i32.store
-    end
-  )
-  (func $33 (;46;) (type $6)
-    nop
-  )
-  (func $34 (;47;) (type $1) (param $0 i32) (result i32)
-    (local $1 i32) (local $2 i32)
-    block $label$1 (result i32) ;; label = @1
-      global.get $global$0
-      i32.load
-      local.tee $2
-      local.get $0
-      i32.const 15
-      i32.add
-      i32.const -16
-      i32.and
-      local.tee $0
-      i32.add
-      local.set $1
-      local.get $0
-      i32.const 0
-      i32.gt_s
-      local.get $1
-      local.get $2
-      i32.lt_s
-      i32.and
-      local.get $1
-      i32.const 0
-      i32.lt_s
-      i32.or
-      if ;; label = @2
-        block ;; label = @3
-          call $fimport$6
-          drop
-          i32.const 12
-          call $fimport$11
-          i32.const -1
-          return
-        end
-      end
-      global.get $global$0
-      local.get $1
-      i32.store
-      local.get $1
-      call $fimport$5
-      i32.gt_s
-      if ;; label = @2
-        call $fimport$4
-        i32.eqz
-        if ;; label = @3
-          block ;; label = @4
-            i32.const 12
-            call $fimport$11
-            global.get $global$0
-            local.get $2
-            i32.store
-            i32.const -1
-            return
-          end
-        end
-      end
-      local.get $2
-    end
-  )
-  (func $35 (;48;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32) (local $4 i32) (local $5 i32)
-    block $label$1 (result i32) ;; label = @1
-      local.get $0
-      local.get $2
-      i32.add
-      local.set $4
-      local.get $2
-      i32.const 20
-      i32.ge_s
-      if ;; label = @2
-        block ;; label = @3
-          local.get $1
-          i32.const 255
-          i32.and
-          local.set $1
-          local.get $0
-          i32.const 3
-          i32.and
-          local.tee $3
-          if ;; label = @4
-            block ;; label = @5
-              local.get $0
-              i32.const 4
-              i32.add
-              local.get $3
-              i32.sub
-              local.set $3
-              loop $label$4 ;; label = @6
-                local.get $0
-                local.get $3
-                i32.lt_s
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $0
-                    local.get $1
-                    i32.store8
-                    local.get $0
-                    i32.const 1
-                    i32.add
-                    local.set $0
-                    br 2 (;@6;)
-                  end
-                end
-              end
-            end
-          end
-          local.get $1
-          local.get $1
-          i32.const 8
-          i32.shl
-          i32.or
-          local.get $1
-          i32.const 16
-          i32.shl
-          i32.or
-          local.get $1
-          i32.const 24
-          i32.shl
-          i32.or
-          local.set $3
-          local.get $4
-          i32.const -4
-          i32.and
-          local.set $5
-          loop $label$6 ;; label = @4
-            local.get $0
-            local.get $5
-            i32.lt_s
-            if ;; label = @5
-              block ;; label = @6
-                local.get $0
-                local.get $3
-                i32.store
-                local.get $0
-                i32.const 4
-                i32.add
-                local.set $0
-                br 2 (;@4;)
-              end
-            end
-          end
-        end
-      end
-      loop $label$8 ;; label = @2
-        local.get $0
-        local.get $4
-        i32.lt_s
-        if ;; label = @3
-          block ;; label = @4
-            local.get $0
-            local.get $1
-            i32.store8
-            local.get $0
-            i32.const 1
-            i32.add
-            local.set $0
-            br 2 (;@2;)
-          end
-        end
-      end
-      local.get $0
-      local.get $2
-      i32.sub
-    end
-  )
-  (func $36 (;49;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    (local $3 i32)
-    block $label$1 (result i32) ;; label = @1
-      local.get $2
-      i32.const 4096
-      i32.ge_s
-      if ;; label = @2
-        local.get $0
-        local.get $1
-        local.get $2
-        call $fimport$12
-        return
-      end
-      local.get $0
-      local.set $3
-      local.get $0
-      i32.const 3
-      i32.and
-      local.get $1
-      i32.const 3
-      i32.and
-      i32.eq
-      if ;; label = @2
-        block ;; label = @3
-          loop $label$4 ;; label = @4
-            local.get $0
-            i32.const 3
-            i32.and
-            if ;; label = @5
-              block ;; label = @6
-                local.get $2
-                i32.eqz
-                if ;; label = @7
-                  local.get $3
-                  return
-                end
-                local.get $0
-                local.get $1
-                i32.load8_s
-                i32.store8
-                local.get $0
-                i32.const 1
-                i32.add
-                local.set $0
-                local.get $1
-                i32.const 1
-                i32.add
-                local.set $1
-                local.get $2
-                i32.const 1
-                i32.sub
-                local.set $2
-                br 2 (;@4;)
-              end
-            end
-          end
-          loop $label$7 ;; label = @4
-            local.get $2
-            i32.const 4
-            i32.ge_s
-            if ;; label = @5
-              block ;; label = @6
-                local.get $0
-                local.get $1
-                i32.load
-                i32.store
-                local.get $0
-                i32.const 4
-                i32.add
-                local.set $0
-                local.get $1
-                i32.const 4
-                i32.add
-                local.set $1
-                local.get $2
-                i32.const 4
-                i32.sub
-                local.set $2
-                br 2 (;@4;)
-              end
-            end
-          end
-        end
-      end
-      loop $label$9 ;; label = @2
-        local.get $2
-        i32.const 0
-        i32.gt_s
-        if ;; label = @3
-          block ;; label = @4
-            local.get $0
-            local.get $1
-            i32.load8_s
-            i32.store8
-            local.get $0
-            i32.const 1
-            i32.add
-            local.set $0
-            local.get $1
-            i32.const 1
-            i32.add
-            local.set $1
-            local.get $2
-            i32.const 1
-            i32.sub
-            local.set $2
-            br 2 (;@2;)
-          end
-        end
-      end
-      local.get $3
-    end
-  )
-  (func $37 (;50;) (type $3) (result i32)
-    i32.const 0
-  )
-  (func $38 (;51;) (type $4) (param $0 i32) (param $1 i32) (result i32)
-    local.get $1
-    local.get $0
-    i32.const 1
-    i32.and
-    i32.const 0
-    i32.add
-    call_indirect (type $1)
-  )
-  (func $39 (;52;) (type $12) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32)
-    local.get $1
-    local.get $2
-    local.get $3
-    local.get $0
-    i32.const 3
-    i32.and
-    i32.const 2
-    i32.add
-    call_indirect (type $0)
-  )
-  (func $40 (;53;) (type $5) (param $0 i32) (param $1 i32)
-    local.get $1
-    local.get $0
-    i32.const 1
-    i32.and
-    i32.const 6
-    i32.add
-    call_indirect (type $2)
-  )
-  (func $41 (;54;) (type $1) (param $0 i32) (result i32)
-    block $label$1 (result i32) ;; label = @1
-      i32.const 0
-      call $fimport$3
-      i32.const 0
-    end
-  )
-  (func $42 (;55;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    block $label$1 (result i32) ;; label = @1
-      i32.const 1
-      call $fimport$3
-      i32.const 0
-    end
-  )
-  (func $43 (;56;) (type $2) (param $0 i32)
-    i32.const 2
-    call $fimport$3
-  )
-  (global $global$0 (;5;) (mut i32) global.get $gimport$0)
-  (global $global$1 (;6;) (mut i32) global.get $gimport$1)
-  (global $global$2 (;7;) (mut i32) global.get $gimport$2)
-  (global $global$3 (;8;) (mut i32) i32.const 0)
-  (global $global$4 (;9;) (mut i32) i32.const 0)
-  (global $global$5 (;10;) (mut i32) i32.const 0)
-  (export "_sbrk" (func $34))
-  (export "_free" (func $32))
-  (export "_main" (func $7))
-  (export "_pthread_self" (func $37))
-  (export "_memset" (func $35))
-  (export "_malloc" (func $31))
-  (export "_memcpy" (func $36))
-  (export "___errno_location" (func $11))
-  (export "runPostSets" (func $33))
-  (export "stackAlloc" (func $0))
-  (export "stackSave" (func $1))
-  (export "stackRestore" (func $2))
-  (export "establishStackSpace" (func $3))
-  (export "setThrew" (func $4))
-  (export "setTempRet0" (func $5))
-  (export "getTempRet0" (func $6))
-  (export "dynCall_ii" (func $38))
-  (export "dynCall_iiii" (func $39))
-  (export "dynCall_vi" (func $40))
-  (elem (;0;) (global.get $gimport$19) func $41 $8 $42 $13 $9 $14 $43 $15)
-  (data (;0;) (i32.const 1024) "\04\04\00\00\05")
-  (data (;1;) (i32.const 1040) "\01")
-  (data (;2;) (i32.const 1064) "\01\00\00\00\02\00\00\004\10\00\00\00\04")
-  (data (;3;) (i32.const 1088) "\01")
-  (data (;4;) (i32.const 1103) "\0a\ff\ff\ff\ff")
-  (data (;5;) (i32.const 1140) "error: %d\5cn\00lastprime: %d.\0a\00\11\00\0a\00\11\11\11\00\00\00\00\05\00\00\00\00\00\00\09\00\00\00\00\0b")
-  (data (;6;) (i32.const 1200) "\11\00\0f\0a\11\11\11\03\0a\07\00\01\13\09\0b\0b\00\00\09\06\0b\00\00\0b\00\06\11\00\00\00\11\11\11")
-  (data (;7;) (i32.const 1249) "\0b")
-  (data (;8;) (i32.const 1258) "\11\00\0a\0a\11\11\11\00\0a\00\00\02\00\09\0b\00\00\00\09\00\0b\00\00\0b")
-  (data (;9;) (i32.const 1307) "\0c")
-  (data (;10;) (i32.const 1319) "\0c\00\00\00\00\0c\00\00\00\00\09\0c\00\00\00\00\00\0c\00\00\0c")
-  (data (;11;) (i32.const 1365) "\0e")
-  (data (;12;) (i32.const 1377) "\0d\00\00\00\04\0d\00\00\00\00\09\0e\00\00\00\00\00\0e\00\00\0e")
-  (data (;13;) (i32.const 1423) "\10")
-  (data (;14;) (i32.const 1435) "\0f\00\00\00\00\0f\00\00\00\00\09\10\00\00\00\00\00\10\00\00\10\00\00\12\00\00\00\12\12\12")
-  (data (;15;) (i32.const 1490) "\12\00\00\00\12\12\12\00\00\00\00\00\00\09")
-  (data (;16;) (i32.const 1539) "\0b")
-  (data (;17;) (i32.const 1551) "\0a\00\00\00\00\0a\00\00\00\00\09\0b\00\00\00\00\00\0b\00\00\0b")
-  (data (;18;) (i32.const 1597) "\0c")
-  (data (;19;) (i32.const 1609) "\0c\00\00\00\00\0c\00\00\00\00\09\0c\00\00\00\00\00\0c\00\00\0c\00\000123456789ABCDEF-+   0X0x\00(null)\00-0X+0X 0X-0x+0x 0x\00inf\00INF\00nan\00NAN\00.\00T!\22\19\0d\01\02\03\11K\1c\0c\10\04\0b\1d\12\1e'hnopqb \05\06\0f\13\14\15\1a\08\16\07($\17\18\09\0a\0e\1b\1f%#\83\82}&*+<=>?CGJMXYZ[\5c]^_`acdefgijklrstyz{|\00Illegal byte sequence\00Domain error\00Result not representable\00Not a tty\00Permission denied\00Operation not permitted\00No such file or directory\00No such process\00File exists\00Value too large for data type\00No space left on device\00Out of memory\00Resource busy\00Interrupted system call\00Resource temporarily unavailable\00Invalid seek\00Cross-device link\00Read-only file system\00Directory not empty\00Connection reset by peer\00Operation timed out\00Connection refused\00Host is down\00Host is unreachable\00Address in use\00Broken pipe\00I/O error\00No such device or address\00Block device required\00No such device\00Not a directory\00Is a directory\00Text file busy\00Exec format error\00Invalid argument\00Argument list too long\00Symbolic link loop\00Filename too long\00Too many open files in system\00No file descriptors available\00Bad file descriptor\00No child process\00Bad address\00File too large\00Too many links\00No locks available\00Resource deadlock would occur\00State not recoverable\00Previous owner died\00Operation canceled\00Function not implemented\00No message of desired type\00Identifier removed\00Device not a stream\00No data available\00Device timeout\00Out of streams resources\00Link has been severed\00Protocol error\00Bad message\00File descriptor in bad state\00Not a socket\00Destination address required\00Message too large\00Protocol wrong type for socket\00Protocol not available\00Protocol not supported\00Socket type not supported\00Not supported\00Protocol family not supported\00Address family not supported by protocol\00Address not available\00Network is down\00Network unreachable\00Connection reset by network\00Connection aborted\00No buffer space available\00Socket is connected\00Socket not connected\00Cannot send after socket shutdown\00Operation already in progress\00Operation in progress\00Stale file handle\00Remote I/O error\00Quota exceeded\00No medium found\00Wrong medium type\00No error information")
-)
\ No newline at end of file
diff --git a/cranelift/wasm/wasmtests/fac-multi-value.wat b/cranelift/wasm/wasmtests/fac-multi-value.wat
deleted file mode 100644
index ad5e3d9a04c7..000000000000
--- a/cranelift/wasm/wasmtests/fac-multi-value.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-(module
-  ;; Iterative factorial without locals.
-  (func $pick0 (param i64) (result i64 i64)
-    (local.get 0) (local.get 0)
-  )
-  (func $pick1 (param i64 i64) (result i64 i64 i64)
-    (local.get 0) (local.get 1) (local.get 0)
-  )
-  (func (export "fac-ssa") (param i64) (result i64)
-    (i64.const 1) (local.get 0)
-    (loop $l (param i64 i64) (result i64)
-      (call $pick1) (call $pick1) (i64.mul)
-      (call $pick1) (i64.const 1) (i64.sub)
-      (call $pick0) (i64.const 0) (i64.gt_u)
-      (br_if $l)
-      (drop) (return)
-    )
-  )
-)
diff --git a/cranelift/wasm/wasmtests/fibonacci.wat b/cranelift/wasm/wasmtests/fibonacci.wat
deleted file mode 100644
index a40b2c91e442..000000000000
--- a/cranelift/wasm/wasmtests/fibonacci.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-(module
-  (memory 1)
-  (func $main (local i32 i32 i32 i32)
-    (local.set 0 (i32.const 0))
-    (local.set 1 (i32.const 1))
-    (local.set 2 (i32.const 1))
-    (local.set 3 (i32.const 0))
-    (block
-    (loop
-        (br_if 1 (i32.gt_s (local.get 0) (i32.const 5)))
-        (local.set 3 (local.get 2))
-        (local.set 2 (i32.add (local.get 2) (local.get 1)))
-        (local.set 1 (local.get 3))
-        (local.set 0 (i32.add (local.get 0) (i32.const 1)))
-        (br 0)
-    )
-    )
-    (i32.store (i32.const 0) (local.get 2))
-  )
-  (start $main)
-  (data (i32.const 0) "0000")
-)
diff --git a/cranelift/wasm/wasmtests/globals.wat b/cranelift/wasm/wasmtests/globals.wat
deleted file mode 100644
index fb9a591172bc..000000000000
--- a/cranelift/wasm/wasmtests/globals.wat
+++ /dev/null
@@ -1,8 +0,0 @@
-(module
-  (global $x (mut i32) (i32.const 4))
-  (memory 1)
-  (func $main (local i32)
-    (i32.store (i32.const 0) (global.get $x))
-  )
-  (start $main)
-)
diff --git a/cranelift/wasm/wasmtests/icall-simd.wat b/cranelift/wasm/wasmtests/icall-simd.wat
deleted file mode 100644
index d656b265b96a..000000000000
--- a/cranelift/wasm/wasmtests/icall-simd.wat
+++ /dev/null
@@ -1,7 +0,0 @@
-(module
-  (type $ft (func (param v128) (result v128)))
-  (func $foo (export "foo") (param i32) (param v128) (result v128)
-    (call_indirect (type $ft) (local.get 1) (local.get 0))
-  )
-  (table (;0;) 23 23 anyfunc)
-)
diff --git a/cranelift/wasm/wasmtests/icall.wat b/cranelift/wasm/wasmtests/icall.wat
deleted file mode 100644
index f1dde0eafea5..000000000000
--- a/cranelift/wasm/wasmtests/icall.wat
+++ /dev/null
@@ -1,7 +0,0 @@
-(module
-  (type $ft (func (param f32) (result i32)))
-  (func $foo (export "foo") (param i32 f32) (result i32)
-    (call_indirect (type $ft) (local.get 1) (local.get 0))
-  )
-  (table (;0;) 23 23 anyfunc)
-)
diff --git a/cranelift/wasm/wasmtests/if-reachability-translation-0.wat b/cranelift/wasm/wasmtests/if-reachability-translation-0.wat
deleted file mode 100644
index 54145a9d4eb7..000000000000
--- a/cranelift/wasm/wasmtests/if-reachability-translation-0.wat
+++ /dev/null
@@ -1,12 +0,0 @@
-;; An unreachable `if` means that the consequent, alternative, and following
-;; block are also unreachable.
-
-(module
-  (func (param i32) (result i32)
-    unreachable
-    if  ;; label = @2
-      nop
-    else
-      nop
-    end
-    i32.const 0))
diff --git a/cranelift/wasm/wasmtests/if-reachability-translation-1.wat b/cranelift/wasm/wasmtests/if-reachability-translation-1.wat
deleted file mode 100644
index 6e1e6121f45e..000000000000
--- a/cranelift/wasm/wasmtests/if-reachability-translation-1.wat
+++ /dev/null
@@ -1,12 +0,0 @@
-;; Reachable `if` head and reachable consequent and alternative means that the
-;; following block is also reachable.
-
-(module
-  (func (param i32) (result i32)
-    local.get 0
-    if  ;; label = @2
-      nop
-    else
-      nop
-    end
-    i32.const 0))
diff --git a/cranelift/wasm/wasmtests/if-reachability-translation-2.wat b/cranelift/wasm/wasmtests/if-reachability-translation-2.wat
deleted file mode 100644
index 4bbaf99820b0..000000000000
--- a/cranelift/wasm/wasmtests/if-reachability-translation-2.wat
+++ /dev/null
@@ -1,12 +0,0 @@
-;; Reachable `if` head and unreachable consequent and reachable alternative
-;; means that the following block is also reachable.
-
-(module
-  (func (param i32) (result i32)
-    local.get 0
-    if
-      unreachable
-    else
-      nop
-    end
-    i32.const 0))
diff --git a/cranelift/wasm/wasmtests/if-reachability-translation-3.wat b/cranelift/wasm/wasmtests/if-reachability-translation-3.wat
deleted file mode 100644
index 72251cba1674..000000000000
--- a/cranelift/wasm/wasmtests/if-reachability-translation-3.wat
+++ /dev/null
@@ -1,12 +0,0 @@
-;; Reachable `if` head and consequent and unreachable alternative means that the
-;; following block is also reachable.
-
-(module
-  (func (param i32) (result i32)
-    local.get 0
-    if
-      nop
-    else
-      unreachable
-    end
-    i32.const 0))
diff --git a/cranelift/wasm/wasmtests/if-reachability-translation-4.wat b/cranelift/wasm/wasmtests/if-reachability-translation-4.wat
deleted file mode 100644
index b8a406943077..000000000000
--- a/cranelift/wasm/wasmtests/if-reachability-translation-4.wat
+++ /dev/null
@@ -1,12 +0,0 @@
-;; Reachable `if` head and unreachable consequent and alternative means that the
-;; following block is unreachable.
-
-(module
-  (func (param i32) (result i32)
-    local.get 0
-    if
-      unreachable
-    else
-      unreachable
-    end
-    i32.const 0))
diff --git a/cranelift/wasm/wasmtests/if-reachability-translation-5.wat b/cranelift/wasm/wasmtests/if-reachability-translation-5.wat
deleted file mode 100644
index 7b1f665e056d..000000000000
--- a/cranelift/wasm/wasmtests/if-reachability-translation-5.wat
+++ /dev/null
@@ -1,14 +0,0 @@
-;; Reachable `if` head and unreachable consequent and alternative, but with a
-;; branch out of the consequent, means that the following block is reachable.
-
-(module
-  (func (param i32 i32) (result i32)
-    local.get 0
-    if
-      local.get 1
-      br_if 0
-      unreachable
-    else
-      unreachable
-    end
-    i32.const 0))
diff --git a/cranelift/wasm/wasmtests/if-reachability-translation-6.wat b/cranelift/wasm/wasmtests/if-reachability-translation-6.wat
deleted file mode 100644
index d9da824f14c4..000000000000
--- a/cranelift/wasm/wasmtests/if-reachability-translation-6.wat
+++ /dev/null
@@ -1,14 +0,0 @@
-;; Reachable `if` head and unreachable consequent and alternative, but with a
-;; branch out of the alternative, means that the following block is reachable.
-
-(module
-  (func (param i32 i32) (result i32)
-    local.get 0
-    if
-      unreachable
-    else
-      local.get 1
-      br_if 0
-      unreachable
-    end
-    i32.const 0))
diff --git a/cranelift/wasm/wasmtests/if-unreachable-else-params-2.wat b/cranelift/wasm/wasmtests/if-unreachable-else-params-2.wat
deleted file mode 100644
index 369ea4db6524..000000000000
--- a/cranelift/wasm/wasmtests/if-unreachable-else-params-2.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-(module
-  (type (;0;) (func (param i32 i32) (result f64)))
-  (func $main (type 0) (param i32 i32) (result f64)
-    f64.const 1.0
-    local.get 0
-    local.get 1
-    if (param i32)  ;; label = @2
-      i64.load16_s align=1
-      drop
-    else
-      unreachable
-    end)
-  (table (;0;) 63 255 funcref)
-  (memory (;0;) 13 16)
-  (export "t1" (table 0))
-  (export "m1" (memory 0))
-  (export "main" (func $main))
-  (export "memory" (memory 0)))
diff --git a/cranelift/wasm/wasmtests/if-unreachable-else-params.wat b/cranelift/wasm/wasmtests/if-unreachable-else-params.wat
deleted file mode 100644
index 02e2d50f9510..000000000000
--- a/cranelift/wasm/wasmtests/if-unreachable-else-params.wat
+++ /dev/null
@@ -1,41 +0,0 @@
-(module
-  (type (;0;) (func (param i32)))
-  (func $main (type 0) (param i32)
-    i32.const 35
-    loop (param i32)  ;; label = @1
-      local.get 0
-      if (param i32)  ;; label = @2
-        i64.load16_s align=1
-        unreachable
-        unreachable
-        unreachable
-        unreachable
-        unreachable
-        local.get 0
-        unreachable
-        unreachable
-        i64.load8_u offset=11789
-        unreachable
-      else
-        i32.popcnt
-        local.set 0
-        return
-        unreachable
-      end
-      unreachable
-      unreachable
-      nop
-      f32.lt
-      i32.store8 offset=82
-      unreachable
-    end
-    unreachable
-    unreachable
-    unreachable
-    unreachable)
-  (table (;0;) 63 255 funcref)
-  (memory (;0;) 13 16)
-  (export "t1" (table 0))
-  (export "m1" (memory 0))
-  (export "main" (func $main))
-  (export "memory" (memory 0)))
diff --git a/cranelift/wasm/wasmtests/issue-1306-name-section-with-u32-max-function-index.wasm b/cranelift/wasm/wasmtests/issue-1306-name-section-with-u32-max-function-index.wasm
deleted file mode 100644
index 79d8dc33881d..000000000000
Binary files a/cranelift/wasm/wasmtests/issue-1306-name-section-with-u32-max-function-index.wasm and /dev/null differ
diff --git a/cranelift/wasm/wasmtests/memory.wat b/cranelift/wasm/wasmtests/memory.wat
deleted file mode 100644
index 0c81bad174de..000000000000
--- a/cranelift/wasm/wasmtests/memory.wat
+++ /dev/null
@@ -1,11 +0,0 @@
-(module
-  (memory 1)
-  (func $main (local i32)
-    (i32.store (i32.const 0) (i32.const 0x0))
-    (if (i32.load (i32.const 0))
-        (then (i32.store (i32.const 0) (i32.const 0xa)))
-        (else (i32.store (i32.const 0) (i32.const 0xb))))
-  )
-  (start $main)
-  (data (i32.const 0) "0000")
-)
diff --git a/cranelift/wasm/wasmtests/multi-0.wat b/cranelift/wasm/wasmtests/multi-0.wat
deleted file mode 100644
index 806493918c30..000000000000
--- a/cranelift/wasm/wasmtests/multi-0.wat
+++ /dev/null
@@ -1,3 +0,0 @@
-(module
-  (func (export "i64.dup") (param i64) (result i64 i64)
-    (local.get 0) (local.get 0)))
diff --git a/cranelift/wasm/wasmtests/multi-1.wat b/cranelift/wasm/wasmtests/multi-1.wat
deleted file mode 100644
index a81464741938..000000000000
--- a/cranelift/wasm/wasmtests/multi-1.wat
+++ /dev/null
@@ -1,6 +0,0 @@
-(module
-  (func (export "multiBlock") (param i64 i32) (result i32 i64 f64)
-    (local.get 1)
-    (local.get 0)
-    (block (param i32 i64) (result i32 i64 f64)
-      (f64.const 1234.5))))
diff --git a/cranelift/wasm/wasmtests/multi-10.wat b/cranelift/wasm/wasmtests/multi-10.wat
deleted file mode 100644
index 01fbf4294152..000000000000
--- a/cranelift/wasm/wasmtests/multi-10.wat
+++ /dev/null
@@ -1,10 +0,0 @@
-(module
-  (func (export "f") (param i64 i32) (result i64 i64)
-    (local.get 0)
-    (local.get 1)
-    ;; If with else. Fewer params than results.
-    (if (param i64) (result i64 i64)
-      (then
-        (i64.const -1))
-      (else
-        (i64.const -2)))))
diff --git a/cranelift/wasm/wasmtests/multi-11.wat b/cranelift/wasm/wasmtests/multi-11.wat
deleted file mode 100644
index 1ae75889bc46..000000000000
--- a/cranelift/wasm/wasmtests/multi-11.wat
+++ /dev/null
@@ -1,7 +0,0 @@
-(module
-  (func (export "multiLoop") (param i64) (result i64 i64)
-    (local.get 0)
-    ;; Fewer params than results.
-    (loop (param i64) (result i64 i64)
-      i64.const 42
-      return)))
diff --git a/cranelift/wasm/wasmtests/multi-12.wat b/cranelift/wasm/wasmtests/multi-12.wat
deleted file mode 100644
index 9a3e4f7fb54c..000000000000
--- a/cranelift/wasm/wasmtests/multi-12.wat
+++ /dev/null
@@ -1,9 +0,0 @@
-(module
-  (func (export "multiLoop") (param i64 i64 i64) (result i64 i64)
-    (local.get 2)
-    (local.get 1)
-    (local.get 0)
-    ;; More params than results.
-    (loop (param i64 i64 i64) (result i64 i64)
-      drop
-      return)))
diff --git a/cranelift/wasm/wasmtests/multi-13.wat b/cranelift/wasm/wasmtests/multi-13.wat
deleted file mode 100644
index 4f4846300eca..000000000000
--- a/cranelift/wasm/wasmtests/multi-13.wat
+++ /dev/null
@@ -1,10 +0,0 @@
-(module
-  (func (export "as-if-then") (param i32 i32) (result i32)
-    (block (result i32)
-      (if (result i32) (local.get 0)
-        (then (br 1 (i32.const 3)))
-        (else (local.get 1))
-      )
-    )
-  )
-)
diff --git a/cranelift/wasm/wasmtests/multi-14.wat b/cranelift/wasm/wasmtests/multi-14.wat
deleted file mode 100644
index 26d0cb596a5b..000000000000
--- a/cranelift/wasm/wasmtests/multi-14.wat
+++ /dev/null
@@ -1,10 +0,0 @@
-(module
-  (func (export "as-if-else") (param i32 i32) (result i32)
-    (block (result i32)
-      (if (result i32) (local.get 0)
-        (then (local.get 1))
-        (else (br 1 (i32.const 4)))
-      )
-    )
-  )
-)
diff --git a/cranelift/wasm/wasmtests/multi-15.wat b/cranelift/wasm/wasmtests/multi-15.wat
deleted file mode 100644
index 2f017bd6aab2..000000000000
--- a/cranelift/wasm/wasmtests/multi-15.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-(module
-  (func (export "large-sig")
-    (param i32 i64 f32 f32 i32 f64 f32 i32 i32 i32 f32 f64 f64 f64 i32 i32 f32)
-    (result f64 f32 i32 i32 i32 i64 f32 i32 i32 f32 f64 f64 i32 f32 i32 f64)
-    (local.get 5)
-    (local.get 2)
-    (local.get 0)
-    (local.get 8)
-    (local.get 7)
-    (local.get 1)
-    (local.get 3)
-    (local.get 9)
-    (local.get 4)
-    (local.get 6)
-    (local.get 13)
-    (local.get 11)
-    (local.get 15)
-    (local.get 16)
-    (local.get 14)
-    (local.get 12)
-  )
-)
diff --git a/cranelift/wasm/wasmtests/multi-16.wat b/cranelift/wasm/wasmtests/multi-16.wat
deleted file mode 100644
index 1e60aa8cc81a..000000000000
--- a/cranelift/wasm/wasmtests/multi-16.wat
+++ /dev/null
@@ -1,9 +0,0 @@
-(module
-  (func (export "param") (param i32) (result i32)
-    (i32.const 1)
-    (if (param i32) (result i32) (local.get 0)
-      (then (i32.const 2) (i32.add))
-      (else (i32.const -2) (i32.add))
-    )
-  )
-)
diff --git a/cranelift/wasm/wasmtests/multi-17.wat b/cranelift/wasm/wasmtests/multi-17.wat
deleted file mode 100644
index e190851e85f3..000000000000
--- a/cranelift/wasm/wasmtests/multi-17.wat
+++ /dev/null
@@ -1,26 +0,0 @@
-(module
-  (func $main (type 0) (param i32 i32 i32) (result i32)
-    i32.const 0
-    i32.const 0
-    i32.const 0
-    i32.const 0
-
-    i32.const 0
-    if (param i32 i32 i32) (result i32)  ;; label = @1
-      br 0 (;@1;)
-    else
-      call $main
-    end
-
-    i32.const 0
-
-    i32.const 0
-    if (param i32 i32 i32) (result i32)  ;; label = @1
-      drop
-      drop
-    else
-      drop
-      drop
-    end
-  )
-  (export "main" (func $main)))
diff --git a/cranelift/wasm/wasmtests/multi-2.wat b/cranelift/wasm/wasmtests/multi-2.wat
deleted file mode 100644
index 6f2a7378b101..000000000000
--- a/cranelift/wasm/wasmtests/multi-2.wat
+++ /dev/null
@@ -1,6 +0,0 @@
-(module
-  (func (export "multiLoop") (param i64 i64) (result i64 i64)
-    (local.get 1)
-    (local.get 0)
-    (loop (param i64 i64) (result i64 i64)
-       return)))
diff --git a/cranelift/wasm/wasmtests/multi-3.wat b/cranelift/wasm/wasmtests/multi-3.wat
deleted file mode 100644
index d58071f9c742..000000000000
--- a/cranelift/wasm/wasmtests/multi-3.wat
+++ /dev/null
@@ -1,13 +0,0 @@
-(module
-  (func (export "multiIf") (param i32 i64 i64) (result i64 i64)
-    (local.get 2)
-    (local.get 1)
-    (local.get 0)
-    (if (param i64 i64) (result i64 i64)
-      (then return)
-      ;; Hits the code path for an `else` after a block that ends unreachable.
-      (else
-        (drop)
-        (drop)
-        (i64.const 0)
-        (i64.const 0)))))
diff --git a/cranelift/wasm/wasmtests/multi-4.wat b/cranelift/wasm/wasmtests/multi-4.wat
deleted file mode 100644
index 9c028531d31b..000000000000
--- a/cranelift/wasm/wasmtests/multi-4.wat
+++ /dev/null
@@ -1,13 +0,0 @@
-(module
-  (func (export "multiIf2") (param i32 i64 i64) (result i64 i64)
-    (local.get 2)
-    (local.get 1)
-    (local.get 0)
-    (if (param i64 i64) (result i64 i64)
-      (then
-        i64.add
-        i64.const 1)
-      ;; Hits the code path for an `else` after a block that does not end unreachable.
-      (else
-        i64.sub
-        i64.const 2))))
diff --git a/cranelift/wasm/wasmtests/multi-5.wat b/cranelift/wasm/wasmtests/multi-5.wat
deleted file mode 100644
index 92944770f9e8..000000000000
--- a/cranelift/wasm/wasmtests/multi-5.wat
+++ /dev/null
@@ -1,11 +0,0 @@
-(module
-  (func (export "foo")
-    i32.const 1
-    i64.const 2
-    ;; More params than results.
-    (block (param i32 i64) (result i32)
-      drop
-    )
-    drop
-  )
-)
diff --git a/cranelift/wasm/wasmtests/multi-6.wat b/cranelift/wasm/wasmtests/multi-6.wat
deleted file mode 100644
index c1135a1187ec..000000000000
--- a/cranelift/wasm/wasmtests/multi-6.wat
+++ /dev/null
@@ -1,11 +0,0 @@
-(module
-  (func (export "foo")
-    i32.const 1
-    ;; Fewer params than results.
-    (block (param i32) (result i32 i64)
-      i64.const 2
-    )
-    drop
-    drop
-  )
-)
diff --git a/cranelift/wasm/wasmtests/multi-7.wat b/cranelift/wasm/wasmtests/multi-7.wat
deleted file mode 100644
index c4545ba26cb5..000000000000
--- a/cranelift/wasm/wasmtests/multi-7.wat
+++ /dev/null
@@ -1,9 +0,0 @@
-(module
-  (func (export "f") (param i64 i32) (result i64)
-    (local.get 0)
-    (local.get 1)
-    ;; If with no else. Same number of params and results.
-    (if (param i64) (result i64)
-      (then
-        (drop)
-        (i64.const -1)))))
diff --git a/cranelift/wasm/wasmtests/multi-8.wat b/cranelift/wasm/wasmtests/multi-8.wat
deleted file mode 100644
index 1bc23f9f5d07..000000000000
--- a/cranelift/wasm/wasmtests/multi-8.wat
+++ /dev/null
@@ -1,12 +0,0 @@
-(module
-  (func (export "f") (param i64 i32) (result i64)
-    (local.get 0)
-    (local.get 1)
-    ;; If with else. Same number of params and results.
-    (if (param i64) (result i64)
-      (then
-        (drop)
-        (i64.const -1))
-      (else
-        (drop)
-        (i64.const -2)))))
diff --git a/cranelift/wasm/wasmtests/multi-9.wat b/cranelift/wasm/wasmtests/multi-9.wat
deleted file mode 100644
index d0cecf71b2b4..000000000000
--- a/cranelift/wasm/wasmtests/multi-9.wat
+++ /dev/null
@@ -1,15 +0,0 @@
-(module
-  (func (export "f") (param i64 i32) (result i64)
-    (local.get 0)
-    (local.get 1)
-    (local.get 1)
-    ;; If with else. More params than results.
-    (if (param i64 i32) (result i64)
-      (then
-        (drop)
-        (drop)
-        (i64.const -1))
-      (else
-        (drop)
-        (drop)
-        (i64.const -2)))))
diff --git a/cranelift/wasm/wasmtests/nullref.wat b/cranelift/wasm/wasmtests/nullref.wat
deleted file mode 100644
index 5dbdcc29a281..000000000000
--- a/cranelift/wasm/wasmtests/nullref.wat
+++ /dev/null
@@ -1,11 +0,0 @@
-(module
-	(func (result externref)
-		(ref.null extern)
-	)
-
-	(func (result externref)
-		(block (result externref)
-			(ref.null extern)
-		)
-	)
-)
diff --git a/cranelift/wasm/wasmtests/passive-data.wat b/cranelift/wasm/wasmtests/passive-data.wat
deleted file mode 100644
index 00d3b2c849ae..000000000000
--- a/cranelift/wasm/wasmtests/passive-data.wat
+++ /dev/null
@@ -1,12 +0,0 @@
-(module
-  (data $passive "this is a passive data segment")
-  (memory 0)
-
-  (func (export "init") (param i32 i32 i32)
-    local.get 0 ;; dst
-    local.get 1 ;; src
-    local.get 2 ;; cnt
-    memory.init $passive)
-
-  (func (export "drop")
-    data.drop $passive))
diff --git a/cranelift/wasm/wasmtests/pr2303.wat b/cranelift/wasm/wasmtests/pr2303.wat
deleted file mode 100644
index f86831e3eeb2..000000000000
--- a/cranelift/wasm/wasmtests/pr2303.wat
+++ /dev/null
@@ -1,15 +0,0 @@
-(module
-    (memory (export "mem") 1 1)
-    (func (export "runif") (param $cond i32)
-      i32.const 48
-      (v128.load (i32.const 0))
-      (v128.load (i32.const 16))
-      (if (param v128) (param v128) (result v128 v128)
-          (local.get $cond)
-          (then i64x2.add
-                (v128.load (i32.const 32)))
-          (else i32x4.sub
-                (v128.load (i32.const 0))))
-      i16x8.mul
-      v128.store)
-)
diff --git a/cranelift/wasm/wasmtests/pr2559.wat b/cranelift/wasm/wasmtests/pr2559.wat
deleted file mode 100644
index 8cf50677c891..000000000000
--- a/cranelift/wasm/wasmtests/pr2559.wat
+++ /dev/null
@@ -1,51 +0,0 @@
-(module
-  (type (;0;) (func (result v128 v128 v128)))
-
-  (func $main1 (type 0) (result v128 v128 v128)
-    call $main1
-    i8x16.add
-    call $main1
-    i8x16.ge_u
-    i16x8.ne
-    i32.const 13
-    br_if 0 (;@0;)
-    i32.const 43
-    br_if 0 (;@0;)
-    i32.const 13
-    br_if 0 (;@0;)
-    i32.const 87
-    select
-    unreachable
-    i32.const 0
-    br_if 0 (;@0;)
-    i32.const 13
-    br_if 0 (;@0;)
-    i32.const 43
-    br_if 0 (;@0;)
-  )
-  (export "main1" (func $main1))
-
-  (func $main2 (type 0) (result v128 v128 v128)
-    call $main2
-    i8x16.add
-    call $main2
-    i8x16.ge_u
-    i16x8.ne
-    i32.const 13
-    br_if 0 (;@0;)
-    i32.const 43
-    br_if 0 (;@0;)
-    i32.const 13
-    br_if 0 (;@0;)
-    i32.const 87
-    select (result v128)
-    unreachable
-    i32.const 0
-    br_if 0 (;@0;)
-    i32.const 13
-    br_if 0 (;@0;)
-    i32.const 43
-    br_if 0 (;@0;)
-  )
-  (export "main2" (func $main2))
-)
diff --git a/cranelift/wasm/wasmtests/ref-func-0.wat b/cranelift/wasm/wasmtests/ref-func-0.wat
deleted file mode 100644
index 4cdee3f567da..000000000000
--- a/cranelift/wasm/wasmtests/ref-func-0.wat
+++ /dev/null
@@ -1,12 +0,0 @@
-(module
-  (func $imported (import "env" "f") (param i32) (result i32))
-  (func $local (result externref externref funcref funcref)
-    global.get 0
-    global.get 1
-    global.get 2
-    global.get 3)
-
-  (global (export "externref-imported") externref (ref.null extern))
-  (global (export "externref-local") externref (ref.null extern))
-  (global (export "funcref-imported") funcref (ref.func $imported))
-  (global (export "funcref-local") funcref (ref.func $local)))
diff --git a/cranelift/wasm/wasmtests/rust_fannkuch.wat b/cranelift/wasm/wasmtests/rust_fannkuch.wat
deleted file mode 100644
index c61f08c67a98..000000000000
--- a/cranelift/wasm/wasmtests/rust_fannkuch.wat
+++ /dev/null
@@ -1,1723 +0,0 @@
-(module
-  (type $0 (;0;) (func (param i32 i32 i32) (result i32)))
-  (type $1 (;1;) (func (param i32 i32) (result i32)))
-  (type $2 (;2;) (func (param i32)))
-  (type $3 (;3;) (func (param i32) (result i32)))
-  (type $4 (;4;) (func (param i32 i32)))
-  (type $5 (;5;) (func (param i64 i32) (result i32)))
-  (type $6 (;6;) (func (param i32) (result i64)))
-  (type $7 (;7;) (func))
-  (type $8 (;8;) (func (param i32 i32)))
-  (type $9 (;9;) (func (param i32 i32 i32) (result i32)))
-  (func $0 (;0;) (type $7)
-    (local $0 i32) (local $1 i32)
-    i32.const 1
-    local.set $0
-    block $label$1 ;; label = @1
-      block $label$2 ;; label = @2
-        block $label$3 ;; label = @3
-          i32.const 1049232
-          i32.load
-          i32.const 1
-          i32.eq
-          if ;; label = @4
-            block ;; label = @5
-              i32.const 1049236
-              i32.const 1049236
-              i32.load
-              i32.const 1
-              i32.add
-              local.tee $0
-              i32.store
-              local.get $0
-              i32.const 3
-              i32.lt_u
-              br_if 2 (;@3;)
-              br 3 (;@2;)
-            end
-          end
-          i32.const 1049232
-          i64.const 4294967297
-          i64.store
-        end
-        i32.const 1049240
-        i32.load
-        local.tee $1
-        i32.const -1
-        i32.le_s
-        br_if 0 (;@2;)
-        i32.const 1049240
-        local.get $1
-        i32.store
-        local.get $0
-        i32.const 2
-        i32.lt_u
-        br_if 1 (;@1;)
-      end
-      unreachable
-    end
-    unreachable
-  )
-  (func $1 (;1;) (type $2) (param $0 i32)
-    (local $1 i32)
-    global.get $global$0
-    i32.const 16
-    i32.sub
-    local.tee $1
-    global.set $global$0
-    local.get $0
-    i32.load offset=8
-    i32.eqz
-    if ;; label = @1
-      block ;; label = @2
-        i32.const 1049172
-        call $2
-        unreachable
-      end
-    end
-    local.get $1
-    local.get $0
-    i32.const 20
-    i32.add
-    i64.load align=4
-    i64.store offset=8
-    local.get $1
-    local.get $0
-    i64.load offset=12 align=4
-    i64.store
-    call $0
-    unreachable
-  )
-  (func $2 (;2;) (type $2) (param $0 i32)
-    (local $1 i32) (local $2 i64) (local $3 i64) (local $4 i64)
-    global.get $global$0
-    i32.const 48
-    i32.sub
-    local.tee $1
-    global.set $global$0
-    local.get $0
-    i64.load offset=8 align=4
-    local.set $2
-    local.get $0
-    i64.load offset=16 align=4
-    local.set $3
-    local.get $0
-    i64.load align=4
-    local.set $4
-    local.get $1
-    i32.const 20
-    i32.add
-    i32.const 0
-    i32.store
-    local.get $1
-    local.get $4
-    i64.store offset=24
-    local.get $1
-    i32.const 1048656
-    i32.store offset=16
-    local.get $1
-    i64.const 1
-    i64.store offset=4 align=4
-    local.get $1
-    local.get $1
-    i32.const 24
-    i32.add
-    i32.store
-    local.get $1
-    local.get $3
-    i64.store offset=40
-    local.get $1
-    local.get $2
-    i64.store offset=32
-    local.get $1
-    local.get $1
-    i32.const 32
-    i32.add
-    call $5
-    unreachable
-  )
-  (func $3 (;3;) (type $8) (param $0 i32) (param $1 i32)
-    (local $2 i32)
-    global.get $global$0
-    i32.const 48
-    i32.sub
-    local.tee $2
-    global.set $global$0
-    local.get $2
-    i32.const 16
-    i32.store offset=4
-    local.get $2
-    local.get $1
-    i32.store
-    local.get $2
-    i32.const 44
-    i32.add
-    i32.const 1
-    i32.store
-    local.get $2
-    i32.const 28
-    i32.add
-    i32.const 2
-    i32.store
-    local.get $2
-    i32.const 1
-    i32.store offset=36
-    local.get $2
-    i64.const 2
-    i64.store offset=12 align=4
-    local.get $2
-    i32.const 1049140
-    i32.store offset=8
-    local.get $2
-    local.get $2
-    i32.store offset=40
-    local.get $2
-    local.get $2
-    i32.const 4
-    i32.add
-    i32.store offset=32
-    local.get $2
-    local.get $2
-    i32.const 32
-    i32.add
-    i32.store offset=24
-    local.get $2
-    i32.const 8
-    i32.add
-    local.get $0
-    call $5
-    unreachable
-  )
-  (func $4 (;4;) (type $1) (param $0 i32) (param $1 i32) (result i32)
-    local.get $0
-    i64.load32_u
-    local.get $1
-    call $6
-  )
-  (func $5 (;5;) (type $4) (param $0 i32) (param $1 i32)
-    (local $2 i32) (local $3 i64)
-    global.get $global$0
-    i32.const 32
-    i32.sub
-    local.tee $2
-    global.set $global$0
-    local.get $1
-    i64.load align=4
-    local.set $3
-    local.get $2
-    i32.const 20
-    i32.add
-    local.get $1
-    i64.load offset=8 align=4
-    i64.store align=4
-    local.get $2
-    local.get $3
-    i64.store offset=12 align=4
-    local.get $2
-    local.get $0
-    i32.store offset=8
-    local.get $2
-    i32.const 1049156
-    i32.store offset=4
-    local.get $2
-    i32.const 1048656
-    i32.store
-    local.get $2
-    call $1
-    unreachable
-  )
-  (func $6 (;6;) (type $5) (param $0 i64) (param $1 i32) (result i32)
-    (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i64) (local $14 i32) (local $15 i32)
-    global.get $global$0
-    i32.const 48
-    i32.sub
-    local.tee $6
-    global.set $global$0
-    i32.const 39
-    local.set $2
-    block $label$1 ;; label = @1
-      block $label$2 ;; label = @2
-        local.get $0
-        i64.const 10000
-        i64.ge_u
-        if ;; label = @3
-          block ;; label = @4
-            loop $label$4 ;; label = @5
-              local.get $6
-              i32.const 9
-              i32.add
-              local.get $2
-              i32.add
-              local.tee $3
-              i32.const -4
-              i32.add
-              local.get $0
-              local.get $0
-              i64.const 10000
-              i64.div_u
-              local.tee $13
-              i64.const -10000
-              i64.mul
-              i64.add
-              i32.wrap_i64
-              local.tee $4
-              i32.const 100
-              i32.div_u
-              local.tee $5
-              i32.const 1
-              i32.shl
-              i32.const 1048706
-              i32.add
-              i32.load16_u align=1
-              i32.store16 align=1
-              local.get $3
-              i32.const -2
-              i32.add
-              local.get $5
-              i32.const -100
-              i32.mul
-              local.get $4
-              i32.add
-              i32.const 1
-              i32.shl
-              i32.const 1048706
-              i32.add
-              i32.load16_u align=1
-              i32.store16 align=1
-              local.get $2
-              i32.const -4
-              i32.add
-              local.set $2
-              block (result i32) ;; label = @6
-                local.get $0
-                i64.const 99999999
-                i64.gt_u
-                local.set $14
-                local.get $13
-                local.set $0
-                local.get $14
-              end
-              br_if 0 (;@5;)
-            end
-            local.get $13
-            i32.wrap_i64
-            local.tee $3
-            i32.const 99
-            i32.le_s
-            br_if 3 (;@1;)
-            br 2 (;@2;)
-          end
-        end
-        local.get $0
-        local.tee $13
-        i32.wrap_i64
-        local.tee $3
-        i32.const 99
-        i32.le_s
-        br_if 1 (;@1;)
-      end
-      local.get $2
-      i32.const -2
-      i32.add
-      local.tee $2
-      local.get $6
-      i32.const 9
-      i32.add
-      i32.add
-      local.get $13
-      i32.wrap_i64
-      local.tee $4
-      i32.const 65535
-      i32.and
-      i32.const 100
-      i32.div_u
-      local.tee $3
-      i32.const -100
-      i32.mul
-      local.get $4
-      i32.add
-      i32.const 65535
-      i32.and
-      i32.const 1
-      i32.shl
-      i32.const 1048706
-      i32.add
-      i32.load16_u align=1
-      i32.store16 align=1
-    end
-    block $label$5 ;; label = @1
-      local.get $3
-      i32.const 9
-      i32.le_s
-      if ;; label = @2
-        block ;; label = @3
-          local.get $2
-          i32.const -1
-          i32.add
-          local.tee $2
-          local.get $6
-          i32.const 9
-          i32.add
-          i32.add
-          local.get $3
-          i32.const 48
-          i32.add
-          i32.store8
-          br 2 (;@1;)
-        end
-      end
-      local.get $2
-      i32.const -2
-      i32.add
-      local.tee $2
-      local.get $6
-      i32.const 9
-      i32.add
-      i32.add
-      local.get $3
-      i32.const 1
-      i32.shl
-      i32.const 1048706
-      i32.add
-      i32.load16_u align=1
-      i32.store16 align=1
-    end
-    i32.const 39
-    local.get $2
-    i32.sub
-    local.set $7
-    i32.const 1
-    local.set $3
-    i32.const 43
-    i32.const 1114112
-    local.get $1
-    i32.load
-    local.tee $4
-    i32.const 1
-    i32.and
-    local.tee $11
-    select
-    local.set $8
-    local.get $4
-    i32.const 29
-    i32.shl
-    i32.const 31
-    i32.shr_s
-    i32.const 1048656
-    i32.and
-    local.set $9
-    local.get $6
-    i32.const 9
-    i32.add
-    local.get $2
-    i32.add
-    local.set $10
-    block $label$7 ;; label = @1
-      block $label$8 ;; label = @2
-        block $label$9 ;; label = @3
-          block $label$10 ;; label = @4
-            block $label$11 ;; label = @5
-              block $label$12 ;; label = @6
-                block $label$13 ;; label = @7
-                  block $label$14 ;; label = @8
-                    block $label$15 (result i32) ;; label = @9
-                      block $label$16 ;; label = @10
-                        block $label$17 ;; label = @11
-                          block $label$18 ;; label = @12
-                            block $label$19 ;; label = @13
-                              local.get $1
-                              i32.load offset=8
-                              i32.const 1
-                              i32.eq
-                              if ;; label = @14
-                                block ;; label = @15
-                                  local.get $1
-                                  i32.const 12
-                                  i32.add
-                                  i32.load
-                                  local.tee $5
-                                  local.get $7
-                                  local.get $11
-                                  i32.add
-                                  local.tee $2
-                                  i32.le_u
-                                  br_if 2 (;@13;)
-                                  local.get $4
-                                  i32.const 8
-                                  i32.and
-                                  br_if 3 (;@12;)
-                                  local.get $5
-                                  local.get $2
-                                  i32.sub
-                                  local.set $4
-                                  i32.const 1
-                                  local.get $1
-                                  i32.load8_u offset=48
-                                  local.tee $3
-                                  local.get $3
-                                  i32.const 3
-                                  i32.eq
-                                  select
-                                  local.tee $3
-                                  i32.const 3
-                                  i32.and
-                                  i32.eqz
-                                  br_if 4 (;@11;)
-                                  local.get $3
-                                  i32.const 2
-                                  i32.eq
-                                  br_if 5 (;@10;)
-                                  i32.const 0
-                                  local.set $5
-                                  local.get $4
-                                  br 6 (;@9;)
-                                end
-                              end
-                              local.get $1
-                              local.get $8
-                              local.get $9
-                              call $9
-                              br_if 10 (;@3;)
-                              br 11 (;@2;)
-                            end
-                            local.get $1
-                            local.get $8
-                            local.get $9
-                            call $9
-                            br_if 9 (;@3;)
-                            br 10 (;@2;)
-                          end
-                          local.get $1
-                          i32.const 1
-                          i32.store8 offset=48
-                          local.get $1
-                          i32.const 48
-                          i32.store offset=4
-                          local.get $1
-                          local.get $8
-                          local.get $9
-                          call $9
-                          br_if 8 (;@3;)
-                          local.get $5
-                          local.get $2
-                          i32.sub
-                          local.set $3
-                          i32.const 1
-                          local.get $1
-                          i32.const 48
-                          i32.add
-                          i32.load8_u
-                          local.tee $4
-                          local.get $4
-                          i32.const 3
-                          i32.eq
-                          select
-                          local.tee $4
-                          i32.const 3
-                          i32.and
-                          i32.eqz
-                          br_if 3 (;@8;)
-                          local.get $4
-                          i32.const 2
-                          i32.eq
-                          br_if 4 (;@7;)
-                          i32.const 0
-                          local.set $4
-                          br 5 (;@6;)
-                        end
-                        local.get $4
-                        local.set $5
-                        i32.const 0
-                        br 1 (;@9;)
-                      end
-                      local.get $4
-                      i32.const 1
-                      i32.add
-                      i32.const 1
-                      i32.shr_u
-                      local.set $5
-                      local.get $4
-                      i32.const 1
-                      i32.shr_u
-                    end
-                    local.set $3
-                    i32.const -1
-                    local.set $2
-                    local.get $1
-                    i32.const 4
-                    i32.add
-                    local.set $4
-                    local.get $1
-                    i32.const 24
-                    i32.add
-                    local.set $11
-                    local.get $1
-                    i32.const 28
-                    i32.add
-                    local.set $12
-                    block $label$21 ;; label = @9
-                      loop $label$22 ;; label = @10
-                        local.get $2
-                        i32.const 1
-                        i32.add
-                        local.tee $2
-                        local.get $3
-                        i32.ge_u
-                        br_if 1 (;@9;)
-                        local.get $11
-                        i32.load
-                        local.get $4
-                        i32.load
-                        local.get $12
-                        i32.load
-                        i32.load offset=16
-                        call_indirect (type $1)
-                        i32.eqz
-                        br_if 0 (;@10;)
-                      end
-                      br 8 (;@1;)
-                    end
-                    local.get $1
-                    i32.const 4
-                    i32.add
-                    i32.load
-                    local.set $4
-                    i32.const 1
-                    local.set $3
-                    local.get $1
-                    local.get $8
-                    local.get $9
-                    call $9
-                    br_if 5 (;@3;)
-                    local.get $1
-                    i32.const 24
-                    i32.add
-                    local.tee $2
-                    i32.load
-                    local.get $10
-                    local.get $7
-                    local.get $1
-                    i32.const 28
-                    i32.add
-                    local.tee $1
-                    i32.load
-                    i32.load offset=12
-                    call_indirect (type $0)
-                    br_if 5 (;@3;)
-                    local.get $2
-                    i32.load
-                    local.set $7
-                    i32.const -1
-                    local.set $2
-                    local.get $1
-                    i32.load
-                    i32.const 16
-                    i32.add
-                    local.set $1
-                    loop $label$23 ;; label = @9
-                      local.get $2
-                      i32.const 1
-                      i32.add
-                      local.tee $2
-                      local.get $5
-                      i32.ge_u
-                      br_if 4 (;@5;)
-                      local.get $7
-                      local.get $4
-                      local.get $1
-                      i32.load
-                      call_indirect (type $1)
-                      i32.eqz
-                      br_if 0 (;@9;)
-                    end
-                    br 5 (;@3;)
-                  end
-                  local.get $3
-                  local.set $4
-                  i32.const 0
-                  local.set $3
-                  br 1 (;@6;)
-                end
-                local.get $3
-                i32.const 1
-                i32.add
-                i32.const 1
-                i32.shr_u
-                local.set $4
-                local.get $3
-                i32.const 1
-                i32.shr_u
-                local.set $3
-              end
-              i32.const -1
-              local.set $2
-              local.get $1
-              i32.const 4
-              i32.add
-              local.set $5
-              local.get $1
-              i32.const 24
-              i32.add
-              local.set $8
-              local.get $1
-              i32.const 28
-              i32.add
-              local.set $9
-              block $label$24 ;; label = @6
-                loop $label$25 ;; label = @7
-                  local.get $2
-                  i32.const 1
-                  i32.add
-                  local.tee $2
-                  local.get $3
-                  i32.ge_u
-                  br_if 1 (;@6;)
-                  local.get $8
-                  i32.load
-                  local.get $5
-                  i32.load
-                  local.get $9
-                  i32.load
-                  i32.load offset=16
-                  call_indirect (type $1)
-                  i32.eqz
-                  br_if 0 (;@7;)
-                end
-                br 5 (;@1;)
-              end
-              local.get $1
-              i32.const 4
-              i32.add
-              i32.load
-              local.set $5
-              i32.const 1
-              local.set $3
-              local.get $1
-              i32.const 24
-              i32.add
-              local.tee $2
-              i32.load
-              local.get $10
-              local.get $7
-              local.get $1
-              i32.const 28
-              i32.add
-              local.tee $1
-              i32.load
-              i32.load offset=12
-              call_indirect (type $0)
-              br_if 2 (;@3;)
-              local.get $2
-              i32.load
-              local.set $7
-              i32.const -1
-              local.set $2
-              local.get $1
-              i32.load
-              i32.const 16
-              i32.add
-              local.set $1
-              loop $label$26 ;; label = @6
-                local.get $2
-                i32.const 1
-                i32.add
-                local.tee $2
-                local.get $4
-                i32.ge_u
-                br_if 2 (;@4;)
-                local.get $7
-                local.get $5
-                local.get $1
-                i32.load
-                call_indirect (type $1)
-                i32.eqz
-                br_if 0 (;@6;)
-              end
-              br 2 (;@3;)
-            end
-            local.get $6
-            i32.const 48
-            i32.add
-            global.set $global$0
-            i32.const 0
-            return
-          end
-          i32.const 0
-          local.set $3
-        end
-        local.get $6
-        i32.const 48
-        i32.add
-        global.set $global$0
-        local.get $3
-        return
-      end
-      block (result i32) ;; label = @2
-        local.get $1
-        i32.load offset=24
-        local.get $10
-        local.get $7
-        local.get $1
-        i32.const 28
-        i32.add
-        i32.load
-        i32.load offset=12
-        call_indirect (type $0)
-        local.set $15
-        local.get $6
-        i32.const 48
-        i32.add
-        global.set $global$0
-        local.get $15
-      end
-      return
-    end
-    local.get $6
-    i32.const 48
-    i32.add
-    global.set $global$0
-    i32.const 1
-  )
-  (func $7 (;7;) (type $2) (param $0 i32)
-    nop
-  )
-  (func $8 (;8;) (type $6) (param $0 i32) (result i64)
-    i64.const -2357177763932378009
-  )
-  (func $9 (;9;) (type $9) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
-    block $label$1 ;; label = @1
-      block $label$2 (result i32) ;; label = @2
-        local.get $1
-        i32.const 1114112
-        i32.ne
-        if ;; label = @3
-          i32.const 1
-          local.get $0
-          i32.load offset=24
-          local.get $1
-          local.get $0
-          i32.const 28
-          i32.add
-          i32.load
-          i32.load offset=16
-          call_indirect (type $1)
-          br_if 1 (;@2;)
-          drop
-        end
-        local.get $2
-        i32.eqz
-        br_if 1 (;@1;)
-        local.get $0
-        i32.load offset=24
-        local.get $2
-        i32.const 0
-        local.get $0
-        i32.const 28
-        i32.add
-        i32.load
-        i32.load offset=12
-        call_indirect (type $0)
-      end
-      return
-    end
-    i32.const 0
-  )
-  (func $10 (;10;) (type $3) (param $0 i32) (result i32)
-    (local $1 i32) (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32) (local $15 i32) (local $16 i32) (local $17 i32) (local $18 i32) (local $19 i32) (local $20 i32) (local $21 i32) (local $22 i32) (local $23 i32) (local $24 i32) (local $25 i32) (local $26 i32) (local $27 i32) (local $28 i32) (local $29 i32) (local $30 i32) (local $31 i32) (local $32 i32) (local $33 i32) (local $34 i32) (local $35 i32) (local $36 i32) (local $37 i32) (local $38 i32) (local $39 i32) (local $40 i32) (local $41 i32) (local $42 i32) (local $43 i32) (local $44 i32) (local $45 i32) (local $46 i32)
-    global.get $global$0
-    i32.const 256
-    i32.sub
-    local.tee $1
-    global.set $global$0
-    local.get $1
-    i64.const 4294967297
-    i64.store offset=56 align=4
-    local.get $1
-    i64.const 4294967297
-    i64.store offset=48 align=4
-    local.get $1
-    i64.const 4294967297
-    i64.store offset=40 align=4
-    local.get $1
-    i64.const 4294967297
-    i64.store offset=32 align=4
-    local.get $1
-    i64.const 4294967297
-    i64.store offset=24 align=4
-    local.get $1
-    i64.const 4294967297
-    i64.store offset=16 align=4
-    local.get $1
-    i64.const 4294967297
-    i64.store offset=8 align=4
-    local.get $1
-    i64.const 4294967297
-    i64.store align=4
-    block $label$1 ;; label = @1
-      local.get $0
-      i32.const 1
-      i32.add
-      local.tee $11
-      i32.const 2
-      i32.ge_u
-      if ;; label = @2
-        block ;; label = @3
-          local.get $1
-          local.set $3
-          i32.const 1
-          local.set $2
-          loop $label$3 ;; label = @4
-            local.get $2
-            i32.const 16
-            i32.ge_u
-            br_if 3 (;@1;)
-            local.get $3
-            i32.const 4
-            i32.add
-            local.tee $4
-            local.get $3
-            i32.load
-            local.get $2
-            i32.mul
-            i32.store
-            local.get $4
-            local.set $3
-            local.get $2
-            i32.const 1
-            i32.add
-            local.tee $4
-            local.set $2
-            local.get $4
-            local.get $11
-            i32.lt_u
-            br_if 0 (;@4;)
-          end
-        end
-      end
-      local.get $0
-      i32.const 16
-      i32.lt_u
-      if ;; label = @2
-        block ;; label = @3
-          i32.const 1
-          local.set $20
-          local.get $1
-          local.get $0
-          i32.const 2
-          i32.shl
-          i32.add
-          i32.load
-          local.tee $9
-          local.set $21
-          local.get $9
-          i32.const 24
-          i32.ge_u
-          if ;; label = @4
-            i32.const 24
-            i32.const 25
-            local.get $9
-            local.get $9
-            i32.const 24
-            i32.div_u
-            local.tee $21
-            i32.const 24
-            i32.mul
-            i32.eq
-            select
-            local.set $20
-          end
-          i32.const 0
-          local.get $0
-          i32.sub
-          local.set $40
-          local.get $1
-          i32.const 196
-          i32.add
-          local.set $12
-          local.get $1
-          i32.const 132
-          i32.add
-          local.set $41
-          local.get $1
-          i32.const 124
-          i32.add
-          local.set $42
-          local.get $1
-          i32.const 68
-          i32.add
-          local.set $11
-          local.get $0
-          i32.const 2
-          i32.lt_u
-          local.set $43
-          loop $label$6 ;; label = @4
-            local.get $1
-            i32.const 120
-            i32.add
-            i64.const 0
-            i64.store
-            local.get $1
-            i32.const 112
-            i32.add
-            i64.const 0
-            i64.store
-            local.get $1
-            i32.const 104
-            i32.add
-            i64.const 0
-            i64.store
-            local.get $1
-            i32.const 96
-            i32.add
-            i64.const 0
-            i64.store
-            local.get $1
-            i32.const 88
-            i32.add
-            i64.const 0
-            i64.store
-            local.get $1
-            i32.const 80
-            i32.add
-            i64.const 0
-            i64.store
-            local.get $1
-            i32.const 72
-            i32.add
-            i64.const 0
-            i64.store
-            local.get $1
-            i64.const 0
-            i64.store offset=64
-            local.get $1
-            i32.const 184
-            i32.add
-            local.tee $26
-            i64.const 0
-            i64.store
-            local.get $1
-            i32.const 176
-            i32.add
-            local.tee $27
-            i64.const 0
-            i64.store
-            local.get $1
-            i32.const 168
-            i32.add
-            local.tee $28
-            i64.const 0
-            i64.store
-            local.get $1
-            i32.const 160
-            i32.add
-            local.tee $29
-            i64.const 0
-            i64.store
-            local.get $1
-            i32.const 152
-            i32.add
-            local.tee $30
-            i64.const 0
-            i64.store
-            local.get $1
-            i32.const 144
-            i32.add
-            local.tee $31
-            i64.const 0
-            i64.store
-            local.get $1
-            i32.const 136
-            i32.add
-            local.tee $32
-            i64.const 0
-            i64.store
-            local.get $1
-            i64.const 0
-            i64.store offset=128
-            local.get $1
-            i32.const 248
-            i32.add
-            local.tee $33
-            i64.const 64424509454
-            i64.store align=4
-            local.get $1
-            i32.const 240
-            i32.add
-            local.tee $34
-            i64.const 55834574860
-            i64.store align=4
-            local.get $1
-            i32.const 232
-            i32.add
-            local.tee $35
-            i64.const 47244640266
-            i64.store align=4
-            local.get $1
-            i32.const 224
-            i32.add
-            local.tee $36
-            i64.const 38654705672
-            i64.store align=4
-            local.get $1
-            i32.const 216
-            i32.add
-            local.tee $37
-            i64.const 30064771078
-            i64.store align=4
-            local.get $1
-            i32.const 208
-            i32.add
-            local.tee $38
-            i64.const 21474836484
-            i64.store align=4
-            local.get $1
-            i32.const 200
-            i32.add
-            local.tee $39
-            i64.const 12884901890
-            i64.store align=4
-            local.get $1
-            i64.const 4294967296
-            i64.store offset=192 align=4
-            local.get $13
-            local.get $21
-            i32.mul
-            local.set $7
-            block $label$7 (result i32) ;; label = @5
-              block $label$8 ;; label = @6
-                local.get $43
-                i32.eqz
-                if ;; label = @7
-                  block ;; label = @8
-                    local.get $40
-                    local.set $23
-                    local.get $7
-                    local.set $14
-                    local.get $0
-                    local.set $15
-                    i32.const 0
-                    local.set $5
-                    br 2 (;@6;)
-                  end
-                end
-                i32.const 0
-                br 1 (;@5;)
-              end
-              i32.const 1
-            end
-            local.set $2
-            loop $label$10 ;; label = @5
-              block $label$11 ;; label = @6
-                block $label$12 ;; label = @7
-                  block $label$13 (result i32) ;; label = @8
-                    block $label$14 ;; label = @9
-                      block $label$15 ;; label = @10
-                        block $label$16 ;; label = @11
-                          block $label$17 ;; label = @12
-                            block $label$18 ;; label = @13
-                              block $label$19 ;; label = @14
-                                local.get $2
-                                i32.eqz
-                                if ;; label = @15
-                                  block ;; label = @16
-                                    local.get $13
-                                    i32.const 1
-                                    i32.add
-                                    local.set $13
-                                    local.get $9
-                                    local.get $7
-                                    local.get $21
-                                    i32.add
-                                    local.tee $3
-                                    local.get $3
-                                    local.get $9
-                                    i32.gt_u
-                                    select
-                                    i32.const -1
-                                    i32.add
-                                    local.set $44
-                                    i32.const 0
-                                    local.set $24
-                                    local.get $1
-                                    i32.load offset=192
-                                    local.tee $6
-                                    i32.const 1
-                                    i32.ge_s
-                                    br_if 2 (;@14;)
-                                    br 3 (;@13;)
-                                  end
-                                end
-                                block $label$21 ;; label = @15
-                                  block $label$22 ;; label = @16
-                                    block $label$23 ;; label = @17
-                                      block $label$24 ;; label = @18
-                                        block $label$25 ;; label = @19
-                                          block $label$26 ;; label = @20
-                                            block $label$27 ;; label = @21
-                                              block $label$28 ;; label = @22
-                                                block $label$29 ;; label = @23
-                                                  block $label$30 ;; label = @24
-                                                    block $label$31 ;; label = @25
-                                                      local.get $5
-                                                      br_table 0 (;@25;) 1 (;@24;) 2 (;@23;)
-                                                    end
-                                                    local.get $15
-                                                    i32.const -1
-                                                    i32.add
-                                                    local.tee $4
-                                                    i32.const 16
-                                                    i32.ge_u
-                                                    br_if 6 (;@18;)
-                                                    local.get $1
-                                                    local.get $4
-                                                    i32.const 2
-                                                    i32.shl
-                                                    local.tee $2
-                                                    i32.add
-                                                    i32.load
-                                                    local.tee $3
-                                                    i32.eqz
-                                                    br_if 7 (;@17;)
-                                                    local.get $14
-                                                    i32.const -2147483648
-                                                    i32.eq
-                                                    if ;; label = @25
-                                                      local.get $3
-                                                      i32.const -1
-                                                      i32.eq
-                                                      br_if 9 (;@16;)
-                                                    end
-                                                    local.get $1
-                                                    i32.const -64
-                                                    i32.sub
-                                                    local.get $2
-                                                    i32.add
-                                                    local.get $14
-                                                    local.get $3
-                                                    i32.div_s
-                                                    local.tee $16
-                                                    i32.store
-                                                    local.get $32
-                                                    local.get $39
-                                                    i64.load align=4
-                                                    i64.store
-                                                    local.get $31
-                                                    local.get $38
-                                                    i64.load align=4
-                                                    i64.store
-                                                    local.get $30
-                                                    local.get $37
-                                                    i64.load align=4
-                                                    i64.store
-                                                    local.get $29
-                                                    local.get $36
-                                                    i64.load align=4
-                                                    i64.store
-                                                    local.get $28
-                                                    local.get $35
-                                                    i64.load align=4
-                                                    i64.store
-                                                    local.get $27
-                                                    local.get $34
-                                                    i64.load align=4
-                                                    i64.store
-                                                    local.get $26
-                                                    local.get $33
-                                                    i64.load align=4
-                                                    i64.store
-                                                    local.get $1
-                                                    local.get $1
-                                                    i64.load offset=192 align=4
-                                                    i64.store offset=128
-                                                    local.get $16
-                                                    local.get $23
-                                                    i32.add
-                                                    local.set $45
-                                                    local.get $14
-                                                    local.get $3
-                                                    local.get $16
-                                                    i32.mul
-                                                    i32.sub
-                                                    local.set $14
-                                                    i32.const 0
-                                                    local.set $2
-                                                    local.get $1
-                                                    i32.const 192
-                                                    i32.add
-                                                    local.set $8
-                                                    loop $label$33 ;; label = @25
-                                                      block $label$34 ;; label = @26
-                                                        local.get $2
-                                                        local.get $16
-                                                        i32.add
-                                                        local.tee $3
-                                                        local.get $4
-                                                        i32.gt_u
-                                                        if ;; label = @27
-                                                          block ;; label = @28
-                                                            local.get $2
-                                                            local.get $45
-                                                            i32.add
-                                                            local.tee $46
-                                                            i32.const 15
-                                                            i32.gt_u
-                                                            br_if 7 (;@21;)
-                                                            local.get $3
-                                                            local.get $15
-                                                            i32.sub
-                                                            local.set $3
-                                                            local.get $2
-                                                            i32.const 15
-                                                            i32.le_u
-                                                            br_if 2 (;@26;)
-                                                            br 6 (;@22;)
-                                                          end
-                                                        end
-                                                        local.get $3
-                                                        i32.const 16
-                                                        i32.ge_u
-                                                        br_if 6 (;@20;)
-                                                        local.get $2
-                                                        i32.const 15
-                                                        i32.gt_u
-                                                        br_if 4 (;@22;)
-                                                      end
-                                                      local.get $8
-                                                      local.get $1
-                                                      i32.const 128
-                                                      i32.add
-                                                      local.get $3
-                                                      i32.const 2
-                                                      i32.shl
-                                                      i32.add
-                                                      i32.load
-                                                      i32.store
-                                                      local.get $8
-                                                      i32.const 4
-                                                      i32.add
-                                                      local.set $8
-                                                      local.get $2
-                                                      i32.const 1
-                                                      i32.add
-                                                      local.tee $2
-                                                      local.get $15
-                                                      i32.lt_u
-                                                      br_if 0 (;@25;)
-                                                    end
-                                                    local.get $23
-                                                    i32.const 1
-                                                    i32.add
-                                                    local.set $23
-                                                    local.get $4
-                                                    local.tee $15
-                                                    i32.const 1
-                                                    i32.gt_u
-                                                    br_if 9 (;@15;)
-                                                    i32.const 0
-                                                    local.set $2
-                                                    br 19 (;@5;)
-                                                  end
-                                                  local.get $26
-                                                  local.get $33
-                                                  i64.load align=4
-                                                  i64.store
-                                                  local.get $27
-                                                  local.get $34
-                                                  i64.load align=4
-                                                  i64.store
-                                                  local.get $28
-                                                  local.get $35
-                                                  i64.load align=4
-                                                  i64.store
-                                                  local.get $29
-                                                  local.get $36
-                                                  i64.load align=4
-                                                  i64.store
-                                                  local.get $30
-                                                  local.get $37
-                                                  i64.load align=4
-                                                  i64.store
-                                                  local.get $31
-                                                  local.get $38
-                                                  i64.load align=4
-                                                  i64.store
-                                                  local.get $32
-                                                  local.get $39
-                                                  i64.load align=4
-                                                  i64.store
-                                                  local.get $1
-                                                  local.get $1
-                                                  i64.load offset=192 align=4
-                                                  i64.store offset=128
-                                                  local.get $6
-                                                  i32.const 15
-                                                  i32.gt_u
-                                                  br_if 4 (;@19;)
-                                                  i32.const 1
-                                                  local.set $17
-                                                  local.get $6
-                                                  local.set $10
-                                                  i32.const 0
-                                                  br 15 (;@8;)
-                                                end
-                                                local.get $7
-                                                local.get $44
-                                                i32.lt_u
-                                                if ;; label = @23
-                                                  block ;; label = @24
-                                                    local.get $12
-                                                    i32.load
-                                                    local.set $25
-                                                    local.get $12
-                                                    local.get $6
-                                                    i32.store
-                                                    local.get $1
-                                                    local.get $25
-                                                    i32.store offset=192
-                                                    local.get $11
-                                                    local.set $18
-                                                    local.get $1
-                                                    i32.load offset=68
-                                                    local.tee $2
-                                                    i32.const 1
-                                                    i32.lt_s
-                                                    br_if 18 (;@6;)
-                                                    i32.const 1
-                                                    local.set $19
-                                                    br 15 (;@9;)
-                                                  end
-                                                end
-                                                local.get $22
-                                                local.get $24
-                                                i32.add
-                                                local.set $22
-                                                local.get $13
-                                                local.get $20
-                                                i32.lt_u
-                                                br_if 18 (;@4;)
-                                                local.get $1
-                                                i32.const 256
-                                                i32.add
-                                                global.set $global$0
-                                                local.get $22
-                                                return
-                                              end
-                                              i32.const 1049076
-                                              local.get $2
-                                              call $3
-                                              unreachable
-                                            end
-                                            i32.const 1049060
-                                            local.get $46
-                                            call $3
-                                            unreachable
-                                          end
-                                          i32.const 1049044
-                                          local.get $2
-                                          local.get $16
-                                          i32.add
-                                          call $3
-                                          unreachable
-                                        end
-                                        local.get $6
-                                        local.set $10
-                                        br 11 (;@7;)
-                                      end
-                                      i32.const 1048980
-                                      local.get $4
-                                      call $3
-                                      unreachable
-                                    end
-                                    i32.const 1048996
-                                    call $2
-                                    unreachable
-                                  end
-                                  i32.const 1049020
-                                  call $2
-                                  unreachable
-                                end
-                                i32.const 0
-                                local.set $5
-                                br 2 (;@12;)
-                              end
-                              i32.const 1
-                              local.set $5
-                              br 2 (;@11;)
-                            end
-                            i32.const 2
-                            local.set $5
-                            br 2 (;@10;)
-                          end
-                          i32.const 1
-                          local.set $2
-                          br 6 (;@5;)
-                        end
-                        i32.const 1
-                        local.set $2
-                        br 5 (;@5;)
-                      end
-                      i32.const 1
-                      local.set $2
-                      br 4 (;@5;)
-                    end
-                    i32.const 1
-                  end
-                  local.set $2
-                  loop $label$37 ;; label = @8
-                    block $label$38 ;; label = @9
-                      block $label$39 ;; label = @10
-                        local.get $2
-                        i32.eqz
-                        if ;; label = @11
-                          block ;; label = @12
-                            local.get $10
-                            local.tee $3
-                            i32.const 2
-                            i32.shl
-                            local.tee $4
-                            local.get $1
-                            i32.const 128
-                            i32.add
-                            i32.add
-                            local.tee $5
-                            i32.load
-                            local.tee $10
-                            if ;; label = @13
-                              block ;; label = @14
-                                local.get $5
-                                local.get $3
-                                i32.store
-                                block $label$42 ;; label = @15
-                                  local.get $3
-                                  i32.const 3
-                                  i32.lt_u
-                                  br_if 0 (;@15;)
-                                  local.get $3
-                                  i32.const -1
-                                  i32.add
-                                  i32.const 1
-                                  i32.shr_u
-                                  local.tee $8
-                                  i32.eqz
-                                  br_if 0 (;@15;)
-                                  local.get $4
-                                  local.get $42
-                                  i32.add
-                                  local.set $2
-                                  local.get $41
-                                  local.set $3
-                                  loop $label$43 ;; label = @16
-                                    local.get $3
-                                    i32.load
-                                    local.set $4
-                                    local.get $3
-                                    local.get $2
-                                    i32.load
-                                    i32.store
-                                    local.get $2
-                                    local.get $4
-                                    i32.store
-                                    local.get $3
-                                    i32.const 4
-                                    i32.add
-                                    local.set $3
-                                    local.get $2
-                                    i32.const -4
-                                    i32.add
-                                    local.set $2
-                                    local.get $8
-                                    i32.const -1
-                                    i32.add
-                                    local.tee $8
-                                    br_if 0 (;@16;)
-                                  end
-                                end
-                                local.get $17
-                                i32.const 1
-                                i32.add
-                                local.set $17
-                                local.get $10
-                                i32.const 16
-                                i32.lt_u
-                                br_if 5 (;@9;)
-                                br 7 (;@7;)
-                              end
-                            end
-                            i32.const 0
-                            local.get $17
-                            i32.sub
-                            local.get $17
-                            local.get $7
-                            i32.const 1
-                            i32.and
-                            select
-                            local.get $24
-                            i32.add
-                            local.set $24
-                            i32.const 2
-                            local.set $5
-                            br 2 (;@10;)
-                          end
-                        end
-                        i32.const 0
-                        local.set $2
-                        local.get $18
-                        i32.const 0
-                        i32.store
-                        local.get $1
-                        local.get $6
-                        local.tee $4
-                        i32.store offset=192
-                        local.get $19
-                        i32.const 1
-                        i32.add
-                        local.set $5
-                        local.get $12
-                        local.set $3
-                        block $label$44 ;; label = @11
-                          block $label$45 ;; label = @12
-                            loop $label$46 ;; label = @13
-                              local.get $2
-                              i32.const 2
-                              i32.add
-                              i32.const 16
-                              i32.ge_u
-                              br_if 1 (;@12;)
-                              local.get $3
-                              local.get $3
-                              i32.const 4
-                              i32.add
-                              local.tee $3
-                              i32.load
-                              i32.store
-                              local.get $2
-                              i32.const 1
-                              i32.add
-                              local.tee $2
-                              local.get $19
-                              i32.lt_u
-                              br_if 0 (;@13;)
-                            end
-                            local.get $5
-                            i32.const 16
-                            i32.ge_u
-                            br_if 1 (;@11;)
-                            local.get $5
-                            i32.const 2
-                            i32.shl
-                            local.tee $3
-                            local.get $1
-                            i32.const 192
-                            i32.add
-                            i32.add
-                            local.get $25
-                            i32.store
-                            local.get $1
-                            i32.const -64
-                            i32.sub
-                            local.get $3
-                            i32.add
-                            local.tee $18
-                            i32.load
-                            local.tee $2
-                            local.get $19
-                            i32.le_s
-                            br_if 6 (;@6;)
-                            local.get $12
-                            i32.load
-                            local.set $6
-                            local.get $5
-                            local.set $19
-                            local.get $4
-                            local.set $25
-                            i32.const 1
-                            local.set $2
-                            br 4 (;@8;)
-                          end
-                          i32.const 1049108
-                          local.get $2
-                          i32.const 2
-                          i32.add
-                          call $3
-                          unreachable
-                        end
-                        i32.const 1049124
-                        local.get $5
-                        call $3
-                        unreachable
-                      end
-                      i32.const 1
-                      local.set $2
-                      br 4 (;@5;)
-                    end
-                    i32.const 0
-                    local.set $2
-                    br 0 (;@8;)
-                  end
-                end
-                i32.const 1049092
-                local.get $10
-                call $3
-                unreachable
-              end
-              local.get $7
-              i32.const 1
-              i32.add
-              local.set $7
-              local.get $18
-              local.get $2
-              i32.const 1
-              i32.add
-              i32.store
-              block $label$47 ;; label = @6
-                block $label$48 ;; label = @7
-                  local.get $1
-                  i32.load offset=192
-                  local.tee $6
-                  i32.const 1
-                  i32.ge_s
-                  if ;; label = @8
-                    block ;; label = @9
-                      i32.const 1
-                      local.set $5
-                      br 2 (;@7;)
-                    end
-                  end
-                  i32.const 2
-                  local.set $5
-                  br 1 (;@6;)
-                end
-                i32.const 1
-                local.set $2
-                br 1 (;@5;)
-              end
-              i32.const 1
-              local.set $2
-              br 0 (;@5;)
-            end
-          end
-        end
-      end
-      i32.const 1049212
-      local.get $0
-      call $3
-      unreachable
-    end
-    i32.const 1049196
-    local.get $2
-    call $3
-    unreachable
-  )
-  (table $0 (;0;) 4 4 funcref)
-  (memory $0 (;0;) 17)
-  (global $global$0 (;0;) (mut i32) i32.const 1048576)
-  (global $global$1 (;1;) i32 i32.const 1049244)
-  (global $global$2 (;2;) i32 i32.const 1049244)
-  (export "memory" (memory $0))
-  (export "__heap_base" (global $global$1))
-  (export "__data_end" (global $global$2))
-  (export "run_fannkuch" (func $10))
-  (elem (;0;) (i32.const 1) func $4 $7 $8)
-  (data (;0;) (i32.const 1048576) "src/lib.rs\00\00\00\00\00\00attempt to divide by zero\00\00\00\00\00\00\00attempt to divide with overflow\00index out of bounds: the len is  but the index is 00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899called `Option::unwrap()` on a `None` valuesrc/libcore/option.rssrc/lib.rs")
-  (data (;1;) (i32.const 1048982) "\10\00\0a\00\00\00%\00\00\00\1d\00\00\00\10\00\10\00\19\00\00\00\00\00\10\00\0a\00\00\00&\00\00\00\15\00\00\000\00\10\00\1f\00\00\00\00\00\10\00\0a\00\00\00&\00\00\00\15\00\00\00\00\00\10\00\0a\00\00\00.\00\00\00\15\00\00\00\00\00\10\00\0a\00\00\000\00\00\00\15\00\00\00\00\00\10\00\0a\00\00\00-\00\00\00\11\00\00\00\00\00\10\00\0a\00\00\00E\00\00\00\17\00\00\00\00\00\10\00\0a\00\00\00q\00\00\00\22\00\00\00\00\00\10\00\0a\00\00\00s\00\00\00\11\00\00\00P\00\10\00 \00\00\00p\00\10\00\12\00\00\00\02\00\00\00\00\00\00\00\01\00\00\00\03\00\00\00J\01\10\00+\00\00\00u\01\10\00\15\00\00\00Y\01\00\00\15\00\00\00\8a\01\10\00\0a\00\00\00\08\00\00\00\09\00\00\00\8a\01\10\00\0a\00\00\00\0a\00\00\00\14")
-)
\ No newline at end of file
diff --git a/cranelift/wasm/wasmtests/select.wat b/cranelift/wasm/wasmtests/select.wat
deleted file mode 100644
index ff3599025b68..000000000000
--- a/cranelift/wasm/wasmtests/select.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-(module
-  (func $untyped-select (result i32)
-  	i32.const 42
-  	i32.const 24
-  	i32.const 1
-  	select)
-
-  (func $typed-select-1 (result externref)
-  	ref.null extern
-  	ref.null extern
-  	i32.const 1
-  	select (result externref))
-
-  (func $typed-select-2 (param externref) (result externref)
-    ref.null extern
-    local.get 0
-    i32.const 1
-    select (result externref))
-)
diff --git a/cranelift/wasm/wasmtests/simd-store.wat b/cranelift/wasm/wasmtests/simd-store.wat
deleted file mode 100644
index f3bdd1d5c064..000000000000
--- a/cranelift/wasm/wasmtests/simd-store.wat
+++ /dev/null
@@ -1,83 +0,0 @@
-(module
-  (func (param v128)
-    (v128.store (i32.const 0) (i8x16.eq (local.get 0) (local.get 0))))
-  (func (param v128)
-    (v128.store (i32.const 0) (i16x8.eq (local.get 0) (local.get 0))))
-  (func (param v128)
-    (v128.store (i32.const 0) (i32x4.eq (local.get 0) (local.get 0))))
-  (func (param v128)
-    (v128.store (i32.const 0) (i64x2.eq (local.get 0) (local.get 0))))
-
-  (func (param v128)
-    (v128.store (i32.const 0) (i8x16.ne (local.get 0) (local.get 0))))
-  (func (param v128)
-    (v128.store (i32.const 0) (i16x8.ne (local.get 0) (local.get 0))))
-  (func (param v128)
-    (v128.store (i32.const 0) (i32x4.ne (local.get 0) (local.get 0))))
-  (func (param v128)
-    (v128.store (i32.const 0) (i64x2.ne (local.get 0) (local.get 0))))
-
-  (func (param v128)
-    (v128.store (i32.const 0) (i8x16.lt_s (local.get 0) (local.get 0))))
-  (func (param v128)
-    (v128.store (i32.const 0) (i16x8.lt_s (local.get 0) (local.get 0))))
-  (func (param v128)
-    (v128.store (i32.const 0) (i32x4.lt_s (local.get 0) (local.get 0))))
-  (func (param v128)
-    (v128.store (i32.const 0) (i64x2.lt_s (local.get 0) (local.get 0))))
-
-  (func (param v128)
-    (v128.store (i32.const 0) (i8x16.lt_u (local.get 0) (local.get 0))))
-  (func (param v128)
-    (v128.store (i32.const 0) (i16x8.lt_u (local.get 0) (local.get 0))))
-  (func (param v128)
-    (v128.store (i32.const 0) (i32x4.lt_u (local.get 0) (local.get 0))))
-
-  (func (param v128)
-    (v128.store (i32.const 0) (i8x16.gt_s (local.get 0) (local.get 0))))
-  (func (param v128)
-    (v128.store (i32.const 0) (i16x8.gt_s (local.get 0) (local.get 0))))
-  (func (param v128)
-    (v128.store (i32.const 0) (i32x4.gt_s (local.get 0) (local.get 0))))
-  (func (param v128)
-    (v128.store (i32.const 0) (i64x2.gt_s (local.get 0) (local.get 0))))
-
-  (func (param v128)
-    (v128.store (i32.const 0) (i8x16.gt_u (local.get 0) (local.get 0))))
-  (func (param v128)
-    (v128.store (i32.const 0) (i16x8.gt_u (local.get 0) (local.get 0))))
-  (func (param v128)
-    (v128.store (i32.const 0) (i32x4.gt_u (local.get 0) (local.get 0))))
-
-  (func (param v128)
-    (v128.store (i32.const 0) (f32x4.eq (local.get 0) (local.get 0))))
-  (func (param v128)
-    (v128.store (i32.const 0) (f64x2.eq (local.get 0) (local.get 0))))
-
-  (func (param v128)
-    (v128.store (i32.const 0) (f32x4.ne (local.get 0) (local.get 0))))
-  (func (param v128)
-    (v128.store (i32.const 0) (f64x2.ne (local.get 0) (local.get 0))))
-
-  (func (param v128)
-    (v128.store (i32.const 0) (f32x4.lt (local.get 0) (local.get 0))))
-  (func (param v128)
-    (v128.store (i32.const 0) (f64x2.lt (local.get 0) (local.get 0))))
-
-  (func (param v128)
-    (v128.store (i32.const 0) (f32x4.le (local.get 0) (local.get 0))))
-  (func (param v128)
-    (v128.store (i32.const 0) (f64x2.le (local.get 0) (local.get 0))))
-
-  (func (param v128)
-    (v128.store (i32.const 0) (f32x4.gt (local.get 0) (local.get 0))))
-  (func (param v128)
-    (v128.store (i32.const 0) (f64x2.gt (local.get 0) (local.get 0))))
-
-  (func (param v128)
-    (v128.store (i32.const 0) (f32x4.ge (local.get 0) (local.get 0))))
-  (func (param v128)
-    (v128.store (i32.const 0) (f64x2.ge (local.get 0) (local.get 0))))
-
-  (memory 0)
-)
diff --git a/cranelift/wasm/wasmtests/simd.wat b/cranelift/wasm/wasmtests/simd.wat
deleted file mode 100644
index 0e4064899337..000000000000
--- a/cranelift/wasm/wasmtests/simd.wat
+++ /dev/null
@@ -1,29 +0,0 @@
-(module
-  (func $test_splat (result i32)
-    i32.const 42
-    i32x4.splat
-    i32x4.extract_lane 0
-  )
-
-  (func $test_insert_lane (result i32)
-      v128.const i64x2 0 0
-      i32.const 99
-      i32x4.replace_lane 1
-      i32x4.extract_lane 1
-  )
-
-  (func $test_const (result i32)
-    v128.const i32x4 1 2 3 4
-    i32x4.extract_lane 3
-  )
-
-  (func $test_locals (local i32 v128)
-    local.get 0
-    i32x4.splat
-    local.set 1
-  )
-
-  (export "test_splat" (func $test_splat))
-  (export "test_insert_lane" (func $test_insert_lane))
-  (export "test_const" (func $test_const))
-)
diff --git a/cranelift/wasm/wasmtests/table-copy.wat b/cranelift/wasm/wasmtests/table-copy.wat
deleted file mode 100644
index dd9e1611e61a..000000000000
--- a/cranelift/wasm/wasmtests/table-copy.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-(module $n
-  (table $t (import "m" "t") 6 funcref)
-
-  (func $i (param i32 i32 i32 i32 i32 i32) (result i32) (local.get 3))
-  (func $j (param i32 i32 i32 i32 i32 i32) (result i32) (local.get 4))
-  (func $k (param i32 i32 i32 i32 i32 i32) (result i32) (local.get 5))
-
-  (table $u (export "u") funcref (elem $i $j $k $i $j $k))
-
-  (func (export "copy_to_t_from_u") (param i32 i32 i32 i32) (result i32)
-    local.get 0
-    local.get 1
-    local.get 2
-    local.get 3
-    table.copy $t $u)
-
-  (func (export "copy_to_u_from_t") (param i32 i32 i32 i32) (result i32)
-    local.get 0
-    local.get 1
-    local.get 2
-    local.get 3
-    table.copy $u $t))
diff --git a/cranelift/wasm/wasmtests/unreachable_code.wat b/cranelift/wasm/wasmtests/unreachable_code.wat
deleted file mode 100644
index 38c1a315cef9..000000000000
--- a/cranelift/wasm/wasmtests/unreachable_code.wat
+++ /dev/null
@@ -1,77 +0,0 @@
-(module
-  (type (;0;) (func (param i32 i64 f64) (result f64)))
-  (type (;1;) (func))
-  (type (;2;) (func (result f32)))
-  (type (;3;) (func (result f64)))
-  (type (;4;) (func (param f64 f64) (result f64)))
-  (type (;5;) (func (result i32)))
-  (func (result i32)
-      block (result i32)
-        unreachable
-      end
-      block
-      end
-      i32.clz
-  )
-  (func (result i32)
-      loop (result i32)
-        unreachable
-      end
-      block
-      end
-      i32.clz
-  )
-  (func (;0;) (type 5) (result i32)
-    nop
-    block (result i32)  ;; label = @1
-      block  ;; label = @2
-        block  ;; label = @3
-          nop
-          block  ;; label = @4
-            i32.const 1
-            if  ;; label = @5
-              nop
-              block  ;; label = @6
-                nop
-                nop
-                loop (result i32)  ;; label = @7
-                  nop
-                  block (result i32)  ;; label = @8
-                    nop
-                    nop
-                    block (result i32)  ;; label = @9
-                      nop
-                      unreachable
-                    end
-                  end
-                end
-                block (result i32)  ;; label = @7
-                  block  ;; label = @8
-                    nop
-                  end
-                  i32.const 0
-                end
-                br_if 5 (;@1;)
-                drop
-              end
-            else
-              nop
-            end
-            nop
-          end
-        end
-      end
-      unreachable
-    end)
-  (func
-    block (result i32)
-      block (result i32)
-        i32.const 1
-        br 1
-      end
-    end
-    drop
-  )
-  (table (;0;) 16 anyfunc)
-  (elem (i32.const 0))
-)
diff --git a/crates/asm-macros/Cargo.toml b/crates/asm-macros/Cargo.toml
index 8b9d96cc9ae3..f04d759e05c2 100644
--- a/crates/asm-macros/Cargo.toml
+++ b/crates/asm-macros/Cargo.toml
@@ -2,6 +2,7 @@
 authors = ["The Wasmtime Project Developers"]
 description = "Macros for defining asm functions in Wasmtime"
 edition.workspace = true
+rust-version.workspace = true
 license = "Apache-2.0 WITH LLVM-exception"
 name = "wasmtime-asm-macros"
 repository = "https://github.com/bytecodealliance/wasmtime"
diff --git a/crates/asm-macros/src/lib.rs b/crates/asm-macros/src/lib.rs
index efd970d6bca0..0fd62e8b382f 100644
--- a/crates/asm-macros/src/lib.rs
+++ b/crates/asm-macros/src/lib.rs
@@ -6,6 +6,8 @@
 //! function) and additionally handles visibility across platforms. All symbols
 //! should be visible to Rust but not visible externally outside of a `*.so`.
 
+#![no_std]
+
 cfg_if::cfg_if! {
     if #[cfg(target_os = "macos")] {
         #[macro_export]
diff --git a/crates/bench-api/Cargo.toml b/crates/bench-api/Cargo.toml
index 83cce9065cae..b8d36dd54999 100644
--- a/crates/bench-api/Cargo.toml
+++ b/crates/bench-api/Cargo.toml
@@ -7,8 +7,12 @@ license = "Apache-2.0 WITH LLVM-exception"
 repository = "https://github.com/bytecodealliance/wasmtime"
 readme = "README.md"
 edition.workspace = true
+rust-version.workspace = true
 publish = false
 
+[lints]
+workspace = true
+
 [lib]
 name = "wasmtime_bench_api"
 crate-type = ["cdylib"]
@@ -18,11 +22,12 @@ doctest = false
 anyhow = { workspace = true }
 shuffling-allocator = { version = "1.1.1", optional = true }
 target-lexicon = { workspace = true }
-wasmtime = { workspace = true }
-wasmtime-cli-flags = { workspace = true, default-features = true }
-wasmtime-wasi = { workspace = true, default-features = true }
+wasmtime = { workspace = true, default-features = true }
+wasmtime-cli-flags = { workspace = true, default-features = true, features = [
+    "cranelift",
+] }
+wasi-common = { workspace = true, default-features = true }
 wasmtime-wasi-nn = { workspace = true, optional = true }
-wasi-cap-std-sync = { workspace = true }
 cap-std = { workspace = true }
 clap = { workspace = true }
 
diff --git a/crates/bench-api/src/lib.rs b/crates/bench-api/src/lib.rs
index a2ec33a9f5fd..6f4eea73da8a 100644
--- a/crates/bench-api/src/lib.rs
+++ b/crates/bench-api/src/lib.rs
@@ -142,9 +142,9 @@ use std::os::raw::{c_int, c_void};
 use std::slice;
 use std::{env, path::PathBuf};
 use target_lexicon::Triple;
+use wasi_common::{sync::WasiCtxBuilder, I32Exit, WasiCtx};
 use wasmtime::{Engine, Instance, Linker, Module, Store};
 use wasmtime_cli_flags::CommonOptions;
-use wasmtime_wasi::{sync::WasiCtxBuilder, I32Exit, WasiCtx};
 
 pub type ExitCode = c_int;
 pub const OK: ExitCode = 0;
@@ -304,20 +304,20 @@ pub extern "C" fn wasm_bench_create(
                 let stdout = std::fs::File::create(&stdout_path)
                     .with_context(|| format!("failed to create {}", stdout_path.display()))?;
                 let stdout = cap_std::fs::File::from_std(stdout);
-                let stdout = wasi_cap_std_sync::file::File::from_cap_std(stdout);
+                let stdout = wasi_common::sync::file::File::from_cap_std(stdout);
                 cx.stdout(Box::new(stdout));
 
                 let stderr = std::fs::File::create(&stderr_path)
                     .with_context(|| format!("failed to create {}", stderr_path.display()))?;
                 let stderr = cap_std::fs::File::from_std(stderr);
-                let stderr = wasi_cap_std_sync::file::File::from_cap_std(stderr);
+                let stderr = wasi_common::sync::file::File::from_cap_std(stderr);
                 cx.stderr(Box::new(stderr));
 
                 if let Some(stdin_path) = &stdin_path {
                     let stdin = std::fs::File::open(stdin_path)
                         .with_context(|| format!("failed to open {}", stdin_path.display()))?;
                     let stdin = cap_std::fs::File::from_std(stdin);
-                    let stdin = wasi_cap_std_sync::file::File::from_cap_std(stdin);
+                    let stdin = wasi_common::sync::file::File::from_cap_std(stdin);
                     cx.stdin(Box::new(stdin));
                 }
 
@@ -392,7 +392,7 @@ fn to_exit_code<T>(result: impl Into<Result<T>>) -> ExitCode {
     match result.into() {
         Ok(_) => OK,
         Err(error) => {
-            eprintln!("{:?}", error);
+            eprintln!("{error:?}");
             ERR
         }
     }
@@ -418,7 +418,7 @@ struct BenchState {
 struct HostState {
     wasi: WasiCtx,
     #[cfg(feature = "wasi-nn")]
-    wasi_nn: wasmtime_wasi_nn::WasiNnCtx,
+    wasi_nn: wasmtime_wasi_nn::witx::WasiNnCtx,
 }
 
 impl BenchState {
@@ -435,7 +435,7 @@ impl BenchState {
         execution_end: extern "C" fn(*mut u8),
         make_wasi_cx: impl FnMut() -> Result<WasiCtx> + 'static,
     ) -> Result<Self> {
-        let mut config = options.config(Some(&Triple::host().to_string()))?;
+        let mut config = options.config(Some(&Triple::host().to_string()), None)?;
         // NB: always disable the compilation cache.
         config.disable_cache();
         let engine = Engine::new(&config)?;
@@ -460,7 +460,7 @@ impl BenchState {
         let fuel = options.wasm.fuel;
 
         if options.wasi.common != Some(false) {
-            wasmtime_wasi::add_to_linker(&mut linker, |cx| &mut cx.wasi)?;
+            wasi_common::sync::add_to_linker(&mut linker, |cx| &mut cx.wasi)?;
         }
 
         #[cfg(feature = "wasi-nn")]
@@ -509,7 +509,7 @@ impl BenchState {
             #[cfg(feature = "wasi-nn")]
             wasi_nn: {
                 let (backends, registry) = wasmtime_wasi_nn::preload(&[])?;
-                wasmtime_wasi_nn::WasiNnCtx::new(backends, registry)
+                wasmtime_wasi_nn::witx::WasiNnCtx::new(backends, registry)
             },
         };
 
@@ -522,7 +522,7 @@ impl BenchState {
             store.set_epoch_deadline(1);
         }
         if let Some(fuel) = self.fuel {
-            store.add_fuel(fuel).unwrap();
+            store.set_fuel(fuel).unwrap();
         }
 
         let instance = self.linker.instantiate(&mut store, &module)?;
diff --git a/crates/c-api-macros/Cargo.toml b/crates/c-api-macros/Cargo.toml
new file mode 100644
index 000000000000..99945a8ebdc6
--- /dev/null
+++ b/crates/c-api-macros/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+name = "wasmtime-c-api-macros"
+version.workspace = true
+authors = ["The Wasmtime Project Developers"]
+license = "Apache-2.0 WITH LLVM-exception"
+edition.workspace = true
+rust-version.workspace = true
+description = "Support macros for `wasmtime-c-api`"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[lints]
+workspace = true
+
+[lib]
+proc-macro = true
+test = false
+doctest = false
+
+[dependencies]
+quote = "1.0"
+proc-macro2 = "1.0"
diff --git a/crates/c-api-macros/src/lib.rs b/crates/c-api-macros/src/lib.rs
new file mode 100644
index 000000000000..4dbd9d599599
--- /dev/null
+++ b/crates/c-api-macros/src/lib.rs
@@ -0,0 +1,147 @@
+//! A set of convenience macros for our wasmtime-c-api crate.
+//!
+//! These are intended to mirror the macros in the `wasm.h` header file and
+//! largely facilitate the `declare_ref` macro.
+
+use proc_macro2::{Ident, TokenStream, TokenTree};
+use quote::quote;
+
+fn extract_ident(input: proc_macro::TokenStream) -> Ident {
+    let input = TokenStream::from(input);
+    let i = match input.into_iter().next().unwrap() {
+        TokenTree::Ident(i) => i,
+        _ => panic!("expected an ident"),
+    };
+    let name = i.to_string();
+    assert!(name.ends_with("_t"));
+    return i;
+}
+
+#[proc_macro]
+pub fn declare_own(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let ty = extract_ident(input);
+    let name = ty.to_string();
+    let delete = quote::format_ident!("{}_delete", &name[..name.len() - 2]);
+    let docs = format!("Deletes the [`{name}`].");
+
+    (quote! {
+        #[doc = #docs]
+        #[no_mangle]
+        pub extern fn #delete(_: Box<#ty>) {}
+    })
+    .into()
+}
+
+#[proc_macro]
+pub fn declare_ty(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let ty = extract_ident(input);
+    let name = ty.to_string();
+    let prefix = &name[..name.len() - 2];
+    let copy = quote::format_ident!("{}_copy", &prefix);
+    let docs = format!(
+        "Creates a new [`{name}`] which matches the provided one.\n\n\
+        The caller is responsible for deleting the returned value via [`{prefix}_delete`].\n\n\
+    "
+    );
+
+    (quote! {
+        wasmtime_c_api_macros::declare_own!(#ty);
+
+        #[doc = #docs]
+        #[no_mangle]
+        pub extern fn #copy(src: &#ty) -> Box<#ty> {
+            Box::new(src.clone())
+        }
+    })
+    .into()
+}
+
+#[proc_macro]
+pub fn declare_ref(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let ty = extract_ident(input);
+    let name = ty.to_string();
+    let prefix = &name[..name.len() - 2];
+    let same = quote::format_ident!("{}_same", prefix);
+    let same_docs = format!(
+        "Returns `true` if the given references are pointing to the same [`{name}`].\n\n\
+        This is not yet supported and aborts the process upon use."
+    );
+    let get_host_info = quote::format_ident!("{}_get_host_info", prefix);
+    let get_host_info_docs = format!(
+        "Returns the host information of the [`{name}`].\n\n\
+        This is not yet supported and always returns `NULL`."
+    );
+    let set_host_info = quote::format_ident!("{}_set_host_info", prefix);
+    let set_host_info_docs = format!(
+        "Sets the host information of the [`{name}`].\n\n\
+        This is not yet supported and aborts the process upon use."
+    );
+    let set_host_info_final = quote::format_ident!("{}_set_host_info_with_finalizer", prefix);
+    let set_host_info_final_docs = format!(
+        "Sets the host information finalizer of the [`{name}`].\n\n\
+        This is not yet supported and aborts the process upon use."
+    );
+    let as_ref = quote::format_ident!("{}_as_ref", prefix);
+    let as_ref_docs = format!(
+        "Returns the [`{name}`] as mutable reference.\n\n\
+        This is not yet supported and aborts the process upon use."
+    );
+    let as_ref_const = quote::format_ident!("{}_as_ref_const", prefix);
+    let as_ref_const_docs = format!(
+        "Returns the [`{name}`] as immutable reference.\n\n\
+        This is not yet supported and aborts the process upon use."
+    );
+
+    (quote! {
+        wasmtime_c_api_macros::declare_ty!(#ty);
+
+        #[doc = #same_docs]
+        #[no_mangle]
+        pub extern fn #same(_a: &#ty, _b: &#ty) -> bool {
+            eprintln!("`{}` is not implemented", stringify!(#same));
+            std::process::abort();
+        }
+
+        #[doc = #get_host_info_docs]
+        #[no_mangle]
+        pub extern fn #get_host_info(a: &#ty) -> *mut std::os::raw::c_void {
+            std::ptr::null_mut()
+        }
+
+        #[doc = #set_host_info_docs]
+        #[no_mangle]
+        pub extern fn #set_host_info(a: &#ty, info: *mut std::os::raw::c_void) {
+            eprintln!("`{}` is not implemented", stringify!(#set_host_info));
+            std::process::abort();
+        }
+
+        #[doc = #set_host_info_final_docs]
+        #[no_mangle]
+        pub extern fn #set_host_info_final(
+            a: &#ty,
+            info: *mut std::os::raw::c_void,
+            finalizer: Option<extern "C" fn(*mut std::os::raw::c_void)>,
+        ) {
+            eprintln!("`{}` is not implemented", stringify!(#set_host_info_final));
+            std::process::abort();
+        }
+
+        #[doc = #as_ref_docs]
+        #[no_mangle]
+        pub extern fn #as_ref(a: &#ty) -> Box<crate::wasm_ref_t> {
+            eprintln!("`{}` is not implemented", stringify!(#as_ref));
+            std::process::abort();
+        }
+
+        #[doc = #as_ref_const_docs]
+        #[no_mangle]
+        pub extern fn #as_ref_const(a: &#ty) -> Box<crate::wasm_ref_t> {
+            eprintln!("`{}` is not implemented", stringify!(#as_ref_const));
+            std::process::abort();
+        }
+
+        // TODO: implement `wasm_ref_as_#name#`
+        // TODO: implement `wasm_ref_as_#name#_const`
+    })
+    .into()
+}
diff --git a/crates/c-api/CMakeLists.txt b/crates/c-api/CMakeLists.txt
index 37ec5761106e..09e8104a2710 100644
--- a/crates/c-api/CMakeLists.txt
+++ b/crates/c-api/CMakeLists.txt
@@ -1,139 +1,131 @@
-cmake_minimum_required(VERSION 3.10)
+cmake_minimum_required(VERSION 3.12)
+project(wasmtime C)
 
+set(WASMTIME_USER_CARGO_BUILD_OPTIONS "" CACHE STRING "Additional cargo flags (such as --features) to apply to the build command")
 option(BUILD_SHARED_LIBS "Build using shared libraries" OFF)
+option(WASMTIME_ALWAYS_BUILD "If cmake should always invoke cargo to build wasmtime" ON)
+option(WASMTIME_FASTEST_RUNTIME "Set flags designed to optimize runtime performance" OFF)
+set(WASMTIME_TARGET "" CACHE STRING "Rust target to build for")
 
-if(CMAKE_BUILD_TYPE STREQUAL "Release")
-	set(WASMTIME_BUILD_TYPE_FLAG "--release")
-	set(WASMTIME_BUILD_TYPE "release")
-else()
-	set(WASMTIME_BUILD_TYPE "debug")
-endif()
-
-if(BUILD_SHARED_LIBS)
-	# Copy shared library into build directory
-	if(WIN32)
-		set(WASMTIME_INSTALL_COMMAND ${CMAKE_COMMAND} -E copy_if_different
-			${CMAKE_CURRENT_SOURCE_DIR}/../../target/${WASMTIME_BUILD_TYPE}/wasmtime.dll
-			${CMAKE_BINARY_DIR})
-	elseif(APPLE)
-		set(WASMTIME_INSTALL_COMMAND ${CMAKE_COMMAND} -E copy_if_different
-			${CMAKE_CURRENT_SOURCE_DIR}/../../target/${WASMTIME_BUILD_TYPE}/libwasmtime.dylib
-			${CMAKE_BINARY_DIR})
-	else()
-		set(WASMTIME_INSTALL_COMMAND ${CMAKE_COMMAND} -E copy_if_different
-			${CMAKE_CURRENT_SOURCE_DIR}/../../target/${WASMTIME_BUILD_TYPE}/libwasmtime.so
-			${CMAKE_BINARY_DIR})
-	endif()
+if(WASMTIME_TARGET STREQUAL "")
+  execute_process(COMMAND rustc -vV OUTPUT_VARIABLE RUSTC_VERSION)
+  string(REGEX MATCH "host: ([^ \n]*)" RUSTC_HOST ${RUSTC_VERSION})
+  string(STRIP ${CMAKE_MATCH_1} RUSTC_HOST_TARGET)
+  set(WASMTIME_TARGET ${RUSTC_HOST_TARGET})
 endif()
 
-if(ANDROID)
-	# TODO wasmtime only supports arm64-v8a right now
-	if(ANDROID_ABI STREQUAL "armeabi-v7a")
-		set(ANDROID_TARGET "armv7-linux-androideabi")
-		set(ANDROID_ARCH_SHORT "arm")
-	elseif(ANDROID_ABI STREQUAL "arm64-v8a")
-		set(ANDROID_TARGET "aarch64-linux-android")
-		set(ANDROID_ARCH_SHORT "aarch64")
-	elseif(ANDROID_ABI STREQUAL "x86")
-		set(ANDROID_TARGET "i686-linux-android")
-		set(ANDROID_ARCH_SHORT "i386")
-	elseif(ANDROID_ABI STREQUAL "x86_64")
-		set(ANDROID_TARGET "x86_64-linux-android")
-		set(ANDROID_ARCH_SHORT "x86_64")
-	endif()
+include(cmake/features.cmake)
 
-	set(WASMTIME_BUILD_TARGET "--target=${ANDROID_TARGET}")
+if(WASMTIME_FASTEST_RUNTIME)
+  set(WASMTIME_BUILD_TYPE_FLAG "--profile=fastest-runtime")
+  set(WASMTIME_BUILD_TYPE "fastest-runtime")
+  set(CARGO_PROFILE_PANIC CARGO_PROFILE_RELEASE_PANIC)
+else()
+  if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    set(WASMTIME_BUILD_TYPE "debug")
+    set(CARGO_PROFILE_PANIC CARGO_PROFILE_DEBUG_PANIC)
+  else()
+    set(WASMTIME_BUILD_TYPE_FLAG "--release")
+    set(WASMTIME_BUILD_TYPE "release")
+    set(CARGO_PROFILE_PANIC CARGO_PROFILE_RELEASE_PANIC)
+  endif()
 endif()
 
-if (BUILD_SHARED_LIBS AND ANDROID)
-	message(FATAL_ERROR "Wasmtime cannot be built with BUILD_SHARED_LIBS on Android")
-endif()
+set(WASMTIME_TARGET_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../target/${WASMTIME_TARGET}/${WASMTIME_BUILD_TYPE})
 
-if(BUILD_SHARED_LIBS)
-	if(WIN32)
-		set(WASMTIME_BUILD_PRODUCT
-			${CMAKE_CURRENT_SOURCE_DIR}/../../target/${WASMTIME_BUILD_TYPE}/wasmtime.dll.lib)
-	elseif(APPLE)
-		set(WASMTIME_BUILD_PRODUCT
-			${CMAKE_CURRENT_SOURCE_DIR}/../../target/${WASMTIME_BUILD_TYPE}/libwasmtime.dylib)
-	else()
-		set(WASMTIME_BUILD_PRODUCT
-			${CMAKE_CURRENT_SOURCE_DIR}/../../target/${WASMTIME_BUILD_TYPE}/libwasmtime.so)
-	endif()
+if(WASMTIME_TARGET MATCHES "darwin")
+  set(WASMTIME_SHARED_FILES libwasmtime.dylib)
+  set(WASMTIME_STATIC_FILES libwasmtime.a)
+elseif(WASMTIME_TARGET MATCHES "windows-gnu")
+  set(WASMTIME_SHARED_FILES libwasmtime.dll.a wasmtime.dll)
+  set(WASMTIME_STATIC_FILES libwasmtime.a)
+elseif(WASMTIME_TARGET MATCHES "windows-msvc")
+  set(WASMTIME_SHARED_FILES wasmtime.dll.lib wasmtime.dll)
+  set(WASMTIME_STATIC_FILES wasmtime.lib)
 else()
-	if(WIN32)
-		set(WASMTIME_BUILD_PRODUCT
-			${CMAKE_CURRENT_SOURCE_DIR}/../../target/${WASMTIME_BUILD_TYPE}/wasmtime.lib)
-	elseif(ANDROID)
-		set(WASMTIME_BUILD_PRODUCT
-			${CMAKE_CURRENT_SOURCE_DIR}/../../target/${ANDROID_TARGET}/${WASMTIME_BUILD_TYPE}/libwasmtime.a)
-	else()
-		set(WASMTIME_BUILD_PRODUCT
-			${CMAKE_CURRENT_SOURCE_DIR}/../../target/${WASMTIME_BUILD_TYPE}/libwasmtime.a)
-	endif()
+  set(WASMTIME_SHARED_FILES libwasmtime.so)
+  set(WASMTIME_STATIC_FILES libwasmtime.a)
 endif()
 
-if(ANDROID)
-	# Rust attempts to use libgcc.a on NDK versions r23-beta3 and up
-	# but it has been replaced with libunwind.a (rust-lang/rust#85806)
-	file(WRITE ${CMAKE_BINARY_DIR}/libgcc.a "INPUT(-lunwind)")
-	# The version of the clang compiler is part of the libunwind.a path
-	file(STRINGS ${ANDROID_TOOLCHAIN_ROOT}/AndroidVersion.txt CLANG_VERSION_FILE)
-	list(GET CLANG_VERSION_FILE 0 CLANG_VERSION)
+list(TRANSFORM WASMTIME_SHARED_FILES PREPEND ${WASMTIME_TARGET_DIR}/)
+list(TRANSFORM WASMTIME_STATIC_FILES PREPEND ${WASMTIME_TARGET_DIR}/)
 
-	# Some crates use the compiler directly, environment variables
-	# are set to make them use the Android compiler
-	set(WASMTIME_PREBUILD_COMMAND ${CMAKE_COMMAND} -E env
-	CC=${ANDROID_TOOLCHAIN_ROOT}/bin/clang
-	AR=${ANDROID_TOOLCHAIN_ROOT}/bin/llvm-ar
-	"RUSTFLAGS=-L ${CMAKE_SYSROOT}/usr/lib/${ANDROID_TARGET}/${ANDROID_NATIVE_API_LEVEL} \
-		-L ${ANDROID_TOOLCHAIN_ROOT}/lib64/clang/${CLANG_VERSION}/lib/linux/${ANDROID_ARCH_SHORT} \
-		-L ${CMAKE_BINARY_DIR} -C linker=${ANDROID_TOOLCHAIN_ROOT}/bin/ld")
-endif()
 include(ExternalProject)
 find_program(WASMTIME_CARGO_BINARY cargo)
+if(NOT WASMTIME_CARGO_BINARY)
+    message(FATAL_ERROR [["cargo" was not found. Ensure "cargo" is in PATH. Aborting...]])
+endif()
 ExternalProject_Add(
-	wasmtime-crate
-	DOWNLOAD_COMMAND ""
-	CONFIGURE_COMMAND ""
-	INSTALL_COMMAND "${WASMTIME_INSTALL_COMMAND}"
-        BUILD_COMMAND ${WASMTIME_PREBUILD_COMMAND} ${WASMTIME_CARGO_BINARY} build ${WASMTIME_BUILD_TYPE_FLAG} ${WASMTIME_BUILD_TARGET}
-	BINARY_DIR ${CMAKE_CURRENT_SOURCE_DIR}
-	BUILD_ALWAYS ON
-	BUILD_BYPRODUCTS ${WASMTIME_BUILD_PRODUCT})
+    wasmtime-crate
+    DOWNLOAD_COMMAND ""
+    CONFIGURE_COMMAND ""
+    INSTALL_COMMAND "${WASMTIME_INSTALL_COMMAND}"
+    BUILD_COMMAND
+        ${CMAKE_COMMAND} -E env ${CARGO_PROFILE_PANIC}=abort
+        ${WASMTIME_CARGO_BINARY} build
+          --target ${WASMTIME_TARGET}
+          --package wasmtime-c-api
+          ${WASMTIME_BUILD_TYPE_FLAG}
+          ${WASMTIME_FEATURES}
+          ${WASMTIME_USER_CARGO_BUILD_OPTIONS}
+    USES_TERMINAL_BUILD TRUE
+    # Note that this is used as the cwd for the cargo invocation itself, build
+    # byproducts go in the `target` directory at the top-level.
+    BINARY_DIR ${CMAKE_CURRENT_SOURCE_DIR}
+    BUILD_ALWAYS ${WASMTIME_ALWAYS_BUILD}
+    BUILD_BYPRODUCTS ${WASMTIME_SHARED_FILES} ${WASMTIME_STATIC_FILES})
 add_library(wasmtime INTERFACE)
 add_dependencies(wasmtime wasmtime-crate)
 
 if(BUILD_SHARED_LIBS)
-	if(NOT WIN32)
-		set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-rpath='$ORIGIN'")
-	endif()
-	target_link_libraries(wasmtime INTERFACE ${WASMTIME_BUILD_PRODUCT})
+    if(NOT WASMTIME_TARGET MATCHES "windows")
+        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,-rpath='$ORIGIN'")
+    endif()
+    list(GET WASMTIME_SHARED_FILES 0 WASMTIME_SHARED_LIB_TO_LINK)
+    target_link_libraries(wasmtime INTERFACE ${WASMTIME_SHARED_LIB_TO_LINK})
 else()
-	if(WIN32)
-		target_compile_options(wasmtime INTERFACE -DWASM_API_EXTERN= -DWASI_API_EXTERN=)
-		target_link_libraries(wasmtime INTERFACE ${WASMTIME_BUILD_PRODUCT}
-			ws2_32 advapi32 userenv ntdll shell32 ole32 bcrypt)
-	elseif(APPLE OR ANDROID)
-		target_link_libraries(wasmtime INTERFACE ${WASMTIME_BUILD_PRODUCT})
-	else()
-		target_link_libraries(wasmtime INTERFACE ${WASMTIME_BUILD_PRODUCT}
-			pthread dl m)
-	endif()
+    if(WASMTIME_TARGET MATCHES "windows")
+        target_compile_options(wasmtime INTERFACE -DWASM_API_EXTERN= -DWASI_API_EXTERN=)
+        target_link_libraries(wasmtime INTERFACE ${WASMTIME_STATIC_FILES}
+            ws2_32 advapi32 userenv ntdll shell32 ole32 bcrypt)
+    elseif(WASMTIME_TARGET MATCHES "darwin")
+        target_link_libraries(wasmtime INTERFACE ${WASMTIME_STATIC_FILES})
+    else()
+        target_link_libraries(wasmtime INTERFACE ${WASMTIME_STATIC_FILES}
+            pthread dl m)
+    endif()
 endif()
 
-target_include_directories(wasmtime INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/include
-	${CMAKE_CURRENT_SOURCE_DIR}/wasm-c-api/include)
+target_include_directories(wasmtime INTERFACE ${CMAKE_BINARY_DIR}/include)
+set(WASMTIME_HEADER_DST ${CMAKE_BINARY_DIR}/include)
+include(cmake/install-headers.cmake)
 
 include(GNUInstallDirs)
-install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/include/wasmtime.h
-	${CMAKE_CURRENT_SOURCE_DIR}/include/wasi.h
-	${CMAKE_CURRENT_SOURCE_DIR}/include/doc-wasm.h
-	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/wasm-c-api/include/wasm.h
-	${CMAKE_CURRENT_SOURCE_DIR}/wasm-c-api/include/wasm.hh
-	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/include/wasmtime
-	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-install(FILES ${WASMTIME_BUILD_PRODUCT} 
-	DESTINATION ${CMAKE_INSTALL_LIBDIR})
+install(SCRIPT ${CMAKE_CURRENT_SOURCE_DIR}/cmake/install-headers.cmake)
+install(FILES ${WASMTIME_SHARED_FILES} ${WASMTIME_STATIC_FILES}
+        DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+if(WASMTIME_TARGET MATCHES "darwin")
+  # Postprocess the macOS dylib a bit to have a more reasonable `LC_ID_DYLIB`
+  # directive than the default one that comes out of the linker when typically
+  # doing `cargo build`. For more info see #984
+  set(INSTALLED_LIB ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/libwasmtime.dylib)
+  install(CODE "execute_process(COMMAND install_name_tool -id \"@rpath/libwasmtime.dylib\" ${INSTALLED_LIB})")
+endif()
+
+set(DOXYGEN_CONF_IN ${CMAKE_CURRENT_SOURCE_DIR}/doxygen.conf.in)
+set(DOXYGEN_CONF_OUT ${CMAKE_BINARY_DIR}/doxygen.conf)
+configure_file(${DOXYGEN_CONF_IN} ${DOXYGEN_CONF_OUT})
+add_custom_target(doc
+    COMMAND doxygen ${DOXYGEN_CONF_OUT}
+    DEPENDS ${WASMTIME_GENERATED_CONF_H} ${DOXYGEN_CONF_OUT}
+    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+add_dependencies(doc headers-to-doc)
+
+file(GLOB headers "include/*.h")
+add_custom_target(headers-to-doc
+  COMMAND
+    ${CMAKE_COMMAND}
+      -DWASMTIME_HEADER_DST=${CMAKE_BINARY_DIR}/include
+      -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/install-headers.cmake
+  DEPENDS ${headers})
diff --git a/crates/c-api/Cargo.toml b/crates/c-api/Cargo.toml
index 47ec57d6c8ec..9b1abe546ebb 100644
--- a/crates/c-api/Cargo.toml
+++ b/crates/c-api/Cargo.toml
@@ -1,5 +1,5 @@
 [package]
-name = "wasmtime-c-api"
+name = "wasmtime-c-api-impl"
 version.workspace = true
 authors.workspace = true
 description = "C API to expose the Wasmtime runtime"
@@ -7,38 +7,53 @@ license = "Apache-2.0 WITH LLVM-exception"
 repository = "https://github.com/bytecodealliance/wasmtime"
 readme = "README.md"
 edition.workspace = true
-publish = false
+rust-version.workspace = true
+links = "wasmtime-c-api"
+include = ["include", "src", "build.rs", "CMakeLists.txt", "cmake", "doxygen.conf.in"]
+
+[lints]
+workspace = true
 
 [lib]
-name = "wasmtime"
-crate-type = ["staticlib", "cdylib", "rlib"]
-doc = false
+name = "wasmtime_c_api"
 test = false
 doctest = false
 
 [dependencies]
-env_logger = { workspace = true }
+env_logger = { workspace = true, optional = true }
 anyhow = { workspace = true }
 once_cell = { workspace = true }
-wasmtime = { workspace = true, features = ['cranelift'] }
-wasmtime-c-api-macros = { path = "macros" }
+wasmtime = { workspace = true, features = ['runtime', 'gc', 'std'] }
+wasmtime-c-api-macros = { workspace = true }
+log = { workspace = true }
+tracing = { workspace = true }
 
 # Optional dependency for the `wat2wasm` API
 wat = { workspace = true, optional = true }
 
 # Optional dependencies for the `wasi` feature
-wasi-cap-std-sync = { workspace = true, optional = true }
-wasmtime-wasi = { workspace = true, default-features = true, optional = true }
 cap-std = { workspace = true, optional = true }
-wasi-common = { workspace = true, optional = true }
+tokio = { workspace = true, optional = true, features = ["fs"] }
+wasmtime-wasi = { workspace = true, optional = true, features = ["preview1"] }
 
 # Optional dependencies for the `async` feature
 futures = { workspace = true, optional = true }
 
 [features]
-default = ['jitdump', 'wat', 'wasi', 'cache', 'parallel-compilation', 'async']
+# WASMTIME_FEATURE_LIST
 async = ['wasmtime/async', 'futures']
-jitdump = ["wasmtime/jitdump"]
+profiling = ["wasmtime/profiling"]
 cache = ["wasmtime/cache"]
 parallel-compilation = ['wasmtime/parallel-compilation']
-wasi = ['wasi-cap-std-sync', 'wasmtime-wasi', 'cap-std', 'wasi-common']
+wasi = ['cap-std', 'wasmtime-wasi', 'tokio']
+logging = ['dep:env_logger']
+disable-logging = ["log/max_level_off", "tracing/max_level_off"]
+coredump = ["wasmtime/coredump"]
+addr2line = ["wasmtime/addr2line"]
+demangle = ["wasmtime/demangle"]
+threads = ["wasmtime/threads"]
+gc = ["wasmtime/gc"]
+cranelift = ['wasmtime/cranelift']
+winch = ['wasmtime/winch']
+# ... if you add a line above this be sure to change the other locations
+# marked WASMTIME_FEATURE_LIST
diff --git a/crates/c-api/README.md b/crates/c-api/README.md
index 5d7149dd18ac..7a858cab86e2 100644
--- a/crates/c-api/README.md
+++ b/crates/c-api/README.md
@@ -1,4 +1,68 @@
 # Wasmtime's C API
 
-For more information you can find the documentation for this library
-[online](https://bytecodealliance.github.io/wasmtime/c-api/).
+## API Documentation
+
+[The API documentation for the Wasmtime C library is hosted
+here.](https://bytecodealliance.github.io/wasmtime/c-api/).
+
+## Using in a C Project
+
+### Using a Pre-Built Static or Dynamic Library
+
+Each release on Wasmtime's [GitHub Releases
+page](https://github.com/bytecodealliance/wasmtime/releases) has pre-built
+binaries for both static and dynamic libraries for a variety of architectures
+and operating systems attached, as well as header files you can include.
+
+### Building Wasmtime's C API from Source
+
+To use Wasmtime from a C or C++ project, you must have
+[CMake](https://cmake.org/) and [a Rust
+toolchain](https://www.rust-lang.org/tools/install) installed.
+
+From the root of the Wasmtime repository, run the following commands:
+
+```
+$ cmake -S crates/c-api -B target/c-api --install-prefix "$(pwd)/artifacts"
+$ cmake --build target/c-api
+$ cmake --install target/c-api
+```
+
+These commands will produce the following files:
+
+* `artifacts/lib/libwasmtime.{a,lib}`: Static Wasmtime library. Exact extension
+  depends on your operating system.
+
+* `artifacts/lib/libwasmtime.{so,dylib,dll}`: Dynamic Wasmtime library. Exact
+  extension depends on your operating system.
+
+* `artifacts/include/**.h`: Header files for working with Wasmtime.
+
+## Using in a Rust Project
+
+If you have a Rust crate that contains bindings to a C or C++ library that uses Wasmtime, you can link the Wasmtime C API using Cargo.
+
+1. Add a dependency on the `wasmtime-c-api-impl` crate to your `Cargo.toml`. Note that package name differs from the library name.
+
+```toml
+[dependencies]
+wasmtime-c-api = { version = "16.0.0", package = "wasmtime-c-api-impl" }
+```
+
+2. In your `build.rs` file, when compiling your C/C++ source code, add the C `wasmtime-c-api` headers to the include path:
+
+```rust
+fn main() {
+    let mut cfg = cc::Build::new();
+
+    // Add to the include path the wasmtime headers and the standard
+    // Wasm C API headers.
+    cfg
+        .include(std::env::var("DEP_WASMTIME_C_API_INCLUDE").unwrap());
+
+    // Compile your C code.
+    cfg
+        .file("src/your_c_code.c")
+        .compile("your_library");
+}
+```
diff --git a/crates/c-api/artifact/Cargo.toml b/crates/c-api/artifact/Cargo.toml
new file mode 100644
index 000000000000..d3f5e816e56a
--- /dev/null
+++ b/crates/c-api/artifact/Cargo.toml
@@ -0,0 +1,58 @@
+[package]
+name = "wasmtime-c-api"
+version.workspace = true
+authors.workspace = true
+description = "C API to expose the Wasmtime runtime"
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+readme = "README.md"
+edition.workspace = true
+rust-version.workspace = true
+publish = false
+
+[lib]
+name = "wasmtime"
+crate-type = ["staticlib", "cdylib"]
+doc = false
+test = false
+doctest = false
+
+[dependencies]
+wasmtime-c-api = { path = '..', package = 'wasmtime-c-api-impl' }
+
+[features]
+# WASMTIME_FEATURE_LIST
+default = [
+  'profiling',
+  'wat',
+  'wasi',
+  'cache',
+  'parallel-compilation',
+  'async',
+  'coredump',
+  'addr2line',
+  'demangle',
+  'threads',
+  'gc',
+  'cranelift',
+  'winch',
+  # ... if you add a line above this be sure to change the other locations
+  # marked WASMTIME_FEATURE_LIST
+]
+async = ['wasmtime-c-api/async']
+profiling = ["wasmtime-c-api/profiling"]
+cache = ["wasmtime-c-api/cache"]
+parallel-compilation = ['wasmtime-c-api/parallel-compilation']
+wasi = ['wasmtime-c-api/wasi']
+logging = ['wasmtime-c-api/logging']
+disable-logging = ["wasmtime-c-api/disable-logging"]
+coredump = ["wasmtime-c-api/coredump"]
+addr2line = ["wasmtime-c-api/addr2line"]
+demangle = ["wasmtime-c-api/demangle"]
+wat = ["wasmtime-c-api/wat"]
+threads = ["wasmtime-c-api/threads"]
+gc = ["wasmtime-c-api/gc"]
+cranelift = ["wasmtime-c-api/cranelift"]
+winch = ["wasmtime-c-api/winch"]
+# ... if you add a line above this be sure to read the comment at the end of
+# `default`
diff --git a/crates/c-api/artifact/src/lib.rs b/crates/c-api/artifact/src/lib.rs
new file mode 100644
index 000000000000..43929bb8605f
--- /dev/null
+++ b/crates/c-api/artifact/src/lib.rs
@@ -0,0 +1 @@
+pub use wasmtime_c_api::*;
diff --git a/crates/c-api/build.rs b/crates/c-api/build.rs
new file mode 100644
index 000000000000..6db41dec75cc
--- /dev/null
+++ b/crates/c-api/build.rs
@@ -0,0 +1,45 @@
+use std::env;
+use std::process::Command;
+
+// WASMTIME_FEATURE_LIST
+const FEATURES: &[&str] = &[
+    "ASYNC",
+    "PROFILING",
+    "CACHE",
+    "PARALLEL_COMPILATION",
+    "WASI",
+    "LOGGING",
+    "DISABLE_LOGGING",
+    "COREDUMP",
+    "ADDR2LINE",
+    "DEMANGLE",
+    "THREADS",
+    "GC",
+    "CRANELIFT",
+    "WINCH",
+];
+// ... if you add a line above this be sure to change the other locations
+// marked WASMTIME_FEATURE_LIST
+
+fn main() {
+    println!("cargo:rerun-if-changed=cmake/features.cmake");
+    println!("cargo:rerun-if-changed=cmake/install-headers.cmake");
+    println!("cargo:rerun-if-changed=include");
+
+    let out_dir = std::env::var("OUT_DIR").unwrap();
+    let mut cmake = Command::new("cmake");
+    cmake.arg("-DWASMTIME_DISABLE_ALL_FEATURES=ON");
+    cmake.arg(format!("-DCMAKE_INSTALL_PREFIX={out_dir}"));
+    for f in FEATURES {
+        if env::var_os(format!("CARGO_FEATURE_{f}")).is_some() {
+            cmake.arg(format!("-DWASMTIME_FEATURE_{f}=ON"));
+        }
+    }
+
+    cmake.arg("-P").arg("cmake/install-headers.cmake");
+
+    let status = cmake.status().expect("failed to spawn `cmake`");
+    assert!(status.success());
+
+    println!("cargo:include={out_dir}/include");
+}
diff --git a/crates/c-api/cmake/features.cmake b/crates/c-api/cmake/features.cmake
new file mode 100644
index 000000000000..44ae4b9b5ec3
--- /dev/null
+++ b/crates/c-api/cmake/features.cmake
@@ -0,0 +1,45 @@
+set(WASMTIME_FEATURES "--no-default-features")
+
+option(WASMTIME_DISABLE_ALL_FEATURES
+       "disable all features by default instead of enabling them"
+       OFF)
+
+macro(feature rust_name default)
+  string(TOUPPER "wasmtime_feature_${rust_name}" cmake_name)
+  string(REPLACE "-" "_" cmake_name ${cmake_name})
+  if(${default})
+    if(${WASMTIME_DISABLE_ALL_FEATURES})
+      set(feature_default OFF)
+    else()
+      set(feature_default ON)
+    endif()
+  else()
+    set(feature_default OFF)
+  endif()
+
+  option(${cmake_name} "enable the Cargo feature ${rust_name}" ${feature_default})
+
+  if(${cmake_name})
+    list(APPEND WASMTIME_FEATURES "--features=${rust_name}")
+    message(STATUS "Enabling feature ${rust_name}")
+  endif()
+endmacro()
+
+# WASMTIME_FEATURE_LIST
+feature(profiling ON)
+feature(wat ON)
+feature(cache ON)
+feature(parallel-compilation ON)
+feature(wasi ON)
+feature(logging ON)
+feature(disable-logging OFF)
+feature(coredump ON)
+feature(addr2line ON)
+feature(demangle ON)
+feature(threads ON)
+feature(gc ON)
+feature(async ON)
+feature(cranelift ON)
+feature(winch ON)
+# ... if you add a line above this be sure to change the other locations
+# marked WASMTIME_FEATURE_LIST
diff --git a/crates/c-api/cmake/install-headers.cmake b/crates/c-api/cmake/install-headers.cmake
new file mode 100644
index 000000000000..528e20823048
--- /dev/null
+++ b/crates/c-api/cmake/install-headers.cmake
@@ -0,0 +1,18 @@
+cmake_minimum_required(VERSION 3.12)
+
+include(${CMAKE_CURRENT_LIST_DIR}/features.cmake)
+
+if(WASMTIME_HEADER_DST)
+  set(dst "${WASMTIME_HEADER_DST}")
+else()
+  set(dst "${CMAKE_INSTALL_PREFIX}/include")
+endif()
+set(include_src "${CMAKE_CURRENT_LIST_DIR}/../include")
+
+message(STATUS "Installing: ${dst}/wasmtime/conf.h")
+file(READ "${include_src}/wasmtime/conf.h.in" conf_h)
+file(CONFIGURE OUTPUT "${dst}/wasmtime/conf.h" CONTENT "${conf_h}"
+     NEWLINE_STYLE CRLF)
+file(INSTALL "${include_src}/"
+     DESTINATION "${dst}"
+     FILES_MATCHING REGEX "\\.hh?$")
diff --git a/crates/c-api/doxygen.conf b/crates/c-api/doxygen.conf
deleted file mode 100644
index 4e43ca4076de..000000000000
--- a/crates/c-api/doxygen.conf
+++ /dev/null
@@ -1,2583 +0,0 @@
-# Doxyfile 1.9.1
-
-# This file describes the settings to be used by the documentation system
-# doxygen (www.doxygen.org) for a project.
-#
-# All text after a double hash (##) is considered a comment and is placed in
-# front of the TAG it is preceding.
-#
-# All text after a single hash (#) is considered a comment and will be ignored.
-# The format is:
-# TAG = value [value, ...]
-# For lists, items can also be appended using:
-# TAG += value [value, ...]
-# Values that contain spaces should be placed between quotes (\" \").
-
-#---------------------------------------------------------------------------
-# Project related configuration options
-#---------------------------------------------------------------------------
-
-# This tag specifies the encoding used for all characters in the configuration
-# file that follow. The default is UTF-8 which is also the encoding used for all
-# text before the first occurrence of this tag. Doxygen uses libiconv (or the
-# iconv built into libc) for the transcoding. See
-# https://www.gnu.org/software/libiconv/ for the list of possible encodings.
-# The default value is: UTF-8.
-
-DOXYFILE_ENCODING      = UTF-8
-
-# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by
-# double-quotes, unless you are using Doxywizard) that should identify the
-# project for which the documentation is generated. This name is used in the
-# title of most generated pages and in a few other places.
-# The default value is: My Project.
-
-PROJECT_NAME           = Wasmtime
-
-# The PROJECT_NUMBER tag can be used to enter a project or revision number. This
-# could be handy for archiving the generated documentation or if some version
-# control system is used.
-
-PROJECT_NUMBER         =
-
-# Using the PROJECT_BRIEF tag one can provide an optional one line description
-# for a project that appears at the top of each page and should give viewer a
-# quick idea about the purpose of the project. Keep the description short.
-
-PROJECT_BRIEF          =
-
-# With the PROJECT_LOGO tag one can specify a logo or an icon that is included
-# in the documentation. The maximum height of the logo should not exceed 55
-# pixels and the maximum width should not exceed 200 pixels. Doxygen will copy
-# the logo to the output directory.
-
-PROJECT_LOGO           =
-
-# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
-# into which the generated documentation will be written. If a relative path is
-# entered, it will be relative to the location where doxygen was started. If
-# left blank the current directory will be used.
-
-OUTPUT_DIRECTORY       =
-
-# If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub-
-# directories (in 2 levels) under the output directory of each output format and
-# will distribute the generated files over these directories. Enabling this
-# option can be useful when feeding doxygen a huge amount of source files, where
-# putting all generated files in the same directory would otherwise causes
-# performance problems for the file system.
-# The default value is: NO.
-
-CREATE_SUBDIRS         = NO
-
-# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII
-# characters to appear in the names of generated files. If set to NO, non-ASCII
-# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode
-# U+3044.
-# The default value is: NO.
-
-ALLOW_UNICODE_NAMES    = NO
-
-# The OUTPUT_LANGUAGE tag is used to specify the language in which all
-# documentation generated by doxygen is written. Doxygen will use this
-# information to generate all constant output in the proper language.
-# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese,
-# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States),
-# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian,
-# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages),
-# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian,
-# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian,
-# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish,
-# Ukrainian and Vietnamese.
-# The default value is: English.
-
-OUTPUT_LANGUAGE        = English
-
-# The OUTPUT_TEXT_DIRECTION tag is used to specify the direction in which all
-# documentation generated by doxygen is written. Doxygen will use this
-# information to generate all generated output in the proper direction.
-# Possible values are: None, LTR, RTL and Context.
-# The default value is: None.
-
-OUTPUT_TEXT_DIRECTION  = None
-
-# If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member
-# descriptions after the members that are listed in the file and class
-# documentation (similar to Javadoc). Set to NO to disable this.
-# The default value is: YES.
-
-BRIEF_MEMBER_DESC      = YES
-
-# If the REPEAT_BRIEF tag is set to YES, doxygen will prepend the brief
-# description of a member or function before the detailed description
-#
-# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
-# brief descriptions will be completely suppressed.
-# The default value is: YES.
-
-REPEAT_BRIEF           = YES
-
-# This tag implements a quasi-intelligent brief description abbreviator that is
-# used to form the text in various listings. Each string in this list, if found
-# as the leading text of the brief description, will be stripped from the text
-# and the result, after processing the whole list, is used as the annotated
-# text. Otherwise, the brief description is used as-is. If left blank, the
-# following values are used ($name is automatically replaced with the name of
-# the entity):The $name class, The $name widget, The $name file, is, provides,
-# specifies, contains, represents, a, an and the.
-
-ABBREVIATE_BRIEF       = "The $name class" \
-                         "The $name widget" \
-                         "The $name file" \
-                         is \
-                         provides \
-                         specifies \
-                         contains \
-                         represents \
-                         a \
-                         an \
-                         the
-
-# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
-# doxygen will generate a detailed section even if there is only a brief
-# description.
-# The default value is: NO.
-
-ALWAYS_DETAILED_SEC    = NO
-
-# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
-# inherited members of a class in the documentation of that class as if those
-# members were ordinary class members. Constructors, destructors and assignment
-# operators of the base classes will not be shown.
-# The default value is: NO.
-
-INLINE_INHERITED_MEMB  = NO
-
-# If the FULL_PATH_NAMES tag is set to YES, doxygen will prepend the full path
-# before files name in the file list and in the header files. If set to NO the
-# shortest path that makes the file name unique will be used
-# The default value is: YES.
-
-FULL_PATH_NAMES        = NO
-
-# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path.
-# Stripping is only done if one of the specified strings matches the left-hand
-# part of the path. The tag can be used to show relative paths in the file list.
-# If left blank the directory from which doxygen is run is used as the path to
-# strip.
-#
-# Note that you can specify absolute paths here, but also relative paths, which
-# will be relative from the directory where doxygen is started.
-# This tag requires that the tag FULL_PATH_NAMES is set to YES.
-
-STRIP_FROM_PATH        =
-
-# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
-# path mentioned in the documentation of a class, which tells the reader which
-# header file to include in order to use a class. If left blank only the name of
-# the header file containing the class definition is used. Otherwise one should
-# specify the list of include paths that are normally passed to the compiler
-# using the -I flag.
-
-STRIP_FROM_INC_PATH    =
-
-# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but
-# less readable) file names. This can be useful is your file systems doesn't
-# support long names like on DOS, Mac, or CD-ROM.
-# The default value is: NO.
-
-SHORT_NAMES            = NO
-
-# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the
-# first line (until the first dot) of a Javadoc-style comment as the brief
-# description. If set to NO, the Javadoc-style will behave just like regular Qt-
-# style comments (thus requiring an explicit @brief command for a brief
-# description.)
-# The default value is: NO.
-
-JAVADOC_AUTOBRIEF      = NO
-
-# If the JAVADOC_BANNER tag is set to YES then doxygen will interpret a line
-# such as
-# /***************
-# as being the beginning of a Javadoc-style comment "banner". If set to NO, the
-# Javadoc-style will behave just like regular comments and it will not be
-# interpreted by doxygen.
-# The default value is: NO.
-
-JAVADOC_BANNER         = NO
-
-# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
-# line (until the first dot) of a Qt-style comment as the brief description. If
-# set to NO, the Qt-style will behave just like regular Qt-style comments (thus
-# requiring an explicit \brief command for a brief description.)
-# The default value is: NO.
-
-QT_AUTOBRIEF           = NO
-
-# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a
-# multi-line C++ special comment block (i.e. a block of //! or /// comments) as
-# a brief description. This used to be the default behavior. The new default is
-# to treat a multi-line C++ comment block as a detailed description. Set this
-# tag to YES if you prefer the old behavior instead.
-#
-# Note that setting this tag to YES also means that rational rose comments are
-# not recognized any more.
-# The default value is: NO.
-
-MULTILINE_CPP_IS_BRIEF = NO
-
-# By default Python docstrings are displayed as preformatted text and doxygen's
-# special commands cannot be used. By setting PYTHON_DOCSTRING to NO the
-# doxygen's special commands can be used and the contents of the docstring
-# documentation blocks is shown as doxygen documentation.
-# The default value is: YES.
-
-PYTHON_DOCSTRING       = YES
-
-# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
-# documentation from any documented member that it re-implements.
-# The default value is: YES.
-
-INHERIT_DOCS           = YES
-
-# If the SEPARATE_MEMBER_PAGES tag is set to YES then doxygen will produce a new
-# page for each member. If set to NO, the documentation of a member will be part
-# of the file/class/namespace that contains it.
-# The default value is: NO.
-
-SEPARATE_MEMBER_PAGES  = NO
-
-# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen
-# uses this value to replace tabs by spaces in code fragments.
-# Minimum value: 1, maximum value: 16, default value: 4.
-
-TAB_SIZE               = 4
-
-# This tag can be used to specify a number of aliases that act as commands in
-# the documentation. An alias has the form:
-# name=value
-# For example adding
-# "sideeffect=@par Side Effects:\n"
-# will allow you to put the command \sideeffect (or @sideeffect) in the
-# documentation, which will result in a user-defined paragraph with heading
-# "Side Effects:". You can put \n's in the value part of an alias to insert
-# newlines (in the resulting output). You can put ^^ in the value part of an
-# alias to insert a newline as if a physical newline was in the original file.
-# When you need a literal { or } or , in the value part of an alias you have to
-# escape them by means of a backslash (\), this can lead to conflicts with the
-# commands \{ and \} for these it is advised to use the version @{ and @} or use
-# a double escape (\\{ and \\})
-
-ALIASES                =
-
-# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
-# only. Doxygen will then generate output that is more tailored for C. For
-# instance, some of the names that are used will be different. The list of all
-# members will be omitted, etc.
-# The default value is: NO.
-
-OPTIMIZE_OUTPUT_FOR_C  = YES
-
-# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or
-# Python sources only. Doxygen will then generate output that is more tailored
-# for that language. For instance, namespaces will be presented as packages,
-# qualified scopes will look different, etc.
-# The default value is: NO.
-
-OPTIMIZE_OUTPUT_JAVA   = NO
-
-# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
-# sources. Doxygen will then generate output that is tailored for Fortran.
-# The default value is: NO.
-
-OPTIMIZE_FOR_FORTRAN   = NO
-
-# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
-# sources. Doxygen will then generate output that is tailored for VHDL.
-# The default value is: NO.
-
-OPTIMIZE_OUTPUT_VHDL   = NO
-
-# Set the OPTIMIZE_OUTPUT_SLICE tag to YES if your project consists of Slice
-# sources only. Doxygen will then generate output that is more tailored for that
-# language. For instance, namespaces will be presented as modules, types will be
-# separated into more groups, etc.
-# The default value is: NO.
-
-OPTIMIZE_OUTPUT_SLICE  = NO
-
-# Doxygen selects the parser to use depending on the extension of the files it
-# parses. With this tag you can assign which parser to use for a given
-# extension. Doxygen has a built-in mapping, but you can override or extend it
-# using this tag. The format is ext=language, where ext is a file extension, and
-# language is one of the parsers supported by doxygen: IDL, Java, JavaScript,
-# Csharp (C#), C, C++, D, PHP, md (Markdown), Objective-C, Python, Slice, VHDL,
-# Fortran (fixed format Fortran: FortranFixed, free formatted Fortran:
-# FortranFree, unknown formatted Fortran: Fortran. In the later case the parser
-# tries to guess whether the code is fixed or free formatted code, this is the
-# default for Fortran type files). For instance to make doxygen treat .inc files
-# as Fortran files (default is PHP), and .f files as C (default is Fortran),
-# use: inc=Fortran f=C.
-#
-# Note: For files without extension you can use no_extension as a placeholder.
-#
-# Note that for custom extensions you also need to set FILE_PATTERNS otherwise
-# the files are not read by doxygen. When specifying no_extension you should add
-# * to the FILE_PATTERNS.
-#
-# Note see also the list of default file extension mappings.
-
-EXTENSION_MAPPING      =
-
-# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
-# according to the Markdown format, which allows for more readable
-# documentation. See https://daringfireball.net/projects/markdown/ for details.
-# The output of markdown processing is further processed by doxygen, so you can
-# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
-# case of backward compatibilities issues.
-# The default value is: YES.
-
-MARKDOWN_SUPPORT       = YES
-
-# When the TOC_INCLUDE_HEADINGS tag is set to a non-zero value, all headings up
-# to that level are automatically included in the table of contents, even if
-# they do not have an id attribute.
-# Note: This feature currently applies only to Markdown headings.
-# Minimum value: 0, maximum value: 99, default value: 5.
-# This tag requires that the tag MARKDOWN_SUPPORT is set to YES.
-
-TOC_INCLUDE_HEADINGS   = 5
-
-# When enabled doxygen tries to link words that correspond to documented
-# classes, or namespaces to their corresponding documentation. Such a link can
-# be prevented in individual cases by putting a % sign in front of the word or
-# globally by setting AUTOLINK_SUPPORT to NO.
-# The default value is: YES.
-
-AUTOLINK_SUPPORT       = YES
-
-# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
-# to include (a tag file for) the STL sources as input, then you should set this
-# tag to YES in order to let doxygen match functions declarations and
-# definitions whose arguments contain STL classes (e.g. func(std::string);
-# versus func(std::string) {}). This also make the inheritance and collaboration
-# diagrams that involve STL classes more complete and accurate.
-# The default value is: NO.
-
-BUILTIN_STL_SUPPORT    = NO
-
-# If you use Microsoft's C++/CLI language, you should set this option to YES to
-# enable parsing support.
-# The default value is: NO.
-
-CPP_CLI_SUPPORT        = NO
-
-# Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
-# https://www.riverbankcomputing.com/software/sip/intro) sources only. Doxygen
-# will parse them like normal C++ but will assume all classes use public instead
-# of private inheritance when no explicit protection keyword is present.
-# The default value is: NO.
-
-SIP_SUPPORT            = NO
-
-# For Microsoft's IDL there are propget and propput attributes to indicate
-# getter and setter methods for a property. Setting this option to YES will make
-# doxygen to replace the get and set methods by a property in the documentation.
-# This will only work if the methods are indeed getting or setting a simple
-# type. If this is not the case, or you want to show the methods anyway, you
-# should set this option to NO.
-# The default value is: YES.
-
-IDL_PROPERTY_SUPPORT   = YES
-
-# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
-# tag is set to YES then doxygen will reuse the documentation of the first
-# member in the group (if any) for the other members of the group. By default
-# all members of a group must be documented explicitly.
-# The default value is: NO.
-
-DISTRIBUTE_GROUP_DOC   = NO
-
-# If one adds a struct or class to a group and this option is enabled, then also
-# any nested class or struct is added to the same group. By default this option
-# is disabled and one has to add nested compounds explicitly via \ingroup.
-# The default value is: NO.
-
-GROUP_NESTED_COMPOUNDS = NO
-
-# Set the SUBGROUPING tag to YES to allow class member groups of the same type
-# (for instance a group of public functions) to be put as a subgroup of that
-# type (e.g. under the Public Functions section). Set it to NO to prevent
-# subgrouping. Alternatively, this can be done per class using the
-# \nosubgrouping command.
-# The default value is: YES.
-
-SUBGROUPING            = YES
-
-# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions
-# are shown inside the group in which they are included (e.g. using \ingroup)
-# instead of on a separate page (for HTML and Man pages) or section (for LaTeX
-# and RTF).
-#
-# Note that this feature does not work in combination with
-# SEPARATE_MEMBER_PAGES.
-# The default value is: NO.
-
-INLINE_GROUPED_CLASSES = NO
-
-# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions
-# with only public data fields or simple typedef fields will be shown inline in
-# the documentation of the scope in which they are defined (i.e. file,
-# namespace, or group documentation), provided this scope is documented. If set
-# to NO, structs, classes, and unions are shown on a separate page (for HTML and
-# Man pages) or section (for LaTeX and RTF).
-# The default value is: NO.
-
-INLINE_SIMPLE_STRUCTS  = NO
-
-# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or
-# enum is documented as struct, union, or enum with the name of the typedef. So
-# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
-# with name TypeT. When disabled the typedef will appear as a member of a file,
-# namespace, or class. And the struct will be named TypeS. This can typically be
-# useful for C code in case the coding convention dictates that all compound
-# types are typedef'ed and only the typedef is referenced, never the tag name.
-# The default value is: NO.
-
-TYPEDEF_HIDES_STRUCT   = NO
-
-# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
-# cache is used to resolve symbols given their name and scope. Since this can be
-# an expensive process and often the same symbol appears multiple times in the
-# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small
-# doxygen will become slower. If the cache is too large, memory is wasted. The
-# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range
-# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536
-# symbols. At the end of a run doxygen will report the cache usage and suggest
-# the optimal cache size from a speed point of view.
-# Minimum value: 0, maximum value: 9, default value: 0.
-
-LOOKUP_CACHE_SIZE      = 0
-
-# The NUM_PROC_THREADS specifies the number threads doxygen is allowed to use
-# during processing. When set to 0 doxygen will based this on the number of
-# cores available in the system. You can set it explicitly to a value larger
-# than 0 to get more control over the balance between CPU load and processing
-# speed. At this moment only the input processing can be done using multiple
-# threads. Since this is still an experimental feature the default is set to 1,
-# which efficively disables parallel processing. Please report any issues you
-# encounter. Generating dot graphs in parallel is controlled by the
-# DOT_NUM_THREADS setting.
-# Minimum value: 0, maximum value: 32, default value: 1.
-
-NUM_PROC_THREADS       = 1
-
-#---------------------------------------------------------------------------
-# Build related configuration options
-#---------------------------------------------------------------------------
-
-# If the EXTRACT_ALL tag is set to YES, doxygen will assume all entities in
-# documentation are documented, even if no documentation was available. Private
-# class members and static file members will be hidden unless the
-# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES.
-# Note: This will also disable the warnings about undocumented members that are
-# normally produced when WARNINGS is set to YES.
-# The default value is: NO.
-
-EXTRACT_ALL            = NO
-
-# If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will
-# be included in the documentation.
-# The default value is: NO.
-
-EXTRACT_PRIVATE        = NO
-
-# If the EXTRACT_PRIV_VIRTUAL tag is set to YES, documented private virtual
-# methods of a class will be included in the documentation.
-# The default value is: NO.
-
-EXTRACT_PRIV_VIRTUAL   = NO
-
-# If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal
-# scope will be included in the documentation.
-# The default value is: NO.
-
-EXTRACT_PACKAGE        = NO
-
-# If the EXTRACT_STATIC tag is set to YES, all static members of a file will be
-# included in the documentation.
-# The default value is: NO.
-
-EXTRACT_STATIC         = NO
-
-# If the EXTRACT_LOCAL_CLASSES tag is set to YES, classes (and structs) defined
-# locally in source files will be included in the documentation. If set to NO,
-# only classes defined in header files are included. Does not have any effect
-# for Java sources.
-# The default value is: YES.
-
-EXTRACT_LOCAL_CLASSES  = YES
-
-# This flag is only useful for Objective-C code. If set to YES, local methods,
-# which are defined in the implementation section but not in the interface are
-# included in the documentation. If set to NO, only methods in the interface are
-# included.
-# The default value is: NO.
-
-EXTRACT_LOCAL_METHODS  = NO
-
-# If this flag is set to YES, the members of anonymous namespaces will be
-# extracted and appear in the documentation as a namespace called
-# 'anonymous_namespace{file}', where file will be replaced with the base name of
-# the file that contains the anonymous namespace. By default anonymous namespace
-# are hidden.
-# The default value is: NO.
-
-EXTRACT_ANON_NSPACES   = NO
-
-# If this flag is set to YES, the name of an unnamed parameter in a declaration
-# will be determined by the corresponding definition. By default unnamed
-# parameters remain unnamed in the output.
-# The default value is: YES.
-
-RESOLVE_UNNAMED_PARAMS = YES
-
-# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
-# undocumented members inside documented classes or files. If set to NO these
-# members will be included in the various overviews, but no documentation
-# section is generated. This option has no effect if EXTRACT_ALL is enabled.
-# The default value is: NO.
-
-HIDE_UNDOC_MEMBERS     = NO
-
-# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
-# undocumented classes that are normally visible in the class hierarchy. If set
-# to NO, these classes will be included in the various overviews. This option
-# has no effect if EXTRACT_ALL is enabled.
-# The default value is: NO.
-
-HIDE_UNDOC_CLASSES     = NO
-
-# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
-# declarations. If set to NO, these declarations will be included in the
-# documentation.
-# The default value is: NO.
-
-HIDE_FRIEND_COMPOUNDS  = NO
-
-# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any
-# documentation blocks found inside the body of a function. If set to NO, these
-# blocks will be appended to the function's detailed documentation block.
-# The default value is: NO.
-
-HIDE_IN_BODY_DOCS      = NO
-
-# The INTERNAL_DOCS tag determines if documentation that is typed after a
-# \internal command is included. If the tag is set to NO then the documentation
-# will be excluded. Set it to YES to include the internal documentation.
-# The default value is: NO.
-
-INTERNAL_DOCS          = NO
-
-# With the correct setting of option CASE_SENSE_NAMES doxygen will better be
-# able to match the capabilities of the underlying filesystem. In case the
-# filesystem is case sensitive (i.e. it supports files in the same directory
-# whose names only differ in casing), the option must be set to YES to properly
-# deal with such files in case they appear in the input. For filesystems that
-# are not case sensitive the option should be be set to NO to properly deal with
-# output files written for symbols that only differ in casing, such as for two
-# classes, one named CLASS and the other named Class, and to also support
-# references to files without having to specify the exact matching casing. On
-# Windows (including Cygwin) and MacOS, users should typically set this option
-# to NO, whereas on Linux or other Unix flavors it should typically be set to
-# YES.
-# The default value is: system dependent.
-
-CASE_SENSE_NAMES       = YES
-
-# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
-# their full class and namespace scopes in the documentation. If set to YES, the
-# scope will be hidden.
-# The default value is: NO.
-
-HIDE_SCOPE_NAMES       = NO
-
-# If the HIDE_COMPOUND_REFERENCE tag is set to NO (default) then doxygen will
-# append additional text to a page's title, such as Class Reference. If set to
-# YES the compound reference will be hidden.
-# The default value is: NO.
-
-HIDE_COMPOUND_REFERENCE= NO
-
-# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
-# the files that are included by a file in the documentation of that file.
-# The default value is: YES.
-
-SHOW_INCLUDE_FILES     = YES
-
-# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each
-# grouped member an include statement to the documentation, telling the reader
-# which file to include in order to use the member.
-# The default value is: NO.
-
-SHOW_GROUPED_MEMB_INC  = NO
-
-# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include
-# files with double quotes in the documentation rather than with sharp brackets.
-# The default value is: NO.
-
-FORCE_LOCAL_INCLUDES   = NO
-
-# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the
-# documentation for inline members.
-# The default value is: YES.
-
-INLINE_INFO            = YES
-
-# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the
-# (detailed) documentation of file and class members alphabetically by member
-# name. If set to NO, the members will appear in declaration order.
-# The default value is: YES.
-
-SORT_MEMBER_DOCS       = YES
-
-# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief
-# descriptions of file, namespace and class members alphabetically by member
-# name. If set to NO, the members will appear in declaration order. Note that
-# this will also influence the order of the classes in the class list.
-# The default value is: NO.
-
-SORT_BRIEF_DOCS        = NO
-
-# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the
-# (brief and detailed) documentation of class members so that constructors and
-# destructors are listed first. If set to NO the constructors will appear in the
-# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS.
-# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief
-# member documentation.
-# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting
-# detailed member documentation.
-# The default value is: NO.
-
-SORT_MEMBERS_CTORS_1ST = NO
-
-# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy
-# of group names into alphabetical order. If set to NO the group names will
-# appear in their defined order.
-# The default value is: NO.
-
-SORT_GROUP_NAMES       = NO
-
-# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by
-# fully-qualified names, including namespaces. If set to NO, the class list will
-# be sorted only by class name, not including the namespace part.
-# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
-# Note: This option applies only to the class list, not to the alphabetical
-# list.
-# The default value is: NO.
-
-SORT_BY_SCOPE_NAME     = NO
-
-# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper
-# type resolution of all parameters of a function it will reject a match between
-# the prototype and the implementation of a member function even if there is
-# only one candidate or it is obvious which candidate to choose by doing a
-# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still
-# accept a match between prototype and implementation in such cases.
-# The default value is: NO.
-
-STRICT_PROTO_MATCHING  = NO
-
-# The GENERATE_TODOLIST tag can be used to enable (YES) or disable (NO) the todo
-# list. This list is created by putting \todo commands in the documentation.
-# The default value is: YES.
-
-GENERATE_TODOLIST      = YES
-
-# The GENERATE_TESTLIST tag can be used to enable (YES) or disable (NO) the test
-# list. This list is created by putting \test commands in the documentation.
-# The default value is: YES.
-
-GENERATE_TESTLIST      = YES
-
-# The GENERATE_BUGLIST tag can be used to enable (YES) or disable (NO) the bug
-# list. This list is created by putting \bug commands in the documentation.
-# The default value is: YES.
-
-GENERATE_BUGLIST       = YES
-
-# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or disable (NO)
-# the deprecated list. This list is created by putting \deprecated commands in
-# the documentation.
-# The default value is: YES.
-
-GENERATE_DEPRECATEDLIST= YES
-
-# The ENABLED_SECTIONS tag can be used to enable conditional documentation
-# sections, marked by \if <section_label> ... \endif and \cond <section_label>
-# ... \endcond blocks.
-
-ENABLED_SECTIONS       =
-
-# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the
-# initial value of a variable or macro / define can have for it to appear in the
-# documentation. If the initializer consists of more lines than specified here
-# it will be hidden. Use a value of 0 to hide initializers completely. The
-# appearance of the value of individual variables and macros / defines can be
-# controlled using \showinitializer or \hideinitializer command in the
-# documentation regardless of this setting.
-# Minimum value: 0, maximum value: 10000, default value: 30.
-
-MAX_INITIALIZER_LINES  = 30
-
-# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at
-# the bottom of the documentation of classes and structs. If set to YES, the
-# list will mention the files that were used to generate the documentation.
-# The default value is: YES.
-
-SHOW_USED_FILES        = YES
-
-# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This
-# will remove the Files entry from the Quick Index and from the Folder Tree View
-# (if specified).
-# The default value is: YES.
-
-SHOW_FILES             = YES
-
-# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces
-# page. This will remove the Namespaces entry from the Quick Index and from the
-# Folder Tree View (if specified).
-# The default value is: YES.
-
-SHOW_NAMESPACES        = YES
-
-# The FILE_VERSION_FILTER tag can be used to specify a program or script that
-# doxygen should invoke to get the current version for each file (typically from
-# the version control system). Doxygen will invoke the program by executing (via
-# popen()) the command command input-file, where command is the value of the
-# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided
-# by doxygen. Whatever the program writes to standard output is used as the file
-# version. For an example see the documentation.
-
-FILE_VERSION_FILTER    =
-
-# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
-# by doxygen. The layout file controls the global structure of the generated
-# output files in an output format independent way. To create the layout file
-# that represents doxygen's defaults, run doxygen with the -l option. You can
-# optionally specify a file name after the option, if omitted DoxygenLayout.xml
-# will be used as the name of the layout file.
-#
-# Note that if you run doxygen from a directory containing a file called
-# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
-# tag is left empty.
-
-LAYOUT_FILE            =
-
-# The CITE_BIB_FILES tag can be used to specify one or more bib files containing
-# the reference definitions. This must be a list of .bib files. The .bib
-# extension is automatically appended if omitted. This requires the bibtex tool
-# to be installed. See also https://en.wikipedia.org/wiki/BibTeX for more info.
-# For LaTeX the style of the bibliography can be controlled using
-# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
-# search path. See also \cite for info how to create references.
-
-CITE_BIB_FILES         =
-
-#---------------------------------------------------------------------------
-# Configuration options related to warning and progress messages
-#---------------------------------------------------------------------------
-
-# The QUIET tag can be used to turn on/off the messages that are generated to
-# standard output by doxygen. If QUIET is set to YES this implies that the
-# messages are off.
-# The default value is: NO.
-
-QUIET                  = NO
-
-# The WARNINGS tag can be used to turn on/off the warning messages that are
-# generated to standard error (stderr) by doxygen. If WARNINGS is set to YES
-# this implies that the warnings are on.
-#
-# Tip: Turn warnings on while writing the documentation.
-# The default value is: YES.
-
-WARNINGS               = YES
-
-# If the WARN_IF_UNDOCUMENTED tag is set to YES then doxygen will generate
-# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag
-# will automatically be disabled.
-# The default value is: YES.
-
-WARN_IF_UNDOCUMENTED   = YES
-
-# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
-# potential errors in the documentation, such as not documenting some parameters
-# in a documented function, or documenting parameters that don't exist or using
-# markup commands wrongly.
-# The default value is: YES.
-
-WARN_IF_DOC_ERROR      = YES
-
-# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
-# are documented, but have no documentation for their parameters or return
-# value. If set to NO, doxygen will only warn about wrong or incomplete
-# parameter documentation, but not about the absence of documentation. If
-# EXTRACT_ALL is set to YES then this flag will automatically be disabled.
-# The default value is: NO.
-
-WARN_NO_PARAMDOC       = NO
-
-# If the WARN_AS_ERROR tag is set to YES then doxygen will immediately stop when
-# a warning is encountered. If the WARN_AS_ERROR tag is set to FAIL_ON_WARNINGS
-# then doxygen will continue running as if WARN_AS_ERROR tag is set to NO, but
-# at the end of the doxygen process doxygen will return with a non-zero status.
-# Possible values are: NO, YES and FAIL_ON_WARNINGS.
-# The default value is: NO.
-
-WARN_AS_ERROR          = YES
-
-# The WARN_FORMAT tag determines the format of the warning messages that doxygen
-# can produce. The string should contain the $file, $line, and $text tags, which
-# will be replaced by the file and line number from which the warning originated
-# and the warning text. Optionally the format may contain $version, which will
-# be replaced by the version of the file (if it could be obtained via
-# FILE_VERSION_FILTER)
-# The default value is: $file:$line: $text.
-
-WARN_FORMAT            = "$file:$line: $text"
-
-# The WARN_LOGFILE tag can be used to specify a file to which warning and error
-# messages should be written. If left blank the output is written to standard
-# error (stderr).
-
-WARN_LOGFILE           =
-
-#---------------------------------------------------------------------------
-# Configuration options related to the input files
-#---------------------------------------------------------------------------
-
-# The INPUT tag is used to specify the files and/or directories that contain
-# documented source files. You may enter file names like myfile.cpp or
-# directories like /usr/src/myproject. Separate the files or directories with
-# spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
-# Note: If this tag is empty the current directory is searched.
-
-INPUT                  = include wasm-c-api/include
-
-# This tag can be used to specify the character encoding of the source files
-# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
-# libiconv (or the iconv built into libc) for the transcoding. See the libiconv
-# documentation (see:
-# https://www.gnu.org/software/libiconv/) for the list of possible encodings.
-# The default value is: UTF-8.
-
-INPUT_ENCODING         = UTF-8
-
-# If the value of the INPUT tag contains directories, you can use the
-# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
-# *.h) to filter out the source-files in the directories.
-#
-# Note that for custom extensions or not directly supported extensions you also
-# need to set EXTENSION_MAPPING for the extension otherwise the files are not
-# read by doxygen.
-#
-# Note the list of default checked file patterns might differ from the list of
-# default file extension mappings.
-#
-# If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp,
-# *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h,
-# *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc,
-# *.m, *.markdown, *.md, *.mm, *.dox (to be provided as doxygen C comment),
-# *.py, *.pyw, *.f90, *.f95, *.f03, *.f08, *.f18, *.f, *.for, *.vhd, *.vhdl,
-# *.ucf, *.qsf and *.ice.
-
-FILE_PATTERNS          = *.h
-
-# The RECURSIVE tag can be used to specify whether or not subdirectories should
-# be searched for input files as well.
-# The default value is: NO.
-
-RECURSIVE              = YES
-
-# The EXCLUDE tag can be used to specify files and/or directories that should be
-# excluded from the INPUT source files. This way you can easily exclude a
-# subdirectory from a directory tree whose root is specified with the INPUT tag.
-#
-# Note that relative paths are relative to the directory from which doxygen is
-# run.
-
-EXCLUDE                =
-
-# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
-# directories that are symbolic links (a Unix file system feature) are excluded
-# from the input.
-# The default value is: NO.
-
-EXCLUDE_SYMLINKS       = NO
-
-# If the value of the INPUT tag contains directories, you can use the
-# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
-# certain files from those directories.
-#
-# Note that the wildcards are matched against the file with absolute path, so to
-# exclude all test directories for example use the pattern */test/*
-
-EXCLUDE_PATTERNS       =
-
-# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
-# (namespaces, classes, functions, etc.) that should be excluded from the
-# output. The symbol name can be a fully qualified name, a word, or if the
-# wildcard * is used, a substring. Examples: ANamespace, AClass,
-# AClass::ANamespace, ANamespace::*Test
-#
-# Note that the wildcards are matched against the file with absolute path, so to
-# exclude all test directories use the pattern */test/*
-
-EXCLUDE_SYMBOLS        = assertions \
-                         WASM_DECLARE_* \
-                         WASM_API_EXTERN \
-                         WASI_API_EXTERN \
-                         WASMTIME_DECLARE_OWN \
-                         WASI_DECLARE_OWN \
-                         WASMTIME_CONFIG_PROP \
-                         own \
-                         wasm_*_enum
-
-# The EXAMPLE_PATH tag can be used to specify one or more files or directories
-# that contain example code fragments that are included (see the \include
-# command).
-
-EXAMPLE_PATH           = ../../examples
-
-# If the value of the EXAMPLE_PATH tag contains directories, you can use the
-# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and
-# *.h) to filter out the source-files in the directories. If left blank all
-# files are included.
-
-EXAMPLE_PATTERNS       = *.c
-
-# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
-# searched for input files to be used with the \include or \dontinclude commands
-# irrespective of the value of the RECURSIVE tag.
-# The default value is: NO.
-
-EXAMPLE_RECURSIVE      = YES
-
-# The IMAGE_PATH tag can be used to specify one or more files or directories
-# that contain images that are to be included in the documentation (see the
-# \image command).
-
-IMAGE_PATH             =
-
-# The INPUT_FILTER tag can be used to specify a program that doxygen should
-# invoke to filter for each input file. Doxygen will invoke the filter program
-# by executing (via popen()) the command:
-#
-# <filter> <input-file>
-#
-# where <filter> is the value of the INPUT_FILTER tag, and <input-file> is the
-# name of an input file. Doxygen will then use the output that the filter
-# program writes to standard output. If FILTER_PATTERNS is specified, this tag
-# will be ignored.
-#
-# Note that the filter must not add or remove lines; it is applied before the
-# code is scanned, but not when the output code is generated. If lines are added
-# or removed, the anchors will not be placed correctly.
-#
-# Note that for custom extensions or not directly supported extensions you also
-# need to set EXTENSION_MAPPING for the extension otherwise the files are not
-# properly processed by doxygen.
-
-INPUT_FILTER           =
-
-# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
-# basis. Doxygen will compare the file name with each pattern and apply the
-# filter if there is a match. The filters are a list of the form: pattern=filter
-# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how
-# filters are used. If the FILTER_PATTERNS tag is empty or if none of the
-# patterns match the file name, INPUT_FILTER is applied.
-#
-# Note that for custom extensions or not directly supported extensions you also
-# need to set EXTENSION_MAPPING for the extension otherwise the files are not
-# properly processed by doxygen.
-
-FILTER_PATTERNS        =
-
-# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
-# INPUT_FILTER) will also be used to filter the input files that are used for
-# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES).
-# The default value is: NO.
-
-FILTER_SOURCE_FILES    = NO
-
-# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
-# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and
-# it is also possible to disable source filtering for a specific pattern using
-# *.ext= (so without naming a filter).
-# This tag requires that the tag FILTER_SOURCE_FILES is set to YES.
-
-FILTER_SOURCE_PATTERNS =
-
-# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that
-# is part of the input, its contents will be placed on the main page
-# (index.html). This can be useful if you have a project on for instance GitHub
-# and want to reuse the introduction page also for the doxygen output.
-
-USE_MDFILE_AS_MAINPAGE =
-
-#---------------------------------------------------------------------------
-# Configuration options related to source browsing
-#---------------------------------------------------------------------------
-
-# If the SOURCE_BROWSER tag is set to YES then a list of source files will be
-# generated. Documented entities will be cross-referenced with these sources.
-#
-# Note: To get rid of all source code in the generated output, make sure that
-# also VERBATIM_HEADERS is set to NO.
-# The default value is: NO.
-
-SOURCE_BROWSER         = NO
-
-# Setting the INLINE_SOURCES tag to YES will include the body of functions,
-# classes and enums directly into the documentation.
-# The default value is: NO.
-
-INLINE_SOURCES         = NO
-
-# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any
-# special comment blocks from generated source code fragments. Normal C, C++ and
-# Fortran comments will always remain visible.
-# The default value is: YES.
-
-STRIP_CODE_COMMENTS    = YES
-
-# If the REFERENCED_BY_RELATION tag is set to YES then for each documented
-# entity all documented functions referencing it will be listed.
-# The default value is: NO.
-
-REFERENCED_BY_RELATION = NO
-
-# If the REFERENCES_RELATION tag is set to YES then for each documented function
-# all documented entities called/used by that function will be listed.
-# The default value is: NO.
-
-REFERENCES_RELATION    = NO
-
-# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set
-# to YES then the hyperlinks from functions in REFERENCES_RELATION and
-# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will
-# link to the documentation.
-# The default value is: YES.
-
-REFERENCES_LINK_SOURCE = YES
-
-# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the
-# source code will show a tooltip with additional information such as prototype,
-# brief description and links to the definition and documentation. Since this
-# will make the HTML file larger and loading of large files a bit slower, you
-# can opt to disable this feature.
-# The default value is: YES.
-# This tag requires that the tag SOURCE_BROWSER is set to YES.
-
-SOURCE_TOOLTIPS        = YES
-
-# If the USE_HTAGS tag is set to YES then the references to source code will
-# point to the HTML generated by the htags(1) tool instead of doxygen built-in
-# source browser. The htags tool is part of GNU's global source tagging system
-# (see https://www.gnu.org/software/global/global.html). You will need version
-# 4.8.6 or higher.
-#
-# To use it do the following:
-# - Install the latest version of global
-# - Enable SOURCE_BROWSER and USE_HTAGS in the configuration file
-# - Make sure the INPUT points to the root of the source tree
-# - Run doxygen as normal
-#
-# Doxygen will invoke htags (and that will in turn invoke gtags), so these
-# tools must be available from the command line (i.e. in the search path).
-#
-# The result: instead of the source browser generated by doxygen, the links to
-# source code will now point to the output of htags.
-# The default value is: NO.
-# This tag requires that the tag SOURCE_BROWSER is set to YES.
-
-USE_HTAGS              = NO
-
-# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a
-# verbatim copy of the header file for each class for which an include is
-# specified. Set to NO to disable this.
-# See also: Section \class.
-# The default value is: YES.
-
-VERBATIM_HEADERS       = YES
-
-#---------------------------------------------------------------------------
-# Configuration options related to the alphabetical class index
-#---------------------------------------------------------------------------
-
-# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all
-# compounds will be generated. Enable this if the project contains a lot of
-# classes, structs, unions or interfaces.
-# The default value is: YES.
-
-ALPHABETICAL_INDEX     = YES
-
-# In case all classes in a project start with a common prefix, all classes will
-# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
-# can be used to specify a prefix (or a list of prefixes) that should be ignored
-# while generating the index headers.
-# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
-
-IGNORE_PREFIX          =
-
-#---------------------------------------------------------------------------
-# Configuration options related to the HTML output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_HTML tag is set to YES, doxygen will generate HTML output
-# The default value is: YES.
-
-GENERATE_HTML          = YES
-
-# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it.
-# The default directory is: html.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_OUTPUT            = html
-
-# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each
-# generated HTML page (for example: .htm, .php, .asp).
-# The default value is: .html.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_FILE_EXTENSION    = .html
-
-# The HTML_HEADER tag can be used to specify a user-defined HTML header file for
-# each generated HTML page. If the tag is left blank doxygen will generate a
-# standard header.
-#
-# To get valid HTML the header file that includes any scripts and style sheets
-# that doxygen needs, which is dependent on the configuration options used (e.g.
-# the setting GENERATE_TREEVIEW). It is highly recommended to start with a
-# default header using
-# doxygen -w html new_header.html new_footer.html new_stylesheet.css
-# YourConfigFile
-# and then modify the file new_header.html. See also section "Doxygen usage"
-# for information on how to generate the default header that doxygen normally
-# uses.
-# Note: The header is subject to change so you typically have to regenerate the
-# default header when upgrading to a newer version of doxygen. For a description
-# of the possible markers and block names see the documentation.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_HEADER            =
-
-# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
-# generated HTML page. If the tag is left blank doxygen will generate a standard
-# footer. See HTML_HEADER for more information on how to generate a default
-# footer and what special commands can be used inside the footer. See also
-# section "Doxygen usage" for information on how to generate the default footer
-# that doxygen normally uses.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_FOOTER            =
-
-# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style
-# sheet that is used by each HTML page. It can be used to fine-tune the look of
-# the HTML output. If left blank doxygen will generate a default style sheet.
-# See also section "Doxygen usage" for information on how to generate the style
-# sheet that doxygen normally uses.
-# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as
-# it is more robust and this tag (HTML_STYLESHEET) will in the future become
-# obsolete.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_STYLESHEET        =
-
-# The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined
-# cascading style sheets that are included after the standard style sheets
-# created by doxygen. Using this option one can overrule certain style aspects.
-# This is preferred over using HTML_STYLESHEET since it does not replace the
-# standard style sheet and is therefore more robust against future updates.
-# Doxygen will copy the style sheet files to the output directory.
-# Note: The order of the extra style sheet files is of importance (e.g. the last
-# style sheet in the list overrules the setting of the previous ones in the
-# list). For an example see the documentation.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_EXTRA_STYLESHEET  =
-
-# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
-# other source files which should be copied to the HTML output directory. Note
-# that these files will be copied to the base HTML output directory. Use the
-# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
-# files. In the HTML_STYLESHEET file, use the file name only. Also note that the
-# files will be copied as-is; there are no commands or markers available.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_EXTRA_FILES       =
-
-# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
-# will adjust the colors in the style sheet and background images according to
-# this color. Hue is specified as an angle on a colorwheel, see
-# https://en.wikipedia.org/wiki/Hue for more information. For instance the value
-# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
-# purple, and 360 is red again.
-# Minimum value: 0, maximum value: 359, default value: 220.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_COLORSTYLE_HUE    = 220
-
-# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
-# in the HTML output. For a value of 0 the output will use grayscales only. A
-# value of 255 will produce the most vivid colors.
-# Minimum value: 0, maximum value: 255, default value: 100.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_COLORSTYLE_SAT    = 100
-
-# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the
-# luminance component of the colors in the HTML output. Values below 100
-# gradually make the output lighter, whereas values above 100 make the output
-# darker. The value divided by 100 is the actual gamma applied, so 80 represents
-# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not
-# change the gamma.
-# Minimum value: 40, maximum value: 240, default value: 80.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_COLORSTYLE_GAMMA  = 80
-
-# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
-# page will contain the date and time when the page was generated. Setting this
-# to YES can help to show when doxygen was last run and thus if the
-# documentation is up to date.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_TIMESTAMP         = NO
-
-# If the HTML_DYNAMIC_MENUS tag is set to YES then the generated HTML
-# documentation will contain a main index with vertical navigation menus that
-# are dynamically created via JavaScript. If disabled, the navigation index will
-# consists of multiple levels of tabs that are statically embedded in every HTML
-# page. Disable this option to support browsers that do not have JavaScript,
-# like the Qt help browser.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_DYNAMIC_MENUS     = YES
-
-# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
-# documentation will contain sections that can be hidden and shown after the
-# page has loaded.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_DYNAMIC_SECTIONS  = NO
-
-# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries
-# shown in the various tree structured indices initially; the user can expand
-# and collapse entries dynamically later on. Doxygen will expand the tree to
-# such a level that at most the specified number of entries are visible (unless
-# a fully collapsed tree already exceeds this amount). So setting the number of
-# entries 1 will produce a full collapsed tree by default. 0 is a special value
-# representing an infinite number of entries and will result in a full expanded
-# tree by default.
-# Minimum value: 0, maximum value: 9999, default value: 100.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_INDEX_NUM_ENTRIES = 100
-
-# If the GENERATE_DOCSET tag is set to YES, additional index files will be
-# generated that can be used as input for Apple's Xcode 3 integrated development
-# environment (see:
-# https://developer.apple.com/xcode/), introduced with OSX 10.5 (Leopard). To
-# create a documentation set, doxygen will generate a Makefile in the HTML
-# output directory. Running make will produce the docset in that directory and
-# running make install will install the docset in
-# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
-# startup. See https://developer.apple.com/library/archive/featuredarticles/Doxy
-# genXcode/_index.html for more information.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_DOCSET        = NO
-
-# This tag determines the name of the docset feed. A documentation feed provides
-# an umbrella under which multiple documentation sets from a single provider
-# (such as a company or product suite) can be grouped.
-# The default value is: Doxygen generated docs.
-# This tag requires that the tag GENERATE_DOCSET is set to YES.
-
-DOCSET_FEEDNAME        = "Doxygen generated docs"
-
-# This tag specifies a string that should uniquely identify the documentation
-# set bundle. This should be a reverse domain-name style string, e.g.
-# com.mycompany.MyDocSet. Doxygen will append .docset to the name.
-# The default value is: org.doxygen.Project.
-# This tag requires that the tag GENERATE_DOCSET is set to YES.
-
-DOCSET_BUNDLE_ID       = org.doxygen.Project
-
-# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify
-# the documentation publisher. This should be a reverse domain-name style
-# string, e.g. com.mycompany.MyDocSet.documentation.
-# The default value is: org.doxygen.Publisher.
-# This tag requires that the tag GENERATE_DOCSET is set to YES.
-
-DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
-
-# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher.
-# The default value is: Publisher.
-# This tag requires that the tag GENERATE_DOCSET is set to YES.
-
-DOCSET_PUBLISHER_NAME  = Publisher
-
-# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
-# additional HTML index files: index.hhp, index.hhc, and index.hhk. The
-# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
-# (see:
-# https://www.microsoft.com/en-us/download/details.aspx?id=21138) on Windows.
-#
-# The HTML Help Workshop contains a compiler that can convert all HTML output
-# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
-# files are now used as the Windows 98 help format, and will replace the old
-# Windows help format (.hlp) on all Windows platforms in the future. Compressed
-# HTML files also contain an index, a table of contents, and you can search for
-# words in the documentation. The HTML workshop also contains a viewer for
-# compressed HTML files.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_HTMLHELP      = NO
-
-# The CHM_FILE tag can be used to specify the file name of the resulting .chm
-# file. You can add a path in front of the file if the result should not be
-# written to the html output directory.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-CHM_FILE               =
-
-# The HHC_LOCATION tag can be used to specify the location (absolute path
-# including file name) of the HTML help compiler (hhc.exe). If non-empty,
-# doxygen will try to run the HTML help compiler on the generated index.hhp.
-# The file has to be specified with full path.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-HHC_LOCATION           =
-
-# The GENERATE_CHI flag controls if a separate .chi index file is generated
-# (YES) or that it should be included in the main .chm file (NO).
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-GENERATE_CHI           = NO
-
-# The CHM_INDEX_ENCODING is used to encode HtmlHelp index (hhk), content (hhc)
-# and project file content.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-CHM_INDEX_ENCODING     =
-
-# The BINARY_TOC flag controls whether a binary table of contents is generated
-# (YES) or a normal table of contents (NO) in the .chm file. Furthermore it
-# enables the Previous and Next buttons.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-BINARY_TOC             = NO
-
-# The TOC_EXPAND flag can be set to YES to add extra items for group members to
-# the table of contents of the HTML help documentation and to the tree view.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-TOC_EXPAND             = NO
-
-# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
-# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that
-# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help
-# (.qch) of the generated HTML documentation.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_QHP           = NO
-
-# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify
-# the file name of the resulting .qch file. The path specified is relative to
-# the HTML output folder.
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QCH_FILE               =
-
-# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
-# Project output. For more information please see Qt Help Project / Namespace
-# (see:
-# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#namespace).
-# The default value is: org.doxygen.Project.
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_NAMESPACE          = org.doxygen.Project
-
-# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
-# Help Project output. For more information please see Qt Help Project / Virtual
-# Folders (see:
-# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#virtual-folders).
-# The default value is: doc.
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_VIRTUAL_FOLDER     = doc
-
-# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
-# filter to add. For more information please see Qt Help Project / Custom
-# Filters (see:
-# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters).
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_CUST_FILTER_NAME   =
-
-# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
-# custom filter to add. For more information please see Qt Help Project / Custom
-# Filters (see:
-# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters).
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_CUST_FILTER_ATTRS  =
-
-# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
-# project's filter section matches. Qt Help Project / Filter Attributes (see:
-# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#filter-attributes).
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_SECT_FILTER_ATTRS  =
-
-# The QHG_LOCATION tag can be used to specify the location (absolute path
-# including file name) of Qt's qhelpgenerator. If non-empty doxygen will try to
-# run qhelpgenerator on the generated .qhp file.
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHG_LOCATION           =
-
-# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be
-# generated, together with the HTML files, they form an Eclipse help plugin. To
-# install this plugin and make it available under the help contents menu in
-# Eclipse, the contents of the directory containing the HTML and XML files needs
-# to be copied into the plugins directory of eclipse. The name of the directory
-# within the plugins directory should be the same as the ECLIPSE_DOC_ID value.
-# After copying Eclipse needs to be restarted before the help appears.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_ECLIPSEHELP   = NO
-
-# A unique identifier for the Eclipse help plugin. When installing the plugin
-# the directory name containing the HTML and XML files should also have this
-# name. Each documentation set should have its own identifier.
-# The default value is: org.doxygen.Project.
-# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES.
-
-ECLIPSE_DOC_ID         = org.doxygen.Project
-
-# If you want full control over the layout of the generated HTML pages it might
-# be necessary to disable the index and replace it with your own. The
-# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top
-# of each HTML page. A value of NO enables the index and the value YES disables
-# it. Since the tabs in the index contain the same information as the navigation
-# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-DISABLE_INDEX          = NO
-
-# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
-# structure should be generated to display hierarchical information. If the tag
-# value is set to YES, a side panel will be generated containing a tree-like
-# index structure (just like the one that is generated for HTML Help). For this
-# to work a browser that supports JavaScript, DHTML, CSS and frames is required
-# (i.e. any modern browser). Windows users are probably better off using the
-# HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can
-# further fine-tune the look of the index. As an example, the default style
-# sheet generated by doxygen has an example that shows how to put an image at
-# the root of the tree instead of the PROJECT_NAME. Since the tree basically has
-# the same information as the tab index, you could consider setting
-# DISABLE_INDEX to YES when enabling this option.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_TREEVIEW      = YES
-
-# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
-# doxygen will group on one line in the generated HTML documentation.
-#
-# Note that a value of 0 will completely suppress the enum values from appearing
-# in the overview section.
-# Minimum value: 0, maximum value: 20, default value: 4.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-ENUM_VALUES_PER_LINE   = 4
-
-# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used
-# to set the initial width (in pixels) of the frame in which the tree is shown.
-# Minimum value: 0, maximum value: 1500, default value: 250.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-TREEVIEW_WIDTH         = 250
-
-# If the EXT_LINKS_IN_WINDOW option is set to YES, doxygen will open links to
-# external symbols imported via tag files in a separate window.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-EXT_LINKS_IN_WINDOW    = NO
-
-# If the HTML_FORMULA_FORMAT option is set to svg, doxygen will use the pdf2svg
-# tool (see https://github.com/dawbarton/pdf2svg) or inkscape (see
-# https://inkscape.org) to generate formulas as SVG images instead of PNGs for
-# the HTML output. These images will generally look nicer at scaled resolutions.
-# Possible values are: png (the default) and svg (looks nicer but requires the
-# pdf2svg or inkscape tool).
-# The default value is: png.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_FORMULA_FORMAT    = png
-
-# Use this tag to change the font size of LaTeX formulas included as images in
-# the HTML documentation. When you change the font size after a successful
-# doxygen run you need to manually remove any form_*.png images from the HTML
-# output directory to force them to be regenerated.
-# Minimum value: 8, maximum value: 50, default value: 10.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-FORMULA_FONTSIZE       = 10
-
-# Use the FORMULA_TRANSPARENT tag to determine whether or not the images
-# generated for formulas are transparent PNGs. Transparent PNGs are not
-# supported properly for IE 6.0, but are supported on all modern browsers.
-#
-# Note that when changing this option you need to delete any form_*.png files in
-# the HTML output directory before the changes have effect.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-FORMULA_TRANSPARENT    = YES
-
-# The FORMULA_MACROFILE can contain LaTeX \newcommand and \renewcommand commands
-# to create new LaTeX commands to be used in formulas as building blocks. See
-# the section "Including formulas" for details.
-
-FORMULA_MACROFILE      =
-
-# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
-# https://www.mathjax.org) which uses client side JavaScript for the rendering
-# instead of using pre-rendered bitmaps. Use this if you do not have LaTeX
-# installed or if you want to formulas look prettier in the HTML output. When
-# enabled you may also need to install MathJax separately and configure the path
-# to it using the MATHJAX_RELPATH option.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-USE_MATHJAX            = NO
-
-# When MathJax is enabled you can set the default output format to be used for
-# the MathJax output. See the MathJax site (see:
-# http://docs.mathjax.org/en/v2.7-latest/output.html) for more details.
-# Possible values are: HTML-CSS (which is slower, but has the best
-# compatibility), NativeMML (i.e. MathML) and SVG.
-# The default value is: HTML-CSS.
-# This tag requires that the tag USE_MATHJAX is set to YES.
-
-MATHJAX_FORMAT         = HTML-CSS
-
-# When MathJax is enabled you need to specify the location relative to the HTML
-# output directory using the MATHJAX_RELPATH option. The destination directory
-# should contain the MathJax.js script. For instance, if the mathjax directory
-# is located at the same level as the HTML output directory, then
-# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
-# Content Delivery Network so you can quickly see the result without installing
-# MathJax. However, it is strongly recommended to install a local copy of
-# MathJax from https://www.mathjax.org before deployment.
-# The default value is: https://cdn.jsdelivr.net/npm/mathjax@2.
-# This tag requires that the tag USE_MATHJAX is set to YES.
-
-MATHJAX_RELPATH        = https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/
-
-# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
-# extension names that should be enabled during MathJax rendering. For example
-# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
-# This tag requires that the tag USE_MATHJAX is set to YES.
-
-MATHJAX_EXTENSIONS     =
-
-# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
-# of code that will be used on startup of the MathJax code. See the MathJax site
-# (see:
-# http://docs.mathjax.org/en/v2.7-latest/output.html) for more details. For an
-# example see the documentation.
-# This tag requires that the tag USE_MATHJAX is set to YES.
-
-MATHJAX_CODEFILE       =
-
-# When the SEARCHENGINE tag is enabled doxygen will generate a search box for
-# the HTML output. The underlying search engine uses javascript and DHTML and
-# should work on any modern browser. Note that when using HTML help
-# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET)
-# there is already a search function so this one should typically be disabled.
-# For large projects the javascript based search engine can be slow, then
-# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to
-# search using the keyboard; to jump to the search box use <access key> + S
-# (what the <access key> is depends on the OS and browser, but it is typically
-# <CTRL>, <ALT>/<option>, or both). Inside the search box use the <cursor down
-# key> to jump into the search results window, the results can be navigated
-# using the <cursor keys>. Press <Enter> to select an item or <escape> to cancel
-# the search. The filter options can be selected when the cursor is inside the
-# search box by pressing <Shift>+<cursor down>. Also here use the <cursor keys>
-# to select a filter and <Enter> or <escape> to activate or cancel the filter
-# option.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-SEARCHENGINE           = YES
-
-# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
-# implemented using a web server instead of a web client using JavaScript. There
-# are two flavors of web server based searching depending on the EXTERNAL_SEARCH
-# setting. When disabled, doxygen will generate a PHP script for searching and
-# an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
-# and searching needs to be provided by external tools. See the section
-# "External Indexing and Searching" for details.
-# The default value is: NO.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-SERVER_BASED_SEARCH    = NO
-
-# When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP
-# script for searching. Instead the search results are written to an XML file
-# which needs to be processed by an external indexer. Doxygen will invoke an
-# external search engine pointed to by the SEARCHENGINE_URL option to obtain the
-# search results.
-#
-# Doxygen ships with an example indexer (doxyindexer) and search engine
-# (doxysearch.cgi) which are based on the open source search engine library
-# Xapian (see:
-# https://xapian.org/).
-#
-# See the section "External Indexing and Searching" for details.
-# The default value is: NO.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-EXTERNAL_SEARCH        = NO
-
-# The SEARCHENGINE_URL should point to a search engine hosted by a web server
-# which will return the search results when EXTERNAL_SEARCH is enabled.
-#
-# Doxygen ships with an example indexer (doxyindexer) and search engine
-# (doxysearch.cgi) which are based on the open source search engine library
-# Xapian (see:
-# https://xapian.org/). See the section "External Indexing and Searching" for
-# details.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-SEARCHENGINE_URL       =
-
-# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
-# search data is written to a file for indexing by an external tool. With the
-# SEARCHDATA_FILE tag the name of this file can be specified.
-# The default file is: searchdata.xml.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-SEARCHDATA_FILE        = searchdata.xml
-
-# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the
-# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
-# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
-# projects and redirect the results back to the right project.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-EXTERNAL_SEARCH_ID     =
-
-# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
-# projects other than the one defined by this configuration file, but that are
-# all added to the same external search index. Each project needs to have a
-# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of
-# to a relative location where the documentation can be found. The format is:
-# EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ...
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-EXTRA_SEARCH_MAPPINGS  =
-
-#---------------------------------------------------------------------------
-# Configuration options related to the LaTeX output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_LATEX tag is set to YES, doxygen will generate LaTeX output.
-# The default value is: YES.
-
-GENERATE_LATEX         = NO
-
-# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it.
-# The default directory is: latex.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_OUTPUT           = latex
-
-# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
-# invoked.
-#
-# Note that when not enabling USE_PDFLATEX the default is latex when enabling
-# USE_PDFLATEX the default is pdflatex and when in the later case latex is
-# chosen this is overwritten by pdflatex. For specific output languages the
-# default can have been set differently, this depends on the implementation of
-# the output language.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_CMD_NAME         =
-
-# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
-# index for LaTeX.
-# Note: This tag is used in the Makefile / make.bat.
-# See also: LATEX_MAKEINDEX_CMD for the part in the generated output file
-# (.tex).
-# The default file is: makeindex.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-MAKEINDEX_CMD_NAME     = makeindex
-
-# The LATEX_MAKEINDEX_CMD tag can be used to specify the command name to
-# generate index for LaTeX. In case there is no backslash (\) as first character
-# it will be automatically added in the LaTeX code.
-# Note: This tag is used in the generated output file (.tex).
-# See also: MAKEINDEX_CMD_NAME for the part in the Makefile / make.bat.
-# The default value is: makeindex.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_MAKEINDEX_CMD    = makeindex
-
-# If the COMPACT_LATEX tag is set to YES, doxygen generates more compact LaTeX
-# documents. This may be useful for small projects and may help to save some
-# trees in general.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-COMPACT_LATEX          = NO
-
-# The PAPER_TYPE tag can be used to set the paper type that is used by the
-# printer.
-# Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x
-# 14 inches) and executive (7.25 x 10.5 inches).
-# The default value is: a4.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-PAPER_TYPE             = a4
-
-# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
-# that should be included in the LaTeX output. The package can be specified just
-# by its name or with the correct syntax as to be used with the LaTeX
-# \usepackage command. To get the times font for instance you can specify :
-# EXTRA_PACKAGES=times or EXTRA_PACKAGES={times}
-# To use the option intlimits with the amsmath package you can specify:
-# EXTRA_PACKAGES=[intlimits]{amsmath}
-# If left blank no extra packages will be included.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-EXTRA_PACKAGES         =
-
-# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
-# generated LaTeX document. The header should contain everything until the first
-# chapter. If it is left blank doxygen will generate a standard header. See
-# section "Doxygen usage" for information on how to let doxygen write the
-# default header to a separate file.
-#
-# Note: Only use a user-defined header if you know what you are doing! The
-# following commands have a special meaning inside the header: $title,
-# $datetime, $date, $doxygenversion, $projectname, $projectnumber,
-# $projectbrief, $projectlogo. Doxygen will replace $title with the empty
-# string, for the replacement values of the other commands the user is referred
-# to HTML_HEADER.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_HEADER           =
-
-# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
-# generated LaTeX document. The footer should contain everything after the last
-# chapter. If it is left blank doxygen will generate a standard footer. See
-# LATEX_HEADER for more information on how to generate a default footer and what
-# special commands can be used inside the footer.
-#
-# Note: Only use a user-defined footer if you know what you are doing!
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_FOOTER           =
-
-# The LATEX_EXTRA_STYLESHEET tag can be used to specify additional user-defined
-# LaTeX style sheets that are included after the standard style sheets created
-# by doxygen. Using this option one can overrule certain style aspects. Doxygen
-# will copy the style sheet files to the output directory.
-# Note: The order of the extra style sheet files is of importance (e.g. the last
-# style sheet in the list overrules the setting of the previous ones in the
-# list).
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_EXTRA_STYLESHEET =
-
-# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
-# other source files which should be copied to the LATEX_OUTPUT output
-# directory. Note that the files will be copied as-is; there are no commands or
-# markers available.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_EXTRA_FILES      =
-
-# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is
-# prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will
-# contain links (just like the HTML output) instead of page references. This
-# makes the output suitable for online browsing using a PDF viewer.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-PDF_HYPERLINKS         = YES
-
-# If the USE_PDFLATEX tag is set to YES, doxygen will use the engine as
-# specified with LATEX_CMD_NAME to generate the PDF file directly from the LaTeX
-# files. Set this option to YES, to get a higher quality PDF documentation.
-#
-# See also section LATEX_CMD_NAME for selecting the engine.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-USE_PDFLATEX           = YES
-
-# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
-# command to the generated LaTeX files. This will instruct LaTeX to keep running
-# if errors occur, instead of asking the user for help. This option is also used
-# when generating formulas in HTML.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_BATCHMODE        = NO
-
-# If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the
-# index chapters (such as File Index, Compound Index, etc.) in the output.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_HIDE_INDICES     = NO
-
-# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
-# code with syntax highlighting in the LaTeX output.
-#
-# Note that which sources are shown also depends on other settings such as
-# SOURCE_BROWSER.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_SOURCE_CODE      = NO
-
-# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
-# bibliography, e.g. plainnat, or ieeetr. See
-# https://en.wikipedia.org/wiki/BibTeX and \cite for more info.
-# The default value is: plain.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_BIB_STYLE        = plain
-
-# If the LATEX_TIMESTAMP tag is set to YES then the footer of each generated
-# page will contain the date and time when the page was generated. Setting this
-# to NO can help when comparing the output of multiple runs.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_TIMESTAMP        = NO
-
-# The LATEX_EMOJI_DIRECTORY tag is used to specify the (relative or absolute)
-# path from which the emoji images will be read. If a relative path is entered,
-# it will be relative to the LATEX_OUTPUT directory. If left blank the
-# LATEX_OUTPUT directory will be used.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_EMOJI_DIRECTORY  =
-
-#---------------------------------------------------------------------------
-# Configuration options related to the RTF output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_RTF tag is set to YES, doxygen will generate RTF output. The
-# RTF output is optimized for Word 97 and may not look too pretty with other RTF
-# readers/editors.
-# The default value is: NO.
-
-GENERATE_RTF           = NO
-
-# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it.
-# The default directory is: rtf.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_OUTPUT             = rtf
-
-# If the COMPACT_RTF tag is set to YES, doxygen generates more compact RTF
-# documents. This may be useful for small projects and may help to save some
-# trees in general.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-COMPACT_RTF            = NO
-
-# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will
-# contain hyperlink fields. The RTF file will contain links (just like the HTML
-# output) instead of page references. This makes the output suitable for online
-# browsing using Word or some other Word compatible readers that support those
-# fields.
-#
-# Note: WordPad (write) and others do not support links.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_HYPERLINKS         = NO
-
-# Load stylesheet definitions from file. Syntax is similar to doxygen's
-# configuration file, i.e. a series of assignments. You only have to provide
-# replacements, missing definitions are set to their default value.
-#
-# See also section "Doxygen usage" for information on how to generate the
-# default style sheet that doxygen normally uses.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_STYLESHEET_FILE    =
-
-# Set optional variables used in the generation of an RTF document. Syntax is
-# similar to doxygen's configuration file. A template extensions file can be
-# generated using doxygen -e rtf extensionFile.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_EXTENSIONS_FILE    =
-
-# If the RTF_SOURCE_CODE tag is set to YES then doxygen will include source code
-# with syntax highlighting in the RTF output.
-#
-# Note that which sources are shown also depends on other settings such as
-# SOURCE_BROWSER.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_SOURCE_CODE        = NO
-
-#---------------------------------------------------------------------------
-# Configuration options related to the man page output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_MAN tag is set to YES, doxygen will generate man pages for
-# classes and files.
-# The default value is: NO.
-
-GENERATE_MAN           = NO
-
-# The MAN_OUTPUT tag is used to specify where the man pages will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it. A directory man3 will be created inside the directory specified by
-# MAN_OUTPUT.
-# The default directory is: man.
-# This tag requires that the tag GENERATE_MAN is set to YES.
-
-MAN_OUTPUT             = man
-
-# The MAN_EXTENSION tag determines the extension that is added to the generated
-# man pages. In case the manual section does not start with a number, the number
-# 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is
-# optional.
-# The default value is: .3.
-# This tag requires that the tag GENERATE_MAN is set to YES.
-
-MAN_EXTENSION          = .3
-
-# The MAN_SUBDIR tag determines the name of the directory created within
-# MAN_OUTPUT in which the man pages are placed. If defaults to man followed by
-# MAN_EXTENSION with the initial . removed.
-# This tag requires that the tag GENERATE_MAN is set to YES.
-
-MAN_SUBDIR             =
-
-# If the MAN_LINKS tag is set to YES and doxygen generates man output, then it
-# will generate one additional man file for each entity documented in the real
-# man page(s). These additional files only source the real man page, but without
-# them the man command would be unable to find the correct page.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_MAN is set to YES.
-
-MAN_LINKS              = NO
-
-#---------------------------------------------------------------------------
-# Configuration options related to the XML output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_XML tag is set to YES, doxygen will generate an XML file that
-# captures the structure of the code including all documentation.
-# The default value is: NO.
-
-GENERATE_XML           = NO
-
-# The XML_OUTPUT tag is used to specify where the XML pages will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it.
-# The default directory is: xml.
-# This tag requires that the tag GENERATE_XML is set to YES.
-
-XML_OUTPUT             = xml
-
-# If the XML_PROGRAMLISTING tag is set to YES, doxygen will dump the program
-# listings (including syntax highlighting and cross-referencing information) to
-# the XML output. Note that enabling this will significantly increase the size
-# of the XML output.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_XML is set to YES.
-
-XML_PROGRAMLISTING     = YES
-
-# If the XML_NS_MEMB_FILE_SCOPE tag is set to YES, doxygen will include
-# namespace members in file scope as well, matching the HTML output.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_XML is set to YES.
-
-XML_NS_MEMB_FILE_SCOPE = NO
-
-#---------------------------------------------------------------------------
-# Configuration options related to the DOCBOOK output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_DOCBOOK tag is set to YES, doxygen will generate Docbook files
-# that can be used to generate PDF.
-# The default value is: NO.
-
-GENERATE_DOCBOOK       = NO
-
-# The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put.
-# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
-# front of it.
-# The default directory is: docbook.
-# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
-
-DOCBOOK_OUTPUT         = docbook
-
-# If the DOCBOOK_PROGRAMLISTING tag is set to YES, doxygen will include the
-# program listings (including syntax highlighting and cross-referencing
-# information) to the DOCBOOK output. Note that enabling this will significantly
-# increase the size of the DOCBOOK output.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
-
-DOCBOOK_PROGRAMLISTING = NO
-
-#---------------------------------------------------------------------------
-# Configuration options for the AutoGen Definitions output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_AUTOGEN_DEF tag is set to YES, doxygen will generate an
-# AutoGen Definitions (see http://autogen.sourceforge.net/) file that captures
-# the structure of the code including all documentation. Note that this feature
-# is still experimental and incomplete at the moment.
-# The default value is: NO.
-
-GENERATE_AUTOGEN_DEF   = NO
-
-#---------------------------------------------------------------------------
-# Configuration options related to the Perl module output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_PERLMOD tag is set to YES, doxygen will generate a Perl module
-# file that captures the structure of the code including all documentation.
-#
-# Note that this feature is still experimental and incomplete at the moment.
-# The default value is: NO.
-
-GENERATE_PERLMOD       = NO
-
-# If the PERLMOD_LATEX tag is set to YES, doxygen will generate the necessary
-# Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI
-# output from the Perl module output.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_PERLMOD is set to YES.
-
-PERLMOD_LATEX          = NO
-
-# If the PERLMOD_PRETTY tag is set to YES, the Perl module output will be nicely
-# formatted so it can be parsed by a human reader. This is useful if you want to
-# understand what is going on. On the other hand, if this tag is set to NO, the
-# size of the Perl module output will be much smaller and Perl will parse it
-# just the same.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_PERLMOD is set to YES.
-
-PERLMOD_PRETTY         = YES
-
-# The names of the make variables in the generated doxyrules.make file are
-# prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. This is useful
-# so different doxyrules.make files included by the same Makefile don't
-# overwrite each other's variables.
-# This tag requires that the tag GENERATE_PERLMOD is set to YES.
-
-PERLMOD_MAKEVAR_PREFIX =
-
-#---------------------------------------------------------------------------
-# Configuration options related to the preprocessor
-#---------------------------------------------------------------------------
-
-# If the ENABLE_PREPROCESSING tag is set to YES, doxygen will evaluate all
-# C-preprocessor directives found in the sources and include files.
-# The default value is: YES.
-
-ENABLE_PREPROCESSING   = YES
-
-# If the MACRO_EXPANSION tag is set to YES, doxygen will expand all macro names
-# in the source code. If set to NO, only conditional compilation will be
-# performed. Macro expansion can be done in a controlled way by setting
-# EXPAND_ONLY_PREDEF to YES.
-# The default value is: NO.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-MACRO_EXPANSION        = YES
-
-# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
-# the macro expansion is limited to the macros specified with the PREDEFINED and
-# EXPAND_AS_DEFINED tags.
-# The default value is: NO.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-EXPAND_ONLY_PREDEF     = NO
-
-# If the SEARCH_INCLUDES tag is set to YES, the include files in the
-# INCLUDE_PATH will be searched if a #include is found.
-# The default value is: YES.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-SEARCH_INCLUDES        = YES
-
-# The INCLUDE_PATH tag can be used to specify one or more directories that
-# contain include files that are not input files but should be processed by the
-# preprocessor.
-# This tag requires that the tag SEARCH_INCLUDES is set to YES.
-
-INCLUDE_PATH           = wasm-c-api/include \
-                         include
-
-# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
-# patterns (like *.h and *.hpp) to filter out the header-files in the
-# directories. If left blank, the patterns specified with FILE_PATTERNS will be
-# used.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-INCLUDE_FILE_PATTERNS  = *.h
-
-# The PREDEFINED tag can be used to specify one or more macro names that are
-# defined before the preprocessor is started (similar to the -D option of e.g.
-# gcc). The argument of the tag is a list of macros of the form: name or
-# name=definition (no spaces). If the definition and the "=" are omitted, "=1"
-# is assumed. To prevent a macro definition from being undefined via #undef or
-# recursively expanded use the := operator instead of the = operator.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-PREDEFINED             =
-
-# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
-# tag can be used to specify a list of macro names that should be expanded. The
-# macro definition that is found in the sources will be used. Use the PREDEFINED
-# tag if you want to use a different macro definition that overrules the
-# definition found in the source code.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-EXPAND_AS_DEFINED      =
-
-# If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
-# remove all references to function-like macros that are alone on a line, have
-# an all uppercase name, and do not end with a semicolon. Such function macros
-# are typically used for boiler-plate code, and will confuse the parser if not
-# removed.
-# The default value is: YES.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-SKIP_FUNCTION_MACROS   = YES
-
-#---------------------------------------------------------------------------
-# Configuration options related to external references
-#---------------------------------------------------------------------------
-
-# The TAGFILES tag can be used to specify one or more tag files. For each tag
-# file the location of the external documentation should be added. The format of
-# a tag file without this location is as follows:
-# TAGFILES = file1 file2 ...
-# Adding location for the tag files is done as follows:
-# TAGFILES = file1=loc1 "file2 = loc2" ...
-# where loc1 and loc2 can be relative or absolute paths or URLs. See the
-# section "Linking to external documentation" for more information about the use
-# of tag files.
-# Note: Each tag file must have a unique name (where the name does NOT include
-# the path). If a tag file is not located in the directory in which doxygen is
-# run, you must also specify the path to the tagfile here.
-
-TAGFILES               =
-
-# When a file name is specified after GENERATE_TAGFILE, doxygen will create a
-# tag file that is based on the input files it reads. See section "Linking to
-# external documentation" for more information about the usage of tag files.
-
-GENERATE_TAGFILE       =
-
-# If the ALLEXTERNALS tag is set to YES, all external class will be listed in
-# the class index. If set to NO, only the inherited external classes will be
-# listed.
-# The default value is: NO.
-
-ALLEXTERNALS           = NO
-
-# If the EXTERNAL_GROUPS tag is set to YES, all external groups will be listed
-# in the modules index. If set to NO, only the current project's groups will be
-# listed.
-# The default value is: YES.
-
-EXTERNAL_GROUPS        = YES
-
-# If the EXTERNAL_PAGES tag is set to YES, all external pages will be listed in
-# the related pages index. If set to NO, only the current project's pages will
-# be listed.
-# The default value is: YES.
-
-EXTERNAL_PAGES         = YES
-
-#---------------------------------------------------------------------------
-# Configuration options related to the dot tool
-#---------------------------------------------------------------------------
-
-# If the CLASS_DIAGRAMS tag is set to YES, doxygen will generate a class diagram
-# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
-# NO turns the diagrams off. Note that this option also works with HAVE_DOT
-# disabled, but it is recommended to install and use dot, since it yields more
-# powerful graphs.
-# The default value is: YES.
-
-CLASS_DIAGRAMS         = YES
-
-# You can include diagrams made with dia in doxygen documentation. Doxygen will
-# then run dia to produce the diagram and insert it in the documentation. The
-# DIA_PATH tag allows you to specify the directory where the dia binary resides.
-# If left empty dia is assumed to be found in the default search path.
-
-DIA_PATH               =
-
-# If set to YES the inheritance and collaboration graphs will hide inheritance
-# and usage relations if the target is undocumented or is not a class.
-# The default value is: YES.
-
-HIDE_UNDOC_RELATIONS   = YES
-
-# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
-# available from the path. This tool is part of Graphviz (see:
-# http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
-# Bell Labs. The other options in this section have no effect if this option is
-# set to NO
-# The default value is: NO.
-
-HAVE_DOT               = NO
-
-# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed
-# to run in parallel. When set to 0 doxygen will base this on the number of
-# processors available in the system. You can set it explicitly to a value
-# larger than 0 to get control over the balance between CPU load and processing
-# speed.
-# Minimum value: 0, maximum value: 32, default value: 0.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_NUM_THREADS        = 0
-
-# When you want a differently looking font in the dot files that doxygen
-# generates you can specify the font name using DOT_FONTNAME. You need to make
-# sure dot is able to find the font, which can be done by putting it in a
-# standard location or by setting the DOTFONTPATH environment variable or by
-# setting DOT_FONTPATH to the directory containing the font.
-# The default value is: Helvetica.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_FONTNAME           = Helvetica
-
-# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
-# dot graphs.
-# Minimum value: 4, maximum value: 24, default value: 10.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_FONTSIZE           = 10
-
-# By default doxygen will tell dot to use the default font as specified with
-# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
-# the path where dot can find it using this tag.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_FONTPATH           =
-
-# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
-# each documented class showing the direct and indirect inheritance relations.
-# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-CLASS_GRAPH            = YES
-
-# If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
-# graph for each documented class showing the direct and indirect implementation
-# dependencies (inheritance, containment, and class references variables) of the
-# class with other documented classes.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-COLLABORATION_GRAPH    = YES
-
-# If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
-# groups, showing the direct groups dependencies.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-GROUP_GRAPHS           = YES
-
-# If the UML_LOOK tag is set to YES, doxygen will generate inheritance and
-# collaboration diagrams in a style similar to the OMG's Unified Modeling
-# Language.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-UML_LOOK               = NO
-
-# If the UML_LOOK tag is enabled, the fields and methods are shown inside the
-# class node. If there are many fields or methods and many nodes the graph may
-# become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the
-# number of items for each type to make the size more manageable. Set this to 0
-# for no limit. Note that the threshold may be exceeded by 50% before the limit
-# is enforced. So when you set the threshold to 10, up to 15 fields may appear,
-# but if the number exceeds 15, the total amount of fields shown is limited to
-# 10.
-# Minimum value: 0, maximum value: 100, default value: 10.
-# This tag requires that the tag UML_LOOK is set to YES.
-
-UML_LIMIT_NUM_FIELDS   = 10
-
-# If the DOT_UML_DETAILS tag is set to NO, doxygen will show attributes and
-# methods without types and arguments in the UML graphs. If the DOT_UML_DETAILS
-# tag is set to YES, doxygen will add type and arguments for attributes and
-# methods in the UML graphs. If the DOT_UML_DETAILS tag is set to NONE, doxygen
-# will not generate fields with class member information in the UML graphs. The
-# class diagrams will look similar to the default class diagrams but using UML
-# notation for the relationships.
-# Possible values are: NO, YES and NONE.
-# The default value is: NO.
-# This tag requires that the tag UML_LOOK is set to YES.
-
-DOT_UML_DETAILS        = NO
-
-# The DOT_WRAP_THRESHOLD tag can be used to set the maximum number of characters
-# to display on a single line. If the actual line length exceeds this threshold
-# significantly it will wrapped across multiple lines. Some heuristics are apply
-# to avoid ugly line breaks.
-# Minimum value: 0, maximum value: 1000, default value: 17.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_WRAP_THRESHOLD     = 17
-
-# If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
-# collaboration graphs will show the relations between templates and their
-# instances.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-TEMPLATE_RELATIONS     = NO
-
-# If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to
-# YES then doxygen will generate a graph for each documented file showing the
-# direct and indirect include dependencies of the file with other documented
-# files.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-INCLUDE_GRAPH          = YES
-
-# If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are
-# set to YES then doxygen will generate a graph for each documented file showing
-# the direct and indirect include dependencies of the file with other documented
-# files.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-INCLUDED_BY_GRAPH      = YES
-
-# If the CALL_GRAPH tag is set to YES then doxygen will generate a call
-# dependency graph for every global function or class method.
-#
-# Note that enabling this option will significantly increase the time of a run.
-# So in most cases it will be better to enable call graphs for selected
-# functions only using the \callgraph command. Disabling a call graph can be
-# accomplished by means of the command \hidecallgraph.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-CALL_GRAPH             = NO
-
-# If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller
-# dependency graph for every global function or class method.
-#
-# Note that enabling this option will significantly increase the time of a run.
-# So in most cases it will be better to enable caller graphs for selected
-# functions only using the \callergraph command. Disabling a caller graph can be
-# accomplished by means of the command \hidecallergraph.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-CALLER_GRAPH           = NO
-
-# If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
-# hierarchy of all classes instead of a textual one.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-GRAPHICAL_HIERARCHY    = YES
-
-# If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the
-# dependencies a directory has on other directories in a graphical way. The
-# dependency relations are determined by the #include relations between the
-# files in the directories.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DIRECTORY_GRAPH        = YES
-
-# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
-# generated by dot. For an explanation of the image formats see the section
-# output formats in the documentation of the dot tool (Graphviz (see:
-# http://www.graphviz.org/)).
-# Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
-# to make the SVG files visible in IE 9+ (other browsers do not have this
-# requirement).
-# Possible values are: png, jpg, gif, svg, png:gd, png:gd:gd, png:cairo,
-# png:cairo:gd, png:cairo:cairo, png:cairo:gdiplus, png:gdiplus and
-# png:gdiplus:gdiplus.
-# The default value is: png.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_IMAGE_FORMAT       = png
-
-# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
-# enable generation of interactive SVG images that allow zooming and panning.
-#
-# Note that this requires a modern browser other than Internet Explorer. Tested
-# and working are Firefox, Chrome, Safari, and Opera.
-# Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
-# the SVG files visible. Older versions of IE do not have SVG support.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-INTERACTIVE_SVG        = NO
-
-# The DOT_PATH tag can be used to specify the path where the dot tool can be
-# found. If left blank, it is assumed the dot tool can be found in the path.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_PATH               =
-
-# The DOTFILE_DIRS tag can be used to specify one or more directories that
-# contain dot files that are included in the documentation (see the \dotfile
-# command).
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOTFILE_DIRS           =
-
-# The MSCFILE_DIRS tag can be used to specify one or more directories that
-# contain msc files that are included in the documentation (see the \mscfile
-# command).
-
-MSCFILE_DIRS           =
-
-# The DIAFILE_DIRS tag can be used to specify one or more directories that
-# contain dia files that are included in the documentation (see the \diafile
-# command).
-
-DIAFILE_DIRS           =
-
-# When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the
-# path where java can find the plantuml.jar file. If left blank, it is assumed
-# PlantUML is not used or called during a preprocessing step. Doxygen will
-# generate a warning when it encounters a \startuml command in this case and
-# will not generate output for the diagram.
-
-PLANTUML_JAR_PATH      =
-
-# When using plantuml, the PLANTUML_CFG_FILE tag can be used to specify a
-# configuration file for plantuml.
-
-PLANTUML_CFG_FILE      =
-
-# When using plantuml, the specified paths are searched for files specified by
-# the !include statement in a plantuml block.
-
-PLANTUML_INCLUDE_PATH  =
-
-# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
-# that will be shown in the graph. If the number of nodes in a graph becomes
-# larger than this value, doxygen will truncate the graph, which is visualized
-# by representing a node as a red box. Note that doxygen if the number of direct
-# children of the root node in a graph is already larger than
-# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that
-# the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
-# Minimum value: 0, maximum value: 10000, default value: 50.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_GRAPH_MAX_NODES    = 50
-
-# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs
-# generated by dot. A depth value of 3 means that only nodes reachable from the
-# root by following a path via at most 3 edges will be shown. Nodes that lay
-# further from the root node will be omitted. Note that setting this option to 1
-# or 2 may greatly reduce the computation time needed for large code bases. Also
-# note that the size of a graph can be further restricted by
-# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
-# Minimum value: 0, maximum value: 1000, default value: 0.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-MAX_DOT_GRAPH_DEPTH    = 0
-
-# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
-# background. This is disabled by default, because dot on Windows does not seem
-# to support this out of the box.
-#
-# Warning: Depending on the platform used, enabling this option may lead to
-# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
-# read).
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_TRANSPARENT        = NO
-
-# Set the DOT_MULTI_TARGETS tag to YES to allow dot to generate multiple output
-# files in one run (i.e. multiple -o and -T options on the command line). This
-# makes dot run faster, but since only newer versions of dot (>1.8.10) support
-# this, this feature is disabled by default.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_MULTI_TARGETS      = NO
-
-# If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
-# explaining the meaning of the various boxes and arrows in the dot generated
-# graphs.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-GENERATE_LEGEND        = YES
-
-# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate
-# files that are used to generate the various graphs.
-#
-# Note: This setting is not only used for dot files but also for msc and
-# plantuml temporary files.
-# The default value is: YES.
-
-DOT_CLEANUP            = YES
diff --git a/crates/c-api/doxygen.conf.in b/crates/c-api/doxygen.conf.in
new file mode 100644
index 000000000000..6ba0b993b710
--- /dev/null
+++ b/crates/c-api/doxygen.conf.in
@@ -0,0 +1,2582 @@
+# Doxyfile 1.9.1
+
+# This file describes the settings to be used by the documentation system
+# doxygen (www.doxygen.org) for a project.
+#
+# All text after a double hash (##) is considered a comment and is placed in
+# front of the TAG it is preceding.
+#
+# All text after a single hash (#) is considered a comment and will be ignored.
+# The format is:
+# TAG = value [value, ...]
+# For lists, items can also be appended using:
+# TAG += value [value, ...]
+# Values that contain spaces should be placed between quotes (\" \").
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+
+# This tag specifies the encoding used for all characters in the configuration
+# file that follow. The default is UTF-8 which is also the encoding used for all
+# text before the first occurrence of this tag. Doxygen uses libiconv (or the
+# iconv built into libc) for the transcoding. See
+# https://www.gnu.org/software/libiconv/ for the list of possible encodings.
+# The default value is: UTF-8.
+
+DOXYFILE_ENCODING      = UTF-8
+
+# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by
+# double-quotes, unless you are using Doxywizard) that should identify the
+# project for which the documentation is generated. This name is used in the
+# title of most generated pages and in a few other places.
+# The default value is: My Project.
+
+PROJECT_NAME           = Wasmtime
+
+# The PROJECT_NUMBER tag can be used to enter a project or revision number. This
+# could be handy for archiving the generated documentation or if some version
+# control system is used.
+
+PROJECT_NUMBER         =
+
+# Using the PROJECT_BRIEF tag one can provide an optional one line description
+# for a project that appears at the top of each page and should give viewer a
+# quick idea about the purpose of the project. Keep the description short.
+
+PROJECT_BRIEF          =
+
+# With the PROJECT_LOGO tag one can specify a logo or an icon that is included
+# in the documentation. The maximum height of the logo should not exceed 55
+# pixels and the maximum width should not exceed 200 pixels. Doxygen will copy
+# the logo to the output directory.
+
+PROJECT_LOGO           =
+
+# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
+# into which the generated documentation will be written. If a relative path is
+# entered, it will be relative to the location where doxygen was started. If
+# left blank the current directory will be used.
+
+OUTPUT_DIRECTORY       =
+
+# If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub-
+# directories (in 2 levels) under the output directory of each output format and
+# will distribute the generated files over these directories. Enabling this
+# option can be useful when feeding doxygen a huge amount of source files, where
+# putting all generated files in the same directory would otherwise causes
+# performance problems for the file system.
+# The default value is: NO.
+
+CREATE_SUBDIRS         = NO
+
+# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII
+# characters to appear in the names of generated files. If set to NO, non-ASCII
+# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode
+# U+3044.
+# The default value is: NO.
+
+ALLOW_UNICODE_NAMES    = NO
+
+# The OUTPUT_LANGUAGE tag is used to specify the language in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all constant output in the proper language.
+# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese,
+# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States),
+# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian,
+# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages),
+# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian,
+# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian,
+# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish,
+# Ukrainian and Vietnamese.
+# The default value is: English.
+
+OUTPUT_LANGUAGE        = English
+
+# The OUTPUT_TEXT_DIRECTION tag is used to specify the direction in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all generated output in the proper direction.
+# Possible values are: None, LTR, RTL and Context.
+# The default value is: None.
+
+OUTPUT_TEXT_DIRECTION  = None
+
+# If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member
+# descriptions after the members that are listed in the file and class
+# documentation (similar to Javadoc). Set to NO to disable this.
+# The default value is: YES.
+
+BRIEF_MEMBER_DESC      = YES
+
+# If the REPEAT_BRIEF tag is set to YES, doxygen will prepend the brief
+# description of a member or function before the detailed description
+#
+# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
+# brief descriptions will be completely suppressed.
+# The default value is: YES.
+
+REPEAT_BRIEF           = YES
+
+# This tag implements a quasi-intelligent brief description abbreviator that is
+# used to form the text in various listings. Each string in this list, if found
+# as the leading text of the brief description, will be stripped from the text
+# and the result, after processing the whole list, is used as the annotated
+# text. Otherwise, the brief description is used as-is. If left blank, the
+# following values are used ($name is automatically replaced with the name of
+# the entity):The $name class, The $name widget, The $name file, is, provides,
+# specifies, contains, represents, a, an and the.
+
+ABBREVIATE_BRIEF       = "The $name class" \
+                         "The $name widget" \
+                         "The $name file" \
+                         is \
+                         provides \
+                         specifies \
+                         contains \
+                         represents \
+                         a \
+                         an \
+                         the
+
+# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
+# doxygen will generate a detailed section even if there is only a brief
+# description.
+# The default value is: NO.
+
+ALWAYS_DETAILED_SEC    = NO
+
+# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
+# inherited members of a class in the documentation of that class as if those
+# members were ordinary class members. Constructors, destructors and assignment
+# operators of the base classes will not be shown.
+# The default value is: NO.
+
+INLINE_INHERITED_MEMB  = NO
+
+# If the FULL_PATH_NAMES tag is set to YES, doxygen will prepend the full path
+# before files name in the file list and in the header files. If set to NO the
+# shortest path that makes the file name unique will be used
+# The default value is: YES.
+
+FULL_PATH_NAMES        = NO
+
+# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path.
+# Stripping is only done if one of the specified strings matches the left-hand
+# part of the path. The tag can be used to show relative paths in the file list.
+# If left blank the directory from which doxygen is run is used as the path to
+# strip.
+#
+# Note that you can specify absolute paths here, but also relative paths, which
+# will be relative from the directory where doxygen is started.
+# This tag requires that the tag FULL_PATH_NAMES is set to YES.
+
+STRIP_FROM_PATH        =
+
+# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
+# path mentioned in the documentation of a class, which tells the reader which
+# header file to include in order to use a class. If left blank only the name of
+# the header file containing the class definition is used. Otherwise one should
+# specify the list of include paths that are normally passed to the compiler
+# using the -I flag.
+
+STRIP_FROM_INC_PATH    =
+
+# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but
+# less readable) file names. This can be useful is your file systems doesn't
+# support long names like on DOS, Mac, or CD-ROM.
+# The default value is: NO.
+
+SHORT_NAMES            = NO
+
+# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the
+# first line (until the first dot) of a Javadoc-style comment as the brief
+# description. If set to NO, the Javadoc-style will behave just like regular Qt-
+# style comments (thus requiring an explicit @brief command for a brief
+# description.)
+# The default value is: NO.
+
+JAVADOC_AUTOBRIEF      = NO
+
+# If the JAVADOC_BANNER tag is set to YES then doxygen will interpret a line
+# such as
+# /***************
+# as being the beginning of a Javadoc-style comment "banner". If set to NO, the
+# Javadoc-style will behave just like regular comments and it will not be
+# interpreted by doxygen.
+# The default value is: NO.
+
+JAVADOC_BANNER         = NO
+
+# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
+# line (until the first dot) of a Qt-style comment as the brief description. If
+# set to NO, the Qt-style will behave just like regular Qt-style comments (thus
+# requiring an explicit \brief command for a brief description.)
+# The default value is: NO.
+
+QT_AUTOBRIEF           = NO
+
+# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a
+# multi-line C++ special comment block (i.e. a block of //! or /// comments) as
+# a brief description. This used to be the default behavior. The new default is
+# to treat a multi-line C++ comment block as a detailed description. Set this
+# tag to YES if you prefer the old behavior instead.
+#
+# Note that setting this tag to YES also means that rational rose comments are
+# not recognized any more.
+# The default value is: NO.
+
+MULTILINE_CPP_IS_BRIEF = NO
+
+# By default Python docstrings are displayed as preformatted text and doxygen's
+# special commands cannot be used. By setting PYTHON_DOCSTRING to NO the
+# doxygen's special commands can be used and the contents of the docstring
+# documentation blocks is shown as doxygen documentation.
+# The default value is: YES.
+
+PYTHON_DOCSTRING       = YES
+
+# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
+# documentation from any documented member that it re-implements.
+# The default value is: YES.
+
+INHERIT_DOCS           = YES
+
+# If the SEPARATE_MEMBER_PAGES tag is set to YES then doxygen will produce a new
+# page for each member. If set to NO, the documentation of a member will be part
+# of the file/class/namespace that contains it.
+# The default value is: NO.
+
+SEPARATE_MEMBER_PAGES  = NO
+
+# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen
+# uses this value to replace tabs by spaces in code fragments.
+# Minimum value: 1, maximum value: 16, default value: 4.
+
+TAB_SIZE               = 4
+
+# This tag can be used to specify a number of aliases that act as commands in
+# the documentation. An alias has the form:
+# name=value
+# For example adding
+# "sideeffect=@par Side Effects:\n"
+# will allow you to put the command \sideeffect (or @sideeffect) in the
+# documentation, which will result in a user-defined paragraph with heading
+# "Side Effects:". You can put \n's in the value part of an alias to insert
+# newlines (in the resulting output). You can put ^^ in the value part of an
+# alias to insert a newline as if a physical newline was in the original file.
+# When you need a literal { or } or , in the value part of an alias you have to
+# escape them by means of a backslash (\), this can lead to conflicts with the
+# commands \{ and \} for these it is advised to use the version @{ and @} or use
+# a double escape (\\{ and \\})
+
+ALIASES                =
+
+# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
+# only. Doxygen will then generate output that is more tailored for C. For
+# instance, some of the names that are used will be different. The list of all
+# members will be omitted, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_FOR_C  = YES
+
+# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or
+# Python sources only. Doxygen will then generate output that is more tailored
+# for that language. For instance, namespaces will be presented as packages,
+# qualified scopes will look different, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_JAVA   = NO
+
+# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
+# sources. Doxygen will then generate output that is tailored for Fortran.
+# The default value is: NO.
+
+OPTIMIZE_FOR_FORTRAN   = NO
+
+# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
+# sources. Doxygen will then generate output that is tailored for VHDL.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_VHDL   = NO
+
+# Set the OPTIMIZE_OUTPUT_SLICE tag to YES if your project consists of Slice
+# sources only. Doxygen will then generate output that is more tailored for that
+# language. For instance, namespaces will be presented as modules, types will be
+# separated into more groups, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_SLICE  = NO
+
+# Doxygen selects the parser to use depending on the extension of the files it
+# parses. With this tag you can assign which parser to use for a given
+# extension. Doxygen has a built-in mapping, but you can override or extend it
+# using this tag. The format is ext=language, where ext is a file extension, and
+# language is one of the parsers supported by doxygen: IDL, Java, JavaScript,
+# Csharp (C#), C, C++, D, PHP, md (Markdown), Objective-C, Python, Slice, VHDL,
+# Fortran (fixed format Fortran: FortranFixed, free formatted Fortran:
+# FortranFree, unknown formatted Fortran: Fortran. In the later case the parser
+# tries to guess whether the code is fixed or free formatted code, this is the
+# default for Fortran type files). For instance to make doxygen treat .inc files
+# as Fortran files (default is PHP), and .f files as C (default is Fortran),
+# use: inc=Fortran f=C.
+#
+# Note: For files without extension you can use no_extension as a placeholder.
+#
+# Note that for custom extensions you also need to set FILE_PATTERNS otherwise
+# the files are not read by doxygen. When specifying no_extension you should add
+# * to the FILE_PATTERNS.
+#
+# Note see also the list of default file extension mappings.
+
+EXTENSION_MAPPING      =
+
+# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
+# according to the Markdown format, which allows for more readable
+# documentation. See https://daringfireball.net/projects/markdown/ for details.
+# The output of markdown processing is further processed by doxygen, so you can
+# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
+# case of backward compatibilities issues.
+# The default value is: YES.
+
+MARKDOWN_SUPPORT       = YES
+
+# When the TOC_INCLUDE_HEADINGS tag is set to a non-zero value, all headings up
+# to that level are automatically included in the table of contents, even if
+# they do not have an id attribute.
+# Note: This feature currently applies only to Markdown headings.
+# Minimum value: 0, maximum value: 99, default value: 5.
+# This tag requires that the tag MARKDOWN_SUPPORT is set to YES.
+
+TOC_INCLUDE_HEADINGS   = 5
+
+# When enabled doxygen tries to link words that correspond to documented
+# classes, or namespaces to their corresponding documentation. Such a link can
+# be prevented in individual cases by putting a % sign in front of the word or
+# globally by setting AUTOLINK_SUPPORT to NO.
+# The default value is: YES.
+
+AUTOLINK_SUPPORT       = YES
+
+# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
+# to include (a tag file for) the STL sources as input, then you should set this
+# tag to YES in order to let doxygen match functions declarations and
+# definitions whose arguments contain STL classes (e.g. func(std::string);
+# versus func(std::string) {}). This also make the inheritance and collaboration
+# diagrams that involve STL classes more complete and accurate.
+# The default value is: NO.
+
+BUILTIN_STL_SUPPORT    = NO
+
+# If you use Microsoft's C++/CLI language, you should set this option to YES to
+# enable parsing support.
+# The default value is: NO.
+
+CPP_CLI_SUPPORT        = NO
+
+# Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
+# https://www.riverbankcomputing.com/software/sip/intro) sources only. Doxygen
+# will parse them like normal C++ but will assume all classes use public instead
+# of private inheritance when no explicit protection keyword is present.
+# The default value is: NO.
+
+SIP_SUPPORT            = NO
+
+# For Microsoft's IDL there are propget and propput attributes to indicate
+# getter and setter methods for a property. Setting this option to YES will make
+# doxygen to replace the get and set methods by a property in the documentation.
+# This will only work if the methods are indeed getting or setting a simple
+# type. If this is not the case, or you want to show the methods anyway, you
+# should set this option to NO.
+# The default value is: YES.
+
+IDL_PROPERTY_SUPPORT   = YES
+
+# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
+# tag is set to YES then doxygen will reuse the documentation of the first
+# member in the group (if any) for the other members of the group. By default
+# all members of a group must be documented explicitly.
+# The default value is: NO.
+
+DISTRIBUTE_GROUP_DOC   = NO
+
+# If one adds a struct or class to a group and this option is enabled, then also
+# any nested class or struct is added to the same group. By default this option
+# is disabled and one has to add nested compounds explicitly via \ingroup.
+# The default value is: NO.
+
+GROUP_NESTED_COMPOUNDS = NO
+
+# Set the SUBGROUPING tag to YES to allow class member groups of the same type
+# (for instance a group of public functions) to be put as a subgroup of that
+# type (e.g. under the Public Functions section). Set it to NO to prevent
+# subgrouping. Alternatively, this can be done per class using the
+# \nosubgrouping command.
+# The default value is: YES.
+
+SUBGROUPING            = YES
+
+# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions
+# are shown inside the group in which they are included (e.g. using \ingroup)
+# instead of on a separate page (for HTML and Man pages) or section (for LaTeX
+# and RTF).
+#
+# Note that this feature does not work in combination with
+# SEPARATE_MEMBER_PAGES.
+# The default value is: NO.
+
+INLINE_GROUPED_CLASSES = NO
+
+# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions
+# with only public data fields or simple typedef fields will be shown inline in
+# the documentation of the scope in which they are defined (i.e. file,
+# namespace, or group documentation), provided this scope is documented. If set
+# to NO, structs, classes, and unions are shown on a separate page (for HTML and
+# Man pages) or section (for LaTeX and RTF).
+# The default value is: NO.
+
+INLINE_SIMPLE_STRUCTS  = NO
+
+# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or
+# enum is documented as struct, union, or enum with the name of the typedef. So
+# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
+# with name TypeT. When disabled the typedef will appear as a member of a file,
+# namespace, or class. And the struct will be named TypeS. This can typically be
+# useful for C code in case the coding convention dictates that all compound
+# types are typedef'ed and only the typedef is referenced, never the tag name.
+# The default value is: NO.
+
+TYPEDEF_HIDES_STRUCT   = NO
+
+# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
+# cache is used to resolve symbols given their name and scope. Since this can be
+# an expensive process and often the same symbol appears multiple times in the
+# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small
+# doxygen will become slower. If the cache is too large, memory is wasted. The
+# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range
+# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536
+# symbols. At the end of a run doxygen will report the cache usage and suggest
+# the optimal cache size from a speed point of view.
+# Minimum value: 0, maximum value: 9, default value: 0.
+
+LOOKUP_CACHE_SIZE      = 0
+
+# The NUM_PROC_THREADS specifies the number threads doxygen is allowed to use
+# during processing. When set to 0 doxygen will based this on the number of
+# cores available in the system. You can set it explicitly to a value larger
+# than 0 to get more control over the balance between CPU load and processing
+# speed. At this moment only the input processing can be done using multiple
+# threads. Since this is still an experimental feature the default is set to 1,
+# which efficively disables parallel processing. Please report any issues you
+# encounter. Generating dot graphs in parallel is controlled by the
+# DOT_NUM_THREADS setting.
+# Minimum value: 0, maximum value: 32, default value: 1.
+
+NUM_PROC_THREADS       = 1
+
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+
+# If the EXTRACT_ALL tag is set to YES, doxygen will assume all entities in
+# documentation are documented, even if no documentation was available. Private
+# class members and static file members will be hidden unless the
+# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES.
+# Note: This will also disable the warnings about undocumented members that are
+# normally produced when WARNINGS is set to YES.
+# The default value is: NO.
+
+EXTRACT_ALL            = NO
+
+# If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will
+# be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PRIVATE        = NO
+
+# If the EXTRACT_PRIV_VIRTUAL tag is set to YES, documented private virtual
+# methods of a class will be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PRIV_VIRTUAL   = NO
+
+# If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal
+# scope will be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PACKAGE        = NO
+
+# If the EXTRACT_STATIC tag is set to YES, all static members of a file will be
+# included in the documentation.
+# The default value is: NO.
+
+EXTRACT_STATIC         = NO
+
+# If the EXTRACT_LOCAL_CLASSES tag is set to YES, classes (and structs) defined
+# locally in source files will be included in the documentation. If set to NO,
+# only classes defined in header files are included. Does not have any effect
+# for Java sources.
+# The default value is: YES.
+
+EXTRACT_LOCAL_CLASSES  = YES
+
+# This flag is only useful for Objective-C code. If set to YES, local methods,
+# which are defined in the implementation section but not in the interface are
+# included in the documentation. If set to NO, only methods in the interface are
+# included.
+# The default value is: NO.
+
+EXTRACT_LOCAL_METHODS  = NO
+
+# If this flag is set to YES, the members of anonymous namespaces will be
+# extracted and appear in the documentation as a namespace called
+# 'anonymous_namespace{file}', where file will be replaced with the base name of
+# the file that contains the anonymous namespace. By default anonymous namespace
+# are hidden.
+# The default value is: NO.
+
+EXTRACT_ANON_NSPACES   = NO
+
+# If this flag is set to YES, the name of an unnamed parameter in a declaration
+# will be determined by the corresponding definition. By default unnamed
+# parameters remain unnamed in the output.
+# The default value is: YES.
+
+RESOLVE_UNNAMED_PARAMS = YES
+
+# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
+# undocumented members inside documented classes or files. If set to NO these
+# members will be included in the various overviews, but no documentation
+# section is generated. This option has no effect if EXTRACT_ALL is enabled.
+# The default value is: NO.
+
+HIDE_UNDOC_MEMBERS     = NO
+
+# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
+# undocumented classes that are normally visible in the class hierarchy. If set
+# to NO, these classes will be included in the various overviews. This option
+# has no effect if EXTRACT_ALL is enabled.
+# The default value is: NO.
+
+HIDE_UNDOC_CLASSES     = NO
+
+# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
+# declarations. If set to NO, these declarations will be included in the
+# documentation.
+# The default value is: NO.
+
+HIDE_FRIEND_COMPOUNDS  = NO
+
+# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any
+# documentation blocks found inside the body of a function. If set to NO, these
+# blocks will be appended to the function's detailed documentation block.
+# The default value is: NO.
+
+HIDE_IN_BODY_DOCS      = NO
+
+# The INTERNAL_DOCS tag determines if documentation that is typed after a
+# \internal command is included. If the tag is set to NO then the documentation
+# will be excluded. Set it to YES to include the internal documentation.
+# The default value is: NO.
+
+INTERNAL_DOCS          = NO
+
+# With the correct setting of option CASE_SENSE_NAMES doxygen will better be
+# able to match the capabilities of the underlying filesystem. In case the
+# filesystem is case sensitive (i.e. it supports files in the same directory
+# whose names only differ in casing), the option must be set to YES to properly
+# deal with such files in case they appear in the input. For filesystems that
+# are not case sensitive the option should be be set to NO to properly deal with
+# output files written for symbols that only differ in casing, such as for two
+# classes, one named CLASS and the other named Class, and to also support
+# references to files without having to specify the exact matching casing. On
+# Windows (including Cygwin) and MacOS, users should typically set this option
+# to NO, whereas on Linux or other Unix flavors it should typically be set to
+# YES.
+# The default value is: system dependent.
+
+CASE_SENSE_NAMES       = YES
+
+# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
+# their full class and namespace scopes in the documentation. If set to YES, the
+# scope will be hidden.
+# The default value is: NO.
+
+HIDE_SCOPE_NAMES       = NO
+
+# If the HIDE_COMPOUND_REFERENCE tag is set to NO (default) then doxygen will
+# append additional text to a page's title, such as Class Reference. If set to
+# YES the compound reference will be hidden.
+# The default value is: NO.
+
+HIDE_COMPOUND_REFERENCE= NO
+
+# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
+# the files that are included by a file in the documentation of that file.
+# The default value is: YES.
+
+SHOW_INCLUDE_FILES     = YES
+
+# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each
+# grouped member an include statement to the documentation, telling the reader
+# which file to include in order to use the member.
+# The default value is: NO.
+
+SHOW_GROUPED_MEMB_INC  = NO
+
+# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include
+# files with double quotes in the documentation rather than with sharp brackets.
+# The default value is: NO.
+
+FORCE_LOCAL_INCLUDES   = NO
+
+# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the
+# documentation for inline members.
+# The default value is: YES.
+
+INLINE_INFO            = YES
+
+# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the
+# (detailed) documentation of file and class members alphabetically by member
+# name. If set to NO, the members will appear in declaration order.
+# The default value is: YES.
+
+SORT_MEMBER_DOCS       = YES
+
+# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief
+# descriptions of file, namespace and class members alphabetically by member
+# name. If set to NO, the members will appear in declaration order. Note that
+# this will also influence the order of the classes in the class list.
+# The default value is: NO.
+
+SORT_BRIEF_DOCS        = NO
+
+# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the
+# (brief and detailed) documentation of class members so that constructors and
+# destructors are listed first. If set to NO the constructors will appear in the
+# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS.
+# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief
+# member documentation.
+# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting
+# detailed member documentation.
+# The default value is: NO.
+
+SORT_MEMBERS_CTORS_1ST = NO
+
+# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy
+# of group names into alphabetical order. If set to NO the group names will
+# appear in their defined order.
+# The default value is: NO.
+
+SORT_GROUP_NAMES       = NO
+
+# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by
+# fully-qualified names, including namespaces. If set to NO, the class list will
+# be sorted only by class name, not including the namespace part.
+# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
+# Note: This option applies only to the class list, not to the alphabetical
+# list.
+# The default value is: NO.
+
+SORT_BY_SCOPE_NAME     = NO
+
+# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper
+# type resolution of all parameters of a function it will reject a match between
+# the prototype and the implementation of a member function even if there is
+# only one candidate or it is obvious which candidate to choose by doing a
+# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still
+# accept a match between prototype and implementation in such cases.
+# The default value is: NO.
+
+STRICT_PROTO_MATCHING  = NO
+
+# The GENERATE_TODOLIST tag can be used to enable (YES) or disable (NO) the todo
+# list. This list is created by putting \todo commands in the documentation.
+# The default value is: YES.
+
+GENERATE_TODOLIST      = YES
+
+# The GENERATE_TESTLIST tag can be used to enable (YES) or disable (NO) the test
+# list. This list is created by putting \test commands in the documentation.
+# The default value is: YES.
+
+GENERATE_TESTLIST      = YES
+
+# The GENERATE_BUGLIST tag can be used to enable (YES) or disable (NO) the bug
+# list. This list is created by putting \bug commands in the documentation.
+# The default value is: YES.
+
+GENERATE_BUGLIST       = YES
+
+# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or disable (NO)
+# the deprecated list. This list is created by putting \deprecated commands in
+# the documentation.
+# The default value is: YES.
+
+GENERATE_DEPRECATEDLIST= YES
+
+# The ENABLED_SECTIONS tag can be used to enable conditional documentation
+# sections, marked by \if <section_label> ... \endif and \cond <section_label>
+# ... \endcond blocks.
+
+ENABLED_SECTIONS       =
+
+# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the
+# initial value of a variable or macro / define can have for it to appear in the
+# documentation. If the initializer consists of more lines than specified here
+# it will be hidden. Use a value of 0 to hide initializers completely. The
+# appearance of the value of individual variables and macros / defines can be
+# controlled using \showinitializer or \hideinitializer command in the
+# documentation regardless of this setting.
+# Minimum value: 0, maximum value: 10000, default value: 30.
+
+MAX_INITIALIZER_LINES  = 30
+
+# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at
+# the bottom of the documentation of classes and structs. If set to YES, the
+# list will mention the files that were used to generate the documentation.
+# The default value is: YES.
+
+SHOW_USED_FILES        = YES
+
+# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This
+# will remove the Files entry from the Quick Index and from the Folder Tree View
+# (if specified).
+# The default value is: YES.
+
+SHOW_FILES             = YES
+
+# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces
+# page. This will remove the Namespaces entry from the Quick Index and from the
+# Folder Tree View (if specified).
+# The default value is: YES.
+
+SHOW_NAMESPACES        = YES
+
+# The FILE_VERSION_FILTER tag can be used to specify a program or script that
+# doxygen should invoke to get the current version for each file (typically from
+# the version control system). Doxygen will invoke the program by executing (via
+# popen()) the command command input-file, where command is the value of the
+# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided
+# by doxygen. Whatever the program writes to standard output is used as the file
+# version. For an example see the documentation.
+
+FILE_VERSION_FILTER    =
+
+# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
+# by doxygen. The layout file controls the global structure of the generated
+# output files in an output format independent way. To create the layout file
+# that represents doxygen's defaults, run doxygen with the -l option. You can
+# optionally specify a file name after the option, if omitted DoxygenLayout.xml
+# will be used as the name of the layout file.
+#
+# Note that if you run doxygen from a directory containing a file called
+# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
+# tag is left empty.
+
+LAYOUT_FILE            =
+
+# The CITE_BIB_FILES tag can be used to specify one or more bib files containing
+# the reference definitions. This must be a list of .bib files. The .bib
+# extension is automatically appended if omitted. This requires the bibtex tool
+# to be installed. See also https://en.wikipedia.org/wiki/BibTeX for more info.
+# For LaTeX the style of the bibliography can be controlled using
+# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
+# search path. See also \cite for info how to create references.
+
+CITE_BIB_FILES         =
+
+#---------------------------------------------------------------------------
+# Configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+
+# The QUIET tag can be used to turn on/off the messages that are generated to
+# standard output by doxygen. If QUIET is set to YES this implies that the
+# messages are off.
+# The default value is: NO.
+
+QUIET                  = NO
+
+# The WARNINGS tag can be used to turn on/off the warning messages that are
+# generated to standard error (stderr) by doxygen. If WARNINGS is set to YES
+# this implies that the warnings are on.
+#
+# Tip: Turn warnings on while writing the documentation.
+# The default value is: YES.
+
+WARNINGS               = YES
+
+# If the WARN_IF_UNDOCUMENTED tag is set to YES then doxygen will generate
+# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag
+# will automatically be disabled.
+# The default value is: YES.
+
+WARN_IF_UNDOCUMENTED   = YES
+
+# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
+# potential errors in the documentation, such as not documenting some parameters
+# in a documented function, or documenting parameters that don't exist or using
+# markup commands wrongly.
+# The default value is: YES.
+
+WARN_IF_DOC_ERROR      = YES
+
+# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
+# are documented, but have no documentation for their parameters or return
+# value. If set to NO, doxygen will only warn about wrong or incomplete
+# parameter documentation, but not about the absence of documentation. If
+# EXTRACT_ALL is set to YES then this flag will automatically be disabled.
+# The default value is: NO.
+
+WARN_NO_PARAMDOC       = NO
+
+# If the WARN_AS_ERROR tag is set to YES then doxygen will immediately stop when
+# a warning is encountered. If the WARN_AS_ERROR tag is set to FAIL_ON_WARNINGS
+# then doxygen will continue running as if WARN_AS_ERROR tag is set to NO, but
+# at the end of the doxygen process doxygen will return with a non-zero status.
+# Possible values are: NO, YES and FAIL_ON_WARNINGS.
+# The default value is: NO.
+
+WARN_AS_ERROR          = YES
+
+# The WARN_FORMAT tag determines the format of the warning messages that doxygen
+# can produce. The string should contain the $file, $line, and $text tags, which
+# will be replaced by the file and line number from which the warning originated
+# and the warning text. Optionally the format may contain $version, which will
+# be replaced by the version of the file (if it could be obtained via
+# FILE_VERSION_FILTER)
+# The default value is: $file:$line: $text.
+
+WARN_FORMAT            = "$file:$line: $text"
+
+# The WARN_LOGFILE tag can be used to specify a file to which warning and error
+# messages should be written. If left blank the output is written to standard
+# error (stderr).
+
+WARN_LOGFILE           =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the input files
+#---------------------------------------------------------------------------
+
+# The INPUT tag is used to specify the files and/or directories that contain
+# documented source files. You may enter file names like myfile.cpp or
+# directories like /usr/src/myproject. Separate the files or directories with
+# spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
+# Note: If this tag is empty the current directory is searched.
+
+INPUT                  = @CMAKE_BINARY_DIR@/include
+
+# This tag can be used to specify the character encoding of the source files
+# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
+# libiconv (or the iconv built into libc) for the transcoding. See the libiconv
+# documentation (see:
+# https://www.gnu.org/software/libiconv/) for the list of possible encodings.
+# The default value is: UTF-8.
+
+INPUT_ENCODING         = UTF-8
+
+# If the value of the INPUT tag contains directories, you can use the
+# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
+# *.h) to filter out the source-files in the directories.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# read by doxygen.
+#
+# Note the list of default checked file patterns might differ from the list of
+# default file extension mappings.
+#
+# If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp,
+# *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h,
+# *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc,
+# *.m, *.markdown, *.md, *.mm, *.dox (to be provided as doxygen C comment),
+# *.py, *.pyw, *.f90, *.f95, *.f03, *.f08, *.f18, *.f, *.for, *.vhd, *.vhdl,
+# *.ucf, *.qsf and *.ice.
+
+FILE_PATTERNS          = *.h
+
+# The RECURSIVE tag can be used to specify whether or not subdirectories should
+# be searched for input files as well.
+# The default value is: NO.
+
+RECURSIVE              = YES
+
+# The EXCLUDE tag can be used to specify files and/or directories that should be
+# excluded from the INPUT source files. This way you can easily exclude a
+# subdirectory from a directory tree whose root is specified with the INPUT tag.
+#
+# Note that relative paths are relative to the directory from which doxygen is
+# run.
+
+EXCLUDE                =
+
+# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
+# directories that are symbolic links (a Unix file system feature) are excluded
+# from the input.
+# The default value is: NO.
+
+EXCLUDE_SYMLINKS       = NO
+
+# If the value of the INPUT tag contains directories, you can use the
+# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
+# certain files from those directories.
+#
+# Note that the wildcards are matched against the file with absolute path, so to
+# exclude all test directories for example use the pattern */test/*
+
+EXCLUDE_PATTERNS       =
+
+# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
+# (namespaces, classes, functions, etc.) that should be excluded from the
+# output. The symbol name can be a fully qualified name, a word, or if the
+# wildcard * is used, a substring. Examples: ANamespace, AClass,
+# AClass::ANamespace, ANamespace::*Test
+#
+# Note that the wildcards are matched against the file with absolute path, so to
+# exclude all test directories use the pattern */test/*
+
+EXCLUDE_SYMBOLS        = assertions \
+                         WASM_DECLARE_* \
+                         WASM_API_EXTERN \
+                         WASI_API_EXTERN \
+                         WASMTIME_DECLARE_OWN \
+                         WASI_DECLARE_OWN \
+                         WASMTIME_CONFIG_PROP \
+                         own \
+                         wasm_*_enum
+
+# The EXAMPLE_PATH tag can be used to specify one or more files or directories
+# that contain example code fragments that are included (see the \include
+# command).
+
+EXAMPLE_PATH           = ../../examples
+
+# If the value of the EXAMPLE_PATH tag contains directories, you can use the
+# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and
+# *.h) to filter out the source-files in the directories. If left blank all
+# files are included.
+
+EXAMPLE_PATTERNS       = *.c
+
+# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
+# searched for input files to be used with the \include or \dontinclude commands
+# irrespective of the value of the RECURSIVE tag.
+# The default value is: NO.
+
+EXAMPLE_RECURSIVE      = YES
+
+# The IMAGE_PATH tag can be used to specify one or more files or directories
+# that contain images that are to be included in the documentation (see the
+# \image command).
+
+IMAGE_PATH             =
+
+# The INPUT_FILTER tag can be used to specify a program that doxygen should
+# invoke to filter for each input file. Doxygen will invoke the filter program
+# by executing (via popen()) the command:
+#
+# <filter> <input-file>
+#
+# where <filter> is the value of the INPUT_FILTER tag, and <input-file> is the
+# name of an input file. Doxygen will then use the output that the filter
+# program writes to standard output. If FILTER_PATTERNS is specified, this tag
+# will be ignored.
+#
+# Note that the filter must not add or remove lines; it is applied before the
+# code is scanned, but not when the output code is generated. If lines are added
+# or removed, the anchors will not be placed correctly.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# properly processed by doxygen.
+
+INPUT_FILTER           =
+
+# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
+# basis. Doxygen will compare the file name with each pattern and apply the
+# filter if there is a match. The filters are a list of the form: pattern=filter
+# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how
+# filters are used. If the FILTER_PATTERNS tag is empty or if none of the
+# patterns match the file name, INPUT_FILTER is applied.
+#
+# Note that for custom extensions or not directly supported extensions you also
+# need to set EXTENSION_MAPPING for the extension otherwise the files are not
+# properly processed by doxygen.
+
+FILTER_PATTERNS        =
+
+# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
+# INPUT_FILTER) will also be used to filter the input files that are used for
+# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES).
+# The default value is: NO.
+
+FILTER_SOURCE_FILES    = NO
+
+# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
+# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and
+# it is also possible to disable source filtering for a specific pattern using
+# *.ext= (so without naming a filter).
+# This tag requires that the tag FILTER_SOURCE_FILES is set to YES.
+
+FILTER_SOURCE_PATTERNS =
+
+# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that
+# is part of the input, its contents will be placed on the main page
+# (index.html). This can be useful if you have a project on for instance GitHub
+# and want to reuse the introduction page also for the doxygen output.
+
+USE_MDFILE_AS_MAINPAGE =
+
+#---------------------------------------------------------------------------
+# Configuration options related to source browsing
+#---------------------------------------------------------------------------
+
+# If the SOURCE_BROWSER tag is set to YES then a list of source files will be
+# generated. Documented entities will be cross-referenced with these sources.
+#
+# Note: To get rid of all source code in the generated output, make sure that
+# also VERBATIM_HEADERS is set to NO.
+# The default value is: NO.
+
+SOURCE_BROWSER         = NO
+
+# Setting the INLINE_SOURCES tag to YES will include the body of functions,
+# classes and enums directly into the documentation.
+# The default value is: NO.
+
+INLINE_SOURCES         = NO
+
+# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any
+# special comment blocks from generated source code fragments. Normal C, C++ and
+# Fortran comments will always remain visible.
+# The default value is: YES.
+
+STRIP_CODE_COMMENTS    = YES
+
+# If the REFERENCED_BY_RELATION tag is set to YES then for each documented
+# entity all documented functions referencing it will be listed.
+# The default value is: NO.
+
+REFERENCED_BY_RELATION = NO
+
+# If the REFERENCES_RELATION tag is set to YES then for each documented function
+# all documented entities called/used by that function will be listed.
+# The default value is: NO.
+
+REFERENCES_RELATION    = NO
+
+# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set
+# to YES then the hyperlinks from functions in REFERENCES_RELATION and
+# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will
+# link to the documentation.
+# The default value is: YES.
+
+REFERENCES_LINK_SOURCE = YES
+
+# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the
+# source code will show a tooltip with additional information such as prototype,
+# brief description and links to the definition and documentation. Since this
+# will make the HTML file larger and loading of large files a bit slower, you
+# can opt to disable this feature.
+# The default value is: YES.
+# This tag requires that the tag SOURCE_BROWSER is set to YES.
+
+SOURCE_TOOLTIPS        = YES
+
+# If the USE_HTAGS tag is set to YES then the references to source code will
+# point to the HTML generated by the htags(1) tool instead of doxygen built-in
+# source browser. The htags tool is part of GNU's global source tagging system
+# (see https://www.gnu.org/software/global/global.html). You will need version
+# 4.8.6 or higher.
+#
+# To use it do the following:
+# - Install the latest version of global
+# - Enable SOURCE_BROWSER and USE_HTAGS in the configuration file
+# - Make sure the INPUT points to the root of the source tree
+# - Run doxygen as normal
+#
+# Doxygen will invoke htags (and that will in turn invoke gtags), so these
+# tools must be available from the command line (i.e. in the search path).
+#
+# The result: instead of the source browser generated by doxygen, the links to
+# source code will now point to the output of htags.
+# The default value is: NO.
+# This tag requires that the tag SOURCE_BROWSER is set to YES.
+
+USE_HTAGS              = NO
+
+# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a
+# verbatim copy of the header file for each class for which an include is
+# specified. Set to NO to disable this.
+# See also: Section \class.
+# The default value is: YES.
+
+VERBATIM_HEADERS       = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+
+# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all
+# compounds will be generated. Enable this if the project contains a lot of
+# classes, structs, unions or interfaces.
+# The default value is: YES.
+
+ALPHABETICAL_INDEX     = YES
+
+# In case all classes in a project start with a common prefix, all classes will
+# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
+# can be used to specify a prefix (or a list of prefixes) that should be ignored
+# while generating the index headers.
+# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
+
+IGNORE_PREFIX          =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the HTML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_HTML tag is set to YES, doxygen will generate HTML output
+# The default value is: YES.
+
+GENERATE_HTML          = YES
+
+# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: html.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_OUTPUT            = html
+
+# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each
+# generated HTML page (for example: .htm, .php, .asp).
+# The default value is: .html.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FILE_EXTENSION    = .html
+
+# The HTML_HEADER tag can be used to specify a user-defined HTML header file for
+# each generated HTML page. If the tag is left blank doxygen will generate a
+# standard header.
+#
+# To get valid HTML the header file that includes any scripts and style sheets
+# that doxygen needs, which is dependent on the configuration options used (e.g.
+# the setting GENERATE_TREEVIEW). It is highly recommended to start with a
+# default header using
+# doxygen -w html new_header.html new_footer.html new_stylesheet.css
+# YourConfigFile
+# and then modify the file new_header.html. See also section "Doxygen usage"
+# for information on how to generate the default header that doxygen normally
+# uses.
+# Note: The header is subject to change so you typically have to regenerate the
+# default header when upgrading to a newer version of doxygen. For a description
+# of the possible markers and block names see the documentation.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_HEADER            =
+
+# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
+# generated HTML page. If the tag is left blank doxygen will generate a standard
+# footer. See HTML_HEADER for more information on how to generate a default
+# footer and what special commands can be used inside the footer. See also
+# section "Doxygen usage" for information on how to generate the default footer
+# that doxygen normally uses.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FOOTER            =
+
+# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style
+# sheet that is used by each HTML page. It can be used to fine-tune the look of
+# the HTML output. If left blank doxygen will generate a default style sheet.
+# See also section "Doxygen usage" for information on how to generate the style
+# sheet that doxygen normally uses.
+# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as
+# it is more robust and this tag (HTML_STYLESHEET) will in the future become
+# obsolete.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_STYLESHEET        =
+
+# The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined
+# cascading style sheets that are included after the standard style sheets
+# created by doxygen. Using this option one can overrule certain style aspects.
+# This is preferred over using HTML_STYLESHEET since it does not replace the
+# standard style sheet and is therefore more robust against future updates.
+# Doxygen will copy the style sheet files to the output directory.
+# Note: The order of the extra style sheet files is of importance (e.g. the last
+# style sheet in the list overrules the setting of the previous ones in the
+# list). For an example see the documentation.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_EXTRA_STYLESHEET  =
+
+# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the HTML output directory. Note
+# that these files will be copied to the base HTML output directory. Use the
+# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
+# files. In the HTML_STYLESHEET file, use the file name only. Also note that the
+# files will be copied as-is; there are no commands or markers available.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_EXTRA_FILES       =
+
+# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
+# will adjust the colors in the style sheet and background images according to
+# this color. Hue is specified as an angle on a colorwheel, see
+# https://en.wikipedia.org/wiki/Hue for more information. For instance the value
+# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
+# purple, and 360 is red again.
+# Minimum value: 0, maximum value: 359, default value: 220.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_HUE    = 220
+
+# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
+# in the HTML output. For a value of 0 the output will use grayscales only. A
+# value of 255 will produce the most vivid colors.
+# Minimum value: 0, maximum value: 255, default value: 100.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_SAT    = 100
+
+# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the
+# luminance component of the colors in the HTML output. Values below 100
+# gradually make the output lighter, whereas values above 100 make the output
+# darker. The value divided by 100 is the actual gamma applied, so 80 represents
+# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not
+# change the gamma.
+# Minimum value: 40, maximum value: 240, default value: 80.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_COLORSTYLE_GAMMA  = 80
+
+# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
+# page will contain the date and time when the page was generated. Setting this
+# to YES can help to show when doxygen was last run and thus if the
+# documentation is up to date.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_TIMESTAMP         = NO
+
+# If the HTML_DYNAMIC_MENUS tag is set to YES then the generated HTML
+# documentation will contain a main index with vertical navigation menus that
+# are dynamically created via JavaScript. If disabled, the navigation index will
+# consists of multiple levels of tabs that are statically embedded in every HTML
+# page. Disable this option to support browsers that do not have JavaScript,
+# like the Qt help browser.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_DYNAMIC_MENUS     = YES
+
+# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
+# documentation will contain sections that can be hidden and shown after the
+# page has loaded.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_DYNAMIC_SECTIONS  = NO
+
+# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries
+# shown in the various tree structured indices initially; the user can expand
+# and collapse entries dynamically later on. Doxygen will expand the tree to
+# such a level that at most the specified number of entries are visible (unless
+# a fully collapsed tree already exceeds this amount). So setting the number of
+# entries 1 will produce a full collapsed tree by default. 0 is a special value
+# representing an infinite number of entries and will result in a full expanded
+# tree by default.
+# Minimum value: 0, maximum value: 9999, default value: 100.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_INDEX_NUM_ENTRIES = 100
+
+# If the GENERATE_DOCSET tag is set to YES, additional index files will be
+# generated that can be used as input for Apple's Xcode 3 integrated development
+# environment (see:
+# https://developer.apple.com/xcode/), introduced with OSX 10.5 (Leopard). To
+# create a documentation set, doxygen will generate a Makefile in the HTML
+# output directory. Running make will produce the docset in that directory and
+# running make install will install the docset in
+# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
+# startup. See https://developer.apple.com/library/archive/featuredarticles/Doxy
+# genXcode/_index.html for more information.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_DOCSET        = NO
+
+# This tag determines the name of the docset feed. A documentation feed provides
+# an umbrella under which multiple documentation sets from a single provider
+# (such as a company or product suite) can be grouped.
+# The default value is: Doxygen generated docs.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_FEEDNAME        = "Doxygen generated docs"
+
+# This tag specifies a string that should uniquely identify the documentation
+# set bundle. This should be a reverse domain-name style string, e.g.
+# com.mycompany.MyDocSet. Doxygen will append .docset to the name.
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_BUNDLE_ID       = org.doxygen.Project
+
+# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify
+# the documentation publisher. This should be a reverse domain-name style
+# string, e.g. com.mycompany.MyDocSet.documentation.
+# The default value is: org.doxygen.Publisher.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
+
+# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher.
+# The default value is: Publisher.
+# This tag requires that the tag GENERATE_DOCSET is set to YES.
+
+DOCSET_PUBLISHER_NAME  = Publisher
+
+# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
+# additional HTML index files: index.hhp, index.hhc, and index.hhk. The
+# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
+# (see:
+# https://www.microsoft.com/en-us/download/details.aspx?id=21138) on Windows.
+#
+# The HTML Help Workshop contains a compiler that can convert all HTML output
+# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
+# files are now used as the Windows 98 help format, and will replace the old
+# Windows help format (.hlp) on all Windows platforms in the future. Compressed
+# HTML files also contain an index, a table of contents, and you can search for
+# words in the documentation. The HTML workshop also contains a viewer for
+# compressed HTML files.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_HTMLHELP      = NO
+
+# The CHM_FILE tag can be used to specify the file name of the resulting .chm
+# file. You can add a path in front of the file if the result should not be
+# written to the html output directory.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+CHM_FILE               =
+
+# The HHC_LOCATION tag can be used to specify the location (absolute path
+# including file name) of the HTML help compiler (hhc.exe). If non-empty,
+# doxygen will try to run the HTML help compiler on the generated index.hhp.
+# The file has to be specified with full path.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+HHC_LOCATION           =
+
+# The GENERATE_CHI flag controls if a separate .chi index file is generated
+# (YES) or that it should be included in the main .chm file (NO).
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+GENERATE_CHI           = NO
+
+# The CHM_INDEX_ENCODING is used to encode HtmlHelp index (hhk), content (hhc)
+# and project file content.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+CHM_INDEX_ENCODING     =
+
+# The BINARY_TOC flag controls whether a binary table of contents is generated
+# (YES) or a normal table of contents (NO) in the .chm file. Furthermore it
+# enables the Previous and Next buttons.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+BINARY_TOC             = NO
+
+# The TOC_EXPAND flag can be set to YES to add extra items for group members to
+# the table of contents of the HTML help documentation and to the tree view.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
+
+TOC_EXPAND             = NO
+
+# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
+# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that
+# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help
+# (.qch) of the generated HTML documentation.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_QHP           = NO
+
+# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify
+# the file name of the resulting .qch file. The path specified is relative to
+# the HTML output folder.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QCH_FILE               =
+
+# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
+# Project output. For more information please see Qt Help Project / Namespace
+# (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#namespace).
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_NAMESPACE          = org.doxygen.Project
+
+# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
+# Help Project output. For more information please see Qt Help Project / Virtual
+# Folders (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#virtual-folders).
+# The default value is: doc.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_VIRTUAL_FOLDER     = doc
+
+# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
+# filter to add. For more information please see Qt Help Project / Custom
+# Filters (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_CUST_FILTER_NAME   =
+
+# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
+# custom filter to add. For more information please see Qt Help Project / Custom
+# Filters (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_CUST_FILTER_ATTRS  =
+
+# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
+# project's filter section matches. Qt Help Project / Filter Attributes (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#filter-attributes).
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHP_SECT_FILTER_ATTRS  =
+
+# The QHG_LOCATION tag can be used to specify the location (absolute path
+# including file name) of Qt's qhelpgenerator. If non-empty doxygen will try to
+# run qhelpgenerator on the generated .qhp file.
+# This tag requires that the tag GENERATE_QHP is set to YES.
+
+QHG_LOCATION           =
+
+# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be
+# generated, together with the HTML files, they form an Eclipse help plugin. To
+# install this plugin and make it available under the help contents menu in
+# Eclipse, the contents of the directory containing the HTML and XML files needs
+# to be copied into the plugins directory of eclipse. The name of the directory
+# within the plugins directory should be the same as the ECLIPSE_DOC_ID value.
+# After copying Eclipse needs to be restarted before the help appears.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_ECLIPSEHELP   = NO
+
+# A unique identifier for the Eclipse help plugin. When installing the plugin
+# the directory name containing the HTML and XML files should also have this
+# name. Each documentation set should have its own identifier.
+# The default value is: org.doxygen.Project.
+# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES.
+
+ECLIPSE_DOC_ID         = org.doxygen.Project
+
+# If you want full control over the layout of the generated HTML pages it might
+# be necessary to disable the index and replace it with your own. The
+# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top
+# of each HTML page. A value of NO enables the index and the value YES disables
+# it. Since the tabs in the index contain the same information as the navigation
+# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+DISABLE_INDEX          = NO
+
+# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
+# structure should be generated to display hierarchical information. If the tag
+# value is set to YES, a side panel will be generated containing a tree-like
+# index structure (just like the one that is generated for HTML Help). For this
+# to work a browser that supports JavaScript, DHTML, CSS and frames is required
+# (i.e. any modern browser). Windows users are probably better off using the
+# HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can
+# further fine-tune the look of the index. As an example, the default style
+# sheet generated by doxygen has an example that shows how to put an image at
+# the root of the tree instead of the PROJECT_NAME. Since the tree basically has
+# the same information as the tab index, you could consider setting
+# DISABLE_INDEX to YES when enabling this option.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+GENERATE_TREEVIEW      = YES
+
+# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
+# doxygen will group on one line in the generated HTML documentation.
+#
+# Note that a value of 0 will completely suppress the enum values from appearing
+# in the overview section.
+# Minimum value: 0, maximum value: 20, default value: 4.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+ENUM_VALUES_PER_LINE   = 4
+
+# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used
+# to set the initial width (in pixels) of the frame in which the tree is shown.
+# Minimum value: 0, maximum value: 1500, default value: 250.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+TREEVIEW_WIDTH         = 250
+
+# If the EXT_LINKS_IN_WINDOW option is set to YES, doxygen will open links to
+# external symbols imported via tag files in a separate window.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+EXT_LINKS_IN_WINDOW    = NO
+
+# If the HTML_FORMULA_FORMAT option is set to svg, doxygen will use the pdf2svg
+# tool (see https://github.com/dawbarton/pdf2svg) or inkscape (see
+# https://inkscape.org) to generate formulas as SVG images instead of PNGs for
+# the HTML output. These images will generally look nicer at scaled resolutions.
+# Possible values are: png (the default) and svg (looks nicer but requires the
+# pdf2svg or inkscape tool).
+# The default value is: png.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FORMULA_FORMAT    = png
+
+# Use this tag to change the font size of LaTeX formulas included as images in
+# the HTML documentation. When you change the font size after a successful
+# doxygen run you need to manually remove any form_*.png images from the HTML
+# output directory to force them to be regenerated.
+# Minimum value: 8, maximum value: 50, default value: 10.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FORMULA_FONTSIZE       = 10
+
+# Use the FORMULA_TRANSPARENT tag to determine whether or not the images
+# generated for formulas are transparent PNGs. Transparent PNGs are not
+# supported properly for IE 6.0, but are supported on all modern browsers.
+#
+# Note that when changing this option you need to delete any form_*.png files in
+# the HTML output directory before the changes have effect.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+FORMULA_TRANSPARENT    = YES
+
+# The FORMULA_MACROFILE can contain LaTeX \newcommand and \renewcommand commands
+# to create new LaTeX commands to be used in formulas as building blocks. See
+# the section "Including formulas" for details.
+
+FORMULA_MACROFILE      =
+
+# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
+# https://www.mathjax.org) which uses client side JavaScript for the rendering
+# instead of using pre-rendered bitmaps. Use this if you do not have LaTeX
+# installed or if you want to formulas look prettier in the HTML output. When
+# enabled you may also need to install MathJax separately and configure the path
+# to it using the MATHJAX_RELPATH option.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+USE_MATHJAX            = NO
+
+# When MathJax is enabled you can set the default output format to be used for
+# the MathJax output. See the MathJax site (see:
+# http://docs.mathjax.org/en/v2.7-latest/output.html) for more details.
+# Possible values are: HTML-CSS (which is slower, but has the best
+# compatibility), NativeMML (i.e. MathML) and SVG.
+# The default value is: HTML-CSS.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_FORMAT         = HTML-CSS
+
+# When MathJax is enabled you need to specify the location relative to the HTML
+# output directory using the MATHJAX_RELPATH option. The destination directory
+# should contain the MathJax.js script. For instance, if the mathjax directory
+# is located at the same level as the HTML output directory, then
+# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
+# Content Delivery Network so you can quickly see the result without installing
+# MathJax. However, it is strongly recommended to install a local copy of
+# MathJax from https://www.mathjax.org before deployment.
+# The default value is: https://cdn.jsdelivr.net/npm/mathjax@2.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_RELPATH        = https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/
+
+# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
+# extension names that should be enabled during MathJax rendering. For example
+# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_EXTENSIONS     =
+
+# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
+# of code that will be used on startup of the MathJax code. See the MathJax site
+# (see:
+# http://docs.mathjax.org/en/v2.7-latest/output.html) for more details. For an
+# example see the documentation.
+# This tag requires that the tag USE_MATHJAX is set to YES.
+
+MATHJAX_CODEFILE       =
+
+# When the SEARCHENGINE tag is enabled doxygen will generate a search box for
+# the HTML output. The underlying search engine uses javascript and DHTML and
+# should work on any modern browser. Note that when using HTML help
+# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET)
+# there is already a search function so this one should typically be disabled.
+# For large projects the javascript based search engine can be slow, then
+# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to
+# search using the keyboard; to jump to the search box use <access key> + S
+# (what the <access key> is depends on the OS and browser, but it is typically
+# <CTRL>, <ALT>/<option>, or both). Inside the search box use the <cursor down
+# key> to jump into the search results window, the results can be navigated
+# using the <cursor keys>. Press <Enter> to select an item or <escape> to cancel
+# the search. The filter options can be selected when the cursor is inside the
+# search box by pressing <Shift>+<cursor down>. Also here use the <cursor keys>
+# to select a filter and <Enter> or <escape> to activate or cancel the filter
+# option.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+SEARCHENGINE           = YES
+
+# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
+# implemented using a web server instead of a web client using JavaScript. There
+# are two flavors of web server based searching depending on the EXTERNAL_SEARCH
+# setting. When disabled, doxygen will generate a PHP script for searching and
+# an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
+# and searching needs to be provided by external tools. See the section
+# "External Indexing and Searching" for details.
+# The default value is: NO.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SERVER_BASED_SEARCH    = NO
+
+# When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP
+# script for searching. Instead the search results are written to an XML file
+# which needs to be processed by an external indexer. Doxygen will invoke an
+# external search engine pointed to by the SEARCHENGINE_URL option to obtain the
+# search results.
+#
+# Doxygen ships with an example indexer (doxyindexer) and search engine
+# (doxysearch.cgi) which are based on the open source search engine library
+# Xapian (see:
+# https://xapian.org/).
+#
+# See the section "External Indexing and Searching" for details.
+# The default value is: NO.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTERNAL_SEARCH        = NO
+
+# The SEARCHENGINE_URL should point to a search engine hosted by a web server
+# which will return the search results when EXTERNAL_SEARCH is enabled.
+#
+# Doxygen ships with an example indexer (doxyindexer) and search engine
+# (doxysearch.cgi) which are based on the open source search engine library
+# Xapian (see:
+# https://xapian.org/). See the section "External Indexing and Searching" for
+# details.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SEARCHENGINE_URL       =
+
+# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
+# search data is written to a file for indexing by an external tool. With the
+# SEARCHDATA_FILE tag the name of this file can be specified.
+# The default file is: searchdata.xml.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+SEARCHDATA_FILE        = searchdata.xml
+
+# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the
+# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
+# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
+# projects and redirect the results back to the right project.
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTERNAL_SEARCH_ID     =
+
+# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
+# projects other than the one defined by this configuration file, but that are
+# all added to the same external search index. Each project needs to have a
+# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of
+# to a relative location where the documentation can be found. The format is:
+# EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ...
+# This tag requires that the tag SEARCHENGINE is set to YES.
+
+EXTRA_SEARCH_MAPPINGS  =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_LATEX tag is set to YES, doxygen will generate LaTeX output.
+# The default value is: YES.
+
+GENERATE_LATEX         = NO
+
+# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: latex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_OUTPUT           = latex
+
+# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
+# invoked.
+#
+# Note that when not enabling USE_PDFLATEX the default is latex when enabling
+# USE_PDFLATEX the default is pdflatex and when in the later case latex is
+# chosen this is overwritten by pdflatex. For specific output languages the
+# default can have been set differently, this depends on the implementation of
+# the output language.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_CMD_NAME         =
+
+# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
+# index for LaTeX.
+# Note: This tag is used in the Makefile / make.bat.
+# See also: LATEX_MAKEINDEX_CMD for the part in the generated output file
+# (.tex).
+# The default file is: makeindex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+MAKEINDEX_CMD_NAME     = makeindex
+
+# The LATEX_MAKEINDEX_CMD tag can be used to specify the command name to
+# generate index for LaTeX. In case there is no backslash (\) as first character
+# it will be automatically added in the LaTeX code.
+# Note: This tag is used in the generated output file (.tex).
+# See also: MAKEINDEX_CMD_NAME for the part in the Makefile / make.bat.
+# The default value is: makeindex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_MAKEINDEX_CMD    = makeindex
+
+# If the COMPACT_LATEX tag is set to YES, doxygen generates more compact LaTeX
+# documents. This may be useful for small projects and may help to save some
+# trees in general.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+COMPACT_LATEX          = NO
+
+# The PAPER_TYPE tag can be used to set the paper type that is used by the
+# printer.
+# Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x
+# 14 inches) and executive (7.25 x 10.5 inches).
+# The default value is: a4.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+PAPER_TYPE             = a4
+
+# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
+# that should be included in the LaTeX output. The package can be specified just
+# by its name or with the correct syntax as to be used with the LaTeX
+# \usepackage command. To get the times font for instance you can specify :
+# EXTRA_PACKAGES=times or EXTRA_PACKAGES={times}
+# To use the option intlimits with the amsmath package you can specify:
+# EXTRA_PACKAGES=[intlimits]{amsmath}
+# If left blank no extra packages will be included.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+EXTRA_PACKAGES         =
+
+# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
+# generated LaTeX document. The header should contain everything until the first
+# chapter. If it is left blank doxygen will generate a standard header. See
+# section "Doxygen usage" for information on how to let doxygen write the
+# default header to a separate file.
+#
+# Note: Only use a user-defined header if you know what you are doing! The
+# following commands have a special meaning inside the header: $title,
+# $datetime, $date, $doxygenversion, $projectname, $projectnumber,
+# $projectbrief, $projectlogo. Doxygen will replace $title with the empty
+# string, for the replacement values of the other commands the user is referred
+# to HTML_HEADER.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_HEADER           =
+
+# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
+# generated LaTeX document. The footer should contain everything after the last
+# chapter. If it is left blank doxygen will generate a standard footer. See
+# LATEX_HEADER for more information on how to generate a default footer and what
+# special commands can be used inside the footer.
+#
+# Note: Only use a user-defined footer if you know what you are doing!
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_FOOTER           =
+
+# The LATEX_EXTRA_STYLESHEET tag can be used to specify additional user-defined
+# LaTeX style sheets that are included after the standard style sheets created
+# by doxygen. Using this option one can overrule certain style aspects. Doxygen
+# will copy the style sheet files to the output directory.
+# Note: The order of the extra style sheet files is of importance (e.g. the last
+# style sheet in the list overrules the setting of the previous ones in the
+# list).
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EXTRA_STYLESHEET =
+
+# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
+# other source files which should be copied to the LATEX_OUTPUT output
+# directory. Note that the files will be copied as-is; there are no commands or
+# markers available.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EXTRA_FILES      =
+
+# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is
+# prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will
+# contain links (just like the HTML output) instead of page references. This
+# makes the output suitable for online browsing using a PDF viewer.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+PDF_HYPERLINKS         = YES
+
+# If the USE_PDFLATEX tag is set to YES, doxygen will use the engine as
+# specified with LATEX_CMD_NAME to generate the PDF file directly from the LaTeX
+# files. Set this option to YES, to get a higher quality PDF documentation.
+#
+# See also section LATEX_CMD_NAME for selecting the engine.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+USE_PDFLATEX           = YES
+
+# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
+# command to the generated LaTeX files. This will instruct LaTeX to keep running
+# if errors occur, instead of asking the user for help. This option is also used
+# when generating formulas in HTML.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_BATCHMODE        = NO
+
+# If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the
+# index chapters (such as File Index, Compound Index, etc.) in the output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_HIDE_INDICES     = NO
+
+# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
+# code with syntax highlighting in the LaTeX output.
+#
+# Note that which sources are shown also depends on other settings such as
+# SOURCE_BROWSER.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_SOURCE_CODE      = NO
+
+# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
+# bibliography, e.g. plainnat, or ieeetr. See
+# https://en.wikipedia.org/wiki/BibTeX and \cite for more info.
+# The default value is: plain.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_BIB_STYLE        = plain
+
+# If the LATEX_TIMESTAMP tag is set to YES then the footer of each generated
+# page will contain the date and time when the page was generated. Setting this
+# to NO can help when comparing the output of multiple runs.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_TIMESTAMP        = NO
+
+# The LATEX_EMOJI_DIRECTORY tag is used to specify the (relative or absolute)
+# path from which the emoji images will be read. If a relative path is entered,
+# it will be relative to the LATEX_OUTPUT directory. If left blank the
+# LATEX_OUTPUT directory will be used.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EMOJI_DIRECTORY  =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the RTF output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_RTF tag is set to YES, doxygen will generate RTF output. The
+# RTF output is optimized for Word 97 and may not look too pretty with other RTF
+# readers/editors.
+# The default value is: NO.
+
+GENERATE_RTF           = NO
+
+# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: rtf.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_OUTPUT             = rtf
+
+# If the COMPACT_RTF tag is set to YES, doxygen generates more compact RTF
+# documents. This may be useful for small projects and may help to save some
+# trees in general.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+COMPACT_RTF            = NO
+
+# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will
+# contain hyperlink fields. The RTF file will contain links (just like the HTML
+# output) instead of page references. This makes the output suitable for online
+# browsing using Word or some other Word compatible readers that support those
+# fields.
+#
+# Note: WordPad (write) and others do not support links.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_HYPERLINKS         = NO
+
+# Load stylesheet definitions from file. Syntax is similar to doxygen's
+# configuration file, i.e. a series of assignments. You only have to provide
+# replacements, missing definitions are set to their default value.
+#
+# See also section "Doxygen usage" for information on how to generate the
+# default style sheet that doxygen normally uses.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_STYLESHEET_FILE    =
+
+# Set optional variables used in the generation of an RTF document. Syntax is
+# similar to doxygen's configuration file. A template extensions file can be
+# generated using doxygen -e rtf extensionFile.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_EXTENSIONS_FILE    =
+
+# If the RTF_SOURCE_CODE tag is set to YES then doxygen will include source code
+# with syntax highlighting in the RTF output.
+#
+# Note that which sources are shown also depends on other settings such as
+# SOURCE_BROWSER.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_RTF is set to YES.
+
+RTF_SOURCE_CODE        = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the man page output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_MAN tag is set to YES, doxygen will generate man pages for
+# classes and files.
+# The default value is: NO.
+
+GENERATE_MAN           = NO
+
+# The MAN_OUTPUT tag is used to specify where the man pages will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it. A directory man3 will be created inside the directory specified by
+# MAN_OUTPUT.
+# The default directory is: man.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_OUTPUT             = man
+
+# The MAN_EXTENSION tag determines the extension that is added to the generated
+# man pages. In case the manual section does not start with a number, the number
+# 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is
+# optional.
+# The default value is: .3.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_EXTENSION          = .3
+
+# The MAN_SUBDIR tag determines the name of the directory created within
+# MAN_OUTPUT in which the man pages are placed. If defaults to man followed by
+# MAN_EXTENSION with the initial . removed.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_SUBDIR             =
+
+# If the MAN_LINKS tag is set to YES and doxygen generates man output, then it
+# will generate one additional man file for each entity documented in the real
+# man page(s). These additional files only source the real man page, but without
+# them the man command would be unable to find the correct page.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_MAN is set to YES.
+
+MAN_LINKS              = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the XML output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_XML tag is set to YES, doxygen will generate an XML file that
+# captures the structure of the code including all documentation.
+# The default value is: NO.
+
+GENERATE_XML           = NO
+
+# The XML_OUTPUT tag is used to specify where the XML pages will be put. If a
+# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
+# it.
+# The default directory is: xml.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_OUTPUT             = xml
+
+# If the XML_PROGRAMLISTING tag is set to YES, doxygen will dump the program
+# listings (including syntax highlighting and cross-referencing information) to
+# the XML output. Note that enabling this will significantly increase the size
+# of the XML output.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_PROGRAMLISTING     = YES
+
+# If the XML_NS_MEMB_FILE_SCOPE tag is set to YES, doxygen will include
+# namespace members in file scope as well, matching the HTML output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_NS_MEMB_FILE_SCOPE = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the DOCBOOK output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_DOCBOOK tag is set to YES, doxygen will generate Docbook files
+# that can be used to generate PDF.
+# The default value is: NO.
+
+GENERATE_DOCBOOK       = NO
+
+# The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put.
+# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
+# front of it.
+# The default directory is: docbook.
+# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
+
+DOCBOOK_OUTPUT         = docbook
+
+# If the DOCBOOK_PROGRAMLISTING tag is set to YES, doxygen will include the
+# program listings (including syntax highlighting and cross-referencing
+# information) to the DOCBOOK output. Note that enabling this will significantly
+# increase the size of the DOCBOOK output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
+
+DOCBOOK_PROGRAMLISTING = NO
+
+#---------------------------------------------------------------------------
+# Configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_AUTOGEN_DEF tag is set to YES, doxygen will generate an
+# AutoGen Definitions (see http://autogen.sourceforge.net/) file that captures
+# the structure of the code including all documentation. Note that this feature
+# is still experimental and incomplete at the moment.
+# The default value is: NO.
+
+GENERATE_AUTOGEN_DEF   = NO
+
+#---------------------------------------------------------------------------
+# Configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+
+# If the GENERATE_PERLMOD tag is set to YES, doxygen will generate a Perl module
+# file that captures the structure of the code including all documentation.
+#
+# Note that this feature is still experimental and incomplete at the moment.
+# The default value is: NO.
+
+GENERATE_PERLMOD       = NO
+
+# If the PERLMOD_LATEX tag is set to YES, doxygen will generate the necessary
+# Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI
+# output from the Perl module output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_LATEX          = NO
+
+# If the PERLMOD_PRETTY tag is set to YES, the Perl module output will be nicely
+# formatted so it can be parsed by a human reader. This is useful if you want to
+# understand what is going on. On the other hand, if this tag is set to NO, the
+# size of the Perl module output will be much smaller and Perl will parse it
+# just the same.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_PRETTY         = YES
+
+# The names of the make variables in the generated doxyrules.make file are
+# prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. This is useful
+# so different doxyrules.make files included by the same Makefile don't
+# overwrite each other's variables.
+# This tag requires that the tag GENERATE_PERLMOD is set to YES.
+
+PERLMOD_MAKEVAR_PREFIX =
+
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+
+# If the ENABLE_PREPROCESSING tag is set to YES, doxygen will evaluate all
+# C-preprocessor directives found in the sources and include files.
+# The default value is: YES.
+
+ENABLE_PREPROCESSING   = YES
+
+# If the MACRO_EXPANSION tag is set to YES, doxygen will expand all macro names
+# in the source code. If set to NO, only conditional compilation will be
+# performed. Macro expansion can be done in a controlled way by setting
+# EXPAND_ONLY_PREDEF to YES.
+# The default value is: NO.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+MACRO_EXPANSION        = YES
+
+# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
+# the macro expansion is limited to the macros specified with the PREDEFINED and
+# EXPAND_AS_DEFINED tags.
+# The default value is: NO.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+EXPAND_ONLY_PREDEF     = NO
+
+# If the SEARCH_INCLUDES tag is set to YES, the include files in the
+# INCLUDE_PATH will be searched if a #include is found.
+# The default value is: YES.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+SEARCH_INCLUDES        = YES
+
+# The INCLUDE_PATH tag can be used to specify one or more directories that
+# contain include files that are not input files but should be processed by the
+# preprocessor.
+# This tag requires that the tag SEARCH_INCLUDES is set to YES.
+
+INCLUDE_PATH           = @CMAKE_BINARY_DIR@/include
+
+# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
+# patterns (like *.h and *.hpp) to filter out the header-files in the
+# directories. If left blank, the patterns specified with FILE_PATTERNS will be
+# used.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+INCLUDE_FILE_PATTERNS  = *.h
+
+# The PREDEFINED tag can be used to specify one or more macro names that are
+# defined before the preprocessor is started (similar to the -D option of e.g.
+# gcc). The argument of the tag is a list of macros of the form: name or
+# name=definition (no spaces). If the definition and the "=" are omitted, "=1"
+# is assumed. To prevent a macro definition from being undefined via #undef or
+# recursively expanded use the := operator instead of the = operator.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+PREDEFINED             =
+
+# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
+# tag can be used to specify a list of macro names that should be expanded. The
+# macro definition that is found in the sources will be used. Use the PREDEFINED
+# tag if you want to use a different macro definition that overrules the
+# definition found in the source code.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+EXPAND_AS_DEFINED      =
+
+# If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
+# remove all references to function-like macros that are alone on a line, have
+# an all uppercase name, and do not end with a semicolon. Such function macros
+# are typically used for boiler-plate code, and will confuse the parser if not
+# removed.
+# The default value is: YES.
+# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
+
+SKIP_FUNCTION_MACROS   = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to external references
+#---------------------------------------------------------------------------
+
+# The TAGFILES tag can be used to specify one or more tag files. For each tag
+# file the location of the external documentation should be added. The format of
+# a tag file without this location is as follows:
+# TAGFILES = file1 file2 ...
+# Adding location for the tag files is done as follows:
+# TAGFILES = file1=loc1 "file2 = loc2" ...
+# where loc1 and loc2 can be relative or absolute paths or URLs. See the
+# section "Linking to external documentation" for more information about the use
+# of tag files.
+# Note: Each tag file must have a unique name (where the name does NOT include
+# the path). If a tag file is not located in the directory in which doxygen is
+# run, you must also specify the path to the tagfile here.
+
+TAGFILES               =
+
+# When a file name is specified after GENERATE_TAGFILE, doxygen will create a
+# tag file that is based on the input files it reads. See section "Linking to
+# external documentation" for more information about the usage of tag files.
+
+GENERATE_TAGFILE       =
+
+# If the ALLEXTERNALS tag is set to YES, all external class will be listed in
+# the class index. If set to NO, only the inherited external classes will be
+# listed.
+# The default value is: NO.
+
+ALLEXTERNALS           = NO
+
+# If the EXTERNAL_GROUPS tag is set to YES, all external groups will be listed
+# in the modules index. If set to NO, only the current project's groups will be
+# listed.
+# The default value is: YES.
+
+EXTERNAL_GROUPS        = YES
+
+# If the EXTERNAL_PAGES tag is set to YES, all external pages will be listed in
+# the related pages index. If set to NO, only the current project's pages will
+# be listed.
+# The default value is: YES.
+
+EXTERNAL_PAGES         = YES
+
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+
+# If the CLASS_DIAGRAMS tag is set to YES, doxygen will generate a class diagram
+# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
+# NO turns the diagrams off. Note that this option also works with HAVE_DOT
+# disabled, but it is recommended to install and use dot, since it yields more
+# powerful graphs.
+# The default value is: YES.
+
+CLASS_DIAGRAMS         = YES
+
+# You can include diagrams made with dia in doxygen documentation. Doxygen will
+# then run dia to produce the diagram and insert it in the documentation. The
+# DIA_PATH tag allows you to specify the directory where the dia binary resides.
+# If left empty dia is assumed to be found in the default search path.
+
+DIA_PATH               =
+
+# If set to YES the inheritance and collaboration graphs will hide inheritance
+# and usage relations if the target is undocumented or is not a class.
+# The default value is: YES.
+
+HIDE_UNDOC_RELATIONS   = YES
+
+# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
+# available from the path. This tool is part of Graphviz (see:
+# http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
+# Bell Labs. The other options in this section have no effect if this option is
+# set to NO
+# The default value is: NO.
+
+HAVE_DOT               = NO
+
+# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed
+# to run in parallel. When set to 0 doxygen will base this on the number of
+# processors available in the system. You can set it explicitly to a value
+# larger than 0 to get control over the balance between CPU load and processing
+# speed.
+# Minimum value: 0, maximum value: 32, default value: 0.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_NUM_THREADS        = 0
+
+# When you want a differently looking font in the dot files that doxygen
+# generates you can specify the font name using DOT_FONTNAME. You need to make
+# sure dot is able to find the font, which can be done by putting it in a
+# standard location or by setting the DOTFONTPATH environment variable or by
+# setting DOT_FONTPATH to the directory containing the font.
+# The default value is: Helvetica.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTNAME           = Helvetica
+
+# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
+# dot graphs.
+# Minimum value: 4, maximum value: 24, default value: 10.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTSIZE           = 10
+
+# By default doxygen will tell dot to use the default font as specified with
+# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
+# the path where dot can find it using this tag.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_FONTPATH           =
+
+# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
+# each documented class showing the direct and indirect inheritance relations.
+# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CLASS_GRAPH            = YES
+
+# If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
+# graph for each documented class showing the direct and indirect implementation
+# dependencies (inheritance, containment, and class references variables) of the
+# class with other documented classes.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+COLLABORATION_GRAPH    = YES
+
+# If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
+# groups, showing the direct groups dependencies.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GROUP_GRAPHS           = YES
+
+# If the UML_LOOK tag is set to YES, doxygen will generate inheritance and
+# collaboration diagrams in a style similar to the OMG's Unified Modeling
+# Language.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+UML_LOOK               = NO
+
+# If the UML_LOOK tag is enabled, the fields and methods are shown inside the
+# class node. If there are many fields or methods and many nodes the graph may
+# become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the
+# number of items for each type to make the size more manageable. Set this to 0
+# for no limit. Note that the threshold may be exceeded by 50% before the limit
+# is enforced. So when you set the threshold to 10, up to 15 fields may appear,
+# but if the number exceeds 15, the total amount of fields shown is limited to
+# 10.
+# Minimum value: 0, maximum value: 100, default value: 10.
+# This tag requires that the tag UML_LOOK is set to YES.
+
+UML_LIMIT_NUM_FIELDS   = 10
+
+# If the DOT_UML_DETAILS tag is set to NO, doxygen will show attributes and
+# methods without types and arguments in the UML graphs. If the DOT_UML_DETAILS
+# tag is set to YES, doxygen will add type and arguments for attributes and
+# methods in the UML graphs. If the DOT_UML_DETAILS tag is set to NONE, doxygen
+# will not generate fields with class member information in the UML graphs. The
+# class diagrams will look similar to the default class diagrams but using UML
+# notation for the relationships.
+# Possible values are: NO, YES and NONE.
+# The default value is: NO.
+# This tag requires that the tag UML_LOOK is set to YES.
+
+DOT_UML_DETAILS        = NO
+
+# The DOT_WRAP_THRESHOLD tag can be used to set the maximum number of characters
+# to display on a single line. If the actual line length exceeds this threshold
+# significantly it will wrapped across multiple lines. Some heuristics are apply
+# to avoid ugly line breaks.
+# Minimum value: 0, maximum value: 1000, default value: 17.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_WRAP_THRESHOLD     = 17
+
+# If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
+# collaboration graphs will show the relations between templates and their
+# instances.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+TEMPLATE_RELATIONS     = NO
+
+# If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to
+# YES then doxygen will generate a graph for each documented file showing the
+# direct and indirect include dependencies of the file with other documented
+# files.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INCLUDE_GRAPH          = YES
+
+# If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are
+# set to YES then doxygen will generate a graph for each documented file showing
+# the direct and indirect include dependencies of the file with other documented
+# files.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INCLUDED_BY_GRAPH      = YES
+
+# If the CALL_GRAPH tag is set to YES then doxygen will generate a call
+# dependency graph for every global function or class method.
+#
+# Note that enabling this option will significantly increase the time of a run.
+# So in most cases it will be better to enable call graphs for selected
+# functions only using the \callgraph command. Disabling a call graph can be
+# accomplished by means of the command \hidecallgraph.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CALL_GRAPH             = NO
+
+# If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller
+# dependency graph for every global function or class method.
+#
+# Note that enabling this option will significantly increase the time of a run.
+# So in most cases it will be better to enable caller graphs for selected
+# functions only using the \callergraph command. Disabling a caller graph can be
+# accomplished by means of the command \hidecallergraph.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+CALLER_GRAPH           = NO
+
+# If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
+# hierarchy of all classes instead of a textual one.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GRAPHICAL_HIERARCHY    = YES
+
+# If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the
+# dependencies a directory has on other directories in a graphical way. The
+# dependency relations are determined by the #include relations between the
+# files in the directories.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DIRECTORY_GRAPH        = YES
+
+# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
+# generated by dot. For an explanation of the image formats see the section
+# output formats in the documentation of the dot tool (Graphviz (see:
+# http://www.graphviz.org/)).
+# Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
+# to make the SVG files visible in IE 9+ (other browsers do not have this
+# requirement).
+# Possible values are: png, jpg, gif, svg, png:gd, png:gd:gd, png:cairo,
+# png:cairo:gd, png:cairo:cairo, png:cairo:gdiplus, png:gdiplus and
+# png:gdiplus:gdiplus.
+# The default value is: png.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_IMAGE_FORMAT       = png
+
+# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
+# enable generation of interactive SVG images that allow zooming and panning.
+#
+# Note that this requires a modern browser other than Internet Explorer. Tested
+# and working are Firefox, Chrome, Safari, and Opera.
+# Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
+# the SVG files visible. Older versions of IE do not have SVG support.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+INTERACTIVE_SVG        = NO
+
+# The DOT_PATH tag can be used to specify the path where the dot tool can be
+# found. If left blank, it is assumed the dot tool can be found in the path.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_PATH               =
+
+# The DOTFILE_DIRS tag can be used to specify one or more directories that
+# contain dot files that are included in the documentation (see the \dotfile
+# command).
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOTFILE_DIRS           =
+
+# The MSCFILE_DIRS tag can be used to specify one or more directories that
+# contain msc files that are included in the documentation (see the \mscfile
+# command).
+
+MSCFILE_DIRS           =
+
+# The DIAFILE_DIRS tag can be used to specify one or more directories that
+# contain dia files that are included in the documentation (see the \diafile
+# command).
+
+DIAFILE_DIRS           =
+
+# When using plantuml, the PLANTUML_JAR_PATH tag should be used to specify the
+# path where java can find the plantuml.jar file. If left blank, it is assumed
+# PlantUML is not used or called during a preprocessing step. Doxygen will
+# generate a warning when it encounters a \startuml command in this case and
+# will not generate output for the diagram.
+
+PLANTUML_JAR_PATH      =
+
+# When using plantuml, the PLANTUML_CFG_FILE tag can be used to specify a
+# configuration file for plantuml.
+
+PLANTUML_CFG_FILE      =
+
+# When using plantuml, the specified paths are searched for files specified by
+# the !include statement in a plantuml block.
+
+PLANTUML_INCLUDE_PATH  =
+
+# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
+# that will be shown in the graph. If the number of nodes in a graph becomes
+# larger than this value, doxygen will truncate the graph, which is visualized
+# by representing a node as a red box. Note that doxygen if the number of direct
+# children of the root node in a graph is already larger than
+# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that
+# the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
+# Minimum value: 0, maximum value: 10000, default value: 50.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_GRAPH_MAX_NODES    = 50
+
+# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs
+# generated by dot. A depth value of 3 means that only nodes reachable from the
+# root by following a path via at most 3 edges will be shown. Nodes that lay
+# further from the root node will be omitted. Note that setting this option to 1
+# or 2 may greatly reduce the computation time needed for large code bases. Also
+# note that the size of a graph can be further restricted by
+# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
+# Minimum value: 0, maximum value: 1000, default value: 0.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+MAX_DOT_GRAPH_DEPTH    = 0
+
+# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
+# background. This is disabled by default, because dot on Windows does not seem
+# to support this out of the box.
+#
+# Warning: Depending on the platform used, enabling this option may lead to
+# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
+# read).
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_TRANSPARENT        = NO
+
+# Set the DOT_MULTI_TARGETS tag to YES to allow dot to generate multiple output
+# files in one run (i.e. multiple -o and -T options on the command line). This
+# makes dot run faster, but since only newer versions of dot (>1.8.10) support
+# this, this feature is disabled by default.
+# The default value is: NO.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_MULTI_TARGETS      = NO
+
+# If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
+# explaining the meaning of the various boxes and arrows in the dot generated
+# graphs.
+# The default value is: YES.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+GENERATE_LEGEND        = YES
+
+# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate
+# files that are used to generate the various graphs.
+#
+# Note: This setting is not only used for dot files but also for msc and
+# plantuml temporary files.
+# The default value is: YES.
+
+DOT_CLEANUP            = YES
diff --git a/crates/c-api/include/doc-wasm.h b/crates/c-api/include/doc-wasm.h
index 6bad15c7445a..45afbecf919f 100644
--- a/crates/c-api/include/doc-wasm.h
+++ b/crates/c-api/include/doc-wasm.h
@@ -1,3 +1,5 @@
+/* clang-format off */
+
 /**
  * \file wasm.h
  *
diff --git a/crates/c-api/include/wasi.h b/crates/c-api/include/wasi.h
index e927e04a44aa..b7d6d0623f9b 100644
--- a/crates/c-api/include/wasi.h
+++ b/crates/c-api/include/wasi.h
@@ -7,8 +7,11 @@
 #ifndef WASI_H
 #define WASI_H
 
-#include <stdint.h>
 #include "wasm.h"
+#include <stdint.h>
+#include <wasmtime/conf.h>
+
+#ifdef WASMTIME_FEATURE_WASI
 
 #ifndef WASI_API_EXTERN
 #ifdef _WIN32
@@ -24,9 +27,9 @@ extern "C" {
 
 #define own
 
-#define WASI_DECLARE_OWN(name) \
-  typedef struct wasi_##name##_t wasi_##name##_t; \
-  WASI_API_EXTERN void wasi_##name##_delete(own wasi_##name##_t*);
+#define WASI_DECLARE_OWN(name)                                                 \
+  typedef struct wasi_##name##_t wasi_##name##_t;                              \
+  WASI_API_EXTERN void wasi_##name##_delete(own wasi_##name##_t *);
 
 /**
  * \typedef wasi_config_t
@@ -45,7 +48,7 @@ WASI_DECLARE_OWN(config)
  *
  * The caller is expected to deallocate the returned configuration
  */
-WASI_API_EXTERN own wasi_config_t* wasi_config_new();
+WASI_API_EXTERN own wasi_config_t *wasi_config_new();
 
 /**
  * \brief Sets the argv list for this configuration object.
@@ -55,14 +58,18 @@ WASI_API_EXTERN own wasi_config_t* wasi_config_new();
  *
  * The arguments are copied into the `config` object as part of this function
  * call, so the `argv` pointer only needs to stay alive for this function call.
+ *
+ * This function returns `true` if all arguments were registered successfully,
+ * or `false` if an argument was not valid UTF-8.
  */
-WASI_API_EXTERN void wasi_config_set_argv(wasi_config_t* config, int argc, const char* argv[]);
+WASI_API_EXTERN bool wasi_config_set_argv(wasi_config_t *config, size_t argc,
+                                          const char *argv[]);
 
 /**
  * \brief Indicates that the argv list should be inherited from this process's
  * argv list.
  */
-WASI_API_EXTERN void wasi_config_inherit_argv(wasi_config_t* config);
+WASI_API_EXTERN void wasi_config_inherit_argv(wasi_config_t *config);
 
 /**
  * \brief Sets the list of environment variables available to the WASI instance.
@@ -75,14 +82,20 @@ WASI_API_EXTERN void wasi_config_inherit_argv(wasi_config_t* config);
  * The env vars are copied into the `config` object as part of this function
  * call, so the `names` and `values` pointers only need to stay alive for this
  * function call.
+ *
+ * This function returns `true` if all environment variables were successfully
+ * registered. This returns `false` if environment variables are not valid
+ * UTF-8.
  */
-WASI_API_EXTERN void wasi_config_set_env(wasi_config_t* config, int envc, const char* names[], const char* values[]);
+WASI_API_EXTERN bool wasi_config_set_env(wasi_config_t *config, size_t envc,
+                                         const char *names[],
+                                         const char *values[]);
 
 /**
  * \brief Indicates that the entire environment of the calling process should be
  * inherited by this WASI configuration.
  */
-WASI_API_EXTERN void wasi_config_inherit_env(wasi_config_t* config);
+WASI_API_EXTERN void wasi_config_inherit_env(wasi_config_t *config);
 
 /**
  * \brief Configures standard input to be taken from the specified file.
@@ -93,23 +106,26 @@ WASI_API_EXTERN void wasi_config_inherit_env(wasi_config_t* config);
  * If the stdin location does not exist or it cannot be opened for reading then
  * `false` is returned. Otherwise `true` is returned.
  */
-WASI_API_EXTERN bool wasi_config_set_stdin_file(wasi_config_t* config, const char* path);
+WASI_API_EXTERN bool wasi_config_set_stdin_file(wasi_config_t *config,
+                                                const char *path);
 
 /**
- * \brief Configures standard input to be taken from the specified #wasm_byte_vec_t.
+ * \brief Configures standard input to be taken from the specified
+ * #wasm_byte_vec_t.
  *
  * By default WASI programs have no stdin, but this configures the specified
  * bytes to be used as stdin for this configuration.
  *
  * This function takes ownership of the `binary` argument.
  */
-WASI_API_EXTERN void wasi_config_set_stdin_bytes(wasi_config_t* config, wasm_byte_vec_t* binary);
+WASI_API_EXTERN void wasi_config_set_stdin_bytes(wasi_config_t *config,
+                                                 wasm_byte_vec_t *binary);
 
 /**
  * \brief Configures this process's own stdin stream to be used as stdin for
  * this WASI configuration.
  */
-WASI_API_EXTERN void wasi_config_inherit_stdin(wasi_config_t* config);
+WASI_API_EXTERN void wasi_config_inherit_stdin(wasi_config_t *config);
 
 /**
  * \brief Configures standard output to be written to the specified file.
@@ -120,13 +136,14 @@ WASI_API_EXTERN void wasi_config_inherit_stdin(wasi_config_t* config);
  * If the stdout location could not be opened for writing then `false` is
  * returned. Otherwise `true` is returned.
  */
-WASI_API_EXTERN bool wasi_config_set_stdout_file(wasi_config_t* config, const char* path);
+WASI_API_EXTERN bool wasi_config_set_stdout_file(wasi_config_t *config,
+                                                 const char *path);
 
 /**
  * \brief Configures this process's own stdout stream to be used as stdout for
  * this WASI configuration.
  */
-WASI_API_EXTERN void wasi_config_inherit_stdout(wasi_config_t* config);
+WASI_API_EXTERN void wasi_config_inherit_stdout(wasi_config_t *config);
 
 /**
  * \brief Configures standard output to be written to the specified file.
@@ -137,43 +154,36 @@ WASI_API_EXTERN void wasi_config_inherit_stdout(wasi_config_t* config);
  * If the stderr location could not be opened for writing then `false` is
  * returned. Otherwise `true` is returned.
  */
-WASI_API_EXTERN bool wasi_config_set_stderr_file(wasi_config_t* config, const char* path);
+WASI_API_EXTERN bool wasi_config_set_stderr_file(wasi_config_t *config,
+                                                 const char *path);
 
 /**
  * \brief Configures this process's own stderr stream to be used as stderr for
  * this WASI configuration.
  */
-WASI_API_EXTERN void wasi_config_inherit_stderr(wasi_config_t* config);
+WASI_API_EXTERN void wasi_config_inherit_stderr(wasi_config_t *config);
 
 /**
  * \brief Configures a "preopened directory" to be available to WASI APIs.
  *
  * By default WASI programs do not have access to anything on the filesystem.
  * This API can be used to grant WASI programs access to a directory on the
- * filesystem, but only that directory (its whole contents but nothing above it).
+ * filesystem, but only that directory (its whole contents but nothing above
+ * it).
  *
  * The `path` argument here is a path name on the host filesystem, and
  * `guest_path` is the name by which it will be known in wasm.
  */
-WASI_API_EXTERN bool wasi_config_preopen_dir(wasi_config_t* config, const char* path, const char* guest_path);
-
-/**
- * \brief Configures a "preopened" listen socket to be available to WASI APIs.
- *
- * By default WASI programs do not have access to open up network sockets on
- * the host. This API can be used to grant WASI programs access to a network
- * socket file descriptor on the host.
- *
- * The fd_num argument is the number of the file descriptor by which it will be
- * known in WASM and the host_port is the IP address and port (e.g.
- * "127.0.0.1:8080") requested to listen on.
- */
-WASI_API_EXTERN bool wasi_config_preopen_socket(wasi_config_t* config, uint32_t fd_num, const char* host_port);
+WASI_API_EXTERN bool wasi_config_preopen_dir(wasi_config_t *config,
+                                             const char *path,
+                                             const char *guest_path);
 
 #undef own
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
-#endif  // #ifdef WASI_H
+#endif // WASMTIME_FEATURE_WASI
+
+#endif // #ifdef WASI_H
diff --git a/crates/c-api/include/wasm.h b/crates/c-api/include/wasm.h
new file mode 100644
index 000000000000..c8b3cb7d31f4
--- /dev/null
+++ b/crates/c-api/include/wasm.h
@@ -0,0 +1,729 @@
+// Wasmtime-vendored copy of this header file as present in upstream:
+// <https://github.com/WebAssembly/wasm-c-api/blob/2ce1367c9d1271c83fb63bef26d896a2f290cd23/include/wasm.h>
+//
+// Wasmtime maintainers can update this vendored copy in-tree with the
+// ./ci/vendor-c-api-headers.sh shell script.
+//
+// WebAssembly C API
+
+#ifndef WASM_H
+#define WASM_H
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+#include <assert.h>
+
+#ifndef WASM_API_EXTERN
+#if defined(_WIN32) && !defined(__MINGW32__) && !defined(LIBWASM_STATIC)
+#define WASM_API_EXTERN __declspec(dllimport)
+#else
+#define WASM_API_EXTERN
+#endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// Auxiliaries
+
+// Machine types
+
+inline void assertions(void) {
+  static_assert(sizeof(float) == sizeof(uint32_t), "incompatible float type");
+  static_assert(sizeof(double) == sizeof(uint64_t), "incompatible double type");
+  static_assert(sizeof(intptr_t) == sizeof(uint32_t) ||
+                sizeof(intptr_t) == sizeof(uint64_t),
+                "incompatible pointer type");
+}
+
+typedef char byte_t;
+typedef float float32_t;
+typedef double float64_t;
+
+
+// Ownership
+
+#define own
+
+// The qualifier `own` is used to indicate ownership of data in this API.
+// It is intended to be interpreted similar to a `const` qualifier:
+//
+// - `own wasm_xxx_t*` owns the pointed-to data
+// - `own wasm_xxx_t` distributes to all fields of a struct or union `xxx`
+// - `own wasm_xxx_vec_t` owns the vector as well as its elements(!)
+// - an `own` function parameter passes ownership from caller to callee
+// - an `own` function result passes ownership from callee to caller
+// - an exception are `own` pointer parameters named `out`, which are copy-back
+//   output parameters passing back ownership from callee to caller
+//
+// Own data is created by `wasm_xxx_new` functions and some others.
+// It must be released with the corresponding `wasm_xxx_delete` function.
+//
+// Deleting a reference does not necessarily delete the underlying object,
+// it merely indicates that this owner no longer uses it.
+//
+// For vectors, `const wasm_xxx_vec_t` is used informally to indicate that
+// neither the vector nor its elements should be modified.
+// TODO: introduce proper `wasm_xxx_const_vec_t`?
+
+
+#define WASM_DECLARE_OWN(name) \
+  typedef struct wasm_##name##_t wasm_##name##_t; \
+  \
+  WASM_API_EXTERN void wasm_##name##_delete(own wasm_##name##_t*);
+
+
+// Vectors
+
+#define WASM_DECLARE_VEC(name, ptr_or_none) \
+  typedef struct wasm_##name##_vec_t { \
+    size_t size; \
+    wasm_##name##_t ptr_or_none* data; \
+  } wasm_##name##_vec_t; \
+  \
+  WASM_API_EXTERN void wasm_##name##_vec_new_empty(own wasm_##name##_vec_t* out); \
+  WASM_API_EXTERN void wasm_##name##_vec_new_uninitialized( \
+    own wasm_##name##_vec_t* out, size_t); \
+  WASM_API_EXTERN void wasm_##name##_vec_new( \
+    own wasm_##name##_vec_t* out, \
+    size_t, own wasm_##name##_t ptr_or_none const[]); \
+  WASM_API_EXTERN void wasm_##name##_vec_copy( \
+    own wasm_##name##_vec_t* out, const wasm_##name##_vec_t*); \
+  WASM_API_EXTERN void wasm_##name##_vec_delete(own wasm_##name##_vec_t*);
+
+
+// Byte vectors
+
+typedef byte_t wasm_byte_t;
+WASM_DECLARE_VEC(byte, )
+
+typedef wasm_byte_vec_t wasm_name_t;
+
+#define wasm_name wasm_byte_vec
+#define wasm_name_new wasm_byte_vec_new
+#define wasm_name_new_empty wasm_byte_vec_new_empty
+#define wasm_name_new_new_uninitialized wasm_byte_vec_new_uninitialized
+#define wasm_name_copy wasm_byte_vec_copy
+#define wasm_name_delete wasm_byte_vec_delete
+
+static inline void wasm_name_new_from_string(
+  own wasm_name_t* out, const char* s
+) {
+  wasm_name_new(out, strlen(s), s);
+}
+
+static inline void wasm_name_new_from_string_nt(
+  own wasm_name_t* out, const char* s
+) {
+  wasm_name_new(out, strlen(s) + 1, s);
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Runtime Environment
+
+// Configuration
+
+WASM_DECLARE_OWN(config)
+
+WASM_API_EXTERN own wasm_config_t* wasm_config_new(void);
+
+// Embedders may provide custom functions for manipulating configs.
+
+
+// Engine
+
+WASM_DECLARE_OWN(engine)
+
+WASM_API_EXTERN own wasm_engine_t* wasm_engine_new(void);
+WASM_API_EXTERN own wasm_engine_t* wasm_engine_new_with_config(own wasm_config_t*);
+
+
+// Store
+
+WASM_DECLARE_OWN(store)
+
+WASM_API_EXTERN own wasm_store_t* wasm_store_new(wasm_engine_t*);
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Type Representations
+
+// Type attributes
+
+typedef uint8_t wasm_mutability_t;
+enum wasm_mutability_enum {
+  WASM_CONST,
+  WASM_VAR,
+};
+
+typedef struct wasm_limits_t {
+  uint32_t min;
+  uint32_t max;
+} wasm_limits_t;
+
+static const uint32_t wasm_limits_max_default = 0xffffffff;
+
+
+// Generic
+
+#define WASM_DECLARE_TYPE(name) \
+  WASM_DECLARE_OWN(name) \
+  WASM_DECLARE_VEC(name, *) \
+  \
+  WASM_API_EXTERN own wasm_##name##_t* wasm_##name##_copy(const wasm_##name##_t*);
+
+
+// Value Types
+
+WASM_DECLARE_TYPE(valtype)
+
+typedef uint8_t wasm_valkind_t;
+enum wasm_valkind_enum {
+  WASM_I32,
+  WASM_I64,
+  WASM_F32,
+  WASM_F64,
+  WASM_EXTERNREF = 128,
+  WASM_FUNCREF,
+};
+
+WASM_API_EXTERN own wasm_valtype_t* wasm_valtype_new(wasm_valkind_t);
+
+WASM_API_EXTERN wasm_valkind_t wasm_valtype_kind(const wasm_valtype_t*);
+
+static inline bool wasm_valkind_is_num(wasm_valkind_t k) {
+  return k < WASM_EXTERNREF;
+}
+static inline bool wasm_valkind_is_ref(wasm_valkind_t k) {
+  return k >= WASM_EXTERNREF;
+}
+
+static inline bool wasm_valtype_is_num(const wasm_valtype_t* t) {
+  return wasm_valkind_is_num(wasm_valtype_kind(t));
+}
+static inline bool wasm_valtype_is_ref(const wasm_valtype_t* t) {
+  return wasm_valkind_is_ref(wasm_valtype_kind(t));
+}
+
+
+// Function Types
+
+WASM_DECLARE_TYPE(functype)
+
+WASM_API_EXTERN own wasm_functype_t* wasm_functype_new(
+  own wasm_valtype_vec_t* params, own wasm_valtype_vec_t* results);
+
+WASM_API_EXTERN const wasm_valtype_vec_t* wasm_functype_params(const wasm_functype_t*);
+WASM_API_EXTERN const wasm_valtype_vec_t* wasm_functype_results(const wasm_functype_t*);
+
+
+// Global Types
+
+WASM_DECLARE_TYPE(globaltype)
+
+WASM_API_EXTERN own wasm_globaltype_t* wasm_globaltype_new(
+  own wasm_valtype_t*, wasm_mutability_t);
+
+WASM_API_EXTERN const wasm_valtype_t* wasm_globaltype_content(const wasm_globaltype_t*);
+WASM_API_EXTERN wasm_mutability_t wasm_globaltype_mutability(const wasm_globaltype_t*);
+
+
+// Table Types
+
+WASM_DECLARE_TYPE(tabletype)
+
+WASM_API_EXTERN own wasm_tabletype_t* wasm_tabletype_new(
+  own wasm_valtype_t*, const wasm_limits_t*);
+
+WASM_API_EXTERN const wasm_valtype_t* wasm_tabletype_element(const wasm_tabletype_t*);
+WASM_API_EXTERN const wasm_limits_t* wasm_tabletype_limits(const wasm_tabletype_t*);
+
+
+// Memory Types
+
+WASM_DECLARE_TYPE(memorytype)
+
+WASM_API_EXTERN own wasm_memorytype_t* wasm_memorytype_new(const wasm_limits_t*);
+
+WASM_API_EXTERN const wasm_limits_t* wasm_memorytype_limits(const wasm_memorytype_t*);
+
+
+// Extern Types
+
+WASM_DECLARE_TYPE(externtype)
+
+typedef uint8_t wasm_externkind_t;
+enum wasm_externkind_enum {
+  WASM_EXTERN_FUNC,
+  WASM_EXTERN_GLOBAL,
+  WASM_EXTERN_TABLE,
+  WASM_EXTERN_MEMORY,
+};
+
+WASM_API_EXTERN wasm_externkind_t wasm_externtype_kind(const wasm_externtype_t*);
+
+WASM_API_EXTERN wasm_externtype_t* wasm_functype_as_externtype(wasm_functype_t*);
+WASM_API_EXTERN wasm_externtype_t* wasm_globaltype_as_externtype(wasm_globaltype_t*);
+WASM_API_EXTERN wasm_externtype_t* wasm_tabletype_as_externtype(wasm_tabletype_t*);
+WASM_API_EXTERN wasm_externtype_t* wasm_memorytype_as_externtype(wasm_memorytype_t*);
+
+WASM_API_EXTERN wasm_functype_t* wasm_externtype_as_functype(wasm_externtype_t*);
+WASM_API_EXTERN wasm_globaltype_t* wasm_externtype_as_globaltype(wasm_externtype_t*);
+WASM_API_EXTERN wasm_tabletype_t* wasm_externtype_as_tabletype(wasm_externtype_t*);
+WASM_API_EXTERN wasm_memorytype_t* wasm_externtype_as_memorytype(wasm_externtype_t*);
+
+WASM_API_EXTERN const wasm_externtype_t* wasm_functype_as_externtype_const(const wasm_functype_t*);
+WASM_API_EXTERN const wasm_externtype_t* wasm_globaltype_as_externtype_const(const wasm_globaltype_t*);
+WASM_API_EXTERN const wasm_externtype_t* wasm_tabletype_as_externtype_const(const wasm_tabletype_t*);
+WASM_API_EXTERN const wasm_externtype_t* wasm_memorytype_as_externtype_const(const wasm_memorytype_t*);
+
+WASM_API_EXTERN const wasm_functype_t* wasm_externtype_as_functype_const(const wasm_externtype_t*);
+WASM_API_EXTERN const wasm_globaltype_t* wasm_externtype_as_globaltype_const(const wasm_externtype_t*);
+WASM_API_EXTERN const wasm_tabletype_t* wasm_externtype_as_tabletype_const(const wasm_externtype_t*);
+WASM_API_EXTERN const wasm_memorytype_t* wasm_externtype_as_memorytype_const(const wasm_externtype_t*);
+
+
+// Import Types
+
+WASM_DECLARE_TYPE(importtype)
+
+WASM_API_EXTERN own wasm_importtype_t* wasm_importtype_new(
+  own wasm_name_t* module, own wasm_name_t* name, own wasm_externtype_t*);
+
+WASM_API_EXTERN const wasm_name_t* wasm_importtype_module(const wasm_importtype_t*);
+WASM_API_EXTERN const wasm_name_t* wasm_importtype_name(const wasm_importtype_t*);
+WASM_API_EXTERN const wasm_externtype_t* wasm_importtype_type(const wasm_importtype_t*);
+
+
+// Export Types
+
+WASM_DECLARE_TYPE(exporttype)
+
+WASM_API_EXTERN own wasm_exporttype_t* wasm_exporttype_new(
+  own wasm_name_t*, own wasm_externtype_t*);
+
+WASM_API_EXTERN const wasm_name_t* wasm_exporttype_name(const wasm_exporttype_t*);
+WASM_API_EXTERN const wasm_externtype_t* wasm_exporttype_type(const wasm_exporttype_t*);
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Runtime Objects
+
+// Values
+
+struct wasm_ref_t;
+
+typedef struct wasm_val_t {
+  wasm_valkind_t kind;
+  union {
+    int32_t i32;
+    int64_t i64;
+    float32_t f32;
+    float64_t f64;
+    struct wasm_ref_t* ref;
+  } of;
+} wasm_val_t;
+
+WASM_API_EXTERN void wasm_val_delete(own wasm_val_t* v);
+WASM_API_EXTERN void wasm_val_copy(own wasm_val_t* out, const wasm_val_t*);
+
+WASM_DECLARE_VEC(val, )
+
+
+// References
+
+#define WASM_DECLARE_REF_BASE(name) \
+  WASM_DECLARE_OWN(name) \
+  \
+  WASM_API_EXTERN own wasm_##name##_t* wasm_##name##_copy(const wasm_##name##_t*); \
+  WASM_API_EXTERN bool wasm_##name##_same(const wasm_##name##_t*, const wasm_##name##_t*); \
+  \
+  WASM_API_EXTERN void* wasm_##name##_get_host_info(const wasm_##name##_t*); \
+  WASM_API_EXTERN void wasm_##name##_set_host_info(wasm_##name##_t*, void*); \
+  WASM_API_EXTERN void wasm_##name##_set_host_info_with_finalizer( \
+    wasm_##name##_t*, void*, void (*)(void*));
+
+#define WASM_DECLARE_REF(name) \
+  WASM_DECLARE_REF_BASE(name) \
+  \
+  WASM_API_EXTERN wasm_ref_t* wasm_##name##_as_ref(wasm_##name##_t*); \
+  WASM_API_EXTERN wasm_##name##_t* wasm_ref_as_##name(wasm_ref_t*); \
+  WASM_API_EXTERN const wasm_ref_t* wasm_##name##_as_ref_const(const wasm_##name##_t*); \
+  WASM_API_EXTERN const wasm_##name##_t* wasm_ref_as_##name##_const(const wasm_ref_t*);
+
+#define WASM_DECLARE_SHARABLE_REF(name) \
+  WASM_DECLARE_REF(name) \
+  WASM_DECLARE_OWN(shared_##name) \
+  \
+  WASM_API_EXTERN own wasm_shared_##name##_t* wasm_##name##_share(const wasm_##name##_t*); \
+  WASM_API_EXTERN own wasm_##name##_t* wasm_##name##_obtain(wasm_store_t*, const wasm_shared_##name##_t*);
+
+
+WASM_DECLARE_REF_BASE(ref)
+
+
+// Frames
+
+WASM_DECLARE_OWN(frame)
+WASM_DECLARE_VEC(frame, *)
+WASM_API_EXTERN own wasm_frame_t* wasm_frame_copy(const wasm_frame_t*);
+
+WASM_API_EXTERN struct wasm_instance_t* wasm_frame_instance(const wasm_frame_t*);
+WASM_API_EXTERN uint32_t wasm_frame_func_index(const wasm_frame_t*);
+WASM_API_EXTERN size_t wasm_frame_func_offset(const wasm_frame_t*);
+WASM_API_EXTERN size_t wasm_frame_module_offset(const wasm_frame_t*);
+
+
+// Traps
+
+typedef wasm_name_t wasm_message_t;  // null terminated
+
+WASM_DECLARE_REF(trap)
+
+WASM_API_EXTERN own wasm_trap_t* wasm_trap_new(wasm_store_t* store, const wasm_message_t*);
+
+WASM_API_EXTERN void wasm_trap_message(const wasm_trap_t*, own wasm_message_t* out);
+WASM_API_EXTERN own wasm_frame_t* wasm_trap_origin(const wasm_trap_t*);
+WASM_API_EXTERN void wasm_trap_trace(const wasm_trap_t*, own wasm_frame_vec_t* out);
+
+
+// Foreign Objects
+
+WASM_DECLARE_REF(foreign)
+
+WASM_API_EXTERN own wasm_foreign_t* wasm_foreign_new(wasm_store_t*);
+
+
+// Modules
+
+WASM_DECLARE_SHARABLE_REF(module)
+
+WASM_API_EXTERN own wasm_module_t* wasm_module_new(
+  wasm_store_t*, const wasm_byte_vec_t* binary);
+
+WASM_API_EXTERN bool wasm_module_validate(wasm_store_t*, const wasm_byte_vec_t* binary);
+
+WASM_API_EXTERN void wasm_module_imports(const wasm_module_t*, own wasm_importtype_vec_t* out);
+WASM_API_EXTERN void wasm_module_exports(const wasm_module_t*, own wasm_exporttype_vec_t* out);
+
+WASM_API_EXTERN void wasm_module_serialize(const wasm_module_t*, own wasm_byte_vec_t* out);
+WASM_API_EXTERN own wasm_module_t* wasm_module_deserialize(wasm_store_t*, const wasm_byte_vec_t*);
+
+
+// Function Instances
+
+WASM_DECLARE_REF(func)
+
+typedef own wasm_trap_t* (*wasm_func_callback_t)(
+  const wasm_val_vec_t* args, own wasm_val_vec_t* results);
+typedef own wasm_trap_t* (*wasm_func_callback_with_env_t)(
+  void* env, const wasm_val_vec_t* args, wasm_val_vec_t* results);
+
+WASM_API_EXTERN own wasm_func_t* wasm_func_new(
+  wasm_store_t*, const wasm_functype_t*, wasm_func_callback_t);
+WASM_API_EXTERN own wasm_func_t* wasm_func_new_with_env(
+  wasm_store_t*, const wasm_functype_t* type, wasm_func_callback_with_env_t,
+  void* env, void (*finalizer)(void*));
+
+WASM_API_EXTERN own wasm_functype_t* wasm_func_type(const wasm_func_t*);
+WASM_API_EXTERN size_t wasm_func_param_arity(const wasm_func_t*);
+WASM_API_EXTERN size_t wasm_func_result_arity(const wasm_func_t*);
+
+WASM_API_EXTERN own wasm_trap_t* wasm_func_call(
+  const wasm_func_t*, const wasm_val_vec_t* args, wasm_val_vec_t* results);
+
+
+// Global Instances
+
+WASM_DECLARE_REF(global)
+
+WASM_API_EXTERN own wasm_global_t* wasm_global_new(
+  wasm_store_t*, const wasm_globaltype_t*, const wasm_val_t*);
+
+WASM_API_EXTERN own wasm_globaltype_t* wasm_global_type(const wasm_global_t*);
+
+WASM_API_EXTERN void wasm_global_get(const wasm_global_t*, own wasm_val_t* out);
+WASM_API_EXTERN void wasm_global_set(wasm_global_t*, const wasm_val_t*);
+
+
+// Table Instances
+
+WASM_DECLARE_REF(table)
+
+typedef uint32_t wasm_table_size_t;
+
+WASM_API_EXTERN own wasm_table_t* wasm_table_new(
+  wasm_store_t*, const wasm_tabletype_t*, wasm_ref_t* init);
+
+WASM_API_EXTERN own wasm_tabletype_t* wasm_table_type(const wasm_table_t*);
+
+WASM_API_EXTERN own wasm_ref_t* wasm_table_get(const wasm_table_t*, wasm_table_size_t index);
+WASM_API_EXTERN bool wasm_table_set(wasm_table_t*, wasm_table_size_t index, wasm_ref_t*);
+
+WASM_API_EXTERN wasm_table_size_t wasm_table_size(const wasm_table_t*);
+WASM_API_EXTERN bool wasm_table_grow(wasm_table_t*, wasm_table_size_t delta, wasm_ref_t* init);
+
+
+// Memory Instances
+
+WASM_DECLARE_REF(memory)
+
+typedef uint32_t wasm_memory_pages_t;
+
+static const size_t MEMORY_PAGE_SIZE = 0x10000;
+
+WASM_API_EXTERN own wasm_memory_t* wasm_memory_new(wasm_store_t*, const wasm_memorytype_t*);
+
+WASM_API_EXTERN own wasm_memorytype_t* wasm_memory_type(const wasm_memory_t*);
+
+WASM_API_EXTERN byte_t* wasm_memory_data(wasm_memory_t*);
+WASM_API_EXTERN size_t wasm_memory_data_size(const wasm_memory_t*);
+
+WASM_API_EXTERN wasm_memory_pages_t wasm_memory_size(const wasm_memory_t*);
+WASM_API_EXTERN bool wasm_memory_grow(wasm_memory_t*, wasm_memory_pages_t delta);
+
+
+// Externals
+
+WASM_DECLARE_REF(extern)
+WASM_DECLARE_VEC(extern, *)
+
+WASM_API_EXTERN wasm_externkind_t wasm_extern_kind(const wasm_extern_t*);
+WASM_API_EXTERN own wasm_externtype_t* wasm_extern_type(const wasm_extern_t*);
+
+WASM_API_EXTERN wasm_extern_t* wasm_func_as_extern(wasm_func_t*);
+WASM_API_EXTERN wasm_extern_t* wasm_global_as_extern(wasm_global_t*);
+WASM_API_EXTERN wasm_extern_t* wasm_table_as_extern(wasm_table_t*);
+WASM_API_EXTERN wasm_extern_t* wasm_memory_as_extern(wasm_memory_t*);
+
+WASM_API_EXTERN wasm_func_t* wasm_extern_as_func(wasm_extern_t*);
+WASM_API_EXTERN wasm_global_t* wasm_extern_as_global(wasm_extern_t*);
+WASM_API_EXTERN wasm_table_t* wasm_extern_as_table(wasm_extern_t*);
+WASM_API_EXTERN wasm_memory_t* wasm_extern_as_memory(wasm_extern_t*);
+
+WASM_API_EXTERN const wasm_extern_t* wasm_func_as_extern_const(const wasm_func_t*);
+WASM_API_EXTERN const wasm_extern_t* wasm_global_as_extern_const(const wasm_global_t*);
+WASM_API_EXTERN const wasm_extern_t* wasm_table_as_extern_const(const wasm_table_t*);
+WASM_API_EXTERN const wasm_extern_t* wasm_memory_as_extern_const(const wasm_memory_t*);
+
+WASM_API_EXTERN const wasm_func_t* wasm_extern_as_func_const(const wasm_extern_t*);
+WASM_API_EXTERN const wasm_global_t* wasm_extern_as_global_const(const wasm_extern_t*);
+WASM_API_EXTERN const wasm_table_t* wasm_extern_as_table_const(const wasm_extern_t*);
+WASM_API_EXTERN const wasm_memory_t* wasm_extern_as_memory_const(const wasm_extern_t*);
+
+
+// Module Instances
+
+WASM_DECLARE_REF(instance)
+
+WASM_API_EXTERN own wasm_instance_t* wasm_instance_new(
+  wasm_store_t*, const wasm_module_t*, const wasm_extern_vec_t* imports,
+  own wasm_trap_t**
+);
+
+WASM_API_EXTERN void wasm_instance_exports(const wasm_instance_t*, own wasm_extern_vec_t* out);
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Convenience
+
+// Vectors
+
+#define WASM_EMPTY_VEC {0, NULL}
+#define WASM_ARRAY_VEC(array) {sizeof(array)/sizeof(*(array)), array}
+
+
+// Value Type construction short-hands
+
+static inline own wasm_valtype_t* wasm_valtype_new_i32(void) {
+  return wasm_valtype_new(WASM_I32);
+}
+static inline own wasm_valtype_t* wasm_valtype_new_i64(void) {
+  return wasm_valtype_new(WASM_I64);
+}
+static inline own wasm_valtype_t* wasm_valtype_new_f32(void) {
+  return wasm_valtype_new(WASM_F32);
+}
+static inline own wasm_valtype_t* wasm_valtype_new_f64(void) {
+  return wasm_valtype_new(WASM_F64);
+}
+
+static inline own wasm_valtype_t* wasm_valtype_new_externref(void) {
+  return wasm_valtype_new(WASM_EXTERNREF);
+}
+static inline own wasm_valtype_t* wasm_valtype_new_funcref(void) {
+  return wasm_valtype_new(WASM_FUNCREF);
+}
+
+
+// Function Types construction short-hands
+
+static inline own wasm_functype_t* wasm_functype_new_0_0(void) {
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new_empty(&params);
+  wasm_valtype_vec_new_empty(&results);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_1_0(
+  own wasm_valtype_t* p
+) {
+  wasm_valtype_t* ps[1] = {p};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new(&params, 1, ps);
+  wasm_valtype_vec_new_empty(&results);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_2_0(
+  own wasm_valtype_t* p1, own wasm_valtype_t* p2
+) {
+  wasm_valtype_t* ps[2] = {p1, p2};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new(&params, 2, ps);
+  wasm_valtype_vec_new_empty(&results);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_3_0(
+  own wasm_valtype_t* p1, own wasm_valtype_t* p2, own wasm_valtype_t* p3
+) {
+  wasm_valtype_t* ps[3] = {p1, p2, p3};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new(&params, 3, ps);
+  wasm_valtype_vec_new_empty(&results);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_0_1(
+  own wasm_valtype_t* r
+) {
+  wasm_valtype_t* rs[1] = {r};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new_empty(&params);
+  wasm_valtype_vec_new(&results, 1, rs);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_1_1(
+  own wasm_valtype_t* p, own wasm_valtype_t* r
+) {
+  wasm_valtype_t* ps[1] = {p};
+  wasm_valtype_t* rs[1] = {r};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new(&params, 1, ps);
+  wasm_valtype_vec_new(&results, 1, rs);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_2_1(
+  own wasm_valtype_t* p1, own wasm_valtype_t* p2, own wasm_valtype_t* r
+) {
+  wasm_valtype_t* ps[2] = {p1, p2};
+  wasm_valtype_t* rs[1] = {r};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new(&params, 2, ps);
+  wasm_valtype_vec_new(&results, 1, rs);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_3_1(
+  own wasm_valtype_t* p1, own wasm_valtype_t* p2, own wasm_valtype_t* p3,
+  own wasm_valtype_t* r
+) {
+  wasm_valtype_t* ps[3] = {p1, p2, p3};
+  wasm_valtype_t* rs[1] = {r};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new(&params, 3, ps);
+  wasm_valtype_vec_new(&results, 1, rs);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_0_2(
+  own wasm_valtype_t* r1, own wasm_valtype_t* r2
+) {
+  wasm_valtype_t* rs[2] = {r1, r2};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new_empty(&params);
+  wasm_valtype_vec_new(&results, 2, rs);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_1_2(
+  own wasm_valtype_t* p, own wasm_valtype_t* r1, own wasm_valtype_t* r2
+) {
+  wasm_valtype_t* ps[1] = {p};
+  wasm_valtype_t* rs[2] = {r1, r2};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new(&params, 1, ps);
+  wasm_valtype_vec_new(&results, 2, rs);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_2_2(
+  own wasm_valtype_t* p1, own wasm_valtype_t* p2,
+  own wasm_valtype_t* r1, own wasm_valtype_t* r2
+) {
+  wasm_valtype_t* ps[2] = {p1, p2};
+  wasm_valtype_t* rs[2] = {r1, r2};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new(&params, 2, ps);
+  wasm_valtype_vec_new(&results, 2, rs);
+  return wasm_functype_new(&params, &results);
+}
+
+static inline own wasm_functype_t* wasm_functype_new_3_2(
+  own wasm_valtype_t* p1, own wasm_valtype_t* p2, own wasm_valtype_t* p3,
+  own wasm_valtype_t* r1, own wasm_valtype_t* r2
+) {
+  wasm_valtype_t* ps[3] = {p1, p2, p3};
+  wasm_valtype_t* rs[2] = {r1, r2};
+  wasm_valtype_vec_t params, results;
+  wasm_valtype_vec_new(&params, 3, ps);
+  wasm_valtype_vec_new(&results, 2, rs);
+  return wasm_functype_new(&params, &results);
+}
+
+
+// Value construction short-hands
+
+static inline void wasm_val_init_ptr(own wasm_val_t* out, void* p) {
+#if UINTPTR_MAX == UINT32_MAX
+  out->kind = WASM_I32;
+  out->of.i32 = (intptr_t)p;
+#elif UINTPTR_MAX == UINT64_MAX
+  out->kind = WASM_I64;
+  out->of.i64 = (intptr_t)p;
+#endif
+}
+
+static inline void* wasm_val_ptr(const wasm_val_t* val) {
+#if UINTPTR_MAX == UINT32_MAX
+  return (void*)(intptr_t)val->of.i32;
+#elif UINTPTR_MAX == UINT64_MAX
+  return (void*)(intptr_t)val->of.i64;
+#endif
+}
+
+#define WASM_I32_VAL(i) {.kind = WASM_I32, .of = {.i32 = i}}
+#define WASM_I64_VAL(i) {.kind = WASM_I64, .of = {.i64 = i}}
+#define WASM_F32_VAL(z) {.kind = WASM_F32, .of = {.f32 = z}}
+#define WASM_F64_VAL(z) {.kind = WASM_F64, .of = {.f64 = z}}
+#define WASM_REF_VAL(r) {.kind = WASM_EXTERNREF, .of = {.ref = r}}
+#define WASM_INIT_VAL {.kind = WASM_EXTERNREF, .of = {.ref = NULL}}
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+#undef own
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // #ifdef WASM_H
diff --git a/crates/c-api/include/wasm.hh b/crates/c-api/include/wasm.hh
new file mode 100644
index 000000000000..e03408241b73
--- /dev/null
+++ b/crates/c-api/include/wasm.hh
@@ -0,0 +1,849 @@
+// Wasmtime-vendored copy of this header file as present in upstream:
+// <https://github.com/WebAssembly/wasm-c-api/blob/2ce1367c9d1271c83fb63bef26d896a2f290cd23/include/wasm.hh>
+//
+// Wasmtime maintainers can update this vendored copy in-tree with the
+// ./ci/vendor-c-api-headers.sh shell script.
+//
+// WebAssembly C++ API
+
+#ifndef WASM_HH
+#define WASM_HH
+
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <limits>
+#include <string>
+
+#ifndef WASM_API_EXTERN
+#if defined(_WIN32) && !defined(__MINGW32__) && !defined(LIBWASM_STATIC)
+#define WASM_API_EXTERN __declspec(dllimport)
+#else
+#define WASM_API_EXTERN
+#endif
+#endif
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Auxiliaries
+
+// Machine types
+
+static_assert(sizeof(float) == sizeof(int32_t), "incompatible float type");
+static_assert(sizeof(double) == sizeof(int64_t), "incompatible double type");
+static_assert(sizeof(intptr_t) == sizeof(int32_t) ||
+              sizeof(intptr_t) == sizeof(int64_t), "incompatible pointer type");
+
+using byte_t = char;
+using float32_t = float;
+using float64_t = double;
+
+
+namespace wasm {
+
+// Vectors
+
+template<class T>
+class vec {
+  static const size_t invalid_size = SIZE_MAX;
+
+  size_t size_;
+  std::unique_ptr<T[]> data_;
+
+#ifdef WASM_API_DEBUG
+  WASM_API_EXTERN void make_data();
+  WASM_API_EXTERN void free_data();
+#else
+  void make_data() {}
+  void free_data() {}
+#endif
+
+  vec(size_t size) : vec(size, size ? new(std::nothrow) T[size] : nullptr) {
+    make_data();
+  }
+
+  vec(size_t size, T* data) : size_(size), data_(data) {
+    assert(!!size_ == !!data_ || size_ == invalid_size);
+  }
+
+public:
+  using elem_type = T;
+
+  vec(vec<T>&& that) : vec(that.size_, that.data_.release()) {
+    that.size_ = invalid_size;
+  }
+
+  ~vec() {
+    free_data();
+  }
+
+  operator bool() const {
+    return bool(size_ != invalid_size);
+  }
+
+  auto size() const -> size_t {
+    return size_;
+  }
+
+  auto get() const -> const T* {
+    return data_.get();
+  }
+
+  auto get() -> T* {
+    return data_.get();
+  }
+
+  auto release() -> T* {
+    size_ = invalid_size;
+    return data_.release();
+  }
+
+  void reset() {
+    free_data();
+    size_ = invalid_size;
+    data_.reset();
+  }
+
+  void reset(vec& that) {
+    free_data();
+    size_ = that.size_;
+    data_.reset(that.data_.release());
+    that.size_ = invalid_size;
+  }
+
+  auto operator=(vec&& that) -> vec& {
+    reset(that);
+    return *this;
+  }
+
+  auto operator[](size_t i) -> T& {
+    assert(i < size_);
+    return data_[i];
+  }
+
+  auto operator[](size_t i) const -> const T& {
+    assert(i < size_);
+    return data_[i];
+  }
+
+  auto copy() const -> vec {
+    auto v = vec(size_);
+    if (v) for (size_t i = 0; i < size_; ++i) v.data_[i] = data_[i];
+    return v;
+  }
+
+  // TODO: This can't be used for e.g. vec<Val>
+  auto deep_copy() const -> vec {
+    auto v = vec(size_);
+    if (v) for (size_t i = 0; i < size_; ++i) v.data_[i] = data_[i]->copy();
+    return v;
+  }
+
+  static auto make_uninitialized(size_t size = 0) -> vec {
+    return vec(size);
+  }
+
+  static auto make(size_t size, T init[]) -> vec {
+    auto v = vec(size);
+    if (v) for (size_t i = 0; i < size; ++i) v.data_[i] = std::move(init[i]);
+    return v;
+  }
+
+  static auto make(std::string s) -> vec<char> {
+    auto v = vec(s.length());
+    if (v) std::strncpy(v.get(), s.data(), s.length());
+    return v;
+  }
+
+  static auto make_nt(std::string s) -> vec<char> {
+    auto v = vec(s.length() + 1);
+    if (v) std::strcpy(v.get(), s.data());
+    return v;
+  }
+
+  // TODO(mvsc): MVSC requires this special case:
+  static auto make() -> vec {
+    return vec(0);
+  }
+
+  template<class... Ts>
+  static auto make(Ts&&... args) -> vec {
+    T data[] = { std::forward<Ts>(args)... };
+    return make(sizeof...(Ts), data);
+  }
+
+  static auto adopt(size_t size, T data[]) -> vec {
+    return vec(size, data);
+  }
+
+  static auto invalid() -> vec {
+    return vec(invalid_size, nullptr);
+  }
+};
+
+
+// Ownership
+
+class destroyer {
+public:
+  template <typename T>
+  void operator()(T* ptr) {
+    ptr->destroy();
+  }
+};
+
+template<class T> using own = std::unique_ptr<T, destroyer>;
+template<class T> using ownvec = vec<own<T>>;
+
+template<class T> own<T> make_own(T* ptr) {
+  return own<T>(ptr);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Runtime Environment
+
+// Configuration
+
+class WASM_API_EXTERN Config {
+  friend class destroyer;
+  void destroy();
+
+protected:
+  Config() = default;
+  ~Config() = default;
+
+public:
+  static auto make() -> own<Config>;
+
+  // Implementations may provide custom methods for manipulating Configs.
+};
+
+
+// Engine
+
+class WASM_API_EXTERN Engine {
+  friend class destroyer;
+  void destroy();
+
+protected:
+  Engine() = default;
+  ~Engine() = default;
+
+public:
+  static auto make(own<Config>&& = Config::make()) -> own<Engine>;
+};
+
+
+// Store
+
+class WASM_API_EXTERN Store {
+  friend class destroyer;
+  void destroy();
+
+protected:
+  Store() = default;
+  ~Store() = default;
+
+public:
+  static auto make(Engine*) -> own<Store>;
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Type Representations
+
+// Type attributes
+
+enum class Mutability : uint8_t { CONST, VAR };
+
+struct Limits {
+  uint32_t min;
+  uint32_t max;
+
+  Limits(uint32_t min, uint32_t max = std::numeric_limits<uint32_t>::max()) :
+    min(min), max(max) {}
+};
+
+
+// Value Types
+
+enum class ValKind : uint8_t {
+  I32, I64, F32, F64,
+  EXTERNREF = 128, FUNCREF,
+};
+
+inline bool is_num(ValKind k) { return k < ValKind::EXTERNREF; }
+inline bool is_ref(ValKind k) { return k >= ValKind::EXTERNREF; }
+
+
+class WASM_API_EXTERN ValType {
+  friend class destroyer;
+  void destroy();
+
+protected:
+  ValType() = default;
+  ~ValType() = default;
+
+public:
+  static auto make(ValKind) -> own<ValType>;
+  auto copy() const -> own<ValType>;
+
+  auto kind() const -> ValKind;
+  auto is_num() const -> bool { return wasm::is_num(kind()); }
+  auto is_ref() const -> bool { return wasm::is_ref(kind()); }
+};
+
+
+// External Types
+
+enum class ExternKind : uint8_t {
+  FUNC, GLOBAL, TABLE, MEMORY
+};
+
+class FuncType;
+class GlobalType;
+class TableType;
+class MemoryType;
+
+class WASM_API_EXTERN ExternType {
+  friend class destroyer;
+  void destroy();
+
+protected:
+  ExternType() = default;
+  ~ExternType() = default;
+
+public:
+  auto copy() const-> own<ExternType>;
+
+  auto kind() const -> ExternKind;
+
+  auto func() -> FuncType*;
+  auto global() -> GlobalType*;
+  auto table() -> TableType*;
+  auto memory() -> MemoryType*;
+
+  auto func() const -> const FuncType*;
+  auto global() const -> const GlobalType*;
+  auto table() const -> const TableType*;
+  auto memory() const -> const MemoryType*;
+};
+
+
+// Function Types
+
+class WASM_API_EXTERN FuncType : public ExternType {
+  friend class destroyer;
+  void destroy();
+
+protected:
+  FuncType() = default;
+  ~FuncType() = default;
+
+public:
+  static auto make(
+    ownvec<ValType>&& params = ownvec<ValType>::make(),
+    ownvec<ValType>&& results = ownvec<ValType>::make()
+  ) -> own<FuncType>;
+
+  auto copy() const -> own<FuncType>;
+
+  auto params() const -> const ownvec<ValType>&;
+  auto results() const -> const ownvec<ValType>&;
+};
+
+
+// Global Types
+
+class WASM_API_EXTERN GlobalType : public ExternType {
+  friend class destroyer;
+  void destroy();
+
+protected:
+  GlobalType() = default;
+  ~GlobalType() = default;
+
+public:
+  static auto make(own<ValType>&&, Mutability) -> own<GlobalType>;
+  auto copy() const -> own<GlobalType>;
+
+  auto content() const -> const ValType*;
+  auto mutability() const -> Mutability;
+};
+
+
+// Table Types
+
+class WASM_API_EXTERN TableType : public ExternType {
+  friend class destroyer;
+  void destroy();
+
+protected:
+  TableType() = default;
+  ~TableType() = default;
+
+public:
+  static auto make(own<ValType>&&, Limits) -> own<TableType>;
+  auto copy() const -> own<TableType>;
+
+  auto element() const -> const ValType*;
+  auto limits() const -> const Limits&;
+};
+
+
+// Memory Types
+
+class WASM_API_EXTERN MemoryType : public ExternType {
+  friend class destroyer;
+  void destroy();
+
+protected:
+  MemoryType() = default;
+  ~MemoryType() = default;
+
+public:
+  static auto make(Limits) -> own<MemoryType>;
+  auto copy() const -> own<MemoryType>;
+
+  auto limits() const -> const Limits&;
+};
+
+
+// Import Types
+
+using Name = vec<byte_t>;
+
+class WASM_API_EXTERN ImportType {
+  friend class destroyer;
+  void destroy();
+
+protected:
+  ImportType() = default;
+  ~ImportType() = default;
+
+public:
+  static auto make(Name&& module, Name&& name, own<ExternType>&&) ->
+    own<ImportType>;
+  auto copy() const -> own<ImportType>;
+
+  auto module() const -> const Name&;
+  auto name() const -> const Name&;
+  auto type() const -> const ExternType*;
+};
+
+
+// Export Types
+
+class WASM_API_EXTERN ExportType {
+  friend class destroyer;
+  void destroy();
+
+protected:
+  ExportType() = default;
+  ~ExportType() = default;
+
+public:
+  static auto make(Name&&, own<ExternType>&&) -> own<ExportType>;
+  auto copy() const -> own<ExportType>;
+
+  auto name() const -> const Name&;
+  auto type() const -> const ExternType*;
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Runtime Objects
+
+// References
+
+class WASM_API_EXTERN Ref {
+  friend class destroyer;
+  void destroy();
+
+protected:
+  Ref() = default;
+  ~Ref() = default;
+
+public:
+  auto copy() const -> own<Ref>;
+  auto same(const Ref*) const -> bool;
+
+  auto get_host_info() const -> void*;
+  void set_host_info(void* info, void (*finalizer)(void*) = nullptr);
+};
+
+
+// Values
+
+class Val {
+  ValKind kind_;
+  union impl {
+    int32_t i32;
+    int64_t i64;
+    float32_t f32;
+    float64_t f64;
+    Ref* ref;
+  } impl_;
+
+  Val(ValKind kind, impl impl) : kind_(kind), impl_(impl) {}
+
+public:
+  Val() : kind_(ValKind::EXTERNREF) { impl_.ref = nullptr; }
+  explicit Val(int32_t i) : kind_(ValKind::I32) { impl_.i32 = i; }
+  explicit Val(int64_t i) : kind_(ValKind::I64) { impl_.i64 = i; }
+  explicit Val(float32_t z) : kind_(ValKind::F32) { impl_.f32 = z; }
+  explicit Val(float64_t z) : kind_(ValKind::F64) { impl_.f64 = z; }
+  explicit Val(own<Ref>&& r) : kind_(ValKind::EXTERNREF) { impl_.ref = r.release(); }
+
+  Val(Val&& that) : kind_(that.kind_), impl_(that.impl_) {
+    if (is_ref()) that.impl_.ref = nullptr;
+  }
+
+  ~Val() {
+    reset();
+  }
+
+  auto is_num() const -> bool { return wasm::is_num(kind_); }
+  auto is_ref() const -> bool { return wasm::is_ref(kind_); }
+
+  static auto i32(int32_t x) -> Val { return Val(x); }
+  static auto i64(int64_t x) -> Val { return Val(x); }
+  static auto f32(float32_t x) -> Val { return Val(x); }
+  static auto f64(float64_t x) -> Val { return Val(x); }
+  static auto ref(own<Ref>&& x) -> Val { return Val(std::move(x)); }
+  template<class T> inline static auto make(T x) -> Val;
+  template<class T> inline static auto make(own<T>&& x) -> Val;
+
+  void reset() {
+    if (is_ref() && impl_.ref) {
+      destroyer()(impl_.ref);
+      impl_.ref = nullptr;
+    }
+  }
+
+  void reset(Val& that) {
+    reset();
+    kind_ = that.kind_;
+    impl_ = that.impl_;
+    if (is_ref()) that.impl_.ref = nullptr;
+  }
+
+  auto operator=(Val&& that) -> Val& {
+    reset(that);
+    return *this;
+  }
+
+  auto kind() const -> ValKind { return kind_; }
+  auto i32() const -> int32_t { assert(kind_ == ValKind::I32); return impl_.i32; }
+  auto i64() const -> int64_t { assert(kind_ == ValKind::I64); return impl_.i64; }
+  auto f32() const -> float32_t { assert(kind_ == ValKind::F32); return impl_.f32; }
+  auto f64() const -> float64_t { assert(kind_ == ValKind::F64); return impl_.f64; }
+  auto ref() const -> Ref* { assert(is_ref()); return impl_.ref; }
+  template<class T> inline auto get() const -> T;
+
+  auto release_ref() -> own<Ref> {
+    assert(is_ref());
+    auto ref = impl_.ref;
+    impl_.ref = nullptr;
+    return own<Ref>(ref);
+  }
+
+  auto copy() const -> Val {
+    if (is_ref() && impl_.ref != nullptr) {
+      // TODO(mvsc): MVSC cannot handle this:
+      // impl impl = {.ref = impl_.ref->copy().release()};
+      impl impl;
+      impl.ref = impl_.ref->copy().release();
+      return Val(kind_, impl);
+    } else {
+      return Val(kind_, impl_);
+    }
+  }
+};
+
+
+template<> inline auto Val::make<int32_t>(int32_t x) -> Val { return Val(x); }
+template<> inline auto Val::make<int64_t>(int64_t x) -> Val { return Val(x); }
+template<> inline auto Val::make<float32_t>(float32_t x) -> Val { return Val(x); }
+template<> inline auto Val::make<float64_t>(float64_t x) -> Val { return Val(x); }
+template<> inline auto Val::make<Ref>(own<Ref>&& x) -> Val {
+  return Val(std::move(x));
+}
+
+template<> inline auto Val::make<uint32_t>(uint32_t x) -> Val {
+  return Val(static_cast<int32_t>(x));
+}
+template<> inline auto Val::make<uint64_t>(uint64_t x) -> Val {
+  return Val(static_cast<int64_t>(x));
+}
+
+template<> inline auto Val::get<int32_t>() const -> int32_t { return i32(); }
+template<> inline auto Val::get<int64_t>() const -> int64_t { return i64(); }
+template<> inline auto Val::get<float32_t>() const -> float32_t { return f32(); }
+template<> inline auto Val::get<float64_t>() const -> float64_t { return f64(); }
+template<> inline auto Val::get<Ref*>() const -> Ref* { return ref(); }
+
+template<> inline auto Val::get<uint32_t>() const -> uint32_t {
+  return static_cast<uint32_t>(i32());
+}
+template<> inline auto Val::get<uint64_t>() const -> uint64_t {
+  return static_cast<uint64_t>(i64());
+}
+
+
+// Traps
+
+using Message = vec<byte_t>;  // null terminated
+
+class Instance;
+
+class WASM_API_EXTERN Frame {
+  friend class destroyer;
+  void destroy();
+
+protected:
+  Frame() = default;
+  ~Frame() = default;
+
+public:
+  auto copy() const -> own<Frame>;
+
+  auto instance() const -> Instance*;
+  auto func_index() const -> uint32_t;
+  auto func_offset() const -> size_t;
+  auto module_offset() const -> size_t;
+};
+
+class WASM_API_EXTERN Trap : public Ref {
+  friend class destroyer;
+  void destroy();
+
+protected:
+  Trap() = default;
+  ~Trap() = default;
+
+public:
+  static auto make(Store*, const Message& msg) -> own<Trap>;
+  auto copy() const -> own<Trap>;
+
+  auto message() const -> Message;
+  auto origin() const -> own<Frame>;  // may be null
+  auto trace() const -> ownvec<Frame>;  // may be empty, origin first
+};
+
+
+// Modules
+
+template<class T> class WASM_API_EXTERN Shared;
+
+class WASM_API_EXTERN Module : public Ref {
+  friend class destroyer;
+  void destroy();
+
+protected:
+  Module() = default;
+  ~Module() = default;
+
+public:
+  static auto validate(Store*, const vec<byte_t>& binary) -> bool;
+  static auto make(Store*, const vec<byte_t>& binary) -> own<Module>;
+  auto copy() const -> own<Module>;
+
+  auto imports() const -> ownvec<ImportType>;
+  auto exports() const -> ownvec<ExportType>;
+
+  auto share() const -> own<Shared<Module>>;
+  static auto obtain(Store*, const Shared<Module>*) -> own<Module>;
+
+  auto serialize() const -> vec<byte_t>;
+  static auto deserialize(Store*, const vec<byte_t>&) -> own<Module>;
+};
+
+
+// Shared objects
+
+template<>
+class WASM_API_EXTERN Shared<Module> {
+  friend class destroyer;
+  void destroy();
+
+protected:
+  Shared() = default;
+  ~Shared() = default;
+};
+
+
+// Foreign Objects
+
+class WASM_API_EXTERN Foreign : public Ref {
+  friend class destroyer;
+  void destroy();
+
+protected:
+  Foreign() = default;
+  ~Foreign() = default;
+
+public:
+  static auto make(Store*) -> own<Foreign>;
+  auto copy() const -> own<Foreign>;
+};
+
+
+// Externals
+
+class Func;
+class Global;
+class Table;
+class Memory;
+
+class WASM_API_EXTERN Extern : public Ref {
+  friend class destroyer;
+  void destroy();
+
+protected:
+  Extern() = default;
+  ~Extern() = default;
+
+public:
+  auto copy() const -> own<Extern>;
+
+  auto kind() const -> ExternKind;
+  auto type() const -> own<ExternType>;
+
+  auto func() -> Func*;
+  auto global() -> Global*;
+  auto table() -> Table*;
+  auto memory() -> Memory*;
+
+  auto func() const -> const Func*;
+  auto global() const -> const Global*;
+  auto table() const -> const Table*;
+  auto memory() const -> const Memory*;
+};
+
+
+// Function Instances
+
+class WASM_API_EXTERN Func : public Extern {
+  friend class destroyer;
+  void destroy();
+
+protected:
+  Func() = default;
+  ~Func() = default;
+
+public:
+  using callback = auto (*)(const vec<Val>&, vec<Val>&) -> own<Trap>;
+  using callback_with_env = auto (*)(void*, const vec<Val>&, vec<Val>&) -> own<Trap>;
+
+  static auto make(Store*, const FuncType*, callback) -> own<Func>;
+  static auto make(Store*, const FuncType*, callback_with_env,
+    void*, void (*finalizer)(void*) = nullptr) -> own<Func>;
+  auto copy() const -> own<Func>;
+
+  auto type() const -> own<FuncType>;
+  auto param_arity() const -> size_t;
+  auto result_arity() const -> size_t;
+
+  auto call(const vec<Val>&, vec<Val>&) const -> own<Trap>;
+};
+
+
+// Global Instances
+
+class WASM_API_EXTERN Global : public Extern {
+  friend class destroyer;
+  void destroy();
+
+protected:
+  Global() = default;
+  ~Global() = default;
+
+ public:
+  static auto make(Store*, const GlobalType*, const Val&) -> own<Global>;
+  auto copy() const -> own<Global>;
+
+  auto type() const -> own<GlobalType>;
+  auto get() const -> Val;
+  void set(const Val&);
+};
+
+
+// Table Instances
+
+class WASM_API_EXTERN Table : public Extern {
+  friend class destroyer;
+  void destroy();
+
+protected:
+  Table() = default;
+  ~Table() = default;
+
+public:
+  using size_t = uint32_t;
+
+  static auto make(
+    Store*, const TableType*, const Ref* init = nullptr) -> own<Table>;
+  auto copy() const -> own<Table>;
+
+  auto type() const -> own<TableType>;
+  auto get(size_t index) const -> own<Ref>;
+  auto set(size_t index, const Ref*) -> bool;
+  auto size() const -> size_t;
+  auto grow(size_t delta, const Ref* init = nullptr) -> bool;
+};
+
+
+// Memory Instances
+
+class WASM_API_EXTERN Memory : public Extern {
+  friend class destroyer;
+  void destroy();
+
+protected:
+  Memory() = default;
+  ~Memory() = default;
+
+public:
+  static auto make(Store*, const MemoryType*) -> own<Memory>;
+  auto copy() const -> own<Memory>;
+
+  using pages_t = uint32_t;
+
+  static const size_t page_size = 0x10000;
+
+  auto type() const -> own<MemoryType>;
+  auto data() const -> byte_t*;
+  auto data_size() const -> size_t;
+  auto size() const -> pages_t;
+  auto grow(pages_t delta) -> bool;
+};
+
+
+// Module Instances
+
+class WASM_API_EXTERN Instance : public Ref {
+  friend class destroyer;
+  void destroy();
+
+protected:
+  Instance() = default;
+  ~Instance() = default;
+
+public:
+  static auto make(
+    Store*, const Module*, const vec<Extern*>&, own<Trap>* = nullptr
+  ) -> own<Instance>;
+  auto copy() const -> own<Instance>;
+
+  auto exports() const -> ownvec<Extern>;
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+}  // namespace wasm
+
+#endif  // #ifdef WASM_HH
diff --git a/crates/c-api/include/wasmtime.h b/crates/c-api/include/wasmtime.h
index 32c0478e5753..0cbae0c9738f 100644
--- a/crates/c-api/include/wasmtime.h
+++ b/crates/c-api/include/wasmtime.h
@@ -57,7 +57,8 @@
  *
  * * Linux - `-lpthread -ldl -lm`
  * * macOS - no extra flags needed
- * * Windows - `ws2_32.lib advapi32.lib userenv.lib ntdll.lib shell32.lib ole32.lib bcrypt.lib`
+ * * Windows - `ws2_32.lib advapi32.lib userenv.lib ntdll.lib shell32.lib
+ * ole32.lib bcrypt.lib`
  *
  * ## Building from Source
  *
@@ -89,7 +90,7 @@
  *   issue](https://github.com/bytecodealliance/wasmtime/issues/new).
  *
  * * [C embedding
- *   examples](https://bytecodealliance.github.io/wasmtime/examples-c-embed.html)
+ *   examples](https://bytecodealliance.github.io/wasmtime/lang-c.html)
  *   are available online and are tested from the Wasmtime repository itself.
  *
  * * [Contribution documentation for
@@ -151,9 +152,7 @@
  * provided access to it. For example in a host function created with
  * #wasmtime_func_new you can use #wasmtime_context_t in the host function
  * callback. This is because an argument, a #wasmtime_caller_t, provides access
- * to #wasmtime_context_t. On the other hand a destructor passed to
- * #wasmtime_externref_new, however, cannot use a #wasmtime_context_t because
- * it was not provided access to one. Doing so may lead to memory unsafety.
+ * to #wasmtime_context_t.
  *
  * ### Stores
  *
@@ -181,6 +180,9 @@
 #define WASMTIME_API_H
 
 #include <wasi.h>
+#include <wasmtime/conf.h>
+// clang-format off
+// IWYU pragma: begin_exports
 #include <wasmtime/config.h>
 #include <wasmtime/engine.h>
 #include <wasmtime/error.h>
@@ -191,20 +193,24 @@
 #include <wasmtime/linker.h>
 #include <wasmtime/memory.h>
 #include <wasmtime/module.h>
+#include <wasmtime/profiling.h>
+#include <wasmtime/sharedmemory.h>
 #include <wasmtime/store.h>
 #include <wasmtime/table.h>
 #include <wasmtime/trap.h>
 #include <wasmtime/val.h>
 #include <wasmtime/async.h>
+// IWYU pragma: end_exports
+// clang-format on
 
 /**
  * \brief Wasmtime version string.
  */
-#define WASMTIME_VERSION "14.0.0"
+#define WASMTIME_VERSION "25.0.0"
 /**
  * \brief Wasmtime major version number.
  */
-#define WASMTIME_VERSION_MAJOR 14
+#define WASMTIME_VERSION_MAJOR 25
 /**
  * \brief Wasmtime minor version number.
  */
@@ -218,14 +224,16 @@
 extern "C" {
 #endif
 
+#ifdef WASMTIME_FEATURE_WAT
+
 /**
- * \brief Converts from the text format of WebAssembly to to the binary format.
+ * \brief Converts from the text format of WebAssembly to the binary format.
  *
- * \param wat this it the input pointer with the WebAssembly Text Format inside of
- *   it. This will be parsed and converted to the binary format.
+ * \param wat this it the input pointer with the WebAssembly Text Format inside
+ *        of it. This will be parsed and converted to the binary format.
  * \param wat_len this it the length of `wat`, in bytes.
- * \param ret if the conversion is successful, this byte vector is filled in with
- *   the WebAssembly binary format.
+ * \param ret if the conversion is successful, this byte vector is filled in
+ *        with the WebAssembly binary format.
  *
  * \return a non-null error if parsing fails, or returns `NULL`. If parsing
  * fails then `ret` isn't touched.
@@ -233,14 +241,13 @@ extern "C" {
  * This function does not take ownership of `wat`, and the caller is expected to
  * deallocate the returned #wasmtime_error_t and #wasm_byte_vec_t.
  */
-WASM_API_EXTERN wasmtime_error_t* wasmtime_wat2wasm(
-    const char *wat,
-    size_t wat_len,
-    wasm_byte_vec_t *ret
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_wat2wasm(const char *wat, size_t wat_len, wasm_byte_vec_t *ret);
+
+#endif
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
 #endif // WASMTIME_API_H
diff --git a/crates/c-api/include/wasmtime/async.h b/crates/c-api/include/wasmtime/async.h
index dbe4312dc118..c0f6a14b4fd6 100644
--- a/crates/c-api/include/wasmtime/async.h
+++ b/crates/c-api/include/wasmtime/async.h
@@ -6,23 +6,27 @@
  * Async functionality in Wasmtime is well documented here:
  * https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.async_support
  *
- * All WebAssembly executes synchronously, but an async support enables the Wasm code
- * be executed on a seperate stack, so it can be paused and resumed. There are three
- * mechanisms for yielding control from wasm to the caller: fuel, epochs, and async host functions.
- *
- * When WebAssembly is executed, a #wasmtime_call_future_t is returned. This struct represents the
- * state of the execution and each call to #wasmtime_call_future_poll will execute the WebAssembly
- * code on a seperate stack until the function returns or yields control back to the caller.
- *
- * It's expected these futures are pulled in a loop until completed, at which point the future 
- * should be deleted. Functions that return a #wasmtime_call_future_t are special in that all 
- * parameters to that function should not be modified in any way and must be kept alive until
- * the future is deleted. This includes concurrent calls for a single store - another function
- * on a store should not be called while there is a #wasmtime_call_future_t alive.
- *
- * As for asynchronous host calls - the reverse contract is upheld. Wasmtime will keep all parameters
- * to the function alive and unmodified until the #wasmtime_func_async_continuation_callback_t returns
- * true.
+ * All WebAssembly executes synchronously, but an async support enables the Wasm
+ * code be executed on a separate stack, so it can be paused and resumed. There
+ * are three mechanisms for yielding control from wasm to the caller: fuel,
+ * epochs, and async host functions.
+ *
+ * When WebAssembly is executed, a `wasmtime_call_future_t` is returned. This
+ * struct represents the state of the execution and each call to
+ * `wasmtime_call_future_poll` will execute the WebAssembly code on a separate
+ * stack until the function returns or yields control back to the caller.
+ *
+ * It's expected these futures are pulled in a loop until completed, at which
+ * point the future should be deleted. Functions that return a
+ * `wasmtime_call_future_t` are special in that all parameters to that function
+ * should not be modified in any way and must be kept alive until the future is
+ * deleted. This includes concurrent calls for a single store - another function
+ * on a store should not be called while there is a `wasmtime_call_future_t`
+ * alive.
+ *
+ * As for asynchronous host calls - the reverse contract is upheld. Wasmtime
+ * will keep all parameters to the function alive and unmodified until the
+ * `wasmtime_func_async_continuation_callback_t` returns true.
  *
  */
 
@@ -30,22 +34,27 @@
 #define WASMTIME_ASYNC_H
 
 #include <wasm.h>
-#include <wasmtime/error.h>
+#include <wasmtime/conf.h>
 #include <wasmtime/config.h>
-#include <wasmtime/store.h>
+#include <wasmtime/error.h>
 #include <wasmtime/func.h>
 #include <wasmtime/linker.h>
+#include <wasmtime/store.h>
+
+#ifdef WASMTIME_FEATURE_ASYNC
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /**
- * \brief Whether or not to enable support for asynchronous functions in Wasmtime.
+ * \brief Whether or not to enable support for asynchronous functions in
+ * Wasmtime.
  *
- * When enabled, the config can optionally define host functions with async. 
- * Instances created and functions called with this Config must be called through their asynchronous APIs, however.
- * For example using wasmtime_func_call will panic when used with this config.
+ * When enabled, the config can optionally define host functions with async.
+ * Instances created and functions called with this Config must be called
+ * through their asynchronous APIs, however. For example using
+ * wasmtime_func_call will panic when used with this config.
  *
  * For more information see the Rust documentation at
  * https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.async_support
@@ -55,13 +64,15 @@ WASMTIME_CONFIG_PROP(void, async_support, bool)
 /**
  * \brief Configures the size of the stacks used for asynchronous execution.
  *
- * This setting configures the size of the stacks that are allocated for asynchronous execution. 
+ * This setting configures the size of the stacks that are allocated for
+ * asynchronous execution.
  *
  * The value cannot be less than max_wasm_stack.
  *
- * The amount of stack space guaranteed for host functions is async_stack_size - max_wasm_stack, so take care
- * not to set these two values close to one another; doing so may cause host functions to overflow the stack 
- * and abort the process.
+ * The amount of stack space guaranteed for host functions is async_stack_size -
+ * max_wasm_stack, so take care not to set these two values close to one
+ * another; doing so may cause host functions to overflow the stack and abort
+ * the process.
  *
  * By default this option is 2 MiB.
  *
@@ -71,37 +82,43 @@ WASMTIME_CONFIG_PROP(void, async_support, bool)
 WASMTIME_CONFIG_PROP(void, async_stack_size, uint64_t)
 
 /**
- * \brief Configures a Store to yield execution of async WebAssembly code periodically.
+ * \brief Configures a Store to yield execution of async WebAssembly code
+ * periodically.
+ *
+ * When a Store is configured to consume fuel with
+ * `wasmtime_config_consume_fuel` this method will configure what happens when
+ * fuel runs out. Specifically executing WebAssembly will be suspended and
+ * control will be yielded back to the caller.
  *
- * When a Store is configured to consume fuel with `wasmtime_config_consume_fuel` 
- * this method will configure what happens when fuel runs out. Specifically executing
- * WebAssembly will be suspended and control will be yielded back to the caller.
+ * This is only suitable with use of a store associated with an async config
+ * because only then are futures used and yields are possible.
  *
- * This is only suitable with use of a store associated with an async config because
- * only then are futures used and yields are possible.
+ * \param context the context for the store to configure.
+ * \param interval the amount of fuel at which to yield. A value of 0 will
+ *        disable yielding.
  */
-WASM_API_EXTERN void wasmtime_context_out_of_fuel_async_yield(
-    wasmtime_context_t *context,
-    uint64_t injection_count,
-    uint64_t fuel_to_inject);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_context_fuel_async_yield_interval(wasmtime_context_t *context,
+                                           uint64_t interval);
 
 /**
- * \brief Configures epoch-deadline expiration to yield to the async caller and the update the deadline.
+ * \brief Configures epoch-deadline expiration to yield to the async caller and
+ * the update the deadline.
  *
- * This is only suitable with use of a store associated with an async config because
- * only then are futures used and yields are possible.
+ * This is only suitable with use of a store associated with an async config
+ * because only then are futures used and yields are possible.
  *
  * See the Rust documentation for more:
  * https://docs.wasmtime.dev/api/wasmtime/struct.Store.html#method.epoch_deadline_async_yield_and_update
  */
-WASM_API_EXTERN void wasmtime_context_epoch_deadline_async_yield_and_update(
-    wasmtime_context_t *context,
-    uint64_t delta);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_context_epoch_deadline_async_yield_and_update(
+    wasmtime_context_t *context, uint64_t delta);
 
 /**
  * The callback to determine a continuation's current state.
  *
- * Return true if the host call has completed, otherwise false will 
+ * Return true if the host call has completed, otherwise false will
  * continue to yield WebAssembly execution.
  */
 typedef bool (*wasmtime_func_async_continuation_callback_t)(void *env);
@@ -121,59 +138,58 @@ typedef struct wasmtime_async_continuation_t {
 /**
  * \brief Callback signature for #wasmtime_linker_define_async_func.
  *
- * This is a host function that returns a continuation to be called later. 
+ * This is a host function that returns a continuation to be called later.
  *
  * All the arguments to this function will be kept alive until the continuation
  * returns that it has errored or has completed.
  *
- * \param env user-provided argument passed to #wasmtime_linker_define_async_func
+ * \param env user-provided argument passed to
+ *        #wasmtime_linker_define_async_func
  * \param caller a temporary object that can only be used during this function
- * call. Used to acquire #wasmtime_context_t or caller's state
+ *        call. Used to acquire #wasmtime_context_t or caller's state
  * \param args the arguments provided to this function invocation
  * \param nargs how many arguments are provided
  * \param results where to write the results of this function
  * \param nresults how many results must be produced
- * \param trap_ret if assigned a not `NULL` value then the called function will
- *        trap with the returned error. Note that ownership of trap is transferred
- *        to wasmtime.
- * \param continuation_ret the returned continuation that determines when the 
- *        async function has completed executing.
+ * \param trap_ret if assigned a not `NULL` value then the called
+ *        function will trap with the returned error. Note that ownership of
+ *        trap is transferred to wasmtime.
+ * \param continuation_ret the returned continuation
+ *        that determines when the async function has completed executing.
  *
  * Only supported for async stores.
  *
  * See #wasmtime_func_callback_t for more information.
  */
 typedef void (*wasmtime_func_async_callback_t)(
-    void *env,
-    wasmtime_caller_t *caller, 
-    const wasmtime_val_t *args,
-    size_t nargs, 
-    wasmtime_val_t *results,
-    size_t nresults,
-    wasm_trap_t** trap_ret,
-    wasmtime_async_continuation_t * continuation_ret);
+    void *env, wasmtime_caller_t *caller, const wasmtime_val_t *args,
+    size_t nargs, wasmtime_val_t *results, size_t nresults,
+    wasm_trap_t **trap_ret, wasmtime_async_continuation_t *continuation_ret);
 
 /**
  * \brief The structure representing a asynchronously running function.
  *
- * This structure is always owned by the caller and must be deleted using #wasmtime_call_future_delete.
+ * This structure is always owned by the caller and must be deleted using
+ * #wasmtime_call_future_delete.
  *
- * Functions that return this type require that the parameters to the function are unmodified until 
- * this future is destroyed.
+ * Functions that return this type require that the parameters to the function
+ * are unmodified until this future is destroyed.
  */
 typedef struct wasmtime_call_future wasmtime_call_future_t;
 
 /**
  * \brief Executes WebAssembly in the function.
  *
- * Returns true if the function call has completed. After this function returns true, it should *not* be 
- * called again for a given future.
+ * Returns true if the function call has completed. After this function returns
+ * true, it should *not* be called again for a given future.
  *
- * This function returns false if execution has yielded either due to being out of fuel 
- * (see wasmtime_store_out_of_fuel_async_yield), or the epoch has been incremented enough 
- * (see wasmtime_store_epoch_deadline_async_yield_and_update). The function may also return false if 
- * asynchronous host functions have been called, which then calling this  function will call the 
- * continuation from the async host function.
+ * This function returns false if execution has yielded either due to being out
+ * of fuel (see wasmtime_context_fuel_async_yield_interval), or the epoch has
+ * been incremented enough (see
+ * wasmtime_context_epoch_deadline_async_yield_and_update). The function may
+ * also return false if asynchronous host functions have been called, which then
+ * calling this  function will call the continuation from the async host
+ * function.
  *
  * For more see the information at
  * https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#asynchronous-wasm
@@ -184,86 +200,83 @@ WASM_API_EXTERN bool wasmtime_call_future_poll(wasmtime_call_future_t *future);
 /**
  * /brief Frees the underlying memory for a future.
  *
- * All wasmtime_call_future_t are owned by the caller and should be deleted using this function.
+ * All wasmtime_call_future_t are owned by the caller and should be deleted
+ * using this function.
  */
-WASM_API_EXTERN void wasmtime_call_future_delete(wasmtime_call_future_t *future);
+WASM_API_EXTERN void
+wasmtime_call_future_delete(wasmtime_call_future_t *future);
 
 /**
- * \brief Invokes this function with the params given, returning the results asynchronously.
+ * \brief Invokes this function with the params given, returning the results
+ * asynchronously.
  *
- * This function is the same as wasmtime_func_call except that it is asynchronous.
- * This is only compatible with stores associated with an asynchronous config.
+ * This function is the same as wasmtime_func_call except that it is
+ * asynchronous. This is only compatible with stores associated with an
+ * asynchronous config.
  *
- * The result is a future that is owned by the caller and must be deleted via #wasmtime_call_future_delete. 
+ * The result is a future that is owned by the caller and must be deleted via
+ * #wasmtime_call_future_delete.
  *
- * The `args` and `results` pointers may be `NULL` if the corresponding length is zero.
- * The `trap_ret` and `error_ret` pointers may *not* be `NULL`.
+ * The `args` and `results` pointers may be `NULL` if the corresponding length
+ * is zero. The `trap_ret` and `error_ret` pointers may *not* be `NULL`.
  *
- * Does not take ownership of #wasmtime_val_t arguments or #wasmtime_val_t results,
- * and all parameters to this function must be kept alive and not modified until the
- * returned #wasmtime_call_future_t is deleted. This includes the context and store
- * parameters. Only a single future can be alive for a given store at a single time 
- * (meaning only call this function after the previous call's future was deleted).
+ * Does not take ownership of #wasmtime_val_t arguments or #wasmtime_val_t
+ * results, and all parameters to this function must be kept alive and not
+ * modified until the returned #wasmtime_call_future_t is deleted. This includes
+ * the context and store parameters. Only a single future can be alive for a
+ * given store at a single time (meaning only call this function after the
+ * previous call's future was deleted).
  *
  * See the header documentation for for more information.
  *
  * For more information see the Rust documentation at
  * https://docs.wasmtime.dev/api/wasmtime/struct.Func.html#method.call_async
  */
-WASM_API_EXTERN wasmtime_call_future_t* wasmtime_func_call_async(
-    wasmtime_context_t *context,
-    const wasmtime_func_t *func,
-    const wasmtime_val_t *args,
-    size_t nargs,
-    wasmtime_val_t *results,
-    size_t nresults,
-    wasm_trap_t** trap_ret,
-    wasmtime_error_t** error_ret);
+WASM_API_EXTERN wasmtime_call_future_t *wasmtime_func_call_async(
+    wasmtime_context_t *context, const wasmtime_func_t *func,
+    const wasmtime_val_t *args, size_t nargs, wasmtime_val_t *results,
+    size_t nresults, wasm_trap_t **trap_ret, wasmtime_error_t **error_ret);
 
 /**
  * \brief Defines a new async function in this linker.
  *
- * This function behaves similar to #wasmtime_linker_define_func, except it supports async
- * callbacks.
+ * This function behaves similar to #wasmtime_linker_define_func, except it
+ * supports async callbacks.
  *
  * The callback `cb` will be invoked on another stack (fiber for Windows).
  */
 WASM_API_EXTERN wasmtime_error_t *wasmtime_linker_define_async_func(
-    wasmtime_linker_t *linker,
-    const char *module,
-    size_t module_len,
-    const char *name,
-    size_t name_len,
-    const wasm_functype_t *ty,
-    wasmtime_func_async_callback_t cb,
-    void *data,
-    void (*finalizer)(void *));
+    wasmtime_linker_t *linker, const char *module, size_t module_len,
+    const char *name, size_t name_len, const wasm_functype_t *ty,
+    wasmtime_func_async_callback_t cb, void *data, void (*finalizer)(void *));
 
 /**
- * \brief Instantiates a #wasm_module_t with the items defined in this linker for an async store.
+ * \brief Instantiates a #wasm_module_t with the items defined in this linker
+ * for an async store.
  *
- * This is the same as #wasmtime_linker_instantiate but used for async stores 
- * (which requires functions are called asynchronously). The returning #wasmtime_call_future_t 
- * must be polled using #wasmtime_call_future_poll, and is owned and must be deleted using #wasmtime_call_future_delete.
+ * This is the same as #wasmtime_linker_instantiate but used for async stores
+ * (which requires functions are called asynchronously). The returning
+ * #wasmtime_call_future_t must be polled using #wasmtime_call_future_poll, and
+ * is owned and must be deleted using #wasmtime_call_future_delete.
  *
- * The `trap_ret` and `error_ret` pointers may *not* be `NULL` and the returned memory is owned by the caller.
+ * The `trap_ret` and `error_ret` pointers may *not* be `NULL` and the returned
+ * memory is owned by the caller.
  *
- * All arguments to this function must outlive the returned future and be unmodified until the future is deleted.
+ * All arguments to this function must outlive the returned future and be
+ * unmodified until the future is deleted.
  */
 WASM_API_EXTERN wasmtime_call_future_t *wasmtime_linker_instantiate_async(
-    const wasmtime_linker_t *linker,
-    wasmtime_context_t *store,
-    const wasmtime_module_t *module,
-    wasmtime_instance_t *instance,
-    wasm_trap_t** trap_ret,
-    wasmtime_error_t** error_ret);
+    const wasmtime_linker_t *linker, wasmtime_context_t *store,
+    const wasmtime_module_t *module, wasmtime_instance_t *instance,
+    wasm_trap_t **trap_ret, wasmtime_error_t **error_ret);
 
 /**
  * \brief Instantiates instance within the given store.
  *
  * This will also run the function's startup function, if there is one.
  *
- * For more information on async instantiation see #wasmtime_linker_instantiate_async.
+ * For more information on async instantiation see
+ * #wasmtime_linker_instantiate_async.
  *
  * \param instance_pre the pre-initialized instance
  * \param store the store in which to create the instance
@@ -271,20 +284,91 @@ WASM_API_EXTERN wasmtime_call_future_t *wasmtime_linker_instantiate_async(
  * \param trap_ret where to store the returned trap
  * \param error_ret where to store the returned trap
  *
- * The `trap_ret` and `error_ret` pointers may *not* be `NULL` and the returned memory is owned by the caller.
+ * The `trap_ret` and `error_ret` pointers may *not* be `NULL` and the returned
+ * memory is owned by the caller.
  *
- * All arguments to this function must outlive the returned future and be unmodified until the future is deleted.
+ * All arguments to this function must outlive the returned future and be
+ * unmodified until the future is deleted.
  */
 WASM_API_EXTERN wasmtime_call_future_t *wasmtime_instance_pre_instantiate_async(
-    const wasmtime_instance_pre_t* instance_pre,
-    wasmtime_context_t *store,
-    wasmtime_instance_t *instance,
-    wasm_trap_t** trap_ret,
-    wasmtime_error_t** error_ret);
+    const wasmtime_instance_pre_t *instance_pre, wasmtime_context_t *store,
+    wasmtime_instance_t *instance, wasm_trap_t **trap_ret,
+    wasmtime_error_t **error_ret);
+
+/**
+ * A callback to get the top of the stack address and the length of the stack,
+ * excluding guard pages.
+ *
+ * For more information about the parameters see the Rust documentation at
+ * https://docs.wasmtime.dev/api/wasmtime/trait.StackMemory.html
+ */
+typedef uint8_t *(*wasmtime_stack_memory_get_callback_t)(void *env,
+                                                         size_t *out_len);
+
+/**
+ * A Stack instance created from a #wasmtime_new_stack_memory_callback_t.
+ *
+ * For more information see the Rust documentation at
+ * https://docs.wasmtime.dev/api/wasmtime/trait.StackMemory.html
+ */
+typedef struct {
+  /// User provided value to be passed to get_memory and grow_memory
+  void *env;
+  /// Callback to get the memory and size of this LinearMemory
+  wasmtime_stack_memory_get_callback_t get_stack_memory;
+  /// An optional finalizer for env
+  void (*finalizer)(void *);
+} wasmtime_stack_memory_t;
+
+/**
+ * A callback to create a new StackMemory from the specified parameters.
+ *
+ * The result should be written to `stack_ret` and wasmtime will own the values
+ * written into that struct.
+ *
+ * This callback must be thread-safe.
+ *
+ * For more information about the parameters see the Rust documentation at
+ * https://docs.wasmtime.dev/api/wasmtime/trait.StackCreator.html#tymethod.new_stack
+ */
+typedef wasmtime_error_t *(*wasmtime_new_stack_memory_callback_t)(
+    void *env, size_t size, wasmtime_stack_memory_t *stack_ret);
+
+/**
+ * A representation of custom stack creator.
+ *
+ * For more information see the Rust documentation at
+ * https://docs.wasmtime.dev/api/wasmtime/trait.StackCreator.html
+ */
+typedef struct {
+  /// User provided value to be passed to new_stack
+  void *env;
+  /// The callback to create a new stack, must be thread safe
+  wasmtime_new_stack_memory_callback_t new_stack;
+  /// An optional finalizer for env.
+  void (*finalizer)(void *);
+} wasmtime_stack_creator_t;
+
+/**
+ * Sets a custom stack creator.
+ *
+ * Custom memory creators are used when creating creating async instance stacks
+ * for the on-demand instance allocation strategy.
+ *
+ * The config does **not** take ownership of the #wasmtime_stack_creator_t
+ * passed in, but instead copies all the values in the struct.
+ *
+ * For more information see the Rust documentation at
+ * https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.with_host_stack
+ */
+WASM_API_EXTERN void
+wasmtime_config_host_stack_creator_set(wasm_config_t *,
+                                       wasmtime_stack_creator_t *);
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
-#endif // WASMTIME_ASYNC_H
+#endif // WASMTIME_FEATURE_ASYNC
 
+#endif // WASMTIME_ASYNC_H
diff --git a/crates/c-api/include/wasmtime/conf.h.in b/crates/c-api/include/wasmtime/conf.h.in
new file mode 100644
index 000000000000..c04cfca886ad
--- /dev/null
+++ b/crates/c-api/include/wasmtime/conf.h.in
@@ -0,0 +1,33 @@
+/**
+ * \file wasmtime/conf.h
+ *
+ * \brief Build-time defines for how the C API was built.
+ */
+
+#ifndef WASMTIME_CONF_H
+#define WASMTIME_CONF_H
+
+// WASMTIME_FEATURE_LIST
+#cmakedefine WASMTIME_FEATURE_PROFILING
+#cmakedefine WASMTIME_FEATURE_WAT
+#cmakedefine WASMTIME_FEATURE_CACHE
+#cmakedefine WASMTIME_FEATURE_PARALLEL_COMPILATION
+#cmakedefine WASMTIME_FEATURE_WASI
+#cmakedefine WASMTIME_FEATURE_LOGGING
+#cmakedefine WASMTIME_FEATURE_DISABLE_LOGGING
+#cmakedefine WASMTIME_FEATURE_COREDUMP
+#cmakedefine WASMTIME_FEATURE_ADDR2LINE
+#cmakedefine WASMTIME_FEATURE_DEMANGLE
+#cmakedefine WASMTIME_FEATURE_THREADS
+#cmakedefine WASMTIME_FEATURE_GC
+#cmakedefine WASMTIME_FEATURE_ASYNC
+#cmakedefine WASMTIME_FEATURE_CRANELIFT
+#cmakedefine WASMTIME_FEATURE_WINCH
+// ... if you add a line above this be sure to change the other locations
+// marked WASMTIME_FEATURE_LIST
+
+#if defined(WASMTIME_FEATURE_CRANELIFT) || defined(WASMTIME_FEATURE_WINCH)
+#define WASMTIME_FEATURE_COMPILER
+#endif
+
+#endif // WASMTIME_CONF_H
diff --git a/crates/c-api/include/wasmtime/config.h b/crates/c-api/include/wasmtime/config.h
index 38f1edc1b504..0cd970ccc9b3 100644
--- a/crates/c-api/include/wasmtime/config.h
+++ b/crates/c-api/include/wasmtime/config.h
@@ -8,6 +8,7 @@
 #define WASMTIME_CONFIG_H
 
 #include <wasm.h>
+#include <wasmtime/conf.h>
 #include <wasmtime/error.h>
 
 #ifdef __cplusplus
@@ -86,8 +87,8 @@ enum wasmtime_profiling_strategy_enum { // ProfilingStrategy
   WASMTIME_PROFILING_STRATEGY_PERFMAP,
 };
 
-#define WASMTIME_CONFIG_PROP(ret, name, ty) \
-    WASM_API_EXTERN ret wasmtime_config_##name##_set(wasm_config_t*, ty);
+#define WASMTIME_CONFIG_PROP(ret, name, ty)                                    \
+  WASM_API_EXTERN ret wasmtime_config_##name##_set(wasm_config_t *, ty);
 
 /**
  * \brief Configures whether DWARF debug information is constructed at runtime
@@ -140,6 +141,8 @@ WASMTIME_CONFIG_PROP(void, epoch_interruption, bool)
  */
 WASMTIME_CONFIG_PROP(void, max_wasm_stack, size_t)
 
+#ifdef WASMTIME_FEATURE_THREADS
+
 /**
  * \brief Configures whether the WebAssembly threading proposal is enabled.
  *
@@ -149,6 +152,15 @@ WASMTIME_CONFIG_PROP(void, max_wasm_stack, size_t)
  */
 WASMTIME_CONFIG_PROP(void, wasm_threads, bool)
 
+#endif // WASMTIME_FEATURE_THREADS
+
+/**
+ * \brief Configures whether the WebAssembly tail call proposal is enabled.
+ *
+ * This setting is `false` by default.
+ */
+WASMTIME_CONFIG_PROP(void, wasm_tail_call, bool)
+
 /**
  * \brief Configures whether the WebAssembly reference types proposal is
  * enabled.
@@ -157,6 +169,21 @@ WASMTIME_CONFIG_PROP(void, wasm_threads, bool)
  */
 WASMTIME_CONFIG_PROP(void, wasm_reference_types, bool)
 
+/**
+ * \brief Configures whether the WebAssembly typed function reference types
+ * proposal is enabled.
+ *
+ * This setting is `false` by default.
+ */
+WASMTIME_CONFIG_PROP(void, wasm_function_references, bool)
+
+/**
+ * \brief Configures whether the WebAssembly GC proposal is enabled.
+ *
+ * This setting is `false` by default.
+ */
+WASMTIME_CONFIG_PROP(void, wasm_gc, bool)
+
 /**
  * \brief Configures whether the WebAssembly SIMD proposal is
  * enabled.
@@ -213,6 +240,8 @@ WASMTIME_CONFIG_PROP(void, wasm_multi_memory, bool)
  */
 WASMTIME_CONFIG_PROP(void, wasm_memory64, bool)
 
+#ifdef WASMTIME_FEATURE_COMPILER
+
 /**
  * \brief Configures how JIT code will be compiled.
  *
@@ -220,14 +249,23 @@ WASMTIME_CONFIG_PROP(void, wasm_memory64, bool)
  */
 WASMTIME_CONFIG_PROP(void, strategy, wasmtime_strategy_t)
 
+#endif // WASMTIME_FEATURE_COMPILER
+
+#ifdef WASMTIME_FEATURE_PARALLEL_COMPILATION
+
 /**
- * \brief Configure whether wasmtime should compile a module using multiple threads.
+ * \brief Configure whether wasmtime should compile a module using multiple
+ * threads.
  *
  * For more information see the Rust documentation at
  * https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.parallel_compilation.
  */
 WASMTIME_CONFIG_PROP(void, parallel_compilation, bool)
 
+#endif // WASMTIME_FEATURE_PARALLEL_COMPILATION
+
+#ifdef WASMTIME_FEATURE_COMPILER
+
 /**
  * \brief Configures whether Cranelift's debug verifier is enabled.
  *
@@ -239,13 +277,15 @@ WASMTIME_CONFIG_PROP(void, parallel_compilation, bool)
 WASMTIME_CONFIG_PROP(void, cranelift_debug_verifier, bool)
 
 /**
- * \brief Configures whether Cranelift should perform a NaN-canonicalization pass.
+ * \brief Configures whether Cranelift should perform a NaN-canonicalization
+ * pass.
  *
  * When Cranelift is used as a code generation backend this will configure
  * it to replace NaNs with a single canonical value. This is useful for users
  * requiring entirely deterministic WebAssembly computation.
  *
- * This is not required by the WebAssembly spec, so it is not enabled by default.
+ * This is not required by the WebAssembly spec, so it is not enabled by
+ * default.
  *
  * The default value for this is `false`
  */
@@ -258,6 +298,8 @@ WASMTIME_CONFIG_PROP(void, cranelift_nan_canonicalization, bool)
  */
 WASMTIME_CONFIG_PROP(void, cranelift_opt_level, wasmtime_opt_level_t)
 
+#endif // WASMTIME_FEATURE_COMPILER
+
 /**
  * \brief Configures the profiling strategy used for JIT code.
  *
@@ -300,7 +342,8 @@ WASMTIME_CONFIG_PROP(void, static_memory_guard_size, uint64_t)
 WASMTIME_CONFIG_PROP(void, dynamic_memory_guard_size, uint64_t)
 
 /**
- * \brief Configures the size, in bytes, of the extra virtual memory space reserved after a “dynamic” memory for growing into.
+ * \brief Configures the size, in bytes, of the extra virtual memory space
+ * reserved after a “dynamic” memory for growing into.
  *
  * For more information see the Rust documentation at
  * https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.dynamic_memory_reserved_for_growth
@@ -308,7 +351,8 @@ WASMTIME_CONFIG_PROP(void, dynamic_memory_guard_size, uint64_t)
 WASMTIME_CONFIG_PROP(void, dynamic_memory_reserved_for_growth, uint64_t)
 
 /**
- * \brief Configures whether to generate native unwind information (e.g. .eh_frame on Linux).
+ * \brief Configures whether to generate native unwind information (e.g.
+ * .eh_frame on Linux).
  *
  * This option defaults to true.
  *
@@ -317,6 +361,8 @@ WASMTIME_CONFIG_PROP(void, dynamic_memory_reserved_for_growth, uint64_t)
  */
 WASMTIME_CONFIG_PROP(void, native_unwind_info, bool)
 
+#ifdef WASMTIME_FEATURE_CACHE
+
 /**
  * \brief Enables Wasmtime's cache and loads configuration from the specified
  * path.
@@ -329,7 +375,12 @@ WASMTIME_CONFIG_PROP(void, native_unwind_info, bool)
  * An error is returned if the cache configuration could not be loaded or if the
  * cache could not be enabled.
  */
-WASM_API_EXTERN wasmtime_error_t* wasmtime_config_cache_config_load(wasm_config_t*, const char*);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_config_cache_config_load(wasm_config_t *, const char *);
+
+#endif // WASMTIME_FEATURE_CACHE
+
+#ifdef WASMTIME_FEATURE_COMPILER
 
 /**
  * \brief Configures the target triple that this configuration will produce
@@ -343,7 +394,7 @@ WASM_API_EXTERN wasmtime_error_t* wasmtime_config_cache_config_load(wasm_config_
  * For more information see the Rust documentation at
  * https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.config
  */
-WASMTIME_CONFIG_PROP(wasmtime_error_t*, target, const char*)
+WASMTIME_CONFIG_PROP(wasmtime_error_t *, target, const char *)
 
 /**
  * \brief Enables a target-specific flag in Cranelift.
@@ -354,7 +405,8 @@ WASMTIME_CONFIG_PROP(wasmtime_error_t*, target, const char*)
  * For more information see the Rust documentation at
  * https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.cranelift_flag_enable
  */
-WASM_API_EXTERN void wasmtime_config_cranelift_flag_enable(wasm_config_t*, const char*);
+WASM_API_EXTERN void wasmtime_config_cranelift_flag_enable(wasm_config_t *,
+                                                           const char *);
 
 /**
  * \brief Sets a target-specific flag in Cranelift to the specified value.
@@ -365,22 +417,34 @@ WASM_API_EXTERN void wasmtime_config_cranelift_flag_enable(wasm_config_t*, const
  * For more information see the Rust documentation at
  * https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.cranelift_flag_set
  */
-WASM_API_EXTERN void wasmtime_config_cranelift_flag_set(wasm_config_t*, const char *key, const char *value);
+WASM_API_EXTERN void wasmtime_config_cranelift_flag_set(wasm_config_t *,
+                                                        const char *key,
+                                                        const char *value);
+
+#endif // WASMTIME_FEATURE_COMPILER
 
+/**
+ * \brief Configures whether, when on macOS, Mach ports are used for exception
+ * handling instead of traditional Unix-based signal handling.
+ *
+ * This option defaults to true, using Mach ports by default.
+ *
+ * For more information see the Rust documentation at
+ * https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.macos_use_mach_ports
+ */
+WASMTIME_CONFIG_PROP(void, macos_use_mach_ports, bool)
 
 /**
  * Return the data from a LinearMemory instance.
  *
- * The size in bytes as well as the maximum number of bytes that can be allocated should be 
- * returned as well.
+ * The size in bytes as well as the maximum number of bytes that can be
+ * allocated should be returned as well.
  *
  * For more information about see the Rust documentation at
  * https://docs.wasmtime.dev/api/wasmtime/trait.LinearMemory.html
  */
-typedef uint8_t *(*wasmtime_memory_get_callback_t)(
-    void *env,
-    size_t *byte_size,
-    size_t *maximum_byte_size);
+typedef uint8_t *(*wasmtime_memory_get_callback_t)(void *env, size_t *byte_size,
+                                                   size_t *maximum_byte_size);
 
 /**
  * Grow the memory to the `new_size` in bytes.
@@ -388,9 +452,8 @@ typedef uint8_t *(*wasmtime_memory_get_callback_t)(
  * For more information about the parameters see the Rust documentation at
  * https://docs.wasmtime.dev/api/wasmtime/trait.LinearMemory.html#tymethod.grow_to
  */
-typedef wasmtime_error_t *(*wasmtime_memory_grow_callback_t)(
-    void *env,
-    size_t new_size);
+typedef wasmtime_error_t *(*wasmtime_memory_grow_callback_t)(void *env,
+                                                             size_t new_size);
 
 /**
  * A LinearMemory instance created from a #wasmtime_new_memory_callback_t.
@@ -398,7 +461,7 @@ typedef wasmtime_error_t *(*wasmtime_memory_grow_callback_t)(
  * For more information see the Rust documentation at
  * https://docs.wasmtime.dev/api/wasmtime/trait.LinearMemory.html
  */
-typedef struct {
+typedef struct wasmtime_linear_memory {
   /// User provided value to be passed to get_memory and grow_memory
   void *env;
   /// Callback to get the memory and size of this LinearMemory
@@ -406,14 +469,14 @@ typedef struct {
   /// Callback to request growing the memory
   wasmtime_memory_grow_callback_t grow_memory;
   /// An optional finalizer for env
-  void (*finalizer)(void*);
+  void (*finalizer)(void *);
 } wasmtime_linear_memory_t;
 
 /**
  * A callback to create a new LinearMemory from the specified parameters.
  *
- * The result should be written to `memory_ret` and wasmtime will own the values written 
- * into that struct.
+ * The result should be written to `memory_ret` and wasmtime will own the values
+ * written into that struct.
  *
  * This callback must be thread-safe.
  *
@@ -421,48 +484,64 @@ typedef struct {
  * https://docs.wasmtime.dev/api/wasmtime/trait.MemoryCreator.html#tymethod.new_memory
  */
 typedef wasmtime_error_t *(*wasmtime_new_memory_callback_t)(
-    void *env,
-    const wasm_memorytype_t *ty,
-    size_t minimum,
-    size_t maximum,
-    size_t reserved_size_in_bytes,
-    size_t guard_size_in_bytes,
+    void *env, const wasm_memorytype_t *ty, size_t minimum, size_t maximum,
+    size_t reserved_size_in_bytes, size_t guard_size_in_bytes,
     wasmtime_linear_memory_t *memory_ret);
 
 /**
- * A representation of custom memory creator and methods for an instance of LinearMemory.
+ * A representation of custom memory creator and methods for an instance of
+ * LinearMemory.
  *
  * For more information see the Rust documentation at
  * https://docs.wasmtime.dev/api/wasmtime/trait.MemoryCreator.html
  */
-typedef struct {
+typedef struct wasmtime_memory_creator {
   /// User provided value to be passed to new_memory
-  void* env;
+  void *env;
   /// The callback to create new memory, must be thread safe
   wasmtime_new_memory_callback_t new_memory;
   /// An optional finalizer for env.
-  void (*finalizer)(void*);
+  void (*finalizer)(void *);
 } wasmtime_memory_creator_t;
 
 /**
  * Sets a custom memory creator.
  *
- * Custom memory creators are used when creating host Memory objects or when creating instance
- * linear memories for the on-demand instance allocation strategy.
+ * Custom memory creators are used when creating host Memory objects or when
+ * creating instance linear memories for the on-demand instance allocation
+ * strategy.
  *
- * The config does **not** take ownership of the #wasmtime_memory_creator_t passed in, but 
- * instead copies all the values in the struct.
+ * The config does **not** take ownership of the #wasmtime_memory_creator_t
+ * passed in, but instead copies all the values in the struct.
  *
  * For more information see the Rust documentation at
  * https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.with_host_memory
  */
-WASM_API_EXTERN void wasmtime_config_host_memory_creator_set(
-    wasm_config_t*,
-    wasmtime_memory_creator_t*);
+WASM_API_EXTERN void
+wasmtime_config_host_memory_creator_set(wasm_config_t *,
+                                        wasmtime_memory_creator_t *);
+
+/**
+ * \brief Configures whether copy-on-write memory-mapped data is used to
+ * initialize a linear memory.
+ *
+ * Initializing linear memory via a copy-on-write mapping can drastically
+ * improve instantiation costs of a WebAssembly module because copying memory is
+ * deferred. Additionally if a page of memory is only ever read from WebAssembly
+ * and never written too then the same underlying page of data will be reused
+ * between all instantiations of a module meaning that if a module is
+ * instantiated many times this can lower the overall memory required needed to
+ * run that module.
+ *
+ * This option defaults to true.
+ *
+ * For more information see the Rust documentation at
+ * https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.memory_init_cow
+ */
+WASMTIME_CONFIG_PROP(void, memory_init_cow, bool)
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
 #endif // WASMTIME_CONFIG_H
-
diff --git a/crates/c-api/include/wasmtime/engine.h b/crates/c-api/include/wasmtime/engine.h
index 1b8336f4605e..6b666bf5f983 100644
--- a/crates/c-api/include/wasmtime/engine.h
+++ b/crates/c-api/include/wasmtime/engine.h
@@ -13,6 +13,14 @@
 extern "C" {
 #endif
 
+/**
+ * \brief Create a new reference to the same underlying engine.
+ *
+ * This function clones the reference-counted pointer to the internal object,
+ * and must be freed using #wasm_engine_delete.
+ */
+WASM_API_EXTERN wasm_engine_t *wasmtime_engine_clone(wasm_engine_t *engine);
+
 /**
  * \brief Increments the engine-local epoch variable.
  *
@@ -28,9 +36,7 @@ extern "C" {
 WASM_API_EXTERN void wasmtime_engine_increment_epoch(wasm_engine_t *engine);
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
 #endif // WASMTIME_ENGINE_H
-
-
diff --git a/crates/c-api/include/wasmtime/error.h b/crates/c-api/include/wasmtime/error.h
index 517755206759..ad9172543629 100644
--- a/crates/c-api/include/wasmtime/error.h
+++ b/crates/c-api/include/wasmtime/error.h
@@ -33,7 +33,7 @@ typedef struct wasmtime_error wasmtime_error_t;
 /**
  * \brief Creates a new error with the provided message.
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_error_new(const char*);
+WASM_API_EXTERN wasmtime_error_t *wasmtime_error_new(const char *);
 
 /**
  * \brief Deletes an error.
@@ -48,10 +48,8 @@ WASM_API_EXTERN void wasmtime_error_delete(wasmtime_error_t *error);
  * uninitialized before this function is called and the caller is responsible
  * for deallocating it with #wasm_byte_vec_delete afterwards.
  */
-WASM_API_EXTERN void wasmtime_error_message(
-    const wasmtime_error_t *error,
-    wasm_name_t *message
-);
+WASM_API_EXTERN void wasmtime_error_message(const wasmtime_error_t *error,
+                                            wasm_name_t *message);
 
 /**
  * \brief Attempts to extract a WASI-specific exit status from this error.
@@ -60,7 +58,8 @@ WASM_API_EXTERN void wasmtime_error_message(
  * If `true` is returned then the exit status is returned through the `status`
  * pointer. If `false` is returned then this is not a wasi exit trap.
  */
-WASM_API_EXTERN bool wasmtime_error_exit_status(const wasmtime_error_t*, int *status);
+WASM_API_EXTERN bool wasmtime_error_exit_status(const wasmtime_error_t *,
+                                                int *status);
 
 /**
  * \brief Attempts to extract a WebAssembly trace from this error.
@@ -69,10 +68,11 @@ WASM_API_EXTERN bool wasmtime_error_exit_status(const wasmtime_error_t*, int *st
  * as input. The `out` argument will be filled in with the wasm trace, if
  * present.
  */
-WASM_API_EXTERN void wasmtime_error_wasm_trace(const wasmtime_error_t*, wasm_frame_vec_t *out);
+WASM_API_EXTERN void wasmtime_error_wasm_trace(const wasmtime_error_t *,
+                                               wasm_frame_vec_t *out);
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
 #endif // WASMTIME_ERROR_H
diff --git a/crates/c-api/include/wasmtime/extern.h b/crates/c-api/include/wasmtime/extern.h
index 29dcb217feb6..347f2b51bddd 100644
--- a/crates/c-api/include/wasmtime/extern.h
+++ b/crates/c-api/include/wasmtime/extern.h
@@ -8,6 +8,7 @@
 #define WASMTIME_EXTERN_H
 
 #include <wasmtime/module.h>
+#include <wasmtime/sharedmemory.h>
 #include <wasmtime/store.h>
 
 #ifdef __cplusplus
@@ -16,58 +17,62 @@ extern "C" {
 
 /// \brief Representation of a function in Wasmtime.
 ///
-/// Functions are represented with a 64-bit identifying integer in Wasmtime.
-/// They do not have any destructor associated with them. Functions cannot
-/// interoperate between #wasmtime_store_t instances and if the wrong function
-/// is passed to the wrong store then it may trigger an assertion to abort the
-/// process.
+/// Functions in Wasmtime are represented as an index into a store and don't
+/// have any data or destructor associated with the #wasmtime_func_t value.
+/// Functions cannot interoperate between #wasmtime_store_t instances and if the
+/// wrong function is passed to the wrong store then it may trigger an assertion
+/// to abort the process.
 typedef struct wasmtime_func {
-  /// Internal identifier of what store this belongs to, never zero.
+  /// Internal identifier of what store this belongs to.
+  ///
+  /// This field may be zero when used in conjunction with #wasmtime_val_t
+  /// to represent a null `funcref` value in WebAssembly. For a valid function
+  /// this field is otherwise never zero.
   uint64_t store_id;
-  /// Internal index within the store.
-  size_t index;
+  /// Private field for Wasmtime, undefined if `store_id` is zero.
+  size_t __private;
 } wasmtime_func_t;
 
 /// \brief Representation of a table in Wasmtime.
 ///
-/// Tables are represented with a 64-bit identifying integer in Wasmtime.
-/// They do not have any destructor associated with them. Tables cannot
-/// interoperate between #wasmtime_store_t instances and if the wrong table
-/// is passed to the wrong store then it may trigger an assertion to abort the
-/// process.
+/// Tables in Wasmtime are represented as an index into a store and don't
+/// have any data or destructor associated with the #wasmtime_table_t value.
+/// Tables cannot interoperate between #wasmtime_store_t instances and if the
+/// wrong table is passed to the wrong store then it may trigger an assertion
+/// to abort the process.
 typedef struct wasmtime_table {
   /// Internal identifier of what store this belongs to, never zero.
   uint64_t store_id;
-  /// Internal index within the store.
-  size_t index;
+  /// Private field for Wasmtime.
+  size_t __private;
 } wasmtime_table_t;
 
 /// \brief Representation of a memory in Wasmtime.
 ///
-/// Memories are represented with a 64-bit identifying integer in Wasmtime.
-/// They do not have any destructor associated with them. Memories cannot
-/// interoperate between #wasmtime_store_t instances and if the wrong memory
-/// is passed to the wrong store then it may trigger an assertion to abort the
-/// process.
+/// Memories in Wasmtime are represented as an index into a store and don't
+/// have any data or destructor associated with the #wasmtime_memory_t value.
+/// Memories cannot interoperate between #wasmtime_store_t instances and if the
+/// wrong memory is passed to the wrong store then it may trigger an assertion
+/// to abort the process.
 typedef struct wasmtime_memory {
   /// Internal identifier of what store this belongs to, never zero.
   uint64_t store_id;
-  /// Internal index within the store.
-  size_t index;
+  /// Private field for Wasmtime.
+  size_t __private;
 } wasmtime_memory_t;
 
 /// \brief Representation of a global in Wasmtime.
 ///
-/// Globals are represented with a 64-bit identifying integer in Wasmtime.
-/// They do not have any destructor associated with them. Globals cannot
-/// interoperate between #wasmtime_store_t instances and if the wrong global
-/// is passed to the wrong store then it may trigger an assertion to abort the
-/// process.
+/// Globals in Wasmtime are represented as an index into a store and don't
+/// have any data or destructor associated with the #wasmtime_global_t value.
+/// Globals cannot interoperate between #wasmtime_store_t instances and if the
+/// wrong global is passed to the wrong store then it may trigger an assertion
+/// to abort the process.
 typedef struct wasmtime_global {
   /// Internal identifier of what store this belongs to, never zero.
   uint64_t store_id;
-  /// Internal index within the store.
-  size_t index;
+  /// Private field for Wasmtime.
+  size_t __private;
 } wasmtime_global_t;
 
 /// \brief Discriminant of #wasmtime_extern_t
@@ -85,6 +90,9 @@ typedef uint8_t wasmtime_extern_kind_t;
 /// \brief Value of #wasmtime_extern_kind_t meaning that #wasmtime_extern_t is a
 /// memory
 #define WASMTIME_EXTERN_MEMORY 3
+/// \brief Value of #wasmtime_extern_kind_t meaning that #wasmtime_extern_t is a
+/// shared memory
+#define WASMTIME_EXTERN_SHAREDMEMORY 4
 
 /**
  * \typedef wasmtime_extern_union_t
@@ -97,14 +105,16 @@ typedef uint8_t wasmtime_extern_kind_t;
  * various kinds of items an extern wasm item can be.
  */
 typedef union wasmtime_extern_union {
-    /// Field used if #wasmtime_extern_t::kind is #WASMTIME_EXTERN_FUNC
-    wasmtime_func_t func;
-    /// Field used if #wasmtime_extern_t::kind is #WASMTIME_EXTERN_GLOBAL
-    wasmtime_global_t global;
-    /// Field used if #wasmtime_extern_t::kind is #WASMTIME_EXTERN_TABLE
-    wasmtime_table_t table;
-    /// Field used if #wasmtime_extern_t::kind is #WASMTIME_EXTERN_MEMORY
-    wasmtime_memory_t memory;
+  /// Field used if #wasmtime_extern_t::kind is #WASMTIME_EXTERN_FUNC
+  wasmtime_func_t func;
+  /// Field used if #wasmtime_extern_t::kind is #WASMTIME_EXTERN_GLOBAL
+  wasmtime_global_t global;
+  /// Field used if #wasmtime_extern_t::kind is #WASMTIME_EXTERN_TABLE
+  wasmtime_table_t table;
+  /// Field used if #wasmtime_extern_t::kind is #WASMTIME_EXTERN_MEMORY
+  wasmtime_memory_t memory;
+  /// Field used if #wasmtime_extern_t::kind is #WASMTIME_EXTERN_SHAREDMEMORY
+  struct wasmtime_sharedmemory *sharedmemory;
 } wasmtime_extern_union_t;
 
 /**
@@ -121,10 +131,10 @@ typedef union wasmtime_extern_union {
  * deallocate the value.
  */
 typedef struct wasmtime_extern {
-    /// Discriminant of which field of #of is valid.
-    wasmtime_extern_kind_t kind;
-    /// Container for the extern item's value.
-    wasmtime_extern_union_t of;
+  /// Discriminant of which field of #of is valid.
+  wasmtime_extern_kind_t kind;
+  /// Container for the extern item's value.
+  wasmtime_extern_union_t of;
 } wasmtime_extern_t;
 
 /// \brief Deletes a #wasmtime_extern_t.
@@ -135,11 +145,11 @@ void wasmtime_extern_delete(wasmtime_extern_t *val);
 ///
 /// Does not take ownership of `context` or `val`, but the returned
 /// #wasm_externtype_t is an owned value that needs to be deleted.
-wasm_externtype_t *wasmtime_extern_type(wasmtime_context_t *context, wasmtime_extern_t *val);
+wasm_externtype_t *wasmtime_extern_type(wasmtime_context_t *context,
+                                        wasmtime_extern_t *val);
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
 #endif // WASMTIME_EXTERN_H
-
diff --git a/crates/c-api/include/wasmtime/func.h b/crates/c-api/include/wasmtime/func.h
index c5b927fd7923..41ff907c37cc 100644
--- a/crates/c-api/include/wasmtime/func.h
+++ b/crates/c-api/include/wasmtime/func.h
@@ -8,9 +8,9 @@
 #define WASMTIME_FUNC_H
 
 #include <wasm.h>
-#include <wasmtime/val.h>
-#include <wasmtime/store.h>
 #include <wasmtime/extern.h>
+#include <wasmtime/store.h>
+#include <wasmtime/val.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -54,13 +54,9 @@ typedef struct wasmtime_caller wasmtime_caller_t;
  * should be raised in WebAssembly. It's expected that in this case the caller
  * relinquishes ownership of the trap and it is passed back to the engine.
  */
-typedef wasm_trap_t* (*wasmtime_func_callback_t)(
-    void *env,
-    wasmtime_caller_t* caller,
-    const wasmtime_val_t *args,
-    size_t nargs,
-    wasmtime_val_t *results,
-    size_t nresults);
+typedef wasm_trap_t *(*wasmtime_func_callback_t)(
+    void *env, wasmtime_caller_t *caller, const wasmtime_val_t *args,
+    size_t nargs, wasmtime_val_t *results, size_t nresults);
 
 /**
  * \brief Creates a new host-defined function.
@@ -78,14 +74,11 @@ typedef wasm_trap_t* (*wasmtime_func_callback_t)(
  *
  * The returned function can only be used with the specified `store`.
  */
-WASM_API_EXTERN void wasmtime_func_new(
-  wasmtime_context_t *store,
-  const wasm_functype_t* type,
-  wasmtime_func_callback_t callback,
-  void *env,
-  void (*finalizer)(void*),
-  wasmtime_func_t *ret
-);
+WASM_API_EXTERN void wasmtime_func_new(wasmtime_context_t *store,
+                                       const wasm_functype_t *type,
+                                       wasmtime_func_callback_t callback,
+                                       void *env, void (*finalizer)(void *),
+                                       wasmtime_func_t *ret);
 
 /**
  * \brief Callback signature for #wasmtime_func_new_unchecked.
@@ -120,10 +113,8 @@ WASM_API_EXTERN void wasmtime_func_new(
  * array. Results are also written starting at index 0, which will overwrite
  * the arguments.
  */
-typedef wasm_trap_t* (*wasmtime_func_unchecked_callback_t)(
-    void *env,
-    wasmtime_caller_t* caller,
-    wasmtime_val_raw_t *args_and_results,
+typedef wasm_trap_t *(*wasmtime_func_unchecked_callback_t)(
+    void *env, wasmtime_caller_t *caller, wasmtime_val_raw_t *args_and_results,
     size_t num_args_and_results);
 
 /**
@@ -151,23 +142,18 @@ typedef wasm_trap_t* (*wasmtime_func_unchecked_callback_t)(
  * existence).
  */
 WASM_API_EXTERN void wasmtime_func_new_unchecked(
-  wasmtime_context_t *store,
-  const wasm_functype_t* type,
-  wasmtime_func_unchecked_callback_t callback,
-  void *env,
-  void (*finalizer)(void*),
-  wasmtime_func_t *ret
-);
+    wasmtime_context_t *store, const wasm_functype_t *type,
+    wasmtime_func_unchecked_callback_t callback, void *env,
+    void (*finalizer)(void *), wasmtime_func_t *ret);
 
 /**
  * \brief Returns the type of the function specified
  *
  * The returned #wasm_functype_t is owned by the caller.
  */
-WASM_API_EXTERN wasm_functype_t* wasmtime_func_type(
-    const wasmtime_context_t *store,
-    const wasmtime_func_t *func
-);
+WASM_API_EXTERN wasm_functype_t *
+wasmtime_func_type(const wasmtime_context_t *store,
+                   const wasmtime_func_t *func);
 
 /**
  * \brief Call a WebAssembly function.
@@ -204,15 +190,11 @@ WASM_API_EXTERN wasm_functype_t* wasmtime_func_type(
  * Does not take ownership of #wasmtime_val_t arguments. Gives ownership of
  * #wasmtime_val_t results.
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_func_call(
-    wasmtime_context_t *store,
-    const wasmtime_func_t *func,
-    const wasmtime_val_t *args,
-    size_t nargs,
-    wasmtime_val_t *results,
-    size_t nresults,
-    wasm_trap_t **trap
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_func_call(wasmtime_context_t *store, const wasmtime_func_t *func,
+                   const wasmtime_val_t *args, size_t nargs,
+                   wasmtime_val_t *results, size_t nresults,
+                   wasm_trap_t **trap);
 
 /**
  * \brief Call a WebAssembly function in an "unchecked" fashion.
@@ -243,13 +225,11 @@ WASM_API_EXTERN wasmtime_error_t *wasmtime_func_call(
  * faster than that function, but the tradeoff is that embeddings must uphold
  * more invariants rather than relying on Wasmtime to check them for you.
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_func_call_unchecked(
-    wasmtime_context_t *store,
-    const wasmtime_func_t *func,
-    wasmtime_val_raw_t *args_and_results,
-    size_t args_and_results_len,
-    wasm_trap_t **trap
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_func_call_unchecked(wasmtime_context_t *store,
+                             const wasmtime_func_t *func,
+                             wasmtime_val_raw_t *args_and_results,
+                             size_t args_and_results_len, wasm_trap_t **trap);
 
 /**
  * \brief Loads a #wasmtime_extern_t from the caller's context
@@ -269,17 +249,16 @@ WASM_API_EXTERN wasmtime_error_t *wasmtime_func_call_unchecked(
  * Returns a nonzero value if the export was found, or 0 if the export wasn't
  * found. If the export wasn't found then `item` isn't written to.
  */
-WASM_API_EXTERN bool wasmtime_caller_export_get(
-    wasmtime_caller_t *caller,
-    const char *name,
-    size_t name_len,
-    wasmtime_extern_t *item
-);
+WASM_API_EXTERN bool wasmtime_caller_export_get(wasmtime_caller_t *caller,
+                                                const char *name,
+                                                size_t name_len,
+                                                wasmtime_extern_t *item);
 
 /**
  * \brief Returns the store context of the caller object.
  */
-WASM_API_EXTERN wasmtime_context_t* wasmtime_caller_context(wasmtime_caller_t* caller);
+WASM_API_EXTERN wasmtime_context_t *
+wasmtime_caller_context(wasmtime_caller_t *caller);
 
 /**
  * \brief Converts a `raw` nonzero `funcref` value from #wasmtime_val_raw_t
@@ -294,21 +273,18 @@ WASM_API_EXTERN wasmtime_context_t* wasmtime_caller_context(wasmtime_caller_t* c
  * #wasmtime_context_t that they were produced from. Providing arbitrary values
  * to `raw` here or cross-context values with `context` is UB.
  */
-WASM_API_EXTERN void wasmtime_func_from_raw(
-    wasmtime_context_t* context,
-    void *raw,
-    wasmtime_func_t *ret);
+WASM_API_EXTERN void wasmtime_func_from_raw(wasmtime_context_t *context,
+                                            void *raw, wasmtime_func_t *ret);
 
 /**
  * \brief Converts a `func`  which belongs to `context` into a `usize`
  * parameter that is suitable for insertion into a #wasmtime_val_raw_t.
  */
-WASM_API_EXTERN void *wasmtime_func_to_raw(
-    wasmtime_context_t* context,
-    const wasmtime_func_t *func);
+WASM_API_EXTERN void *wasmtime_func_to_raw(wasmtime_context_t *context,
+                                           const wasmtime_func_t *func);
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
 #endif // WASMTIME_FUNC_H
diff --git a/crates/c-api/include/wasmtime/global.h b/crates/c-api/include/wasmtime/global.h
index 4e244285a57c..8b20af9150b8 100644
--- a/crates/c-api/include/wasmtime/global.h
+++ b/crates/c-api/include/wasmtime/global.h
@@ -33,22 +33,18 @@ extern "C" {
  * This function does not take ownership of any of its arguments but error is
  * owned by the caller.
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_global_new(
-    wasmtime_context_t *store,
-    const wasm_globaltype_t *type,
-    const wasmtime_val_t *val,
-    wasmtime_global_t *ret
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_global_new(wasmtime_context_t *store, const wasm_globaltype_t *type,
+                    const wasmtime_val_t *val, wasmtime_global_t *ret);
 
 /**
  * \brief Returns the wasm type of the specified global.
  *
  * The returned #wasm_globaltype_t is owned by the caller.
  */
-WASM_API_EXTERN wasm_globaltype_t* wasmtime_global_type(
-    const wasmtime_context_t *store,
-    const wasmtime_global_t *global
-);
+WASM_API_EXTERN wasm_globaltype_t *
+wasmtime_global_type(const wasmtime_context_t *store,
+                     const wasmtime_global_t *global);
 
 /**
  * \brief Get the value of the specified global.
@@ -58,13 +54,11 @@ WASM_API_EXTERN wasm_globaltype_t* wasmtime_global_type(
  * \param out where to store the value in this global.
  *
  * This function returns ownership of the contents of `out`, so
- * #wasmtime_val_delete may need to be called on the value.
+ * #wasmtime_val_unroot may need to be called on the value.
  */
-WASM_API_EXTERN void wasmtime_global_get(
-    wasmtime_context_t *store,
-    const wasmtime_global_t *global,
-    wasmtime_val_t *out
-);
+WASM_API_EXTERN void wasmtime_global_get(wasmtime_context_t *store,
+                                         const wasmtime_global_t *global,
+                                         wasmtime_val_t *out);
 
 /**
  * \brief Sets a global to a new value.
@@ -76,16 +70,15 @@ WASM_API_EXTERN void wasmtime_global_get(
  * This function may return an error if `global` is not mutable or if `val` has
  * the wrong type for `global`.
  *
- * THis does not take ownership of any argument but returns ownership of the error.
+ * THis does not take ownership of any argument but returns ownership of the
+ * error.
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_global_set(
-    wasmtime_context_t *store,
-    const wasmtime_global_t *global,
-    const wasmtime_val_t *val
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_global_set(wasmtime_context_t *store, const wasmtime_global_t *global,
+                    const wasmtime_val_t *val);
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
 #endif // WASMTIME_GLOBAL_H
diff --git a/crates/c-api/include/wasmtime/instance.h b/crates/c-api/include/wasmtime/instance.h
index 72f398ec9cff..0d63cfb7a421 100644
--- a/crates/c-api/include/wasmtime/instance.h
+++ b/crates/c-api/include/wasmtime/instance.h
@@ -62,14 +62,11 @@ typedef struct wasmtime_instance {
  * This function does not take ownership of any of its arguments, but all return
  * values are owned by the caller.
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_instance_new(
-    wasmtime_context_t *store,
-    const wasmtime_module_t *module,
-    const wasmtime_extern_t* imports,
-    size_t nimports,
-    wasmtime_instance_t *instance,
-    wasm_trap_t **trap
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_instance_new(wasmtime_context_t *store,
+                      const wasmtime_module_t *module,
+                      const wasmtime_extern_t *imports, size_t nimports,
+                      wasmtime_instance_t *instance, wasm_trap_t **trap);
 
 /**
  * \brief Get an export by name from an instance.
@@ -87,12 +84,8 @@ WASM_API_EXTERN wasmtime_error_t *wasmtime_instance_new(
  * #wasmtime_extern_t.
  */
 WASM_API_EXTERN bool wasmtime_instance_export_get(
-    wasmtime_context_t *store,
-    const wasmtime_instance_t *instance,
-    const char *name,
-    size_t name_len,
-    wasmtime_extern_t *item
-);
+    wasmtime_context_t *store, const wasmtime_instance_t *instance,
+    const char *name, size_t name_len, wasmtime_extern_t *item);
 
 /**
  * \brief Get an export by index from an instance.
@@ -113,16 +106,12 @@ WASM_API_EXTERN bool wasmtime_instance_export_get(
  * #wasmtime_context_t.
  */
 WASM_API_EXTERN bool wasmtime_instance_export_nth(
-    wasmtime_context_t *store,
-    const wasmtime_instance_t *instance,
-    size_t index,
-    char **name,
-    size_t *name_len,
-    wasmtime_extern_t *item
-);
+    wasmtime_context_t *store, const wasmtime_instance_t *instance,
+    size_t index, char **name, size_t *name_len, wasmtime_extern_t *item);
 
 /**
- * \brief A #wasmtime_instance_t, pre-instantiation, that is ready to be instantiated.
+ * \brief A #wasmtime_instance_t, pre-instantiation, that is ready to be
+ * instantiated.
  *
  * Must be deleted using #wasmtime_instance_pre_delete.
  *
@@ -135,7 +124,7 @@ typedef struct wasmtime_instance_pre wasmtime_instance_pre_t;
  * \brief Delete a previously created wasmtime_instance_pre_t.
  */
 WASM_API_EXTERN void
-wasmtime_instance_pre_delete(wasmtime_instance_pre_t *instance);
+wasmtime_instance_pre_delete(wasmtime_instance_pre_t *instance_pre);
 
 /**
  * \brief Instantiates instance within the given store.
@@ -160,14 +149,21 @@ wasmtime_instance_pre_delete(wasmtime_instance_pre_t *instance);
  * This function does not take ownership of any of its arguments, and all return
  * values are owned by the caller.
  */
-WASM_API_EXTERN wasmtime_error_t* wasmtime_instance_pre_instantiate(
-    const wasmtime_instance_pre_t* instance_pre,
-    wasmtime_store_t *store,
-    wasmtime_instance_t* instance,
-    wasm_trap_t **trap_ptr);
+WASM_API_EXTERN wasmtime_error_t *wasmtime_instance_pre_instantiate(
+    const wasmtime_instance_pre_t *instance_pre, wasmtime_store_t *store,
+    wasmtime_instance_t *instance, wasm_trap_t **trap_ptr);
+
+/**
+ * \brief Get the module (as a shallow clone) for a instance_pre.
+ *
+ * The returned module is owned by the caller and the caller **must**
+ * delete it via `wasmtime_module_delete`.
+ */
+WASM_API_EXTERN wasmtime_module_t *
+wasmtime_instance_pre_module(wasmtime_instance_pre_t *instance_pre);
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
 #endif // WASMTIME_INSTANCE_H
diff --git a/crates/c-api/include/wasmtime/linker.h b/crates/c-api/include/wasmtime/linker.h
index 3215efe9ff6c..0a793d1e6fc9 100644
--- a/crates/c-api/include/wasmtime/linker.h
+++ b/crates/c-api/include/wasmtime/linker.h
@@ -8,9 +8,10 @@
 #define WASMTIME_LINKER_H
 
 #include <wasm.h>
+#include <wasmtime/conf.h>
 #include <wasmtime/error.h>
-#include <wasmtime/store.h>
 #include <wasmtime/extern.h>
+#include <wasmtime/store.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -40,12 +41,21 @@ typedef struct wasmtime_linker wasmtime_linker_t;
  * This function does not take ownership of the engine argument, and the caller
  * is expected to delete the returned linker.
  */
-WASM_API_EXTERN wasmtime_linker_t* wasmtime_linker_new(wasm_engine_t* engine);
+WASM_API_EXTERN wasmtime_linker_t *wasmtime_linker_new(wasm_engine_t *engine);
+
+/**
+ * \brief Clones existing linker.
+ *
+ * This function does not take ownership of the linker argument, and the caller
+ * is expected to delete the returned linker.
+ */
+WASM_API_EXTERN wasmtime_linker_t *
+wasmtime_linker_clone(wasmtime_linker_t *linker);
 
 /**
  * \brief Deletes a linker
  */
-WASM_API_EXTERN void wasmtime_linker_delete(wasmtime_linker_t* linker);
+WASM_API_EXTERN void wasmtime_linker_delete(wasmtime_linker_t *linker);
 
 /**
  * \brief Configures whether this linker allows later definitions to shadow
@@ -53,7 +63,8 @@ WASM_API_EXTERN void wasmtime_linker_delete(wasmtime_linker_t* linker);
  *
  * By default this setting is `false`.
  */
-WASM_API_EXTERN void wasmtime_linker_allow_shadowing(wasmtime_linker_t* linker, bool allow_shadowing);
+WASM_API_EXTERN void wasmtime_linker_allow_shadowing(wasmtime_linker_t *linker,
+                                                     bool allow_shadowing);
 
 /**
  * \brief Defines a new item in this linker.
@@ -72,15 +83,10 @@ WASM_API_EXTERN void wasmtime_linker_allow_shadowing(wasmtime_linker_t* linker,
  * For more information about name resolution consult the [Rust
  * documentation](https://bytecodealliance.github.io/wasmtime/api/wasmtime/struct.Linker.html#name-resolution).
  */
-WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_define(
-    wasmtime_linker_t *linker,
-    wasmtime_context_t *store,
-    const char *module,
-    size_t module_len,
-    const char *name,
-    size_t name_len,
-    const wasmtime_extern_t *item
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_linker_define(wasmtime_linker_t *linker, wasmtime_context_t *store,
+                       const char *module, size_t module_len, const char *name,
+                       size_t name_len, const wasmtime_extern_t *item);
 
 /**
  * \brief Defines a new function in this linker.
@@ -92,7 +98,8 @@ WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_define(
  * \param name_len the byte length of `name`
  * \param ty the type of the function that's being defined
  * \param cb the host callback to invoke when the function is called
- * \param data the host-provided data to provide as the first argument to the callback
+ * \param data the host-provided data to provide as the first argument to the
+ *        callback
  * \param finalizer an optional finalizer for the `data` argument.
  *
  * \return On success `NULL` is returned, otherwise an error is returned which
@@ -107,17 +114,10 @@ WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_define(
  *
  * For more information about host callbacks see #wasmtime_func_new.
  */
-WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_define_func(
-    wasmtime_linker_t *linker,
-    const char *module,
-    size_t module_len,
-    const char *name,
-    size_t name_len,
-    const wasm_functype_t *ty,
-    wasmtime_func_callback_t cb,
-    void *data,
-    void (*finalizer)(void*)
-);
+WASM_API_EXTERN wasmtime_error_t *wasmtime_linker_define_func(
+    wasmtime_linker_t *linker, const char *module, size_t module_len,
+    const char *name, size_t name_len, const wasm_functype_t *ty,
+    wasmtime_func_callback_t cb, void *data, void (*finalizer)(void *));
 
 /**
  * \brief Defines a new function in this linker.
@@ -128,17 +128,13 @@ WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_define_func(
  * information as well as #wasmtime_func_new_unchecked for why this is an
  * unsafe API.
  */
-WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_define_func_unchecked(
-    wasmtime_linker_t *linker,
-    const char *module,
-    size_t module_len,
-    const char *name,
-    size_t name_len,
-    const wasm_functype_t *ty,
-    wasmtime_func_unchecked_callback_t cb,
-    void *data,
-    void (*finalizer)(void*)
-);
+WASM_API_EXTERN wasmtime_error_t *wasmtime_linker_define_func_unchecked(
+    wasmtime_linker_t *linker, const char *module, size_t module_len,
+    const char *name, size_t name_len, const wasm_functype_t *ty,
+    wasmtime_func_unchecked_callback_t cb, void *data,
+    void (*finalizer)(void *));
+
+#ifdef WASMTIME_FEATURE_WASI
 
 /**
  * \brief Defines WASI functions in this linker.
@@ -157,9 +153,10 @@ WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_define_func_unchecked(
  * For more information about name resolution consult the [Rust
  * documentation](https://bytecodealliance.github.io/wasmtime/api/wasmtime/struct.Linker.html#name-resolution).
  */
-WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_define_wasi(
-    wasmtime_linker_t *linker
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_linker_define_wasi(wasmtime_linker_t *linker);
+
+#endif // WASMTIME_FEATURE_WASI
 
 /**
  * \brief Defines an instance under the specified name in this linker.
@@ -180,13 +177,9 @@ WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_define_wasi(
  * For more information about name resolution consult the [Rust
  * documentation](https://bytecodealliance.github.io/wasmtime/api/wasmtime/struct.Linker.html#name-resolution).
  */
-WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_define_instance(
-    wasmtime_linker_t *linker,
-    wasmtime_context_t *store,
-    const char *name,
-    size_t name_len,
-    const wasmtime_instance_t *instance
-);
+WASM_API_EXTERN wasmtime_error_t *wasmtime_linker_define_instance(
+    wasmtime_linker_t *linker, wasmtime_context_t *store, const char *name,
+    size_t name_len, const wasmtime_instance_t *instance);
 
 /**
  * \brief Instantiates a #wasm_module_t with the items defined in this linker.
@@ -210,13 +203,11 @@ WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_define_instance(
  * defined in the linker than an error is returned. (or if the previously
  * defined item is of the wrong type).
  */
-WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_instantiate(
-    const wasmtime_linker_t *linker,
-    wasmtime_context_t *store,
-    const wasmtime_module_t *module,
-    wasmtime_instance_t *instance,
-    wasm_trap_t **trap
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_linker_instantiate(const wasmtime_linker_t *linker,
+                            wasmtime_context_t *store,
+                            const wasmtime_module_t *module,
+                            wasmtime_instance_t *instance, wasm_trap_t **trap);
 
 /**
  * \brief Defines automatic instantiations of a #wasm_module_t in this linker.
@@ -237,13 +228,10 @@ WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_instantiate(
  * For more information see the [Rust
  * documentation](https://bytecodealliance.github.io/wasmtime/api/wasmtime/struct.Linker.html#method.module).
  */
-WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_module(
-    wasmtime_linker_t *linker,
-    wasmtime_context_t *store,
-    const char *name,
-    size_t name_len,
-    const wasmtime_module_t *module
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_linker_module(wasmtime_linker_t *linker, wasmtime_context_t *store,
+                       const char *name, size_t name_len,
+                       const wasmtime_module_t *module);
 
 /**
  * \brief Acquires the "default export" of the named module in this linker.
@@ -260,13 +248,10 @@ WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_module(
  * For more information see the [Rust
  * documentation](https://bytecodealliance.github.io/wasmtime/api/wasmtime/struct.Linker.html#method.get_default).
  */
-WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_get_default(
-    const wasmtime_linker_t *linker,
-    wasmtime_context_t *store,
-    const char *name,
-    size_t name_len,
-    wasmtime_func_t *func
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_linker_get_default(const wasmtime_linker_t *linker,
+                            wasmtime_context_t *store, const char *name,
+                            size_t name_len, wasmtime_func_t *func);
 
 /**
  * \brief Loads an item by name from this linker.
@@ -282,18 +267,14 @@ WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_get_default(
  * \return A nonzero value if the item is defined, in which case `item` is also
  * filled in. Otherwise zero is returned.
  */
-WASM_API_EXTERN bool wasmtime_linker_get(
-    const wasmtime_linker_t *linker,
-    wasmtime_context_t *store,
-    const char *module,
-    size_t module_len,
-    const char *name,
-    size_t name_len,
-    wasmtime_extern_t *item
-);
+WASM_API_EXTERN bool wasmtime_linker_get(const wasmtime_linker_t *linker,
+                                         wasmtime_context_t *store,
+                                         const char *module, size_t module_len,
+                                         const char *name, size_t name_len,
+                                         wasmtime_extern_t *item);
 
 /**
- * \brief Preform all the checks for instantiating `module` with the linker,
+ * \brief Perform all the checks for instantiating `module` with the linker,
  *        except that instantiation doesn't actually finish.
  *
  * \param linker the linker used to instantiate the provided module.
@@ -305,13 +286,13 @@ WASM_API_EXTERN bool wasmtime_linker_get(
  * For more information see the Rust documentation at:
  * https://docs.wasmtime.dev/api/wasmtime/struct.Linker.html#method.instantiate_pre
  */
-WASM_API_EXTERN wasmtime_error_t* wasmtime_linker_instantiate_pre(
-    const wasmtime_linker_t *linker,
-    const wasmtime_module_t *module,
-    wasmtime_instance_t **instance_pre);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_linker_instantiate_pre(const wasmtime_linker_t *linker,
+                                const wasmtime_module_t *module,
+                                wasmtime_instance_pre_t **instance_pre);
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
 #endif // WASMTIME_LINKER_H
diff --git a/crates/c-api/include/wasmtime/memory.h b/crates/c-api/include/wasmtime/memory.h
index cda42c2b855a..53e82fcc65ed 100644
--- a/crates/c-api/include/wasmtime/memory.h
+++ b/crates/c-api/include/wasmtime/memory.h
@@ -8,9 +8,9 @@
 #define WASMTIME_MEMORY_H
 
 #include <wasm.h>
+#include <wasmtime/error.h>
 #include <wasmtime/extern.h>
 #include <wasmtime/store.h>
-#include <wasmtime/error.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -22,7 +22,10 @@ extern "C" {
  * Note that this function is preferred over #wasm_memorytype_new for
  * compatibility with the memory64 proposal.
  */
-WASM_API_EXTERN wasm_memorytype_t *wasmtime_memorytype_new(uint64_t min, bool max_present, uint64_t max, bool is_64);
+WASM_API_EXTERN wasm_memorytype_t *wasmtime_memorytype_new(uint64_t min,
+                                                           bool max_present,
+                                                           uint64_t max,
+                                                           bool is_64);
 
 /**
  * \brief Returns the minimum size, in pages, of the specified memory type.
@@ -30,7 +33,8 @@ WASM_API_EXTERN wasm_memorytype_t *wasmtime_memorytype_new(uint64_t min, bool ma
  * Note that this function is preferred over #wasm_memorytype_limits for
  * compatibility with the memory64 proposal.
  */
-WASM_API_EXTERN uint64_t wasmtime_memorytype_minimum(const wasm_memorytype_t *ty);
+WASM_API_EXTERN uint64_t
+wasmtime_memorytype_minimum(const wasm_memorytype_t *ty);
 
 /**
  * \brief Returns the maximum size, in pages, of the specified memory type.
@@ -42,13 +46,19 @@ WASM_API_EXTERN uint64_t wasmtime_memorytype_minimum(const wasm_memorytype_t *ty
  * Note that this function is preferred over #wasm_memorytype_limits for
  * compatibility with the memory64 proposal.
  */
-WASM_API_EXTERN bool wasmtime_memorytype_maximum(const wasm_memorytype_t *ty, uint64_t *max);
+WASM_API_EXTERN bool wasmtime_memorytype_maximum(const wasm_memorytype_t *ty,
+                                                 uint64_t *max);
 
 /**
  * \brief Returns whether this type of memory represents a 64-bit memory.
  */
 WASM_API_EXTERN bool wasmtime_memorytype_is64(const wasm_memorytype_t *ty);
 
+/**
+ * \brief Returns whether this type of memory represents a shared memory.
+ */
+WASM_API_EXTERN bool wasmtime_memorytype_isshared(const wasm_memorytype_t *ty);
+
 /**
  * \brief Creates a new WebAssembly linear memory
  *
@@ -59,43 +69,34 @@ WASM_API_EXTERN bool wasmtime_memorytype_is64(const wasm_memorytype_t *ty);
  * If an error happens when creating the memory it's returned and owned by the
  * caller. If an error happens then `ret` is not filled in.
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_memory_new(
-    wasmtime_context_t *store,
-    const wasm_memorytype_t* ty,
-    wasmtime_memory_t *ret
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_memory_new(wasmtime_context_t *store, const wasm_memorytype_t *ty,
+                    wasmtime_memory_t *ret);
 
 /**
  * \brief Returns the type of the memory specified
  */
-WASM_API_EXTERN wasm_memorytype_t* wasmtime_memory_type(
-    const wasmtime_context_t *store,
-    const wasmtime_memory_t *memory
-);
+WASM_API_EXTERN wasm_memorytype_t *
+wasmtime_memory_type(const wasmtime_context_t *store,
+                     const wasmtime_memory_t *memory);
 
 /**
  * \brief Returns the base pointer in memory where the linear memory starts.
  */
-WASM_API_EXTERN uint8_t *wasmtime_memory_data(
-    const wasmtime_context_t *store,
-    const wasmtime_memory_t *memory
-);
+WASM_API_EXTERN uint8_t *wasmtime_memory_data(const wasmtime_context_t *store,
+                                              const wasmtime_memory_t *memory);
 
 /**
  * \brief Returns the byte length of this linear memory.
  */
 WASM_API_EXTERN size_t wasmtime_memory_data_size(
-    const wasmtime_context_t *store,
-    const wasmtime_memory_t *memory
-);
+    const wasmtime_context_t *store, const wasmtime_memory_t *memory);
 
 /**
  * \brief Returns the length, in WebAssembly pages, of this linear memory
  */
-WASM_API_EXTERN uint64_t wasmtime_memory_size(
-    const wasmtime_context_t *store,
-    const wasmtime_memory_t *memory
-);
+WASM_API_EXTERN uint64_t wasmtime_memory_size(const wasmtime_context_t *store,
+                                              const wasmtime_memory_t *memory);
 
 /**
  * \brief Attempts to grow the specified memory by `delta` pages.
@@ -109,15 +110,12 @@ WASM_API_EXTERN uint64_t wasmtime_memory_size(
  * returned. Otherwise `prev_size` is set to the previous size of the memory, in
  * WebAssembly pages, and `NULL` is returned.
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_memory_grow(
-    wasmtime_context_t *store,
-    const wasmtime_memory_t *memory,
-    uint64_t delta,
-    uint64_t *prev_size
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_memory_grow(wasmtime_context_t *store, const wasmtime_memory_t *memory,
+                     uint64_t delta, uint64_t *prev_size);
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
 #endif // WASMTIME_MEMORY_H
diff --git a/crates/c-api/include/wasmtime/module.h b/crates/c-api/include/wasmtime/module.h
index 222239e81f66..286f784bd561 100644
--- a/crates/c-api/include/wasmtime/module.h
+++ b/crates/c-api/include/wasmtime/module.h
@@ -27,6 +27,8 @@ extern "C" {
  */
 typedef struct wasmtime_module wasmtime_module_t;
 
+#ifdef WASMTIME_FEATURE_COMPILER
+
 /**
  * \brief Compiles a WebAssembly binary into a #wasmtime_module_t
  *
@@ -41,12 +43,12 @@ typedef struct wasmtime_module wasmtime_module_t;
  * This function does not take ownership of any of its arguments, but the
  * returned error and module are owned by the caller.
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_module_new(
-    wasm_engine_t *engine,
-    const uint8_t *wasm,
-    size_t wasm_len,
-    wasmtime_module_t **ret
-);
+WASM_API_EXTERN wasmtime_error_t *wasmtime_module_new(wasm_engine_t *engine,
+                                                      const uint8_t *wasm,
+                                                      size_t wasm_len,
+                                                      wasmtime_module_t **ret);
+
+#endif // WASMTIME_FEATURE_COMPILER
 
 /**
  * \brief Deletes a module.
@@ -62,18 +64,16 @@ WASM_API_EXTERN wasmtime_module_t *wasmtime_module_clone(wasmtime_module_t *m);
 /**
  * \brief Same as #wasm_module_imports, but for #wasmtime_module_t.
  */
-WASM_API_EXTERN void wasmtime_module_imports(
-    const wasmtime_module_t *module,
-    wasm_importtype_vec_t *out
-);
+WASM_API_EXTERN void wasmtime_module_imports(const wasmtime_module_t *module,
+                                             wasm_importtype_vec_t *out);
 
 /**
  * \brief Same as #wasm_module_exports, but for #wasmtime_module_t.
  */
-WASM_API_EXTERN void wasmtime_module_exports(
-    const wasmtime_module_t *module,
-    wasm_exporttype_vec_t *out
-);
+WASM_API_EXTERN void wasmtime_module_exports(const wasmtime_module_t *module,
+                                             wasm_exporttype_vec_t *out);
+
+#ifdef WASMTIME_FEATURE_COMPILER
 
 /**
  * \brief Validate a WebAssembly binary.
@@ -87,18 +87,16 @@ WASM_API_EXTERN void wasmtime_module_exports(
  * If the binary validates then `NULL` is returned, otherwise the error returned
  * describes why the binary did not validate.
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_module_validate(
-    wasm_engine_t *engine,
-    const uint8_t *wasm,
-    size_t wasm_len
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_module_validate(wasm_engine_t *engine, const uint8_t *wasm,
+                         size_t wasm_len);
 
 /**
  * \brief This function serializes compiled module artifacts as blob data.
  *
  * \param module the module
- * \param ret if the conversion is successful, this byte vector is filled in with
- *   the serialized compiled module.
+ * \param ret if the conversion is successful, this byte vector is filled in
+ * with the serialized compiled module.
  *
  * \return a non-null error if parsing fails, or returns `NULL`. If parsing
  * fails then `ret` isn't touched.
@@ -106,10 +104,10 @@ WASM_API_EXTERN wasmtime_error_t *wasmtime_module_validate(
  * This function does not take ownership of `module`, and the caller is
  * expected to deallocate the returned #wasmtime_error_t and #wasm_byte_vec_t.
  */
-WASM_API_EXTERN wasmtime_error_t* wasmtime_module_serialize(
-    wasmtime_module_t* module,
-    wasm_byte_vec_t *ret
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_module_serialize(wasmtime_module_t *module, wasm_byte_vec_t *ret);
+
+#endif // WASMTIME_FEATURE_COMPILER
 
 /**
  * \brief Build a module from serialized data.
@@ -119,14 +117,11 @@ WASM_API_EXTERN wasmtime_error_t* wasmtime_module_serialize(
  *
  * This function is not safe to receive arbitrary user input. See the Rust
  * documentation for more information on what inputs are safe to pass in here
- * (e.g. only that of #wasmtime_module_serialize)
+ * (e.g. only that of `wasmtime_module_serialize`)
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_module_deserialize(
-    wasm_engine_t *engine,
-    const uint8_t *bytes,
-    size_t bytes_len,
-    wasmtime_module_t **ret
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_module_deserialize(wasm_engine_t *engine, const uint8_t *bytes,
+                            size_t bytes_len, wasmtime_module_t **ret);
 
 /**
  * \brief Deserialize a module from an on-disk file.
@@ -140,31 +135,29 @@ WASM_API_EXTERN wasmtime_error_t *wasmtime_module_deserialize(
  *
  * This function is not safe to receive arbitrary user input. See the Rust
  * documentation for more information on what inputs are safe to pass in here
- * (e.g. only that of #wasmtime_module_serialize)
+ * (e.g. only that of `wasmtime_module_serialize`)
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_module_deserialize_file(
-    wasm_engine_t *engine,
-    const char *path,
-    wasmtime_module_t **ret
-);
-
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_module_deserialize_file(wasm_engine_t *engine, const char *path,
+                                 wasmtime_module_t **ret);
 
 /**
- * \brief Returns the range of bytes in memory where this module’s compilation image resides.
+ * \brief Returns the range of bytes in memory where this module’s compilation
+ * image resides.
  *
- * The compilation image for a module contains executable code, data, debug information, etc. 
- * This is roughly the same as the wasmtime_module_serialize but not the exact same.
+ * The compilation image for a module contains executable code, data, debug
+ * information, etc. This is roughly the same as the wasmtime_module_serialize
+ * but not the exact same.
  *
- * For more details see: https://docs.wasmtime.dev/api/wasmtime/struct.Module.html#method.image_range
+ * For more details see:
+ * https://docs.wasmtime.dev/api/wasmtime/struct.Module.html#method.image_range
  */
-WASM_API_EXTERN void wasmtime_module_image_range(
-    const wasmtime_module_t *module,
-    size_t *start,
-    size_t *end
-);
+WASM_API_EXTERN void
+wasmtime_module_image_range(const wasmtime_module_t *module, void **start,
+                            void **end);
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
 #endif // WASMTIME_MODULE_H
diff --git a/crates/c-api/include/wasmtime/profiling.h b/crates/c-api/include/wasmtime/profiling.h
new file mode 100644
index 000000000000..55e95d37233e
--- /dev/null
+++ b/crates/c-api/include/wasmtime/profiling.h
@@ -0,0 +1,123 @@
+/**
+ * \file wasmtime/profiling.h
+ *
+ * \brief API for Wasmtime guest profiler
+ */
+
+#ifndef WASMTIME_PROFILING_H
+#define WASMTIME_PROFILING_H
+
+#include <wasm.h>
+#include <wasmtime/conf.h>
+#include <wasmtime/error.h>
+
+#ifdef WASMTIME_FEATURE_PROFILING
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * \brief Collects basic profiling data for a single WebAssembly guest.
+ *
+ * To use this, you’ll need to arrange to call #wasmtime_guestprofiler_sample at
+ * regular intervals while the guest is on the stack. The most straightforward
+ * way to do that is to call it from a callback registered with
+ * #wasmtime_store_epoch_deadline_callback.
+ *
+ * For more information see the Rust documentation at:
+ * https://docs.wasmtime.dev/api/wasmtime/struct.GuestProfiler.html
+ */
+typedef struct wasmtime_guestprofiler wasmtime_guestprofiler_t;
+
+/**
+ * \brief Deletes profiler without finishing it.
+ *
+ * \param guestprofiler profiler that is being deleted
+ */
+WASM_API_EXTERN void wasmtime_guestprofiler_delete(
+    /* own */ wasmtime_guestprofiler_t *guestprofiler);
+
+/**
+ * \typedef wasmtime_guestprofiler_modules_t
+ * \brief Alias to #wasmtime_guestprofiler_modules
+ *
+ * \struct #wasmtime_guestprofiler_modules
+ * \brief Tuple of name and module for passing into #wasmtime_guestprofiler_new.
+ */
+typedef struct wasmtime_guestprofiler_modules {
+  const wasm_name_t *name; //!< Name recorded in the profile.
+  const wasmtime_module_t
+      *mod; //!< Module that is being allowed to appear in captured stack trace.
+} wasmtime_guestprofiler_modules_t;
+
+/**
+ * \brief Begin profiling a new guest.
+ *
+ * \param module_name    name recorded in the profile
+ * \param interval_nanos intended sampling interval in nanoseconds recorded in
+ *                       the profile
+ * \param modules        modules and associated names that will appear in
+ *                       captured stack traces, pointer to the first element
+ * \param modules_len    count of elements in `modules`
+ *
+ * \return Created profiler that is owned by the caller.
+ *
+ * This function does not take ownership of the arguments.
+ *
+ * For more information see the Rust documentation at:
+ * https://docs.wasmtime.dev/api/wasmtime/struct.GuestProfiler.html#method.new
+ */
+WASM_API_EXTERN /* own */ wasmtime_guestprofiler_t *wasmtime_guestprofiler_new(
+    const wasm_name_t *module_name, uint64_t interval_nanos,
+    const wasmtime_guestprofiler_modules_t *modules, size_t modules_len);
+
+/**
+ * \brief Add a sample to the profile.
+ *
+ * \param guestprofiler the profiler the sample is being added to
+ * \param store         store that is being used to collect the backtraces
+ * \param delta_nanos   CPU time in nanoseconds that was used by this guest
+ *                      since the previous sample
+ *
+ * Zero can be passed as `delta_nanos` if recording CPU usage information
+ * is not needed.
+ * This function does not take ownership of the arguments.
+ *
+ * For more information see the Rust documentation at:
+ * https://docs.wasmtime.dev/api/wasmtime/struct.GuestProfiler.html#method.sample
+ */
+WASM_API_EXTERN void
+wasmtime_guestprofiler_sample(wasmtime_guestprofiler_t *guestprofiler,
+                              const wasmtime_store_t *store,
+                              uint64_t delta_nanos);
+
+/**
+ * \brief Writes out the captured profile.
+ *
+ * \param guestprofiler the profiler which is being finished and deleted
+ * \param out           pointer to where #wasm_byte_vec_t containing generated
+ *                      file will be written
+ *
+ * \return Returns #wasmtime_error_t owned by the caller in case of error,
+ * `NULL` otherwise.
+ *
+ * This function takes ownership of `guestprofiler`, even when error is
+ * returned.
+ * Only when returning without error `out` is filled with #wasm_byte_vec_t owned
+ * by the caller.
+ *
+ * For more information see the Rust documentation at:
+ * https://docs.wasmtime.dev/api/wasmtime/struct.GuestProfiler.html#method.finish
+ */
+WASM_API_EXTERN /* own */ wasmtime_error_t *
+wasmtime_guestprofiler_finish(/* own */ wasmtime_guestprofiler_t *guestprofiler,
+                              /* own */ wasm_byte_vec_t *out);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // WASMTIME_FEATURE_PROFILING
+
+#endif // WASMTIME_PROFILING_H
diff --git a/crates/c-api/include/wasmtime/sharedmemory.h b/crates/c-api/include/wasmtime/sharedmemory.h
new file mode 100644
index 000000000000..3065a0ef1ad2
--- /dev/null
+++ b/crates/c-api/include/wasmtime/sharedmemory.h
@@ -0,0 +1,108 @@
+/**
+ * \file wasmtime/sharedmemory.h
+ *
+ * Wasmtime API for interacting with wasm shared memories.
+ */
+
+#ifndef WASMTIME_SHAREDMEMORY_H
+#define WASMTIME_SHAREDMEMORY_H
+
+#include <wasm.h>
+#include <wasmtime/conf.h>
+#include <wasmtime/error.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * \brief Interface for shared memories.
+ *
+ * For more information see the Rust documentation at:
+ * https://docs.wasmtime.dev/api/wasmtime/struct.SharedMemory.html
+ */
+typedef struct wasmtime_sharedmemory wasmtime_sharedmemory_t;
+
+#ifdef WASMTIME_FEATURE_THREADS
+
+/**
+ * \brief Creates a new WebAssembly shared linear memory
+ *
+ * \param engine engine that created shared memory is associated with
+ * \param ty the type of the memory to create
+ * \param ret where to store the returned memory
+ *
+ * If an error happens when creating the memory it's returned and owned by the
+ * caller. If an error happens then `ret` is not filled in.
+ */
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_sharedmemory_new(const wasm_engine_t *engine,
+                          const wasm_memorytype_t *ty,
+                          wasmtime_sharedmemory_t **ret);
+
+#endif // WASMTIME_FEATURE_THREADS
+
+/**
+ * \brief Deletes shared linear memory
+ *
+ * \param memory memory to be deleted
+ */
+WASM_API_EXTERN void
+wasmtime_sharedmemory_delete(wasmtime_sharedmemory_t *memory);
+
+/**
+ * \brief Clones shared linear memory
+ *
+ * \param memory memory to be cloned
+ *
+ * This function makes shallow clone, ie. copy of reference counted
+ * memory handle.
+ */
+WASM_API_EXTERN wasmtime_sharedmemory_t *
+wasmtime_sharedmemory_clone(const wasmtime_sharedmemory_t *memory);
+
+/**
+ * \brief Returns the type of the shared memory specified
+ */
+WASM_API_EXTERN wasm_memorytype_t *
+wasmtime_sharedmemory_type(const wasmtime_sharedmemory_t *memory);
+
+/**
+ * \brief Returns the base pointer in memory where
+          the shared linear memory starts.
+ */
+WASM_API_EXTERN uint8_t *
+wasmtime_sharedmemory_data(const wasmtime_sharedmemory_t *memory);
+
+/**
+ * \brief Returns the byte length of this shared linear memory.
+ */
+WASM_API_EXTERN size_t
+wasmtime_sharedmemory_data_size(const wasmtime_sharedmemory_t *memory);
+
+/**
+ * \brief Returns the length, in WebAssembly pages, of this shared linear memory
+ */
+WASM_API_EXTERN uint64_t
+wasmtime_sharedmemory_size(const wasmtime_sharedmemory_t *memory);
+
+/**
+ * \brief Attempts to grow the specified shared memory by `delta` pages.
+ *
+ * \param memory the memory to grow
+ * \param delta the number of pages to grow by
+ * \param prev_size where to store the previous size of memory
+ *
+ * If memory cannot be grown then `prev_size` is left unchanged and an error is
+ * returned. Otherwise `prev_size` is set to the previous size of the memory, in
+ * WebAssembly pages, and `NULL` is returned.
+ */
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_sharedmemory_grow(const wasmtime_sharedmemory_t *memory,
+                           uint64_t delta, uint64_t *prev_size);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // WASMTIME_SHAREDMEMORY_H
diff --git a/crates/c-api/include/wasmtime/store.h b/crates/c-api/include/wasmtime/store.h
index c86ac57234e6..65613041c93c 100644
--- a/crates/c-api/include/wasmtime/store.h
+++ b/crates/c-api/include/wasmtime/store.h
@@ -7,8 +7,9 @@
 #ifndef WASMTIME_STORE_H
 #define WASMTIME_STORE_H
 
-#include <wasm.h>
 #include <wasi.h>
+#include <wasm.h>
+#include <wasmtime/conf.h>
 #include <wasmtime/error.h>
 
 #ifdef __cplusplus
@@ -43,8 +44,8 @@ typedef struct wasmtime_store wasmtime_store_t;
  * \brief An interior pointer into a #wasmtime_store_t which is used as
  * "context" for many functions.
  *
- * This context pointer is used pervasively throught Wasmtime's API. This can be
- * acquired from #wasmtime_store_context or #wasmtime_caller_context. The
+ * This context pointer is used pervasively throughout Wasmtime's API. This can
+ * be acquired from #wasmtime_store_context or #wasmtime_caller_context. The
  * context pointer for a store is the same for the entire lifetime of a store,
  * so it can safely be stored adjacent to a #wasmtime_store_t itself.
  *
@@ -68,16 +69,15 @@ typedef struct wasmtime_context wasmtime_context_t;
  * This function creates a fresh store with the provided configuration settings.
  * The returned store must be deleted with #wasmtime_store_delete.
  */
-WASM_API_EXTERN wasmtime_store_t *wasmtime_store_new(
-    wasm_engine_t *engine,
-    void *data,
-    void (*finalizer)(void*)
-);
+WASM_API_EXTERN wasmtime_store_t *wasmtime_store_new(wasm_engine_t *engine,
+                                                     void *data,
+                                                     void (*finalizer)(void *));
 
 /**
  * \brief Returns the interior #wasmtime_context_t pointer to this store
  */
-WASM_API_EXTERN wasmtime_context_t *wasmtime_store_context(wasmtime_store_t *store);
+WASM_API_EXTERN wasmtime_context_t *
+wasmtime_store_context(wasmtime_store_t *store);
 
 /**
  * \brief Provides limits for a store. Used by hosts to limit resource
@@ -108,14 +108,11 @@ WASM_API_EXTERN wasmtime_context_t *wasmtime_store_context(wasmtime_store_t *sto
  * resources in the future, this does not retroactively attempt to apply
  * limits to the store.
  */
-WASM_API_EXTERN void wasmtime_store_limiter(
-        wasmtime_store_t *store,
-        int64_t memory_size,
-        int64_t table_elements,
-        int64_t instances,
-        int64_t tables,
-        int64_t memories
-);
+WASM_API_EXTERN void wasmtime_store_limiter(wasmtime_store_t *store,
+                                            int64_t memory_size,
+                                            int64_t table_elements,
+                                            int64_t instances, int64_t tables,
+                                            int64_t memories);
 
 /**
  * \brief Deletes a store.
@@ -125,7 +122,8 @@ WASM_API_EXTERN void wasmtime_store_delete(wasmtime_store_t *store);
 /**
  * \brief Returns the user-specified data associated with the specified store
  */
-WASM_API_EXTERN void *wasmtime_context_get_data(const wasmtime_context_t* context);
+WASM_API_EXTERN void *
+wasmtime_context_get_data(const wasmtime_context_t *context);
 
 /**
  * \brief Overwrites the user-specified data associated with this store.
@@ -134,7 +132,8 @@ WASM_API_EXTERN void *wasmtime_context_get_data(const wasmtime_context_t* contex
  * and the original finalizer will be executed for the provided data when the
  * store is deleted.
  */
-WASM_API_EXTERN void wasmtime_context_set_data(wasmtime_context_t* context, void *data);
+WASM_API_EXTERN void wasmtime_context_set_data(wasmtime_context_t *context,
+                                               void *data);
 
 /**
  * \brief Perform garbage collection within the given context.
@@ -145,10 +144,10 @@ WASM_API_EXTERN void wasmtime_context_set_data(wasmtime_context_t* context, void
  *
  * The `context` argument must not be NULL.
  */
-WASM_API_EXTERN void wasmtime_context_gc(wasmtime_context_t* context);
+WASM_API_EXTERN void wasmtime_context_gc(wasmtime_context_t *context);
 
 /**
- * \brief Adds fuel to this context's store for wasm to consume while executing.
+ * \brief Set fuel to this context's store for wasm to consume while executing.
  *
  * For this method to work fuel consumption must be enabled via
  * #wasmtime_config_consume_fuel_set. By default a store starts with 0 fuel
@@ -156,53 +155,28 @@ WASM_API_EXTERN void wasmtime_context_gc(wasmtime_context_t* context);
  * This function must be called for the store to have
  * some fuel to allow WebAssembly to execute.
  *
- * Note that at this time when fuel is entirely consumed it will cause
- * wasm to trap. More usages of fuel are planned for the future.
+ * Note that when fuel is entirely consumed it will cause wasm to trap.
  *
  * If fuel is not enabled within this store then an error is returned. If fuel
  * is successfully added then NULL is returned.
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_context_add_fuel(wasmtime_context_t *store, uint64_t fuel);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_context_set_fuel(wasmtime_context_t *store, uint64_t fuel);
 
 /**
- * \brief Returns the amount of fuel consumed by this context's store execution
- * so far.
+ * \brief Returns the amount of fuel remaining in this context's store.
  *
  * If fuel consumption is not enabled via #wasmtime_config_consume_fuel_set
- * then this function will return false. Otherwise true is returned and the
+ * then this function will return an error. Otherwise `NULL` is returned and the
  * fuel parameter is filled in with fuel consumed so far.
  *
  * Also note that fuel, if enabled, must be originally configured via
- * #wasmtime_context_add_fuel.
+ * #wasmtime_context_set_fuel.
  */
-WASM_API_EXTERN bool wasmtime_context_fuel_consumed(const wasmtime_context_t *context, uint64_t *fuel);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_context_get_fuel(const wasmtime_context_t *context, uint64_t *fuel);
 
-/**
- * \brief Returns the amount of fuel remaining in this context's store execution
- * before engine traps execution.
- *
- * If fuel consumption is not enabled via #wasmtime_config_consume_fuel_set
- * then this function will return false. Otherwise true is returned and the
- * fuel parameter is filled in with remaining fuel.
- *
- * Also note that fuel, if enabled, must be originally configured via
- * #wasmtime_context_add_fuel.
- */
-WASM_API_EXTERN bool wasmtime_context_fuel_remaining(const wasmtime_context_t *context, uint64_t *fuel);
-
-/**
- * \brief Attempt to manually consume fuel from the store.
- *
- * If fuel consumption is not enabled via #wasmtime_config_consume_fuel_set then
- * this function will return an error. Otherwise this will attempt to consume
- * the specified amount of `fuel` from the store. If successful the remaining
- * amount of fuel is stored into `remaining`. If `fuel` couldn't be consumed
- * then an error is returned.
- *
- * Also note that fuel, if enabled, must be originally configured via
- * #wasmtime_context_add_fuel.
- */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_context_consume_fuel(wasmtime_context_t *context, uint64_t fuel, uint64_t *remaining);
+#ifdef WASMTIME_FEATURE_WASI
 
 /**
  * \brief Configures WASI state within the specified store.
@@ -215,7 +189,10 @@ WASM_API_EXTERN wasmtime_error_t *wasmtime_context_consume_fuel(wasmtime_context
  * of `wasi`. The caller should no longer use `wasi` after calling this function
  * (even if an error is returned).
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_context_set_wasi(wasmtime_context_t *context, wasi_config_t *wasi);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_context_set_wasi(wasmtime_context_t *context, wasi_config_t *wasi);
+
+#endif // WASMTIME_FEATURE_WASI
 
 /**
  * \brief Configures the relative deadline at which point WebAssembly code will
@@ -227,25 +204,46 @@ WASM_API_EXTERN wasmtime_error_t *wasmtime_context_set_wasi(wasmtime_context_t *
  * See also #wasmtime_config_epoch_interruption_set and
  * #wasmtime_store_epoch_deadline_callback.
  */
-WASM_API_EXTERN void wasmtime_context_set_epoch_deadline(wasmtime_context_t *context, uint64_t ticks_beyond_current);
+WASM_API_EXTERN void
+wasmtime_context_set_epoch_deadline(wasmtime_context_t *context,
+                                    uint64_t ticks_beyond_current);
+
+/// \brief An enum for the behavior before extending the epoch deadline.
+typedef uint8_t wasmtime_update_deadline_kind_t;
+/// \brief Directly continue to updating the deadline and executing WebAssembly.
+#define WASMTIME_UPDATE_DEADLINE_CONTINUE 0
+/// \brief Yield control (via async support) then update the deadline.
+#define WASMTIME_UPDATE_DEADLINE_YIELD 1
 
 /**
  * \brief Configures epoch deadline callback to C function.
  *
  * This function configures a store-local callback function that will be
  * called when the running WebAssembly function has exceeded its epoch
- * deadline. That function can return a #wasmtime_error_t to terminate
- * the function, or set the delta argument and return NULL to update the
- * epoch deadline and resume function execution.
+ * deadline. That function can:
+ * - return a #wasmtime_error_t to terminate the function
+ * - set the delta argument and return NULL to update the
+ *   epoch deadline delta and resume function execution.
+ * - set the delta argument, update the epoch deadline,
+ *   set update_kind to WASMTIME_UPDATE_DEADLINE_YIELD,
+ *   and return NULL to yield (via async support) and
+ *   resume function execution.
+ *
+ * To use WASMTIME_UPDATE_DEADLINE_YIELD async support must be enabled
+ * for this store.
  *
  * See also #wasmtime_config_epoch_interruption_set and
  * #wasmtime_context_set_epoch_deadline.
  */
-WASM_API_EXTERN void wasmtime_store_epoch_deadline_callback(wasmtime_store_t *store, wasmtime_error_t* (*func)(wasmtime_context_t*, void*, uint64_t*), void *data);
+WASM_API_EXTERN void wasmtime_store_epoch_deadline_callback(
+    wasmtime_store_t *store,
+    wasmtime_error_t *(*func)(wasmtime_context_t *context, void *data,
+                              uint64_t *epoch_deadline_delta,
+                              wasmtime_update_deadline_kind_t *update_kind),
+    void *data, void (*finalizer)(void *));
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
 #endif // WASMTIME_STORE_H
-
diff --git a/crates/c-api/include/wasmtime/table.h b/crates/c-api/include/wasmtime/table.h
index 630cee9ecae6..9ec8f3796c80 100644
--- a/crates/c-api/include/wasmtime/table.h
+++ b/crates/c-api/include/wasmtime/table.h
@@ -8,9 +8,9 @@
 #define WASMTIME_TABLE_H
 
 #include <wasm.h>
+#include <wasmtime/error.h>
 #include <wasmtime/extern.h>
 #include <wasmtime/store.h>
-#include <wasmtime/error.h>
 #include <wasmtime/val.h>
 
 #ifdef __cplusplus
@@ -29,22 +29,19 @@ extern "C" {
  * ownership of returned error. This function may return an error if the `init`
  * value does not match `ty`, for example.
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_table_new(
-    wasmtime_context_t *store,
-    const wasm_tabletype_t *ty,
-    const wasmtime_val_t *init,
-    wasmtime_table_t *table
-);
+WASM_API_EXTERN wasmtime_error_t *wasmtime_table_new(wasmtime_context_t *store,
+                                                     const wasm_tabletype_t *ty,
+                                                     const wasmtime_val_t *init,
+                                                     wasmtime_table_t *table);
 
 /**
  * \brief Returns the type of this table.
  *
  * The caller has ownership of the returned #wasm_tabletype_t
  */
-WASM_API_EXTERN wasm_tabletype_t* wasmtime_table_type(
-    const wasmtime_context_t *store,
-    const wasmtime_table_t *table
-);
+WASM_API_EXTERN wasm_tabletype_t *
+wasmtime_table_type(const wasmtime_context_t *store,
+                    const wasmtime_table_t *table);
 
 /**
  * \brief Gets a value in a table.
@@ -58,12 +55,9 @@ WASM_API_EXTERN wasm_tabletype_t* wasmtime_table_type(
  * returned then `val` is filled in and is owned by the caller. Otherwise zero
  * is returned because the `index` is out-of-bounds.
  */
-WASM_API_EXTERN bool wasmtime_table_get(
-    wasmtime_context_t *store,
-    const wasmtime_table_t *table,
-    uint32_t index,
-    wasmtime_val_t *val
-);
+WASM_API_EXTERN bool wasmtime_table_get(wasmtime_context_t *store,
+                                        const wasmtime_table_t *table,
+                                        uint32_t index, wasmtime_val_t *val);
 
 /**
  * \brief Sets a value in a table.
@@ -78,20 +72,15 @@ WASM_API_EXTERN bool wasmtime_table_get(
  * This function can fail if `value` has the wrong type for the table, or if
  * `index` is out of bounds.
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_table_set(
-    wasmtime_context_t *store,
-    const wasmtime_table_t *table,
-    uint32_t index,
-    const wasmtime_val_t *value
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_table_set(wasmtime_context_t *store, const wasmtime_table_t *table,
+                   uint32_t index, const wasmtime_val_t *value);
 
 /**
  * \brief Returns the size, in elements, of the specified table
  */
-WASM_API_EXTERN uint32_t wasmtime_table_size(
-    const wasmtime_context_t *store,
-    const wasmtime_table_t *table
-);
+WASM_API_EXTERN uint32_t wasmtime_table_size(const wasmtime_context_t *store,
+                                             const wasmtime_table_t *table);
 
 /**
  * \brief Grows a table.
@@ -110,17 +99,13 @@ WASM_API_EXTERN uint32_t wasmtime_table_size(
  *
  * This function does not take ownership of any of its arguments.
  */
-WASM_API_EXTERN wasmtime_error_t *wasmtime_table_grow(
-    wasmtime_context_t *store,
-    const wasmtime_table_t *table,
-    uint32_t delta,
-    const wasmtime_val_t *init,
-    uint32_t *prev_size
-);
+WASM_API_EXTERN wasmtime_error_t *
+wasmtime_table_grow(wasmtime_context_t *store, const wasmtime_table_t *table,
+                    uint32_t delta, const wasmtime_val_t *init,
+                    uint32_t *prev_size);
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
 #endif // WASMTIME_TABLE_H
-
diff --git a/crates/c-api/include/wasmtime/trap.h b/crates/c-api/include/wasmtime/trap.h
index 2d2e20407c20..0d2385bb008b 100644
--- a/crates/c-api/include/wasmtime/trap.h
+++ b/crates/c-api/include/wasmtime/trap.h
@@ -28,7 +28,8 @@ enum wasmtime_trap_code_enum {
   WASMTIME_TRAP_CODE_STACK_OVERFLOW,
   /// An out-of-bounds memory access.
   WASMTIME_TRAP_CODE_MEMORY_OUT_OF_BOUNDS,
-  /// A wasm atomic operation was presented with a not-naturally-aligned linear-memory address.
+  /// A wasm atomic operation was presented with a not-naturally-aligned
+  /// linear-memory address.
   WASMTIME_TRAP_CODE_HEAP_MISALIGNED,
   /// An out-of-bounds access to a table.
   WASMTIME_TRAP_CODE_TABLE_OUT_OF_BOUNDS,
@@ -69,7 +70,8 @@ WASM_API_EXTERN wasm_trap_t *wasmtime_trap_new(const char *msg, size_t msg_len);
  * an instruction trap -- traps can also be created using wasm_trap_new,
  * or occur with WASI modules exiting with a certain exit code.
  */
-WASM_API_EXTERN bool wasmtime_trap_code(const wasm_trap_t*, wasmtime_trap_code_t *code);
+WASM_API_EXTERN bool wasmtime_trap_code(const wasm_trap_t *,
+                                        wasmtime_trap_code_t *code);
 
 /**
  * \brief Returns a human-readable name for this frame's function.
@@ -79,7 +81,8 @@ WASM_API_EXTERN bool wasmtime_trap_code(const wasm_trap_t*, wasmtime_trap_code_t
  *
  * The lifetime of the returned name is the same as the #wasm_frame_t itself.
  */
-WASM_API_EXTERN const wasm_name_t *wasmtime_frame_func_name(const wasm_frame_t*);
+WASM_API_EXTERN const wasm_name_t *
+wasmtime_frame_func_name(const wasm_frame_t *);
 
 /**
  * \brief Returns a human-readable name for this frame's module.
@@ -89,11 +92,11 @@ WASM_API_EXTERN const wasm_name_t *wasmtime_frame_func_name(const wasm_frame_t*)
  *
  * The lifetime of the returned name is the same as the #wasm_frame_t itself.
  */
-WASM_API_EXTERN const wasm_name_t *wasmtime_frame_module_name(const wasm_frame_t*);
-
+WASM_API_EXTERN const wasm_name_t *
+wasmtime_frame_module_name(const wasm_frame_t *);
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
 #endif // WASMTIME_TRAP_H
diff --git a/crates/c-api/include/wasmtime/val.h b/crates/c-api/include/wasmtime/val.h
index 4c4081336a68..bdac5b9c7675 100644
--- a/crates/c-api/include/wasmtime/val.h
+++ b/crates/c-api/include/wasmtime/val.h
@@ -7,6 +7,7 @@
 #ifndef WASMTIME_VAL_H
 #define WASMTIME_VAL_H
 
+#include <stdalign.h>
 #include <wasm.h>
 #include <wasmtime/extern.h>
 
@@ -14,6 +15,141 @@
 extern "C" {
 #endif
 
+/**
+ * \typedef wasmtime_anyref_t
+ * \brief Convenience alias for #wasmtime_anyref
+ *
+ * \struct wasmtime_anyref
+ * \brief A WebAssembly value in the `any` hierarchy of GC types.
+ *
+ * This structure represents an `anyref` that WebAssembly can create and
+ * pass back to the host. The host can also create values to pass to a guest.
+ *
+ * Note that this structure does not itself contain the data that it refers to.
+ * Instead to contains metadata to point back within a #wasmtime_context_t, so
+ * referencing the internal data requires using a `wasmtime_context_t`.
+ *
+ * Anyref values are required to be explicitly unrooted via
+ * #wasmtime_anyref_unroot to enable them to be garbage-collected.
+ *
+ * Null anyref values are represented by this structure and can be tested and
+ * created with the `wasmtime_anyref_is_null` and `wasmtime_anyref_set_null`
+ * functions.
+ */
+typedef struct wasmtime_anyref {
+  /// Internal metadata tracking within the store, embedders should not
+  /// configure or modify these fields.
+  uint64_t store_id;
+  /// Internal to Wasmtime.
+  uint32_t __private1;
+  /// Internal to Wasmtime.
+  uint32_t __private2;
+} wasmtime_anyref_t;
+
+/// \brief Helper function to initialize the `ref` provided to a null anyref
+/// value.
+static inline void wasmtime_anyref_set_null(wasmtime_anyref_t *ref) {
+  ref->store_id = 0;
+}
+
+/// \brief Helper function to return whether the provided `ref` points to a null
+/// `anyref` value.
+///
+/// Note that `ref` itself should not be null as null is represented internally
+/// within a #wasmtime_anyref_t value.
+static inline bool wasmtime_anyref_is_null(const wasmtime_anyref_t *ref) {
+  return ref->store_id == 0;
+}
+
+/**
+ * \brief Creates a new reference pointing to the same data that `anyref`
+ * points to (depending on the configured collector this might increase a
+ * reference count or create a new GC root).
+ *
+ * The returned reference is stored in `out`.
+ */
+WASM_API_EXTERN void wasmtime_anyref_clone(wasmtime_context_t *context,
+                                           const wasmtime_anyref_t *anyref,
+                                           wasmtime_anyref_t *out);
+
+/**
+ * \brief Unroots the `ref` provided within the `context`.
+ *
+ * This API is required to enable the `ref` value provided to be
+ * garbage-collected. This API itself does not necessarily garbage-collect the
+ * value, but it's possible to collect it in the future after this.
+ *
+ * This may modify `ref` and the contents of `ref` are left in an undefined
+ * state after this API is called and it should no longer be used.
+ *
+ * Note that null or i32 anyref values do not need to be unrooted but are still
+ * valid to pass to this function.
+ */
+WASM_API_EXTERN void wasmtime_anyref_unroot(wasmtime_context_t *context,
+                                            wasmtime_anyref_t *ref);
+
+/**
+ * \brief Converts a raw `anyref` value coming from #wasmtime_val_raw_t into
+ * a #wasmtime_anyref_t.
+ *
+ * The provided `out` pointer is filled in with a reference converted from
+ * `raw`.
+ */
+WASM_API_EXTERN void wasmtime_anyref_from_raw(wasmtime_context_t *context,
+                                              uint32_t raw,
+                                              wasmtime_anyref_t *out);
+
+/**
+ * \brief Converts a #wasmtime_anyref_t to a raw value suitable for storing
+ * into a #wasmtime_val_raw_t.
+ *
+ * Note that the returned underlying value is not tracked by Wasmtime's garbage
+ * collector until it enters WebAssembly. This means that a GC may release the
+ * context's reference to the raw value, making the raw value invalid within the
+ * context of the store. Do not perform a GC between calling this function and
+ * passing it to WebAssembly.
+ */
+WASM_API_EXTERN uint32_t wasmtime_anyref_to_raw(wasmtime_context_t *context,
+                                                const wasmtime_anyref_t *ref);
+
+/**
+ * \brief Create a new `i31ref` value.
+ *
+ * Creates a new `i31ref` value (which is a subtype of `anyref`) and returns a
+ * pointer to it.
+ *
+ * If `i31val` does not fit in 31 bits, it is wrapped.
+ */
+WASM_API_EXTERN void wasmtime_anyref_from_i31(wasmtime_context_t *context,
+                                              uint32_t i31val,
+                                              wasmtime_anyref_t *out);
+
+/**
+ * \brief Get the `anyref`'s underlying `i31ref` value, zero extended, if any.
+ *
+ * If the given `anyref` is an instance of `i31ref`, then its value is zero
+ * extended to 32 bits, written to `dst`, and `true` is returned.
+ *
+ * If the given `anyref` is not an instance of `i31ref`, then `false` is
+ * returned and `dst` is left unmodified.
+ */
+WASM_API_EXTERN bool wasmtime_anyref_i31_get_u(wasmtime_context_t *context,
+                                               const wasmtime_anyref_t *anyref,
+                                               uint32_t *dst);
+
+/**
+ * \brief Get the `anyref`'s underlying `i31ref` value, sign extended, if any.
+ *
+ * If the given `anyref` is an instance of `i31ref`, then its value is sign
+ * extended to 32 bits, written to `dst`, and `true` is returned.
+ *
+ * If the given `anyref` is not an instance of `i31ref`, then `false` is
+ * returned and `dst` is left unmodified.
+ */
+WASM_API_EXTERN bool wasmtime_anyref_i31_get_s(wasmtime_context_t *context,
+                                               const wasmtime_anyref_t *anyref,
+                                               int32_t *dst);
+
 /**
  * \typedef wasmtime_externref_t
  * \brief Convenience alias for #wasmtime_externref
@@ -24,24 +160,65 @@ extern "C" {
  * This structure represents an `externref` that can be passed to WebAssembly.
  * It cannot be forged by WebAssembly itself and is guaranteed to have been
  * created by the host.
+ *
+ * This structure is similar to #wasmtime_anyref_t but represents the
+ * `externref` type in WebAssembly. This can be created on the host from
+ * arbitrary host pointers/destructors. Note that this value is itself a
+ * reference into a #wasmtime_context_t and must be explicitly unrooted to
+ * enable garbage collection.
+ *
+ * Note that null is represented with this structure and created with
+ * `wasmtime_externref_set_null`. Null can be tested for with the
+ * `wasmtime_externref_is_null` function.
  */
-typedef struct wasmtime_externref wasmtime_externref_t;
+typedef struct wasmtime_externref {
+  /// Internal metadata tracking within the store, embedders should not
+  /// configure or modify these fields.
+  uint64_t store_id;
+  /// Internal to Wasmtime.
+  uint32_t __private1;
+  /// Internal to Wasmtime.
+  uint32_t __private2;
+} wasmtime_externref_t;
+
+/// \brief Helper function to initialize the `ref` provided to a null externref
+/// value.
+static inline void wasmtime_externref_set_null(wasmtime_externref_t *ref) {
+  ref->store_id = 0;
+}
+
+/// \brief Helper function to return whether the provided `ref` points to a null
+/// `externref` value.
+///
+/// Note that `ref` itself should not be null as null is represented internally
+/// within a #wasmtime_externref_t value.
+static inline bool wasmtime_externref_is_null(const wasmtime_externref_t *ref) {
+  return ref->store_id == 0;
+}
 
 /**
  * \brief Create a new `externref` value.
  *
- * Creates a new `externref` value wrapping the provided data, returning the
- * pointer to the externref.
+ * Creates a new `externref` value wrapping the provided data, returning whether
+ * it was created or not.
  *
+ * \param context the store context to allocate this externref within
  * \param data the host-specific data to wrap
  * \param finalizer an optional finalizer for `data`
+ * \param out where to store the created value.
  *
  * When the reference is reclaimed, the wrapped data is cleaned up with the
  * provided `finalizer`.
  *
- * The returned value must be deleted with #wasmtime_externref_delete
+ * If `true` is returned then `out` has been filled in and must be unrooted
+ * in the future with #wasmtime_externref_unroot. If `false` is returned then
+ * the host wasn't able to create more GC values at this time. Performing a GC
+ * may free up enough space to try again.
  */
-WASM_API_EXTERN wasmtime_externref_t *wasmtime_externref_new(void *data, void (*finalizer)(void*));
+WASM_API_EXTERN bool wasmtime_externref_new(wasmtime_context_t *context,
+                                            void *data,
+                                            void (*finalizer)(void *),
+                                            wasmtime_externref_t *out);
 
 /**
  * \brief Get an `externref`'s wrapped data
@@ -49,28 +226,46 @@ WASM_API_EXTERN wasmtime_externref_t *wasmtime_externref_new(void *data, void (*
  * Returns the original `data` passed to #wasmtime_externref_new. It is required
  * that `data` is not `NULL`.
  */
-WASM_API_EXTERN void *wasmtime_externref_data(wasmtime_externref_t *data);
+WASM_API_EXTERN void *wasmtime_externref_data(wasmtime_context_t *context,
+                                              const wasmtime_externref_t *data);
 
 /**
- * \brief Creates a shallow copy of the `externref` argument, returning a
- * separately owned pointer (increases the reference count).
+ * \brief Creates a new reference pointing to the same data that `ref` points
+ * to (depending on the configured collector this might increase a reference
+ * count or create a new GC root).
+ *
+ * The `out` parameter stores the cloned reference. This reference must
+ * eventually be unrooted with #wasmtime_externref_unroot in the future to
+ * enable GC'ing it.
  */
-WASM_API_EXTERN wasmtime_externref_t *wasmtime_externref_clone(wasmtime_externref_t *ref);
+WASM_API_EXTERN void wasmtime_externref_clone(wasmtime_context_t *context,
+                                              const wasmtime_externref_t *ref,
+                                              wasmtime_externref_t *out);
 
 /**
- * \brief Decrements the reference count of the `ref`, deleting it if it's the
- * last reference.
+ * \brief Unroots the pointer `ref` from the `context` provided.
+ *
+ * This function will enable future garbage collection of the value pointed to
+ * by `ref` once there are no more references. The `ref` value may be mutated in
+ * place by this function and its contents are undefined after this function
+ * returns. It should not be used until after re-initializing it.
+ *
+ * Note that null externref values do not need to be unrooted but are still
+ * valid to pass to this function.
  */
-WASM_API_EXTERN void wasmtime_externref_delete(wasmtime_externref_t *ref);
+WASM_API_EXTERN void wasmtime_externref_unroot(wasmtime_context_t *context,
+                                               wasmtime_externref_t *ref);
 
 /**
  * \brief Converts a raw `externref` value coming from #wasmtime_val_raw_t into
  * a #wasmtime_externref_t.
  *
- * Note that the returned #wasmtime_externref_t is an owned value that must be
- * deleted via #wasmtime_externref_delete by the caller if it is non-null.
+ * The `out` reference is filled in with the non-raw version of this externref.
+ * It must eventually be unrooted with #wasmtime_externref_unroot.
  */
-WASM_API_EXTERN wasmtime_externref_t *wasmtime_externref_from_raw(wasmtime_context_t *context, void *raw);
+WASM_API_EXTERN void wasmtime_externref_from_raw(wasmtime_context_t *context,
+                                                 uint32_t raw,
+                                                 wasmtime_externref_t *out);
 
 /**
  * \brief Converts a #wasmtime_externref_t to a raw value suitable for storing
@@ -82,9 +277,8 @@ WASM_API_EXTERN wasmtime_externref_t *wasmtime_externref_from_raw(wasmtime_conte
  * context of the store. Do not perform a GC between calling this function and
  * passing it to WebAssembly.
  */
-WASM_API_EXTERN void *wasmtime_externref_to_raw(
-    wasmtime_context_t *context,
-    const wasmtime_externref_t *ref);
+WASM_API_EXTERN uint32_t wasmtime_externref_to_raw(
+    wasmtime_context_t *context, const wasmtime_externref_t *ref);
 
 /// \brief Discriminant stored in #wasmtime_val::kind
 typedef uint8_t wasmtime_valkind_t;
@@ -98,10 +292,15 @@ typedef uint8_t wasmtime_valkind_t;
 #define WASMTIME_F64 3
 /// \brief Value of #wasmtime_valkind_t meaning that #wasmtime_val_t is a v128
 #define WASMTIME_V128 4
-/// \brief Value of #wasmtime_valkind_t meaning that #wasmtime_val_t is a funcref
+/// \brief Value of #wasmtime_valkind_t meaning that #wasmtime_val_t is a
+/// funcref
 #define WASMTIME_FUNCREF 5
-/// \brief Value of #wasmtime_valkind_t meaning that #wasmtime_val_t is an externref
+/// \brief Value of #wasmtime_valkind_t meaning that #wasmtime_val_t is an
+/// externref
 #define WASMTIME_EXTERNREF 6
+/// \brief Value of #wasmtime_valkind_t meaning that #wasmtime_val_t is an
+/// anyref
+#define WASMTIME_ANYREF 7
 
 /// \brief A 128-bit value representing the WebAssembly `v128` type. Bytes are
 /// stored in little-endian order.
@@ -126,20 +325,37 @@ typedef union wasmtime_valunion {
   float32_t f32;
   /// Field used if #wasmtime_val_t::kind is #WASMTIME_F64
   float64_t f64;
+  /// Field used if #wasmtime_val_t::kind is #WASMTIME_ANYREF
+  wasmtime_anyref_t anyref;
+  /// Field used if #wasmtime_val_t::kind is #WASMTIME_EXTERNREF
+  wasmtime_externref_t externref;
   /// Field used if #wasmtime_val_t::kind is #WASMTIME_FUNCREF
   ///
-  /// If this value represents a `ref.null func` value then the `store_id` field
-  /// is set to zero.
+  /// Use `wasmtime_funcref_is_null` to test whether this is a null function
+  /// reference.
   wasmtime_func_t funcref;
-  /// Field used if #wasmtime_val_t::kind is #WASMTIME_EXTERNREF
-  ///
-  /// If this value represents a `ref.null extern` value then this pointer will
-  /// be `NULL`.
-  wasmtime_externref_t *externref;
   /// Field used if #wasmtime_val_t::kind is #WASMTIME_V128
   wasmtime_v128 v128;
 } wasmtime_valunion_t;
 
+/// \brief Initialize a `wasmtime_func_t` value as a null function reference.
+///
+/// This function will initialize the `func` provided to be a null function
+/// reference. Used in conjunction with #wasmtime_val_t and
+/// #wasmtime_valunion_t.
+static inline void wasmtime_funcref_set_null(wasmtime_func_t *func) {
+  func->store_id = 0;
+}
+
+/// \brief Helper function to test whether the `func` provided is a null
+/// function reference.
+///
+/// This function is used with #wasmtime_val_t and #wasmtime_valunion_t and its
+/// `funcref` field. This will test whether the field represents a null funcref.
+static inline bool wasmtime_funcref_is_null(const wasmtime_func_t *func) {
+  return func->store_id == 0;
+}
+
 /**
  * \typedef wasmtime_val_raw_t
  * \brief Convenience alias for #wasmtime_val_raw
@@ -174,13 +390,14 @@ typedef union wasmtime_val_raw {
   ///
   /// Note that this field is always stored in a little-endian format.
   wasmtime_v128 v128;
-  /// Field for when this val is a WebAssembly `funcref` value.
+  /// Field for when this val is a WebAssembly `anyref` value.
   ///
-  /// If this is set to 0 then it's a null funcref, otherwise this must be
-  /// passed to `wasmtime_func_from_raw` to determine the `wasmtime_func_t`.
+  /// If this is set to 0 then it's a null anyref, otherwise this must be
+  /// passed to `wasmtime_anyref_from_raw` to determine the
+  /// `wasmtime_anyref_t`.
   ///
   /// Note that this field is always stored in a little-endian format.
-  void *funcref;
+  uint32_t anyref;
   /// Field for when this val is a WebAssembly `externref` value.
   ///
   /// If this is set to 0 then it's a null externref, otherwise this must be
@@ -188,9 +405,26 @@ typedef union wasmtime_val_raw {
   /// `wasmtime_externref_t`.
   ///
   /// Note that this field is always stored in a little-endian format.
-  void *externref;
+  uint32_t externref;
+  /// Field for when this val is a WebAssembly `funcref` value.
+  ///
+  /// If this is set to 0 then it's a null funcref, otherwise this must be
+  /// passed to `wasmtime_func_from_raw` to determine the `wasmtime_func_t`.
+  ///
+  /// Note that this field is always stored in a little-endian format.
+  void *funcref;
 } wasmtime_val_raw_t;
 
+// Assert that the shape of this type is as expected since it needs to match
+// Rust.
+static inline void __wasmtime_val_assertions() {
+  static_assert(sizeof(wasmtime_valunion_t) == 16, "should be 16-bytes large");
+  static_assert(__alignof(wasmtime_valunion_t) == 8,
+                "should be 8-byte aligned");
+  static_assert(sizeof(wasmtime_val_raw_t) == 16, "should be 16 bytes large");
+  static_assert(__alignof(wasmtime_val_raw_t) == 8, "should be 8-byte aligned");
+}
+
 /**
  * \typedef wasmtime_val_t
  * \brief Convenience alias for #wasmtime_val_t
@@ -198,11 +432,11 @@ typedef union wasmtime_val_raw {
  * \union wasmtime_val
  * \brief Container for different kinds of wasm values.
  *
- * Note that this structure may contain an owned value, namely
- * #wasmtime_externref_t, depending on the context in which this is used. APIs
- * which consume a #wasmtime_val_t do not take ownership, but APIs that return
- * #wasmtime_val_t require that #wasmtime_val_delete is called to deallocate
- * the value.
+ * Note that this structure may contain an owned value, namely rooted GC
+ * references, depending on the context in which this is used. APIs which
+ * consume a #wasmtime_val_t do not take ownership, but APIs that return
+ * #wasmtime_val_t require that #wasmtime_val_unroot is called to clean up
+ * any possible GC roots in the value.
  */
 typedef struct wasmtime_val {
   /// Discriminant of which field of #of is valid.
@@ -212,21 +446,32 @@ typedef struct wasmtime_val {
 } wasmtime_val_t;
 
 /**
- * \brief Deletes an owned #wasmtime_val_t.
+ * \brief Unroot the value contained by `val`.
+ *
+ * This function will unroot any GC references that `val` points to, for
+ * example if it has the `WASMTIME_EXTERNREF` or `WASMTIME_ANYREF` kinds. This
+ * function leaves `val` in an undefined state and it should not be used again
+ * without re-initializing.
  *
- * Note that this only deletes the contents, not the memory that `val` points to
- * itself (which is owned by the caller).
+ * This method does not need to be called for integers, floats, v128, or
+ * funcref values.
  */
-WASM_API_EXTERN void wasmtime_val_delete(wasmtime_val_t *val);
+WASM_API_EXTERN void wasmtime_val_unroot(wasmtime_context_t *context,
+                                         wasmtime_val_t *val);
 
 /**
- * \brief Copies `src` into `dst`.
+ * \brief Clones the value pointed to by `src` into the `dst` provided.
+ *
+ * This function will clone any rooted GC values in `src` and have them
+ * newly rooted inside of `dst`. When using this API the `dst` should be
+ * later unrooted with #wasmtime_val_unroot if it contains GC values.
  */
-WASM_API_EXTERN void wasmtime_val_copy(wasmtime_val_t *dst, const wasmtime_val_t *src);
+WASM_API_EXTERN void wasmtime_val_clone(wasmtime_context_t *context,
+                                        const wasmtime_val_t *src,
+                                        wasmtime_val_t *dst);
 
 #ifdef __cplusplus
-}  // extern "C"
+} // extern "C"
 #endif
 
 #endif // WASMTIME_VAL_H
-
diff --git a/crates/c-api/macros/Cargo.toml b/crates/c-api/macros/Cargo.toml
deleted file mode 100644
index 33de12aa0ad4..000000000000
--- a/crates/c-api/macros/Cargo.toml
+++ /dev/null
@@ -1,16 +0,0 @@
-[package]
-name = "wasmtime-c-api-macros"
-version = "0.0.0"
-authors = ["The Wasmtime Project Developers"]
-license = "Apache-2.0 WITH LLVM-exception"
-edition.workspace = true
-publish = false
-
-[lib]
-proc-macro = true
-test = false
-doctest = false
-
-[dependencies]
-quote = "1.0"
-proc-macro2 = "1.0"
diff --git a/crates/c-api/macros/src/lib.rs b/crates/c-api/macros/src/lib.rs
deleted file mode 100644
index 9eb9bea4e31d..000000000000
--- a/crates/c-api/macros/src/lib.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-//! A set of convenience macros for our wasmtime-c-api crate.
-//!
-//! These are intended to mirror the macros in the `wasm.h` header file and
-//! largely facilitate the `declare_ref` macro.
-
-extern crate proc_macro;
-
-use proc_macro2::{Ident, TokenStream, TokenTree};
-use quote::quote;
-
-fn extract_ident(input: proc_macro::TokenStream) -> Ident {
-    let input = TokenStream::from(input);
-    let i = match input.into_iter().next().unwrap() {
-        TokenTree::Ident(i) => i,
-        _ => panic!("expected an ident"),
-    };
-    let name = i.to_string();
-    assert!(name.ends_with("_t"));
-    return i;
-}
-
-#[proc_macro]
-pub fn declare_own(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-    let ty = extract_ident(input);
-    let name = ty.to_string();
-    let delete = quote::format_ident!("{}_delete", &name[..name.len() - 2]);
-
-    (quote! {
-        #[no_mangle]
-        pub extern fn #delete(_: Box<#ty>) {}
-    })
-    .into()
-}
-
-#[proc_macro]
-pub fn declare_ty(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-    let ty = extract_ident(input);
-    let name = ty.to_string();
-    let copy = quote::format_ident!("{}_copy", &name[..name.len() - 2]);
-
-    (quote! {
-        wasmtime_c_api_macros::declare_own!(#ty);
-
-        #[no_mangle]
-        pub extern fn #copy(src: &#ty) -> Box<#ty> {
-            Box::new(src.clone())
-        }
-    })
-    .into()
-}
-
-#[proc_macro]
-pub fn declare_ref(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-    let ty = extract_ident(input);
-    let name = ty.to_string();
-    let prefix = &name[..name.len() - 2];
-    let copy = quote::format_ident!("{}_copy", prefix);
-    let same = quote::format_ident!("{}_same", prefix);
-    let get_host_info = quote::format_ident!("{}_get_host_info", prefix);
-    let set_host_info = quote::format_ident!("{}_set_host_info", prefix);
-    let set_host_info_final = quote::format_ident!("{}_set_host_info_with_finalizer", prefix);
-    let as_ref = quote::format_ident!("{}_as_ref", prefix);
-    let as_ref_const = quote::format_ident!("{}_as_ref_const", prefix);
-
-    (quote! {
-        wasmtime_c_api_macros::declare_own!(#ty);
-
-        #[no_mangle]
-        pub extern fn #copy(src: &#ty) -> Box<#ty> {
-            Box::new(src.clone())
-        }
-
-        #[no_mangle]
-        pub extern fn #same(_a: &#ty, _b: &#ty) -> bool {
-            eprintln!("`{}` is not implemented", stringify!(#same));
-            std::process::abort();
-        }
-
-        #[no_mangle]
-        pub extern fn #get_host_info(a: &#ty) -> *mut std::os::raw::c_void {
-            std::ptr::null_mut()
-        }
-
-        #[no_mangle]
-        pub extern fn #set_host_info(a: &#ty, info: *mut std::os::raw::c_void) {
-            eprintln!("`{}` is not implemented", stringify!(#set_host_info));
-            std::process::abort();
-        }
-
-        #[no_mangle]
-        pub extern fn #set_host_info_final(
-            a: &#ty,
-            info: *mut std::os::raw::c_void,
-            finalizer: Option<extern "C" fn(*mut std::os::raw::c_void)>,
-        ) {
-            eprintln!("`{}` is not implemented", stringify!(#set_host_info_final));
-            std::process::abort();
-        }
-
-        #[no_mangle]
-        pub extern fn #as_ref(a: &#ty) -> Box<crate::wasm_ref_t> {
-            eprintln!("`{}` is not implemented", stringify!(#as_ref));
-            std::process::abort();
-        }
-
-        #[no_mangle]
-        pub extern fn #as_ref_const(a: &#ty) -> Box<crate::wasm_ref_t> {
-            eprintln!("`{}` is not implemented", stringify!(#as_ref_const));
-            std::process::abort();
-        }
-
-        // TODO: implement `wasm_ref_as_#name#`
-        // TODO: implement `wasm_ref_as_#name#_const`
-    })
-    .into()
-}
diff --git a/crates/c-api/src/async.rs b/crates/c-api/src/async.rs
index 23572db32e22..ef577d87cded 100644
--- a/crates/c-api/src/async.rs
+++ b/crates/c-api/src/async.rs
@@ -1,16 +1,21 @@
 use std::ffi::c_void;
 use std::future::Future;
 use std::mem::{self, MaybeUninit};
+use std::num::NonZeroU64;
+use std::ops::Range;
 use std::pin::Pin;
+use std::sync::Arc;
 use std::task::{Context, Poll};
 use std::{ptr, str};
-
-use wasmtime::{AsContextMut, Caller, Func, Instance, Result, Trap, Val};
+use wasmtime::{
+    AsContextMut, Func, Instance, Result, RootScope, StackCreator, StackMemory, Trap, Val,
+};
 
 use crate::{
     bad_utf8, handle_result, to_str, translate_args, wasm_config_t, wasm_functype_t, wasm_trap_t,
     wasmtime_caller_t, wasmtime_error_t, wasmtime_instance_pre_t, wasmtime_linker_t,
-    wasmtime_module_t, wasmtime_val_t, wasmtime_val_union, CStoreContextMut, WASMTIME_I32,
+    wasmtime_module_t, wasmtime_val_t, wasmtime_val_union, WasmtimeCaller, WasmtimeStoreContextMut,
+    WASMTIME_I32,
 };
 
 #[no_mangle]
@@ -25,19 +30,21 @@ pub extern "C" fn wasmtime_config_async_stack_size_set(c: &mut wasm_config_t, si
 
 #[no_mangle]
 pub extern "C" fn wasmtime_context_epoch_deadline_async_yield_and_update(
-    mut store: CStoreContextMut<'_>,
+    mut store: WasmtimeStoreContextMut<'_>,
     delta: u64,
 ) {
     store.epoch_deadline_async_yield_and_update(delta);
 }
 
 #[no_mangle]
-pub extern "C" fn wasmtime_context_out_of_fuel_async_yield(
-    mut store: CStoreContextMut<'_>,
-    injection_count: u64,
-    fuel_to_inject: u64,
-) {
-    store.out_of_fuel_async_yield(injection_count, fuel_to_inject);
+pub extern "C" fn wasmtime_context_fuel_async_yield_interval(
+    mut store: WasmtimeStoreContextMut<'_>,
+    interval: Option<NonZeroU64>,
+) -> Option<Box<wasmtime_error_t>> {
+    handle_result(
+        store.fuel_async_yield_interval(interval.map(|n| n.get())),
+        |()| {},
+    )
 }
 
 pub type wasmtime_func_async_callback_t = extern "C" fn(
@@ -80,17 +87,23 @@ impl Future for wasmtime_async_continuation_t {
     }
 }
 
-pub type wasmtime_func_async_continuation_callback_t = extern "C" fn(*mut c_void) -> bool;
-
-struct CallbackData {
-    env: *mut c_void,
+/// Internal structure to add Send/Sync to a c_void member.
+///
+/// This is useful in closures that need to capture some C data.
+#[derive(Debug)]
+struct CallbackDataPtr {
+    pub ptr: *mut std::ffi::c_void,
 }
-unsafe impl Send for CallbackData {}
+
+unsafe impl Send for CallbackDataPtr {}
+unsafe impl Sync for CallbackDataPtr {}
+
+pub type wasmtime_func_async_continuation_callback_t = extern "C" fn(*mut c_void) -> bool;
 
 async fn invoke_c_async_callback<'a>(
     cb: wasmtime_func_async_callback_t,
-    data: CallbackData,
-    mut caller: Caller<'a, crate::StoreData>,
+    data: CallbackDataPtr,
+    mut caller: WasmtimeCaller<'a>,
     params: &'a [Val],
     results: &'a mut [Val],
 ) -> Result<()> {
@@ -100,7 +113,12 @@ async fn invoke_c_async_callback<'a>(
     let mut hostcall_val_storage = mem::take(&mut caller.data_mut().hostcall_val_storage);
     debug_assert!(hostcall_val_storage.is_empty());
     hostcall_val_storage.reserve(params.len() + results.len());
-    hostcall_val_storage.extend(params.iter().cloned().map(|p| wasmtime_val_t::from_val(p)));
+    hostcall_val_storage.extend(
+        params
+            .iter()
+            .cloned()
+            .map(|p| wasmtime_val_t::from_val_unscoped(&mut caller, p)),
+    );
     hostcall_val_storage.extend((0..results.len()).map(|_| wasmtime_val_t {
         kind: WASMTIME_I32,
         of: wasmtime_val_union { i32: 0 },
@@ -108,7 +126,7 @@ async fn invoke_c_async_callback<'a>(
     let (params, out_results) = hostcall_val_storage.split_at_mut(params.len());
 
     // Invoke the C function pointer.
-    // The result will be a continutation which we will wrap in a Future.
+    // The result will be a continuation which we will wrap in a Future.
     let mut caller = wasmtime_caller_t { caller };
     let mut trap = None;
     extern "C" fn panic_callback(_: *mut c_void) -> bool {
@@ -120,7 +138,7 @@ async fn invoke_c_async_callback<'a>(
         finalizer: None,
     };
     cb(
-        data.env,
+        data.ptr,
         &mut caller,
         params.as_ptr(),
         params.len(),
@@ -138,7 +156,7 @@ async fn invoke_c_async_callback<'a>(
     // Translate the `wasmtime_val_t` results into the `results` space
     for (i, result) in out_results.iter().enumerate() {
         unsafe {
-            results[i] = result.to_val();
+            results[i] = result.to_val_unscoped(&mut caller.caller);
         }
     }
     // Move our `vals` storage back into the store now that we no longer
@@ -154,7 +172,7 @@ unsafe fn c_async_callback_to_rust_fn(
     data: *mut c_void,
     finalizer: Option<extern "C" fn(*mut std::ffi::c_void)>,
 ) -> impl for<'a> Fn(
-    Caller<'a, crate::StoreData>,
+    WasmtimeCaller<'a>,
     &'a [Val],
     &'a mut [Val],
 ) -> Box<dyn Future<Output = Result<()>> + Send + 'a>
@@ -164,7 +182,7 @@ unsafe fn c_async_callback_to_rust_fn(
     let foreign = crate::ForeignData { data, finalizer };
     move |caller, params, results| {
         let _ = &foreign; // move entire foreign into this closure
-        let data = CallbackData { env: foreign.data };
+        let data = CallbackDataPtr { ptr: foreign.data };
         Box::new(invoke_c_async_callback(
             callback, data, caller, params, results,
         ))
@@ -201,25 +219,24 @@ fn handle_call_error(
 }
 
 async fn do_func_call_async(
-    mut store: CStoreContextMut<'_>,
+    mut store: RootScope<WasmtimeStoreContextMut<'_>>,
     func: &Func,
     args: impl ExactSizeIterator<Item = Val>,
     results: &mut [MaybeUninit<wasmtime_val_t>],
     trap_ret: &mut *mut wasm_trap_t,
     err_ret: &mut *mut wasmtime_error_t,
 ) {
-    let mut store = store.as_context_mut();
-    let mut params = mem::take(&mut store.data_mut().wasm_val_storage);
+    let mut params = mem::take(&mut store.as_context_mut().data_mut().wasm_val_storage);
     let (wt_params, wt_results) = translate_args(&mut params, args, results.len());
     let result = func.call_async(&mut store, wt_params, wt_results).await;
 
     match result {
         Ok(()) => {
             for (slot, val) in results.iter_mut().zip(wt_results.iter()) {
-                crate::initialize(slot, wasmtime_val_t::from_val(val.clone()));
+                crate::initialize(slot, wasmtime_val_t::from_val(&mut store, *val));
             }
             params.truncate(0);
-            store.data_mut().wasm_val_storage = params;
+            store.as_context_mut().data_mut().wasm_val_storage = params;
         }
         Err(err) => handle_call_error(err, trap_ret, err_ret),
     }
@@ -227,7 +244,7 @@ async fn do_func_call_async(
 
 #[no_mangle]
 pub unsafe extern "C" fn wasmtime_func_call_async<'a>(
-    store: CStoreContextMut<'a>,
+    store: WasmtimeStoreContextMut<'a>,
     func: &'a Func,
     args: *const wasmtime_val_t,
     nargs: usize,
@@ -236,12 +253,19 @@ pub unsafe extern "C" fn wasmtime_func_call_async<'a>(
     trap_ret: &'a mut *mut wasm_trap_t,
     err_ret: &'a mut *mut wasmtime_error_t,
 ) -> Box<wasmtime_call_future_t<'a>> {
+    let mut scope = RootScope::new(store);
     let args = crate::slice_from_raw_parts(args, nargs)
         .iter()
-        .map(|i| i.to_val());
+        .map(|i| i.to_val(&mut scope))
+        .collect::<Vec<_>>();
     let results = crate::slice_from_raw_parts_mut(results, nresults);
     let fut = Box::pin(do_func_call_async(
-        store, func, args, results, trap_ret, err_ret,
+        scope,
+        func,
+        args.into_iter(),
+        results,
+        trap_ret,
+        err_ret,
     ));
     Box::new(wasmtime_call_future_t { underlying: fut })
 }
@@ -258,7 +282,7 @@ pub unsafe extern "C" fn wasmtime_linker_define_async_func(
     data: *mut c_void,
     finalizer: Option<extern "C" fn(*mut std::ffi::c_void)>,
 ) -> Option<Box<wasmtime_error_t>> {
-    let ty = ty.ty().ty.clone();
+    let ty = ty.ty().ty(linker.linker.engine());
     let module = to_str!(module, module_len);
     let name = to_str!(name, name_len);
     let cb = c_async_callback_to_rust_fn(callback, data, finalizer);
@@ -271,7 +295,7 @@ pub unsafe extern "C" fn wasmtime_linker_define_async_func(
 
 async fn do_linker_instantiate_async(
     linker: &wasmtime_linker_t,
-    store: CStoreContextMut<'_>,
+    store: WasmtimeStoreContextMut<'_>,
     module: &wasmtime_module_t,
     instance_ptr: &mut Instance,
     trap_ret: &mut *mut wasm_trap_t,
@@ -287,7 +311,7 @@ async fn do_linker_instantiate_async(
 #[no_mangle]
 pub extern "C" fn wasmtime_linker_instantiate_async<'a>(
     linker: &'a wasmtime_linker_t,
-    store: CStoreContextMut<'a>,
+    store: WasmtimeStoreContextMut<'a>,
     module: &'a wasmtime_module_t,
     instance_ptr: &'a mut Instance,
     trap_ret: &'a mut *mut wasm_trap_t,
@@ -306,7 +330,7 @@ pub extern "C" fn wasmtime_linker_instantiate_async<'a>(
 
 async fn do_instance_pre_instantiate_async(
     instance_pre: &wasmtime_instance_pre_t,
-    store: CStoreContextMut<'_>,
+    store: WasmtimeStoreContextMut<'_>,
     instance_ptr: &mut Instance,
     trap_ret: &mut *mut wasm_trap_t,
     err_ret: &mut *mut wasmtime_error_t,
@@ -321,7 +345,7 @@ async fn do_instance_pre_instantiate_async(
 #[no_mangle]
 pub extern "C" fn wasmtime_instance_pre_instantiate_async<'a>(
     instance_pre: &'a wasmtime_instance_pre_t,
-    store: CStoreContextMut<'a>,
+    store: WasmtimeStoreContextMut<'a>,
     instance_ptr: &'a mut Instance,
     trap_ret: &'a mut *mut wasm_trap_t,
     err_ret: &'a mut *mut wasmtime_error_t,
@@ -335,3 +359,92 @@ pub extern "C" fn wasmtime_instance_pre_instantiate_async<'a>(
     ));
     Box::new(crate::wasmtime_call_future_t { underlying: fut })
 }
+
+pub type wasmtime_stack_memory_get_callback_t =
+    extern "C" fn(env: *mut std::ffi::c_void, out_len: &mut usize) -> *mut u8;
+
+#[repr(C)]
+pub struct wasmtime_stack_memory_t {
+    env: *mut std::ffi::c_void,
+    get_stack_memory: wasmtime_stack_memory_get_callback_t,
+    finalizer: Option<extern "C" fn(arg1: *mut std::ffi::c_void)>,
+}
+
+struct CHostStackMemory {
+    foreign: crate::ForeignData,
+    get_memory: wasmtime_stack_memory_get_callback_t,
+}
+unsafe impl Send for CHostStackMemory {}
+unsafe impl Sync for CHostStackMemory {}
+unsafe impl StackMemory for CHostStackMemory {
+    fn top(&self) -> *mut u8 {
+        let mut len = 0;
+        let cb = self.get_memory;
+        cb(self.foreign.data, &mut len)
+    }
+    fn range(&self) -> Range<usize> {
+        let mut len = 0;
+        let cb = self.get_memory;
+        let top = cb(self.foreign.data, &mut len);
+        let base = unsafe { top.sub(len) as usize };
+        base..base + len
+    }
+}
+
+pub type wasmtime_new_stack_memory_callback_t = extern "C" fn(
+    env: *mut std::ffi::c_void,
+    size: usize,
+    stack_ret: &mut wasmtime_stack_memory_t,
+) -> Option<Box<wasmtime_error_t>>;
+
+#[repr(C)]
+pub struct wasmtime_stack_creator_t {
+    env: *mut std::ffi::c_void,
+    new_stack: wasmtime_new_stack_memory_callback_t,
+    finalizer: Option<extern "C" fn(arg1: *mut std::ffi::c_void)>,
+}
+
+struct CHostStackCreator {
+    foreign: crate::ForeignData,
+    new_stack: wasmtime_new_stack_memory_callback_t,
+}
+unsafe impl Send for CHostStackCreator {}
+unsafe impl Sync for CHostStackCreator {}
+unsafe impl StackCreator for CHostStackCreator {
+    fn new_stack(&self, size: usize) -> Result<Box<dyn wasmtime::StackMemory>> {
+        extern "C" fn panic_callback(_env: *mut std::ffi::c_void, _out_len: &mut usize) -> *mut u8 {
+            panic!("a callback must be set");
+        }
+        let mut out = wasmtime_stack_memory_t {
+            env: ptr::null_mut(),
+            get_stack_memory: panic_callback,
+            finalizer: None,
+        };
+        let cb = self.new_stack;
+        let result = cb(self.foreign.data, size, &mut out);
+        match result {
+            Some(error) => Err((*error).into()),
+            None => Ok(Box::new(CHostStackMemory {
+                foreign: crate::ForeignData {
+                    data: out.env,
+                    finalizer: out.finalizer,
+                },
+                get_memory: out.get_stack_memory,
+            })),
+        }
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasmtime_config_host_stack_creator_set(
+    c: &mut wasm_config_t,
+    creator: &wasmtime_stack_creator_t,
+) {
+    c.config.with_host_stack(Arc::new(CHostStackCreator {
+        foreign: crate::ForeignData {
+            data: creator.env,
+            finalizer: creator.finalizer,
+        },
+        new_stack: creator.new_stack,
+    }));
+}
diff --git a/crates/c-api/src/config.rs b/crates/c-api/src/config.rs
index 76fe4546b69b..4ce46768a7d1 100644
--- a/crates/c-api/src/config.rs
+++ b/crates/c-api/src/config.rs
@@ -3,9 +3,9 @@
 #![cfg_attr(not(feature = "cache"), allow(unused_imports))]
 
 use crate::{handle_result, wasm_memorytype_t, wasmtime_error_t};
-use std::mem::MaybeUninit;
 use std::ops::Range;
 use std::os::raw::c_char;
+use std::ptr;
 use std::{ffi::CStr, sync::Arc};
 use wasmtime::{
     Config, LinearMemory, MemoryCreator, OptLevel, ProfilingStrategy, Result, Strategy,
@@ -71,15 +71,34 @@ pub extern "C" fn wasmtime_config_max_wasm_stack_set(c: &mut wasm_config_t, size
 }
 
 #[no_mangle]
+#[cfg(feature = "threads")]
 pub extern "C" fn wasmtime_config_wasm_threads_set(c: &mut wasm_config_t, enable: bool) {
     c.config.wasm_threads(enable);
 }
 
+#[no_mangle]
+pub extern "C" fn wasmtime_config_wasm_tail_call_set(c: &mut wasm_config_t, enable: bool) {
+    c.config.wasm_tail_call(enable);
+}
+
 #[no_mangle]
 pub extern "C" fn wasmtime_config_wasm_reference_types_set(c: &mut wasm_config_t, enable: bool) {
     c.config.wasm_reference_types(enable);
 }
 
+#[no_mangle]
+pub extern "C" fn wasmtime_config_wasm_function_references_set(
+    c: &mut wasm_config_t,
+    enable: bool,
+) {
+    c.config.wasm_function_references(enable);
+}
+
+#[no_mangle]
+pub extern "C" fn wasmtime_config_wasm_gc_set(c: &mut wasm_config_t, enable: bool) {
+    c.config.wasm_gc(enable);
+}
+
 #[no_mangle]
 pub extern "C" fn wasmtime_config_wasm_simd_set(c: &mut wasm_config_t, enable: bool) {
     c.config.wasm_simd(enable);
@@ -119,6 +138,7 @@ pub extern "C" fn wasmtime_config_wasm_memory64_set(c: &mut wasm_config_t, enabl
 }
 
 #[no_mangle]
+#[cfg(any(feature = "cranelift", feature = "winch"))]
 pub extern "C" fn wasmtime_config_strategy_set(
     c: &mut wasm_config_t,
     strategy: wasmtime_strategy_t,
@@ -137,6 +157,7 @@ pub extern "C" fn wasmtime_config_parallel_compilation_set(c: &mut wasm_config_t
 }
 
 #[no_mangle]
+#[cfg(any(feature = "cranelift", feature = "winch"))]
 pub extern "C" fn wasmtime_config_cranelift_debug_verifier_set(
     c: &mut wasm_config_t,
     enable: bool,
@@ -145,6 +166,7 @@ pub extern "C" fn wasmtime_config_cranelift_debug_verifier_set(
 }
 
 #[no_mangle]
+#[cfg(any(feature = "cranelift", feature = "winch"))]
 pub extern "C" fn wasmtime_config_cranelift_nan_canonicalization_set(
     c: &mut wasm_config_t,
     enable: bool,
@@ -153,6 +175,7 @@ pub extern "C" fn wasmtime_config_cranelift_nan_canonicalization_set(
 }
 
 #[no_mangle]
+#[cfg(any(feature = "cranelift", feature = "winch"))]
 pub extern "C" fn wasmtime_config_cranelift_opt_level_set(
     c: &mut wasm_config_t,
     opt_level: wasmtime_opt_level_t,
@@ -232,6 +255,7 @@ pub extern "C" fn wasmtime_config_native_unwind_info_set(c: &mut wasm_config_t,
 }
 
 #[no_mangle]
+#[cfg(any(feature = "cranelift", feature = "winch"))]
 pub unsafe extern "C" fn wasmtime_config_target_set(
     c: &mut wasm_config_t,
     target: *const c_char,
@@ -241,6 +265,12 @@ pub unsafe extern "C" fn wasmtime_config_target_set(
 }
 
 #[no_mangle]
+pub extern "C" fn wasmtime_config_macos_use_mach_ports_set(c: &mut wasm_config_t, enabled: bool) {
+    c.config.macos_use_mach_ports(enabled);
+}
+
+#[no_mangle]
+#[cfg(any(feature = "cranelift", feature = "winch"))]
 pub unsafe extern "C" fn wasmtime_config_cranelift_flag_enable(
     c: &mut wasm_config_t,
     flag: *const c_char,
@@ -250,6 +280,7 @@ pub unsafe extern "C" fn wasmtime_config_cranelift_flag_enable(
 }
 
 #[no_mangle]
+#[cfg(any(feature = "cranelift", feature = "winch"))]
 pub unsafe extern "C" fn wasmtime_config_cranelift_flag_set(
     c: &mut wasm_config_t,
     flag: *const c_char,
@@ -362,7 +393,25 @@ unsafe impl MemoryCreator for CHostMemoryCreator {
         reserved_size_in_bytes: Option<usize>,
         guard_size_in_bytes: usize,
     ) -> Result<Box<dyn wasmtime::LinearMemory>, String> {
-        let mut memory = MaybeUninit::uninit();
+        extern "C" fn panic_get_callback(
+            _env: *mut std::ffi::c_void,
+            _byte_size: &mut usize,
+            _maximum_byte_size: &mut usize,
+        ) -> *mut u8 {
+            panic!("a callback must be set");
+        }
+        extern "C" fn panic_grow_callback(
+            _env: *mut std::ffi::c_void,
+            _size: usize,
+        ) -> Option<Box<wasmtime_error_t>> {
+            panic!("a callback must be set");
+        }
+        let mut memory = wasmtime_linear_memory_t {
+            env: ptr::null_mut(),
+            get_memory: panic_get_callback,
+            grow_memory: panic_grow_callback,
+            finalizer: None,
+        };
         let cb = self.new_memory;
         let error = cb(
             self.foreign.data,
@@ -371,11 +420,10 @@ unsafe impl MemoryCreator for CHostMemoryCreator {
             maximum.unwrap_or(usize::MAX),
             reserved_size_in_bytes.unwrap_or(0),
             guard_size_in_bytes,
-            memory.as_mut_ptr(),
+            &mut memory,
         );
         match error {
             None => {
-                let memory = unsafe { memory.assume_init() };
                 let foreign = crate::ForeignData {
                     data: memory.env,
                     finalizer: memory.finalizer,
@@ -388,7 +436,7 @@ unsafe impl MemoryCreator for CHostMemoryCreator {
             }
             Some(err) => {
                 let err: anyhow::Error = (*err).into();
-                Err(format!("{}", err))
+                Err(format!("{err}"))
             }
         }
     }
@@ -407,3 +455,8 @@ pub unsafe extern "C" fn wasmtime_config_host_memory_creator_set(
         new_memory: creator.new_memory,
     }));
 }
+
+#[no_mangle]
+pub extern "C" fn wasmtime_config_memory_init_cow_set(c: &mut wasm_config_t, enable: bool) {
+    c.config.memory_init_cow(enable);
+}
diff --git a/crates/c-api/src/engine.rs b/crates/c-api/src/engine.rs
index 67785fc03fc5..e8cea19e7571 100644
--- a/crates/c-api/src/engine.rs
+++ b/crates/c-api/src/engine.rs
@@ -19,6 +19,7 @@ pub extern "C" fn wasm_engine_new() -> Box<wasm_engine_t> {
     // Note that we `drop` the result here since this fails after the first
     // initialization attempt. We don't mind that though because this function
     // can be called multiple times, so we just ignore the result.
+    #[cfg(feature = "logging")]
     drop(env_logger::try_init());
 
     Box::new(wasm_engine_t {
@@ -28,12 +29,20 @@ pub extern "C" fn wasm_engine_new() -> Box<wasm_engine_t> {
 
 #[no_mangle]
 pub extern "C" fn wasm_engine_new_with_config(c: Box<wasm_config_t>) -> Box<wasm_engine_t> {
+    #[cfg(feature = "logging")]
+    drop(env_logger::try_init());
+
     let config = c.config;
     Box::new(wasm_engine_t {
         engine: Engine::new(&config).unwrap(),
     })
 }
 
+#[no_mangle]
+pub extern "C" fn wasmtime_engine_clone(engine: &wasm_engine_t) -> Box<wasm_engine_t> {
+    Box::new(engine.clone())
+}
+
 #[no_mangle]
 pub extern "C" fn wasmtime_engine_increment_epoch(engine: &wasm_engine_t) {
     engine.engine.increment_epoch();
diff --git a/crates/c-api/src/extern.rs b/crates/c-api/src/extern.rs
index 516e21b28467..77aba7818d5c 100644
--- a/crates/c-api/src/extern.rs
+++ b/crates/c-api/src/extern.rs
@@ -1,13 +1,13 @@
 use crate::{
     wasm_externkind_t, wasm_externtype_t, wasm_func_t, wasm_global_t, wasm_memory_t, wasm_table_t,
-    CStoreContext, StoreRef,
+    WasmStoreRef, WasmtimeStoreContext,
 };
 use std::mem::ManuallyDrop;
-use wasmtime::{Extern, Func, Global, Memory, Table};
+use wasmtime::{Extern, Func, Global, Memory, SharedMemory, Table};
 
 #[derive(Clone)]
 pub struct wasm_extern_t {
-    pub(crate) store: StoreRef,
+    pub(crate) store: WasmStoreRef,
     pub(crate) which: Extern,
 }
 
@@ -26,7 +26,9 @@ pub extern "C" fn wasm_extern_kind(e: &wasm_extern_t) -> wasm_externkind_t {
 
 #[no_mangle]
 pub unsafe extern "C" fn wasm_extern_type(e: &wasm_extern_t) -> Box<wasm_externtype_t> {
-    Box::new(wasm_externtype_t::new(e.which.ty(&e.store.context())))
+    Box::new(wasm_externtype_t::from_extern_type(
+        e.which.ty(&e.store.context()),
+    ))
 }
 
 #[no_mangle]
@@ -80,6 +82,7 @@ pub const WASMTIME_EXTERN_FUNC: wasmtime_extern_kind_t = 0;
 pub const WASMTIME_EXTERN_GLOBAL: wasmtime_extern_kind_t = 1;
 pub const WASMTIME_EXTERN_TABLE: wasmtime_extern_kind_t = 2;
 pub const WASMTIME_EXTERN_MEMORY: wasmtime_extern_kind_t = 3;
+pub const WASMTIME_EXTERN_SHAREDMEMORY: wasmtime_extern_kind_t = 4;
 
 #[repr(C)]
 pub union wasmtime_extern_union {
@@ -87,6 +90,17 @@ pub union wasmtime_extern_union {
     pub table: Table,
     pub global: Global,
     pub memory: Memory,
+    pub sharedmemory: ManuallyDrop<Box<SharedMemory>>,
+}
+
+impl Drop for wasmtime_extern_t {
+    fn drop(&mut self) {
+        if self.kind == WASMTIME_EXTERN_SHAREDMEMORY {
+            unsafe {
+                ManuallyDrop::drop(&mut self.of.sharedmemory);
+            }
+        }
+    }
 }
 
 impl wasmtime_extern_t {
@@ -96,7 +110,8 @@ impl wasmtime_extern_t {
             WASMTIME_EXTERN_GLOBAL => Extern::Global(self.of.global),
             WASMTIME_EXTERN_TABLE => Extern::Table(self.of.table),
             WASMTIME_EXTERN_MEMORY => Extern::Memory(self.of.memory),
-            other => panic!("unknown wasm_extern_kind_t: {}", other),
+            WASMTIME_EXTERN_SHAREDMEMORY => Extern::SharedMemory((**self.of.sharedmemory).clone()),
+            other => panic!("unknown wasmtime_extern_kind_t: {other}"),
         }
     }
 }
@@ -120,7 +135,12 @@ impl From<Extern> for wasmtime_extern_t {
                 kind: WASMTIME_EXTERN_MEMORY,
                 of: wasmtime_extern_union { memory },
             },
-            Extern::SharedMemory(_memory) => todo!(),
+            Extern::SharedMemory(sharedmemory) => wasmtime_extern_t {
+                kind: WASMTIME_EXTERN_SHAREDMEMORY,
+                of: wasmtime_extern_union {
+                    sharedmemory: ManuallyDrop::new(Box::new(sharedmemory)),
+                },
+            },
         }
     }
 }
@@ -132,8 +152,8 @@ pub unsafe extern "C" fn wasmtime_extern_delete(e: &mut ManuallyDrop<wasmtime_ex
 
 #[no_mangle]
 pub unsafe extern "C" fn wasmtime_extern_type(
-    store: CStoreContext<'_>,
+    store: WasmtimeStoreContext<'_>,
     e: &wasmtime_extern_t,
 ) -> Box<wasm_externtype_t> {
-    Box::new(wasm_externtype_t::new(e.to_extern().ty(store)))
+    Box::new(wasm_externtype_t::from_extern_type(e.to_extern().ty(store)))
 }
diff --git a/crates/c-api/src/func.rs b/crates/c-api/src/func.rs
index 8fbec441da29..0e85ee9b90c9 100644
--- a/crates/c-api/src/func.rs
+++ b/crates/c-api/src/func.rs
@@ -1,8 +1,9 @@
-use crate::wasm_trap_t;
 use crate::{
     wasm_extern_t, wasm_functype_t, wasm_store_t, wasm_val_t, wasm_val_vec_t, wasmtime_error_t,
-    wasmtime_extern_t, wasmtime_val_t, wasmtime_val_union, CStoreContext, CStoreContextMut,
+    wasmtime_extern_t, wasmtime_val_t, wasmtime_val_union, WasmtimeStoreContext,
+    WasmtimeStoreContextMut,
 };
+use crate::{wasm_trap_t, WasmtimeCaller, WasmtimeStoreData};
 use anyhow::{Error, Result};
 use std::any::Any;
 use std::ffi::c_void;
@@ -10,7 +11,10 @@ use std::mem::{self, MaybeUninit};
 use std::panic::{self, AssertUnwindSafe};
 use std::ptr;
 use std::str;
-use wasmtime::{AsContextMut, Caller, Extern, Func, Trap, Val, ValRaw};
+use wasmtime::{
+    AsContext, AsContextMut, Extern, Func, RootScope, StoreContext, StoreContextMut, Trap, Val,
+    ValRaw,
+};
 
 #[derive(Clone)]
 #[repr(transparent)]
@@ -55,7 +59,7 @@ unsafe fn create_function(
         + Sync
         + 'static,
 ) -> Box<wasm_func_t> {
-    let ty = ty.ty().ty.clone();
+    let ty = ty.ty().ty(store.store.context().engine());
     let func = Func::new(
         store.store.context_mut(),
         ty,
@@ -122,7 +126,7 @@ pub(crate) fn translate_args<'a>(
     let num_args = args.len();
     dst.reserve(args.len() + results_size);
     dst.extend(args);
-    dst.extend((0..results_size).map(|_| Val::null()));
+    dst.extend((0..results_size).map(|_| Val::null_func_ref()));
     let (a, b) = dst.split_at_mut(num_args);
     (a, b)
 }
@@ -200,7 +204,21 @@ pub extern "C" fn wasm_func_as_extern_const(f: &wasm_func_t) -> &wasm_extern_t {
 
 #[repr(C)]
 pub struct wasmtime_caller_t<'a> {
-    pub(crate) caller: Caller<'a, crate::StoreData>,
+    pub(crate) caller: WasmtimeCaller<'a>,
+}
+
+impl AsContext for wasmtime_caller_t<'_> {
+    type Data = WasmtimeStoreData;
+
+    fn as_context(&self) -> StoreContext<'_, WasmtimeStoreData> {
+        self.caller.as_context()
+    }
+}
+
+impl AsContextMut for wasmtime_caller_t<'_> {
+    fn as_context_mut(&mut self) -> StoreContextMut<'_, WasmtimeStoreData> {
+        self.caller.as_context_mut()
+    }
 }
 
 pub type wasmtime_func_callback_t = extern "C" fn(
@@ -221,14 +239,14 @@ pub type wasmtime_func_unchecked_callback_t = extern "C" fn(
 
 #[no_mangle]
 pub unsafe extern "C" fn wasmtime_func_new(
-    store: CStoreContextMut<'_>,
+    store: WasmtimeStoreContextMut<'_>,
     ty: &wasm_functype_t,
     callback: wasmtime_func_callback_t,
     data: *mut c_void,
     finalizer: Option<extern "C" fn(*mut std::ffi::c_void)>,
     func: &mut Func,
 ) {
-    let ty = ty.ty().ty.clone();
+    let ty = ty.ty().ty(store.engine());
     let cb = c_callback_to_rust_fn(callback, data, finalizer);
     let f = Func::new(store, ty, cb);
     *func = f;
@@ -238,7 +256,7 @@ pub(crate) unsafe fn c_callback_to_rust_fn(
     callback: wasmtime_func_callback_t,
     data: *mut c_void,
     finalizer: Option<extern "C" fn(*mut std::ffi::c_void)>,
-) -> impl Fn(Caller<'_, crate::StoreData>, &[Val], &mut [Val]) -> Result<()> {
+) -> impl Fn(WasmtimeCaller<'_>, &[Val], &mut [Val]) -> Result<()> {
     let foreign = crate::ForeignData { data, finalizer };
     move |mut caller, params, results| {
         let _ = &foreign; // move entire foreign into this closure
@@ -249,7 +267,12 @@ pub(crate) unsafe fn c_callback_to_rust_fn(
         let mut vals = mem::take(&mut caller.data_mut().hostcall_val_storage);
         debug_assert!(vals.is_empty());
         vals.reserve(params.len() + results.len());
-        vals.extend(params.iter().cloned().map(|p| wasmtime_val_t::from_val(p)));
+        vals.extend(
+            params
+                .iter()
+                .cloned()
+                .map(|p| wasmtime_val_t::from_val_unscoped(&mut caller, p)),
+        );
         vals.extend((0..results.len()).map(|_| wasmtime_val_t {
             kind: crate::WASMTIME_I32,
             of: wasmtime_val_union { i32: 0 },
@@ -272,7 +295,7 @@ pub(crate) unsafe fn c_callback_to_rust_fn(
 
         // Translate the `wasmtime_val_t` results into the `results` space
         for (i, result) in out_results.iter().enumerate() {
-            results[i] = result.to_val();
+            results[i] = result.to_val_unscoped(&mut caller);
         }
 
         // Move our `vals` storage back into the store now that we no longer
@@ -286,14 +309,14 @@ pub(crate) unsafe fn c_callback_to_rust_fn(
 
 #[no_mangle]
 pub unsafe extern "C" fn wasmtime_func_new_unchecked(
-    store: CStoreContextMut<'_>,
+    store: WasmtimeStoreContextMut<'_>,
     ty: &wasm_functype_t,
     callback: wasmtime_func_unchecked_callback_t,
     data: *mut c_void,
     finalizer: Option<extern "C" fn(*mut std::ffi::c_void)>,
     func: &mut Func,
 ) {
-    let ty = ty.ty().ty.clone();
+    let ty = ty.ty().ty(store.engine());
     let cb = c_unchecked_callback_to_rust_fn(callback, data, finalizer);
     *func = Func::new_unchecked(store, ty, cb);
 }
@@ -302,7 +325,7 @@ pub(crate) unsafe fn c_unchecked_callback_to_rust_fn(
     callback: wasmtime_func_unchecked_callback_t,
     data: *mut c_void,
     finalizer: Option<extern "C" fn(*mut std::ffi::c_void)>,
-) -> impl Fn(Caller<'_, crate::StoreData>, &mut [ValRaw]) -> Result<()> {
+) -> impl Fn(WasmtimeCaller<'_>, &mut [ValRaw]) -> Result<()> {
     let foreign = crate::ForeignData { data, finalizer };
     move |caller, values| {
         let _ = &foreign; // move entire foreign into this closure
@@ -316,7 +339,7 @@ pub(crate) unsafe fn c_unchecked_callback_to_rust_fn(
 
 #[no_mangle]
 pub unsafe extern "C" fn wasmtime_func_call(
-    mut store: CStoreContextMut<'_>,
+    mut store: WasmtimeStoreContextMut<'_>,
     func: &Func,
     args: *const wasmtime_val_t,
     nargs: usize,
@@ -324,13 +347,13 @@ pub unsafe extern "C" fn wasmtime_func_call(
     nresults: usize,
     trap_ret: &mut *mut wasm_trap_t,
 ) -> Option<Box<wasmtime_error_t>> {
-    let mut store = store.as_context_mut();
-    let mut params = mem::take(&mut store.data_mut().wasm_val_storage);
+    let mut scope = RootScope::new(&mut store);
+    let mut params = mem::take(&mut scope.as_context_mut().data_mut().wasm_val_storage);
     let (wt_params, wt_results) = translate_args(
         &mut params,
         crate::slice_from_raw_parts(args, nargs)
             .iter()
-            .map(|i| i.to_val()),
+            .map(|i| i.to_val(&mut scope)),
         nresults,
     );
 
@@ -339,16 +362,16 @@ pub unsafe extern "C" fn wasmtime_func_call(
     // can. As a result we catch panics here and transform them to traps to
     // allow the caller to have any insulation possible against Rust panics.
     let result = panic::catch_unwind(AssertUnwindSafe(|| {
-        func.call(&mut store, wt_params, wt_results)
+        func.call(&mut scope, wt_params, wt_results)
     }));
     match result {
         Ok(Ok(())) => {
             let results = crate::slice_from_raw_parts_mut(results, nresults);
             for (slot, val) in results.iter_mut().zip(wt_results.iter()) {
-                crate::initialize(slot, wasmtime_val_t::from_val(val.clone()));
+                crate::initialize(slot, wasmtime_val_t::from_val(&mut scope, *val));
             }
             params.truncate(0);
-            store.data_mut().wasm_val_storage = params;
+            scope.as_context_mut().data_mut().wasm_val_storage = params;
             None
         }
         Ok(Err(trap)) => store_err(trap, trap_ret),
@@ -362,7 +385,7 @@ pub unsafe extern "C" fn wasmtime_func_call(
 
 #[no_mangle]
 pub unsafe extern "C" fn wasmtime_func_call_unchecked(
-    store: CStoreContextMut<'_>,
+    store: WasmtimeStoreContextMut<'_>,
     func: &Func,
     args_and_results: *mut ValRaw,
     args_and_results_len: usize,
@@ -385,7 +408,7 @@ fn store_err(err: Error, trap_ret: &mut *mut wasm_trap_t) -> Option<Box<wasmtime
 
 #[no_mangle]
 pub extern "C" fn wasmtime_func_type(
-    store: CStoreContext<'_>,
+    store: WasmtimeStoreContext<'_>,
     func: &Func,
 ) -> Box<wasm_functype_t> {
     Box::new(wasm_functype_t::new(func.ty(store)))
@@ -394,7 +417,7 @@ pub extern "C" fn wasmtime_func_type(
 #[no_mangle]
 pub extern "C" fn wasmtime_caller_context<'a>(
     caller: &'a mut wasmtime_caller_t,
-) -> CStoreContextMut<'a> {
+) -> WasmtimeStoreContextMut<'a> {
     caller.caller.as_context_mut()
 }
 
@@ -419,7 +442,7 @@ pub unsafe extern "C" fn wasmtime_caller_export_get(
 
 #[no_mangle]
 pub unsafe extern "C" fn wasmtime_func_from_raw(
-    store: CStoreContextMut<'_>,
+    store: WasmtimeStoreContextMut<'_>,
     raw: *mut c_void,
     func: &mut Func,
 ) {
@@ -428,7 +451,7 @@ pub unsafe extern "C" fn wasmtime_func_from_raw(
 
 #[no_mangle]
 pub unsafe extern "C" fn wasmtime_func_to_raw(
-    store: CStoreContextMut<'_>,
+    store: WasmtimeStoreContextMut<'_>,
     func: &Func,
 ) -> *mut c_void {
     func.to_raw(store)
diff --git a/crates/c-api/src/global.rs b/crates/c-api/src/global.rs
index 653855b52894..073dfd2172cb 100644
--- a/crates/c-api/src/global.rs
+++ b/crates/c-api/src/global.rs
@@ -1,9 +1,9 @@
 use crate::{
     handle_result, wasm_extern_t, wasm_globaltype_t, wasm_store_t, wasm_val_t, wasmtime_error_t,
-    wasmtime_val_t, CStoreContext, CStoreContextMut,
+    wasmtime_val_t, WasmtimeStoreContext, WasmtimeStoreContextMut,
 };
 use std::mem::MaybeUninit;
-use wasmtime::{Extern, Global};
+use wasmtime::{Extern, Global, RootScope};
 
 #[derive(Clone)]
 #[repr(transparent)]
@@ -79,12 +79,14 @@ pub unsafe extern "C" fn wasm_global_set(g: &mut wasm_global_t, val: &wasm_val_t
 
 #[no_mangle]
 pub unsafe extern "C" fn wasmtime_global_new(
-    store: CStoreContextMut<'_>,
+    mut store: WasmtimeStoreContextMut<'_>,
     gt: &wasm_globaltype_t,
     val: &wasmtime_val_t,
     ret: &mut Global,
 ) -> Option<Box<wasmtime_error_t>> {
-    let global = Global::new(store, gt.ty().ty.clone(), val.to_val());
+    let mut scope = RootScope::new(&mut store);
+    let val = val.to_val(&mut scope);
+    let global = Global::new(scope, gt.ty().ty.clone(), val);
     handle_result(global, |global| {
         *ret = global;
     })
@@ -92,7 +94,7 @@ pub unsafe extern "C" fn wasmtime_global_new(
 
 #[no_mangle]
 pub extern "C" fn wasmtime_global_type(
-    store: CStoreContext<'_>,
+    store: WasmtimeStoreContext<'_>,
     global: &Global,
 ) -> Box<wasm_globaltype_t> {
     Box::new(wasm_globaltype_t::new(global.ty(store)))
@@ -100,18 +102,22 @@ pub extern "C" fn wasmtime_global_type(
 
 #[no_mangle]
 pub extern "C" fn wasmtime_global_get(
-    store: CStoreContextMut<'_>,
+    store: WasmtimeStoreContextMut<'_>,
     global: &Global,
     val: &mut MaybeUninit<wasmtime_val_t>,
 ) {
-    crate::initialize(val, wasmtime_val_t::from_val(global.get(store)))
+    let mut scope = RootScope::new(store);
+    let gval = global.get(&mut scope);
+    crate::initialize(val, wasmtime_val_t::from_val(&mut scope, gval))
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn wasmtime_global_set(
-    store: CStoreContextMut<'_>,
+    mut store: WasmtimeStoreContextMut<'_>,
     global: &Global,
     val: &wasmtime_val_t,
 ) -> Option<Box<wasmtime_error_t>> {
-    handle_result(global.set(store, val.to_val()), |()| {})
+    let mut scope = RootScope::new(&mut store);
+    let val = val.to_val(&mut scope);
+    handle_result(global.set(scope, val), |()| {})
 }
diff --git a/crates/c-api/src/instance.rs b/crates/c-api/src/instance.rs
index b8ae5bc82341..f38d151d36f3 100644
--- a/crates/c-api/src/instance.rs
+++ b/crates/c-api/src/instance.rs
@@ -1,20 +1,20 @@
 use crate::{
     wasm_extern_t, wasm_extern_vec_t, wasm_module_t, wasm_store_t, wasm_trap_t, wasmtime_error_t,
-    wasmtime_extern_t, wasmtime_module_t, CStoreContextMut, StoreData, StoreRef,
+    wasmtime_extern_t, wasmtime_module_t, WasmStoreRef, WasmtimeStoreContextMut, WasmtimeStoreData,
 };
 use std::mem::MaybeUninit;
 use wasmtime::{Instance, InstancePre, Trap};
 
 #[derive(Clone)]
 pub struct wasm_instance_t {
-    store: StoreRef,
+    store: WasmStoreRef,
     instance: Instance,
 }
 
 wasmtime_c_api_macros::declare_ref!(wasm_instance_t);
 
 impl wasm_instance_t {
-    pub(crate) fn new(store: StoreRef, instance: Instance) -> wasm_instance_t {
+    pub(crate) fn new(store: WasmStoreRef, instance: Instance) -> wasm_instance_t {
         wasm_instance_t { store, instance }
     }
 }
@@ -70,7 +70,7 @@ pub unsafe extern "C" fn wasm_instance_exports(
 
 #[no_mangle]
 pub unsafe extern "C" fn wasmtime_instance_new(
-    store: CStoreContextMut<'_>,
+    store: WasmtimeStoreContextMut<'_>,
     module: &wasmtime_module_t,
     imports: *const wasmtime_extern_t,
     nimports: usize,
@@ -111,7 +111,7 @@ pub(crate) fn handle_instantiate(
 
 #[no_mangle]
 pub unsafe extern "C" fn wasmtime_instance_export_get(
-    store: CStoreContextMut<'_>,
+    store: WasmtimeStoreContextMut<'_>,
     instance: &Instance,
     name: *const u8,
     name_len: usize,
@@ -133,7 +133,7 @@ pub unsafe extern "C" fn wasmtime_instance_export_get(
 
 #[no_mangle]
 pub unsafe extern "C" fn wasmtime_instance_export_nth(
-    store: CStoreContextMut<'_>,
+    store: WasmtimeStoreContextMut<'_>,
     instance: &Instance,
     index: usize,
     name_ptr: &mut *const u8,
@@ -153,7 +153,7 @@ pub unsafe extern "C" fn wasmtime_instance_export_nth(
 
 #[repr(transparent)]
 pub struct wasmtime_instance_pre_t {
-    pub(crate) underlying: InstancePre<StoreData>,
+    pub(crate) underlying: InstancePre<WasmtimeStoreData>,
 }
 
 #[no_mangle]
@@ -163,10 +163,18 @@ pub unsafe extern "C" fn wasmtime_instance_pre_delete(_instance_pre: Box<wasmtim
 #[no_mangle]
 pub unsafe extern "C" fn wasmtime_instance_pre_instantiate(
     instance_pre: &wasmtime_instance_pre_t,
-    store: CStoreContextMut<'_>,
+    store: WasmtimeStoreContextMut<'_>,
     instance_ptr: &mut Instance,
     trap_ptr: &mut *mut wasm_trap_t,
 ) -> Option<Box<wasmtime_error_t>> {
     let result = instance_pre.underlying.instantiate(store);
     handle_instantiate(result, instance_ptr, trap_ptr)
 }
+
+#[no_mangle]
+pub unsafe extern "C" fn wasmtime_instance_pre_module(
+    instance_pre: &wasmtime_instance_pre_t,
+) -> Box<wasmtime_module_t> {
+    let module = instance_pre.underlying.module().clone();
+    Box::new(wasmtime_module_t { module })
+}
diff --git a/crates/c-api/src/lib.rs b/crates/c-api/src/lib.rs
index ea4696e9387e..652bcf83e51e 100644
--- a/crates/c-api/src/lib.rs
+++ b/crates/c-api/src/lib.rs
@@ -1,8 +1,11 @@
 //! This crate is the implementation of Wasmtime's C API.
 //!
-//! This crate is not intended to be used from Rust itself, for that see the
-//! `wasmtime` crate. Otherwise this is typically compiled as a
-//! cdylib/staticlib. Documentation for this crate largely lives in the header
+//! This crate is normally not intended to be used from Rust itself. For that,
+//! see the `wasmtime` crate. It is possible to use this crate via Cargo, for
+//! Rust crates that wrap C libraries that use wasmtime. Most often, this crate
+//! is compiled as a cdylib or staticlib, via the `wasmtime-c-api` crate.
+//!
+//! Documentation for this crate largely lives in the header
 //! files of the `include` directory for this crate.
 //!
 //! At a high level this crate implements the `wasm.h` API with some gymnastics,
@@ -11,7 +14,7 @@
 
 #![allow(non_snake_case, non_camel_case_types, non_upper_case_globals)]
 
-pub use wasmtime::*;
+pub use wasmtime;
 
 mod config;
 mod engine;
@@ -23,7 +26,10 @@ mod instance;
 mod linker;
 mod memory;
 mod module;
+#[cfg(feature = "profiling")]
+mod profiling;
 mod r#ref;
+mod sharedmemory;
 mod store;
 mod table;
 mod trap;
@@ -114,3 +120,8 @@ unsafe fn slice_from_raw_parts_mut<'a, T>(ptr: *mut T, len: usize) -> &'a mut [T
         std::slice::from_raw_parts_mut(ptr, len)
     }
 }
+
+pub(crate) fn abort(name: &str) -> ! {
+    eprintln!("`{name}` is not implemented");
+    std::process::abort();
+}
diff --git a/crates/c-api/src/linker.rs b/crates/c-api/src/linker.rs
index 7cf9391d8f8a..b20104abcc3a 100644
--- a/crates/c-api/src/linker.rs
+++ b/crates/c-api/src/linker.rs
@@ -1,6 +1,7 @@
 use crate::{
     bad_utf8, handle_result, wasm_engine_t, wasm_functype_t, wasm_trap_t, wasmtime_error_t,
-    wasmtime_extern_t, wasmtime_instance_pre_t, wasmtime_module_t, CStoreContext, CStoreContextMut,
+    wasmtime_extern_t, wasmtime_instance_pre_t, wasmtime_module_t, WasmtimeStoreContext,
+    WasmtimeStoreContextMut,
 };
 use std::ffi::c_void;
 use std::mem::MaybeUninit;
@@ -9,7 +10,7 @@ use wasmtime::{Func, Instance, Linker};
 
 #[repr(C)]
 pub struct wasmtime_linker_t {
-    pub(crate) linker: Linker<crate::StoreData>,
+    pub(crate) linker: Linker<crate::WasmtimeStoreData>,
 }
 
 wasmtime_c_api_macros::declare_own!(wasmtime_linker_t);
@@ -21,6 +22,13 @@ pub extern "C" fn wasmtime_linker_new(engine: &wasm_engine_t) -> Box<wasmtime_li
     })
 }
 
+#[no_mangle]
+pub extern "C" fn wasmtime_linker_clone(linker: &wasmtime_linker_t) -> Box<wasmtime_linker_t> {
+    Box::new(wasmtime_linker_t {
+        linker: linker.linker.clone(),
+    })
+}
+
 #[no_mangle]
 pub extern "C" fn wasmtime_linker_allow_shadowing(
     linker: &mut wasmtime_linker_t,
@@ -43,7 +51,7 @@ pub(crate) use to_str;
 #[no_mangle]
 pub unsafe extern "C" fn wasmtime_linker_define(
     linker: &mut wasmtime_linker_t,
-    store: CStoreContext<'_>,
+    store: WasmtimeStoreContext<'_>,
     module: *const u8,
     module_len: usize,
     name: *const u8,
@@ -69,7 +77,7 @@ pub unsafe extern "C" fn wasmtime_linker_define_func(
     data: *mut c_void,
     finalizer: Option<extern "C" fn(*mut std::ffi::c_void)>,
 ) -> Option<Box<wasmtime_error_t>> {
-    let ty = ty.ty().ty.clone();
+    let ty = ty.ty().ty(linker.linker.engine());
     let module = to_str!(module, module_len);
     let name = to_str!(name, name_len);
     let cb = crate::func::c_callback_to_rust_fn(callback, data, finalizer);
@@ -88,7 +96,7 @@ pub unsafe extern "C" fn wasmtime_linker_define_func_unchecked(
     data: *mut c_void,
     finalizer: Option<extern "C" fn(*mut std::ffi::c_void)>,
 ) -> Option<Box<wasmtime_error_t>> {
-    let ty = ty.ty().ty.clone();
+    let ty = ty.ty().ty(linker.linker.engine());
     let module = to_str!(module, module_len);
     let name = to_str!(name, name_len);
     let cb = crate::func::c_unchecked_callback_to_rust_fn(callback, data, finalizer);
@@ -104,10 +112,8 @@ pub extern "C" fn wasmtime_linker_define_wasi(
     linker: &mut wasmtime_linker_t,
 ) -> Option<Box<wasmtime_error_t>> {
     handle_result(
-        wasmtime_wasi::add_to_linker(&mut linker.linker, |cx| {
-            cx.wasi.as_mut().expect(
-                "failed to define WASI on linker; did you set a WASI configuration in the store?",
-            )
+        wasmtime_wasi::preview1::add_to_linker_sync(&mut linker.linker, |ctx| {
+            ctx.wasi.as_mut().expect("wasi context must be populated")
         }),
         |_linker| (),
     )
@@ -116,7 +122,7 @@ pub extern "C" fn wasmtime_linker_define_wasi(
 #[no_mangle]
 pub unsafe extern "C" fn wasmtime_linker_define_instance(
     linker: &mut wasmtime_linker_t,
-    store: CStoreContextMut<'_>,
+    store: WasmtimeStoreContextMut<'_>,
     name: *const u8,
     name_len: usize,
     instance: &Instance,
@@ -129,7 +135,7 @@ pub unsafe extern "C" fn wasmtime_linker_define_instance(
 #[no_mangle]
 pub extern "C" fn wasmtime_linker_instantiate(
     linker: &wasmtime_linker_t,
-    store: CStoreContextMut<'_>,
+    store: WasmtimeStoreContextMut<'_>,
     module: &wasmtime_module_t,
     instance_ptr: &mut Instance,
     trap_ptr: &mut *mut wasm_trap_t,
@@ -154,7 +160,7 @@ pub unsafe extern "C" fn wasmtime_linker_instantiate_pre(
 #[no_mangle]
 pub unsafe extern "C" fn wasmtime_linker_module(
     linker: &mut wasmtime_linker_t,
-    store: CStoreContextMut<'_>,
+    store: WasmtimeStoreContextMut<'_>,
     name: *const u8,
     name_len: usize,
     module: &wasmtime_module_t,
@@ -167,7 +173,7 @@ pub unsafe extern "C" fn wasmtime_linker_module(
 #[no_mangle]
 pub unsafe extern "C" fn wasmtime_linker_get_default(
     linker: &wasmtime_linker_t,
-    store: CStoreContextMut<'_>,
+    store: WasmtimeStoreContextMut<'_>,
     name: *const u8,
     name_len: usize,
     func: &mut Func,
@@ -180,7 +186,7 @@ pub unsafe extern "C" fn wasmtime_linker_get_default(
 #[no_mangle]
 pub unsafe extern "C" fn wasmtime_linker_get(
     linker: &wasmtime_linker_t,
-    store: CStoreContextMut<'_>,
+    store: WasmtimeStoreContextMut<'_>,
     module: *const u8,
     module_len: usize,
     name: *const u8,
diff --git a/crates/c-api/src/memory.rs b/crates/c-api/src/memory.rs
index 299dbae7bb68..4d2cb82e9b98 100644
--- a/crates/c-api/src/memory.rs
+++ b/crates/c-api/src/memory.rs
@@ -1,6 +1,6 @@
 use crate::{
-    handle_result, wasm_extern_t, wasm_memorytype_t, wasm_store_t, wasmtime_error_t, CStoreContext,
-    CStoreContextMut,
+    handle_result, wasm_extern_t, wasm_memorytype_t, wasm_store_t, wasmtime_error_t,
+    WasmtimeStoreContext, WasmtimeStoreContextMut,
 };
 use std::convert::TryFrom;
 use wasmtime::{Extern, Memory};
@@ -88,7 +88,7 @@ pub unsafe extern "C" fn wasm_memory_grow(
 
 #[no_mangle]
 pub extern "C" fn wasmtime_memory_new(
-    store: CStoreContextMut<'_>,
+    store: WasmtimeStoreContextMut<'_>,
     ty: &wasm_memorytype_t,
     ret: &mut Memory,
 ) -> Option<Box<wasmtime_error_t>> {
@@ -97,30 +97,33 @@ pub extern "C" fn wasmtime_memory_new(
 
 #[no_mangle]
 pub extern "C" fn wasmtime_memory_type(
-    store: CStoreContext<'_>,
+    store: WasmtimeStoreContext<'_>,
     mem: &Memory,
 ) -> Box<wasm_memorytype_t> {
     Box::new(wasm_memorytype_t::new(mem.ty(store)))
 }
 
 #[no_mangle]
-pub extern "C" fn wasmtime_memory_data(store: CStoreContext<'_>, mem: &Memory) -> *const u8 {
+pub extern "C" fn wasmtime_memory_data(store: WasmtimeStoreContext<'_>, mem: &Memory) -> *const u8 {
     mem.data(store).as_ptr()
 }
 
 #[no_mangle]
-pub extern "C" fn wasmtime_memory_data_size(store: CStoreContext<'_>, mem: &Memory) -> usize {
+pub extern "C" fn wasmtime_memory_data_size(
+    store: WasmtimeStoreContext<'_>,
+    mem: &Memory,
+) -> usize {
     mem.data(store).len()
 }
 
 #[no_mangle]
-pub extern "C" fn wasmtime_memory_size(store: CStoreContext<'_>, mem: &Memory) -> u64 {
+pub extern "C" fn wasmtime_memory_size(store: WasmtimeStoreContext<'_>, mem: &Memory) -> u64 {
     mem.size(store)
 }
 
 #[no_mangle]
 pub extern "C" fn wasmtime_memory_grow(
-    store: CStoreContextMut<'_>,
+    store: WasmtimeStoreContextMut<'_>,
     mem: &Memory,
     delta: u64,
     prev_size: &mut u64,
diff --git a/crates/c-api/src/module.rs b/crates/c-api/src/module.rs
index 3a1a6e6664cc..47250fb710d4 100644
--- a/crates/c-api/src/module.rs
+++ b/crates/c-api/src/module.rs
@@ -1,6 +1,6 @@
 use crate::{
     handle_result, wasm_byte_vec_t, wasm_engine_t, wasm_exporttype_t, wasm_exporttype_vec_t,
-    wasm_importtype_t, wasm_importtype_vec_t, wasm_store_t, wasmtime_error_t,
+    wasm_importtype_t, wasm_importtype_vec_t, wasm_store_t, wasmtime_error_t, CExternType,
 };
 use anyhow::Context;
 use std::ffi::CStr;
@@ -29,6 +29,7 @@ pub struct wasm_shared_module_t {
 wasmtime_c_api_macros::declare_own!(wasm_shared_module_t);
 
 #[no_mangle]
+#[cfg(any(feature = "cranelift", feature = "winch"))]
 pub unsafe extern "C" fn wasm_module_new(
     store: &mut wasm_store_t,
     binary: &wasm_byte_vec_t,
@@ -40,6 +41,7 @@ pub unsafe extern "C" fn wasm_module_new(
 }
 
 #[no_mangle]
+#[cfg(any(feature = "cranelift", feature = "winch"))]
 pub unsafe extern "C" fn wasm_module_validate(
     store: &mut wasm_store_t,
     binary: &wasm_byte_vec_t,
@@ -53,7 +55,7 @@ fn fill_exports(module: &Module, out: &mut wasm_exporttype_vec_t) {
         .map(|e| {
             Some(Box::new(wasm_exporttype_t::new(
                 e.name().to_owned(),
-                e.ty(),
+                CExternType::new(e.ty()),
             )))
         })
         .collect::<Vec<_>>();
@@ -67,7 +69,7 @@ fn fill_imports(module: &Module, out: &mut wasm_importtype_vec_t) {
             Some(Box::new(wasm_importtype_t::new(
                 i.module().to_owned(),
                 i.name().to_owned(),
-                i.ty(),
+                CExternType::new(i.ty()),
             )))
         })
         .collect::<Vec<_>>();
@@ -105,6 +107,7 @@ pub unsafe extern "C" fn wasm_module_obtain(
 }
 
 #[no_mangle]
+#[cfg(any(feature = "cranelift", feature = "winch"))]
 pub extern "C" fn wasm_module_serialize(module: &wasm_module_t, ret: &mut wasm_byte_vec_t) {
     if let Ok(buf) = module.module.serialize() {
         ret.set_buffer(buf);
@@ -130,6 +133,7 @@ pub struct wasmtime_module_t {
 wasmtime_c_api_macros::declare_own!(wasmtime_module_t);
 
 #[no_mangle]
+#[cfg(any(feature = "cranelift", feature = "winch"))]
 pub unsafe extern "C" fn wasmtime_module_new(
     engine: &wasm_engine_t,
     wasm: *const u8,
@@ -166,6 +170,7 @@ pub extern "C" fn wasmtime_module_imports(
 }
 
 #[no_mangle]
+#[cfg(any(feature = "cranelift", feature = "winch"))]
 pub unsafe extern "C" fn wasmtime_module_validate(
     engine: &wasm_engine_t,
     wasm: *const u8,
@@ -176,6 +181,7 @@ pub unsafe extern "C" fn wasmtime_module_validate(
 }
 
 #[no_mangle]
+#[cfg(any(feature = "cranelift", feature = "winch"))]
 pub extern "C" fn wasmtime_module_serialize(
     module: &wasmtime_module_t,
     ret: &mut wasm_byte_vec_t,
@@ -186,8 +192,8 @@ pub extern "C" fn wasmtime_module_serialize(
 #[no_mangle]
 pub extern "C" fn wasmtime_module_image_range(
     module: &wasmtime_module_t,
-    start: &mut usize,
-    end: &mut usize,
+    start: &mut *const u8,
+    end: &mut *const u8,
 ) {
     let range = module.module.image_range();
     *start = range.start;
diff --git a/crates/c-api/src/profiling.rs b/crates/c-api/src/profiling.rs
new file mode 100644
index 000000000000..1b59b6c2e50a
--- /dev/null
+++ b/crates/c-api/src/profiling.rs
@@ -0,0 +1,67 @@
+use crate::{wasm_byte_vec_t, wasm_name_t, wasmtime_error_t, wasmtime_module_t, wasmtime_store_t};
+use std::slice;
+use std::str::from_utf8;
+use std::time::Duration;
+use wasmtime::GuestProfiler;
+
+pub struct wasmtime_guestprofiler_t {
+    guest_profiler: GuestProfiler,
+}
+
+wasmtime_c_api_macros::declare_own!(wasmtime_guestprofiler_t);
+
+#[repr(C)]
+pub struct wasmtime_guestprofiler_modules_t<'a> {
+    name: &'a wasm_name_t,
+    module: &'a wasmtime_module_t,
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasmtime_guestprofiler_new(
+    module_name: &wasm_name_t,
+    interval_nanos: u64,
+    modules: *const wasmtime_guestprofiler_modules_t,
+    modules_len: usize,
+) -> Box<wasmtime_guestprofiler_t> {
+    let module_name = from_utf8(&module_name.as_slice()).expect("not valid utf-8");
+    let list = slice::from_raw_parts(modules, modules_len)
+        .iter()
+        .map(|entry| {
+            (
+                from_utf8(entry.name.as_slice())
+                    .expect("not valid utf-8")
+                    .to_owned(),
+                entry.module.module.clone(),
+            )
+        })
+        .collect();
+    Box::new(wasmtime_guestprofiler_t {
+        guest_profiler: GuestProfiler::new(module_name, Duration::from_nanos(interval_nanos), list),
+    })
+}
+
+#[no_mangle]
+pub extern "C" fn wasmtime_guestprofiler_sample(
+    guestprofiler: &mut wasmtime_guestprofiler_t,
+    store: &wasmtime_store_t,
+    delta_nanos: u64,
+) {
+    guestprofiler
+        .guest_profiler
+        .sample(&store.store, Duration::from_nanos(delta_nanos));
+}
+
+#[no_mangle]
+pub extern "C" fn wasmtime_guestprofiler_finish(
+    guestprofiler: Box<wasmtime_guestprofiler_t>,
+    out: &mut wasm_byte_vec_t,
+) -> Option<Box<wasmtime_error_t>> {
+    let mut buf = vec![];
+    match guestprofiler.guest_profiler.finish(&mut buf) {
+        Ok(()) => {
+            out.set_buffer(buf);
+            None
+        }
+        Err(e) => Some(Box::new(e.into())),
+    }
+}
diff --git a/crates/c-api/src/ref.rs b/crates/c-api/src/ref.rs
index 7e1d3912b52d..44f14c3f9945 100644
--- a/crates/c-api/src/ref.rs
+++ b/crates/c-api/src/ref.rs
@@ -1,5 +1,6 @@
-use std::os::raw::c_void;
-use wasmtime::{ExternRef, Func, Val};
+use crate::{abort, WasmtimeStoreContextMut};
+use std::{mem::MaybeUninit, num::NonZeroU64, os::raw::c_void, ptr};
+use wasmtime::{AnyRef, ExternRef, ManuallyRooted, Ref, RootScope, Val, I31};
 
 /// `*mut wasm_ref_t` is a reference type (`externref` or `funcref`), as seen by
 /// the C API. Because we do not have a uniform representation for `funcref`s
@@ -15,34 +16,23 @@ use wasmtime::{ExternRef, Func, Val};
 /// regular, non-`repr(C)` `enum` to define `WasmRefInner`.
 #[derive(Clone)]
 pub struct wasm_ref_t {
-    pub(crate) r: WasmRefInner,
-}
-
-#[derive(Clone)]
-pub(crate) enum WasmRefInner {
-    ExternRef(ExternRef),
-    FuncRef(Func),
+    pub(crate) r: Ref,
 }
 
 wasmtime_c_api_macros::declare_own!(wasm_ref_t);
 
-pub(crate) fn ref_to_val(r: &wasm_ref_t) -> Val {
-    match &r.r {
-        WasmRefInner::ExternRef(x) => Val::ExternRef(Some(x.clone())),
-        WasmRefInner::FuncRef(f) => Val::FuncRef(Some(f.clone())),
+impl wasm_ref_t {
+    pub(crate) fn new(r: Ref) -> Option<Box<wasm_ref_t>> {
+        if r.is_null() || !r.is_func() {
+            None
+        } else {
+            Some(Box::new(wasm_ref_t { r }))
+        }
     }
 }
 
-pub(crate) fn val_into_ref(val: Val) -> Option<Box<wasm_ref_t>> {
-    match val {
-        Val::ExternRef(Some(x)) => Some(Box::new(wasm_ref_t {
-            r: WasmRefInner::ExternRef(x),
-        })),
-        Val::FuncRef(Some(f)) => Some(Box::new(wasm_ref_t {
-            r: WasmRefInner::FuncRef(f),
-        })),
-        _ => None,
-    }
+pub(crate) fn ref_to_val(r: &wasm_ref_t) -> Val {
+    Val::from(r.r.clone())
 }
 
 #[no_mangle]
@@ -50,20 +40,10 @@ pub extern "C" fn wasm_ref_copy(r: Option<&wasm_ref_t>) -> Option<Box<wasm_ref_t
     r.map(|r| Box::new(r.clone()))
 }
 
-fn abort(name: &str) -> ! {
-    eprintln!("`{}` is not implemented", name);
-    std::process::abort();
-}
-
 #[no_mangle]
-pub extern "C" fn wasm_ref_same(a: Option<&wasm_ref_t>, b: Option<&wasm_ref_t>) -> bool {
-    match (a.map(|a| &a.r), b.map(|b| &b.r)) {
-        (Some(WasmRefInner::ExternRef(a)), Some(WasmRefInner::ExternRef(b))) => a.ptr_eq(b),
-        (None, None) => true,
-        // Note: we don't support equality for `Func`, so we always return
-        // `false` for `funcref`s.
-        _ => false,
-    }
+pub extern "C" fn wasm_ref_same(_a: Option<&wasm_ref_t>, _b: Option<&wasm_ref_t>) -> bool {
+    // We need a store to determine whether these are the same reference or not.
+    abort("wasm_ref_same")
 }
 
 #[no_mangle]
@@ -201,3 +181,215 @@ wasmtime_c_api_macros::declare_ref!(wasm_foreign_t);
 pub extern "C" fn wasm_foreign_new(_store: &crate::wasm_store_t) -> Box<wasm_foreign_t> {
     abort("wasm_foreign_new")
 }
+
+/// C-API representation of `anyref`.
+///
+/// This represented differently in the C API from the header to handle how
+/// this is dispatched internally. Null anyref values are represented with a
+/// `store_id` of zero, and otherwise the `rooted` field is valid.
+///
+/// Note that this relies on the Wasmtime definition of `ManuallyRooted` to have
+/// a 64-bit store_id first.
+macro_rules! ref_wrapper {
+    ($wasmtime:ident => $c:ident) => {
+        pub struct $c {
+            store_id: u64,
+            a: u32,
+            b: u32,
+        }
+
+        impl $c {
+            pub unsafe fn as_wasmtime(&self) -> Option<ManuallyRooted<$wasmtime>> {
+                let store_id = NonZeroU64::new(self.store_id)?;
+                Some(ManuallyRooted::from_raw_parts_for_c_api(
+                    store_id, self.a, self.b,
+                ))
+            }
+        }
+
+        impl From<Option<ManuallyRooted<$wasmtime>>> for $c {
+            fn from(rooted: Option<ManuallyRooted<$wasmtime>>) -> $c {
+                let mut ret = $c {
+                    store_id: 0,
+                    a: 0,
+                    b: 0,
+                };
+                if let Some(rooted) = rooted {
+                    let (store_id, a, b) = rooted.into_parts_for_c_api();
+                    ret.store_id = store_id.get();
+                    ret.a = a;
+                    ret.b = b;
+                }
+                ret
+            }
+        }
+    };
+}
+
+ref_wrapper!(AnyRef => wasmtime_anyref_t);
+ref_wrapper!(ExternRef => wasmtime_externref_t);
+
+#[no_mangle]
+pub unsafe extern "C" fn wasmtime_anyref_clone(
+    cx: WasmtimeStoreContextMut<'_>,
+    anyref: Option<&wasmtime_anyref_t>,
+    out: &mut MaybeUninit<wasmtime_anyref_t>,
+) {
+    let anyref = anyref.and_then(|a| a.as_wasmtime()).map(|a| a.clone(cx));
+    crate::initialize(out, anyref.into());
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasmtime_anyref_unroot(
+    cx: WasmtimeStoreContextMut<'_>,
+    val: Option<&mut MaybeUninit<wasmtime_anyref_t>>,
+) {
+    if let Some(val) = val.and_then(|v| v.assume_init_read().as_wasmtime()) {
+        val.unroot(cx);
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasmtime_anyref_to_raw(
+    cx: WasmtimeStoreContextMut<'_>,
+    val: Option<&wasmtime_anyref_t>,
+) -> u32 {
+    val.and_then(|v| v.as_wasmtime())
+        .and_then(|e| e.to_raw(cx).ok())
+        .unwrap_or_default()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasmtime_anyref_from_raw(
+    cx: WasmtimeStoreContextMut<'_>,
+    raw: u32,
+    val: &mut MaybeUninit<wasmtime_anyref_t>,
+) {
+    let mut scope = RootScope::new(cx);
+    let anyref = AnyRef::from_raw(&mut scope, raw)
+        .map(|a| a.to_manually_rooted(&mut scope).expect("in scope"));
+    crate::initialize(val, anyref.into());
+}
+
+#[no_mangle]
+pub extern "C" fn wasmtime_anyref_from_i31(
+    cx: WasmtimeStoreContextMut<'_>,
+    val: u32,
+    out: &mut MaybeUninit<wasmtime_anyref_t>,
+) {
+    let mut scope = RootScope::new(cx);
+    let anyref = AnyRef::from_i31(&mut scope, I31::wrapping_u32(val));
+    let anyref = anyref.to_manually_rooted(&mut scope).expect("in scope");
+    crate::initialize(out, Some(anyref).into())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasmtime_anyref_i31_get_u(
+    cx: WasmtimeStoreContextMut<'_>,
+    anyref: Option<&wasmtime_anyref_t>,
+    dst: &mut MaybeUninit<u32>,
+) -> bool {
+    match anyref.and_then(|a| a.as_wasmtime()) {
+        Some(anyref) if anyref.is_i31(&cx).expect("ManuallyRooted always in scope") => {
+            let val = anyref
+                .unwrap_i31(&cx)
+                .expect("ManuallyRooted always in scope")
+                .get_u32();
+            crate::initialize(dst, val);
+            true
+        }
+        _ => false,
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasmtime_anyref_i31_get_s(
+    cx: WasmtimeStoreContextMut<'_>,
+    anyref: Option<&wasmtime_anyref_t>,
+    dst: &mut MaybeUninit<i32>,
+) -> bool {
+    match anyref.and_then(|a| a.as_wasmtime()) {
+        Some(anyref) if anyref.is_i31(&cx).expect("ManuallyRooted always in scope") => {
+            let val = anyref
+                .unwrap_i31(&cx)
+                .expect("ManuallyRooted always in scope")
+                .get_i32();
+            crate::initialize(dst, val);
+            true
+        }
+        _ => false,
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn wasmtime_externref_new(
+    cx: WasmtimeStoreContextMut<'_>,
+    data: *mut c_void,
+    finalizer: Option<extern "C" fn(*mut c_void)>,
+    out: &mut MaybeUninit<wasmtime_externref_t>,
+) -> bool {
+    let mut scope = RootScope::new(cx);
+    let e = match ExternRef::new(&mut scope, crate::ForeignData { data, finalizer }) {
+        Ok(e) => e,
+        Err(_) => return false,
+    };
+    let e = e.to_manually_rooted(&mut scope).expect("in scope");
+    crate::initialize(out, Some(e).into());
+    true
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasmtime_externref_data(
+    cx: WasmtimeStoreContextMut<'_>,
+    externref: Option<&wasmtime_externref_t>,
+) -> *mut c_void {
+    externref
+        .and_then(|e| e.as_wasmtime())
+        .and_then(|e| {
+            let data = e.data(cx).ok()?;
+            Some(data.downcast_ref::<crate::ForeignData>().unwrap().data)
+        })
+        .unwrap_or(ptr::null_mut())
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasmtime_externref_clone(
+    cx: WasmtimeStoreContextMut<'_>,
+    externref: Option<&wasmtime_externref_t>,
+    out: &mut MaybeUninit<wasmtime_externref_t>,
+) {
+    let externref = externref.and_then(|e| e.as_wasmtime()).map(|e| e.clone(cx));
+    crate::initialize(out, externref.into());
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasmtime_externref_unroot(
+    cx: WasmtimeStoreContextMut<'_>,
+    val: Option<&mut MaybeUninit<wasmtime_externref_t>>,
+) {
+    if let Some(val) = val.and_then(|v| v.assume_init_read().as_wasmtime()) {
+        val.unroot(cx);
+    }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasmtime_externref_to_raw(
+    cx: WasmtimeStoreContextMut<'_>,
+    val: Option<&wasmtime_externref_t>,
+) -> u32 {
+    val.and_then(|e| e.as_wasmtime())
+        .and_then(|e| e.to_raw(cx).ok())
+        .unwrap_or_default()
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn wasmtime_externref_from_raw(
+    cx: WasmtimeStoreContextMut<'_>,
+    raw: u32,
+    val: &mut MaybeUninit<wasmtime_externref_t>,
+) {
+    let mut scope = RootScope::new(cx);
+    let rooted = ExternRef::from_raw(&mut scope, raw)
+        .map(|e| e.to_manually_rooted(&mut scope).expect("in scope"));
+    crate::initialize(val, rooted.into());
+}
diff --git a/crates/c-api/src/sharedmemory.rs b/crates/c-api/src/sharedmemory.rs
new file mode 100644
index 000000000000..43d5076a935b
--- /dev/null
+++ b/crates/c-api/src/sharedmemory.rs
@@ -0,0 +1,60 @@
+use crate::{handle_result, wasm_memorytype_t, wasmtime_error_t};
+use std::cell::UnsafeCell;
+use wasmtime::SharedMemory;
+
+type wasmtime_sharedmemory_t = SharedMemory;
+
+wasmtime_c_api_macros::declare_own!(wasmtime_sharedmemory_t);
+
+#[no_mangle]
+#[cfg(feature = "threads")]
+pub extern "C" fn wasmtime_sharedmemory_new(
+    engine: &crate::wasm_engine_t,
+    ty: &wasm_memorytype_t,
+    ret: &mut *mut wasmtime_sharedmemory_t,
+) -> Option<Box<wasmtime_error_t>> {
+    handle_result(
+        SharedMemory::new(&engine.engine, ty.ty().ty.clone()),
+        |mem| *ret = Box::<wasmtime_sharedmemory_t>::into_raw(Box::new(mem)),
+    )
+}
+
+#[no_mangle]
+pub extern "C" fn wasmtime_sharedmemory_clone(
+    mem: &wasmtime_sharedmemory_t,
+) -> Box<wasmtime_sharedmemory_t> {
+    Box::new(mem.clone())
+}
+
+#[no_mangle]
+pub extern "C" fn wasmtime_sharedmemory_type(
+    mem: &wasmtime_sharedmemory_t,
+) -> Box<wasm_memorytype_t> {
+    Box::new(wasm_memorytype_t::new(mem.ty()))
+}
+
+#[no_mangle]
+pub extern "C" fn wasmtime_sharedmemory_data(
+    mem: &wasmtime_sharedmemory_t,
+) -> *const UnsafeCell<u8> {
+    mem.data().as_ptr()
+}
+
+#[no_mangle]
+pub extern "C" fn wasmtime_sharedmemory_data_size(mem: &wasmtime_sharedmemory_t) -> usize {
+    mem.data().len()
+}
+
+#[no_mangle]
+pub extern "C" fn wasmtime_sharedmemory_size(mem: &wasmtime_sharedmemory_t) -> u64 {
+    mem.size()
+}
+
+#[no_mangle]
+pub extern "C" fn wasmtime_sharedmemory_grow(
+    mem: &wasmtime_sharedmemory_t,
+    delta: u64,
+    prev_size: &mut u64,
+) -> Option<Box<wasmtime_error_t>> {
+    handle_result(mem.grow(delta), |prev| *prev_size = prev)
+}
diff --git a/crates/c-api/src/store.rs b/crates/c-api/src/store.rs
index d56977619888..bffe3c9a3463 100644
--- a/crates/c-api/src/store.rs
+++ b/crates/c-api/src/store.rs
@@ -3,11 +3,19 @@ use std::cell::UnsafeCell;
 use std::ffi::c_void;
 use std::sync::Arc;
 use wasmtime::{
-    AsContext, AsContextMut, Store, StoreContext, StoreContextMut, StoreLimits, StoreLimitsBuilder,
-    UpdateDeadline, Val,
+    AsContext, AsContextMut, Caller, Store, StoreContext, StoreContextMut, StoreLimits,
+    StoreLimitsBuilder, UpdateDeadline, Val,
 };
 
-/// This representation of a `Store` is used to implement the `wasm.h` API.
+// Store-related type aliases for `wasm.h` APIs. Not for use with `wasmtime.h`
+// APIs!
+pub type WasmStoreData = ();
+pub type WasmStore = Store<WasmStoreData>;
+pub type WasmStoreContext<'a> = StoreContext<'a, WasmStoreData>;
+pub type WasmStoreContextMut<'a> = StoreContextMut<'a, WasmStoreData>;
+
+/// This representation of a `Store` is used to implement the `wasm.h` API (and
+/// *not* the `wasmtime.h` API!)
 ///
 /// This is stored alongside `Func` and such for `wasm.h` so each object is
 /// independently owned. The usage of `Arc` here is mostly to just get it to be
@@ -18,16 +26,16 @@ use wasmtime::{
 /// The aliasing requirements are documented in the C API `wasm.h` itself (at
 /// least Wasmtime's implementation).
 #[derive(Clone)]
-pub struct StoreRef {
-    store: Arc<UnsafeCell<Store<()>>>,
+pub struct WasmStoreRef {
+    store: Arc<UnsafeCell<WasmStore>>,
 }
 
-impl StoreRef {
-    pub unsafe fn context(&self) -> StoreContext<'_, ()> {
+impl WasmStoreRef {
+    pub unsafe fn context(&self) -> WasmStoreContext<'_> {
         (*self.store.get()).as_context()
     }
 
-    pub unsafe fn context_mut(&mut self) -> StoreContextMut<'_, ()> {
+    pub unsafe fn context_mut(&mut self) -> WasmStoreContextMut<'_> {
         (*self.store.get()).as_context_mut()
     }
 }
@@ -35,7 +43,7 @@ impl StoreRef {
 #[repr(C)]
 #[derive(Clone)]
 pub struct wasm_store_t {
-    pub(crate) store: StoreRef,
+    pub(crate) store: WasmStoreRef,
 }
 
 wasmtime_c_api_macros::declare_own!(wasm_store_t);
@@ -45,33 +53,37 @@ pub extern "C" fn wasm_store_new(engine: &wasm_engine_t) -> Box<wasm_store_t> {
     let engine = &engine.engine;
     let store = Store::new(engine, ());
     Box::new(wasm_store_t {
-        store: StoreRef {
+        store: WasmStoreRef {
             store: Arc::new(UnsafeCell::new(store)),
         },
     })
 }
 
+// Store-related type aliases for `wasmtime.h` APIs. Not for use with `wasm.h`
+// APIs!
+pub type WasmtimeStore = Store<WasmtimeStoreData>;
+pub type WasmtimeStoreContext<'a> = StoreContext<'a, WasmtimeStoreData>;
+pub type WasmtimeStoreContextMut<'a> = StoreContextMut<'a, WasmtimeStoreData>;
+pub type WasmtimeCaller<'a> = Caller<'a, WasmtimeStoreData>;
+
 /// Representation of a `Store` for `wasmtime.h` This notably tries to move more
 /// burden of aliasing on the caller rather than internally, allowing for a more
 /// raw representation of contexts and such that requires less `unsafe` in the
 /// implementation.
 ///
-/// Note that this notably carries `StoreData` as a payload which allows storing
-/// foreign data and configuring WASI as well.
+/// Note that this notably carries `WasmtimeStoreData` as a payload which allows
+/// storing foreign data and configuring WASI as well.
 #[repr(C)]
 pub struct wasmtime_store_t {
-    pub(crate) store: Store<StoreData>,
+    pub(crate) store: WasmtimeStore,
 }
 
 wasmtime_c_api_macros::declare_own!(wasmtime_store_t);
 
-pub type CStoreContext<'a> = StoreContext<'a, StoreData>;
-pub type CStoreContextMut<'a> = StoreContextMut<'a, StoreData>;
-
-pub struct StoreData {
+pub struct WasmtimeStoreData {
     foreign: crate::ForeignData,
     #[cfg(feature = "wasi")]
-    pub(crate) wasi: Option<wasmtime_wasi::WasiCtx>,
+    pub(crate) wasi: Option<wasmtime_wasi::preview1::WasiP1Ctx>,
 
     /// Temporary storage for usage during a wasm->host call to store values
     /// in a slice we pass to the C API.
@@ -94,7 +106,7 @@ pub extern "C" fn wasmtime_store_new(
     Box::new(wasmtime_store_t {
         store: Store::new(
             &engine.engine,
-            StoreData {
+            WasmtimeStoreData {
                 foreign: ForeignData { data, finalizer },
                 #[cfg(feature = "wasi")]
                 wasi: None,
@@ -106,50 +118,51 @@ pub extern "C" fn wasmtime_store_new(
     })
 }
 
-// Internal structure to add Send/Sync to the c_void member.
-#[derive(Debug)]
-pub struct CallbackDataPtr {
-    pub ptr: *mut c_void,
-}
-
-impl CallbackDataPtr {
-    fn as_mut_ptr(&self) -> *mut c_void {
-        self.ptr
-    }
-}
-
-unsafe impl Send for CallbackDataPtr {}
-unsafe impl Sync for CallbackDataPtr {}
+pub type wasmtime_update_deadline_kind_t = u8;
+pub const WASMTIME_UPDATE_DEADLINE_CONTINUE: wasmtime_update_deadline_kind_t = 0;
+pub const WASMTIME_UPDATE_DEADLINE_YIELD: wasmtime_update_deadline_kind_t = 1;
 
 #[no_mangle]
 pub extern "C" fn wasmtime_store_epoch_deadline_callback(
     store: &mut wasmtime_store_t,
     func: extern "C" fn(
-        CStoreContextMut<'_>,
+        WasmtimeStoreContextMut<'_>,
         *mut c_void,
         *mut u64,
+        *mut wasmtime_update_deadline_kind_t,
     ) -> Option<Box<wasmtime_error_t>>,
     data: *mut c_void,
+    finalizer: Option<extern "C" fn(*mut c_void)>,
 ) {
-    let sendable = CallbackDataPtr { ptr: data };
+    let foreign = crate::ForeignData { data, finalizer };
     store.store.epoch_deadline_callback(move |mut store_ctx| {
+        let _ = &foreign; // Move foreign into this closure
         let mut delta: u64 = 0;
+        let mut kind = WASMTIME_UPDATE_DEADLINE_CONTINUE;
         let result = (func)(
             store_ctx.as_context_mut(),
-            sendable.as_mut_ptr(),
+            foreign.data,
             &mut delta as *mut u64,
+            &mut kind as *mut wasmtime_update_deadline_kind_t,
         );
         match result {
             Some(err) => Err(wasmtime::Error::from(<wasmtime_error_t as Into<
                 anyhow::Error,
             >>::into(*err))),
-            None => Ok(UpdateDeadline::Continue(delta)),
+            None if kind == WASMTIME_UPDATE_DEADLINE_CONTINUE => {
+                Ok(UpdateDeadline::Continue(delta))
+            }
+            #[cfg(feature = "async")]
+            None if kind == WASMTIME_UPDATE_DEADLINE_YIELD => Ok(UpdateDeadline::Yield(delta)),
+            _ => panic!("unknown wasmtime_update_deadline_kind_t: {kind}"),
         }
     });
 }
 
 #[no_mangle]
-pub extern "C" fn wasmtime_store_context(store: &mut wasmtime_store_t) -> CStoreContextMut<'_> {
+pub extern "C" fn wasmtime_store_context(
+    store: &mut wasmtime_store_t,
+) -> WasmtimeStoreContextMut<'_> {
     store.store.as_context_mut()
 }
 
@@ -183,19 +196,22 @@ pub extern "C" fn wasmtime_store_limiter(
 }
 
 #[no_mangle]
-pub extern "C" fn wasmtime_context_get_data(store: CStoreContext<'_>) -> *mut c_void {
+pub extern "C" fn wasmtime_context_get_data(store: WasmtimeStoreContext<'_>) -> *mut c_void {
     store.data().foreign.data
 }
 
 #[no_mangle]
-pub extern "C" fn wasmtime_context_set_data(mut store: CStoreContextMut<'_>, data: *mut c_void) {
+pub extern "C" fn wasmtime_context_set_data(
+    mut store: WasmtimeStoreContextMut<'_>,
+    data: *mut c_void,
+) {
     store.data_mut().foreign.data = data;
 }
 
 #[cfg(feature = "wasi")]
 #[no_mangle]
 pub extern "C" fn wasmtime_context_set_wasi(
-    mut context: CStoreContextMut<'_>,
+    mut context: WasmtimeStoreContextMut<'_>,
     wasi: Box<crate::wasi_config_t>,
 ) -> Option<Box<wasmtime_error_t>> {
     crate::handle_result(wasi.into_wasi_ctx(), |wasi| {
@@ -204,57 +220,31 @@ pub extern "C" fn wasmtime_context_set_wasi(
 }
 
 #[no_mangle]
-pub extern "C" fn wasmtime_context_gc(mut context: CStoreContextMut<'_>) {
+pub extern "C" fn wasmtime_context_gc(mut context: WasmtimeStoreContextMut<'_>) {
     context.gc();
 }
 
 #[no_mangle]
-pub extern "C" fn wasmtime_context_add_fuel(
-    mut store: CStoreContextMut<'_>,
+pub extern "C" fn wasmtime_context_set_fuel(
+    mut store: WasmtimeStoreContextMut<'_>,
     fuel: u64,
 ) -> Option<Box<wasmtime_error_t>> {
-    crate::handle_result(store.add_fuel(fuel), |()| {})
+    crate::handle_result(store.set_fuel(fuel), |()| {})
 }
 
 #[no_mangle]
-pub extern "C" fn wasmtime_context_fuel_consumed(store: CStoreContext<'_>, fuel: &mut u64) -> bool {
-    match store.fuel_consumed() {
-        Some(amt) => {
-            *fuel = amt;
-            true
-        }
-        None => false,
-    }
-}
-
-#[no_mangle]
-pub extern "C" fn wasmtime_context_fuel_remaining(
-    store: CStoreContextMut<'_>,
+pub extern "C" fn wasmtime_context_get_fuel(
+    store: WasmtimeStoreContext<'_>,
     fuel: &mut u64,
-) -> bool {
-    match store.fuel_remaining() {
-        Some(remaining) => {
-            *fuel = remaining;
-            true
-        }
-        None => false,
-    }
-}
-
-#[no_mangle]
-pub extern "C" fn wasmtime_context_consume_fuel(
-    mut store: CStoreContextMut<'_>,
-    fuel: u64,
-    remaining_fuel: &mut u64,
 ) -> Option<Box<wasmtime_error_t>> {
-    crate::handle_result(store.consume_fuel(fuel), |remaining| {
-        *remaining_fuel = remaining;
+    crate::handle_result(store.get_fuel(), |amt| {
+        *fuel = amt;
     })
 }
 
 #[no_mangle]
 pub extern "C" fn wasmtime_context_set_epoch_deadline(
-    mut store: CStoreContextMut<'_>,
+    mut store: WasmtimeStoreContextMut<'_>,
     ticks_beyond_current: u64,
 ) {
     store.set_epoch_deadline(ticks_beyond_current);
diff --git a/crates/c-api/src/table.rs b/crates/c-api/src/table.rs
index 304754fd757f..d7ff324580b8 100644
--- a/crates/c-api/src/table.rs
+++ b/crates/c-api/src/table.rs
@@ -1,10 +1,10 @@
-use crate::r#ref::{ref_to_val, val_into_ref};
 use crate::{
     handle_result, wasm_extern_t, wasm_ref_t, wasm_store_t, wasm_tabletype_t, wasmtime_error_t,
-    wasmtime_val_t, CStoreContext, CStoreContextMut,
+    wasmtime_val_t, WasmtimeStoreContext, WasmtimeStoreContextMut,
 };
+use anyhow::anyhow;
 use std::mem::MaybeUninit;
-use wasmtime::{Extern, Table, TableType, Val, ValType};
+use wasmtime::{Extern, Ref, RootScope, Table, TableType};
 
 #[derive(Clone)]
 #[repr(transparent)]
@@ -32,15 +32,9 @@ impl wasm_table_t {
     }
 }
 
-fn ref_to_val_for_table(r: Option<&wasm_ref_t>, table_ty: &TableType) -> Val {
-    r.map_or_else(
-        || match table_ty.element() {
-            ValType::FuncRef => Val::FuncRef(None),
-            ValType::ExternRef => Val::ExternRef(None),
-            ty => panic!("unsupported table element type: {:?}", ty),
-        },
-        |r| ref_to_val(r),
-    )
+fn option_wasm_ref_t_to_ref(r: Option<&wasm_ref_t>, table_ty: &TableType) -> Ref {
+    r.map(|r| r.r.clone())
+        .unwrap_or_else(|| Ref::null(table_ty.element().heap_type()))
 }
 
 #[no_mangle]
@@ -49,8 +43,9 @@ pub unsafe extern "C" fn wasm_table_new(
     tt: &wasm_tabletype_t,
     init: Option<&wasm_ref_t>,
 ) -> Option<Box<wasm_table_t>> {
-    let init = ref_to_val_for_table(init, &tt.ty().ty);
-    let table = Table::new(store.store.context_mut(), tt.ty().ty.clone(), init).ok()?;
+    let tt = tt.ty().ty.clone();
+    let init = option_wasm_ref_t_to_ref(init, &tt);
+    let table = Table::new(store.store.context_mut(), tt, init).ok()?;
     Some(Box::new(wasm_table_t {
         ext: wasm_extern_t {
             store: store.store.clone(),
@@ -72,8 +67,8 @@ pub unsafe extern "C" fn wasm_table_get(
     index: wasm_table_size_t,
 ) -> Option<Box<wasm_ref_t>> {
     let table = t.table();
-    let val = table.get(t.ext.store.context_mut(), index)?;
-    val_into_ref(val)
+    let r = table.get(t.ext.store.context_mut(), index)?;
+    wasm_ref_t::new(r)
 }
 
 #[no_mangle]
@@ -83,7 +78,7 @@ pub unsafe extern "C" fn wasm_table_set(
     r: Option<&wasm_ref_t>,
 ) -> bool {
     let table = t.table();
-    let val = ref_to_val_for_table(r, &table.ty(t.ext.store.context()));
+    let val = option_wasm_ref_t_to_ref(r, &table.ty(t.ext.store.context()));
     table.set(t.ext.store.context_mut(), index, val).is_ok()
 }
 
@@ -101,7 +96,7 @@ pub unsafe extern "C" fn wasm_table_grow(
     init: Option<&wasm_ref_t>,
 ) -> bool {
     let table = t.table();
-    let init = ref_to_val_for_table(init, &table.ty(t.ext.store.context()));
+    let init = option_wasm_ref_t_to_ref(init, &table.ty(t.ext.store.context()));
     table.grow(t.ext.store.context_mut(), delta, init).is_ok()
 }
 
@@ -117,20 +112,24 @@ pub extern "C" fn wasm_table_as_extern_const(t: &wasm_table_t) -> &wasm_extern_t
 
 #[no_mangle]
 pub unsafe extern "C" fn wasmtime_table_new(
-    store: CStoreContextMut<'_>,
+    mut store: WasmtimeStoreContextMut<'_>,
     tt: &wasm_tabletype_t,
     init: &wasmtime_val_t,
     out: &mut Table,
 ) -> Option<Box<wasmtime_error_t>> {
+    let mut scope = RootScope::new(&mut store);
     handle_result(
-        Table::new(store, tt.ty().ty.clone(), init.to_val()),
+        init.to_val(&mut scope)
+            .ref_()
+            .ok_or_else(|| anyhow!("wasmtime_table_new init value is not a reference"))
+            .and_then(|init| Table::new(scope, tt.ty().ty.clone(), init)),
         |table| *out = table,
     )
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn wasmtime_table_type(
-    store: CStoreContext<'_>,
+    store: WasmtimeStoreContext<'_>,
     table: &Table,
 ) -> Box<wasm_tabletype_t> {
     Box::new(wasm_tabletype_t::new(table.ty(store)))
@@ -138,14 +137,15 @@ pub unsafe extern "C" fn wasmtime_table_type(
 
 #[no_mangle]
 pub extern "C" fn wasmtime_table_get(
-    store: CStoreContextMut<'_>,
+    store: WasmtimeStoreContextMut<'_>,
     table: &Table,
     index: u32,
     ret: &mut MaybeUninit<wasmtime_val_t>,
 ) -> bool {
-    match table.get(store, index) {
-        Some(val) => {
-            crate::initialize(ret, wasmtime_val_t::from_val(val));
+    let mut scope = RootScope::new(store);
+    match table.get(&mut scope, index) {
+        Some(r) => {
+            crate::initialize(ret, wasmtime_val_t::from_val(&mut scope, r.into()));
             true
         }
         None => false,
@@ -154,28 +154,40 @@ pub extern "C" fn wasmtime_table_get(
 
 #[no_mangle]
 pub unsafe extern "C" fn wasmtime_table_set(
-    store: CStoreContextMut<'_>,
+    mut store: WasmtimeStoreContextMut<'_>,
     table: &Table,
     index: u32,
     val: &wasmtime_val_t,
 ) -> Option<Box<wasmtime_error_t>> {
-    handle_result(table.set(store, index, val.to_val()), |()| {})
+    let mut scope = RootScope::new(&mut store);
+    handle_result(
+        val.to_val(&mut scope)
+            .ref_()
+            .ok_or_else(|| anyhow!("wasmtime_table_set value is not a reference"))
+            .and_then(|val| table.set(scope, index, val)),
+        |()| {},
+    )
 }
 
 #[no_mangle]
-pub extern "C" fn wasmtime_table_size(store: CStoreContext<'_>, table: &Table) -> u32 {
+pub extern "C" fn wasmtime_table_size(store: WasmtimeStoreContext<'_>, table: &Table) -> u32 {
     table.size(store)
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn wasmtime_table_grow(
-    store: CStoreContextMut<'_>,
+    mut store: WasmtimeStoreContextMut<'_>,
     table: &Table,
     delta: u32,
     val: &wasmtime_val_t,
     prev_size: &mut u32,
 ) -> Option<Box<wasmtime_error_t>> {
-    handle_result(table.grow(store, delta, val.to_val()), |prev| {
-        *prev_size = prev
-    })
+    let mut scope = RootScope::new(&mut store);
+    handle_result(
+        val.to_val(&mut scope)
+            .ref_()
+            .ok_or_else(|| anyhow!("wasmtime_table_grow value is not a reference"))
+            .and_then(|val| table.grow(scope, delta, val)),
+        |prev| *prev_size = prev,
+    )
 }
diff --git a/crates/c-api/src/types/export.rs b/crates/c-api/src/types/export.rs
index 3d83cc41faca..2eca463d82b2 100644
--- a/crates/c-api/src/types/export.rs
+++ b/crates/c-api/src/types/export.rs
@@ -1,12 +1,11 @@
-use crate::{wasm_externtype_t, wasm_name_t};
+use crate::{wasm_externtype_t, wasm_name_t, CExternType};
 use once_cell::unsync::OnceCell;
-use wasmtime::ExternType;
 
 #[repr(C)]
 #[derive(Clone)]
 pub struct wasm_exporttype_t {
     name: String,
-    ty: ExternType,
+    ty: CExternType,
     name_cache: OnceCell<wasm_name_t>,
     type_cache: OnceCell<wasm_externtype_t>,
 }
@@ -14,7 +13,7 @@ pub struct wasm_exporttype_t {
 wasmtime_c_api_macros::declare_ty!(wasm_exporttype_t);
 
 impl wasm_exporttype_t {
-    pub(crate) fn new(name: String, ty: ExternType) -> wasm_exporttype_t {
+    pub(crate) fn new(name: String, ty: CExternType) -> wasm_exporttype_t {
         wasm_exporttype_t {
             name,
             ty,
@@ -31,7 +30,7 @@ pub extern "C" fn wasm_exporttype_new(
 ) -> Option<Box<wasm_exporttype_t>> {
     let name = name.take();
     let name = String::from_utf8(name).ok()?;
-    Some(Box::new(wasm_exporttype_t::new(name, ty.ty())))
+    Some(Box::new(wasm_exporttype_t::new(name, ty.which.clone())))
 }
 
 #[no_mangle]
@@ -43,5 +42,5 @@ pub extern "C" fn wasm_exporttype_name(et: &wasm_exporttype_t) -> &wasm_name_t {
 #[no_mangle]
 pub extern "C" fn wasm_exporttype_type(et: &wasm_exporttype_t) -> &wasm_externtype_t {
     et.type_cache
-        .get_or_init(|| wasm_externtype_t::new(et.ty.clone()))
+        .get_or_init(|| wasm_externtype_t::from_cextern_type(et.ty.clone()))
 }
diff --git a/crates/c-api/src/types/extern.rs b/crates/c-api/src/types/extern.rs
index 21278a25e722..c85dcbb25cfd 100644
--- a/crates/c-api/src/types/extern.rs
+++ b/crates/c-api/src/types/extern.rs
@@ -18,6 +18,17 @@ pub(crate) enum CExternType {
     Table(CTableType),
 }
 
+impl CExternType {
+    pub(crate) fn new(ty: ExternType) -> CExternType {
+        match ty {
+            ExternType::Func(f) => CExternType::Func(CFuncType::new(f)),
+            ExternType::Global(f) => CExternType::Global(CGlobalType::new(f)),
+            ExternType::Memory(f) => CExternType::Memory(CMemoryType::new(f)),
+            ExternType::Table(f) => CExternType::Table(CTableType::new(f)),
+        }
+    }
+}
+
 pub type wasm_externkind_t = u8;
 
 pub const WASM_EXTERN_FUNC: wasm_externkind_t = 0;
@@ -26,24 +37,14 @@ pub const WASM_EXTERN_TABLE: wasm_externkind_t = 2;
 pub const WASM_EXTERN_MEMORY: wasm_externkind_t = 3;
 
 impl wasm_externtype_t {
-    pub(crate) fn new(ty: ExternType) -> wasm_externtype_t {
+    pub(crate) fn from_extern_type(ty: ExternType) -> wasm_externtype_t {
         wasm_externtype_t {
-            which: match ty {
-                ExternType::Func(f) => CExternType::Func(CFuncType::new(f)),
-                ExternType::Global(f) => CExternType::Global(CGlobalType::new(f)),
-                ExternType::Memory(f) => CExternType::Memory(CMemoryType::new(f)),
-                ExternType::Table(f) => CExternType::Table(CTableType::new(f)),
-            },
+            which: CExternType::new(ty),
         }
     }
 
-    pub(crate) fn ty(&self) -> ExternType {
-        match &self.which {
-            CExternType::Func(f) => ExternType::Func(f.ty.clone()),
-            CExternType::Table(f) => ExternType::Table(f.ty.clone()),
-            CExternType::Global(f) => ExternType::Global(f.ty.clone()),
-            CExternType::Memory(f) => ExternType::Memory(f.ty.clone()),
-        }
+    pub(crate) fn from_cextern_type(ty: CExternType) -> wasm_externtype_t {
+        wasm_externtype_t { which: ty }
     }
 }
 
diff --git a/crates/c-api/src/types/func.rs b/crates/c-api/src/types/func.rs
index 1b4ca752febf..c2158902b2de 100644
--- a/crates/c-api/src/types/func.rs
+++ b/crates/c-api/src/types/func.rs
@@ -1,6 +1,10 @@
 use crate::{wasm_externtype_t, wasm_valtype_t, wasm_valtype_vec_t, CExternType};
 use once_cell::unsync::OnceCell;
-use wasmtime::FuncType;
+use std::{
+    mem,
+    sync::{Arc, Mutex},
+};
+use wasmtime::{Engine, FuncType, ValType};
 
 #[repr(transparent)]
 #[derive(Clone)]
@@ -10,9 +14,75 @@ pub struct wasm_functype_t {
 
 wasmtime_c_api_macros::declare_ty!(wasm_functype_t);
 
+#[derive(Clone)]
+enum LazyFuncType {
+    Lazy {
+        params: Vec<ValType>,
+        results: Vec<ValType>,
+    },
+    FuncType(FuncType),
+}
+
+impl LazyFuncType {
+    pub(crate) fn force(&mut self, engine: &Engine) -> FuncType {
+        match self {
+            LazyFuncType::FuncType(ty) => ty.clone(),
+            LazyFuncType::Lazy { params, results } => {
+                let params = mem::take(params);
+                let results = mem::take(results);
+                let ty = FuncType::new(engine, params, results);
+                *self = LazyFuncType::FuncType(ty.clone());
+                ty
+            }
+        }
+    }
+
+    fn params(&self) -> impl ExactSizeIterator<Item = ValType> + '_ {
+        match self {
+            LazyFuncType::Lazy { params, .. } => LazyFuncTypeIter::Lazy(params.iter()),
+            LazyFuncType::FuncType(f) => LazyFuncTypeIter::FuncType(f.params()),
+        }
+    }
+
+    fn results(&self) -> impl ExactSizeIterator<Item = ValType> + '_ {
+        match self {
+            LazyFuncType::Lazy { results, .. } => LazyFuncTypeIter::Lazy(results.iter()),
+            LazyFuncType::FuncType(f) => LazyFuncTypeIter::FuncType(f.results()),
+        }
+    }
+}
+
+enum LazyFuncTypeIter<'a, T> {
+    Lazy(std::slice::Iter<'a, ValType>),
+    FuncType(T),
+}
+
+impl<'a, T> Iterator for LazyFuncTypeIter<'a, T>
+where
+    T: Iterator<Item = ValType>,
+{
+    type Item = ValType;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self {
+            LazyFuncTypeIter::FuncType(i) => i.next(),
+            LazyFuncTypeIter::Lazy(i) => i.next().cloned(),
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        match self {
+            LazyFuncTypeIter::FuncType(i) => i.size_hint(),
+            LazyFuncTypeIter::Lazy(i) => i.size_hint(),
+        }
+    }
+}
+
+impl<'a, T> ExactSizeIterator for LazyFuncTypeIter<'a, T> where T: ExactSizeIterator<Item = ValType> {}
+
 #[derive(Clone)]
 pub(crate) struct CFuncType {
-    pub(crate) ty: FuncType,
+    ty: Arc<Mutex<LazyFuncType>>,
     params_cache: OnceCell<wasm_valtype_vec_t>,
     returns_cache: OnceCell<wasm_valtype_vec_t>,
 }
@@ -20,7 +90,15 @@ pub(crate) struct CFuncType {
 impl wasm_functype_t {
     pub(crate) fn new(ty: FuncType) -> wasm_functype_t {
         wasm_functype_t {
-            ext: wasm_externtype_t::new(ty.into()),
+            ext: wasm_externtype_t::from_extern_type(ty.into()),
+        }
+    }
+
+    pub(crate) fn lazy(params: Vec<ValType>, results: Vec<ValType>) -> wasm_functype_t {
+        wasm_functype_t {
+            ext: wasm_externtype_t::from_cextern_type(CExternType::Func(CFuncType::lazy(
+                params, results,
+            ))),
         }
     }
 
@@ -42,11 +120,24 @@ impl wasm_functype_t {
 impl CFuncType {
     pub(crate) fn new(ty: FuncType) -> CFuncType {
         CFuncType {
-            ty,
+            ty: Arc::new(Mutex::new(LazyFuncType::FuncType(ty))),
             params_cache: OnceCell::new(),
             returns_cache: OnceCell::new(),
         }
     }
+
+    pub(crate) fn lazy(params: Vec<ValType>, results: Vec<ValType>) -> CFuncType {
+        CFuncType {
+            ty: Arc::new(Mutex::new(LazyFuncType::Lazy { params, results })),
+            params_cache: OnceCell::new(),
+            returns_cache: OnceCell::new(),
+        }
+    }
+
+    pub(crate) fn ty(&self, engine: &Engine) -> FuncType {
+        let mut ty = self.ty.lock().unwrap();
+        ty.force(engine)
+    }
 }
 
 #[no_mangle]
@@ -54,18 +145,25 @@ pub extern "C" fn wasm_functype_new(
     params: &mut wasm_valtype_vec_t,
     results: &mut wasm_valtype_vec_t,
 ) -> Box<wasm_functype_t> {
-    let params = params.take().into_iter().map(|vt| vt.unwrap().ty.clone());
-    let results = results.take().into_iter().map(|vt| vt.unwrap().ty.clone());
-    let functype = FuncType::new(params, results);
-    Box::new(wasm_functype_t::new(functype))
+    let params = params
+        .take()
+        .into_iter()
+        .map(|vt| vt.unwrap().ty.clone())
+        .collect();
+    let results = results
+        .take()
+        .into_iter()
+        .map(|vt| vt.unwrap().ty.clone())
+        .collect();
+    Box::new(wasm_functype_t::lazy(params, results))
 }
 
 #[no_mangle]
 pub extern "C" fn wasm_functype_params(ft: &wasm_functype_t) -> &wasm_valtype_vec_t {
     let ft = ft.ty();
     ft.params_cache.get_or_init(|| {
-        ft.ty
-            .params()
+        let ty = ft.ty.lock().unwrap();
+        ty.params()
             .map(|p| Some(Box::new(wasm_valtype_t { ty: p.clone() })))
             .collect::<Vec<_>>()
             .into()
@@ -76,8 +174,8 @@ pub extern "C" fn wasm_functype_params(ft: &wasm_functype_t) -> &wasm_valtype_ve
 pub extern "C" fn wasm_functype_results(ft: &wasm_functype_t) -> &wasm_valtype_vec_t {
     let ft = ft.ty();
     ft.returns_cache.get_or_init(|| {
-        ft.ty
-            .results()
+        let ty = ft.ty.lock().unwrap();
+        ty.results()
             .map(|p| Some(Box::new(wasm_valtype_t { ty: p.clone() })))
             .collect::<Vec<_>>()
             .into()
diff --git a/crates/c-api/src/types/global.rs b/crates/c-api/src/types/global.rs
index 9fde1f304dc1..176c41865036 100644
--- a/crates/c-api/src/types/global.rs
+++ b/crates/c-api/src/types/global.rs
@@ -24,7 +24,7 @@ pub(crate) struct CGlobalType {
 impl wasm_globaltype_t {
     pub(crate) fn new(ty: GlobalType) -> wasm_globaltype_t {
         wasm_globaltype_t {
-            ext: wasm_externtype_t::new(ty.into()),
+            ext: wasm_externtype_t::from_extern_type(ty.into()),
         }
     }
 
diff --git a/crates/c-api/src/types/import.rs b/crates/c-api/src/types/import.rs
index f9e97a287074..9484ab528070 100644
--- a/crates/c-api/src/types/import.rs
+++ b/crates/c-api/src/types/import.rs
@@ -1,13 +1,12 @@
-use crate::{wasm_externtype_t, wasm_name_t};
+use crate::{wasm_externtype_t, wasm_name_t, CExternType};
 use once_cell::unsync::OnceCell;
-use wasmtime::ExternType;
 
 #[repr(C)]
 #[derive(Clone)]
 pub struct wasm_importtype_t {
     pub(crate) module: String,
     pub(crate) name: String,
-    pub(crate) ty: ExternType,
+    pub(crate) ty: CExternType,
     module_cache: OnceCell<wasm_name_t>,
     name_cache: OnceCell<wasm_name_t>,
     type_cache: OnceCell<wasm_externtype_t>,
@@ -16,7 +15,7 @@ pub struct wasm_importtype_t {
 wasmtime_c_api_macros::declare_ty!(wasm_importtype_t);
 
 impl wasm_importtype_t {
-    pub(crate) fn new(module: String, name: String, ty: ExternType) -> wasm_importtype_t {
+    pub(crate) fn new(module: String, name: String, ty: CExternType) -> wasm_importtype_t {
         wasm_importtype_t {
             module,
             name,
@@ -38,7 +37,11 @@ pub extern "C" fn wasm_importtype_new(
     let name = name.take();
     let module = String::from_utf8(module).ok()?;
     let name = String::from_utf8(name).ok()?;
-    Some(Box::new(wasm_importtype_t::new(module, name, ty.ty())))
+    Some(Box::new(wasm_importtype_t::new(
+        module,
+        name,
+        ty.which.clone(),
+    )))
 }
 
 #[no_mangle]
@@ -56,5 +59,5 @@ pub extern "C" fn wasm_importtype_name(it: &wasm_importtype_t) -> &wasm_name_t {
 #[no_mangle]
 pub extern "C" fn wasm_importtype_type(it: &wasm_importtype_t) -> &wasm_externtype_t {
     it.type_cache
-        .get_or_init(|| wasm_externtype_t::new(it.ty.clone()))
+        .get_or_init(|| wasm_externtype_t::from_cextern_type(it.ty.clone()))
 }
diff --git a/crates/c-api/src/types/memory.rs b/crates/c-api/src/types/memory.rs
index 45f9a5c19f99..bcdb933d7c56 100644
--- a/crates/c-api/src/types/memory.rs
+++ b/crates/c-api/src/types/memory.rs
@@ -20,7 +20,7 @@ pub(crate) struct CMemoryType {
 impl wasm_memorytype_t {
     pub(crate) fn new(ty: MemoryType) -> wasm_memorytype_t {
         wasm_memorytype_t {
-            ext: wasm_externtype_t::new(ty.into()),
+            ext: wasm_externtype_t::from_extern_type(ty.into()),
         }
     }
 
@@ -108,6 +108,11 @@ pub extern "C" fn wasmtime_memorytype_is64(mt: &wasm_memorytype_t) -> bool {
     mt.ty().ty.is_64()
 }
 
+#[no_mangle]
+pub extern "C" fn wasmtime_memorytype_isshared(mt: &wasm_memorytype_t) -> bool {
+    mt.ty().ty.is_shared()
+}
+
 #[no_mangle]
 pub extern "C" fn wasm_memorytype_as_externtype(ty: &wasm_memorytype_t) -> &wasm_externtype_t {
     &ty.ext
diff --git a/crates/c-api/src/types/table.rs b/crates/c-api/src/types/table.rs
index 6599baecd10d..a31b5ef10720 100644
--- a/crates/c-api/src/types/table.rs
+++ b/crates/c-api/src/types/table.rs
@@ -1,6 +1,6 @@
 use crate::{wasm_externtype_t, wasm_limits_t, wasm_valtype_t, CExternType};
 use once_cell::unsync::OnceCell;
-use wasmtime::TableType;
+use wasmtime::{TableType, ValType};
 
 #[repr(transparent)]
 #[derive(Clone)]
@@ -20,7 +20,7 @@ pub(crate) struct CTableType {
 impl wasm_tabletype_t {
     pub(crate) fn new(ty: TableType) -> wasm_tabletype_t {
         wasm_tabletype_t {
-            ext: wasm_externtype_t::new(ty.into()),
+            ext: wasm_externtype_t::from_extern_type(ty.into()),
         }
     }
 
@@ -53,19 +53,20 @@ impl CTableType {
 pub extern "C" fn wasm_tabletype_new(
     ty: Box<wasm_valtype_t>,
     limits: &wasm_limits_t,
-) -> Box<wasm_tabletype_t> {
-    Box::new(wasm_tabletype_t::new(TableType::new(
-        ty.ty,
+) -> Option<Box<wasm_tabletype_t>> {
+    let ty = ty.ty.as_ref()?.clone();
+    Some(Box::new(wasm_tabletype_t::new(TableType::new(
+        ty,
         limits.min,
         limits.max(),
-    )))
+    ))))
 }
 
 #[no_mangle]
 pub extern "C" fn wasm_tabletype_element(tt: &wasm_tabletype_t) -> &wasm_valtype_t {
     let tt = tt.ty();
     tt.element_cache.get_or_init(|| wasm_valtype_t {
-        ty: tt.ty.element().clone(),
+        ty: ValType::Ref(tt.ty.element().clone()),
     })
 }
 
diff --git a/crates/c-api/src/types/val.rs b/crates/c-api/src/types/val.rs
index 7508170e6c30..def5c556c0ba 100644
--- a/crates/c-api/src/types/val.rs
+++ b/crates/c-api/src/types/val.rs
@@ -1,4 +1,4 @@
-use wasmtime::ValType;
+use wasmtime::{HeapType, ValType};
 
 #[repr(C)]
 #[derive(Clone)]
@@ -34,10 +34,10 @@ pub(crate) fn into_valtype(kind: wasm_valkind_t) -> ValType {
         WASM_I64 => ValType::I64,
         WASM_F32 => ValType::F32,
         WASM_F64 => ValType::F64,
-        WASM_EXTERNREF => ValType::ExternRef,
-        WASM_FUNCREF => ValType::FuncRef,
+        WASM_EXTERNREF => ValType::EXTERNREF,
+        WASM_FUNCREF => ValType::FUNCREF,
         WASMTIME_V128 => ValType::V128,
-        _ => panic!("unexpected kind: {}", kind),
+        _ => panic!("unexpected kind: {kind}"),
     }
 }
 
@@ -47,9 +47,12 @@ pub(crate) fn from_valtype(ty: &ValType) -> wasm_valkind_t {
         ValType::I64 => WASM_I64,
         ValType::F32 => WASM_F32,
         ValType::F64 => WASM_F64,
-        ValType::ExternRef => WASM_EXTERNREF,
-        ValType::FuncRef => WASM_FUNCREF,
         ValType::V128 => WASMTIME_V128,
+        ValType::Ref(r) => match (r.is_nullable(), r.heap_type()) {
+            (true, HeapType::Extern) => WASM_EXTERNREF,
+            (true, HeapType::Func) => WASM_FUNCREF,
+            _ => crate::abort("support for non-externref and non-funcref references"),
+        },
     }
 }
 
@@ -61,3 +64,4 @@ pub const WASMTIME_F64: wasmtime_valkind_t = 3;
 pub const WASMTIME_V128: wasmtime_valkind_t = 4;
 pub const WASMTIME_FUNCREF: wasmtime_valkind_t = 5;
 pub const WASMTIME_EXTERNREF: wasmtime_valkind_t = 6;
+pub const WASMTIME_ANYREF: wasmtime_valkind_t = 7;
diff --git a/crates/c-api/src/val.rs b/crates/c-api/src/val.rs
index 85165bf0719a..c7304e3dc985 100644
--- a/crates/c-api/src/val.rs
+++ b/crates/c-api/src/val.rs
@@ -1,12 +1,11 @@
-use crate::r#ref::{ref_to_val, WasmRefInner};
+use crate::r#ref::ref_to_val;
 use crate::{
-    from_valtype, into_valtype, wasm_ref_t, wasm_valkind_t, wasmtime_valkind_t, CStoreContextMut,
-    WASM_I32,
+    from_valtype, into_valtype, wasm_ref_t, wasm_valkind_t, wasmtime_anyref_t,
+    wasmtime_externref_t, wasmtime_valkind_t, WasmtimeStoreContextMut, WASM_I32,
 };
-use std::ffi::c_void;
-use std::mem::{self, ManuallyDrop, MaybeUninit};
+use std::mem::{ManuallyDrop, MaybeUninit};
 use std::ptr;
-use wasmtime::{ExternRef, Func, Val, ValType};
+use wasmtime::{AsContextMut, Func, HeapType, Ref, RootScope, Val, ValType};
 
 #[repr(C)]
 pub struct wasm_val_t {
@@ -29,7 +28,7 @@ pub union wasm_val_union {
 impl Drop for wasm_val_t {
     fn drop(&mut self) {
         match into_valtype(self.kind) {
-            ValType::FuncRef | ValType::ExternRef => unsafe {
+            ValType::Ref(_) => unsafe {
                 if !self.of.ref_.is_null() {
                     drop(Box::from_raw(self.of.ref_));
                 }
@@ -47,7 +46,7 @@ impl Clone for wasm_val_t {
         };
         unsafe {
             match into_valtype(self.kind) {
-                ValType::ExternRef | ValType::FuncRef if !self.of.ref_.is_null() => {
+                ValType::Ref(_) if !self.of.ref_.is_null() => {
                     ret.of.ref_ = Box::into_raw(Box::new((*self.of.ref_).clone()));
                 }
                 _ => {}
@@ -85,35 +84,19 @@ impl wasm_val_t {
                 kind: from_valtype(&ValType::F64),
                 of: wasm_val_union { u64: f },
             },
-            Val::ExternRef(None) => wasm_val_t {
-                kind: from_valtype(&ValType::ExternRef),
+            Val::FuncRef(f) => wasm_val_t {
+                kind: from_valtype(&ValType::FUNCREF),
                 of: wasm_val_union {
-                    ref_: ptr::null_mut(),
+                    ref_: f.map_or(ptr::null_mut(), |f| {
+                        Box::into_raw(Box::new(wasm_ref_t {
+                            r: Ref::Func(Some(f)),
+                        }))
+                    }),
                 },
             },
-            Val::ExternRef(Some(r)) => wasm_val_t {
-                kind: from_valtype(&ValType::ExternRef),
-                of: wasm_val_union {
-                    ref_: Box::into_raw(Box::new(wasm_ref_t {
-                        r: WasmRefInner::ExternRef(r),
-                    })),
-                },
-            },
-            Val::FuncRef(None) => wasm_val_t {
-                kind: from_valtype(&ValType::FuncRef),
-                of: wasm_val_union {
-                    ref_: ptr::null_mut(),
-                },
-            },
-            Val::FuncRef(Some(f)) => wasm_val_t {
-                kind: from_valtype(&ValType::FuncRef),
-                of: wasm_val_union {
-                    ref_: Box::into_raw(Box::new(wasm_ref_t {
-                        r: WasmRefInner::FuncRef(f),
-                    })),
-                },
-            },
-            _ => unimplemented!("wasm_val_t::from_val {:?}", val),
+            Val::AnyRef(_) => crate::abort("creating a wasm_val_t from an anyref"),
+            Val::ExternRef(_) => crate::abort("creating a wasm_val_t from an externref"),
+            Val::V128(_) => crate::abort("creating a wasm_val_t from a v128"),
         }
     }
 
@@ -123,21 +106,18 @@ impl wasm_val_t {
             ValType::I64 => Val::from(unsafe { self.of.i64 }),
             ValType::F32 => Val::from(unsafe { self.of.f32 }),
             ValType::F64 => Val::from(unsafe { self.of.f64 }),
-            ValType::ExternRef => unsafe {
-                if self.of.ref_.is_null() {
-                    Val::ExternRef(None)
-                } else {
-                    ref_to_val(&*self.of.ref_)
-                }
-            },
-            ValType::FuncRef => unsafe {
-                if self.of.ref_.is_null() {
-                    Val::FuncRef(None)
-                } else {
-                    ref_to_val(&*self.of.ref_)
-                }
+            ValType::Ref(r) => match r.heap_type() {
+                HeapType::Func => unsafe {
+                    if self.of.ref_.is_null() {
+                        assert!(r.is_nullable());
+                        Val::FuncRef(None)
+                    } else {
+                        ref_to_val(&*self.of.ref_)
+                    }
+                },
+                _ => unreachable!("wasm_val_t cannot contain non-function reference values"),
             },
-            _ => unimplemented!("wasm_val_t::val {:?}", self.kind),
+            ValType::V128 => unimplemented!("wasm_val_t: v128"),
         }
     }
 }
@@ -164,20 +144,76 @@ pub union wasmtime_val_union {
     pub i64: i64,
     pub f32: u32,
     pub f64: u64,
+    pub anyref: ManuallyDrop<wasmtime_anyref_t>,
+    pub externref: ManuallyDrop<wasmtime_externref_t>,
     pub funcref: wasmtime_func_t,
-    pub externref: ManuallyDrop<Option<ExternRef>>,
     pub v128: [u8; 16],
 }
 
+const _: () = {
+    assert!(std::mem::size_of::<wasmtime_val_union>() == 16);
+    assert!(std::mem::align_of::<wasmtime_val_union>() == 8);
+};
+
+// The raw pointers are actually optional boxes.
+unsafe impl Send for wasmtime_val_union
+where
+    Option<Box<wasmtime_anyref_t>>: Send,
+    Option<Box<wasmtime_externref_t>>: Send,
+{
+}
+unsafe impl Sync for wasmtime_val_union
+where
+    Option<Box<wasmtime_anyref_t>>: Sync,
+    Option<Box<wasmtime_externref_t>>: Sync,
+{
+}
+
 #[repr(C)]
 #[derive(Clone, Copy)]
-pub struct wasmtime_func_t {
-    pub store_id: u64,
-    pub index: usize,
+pub union wasmtime_func_t {
+    store_id: u64,
+    func: Func,
+}
+
+impl wasmtime_func_t {
+    unsafe fn as_wasmtime(&self) -> Option<Func> {
+        if self.store_id == 0 {
+            None
+        } else {
+            Some(self.func)
+        }
+    }
+}
+
+impl From<Option<Func>> for wasmtime_func_t {
+    fn from(func: Option<Func>) -> wasmtime_func_t {
+        match func {
+            Some(func) => wasmtime_func_t { func },
+            None => wasmtime_func_t { store_id: 0 },
+        }
+    }
 }
 
 impl wasmtime_val_t {
-    pub fn from_val(val: Val) -> wasmtime_val_t {
+    /// Creates a new `wasmtime_val_t` from a `wasmtime::Val`.
+    ///
+    /// Note that this requires a `RootScope` to be present to serve as proof
+    /// that `val` is not require to be rooted in the store itself which would
+    /// prevent GC. Callers should prefer this API where possible, creating a
+    /// temporary `RootScope` when needed.
+    pub fn from_val(cx: &mut RootScope<impl AsContextMut>, val: Val) -> wasmtime_val_t {
+        Self::from_val_unscoped(cx, val)
+    }
+
+    /// Equivalent of [`wasmtime_val_t::from_val`] except that a `RootScope`
+    /// is not required.
+    ///
+    /// This method should only be used when a `RootScope` is known to be
+    /// elsewhere on the stack. For example this is used when we call back out
+    /// to the embedder. In such a situation we know we previously entered with
+    /// some other call so the root scope is on the stack there.
+    pub fn from_val_unscoped(cx: impl AsContextMut, val: Val) -> wasmtime_val_t {
         match val {
             Val::I32(i) => wasmtime_val_t {
                 kind: crate::WASMTIME_I32,
@@ -195,22 +231,24 @@ impl wasmtime_val_t {
                 kind: crate::WASMTIME_F64,
                 of: wasmtime_val_union { f64: i },
             },
-            Val::ExternRef(i) => wasmtime_val_t {
+            Val::AnyRef(a) => wasmtime_val_t {
+                kind: crate::WASMTIME_ANYREF,
+                of: wasmtime_val_union {
+                    anyref: ManuallyDrop::new(a.and_then(|a| a.to_manually_rooted(cx).ok()).into()),
+                },
+            },
+            Val::ExternRef(e) => wasmtime_val_t {
                 kind: crate::WASMTIME_EXTERNREF,
                 of: wasmtime_val_union {
-                    externref: ManuallyDrop::new(i),
+                    externref: ManuallyDrop::new(
+                        e.and_then(|e| e.to_manually_rooted(cx).ok()).into(),
+                    ),
                 },
             },
-            Val::FuncRef(i) => wasmtime_val_t {
+            Val::FuncRef(func) => wasmtime_val_t {
                 kind: crate::WASMTIME_FUNCREF,
                 of: wasmtime_val_union {
-                    funcref: match i {
-                        Some(func) => unsafe { mem::transmute::<Func, wasmtime_func_t>(func) },
-                        None => wasmtime_func_t {
-                            store_id: 0,
-                            index: 0,
-                        },
-                    },
+                    funcref: func.into(),
                 },
             },
             Val::V128(val) => wasmtime_val_t {
@@ -222,91 +260,68 @@ impl wasmtime_val_t {
         }
     }
 
-    pub unsafe fn to_val(&self) -> Val {
+    /// Convert this `wasmtime_val_t` into a `wasmtime::Val`.
+    ///
+    /// See [`wasmtime_val_t::from_val`] for notes on the `RootScope`
+    /// requirement here. Note that this is particularly meaningful for this
+    /// API as the `Val` returned may contain a `Rooted<T>` which requires a
+    /// `RootScope` if we don't want the value to live for the entire lifetime
+    /// of the `Store`.
+    pub unsafe fn to_val(&self, cx: &mut RootScope<impl AsContextMut>) -> Val {
+        self.to_val_unscoped(cx)
+    }
+
+    /// Equivalent of `to_val` except doesn't require a `RootScope`.
+    ///
+    /// See notes on [`wasmtime_val_t::from_val_unscoped`] for notes on when to
+    /// use this.
+    pub unsafe fn to_val_unscoped(&self, cx: impl AsContextMut) -> Val {
         match self.kind {
             crate::WASMTIME_I32 => Val::I32(self.of.i32),
             crate::WASMTIME_I64 => Val::I64(self.of.i64),
             crate::WASMTIME_F32 => Val::F32(self.of.f32),
             crate::WASMTIME_F64 => Val::F64(self.of.f64),
             crate::WASMTIME_V128 => Val::V128(u128::from_le_bytes(self.of.v128).into()),
-            crate::WASMTIME_FUNCREF => {
-                let store = self.of.funcref.store_id;
-                let index = self.of.funcref.index;
-                Val::FuncRef(if store == 0 && index == 0 {
-                    None
-                } else {
-                    Some(mem::transmute::<wasmtime_func_t, Func>(self.of.funcref))
-                })
+            crate::WASMTIME_ANYREF => {
+                Val::AnyRef(self.of.anyref.as_wasmtime().map(|a| a.to_rooted(cx)))
             }
-            crate::WASMTIME_EXTERNREF => Val::ExternRef((*self.of.externref).clone()),
-            other => panic!("unknown wasmtime_valkind_t: {}", other),
+            crate::WASMTIME_EXTERNREF => {
+                Val::ExternRef(self.of.externref.as_wasmtime().map(|e| e.to_rooted(cx)))
+            }
+            crate::WASMTIME_FUNCREF => Val::FuncRef(self.of.funcref.as_wasmtime()),
+            other => panic!("unknown wasmtime_valkind_t: {other}"),
         }
     }
 }
 
-impl Drop for wasmtime_val_t {
-    fn drop(&mut self) {
-        if self.kind == crate::WASMTIME_EXTERNREF {
-            unsafe {
-                ManuallyDrop::drop(&mut self.of.externref);
+#[no_mangle]
+pub unsafe extern "C" fn wasmtime_val_unroot(
+    cx: WasmtimeStoreContextMut<'_>,
+    val: &mut MaybeUninit<wasmtime_val_t>,
+) {
+    let val = val.assume_init_read();
+    match val.kind {
+        crate::WASMTIME_ANYREF => {
+            if let Some(val) = ManuallyDrop::into_inner(val.of.anyref).as_wasmtime() {
+                val.unroot(cx);
+            }
+        }
+        crate::WASMTIME_EXTERNREF => {
+            if let Some(val) = ManuallyDrop::into_inner(val.of.externref).as_wasmtime() {
+                val.unroot(cx);
             }
         }
+        _ => {}
     }
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn wasmtime_val_delete(val: &mut ManuallyDrop<wasmtime_val_t>) {
-    ManuallyDrop::drop(val)
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn wasmtime_val_copy(
-    dst: &mut MaybeUninit<wasmtime_val_t>,
+pub unsafe extern "C" fn wasmtime_val_clone(
+    cx: WasmtimeStoreContextMut<'_>,
     src: &wasmtime_val_t,
+    dst: &mut MaybeUninit<wasmtime_val_t>,
 ) {
-    crate::initialize(dst, wasmtime_val_t::from_val(src.to_val()))
-}
-
-#[no_mangle]
-pub extern "C" fn wasmtime_externref_new(
-    data: *mut c_void,
-    finalizer: Option<extern "C" fn(*mut c_void)>,
-) -> ExternRef {
-    ExternRef::new(crate::ForeignData { data, finalizer })
-}
-
-#[no_mangle]
-pub extern "C" fn wasmtime_externref_data(externref: ManuallyDrop<ExternRef>) -> *mut c_void {
-    externref
-        .data()
-        .downcast_ref::<crate::ForeignData>()
-        .unwrap()
-        .data
-}
-
-#[no_mangle]
-pub extern "C" fn wasmtime_externref_clone(externref: ManuallyDrop<ExternRef>) -> ExternRef {
-    (*externref).clone()
-}
-
-#[no_mangle]
-pub extern "C" fn wasmtime_externref_delete(_val: Option<ExternRef>) {}
-
-#[no_mangle]
-pub unsafe extern "C" fn wasmtime_externref_to_raw(
-    cx: CStoreContextMut<'_>,
-    val: Option<ManuallyDrop<ExternRef>>,
-) -> *mut c_void {
-    match val {
-        Some(ptr) => ptr.to_raw(cx),
-        None => ptr::null_mut(),
-    }
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn wasmtime_externref_from_raw(
-    _cx: CStoreContextMut<'_>,
-    val: *mut c_void,
-) -> Option<ExternRef> {
-    ExternRef::from_raw(val)
+    let mut scope = RootScope::new(cx);
+    let val = src.to_val(&mut scope);
+    crate::initialize(dst, wasmtime_val_t::from_val(&mut scope, val))
 }
diff --git a/crates/c-api/src/wasi.rs b/crates/c-api/src/wasi.rs
index 848409bcc866..3f638cd5bfe1 100644
--- a/crates/c-api/src/wasi.rs
+++ b/crates/c-api/src/wasi.rs
@@ -2,18 +2,11 @@
 
 use crate::wasm_byte_vec_t;
 use anyhow::Result;
-use cap_std::ambient_authority;
-use std::collections::HashMap;
-use std::ffi::CStr;
+use std::ffi::{c_char, CStr};
 use std::fs::File;
-use std::os::raw::{c_char, c_int};
-use std::path::{Path, PathBuf};
+use std::path::Path;
 use std::slice;
-use wasi_common::pipe::ReadPipe;
-use wasmtime_wasi::{
-    sync::{Dir, TcpListener, WasiCtxBuilder},
-    WasiCtx,
-};
+use wasmtime_wasi::{preview1::WasiP1Ctx, WasiCtxBuilder};
 
 unsafe fn cstr_to_path<'a>(path: *const c_char) -> Option<&'a Path> {
     CStr::from_ptr(path).to_str().map(Path::new).ok()
@@ -32,164 +25,73 @@ unsafe fn create_file(path: *const c_char) -> Option<File> {
 }
 
 #[repr(C)]
-#[derive(Default)]
 pub struct wasi_config_t {
-    args: Vec<Vec<u8>>,
-    env: Vec<(Vec<u8>, Vec<u8>)>,
-    stdin: WasiConfigReadPipe,
-    stdout: WasiConfigWritePipe,
-    stderr: WasiConfigWritePipe,
-    preopen_dirs: Vec<(Dir, PathBuf)>,
-    preopen_sockets: HashMap<u32, TcpListener>,
-    inherit_args: bool,
-    inherit_env: bool,
-}
-
-#[repr(C)]
-#[derive(Default)]
-pub enum WasiConfigReadPipe {
-    #[default]
-    None,
-    Inherit,
-    File(File),
-    Bytes(Vec<u8>),
-}
-
-#[repr(C)]
-#[derive(Default)]
-pub enum WasiConfigWritePipe {
-    #[default]
-    None,
-    Inherit,
-    File(File),
+    builder: WasiCtxBuilder,
 }
 
 wasmtime_c_api_macros::declare_own!(wasi_config_t);
 
 impl wasi_config_t {
-    pub fn into_wasi_ctx(self) -> Result<WasiCtx> {
-        let mut builder = WasiCtxBuilder::new();
-        if self.inherit_args {
-            builder.inherit_args()?;
-        } else if !self.args.is_empty() {
-            let args = self
-                .args
-                .into_iter()
-                .map(|bytes| Ok(String::from_utf8(bytes)?))
-                .collect::<Result<Vec<String>>>()?;
-            builder.args(&args)?;
-        }
-        if self.inherit_env {
-            builder.inherit_env()?;
-        } else if !self.env.is_empty() {
-            let env = self
-                .env
-                .into_iter()
-                .map(|(kbytes, vbytes)| {
-                    let k = String::from_utf8(kbytes)?;
-                    let v = String::from_utf8(vbytes)?;
-                    Ok((k, v))
-                })
-                .collect::<Result<Vec<(String, String)>>>()?;
-            builder.envs(&env)?;
-        }
-        match self.stdin {
-            WasiConfigReadPipe::None => {}
-            WasiConfigReadPipe::Inherit => {
-                builder.inherit_stdin();
-            }
-            WasiConfigReadPipe::File(file) => {
-                let file = cap_std::fs::File::from_std(file);
-                let file = wasi_cap_std_sync::file::File::from_cap_std(file);
-                builder.stdin(Box::new(file));
-            }
-            WasiConfigReadPipe::Bytes(binary) => {
-                let binary = ReadPipe::from(binary);
-                builder.stdin(Box::new(binary));
-            }
-        };
-        match self.stdout {
-            WasiConfigWritePipe::None => {}
-            WasiConfigWritePipe::Inherit => {
-                builder.inherit_stdout();
-            }
-            WasiConfigWritePipe::File(file) => {
-                let file = cap_std::fs::File::from_std(file);
-                let file = wasi_cap_std_sync::file::File::from_cap_std(file);
-                builder.stdout(Box::new(file));
-            }
-        };
-        match self.stderr {
-            WasiConfigWritePipe::None => {}
-            WasiConfigWritePipe::Inherit => {
-                builder.inherit_stderr();
-            }
-            WasiConfigWritePipe::File(file) => {
-                let file = cap_std::fs::File::from_std(file);
-                let file = wasi_cap_std_sync::file::File::from_cap_std(file);
-                builder.stderr(Box::new(file));
-            }
-        };
-        for (dir, path) in self.preopen_dirs {
-            builder.preopened_dir(dir, path)?;
-        }
-        for (fd_num, listener) in self.preopen_sockets {
-            builder.preopened_socket(fd_num, listener)?;
-        }
-        Ok(builder.build())
+    pub fn into_wasi_ctx(mut self) -> Result<WasiP1Ctx> {
+        Ok(self.builder.build_p1())
     }
 }
 
 #[no_mangle]
 pub extern "C" fn wasi_config_new() -> Box<wasi_config_t> {
-    Box::new(wasi_config_t::default())
+    Box::new(wasi_config_t {
+        builder: WasiCtxBuilder::new(),
+    })
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn wasi_config_set_argv(
     config: &mut wasi_config_t,
-    argc: c_int,
+    argc: usize,
     argv: *const *const c_char,
-) {
-    config.args = slice::from_raw_parts(argv, argc as usize)
-        .iter()
-        .map(|p| CStr::from_ptr(*p).to_bytes().to_owned())
-        .collect();
-    config.inherit_args = false;
+) -> bool {
+    for arg in slice::from_raw_parts(argv, argc) {
+        let arg = match CStr::from_ptr(*arg).to_str() {
+            Ok(s) => s,
+            Err(_) => return false,
+        };
+        config.builder.arg(arg);
+    }
+    true
 }
 
 #[no_mangle]
 pub extern "C" fn wasi_config_inherit_argv(config: &mut wasi_config_t) {
-    config.args.clear();
-    config.inherit_args = true;
+    config.builder.inherit_args();
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn wasi_config_set_env(
     config: &mut wasi_config_t,
-    envc: c_int,
+    envc: usize,
     names: *const *const c_char,
     values: *const *const c_char,
-) {
-    let names = slice::from_raw_parts(names, envc as usize);
-    let values = slice::from_raw_parts(values, envc as usize);
+) -> bool {
+    let names = slice::from_raw_parts(names, envc);
+    let values = slice::from_raw_parts(values, envc);
 
-    config.env = names
-        .iter()
-        .map(|p| CStr::from_ptr(*p).to_bytes().to_owned())
-        .zip(
-            values
-                .iter()
-                .map(|p| CStr::from_ptr(*p).to_bytes().to_owned()),
-        )
-        .collect();
-    config.inherit_env = false;
+    for (k, v) in names.iter().zip(values) {
+        let k = match cstr_to_str(*k) {
+            Some(s) => s,
+            None => return false,
+        };
+        let v = match cstr_to_str(*v) {
+            Some(s) => s,
+            None => return false,
+        };
+        config.builder.env(k, v);
+    }
+    true
 }
 
 #[no_mangle]
 pub extern "C" fn wasi_config_inherit_env(config: &mut wasi_config_t) {
-    config.env.clear();
-    config.inherit_env = true;
+    config.builder.inherit_env();
 }
 
 #[no_mangle]
@@ -202,7 +104,10 @@ pub unsafe extern "C" fn wasi_config_set_stdin_file(
         None => return false,
     };
 
-    config.stdin = WasiConfigReadPipe::File(file);
+    let file = tokio::fs::File::from_std(file);
+    let stdin_stream =
+        wasmtime_wasi::AsyncStdinStream::new(wasmtime_wasi::pipe::AsyncReadStream::new(file));
+    config.builder.stdin(stdin_stream);
 
     true
 }
@@ -213,13 +118,13 @@ pub unsafe extern "C" fn wasi_config_set_stdin_bytes(
     binary: &mut wasm_byte_vec_t,
 ) {
     let binary = binary.take();
-
-    config.stdin = WasiConfigReadPipe::Bytes(binary);
+    let binary = wasmtime_wasi::pipe::MemoryInputPipe::new(binary);
+    config.builder.stdin(binary);
 }
 
 #[no_mangle]
 pub extern "C" fn wasi_config_inherit_stdin(config: &mut wasi_config_t) {
-    config.stdin = WasiConfigReadPipe::Inherit;
+    config.builder.inherit_stdin();
 }
 
 #[no_mangle]
@@ -232,14 +137,14 @@ pub unsafe extern "C" fn wasi_config_set_stdout_file(
         None => return false,
     };
 
-    config.stdout = WasiConfigWritePipe::File(file);
+    config.builder.stdout(wasmtime_wasi::OutputFile::new(file));
 
     true
 }
 
 #[no_mangle]
 pub extern "C" fn wasi_config_inherit_stdout(config: &mut wasi_config_t) {
-    config.stdout = WasiConfigWritePipe::Inherit;
+    config.builder.inherit_stdout();
 }
 
 #[no_mangle]
@@ -252,14 +157,14 @@ pub unsafe extern "C" fn wasi_config_set_stderr_file(
         None => return false,
     };
 
-    config.stderr = WasiConfigWritePipe::File(file);
+    config.builder.stderr(wasmtime_wasi::OutputFile::new(file));
 
     true
 }
 
 #[no_mangle]
 pub extern "C" fn wasi_config_inherit_stderr(config: &mut wasi_config_t) {
-    config.stderr = WasiConfigWritePipe::Inherit;
+    config.builder.inherit_stderr();
 }
 
 #[no_mangle]
@@ -268,51 +173,23 @@ pub unsafe extern "C" fn wasi_config_preopen_dir(
     path: *const c_char,
     guest_path: *const c_char,
 ) -> bool {
-    let guest_path = match cstr_to_path(guest_path) {
+    let guest_path = match cstr_to_str(guest_path) {
         Some(p) => p,
         None => return false,
     };
 
-    let dir = match cstr_to_path(path) {
-        Some(p) => match Dir::open_ambient_dir(p, ambient_authority()) {
-            Ok(d) => d,
-            Err(_) => return false,
-        },
-        None => return false,
-    };
-
-    (*config).preopen_dirs.push((dir, guest_path.to_owned()));
-
-    true
-}
-
-#[no_mangle]
-pub unsafe extern "C" fn wasi_config_preopen_socket(
-    config: &mut wasi_config_t,
-    fd_num: u32,
-    host_port: *const c_char,
-) -> bool {
-    let address = match cstr_to_str(host_port) {
-        Some(s) => s,
+    let host_path = match cstr_to_path(path) {
+        Some(p) => p,
         None => return false,
     };
-    let listener = match std::net::TcpListener::bind(address) {
-        Ok(listener) => listener,
-        Err(_) => return false,
-    };
-
-    if let Err(_) = listener.set_nonblocking(true) {
-        return false;
-    }
 
-    // Caller cannot call in more than once with the same FD number so return an error.
-    if (*config).preopen_sockets.contains_key(&fd_num) {
-        return false;
-    }
-
-    (*config)
-        .preopen_sockets
-        .insert(fd_num, TcpListener::from_std(listener));
-
-    true
+    config
+        .builder
+        .preopened_dir(
+            host_path,
+            guest_path,
+            wasmtime_wasi::DirPerms::all(),
+            wasmtime_wasi::FilePerms::all(),
+        )
+        .is_ok()
 }
diff --git a/crates/c-api/wasm-c-api b/crates/c-api/wasm-c-api
deleted file mode 160000
index c9d31284651b..000000000000
--- a/crates/c-api/wasm-c-api
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit c9d31284651b975f05ac27cee0bab1377560b87e
diff --git a/crates/cache/Cargo.toml b/crates/cache/Cargo.toml
index 0b72cd6b8828..a1510d9ecbe5 100644
--- a/crates/cache/Cargo.toml
+++ b/crates/cache/Cargo.toml
@@ -7,18 +7,22 @@ license = "Apache-2.0 WITH LLVM-exception"
 repository = "https://github.com/bytecodealliance/wasmtime"
 documentation = "https://docs.rs/wasmtime-cache/"
 edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
 
 [dependencies]
-anyhow = { workspace = true }
+anyhow = { workspace = true, features = ['std'] }
 base64 = "0.21.0"
-bincode = "1.1.4"
+postcard = { workspace = true }
 directories-next = "2.0"
 log = { workspace = true }
-serde = "1.0.188"
-serde_derive = "1.0.188"
+serde = { workspace = true }
+serde_derive = { workspace = true }
 sha2 = "0.10.2"
-toml = "0.5.5"
-zstd = { version = "0.11.1", default-features = false }
+toml = { workspace = true }
+zstd = { version = "0.13.0", default-features = false }
 
 [target.'cfg(target_os = "windows")'.dependencies.windows-sys]
 workspace = true
diff --git a/crates/cache/build.rs b/crates/cache/build.rs
index b57b1ac48833..2d7a7437d3b9 100644
--- a/crates/cache/build.rs
+++ b/crates/cache/build.rs
@@ -6,5 +6,5 @@ fn main() {
         Ok(output) => str::from_utf8(&output.stdout).unwrap().trim().to_string(),
         Err(_) => env!("CARGO_PKG_VERSION").to_string(),
     };
-    println!("cargo:rustc-env=GIT_REV={}", git_rev);
+    println!("cargo:rustc-env=GIT_REV={git_rev}");
 }
diff --git a/crates/cache/src/config.rs b/crates/cache/src/config.rs
index d7b8f3d4f019..62fc6e936f8e 100644
--- a/crates/cache/src/config.rs
+++ b/crates/cache/src/config.rs
@@ -153,11 +153,11 @@ const ZSTD_COMPRESSION_LEVELS: std::ops::RangeInclusive<i32> = 0..=21;
 // Default settings, you're welcome to tune them!
 // TODO: what do we want to warn users about?
 
-// At the moment of writing, the modules couldn't depend on anothers,
+// At the moment of writing, the modules couldn't depend on another,
 // so we have at most one module per wasmtime instance
 // if changed, update cli-cache.md
 const DEFAULT_WORKER_EVENT_QUEUE_SIZE: u64 = 0x10;
-const WORKER_EVENT_QUEUE_SIZE_WARNING_TRESHOLD: u64 = 3;
+const WORKER_EVENT_QUEUE_SIZE_WARNING_THRESHOLD: u64 = 3;
 // should be quick and provide good enough compression
 // if changed, update cli-cache.md
 const DEFAULT_BASELINE_COMPRESSION_LEVEL: i32 = zstd::DEFAULT_COMPRESSION_LEVEL;
@@ -407,11 +407,11 @@ impl CacheConfig {
         match (entity_exists, user_custom_file) {
             (false, false) => Ok(Self::new_cache_enabled_template()),
             _ => {
-                let bytes = fs::read(&config_file).context(format!(
+                let contents = fs::read_to_string(&config_file).context(format!(
                     "failed to read config file: {}",
                     config_file.display()
                 ))?;
-                let config = toml::from_slice::<Config>(&bytes[..]).context(format!(
+                let config = toml::from_str::<Config>(&contents).context(format!(
                     "failed to parse config file: {}",
                     config_file.display()
                 ))?;
@@ -460,7 +460,7 @@ impl CacheConfig {
             self.worker_event_queue_size = Some(DEFAULT_WORKER_EVENT_QUEUE_SIZE);
         }
 
-        if self.worker_event_queue_size.unwrap() < WORKER_EVENT_QUEUE_SIZE_WARNING_TRESHOLD {
+        if self.worker_event_queue_size.unwrap() < WORKER_EVENT_QUEUE_SIZE_WARNING_THRESHOLD {
             warn!("Detected small worker event queue size. Some messages might be lost.");
         }
     }
diff --git a/crates/cache/src/config/tests.rs b/crates/cache/src/config/tests.rs
index 0c1dc873fb69..d361caa4871e 100644
--- a/crates/cache/src/config/tests.rs
+++ b/crates/cache/src/config/tests.rs
@@ -2,7 +2,7 @@ use super::CacheConfig;
 use std::fs;
 use std::path::PathBuf;
 use std::time::Duration;
-use tempfile::{self, TempDir};
+use tempfile::TempDir;
 
 // note: config loading during validation creates cache directory to canonicalize its path,
 //       that's why these function and macro always use custom cache directory
@@ -19,10 +19,7 @@ pub fn test_prolog() -> (TempDir, PathBuf, PathBuf) {
 macro_rules! load_config {
     ($config_path:ident, $content_fmt:expr, $cache_dir:ident) => {{
         let config_path = &$config_path;
-        let content = format!(
-            $content_fmt,
-            cache_dir = toml::to_string_pretty(&format!("{}", $cache_dir.display())).unwrap()
-        );
+        let content = format!($content_fmt, cache_dir = $cache_dir.display());
         fs::write(config_path, content).expect("Failed to write test config file");
         CacheConfig::from_file(Some(config_path)).unwrap()
     }};
@@ -31,10 +28,7 @@ macro_rules! load_config {
 macro_rules! bad_config {
     ($config_path:ident, $content_fmt:expr, $cache_dir:ident) => {{
         let config_path = &$config_path;
-        let content = format!(
-            $content_fmt,
-            cache_dir = toml::to_string_pretty(&format!("{}", $cache_dir.display())).unwrap()
-        );
+        let content = format!($content_fmt, cache_dir = $cache_dir.display());
         fs::write(config_path, content).expect("Failed to write test config file");
         assert!(CacheConfig::from_file(Some(config_path)).is_err());
     }};
@@ -60,7 +54,7 @@ fn test_unrecognized_settings() {
         "unrecognized-setting = 42\n\
          [cache]\n\
          enabled = true\n\
-         directory = {cache_dir}",
+         directory = '{cache_dir}'",
         cd
     );
 
@@ -68,7 +62,7 @@ fn test_unrecognized_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          unrecognized-setting = 42",
         cd
     );
@@ -81,7 +75,7 @@ fn test_all_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          worker-event-queue-size = '16'\n\
          baseline-compression-level = 3\n\
          optimized-compression-level = 20\n\
@@ -102,7 +96,7 @@ fn test_all_settings() {
         // added some white spaces
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          worker-event-queue-size  = ' 16\t'\n\
          baseline-compression-level = 3\n\
          optimized-compression-level =\t 20\n\
@@ -151,7 +145,7 @@ fn test_compression_level_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          baseline-compression-level = 1\n\
          optimized-compression-level = 21",
         cd
@@ -164,7 +158,7 @@ fn test_compression_level_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          baseline-compression-level = -1\n\
          optimized-compression-level = 21",
         cd
@@ -174,7 +168,7 @@ fn test_compression_level_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          baseline-compression-level = 15\n\
          optimized-compression-level = 10",
         cd
@@ -188,7 +182,7 @@ fn test_si_prefix_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          worker-event-queue-size = '42'\n\
          optimized-compression-usage-counter-threshold = '4K'\n\
          file-count-soft-limit = '3M'",
@@ -203,7 +197,7 @@ fn test_si_prefix_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          worker-event-queue-size = '2K'\n\
          optimized-compression-usage-counter-threshold = '4444T'\n\
          file-count-soft-limit = '1P'",
@@ -222,7 +216,7 @@ fn test_si_prefix_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          worker-event-queue-size = '2g'",
         cd
     );
@@ -231,7 +225,7 @@ fn test_si_prefix_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          file-count-soft-limit = 1",
         cd
     );
@@ -240,7 +234,7 @@ fn test_si_prefix_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          file-count-soft-limit = '-31337'",
         cd
     );
@@ -249,7 +243,7 @@ fn test_si_prefix_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          file-count-soft-limit = '3.14M'",
         cd
     );
@@ -262,7 +256,7 @@ fn test_disk_space_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          files-total-size-soft-limit = '76'",
         cd
     );
@@ -273,7 +267,7 @@ fn test_disk_space_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          files-total-size-soft-limit = '42 Mi'",
         cd
     );
@@ -284,7 +278,7 @@ fn test_disk_space_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          files-total-size-soft-limit = '2 Gi'",
         cd
     );
@@ -295,7 +289,7 @@ fn test_disk_space_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          files-total-size-soft-limit = '31337 Ti'",
         cd
     );
@@ -306,7 +300,7 @@ fn test_disk_space_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          files-total-size-soft-limit = '7 Pi'",
         cd
     );
@@ -317,7 +311,7 @@ fn test_disk_space_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          files-total-size-soft-limit = '7M'",
         cd
     );
@@ -329,7 +323,7 @@ fn test_disk_space_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          files-total-size-soft-limit = '7 mi'",
         cd
     );
@@ -338,7 +332,7 @@ fn test_disk_space_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          files-total-size-soft-limit = 1",
         cd
     );
@@ -347,7 +341,7 @@ fn test_disk_space_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          files-total-size-soft-limit = '-31337'",
         cd
     );
@@ -356,7 +350,7 @@ fn test_disk_space_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          files-total-size-soft-limit = '3.14Ki'",
         cd
     );
@@ -369,7 +363,7 @@ fn test_duration_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          cleanup-interval = '100s'\n\
          optimizing-compression-task-timeout = '3m'\n\
          allowed-clock-drift-for-files-from-future = '4h'",
@@ -390,7 +384,7 @@ fn test_duration_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          cleanup-interval = '2d'\n\
          optimizing-compression-task-timeout = '333 m'",
         cd
@@ -410,7 +404,7 @@ fn test_duration_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          optimizing-compression-task-timeout = '333'",
         cd
     );
@@ -419,7 +413,7 @@ fn test_duration_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          optimizing-compression-task-timeout = 333",
         cd
     );
@@ -428,7 +422,7 @@ fn test_duration_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          optimizing-compression-task-timeout = '10 M'",
         cd
     );
@@ -437,7 +431,7 @@ fn test_duration_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          optimizing-compression-task-timeout = '10 min'",
         cd
     );
@@ -446,7 +440,7 @@ fn test_duration_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          optimizing-compression-task-timeout = '-10s'",
         cd
     );
@@ -455,7 +449,7 @@ fn test_duration_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          optimizing-compression-task-timeout = '1.5m'",
         cd
     );
@@ -468,7 +462,7 @@ fn test_percent_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          file-count-limit-percent-if-deleting = '62%'\n\
          files-total-size-limit-percent-if-deleting = '23 %'",
         cd
@@ -482,7 +476,7 @@ fn test_percent_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          files-total-size-limit-percent-if-deleting = '23'",
         cd
     );
@@ -491,7 +485,7 @@ fn test_percent_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          files-total-size-limit-percent-if-deleting = '22.5%'",
         cd
     );
@@ -500,7 +494,7 @@ fn test_percent_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          files-total-size-limit-percent-if-deleting = '0.5'",
         cd
     );
@@ -509,7 +503,7 @@ fn test_percent_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          files-total-size-limit-percent-if-deleting = '-1%'",
         cd
     );
@@ -518,7 +512,7 @@ fn test_percent_settings() {
         cp,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          files-total-size-limit-percent-if-deleting = '101%'",
         cd
     );
diff --git a/crates/cache/src/lib.rs b/crates/cache/src/lib.rs
index a997846c1af1..88dbcfd953e1 100644
--- a/crates/cache/src/lib.rs
+++ b/crates/cache/src/lib.rs
@@ -2,11 +2,11 @@ use base64::Engine;
 use log::{debug, trace, warn};
 use serde::{Deserialize, Serialize};
 use sha2::{Digest, Sha256};
-use std::fs;
 use std::hash::Hash;
 use std::hash::Hasher;
 use std::io::Write;
 use std::path::{Path, PathBuf};
+use std::{fs, io};
 
 #[macro_use] // for tests
 mod config;
@@ -27,7 +27,7 @@ struct Sha256Hasher(Sha256);
 
 impl<'config> ModuleCacheEntry<'config> {
     /// Create the cache entry.
-    pub fn new<'data>(compiler_name: &str, cache_config: &'config CacheConfig) -> Self {
+    pub fn new(compiler_name: &str, cache_config: &'config CacheConfig) -> Self {
         if cache_config.enabled() {
             Self(Some(ModuleCacheEntryInner::new(
                 compiler_name,
@@ -54,8 +54,8 @@ impl<'config> ModuleCacheEntry<'config> {
         self.get_data_raw(
             &state,
             compute,
-            |_state, data| bincode::serialize(data).ok(),
-            |_state, data| bincode::deserialize(&data).ok(),
+            |_state, data| postcard::to_allocvec(data).ok(),
+            |_state, data| postcard::from_bytes(&data).ok(),
         )
     }
 
@@ -108,7 +108,7 @@ impl<'config> ModuleCacheEntry<'config> {
 }
 
 impl<'config> ModuleCacheEntryInner<'config> {
-    fn new<'data>(compiler_name: &str, cache_config: &'config CacheConfig) -> Self {
+    fn new(compiler_name: &str, cache_config: &'config CacheConfig) -> Self {
         // If debug assertions are enabled then assume that we're some sort of
         // local build. We don't want local builds to stomp over caches between
         // builds, so just use a separate cache directory based on the mtime of
@@ -172,7 +172,7 @@ impl<'config> ModuleCacheEntryInner<'config> {
 
         // Optimize syscalls: first, try writing to disk. It should succeed in most cases.
         // Otherwise, try creating the cache directory and retry writing to the file.
-        if fs_write_atomic(&mod_cache_path, "mod", &compressed_data) {
+        if fs_write_atomic(&mod_cache_path, "mod", &compressed_data).is_ok() {
             return Some(());
         }
 
@@ -193,10 +193,16 @@ impl<'config> ModuleCacheEntryInner<'config> {
             })
             .ok()?;
 
-        if fs_write_atomic(&mod_cache_path, "mod", &compressed_data) {
-            Some(())
-        } else {
-            None
+        match fs_write_atomic(&mod_cache_path, "mod", &compressed_data) {
+            Ok(_) => Some(()),
+            Err(err) => {
+                warn!(
+                    "Failed to write file with rename, target path: {}, err: {}",
+                    mod_cache_path.display(),
+                    err
+                );
+                None
+            }
         }
     }
 }
@@ -214,8 +220,8 @@ impl Hasher for Sha256Hasher {
 // Assumption: path inside cache directory.
 // Then, we don't have to use sound OS-specific exclusive file access.
 // Note: there's no need to remove temporary file here - cleanup task will do it later.
-fn fs_write_atomic(path: &Path, reason: &str, contents: &[u8]) -> bool {
-    let lock_path = path.with_extension(format!("wip-atomic-write-{}", reason));
+fn fs_write_atomic(path: &Path, reason: &str, contents: &[u8]) -> io::Result<()> {
+    let lock_path = path.with_extension(format!("wip-atomic-write-{reason}"));
     fs::OpenOptions::new()
         .create_new(true) // atomic file creation (assumption: no one will open it without this flag)
         .write(true)
@@ -223,15 +229,6 @@ fn fs_write_atomic(path: &Path, reason: &str, contents: &[u8]) -> bool {
         .and_then(|mut file| file.write_all(contents))
         // file should go out of scope and be closed at this point
         .and_then(|()| fs::rename(&lock_path, &path)) // atomic file rename
-        .map_err(|err| {
-            warn!(
-                "Failed to write file with rename, lock path: {}, target path: {}, err: {}",
-                lock_path.display(),
-                path.display(),
-                err
-            )
-        })
-        .is_ok()
 }
 
 #[cfg(test)]
diff --git a/crates/cache/src/tests.rs b/crates/cache/src/tests.rs
index 4362aaba2222..f901a009cd1f 100644
--- a/crates/cache/src/tests.rs
+++ b/crates/cache/src/tests.rs
@@ -1,8 +1,7 @@
 use super::config::tests::test_prolog;
 use super::*;
-use std::fs;
 
-// Since cache system is a global thing, each test needs to be run in seperate process.
+// Since cache system is a global thing, each test needs to be run in separate process.
 // So, init() tests are run as integration tests.
 // However, caching is a private thing, an implementation detail, and needs to be tested
 // from the inside of the module.
@@ -15,9 +14,9 @@ fn test_cache_init() {
     let config_content = format!(
         "[cache]\n\
          enabled = true\n\
-         directory = {}\n\
+         directory = '{}'\n\
          baseline-compression-level = {}\n",
-        toml::to_string_pretty(&format!("{}", cache_dir.display())).unwrap(),
+        cache_dir.display(),
         baseline_compression_level,
     );
     fs::write(&config_path, config_content).expect("Failed to write test config file");
@@ -47,7 +46,7 @@ fn test_write_read_cache() {
         config_path,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          baseline-compression-level = 3\n",
         cache_dir
     );
diff --git a/crates/cache/src/worker.rs b/crates/cache/src/worker.rs
index 72a53f94c192..78561c104eca 100644
--- a/crates/cache/src/worker.rs
+++ b/crates/cache/src/worker.rs
@@ -259,13 +259,13 @@ impl WorkerThread {
     }
 
     /// Increases the usage counter and recompresses the file
-    /// if the usage counter reached configurable treshold.
+    /// if the usage counter reached configurable threshold.
     fn handle_on_cache_get(&self, path: PathBuf) {
         trace!("handle_on_cache_get() for path: {}", path.display());
 
         // construct .stats file path
         let filename = path.file_name().unwrap().to_str().unwrap();
-        let stats_path = path.with_file_name(format!("{}.stats", filename));
+        let stats_path = path.with_file_name(format!("{filename}.stats"));
 
         // load .stats file (default if none or error)
         let mut stats = read_stats_file(stats_path.as_ref())
@@ -399,7 +399,7 @@ impl WorkerThread {
             .expect("Expected valid cache file name")
             .to_str()
             .expect("Expected valid cache file name");
-        let stats_path = path.with_file_name(format!("{}.stats", filename));
+        let stats_path = path.with_file_name(format!("{filename}.stats"));
 
         // create and write stats file
         let mut stats = ModuleCacheStatistics::default(&self.cache_config);
@@ -728,7 +728,7 @@ impl WorkerThread {
 }
 
 fn read_stats_file(path: &Path) -> Option<ModuleCacheStatistics> {
-    fs::read(path)
+    fs::read_to_string(path)
         .map_err(|err| {
             trace!(
                 "Failed to read stats file, path: {}, err: {}",
@@ -736,8 +736,8 @@ fn read_stats_file(path: &Path) -> Option<ModuleCacheStatistics> {
                 err
             )
         })
-        .and_then(|bytes| {
-            toml::from_slice::<ModuleCacheStatistics>(&bytes[..]).map_err(|err| {
+        .and_then(|contents| {
+            toml::from_str::<ModuleCacheStatistics>(&contents).map_err(|err| {
                 trace!(
                     "Failed to parse stats file, path: {}, err: {}",
                     path.display(),
@@ -758,11 +758,7 @@ fn write_stats_file(path: &Path, stats: &ModuleCacheStatistics) -> bool {
             )
         })
         .and_then(|serialized| {
-            if fs_write_atomic(path, "stats", serialized.as_bytes()) {
-                Ok(())
-            } else {
-                Err(())
-            }
+            fs_write_atomic(path, "stats", serialized.as_bytes()).map_err(|_| ())
         })
         .is_ok()
 }
@@ -851,7 +847,7 @@ fn acquire_task_fs_lock(
 
 // we have either both, or just path; dir entry is desirable since on some platforms we can get
 // metadata without extra syscalls
-// futhermore: it's better to get a path if we have it instead of allocating a new one from the dir entry
+// furthermore: it's better to get a path if we have it instead of allocating a new one from the dir entry
 fn is_fs_lock_expired(
     entry: Option<&fs::DirEntry>,
     path: &PathBuf,
diff --git a/crates/cache/src/worker/tests.rs b/crates/cache/src/worker/tests.rs
index d2652c6c2d28..7392962d77d0 100644
--- a/crates/cache/src/worker/tests.rs
+++ b/crates/cache/src/worker/tests.rs
@@ -15,7 +15,7 @@ fn test_on_get_create_stats_file() {
         config_path,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}",
+         directory = '{cache_dir}'",
         cache_dir
     );
     assert!(cache_config.enabled());
@@ -42,7 +42,7 @@ fn test_on_get_update_usage_counter() {
         config_path,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          worker-event-queue-size = '16'",
         cache_dir
     );
@@ -76,7 +76,7 @@ fn test_on_get_recompress_no_mod_file() {
         config_path,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          worker-event-queue-size = '16'\n\
          baseline-compression-level = 3\n\
          optimized-compression-level = 7\n\
@@ -118,7 +118,7 @@ fn test_on_get_recompress_with_mod_file() {
         config_path,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          worker-event-queue-size = '16'\n\
          baseline-compression-level = 3\n\
          optimized-compression-level = 7\n\
@@ -193,7 +193,7 @@ fn test_on_get_recompress_lock() {
         config_path,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          worker-event-queue-size = '16'\n\
          baseline-compression-level = 3\n\
          optimized-compression-level = 7\n\
@@ -263,7 +263,7 @@ fn test_on_update_fresh_stats_file() {
         config_path,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          worker-event-queue-size = '16'\n\
          baseline-compression-level = 3\n\
          optimized-compression-level = 7\n\
@@ -312,7 +312,7 @@ fn test_on_update_cleanup_limits_trash_locks() {
         config_path,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          worker-event-queue-size = '16'\n\
          cleanup-interval = '30m'\n\
          optimizing-compression-task-timeout = '30m'\n\
@@ -453,7 +453,7 @@ fn test_on_update_cleanup_lru_policy() {
         config_path,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          worker-event-queue-size = '16'\n\
          file-count-soft-limit = '5'\n\
          files-total-size-soft-limit = '30K'\n\
@@ -521,8 +521,8 @@ fn test_on_update_cleanup_lru_policy() {
         let filenames = (0..mods.len())
             .map(|i| {
                 (
-                    mods_files_dir.join(format!("mod-{}", i)),
-                    mods_files_dir.join(format!("mod-{}.stats", i)),
+                    mods_files_dir.join(format!("mod-{i}")),
+                    mods_files_dir.join(format!("mod-{i}.stats")),
                 )
             })
             .collect::<Vec<_>>();
@@ -585,7 +585,7 @@ fn test_on_update_cleanup_future_files() {
         config_path,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          worker-event-queue-size = '16'\n\
          allowed-clock-drift-for-files-from-future = '1d'\n\
          file-count-soft-limit = '3'\n\
@@ -605,12 +605,12 @@ fn test_on_update_cleanup_future_files() {
     let worker_lock_file = cache_dir.join(format!(".cleanup.wip-{}", process::id()));
 
     let scenarios: [&[_]; 5] = [
-        // NOT cleaning up, everythings ok
+        // NOT cleaning up, everything is ok
         &[
             (Duration::from_secs(0), None, true),
             (Duration::from_secs(24 * 60 * 60), None, true),
         ],
-        // NOT cleaning up, everythings ok
+        // NOT cleaning up, everything is ok
         &[
             (Duration::from_secs(0), None, true),
             (Duration::from_secs(24 * 60 * 60 + 1), None, true),
@@ -646,8 +646,8 @@ fn test_on_update_cleanup_future_files() {
         let filenames = (0..mods.len())
             .map(|i| {
                 (
-                    mods_files_dir.join(format!("mod-{}", i)),
-                    mods_files_dir.join(format!("mod-{}.stats", i)),
+                    mods_files_dir.join(format!("mod-{i}")),
+                    mods_files_dir.join(format!("mod-{i}.stats")),
                 )
             })
             .collect::<Vec<_>>();
@@ -693,7 +693,7 @@ fn test_on_update_cleanup_self_lock() {
         config_path,
         "[cache]\n\
          enabled = true\n\
-         directory = {cache_dir}\n\
+         directory = '{cache_dir}'\n\
          worker-event-queue-size = '16'\n\
          cleanup-interval = '30m'\n\
          allowed-clock-drift-for-files-from-future = '1d'",
diff --git a/crates/cli-flags/Cargo.toml b/crates/cli-flags/Cargo.toml
index e15b4d14f149..832b86214da8 100644
--- a/crates/cli-flags/Cargo.toml
+++ b/crates/cli-flags/Cargo.toml
@@ -7,23 +7,29 @@ license = "Apache-2.0 WITH LLVM-exception"
 repository = "https://github.com/bytecodealliance/wasmtime"
 documentation = "https://docs.rs/wasmtime-cache/"
 edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
 
 [dependencies]
-anyhow = { workspace = true }
+anyhow = { workspace = true, features = ['std'] }
 clap = { workspace = true }
-file-per-thread-logger = { workspace = true }
-pretty_env_logger = { workspace = true }
-rayon = "1.5.0"
-wasmtime = { workspace = true }
-humantime = "2.0.0"
+file-per-thread-logger = { workspace = true, optional = true }
+tracing-subscriber = { workspace = true, optional = true }
+rayon = { version = "1.5.0", optional = true }
+wasmtime = { workspace = true, features = ["gc"] }
+humantime = { workspace = true }
 
 [features]
-default = [
-    "wasmtime/cache",
-    "wasmtime/cranelift",
-    "wasmtime/jitdump",
-    "wasmtime/vtune",
-    "wasmtime/parallel-compilation",
-]
-pooling-allocator = []
+async = ["wasmtime/async"]
+pooling-allocator = ["wasmtime/pooling-allocator"]
 component-model = ["wasmtime/component-model"]
+cache = ["wasmtime/cache"]
+parallel-compilation = ["wasmtime/parallel-compilation", "dep:rayon"]
+logging = ["dep:file-per-thread-logger", "dep:tracing-subscriber"]
+cranelift = ["wasmtime/cranelift"]
+coredump = ["wasmtime/coredump"]
+gc = ["wasmtime/gc"]
+threads = ["wasmtime/threads"]
+memory-protection-keys = ["wasmtime/memory-protection-keys"]
diff --git a/crates/cli-flags/src/lib.rs b/crates/cli-flags/src/lib.rs
index db5ba3abc300..f9f51b6b7d3e 100644
--- a/crates/cli-flags/src/lib.rs
+++ b/crates/cli-flags/src/lib.rs
@@ -1,8 +1,5 @@
 //! Contains the common Wasmtime command line interface (CLI) flags.
 
-#![deny(trivial_numeric_casts, unused_extern_crates, unstable_features)]
-#![warn(unused_import_braces)]
-
 use anyhow::Result;
 use clap::Parser;
 use std::time::Duration;
@@ -10,13 +7,16 @@ use wasmtime::Config;
 
 pub mod opt;
 
-fn init_file_per_thread_logger(prefix: &'static str) {
+#[cfg(feature = "logging")]
+fn init_file_per_thread_logger(prefix: &str) {
     file_per_thread_logger::initialize(prefix);
+    file_per_thread_logger::allow_uninitialized();
 
     // Extending behavior of default spawner:
     // https://docs.rs/rayon/1.1.0/rayon/struct.ThreadPoolBuilder.html#method.spawn_handler
     // Source code says DefaultSpawner is implementation detail and
     // shouldn't be used directly.
+    #[cfg(feature = "parallel-compilation")]
     rayon::ThreadPoolBuilder::new()
         .spawn_handler(move |thread| {
             let mut b = std::thread::Builder::new();
@@ -26,8 +26,9 @@ fn init_file_per_thread_logger(prefix: &'static str) {
             if let Some(stack_size) = thread.stack_size() {
                 b = b.stack_size(stack_size);
             }
+            let prefix = prefix.to_string();
             b.spawn(move || {
-                file_per_thread_logger::initialize(prefix);
+                file_per_thread_logger::initialize(&prefix);
                 thread.run()
             })?;
             Ok(())
@@ -37,8 +38,9 @@ fn init_file_per_thread_logger(prefix: &'static str) {
 }
 
 wasmtime_option_group! {
+    #[derive(PartialEq, Clone)]
     pub struct OptimizeOptions {
-        /// Optimization level of generated code (0-2, s; default: 0)
+        /// Optimization level of generated code (0-2, s; default: 2)
         pub opt_level: Option<wasmtime::OptLevel>,
 
         /// Byte size of the guard region after dynamic memories are allocated
@@ -58,12 +60,70 @@ wasmtime_option_group! {
         /// memories.
         pub dynamic_memory_reserved_for_growth: Option<u64>,
 
+        /// Indicates whether an unmapped region of memory is placed before all
+        /// linear memories.
+        pub guard_before_linear_memory: Option<bool>,
+
+        /// Whether to initialize tables lazily, so that instantiation is
+        /// fast but indirect calls are a little slower. If no, tables are
+        /// initialized eagerly from any active element segments that apply to
+        /// them during instantiation. (default: yes)
+        pub table_lazy_init: Option<bool>,
+
         /// Enable the pooling allocator, in place of the on-demand allocator.
         pub pooling_allocator: Option<bool>,
 
+        /// The number of decommits to do per batch. A batch size of 1
+        /// effectively disables decommit batching. (default: 1)
+        pub pooling_decommit_batch_size: Option<u32>,
+
+        /// How many bytes to keep resident between instantiations for the
+        /// pooling allocator in linear memories.
+        pub pooling_memory_keep_resident: Option<usize>,
+
+        /// How many bytes to keep resident between instantiations for the
+        /// pooling allocator in tables.
+        pub pooling_table_keep_resident: Option<usize>,
+
+        /// Enable memory protection keys for the pooling allocator; this can
+        /// optimize the size of memory slots.
+        pub memory_protection_keys: Option<bool>,
+
         /// Configure attempting to initialize linear memory via a
         /// copy-on-write mapping (default: yes)
         pub memory_init_cow: Option<bool>,
+
+        /// The maximum number of WebAssembly instances which can be created
+        /// with the pooling allocator.
+        pub pooling_total_core_instances: Option<u32>,
+
+        /// The maximum number of WebAssembly components which can be created
+        /// with the pooling allocator.
+        pub pooling_total_component_instances: Option<u32>,
+
+        /// The maximum number of WebAssembly memories which can be created with
+        /// the pooling allocator.
+        pub pooling_total_memories: Option<u32>,
+
+        /// The maximum number of WebAssembly tables which can be created with
+        /// the pooling allocator.
+        pub pooling_total_tables: Option<u32>,
+
+        /// The maximum number of WebAssembly stacks which can be created with
+        /// the pooling allocator.
+        pub pooling_total_stacks: Option<u32>,
+
+        /// The maximum runtime size of each linear memory in the pooling
+        /// allocator, in bytes.
+        pub pooling_max_memory_size: Option<usize>,
+
+        /// The maximum table elements for any table defined in a module when
+        /// using the pooling allocator.
+        pub pooling_table_elements: Option<u32>,
+
+        /// The maximum size, in bytes, allocated for a core instance's metadata
+        /// when using the pooling allocator.
+        pub pooling_max_core_instance_size: Option<usize>,
     }
 
     enum Optimize {
@@ -72,6 +132,7 @@ wasmtime_option_group! {
 }
 
 wasmtime_option_group! {
+    #[derive(PartialEq, Clone)]
     pub struct CodegenOptions {
         /// Either `cranelift` or `winch`.
         ///
@@ -86,6 +147,8 @@ wasmtime_option_group! {
         pub cache_config: Option<String>,
         /// Whether or not to enable parallel compilation of modules.
         pub parallel_compilation: Option<bool>,
+        /// Whether to enable proof-carrying code (PCC)-based validation.
+        pub pcc: Option<bool>,
 
         #[prefixed = "cranelift"]
         /// Set a cranelift-specific option. Use `wasmtime settings` to see
@@ -99,6 +162,7 @@ wasmtime_option_group! {
 }
 
 wasmtime_option_group! {
+    #[derive(PartialEq, Clone)]
     pub struct DebugOptions {
         /// Enable generation of DWARF debug information in compiled code.
         pub debug_info: Option<bool>,
@@ -108,6 +172,8 @@ wasmtime_option_group! {
         pub logging: Option<bool>,
         /// Configure whether logs are emitted to files
         pub log_to_files: Option<bool>,
+        /// Log file prefix
+        pub log_prefix: Option<String>,
         /// Enable coredump generation to this file after a WebAssembly trap.
         pub coredump: Option<String>,
     }
@@ -118,6 +184,7 @@ wasmtime_option_group! {
 }
 
 wasmtime_option_group! {
+    #[derive(PartialEq, Clone)]
     pub struct WasmOptions {
         /// Enable canonicalization of all NaN values.
         pub nan_canonicalization: Option<bool>,
@@ -198,8 +265,16 @@ wasmtime_option_group! {
         pub memory64: Option<bool>,
         /// Configure support for the component-model proposal.
         pub component_model: Option<bool>,
+        /// Configure support for 33+ flags in the component model.
+        pub component_model_more_flags: Option<bool>,
+        /// Component model support for more than one return value.
+        pub component_model_multiple_returns: Option<bool>,
         /// Configure support for the function-references proposal.
         pub function_references: Option<bool>,
+        /// Configure support for the GC proposal.
+        pub gc: Option<bool>,
+        /// Configure support for the custom-page-sizes proposal.
+        pub custom_page_sizes: Option<bool>,
     }
 
     enum Wasm {
@@ -208,21 +283,28 @@ wasmtime_option_group! {
 }
 
 wasmtime_option_group! {
+    #[derive(PartialEq, Clone)]
     pub struct WasiOptions {
-        /// Enable support for WASI common APIs
+        /// Enable support for WASI CLI APIs, including filesystems, sockets, clocks, and random.
+        pub cli: Option<bool>,
+        /// Deprecated alias for `cli`
         pub common: Option<bool>,
-        /// Enable suport for WASI neural network API (experimental)
+        /// Enable support for WASI neural network API (experimental)
         pub nn: Option<bool>,
-        /// Enable suport for WASI threading API (experimental)
+        /// Enable support for WASI threading API (experimental)
         pub threads: Option<bool>,
-        /// Enable suport for WASI HTTP API (experimental)
+        /// Enable support for WASI HTTP API (experimental)
         pub http: Option<bool>,
+        /// Enable support for WASI runtime config API (experimental)
+        pub runtime_config: Option<bool>,
+        /// Enable support for WASI key-value API (experimental)
+        pub keyvalue: Option<bool>,
         /// Inherit environment variables and file descriptors following the
         /// systemd listen fd specification (UNIX only)
         pub listenfd: Option<bool>,
         /// Grant access to the given TCP listen socket
         pub tcplisten: Vec<String>,
-        /// Implement WASI with preview2 primitives (experimental).
+        /// Implement WASI CLI APIs with preview2 primitives (experimental).
         ///
         /// Indicates that the implementation of WASI preview1 should be backed by
         /// the preview2 implementation for components.
@@ -244,7 +326,20 @@ wasmtime_option_group! {
         pub inherit_network: Option<bool>,
         /// Indicates whether `wasi:sockets/ip-name-lookup` is enabled or not.
         pub allow_ip_name_lookup: Option<bool>,
-
+        /// Indicates whether `wasi:sockets` TCP support is enabled or not.
+        pub tcp: Option<bool>,
+        /// Indicates whether `wasi:sockets` UDP support is enabled or not.
+        pub udp: Option<bool>,
+        /// Allows imports from the `wasi_unstable` core wasm module.
+        pub preview0: Option<bool>,
+        /// Inherit all environment variables from the parent process.
+        ///
+        /// This option can be further overwritten with `--env` flags.
+        pub inherit_env: Option<bool>,
+        /// Pass a wasi runtime config variable to the program.
+        pub runtime_config_var: Vec<KeyValuePair>,
+        /// Preset data for the In-Memory provider of WASI key-value API.
+        pub keyvalue_in_memory_data: Vec<KeyValuePair>,
     }
 
     enum Wasi {
@@ -252,14 +347,20 @@ wasmtime_option_group! {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct WasiNnGraph {
     pub format: String,
     pub dir: String,
 }
 
+#[derive(Debug, Clone, PartialEq)]
+pub struct KeyValuePair {
+    pub key: String,
+    pub value: String,
+}
+
 /// Common options for commands that translate WebAssembly modules
-#[derive(Parser)]
+#[derive(Parser, Clone)]
 pub struct CommonOptions {
     // These options groups are used to parse `-O` and such options but aren't
     // the raw form consumed by the CLI. Instead they're pushed into the `pub`
@@ -270,42 +371,63 @@ pub struct CommonOptions {
     // now.
     /// Optimization and tuning related options for wasm performance, `-O help` to
     /// see all.
-    #[clap(short = 'O', long = "optimize", value_name = "KEY[=VAL[,..]]")]
+    #[arg(short = 'O', long = "optimize", value_name = "KEY[=VAL[,..]]")]
     opts_raw: Vec<opt::CommaSeparated<Optimize>>,
 
     /// Codegen-related configuration options, `-C help` to see all.
-    #[clap(short = 'C', long = "codegen", value_name = "KEY[=VAL[,..]]")]
+    #[arg(short = 'C', long = "codegen", value_name = "KEY[=VAL[,..]]")]
     codegen_raw: Vec<opt::CommaSeparated<Codegen>>,
 
     /// Debug-related configuration options, `-D help` to see all.
-    #[clap(short = 'D', long = "debug", value_name = "KEY[=VAL[,..]]")]
+    #[arg(short = 'D', long = "debug", value_name = "KEY[=VAL[,..]]")]
     debug_raw: Vec<opt::CommaSeparated<Debug>>,
 
     /// Options for configuring semantic execution of WebAssembly, `-W help` to see
     /// all.
-    #[clap(short = 'W', long = "wasm", value_name = "KEY[=VAL[,..]]")]
+    #[arg(short = 'W', long = "wasm", value_name = "KEY[=VAL[,..]]")]
     wasm_raw: Vec<opt::CommaSeparated<Wasm>>,
 
     /// Options for configuring WASI and its proposals, `-S help` to see all.
-    #[clap(short = 'S', long = "wasi", value_name = "KEY[=VAL[,..]]")]
+    #[arg(short = 'S', long = "wasi", value_name = "KEY[=VAL[,..]]")]
     wasi_raw: Vec<opt::CommaSeparated<Wasi>>,
 
     // These fields are filled in by the `configure` method below via the
     // options parsed from the CLI above. This is what the CLI should use.
-    #[clap(skip)]
+    #[arg(skip)]
     configured: bool,
-    #[clap(skip)]
+    #[arg(skip)]
     pub opts: OptimizeOptions,
-    #[clap(skip)]
+    #[arg(skip)]
     pub codegen: CodegenOptions,
-    #[clap(skip)]
+    #[arg(skip)]
     pub debug: DebugOptions,
-    #[clap(skip)]
+    #[arg(skip)]
     pub wasm: WasmOptions,
-    #[clap(skip)]
+    #[arg(skip)]
     pub wasi: WasiOptions,
 }
 
+macro_rules! match_feature {
+    (
+        [$feat:tt : $config:expr]
+        $val:ident => $e:expr,
+        $p:pat => err,
+    ) => {
+        #[cfg(feature = $feat)]
+        {
+            if let Some($val) = $config {
+                $e;
+            }
+        }
+        #[cfg(not(feature = $feat))]
+        {
+            if let Some($p) = $config {
+                anyhow::bail!(concat!("support for ", $feat, " disabled at compile time"));
+            }
+        }
+    };
+}
+
 impl CommonOptions {
     fn configure(&mut self) {
         if self.configured {
@@ -319,51 +441,87 @@ impl CommonOptions {
         self.wasi.configure_with(&self.wasi_raw);
     }
 
-    pub fn init_logging(&mut self) {
+    pub fn init_logging(&mut self) -> Result<()> {
         self.configure();
         if self.debug.logging == Some(false) {
-            return;
+            return Ok(());
         }
+        #[cfg(feature = "logging")]
         if self.debug.log_to_files == Some(true) {
-            let prefix = "wasmtime.dbg.";
+            let default_prefix = "wasmtime.dbg.";
+            let prefix = self
+                .debug
+                .log_prefix
+                .as_ref()
+                .map_or(default_prefix, |p| p.as_str());
             init_file_per_thread_logger(prefix);
         } else {
-            pretty_env_logger::init();
+            use std::io::IsTerminal;
+            use tracing_subscriber::{EnvFilter, FmtSubscriber};
+            let b = FmtSubscriber::builder()
+                .with_writer(std::io::stderr)
+                .with_env_filter(EnvFilter::from_env("WASMTIME_LOG"))
+                .with_ansi(std::io::stderr().is_terminal());
+            b.init();
+        }
+        #[cfg(not(feature = "logging"))]
+        if self.debug.log_to_files == Some(true) || self.debug.logging == Some(true) {
+            anyhow::bail!("support for logging disabled at compile time");
         }
+        Ok(())
     }
 
-    pub fn config(&mut self, target: Option<&str>) -> Result<Config> {
+    pub fn config(
+        &mut self,
+        target: Option<&str>,
+        pooling_allocator_default: Option<bool>,
+    ) -> Result<Config> {
         self.configure();
         let mut config = Config::new();
 
-        if let Some(strategy) = self.codegen.compiler {
-            config.strategy(strategy);
+        match_feature! {
+            ["cranelift" : self.codegen.compiler]
+            strategy => config.strategy(strategy),
+            _ => err,
         }
-
-        // Set the target before setting any cranelift options, since the
-        // target will reset any target-specific options.
-        if let Some(target) = target {
-            config.target(target)?;
+        match_feature! {
+            ["cranelift" : target]
+            target => config.target(target)?,
+            _ => err,
         }
-
-        if let Some(enable) = self.codegen.cranelift_debug_verifier {
-            config.cranelift_debug_verifier(enable);
+        match_feature! {
+            ["cranelift" : self.codegen.cranelift_debug_verifier]
+            enable => config.cranelift_debug_verifier(enable),
+            true => err,
         }
         if let Some(enable) = self.debug.debug_info {
             config.debug_info(enable);
         }
         if self.debug.coredump.is_some() {
+            #[cfg(feature = "coredump")]
             config.coredump_on_trap(true);
+            #[cfg(not(feature = "coredump"))]
+            anyhow::bail!("support for coredumps disabled at compile time");
+        }
+        match_feature! {
+            ["cranelift" : self.opts.opt_level]
+            level => config.cranelift_opt_level(level),
+            _ => err,
         }
-        if let Some(level) = self.opts.opt_level {
-            config.cranelift_opt_level(level);
+        match_feature! {
+            ["cranelift" : self.wasm.nan_canonicalization]
+            enable => config.cranelift_nan_canonicalization(enable),
+            true => err,
         }
-        if let Some(enable) = self.wasm.nan_canonicalization {
-            config.cranelift_nan_canonicalization(enable);
+        match_feature! {
+            ["cranelift" : self.codegen.pcc]
+            enable => config.cranelift_pcc(enable),
+            true => err,
         }
 
         self.enable_wasm_features(&mut config)?;
 
+        #[cfg(feature = "cranelift")]
         for (name, value) in self.codegen.cranelift.iter() {
             let name = name.replace('-', "_");
             unsafe {
@@ -377,7 +535,12 @@ impl CommonOptions {
                 }
             }
         }
+        #[cfg(not(feature = "cranelift"))]
+        if !self.codegen.cranelift.is_empty() {
+            anyhow::bail!("support for cranelift disabled at compile time");
+        }
 
+        #[cfg(feature = "cache")]
         if self.codegen.cache != Some(false) {
             match &self.codegen.cache_config {
                 Some(path) => {
@@ -388,9 +551,15 @@ impl CommonOptions {
                 }
             }
         }
+        #[cfg(not(feature = "cache"))]
+        if self.codegen.cache == Some(true) {
+            anyhow::bail!("support for caching disabled at compile time");
+        }
 
-        if let Some(enable) = self.codegen.parallel_compilation {
-            config.parallel_compilation(enable);
+        match_feature! {
+            ["parallel-compilation" : self.codegen.parallel_compilation]
+            enable => config.parallel_compilation(enable),
+            true => err,
         }
 
         if let Some(max) = self.opts.static_memory_maximum_size {
@@ -411,6 +580,12 @@ impl CommonOptions {
         if let Some(size) = self.opts.dynamic_memory_reserved_for_growth {
             config.dynamic_memory_reserved_for_growth(size);
         }
+        if let Some(enable) = self.opts.guard_before_linear_memory {
+            config.guard_before_linear_memory(enable);
+        }
+        if let Some(enable) = self.opts.table_lazy_init {
+            config.table_lazy_init(enable);
+        }
 
         // If fuel has been configured, set the `consume fuel` flag on the config.
         if self.wasm.fuel.is_some() {
@@ -427,11 +602,62 @@ impl CommonOptions {
             config.memory_init_cow(enable);
         }
 
-        if self.opts.pooling_allocator == Some(true) {
-            #[cfg(feature = "pooling-allocator")]
-            config.allocation_strategy(wasmtime::InstanceAllocationStrategy::pooling());
-            #[cfg(not(feature = "pooling-allocator"))]
-            anyhow::bail!("support for the pooling allocator was disabled at compile-time");
+        match_feature! {
+            ["pooling-allocator" : self.opts.pooling_allocator.or(pooling_allocator_default)]
+            enable => {
+                if enable {
+                    let mut cfg = wasmtime::PoolingAllocationConfig::default();
+                    if let Some(size) = self.opts.pooling_memory_keep_resident {
+                        cfg.linear_memory_keep_resident(size);
+                    }
+                    if let Some(size) = self.opts.pooling_table_keep_resident {
+                        cfg.table_keep_resident(size);
+                    }
+                    if let Some(limit) = self.opts.pooling_total_core_instances {
+                        cfg.total_core_instances(limit);
+                    }
+                    if let Some(limit) = self.opts.pooling_total_component_instances {
+                        cfg.total_component_instances(limit);
+                    }
+                    if let Some(limit) = self.opts.pooling_total_memories {
+                        cfg.total_memories(limit);
+                    }
+                    if let Some(limit) = self.opts.pooling_total_tables {
+                        cfg.total_tables(limit);
+                    }
+                    if let Some(limit) = self.opts.pooling_table_elements {
+                        cfg.table_elements(limit);
+                    }
+                    if let Some(limit) = self.opts.pooling_max_core_instance_size {
+                        cfg.max_core_instance_size(limit);
+                    }
+                    match_feature! {
+                        ["async" : self.opts.pooling_total_stacks]
+                        limit => cfg.total_stacks(limit),
+                        _ => err,
+                    }
+                    if let Some(limit) = self.opts.pooling_max_memory_size {
+                        cfg.max_memory_size(limit);
+                    }
+                    match_feature! {
+                        ["memory-protection-keys" : self.opts.memory_protection_keys]
+                        enable => cfg.memory_protection_keys(if enable {
+                            wasmtime::MpkEnabled::Enable
+                        } else {
+                            wasmtime::MpkEnabled::Disable
+                        }),
+                        _ => err,
+                    }
+                    config.allocation_strategy(wasmtime::InstanceAllocationStrategy::Pooling(cfg));
+                }
+            },
+            true => err,
+        }
+
+        if self.opts.memory_protection_keys.unwrap_or(false)
+            && !self.opts.pooling_allocator.unwrap_or(false)
+        {
+            anyhow::bail!("memory protection keys require the pooling allocator");
         }
 
         if let Some(max) = self.wasm.max_wasm_stack {
@@ -441,8 +667,10 @@ impl CommonOptions {
         if let Some(enable) = self.wasm.relaxed_simd_deterministic {
             config.relaxed_simd_deterministic(enable);
         }
-        if let Some(enable) = self.wasm.wmemcheck {
-            config.wmemcheck(enable);
+        match_feature! {
+            ["cranelift" : self.wasm.wmemcheck]
+            enable => config.wmemcheck(enable),
+            true => err,
         }
 
         Ok(config)
@@ -460,35 +688,72 @@ impl CommonOptions {
         if let Some(enable) = self.wasm.bulk_memory.or(all) {
             config.wasm_bulk_memory(enable);
         }
-        if let Some(enable) = self.wasm.reference_types.or(all) {
-            config.wasm_reference_types(enable);
-        }
-        if let Some(enable) = self.wasm.function_references.or(all) {
-            config.wasm_function_references(enable);
-        }
         if let Some(enable) = self.wasm.multi_value.or(all) {
             config.wasm_multi_value(enable);
         }
         if let Some(enable) = self.wasm.tail_call.or(all) {
             config.wasm_tail_call(enable);
         }
-        if let Some(enable) = self.wasm.threads.or(all) {
-            config.wasm_threads(enable);
-        }
         if let Some(enable) = self.wasm.multi_memory.or(all) {
             config.wasm_multi_memory(enable);
         }
         if let Some(enable) = self.wasm.memory64.or(all) {
             config.wasm_memory64(enable);
         }
-        if let Some(enable) = self.wasm.component_model.or(all) {
-            #[cfg(feature = "component-model")]
-            config.wasm_component_model(enable);
-            #[cfg(not(feature = "component-model"))]
-            if enable && all.is_none() {
-                anyhow::bail!("support for the component model was disabled at compile-time");
-            }
+        if let Some(enable) = self.wasm.custom_page_sizes.or(all) {
+            config.wasm_custom_page_sizes(enable);
+        }
+
+        macro_rules! handle_conditionally_compiled {
+            ($(($feature:tt, $field:tt, $method:tt))*) => ($(
+                if let Some(enable) = self.wasm.$field.or(all) {
+                    #[cfg(feature = $feature)]
+                    config.$method(enable);
+                    #[cfg(not(feature = $feature))]
+                    if enable && all.is_none() {
+                        anyhow::bail!("support for {} was disabled at compile-time", $feature);
+                    }
+                }
+            )*)
+        }
+
+        handle_conditionally_compiled! {
+            ("component-model", component_model, wasm_component_model)
+            ("component-model", component_model_more_flags, wasm_component_model_more_flags)
+            ("component-model", component_model_multiple_returns, wasm_component_model_multiple_returns)
+            ("threads", threads, wasm_threads)
+            ("gc", gc, wasm_gc)
+            ("gc", reference_types, wasm_reference_types)
+            ("gc", function_references, wasm_function_references)
         }
         Ok(())
     }
 }
+
+impl PartialEq for CommonOptions {
+    fn eq(&self, other: &CommonOptions) -> bool {
+        let mut me = self.clone();
+        me.configure();
+        let mut other = other.clone();
+        other.configure();
+        let CommonOptions {
+            opts_raw: _,
+            codegen_raw: _,
+            debug_raw: _,
+            wasm_raw: _,
+            wasi_raw: _,
+            configured: _,
+
+            opts,
+            codegen,
+            debug,
+            wasm,
+            wasi,
+        } = me;
+        opts == other.opts
+            && codegen == other.codegen
+            && debug == other.debug
+            && wasm == other.wasm
+            && wasi == other.wasi
+    }
+}
diff --git a/crates/cli-flags/src/opt.rs b/crates/cli-flags/src/opt.rs
index 18a3622bbd58..f1d4af3e4a4c 100644
--- a/crates/cli-flags/src/opt.rs
+++ b/crates/cli-flags/src/opt.rs
@@ -5,7 +5,7 @@
 //! specifying options in a struct-like syntax where all other boilerplate about
 //! option parsing is contained exclusively within this module.
 
-use crate::WasiNnGraph;
+use crate::{KeyValuePair, WasiNnGraph};
 use anyhow::{bail, Result};
 use clap::builder::{StringValueParser, TypedValueParser, ValueParserFactory};
 use clap::error::{Error, ErrorKind};
@@ -15,6 +15,7 @@ use std::time::Duration;
 #[macro_export]
 macro_rules! wasmtime_option_group {
     (
+        $(#[$attr:meta])*
         pub struct $opts:ident {
             $(
                 $(#[doc = $doc:tt])*
@@ -32,6 +33,7 @@ macro_rules! wasmtime_option_group {
         }
     ) => {
         #[derive(Default, Debug)]
+        $(#[$attr])*
         pub struct $opts {
             $(
                 pub $opt: $container<$payload>,
@@ -41,7 +43,7 @@ macro_rules! wasmtime_option_group {
             )?
         }
 
-        #[derive(Clone, Debug)]
+        #[derive(Clone, Debug,PartialEq)]
         #[allow(non_camel_case_types)]
         enum $option {
             $(
@@ -106,7 +108,7 @@ macro_rules! wasmtime_option_group {
 }
 
 /// Parser registered with clap which handles parsing the `...` in `-O ...`.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 pub struct CommaSeparated<T>(pub Vec<T>);
 
 impl<T> ValueParserFactory for CommaSeparated<T>
@@ -299,7 +301,10 @@ impl WasmtimeOptionValue for u32 {
     const VAL_HELP: &'static str = "=N";
     fn parse(val: Option<&str>) -> Result<Self> {
         let val = String::parse(val)?;
-        Ok(val.parse()?)
+        match val.strip_prefix("0x") {
+            Some(hex) => Ok(u32::from_str_radix(hex, 16)?),
+            None => Ok(val.parse()?),
+        }
     }
 }
 
@@ -307,7 +312,10 @@ impl WasmtimeOptionValue for u64 {
     const VAL_HELP: &'static str = "=N";
     fn parse(val: Option<&str>) -> Result<Self> {
         let val = String::parse(val)?;
-        Ok(val.parse()?)
+        match val.strip_prefix("0x") {
+            Some(hex) => Ok(u64::from_str_radix(hex, 16)?),
+            None => Ok(val.parse()?),
+        }
     }
 }
 
@@ -315,7 +323,10 @@ impl WasmtimeOptionValue for usize {
     const VAL_HELP: &'static str = "=N";
     fn parse(val: Option<&str>) -> Result<Self> {
         let val = String::parse(val)?;
-        Ok(val.parse()?)
+        match val.strip_prefix("0x") {
+            Some(hex) => Ok(usize::from_str_radix(hex, 16)?),
+            None => Ok(val.parse()?),
+        }
     }
 }
 
@@ -366,10 +377,7 @@ impl WasmtimeOptionValue for wasmtime::Strategy {
         match String::parse(val)?.as_str() {
             "cranelift" => Ok(wasmtime::Strategy::Cranelift),
             "winch" => Ok(wasmtime::Strategy::Winch),
-            other => bail!(
-                "unknown optimization level `{}`, only 0,1,2,s accepted",
-                other
-            ),
+            other => bail!("unknown compiler `{other}` only `cranelift` and `winch` accepted",),
         }
     }
 }
@@ -388,3 +396,18 @@ impl WasmtimeOptionValue for WasiNnGraph {
         })
     }
 }
+
+impl WasmtimeOptionValue for KeyValuePair {
+    const VAL_HELP: &'static str = "=<name>=<val>";
+    fn parse(val: Option<&str>) -> Result<Self> {
+        let val = String::parse(val)?;
+        let mut parts = val.splitn(2, "=");
+        Ok(KeyValuePair {
+            key: parts.next().unwrap().to_string(),
+            value: match parts.next() {
+                Some(part) => part.into(),
+                None => "".to_string(),
+            },
+        })
+    }
+}
diff --git a/crates/component-macro/Cargo.toml b/crates/component-macro/Cargo.toml
index 069a560f5bb3..79dbc6a27353 100644
--- a/crates/component-macro/Cargo.toml
+++ b/crates/component-macro/Cargo.toml
@@ -9,6 +9,10 @@ documentation = "https://docs.rs/wasmtime-component-macro/"
 categories = ["wasm"]
 keywords = ["webassembly", "wasm"]
 edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
 
 [lib]
 proc-macro = true
@@ -28,6 +32,12 @@ wit-parser = { workspace = true }
 wasmtime = { path = '../wasmtime', features = ['component-model'] }
 component-macro-test-helpers = { path = 'test-helpers' }
 tracing = { workspace = true }
+# For use with the custom attributes test
+serde = { workspace = true, features = ["derive"] }
+serde_json = { workspace = true }
+prettyplease = "0.2.19"
+similar = { workspace = true }
 
 [features]
 async = []
+std = ['wasmtime-wit-bindgen/std']
diff --git a/crates/component-macro/build.rs b/crates/component-macro/build.rs
new file mode 100644
index 000000000000..be0ad5bc97cb
--- /dev/null
+++ b/crates/component-macro/build.rs
@@ -0,0 +1,5 @@
+fn main() {
+    println!("cargo:rerun-if-changed=build.rs");
+    let out_dir = std::env::var("OUT_DIR").unwrap();
+    println!("cargo:rustc-env=DEBUG_OUTPUT_DIR={out_dir}");
+}
diff --git a/crates/component-macro/src/bindgen.rs b/crates/component-macro/src/bindgen.rs
index a87616e55d82..9b0a6a1d90ad 100644
--- a/crates/component-macro/src/bindgen.rs
+++ b/crates/component-macro/src/bindgen.rs
@@ -1,18 +1,22 @@
 use proc_macro2::{Span, TokenStream};
+use quote::ToTokens;
 use std::collections::HashMap;
 use std::collections::HashSet;
+use std::env;
 use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicUsize, Ordering::Relaxed};
 use syn::parse::{Error, Parse, ParseStream, Result};
 use syn::punctuated::Punctuated;
-use syn::{braced, token, Ident, Token};
-use wasmtime_wit_bindgen::{AsyncConfig, Opts, Ownership, TrappableError};
-use wit_parser::{PackageId, Resolve, UnresolvedPackage, WorldId};
+use syn::{braced, token, Token};
+use wasmtime_wit_bindgen::{AsyncConfig, Opts, Ownership, TrappableError, TrappableImports};
+use wit_parser::{PackageId, Resolve, UnresolvedPackageGroup, WorldId};
 
 pub struct Config {
     opts: Opts,
     resolve: Resolve,
     world: WorldId,
     files: Vec<PathBuf>,
+    include_generated_code_from_file: bool,
 }
 
 pub fn expand(input: &Config) -> Result<TokenStream> {
@@ -23,7 +27,38 @@ pub fn expand(input: &Config) -> Result<TokenStream> {
         ));
     }
 
-    let src = input.opts.generate(&input.resolve, input.world);
+    let mut src = match input.opts.generate(&input.resolve, input.world) {
+        Ok(s) => s,
+        Err(e) => return Err(Error::new(Span::call_site(), e.to_string())),
+    };
+
+    if input.opts.stringify {
+        return Ok(quote::quote!(#src));
+    }
+
+    // If a magical `WASMTIME_DEBUG_BINDGEN` environment variable is set then
+    // place a formatted version of the expanded code into a file. This file
+    // will then show up in rustc error messages for any codegen issues and can
+    // be inspected manually.
+    if input.include_generated_code_from_file || std::env::var("WASMTIME_DEBUG_BINDGEN").is_ok() {
+        static INVOCATION: AtomicUsize = AtomicUsize::new(0);
+        let root = Path::new(env!("DEBUG_OUTPUT_DIR"));
+        let world_name = &input.resolve.worlds[input.world].name;
+        let n = INVOCATION.fetch_add(1, Relaxed);
+        let path = root.join(format!("{world_name}{n}.rs"));
+
+        std::fs::write(&path, &src).unwrap();
+
+        // optimistically format the code but don't require success
+        drop(
+            std::process::Command::new("rustfmt")
+                .arg(&path)
+                .arg("--edition=2021")
+                .output(),
+        );
+
+        src = format!("include!({path:?});");
+    }
     let mut contents = src.parse::<TokenStream>().unwrap();
 
     // Include a dummy `include_str!` for any files we read so rustc knows that
@@ -47,6 +82,8 @@ impl Parse for Config {
         let mut inline = None;
         let mut path = None;
         let mut async_configured = false;
+        let mut features = Vec::new();
+        let mut include_generated_code_from_file = false;
 
         if input.peek(token::Brace) {
             let content;
@@ -81,6 +118,7 @@ impl Parse for Config {
                         opts.async_ = val;
                     }
                     Opt::TrappableErrorType(val) => opts.trappable_error_type = val,
+                    Opt::TrappableImports(val) => opts.trappable_imports = val,
                     Opt::Ownership(val) => opts.ownership = val,
                     Opt::Interfaces(s) => {
                         if inline.is_some() {
@@ -88,7 +126,7 @@ impl Parse for Config {
                         }
                         inline = Some(format!(
                             "
-                                package wasmtime:component-macro-synthesized
+                                package wasmtime:component-macro-synthesized;
 
                                 world interfaces {{
                                     {}
@@ -108,6 +146,22 @@ impl Parse for Config {
                         opts.only_interfaces = true;
                     }
                     Opt::With(val) => opts.with.extend(val),
+                    Opt::AdditionalDerives(paths) => {
+                        opts.additional_derive_attributes = paths
+                            .into_iter()
+                            .map(|p| p.into_token_stream().to_string())
+                            .collect()
+                    }
+                    Opt::Stringify(val) => opts.stringify = val,
+                    Opt::SkipMutForwardingImpls(val) => opts.skip_mut_forwarding_impls = val,
+                    Opt::Features(f) => {
+                        features.extend(f.into_iter().map(|f| f.value()));
+                    }
+                    Opt::RequireStoreDataSend(val) => opts.require_store_data_send = val,
+                    Opt::WasmtimeCrate(f) => {
+                        opts.wasmtime_crate = Some(f.into_token_stream().to_string())
+                    }
+                    Opt::IncludeGeneratedCodeFromFile(i) => include_generated_code_from_file = i,
                 }
             }
         } else {
@@ -116,7 +170,7 @@ impl Parse for Config {
                 path = Some(input.parse::<syn::LitStr>()?.value());
             }
         }
-        let (resolve, pkg, files) = parse_source(&path, &inline)
+        let (resolve, pkg, files) = parse_source(&path, &inline, &features)
             .map_err(|err| Error::new(call_site, format!("{err:?}")))?;
 
         let world = resolve
@@ -127,6 +181,7 @@ impl Parse for Config {
             resolve,
             world,
             files,
+            include_generated_code_from_file,
         })
     }
 }
@@ -134,40 +189,43 @@ impl Parse for Config {
 fn parse_source(
     path: &Option<String>,
     inline: &Option<String>,
+    features: &[String],
 ) -> anyhow::Result<(Resolve, PackageId, Vec<PathBuf>)> {
     let mut resolve = Resolve::default();
+    resolve.features.extend(features.iter().cloned());
     let mut files = Vec::new();
     let root = PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap());
 
     let mut parse = |resolve: &mut Resolve, path: &Path| -> anyhow::Result<_> {
-        if path.is_dir() {
-            let (pkg, sources) = resolve.push_dir(path)?;
-            files = sources;
-            Ok(pkg)
-        } else {
-            let pkg = UnresolvedPackage::parse_file(path)?;
-            files.extend(pkg.source_files().map(|s| s.to_owned()));
-            resolve.push(pkg)
-        }
+        // Try to normalize the path to make the error message more understandable when
+        // the path is not correct. Fallback to the original path if normalization fails
+        // (probably return an error somewhere else).
+        let normalized_path = match std::fs::canonicalize(path) {
+            Ok(p) => p,
+            Err(_) => path.to_path_buf(),
+        };
+        let (pkg, sources) = resolve.push_path(normalized_path)?;
+        files.extend(sources);
+        Ok(pkg)
     };
 
     let path_pkg = if let Some(path) = path {
-        Some(parse(&mut resolve, &root.join(&path))?)
+        Some(parse(&mut resolve, &root.join(path))?)
     } else {
         None
     };
 
-    let inline_pkg = if let Some(inline) = inline {
-        Some(resolve.push(UnresolvedPackage::parse("macro-input".as_ref(), &inline)?)?)
+    let inline_pkgs = if let Some(inline) = inline {
+        Some(resolve.push_group(UnresolvedPackageGroup::parse("macro-input", inline)?)?)
     } else {
         None
     };
 
-    let pkg = inline_pkg
+    let pkgs = inline_pkgs
         .or(path_pkg)
         .map_or_else(|| parse(&mut resolve, &root.join("wit")), Ok)?;
 
-    Ok((resolve, pkg, files))
+    Ok((resolve, pkgs, files))
 }
 
 mod kw {
@@ -181,6 +239,14 @@ mod kw {
     syn::custom_keyword!(with);
     syn::custom_keyword!(except_imports);
     syn::custom_keyword!(only_imports);
+    syn::custom_keyword!(trappable_imports);
+    syn::custom_keyword!(additional_derives);
+    syn::custom_keyword!(stringify);
+    syn::custom_keyword!(skip_mut_forwarding_impls);
+    syn::custom_keyword!(features);
+    syn::custom_keyword!(require_store_data_send);
+    syn::custom_keyword!(wasmtime_crate);
+    syn::custom_keyword!(include_generated_code_from_file);
 }
 
 enum Opt {
@@ -193,6 +259,14 @@ enum Opt {
     Ownership(Ownership),
     Interfaces(syn::LitStr),
     With(HashMap<String, String>),
+    TrappableImports(TrappableImports),
+    AdditionalDerives(Vec<syn::Path>),
+    Stringify(bool),
+    SkipMutForwardingImpls(bool),
+    Features(Vec<syn::LitStr>),
+    RequireStoreDataSend(bool),
+    WasmtimeCrate(syn::Path),
+    IncludeGeneratedCodeFromFile(bool),
 }
 
 impl Parse for Opt {
@@ -297,7 +371,7 @@ impl Parse for Opt {
             let _lbrace = braced!(contents in input);
             let fields: Punctuated<_, Token![,]> =
                 contents.parse_terminated(trappable_error_field_parse, Token![,])?;
-            Ok(Opt::TrappableErrorType(Vec::from_iter(fields.into_iter())))
+            Ok(Opt::TrappableErrorType(Vec::from_iter(fields)))
         } else if l.peek(kw::interfaces) {
             input.parse::<kw::interfaces>()?;
             input.parse::<Token![:]>()?;
@@ -309,7 +383,63 @@ impl Parse for Opt {
             let _lbrace = braced!(contents in input);
             let fields: Punctuated<(String, String), Token![,]> =
                 contents.parse_terminated(with_field_parse, Token![,])?;
-            Ok(Opt::With(HashMap::from_iter(fields.into_iter())))
+            Ok(Opt::With(HashMap::from_iter(fields)))
+        } else if l.peek(kw::trappable_imports) {
+            input.parse::<kw::trappable_imports>()?;
+            input.parse::<Token![:]>()?;
+            let config = if input.peek(syn::LitBool) {
+                match input.parse::<syn::LitBool>()?.value {
+                    true => TrappableImports::All,
+                    false => TrappableImports::None,
+                }
+            } else {
+                let contents;
+                syn::bracketed!(contents in input);
+                let fields: Punctuated<syn::LitStr, Token![,]> =
+                    contents.parse_terminated(Parse::parse, Token![,])?;
+                TrappableImports::Only(fields.iter().map(|s| s.value()).collect())
+            };
+            Ok(Opt::TrappableImports(config))
+        } else if l.peek(kw::additional_derives) {
+            input.parse::<kw::additional_derives>()?;
+            input.parse::<Token![:]>()?;
+            let contents;
+            syn::bracketed!(contents in input);
+            let list = Punctuated::<_, Token![,]>::parse_terminated(&contents)?;
+            Ok(Opt::AdditionalDerives(list.iter().cloned().collect()))
+        } else if l.peek(kw::stringify) {
+            input.parse::<kw::stringify>()?;
+            input.parse::<Token![:]>()?;
+            Ok(Opt::Stringify(input.parse::<syn::LitBool>()?.value))
+        } else if l.peek(kw::skip_mut_forwarding_impls) {
+            input.parse::<kw::skip_mut_forwarding_impls>()?;
+            input.parse::<Token![:]>()?;
+            Ok(Opt::SkipMutForwardingImpls(
+                input.parse::<syn::LitBool>()?.value,
+            ))
+        } else if l.peek(kw::features) {
+            input.parse::<kw::features>()?;
+            input.parse::<Token![:]>()?;
+            let contents;
+            syn::bracketed!(contents in input);
+            let list = Punctuated::<_, Token![,]>::parse_terminated(&contents)?;
+            Ok(Opt::Features(list.into_iter().collect()))
+        } else if l.peek(kw::require_store_data_send) {
+            input.parse::<kw::require_store_data_send>()?;
+            input.parse::<Token![:]>()?;
+            Ok(Opt::RequireStoreDataSend(
+                input.parse::<syn::LitBool>()?.value,
+            ))
+        } else if l.peek(kw::wasmtime_crate) {
+            input.parse::<kw::wasmtime_crate>()?;
+            input.parse::<Token![:]>()?;
+            Ok(Opt::WasmtimeCrate(input.parse()?))
+        } else if l.peek(kw::include_generated_code_from_file) {
+            input.parse::<kw::include_generated_code_from_file>()?;
+            input.parse::<Token![:]>()?;
+            Ok(Opt::IncludeGeneratedCodeFromFile(
+                input.parse::<syn::LitBool>()?.value,
+            ))
         } else {
             Err(l.error())
         }
@@ -317,28 +447,11 @@ impl Parse for Opt {
 }
 
 fn trappable_error_field_parse(input: ParseStream<'_>) -> Result<TrappableError> {
-    // Accept a Rust identifier or a string literal. This is required
-    // because not all wit identifiers are Rust identifiers, so we can
-    // smuggle the invalid ones inside quotes.
-    fn ident_or_str(input: ParseStream<'_>) -> Result<String> {
-        let l = input.lookahead1();
-        if l.peek(syn::LitStr) {
-            Ok(input.parse::<syn::LitStr>()?.value())
-        } else if l.peek(syn::Ident) {
-            Ok(input.parse::<syn::Ident>()?.to_string())
-        } else {
-            Err(l.error())
-        }
-    }
-
-    let wit_package_path = input.parse::<syn::LitStr>()?.value();
-    input.parse::<Token![::]>()?;
-    let wit_type_name = ident_or_str(input)?;
-    input.parse::<Token![:]>()?;
-    let rust_type_name = input.parse::<Ident>()?.to_string();
+    let wit_path = input.parse::<syn::LitStr>()?.value();
+    input.parse::<Token![=>]>()?;
+    let rust_type_name = input.parse::<syn::Path>()?.to_token_stream().to_string();
     Ok(TrappableError {
-        wit_package_path,
-        wit_type_name,
+        wit_path,
         rust_type_name,
     })
 }
diff --git a/crates/component-macro/src/component.rs b/crates/component-macro/src/component.rs
index 0f49ef07a819..a4c44e784607 100644
--- a/crates/component-macro/src/component.rs
+++ b/crates/component-macro/src/component.rs
@@ -1,10 +1,10 @@
-use proc_macro2::TokenStream;
+use proc_macro2::{Span, TokenStream};
 use quote::{format_ident, quote};
 use std::collections::HashSet;
 use std::fmt;
 use syn::parse::{Parse, ParseStream};
 use syn::punctuated::Punctuated;
-use syn::{braced, parse_quote, Data, DeriveInput, Error, Result, Token};
+use syn::{braced, parse_quote, Data, DeriveInput, Error, Ident, Result, Token};
 use wasmtime_component_util::{DiscriminantSize, FlagsSize};
 
 mod kw {
@@ -12,62 +12,48 @@ mod kw {
     syn::custom_keyword!(variant);
     syn::custom_keyword!(flags);
     syn::custom_keyword!(name);
-}
-
-#[derive(Debug, Copy, Clone)]
-pub enum VariantStyle {
-    Variant,
-    Enum,
-}
-
-impl fmt::Display for VariantStyle {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str(match self {
-            Self::Variant => "variant",
-            Self::Enum => "enum",
-        })
-    }
+    syn::custom_keyword!(wasmtime_crate);
 }
 
 #[derive(Debug, Copy, Clone)]
 enum Style {
     Record,
-    Variant(VariantStyle),
+    Enum,
+    Variant,
 }
 
-fn find_style(input: &DeriveInput) -> Result<Style> {
-    let mut style = None;
-
-    for attribute in &input.attrs {
-        if !attribute.path().is_ident("component") {
-            continue;
-        }
-        let attr_style = attribute.parse_args()?;
-
-        if style.is_some() {
-            return Err(Error::new_spanned(
-                attribute,
-                "duplicate `component` attribute",
-            ));
+impl fmt::Display for Style {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Style::Record => f.write_str("record"),
+            Style::Enum => f.write_str("enum"),
+            Style::Variant => f.write_str("variant"),
         }
-        style = Some(attr_style);
     }
+}
 
-    style.ok_or_else(|| Error::new_spanned(input, "missing `component` attribute"))
+#[derive(Debug, Clone)]
+enum ComponentAttr {
+    Style(Style),
+    WasmtimeCrate(syn::Path),
 }
 
-impl Parse for Style {
+impl Parse for ComponentAttr {
     fn parse(input: ParseStream) -> Result<Self> {
         let lookahead = input.lookahead1();
         if lookahead.peek(kw::record) {
             input.parse::<kw::record>()?;
-            Ok(Style::Record)
+            Ok(ComponentAttr::Style(Style::Record))
         } else if lookahead.peek(kw::variant) {
             input.parse::<kw::variant>()?;
-            Ok(Style::Variant(VariantStyle::Variant))
+            Ok(ComponentAttr::Style(Style::Variant))
         } else if lookahead.peek(Token![enum]) {
             input.parse::<Token![enum]>()?;
-            Ok(Style::Variant(VariantStyle::Enum))
+            Ok(ComponentAttr::Style(Style::Enum))
+        } else if lookahead.peek(kw::wasmtime_crate) {
+            input.parse::<kw::wasmtime_crate>()?;
+            input.parse::<Token![=]>()?;
+            Ok(ComponentAttr::WasmtimeCrate(input.parse()?))
         } else if input.peek(kw::flags) {
             Err(input.error(
                 "`flags` not allowed here; \
@@ -127,6 +113,7 @@ pub trait Expander {
         name: &syn::Ident,
         generics: &syn::Generics,
         fields: &[&syn::Field],
+        wasmtime_crate: &syn::Path,
     ) -> Result<TokenStream>;
 
     fn expand_variant(
@@ -135,18 +122,57 @@ pub trait Expander {
         generics: &syn::Generics,
         discriminant_size: DiscriminantSize,
         cases: &[VariantCase],
-        style: VariantStyle,
+        wasmtime_crate: &syn::Path,
+    ) -> Result<TokenStream>;
+
+    fn expand_enum(
+        &self,
+        name: &syn::Ident,
+        discriminant_size: DiscriminantSize,
+        cases: &[VariantCase],
+        wasmtime_crate: &syn::Path,
     ) -> Result<TokenStream>;
 }
 
 pub fn expand(expander: &dyn Expander, input: &DeriveInput) -> Result<TokenStream> {
-    match find_style(input)? {
-        Style::Record => expand_record(expander, input),
-        Style::Variant(style) => expand_variant(expander, input, style),
+    let mut wasmtime_crate = None;
+    let mut style = None;
+
+    for attribute in &input.attrs {
+        if !attribute.path().is_ident("component") {
+            continue;
+        }
+        match attribute.parse_args()? {
+            ComponentAttr::WasmtimeCrate(c) => wasmtime_crate = Some(c),
+            ComponentAttr::Style(attr_style) => {
+                if style.is_some() {
+                    return Err(Error::new_spanned(
+                        attribute,
+                        "duplicate `component` attribute",
+                    ));
+                }
+                style = Some(attr_style);
+            }
+        }
+    }
+
+    let style = style.ok_or_else(|| Error::new_spanned(input, "missing `component` attribute"))?;
+    let wasmtime_crate = wasmtime_crate.unwrap_or_else(default_wasmtime_crate);
+    match style {
+        Style::Record => expand_record(expander, input, &wasmtime_crate),
+        Style::Enum | Style::Variant => expand_variant(expander, input, style, &wasmtime_crate),
     }
 }
 
-fn expand_record(expander: &dyn Expander, input: &DeriveInput) -> Result<TokenStream> {
+fn default_wasmtime_crate() -> syn::Path {
+    Ident::new("wasmtime", Span::call_site()).into()
+}
+
+fn expand_record(
+    expander: &dyn Expander,
+    input: &DeriveInput,
+    wasmtime_crate: &syn::Path,
+) -> Result<TokenStream> {
     let name = &input.ident;
 
     let body = if let Data::Struct(body) = &input.data {
@@ -163,6 +189,7 @@ fn expand_record(expander: &dyn Expander, input: &DeriveInput) -> Result<TokenSt
             &input.ident,
             &input.generics,
             &fields.named.iter().collect::<Vec<_>>(),
+            wasmtime_crate,
         ),
 
         syn::Fields::Unnamed(_) | syn::Fields::Unit => Err(Error::new(
@@ -175,7 +202,8 @@ fn expand_record(expander: &dyn Expander, input: &DeriveInput) -> Result<TokenSt
 fn expand_variant(
     expander: &dyn Expander,
     input: &DeriveInput,
-    style: VariantStyle,
+    style: Style,
+    wasmtime_crate: &syn::Path,
 ) -> Result<TokenStream> {
     let name = &input.ident;
 
@@ -184,17 +212,14 @@ fn expand_variant(
     } else {
         return Err(Error::new(
             name.span(),
-            format!(
-                "`{}` component types can only be derived for Rust `enum`s",
-                style
-            ),
+            format!("`{style}` component types can only be derived for Rust `enum`s"),
         ));
     };
 
     if body.variants.is_empty() {
         return Err(Error::new(
             name.span(),
-            format!("`{}` component types can only be derived for Rust `enum`s with at least one variant", style),
+            format!("`{style}` component types can only be derived for Rust `enum`s with at least one variant"),
         ));
     }
 
@@ -231,8 +256,9 @@ fn expand_variant(
                                      containing variants with {}",
                                     style,
                                     match style {
-                                        VariantStyle::Variant => "at most one unnamed field each",
-                                        VariantStyle::Enum => "no fields",
+                                        Style::Variant => "at most one unnamed field each",
+                                        Style::Enum => "no fields",
+                                        Style::Record => unreachable!(),
                                     }
                                 ),
                             ))
@@ -243,13 +269,77 @@ fn expand_variant(
         )
         .collect::<Result<Vec<_>>>()?;
 
-    expander.expand_variant(
-        &input.ident,
-        &input.generics,
-        discriminant_size,
-        &cases,
-        style,
-    )
+    match style {
+        Style::Variant => expander.expand_variant(
+            &input.ident,
+            &input.generics,
+            discriminant_size,
+            &cases,
+            wasmtime_crate,
+        ),
+        Style::Enum => {
+            validate_enum(input, &body, discriminant_size)?;
+            expander.expand_enum(&input.ident, discriminant_size, &cases, wasmtime_crate)
+        }
+        Style::Record => unreachable!(),
+    }
+}
+
+/// Validates component model `enum` definitions are accompanied with
+/// appropriate `#[repr]` tags. Additionally requires that no discriminants are
+/// listed to ensure that unsafe transmutes in lift are valid.
+fn validate_enum(input: &DeriveInput, body: &syn::DataEnum, size: DiscriminantSize) -> Result<()> {
+    if !input.generics.params.is_empty() {
+        return Err(Error::new_spanned(
+            &input.generics.params,
+            "cannot have generics on an `enum`",
+        ));
+    }
+    if let Some(clause) = &input.generics.where_clause {
+        return Err(Error::new_spanned(
+            clause,
+            "cannot have a where clause on an `enum`",
+        ));
+    }
+    let expected_discr = match size {
+        DiscriminantSize::Size1 => "u8",
+        DiscriminantSize::Size2 => "u16",
+        DiscriminantSize::Size4 => "u32",
+    };
+    let mut found_repr = false;
+    for attr in input.attrs.iter() {
+        if !attr.meta.path().is_ident("repr") {
+            continue;
+        }
+        let list = attr.meta.require_list()?;
+        found_repr = true;
+        if list.tokens.to_string() != expected_discr {
+            return Err(Error::new_spanned(
+                &list.tokens,
+                format!(
+                    "expected `repr({expected_discr})`, found `repr({})`",
+                    list.tokens
+                ),
+            ));
+        }
+    }
+    if !found_repr {
+        return Err(Error::new_spanned(
+            &body.enum_token,
+            format!("missing required `#[repr({expected_discr})]`"),
+        ));
+    }
+
+    for case in body.variants.iter() {
+        if let Some((_, expr)) = &case.discriminant {
+            return Err(Error::new_spanned(
+                expr,
+                "cannot have an explicit discriminant",
+            ));
+        }
+    }
+
+    Ok(())
 }
 
 fn expand_record_for_component_type(
@@ -258,8 +348,9 @@ fn expand_record_for_component_type(
     fields: &[&syn::Field],
     typecheck: TokenStream,
     typecheck_argument: TokenStream,
+    wt: &syn::Path,
 ) -> Result<TokenStream> {
-    let internal = quote!(wasmtime::component::__internal);
+    let internal = quote!(#wt::component::__internal);
 
     let mut lower_generic_params = TokenStream::new();
     let mut lower_generic_args = TokenStream::new();
@@ -271,18 +362,18 @@ fn expand_record_for_component_type(
         let generic = format_ident!("T{}", index);
 
         lower_generic_params.extend(quote!(#generic: Copy,));
-        lower_generic_args.extend(quote!(<#ty as wasmtime::component::ComponentType>::Lower,));
+        lower_generic_args.extend(quote!(<#ty as #wt::component::ComponentType>::Lower,));
 
         lower_field_declarations.extend(quote!(#ident: #generic,));
 
         abi_list.extend(quote!(
-            <#ty as wasmtime::component::ComponentType>::ABI,
+            <#ty as #wt::component::ComponentType>::ABI,
         ));
 
         unique_types.insert(ty);
     }
 
-    let generics = add_trait_bounds(generics, parse_quote!(wasmtime::component::ComponentType));
+    let generics = add_trait_bounds(generics, parse_quote!(#wt::component::ComponentType));
     let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
     let lower = format_ident!("Lower{}", name);
 
@@ -307,10 +398,10 @@ fn expand_record_for_component_type(
         #[repr(C)]
         pub struct #lower <#lower_generic_params> {
             #lower_field_declarations
-            _align: [wasmtime::ValRaw; 0],
+            _align: [#wt::ValRaw; 0],
         }
 
-        unsafe impl #impl_generics wasmtime::component::ComponentType for #name #ty_generics #where_clause {
+        unsafe impl #impl_generics #wt::component::ComponentType for #name #ty_generics #where_clause {
             type Lower = #lower <#lower_generic_args>;
 
             const ABI: #internal::CanonicalAbiInfo =
@@ -354,27 +445,28 @@ impl Expander for LiftExpander {
         name: &syn::Ident,
         generics: &syn::Generics,
         fields: &[&syn::Field],
+        wt: &syn::Path,
     ) -> Result<TokenStream> {
-        let internal = quote!(wasmtime::component::__internal);
+        let internal = quote!(#wt::component::__internal);
 
         let mut lifts = TokenStream::new();
         let mut loads = TokenStream::new();
 
         for (i, syn::Field { ident, ty, .. }) in fields.iter().enumerate() {
             let field_ty = quote!(ty.fields[#i].ty);
-            lifts.extend(quote!(#ident: <#ty as wasmtime::component::Lift>::lift(
+            lifts.extend(quote!(#ident: <#ty as #wt::component::Lift>::lift(
                 cx, #field_ty, &src.#ident
             )?,));
 
-            loads.extend(quote!(#ident: <#ty as wasmtime::component::Lift>::load(
+            loads.extend(quote!(#ident: <#ty as #wt::component::Lift>::load(
                 cx, #field_ty,
                 &bytes
-                    [<#ty as wasmtime::component::ComponentType>::ABI.next_field32_size(&mut offset)..]
-                    [..<#ty as wasmtime::component::ComponentType>::SIZE32]
+                    [<#ty as #wt::component::ComponentType>::ABI.next_field32_size(&mut offset)..]
+                    [..<#ty as #wt::component::ComponentType>::SIZE32]
             )?,));
         }
 
-        let generics = add_trait_bounds(generics, parse_quote!(wasmtime::component::Lift));
+        let generics = add_trait_bounds(generics, parse_quote!(#wt::component::Lift));
         let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
 
         let extract_ty = quote! {
@@ -385,7 +477,7 @@ impl Expander for LiftExpander {
         };
 
         let expanded = quote! {
-            unsafe impl #impl_generics wasmtime::component::Lift for #name #ty_generics #where_clause {
+            unsafe impl #impl_generics #wt::component::Lift for #name #ty_generics #where_clause {
                 #[inline]
                 fn lift(
                     cx: &mut #internal::LiftContext<'_>,
@@ -407,7 +499,7 @@ impl Expander for LiftExpander {
                     #extract_ty
                     debug_assert!(
                         (bytes.as_ptr() as usize)
-                            % (<Self as wasmtime::component::ComponentType>::ALIGN32 as usize)
+                            % (<Self as #wt::component::ComponentType>::ALIGN32 as usize)
                             == 0
                     );
                     let mut offset = 0;
@@ -427,39 +519,29 @@ impl Expander for LiftExpander {
         generics: &syn::Generics,
         discriminant_size: DiscriminantSize,
         cases: &[VariantCase],
-        style: VariantStyle,
+        wt: &syn::Path,
     ) -> Result<TokenStream> {
-        let internal = quote!(wasmtime::component::__internal);
+        let internal = quote!(#wt::component::__internal);
 
         let mut lifts = TokenStream::new();
         let mut loads = TokenStream::new();
 
-        let interface_type_variant = match style {
-            VariantStyle::Variant => quote!(Variant),
-            VariantStyle::Enum => quote!(Enum),
-        };
-
         for (index, VariantCase { ident, ty, .. }) in cases.iter().enumerate() {
             let index_u32 = u32::try_from(index).unwrap();
 
             let index_quoted = quote(discriminant_size, index);
 
             if let Some(ty) = ty {
-                let payload_ty = match style {
-                    VariantStyle::Variant => {
-                        quote!(ty.cases[#index].ty.unwrap_or_else(#internal::bad_type_info))
-                    }
-                    VariantStyle::Enum => unreachable!(),
-                };
+                let payload_ty = quote!(ty.cases[#index].unwrap_or_else(#internal::bad_type_info));
                 lifts.extend(
-                    quote!(#index_u32 => Self::#ident(<#ty as wasmtime::component::Lift>::lift(
+                    quote!(#index_u32 => Self::#ident(<#ty as #wt::component::Lift>::lift(
                         cx, #payload_ty, unsafe { &src.payload.#ident }
                     )?),),
                 );
 
                 loads.extend(
-                    quote!(#index_quoted => Self::#ident(<#ty as wasmtime::component::Lift>::load(
-                        cx, #payload_ty, &payload[..<#ty as wasmtime::component::ComponentType>::SIZE32]
+                    quote!(#index_quoted => Self::#ident(<#ty as #wt::component::Lift>::load(
+                        cx, #payload_ty, &payload[..<#ty as #wt::component::ComponentType>::SIZE32]
                     )?),),
                 );
             } else {
@@ -469,7 +551,7 @@ impl Expander for LiftExpander {
             }
         }
 
-        let generics = add_trait_bounds(generics, parse_quote!(wasmtime::component::Lift));
+        let generics = add_trait_bounds(generics, parse_quote!(#wt::component::Lift));
         let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
 
         let from_bytes = match discriminant_size {
@@ -480,13 +562,13 @@ impl Expander for LiftExpander {
 
         let extract_ty = quote! {
             let ty = match ty {
-                #internal::InterfaceType::#interface_type_variant(i) => &cx.types[i],
+                #internal::InterfaceType::Variant(i) => &cx.types[i],
                 _ => #internal::bad_type_info(),
             };
         };
 
         let expanded = quote! {
-            unsafe impl #impl_generics wasmtime::component::Lift for #name #ty_generics #where_clause {
+            unsafe impl #impl_generics #wt::component::Lift for #name #ty_generics #where_clause {
                 #[inline]
                 fn lift(
                     cx: &mut #internal::LiftContext<'_>,
@@ -506,7 +588,7 @@ impl Expander for LiftExpander {
                     ty: #internal::InterfaceType,
                     bytes: &[u8],
                 ) -> #internal::anyhow::Result<Self> {
-                    let align = <Self as wasmtime::component::ComponentType>::ALIGN32;
+                    let align = <Self as #wt::component::ComponentType>::ALIGN32;
                     debug_assert!((bytes.as_ptr() as usize) % (align as usize) == 0);
                     let discrim = #from_bytes;
                     let payload_offset = <Self as #internal::ComponentVariant>::PAYLOAD_OFFSET32;
@@ -522,6 +604,75 @@ impl Expander for LiftExpander {
 
         Ok(expanded)
     }
+
+    fn expand_enum(
+        &self,
+        name: &syn::Ident,
+        discriminant_size: DiscriminantSize,
+        cases: &[VariantCase],
+        wt: &syn::Path,
+    ) -> Result<TokenStream> {
+        let internal = quote!(#wt::component::__internal);
+
+        let (from_bytes, discrim_ty) = match discriminant_size {
+            DiscriminantSize::Size1 => (quote!(bytes[0]), quote!(u8)),
+            DiscriminantSize::Size2 => (
+                quote!(u16::from_le_bytes(bytes[0..2].try_into()?)),
+                quote!(u16),
+            ),
+            DiscriminantSize::Size4 => (
+                quote!(u32::from_le_bytes(bytes[0..4].try_into()?)),
+                quote!(u32),
+            ),
+        };
+        let discrim_limit = proc_macro2::Literal::usize_unsuffixed(cases.len());
+
+        let extract_ty = quote! {
+            let ty = match ty {
+                #internal::InterfaceType::Enum(i) => &cx.types[i],
+                _ => #internal::bad_type_info(),
+            };
+        };
+
+        let expanded = quote! {
+            unsafe impl #wt::component::Lift for #name {
+                #[inline]
+                fn lift(
+                    cx: &mut #internal::LiftContext<'_>,
+                    ty: #internal::InterfaceType,
+                    src: &Self::Lower,
+                ) -> #internal::anyhow::Result<Self> {
+                    #extract_ty
+                    let discrim = src.tag.get_u32();
+                    if discrim >= #discrim_limit {
+                        #internal::anyhow::bail!("unexpected discriminant: {discrim}");
+                    }
+                    Ok(unsafe {
+                        #internal::transmute::<#discrim_ty, #name>(discrim as #discrim_ty)
+                    })
+                }
+
+                #[inline]
+                fn load(
+                    cx: &mut #internal::LiftContext<'_>,
+                    ty: #internal::InterfaceType,
+                    bytes: &[u8],
+                ) -> #internal::anyhow::Result<Self> {
+                    let align = <Self as #wt::component::ComponentType>::ALIGN32;
+                    debug_assert!((bytes.as_ptr() as usize) % (align as usize) == 0);
+                    let discrim = #from_bytes;
+                    if discrim >= #discrim_limit {
+                        #internal::anyhow::bail!("unexpected discriminant: {discrim}");
+                    }
+                    Ok(unsafe {
+                        #internal::transmute::<#discrim_ty, #name>(discrim)
+                    })
+                }
+            }
+        };
+
+        Ok(expanded)
+    }
 }
 
 pub struct LowerExpander;
@@ -532,27 +683,28 @@ impl Expander for LowerExpander {
         name: &syn::Ident,
         generics: &syn::Generics,
         fields: &[&syn::Field],
+        wt: &syn::Path,
     ) -> Result<TokenStream> {
-        let internal = quote!(wasmtime::component::__internal);
+        let internal = quote!(#wt::component::__internal);
 
         let mut lowers = TokenStream::new();
         let mut stores = TokenStream::new();
 
         for (i, syn::Field { ident, ty, .. }) in fields.iter().enumerate() {
             let field_ty = quote!(ty.fields[#i].ty);
-            lowers.extend(quote!(wasmtime::component::Lower::lower(
+            lowers.extend(quote!(#wt::component::Lower::lower(
                 &self.#ident, cx, #field_ty, #internal::map_maybe_uninit!(dst.#ident)
             )?;));
 
-            stores.extend(quote!(wasmtime::component::Lower::store(
+            stores.extend(quote!(#wt::component::Lower::store(
                 &self.#ident,
                 cx,
                 #field_ty,
-                <#ty as wasmtime::component::ComponentType>::ABI.next_field32_size(&mut offset),
+                <#ty as #wt::component::ComponentType>::ABI.next_field32_size(&mut offset),
             )?;));
         }
 
-        let generics = add_trait_bounds(generics, parse_quote!(wasmtime::component::Lower));
+        let generics = add_trait_bounds(generics, parse_quote!(#wt::component::Lower));
         let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
 
         let extract_ty = quote! {
@@ -563,13 +715,13 @@ impl Expander for LowerExpander {
         };
 
         let expanded = quote! {
-            unsafe impl #impl_generics wasmtime::component::Lower for #name #ty_generics #where_clause {
+            unsafe impl #impl_generics #wt::component::Lower for #name #ty_generics #where_clause {
                 #[inline]
                 fn lower<T>(
                     &self,
                     cx: &mut #internal::LowerContext<'_, T>,
                     ty: #internal::InterfaceType,
-                    dst: &mut std::mem::MaybeUninit<Self::Lower>,
+                    dst: &mut core::mem::MaybeUninit<Self::Lower>,
                 ) -> #internal::anyhow::Result<()> {
                     #extract_ty
                     #lowers
@@ -583,7 +735,7 @@ impl Expander for LowerExpander {
                     ty: #internal::InterfaceType,
                     mut offset: usize
                 ) -> #internal::anyhow::Result<()> {
-                    debug_assert!(offset % (<Self as wasmtime::component::ComponentType>::ALIGN32 as usize) == 0);
+                    debug_assert!(offset % (<Self as #wt::component::ComponentType>::ALIGN32 as usize) == 0);
                     #extract_ty
                     #stores
                     Ok(())
@@ -600,18 +752,13 @@ impl Expander for LowerExpander {
         generics: &syn::Generics,
         discriminant_size: DiscriminantSize,
         cases: &[VariantCase],
-        style: VariantStyle,
+        wt: &syn::Path,
     ) -> Result<TokenStream> {
-        let internal = quote!(wasmtime::component::__internal);
+        let internal = quote!(#wt::component::__internal);
 
         let mut lowers = TokenStream::new();
         let mut stores = TokenStream::new();
 
-        let interface_type_variant = match style {
-            VariantStyle::Variant => quote!(Variant),
-            VariantStyle::Enum => quote!(Enum),
-        };
-
         for (index, VariantCase { ident, ty, .. }) in cases.iter().enumerate() {
             let index_u32 = u32::try_from(index).unwrap();
 
@@ -624,12 +771,7 @@ impl Expander for LowerExpander {
             let store;
 
             if ty.is_some() {
-                let ty = match style {
-                    VariantStyle::Variant => {
-                        quote!(ty.cases[#index].ty.unwrap_or_else(#internal::bad_type_info))
-                    }
-                    VariantStyle::Enum => unreachable!(),
-                };
+                let ty = quote!(ty.cases[#index].unwrap_or_else(#internal::bad_type_info));
                 pattern = quote!(Self::#ident(value));
                 lower = quote!(value.lower(cx, #ty, dst));
                 store = quote!(value.store(
@@ -644,7 +786,7 @@ impl Expander for LowerExpander {
             }
 
             lowers.extend(quote!(#pattern => {
-                #internal::map_maybe_uninit!(dst.tag).write(wasmtime::ValRaw::u32(#index_u32));
+                #internal::map_maybe_uninit!(dst.tag).write(#wt::ValRaw::u32(#index_u32));
                 unsafe {
                     #internal::lower_payload(
                         #internal::map_maybe_uninit!(dst.payload),
@@ -660,24 +802,24 @@ impl Expander for LowerExpander {
             }));
         }
 
-        let generics = add_trait_bounds(generics, parse_quote!(wasmtime::component::Lower));
+        let generics = add_trait_bounds(generics, parse_quote!(#wt::component::Lower));
         let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
 
         let extract_ty = quote! {
             let ty = match ty {
-                #internal::InterfaceType::#interface_type_variant(i) => &cx.types[i],
+                #internal::InterfaceType::Variant(i) => &cx.types[i],
                 _ => #internal::bad_type_info(),
             };
         };
 
         let expanded = quote! {
-            unsafe impl #impl_generics wasmtime::component::Lower for #name #ty_generics #where_clause {
+            unsafe impl #impl_generics #wt::component::Lower for #name #ty_generics #where_clause {
                 #[inline]
                 fn lower<T>(
                     &self,
                     cx: &mut #internal::LowerContext<'_, T>,
                     ty: #internal::InterfaceType,
-                    dst: &mut std::mem::MaybeUninit<Self::Lower>,
+                    dst: &mut core::mem::MaybeUninit<Self::Lower>,
                 ) -> #internal::anyhow::Result<()> {
                     #extract_ty
                     match self {
@@ -693,7 +835,7 @@ impl Expander for LowerExpander {
                     mut offset: usize
                 ) -> #internal::anyhow::Result<()> {
                     #extract_ty
-                    debug_assert!(offset % (<Self as wasmtime::component::ComponentType>::ALIGN32 as usize) == 0);
+                    debug_assert!(offset % (<Self as #wt::component::ComponentType>::ALIGN32 as usize) == 0);
                     match self {
                         #stores
                     }
@@ -703,6 +845,63 @@ impl Expander for LowerExpander {
 
         Ok(expanded)
     }
+
+    fn expand_enum(
+        &self,
+        name: &syn::Ident,
+        discriminant_size: DiscriminantSize,
+        _cases: &[VariantCase],
+        wt: &syn::Path,
+    ) -> Result<TokenStream> {
+        let internal = quote!(#wt::component::__internal);
+
+        let extract_ty = quote! {
+            let ty = match ty {
+                #internal::InterfaceType::Enum(i) => &cx.types[i],
+                _ => #internal::bad_type_info(),
+            };
+        };
+
+        let (size, ty) = match discriminant_size {
+            DiscriminantSize::Size1 => (1, quote!(u8)),
+            DiscriminantSize::Size2 => (2, quote!(u16)),
+            DiscriminantSize::Size4 => (4, quote!(u32)),
+        };
+        let size = proc_macro2::Literal::usize_unsuffixed(size);
+
+        let expanded = quote! {
+            unsafe impl #wt::component::Lower for #name {
+                #[inline]
+                fn lower<T>(
+                    &self,
+                    cx: &mut #internal::LowerContext<'_, T>,
+                    ty: #internal::InterfaceType,
+                    dst: &mut core::mem::MaybeUninit<Self::Lower>,
+                ) -> #internal::anyhow::Result<()> {
+                    #extract_ty
+                    #internal::map_maybe_uninit!(dst.tag)
+                        .write(#wt::ValRaw::u32(*self as u32));
+                    Ok(())
+                }
+
+                #[inline]
+                fn store<T>(
+                    &self,
+                    cx: &mut #internal::LowerContext<'_, T>,
+                    ty: #internal::InterfaceType,
+                    mut offset: usize
+                ) -> #internal::anyhow::Result<()> {
+                    #extract_ty
+                    debug_assert!(offset % (<Self as #wt::component::ComponentType>::ALIGN32 as usize) == 0);
+                    let discrim = *self as #ty;
+                    *cx.get::<#size>(offset) = discrim.to_le_bytes();
+                    Ok(())
+                }
+            }
+        };
+
+        Ok(expanded)
+    }
 }
 
 pub struct ComponentTypeExpander;
@@ -713,6 +912,7 @@ impl Expander for ComponentTypeExpander {
         name: &syn::Ident,
         generics: &syn::Generics,
         fields: &[&syn::Field],
+        wt: &syn::Path,
     ) -> Result<TokenStream> {
         expand_record_for_component_type(
             name,
@@ -730,10 +930,11 @@ impl Expander for ComponentTypeExpander {
                             syn::LitStr::new(&ident.to_string(), ident.span())
                         });
 
-                        Ok(quote!((#name, <#ty as wasmtime::component::ComponentType>::typecheck),))
+                        Ok(quote!((#name, <#ty as #wt::component::ComponentType>::typecheck),))
                     },
                 )
                 .collect::<Result<_>>()?,
+            wt,
         )
     }
 
@@ -743,9 +944,9 @@ impl Expander for ComponentTypeExpander {
         generics: &syn::Generics,
         _discriminant_size: DiscriminantSize,
         cases: &[VariantCase],
-        style: VariantStyle,
+        wt: &syn::Path,
     ) -> Result<TokenStream> {
-        let internal = quote!(wasmtime::component::__internal);
+        let internal = quote!(#wt::component::__internal);
 
         let mut case_names_and_checks = TokenStream::new();
         let mut lower_payload_generic_params = TokenStream::new();
@@ -761,47 +962,28 @@ impl Expander for ComponentTypeExpander {
             let name = rename.unwrap_or_else(|| syn::LitStr::new(&ident.to_string(), ident.span()));
 
             if let Some(ty) = ty {
-                abi_list.extend(quote!(Some(<#ty as wasmtime::component::ComponentType>::ABI),));
+                abi_list.extend(quote!(Some(<#ty as #wt::component::ComponentType>::ABI),));
 
-                case_names_and_checks.extend(match style {
-                    VariantStyle::Variant => {
-                        quote!((#name, Some(<#ty as wasmtime::component::ComponentType>::typecheck)),)
-                    }
-                    VariantStyle::Enum => {
-                        return Err(Error::new(
-                            ident.span(),
-                            "payloads are not permitted for `enum` cases",
-                        ))
-                    }
-                });
+                case_names_and_checks.extend(
+                    quote!((#name, Some(<#ty as #wt::component::ComponentType>::typecheck)),),
+                );
 
                 let generic = format_ident!("T{}", index);
 
                 lower_payload_generic_params.extend(quote!(#generic: Copy,));
                 lower_payload_generic_args.extend(quote!(#generic,));
                 lower_payload_case_declarations.extend(quote!(#ident: #generic,));
-                lower_generic_args
-                    .extend(quote!(<#ty as wasmtime::component::ComponentType>::Lower,));
+                lower_generic_args.extend(quote!(<#ty as #wt::component::ComponentType>::Lower,));
 
                 unique_types.insert(ty);
             } else {
                 abi_list.extend(quote!(None,));
-                case_names_and_checks.extend(match style {
-                    VariantStyle::Variant => {
-                        quote!((#name, None),)
-                    }
-                    VariantStyle::Enum => quote!(#name,),
-                });
-                lower_payload_case_declarations.extend(quote!(#ident: [wasmtime::ValRaw; 0],));
+                case_names_and_checks.extend(quote!((#name, None),));
+                lower_payload_case_declarations.extend(quote!(#ident: [#wt::ValRaw; 0],));
             }
         }
 
-        let typecheck = match style {
-            VariantStyle::Variant => quote!(typecheck_variant),
-            VariantStyle::Enum => quote!(typecheck_enum),
-        };
-
-        let generics = add_trait_bounds(generics, parse_quote!(wasmtime::component::ComponentType));
+        let generics = add_trait_bounds(generics, parse_quote!(#wt::component::ComponentType));
         let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
         let lower = format_ident!("Lower{}", name);
         let lower_payload = format_ident!("LowerPayload{}", name);
@@ -819,7 +1001,7 @@ impl Expander for ComponentTypeExpander {
             #[derive(Clone, Copy)]
             #[repr(C)]
             pub struct #lower<#lower_payload_generic_params> {
-                tag: wasmtime::ValRaw,
+                tag: #wt::ValRaw,
                 payload: #lower_payload<#lower_payload_generic_args>
             }
 
@@ -831,7 +1013,7 @@ impl Expander for ComponentTypeExpander {
                 #lower_payload_case_declarations
             }
 
-            unsafe impl #impl_generics wasmtime::component::ComponentType for #name #ty_generics #where_clause {
+            unsafe impl #impl_generics #wt::component::ComponentType for #name #ty_generics #where_clause {
                 type Lower = #lower<#lower_generic_args>;
 
                 #[inline]
@@ -839,7 +1021,7 @@ impl Expander for ComponentTypeExpander {
                     ty: &#internal::InterfaceType,
                     types: &#internal::InstanceType<'_>,
                 ) -> #internal::anyhow::Result<()> {
-                    #internal::#typecheck(ty, types, &[#case_names_and_checks])
+                    #internal::typecheck_variant(ty, types, &[#case_names_and_checks])
                 }
 
                 const ABI: #internal::CanonicalAbiInfo =
@@ -853,6 +1035,67 @@ impl Expander for ComponentTypeExpander {
 
         Ok(quote!(const _: () = { #expanded };))
     }
+
+    fn expand_enum(
+        &self,
+        name: &syn::Ident,
+        _discriminant_size: DiscriminantSize,
+        cases: &[VariantCase],
+        wt: &syn::Path,
+    ) -> Result<TokenStream> {
+        let internal = quote!(#wt::component::__internal);
+
+        let mut case_names = TokenStream::new();
+        let mut abi_list = TokenStream::new();
+
+        for VariantCase { attrs, ident, ty } in cases.iter() {
+            let rename = find_rename(attrs)?;
+
+            let name = rename.unwrap_or_else(|| syn::LitStr::new(&ident.to_string(), ident.span()));
+
+            if ty.is_some() {
+                return Err(Error::new(
+                    ident.span(),
+                    "payloads are not permitted for `enum` cases",
+                ));
+            }
+            abi_list.extend(quote!(None,));
+            case_names.extend(quote!(#name,));
+        }
+
+        let lower = format_ident!("Lower{}", name);
+
+        let cases_len = cases.len();
+        let expanded = quote! {
+            #[doc(hidden)]
+            #[derive(Clone, Copy)]
+            #[repr(C)]
+            pub struct #lower {
+                tag: #wt::ValRaw,
+            }
+
+            unsafe impl #wt::component::ComponentType for #name {
+                type Lower = #lower;
+
+                #[inline]
+                fn typecheck(
+                    ty: &#internal::InterfaceType,
+                    types: &#internal::InstanceType<'_>,
+                ) -> #internal::anyhow::Result<()> {
+                    #internal::typecheck_enum(ty, types, &[#case_names])
+                }
+
+                const ABI: #internal::CanonicalAbiInfo =
+                    #internal::CanonicalAbiInfo::enum_(#cases_len);
+            }
+
+            unsafe impl #internal::ComponentVariant for #name {
+                const CASES: &'static [Option<#internal::CanonicalAbiInfo>] = &[#abi_list];
+            }
+        };
+
+        Ok(quote!(const _: () = { #expanded };))
+    }
 }
 
 #[derive(Debug)]
@@ -897,6 +1140,7 @@ impl Parse for Flags {
 }
 
 pub fn expand_flags(flags: &Flags) -> Result<TokenStream> {
+    let wt = default_wasmtime_crate();
     let size = FlagsSize::from_count(flags.flags.len());
 
     let ty;
@@ -1099,9 +1343,10 @@ pub fn expand_flags(flags: &Flags) -> Result<TokenStream> {
         &fields,
         quote!(typecheck_flags),
         component_names,
+        &wt,
     )?;
 
-    let internal = quote!(wasmtime::component::__internal);
+    let internal = quote!(#wt::component::__internal);
 
     let field_names = fields
         .iter()
@@ -1136,7 +1381,7 @@ pub fn expand_flags(flags: &Flags) -> Result<TokenStream> {
             }
 
             pub fn all() -> Self {
-                use std::ops::Not;
+                use core::ops::Not;
                 Self::default().not()
             }
 
@@ -1149,21 +1394,21 @@ pub fn expand_flags(flags: &Flags) -> Result<TokenStream> {
             }
         }
 
-        impl std::cmp::PartialEq for #name {
+        impl core::cmp::PartialEq for #name {
             fn eq(&self, rhs: &#name) -> bool {
                 #eq
             }
         }
 
-        impl std::cmp::Eq for #name { }
+        impl core::cmp::Eq for #name { }
 
-        impl std::fmt::Debug for #name {
-            fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        impl core::fmt::Debug for #name {
+            fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
                 #internal::format_flags(&self.as_array(), &[#rust_names], f)
             }
         }
 
-        impl std::ops::BitOr for #name {
+        impl core::ops::BitOr for #name {
             type Output = #name;
 
             fn bitor(self, rhs: #name) -> #name {
@@ -1171,13 +1416,13 @@ pub fn expand_flags(flags: &Flags) -> Result<TokenStream> {
             }
         }
 
-        impl std::ops::BitOrAssign for #name {
+        impl core::ops::BitOrAssign for #name {
             fn bitor_assign(&mut self, rhs: #name) {
                 #bitor_assign
             }
         }
 
-        impl std::ops::BitAnd for #name {
+        impl core::ops::BitAnd for #name {
             type Output = #name;
 
             fn bitand(self, rhs: #name) -> #name {
@@ -1185,13 +1430,13 @@ pub fn expand_flags(flags: &Flags) -> Result<TokenStream> {
             }
         }
 
-        impl std::ops::BitAndAssign for #name {
+        impl core::ops::BitAndAssign for #name {
             fn bitand_assign(&mut self, rhs: #name) {
                 #bitand_assign
             }
         }
 
-        impl std::ops::BitXor for #name {
+        impl core::ops::BitXor for #name {
             type Output = #name;
 
             fn bitxor(self, rhs: #name) -> #name {
@@ -1199,13 +1444,13 @@ pub fn expand_flags(flags: &Flags) -> Result<TokenStream> {
             }
         }
 
-        impl std::ops::BitXorAssign for #name {
+        impl core::ops::BitXorAssign for #name {
             fn bitxor_assign(&mut self, rhs: #name) {
                 #bitxor_assign
             }
         }
 
-        impl std::ops::Not for #name {
+        impl core::ops::Not for #name {
             type Output = #name;
 
             fn not(self) -> #name {
@@ -1215,12 +1460,12 @@ pub fn expand_flags(flags: &Flags) -> Result<TokenStream> {
 
         #component_type_impl
 
-        unsafe impl wasmtime::component::Lower for #name {
+        unsafe impl #wt::component::Lower for #name {
             fn lower<T>(
                 &self,
                 cx: &mut #internal::LowerContext<'_, T>,
                 _ty: #internal::InterfaceType,
-                dst: &mut std::mem::MaybeUninit<Self::Lower>,
+                dst: &mut core::mem::MaybeUninit<Self::Lower>,
             ) -> #internal::anyhow::Result<()> {
                 #(
                     self.#field_names.lower(
@@ -1238,20 +1483,20 @@ pub fn expand_flags(flags: &Flags) -> Result<TokenStream> {
                 _ty: #internal::InterfaceType,
                 mut offset: usize
             ) -> #internal::anyhow::Result<()> {
-                debug_assert!(offset % (<Self as wasmtime::component::ComponentType>::ALIGN32 as usize) == 0);
+                debug_assert!(offset % (<Self as #wt::component::ComponentType>::ALIGN32 as usize) == 0);
                 #(
                     self.#field_names.store(
                         cx,
                         #field_interface_type,
                         offset,
                     )?;
-                    offset += std::mem::size_of_val(&self.#field_names);
+                    offset += core::mem::size_of_val(&self.#field_names);
                 )*
                 Ok(())
             }
         }
 
-        unsafe impl wasmtime::component::Lift for #name {
+        unsafe impl #wt::component::Lift for #name {
             fn lift(
                 cx: &mut #internal::LiftContext<'_>,
                 _ty: #internal::InterfaceType,
@@ -1259,7 +1504,7 @@ pub fn expand_flags(flags: &Flags) -> Result<TokenStream> {
             ) -> #internal::anyhow::Result<Self> {
                 Ok(Self {
                     #(
-                        #field_names: wasmtime::component::Lift::lift(
+                        #field_names: #wt::component::Lift::lift(
                             cx,
                             #field_interface_type,
                             &src.#field_names,
@@ -1275,12 +1520,12 @@ pub fn expand_flags(flags: &Flags) -> Result<TokenStream> {
             ) -> #internal::anyhow::Result<Self> {
                 debug_assert!(
                     (bytes.as_ptr() as usize)
-                        % (<Self as wasmtime::component::ComponentType>::ALIGN32 as usize)
+                        % (<Self as #wt::component::ComponentType>::ALIGN32 as usize)
                         == 0
                 );
                 #(
                     let (field, bytes) = bytes.split_at(#field_size);
-                    let #field_names = wasmtime::component::Lift::load(
+                    let #field_names = #wt::component::Lift::load(
                         cx,
                         #field_interface_type,
                         field,
diff --git a/crates/component-macro/test-helpers/Cargo.toml b/crates/component-macro/test-helpers/Cargo.toml
index 6a56a77dc0ab..03d2b1372b31 100644
--- a/crates/component-macro/test-helpers/Cargo.toml
+++ b/crates/component-macro/test-helpers/Cargo.toml
@@ -2,9 +2,13 @@
 name = "component-macro-test-helpers"
 version = "0.0.0"
 edition.workspace = true
+rust-version.workspace = true
 publish = false
 license = "Apache-2.0 WITH LLVM-exception"
 
+[lints]
+workspace = true
+
 [lib]
 proc-macro = true
 test = false
diff --git a/crates/component-macro/test-helpers/src/lib.rs b/crates/component-macro/test-helpers/src/lib.rs
index 28ea3ca4652f..9029b90bc686 100644
--- a/crates/component-macro/test-helpers/src/lib.rs
+++ b/crates/component-macro/test-helpers/src/lib.rs
@@ -10,7 +10,7 @@ pub fn foreach(input: TokenStream) -> TokenStream {
     let mut result = Vec::new();
     for f in cwd.read_dir().unwrap() {
         let f = f.unwrap().path();
-        if f.extension().and_then(|s| s.to_str()) == Some("wit") {
+        if f.extension().and_then(|s| s.to_str()) == Some("wit") || f.is_dir() {
             let name = f.file_stem().unwrap().to_str().unwrap();
             let ident = Ident::new(&name.replace("-", "_"), Span::call_site());
             let path = f.to_str().unwrap();
diff --git a/crates/component-macro/tests/codegen.rs b/crates/component-macro/tests/codegen.rs
index 90d58bd890f2..c7f40829b0be 100644
--- a/crates/component-macro/tests/codegen.rs
+++ b/crates/component-macro/tests/codegen.rs
@@ -1,3 +1,5 @@
+#![allow(dead_code)]
+
 macro_rules! gentest {
     ($id:ident $name:tt $path:tt) => {
         mod $id {
@@ -31,23 +33,23 @@ mod with_key_and_resources {
 
     wasmtime::component::bindgen!({
         inline: "
-            package demo:pkg
+            package demo:pkg;
 
             interface bar {
-                resource a
-                resource b
+                resource a;
+                resource b;
             }
 
             world foo {
-                resource a
-                resource b
+                resource a;
+                resource b;
 
                 import foo: interface {
-                    resource a
-                    resource b
+                    resource a;
+                    resource b;
                 }
 
-                import bar
+                import bar;
             }
         ",
         with: {
@@ -106,3 +108,591 @@ mod with_key_and_resources {
         }
     }
 }
+
+mod trappable_errors_with_versioned_and_unversioned_packages {
+    wasmtime::component::bindgen!({
+        inline: "
+            package foo:foo@0.1.0;
+
+            interface a {
+                variant error {
+                    other(string),
+                }
+
+                f: func() -> result<_, error>;
+            }
+
+            world foo {
+                import a;
+            }
+        ",
+        path: "tests/codegen/unversioned-foo.wit",
+        trappable_error_type: {
+            "foo:foo/a@0.1.0/error" => MyX,
+        },
+    });
+
+    #[allow(dead_code)]
+    type MyX = u64;
+}
+
+mod trappable_errors {
+    wasmtime::component::bindgen!({
+        inline: "
+            package demo:pkg;
+
+            interface a {
+                type b = u64;
+
+                z1: func() -> result<_, b>;
+                z2: func() -> result<_, b>;
+            }
+
+            interface b {
+                use a.{b};
+                z: func() -> result<_, b>;
+            }
+
+            interface c {
+                type b = u64;
+            }
+
+            interface d {
+                use c.{b};
+                z: func() -> result<_, b>;
+            }
+
+            world foo {
+                import a;
+                import b;
+                import d;
+            }
+        ",
+        trappable_error_type: {
+            "demo:pkg/a/b" => MyX,
+            "demo:pkg/c/b" => MyX,
+        },
+    });
+
+    #[allow(dead_code)]
+    type MyX = u32;
+}
+
+mod interface_name_with_rust_keyword {
+    wasmtime::component::bindgen!({
+        inline: "
+            package foo:foo;
+
+            interface crate { }
+
+            world foo {
+                export crate;
+            }
+        "
+    });
+}
+
+mod with_works_with_hierarchy {
+    mod bindings {
+        wasmtime::component::bindgen!({
+            inline: "
+                package foo:foo;
+
+                interface a {
+                    record t {
+                        x: u32,
+                    }
+                    x: func() -> t;
+                }
+
+                interface b {
+                    use a.{t};
+                    x: func() -> t;
+                }
+
+                interface c {
+                    use b.{t};
+                    x: func() -> t;
+                }
+
+                world foo {
+                    import c;
+                }
+            "
+        });
+    }
+
+    mod with_just_one_interface {
+        wasmtime::component::bindgen!({
+            inline: "
+                package foo:foo;
+
+                interface a {
+                    record t {
+                        x: u32,
+                    }
+                    x: func() -> t;
+                }
+
+                interface b {
+                    use a.{t};
+                    x: func() -> t;
+                }
+
+                interface c {
+                    use b.{t};
+                    x: func() -> t;
+                }
+
+                world foo {
+                    use c.{t};
+
+                    import x: func() -> t;
+                }
+            ",
+            with: { "foo:foo/a": super::bindings::foo::foo::a }
+        });
+
+        struct X;
+
+        impl FooImports for X {
+            fn x(&mut self) -> super::bindings::foo::foo::a::T {
+                loop {}
+            }
+        }
+    }
+
+    mod with_whole_package {
+        wasmtime::component::bindgen!({
+            inline: "
+                package foo:foo;
+
+                interface a {
+                    record t {
+                        x: u32,
+                    }
+                    x: func() -> t;
+                }
+
+                interface b {
+                    use a.{t};
+                    x: func() -> t;
+                }
+
+                interface c {
+                    use b.{t};
+                    x: func() -> t;
+                }
+
+                world foo {
+                    use c.{t};
+
+                    import x: func() -> t;
+                }
+            ",
+            with: { "foo:foo": super::bindings::foo::foo }
+        });
+
+        struct X;
+
+        impl FooImports for X {
+            fn x(&mut self) -> super::bindings::foo::foo::a::T {
+                loop {}
+            }
+        }
+    }
+
+    mod with_whole_namespace {
+        wasmtime::component::bindgen!({
+            inline: "
+                package foo:foo;
+
+                interface a {
+                    record t {
+                        x: u32,
+                    }
+                    x: func() -> t;
+                }
+
+                interface b {
+                    use a.{t};
+                    x: func() -> t;
+                }
+
+                interface c {
+                    use b.{t};
+                    x: func() -> t;
+                }
+
+                world foo {
+                    use c.{t};
+
+                    import x: func() -> t;
+                }
+            ",
+            with: { "foo": super::bindings::foo }
+        });
+
+        struct X;
+
+        impl FooImports for X {
+            fn x(&mut self) -> super::bindings::foo::foo::a::T {
+                loop {}
+            }
+        }
+    }
+}
+
+mod trappable_imports {
+    mod none {
+        wasmtime::component::bindgen!({
+            inline: "
+                package foo:foo;
+
+                world foo {
+                    import foo: func();
+                }
+            ",
+            trappable_imports: false,
+        });
+        struct X;
+
+        impl FooImports for X {
+            fn foo(&mut self) {}
+        }
+    }
+
+    mod all {
+        wasmtime::component::bindgen!({
+            inline: "
+                package foo:foo;
+
+                world foo {
+                    import foo: func();
+                }
+            ",
+            trappable_imports: true,
+        });
+        struct X;
+
+        impl FooImports for X {
+            fn foo(&mut self) -> wasmtime::Result<()> {
+                Ok(())
+            }
+        }
+    }
+
+    mod some {
+        wasmtime::component::bindgen!({
+            inline: "
+                package foo:foo;
+
+                world foo {
+                    import foo: func();
+                    import bar: func();
+                }
+            ",
+            trappable_imports: ["foo"],
+        });
+        struct X;
+
+        impl FooImports for X {
+            fn foo(&mut self) -> wasmtime::Result<()> {
+                Ok(())
+            }
+            fn bar(&mut self) {}
+        }
+    }
+
+    mod across_interfaces {
+        use wasmtime::component::Resource;
+
+        wasmtime::component::bindgen!({
+            inline: "
+                package foo:foo;
+
+                interface a {
+                    foo: func();
+                    bar: func();
+
+                    resource r {
+                        constructor();
+                        foo: func();
+                        bar: static func();
+                    }
+                }
+
+                world foo {
+                    import a;
+                    import foo: func();
+                    import bar: func();
+                    import i: interface {
+                        foo: func();
+                        bar: func();
+                    }
+
+                }
+            ",
+            trappable_imports: ["foo"],
+            with: { "foo:foo/a/r": R },
+        });
+
+        struct X;
+        pub struct R;
+
+        impl FooImports for X {
+            fn foo(&mut self) -> wasmtime::Result<()> {
+                Ok(())
+            }
+            fn bar(&mut self) {}
+        }
+
+        impl i::Host for X {
+            fn foo(&mut self) -> wasmtime::Result<()> {
+                Ok(())
+            }
+            fn bar(&mut self) {}
+        }
+
+        impl foo::foo::a::Host for X {
+            fn foo(&mut self) -> wasmtime::Result<()> {
+                Ok(())
+            }
+            fn bar(&mut self) {}
+        }
+
+        impl foo::foo::a::HostR for X {
+            fn new(&mut self) -> Resource<R> {
+                loop {}
+            }
+            fn foo(&mut self, _: Resource<R>) {}
+            fn bar(&mut self) {}
+            fn drop(&mut self, _: Resource<R>) -> wasmtime::Result<()> {
+                Ok(())
+            }
+        }
+    }
+
+    mod resources {
+        use wasmtime::component::Resource;
+
+        wasmtime::component::bindgen!({
+            inline: "
+                package foo:foo;
+
+                interface a {
+                    resource r {
+                        constructor();
+                        foo: func();
+                        bar: static func();
+                    }
+                }
+
+                world foo {
+                    import a;
+
+                }
+            ",
+            trappable_imports: [
+                "[constructor]r",
+                "[method]r.foo",
+                "[static]r.bar",
+            ],
+            with: { "foo:foo/a/r": R },
+        });
+
+        struct X;
+        pub struct R;
+
+        impl foo::foo::a::Host for X {}
+
+        impl foo::foo::a::HostR for X {
+            fn new(&mut self) -> wasmtime::Result<Resource<R>> {
+                loop {}
+            }
+            fn foo(&mut self, _: Resource<R>) -> wasmtime::Result<()> {
+                Ok(())
+            }
+            fn bar(&mut self) -> wasmtime::Result<()> {
+                Ok(())
+            }
+            fn drop(&mut self, _: Resource<R>) -> wasmtime::Result<()> {
+                Ok(())
+            }
+        }
+    }
+}
+
+mod custom_derives {
+    use std::collections::{hash_map::RandomState, HashSet};
+
+    wasmtime::component::bindgen!({
+        inline: "
+            package my:inline;
+
+            interface blah {
+                variant abc {
+                    a,
+                    b,
+                    c
+                }
+
+                record foo {
+                    field1: string,
+                    field2: list<u32>,
+                    field3: abc
+                }
+
+                bar: func(cool: foo);
+            }
+
+            world baz {
+                import blah;
+            }
+        ",
+        // Clone is included by default almost everywhere, so include it here to make sure it
+        // doesn't conflict
+        additional_derives: [serde::Serialize, serde::Deserialize, Hash, Clone, PartialEq, Eq],
+    });
+
+    use my::inline::blah::{Abc, Foo, Host};
+
+    struct X;
+
+    impl Host for X {
+        fn bar(&mut self, cool: Foo) {
+            // Check that built in derives that I've added actually work by seeing that this hashes
+            let _blah: HashSet<Foo, RandomState> = HashSet::from_iter([Foo {
+                field1: "hello".to_string(),
+                field2: vec![1, 2, 3],
+                field3: Abc::B,
+            }]);
+
+            // Check that the attributes from an external crate actually work. If they don't work,
+            // compilation will fail here
+            let _ = serde_json::to_string(&cool);
+        }
+    }
+}
+
+mod with_and_mixing_async {
+    mod with_async {
+        wasmtime::component::bindgen!({
+            inline: "
+                package my:inline;
+                interface foo {
+                    type t = u32;
+                    foo: func() -> t;
+                }
+                interface bar {
+                    use foo.{t};
+                    bar: func() -> t;
+                }
+                world x {
+                    import bar;
+                }
+            ",
+            async: {
+                only_imports: ["bar"],
+            },
+        });
+    }
+
+    mod without_async {
+        wasmtime::component::bindgen!({
+            inline: "
+                package my:inline;
+                interface foo {
+                    type t = u32;
+                    foo: func() -> t;
+                }
+                interface bar {
+                    use foo.{t};
+                    bar: func() -> t;
+                }
+                world x {
+                    import bar;
+                }
+            ",
+            with: {
+                "my:inline/foo": super::with_async::my::inline::foo,
+            },
+            require_store_data_send: true,
+        });
+    }
+
+    mod third {
+        wasmtime::component::bindgen!({
+            inline: "
+                package my:inline;
+                interface foo {
+                    type t = u32;
+                    foo: func() -> t;
+                }
+                interface bar {
+                    use foo.{t};
+                    bar: func() -> t;
+                }
+                interface baz {
+                    use bar.{t};
+                    baz: func() -> t;
+                }
+                world x {
+                    import baz;
+                }
+            ",
+            with: {
+                "my:inline/foo": super::with_async::my::inline::foo,
+                "my:inline/bar": super::without_async::my::inline::bar,
+            },
+            require_store_data_send: true,
+        });
+    }
+}
+
+mod trappable_error_type_and_versions {
+    struct MyError;
+
+    mod package_no_version_path_no_version {
+        wasmtime::component::bindgen!({
+            inline: "
+                package my:inline;
+                interface i {
+                    enum e { a, b, c }
+                }
+                world foo {}
+            ",
+            trappable_error_type: {
+                "my:inline/i/e" => super::MyError,
+            },
+        });
+    }
+    mod package_version_path_no_version {
+        wasmtime::component::bindgen!({
+            inline: "
+                package my:inline@1.0.0;
+                interface i {
+                    enum e { a, b, c }
+                }
+                world foo {}
+            ",
+            trappable_error_type: {
+                "my:inline/i/e" => super::MyError,
+            },
+        });
+    }
+    mod package_version_path_version {
+        wasmtime::component::bindgen!({
+            inline: "
+                package my:inline@1.0.0;
+                interface i {
+                    enum e { a, b, c }
+                }
+                world foo {}
+            ",
+            trappable_error_type: {
+                "my:inline/i@1.0.0/e" => super::MyError,
+            },
+        });
+    }
+}
diff --git a/crates/component-macro/tests/codegen/char.wit b/crates/component-macro/tests/codegen/char.wit
index b49947b38abb..165642279af0 100644
--- a/crates/component-macro/tests/codegen/char.wit
+++ b/crates/component-macro/tests/codegen/char.wit
@@ -1,13 +1,13 @@
-package foo:foo
+package foo:foo;
 
 interface chars {
   /// A function that accepts a character
-  take-char: func(x: char)
+  take-char: func(x: char);
   /// A function that returns a character
-  return-char: func() -> char
+  return-char: func() -> char;
 }
 
 world the-world {
-  import chars
-  export chars
+  import chars;
+  export chars;
 }
diff --git a/crates/component-macro/tests/codegen/conventions.wit b/crates/component-macro/tests/codegen/conventions.wit
index a96b5afd3444..507ef40b95b4 100644
--- a/crates/component-macro/tests/codegen/conventions.wit
+++ b/crates/component-macro/tests/codegen/conventions.wit
@@ -1,22 +1,22 @@
 // hello 🐱 world
-package foo:foo
+package foo:foo;
 
 interface conventions {
-  kebab-case: func()
+  kebab-case: func();
 
   record ludicrous-speed {
     how-fast-are-you-going: u32,
     i-am-going-extremely-slow: u64,
   }
 
-  foo: func(x: ludicrous-speed)
-  %function-with-dashes: func()
-  %function-with-no-weird-characters: func()
+  foo: func(x: ludicrous-speed);
+  %function-with-dashes: func();
+  %function-with-no-weird-characters: func();
 
-  apple: func()
-  apple-pear: func()
-  apple-pear-grape: func()
-  a0: func()
+  apple: func();
+  apple-pear: func();
+  apple-pear-grape: func();
+  a0: func();
 
   // Comment out identifiers that collide when mapped to snake_case, for now; see
   // https://github.com/WebAssembly/component-model/issues/118
@@ -24,16 +24,16 @@ interface conventions {
   //APPLE-pear-GRAPE: func()
   //apple-PEAR-grape: func()
 
-  is-XML: func()
+  is-XML: func();
 
-  %explicit: func()
-  %explicit-kebab: func()
+  %explicit: func();
+  %explicit-kebab: func();
 
   // Identifiers with the same name as keywords are quoted.
-  %bool: func()
+  %bool: func();
 }
 
 world the-world {
-  import conventions
-  export conventions
+  import conventions;
+  export conventions;
 }
diff --git a/crates/component-macro/tests/codegen/dead-code.wit b/crates/component-macro/tests/codegen/dead-code.wit
new file mode 100644
index 000000000000..1190c31a0337
--- /dev/null
+++ b/crates/component-macro/tests/codegen/dead-code.wit
@@ -0,0 +1,27 @@
+package a:b;
+
+world imports {
+  import interface-with-live-type;
+  import interface-with-dead-type;
+}
+
+interface interface-with-live-type {
+  record live-type {
+    a: u32,
+  }
+  f: func() -> live-type;
+}
+
+
+interface interface-with-dead-type {
+  use interface-with-live-type.{live-type};
+
+  record dead-type {
+    a: u32,
+  }
+
+  variant v {
+    a(live-type),
+    b(dead-type),
+  }
+}
diff --git a/crates/component-macro/tests/codegen/direct-import.wit b/crates/component-macro/tests/codegen/direct-import.wit
index 67d252a4a898..20d8fe753517 100644
--- a/crates/component-macro/tests/codegen/direct-import.wit
+++ b/crates/component-macro/tests/codegen/direct-import.wit
@@ -1,5 +1,5 @@
-package foo:foo
+package foo:foo;
 
 world foo {
-  import foo: func()
+  import foo: func();
 }
diff --git a/crates/component-macro/tests/codegen/empty.wit b/crates/component-macro/tests/codegen/empty.wit
index b720c27d628e..ea2e3c8d405e 100644
--- a/crates/component-macro/tests/codegen/empty.wit
+++ b/crates/component-macro/tests/codegen/empty.wit
@@ -1,2 +1,2 @@
-package foo:foo
+package foo:foo;
 world empty {}
diff --git a/crates/component-macro/tests/codegen/flags.wit b/crates/component-macro/tests/codegen/flags.wit
index 8c9c1437169d..296c47e65c62 100644
--- a/crates/component-macro/tests/codegen/flags.wit
+++ b/crates/component-macro/tests/codegen/flags.wit
@@ -1,4 +1,4 @@
-package foo:foo
+package foo:foo;
 
 interface flegs {
   flags flag1 {
@@ -40,16 +40,16 @@ interface flegs {
     b56, b57, b58, b59, b60, b61, b62, b63,
   }
 
-  roundtrip-flag1: func(x: flag1) -> flag1
-  roundtrip-flag2: func(x: flag2) -> flag2
-  roundtrip-flag4: func(x: flag4) -> flag4
-  roundtrip-flag8: func(x: flag8) -> flag8
-  roundtrip-flag16: func(x: flag16) -> flag16
-  roundtrip-flag32: func(x: flag32) -> flag32
-  roundtrip-flag64: func(x: flag64) -> flag64
+  roundtrip-flag1: func(x: flag1) -> flag1;
+  roundtrip-flag2: func(x: flag2) -> flag2;
+  roundtrip-flag4: func(x: flag4) -> flag4;
+  roundtrip-flag8: func(x: flag8) -> flag8;
+  roundtrip-flag16: func(x: flag16) -> flag16;
+  roundtrip-flag32: func(x: flag32) -> flag32;
+  roundtrip-flag64: func(x: flag64) -> flag64;
 }
 
 world the-flags {
-  import flegs
-  export flegs
+  import flegs;
+  export flegs;
 }
diff --git a/crates/component-macro/tests/codegen/floats.wit b/crates/component-macro/tests/codegen/floats.wit
index 6cd720a8dc39..690e920aa1b9 100644
--- a/crates/component-macro/tests/codegen/floats.wit
+++ b/crates/component-macro/tests/codegen/floats.wit
@@ -1,13 +1,13 @@
-package foo:foo
+package foo:foo;
 
 interface floats {
-  float32-param: func(x: float32)
-  float64-param: func(x: float64)
-  float32-result: func() -> float32
-  float64-result: func() -> float64
+  float32-param: func(x: float32);
+  float64-param: func(x: float64);
+  float32-result: func() -> float32;
+  float64-result: func() -> float64;
 }
 
 world the-world {
-  import floats
-  export floats
+  import floats;
+  export floats;
 }
diff --git a/crates/component-macro/tests/codegen/function-new.wit b/crates/component-macro/tests/codegen/function-new.wit
index 2f4e407566cd..cba7fe65d1d6 100644
--- a/crates/component-macro/tests/codegen/function-new.wit
+++ b/crates/component-macro/tests/codegen/function-new.wit
@@ -1,4 +1,4 @@
-package foo:foo
+package foo:foo;
 world foo {
-  export new: func()
+  export new: func();
 }
diff --git a/crates/component-macro/tests/codegen/integers.wit b/crates/component-macro/tests/codegen/integers.wit
index 2f5866bb2ae6..ad96a59d2c38 100644
--- a/crates/component-macro/tests/codegen/integers.wit
+++ b/crates/component-macro/tests/codegen/integers.wit
@@ -1,14 +1,14 @@
-package foo:foo
+package foo:foo;
 
 interface integers {
-  a1: func(x: u8)
-  a2: func(x: s8)
-  a3: func(x: u16)
-  a4: func(x: s16)
-  a5: func(x: u32)
-  a6: func(x: s32)
-  a7: func(x: u64)
-  a8: func(x: s64)
+  a1: func(x: u8);
+  a2: func(x: s8);
+  a3: func(x: u16);
+  a4: func(x: s16);
+  a5: func(x: u32);
+  a6: func(x: s32);
+  a7: func(x: u64);
+  a8: func(x: s64);
 
   a9: func(
     p1: u8,
@@ -19,22 +19,22 @@ interface integers {
     p6: s32,
     p7: u64,
     p8: s64,
-  )
+  );
 
 
-  r1: func() -> u8
-  r2: func() -> s8
-  r3: func() -> u16
-  r4: func() -> s16
-  r5: func() -> u32
-  r6: func() -> s32
-  r7: func() -> u64
-  r8: func() -> s64
+  r1: func() -> u8;
+  r2: func() -> s8;
+  r3: func() -> u16;
+  r4: func() -> s16;
+  r5: func() -> u32;
+  r6: func() -> s32;
+  r7: func() -> u64;
+  r8: func() -> s64;
 
-  pair-ret: func() -> tuple<s64, u8>
+  pair-ret: func() -> tuple<s64, u8>;
 }
 
 world the-world {
-  import integers
-  export integers
+  import integers;
+  export integers;
 }
diff --git a/crates/component-macro/tests/codegen/lists.wit b/crates/component-macro/tests/codegen/lists.wit
index 256a1cdf8fcf..a6d323fcb5c7 100644
--- a/crates/component-macro/tests/codegen/lists.wit
+++ b/crates/component-macro/tests/codegen/lists.wit
@@ -1,33 +1,33 @@
-package foo:foo
+package foo:foo;
 
 interface lists {
-  list-u8-param: func(x: list<u8>)
-  list-u16-param: func(x: list<u16>)
-  list-u32-param: func(x: list<u32>)
-  list-u64-param: func(x: list<u64>)
-  list-s8-param: func(x: list<s8>)
-  list-s16-param: func(x: list<s16>)
-  list-s32-param: func(x: list<s32>)
-  list-s64-param: func(x: list<s64>)
-  list-float32-param: func(x: list<float32>)
-  list-float64-param: func(x: list<float64>)
+  list-u8-param: func(x: list<u8>);
+  list-u16-param: func(x: list<u16>);
+  list-u32-param: func(x: list<u32>);
+  list-u64-param: func(x: list<u64>);
+  list-s8-param: func(x: list<s8>);
+  list-s16-param: func(x: list<s16>);
+  list-s32-param: func(x: list<s32>);
+  list-s64-param: func(x: list<s64>);
+  list-float32-param: func(x: list<float32>);
+  list-float64-param: func(x: list<float64>);
 
-  list-u8-ret: func() -> list<u8>
-  list-u16-ret: func() -> list<u16>
-  list-u32-ret: func() -> list<u32>
-  list-u64-ret: func() -> list<u64>
-  list-s8-ret: func() -> list<s8>
-  list-s16-ret: func() -> list<s16>
-  list-s32-ret: func() -> list<s32>
-  list-s64-ret: func() -> list<s64>
-  list-float32-ret: func() -> list<float32>
-  list-float64-ret: func() -> list<float64>
+  list-u8-ret: func() -> list<u8>;
+  list-u16-ret: func() -> list<u16>;
+  list-u32-ret: func() -> list<u32>;
+  list-u64-ret: func() -> list<u64>;
+  list-s8-ret: func() -> list<s8>;
+  list-s16-ret: func() -> list<s16>;
+  list-s32-ret: func() -> list<s32>;
+  list-s64-ret: func() -> list<s64>;
+  list-float32-ret: func() -> list<float32>;
+  list-float64-ret: func() -> list<float64>;
 
-  tuple-list: func(x: list<tuple<u8, s8>>) -> list<tuple<s64, u32>>
-  string-list-arg: func(a: list<string>)
-  string-list-ret: func() -> list<string>
-  tuple-string-list: func(x: list<tuple<u8, string>>) -> list<tuple<string, u8>>
-  string-list: func(x: list<string>) -> list<string>
+  tuple-list: func(x: list<tuple<u8, s8>>) -> list<tuple<s64, u32>>;
+  string-list-arg: func(a: list<string>);
+  string-list-ret: func() -> list<string>;
+  tuple-string-list: func(x: list<tuple<u8, string>>) -> list<tuple<string, u8>>;
+  string-list: func(x: list<string>) -> list<string>;
 
   record some-record {
     x: string,
@@ -46,8 +46,8 @@ interface lists {
     b: string,
     c: list<u8>,
   }
-  record-list: func(x: list<some-record>) -> list<other-record>
-  record-list-reverse: func(x: list<other-record>) -> list<some-record>
+  record-list: func(x: list<some-record>) -> list<other-record>;
+  record-list-reverse: func(x: list<other-record>) -> list<some-record>;
 
   variant some-variant {
     a(string),
@@ -60,7 +60,7 @@ interface lists {
     b(u32),
     c(string),
   }
-  variant-list: func(x: list<some-variant>) -> list<other-variant>
+  variant-list: func(x: list<some-variant>) -> list<other-variant>;
 
   type load-store-all-sizes = list<tuple<
     string,
@@ -75,11 +75,11 @@ interface lists {
     float32,
     float64,
     char,
-  >>
-  load-store-everything: func(a: load-store-all-sizes) -> load-store-all-sizes
+  >>;
+  load-store-everything: func(a: load-store-all-sizes) -> load-store-all-sizes;
 }
 
 world the-lists {
-  import lists
-  export lists
+  import lists;
+  export lists;
 }
diff --git a/crates/component-macro/tests/codegen/many-arguments.wit b/crates/component-macro/tests/codegen/many-arguments.wit
index cbfc123144fa..234b74b2022e 100644
--- a/crates/component-macro/tests/codegen/many-arguments.wit
+++ b/crates/component-macro/tests/codegen/many-arguments.wit
@@ -1,4 +1,4 @@
-package foo:foo
+package foo:foo;
 
 interface manyarg {
   many-args: func(
@@ -18,7 +18,7 @@ interface manyarg {
     a14: u64,
     a15: u64,
     a16: u64,
-  )
+  );
 
   record big-struct {
     a1: string,
@@ -43,10 +43,10 @@ interface manyarg {
     a20: string,
   }
 
-  big-argument: func(x: big-struct)
+  big-argument: func(x: big-struct);
 }
 
 world the-world {
-  import manyarg
-  export manyarg
+  import manyarg;
+  export manyarg;
 }
diff --git a/crates/component-macro/tests/codegen/multi-return.wit b/crates/component-macro/tests/codegen/multi-return.wit
index 69951b2c3393..3076ccf758c9 100644
--- a/crates/component-macro/tests/codegen/multi-return.wit
+++ b/crates/component-macro/tests/codegen/multi-return.wit
@@ -1,14 +1,14 @@
-package foo:foo
+package foo:foo;
 
 interface multi-return {
-  mra: func()
-  mrb: func() -> ()
-  mrc: func() -> u32
-  mrd: func() -> (a: u32)
-  mre: func() -> (a: u32, b: float32)
+  mra: func();
+  mrb: func() -> ();
+  mrc: func() -> u32;
+  mrd: func() -> (a: u32);
+  mre: func() -> (a: u32, b: float32);
 }
 
 world the-world {
-  import multi-return
-  export multi-return
+  import multi-return;
+  export multi-return;
 }
diff --git a/crates/component-macro/tests/codegen/multiversion/deps/v1/root.wit b/crates/component-macro/tests/codegen/multiversion/deps/v1/root.wit
new file mode 100644
index 000000000000..cdda0a38b4ba
--- /dev/null
+++ b/crates/component-macro/tests/codegen/multiversion/deps/v1/root.wit
@@ -0,0 +1,5 @@
+package my:dep@0.1.0;
+
+interface a {
+  x: func();
+}
diff --git a/crates/component-macro/tests/codegen/multiversion/deps/v2/root.wit b/crates/component-macro/tests/codegen/multiversion/deps/v2/root.wit
new file mode 100644
index 000000000000..fa8fbeb2df6b
--- /dev/null
+++ b/crates/component-macro/tests/codegen/multiversion/deps/v2/root.wit
@@ -0,0 +1,5 @@
+package my:dep@0.2.0;
+
+interface a {
+  x: func();
+}
diff --git a/crates/component-macro/tests/codegen/multiversion/root.wit b/crates/component-macro/tests/codegen/multiversion/root.wit
new file mode 100644
index 000000000000..b3bb3c80d3da
--- /dev/null
+++ b/crates/component-macro/tests/codegen/multiversion/root.wit
@@ -0,0 +1,8 @@
+package foo:bar;
+
+world foo {
+  import my:dep/a@0.1.0;
+  import my:dep/a@0.2.0;
+  export my:dep/a@0.1.0;
+  export my:dep/a@0.2.0;
+}
diff --git a/crates/component-macro/tests/codegen/records.wit b/crates/component-macro/tests/codegen/records.wit
index f51bb8f28f75..e47af0cbf61e 100644
--- a/crates/component-macro/tests/codegen/records.wit
+++ b/crates/component-macro/tests/codegen/records.wit
@@ -1,13 +1,13 @@
-package foo:foo
+package foo:foo;
 
 interface records {
-  tuple-arg: func(x: tuple<char, u32>)
-  tuple-result: func() -> tuple<char, u32>
+  tuple-arg: func(x: tuple<char, u32>);
+  tuple-result: func() -> tuple<char, u32>;
 
   record empty {}
 
-  empty-arg: func(x: empty)
-  empty-result: func() -> empty
+  empty-arg: func(x: empty);
+  empty-result: func() -> empty;
 
   /// A record containing two scalar fields
   /// that both have the same type
@@ -18,8 +18,8 @@ interface records {
       b: u32,
   }
 
-  scalar-arg: func(x: scalars)
-  scalar-result: func() -> scalars
+  scalar-arg: func(x: scalars);
+  scalar-result: func() -> scalars;
 
   /// A record that is really just flags
   /// All of the fields are bool
@@ -35,8 +35,8 @@ interface records {
       i: bool,
   }
 
-  flags-arg: func(x: really-flags)
-  flags-result: func() -> really-flags
+  flags-arg: func(x: really-flags);
+  flags-result: func() -> really-flags;
 
   record aggregates {
       a: scalars,
@@ -46,16 +46,16 @@ interface records {
       e: really-flags,
   }
 
-  aggregate-arg: func(x: aggregates)
-  aggregate-result: func() -> aggregates
+  aggregate-arg: func(x: aggregates);
+  aggregate-result: func() -> aggregates;
 
-  type tuple-typedef = tuple<s32>
-  type int-typedef = s32
-  type tuple-typedef2 = tuple<int-typedef>
-  typedef-inout: func(e: tuple-typedef2) -> s32
+  type tuple-typedef = tuple<s32>;
+  type int-typedef = s32;
+  type tuple-typedef2 = tuple<int-typedef>;
+  typedef-inout: func(e: tuple-typedef2) -> s32;
 }
 
 world the-world {
-  import records
-  export records
+  import records;
+  export records;
 }
diff --git a/crates/component-macro/tests/codegen/rename.wit b/crates/component-macro/tests/codegen/rename.wit
index 8bfc7f36862b..0b6dfee5a7ca 100644
--- a/crates/component-macro/tests/codegen/rename.wit
+++ b/crates/component-macro/tests/codegen/rename.wit
@@ -1,16 +1,16 @@
-package foo:foo
+package foo:foo;
 
 interface red {
-  use green.{thing}
+  use green.{thing};
 
-  foo: func() -> thing
+  foo: func() -> thing;
 }
 
 interface green {
-  type thing = s32
+  type thing = s32;
 }
 
 world neptune {
-  import red
-  import green
+  import red;
+  import green;
 }
diff --git a/crates/component-macro/tests/codegen/resources-export.wit b/crates/component-macro/tests/codegen/resources-export.wit
index f0e943671c16..da0027991c79 100644
--- a/crates/component-macro/tests/codegen/resources-export.wit
+++ b/crates/component-macro/tests/codegen/resources-export.wit
@@ -1,43 +1,43 @@
-package foo:foo
+package foo:foo;
 
 world w {
-  export simple-export
-  export export-using-import
+  export simple-export;
+  export export-using-import;
 
-  export export-using-export1
-  export export-using-export2
+  export export-using-export1;
+  export export-using-export2;
 }
 
 interface simple-export {
   resource a {
-    constructor()
-    static-a: static func() -> u32
-    method-a: func() -> u32
+    constructor();
+    static-a: static func() -> u32;
+    method-a: func() -> u32;
   }
 }
 
 interface export-using-import {
-  use transitive-import.{y}
+  use transitive-import.{y};
   resource a {
-    constructor(y: y)
-    static-a: static func() -> y
-    method-a: func(y: y) -> y
+    constructor(y: y);
+    static-a: static func() -> y;
+    method-a: func(y: y) -> y;
   }
 }
 
 interface transitive-import {
-  resource y
+  resource y;
 }
 
 interface export-using-export1 {
   resource a {
-    constructor()
+    constructor();
   }
 }
 
 interface export-using-export2 {
-  use export-using-export1.{a}
+  use export-using-export1.{a};
   resource b {
-    constructor(a: a)
+    constructor(a: a);
   }
 }
diff --git a/crates/component-macro/tests/codegen/resources-import.wit b/crates/component-macro/tests/codegen/resources-import.wit
index bfe0c40deed3..d45916436b4f 100644
--- a/crates/component-macro/tests/codegen/resources-import.wit
+++ b/crates/component-macro/tests/codegen/resources-import.wit
@@ -1,31 +1,31 @@
-package foo:foo
+package foo:foo;
 
 interface resources {
   resource bar {
-    constructor()
-    static-a: static func() -> u32
-    method-a: func() -> u32
+    constructor();
+    static-a: static func() -> u32;
+    method-a: func() -> u32;
   }
 
-  bar-own-arg: func(x: own<bar>)
-  bar-borrow-arg: func(x: borrow<bar>)
-  bar-result: func() -> own<bar>
+  bar-own-arg: func(x: own<bar>);
+  bar-borrow-arg: func(x: borrow<bar>);
+  bar-result: func() -> own<bar>;
 
-  tuple-own-arg: func(x: tuple<own<bar>, u32>)
-  tuple-borrow-arg: func(x: tuple<own<bar>, u32>)
-  tuple-result: func() -> tuple<own<bar>, u32>
+  tuple-own-arg: func(x: tuple<own<bar>, u32>);
+  tuple-borrow-arg: func(x: tuple<own<bar>, u32>);
+  tuple-result: func() -> tuple<own<bar>, u32>;
 
-  option-own-arg: func(x: option<own<bar>>)
-  option-borrow-arg: func(x: option<borrow<bar>>)
-  option-result: func() -> option<own<bar>>
+  option-own-arg: func(x: option<own<bar>>);
+  option-borrow-arg: func(x: option<borrow<bar>>);
+  option-result: func() -> option<own<bar>>;
 
-  result-own-arg: func(x: result<own<bar>>)
-  result-borrow-arg: func(x: result<borrow<bar>>)
-  result-result: func() -> result<own<bar>>
+  result-own-arg: func(x: result<own<bar>>);
+  result-borrow-arg: func(x: result<borrow<bar>>);
+  result-result: func() -> result<own<bar>>;
 
-  list-own-arg: func(x: list<own<bar>>)
-  list-borrow-arg: func(x: list<borrow<bar>>)
-  list-result: func() -> list<own<bar>>
+  list-own-arg: func(x: list<own<bar>>);
+  list-borrow-arg: func(x: list<borrow<bar>>);
+  list-result: func() -> list<own<bar>>;
 
   record nested-own {
     nested-bar: own<bar>
@@ -35,53 +35,53 @@ interface resources {
     nested-bar: borrow<bar>
   }
 
-  record-own-arg: func(x: nested-own)
-  record-borrow-arg: func(x: nested-borrow)
-  record-result: func() -> nested-own
+  record-own-arg: func(x: nested-own);
+  record-borrow-arg: func(x: nested-borrow);
+  record-result: func() -> nested-own;
 
-  type some-handle = borrow<bar>
-  func-with-handle-typedef: func(x: some-handle)
+  type some-handle = borrow<bar>;
+  func-with-handle-typedef: func(x: some-handle);
 }
 
 world the-world {
-  import resources
+  import resources;
 
   resource world-resource {
-    constructor()
+    constructor();
 
-    foo: func()
-    static-foo: static func()
+    foo: func();
+    static-foo: static func();
   }
 
-  import some-world-func: func() -> world-resource
-  export some-world-func2: func() -> world-resource
+  import some-world-func: func() -> world-resource;
+  export some-world-func2: func() -> world-resource;
 
-  export uses-resource-transitively
+  export uses-resource-transitively;
 
-  import long-use-chain4
+  import long-use-chain4;
 }
 
 interface transitive-interface-with-resource {
-  resource foo
+  resource foo;
 }
 
 interface uses-resource-transitively {
-  use transitive-interface-with-resource.{foo}
+  use transitive-interface-with-resource.{foo};
 
-  handle: func(x: foo)
+  handle: func(x: foo);
 }
 
 interface long-use-chain4 {
-  use long-use-chain3.{a}
+  use long-use-chain3.{a};
 
-  foo: func() -> a
+  foo: func() -> a;
 }
 interface long-use-chain3 {
-  use long-use-chain2.{a}
+  use long-use-chain2.{a};
 }
 interface long-use-chain2 {
-  use long-use-chain1.{a}
+  use long-use-chain1.{a};
 }
 interface long-use-chain1 {
-  resource a
+  resource a;
 }
diff --git a/crates/component-macro/tests/codegen/share-types.wit b/crates/component-macro/tests/codegen/share-types.wit
index 8d36d1b0aa88..85d2c03712f2 100644
--- a/crates/component-macro/tests/codegen/share-types.wit
+++ b/crates/component-macro/tests/codegen/share-types.wit
@@ -1,4 +1,4 @@
-package foo:foo
+package foo:foo;
 
 interface http-types{
   record request {
@@ -11,11 +11,11 @@ interface http-types{
 
 world http-interface {
   export http-handler: interface {
-    use http-types.{request,response}
-    handle-request: func(request: request) -> response
+    use http-types.{request,response};
+    handle-request: func(request: request) -> response;
   }
   import http-fetch: interface {
-    use http-types.{request,response}
-    fetch-request: func(request: request) -> response
+    use http-types.{request,response};
+    fetch-request: func(request: request) -> response;
   }
 }
diff --git a/crates/component-macro/tests/codegen/simple-functions.wit b/crates/component-macro/tests/codegen/simple-functions.wit
index 2593d199e565..199fc522fb2d 100644
--- a/crates/component-macro/tests/codegen/simple-functions.wit
+++ b/crates/component-macro/tests/codegen/simple-functions.wit
@@ -1,17 +1,17 @@
-package foo:foo
+package foo:foo;
 
 interface simple {
-  f1: func()
-  f2: func(a: u32)
-  f3: func(a: u32, b: u32)
+  f1: func();
+  f2: func(a: u32);
+  f3: func(a: u32, b: u32);
 
-  f4: func() -> u32
-  f5: func() -> tuple<u32, u32>
+  f4: func() -> u32;
+  f5: func() -> tuple<u32, u32>;
 
-  f6: func(a: u32, b: u32, c: u32) -> tuple<u32, u32, u32>
+  f6: func(a: u32, b: u32, c: u32) -> tuple<u32, u32, u32>;
 }
 
 world the-world {
-  import simple
-  export simple
+  import simple;
+  export simple;
 }
diff --git a/crates/component-macro/tests/codegen/simple-lists.wit b/crates/component-macro/tests/codegen/simple-lists.wit
index 8e082b6e34e7..f814cee85ad2 100644
--- a/crates/component-macro/tests/codegen/simple-lists.wit
+++ b/crates/component-macro/tests/codegen/simple-lists.wit
@@ -1,13 +1,13 @@
-package foo:foo
+package foo:foo;
 
 interface simple-lists {
-  simple-list1: func(l: list<u32>)
-  simple-list2: func() -> list<u32>
-  simple-list3: func(a: list<u32>, b: list<u32>) -> tuple<list<u32>, list<u32>>
-  simple-list4: func(l: list<list<u32>>) -> list<list<u32>>
+  simple-list1: func(l: list<u32>);
+  simple-list2: func() -> list<u32>;
+  simple-list3: func(a: list<u32>, b: list<u32>) -> tuple<list<u32>, list<u32>>;
+  simple-list4: func(l: list<list<u32>>) -> list<list<u32>>;
 }
 
 world my-world {
-  import simple-lists
-  export simple-lists
+  import simple-lists;
+  export simple-lists;
 }
diff --git a/crates/component-macro/tests/codegen/simple-wasi.wit b/crates/component-macro/tests/codegen/simple-wasi.wit
index 60192473d99e..2ab07d32d837 100644
--- a/crates/component-macro/tests/codegen/simple-wasi.wit
+++ b/crates/component-macro/tests/codegen/simple-wasi.wit
@@ -1,4 +1,4 @@
-package foo:foo
+package foo:foo;
 
 interface wasi-filesystem {
   record descriptor-stat {
@@ -7,9 +7,9 @@ interface wasi-filesystem {
   enum errno { e }
 
 
-  create-directory-at: func() -> result<_, errno>
+  create-directory-at: func() -> result<_, errno>;
 
-  stat: func() -> result<descriptor-stat, errno>
+  stat: func() -> result<descriptor-stat, errno>;
 }
 
 interface wall-clock {
@@ -18,6 +18,6 @@ interface wall-clock {
 }
 
 world wasi {
-  import wasi-filesystem
-  import wall-clock
+  import wasi-filesystem;
+  import wall-clock;
 }
diff --git a/crates/component-macro/tests/codegen/small-anonymous.wit b/crates/component-macro/tests/codegen/small-anonymous.wit
index ad9c67287d4e..3a314fbfe4e9 100644
--- a/crates/component-macro/tests/codegen/small-anonymous.wit
+++ b/crates/component-macro/tests/codegen/small-anonymous.wit
@@ -1,4 +1,4 @@
-package foo:foo
+package foo:foo;
 
 interface anon {
   enum error {
@@ -6,10 +6,10 @@ interface anon {
     failure,
   }
 
-  option-test: func() -> result<option<string>, error>
+  option-test: func() -> result<option<string>, error>;
 }
 
 world the-world {
-  import anon
-  export anon
+  import anon;
+  export anon;
 }
diff --git a/crates/component-macro/tests/codegen/smoke-default.wit b/crates/component-macro/tests/codegen/smoke-default.wit
index 90be0b1e3cdc..6206a7c8e131 100644
--- a/crates/component-macro/tests/codegen/smoke-default.wit
+++ b/crates/component-macro/tests/codegen/smoke-default.wit
@@ -1,5 +1,5 @@
-package foo:foo
+package foo:foo;
 
 world the-world {
-  export y: func()
+  export y: func();
 }
diff --git a/crates/component-macro/tests/codegen/smoke-export.wit b/crates/component-macro/tests/codegen/smoke-export.wit
index 983f1c35066e..a8b7b15e70e6 100644
--- a/crates/component-macro/tests/codegen/smoke-export.wit
+++ b/crates/component-macro/tests/codegen/smoke-export.wit
@@ -1,7 +1,7 @@
-package foo:foo
+package foo:foo;
 
 world the-world {
   export the-name: interface {
-    y: func()
+    y: func();
   }
 }
diff --git a/crates/component-macro/tests/codegen/smoke.wit b/crates/component-macro/tests/codegen/smoke.wit
index 0476bd988ec1..14502341f7ca 100644
--- a/crates/component-macro/tests/codegen/smoke.wit
+++ b/crates/component-macro/tests/codegen/smoke.wit
@@ -1,7 +1,7 @@
-package foo:foo
+package foo:foo;
 
 world the-world {
   import imports: interface {
-    y: func()
+    y: func();
   }
 }
diff --git a/crates/component-macro/tests/codegen/strings.wit b/crates/component-macro/tests/codegen/strings.wit
index 650300acfb9d..6d45a9845bce 100644
--- a/crates/component-macro/tests/codegen/strings.wit
+++ b/crates/component-macro/tests/codegen/strings.wit
@@ -1,12 +1,12 @@
-package foo:foo
+package foo:foo;
 
 interface strings {
-  a: func(x: string)
-  b: func() -> string
-  c: func(a: string, b: string) -> string
+  a: func(x: string);
+  b: func() -> string;
+  c: func(a: string, b: string) -> string;
 }
 
 world the-world {
-  import strings
-  export strings
+  import strings;
+  export strings;
 }
diff --git a/crates/component-macro/tests/codegen/unversioned-foo.wit b/crates/component-macro/tests/codegen/unversioned-foo.wit
new file mode 100644
index 000000000000..a7b3bb616c0c
--- /dev/null
+++ b/crates/component-macro/tests/codegen/unversioned-foo.wit
@@ -0,0 +1,12 @@
+package foo:foo;
+
+interface a {
+    variant error {
+        other(string),
+    }
+    g: func() -> result<_, error>;
+}
+
+world nope {
+    import a;
+}
\ No newline at end of file
diff --git a/crates/component-macro/tests/codegen/use-paths.wit b/crates/component-macro/tests/codegen/use-paths.wit
index dab6646afac8..3a16b375d34c 100644
--- a/crates/component-macro/tests/codegen/use-paths.wit
+++ b/crates/component-macro/tests/codegen/use-paths.wit
@@ -1,29 +1,29 @@
-package foo:foo
+package foo:foo;
 
 interface a {
   record foo {}
 
-  a: func() -> foo
+  a: func() -> foo;
 }
 
 interface b {
-  use a.{foo}
+  use a.{foo};
 
-  a: func() -> foo
+  a: func() -> foo;
 }
 
 interface c {
-  use b.{foo}
+  use b.{foo};
 
-  a: func() -> foo
+  a: func() -> foo;
 }
 
 world d {
-  import a
-  import b
+  import a;
+  import b;
   import d: interface {
-    use c.{foo}
+    use c.{foo};
 
-    b: func() -> foo
+    b: func() -> foo;
   }
 }
diff --git a/crates/component-macro/tests/codegen/variants.wit b/crates/component-macro/tests/codegen/variants.wit
index a53938cb02ef..8ba28d40ebdf 100644
--- a/crates/component-macro/tests/codegen/variants.wit
+++ b/crates/component-macro/tests/codegen/variants.wit
@@ -1,12 +1,12 @@
-package foo:foo
+package foo:foo;
 
 interface variants {
   enum e1 {
       a,
   }
 
-  e1-arg: func(x: e1)
-  e1-result: func() -> e1
+  e1-arg: func(x: e1);
+  e1-result: func() -> e1;
 
   record empty {}
 
@@ -19,11 +19,11 @@ interface variants {
       g(u32),
   }
 
-  v1-arg: func(x: v1)
-  v1-result: func() -> v1
+  v1-arg: func(x: v1);
+  v1-result: func() -> v1;
 
-  bool-arg: func(x: bool)
-  bool-result: func() -> bool
+  bool-arg: func(x: bool);
+  bool-result: func() -> bool;
 
   option-arg: func(
     a: option<bool>,
@@ -32,7 +32,7 @@ interface variants {
     d: option<e1>,
     e: option<float32>,
     g: option<option<bool>>,
-  )
+  );
   option-result: func() -> tuple<
     option<bool>,
     option<tuple<>>,
@@ -40,7 +40,7 @@ interface variants {
     option<e1>,
     option<float32>,
     option<option<bool>>,
-  >
+  >;
 
   variant casts1 {
     a(s32),
@@ -86,7 +86,7 @@ interface variants {
     casts4,
     casts5,
     casts6,
-  >
+  >;
 
   result-arg: func(
     a: result,
@@ -95,7 +95,7 @@ interface variants {
     d: result<tuple<>, tuple<>>,
     e: result<u32, v1>,
     f: result<string, list<u8>>,
-  )
+  );
   result-result: func() -> tuple<
     result,
     result<_, e1>,
@@ -103,34 +103,34 @@ interface variants {
     result<tuple<>, tuple<>>,
     result<u32, v1>,
     result<string, list<u8>>,
-  >
+  >;
 
   enum my-errno {
     bad1,
     bad2,
   }
 
-  return-result-sugar: func() -> result<s32, my-errno>
-  return-result-sugar2: func() -> result<_, my-errno>
-  return-result-sugar3: func() -> result<my-errno, my-errno>
-  return-result-sugar4: func() -> result<tuple<s32, u32>, my-errno>
-  return-option-sugar: func() -> option<s32>
-  return-option-sugar2: func() -> option<my-errno>
+  return-result-sugar: func() -> result<s32, my-errno>;
+  return-result-sugar2: func() -> result<_, my-errno>;
+  return-result-sugar3: func() -> result<my-errno, my-errno>;
+  return-result-sugar4: func() -> result<tuple<s32, u32>, my-errno>;
+  return-option-sugar: func() -> option<s32>;
+  return-option-sugar2: func() -> option<my-errno>;
 
-  result-simple: func() -> result<u32, s32>
+  result-simple: func() -> result<u32, s32>;
 
   record is-clone {
     v1: v1,
   }
 
-  is-clone-arg: func(a: is-clone)
-  is-clone-return: func() -> is-clone
+  is-clone-arg: func(a: is-clone);
+  is-clone-return: func() -> is-clone;
 
-  return-named-option: func() -> (a: option<u8>)
-  return-named-result: func() -> (a: result<u8, my-errno>)
+  return-named-option: func() -> (a: option<u8>);
+  return-named-result: func() -> (a: result<u8, my-errno>);
 }
 
 world my-world {
-  import variants
-  export variants
+  import variants;
+  export variants;
 }
diff --git a/crates/component-macro/tests/codegen/wat.wit b/crates/component-macro/tests/codegen/wat.wit
new file mode 100644
index 000000000000..cba93e0d4fd8
--- /dev/null
+++ b/crates/component-macro/tests/codegen/wat.wit
@@ -0,0 +1,10 @@
+package same:name;
+
+interface this-name-is-duplicated {
+  resource this-name-is-duplicated {
+  }
+}
+
+world example {
+  export this-name-is-duplicated;
+}
diff --git a/crates/component-macro/tests/codegen/worlds-with-types.wit b/crates/component-macro/tests/codegen/worlds-with-types.wit
index dc4cbddcbabe..149e392dfc7a 100644
--- a/crates/component-macro/tests/codegen/worlds-with-types.wit
+++ b/crates/component-macro/tests/codegen/worlds-with-types.wit
@@ -1,16 +1,16 @@
-package foo:foo
+package foo:foo;
 
 interface i {
-  type t = u16
+  type t = u16;
 }
 
 world foo {
-  use i.{t as u}
+  use i.{t as u};
 
-  type t = u32
+  type t = u32;
 
   record r {
   }
 
-  export f: func() -> tuple<t, u, r>
+  export f: func() -> tuple<t, u, r>;
 }
diff --git a/crates/component-macro/tests/codegen_no_std.rs b/crates/component-macro/tests/codegen_no_std.rs
new file mode 100644
index 000000000000..ecd8b82814f8
--- /dev/null
+++ b/crates/component-macro/tests/codegen_no_std.rs
@@ -0,0 +1,16 @@
+// The output of `bindgen!` should be compatible with `no_std` by default, so
+// test that here with a no_std crate.
+
+#![no_std]
+
+extern crate std;
+
+macro_rules! gentest {
+    ($id:ident $name:tt $path:tt) => {
+        mod $id {
+            wasmtime::component::bindgen!(in $path);
+        }
+    };
+}
+
+component_macro_test_helpers::foreach!(gentest);
diff --git a/crates/component-macro/tests/expanded.rs b/crates/component-macro/tests/expanded.rs
new file mode 100644
index 000000000000..89da10fbb21b
--- /dev/null
+++ b/crates/component-macro/tests/expanded.rs
@@ -0,0 +1,65 @@
+use std::path::Path;
+
+use anyhow::{bail, Context, Result};
+
+macro_rules! genexpand {
+    ($id:ident $name:tt $path:tt) => {
+        process_expanded($path, "", wasmtime::component::bindgen!({
+            path: $path,
+            stringify: true,
+        }))?;
+
+        process_expanded($path, "_async", wasmtime::component::bindgen!({
+            path: $path,
+            async: true,
+            stringify: true,
+        }))?;
+    };
+}
+
+fn process_expanded(path: &str, suffix: &str, src: &str) -> Result<()> {
+    let formatted_src = {
+        let syn_file = syn::parse_file(src).unwrap();
+        prettyplease::unparse(&syn_file)
+    };
+    let expanded_path = {
+        let mut stem = Path::new(path).file_stem().unwrap().to_os_string();
+        stem.push(suffix);
+        Path::new("tests/expanded").join(stem).with_extension("rs")
+    };
+    if std::env::var("BINDGEN_TEST_BLESS").is_ok_and(|val| !val.is_empty()) {
+        std::fs::write(expanded_path, formatted_src)?;
+    } else {
+        match std::fs::read_to_string(&expanded_path) {
+            Ok(expected) if formatted_src == expected => (),
+            Ok(expected) => {
+                bail!(
+                    "checked-in expanded bindings from {expanded_path:?} \
+                    do not match those generated from {path:?}
+                    \n\
+                    {diff}\n\
+                    \n\
+                    This test assertion can be automatically updated by setting the\n\
+                    BINDGEN_TEST_BLESS=1 environment variable when running this test.",
+                    diff = similar::TextDiff::from_lines(&expected, &formatted_src)
+                        .unified_diff()
+                        .header("expected", "actual")
+                )
+            }
+            Err(err) => {
+                return Err(err).with_context(|| {
+                    format!(
+                    "failed to read {expanded_path:?}; re-run with BINDGEN_TEST_BLESS=1 to create"
+                )
+                })
+            }
+        }
+    }
+    Ok(())
+}
+
+#[test]
+fn expand_wits() -> Result<()> {
+    component_macro_test_helpers::foreach!(genexpand);
+    Ok(())
+}
diff --git a/crates/component-macro/tests/expanded/char.rs b/crates/component-macro/tests/expanded/char.rs
new file mode 100644
index 000000000000..c8e1b9436487
--- /dev/null
+++ b/crates/component-macro/tests/expanded/char.rs
@@ -0,0 +1,387 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-world`.
+///
+/// This structure is created through [`TheWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheWorld`] as well.
+pub struct TheWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheWorldIndices,
+}
+impl<T> Clone for TheWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheWorldPre<_T> {
+    /// Creates a new copy of `TheWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheWorld> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-world`.
+///
+/// This is an implementation detail of [`TheWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheWorld`] as well.
+#[derive(Clone)]
+pub struct TheWorldIndices {
+    interface0: exports::foo::foo::chars::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheWorld::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheWorldPre::instantiate`] to
+///   create a [`TheWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheWorldIndices::new_instance`] followed
+///   by [`TheWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheWorld {
+    interface0: exports::foo::foo::chars::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheWorldIndices {
+        /// Creates a new copy of `TheWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::chars::GuestIndices::new(_component)?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Creates a new instance of [`TheWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::chars::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(TheWorld { interface0 })
+        }
+    }
+    impl TheWorld {
+        /// Convenience wrapper around [`TheWorldPre::new`] and
+        /// [`TheWorldPre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheWorld> {
+            let pre = linker.instantiate_pre(component)?;
+            TheWorldPre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`TheWorldIndices::new_instance`] and
+        /// [`TheWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let indices = TheWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            U: foo::foo::chars::Host,
+        {
+            foo::foo::chars::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_chars(&self) -> &exports::foo::foo::chars::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod chars {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub trait Host {
+                /// A function that accepts a character
+                fn take_char(&mut self, x: char) -> ();
+                /// A function that returns a character
+                fn return_char(&mut self) -> char;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/chars")?;
+                inst.func_wrap(
+                    "take-char",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (char,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::take_char(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "return-char",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::return_char(host);
+                        Ok((r,))
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {
+                /// A function that accepts a character
+                fn take_char(&mut self, x: char) -> () {
+                    Host::take_char(*self, x)
+                }
+                /// A function that returns a character
+                fn return_char(&mut self) -> char {
+                    Host::return_char(*self)
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod chars {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub struct Guest {
+                    take_char: wasmtime::component::Func,
+                    return_char: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    take_char: wasmtime::component::ComponentExportIndex,
+                    return_char: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/chars")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/chars`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/chars")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/chars`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/chars` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let take_char = lookup("take-char")?;
+                        let return_char = lookup("return-char")?;
+                        Ok(GuestIndices {
+                            take_char,
+                            return_char,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let take_char = *_instance
+                            .get_typed_func::<(char,), ()>(&mut store, &self.take_char)?
+                            .func();
+                        let return_char = *_instance
+                            .get_typed_func::<
+                                (),
+                                (char,),
+                            >(&mut store, &self.return_char)?
+                            .func();
+                        Ok(Guest { take_char, return_char })
+                    }
+                }
+                impl Guest {
+                    /// A function that accepts a character
+                    pub fn call_take_char<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: char,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (char,),
+                                (),
+                            >::new_unchecked(self.take_char)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    /// A function that returns a character
+                    pub fn call_return_char<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<char> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (char,),
+                            >::new_unchecked(self.return_char)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/char_async.rs b/crates/component-macro/tests/expanded/char_async.rs
new file mode 100644
index 000000000000..6fbcfca5517b
--- /dev/null
+++ b/crates/component-macro/tests/expanded/char_async.rs
@@ -0,0 +1,410 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-world`.
+///
+/// This structure is created through [`TheWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheWorld`] as well.
+pub struct TheWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheWorldIndices,
+}
+impl<T> Clone for TheWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheWorldPre<_T> {
+    /// Creates a new copy of `TheWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheWorld>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-world`.
+///
+/// This is an implementation detail of [`TheWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheWorld`] as well.
+#[derive(Clone)]
+pub struct TheWorldIndices {
+    interface0: exports::foo::foo::chars::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheWorld::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheWorldPre::instantiate_async`] to
+///   create a [`TheWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheWorldIndices::new_instance`] followed
+///   by [`TheWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheWorld {
+    interface0: exports::foo::foo::chars::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheWorldIndices {
+        /// Creates a new copy of `TheWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::chars::GuestIndices::new(_component)?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Creates a new instance of [`TheWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::chars::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(TheWorld { interface0 })
+        }
+    }
+    impl TheWorld {
+        /// Convenience wrapper around [`TheWorldPre::new`] and
+        /// [`TheWorldPre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheWorld>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            TheWorldPre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`TheWorldIndices::new_instance`] and
+        /// [`TheWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let indices = TheWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+            U: foo::foo::chars::Host + Send,
+        {
+            foo::foo::chars::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_chars(&self) -> &exports::foo::foo::chars::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod chars {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {
+                /// A function that accepts a character
+                async fn take_char(&mut self, x: char) -> ();
+                /// A function that returns a character
+                async fn return_char(&mut self) -> char;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/chars")?;
+                inst.func_wrap_async(
+                    "take-char",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (char,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::take_char(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "return-char",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::return_char(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {
+                /// A function that accepts a character
+                async fn take_char(&mut self, x: char) -> () {
+                    Host::take_char(*self, x).await
+                }
+                /// A function that returns a character
+                async fn return_char(&mut self) -> char {
+                    Host::return_char(*self).await
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod chars {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub struct Guest {
+                    take_char: wasmtime::component::Func,
+                    return_char: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    take_char: wasmtime::component::ComponentExportIndex,
+                    return_char: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/chars")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/chars`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/chars")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/chars`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/chars` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let take_char = lookup("take-char")?;
+                        let return_char = lookup("return-char")?;
+                        Ok(GuestIndices {
+                            take_char,
+                            return_char,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let take_char = *_instance
+                            .get_typed_func::<(char,), ()>(&mut store, &self.take_char)?
+                            .func();
+                        let return_char = *_instance
+                            .get_typed_func::<
+                                (),
+                                (char,),
+                            >(&mut store, &self.return_char)?
+                            .func();
+                        Ok(Guest { take_char, return_char })
+                    }
+                }
+                impl Guest {
+                    /// A function that accepts a character
+                    pub async fn call_take_char<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: char,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (char,),
+                                (),
+                            >::new_unchecked(self.take_char)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    /// A function that returns a character
+                    pub async fn call_return_char<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<char>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (char,),
+                            >::new_unchecked(self.return_char)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/conventions.rs b/crates/component-macro/tests/expanded/conventions.rs
new file mode 100644
index 000000000000..631be530d8b8
--- /dev/null
+++ b/crates/component-macro/tests/expanded/conventions.rs
@@ -0,0 +1,824 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-world`.
+///
+/// This structure is created through [`TheWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheWorld`] as well.
+pub struct TheWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheWorldIndices,
+}
+impl<T> Clone for TheWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheWorldPre<_T> {
+    /// Creates a new copy of `TheWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheWorld> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-world`.
+///
+/// This is an implementation detail of [`TheWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheWorld`] as well.
+#[derive(Clone)]
+pub struct TheWorldIndices {
+    interface0: exports::foo::foo::conventions::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheWorld::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheWorldPre::instantiate`] to
+///   create a [`TheWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheWorldIndices::new_instance`] followed
+///   by [`TheWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheWorld {
+    interface0: exports::foo::foo::conventions::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheWorldIndices {
+        /// Creates a new copy of `TheWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::conventions::GuestIndices::new(
+                _component,
+            )?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Creates a new instance of [`TheWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::conventions::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(TheWorld { interface0 })
+        }
+    }
+    impl TheWorld {
+        /// Convenience wrapper around [`TheWorldPre::new`] and
+        /// [`TheWorldPre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheWorld> {
+            let pre = linker.instantiate_pre(component)?;
+            TheWorldPre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`TheWorldIndices::new_instance`] and
+        /// [`TheWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let indices = TheWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            U: foo::foo::conventions::Host,
+        {
+            foo::foo::conventions::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_conventions(&self) -> &exports::foo::foo::conventions::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod conventions {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone, Copy)]
+            pub struct LudicrousSpeed {
+                #[component(name = "how-fast-are-you-going")]
+                pub how_fast_are_you_going: u32,
+                #[component(name = "i-am-going-extremely-slow")]
+                pub i_am_going_extremely_slow: u64,
+            }
+            impl core::fmt::Debug for LudicrousSpeed {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("LudicrousSpeed")
+                        .field("how-fast-are-you-going", &self.how_fast_are_you_going)
+                        .field(
+                            "i-am-going-extremely-slow",
+                            &self.i_am_going_extremely_slow,
+                        )
+                        .finish()
+                }
+            }
+            const _: () = {
+                assert!(
+                    16 == < LudicrousSpeed as wasmtime::component::ComponentType
+                    >::SIZE32
+                );
+                assert!(
+                    8 == < LudicrousSpeed as wasmtime::component::ComponentType
+                    >::ALIGN32
+                );
+            };
+            pub trait Host {
+                fn kebab_case(&mut self) -> ();
+                fn foo(&mut self, x: LudicrousSpeed) -> ();
+                fn function_with_dashes(&mut self) -> ();
+                fn function_with_no_weird_characters(&mut self) -> ();
+                fn apple(&mut self) -> ();
+                fn apple_pear(&mut self) -> ();
+                fn apple_pear_grape(&mut self) -> ();
+                fn a0(&mut self) -> ();
+                /// Comment out identifiers that collide when mapped to snake_case, for now; see
+                /// https://github.com/WebAssembly/component-model/issues/118
+                /// APPLE: func()
+                /// APPLE-pear-GRAPE: func()
+                /// apple-PEAR-grape: func()
+                fn is_xml(&mut self) -> ();
+                fn explicit(&mut self) -> ();
+                fn explicit_kebab(&mut self) -> ();
+                /// Identifiers with the same name as keywords are quoted.
+                fn bool(&mut self) -> ();
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/conventions")?;
+                inst.func_wrap(
+                    "kebab-case",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::kebab_case(host);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "foo",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (LudicrousSpeed,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::foo(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "function-with-dashes",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::function_with_dashes(host);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "function-with-no-weird-characters",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::function_with_no_weird_characters(host);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "apple",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::apple(host);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "apple-pear",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::apple_pear(host);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "apple-pear-grape",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::apple_pear_grape(host);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "a0",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::a0(host);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "is-XML",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::is_xml(host);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "explicit",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::explicit(host);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "explicit-kebab",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::explicit_kebab(host);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "bool",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::bool(host);
+                        Ok(r)
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {
+                fn kebab_case(&mut self) -> () {
+                    Host::kebab_case(*self)
+                }
+                fn foo(&mut self, x: LudicrousSpeed) -> () {
+                    Host::foo(*self, x)
+                }
+                fn function_with_dashes(&mut self) -> () {
+                    Host::function_with_dashes(*self)
+                }
+                fn function_with_no_weird_characters(&mut self) -> () {
+                    Host::function_with_no_weird_characters(*self)
+                }
+                fn apple(&mut self) -> () {
+                    Host::apple(*self)
+                }
+                fn apple_pear(&mut self) -> () {
+                    Host::apple_pear(*self)
+                }
+                fn apple_pear_grape(&mut self) -> () {
+                    Host::apple_pear_grape(*self)
+                }
+                fn a0(&mut self) -> () {
+                    Host::a0(*self)
+                }
+                /// Comment out identifiers that collide when mapped to snake_case, for now; see
+                /// https://github.com/WebAssembly/component-model/issues/118
+                /// APPLE: func()
+                /// APPLE-pear-GRAPE: func()
+                /// apple-PEAR-grape: func()
+                fn is_xml(&mut self) -> () {
+                    Host::is_xml(*self)
+                }
+                fn explicit(&mut self) -> () {
+                    Host::explicit(*self)
+                }
+                fn explicit_kebab(&mut self) -> () {
+                    Host::explicit_kebab(*self)
+                }
+                /// Identifiers with the same name as keywords are quoted.
+                fn bool(&mut self) -> () {
+                    Host::bool(*self)
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod conventions {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(record)]
+                #[derive(Clone, Copy)]
+                pub struct LudicrousSpeed {
+                    #[component(name = "how-fast-are-you-going")]
+                    pub how_fast_are_you_going: u32,
+                    #[component(name = "i-am-going-extremely-slow")]
+                    pub i_am_going_extremely_slow: u64,
+                }
+                impl core::fmt::Debug for LudicrousSpeed {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        f.debug_struct("LudicrousSpeed")
+                            .field(
+                                "how-fast-are-you-going",
+                                &self.how_fast_are_you_going,
+                            )
+                            .field(
+                                "i-am-going-extremely-slow",
+                                &self.i_am_going_extremely_slow,
+                            )
+                            .finish()
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        16 == < LudicrousSpeed as wasmtime::component::ComponentType
+                        >::SIZE32
+                    );
+                    assert!(
+                        8 == < LudicrousSpeed as wasmtime::component::ComponentType
+                        >::ALIGN32
+                    );
+                };
+                pub struct Guest {
+                    kebab_case: wasmtime::component::Func,
+                    foo: wasmtime::component::Func,
+                    function_with_dashes: wasmtime::component::Func,
+                    function_with_no_weird_characters: wasmtime::component::Func,
+                    apple: wasmtime::component::Func,
+                    apple_pear: wasmtime::component::Func,
+                    apple_pear_grape: wasmtime::component::Func,
+                    a0: wasmtime::component::Func,
+                    is_xml: wasmtime::component::Func,
+                    explicit: wasmtime::component::Func,
+                    explicit_kebab: wasmtime::component::Func,
+                    bool: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    kebab_case: wasmtime::component::ComponentExportIndex,
+                    foo: wasmtime::component::ComponentExportIndex,
+                    function_with_dashes: wasmtime::component::ComponentExportIndex,
+                    function_with_no_weird_characters: wasmtime::component::ComponentExportIndex,
+                    apple: wasmtime::component::ComponentExportIndex,
+                    apple_pear: wasmtime::component::ComponentExportIndex,
+                    apple_pear_grape: wasmtime::component::ComponentExportIndex,
+                    a0: wasmtime::component::ComponentExportIndex,
+                    is_xml: wasmtime::component::ComponentExportIndex,
+                    explicit: wasmtime::component::ComponentExportIndex,
+                    explicit_kebab: wasmtime::component::ComponentExportIndex,
+                    bool: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/conventions")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/conventions`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/conventions")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/conventions`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/conventions` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let kebab_case = lookup("kebab-case")?;
+                        let foo = lookup("foo")?;
+                        let function_with_dashes = lookup("function-with-dashes")?;
+                        let function_with_no_weird_characters = lookup(
+                            "function-with-no-weird-characters",
+                        )?;
+                        let apple = lookup("apple")?;
+                        let apple_pear = lookup("apple-pear")?;
+                        let apple_pear_grape = lookup("apple-pear-grape")?;
+                        let a0 = lookup("a0")?;
+                        let is_xml = lookup("is-XML")?;
+                        let explicit = lookup("explicit")?;
+                        let explicit_kebab = lookup("explicit-kebab")?;
+                        let bool = lookup("bool")?;
+                        Ok(GuestIndices {
+                            kebab_case,
+                            foo,
+                            function_with_dashes,
+                            function_with_no_weird_characters,
+                            apple,
+                            apple_pear,
+                            apple_pear_grape,
+                            a0,
+                            is_xml,
+                            explicit,
+                            explicit_kebab,
+                            bool,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let kebab_case = *_instance
+                            .get_typed_func::<(), ()>(&mut store, &self.kebab_case)?
+                            .func();
+                        let foo = *_instance
+                            .get_typed_func::<
+                                (LudicrousSpeed,),
+                                (),
+                            >(&mut store, &self.foo)?
+                            .func();
+                        let function_with_dashes = *_instance
+                            .get_typed_func::<
+                                (),
+                                (),
+                            >(&mut store, &self.function_with_dashes)?
+                            .func();
+                        let function_with_no_weird_characters = *_instance
+                            .get_typed_func::<
+                                (),
+                                (),
+                            >(&mut store, &self.function_with_no_weird_characters)?
+                            .func();
+                        let apple = *_instance
+                            .get_typed_func::<(), ()>(&mut store, &self.apple)?
+                            .func();
+                        let apple_pear = *_instance
+                            .get_typed_func::<(), ()>(&mut store, &self.apple_pear)?
+                            .func();
+                        let apple_pear_grape = *_instance
+                            .get_typed_func::<
+                                (),
+                                (),
+                            >(&mut store, &self.apple_pear_grape)?
+                            .func();
+                        let a0 = *_instance
+                            .get_typed_func::<(), ()>(&mut store, &self.a0)?
+                            .func();
+                        let is_xml = *_instance
+                            .get_typed_func::<(), ()>(&mut store, &self.is_xml)?
+                            .func();
+                        let explicit = *_instance
+                            .get_typed_func::<(), ()>(&mut store, &self.explicit)?
+                            .func();
+                        let explicit_kebab = *_instance
+                            .get_typed_func::<(), ()>(&mut store, &self.explicit_kebab)?
+                            .func();
+                        let bool = *_instance
+                            .get_typed_func::<(), ()>(&mut store, &self.bool)?
+                            .func();
+                        Ok(Guest {
+                            kebab_case,
+                            foo,
+                            function_with_dashes,
+                            function_with_no_weird_characters,
+                            apple,
+                            apple_pear,
+                            apple_pear_grape,
+                            a0,
+                            is_xml,
+                            explicit,
+                            explicit_kebab,
+                            bool,
+                        })
+                    }
+                }
+                impl Guest {
+                    pub fn call_kebab_case<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.kebab_case)
+                        };
+                        let () = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_foo<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: LudicrousSpeed,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (LudicrousSpeed,),
+                                (),
+                            >::new_unchecked(self.foo)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_function_with_dashes<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.function_with_dashes)
+                        };
+                        let () = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_function_with_no_weird_characters<
+                        S: wasmtime::AsContextMut,
+                    >(&self, mut store: S) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.function_with_no_weird_characters)
+                        };
+                        let () = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_apple<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.apple)
+                        };
+                        let () = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_apple_pear<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.apple_pear)
+                        };
+                        let () = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_apple_pear_grape<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.apple_pear_grape)
+                        };
+                        let () = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_a0<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.a0)
+                        };
+                        let () = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    /// Comment out identifiers that collide when mapped to snake_case, for now; see
+                    /// https://github.com/WebAssembly/component-model/issues/118
+                    /// APPLE: func()
+                    /// APPLE-pear-GRAPE: func()
+                    /// apple-PEAR-grape: func()
+                    pub fn call_is_xml<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.is_xml)
+                        };
+                        let () = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_explicit<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.explicit)
+                        };
+                        let () = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_explicit_kebab<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.explicit_kebab)
+                        };
+                        let () = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    /// Identifiers with the same name as keywords are quoted.
+                    pub fn call_bool<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.bool)
+                        };
+                        let () = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/conventions_async.rs b/crates/component-macro/tests/expanded/conventions_async.rs
new file mode 100644
index 000000000000..e03bae3f1012
--- /dev/null
+++ b/crates/component-macro/tests/expanded/conventions_async.rs
@@ -0,0 +1,875 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-world`.
+///
+/// This structure is created through [`TheWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheWorld`] as well.
+pub struct TheWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheWorldIndices,
+}
+impl<T> Clone for TheWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheWorldPre<_T> {
+    /// Creates a new copy of `TheWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheWorld>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-world`.
+///
+/// This is an implementation detail of [`TheWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheWorld`] as well.
+#[derive(Clone)]
+pub struct TheWorldIndices {
+    interface0: exports::foo::foo::conventions::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheWorld::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheWorldPre::instantiate_async`] to
+///   create a [`TheWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheWorldIndices::new_instance`] followed
+///   by [`TheWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheWorld {
+    interface0: exports::foo::foo::conventions::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheWorldIndices {
+        /// Creates a new copy of `TheWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::conventions::GuestIndices::new(
+                _component,
+            )?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Creates a new instance of [`TheWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::conventions::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(TheWorld { interface0 })
+        }
+    }
+    impl TheWorld {
+        /// Convenience wrapper around [`TheWorldPre::new`] and
+        /// [`TheWorldPre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheWorld>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            TheWorldPre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`TheWorldIndices::new_instance`] and
+        /// [`TheWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let indices = TheWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+            U: foo::foo::conventions::Host + Send,
+        {
+            foo::foo::conventions::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_conventions(&self) -> &exports::foo::foo::conventions::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod conventions {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone, Copy)]
+            pub struct LudicrousSpeed {
+                #[component(name = "how-fast-are-you-going")]
+                pub how_fast_are_you_going: u32,
+                #[component(name = "i-am-going-extremely-slow")]
+                pub i_am_going_extremely_slow: u64,
+            }
+            impl core::fmt::Debug for LudicrousSpeed {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("LudicrousSpeed")
+                        .field("how-fast-are-you-going", &self.how_fast_are_you_going)
+                        .field(
+                            "i-am-going-extremely-slow",
+                            &self.i_am_going_extremely_slow,
+                        )
+                        .finish()
+                }
+            }
+            const _: () = {
+                assert!(
+                    16 == < LudicrousSpeed as wasmtime::component::ComponentType
+                    >::SIZE32
+                );
+                assert!(
+                    8 == < LudicrousSpeed as wasmtime::component::ComponentType
+                    >::ALIGN32
+                );
+            };
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {
+                async fn kebab_case(&mut self) -> ();
+                async fn foo(&mut self, x: LudicrousSpeed) -> ();
+                async fn function_with_dashes(&mut self) -> ();
+                async fn function_with_no_weird_characters(&mut self) -> ();
+                async fn apple(&mut self) -> ();
+                async fn apple_pear(&mut self) -> ();
+                async fn apple_pear_grape(&mut self) -> ();
+                async fn a0(&mut self) -> ();
+                /// Comment out identifiers that collide when mapped to snake_case, for now; see
+                /// https://github.com/WebAssembly/component-model/issues/118
+                /// APPLE: func()
+                /// APPLE-pear-GRAPE: func()
+                /// apple-PEAR-grape: func()
+                async fn is_xml(&mut self) -> ();
+                async fn explicit(&mut self) -> ();
+                async fn explicit_kebab(&mut self) -> ();
+                /// Identifiers with the same name as keywords are quoted.
+                async fn bool(&mut self) -> ();
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/conventions")?;
+                inst.func_wrap_async(
+                    "kebab-case",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::kebab_case(host).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "foo",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (LudicrousSpeed,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::foo(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "function-with-dashes",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::function_with_dashes(host).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "function-with-no-weird-characters",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::function_with_no_weird_characters(host).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "apple",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::apple(host).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "apple-pear",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::apple_pear(host).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "apple-pear-grape",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::apple_pear_grape(host).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "a0",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::a0(host).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "is-XML",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::is_xml(host).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "explicit",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::explicit(host).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "explicit-kebab",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::explicit_kebab(host).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "bool",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::bool(host).await;
+                        Ok(r)
+                    }),
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {
+                async fn kebab_case(&mut self) -> () {
+                    Host::kebab_case(*self).await
+                }
+                async fn foo(&mut self, x: LudicrousSpeed) -> () {
+                    Host::foo(*self, x).await
+                }
+                async fn function_with_dashes(&mut self) -> () {
+                    Host::function_with_dashes(*self).await
+                }
+                async fn function_with_no_weird_characters(&mut self) -> () {
+                    Host::function_with_no_weird_characters(*self).await
+                }
+                async fn apple(&mut self) -> () {
+                    Host::apple(*self).await
+                }
+                async fn apple_pear(&mut self) -> () {
+                    Host::apple_pear(*self).await
+                }
+                async fn apple_pear_grape(&mut self) -> () {
+                    Host::apple_pear_grape(*self).await
+                }
+                async fn a0(&mut self) -> () {
+                    Host::a0(*self).await
+                }
+                /// Comment out identifiers that collide when mapped to snake_case, for now; see
+                /// https://github.com/WebAssembly/component-model/issues/118
+                /// APPLE: func()
+                /// APPLE-pear-GRAPE: func()
+                /// apple-PEAR-grape: func()
+                async fn is_xml(&mut self) -> () {
+                    Host::is_xml(*self).await
+                }
+                async fn explicit(&mut self) -> () {
+                    Host::explicit(*self).await
+                }
+                async fn explicit_kebab(&mut self) -> () {
+                    Host::explicit_kebab(*self).await
+                }
+                /// Identifiers with the same name as keywords are quoted.
+                async fn bool(&mut self) -> () {
+                    Host::bool(*self).await
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod conventions {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(record)]
+                #[derive(Clone, Copy)]
+                pub struct LudicrousSpeed {
+                    #[component(name = "how-fast-are-you-going")]
+                    pub how_fast_are_you_going: u32,
+                    #[component(name = "i-am-going-extremely-slow")]
+                    pub i_am_going_extremely_slow: u64,
+                }
+                impl core::fmt::Debug for LudicrousSpeed {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        f.debug_struct("LudicrousSpeed")
+                            .field(
+                                "how-fast-are-you-going",
+                                &self.how_fast_are_you_going,
+                            )
+                            .field(
+                                "i-am-going-extremely-slow",
+                                &self.i_am_going_extremely_slow,
+                            )
+                            .finish()
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        16 == < LudicrousSpeed as wasmtime::component::ComponentType
+                        >::SIZE32
+                    );
+                    assert!(
+                        8 == < LudicrousSpeed as wasmtime::component::ComponentType
+                        >::ALIGN32
+                    );
+                };
+                pub struct Guest {
+                    kebab_case: wasmtime::component::Func,
+                    foo: wasmtime::component::Func,
+                    function_with_dashes: wasmtime::component::Func,
+                    function_with_no_weird_characters: wasmtime::component::Func,
+                    apple: wasmtime::component::Func,
+                    apple_pear: wasmtime::component::Func,
+                    apple_pear_grape: wasmtime::component::Func,
+                    a0: wasmtime::component::Func,
+                    is_xml: wasmtime::component::Func,
+                    explicit: wasmtime::component::Func,
+                    explicit_kebab: wasmtime::component::Func,
+                    bool: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    kebab_case: wasmtime::component::ComponentExportIndex,
+                    foo: wasmtime::component::ComponentExportIndex,
+                    function_with_dashes: wasmtime::component::ComponentExportIndex,
+                    function_with_no_weird_characters: wasmtime::component::ComponentExportIndex,
+                    apple: wasmtime::component::ComponentExportIndex,
+                    apple_pear: wasmtime::component::ComponentExportIndex,
+                    apple_pear_grape: wasmtime::component::ComponentExportIndex,
+                    a0: wasmtime::component::ComponentExportIndex,
+                    is_xml: wasmtime::component::ComponentExportIndex,
+                    explicit: wasmtime::component::ComponentExportIndex,
+                    explicit_kebab: wasmtime::component::ComponentExportIndex,
+                    bool: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/conventions")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/conventions`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/conventions")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/conventions`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/conventions` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let kebab_case = lookup("kebab-case")?;
+                        let foo = lookup("foo")?;
+                        let function_with_dashes = lookup("function-with-dashes")?;
+                        let function_with_no_weird_characters = lookup(
+                            "function-with-no-weird-characters",
+                        )?;
+                        let apple = lookup("apple")?;
+                        let apple_pear = lookup("apple-pear")?;
+                        let apple_pear_grape = lookup("apple-pear-grape")?;
+                        let a0 = lookup("a0")?;
+                        let is_xml = lookup("is-XML")?;
+                        let explicit = lookup("explicit")?;
+                        let explicit_kebab = lookup("explicit-kebab")?;
+                        let bool = lookup("bool")?;
+                        Ok(GuestIndices {
+                            kebab_case,
+                            foo,
+                            function_with_dashes,
+                            function_with_no_weird_characters,
+                            apple,
+                            apple_pear,
+                            apple_pear_grape,
+                            a0,
+                            is_xml,
+                            explicit,
+                            explicit_kebab,
+                            bool,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let kebab_case = *_instance
+                            .get_typed_func::<(), ()>(&mut store, &self.kebab_case)?
+                            .func();
+                        let foo = *_instance
+                            .get_typed_func::<
+                                (LudicrousSpeed,),
+                                (),
+                            >(&mut store, &self.foo)?
+                            .func();
+                        let function_with_dashes = *_instance
+                            .get_typed_func::<
+                                (),
+                                (),
+                            >(&mut store, &self.function_with_dashes)?
+                            .func();
+                        let function_with_no_weird_characters = *_instance
+                            .get_typed_func::<
+                                (),
+                                (),
+                            >(&mut store, &self.function_with_no_weird_characters)?
+                            .func();
+                        let apple = *_instance
+                            .get_typed_func::<(), ()>(&mut store, &self.apple)?
+                            .func();
+                        let apple_pear = *_instance
+                            .get_typed_func::<(), ()>(&mut store, &self.apple_pear)?
+                            .func();
+                        let apple_pear_grape = *_instance
+                            .get_typed_func::<
+                                (),
+                                (),
+                            >(&mut store, &self.apple_pear_grape)?
+                            .func();
+                        let a0 = *_instance
+                            .get_typed_func::<(), ()>(&mut store, &self.a0)?
+                            .func();
+                        let is_xml = *_instance
+                            .get_typed_func::<(), ()>(&mut store, &self.is_xml)?
+                            .func();
+                        let explicit = *_instance
+                            .get_typed_func::<(), ()>(&mut store, &self.explicit)?
+                            .func();
+                        let explicit_kebab = *_instance
+                            .get_typed_func::<(), ()>(&mut store, &self.explicit_kebab)?
+                            .func();
+                        let bool = *_instance
+                            .get_typed_func::<(), ()>(&mut store, &self.bool)?
+                            .func();
+                        Ok(Guest {
+                            kebab_case,
+                            foo,
+                            function_with_dashes,
+                            function_with_no_weird_characters,
+                            apple,
+                            apple_pear,
+                            apple_pear_grape,
+                            a0,
+                            is_xml,
+                            explicit,
+                            explicit_kebab,
+                            bool,
+                        })
+                    }
+                }
+                impl Guest {
+                    pub async fn call_kebab_case<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.kebab_case)
+                        };
+                        let () = callee.call_async(store.as_context_mut(), ()).await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_foo<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: LudicrousSpeed,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (LudicrousSpeed,),
+                                (),
+                            >::new_unchecked(self.foo)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_function_with_dashes<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.function_with_dashes)
+                        };
+                        let () = callee.call_async(store.as_context_mut(), ()).await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_function_with_no_weird_characters<
+                        S: wasmtime::AsContextMut,
+                    >(&self, mut store: S) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.function_with_no_weird_characters)
+                        };
+                        let () = callee.call_async(store.as_context_mut(), ()).await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_apple<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.apple)
+                        };
+                        let () = callee.call_async(store.as_context_mut(), ()).await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_apple_pear<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.apple_pear)
+                        };
+                        let () = callee.call_async(store.as_context_mut(), ()).await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_apple_pear_grape<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.apple_pear_grape)
+                        };
+                        let () = callee.call_async(store.as_context_mut(), ()).await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_a0<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.a0)
+                        };
+                        let () = callee.call_async(store.as_context_mut(), ()).await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    /// Comment out identifiers that collide when mapped to snake_case, for now; see
+                    /// https://github.com/WebAssembly/component-model/issues/118
+                    /// APPLE: func()
+                    /// APPLE-pear-GRAPE: func()
+                    /// apple-PEAR-grape: func()
+                    pub async fn call_is_xml<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.is_xml)
+                        };
+                        let () = callee.call_async(store.as_context_mut(), ()).await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_explicit<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.explicit)
+                        };
+                        let () = callee.call_async(store.as_context_mut(), ()).await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_explicit_kebab<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.explicit_kebab)
+                        };
+                        let () = callee.call_async(store.as_context_mut(), ()).await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    /// Identifiers with the same name as keywords are quoted.
+                    pub async fn call_bool<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.bool)
+                        };
+                        let () = callee.call_async(store.as_context_mut(), ()).await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/dead-code.rs b/crates/component-macro/tests/expanded/dead-code.rs
new file mode 100644
index 000000000000..30781af56403
--- /dev/null
+++ b/crates/component-macro/tests/expanded/dead-code.rs
@@ -0,0 +1,279 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `imports`.
+///
+/// This structure is created through [`ImportsPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`Imports`] as well.
+pub struct ImportsPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: ImportsIndices,
+}
+impl<T> Clone for ImportsPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> ImportsPre<_T> {
+    /// Creates a new copy of `ImportsPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = ImportsIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`Imports`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<Imports> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `imports`.
+///
+/// This is an implementation detail of [`ImportsPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`Imports`] as well.
+#[derive(Clone)]
+pub struct ImportsIndices {}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `imports`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`Imports::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`ImportsPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`ImportsPre::instantiate`] to
+///   create a [`Imports`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`Imports::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`ImportsIndices::new_instance`] followed
+///   by [`ImportsIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct Imports {}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl ImportsIndices {
+        /// Creates a new copy of `ImportsIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            Ok(ImportsIndices {})
+        }
+        /// Creates a new instance of [`ImportsIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`Imports`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`Imports`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            Ok(ImportsIndices {})
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`Imports`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Imports> {
+            let _instance = instance;
+            Ok(Imports {})
+        }
+    }
+    impl Imports {
+        /// Convenience wrapper around [`ImportsPre::new`] and
+        /// [`ImportsPre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<Imports> {
+            let pre = linker.instantiate_pre(component)?;
+            ImportsPre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`ImportsIndices::new_instance`] and
+        /// [`ImportsIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Imports> {
+            let indices = ImportsIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            U: a::b::interface_with_live_type::Host
+                + a::b::interface_with_dead_type::Host,
+        {
+            a::b::interface_with_live_type::add_to_linker(linker, get)?;
+            a::b::interface_with_dead_type::add_to_linker(linker, get)?;
+            Ok(())
+        }
+    }
+};
+pub mod a {
+    pub mod b {
+        #[allow(clippy::all)]
+        pub mod interface_with_live_type {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone, Copy)]
+            pub struct LiveType {
+                #[component(name = "a")]
+                pub a: u32,
+            }
+            impl core::fmt::Debug for LiveType {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("LiveType").field("a", &self.a).finish()
+                }
+            }
+            const _: () = {
+                assert!(4 == < LiveType as wasmtime::component::ComponentType >::SIZE32);
+                assert!(
+                    4 == < LiveType as wasmtime::component::ComponentType >::ALIGN32
+                );
+            };
+            pub trait Host {
+                fn f(&mut self) -> LiveType;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("a:b/interface-with-live-type")?;
+                inst.func_wrap(
+                    "f",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::f(host);
+                        Ok((r,))
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {
+                fn f(&mut self) -> LiveType {
+                    Host::f(*self)
+                }
+            }
+        }
+        #[allow(clippy::all)]
+        pub mod interface_with_dead_type {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub trait Host {}
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("a:b/interface-with-dead-type")?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {}
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/dead-code_async.rs b/crates/component-macro/tests/expanded/dead-code_async.rs
new file mode 100644
index 000000000000..ab2ce33833d4
--- /dev/null
+++ b/crates/component-macro/tests/expanded/dead-code_async.rs
@@ -0,0 +1,298 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `imports`.
+///
+/// This structure is created through [`ImportsPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`Imports`] as well.
+pub struct ImportsPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: ImportsIndices,
+}
+impl<T> Clone for ImportsPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> ImportsPre<_T> {
+    /// Creates a new copy of `ImportsPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = ImportsIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`Imports`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<Imports>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `imports`.
+///
+/// This is an implementation detail of [`ImportsPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`Imports`] as well.
+#[derive(Clone)]
+pub struct ImportsIndices {}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `imports`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`Imports::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`ImportsPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`ImportsPre::instantiate_async`] to
+///   create a [`Imports`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`Imports::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`ImportsIndices::new_instance`] followed
+///   by [`ImportsIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct Imports {}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl ImportsIndices {
+        /// Creates a new copy of `ImportsIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            Ok(ImportsIndices {})
+        }
+        /// Creates a new instance of [`ImportsIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`Imports`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`Imports`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            Ok(ImportsIndices {})
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`Imports`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Imports> {
+            let _instance = instance;
+            Ok(Imports {})
+        }
+    }
+    impl Imports {
+        /// Convenience wrapper around [`ImportsPre::new`] and
+        /// [`ImportsPre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<Imports>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            ImportsPre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`ImportsIndices::new_instance`] and
+        /// [`ImportsIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Imports> {
+            let indices = ImportsIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+            U: a::b::interface_with_live_type::Host
+                + a::b::interface_with_dead_type::Host + Send,
+        {
+            a::b::interface_with_live_type::add_to_linker(linker, get)?;
+            a::b::interface_with_dead_type::add_to_linker(linker, get)?;
+            Ok(())
+        }
+    }
+};
+pub mod a {
+    pub mod b {
+        #[allow(clippy::all)]
+        pub mod interface_with_live_type {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone, Copy)]
+            pub struct LiveType {
+                #[component(name = "a")]
+                pub a: u32,
+            }
+            impl core::fmt::Debug for LiveType {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("LiveType").field("a", &self.a).finish()
+                }
+            }
+            const _: () = {
+                assert!(4 == < LiveType as wasmtime::component::ComponentType >::SIZE32);
+                assert!(
+                    4 == < LiveType as wasmtime::component::ComponentType >::ALIGN32
+                );
+            };
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {
+                async fn f(&mut self) -> LiveType;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("a:b/interface-with-live-type")?;
+                inst.func_wrap_async(
+                    "f",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::f(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {
+                async fn f(&mut self) -> LiveType {
+                    Host::f(*self).await
+                }
+            }
+        }
+        #[allow(clippy::all)]
+        pub mod interface_with_dead_type {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {}
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("a:b/interface-with-dead-type")?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {}
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/direct-import.rs b/crates/component-macro/tests/expanded/direct-import.rs
new file mode 100644
index 000000000000..225fe6c9009f
--- /dev/null
+++ b/crates/component-macro/tests/expanded/direct-import.rs
@@ -0,0 +1,205 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `foo`.
+///
+/// This structure is created through [`FooPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`Foo`] as well.
+pub struct FooPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: FooIndices,
+}
+impl<T> Clone for FooPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> FooPre<_T> {
+    /// Creates a new copy of `FooPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = FooIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`Foo`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<Foo> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `foo`.
+///
+/// This is an implementation detail of [`FooPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`Foo`] as well.
+#[derive(Clone)]
+pub struct FooIndices {}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `foo`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`Foo::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`FooPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`FooPre::instantiate`] to
+///   create a [`Foo`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`Foo::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`FooIndices::new_instance`] followed
+///   by [`FooIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct Foo {}
+pub trait FooImports {
+    fn foo(&mut self) -> ();
+}
+pub trait FooImportsGetHost<
+    T,
+>: Fn(T) -> <Self as FooImportsGetHost<T>>::Host + Send + Sync + Copy + 'static {
+    type Host: FooImports;
+}
+impl<F, T, O> FooImportsGetHost<T> for F
+where
+    F: Fn(T) -> O + Send + Sync + Copy + 'static,
+    O: FooImports,
+{
+    type Host = O;
+}
+impl<_T: FooImports + ?Sized> FooImports for &mut _T {
+    fn foo(&mut self) -> () {
+        FooImports::foo(*self)
+    }
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl FooIndices {
+        /// Creates a new copy of `FooIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            Ok(FooIndices {})
+        }
+        /// Creates a new instance of [`FooIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`Foo`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`Foo`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            Ok(FooIndices {})
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`Foo`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Foo> {
+            let _instance = instance;
+            Ok(Foo {})
+        }
+    }
+    impl Foo {
+        /// Convenience wrapper around [`FooPre::new`] and
+        /// [`FooPre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<Foo> {
+            let pre = linker.instantiate_pre(component)?;
+            FooPre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`FooIndices::new_instance`] and
+        /// [`FooIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Foo> {
+            let indices = FooIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker_imports_get_host<T>(
+            linker: &mut wasmtime::component::Linker<T>,
+            host_getter: impl for<'a> FooImportsGetHost<&'a mut T>,
+        ) -> wasmtime::Result<()> {
+            let mut linker = linker.root();
+            linker
+                .func_wrap(
+                    "foo",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = FooImports::foo(host);
+                        Ok(r)
+                    },
+                )?;
+            Ok(())
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            U: FooImports,
+        {
+            Self::add_to_linker_imports_get_host(linker, get)?;
+            Ok(())
+        }
+    }
+};
diff --git a/crates/component-macro/tests/expanded/direct-import_async.rs b/crates/component-macro/tests/expanded/direct-import_async.rs
new file mode 100644
index 000000000000..59ee3fc7c68a
--- /dev/null
+++ b/crates/component-macro/tests/expanded/direct-import_async.rs
@@ -0,0 +1,217 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `foo`.
+///
+/// This structure is created through [`FooPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`Foo`] as well.
+pub struct FooPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: FooIndices,
+}
+impl<T> Clone for FooPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> FooPre<_T> {
+    /// Creates a new copy of `FooPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = FooIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`Foo`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<Foo>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `foo`.
+///
+/// This is an implementation detail of [`FooPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`Foo`] as well.
+#[derive(Clone)]
+pub struct FooIndices {}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `foo`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`Foo::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`FooPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`FooPre::instantiate_async`] to
+///   create a [`Foo`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`Foo::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`FooIndices::new_instance`] followed
+///   by [`FooIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct Foo {}
+#[wasmtime::component::__internal::async_trait]
+pub trait FooImports: Send {
+    async fn foo(&mut self) -> ();
+}
+pub trait FooImportsGetHost<
+    T,
+>: Fn(T) -> <Self as FooImportsGetHost<T>>::Host + Send + Sync + Copy + 'static {
+    type Host: FooImports;
+}
+impl<F, T, O> FooImportsGetHost<T> for F
+where
+    F: Fn(T) -> O + Send + Sync + Copy + 'static,
+    O: FooImports,
+{
+    type Host = O;
+}
+#[wasmtime::component::__internal::async_trait]
+impl<_T: FooImports + ?Sized + Send> FooImports for &mut _T {
+    async fn foo(&mut self) -> () {
+        FooImports::foo(*self).await
+    }
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl FooIndices {
+        /// Creates a new copy of `FooIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            Ok(FooIndices {})
+        }
+        /// Creates a new instance of [`FooIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`Foo`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`Foo`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            Ok(FooIndices {})
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`Foo`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Foo> {
+            let _instance = instance;
+            Ok(Foo {})
+        }
+    }
+    impl Foo {
+        /// Convenience wrapper around [`FooPre::new`] and
+        /// [`FooPre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<Foo>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            FooPre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`FooIndices::new_instance`] and
+        /// [`FooIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Foo> {
+            let indices = FooIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker_imports_get_host<T>(
+            linker: &mut wasmtime::component::Linker<T>,
+            host_getter: impl for<'a> FooImportsGetHost<&'a mut T>,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+        {
+            let mut linker = linker.root();
+            linker
+                .func_wrap_async(
+                    "foo",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = FooImports::foo(host).await;
+                        Ok(r)
+                    }),
+                )?;
+            Ok(())
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+            U: FooImports + Send,
+        {
+            Self::add_to_linker_imports_get_host(linker, get)?;
+            Ok(())
+        }
+    }
+};
diff --git a/crates/component-macro/tests/expanded/empty.rs b/crates/component-macro/tests/expanded/empty.rs
new file mode 100644
index 000000000000..573b02c84e74
--- /dev/null
+++ b/crates/component-macro/tests/expanded/empty.rs
@@ -0,0 +1,159 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `empty`.
+///
+/// This structure is created through [`EmptyPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`Empty`] as well.
+pub struct EmptyPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: EmptyIndices,
+}
+impl<T> Clone for EmptyPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> EmptyPre<_T> {
+    /// Creates a new copy of `EmptyPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = EmptyIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`Empty`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<Empty> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `empty`.
+///
+/// This is an implementation detail of [`EmptyPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`Empty`] as well.
+#[derive(Clone)]
+pub struct EmptyIndices {}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `empty`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`Empty::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`EmptyPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`EmptyPre::instantiate`] to
+///   create a [`Empty`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`Empty::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`EmptyIndices::new_instance`] followed
+///   by [`EmptyIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct Empty {}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl EmptyIndices {
+        /// Creates a new copy of `EmptyIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            Ok(EmptyIndices {})
+        }
+        /// Creates a new instance of [`EmptyIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`Empty`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`Empty`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            Ok(EmptyIndices {})
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`Empty`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Empty> {
+            let _instance = instance;
+            Ok(Empty {})
+        }
+    }
+    impl Empty {
+        /// Convenience wrapper around [`EmptyPre::new`] and
+        /// [`EmptyPre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<Empty> {
+            let pre = linker.instantiate_pre(component)?;
+            EmptyPre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`EmptyIndices::new_instance`] and
+        /// [`EmptyIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Empty> {
+            let indices = EmptyIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+    }
+};
diff --git a/crates/component-macro/tests/expanded/empty_async.rs b/crates/component-macro/tests/expanded/empty_async.rs
new file mode 100644
index 000000000000..d2eea87b72a0
--- /dev/null
+++ b/crates/component-macro/tests/expanded/empty_async.rs
@@ -0,0 +1,165 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `empty`.
+///
+/// This structure is created through [`EmptyPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`Empty`] as well.
+pub struct EmptyPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: EmptyIndices,
+}
+impl<T> Clone for EmptyPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> EmptyPre<_T> {
+    /// Creates a new copy of `EmptyPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = EmptyIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`Empty`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<Empty>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `empty`.
+///
+/// This is an implementation detail of [`EmptyPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`Empty`] as well.
+#[derive(Clone)]
+pub struct EmptyIndices {}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `empty`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`Empty::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`EmptyPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`EmptyPre::instantiate_async`] to
+///   create a [`Empty`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`Empty::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`EmptyIndices::new_instance`] followed
+///   by [`EmptyIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct Empty {}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl EmptyIndices {
+        /// Creates a new copy of `EmptyIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            Ok(EmptyIndices {})
+        }
+        /// Creates a new instance of [`EmptyIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`Empty`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`Empty`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            Ok(EmptyIndices {})
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`Empty`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Empty> {
+            let _instance = instance;
+            Ok(Empty {})
+        }
+    }
+    impl Empty {
+        /// Convenience wrapper around [`EmptyPre::new`] and
+        /// [`EmptyPre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<Empty>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            EmptyPre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`EmptyIndices::new_instance`] and
+        /// [`EmptyIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Empty> {
+            let indices = EmptyIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+    }
+};
diff --git a/crates/component-macro/tests/expanded/flags.rs b/crates/component-macro/tests/expanded/flags.rs
new file mode 100644
index 000000000000..c036a1a2d85b
--- /dev/null
+++ b/crates/component-macro/tests/expanded/flags.rs
@@ -0,0 +1,859 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-flags`.
+///
+/// This structure is created through [`TheFlagsPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheFlags`] as well.
+pub struct TheFlagsPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheFlagsIndices,
+}
+impl<T> Clone for TheFlagsPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheFlagsPre<_T> {
+    /// Creates a new copy of `TheFlagsPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheFlagsIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheFlags`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheFlags> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-flags`.
+///
+/// This is an implementation detail of [`TheFlagsPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheFlags`] as well.
+#[derive(Clone)]
+pub struct TheFlagsIndices {
+    interface0: exports::foo::foo::flegs::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-flags`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheFlags::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheFlagsPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheFlagsPre::instantiate`] to
+///   create a [`TheFlags`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheFlags::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheFlagsIndices::new_instance`] followed
+///   by [`TheFlagsIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheFlags {
+    interface0: exports::foo::foo::flegs::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheFlagsIndices {
+        /// Creates a new copy of `TheFlagsIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::flegs::GuestIndices::new(_component)?;
+            Ok(TheFlagsIndices { interface0 })
+        }
+        /// Creates a new instance of [`TheFlagsIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheFlags`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheFlags`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::flegs::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(TheFlagsIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheFlags`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheFlags> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(TheFlags { interface0 })
+        }
+    }
+    impl TheFlags {
+        /// Convenience wrapper around [`TheFlagsPre::new`] and
+        /// [`TheFlagsPre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheFlags> {
+            let pre = linker.instantiate_pre(component)?;
+            TheFlagsPre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`TheFlagsIndices::new_instance`] and
+        /// [`TheFlagsIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheFlags> {
+            let indices = TheFlagsIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            U: foo::foo::flegs::Host,
+        {
+            foo::foo::flegs::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_flegs(&self) -> &exports::foo::foo::flegs::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod flegs {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            wasmtime::component::flags!(Flag1 { #[component(name = "b0")] const B0; });
+            const _: () = {
+                assert!(1 == < Flag1 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(1 == < Flag1 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            wasmtime::component::flags!(
+                Flag2 { #[component(name = "b0")] const B0; #[component(name = "b1")]
+                const B1; }
+            );
+            const _: () = {
+                assert!(1 == < Flag2 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(1 == < Flag2 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            wasmtime::component::flags!(
+                Flag4 { #[component(name = "b0")] const B0; #[component(name = "b1")]
+                const B1; #[component(name = "b2")] const B2; #[component(name = "b3")]
+                const B3; }
+            );
+            const _: () = {
+                assert!(1 == < Flag4 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(1 == < Flag4 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            wasmtime::component::flags!(
+                Flag8 { #[component(name = "b0")] const B0; #[component(name = "b1")]
+                const B1; #[component(name = "b2")] const B2; #[component(name = "b3")]
+                const B3; #[component(name = "b4")] const B4; #[component(name = "b5")]
+                const B5; #[component(name = "b6")] const B6; #[component(name = "b7")]
+                const B7; }
+            );
+            const _: () = {
+                assert!(1 == < Flag8 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(1 == < Flag8 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            wasmtime::component::flags!(
+                Flag16 { #[component(name = "b0")] const B0; #[component(name = "b1")]
+                const B1; #[component(name = "b2")] const B2; #[component(name = "b3")]
+                const B3; #[component(name = "b4")] const B4; #[component(name = "b5")]
+                const B5; #[component(name = "b6")] const B6; #[component(name = "b7")]
+                const B7; #[component(name = "b8")] const B8; #[component(name = "b9")]
+                const B9; #[component(name = "b10")] const B10; #[component(name =
+                "b11")] const B11; #[component(name = "b12")] const B12; #[component(name
+                = "b13")] const B13; #[component(name = "b14")] const B14;
+                #[component(name = "b15")] const B15; }
+            );
+            const _: () = {
+                assert!(2 == < Flag16 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(2 == < Flag16 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            wasmtime::component::flags!(
+                Flag32 { #[component(name = "b0")] const B0; #[component(name = "b1")]
+                const B1; #[component(name = "b2")] const B2; #[component(name = "b3")]
+                const B3; #[component(name = "b4")] const B4; #[component(name = "b5")]
+                const B5; #[component(name = "b6")] const B6; #[component(name = "b7")]
+                const B7; #[component(name = "b8")] const B8; #[component(name = "b9")]
+                const B9; #[component(name = "b10")] const B10; #[component(name =
+                "b11")] const B11; #[component(name = "b12")] const B12; #[component(name
+                = "b13")] const B13; #[component(name = "b14")] const B14;
+                #[component(name = "b15")] const B15; #[component(name = "b16")] const
+                B16; #[component(name = "b17")] const B17; #[component(name = "b18")]
+                const B18; #[component(name = "b19")] const B19; #[component(name =
+                "b20")] const B20; #[component(name = "b21")] const B21; #[component(name
+                = "b22")] const B22; #[component(name = "b23")] const B23;
+                #[component(name = "b24")] const B24; #[component(name = "b25")] const
+                B25; #[component(name = "b26")] const B26; #[component(name = "b27")]
+                const B27; #[component(name = "b28")] const B28; #[component(name =
+                "b29")] const B29; #[component(name = "b30")] const B30; #[component(name
+                = "b31")] const B31; }
+            );
+            const _: () = {
+                assert!(4 == < Flag32 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(4 == < Flag32 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            wasmtime::component::flags!(
+                Flag64 { #[component(name = "b0")] const B0; #[component(name = "b1")]
+                const B1; #[component(name = "b2")] const B2; #[component(name = "b3")]
+                const B3; #[component(name = "b4")] const B4; #[component(name = "b5")]
+                const B5; #[component(name = "b6")] const B6; #[component(name = "b7")]
+                const B7; #[component(name = "b8")] const B8; #[component(name = "b9")]
+                const B9; #[component(name = "b10")] const B10; #[component(name =
+                "b11")] const B11; #[component(name = "b12")] const B12; #[component(name
+                = "b13")] const B13; #[component(name = "b14")] const B14;
+                #[component(name = "b15")] const B15; #[component(name = "b16")] const
+                B16; #[component(name = "b17")] const B17; #[component(name = "b18")]
+                const B18; #[component(name = "b19")] const B19; #[component(name =
+                "b20")] const B20; #[component(name = "b21")] const B21; #[component(name
+                = "b22")] const B22; #[component(name = "b23")] const B23;
+                #[component(name = "b24")] const B24; #[component(name = "b25")] const
+                B25; #[component(name = "b26")] const B26; #[component(name = "b27")]
+                const B27; #[component(name = "b28")] const B28; #[component(name =
+                "b29")] const B29; #[component(name = "b30")] const B30; #[component(name
+                = "b31")] const B31; #[component(name = "b32")] const B32;
+                #[component(name = "b33")] const B33; #[component(name = "b34")] const
+                B34; #[component(name = "b35")] const B35; #[component(name = "b36")]
+                const B36; #[component(name = "b37")] const B37; #[component(name =
+                "b38")] const B38; #[component(name = "b39")] const B39; #[component(name
+                = "b40")] const B40; #[component(name = "b41")] const B41;
+                #[component(name = "b42")] const B42; #[component(name = "b43")] const
+                B43; #[component(name = "b44")] const B44; #[component(name = "b45")]
+                const B45; #[component(name = "b46")] const B46; #[component(name =
+                "b47")] const B47; #[component(name = "b48")] const B48; #[component(name
+                = "b49")] const B49; #[component(name = "b50")] const B50;
+                #[component(name = "b51")] const B51; #[component(name = "b52")] const
+                B52; #[component(name = "b53")] const B53; #[component(name = "b54")]
+                const B54; #[component(name = "b55")] const B55; #[component(name =
+                "b56")] const B56; #[component(name = "b57")] const B57; #[component(name
+                = "b58")] const B58; #[component(name = "b59")] const B59;
+                #[component(name = "b60")] const B60; #[component(name = "b61")] const
+                B61; #[component(name = "b62")] const B62; #[component(name = "b63")]
+                const B63; }
+            );
+            const _: () = {
+                assert!(8 == < Flag64 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(4 == < Flag64 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            pub trait Host {
+                fn roundtrip_flag1(&mut self, x: Flag1) -> Flag1;
+                fn roundtrip_flag2(&mut self, x: Flag2) -> Flag2;
+                fn roundtrip_flag4(&mut self, x: Flag4) -> Flag4;
+                fn roundtrip_flag8(&mut self, x: Flag8) -> Flag8;
+                fn roundtrip_flag16(&mut self, x: Flag16) -> Flag16;
+                fn roundtrip_flag32(&mut self, x: Flag32) -> Flag32;
+                fn roundtrip_flag64(&mut self, x: Flag64) -> Flag64;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/flegs")?;
+                inst.func_wrap(
+                    "roundtrip-flag1",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (Flag1,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::roundtrip_flag1(host, arg0);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "roundtrip-flag2",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (Flag2,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::roundtrip_flag2(host, arg0);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "roundtrip-flag4",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (Flag4,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::roundtrip_flag4(host, arg0);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "roundtrip-flag8",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (Flag8,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::roundtrip_flag8(host, arg0);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "roundtrip-flag16",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (Flag16,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::roundtrip_flag16(host, arg0);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "roundtrip-flag32",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (Flag32,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::roundtrip_flag32(host, arg0);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "roundtrip-flag64",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (Flag64,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::roundtrip_flag64(host, arg0);
+                        Ok((r,))
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {
+                fn roundtrip_flag1(&mut self, x: Flag1) -> Flag1 {
+                    Host::roundtrip_flag1(*self, x)
+                }
+                fn roundtrip_flag2(&mut self, x: Flag2) -> Flag2 {
+                    Host::roundtrip_flag2(*self, x)
+                }
+                fn roundtrip_flag4(&mut self, x: Flag4) -> Flag4 {
+                    Host::roundtrip_flag4(*self, x)
+                }
+                fn roundtrip_flag8(&mut self, x: Flag8) -> Flag8 {
+                    Host::roundtrip_flag8(*self, x)
+                }
+                fn roundtrip_flag16(&mut self, x: Flag16) -> Flag16 {
+                    Host::roundtrip_flag16(*self, x)
+                }
+                fn roundtrip_flag32(&mut self, x: Flag32) -> Flag32 {
+                    Host::roundtrip_flag32(*self, x)
+                }
+                fn roundtrip_flag64(&mut self, x: Flag64) -> Flag64 {
+                    Host::roundtrip_flag64(*self, x)
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod flegs {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                wasmtime::component::flags!(
+                    Flag1 { #[component(name = "b0")] const B0; }
+                );
+                const _: () = {
+                    assert!(
+                        1 == < Flag1 as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        1 == < Flag1 as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                wasmtime::component::flags!(
+                    Flag2 { #[component(name = "b0")] const B0; #[component(name = "b1")]
+                    const B1; }
+                );
+                const _: () = {
+                    assert!(
+                        1 == < Flag2 as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        1 == < Flag2 as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                wasmtime::component::flags!(
+                    Flag4 { #[component(name = "b0")] const B0; #[component(name = "b1")]
+                    const B1; #[component(name = "b2")] const B2; #[component(name =
+                    "b3")] const B3; }
+                );
+                const _: () = {
+                    assert!(
+                        1 == < Flag4 as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        1 == < Flag4 as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                wasmtime::component::flags!(
+                    Flag8 { #[component(name = "b0")] const B0; #[component(name = "b1")]
+                    const B1; #[component(name = "b2")] const B2; #[component(name =
+                    "b3")] const B3; #[component(name = "b4")] const B4; #[component(name
+                    = "b5")] const B5; #[component(name = "b6")] const B6;
+                    #[component(name = "b7")] const B7; }
+                );
+                const _: () = {
+                    assert!(
+                        1 == < Flag8 as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        1 == < Flag8 as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                wasmtime::component::flags!(
+                    Flag16 { #[component(name = "b0")] const B0; #[component(name =
+                    "b1")] const B1; #[component(name = "b2")] const B2; #[component(name
+                    = "b3")] const B3; #[component(name = "b4")] const B4;
+                    #[component(name = "b5")] const B5; #[component(name = "b6")] const
+                    B6; #[component(name = "b7")] const B7; #[component(name = "b8")]
+                    const B8; #[component(name = "b9")] const B9; #[component(name =
+                    "b10")] const B10; #[component(name = "b11")] const B11;
+                    #[component(name = "b12")] const B12; #[component(name = "b13")]
+                    const B13; #[component(name = "b14")] const B14; #[component(name =
+                    "b15")] const B15; }
+                );
+                const _: () = {
+                    assert!(
+                        2 == < Flag16 as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        2 == < Flag16 as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                wasmtime::component::flags!(
+                    Flag32 { #[component(name = "b0")] const B0; #[component(name =
+                    "b1")] const B1; #[component(name = "b2")] const B2; #[component(name
+                    = "b3")] const B3; #[component(name = "b4")] const B4;
+                    #[component(name = "b5")] const B5; #[component(name = "b6")] const
+                    B6; #[component(name = "b7")] const B7; #[component(name = "b8")]
+                    const B8; #[component(name = "b9")] const B9; #[component(name =
+                    "b10")] const B10; #[component(name = "b11")] const B11;
+                    #[component(name = "b12")] const B12; #[component(name = "b13")]
+                    const B13; #[component(name = "b14")] const B14; #[component(name =
+                    "b15")] const B15; #[component(name = "b16")] const B16;
+                    #[component(name = "b17")] const B17; #[component(name = "b18")]
+                    const B18; #[component(name = "b19")] const B19; #[component(name =
+                    "b20")] const B20; #[component(name = "b21")] const B21;
+                    #[component(name = "b22")] const B22; #[component(name = "b23")]
+                    const B23; #[component(name = "b24")] const B24; #[component(name =
+                    "b25")] const B25; #[component(name = "b26")] const B26;
+                    #[component(name = "b27")] const B27; #[component(name = "b28")]
+                    const B28; #[component(name = "b29")] const B29; #[component(name =
+                    "b30")] const B30; #[component(name = "b31")] const B31; }
+                );
+                const _: () = {
+                    assert!(
+                        4 == < Flag32 as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        4 == < Flag32 as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                wasmtime::component::flags!(
+                    Flag64 { #[component(name = "b0")] const B0; #[component(name =
+                    "b1")] const B1; #[component(name = "b2")] const B2; #[component(name
+                    = "b3")] const B3; #[component(name = "b4")] const B4;
+                    #[component(name = "b5")] const B5; #[component(name = "b6")] const
+                    B6; #[component(name = "b7")] const B7; #[component(name = "b8")]
+                    const B8; #[component(name = "b9")] const B9; #[component(name =
+                    "b10")] const B10; #[component(name = "b11")] const B11;
+                    #[component(name = "b12")] const B12; #[component(name = "b13")]
+                    const B13; #[component(name = "b14")] const B14; #[component(name =
+                    "b15")] const B15; #[component(name = "b16")] const B16;
+                    #[component(name = "b17")] const B17; #[component(name = "b18")]
+                    const B18; #[component(name = "b19")] const B19; #[component(name =
+                    "b20")] const B20; #[component(name = "b21")] const B21;
+                    #[component(name = "b22")] const B22; #[component(name = "b23")]
+                    const B23; #[component(name = "b24")] const B24; #[component(name =
+                    "b25")] const B25; #[component(name = "b26")] const B26;
+                    #[component(name = "b27")] const B27; #[component(name = "b28")]
+                    const B28; #[component(name = "b29")] const B29; #[component(name =
+                    "b30")] const B30; #[component(name = "b31")] const B31;
+                    #[component(name = "b32")] const B32; #[component(name = "b33")]
+                    const B33; #[component(name = "b34")] const B34; #[component(name =
+                    "b35")] const B35; #[component(name = "b36")] const B36;
+                    #[component(name = "b37")] const B37; #[component(name = "b38")]
+                    const B38; #[component(name = "b39")] const B39; #[component(name =
+                    "b40")] const B40; #[component(name = "b41")] const B41;
+                    #[component(name = "b42")] const B42; #[component(name = "b43")]
+                    const B43; #[component(name = "b44")] const B44; #[component(name =
+                    "b45")] const B45; #[component(name = "b46")] const B46;
+                    #[component(name = "b47")] const B47; #[component(name = "b48")]
+                    const B48; #[component(name = "b49")] const B49; #[component(name =
+                    "b50")] const B50; #[component(name = "b51")] const B51;
+                    #[component(name = "b52")] const B52; #[component(name = "b53")]
+                    const B53; #[component(name = "b54")] const B54; #[component(name =
+                    "b55")] const B55; #[component(name = "b56")] const B56;
+                    #[component(name = "b57")] const B57; #[component(name = "b58")]
+                    const B58; #[component(name = "b59")] const B59; #[component(name =
+                    "b60")] const B60; #[component(name = "b61")] const B61;
+                    #[component(name = "b62")] const B62; #[component(name = "b63")]
+                    const B63; }
+                );
+                const _: () = {
+                    assert!(
+                        8 == < Flag64 as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        4 == < Flag64 as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                pub struct Guest {
+                    roundtrip_flag1: wasmtime::component::Func,
+                    roundtrip_flag2: wasmtime::component::Func,
+                    roundtrip_flag4: wasmtime::component::Func,
+                    roundtrip_flag8: wasmtime::component::Func,
+                    roundtrip_flag16: wasmtime::component::Func,
+                    roundtrip_flag32: wasmtime::component::Func,
+                    roundtrip_flag64: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    roundtrip_flag1: wasmtime::component::ComponentExportIndex,
+                    roundtrip_flag2: wasmtime::component::ComponentExportIndex,
+                    roundtrip_flag4: wasmtime::component::ComponentExportIndex,
+                    roundtrip_flag8: wasmtime::component::ComponentExportIndex,
+                    roundtrip_flag16: wasmtime::component::ComponentExportIndex,
+                    roundtrip_flag32: wasmtime::component::ComponentExportIndex,
+                    roundtrip_flag64: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/flegs")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/flegs`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/flegs")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/flegs`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/flegs` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let roundtrip_flag1 = lookup("roundtrip-flag1")?;
+                        let roundtrip_flag2 = lookup("roundtrip-flag2")?;
+                        let roundtrip_flag4 = lookup("roundtrip-flag4")?;
+                        let roundtrip_flag8 = lookup("roundtrip-flag8")?;
+                        let roundtrip_flag16 = lookup("roundtrip-flag16")?;
+                        let roundtrip_flag32 = lookup("roundtrip-flag32")?;
+                        let roundtrip_flag64 = lookup("roundtrip-flag64")?;
+                        Ok(GuestIndices {
+                            roundtrip_flag1,
+                            roundtrip_flag2,
+                            roundtrip_flag4,
+                            roundtrip_flag8,
+                            roundtrip_flag16,
+                            roundtrip_flag32,
+                            roundtrip_flag64,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let roundtrip_flag1 = *_instance
+                            .get_typed_func::<
+                                (Flag1,),
+                                (Flag1,),
+                            >(&mut store, &self.roundtrip_flag1)?
+                            .func();
+                        let roundtrip_flag2 = *_instance
+                            .get_typed_func::<
+                                (Flag2,),
+                                (Flag2,),
+                            >(&mut store, &self.roundtrip_flag2)?
+                            .func();
+                        let roundtrip_flag4 = *_instance
+                            .get_typed_func::<
+                                (Flag4,),
+                                (Flag4,),
+                            >(&mut store, &self.roundtrip_flag4)?
+                            .func();
+                        let roundtrip_flag8 = *_instance
+                            .get_typed_func::<
+                                (Flag8,),
+                                (Flag8,),
+                            >(&mut store, &self.roundtrip_flag8)?
+                            .func();
+                        let roundtrip_flag16 = *_instance
+                            .get_typed_func::<
+                                (Flag16,),
+                                (Flag16,),
+                            >(&mut store, &self.roundtrip_flag16)?
+                            .func();
+                        let roundtrip_flag32 = *_instance
+                            .get_typed_func::<
+                                (Flag32,),
+                                (Flag32,),
+                            >(&mut store, &self.roundtrip_flag32)?
+                            .func();
+                        let roundtrip_flag64 = *_instance
+                            .get_typed_func::<
+                                (Flag64,),
+                                (Flag64,),
+                            >(&mut store, &self.roundtrip_flag64)?
+                            .func();
+                        Ok(Guest {
+                            roundtrip_flag1,
+                            roundtrip_flag2,
+                            roundtrip_flag4,
+                            roundtrip_flag8,
+                            roundtrip_flag16,
+                            roundtrip_flag32,
+                            roundtrip_flag64,
+                        })
+                    }
+                }
+                impl Guest {
+                    pub fn call_roundtrip_flag1<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: Flag1,
+                    ) -> wasmtime::Result<Flag1> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (Flag1,),
+                                (Flag1,),
+                            >::new_unchecked(self.roundtrip_flag1)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_roundtrip_flag2<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: Flag2,
+                    ) -> wasmtime::Result<Flag2> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (Flag2,),
+                                (Flag2,),
+                            >::new_unchecked(self.roundtrip_flag2)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_roundtrip_flag4<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: Flag4,
+                    ) -> wasmtime::Result<Flag4> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (Flag4,),
+                                (Flag4,),
+                            >::new_unchecked(self.roundtrip_flag4)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_roundtrip_flag8<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: Flag8,
+                    ) -> wasmtime::Result<Flag8> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (Flag8,),
+                                (Flag8,),
+                            >::new_unchecked(self.roundtrip_flag8)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_roundtrip_flag16<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: Flag16,
+                    ) -> wasmtime::Result<Flag16> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (Flag16,),
+                                (Flag16,),
+                            >::new_unchecked(self.roundtrip_flag16)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_roundtrip_flag32<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: Flag32,
+                    ) -> wasmtime::Result<Flag32> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (Flag32,),
+                                (Flag32,),
+                            >::new_unchecked(self.roundtrip_flag32)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_roundtrip_flag64<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: Flag64,
+                    ) -> wasmtime::Result<Flag64> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (Flag64,),
+                                (Flag64,),
+                            >::new_unchecked(self.roundtrip_flag64)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/flags_async.rs b/crates/component-macro/tests/expanded/flags_async.rs
new file mode 100644
index 000000000000..4ac5814dab67
--- /dev/null
+++ b/crates/component-macro/tests/expanded/flags_async.rs
@@ -0,0 +1,907 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-flags`.
+///
+/// This structure is created through [`TheFlagsPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheFlags`] as well.
+pub struct TheFlagsPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheFlagsIndices,
+}
+impl<T> Clone for TheFlagsPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheFlagsPre<_T> {
+    /// Creates a new copy of `TheFlagsPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheFlagsIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheFlags`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheFlags>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-flags`.
+///
+/// This is an implementation detail of [`TheFlagsPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheFlags`] as well.
+#[derive(Clone)]
+pub struct TheFlagsIndices {
+    interface0: exports::foo::foo::flegs::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-flags`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheFlags::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheFlagsPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheFlagsPre::instantiate_async`] to
+///   create a [`TheFlags`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheFlags::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheFlagsIndices::new_instance`] followed
+///   by [`TheFlagsIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheFlags {
+    interface0: exports::foo::foo::flegs::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheFlagsIndices {
+        /// Creates a new copy of `TheFlagsIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::flegs::GuestIndices::new(_component)?;
+            Ok(TheFlagsIndices { interface0 })
+        }
+        /// Creates a new instance of [`TheFlagsIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheFlags`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheFlags`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::flegs::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(TheFlagsIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheFlags`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheFlags> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(TheFlags { interface0 })
+        }
+    }
+    impl TheFlags {
+        /// Convenience wrapper around [`TheFlagsPre::new`] and
+        /// [`TheFlagsPre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheFlags>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            TheFlagsPre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`TheFlagsIndices::new_instance`] and
+        /// [`TheFlagsIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheFlags> {
+            let indices = TheFlagsIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+            U: foo::foo::flegs::Host + Send,
+        {
+            foo::foo::flegs::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_flegs(&self) -> &exports::foo::foo::flegs::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod flegs {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            wasmtime::component::flags!(Flag1 { #[component(name = "b0")] const B0; });
+            const _: () = {
+                assert!(1 == < Flag1 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(1 == < Flag1 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            wasmtime::component::flags!(
+                Flag2 { #[component(name = "b0")] const B0; #[component(name = "b1")]
+                const B1; }
+            );
+            const _: () = {
+                assert!(1 == < Flag2 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(1 == < Flag2 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            wasmtime::component::flags!(
+                Flag4 { #[component(name = "b0")] const B0; #[component(name = "b1")]
+                const B1; #[component(name = "b2")] const B2; #[component(name = "b3")]
+                const B3; }
+            );
+            const _: () = {
+                assert!(1 == < Flag4 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(1 == < Flag4 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            wasmtime::component::flags!(
+                Flag8 { #[component(name = "b0")] const B0; #[component(name = "b1")]
+                const B1; #[component(name = "b2")] const B2; #[component(name = "b3")]
+                const B3; #[component(name = "b4")] const B4; #[component(name = "b5")]
+                const B5; #[component(name = "b6")] const B6; #[component(name = "b7")]
+                const B7; }
+            );
+            const _: () = {
+                assert!(1 == < Flag8 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(1 == < Flag8 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            wasmtime::component::flags!(
+                Flag16 { #[component(name = "b0")] const B0; #[component(name = "b1")]
+                const B1; #[component(name = "b2")] const B2; #[component(name = "b3")]
+                const B3; #[component(name = "b4")] const B4; #[component(name = "b5")]
+                const B5; #[component(name = "b6")] const B6; #[component(name = "b7")]
+                const B7; #[component(name = "b8")] const B8; #[component(name = "b9")]
+                const B9; #[component(name = "b10")] const B10; #[component(name =
+                "b11")] const B11; #[component(name = "b12")] const B12; #[component(name
+                = "b13")] const B13; #[component(name = "b14")] const B14;
+                #[component(name = "b15")] const B15; }
+            );
+            const _: () = {
+                assert!(2 == < Flag16 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(2 == < Flag16 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            wasmtime::component::flags!(
+                Flag32 { #[component(name = "b0")] const B0; #[component(name = "b1")]
+                const B1; #[component(name = "b2")] const B2; #[component(name = "b3")]
+                const B3; #[component(name = "b4")] const B4; #[component(name = "b5")]
+                const B5; #[component(name = "b6")] const B6; #[component(name = "b7")]
+                const B7; #[component(name = "b8")] const B8; #[component(name = "b9")]
+                const B9; #[component(name = "b10")] const B10; #[component(name =
+                "b11")] const B11; #[component(name = "b12")] const B12; #[component(name
+                = "b13")] const B13; #[component(name = "b14")] const B14;
+                #[component(name = "b15")] const B15; #[component(name = "b16")] const
+                B16; #[component(name = "b17")] const B17; #[component(name = "b18")]
+                const B18; #[component(name = "b19")] const B19; #[component(name =
+                "b20")] const B20; #[component(name = "b21")] const B21; #[component(name
+                = "b22")] const B22; #[component(name = "b23")] const B23;
+                #[component(name = "b24")] const B24; #[component(name = "b25")] const
+                B25; #[component(name = "b26")] const B26; #[component(name = "b27")]
+                const B27; #[component(name = "b28")] const B28; #[component(name =
+                "b29")] const B29; #[component(name = "b30")] const B30; #[component(name
+                = "b31")] const B31; }
+            );
+            const _: () = {
+                assert!(4 == < Flag32 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(4 == < Flag32 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            wasmtime::component::flags!(
+                Flag64 { #[component(name = "b0")] const B0; #[component(name = "b1")]
+                const B1; #[component(name = "b2")] const B2; #[component(name = "b3")]
+                const B3; #[component(name = "b4")] const B4; #[component(name = "b5")]
+                const B5; #[component(name = "b6")] const B6; #[component(name = "b7")]
+                const B7; #[component(name = "b8")] const B8; #[component(name = "b9")]
+                const B9; #[component(name = "b10")] const B10; #[component(name =
+                "b11")] const B11; #[component(name = "b12")] const B12; #[component(name
+                = "b13")] const B13; #[component(name = "b14")] const B14;
+                #[component(name = "b15")] const B15; #[component(name = "b16")] const
+                B16; #[component(name = "b17")] const B17; #[component(name = "b18")]
+                const B18; #[component(name = "b19")] const B19; #[component(name =
+                "b20")] const B20; #[component(name = "b21")] const B21; #[component(name
+                = "b22")] const B22; #[component(name = "b23")] const B23;
+                #[component(name = "b24")] const B24; #[component(name = "b25")] const
+                B25; #[component(name = "b26")] const B26; #[component(name = "b27")]
+                const B27; #[component(name = "b28")] const B28; #[component(name =
+                "b29")] const B29; #[component(name = "b30")] const B30; #[component(name
+                = "b31")] const B31; #[component(name = "b32")] const B32;
+                #[component(name = "b33")] const B33; #[component(name = "b34")] const
+                B34; #[component(name = "b35")] const B35; #[component(name = "b36")]
+                const B36; #[component(name = "b37")] const B37; #[component(name =
+                "b38")] const B38; #[component(name = "b39")] const B39; #[component(name
+                = "b40")] const B40; #[component(name = "b41")] const B41;
+                #[component(name = "b42")] const B42; #[component(name = "b43")] const
+                B43; #[component(name = "b44")] const B44; #[component(name = "b45")]
+                const B45; #[component(name = "b46")] const B46; #[component(name =
+                "b47")] const B47; #[component(name = "b48")] const B48; #[component(name
+                = "b49")] const B49; #[component(name = "b50")] const B50;
+                #[component(name = "b51")] const B51; #[component(name = "b52")] const
+                B52; #[component(name = "b53")] const B53; #[component(name = "b54")]
+                const B54; #[component(name = "b55")] const B55; #[component(name =
+                "b56")] const B56; #[component(name = "b57")] const B57; #[component(name
+                = "b58")] const B58; #[component(name = "b59")] const B59;
+                #[component(name = "b60")] const B60; #[component(name = "b61")] const
+                B61; #[component(name = "b62")] const B62; #[component(name = "b63")]
+                const B63; }
+            );
+            const _: () = {
+                assert!(8 == < Flag64 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(4 == < Flag64 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {
+                async fn roundtrip_flag1(&mut self, x: Flag1) -> Flag1;
+                async fn roundtrip_flag2(&mut self, x: Flag2) -> Flag2;
+                async fn roundtrip_flag4(&mut self, x: Flag4) -> Flag4;
+                async fn roundtrip_flag8(&mut self, x: Flag8) -> Flag8;
+                async fn roundtrip_flag16(&mut self, x: Flag16) -> Flag16;
+                async fn roundtrip_flag32(&mut self, x: Flag32) -> Flag32;
+                async fn roundtrip_flag64(&mut self, x: Flag64) -> Flag64;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/flegs")?;
+                inst.func_wrap_async(
+                    "roundtrip-flag1",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (Flag1,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::roundtrip_flag1(host, arg0).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "roundtrip-flag2",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (Flag2,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::roundtrip_flag2(host, arg0).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "roundtrip-flag4",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (Flag4,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::roundtrip_flag4(host, arg0).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "roundtrip-flag8",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (Flag8,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::roundtrip_flag8(host, arg0).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "roundtrip-flag16",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (Flag16,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::roundtrip_flag16(host, arg0).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "roundtrip-flag32",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (Flag32,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::roundtrip_flag32(host, arg0).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "roundtrip-flag64",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (Flag64,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::roundtrip_flag64(host, arg0).await;
+                        Ok((r,))
+                    }),
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {
+                async fn roundtrip_flag1(&mut self, x: Flag1) -> Flag1 {
+                    Host::roundtrip_flag1(*self, x).await
+                }
+                async fn roundtrip_flag2(&mut self, x: Flag2) -> Flag2 {
+                    Host::roundtrip_flag2(*self, x).await
+                }
+                async fn roundtrip_flag4(&mut self, x: Flag4) -> Flag4 {
+                    Host::roundtrip_flag4(*self, x).await
+                }
+                async fn roundtrip_flag8(&mut self, x: Flag8) -> Flag8 {
+                    Host::roundtrip_flag8(*self, x).await
+                }
+                async fn roundtrip_flag16(&mut self, x: Flag16) -> Flag16 {
+                    Host::roundtrip_flag16(*self, x).await
+                }
+                async fn roundtrip_flag32(&mut self, x: Flag32) -> Flag32 {
+                    Host::roundtrip_flag32(*self, x).await
+                }
+                async fn roundtrip_flag64(&mut self, x: Flag64) -> Flag64 {
+                    Host::roundtrip_flag64(*self, x).await
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod flegs {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                wasmtime::component::flags!(
+                    Flag1 { #[component(name = "b0")] const B0; }
+                );
+                const _: () = {
+                    assert!(
+                        1 == < Flag1 as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        1 == < Flag1 as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                wasmtime::component::flags!(
+                    Flag2 { #[component(name = "b0")] const B0; #[component(name = "b1")]
+                    const B1; }
+                );
+                const _: () = {
+                    assert!(
+                        1 == < Flag2 as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        1 == < Flag2 as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                wasmtime::component::flags!(
+                    Flag4 { #[component(name = "b0")] const B0; #[component(name = "b1")]
+                    const B1; #[component(name = "b2")] const B2; #[component(name =
+                    "b3")] const B3; }
+                );
+                const _: () = {
+                    assert!(
+                        1 == < Flag4 as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        1 == < Flag4 as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                wasmtime::component::flags!(
+                    Flag8 { #[component(name = "b0")] const B0; #[component(name = "b1")]
+                    const B1; #[component(name = "b2")] const B2; #[component(name =
+                    "b3")] const B3; #[component(name = "b4")] const B4; #[component(name
+                    = "b5")] const B5; #[component(name = "b6")] const B6;
+                    #[component(name = "b7")] const B7; }
+                );
+                const _: () = {
+                    assert!(
+                        1 == < Flag8 as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        1 == < Flag8 as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                wasmtime::component::flags!(
+                    Flag16 { #[component(name = "b0")] const B0; #[component(name =
+                    "b1")] const B1; #[component(name = "b2")] const B2; #[component(name
+                    = "b3")] const B3; #[component(name = "b4")] const B4;
+                    #[component(name = "b5")] const B5; #[component(name = "b6")] const
+                    B6; #[component(name = "b7")] const B7; #[component(name = "b8")]
+                    const B8; #[component(name = "b9")] const B9; #[component(name =
+                    "b10")] const B10; #[component(name = "b11")] const B11;
+                    #[component(name = "b12")] const B12; #[component(name = "b13")]
+                    const B13; #[component(name = "b14")] const B14; #[component(name =
+                    "b15")] const B15; }
+                );
+                const _: () = {
+                    assert!(
+                        2 == < Flag16 as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        2 == < Flag16 as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                wasmtime::component::flags!(
+                    Flag32 { #[component(name = "b0")] const B0; #[component(name =
+                    "b1")] const B1; #[component(name = "b2")] const B2; #[component(name
+                    = "b3")] const B3; #[component(name = "b4")] const B4;
+                    #[component(name = "b5")] const B5; #[component(name = "b6")] const
+                    B6; #[component(name = "b7")] const B7; #[component(name = "b8")]
+                    const B8; #[component(name = "b9")] const B9; #[component(name =
+                    "b10")] const B10; #[component(name = "b11")] const B11;
+                    #[component(name = "b12")] const B12; #[component(name = "b13")]
+                    const B13; #[component(name = "b14")] const B14; #[component(name =
+                    "b15")] const B15; #[component(name = "b16")] const B16;
+                    #[component(name = "b17")] const B17; #[component(name = "b18")]
+                    const B18; #[component(name = "b19")] const B19; #[component(name =
+                    "b20")] const B20; #[component(name = "b21")] const B21;
+                    #[component(name = "b22")] const B22; #[component(name = "b23")]
+                    const B23; #[component(name = "b24")] const B24; #[component(name =
+                    "b25")] const B25; #[component(name = "b26")] const B26;
+                    #[component(name = "b27")] const B27; #[component(name = "b28")]
+                    const B28; #[component(name = "b29")] const B29; #[component(name =
+                    "b30")] const B30; #[component(name = "b31")] const B31; }
+                );
+                const _: () = {
+                    assert!(
+                        4 == < Flag32 as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        4 == < Flag32 as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                wasmtime::component::flags!(
+                    Flag64 { #[component(name = "b0")] const B0; #[component(name =
+                    "b1")] const B1; #[component(name = "b2")] const B2; #[component(name
+                    = "b3")] const B3; #[component(name = "b4")] const B4;
+                    #[component(name = "b5")] const B5; #[component(name = "b6")] const
+                    B6; #[component(name = "b7")] const B7; #[component(name = "b8")]
+                    const B8; #[component(name = "b9")] const B9; #[component(name =
+                    "b10")] const B10; #[component(name = "b11")] const B11;
+                    #[component(name = "b12")] const B12; #[component(name = "b13")]
+                    const B13; #[component(name = "b14")] const B14; #[component(name =
+                    "b15")] const B15; #[component(name = "b16")] const B16;
+                    #[component(name = "b17")] const B17; #[component(name = "b18")]
+                    const B18; #[component(name = "b19")] const B19; #[component(name =
+                    "b20")] const B20; #[component(name = "b21")] const B21;
+                    #[component(name = "b22")] const B22; #[component(name = "b23")]
+                    const B23; #[component(name = "b24")] const B24; #[component(name =
+                    "b25")] const B25; #[component(name = "b26")] const B26;
+                    #[component(name = "b27")] const B27; #[component(name = "b28")]
+                    const B28; #[component(name = "b29")] const B29; #[component(name =
+                    "b30")] const B30; #[component(name = "b31")] const B31;
+                    #[component(name = "b32")] const B32; #[component(name = "b33")]
+                    const B33; #[component(name = "b34")] const B34; #[component(name =
+                    "b35")] const B35; #[component(name = "b36")] const B36;
+                    #[component(name = "b37")] const B37; #[component(name = "b38")]
+                    const B38; #[component(name = "b39")] const B39; #[component(name =
+                    "b40")] const B40; #[component(name = "b41")] const B41;
+                    #[component(name = "b42")] const B42; #[component(name = "b43")]
+                    const B43; #[component(name = "b44")] const B44; #[component(name =
+                    "b45")] const B45; #[component(name = "b46")] const B46;
+                    #[component(name = "b47")] const B47; #[component(name = "b48")]
+                    const B48; #[component(name = "b49")] const B49; #[component(name =
+                    "b50")] const B50; #[component(name = "b51")] const B51;
+                    #[component(name = "b52")] const B52; #[component(name = "b53")]
+                    const B53; #[component(name = "b54")] const B54; #[component(name =
+                    "b55")] const B55; #[component(name = "b56")] const B56;
+                    #[component(name = "b57")] const B57; #[component(name = "b58")]
+                    const B58; #[component(name = "b59")] const B59; #[component(name =
+                    "b60")] const B60; #[component(name = "b61")] const B61;
+                    #[component(name = "b62")] const B62; #[component(name = "b63")]
+                    const B63; }
+                );
+                const _: () = {
+                    assert!(
+                        8 == < Flag64 as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        4 == < Flag64 as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                pub struct Guest {
+                    roundtrip_flag1: wasmtime::component::Func,
+                    roundtrip_flag2: wasmtime::component::Func,
+                    roundtrip_flag4: wasmtime::component::Func,
+                    roundtrip_flag8: wasmtime::component::Func,
+                    roundtrip_flag16: wasmtime::component::Func,
+                    roundtrip_flag32: wasmtime::component::Func,
+                    roundtrip_flag64: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    roundtrip_flag1: wasmtime::component::ComponentExportIndex,
+                    roundtrip_flag2: wasmtime::component::ComponentExportIndex,
+                    roundtrip_flag4: wasmtime::component::ComponentExportIndex,
+                    roundtrip_flag8: wasmtime::component::ComponentExportIndex,
+                    roundtrip_flag16: wasmtime::component::ComponentExportIndex,
+                    roundtrip_flag32: wasmtime::component::ComponentExportIndex,
+                    roundtrip_flag64: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/flegs")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/flegs`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/flegs")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/flegs`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/flegs` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let roundtrip_flag1 = lookup("roundtrip-flag1")?;
+                        let roundtrip_flag2 = lookup("roundtrip-flag2")?;
+                        let roundtrip_flag4 = lookup("roundtrip-flag4")?;
+                        let roundtrip_flag8 = lookup("roundtrip-flag8")?;
+                        let roundtrip_flag16 = lookup("roundtrip-flag16")?;
+                        let roundtrip_flag32 = lookup("roundtrip-flag32")?;
+                        let roundtrip_flag64 = lookup("roundtrip-flag64")?;
+                        Ok(GuestIndices {
+                            roundtrip_flag1,
+                            roundtrip_flag2,
+                            roundtrip_flag4,
+                            roundtrip_flag8,
+                            roundtrip_flag16,
+                            roundtrip_flag32,
+                            roundtrip_flag64,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let roundtrip_flag1 = *_instance
+                            .get_typed_func::<
+                                (Flag1,),
+                                (Flag1,),
+                            >(&mut store, &self.roundtrip_flag1)?
+                            .func();
+                        let roundtrip_flag2 = *_instance
+                            .get_typed_func::<
+                                (Flag2,),
+                                (Flag2,),
+                            >(&mut store, &self.roundtrip_flag2)?
+                            .func();
+                        let roundtrip_flag4 = *_instance
+                            .get_typed_func::<
+                                (Flag4,),
+                                (Flag4,),
+                            >(&mut store, &self.roundtrip_flag4)?
+                            .func();
+                        let roundtrip_flag8 = *_instance
+                            .get_typed_func::<
+                                (Flag8,),
+                                (Flag8,),
+                            >(&mut store, &self.roundtrip_flag8)?
+                            .func();
+                        let roundtrip_flag16 = *_instance
+                            .get_typed_func::<
+                                (Flag16,),
+                                (Flag16,),
+                            >(&mut store, &self.roundtrip_flag16)?
+                            .func();
+                        let roundtrip_flag32 = *_instance
+                            .get_typed_func::<
+                                (Flag32,),
+                                (Flag32,),
+                            >(&mut store, &self.roundtrip_flag32)?
+                            .func();
+                        let roundtrip_flag64 = *_instance
+                            .get_typed_func::<
+                                (Flag64,),
+                                (Flag64,),
+                            >(&mut store, &self.roundtrip_flag64)?
+                            .func();
+                        Ok(Guest {
+                            roundtrip_flag1,
+                            roundtrip_flag2,
+                            roundtrip_flag4,
+                            roundtrip_flag8,
+                            roundtrip_flag16,
+                            roundtrip_flag32,
+                            roundtrip_flag64,
+                        })
+                    }
+                }
+                impl Guest {
+                    pub async fn call_roundtrip_flag1<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: Flag1,
+                    ) -> wasmtime::Result<Flag1>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (Flag1,),
+                                (Flag1,),
+                            >::new_unchecked(self.roundtrip_flag1)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_roundtrip_flag2<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: Flag2,
+                    ) -> wasmtime::Result<Flag2>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (Flag2,),
+                                (Flag2,),
+                            >::new_unchecked(self.roundtrip_flag2)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_roundtrip_flag4<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: Flag4,
+                    ) -> wasmtime::Result<Flag4>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (Flag4,),
+                                (Flag4,),
+                            >::new_unchecked(self.roundtrip_flag4)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_roundtrip_flag8<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: Flag8,
+                    ) -> wasmtime::Result<Flag8>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (Flag8,),
+                                (Flag8,),
+                            >::new_unchecked(self.roundtrip_flag8)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_roundtrip_flag16<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: Flag16,
+                    ) -> wasmtime::Result<Flag16>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (Flag16,),
+                                (Flag16,),
+                            >::new_unchecked(self.roundtrip_flag16)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_roundtrip_flag32<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: Flag32,
+                    ) -> wasmtime::Result<Flag32>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (Flag32,),
+                                (Flag32,),
+                            >::new_unchecked(self.roundtrip_flag32)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_roundtrip_flag64<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: Flag64,
+                    ) -> wasmtime::Result<Flag64>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (Flag64,),
+                                (Flag64,),
+                            >::new_unchecked(self.roundtrip_flag64)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/floats.rs b/crates/component-macro/tests/expanded/floats.rs
new file mode 100644
index 000000000000..a56863d0e78c
--- /dev/null
+++ b/crates/component-macro/tests/expanded/floats.rs
@@ -0,0 +1,459 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-world`.
+///
+/// This structure is created through [`TheWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheWorld`] as well.
+pub struct TheWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheWorldIndices,
+}
+impl<T> Clone for TheWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheWorldPre<_T> {
+    /// Creates a new copy of `TheWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheWorld> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-world`.
+///
+/// This is an implementation detail of [`TheWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheWorld`] as well.
+#[derive(Clone)]
+pub struct TheWorldIndices {
+    interface0: exports::foo::foo::floats::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheWorld::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheWorldPre::instantiate`] to
+///   create a [`TheWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheWorldIndices::new_instance`] followed
+///   by [`TheWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheWorld {
+    interface0: exports::foo::foo::floats::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheWorldIndices {
+        /// Creates a new copy of `TheWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::floats::GuestIndices::new(_component)?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Creates a new instance of [`TheWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::floats::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(TheWorld { interface0 })
+        }
+    }
+    impl TheWorld {
+        /// Convenience wrapper around [`TheWorldPre::new`] and
+        /// [`TheWorldPre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheWorld> {
+            let pre = linker.instantiate_pre(component)?;
+            TheWorldPre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`TheWorldIndices::new_instance`] and
+        /// [`TheWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let indices = TheWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            U: foo::foo::floats::Host,
+        {
+            foo::foo::floats::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_floats(&self) -> &exports::foo::foo::floats::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod floats {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub trait Host {
+                fn float32_param(&mut self, x: f32) -> ();
+                fn float64_param(&mut self, x: f64) -> ();
+                fn float32_result(&mut self) -> f32;
+                fn float64_result(&mut self) -> f64;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/floats")?;
+                inst.func_wrap(
+                    "float32-param",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (f32,)| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::float32_param(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "float64-param",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (f64,)| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::float64_param(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "float32-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::float32_result(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "float64-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::float64_result(host);
+                        Ok((r,))
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {
+                fn float32_param(&mut self, x: f32) -> () {
+                    Host::float32_param(*self, x)
+                }
+                fn float64_param(&mut self, x: f64) -> () {
+                    Host::float64_param(*self, x)
+                }
+                fn float32_result(&mut self) -> f32 {
+                    Host::float32_result(*self)
+                }
+                fn float64_result(&mut self) -> f64 {
+                    Host::float64_result(*self)
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod floats {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub struct Guest {
+                    float32_param: wasmtime::component::Func,
+                    float64_param: wasmtime::component::Func,
+                    float32_result: wasmtime::component::Func,
+                    float64_result: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    float32_param: wasmtime::component::ComponentExportIndex,
+                    float64_param: wasmtime::component::ComponentExportIndex,
+                    float32_result: wasmtime::component::ComponentExportIndex,
+                    float64_result: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/floats")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/floats`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/floats")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/floats`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/floats` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let float32_param = lookup("float32-param")?;
+                        let float64_param = lookup("float64-param")?;
+                        let float32_result = lookup("float32-result")?;
+                        let float64_result = lookup("float64-result")?;
+                        Ok(GuestIndices {
+                            float32_param,
+                            float64_param,
+                            float32_result,
+                            float64_result,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let float32_param = *_instance
+                            .get_typed_func::<
+                                (f32,),
+                                (),
+                            >(&mut store, &self.float32_param)?
+                            .func();
+                        let float64_param = *_instance
+                            .get_typed_func::<
+                                (f64,),
+                                (),
+                            >(&mut store, &self.float64_param)?
+                            .func();
+                        let float32_result = *_instance
+                            .get_typed_func::<
+                                (),
+                                (f32,),
+                            >(&mut store, &self.float32_result)?
+                            .func();
+                        let float64_result = *_instance
+                            .get_typed_func::<
+                                (),
+                                (f64,),
+                            >(&mut store, &self.float64_result)?
+                            .func();
+                        Ok(Guest {
+                            float32_param,
+                            float64_param,
+                            float32_result,
+                            float64_result,
+                        })
+                    }
+                }
+                impl Guest {
+                    pub fn call_float32_param<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: f32,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (f32,),
+                                (),
+                            >::new_unchecked(self.float32_param)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_float64_param<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: f64,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (f64,),
+                                (),
+                            >::new_unchecked(self.float64_param)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_float32_result<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<f32> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (f32,),
+                            >::new_unchecked(self.float32_result)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_float64_result<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<f64> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (f64,),
+                            >::new_unchecked(self.float64_result)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/floats_async.rs b/crates/component-macro/tests/expanded/floats_async.rs
new file mode 100644
index 000000000000..9747e1cb6eab
--- /dev/null
+++ b/crates/component-macro/tests/expanded/floats_async.rs
@@ -0,0 +1,492 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-world`.
+///
+/// This structure is created through [`TheWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheWorld`] as well.
+pub struct TheWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheWorldIndices,
+}
+impl<T> Clone for TheWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheWorldPre<_T> {
+    /// Creates a new copy of `TheWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheWorld>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-world`.
+///
+/// This is an implementation detail of [`TheWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheWorld`] as well.
+#[derive(Clone)]
+pub struct TheWorldIndices {
+    interface0: exports::foo::foo::floats::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheWorld::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheWorldPre::instantiate_async`] to
+///   create a [`TheWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheWorldIndices::new_instance`] followed
+///   by [`TheWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheWorld {
+    interface0: exports::foo::foo::floats::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheWorldIndices {
+        /// Creates a new copy of `TheWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::floats::GuestIndices::new(_component)?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Creates a new instance of [`TheWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::floats::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(TheWorld { interface0 })
+        }
+    }
+    impl TheWorld {
+        /// Convenience wrapper around [`TheWorldPre::new`] and
+        /// [`TheWorldPre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheWorld>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            TheWorldPre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`TheWorldIndices::new_instance`] and
+        /// [`TheWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let indices = TheWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+            U: foo::foo::floats::Host + Send,
+        {
+            foo::foo::floats::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_floats(&self) -> &exports::foo::foo::floats::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod floats {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {
+                async fn float32_param(&mut self, x: f32) -> ();
+                async fn float64_param(&mut self, x: f64) -> ();
+                async fn float32_result(&mut self) -> f32;
+                async fn float64_result(&mut self) -> f64;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/floats")?;
+                inst.func_wrap_async(
+                    "float32-param",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (f32,)| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::float32_param(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "float64-param",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (f64,)| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::float64_param(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "float32-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::float32_result(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "float64-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::float64_result(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {
+                async fn float32_param(&mut self, x: f32) -> () {
+                    Host::float32_param(*self, x).await
+                }
+                async fn float64_param(&mut self, x: f64) -> () {
+                    Host::float64_param(*self, x).await
+                }
+                async fn float32_result(&mut self) -> f32 {
+                    Host::float32_result(*self).await
+                }
+                async fn float64_result(&mut self) -> f64 {
+                    Host::float64_result(*self).await
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod floats {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub struct Guest {
+                    float32_param: wasmtime::component::Func,
+                    float64_param: wasmtime::component::Func,
+                    float32_result: wasmtime::component::Func,
+                    float64_result: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    float32_param: wasmtime::component::ComponentExportIndex,
+                    float64_param: wasmtime::component::ComponentExportIndex,
+                    float32_result: wasmtime::component::ComponentExportIndex,
+                    float64_result: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/floats")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/floats`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/floats")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/floats`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/floats` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let float32_param = lookup("float32-param")?;
+                        let float64_param = lookup("float64-param")?;
+                        let float32_result = lookup("float32-result")?;
+                        let float64_result = lookup("float64-result")?;
+                        Ok(GuestIndices {
+                            float32_param,
+                            float64_param,
+                            float32_result,
+                            float64_result,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let float32_param = *_instance
+                            .get_typed_func::<
+                                (f32,),
+                                (),
+                            >(&mut store, &self.float32_param)?
+                            .func();
+                        let float64_param = *_instance
+                            .get_typed_func::<
+                                (f64,),
+                                (),
+                            >(&mut store, &self.float64_param)?
+                            .func();
+                        let float32_result = *_instance
+                            .get_typed_func::<
+                                (),
+                                (f32,),
+                            >(&mut store, &self.float32_result)?
+                            .func();
+                        let float64_result = *_instance
+                            .get_typed_func::<
+                                (),
+                                (f64,),
+                            >(&mut store, &self.float64_result)?
+                            .func();
+                        Ok(Guest {
+                            float32_param,
+                            float64_param,
+                            float32_result,
+                            float64_result,
+                        })
+                    }
+                }
+                impl Guest {
+                    pub async fn call_float32_param<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: f32,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (f32,),
+                                (),
+                            >::new_unchecked(self.float32_param)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_float64_param<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: f64,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (f64,),
+                                (),
+                            >::new_unchecked(self.float64_param)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_float32_result<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<f32>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (f32,),
+                            >::new_unchecked(self.float32_result)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_float64_result<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<f64>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (f64,),
+                            >::new_unchecked(self.float64_result)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/function-new.rs b/crates/component-macro/tests/expanded/function-new.rs
new file mode 100644
index 000000000000..ca37b6668473
--- /dev/null
+++ b/crates/component-macro/tests/expanded/function-new.rs
@@ -0,0 +1,182 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `foo`.
+///
+/// This structure is created through [`FooPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`Foo`] as well.
+pub struct FooPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: FooIndices,
+}
+impl<T> Clone for FooPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> FooPre<_T> {
+    /// Creates a new copy of `FooPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = FooIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`Foo`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<Foo> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `foo`.
+///
+/// This is an implementation detail of [`FooPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`Foo`] as well.
+#[derive(Clone)]
+pub struct FooIndices {
+    new: wasmtime::component::ComponentExportIndex,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `foo`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`Foo::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`FooPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`FooPre::instantiate`] to
+///   create a [`Foo`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`Foo::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`FooIndices::new_instance`] followed
+///   by [`FooIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct Foo {
+    new: wasmtime::component::Func,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl FooIndices {
+        /// Creates a new copy of `FooIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let new = _component
+                .export_index(None, "new")
+                .ok_or_else(|| anyhow::anyhow!("no function export `new` found"))?
+                .1;
+            Ok(FooIndices { new })
+        }
+        /// Creates a new instance of [`FooIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`Foo`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`Foo`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let new = _instance
+                .get_export(&mut store, None, "new")
+                .ok_or_else(|| anyhow::anyhow!("no function export `new` found"))?;
+            Ok(FooIndices { new })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`Foo`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Foo> {
+            let _instance = instance;
+            let new = *_instance.get_typed_func::<(), ()>(&mut store, &self.new)?.func();
+            Ok(Foo { new })
+        }
+    }
+    impl Foo {
+        /// Convenience wrapper around [`FooPre::new`] and
+        /// [`FooPre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<Foo> {
+            let pre = linker.instantiate_pre(component)?;
+            FooPre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`FooIndices::new_instance`] and
+        /// [`FooIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Foo> {
+            let indices = FooIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn call_new<S: wasmtime::AsContextMut>(
+            &self,
+            mut store: S,
+        ) -> wasmtime::Result<()> {
+            let callee = unsafe {
+                wasmtime::component::TypedFunc::<(), ()>::new_unchecked(self.new)
+            };
+            let () = callee.call(store.as_context_mut(), ())?;
+            callee.post_return(store.as_context_mut())?;
+            Ok(())
+        }
+    }
+};
diff --git a/crates/component-macro/tests/expanded/function-new_async.rs b/crates/component-macro/tests/expanded/function-new_async.rs
new file mode 100644
index 000000000000..38a06794f9a6
--- /dev/null
+++ b/crates/component-macro/tests/expanded/function-new_async.rs
@@ -0,0 +1,191 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `foo`.
+///
+/// This structure is created through [`FooPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`Foo`] as well.
+pub struct FooPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: FooIndices,
+}
+impl<T> Clone for FooPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> FooPre<_T> {
+    /// Creates a new copy of `FooPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = FooIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`Foo`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<Foo>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `foo`.
+///
+/// This is an implementation detail of [`FooPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`Foo`] as well.
+#[derive(Clone)]
+pub struct FooIndices {
+    new: wasmtime::component::ComponentExportIndex,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `foo`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`Foo::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`FooPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`FooPre::instantiate_async`] to
+///   create a [`Foo`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`Foo::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`FooIndices::new_instance`] followed
+///   by [`FooIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct Foo {
+    new: wasmtime::component::Func,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl FooIndices {
+        /// Creates a new copy of `FooIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let new = _component
+                .export_index(None, "new")
+                .ok_or_else(|| anyhow::anyhow!("no function export `new` found"))?
+                .1;
+            Ok(FooIndices { new })
+        }
+        /// Creates a new instance of [`FooIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`Foo`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`Foo`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let new = _instance
+                .get_export(&mut store, None, "new")
+                .ok_or_else(|| anyhow::anyhow!("no function export `new` found"))?;
+            Ok(FooIndices { new })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`Foo`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Foo> {
+            let _instance = instance;
+            let new = *_instance.get_typed_func::<(), ()>(&mut store, &self.new)?.func();
+            Ok(Foo { new })
+        }
+    }
+    impl Foo {
+        /// Convenience wrapper around [`FooPre::new`] and
+        /// [`FooPre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<Foo>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            FooPre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`FooIndices::new_instance`] and
+        /// [`FooIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Foo> {
+            let indices = FooIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub async fn call_new<S: wasmtime::AsContextMut>(
+            &self,
+            mut store: S,
+        ) -> wasmtime::Result<()>
+        where
+            <S as wasmtime::AsContext>::Data: Send,
+        {
+            let callee = unsafe {
+                wasmtime::component::TypedFunc::<(), ()>::new_unchecked(self.new)
+            };
+            let () = callee.call_async(store.as_context_mut(), ()).await?;
+            callee.post_return_async(store.as_context_mut()).await?;
+            Ok(())
+        }
+    }
+};
diff --git a/crates/component-macro/tests/expanded/integers.rs b/crates/component-macro/tests/expanded/integers.rs
new file mode 100644
index 000000000000..a0ea4d42e45e
--- /dev/null
+++ b/crates/component-macro/tests/expanded/integers.rs
@@ -0,0 +1,989 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-world`.
+///
+/// This structure is created through [`TheWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheWorld`] as well.
+pub struct TheWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheWorldIndices,
+}
+impl<T> Clone for TheWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheWorldPre<_T> {
+    /// Creates a new copy of `TheWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheWorld> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-world`.
+///
+/// This is an implementation detail of [`TheWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheWorld`] as well.
+#[derive(Clone)]
+pub struct TheWorldIndices {
+    interface0: exports::foo::foo::integers::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheWorld::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheWorldPre::instantiate`] to
+///   create a [`TheWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheWorldIndices::new_instance`] followed
+///   by [`TheWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheWorld {
+    interface0: exports::foo::foo::integers::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheWorldIndices {
+        /// Creates a new copy of `TheWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::integers::GuestIndices::new(_component)?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Creates a new instance of [`TheWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::integers::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(TheWorld { interface0 })
+        }
+    }
+    impl TheWorld {
+        /// Convenience wrapper around [`TheWorldPre::new`] and
+        /// [`TheWorldPre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheWorld> {
+            let pre = linker.instantiate_pre(component)?;
+            TheWorldPre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`TheWorldIndices::new_instance`] and
+        /// [`TheWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let indices = TheWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            U: foo::foo::integers::Host,
+        {
+            foo::foo::integers::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_integers(&self) -> &exports::foo::foo::integers::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod integers {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub trait Host {
+                fn a1(&mut self, x: u8) -> ();
+                fn a2(&mut self, x: i8) -> ();
+                fn a3(&mut self, x: u16) -> ();
+                fn a4(&mut self, x: i16) -> ();
+                fn a5(&mut self, x: u32) -> ();
+                fn a6(&mut self, x: i32) -> ();
+                fn a7(&mut self, x: u64) -> ();
+                fn a8(&mut self, x: i64) -> ();
+                fn a9(
+                    &mut self,
+                    p1: u8,
+                    p2: i8,
+                    p3: u16,
+                    p4: i16,
+                    p5: u32,
+                    p6: i32,
+                    p7: u64,
+                    p8: i64,
+                ) -> ();
+                fn r1(&mut self) -> u8;
+                fn r2(&mut self) -> i8;
+                fn r3(&mut self) -> u16;
+                fn r4(&mut self) -> i16;
+                fn r5(&mut self) -> u32;
+                fn r6(&mut self) -> i32;
+                fn r7(&mut self) -> u64;
+                fn r8(&mut self) -> i64;
+                fn pair_ret(&mut self) -> (i64, u8);
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/integers")?;
+                inst.func_wrap(
+                    "a1",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (u8,)| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::a1(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "a2",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (i8,)| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::a2(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "a3",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (u16,)| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::a3(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "a4",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (i16,)| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::a4(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "a5",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (u32,)| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::a5(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "a6",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (i32,)| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::a6(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "a7",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (u64,)| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::a7(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "a8",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (i64,)| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::a8(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "a9",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (
+                            arg0,
+                            arg1,
+                            arg2,
+                            arg3,
+                            arg4,
+                            arg5,
+                            arg6,
+                            arg7,
+                        ): (u8, i8, u16, i16, u32, i32, u64, i64)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::a9(
+                            host,
+                            arg0,
+                            arg1,
+                            arg2,
+                            arg3,
+                            arg4,
+                            arg5,
+                            arg6,
+                            arg7,
+                        );
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "r1",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::r1(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "r2",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::r2(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "r3",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::r3(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "r4",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::r4(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "r5",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::r5(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "r6",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::r6(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "r7",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::r7(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "r8",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::r8(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "pair-ret",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::pair_ret(host);
+                        Ok((r,))
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {
+                fn a1(&mut self, x: u8) -> () {
+                    Host::a1(*self, x)
+                }
+                fn a2(&mut self, x: i8) -> () {
+                    Host::a2(*self, x)
+                }
+                fn a3(&mut self, x: u16) -> () {
+                    Host::a3(*self, x)
+                }
+                fn a4(&mut self, x: i16) -> () {
+                    Host::a4(*self, x)
+                }
+                fn a5(&mut self, x: u32) -> () {
+                    Host::a5(*self, x)
+                }
+                fn a6(&mut self, x: i32) -> () {
+                    Host::a6(*self, x)
+                }
+                fn a7(&mut self, x: u64) -> () {
+                    Host::a7(*self, x)
+                }
+                fn a8(&mut self, x: i64) -> () {
+                    Host::a8(*self, x)
+                }
+                fn a9(
+                    &mut self,
+                    p1: u8,
+                    p2: i8,
+                    p3: u16,
+                    p4: i16,
+                    p5: u32,
+                    p6: i32,
+                    p7: u64,
+                    p8: i64,
+                ) -> () {
+                    Host::a9(*self, p1, p2, p3, p4, p5, p6, p7, p8)
+                }
+                fn r1(&mut self) -> u8 {
+                    Host::r1(*self)
+                }
+                fn r2(&mut self) -> i8 {
+                    Host::r2(*self)
+                }
+                fn r3(&mut self) -> u16 {
+                    Host::r3(*self)
+                }
+                fn r4(&mut self) -> i16 {
+                    Host::r4(*self)
+                }
+                fn r5(&mut self) -> u32 {
+                    Host::r5(*self)
+                }
+                fn r6(&mut self) -> i32 {
+                    Host::r6(*self)
+                }
+                fn r7(&mut self) -> u64 {
+                    Host::r7(*self)
+                }
+                fn r8(&mut self) -> i64 {
+                    Host::r8(*self)
+                }
+                fn pair_ret(&mut self) -> (i64, u8) {
+                    Host::pair_ret(*self)
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod integers {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub struct Guest {
+                    a1: wasmtime::component::Func,
+                    a2: wasmtime::component::Func,
+                    a3: wasmtime::component::Func,
+                    a4: wasmtime::component::Func,
+                    a5: wasmtime::component::Func,
+                    a6: wasmtime::component::Func,
+                    a7: wasmtime::component::Func,
+                    a8: wasmtime::component::Func,
+                    a9: wasmtime::component::Func,
+                    r1: wasmtime::component::Func,
+                    r2: wasmtime::component::Func,
+                    r3: wasmtime::component::Func,
+                    r4: wasmtime::component::Func,
+                    r5: wasmtime::component::Func,
+                    r6: wasmtime::component::Func,
+                    r7: wasmtime::component::Func,
+                    r8: wasmtime::component::Func,
+                    pair_ret: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    a1: wasmtime::component::ComponentExportIndex,
+                    a2: wasmtime::component::ComponentExportIndex,
+                    a3: wasmtime::component::ComponentExportIndex,
+                    a4: wasmtime::component::ComponentExportIndex,
+                    a5: wasmtime::component::ComponentExportIndex,
+                    a6: wasmtime::component::ComponentExportIndex,
+                    a7: wasmtime::component::ComponentExportIndex,
+                    a8: wasmtime::component::ComponentExportIndex,
+                    a9: wasmtime::component::ComponentExportIndex,
+                    r1: wasmtime::component::ComponentExportIndex,
+                    r2: wasmtime::component::ComponentExportIndex,
+                    r3: wasmtime::component::ComponentExportIndex,
+                    r4: wasmtime::component::ComponentExportIndex,
+                    r5: wasmtime::component::ComponentExportIndex,
+                    r6: wasmtime::component::ComponentExportIndex,
+                    r7: wasmtime::component::ComponentExportIndex,
+                    r8: wasmtime::component::ComponentExportIndex,
+                    pair_ret: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/integers")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/integers`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/integers")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/integers`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/integers` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let a1 = lookup("a1")?;
+                        let a2 = lookup("a2")?;
+                        let a3 = lookup("a3")?;
+                        let a4 = lookup("a4")?;
+                        let a5 = lookup("a5")?;
+                        let a6 = lookup("a6")?;
+                        let a7 = lookup("a7")?;
+                        let a8 = lookup("a8")?;
+                        let a9 = lookup("a9")?;
+                        let r1 = lookup("r1")?;
+                        let r2 = lookup("r2")?;
+                        let r3 = lookup("r3")?;
+                        let r4 = lookup("r4")?;
+                        let r5 = lookup("r5")?;
+                        let r6 = lookup("r6")?;
+                        let r7 = lookup("r7")?;
+                        let r8 = lookup("r8")?;
+                        let pair_ret = lookup("pair-ret")?;
+                        Ok(GuestIndices {
+                            a1,
+                            a2,
+                            a3,
+                            a4,
+                            a5,
+                            a6,
+                            a7,
+                            a8,
+                            a9,
+                            r1,
+                            r2,
+                            r3,
+                            r4,
+                            r5,
+                            r6,
+                            r7,
+                            r8,
+                            pair_ret,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let a1 = *_instance
+                            .get_typed_func::<(u8,), ()>(&mut store, &self.a1)?
+                            .func();
+                        let a2 = *_instance
+                            .get_typed_func::<(i8,), ()>(&mut store, &self.a2)?
+                            .func();
+                        let a3 = *_instance
+                            .get_typed_func::<(u16,), ()>(&mut store, &self.a3)?
+                            .func();
+                        let a4 = *_instance
+                            .get_typed_func::<(i16,), ()>(&mut store, &self.a4)?
+                            .func();
+                        let a5 = *_instance
+                            .get_typed_func::<(u32,), ()>(&mut store, &self.a5)?
+                            .func();
+                        let a6 = *_instance
+                            .get_typed_func::<(i32,), ()>(&mut store, &self.a6)?
+                            .func();
+                        let a7 = *_instance
+                            .get_typed_func::<(u64,), ()>(&mut store, &self.a7)?
+                            .func();
+                        let a8 = *_instance
+                            .get_typed_func::<(i64,), ()>(&mut store, &self.a8)?
+                            .func();
+                        let a9 = *_instance
+                            .get_typed_func::<
+                                (u8, i8, u16, i16, u32, i32, u64, i64),
+                                (),
+                            >(&mut store, &self.a9)?
+                            .func();
+                        let r1 = *_instance
+                            .get_typed_func::<(), (u8,)>(&mut store, &self.r1)?
+                            .func();
+                        let r2 = *_instance
+                            .get_typed_func::<(), (i8,)>(&mut store, &self.r2)?
+                            .func();
+                        let r3 = *_instance
+                            .get_typed_func::<(), (u16,)>(&mut store, &self.r3)?
+                            .func();
+                        let r4 = *_instance
+                            .get_typed_func::<(), (i16,)>(&mut store, &self.r4)?
+                            .func();
+                        let r5 = *_instance
+                            .get_typed_func::<(), (u32,)>(&mut store, &self.r5)?
+                            .func();
+                        let r6 = *_instance
+                            .get_typed_func::<(), (i32,)>(&mut store, &self.r6)?
+                            .func();
+                        let r7 = *_instance
+                            .get_typed_func::<(), (u64,)>(&mut store, &self.r7)?
+                            .func();
+                        let r8 = *_instance
+                            .get_typed_func::<(), (i64,)>(&mut store, &self.r8)?
+                            .func();
+                        let pair_ret = *_instance
+                            .get_typed_func::<
+                                (),
+                                ((i64, u8),),
+                            >(&mut store, &self.pair_ret)?
+                            .func();
+                        Ok(Guest {
+                            a1,
+                            a2,
+                            a3,
+                            a4,
+                            a5,
+                            a6,
+                            a7,
+                            a8,
+                            a9,
+                            r1,
+                            r2,
+                            r3,
+                            r4,
+                            r5,
+                            r6,
+                            r7,
+                            r8,
+                            pair_ret,
+                        })
+                    }
+                }
+                impl Guest {
+                    pub fn call_a1<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: u8,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (u8,),
+                                (),
+                            >::new_unchecked(self.a1)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_a2<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: i8,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (i8,),
+                                (),
+                            >::new_unchecked(self.a2)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_a3<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: u16,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (u16,),
+                                (),
+                            >::new_unchecked(self.a3)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_a4<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: i16,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (i16,),
+                                (),
+                            >::new_unchecked(self.a4)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_a5<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: u32,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (u32,),
+                                (),
+                            >::new_unchecked(self.a5)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_a6<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: i32,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (i32,),
+                                (),
+                            >::new_unchecked(self.a6)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_a7<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: u64,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (u64,),
+                                (),
+                            >::new_unchecked(self.a7)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_a8<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: i64,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (i64,),
+                                (),
+                            >::new_unchecked(self.a8)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_a9<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: u8,
+                        arg1: i8,
+                        arg2: u16,
+                        arg3: i16,
+                        arg4: u32,
+                        arg5: i32,
+                        arg6: u64,
+                        arg7: i64,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (u8, i8, u16, i16, u32, i32, u64, i64),
+                                (),
+                            >::new_unchecked(self.a9)
+                        };
+                        let () = callee
+                            .call(
+                                store.as_context_mut(),
+                                (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7),
+                            )?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_r1<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<u8> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (u8,),
+                            >::new_unchecked(self.r1)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_r2<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<i8> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (i8,),
+                            >::new_unchecked(self.r2)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_r3<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<u16> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (u16,),
+                            >::new_unchecked(self.r3)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_r4<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<i16> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (i16,),
+                            >::new_unchecked(self.r4)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_r5<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<u32> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (u32,),
+                            >::new_unchecked(self.r5)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_r6<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<i32> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (i32,),
+                            >::new_unchecked(self.r6)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_r7<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<u64> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (u64,),
+                            >::new_unchecked(self.r7)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_r8<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<i64> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (i64,),
+                            >::new_unchecked(self.r8)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_pair_ret<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<(i64, u8)> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                ((i64, u8),),
+                            >::new_unchecked(self.pair_ret)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/integers_async.rs b/crates/component-macro/tests/expanded/integers_async.rs
new file mode 100644
index 000000000000..3b6c21f7ce21
--- /dev/null
+++ b/crates/component-macro/tests/expanded/integers_async.rs
@@ -0,0 +1,1092 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-world`.
+///
+/// This structure is created through [`TheWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheWorld`] as well.
+pub struct TheWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheWorldIndices,
+}
+impl<T> Clone for TheWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheWorldPre<_T> {
+    /// Creates a new copy of `TheWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheWorld>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-world`.
+///
+/// This is an implementation detail of [`TheWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheWorld`] as well.
+#[derive(Clone)]
+pub struct TheWorldIndices {
+    interface0: exports::foo::foo::integers::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheWorld::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheWorldPre::instantiate_async`] to
+///   create a [`TheWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheWorldIndices::new_instance`] followed
+///   by [`TheWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheWorld {
+    interface0: exports::foo::foo::integers::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheWorldIndices {
+        /// Creates a new copy of `TheWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::integers::GuestIndices::new(_component)?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Creates a new instance of [`TheWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::integers::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(TheWorld { interface0 })
+        }
+    }
+    impl TheWorld {
+        /// Convenience wrapper around [`TheWorldPre::new`] and
+        /// [`TheWorldPre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheWorld>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            TheWorldPre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`TheWorldIndices::new_instance`] and
+        /// [`TheWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let indices = TheWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+            U: foo::foo::integers::Host + Send,
+        {
+            foo::foo::integers::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_integers(&self) -> &exports::foo::foo::integers::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod integers {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {
+                async fn a1(&mut self, x: u8) -> ();
+                async fn a2(&mut self, x: i8) -> ();
+                async fn a3(&mut self, x: u16) -> ();
+                async fn a4(&mut self, x: i16) -> ();
+                async fn a5(&mut self, x: u32) -> ();
+                async fn a6(&mut self, x: i32) -> ();
+                async fn a7(&mut self, x: u64) -> ();
+                async fn a8(&mut self, x: i64) -> ();
+                async fn a9(
+                    &mut self,
+                    p1: u8,
+                    p2: i8,
+                    p3: u16,
+                    p4: i16,
+                    p5: u32,
+                    p6: i32,
+                    p7: u64,
+                    p8: i64,
+                ) -> ();
+                async fn r1(&mut self) -> u8;
+                async fn r2(&mut self) -> i8;
+                async fn r3(&mut self) -> u16;
+                async fn r4(&mut self) -> i16;
+                async fn r5(&mut self) -> u32;
+                async fn r6(&mut self) -> i32;
+                async fn r7(&mut self) -> u64;
+                async fn r8(&mut self) -> i64;
+                async fn pair_ret(&mut self) -> (i64, u8);
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/integers")?;
+                inst.func_wrap_async(
+                    "a1",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (u8,)| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::a1(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "a2",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (i8,)| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::a2(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "a3",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (u16,)| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::a3(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "a4",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (i16,)| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::a4(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "a5",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (u32,)| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::a5(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "a6",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (i32,)| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::a6(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "a7",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (u64,)| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::a7(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "a8",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (i64,)| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::a8(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "a9",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (
+                            arg0,
+                            arg1,
+                            arg2,
+                            arg3,
+                            arg4,
+                            arg5,
+                            arg6,
+                            arg7,
+                        ): (u8, i8, u16, i16, u32, i32, u64, i64)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::a9(
+                                host,
+                                arg0,
+                                arg1,
+                                arg2,
+                                arg3,
+                                arg4,
+                                arg5,
+                                arg6,
+                                arg7,
+                            )
+                            .await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "r1",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::r1(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "r2",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::r2(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "r3",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::r3(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "r4",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::r4(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "r5",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::r5(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "r6",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::r6(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "r7",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::r7(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "r8",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::r8(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "pair-ret",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::pair_ret(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {
+                async fn a1(&mut self, x: u8) -> () {
+                    Host::a1(*self, x).await
+                }
+                async fn a2(&mut self, x: i8) -> () {
+                    Host::a2(*self, x).await
+                }
+                async fn a3(&mut self, x: u16) -> () {
+                    Host::a3(*self, x).await
+                }
+                async fn a4(&mut self, x: i16) -> () {
+                    Host::a4(*self, x).await
+                }
+                async fn a5(&mut self, x: u32) -> () {
+                    Host::a5(*self, x).await
+                }
+                async fn a6(&mut self, x: i32) -> () {
+                    Host::a6(*self, x).await
+                }
+                async fn a7(&mut self, x: u64) -> () {
+                    Host::a7(*self, x).await
+                }
+                async fn a8(&mut self, x: i64) -> () {
+                    Host::a8(*self, x).await
+                }
+                async fn a9(
+                    &mut self,
+                    p1: u8,
+                    p2: i8,
+                    p3: u16,
+                    p4: i16,
+                    p5: u32,
+                    p6: i32,
+                    p7: u64,
+                    p8: i64,
+                ) -> () {
+                    Host::a9(*self, p1, p2, p3, p4, p5, p6, p7, p8).await
+                }
+                async fn r1(&mut self) -> u8 {
+                    Host::r1(*self).await
+                }
+                async fn r2(&mut self) -> i8 {
+                    Host::r2(*self).await
+                }
+                async fn r3(&mut self) -> u16 {
+                    Host::r3(*self).await
+                }
+                async fn r4(&mut self) -> i16 {
+                    Host::r4(*self).await
+                }
+                async fn r5(&mut self) -> u32 {
+                    Host::r5(*self).await
+                }
+                async fn r6(&mut self) -> i32 {
+                    Host::r6(*self).await
+                }
+                async fn r7(&mut self) -> u64 {
+                    Host::r7(*self).await
+                }
+                async fn r8(&mut self) -> i64 {
+                    Host::r8(*self).await
+                }
+                async fn pair_ret(&mut self) -> (i64, u8) {
+                    Host::pair_ret(*self).await
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod integers {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub struct Guest {
+                    a1: wasmtime::component::Func,
+                    a2: wasmtime::component::Func,
+                    a3: wasmtime::component::Func,
+                    a4: wasmtime::component::Func,
+                    a5: wasmtime::component::Func,
+                    a6: wasmtime::component::Func,
+                    a7: wasmtime::component::Func,
+                    a8: wasmtime::component::Func,
+                    a9: wasmtime::component::Func,
+                    r1: wasmtime::component::Func,
+                    r2: wasmtime::component::Func,
+                    r3: wasmtime::component::Func,
+                    r4: wasmtime::component::Func,
+                    r5: wasmtime::component::Func,
+                    r6: wasmtime::component::Func,
+                    r7: wasmtime::component::Func,
+                    r8: wasmtime::component::Func,
+                    pair_ret: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    a1: wasmtime::component::ComponentExportIndex,
+                    a2: wasmtime::component::ComponentExportIndex,
+                    a3: wasmtime::component::ComponentExportIndex,
+                    a4: wasmtime::component::ComponentExportIndex,
+                    a5: wasmtime::component::ComponentExportIndex,
+                    a6: wasmtime::component::ComponentExportIndex,
+                    a7: wasmtime::component::ComponentExportIndex,
+                    a8: wasmtime::component::ComponentExportIndex,
+                    a9: wasmtime::component::ComponentExportIndex,
+                    r1: wasmtime::component::ComponentExportIndex,
+                    r2: wasmtime::component::ComponentExportIndex,
+                    r3: wasmtime::component::ComponentExportIndex,
+                    r4: wasmtime::component::ComponentExportIndex,
+                    r5: wasmtime::component::ComponentExportIndex,
+                    r6: wasmtime::component::ComponentExportIndex,
+                    r7: wasmtime::component::ComponentExportIndex,
+                    r8: wasmtime::component::ComponentExportIndex,
+                    pair_ret: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/integers")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/integers`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/integers")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/integers`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/integers` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let a1 = lookup("a1")?;
+                        let a2 = lookup("a2")?;
+                        let a3 = lookup("a3")?;
+                        let a4 = lookup("a4")?;
+                        let a5 = lookup("a5")?;
+                        let a6 = lookup("a6")?;
+                        let a7 = lookup("a7")?;
+                        let a8 = lookup("a8")?;
+                        let a9 = lookup("a9")?;
+                        let r1 = lookup("r1")?;
+                        let r2 = lookup("r2")?;
+                        let r3 = lookup("r3")?;
+                        let r4 = lookup("r4")?;
+                        let r5 = lookup("r5")?;
+                        let r6 = lookup("r6")?;
+                        let r7 = lookup("r7")?;
+                        let r8 = lookup("r8")?;
+                        let pair_ret = lookup("pair-ret")?;
+                        Ok(GuestIndices {
+                            a1,
+                            a2,
+                            a3,
+                            a4,
+                            a5,
+                            a6,
+                            a7,
+                            a8,
+                            a9,
+                            r1,
+                            r2,
+                            r3,
+                            r4,
+                            r5,
+                            r6,
+                            r7,
+                            r8,
+                            pair_ret,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let a1 = *_instance
+                            .get_typed_func::<(u8,), ()>(&mut store, &self.a1)?
+                            .func();
+                        let a2 = *_instance
+                            .get_typed_func::<(i8,), ()>(&mut store, &self.a2)?
+                            .func();
+                        let a3 = *_instance
+                            .get_typed_func::<(u16,), ()>(&mut store, &self.a3)?
+                            .func();
+                        let a4 = *_instance
+                            .get_typed_func::<(i16,), ()>(&mut store, &self.a4)?
+                            .func();
+                        let a5 = *_instance
+                            .get_typed_func::<(u32,), ()>(&mut store, &self.a5)?
+                            .func();
+                        let a6 = *_instance
+                            .get_typed_func::<(i32,), ()>(&mut store, &self.a6)?
+                            .func();
+                        let a7 = *_instance
+                            .get_typed_func::<(u64,), ()>(&mut store, &self.a7)?
+                            .func();
+                        let a8 = *_instance
+                            .get_typed_func::<(i64,), ()>(&mut store, &self.a8)?
+                            .func();
+                        let a9 = *_instance
+                            .get_typed_func::<
+                                (u8, i8, u16, i16, u32, i32, u64, i64),
+                                (),
+                            >(&mut store, &self.a9)?
+                            .func();
+                        let r1 = *_instance
+                            .get_typed_func::<(), (u8,)>(&mut store, &self.r1)?
+                            .func();
+                        let r2 = *_instance
+                            .get_typed_func::<(), (i8,)>(&mut store, &self.r2)?
+                            .func();
+                        let r3 = *_instance
+                            .get_typed_func::<(), (u16,)>(&mut store, &self.r3)?
+                            .func();
+                        let r4 = *_instance
+                            .get_typed_func::<(), (i16,)>(&mut store, &self.r4)?
+                            .func();
+                        let r5 = *_instance
+                            .get_typed_func::<(), (u32,)>(&mut store, &self.r5)?
+                            .func();
+                        let r6 = *_instance
+                            .get_typed_func::<(), (i32,)>(&mut store, &self.r6)?
+                            .func();
+                        let r7 = *_instance
+                            .get_typed_func::<(), (u64,)>(&mut store, &self.r7)?
+                            .func();
+                        let r8 = *_instance
+                            .get_typed_func::<(), (i64,)>(&mut store, &self.r8)?
+                            .func();
+                        let pair_ret = *_instance
+                            .get_typed_func::<
+                                (),
+                                ((i64, u8),),
+                            >(&mut store, &self.pair_ret)?
+                            .func();
+                        Ok(Guest {
+                            a1,
+                            a2,
+                            a3,
+                            a4,
+                            a5,
+                            a6,
+                            a7,
+                            a8,
+                            a9,
+                            r1,
+                            r2,
+                            r3,
+                            r4,
+                            r5,
+                            r6,
+                            r7,
+                            r8,
+                            pair_ret,
+                        })
+                    }
+                }
+                impl Guest {
+                    pub async fn call_a1<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: u8,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (u8,),
+                                (),
+                            >::new_unchecked(self.a1)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_a2<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: i8,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (i8,),
+                                (),
+                            >::new_unchecked(self.a2)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_a3<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: u16,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (u16,),
+                                (),
+                            >::new_unchecked(self.a3)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_a4<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: i16,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (i16,),
+                                (),
+                            >::new_unchecked(self.a4)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_a5<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: u32,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (u32,),
+                                (),
+                            >::new_unchecked(self.a5)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_a6<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: i32,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (i32,),
+                                (),
+                            >::new_unchecked(self.a6)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_a7<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: u64,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (u64,),
+                                (),
+                            >::new_unchecked(self.a7)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_a8<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: i64,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (i64,),
+                                (),
+                            >::new_unchecked(self.a8)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_a9<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: u8,
+                        arg1: i8,
+                        arg2: u16,
+                        arg3: i16,
+                        arg4: u32,
+                        arg5: i32,
+                        arg6: u64,
+                        arg7: i64,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (u8, i8, u16, i16, u32, i32, u64, i64),
+                                (),
+                            >::new_unchecked(self.a9)
+                        };
+                        let () = callee
+                            .call_async(
+                                store.as_context_mut(),
+                                (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7),
+                            )
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_r1<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<u8>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (u8,),
+                            >::new_unchecked(self.r1)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_r2<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<i8>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (i8,),
+                            >::new_unchecked(self.r2)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_r3<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<u16>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (u16,),
+                            >::new_unchecked(self.r3)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_r4<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<i16>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (i16,),
+                            >::new_unchecked(self.r4)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_r5<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<u32>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (u32,),
+                            >::new_unchecked(self.r5)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_r6<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<i32>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (i32,),
+                            >::new_unchecked(self.r6)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_r7<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<u64>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (u64,),
+                            >::new_unchecked(self.r7)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_r8<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<i64>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (i64,),
+                            >::new_unchecked(self.r8)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_pair_ret<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<(i64, u8)>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                ((i64, u8),),
+                            >::new_unchecked(self.pair_ret)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/lists.rs b/crates/component-macro/tests/expanded/lists.rs
new file mode 100644
index 000000000000..acffcb2154d3
--- /dev/null
+++ b/crates/component-macro/tests/expanded/lists.rs
@@ -0,0 +1,2040 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-lists`.
+///
+/// This structure is created through [`TheListsPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheLists`] as well.
+pub struct TheListsPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheListsIndices,
+}
+impl<T> Clone for TheListsPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheListsPre<_T> {
+    /// Creates a new copy of `TheListsPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheListsIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheLists`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheLists> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-lists`.
+///
+/// This is an implementation detail of [`TheListsPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheLists`] as well.
+#[derive(Clone)]
+pub struct TheListsIndices {
+    interface0: exports::foo::foo::lists::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-lists`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheLists::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheListsPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheListsPre::instantiate`] to
+///   create a [`TheLists`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheLists::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheListsIndices::new_instance`] followed
+///   by [`TheListsIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheLists {
+    interface0: exports::foo::foo::lists::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheListsIndices {
+        /// Creates a new copy of `TheListsIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::lists::GuestIndices::new(_component)?;
+            Ok(TheListsIndices { interface0 })
+        }
+        /// Creates a new instance of [`TheListsIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheLists`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheLists`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::lists::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(TheListsIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheLists`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheLists> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(TheLists { interface0 })
+        }
+    }
+    impl TheLists {
+        /// Convenience wrapper around [`TheListsPre::new`] and
+        /// [`TheListsPre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheLists> {
+            let pre = linker.instantiate_pre(component)?;
+            TheListsPre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`TheListsIndices::new_instance`] and
+        /// [`TheListsIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheLists> {
+            let indices = TheListsIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            U: foo::foo::lists::Host,
+        {
+            foo::foo::lists::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_lists(&self) -> &exports::foo::foo::lists::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod lists {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone)]
+            pub struct OtherRecord {
+                #[component(name = "a1")]
+                pub a1: u32,
+                #[component(name = "a2")]
+                pub a2: u64,
+                #[component(name = "a3")]
+                pub a3: i32,
+                #[component(name = "a4")]
+                pub a4: i64,
+                #[component(name = "b")]
+                pub b: wasmtime::component::__internal::String,
+                #[component(name = "c")]
+                pub c: wasmtime::component::__internal::Vec<u8>,
+            }
+            impl core::fmt::Debug for OtherRecord {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("OtherRecord")
+                        .field("a1", &self.a1)
+                        .field("a2", &self.a2)
+                        .field("a3", &self.a3)
+                        .field("a4", &self.a4)
+                        .field("b", &self.b)
+                        .field("c", &self.c)
+                        .finish()
+                }
+            }
+            const _: () = {
+                assert!(
+                    48 == < OtherRecord as wasmtime::component::ComponentType >::SIZE32
+                );
+                assert!(
+                    8 == < OtherRecord as wasmtime::component::ComponentType >::ALIGN32
+                );
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone)]
+            pub struct SomeRecord {
+                #[component(name = "x")]
+                pub x: wasmtime::component::__internal::String,
+                #[component(name = "y")]
+                pub y: OtherRecord,
+                #[component(name = "z")]
+                pub z: wasmtime::component::__internal::Vec<OtherRecord>,
+                #[component(name = "c1")]
+                pub c1: u32,
+                #[component(name = "c2")]
+                pub c2: u64,
+                #[component(name = "c3")]
+                pub c3: i32,
+                #[component(name = "c4")]
+                pub c4: i64,
+            }
+            impl core::fmt::Debug for SomeRecord {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("SomeRecord")
+                        .field("x", &self.x)
+                        .field("y", &self.y)
+                        .field("z", &self.z)
+                        .field("c1", &self.c1)
+                        .field("c2", &self.c2)
+                        .field("c3", &self.c3)
+                        .field("c4", &self.c4)
+                        .finish()
+                }
+            }
+            const _: () = {
+                assert!(
+                    96 == < SomeRecord as wasmtime::component::ComponentType >::SIZE32
+                );
+                assert!(
+                    8 == < SomeRecord as wasmtime::component::ComponentType >::ALIGN32
+                );
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(variant)]
+            #[derive(Clone)]
+            pub enum OtherVariant {
+                #[component(name = "a")]
+                A,
+                #[component(name = "b")]
+                B(u32),
+                #[component(name = "c")]
+                C(wasmtime::component::__internal::String),
+            }
+            impl core::fmt::Debug for OtherVariant {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    match self {
+                        OtherVariant::A => f.debug_tuple("OtherVariant::A").finish(),
+                        OtherVariant::B(e) => {
+                            f.debug_tuple("OtherVariant::B").field(e).finish()
+                        }
+                        OtherVariant::C(e) => {
+                            f.debug_tuple("OtherVariant::C").field(e).finish()
+                        }
+                    }
+                }
+            }
+            const _: () = {
+                assert!(
+                    12 == < OtherVariant as wasmtime::component::ComponentType >::SIZE32
+                );
+                assert!(
+                    4 == < OtherVariant as wasmtime::component::ComponentType >::ALIGN32
+                );
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(variant)]
+            #[derive(Clone)]
+            pub enum SomeVariant {
+                #[component(name = "a")]
+                A(wasmtime::component::__internal::String),
+                #[component(name = "b")]
+                B,
+                #[component(name = "c")]
+                C(u32),
+                #[component(name = "d")]
+                D(wasmtime::component::__internal::Vec<OtherVariant>),
+            }
+            impl core::fmt::Debug for SomeVariant {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    match self {
+                        SomeVariant::A(e) => {
+                            f.debug_tuple("SomeVariant::A").field(e).finish()
+                        }
+                        SomeVariant::B => f.debug_tuple("SomeVariant::B").finish(),
+                        SomeVariant::C(e) => {
+                            f.debug_tuple("SomeVariant::C").field(e).finish()
+                        }
+                        SomeVariant::D(e) => {
+                            f.debug_tuple("SomeVariant::D").field(e).finish()
+                        }
+                    }
+                }
+            }
+            const _: () = {
+                assert!(
+                    12 == < SomeVariant as wasmtime::component::ComponentType >::SIZE32
+                );
+                assert!(
+                    4 == < SomeVariant as wasmtime::component::ComponentType >::ALIGN32
+                );
+            };
+            pub type LoadStoreAllSizes = wasmtime::component::__internal::Vec<
+                (
+                    wasmtime::component::__internal::String,
+                    u8,
+                    i8,
+                    u16,
+                    i16,
+                    u32,
+                    i32,
+                    u64,
+                    i64,
+                    f32,
+                    f64,
+                    char,
+                ),
+            >;
+            const _: () = {
+                assert!(
+                    8 == < LoadStoreAllSizes as wasmtime::component::ComponentType
+                    >::SIZE32
+                );
+                assert!(
+                    4 == < LoadStoreAllSizes as wasmtime::component::ComponentType
+                    >::ALIGN32
+                );
+            };
+            pub trait Host {
+                fn list_u8_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<u8>,
+                ) -> ();
+                fn list_u16_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<u16>,
+                ) -> ();
+                fn list_u32_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<u32>,
+                ) -> ();
+                fn list_u64_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<u64>,
+                ) -> ();
+                fn list_s8_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<i8>,
+                ) -> ();
+                fn list_s16_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<i16>,
+                ) -> ();
+                fn list_s32_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<i32>,
+                ) -> ();
+                fn list_s64_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<i64>,
+                ) -> ();
+                fn list_float32_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<f32>,
+                ) -> ();
+                fn list_float64_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<f64>,
+                ) -> ();
+                fn list_u8_ret(&mut self) -> wasmtime::component::__internal::Vec<u8>;
+                fn list_u16_ret(&mut self) -> wasmtime::component::__internal::Vec<u16>;
+                fn list_u32_ret(&mut self) -> wasmtime::component::__internal::Vec<u32>;
+                fn list_u64_ret(&mut self) -> wasmtime::component::__internal::Vec<u64>;
+                fn list_s8_ret(&mut self) -> wasmtime::component::__internal::Vec<i8>;
+                fn list_s16_ret(&mut self) -> wasmtime::component::__internal::Vec<i16>;
+                fn list_s32_ret(&mut self) -> wasmtime::component::__internal::Vec<i32>;
+                fn list_s64_ret(&mut self) -> wasmtime::component::__internal::Vec<i64>;
+                fn list_float32_ret(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<f32>;
+                fn list_float64_ret(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<f64>;
+                fn tuple_list(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<(u8, i8)>,
+                ) -> wasmtime::component::__internal::Vec<(i64, u32)>;
+                fn string_list_arg(
+                    &mut self,
+                    a: wasmtime::component::__internal::Vec<
+                        wasmtime::component::__internal::String,
+                    >,
+                ) -> ();
+                fn string_list_ret(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<
+                    wasmtime::component::__internal::String,
+                >;
+                fn tuple_string_list(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<
+                        (u8, wasmtime::component::__internal::String),
+                    >,
+                ) -> wasmtime::component::__internal::Vec<
+                    (wasmtime::component::__internal::String, u8),
+                >;
+                fn string_list(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<
+                        wasmtime::component::__internal::String,
+                    >,
+                ) -> wasmtime::component::__internal::Vec<
+                    wasmtime::component::__internal::String,
+                >;
+                fn record_list(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<SomeRecord>,
+                ) -> wasmtime::component::__internal::Vec<OtherRecord>;
+                fn record_list_reverse(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<OtherRecord>,
+                ) -> wasmtime::component::__internal::Vec<SomeRecord>;
+                fn variant_list(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<SomeVariant>,
+                ) -> wasmtime::component::__internal::Vec<OtherVariant>;
+                fn load_store_everything(
+                    &mut self,
+                    a: LoadStoreAllSizes,
+                ) -> LoadStoreAllSizes;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/lists")?;
+                inst.func_wrap(
+                    "list-u8-param",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<u8>,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_u8_param(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "list-u16-param",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<u16>,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_u16_param(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "list-u32-param",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<u32>,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_u32_param(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "list-u64-param",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<u64>,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_u64_param(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "list-s8-param",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<i8>,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_s8_param(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "list-s16-param",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<i16>,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_s16_param(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "list-s32-param",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<i32>,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_s32_param(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "list-s64-param",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<i64>,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_s64_param(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "list-float32-param",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<f32>,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_float32_param(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "list-float64-param",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<f64>,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_float64_param(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "list-u8-ret",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_u8_ret(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "list-u16-ret",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_u16_ret(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "list-u32-ret",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_u32_ret(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "list-u64-ret",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_u64_ret(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "list-s8-ret",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_s8_ret(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "list-s16-ret",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_s16_ret(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "list-s32-ret",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_s32_ret(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "list-s64-ret",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_s64_ret(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "list-float32-ret",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_float32_ret(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "list-float64-ret",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_float64_ret(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "tuple-list",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<(u8, i8)>,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::tuple_list(host, arg0);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "string-list-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (
+                            arg0,
+                        ): (
+                            wasmtime::component::__internal::Vec<
+                                wasmtime::component::__internal::String,
+                            >,
+                        )|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::string_list_arg(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "string-list-ret",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::string_list_ret(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "tuple-string-list",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (
+                            arg0,
+                        ): (
+                            wasmtime::component::__internal::Vec<
+                                (u8, wasmtime::component::__internal::String),
+                            >,
+                        )|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::tuple_string_list(host, arg0);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "string-list",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (
+                            arg0,
+                        ): (
+                            wasmtime::component::__internal::Vec<
+                                wasmtime::component::__internal::String,
+                            >,
+                        )|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::string_list(host, arg0);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "record-list",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<SomeRecord>,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::record_list(host, arg0);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "record-list-reverse",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<OtherRecord>,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::record_list_reverse(host, arg0);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "variant-list",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<SomeVariant>,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::variant_list(host, arg0);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "load-store-everything",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (LoadStoreAllSizes,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::load_store_everything(host, arg0);
+                        Ok((r,))
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {
+                fn list_u8_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<u8>,
+                ) -> () {
+                    Host::list_u8_param(*self, x)
+                }
+                fn list_u16_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<u16>,
+                ) -> () {
+                    Host::list_u16_param(*self, x)
+                }
+                fn list_u32_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<u32>,
+                ) -> () {
+                    Host::list_u32_param(*self, x)
+                }
+                fn list_u64_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<u64>,
+                ) -> () {
+                    Host::list_u64_param(*self, x)
+                }
+                fn list_s8_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<i8>,
+                ) -> () {
+                    Host::list_s8_param(*self, x)
+                }
+                fn list_s16_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<i16>,
+                ) -> () {
+                    Host::list_s16_param(*self, x)
+                }
+                fn list_s32_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<i32>,
+                ) -> () {
+                    Host::list_s32_param(*self, x)
+                }
+                fn list_s64_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<i64>,
+                ) -> () {
+                    Host::list_s64_param(*self, x)
+                }
+                fn list_float32_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<f32>,
+                ) -> () {
+                    Host::list_float32_param(*self, x)
+                }
+                fn list_float64_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<f64>,
+                ) -> () {
+                    Host::list_float64_param(*self, x)
+                }
+                fn list_u8_ret(&mut self) -> wasmtime::component::__internal::Vec<u8> {
+                    Host::list_u8_ret(*self)
+                }
+                fn list_u16_ret(&mut self) -> wasmtime::component::__internal::Vec<u16> {
+                    Host::list_u16_ret(*self)
+                }
+                fn list_u32_ret(&mut self) -> wasmtime::component::__internal::Vec<u32> {
+                    Host::list_u32_ret(*self)
+                }
+                fn list_u64_ret(&mut self) -> wasmtime::component::__internal::Vec<u64> {
+                    Host::list_u64_ret(*self)
+                }
+                fn list_s8_ret(&mut self) -> wasmtime::component::__internal::Vec<i8> {
+                    Host::list_s8_ret(*self)
+                }
+                fn list_s16_ret(&mut self) -> wasmtime::component::__internal::Vec<i16> {
+                    Host::list_s16_ret(*self)
+                }
+                fn list_s32_ret(&mut self) -> wasmtime::component::__internal::Vec<i32> {
+                    Host::list_s32_ret(*self)
+                }
+                fn list_s64_ret(&mut self) -> wasmtime::component::__internal::Vec<i64> {
+                    Host::list_s64_ret(*self)
+                }
+                fn list_float32_ret(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<f32> {
+                    Host::list_float32_ret(*self)
+                }
+                fn list_float64_ret(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<f64> {
+                    Host::list_float64_ret(*self)
+                }
+                fn tuple_list(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<(u8, i8)>,
+                ) -> wasmtime::component::__internal::Vec<(i64, u32)> {
+                    Host::tuple_list(*self, x)
+                }
+                fn string_list_arg(
+                    &mut self,
+                    a: wasmtime::component::__internal::Vec<
+                        wasmtime::component::__internal::String,
+                    >,
+                ) -> () {
+                    Host::string_list_arg(*self, a)
+                }
+                fn string_list_ret(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<
+                    wasmtime::component::__internal::String,
+                > {
+                    Host::string_list_ret(*self)
+                }
+                fn tuple_string_list(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<
+                        (u8, wasmtime::component::__internal::String),
+                    >,
+                ) -> wasmtime::component::__internal::Vec<
+                    (wasmtime::component::__internal::String, u8),
+                > {
+                    Host::tuple_string_list(*self, x)
+                }
+                fn string_list(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<
+                        wasmtime::component::__internal::String,
+                    >,
+                ) -> wasmtime::component::__internal::Vec<
+                    wasmtime::component::__internal::String,
+                > {
+                    Host::string_list(*self, x)
+                }
+                fn record_list(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<SomeRecord>,
+                ) -> wasmtime::component::__internal::Vec<OtherRecord> {
+                    Host::record_list(*self, x)
+                }
+                fn record_list_reverse(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<OtherRecord>,
+                ) -> wasmtime::component::__internal::Vec<SomeRecord> {
+                    Host::record_list_reverse(*self, x)
+                }
+                fn variant_list(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<SomeVariant>,
+                ) -> wasmtime::component::__internal::Vec<OtherVariant> {
+                    Host::variant_list(*self, x)
+                }
+                fn load_store_everything(
+                    &mut self,
+                    a: LoadStoreAllSizes,
+                ) -> LoadStoreAllSizes {
+                    Host::load_store_everything(*self, a)
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod lists {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(record)]
+                #[derive(Clone)]
+                pub struct OtherRecord {
+                    #[component(name = "a1")]
+                    pub a1: u32,
+                    #[component(name = "a2")]
+                    pub a2: u64,
+                    #[component(name = "a3")]
+                    pub a3: i32,
+                    #[component(name = "a4")]
+                    pub a4: i64,
+                    #[component(name = "b")]
+                    pub b: wasmtime::component::__internal::String,
+                    #[component(name = "c")]
+                    pub c: wasmtime::component::__internal::Vec<u8>,
+                }
+                impl core::fmt::Debug for OtherRecord {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        f.debug_struct("OtherRecord")
+                            .field("a1", &self.a1)
+                            .field("a2", &self.a2)
+                            .field("a3", &self.a3)
+                            .field("a4", &self.a4)
+                            .field("b", &self.b)
+                            .field("c", &self.c)
+                            .finish()
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        48 == < OtherRecord as wasmtime::component::ComponentType
+                        >::SIZE32
+                    );
+                    assert!(
+                        8 == < OtherRecord as wasmtime::component::ComponentType
+                        >::ALIGN32
+                    );
+                };
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(record)]
+                #[derive(Clone)]
+                pub struct SomeRecord {
+                    #[component(name = "x")]
+                    pub x: wasmtime::component::__internal::String,
+                    #[component(name = "y")]
+                    pub y: OtherRecord,
+                    #[component(name = "z")]
+                    pub z: wasmtime::component::__internal::Vec<OtherRecord>,
+                    #[component(name = "c1")]
+                    pub c1: u32,
+                    #[component(name = "c2")]
+                    pub c2: u64,
+                    #[component(name = "c3")]
+                    pub c3: i32,
+                    #[component(name = "c4")]
+                    pub c4: i64,
+                }
+                impl core::fmt::Debug for SomeRecord {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        f.debug_struct("SomeRecord")
+                            .field("x", &self.x)
+                            .field("y", &self.y)
+                            .field("z", &self.z)
+                            .field("c1", &self.c1)
+                            .field("c2", &self.c2)
+                            .field("c3", &self.c3)
+                            .field("c4", &self.c4)
+                            .finish()
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        96 == < SomeRecord as wasmtime::component::ComponentType
+                        >::SIZE32
+                    );
+                    assert!(
+                        8 == < SomeRecord as wasmtime::component::ComponentType
+                        >::ALIGN32
+                    );
+                };
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(variant)]
+                #[derive(Clone)]
+                pub enum OtherVariant {
+                    #[component(name = "a")]
+                    A,
+                    #[component(name = "b")]
+                    B(u32),
+                    #[component(name = "c")]
+                    C(wasmtime::component::__internal::String),
+                }
+                impl core::fmt::Debug for OtherVariant {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        match self {
+                            OtherVariant::A => f.debug_tuple("OtherVariant::A").finish(),
+                            OtherVariant::B(e) => {
+                                f.debug_tuple("OtherVariant::B").field(e).finish()
+                            }
+                            OtherVariant::C(e) => {
+                                f.debug_tuple("OtherVariant::C").field(e).finish()
+                            }
+                        }
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        12 == < OtherVariant as wasmtime::component::ComponentType
+                        >::SIZE32
+                    );
+                    assert!(
+                        4 == < OtherVariant as wasmtime::component::ComponentType
+                        >::ALIGN32
+                    );
+                };
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(variant)]
+                #[derive(Clone)]
+                pub enum SomeVariant {
+                    #[component(name = "a")]
+                    A(wasmtime::component::__internal::String),
+                    #[component(name = "b")]
+                    B,
+                    #[component(name = "c")]
+                    C(u32),
+                    #[component(name = "d")]
+                    D(wasmtime::component::__internal::Vec<OtherVariant>),
+                }
+                impl core::fmt::Debug for SomeVariant {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        match self {
+                            SomeVariant::A(e) => {
+                                f.debug_tuple("SomeVariant::A").field(e).finish()
+                            }
+                            SomeVariant::B => f.debug_tuple("SomeVariant::B").finish(),
+                            SomeVariant::C(e) => {
+                                f.debug_tuple("SomeVariant::C").field(e).finish()
+                            }
+                            SomeVariant::D(e) => {
+                                f.debug_tuple("SomeVariant::D").field(e).finish()
+                            }
+                        }
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        12 == < SomeVariant as wasmtime::component::ComponentType
+                        >::SIZE32
+                    );
+                    assert!(
+                        4 == < SomeVariant as wasmtime::component::ComponentType
+                        >::ALIGN32
+                    );
+                };
+                pub type LoadStoreAllSizes = wasmtime::component::__internal::Vec<
+                    (
+                        wasmtime::component::__internal::String,
+                        u8,
+                        i8,
+                        u16,
+                        i16,
+                        u32,
+                        i32,
+                        u64,
+                        i64,
+                        f32,
+                        f64,
+                        char,
+                    ),
+                >;
+                const _: () = {
+                    assert!(
+                        8 == < LoadStoreAllSizes as wasmtime::component::ComponentType
+                        >::SIZE32
+                    );
+                    assert!(
+                        4 == < LoadStoreAllSizes as wasmtime::component::ComponentType
+                        >::ALIGN32
+                    );
+                };
+                pub struct Guest {
+                    list_u8_param: wasmtime::component::Func,
+                    list_u16_param: wasmtime::component::Func,
+                    list_u32_param: wasmtime::component::Func,
+                    list_u64_param: wasmtime::component::Func,
+                    list_s8_param: wasmtime::component::Func,
+                    list_s16_param: wasmtime::component::Func,
+                    list_s32_param: wasmtime::component::Func,
+                    list_s64_param: wasmtime::component::Func,
+                    list_float32_param: wasmtime::component::Func,
+                    list_float64_param: wasmtime::component::Func,
+                    list_u8_ret: wasmtime::component::Func,
+                    list_u16_ret: wasmtime::component::Func,
+                    list_u32_ret: wasmtime::component::Func,
+                    list_u64_ret: wasmtime::component::Func,
+                    list_s8_ret: wasmtime::component::Func,
+                    list_s16_ret: wasmtime::component::Func,
+                    list_s32_ret: wasmtime::component::Func,
+                    list_s64_ret: wasmtime::component::Func,
+                    list_float32_ret: wasmtime::component::Func,
+                    list_float64_ret: wasmtime::component::Func,
+                    tuple_list: wasmtime::component::Func,
+                    string_list_arg: wasmtime::component::Func,
+                    string_list_ret: wasmtime::component::Func,
+                    tuple_string_list: wasmtime::component::Func,
+                    string_list: wasmtime::component::Func,
+                    record_list: wasmtime::component::Func,
+                    record_list_reverse: wasmtime::component::Func,
+                    variant_list: wasmtime::component::Func,
+                    load_store_everything: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    list_u8_param: wasmtime::component::ComponentExportIndex,
+                    list_u16_param: wasmtime::component::ComponentExportIndex,
+                    list_u32_param: wasmtime::component::ComponentExportIndex,
+                    list_u64_param: wasmtime::component::ComponentExportIndex,
+                    list_s8_param: wasmtime::component::ComponentExportIndex,
+                    list_s16_param: wasmtime::component::ComponentExportIndex,
+                    list_s32_param: wasmtime::component::ComponentExportIndex,
+                    list_s64_param: wasmtime::component::ComponentExportIndex,
+                    list_float32_param: wasmtime::component::ComponentExportIndex,
+                    list_float64_param: wasmtime::component::ComponentExportIndex,
+                    list_u8_ret: wasmtime::component::ComponentExportIndex,
+                    list_u16_ret: wasmtime::component::ComponentExportIndex,
+                    list_u32_ret: wasmtime::component::ComponentExportIndex,
+                    list_u64_ret: wasmtime::component::ComponentExportIndex,
+                    list_s8_ret: wasmtime::component::ComponentExportIndex,
+                    list_s16_ret: wasmtime::component::ComponentExportIndex,
+                    list_s32_ret: wasmtime::component::ComponentExportIndex,
+                    list_s64_ret: wasmtime::component::ComponentExportIndex,
+                    list_float32_ret: wasmtime::component::ComponentExportIndex,
+                    list_float64_ret: wasmtime::component::ComponentExportIndex,
+                    tuple_list: wasmtime::component::ComponentExportIndex,
+                    string_list_arg: wasmtime::component::ComponentExportIndex,
+                    string_list_ret: wasmtime::component::ComponentExportIndex,
+                    tuple_string_list: wasmtime::component::ComponentExportIndex,
+                    string_list: wasmtime::component::ComponentExportIndex,
+                    record_list: wasmtime::component::ComponentExportIndex,
+                    record_list_reverse: wasmtime::component::ComponentExportIndex,
+                    variant_list: wasmtime::component::ComponentExportIndex,
+                    load_store_everything: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/lists")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/lists`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/lists")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/lists`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/lists` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let list_u8_param = lookup("list-u8-param")?;
+                        let list_u16_param = lookup("list-u16-param")?;
+                        let list_u32_param = lookup("list-u32-param")?;
+                        let list_u64_param = lookup("list-u64-param")?;
+                        let list_s8_param = lookup("list-s8-param")?;
+                        let list_s16_param = lookup("list-s16-param")?;
+                        let list_s32_param = lookup("list-s32-param")?;
+                        let list_s64_param = lookup("list-s64-param")?;
+                        let list_float32_param = lookup("list-float32-param")?;
+                        let list_float64_param = lookup("list-float64-param")?;
+                        let list_u8_ret = lookup("list-u8-ret")?;
+                        let list_u16_ret = lookup("list-u16-ret")?;
+                        let list_u32_ret = lookup("list-u32-ret")?;
+                        let list_u64_ret = lookup("list-u64-ret")?;
+                        let list_s8_ret = lookup("list-s8-ret")?;
+                        let list_s16_ret = lookup("list-s16-ret")?;
+                        let list_s32_ret = lookup("list-s32-ret")?;
+                        let list_s64_ret = lookup("list-s64-ret")?;
+                        let list_float32_ret = lookup("list-float32-ret")?;
+                        let list_float64_ret = lookup("list-float64-ret")?;
+                        let tuple_list = lookup("tuple-list")?;
+                        let string_list_arg = lookup("string-list-arg")?;
+                        let string_list_ret = lookup("string-list-ret")?;
+                        let tuple_string_list = lookup("tuple-string-list")?;
+                        let string_list = lookup("string-list")?;
+                        let record_list = lookup("record-list")?;
+                        let record_list_reverse = lookup("record-list-reverse")?;
+                        let variant_list = lookup("variant-list")?;
+                        let load_store_everything = lookup("load-store-everything")?;
+                        Ok(GuestIndices {
+                            list_u8_param,
+                            list_u16_param,
+                            list_u32_param,
+                            list_u64_param,
+                            list_s8_param,
+                            list_s16_param,
+                            list_s32_param,
+                            list_s64_param,
+                            list_float32_param,
+                            list_float64_param,
+                            list_u8_ret,
+                            list_u16_ret,
+                            list_u32_ret,
+                            list_u64_ret,
+                            list_s8_ret,
+                            list_s16_ret,
+                            list_s32_ret,
+                            list_s64_ret,
+                            list_float32_ret,
+                            list_float64_ret,
+                            tuple_list,
+                            string_list_arg,
+                            string_list_ret,
+                            tuple_string_list,
+                            string_list,
+                            record_list,
+                            record_list_reverse,
+                            variant_list,
+                            load_store_everything,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let list_u8_param = *_instance
+                            .get_typed_func::<
+                                (&[u8],),
+                                (),
+                            >(&mut store, &self.list_u8_param)?
+                            .func();
+                        let list_u16_param = *_instance
+                            .get_typed_func::<
+                                (&[u16],),
+                                (),
+                            >(&mut store, &self.list_u16_param)?
+                            .func();
+                        let list_u32_param = *_instance
+                            .get_typed_func::<
+                                (&[u32],),
+                                (),
+                            >(&mut store, &self.list_u32_param)?
+                            .func();
+                        let list_u64_param = *_instance
+                            .get_typed_func::<
+                                (&[u64],),
+                                (),
+                            >(&mut store, &self.list_u64_param)?
+                            .func();
+                        let list_s8_param = *_instance
+                            .get_typed_func::<
+                                (&[i8],),
+                                (),
+                            >(&mut store, &self.list_s8_param)?
+                            .func();
+                        let list_s16_param = *_instance
+                            .get_typed_func::<
+                                (&[i16],),
+                                (),
+                            >(&mut store, &self.list_s16_param)?
+                            .func();
+                        let list_s32_param = *_instance
+                            .get_typed_func::<
+                                (&[i32],),
+                                (),
+                            >(&mut store, &self.list_s32_param)?
+                            .func();
+                        let list_s64_param = *_instance
+                            .get_typed_func::<
+                                (&[i64],),
+                                (),
+                            >(&mut store, &self.list_s64_param)?
+                            .func();
+                        let list_float32_param = *_instance
+                            .get_typed_func::<
+                                (&[f32],),
+                                (),
+                            >(&mut store, &self.list_float32_param)?
+                            .func();
+                        let list_float64_param = *_instance
+                            .get_typed_func::<
+                                (&[f64],),
+                                (),
+                            >(&mut store, &self.list_float64_param)?
+                            .func();
+                        let list_u8_ret = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::__internal::Vec<u8>,),
+                            >(&mut store, &self.list_u8_ret)?
+                            .func();
+                        let list_u16_ret = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::__internal::Vec<u16>,),
+                            >(&mut store, &self.list_u16_ret)?
+                            .func();
+                        let list_u32_ret = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::__internal::Vec<u32>,),
+                            >(&mut store, &self.list_u32_ret)?
+                            .func();
+                        let list_u64_ret = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::__internal::Vec<u64>,),
+                            >(&mut store, &self.list_u64_ret)?
+                            .func();
+                        let list_s8_ret = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::__internal::Vec<i8>,),
+                            >(&mut store, &self.list_s8_ret)?
+                            .func();
+                        let list_s16_ret = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::__internal::Vec<i16>,),
+                            >(&mut store, &self.list_s16_ret)?
+                            .func();
+                        let list_s32_ret = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::__internal::Vec<i32>,),
+                            >(&mut store, &self.list_s32_ret)?
+                            .func();
+                        let list_s64_ret = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::__internal::Vec<i64>,),
+                            >(&mut store, &self.list_s64_ret)?
+                            .func();
+                        let list_float32_ret = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::__internal::Vec<f32>,),
+                            >(&mut store, &self.list_float32_ret)?
+                            .func();
+                        let list_float64_ret = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::__internal::Vec<f64>,),
+                            >(&mut store, &self.list_float64_ret)?
+                            .func();
+                        let tuple_list = *_instance
+                            .get_typed_func::<
+                                (&[(u8, i8)],),
+                                (wasmtime::component::__internal::Vec<(i64, u32)>,),
+                            >(&mut store, &self.tuple_list)?
+                            .func();
+                        let string_list_arg = *_instance
+                            .get_typed_func::<
+                                (&[wasmtime::component::__internal::String],),
+                                (),
+                            >(&mut store, &self.string_list_arg)?
+                            .func();
+                        let string_list_ret = *_instance
+                            .get_typed_func::<
+                                (),
+                                (
+                                    wasmtime::component::__internal::Vec<
+                                        wasmtime::component::__internal::String,
+                                    >,
+                                ),
+                            >(&mut store, &self.string_list_ret)?
+                            .func();
+                        let tuple_string_list = *_instance
+                            .get_typed_func::<
+                                (&[(u8, wasmtime::component::__internal::String)],),
+                                (
+                                    wasmtime::component::__internal::Vec<
+                                        (wasmtime::component::__internal::String, u8),
+                                    >,
+                                ),
+                            >(&mut store, &self.tuple_string_list)?
+                            .func();
+                        let string_list = *_instance
+                            .get_typed_func::<
+                                (&[wasmtime::component::__internal::String],),
+                                (
+                                    wasmtime::component::__internal::Vec<
+                                        wasmtime::component::__internal::String,
+                                    >,
+                                ),
+                            >(&mut store, &self.string_list)?
+                            .func();
+                        let record_list = *_instance
+                            .get_typed_func::<
+                                (&[SomeRecord],),
+                                (wasmtime::component::__internal::Vec<OtherRecord>,),
+                            >(&mut store, &self.record_list)?
+                            .func();
+                        let record_list_reverse = *_instance
+                            .get_typed_func::<
+                                (&[OtherRecord],),
+                                (wasmtime::component::__internal::Vec<SomeRecord>,),
+                            >(&mut store, &self.record_list_reverse)?
+                            .func();
+                        let variant_list = *_instance
+                            .get_typed_func::<
+                                (&[SomeVariant],),
+                                (wasmtime::component::__internal::Vec<OtherVariant>,),
+                            >(&mut store, &self.variant_list)?
+                            .func();
+                        let load_store_everything = *_instance
+                            .get_typed_func::<
+                                (&LoadStoreAllSizes,),
+                                (LoadStoreAllSizes,),
+                            >(&mut store, &self.load_store_everything)?
+                            .func();
+                        Ok(Guest {
+                            list_u8_param,
+                            list_u16_param,
+                            list_u32_param,
+                            list_u64_param,
+                            list_s8_param,
+                            list_s16_param,
+                            list_s32_param,
+                            list_s64_param,
+                            list_float32_param,
+                            list_float64_param,
+                            list_u8_ret,
+                            list_u16_ret,
+                            list_u32_ret,
+                            list_u64_ret,
+                            list_s8_ret,
+                            list_s16_ret,
+                            list_s32_ret,
+                            list_s64_ret,
+                            list_float32_ret,
+                            list_float64_ret,
+                            tuple_list,
+                            string_list_arg,
+                            string_list_ret,
+                            tuple_string_list,
+                            string_list,
+                            record_list,
+                            record_list_reverse,
+                            variant_list,
+                            load_store_everything,
+                        })
+                    }
+                }
+                impl Guest {
+                    pub fn call_list_u8_param<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[u8],
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[u8],),
+                                (),
+                            >::new_unchecked(self.list_u8_param)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_list_u16_param<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[u16],
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[u16],),
+                                (),
+                            >::new_unchecked(self.list_u16_param)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_list_u32_param<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[u32],
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[u32],),
+                                (),
+                            >::new_unchecked(self.list_u32_param)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_list_u64_param<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[u64],
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[u64],),
+                                (),
+                            >::new_unchecked(self.list_u64_param)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_list_s8_param<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[i8],
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[i8],),
+                                (),
+                            >::new_unchecked(self.list_s8_param)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_list_s16_param<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[i16],
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[i16],),
+                                (),
+                            >::new_unchecked(self.list_s16_param)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_list_s32_param<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[i32],
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[i32],),
+                                (),
+                            >::new_unchecked(self.list_s32_param)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_list_s64_param<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[i64],
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[i64],),
+                                (),
+                            >::new_unchecked(self.list_s64_param)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_list_float32_param<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[f32],
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[f32],),
+                                (),
+                            >::new_unchecked(self.list_float32_param)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_list_float64_param<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[f64],
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[f64],),
+                                (),
+                            >::new_unchecked(self.list_float64_param)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_list_u8_ret<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::__internal::Vec<u8>> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::__internal::Vec<u8>,),
+                            >::new_unchecked(self.list_u8_ret)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_list_u16_ret<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::__internal::Vec<u16>> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::__internal::Vec<u16>,),
+                            >::new_unchecked(self.list_u16_ret)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_list_u32_ret<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::__internal::Vec<u32>> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::__internal::Vec<u32>,),
+                            >::new_unchecked(self.list_u32_ret)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_list_u64_ret<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::__internal::Vec<u64>> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::__internal::Vec<u64>,),
+                            >::new_unchecked(self.list_u64_ret)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_list_s8_ret<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::__internal::Vec<i8>> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::__internal::Vec<i8>,),
+                            >::new_unchecked(self.list_s8_ret)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_list_s16_ret<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::__internal::Vec<i16>> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::__internal::Vec<i16>,),
+                            >::new_unchecked(self.list_s16_ret)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_list_s32_ret<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::__internal::Vec<i32>> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::__internal::Vec<i32>,),
+                            >::new_unchecked(self.list_s32_ret)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_list_s64_ret<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::__internal::Vec<i64>> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::__internal::Vec<i64>,),
+                            >::new_unchecked(self.list_s64_ret)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_list_float32_ret<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::__internal::Vec<f32>> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::__internal::Vec<f32>,),
+                            >::new_unchecked(self.list_float32_ret)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_list_float64_ret<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::__internal::Vec<f64>> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::__internal::Vec<f64>,),
+                            >::new_unchecked(self.list_float64_ret)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_tuple_list<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[(u8, i8)],
+                    ) -> wasmtime::Result<
+                        wasmtime::component::__internal::Vec<(i64, u32)>,
+                    > {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[(u8, i8)],),
+                                (wasmtime::component::__internal::Vec<(i64, u32)>,),
+                            >::new_unchecked(self.tuple_list)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_string_list_arg<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[wasmtime::component::__internal::String],
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[wasmtime::component::__internal::String],),
+                                (),
+                            >::new_unchecked(self.string_list_arg)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_string_list_ret<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<
+                        wasmtime::component::__internal::Vec<
+                            wasmtime::component::__internal::String,
+                        >,
+                    > {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (
+                                    wasmtime::component::__internal::Vec<
+                                        wasmtime::component::__internal::String,
+                                    >,
+                                ),
+                            >::new_unchecked(self.string_list_ret)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_tuple_string_list<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[(u8, wasmtime::component::__internal::String)],
+                    ) -> wasmtime::Result<
+                        wasmtime::component::__internal::Vec<
+                            (wasmtime::component::__internal::String, u8),
+                        >,
+                    > {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[(u8, wasmtime::component::__internal::String)],),
+                                (
+                                    wasmtime::component::__internal::Vec<
+                                        (wasmtime::component::__internal::String, u8),
+                                    >,
+                                ),
+                            >::new_unchecked(self.tuple_string_list)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_string_list<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[wasmtime::component::__internal::String],
+                    ) -> wasmtime::Result<
+                        wasmtime::component::__internal::Vec<
+                            wasmtime::component::__internal::String,
+                        >,
+                    > {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[wasmtime::component::__internal::String],),
+                                (
+                                    wasmtime::component::__internal::Vec<
+                                        wasmtime::component::__internal::String,
+                                    >,
+                                ),
+                            >::new_unchecked(self.string_list)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_record_list<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[SomeRecord],
+                    ) -> wasmtime::Result<
+                        wasmtime::component::__internal::Vec<OtherRecord>,
+                    > {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[SomeRecord],),
+                                (wasmtime::component::__internal::Vec<OtherRecord>,),
+                            >::new_unchecked(self.record_list)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_record_list_reverse<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[OtherRecord],
+                    ) -> wasmtime::Result<
+                        wasmtime::component::__internal::Vec<SomeRecord>,
+                    > {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[OtherRecord],),
+                                (wasmtime::component::__internal::Vec<SomeRecord>,),
+                            >::new_unchecked(self.record_list_reverse)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_variant_list<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[SomeVariant],
+                    ) -> wasmtime::Result<
+                        wasmtime::component::__internal::Vec<OtherVariant>,
+                    > {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[SomeVariant],),
+                                (wasmtime::component::__internal::Vec<OtherVariant>,),
+                            >::new_unchecked(self.variant_list)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_load_store_everything<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &LoadStoreAllSizes,
+                    ) -> wasmtime::Result<LoadStoreAllSizes> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&LoadStoreAllSizes,),
+                                (LoadStoreAllSizes,),
+                            >::new_unchecked(self.load_store_everything)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/lists_async.rs b/crates/component-macro/tests/expanded/lists_async.rs
new file mode 100644
index 000000000000..63d0fd7ff69f
--- /dev/null
+++ b/crates/component-macro/tests/expanded/lists_async.rs
@@ -0,0 +1,2230 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-lists`.
+///
+/// This structure is created through [`TheListsPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheLists`] as well.
+pub struct TheListsPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheListsIndices,
+}
+impl<T> Clone for TheListsPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheListsPre<_T> {
+    /// Creates a new copy of `TheListsPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheListsIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheLists`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheLists>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-lists`.
+///
+/// This is an implementation detail of [`TheListsPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheLists`] as well.
+#[derive(Clone)]
+pub struct TheListsIndices {
+    interface0: exports::foo::foo::lists::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-lists`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheLists::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheListsPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheListsPre::instantiate_async`] to
+///   create a [`TheLists`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheLists::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheListsIndices::new_instance`] followed
+///   by [`TheListsIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheLists {
+    interface0: exports::foo::foo::lists::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheListsIndices {
+        /// Creates a new copy of `TheListsIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::lists::GuestIndices::new(_component)?;
+            Ok(TheListsIndices { interface0 })
+        }
+        /// Creates a new instance of [`TheListsIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheLists`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheLists`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::lists::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(TheListsIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheLists`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheLists> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(TheLists { interface0 })
+        }
+    }
+    impl TheLists {
+        /// Convenience wrapper around [`TheListsPre::new`] and
+        /// [`TheListsPre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheLists>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            TheListsPre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`TheListsIndices::new_instance`] and
+        /// [`TheListsIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheLists> {
+            let indices = TheListsIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+            U: foo::foo::lists::Host + Send,
+        {
+            foo::foo::lists::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_lists(&self) -> &exports::foo::foo::lists::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod lists {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone)]
+            pub struct OtherRecord {
+                #[component(name = "a1")]
+                pub a1: u32,
+                #[component(name = "a2")]
+                pub a2: u64,
+                #[component(name = "a3")]
+                pub a3: i32,
+                #[component(name = "a4")]
+                pub a4: i64,
+                #[component(name = "b")]
+                pub b: wasmtime::component::__internal::String,
+                #[component(name = "c")]
+                pub c: wasmtime::component::__internal::Vec<u8>,
+            }
+            impl core::fmt::Debug for OtherRecord {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("OtherRecord")
+                        .field("a1", &self.a1)
+                        .field("a2", &self.a2)
+                        .field("a3", &self.a3)
+                        .field("a4", &self.a4)
+                        .field("b", &self.b)
+                        .field("c", &self.c)
+                        .finish()
+                }
+            }
+            const _: () = {
+                assert!(
+                    48 == < OtherRecord as wasmtime::component::ComponentType >::SIZE32
+                );
+                assert!(
+                    8 == < OtherRecord as wasmtime::component::ComponentType >::ALIGN32
+                );
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone)]
+            pub struct SomeRecord {
+                #[component(name = "x")]
+                pub x: wasmtime::component::__internal::String,
+                #[component(name = "y")]
+                pub y: OtherRecord,
+                #[component(name = "z")]
+                pub z: wasmtime::component::__internal::Vec<OtherRecord>,
+                #[component(name = "c1")]
+                pub c1: u32,
+                #[component(name = "c2")]
+                pub c2: u64,
+                #[component(name = "c3")]
+                pub c3: i32,
+                #[component(name = "c4")]
+                pub c4: i64,
+            }
+            impl core::fmt::Debug for SomeRecord {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("SomeRecord")
+                        .field("x", &self.x)
+                        .field("y", &self.y)
+                        .field("z", &self.z)
+                        .field("c1", &self.c1)
+                        .field("c2", &self.c2)
+                        .field("c3", &self.c3)
+                        .field("c4", &self.c4)
+                        .finish()
+                }
+            }
+            const _: () = {
+                assert!(
+                    96 == < SomeRecord as wasmtime::component::ComponentType >::SIZE32
+                );
+                assert!(
+                    8 == < SomeRecord as wasmtime::component::ComponentType >::ALIGN32
+                );
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(variant)]
+            #[derive(Clone)]
+            pub enum OtherVariant {
+                #[component(name = "a")]
+                A,
+                #[component(name = "b")]
+                B(u32),
+                #[component(name = "c")]
+                C(wasmtime::component::__internal::String),
+            }
+            impl core::fmt::Debug for OtherVariant {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    match self {
+                        OtherVariant::A => f.debug_tuple("OtherVariant::A").finish(),
+                        OtherVariant::B(e) => {
+                            f.debug_tuple("OtherVariant::B").field(e).finish()
+                        }
+                        OtherVariant::C(e) => {
+                            f.debug_tuple("OtherVariant::C").field(e).finish()
+                        }
+                    }
+                }
+            }
+            const _: () = {
+                assert!(
+                    12 == < OtherVariant as wasmtime::component::ComponentType >::SIZE32
+                );
+                assert!(
+                    4 == < OtherVariant as wasmtime::component::ComponentType >::ALIGN32
+                );
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(variant)]
+            #[derive(Clone)]
+            pub enum SomeVariant {
+                #[component(name = "a")]
+                A(wasmtime::component::__internal::String),
+                #[component(name = "b")]
+                B,
+                #[component(name = "c")]
+                C(u32),
+                #[component(name = "d")]
+                D(wasmtime::component::__internal::Vec<OtherVariant>),
+            }
+            impl core::fmt::Debug for SomeVariant {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    match self {
+                        SomeVariant::A(e) => {
+                            f.debug_tuple("SomeVariant::A").field(e).finish()
+                        }
+                        SomeVariant::B => f.debug_tuple("SomeVariant::B").finish(),
+                        SomeVariant::C(e) => {
+                            f.debug_tuple("SomeVariant::C").field(e).finish()
+                        }
+                        SomeVariant::D(e) => {
+                            f.debug_tuple("SomeVariant::D").field(e).finish()
+                        }
+                    }
+                }
+            }
+            const _: () = {
+                assert!(
+                    12 == < SomeVariant as wasmtime::component::ComponentType >::SIZE32
+                );
+                assert!(
+                    4 == < SomeVariant as wasmtime::component::ComponentType >::ALIGN32
+                );
+            };
+            pub type LoadStoreAllSizes = wasmtime::component::__internal::Vec<
+                (
+                    wasmtime::component::__internal::String,
+                    u8,
+                    i8,
+                    u16,
+                    i16,
+                    u32,
+                    i32,
+                    u64,
+                    i64,
+                    f32,
+                    f64,
+                    char,
+                ),
+            >;
+            const _: () = {
+                assert!(
+                    8 == < LoadStoreAllSizes as wasmtime::component::ComponentType
+                    >::SIZE32
+                );
+                assert!(
+                    4 == < LoadStoreAllSizes as wasmtime::component::ComponentType
+                    >::ALIGN32
+                );
+            };
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {
+                async fn list_u8_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<u8>,
+                ) -> ();
+                async fn list_u16_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<u16>,
+                ) -> ();
+                async fn list_u32_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<u32>,
+                ) -> ();
+                async fn list_u64_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<u64>,
+                ) -> ();
+                async fn list_s8_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<i8>,
+                ) -> ();
+                async fn list_s16_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<i16>,
+                ) -> ();
+                async fn list_s32_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<i32>,
+                ) -> ();
+                async fn list_s64_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<i64>,
+                ) -> ();
+                async fn list_float32_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<f32>,
+                ) -> ();
+                async fn list_float64_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<f64>,
+                ) -> ();
+                async fn list_u8_ret(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<u8>;
+                async fn list_u16_ret(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<u16>;
+                async fn list_u32_ret(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<u32>;
+                async fn list_u64_ret(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<u64>;
+                async fn list_s8_ret(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<i8>;
+                async fn list_s16_ret(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<i16>;
+                async fn list_s32_ret(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<i32>;
+                async fn list_s64_ret(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<i64>;
+                async fn list_float32_ret(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<f32>;
+                async fn list_float64_ret(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<f64>;
+                async fn tuple_list(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<(u8, i8)>,
+                ) -> wasmtime::component::__internal::Vec<(i64, u32)>;
+                async fn string_list_arg(
+                    &mut self,
+                    a: wasmtime::component::__internal::Vec<
+                        wasmtime::component::__internal::String,
+                    >,
+                ) -> ();
+                async fn string_list_ret(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<
+                    wasmtime::component::__internal::String,
+                >;
+                async fn tuple_string_list(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<
+                        (u8, wasmtime::component::__internal::String),
+                    >,
+                ) -> wasmtime::component::__internal::Vec<
+                    (wasmtime::component::__internal::String, u8),
+                >;
+                async fn string_list(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<
+                        wasmtime::component::__internal::String,
+                    >,
+                ) -> wasmtime::component::__internal::Vec<
+                    wasmtime::component::__internal::String,
+                >;
+                async fn record_list(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<SomeRecord>,
+                ) -> wasmtime::component::__internal::Vec<OtherRecord>;
+                async fn record_list_reverse(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<OtherRecord>,
+                ) -> wasmtime::component::__internal::Vec<SomeRecord>;
+                async fn variant_list(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<SomeVariant>,
+                ) -> wasmtime::component::__internal::Vec<OtherVariant>;
+                async fn load_store_everything(
+                    &mut self,
+                    a: LoadStoreAllSizes,
+                ) -> LoadStoreAllSizes;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/lists")?;
+                inst.func_wrap_async(
+                    "list-u8-param",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<u8>,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_u8_param(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "list-u16-param",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<u16>,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_u16_param(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "list-u32-param",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<u32>,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_u32_param(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "list-u64-param",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<u64>,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_u64_param(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "list-s8-param",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<i8>,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_s8_param(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "list-s16-param",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<i16>,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_s16_param(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "list-s32-param",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<i32>,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_s32_param(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "list-s64-param",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<i64>,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_s64_param(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "list-float32-param",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<f32>,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_float32_param(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "list-float64-param",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<f64>,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_float64_param(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "list-u8-ret",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_u8_ret(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "list-u16-ret",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_u16_ret(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "list-u32-ret",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_u32_ret(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "list-u64-ret",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_u64_ret(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "list-s8-ret",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_s8_ret(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "list-s16-ret",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_s16_ret(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "list-s32-ret",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_s32_ret(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "list-s64-ret",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_s64_ret(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "list-float32-ret",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_float32_ret(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "list-float64-ret",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_float64_ret(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "tuple-list",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<(u8, i8)>,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::tuple_list(host, arg0).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "string-list-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (
+                            arg0,
+                        ): (
+                            wasmtime::component::__internal::Vec<
+                                wasmtime::component::__internal::String,
+                            >,
+                        )|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::string_list_arg(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "string-list-ret",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::string_list_ret(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "tuple-string-list",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (
+                            arg0,
+                        ): (
+                            wasmtime::component::__internal::Vec<
+                                (u8, wasmtime::component::__internal::String),
+                            >,
+                        )|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::tuple_string_list(host, arg0).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "string-list",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (
+                            arg0,
+                        ): (
+                            wasmtime::component::__internal::Vec<
+                                wasmtime::component::__internal::String,
+                            >,
+                        )|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::string_list(host, arg0).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "record-list",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<SomeRecord>,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::record_list(host, arg0).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "record-list-reverse",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<OtherRecord>,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::record_list_reverse(host, arg0).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "variant-list",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<SomeVariant>,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::variant_list(host, arg0).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "load-store-everything",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (LoadStoreAllSizes,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::load_store_everything(host, arg0).await;
+                        Ok((r,))
+                    }),
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {
+                async fn list_u8_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<u8>,
+                ) -> () {
+                    Host::list_u8_param(*self, x).await
+                }
+                async fn list_u16_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<u16>,
+                ) -> () {
+                    Host::list_u16_param(*self, x).await
+                }
+                async fn list_u32_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<u32>,
+                ) -> () {
+                    Host::list_u32_param(*self, x).await
+                }
+                async fn list_u64_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<u64>,
+                ) -> () {
+                    Host::list_u64_param(*self, x).await
+                }
+                async fn list_s8_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<i8>,
+                ) -> () {
+                    Host::list_s8_param(*self, x).await
+                }
+                async fn list_s16_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<i16>,
+                ) -> () {
+                    Host::list_s16_param(*self, x).await
+                }
+                async fn list_s32_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<i32>,
+                ) -> () {
+                    Host::list_s32_param(*self, x).await
+                }
+                async fn list_s64_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<i64>,
+                ) -> () {
+                    Host::list_s64_param(*self, x).await
+                }
+                async fn list_float32_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<f32>,
+                ) -> () {
+                    Host::list_float32_param(*self, x).await
+                }
+                async fn list_float64_param(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<f64>,
+                ) -> () {
+                    Host::list_float64_param(*self, x).await
+                }
+                async fn list_u8_ret(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<u8> {
+                    Host::list_u8_ret(*self).await
+                }
+                async fn list_u16_ret(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<u16> {
+                    Host::list_u16_ret(*self).await
+                }
+                async fn list_u32_ret(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<u32> {
+                    Host::list_u32_ret(*self).await
+                }
+                async fn list_u64_ret(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<u64> {
+                    Host::list_u64_ret(*self).await
+                }
+                async fn list_s8_ret(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<i8> {
+                    Host::list_s8_ret(*self).await
+                }
+                async fn list_s16_ret(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<i16> {
+                    Host::list_s16_ret(*self).await
+                }
+                async fn list_s32_ret(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<i32> {
+                    Host::list_s32_ret(*self).await
+                }
+                async fn list_s64_ret(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<i64> {
+                    Host::list_s64_ret(*self).await
+                }
+                async fn list_float32_ret(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<f32> {
+                    Host::list_float32_ret(*self).await
+                }
+                async fn list_float64_ret(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<f64> {
+                    Host::list_float64_ret(*self).await
+                }
+                async fn tuple_list(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<(u8, i8)>,
+                ) -> wasmtime::component::__internal::Vec<(i64, u32)> {
+                    Host::tuple_list(*self, x).await
+                }
+                async fn string_list_arg(
+                    &mut self,
+                    a: wasmtime::component::__internal::Vec<
+                        wasmtime::component::__internal::String,
+                    >,
+                ) -> () {
+                    Host::string_list_arg(*self, a).await
+                }
+                async fn string_list_ret(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<
+                    wasmtime::component::__internal::String,
+                > {
+                    Host::string_list_ret(*self).await
+                }
+                async fn tuple_string_list(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<
+                        (u8, wasmtime::component::__internal::String),
+                    >,
+                ) -> wasmtime::component::__internal::Vec<
+                    (wasmtime::component::__internal::String, u8),
+                > {
+                    Host::tuple_string_list(*self, x).await
+                }
+                async fn string_list(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<
+                        wasmtime::component::__internal::String,
+                    >,
+                ) -> wasmtime::component::__internal::Vec<
+                    wasmtime::component::__internal::String,
+                > {
+                    Host::string_list(*self, x).await
+                }
+                async fn record_list(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<SomeRecord>,
+                ) -> wasmtime::component::__internal::Vec<OtherRecord> {
+                    Host::record_list(*self, x).await
+                }
+                async fn record_list_reverse(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<OtherRecord>,
+                ) -> wasmtime::component::__internal::Vec<SomeRecord> {
+                    Host::record_list_reverse(*self, x).await
+                }
+                async fn variant_list(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<SomeVariant>,
+                ) -> wasmtime::component::__internal::Vec<OtherVariant> {
+                    Host::variant_list(*self, x).await
+                }
+                async fn load_store_everything(
+                    &mut self,
+                    a: LoadStoreAllSizes,
+                ) -> LoadStoreAllSizes {
+                    Host::load_store_everything(*self, a).await
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod lists {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(record)]
+                #[derive(Clone)]
+                pub struct OtherRecord {
+                    #[component(name = "a1")]
+                    pub a1: u32,
+                    #[component(name = "a2")]
+                    pub a2: u64,
+                    #[component(name = "a3")]
+                    pub a3: i32,
+                    #[component(name = "a4")]
+                    pub a4: i64,
+                    #[component(name = "b")]
+                    pub b: wasmtime::component::__internal::String,
+                    #[component(name = "c")]
+                    pub c: wasmtime::component::__internal::Vec<u8>,
+                }
+                impl core::fmt::Debug for OtherRecord {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        f.debug_struct("OtherRecord")
+                            .field("a1", &self.a1)
+                            .field("a2", &self.a2)
+                            .field("a3", &self.a3)
+                            .field("a4", &self.a4)
+                            .field("b", &self.b)
+                            .field("c", &self.c)
+                            .finish()
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        48 == < OtherRecord as wasmtime::component::ComponentType
+                        >::SIZE32
+                    );
+                    assert!(
+                        8 == < OtherRecord as wasmtime::component::ComponentType
+                        >::ALIGN32
+                    );
+                };
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(record)]
+                #[derive(Clone)]
+                pub struct SomeRecord {
+                    #[component(name = "x")]
+                    pub x: wasmtime::component::__internal::String,
+                    #[component(name = "y")]
+                    pub y: OtherRecord,
+                    #[component(name = "z")]
+                    pub z: wasmtime::component::__internal::Vec<OtherRecord>,
+                    #[component(name = "c1")]
+                    pub c1: u32,
+                    #[component(name = "c2")]
+                    pub c2: u64,
+                    #[component(name = "c3")]
+                    pub c3: i32,
+                    #[component(name = "c4")]
+                    pub c4: i64,
+                }
+                impl core::fmt::Debug for SomeRecord {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        f.debug_struct("SomeRecord")
+                            .field("x", &self.x)
+                            .field("y", &self.y)
+                            .field("z", &self.z)
+                            .field("c1", &self.c1)
+                            .field("c2", &self.c2)
+                            .field("c3", &self.c3)
+                            .field("c4", &self.c4)
+                            .finish()
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        96 == < SomeRecord as wasmtime::component::ComponentType
+                        >::SIZE32
+                    );
+                    assert!(
+                        8 == < SomeRecord as wasmtime::component::ComponentType
+                        >::ALIGN32
+                    );
+                };
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(variant)]
+                #[derive(Clone)]
+                pub enum OtherVariant {
+                    #[component(name = "a")]
+                    A,
+                    #[component(name = "b")]
+                    B(u32),
+                    #[component(name = "c")]
+                    C(wasmtime::component::__internal::String),
+                }
+                impl core::fmt::Debug for OtherVariant {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        match self {
+                            OtherVariant::A => f.debug_tuple("OtherVariant::A").finish(),
+                            OtherVariant::B(e) => {
+                                f.debug_tuple("OtherVariant::B").field(e).finish()
+                            }
+                            OtherVariant::C(e) => {
+                                f.debug_tuple("OtherVariant::C").field(e).finish()
+                            }
+                        }
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        12 == < OtherVariant as wasmtime::component::ComponentType
+                        >::SIZE32
+                    );
+                    assert!(
+                        4 == < OtherVariant as wasmtime::component::ComponentType
+                        >::ALIGN32
+                    );
+                };
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(variant)]
+                #[derive(Clone)]
+                pub enum SomeVariant {
+                    #[component(name = "a")]
+                    A(wasmtime::component::__internal::String),
+                    #[component(name = "b")]
+                    B,
+                    #[component(name = "c")]
+                    C(u32),
+                    #[component(name = "d")]
+                    D(wasmtime::component::__internal::Vec<OtherVariant>),
+                }
+                impl core::fmt::Debug for SomeVariant {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        match self {
+                            SomeVariant::A(e) => {
+                                f.debug_tuple("SomeVariant::A").field(e).finish()
+                            }
+                            SomeVariant::B => f.debug_tuple("SomeVariant::B").finish(),
+                            SomeVariant::C(e) => {
+                                f.debug_tuple("SomeVariant::C").field(e).finish()
+                            }
+                            SomeVariant::D(e) => {
+                                f.debug_tuple("SomeVariant::D").field(e).finish()
+                            }
+                        }
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        12 == < SomeVariant as wasmtime::component::ComponentType
+                        >::SIZE32
+                    );
+                    assert!(
+                        4 == < SomeVariant as wasmtime::component::ComponentType
+                        >::ALIGN32
+                    );
+                };
+                pub type LoadStoreAllSizes = wasmtime::component::__internal::Vec<
+                    (
+                        wasmtime::component::__internal::String,
+                        u8,
+                        i8,
+                        u16,
+                        i16,
+                        u32,
+                        i32,
+                        u64,
+                        i64,
+                        f32,
+                        f64,
+                        char,
+                    ),
+                >;
+                const _: () = {
+                    assert!(
+                        8 == < LoadStoreAllSizes as wasmtime::component::ComponentType
+                        >::SIZE32
+                    );
+                    assert!(
+                        4 == < LoadStoreAllSizes as wasmtime::component::ComponentType
+                        >::ALIGN32
+                    );
+                };
+                pub struct Guest {
+                    list_u8_param: wasmtime::component::Func,
+                    list_u16_param: wasmtime::component::Func,
+                    list_u32_param: wasmtime::component::Func,
+                    list_u64_param: wasmtime::component::Func,
+                    list_s8_param: wasmtime::component::Func,
+                    list_s16_param: wasmtime::component::Func,
+                    list_s32_param: wasmtime::component::Func,
+                    list_s64_param: wasmtime::component::Func,
+                    list_float32_param: wasmtime::component::Func,
+                    list_float64_param: wasmtime::component::Func,
+                    list_u8_ret: wasmtime::component::Func,
+                    list_u16_ret: wasmtime::component::Func,
+                    list_u32_ret: wasmtime::component::Func,
+                    list_u64_ret: wasmtime::component::Func,
+                    list_s8_ret: wasmtime::component::Func,
+                    list_s16_ret: wasmtime::component::Func,
+                    list_s32_ret: wasmtime::component::Func,
+                    list_s64_ret: wasmtime::component::Func,
+                    list_float32_ret: wasmtime::component::Func,
+                    list_float64_ret: wasmtime::component::Func,
+                    tuple_list: wasmtime::component::Func,
+                    string_list_arg: wasmtime::component::Func,
+                    string_list_ret: wasmtime::component::Func,
+                    tuple_string_list: wasmtime::component::Func,
+                    string_list: wasmtime::component::Func,
+                    record_list: wasmtime::component::Func,
+                    record_list_reverse: wasmtime::component::Func,
+                    variant_list: wasmtime::component::Func,
+                    load_store_everything: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    list_u8_param: wasmtime::component::ComponentExportIndex,
+                    list_u16_param: wasmtime::component::ComponentExportIndex,
+                    list_u32_param: wasmtime::component::ComponentExportIndex,
+                    list_u64_param: wasmtime::component::ComponentExportIndex,
+                    list_s8_param: wasmtime::component::ComponentExportIndex,
+                    list_s16_param: wasmtime::component::ComponentExportIndex,
+                    list_s32_param: wasmtime::component::ComponentExportIndex,
+                    list_s64_param: wasmtime::component::ComponentExportIndex,
+                    list_float32_param: wasmtime::component::ComponentExportIndex,
+                    list_float64_param: wasmtime::component::ComponentExportIndex,
+                    list_u8_ret: wasmtime::component::ComponentExportIndex,
+                    list_u16_ret: wasmtime::component::ComponentExportIndex,
+                    list_u32_ret: wasmtime::component::ComponentExportIndex,
+                    list_u64_ret: wasmtime::component::ComponentExportIndex,
+                    list_s8_ret: wasmtime::component::ComponentExportIndex,
+                    list_s16_ret: wasmtime::component::ComponentExportIndex,
+                    list_s32_ret: wasmtime::component::ComponentExportIndex,
+                    list_s64_ret: wasmtime::component::ComponentExportIndex,
+                    list_float32_ret: wasmtime::component::ComponentExportIndex,
+                    list_float64_ret: wasmtime::component::ComponentExportIndex,
+                    tuple_list: wasmtime::component::ComponentExportIndex,
+                    string_list_arg: wasmtime::component::ComponentExportIndex,
+                    string_list_ret: wasmtime::component::ComponentExportIndex,
+                    tuple_string_list: wasmtime::component::ComponentExportIndex,
+                    string_list: wasmtime::component::ComponentExportIndex,
+                    record_list: wasmtime::component::ComponentExportIndex,
+                    record_list_reverse: wasmtime::component::ComponentExportIndex,
+                    variant_list: wasmtime::component::ComponentExportIndex,
+                    load_store_everything: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/lists")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/lists`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/lists")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/lists`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/lists` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let list_u8_param = lookup("list-u8-param")?;
+                        let list_u16_param = lookup("list-u16-param")?;
+                        let list_u32_param = lookup("list-u32-param")?;
+                        let list_u64_param = lookup("list-u64-param")?;
+                        let list_s8_param = lookup("list-s8-param")?;
+                        let list_s16_param = lookup("list-s16-param")?;
+                        let list_s32_param = lookup("list-s32-param")?;
+                        let list_s64_param = lookup("list-s64-param")?;
+                        let list_float32_param = lookup("list-float32-param")?;
+                        let list_float64_param = lookup("list-float64-param")?;
+                        let list_u8_ret = lookup("list-u8-ret")?;
+                        let list_u16_ret = lookup("list-u16-ret")?;
+                        let list_u32_ret = lookup("list-u32-ret")?;
+                        let list_u64_ret = lookup("list-u64-ret")?;
+                        let list_s8_ret = lookup("list-s8-ret")?;
+                        let list_s16_ret = lookup("list-s16-ret")?;
+                        let list_s32_ret = lookup("list-s32-ret")?;
+                        let list_s64_ret = lookup("list-s64-ret")?;
+                        let list_float32_ret = lookup("list-float32-ret")?;
+                        let list_float64_ret = lookup("list-float64-ret")?;
+                        let tuple_list = lookup("tuple-list")?;
+                        let string_list_arg = lookup("string-list-arg")?;
+                        let string_list_ret = lookup("string-list-ret")?;
+                        let tuple_string_list = lookup("tuple-string-list")?;
+                        let string_list = lookup("string-list")?;
+                        let record_list = lookup("record-list")?;
+                        let record_list_reverse = lookup("record-list-reverse")?;
+                        let variant_list = lookup("variant-list")?;
+                        let load_store_everything = lookup("load-store-everything")?;
+                        Ok(GuestIndices {
+                            list_u8_param,
+                            list_u16_param,
+                            list_u32_param,
+                            list_u64_param,
+                            list_s8_param,
+                            list_s16_param,
+                            list_s32_param,
+                            list_s64_param,
+                            list_float32_param,
+                            list_float64_param,
+                            list_u8_ret,
+                            list_u16_ret,
+                            list_u32_ret,
+                            list_u64_ret,
+                            list_s8_ret,
+                            list_s16_ret,
+                            list_s32_ret,
+                            list_s64_ret,
+                            list_float32_ret,
+                            list_float64_ret,
+                            tuple_list,
+                            string_list_arg,
+                            string_list_ret,
+                            tuple_string_list,
+                            string_list,
+                            record_list,
+                            record_list_reverse,
+                            variant_list,
+                            load_store_everything,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let list_u8_param = *_instance
+                            .get_typed_func::<
+                                (&[u8],),
+                                (),
+                            >(&mut store, &self.list_u8_param)?
+                            .func();
+                        let list_u16_param = *_instance
+                            .get_typed_func::<
+                                (&[u16],),
+                                (),
+                            >(&mut store, &self.list_u16_param)?
+                            .func();
+                        let list_u32_param = *_instance
+                            .get_typed_func::<
+                                (&[u32],),
+                                (),
+                            >(&mut store, &self.list_u32_param)?
+                            .func();
+                        let list_u64_param = *_instance
+                            .get_typed_func::<
+                                (&[u64],),
+                                (),
+                            >(&mut store, &self.list_u64_param)?
+                            .func();
+                        let list_s8_param = *_instance
+                            .get_typed_func::<
+                                (&[i8],),
+                                (),
+                            >(&mut store, &self.list_s8_param)?
+                            .func();
+                        let list_s16_param = *_instance
+                            .get_typed_func::<
+                                (&[i16],),
+                                (),
+                            >(&mut store, &self.list_s16_param)?
+                            .func();
+                        let list_s32_param = *_instance
+                            .get_typed_func::<
+                                (&[i32],),
+                                (),
+                            >(&mut store, &self.list_s32_param)?
+                            .func();
+                        let list_s64_param = *_instance
+                            .get_typed_func::<
+                                (&[i64],),
+                                (),
+                            >(&mut store, &self.list_s64_param)?
+                            .func();
+                        let list_float32_param = *_instance
+                            .get_typed_func::<
+                                (&[f32],),
+                                (),
+                            >(&mut store, &self.list_float32_param)?
+                            .func();
+                        let list_float64_param = *_instance
+                            .get_typed_func::<
+                                (&[f64],),
+                                (),
+                            >(&mut store, &self.list_float64_param)?
+                            .func();
+                        let list_u8_ret = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::__internal::Vec<u8>,),
+                            >(&mut store, &self.list_u8_ret)?
+                            .func();
+                        let list_u16_ret = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::__internal::Vec<u16>,),
+                            >(&mut store, &self.list_u16_ret)?
+                            .func();
+                        let list_u32_ret = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::__internal::Vec<u32>,),
+                            >(&mut store, &self.list_u32_ret)?
+                            .func();
+                        let list_u64_ret = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::__internal::Vec<u64>,),
+                            >(&mut store, &self.list_u64_ret)?
+                            .func();
+                        let list_s8_ret = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::__internal::Vec<i8>,),
+                            >(&mut store, &self.list_s8_ret)?
+                            .func();
+                        let list_s16_ret = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::__internal::Vec<i16>,),
+                            >(&mut store, &self.list_s16_ret)?
+                            .func();
+                        let list_s32_ret = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::__internal::Vec<i32>,),
+                            >(&mut store, &self.list_s32_ret)?
+                            .func();
+                        let list_s64_ret = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::__internal::Vec<i64>,),
+                            >(&mut store, &self.list_s64_ret)?
+                            .func();
+                        let list_float32_ret = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::__internal::Vec<f32>,),
+                            >(&mut store, &self.list_float32_ret)?
+                            .func();
+                        let list_float64_ret = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::__internal::Vec<f64>,),
+                            >(&mut store, &self.list_float64_ret)?
+                            .func();
+                        let tuple_list = *_instance
+                            .get_typed_func::<
+                                (&[(u8, i8)],),
+                                (wasmtime::component::__internal::Vec<(i64, u32)>,),
+                            >(&mut store, &self.tuple_list)?
+                            .func();
+                        let string_list_arg = *_instance
+                            .get_typed_func::<
+                                (&[wasmtime::component::__internal::String],),
+                                (),
+                            >(&mut store, &self.string_list_arg)?
+                            .func();
+                        let string_list_ret = *_instance
+                            .get_typed_func::<
+                                (),
+                                (
+                                    wasmtime::component::__internal::Vec<
+                                        wasmtime::component::__internal::String,
+                                    >,
+                                ),
+                            >(&mut store, &self.string_list_ret)?
+                            .func();
+                        let tuple_string_list = *_instance
+                            .get_typed_func::<
+                                (&[(u8, wasmtime::component::__internal::String)],),
+                                (
+                                    wasmtime::component::__internal::Vec<
+                                        (wasmtime::component::__internal::String, u8),
+                                    >,
+                                ),
+                            >(&mut store, &self.tuple_string_list)?
+                            .func();
+                        let string_list = *_instance
+                            .get_typed_func::<
+                                (&[wasmtime::component::__internal::String],),
+                                (
+                                    wasmtime::component::__internal::Vec<
+                                        wasmtime::component::__internal::String,
+                                    >,
+                                ),
+                            >(&mut store, &self.string_list)?
+                            .func();
+                        let record_list = *_instance
+                            .get_typed_func::<
+                                (&[SomeRecord],),
+                                (wasmtime::component::__internal::Vec<OtherRecord>,),
+                            >(&mut store, &self.record_list)?
+                            .func();
+                        let record_list_reverse = *_instance
+                            .get_typed_func::<
+                                (&[OtherRecord],),
+                                (wasmtime::component::__internal::Vec<SomeRecord>,),
+                            >(&mut store, &self.record_list_reverse)?
+                            .func();
+                        let variant_list = *_instance
+                            .get_typed_func::<
+                                (&[SomeVariant],),
+                                (wasmtime::component::__internal::Vec<OtherVariant>,),
+                            >(&mut store, &self.variant_list)?
+                            .func();
+                        let load_store_everything = *_instance
+                            .get_typed_func::<
+                                (&LoadStoreAllSizes,),
+                                (LoadStoreAllSizes,),
+                            >(&mut store, &self.load_store_everything)?
+                            .func();
+                        Ok(Guest {
+                            list_u8_param,
+                            list_u16_param,
+                            list_u32_param,
+                            list_u64_param,
+                            list_s8_param,
+                            list_s16_param,
+                            list_s32_param,
+                            list_s64_param,
+                            list_float32_param,
+                            list_float64_param,
+                            list_u8_ret,
+                            list_u16_ret,
+                            list_u32_ret,
+                            list_u64_ret,
+                            list_s8_ret,
+                            list_s16_ret,
+                            list_s32_ret,
+                            list_s64_ret,
+                            list_float32_ret,
+                            list_float64_ret,
+                            tuple_list,
+                            string_list_arg,
+                            string_list_ret,
+                            tuple_string_list,
+                            string_list,
+                            record_list,
+                            record_list_reverse,
+                            variant_list,
+                            load_store_everything,
+                        })
+                    }
+                }
+                impl Guest {
+                    pub async fn call_list_u8_param<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[u8],
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[u8],),
+                                (),
+                            >::new_unchecked(self.list_u8_param)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_list_u16_param<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[u16],
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[u16],),
+                                (),
+                            >::new_unchecked(self.list_u16_param)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_list_u32_param<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[u32],
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[u32],),
+                                (),
+                            >::new_unchecked(self.list_u32_param)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_list_u64_param<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[u64],
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[u64],),
+                                (),
+                            >::new_unchecked(self.list_u64_param)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_list_s8_param<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[i8],
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[i8],),
+                                (),
+                            >::new_unchecked(self.list_s8_param)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_list_s16_param<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[i16],
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[i16],),
+                                (),
+                            >::new_unchecked(self.list_s16_param)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_list_s32_param<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[i32],
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[i32],),
+                                (),
+                            >::new_unchecked(self.list_s32_param)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_list_s64_param<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[i64],
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[i64],),
+                                (),
+                            >::new_unchecked(self.list_s64_param)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_list_float32_param<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[f32],
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[f32],),
+                                (),
+                            >::new_unchecked(self.list_float32_param)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_list_float64_param<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[f64],
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[f64],),
+                                (),
+                            >::new_unchecked(self.list_float64_param)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_list_u8_ret<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::__internal::Vec<u8>>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::__internal::Vec<u8>,),
+                            >::new_unchecked(self.list_u8_ret)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_list_u16_ret<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::__internal::Vec<u16>>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::__internal::Vec<u16>,),
+                            >::new_unchecked(self.list_u16_ret)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_list_u32_ret<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::__internal::Vec<u32>>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::__internal::Vec<u32>,),
+                            >::new_unchecked(self.list_u32_ret)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_list_u64_ret<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::__internal::Vec<u64>>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::__internal::Vec<u64>,),
+                            >::new_unchecked(self.list_u64_ret)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_list_s8_ret<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::__internal::Vec<i8>>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::__internal::Vec<i8>,),
+                            >::new_unchecked(self.list_s8_ret)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_list_s16_ret<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::__internal::Vec<i16>>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::__internal::Vec<i16>,),
+                            >::new_unchecked(self.list_s16_ret)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_list_s32_ret<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::__internal::Vec<i32>>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::__internal::Vec<i32>,),
+                            >::new_unchecked(self.list_s32_ret)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_list_s64_ret<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::__internal::Vec<i64>>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::__internal::Vec<i64>,),
+                            >::new_unchecked(self.list_s64_ret)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_list_float32_ret<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::__internal::Vec<f32>>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::__internal::Vec<f32>,),
+                            >::new_unchecked(self.list_float32_ret)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_list_float64_ret<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::__internal::Vec<f64>>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::__internal::Vec<f64>,),
+                            >::new_unchecked(self.list_float64_ret)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_tuple_list<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[(u8, i8)],
+                    ) -> wasmtime::Result<
+                        wasmtime::component::__internal::Vec<(i64, u32)>,
+                    >
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[(u8, i8)],),
+                                (wasmtime::component::__internal::Vec<(i64, u32)>,),
+                            >::new_unchecked(self.tuple_list)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_string_list_arg<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[wasmtime::component::__internal::String],
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[wasmtime::component::__internal::String],),
+                                (),
+                            >::new_unchecked(self.string_list_arg)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_string_list_ret<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<
+                        wasmtime::component::__internal::Vec<
+                            wasmtime::component::__internal::String,
+                        >,
+                    >
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (
+                                    wasmtime::component::__internal::Vec<
+                                        wasmtime::component::__internal::String,
+                                    >,
+                                ),
+                            >::new_unchecked(self.string_list_ret)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_tuple_string_list<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[(u8, wasmtime::component::__internal::String)],
+                    ) -> wasmtime::Result<
+                        wasmtime::component::__internal::Vec<
+                            (wasmtime::component::__internal::String, u8),
+                        >,
+                    >
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[(u8, wasmtime::component::__internal::String)],),
+                                (
+                                    wasmtime::component::__internal::Vec<
+                                        (wasmtime::component::__internal::String, u8),
+                                    >,
+                                ),
+                            >::new_unchecked(self.tuple_string_list)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_string_list<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[wasmtime::component::__internal::String],
+                    ) -> wasmtime::Result<
+                        wasmtime::component::__internal::Vec<
+                            wasmtime::component::__internal::String,
+                        >,
+                    >
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[wasmtime::component::__internal::String],),
+                                (
+                                    wasmtime::component::__internal::Vec<
+                                        wasmtime::component::__internal::String,
+                                    >,
+                                ),
+                            >::new_unchecked(self.string_list)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_record_list<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[SomeRecord],
+                    ) -> wasmtime::Result<
+                        wasmtime::component::__internal::Vec<OtherRecord>,
+                    >
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[SomeRecord],),
+                                (wasmtime::component::__internal::Vec<OtherRecord>,),
+                            >::new_unchecked(self.record_list)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_record_list_reverse<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[OtherRecord],
+                    ) -> wasmtime::Result<
+                        wasmtime::component::__internal::Vec<SomeRecord>,
+                    >
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[OtherRecord],),
+                                (wasmtime::component::__internal::Vec<SomeRecord>,),
+                            >::new_unchecked(self.record_list_reverse)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_variant_list<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[SomeVariant],
+                    ) -> wasmtime::Result<
+                        wasmtime::component::__internal::Vec<OtherVariant>,
+                    >
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[SomeVariant],),
+                                (wasmtime::component::__internal::Vec<OtherVariant>,),
+                            >::new_unchecked(self.variant_list)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_load_store_everything<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &LoadStoreAllSizes,
+                    ) -> wasmtime::Result<LoadStoreAllSizes>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&LoadStoreAllSizes,),
+                                (LoadStoreAllSizes,),
+                            >::new_unchecked(self.load_store_everything)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/many-arguments.rs b/crates/component-macro/tests/expanded/many-arguments.rs
new file mode 100644
index 000000000000..86db694f8323
--- /dev/null
+++ b/crates/component-macro/tests/expanded/many-arguments.rs
@@ -0,0 +1,730 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-world`.
+///
+/// This structure is created through [`TheWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheWorld`] as well.
+pub struct TheWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheWorldIndices,
+}
+impl<T> Clone for TheWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheWorldPre<_T> {
+    /// Creates a new copy of `TheWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheWorld> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-world`.
+///
+/// This is an implementation detail of [`TheWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheWorld`] as well.
+#[derive(Clone)]
+pub struct TheWorldIndices {
+    interface0: exports::foo::foo::manyarg::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheWorld::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheWorldPre::instantiate`] to
+///   create a [`TheWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheWorldIndices::new_instance`] followed
+///   by [`TheWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheWorld {
+    interface0: exports::foo::foo::manyarg::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheWorldIndices {
+        /// Creates a new copy of `TheWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::manyarg::GuestIndices::new(_component)?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Creates a new instance of [`TheWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::manyarg::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(TheWorld { interface0 })
+        }
+    }
+    impl TheWorld {
+        /// Convenience wrapper around [`TheWorldPre::new`] and
+        /// [`TheWorldPre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheWorld> {
+            let pre = linker.instantiate_pre(component)?;
+            TheWorldPre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`TheWorldIndices::new_instance`] and
+        /// [`TheWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let indices = TheWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            U: foo::foo::manyarg::Host,
+        {
+            foo::foo::manyarg::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_manyarg(&self) -> &exports::foo::foo::manyarg::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod manyarg {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone)]
+            pub struct BigStruct {
+                #[component(name = "a1")]
+                pub a1: wasmtime::component::__internal::String,
+                #[component(name = "a2")]
+                pub a2: wasmtime::component::__internal::String,
+                #[component(name = "a3")]
+                pub a3: wasmtime::component::__internal::String,
+                #[component(name = "a4")]
+                pub a4: wasmtime::component::__internal::String,
+                #[component(name = "a5")]
+                pub a5: wasmtime::component::__internal::String,
+                #[component(name = "a6")]
+                pub a6: wasmtime::component::__internal::String,
+                #[component(name = "a7")]
+                pub a7: wasmtime::component::__internal::String,
+                #[component(name = "a8")]
+                pub a8: wasmtime::component::__internal::String,
+                #[component(name = "a9")]
+                pub a9: wasmtime::component::__internal::String,
+                #[component(name = "a10")]
+                pub a10: wasmtime::component::__internal::String,
+                #[component(name = "a11")]
+                pub a11: wasmtime::component::__internal::String,
+                #[component(name = "a12")]
+                pub a12: wasmtime::component::__internal::String,
+                #[component(name = "a13")]
+                pub a13: wasmtime::component::__internal::String,
+                #[component(name = "a14")]
+                pub a14: wasmtime::component::__internal::String,
+                #[component(name = "a15")]
+                pub a15: wasmtime::component::__internal::String,
+                #[component(name = "a16")]
+                pub a16: wasmtime::component::__internal::String,
+                #[component(name = "a17")]
+                pub a17: wasmtime::component::__internal::String,
+                #[component(name = "a18")]
+                pub a18: wasmtime::component::__internal::String,
+                #[component(name = "a19")]
+                pub a19: wasmtime::component::__internal::String,
+                #[component(name = "a20")]
+                pub a20: wasmtime::component::__internal::String,
+            }
+            impl core::fmt::Debug for BigStruct {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("BigStruct")
+                        .field("a1", &self.a1)
+                        .field("a2", &self.a2)
+                        .field("a3", &self.a3)
+                        .field("a4", &self.a4)
+                        .field("a5", &self.a5)
+                        .field("a6", &self.a6)
+                        .field("a7", &self.a7)
+                        .field("a8", &self.a8)
+                        .field("a9", &self.a9)
+                        .field("a10", &self.a10)
+                        .field("a11", &self.a11)
+                        .field("a12", &self.a12)
+                        .field("a13", &self.a13)
+                        .field("a14", &self.a14)
+                        .field("a15", &self.a15)
+                        .field("a16", &self.a16)
+                        .field("a17", &self.a17)
+                        .field("a18", &self.a18)
+                        .field("a19", &self.a19)
+                        .field("a20", &self.a20)
+                        .finish()
+                }
+            }
+            const _: () = {
+                assert!(
+                    160 == < BigStruct as wasmtime::component::ComponentType >::SIZE32
+                );
+                assert!(
+                    4 == < BigStruct as wasmtime::component::ComponentType >::ALIGN32
+                );
+            };
+            pub trait Host {
+                fn many_args(
+                    &mut self,
+                    a1: u64,
+                    a2: u64,
+                    a3: u64,
+                    a4: u64,
+                    a5: u64,
+                    a6: u64,
+                    a7: u64,
+                    a8: u64,
+                    a9: u64,
+                    a10: u64,
+                    a11: u64,
+                    a12: u64,
+                    a13: u64,
+                    a14: u64,
+                    a15: u64,
+                    a16: u64,
+                ) -> ();
+                fn big_argument(&mut self, x: BigStruct) -> ();
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/manyarg")?;
+                inst.func_wrap(
+                    "many-args",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (
+                            arg0,
+                            arg1,
+                            arg2,
+                            arg3,
+                            arg4,
+                            arg5,
+                            arg6,
+                            arg7,
+                            arg8,
+                            arg9,
+                            arg10,
+                            arg11,
+                            arg12,
+                            arg13,
+                            arg14,
+                            arg15,
+                        ): (
+                            u64,
+                            u64,
+                            u64,
+                            u64,
+                            u64,
+                            u64,
+                            u64,
+                            u64,
+                            u64,
+                            u64,
+                            u64,
+                            u64,
+                            u64,
+                            u64,
+                            u64,
+                            u64,
+                        )|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::many_args(
+                            host,
+                            arg0,
+                            arg1,
+                            arg2,
+                            arg3,
+                            arg4,
+                            arg5,
+                            arg6,
+                            arg7,
+                            arg8,
+                            arg9,
+                            arg10,
+                            arg11,
+                            arg12,
+                            arg13,
+                            arg14,
+                            arg15,
+                        );
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "big-argument",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (BigStruct,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::big_argument(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {
+                fn many_args(
+                    &mut self,
+                    a1: u64,
+                    a2: u64,
+                    a3: u64,
+                    a4: u64,
+                    a5: u64,
+                    a6: u64,
+                    a7: u64,
+                    a8: u64,
+                    a9: u64,
+                    a10: u64,
+                    a11: u64,
+                    a12: u64,
+                    a13: u64,
+                    a14: u64,
+                    a15: u64,
+                    a16: u64,
+                ) -> () {
+                    Host::many_args(
+                        *self,
+                        a1,
+                        a2,
+                        a3,
+                        a4,
+                        a5,
+                        a6,
+                        a7,
+                        a8,
+                        a9,
+                        a10,
+                        a11,
+                        a12,
+                        a13,
+                        a14,
+                        a15,
+                        a16,
+                    )
+                }
+                fn big_argument(&mut self, x: BigStruct) -> () {
+                    Host::big_argument(*self, x)
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod manyarg {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(record)]
+                #[derive(Clone)]
+                pub struct BigStruct {
+                    #[component(name = "a1")]
+                    pub a1: wasmtime::component::__internal::String,
+                    #[component(name = "a2")]
+                    pub a2: wasmtime::component::__internal::String,
+                    #[component(name = "a3")]
+                    pub a3: wasmtime::component::__internal::String,
+                    #[component(name = "a4")]
+                    pub a4: wasmtime::component::__internal::String,
+                    #[component(name = "a5")]
+                    pub a5: wasmtime::component::__internal::String,
+                    #[component(name = "a6")]
+                    pub a6: wasmtime::component::__internal::String,
+                    #[component(name = "a7")]
+                    pub a7: wasmtime::component::__internal::String,
+                    #[component(name = "a8")]
+                    pub a8: wasmtime::component::__internal::String,
+                    #[component(name = "a9")]
+                    pub a9: wasmtime::component::__internal::String,
+                    #[component(name = "a10")]
+                    pub a10: wasmtime::component::__internal::String,
+                    #[component(name = "a11")]
+                    pub a11: wasmtime::component::__internal::String,
+                    #[component(name = "a12")]
+                    pub a12: wasmtime::component::__internal::String,
+                    #[component(name = "a13")]
+                    pub a13: wasmtime::component::__internal::String,
+                    #[component(name = "a14")]
+                    pub a14: wasmtime::component::__internal::String,
+                    #[component(name = "a15")]
+                    pub a15: wasmtime::component::__internal::String,
+                    #[component(name = "a16")]
+                    pub a16: wasmtime::component::__internal::String,
+                    #[component(name = "a17")]
+                    pub a17: wasmtime::component::__internal::String,
+                    #[component(name = "a18")]
+                    pub a18: wasmtime::component::__internal::String,
+                    #[component(name = "a19")]
+                    pub a19: wasmtime::component::__internal::String,
+                    #[component(name = "a20")]
+                    pub a20: wasmtime::component::__internal::String,
+                }
+                impl core::fmt::Debug for BigStruct {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        f.debug_struct("BigStruct")
+                            .field("a1", &self.a1)
+                            .field("a2", &self.a2)
+                            .field("a3", &self.a3)
+                            .field("a4", &self.a4)
+                            .field("a5", &self.a5)
+                            .field("a6", &self.a6)
+                            .field("a7", &self.a7)
+                            .field("a8", &self.a8)
+                            .field("a9", &self.a9)
+                            .field("a10", &self.a10)
+                            .field("a11", &self.a11)
+                            .field("a12", &self.a12)
+                            .field("a13", &self.a13)
+                            .field("a14", &self.a14)
+                            .field("a15", &self.a15)
+                            .field("a16", &self.a16)
+                            .field("a17", &self.a17)
+                            .field("a18", &self.a18)
+                            .field("a19", &self.a19)
+                            .field("a20", &self.a20)
+                            .finish()
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        160 == < BigStruct as wasmtime::component::ComponentType
+                        >::SIZE32
+                    );
+                    assert!(
+                        4 == < BigStruct as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                pub struct Guest {
+                    many_args: wasmtime::component::Func,
+                    big_argument: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    many_args: wasmtime::component::ComponentExportIndex,
+                    big_argument: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/manyarg")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/manyarg`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/manyarg")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/manyarg`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/manyarg` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let many_args = lookup("many-args")?;
+                        let big_argument = lookup("big-argument")?;
+                        Ok(GuestIndices {
+                            many_args,
+                            big_argument,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let many_args = *_instance
+                            .get_typed_func::<
+                                (
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                ),
+                                (),
+                            >(&mut store, &self.many_args)?
+                            .func();
+                        let big_argument = *_instance
+                            .get_typed_func::<
+                                (&BigStruct,),
+                                (),
+                            >(&mut store, &self.big_argument)?
+                            .func();
+                        Ok(Guest { many_args, big_argument })
+                    }
+                }
+                impl Guest {
+                    pub fn call_many_args<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: u64,
+                        arg1: u64,
+                        arg2: u64,
+                        arg3: u64,
+                        arg4: u64,
+                        arg5: u64,
+                        arg6: u64,
+                        arg7: u64,
+                        arg8: u64,
+                        arg9: u64,
+                        arg10: u64,
+                        arg11: u64,
+                        arg12: u64,
+                        arg13: u64,
+                        arg14: u64,
+                        arg15: u64,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                ),
+                                (),
+                            >::new_unchecked(self.many_args)
+                        };
+                        let () = callee
+                            .call(
+                                store.as_context_mut(),
+                                (
+                                    arg0,
+                                    arg1,
+                                    arg2,
+                                    arg3,
+                                    arg4,
+                                    arg5,
+                                    arg6,
+                                    arg7,
+                                    arg8,
+                                    arg9,
+                                    arg10,
+                                    arg11,
+                                    arg12,
+                                    arg13,
+                                    arg14,
+                                    arg15,
+                                ),
+                            )?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_big_argument<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &BigStruct,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&BigStruct,),
+                                (),
+                            >::new_unchecked(self.big_argument)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/many-arguments_async.rs b/crates/component-macro/tests/expanded/many-arguments_async.rs
new file mode 100644
index 000000000000..2411593f3fab
--- /dev/null
+++ b/crates/component-macro/tests/expanded/many-arguments_async.rs
@@ -0,0 +1,754 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-world`.
+///
+/// This structure is created through [`TheWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheWorld`] as well.
+pub struct TheWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheWorldIndices,
+}
+impl<T> Clone for TheWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheWorldPre<_T> {
+    /// Creates a new copy of `TheWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheWorld>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-world`.
+///
+/// This is an implementation detail of [`TheWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheWorld`] as well.
+#[derive(Clone)]
+pub struct TheWorldIndices {
+    interface0: exports::foo::foo::manyarg::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheWorld::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheWorldPre::instantiate_async`] to
+///   create a [`TheWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheWorldIndices::new_instance`] followed
+///   by [`TheWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheWorld {
+    interface0: exports::foo::foo::manyarg::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheWorldIndices {
+        /// Creates a new copy of `TheWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::manyarg::GuestIndices::new(_component)?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Creates a new instance of [`TheWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::manyarg::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(TheWorld { interface0 })
+        }
+    }
+    impl TheWorld {
+        /// Convenience wrapper around [`TheWorldPre::new`] and
+        /// [`TheWorldPre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheWorld>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            TheWorldPre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`TheWorldIndices::new_instance`] and
+        /// [`TheWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let indices = TheWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+            U: foo::foo::manyarg::Host + Send,
+        {
+            foo::foo::manyarg::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_manyarg(&self) -> &exports::foo::foo::manyarg::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod manyarg {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone)]
+            pub struct BigStruct {
+                #[component(name = "a1")]
+                pub a1: wasmtime::component::__internal::String,
+                #[component(name = "a2")]
+                pub a2: wasmtime::component::__internal::String,
+                #[component(name = "a3")]
+                pub a3: wasmtime::component::__internal::String,
+                #[component(name = "a4")]
+                pub a4: wasmtime::component::__internal::String,
+                #[component(name = "a5")]
+                pub a5: wasmtime::component::__internal::String,
+                #[component(name = "a6")]
+                pub a6: wasmtime::component::__internal::String,
+                #[component(name = "a7")]
+                pub a7: wasmtime::component::__internal::String,
+                #[component(name = "a8")]
+                pub a8: wasmtime::component::__internal::String,
+                #[component(name = "a9")]
+                pub a9: wasmtime::component::__internal::String,
+                #[component(name = "a10")]
+                pub a10: wasmtime::component::__internal::String,
+                #[component(name = "a11")]
+                pub a11: wasmtime::component::__internal::String,
+                #[component(name = "a12")]
+                pub a12: wasmtime::component::__internal::String,
+                #[component(name = "a13")]
+                pub a13: wasmtime::component::__internal::String,
+                #[component(name = "a14")]
+                pub a14: wasmtime::component::__internal::String,
+                #[component(name = "a15")]
+                pub a15: wasmtime::component::__internal::String,
+                #[component(name = "a16")]
+                pub a16: wasmtime::component::__internal::String,
+                #[component(name = "a17")]
+                pub a17: wasmtime::component::__internal::String,
+                #[component(name = "a18")]
+                pub a18: wasmtime::component::__internal::String,
+                #[component(name = "a19")]
+                pub a19: wasmtime::component::__internal::String,
+                #[component(name = "a20")]
+                pub a20: wasmtime::component::__internal::String,
+            }
+            impl core::fmt::Debug for BigStruct {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("BigStruct")
+                        .field("a1", &self.a1)
+                        .field("a2", &self.a2)
+                        .field("a3", &self.a3)
+                        .field("a4", &self.a4)
+                        .field("a5", &self.a5)
+                        .field("a6", &self.a6)
+                        .field("a7", &self.a7)
+                        .field("a8", &self.a8)
+                        .field("a9", &self.a9)
+                        .field("a10", &self.a10)
+                        .field("a11", &self.a11)
+                        .field("a12", &self.a12)
+                        .field("a13", &self.a13)
+                        .field("a14", &self.a14)
+                        .field("a15", &self.a15)
+                        .field("a16", &self.a16)
+                        .field("a17", &self.a17)
+                        .field("a18", &self.a18)
+                        .field("a19", &self.a19)
+                        .field("a20", &self.a20)
+                        .finish()
+                }
+            }
+            const _: () = {
+                assert!(
+                    160 == < BigStruct as wasmtime::component::ComponentType >::SIZE32
+                );
+                assert!(
+                    4 == < BigStruct as wasmtime::component::ComponentType >::ALIGN32
+                );
+            };
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {
+                async fn many_args(
+                    &mut self,
+                    a1: u64,
+                    a2: u64,
+                    a3: u64,
+                    a4: u64,
+                    a5: u64,
+                    a6: u64,
+                    a7: u64,
+                    a8: u64,
+                    a9: u64,
+                    a10: u64,
+                    a11: u64,
+                    a12: u64,
+                    a13: u64,
+                    a14: u64,
+                    a15: u64,
+                    a16: u64,
+                ) -> ();
+                async fn big_argument(&mut self, x: BigStruct) -> ();
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/manyarg")?;
+                inst.func_wrap_async(
+                    "many-args",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (
+                            arg0,
+                            arg1,
+                            arg2,
+                            arg3,
+                            arg4,
+                            arg5,
+                            arg6,
+                            arg7,
+                            arg8,
+                            arg9,
+                            arg10,
+                            arg11,
+                            arg12,
+                            arg13,
+                            arg14,
+                            arg15,
+                        ): (
+                            u64,
+                            u64,
+                            u64,
+                            u64,
+                            u64,
+                            u64,
+                            u64,
+                            u64,
+                            u64,
+                            u64,
+                            u64,
+                            u64,
+                            u64,
+                            u64,
+                            u64,
+                            u64,
+                        )|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::many_args(
+                                host,
+                                arg0,
+                                arg1,
+                                arg2,
+                                arg3,
+                                arg4,
+                                arg5,
+                                arg6,
+                                arg7,
+                                arg8,
+                                arg9,
+                                arg10,
+                                arg11,
+                                arg12,
+                                arg13,
+                                arg14,
+                                arg15,
+                            )
+                            .await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "big-argument",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (BigStruct,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::big_argument(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {
+                async fn many_args(
+                    &mut self,
+                    a1: u64,
+                    a2: u64,
+                    a3: u64,
+                    a4: u64,
+                    a5: u64,
+                    a6: u64,
+                    a7: u64,
+                    a8: u64,
+                    a9: u64,
+                    a10: u64,
+                    a11: u64,
+                    a12: u64,
+                    a13: u64,
+                    a14: u64,
+                    a15: u64,
+                    a16: u64,
+                ) -> () {
+                    Host::many_args(
+                            *self,
+                            a1,
+                            a2,
+                            a3,
+                            a4,
+                            a5,
+                            a6,
+                            a7,
+                            a8,
+                            a9,
+                            a10,
+                            a11,
+                            a12,
+                            a13,
+                            a14,
+                            a15,
+                            a16,
+                        )
+                        .await
+                }
+                async fn big_argument(&mut self, x: BigStruct) -> () {
+                    Host::big_argument(*self, x).await
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod manyarg {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(record)]
+                #[derive(Clone)]
+                pub struct BigStruct {
+                    #[component(name = "a1")]
+                    pub a1: wasmtime::component::__internal::String,
+                    #[component(name = "a2")]
+                    pub a2: wasmtime::component::__internal::String,
+                    #[component(name = "a3")]
+                    pub a3: wasmtime::component::__internal::String,
+                    #[component(name = "a4")]
+                    pub a4: wasmtime::component::__internal::String,
+                    #[component(name = "a5")]
+                    pub a5: wasmtime::component::__internal::String,
+                    #[component(name = "a6")]
+                    pub a6: wasmtime::component::__internal::String,
+                    #[component(name = "a7")]
+                    pub a7: wasmtime::component::__internal::String,
+                    #[component(name = "a8")]
+                    pub a8: wasmtime::component::__internal::String,
+                    #[component(name = "a9")]
+                    pub a9: wasmtime::component::__internal::String,
+                    #[component(name = "a10")]
+                    pub a10: wasmtime::component::__internal::String,
+                    #[component(name = "a11")]
+                    pub a11: wasmtime::component::__internal::String,
+                    #[component(name = "a12")]
+                    pub a12: wasmtime::component::__internal::String,
+                    #[component(name = "a13")]
+                    pub a13: wasmtime::component::__internal::String,
+                    #[component(name = "a14")]
+                    pub a14: wasmtime::component::__internal::String,
+                    #[component(name = "a15")]
+                    pub a15: wasmtime::component::__internal::String,
+                    #[component(name = "a16")]
+                    pub a16: wasmtime::component::__internal::String,
+                    #[component(name = "a17")]
+                    pub a17: wasmtime::component::__internal::String,
+                    #[component(name = "a18")]
+                    pub a18: wasmtime::component::__internal::String,
+                    #[component(name = "a19")]
+                    pub a19: wasmtime::component::__internal::String,
+                    #[component(name = "a20")]
+                    pub a20: wasmtime::component::__internal::String,
+                }
+                impl core::fmt::Debug for BigStruct {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        f.debug_struct("BigStruct")
+                            .field("a1", &self.a1)
+                            .field("a2", &self.a2)
+                            .field("a3", &self.a3)
+                            .field("a4", &self.a4)
+                            .field("a5", &self.a5)
+                            .field("a6", &self.a6)
+                            .field("a7", &self.a7)
+                            .field("a8", &self.a8)
+                            .field("a9", &self.a9)
+                            .field("a10", &self.a10)
+                            .field("a11", &self.a11)
+                            .field("a12", &self.a12)
+                            .field("a13", &self.a13)
+                            .field("a14", &self.a14)
+                            .field("a15", &self.a15)
+                            .field("a16", &self.a16)
+                            .field("a17", &self.a17)
+                            .field("a18", &self.a18)
+                            .field("a19", &self.a19)
+                            .field("a20", &self.a20)
+                            .finish()
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        160 == < BigStruct as wasmtime::component::ComponentType
+                        >::SIZE32
+                    );
+                    assert!(
+                        4 == < BigStruct as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                pub struct Guest {
+                    many_args: wasmtime::component::Func,
+                    big_argument: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    many_args: wasmtime::component::ComponentExportIndex,
+                    big_argument: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/manyarg")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/manyarg`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/manyarg")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/manyarg`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/manyarg` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let many_args = lookup("many-args")?;
+                        let big_argument = lookup("big-argument")?;
+                        Ok(GuestIndices {
+                            many_args,
+                            big_argument,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let many_args = *_instance
+                            .get_typed_func::<
+                                (
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                ),
+                                (),
+                            >(&mut store, &self.many_args)?
+                            .func();
+                        let big_argument = *_instance
+                            .get_typed_func::<
+                                (&BigStruct,),
+                                (),
+                            >(&mut store, &self.big_argument)?
+                            .func();
+                        Ok(Guest { many_args, big_argument })
+                    }
+                }
+                impl Guest {
+                    pub async fn call_many_args<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: u64,
+                        arg1: u64,
+                        arg2: u64,
+                        arg3: u64,
+                        arg4: u64,
+                        arg5: u64,
+                        arg6: u64,
+                        arg7: u64,
+                        arg8: u64,
+                        arg9: u64,
+                        arg10: u64,
+                        arg11: u64,
+                        arg12: u64,
+                        arg13: u64,
+                        arg14: u64,
+                        arg15: u64,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                    u64,
+                                ),
+                                (),
+                            >::new_unchecked(self.many_args)
+                        };
+                        let () = callee
+                            .call_async(
+                                store.as_context_mut(),
+                                (
+                                    arg0,
+                                    arg1,
+                                    arg2,
+                                    arg3,
+                                    arg4,
+                                    arg5,
+                                    arg6,
+                                    arg7,
+                                    arg8,
+                                    arg9,
+                                    arg10,
+                                    arg11,
+                                    arg12,
+                                    arg13,
+                                    arg14,
+                                    arg15,
+                                ),
+                            )
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_big_argument<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &BigStruct,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&BigStruct,),
+                                (),
+                            >::new_unchecked(self.big_argument)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/multi-return.rs b/crates/component-macro/tests/expanded/multi-return.rs
new file mode 100644
index 000000000000..7b42ddcaeb3c
--- /dev/null
+++ b/crates/component-macro/tests/expanded/multi-return.rs
@@ -0,0 +1,475 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-world`.
+///
+/// This structure is created through [`TheWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheWorld`] as well.
+pub struct TheWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheWorldIndices,
+}
+impl<T> Clone for TheWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheWorldPre<_T> {
+    /// Creates a new copy of `TheWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheWorld> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-world`.
+///
+/// This is an implementation detail of [`TheWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheWorld`] as well.
+#[derive(Clone)]
+pub struct TheWorldIndices {
+    interface0: exports::foo::foo::multi_return::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheWorld::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheWorldPre::instantiate`] to
+///   create a [`TheWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheWorldIndices::new_instance`] followed
+///   by [`TheWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheWorld {
+    interface0: exports::foo::foo::multi_return::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheWorldIndices {
+        /// Creates a new copy of `TheWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::multi_return::GuestIndices::new(
+                _component,
+            )?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Creates a new instance of [`TheWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::multi_return::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(TheWorld { interface0 })
+        }
+    }
+    impl TheWorld {
+        /// Convenience wrapper around [`TheWorldPre::new`] and
+        /// [`TheWorldPre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheWorld> {
+            let pre = linker.instantiate_pre(component)?;
+            TheWorldPre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`TheWorldIndices::new_instance`] and
+        /// [`TheWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let indices = TheWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            U: foo::foo::multi_return::Host,
+        {
+            foo::foo::multi_return::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_multi_return(&self) -> &exports::foo::foo::multi_return::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod multi_return {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub trait Host {
+                fn mra(&mut self) -> ();
+                fn mrb(&mut self) -> ();
+                fn mrc(&mut self) -> u32;
+                fn mrd(&mut self) -> u32;
+                fn mre(&mut self) -> (u32, f32);
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/multi-return")?;
+                inst.func_wrap(
+                    "mra",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::mra(host);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "mrb",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::mrb(host);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "mrc",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::mrc(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "mrd",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::mrd(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "mre",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::mre(host);
+                        Ok(r)
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {
+                fn mra(&mut self) -> () {
+                    Host::mra(*self)
+                }
+                fn mrb(&mut self) -> () {
+                    Host::mrb(*self)
+                }
+                fn mrc(&mut self) -> u32 {
+                    Host::mrc(*self)
+                }
+                fn mrd(&mut self) -> u32 {
+                    Host::mrd(*self)
+                }
+                fn mre(&mut self) -> (u32, f32) {
+                    Host::mre(*self)
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod multi_return {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub struct Guest {
+                    mra: wasmtime::component::Func,
+                    mrb: wasmtime::component::Func,
+                    mrc: wasmtime::component::Func,
+                    mrd: wasmtime::component::Func,
+                    mre: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    mra: wasmtime::component::ComponentExportIndex,
+                    mrb: wasmtime::component::ComponentExportIndex,
+                    mrc: wasmtime::component::ComponentExportIndex,
+                    mrd: wasmtime::component::ComponentExportIndex,
+                    mre: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/multi-return")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/multi-return`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/multi-return")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/multi-return`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/multi-return` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let mra = lookup("mra")?;
+                        let mrb = lookup("mrb")?;
+                        let mrc = lookup("mrc")?;
+                        let mrd = lookup("mrd")?;
+                        let mre = lookup("mre")?;
+                        Ok(GuestIndices {
+                            mra,
+                            mrb,
+                            mrc,
+                            mrd,
+                            mre,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let mra = *_instance
+                            .get_typed_func::<(), ()>(&mut store, &self.mra)?
+                            .func();
+                        let mrb = *_instance
+                            .get_typed_func::<(), ()>(&mut store, &self.mrb)?
+                            .func();
+                        let mrc = *_instance
+                            .get_typed_func::<(), (u32,)>(&mut store, &self.mrc)?
+                            .func();
+                        let mrd = *_instance
+                            .get_typed_func::<(), (u32,)>(&mut store, &self.mrd)?
+                            .func();
+                        let mre = *_instance
+                            .get_typed_func::<(), (u32, f32)>(&mut store, &self.mre)?
+                            .func();
+                        Ok(Guest { mra, mrb, mrc, mrd, mre })
+                    }
+                }
+                impl Guest {
+                    pub fn call_mra<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.mra)
+                        };
+                        let () = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_mrb<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.mrb)
+                        };
+                        let () = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_mrc<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<u32> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (u32,),
+                            >::new_unchecked(self.mrc)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_mrd<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<u32> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (u32,),
+                            >::new_unchecked(self.mrd)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_mre<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<(u32, f32)> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (u32, f32),
+                            >::new_unchecked(self.mre)
+                        };
+                        let (ret0, ret1) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok((ret0, ret1))
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/multi-return_async.rs b/crates/component-macro/tests/expanded/multi-return_async.rs
new file mode 100644
index 000000000000..77975ff6cb3d
--- /dev/null
+++ b/crates/component-macro/tests/expanded/multi-return_async.rs
@@ -0,0 +1,509 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-world`.
+///
+/// This structure is created through [`TheWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheWorld`] as well.
+pub struct TheWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheWorldIndices,
+}
+impl<T> Clone for TheWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheWorldPre<_T> {
+    /// Creates a new copy of `TheWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheWorld>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-world`.
+///
+/// This is an implementation detail of [`TheWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheWorld`] as well.
+#[derive(Clone)]
+pub struct TheWorldIndices {
+    interface0: exports::foo::foo::multi_return::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheWorld::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheWorldPre::instantiate_async`] to
+///   create a [`TheWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheWorldIndices::new_instance`] followed
+///   by [`TheWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheWorld {
+    interface0: exports::foo::foo::multi_return::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheWorldIndices {
+        /// Creates a new copy of `TheWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::multi_return::GuestIndices::new(
+                _component,
+            )?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Creates a new instance of [`TheWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::multi_return::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(TheWorld { interface0 })
+        }
+    }
+    impl TheWorld {
+        /// Convenience wrapper around [`TheWorldPre::new`] and
+        /// [`TheWorldPre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheWorld>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            TheWorldPre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`TheWorldIndices::new_instance`] and
+        /// [`TheWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let indices = TheWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+            U: foo::foo::multi_return::Host + Send,
+        {
+            foo::foo::multi_return::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_multi_return(&self) -> &exports::foo::foo::multi_return::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod multi_return {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {
+                async fn mra(&mut self) -> ();
+                async fn mrb(&mut self) -> ();
+                async fn mrc(&mut self) -> u32;
+                async fn mrd(&mut self) -> u32;
+                async fn mre(&mut self) -> (u32, f32);
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/multi-return")?;
+                inst.func_wrap_async(
+                    "mra",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::mra(host).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "mrb",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::mrb(host).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "mrc",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::mrc(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "mrd",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::mrd(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "mre",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::mre(host).await;
+                        Ok(r)
+                    }),
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {
+                async fn mra(&mut self) -> () {
+                    Host::mra(*self).await
+                }
+                async fn mrb(&mut self) -> () {
+                    Host::mrb(*self).await
+                }
+                async fn mrc(&mut self) -> u32 {
+                    Host::mrc(*self).await
+                }
+                async fn mrd(&mut self) -> u32 {
+                    Host::mrd(*self).await
+                }
+                async fn mre(&mut self) -> (u32, f32) {
+                    Host::mre(*self).await
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod multi_return {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub struct Guest {
+                    mra: wasmtime::component::Func,
+                    mrb: wasmtime::component::Func,
+                    mrc: wasmtime::component::Func,
+                    mrd: wasmtime::component::Func,
+                    mre: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    mra: wasmtime::component::ComponentExportIndex,
+                    mrb: wasmtime::component::ComponentExportIndex,
+                    mrc: wasmtime::component::ComponentExportIndex,
+                    mrd: wasmtime::component::ComponentExportIndex,
+                    mre: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/multi-return")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/multi-return`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/multi-return")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/multi-return`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/multi-return` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let mra = lookup("mra")?;
+                        let mrb = lookup("mrb")?;
+                        let mrc = lookup("mrc")?;
+                        let mrd = lookup("mrd")?;
+                        let mre = lookup("mre")?;
+                        Ok(GuestIndices {
+                            mra,
+                            mrb,
+                            mrc,
+                            mrd,
+                            mre,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let mra = *_instance
+                            .get_typed_func::<(), ()>(&mut store, &self.mra)?
+                            .func();
+                        let mrb = *_instance
+                            .get_typed_func::<(), ()>(&mut store, &self.mrb)?
+                            .func();
+                        let mrc = *_instance
+                            .get_typed_func::<(), (u32,)>(&mut store, &self.mrc)?
+                            .func();
+                        let mrd = *_instance
+                            .get_typed_func::<(), (u32,)>(&mut store, &self.mrd)?
+                            .func();
+                        let mre = *_instance
+                            .get_typed_func::<(), (u32, f32)>(&mut store, &self.mre)?
+                            .func();
+                        Ok(Guest { mra, mrb, mrc, mrd, mre })
+                    }
+                }
+                impl Guest {
+                    pub async fn call_mra<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.mra)
+                        };
+                        let () = callee.call_async(store.as_context_mut(), ()).await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_mrb<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.mrb)
+                        };
+                        let () = callee.call_async(store.as_context_mut(), ()).await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_mrc<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<u32>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (u32,),
+                            >::new_unchecked(self.mrc)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_mrd<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<u32>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (u32,),
+                            >::new_unchecked(self.mrd)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_mre<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<(u32, f32)>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (u32, f32),
+                            >::new_unchecked(self.mre)
+                        };
+                        let (ret0, ret1) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok((ret0, ret1))
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/multiversion.rs b/crates/component-macro/tests/expanded/multiversion.rs
new file mode 100644
index 000000000000..44d9e429237e
--- /dev/null
+++ b/crates/component-macro/tests/expanded/multiversion.rs
@@ -0,0 +1,508 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `foo`.
+///
+/// This structure is created through [`FooPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`Foo`] as well.
+pub struct FooPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: FooIndices,
+}
+impl<T> Clone for FooPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> FooPre<_T> {
+    /// Creates a new copy of `FooPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = FooIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`Foo`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<Foo> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `foo`.
+///
+/// This is an implementation detail of [`FooPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`Foo`] as well.
+#[derive(Clone)]
+pub struct FooIndices {
+    interface0: exports::my::dep0_1_0::a::GuestIndices,
+    interface1: exports::my::dep0_2_0::a::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `foo`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`Foo::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`FooPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`FooPre::instantiate`] to
+///   create a [`Foo`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`Foo::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`FooIndices::new_instance`] followed
+///   by [`FooIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct Foo {
+    interface0: exports::my::dep0_1_0::a::Guest,
+    interface1: exports::my::dep0_2_0::a::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl FooIndices {
+        /// Creates a new copy of `FooIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::my::dep0_1_0::a::GuestIndices::new(_component)?;
+            let interface1 = exports::my::dep0_2_0::a::GuestIndices::new(_component)?;
+            Ok(FooIndices {
+                interface0,
+                interface1,
+            })
+        }
+        /// Creates a new instance of [`FooIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`Foo`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`Foo`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::my::dep0_1_0::a::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            let interface1 = exports::my::dep0_2_0::a::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(FooIndices {
+                interface0,
+                interface1,
+            })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`Foo`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Foo> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            let interface1 = self.interface1.load(&mut store, &_instance)?;
+            Ok(Foo { interface0, interface1 })
+        }
+    }
+    impl Foo {
+        /// Convenience wrapper around [`FooPre::new`] and
+        /// [`FooPre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<Foo> {
+            let pre = linker.instantiate_pre(component)?;
+            FooPre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`FooIndices::new_instance`] and
+        /// [`FooIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Foo> {
+            let indices = FooIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            U: my::dep0_1_0::a::Host + my::dep0_2_0::a::Host,
+        {
+            my::dep0_1_0::a::add_to_linker(linker, get)?;
+            my::dep0_2_0::a::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn my_dep0_1_0_a(&self) -> &exports::my::dep0_1_0::a::Guest {
+            &self.interface0
+        }
+        pub fn my_dep0_2_0_a(&self) -> &exports::my::dep0_2_0::a::Guest {
+            &self.interface1
+        }
+    }
+};
+pub mod my {
+    pub mod dep0_1_0 {
+        #[allow(clippy::all)]
+        pub mod a {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub trait Host {
+                fn x(&mut self) -> ();
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("my:dep/a@0.1.0")?;
+                inst.func_wrap(
+                    "x",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::x(host);
+                        Ok(r)
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {
+                fn x(&mut self) -> () {
+                    Host::x(*self)
+                }
+            }
+        }
+    }
+    pub mod dep0_2_0 {
+        #[allow(clippy::all)]
+        pub mod a {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub trait Host {
+                fn x(&mut self) -> ();
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("my:dep/a@0.2.0")?;
+                inst.func_wrap(
+                    "x",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::x(host);
+                        Ok(r)
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {
+                fn x(&mut self) -> () {
+                    Host::x(*self)
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod my {
+        pub mod dep0_1_0 {
+            #[allow(clippy::all)]
+            pub mod a {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub struct Guest {
+                    x: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    x: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "my:dep/a@0.1.0")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `my:dep/a@0.1.0`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "my:dep/a@0.1.0")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `my:dep/a@0.1.0`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `my:dep/a@0.1.0` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let x = lookup("x")?;
+                        Ok(GuestIndices { x })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let x = *_instance
+                            .get_typed_func::<(), ()>(&mut store, &self.x)?
+                            .func();
+                        Ok(Guest { x })
+                    }
+                }
+                impl Guest {
+                    pub fn call_x<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.x)
+                        };
+                        let () = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                }
+            }
+        }
+        pub mod dep0_2_0 {
+            #[allow(clippy::all)]
+            pub mod a {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub struct Guest {
+                    x: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    x: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "my:dep/a@0.2.0")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `my:dep/a@0.2.0`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "my:dep/a@0.2.0")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `my:dep/a@0.2.0`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `my:dep/a@0.2.0` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let x = lookup("x")?;
+                        Ok(GuestIndices { x })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let x = *_instance
+                            .get_typed_func::<(), ()>(&mut store, &self.x)?
+                            .func();
+                        Ok(Guest { x })
+                    }
+                }
+                impl Guest {
+                    pub fn call_x<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.x)
+                        };
+                        let () = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/multiversion_async.rs b/crates/component-macro/tests/expanded/multiversion_async.rs
new file mode 100644
index 000000000000..08edeb34c3a7
--- /dev/null
+++ b/crates/component-macro/tests/expanded/multiversion_async.rs
@@ -0,0 +1,533 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `foo`.
+///
+/// This structure is created through [`FooPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`Foo`] as well.
+pub struct FooPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: FooIndices,
+}
+impl<T> Clone for FooPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> FooPre<_T> {
+    /// Creates a new copy of `FooPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = FooIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`Foo`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<Foo>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `foo`.
+///
+/// This is an implementation detail of [`FooPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`Foo`] as well.
+#[derive(Clone)]
+pub struct FooIndices {
+    interface0: exports::my::dep0_1_0::a::GuestIndices,
+    interface1: exports::my::dep0_2_0::a::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `foo`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`Foo::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`FooPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`FooPre::instantiate_async`] to
+///   create a [`Foo`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`Foo::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`FooIndices::new_instance`] followed
+///   by [`FooIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct Foo {
+    interface0: exports::my::dep0_1_0::a::Guest,
+    interface1: exports::my::dep0_2_0::a::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl FooIndices {
+        /// Creates a new copy of `FooIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::my::dep0_1_0::a::GuestIndices::new(_component)?;
+            let interface1 = exports::my::dep0_2_0::a::GuestIndices::new(_component)?;
+            Ok(FooIndices {
+                interface0,
+                interface1,
+            })
+        }
+        /// Creates a new instance of [`FooIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`Foo`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`Foo`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::my::dep0_1_0::a::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            let interface1 = exports::my::dep0_2_0::a::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(FooIndices {
+                interface0,
+                interface1,
+            })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`Foo`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Foo> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            let interface1 = self.interface1.load(&mut store, &_instance)?;
+            Ok(Foo { interface0, interface1 })
+        }
+    }
+    impl Foo {
+        /// Convenience wrapper around [`FooPre::new`] and
+        /// [`FooPre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<Foo>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            FooPre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`FooIndices::new_instance`] and
+        /// [`FooIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Foo> {
+            let indices = FooIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+            U: my::dep0_1_0::a::Host + my::dep0_2_0::a::Host + Send,
+        {
+            my::dep0_1_0::a::add_to_linker(linker, get)?;
+            my::dep0_2_0::a::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn my_dep0_1_0_a(&self) -> &exports::my::dep0_1_0::a::Guest {
+            &self.interface0
+        }
+        pub fn my_dep0_2_0_a(&self) -> &exports::my::dep0_2_0::a::Guest {
+            &self.interface1
+        }
+    }
+};
+pub mod my {
+    pub mod dep0_1_0 {
+        #[allow(clippy::all)]
+        pub mod a {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {
+                async fn x(&mut self) -> ();
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("my:dep/a@0.1.0")?;
+                inst.func_wrap_async(
+                    "x",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::x(host).await;
+                        Ok(r)
+                    }),
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {
+                async fn x(&mut self) -> () {
+                    Host::x(*self).await
+                }
+            }
+        }
+    }
+    pub mod dep0_2_0 {
+        #[allow(clippy::all)]
+        pub mod a {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {
+                async fn x(&mut self) -> ();
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("my:dep/a@0.2.0")?;
+                inst.func_wrap_async(
+                    "x",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::x(host).await;
+                        Ok(r)
+                    }),
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {
+                async fn x(&mut self) -> () {
+                    Host::x(*self).await
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod my {
+        pub mod dep0_1_0 {
+            #[allow(clippy::all)]
+            pub mod a {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub struct Guest {
+                    x: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    x: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "my:dep/a@0.1.0")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `my:dep/a@0.1.0`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "my:dep/a@0.1.0")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `my:dep/a@0.1.0`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `my:dep/a@0.1.0` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let x = lookup("x")?;
+                        Ok(GuestIndices { x })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let x = *_instance
+                            .get_typed_func::<(), ()>(&mut store, &self.x)?
+                            .func();
+                        Ok(Guest { x })
+                    }
+                }
+                impl Guest {
+                    pub async fn call_x<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.x)
+                        };
+                        let () = callee.call_async(store.as_context_mut(), ()).await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                }
+            }
+        }
+        pub mod dep0_2_0 {
+            #[allow(clippy::all)]
+            pub mod a {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub struct Guest {
+                    x: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    x: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "my:dep/a@0.2.0")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `my:dep/a@0.2.0`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "my:dep/a@0.2.0")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `my:dep/a@0.2.0`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `my:dep/a@0.2.0` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let x = lookup("x")?;
+                        Ok(GuestIndices { x })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let x = *_instance
+                            .get_typed_func::<(), ()>(&mut store, &self.x)?
+                            .func();
+                        Ok(Guest { x })
+                    }
+                }
+                impl Guest {
+                    pub async fn call_x<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.x)
+                        };
+                        let () = callee.call_async(store.as_context_mut(), ()).await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/records.rs b/crates/component-macro/tests/expanded/records.rs
new file mode 100644
index 000000000000..5a6fed8dcbd3
--- /dev/null
+++ b/crates/component-macro/tests/expanded/records.rs
@@ -0,0 +1,1056 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-world`.
+///
+/// This structure is created through [`TheWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheWorld`] as well.
+pub struct TheWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheWorldIndices,
+}
+impl<T> Clone for TheWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheWorldPre<_T> {
+    /// Creates a new copy of `TheWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheWorld> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-world`.
+///
+/// This is an implementation detail of [`TheWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheWorld`] as well.
+#[derive(Clone)]
+pub struct TheWorldIndices {
+    interface0: exports::foo::foo::records::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheWorld::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheWorldPre::instantiate`] to
+///   create a [`TheWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheWorldIndices::new_instance`] followed
+///   by [`TheWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheWorld {
+    interface0: exports::foo::foo::records::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheWorldIndices {
+        /// Creates a new copy of `TheWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::records::GuestIndices::new(_component)?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Creates a new instance of [`TheWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::records::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(TheWorld { interface0 })
+        }
+    }
+    impl TheWorld {
+        /// Convenience wrapper around [`TheWorldPre::new`] and
+        /// [`TheWorldPre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheWorld> {
+            let pre = linker.instantiate_pre(component)?;
+            TheWorldPre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`TheWorldIndices::new_instance`] and
+        /// [`TheWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let indices = TheWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            U: foo::foo::records::Host,
+        {
+            foo::foo::records::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_records(&self) -> &exports::foo::foo::records::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod records {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone, Copy)]
+            pub struct Empty {}
+            impl core::fmt::Debug for Empty {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("Empty").finish()
+                }
+            }
+            const _: () = {
+                assert!(0 == < Empty as wasmtime::component::ComponentType >::SIZE32);
+                assert!(1 == < Empty as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            /// A record containing two scalar fields
+            /// that both have the same type
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone, Copy)]
+            pub struct Scalars {
+                /// The first field, named a
+                #[component(name = "a")]
+                pub a: u32,
+                /// The second field, named b
+                #[component(name = "b")]
+                pub b: u32,
+            }
+            impl core::fmt::Debug for Scalars {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("Scalars")
+                        .field("a", &self.a)
+                        .field("b", &self.b)
+                        .finish()
+                }
+            }
+            const _: () = {
+                assert!(8 == < Scalars as wasmtime::component::ComponentType >::SIZE32);
+                assert!(4 == < Scalars as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            /// A record that is really just flags
+            /// All of the fields are bool
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone, Copy)]
+            pub struct ReallyFlags {
+                #[component(name = "a")]
+                pub a: bool,
+                #[component(name = "b")]
+                pub b: bool,
+                #[component(name = "c")]
+                pub c: bool,
+                #[component(name = "d")]
+                pub d: bool,
+                #[component(name = "e")]
+                pub e: bool,
+                #[component(name = "f")]
+                pub f: bool,
+                #[component(name = "g")]
+                pub g: bool,
+                #[component(name = "h")]
+                pub h: bool,
+                #[component(name = "i")]
+                pub i: bool,
+            }
+            impl core::fmt::Debug for ReallyFlags {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("ReallyFlags")
+                        .field("a", &self.a)
+                        .field("b", &self.b)
+                        .field("c", &self.c)
+                        .field("d", &self.d)
+                        .field("e", &self.e)
+                        .field("f", &self.f)
+                        .field("g", &self.g)
+                        .field("h", &self.h)
+                        .field("i", &self.i)
+                        .finish()
+                }
+            }
+            const _: () = {
+                assert!(
+                    9 == < ReallyFlags as wasmtime::component::ComponentType >::SIZE32
+                );
+                assert!(
+                    1 == < ReallyFlags as wasmtime::component::ComponentType >::ALIGN32
+                );
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone)]
+            pub struct Aggregates {
+                #[component(name = "a")]
+                pub a: Scalars,
+                #[component(name = "b")]
+                pub b: u32,
+                #[component(name = "c")]
+                pub c: Empty,
+                #[component(name = "d")]
+                pub d: wasmtime::component::__internal::String,
+                #[component(name = "e")]
+                pub e: ReallyFlags,
+            }
+            impl core::fmt::Debug for Aggregates {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("Aggregates")
+                        .field("a", &self.a)
+                        .field("b", &self.b)
+                        .field("c", &self.c)
+                        .field("d", &self.d)
+                        .field("e", &self.e)
+                        .finish()
+                }
+            }
+            const _: () = {
+                assert!(
+                    32 == < Aggregates as wasmtime::component::ComponentType >::SIZE32
+                );
+                assert!(
+                    4 == < Aggregates as wasmtime::component::ComponentType >::ALIGN32
+                );
+            };
+            pub type IntTypedef = i32;
+            const _: () = {
+                assert!(
+                    4 == < IntTypedef as wasmtime::component::ComponentType >::SIZE32
+                );
+                assert!(
+                    4 == < IntTypedef as wasmtime::component::ComponentType >::ALIGN32
+                );
+            };
+            pub type TupleTypedef2 = (IntTypedef,);
+            const _: () = {
+                assert!(
+                    4 == < TupleTypedef2 as wasmtime::component::ComponentType >::SIZE32
+                );
+                assert!(
+                    4 == < TupleTypedef2 as wasmtime::component::ComponentType >::ALIGN32
+                );
+            };
+            pub trait Host {
+                fn tuple_arg(&mut self, x: (char, u32)) -> ();
+                fn tuple_result(&mut self) -> (char, u32);
+                fn empty_arg(&mut self, x: Empty) -> ();
+                fn empty_result(&mut self) -> Empty;
+                fn scalar_arg(&mut self, x: Scalars) -> ();
+                fn scalar_result(&mut self) -> Scalars;
+                fn flags_arg(&mut self, x: ReallyFlags) -> ();
+                fn flags_result(&mut self) -> ReallyFlags;
+                fn aggregate_arg(&mut self, x: Aggregates) -> ();
+                fn aggregate_result(&mut self) -> Aggregates;
+                fn typedef_inout(&mut self, e: TupleTypedef2) -> i32;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/records")?;
+                inst.func_wrap(
+                    "tuple-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): ((char, u32),)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::tuple_arg(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "tuple-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::tuple_result(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "empty-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (Empty,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::empty_arg(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "empty-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::empty_result(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "scalar-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (Scalars,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::scalar_arg(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "scalar-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::scalar_result(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "flags-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (ReallyFlags,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::flags_arg(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "flags-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::flags_result(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "aggregate-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (Aggregates,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::aggregate_arg(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "aggregate-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::aggregate_result(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "typedef-inout",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (TupleTypedef2,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::typedef_inout(host, arg0);
+                        Ok((r,))
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {
+                fn tuple_arg(&mut self, x: (char, u32)) -> () {
+                    Host::tuple_arg(*self, x)
+                }
+                fn tuple_result(&mut self) -> (char, u32) {
+                    Host::tuple_result(*self)
+                }
+                fn empty_arg(&mut self, x: Empty) -> () {
+                    Host::empty_arg(*self, x)
+                }
+                fn empty_result(&mut self) -> Empty {
+                    Host::empty_result(*self)
+                }
+                fn scalar_arg(&mut self, x: Scalars) -> () {
+                    Host::scalar_arg(*self, x)
+                }
+                fn scalar_result(&mut self) -> Scalars {
+                    Host::scalar_result(*self)
+                }
+                fn flags_arg(&mut self, x: ReallyFlags) -> () {
+                    Host::flags_arg(*self, x)
+                }
+                fn flags_result(&mut self) -> ReallyFlags {
+                    Host::flags_result(*self)
+                }
+                fn aggregate_arg(&mut self, x: Aggregates) -> () {
+                    Host::aggregate_arg(*self, x)
+                }
+                fn aggregate_result(&mut self) -> Aggregates {
+                    Host::aggregate_result(*self)
+                }
+                fn typedef_inout(&mut self, e: TupleTypedef2) -> i32 {
+                    Host::typedef_inout(*self, e)
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod records {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(record)]
+                #[derive(Clone, Copy)]
+                pub struct Empty {}
+                impl core::fmt::Debug for Empty {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        f.debug_struct("Empty").finish()
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        0 == < Empty as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        1 == < Empty as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                /// A record containing two scalar fields
+                /// that both have the same type
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(record)]
+                #[derive(Clone, Copy)]
+                pub struct Scalars {
+                    /// The first field, named a
+                    #[component(name = "a")]
+                    pub a: u32,
+                    /// The second field, named b
+                    #[component(name = "b")]
+                    pub b: u32,
+                }
+                impl core::fmt::Debug for Scalars {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        f.debug_struct("Scalars")
+                            .field("a", &self.a)
+                            .field("b", &self.b)
+                            .finish()
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        8 == < Scalars as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        4 == < Scalars as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                /// A record that is really just flags
+                /// All of the fields are bool
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(record)]
+                #[derive(Clone, Copy)]
+                pub struct ReallyFlags {
+                    #[component(name = "a")]
+                    pub a: bool,
+                    #[component(name = "b")]
+                    pub b: bool,
+                    #[component(name = "c")]
+                    pub c: bool,
+                    #[component(name = "d")]
+                    pub d: bool,
+                    #[component(name = "e")]
+                    pub e: bool,
+                    #[component(name = "f")]
+                    pub f: bool,
+                    #[component(name = "g")]
+                    pub g: bool,
+                    #[component(name = "h")]
+                    pub h: bool,
+                    #[component(name = "i")]
+                    pub i: bool,
+                }
+                impl core::fmt::Debug for ReallyFlags {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        f.debug_struct("ReallyFlags")
+                            .field("a", &self.a)
+                            .field("b", &self.b)
+                            .field("c", &self.c)
+                            .field("d", &self.d)
+                            .field("e", &self.e)
+                            .field("f", &self.f)
+                            .field("g", &self.g)
+                            .field("h", &self.h)
+                            .field("i", &self.i)
+                            .finish()
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        9 == < ReallyFlags as wasmtime::component::ComponentType
+                        >::SIZE32
+                    );
+                    assert!(
+                        1 == < ReallyFlags as wasmtime::component::ComponentType
+                        >::ALIGN32
+                    );
+                };
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(record)]
+                #[derive(Clone)]
+                pub struct Aggregates {
+                    #[component(name = "a")]
+                    pub a: Scalars,
+                    #[component(name = "b")]
+                    pub b: u32,
+                    #[component(name = "c")]
+                    pub c: Empty,
+                    #[component(name = "d")]
+                    pub d: wasmtime::component::__internal::String,
+                    #[component(name = "e")]
+                    pub e: ReallyFlags,
+                }
+                impl core::fmt::Debug for Aggregates {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        f.debug_struct("Aggregates")
+                            .field("a", &self.a)
+                            .field("b", &self.b)
+                            .field("c", &self.c)
+                            .field("d", &self.d)
+                            .field("e", &self.e)
+                            .finish()
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        32 == < Aggregates as wasmtime::component::ComponentType
+                        >::SIZE32
+                    );
+                    assert!(
+                        4 == < Aggregates as wasmtime::component::ComponentType
+                        >::ALIGN32
+                    );
+                };
+                pub type IntTypedef = i32;
+                const _: () = {
+                    assert!(
+                        4 == < IntTypedef as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        4 == < IntTypedef as wasmtime::component::ComponentType
+                        >::ALIGN32
+                    );
+                };
+                pub type TupleTypedef2 = (IntTypedef,);
+                const _: () = {
+                    assert!(
+                        4 == < TupleTypedef2 as wasmtime::component::ComponentType
+                        >::SIZE32
+                    );
+                    assert!(
+                        4 == < TupleTypedef2 as wasmtime::component::ComponentType
+                        >::ALIGN32
+                    );
+                };
+                pub struct Guest {
+                    tuple_arg: wasmtime::component::Func,
+                    tuple_result: wasmtime::component::Func,
+                    empty_arg: wasmtime::component::Func,
+                    empty_result: wasmtime::component::Func,
+                    scalar_arg: wasmtime::component::Func,
+                    scalar_result: wasmtime::component::Func,
+                    flags_arg: wasmtime::component::Func,
+                    flags_result: wasmtime::component::Func,
+                    aggregate_arg: wasmtime::component::Func,
+                    aggregate_result: wasmtime::component::Func,
+                    typedef_inout: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    tuple_arg: wasmtime::component::ComponentExportIndex,
+                    tuple_result: wasmtime::component::ComponentExportIndex,
+                    empty_arg: wasmtime::component::ComponentExportIndex,
+                    empty_result: wasmtime::component::ComponentExportIndex,
+                    scalar_arg: wasmtime::component::ComponentExportIndex,
+                    scalar_result: wasmtime::component::ComponentExportIndex,
+                    flags_arg: wasmtime::component::ComponentExportIndex,
+                    flags_result: wasmtime::component::ComponentExportIndex,
+                    aggregate_arg: wasmtime::component::ComponentExportIndex,
+                    aggregate_result: wasmtime::component::ComponentExportIndex,
+                    typedef_inout: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/records")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/records`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/records")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/records`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/records` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let tuple_arg = lookup("tuple-arg")?;
+                        let tuple_result = lookup("tuple-result")?;
+                        let empty_arg = lookup("empty-arg")?;
+                        let empty_result = lookup("empty-result")?;
+                        let scalar_arg = lookup("scalar-arg")?;
+                        let scalar_result = lookup("scalar-result")?;
+                        let flags_arg = lookup("flags-arg")?;
+                        let flags_result = lookup("flags-result")?;
+                        let aggregate_arg = lookup("aggregate-arg")?;
+                        let aggregate_result = lookup("aggregate-result")?;
+                        let typedef_inout = lookup("typedef-inout")?;
+                        Ok(GuestIndices {
+                            tuple_arg,
+                            tuple_result,
+                            empty_arg,
+                            empty_result,
+                            scalar_arg,
+                            scalar_result,
+                            flags_arg,
+                            flags_result,
+                            aggregate_arg,
+                            aggregate_result,
+                            typedef_inout,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let tuple_arg = *_instance
+                            .get_typed_func::<
+                                ((char, u32),),
+                                (),
+                            >(&mut store, &self.tuple_arg)?
+                            .func();
+                        let tuple_result = *_instance
+                            .get_typed_func::<
+                                (),
+                                ((char, u32),),
+                            >(&mut store, &self.tuple_result)?
+                            .func();
+                        let empty_arg = *_instance
+                            .get_typed_func::<(Empty,), ()>(&mut store, &self.empty_arg)?
+                            .func();
+                        let empty_result = *_instance
+                            .get_typed_func::<
+                                (),
+                                (Empty,),
+                            >(&mut store, &self.empty_result)?
+                            .func();
+                        let scalar_arg = *_instance
+                            .get_typed_func::<
+                                (Scalars,),
+                                (),
+                            >(&mut store, &self.scalar_arg)?
+                            .func();
+                        let scalar_result = *_instance
+                            .get_typed_func::<
+                                (),
+                                (Scalars,),
+                            >(&mut store, &self.scalar_result)?
+                            .func();
+                        let flags_arg = *_instance
+                            .get_typed_func::<
+                                (ReallyFlags,),
+                                (),
+                            >(&mut store, &self.flags_arg)?
+                            .func();
+                        let flags_result = *_instance
+                            .get_typed_func::<
+                                (),
+                                (ReallyFlags,),
+                            >(&mut store, &self.flags_result)?
+                            .func();
+                        let aggregate_arg = *_instance
+                            .get_typed_func::<
+                                (&Aggregates,),
+                                (),
+                            >(&mut store, &self.aggregate_arg)?
+                            .func();
+                        let aggregate_result = *_instance
+                            .get_typed_func::<
+                                (),
+                                (Aggregates,),
+                            >(&mut store, &self.aggregate_result)?
+                            .func();
+                        let typedef_inout = *_instance
+                            .get_typed_func::<
+                                (TupleTypedef2,),
+                                (i32,),
+                            >(&mut store, &self.typedef_inout)?
+                            .func();
+                        Ok(Guest {
+                            tuple_arg,
+                            tuple_result,
+                            empty_arg,
+                            empty_result,
+                            scalar_arg,
+                            scalar_result,
+                            flags_arg,
+                            flags_result,
+                            aggregate_arg,
+                            aggregate_result,
+                            typedef_inout,
+                        })
+                    }
+                }
+                impl Guest {
+                    pub fn call_tuple_arg<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: (char, u32),
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                ((char, u32),),
+                                (),
+                            >::new_unchecked(self.tuple_arg)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_tuple_result<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<(char, u32)> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                ((char, u32),),
+                            >::new_unchecked(self.tuple_result)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_empty_arg<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: Empty,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (Empty,),
+                                (),
+                            >::new_unchecked(self.empty_arg)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_empty_result<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<Empty> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (Empty,),
+                            >::new_unchecked(self.empty_result)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_scalar_arg<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: Scalars,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (Scalars,),
+                                (),
+                            >::new_unchecked(self.scalar_arg)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_scalar_result<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<Scalars> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (Scalars,),
+                            >::new_unchecked(self.scalar_result)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_flags_arg<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: ReallyFlags,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (ReallyFlags,),
+                                (),
+                            >::new_unchecked(self.flags_arg)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_flags_result<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<ReallyFlags> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (ReallyFlags,),
+                            >::new_unchecked(self.flags_result)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_aggregate_arg<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &Aggregates,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&Aggregates,),
+                                (),
+                            >::new_unchecked(self.aggregate_arg)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_aggregate_result<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<Aggregates> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (Aggregates,),
+                            >::new_unchecked(self.aggregate_result)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_typedef_inout<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: TupleTypedef2,
+                    ) -> wasmtime::Result<i32> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (TupleTypedef2,),
+                                (i32,),
+                            >::new_unchecked(self.typedef_inout)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/records_async.rs b/crates/component-macro/tests/expanded/records_async.rs
new file mode 100644
index 000000000000..287af7c19a78
--- /dev/null
+++ b/crates/component-macro/tests/expanded/records_async.rs
@@ -0,0 +1,1124 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-world`.
+///
+/// This structure is created through [`TheWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheWorld`] as well.
+pub struct TheWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheWorldIndices,
+}
+impl<T> Clone for TheWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheWorldPre<_T> {
+    /// Creates a new copy of `TheWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheWorld>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-world`.
+///
+/// This is an implementation detail of [`TheWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheWorld`] as well.
+#[derive(Clone)]
+pub struct TheWorldIndices {
+    interface0: exports::foo::foo::records::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheWorld::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheWorldPre::instantiate_async`] to
+///   create a [`TheWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheWorldIndices::new_instance`] followed
+///   by [`TheWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheWorld {
+    interface0: exports::foo::foo::records::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheWorldIndices {
+        /// Creates a new copy of `TheWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::records::GuestIndices::new(_component)?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Creates a new instance of [`TheWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::records::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(TheWorld { interface0 })
+        }
+    }
+    impl TheWorld {
+        /// Convenience wrapper around [`TheWorldPre::new`] and
+        /// [`TheWorldPre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheWorld>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            TheWorldPre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`TheWorldIndices::new_instance`] and
+        /// [`TheWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let indices = TheWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+            U: foo::foo::records::Host + Send,
+        {
+            foo::foo::records::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_records(&self) -> &exports::foo::foo::records::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod records {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone, Copy)]
+            pub struct Empty {}
+            impl core::fmt::Debug for Empty {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("Empty").finish()
+                }
+            }
+            const _: () = {
+                assert!(0 == < Empty as wasmtime::component::ComponentType >::SIZE32);
+                assert!(1 == < Empty as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            /// A record containing two scalar fields
+            /// that both have the same type
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone, Copy)]
+            pub struct Scalars {
+                /// The first field, named a
+                #[component(name = "a")]
+                pub a: u32,
+                /// The second field, named b
+                #[component(name = "b")]
+                pub b: u32,
+            }
+            impl core::fmt::Debug for Scalars {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("Scalars")
+                        .field("a", &self.a)
+                        .field("b", &self.b)
+                        .finish()
+                }
+            }
+            const _: () = {
+                assert!(8 == < Scalars as wasmtime::component::ComponentType >::SIZE32);
+                assert!(4 == < Scalars as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            /// A record that is really just flags
+            /// All of the fields are bool
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone, Copy)]
+            pub struct ReallyFlags {
+                #[component(name = "a")]
+                pub a: bool,
+                #[component(name = "b")]
+                pub b: bool,
+                #[component(name = "c")]
+                pub c: bool,
+                #[component(name = "d")]
+                pub d: bool,
+                #[component(name = "e")]
+                pub e: bool,
+                #[component(name = "f")]
+                pub f: bool,
+                #[component(name = "g")]
+                pub g: bool,
+                #[component(name = "h")]
+                pub h: bool,
+                #[component(name = "i")]
+                pub i: bool,
+            }
+            impl core::fmt::Debug for ReallyFlags {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("ReallyFlags")
+                        .field("a", &self.a)
+                        .field("b", &self.b)
+                        .field("c", &self.c)
+                        .field("d", &self.d)
+                        .field("e", &self.e)
+                        .field("f", &self.f)
+                        .field("g", &self.g)
+                        .field("h", &self.h)
+                        .field("i", &self.i)
+                        .finish()
+                }
+            }
+            const _: () = {
+                assert!(
+                    9 == < ReallyFlags as wasmtime::component::ComponentType >::SIZE32
+                );
+                assert!(
+                    1 == < ReallyFlags as wasmtime::component::ComponentType >::ALIGN32
+                );
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone)]
+            pub struct Aggregates {
+                #[component(name = "a")]
+                pub a: Scalars,
+                #[component(name = "b")]
+                pub b: u32,
+                #[component(name = "c")]
+                pub c: Empty,
+                #[component(name = "d")]
+                pub d: wasmtime::component::__internal::String,
+                #[component(name = "e")]
+                pub e: ReallyFlags,
+            }
+            impl core::fmt::Debug for Aggregates {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("Aggregates")
+                        .field("a", &self.a)
+                        .field("b", &self.b)
+                        .field("c", &self.c)
+                        .field("d", &self.d)
+                        .field("e", &self.e)
+                        .finish()
+                }
+            }
+            const _: () = {
+                assert!(
+                    32 == < Aggregates as wasmtime::component::ComponentType >::SIZE32
+                );
+                assert!(
+                    4 == < Aggregates as wasmtime::component::ComponentType >::ALIGN32
+                );
+            };
+            pub type IntTypedef = i32;
+            const _: () = {
+                assert!(
+                    4 == < IntTypedef as wasmtime::component::ComponentType >::SIZE32
+                );
+                assert!(
+                    4 == < IntTypedef as wasmtime::component::ComponentType >::ALIGN32
+                );
+            };
+            pub type TupleTypedef2 = (IntTypedef,);
+            const _: () = {
+                assert!(
+                    4 == < TupleTypedef2 as wasmtime::component::ComponentType >::SIZE32
+                );
+                assert!(
+                    4 == < TupleTypedef2 as wasmtime::component::ComponentType >::ALIGN32
+                );
+            };
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {
+                async fn tuple_arg(&mut self, x: (char, u32)) -> ();
+                async fn tuple_result(&mut self) -> (char, u32);
+                async fn empty_arg(&mut self, x: Empty) -> ();
+                async fn empty_result(&mut self) -> Empty;
+                async fn scalar_arg(&mut self, x: Scalars) -> ();
+                async fn scalar_result(&mut self) -> Scalars;
+                async fn flags_arg(&mut self, x: ReallyFlags) -> ();
+                async fn flags_result(&mut self) -> ReallyFlags;
+                async fn aggregate_arg(&mut self, x: Aggregates) -> ();
+                async fn aggregate_result(&mut self) -> Aggregates;
+                async fn typedef_inout(&mut self, e: TupleTypedef2) -> i32;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/records")?;
+                inst.func_wrap_async(
+                    "tuple-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): ((char, u32),)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::tuple_arg(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "tuple-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::tuple_result(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "empty-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (Empty,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::empty_arg(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "empty-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::empty_result(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "scalar-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (Scalars,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::scalar_arg(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "scalar-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::scalar_result(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "flags-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (ReallyFlags,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::flags_arg(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "flags-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::flags_result(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "aggregate-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (Aggregates,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::aggregate_arg(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "aggregate-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::aggregate_result(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "typedef-inout",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (TupleTypedef2,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::typedef_inout(host, arg0).await;
+                        Ok((r,))
+                    }),
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {
+                async fn tuple_arg(&mut self, x: (char, u32)) -> () {
+                    Host::tuple_arg(*self, x).await
+                }
+                async fn tuple_result(&mut self) -> (char, u32) {
+                    Host::tuple_result(*self).await
+                }
+                async fn empty_arg(&mut self, x: Empty) -> () {
+                    Host::empty_arg(*self, x).await
+                }
+                async fn empty_result(&mut self) -> Empty {
+                    Host::empty_result(*self).await
+                }
+                async fn scalar_arg(&mut self, x: Scalars) -> () {
+                    Host::scalar_arg(*self, x).await
+                }
+                async fn scalar_result(&mut self) -> Scalars {
+                    Host::scalar_result(*self).await
+                }
+                async fn flags_arg(&mut self, x: ReallyFlags) -> () {
+                    Host::flags_arg(*self, x).await
+                }
+                async fn flags_result(&mut self) -> ReallyFlags {
+                    Host::flags_result(*self).await
+                }
+                async fn aggregate_arg(&mut self, x: Aggregates) -> () {
+                    Host::aggregate_arg(*self, x).await
+                }
+                async fn aggregate_result(&mut self) -> Aggregates {
+                    Host::aggregate_result(*self).await
+                }
+                async fn typedef_inout(&mut self, e: TupleTypedef2) -> i32 {
+                    Host::typedef_inout(*self, e).await
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod records {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(record)]
+                #[derive(Clone, Copy)]
+                pub struct Empty {}
+                impl core::fmt::Debug for Empty {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        f.debug_struct("Empty").finish()
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        0 == < Empty as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        1 == < Empty as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                /// A record containing two scalar fields
+                /// that both have the same type
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(record)]
+                #[derive(Clone, Copy)]
+                pub struct Scalars {
+                    /// The first field, named a
+                    #[component(name = "a")]
+                    pub a: u32,
+                    /// The second field, named b
+                    #[component(name = "b")]
+                    pub b: u32,
+                }
+                impl core::fmt::Debug for Scalars {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        f.debug_struct("Scalars")
+                            .field("a", &self.a)
+                            .field("b", &self.b)
+                            .finish()
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        8 == < Scalars as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        4 == < Scalars as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                /// A record that is really just flags
+                /// All of the fields are bool
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(record)]
+                #[derive(Clone, Copy)]
+                pub struct ReallyFlags {
+                    #[component(name = "a")]
+                    pub a: bool,
+                    #[component(name = "b")]
+                    pub b: bool,
+                    #[component(name = "c")]
+                    pub c: bool,
+                    #[component(name = "d")]
+                    pub d: bool,
+                    #[component(name = "e")]
+                    pub e: bool,
+                    #[component(name = "f")]
+                    pub f: bool,
+                    #[component(name = "g")]
+                    pub g: bool,
+                    #[component(name = "h")]
+                    pub h: bool,
+                    #[component(name = "i")]
+                    pub i: bool,
+                }
+                impl core::fmt::Debug for ReallyFlags {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        f.debug_struct("ReallyFlags")
+                            .field("a", &self.a)
+                            .field("b", &self.b)
+                            .field("c", &self.c)
+                            .field("d", &self.d)
+                            .field("e", &self.e)
+                            .field("f", &self.f)
+                            .field("g", &self.g)
+                            .field("h", &self.h)
+                            .field("i", &self.i)
+                            .finish()
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        9 == < ReallyFlags as wasmtime::component::ComponentType
+                        >::SIZE32
+                    );
+                    assert!(
+                        1 == < ReallyFlags as wasmtime::component::ComponentType
+                        >::ALIGN32
+                    );
+                };
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(record)]
+                #[derive(Clone)]
+                pub struct Aggregates {
+                    #[component(name = "a")]
+                    pub a: Scalars,
+                    #[component(name = "b")]
+                    pub b: u32,
+                    #[component(name = "c")]
+                    pub c: Empty,
+                    #[component(name = "d")]
+                    pub d: wasmtime::component::__internal::String,
+                    #[component(name = "e")]
+                    pub e: ReallyFlags,
+                }
+                impl core::fmt::Debug for Aggregates {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        f.debug_struct("Aggregates")
+                            .field("a", &self.a)
+                            .field("b", &self.b)
+                            .field("c", &self.c)
+                            .field("d", &self.d)
+                            .field("e", &self.e)
+                            .finish()
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        32 == < Aggregates as wasmtime::component::ComponentType
+                        >::SIZE32
+                    );
+                    assert!(
+                        4 == < Aggregates as wasmtime::component::ComponentType
+                        >::ALIGN32
+                    );
+                };
+                pub type IntTypedef = i32;
+                const _: () = {
+                    assert!(
+                        4 == < IntTypedef as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        4 == < IntTypedef as wasmtime::component::ComponentType
+                        >::ALIGN32
+                    );
+                };
+                pub type TupleTypedef2 = (IntTypedef,);
+                const _: () = {
+                    assert!(
+                        4 == < TupleTypedef2 as wasmtime::component::ComponentType
+                        >::SIZE32
+                    );
+                    assert!(
+                        4 == < TupleTypedef2 as wasmtime::component::ComponentType
+                        >::ALIGN32
+                    );
+                };
+                pub struct Guest {
+                    tuple_arg: wasmtime::component::Func,
+                    tuple_result: wasmtime::component::Func,
+                    empty_arg: wasmtime::component::Func,
+                    empty_result: wasmtime::component::Func,
+                    scalar_arg: wasmtime::component::Func,
+                    scalar_result: wasmtime::component::Func,
+                    flags_arg: wasmtime::component::Func,
+                    flags_result: wasmtime::component::Func,
+                    aggregate_arg: wasmtime::component::Func,
+                    aggregate_result: wasmtime::component::Func,
+                    typedef_inout: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    tuple_arg: wasmtime::component::ComponentExportIndex,
+                    tuple_result: wasmtime::component::ComponentExportIndex,
+                    empty_arg: wasmtime::component::ComponentExportIndex,
+                    empty_result: wasmtime::component::ComponentExportIndex,
+                    scalar_arg: wasmtime::component::ComponentExportIndex,
+                    scalar_result: wasmtime::component::ComponentExportIndex,
+                    flags_arg: wasmtime::component::ComponentExportIndex,
+                    flags_result: wasmtime::component::ComponentExportIndex,
+                    aggregate_arg: wasmtime::component::ComponentExportIndex,
+                    aggregate_result: wasmtime::component::ComponentExportIndex,
+                    typedef_inout: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/records")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/records`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/records")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/records`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/records` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let tuple_arg = lookup("tuple-arg")?;
+                        let tuple_result = lookup("tuple-result")?;
+                        let empty_arg = lookup("empty-arg")?;
+                        let empty_result = lookup("empty-result")?;
+                        let scalar_arg = lookup("scalar-arg")?;
+                        let scalar_result = lookup("scalar-result")?;
+                        let flags_arg = lookup("flags-arg")?;
+                        let flags_result = lookup("flags-result")?;
+                        let aggregate_arg = lookup("aggregate-arg")?;
+                        let aggregate_result = lookup("aggregate-result")?;
+                        let typedef_inout = lookup("typedef-inout")?;
+                        Ok(GuestIndices {
+                            tuple_arg,
+                            tuple_result,
+                            empty_arg,
+                            empty_result,
+                            scalar_arg,
+                            scalar_result,
+                            flags_arg,
+                            flags_result,
+                            aggregate_arg,
+                            aggregate_result,
+                            typedef_inout,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let tuple_arg = *_instance
+                            .get_typed_func::<
+                                ((char, u32),),
+                                (),
+                            >(&mut store, &self.tuple_arg)?
+                            .func();
+                        let tuple_result = *_instance
+                            .get_typed_func::<
+                                (),
+                                ((char, u32),),
+                            >(&mut store, &self.tuple_result)?
+                            .func();
+                        let empty_arg = *_instance
+                            .get_typed_func::<(Empty,), ()>(&mut store, &self.empty_arg)?
+                            .func();
+                        let empty_result = *_instance
+                            .get_typed_func::<
+                                (),
+                                (Empty,),
+                            >(&mut store, &self.empty_result)?
+                            .func();
+                        let scalar_arg = *_instance
+                            .get_typed_func::<
+                                (Scalars,),
+                                (),
+                            >(&mut store, &self.scalar_arg)?
+                            .func();
+                        let scalar_result = *_instance
+                            .get_typed_func::<
+                                (),
+                                (Scalars,),
+                            >(&mut store, &self.scalar_result)?
+                            .func();
+                        let flags_arg = *_instance
+                            .get_typed_func::<
+                                (ReallyFlags,),
+                                (),
+                            >(&mut store, &self.flags_arg)?
+                            .func();
+                        let flags_result = *_instance
+                            .get_typed_func::<
+                                (),
+                                (ReallyFlags,),
+                            >(&mut store, &self.flags_result)?
+                            .func();
+                        let aggregate_arg = *_instance
+                            .get_typed_func::<
+                                (&Aggregates,),
+                                (),
+                            >(&mut store, &self.aggregate_arg)?
+                            .func();
+                        let aggregate_result = *_instance
+                            .get_typed_func::<
+                                (),
+                                (Aggregates,),
+                            >(&mut store, &self.aggregate_result)?
+                            .func();
+                        let typedef_inout = *_instance
+                            .get_typed_func::<
+                                (TupleTypedef2,),
+                                (i32,),
+                            >(&mut store, &self.typedef_inout)?
+                            .func();
+                        Ok(Guest {
+                            tuple_arg,
+                            tuple_result,
+                            empty_arg,
+                            empty_result,
+                            scalar_arg,
+                            scalar_result,
+                            flags_arg,
+                            flags_result,
+                            aggregate_arg,
+                            aggregate_result,
+                            typedef_inout,
+                        })
+                    }
+                }
+                impl Guest {
+                    pub async fn call_tuple_arg<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: (char, u32),
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                ((char, u32),),
+                                (),
+                            >::new_unchecked(self.tuple_arg)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_tuple_result<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<(char, u32)>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                ((char, u32),),
+                            >::new_unchecked(self.tuple_result)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_empty_arg<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: Empty,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (Empty,),
+                                (),
+                            >::new_unchecked(self.empty_arg)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_empty_result<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<Empty>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (Empty,),
+                            >::new_unchecked(self.empty_result)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_scalar_arg<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: Scalars,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (Scalars,),
+                                (),
+                            >::new_unchecked(self.scalar_arg)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_scalar_result<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<Scalars>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (Scalars,),
+                            >::new_unchecked(self.scalar_result)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_flags_arg<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: ReallyFlags,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (ReallyFlags,),
+                                (),
+                            >::new_unchecked(self.flags_arg)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_flags_result<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<ReallyFlags>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (ReallyFlags,),
+                            >::new_unchecked(self.flags_result)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_aggregate_arg<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &Aggregates,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&Aggregates,),
+                                (),
+                            >::new_unchecked(self.aggregate_arg)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_aggregate_result<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<Aggregates>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (Aggregates,),
+                            >::new_unchecked(self.aggregate_result)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_typedef_inout<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: TupleTypedef2,
+                    ) -> wasmtime::Result<i32>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (TupleTypedef2,),
+                                (i32,),
+                            >::new_unchecked(self.typedef_inout)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/rename.rs b/crates/component-macro/tests/expanded/rename.rs
new file mode 100644
index 000000000000..40ad51574259
--- /dev/null
+++ b/crates/component-macro/tests/expanded/rename.rs
@@ -0,0 +1,268 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `neptune`.
+///
+/// This structure is created through [`NeptunePre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`Neptune`] as well.
+pub struct NeptunePre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: NeptuneIndices,
+}
+impl<T> Clone for NeptunePre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> NeptunePre<_T> {
+    /// Creates a new copy of `NeptunePre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = NeptuneIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`Neptune`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<Neptune> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `neptune`.
+///
+/// This is an implementation detail of [`NeptunePre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`Neptune`] as well.
+#[derive(Clone)]
+pub struct NeptuneIndices {}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `neptune`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`Neptune::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`NeptunePre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`NeptunePre::instantiate`] to
+///   create a [`Neptune`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`Neptune::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`NeptuneIndices::new_instance`] followed
+///   by [`NeptuneIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct Neptune {}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl NeptuneIndices {
+        /// Creates a new copy of `NeptuneIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            Ok(NeptuneIndices {})
+        }
+        /// Creates a new instance of [`NeptuneIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`Neptune`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`Neptune`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            Ok(NeptuneIndices {})
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`Neptune`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Neptune> {
+            let _instance = instance;
+            Ok(Neptune {})
+        }
+    }
+    impl Neptune {
+        /// Convenience wrapper around [`NeptunePre::new`] and
+        /// [`NeptunePre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<Neptune> {
+            let pre = linker.instantiate_pre(component)?;
+            NeptunePre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`NeptuneIndices::new_instance`] and
+        /// [`NeptuneIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Neptune> {
+            let indices = NeptuneIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            U: foo::foo::green::Host + foo::foo::red::Host,
+        {
+            foo::foo::green::add_to_linker(linker, get)?;
+            foo::foo::red::add_to_linker(linker, get)?;
+            Ok(())
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod green {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub type Thing = i32;
+            const _: () = {
+                assert!(4 == < Thing as wasmtime::component::ComponentType >::SIZE32);
+                assert!(4 == < Thing as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            pub trait Host {}
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/green")?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {}
+        }
+        #[allow(clippy::all)]
+        pub mod red {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub type Thing = super::super::super::foo::foo::green::Thing;
+            const _: () = {
+                assert!(4 == < Thing as wasmtime::component::ComponentType >::SIZE32);
+                assert!(4 == < Thing as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            pub trait Host {
+                fn foo(&mut self) -> Thing;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/red")?;
+                inst.func_wrap(
+                    "foo",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::foo(host);
+                        Ok((r,))
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {
+                fn foo(&mut self) -> Thing {
+                    Host::foo(*self)
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/rename_async.rs b/crates/component-macro/tests/expanded/rename_async.rs
new file mode 100644
index 000000000000..6d8de01759a5
--- /dev/null
+++ b/crates/component-macro/tests/expanded/rename_async.rs
@@ -0,0 +1,287 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `neptune`.
+///
+/// This structure is created through [`NeptunePre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`Neptune`] as well.
+pub struct NeptunePre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: NeptuneIndices,
+}
+impl<T> Clone for NeptunePre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> NeptunePre<_T> {
+    /// Creates a new copy of `NeptunePre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = NeptuneIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`Neptune`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<Neptune>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `neptune`.
+///
+/// This is an implementation detail of [`NeptunePre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`Neptune`] as well.
+#[derive(Clone)]
+pub struct NeptuneIndices {}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `neptune`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`Neptune::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`NeptunePre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`NeptunePre::instantiate_async`] to
+///   create a [`Neptune`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`Neptune::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`NeptuneIndices::new_instance`] followed
+///   by [`NeptuneIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct Neptune {}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl NeptuneIndices {
+        /// Creates a new copy of `NeptuneIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            Ok(NeptuneIndices {})
+        }
+        /// Creates a new instance of [`NeptuneIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`Neptune`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`Neptune`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            Ok(NeptuneIndices {})
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`Neptune`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Neptune> {
+            let _instance = instance;
+            Ok(Neptune {})
+        }
+    }
+    impl Neptune {
+        /// Convenience wrapper around [`NeptunePre::new`] and
+        /// [`NeptunePre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<Neptune>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            NeptunePre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`NeptuneIndices::new_instance`] and
+        /// [`NeptuneIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Neptune> {
+            let indices = NeptuneIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+            U: foo::foo::green::Host + foo::foo::red::Host + Send,
+        {
+            foo::foo::green::add_to_linker(linker, get)?;
+            foo::foo::red::add_to_linker(linker, get)?;
+            Ok(())
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod green {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub type Thing = i32;
+            const _: () = {
+                assert!(4 == < Thing as wasmtime::component::ComponentType >::SIZE32);
+                assert!(4 == < Thing as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {}
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/green")?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {}
+        }
+        #[allow(clippy::all)]
+        pub mod red {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub type Thing = super::super::super::foo::foo::green::Thing;
+            const _: () = {
+                assert!(4 == < Thing as wasmtime::component::ComponentType >::SIZE32);
+                assert!(4 == < Thing as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {
+                async fn foo(&mut self) -> Thing;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/red")?;
+                inst.func_wrap_async(
+                    "foo",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::foo(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {
+                async fn foo(&mut self) -> Thing {
+                    Host::foo(*self).await
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/resources-export.rs b/crates/component-macro/tests/expanded/resources-export.rs
new file mode 100644
index 000000000000..2df3c228fa37
--- /dev/null
+++ b/crates/component-macro/tests/expanded/resources-export.rs
@@ -0,0 +1,879 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `w`.
+///
+/// This structure is created through [`WPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`W`] as well.
+pub struct WPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: WIndices,
+}
+impl<T> Clone for WPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> WPre<_T> {
+    /// Creates a new copy of `WPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = WIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`W`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<W> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `w`.
+///
+/// This is an implementation detail of [`WPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`W`] as well.
+#[derive(Clone)]
+pub struct WIndices {
+    interface0: exports::foo::foo::simple_export::GuestIndices,
+    interface1: exports::foo::foo::export_using_import::GuestIndices,
+    interface2: exports::foo::foo::export_using_export1::GuestIndices,
+    interface3: exports::foo::foo::export_using_export2::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `w`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`W::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`WPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`WPre::instantiate`] to
+///   create a [`W`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`W::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`WIndices::new_instance`] followed
+///   by [`WIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct W {
+    interface0: exports::foo::foo::simple_export::Guest,
+    interface1: exports::foo::foo::export_using_import::Guest,
+    interface2: exports::foo::foo::export_using_export1::Guest,
+    interface3: exports::foo::foo::export_using_export2::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl WIndices {
+        /// Creates a new copy of `WIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::simple_export::GuestIndices::new(
+                _component,
+            )?;
+            let interface1 = exports::foo::foo::export_using_import::GuestIndices::new(
+                _component,
+            )?;
+            let interface2 = exports::foo::foo::export_using_export1::GuestIndices::new(
+                _component,
+            )?;
+            let interface3 = exports::foo::foo::export_using_export2::GuestIndices::new(
+                _component,
+            )?;
+            Ok(WIndices {
+                interface0,
+                interface1,
+                interface2,
+                interface3,
+            })
+        }
+        /// Creates a new instance of [`WIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`W`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`W`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::simple_export::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            let interface1 = exports::foo::foo::export_using_import::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            let interface2 = exports::foo::foo::export_using_export1::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            let interface3 = exports::foo::foo::export_using_export2::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(WIndices {
+                interface0,
+                interface1,
+                interface2,
+                interface3,
+            })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`W`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<W> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            let interface1 = self.interface1.load(&mut store, &_instance)?;
+            let interface2 = self.interface2.load(&mut store, &_instance)?;
+            let interface3 = self.interface3.load(&mut store, &_instance)?;
+            Ok(W {
+                interface0,
+                interface1,
+                interface2,
+                interface3,
+            })
+        }
+    }
+    impl W {
+        /// Convenience wrapper around [`WPre::new`] and
+        /// [`WPre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<W> {
+            let pre = linker.instantiate_pre(component)?;
+            WPre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`WIndices::new_instance`] and
+        /// [`WIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<W> {
+            let indices = WIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            U: foo::foo::transitive_import::Host,
+        {
+            foo::foo::transitive_import::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_simple_export(&self) -> &exports::foo::foo::simple_export::Guest {
+            &self.interface0
+        }
+        pub fn foo_foo_export_using_import(
+            &self,
+        ) -> &exports::foo::foo::export_using_import::Guest {
+            &self.interface1
+        }
+        pub fn foo_foo_export_using_export1(
+            &self,
+        ) -> &exports::foo::foo::export_using_export1::Guest {
+            &self.interface2
+        }
+        pub fn foo_foo_export_using_export2(
+            &self,
+        ) -> &exports::foo::foo::export_using_export2::Guest {
+            &self.interface3
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod transitive_import {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub enum Y {}
+            pub trait HostY {
+                fn drop(
+                    &mut self,
+                    rep: wasmtime::component::Resource<Y>,
+                ) -> wasmtime::Result<()>;
+            }
+            impl<_T: HostY + ?Sized> HostY for &mut _T {
+                fn drop(
+                    &mut self,
+                    rep: wasmtime::component::Resource<Y>,
+                ) -> wasmtime::Result<()> {
+                    HostY::drop(*self, rep)
+                }
+            }
+            pub trait Host: HostY {}
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/transitive-import")?;
+                inst.resource(
+                    "y",
+                    wasmtime::component::ResourceType::host::<Y>(),
+                    move |mut store, rep| -> wasmtime::Result<()> {
+                        HostY::drop(
+                            &mut host_getter(store.data_mut()),
+                            wasmtime::component::Resource::new_own(rep),
+                        )
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {}
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod simple_export {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub type A = wasmtime::component::ResourceAny;
+                pub struct GuestA<'a> {
+                    funcs: &'a Guest,
+                }
+                pub struct Guest {
+                    constructor_a_constructor: wasmtime::component::Func,
+                    static_a_static_a: wasmtime::component::Func,
+                    method_a_method_a: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    constructor_a_constructor: wasmtime::component::ComponentExportIndex,
+                    static_a_static_a: wasmtime::component::ComponentExportIndex,
+                    method_a_method_a: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/simple-export")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/simple-export`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/simple-export")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/simple-export`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/simple-export` does \
+                  not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let constructor_a_constructor = lookup("[constructor]a")?;
+                        let static_a_static_a = lookup("[static]a.static-a")?;
+                        let method_a_method_a = lookup("[method]a.method-a")?;
+                        Ok(GuestIndices {
+                            constructor_a_constructor,
+                            static_a_static_a,
+                            method_a_method_a,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let constructor_a_constructor = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::ResourceAny,),
+                            >(&mut store, &self.constructor_a_constructor)?
+                            .func();
+                        let static_a_static_a = *_instance
+                            .get_typed_func::<
+                                (),
+                                (u32,),
+                            >(&mut store, &self.static_a_static_a)?
+                            .func();
+                        let method_a_method_a = *_instance
+                            .get_typed_func::<
+                                (wasmtime::component::ResourceAny,),
+                                (u32,),
+                            >(&mut store, &self.method_a_method_a)?
+                            .func();
+                        Ok(Guest {
+                            constructor_a_constructor,
+                            static_a_static_a,
+                            method_a_method_a,
+                        })
+                    }
+                }
+                impl Guest {
+                    pub fn a(&self) -> GuestA<'_> {
+                        GuestA { funcs: self }
+                    }
+                }
+                impl GuestA<'_> {
+                    pub fn call_constructor<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::ResourceAny> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::ResourceAny,),
+                            >::new_unchecked(self.funcs.constructor_a_constructor)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_static_a<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<u32> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (u32,),
+                            >::new_unchecked(self.funcs.static_a_static_a)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_method_a<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: wasmtime::component::ResourceAny,
+                    ) -> wasmtime::Result<u32> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (wasmtime::component::ResourceAny,),
+                                (u32,),
+                            >::new_unchecked(self.funcs.method_a_method_a)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                }
+            }
+            #[allow(clippy::all)]
+            pub mod export_using_import {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub type Y = super::super::super::super::foo::foo::transitive_import::Y;
+                pub type A = wasmtime::component::ResourceAny;
+                pub struct GuestA<'a> {
+                    funcs: &'a Guest,
+                }
+                pub struct Guest {
+                    constructor_a_constructor: wasmtime::component::Func,
+                    static_a_static_a: wasmtime::component::Func,
+                    method_a_method_a: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    constructor_a_constructor: wasmtime::component::ComponentExportIndex,
+                    static_a_static_a: wasmtime::component::ComponentExportIndex,
+                    method_a_method_a: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/export-using-import")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/export-using-import`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/export-using-import")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/export-using-import`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/export-using-import` does \
+                  not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let constructor_a_constructor = lookup("[constructor]a")?;
+                        let static_a_static_a = lookup("[static]a.static-a")?;
+                        let method_a_method_a = lookup("[method]a.method-a")?;
+                        Ok(GuestIndices {
+                            constructor_a_constructor,
+                            static_a_static_a,
+                            method_a_method_a,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let constructor_a_constructor = *_instance
+                            .get_typed_func::<
+                                (wasmtime::component::Resource<Y>,),
+                                (wasmtime::component::ResourceAny,),
+                            >(&mut store, &self.constructor_a_constructor)?
+                            .func();
+                        let static_a_static_a = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::Resource<Y>,),
+                            >(&mut store, &self.static_a_static_a)?
+                            .func();
+                        let method_a_method_a = *_instance
+                            .get_typed_func::<
+                                (
+                                    wasmtime::component::ResourceAny,
+                                    wasmtime::component::Resource<Y>,
+                                ),
+                                (wasmtime::component::Resource<Y>,),
+                            >(&mut store, &self.method_a_method_a)?
+                            .func();
+                        Ok(Guest {
+                            constructor_a_constructor,
+                            static_a_static_a,
+                            method_a_method_a,
+                        })
+                    }
+                }
+                impl Guest {
+                    pub fn a(&self) -> GuestA<'_> {
+                        GuestA { funcs: self }
+                    }
+                }
+                impl GuestA<'_> {
+                    pub fn call_constructor<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: wasmtime::component::Resource<Y>,
+                    ) -> wasmtime::Result<wasmtime::component::ResourceAny> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (wasmtime::component::Resource<Y>,),
+                                (wasmtime::component::ResourceAny,),
+                            >::new_unchecked(self.funcs.constructor_a_constructor)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_static_a<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::Resource<Y>> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::Resource<Y>,),
+                            >::new_unchecked(self.funcs.static_a_static_a)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_method_a<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: wasmtime::component::ResourceAny,
+                        arg1: wasmtime::component::Resource<Y>,
+                    ) -> wasmtime::Result<wasmtime::component::Resource<Y>> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (
+                                    wasmtime::component::ResourceAny,
+                                    wasmtime::component::Resource<Y>,
+                                ),
+                                (wasmtime::component::Resource<Y>,),
+                            >::new_unchecked(self.funcs.method_a_method_a)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), (arg0, arg1))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                }
+            }
+            #[allow(clippy::all)]
+            pub mod export_using_export1 {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub type A = wasmtime::component::ResourceAny;
+                pub struct GuestA<'a> {
+                    funcs: &'a Guest,
+                }
+                pub struct Guest {
+                    constructor_a_constructor: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    constructor_a_constructor: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/export-using-export1")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/export-using-export1`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/export-using-export1")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/export-using-export1`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/export-using-export1` does \
+                  not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let constructor_a_constructor = lookup("[constructor]a")?;
+                        Ok(GuestIndices {
+                            constructor_a_constructor,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let constructor_a_constructor = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::ResourceAny,),
+                            >(&mut store, &self.constructor_a_constructor)?
+                            .func();
+                        Ok(Guest { constructor_a_constructor })
+                    }
+                }
+                impl Guest {
+                    pub fn a(&self) -> GuestA<'_> {
+                        GuestA { funcs: self }
+                    }
+                }
+                impl GuestA<'_> {
+                    pub fn call_constructor<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::ResourceAny> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::ResourceAny,),
+                            >::new_unchecked(self.funcs.constructor_a_constructor)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                }
+            }
+            #[allow(clippy::all)]
+            pub mod export_using_export2 {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub type A = super::super::super::super::exports::foo::foo::export_using_export1::A;
+                pub type B = wasmtime::component::ResourceAny;
+                pub struct GuestB<'a> {
+                    funcs: &'a Guest,
+                }
+                pub struct Guest {
+                    constructor_b_constructor: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    constructor_b_constructor: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/export-using-export2")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/export-using-export2`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/export-using-export2")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/export-using-export2`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/export-using-export2` does \
+                  not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let constructor_b_constructor = lookup("[constructor]b")?;
+                        Ok(GuestIndices {
+                            constructor_b_constructor,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let constructor_b_constructor = *_instance
+                            .get_typed_func::<
+                                (wasmtime::component::ResourceAny,),
+                                (wasmtime::component::ResourceAny,),
+                            >(&mut store, &self.constructor_b_constructor)?
+                            .func();
+                        Ok(Guest { constructor_b_constructor })
+                    }
+                }
+                impl Guest {
+                    pub fn b(&self) -> GuestB<'_> {
+                        GuestB { funcs: self }
+                    }
+                }
+                impl GuestB<'_> {
+                    pub fn call_constructor<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: wasmtime::component::ResourceAny,
+                    ) -> wasmtime::Result<wasmtime::component::ResourceAny> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (wasmtime::component::ResourceAny,),
+                                (wasmtime::component::ResourceAny,),
+                            >::new_unchecked(self.funcs.constructor_b_constructor)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/resources-export_async.rs b/crates/component-macro/tests/expanded/resources-export_async.rs
new file mode 100644
index 000000000000..09a3766b8731
--- /dev/null
+++ b/crates/component-macro/tests/expanded/resources-export_async.rs
@@ -0,0 +1,937 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `w`.
+///
+/// This structure is created through [`WPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`W`] as well.
+pub struct WPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: WIndices,
+}
+impl<T> Clone for WPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> WPre<_T> {
+    /// Creates a new copy of `WPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = WIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`W`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<W>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `w`.
+///
+/// This is an implementation detail of [`WPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`W`] as well.
+#[derive(Clone)]
+pub struct WIndices {
+    interface0: exports::foo::foo::simple_export::GuestIndices,
+    interface1: exports::foo::foo::export_using_import::GuestIndices,
+    interface2: exports::foo::foo::export_using_export1::GuestIndices,
+    interface3: exports::foo::foo::export_using_export2::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `w`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`W::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`WPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`WPre::instantiate_async`] to
+///   create a [`W`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`W::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`WIndices::new_instance`] followed
+///   by [`WIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct W {
+    interface0: exports::foo::foo::simple_export::Guest,
+    interface1: exports::foo::foo::export_using_import::Guest,
+    interface2: exports::foo::foo::export_using_export1::Guest,
+    interface3: exports::foo::foo::export_using_export2::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl WIndices {
+        /// Creates a new copy of `WIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::simple_export::GuestIndices::new(
+                _component,
+            )?;
+            let interface1 = exports::foo::foo::export_using_import::GuestIndices::new(
+                _component,
+            )?;
+            let interface2 = exports::foo::foo::export_using_export1::GuestIndices::new(
+                _component,
+            )?;
+            let interface3 = exports::foo::foo::export_using_export2::GuestIndices::new(
+                _component,
+            )?;
+            Ok(WIndices {
+                interface0,
+                interface1,
+                interface2,
+                interface3,
+            })
+        }
+        /// Creates a new instance of [`WIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`W`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`W`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::simple_export::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            let interface1 = exports::foo::foo::export_using_import::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            let interface2 = exports::foo::foo::export_using_export1::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            let interface3 = exports::foo::foo::export_using_export2::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(WIndices {
+                interface0,
+                interface1,
+                interface2,
+                interface3,
+            })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`W`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<W> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            let interface1 = self.interface1.load(&mut store, &_instance)?;
+            let interface2 = self.interface2.load(&mut store, &_instance)?;
+            let interface3 = self.interface3.load(&mut store, &_instance)?;
+            Ok(W {
+                interface0,
+                interface1,
+                interface2,
+                interface3,
+            })
+        }
+    }
+    impl W {
+        /// Convenience wrapper around [`WPre::new`] and
+        /// [`WPre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<W>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            WPre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`WIndices::new_instance`] and
+        /// [`WIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<W> {
+            let indices = WIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+            U: foo::foo::transitive_import::Host + Send,
+        {
+            foo::foo::transitive_import::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_simple_export(&self) -> &exports::foo::foo::simple_export::Guest {
+            &self.interface0
+        }
+        pub fn foo_foo_export_using_import(
+            &self,
+        ) -> &exports::foo::foo::export_using_import::Guest {
+            &self.interface1
+        }
+        pub fn foo_foo_export_using_export1(
+            &self,
+        ) -> &exports::foo::foo::export_using_export1::Guest {
+            &self.interface2
+        }
+        pub fn foo_foo_export_using_export2(
+            &self,
+        ) -> &exports::foo::foo::export_using_export2::Guest {
+            &self.interface3
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod transitive_import {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub enum Y {}
+            #[wasmtime::component::__internal::async_trait]
+            pub trait HostY {
+                async fn drop(
+                    &mut self,
+                    rep: wasmtime::component::Resource<Y>,
+                ) -> wasmtime::Result<()>;
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: HostY + ?Sized + Send> HostY for &mut _T {
+                async fn drop(
+                    &mut self,
+                    rep: wasmtime::component::Resource<Y>,
+                ) -> wasmtime::Result<()> {
+                    HostY::drop(*self, rep).await
+                }
+            }
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send + HostY {}
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/transitive-import")?;
+                inst.resource_async(
+                    "y",
+                    wasmtime::component::ResourceType::host::<Y>(),
+                    move |mut store, rep| {
+                        std::boxed::Box::new(async move {
+                            HostY::drop(
+                                    &mut host_getter(store.data_mut()),
+                                    wasmtime::component::Resource::new_own(rep),
+                                )
+                                .await
+                        })
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {}
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod simple_export {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub type A = wasmtime::component::ResourceAny;
+                pub struct GuestA<'a> {
+                    funcs: &'a Guest,
+                }
+                pub struct Guest {
+                    constructor_a_constructor: wasmtime::component::Func,
+                    static_a_static_a: wasmtime::component::Func,
+                    method_a_method_a: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    constructor_a_constructor: wasmtime::component::ComponentExportIndex,
+                    static_a_static_a: wasmtime::component::ComponentExportIndex,
+                    method_a_method_a: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/simple-export")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/simple-export`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/simple-export")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/simple-export`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/simple-export` does \
+                  not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let constructor_a_constructor = lookup("[constructor]a")?;
+                        let static_a_static_a = lookup("[static]a.static-a")?;
+                        let method_a_method_a = lookup("[method]a.method-a")?;
+                        Ok(GuestIndices {
+                            constructor_a_constructor,
+                            static_a_static_a,
+                            method_a_method_a,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let constructor_a_constructor = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::ResourceAny,),
+                            >(&mut store, &self.constructor_a_constructor)?
+                            .func();
+                        let static_a_static_a = *_instance
+                            .get_typed_func::<
+                                (),
+                                (u32,),
+                            >(&mut store, &self.static_a_static_a)?
+                            .func();
+                        let method_a_method_a = *_instance
+                            .get_typed_func::<
+                                (wasmtime::component::ResourceAny,),
+                                (u32,),
+                            >(&mut store, &self.method_a_method_a)?
+                            .func();
+                        Ok(Guest {
+                            constructor_a_constructor,
+                            static_a_static_a,
+                            method_a_method_a,
+                        })
+                    }
+                }
+                impl Guest {
+                    pub fn a(&self) -> GuestA<'_> {
+                        GuestA { funcs: self }
+                    }
+                }
+                impl GuestA<'_> {
+                    pub async fn call_constructor<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::ResourceAny>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::ResourceAny,),
+                            >::new_unchecked(self.funcs.constructor_a_constructor)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_static_a<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<u32>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (u32,),
+                            >::new_unchecked(self.funcs.static_a_static_a)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_method_a<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: wasmtime::component::ResourceAny,
+                    ) -> wasmtime::Result<u32>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (wasmtime::component::ResourceAny,),
+                                (u32,),
+                            >::new_unchecked(self.funcs.method_a_method_a)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                }
+            }
+            #[allow(clippy::all)]
+            pub mod export_using_import {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub type Y = super::super::super::super::foo::foo::transitive_import::Y;
+                pub type A = wasmtime::component::ResourceAny;
+                pub struct GuestA<'a> {
+                    funcs: &'a Guest,
+                }
+                pub struct Guest {
+                    constructor_a_constructor: wasmtime::component::Func,
+                    static_a_static_a: wasmtime::component::Func,
+                    method_a_method_a: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    constructor_a_constructor: wasmtime::component::ComponentExportIndex,
+                    static_a_static_a: wasmtime::component::ComponentExportIndex,
+                    method_a_method_a: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/export-using-import")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/export-using-import`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/export-using-import")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/export-using-import`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/export-using-import` does \
+                  not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let constructor_a_constructor = lookup("[constructor]a")?;
+                        let static_a_static_a = lookup("[static]a.static-a")?;
+                        let method_a_method_a = lookup("[method]a.method-a")?;
+                        Ok(GuestIndices {
+                            constructor_a_constructor,
+                            static_a_static_a,
+                            method_a_method_a,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let constructor_a_constructor = *_instance
+                            .get_typed_func::<
+                                (wasmtime::component::Resource<Y>,),
+                                (wasmtime::component::ResourceAny,),
+                            >(&mut store, &self.constructor_a_constructor)?
+                            .func();
+                        let static_a_static_a = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::Resource<Y>,),
+                            >(&mut store, &self.static_a_static_a)?
+                            .func();
+                        let method_a_method_a = *_instance
+                            .get_typed_func::<
+                                (
+                                    wasmtime::component::ResourceAny,
+                                    wasmtime::component::Resource<Y>,
+                                ),
+                                (wasmtime::component::Resource<Y>,),
+                            >(&mut store, &self.method_a_method_a)?
+                            .func();
+                        Ok(Guest {
+                            constructor_a_constructor,
+                            static_a_static_a,
+                            method_a_method_a,
+                        })
+                    }
+                }
+                impl Guest {
+                    pub fn a(&self) -> GuestA<'_> {
+                        GuestA { funcs: self }
+                    }
+                }
+                impl GuestA<'_> {
+                    pub async fn call_constructor<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: wasmtime::component::Resource<Y>,
+                    ) -> wasmtime::Result<wasmtime::component::ResourceAny>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (wasmtime::component::Resource<Y>,),
+                                (wasmtime::component::ResourceAny,),
+                            >::new_unchecked(self.funcs.constructor_a_constructor)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_static_a<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::Resource<Y>>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::Resource<Y>,),
+                            >::new_unchecked(self.funcs.static_a_static_a)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_method_a<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: wasmtime::component::ResourceAny,
+                        arg1: wasmtime::component::Resource<Y>,
+                    ) -> wasmtime::Result<wasmtime::component::Resource<Y>>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (
+                                    wasmtime::component::ResourceAny,
+                                    wasmtime::component::Resource<Y>,
+                                ),
+                                (wasmtime::component::Resource<Y>,),
+                            >::new_unchecked(self.funcs.method_a_method_a)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), (arg0, arg1))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                }
+            }
+            #[allow(clippy::all)]
+            pub mod export_using_export1 {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub type A = wasmtime::component::ResourceAny;
+                pub struct GuestA<'a> {
+                    funcs: &'a Guest,
+                }
+                pub struct Guest {
+                    constructor_a_constructor: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    constructor_a_constructor: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/export-using-export1")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/export-using-export1`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/export-using-export1")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/export-using-export1`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/export-using-export1` does \
+                  not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let constructor_a_constructor = lookup("[constructor]a")?;
+                        Ok(GuestIndices {
+                            constructor_a_constructor,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let constructor_a_constructor = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::ResourceAny,),
+                            >(&mut store, &self.constructor_a_constructor)?
+                            .func();
+                        Ok(Guest { constructor_a_constructor })
+                    }
+                }
+                impl Guest {
+                    pub fn a(&self) -> GuestA<'_> {
+                        GuestA { funcs: self }
+                    }
+                }
+                impl GuestA<'_> {
+                    pub async fn call_constructor<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::ResourceAny>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::ResourceAny,),
+                            >::new_unchecked(self.funcs.constructor_a_constructor)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                }
+            }
+            #[allow(clippy::all)]
+            pub mod export_using_export2 {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub type A = super::super::super::super::exports::foo::foo::export_using_export1::A;
+                pub type B = wasmtime::component::ResourceAny;
+                pub struct GuestB<'a> {
+                    funcs: &'a Guest,
+                }
+                pub struct Guest {
+                    constructor_b_constructor: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    constructor_b_constructor: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/export-using-export2")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/export-using-export2`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/export-using-export2")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/export-using-export2`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/export-using-export2` does \
+                  not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let constructor_b_constructor = lookup("[constructor]b")?;
+                        Ok(GuestIndices {
+                            constructor_b_constructor,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let constructor_b_constructor = *_instance
+                            .get_typed_func::<
+                                (wasmtime::component::ResourceAny,),
+                                (wasmtime::component::ResourceAny,),
+                            >(&mut store, &self.constructor_b_constructor)?
+                            .func();
+                        Ok(Guest { constructor_b_constructor })
+                    }
+                }
+                impl Guest {
+                    pub fn b(&self) -> GuestB<'_> {
+                        GuestB { funcs: self }
+                    }
+                }
+                impl GuestB<'_> {
+                    pub async fn call_constructor<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: wasmtime::component::ResourceAny,
+                    ) -> wasmtime::Result<wasmtime::component::ResourceAny>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (wasmtime::component::ResourceAny,),
+                                (wasmtime::component::ResourceAny,),
+                            >::new_unchecked(self.funcs.constructor_b_constructor)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/resources-import.rs b/crates/component-macro/tests/expanded/resources-import.rs
new file mode 100644
index 000000000000..cbea8b03f851
--- /dev/null
+++ b/crates/component-macro/tests/expanded/resources-import.rs
@@ -0,0 +1,1217 @@
+pub enum WorldResource {}
+pub trait HostWorldResource {
+    fn new(&mut self) -> wasmtime::component::Resource<WorldResource>;
+    fn foo(&mut self, self_: wasmtime::component::Resource<WorldResource>) -> ();
+    fn static_foo(&mut self) -> ();
+    fn drop(
+        &mut self,
+        rep: wasmtime::component::Resource<WorldResource>,
+    ) -> wasmtime::Result<()>;
+}
+impl<_T: HostWorldResource + ?Sized> HostWorldResource for &mut _T {
+    fn new(&mut self) -> wasmtime::component::Resource<WorldResource> {
+        HostWorldResource::new(*self)
+    }
+    fn foo(&mut self, self_: wasmtime::component::Resource<WorldResource>) -> () {
+        HostWorldResource::foo(*self, self_)
+    }
+    fn static_foo(&mut self) -> () {
+        HostWorldResource::static_foo(*self)
+    }
+    fn drop(
+        &mut self,
+        rep: wasmtime::component::Resource<WorldResource>,
+    ) -> wasmtime::Result<()> {
+        HostWorldResource::drop(*self, rep)
+    }
+}
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-world`.
+///
+/// This structure is created through [`TheWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheWorld`] as well.
+pub struct TheWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheWorldIndices,
+}
+impl<T> Clone for TheWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheWorldPre<_T> {
+    /// Creates a new copy of `TheWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheWorld> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-world`.
+///
+/// This is an implementation detail of [`TheWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheWorld`] as well.
+#[derive(Clone)]
+pub struct TheWorldIndices {
+    interface1: exports::foo::foo::uses_resource_transitively::GuestIndices,
+    some_world_func2: wasmtime::component::ComponentExportIndex,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheWorld::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheWorldPre::instantiate`] to
+///   create a [`TheWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheWorldIndices::new_instance`] followed
+///   by [`TheWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheWorld {
+    interface1: exports::foo::foo::uses_resource_transitively::Guest,
+    some_world_func2: wasmtime::component::Func,
+}
+pub trait TheWorldImports: HostWorldResource {
+    fn some_world_func(&mut self) -> wasmtime::component::Resource<WorldResource>;
+}
+pub trait TheWorldImportsGetHost<
+    T,
+>: Fn(T) -> <Self as TheWorldImportsGetHost<T>>::Host + Send + Sync + Copy + 'static {
+    type Host: TheWorldImports;
+}
+impl<F, T, O> TheWorldImportsGetHost<T> for F
+where
+    F: Fn(T) -> O + Send + Sync + Copy + 'static,
+    O: TheWorldImports,
+{
+    type Host = O;
+}
+impl<_T: TheWorldImports + ?Sized> TheWorldImports for &mut _T {
+    fn some_world_func(&mut self) -> wasmtime::component::Resource<WorldResource> {
+        TheWorldImports::some_world_func(*self)
+    }
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheWorldIndices {
+        /// Creates a new copy of `TheWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface1 = exports::foo::foo::uses_resource_transitively::GuestIndices::new(
+                _component,
+            )?;
+            let some_world_func2 = _component
+                .export_index(None, "some-world-func2")
+                .ok_or_else(|| {
+                    anyhow::anyhow!("no function export `some-world-func2` found")
+                })?
+                .1;
+            Ok(TheWorldIndices {
+                interface1,
+                some_world_func2,
+            })
+        }
+        /// Creates a new instance of [`TheWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface1 = exports::foo::foo::uses_resource_transitively::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            let some_world_func2 = _instance
+                .get_export(&mut store, None, "some-world-func2")
+                .ok_or_else(|| {
+                    anyhow::anyhow!("no function export `some-world-func2` found")
+                })?;
+            Ok(TheWorldIndices {
+                interface1,
+                some_world_func2,
+            })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let _instance = instance;
+            let interface1 = self.interface1.load(&mut store, &_instance)?;
+            let some_world_func2 = *_instance
+                .get_typed_func::<
+                    (),
+                    (wasmtime::component::Resource<WorldResource>,),
+                >(&mut store, &self.some_world_func2)?
+                .func();
+            Ok(TheWorld {
+                interface1,
+                some_world_func2,
+            })
+        }
+    }
+    impl TheWorld {
+        /// Convenience wrapper around [`TheWorldPre::new`] and
+        /// [`TheWorldPre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheWorld> {
+            let pre = linker.instantiate_pre(component)?;
+            TheWorldPre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`TheWorldIndices::new_instance`] and
+        /// [`TheWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let indices = TheWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker_imports_get_host<T>(
+            linker: &mut wasmtime::component::Linker<T>,
+            host_getter: impl for<'a> TheWorldImportsGetHost<&'a mut T>,
+        ) -> wasmtime::Result<()> {
+            let mut linker = linker.root();
+            linker
+                .resource(
+                    "world-resource",
+                    wasmtime::component::ResourceType::host::<WorldResource>(),
+                    move |mut store, rep| -> wasmtime::Result<()> {
+                        HostWorldResource::drop(
+                            &mut host_getter(store.data_mut()),
+                            wasmtime::component::Resource::new_own(rep),
+                        )
+                    },
+                )?;
+            linker
+                .func_wrap(
+                    "[constructor]world-resource",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = HostWorldResource::new(host);
+                        Ok((r,))
+                    },
+                )?;
+            linker
+                .func_wrap(
+                    "[method]world-resource.foo",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::Resource<WorldResource>,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = HostWorldResource::foo(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+            linker
+                .func_wrap(
+                    "[static]world-resource.static-foo",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = HostWorldResource::static_foo(host);
+                        Ok(r)
+                    },
+                )?;
+            linker
+                .func_wrap(
+                    "some-world-func",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = TheWorldImports::some_world_func(host);
+                        Ok((r,))
+                    },
+                )?;
+            Ok(())
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            U: foo::foo::resources::Host + foo::foo::long_use_chain1::Host
+                + foo::foo::long_use_chain2::Host + foo::foo::long_use_chain3::Host
+                + foo::foo::long_use_chain4::Host
+                + foo::foo::transitive_interface_with_resource::Host + TheWorldImports,
+        {
+            Self::add_to_linker_imports_get_host(linker, get)?;
+            foo::foo::resources::add_to_linker(linker, get)?;
+            foo::foo::long_use_chain1::add_to_linker(linker, get)?;
+            foo::foo::long_use_chain2::add_to_linker(linker, get)?;
+            foo::foo::long_use_chain3::add_to_linker(linker, get)?;
+            foo::foo::long_use_chain4::add_to_linker(linker, get)?;
+            foo::foo::transitive_interface_with_resource::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn call_some_world_func2<S: wasmtime::AsContextMut>(
+            &self,
+            mut store: S,
+        ) -> wasmtime::Result<wasmtime::component::Resource<WorldResource>> {
+            let callee = unsafe {
+                wasmtime::component::TypedFunc::<
+                    (),
+                    (wasmtime::component::Resource<WorldResource>,),
+                >::new_unchecked(self.some_world_func2)
+            };
+            let (ret0,) = callee.call(store.as_context_mut(), ())?;
+            callee.post_return(store.as_context_mut())?;
+            Ok(ret0)
+        }
+        pub fn foo_foo_uses_resource_transitively(
+            &self,
+        ) -> &exports::foo::foo::uses_resource_transitively::Guest {
+            &self.interface1
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod resources {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub enum Bar {}
+            pub trait HostBar {
+                fn new(&mut self) -> wasmtime::component::Resource<Bar>;
+                fn static_a(&mut self) -> u32;
+                fn method_a(&mut self, self_: wasmtime::component::Resource<Bar>) -> u32;
+                fn drop(
+                    &mut self,
+                    rep: wasmtime::component::Resource<Bar>,
+                ) -> wasmtime::Result<()>;
+            }
+            impl<_T: HostBar + ?Sized> HostBar for &mut _T {
+                fn new(&mut self) -> wasmtime::component::Resource<Bar> {
+                    HostBar::new(*self)
+                }
+                fn static_a(&mut self) -> u32 {
+                    HostBar::static_a(*self)
+                }
+                fn method_a(
+                    &mut self,
+                    self_: wasmtime::component::Resource<Bar>,
+                ) -> u32 {
+                    HostBar::method_a(*self, self_)
+                }
+                fn drop(
+                    &mut self,
+                    rep: wasmtime::component::Resource<Bar>,
+                ) -> wasmtime::Result<()> {
+                    HostBar::drop(*self, rep)
+                }
+            }
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            pub struct NestedOwn {
+                #[component(name = "nested-bar")]
+                pub nested_bar: wasmtime::component::Resource<Bar>,
+            }
+            impl core::fmt::Debug for NestedOwn {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("NestedOwn")
+                        .field("nested-bar", &self.nested_bar)
+                        .finish()
+                }
+            }
+            const _: () = {
+                assert!(
+                    4 == < NestedOwn as wasmtime::component::ComponentType >::SIZE32
+                );
+                assert!(
+                    4 == < NestedOwn as wasmtime::component::ComponentType >::ALIGN32
+                );
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            pub struct NestedBorrow {
+                #[component(name = "nested-bar")]
+                pub nested_bar: wasmtime::component::Resource<Bar>,
+            }
+            impl core::fmt::Debug for NestedBorrow {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("NestedBorrow")
+                        .field("nested-bar", &self.nested_bar)
+                        .finish()
+                }
+            }
+            const _: () = {
+                assert!(
+                    4 == < NestedBorrow as wasmtime::component::ComponentType >::SIZE32
+                );
+                assert!(
+                    4 == < NestedBorrow as wasmtime::component::ComponentType >::ALIGN32
+                );
+            };
+            pub type SomeHandle = wasmtime::component::Resource<Bar>;
+            const _: () = {
+                assert!(
+                    4 == < SomeHandle as wasmtime::component::ComponentType >::SIZE32
+                );
+                assert!(
+                    4 == < SomeHandle as wasmtime::component::ComponentType >::ALIGN32
+                );
+            };
+            pub trait Host: HostBar {
+                fn bar_own_arg(&mut self, x: wasmtime::component::Resource<Bar>) -> ();
+                fn bar_borrow_arg(
+                    &mut self,
+                    x: wasmtime::component::Resource<Bar>,
+                ) -> ();
+                fn bar_result(&mut self) -> wasmtime::component::Resource<Bar>;
+                fn tuple_own_arg(
+                    &mut self,
+                    x: (wasmtime::component::Resource<Bar>, u32),
+                ) -> ();
+                fn tuple_borrow_arg(
+                    &mut self,
+                    x: (wasmtime::component::Resource<Bar>, u32),
+                ) -> ();
+                fn tuple_result(&mut self) -> (wasmtime::component::Resource<Bar>, u32);
+                fn option_own_arg(
+                    &mut self,
+                    x: Option<wasmtime::component::Resource<Bar>>,
+                ) -> ();
+                fn option_borrow_arg(
+                    &mut self,
+                    x: Option<wasmtime::component::Resource<Bar>>,
+                ) -> ();
+                fn option_result(
+                    &mut self,
+                ) -> Option<wasmtime::component::Resource<Bar>>;
+                fn result_own_arg(
+                    &mut self,
+                    x: Result<wasmtime::component::Resource<Bar>, ()>,
+                ) -> ();
+                fn result_borrow_arg(
+                    &mut self,
+                    x: Result<wasmtime::component::Resource<Bar>, ()>,
+                ) -> ();
+                fn result_result(
+                    &mut self,
+                ) -> Result<wasmtime::component::Resource<Bar>, ()>;
+                fn list_own_arg(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<
+                        wasmtime::component::Resource<Bar>,
+                    >,
+                ) -> ();
+                fn list_borrow_arg(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<
+                        wasmtime::component::Resource<Bar>,
+                    >,
+                ) -> ();
+                fn list_result(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<
+                    wasmtime::component::Resource<Bar>,
+                >;
+                fn record_own_arg(&mut self, x: NestedOwn) -> ();
+                fn record_borrow_arg(&mut self, x: NestedBorrow) -> ();
+                fn record_result(&mut self) -> NestedOwn;
+                fn func_with_handle_typedef(&mut self, x: SomeHandle) -> ();
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/resources")?;
+                inst.resource(
+                    "bar",
+                    wasmtime::component::ResourceType::host::<Bar>(),
+                    move |mut store, rep| -> wasmtime::Result<()> {
+                        HostBar::drop(
+                            &mut host_getter(store.data_mut()),
+                            wasmtime::component::Resource::new_own(rep),
+                        )
+                    },
+                )?;
+                inst.func_wrap(
+                    "[constructor]bar",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = HostBar::new(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "[static]bar.static-a",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = HostBar::static_a(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "[method]bar.method-a",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::Resource<Bar>,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = HostBar::method_a(host, arg0);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "bar-own-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::Resource<Bar>,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::bar_own_arg(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "bar-borrow-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::Resource<Bar>,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::bar_borrow_arg(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "bar-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::bar_result(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "tuple-own-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): ((wasmtime::component::Resource<Bar>, u32),)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::tuple_own_arg(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "tuple-borrow-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): ((wasmtime::component::Resource<Bar>, u32),)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::tuple_borrow_arg(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "tuple-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::tuple_result(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "option-own-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (Option<wasmtime::component::Resource<Bar>>,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::option_own_arg(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "option-borrow-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (Option<wasmtime::component::Resource<Bar>>,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::option_borrow_arg(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "option-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::option_result(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "result-own-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (Result<wasmtime::component::Resource<Bar>, ()>,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::result_own_arg(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "result-borrow-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (Result<wasmtime::component::Resource<Bar>, ()>,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::result_borrow_arg(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "result-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::result_result(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "list-own-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (
+                            arg0,
+                        ): (
+                            wasmtime::component::__internal::Vec<
+                                wasmtime::component::Resource<Bar>,
+                            >,
+                        )|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_own_arg(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "list-borrow-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (
+                            arg0,
+                        ): (
+                            wasmtime::component::__internal::Vec<
+                                wasmtime::component::Resource<Bar>,
+                            >,
+                        )|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_borrow_arg(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "list-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_result(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "record-own-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (NestedOwn,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::record_own_arg(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "record-borrow-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (NestedBorrow,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::record_borrow_arg(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "record-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::record_result(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "func-with-handle-typedef",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (SomeHandle,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::func_with_handle_typedef(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {
+                fn bar_own_arg(&mut self, x: wasmtime::component::Resource<Bar>) -> () {
+                    Host::bar_own_arg(*self, x)
+                }
+                fn bar_borrow_arg(
+                    &mut self,
+                    x: wasmtime::component::Resource<Bar>,
+                ) -> () {
+                    Host::bar_borrow_arg(*self, x)
+                }
+                fn bar_result(&mut self) -> wasmtime::component::Resource<Bar> {
+                    Host::bar_result(*self)
+                }
+                fn tuple_own_arg(
+                    &mut self,
+                    x: (wasmtime::component::Resource<Bar>, u32),
+                ) -> () {
+                    Host::tuple_own_arg(*self, x)
+                }
+                fn tuple_borrow_arg(
+                    &mut self,
+                    x: (wasmtime::component::Resource<Bar>, u32),
+                ) -> () {
+                    Host::tuple_borrow_arg(*self, x)
+                }
+                fn tuple_result(&mut self) -> (wasmtime::component::Resource<Bar>, u32) {
+                    Host::tuple_result(*self)
+                }
+                fn option_own_arg(
+                    &mut self,
+                    x: Option<wasmtime::component::Resource<Bar>>,
+                ) -> () {
+                    Host::option_own_arg(*self, x)
+                }
+                fn option_borrow_arg(
+                    &mut self,
+                    x: Option<wasmtime::component::Resource<Bar>>,
+                ) -> () {
+                    Host::option_borrow_arg(*self, x)
+                }
+                fn option_result(
+                    &mut self,
+                ) -> Option<wasmtime::component::Resource<Bar>> {
+                    Host::option_result(*self)
+                }
+                fn result_own_arg(
+                    &mut self,
+                    x: Result<wasmtime::component::Resource<Bar>, ()>,
+                ) -> () {
+                    Host::result_own_arg(*self, x)
+                }
+                fn result_borrow_arg(
+                    &mut self,
+                    x: Result<wasmtime::component::Resource<Bar>, ()>,
+                ) -> () {
+                    Host::result_borrow_arg(*self, x)
+                }
+                fn result_result(
+                    &mut self,
+                ) -> Result<wasmtime::component::Resource<Bar>, ()> {
+                    Host::result_result(*self)
+                }
+                fn list_own_arg(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<
+                        wasmtime::component::Resource<Bar>,
+                    >,
+                ) -> () {
+                    Host::list_own_arg(*self, x)
+                }
+                fn list_borrow_arg(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<
+                        wasmtime::component::Resource<Bar>,
+                    >,
+                ) -> () {
+                    Host::list_borrow_arg(*self, x)
+                }
+                fn list_result(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<
+                    wasmtime::component::Resource<Bar>,
+                > {
+                    Host::list_result(*self)
+                }
+                fn record_own_arg(&mut self, x: NestedOwn) -> () {
+                    Host::record_own_arg(*self, x)
+                }
+                fn record_borrow_arg(&mut self, x: NestedBorrow) -> () {
+                    Host::record_borrow_arg(*self, x)
+                }
+                fn record_result(&mut self) -> NestedOwn {
+                    Host::record_result(*self)
+                }
+                fn func_with_handle_typedef(&mut self, x: SomeHandle) -> () {
+                    Host::func_with_handle_typedef(*self, x)
+                }
+            }
+        }
+        #[allow(clippy::all)]
+        pub mod long_use_chain1 {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub enum A {}
+            pub trait HostA {
+                fn drop(
+                    &mut self,
+                    rep: wasmtime::component::Resource<A>,
+                ) -> wasmtime::Result<()>;
+            }
+            impl<_T: HostA + ?Sized> HostA for &mut _T {
+                fn drop(
+                    &mut self,
+                    rep: wasmtime::component::Resource<A>,
+                ) -> wasmtime::Result<()> {
+                    HostA::drop(*self, rep)
+                }
+            }
+            pub trait Host: HostA {}
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/long-use-chain1")?;
+                inst.resource(
+                    "a",
+                    wasmtime::component::ResourceType::host::<A>(),
+                    move |mut store, rep| -> wasmtime::Result<()> {
+                        HostA::drop(
+                            &mut host_getter(store.data_mut()),
+                            wasmtime::component::Resource::new_own(rep),
+                        )
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {}
+        }
+        #[allow(clippy::all)]
+        pub mod long_use_chain2 {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub type A = super::super::super::foo::foo::long_use_chain1::A;
+            pub trait Host {}
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/long-use-chain2")?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {}
+        }
+        #[allow(clippy::all)]
+        pub mod long_use_chain3 {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub type A = super::super::super::foo::foo::long_use_chain2::A;
+            pub trait Host {}
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/long-use-chain3")?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {}
+        }
+        #[allow(clippy::all)]
+        pub mod long_use_chain4 {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub type A = super::super::super::foo::foo::long_use_chain3::A;
+            pub trait Host {
+                fn foo(&mut self) -> wasmtime::component::Resource<A>;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/long-use-chain4")?;
+                inst.func_wrap(
+                    "foo",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::foo(host);
+                        Ok((r,))
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {
+                fn foo(&mut self) -> wasmtime::component::Resource<A> {
+                    Host::foo(*self)
+                }
+            }
+        }
+        #[allow(clippy::all)]
+        pub mod transitive_interface_with_resource {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub enum Foo {}
+            pub trait HostFoo {
+                fn drop(
+                    &mut self,
+                    rep: wasmtime::component::Resource<Foo>,
+                ) -> wasmtime::Result<()>;
+            }
+            impl<_T: HostFoo + ?Sized> HostFoo for &mut _T {
+                fn drop(
+                    &mut self,
+                    rep: wasmtime::component::Resource<Foo>,
+                ) -> wasmtime::Result<()> {
+                    HostFoo::drop(*self, rep)
+                }
+            }
+            pub trait Host: HostFoo {}
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker
+                    .instance("foo:foo/transitive-interface-with-resource")?;
+                inst.resource(
+                    "foo",
+                    wasmtime::component::ResourceType::host::<Foo>(),
+                    move |mut store, rep| -> wasmtime::Result<()> {
+                        HostFoo::drop(
+                            &mut host_getter(store.data_mut()),
+                            wasmtime::component::Resource::new_own(rep),
+                        )
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {}
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod uses_resource_transitively {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub type Foo = super::super::super::super::foo::foo::transitive_interface_with_resource::Foo;
+                pub struct Guest {
+                    handle: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    handle: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/uses-resource-transitively")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/uses-resource-transitively`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(
+                                &mut store,
+                                None,
+                                "foo:foo/uses-resource-transitively",
+                            )
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/uses-resource-transitively`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/uses-resource-transitively` does \
+                        not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let handle = lookup("handle")?;
+                        Ok(GuestIndices { handle })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let handle = *_instance
+                            .get_typed_func::<
+                                (wasmtime::component::Resource<Foo>,),
+                                (),
+                            >(&mut store, &self.handle)?
+                            .func();
+                        Ok(Guest { handle })
+                    }
+                }
+                impl Guest {
+                    pub fn call_handle<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: wasmtime::component::Resource<Foo>,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (wasmtime::component::Resource<Foo>,),
+                                (),
+                            >::new_unchecked(self.handle)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/resources-import_async.rs b/crates/component-macro/tests/expanded/resources-import_async.rs
new file mode 100644
index 000000000000..1b8424df1eef
--- /dev/null
+++ b/crates/component-macro/tests/expanded/resources-import_async.rs
@@ -0,0 +1,1307 @@
+pub enum WorldResource {}
+#[wasmtime::component::__internal::async_trait]
+pub trait HostWorldResource {
+    async fn new(&mut self) -> wasmtime::component::Resource<WorldResource>;
+    async fn foo(&mut self, self_: wasmtime::component::Resource<WorldResource>) -> ();
+    async fn static_foo(&mut self) -> ();
+    async fn drop(
+        &mut self,
+        rep: wasmtime::component::Resource<WorldResource>,
+    ) -> wasmtime::Result<()>;
+}
+#[wasmtime::component::__internal::async_trait]
+impl<_T: HostWorldResource + ?Sized + Send> HostWorldResource for &mut _T {
+    async fn new(&mut self) -> wasmtime::component::Resource<WorldResource> {
+        HostWorldResource::new(*self).await
+    }
+    async fn foo(&mut self, self_: wasmtime::component::Resource<WorldResource>) -> () {
+        HostWorldResource::foo(*self, self_).await
+    }
+    async fn static_foo(&mut self) -> () {
+        HostWorldResource::static_foo(*self).await
+    }
+    async fn drop(
+        &mut self,
+        rep: wasmtime::component::Resource<WorldResource>,
+    ) -> wasmtime::Result<()> {
+        HostWorldResource::drop(*self, rep).await
+    }
+}
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-world`.
+///
+/// This structure is created through [`TheWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheWorld`] as well.
+pub struct TheWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheWorldIndices,
+}
+impl<T> Clone for TheWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheWorldPre<_T> {
+    /// Creates a new copy of `TheWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheWorld>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-world`.
+///
+/// This is an implementation detail of [`TheWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheWorld`] as well.
+#[derive(Clone)]
+pub struct TheWorldIndices {
+    interface1: exports::foo::foo::uses_resource_transitively::GuestIndices,
+    some_world_func2: wasmtime::component::ComponentExportIndex,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheWorld::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheWorldPre::instantiate_async`] to
+///   create a [`TheWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheWorldIndices::new_instance`] followed
+///   by [`TheWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheWorld {
+    interface1: exports::foo::foo::uses_resource_transitively::Guest,
+    some_world_func2: wasmtime::component::Func,
+}
+#[wasmtime::component::__internal::async_trait]
+pub trait TheWorldImports: Send + HostWorldResource {
+    async fn some_world_func(&mut self) -> wasmtime::component::Resource<WorldResource>;
+}
+pub trait TheWorldImportsGetHost<
+    T,
+>: Fn(T) -> <Self as TheWorldImportsGetHost<T>>::Host + Send + Sync + Copy + 'static {
+    type Host: TheWorldImports;
+}
+impl<F, T, O> TheWorldImportsGetHost<T> for F
+where
+    F: Fn(T) -> O + Send + Sync + Copy + 'static,
+    O: TheWorldImports,
+{
+    type Host = O;
+}
+#[wasmtime::component::__internal::async_trait]
+impl<_T: TheWorldImports + ?Sized + Send> TheWorldImports for &mut _T {
+    async fn some_world_func(&mut self) -> wasmtime::component::Resource<WorldResource> {
+        TheWorldImports::some_world_func(*self).await
+    }
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheWorldIndices {
+        /// Creates a new copy of `TheWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface1 = exports::foo::foo::uses_resource_transitively::GuestIndices::new(
+                _component,
+            )?;
+            let some_world_func2 = _component
+                .export_index(None, "some-world-func2")
+                .ok_or_else(|| {
+                    anyhow::anyhow!("no function export `some-world-func2` found")
+                })?
+                .1;
+            Ok(TheWorldIndices {
+                interface1,
+                some_world_func2,
+            })
+        }
+        /// Creates a new instance of [`TheWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface1 = exports::foo::foo::uses_resource_transitively::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            let some_world_func2 = _instance
+                .get_export(&mut store, None, "some-world-func2")
+                .ok_or_else(|| {
+                    anyhow::anyhow!("no function export `some-world-func2` found")
+                })?;
+            Ok(TheWorldIndices {
+                interface1,
+                some_world_func2,
+            })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let _instance = instance;
+            let interface1 = self.interface1.load(&mut store, &_instance)?;
+            let some_world_func2 = *_instance
+                .get_typed_func::<
+                    (),
+                    (wasmtime::component::Resource<WorldResource>,),
+                >(&mut store, &self.some_world_func2)?
+                .func();
+            Ok(TheWorld {
+                interface1,
+                some_world_func2,
+            })
+        }
+    }
+    impl TheWorld {
+        /// Convenience wrapper around [`TheWorldPre::new`] and
+        /// [`TheWorldPre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheWorld>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            TheWorldPre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`TheWorldIndices::new_instance`] and
+        /// [`TheWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let indices = TheWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker_imports_get_host<T>(
+            linker: &mut wasmtime::component::Linker<T>,
+            host_getter: impl for<'a> TheWorldImportsGetHost<&'a mut T>,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+        {
+            let mut linker = linker.root();
+            linker
+                .resource_async(
+                    "world-resource",
+                    wasmtime::component::ResourceType::host::<WorldResource>(),
+                    move |mut store, rep| {
+                        std::boxed::Box::new(async move {
+                            HostWorldResource::drop(
+                                    &mut host_getter(store.data_mut()),
+                                    wasmtime::component::Resource::new_own(rep),
+                                )
+                                .await
+                        })
+                    },
+                )?;
+            linker
+                .func_wrap_async(
+                    "[constructor]world-resource",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = HostWorldResource::new(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+            linker
+                .func_wrap_async(
+                    "[method]world-resource.foo",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::Resource<WorldResource>,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = HostWorldResource::foo(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+            linker
+                .func_wrap_async(
+                    "[static]world-resource.static-foo",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = HostWorldResource::static_foo(host).await;
+                        Ok(r)
+                    }),
+                )?;
+            linker
+                .func_wrap_async(
+                    "some-world-func",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = TheWorldImports::some_world_func(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+            Ok(())
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+            U: foo::foo::resources::Host + foo::foo::long_use_chain1::Host
+                + foo::foo::long_use_chain2::Host + foo::foo::long_use_chain3::Host
+                + foo::foo::long_use_chain4::Host
+                + foo::foo::transitive_interface_with_resource::Host + TheWorldImports
+                + Send,
+        {
+            Self::add_to_linker_imports_get_host(linker, get)?;
+            foo::foo::resources::add_to_linker(linker, get)?;
+            foo::foo::long_use_chain1::add_to_linker(linker, get)?;
+            foo::foo::long_use_chain2::add_to_linker(linker, get)?;
+            foo::foo::long_use_chain3::add_to_linker(linker, get)?;
+            foo::foo::long_use_chain4::add_to_linker(linker, get)?;
+            foo::foo::transitive_interface_with_resource::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub async fn call_some_world_func2<S: wasmtime::AsContextMut>(
+            &self,
+            mut store: S,
+        ) -> wasmtime::Result<wasmtime::component::Resource<WorldResource>>
+        where
+            <S as wasmtime::AsContext>::Data: Send,
+        {
+            let callee = unsafe {
+                wasmtime::component::TypedFunc::<
+                    (),
+                    (wasmtime::component::Resource<WorldResource>,),
+                >::new_unchecked(self.some_world_func2)
+            };
+            let (ret0,) = callee.call_async(store.as_context_mut(), ()).await?;
+            callee.post_return_async(store.as_context_mut()).await?;
+            Ok(ret0)
+        }
+        pub fn foo_foo_uses_resource_transitively(
+            &self,
+        ) -> &exports::foo::foo::uses_resource_transitively::Guest {
+            &self.interface1
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod resources {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub enum Bar {}
+            #[wasmtime::component::__internal::async_trait]
+            pub trait HostBar {
+                async fn new(&mut self) -> wasmtime::component::Resource<Bar>;
+                async fn static_a(&mut self) -> u32;
+                async fn method_a(
+                    &mut self,
+                    self_: wasmtime::component::Resource<Bar>,
+                ) -> u32;
+                async fn drop(
+                    &mut self,
+                    rep: wasmtime::component::Resource<Bar>,
+                ) -> wasmtime::Result<()>;
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: HostBar + ?Sized + Send> HostBar for &mut _T {
+                async fn new(&mut self) -> wasmtime::component::Resource<Bar> {
+                    HostBar::new(*self).await
+                }
+                async fn static_a(&mut self) -> u32 {
+                    HostBar::static_a(*self).await
+                }
+                async fn method_a(
+                    &mut self,
+                    self_: wasmtime::component::Resource<Bar>,
+                ) -> u32 {
+                    HostBar::method_a(*self, self_).await
+                }
+                async fn drop(
+                    &mut self,
+                    rep: wasmtime::component::Resource<Bar>,
+                ) -> wasmtime::Result<()> {
+                    HostBar::drop(*self, rep).await
+                }
+            }
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            pub struct NestedOwn {
+                #[component(name = "nested-bar")]
+                pub nested_bar: wasmtime::component::Resource<Bar>,
+            }
+            impl core::fmt::Debug for NestedOwn {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("NestedOwn")
+                        .field("nested-bar", &self.nested_bar)
+                        .finish()
+                }
+            }
+            const _: () = {
+                assert!(
+                    4 == < NestedOwn as wasmtime::component::ComponentType >::SIZE32
+                );
+                assert!(
+                    4 == < NestedOwn as wasmtime::component::ComponentType >::ALIGN32
+                );
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            pub struct NestedBorrow {
+                #[component(name = "nested-bar")]
+                pub nested_bar: wasmtime::component::Resource<Bar>,
+            }
+            impl core::fmt::Debug for NestedBorrow {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("NestedBorrow")
+                        .field("nested-bar", &self.nested_bar)
+                        .finish()
+                }
+            }
+            const _: () = {
+                assert!(
+                    4 == < NestedBorrow as wasmtime::component::ComponentType >::SIZE32
+                );
+                assert!(
+                    4 == < NestedBorrow as wasmtime::component::ComponentType >::ALIGN32
+                );
+            };
+            pub type SomeHandle = wasmtime::component::Resource<Bar>;
+            const _: () = {
+                assert!(
+                    4 == < SomeHandle as wasmtime::component::ComponentType >::SIZE32
+                );
+                assert!(
+                    4 == < SomeHandle as wasmtime::component::ComponentType >::ALIGN32
+                );
+            };
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send + HostBar {
+                async fn bar_own_arg(
+                    &mut self,
+                    x: wasmtime::component::Resource<Bar>,
+                ) -> ();
+                async fn bar_borrow_arg(
+                    &mut self,
+                    x: wasmtime::component::Resource<Bar>,
+                ) -> ();
+                async fn bar_result(&mut self) -> wasmtime::component::Resource<Bar>;
+                async fn tuple_own_arg(
+                    &mut self,
+                    x: (wasmtime::component::Resource<Bar>, u32),
+                ) -> ();
+                async fn tuple_borrow_arg(
+                    &mut self,
+                    x: (wasmtime::component::Resource<Bar>, u32),
+                ) -> ();
+                async fn tuple_result(
+                    &mut self,
+                ) -> (wasmtime::component::Resource<Bar>, u32);
+                async fn option_own_arg(
+                    &mut self,
+                    x: Option<wasmtime::component::Resource<Bar>>,
+                ) -> ();
+                async fn option_borrow_arg(
+                    &mut self,
+                    x: Option<wasmtime::component::Resource<Bar>>,
+                ) -> ();
+                async fn option_result(
+                    &mut self,
+                ) -> Option<wasmtime::component::Resource<Bar>>;
+                async fn result_own_arg(
+                    &mut self,
+                    x: Result<wasmtime::component::Resource<Bar>, ()>,
+                ) -> ();
+                async fn result_borrow_arg(
+                    &mut self,
+                    x: Result<wasmtime::component::Resource<Bar>, ()>,
+                ) -> ();
+                async fn result_result(
+                    &mut self,
+                ) -> Result<wasmtime::component::Resource<Bar>, ()>;
+                async fn list_own_arg(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<
+                        wasmtime::component::Resource<Bar>,
+                    >,
+                ) -> ();
+                async fn list_borrow_arg(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<
+                        wasmtime::component::Resource<Bar>,
+                    >,
+                ) -> ();
+                async fn list_result(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<
+                    wasmtime::component::Resource<Bar>,
+                >;
+                async fn record_own_arg(&mut self, x: NestedOwn) -> ();
+                async fn record_borrow_arg(&mut self, x: NestedBorrow) -> ();
+                async fn record_result(&mut self) -> NestedOwn;
+                async fn func_with_handle_typedef(&mut self, x: SomeHandle) -> ();
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/resources")?;
+                inst.resource_async(
+                    "bar",
+                    wasmtime::component::ResourceType::host::<Bar>(),
+                    move |mut store, rep| {
+                        std::boxed::Box::new(async move {
+                            HostBar::drop(
+                                    &mut host_getter(store.data_mut()),
+                                    wasmtime::component::Resource::new_own(rep),
+                                )
+                                .await
+                        })
+                    },
+                )?;
+                inst.func_wrap_async(
+                    "[constructor]bar",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = HostBar::new(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "[static]bar.static-a",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = HostBar::static_a(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "[method]bar.method-a",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::Resource<Bar>,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = HostBar::method_a(host, arg0).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "bar-own-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::Resource<Bar>,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::bar_own_arg(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "bar-borrow-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::Resource<Bar>,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::bar_borrow_arg(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "bar-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::bar_result(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "tuple-own-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): ((wasmtime::component::Resource<Bar>, u32),)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::tuple_own_arg(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "tuple-borrow-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): ((wasmtime::component::Resource<Bar>, u32),)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::tuple_borrow_arg(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "tuple-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::tuple_result(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "option-own-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (Option<wasmtime::component::Resource<Bar>>,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::option_own_arg(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "option-borrow-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (Option<wasmtime::component::Resource<Bar>>,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::option_borrow_arg(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "option-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::option_result(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "result-own-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (Result<wasmtime::component::Resource<Bar>, ()>,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::result_own_arg(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "result-borrow-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (Result<wasmtime::component::Resource<Bar>, ()>,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::result_borrow_arg(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "result-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::result_result(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "list-own-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (
+                            arg0,
+                        ): (
+                            wasmtime::component::__internal::Vec<
+                                wasmtime::component::Resource<Bar>,
+                            >,
+                        )|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_own_arg(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "list-borrow-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (
+                            arg0,
+                        ): (
+                            wasmtime::component::__internal::Vec<
+                                wasmtime::component::Resource<Bar>,
+                            >,
+                        )|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_borrow_arg(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "list-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::list_result(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "record-own-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (NestedOwn,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::record_own_arg(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "record-borrow-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (NestedBorrow,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::record_borrow_arg(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "record-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::record_result(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "func-with-handle-typedef",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (SomeHandle,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::func_with_handle_typedef(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {
+                async fn bar_own_arg(
+                    &mut self,
+                    x: wasmtime::component::Resource<Bar>,
+                ) -> () {
+                    Host::bar_own_arg(*self, x).await
+                }
+                async fn bar_borrow_arg(
+                    &mut self,
+                    x: wasmtime::component::Resource<Bar>,
+                ) -> () {
+                    Host::bar_borrow_arg(*self, x).await
+                }
+                async fn bar_result(&mut self) -> wasmtime::component::Resource<Bar> {
+                    Host::bar_result(*self).await
+                }
+                async fn tuple_own_arg(
+                    &mut self,
+                    x: (wasmtime::component::Resource<Bar>, u32),
+                ) -> () {
+                    Host::tuple_own_arg(*self, x).await
+                }
+                async fn tuple_borrow_arg(
+                    &mut self,
+                    x: (wasmtime::component::Resource<Bar>, u32),
+                ) -> () {
+                    Host::tuple_borrow_arg(*self, x).await
+                }
+                async fn tuple_result(
+                    &mut self,
+                ) -> (wasmtime::component::Resource<Bar>, u32) {
+                    Host::tuple_result(*self).await
+                }
+                async fn option_own_arg(
+                    &mut self,
+                    x: Option<wasmtime::component::Resource<Bar>>,
+                ) -> () {
+                    Host::option_own_arg(*self, x).await
+                }
+                async fn option_borrow_arg(
+                    &mut self,
+                    x: Option<wasmtime::component::Resource<Bar>>,
+                ) -> () {
+                    Host::option_borrow_arg(*self, x).await
+                }
+                async fn option_result(
+                    &mut self,
+                ) -> Option<wasmtime::component::Resource<Bar>> {
+                    Host::option_result(*self).await
+                }
+                async fn result_own_arg(
+                    &mut self,
+                    x: Result<wasmtime::component::Resource<Bar>, ()>,
+                ) -> () {
+                    Host::result_own_arg(*self, x).await
+                }
+                async fn result_borrow_arg(
+                    &mut self,
+                    x: Result<wasmtime::component::Resource<Bar>, ()>,
+                ) -> () {
+                    Host::result_borrow_arg(*self, x).await
+                }
+                async fn result_result(
+                    &mut self,
+                ) -> Result<wasmtime::component::Resource<Bar>, ()> {
+                    Host::result_result(*self).await
+                }
+                async fn list_own_arg(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<
+                        wasmtime::component::Resource<Bar>,
+                    >,
+                ) -> () {
+                    Host::list_own_arg(*self, x).await
+                }
+                async fn list_borrow_arg(
+                    &mut self,
+                    x: wasmtime::component::__internal::Vec<
+                        wasmtime::component::Resource<Bar>,
+                    >,
+                ) -> () {
+                    Host::list_borrow_arg(*self, x).await
+                }
+                async fn list_result(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<
+                    wasmtime::component::Resource<Bar>,
+                > {
+                    Host::list_result(*self).await
+                }
+                async fn record_own_arg(&mut self, x: NestedOwn) -> () {
+                    Host::record_own_arg(*self, x).await
+                }
+                async fn record_borrow_arg(&mut self, x: NestedBorrow) -> () {
+                    Host::record_borrow_arg(*self, x).await
+                }
+                async fn record_result(&mut self) -> NestedOwn {
+                    Host::record_result(*self).await
+                }
+                async fn func_with_handle_typedef(&mut self, x: SomeHandle) -> () {
+                    Host::func_with_handle_typedef(*self, x).await
+                }
+            }
+        }
+        #[allow(clippy::all)]
+        pub mod long_use_chain1 {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub enum A {}
+            #[wasmtime::component::__internal::async_trait]
+            pub trait HostA {
+                async fn drop(
+                    &mut self,
+                    rep: wasmtime::component::Resource<A>,
+                ) -> wasmtime::Result<()>;
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: HostA + ?Sized + Send> HostA for &mut _T {
+                async fn drop(
+                    &mut self,
+                    rep: wasmtime::component::Resource<A>,
+                ) -> wasmtime::Result<()> {
+                    HostA::drop(*self, rep).await
+                }
+            }
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send + HostA {}
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/long-use-chain1")?;
+                inst.resource_async(
+                    "a",
+                    wasmtime::component::ResourceType::host::<A>(),
+                    move |mut store, rep| {
+                        std::boxed::Box::new(async move {
+                            HostA::drop(
+                                    &mut host_getter(store.data_mut()),
+                                    wasmtime::component::Resource::new_own(rep),
+                                )
+                                .await
+                        })
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {}
+        }
+        #[allow(clippy::all)]
+        pub mod long_use_chain2 {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub type A = super::super::super::foo::foo::long_use_chain1::A;
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {}
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/long-use-chain2")?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {}
+        }
+        #[allow(clippy::all)]
+        pub mod long_use_chain3 {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub type A = super::super::super::foo::foo::long_use_chain2::A;
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {}
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/long-use-chain3")?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {}
+        }
+        #[allow(clippy::all)]
+        pub mod long_use_chain4 {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub type A = super::super::super::foo::foo::long_use_chain3::A;
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {
+                async fn foo(&mut self) -> wasmtime::component::Resource<A>;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/long-use-chain4")?;
+                inst.func_wrap_async(
+                    "foo",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::foo(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {
+                async fn foo(&mut self) -> wasmtime::component::Resource<A> {
+                    Host::foo(*self).await
+                }
+            }
+        }
+        #[allow(clippy::all)]
+        pub mod transitive_interface_with_resource {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub enum Foo {}
+            #[wasmtime::component::__internal::async_trait]
+            pub trait HostFoo {
+                async fn drop(
+                    &mut self,
+                    rep: wasmtime::component::Resource<Foo>,
+                ) -> wasmtime::Result<()>;
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: HostFoo + ?Sized + Send> HostFoo for &mut _T {
+                async fn drop(
+                    &mut self,
+                    rep: wasmtime::component::Resource<Foo>,
+                ) -> wasmtime::Result<()> {
+                    HostFoo::drop(*self, rep).await
+                }
+            }
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send + HostFoo {}
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker
+                    .instance("foo:foo/transitive-interface-with-resource")?;
+                inst.resource_async(
+                    "foo",
+                    wasmtime::component::ResourceType::host::<Foo>(),
+                    move |mut store, rep| {
+                        std::boxed::Box::new(async move {
+                            HostFoo::drop(
+                                    &mut host_getter(store.data_mut()),
+                                    wasmtime::component::Resource::new_own(rep),
+                                )
+                                .await
+                        })
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {}
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod uses_resource_transitively {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub type Foo = super::super::super::super::foo::foo::transitive_interface_with_resource::Foo;
+                pub struct Guest {
+                    handle: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    handle: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/uses-resource-transitively")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/uses-resource-transitively`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(
+                                &mut store,
+                                None,
+                                "foo:foo/uses-resource-transitively",
+                            )
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/uses-resource-transitively`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/uses-resource-transitively` does \
+                        not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let handle = lookup("handle")?;
+                        Ok(GuestIndices { handle })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let handle = *_instance
+                            .get_typed_func::<
+                                (wasmtime::component::Resource<Foo>,),
+                                (),
+                            >(&mut store, &self.handle)?
+                            .func();
+                        Ok(Guest { handle })
+                    }
+                }
+                impl Guest {
+                    pub async fn call_handle<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: wasmtime::component::Resource<Foo>,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (wasmtime::component::Resource<Foo>,),
+                                (),
+                            >::new_unchecked(self.handle)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/share-types.rs b/crates/component-macro/tests/expanded/share-types.rs
new file mode 100644
index 000000000000..2e7bd33dfa35
--- /dev/null
+++ b/crates/component-macro/tests/expanded/share-types.rs
@@ -0,0 +1,429 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `http-interface`.
+///
+/// This structure is created through [`HttpInterfacePre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`HttpInterface`] as well.
+pub struct HttpInterfacePre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: HttpInterfaceIndices,
+}
+impl<T> Clone for HttpInterfacePre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> HttpInterfacePre<_T> {
+    /// Creates a new copy of `HttpInterfacePre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = HttpInterfaceIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`HttpInterface`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<HttpInterface> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `http-interface`.
+///
+/// This is an implementation detail of [`HttpInterfacePre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`HttpInterface`] as well.
+#[derive(Clone)]
+pub struct HttpInterfaceIndices {
+    interface0: exports::http_handler::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `http-interface`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`HttpInterface::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`HttpInterfacePre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`HttpInterfacePre::instantiate`] to
+///   create a [`HttpInterface`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`HttpInterface::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`HttpInterfaceIndices::new_instance`] followed
+///   by [`HttpInterfaceIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct HttpInterface {
+    interface0: exports::http_handler::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl HttpInterfaceIndices {
+        /// Creates a new copy of `HttpInterfaceIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::http_handler::GuestIndices::new(_component)?;
+            Ok(HttpInterfaceIndices { interface0 })
+        }
+        /// Creates a new instance of [`HttpInterfaceIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`HttpInterface`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`HttpInterface`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::http_handler::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(HttpInterfaceIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`HttpInterface`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<HttpInterface> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(HttpInterface { interface0 })
+        }
+    }
+    impl HttpInterface {
+        /// Convenience wrapper around [`HttpInterfacePre::new`] and
+        /// [`HttpInterfacePre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<HttpInterface> {
+            let pre = linker.instantiate_pre(component)?;
+            HttpInterfacePre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`HttpInterfaceIndices::new_instance`] and
+        /// [`HttpInterfaceIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<HttpInterface> {
+            let indices = HttpInterfaceIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            U: foo::foo::http_types::Host + http_fetch::Host,
+        {
+            foo::foo::http_types::add_to_linker(linker, get)?;
+            http_fetch::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn http_handler(&self) -> &exports::http_handler::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod http_types {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone)]
+            pub struct Request {
+                #[component(name = "method")]
+                pub method: wasmtime::component::__internal::String,
+            }
+            impl core::fmt::Debug for Request {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("Request").field("method", &self.method).finish()
+                }
+            }
+            const _: () = {
+                assert!(8 == < Request as wasmtime::component::ComponentType >::SIZE32);
+                assert!(4 == < Request as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone)]
+            pub struct Response {
+                #[component(name = "body")]
+                pub body: wasmtime::component::__internal::String,
+            }
+            impl core::fmt::Debug for Response {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("Response").field("body", &self.body).finish()
+                }
+            }
+            const _: () = {
+                assert!(8 == < Response as wasmtime::component::ComponentType >::SIZE32);
+                assert!(
+                    4 == < Response as wasmtime::component::ComponentType >::ALIGN32
+                );
+            };
+            pub trait Host {}
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/http-types")?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {}
+        }
+    }
+}
+#[allow(clippy::all)]
+pub mod http_fetch {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    pub type Request = super::foo::foo::http_types::Request;
+    const _: () = {
+        assert!(8 == < Request as wasmtime::component::ComponentType >::SIZE32);
+        assert!(4 == < Request as wasmtime::component::ComponentType >::ALIGN32);
+    };
+    pub type Response = super::foo::foo::http_types::Response;
+    const _: () = {
+        assert!(8 == < Response as wasmtime::component::ComponentType >::SIZE32);
+        assert!(4 == < Response as wasmtime::component::ComponentType >::ALIGN32);
+    };
+    pub trait Host {
+        fn fetch_request(&mut self, request: Request) -> Response;
+    }
+    pub trait GetHost<
+        T,
+    >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+        type Host: Host;
+    }
+    impl<F, T, O> GetHost<T> for F
+    where
+        F: Fn(T) -> O + Send + Sync + Copy + 'static,
+        O: Host,
+    {
+        type Host = O;
+    }
+    pub fn add_to_linker_get_host<T>(
+        linker: &mut wasmtime::component::Linker<T>,
+        host_getter: impl for<'a> GetHost<&'a mut T>,
+    ) -> wasmtime::Result<()> {
+        let mut inst = linker.instance("http-fetch")?;
+        inst.func_wrap(
+            "fetch-request",
+            move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (Request,)| {
+                let host = &mut host_getter(caller.data_mut());
+                let r = Host::fetch_request(host, arg0);
+                Ok((r,))
+            },
+        )?;
+        Ok(())
+    }
+    pub fn add_to_linker<T, U>(
+        linker: &mut wasmtime::component::Linker<T>,
+        get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+    ) -> wasmtime::Result<()>
+    where
+        U: Host,
+    {
+        add_to_linker_get_host(linker, get)
+    }
+    impl<_T: Host + ?Sized> Host for &mut _T {
+        fn fetch_request(&mut self, request: Request) -> Response {
+            Host::fetch_request(*self, request)
+        }
+    }
+}
+pub mod exports {
+    #[allow(clippy::all)]
+    pub mod http_handler {
+        #[allow(unused_imports)]
+        use wasmtime::component::__internal::anyhow;
+        pub type Request = super::super::foo::foo::http_types::Request;
+        const _: () = {
+            assert!(8 == < Request as wasmtime::component::ComponentType >::SIZE32);
+            assert!(4 == < Request as wasmtime::component::ComponentType >::ALIGN32);
+        };
+        pub type Response = super::super::foo::foo::http_types::Response;
+        const _: () = {
+            assert!(8 == < Response as wasmtime::component::ComponentType >::SIZE32);
+            assert!(4 == < Response as wasmtime::component::ComponentType >::ALIGN32);
+        };
+        pub struct Guest {
+            handle_request: wasmtime::component::Func,
+        }
+        #[derive(Clone)]
+        pub struct GuestIndices {
+            handle_request: wasmtime::component::ComponentExportIndex,
+        }
+        impl GuestIndices {
+            /// Constructor for [`GuestIndices`] which takes a
+            /// [`Component`](wasmtime::component::Component) as input and can be executed
+            /// before instantiation.
+            ///
+            /// This constructor can be used to front-load string lookups to find exports
+            /// within a component.
+            pub fn new(
+                component: &wasmtime::component::Component,
+            ) -> wasmtime::Result<GuestIndices> {
+                let (_, instance) = component
+                    .export_index(None, "http-handler")
+                    .ok_or_else(|| {
+                        anyhow::anyhow!("no exported instance named `http-handler`")
+                    })?;
+                Self::_new(|name| {
+                    component.export_index(Some(&instance), name).map(|p| p.1)
+                })
+            }
+            /// This constructor is similar to [`GuestIndices::new`] except that it
+            /// performs string lookups after instantiation time.
+            pub fn new_instance(
+                mut store: impl wasmtime::AsContextMut,
+                instance: &wasmtime::component::Instance,
+            ) -> wasmtime::Result<GuestIndices> {
+                let instance_export = instance
+                    .get_export(&mut store, None, "http-handler")
+                    .ok_or_else(|| {
+                        anyhow::anyhow!("no exported instance named `http-handler`")
+                    })?;
+                Self::_new(|name| {
+                    instance.get_export(&mut store, Some(&instance_export), name)
+                })
+            }
+            fn _new(
+                mut lookup: impl FnMut(
+                    &str,
+                ) -> Option<wasmtime::component::ComponentExportIndex>,
+            ) -> wasmtime::Result<GuestIndices> {
+                let mut lookup = move |name| {
+                    lookup(name)
+                        .ok_or_else(|| {
+                            anyhow::anyhow!(
+                                "instance export `http-handler` does \
+            not have export `{name}`"
+                            )
+                        })
+                };
+                let _ = &mut lookup;
+                let handle_request = lookup("handle-request")?;
+                Ok(GuestIndices { handle_request })
+            }
+            pub fn load(
+                &self,
+                mut store: impl wasmtime::AsContextMut,
+                instance: &wasmtime::component::Instance,
+            ) -> wasmtime::Result<Guest> {
+                let mut store = store.as_context_mut();
+                let _ = &mut store;
+                let _instance = instance;
+                let handle_request = *_instance
+                    .get_typed_func::<
+                        (&Request,),
+                        (Response,),
+                    >(&mut store, &self.handle_request)?
+                    .func();
+                Ok(Guest { handle_request })
+            }
+        }
+        impl Guest {
+            pub fn call_handle_request<S: wasmtime::AsContextMut>(
+                &self,
+                mut store: S,
+                arg0: &Request,
+            ) -> wasmtime::Result<Response> {
+                let callee = unsafe {
+                    wasmtime::component::TypedFunc::<
+                        (&Request,),
+                        (Response,),
+                    >::new_unchecked(self.handle_request)
+                };
+                let (ret0,) = callee.call(store.as_context_mut(), (arg0,))?;
+                callee.post_return(store.as_context_mut())?;
+                Ok(ret0)
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/share-types_async.rs b/crates/component-macro/tests/expanded/share-types_async.rs
new file mode 100644
index 000000000000..09461c453bc2
--- /dev/null
+++ b/crates/component-macro/tests/expanded/share-types_async.rs
@@ -0,0 +1,451 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `http-interface`.
+///
+/// This structure is created through [`HttpInterfacePre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`HttpInterface`] as well.
+pub struct HttpInterfacePre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: HttpInterfaceIndices,
+}
+impl<T> Clone for HttpInterfacePre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> HttpInterfacePre<_T> {
+    /// Creates a new copy of `HttpInterfacePre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = HttpInterfaceIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`HttpInterface`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<HttpInterface>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `http-interface`.
+///
+/// This is an implementation detail of [`HttpInterfacePre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`HttpInterface`] as well.
+#[derive(Clone)]
+pub struct HttpInterfaceIndices {
+    interface0: exports::http_handler::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `http-interface`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`HttpInterface::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`HttpInterfacePre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`HttpInterfacePre::instantiate_async`] to
+///   create a [`HttpInterface`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`HttpInterface::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`HttpInterfaceIndices::new_instance`] followed
+///   by [`HttpInterfaceIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct HttpInterface {
+    interface0: exports::http_handler::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl HttpInterfaceIndices {
+        /// Creates a new copy of `HttpInterfaceIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::http_handler::GuestIndices::new(_component)?;
+            Ok(HttpInterfaceIndices { interface0 })
+        }
+        /// Creates a new instance of [`HttpInterfaceIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`HttpInterface`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`HttpInterface`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::http_handler::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(HttpInterfaceIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`HttpInterface`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<HttpInterface> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(HttpInterface { interface0 })
+        }
+    }
+    impl HttpInterface {
+        /// Convenience wrapper around [`HttpInterfacePre::new`] and
+        /// [`HttpInterfacePre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<HttpInterface>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            HttpInterfacePre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`HttpInterfaceIndices::new_instance`] and
+        /// [`HttpInterfaceIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<HttpInterface> {
+            let indices = HttpInterfaceIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+            U: foo::foo::http_types::Host + http_fetch::Host + Send,
+        {
+            foo::foo::http_types::add_to_linker(linker, get)?;
+            http_fetch::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn http_handler(&self) -> &exports::http_handler::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod http_types {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone)]
+            pub struct Request {
+                #[component(name = "method")]
+                pub method: wasmtime::component::__internal::String,
+            }
+            impl core::fmt::Debug for Request {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("Request").field("method", &self.method).finish()
+                }
+            }
+            const _: () = {
+                assert!(8 == < Request as wasmtime::component::ComponentType >::SIZE32);
+                assert!(4 == < Request as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone)]
+            pub struct Response {
+                #[component(name = "body")]
+                pub body: wasmtime::component::__internal::String,
+            }
+            impl core::fmt::Debug for Response {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("Response").field("body", &self.body).finish()
+                }
+            }
+            const _: () = {
+                assert!(8 == < Response as wasmtime::component::ComponentType >::SIZE32);
+                assert!(
+                    4 == < Response as wasmtime::component::ComponentType >::ALIGN32
+                );
+            };
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {}
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/http-types")?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {}
+        }
+    }
+}
+#[allow(clippy::all)]
+pub mod http_fetch {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    pub type Request = super::foo::foo::http_types::Request;
+    const _: () = {
+        assert!(8 == < Request as wasmtime::component::ComponentType >::SIZE32);
+        assert!(4 == < Request as wasmtime::component::ComponentType >::ALIGN32);
+    };
+    pub type Response = super::foo::foo::http_types::Response;
+    const _: () = {
+        assert!(8 == < Response as wasmtime::component::ComponentType >::SIZE32);
+        assert!(4 == < Response as wasmtime::component::ComponentType >::ALIGN32);
+    };
+    #[wasmtime::component::__internal::async_trait]
+    pub trait Host: Send {
+        async fn fetch_request(&mut self, request: Request) -> Response;
+    }
+    pub trait GetHost<
+        T,
+    >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+        type Host: Host + Send;
+    }
+    impl<F, T, O> GetHost<T> for F
+    where
+        F: Fn(T) -> O + Send + Sync + Copy + 'static,
+        O: Host + Send,
+    {
+        type Host = O;
+    }
+    pub fn add_to_linker_get_host<T>(
+        linker: &mut wasmtime::component::Linker<T>,
+        host_getter: impl for<'a> GetHost<&'a mut T>,
+    ) -> wasmtime::Result<()>
+    where
+        T: Send,
+    {
+        let mut inst = linker.instance("http-fetch")?;
+        inst.func_wrap_async(
+            "fetch-request",
+            move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (Request,)| wasmtime::component::__internal::Box::new(async move {
+                let host = &mut host_getter(caller.data_mut());
+                let r = Host::fetch_request(host, arg0).await;
+                Ok((r,))
+            }),
+        )?;
+        Ok(())
+    }
+    pub fn add_to_linker<T, U>(
+        linker: &mut wasmtime::component::Linker<T>,
+        get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+    ) -> wasmtime::Result<()>
+    where
+        U: Host + Send,
+        T: Send,
+    {
+        add_to_linker_get_host(linker, get)
+    }
+    #[wasmtime::component::__internal::async_trait]
+    impl<_T: Host + ?Sized + Send> Host for &mut _T {
+        async fn fetch_request(&mut self, request: Request) -> Response {
+            Host::fetch_request(*self, request).await
+        }
+    }
+}
+pub mod exports {
+    #[allow(clippy::all)]
+    pub mod http_handler {
+        #[allow(unused_imports)]
+        use wasmtime::component::__internal::anyhow;
+        pub type Request = super::super::foo::foo::http_types::Request;
+        const _: () = {
+            assert!(8 == < Request as wasmtime::component::ComponentType >::SIZE32);
+            assert!(4 == < Request as wasmtime::component::ComponentType >::ALIGN32);
+        };
+        pub type Response = super::super::foo::foo::http_types::Response;
+        const _: () = {
+            assert!(8 == < Response as wasmtime::component::ComponentType >::SIZE32);
+            assert!(4 == < Response as wasmtime::component::ComponentType >::ALIGN32);
+        };
+        pub struct Guest {
+            handle_request: wasmtime::component::Func,
+        }
+        #[derive(Clone)]
+        pub struct GuestIndices {
+            handle_request: wasmtime::component::ComponentExportIndex,
+        }
+        impl GuestIndices {
+            /// Constructor for [`GuestIndices`] which takes a
+            /// [`Component`](wasmtime::component::Component) as input and can be executed
+            /// before instantiation.
+            ///
+            /// This constructor can be used to front-load string lookups to find exports
+            /// within a component.
+            pub fn new(
+                component: &wasmtime::component::Component,
+            ) -> wasmtime::Result<GuestIndices> {
+                let (_, instance) = component
+                    .export_index(None, "http-handler")
+                    .ok_or_else(|| {
+                        anyhow::anyhow!("no exported instance named `http-handler`")
+                    })?;
+                Self::_new(|name| {
+                    component.export_index(Some(&instance), name).map(|p| p.1)
+                })
+            }
+            /// This constructor is similar to [`GuestIndices::new`] except that it
+            /// performs string lookups after instantiation time.
+            pub fn new_instance(
+                mut store: impl wasmtime::AsContextMut,
+                instance: &wasmtime::component::Instance,
+            ) -> wasmtime::Result<GuestIndices> {
+                let instance_export = instance
+                    .get_export(&mut store, None, "http-handler")
+                    .ok_or_else(|| {
+                        anyhow::anyhow!("no exported instance named `http-handler`")
+                    })?;
+                Self::_new(|name| {
+                    instance.get_export(&mut store, Some(&instance_export), name)
+                })
+            }
+            fn _new(
+                mut lookup: impl FnMut(
+                    &str,
+                ) -> Option<wasmtime::component::ComponentExportIndex>,
+            ) -> wasmtime::Result<GuestIndices> {
+                let mut lookup = move |name| {
+                    lookup(name)
+                        .ok_or_else(|| {
+                            anyhow::anyhow!(
+                                "instance export `http-handler` does \
+            not have export `{name}`"
+                            )
+                        })
+                };
+                let _ = &mut lookup;
+                let handle_request = lookup("handle-request")?;
+                Ok(GuestIndices { handle_request })
+            }
+            pub fn load(
+                &self,
+                mut store: impl wasmtime::AsContextMut,
+                instance: &wasmtime::component::Instance,
+            ) -> wasmtime::Result<Guest> {
+                let mut store = store.as_context_mut();
+                let _ = &mut store;
+                let _instance = instance;
+                let handle_request = *_instance
+                    .get_typed_func::<
+                        (&Request,),
+                        (Response,),
+                    >(&mut store, &self.handle_request)?
+                    .func();
+                Ok(Guest { handle_request })
+            }
+        }
+        impl Guest {
+            pub async fn call_handle_request<S: wasmtime::AsContextMut>(
+                &self,
+                mut store: S,
+                arg0: &Request,
+            ) -> wasmtime::Result<Response>
+            where
+                <S as wasmtime::AsContext>::Data: Send,
+            {
+                let callee = unsafe {
+                    wasmtime::component::TypedFunc::<
+                        (&Request,),
+                        (Response,),
+                    >::new_unchecked(self.handle_request)
+                };
+                let (ret0,) = callee.call_async(store.as_context_mut(), (arg0,)).await?;
+                callee.post_return_async(store.as_context_mut()).await?;
+                Ok(ret0)
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/simple-functions.rs b/crates/component-macro/tests/expanded/simple-functions.rs
new file mode 100644
index 000000000000..16274afb8f98
--- /dev/null
+++ b/crates/component-macro/tests/expanded/simple-functions.rs
@@ -0,0 +1,522 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-world`.
+///
+/// This structure is created through [`TheWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheWorld`] as well.
+pub struct TheWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheWorldIndices,
+}
+impl<T> Clone for TheWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheWorldPre<_T> {
+    /// Creates a new copy of `TheWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheWorld> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-world`.
+///
+/// This is an implementation detail of [`TheWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheWorld`] as well.
+#[derive(Clone)]
+pub struct TheWorldIndices {
+    interface0: exports::foo::foo::simple::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheWorld::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheWorldPre::instantiate`] to
+///   create a [`TheWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheWorldIndices::new_instance`] followed
+///   by [`TheWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheWorld {
+    interface0: exports::foo::foo::simple::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheWorldIndices {
+        /// Creates a new copy of `TheWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::simple::GuestIndices::new(_component)?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Creates a new instance of [`TheWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::simple::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(TheWorld { interface0 })
+        }
+    }
+    impl TheWorld {
+        /// Convenience wrapper around [`TheWorldPre::new`] and
+        /// [`TheWorldPre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheWorld> {
+            let pre = linker.instantiate_pre(component)?;
+            TheWorldPre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`TheWorldIndices::new_instance`] and
+        /// [`TheWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let indices = TheWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            U: foo::foo::simple::Host,
+        {
+            foo::foo::simple::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_simple(&self) -> &exports::foo::foo::simple::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod simple {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub trait Host {
+                fn f1(&mut self) -> ();
+                fn f2(&mut self, a: u32) -> ();
+                fn f3(&mut self, a: u32, b: u32) -> ();
+                fn f4(&mut self) -> u32;
+                fn f5(&mut self) -> (u32, u32);
+                fn f6(&mut self, a: u32, b: u32, c: u32) -> (u32, u32, u32);
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/simple")?;
+                inst.func_wrap(
+                    "f1",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::f1(host);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "f2",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (u32,)| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::f2(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "f3",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0, arg1): (u32, u32)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::f3(host, arg0, arg1);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "f4",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::f4(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "f5",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::f5(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "f6",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0, arg1, arg2): (u32, u32, u32)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::f6(host, arg0, arg1, arg2);
+                        Ok((r,))
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {
+                fn f1(&mut self) -> () {
+                    Host::f1(*self)
+                }
+                fn f2(&mut self, a: u32) -> () {
+                    Host::f2(*self, a)
+                }
+                fn f3(&mut self, a: u32, b: u32) -> () {
+                    Host::f3(*self, a, b)
+                }
+                fn f4(&mut self) -> u32 {
+                    Host::f4(*self)
+                }
+                fn f5(&mut self) -> (u32, u32) {
+                    Host::f5(*self)
+                }
+                fn f6(&mut self, a: u32, b: u32, c: u32) -> (u32, u32, u32) {
+                    Host::f6(*self, a, b, c)
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod simple {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub struct Guest {
+                    f1: wasmtime::component::Func,
+                    f2: wasmtime::component::Func,
+                    f3: wasmtime::component::Func,
+                    f4: wasmtime::component::Func,
+                    f5: wasmtime::component::Func,
+                    f6: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    f1: wasmtime::component::ComponentExportIndex,
+                    f2: wasmtime::component::ComponentExportIndex,
+                    f3: wasmtime::component::ComponentExportIndex,
+                    f4: wasmtime::component::ComponentExportIndex,
+                    f5: wasmtime::component::ComponentExportIndex,
+                    f6: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/simple")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/simple`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/simple")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/simple`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/simple` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let f1 = lookup("f1")?;
+                        let f2 = lookup("f2")?;
+                        let f3 = lookup("f3")?;
+                        let f4 = lookup("f4")?;
+                        let f5 = lookup("f5")?;
+                        let f6 = lookup("f6")?;
+                        Ok(GuestIndices {
+                            f1,
+                            f2,
+                            f3,
+                            f4,
+                            f5,
+                            f6,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let f1 = *_instance
+                            .get_typed_func::<(), ()>(&mut store, &self.f1)?
+                            .func();
+                        let f2 = *_instance
+                            .get_typed_func::<(u32,), ()>(&mut store, &self.f2)?
+                            .func();
+                        let f3 = *_instance
+                            .get_typed_func::<(u32, u32), ()>(&mut store, &self.f3)?
+                            .func();
+                        let f4 = *_instance
+                            .get_typed_func::<(), (u32,)>(&mut store, &self.f4)?
+                            .func();
+                        let f5 = *_instance
+                            .get_typed_func::<(), ((u32, u32),)>(&mut store, &self.f5)?
+                            .func();
+                        let f6 = *_instance
+                            .get_typed_func::<
+                                (u32, u32, u32),
+                                ((u32, u32, u32),),
+                            >(&mut store, &self.f6)?
+                            .func();
+                        Ok(Guest { f1, f2, f3, f4, f5, f6 })
+                    }
+                }
+                impl Guest {
+                    pub fn call_f1<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.f1)
+                        };
+                        let () = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_f2<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: u32,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (u32,),
+                                (),
+                            >::new_unchecked(self.f2)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_f3<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: u32,
+                        arg1: u32,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (u32, u32),
+                                (),
+                            >::new_unchecked(self.f3)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0, arg1))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_f4<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<u32> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (u32,),
+                            >::new_unchecked(self.f4)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_f5<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<(u32, u32)> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                ((u32, u32),),
+                            >::new_unchecked(self.f5)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_f6<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: u32,
+                        arg1: u32,
+                        arg2: u32,
+                    ) -> wasmtime::Result<(u32, u32, u32)> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (u32, u32, u32),
+                                ((u32, u32, u32),),
+                            >::new_unchecked(self.f6)
+                        };
+                        let (ret0,) = callee
+                            .call(store.as_context_mut(), (arg0, arg1, arg2))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/simple-functions_async.rs b/crates/component-macro/tests/expanded/simple-functions_async.rs
new file mode 100644
index 000000000000..5d3da65402a9
--- /dev/null
+++ b/crates/component-macro/tests/expanded/simple-functions_async.rs
@@ -0,0 +1,562 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-world`.
+///
+/// This structure is created through [`TheWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheWorld`] as well.
+pub struct TheWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheWorldIndices,
+}
+impl<T> Clone for TheWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheWorldPre<_T> {
+    /// Creates a new copy of `TheWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheWorld>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-world`.
+///
+/// This is an implementation detail of [`TheWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheWorld`] as well.
+#[derive(Clone)]
+pub struct TheWorldIndices {
+    interface0: exports::foo::foo::simple::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheWorld::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheWorldPre::instantiate_async`] to
+///   create a [`TheWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheWorldIndices::new_instance`] followed
+///   by [`TheWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheWorld {
+    interface0: exports::foo::foo::simple::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheWorldIndices {
+        /// Creates a new copy of `TheWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::simple::GuestIndices::new(_component)?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Creates a new instance of [`TheWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::simple::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(TheWorld { interface0 })
+        }
+    }
+    impl TheWorld {
+        /// Convenience wrapper around [`TheWorldPre::new`] and
+        /// [`TheWorldPre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheWorld>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            TheWorldPre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`TheWorldIndices::new_instance`] and
+        /// [`TheWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let indices = TheWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+            U: foo::foo::simple::Host + Send,
+        {
+            foo::foo::simple::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_simple(&self) -> &exports::foo::foo::simple::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod simple {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {
+                async fn f1(&mut self) -> ();
+                async fn f2(&mut self, a: u32) -> ();
+                async fn f3(&mut self, a: u32, b: u32) -> ();
+                async fn f4(&mut self) -> u32;
+                async fn f5(&mut self) -> (u32, u32);
+                async fn f6(&mut self, a: u32, b: u32, c: u32) -> (u32, u32, u32);
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/simple")?;
+                inst.func_wrap_async(
+                    "f1",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::f1(host).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "f2",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (u32,)| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::f2(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "f3",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0, arg1): (u32, u32)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::f3(host, arg0, arg1).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "f4",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::f4(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "f5",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::f5(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "f6",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0, arg1, arg2): (u32, u32, u32)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::f6(host, arg0, arg1, arg2).await;
+                        Ok((r,))
+                    }),
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {
+                async fn f1(&mut self) -> () {
+                    Host::f1(*self).await
+                }
+                async fn f2(&mut self, a: u32) -> () {
+                    Host::f2(*self, a).await
+                }
+                async fn f3(&mut self, a: u32, b: u32) -> () {
+                    Host::f3(*self, a, b).await
+                }
+                async fn f4(&mut self) -> u32 {
+                    Host::f4(*self).await
+                }
+                async fn f5(&mut self) -> (u32, u32) {
+                    Host::f5(*self).await
+                }
+                async fn f6(&mut self, a: u32, b: u32, c: u32) -> (u32, u32, u32) {
+                    Host::f6(*self, a, b, c).await
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod simple {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub struct Guest {
+                    f1: wasmtime::component::Func,
+                    f2: wasmtime::component::Func,
+                    f3: wasmtime::component::Func,
+                    f4: wasmtime::component::Func,
+                    f5: wasmtime::component::Func,
+                    f6: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    f1: wasmtime::component::ComponentExportIndex,
+                    f2: wasmtime::component::ComponentExportIndex,
+                    f3: wasmtime::component::ComponentExportIndex,
+                    f4: wasmtime::component::ComponentExportIndex,
+                    f5: wasmtime::component::ComponentExportIndex,
+                    f6: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/simple")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/simple`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/simple")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/simple`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/simple` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let f1 = lookup("f1")?;
+                        let f2 = lookup("f2")?;
+                        let f3 = lookup("f3")?;
+                        let f4 = lookup("f4")?;
+                        let f5 = lookup("f5")?;
+                        let f6 = lookup("f6")?;
+                        Ok(GuestIndices {
+                            f1,
+                            f2,
+                            f3,
+                            f4,
+                            f5,
+                            f6,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let f1 = *_instance
+                            .get_typed_func::<(), ()>(&mut store, &self.f1)?
+                            .func();
+                        let f2 = *_instance
+                            .get_typed_func::<(u32,), ()>(&mut store, &self.f2)?
+                            .func();
+                        let f3 = *_instance
+                            .get_typed_func::<(u32, u32), ()>(&mut store, &self.f3)?
+                            .func();
+                        let f4 = *_instance
+                            .get_typed_func::<(), (u32,)>(&mut store, &self.f4)?
+                            .func();
+                        let f5 = *_instance
+                            .get_typed_func::<(), ((u32, u32),)>(&mut store, &self.f5)?
+                            .func();
+                        let f6 = *_instance
+                            .get_typed_func::<
+                                (u32, u32, u32),
+                                ((u32, u32, u32),),
+                            >(&mut store, &self.f6)?
+                            .func();
+                        Ok(Guest { f1, f2, f3, f4, f5, f6 })
+                    }
+                }
+                impl Guest {
+                    pub async fn call_f1<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (),
+                            >::new_unchecked(self.f1)
+                        };
+                        let () = callee.call_async(store.as_context_mut(), ()).await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_f2<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: u32,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (u32,),
+                                (),
+                            >::new_unchecked(self.f2)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_f3<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: u32,
+                        arg1: u32,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (u32, u32),
+                                (),
+                            >::new_unchecked(self.f3)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0, arg1))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_f4<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<u32>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (u32,),
+                            >::new_unchecked(self.f4)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_f5<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<(u32, u32)>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                ((u32, u32),),
+                            >::new_unchecked(self.f5)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_f6<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: u32,
+                        arg1: u32,
+                        arg2: u32,
+                    ) -> wasmtime::Result<(u32, u32, u32)>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (u32, u32, u32),
+                                ((u32, u32, u32),),
+                            >::new_unchecked(self.f6)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), (arg0, arg1, arg2))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/simple-lists.rs b/crates/component-macro/tests/expanded/simple-lists.rs
new file mode 100644
index 000000000000..0215d464ac38
--- /dev/null
+++ b/crates/component-macro/tests/expanded/simple-lists.rs
@@ -0,0 +1,545 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `my-world`.
+///
+/// This structure is created through [`MyWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`MyWorld`] as well.
+pub struct MyWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: MyWorldIndices,
+}
+impl<T> Clone for MyWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> MyWorldPre<_T> {
+    /// Creates a new copy of `MyWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = MyWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`MyWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<MyWorld> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `my-world`.
+///
+/// This is an implementation detail of [`MyWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`MyWorld`] as well.
+#[derive(Clone)]
+pub struct MyWorldIndices {
+    interface0: exports::foo::foo::simple_lists::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `my-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`MyWorld::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`MyWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`MyWorldPre::instantiate`] to
+///   create a [`MyWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`MyWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`MyWorldIndices::new_instance`] followed
+///   by [`MyWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct MyWorld {
+    interface0: exports::foo::foo::simple_lists::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl MyWorldIndices {
+        /// Creates a new copy of `MyWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::simple_lists::GuestIndices::new(
+                _component,
+            )?;
+            Ok(MyWorldIndices { interface0 })
+        }
+        /// Creates a new instance of [`MyWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`MyWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`MyWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::simple_lists::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(MyWorldIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`MyWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<MyWorld> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(MyWorld { interface0 })
+        }
+    }
+    impl MyWorld {
+        /// Convenience wrapper around [`MyWorldPre::new`] and
+        /// [`MyWorldPre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<MyWorld> {
+            let pre = linker.instantiate_pre(component)?;
+            MyWorldPre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`MyWorldIndices::new_instance`] and
+        /// [`MyWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<MyWorld> {
+            let indices = MyWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            U: foo::foo::simple_lists::Host,
+        {
+            foo::foo::simple_lists::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_simple_lists(&self) -> &exports::foo::foo::simple_lists::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod simple_lists {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub trait Host {
+                fn simple_list1(
+                    &mut self,
+                    l: wasmtime::component::__internal::Vec<u32>,
+                ) -> ();
+                fn simple_list2(&mut self) -> wasmtime::component::__internal::Vec<u32>;
+                fn simple_list3(
+                    &mut self,
+                    a: wasmtime::component::__internal::Vec<u32>,
+                    b: wasmtime::component::__internal::Vec<u32>,
+                ) -> (
+                    wasmtime::component::__internal::Vec<u32>,
+                    wasmtime::component::__internal::Vec<u32>,
+                );
+                fn simple_list4(
+                    &mut self,
+                    l: wasmtime::component::__internal::Vec<
+                        wasmtime::component::__internal::Vec<u32>,
+                    >,
+                ) -> wasmtime::component::__internal::Vec<
+                    wasmtime::component::__internal::Vec<u32>,
+                >;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/simple-lists")?;
+                inst.func_wrap(
+                    "simple-list1",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<u32>,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::simple_list1(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "simple-list2",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::simple_list2(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "simple-list3",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (
+                            arg0,
+                            arg1,
+                        ): (
+                            wasmtime::component::__internal::Vec<u32>,
+                            wasmtime::component::__internal::Vec<u32>,
+                        )|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::simple_list3(host, arg0, arg1);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "simple-list4",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (
+                            arg0,
+                        ): (
+                            wasmtime::component::__internal::Vec<
+                                wasmtime::component::__internal::Vec<u32>,
+                            >,
+                        )|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::simple_list4(host, arg0);
+                        Ok((r,))
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {
+                fn simple_list1(
+                    &mut self,
+                    l: wasmtime::component::__internal::Vec<u32>,
+                ) -> () {
+                    Host::simple_list1(*self, l)
+                }
+                fn simple_list2(&mut self) -> wasmtime::component::__internal::Vec<u32> {
+                    Host::simple_list2(*self)
+                }
+                fn simple_list3(
+                    &mut self,
+                    a: wasmtime::component::__internal::Vec<u32>,
+                    b: wasmtime::component::__internal::Vec<u32>,
+                ) -> (
+                    wasmtime::component::__internal::Vec<u32>,
+                    wasmtime::component::__internal::Vec<u32>,
+                ) {
+                    Host::simple_list3(*self, a, b)
+                }
+                fn simple_list4(
+                    &mut self,
+                    l: wasmtime::component::__internal::Vec<
+                        wasmtime::component::__internal::Vec<u32>,
+                    >,
+                ) -> wasmtime::component::__internal::Vec<
+                    wasmtime::component::__internal::Vec<u32>,
+                > {
+                    Host::simple_list4(*self, l)
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod simple_lists {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub struct Guest {
+                    simple_list1: wasmtime::component::Func,
+                    simple_list2: wasmtime::component::Func,
+                    simple_list3: wasmtime::component::Func,
+                    simple_list4: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    simple_list1: wasmtime::component::ComponentExportIndex,
+                    simple_list2: wasmtime::component::ComponentExportIndex,
+                    simple_list3: wasmtime::component::ComponentExportIndex,
+                    simple_list4: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/simple-lists")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/simple-lists`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/simple-lists")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/simple-lists`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/simple-lists` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let simple_list1 = lookup("simple-list1")?;
+                        let simple_list2 = lookup("simple-list2")?;
+                        let simple_list3 = lookup("simple-list3")?;
+                        let simple_list4 = lookup("simple-list4")?;
+                        Ok(GuestIndices {
+                            simple_list1,
+                            simple_list2,
+                            simple_list3,
+                            simple_list4,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let simple_list1 = *_instance
+                            .get_typed_func::<
+                                (&[u32],),
+                                (),
+                            >(&mut store, &self.simple_list1)?
+                            .func();
+                        let simple_list2 = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::__internal::Vec<u32>,),
+                            >(&mut store, &self.simple_list2)?
+                            .func();
+                        let simple_list3 = *_instance
+                            .get_typed_func::<
+                                (&[u32], &[u32]),
+                                (
+                                    (
+                                        wasmtime::component::__internal::Vec<u32>,
+                                        wasmtime::component::__internal::Vec<u32>,
+                                    ),
+                                ),
+                            >(&mut store, &self.simple_list3)?
+                            .func();
+                        let simple_list4 = *_instance
+                            .get_typed_func::<
+                                (&[wasmtime::component::__internal::Vec<u32>],),
+                                (
+                                    wasmtime::component::__internal::Vec<
+                                        wasmtime::component::__internal::Vec<u32>,
+                                    >,
+                                ),
+                            >(&mut store, &self.simple_list4)?
+                            .func();
+                        Ok(Guest {
+                            simple_list1,
+                            simple_list2,
+                            simple_list3,
+                            simple_list4,
+                        })
+                    }
+                }
+                impl Guest {
+                    pub fn call_simple_list1<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[u32],
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[u32],),
+                                (),
+                            >::new_unchecked(self.simple_list1)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_simple_list2<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::__internal::Vec<u32>> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::__internal::Vec<u32>,),
+                            >::new_unchecked(self.simple_list2)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_simple_list3<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[u32],
+                        arg1: &[u32],
+                    ) -> wasmtime::Result<
+                        (
+                            wasmtime::component::__internal::Vec<u32>,
+                            wasmtime::component::__internal::Vec<u32>,
+                        ),
+                    > {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[u32], &[u32]),
+                                (
+                                    (
+                                        wasmtime::component::__internal::Vec<u32>,
+                                        wasmtime::component::__internal::Vec<u32>,
+                                    ),
+                                ),
+                            >::new_unchecked(self.simple_list3)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), (arg0, arg1))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_simple_list4<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[wasmtime::component::__internal::Vec<u32>],
+                    ) -> wasmtime::Result<
+                        wasmtime::component::__internal::Vec<
+                            wasmtime::component::__internal::Vec<u32>,
+                        >,
+                    > {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[wasmtime::component::__internal::Vec<u32>],),
+                                (
+                                    wasmtime::component::__internal::Vec<
+                                        wasmtime::component::__internal::Vec<u32>,
+                                    >,
+                                ),
+                            >::new_unchecked(self.simple_list4)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/simple-lists_async.rs b/crates/component-macro/tests/expanded/simple-lists_async.rs
new file mode 100644
index 000000000000..ad713fdbd19f
--- /dev/null
+++ b/crates/component-macro/tests/expanded/simple-lists_async.rs
@@ -0,0 +1,582 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `my-world`.
+///
+/// This structure is created through [`MyWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`MyWorld`] as well.
+pub struct MyWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: MyWorldIndices,
+}
+impl<T> Clone for MyWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> MyWorldPre<_T> {
+    /// Creates a new copy of `MyWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = MyWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`MyWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<MyWorld>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `my-world`.
+///
+/// This is an implementation detail of [`MyWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`MyWorld`] as well.
+#[derive(Clone)]
+pub struct MyWorldIndices {
+    interface0: exports::foo::foo::simple_lists::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `my-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`MyWorld::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`MyWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`MyWorldPre::instantiate_async`] to
+///   create a [`MyWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`MyWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`MyWorldIndices::new_instance`] followed
+///   by [`MyWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct MyWorld {
+    interface0: exports::foo::foo::simple_lists::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl MyWorldIndices {
+        /// Creates a new copy of `MyWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::simple_lists::GuestIndices::new(
+                _component,
+            )?;
+            Ok(MyWorldIndices { interface0 })
+        }
+        /// Creates a new instance of [`MyWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`MyWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`MyWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::simple_lists::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(MyWorldIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`MyWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<MyWorld> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(MyWorld { interface0 })
+        }
+    }
+    impl MyWorld {
+        /// Convenience wrapper around [`MyWorldPre::new`] and
+        /// [`MyWorldPre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<MyWorld>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            MyWorldPre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`MyWorldIndices::new_instance`] and
+        /// [`MyWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<MyWorld> {
+            let indices = MyWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+            U: foo::foo::simple_lists::Host + Send,
+        {
+            foo::foo::simple_lists::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_simple_lists(&self) -> &exports::foo::foo::simple_lists::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod simple_lists {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {
+                async fn simple_list1(
+                    &mut self,
+                    l: wasmtime::component::__internal::Vec<u32>,
+                ) -> ();
+                async fn simple_list2(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<u32>;
+                async fn simple_list3(
+                    &mut self,
+                    a: wasmtime::component::__internal::Vec<u32>,
+                    b: wasmtime::component::__internal::Vec<u32>,
+                ) -> (
+                    wasmtime::component::__internal::Vec<u32>,
+                    wasmtime::component::__internal::Vec<u32>,
+                );
+                async fn simple_list4(
+                    &mut self,
+                    l: wasmtime::component::__internal::Vec<
+                        wasmtime::component::__internal::Vec<u32>,
+                    >,
+                ) -> wasmtime::component::__internal::Vec<
+                    wasmtime::component::__internal::Vec<u32>,
+                >;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/simple-lists")?;
+                inst.func_wrap_async(
+                    "simple-list1",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::Vec<u32>,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::simple_list1(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "simple-list2",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::simple_list2(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "simple-list3",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (
+                            arg0,
+                            arg1,
+                        ): (
+                            wasmtime::component::__internal::Vec<u32>,
+                            wasmtime::component::__internal::Vec<u32>,
+                        )|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::simple_list3(host, arg0, arg1).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "simple-list4",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (
+                            arg0,
+                        ): (
+                            wasmtime::component::__internal::Vec<
+                                wasmtime::component::__internal::Vec<u32>,
+                            >,
+                        )|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::simple_list4(host, arg0).await;
+                        Ok((r,))
+                    }),
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {
+                async fn simple_list1(
+                    &mut self,
+                    l: wasmtime::component::__internal::Vec<u32>,
+                ) -> () {
+                    Host::simple_list1(*self, l).await
+                }
+                async fn simple_list2(
+                    &mut self,
+                ) -> wasmtime::component::__internal::Vec<u32> {
+                    Host::simple_list2(*self).await
+                }
+                async fn simple_list3(
+                    &mut self,
+                    a: wasmtime::component::__internal::Vec<u32>,
+                    b: wasmtime::component::__internal::Vec<u32>,
+                ) -> (
+                    wasmtime::component::__internal::Vec<u32>,
+                    wasmtime::component::__internal::Vec<u32>,
+                ) {
+                    Host::simple_list3(*self, a, b).await
+                }
+                async fn simple_list4(
+                    &mut self,
+                    l: wasmtime::component::__internal::Vec<
+                        wasmtime::component::__internal::Vec<u32>,
+                    >,
+                ) -> wasmtime::component::__internal::Vec<
+                    wasmtime::component::__internal::Vec<u32>,
+                > {
+                    Host::simple_list4(*self, l).await
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod simple_lists {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub struct Guest {
+                    simple_list1: wasmtime::component::Func,
+                    simple_list2: wasmtime::component::Func,
+                    simple_list3: wasmtime::component::Func,
+                    simple_list4: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    simple_list1: wasmtime::component::ComponentExportIndex,
+                    simple_list2: wasmtime::component::ComponentExportIndex,
+                    simple_list3: wasmtime::component::ComponentExportIndex,
+                    simple_list4: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/simple-lists")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/simple-lists`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/simple-lists")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/simple-lists`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/simple-lists` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let simple_list1 = lookup("simple-list1")?;
+                        let simple_list2 = lookup("simple-list2")?;
+                        let simple_list3 = lookup("simple-list3")?;
+                        let simple_list4 = lookup("simple-list4")?;
+                        Ok(GuestIndices {
+                            simple_list1,
+                            simple_list2,
+                            simple_list3,
+                            simple_list4,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let simple_list1 = *_instance
+                            .get_typed_func::<
+                                (&[u32],),
+                                (),
+                            >(&mut store, &self.simple_list1)?
+                            .func();
+                        let simple_list2 = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::__internal::Vec<u32>,),
+                            >(&mut store, &self.simple_list2)?
+                            .func();
+                        let simple_list3 = *_instance
+                            .get_typed_func::<
+                                (&[u32], &[u32]),
+                                (
+                                    (
+                                        wasmtime::component::__internal::Vec<u32>,
+                                        wasmtime::component::__internal::Vec<u32>,
+                                    ),
+                                ),
+                            >(&mut store, &self.simple_list3)?
+                            .func();
+                        let simple_list4 = *_instance
+                            .get_typed_func::<
+                                (&[wasmtime::component::__internal::Vec<u32>],),
+                                (
+                                    wasmtime::component::__internal::Vec<
+                                        wasmtime::component::__internal::Vec<u32>,
+                                    >,
+                                ),
+                            >(&mut store, &self.simple_list4)?
+                            .func();
+                        Ok(Guest {
+                            simple_list1,
+                            simple_list2,
+                            simple_list3,
+                            simple_list4,
+                        })
+                    }
+                }
+                impl Guest {
+                    pub async fn call_simple_list1<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[u32],
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[u32],),
+                                (),
+                            >::new_unchecked(self.simple_list1)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_simple_list2<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::__internal::Vec<u32>>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::__internal::Vec<u32>,),
+                            >::new_unchecked(self.simple_list2)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_simple_list3<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[u32],
+                        arg1: &[u32],
+                    ) -> wasmtime::Result<
+                        (
+                            wasmtime::component::__internal::Vec<u32>,
+                            wasmtime::component::__internal::Vec<u32>,
+                        ),
+                    >
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[u32], &[u32]),
+                                (
+                                    (
+                                        wasmtime::component::__internal::Vec<u32>,
+                                        wasmtime::component::__internal::Vec<u32>,
+                                    ),
+                                ),
+                            >::new_unchecked(self.simple_list3)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), (arg0, arg1))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_simple_list4<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &[wasmtime::component::__internal::Vec<u32>],
+                    ) -> wasmtime::Result<
+                        wasmtime::component::__internal::Vec<
+                            wasmtime::component::__internal::Vec<u32>,
+                        >,
+                    >
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&[wasmtime::component::__internal::Vec<u32>],),
+                                (
+                                    wasmtime::component::__internal::Vec<
+                                        wasmtime::component::__internal::Vec<u32>,
+                                    >,
+                                ),
+                            >::new_unchecked(self.simple_list4)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/simple-wasi.rs b/crates/component-macro/tests/expanded/simple-wasi.rs
new file mode 100644
index 000000000000..96d4a0bc2a94
--- /dev/null
+++ b/crates/component-macro/tests/expanded/simple-wasi.rs
@@ -0,0 +1,331 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `wasi`.
+///
+/// This structure is created through [`WasiPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`Wasi`] as well.
+pub struct WasiPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: WasiIndices,
+}
+impl<T> Clone for WasiPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> WasiPre<_T> {
+    /// Creates a new copy of `WasiPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = WasiIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`Wasi`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<Wasi> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `wasi`.
+///
+/// This is an implementation detail of [`WasiPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`Wasi`] as well.
+#[derive(Clone)]
+pub struct WasiIndices {}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `wasi`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`Wasi::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`WasiPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`WasiPre::instantiate`] to
+///   create a [`Wasi`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`Wasi::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`WasiIndices::new_instance`] followed
+///   by [`WasiIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct Wasi {}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl WasiIndices {
+        /// Creates a new copy of `WasiIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            Ok(WasiIndices {})
+        }
+        /// Creates a new instance of [`WasiIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`Wasi`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`Wasi`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            Ok(WasiIndices {})
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`Wasi`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Wasi> {
+            let _instance = instance;
+            Ok(Wasi {})
+        }
+    }
+    impl Wasi {
+        /// Convenience wrapper around [`WasiPre::new`] and
+        /// [`WasiPre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<Wasi> {
+            let pre = linker.instantiate_pre(component)?;
+            WasiPre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`WasiIndices::new_instance`] and
+        /// [`WasiIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Wasi> {
+            let indices = WasiIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            U: foo::foo::wasi_filesystem::Host + foo::foo::wall_clock::Host,
+        {
+            foo::foo::wasi_filesystem::add_to_linker(linker, get)?;
+            foo::foo::wall_clock::add_to_linker(linker, get)?;
+            Ok(())
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod wasi_filesystem {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone, Copy)]
+            pub struct DescriptorStat {}
+            impl core::fmt::Debug for DescriptorStat {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("DescriptorStat").finish()
+                }
+            }
+            const _: () = {
+                assert!(
+                    0 == < DescriptorStat as wasmtime::component::ComponentType >::SIZE32
+                );
+                assert!(
+                    1 == < DescriptorStat as wasmtime::component::ComponentType
+                    >::ALIGN32
+                );
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(enum)]
+            #[derive(Clone, Copy, Eq, PartialEq)]
+            #[repr(u8)]
+            pub enum Errno {
+                #[component(name = "e")]
+                E,
+            }
+            impl Errno {
+                pub fn name(&self) -> &'static str {
+                    match self {
+                        Errno::E => "e",
+                    }
+                }
+                pub fn message(&self) -> &'static str {
+                    match self {
+                        Errno::E => "",
+                    }
+                }
+            }
+            impl core::fmt::Debug for Errno {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("Errno")
+                        .field("code", &(*self as i32))
+                        .field("name", &self.name())
+                        .field("message", &self.message())
+                        .finish()
+                }
+            }
+            impl core::fmt::Display for Errno {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    write!(f, "{} (error {})", self.name(), * self as i32)
+                }
+            }
+            impl std::error::Error for Errno {}
+            const _: () = {
+                assert!(1 == < Errno as wasmtime::component::ComponentType >::SIZE32);
+                assert!(1 == < Errno as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            pub trait Host {
+                fn create_directory_at(&mut self) -> Result<(), Errno>;
+                fn stat(&mut self) -> Result<DescriptorStat, Errno>;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/wasi-filesystem")?;
+                inst.func_wrap(
+                    "create-directory-at",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::create_directory_at(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "stat",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::stat(host);
+                        Ok((r,))
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {
+                fn create_directory_at(&mut self) -> Result<(), Errno> {
+                    Host::create_directory_at(*self)
+                }
+                fn stat(&mut self) -> Result<DescriptorStat, Errno> {
+                    Host::stat(*self)
+                }
+            }
+        }
+        #[allow(clippy::all)]
+        pub mod wall_clock {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub trait Host {}
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/wall-clock")?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {}
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/simple-wasi_async.rs b/crates/component-macro/tests/expanded/simple-wasi_async.rs
new file mode 100644
index 000000000000..3cb43fd26d6d
--- /dev/null
+++ b/crates/component-macro/tests/expanded/simple-wasi_async.rs
@@ -0,0 +1,350 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `wasi`.
+///
+/// This structure is created through [`WasiPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`Wasi`] as well.
+pub struct WasiPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: WasiIndices,
+}
+impl<T> Clone for WasiPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> WasiPre<_T> {
+    /// Creates a new copy of `WasiPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = WasiIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`Wasi`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<Wasi>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `wasi`.
+///
+/// This is an implementation detail of [`WasiPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`Wasi`] as well.
+#[derive(Clone)]
+pub struct WasiIndices {}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `wasi`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`Wasi::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`WasiPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`WasiPre::instantiate_async`] to
+///   create a [`Wasi`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`Wasi::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`WasiIndices::new_instance`] followed
+///   by [`WasiIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct Wasi {}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl WasiIndices {
+        /// Creates a new copy of `WasiIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            Ok(WasiIndices {})
+        }
+        /// Creates a new instance of [`WasiIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`Wasi`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`Wasi`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            Ok(WasiIndices {})
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`Wasi`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Wasi> {
+            let _instance = instance;
+            Ok(Wasi {})
+        }
+    }
+    impl Wasi {
+        /// Convenience wrapper around [`WasiPre::new`] and
+        /// [`WasiPre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<Wasi>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            WasiPre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`WasiIndices::new_instance`] and
+        /// [`WasiIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Wasi> {
+            let indices = WasiIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+            U: foo::foo::wasi_filesystem::Host + foo::foo::wall_clock::Host + Send,
+        {
+            foo::foo::wasi_filesystem::add_to_linker(linker, get)?;
+            foo::foo::wall_clock::add_to_linker(linker, get)?;
+            Ok(())
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod wasi_filesystem {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone, Copy)]
+            pub struct DescriptorStat {}
+            impl core::fmt::Debug for DescriptorStat {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("DescriptorStat").finish()
+                }
+            }
+            const _: () = {
+                assert!(
+                    0 == < DescriptorStat as wasmtime::component::ComponentType >::SIZE32
+                );
+                assert!(
+                    1 == < DescriptorStat as wasmtime::component::ComponentType
+                    >::ALIGN32
+                );
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(enum)]
+            #[derive(Clone, Copy, Eq, PartialEq)]
+            #[repr(u8)]
+            pub enum Errno {
+                #[component(name = "e")]
+                E,
+            }
+            impl Errno {
+                pub fn name(&self) -> &'static str {
+                    match self {
+                        Errno::E => "e",
+                    }
+                }
+                pub fn message(&self) -> &'static str {
+                    match self {
+                        Errno::E => "",
+                    }
+                }
+            }
+            impl core::fmt::Debug for Errno {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("Errno")
+                        .field("code", &(*self as i32))
+                        .field("name", &self.name())
+                        .field("message", &self.message())
+                        .finish()
+                }
+            }
+            impl core::fmt::Display for Errno {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    write!(f, "{} (error {})", self.name(), * self as i32)
+                }
+            }
+            impl std::error::Error for Errno {}
+            const _: () = {
+                assert!(1 == < Errno as wasmtime::component::ComponentType >::SIZE32);
+                assert!(1 == < Errno as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {
+                async fn create_directory_at(&mut self) -> Result<(), Errno>;
+                async fn stat(&mut self) -> Result<DescriptorStat, Errno>;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/wasi-filesystem")?;
+                inst.func_wrap_async(
+                    "create-directory-at",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::create_directory_at(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "stat",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::stat(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {
+                async fn create_directory_at(&mut self) -> Result<(), Errno> {
+                    Host::create_directory_at(*self).await
+                }
+                async fn stat(&mut self) -> Result<DescriptorStat, Errno> {
+                    Host::stat(*self).await
+                }
+            }
+        }
+        #[allow(clippy::all)]
+        pub mod wall_clock {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {}
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/wall-clock")?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {}
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/small-anonymous.rs b/crates/component-macro/tests/expanded/small-anonymous.rs
new file mode 100644
index 000000000000..baa6463b58e8
--- /dev/null
+++ b/crates/component-macro/tests/expanded/small-anonymous.rs
@@ -0,0 +1,454 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-world`.
+///
+/// This structure is created through [`TheWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheWorld`] as well.
+pub struct TheWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheWorldIndices,
+}
+impl<T> Clone for TheWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheWorldPre<_T> {
+    /// Creates a new copy of `TheWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheWorld> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-world`.
+///
+/// This is an implementation detail of [`TheWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheWorld`] as well.
+#[derive(Clone)]
+pub struct TheWorldIndices {
+    interface0: exports::foo::foo::anon::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheWorld::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheWorldPre::instantiate`] to
+///   create a [`TheWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheWorldIndices::new_instance`] followed
+///   by [`TheWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheWorld {
+    interface0: exports::foo::foo::anon::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheWorldIndices {
+        /// Creates a new copy of `TheWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::anon::GuestIndices::new(_component)?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Creates a new instance of [`TheWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::anon::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(TheWorld { interface0 })
+        }
+    }
+    impl TheWorld {
+        /// Convenience wrapper around [`TheWorldPre::new`] and
+        /// [`TheWorldPre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheWorld> {
+            let pre = linker.instantiate_pre(component)?;
+            TheWorldPre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`TheWorldIndices::new_instance`] and
+        /// [`TheWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let indices = TheWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            U: foo::foo::anon::Host,
+        {
+            foo::foo::anon::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_anon(&self) -> &exports::foo::foo::anon::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod anon {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(enum)]
+            #[derive(Clone, Copy, Eq, PartialEq)]
+            #[repr(u8)]
+            pub enum Error {
+                #[component(name = "success")]
+                Success,
+                #[component(name = "failure")]
+                Failure,
+            }
+            impl Error {
+                pub fn name(&self) -> &'static str {
+                    match self {
+                        Error::Success => "success",
+                        Error::Failure => "failure",
+                    }
+                }
+                pub fn message(&self) -> &'static str {
+                    match self {
+                        Error::Success => "",
+                        Error::Failure => "",
+                    }
+                }
+            }
+            impl core::fmt::Debug for Error {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("Error")
+                        .field("code", &(*self as i32))
+                        .field("name", &self.name())
+                        .field("message", &self.message())
+                        .finish()
+                }
+            }
+            impl core::fmt::Display for Error {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    write!(f, "{} (error {})", self.name(), * self as i32)
+                }
+            }
+            impl std::error::Error for Error {}
+            const _: () = {
+                assert!(1 == < Error as wasmtime::component::ComponentType >::SIZE32);
+                assert!(1 == < Error as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            pub trait Host {
+                fn option_test(
+                    &mut self,
+                ) -> Result<Option<wasmtime::component::__internal::String>, Error>;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/anon")?;
+                inst.func_wrap(
+                    "option-test",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::option_test(host);
+                        Ok((r,))
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {
+                fn option_test(
+                    &mut self,
+                ) -> Result<Option<wasmtime::component::__internal::String>, Error> {
+                    Host::option_test(*self)
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod anon {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(enum)]
+                #[derive(Clone, Copy, Eq, PartialEq)]
+                #[repr(u8)]
+                pub enum Error {
+                    #[component(name = "success")]
+                    Success,
+                    #[component(name = "failure")]
+                    Failure,
+                }
+                impl Error {
+                    pub fn name(&self) -> &'static str {
+                        match self {
+                            Error::Success => "success",
+                            Error::Failure => "failure",
+                        }
+                    }
+                    pub fn message(&self) -> &'static str {
+                        match self {
+                            Error::Success => "",
+                            Error::Failure => "",
+                        }
+                    }
+                }
+                impl core::fmt::Debug for Error {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        f.debug_struct("Error")
+                            .field("code", &(*self as i32))
+                            .field("name", &self.name())
+                            .field("message", &self.message())
+                            .finish()
+                    }
+                }
+                impl core::fmt::Display for Error {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        write!(f, "{} (error {})", self.name(), * self as i32)
+                    }
+                }
+                impl std::error::Error for Error {}
+                const _: () = {
+                    assert!(
+                        1 == < Error as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        1 == < Error as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                pub struct Guest {
+                    option_test: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    option_test: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/anon")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!("no exported instance named `foo:foo/anon`")
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/anon")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!("no exported instance named `foo:foo/anon`")
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/anon` does \
+                    not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let option_test = lookup("option-test")?;
+                        Ok(GuestIndices { option_test })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let option_test = *_instance
+                            .get_typed_func::<
+                                (),
+                                (
+                                    Result<
+                                        Option<wasmtime::component::__internal::String>,
+                                        Error,
+                                    >,
+                                ),
+                            >(&mut store, &self.option_test)?
+                            .func();
+                        Ok(Guest { option_test })
+                    }
+                }
+                impl Guest {
+                    pub fn call_option_test<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<
+                        Result<Option<wasmtime::component::__internal::String>, Error>,
+                    > {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (
+                                    Result<
+                                        Option<wasmtime::component::__internal::String>,
+                                        Error,
+                                    >,
+                                ),
+                            >::new_unchecked(self.option_test)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/small-anonymous_async.rs b/crates/component-macro/tests/expanded/small-anonymous_async.rs
new file mode 100644
index 000000000000..6fdeda81a976
--- /dev/null
+++ b/crates/component-macro/tests/expanded/small-anonymous_async.rs
@@ -0,0 +1,472 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-world`.
+///
+/// This structure is created through [`TheWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheWorld`] as well.
+pub struct TheWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheWorldIndices,
+}
+impl<T> Clone for TheWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheWorldPre<_T> {
+    /// Creates a new copy of `TheWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheWorld>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-world`.
+///
+/// This is an implementation detail of [`TheWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheWorld`] as well.
+#[derive(Clone)]
+pub struct TheWorldIndices {
+    interface0: exports::foo::foo::anon::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheWorld::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheWorldPre::instantiate_async`] to
+///   create a [`TheWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheWorldIndices::new_instance`] followed
+///   by [`TheWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheWorld {
+    interface0: exports::foo::foo::anon::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheWorldIndices {
+        /// Creates a new copy of `TheWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::anon::GuestIndices::new(_component)?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Creates a new instance of [`TheWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::anon::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(TheWorld { interface0 })
+        }
+    }
+    impl TheWorld {
+        /// Convenience wrapper around [`TheWorldPre::new`] and
+        /// [`TheWorldPre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheWorld>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            TheWorldPre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`TheWorldIndices::new_instance`] and
+        /// [`TheWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let indices = TheWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+            U: foo::foo::anon::Host + Send,
+        {
+            foo::foo::anon::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_anon(&self) -> &exports::foo::foo::anon::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod anon {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(enum)]
+            #[derive(Clone, Copy, Eq, PartialEq)]
+            #[repr(u8)]
+            pub enum Error {
+                #[component(name = "success")]
+                Success,
+                #[component(name = "failure")]
+                Failure,
+            }
+            impl Error {
+                pub fn name(&self) -> &'static str {
+                    match self {
+                        Error::Success => "success",
+                        Error::Failure => "failure",
+                    }
+                }
+                pub fn message(&self) -> &'static str {
+                    match self {
+                        Error::Success => "",
+                        Error::Failure => "",
+                    }
+                }
+            }
+            impl core::fmt::Debug for Error {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("Error")
+                        .field("code", &(*self as i32))
+                        .field("name", &self.name())
+                        .field("message", &self.message())
+                        .finish()
+                }
+            }
+            impl core::fmt::Display for Error {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    write!(f, "{} (error {})", self.name(), * self as i32)
+                }
+            }
+            impl std::error::Error for Error {}
+            const _: () = {
+                assert!(1 == < Error as wasmtime::component::ComponentType >::SIZE32);
+                assert!(1 == < Error as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {
+                async fn option_test(
+                    &mut self,
+                ) -> Result<Option<wasmtime::component::__internal::String>, Error>;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/anon")?;
+                inst.func_wrap_async(
+                    "option-test",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::option_test(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {
+                async fn option_test(
+                    &mut self,
+                ) -> Result<Option<wasmtime::component::__internal::String>, Error> {
+                    Host::option_test(*self).await
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod anon {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(enum)]
+                #[derive(Clone, Copy, Eq, PartialEq)]
+                #[repr(u8)]
+                pub enum Error {
+                    #[component(name = "success")]
+                    Success,
+                    #[component(name = "failure")]
+                    Failure,
+                }
+                impl Error {
+                    pub fn name(&self) -> &'static str {
+                        match self {
+                            Error::Success => "success",
+                            Error::Failure => "failure",
+                        }
+                    }
+                    pub fn message(&self) -> &'static str {
+                        match self {
+                            Error::Success => "",
+                            Error::Failure => "",
+                        }
+                    }
+                }
+                impl core::fmt::Debug for Error {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        f.debug_struct("Error")
+                            .field("code", &(*self as i32))
+                            .field("name", &self.name())
+                            .field("message", &self.message())
+                            .finish()
+                    }
+                }
+                impl core::fmt::Display for Error {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        write!(f, "{} (error {})", self.name(), * self as i32)
+                    }
+                }
+                impl std::error::Error for Error {}
+                const _: () = {
+                    assert!(
+                        1 == < Error as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        1 == < Error as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                pub struct Guest {
+                    option_test: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    option_test: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/anon")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!("no exported instance named `foo:foo/anon`")
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/anon")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!("no exported instance named `foo:foo/anon`")
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/anon` does \
+                    not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let option_test = lookup("option-test")?;
+                        Ok(GuestIndices { option_test })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let option_test = *_instance
+                            .get_typed_func::<
+                                (),
+                                (
+                                    Result<
+                                        Option<wasmtime::component::__internal::String>,
+                                        Error,
+                                    >,
+                                ),
+                            >(&mut store, &self.option_test)?
+                            .func();
+                        Ok(Guest { option_test })
+                    }
+                }
+                impl Guest {
+                    pub async fn call_option_test<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<
+                        Result<Option<wasmtime::component::__internal::String>, Error>,
+                    >
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (
+                                    Result<
+                                        Option<wasmtime::component::__internal::String>,
+                                        Error,
+                                    >,
+                                ),
+                            >::new_unchecked(self.option_test)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/smoke-default.rs b/crates/component-macro/tests/expanded/smoke-default.rs
new file mode 100644
index 000000000000..e9ab3af1d8d4
--- /dev/null
+++ b/crates/component-macro/tests/expanded/smoke-default.rs
@@ -0,0 +1,182 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-world`.
+///
+/// This structure is created through [`TheWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheWorld`] as well.
+pub struct TheWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheWorldIndices,
+}
+impl<T> Clone for TheWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheWorldPre<_T> {
+    /// Creates a new copy of `TheWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheWorld> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-world`.
+///
+/// This is an implementation detail of [`TheWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheWorld`] as well.
+#[derive(Clone)]
+pub struct TheWorldIndices {
+    y: wasmtime::component::ComponentExportIndex,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheWorld::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheWorldPre::instantiate`] to
+///   create a [`TheWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheWorldIndices::new_instance`] followed
+///   by [`TheWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheWorld {
+    y: wasmtime::component::Func,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheWorldIndices {
+        /// Creates a new copy of `TheWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let y = _component
+                .export_index(None, "y")
+                .ok_or_else(|| anyhow::anyhow!("no function export `y` found"))?
+                .1;
+            Ok(TheWorldIndices { y })
+        }
+        /// Creates a new instance of [`TheWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let y = _instance
+                .get_export(&mut store, None, "y")
+                .ok_or_else(|| anyhow::anyhow!("no function export `y` found"))?;
+            Ok(TheWorldIndices { y })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let _instance = instance;
+            let y = *_instance.get_typed_func::<(), ()>(&mut store, &self.y)?.func();
+            Ok(TheWorld { y })
+        }
+    }
+    impl TheWorld {
+        /// Convenience wrapper around [`TheWorldPre::new`] and
+        /// [`TheWorldPre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheWorld> {
+            let pre = linker.instantiate_pre(component)?;
+            TheWorldPre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`TheWorldIndices::new_instance`] and
+        /// [`TheWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let indices = TheWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn call_y<S: wasmtime::AsContextMut>(
+            &self,
+            mut store: S,
+        ) -> wasmtime::Result<()> {
+            let callee = unsafe {
+                wasmtime::component::TypedFunc::<(), ()>::new_unchecked(self.y)
+            };
+            let () = callee.call(store.as_context_mut(), ())?;
+            callee.post_return(store.as_context_mut())?;
+            Ok(())
+        }
+    }
+};
diff --git a/crates/component-macro/tests/expanded/smoke-default_async.rs b/crates/component-macro/tests/expanded/smoke-default_async.rs
new file mode 100644
index 000000000000..30668f31d298
--- /dev/null
+++ b/crates/component-macro/tests/expanded/smoke-default_async.rs
@@ -0,0 +1,191 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-world`.
+///
+/// This structure is created through [`TheWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheWorld`] as well.
+pub struct TheWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheWorldIndices,
+}
+impl<T> Clone for TheWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheWorldPre<_T> {
+    /// Creates a new copy of `TheWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheWorld>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-world`.
+///
+/// This is an implementation detail of [`TheWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheWorld`] as well.
+#[derive(Clone)]
+pub struct TheWorldIndices {
+    y: wasmtime::component::ComponentExportIndex,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheWorld::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheWorldPre::instantiate_async`] to
+///   create a [`TheWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheWorldIndices::new_instance`] followed
+///   by [`TheWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheWorld {
+    y: wasmtime::component::Func,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheWorldIndices {
+        /// Creates a new copy of `TheWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let y = _component
+                .export_index(None, "y")
+                .ok_or_else(|| anyhow::anyhow!("no function export `y` found"))?
+                .1;
+            Ok(TheWorldIndices { y })
+        }
+        /// Creates a new instance of [`TheWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let y = _instance
+                .get_export(&mut store, None, "y")
+                .ok_or_else(|| anyhow::anyhow!("no function export `y` found"))?;
+            Ok(TheWorldIndices { y })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let _instance = instance;
+            let y = *_instance.get_typed_func::<(), ()>(&mut store, &self.y)?.func();
+            Ok(TheWorld { y })
+        }
+    }
+    impl TheWorld {
+        /// Convenience wrapper around [`TheWorldPre::new`] and
+        /// [`TheWorldPre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheWorld>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            TheWorldPre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`TheWorldIndices::new_instance`] and
+        /// [`TheWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let indices = TheWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub async fn call_y<S: wasmtime::AsContextMut>(
+            &self,
+            mut store: S,
+        ) -> wasmtime::Result<()>
+        where
+            <S as wasmtime::AsContext>::Data: Send,
+        {
+            let callee = unsafe {
+                wasmtime::component::TypedFunc::<(), ()>::new_unchecked(self.y)
+            };
+            let () = callee.call_async(store.as_context_mut(), ()).await?;
+            callee.post_return_async(store.as_context_mut()).await?;
+            Ok(())
+        }
+    }
+};
diff --git a/crates/component-macro/tests/expanded/smoke-export.rs b/crates/component-macro/tests/expanded/smoke-export.rs
new file mode 100644
index 000000000000..9a9f8a25b18e
--- /dev/null
+++ b/crates/component-macro/tests/expanded/smoke-export.rs
@@ -0,0 +1,263 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-world`.
+///
+/// This structure is created through [`TheWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheWorld`] as well.
+pub struct TheWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheWorldIndices,
+}
+impl<T> Clone for TheWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheWorldPre<_T> {
+    /// Creates a new copy of `TheWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheWorld> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-world`.
+///
+/// This is an implementation detail of [`TheWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheWorld`] as well.
+#[derive(Clone)]
+pub struct TheWorldIndices {
+    interface0: exports::the_name::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheWorld::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheWorldPre::instantiate`] to
+///   create a [`TheWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheWorldIndices::new_instance`] followed
+///   by [`TheWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheWorld {
+    interface0: exports::the_name::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheWorldIndices {
+        /// Creates a new copy of `TheWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::the_name::GuestIndices::new(_component)?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Creates a new instance of [`TheWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::the_name::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(TheWorld { interface0 })
+        }
+    }
+    impl TheWorld {
+        /// Convenience wrapper around [`TheWorldPre::new`] and
+        /// [`TheWorldPre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheWorld> {
+            let pre = linker.instantiate_pre(component)?;
+            TheWorldPre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`TheWorldIndices::new_instance`] and
+        /// [`TheWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let indices = TheWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn the_name(&self) -> &exports::the_name::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod exports {
+    #[allow(clippy::all)]
+    pub mod the_name {
+        #[allow(unused_imports)]
+        use wasmtime::component::__internal::anyhow;
+        pub struct Guest {
+            y: wasmtime::component::Func,
+        }
+        #[derive(Clone)]
+        pub struct GuestIndices {
+            y: wasmtime::component::ComponentExportIndex,
+        }
+        impl GuestIndices {
+            /// Constructor for [`GuestIndices`] which takes a
+            /// [`Component`](wasmtime::component::Component) as input and can be executed
+            /// before instantiation.
+            ///
+            /// This constructor can be used to front-load string lookups to find exports
+            /// within a component.
+            pub fn new(
+                component: &wasmtime::component::Component,
+            ) -> wasmtime::Result<GuestIndices> {
+                let (_, instance) = component
+                    .export_index(None, "the-name")
+                    .ok_or_else(|| {
+                        anyhow::anyhow!("no exported instance named `the-name`")
+                    })?;
+                Self::_new(|name| {
+                    component.export_index(Some(&instance), name).map(|p| p.1)
+                })
+            }
+            /// This constructor is similar to [`GuestIndices::new`] except that it
+            /// performs string lookups after instantiation time.
+            pub fn new_instance(
+                mut store: impl wasmtime::AsContextMut,
+                instance: &wasmtime::component::Instance,
+            ) -> wasmtime::Result<GuestIndices> {
+                let instance_export = instance
+                    .get_export(&mut store, None, "the-name")
+                    .ok_or_else(|| {
+                        anyhow::anyhow!("no exported instance named `the-name`")
+                    })?;
+                Self::_new(|name| {
+                    instance.get_export(&mut store, Some(&instance_export), name)
+                })
+            }
+            fn _new(
+                mut lookup: impl FnMut(
+                    &str,
+                ) -> Option<wasmtime::component::ComponentExportIndex>,
+            ) -> wasmtime::Result<GuestIndices> {
+                let mut lookup = move |name| {
+                    lookup(name)
+                        .ok_or_else(|| {
+                            anyhow::anyhow!(
+                                "instance export `the-name` does \
+            not have export `{name}`"
+                            )
+                        })
+                };
+                let _ = &mut lookup;
+                let y = lookup("y")?;
+                Ok(GuestIndices { y })
+            }
+            pub fn load(
+                &self,
+                mut store: impl wasmtime::AsContextMut,
+                instance: &wasmtime::component::Instance,
+            ) -> wasmtime::Result<Guest> {
+                let mut store = store.as_context_mut();
+                let _ = &mut store;
+                let _instance = instance;
+                let y = *_instance.get_typed_func::<(), ()>(&mut store, &self.y)?.func();
+                Ok(Guest { y })
+            }
+        }
+        impl Guest {
+            pub fn call_y<S: wasmtime::AsContextMut>(
+                &self,
+                mut store: S,
+            ) -> wasmtime::Result<()> {
+                let callee = unsafe {
+                    wasmtime::component::TypedFunc::<(), ()>::new_unchecked(self.y)
+                };
+                let () = callee.call(store.as_context_mut(), ())?;
+                callee.post_return(store.as_context_mut())?;
+                Ok(())
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/smoke-export_async.rs b/crates/component-macro/tests/expanded/smoke-export_async.rs
new file mode 100644
index 000000000000..e21b8232c855
--- /dev/null
+++ b/crates/component-macro/tests/expanded/smoke-export_async.rs
@@ -0,0 +1,272 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-world`.
+///
+/// This structure is created through [`TheWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheWorld`] as well.
+pub struct TheWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheWorldIndices,
+}
+impl<T> Clone for TheWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheWorldPre<_T> {
+    /// Creates a new copy of `TheWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheWorld>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-world`.
+///
+/// This is an implementation detail of [`TheWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheWorld`] as well.
+#[derive(Clone)]
+pub struct TheWorldIndices {
+    interface0: exports::the_name::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheWorld::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheWorldPre::instantiate_async`] to
+///   create a [`TheWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheWorldIndices::new_instance`] followed
+///   by [`TheWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheWorld {
+    interface0: exports::the_name::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheWorldIndices {
+        /// Creates a new copy of `TheWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::the_name::GuestIndices::new(_component)?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Creates a new instance of [`TheWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::the_name::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(TheWorld { interface0 })
+        }
+    }
+    impl TheWorld {
+        /// Convenience wrapper around [`TheWorldPre::new`] and
+        /// [`TheWorldPre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheWorld>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            TheWorldPre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`TheWorldIndices::new_instance`] and
+        /// [`TheWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let indices = TheWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn the_name(&self) -> &exports::the_name::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod exports {
+    #[allow(clippy::all)]
+    pub mod the_name {
+        #[allow(unused_imports)]
+        use wasmtime::component::__internal::anyhow;
+        pub struct Guest {
+            y: wasmtime::component::Func,
+        }
+        #[derive(Clone)]
+        pub struct GuestIndices {
+            y: wasmtime::component::ComponentExportIndex,
+        }
+        impl GuestIndices {
+            /// Constructor for [`GuestIndices`] which takes a
+            /// [`Component`](wasmtime::component::Component) as input and can be executed
+            /// before instantiation.
+            ///
+            /// This constructor can be used to front-load string lookups to find exports
+            /// within a component.
+            pub fn new(
+                component: &wasmtime::component::Component,
+            ) -> wasmtime::Result<GuestIndices> {
+                let (_, instance) = component
+                    .export_index(None, "the-name")
+                    .ok_or_else(|| {
+                        anyhow::anyhow!("no exported instance named `the-name`")
+                    })?;
+                Self::_new(|name| {
+                    component.export_index(Some(&instance), name).map(|p| p.1)
+                })
+            }
+            /// This constructor is similar to [`GuestIndices::new`] except that it
+            /// performs string lookups after instantiation time.
+            pub fn new_instance(
+                mut store: impl wasmtime::AsContextMut,
+                instance: &wasmtime::component::Instance,
+            ) -> wasmtime::Result<GuestIndices> {
+                let instance_export = instance
+                    .get_export(&mut store, None, "the-name")
+                    .ok_or_else(|| {
+                        anyhow::anyhow!("no exported instance named `the-name`")
+                    })?;
+                Self::_new(|name| {
+                    instance.get_export(&mut store, Some(&instance_export), name)
+                })
+            }
+            fn _new(
+                mut lookup: impl FnMut(
+                    &str,
+                ) -> Option<wasmtime::component::ComponentExportIndex>,
+            ) -> wasmtime::Result<GuestIndices> {
+                let mut lookup = move |name| {
+                    lookup(name)
+                        .ok_or_else(|| {
+                            anyhow::anyhow!(
+                                "instance export `the-name` does \
+            not have export `{name}`"
+                            )
+                        })
+                };
+                let _ = &mut lookup;
+                let y = lookup("y")?;
+                Ok(GuestIndices { y })
+            }
+            pub fn load(
+                &self,
+                mut store: impl wasmtime::AsContextMut,
+                instance: &wasmtime::component::Instance,
+            ) -> wasmtime::Result<Guest> {
+                let mut store = store.as_context_mut();
+                let _ = &mut store;
+                let _instance = instance;
+                let y = *_instance.get_typed_func::<(), ()>(&mut store, &self.y)?.func();
+                Ok(Guest { y })
+            }
+        }
+        impl Guest {
+            pub async fn call_y<S: wasmtime::AsContextMut>(
+                &self,
+                mut store: S,
+            ) -> wasmtime::Result<()>
+            where
+                <S as wasmtime::AsContext>::Data: Send,
+            {
+                let callee = unsafe {
+                    wasmtime::component::TypedFunc::<(), ()>::new_unchecked(self.y)
+                };
+                let () = callee.call_async(store.as_context_mut(), ()).await?;
+                callee.post_return_async(store.as_context_mut()).await?;
+                Ok(())
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/smoke.rs b/crates/component-macro/tests/expanded/smoke.rs
new file mode 100644
index 000000000000..f455ece5d3f7
--- /dev/null
+++ b/crates/component-macro/tests/expanded/smoke.rs
@@ -0,0 +1,218 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-world`.
+///
+/// This structure is created through [`TheWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheWorld`] as well.
+pub struct TheWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheWorldIndices,
+}
+impl<T> Clone for TheWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheWorldPre<_T> {
+    /// Creates a new copy of `TheWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheWorld> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-world`.
+///
+/// This is an implementation detail of [`TheWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheWorld`] as well.
+#[derive(Clone)]
+pub struct TheWorldIndices {}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheWorld::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheWorldPre::instantiate`] to
+///   create a [`TheWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheWorldIndices::new_instance`] followed
+///   by [`TheWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheWorld {}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheWorldIndices {
+        /// Creates a new copy of `TheWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            Ok(TheWorldIndices {})
+        }
+        /// Creates a new instance of [`TheWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            Ok(TheWorldIndices {})
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let _instance = instance;
+            Ok(TheWorld {})
+        }
+    }
+    impl TheWorld {
+        /// Convenience wrapper around [`TheWorldPre::new`] and
+        /// [`TheWorldPre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheWorld> {
+            let pre = linker.instantiate_pre(component)?;
+            TheWorldPre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`TheWorldIndices::new_instance`] and
+        /// [`TheWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let indices = TheWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            U: imports::Host,
+        {
+            imports::add_to_linker(linker, get)?;
+            Ok(())
+        }
+    }
+};
+#[allow(clippy::all)]
+pub mod imports {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    pub trait Host {
+        fn y(&mut self) -> ();
+    }
+    pub trait GetHost<
+        T,
+    >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+        type Host: Host;
+    }
+    impl<F, T, O> GetHost<T> for F
+    where
+        F: Fn(T) -> O + Send + Sync + Copy + 'static,
+        O: Host,
+    {
+        type Host = O;
+    }
+    pub fn add_to_linker_get_host<T>(
+        linker: &mut wasmtime::component::Linker<T>,
+        host_getter: impl for<'a> GetHost<&'a mut T>,
+    ) -> wasmtime::Result<()> {
+        let mut inst = linker.instance("imports")?;
+        inst.func_wrap(
+            "y",
+            move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                let host = &mut host_getter(caller.data_mut());
+                let r = Host::y(host);
+                Ok(r)
+            },
+        )?;
+        Ok(())
+    }
+    pub fn add_to_linker<T, U>(
+        linker: &mut wasmtime::component::Linker<T>,
+        get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+    ) -> wasmtime::Result<()>
+    where
+        U: Host,
+    {
+        add_to_linker_get_host(linker, get)
+    }
+    impl<_T: Host + ?Sized> Host for &mut _T {
+        fn y(&mut self) -> () {
+            Host::y(*self)
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/smoke_async.rs b/crates/component-macro/tests/expanded/smoke_async.rs
new file mode 100644
index 000000000000..b826b5134ffd
--- /dev/null
+++ b/crates/component-macro/tests/expanded/smoke_async.rs
@@ -0,0 +1,231 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-world`.
+///
+/// This structure is created through [`TheWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheWorld`] as well.
+pub struct TheWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheWorldIndices,
+}
+impl<T> Clone for TheWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheWorldPre<_T> {
+    /// Creates a new copy of `TheWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheWorld>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-world`.
+///
+/// This is an implementation detail of [`TheWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheWorld`] as well.
+#[derive(Clone)]
+pub struct TheWorldIndices {}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheWorld::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheWorldPre::instantiate_async`] to
+///   create a [`TheWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheWorldIndices::new_instance`] followed
+///   by [`TheWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheWorld {}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheWorldIndices {
+        /// Creates a new copy of `TheWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            Ok(TheWorldIndices {})
+        }
+        /// Creates a new instance of [`TheWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            Ok(TheWorldIndices {})
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let _instance = instance;
+            Ok(TheWorld {})
+        }
+    }
+    impl TheWorld {
+        /// Convenience wrapper around [`TheWorldPre::new`] and
+        /// [`TheWorldPre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheWorld>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            TheWorldPre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`TheWorldIndices::new_instance`] and
+        /// [`TheWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let indices = TheWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+            U: imports::Host + Send,
+        {
+            imports::add_to_linker(linker, get)?;
+            Ok(())
+        }
+    }
+};
+#[allow(clippy::all)]
+pub mod imports {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    #[wasmtime::component::__internal::async_trait]
+    pub trait Host: Send {
+        async fn y(&mut self) -> ();
+    }
+    pub trait GetHost<
+        T,
+    >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+        type Host: Host + Send;
+    }
+    impl<F, T, O> GetHost<T> for F
+    where
+        F: Fn(T) -> O + Send + Sync + Copy + 'static,
+        O: Host + Send,
+    {
+        type Host = O;
+    }
+    pub fn add_to_linker_get_host<T>(
+        linker: &mut wasmtime::component::Linker<T>,
+        host_getter: impl for<'a> GetHost<&'a mut T>,
+    ) -> wasmtime::Result<()>
+    where
+        T: Send,
+    {
+        let mut inst = linker.instance("imports")?;
+        inst.func_wrap_async(
+            "y",
+            move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                let host = &mut host_getter(caller.data_mut());
+                let r = Host::y(host).await;
+                Ok(r)
+            }),
+        )?;
+        Ok(())
+    }
+    pub fn add_to_linker<T, U>(
+        linker: &mut wasmtime::component::Linker<T>,
+        get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+    ) -> wasmtime::Result<()>
+    where
+        U: Host + Send,
+        T: Send,
+    {
+        add_to_linker_get_host(linker, get)
+    }
+    #[wasmtime::component::__internal::async_trait]
+    impl<_T: Host + ?Sized + Send> Host for &mut _T {
+        async fn y(&mut self) -> () {
+            Host::y(*self).await
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/strings.rs b/crates/component-macro/tests/expanded/strings.rs
new file mode 100644
index 000000000000..743d69f5044c
--- /dev/null
+++ b/crates/component-macro/tests/expanded/strings.rs
@@ -0,0 +1,432 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-world`.
+///
+/// This structure is created through [`TheWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheWorld`] as well.
+pub struct TheWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheWorldIndices,
+}
+impl<T> Clone for TheWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheWorldPre<_T> {
+    /// Creates a new copy of `TheWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheWorld> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-world`.
+///
+/// This is an implementation detail of [`TheWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheWorld`] as well.
+#[derive(Clone)]
+pub struct TheWorldIndices {
+    interface0: exports::foo::foo::strings::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheWorld::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheWorldPre::instantiate`] to
+///   create a [`TheWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheWorldIndices::new_instance`] followed
+///   by [`TheWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheWorld {
+    interface0: exports::foo::foo::strings::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheWorldIndices {
+        /// Creates a new copy of `TheWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::strings::GuestIndices::new(_component)?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Creates a new instance of [`TheWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::strings::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(TheWorld { interface0 })
+        }
+    }
+    impl TheWorld {
+        /// Convenience wrapper around [`TheWorldPre::new`] and
+        /// [`TheWorldPre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheWorld> {
+            let pre = linker.instantiate_pre(component)?;
+            TheWorldPre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`TheWorldIndices::new_instance`] and
+        /// [`TheWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let indices = TheWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            U: foo::foo::strings::Host,
+        {
+            foo::foo::strings::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_strings(&self) -> &exports::foo::foo::strings::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod strings {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub trait Host {
+                fn a(&mut self, x: wasmtime::component::__internal::String) -> ();
+                fn b(&mut self) -> wasmtime::component::__internal::String;
+                fn c(
+                    &mut self,
+                    a: wasmtime::component::__internal::String,
+                    b: wasmtime::component::__internal::String,
+                ) -> wasmtime::component::__internal::String;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/strings")?;
+                inst.func_wrap(
+                    "a",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::String,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::a(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "b",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::b(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "c",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (
+                            arg0,
+                            arg1,
+                        ): (
+                            wasmtime::component::__internal::String,
+                            wasmtime::component::__internal::String,
+                        )|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::c(host, arg0, arg1);
+                        Ok((r,))
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {
+                fn a(&mut self, x: wasmtime::component::__internal::String) -> () {
+                    Host::a(*self, x)
+                }
+                fn b(&mut self) -> wasmtime::component::__internal::String {
+                    Host::b(*self)
+                }
+                fn c(
+                    &mut self,
+                    a: wasmtime::component::__internal::String,
+                    b: wasmtime::component::__internal::String,
+                ) -> wasmtime::component::__internal::String {
+                    Host::c(*self, a, b)
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod strings {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub struct Guest {
+                    a: wasmtime::component::Func,
+                    b: wasmtime::component::Func,
+                    c: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    a: wasmtime::component::ComponentExportIndex,
+                    b: wasmtime::component::ComponentExportIndex,
+                    c: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/strings")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/strings`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/strings")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/strings`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/strings` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let a = lookup("a")?;
+                        let b = lookup("b")?;
+                        let c = lookup("c")?;
+                        Ok(GuestIndices { a, b, c })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let a = *_instance
+                            .get_typed_func::<(&str,), ()>(&mut store, &self.a)?
+                            .func();
+                        let b = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::__internal::String,),
+                            >(&mut store, &self.b)?
+                            .func();
+                        let c = *_instance
+                            .get_typed_func::<
+                                (&str, &str),
+                                (wasmtime::component::__internal::String,),
+                            >(&mut store, &self.c)?
+                            .func();
+                        Ok(Guest { a, b, c })
+                    }
+                }
+                impl Guest {
+                    pub fn call_a<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &str,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&str,),
+                                (),
+                            >::new_unchecked(self.a)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_b<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::__internal::String> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::__internal::String,),
+                            >::new_unchecked(self.b)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_c<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &str,
+                        arg1: &str,
+                    ) -> wasmtime::Result<wasmtime::component::__internal::String> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&str, &str),
+                                (wasmtime::component::__internal::String,),
+                            >::new_unchecked(self.c)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), (arg0, arg1))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/strings_async.rs b/crates/component-macro/tests/expanded/strings_async.rs
new file mode 100644
index 000000000000..63a20c32437d
--- /dev/null
+++ b/crates/component-macro/tests/expanded/strings_async.rs
@@ -0,0 +1,460 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `the-world`.
+///
+/// This structure is created through [`TheWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`TheWorld`] as well.
+pub struct TheWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: TheWorldIndices,
+}
+impl<T> Clone for TheWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> TheWorldPre<_T> {
+    /// Creates a new copy of `TheWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = TheWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`TheWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<TheWorld>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `the-world`.
+///
+/// This is an implementation detail of [`TheWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`TheWorld`] as well.
+#[derive(Clone)]
+pub struct TheWorldIndices {
+    interface0: exports::foo::foo::strings::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `the-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`TheWorld::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`TheWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`TheWorldPre::instantiate_async`] to
+///   create a [`TheWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`TheWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`TheWorldIndices::new_instance`] followed
+///   by [`TheWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct TheWorld {
+    interface0: exports::foo::foo::strings::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl TheWorldIndices {
+        /// Creates a new copy of `TheWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::strings::GuestIndices::new(_component)?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Creates a new instance of [`TheWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`TheWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`TheWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::strings::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(TheWorldIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`TheWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(TheWorld { interface0 })
+        }
+    }
+    impl TheWorld {
+        /// Convenience wrapper around [`TheWorldPre::new`] and
+        /// [`TheWorldPre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<TheWorld>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            TheWorldPre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`TheWorldIndices::new_instance`] and
+        /// [`TheWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<TheWorld> {
+            let indices = TheWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+            U: foo::foo::strings::Host + Send,
+        {
+            foo::foo::strings::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_strings(&self) -> &exports::foo::foo::strings::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod strings {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {
+                async fn a(&mut self, x: wasmtime::component::__internal::String) -> ();
+                async fn b(&mut self) -> wasmtime::component::__internal::String;
+                async fn c(
+                    &mut self,
+                    a: wasmtime::component::__internal::String,
+                    b: wasmtime::component::__internal::String,
+                ) -> wasmtime::component::__internal::String;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/strings")?;
+                inst.func_wrap_async(
+                    "a",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (wasmtime::component::__internal::String,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::a(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "b",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::b(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "c",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (
+                            arg0,
+                            arg1,
+                        ): (
+                            wasmtime::component::__internal::String,
+                            wasmtime::component::__internal::String,
+                        )|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::c(host, arg0, arg1).await;
+                        Ok((r,))
+                    }),
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {
+                async fn a(&mut self, x: wasmtime::component::__internal::String) -> () {
+                    Host::a(*self, x).await
+                }
+                async fn b(&mut self) -> wasmtime::component::__internal::String {
+                    Host::b(*self).await
+                }
+                async fn c(
+                    &mut self,
+                    a: wasmtime::component::__internal::String,
+                    b: wasmtime::component::__internal::String,
+                ) -> wasmtime::component::__internal::String {
+                    Host::c(*self, a, b).await
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod strings {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub struct Guest {
+                    a: wasmtime::component::Func,
+                    b: wasmtime::component::Func,
+                    c: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    a: wasmtime::component::ComponentExportIndex,
+                    b: wasmtime::component::ComponentExportIndex,
+                    c: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/strings")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/strings`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/strings")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/strings`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/strings` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let a = lookup("a")?;
+                        let b = lookup("b")?;
+                        let c = lookup("c")?;
+                        Ok(GuestIndices { a, b, c })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let a = *_instance
+                            .get_typed_func::<(&str,), ()>(&mut store, &self.a)?
+                            .func();
+                        let b = *_instance
+                            .get_typed_func::<
+                                (),
+                                (wasmtime::component::__internal::String,),
+                            >(&mut store, &self.b)?
+                            .func();
+                        let c = *_instance
+                            .get_typed_func::<
+                                (&str, &str),
+                                (wasmtime::component::__internal::String,),
+                            >(&mut store, &self.c)?
+                            .func();
+                        Ok(Guest { a, b, c })
+                    }
+                }
+                impl Guest {
+                    pub async fn call_a<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &str,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&str,),
+                                (),
+                            >::new_unchecked(self.a)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_b<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<wasmtime::component::__internal::String>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (wasmtime::component::__internal::String,),
+                            >::new_unchecked(self.b)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_c<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &str,
+                        arg1: &str,
+                    ) -> wasmtime::Result<wasmtime::component::__internal::String>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&str, &str),
+                                (wasmtime::component::__internal::String,),
+                            >::new_unchecked(self.c)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), (arg0, arg1))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/unversioned-foo.rs b/crates/component-macro/tests/expanded/unversioned-foo.rs
new file mode 100644
index 000000000000..20b394cf1bfb
--- /dev/null
+++ b/crates/component-macro/tests/expanded/unversioned-foo.rs
@@ -0,0 +1,250 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `nope`.
+///
+/// This structure is created through [`NopePre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`Nope`] as well.
+pub struct NopePre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: NopeIndices,
+}
+impl<T> Clone for NopePre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> NopePre<_T> {
+    /// Creates a new copy of `NopePre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = NopeIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`Nope`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<Nope> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `nope`.
+///
+/// This is an implementation detail of [`NopePre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`Nope`] as well.
+#[derive(Clone)]
+pub struct NopeIndices {}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `nope`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`Nope::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`NopePre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`NopePre::instantiate`] to
+///   create a [`Nope`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`Nope::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`NopeIndices::new_instance`] followed
+///   by [`NopeIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct Nope {}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl NopeIndices {
+        /// Creates a new copy of `NopeIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            Ok(NopeIndices {})
+        }
+        /// Creates a new instance of [`NopeIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`Nope`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`Nope`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            Ok(NopeIndices {})
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`Nope`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Nope> {
+            let _instance = instance;
+            Ok(Nope {})
+        }
+    }
+    impl Nope {
+        /// Convenience wrapper around [`NopePre::new`] and
+        /// [`NopePre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<Nope> {
+            let pre = linker.instantiate_pre(component)?;
+            NopePre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`NopeIndices::new_instance`] and
+        /// [`NopeIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Nope> {
+            let indices = NopeIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            U: foo::foo::a::Host,
+        {
+            foo::foo::a::add_to_linker(linker, get)?;
+            Ok(())
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod a {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(variant)]
+            #[derive(Clone)]
+            pub enum Error {
+                #[component(name = "other")]
+                Other(wasmtime::component::__internal::String),
+            }
+            impl core::fmt::Debug for Error {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    match self {
+                        Error::Other(e) => {
+                            f.debug_tuple("Error::Other").field(e).finish()
+                        }
+                    }
+                }
+            }
+            impl core::fmt::Display for Error {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    write!(f, "{:?}", self)
+                }
+            }
+            impl std::error::Error for Error {}
+            const _: () = {
+                assert!(12 == < Error as wasmtime::component::ComponentType >::SIZE32);
+                assert!(4 == < Error as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            pub trait Host {
+                fn g(&mut self) -> Result<(), Error>;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/a")?;
+                inst.func_wrap(
+                    "g",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::g(host);
+                        Ok((r,))
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {
+                fn g(&mut self) -> Result<(), Error> {
+                    Host::g(*self)
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/unversioned-foo_async.rs b/crates/component-macro/tests/expanded/unversioned-foo_async.rs
new file mode 100644
index 000000000000..05fe578c832a
--- /dev/null
+++ b/crates/component-macro/tests/expanded/unversioned-foo_async.rs
@@ -0,0 +1,263 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `nope`.
+///
+/// This structure is created through [`NopePre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`Nope`] as well.
+pub struct NopePre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: NopeIndices,
+}
+impl<T> Clone for NopePre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> NopePre<_T> {
+    /// Creates a new copy of `NopePre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = NopeIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`Nope`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<Nope>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `nope`.
+///
+/// This is an implementation detail of [`NopePre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`Nope`] as well.
+#[derive(Clone)]
+pub struct NopeIndices {}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `nope`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`Nope::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`NopePre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`NopePre::instantiate_async`] to
+///   create a [`Nope`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`Nope::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`NopeIndices::new_instance`] followed
+///   by [`NopeIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct Nope {}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl NopeIndices {
+        /// Creates a new copy of `NopeIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            Ok(NopeIndices {})
+        }
+        /// Creates a new instance of [`NopeIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`Nope`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`Nope`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            Ok(NopeIndices {})
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`Nope`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Nope> {
+            let _instance = instance;
+            Ok(Nope {})
+        }
+    }
+    impl Nope {
+        /// Convenience wrapper around [`NopePre::new`] and
+        /// [`NopePre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<Nope>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            NopePre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`NopeIndices::new_instance`] and
+        /// [`NopeIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Nope> {
+            let indices = NopeIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+            U: foo::foo::a::Host + Send,
+        {
+            foo::foo::a::add_to_linker(linker, get)?;
+            Ok(())
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod a {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(variant)]
+            #[derive(Clone)]
+            pub enum Error {
+                #[component(name = "other")]
+                Other(wasmtime::component::__internal::String),
+            }
+            impl core::fmt::Debug for Error {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    match self {
+                        Error::Other(e) => {
+                            f.debug_tuple("Error::Other").field(e).finish()
+                        }
+                    }
+                }
+            }
+            impl core::fmt::Display for Error {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    write!(f, "{:?}", self)
+                }
+            }
+            impl std::error::Error for Error {}
+            const _: () = {
+                assert!(12 == < Error as wasmtime::component::ComponentType >::SIZE32);
+                assert!(4 == < Error as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {
+                async fn g(&mut self) -> Result<(), Error>;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/a")?;
+                inst.func_wrap_async(
+                    "g",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::g(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {
+                async fn g(&mut self) -> Result<(), Error> {
+                    Host::g(*self).await
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/use-paths.rs b/crates/component-macro/tests/expanded/use-paths.rs
new file mode 100644
index 000000000000..42e5e053aebc
--- /dev/null
+++ b/crates/component-macro/tests/expanded/use-paths.rs
@@ -0,0 +1,402 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `d`.
+///
+/// This structure is created through [`DPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`D`] as well.
+pub struct DPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: DIndices,
+}
+impl<T> Clone for DPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> DPre<_T> {
+    /// Creates a new copy of `DPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = DIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`D`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<D> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `d`.
+///
+/// This is an implementation detail of [`DPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`D`] as well.
+#[derive(Clone)]
+pub struct DIndices {}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `d`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`D::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`DPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`DPre::instantiate`] to
+///   create a [`D`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`D::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`DIndices::new_instance`] followed
+///   by [`DIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct D {}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl DIndices {
+        /// Creates a new copy of `DIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            Ok(DIndices {})
+        }
+        /// Creates a new instance of [`DIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`D`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`D`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            Ok(DIndices {})
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`D`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<D> {
+            let _instance = instance;
+            Ok(D {})
+        }
+    }
+    impl D {
+        /// Convenience wrapper around [`DPre::new`] and
+        /// [`DPre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<D> {
+            let pre = linker.instantiate_pre(component)?;
+            DPre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`DIndices::new_instance`] and
+        /// [`DIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<D> {
+            let indices = DIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            U: foo::foo::a::Host + foo::foo::b::Host + foo::foo::c::Host + d::Host,
+        {
+            foo::foo::a::add_to_linker(linker, get)?;
+            foo::foo::b::add_to_linker(linker, get)?;
+            foo::foo::c::add_to_linker(linker, get)?;
+            d::add_to_linker(linker, get)?;
+            Ok(())
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod a {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone, Copy)]
+            pub struct Foo {}
+            impl core::fmt::Debug for Foo {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("Foo").finish()
+                }
+            }
+            const _: () = {
+                assert!(0 == < Foo as wasmtime::component::ComponentType >::SIZE32);
+                assert!(1 == < Foo as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            pub trait Host {
+                fn a(&mut self) -> Foo;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/a")?;
+                inst.func_wrap(
+                    "a",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::a(host);
+                        Ok((r,))
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {
+                fn a(&mut self) -> Foo {
+                    Host::a(*self)
+                }
+            }
+        }
+        #[allow(clippy::all)]
+        pub mod b {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub type Foo = super::super::super::foo::foo::a::Foo;
+            const _: () = {
+                assert!(0 == < Foo as wasmtime::component::ComponentType >::SIZE32);
+                assert!(1 == < Foo as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            pub trait Host {
+                fn a(&mut self) -> Foo;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/b")?;
+                inst.func_wrap(
+                    "a",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::a(host);
+                        Ok((r,))
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {
+                fn a(&mut self) -> Foo {
+                    Host::a(*self)
+                }
+            }
+        }
+        #[allow(clippy::all)]
+        pub mod c {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub type Foo = super::super::super::foo::foo::b::Foo;
+            const _: () = {
+                assert!(0 == < Foo as wasmtime::component::ComponentType >::SIZE32);
+                assert!(1 == < Foo as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            pub trait Host {
+                fn a(&mut self) -> Foo;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/c")?;
+                inst.func_wrap(
+                    "a",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::a(host);
+                        Ok((r,))
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {
+                fn a(&mut self) -> Foo {
+                    Host::a(*self)
+                }
+            }
+        }
+    }
+}
+#[allow(clippy::all)]
+pub mod d {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    pub type Foo = super::foo::foo::c::Foo;
+    const _: () = {
+        assert!(0 == < Foo as wasmtime::component::ComponentType >::SIZE32);
+        assert!(1 == < Foo as wasmtime::component::ComponentType >::ALIGN32);
+    };
+    pub trait Host {
+        fn b(&mut self) -> Foo;
+    }
+    pub trait GetHost<
+        T,
+    >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+        type Host: Host;
+    }
+    impl<F, T, O> GetHost<T> for F
+    where
+        F: Fn(T) -> O + Send + Sync + Copy + 'static,
+        O: Host,
+    {
+        type Host = O;
+    }
+    pub fn add_to_linker_get_host<T>(
+        linker: &mut wasmtime::component::Linker<T>,
+        host_getter: impl for<'a> GetHost<&'a mut T>,
+    ) -> wasmtime::Result<()> {
+        let mut inst = linker.instance("d")?;
+        inst.func_wrap(
+            "b",
+            move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                let host = &mut host_getter(caller.data_mut());
+                let r = Host::b(host);
+                Ok((r,))
+            },
+        )?;
+        Ok(())
+    }
+    pub fn add_to_linker<T, U>(
+        linker: &mut wasmtime::component::Linker<T>,
+        get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+    ) -> wasmtime::Result<()>
+    where
+        U: Host,
+    {
+        add_to_linker_get_host(linker, get)
+    }
+    impl<_T: Host + ?Sized> Host for &mut _T {
+        fn b(&mut self) -> Foo {
+            Host::b(*self)
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/use-paths_async.rs b/crates/component-macro/tests/expanded/use-paths_async.rs
new file mode 100644
index 000000000000..71860e460cef
--- /dev/null
+++ b/crates/component-macro/tests/expanded/use-paths_async.rs
@@ -0,0 +1,434 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `d`.
+///
+/// This structure is created through [`DPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`D`] as well.
+pub struct DPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: DIndices,
+}
+impl<T> Clone for DPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> DPre<_T> {
+    /// Creates a new copy of `DPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = DIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`D`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<D>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `d`.
+///
+/// This is an implementation detail of [`DPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`D`] as well.
+#[derive(Clone)]
+pub struct DIndices {}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `d`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`D::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`DPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`DPre::instantiate_async`] to
+///   create a [`D`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`D::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`DIndices::new_instance`] followed
+///   by [`DIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct D {}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl DIndices {
+        /// Creates a new copy of `DIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            Ok(DIndices {})
+        }
+        /// Creates a new instance of [`DIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`D`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`D`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            Ok(DIndices {})
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`D`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<D> {
+            let _instance = instance;
+            Ok(D {})
+        }
+    }
+    impl D {
+        /// Convenience wrapper around [`DPre::new`] and
+        /// [`DPre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<D>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            DPre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`DIndices::new_instance`] and
+        /// [`DIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<D> {
+            let indices = DIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+            U: foo::foo::a::Host + foo::foo::b::Host + foo::foo::c::Host + d::Host
+                + Send,
+        {
+            foo::foo::a::add_to_linker(linker, get)?;
+            foo::foo::b::add_to_linker(linker, get)?;
+            foo::foo::c::add_to_linker(linker, get)?;
+            d::add_to_linker(linker, get)?;
+            Ok(())
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod a {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone, Copy)]
+            pub struct Foo {}
+            impl core::fmt::Debug for Foo {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("Foo").finish()
+                }
+            }
+            const _: () = {
+                assert!(0 == < Foo as wasmtime::component::ComponentType >::SIZE32);
+                assert!(1 == < Foo as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {
+                async fn a(&mut self) -> Foo;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/a")?;
+                inst.func_wrap_async(
+                    "a",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::a(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {
+                async fn a(&mut self) -> Foo {
+                    Host::a(*self).await
+                }
+            }
+        }
+        #[allow(clippy::all)]
+        pub mod b {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub type Foo = super::super::super::foo::foo::a::Foo;
+            const _: () = {
+                assert!(0 == < Foo as wasmtime::component::ComponentType >::SIZE32);
+                assert!(1 == < Foo as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {
+                async fn a(&mut self) -> Foo;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/b")?;
+                inst.func_wrap_async(
+                    "a",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::a(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {
+                async fn a(&mut self) -> Foo {
+                    Host::a(*self).await
+                }
+            }
+        }
+        #[allow(clippy::all)]
+        pub mod c {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub type Foo = super::super::super::foo::foo::b::Foo;
+            const _: () = {
+                assert!(0 == < Foo as wasmtime::component::ComponentType >::SIZE32);
+                assert!(1 == < Foo as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {
+                async fn a(&mut self) -> Foo;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/c")?;
+                inst.func_wrap_async(
+                    "a",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::a(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {
+                async fn a(&mut self) -> Foo {
+                    Host::a(*self).await
+                }
+            }
+        }
+    }
+}
+#[allow(clippy::all)]
+pub mod d {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    pub type Foo = super::foo::foo::c::Foo;
+    const _: () = {
+        assert!(0 == < Foo as wasmtime::component::ComponentType >::SIZE32);
+        assert!(1 == < Foo as wasmtime::component::ComponentType >::ALIGN32);
+    };
+    #[wasmtime::component::__internal::async_trait]
+    pub trait Host: Send {
+        async fn b(&mut self) -> Foo;
+    }
+    pub trait GetHost<
+        T,
+    >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+        type Host: Host + Send;
+    }
+    impl<F, T, O> GetHost<T> for F
+    where
+        F: Fn(T) -> O + Send + Sync + Copy + 'static,
+        O: Host + Send,
+    {
+        type Host = O;
+    }
+    pub fn add_to_linker_get_host<T>(
+        linker: &mut wasmtime::component::Linker<T>,
+        host_getter: impl for<'a> GetHost<&'a mut T>,
+    ) -> wasmtime::Result<()>
+    where
+        T: Send,
+    {
+        let mut inst = linker.instance("d")?;
+        inst.func_wrap_async(
+            "b",
+            move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                let host = &mut host_getter(caller.data_mut());
+                let r = Host::b(host).await;
+                Ok((r,))
+            }),
+        )?;
+        Ok(())
+    }
+    pub fn add_to_linker<T, U>(
+        linker: &mut wasmtime::component::Linker<T>,
+        get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+    ) -> wasmtime::Result<()>
+    where
+        U: Host + Send,
+        T: Send,
+    {
+        add_to_linker_get_host(linker, get)
+    }
+    #[wasmtime::component::__internal::async_trait]
+    impl<_T: Host + ?Sized + Send> Host for &mut _T {
+        async fn b(&mut self) -> Foo {
+            Host::b(*self).await
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/variants.rs b/crates/component-macro/tests/expanded/variants.rs
new file mode 100644
index 000000000000..3e67dc0d976d
--- /dev/null
+++ b/crates/component-macro/tests/expanded/variants.rs
@@ -0,0 +1,2016 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `my-world`.
+///
+/// This structure is created through [`MyWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`MyWorld`] as well.
+pub struct MyWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: MyWorldIndices,
+}
+impl<T> Clone for MyWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> MyWorldPre<_T> {
+    /// Creates a new copy of `MyWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = MyWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`MyWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<MyWorld> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `my-world`.
+///
+/// This is an implementation detail of [`MyWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`MyWorld`] as well.
+#[derive(Clone)]
+pub struct MyWorldIndices {
+    interface0: exports::foo::foo::variants::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `my-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`MyWorld::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`MyWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`MyWorldPre::instantiate`] to
+///   create a [`MyWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`MyWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`MyWorldIndices::new_instance`] followed
+///   by [`MyWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct MyWorld {
+    interface0: exports::foo::foo::variants::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl MyWorldIndices {
+        /// Creates a new copy of `MyWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::variants::GuestIndices::new(_component)?;
+            Ok(MyWorldIndices { interface0 })
+        }
+        /// Creates a new instance of [`MyWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`MyWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`MyWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::variants::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(MyWorldIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`MyWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<MyWorld> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(MyWorld { interface0 })
+        }
+    }
+    impl MyWorld {
+        /// Convenience wrapper around [`MyWorldPre::new`] and
+        /// [`MyWorldPre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<MyWorld> {
+            let pre = linker.instantiate_pre(component)?;
+            MyWorldPre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`MyWorldIndices::new_instance`] and
+        /// [`MyWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<MyWorld> {
+            let indices = MyWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            U: foo::foo::variants::Host,
+        {
+            foo::foo::variants::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_variants(&self) -> &exports::foo::foo::variants::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod variants {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(enum)]
+            #[derive(Clone, Copy, Eq, PartialEq)]
+            #[repr(u8)]
+            pub enum E1 {
+                #[component(name = "a")]
+                A,
+            }
+            impl core::fmt::Debug for E1 {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    match self {
+                        E1::A => f.debug_tuple("E1::A").finish(),
+                    }
+                }
+            }
+            const _: () = {
+                assert!(1 == < E1 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(1 == < E1 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone, Copy)]
+            pub struct Empty {}
+            impl core::fmt::Debug for Empty {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("Empty").finish()
+                }
+            }
+            const _: () = {
+                assert!(0 == < Empty as wasmtime::component::ComponentType >::SIZE32);
+                assert!(1 == < Empty as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(variant)]
+            #[derive(Clone)]
+            pub enum V1 {
+                #[component(name = "a")]
+                A,
+                #[component(name = "c")]
+                C(E1),
+                #[component(name = "d")]
+                D(wasmtime::component::__internal::String),
+                #[component(name = "e")]
+                E(Empty),
+                #[component(name = "f")]
+                F,
+                #[component(name = "g")]
+                G(u32),
+            }
+            impl core::fmt::Debug for V1 {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    match self {
+                        V1::A => f.debug_tuple("V1::A").finish(),
+                        V1::C(e) => f.debug_tuple("V1::C").field(e).finish(),
+                        V1::D(e) => f.debug_tuple("V1::D").field(e).finish(),
+                        V1::E(e) => f.debug_tuple("V1::E").field(e).finish(),
+                        V1::F => f.debug_tuple("V1::F").finish(),
+                        V1::G(e) => f.debug_tuple("V1::G").field(e).finish(),
+                    }
+                }
+            }
+            const _: () = {
+                assert!(12 == < V1 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(4 == < V1 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(variant)]
+            #[derive(Clone, Copy)]
+            pub enum Casts1 {
+                #[component(name = "a")]
+                A(i32),
+                #[component(name = "b")]
+                B(f32),
+            }
+            impl core::fmt::Debug for Casts1 {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    match self {
+                        Casts1::A(e) => f.debug_tuple("Casts1::A").field(e).finish(),
+                        Casts1::B(e) => f.debug_tuple("Casts1::B").field(e).finish(),
+                    }
+                }
+            }
+            const _: () = {
+                assert!(8 == < Casts1 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(4 == < Casts1 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(variant)]
+            #[derive(Clone, Copy)]
+            pub enum Casts2 {
+                #[component(name = "a")]
+                A(f64),
+                #[component(name = "b")]
+                B(f32),
+            }
+            impl core::fmt::Debug for Casts2 {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    match self {
+                        Casts2::A(e) => f.debug_tuple("Casts2::A").field(e).finish(),
+                        Casts2::B(e) => f.debug_tuple("Casts2::B").field(e).finish(),
+                    }
+                }
+            }
+            const _: () = {
+                assert!(16 == < Casts2 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(8 == < Casts2 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(variant)]
+            #[derive(Clone, Copy)]
+            pub enum Casts3 {
+                #[component(name = "a")]
+                A(f64),
+                #[component(name = "b")]
+                B(u64),
+            }
+            impl core::fmt::Debug for Casts3 {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    match self {
+                        Casts3::A(e) => f.debug_tuple("Casts3::A").field(e).finish(),
+                        Casts3::B(e) => f.debug_tuple("Casts3::B").field(e).finish(),
+                    }
+                }
+            }
+            const _: () = {
+                assert!(16 == < Casts3 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(8 == < Casts3 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(variant)]
+            #[derive(Clone, Copy)]
+            pub enum Casts4 {
+                #[component(name = "a")]
+                A(u32),
+                #[component(name = "b")]
+                B(i64),
+            }
+            impl core::fmt::Debug for Casts4 {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    match self {
+                        Casts4::A(e) => f.debug_tuple("Casts4::A").field(e).finish(),
+                        Casts4::B(e) => f.debug_tuple("Casts4::B").field(e).finish(),
+                    }
+                }
+            }
+            const _: () = {
+                assert!(16 == < Casts4 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(8 == < Casts4 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(variant)]
+            #[derive(Clone, Copy)]
+            pub enum Casts5 {
+                #[component(name = "a")]
+                A(f32),
+                #[component(name = "b")]
+                B(i64),
+            }
+            impl core::fmt::Debug for Casts5 {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    match self {
+                        Casts5::A(e) => f.debug_tuple("Casts5::A").field(e).finish(),
+                        Casts5::B(e) => f.debug_tuple("Casts5::B").field(e).finish(),
+                    }
+                }
+            }
+            const _: () = {
+                assert!(16 == < Casts5 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(8 == < Casts5 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(variant)]
+            #[derive(Clone, Copy)]
+            pub enum Casts6 {
+                #[component(name = "a")]
+                A((f32, u32)),
+                #[component(name = "b")]
+                B((u32, u32)),
+            }
+            impl core::fmt::Debug for Casts6 {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    match self {
+                        Casts6::A(e) => f.debug_tuple("Casts6::A").field(e).finish(),
+                        Casts6::B(e) => f.debug_tuple("Casts6::B").field(e).finish(),
+                    }
+                }
+            }
+            const _: () = {
+                assert!(12 == < Casts6 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(4 == < Casts6 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(enum)]
+            #[derive(Clone, Copy, Eq, PartialEq)]
+            #[repr(u8)]
+            pub enum MyErrno {
+                #[component(name = "bad1")]
+                Bad1,
+                #[component(name = "bad2")]
+                Bad2,
+            }
+            impl MyErrno {
+                pub fn name(&self) -> &'static str {
+                    match self {
+                        MyErrno::Bad1 => "bad1",
+                        MyErrno::Bad2 => "bad2",
+                    }
+                }
+                pub fn message(&self) -> &'static str {
+                    match self {
+                        MyErrno::Bad1 => "",
+                        MyErrno::Bad2 => "",
+                    }
+                }
+            }
+            impl core::fmt::Debug for MyErrno {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("MyErrno")
+                        .field("code", &(*self as i32))
+                        .field("name", &self.name())
+                        .field("message", &self.message())
+                        .finish()
+                }
+            }
+            impl core::fmt::Display for MyErrno {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    write!(f, "{} (error {})", self.name(), * self as i32)
+                }
+            }
+            impl std::error::Error for MyErrno {}
+            const _: () = {
+                assert!(1 == < MyErrno as wasmtime::component::ComponentType >::SIZE32);
+                assert!(1 == < MyErrno as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone)]
+            pub struct IsClone {
+                #[component(name = "v1")]
+                pub v1: V1,
+            }
+            impl core::fmt::Debug for IsClone {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("IsClone").field("v1", &self.v1).finish()
+                }
+            }
+            const _: () = {
+                assert!(12 == < IsClone as wasmtime::component::ComponentType >::SIZE32);
+                assert!(4 == < IsClone as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            pub trait Host {
+                fn e1_arg(&mut self, x: E1) -> ();
+                fn e1_result(&mut self) -> E1;
+                fn v1_arg(&mut self, x: V1) -> ();
+                fn v1_result(&mut self) -> V1;
+                fn bool_arg(&mut self, x: bool) -> ();
+                fn bool_result(&mut self) -> bool;
+                fn option_arg(
+                    &mut self,
+                    a: Option<bool>,
+                    b: Option<()>,
+                    c: Option<u32>,
+                    d: Option<E1>,
+                    e: Option<f32>,
+                    g: Option<Option<bool>>,
+                ) -> ();
+                fn option_result(
+                    &mut self,
+                ) -> (
+                    Option<bool>,
+                    Option<()>,
+                    Option<u32>,
+                    Option<E1>,
+                    Option<f32>,
+                    Option<Option<bool>>,
+                );
+                fn casts(
+                    &mut self,
+                    a: Casts1,
+                    b: Casts2,
+                    c: Casts3,
+                    d: Casts4,
+                    e: Casts5,
+                    f: Casts6,
+                ) -> (Casts1, Casts2, Casts3, Casts4, Casts5, Casts6);
+                fn result_arg(
+                    &mut self,
+                    a: Result<(), ()>,
+                    b: Result<(), E1>,
+                    c: Result<E1, ()>,
+                    d: Result<(), ()>,
+                    e: Result<u32, V1>,
+                    f: Result<
+                        wasmtime::component::__internal::String,
+                        wasmtime::component::__internal::Vec<u8>,
+                    >,
+                ) -> ();
+                fn result_result(
+                    &mut self,
+                ) -> (
+                    Result<(), ()>,
+                    Result<(), E1>,
+                    Result<E1, ()>,
+                    Result<(), ()>,
+                    Result<u32, V1>,
+                    Result<
+                        wasmtime::component::__internal::String,
+                        wasmtime::component::__internal::Vec<u8>,
+                    >,
+                );
+                fn return_result_sugar(&mut self) -> Result<i32, MyErrno>;
+                fn return_result_sugar2(&mut self) -> Result<(), MyErrno>;
+                fn return_result_sugar3(&mut self) -> Result<MyErrno, MyErrno>;
+                fn return_result_sugar4(&mut self) -> Result<(i32, u32), MyErrno>;
+                fn return_option_sugar(&mut self) -> Option<i32>;
+                fn return_option_sugar2(&mut self) -> Option<MyErrno>;
+                fn result_simple(&mut self) -> Result<u32, i32>;
+                fn is_clone_arg(&mut self, a: IsClone) -> ();
+                fn is_clone_return(&mut self) -> IsClone;
+                fn return_named_option(&mut self) -> Option<u8>;
+                fn return_named_result(&mut self) -> Result<u8, MyErrno>;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/variants")?;
+                inst.func_wrap(
+                    "e1-arg",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (E1,)| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::e1_arg(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "e1-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::e1_result(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "v1-arg",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (V1,)| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::v1_arg(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "v1-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::v1_result(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "bool-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (bool,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::bool_arg(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "bool-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::bool_result(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "option-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (
+                            arg0,
+                            arg1,
+                            arg2,
+                            arg3,
+                            arg4,
+                            arg5,
+                        ): (
+                            Option<bool>,
+                            Option<()>,
+                            Option<u32>,
+                            Option<E1>,
+                            Option<f32>,
+                            Option<Option<bool>>,
+                        )|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::option_arg(
+                            host,
+                            arg0,
+                            arg1,
+                            arg2,
+                            arg3,
+                            arg4,
+                            arg5,
+                        );
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "option-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::option_result(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "casts",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (
+                            arg0,
+                            arg1,
+                            arg2,
+                            arg3,
+                            arg4,
+                            arg5,
+                        ): (Casts1, Casts2, Casts3, Casts4, Casts5, Casts6)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::casts(host, arg0, arg1, arg2, arg3, arg4, arg5);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "result-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (
+                            arg0,
+                            arg1,
+                            arg2,
+                            arg3,
+                            arg4,
+                            arg5,
+                        ): (
+                            Result<(), ()>,
+                            Result<(), E1>,
+                            Result<E1, ()>,
+                            Result<(), ()>,
+                            Result<u32, V1>,
+                            Result<
+                                wasmtime::component::__internal::String,
+                                wasmtime::component::__internal::Vec<u8>,
+                            >,
+                        )|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::result_arg(
+                            host,
+                            arg0,
+                            arg1,
+                            arg2,
+                            arg3,
+                            arg4,
+                            arg5,
+                        );
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "result-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::result_result(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "return-result-sugar",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::return_result_sugar(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "return-result-sugar2",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::return_result_sugar2(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "return-result-sugar3",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::return_result_sugar3(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "return-result-sugar4",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::return_result_sugar4(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "return-option-sugar",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::return_option_sugar(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "return-option-sugar2",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::return_option_sugar2(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "result-simple",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::result_simple(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "is-clone-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (IsClone,)|
+                    {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::is_clone_arg(host, arg0);
+                        Ok(r)
+                    },
+                )?;
+                inst.func_wrap(
+                    "is-clone-return",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::is_clone_return(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "return-named-option",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::return_named_option(host);
+                        Ok((r,))
+                    },
+                )?;
+                inst.func_wrap(
+                    "return-named-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::return_named_result(host);
+                        Ok((r,))
+                    },
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {
+                fn e1_arg(&mut self, x: E1) -> () {
+                    Host::e1_arg(*self, x)
+                }
+                fn e1_result(&mut self) -> E1 {
+                    Host::e1_result(*self)
+                }
+                fn v1_arg(&mut self, x: V1) -> () {
+                    Host::v1_arg(*self, x)
+                }
+                fn v1_result(&mut self) -> V1 {
+                    Host::v1_result(*self)
+                }
+                fn bool_arg(&mut self, x: bool) -> () {
+                    Host::bool_arg(*self, x)
+                }
+                fn bool_result(&mut self) -> bool {
+                    Host::bool_result(*self)
+                }
+                fn option_arg(
+                    &mut self,
+                    a: Option<bool>,
+                    b: Option<()>,
+                    c: Option<u32>,
+                    d: Option<E1>,
+                    e: Option<f32>,
+                    g: Option<Option<bool>>,
+                ) -> () {
+                    Host::option_arg(*self, a, b, c, d, e, g)
+                }
+                fn option_result(
+                    &mut self,
+                ) -> (
+                    Option<bool>,
+                    Option<()>,
+                    Option<u32>,
+                    Option<E1>,
+                    Option<f32>,
+                    Option<Option<bool>>,
+                ) {
+                    Host::option_result(*self)
+                }
+                fn casts(
+                    &mut self,
+                    a: Casts1,
+                    b: Casts2,
+                    c: Casts3,
+                    d: Casts4,
+                    e: Casts5,
+                    f: Casts6,
+                ) -> (Casts1, Casts2, Casts3, Casts4, Casts5, Casts6) {
+                    Host::casts(*self, a, b, c, d, e, f)
+                }
+                fn result_arg(
+                    &mut self,
+                    a: Result<(), ()>,
+                    b: Result<(), E1>,
+                    c: Result<E1, ()>,
+                    d: Result<(), ()>,
+                    e: Result<u32, V1>,
+                    f: Result<
+                        wasmtime::component::__internal::String,
+                        wasmtime::component::__internal::Vec<u8>,
+                    >,
+                ) -> () {
+                    Host::result_arg(*self, a, b, c, d, e, f)
+                }
+                fn result_result(
+                    &mut self,
+                ) -> (
+                    Result<(), ()>,
+                    Result<(), E1>,
+                    Result<E1, ()>,
+                    Result<(), ()>,
+                    Result<u32, V1>,
+                    Result<
+                        wasmtime::component::__internal::String,
+                        wasmtime::component::__internal::Vec<u8>,
+                    >,
+                ) {
+                    Host::result_result(*self)
+                }
+                fn return_result_sugar(&mut self) -> Result<i32, MyErrno> {
+                    Host::return_result_sugar(*self)
+                }
+                fn return_result_sugar2(&mut self) -> Result<(), MyErrno> {
+                    Host::return_result_sugar2(*self)
+                }
+                fn return_result_sugar3(&mut self) -> Result<MyErrno, MyErrno> {
+                    Host::return_result_sugar3(*self)
+                }
+                fn return_result_sugar4(&mut self) -> Result<(i32, u32), MyErrno> {
+                    Host::return_result_sugar4(*self)
+                }
+                fn return_option_sugar(&mut self) -> Option<i32> {
+                    Host::return_option_sugar(*self)
+                }
+                fn return_option_sugar2(&mut self) -> Option<MyErrno> {
+                    Host::return_option_sugar2(*self)
+                }
+                fn result_simple(&mut self) -> Result<u32, i32> {
+                    Host::result_simple(*self)
+                }
+                fn is_clone_arg(&mut self, a: IsClone) -> () {
+                    Host::is_clone_arg(*self, a)
+                }
+                fn is_clone_return(&mut self) -> IsClone {
+                    Host::is_clone_return(*self)
+                }
+                fn return_named_option(&mut self) -> Option<u8> {
+                    Host::return_named_option(*self)
+                }
+                fn return_named_result(&mut self) -> Result<u8, MyErrno> {
+                    Host::return_named_result(*self)
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod variants {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(enum)]
+                #[derive(Clone, Copy, Eq, PartialEq)]
+                #[repr(u8)]
+                pub enum E1 {
+                    #[component(name = "a")]
+                    A,
+                }
+                impl core::fmt::Debug for E1 {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        match self {
+                            E1::A => f.debug_tuple("E1::A").finish(),
+                        }
+                    }
+                }
+                const _: () = {
+                    assert!(1 == < E1 as wasmtime::component::ComponentType >::SIZE32);
+                    assert!(1 == < E1 as wasmtime::component::ComponentType >::ALIGN32);
+                };
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(record)]
+                #[derive(Clone, Copy)]
+                pub struct Empty {}
+                impl core::fmt::Debug for Empty {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        f.debug_struct("Empty").finish()
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        0 == < Empty as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        1 == < Empty as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(variant)]
+                #[derive(Clone)]
+                pub enum V1 {
+                    #[component(name = "a")]
+                    A,
+                    #[component(name = "c")]
+                    C(E1),
+                    #[component(name = "d")]
+                    D(wasmtime::component::__internal::String),
+                    #[component(name = "e")]
+                    E(Empty),
+                    #[component(name = "f")]
+                    F,
+                    #[component(name = "g")]
+                    G(u32),
+                }
+                impl core::fmt::Debug for V1 {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        match self {
+                            V1::A => f.debug_tuple("V1::A").finish(),
+                            V1::C(e) => f.debug_tuple("V1::C").field(e).finish(),
+                            V1::D(e) => f.debug_tuple("V1::D").field(e).finish(),
+                            V1::E(e) => f.debug_tuple("V1::E").field(e).finish(),
+                            V1::F => f.debug_tuple("V1::F").finish(),
+                            V1::G(e) => f.debug_tuple("V1::G").field(e).finish(),
+                        }
+                    }
+                }
+                const _: () = {
+                    assert!(12 == < V1 as wasmtime::component::ComponentType >::SIZE32);
+                    assert!(4 == < V1 as wasmtime::component::ComponentType >::ALIGN32);
+                };
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(variant)]
+                #[derive(Clone, Copy)]
+                pub enum Casts1 {
+                    #[component(name = "a")]
+                    A(i32),
+                    #[component(name = "b")]
+                    B(f32),
+                }
+                impl core::fmt::Debug for Casts1 {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        match self {
+                            Casts1::A(e) => f.debug_tuple("Casts1::A").field(e).finish(),
+                            Casts1::B(e) => f.debug_tuple("Casts1::B").field(e).finish(),
+                        }
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        8 == < Casts1 as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        4 == < Casts1 as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(variant)]
+                #[derive(Clone, Copy)]
+                pub enum Casts2 {
+                    #[component(name = "a")]
+                    A(f64),
+                    #[component(name = "b")]
+                    B(f32),
+                }
+                impl core::fmt::Debug for Casts2 {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        match self {
+                            Casts2::A(e) => f.debug_tuple("Casts2::A").field(e).finish(),
+                            Casts2::B(e) => f.debug_tuple("Casts2::B").field(e).finish(),
+                        }
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        16 == < Casts2 as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        8 == < Casts2 as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(variant)]
+                #[derive(Clone, Copy)]
+                pub enum Casts3 {
+                    #[component(name = "a")]
+                    A(f64),
+                    #[component(name = "b")]
+                    B(u64),
+                }
+                impl core::fmt::Debug for Casts3 {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        match self {
+                            Casts3::A(e) => f.debug_tuple("Casts3::A").field(e).finish(),
+                            Casts3::B(e) => f.debug_tuple("Casts3::B").field(e).finish(),
+                        }
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        16 == < Casts3 as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        8 == < Casts3 as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(variant)]
+                #[derive(Clone, Copy)]
+                pub enum Casts4 {
+                    #[component(name = "a")]
+                    A(u32),
+                    #[component(name = "b")]
+                    B(i64),
+                }
+                impl core::fmt::Debug for Casts4 {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        match self {
+                            Casts4::A(e) => f.debug_tuple("Casts4::A").field(e).finish(),
+                            Casts4::B(e) => f.debug_tuple("Casts4::B").field(e).finish(),
+                        }
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        16 == < Casts4 as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        8 == < Casts4 as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(variant)]
+                #[derive(Clone, Copy)]
+                pub enum Casts5 {
+                    #[component(name = "a")]
+                    A(f32),
+                    #[component(name = "b")]
+                    B(i64),
+                }
+                impl core::fmt::Debug for Casts5 {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        match self {
+                            Casts5::A(e) => f.debug_tuple("Casts5::A").field(e).finish(),
+                            Casts5::B(e) => f.debug_tuple("Casts5::B").field(e).finish(),
+                        }
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        16 == < Casts5 as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        8 == < Casts5 as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(variant)]
+                #[derive(Clone, Copy)]
+                pub enum Casts6 {
+                    #[component(name = "a")]
+                    A((f32, u32)),
+                    #[component(name = "b")]
+                    B((u32, u32)),
+                }
+                impl core::fmt::Debug for Casts6 {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        match self {
+                            Casts6::A(e) => f.debug_tuple("Casts6::A").field(e).finish(),
+                            Casts6::B(e) => f.debug_tuple("Casts6::B").field(e).finish(),
+                        }
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        12 == < Casts6 as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        4 == < Casts6 as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(enum)]
+                #[derive(Clone, Copy, Eq, PartialEq)]
+                #[repr(u8)]
+                pub enum MyErrno {
+                    #[component(name = "bad1")]
+                    Bad1,
+                    #[component(name = "bad2")]
+                    Bad2,
+                }
+                impl MyErrno {
+                    pub fn name(&self) -> &'static str {
+                        match self {
+                            MyErrno::Bad1 => "bad1",
+                            MyErrno::Bad2 => "bad2",
+                        }
+                    }
+                    pub fn message(&self) -> &'static str {
+                        match self {
+                            MyErrno::Bad1 => "",
+                            MyErrno::Bad2 => "",
+                        }
+                    }
+                }
+                impl core::fmt::Debug for MyErrno {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        f.debug_struct("MyErrno")
+                            .field("code", &(*self as i32))
+                            .field("name", &self.name())
+                            .field("message", &self.message())
+                            .finish()
+                    }
+                }
+                impl core::fmt::Display for MyErrno {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        write!(f, "{} (error {})", self.name(), * self as i32)
+                    }
+                }
+                impl std::error::Error for MyErrno {}
+                const _: () = {
+                    assert!(
+                        1 == < MyErrno as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        1 == < MyErrno as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(record)]
+                #[derive(Clone)]
+                pub struct IsClone {
+                    #[component(name = "v1")]
+                    pub v1: V1,
+                }
+                impl core::fmt::Debug for IsClone {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        f.debug_struct("IsClone").field("v1", &self.v1).finish()
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        12 == < IsClone as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        4 == < IsClone as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                pub struct Guest {
+                    e1_arg: wasmtime::component::Func,
+                    e1_result: wasmtime::component::Func,
+                    v1_arg: wasmtime::component::Func,
+                    v1_result: wasmtime::component::Func,
+                    bool_arg: wasmtime::component::Func,
+                    bool_result: wasmtime::component::Func,
+                    option_arg: wasmtime::component::Func,
+                    option_result: wasmtime::component::Func,
+                    casts: wasmtime::component::Func,
+                    result_arg: wasmtime::component::Func,
+                    result_result: wasmtime::component::Func,
+                    return_result_sugar: wasmtime::component::Func,
+                    return_result_sugar2: wasmtime::component::Func,
+                    return_result_sugar3: wasmtime::component::Func,
+                    return_result_sugar4: wasmtime::component::Func,
+                    return_option_sugar: wasmtime::component::Func,
+                    return_option_sugar2: wasmtime::component::Func,
+                    result_simple: wasmtime::component::Func,
+                    is_clone_arg: wasmtime::component::Func,
+                    is_clone_return: wasmtime::component::Func,
+                    return_named_option: wasmtime::component::Func,
+                    return_named_result: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    e1_arg: wasmtime::component::ComponentExportIndex,
+                    e1_result: wasmtime::component::ComponentExportIndex,
+                    v1_arg: wasmtime::component::ComponentExportIndex,
+                    v1_result: wasmtime::component::ComponentExportIndex,
+                    bool_arg: wasmtime::component::ComponentExportIndex,
+                    bool_result: wasmtime::component::ComponentExportIndex,
+                    option_arg: wasmtime::component::ComponentExportIndex,
+                    option_result: wasmtime::component::ComponentExportIndex,
+                    casts: wasmtime::component::ComponentExportIndex,
+                    result_arg: wasmtime::component::ComponentExportIndex,
+                    result_result: wasmtime::component::ComponentExportIndex,
+                    return_result_sugar: wasmtime::component::ComponentExportIndex,
+                    return_result_sugar2: wasmtime::component::ComponentExportIndex,
+                    return_result_sugar3: wasmtime::component::ComponentExportIndex,
+                    return_result_sugar4: wasmtime::component::ComponentExportIndex,
+                    return_option_sugar: wasmtime::component::ComponentExportIndex,
+                    return_option_sugar2: wasmtime::component::ComponentExportIndex,
+                    result_simple: wasmtime::component::ComponentExportIndex,
+                    is_clone_arg: wasmtime::component::ComponentExportIndex,
+                    is_clone_return: wasmtime::component::ComponentExportIndex,
+                    return_named_option: wasmtime::component::ComponentExportIndex,
+                    return_named_result: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/variants")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/variants`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/variants")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/variants`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/variants` does \
+                    not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let e1_arg = lookup("e1-arg")?;
+                        let e1_result = lookup("e1-result")?;
+                        let v1_arg = lookup("v1-arg")?;
+                        let v1_result = lookup("v1-result")?;
+                        let bool_arg = lookup("bool-arg")?;
+                        let bool_result = lookup("bool-result")?;
+                        let option_arg = lookup("option-arg")?;
+                        let option_result = lookup("option-result")?;
+                        let casts = lookup("casts")?;
+                        let result_arg = lookup("result-arg")?;
+                        let result_result = lookup("result-result")?;
+                        let return_result_sugar = lookup("return-result-sugar")?;
+                        let return_result_sugar2 = lookup("return-result-sugar2")?;
+                        let return_result_sugar3 = lookup("return-result-sugar3")?;
+                        let return_result_sugar4 = lookup("return-result-sugar4")?;
+                        let return_option_sugar = lookup("return-option-sugar")?;
+                        let return_option_sugar2 = lookup("return-option-sugar2")?;
+                        let result_simple = lookup("result-simple")?;
+                        let is_clone_arg = lookup("is-clone-arg")?;
+                        let is_clone_return = lookup("is-clone-return")?;
+                        let return_named_option = lookup("return-named-option")?;
+                        let return_named_result = lookup("return-named-result")?;
+                        Ok(GuestIndices {
+                            e1_arg,
+                            e1_result,
+                            v1_arg,
+                            v1_result,
+                            bool_arg,
+                            bool_result,
+                            option_arg,
+                            option_result,
+                            casts,
+                            result_arg,
+                            result_result,
+                            return_result_sugar,
+                            return_result_sugar2,
+                            return_result_sugar3,
+                            return_result_sugar4,
+                            return_option_sugar,
+                            return_option_sugar2,
+                            result_simple,
+                            is_clone_arg,
+                            is_clone_return,
+                            return_named_option,
+                            return_named_result,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let e1_arg = *_instance
+                            .get_typed_func::<(E1,), ()>(&mut store, &self.e1_arg)?
+                            .func();
+                        let e1_result = *_instance
+                            .get_typed_func::<(), (E1,)>(&mut store, &self.e1_result)?
+                            .func();
+                        let v1_arg = *_instance
+                            .get_typed_func::<(&V1,), ()>(&mut store, &self.v1_arg)?
+                            .func();
+                        let v1_result = *_instance
+                            .get_typed_func::<(), (V1,)>(&mut store, &self.v1_result)?
+                            .func();
+                        let bool_arg = *_instance
+                            .get_typed_func::<(bool,), ()>(&mut store, &self.bool_arg)?
+                            .func();
+                        let bool_result = *_instance
+                            .get_typed_func::<
+                                (),
+                                (bool,),
+                            >(&mut store, &self.bool_result)?
+                            .func();
+                        let option_arg = *_instance
+                            .get_typed_func::<
+                                (
+                                    Option<bool>,
+                                    Option<()>,
+                                    Option<u32>,
+                                    Option<E1>,
+                                    Option<f32>,
+                                    Option<Option<bool>>,
+                                ),
+                                (),
+                            >(&mut store, &self.option_arg)?
+                            .func();
+                        let option_result = *_instance
+                            .get_typed_func::<
+                                (),
+                                (
+                                    (
+                                        Option<bool>,
+                                        Option<()>,
+                                        Option<u32>,
+                                        Option<E1>,
+                                        Option<f32>,
+                                        Option<Option<bool>>,
+                                    ),
+                                ),
+                            >(&mut store, &self.option_result)?
+                            .func();
+                        let casts = *_instance
+                            .get_typed_func::<
+                                (Casts1, Casts2, Casts3, Casts4, Casts5, Casts6),
+                                ((Casts1, Casts2, Casts3, Casts4, Casts5, Casts6),),
+                            >(&mut store, &self.casts)?
+                            .func();
+                        let result_arg = *_instance
+                            .get_typed_func::<
+                                (
+                                    Result<(), ()>,
+                                    Result<(), E1>,
+                                    Result<E1, ()>,
+                                    Result<(), ()>,
+                                    Result<u32, &V1>,
+                                    Result<&str, &[u8]>,
+                                ),
+                                (),
+                            >(&mut store, &self.result_arg)?
+                            .func();
+                        let result_result = *_instance
+                            .get_typed_func::<
+                                (),
+                                (
+                                    (
+                                        Result<(), ()>,
+                                        Result<(), E1>,
+                                        Result<E1, ()>,
+                                        Result<(), ()>,
+                                        Result<u32, V1>,
+                                        Result<
+                                            wasmtime::component::__internal::String,
+                                            wasmtime::component::__internal::Vec<u8>,
+                                        >,
+                                    ),
+                                ),
+                            >(&mut store, &self.result_result)?
+                            .func();
+                        let return_result_sugar = *_instance
+                            .get_typed_func::<
+                                (),
+                                (Result<i32, MyErrno>,),
+                            >(&mut store, &self.return_result_sugar)?
+                            .func();
+                        let return_result_sugar2 = *_instance
+                            .get_typed_func::<
+                                (),
+                                (Result<(), MyErrno>,),
+                            >(&mut store, &self.return_result_sugar2)?
+                            .func();
+                        let return_result_sugar3 = *_instance
+                            .get_typed_func::<
+                                (),
+                                (Result<MyErrno, MyErrno>,),
+                            >(&mut store, &self.return_result_sugar3)?
+                            .func();
+                        let return_result_sugar4 = *_instance
+                            .get_typed_func::<
+                                (),
+                                (Result<(i32, u32), MyErrno>,),
+                            >(&mut store, &self.return_result_sugar4)?
+                            .func();
+                        let return_option_sugar = *_instance
+                            .get_typed_func::<
+                                (),
+                                (Option<i32>,),
+                            >(&mut store, &self.return_option_sugar)?
+                            .func();
+                        let return_option_sugar2 = *_instance
+                            .get_typed_func::<
+                                (),
+                                (Option<MyErrno>,),
+                            >(&mut store, &self.return_option_sugar2)?
+                            .func();
+                        let result_simple = *_instance
+                            .get_typed_func::<
+                                (),
+                                (Result<u32, i32>,),
+                            >(&mut store, &self.result_simple)?
+                            .func();
+                        let is_clone_arg = *_instance
+                            .get_typed_func::<
+                                (&IsClone,),
+                                (),
+                            >(&mut store, &self.is_clone_arg)?
+                            .func();
+                        let is_clone_return = *_instance
+                            .get_typed_func::<
+                                (),
+                                (IsClone,),
+                            >(&mut store, &self.is_clone_return)?
+                            .func();
+                        let return_named_option = *_instance
+                            .get_typed_func::<
+                                (),
+                                (Option<u8>,),
+                            >(&mut store, &self.return_named_option)?
+                            .func();
+                        let return_named_result = *_instance
+                            .get_typed_func::<
+                                (),
+                                (Result<u8, MyErrno>,),
+                            >(&mut store, &self.return_named_result)?
+                            .func();
+                        Ok(Guest {
+                            e1_arg,
+                            e1_result,
+                            v1_arg,
+                            v1_result,
+                            bool_arg,
+                            bool_result,
+                            option_arg,
+                            option_result,
+                            casts,
+                            result_arg,
+                            result_result,
+                            return_result_sugar,
+                            return_result_sugar2,
+                            return_result_sugar3,
+                            return_result_sugar4,
+                            return_option_sugar,
+                            return_option_sugar2,
+                            result_simple,
+                            is_clone_arg,
+                            is_clone_return,
+                            return_named_option,
+                            return_named_result,
+                        })
+                    }
+                }
+                impl Guest {
+                    pub fn call_e1_arg<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: E1,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (E1,),
+                                (),
+                            >::new_unchecked(self.e1_arg)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_e1_result<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<E1> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (E1,),
+                            >::new_unchecked(self.e1_result)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_v1_arg<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &V1,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&V1,),
+                                (),
+                            >::new_unchecked(self.v1_arg)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_v1_result<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<V1> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (V1,),
+                            >::new_unchecked(self.v1_result)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_bool_arg<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: bool,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (bool,),
+                                (),
+                            >::new_unchecked(self.bool_arg)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_bool_result<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<bool> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (bool,),
+                            >::new_unchecked(self.bool_result)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_option_arg<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: Option<bool>,
+                        arg1: Option<()>,
+                        arg2: Option<u32>,
+                        arg3: Option<E1>,
+                        arg4: Option<f32>,
+                        arg5: Option<Option<bool>>,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (
+                                    Option<bool>,
+                                    Option<()>,
+                                    Option<u32>,
+                                    Option<E1>,
+                                    Option<f32>,
+                                    Option<Option<bool>>,
+                                ),
+                                (),
+                            >::new_unchecked(self.option_arg)
+                        };
+                        let () = callee
+                            .call(
+                                store.as_context_mut(),
+                                (arg0, arg1, arg2, arg3, arg4, arg5),
+                            )?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_option_result<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<
+                        (
+                            Option<bool>,
+                            Option<()>,
+                            Option<u32>,
+                            Option<E1>,
+                            Option<f32>,
+                            Option<Option<bool>>,
+                        ),
+                    > {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (
+                                    (
+                                        Option<bool>,
+                                        Option<()>,
+                                        Option<u32>,
+                                        Option<E1>,
+                                        Option<f32>,
+                                        Option<Option<bool>>,
+                                    ),
+                                ),
+                            >::new_unchecked(self.option_result)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_casts<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: Casts1,
+                        arg1: Casts2,
+                        arg2: Casts3,
+                        arg3: Casts4,
+                        arg4: Casts5,
+                        arg5: Casts6,
+                    ) -> wasmtime::Result<
+                        (Casts1, Casts2, Casts3, Casts4, Casts5, Casts6),
+                    > {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (Casts1, Casts2, Casts3, Casts4, Casts5, Casts6),
+                                ((Casts1, Casts2, Casts3, Casts4, Casts5, Casts6),),
+                            >::new_unchecked(self.casts)
+                        };
+                        let (ret0,) = callee
+                            .call(
+                                store.as_context_mut(),
+                                (arg0, arg1, arg2, arg3, arg4, arg5),
+                            )?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_result_arg<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: Result<(), ()>,
+                        arg1: Result<(), E1>,
+                        arg2: Result<E1, ()>,
+                        arg3: Result<(), ()>,
+                        arg4: Result<u32, &V1>,
+                        arg5: Result<&str, &[u8]>,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (
+                                    Result<(), ()>,
+                                    Result<(), E1>,
+                                    Result<E1, ()>,
+                                    Result<(), ()>,
+                                    Result<u32, &V1>,
+                                    Result<&str, &[u8]>,
+                                ),
+                                (),
+                            >::new_unchecked(self.result_arg)
+                        };
+                        let () = callee
+                            .call(
+                                store.as_context_mut(),
+                                (arg0, arg1, arg2, arg3, arg4, arg5),
+                            )?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_result_result<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<
+                        (
+                            Result<(), ()>,
+                            Result<(), E1>,
+                            Result<E1, ()>,
+                            Result<(), ()>,
+                            Result<u32, V1>,
+                            Result<
+                                wasmtime::component::__internal::String,
+                                wasmtime::component::__internal::Vec<u8>,
+                            >,
+                        ),
+                    > {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (
+                                    (
+                                        Result<(), ()>,
+                                        Result<(), E1>,
+                                        Result<E1, ()>,
+                                        Result<(), ()>,
+                                        Result<u32, V1>,
+                                        Result<
+                                            wasmtime::component::__internal::String,
+                                            wasmtime::component::__internal::Vec<u8>,
+                                        >,
+                                    ),
+                                ),
+                            >::new_unchecked(self.result_result)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_return_result_sugar<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<Result<i32, MyErrno>> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (Result<i32, MyErrno>,),
+                            >::new_unchecked(self.return_result_sugar)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_return_result_sugar2<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<Result<(), MyErrno>> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (Result<(), MyErrno>,),
+                            >::new_unchecked(self.return_result_sugar2)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_return_result_sugar3<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<Result<MyErrno, MyErrno>> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (Result<MyErrno, MyErrno>,),
+                            >::new_unchecked(self.return_result_sugar3)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_return_result_sugar4<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<Result<(i32, u32), MyErrno>> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (Result<(i32, u32), MyErrno>,),
+                            >::new_unchecked(self.return_result_sugar4)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_return_option_sugar<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<Option<i32>> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (Option<i32>,),
+                            >::new_unchecked(self.return_option_sugar)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_return_option_sugar2<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<Option<MyErrno>> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (Option<MyErrno>,),
+                            >::new_unchecked(self.return_option_sugar2)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_result_simple<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<Result<u32, i32>> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (Result<u32, i32>,),
+                            >::new_unchecked(self.result_simple)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_is_clone_arg<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &IsClone,
+                    ) -> wasmtime::Result<()> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&IsClone,),
+                                (),
+                            >::new_unchecked(self.is_clone_arg)
+                        };
+                        let () = callee.call(store.as_context_mut(), (arg0,))?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(())
+                    }
+                    pub fn call_is_clone_return<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<IsClone> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (IsClone,),
+                            >::new_unchecked(self.is_clone_return)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_return_named_option<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<Option<u8>> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (Option<u8>,),
+                            >::new_unchecked(self.return_named_option)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                    pub fn call_return_named_result<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<Result<u8, MyErrno>> {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (Result<u8, MyErrno>,),
+                            >::new_unchecked(self.return_named_result)
+                        };
+                        let (ret0,) = callee.call(store.as_context_mut(), ())?;
+                        callee.post_return(store.as_context_mut())?;
+                        Ok(ret0)
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/variants_async.rs b/crates/component-macro/tests/expanded/variants_async.rs
new file mode 100644
index 000000000000..e329d7d3b8ec
--- /dev/null
+++ b/crates/component-macro/tests/expanded/variants_async.rs
@@ -0,0 +1,2139 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `my-world`.
+///
+/// This structure is created through [`MyWorldPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`MyWorld`] as well.
+pub struct MyWorldPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: MyWorldIndices,
+}
+impl<T> Clone for MyWorldPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> MyWorldPre<_T> {
+    /// Creates a new copy of `MyWorldPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = MyWorldIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`MyWorld`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<MyWorld>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `my-world`.
+///
+/// This is an implementation detail of [`MyWorldPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`MyWorld`] as well.
+#[derive(Clone)]
+pub struct MyWorldIndices {
+    interface0: exports::foo::foo::variants::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `my-world`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`MyWorld::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`MyWorldPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`MyWorldPre::instantiate_async`] to
+///   create a [`MyWorld`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`MyWorld::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`MyWorldIndices::new_instance`] followed
+///   by [`MyWorldIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct MyWorld {
+    interface0: exports::foo::foo::variants::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl MyWorldIndices {
+        /// Creates a new copy of `MyWorldIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::foo::foo::variants::GuestIndices::new(_component)?;
+            Ok(MyWorldIndices { interface0 })
+        }
+        /// Creates a new instance of [`MyWorldIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`MyWorld`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`MyWorld`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::foo::foo::variants::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(MyWorldIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`MyWorld`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<MyWorld> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(MyWorld { interface0 })
+        }
+    }
+    impl MyWorld {
+        /// Convenience wrapper around [`MyWorldPre::new`] and
+        /// [`MyWorldPre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<MyWorld>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            MyWorldPre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`MyWorldIndices::new_instance`] and
+        /// [`MyWorldIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<MyWorld> {
+            let indices = MyWorldIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+            U: foo::foo::variants::Host + Send,
+        {
+            foo::foo::variants::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn foo_foo_variants(&self) -> &exports::foo::foo::variants::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod variants {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(enum)]
+            #[derive(Clone, Copy, Eq, PartialEq)]
+            #[repr(u8)]
+            pub enum E1 {
+                #[component(name = "a")]
+                A,
+            }
+            impl core::fmt::Debug for E1 {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    match self {
+                        E1::A => f.debug_tuple("E1::A").finish(),
+                    }
+                }
+            }
+            const _: () = {
+                assert!(1 == < E1 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(1 == < E1 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone, Copy)]
+            pub struct Empty {}
+            impl core::fmt::Debug for Empty {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("Empty").finish()
+                }
+            }
+            const _: () = {
+                assert!(0 == < Empty as wasmtime::component::ComponentType >::SIZE32);
+                assert!(1 == < Empty as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(variant)]
+            #[derive(Clone)]
+            pub enum V1 {
+                #[component(name = "a")]
+                A,
+                #[component(name = "c")]
+                C(E1),
+                #[component(name = "d")]
+                D(wasmtime::component::__internal::String),
+                #[component(name = "e")]
+                E(Empty),
+                #[component(name = "f")]
+                F,
+                #[component(name = "g")]
+                G(u32),
+            }
+            impl core::fmt::Debug for V1 {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    match self {
+                        V1::A => f.debug_tuple("V1::A").finish(),
+                        V1::C(e) => f.debug_tuple("V1::C").field(e).finish(),
+                        V1::D(e) => f.debug_tuple("V1::D").field(e).finish(),
+                        V1::E(e) => f.debug_tuple("V1::E").field(e).finish(),
+                        V1::F => f.debug_tuple("V1::F").finish(),
+                        V1::G(e) => f.debug_tuple("V1::G").field(e).finish(),
+                    }
+                }
+            }
+            const _: () = {
+                assert!(12 == < V1 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(4 == < V1 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(variant)]
+            #[derive(Clone, Copy)]
+            pub enum Casts1 {
+                #[component(name = "a")]
+                A(i32),
+                #[component(name = "b")]
+                B(f32),
+            }
+            impl core::fmt::Debug for Casts1 {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    match self {
+                        Casts1::A(e) => f.debug_tuple("Casts1::A").field(e).finish(),
+                        Casts1::B(e) => f.debug_tuple("Casts1::B").field(e).finish(),
+                    }
+                }
+            }
+            const _: () = {
+                assert!(8 == < Casts1 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(4 == < Casts1 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(variant)]
+            #[derive(Clone, Copy)]
+            pub enum Casts2 {
+                #[component(name = "a")]
+                A(f64),
+                #[component(name = "b")]
+                B(f32),
+            }
+            impl core::fmt::Debug for Casts2 {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    match self {
+                        Casts2::A(e) => f.debug_tuple("Casts2::A").field(e).finish(),
+                        Casts2::B(e) => f.debug_tuple("Casts2::B").field(e).finish(),
+                    }
+                }
+            }
+            const _: () = {
+                assert!(16 == < Casts2 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(8 == < Casts2 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(variant)]
+            #[derive(Clone, Copy)]
+            pub enum Casts3 {
+                #[component(name = "a")]
+                A(f64),
+                #[component(name = "b")]
+                B(u64),
+            }
+            impl core::fmt::Debug for Casts3 {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    match self {
+                        Casts3::A(e) => f.debug_tuple("Casts3::A").field(e).finish(),
+                        Casts3::B(e) => f.debug_tuple("Casts3::B").field(e).finish(),
+                    }
+                }
+            }
+            const _: () = {
+                assert!(16 == < Casts3 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(8 == < Casts3 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(variant)]
+            #[derive(Clone, Copy)]
+            pub enum Casts4 {
+                #[component(name = "a")]
+                A(u32),
+                #[component(name = "b")]
+                B(i64),
+            }
+            impl core::fmt::Debug for Casts4 {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    match self {
+                        Casts4::A(e) => f.debug_tuple("Casts4::A").field(e).finish(),
+                        Casts4::B(e) => f.debug_tuple("Casts4::B").field(e).finish(),
+                    }
+                }
+            }
+            const _: () = {
+                assert!(16 == < Casts4 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(8 == < Casts4 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(variant)]
+            #[derive(Clone, Copy)]
+            pub enum Casts5 {
+                #[component(name = "a")]
+                A(f32),
+                #[component(name = "b")]
+                B(i64),
+            }
+            impl core::fmt::Debug for Casts5 {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    match self {
+                        Casts5::A(e) => f.debug_tuple("Casts5::A").field(e).finish(),
+                        Casts5::B(e) => f.debug_tuple("Casts5::B").field(e).finish(),
+                    }
+                }
+            }
+            const _: () = {
+                assert!(16 == < Casts5 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(8 == < Casts5 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(variant)]
+            #[derive(Clone, Copy)]
+            pub enum Casts6 {
+                #[component(name = "a")]
+                A((f32, u32)),
+                #[component(name = "b")]
+                B((u32, u32)),
+            }
+            impl core::fmt::Debug for Casts6 {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    match self {
+                        Casts6::A(e) => f.debug_tuple("Casts6::A").field(e).finish(),
+                        Casts6::B(e) => f.debug_tuple("Casts6::B").field(e).finish(),
+                    }
+                }
+            }
+            const _: () = {
+                assert!(12 == < Casts6 as wasmtime::component::ComponentType >::SIZE32);
+                assert!(4 == < Casts6 as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(enum)]
+            #[derive(Clone, Copy, Eq, PartialEq)]
+            #[repr(u8)]
+            pub enum MyErrno {
+                #[component(name = "bad1")]
+                Bad1,
+                #[component(name = "bad2")]
+                Bad2,
+            }
+            impl MyErrno {
+                pub fn name(&self) -> &'static str {
+                    match self {
+                        MyErrno::Bad1 => "bad1",
+                        MyErrno::Bad2 => "bad2",
+                    }
+                }
+                pub fn message(&self) -> &'static str {
+                    match self {
+                        MyErrno::Bad1 => "",
+                        MyErrno::Bad2 => "",
+                    }
+                }
+            }
+            impl core::fmt::Debug for MyErrno {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("MyErrno")
+                        .field("code", &(*self as i32))
+                        .field("name", &self.name())
+                        .field("message", &self.message())
+                        .finish()
+                }
+            }
+            impl core::fmt::Display for MyErrno {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    write!(f, "{} (error {})", self.name(), * self as i32)
+                }
+            }
+            impl std::error::Error for MyErrno {}
+            const _: () = {
+                assert!(1 == < MyErrno as wasmtime::component::ComponentType >::SIZE32);
+                assert!(1 == < MyErrno as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[derive(wasmtime::component::ComponentType)]
+            #[derive(wasmtime::component::Lift)]
+            #[derive(wasmtime::component::Lower)]
+            #[component(record)]
+            #[derive(Clone)]
+            pub struct IsClone {
+                #[component(name = "v1")]
+                pub v1: V1,
+            }
+            impl core::fmt::Debug for IsClone {
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    f.debug_struct("IsClone").field("v1", &self.v1).finish()
+                }
+            }
+            const _: () = {
+                assert!(12 == < IsClone as wasmtime::component::ComponentType >::SIZE32);
+                assert!(4 == < IsClone as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {
+                async fn e1_arg(&mut self, x: E1) -> ();
+                async fn e1_result(&mut self) -> E1;
+                async fn v1_arg(&mut self, x: V1) -> ();
+                async fn v1_result(&mut self) -> V1;
+                async fn bool_arg(&mut self, x: bool) -> ();
+                async fn bool_result(&mut self) -> bool;
+                async fn option_arg(
+                    &mut self,
+                    a: Option<bool>,
+                    b: Option<()>,
+                    c: Option<u32>,
+                    d: Option<E1>,
+                    e: Option<f32>,
+                    g: Option<Option<bool>>,
+                ) -> ();
+                async fn option_result(
+                    &mut self,
+                ) -> (
+                    Option<bool>,
+                    Option<()>,
+                    Option<u32>,
+                    Option<E1>,
+                    Option<f32>,
+                    Option<Option<bool>>,
+                );
+                async fn casts(
+                    &mut self,
+                    a: Casts1,
+                    b: Casts2,
+                    c: Casts3,
+                    d: Casts4,
+                    e: Casts5,
+                    f: Casts6,
+                ) -> (Casts1, Casts2, Casts3, Casts4, Casts5, Casts6);
+                async fn result_arg(
+                    &mut self,
+                    a: Result<(), ()>,
+                    b: Result<(), E1>,
+                    c: Result<E1, ()>,
+                    d: Result<(), ()>,
+                    e: Result<u32, V1>,
+                    f: Result<
+                        wasmtime::component::__internal::String,
+                        wasmtime::component::__internal::Vec<u8>,
+                    >,
+                ) -> ();
+                async fn result_result(
+                    &mut self,
+                ) -> (
+                    Result<(), ()>,
+                    Result<(), E1>,
+                    Result<E1, ()>,
+                    Result<(), ()>,
+                    Result<u32, V1>,
+                    Result<
+                        wasmtime::component::__internal::String,
+                        wasmtime::component::__internal::Vec<u8>,
+                    >,
+                );
+                async fn return_result_sugar(&mut self) -> Result<i32, MyErrno>;
+                async fn return_result_sugar2(&mut self) -> Result<(), MyErrno>;
+                async fn return_result_sugar3(&mut self) -> Result<MyErrno, MyErrno>;
+                async fn return_result_sugar4(&mut self) -> Result<(i32, u32), MyErrno>;
+                async fn return_option_sugar(&mut self) -> Option<i32>;
+                async fn return_option_sugar2(&mut self) -> Option<MyErrno>;
+                async fn result_simple(&mut self) -> Result<u32, i32>;
+                async fn is_clone_arg(&mut self, a: IsClone) -> ();
+                async fn is_clone_return(&mut self) -> IsClone;
+                async fn return_named_option(&mut self) -> Option<u8>;
+                async fn return_named_result(&mut self) -> Result<u8, MyErrno>;
+            }
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/variants")?;
+                inst.func_wrap_async(
+                    "e1-arg",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (E1,)| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::e1_arg(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "e1-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::e1_result(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "v1-arg",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (V1,)| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::v1_arg(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "v1-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::v1_result(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "bool-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (bool,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::bool_arg(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "bool-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::bool_result(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "option-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (
+                            arg0,
+                            arg1,
+                            arg2,
+                            arg3,
+                            arg4,
+                            arg5,
+                        ): (
+                            Option<bool>,
+                            Option<()>,
+                            Option<u32>,
+                            Option<E1>,
+                            Option<f32>,
+                            Option<Option<bool>>,
+                        )|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::option_arg(
+                                host,
+                                arg0,
+                                arg1,
+                                arg2,
+                                arg3,
+                                arg4,
+                                arg5,
+                            )
+                            .await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "option-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::option_result(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "casts",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (
+                            arg0,
+                            arg1,
+                            arg2,
+                            arg3,
+                            arg4,
+                            arg5,
+                        ): (Casts1, Casts2, Casts3, Casts4, Casts5, Casts6)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::casts(host, arg0, arg1, arg2, arg3, arg4, arg5)
+                            .await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "result-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (
+                            arg0,
+                            arg1,
+                            arg2,
+                            arg3,
+                            arg4,
+                            arg5,
+                        ): (
+                            Result<(), ()>,
+                            Result<(), E1>,
+                            Result<E1, ()>,
+                            Result<(), ()>,
+                            Result<u32, V1>,
+                            Result<
+                                wasmtime::component::__internal::String,
+                                wasmtime::component::__internal::Vec<u8>,
+                            >,
+                        )|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::result_arg(
+                                host,
+                                arg0,
+                                arg1,
+                                arg2,
+                                arg3,
+                                arg4,
+                                arg5,
+                            )
+                            .await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "result-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::result_result(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "return-result-sugar",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::return_result_sugar(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "return-result-sugar2",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::return_result_sugar2(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "return-result-sugar3",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::return_result_sugar3(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "return-result-sugar4",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::return_result_sugar4(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "return-option-sugar",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::return_option_sugar(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "return-option-sugar2",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::return_option_sugar2(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "result-simple",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::result_simple(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "is-clone-arg",
+                    move |
+                        mut caller: wasmtime::StoreContextMut<'_, T>,
+                        (arg0,): (IsClone,)|
+                    wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::is_clone_arg(host, arg0).await;
+                        Ok(r)
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "is-clone-return",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::is_clone_return(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "return-named-option",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::return_named_option(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                inst.func_wrap_async(
+                    "return-named-result",
+                    move |mut caller: wasmtime::StoreContextMut<'_, T>, (): ()| wasmtime::component::__internal::Box::new(async move {
+                        let host = &mut host_getter(caller.data_mut());
+                        let r = Host::return_named_result(host).await;
+                        Ok((r,))
+                    }),
+                )?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {
+                async fn e1_arg(&mut self, x: E1) -> () {
+                    Host::e1_arg(*self, x).await
+                }
+                async fn e1_result(&mut self) -> E1 {
+                    Host::e1_result(*self).await
+                }
+                async fn v1_arg(&mut self, x: V1) -> () {
+                    Host::v1_arg(*self, x).await
+                }
+                async fn v1_result(&mut self) -> V1 {
+                    Host::v1_result(*self).await
+                }
+                async fn bool_arg(&mut self, x: bool) -> () {
+                    Host::bool_arg(*self, x).await
+                }
+                async fn bool_result(&mut self) -> bool {
+                    Host::bool_result(*self).await
+                }
+                async fn option_arg(
+                    &mut self,
+                    a: Option<bool>,
+                    b: Option<()>,
+                    c: Option<u32>,
+                    d: Option<E1>,
+                    e: Option<f32>,
+                    g: Option<Option<bool>>,
+                ) -> () {
+                    Host::option_arg(*self, a, b, c, d, e, g).await
+                }
+                async fn option_result(
+                    &mut self,
+                ) -> (
+                    Option<bool>,
+                    Option<()>,
+                    Option<u32>,
+                    Option<E1>,
+                    Option<f32>,
+                    Option<Option<bool>>,
+                ) {
+                    Host::option_result(*self).await
+                }
+                async fn casts(
+                    &mut self,
+                    a: Casts1,
+                    b: Casts2,
+                    c: Casts3,
+                    d: Casts4,
+                    e: Casts5,
+                    f: Casts6,
+                ) -> (Casts1, Casts2, Casts3, Casts4, Casts5, Casts6) {
+                    Host::casts(*self, a, b, c, d, e, f).await
+                }
+                async fn result_arg(
+                    &mut self,
+                    a: Result<(), ()>,
+                    b: Result<(), E1>,
+                    c: Result<E1, ()>,
+                    d: Result<(), ()>,
+                    e: Result<u32, V1>,
+                    f: Result<
+                        wasmtime::component::__internal::String,
+                        wasmtime::component::__internal::Vec<u8>,
+                    >,
+                ) -> () {
+                    Host::result_arg(*self, a, b, c, d, e, f).await
+                }
+                async fn result_result(
+                    &mut self,
+                ) -> (
+                    Result<(), ()>,
+                    Result<(), E1>,
+                    Result<E1, ()>,
+                    Result<(), ()>,
+                    Result<u32, V1>,
+                    Result<
+                        wasmtime::component::__internal::String,
+                        wasmtime::component::__internal::Vec<u8>,
+                    >,
+                ) {
+                    Host::result_result(*self).await
+                }
+                async fn return_result_sugar(&mut self) -> Result<i32, MyErrno> {
+                    Host::return_result_sugar(*self).await
+                }
+                async fn return_result_sugar2(&mut self) -> Result<(), MyErrno> {
+                    Host::return_result_sugar2(*self).await
+                }
+                async fn return_result_sugar3(&mut self) -> Result<MyErrno, MyErrno> {
+                    Host::return_result_sugar3(*self).await
+                }
+                async fn return_result_sugar4(&mut self) -> Result<(i32, u32), MyErrno> {
+                    Host::return_result_sugar4(*self).await
+                }
+                async fn return_option_sugar(&mut self) -> Option<i32> {
+                    Host::return_option_sugar(*self).await
+                }
+                async fn return_option_sugar2(&mut self) -> Option<MyErrno> {
+                    Host::return_option_sugar2(*self).await
+                }
+                async fn result_simple(&mut self) -> Result<u32, i32> {
+                    Host::result_simple(*self).await
+                }
+                async fn is_clone_arg(&mut self, a: IsClone) -> () {
+                    Host::is_clone_arg(*self, a).await
+                }
+                async fn is_clone_return(&mut self) -> IsClone {
+                    Host::is_clone_return(*self).await
+                }
+                async fn return_named_option(&mut self) -> Option<u8> {
+                    Host::return_named_option(*self).await
+                }
+                async fn return_named_result(&mut self) -> Result<u8, MyErrno> {
+                    Host::return_named_result(*self).await
+                }
+            }
+        }
+    }
+}
+pub mod exports {
+    pub mod foo {
+        pub mod foo {
+            #[allow(clippy::all)]
+            pub mod variants {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(enum)]
+                #[derive(Clone, Copy, Eq, PartialEq)]
+                #[repr(u8)]
+                pub enum E1 {
+                    #[component(name = "a")]
+                    A,
+                }
+                impl core::fmt::Debug for E1 {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        match self {
+                            E1::A => f.debug_tuple("E1::A").finish(),
+                        }
+                    }
+                }
+                const _: () = {
+                    assert!(1 == < E1 as wasmtime::component::ComponentType >::SIZE32);
+                    assert!(1 == < E1 as wasmtime::component::ComponentType >::ALIGN32);
+                };
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(record)]
+                #[derive(Clone, Copy)]
+                pub struct Empty {}
+                impl core::fmt::Debug for Empty {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        f.debug_struct("Empty").finish()
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        0 == < Empty as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        1 == < Empty as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(variant)]
+                #[derive(Clone)]
+                pub enum V1 {
+                    #[component(name = "a")]
+                    A,
+                    #[component(name = "c")]
+                    C(E1),
+                    #[component(name = "d")]
+                    D(wasmtime::component::__internal::String),
+                    #[component(name = "e")]
+                    E(Empty),
+                    #[component(name = "f")]
+                    F,
+                    #[component(name = "g")]
+                    G(u32),
+                }
+                impl core::fmt::Debug for V1 {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        match self {
+                            V1::A => f.debug_tuple("V1::A").finish(),
+                            V1::C(e) => f.debug_tuple("V1::C").field(e).finish(),
+                            V1::D(e) => f.debug_tuple("V1::D").field(e).finish(),
+                            V1::E(e) => f.debug_tuple("V1::E").field(e).finish(),
+                            V1::F => f.debug_tuple("V1::F").finish(),
+                            V1::G(e) => f.debug_tuple("V1::G").field(e).finish(),
+                        }
+                    }
+                }
+                const _: () = {
+                    assert!(12 == < V1 as wasmtime::component::ComponentType >::SIZE32);
+                    assert!(4 == < V1 as wasmtime::component::ComponentType >::ALIGN32);
+                };
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(variant)]
+                #[derive(Clone, Copy)]
+                pub enum Casts1 {
+                    #[component(name = "a")]
+                    A(i32),
+                    #[component(name = "b")]
+                    B(f32),
+                }
+                impl core::fmt::Debug for Casts1 {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        match self {
+                            Casts1::A(e) => f.debug_tuple("Casts1::A").field(e).finish(),
+                            Casts1::B(e) => f.debug_tuple("Casts1::B").field(e).finish(),
+                        }
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        8 == < Casts1 as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        4 == < Casts1 as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(variant)]
+                #[derive(Clone, Copy)]
+                pub enum Casts2 {
+                    #[component(name = "a")]
+                    A(f64),
+                    #[component(name = "b")]
+                    B(f32),
+                }
+                impl core::fmt::Debug for Casts2 {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        match self {
+                            Casts2::A(e) => f.debug_tuple("Casts2::A").field(e).finish(),
+                            Casts2::B(e) => f.debug_tuple("Casts2::B").field(e).finish(),
+                        }
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        16 == < Casts2 as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        8 == < Casts2 as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(variant)]
+                #[derive(Clone, Copy)]
+                pub enum Casts3 {
+                    #[component(name = "a")]
+                    A(f64),
+                    #[component(name = "b")]
+                    B(u64),
+                }
+                impl core::fmt::Debug for Casts3 {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        match self {
+                            Casts3::A(e) => f.debug_tuple("Casts3::A").field(e).finish(),
+                            Casts3::B(e) => f.debug_tuple("Casts3::B").field(e).finish(),
+                        }
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        16 == < Casts3 as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        8 == < Casts3 as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(variant)]
+                #[derive(Clone, Copy)]
+                pub enum Casts4 {
+                    #[component(name = "a")]
+                    A(u32),
+                    #[component(name = "b")]
+                    B(i64),
+                }
+                impl core::fmt::Debug for Casts4 {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        match self {
+                            Casts4::A(e) => f.debug_tuple("Casts4::A").field(e).finish(),
+                            Casts4::B(e) => f.debug_tuple("Casts4::B").field(e).finish(),
+                        }
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        16 == < Casts4 as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        8 == < Casts4 as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(variant)]
+                #[derive(Clone, Copy)]
+                pub enum Casts5 {
+                    #[component(name = "a")]
+                    A(f32),
+                    #[component(name = "b")]
+                    B(i64),
+                }
+                impl core::fmt::Debug for Casts5 {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        match self {
+                            Casts5::A(e) => f.debug_tuple("Casts5::A").field(e).finish(),
+                            Casts5::B(e) => f.debug_tuple("Casts5::B").field(e).finish(),
+                        }
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        16 == < Casts5 as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        8 == < Casts5 as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(variant)]
+                #[derive(Clone, Copy)]
+                pub enum Casts6 {
+                    #[component(name = "a")]
+                    A((f32, u32)),
+                    #[component(name = "b")]
+                    B((u32, u32)),
+                }
+                impl core::fmt::Debug for Casts6 {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        match self {
+                            Casts6::A(e) => f.debug_tuple("Casts6::A").field(e).finish(),
+                            Casts6::B(e) => f.debug_tuple("Casts6::B").field(e).finish(),
+                        }
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        12 == < Casts6 as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        4 == < Casts6 as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(enum)]
+                #[derive(Clone, Copy, Eq, PartialEq)]
+                #[repr(u8)]
+                pub enum MyErrno {
+                    #[component(name = "bad1")]
+                    Bad1,
+                    #[component(name = "bad2")]
+                    Bad2,
+                }
+                impl MyErrno {
+                    pub fn name(&self) -> &'static str {
+                        match self {
+                            MyErrno::Bad1 => "bad1",
+                            MyErrno::Bad2 => "bad2",
+                        }
+                    }
+                    pub fn message(&self) -> &'static str {
+                        match self {
+                            MyErrno::Bad1 => "",
+                            MyErrno::Bad2 => "",
+                        }
+                    }
+                }
+                impl core::fmt::Debug for MyErrno {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        f.debug_struct("MyErrno")
+                            .field("code", &(*self as i32))
+                            .field("name", &self.name())
+                            .field("message", &self.message())
+                            .finish()
+                    }
+                }
+                impl core::fmt::Display for MyErrno {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        write!(f, "{} (error {})", self.name(), * self as i32)
+                    }
+                }
+                impl std::error::Error for MyErrno {}
+                const _: () = {
+                    assert!(
+                        1 == < MyErrno as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        1 == < MyErrno as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                #[derive(wasmtime::component::ComponentType)]
+                #[derive(wasmtime::component::Lift)]
+                #[derive(wasmtime::component::Lower)]
+                #[component(record)]
+                #[derive(Clone)]
+                pub struct IsClone {
+                    #[component(name = "v1")]
+                    pub v1: V1,
+                }
+                impl core::fmt::Debug for IsClone {
+                    fn fmt(
+                        &self,
+                        f: &mut core::fmt::Formatter<'_>,
+                    ) -> core::fmt::Result {
+                        f.debug_struct("IsClone").field("v1", &self.v1).finish()
+                    }
+                }
+                const _: () = {
+                    assert!(
+                        12 == < IsClone as wasmtime::component::ComponentType >::SIZE32
+                    );
+                    assert!(
+                        4 == < IsClone as wasmtime::component::ComponentType >::ALIGN32
+                    );
+                };
+                pub struct Guest {
+                    e1_arg: wasmtime::component::Func,
+                    e1_result: wasmtime::component::Func,
+                    v1_arg: wasmtime::component::Func,
+                    v1_result: wasmtime::component::Func,
+                    bool_arg: wasmtime::component::Func,
+                    bool_result: wasmtime::component::Func,
+                    option_arg: wasmtime::component::Func,
+                    option_result: wasmtime::component::Func,
+                    casts: wasmtime::component::Func,
+                    result_arg: wasmtime::component::Func,
+                    result_result: wasmtime::component::Func,
+                    return_result_sugar: wasmtime::component::Func,
+                    return_result_sugar2: wasmtime::component::Func,
+                    return_result_sugar3: wasmtime::component::Func,
+                    return_result_sugar4: wasmtime::component::Func,
+                    return_option_sugar: wasmtime::component::Func,
+                    return_option_sugar2: wasmtime::component::Func,
+                    result_simple: wasmtime::component::Func,
+                    is_clone_arg: wasmtime::component::Func,
+                    is_clone_return: wasmtime::component::Func,
+                    return_named_option: wasmtime::component::Func,
+                    return_named_result: wasmtime::component::Func,
+                }
+                #[derive(Clone)]
+                pub struct GuestIndices {
+                    e1_arg: wasmtime::component::ComponentExportIndex,
+                    e1_result: wasmtime::component::ComponentExportIndex,
+                    v1_arg: wasmtime::component::ComponentExportIndex,
+                    v1_result: wasmtime::component::ComponentExportIndex,
+                    bool_arg: wasmtime::component::ComponentExportIndex,
+                    bool_result: wasmtime::component::ComponentExportIndex,
+                    option_arg: wasmtime::component::ComponentExportIndex,
+                    option_result: wasmtime::component::ComponentExportIndex,
+                    casts: wasmtime::component::ComponentExportIndex,
+                    result_arg: wasmtime::component::ComponentExportIndex,
+                    result_result: wasmtime::component::ComponentExportIndex,
+                    return_result_sugar: wasmtime::component::ComponentExportIndex,
+                    return_result_sugar2: wasmtime::component::ComponentExportIndex,
+                    return_result_sugar3: wasmtime::component::ComponentExportIndex,
+                    return_result_sugar4: wasmtime::component::ComponentExportIndex,
+                    return_option_sugar: wasmtime::component::ComponentExportIndex,
+                    return_option_sugar2: wasmtime::component::ComponentExportIndex,
+                    result_simple: wasmtime::component::ComponentExportIndex,
+                    is_clone_arg: wasmtime::component::ComponentExportIndex,
+                    is_clone_return: wasmtime::component::ComponentExportIndex,
+                    return_named_option: wasmtime::component::ComponentExportIndex,
+                    return_named_result: wasmtime::component::ComponentExportIndex,
+                }
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "foo:foo/variants")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/variants`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(&mut store, None, "foo:foo/variants")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `foo:foo/variants`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `foo:foo/variants` does \
+                    not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        let e1_arg = lookup("e1-arg")?;
+                        let e1_result = lookup("e1-result")?;
+                        let v1_arg = lookup("v1-arg")?;
+                        let v1_result = lookup("v1-result")?;
+                        let bool_arg = lookup("bool-arg")?;
+                        let bool_result = lookup("bool-result")?;
+                        let option_arg = lookup("option-arg")?;
+                        let option_result = lookup("option-result")?;
+                        let casts = lookup("casts")?;
+                        let result_arg = lookup("result-arg")?;
+                        let result_result = lookup("result-result")?;
+                        let return_result_sugar = lookup("return-result-sugar")?;
+                        let return_result_sugar2 = lookup("return-result-sugar2")?;
+                        let return_result_sugar3 = lookup("return-result-sugar3")?;
+                        let return_result_sugar4 = lookup("return-result-sugar4")?;
+                        let return_option_sugar = lookup("return-option-sugar")?;
+                        let return_option_sugar2 = lookup("return-option-sugar2")?;
+                        let result_simple = lookup("result-simple")?;
+                        let is_clone_arg = lookup("is-clone-arg")?;
+                        let is_clone_return = lookup("is-clone-return")?;
+                        let return_named_option = lookup("return-named-option")?;
+                        let return_named_result = lookup("return-named-result")?;
+                        Ok(GuestIndices {
+                            e1_arg,
+                            e1_result,
+                            v1_arg,
+                            v1_result,
+                            bool_arg,
+                            bool_result,
+                            option_arg,
+                            option_result,
+                            casts,
+                            result_arg,
+                            result_result,
+                            return_result_sugar,
+                            return_result_sugar2,
+                            return_result_sugar3,
+                            return_result_sugar4,
+                            return_option_sugar,
+                            return_option_sugar2,
+                            result_simple,
+                            is_clone_arg,
+                            is_clone_return,
+                            return_named_option,
+                            return_named_result,
+                        })
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        let e1_arg = *_instance
+                            .get_typed_func::<(E1,), ()>(&mut store, &self.e1_arg)?
+                            .func();
+                        let e1_result = *_instance
+                            .get_typed_func::<(), (E1,)>(&mut store, &self.e1_result)?
+                            .func();
+                        let v1_arg = *_instance
+                            .get_typed_func::<(&V1,), ()>(&mut store, &self.v1_arg)?
+                            .func();
+                        let v1_result = *_instance
+                            .get_typed_func::<(), (V1,)>(&mut store, &self.v1_result)?
+                            .func();
+                        let bool_arg = *_instance
+                            .get_typed_func::<(bool,), ()>(&mut store, &self.bool_arg)?
+                            .func();
+                        let bool_result = *_instance
+                            .get_typed_func::<
+                                (),
+                                (bool,),
+                            >(&mut store, &self.bool_result)?
+                            .func();
+                        let option_arg = *_instance
+                            .get_typed_func::<
+                                (
+                                    Option<bool>,
+                                    Option<()>,
+                                    Option<u32>,
+                                    Option<E1>,
+                                    Option<f32>,
+                                    Option<Option<bool>>,
+                                ),
+                                (),
+                            >(&mut store, &self.option_arg)?
+                            .func();
+                        let option_result = *_instance
+                            .get_typed_func::<
+                                (),
+                                (
+                                    (
+                                        Option<bool>,
+                                        Option<()>,
+                                        Option<u32>,
+                                        Option<E1>,
+                                        Option<f32>,
+                                        Option<Option<bool>>,
+                                    ),
+                                ),
+                            >(&mut store, &self.option_result)?
+                            .func();
+                        let casts = *_instance
+                            .get_typed_func::<
+                                (Casts1, Casts2, Casts3, Casts4, Casts5, Casts6),
+                                ((Casts1, Casts2, Casts3, Casts4, Casts5, Casts6),),
+                            >(&mut store, &self.casts)?
+                            .func();
+                        let result_arg = *_instance
+                            .get_typed_func::<
+                                (
+                                    Result<(), ()>,
+                                    Result<(), E1>,
+                                    Result<E1, ()>,
+                                    Result<(), ()>,
+                                    Result<u32, &V1>,
+                                    Result<&str, &[u8]>,
+                                ),
+                                (),
+                            >(&mut store, &self.result_arg)?
+                            .func();
+                        let result_result = *_instance
+                            .get_typed_func::<
+                                (),
+                                (
+                                    (
+                                        Result<(), ()>,
+                                        Result<(), E1>,
+                                        Result<E1, ()>,
+                                        Result<(), ()>,
+                                        Result<u32, V1>,
+                                        Result<
+                                            wasmtime::component::__internal::String,
+                                            wasmtime::component::__internal::Vec<u8>,
+                                        >,
+                                    ),
+                                ),
+                            >(&mut store, &self.result_result)?
+                            .func();
+                        let return_result_sugar = *_instance
+                            .get_typed_func::<
+                                (),
+                                (Result<i32, MyErrno>,),
+                            >(&mut store, &self.return_result_sugar)?
+                            .func();
+                        let return_result_sugar2 = *_instance
+                            .get_typed_func::<
+                                (),
+                                (Result<(), MyErrno>,),
+                            >(&mut store, &self.return_result_sugar2)?
+                            .func();
+                        let return_result_sugar3 = *_instance
+                            .get_typed_func::<
+                                (),
+                                (Result<MyErrno, MyErrno>,),
+                            >(&mut store, &self.return_result_sugar3)?
+                            .func();
+                        let return_result_sugar4 = *_instance
+                            .get_typed_func::<
+                                (),
+                                (Result<(i32, u32), MyErrno>,),
+                            >(&mut store, &self.return_result_sugar4)?
+                            .func();
+                        let return_option_sugar = *_instance
+                            .get_typed_func::<
+                                (),
+                                (Option<i32>,),
+                            >(&mut store, &self.return_option_sugar)?
+                            .func();
+                        let return_option_sugar2 = *_instance
+                            .get_typed_func::<
+                                (),
+                                (Option<MyErrno>,),
+                            >(&mut store, &self.return_option_sugar2)?
+                            .func();
+                        let result_simple = *_instance
+                            .get_typed_func::<
+                                (),
+                                (Result<u32, i32>,),
+                            >(&mut store, &self.result_simple)?
+                            .func();
+                        let is_clone_arg = *_instance
+                            .get_typed_func::<
+                                (&IsClone,),
+                                (),
+                            >(&mut store, &self.is_clone_arg)?
+                            .func();
+                        let is_clone_return = *_instance
+                            .get_typed_func::<
+                                (),
+                                (IsClone,),
+                            >(&mut store, &self.is_clone_return)?
+                            .func();
+                        let return_named_option = *_instance
+                            .get_typed_func::<
+                                (),
+                                (Option<u8>,),
+                            >(&mut store, &self.return_named_option)?
+                            .func();
+                        let return_named_result = *_instance
+                            .get_typed_func::<
+                                (),
+                                (Result<u8, MyErrno>,),
+                            >(&mut store, &self.return_named_result)?
+                            .func();
+                        Ok(Guest {
+                            e1_arg,
+                            e1_result,
+                            v1_arg,
+                            v1_result,
+                            bool_arg,
+                            bool_result,
+                            option_arg,
+                            option_result,
+                            casts,
+                            result_arg,
+                            result_result,
+                            return_result_sugar,
+                            return_result_sugar2,
+                            return_result_sugar3,
+                            return_result_sugar4,
+                            return_option_sugar,
+                            return_option_sugar2,
+                            result_simple,
+                            is_clone_arg,
+                            is_clone_return,
+                            return_named_option,
+                            return_named_result,
+                        })
+                    }
+                }
+                impl Guest {
+                    pub async fn call_e1_arg<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: E1,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (E1,),
+                                (),
+                            >::new_unchecked(self.e1_arg)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_e1_result<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<E1>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (E1,),
+                            >::new_unchecked(self.e1_result)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_v1_arg<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &V1,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&V1,),
+                                (),
+                            >::new_unchecked(self.v1_arg)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_v1_result<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<V1>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (V1,),
+                            >::new_unchecked(self.v1_result)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_bool_arg<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: bool,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (bool,),
+                                (),
+                            >::new_unchecked(self.bool_arg)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_bool_result<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<bool>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (bool,),
+                            >::new_unchecked(self.bool_result)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_option_arg<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: Option<bool>,
+                        arg1: Option<()>,
+                        arg2: Option<u32>,
+                        arg3: Option<E1>,
+                        arg4: Option<f32>,
+                        arg5: Option<Option<bool>>,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (
+                                    Option<bool>,
+                                    Option<()>,
+                                    Option<u32>,
+                                    Option<E1>,
+                                    Option<f32>,
+                                    Option<Option<bool>>,
+                                ),
+                                (),
+                            >::new_unchecked(self.option_arg)
+                        };
+                        let () = callee
+                            .call_async(
+                                store.as_context_mut(),
+                                (arg0, arg1, arg2, arg3, arg4, arg5),
+                            )
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_option_result<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<
+                        (
+                            Option<bool>,
+                            Option<()>,
+                            Option<u32>,
+                            Option<E1>,
+                            Option<f32>,
+                            Option<Option<bool>>,
+                        ),
+                    >
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (
+                                    (
+                                        Option<bool>,
+                                        Option<()>,
+                                        Option<u32>,
+                                        Option<E1>,
+                                        Option<f32>,
+                                        Option<Option<bool>>,
+                                    ),
+                                ),
+                            >::new_unchecked(self.option_result)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_casts<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: Casts1,
+                        arg1: Casts2,
+                        arg2: Casts3,
+                        arg3: Casts4,
+                        arg4: Casts5,
+                        arg5: Casts6,
+                    ) -> wasmtime::Result<
+                        (Casts1, Casts2, Casts3, Casts4, Casts5, Casts6),
+                    >
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (Casts1, Casts2, Casts3, Casts4, Casts5, Casts6),
+                                ((Casts1, Casts2, Casts3, Casts4, Casts5, Casts6),),
+                            >::new_unchecked(self.casts)
+                        };
+                        let (ret0,) = callee
+                            .call_async(
+                                store.as_context_mut(),
+                                (arg0, arg1, arg2, arg3, arg4, arg5),
+                            )
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_result_arg<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: Result<(), ()>,
+                        arg1: Result<(), E1>,
+                        arg2: Result<E1, ()>,
+                        arg3: Result<(), ()>,
+                        arg4: Result<u32, &V1>,
+                        arg5: Result<&str, &[u8]>,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (
+                                    Result<(), ()>,
+                                    Result<(), E1>,
+                                    Result<E1, ()>,
+                                    Result<(), ()>,
+                                    Result<u32, &V1>,
+                                    Result<&str, &[u8]>,
+                                ),
+                                (),
+                            >::new_unchecked(self.result_arg)
+                        };
+                        let () = callee
+                            .call_async(
+                                store.as_context_mut(),
+                                (arg0, arg1, arg2, arg3, arg4, arg5),
+                            )
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_result_result<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<
+                        (
+                            Result<(), ()>,
+                            Result<(), E1>,
+                            Result<E1, ()>,
+                            Result<(), ()>,
+                            Result<u32, V1>,
+                            Result<
+                                wasmtime::component::__internal::String,
+                                wasmtime::component::__internal::Vec<u8>,
+                            >,
+                        ),
+                    >
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (
+                                    (
+                                        Result<(), ()>,
+                                        Result<(), E1>,
+                                        Result<E1, ()>,
+                                        Result<(), ()>,
+                                        Result<u32, V1>,
+                                        Result<
+                                            wasmtime::component::__internal::String,
+                                            wasmtime::component::__internal::Vec<u8>,
+                                        >,
+                                    ),
+                                ),
+                            >::new_unchecked(self.result_result)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_return_result_sugar<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<Result<i32, MyErrno>>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (Result<i32, MyErrno>,),
+                            >::new_unchecked(self.return_result_sugar)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_return_result_sugar2<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<Result<(), MyErrno>>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (Result<(), MyErrno>,),
+                            >::new_unchecked(self.return_result_sugar2)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_return_result_sugar3<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<Result<MyErrno, MyErrno>>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (Result<MyErrno, MyErrno>,),
+                            >::new_unchecked(self.return_result_sugar3)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_return_result_sugar4<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<Result<(i32, u32), MyErrno>>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (Result<(i32, u32), MyErrno>,),
+                            >::new_unchecked(self.return_result_sugar4)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_return_option_sugar<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<Option<i32>>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (Option<i32>,),
+                            >::new_unchecked(self.return_option_sugar)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_return_option_sugar2<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<Option<MyErrno>>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (Option<MyErrno>,),
+                            >::new_unchecked(self.return_option_sugar2)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_result_simple<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<Result<u32, i32>>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (Result<u32, i32>,),
+                            >::new_unchecked(self.result_simple)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_is_clone_arg<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                        arg0: &IsClone,
+                    ) -> wasmtime::Result<()>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (&IsClone,),
+                                (),
+                            >::new_unchecked(self.is_clone_arg)
+                        };
+                        let () = callee
+                            .call_async(store.as_context_mut(), (arg0,))
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(())
+                    }
+                    pub async fn call_is_clone_return<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<IsClone>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (IsClone,),
+                            >::new_unchecked(self.is_clone_return)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_return_named_option<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<Option<u8>>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (Option<u8>,),
+                            >::new_unchecked(self.return_named_option)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                    pub async fn call_return_named_result<S: wasmtime::AsContextMut>(
+                        &self,
+                        mut store: S,
+                    ) -> wasmtime::Result<Result<u8, MyErrno>>
+                    where
+                        <S as wasmtime::AsContext>::Data: Send,
+                    {
+                        let callee = unsafe {
+                            wasmtime::component::TypedFunc::<
+                                (),
+                                (Result<u8, MyErrno>,),
+                            >::new_unchecked(self.return_named_result)
+                        };
+                        let (ret0,) = callee
+                            .call_async(store.as_context_mut(), ())
+                            .await?;
+                        callee.post_return_async(store.as_context_mut()).await?;
+                        Ok(ret0)
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/wat.rs b/crates/component-macro/tests/expanded/wat.rs
new file mode 100644
index 000000000000..14da6ff9efb6
--- /dev/null
+++ b/crates/component-macro/tests/expanded/wat.rs
@@ -0,0 +1,265 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `example`.
+///
+/// This structure is created through [`ExamplePre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`Example`] as well.
+pub struct ExamplePre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: ExampleIndices,
+}
+impl<T> Clone for ExamplePre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> ExamplePre<_T> {
+    /// Creates a new copy of `ExamplePre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = ExampleIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`Example`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<Example> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `example`.
+///
+/// This is an implementation detail of [`ExamplePre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`Example`] as well.
+#[derive(Clone)]
+pub struct ExampleIndices {
+    interface0: exports::same::name::this_name_is_duplicated::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `example`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`Example::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`ExamplePre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`ExamplePre::instantiate`] to
+///   create a [`Example`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`Example::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`ExampleIndices::new_instance`] followed
+///   by [`ExampleIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct Example {
+    interface0: exports::same::name::this_name_is_duplicated::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl ExampleIndices {
+        /// Creates a new copy of `ExampleIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::same::name::this_name_is_duplicated::GuestIndices::new(
+                _component,
+            )?;
+            Ok(ExampleIndices { interface0 })
+        }
+        /// Creates a new instance of [`ExampleIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`Example`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`Example`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::same::name::this_name_is_duplicated::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(ExampleIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`Example`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Example> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(Example { interface0 })
+        }
+    }
+    impl Example {
+        /// Convenience wrapper around [`ExamplePre::new`] and
+        /// [`ExamplePre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<Example> {
+            let pre = linker.instantiate_pre(component)?;
+            ExamplePre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`ExampleIndices::new_instance`] and
+        /// [`ExampleIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Example> {
+            let indices = ExampleIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn same_name_this_name_is_duplicated(
+            &self,
+        ) -> &exports::same::name::this_name_is_duplicated::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod exports {
+    pub mod same {
+        pub mod name {
+            #[allow(clippy::all)]
+            pub mod this_name_is_duplicated {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub type ThisNameIsDuplicated = wasmtime::component::ResourceAny;
+                pub struct GuestThisNameIsDuplicated<'a> {
+                    funcs: &'a Guest,
+                }
+                pub struct Guest {}
+                #[derive(Clone)]
+                pub struct GuestIndices {}
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "same:name/this-name-is-duplicated")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `same:name/this-name-is-duplicated`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(
+                                &mut store,
+                                None,
+                                "same:name/this-name-is-duplicated",
+                            )
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `same:name/this-name-is-duplicated`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `same:name/this-name-is-duplicated` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        Ok(GuestIndices {})
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        Ok(Guest {})
+                    }
+                }
+                impl Guest {}
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/wat_async.rs b/crates/component-macro/tests/expanded/wat_async.rs
new file mode 100644
index 000000000000..cad73611fe21
--- /dev/null
+++ b/crates/component-macro/tests/expanded/wat_async.rs
@@ -0,0 +1,271 @@
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `example`.
+///
+/// This structure is created through [`ExamplePre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`Example`] as well.
+pub struct ExamplePre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: ExampleIndices,
+}
+impl<T> Clone for ExamplePre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> ExamplePre<_T> {
+    /// Creates a new copy of `ExamplePre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = ExampleIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`Example`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<Example>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `example`.
+///
+/// This is an implementation detail of [`ExamplePre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`Example`] as well.
+#[derive(Clone)]
+pub struct ExampleIndices {
+    interface0: exports::same::name::this_name_is_duplicated::GuestIndices,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `example`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`Example::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`ExamplePre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`ExamplePre::instantiate_async`] to
+///   create a [`Example`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`Example::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`ExampleIndices::new_instance`] followed
+///   by [`ExampleIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct Example {
+    interface0: exports::same::name::this_name_is_duplicated::Guest,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl ExampleIndices {
+        /// Creates a new copy of `ExampleIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let interface0 = exports::same::name::this_name_is_duplicated::GuestIndices::new(
+                _component,
+            )?;
+            Ok(ExampleIndices { interface0 })
+        }
+        /// Creates a new instance of [`ExampleIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`Example`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`Example`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let interface0 = exports::same::name::this_name_is_duplicated::GuestIndices::new_instance(
+                &mut store,
+                _instance,
+            )?;
+            Ok(ExampleIndices { interface0 })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`Example`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Example> {
+            let _instance = instance;
+            let interface0 = self.interface0.load(&mut store, &_instance)?;
+            Ok(Example { interface0 })
+        }
+    }
+    impl Example {
+        /// Convenience wrapper around [`ExamplePre::new`] and
+        /// [`ExamplePre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<Example>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            ExamplePre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`ExampleIndices::new_instance`] and
+        /// [`ExampleIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Example> {
+            let indices = ExampleIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn same_name_this_name_is_duplicated(
+            &self,
+        ) -> &exports::same::name::this_name_is_duplicated::Guest {
+            &self.interface0
+        }
+    }
+};
+pub mod exports {
+    pub mod same {
+        pub mod name {
+            #[allow(clippy::all)]
+            pub mod this_name_is_duplicated {
+                #[allow(unused_imports)]
+                use wasmtime::component::__internal::anyhow;
+                pub type ThisNameIsDuplicated = wasmtime::component::ResourceAny;
+                pub struct GuestThisNameIsDuplicated<'a> {
+                    funcs: &'a Guest,
+                }
+                pub struct Guest {}
+                #[derive(Clone)]
+                pub struct GuestIndices {}
+                impl GuestIndices {
+                    /// Constructor for [`GuestIndices`] which takes a
+                    /// [`Component`](wasmtime::component::Component) as input and can be executed
+                    /// before instantiation.
+                    ///
+                    /// This constructor can be used to front-load string lookups to find exports
+                    /// within a component.
+                    pub fn new(
+                        component: &wasmtime::component::Component,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let (_, instance) = component
+                            .export_index(None, "same:name/this-name-is-duplicated")
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `same:name/this-name-is-duplicated`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            component.export_index(Some(&instance), name).map(|p| p.1)
+                        })
+                    }
+                    /// This constructor is similar to [`GuestIndices::new`] except that it
+                    /// performs string lookups after instantiation time.
+                    pub fn new_instance(
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let instance_export = instance
+                            .get_export(
+                                &mut store,
+                                None,
+                                "same:name/this-name-is-duplicated",
+                            )
+                            .ok_or_else(|| {
+                                anyhow::anyhow!(
+                                    "no exported instance named `same:name/this-name-is-duplicated`"
+                                )
+                            })?;
+                        Self::_new(|name| {
+                            instance.get_export(&mut store, Some(&instance_export), name)
+                        })
+                    }
+                    fn _new(
+                        mut lookup: impl FnMut(
+                            &str,
+                        ) -> Option<wasmtime::component::ComponentExportIndex>,
+                    ) -> wasmtime::Result<GuestIndices> {
+                        let mut lookup = move |name| {
+                            lookup(name)
+                                .ok_or_else(|| {
+                                    anyhow::anyhow!(
+                                        "instance export `same:name/this-name-is-duplicated` does \
+                not have export `{name}`"
+                                    )
+                                })
+                        };
+                        let _ = &mut lookup;
+                        Ok(GuestIndices {})
+                    }
+                    pub fn load(
+                        &self,
+                        mut store: impl wasmtime::AsContextMut,
+                        instance: &wasmtime::component::Instance,
+                    ) -> wasmtime::Result<Guest> {
+                        let mut store = store.as_context_mut();
+                        let _ = &mut store;
+                        let _instance = instance;
+                        Ok(Guest {})
+                    }
+                }
+                impl Guest {}
+            }
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/worlds-with-types.rs b/crates/component-macro/tests/expanded/worlds-with-types.rs
new file mode 100644
index 000000000000..2fd790395a13
--- /dev/null
+++ b/crates/component-macro/tests/expanded/worlds-with-types.rs
@@ -0,0 +1,263 @@
+pub type U = foo::foo::i::T;
+const _: () = {
+    assert!(2 == < U as wasmtime::component::ComponentType >::SIZE32);
+    assert!(2 == < U as wasmtime::component::ComponentType >::ALIGN32);
+};
+pub type T = u32;
+const _: () = {
+    assert!(4 == < T as wasmtime::component::ComponentType >::SIZE32);
+    assert!(4 == < T as wasmtime::component::ComponentType >::ALIGN32);
+};
+#[derive(wasmtime::component::ComponentType)]
+#[derive(wasmtime::component::Lift)]
+#[derive(wasmtime::component::Lower)]
+#[component(record)]
+#[derive(Clone, Copy)]
+pub struct R {}
+impl core::fmt::Debug for R {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("R").finish()
+    }
+}
+const _: () = {
+    assert!(0 == < R as wasmtime::component::ComponentType >::SIZE32);
+    assert!(1 == < R as wasmtime::component::ComponentType >::ALIGN32);
+};
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `foo`.
+///
+/// This structure is created through [`FooPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`Foo`] as well.
+pub struct FooPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: FooIndices,
+}
+impl<T> Clone for FooPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> FooPre<_T> {
+    /// Creates a new copy of `FooPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = FooIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`Foo`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub fn instantiate(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<Foo> {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate(&mut store)?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `foo`.
+///
+/// This is an implementation detail of [`FooPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`Foo`] as well.
+#[derive(Clone)]
+pub struct FooIndices {
+    f: wasmtime::component::ComponentExportIndex,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `foo`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`Foo::instantiate`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`FooPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`FooPre::instantiate`] to
+///   create a [`Foo`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`Foo::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`FooIndices::new_instance`] followed
+///   by [`FooIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct Foo {
+    f: wasmtime::component::Func,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl FooIndices {
+        /// Creates a new copy of `FooIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let f = _component
+                .export_index(None, "f")
+                .ok_or_else(|| anyhow::anyhow!("no function export `f` found"))?
+                .1;
+            Ok(FooIndices { f })
+        }
+        /// Creates a new instance of [`FooIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`Foo`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`Foo`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let f = _instance
+                .get_export(&mut store, None, "f")
+                .ok_or_else(|| anyhow::anyhow!("no function export `f` found"))?;
+            Ok(FooIndices { f })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`Foo`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Foo> {
+            let _instance = instance;
+            let f = *_instance
+                .get_typed_func::<(), ((T, U, R),)>(&mut store, &self.f)?
+                .func();
+            Ok(Foo { f })
+        }
+    }
+    impl Foo {
+        /// Convenience wrapper around [`FooPre::new`] and
+        /// [`FooPre::instantiate`].
+        pub fn instantiate<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<Foo> {
+            let pre = linker.instantiate_pre(component)?;
+            FooPre::new(pre)?.instantiate(store)
+        }
+        /// Convenience wrapper around [`FooIndices::new_instance`] and
+        /// [`FooIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Foo> {
+            let indices = FooIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            U: foo::foo::i::Host,
+        {
+            foo::foo::i::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub fn call_f<S: wasmtime::AsContextMut>(
+            &self,
+            mut store: S,
+        ) -> wasmtime::Result<(T, U, R)> {
+            let callee = unsafe {
+                wasmtime::component::TypedFunc::<(), ((T, U, R),)>::new_unchecked(self.f)
+            };
+            let (ret0,) = callee.call(store.as_context_mut(), ())?;
+            callee.post_return(store.as_context_mut())?;
+            Ok(ret0)
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod i {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub type T = u16;
+            const _: () = {
+                assert!(2 == < T as wasmtime::component::ComponentType >::SIZE32);
+                assert!(2 == < T as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            pub trait Host {}
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()> {
+                let mut inst = linker.instance("foo:foo/i")?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            impl<_T: Host + ?Sized> Host for &mut _T {}
+        }
+    }
+}
diff --git a/crates/component-macro/tests/expanded/worlds-with-types_async.rs b/crates/component-macro/tests/expanded/worlds-with-types_async.rs
new file mode 100644
index 000000000000..48f42f3a99b6
--- /dev/null
+++ b/crates/component-macro/tests/expanded/worlds-with-types_async.rs
@@ -0,0 +1,279 @@
+pub type U = foo::foo::i::T;
+const _: () = {
+    assert!(2 == < U as wasmtime::component::ComponentType >::SIZE32);
+    assert!(2 == < U as wasmtime::component::ComponentType >::ALIGN32);
+};
+pub type T = u32;
+const _: () = {
+    assert!(4 == < T as wasmtime::component::ComponentType >::SIZE32);
+    assert!(4 == < T as wasmtime::component::ComponentType >::ALIGN32);
+};
+#[derive(wasmtime::component::ComponentType)]
+#[derive(wasmtime::component::Lift)]
+#[derive(wasmtime::component::Lower)]
+#[component(record)]
+#[derive(Clone, Copy)]
+pub struct R {}
+impl core::fmt::Debug for R {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("R").finish()
+    }
+}
+const _: () = {
+    assert!(0 == < R as wasmtime::component::ComponentType >::SIZE32);
+    assert!(1 == < R as wasmtime::component::ComponentType >::ALIGN32);
+};
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `foo`.
+///
+/// This structure is created through [`FooPre::new`] which
+/// takes a [`InstancePre`](wasmtime::component::InstancePre) that
+/// has been created through a [`Linker`](wasmtime::component::Linker).
+///
+/// For more information see [`Foo`] as well.
+pub struct FooPre<T> {
+    instance_pre: wasmtime::component::InstancePre<T>,
+    indices: FooIndices,
+}
+impl<T> Clone for FooPre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }
+    }
+}
+impl<_T> FooPre<_T> {
+    /// Creates a new copy of `FooPre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(
+        instance_pre: wasmtime::component::InstancePre<_T>,
+    ) -> wasmtime::Result<Self> {
+        let indices = FooIndices::new(instance_pre.component())?;
+        Ok(Self { instance_pre, indices })
+    }
+    pub fn engine(&self) -> &wasmtime::Engine {
+        self.instance_pre.engine()
+    }
+    pub fn instance_pre(&self) -> &wasmtime::component::InstancePre<_T> {
+        &self.instance_pre
+    }
+    /// Instantiates a new instance of [`Foo`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl wasmtime::AsContextMut<Data = _T>,
+    ) -> wasmtime::Result<Foo>
+    where
+        _T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate_async(&mut store).await?;
+        self.indices.load(&mut store, &instance)
+    }
+}
+/// Auto-generated bindings for index of the exports of
+/// `foo`.
+///
+/// This is an implementation detail of [`FooPre`] and can
+/// be constructed if needed as well.
+///
+/// For more information see [`Foo`] as well.
+#[derive(Clone)]
+pub struct FooIndices {
+    f: wasmtime::component::ComponentExportIndex,
+}
+/// Auto-generated bindings for an instance a component which
+/// implements the world `foo`.
+///
+/// This structure can be created through a number of means
+/// depending on your requirements and what you have on hand:
+///
+/// * The most convenient way is to use
+///   [`Foo::instantiate_async`] which only needs a
+///   [`Store`], [`Component`], and [`Linker`].
+///
+/// * Alternatively you can create a [`FooPre`] ahead of
+///   time with a [`Component`] to front-load string lookups
+///   of exports once instead of per-instantiation. This
+///   method then uses [`FooPre::instantiate_async`] to
+///   create a [`Foo`].
+///
+/// * If you've instantiated the instance yourself already
+///   then you can use [`Foo::new`].
+///
+/// * You can also access the guts of instantiation through
+///   [`FooIndices::new_instance`] followed
+///   by [`FooIndices::load`] to crate an instance of this
+///   type.
+///
+/// These methods are all equivalent to one another and move
+/// around the tradeoff of what work is performed when.
+///
+/// [`Store`]: wasmtime::Store
+/// [`Component`]: wasmtime::component::Component
+/// [`Linker`]: wasmtime::component::Linker
+pub struct Foo {
+    f: wasmtime::component::Func,
+}
+const _: () = {
+    #[allow(unused_imports)]
+    use wasmtime::component::__internal::anyhow;
+    impl FooIndices {
+        /// Creates a new copy of `FooIndices` bindings which can then
+        /// be used to instantiate into a particular store.
+        ///
+        /// This method may fail if the component does not have the
+        /// required exports.
+        pub fn new(
+            component: &wasmtime::component::Component,
+        ) -> wasmtime::Result<Self> {
+            let _component = component;
+            let f = _component
+                .export_index(None, "f")
+                .ok_or_else(|| anyhow::anyhow!("no function export `f` found"))?
+                .1;
+            Ok(FooIndices { f })
+        }
+        /// Creates a new instance of [`FooIndices`] from an
+        /// instantiated component.
+        ///
+        /// This method of creating a [`Foo`] will perform string
+        /// lookups for all exports when this method is called. This
+        /// will only succeed if the provided instance matches the
+        /// requirements of [`Foo`].
+        pub fn new_instance(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Self> {
+            let _instance = instance;
+            let f = _instance
+                .get_export(&mut store, None, "f")
+                .ok_or_else(|| anyhow::anyhow!("no function export `f` found"))?;
+            Ok(FooIndices { f })
+        }
+        /// Uses the indices stored in `self` to load an instance
+        /// of [`Foo`] from the instance provided.
+        ///
+        /// Note that at this time this method will additionally
+        /// perform type-checks of all exports.
+        pub fn load(
+            &self,
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Foo> {
+            let _instance = instance;
+            let f = *_instance
+                .get_typed_func::<(), ((T, U, R),)>(&mut store, &self.f)?
+                .func();
+            Ok(Foo { f })
+        }
+    }
+    impl Foo {
+        /// Convenience wrapper around [`FooPre::new`] and
+        /// [`FooPre::instantiate_async`].
+        pub async fn instantiate_async<_T>(
+            mut store: impl wasmtime::AsContextMut<Data = _T>,
+            component: &wasmtime::component::Component,
+            linker: &wasmtime::component::Linker<_T>,
+        ) -> wasmtime::Result<Foo>
+        where
+            _T: Send,
+        {
+            let pre = linker.instantiate_pre(component)?;
+            FooPre::new(pre)?.instantiate_async(store).await
+        }
+        /// Convenience wrapper around [`FooIndices::new_instance`] and
+        /// [`FooIndices::load`].
+        pub fn new(
+            mut store: impl wasmtime::AsContextMut,
+            instance: &wasmtime::component::Instance,
+        ) -> wasmtime::Result<Foo> {
+            let indices = FooIndices::new_instance(&mut store, instance)?;
+            indices.load(store, instance)
+        }
+        pub fn add_to_linker<T, U>(
+            linker: &mut wasmtime::component::Linker<T>,
+            get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+        ) -> wasmtime::Result<()>
+        where
+            T: Send,
+            U: foo::foo::i::Host + Send,
+        {
+            foo::foo::i::add_to_linker(linker, get)?;
+            Ok(())
+        }
+        pub async fn call_f<S: wasmtime::AsContextMut>(
+            &self,
+            mut store: S,
+        ) -> wasmtime::Result<(T, U, R)>
+        where
+            <S as wasmtime::AsContext>::Data: Send,
+        {
+            let callee = unsafe {
+                wasmtime::component::TypedFunc::<(), ((T, U, R),)>::new_unchecked(self.f)
+            };
+            let (ret0,) = callee.call_async(store.as_context_mut(), ()).await?;
+            callee.post_return_async(store.as_context_mut()).await?;
+            Ok(ret0)
+        }
+    }
+};
+pub mod foo {
+    pub mod foo {
+        #[allow(clippy::all)]
+        pub mod i {
+            #[allow(unused_imports)]
+            use wasmtime::component::__internal::anyhow;
+            pub type T = u16;
+            const _: () = {
+                assert!(2 == < T as wasmtime::component::ComponentType >::SIZE32);
+                assert!(2 == < T as wasmtime::component::ComponentType >::ALIGN32);
+            };
+            #[wasmtime::component::__internal::async_trait]
+            pub trait Host: Send {}
+            pub trait GetHost<
+                T,
+            >: Fn(T) -> <Self as GetHost<T>>::Host + Send + Sync + Copy + 'static {
+                type Host: Host + Send;
+            }
+            impl<F, T, O> GetHost<T> for F
+            where
+                F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                O: Host + Send,
+            {
+                type Host = O;
+            }
+            pub fn add_to_linker_get_host<T>(
+                linker: &mut wasmtime::component::Linker<T>,
+                host_getter: impl for<'a> GetHost<&'a mut T>,
+            ) -> wasmtime::Result<()>
+            where
+                T: Send,
+            {
+                let mut inst = linker.instance("foo:foo/i")?;
+                Ok(())
+            }
+            pub fn add_to_linker<T, U>(
+                linker: &mut wasmtime::component::Linker<T>,
+                get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+            ) -> wasmtime::Result<()>
+            where
+                U: Host + Send,
+                T: Send,
+            {
+                add_to_linker_get_host(linker, get)
+            }
+            #[wasmtime::component::__internal::async_trait]
+            impl<_T: Host + ?Sized + Send> Host for &mut _T {}
+        }
+    }
+}
diff --git a/crates/component-util/Cargo.toml b/crates/component-util/Cargo.toml
index f51f761301ce..d1661b0f9d6b 100644
--- a/crates/component-util/Cargo.toml
+++ b/crates/component-util/Cargo.toml
@@ -9,3 +9,4 @@ documentation = "https://docs.rs/wasmtime-component-util/"
 categories = ["wasm"]
 keywords = ["webassembly", "wasm"]
 edition.workspace = true
+rust-version.workspace = true
diff --git a/crates/component-util/src/lib.rs b/crates/component-util/src/lib.rs
index db1e4b97689e..642b8e34969d 100644
--- a/crates/component-util/src/lib.rs
+++ b/crates/component-util/src/lib.rs
@@ -1,3 +1,5 @@
+#![no_std]
+
 /// Represents the possible sizes in bytes of the discriminant of a variant type in the component model
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum DiscriminantSize {
diff --git a/crates/cranelift-shared/Cargo.toml b/crates/cranelift-shared/Cargo.toml
deleted file mode 100644
index 78446e42add7..000000000000
--- a/crates/cranelift-shared/Cargo.toml
+++ /dev/null
@@ -1,19 +0,0 @@
-[package]
-name = "wasmtime-cranelift-shared"
-version.workspace = true
-authors.workspace = true
-description = "Base-level integration with Wasmtime and Cranelift"
-license = "Apache-2.0 WITH LLVM-exception"
-repository = "https://github.com/bytecodealliance/wasmtime"
-documentation = "https://docs.rs/wasmtime-cranelift-shared/"
-edition.workspace = true
-
-[dependencies]
-anyhow = { workspace = true }
-wasmtime-environ = { workspace = true }
-cranelift-codegen = { workspace = true }
-cranelift-control = { workspace = true }
-cranelift-native = { workspace = true }
-target-lexicon = { workspace = true }
-gimli = { workspace = true }
-object = { workspace = true }
diff --git a/crates/cranelift-shared/src/lib.rs b/crates/cranelift-shared/src/lib.rs
index b508e04a79e6..408c266e0d5c 100644
--- a/crates/cranelift-shared/src/lib.rs
+++ b/crates/cranelift-shared/src/lib.rs
@@ -3,7 +3,6 @@ use cranelift_codegen::{
     ir::{self, ExternalName, UserExternalNameRef},
     settings, FinalizedMachReloc, FinalizedRelocTarget, MachTrap,
 };
-use std::collections::BTreeMap;
 use wasmtime_environ::{FlagValue, FuncIndex, Trap, TrapInformation};
 
 pub mod isa_builder;
@@ -37,16 +36,16 @@ pub enum RelocationTarget {
 /// Converts cranelift_codegen settings to the wasmtime_environ equivalent.
 pub fn clif_flags_to_wasmtime(
     flags: impl IntoIterator<Item = settings::Value>,
-) -> BTreeMap<String, FlagValue> {
+) -> Vec<(&'static str, FlagValue<'static>)> {
     flags
         .into_iter()
-        .map(|val| (val.name.to_string(), to_flag_value(&val)))
+        .map(|val| (val.name, to_flag_value(&val)))
         .collect()
 }
 
-fn to_flag_value(v: &settings::Value) -> FlagValue {
+fn to_flag_value(v: &settings::Value) -> FlagValue<'static> {
     match v.kind() {
-        settings::SettingKind::Enum => FlagValue::Enum(v.as_enum().unwrap().into()),
+        settings::SettingKind::Enum => FlagValue::Enum(v.as_enum().unwrap()),
         settings::SettingKind::Num => FlagValue::Num(v.as_num().unwrap()),
         settings::SettingKind::Bool => FlagValue::Bool(v.as_bool().unwrap()),
         settings::SettingKind::Preset => unreachable!(),
@@ -87,6 +86,7 @@ pub fn mach_trap_to_trap(trap: &MachTrap) -> Option<TrapInformation> {
             ir::TrapCode::User(ALWAYS_TRAP_CODE) => Trap::AlwaysTrapAdapter,
             ir::TrapCode::User(CANNOT_ENTER_CODE) => Trap::CannotEnterComponent,
             ir::TrapCode::NullReference => Trap::NullReference,
+            ir::TrapCode::NullI31Ref => Trap::NullI31Ref,
 
             // These do not get converted to wasmtime traps, since they
             // shouldn't ever be hit in theory. Instead of catching and handling
diff --git a/crates/cranelift/Cargo.toml b/crates/cranelift/Cargo.toml
index e7318e4abc42..7aee4ea58af7 100644
--- a/crates/cranelift/Cargo.toml
+++ b/crates/cranelift/Cargo.toml
@@ -9,28 +9,36 @@ documentation = "https://docs.rs/wasmtime-cranelift/"
 categories = ["wasm"]
 keywords = ["webassembly", "wasm"]
 edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
 
 [dependencies]
 anyhow = { workspace = true }
 log = { workspace = true }
-wasmtime-environ = { workspace = true }
+wasmtime-environ = { workspace = true, features = ['compile'] }
 cranelift-wasm = { workspace = true }
-cranelift-codegen = { workspace = true }
+cranelift-codegen = { workspace = true, features = ["host-arch"] }
 cranelift-frontend = { workspace = true }
 cranelift-entity = { workspace = true }
 cranelift-native = { workspace = true }
 cranelift-control = { workspace = true }
-wasmtime-cranelift-shared = { workspace = true }
 wasmparser = { workspace = true }
 target-lexicon = { workspace = true }
-gimli = { workspace = true }
-object = { workspace = true, features = ['write'] }
+gimli = { workspace = true, features = ['std'] }
+object = { workspace = true, features = ['write', 'std'] }
+smallvec = { workspace = true }
 thiserror = { workspace = true }
 cfg-if = { workspace = true }
 wasmtime-versioned-export-macros = { workspace = true }
 
 [features]
 all-arch = ["cranelift-codegen/all-arch"]
+trace-log = ["cranelift-codegen/trace-log"]
+host-arch = ["cranelift-codegen/host-arch"]
 component-model = ["wasmtime-environ/component-model"]
 incremental-cache = ["cranelift-codegen/incremental-cache"]
-wmemcheck = []
+wmemcheck = ["wasmtime-environ/wmemcheck"]
+gc = ["wasmtime-environ/gc"]
+threads = ["wasmtime-environ/threads"]
diff --git a/crates/cranelift/src/builder.rs b/crates/cranelift/src/builder.rs
index b2c86107cb7c..58df015e97a1 100644
--- a/crates/cranelift/src/builder.rs
+++ b/crates/cranelift/src/builder.rs
@@ -3,6 +3,7 @@
 //! This module contains the implementation of how Cranelift is configured, as
 //! well as providing a function to return the default configuration to build.
 
+use crate::isa_builder::IsaBuilder;
 use anyhow::Result;
 use cranelift_codegen::{
     isa::{self, OwnedTargetIsa},
@@ -11,11 +12,11 @@ use cranelift_codegen::{
 use std::fmt;
 use std::path;
 use std::sync::Arc;
-use wasmtime_cranelift_shared::isa_builder::IsaBuilder;
+use target_lexicon::Triple;
 use wasmtime_environ::{CacheStore, CompilerBuilder, Setting, Tunables};
 
 struct Builder {
-    tunables: Tunables,
+    tunables: Option<Tunables>,
     inner: IsaBuilder<CodegenResult<OwnedTargetIsa>>,
     linkopts: LinkOptions,
     cache_store: Option<Arc<dyn CacheStore>>,
@@ -36,15 +37,15 @@ pub struct LinkOptions {
     pub force_jump_veneers: bool,
 }
 
-pub fn builder() -> Box<dyn CompilerBuilder> {
-    Box::new(Builder {
-        tunables: Tunables::default(),
-        inner: IsaBuilder::new(|triple| isa::lookup(triple).map_err(|e| e.into())),
+pub fn builder(triple: Option<Triple>) -> Result<Box<dyn CompilerBuilder>> {
+    Ok(Box::new(Builder {
+        tunables: None,
+        inner: IsaBuilder::new(triple, |triple| isa::lookup(triple).map_err(|e| e.into()))?,
         linkopts: LinkOptions::default(),
         cache_store: None,
         clif_dir: None,
         wmemcheck: false,
-    })
+    }))
 }
 
 impl CompilerBuilder for Builder {
@@ -81,14 +82,17 @@ impl CompilerBuilder for Builder {
     }
 
     fn set_tunables(&mut self, tunables: Tunables) -> Result<()> {
-        self.tunables = tunables;
+        self.tunables = Some(tunables);
         Ok(())
     }
 
     fn build(&self) -> Result<Box<dyn wasmtime_environ::Compiler>> {
         let isa = self.inner.build()?;
         Ok(Box::new(crate::compiler::Compiler::new(
-            self.tunables.clone(),
+            self.tunables
+                .as_ref()
+                .expect("set_tunables not called")
+                .clone(),
             isa,
             self.cache_store.clone(),
             self.linkopts.clone(),
diff --git a/crates/cranelift-shared/src/compiled_function.rs b/crates/cranelift/src/compiled_function.rs
similarity index 87%
rename from crates/cranelift-shared/src/compiled_function.rs
rename to crates/cranelift/src/compiled_function.rs
index 949c276c3b13..24732f003f9b 100644
--- a/crates/cranelift-shared/src/compiled_function.rs
+++ b/crates/cranelift/src/compiled_function.rs
@@ -1,15 +1,9 @@
 use crate::{mach_reloc_to_reloc, mach_trap_to_trap, Relocation};
 use cranelift_codegen::{
-    ir, ir::UserExternalNameRef, isa::unwind::CfaUnwindInfo, isa::unwind::UnwindInfo, Final,
-    MachBufferFinalized, MachSrcLoc, ValueLabelsRanges,
+    ir, isa::unwind::CfaUnwindInfo, isa::unwind::UnwindInfo, Final, MachBufferFinalized,
+    MachSrcLoc, ValueLabelsRanges,
 };
-use wasmtime_environ::{FilePos, InstructionAddressMap, TrapInformation};
-
-/// Trait used in the [CompiledFunction] to resolve the locations of
-/// external name references in a compiled function.
-pub trait CompiledFuncEnv {
-    fn resolve_user_external_name_ref(&self, external: UserExternalNameRef) -> (u32, u32);
-}
+use wasmtime_environ::{FilePos, InstructionAddressMap, PrimaryMap, TrapInformation};
 
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
 /// Metadata to translate from binary offsets back to the original
@@ -59,11 +53,11 @@ pub struct CompiledFunctionMetadata {
 }
 
 /// Compiled function: machine code body, jump table offsets, and unwind information.
-pub struct CompiledFunction<E: CompiledFuncEnv> {
+pub struct CompiledFunction {
     /// The machine code buffer for this function.
     pub buffer: MachBufferFinalized<Final>,
-    /// The environment for the compiled function.
-    env: E,
+    /// What names each name ref corresponds to.
+    name_map: PrimaryMap<ir::UserExternalNameRef, ir::UserExternalName>,
     /// The alignment for the compiled function.
     pub alignment: u32,
     /// The metadata for the compiled function, including unwind information
@@ -71,17 +65,18 @@ pub struct CompiledFunction<E: CompiledFuncEnv> {
     metadata: CompiledFunctionMetadata,
 }
 
-impl<E: CompiledFuncEnv> CompiledFunction<E>
-where
-    E: CompiledFuncEnv,
-{
-    /// Creates a [CompiledFunction] from a [cranelift_codegen::MachBufferFinalized<Final>]
+impl CompiledFunction {
+    /// Creates a [CompiledFunction] from a [`cranelift_codegen::MachBufferFinalized<Final>`]
     /// This function uses the information in the machine buffer to derive the traps and relocations
     /// fields. The compiled function metadata is loaded with the default values.
-    pub fn new(buffer: MachBufferFinalized<Final>, env: E, alignment: u32) -> Self {
+    pub fn new(
+        buffer: MachBufferFinalized<Final>,
+        name_map: PrimaryMap<ir::UserExternalNameRef, ir::UserExternalName>,
+        alignment: u32,
+    ) -> Self {
         Self {
             buffer,
-            env,
+            name_map,
             alignment,
             metadata: Default::default(),
         }
@@ -89,11 +84,10 @@ where
 
     /// Returns an iterator to the function's relocation information.
     pub fn relocations(&self) -> impl Iterator<Item = Relocation> + '_ {
-        self.buffer.relocs().iter().map(|r| {
-            mach_reloc_to_reloc(r, |external| {
-                self.env.resolve_user_external_name_ref(external)
-            })
-        })
+        self.buffer
+            .relocs()
+            .iter()
+            .map(|r| mach_reloc_to_reloc(r, &self.name_map))
     }
 
     /// Returns an iterator to the function's trap information.
diff --git a/crates/cranelift/src/compiler.rs b/crates/cranelift/src/compiler.rs
index 9bc954a4cbef..a25679b6e5e6 100644
--- a/crates/cranelift/src/compiler.rs
+++ b/crates/cranelift/src/compiler.rs
@@ -1,40 +1,35 @@
-use crate::debug::{DwarfSectionRelocTarget, ModuleMemoryOffset};
+use crate::debug::DwarfSectionRelocTarget;
 use crate::func_environ::FuncEnvironment;
-use crate::{array_call_signature, native_call_signature, DEBUG_ASSERT_TRAP_CODE};
-use crate::{builder::LinkOptions, value_type, wasm_call_signature};
+use crate::DEBUG_ASSERT_TRAP_CODE;
+use crate::{array_call_signature, CompiledFunction, ModuleTextBuilder};
+use crate::{builder::LinkOptions, wasm_call_signature, BuiltinFunctionSignatures};
 use anyhow::{Context as _, Result};
-use cranelift_codegen::ir::{
-    self, InstBuilder, MemFlags, UserExternalName, UserExternalNameRef, UserFuncName, Value,
-};
+use cranelift_codegen::binemit::CodeOffset;
+use cranelift_codegen::bitset::CompoundBitSet;
+use cranelift_codegen::ir::{self, InstBuilder, MemFlags, UserExternalName, UserFuncName, Value};
 use cranelift_codegen::isa::{
     unwind::{UnwindInfo, UnwindInfoKind},
     OwnedTargetIsa, TargetIsa,
 };
 use cranelift_codegen::print_errors::pretty_error;
-use cranelift_codegen::Context;
-use cranelift_codegen::{CompiledCode, MachStackMap};
-use cranelift_entity::{EntityRef, PrimaryMap};
+use cranelift_codegen::{CompiledCode, Context};
+use cranelift_entity::PrimaryMap;
 use cranelift_frontend::FunctionBuilder;
-use cranelift_wasm::{
-    DefinedFuncIndex, FuncIndex, FuncTranslator, MemoryIndex, OwnedMemoryIndex, WasmFuncType,
-    WasmType,
-};
+use cranelift_wasm::{DefinedFuncIndex, FuncTranslator, WasmFuncType, WasmValType};
 use object::write::{Object, StandardSegment, SymbolId};
-use object::{RelocationEncoding, RelocationKind, SectionKind};
+use object::{RelocationEncoding, RelocationFlags, RelocationKind, SectionKind};
 use std::any::Any;
 use std::cmp;
-use std::collections::BTreeMap;
 use std::collections::HashMap;
-use std::convert::TryFrom;
 use std::mem;
 use std::path;
 use std::sync::{Arc, Mutex};
 use wasmparser::{FuncValidatorAllocations, FunctionBody};
-use wasmtime_cranelift_shared::{CompiledFunction, ModuleTextBuilder};
 use wasmtime_environ::{
-    AddressMapSection, CacheStore, CompileError, FlagValue, FunctionBodyData, FunctionLoc,
-    ModuleTranslation, ModuleTypes, PtrSize, StackMapInformation, TrapEncodingBuilder, Tunables,
-    VMOffsets, WasmFunctionInfo,
+    AddressMapSection, BuiltinFunctionIndex, CacheStore, CompileError, FlagValue, FunctionBodyData,
+    FunctionLoc, ModuleTranslation, ModuleTypesBuilder, PtrSize, RelocationTarget,
+    StackMapInformation, StaticModuleIndex, TrapEncodingBuilder, Tunables, VMOffsets,
+    WasmFunctionInfo,
 };
 
 #[cfg(feature = "component-model")]
@@ -67,7 +62,7 @@ impl Default for CompilerContext {
 
 /// A compiler that compiles a WebAssembly module with Compiler, translating
 /// the Wasm to Compiler IR, optimizing it and then translating to assembly.
-pub(crate) struct Compiler {
+pub struct Compiler {
     tunables: Tunables,
     contexts: Mutex<Vec<CompilerContext>>,
     isa: OwnedTargetIsa,
@@ -106,7 +101,7 @@ impl Drop for Compiler {
 }
 
 impl Compiler {
-    pub(crate) fn new(
+    pub fn new(
         tunables: Tunables,
         isa: OwnedTargetIsa,
         cache_store: Option<Arc<dyn CacheStore>>,
@@ -132,20 +127,20 @@ impl wasmtime_environ::Compiler for Compiler {
         translation: &ModuleTranslation<'_>,
         func_index: DefinedFuncIndex,
         input: FunctionBodyData<'_>,
-        types: &ModuleTypes,
+        types: &ModuleTypesBuilder,
     ) -> Result<(WasmFunctionInfo, Box<dyn Any + Send>), CompileError> {
         let isa = &*self.isa;
         let module = &translation.module;
         let func_index = module.func_index(func_index);
         let sig = translation.module.functions[func_index].signature;
-        let wasm_func_ty = &types[sig];
+        let wasm_func_ty = types[sig].unwrap_func();
 
         let mut compiler = self.function_compiler();
 
         let context = &mut compiler.cx.codegen_context;
         context.func.signature = wasm_call_signature(isa, wasm_func_ty, &self.tunables);
         context.func.name = UserFuncName::User(UserExternalName {
-            namespace: 0,
+            namespace: crate::NS_WASM_FUNC,
             index: func_index.as_u32(),
         });
 
@@ -153,8 +148,14 @@ impl wasmtime_environ::Compiler for Compiler {
             context.func.collect_debug_info();
         }
 
-        let mut func_env =
-            FuncEnvironment::new(isa, translation, types, &self.tunables, self.wmemcheck);
+        let mut func_env = FuncEnvironment::new(
+            isa,
+            translation,
+            types,
+            &self.tunables,
+            self.wmemcheck,
+            wasm_func_ty,
+        );
 
         // The `stack_limit` global value below is the implementation of stack
         // overflow checks in Wasmtime.
@@ -193,11 +194,9 @@ impl wasmtime_environ::Compiler for Compiler {
             .create_global_value(ir::GlobalValueData::VMContext);
         let interrupts_ptr = context.func.create_global_value(ir::GlobalValueData::Load {
             base: vmctx,
-            offset: i32::try_from(func_env.offsets.vmctx_runtime_limits())
-                .unwrap()
-                .into(),
+            offset: i32::from(func_env.offsets.ptr.vmctx_runtime_limits()).into(),
             global_type: isa.pointer_type(),
-            readonly: true,
+            flags: MemFlags::trusted().with_readonly(),
         });
         let stack_limit = context.func.create_global_value(ir::GlobalValueData::Load {
             base: interrupts_ptr,
@@ -205,7 +204,7 @@ impl wasmtime_environ::Compiler for Compiler {
                 .unwrap()
                 .into(),
             global_type: isa.pointer_type(),
-            readonly: false,
+            flags: MemFlags::trusted(),
         });
         context.func.stack_limit = Some(stack_limit);
         let FunctionBodyData { validator, body } = input;
@@ -241,12 +240,12 @@ impl wasmtime_environ::Compiler for Compiler {
     fn compile_array_to_wasm_trampoline(
         &self,
         translation: &ModuleTranslation<'_>,
-        types: &ModuleTypes,
+        types: &ModuleTypesBuilder,
         def_func_index: DefinedFuncIndex,
     ) -> Result<Box<dyn Any + Send>, CompileError> {
         let func_index = translation.module.func_index(def_func_index);
         let sig = translation.module.functions[func_index].signature;
-        let wasm_func_ty = &types[sig];
+        let wasm_func_ty = types[sig].unwrap_func();
 
         let isa = &*self.isa;
         let pointer_type = isa.pointer_type();
@@ -278,12 +277,12 @@ impl wasmtime_environ::Compiler for Compiler {
         // what we are assuming with our offsets below.
         debug_assert_vmctx_kind(isa, &mut builder, vmctx, wasmtime_environ::VMCONTEXT_MAGIC);
         let offsets = VMOffsets::new(isa.pointer_bytes(), &translation.module);
-        let vm_runtime_limits_offset = offsets.vmctx_runtime_limits();
+        let vm_runtime_limits_offset = offsets.ptr.vmctx_runtime_limits();
         save_last_wasm_entry_sp(
             &mut builder,
             pointer_type,
             &offsets.ptr,
-            vm_runtime_limits_offset,
+            vm_runtime_limits_offset.into(),
             vmctx,
         );
 
@@ -306,77 +305,23 @@ impl wasmtime_environ::Compiler for Compiler {
         Ok(Box::new(compiler.finish()?))
     }
 
-    fn compile_native_to_wasm_trampoline(
-        &self,
-        translation: &ModuleTranslation<'_>,
-        types: &ModuleTypes,
-        def_func_index: DefinedFuncIndex,
-    ) -> Result<Box<dyn Any + Send>, CompileError> {
-        let func_index = translation.module.func_index(def_func_index);
-        let sig = translation.module.functions[func_index].signature;
-        let wasm_func_ty = &types[sig];
-
-        let isa = &*self.isa;
-        let pointer_type = isa.pointer_type();
-        let func_index = translation.module.func_index(def_func_index);
-        let wasm_call_sig = wasm_call_signature(isa, wasm_func_ty, &self.tunables);
-        let native_call_sig = native_call_signature(isa, wasm_func_ty);
-
-        let mut compiler = self.function_compiler();
-        let func = ir::Function::with_name_signature(Default::default(), native_call_sig);
-        let (mut builder, block0) = compiler.builder(func);
-
-        let args = builder.func.dfg.block_params(block0).to_vec();
-        let vmctx = args[0];
-
-        // Since we are entering Wasm, save our SP.
-        //
-        // Assert that we were really given a core Wasm vmctx, since that's
-        // what we are assuming with our offsets below.
-        debug_assert_vmctx_kind(isa, &mut builder, vmctx, wasmtime_environ::VMCONTEXT_MAGIC);
-        let offsets = VMOffsets::new(isa.pointer_bytes(), &translation.module);
-        let vm_runtime_limits_offset = offsets.vmctx_runtime_limits();
-        save_last_wasm_entry_sp(
-            &mut builder,
-            pointer_type,
-            &offsets.ptr,
-            vm_runtime_limits_offset,
-            vmctx,
-        );
-
-        let ret = NativeRet::classify(pointer_type, wasm_func_ty);
-        let wasm_args = ret.native_args(&args);
-
-        // Then call into Wasm.
-        let call = declare_and_call(&mut builder, wasm_call_sig, func_index.as_u32(), wasm_args);
-
-        // Forward the results along.
-        let results = builder.func.dfg.inst_results(call).to_vec();
-        ret.native_return(&mut builder, block0, &results);
-        builder.finalize();
-
-        Ok(Box::new(compiler.finish()?))
-    }
-
-    fn compile_wasm_to_native_trampoline(
+    fn compile_wasm_to_array_trampoline(
         &self,
         wasm_func_ty: &WasmFuncType,
     ) -> Result<Box<dyn Any + Send>, CompileError> {
         let isa = &*self.isa;
         let pointer_type = isa.pointer_type();
         let wasm_call_sig = wasm_call_signature(isa, wasm_func_ty, &self.tunables);
-        let native_call_sig = native_call_signature(isa, wasm_func_ty);
+        let array_call_sig = array_call_signature(isa);
 
         let mut compiler = self.function_compiler();
         let func = ir::Function::with_name_signature(Default::default(), wasm_call_sig);
         let (mut builder, block0) = compiler.builder(func);
 
-        let mut args = builder.func.dfg.block_params(block0).to_vec();
+        let args = builder.func.dfg.block_params(block0).to_vec();
         let callee_vmctx = args[0];
         let caller_vmctx = args[1];
 
-        let ret = NativeRet::classify(pointer_type, wasm_func_ty);
-
         // We are exiting Wasm, so save our PC and FP.
         //
         // Assert that the caller vmctx really is a core Wasm vmctx, since
@@ -396,50 +341,31 @@ impl wasmtime_environ::Compiler for Compiler {
         );
         save_last_wasm_exit_fp_and_pc(&mut builder, pointer_type, &ptr, limits);
 
-        // If the native call signature for this function uses a return pointer
-        // then allocate the return pointer here on the stack and pass it as the
-        // last argument.
-        let slot = match &ret {
-            NativeRet::Bare => None,
-            NativeRet::Retptr { size, .. } => Some(builder.func.create_sized_stack_slot(
-                ir::StackSlotData::new(ir::StackSlotKind::ExplicitSlot, *size),
-            )),
-        };
-        if let Some(slot) = slot {
-            args.push(builder.ins().stack_addr(pointer_type, slot, 0));
-        }
+        // Spill all wasm arguments to the stack in `ValRaw` slots.
+        let (args_base, args_len) =
+            self.allocate_stack_array_and_spill_args(wasm_func_ty, &mut builder, &args[2..]);
+        let args_len = builder.ins().iconst(pointer_type, i64::from(args_len));
 
         // Load the actual callee out of the
-        // `VMNativeCallHostFuncContext::host_func`.
+        // `VMArrayCallHostFuncContext::host_func`.
         let ptr_size = isa.pointer_bytes();
         let callee = builder.ins().load(
             pointer_type,
             MemFlags::trusted(),
             callee_vmctx,
-            ptr_size.vmnative_call_host_func_context_func_ref()
-                + ptr_size.vm_func_ref_native_call(),
+            ptr_size.vmarray_call_host_func_context_func_ref() + ptr_size.vm_func_ref_array_call(),
         );
 
         // Do an indirect call to the callee.
-        let callee_signature = builder.func.import_signature(native_call_sig);
-        let call = builder.ins().call_indirect(callee_signature, callee, &args);
-
-        // Forward the results back to the caller. If a return pointer was in
-        // use for the native call then load the results from the return pointer
-        // to pass through as native return values in the wasm abi.
-        let mut results = builder.func.dfg.inst_results(call).to_vec();
-        if let NativeRet::Retptr { offsets, .. } = ret {
-            let slot = *args.last().unwrap();
-            assert_eq!(offsets.len(), wasm_func_ty.returns().len() - 1);
-            for (ty, offset) in wasm_func_ty.returns()[1..].iter().zip(offsets) {
-                let ty = crate::value_type(isa, *ty);
-                results.push(
-                    builder
-                        .ins()
-                        .load(ty, MemFlags::trusted(), slot, offset as i32),
-                );
-            }
-        }
+        let callee_signature = builder.func.import_signature(array_call_sig);
+        builder.ins().call_indirect(
+            callee_signature,
+            callee,
+            &[callee_vmctx, caller_vmctx, args_base, args_len],
+        );
+
+        let results =
+            self.load_values_from_array(wasm_func_ty.returns(), &mut builder, args_base, args_len);
         builder.ins().return_(&results);
         builder.finalize();
 
@@ -450,7 +376,7 @@ impl wasmtime_environ::Compiler for Compiler {
         &self,
         obj: &mut Object<'static>,
         funcs: &[(String, Box<dyn Any + Send>)],
-        resolve_reloc: &dyn Fn(usize, FuncIndex) -> usize,
+        resolve_reloc: &dyn Fn(usize, RelocationTarget) -> usize,
     ) -> Result<Vec<(SymbolId, FunctionLoc)>> {
         let mut builder =
             ModuleTextBuilder::new(obj, self, self.isa.text_section_builder(funcs.len()));
@@ -462,9 +388,7 @@ impl wasmtime_environ::Compiler for Compiler {
 
         let mut ret = Vec::with_capacity(funcs.len());
         for (i, (sym, func)) in funcs.iter().enumerate() {
-            let func = func
-                .downcast_ref::<CompiledFunction<CompiledFuncEnv>>()
-                .unwrap();
+            let func = func.downcast_ref::<CompiledFunction>().unwrap();
             let (sym, range) = builder.append_func(&sym, func, |idx| resolve_reloc(i, idx));
             if self.tunables.generate_address_map {
                 let addr = func.address_map();
@@ -489,45 +413,16 @@ impl wasmtime_environ::Compiler for Compiler {
         Ok(ret)
     }
 
-    fn emit_trampolines_for_array_call_host_func(
-        &self,
-        ty: &WasmFuncType,
-        host_fn: usize,
-        obj: &mut Object<'static>,
-    ) -> Result<(FunctionLoc, FunctionLoc)> {
-        let mut wasm_to_array = self.wasm_to_array_trampoline(ty, host_fn)?;
-        let mut native_to_array = self.native_to_array_trampoline(ty, host_fn)?;
-
-        let mut builder = ModuleTextBuilder::new(obj, self, self.isa.text_section_builder(2));
-
-        let (_, wasm_to_array) =
-            builder.append_func("wasm_to_array", &mut wasm_to_array, |_| unreachable!());
-        let (_, native_to_array) =
-            builder.append_func("native_to_array", &mut native_to_array, |_| unreachable!());
-
-        let wasm_to_array = FunctionLoc {
-            start: u32::try_from(wasm_to_array.start).unwrap(),
-            length: u32::try_from(wasm_to_array.end - wasm_to_array.start).unwrap(),
-        };
-        let native_to_array = FunctionLoc {
-            start: u32::try_from(native_to_array.start).unwrap(),
-            length: u32::try_from(native_to_array.end - native_to_array.start).unwrap(),
-        };
-
-        builder.finish();
-        Ok((wasm_to_array, native_to_array))
-    }
-
     fn triple(&self) -> &target_lexicon::Triple {
         self.isa.triple()
     }
 
-    fn flags(&self) -> BTreeMap<String, FlagValue> {
-        wasmtime_cranelift_shared::clif_flags_to_wasmtime(self.isa.flags().iter())
+    fn flags(&self) -> Vec<(&'static str, FlagValue<'static>)> {
+        crate::clif_flags_to_wasmtime(self.isa.flags().iter())
     }
 
-    fn isa_flags(&self) -> BTreeMap<String, FlagValue> {
-        wasmtime_cranelift_shared::clif_flags_to_wasmtime(self.isa.isa_flags())
+    fn isa_flags(&self) -> Vec<(&'static str, FlagValue<'static>)> {
+        crate::clif_flags_to_wasmtime(self.isa.isa_flags())
     }
 
     fn is_branch_protection_enabled(&self) -> bool {
@@ -539,55 +434,33 @@ impl wasmtime_environ::Compiler for Compiler {
         self
     }
 
-    fn append_dwarf(
+    fn append_dwarf<'a>(
         &self,
         obj: &mut Object<'_>,
-        translation: &ModuleTranslation<'_>,
-        funcs: &PrimaryMap<DefinedFuncIndex, (SymbolId, &(dyn Any + Send))>,
+        translations: &'a PrimaryMap<StaticModuleIndex, ModuleTranslation<'a>>,
+        get_func: &'a dyn Fn(
+            StaticModuleIndex,
+            DefinedFuncIndex,
+        ) -> (SymbolId, &'a (dyn Any + Send)),
+        dwarf_package_bytes: Option<&'a [u8]>,
+        tunables: &'a Tunables,
     ) -> Result<()> {
-        let ofs = VMOffsets::new(
-            self.isa
-                .triple()
-                .architecture
-                .pointer_width()
-                .unwrap()
-                .bytes(),
-            &translation.module,
-        );
-
-        let memory_offset = if ofs.num_imported_memories > 0 {
-            ModuleMemoryOffset::Imported(ofs.vmctx_vmmemory_import(MemoryIndex::new(0)))
-        } else if ofs.num_defined_memories > 0 {
-            // The addition of shared memory makes the following assumption,
-            // "owned memory index = 0", possibly false. If the first memory
-            // is a shared memory, the base pointer will not be stored in
-            // the `owned_memories` array. The following code should
-            // eventually be fixed to not only handle shared memories but
-            // also multiple memories.
-            assert_eq!(
-                ofs.num_defined_memories, ofs.num_owned_memories,
-                "the memory base pointer may be incorrect due to sharing memory"
-            );
-            ModuleMemoryOffset::Defined(
-                ofs.vmctx_vmmemory_definition_base(OwnedMemoryIndex::new(0)),
+        let get_func = move |m, f| {
+            let (sym, any) = get_func(m, f);
+            (
+                sym,
+                any.downcast_ref::<CompiledFunction>().unwrap().metadata(),
             )
-        } else {
-            ModuleMemoryOffset::None
         };
-        let functions_info = funcs
-            .iter()
-            .map(|(_, (_, func))| {
-                let f: &CompiledFunction<CompiledFuncEnv> = func.downcast_ref().unwrap();
-                f.metadata()
-            })
-            .collect();
-        let dwarf_sections = crate::debug::emit_dwarf(
+        let mut compilation = crate::debug::Compilation::new(
             &*self.isa,
-            &translation.debuginfo,
-            &functions_info,
-            &memory_offset,
-        )
-        .with_context(|| "failed to emit DWARF debug information")?;
+            translations,
+            &get_func,
+            dwarf_package_bytes,
+            tunables,
+        );
+        let dwarf_sections = crate::debug::emit_dwarf(&*self.isa, &mut compilation)
+            .with_context(|| "failed to emit DWARF debug information")?;
 
         let (debug_bodies, debug_relocs): (Vec<_>, Vec<_>) = dwarf_sections
             .iter()
@@ -606,7 +479,7 @@ impl wasmtime_environ::Compiler for Compiler {
             let section_id = *dwarf_sections_ids.get(name).unwrap();
             for reloc in relocs {
                 let target_symbol = match reloc.target {
-                    DwarfSectionRelocTarget::Func(index) => funcs[DefinedFuncIndex::new(index)].0,
+                    DwarfSectionRelocTarget::Func(id) => compilation.symbol_id(id),
                     DwarfSectionRelocTarget::Section(name) => {
                         obj.section_symbol(dwarf_sections_ids[name])
                     }
@@ -615,11 +488,13 @@ impl wasmtime_environ::Compiler for Compiler {
                     section_id,
                     object::write::Relocation {
                         offset: u64::from(reloc.offset),
-                        size: reloc.size << 3,
-                        kind: RelocationKind::Absolute,
-                        encoding: RelocationEncoding::Generic,
                         symbol: target_symbol,
                         addend: i64::from(reloc.addend),
+                        flags: RelocationFlags::Generic {
+                            size: reloc.size << 3,
+                            kind: RelocationKind::Absolute,
+                            encoding: RelocationEncoding::Generic,
+                        },
                     },
                 )?;
             }
@@ -631,6 +506,68 @@ impl wasmtime_environ::Compiler for Compiler {
     fn create_systemv_cie(&self) -> Option<gimli::write::CommonInformationEntry> {
         self.isa.create_systemv_cie()
     }
+
+    fn compile_wasm_to_builtin(
+        &self,
+        index: BuiltinFunctionIndex,
+    ) -> Result<Box<dyn Any + Send>, CompileError> {
+        let isa = &*self.isa;
+        let ptr_size = isa.pointer_bytes();
+        let pointer_type = isa.pointer_type();
+        let sig = BuiltinFunctionSignatures::new(isa).signature(index);
+
+        let mut compiler = self.function_compiler();
+        let func = ir::Function::with_name_signature(Default::default(), sig.clone());
+        let (mut builder, block0) = compiler.builder(func);
+        let vmctx = builder.block_params(block0)[0];
+
+        // Debug-assert that this is the right kind of vmctx, and then
+        // additionally perform the "routine of the exit trampoline" of saving
+        // fp/pc/etc.
+        debug_assert_vmctx_kind(isa, &mut builder, vmctx, wasmtime_environ::VMCONTEXT_MAGIC);
+        let limits = builder.ins().load(
+            pointer_type,
+            MemFlags::trusted(),
+            vmctx,
+            ptr_size.vmcontext_runtime_limits(),
+        );
+        save_last_wasm_exit_fp_and_pc(&mut builder, pointer_type, &ptr_size, limits);
+
+        // Now it's time to delegate to the actual builtin. Builtins are stored
+        // in an array in all `VMContext`s. First load the base pointer of the
+        // array and then load the entry of the array that corresponds to this
+        // builtin.
+        let mem_flags = ir::MemFlags::trusted().with_readonly();
+        let array_addr = builder.ins().load(
+            pointer_type,
+            mem_flags,
+            vmctx,
+            i32::try_from(ptr_size.vmcontext_builtin_functions()).unwrap(),
+        );
+        let body_offset = i32::try_from(index.index() * pointer_type.bytes()).unwrap();
+        let func_addr = builder
+            .ins()
+            .load(pointer_type, mem_flags, array_addr, body_offset);
+
+        // Forward all our own arguments to the libcall itself, and then return
+        // all the same results as the libcall.
+        let block_params = builder.block_params(block0).to_vec();
+        let sig = builder.func.import_signature(sig);
+        let call = builder.ins().call_indirect(sig, func_addr, &block_params);
+        let results = builder.func.dfg.inst_results(call).to_vec();
+        builder.ins().return_(&results);
+        builder.finalize();
+
+        Ok(Box::new(compiler.finish()?))
+    }
+
+    fn compiled_function_relocation_targets<'a>(
+        &'a self,
+        func: &'a dyn Any,
+    ) -> Box<dyn Iterator<Item = RelocationTarget> + 'a> {
+        let func = func.downcast_ref::<CompiledFunction>().unwrap();
+        Box::new(func.relocations().map(|r| r.reloc_target))
+    }
 }
 
 #[cfg(feature = "incremental-cache")]
@@ -697,154 +634,6 @@ fn compile_uncached<'a>(
 }
 
 impl Compiler {
-    /// Creates a trampoline for calling a host function callee defined with the
-    /// "array" calling convention from a native calling convention caller.
-    ///
-    /// This style of trampoline is used with `Func::new`-style callees and
-    /// `TypedFunc::call`-style callers.
-    ///
-    /// Both callee and caller are on the host side, so there is no host/Wasm
-    /// transition and associated entry/exit state to maintain.
-    ///
-    /// The `host_fn` is a function pointer in this process with the following
-    /// signature:
-    ///
-    /// ```ignore
-    /// unsafe extern "C" fn(*mut VMContext, *mut VMContext, *mut ValRaw, usize)
-    /// ```
-    ///
-    /// where the first two arguments are forwarded from the trampoline
-    /// generated here itself, and the second two arguments are a pointer/length
-    /// into stack-space of this trampoline with storage for both the arguments
-    /// to the function and the results.
-    ///
-    /// Note that `host_fn` is an immediate which is an actual function pointer
-    /// in this process. As such this compiled trampoline is not suitable for
-    /// serialization.
-    fn native_to_array_trampoline(
-        &self,
-        ty: &WasmFuncType,
-        host_fn: usize,
-    ) -> Result<CompiledFunction<CompiledFuncEnv>, CompileError> {
-        let isa = &*self.isa;
-        let pointer_type = isa.pointer_type();
-        let native_call_sig = native_call_signature(isa, ty);
-        let array_call_sig = array_call_signature(isa);
-
-        let mut compiler = self.function_compiler();
-        let func = ir::Function::with_name_signature(Default::default(), native_call_sig);
-        let (mut builder, block0) = compiler.builder(func);
-        let args = builder.func.dfg.block_params(block0).to_vec();
-
-        let ret = NativeRet::classify(pointer_type, ty);
-        let wasm_args = &ret.native_args(&args)[2..];
-
-        let (values_vec_ptr, values_vec_len) =
-            self.allocate_stack_array_and_spill_args(ty, &mut builder, wasm_args);
-        let values_vec_len = builder
-            .ins()
-            .iconst(pointer_type, i64::from(values_vec_len));
-
-        let callee_args = [args[0], args[1], values_vec_ptr, values_vec_len];
-
-        let new_sig = builder.import_signature(array_call_sig);
-        let callee_value = builder.ins().iconst(pointer_type, host_fn as i64);
-        builder
-            .ins()
-            .call_indirect(new_sig, callee_value, &callee_args);
-
-        let results =
-            self.load_values_from_array(ty.returns(), &mut builder, values_vec_ptr, values_vec_len);
-        ret.native_return(&mut builder, block0, &results);
-        builder.finalize();
-
-        compiler.finish()
-    }
-
-    /// Creates a trampoline for WebAssembly to call a host function defined
-    /// with the "array" calling convention: where all the arguments are spilled
-    /// to an array on the stack and results are loaded from the stack array.
-    ///
-    /// This style of trampoline is currently only used with the
-    /// `Func::new`-style created functions in the Wasmtime embedding API. The
-    /// generated trampoline has a function signature appropriate to the `ty`
-    /// specified (e.g. a System-V ABI) and will call a `host_fn` that has a
-    /// type signature of:
-    ///
-    /// ```ignore
-    /// unsafe extern "C" fn(*mut VMContext, *mut VMContext, *mut ValRaw, usize)
-    /// ```
-    ///
-    /// where the first two arguments are forwarded from the trampoline
-    /// generated here itself, and the second two arguments are a pointer/length
-    /// into stack-space of this trampoline with storage for both the arguments
-    /// to the function and the results.
-    ///
-    /// Note that `host_fn` is an immediate which is an actual function pointer
-    /// in this process, and `limits` is a pointer to `VMRuntimeLimits`. As such
-    /// this compiled trampoline is not suitable for serialization, and only
-    /// valid for a particular store.
-    fn wasm_to_array_trampoline(
-        &self,
-        ty: &WasmFuncType,
-        host_fn: usize,
-    ) -> Result<CompiledFunction<CompiledFuncEnv>, CompileError> {
-        let isa = &*self.isa;
-        let pointer_type = isa.pointer_type();
-        let wasm_call_sig = wasm_call_signature(isa, ty, &self.tunables);
-        let array_call_sig = array_call_signature(isa);
-
-        let mut compiler = self.function_compiler();
-        let func = ir::Function::with_name_signature(Default::default(), wasm_call_sig);
-        let (mut builder, block0) = compiler.builder(func);
-        let args = builder.func.dfg.block_params(block0).to_vec();
-        let caller_vmctx = args[1];
-
-        // Assert that we were really given a core Wasm vmctx, since that's
-        // what we are assuming with our offsets below.
-        debug_assert_vmctx_kind(
-            isa,
-            &mut builder,
-            caller_vmctx,
-            wasmtime_environ::VMCONTEXT_MAGIC,
-        );
-        let ptr_size = isa.pointer_bytes();
-        let limits = builder.ins().load(
-            pointer_type,
-            MemFlags::trusted(),
-            caller_vmctx,
-            ptr_size.vmcontext_runtime_limits(),
-        );
-        save_last_wasm_exit_fp_and_pc(&mut builder, pointer_type, &ptr_size, limits);
-
-        let (values_vec_ptr, values_vec_len) =
-            self.allocate_stack_array_and_spill_args(ty, &mut builder, &args[2..]);
-        let values_vec_len = builder
-            .ins()
-            .iconst(pointer_type, i64::from(values_vec_len));
-
-        let block_params = builder.func.dfg.block_params(block0);
-        let callee_args = [
-            block_params[0],
-            block_params[1],
-            values_vec_ptr,
-            values_vec_len,
-        ];
-
-        let new_sig = builder.import_signature(array_call_sig);
-        let callee_value = builder.ins().iconst(pointer_type, host_fn as i64);
-        builder
-            .ins()
-            .call_indirect(new_sig, callee_value, &callee_args);
-
-        let results =
-            self.load_values_from_array(ty.returns(), &mut builder, values_vec_ptr, values_vec_len);
-        builder.ins().return_(&results);
-        builder.finalize();
-
-        compiler.finish()
-    }
-
     /// This function will allocate a stack slot suitable for storing both the
     /// arguments and return values of the function, and then the arguments will
     /// all be stored in this block.
@@ -872,6 +661,7 @@ impl Compiler {
         let slot = builder.func.create_sized_stack_slot(ir::StackSlotData::new(
             ir::StackSlotKind::ExplicitSlot,
             values_vec_byte_size,
+            4,
         ));
         let values_vec_ptr = builder.ins().stack_addr(pointer_type, slot, 0);
 
@@ -894,26 +684,32 @@ impl Compiler {
     fn store_values_to_array(
         &self,
         builder: &mut FunctionBuilder,
-        types: &[WasmType],
+        types: &[WasmValType],
         values: &[Value],
         values_vec_ptr: Value,
         values_vec_capacity: Value,
     ) {
+        debug_assert_eq!(types.len(), values.len());
         debug_assert_enough_capacity_for_length(builder, types.len(), values_vec_capacity);
 
         // Note that loads and stores are unconditionally done in the
         // little-endian format rather than the host's native-endianness,
         // despite this load/store being unrelated to execution in wasm itself.
-        // For more details on this see the `ValRaw` type in the
-        // `wasmtime-runtime` crate.
-        let mut mflags = MemFlags::trusted();
-        mflags.set_endianness(ir::Endianness::Little);
+        // For more details on this see the `ValRaw` type in
+        // `wasmtime::runtime::vm`.
+        let flags = ir::MemFlags::new()
+            .with_notrap()
+            .with_endianness(ir::Endianness::Little);
 
         let value_size = mem::size_of::<u128>();
         for (i, val) in values.iter().copied().enumerate() {
-            builder
-                .ins()
-                .store(mflags, val, values_vec_ptr, (i * value_size) as i32);
+            crate::unbarriered_store_type_at_offset(
+                &mut builder.cursor(),
+                flags,
+                values_vec_ptr,
+                i32::try_from(i * value_size).unwrap(),
+                val,
+            );
         }
     }
 
@@ -922,11 +718,11 @@ impl Compiler {
     ///
     /// This can be used to load arguments out of the array if the trampoline we
     /// are building exposes the array calling convention, or it can be used to
-    /// laod results out of the array if the trampoline we are building calls a
+    /// load results out of the array if the trampoline we are building calls a
     /// function that uses the array calling convention.
     fn load_values_from_array(
         &self,
-        types: &[WasmType],
+        types: &[WasmValType],
         builder: &mut FunctionBuilder,
         values_vec_ptr: Value,
         values_vec_capacity: Value,
@@ -938,18 +734,20 @@ impl Compiler {
 
         // Note that this is little-endian like `store_values_to_array` above,
         // see notes there for more information.
-        let mut mflags = MemFlags::trusted();
-        mflags.set_endianness(ir::Endianness::Little);
+        let flags = MemFlags::new()
+            .with_notrap()
+            .with_endianness(ir::Endianness::Little);
 
         let mut results = Vec::new();
-        for (i, r) in types.iter().enumerate() {
-            let load = builder.ins().load(
-                value_type(isa, *r),
-                mflags,
+        for (i, ty) in types.iter().enumerate() {
+            results.push(crate::unbarriered_load_type_at_offset(
+                isa,
+                &mut builder.cursor(),
+                *ty,
+                flags,
                 values_vec_ptr,
-                (i * value_size) as i32,
-            );
-            results.push(load);
+                i32::try_from(i * value_size).unwrap(),
+            ));
         }
         results
     }
@@ -978,20 +776,6 @@ impl Compiler {
     }
 }
 
-/// The compiled function environment.
-pub struct CompiledFuncEnv {
-    /// Map to resolve external name references.
-    map: PrimaryMap<UserExternalNameRef, UserExternalName>,
-}
-
-impl wasmtime_cranelift_shared::CompiledFuncEnv for CompiledFuncEnv {
-    fn resolve_user_external_name_ref(&self, external: ir::UserExternalNameRef) -> (u32, u32) {
-        let UserExternalName { index, namespace } = self.map[external];
-
-        (namespace, index)
-    }
-}
-
 struct FunctionCompiler<'a> {
     compiler: &'a Compiler,
     cx: CompilerContext,
@@ -1012,7 +796,7 @@ impl FunctionCompiler<'_> {
         (builder, block0)
     }
 
-    fn finish(self) -> Result<CompiledFunction<CompiledFuncEnv>, CompileError> {
+    fn finish(self) -> Result<CompiledFunction, CompileError> {
         let (info, func) = self.finish_with_info(None)?;
         assert!(info.stack_maps.is_empty());
         Ok(func)
@@ -1021,12 +805,12 @@ impl FunctionCompiler<'_> {
     fn finish_with_info(
         mut self,
         body_and_tunables: Option<(&FunctionBody<'_>, &Tunables)>,
-    ) -> Result<(WasmFunctionInfo, CompiledFunction<CompiledFuncEnv>), CompileError> {
+    ) -> Result<(WasmFunctionInfo, CompiledFunction), CompileError> {
         let context = &mut self.cx.codegen_context;
         let isa = &*self.compiler.isa;
         let (_, _code_buf) =
             compile_maybe_cached(context, isa, self.cx.incremental_cache_ctx.as_mut())?;
-        let compiled_code = context.compiled_code().unwrap();
+        let mut compiled_code = context.take_compiled_code().unwrap();
 
         // Give wasm functions, user defined code, a "preferred" alignment
         // instead of the minimum alignment as this can help perf in niche
@@ -1038,11 +822,11 @@ impl FunctionCompiler<'_> {
         };
 
         let alignment = compiled_code.buffer.alignment.max(preferred_alignment);
-        let env = CompiledFuncEnv {
-            map: context.func.params.user_named_funcs().clone(),
-        };
-        let mut compiled_function =
-            CompiledFunction::new(compiled_code.buffer.clone(), env, alignment);
+        let mut compiled_function = CompiledFunction::new(
+            compiled_code.buffer.clone(),
+            context.func.params.user_named_funcs().clone(),
+            alignment,
+        );
 
         if let Some((body, tunables)) = body_and_tunables {
             let data = body.get_binary_reader();
@@ -1086,7 +870,8 @@ impl FunctionCompiler<'_> {
             }
         }
 
-        let stack_maps = mach_stack_maps_to_stack_maps(compiled_code.buffer.stack_maps());
+        let stack_maps =
+            clif_to_env_stack_maps(compiled_code.buffer.take_user_stack_maps().into_iter());
         compiled_function
             .set_sized_stack_slots(std::mem::take(&mut context.func.sized_stack_slots));
         self.compiler.contexts.lock().unwrap().push(self.cx);
@@ -1101,23 +886,24 @@ impl FunctionCompiler<'_> {
     }
 }
 
-fn mach_stack_maps_to_stack_maps(mach_stack_maps: &[MachStackMap]) -> Vec<StackMapInformation> {
-    // This is converting from Cranelift's representation of a stack map to
-    // Wasmtime's representation. They happen to align today but that may
-    // not always be true in the future.
-    let mut stack_maps = Vec::new();
-    for &MachStackMap {
-        offset_end,
-        ref stack_map,
-        ..
-    } in mach_stack_maps
-    {
-        let stack_map = wasmtime_environ::StackMap::new(
-            stack_map.mapped_words(),
-            stack_map.as_slice().iter().map(|a| a.0),
-        );
+/// Convert from Cranelift's representation of a stack map to Wasmtime's
+/// compiler-agnostic representation.
+fn clif_to_env_stack_maps(
+    clif_stack_maps: impl ExactSizeIterator<Item = (CodeOffset, u32, ir::UserStackMap)>,
+) -> Vec<StackMapInformation> {
+    let mut stack_maps = Vec::with_capacity(clif_stack_maps.len());
+    for (code_offset, mapped_bytes, stack_map) in clif_stack_maps {
+        let mut bitset = CompoundBitSet::new();
+        for (ty, offset) in stack_map.entries() {
+            assert_eq!(ty, ir::types::I32);
+            bitset.insert(usize::try_from(offset).unwrap());
+        }
+        if bitset.is_empty() {
+            continue;
+        }
+        let stack_map = wasmtime_environ::StackMap::new(mapped_bytes, bitset);
         stack_maps.push(StackMapInformation {
-            code_offset: offset_end,
+            code_offset,
             stack_map,
         });
     }
@@ -1133,7 +919,7 @@ fn declare_and_call(
 ) -> ir::Inst {
     let name = ir::ExternalName::User(builder.func.declare_imported_user_function(
         ir::UserExternalName {
-            namespace: 0,
+            namespace: crate::NS_WASM_FUNC,
             index: func_index,
         },
     ));
@@ -1229,7 +1015,7 @@ fn save_last_wasm_exit_fp_and_pc(
         trampoline_fp,
         // The FP always points to the next older FP for all supported
         // targets. See assertion in
-        // `crates/runtime/src/traphandlers/backtrace.rs`.
+        // `crates/wasmtime/src/runtime/vm/traphandlers/backtrace.rs`.
         0,
     );
     builder.ins().store(
@@ -1247,72 +1033,3 @@ fn save_last_wasm_exit_fp_and_pc(
         ptr.vmruntime_limits_last_wasm_exit_pc(),
     );
 }
-
-enum NativeRet {
-    Bare,
-    Retptr { offsets: Vec<u32>, size: u32 },
-}
-
-impl NativeRet {
-    fn classify(pointer_type: ir::Type, ty: &WasmFuncType) -> NativeRet {
-        fn align_to(val: u32, align: u32) -> u32 {
-            (val + (align - 1)) & !(align - 1)
-        }
-
-        match ty.returns() {
-            [] | [_] => NativeRet::Bare,
-            other => {
-                let mut offset = 0;
-                let mut offsets = Vec::new();
-                let mut max_align = 1;
-                for ty in other[1..].iter() {
-                    let size = match ty {
-                        WasmType::I32 | WasmType::F32 => 4,
-                        WasmType::I64 | WasmType::F64 => 8,
-                        WasmType::Ref(_) => pointer_type.bytes(),
-                        WasmType::V128 => 16,
-                    };
-                    offset = align_to(offset, size);
-                    offsets.push(offset);
-                    offset += size;
-                    max_align = max_align.max(size);
-                }
-                NativeRet::Retptr {
-                    offsets,
-                    size: align_to(offset, max_align),
-                }
-            }
-        }
-    }
-
-    fn native_args<'a>(&self, args: &'a [ir::Value]) -> &'a [ir::Value] {
-        match self {
-            NativeRet::Bare => args,
-            NativeRet::Retptr { .. } => &args[..args.len() - 1],
-        }
-    }
-
-    fn native_return(
-        &self,
-        builder: &mut FunctionBuilder<'_>,
-        block0: ir::Block,
-        results: &[ir::Value],
-    ) {
-        match self {
-            NativeRet::Bare => {
-                builder.ins().return_(&results);
-            }
-            NativeRet::Retptr { offsets, .. } => {
-                let ptr = *builder.func.dfg.block_params(block0).last().unwrap();
-                let (first, rest) = results.split_first().unwrap();
-                assert_eq!(rest.len(), offsets.len());
-                for (arg, offset) in rest.iter().zip(offsets) {
-                    builder
-                        .ins()
-                        .store(MemFlags::trusted(), *arg, ptr, *offset as i32);
-                }
-                builder.ins().return_(&[*first]);
-            }
-        }
-    }
-}
diff --git a/crates/cranelift/src/compiler/component.rs b/crates/cranelift/src/compiler/component.rs
index e914d8a26805..774eeb43f5ea 100644
--- a/crates/cranelift/src/compiler/component.rs
+++ b/crates/cranelift/src/compiler/component.rs
@@ -1,31 +1,30 @@
 //! Compilation support for the component model.
 
-use crate::compiler::{Compiler, NativeRet};
+use crate::{compiler::Compiler, ALWAYS_TRAP_CODE, CANNOT_ENTER_CODE};
 use anyhow::Result;
 use cranelift_codegen::ir::{self, InstBuilder, MemFlags};
 use cranelift_codegen::isa::{CallConv, TargetIsa};
 use cranelift_frontend::FunctionBuilder;
+use cranelift_wasm::ModuleInternedTypeIndex;
 use std::any::Any;
-use wasmtime_cranelift_shared::{ALWAYS_TRAP_CODE, CANNOT_ENTER_CODE};
 use wasmtime_environ::component::*;
-use wasmtime_environ::{PtrSize, SignatureIndex, WasmType};
+use wasmtime_environ::{PtrSize, WasmValType};
 
 struct TrampolineCompiler<'a> {
     compiler: &'a Compiler,
     isa: &'a (dyn TargetIsa + 'static),
     builder: FunctionBuilder<'a>,
     component: &'a Component,
-    types: &'a ComponentTypes,
+    types: &'a ComponentTypesBuilder,
     offsets: VMComponentOffsets<u8>,
     abi: Abi,
     block0: ir::Block,
-    signature: SignatureIndex,
+    signature: ModuleInternedTypeIndex,
 }
 
 #[derive(Copy, Clone)]
 enum Abi {
     Wasm,
-    Native,
     Array,
 }
 
@@ -34,18 +33,17 @@ impl<'a> TrampolineCompiler<'a> {
         compiler: &'a Compiler,
         func_compiler: &'a mut super::FunctionCompiler<'_>,
         component: &'a Component,
-        types: &'a ComponentTypes,
+        types: &'a ComponentTypesBuilder,
         index: TrampolineIndex,
         abi: Abi,
     ) -> TrampolineCompiler<'a> {
         let isa = &*compiler.isa;
         let signature = component.trampolines[index];
-        let ty = &types[signature];
+        let ty = types[signature].unwrap_func();
         let func = ir::Function::with_name_signature(
             ir::UserFuncName::user(0, 0),
             match abi {
                 Abi::Wasm => crate::wasm_call_signature(isa, ty, &compiler.tunables),
-                Abi::Native => crate::native_call_signature(isa, ty),
                 Abi::Array => crate::array_call_signature(isa),
             },
         );
@@ -78,7 +76,7 @@ impl<'a> TrampolineCompiler<'a> {
                     }
                     // Transcoders can only actually be called by Wasm, so let's assert
                     // that here.
-                    Abi::Native | Abi::Array => {
+                    Abi::Array => {
                         self.builder
                             .ins()
                             .trap(ir::TrapCode::User(crate::DEBUG_ASSERT_TRAP_CODE));
@@ -124,18 +122,12 @@ impl<'a> TrampolineCompiler<'a> {
         let pointer_type = self.isa.pointer_type();
         let args = self.builder.func.dfg.block_params(self.block0).to_vec();
         let vmctx = args[0];
-        let wasm_func_ty = &self.types[self.signature];
-
-        // More handling is necessary here if this changes
-        assert!(matches!(
-            NativeRet::classify(pointer_type, wasm_func_ty),
-            NativeRet::Bare
-        ));
+        let wasm_func_ty = self.types[self.signature].unwrap_func();
 
         // Start off by spilling all the wasm arguments into a stack slot to be
         // passed to the host function.
         let (values_vec_ptr, values_vec_len) = match self.abi {
-            Abi::Wasm | Abi::Native => {
+            Abi::Wasm => {
                 let (ptr, len) = self.compiler.allocate_stack_array_and_spill_args(
                     wasm_func_ty,
                     &mut self.builder,
@@ -252,7 +244,7 @@ impl<'a> TrampolineCompiler<'a> {
             .call_indirect(host_sig, host_fn, &callee_args);
 
         match self.abi {
-            Abi::Wasm | Abi::Native => {
+            Abi::Wasm => {
                 // After the host function has returned the results are loaded from
                 // `values_vec_ptr` and then returned.
                 let results = self.compiler.load_values_from_array(
@@ -288,7 +280,10 @@ impl<'a> TrampolineCompiler<'a> {
         host_args.push(args[2]);
 
         // Currently this only support resources represented by `i32`
-        assert_eq!(self.types[self.signature].params()[0], WasmType::I32);
+        assert_eq!(
+            self.types[self.signature].unwrap_func().params()[0],
+            WasmValType::I32
+        );
         let (host_sig, offset) = host::resource_new32(self.isa, &mut self.builder.func);
 
         let host_fn = self.load_libcall(vmctx, offset);
@@ -319,7 +314,10 @@ impl<'a> TrampolineCompiler<'a> {
         host_args.push(args[2]);
 
         // Currently this only support resources represented by `i32`
-        assert_eq!(self.types[self.signature].returns()[0], WasmType::I32);
+        assert_eq!(
+            self.types[self.signature].unwrap_func().returns()[0],
+            WasmValType::I32
+        );
         let (host_sig, offset) = host::resource_rep32(self.isa, &mut self.builder.func);
 
         let host_fn = self.load_libcall(vmctx, offset);
@@ -490,7 +488,7 @@ impl<'a> TrampolineCompiler<'a> {
 
             let sig = crate::wasm_call_signature(
                 self.isa,
-                &self.types[self.signature],
+                &self.types[self.signature].unwrap_func(),
                 &self.compiler.tunables,
             );
             let sig_ref = self.builder.import_signature(sig);
@@ -527,7 +525,7 @@ impl<'a> TrampolineCompiler<'a> {
 
             // These trampolines can only actually be called by Wasm, so
             // let's assert that here.
-            Abi::Native | Abi::Array => {
+            Abi::Array => {
                 self.builder
                     .ins()
                     .trap(ir::TrapCode::User(crate::DEBUG_ASSERT_TRAP_CODE));
@@ -577,13 +575,13 @@ impl<'a> TrampolineCompiler<'a> {
         match self.abi {
             // Wasm and native ABIs pass parameters as normal function
             // parameters.
-            Abi::Wasm | Abi::Native => block0_params,
+            Abi::Wasm => block0_params,
 
             // The array ABI passes a pointer/length as the 3rd/4th arguments
             // and those are used to load the actual wasm parameters.
             Abi::Array => {
                 let results = self.compiler.load_values_from_array(
-                    self.types[self.signature].params(),
+                    self.types[self.signature].unwrap_func().params(),
                     &mut self.builder,
                     block0_params[2],
                     block0_params[3],
@@ -598,7 +596,7 @@ impl<'a> TrampolineCompiler<'a> {
     fn abi_store_results(&mut self, results: &[ir::Value]) {
         match self.abi {
             // Wasm/native ABIs return values as usual.
-            Abi::Wasm | Abi::Native => {
+            Abi::Wasm => {
                 self.builder.ins().return_(results);
             }
 
@@ -610,7 +608,7 @@ impl<'a> TrampolineCompiler<'a> {
                 let (ptr, len) = (block0_params[2], block0_params[3]);
                 self.compiler.store_values_to_array(
                     &mut self.builder,
-                    self.types[self.signature].returns(),
+                    self.types[self.signature].unwrap_func().returns(),
                     results,
                     ptr,
                     len,
@@ -625,7 +623,7 @@ impl ComponentCompiler for Compiler {
     fn compile_trampoline(
         &self,
         component: &ComponentTranslation,
-        types: &ComponentTypes,
+        types: &ComponentTypesBuilder,
         index: TrampolineIndex,
     ) -> Result<AllCallFunc<Box<dyn Any + Send>>> {
         let compile = |abi: Abi| -> Result<_> {
@@ -675,7 +673,6 @@ impl ComponentCompiler for Compiler {
         Ok(AllCallFunc {
             wasm_call: compile(Abi::Wasm)?,
             array_call: compile(Abi::Array)?,
-            native_call: compile(Abi::Native)?,
         })
     }
 }
@@ -766,6 +763,7 @@ impl TrampolineCompiler<'_> {
                 .create_sized_stack_slot(ir::StackSlotData::new(
                     ir::StackSlotKind::ExplicitSlot,
                     pointer_type.bytes(),
+                    0,
                 ));
             args.push(self.builder.ins().stack_addr(pointer_type, slot, 0));
         }
diff --git a/crates/cranelift/src/debug.rs b/crates/cranelift/src/debug.rs
index 04095d6407cc..542a07092270 100644
--- a/crates/cranelift/src/debug.rs
+++ b/crates/cranelift/src/debug.rs
@@ -1,5 +1,14 @@
 //! Debug utils for WebAssembly using Cranelift.
 
+use crate::CompiledFunctionMetadata;
+use cranelift_codegen::isa::TargetIsa;
+use object::write::SymbolId;
+use std::collections::HashMap;
+use wasmtime_environ::{
+    DefinedFuncIndex, DefinedMemoryIndex, EntityRef, MemoryIndex, ModuleTranslation,
+    OwnedMemoryIndex, PrimaryMap, PtrSize, StaticModuleIndex, Tunables, VMOffsets,
+};
+
 /// Memory definition offset in the VMContext structure.
 #[derive(Debug, Clone)]
 pub enum ModuleMemoryOffset {
@@ -7,11 +16,162 @@ pub enum ModuleMemoryOffset {
     None,
     /// Offset to the defined memory.
     Defined(u32),
-    /// Offset to the imported memory.
-    Imported(u32),
+    /// This memory is imported.
+    Imported {
+        /// Offset, in bytes, to the `*mut VMMemoryDefinition` structure within
+        /// `VMContext`.
+        offset_to_vm_memory_definition: u32,
+        /// Offset, in bytes within `VMMemoryDefinition` where the `base` field
+        /// lies.
+        offset_to_memory_base: u32,
+    },
+}
+
+type Reader<'input> = gimli::EndianSlice<'input, gimli::LittleEndian>;
+
+/// "Package structure" to collect together various artifacts/results of a
+/// compilation.
+///
+/// This structure is threaded through a number of top-level functions of DWARF
+/// processing within in this submodule to pass along all the bits-and-pieces of
+/// the compilation context.
+pub struct Compilation<'a> {
+    /// All module translations which were present in this compilation.
+    ///
+    /// This map has one entry for core wasm modules and may have multiple (or
+    /// zero) for components.
+    translations: &'a PrimaryMap<StaticModuleIndex, ModuleTranslation<'a>>,
+
+    /// Accessor of a particular compiled function for a module.
+    ///
+    /// This returns the `object`-based-symbol for the function as well as the
+    /// `&CompiledFunction`.
+    get_func:
+        &'a dyn Fn(StaticModuleIndex, DefinedFuncIndex) -> (SymbolId, &'a CompiledFunctionMetadata),
+
+    /// Optionally-specified `*.dwp` file, currently only supported for core
+    /// wasm modules.
+    dwarf_package_bytes: Option<&'a [u8]>,
+
+    /// Compilation settings used when producing functions.
+    tunables: &'a Tunables,
+
+    /// Translation between `SymbolId` and a `usize`-based symbol which gimli
+    /// uses.
+    symbol_index_to_id: Vec<SymbolId>,
+    symbol_id_to_index: HashMap<SymbolId, (usize, StaticModuleIndex, DefinedFuncIndex)>,
+
+    /// The `ModuleMemoryOffset` for each module within `translations`.
+    ///
+    /// Note that this doesn't support multi-memory at this time.
+    module_memory_offsets: PrimaryMap<StaticModuleIndex, ModuleMemoryOffset>,
+}
+
+impl<'a> Compilation<'a> {
+    pub fn new(
+        isa: &dyn TargetIsa,
+        translations: &'a PrimaryMap<StaticModuleIndex, ModuleTranslation<'a>>,
+        get_func: &'a dyn Fn(
+            StaticModuleIndex,
+            DefinedFuncIndex,
+        ) -> (SymbolId, &'a CompiledFunctionMetadata),
+        dwarf_package_bytes: Option<&'a [u8]>,
+        tunables: &'a Tunables,
+    ) -> Compilation<'a> {
+        // Build the `module_memory_offsets` map based on the modules in
+        // `translations`.
+        let mut module_memory_offsets = PrimaryMap::new();
+        for (i, translation) in translations {
+            let ofs = VMOffsets::new(
+                isa.triple().architecture.pointer_width().unwrap().bytes(),
+                &translation.module,
+            );
+
+            let memory_offset = if ofs.num_imported_memories > 0 {
+                let index = MemoryIndex::new(0);
+                ModuleMemoryOffset::Imported {
+                    offset_to_vm_memory_definition: ofs.vmctx_vmmemory_import(index)
+                        + u32::from(ofs.vmmemory_import_from()),
+                    offset_to_memory_base: ofs.ptr.vmmemory_definition_base().into(),
+                }
+            } else if ofs.num_owned_memories > 0 {
+                let index = OwnedMemoryIndex::new(0);
+                ModuleMemoryOffset::Defined(ofs.vmctx_vmmemory_definition_base(index))
+            } else if ofs.num_defined_memories > 0 {
+                let index = DefinedMemoryIndex::new(0);
+                ModuleMemoryOffset::Imported {
+                    offset_to_vm_memory_definition: ofs.vmctx_vmmemory_pointer(index),
+                    offset_to_memory_base: ofs.ptr.vmmemory_definition_base().into(),
+                }
+            } else {
+                ModuleMemoryOffset::None
+            };
+            let j = module_memory_offsets.push(memory_offset);
+            assert_eq!(i, j);
+        }
+
+        // Build the `symbol <=> usize` mappings
+        let mut symbol_index_to_id = Vec::new();
+        let mut symbol_id_to_index = HashMap::new();
+
+        for (module, translation) in translations {
+            for func in translation.module.defined_func_indices() {
+                let (sym, _func) = get_func(module, func);
+                symbol_id_to_index.insert(sym, (symbol_index_to_id.len(), module, func));
+                symbol_index_to_id.push(sym);
+            }
+        }
+
+        Compilation {
+            translations,
+            get_func,
+            dwarf_package_bytes,
+            tunables,
+            symbol_index_to_id,
+            symbol_id_to_index,
+            module_memory_offsets,
+        }
+    }
+
+    /// Returns an iterator over all function indexes present in this
+    /// compilation.
+    ///
+    /// Each function is additionally accompanied with its module index.
+    fn indexes(&self) -> impl Iterator<Item = (StaticModuleIndex, DefinedFuncIndex)> + '_ {
+        self.translations
+            .iter()
+            .flat_map(|(i, t)| t.module.defined_func_indices().map(move |j| (i, j)))
+    }
+
+    /// Returns an iterator of all functions with their module, symbol, and
+    /// function metadata that were produced during compilation.
+    fn functions(
+        &self,
+    ) -> impl Iterator<Item = (StaticModuleIndex, usize, &'a CompiledFunctionMetadata)> + '_ {
+        self.indexes().map(move |(module, func)| {
+            let (sym, func) = self.function(module, func);
+            (module, sym, func)
+        })
+    }
+
+    /// Returns the symbol and metadata associated with a specific function.
+    fn function(
+        &self,
+        module: StaticModuleIndex,
+        func: DefinedFuncIndex,
+    ) -> (usize, &'a CompiledFunctionMetadata) {
+        let (sym, func) = (self.get_func)(module, func);
+        (self.symbol_id_to_index[&sym].0, func)
+    }
+
+    /// Maps a `usize`-based symbol used by gimli to the object-based
+    /// `SymbolId`.
+    pub fn symbol_id(&self, sym: usize) -> SymbolId {
+        self.symbol_index_to_id[sym]
+    }
 }
 
-pub use write_debuginfo::{emit_dwarf, DwarfSection, DwarfSectionRelocTarget};
+pub use write_debuginfo::{emit_dwarf, DwarfSectionRelocTarget};
 
 mod gc;
 mod transform;
diff --git a/crates/cranelift/src/debug/gc.rs b/crates/cranelift/src/debug/gc.rs
index ad8c25d8b82c..bb45e8e838a7 100644
--- a/crates/cranelift/src/debug/gc.rs
+++ b/crates/cranelift/src/debug/gc.rs
@@ -1,8 +1,10 @@
 use crate::debug::transform::AddressTransform;
+use crate::debug::{Compilation, Reader};
 use gimli::constants;
 use gimli::read;
-use gimli::{Reader, UnitSectionOffset};
+use gimli::UnitSectionOffset;
 use std::collections::{HashMap, HashSet};
+use wasmtime_environ::{PrimaryMap, StaticModuleIndex};
 
 #[derive(Debug)]
 pub struct Dependencies {
@@ -65,21 +67,26 @@ impl Dependencies {
     }
 }
 
-pub fn build_dependencies<R: Reader<Offset = usize>>(
-    dwarf: &read::Dwarf<R>,
-    at: &AddressTransform,
+pub fn build_dependencies(
+    compilation: &mut Compilation<'_>,
+    dwp: &Option<read::DwarfPackage<Reader<'_>>>,
+    at: &PrimaryMap<StaticModuleIndex, AddressTransform>,
 ) -> read::Result<Dependencies> {
     let mut deps = Dependencies::new();
-    let mut units = dwarf.units();
-    while let Some(unit) = units.next()? {
-        build_unit_dependencies(unit, dwarf, at, &mut deps)?;
+    for (i, translation) in compilation.translations.iter() {
+        let dwarf = &translation.debuginfo.dwarf;
+        let mut units = dwarf.units();
+        while let Some(unit) = units.next()? {
+            build_unit_dependencies(unit, dwarf, dwp, &at[i], &mut deps)?;
+        }
     }
     Ok(deps)
 }
 
-fn build_unit_dependencies<R: Reader<Offset = usize>>(
-    header: read::UnitHeader<R>,
-    dwarf: &read::Dwarf<R>,
+fn build_unit_dependencies(
+    header: read::UnitHeader<Reader<'_>>,
+    dwarf: &read::Dwarf<Reader<'_>>,
+    dwp: &Option<read::DwarfPackage<Reader<'_>>>,
     at: &AddressTransform,
     deps: &mut Dependencies,
 ) -> read::Result<()> {
@@ -87,10 +94,21 @@ fn build_unit_dependencies<R: Reader<Offset = usize>>(
     let mut tree = unit.entries_tree(None)?;
     let root = tree.root()?;
     build_die_dependencies(root, dwarf, &unit, at, deps)?;
+
+    if let Some(dwarf_package) = dwp {
+        if let Some(dwo_id) = unit.dwo_id {
+            if let Some(cu) = dwarf_package.find_cu(dwo_id, dwarf)? {
+                if let Some(unit_header) = cu.debug_info.units().next()? {
+                    build_unit_dependencies(unit_header, &cu, &None, at, deps)?;
+                }
+            }
+        }
+    }
+
     Ok(())
 }
 
-fn has_die_back_edge<R: Reader<Offset = usize>>(die: &read::DebuggingInformationEntry<R>) -> bool {
+fn has_die_back_edge(die: &read::DebuggingInformationEntry<Reader<'_>>) -> bool {
     match die.tag() {
         constants::DW_TAG_variable
         | constants::DW_TAG_constant
@@ -110,10 +128,10 @@ fn has_die_back_edge<R: Reader<Offset = usize>>(die: &read::DebuggingInformation
     }
 }
 
-fn has_valid_code_range<R: Reader<Offset = usize>>(
-    die: &read::DebuggingInformationEntry<R>,
-    dwarf: &read::Dwarf<R>,
-    unit: &read::Unit<R>,
+fn has_valid_code_range(
+    die: &read::DebuggingInformationEntry<Reader<'_>>,
+    dwarf: &read::Dwarf<Reader<'_>>,
+    unit: &read::Unit<Reader<'_>>,
     at: &AddressTransform,
 ) -> read::Result<bool> {
     match die.tag() {
@@ -186,10 +204,10 @@ fn has_valid_code_range<R: Reader<Offset = usize>>(
     Ok(false)
 }
 
-fn build_die_dependencies<R: Reader<Offset = usize>>(
-    die: read::EntriesTreeNode<R>,
-    dwarf: &read::Dwarf<R>,
-    unit: &read::Unit<R>,
+fn build_die_dependencies(
+    die: read::EntriesTreeNode<Reader<'_>>,
+    dwarf: &read::Dwarf<Reader<'_>>,
+    unit: &read::Unit<Reader<'_>>,
     at: &AddressTransform,
     deps: &mut Dependencies,
 ) -> read::Result<()> {
@@ -216,11 +234,11 @@ fn build_die_dependencies<R: Reader<Offset = usize>>(
     Ok(())
 }
 
-fn build_attr_dependencies<R: Reader<Offset = usize>>(
-    attr: &read::Attribute<R>,
+fn build_attr_dependencies(
+    attr: &read::Attribute<Reader<'_>>,
     offset: UnitSectionOffset,
-    _dwarf: &read::Dwarf<R>,
-    unit: &read::Unit<R>,
+    _dwarf: &read::Dwarf<Reader<'_>>,
+    unit: &read::Unit<Reader<'_>>,
     _at: &AddressTransform,
     deps: &mut Dependencies,
 ) -> read::Result<()> {
diff --git a/crates/cranelift/src/debug/transform/address_transform.rs b/crates/cranelift/src/debug/transform/address_transform.rs
index a95ff244bbd2..2bb126dde764 100644
--- a/crates/cranelift/src/debug/transform/address_transform.rs
+++ b/crates/cranelift/src/debug/transform/address_transform.rs
@@ -1,9 +1,8 @@
-use crate::CompiledFunctionsMetadata;
+use crate::debug::Compilation;
+use crate::FunctionAddressMap;
 use gimli::write;
 use std::collections::BTreeMap;
-use std::iter::FromIterator;
-use wasmtime_cranelift_shared::FunctionAddressMap;
-use wasmtime_environ::{DefinedFuncIndex, EntityRef, FilePos, PrimaryMap, WasmFileInfo};
+use wasmtime_environ::{DefinedFuncIndex, FilePos, PrimaryMap, StaticModuleIndex};
 
 pub type GeneratedAddress = usize;
 pub type WasmAddress = u64;
@@ -20,6 +19,7 @@ pub struct AddressMap {
 /// length, and instructions addresses.
 #[derive(Debug)]
 pub struct FunctionMap {
+    pub symbol: usize,
     pub offset: GeneratedAddress,
     pub len: GeneratedAddress,
     pub wasm_start: WasmAddress,
@@ -189,11 +189,19 @@ fn build_function_lookup(
 }
 
 fn build_function_addr_map(
-    funcs: &CompiledFunctionsMetadata,
-    code_section_offset: u64,
+    compilation: &Compilation<'_>,
+    module: StaticModuleIndex,
 ) -> PrimaryMap<DefinedFuncIndex, FunctionMap> {
     let mut map = PrimaryMap::new();
-    for (_, metadata) in funcs {
+    for idx in compilation.translations[module]
+        .module
+        .defined_func_indices()
+    {
+        let (symbol, metadata) = compilation.function(module, idx);
+        let code_section_offset = compilation.translations[module]
+            .debuginfo
+            .wasm_file
+            .code_section_offset;
         let ft = &metadata.address_map;
         let mut fn_map = Vec::new();
         for t in ft.instructions.iter() {
@@ -215,6 +223,7 @@ fn build_function_addr_map(
         }
 
         map.push(FunctionMap {
+            symbol,
             offset: ft.body_offset,
             len: ft.body_len as usize,
             wasm_start: get_wasm_code_offset(ft.start_srcloc, code_section_offset),
@@ -354,7 +363,7 @@ impl<'a> Iterator for TransformRangeEndIter<'a> {
 }
 
 // Utility iterator to iterate by translated function ranges.
-pub struct TransformRangeIter<'a> {
+struct TransformRangeIter<'a> {
     func: &'a FuncTransform,
     start_it: TransformRangeStartIter<'a>,
     end_it: TransformRangeEndIter<'a>,
@@ -385,7 +394,7 @@ impl<'a> Iterator for TransformRangeIter<'a> {
     fn next(&mut self) -> Option<Self::Item> {
         loop {
             // Merge TransformRangeStartIter and TransformRangeEndIter data using
-            // FuncLookup index's field propery to be sorted by RangeIndex.
+            // FuncLookup index's field property to be sorted by RangeIndex.
             let (start, end, range_index): (
                 Option<GeneratedAddress>,
                 Option<GeneratedAddress>,
@@ -450,11 +459,18 @@ impl<'a> Iterator for TransformRangeIter<'a> {
 }
 
 impl AddressTransform {
-    pub fn new(funcs: &CompiledFunctionsMetadata, wasm_file: &WasmFileInfo) -> Self {
-        let code_section_offset = wasm_file.code_section_offset;
-
+    pub fn new(compilation: &Compilation<'_>, module: StaticModuleIndex) -> Self {
         let mut func = BTreeMap::new();
-        for (i, metadata) in funcs {
+        let code_section_offset = compilation.translations[module]
+            .debuginfo
+            .wasm_file
+            .code_section_offset;
+
+        for idx in compilation.translations[module]
+            .module
+            .defined_func_indices()
+        {
+            let (_, metadata) = compilation.function(module, idx);
             let (fn_start, fn_end, lookup) =
                 build_function_lookup(&metadata.address_map, code_section_offset);
 
@@ -463,17 +479,56 @@ impl AddressTransform {
                 FuncTransform {
                     start: fn_start,
                     end: fn_end,
-                    index: i,
+                    index: idx,
                     lookup,
                 },
             );
         }
 
-        let map = build_function_addr_map(funcs, code_section_offset);
+        let map = build_function_addr_map(compilation, module);
         let func = Vec::from_iter(func.into_iter());
         AddressTransform { map, func }
     }
 
+    #[cfg(test)]
+    pub fn mock(
+        module_map: &wasmtime_environ::PrimaryMap<
+            wasmtime_environ::DefinedFuncIndex,
+            &crate::CompiledFunctionMetadata,
+        >,
+        wasm_file: wasmtime_environ::WasmFileInfo,
+    ) -> Self {
+        let mut translations = wasmtime_environ::PrimaryMap::new();
+        let mut translation = wasmtime_environ::ModuleTranslation::default();
+        translation.debuginfo.wasm_file = wasm_file;
+        translation
+            .module
+            .push_function(wasmtime_environ::ModuleInternedTypeIndex::from_u32(0));
+        translations.push(translation);
+
+        let mut dummy_obj = object::write::Object::new(
+            object::BinaryFormat::Elf,
+            object::Architecture::Wasm32,
+            object::Endianness::Little,
+        );
+        let dummy_symbol = dummy_obj.add_file_symbol(Vec::new());
+        let func_lookup = move |_, f| (dummy_symbol, module_map[f]);
+        let tunables = wasmtime_environ::Tunables::default_host();
+        let compile = Compilation::new(
+            &*cranelift_codegen::isa::lookup(target_lexicon::Triple::host())
+                .unwrap()
+                .finish(cranelift_codegen::settings::Flags::new(
+                    cranelift_codegen::settings::builder(),
+                ))
+                .unwrap(),
+            &translations,
+            &func_lookup,
+            None,
+            &tunables,
+        );
+        Self::new(&compile, StaticModuleIndex::from_u32(0))
+    }
+
     fn find_func(&self, addr: u64) -> Option<&FuncTransform> {
         // TODO check if we need to include end address
         let func = match self.func.binary_search_by(|entry| entry.0.cmp(&addr)) {
@@ -496,20 +551,20 @@ impl AddressTransform {
         self.find_func(addr).map(|f| f.index)
     }
 
-    pub fn translate_raw(&self, addr: u64) -> Option<(DefinedFuncIndex, GeneratedAddress)> {
+    fn translate_raw(&self, addr: u64) -> Option<(usize, GeneratedAddress)> {
         if addr == 0 {
             // It's normally 0 for debug info without the linked code.
             return None;
         }
         if let Some(func) = self.find_func(addr) {
+            let map = &self.map[func.index];
             if addr == func.end {
                 // Clamp last address to the end to extend translation to the end
                 // of the function.
-                let map = &self.map[func.index];
-                return Some((func.index, map.len));
+                return Some((map.symbol, map.len));
             }
             let first_result = TransformRangeStartIter::new(func, addr).next();
-            first_result.map(|(address, _)| (func.index, address))
+            first_result.map(|(address, _)| (map.symbol, address))
         } else {
             // Address was not found: function was not compiled?
             None
@@ -522,8 +577,8 @@ impl AddressTransform {
 
     pub fn translate(&self, addr: u64) -> Option<write::Address> {
         self.translate_raw(addr)
-            .map(|(func_index, address)| write::Address::Symbol {
-                symbol: func_index.index(),
+            .map(|(symbol, address)| write::Address::Symbol {
+                symbol,
                 addend: address as i64,
             })
     }
@@ -532,14 +587,15 @@ impl AddressTransform {
         &'a self,
         start: u64,
         end: u64,
-    ) -> Option<(DefinedFuncIndex, impl Iterator<Item = (usize, usize)> + 'a)> {
+    ) -> Option<(usize, impl Iterator<Item = (usize, usize)> + 'a)> {
         if start == 0 {
             // It's normally 0 for debug info without the linked code.
             return None;
         }
         if let Some(func) = self.find_func(start) {
             let result = TransformRangeIter::new(func, start, end);
-            return Some((func.index, result));
+            let symbol = self.map[func.index].symbol;
+            return Some((symbol, result));
         }
         // Address was not found: function was not compiled?
         None
@@ -580,8 +636,8 @@ impl AddressTransform {
         }
 
         match self.translate_ranges_raw(start, end) {
-            Some((func_index, ranges)) => TranslateRangesResult::Raw {
-                symbol: func_index.index(),
+            Some((symbol, ranges)) => TranslateRangesResult::Raw {
+                symbol,
                 it: Box::new(ranges),
             },
             None => TranslateRangesResult::Empty,
@@ -606,11 +662,10 @@ impl AddressTransform {
 #[cfg(test)]
 mod tests {
     use super::{build_function_lookup, get_wasm_code_offset, AddressTransform};
+    use crate::{CompiledFunctionMetadata, FunctionAddressMap};
     use cranelift_entity::PrimaryMap;
     use gimli::write::Address;
-    use std::iter::FromIterator;
     use std::mem;
-    use wasmtime_cranelift_shared::{CompiledFunctionMetadata, FunctionAddressMap};
     use wasmtime_environ::{FilePos, InstructionAddressMap, WasmFileInfo};
 
     #[test]
@@ -734,9 +789,9 @@ mod tests {
             ..Default::default()
         };
         let input = PrimaryMap::from_iter([&func]);
-        let at = AddressTransform::new(
+        let at = AddressTransform::mock(
             &input,
-            &WasmFileInfo {
+            WasmFileInfo {
                 path: None,
                 code_section_offset: 1,
                 imported_func_count: 0,
diff --git a/crates/cranelift/src/debug/transform/attr.rs b/crates/cranelift/src/debug/transform/attr.rs
index 13bf62e9fba8..5982100b8d1c 100644
--- a/crates/cranelift/src/debug/transform/attr.rs
+++ b/crates/cranelift/src/debug/transform/attr.rs
@@ -2,13 +2,10 @@ use super::address_transform::AddressTransform;
 use super::expression::{compile_expression, CompiledExpression, FunctionFrameInfo};
 use super::range_info_builder::RangeInfoBuilder;
 use super::refs::{PendingDebugInfoRefs, PendingUnitRefs};
-use super::{DebugInputContext, Reader, TransformError};
+use super::{Reader, TransformError};
 use anyhow::{bail, Error};
 use cranelift_codegen::isa::TargetIsa;
-use gimli::{
-    write, AttributeValue, DebugLineOffset, DebugLineStr, DebugStr, DebugStrOffsets,
-    DebuggingInformationEntry, Unit,
-};
+use gimli::{write, AttributeValue, DebugLineOffset, DebuggingInformationEntry, Unit};
 
 #[derive(Debug)]
 pub(crate) enum FileAttributeContext<'a> {
@@ -39,14 +36,12 @@ pub(crate) fn clone_die_attributes<'a, R>(
     dwarf: &gimli::Dwarf<R>,
     unit: &Unit<R, R::Offset>,
     entry: &DebuggingInformationEntry<R>,
-    context: &DebugInputContext<R>,
     addr_tr: &'a AddressTransform,
     frame_info: Option<&FunctionFrameInfo>,
     out_unit: &mut write::Unit,
     current_scope_id: write::UnitEntryId,
     subprogram_range_builder: Option<RangeInfoBuilder>,
     scope_ranges: Option<&Vec<(u64, u64)>>,
-    cu_low_pc: u64,
     out_strings: &mut write::StringTable,
     pending_die_refs: &mut PendingUnitRefs,
     pending_di_refs: &mut PendingDebugInfoRefs,
@@ -64,38 +59,43 @@ where
         // FIXME for CU: currently address_transform operate on a single
         // function range, and when CU spans multiple ranges the
         // transformation may be incomplete.
-        RangeInfoBuilder::from(dwarf, unit, entry, context, cu_low_pc)?
+        RangeInfoBuilder::from(dwarf, unit, entry)?
     };
     range_info.build(addr_tr, out_unit, current_scope_id);
 
     let mut attrs = entry.attrs();
     while let Some(attr) = attrs.next()? {
-        let attr_value = match attr.value() {
-            AttributeValue::Addr(_) | AttributeValue::DebugAddrIndex(_)
-                if attr.name() == gimli::DW_AT_low_pc =>
-            {
+        match attr.name() {
+            gimli::DW_AT_low_pc | gimli::DW_AT_high_pc | gimli::DW_AT_ranges => {
+                // Handled by RangeInfoBuilder.
                 continue;
             }
-            AttributeValue::Udata(_) if attr.name() == gimli::DW_AT_high_pc => {
+            gimli::DW_AT_str_offsets_base
+            | gimli::DW_AT_addr_base
+            | gimli::DW_AT_rnglists_base
+            | gimli::DW_AT_loclists_base
+            | gimli::DW_AT_dwo_name
+            | gimli::DW_AT_GNU_addr_base
+            | gimli::DW_AT_GNU_ranges_base
+            | gimli::DW_AT_GNU_dwo_name
+            | gimli::DW_AT_GNU_dwo_id => {
+                // DWARF encoding details that we don't need to copy.
                 continue;
             }
-            AttributeValue::RangeListsRef(_) if attr.name() == gimli::DW_AT_ranges => {
-                continue;
-            }
-            AttributeValue::DebugAddrBase(_) | AttributeValue::DebugStrOffsetsBase(_) => {
-                continue;
-            }
-
+            _ => {}
+        }
+        let attr_value = attr.value();
+        let out_attr_value = match attr_value {
             AttributeValue::Addr(u) => {
                 let addr = addr_tr.translate(u).unwrap_or(write::Address::Constant(0));
                 write::AttributeValue::Address(addr)
             }
             AttributeValue::DebugAddrIndex(i) => {
-                let u = context.debug_addr.get_address(4, unit.addr_base, i)?;
+                let u = dwarf.address(unit, i)?;
                 let addr = addr_tr.translate(u).unwrap_or(write::Address::Constant(0));
                 write::AttributeValue::Address(addr)
             }
-            AttributeValue::Block(d) => write::AttributeValue::Block(d.to_slice()?.to_vec()),
+            AttributeValue::Block(d) => write::AttributeValue::Block(d.to_slice()?.into_owned()),
             AttributeValue::Udata(u) => write::AttributeValue::Udata(u),
             AttributeValue::Data1(d) => write::AttributeValue::Data1(d),
             AttributeValue::Data2(d) => write::AttributeValue::Data2(d),
@@ -119,37 +119,40 @@ where
                     ..
                 } = file_context
                 {
-                    write::AttributeValue::FileIndex(Some(file_map[(i - file_index_base) as usize]))
+                    let index = usize::try_from(i - file_index_base)
+                        .ok()
+                        .and_then(|i| file_map.get(i).copied());
+                    match index {
+                        Some(index) => write::AttributeValue::FileIndex(Some(index)),
+                        // This was seen to be invalid in #8884 and #8904 so
+                        // ignore this seemingly invalid DWARF from LLVM
+                        None => continue,
+                    }
                 } else {
                     return Err(TransformError("unexpected file index attribute").into());
                 }
             }
-            AttributeValue::DebugStrRef(str_offset) => {
-                let s = context.debug_str.get_str(str_offset)?.to_slice()?.to_vec();
+            AttributeValue::DebugStrRef(_) | AttributeValue::DebugStrOffsetsIndex(_) => {
+                let s = dwarf
+                    .attr_string(unit, attr_value)?
+                    .to_string_lossy()?
+                    .into_owned();
                 write::AttributeValue::StringRef(out_strings.add(s))
             }
-            AttributeValue::DebugStrOffsetsIndex(i) => {
-                let str_offset = context.debug_str_offsets.get_str_offset(
-                    gimli::Format::Dwarf32,
-                    unit.str_offsets_base,
-                    i,
-                )?;
-                let s = context.debug_str.get_str(str_offset)?.to_slice()?.to_vec();
-                write::AttributeValue::StringRef(out_strings.add(s))
-            }
-            AttributeValue::RangeListsRef(r) => {
-                let r = dwarf.ranges_offset_from_raw(unit, r);
-                let range_info = RangeInfoBuilder::from_ranges_ref(unit, r, context, cu_low_pc)?;
+            AttributeValue::RangeListsRef(_) | AttributeValue::DebugRngListsIndex(_) => {
+                let r = dwarf.attr_ranges_offset(unit, attr_value)?.unwrap();
+                let range_info = RangeInfoBuilder::from_ranges_ref(dwarf, unit, r)?;
                 let range_list_id = range_info.build_ranges(addr_tr, &mut out_unit.ranges);
                 write::AttributeValue::RangeListRef(range_list_id)
             }
-            AttributeValue::LocationListsRef(r) => {
+            AttributeValue::LocationListsRef(_) | AttributeValue::DebugLocListsIndex(_) => {
+                let r = dwarf.attr_locations_offset(unit, attr_value)?.unwrap();
                 let low_pc = 0;
-                let mut locs = context.loclists.locations(
+                let mut locs = dwarf.locations.locations(
                     r,
                     unit_encoding,
                     low_pc,
-                    &context.debug_addr,
+                    &dwarf.debug_addr,
                     unit.addr_base,
                 )?;
                 let frame_base =
@@ -295,50 +298,11 @@ where
                 pending_di_refs.insert(current_scope_id, attr.name(), offset);
                 continue;
             }
+            AttributeValue::String(d) => write::AttributeValue::String(d.to_slice()?.into_owned()),
             a => bail!("Unexpected attribute: {:?}", a),
         };
         let current_scope = out_unit.get_mut(current_scope_id);
-        current_scope.set(attr.name(), attr_value);
+        current_scope.set(attr.name(), out_attr_value);
     }
     Ok(())
 }
-
-pub(crate) fn clone_attr_string<R>(
-    attr_value: &AttributeValue<R>,
-    form: gimli::DwForm,
-    unit: &Unit<R, R::Offset>,
-    debug_str: &DebugStr<R>,
-    debug_str_offsets: &DebugStrOffsets<R>,
-    debug_line_str: &DebugLineStr<R>,
-    out_strings: &mut write::StringTable,
-) -> Result<write::LineString, Error>
-where
-    R: Reader,
-{
-    let content = match attr_value {
-        AttributeValue::DebugStrRef(str_offset) => {
-            debug_str.get_str(*str_offset)?.to_slice()?.to_vec()
-        }
-        AttributeValue::DebugStrOffsetsIndex(i) => {
-            let str_offset = debug_str_offsets.get_str_offset(
-                gimli::Format::Dwarf32,
-                unit.str_offsets_base,
-                *i,
-            )?;
-            debug_str.get_str(str_offset)?.to_slice()?.to_vec()
-        }
-        AttributeValue::DebugLineStrRef(str_offset) => {
-            debug_line_str.get_str(*str_offset)?.to_slice()?.to_vec()
-        }
-        AttributeValue::String(b) => b.to_slice()?.to_vec(),
-        v => bail!("Unexpected attribute value: {:?}", v),
-    };
-    Ok(match form {
-        gimli::DW_FORM_strp => {
-            let id = out_strings.add(content);
-            write::LineString::StringRef(id)
-        }
-        gimli::DW_FORM_string => write::LineString::String(content),
-        _ => bail!("DW_FORM_line_strp or other not supported"),
-    })
-}
diff --git a/crates/cranelift/src/debug/transform/expression.rs b/crates/cranelift/src/debug/transform/expression.rs
index aae55791c4bc..19015ea1ef42 100644
--- a/crates/cranelift/src/debug/transform/expression.rs
+++ b/crates/cranelift/src/debug/transform/expression.rs
@@ -1,52 +1,44 @@
+#![allow(trivial_numeric_casts)]
+
 use super::address_transform::AddressTransform;
 use crate::debug::ModuleMemoryOffset;
 use anyhow::{Context, Error, Result};
-use cranelift_codegen::ir::{StackSlots, ValueLabel};
+use cranelift_codegen::ir::ValueLabel;
 use cranelift_codegen::isa::TargetIsa;
 use cranelift_codegen::LabelValueLoc;
 use cranelift_codegen::ValueLabelsRanges;
 use cranelift_wasm::get_vmctx_value_label;
-use gimli::{self, write, Expression, Operation, Reader, ReaderOffset};
+use gimli::{write, Expression, Operation, Reader, ReaderOffset};
 use std::cmp::PartialEq;
 use std::collections::{HashMap, HashSet};
 use std::hash::{Hash, Hasher};
 use std::rc::Rc;
-use wasmtime_environ::{DefinedFuncIndex, EntityRef};
 
 #[derive(Debug)]
 pub struct FunctionFrameInfo<'a> {
     pub value_ranges: &'a ValueLabelsRanges,
     pub memory_offset: ModuleMemoryOffset,
-    pub sized_stack_slots: &'a StackSlots,
-}
-
-impl<'a> FunctionFrameInfo<'a> {
-    fn vmctx_memory_offset(&self) -> Option<i64> {
-        match self.memory_offset {
-            ModuleMemoryOffset::Defined(x) => Some(x as i64),
-            ModuleMemoryOffset::Imported(_) => {
-                // TODO implement memory offset for imported memory
-                None
-            }
-            ModuleMemoryOffset::None => None,
-        }
-    }
 }
 
 struct ExpressionWriter(write::EndianVec<gimli::RunTimeEndian>);
 
+enum VmctxBase {
+    Reg(u16),
+    OnStack,
+}
+
 impl ExpressionWriter {
-    pub fn new() -> Self {
+    fn new() -> Self {
         let endian = gimli::RunTimeEndian::Little;
         let writer = write::EndianVec::new(endian);
         ExpressionWriter(writer)
     }
 
-    pub fn write_op(&mut self, op: gimli::DwOp) -> write::Result<()> {
+    fn write_op(&mut self, op: gimli::DwOp) -> write::Result<()> {
         self.write_u8(op.0 as u8)
     }
 
-    pub fn write_op_reg(&mut self, reg: u16) -> write::Result<()> {
+    fn write_op_reg(&mut self, reg: u16) -> write::Result<()> {
         if reg < 32 {
             self.write_u8(gimli::constants::DW_OP_reg0.0 as u8 + reg as u8)
         } else {
@@ -55,7 +47,7 @@ impl ExpressionWriter {
         }
     }
 
-    pub fn write_op_breg(&mut self, reg: u16) -> write::Result<()> {
+    fn write_op_breg(&mut self, reg: u16) -> write::Result<()> {
         if reg < 32 {
             self.write_u8(gimli::constants::DW_OP_breg0.0 as u8 + reg as u8)
         } else {
@@ -64,25 +56,71 @@ impl ExpressionWriter {
         }
     }
 
-    pub fn write_u8(&mut self, b: u8) -> write::Result<()> {
+    fn write_u8(&mut self, b: u8) -> write::Result<()> {
         write::Writer::write_u8(&mut self.0, b)
     }
 
-    pub fn write_u32(&mut self, b: u32) -> write::Result<()> {
+    fn write_u32(&mut self, b: u32) -> write::Result<()> {
         write::Writer::write_u32(&mut self.0, b)
     }
 
-    pub fn write_uleb128(&mut self, i: u64) -> write::Result<()> {
+    fn write_uleb128(&mut self, i: u64) -> write::Result<()> {
         write::Writer::write_uleb128(&mut self.0, i)
     }
 
-    pub fn write_sleb128(&mut self, i: i64) -> write::Result<()> {
+    fn write_sleb128(&mut self, i: i64) -> write::Result<()> {
         write::Writer::write_sleb128(&mut self.0, i)
     }
 
-    pub fn into_vec(self) -> Vec<u8> {
+    fn into_vec(self) -> Vec<u8> {
         self.0.into_vec()
     }
+
+    fn gen_address_of_memory_base_pointer(
+        &mut self,
+        vmctx: VmctxBase,
+        memory_base: &ModuleMemoryOffset,
+    ) -> write::Result<()> {
+        match *memory_base {
+            ModuleMemoryOffset::Defined(offset) => match vmctx {
+                VmctxBase::Reg(reg) => {
+                    self.write_op_breg(reg)?;
+                    self.write_sleb128(offset.into())?;
+                }
+                VmctxBase::OnStack => {
+                    self.write_op(gimli::constants::DW_OP_consts)?;
+                    self.write_sleb128(offset.into())?;
+                    self.write_op(gimli::constants::DW_OP_plus)?;
+                }
+            },
+            ModuleMemoryOffset::Imported {
+                offset_to_vm_memory_definition,
+                offset_to_memory_base,
+            } => {
+                match vmctx {
+                    VmctxBase::Reg(reg) => {
+                        self.write_op_breg(reg)?;
+                        self.write_sleb128(offset_to_vm_memory_definition.into())?;
+                    }
+                    VmctxBase::OnStack => {
+                        if offset_to_vm_memory_definition > 0 {
+                            self.write_op(gimli::constants::DW_OP_consts)?;
+                            self.write_sleb128(offset_to_vm_memory_definition.into())?;
+                        }
+                        self.write_op(gimli::constants::DW_OP_plus)?;
+                    }
+                }
+                self.write_op(gimli::constants::DW_OP_deref)?;
+                if offset_to_memory_base > 0 {
+                    self.write_op(gimli::constants::DW_OP_consts)?;
+                    self.write_sleb128(offset_to_memory_base.into())?;
+                    self.write_op(gimli::constants::DW_OP_plus)?;
+                }
+            }
+            ModuleMemoryOffset::None => return Err(write::Error::InvalidAttributeValue),
+        }
+        Ok(())
+    }
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -165,34 +203,16 @@ fn append_memory_deref(
     isa: &dyn TargetIsa,
 ) -> Result<bool> {
     let mut writer = ExpressionWriter::new();
-    // FIXME for imported memory
-    match vmctx_loc {
-        LabelValueLoc::Reg(r) => {
-            let reg = isa.map_regalloc_reg_to_dwarf(r)?;
-            writer.write_op_breg(reg)?;
-            let memory_offset = match frame_info.vmctx_memory_offset() {
-                Some(offset) => offset,
-                None => {
-                    return Ok(false);
-                }
-            };
-            writer.write_sleb128(memory_offset)?;
-        }
+    let vmctx_base = match vmctx_loc {
+        LabelValueLoc::Reg(r) => VmctxBase::Reg(isa.map_regalloc_reg_to_dwarf(r)?),
         LabelValueLoc::CFAOffset(off) => {
             writer.write_op(gimli::constants::DW_OP_fbreg)?;
             writer.write_sleb128(off)?;
             writer.write_op(gimli::constants::DW_OP_deref)?;
-            writer.write_op(gimli::constants::DW_OP_consts)?;
-            let memory_offset = match frame_info.vmctx_memory_offset() {
-                Some(offset) => offset,
-                None => {
-                    return Ok(false);
-                }
-            };
-            writer.write_sleb128(memory_offset)?;
-            writer.write_op(gimli::constants::DW_OP_plus)?;
+            VmctxBase::OnStack
         }
-    }
+    };
+    writer.gen_address_of_memory_base_pointer(vmctx_base, &frame_info.memory_offset)?;
     writer.write_op(gimli::constants::DW_OP_deref)?;
     writer.write_op(gimli::constants::DW_OP_swap)?;
     writer.write_op(gimli::constants::DW_OP_const4u)?;
@@ -233,9 +253,7 @@ impl CompiledExpression {
                 Box<dyn Iterator<Item = (write::Address, u64)> + 'a>,
                 Vec<u8>,
             ),
-            Ranges(
-                Box<dyn Iterator<Item = Result<(DefinedFuncIndex, usize, usize, Vec<u8>)>> + 'a>,
-            ),
+            Ranges(Box<dyn Iterator<Item = Result<(usize, usize, usize, Vec<u8>)>> + 'a>),
         }
         impl Iterator for BuildWithLocalsResult<'_> {
             type Item = Result<(write::Address, u64, write::Expression)>;
@@ -246,10 +264,10 @@ impl CompiledExpression {
                         .next()
                         .map(|(addr, len)| Ok((addr, len, write::Expression::raw(code.to_vec())))),
                     BuildWithLocalsResult::Ranges(it) => it.next().map(|r| {
-                        r.map(|(func_index, start, end, code_buf)| {
+                        r.map(|(symbol, start, end, code_buf)| {
                             (
                                 write::Address::Symbol {
-                                    symbol: func_index.index(),
+                                    symbol,
                                     addend: start as i64,
                                 },
                                 (end - start) as u64,
@@ -629,7 +647,7 @@ where
 
 #[derive(Debug, Clone)]
 struct CachedValueLabelRange {
-    func_index: DefinedFuncIndex,
+    func_index: usize,
     start: usize,
     end: usize,
     label_location: HashMap<ValueLabel, LabelValueLoc>,
@@ -784,7 +802,7 @@ mod tests {
         FunctionFrameInfo, JumpTargetMarker, ValueLabel, ValueLabelsRanges,
     };
     use crate::CompiledFunctionMetadata;
-    use gimli::{self, constants, Encoding, EndianSlice, Expression, RunTimeEndian};
+    use gimli::{constants, Encoding, EndianSlice, Expression, RunTimeEndian};
     use wasmtime_environ::FilePos;
 
     macro_rules! dw_op {
@@ -1113,8 +1131,8 @@ mod tests {
     }
 
     fn create_mock_address_transform() -> AddressTransform {
+        use crate::FunctionAddressMap;
         use cranelift_entity::PrimaryMap;
-        use wasmtime_cranelift_shared::FunctionAddressMap;
         use wasmtime_environ::InstructionAddressMap;
         use wasmtime_environ::WasmFileInfo;
 
@@ -1155,7 +1173,7 @@ mod tests {
             imported_func_count: 0,
             path: None,
         };
-        AddressTransform::new(&module_map, &fi)
+        AddressTransform::mock(&module_map, fi)
     }
 
     fn create_mock_value_ranges() -> (ValueLabelsRanges, (ValueLabel, ValueLabel, ValueLabel)) {
@@ -1204,15 +1222,11 @@ mod tests {
     fn test_debug_value_range_builder() {
         use super::ValueLabelRangesBuilder;
         use crate::debug::ModuleMemoryOffset;
-        use cranelift_codegen::ir::StackSlots;
-        use wasmtime_environ::{DefinedFuncIndex, EntityRef};
 
         let addr_tr = create_mock_address_transform();
-        let sized_stack_slots = StackSlots::new();
         let (value_ranges, value_labels) = create_mock_value_ranges();
         let fi = FunctionFrameInfo {
             memory_offset: ModuleMemoryOffset::None,
-            sized_stack_slots: &sized_stack_slots,
             value_ranges: &value_ranges,
         };
 
@@ -1220,7 +1234,7 @@ mod tests {
         let builder = ValueLabelRangesBuilder::new(&[(10, 20)], &addr_tr, Some(&fi));
         let ranges = builder.into_ranges().collect::<Vec<_>>();
         assert_eq!(ranges.len(), 1);
-        assert_eq!(ranges[0].func_index, DefinedFuncIndex::new(0));
+        assert_eq!(ranges[0].func_index, 0);
         assert_eq!(ranges[0].start, 0);
         assert_eq!(ranges[0].end, 30);
 
diff --git a/crates/cranelift/src/debug/transform/line_program.rs b/crates/cranelift/src/debug/transform/line_program.rs
index 52d20ead62bc..56835d6feb97 100644
--- a/crates/cranelift/src/debug/transform/line_program.rs
+++ b/crates/cranelift/src/debug/transform/line_program.rs
@@ -1,12 +1,8 @@
 use super::address_transform::AddressTransform;
-use super::attr::clone_attr_string;
 use super::{Reader, TransformError};
-use anyhow::{Context, Error};
-use gimli::{
-    write, DebugLine, DebugLineOffset, DebugLineStr, DebugStr, DebugStrOffsets,
-    DebuggingInformationEntry, LineEncoding, Unit,
-};
-use wasmtime_environ::{DefinedFuncIndex, EntityRef};
+use anyhow::{bail, Error};
+use gimli::{write, DebugLineOffset, LineEncoding, Unit};
+use wasmtime_environ::DefinedFuncIndex;
 
 #[derive(Debug)]
 enum SavedLineProgramRow {
@@ -23,7 +19,7 @@ enum SavedLineProgramRow {
         epilogue_begin: bool,
         isa: u64,
     },
-    EndOfSequence(u64),
+    EndOfSequence,
 }
 
 #[derive(Debug)]
@@ -40,57 +36,19 @@ enum ReadLineProgramState {
 }
 
 pub(crate) fn clone_line_program<R>(
+    dwarf: &gimli::Dwarf<R>,
     unit: &Unit<R, R::Offset>,
-    root: &DebuggingInformationEntry<R>,
+    comp_name: Option<R>,
     addr_tr: &AddressTransform,
     out_encoding: gimli::Encoding,
-    debug_str: &DebugStr<R>,
-    debug_str_offsets: &DebugStrOffsets<R>,
-    debug_line_str: &DebugLineStr<R>,
-    debug_line: &DebugLine<R>,
     out_strings: &mut write::StringTable,
 ) -> Result<(write::LineProgram, DebugLineOffset, Vec<write::FileId>, u64), Error>
 where
     R: Reader,
 {
-    let offset = match root.attr_value(gimli::DW_AT_stmt_list)? {
-        Some(gimli::AttributeValue::DebugLineRef(offset)) => offset,
-        _ => {
-            return Err(TransformError("Debug line offset is not found").into());
-        }
-    };
-    let comp_dir = root.attr_value(gimli::DW_AT_comp_dir)?;
-    let comp_name = root.attr_value(gimli::DW_AT_name)?;
-    let out_comp_dir = match &comp_dir {
-        Some(comp_dir) => Some(clone_attr_string(
-            comp_dir,
-            gimli::DW_FORM_strp,
-            unit,
-            debug_str,
-            debug_str_offsets,
-            debug_line_str,
-            out_strings,
-        )?),
-        None => None,
-    };
-    let out_comp_name = clone_attr_string(
-        comp_name.as_ref().context("missing DW_AT_name attribute")?,
-        gimli::DW_FORM_strp,
-        unit,
-        debug_str,
-        debug_str_offsets,
-        debug_line_str,
-        out_strings,
-    )?;
-
-    let program = debug_line.program(
-        offset,
-        unit.header.address_size(),
-        comp_dir.and_then(|val| val.string_value(&debug_str)),
-        comp_name.and_then(|val| val.string_value(&debug_str)),
-    );
-    if let Ok(program) = program {
+    if let Some(program) = unit.line_program.clone() {
         let header = program.header();
+        let offset = header.offset();
         let file_index_base = if header.version() < 5 { 1 } else { 0 };
         assert!(header.version() <= 5, "not supported 6");
         let line_encoding = LineEncoding {
@@ -100,23 +58,32 @@ where
             line_base: header.line_base(),
             line_range: header.line_range(),
         };
+        let out_comp_dir = match header.directory(0) {
+            Some(comp_dir) => clone_line_string(
+                dwarf.attr_string(unit, comp_dir)?,
+                gimli::DW_FORM_string,
+                out_strings,
+            )?,
+            None => write::LineString::String(Vec::new()),
+        };
+        let out_comp_name = match comp_name {
+            Some(comp_name) => clone_line_string(comp_name, gimli::DW_FORM_strp, out_strings)?,
+            None => write::LineString::String(Vec::new()),
+        };
+
         let mut out_program = write::LineProgram::new(
             out_encoding,
             line_encoding,
-            out_comp_dir.unwrap_or_else(|| write::LineString::String(Vec::new())),
+            out_comp_dir,
             out_comp_name,
             None,
         );
         let mut dirs = Vec::new();
         dirs.push(out_program.default_directory());
         for dir_attr in header.include_directories() {
-            let dir_id = out_program.add_directory(clone_attr_string(
-                dir_attr,
+            let dir_id = out_program.add_directory(clone_line_string(
+                dwarf.attr_string(unit, dir_attr.clone())?,
                 gimli::DW_FORM_string,
-                unit,
-                debug_str,
-                debug_str_offsets,
-                debug_line_str,
                 out_strings,
             )?);
             dirs.push(dir_id);
@@ -128,13 +95,9 @@ where
             let dir_index = file_entry.directory_index() + directory_index_correction;
             let dir_id = dirs[dir_index as usize];
             let file_id = out_program.add_file(
-                clone_attr_string(
-                    &file_entry.path_name(),
+                clone_line_string(
+                    dwarf.attr_string(unit, file_entry.path_name())?,
                     gimli::DW_FORM_string,
-                    unit,
-                    debug_str,
-                    debug_str_offsets,
-                    debug_line_str,
                     out_strings,
                 )?,
                 dir_id,
@@ -167,7 +130,7 @@ where
 
                 saved_rows = Vec::new();
                 state = ReadLineProgramState::SequenceEnded;
-                SavedLineProgramRow::EndOfSequence(row.address())
+                SavedLineProgramRow::EndOfSequence
             } else {
                 if state == ReadLineProgramState::SequenceEnded {
                     // Discard sequences for non-existent code.
@@ -217,7 +180,7 @@ where
                     continue; // no code generated
                 }
             };
-            let symbol = index.index();
+            let symbol = map.symbol;
             let base_addr = map.offset;
             out_program.begin_sequence(Some(write::Address::Symbol { symbol, addend: 0 }));
             // TODO track and place function declaration line here
@@ -280,3 +243,22 @@ where
         Err(TransformError("Valid line program not found").into())
     }
 }
+
+fn clone_line_string<R>(
+    value: R,
+    form: gimli::DwForm,
+    out_strings: &mut write::StringTable,
+) -> Result<write::LineString, Error>
+where
+    R: Reader,
+{
+    let content = value.to_string_lossy()?.into_owned();
+    Ok(match form {
+        gimli::DW_FORM_strp => {
+            let id = out_strings.add(content);
+            write::LineString::StringRef(id)
+        }
+        gimli::DW_FORM_string => write::LineString::String(content.into()),
+        _ => bail!("DW_FORM_line_strp or other not supported"),
+    })
+}
diff --git a/crates/cranelift/src/debug/transform/mod.rs b/crates/cranelift/src/debug/transform/mod.rs
index 8a0b3e3cccaf..b9a813ac7987 100644
--- a/crates/cranelift/src/debug/transform/mod.rs
+++ b/crates/cranelift/src/debug/transform/mod.rs
@@ -2,17 +2,15 @@ use self::refs::DebugInfoRefsMap;
 use self::simulate::generate_simulated_dwarf;
 use self::unit::clone_unit;
 use crate::debug::gc::build_dependencies;
-use crate::debug::ModuleMemoryOffset;
-use crate::CompiledFunctionsMetadata;
+use crate::debug::Compilation;
 use anyhow::Error;
 use cranelift_codegen::isa::TargetIsa;
-use gimli::{
-    write, DebugAddr, DebugLine, DebugLineStr, DebugStr, DebugStrOffsets, LocationLists,
-    RangeLists, UnitSectionOffset,
-};
-use std::collections::HashSet;
+use gimli::{write, Dwarf, DwarfPackage, LittleEndian, Section, Unit, UnitSectionOffset};
+use std::{collections::HashSet, fmt::Debug};
 use thiserror::Error;
-use wasmtime_environ::DebugInfoData;
+use wasmtime_environ::{
+    DefinedFuncIndex, ModuleTranslation, PrimaryMap, StaticModuleIndex, Tunables,
+};
 
 pub use address_transform::AddressTransform;
 
@@ -26,47 +24,140 @@ mod simulate;
 mod unit;
 mod utils;
 
-pub(crate) trait Reader: gimli::Reader<Offset = usize> {}
+impl<'a> Compilation<'a> {
+    fn function_frame_info(
+        &mut self,
+        module: StaticModuleIndex,
+        func: DefinedFuncIndex,
+    ) -> expression::FunctionFrameInfo<'a> {
+        let (_, func) = self.function(module, func);
 
-impl<'input, Endian> Reader for gimli::EndianSlice<'input, Endian> where Endian: gimli::Endianity {}
+        expression::FunctionFrameInfo {
+            value_ranges: &func.value_labels_ranges,
+            memory_offset: self.module_memory_offsets[module].clone(),
+        }
+    }
+}
+
+pub(crate) trait Reader: gimli::Reader<Offset = usize> + Send + Sync {}
+
+impl<'input, Endian> Reader for gimli::EndianSlice<'input, Endian> where
+    Endian: gimli::Endianity + Send + Sync
+{
+}
 
 #[derive(Error, Debug)]
 #[error("Debug info transform error: {0}")]
 pub struct TransformError(&'static str);
 
-pub(crate) struct DebugInputContext<'a, R>
-where
-    R: Reader,
-{
-    debug_str: &'a DebugStr<R>,
-    debug_str_offsets: &'a DebugStrOffsets<R>,
-    debug_line_str: &'a DebugLineStr<R>,
-    debug_line: &'a DebugLine<R>,
-    debug_addr: &'a DebugAddr<R>,
-    rnglists: &'a RangeLists<R>,
-    loclists: &'a LocationLists<R>,
+pub(crate) struct DebugInputContext<'a> {
     reachable: &'a HashSet<UnitSectionOffset>,
 }
 
+fn load_dwp<'data>(
+    translation: ModuleTranslation<'data>,
+    buffer: &'data [u8],
+) -> anyhow::Result<DwarfPackage<gimli::EndianSlice<'data, gimli::LittleEndian>>> {
+    let endian_slice = gimli::EndianSlice::new(buffer, LittleEndian);
+
+    let dwarf_package = DwarfPackage::load(
+        |id| -> anyhow::Result<_> {
+            let slice = match id {
+                gimli::SectionId::DebugAbbrev => {
+                    translation.debuginfo.dwarf.debug_abbrev.reader().slice()
+                }
+                gimli::SectionId::DebugInfo => {
+                    translation.debuginfo.dwarf.debug_info.reader().slice()
+                }
+                gimli::SectionId::DebugLine => {
+                    translation.debuginfo.dwarf.debug_line.reader().slice()
+                }
+                gimli::SectionId::DebugStr => {
+                    translation.debuginfo.dwarf.debug_str.reader().slice()
+                }
+                gimli::SectionId::DebugStrOffsets => translation
+                    .debuginfo
+                    .dwarf
+                    .debug_str_offsets
+                    .reader()
+                    .slice(),
+                gimli::SectionId::DebugLoc => translation.debuginfo.debug_loc.reader().slice(),
+                gimli::SectionId::DebugLocLists => {
+                    translation.debuginfo.debug_loclists.reader().slice()
+                }
+                gimli::SectionId::DebugRngLists => {
+                    translation.debuginfo.debug_rnglists.reader().slice()
+                }
+                gimli::SectionId::DebugTypes => {
+                    translation.debuginfo.dwarf.debug_types.reader().slice()
+                }
+                gimli::SectionId::DebugCuIndex => {
+                    translation.debuginfo.debug_cu_index.reader().slice()
+                }
+                gimli::SectionId::DebugTuIndex => {
+                    translation.debuginfo.debug_tu_index.reader().slice()
+                }
+                _ => &buffer,
+            };
+
+            Ok(gimli::EndianSlice::new(slice, gimli::LittleEndian))
+        },
+        endian_slice,
+    )?;
+
+    Ok(dwarf_package)
+}
+
+/// Attempts to load a DWARF package using the passed bytes.
+fn read_dwarf_package_from_bytes<'data>(
+    dwp_bytes: &'data [u8],
+    buffer: &'data [u8],
+    tunables: &Tunables,
+) -> Option<DwarfPackage<gimli::EndianSlice<'data, gimli::LittleEndian>>> {
+    let mut validator = wasmparser::Validator::new();
+    let parser = wasmparser::Parser::new(0);
+    let mut types = wasmtime_environ::ModuleTypesBuilder::new(&validator);
+    let translation =
+        match wasmtime_environ::ModuleEnvironment::new(tunables, &mut validator, &mut types)
+            .translate(parser, dwp_bytes)
+        {
+            Ok(translation) => translation,
+            Err(e) => {
+                log::warn!("failed to parse wasm dwarf package: {e:?}");
+                return None;
+            }
+        };
+
+    match load_dwp(translation, buffer) {
+        Ok(package) => Some(package),
+        Err(err) => {
+            log::warn!("Failed to load Dwarf package {}", err);
+            None
+        }
+    }
+}
+
 pub fn transform_dwarf(
     isa: &dyn TargetIsa,
-    di: &DebugInfoData,
-    funcs: &CompiledFunctionsMetadata,
-    memory_offset: &ModuleMemoryOffset,
+    compilation: &mut Compilation<'_>,
 ) -> Result<write::Dwarf, Error> {
-    let addr_tr = AddressTransform::new(funcs, &di.wasm_file);
-    let reachable = build_dependencies(&di.dwarf, &addr_tr)?.get_reachable();
-
-    let context = DebugInputContext {
-        debug_str: &di.dwarf.debug_str,
-        debug_str_offsets: &di.dwarf.debug_str_offsets,
-        debug_line_str: &di.dwarf.debug_line_str,
-        debug_line: &di.dwarf.debug_line,
-        debug_addr: &di.dwarf.debug_addr,
-        rnglists: &di.dwarf.ranges,
-        loclists: &di.dwarf.locations,
-        reachable: &reachable,
-    };
+    let mut transforms = PrimaryMap::new();
+    for (i, _) in compilation.translations.iter() {
+        transforms.push(AddressTransform::new(compilation, i));
+    }
+
+    let buffer = Vec::new();
+
+    let dwarf_package = compilation
+        .dwarf_package_bytes
+        .map(
+            |bytes| -> Option<DwarfPackage<gimli::EndianSlice<'_, gimli::LittleEndian>>> {
+                read_dwarf_package_from_bytes(bytes, &buffer, compilation.tunables)
+            },
+        )
+        .flatten();
+
+    let reachable = build_dependencies(compilation, &dwarf_package, &transforms)?.get_reachable();
 
     let out_encoding = gimli::Encoding {
         format: gimli::Format::Dwarf32,
@@ -83,33 +174,56 @@ pub fn transform_dwarf(
     let mut di_ref_map = DebugInfoRefsMap::new();
 
     let mut translated = HashSet::new();
-    let mut iter = di.dwarf.debug_info.units();
-    while let Some(header) = iter.next().unwrap_or(None) {
-        let unit = di.dwarf.unit(header)?;
-        if let Some((id, ref_map, pending_refs)) = clone_unit(
-            &di.dwarf,
-            unit,
-            &context,
-            &addr_tr,
-            funcs,
-            memory_offset,
-            out_encoding,
-            &mut out_units,
-            &mut out_strings,
-            &mut translated,
-            isa,
-        )? {
-            di_ref_map.insert(&header, id, ref_map);
-            pending_di_refs.push((id, pending_refs));
+
+    for (module, translation) in compilation.translations.iter() {
+        let addr_tr = &transforms[module];
+        let di = &translation.debuginfo;
+        let context = DebugInputContext {
+            reachable: &reachable,
+        };
+        let mut iter = di.dwarf.debug_info.units();
+
+        while let Some(header) = iter.next().unwrap_or(None) {
+            let unit = di.dwarf.unit(header)?;
+
+            let mut resolved_unit = None;
+            let mut split_dwarf = None;
+
+            if unit.dwo_id.is_some() {
+                if let Some(dwarf_package) = &dwarf_package {
+                    if let Some((fused, fused_dwarf)) =
+                        replace_unit_from_split_dwarf(&unit, dwarf_package, &di.dwarf)
+                    {
+                        resolved_unit = Some(fused);
+                        split_dwarf = Some(fused_dwarf);
+                    }
+                }
+            }
+
+            if let Some((id, ref_map, pending_refs)) = clone_unit(
+                compilation,
+                module,
+                &unit,
+                resolved_unit.as_ref(),
+                split_dwarf.as_ref(),
+                &context,
+                &addr_tr,
+                out_encoding,
+                &mut out_units,
+                &mut out_strings,
+                &mut translated,
+                isa,
+            )? {
+                di_ref_map.insert(&header, id, ref_map);
+                pending_di_refs.push((id, pending_refs));
+            }
         }
     }
     di_ref_map.patch(pending_di_refs.into_iter(), &mut out_units);
 
     generate_simulated_dwarf(
-        &addr_tr,
-        di,
-        memory_offset,
-        funcs,
+        compilation,
+        &transforms,
         &translated,
         out_encoding,
         &mut out_units,
@@ -124,3 +238,19 @@ pub fn transform_dwarf(
         strings: out_strings,
     })
 }
+
+fn replace_unit_from_split_dwarf<'a>(
+    unit: &'a Unit<gimli::EndianSlice<'a, gimli::LittleEndian>, usize>,
+    dwp: &DwarfPackage<gimli::EndianSlice<'a, gimli::LittleEndian>>,
+    parent: &Dwarf<gimli::EndianSlice<'a, gimli::LittleEndian>>,
+) -> Option<(
+    Unit<gimli::EndianSlice<'a, gimli::LittleEndian>, usize>,
+    Dwarf<gimli::EndianSlice<'a, gimli::LittleEndian>>,
+)> {
+    let dwo_id = unit.dwo_id?;
+    let split_unit_dwarf = dwp.find_cu(dwo_id, parent).ok()??;
+    let unit_header = split_unit_dwarf.debug_info.units().next().ok()??;
+    let mut split_unit = split_unit_dwarf.unit(unit_header).ok()?;
+    split_unit.copy_relocated_attributes(unit);
+    Some((split_unit, split_unit_dwarf))
+}
diff --git a/crates/cranelift/src/debug/transform/range_info_builder.rs b/crates/cranelift/src/debug/transform/range_info_builder.rs
index 7fda1c33e4d4..526c83e6173f 100644
--- a/crates/cranelift/src/debug/transform/range_info_builder.rs
+++ b/crates/cranelift/src/debug/transform/range_info_builder.rs
@@ -1,8 +1,8 @@
 use super::address_transform::AddressTransform;
-use super::{DebugInputContext, Reader};
+use super::Reader;
 use anyhow::Error;
 use gimli::{write, AttributeValue, DebuggingInformationEntry, RangeListsOffset, Unit};
-use wasmtime_environ::{DefinedFuncIndex, EntityRef};
+use wasmtime_environ::DefinedFuncIndex;
 
 pub(crate) enum RangeInfoBuilder {
     Undefined,
@@ -16,15 +16,13 @@ impl RangeInfoBuilder {
         dwarf: &gimli::Dwarf<R>,
         unit: &Unit<R, R::Offset>,
         entry: &DebuggingInformationEntry<R>,
-        context: &DebugInputContext<R>,
-        cu_low_pc: u64,
     ) -> Result<Self, Error>
     where
         R: Reader,
     {
         if let Some(AttributeValue::RangeListsRef(r)) = entry.attr_value(gimli::DW_AT_ranges)? {
             let r = dwarf.ranges_offset_from_raw(unit, r);
-            return RangeInfoBuilder::from_ranges_ref(unit, r, context, cu_low_pc);
+            return RangeInfoBuilder::from_ranges_ref(dwarf, unit, r);
         };
 
         let low_pc =
@@ -33,7 +31,7 @@ impl RangeInfoBuilder {
             } else if let Some(AttributeValue::DebugAddrIndex(i)) =
                 entry.attr_value(gimli::DW_AT_low_pc)?
             {
-                context.debug_addr.get_address(4, unit.addr_base, i)?
+                dwarf.address(unit, i)?
             } else {
                 return Ok(RangeInfoBuilder::Undefined);
             };
@@ -48,22 +46,14 @@ impl RangeInfoBuilder {
     }
 
     pub(crate) fn from_ranges_ref<R>(
+        dwarf: &gimli::Dwarf<R>,
         unit: &Unit<R, R::Offset>,
         ranges: RangeListsOffset,
-        context: &DebugInputContext<R>,
-        cu_low_pc: u64,
     ) -> Result<Self, Error>
     where
         R: Reader,
     {
-        let unit_encoding = unit.encoding();
-        let mut ranges = context.rnglists.ranges(
-            ranges,
-            unit_encoding,
-            cu_low_pc,
-            &context.debug_addr,
-            unit.addr_base,
-        )?;
+        let mut ranges = dwarf.ranges(unit, ranges)?;
         let mut result = Vec::new();
         while let Some(range) = ranges.next()? {
             if range.begin >= range.end {
@@ -83,32 +73,23 @@ impl RangeInfoBuilder {
         dwarf: &gimli::Dwarf<R>,
         unit: &Unit<R, R::Offset>,
         entry: &DebuggingInformationEntry<R>,
-        context: &DebugInputContext<R>,
         addr_tr: &AddressTransform,
-        cu_low_pc: u64,
     ) -> Result<Self, Error>
     where
         R: Reader,
     {
-        let unit_encoding = unit.encoding();
         let addr =
             if let Some(AttributeValue::Addr(addr)) = entry.attr_value(gimli::DW_AT_low_pc)? {
                 addr
             } else if let Some(AttributeValue::DebugAddrIndex(i)) =
                 entry.attr_value(gimli::DW_AT_low_pc)?
             {
-                context.debug_addr.get_address(4, unit.addr_base, i)?
+                dwarf.address(unit, i)?
             } else if let Some(AttributeValue::RangeListsRef(r)) =
                 entry.attr_value(gimli::DW_AT_ranges)?
             {
                 let r = dwarf.ranges_offset_from_raw(unit, r);
-                let mut ranges = context.rnglists.ranges(
-                    r,
-                    unit_encoding,
-                    cu_low_pc,
-                    &context.debug_addr,
-                    unit.addr_base,
-                )?;
+                let mut ranges = dwarf.ranges(unit, r)?;
                 if let Some(range) = ranges.next()? {
                     range.begin
                 } else {
@@ -145,7 +126,20 @@ impl RangeInfoBuilder {
                 for (begin, end) in ranges {
                     result.extend(addr_tr.translate_ranges(*begin, *end));
                 }
-                if result.len() != 1 {
+
+                // If we're seeing the ranges for a `DW_TAG_compile_unit` DIE
+                // then don't use `DW_AT_low_pc` and `DW_AT_high_pc`. These
+                // attributes, if set, will configure the base address of all
+                // location lists that this unit refers to. Currently this
+                // debug transform does not take this base address into account
+                // when generate the `.debug_loc` section. Consequently when a
+                // compile unit is configured here the `DW_AT_ranges` attribute
+                // is unconditionally used instead of
+                // `DW_AT_low_pc`/`DW_AT_high_pc`.
+                let is_attr_for_compile_unit =
+                    out_unit.get(current_scope_id).tag() == gimli::DW_TAG_compile_unit;
+
+                if result.len() != 1 || is_attr_for_compile_unit {
                     let range_list = result
                         .iter()
                         .map(|tr| write::Range::StartLength {
@@ -172,8 +166,8 @@ impl RangeInfoBuilder {
                 }
             }
             RangeInfoBuilder::Function(index) => {
+                let symbol = addr_tr.map()[*index].symbol;
                 let range = addr_tr.func_range(*index);
-                let symbol = index.index();
                 let addr = write::Address::Symbol {
                     symbol,
                     addend: range.0 as i64,
diff --git a/crates/cranelift/src/debug/transform/simulate.rs b/crates/cranelift/src/debug/transform/simulate.rs
index df06268d86cc..2e0875a97736 100644
--- a/crates/cranelift/src/debug/transform/simulate.rs
+++ b/crates/cranelift/src/debug/transform/simulate.rs
@@ -1,18 +1,18 @@
 use super::expression::{CompiledExpression, FunctionFrameInfo};
-use super::utils::{add_internal_types, append_vmctx_info, get_function_frame_info};
+use super::utils::{add_internal_types, append_vmctx_info};
 use super::AddressTransform;
-use crate::debug::ModuleMemoryOffset;
-use crate::CompiledFunctionsMetadata;
+use crate::debug::{Compilation, ModuleMemoryOffset};
 use anyhow::{Context, Error};
 use cranelift_codegen::isa::TargetIsa;
 use cranelift_wasm::get_vmctx_value_label;
 use gimli::write;
-use gimli::{self, LineEncoding};
+use gimli::LineEncoding;
 use std::collections::{HashMap, HashSet};
 use std::path::PathBuf;
 use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
 use wasmtime_environ::{
-    DebugInfoData, DefinedFuncIndex, EntityRef, FuncIndex, FunctionMetadata, WasmFileInfo, WasmType,
+    DebugInfoData, EntityRef, FunctionMetadata, PrimaryMap, StaticModuleIndex, WasmFileInfo,
+    WasmValType,
 };
 
 const PRODUCER_NAME: &str = "wasmtime";
@@ -30,14 +30,14 @@ macro_rules! assert_dwarf_str {
 }
 
 fn generate_line_info(
-    addr_tr: &AddressTransform,
-    translated: &HashSet<DefinedFuncIndex>,
+    addr_tr: &PrimaryMap<StaticModuleIndex, AddressTransform>,
+    translated: &HashSet<usize>,
     out_encoding: gimli::Encoding,
     w: &WasmFileInfo,
     comp_dir_id: write::StringId,
     name_id: write::StringId,
     name: &str,
-) -> Result<write::LineProgram, Error> {
+) -> Result<(write::LineProgram, write::FileId), Error> {
     let out_comp_dir = write::LineString::StringRef(comp_dir_id);
     let out_comp_name = write::LineString::StringRef(name_id);
 
@@ -57,12 +57,17 @@ fn generate_line_info(
         None,
     );
 
-    for (i, map) in addr_tr.map() {
-        let symbol = i.index();
-        if translated.contains(&i) {
-            continue;
-        }
-
+    let maps = addr_tr.iter().flat_map(|(_, transform)| {
+        transform.map().iter().filter_map(|(_, map)| {
+            if translated.contains(&map.symbol) {
+                None
+            } else {
+                Some((map.symbol, map))
+            }
+        })
+    });
+
+    for (symbol, map) in maps {
         let base_addr = map.offset;
         out_program.begin_sequence(Some(write::Address::Symbol { symbol, addend: 0 }));
         for addr_map in map.addresses.iter() {
@@ -70,7 +75,7 @@ fn generate_line_info(
             out_program.row().address_offset = address_offset;
             out_program.row().op_index = 0;
             out_program.row().file = file_index;
-            let wasm_offset = w.code_section_offset + addr_map.wasm as u64;
+            let wasm_offset = w.code_section_offset + addr_map.wasm;
             out_program.row().line = wasm_offset;
             out_program.row().column = 0;
             out_program.row().discriminator = 1;
@@ -85,7 +90,7 @@ fn generate_line_info(
         out_program.end_sequence(end_addr);
     }
 
-    Ok(out_program)
+    Ok((out_program, file_index))
 }
 
 fn check_invalid_chars_in_name(s: &str) -> Option<&str> {
@@ -103,8 +108,8 @@ fn autogenerate_dwarf_wasm_path(di: &DebugInfoData) -> PathBuf {
         .module_name
         .and_then(check_invalid_chars_in_name)
         .map(|s| s.to_string())
-        .unwrap_or_else(|| format!("<gen-{}>", NEXT_ID.fetch_add(1, SeqCst)));
-    let path = format!("/<wasm-module>/{}.wasm", module_name);
+        .unwrap_or_else(|| format!("<gen-{}>.wasm", NEXT_ID.fetch_add(1, SeqCst)));
+    let path = format!("/<wasm-module>/{module_name}");
     PathBuf::from(path)
 }
 
@@ -173,10 +178,10 @@ fn resolve_var_type(
         (func_meta.locals[j].1, false)
     };
     let type_die_id = match ty {
-        WasmType::I32 => wasm_types.i32,
-        WasmType::I64 => wasm_types.i64,
-        WasmType::F32 => wasm_types.f32,
-        WasmType::F64 => wasm_types.f64,
+        WasmValType::I32 => wasm_types.i32,
+        WasmValType::I64 => wasm_types.i64,
+        WasmValType::F32 => wasm_types.f32,
+        WasmValType::F64 => wasm_types.f64,
         _ => {
             // Ignore unsupported types.
             return None;
@@ -199,7 +204,7 @@ fn generate_vars(
 ) -> Result<(), Error> {
     let vmctx_label = get_vmctx_value_label();
 
-    // Normalize order of ValueLabelsRanges keys to have reproducable results.
+    // Normalize order of ValueLabelsRanges keys to have reproducible results.
     let mut vars = frame_info.value_ranges.keys().collect::<Vec<_>>();
     vars.sort_by(|a, b| a.index().cmp(&b.index()));
 
@@ -254,7 +259,7 @@ fn generate_vars(
                 .and_then(|s| check_invalid_chars_in_name(s))
             {
                 Some(n) => out_strings.add(assert_dwarf_str!(n)),
-                None => out_strings.add(format!("var{}", var_index)),
+                None => out_strings.add(format!("var{var_index}")),
             };
 
             var.set(gimli::DW_AT_name, write::AttributeValue::StringRef(name_id));
@@ -278,28 +283,26 @@ fn check_invalid_chars_in_path(path: PathBuf) -> Option<PathBuf> {
 }
 
 pub fn generate_simulated_dwarf(
-    addr_tr: &AddressTransform,
-    di: &DebugInfoData,
-    memory_offset: &ModuleMemoryOffset,
-    funcs: &CompiledFunctionsMetadata,
-    translated: &HashSet<DefinedFuncIndex>,
+    compilation: &mut Compilation<'_>,
+    addr_tr: &PrimaryMap<StaticModuleIndex, AddressTransform>,
+    translated: &HashSet<usize>,
     out_encoding: gimli::Encoding,
     out_units: &mut write::UnitTable,
     out_strings: &mut write::StringTable,
     isa: &dyn TargetIsa,
 ) -> Result<(), Error> {
-    let path = di
-        .wasm_file
-        .path
-        .to_owned()
-        .and_then(check_invalid_chars_in_path)
-        .unwrap_or_else(|| autogenerate_dwarf_wasm_path(di));
-
-    let func_names = &di.name_section.func_names;
-    let locals_names = &di.name_section.locals_names;
-    let imported_func_count = di.wasm_file.imported_func_count;
-
-    let (unit, root_id, name_id) = {
+    let (wasm_file, path) = {
+        let di = &compilation.translations.iter().next().unwrap().1.debuginfo;
+        let path = di
+            .wasm_file
+            .path
+            .to_owned()
+            .and_then(check_invalid_chars_in_path)
+            .unwrap_or_else(|| autogenerate_dwarf_wasm_path(di));
+        (&di.wasm_file, path)
+    };
+
+    let (unit, root_id, file_id) = {
         let comp_dir_id = out_strings.add(assert_dwarf_str!(path
             .parent()
             .context("path dir")?
@@ -312,11 +315,11 @@ pub fn generate_simulated_dwarf(
             .context("path name encoding")?;
         let name_id = out_strings.add(assert_dwarf_str!(name));
 
-        let out_program = generate_line_info(
+        let (out_program, file_id) = generate_line_info(
             addr_tr,
             translated,
             out_encoding,
-            &di.wasm_file,
+            wasm_file,
             comp_dir_id,
             name_id,
             name,
@@ -339,17 +342,24 @@ pub fn generate_simulated_dwarf(
             gimli::DW_AT_comp_dir,
             write::AttributeValue::StringRef(comp_dir_id),
         );
-        (unit, root_id, name_id)
+        (unit, root_id, file_id)
     };
 
-    let wasm_types = add_wasm_types(unit, root_id, out_strings, memory_offset);
+    let mut module_wasm_types = PrimaryMap::new();
+    for (module, memory_offset) in compilation.module_memory_offsets.iter() {
+        let wasm_types = add_wasm_types(unit, root_id, out_strings, memory_offset);
+        let i = module_wasm_types.push(wasm_types);
+        assert_eq!(i, module);
+    }
 
-    for (i, map) in addr_tr.map().iter() {
-        let index = i.index();
-        if translated.contains(&i) {
+    for (module, index) in compilation.indexes().collect::<Vec<_>>() {
+        let (symbol, _) = compilation.function(module, index);
+        if translated.contains(&symbol) {
             continue;
         }
 
+        let addr_tr = &addr_tr[module];
+        let map = &addr_tr.map()[index];
         let start = map.offset as u64;
         let end = start + map.len as u64;
         let die_id = unit.add(root_id, gimli::DW_TAG_subprogram);
@@ -357,53 +367,56 @@ pub fn generate_simulated_dwarf(
         die.set(
             gimli::DW_AT_low_pc,
             write::AttributeValue::Address(write::Address::Symbol {
-                symbol: index,
+                symbol,
                 addend: start as i64,
             }),
         );
         die.set(
             gimli::DW_AT_high_pc,
-            write::AttributeValue::Udata((end - start) as u64),
+            write::AttributeValue::Udata(end - start),
         );
 
-        let func_index = imported_func_count + (index as u32);
-        let id = match func_names
-            .get(&FuncIndex::from_u32(func_index))
+        let translation = &compilation.translations[module];
+        let func_index = translation.module.func_index(index);
+        let di = &translation.debuginfo;
+        let id = match di
+            .name_section
+            .func_names
+            .get(&func_index)
             .and_then(|s| check_invalid_chars_in_name(s))
         {
             Some(n) => out_strings.add(assert_dwarf_str!(n)),
-            None => out_strings.add(format!("wasm-function[{}]", func_index)),
+            None => out_strings.add(format!("wasm-function[{}]", func_index.as_u32())),
         };
 
         die.set(gimli::DW_AT_name, write::AttributeValue::StringRef(id));
 
         die.set(
             gimli::DW_AT_decl_file,
-            write::AttributeValue::StringRef(name_id),
+            write::AttributeValue::FileIndex(Some(file_id)),
         );
 
         let f_start = map.addresses[0].wasm;
-        let wasm_offset = di.wasm_file.code_section_offset + f_start as u64;
+        let wasm_offset = di.wasm_file.code_section_offset + f_start;
         die.set(
-            gimli::DW_AT_decl_file,
+            gimli::DW_AT_decl_line,
             write::AttributeValue::Udata(wasm_offset),
         );
 
-        if let Some(frame_info) = get_function_frame_info(memory_offset, funcs, i) {
-            let source_range = addr_tr.func_source_range(i);
-            generate_vars(
-                unit,
-                die_id,
-                addr_tr,
-                &frame_info,
-                &[(source_range.0, source_range.1)],
-                &wasm_types,
-                &di.wasm_file.funcs[index],
-                locals_names.get(&FuncIndex::from_u32(index as u32)),
-                out_strings,
-                isa,
-            )?;
-        }
+        let frame_info = compilation.function_frame_info(module, index);
+        let source_range = addr_tr.func_source_range(index);
+        generate_vars(
+            unit,
+            die_id,
+            addr_tr,
+            &frame_info,
+            &[(source_range.0, source_range.1)],
+            &module_wasm_types[module],
+            &di.wasm_file.funcs[index.as_u32() as usize],
+            di.name_section.locals_names.get(&func_index),
+            out_strings,
+            isa,
+        )?;
     }
 
     Ok(())
diff --git a/crates/cranelift/src/debug/transform/unit.rs b/crates/cranelift/src/debug/transform/unit.rs
index eefed56d071b..1a2292b9050d 100644
--- a/crates/cranelift/src/debug/transform/unit.rs
+++ b/crates/cranelift/src/debug/transform/unit.rs
@@ -4,17 +4,16 @@ use super::expression::compile_expression;
 use super::line_program::clone_line_program;
 use super::range_info_builder::RangeInfoBuilder;
 use super::refs::{PendingDebugInfoRefs, PendingUnitRefs, UnitRefsMap};
-use super::utils::{add_internal_types, append_vmctx_info, get_function_frame_info};
-use super::{DebugInputContext, Reader, TransformError};
-use crate::debug::ModuleMemoryOffset;
-use crate::CompiledFunctionsMetadata;
+use super::utils::{add_internal_types, append_vmctx_info};
+use super::DebugInputContext;
+use crate::debug::{Compilation, Reader};
 use anyhow::{Context, Error};
 use cranelift_codegen::ir::Endianness;
 use cranelift_codegen::isa::TargetIsa;
 use gimli::write;
-use gimli::{AttributeValue, DebuggingInformationEntry, Unit};
+use gimli::{AttributeValue, DebuggingInformationEntry, Dwarf, Unit};
 use std::collections::HashSet;
-use wasmtime_environ::DefinedFuncIndex;
+use wasmtime_environ::StaticModuleIndex;
 use wasmtime_versioned_export_macros::versioned_stringify_ident;
 
 struct InheritedAttr<T> {
@@ -45,38 +44,31 @@ impl<T> InheritedAttr<T> {
     }
 }
 
-fn get_base_type_name<R>(
-    type_entry: &DebuggingInformationEntry<R>,
-    unit: &Unit<R, R::Offset>,
-    context: &DebugInputContext<R>,
-) -> Result<String, Error>
-where
-    R: Reader,
-{
+fn get_base_type_name(
+    type_entry: &DebuggingInformationEntry<Reader<'_>>,
+    unit: &Unit<Reader<'_>, usize>,
+    dwarf: &Dwarf<Reader<'_>>,
+) -> Result<String, Error> {
     // FIXME remove recursion.
     if let Some(AttributeValue::UnitRef(ref offset)) = type_entry.attr_value(gimli::DW_AT_type)? {
         let mut entries = unit.entries_at_offset(*offset)?;
         entries.next_entry()?;
         if let Some(die) = entries.current() {
-            if let Some(AttributeValue::DebugStrRef(str_offset)) =
-                die.attr_value(gimli::DW_AT_name)?
-            {
-                return Ok(String::from(
-                    context.debug_str.get_str(str_offset)?.to_string()?,
-                ));
+            if let Some(value) = die.attr_value(gimli::DW_AT_name)? {
+                return Ok(String::from(dwarf.attr_string(unit, value)?.to_string()?));
             }
             match die.tag() {
                 gimli::DW_TAG_const_type => {
-                    return Ok(format!("const {}", get_base_type_name(die, unit, context)?));
+                    return Ok(format!("const {}", get_base_type_name(die, unit, dwarf)?));
                 }
                 gimli::DW_TAG_pointer_type => {
-                    return Ok(format!("{}*", get_base_type_name(die, unit, context)?));
+                    return Ok(format!("{}*", get_base_type_name(die, unit, dwarf)?));
                 }
                 gimli::DW_TAG_reference_type => {
-                    return Ok(format!("{}&", get_base_type_name(die, unit, context)?));
+                    return Ok(format!("{}&", get_base_type_name(die, unit, dwarf)?));
                 }
                 gimli::DW_TAG_array_type => {
-                    return Ok(format!("{}[]", get_base_type_name(die, unit, context)?));
+                    return Ok(format!("{}[]", get_base_type_name(die, unit, dwarf)?));
                 }
                 _ => (),
             }
@@ -107,20 +99,17 @@ enum WebAssemblyPtrKind {
 ///
 /// Notice that "resolve_vmctx_memory_ptr" is external/builtin
 /// subprogram that is not part of Wasm code.
-fn replace_pointer_type<R>(
+fn replace_pointer_type(
     parent_id: write::UnitEntryId,
     kind: WebAssemblyPtrKind,
     comp_unit: &mut write::Unit,
     wp_die_id: write::UnitEntryId,
-    pointer_type_entry: &DebuggingInformationEntry<R>,
-    unit: &Unit<R, R::Offset>,
-    context: &DebugInputContext<R>,
+    pointer_type_entry: &DebuggingInformationEntry<Reader<'_>>,
+    unit: &Unit<Reader<'_>, usize>,
+    dwarf: &Dwarf<Reader<'_>>,
     out_strings: &mut write::StringTable,
     pending_die_refs: &mut PendingUnitRefs,
-) -> Result<write::UnitEntryId, Error>
-where
-    R: Reader,
-{
+) -> Result<write::UnitEntryId, Error> {
     const WASM_PTR_LEN: u8 = 4;
 
     macro_rules! add_tag {
@@ -138,11 +127,11 @@ where
     let name = match kind {
         WebAssemblyPtrKind::Pointer => format!(
             "WebAssemblyPtrWrapper<{}>",
-            get_base_type_name(pointer_type_entry, unit, context)?
+            get_base_type_name(pointer_type_entry, unit, dwarf)?
         ),
         WebAssemblyPtrKind::Reference => format!(
             "WebAssemblyRefWrapper<{}>",
-            get_base_type_name(pointer_type_entry, unit, context)?
+            get_base_type_name(pointer_type_entry, unit, dwarf)?
         ),
     };
     add_tag!(parent_id, gimli::DW_TAG_structure_type => wrapper_die as wrapper_die_id {
@@ -245,7 +234,7 @@ where
     Ok(wrapper_die_id)
 }
 
-fn is_dead_code<R: Reader>(entry: &DebuggingInformationEntry<R>) -> bool {
+fn is_dead_code(entry: &DebuggingInformationEntry<Reader<'_>>) -> bool {
     const TOMBSTONE: u64 = u32::MAX as u64;
 
     match entry.attr_value(gimli::DW_AT_low_pc) {
@@ -254,42 +243,42 @@ fn is_dead_code<R: Reader>(entry: &DebuggingInformationEntry<R>) -> bool {
     }
 }
 
-pub(crate) fn clone_unit<'a, R>(
-    dwarf: &gimli::Dwarf<R>,
-    unit: Unit<R, R::Offset>,
-    context: &DebugInputContext<R>,
-    addr_tr: &'a AddressTransform,
-    funcs: &'a CompiledFunctionsMetadata,
-    memory_offset: &ModuleMemoryOffset,
+pub(crate) fn clone_unit(
+    compilation: &mut Compilation<'_>,
+    module: StaticModuleIndex,
+    skeleton_unit: &Unit<Reader<'_>, usize>,
+    split_unit: Option<&Unit<Reader<'_>, usize>>,
+    split_dwarf: Option<&Dwarf<Reader<'_>>>,
+    context: &DebugInputContext,
+    addr_tr: &AddressTransform,
     out_encoding: gimli::Encoding,
     out_units: &mut write::UnitTable,
     out_strings: &mut write::StringTable,
-    translated: &mut HashSet<DefinedFuncIndex>,
+    translated: &mut HashSet<usize>,
     isa: &dyn TargetIsa,
-) -> Result<Option<(write::UnitId, UnitRefsMap, PendingDebugInfoRefs)>, Error>
-where
-    R: Reader,
-{
+) -> Result<Option<(write::UnitId, UnitRefsMap, PendingDebugInfoRefs)>, Error> {
     let mut die_ref_map = UnitRefsMap::new();
     let mut pending_die_refs = PendingUnitRefs::new();
     let mut pending_di_refs = PendingDebugInfoRefs::new();
     let mut stack = Vec::new();
 
+    let skeleton_dwarf = &compilation.translations[module].debuginfo.dwarf;
+    let memory_offset = &compilation.module_memory_offsets[module];
+
     // Iterate over all of this compilation unit's entries.
+    let dwarf = split_dwarf.unwrap_or(skeleton_dwarf);
+    let unit = split_unit.unwrap_or(skeleton_unit);
     let mut entries = unit.entries();
-    let (mut comp_unit, unit_id, file_map, file_index_base, cu_low_pc, wp_die_id, vmctx_die_id) =
+    let (mut comp_unit, unit_id, file_map, file_index_base, wp_die_id, vmctx_die_id) =
         if let Some((depth_delta, entry)) = entries.next_dfs()? {
             assert_eq!(depth_delta, 0);
             let (out_line_program, debug_line_offset, file_map, file_index_base) =
                 clone_line_program(
-                    &unit,
-                    entry,
+                    skeleton_dwarf,
+                    skeleton_unit,
+                    unit.name,
                     addr_tr,
                     out_encoding,
-                    context.debug_str,
-                    context.debug_str_offsets,
-                    context.debug_line_str,
-                    context.debug_line,
                     out_strings,
                 )?;
 
@@ -300,37 +289,42 @@ where
                 let root_id = comp_unit.root();
                 die_ref_map.insert(entry.offset(), root_id);
 
-                let cu_low_pc = if let Some(AttributeValue::Addr(addr)) =
-                    entry.attr_value(gimli::DW_AT_low_pc)?
-                {
-                    addr
-                } else if let Some(AttributeValue::DebugAddrIndex(i)) =
-                    entry.attr_value(gimli::DW_AT_low_pc)?
-                {
-                    context.debug_addr.get_address(4, unit.addr_base, i)?
-                } else {
-                    // FIXME? return Err(TransformError("No low_pc for unit header").into());
-                    0
-                };
-
                 clone_die_attributes(
                     dwarf,
                     &unit,
                     entry,
-                    context,
                     addr_tr,
                     None,
                     comp_unit,
                     root_id,
                     None,
                     None,
-                    cu_low_pc,
                     out_strings,
                     &mut pending_die_refs,
                     &mut pending_di_refs,
                     FileAttributeContext::Root(Some(debug_line_offset)),
                     isa,
                 )?;
+                if split_unit.is_some() {
+                    if let Some((_, skeleton_entry)) = skeleton_unit.entries().next_dfs()? {
+                        clone_die_attributes(
+                            skeleton_dwarf,
+                            skeleton_unit,
+                            skeleton_entry,
+                            addr_tr,
+                            None,
+                            comp_unit,
+                            root_id,
+                            None,
+                            None,
+                            out_strings,
+                            &mut pending_die_refs,
+                            &mut pending_di_refs,
+                            FileAttributeContext::Root(Some(debug_line_offset)),
+                            isa,
+                        )?;
+                    }
+                }
 
                 let (wp_die_id, vmctx_die_id) =
                     add_internal_types(comp_unit, root_id, out_strings, memory_offset);
@@ -341,12 +335,13 @@ where
                     unit_id,
                     file_map,
                     file_index_base,
-                    cu_low_pc,
                     wp_die_id,
                     vmctx_die_id,
                 )
             } else {
-                return Err(TransformError("Unexpected unit header").into());
+                // Can happen when the DWARF is split and we dont have the package/dwo files.
+                // This is a better user experience than errorring.
+                return Ok(None); // empty:
             }
         } else {
             return Ok(None); // empty
@@ -359,7 +354,7 @@ where
         // If `skip_at_depth` is `Some` then we previously decided to skip over
         // a node and all it's children. Let A be the last node processed, B be
         // the first node skipped, C be previous node, and D the current node.
-        // Then `cached` is the difference from A to B, `depth` is the diffence
+        // Then `cached` is the difference from A to B, `depth` is the difference
         // from B to C, and `depth_delta` is the differenc from C to D.
         let depth_delta = if let Some((depth, cached)) = skip_at_depth {
             // `new_depth` = B to D
@@ -393,15 +388,13 @@ where
         current_scope_ranges.update(new_stack_len);
         current_value_range.update(new_stack_len);
         let range_builder = if entry.tag() == gimli::DW_TAG_subprogram {
-            let range_builder = RangeInfoBuilder::from_subprogram_die(
-                dwarf, &unit, entry, context, addr_tr, cu_low_pc,
-            )?;
-            if let RangeInfoBuilder::Function(func_index) = range_builder {
-                if let Some(frame_info) = get_function_frame_info(memory_offset, funcs, func_index)
-                {
-                    current_value_range.push(new_stack_len, frame_info);
-                }
-                translated.insert(func_index);
+            let range_builder =
+                RangeInfoBuilder::from_subprogram_die(dwarf, &unit, entry, addr_tr)?;
+            if let RangeInfoBuilder::Function(func) = range_builder {
+                let frame_info = compilation.function_frame_info(module, func);
+                current_value_range.push(new_stack_len, frame_info);
+                let (symbol, _) = compilation.function(module, func);
+                translated.insert(symbol);
                 current_scope_ranges.push(new_stack_len, range_builder.get_ranges(addr_tr));
                 Some(range_builder)
             } else {
@@ -412,8 +405,7 @@ where
             let high_pc = entry.attr_value(gimli::DW_AT_high_pc)?;
             let ranges = entry.attr_value(gimli::DW_AT_ranges)?;
             if high_pc.is_some() || ranges.is_some() {
-                let range_builder =
-                    RangeInfoBuilder::from(dwarf, &unit, entry, context, cu_low_pc)?;
+                let range_builder = RangeInfoBuilder::from(dwarf, &unit, entry)?;
                 current_scope_ranges.push(new_stack_len, range_builder.get_ranges(addr_tr));
                 Some(range_builder)
             } else {
@@ -451,8 +443,8 @@ where
                 comp_unit,
                 wp_die_id,
                 entry,
-                &unit,
-                context,
+                unit,
+                dwarf,
                 out_strings,
                 &mut pending_die_refs,
             )?;
@@ -472,14 +464,12 @@ where
             dwarf,
             &unit,
             entry,
-            context,
             addr_tr,
             current_value_range.top(),
             &mut comp_unit,
             die_id,
             range_builder,
             current_scope_ranges.top(),
-            cu_low_pc,
             out_strings,
             &mut pending_die_refs,
             &mut pending_di_refs,
diff --git a/crates/cranelift/src/debug/transform/utils.rs b/crates/cranelift/src/debug/transform/utils.rs
index 0ffd19062490..1ddbfe7d7af5 100644
--- a/crates/cranelift/src/debug/transform/utils.rs
+++ b/crates/cranelift/src/debug/transform/utils.rs
@@ -1,12 +1,11 @@
 use super::address_transform::AddressTransform;
 use super::expression::{CompiledExpression, FunctionFrameInfo};
 use crate::debug::ModuleMemoryOffset;
-use crate::CompiledFunctionsMetadata;
 use anyhow::Error;
 use cranelift_codegen::isa::TargetIsa;
 use gimli::write;
-use wasmtime_environ::DefinedFuncIndex;
 use wasmtime_versioned_export_macros::versioned_stringify_ident;
+
 ///Adds internal Wasm utility types DIEs such as WebAssemblyPtr and
 /// WasmtimeVMContext.
 ///
@@ -60,7 +59,7 @@ pub(crate) fn add_internal_types(
         gimli::DW_AT_type = write::AttributeValue::UnitRef(memory_byte_die_id)
     });
 
-    // Create artificial VMContext type and its reference for convinience viewing
+    // Create artificial VMContext type and its reference for convenience viewing
     // its fields (such as memory ref) in a debugger. Build DW_TAG_structure_type:
     //   .. DW_AT_name = "WasmtimeVMContext"
     let vmctx_die_id = comp_unit.add(root_id, gimli::DW_TAG_structure_type);
@@ -92,8 +91,8 @@ pub(crate) fn add_internal_types(
                 gimli::DW_AT_data_member_location = write::AttributeValue::Udata(memory_offset as u64)
             });
         }
-        ModuleMemoryOffset::Imported(_) => {
-            // TODO implement convinience pointer to and additional types for VMMemoryImport.
+        ModuleMemoryOffset::Imported { .. } => {
+            // TODO implement convenience pointer to and additional types for VMMemoryImport.
         }
         ModuleMemoryOffset::None => (),
     }
@@ -164,24 +163,3 @@ pub(crate) fn append_vmctx_info(
 
     Ok(())
 }
-
-pub(crate) fn get_function_frame_info<'a, 'b, 'c>(
-    memory_offset: &ModuleMemoryOffset,
-    funcs: &'b CompiledFunctionsMetadata,
-    func_index: DefinedFuncIndex,
-) -> Option<FunctionFrameInfo<'a>>
-where
-    'b: 'a,
-    'c: 'a,
-{
-    if let Some(func) = funcs.get(func_index) {
-        let frame_info = FunctionFrameInfo {
-            value_ranges: &func.value_labels_ranges,
-            memory_offset: memory_offset.clone(),
-            sized_stack_slots: &func.sized_stack_slots,
-        };
-        Some(frame_info)
-    } else {
-        None
-    }
-}
diff --git a/crates/cranelift/src/debug/write_debuginfo.rs b/crates/cranelift/src/debug/write_debuginfo.rs
index e5e6269f8e8d..66b2b1dcc07a 100644
--- a/crates/cranelift/src/debug/write_debuginfo.rs
+++ b/crates/cranelift/src/debug/write_debuginfo.rs
@@ -1,15 +1,12 @@
 pub use crate::debug::transform::transform_dwarf;
-use crate::debug::ModuleMemoryOffset;
-use crate::CompiledFunctionsMetadata;
+use crate::debug::Compilation;
 use cranelift_codegen::ir::Endianness;
 use cranelift_codegen::isa::{
     unwind::{CfaUnwindInfo, UnwindInfo},
     TargetIsa,
 };
-use cranelift_entity::EntityRef;
 use gimli::write::{Address, Dwarf, EndianVec, FrameTable, Result, Sections, Writer};
 use gimli::{RunTimeEndian, SectionId};
-use wasmtime_environ::DebugInfoData;
 
 #[allow(missing_docs)]
 pub struct DwarfSection {
@@ -140,15 +137,15 @@ impl Writer for WriterRelocate {
     }
 }
 
-fn create_frame_table<'a>(
+fn create_frame_table(
     isa: &dyn TargetIsa,
-    funcs: &CompiledFunctionsMetadata,
+    compilation: &mut Compilation<'_>,
 ) -> Option<FrameTable> {
     let mut table = FrameTable::default();
 
     let cie_id = table.add_cie(isa.create_systemv_cie()?);
 
-    for (i, metadata) in funcs {
+    for (_, symbol, metadata) in compilation.functions() {
         // The CFA-based unwind info will either be natively present, or we
         // have generated it and placed into the "cfa_unwind_info" auxiliary
         // field. We shouldn't emit both, though, it'd be wasteful.
@@ -161,27 +158,19 @@ fn create_frame_table<'a>(
         }
 
         if let Some(info) = unwind_info {
-            table.add_fde(
-                cie_id,
-                info.to_fde(Address::Symbol {
-                    symbol: i.index(),
-                    addend: 0,
-                }),
-            );
+            table.add_fde(cie_id, info.to_fde(Address::Symbol { symbol, addend: 0 }));
         }
     }
 
     Some(table)
 }
 
-pub fn emit_dwarf<'a>(
+pub fn emit_dwarf(
     isa: &dyn TargetIsa,
-    debuginfo_data: &DebugInfoData,
-    funcs: &CompiledFunctionsMetadata,
-    memory_offset: &ModuleMemoryOffset,
+    compilation: &mut Compilation<'_>,
 ) -> anyhow::Result<Vec<DwarfSection>> {
-    let dwarf = transform_dwarf(isa, debuginfo_data, funcs, memory_offset)?;
-    let frame_table = create_frame_table(isa, funcs);
+    let dwarf = transform_dwarf(isa, compilation)?;
+    let frame_table = create_frame_table(isa, compilation);
     let sections = emit_dwarf_sections(isa, dwarf, frame_table)?;
     Ok(sections)
 }
diff --git a/crates/cranelift/src/func_environ.rs b/crates/cranelift/src/func_environ.rs
index 39df50fb0b0c..12ec5698aa0d 100644
--- a/crates/cranelift/src/func_environ.rs
+++ b/crates/cranelift/src/func_environ.rs
@@ -1,128 +1,111 @@
-use cfg_if::cfg_if;
+use crate::{gc, BuiltinFunctionSignatures};
 use cranelift_codegen::cursor::FuncCursor;
-use cranelift_codegen::ir;
-use cranelift_codegen::ir::condcodes::*;
-use cranelift_codegen::ir::immediates::{Imm64, Offset32, Uimm64};
+use cranelift_codegen::ir::condcodes::IntCC;
+use cranelift_codegen::ir::immediates::{Imm64, Offset32};
+use cranelift_codegen::ir::pcc::Fact;
 use cranelift_codegen::ir::types::*;
-use cranelift_codegen::ir::{
-    AbiParam, ArgumentPurpose, Function, InstBuilder, Signature, UserFuncName, Value,
-};
-use cranelift_codegen::isa::{self, CallConv, TargetFrontendConfig, TargetIsa};
-use cranelift_entity::{EntityRef, PrimaryMap};
+use cranelift_codegen::ir::{self, types};
+use cranelift_codegen::ir::{ArgumentPurpose, Function, InstBuilder, MemFlags};
+use cranelift_codegen::isa::{TargetFrontendConfig, TargetIsa};
+use cranelift_entity::packed_option::ReservedValue;
+use cranelift_entity::{EntityRef, PrimaryMap, SecondaryMap};
 use cranelift_frontend::FunctionBuilder;
 use cranelift_frontend::Variable;
 use cranelift_wasm::{
-    self, FuncIndex, FuncTranslationState, GlobalIndex, GlobalVariable, Heap, HeapData, HeapStyle,
-    MemoryIndex, TableIndex, TargetEnvironment, TypeIndex, WasmHeapType, WasmRefType, WasmResult,
-    WasmType,
+    EngineOrModuleTypeIndex, FuncEnvironment as _, FuncIndex, FuncTranslationState, GlobalIndex,
+    GlobalVariable, Heap, HeapData, HeapStyle, MemoryIndex, TableData, TableIndex, TableSize,
+    TargetEnvironment, TypeIndex, WasmFuncType, WasmHeapTopType, WasmHeapType, WasmResult,
 };
-use std::convert::TryFrom;
+use smallvec::SmallVec;
 use std::mem;
 use wasmparser::Operator;
 use wasmtime_environ::{
-    BuiltinFunctionIndex, MemoryPlan, MemoryStyle, Module, ModuleTranslation, ModuleTypes, PtrSize,
-    TableStyle, Tunables, TypeConvert, VMOffsets, WASM_PAGE_SIZE,
+    BuiltinFunctionIndex, MemoryPlan, MemoryStyle, Module, ModuleTranslation, ModuleTypesBuilder,
+    PtrSize, TableStyle, Tunables, TypeConvert, VMOffsets,
 };
 use wasmtime_environ::{FUNCREF_INIT_BIT, FUNCREF_MASK};
 
-macro_rules! declare_function_signatures {
-    (
-        $(
-            $( #[$attr:meta] )*
-            $name:ident( $( $pname:ident: $param:ident ),* ) $( -> $result:ident )?;
-        )*
-    ) => {
-        /// A struct with an `Option<ir::SigRef>` member for every builtin
-        /// function, to de-duplicate constructing/getting its signature.
-        struct BuiltinFunctionSignatures {
-            pointer_type: ir::Type,
-            reference_type: ir::Type,
-            call_conv: isa::CallConv,
-            $(
-                $name: Option<ir::SigRef>,
-            )*
-        }
-
-        impl BuiltinFunctionSignatures {
-            fn new(
-                pointer_type: ir::Type,
-                reference_type: ir::Type,
-                call_conv: isa::CallConv,
-            ) -> Self {
-                Self {
-                    pointer_type,
-                    reference_type,
-                    call_conv,
-                    $(
-                        $name: None,
-                    )*
-                }
-            }
-
-            fn vmctx(&self) -> AbiParam {
-                AbiParam::special(self.pointer_type, ArgumentPurpose::VMContext)
-            }
+/// A struct with an `Option<ir::FuncRef>` member for every builtin
+/// function, to de-duplicate constructing/getting its function.
+pub(crate) struct BuiltinFunctions {
+    types: BuiltinFunctionSignatures,
 
-            fn reference(&self) -> AbiParam {
-                AbiParam::new(self.reference_type)
-            }
+    builtins:
+        [Option<ir::FuncRef>; BuiltinFunctionIndex::builtin_functions_total_number() as usize],
+}
 
-            fn pointer(&self) -> AbiParam {
-                AbiParam::new(self.pointer_type)
-            }
+impl BuiltinFunctions {
+    fn new(isa: &dyn TargetIsa) -> Self {
+        Self {
+            types: BuiltinFunctionSignatures::new(isa),
+            builtins: [None; BuiltinFunctionIndex::builtin_functions_total_number() as usize],
+        }
+    }
 
-            fn i32(&self) -> AbiParam {
-                // Some platform ABIs require i32 values to be zero- or sign-
-                // extended to the full register width.  We need to indicate
-                // this here by using the appropriate .uext or .sext attribute.
-                // The attribute can be added unconditionally; platforms whose
-                // ABI does not require such extensions will simply ignore it.
-                // Note that currently all i32 arguments or return values used
-                // by builtin functions are unsigned, so we always use .uext.
-                // If that ever changes, we will have to add a second type
-                // marker here.
-                AbiParam::new(I32).uext()
-            }
+    fn load_builtin(&mut self, func: &mut Function, index: BuiltinFunctionIndex) -> ir::FuncRef {
+        let cache = &mut self.builtins[index.index() as usize];
+        if let Some(f) = cache {
+            return *f;
+        }
+        let signature = func.import_signature(self.types.signature(index));
+        let name =
+            ir::ExternalName::User(func.declare_imported_user_function(ir::UserExternalName {
+                namespace: crate::NS_WASMTIME_BUILTIN,
+                index: index.index(),
+            }));
+        let f = func.import_function(ir::ExtFuncData {
+            name,
+            signature,
+            colocated: true,
+        });
+        *cache = Some(f);
+        f
+    }
+}
 
-            fn i64(&self) -> AbiParam {
-                AbiParam::new(I64)
+// Generate helper methods on `BuiltinFunctions` above for each named builtin
+// as well.
+macro_rules! declare_function_signatures {
+    ($(
+        $( #[$attr:meta] )*
+        $name:ident( $( $pname:ident: $param:ident ),* ) $( -> $result:ident )?;
+    )*) => {
+        $(impl BuiltinFunctions {
+            $( #[$attr] )*
+            pub(crate) fn $name(&mut self, func: &mut Function) -> ir::FuncRef {
+                self.load_builtin(func, BuiltinFunctionIndex::$name())
             }
-
-            $(
-                fn $name(&mut self, func: &mut Function) -> ir::SigRef {
-                    let sig = self.$name.unwrap_or_else(|| {
-                        func.import_signature(Signature {
-                            params: vec![ $( self.$param() ),* ],
-                            returns: vec![ $( self.$result() )? ],
-                            call_conv: self.call_conv,
-                        })
-                    });
-                    self.$name = Some(sig);
-                    sig
-                }
-            )*
-        }
+        })*
     };
 }
-
 wasmtime_environ::foreach_builtin_function!(declare_function_signatures);
 
 /// The `FuncEnvironment` implementation for use by the `ModuleEnvironment`.
 pub struct FuncEnvironment<'module_environment> {
     isa: &'module_environment (dyn TargetIsa + 'module_environment),
     module: &'module_environment Module,
-    types: &'module_environment ModuleTypes,
+    types: &'module_environment ModuleTypesBuilder,
+    wasm_func_ty: &'module_environment WasmFuncType,
+    sig_ref_to_ty: SecondaryMap<ir::SigRef, Option<&'module_environment WasmFuncType>>,
 
+    #[cfg(feature = "wmemcheck")]
     translation: &'module_environment ModuleTranslation<'module_environment>,
 
     /// Heaps implementing WebAssembly linear memories.
     heaps: PrimaryMap<Heap, HeapData>,
 
+    /// Cranelift tables we have created to implement Wasm tables.
+    tables: SecondaryMap<TableIndex, Option<TableData>>,
+
     /// The Cranelift global holding the vmctx address.
     vmctx: Option<ir::GlobalValue>,
 
+    /// The PCC memory type describing the vmctx layout, if we're
+    /// using PCC.
+    pcc_vmctx_memtype: Option<ir::MemoryType>,
+
     /// Caches of signatures for builtin functions.
-    builtin_function_signatures: BuiltinFunctionSignatures,
+    pub(crate) builtin_functions: BuiltinFunctions,
 
     /// Offsets to struct fields accessed by JIT code.
     pub(crate) offsets: VMOffsets<u8>,
@@ -139,7 +122,7 @@ pub struct FuncEnvironment<'module_environment> {
     /// VMRuntimeLimits` for this function's vmctx argument. This pointer is stored
     /// in the vmctx itself, but never changes for the lifetime of the function,
     /// so if we load it up front we can continue to use it throughout.
-    vmruntime_limits_ptr: cranelift_frontend::Variable,
+    vmruntime_limits_ptr: ir::Value,
 
     /// A cached epoch deadline value, when performing epoch-based
     /// interruption. Loaded from `VMRuntimeLimits` and reloaded after
@@ -164,19 +147,12 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
     pub fn new(
         isa: &'module_environment (dyn TargetIsa + 'module_environment),
         translation: &'module_environment ModuleTranslation<'module_environment>,
-        types: &'module_environment ModuleTypes,
+        types: &'module_environment ModuleTypesBuilder,
         tunables: &'module_environment Tunables,
         wmemcheck: bool,
+        wasm_func_ty: &'module_environment WasmFuncType,
     ) -> Self {
-        let builtin_function_signatures = BuiltinFunctionSignatures::new(
-            isa.pointer_type(),
-            match isa.pointer_type() {
-                ir::types::I32 => ir::types::R32,
-                ir::types::I64 => ir::types::R64,
-                _ => panic!(),
-            },
-            CallConv::triple_default(isa.triple()),
-        );
+        let builtin_functions = BuiltinFunctions::new(isa);
 
         // Avoid unused warning in default build.
         #[cfg(not(feature = "wmemcheck"))]
@@ -186,156 +162,102 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
             isa,
             module: &translation.module,
             types,
+            wasm_func_ty,
+            sig_ref_to_ty: SecondaryMap::default(),
+
             heaps: PrimaryMap::default(),
+            tables: SecondaryMap::default(),
             vmctx: None,
-            builtin_function_signatures,
+            pcc_vmctx_memtype: None,
+            builtin_functions,
             offsets: VMOffsets::new(isa.pointer_bytes(), &translation.module),
             tunables,
             fuel_var: Variable::new(0),
             epoch_deadline_var: Variable::new(0),
             epoch_ptr_var: Variable::new(0),
-            vmruntime_limits_ptr: Variable::new(0),
-            translation: translation,
+            vmruntime_limits_ptr: ir::Value::reserved_value(),
 
             // Start with at least one fuel being consumed because even empty
             // functions should consume at least some fuel.
             fuel_consumed: 1,
+
             #[cfg(feature = "wmemcheck")]
             wmemcheck,
+            #[cfg(feature = "wmemcheck")]
+            translation,
         }
     }
 
-    fn pointer_type(&self) -> ir::Type {
+    pub(crate) fn pointer_type(&self) -> ir::Type {
         self.isa.pointer_type()
     }
 
-    fn vmctx(&mut self, func: &mut Function) -> ir::GlobalValue {
+    pub(crate) fn vmctx(&mut self, func: &mut Function) -> ir::GlobalValue {
         self.vmctx.unwrap_or_else(|| {
             let vmctx = func.create_global_value(ir::GlobalValueData::VMContext);
+            if self.isa.flags().enable_pcc() {
+                // Create a placeholder memtype for the vmctx; we'll
+                // add fields to it as we lazily create HeapData
+                // structs and global values.
+                let vmctx_memtype = func.create_memory_type(ir::MemoryTypeData::Struct {
+                    size: 0,
+                    fields: vec![],
+                });
+
+                self.pcc_vmctx_memtype = Some(vmctx_memtype);
+                func.global_value_facts[vmctx] = Some(Fact::Mem {
+                    ty: vmctx_memtype,
+                    min_offset: 0,
+                    max_offset: 0,
+                    nullable: false,
+                });
+            }
+
             self.vmctx = Some(vmctx);
             vmctx
         })
     }
 
+    pub(crate) fn vmctx_val(&mut self, pos: &mut FuncCursor<'_>) -> ir::Value {
+        let pointer_type = self.pointer_type();
+        let vmctx = self.vmctx(&mut pos.func);
+        pos.ins().global_value(pointer_type, vmctx)
+    }
+
     fn get_table_copy_func(
         &mut self,
         func: &mut Function,
         dst_table_index: TableIndex,
         src_table_index: TableIndex,
-    ) -> (ir::SigRef, usize, usize, BuiltinFunctionIndex) {
-        let sig = self.builtin_function_signatures.table_copy(func);
+    ) -> (ir::FuncRef, usize, usize) {
+        let sig = self.builtin_functions.table_copy(func);
         (
             sig,
             dst_table_index.as_u32() as usize,
             src_table_index.as_u32() as usize,
-            BuiltinFunctionIndex::table_copy(),
         )
     }
 
-    fn get_table_init_func(
-        &mut self,
-        func: &mut Function,
-        table_index: TableIndex,
-    ) -> (ir::SigRef, usize, BuiltinFunctionIndex) {
-        let sig = self.builtin_function_signatures.table_init(func);
-        let table_index = table_index.as_u32() as usize;
-        (sig, table_index, BuiltinFunctionIndex::table_init())
-    }
-
-    fn get_elem_drop_func(&mut self, func: &mut Function) -> (ir::SigRef, BuiltinFunctionIndex) {
-        let sig = self.builtin_function_signatures.elem_drop(func);
-        (sig, BuiltinFunctionIndex::elem_drop())
-    }
-
+    #[cfg(feature = "threads")]
     fn get_memory_atomic_wait(
         &mut self,
         func: &mut Function,
         memory_index: MemoryIndex,
         ty: ir::Type,
-    ) -> (ir::SigRef, usize, BuiltinFunctionIndex) {
+    ) -> (ir::FuncRef, usize) {
         match ty {
             I32 => (
-                self.builtin_function_signatures.memory_atomic_wait32(func),
+                self.builtin_functions.memory_atomic_wait32(func),
                 memory_index.index(),
-                BuiltinFunctionIndex::memory_atomic_wait32(),
             ),
             I64 => (
-                self.builtin_function_signatures.memory_atomic_wait64(func),
+                self.builtin_functions.memory_atomic_wait64(func),
                 memory_index.index(),
-                BuiltinFunctionIndex::memory_atomic_wait64(),
             ),
-            x => panic!("get_memory_atomic_wait unsupported type: {:?}", x),
+            x => panic!("get_memory_atomic_wait unsupported type: {x:?}"),
         }
     }
 
-    fn get_memory_init_func(&mut self, func: &mut Function) -> (ir::SigRef, BuiltinFunctionIndex) {
-        (
-            self.builtin_function_signatures.memory_init(func),
-            BuiltinFunctionIndex::memory_init(),
-        )
-    }
-
-    fn get_data_drop_func(&mut self, func: &mut Function) -> (ir::SigRef, BuiltinFunctionIndex) {
-        (
-            self.builtin_function_signatures.data_drop(func),
-            BuiltinFunctionIndex::data_drop(),
-        )
-    }
-
-    /// Translates load of builtin function and returns a pair of values `vmctx`
-    /// and address of the loaded function.
-    fn translate_load_builtin_function_address(
-        &mut self,
-        pos: &mut FuncCursor<'_>,
-        callee_func_idx: BuiltinFunctionIndex,
-    ) -> (ir::Value, ir::Value) {
-        // We use an indirect call so that we don't have to patch the code at runtime.
-        let pointer_type = self.pointer_type();
-        let vmctx = self.vmctx(&mut pos.func);
-        let base = pos.ins().global_value(pointer_type, vmctx);
-
-        let mem_flags = ir::MemFlags::trusted().with_readonly();
-
-        // Load the base of the array of builtin functions
-        let array_offset = i32::try_from(self.offsets.vmctx_builtin_functions()).unwrap();
-        let array_addr = pos.ins().load(pointer_type, mem_flags, base, array_offset);
-
-        // Load the callee address.
-        let body_offset = i32::try_from(callee_func_idx.index() * pointer_type.bytes()).unwrap();
-        let func_addr = pos
-            .ins()
-            .load(pointer_type, mem_flags, array_addr, body_offset);
-
-        (base, func_addr)
-    }
-
-    /// Generate code to increment or decrement the given `externref`'s
-    /// reference count.
-    ///
-    /// The new reference count is returned.
-    fn mutate_externref_ref_count(
-        &mut self,
-        builder: &mut FunctionBuilder,
-        externref: ir::Value,
-        delta: i64,
-    ) -> ir::Value {
-        debug_assert!(delta == -1 || delta == 1);
-
-        let pointer_type = self.pointer_type();
-
-        // If this changes that's ok, the `atomic_rmw` below just needs to be
-        // preceded with an add instruction of `externref` and the offset.
-        assert_eq!(self.offsets.vm_extern_data_ref_count(), 0);
-        let delta = builder.ins().iconst(pointer_type, delta);
-        builder.ins().atomic_rmw(
-            pointer_type,
-            ir::MemFlags::trusted(),
-            ir::AtomicRmwOp::Add,
-            externref,
-            delta,
-        )
-    }
-
     fn get_global_location(
         &mut self,
         func: &mut ir::Function,
@@ -352,7 +274,7 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
                 base: vmctx,
                 offset: Offset32::new(i32::try_from(from_offset).unwrap()),
                 global_type: pointer_type,
-                readonly: true,
+                flags: MemFlags::trusted().with_readonly(),
             });
             (global, 0)
         }
@@ -364,14 +286,14 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
         // function. This is possible since we know that the pointer never
         // changes for the lifetime of the function.
         let pointer_type = self.pointer_type();
-        builder.declare_var(self.vmruntime_limits_ptr, pointer_type);
         let vmctx = self.vmctx(builder.func);
         let base = builder.ins().global_value(pointer_type, vmctx);
-        let offset = i32::try_from(self.offsets.vmctx_runtime_limits()).unwrap();
-        let interrupt_ptr = builder
-            .ins()
-            .load(pointer_type, ir::MemFlags::trusted(), base, offset);
-        builder.def_var(self.vmruntime_limits_ptr, interrupt_ptr);
+        let offset = i32::from(self.offsets.ptr.vmctx_runtime_limits());
+        debug_assert!(self.vmruntime_limits_ptr.is_reserved_value());
+        self.vmruntime_limits_ptr =
+            builder
+                .ins()
+                .load(pointer_type, ir::MemFlags::trusted(), base, offset);
     }
 
     fn fuel_function_entry(&mut self, builder: &mut FunctionBuilder<'_>) {
@@ -518,7 +440,7 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
 
     /// Loads the fuel consumption value from `VMRuntimeLimits` into `self.fuel_var`
     fn fuel_load_into_var(&mut self, builder: &mut FunctionBuilder<'_>) {
-        let (addr, offset) = self.fuel_addr_offset(builder);
+        let (addr, offset) = self.fuel_addr_offset();
         let fuel = builder
             .ins()
             .load(ir::types::I64, ir::MemFlags::trusted(), addr, offset);
@@ -528,7 +450,7 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
     /// Stores the fuel consumption value from `self.fuel_var` into
     /// `VMRuntimeLimits`.
     fn fuel_save_from_var(&mut self, builder: &mut FunctionBuilder<'_>) {
-        let (addr, offset) = self.fuel_addr_offset(builder);
+        let (addr, offset) = self.fuel_addr_offset();
         let fuel_consumed = builder.use_var(self.fuel_var);
         builder
             .ins()
@@ -537,12 +459,10 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
 
     /// Returns the `(address, offset)` of the fuel consumption within
     /// `VMRuntimeLimits`, used to perform loads/stores later.
-    fn fuel_addr_offset(
-        &mut self,
-        builder: &mut FunctionBuilder<'_>,
-    ) -> (ir::Value, ir::immediates::Offset32) {
+    fn fuel_addr_offset(&mut self) -> (ir::Value, ir::immediates::Offset32) {
+        debug_assert!(!self.vmruntime_limits_ptr.is_reserved_value());
         (
-            builder.use_var(self.vmruntime_limits_ptr),
+            self.vmruntime_limits_ptr,
             i32::from(self.offsets.ptr.vmruntime_limits_fuel_consumed()).into(),
         )
     }
@@ -579,14 +499,9 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
         // intrinsic may alter how much fuel is in the system.
         builder.switch_to_block(out_of_gas_block);
         self.fuel_save_from_var(builder);
-        let out_of_gas_sig = self.builtin_function_signatures.out_of_gas(builder.func);
-        let (vmctx, out_of_gas) = self.translate_load_builtin_function_address(
-            &mut builder.cursor(),
-            BuiltinFunctionIndex::out_of_gas(),
-        );
-        builder
-            .ins()
-            .call_indirect(out_of_gas_sig, out_of_gas, &[vmctx]);
+        let out_of_gas = self.builtin_functions.out_of_gas(builder.func);
+        let vmctx = self.vmctx_val(&mut builder.cursor());
+        builder.ins().call(out_of_gas, &[vmctx]);
         self.fuel_load_into_var(builder);
         builder.ins().jump(continuation_block, &[]);
         builder.seal_block(continuation_block);
@@ -596,7 +511,8 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
 
     fn epoch_function_entry(&mut self, builder: &mut FunctionBuilder<'_>) {
         builder.declare_var(self.epoch_deadline_var, ir::types::I64);
-        self.epoch_load_deadline_into_var(builder);
+        // Let epoch_check_full load the current deadline and call def_var
+
         builder.declare_var(self.epoch_ptr_var, self.pointer_type());
         let epoch_ptr = self.epoch_ptr(builder);
         builder.def_var(self.epoch_ptr_var, epoch_ptr);
@@ -618,16 +534,15 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
         // sufficient. Then, combined with checks at every backedge
         // (loop) the longest runtime between checks is bounded by the
         // straightline length of any function body.
-        self.epoch_check(builder);
+        let continuation_block = builder.create_block();
+        let cur_epoch_value = self.epoch_load_current(builder);
+        self.epoch_check_full(builder, cur_epoch_value, continuation_block);
     }
 
     #[cfg(feature = "wmemcheck")]
-    fn hook_malloc_exit(&mut self, builder: &mut FunctionBuilder, retvals: &[Value]) {
-        let check_malloc_sig = self.builtin_function_signatures.check_malloc(builder.func);
-        let (vmctx, check_malloc) = self.translate_load_builtin_function_address(
-            &mut builder.cursor(),
-            BuiltinFunctionIndex::check_malloc(),
-        );
+    fn hook_malloc_exit(&mut self, builder: &mut FunctionBuilder, retvals: &[ir::Value]) {
+        let check_malloc = self.builtin_functions.check_malloc(builder.func);
+        let vmctx = self.vmctx_val(&mut builder.cursor());
         let func_args = builder
             .func
             .dfg
@@ -644,18 +559,13 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
         } else {
             retvals[0]
         };
-        builder
-            .ins()
-            .call_indirect(check_malloc_sig, check_malloc, &[vmctx, retval, len]);
+        builder.ins().call(check_malloc, &[vmctx, retval, len]);
     }
 
     #[cfg(feature = "wmemcheck")]
     fn hook_free_exit(&mut self, builder: &mut FunctionBuilder) {
-        let check_free_sig = self.builtin_function_signatures.check_free(builder.func);
-        let (vmctx, check_free) = self.translate_load_builtin_function_address(
-            &mut builder.cursor(),
-            BuiltinFunctionIndex::check_free(),
-        );
+        let check_free = self.builtin_functions.check_free(builder.func);
+        let vmctx = self.vmctx_val(&mut builder.cursor());
         let func_args = builder
             .func
             .dfg
@@ -667,16 +577,14 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
             // first argument is a pointer to memory.
             func_args[2]
         };
-        builder
-            .ins()
-            .call_indirect(check_free_sig, check_free, &[vmctx, ptr]);
+        builder.ins().call(check_free, &[vmctx, ptr]);
     }
 
     fn epoch_ptr(&mut self, builder: &mut FunctionBuilder<'_>) -> ir::Value {
         let vmctx = self.vmctx(builder.func);
         let pointer_type = self.pointer_type();
         let base = builder.ins().global_value(pointer_type, vmctx);
-        let offset = i32::try_from(self.offsets.vmctx_epoch_ptr()).unwrap();
+        let offset = i32::try_from(self.offsets.ptr.vmctx_epoch_ptr()).unwrap();
         let epoch_ptr = builder
             .ins()
             .load(pointer_type, ir::MemFlags::trusted(), base, offset);
@@ -693,34 +601,30 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
         )
     }
 
-    fn epoch_load_deadline_into_var(&mut self, builder: &mut FunctionBuilder<'_>) {
-        let interrupts = builder.use_var(self.vmruntime_limits_ptr);
-        let deadline =
-            builder.ins().load(
-                ir::types::I64,
-                ir::MemFlags::trusted(),
-                interrupts,
-                ir::immediates::Offset32::new(
-                    self.offsets.ptr.vmruntime_limits_epoch_deadline() as i32
-                ),
-            );
-        builder.def_var(self.epoch_deadline_var, deadline);
+    fn epoch_check(&mut self, builder: &mut FunctionBuilder<'_>) {
+        let continuation_block = builder.create_block();
+
+        // Load new epoch and check against the cached deadline.
+        let cur_epoch_value = self.epoch_load_current(builder);
+        self.epoch_check_cached(builder, cur_epoch_value, continuation_block);
+
+        // At this point we've noticed that the epoch has exceeded our
+        // cached deadline. However the real deadline may have been
+        // updated (within another yield) during some function that we
+        // called in the meantime, so reload the cache and check again.
+        self.epoch_check_full(builder, cur_epoch_value, continuation_block);
     }
 
-    fn epoch_check(&mut self, builder: &mut FunctionBuilder<'_>) {
+    fn epoch_check_cached(
+        &mut self,
+        builder: &mut FunctionBuilder,
+        cur_epoch_value: ir::Value,
+        continuation_block: ir::Block,
+    ) {
         let new_epoch_block = builder.create_block();
-        let new_epoch_doublecheck_block = builder.create_block();
-        let continuation_block = builder.create_block();
         builder.set_cold_block(new_epoch_block);
-        builder.set_cold_block(new_epoch_doublecheck_block);
 
         let epoch_deadline = builder.use_var(self.epoch_deadline_var);
-        // Load new epoch and check against cached deadline. The
-        // deadline may be out of date if it was updated (within
-        // another yield) during some function that we called; this is
-        // fine, as we'll reload it and check again before yielding in
-        // the cold path.
-        let cur_epoch_value = self.epoch_load_current(builder);
         let cmp = builder.ins().icmp(
             IntCC::UnsignedGreaterThanOrEqual,
             cur_epoch_value,
@@ -731,41 +635,35 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
             .brif(cmp, new_epoch_block, &[], continuation_block, &[]);
         builder.seal_block(new_epoch_block);
 
-        // In the "new epoch block", we've noticed that the epoch has
-        // exceeded our cached deadline. However the real deadline may
-        // have been moved in the meantime. We keep the cached value
-        // in a register to speed the checks in the common case
-        // (between epoch ticks) but we want to do a precise check
-        // here, on the cold path, by reloading the latest value
-        // first.
         builder.switch_to_block(new_epoch_block);
-        self.epoch_load_deadline_into_var(builder);
-        let fresh_epoch_deadline = builder.use_var(self.epoch_deadline_var);
-        let fresh_cmp = builder.ins().icmp(
-            IntCC::UnsignedGreaterThanOrEqual,
-            cur_epoch_value,
-            fresh_epoch_deadline,
-        );
-        builder.ins().brif(
-            fresh_cmp,
-            new_epoch_doublecheck_block,
-            &[],
-            continuation_block,
-            &[],
-        );
-        builder.seal_block(new_epoch_doublecheck_block);
+    }
 
-        builder.switch_to_block(new_epoch_doublecheck_block);
-        let new_epoch_sig = self.builtin_function_signatures.new_epoch(builder.func);
-        let (vmctx, new_epoch) = self.translate_load_builtin_function_address(
-            &mut builder.cursor(),
-            BuiltinFunctionIndex::new_epoch(),
-        );
+    fn epoch_check_full(
+        &mut self,
+        builder: &mut FunctionBuilder,
+        cur_epoch_value: ir::Value,
+        continuation_block: ir::Block,
+    ) {
+        // We keep the deadline cached in a register to speed the checks
+        // in the common case (between epoch ticks) but we want to do a
+        // precise check here by reloading the cache first.
+        let deadline =
+            builder.ins().load(
+                ir::types::I64,
+                ir::MemFlags::trusted(),
+                self.vmruntime_limits_ptr,
+                ir::immediates::Offset32::new(
+                    self.offsets.ptr.vmruntime_limits_epoch_deadline() as i32
+                ),
+            );
+        builder.def_var(self.epoch_deadline_var, deadline);
+        self.epoch_check_cached(builder, cur_epoch_value, continuation_block);
+
+        let new_epoch = self.builtin_functions.new_epoch(builder.func);
+        let vmctx = self.vmctx_val(&mut builder.cursor());
         // new_epoch() returns the new deadline, so we don't have to
         // reload it.
-        let call = builder
-            .ins()
-            .call_indirect(new_epoch_sig, new_epoch, &[vmctx]);
+        let call = builder.ins().call(new_epoch, &[vmctx]);
         let new_deadline = *builder.func.dfg.inst_results(call).first().unwrap();
         builder.def_var(self.epoch_deadline_var, new_deadline);
         builder.ins().jump(continuation_block, &[]);
@@ -782,7 +680,13 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
         }
     }
 
-    fn cast_pointer_to_memory_index(
+    /// Convert the target pointer-sized integer `val` that is holding a memory
+    /// length (or the `-1` `memory.grow`-failed sentinel) into the memory's
+    /// index type.
+    ///
+    /// This might involve extending or truncating it depending on the memory's
+    /// index type and the target's pointer type.
+    fn convert_memory_length_to_index_type(
         &self,
         mut pos: FuncCursor<'_>,
         val: ir::Value,
@@ -800,18 +704,32 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
         } else if pointer_type.bits() > desired_type.bits() {
             pos.ins().ireduce(desired_type, val)
         } else {
-            // Note that we `sextend` instead of the probably expected
-            // `uextend`. This function is only used within the contexts of
-            // `memory.size` and `memory.grow` where we're working with units of
-            // pages instead of actual bytes, so we know that the upper bit is
-            // always cleared for "valid values". The one case we care about
-            // sextend would be when the return value of `memory.grow` is `-1`,
-            // in which case we want to copy the sign bit.
-            //
-            // This should only come up on 32-bit hosts running wasm64 modules,
-            // which at some point also makes you question various assumptions
-            // made along the way...
-            pos.ins().sextend(desired_type, val)
+            // We have a 64-bit memory on a 32-bit host -- this combo doesn't
+            // really make a whole lot of sense to do from a user perspective
+            // but that is neither here nor there. We want to logically do an
+            // unsigned extend *except* when we are given the `-1` sentinel,
+            // which we must preserve as `-1` in the wider type.
+            match self.module.memory_plans[index].memory.page_size_log2 {
+                16 => {
+                    // In the case that we have default page sizes, we can
+                    // always sign extend, since valid memory lengths (in pages)
+                    // never have their sign bit set, and so if the sign bit is
+                    // set then this must be the `-1` sentinel, which we want to
+                    // preserve through the extension.
+                    pos.ins().sextend(desired_type, val)
+                }
+                0 => {
+                    // For single-byte pages, we have to explicitly check for
+                    // `-1` and choose whether to do an unsigned extension or
+                    // return a larger `-1` because there are valid memory
+                    // lengths (in pages) that have the sign bit set.
+                    let extended = pos.ins().uextend(desired_type, val);
+                    let neg_one = pos.ins().iconst(desired_type, -1);
+                    let is_failure = pos.ins().icmp_imm(IntCC::Equal, val, -1);
+                    pos.ins().select(is_failure, neg_one, extended)
+                }
+                _ => unreachable!("only page sizes 2**0 and 2**16 are currently valid"),
+            }
         }
     }
 
@@ -828,31 +746,132 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
         }
     }
 
+    /// Set up the necessary preamble definitions in `func` to access the table identified
+    /// by `index`.
+    ///
+    /// The index space covers both imported and locally declared tables.
+    fn ensure_table_exists(&mut self, func: &mut ir::Function, index: TableIndex) {
+        if self.tables[index].is_some() {
+            return;
+        }
+
+        let pointer_type = self.pointer_type();
+
+        let (ptr, base_offset, current_elements_offset) = {
+            let vmctx = self.vmctx(func);
+            if let Some(def_index) = self.module.defined_table_index(index) {
+                let base_offset =
+                    i32::try_from(self.offsets.vmctx_vmtable_definition_base(def_index)).unwrap();
+                let current_elements_offset = i32::try_from(
+                    self.offsets
+                        .vmctx_vmtable_definition_current_elements(def_index),
+                )
+                .unwrap();
+                (vmctx, base_offset, current_elements_offset)
+            } else {
+                let from_offset = self.offsets.vmctx_vmtable_import_from(index);
+                let table = func.create_global_value(ir::GlobalValueData::Load {
+                    base: vmctx,
+                    offset: Offset32::new(i32::try_from(from_offset).unwrap()),
+                    global_type: pointer_type,
+                    flags: MemFlags::trusted().with_readonly(),
+                });
+                let base_offset = i32::from(self.offsets.vmtable_definition_base());
+                let current_elements_offset =
+                    i32::from(self.offsets.vmtable_definition_current_elements());
+                (table, base_offset, current_elements_offset)
+            }
+        };
+
+        let table = &self.module.table_plans[index].table;
+        let element_size = if table.wasm_ty.is_vmgcref_type() {
+            // For GC-managed references, tables store `Option<VMGcRef>`s.
+            ir::types::I32.bytes()
+        } else {
+            self.reference_type(table.wasm_ty.heap_type).0.bytes()
+        };
+
+        let base_gv = func.create_global_value(ir::GlobalValueData::Load {
+            base: ptr,
+            offset: Offset32::new(base_offset),
+            global_type: pointer_type,
+            flags: if Some(table.minimum) == table.maximum {
+                // A fixed-size table can't be resized so its base address won't
+                // change.
+                MemFlags::trusted().with_readonly()
+            } else {
+                MemFlags::trusted()
+            },
+        });
+
+        let bound = if Some(table.minimum) == table.maximum {
+            TableSize::Static {
+                bound: table.minimum,
+            }
+        } else {
+            TableSize::Dynamic {
+                bound_gv: func.create_global_value(ir::GlobalValueData::Load {
+                    base: ptr,
+                    offset: Offset32::new(current_elements_offset),
+                    global_type: ir::Type::int(
+                        u16::from(self.offsets.size_of_vmtable_definition_current_elements()) * 8,
+                    )
+                    .unwrap(),
+                    flags: MemFlags::trusted(),
+                }),
+            }
+        };
+
+        self.tables[index] = Some(TableData {
+            base_gv,
+            bound,
+            element_size,
+        });
+    }
+
     fn get_or_init_func_ref_table_elem(
         &mut self,
         builder: &mut FunctionBuilder,
         table_index: TableIndex,
-        table: ir::Table,
         index: ir::Value,
+        cold_blocks: bool,
+        lazy_init: bool,
     ) -> ir::Value {
         let pointer_type = self.pointer_type();
+        self.ensure_table_exists(builder.func, table_index);
+        let table_data = self.tables[table_index].as_ref().unwrap();
 
         // To support lazy initialization of table
         // contents, we check for a null entry here, and
         // if null, we take a slow-path that invokes a
         // libcall.
-        let table_entry_addr = builder.ins().table_addr(pointer_type, table, index, 0);
-        let flags = ir::MemFlags::trusted().with_table();
+        let (table_entry_addr, flags) = table_data.prepare_table_addr(
+            builder,
+            index,
+            pointer_type,
+            self.isa.flags().enable_table_access_spectre_mitigation(),
+        );
         let value = builder.ins().load(pointer_type, flags, table_entry_addr, 0);
+
+        if !lazy_init {
+            return value;
+        }
+
         // Mask off the "initialized bit". See documentation on
         // FUNCREF_INIT_BIT in crates/environ/src/ref_bits.rs for more
-        // details.
-        let value_masked = builder
-            .ins()
-            .band_imm(value, Imm64::from(FUNCREF_MASK as i64));
+        // details. Note that `FUNCREF_MASK` has type `usize` which may not be
+        // appropriate for the target architecture. Right now its value is
+        // always -2 so assert that part doesn't change and then thread through
+        // -2 as the immediate.
+        assert_eq!(FUNCREF_MASK as isize, -2);
+        let value_masked = builder.ins().band_imm(value, Imm64::from(-2));
 
         let null_block = builder.create_block();
         let continuation_block = builder.create_block();
+        if cold_blocks {
+            builder.set_cold_block(null_block);
+            builder.set_cold_block(continuation_block);
+        }
         let result_param = builder.append_block_param(continuation_block, pointer_type);
         builder.set_cold_block(null_block);
 
@@ -863,16 +882,11 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
 
         builder.switch_to_block(null_block);
         let table_index = builder.ins().iconst(I32, table_index.index() as i64);
-        let builtin_idx = BuiltinFunctionIndex::table_get_lazy_init_func_ref();
-        let builtin_sig = self
-            .builtin_function_signatures
+        let lazy_init = self
+            .builtin_functions
             .table_get_lazy_init_func_ref(builder.func);
-        let (vmctx, builtin_addr) =
-            self.translate_load_builtin_function_address(&mut builder.cursor(), builtin_idx);
-        let call_inst =
-            builder
-                .ins()
-                .call_indirect(builtin_sig, builtin_addr, &[vmctx, table_index, index]);
+        let vmctx = self.vmctx_val(&mut builder.cursor());
+        let call_inst = builder.ins().call(lazy_init, &[vmctx, table_index, index]);
         let returned_entry = builder.func.dfg.inst_results(call_inst)[0];
         builder.ins().jump(continuation_block, &[returned_entry]);
         builder.seal_block(continuation_block);
@@ -881,31 +895,24 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
         result_param
     }
 
+    #[cfg(feature = "wmemcheck")]
     fn check_malloc_start(&mut self, builder: &mut FunctionBuilder) {
-        let malloc_start_sig = self.builtin_function_signatures.malloc_start(builder.func);
-        let (vmctx, malloc_start) = self.translate_load_builtin_function_address(
-            &mut builder.cursor(),
-            BuiltinFunctionIndex::malloc_start(),
-        );
-        builder
-            .ins()
-            .call_indirect(malloc_start_sig, malloc_start, &[vmctx]);
+        let malloc_start = self.builtin_functions.malloc_start(builder.func);
+        let vmctx = self.vmctx_val(&mut builder.cursor());
+        builder.ins().call(malloc_start, &[vmctx]);
     }
 
+    #[cfg(feature = "wmemcheck")]
     fn check_free_start(&mut self, builder: &mut FunctionBuilder) {
-        let free_start_sig = self.builtin_function_signatures.free_start(builder.func);
-        let (vmctx, free_start) = self.translate_load_builtin_function_address(
-            &mut builder.cursor(),
-            BuiltinFunctionIndex::free_start(),
-        );
-        builder
-            .ins()
-            .call_indirect(free_start_sig, free_start, &[vmctx]);
+        let free_start = self.builtin_functions.free_start(builder.func);
+        let vmctx = self.vmctx_val(&mut builder.cursor());
+        builder.ins().call(free_start, &[vmctx]);
     }
 
+    #[cfg(feature = "wmemcheck")]
     fn current_func_name(&self, builder: &mut FunctionBuilder) -> Option<&str> {
         let func_index = match &builder.func.name {
-            UserFuncName::User(user) => FuncIndex::from_u32(user.index),
+            ir::UserFuncName::User(user) => FuncIndex::from_u32(user.index),
             _ => {
                 panic!("function name not a UserFuncName::User as expected")
             }
@@ -917,6 +924,87 @@ impl<'module_environment> FuncEnvironment<'module_environment> {
             .get(&func_index)
             .map(|s| *s)
     }
+
+    /// Proof-carrying code: create a memtype describing an empty
+    /// runtime struct (to be updated later).
+    fn create_empty_struct_memtype(&self, func: &mut ir::Function) -> ir::MemoryType {
+        func.create_memory_type(ir::MemoryTypeData::Struct {
+            size: 0,
+            fields: vec![],
+        })
+    }
+
+    /// Proof-carrying code: add a new field to a memtype used to
+    /// describe a runtime struct. A memory region of type `memtype`
+    /// will have a pointer at `offset` pointing to another memory
+    /// region of type `pointee`. `readonly` indicates whether the
+    /// PCC-checked code is expected to update this field or not.
+    fn add_field_to_memtype(
+        &self,
+        func: &mut ir::Function,
+        memtype: ir::MemoryType,
+        offset: u32,
+        pointee: ir::MemoryType,
+        readonly: bool,
+    ) {
+        let ptr_size = self.pointer_type().bytes();
+        match &mut func.memory_types[memtype] {
+            ir::MemoryTypeData::Struct { size, fields } => {
+                *size = std::cmp::max(*size, offset.checked_add(ptr_size).unwrap().into());
+                fields.push(ir::MemoryTypeField {
+                    ty: self.pointer_type(),
+                    offset: offset.into(),
+                    readonly,
+                    fact: Some(ir::Fact::Mem {
+                        ty: pointee,
+                        min_offset: 0,
+                        max_offset: 0,
+                        nullable: false,
+                    }),
+                });
+
+                // Sort fields by offset -- we need to do this now
+                // because we may create an arbitrary number of
+                // memtypes for imported memories and we don't
+                // otherwise track them.
+                fields.sort_by_key(|f| f.offset);
+            }
+            _ => panic!("Cannot add field to non-struct memtype"),
+        }
+    }
+
+    /// Add one level of indirection to a pointer-and-memtype pair:
+    /// generate a load in the code at the specified offset, and if
+    /// memtypes are in use, add a field to the original struct and
+    /// generate a new memtype for the pointee.
+    fn load_pointer_with_memtypes(
+        &self,
+        func: &mut ir::Function,
+        value: ir::GlobalValue,
+        offset: u32,
+        readonly: bool,
+        memtype: Option<ir::MemoryType>,
+    ) -> (ir::GlobalValue, Option<ir::MemoryType>) {
+        let pointee = func.create_global_value(ir::GlobalValueData::Load {
+            base: value,
+            offset: Offset32::new(i32::try_from(offset).unwrap()),
+            global_type: self.pointer_type(),
+            flags: MemFlags::trusted().with_readonly(),
+        });
+
+        let mt = memtype.map(|mt| {
+            let pointee_mt = self.create_empty_struct_memtype(func);
+            self.add_field_to_memtype(func, mt, offset, pointee_mt, readonly);
+            func.global_value_facts[pointee] = Some(Fact::Mem {
+                ty: pointee_mt,
+                min_offset: 0,
+                max_offset: 0,
+                nullable: false,
+            });
+            pointee_mt
+        });
+        (pointee, mt)
+    }
 }
 
 struct Call<'a, 'func, 'module_env> {
@@ -925,6 +1013,16 @@ struct Call<'a, 'func, 'module_env> {
     tail: bool,
 }
 
+enum CheckIndirectCallTypeSignature {
+    Runtime,
+    StaticMatch {
+        /// Whether or not the funcref may be null or if it's statically known
+        /// to not be null.
+        may_be_null: bool,
+    },
+    StaticTrap,
+}
+
 impl<'a, 'func, 'module_env> Call<'a, 'func, 'module_env> {
     /// Create a new `Call` site that will do regular, non-tail calls.
     pub fn new(
@@ -1022,70 +1120,202 @@ impl<'a, 'func, 'module_env> Call<'a, 'func, 'module_env> {
     pub fn indirect_call(
         mut self,
         table_index: TableIndex,
-        table: ir::Table,
         ty_index: TypeIndex,
         sig_ref: ir::SigRef,
         callee: ir::Value,
         call_args: &[ir::Value],
-    ) -> WasmResult<ir::Inst> {
-        let pointer_type = self.env.pointer_type();
+    ) -> WasmResult<Option<ir::Inst>> {
+        let (code_ptr, callee_vmctx) = match self.check_and_load_code_and_callee_vmctx(
+            table_index,
+            ty_index,
+            callee,
+            false,
+        )? {
+            Some(pair) => pair,
+            None => return Ok(None),
+        };
 
-        // Get the funcref pointer from the table.
-        let funcref_ptr =
-            self.env
-                .get_or_init_func_ref_table_elem(self.builder, table_index, table, callee);
+        self.unchecked_call_impl(sig_ref, code_ptr, callee_vmctx, call_args)
+            .map(Some)
+    }
 
-        // Check for whether the table element is null, and trap if so.
-        self.builder
-            .ins()
-            .trapz(funcref_ptr, ir::TrapCode::IndirectCallToNull);
+    fn check_and_load_code_and_callee_vmctx(
+        &mut self,
+        table_index: TableIndex,
+        ty_index: TypeIndex,
+        callee: ir::Value,
+        cold_blocks: bool,
+    ) -> WasmResult<Option<(ir::Value, ir::Value)>> {
+        // Get the funcref pointer from the table.
+        let table = &self.env.module.table_plans[table_index];
+        let TableStyle::CallerChecksSignature { lazy_init } = table.style;
+        let funcref_ptr = self.env.get_or_init_func_ref_table_elem(
+            self.builder,
+            table_index,
+            callee,
+            cold_blocks,
+            lazy_init,
+        );
 
         // If necessary, check the signature.
-        match self.env.module.table_plans[table_index].style {
-            TableStyle::CallerChecksSignature => {
-                let sig_id_size = self.env.offsets.size_of_vmshared_signature_index();
-                let sig_id_type = Type::int(u16::from(sig_id_size) * 8).unwrap();
-                let vmctx = self.env.vmctx(self.builder.func);
-                let base = self.builder.ins().global_value(pointer_type, vmctx);
-
-                // Load the caller ID. This requires loading the `*mut
-                // VMFuncRef` base pointer from `VMContext` and then loading,
-                // based on `SignatureIndex`, the corresponding entry.
-                let mem_flags = ir::MemFlags::trusted().with_readonly();
-                let signatures = self.builder.ins().load(
-                    pointer_type,
-                    mem_flags,
-                    base,
-                    i32::try_from(self.env.offsets.vmctx_signature_ids_array()).unwrap(),
-                );
-                let sig_index = self.env.module.types[ty_index].unwrap_function();
-                let offset =
-                    i32::try_from(sig_index.as_u32().checked_mul(sig_id_type.bytes()).unwrap())
-                        .unwrap();
-                let caller_sig_id =
-                    self.builder
-                        .ins()
-                        .load(sig_id_type, mem_flags, signatures, offset);
-
-                // Load the callee ID.
-                let mem_flags = ir::MemFlags::trusted().with_readonly();
-                let callee_sig_id = self.builder.ins().load(
-                    sig_id_type,
-                    mem_flags,
-                    funcref_ptr,
-                    i32::from(self.env.offsets.ptr.vm_func_ref_type_index()),
-                );
+        let check = self.check_indirect_call_type_signature(table_index, ty_index, funcref_ptr);
+
+        let trap_code = match check {
+            // `funcref_ptr` is checked at runtime that its type matches,
+            // meaning that if code gets this far it's guaranteed to not be
+            // null. That means nothing in `unchecked_call` can fail.
+            CheckIndirectCallTypeSignature::Runtime => None,
+
+            // No type check was performed on `funcref_ptr` because it's
+            // statically known to have the right type. Note that whether or
+            // not the function is null is not necessarily tested so far since
+            // no type information was inspected.
+            //
+            // If the table may hold null functions, then further loads in
+            // `unchecked_call` may fail. If the table only holds non-null
+            // functions, though, then there's no possibility of a trap.
+            CheckIndirectCallTypeSignature::StaticMatch { may_be_null } => {
+                if may_be_null {
+                    Some(ir::TrapCode::IndirectCallToNull)
+                } else {
+                    None
+                }
+            }
+
+            // Code has already trapped, so return nothing indicating that this
+            // is now unreachable code.
+            CheckIndirectCallTypeSignature::StaticTrap => return Ok(None),
+        };
+
+        Ok(Some(self.load_code_and_vmctx(funcref_ptr, trap_code)))
+    }
+
+    fn check_indirect_call_type_signature(
+        &mut self,
+        table_index: TableIndex,
+        ty_index: TypeIndex,
+        funcref_ptr: ir::Value,
+    ) -> CheckIndirectCallTypeSignature {
+        let pointer_type = self.env.pointer_type();
+        let table = &self.env.module.table_plans[table_index];
+        let sig_id_size = self.env.offsets.size_of_vmshared_type_index();
+        let sig_id_type = Type::int(u16::from(sig_id_size) * 8).unwrap();
+
+        // Generate a rustc compile error here if more styles are added in
+        // the future as the following code is tailored to just this style.
+        let TableStyle::CallerChecksSignature { .. } = table.style;
+
+        // Test if a type check is necessary for this table. If this table is a
+        // table of typed functions and that type matches `ty_index`, then
+        // there's no need to perform a typecheck.
+        match table.table.wasm_ty.heap_type {
+            // Functions do not have a statically known type in the table, a
+            // typecheck is required. Fall through to below to perform the
+            // actual typecheck.
+            WasmHeapType::Func => {}
+
+            // Functions that have a statically known type are either going to
+            // always succeed or always fail. Figure out by inspecting the types
+            // further.
+            WasmHeapType::ConcreteFunc(EngineOrModuleTypeIndex::Module(table_ty)) => {
+                // If `ty_index` matches `table_ty`, then this call is
+                // statically known to have the right type, so no checks are
+                // necessary.
+                let specified_ty = self.env.module.types[ty_index];
+                if specified_ty == table_ty {
+                    return CheckIndirectCallTypeSignature::StaticMatch {
+                        may_be_null: table.table.wasm_ty.nullable,
+                    };
+                }
 
-                // Check that they match.
-                let cmp = self
-                    .builder
-                    .ins()
-                    .icmp(IntCC::Equal, callee_sig_id, caller_sig_id);
-                self.builder.ins().trapz(cmp, ir::TrapCode::BadSignature);
+                // Otherwise if the types don't match then either (a) this is a
+                // null pointer or (b) it's a pointer with the wrong type.
+                // Figure out which and trap here.
+                //
+                // If it's possible to have a null here then try to load the
+                // type information. If that fails due to the function being a
+                // null pointer, then this was a call to null. Otherwise if it
+                // succeeds then we know it won't match, so trap anyway.
+                if table.table.wasm_ty.nullable {
+                    let mem_flags = ir::MemFlags::trusted().with_readonly();
+                    self.builder.ins().load(
+                        sig_id_type,
+                        mem_flags.with_trap_code(Some(ir::TrapCode::IndirectCallToNull)),
+                        funcref_ptr,
+                        i32::from(self.env.offsets.ptr.vm_func_ref_type_index()),
+                    );
+                }
+                self.builder.ins().trap(ir::TrapCode::BadSignature);
+                return CheckIndirectCallTypeSignature::StaticTrap;
+            }
+
+            // Tables of `nofunc` can only be inhabited by null, so go ahead and
+            // trap with that.
+            WasmHeapType::NoFunc => {
+                assert!(table.table.wasm_ty.nullable);
+                self.builder.ins().trap(ir::TrapCode::IndirectCallToNull);
+                return CheckIndirectCallTypeSignature::StaticTrap;
+            }
+
+            // Engine-indexed types don't show up until runtime and it's a Wasm
+            // validation error to perform a call through a non-function table,
+            // so these cases are dynamically not reachable.
+            WasmHeapType::ConcreteFunc(EngineOrModuleTypeIndex::Engine(_))
+            | WasmHeapType::ConcreteFunc(EngineOrModuleTypeIndex::RecGroup(_))
+            | WasmHeapType::Extern
+            | WasmHeapType::NoExtern
+            | WasmHeapType::Any
+            | WasmHeapType::Eq
+            | WasmHeapType::I31
+            | WasmHeapType::Array
+            | WasmHeapType::ConcreteArray(_)
+            | WasmHeapType::Struct
+            | WasmHeapType::ConcreteStruct(_)
+            | WasmHeapType::None => {
+                unreachable!()
             }
         }
 
-        self.unchecked_call(sig_ref, funcref_ptr, call_args)
+        let vmctx = self.env.vmctx(self.builder.func);
+        let base = self.builder.ins().global_value(pointer_type, vmctx);
+
+        // Load the caller ID. This requires loading the `*mut VMFuncRef` base
+        // pointer from `VMContext` and then loading, based on `SignatureIndex`,
+        // the corresponding entry.
+        let mem_flags = ir::MemFlags::trusted().with_readonly();
+        let signatures = self.builder.ins().load(
+            pointer_type,
+            mem_flags,
+            base,
+            i32::from(self.env.offsets.ptr.vmctx_type_ids_array()),
+        );
+        let sig_index = self.env.module.types[ty_index];
+        let offset =
+            i32::try_from(sig_index.as_u32().checked_mul(sig_id_type.bytes()).unwrap()).unwrap();
+        let caller_sig_id = self
+            .builder
+            .ins()
+            .load(sig_id_type, mem_flags, signatures, offset);
+
+        // Load the callee ID.
+        //
+        // Note that the callee may be null in which case this load may
+        // trap. If so use the `IndirectCallToNull` trap code.
+        let mem_flags = ir::MemFlags::trusted().with_readonly();
+        let callee_sig_id = self.builder.ins().load(
+            sig_id_type,
+            mem_flags.with_trap_code(Some(ir::TrapCode::IndirectCallToNull)),
+            funcref_ptr,
+            i32::from(self.env.offsets.ptr.vm_func_ref_type_index()),
+        );
+
+        // Check that they match.
+        let cmp = self
+            .builder
+            .ins()
+            .icmp(IntCC::Equal, callee_sig_id, caller_sig_id);
+        self.builder.ins().trapz(cmp, ir::TrapCode::BadSignature);
+        CheckIndirectCallTypeSignature::Runtime
     }
 
     /// Call a typed function reference.
@@ -1095,19 +1325,15 @@ impl<'a, 'func, 'module_env> Call<'a, 'func, 'module_env> {
         callee: ir::Value,
         args: &[ir::Value],
     ) -> WasmResult<ir::Inst> {
-        // Check for whether the callee is null, and trap if so.
-        //
         // FIXME: the wasm type system tracks enough information to know whether
         // `callee` is a null reference or not. In some situations it can be
         // statically known here that `callee` cannot be null in which case this
-        // null check can be elided. This requires feeding type information from
+        // can be `None` instead. This requires feeding type information from
         // wasmparser's validator into this function, however, which is not
         // easily done at this time.
-        self.builder
-            .ins()
-            .trapz(callee, ir::TrapCode::NullReference);
+        let callee_load_trap_code = Some(ir::TrapCode::NullReference);
 
-        self.unchecked_call(sig_ref, callee, args)
+        self.unchecked_call(sig_ref, callee, callee_load_trap_code, args)
     }
 
     /// This calls a function by reference without checking the signature.
@@ -1119,19 +1345,54 @@ impl<'a, 'func, 'module_env> Call<'a, 'func, 'module_env> {
         &mut self,
         sig_ref: ir::SigRef,
         callee: ir::Value,
+        callee_load_trap_code: Option<ir::TrapCode>,
         call_args: &[ir::Value],
     ) -> WasmResult<ir::Inst> {
+        let (func_addr, callee_vmctx) = self.load_code_and_vmctx(callee, callee_load_trap_code);
+        self.unchecked_call_impl(sig_ref, func_addr, callee_vmctx, call_args)
+    }
+
+    fn load_code_and_vmctx(
+        &mut self,
+        callee: ir::Value,
+        callee_load_trap_code: Option<ir::TrapCode>,
+    ) -> (ir::Value, ir::Value) {
         let pointer_type = self.env.pointer_type();
 
         // Dereference callee pointer to get the function address.
+        //
+        // Note that this may trap if `callee` hasn't previously been verified
+        // to be non-null. This means that this load is annotated with an
+        // optional trap code provided by the caller of `unchecked_call` which
+        // will handle the case where this is either already known to be
+        // non-null or may trap.
         let mem_flags = ir::MemFlags::trusted().with_readonly();
         let func_addr = self.builder.ins().load(
             pointer_type,
-            mem_flags,
+            mem_flags.with_trap_code(callee_load_trap_code),
             callee,
             i32::from(self.env.offsets.ptr.vm_func_ref_wasm_call()),
         );
+        let callee_vmctx = self.builder.ins().load(
+            pointer_type,
+            mem_flags,
+            callee,
+            i32::from(self.env.offsets.ptr.vm_func_ref_vmctx()),
+        );
 
+        (func_addr, callee_vmctx)
+    }
+
+    /// This calls a function by reference without checking the
+    /// signature, given the raw code pointer to the
+    /// Wasm-calling-convention entry point and the callee vmctx.
+    fn unchecked_call_impl(
+        &mut self,
+        sig_ref: ir::SigRef,
+        func_addr: ir::Value,
+        callee_vmctx: ir::Value,
+        call_args: &[ir::Value],
+    ) -> WasmResult<ir::Inst> {
         let mut real_call_args = Vec::with_capacity(call_args.len() + 2);
         let caller_vmctx = self
             .builder
@@ -1139,14 +1400,8 @@ impl<'a, 'func, 'module_env> Call<'a, 'func, 'module_env> {
             .special_param(ArgumentPurpose::VMContext)
             .unwrap();
 
-        // First append the callee vmctx address.
-        let vmctx = self.builder.ins().load(
-            pointer_type,
-            mem_flags,
-            callee,
-            i32::from(self.env.offsets.ptr.vm_func_ref_vmctx()),
-        );
-        real_call_args.push(vmctx);
+        // First append the callee and caller vmctx addresses.
+        real_call_args.push(callee_vmctx);
         real_call_args.push(caller_vmctx);
 
         // Then append the regular call arguments.
@@ -1159,7 +1414,24 @@ impl<'a, 'func, 'module_env> Call<'a, 'func, 'module_env> {
         if self.tail {
             self.builder.ins().return_call(callee, args)
         } else {
-            self.builder.ins().call(callee, args)
+            let inst = self.builder.ins().call(callee, args);
+            let results: SmallVec<[_; 4]> = self
+                .builder
+                .func
+                .dfg
+                .inst_results(inst)
+                .iter()
+                .copied()
+                .collect();
+            for (i, val) in results.into_iter().enumerate() {
+                if self
+                    .env
+                    .func_ref_result_needs_stack_map(&self.builder.func, callee, i)
+                {
+                    self.builder.declare_value_needs_stack_map(val);
+                }
+            }
+            inst
         }
     }
 
@@ -1174,14 +1446,33 @@ impl<'a, 'func, 'module_env> Call<'a, 'func, 'module_env> {
                 .ins()
                 .return_call_indirect(sig_ref, func_addr, args)
         } else {
-            self.builder.ins().call_indirect(sig_ref, func_addr, args)
+            let inst = self.builder.ins().call_indirect(sig_ref, func_addr, args);
+            let results: SmallVec<[_; 4]> = self
+                .builder
+                .func
+                .dfg
+                .inst_results(inst)
+                .iter()
+                .copied()
+                .collect();
+            for (i, val) in results.into_iter().enumerate() {
+                if self.env.sig_ref_result_needs_stack_map(sig_ref, i) {
+                    self.builder.declare_value_needs_stack_map(val);
+                }
+            }
+            inst
         }
     }
 }
 
 impl TypeConvert for FuncEnvironment<'_> {
-    fn lookup_heap_type(&self, ty: TypeIndex) -> WasmHeapType {
-        self.module.lookup_heap_type(ty)
+    fn lookup_heap_type(&self, ty: wasmparser::UnpackedIndex) -> WasmHeapType {
+        wasmtime_environ::WasmparserTypeConverter::new(self.types, self.module).lookup_heap_type(ty)
+    }
+
+    fn lookup_type_index(&self, index: wasmparser::UnpackedIndex) -> EngineOrModuleTypeIndex {
+        wasmtime_environ::WasmparserTypeConverter::new(self.types, self.module)
+            .lookup_type_index(index)
     }
 }
 
@@ -1190,13 +1481,22 @@ impl<'module_environment> TargetEnvironment for FuncEnvironment<'module_environm
         self.isa.frontend_config()
     }
 
-    fn reference_type(&self, ty: WasmHeapType) -> ir::Type {
-        crate::reference_type(ty, self.pointer_type())
+    fn reference_type(&self, wasm_ty: WasmHeapType) -> (ir::Type, bool) {
+        let ty = crate::reference_type(wasm_ty, self.pointer_type());
+        let needs_stack_map = match wasm_ty.top() {
+            WasmHeapTopType::Extern | WasmHeapTopType::Any => true,
+            WasmHeapTopType::Func => false,
+        };
+        (ty, needs_stack_map)
     }
 
     fn heap_access_spectre_mitigation(&self) -> bool {
         self.isa.flags().enable_heap_access_spectre_mitigation()
     }
+
+    fn proof_carrying_code(&self) -> bool {
+        self.isa.flags().enable_pcc()
+    }
 }
 
 impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'module_environment> {
@@ -1210,102 +1510,58 @@ impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'m
         index >= 2
     }
 
-    fn after_locals(&mut self, num_locals: usize) {
-        self.vmruntime_limits_ptr = Variable::new(num_locals);
-        self.fuel_var = Variable::new(num_locals + 1);
-        self.epoch_deadline_var = Variable::new(num_locals + 2);
-        self.epoch_ptr_var = Variable::new(num_locals + 3);
-    }
-
-    fn make_table(&mut self, func: &mut ir::Function, index: TableIndex) -> WasmResult<ir::Table> {
-        let pointer_type = self.pointer_type();
+    fn param_needs_stack_map(&self, _signature: &ir::Signature, index: usize) -> bool {
+        // Skip the caller and callee vmctx.
+        if index < 2 {
+            return false;
+        }
 
-        let (ptr, base_offset, current_elements_offset) = {
-            let vmctx = self.vmctx(func);
-            if let Some(def_index) = self.module.defined_table_index(index) {
-                let base_offset =
-                    i32::try_from(self.offsets.vmctx_vmtable_definition_base(def_index)).unwrap();
-                let current_elements_offset = i32::try_from(
-                    self.offsets
-                        .vmctx_vmtable_definition_current_elements(def_index),
-                )
-                .unwrap();
-                (vmctx, base_offset, current_elements_offset)
-            } else {
-                let from_offset = self.offsets.vmctx_vmtable_import_from(index);
-                let table = func.create_global_value(ir::GlobalValueData::Load {
-                    base: vmctx,
-                    offset: Offset32::new(i32::try_from(from_offset).unwrap()),
-                    global_type: pointer_type,
-                    readonly: true,
-                });
-                let base_offset = i32::from(self.offsets.vmtable_definition_base());
-                let current_elements_offset =
-                    i32::from(self.offsets.vmtable_definition_current_elements());
-                (table, base_offset, current_elements_offset)
-            }
-        };
+        self.wasm_func_ty.params()[index - 2].is_vmgcref_type_and_not_i31()
+    }
 
-        let base_gv = func.create_global_value(ir::GlobalValueData::Load {
-            base: ptr,
-            offset: Offset32::new(base_offset),
-            global_type: pointer_type,
-            readonly: false,
-        });
-        let bound_gv = func.create_global_value(ir::GlobalValueData::Load {
-            base: ptr,
-            offset: Offset32::new(current_elements_offset),
-            global_type: ir::Type::int(
-                u16::from(self.offsets.size_of_vmtable_definition_current_elements()) * 8,
-            )
-            .unwrap(),
-            readonly: false,
-        });
+    fn sig_ref_result_needs_stack_map(&self, sig_ref: ir::SigRef, index: usize) -> bool {
+        let wasm_func_ty = self.sig_ref_to_ty[sig_ref].as_ref().unwrap();
+        wasm_func_ty.returns()[index].is_vmgcref_type_and_not_i31()
+    }
 
-        let element_size = u64::from(
-            self.reference_type(self.module.table_plans[index].table.wasm_ty.heap_type)
-                .bytes(),
-        );
+    fn func_ref_result_needs_stack_map(
+        &self,
+        func: &ir::Function,
+        func_ref: ir::FuncRef,
+        index: usize,
+    ) -> bool {
+        let sig_ref = func.dfg.ext_funcs[func_ref].signature;
+        let wasm_func_ty = self.sig_ref_to_ty[sig_ref].as_ref().unwrap();
+        wasm_func_ty.returns()[index].is_vmgcref_type_and_not_i31()
+    }
 
-        Ok(func.create_table(ir::TableData {
-            base_gv,
-            min_size: Uimm64::new(0),
-            bound_gv,
-            element_size: Uimm64::new(element_size),
-            index_type: I32,
-        }))
+    fn after_locals(&mut self, num_locals: usize) {
+        self.fuel_var = Variable::new(num_locals);
+        self.epoch_deadline_var = Variable::new(num_locals + 1);
+        self.epoch_ptr_var = Variable::new(num_locals + 2);
     }
 
     fn translate_table_grow(
         &mut self,
         mut pos: cranelift_codegen::cursor::FuncCursor<'_>,
         table_index: TableIndex,
-        _table: ir::Table,
         delta: ir::Value,
         init_value: ir::Value,
     ) -> WasmResult<ir::Value> {
-        let (func_idx, func_sig) =
-            match self.module.table_plans[table_index].table.wasm_ty.heap_type {
-                WasmHeapType::Func | WasmHeapType::TypedFunc(_) => (
-                    BuiltinFunctionIndex::table_grow_func_ref(),
-                    self.builtin_function_signatures
-                        .table_grow_func_ref(&mut pos.func),
-                ),
-                WasmHeapType::Extern => (
-                    BuiltinFunctionIndex::table_grow_externref(),
-                    self.builtin_function_signatures
-                        .table_grow_externref(&mut pos.func),
-                ),
-            };
+        let ty = self.module.table_plans[table_index].table.wasm_ty.heap_type;
+        let grow = if ty.is_vmgcref_type() {
+            gc::gc_ref_table_grow_builtin(ty, self, &mut pos.func)?
+        } else {
+            debug_assert_eq!(ty.top(), WasmHeapTopType::Func);
+            self.builtin_functions.table_grow_func_ref(&mut pos.func)
+        };
 
-        let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx);
+        let vmctx = self.vmctx_val(&mut pos);
 
         let table_index_arg = pos.ins().iconst(I32, table_index.as_u32() as i64);
-        let call_inst = pos.ins().call_indirect(
-            func_sig,
-            func_addr,
-            &[vmctx, table_index_arg, delta, init_value],
-        );
+        let call_inst = pos
+            .ins()
+            .call(grow, &[vmctx, table_index_arg, delta, init_value]);
 
         Ok(pos.func.dfg.first_result(call_inst))
     }
@@ -1314,134 +1570,53 @@ impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'m
         &mut self,
         builder: &mut FunctionBuilder,
         table_index: TableIndex,
-        table: ir::Table,
         index: ir::Value,
     ) -> WasmResult<ir::Value> {
-        let pointer_type = self.pointer_type();
-
         let plan = &self.module.table_plans[table_index];
-        match plan.table.wasm_ty.heap_type {
-            WasmHeapType::Func | WasmHeapType::TypedFunc(_) => match plan.style {
-                TableStyle::CallerChecksSignature => {
-                    Ok(self.get_or_init_func_ref_table_elem(builder, table_index, table, index))
-                }
-            },
-            WasmHeapType::Extern => {
-                // Our read barrier for `externref` tables is roughly equivalent
-                // to the following pseudocode:
-                //
-                // ```
-                // let elem = table[index]
-                // if elem is not null:
-                //     let (next, end) = VMExternRefActivationsTable bump region
-                //     if next != end:
-                //         elem.ref_count += 1
-                //         *next = elem
-                //         next += 1
-                //     else:
-                //         call activations_table_insert_with_gc(elem)
-                // return elem
-                // ```
-                //
-                // This ensures that all `externref`s coming out of tables and
-                // onto the stack are safely held alive by the
-                // `VMExternRefActivationsTable`.
-
-                let reference_type = self.reference_type(WasmHeapType::Extern);
-
-                builder.ensure_inserted_block();
-                let continue_block = builder.create_block();
-                let non_null_elem_block = builder.create_block();
-                let gc_block = builder.create_block();
-                let no_gc_block = builder.create_block();
-                let current_block = builder.current_block().unwrap();
-                builder.insert_block_after(non_null_elem_block, current_block);
-                builder.insert_block_after(no_gc_block, non_null_elem_block);
-                builder.insert_block_after(gc_block, no_gc_block);
-                builder.insert_block_after(continue_block, gc_block);
-
-                // Load the table element.
-                let elem_addr = builder.ins().table_addr(pointer_type, table, index, 0);
-                let flags = ir::MemFlags::trusted().with_table();
-                let elem = builder.ins().load(reference_type, flags, elem_addr, 0);
-
-                let elem_is_null = builder.ins().is_null(elem);
-                builder
-                    .ins()
-                    .brif(elem_is_null, continue_block, &[], non_null_elem_block, &[]);
-
-                // Load the `VMExternRefActivationsTable::next` bump finger and
-                // the `VMExternRefActivationsTable::end` bump boundary.
-                builder.switch_to_block(non_null_elem_block);
-                let vmctx = self.vmctx(&mut builder.func);
-                let vmctx = builder.ins().global_value(pointer_type, vmctx);
-                let activations_table = builder.ins().load(
-                    pointer_type,
-                    ir::MemFlags::trusted(),
-                    vmctx,
-                    i32::try_from(self.offsets.vmctx_externref_activations_table()).unwrap(),
-                );
-                let next = builder.ins().load(
-                    pointer_type,
-                    ir::MemFlags::trusted(),
-                    activations_table,
-                    i32::try_from(self.offsets.vm_extern_ref_activation_table_next()).unwrap(),
-                );
-                let end = builder.ins().load(
-                    pointer_type,
-                    ir::MemFlags::trusted(),
-                    activations_table,
-                    i32::try_from(self.offsets.vm_extern_ref_activation_table_end()).unwrap(),
+        self.ensure_table_exists(builder.func, table_index);
+        let table_data = self.tables[table_index].as_ref().unwrap();
+        let heap_ty = plan.table.wasm_ty.heap_type;
+        match heap_ty.top() {
+            // `i31ref`s never need barriers, and therefore don't need to go
+            // through the GC compiler.
+            WasmHeapTopType::Any if heap_ty == WasmHeapType::I31 => {
+                let (src, flags) = table_data.prepare_table_addr(
+                    builder,
+                    index,
+                    self.pointer_type(),
+                    self.isa.flags().enable_table_access_spectre_mitigation(),
                 );
+                gc::unbarriered_load_gc_ref(self, builder, WasmHeapType::I31, src, flags)
+            }
 
-                // If `next == end`, then we are at full capacity. Call a
-                // builtin to do a GC and insert this reference into the
-                // just-swept table for us.
-                let at_capacity = builder.ins().icmp(ir::condcodes::IntCC::Equal, next, end);
-                builder
-                    .ins()
-                    .brif(at_capacity, gc_block, &[], no_gc_block, &[]);
-                builder.switch_to_block(gc_block);
-                let builtin_idx = BuiltinFunctionIndex::activations_table_insert_with_gc();
-                let builtin_sig = self
-                    .builtin_function_signatures
-                    .activations_table_insert_with_gc(builder.func);
-                let (vmctx, builtin_addr) = self
-                    .translate_load_builtin_function_address(&mut builder.cursor(), builtin_idx);
-                builder
-                    .ins()
-                    .call_indirect(builtin_sig, builtin_addr, &[vmctx, elem]);
-                builder.ins().jump(continue_block, &[]);
-
-                // If `next != end`, then:
-                //
-                // * increment this reference's ref count,
-                // * store the reference into the bump table at `*next`,
-                // * and finally increment the `next` bump finger.
-                builder.switch_to_block(no_gc_block);
-                self.mutate_externref_ref_count(builder, elem, 1);
-                builder.ins().store(ir::MemFlags::trusted(), elem, next, 0);
-
-                let new_next = builder
-                    .ins()
-                    .iadd_imm(next, i64::from(reference_type.bytes()));
-                builder.ins().store(
-                    ir::MemFlags::trusted(),
-                    new_next,
-                    activations_table,
-                    i32::try_from(self.offsets.vm_extern_ref_activation_table_next()).unwrap(),
+            // GC-managed types.
+            WasmHeapTopType::Any | WasmHeapTopType::Extern => {
+                let (src, flags) = table_data.prepare_table_addr(
+                    builder,
+                    index,
+                    self.pointer_type(),
+                    self.isa.flags().enable_table_access_spectre_mitigation(),
                 );
-
-                builder.ins().jump(continue_block, &[]);
-                builder.switch_to_block(continue_block);
-
-                builder.seal_block(non_null_elem_block);
-                builder.seal_block(gc_block);
-                builder.seal_block(no_gc_block);
-                builder.seal_block(continue_block);
-
-                Ok(elem)
+                gc::gc_compiler(self).translate_read_gc_reference(
+                    self,
+                    builder,
+                    plan.table.wasm_ty,
+                    src,
+                    flags,
+                )
             }
+
+            // Function types.
+            WasmHeapTopType::Func => match plan.style {
+                TableStyle::CallerChecksSignature { lazy_init } => Ok(self
+                    .get_or_init_func_ref_table_elem(
+                        builder,
+                        table_index,
+                        index,
+                        false,
+                        lazy_init,
+                    )),
+            },
         }
     }
 
@@ -1449,159 +1624,71 @@ impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'m
         &mut self,
         builder: &mut FunctionBuilder,
         table_index: TableIndex,
-        table: ir::Table,
         value: ir::Value,
         index: ir::Value,
     ) -> WasmResult<()> {
         let pointer_type = self.pointer_type();
         let plan = &self.module.table_plans[table_index];
-        match plan.table.wasm_ty.heap_type {
-            WasmHeapType::Func | WasmHeapType::TypedFunc(_) => match plan.style {
-                TableStyle::CallerChecksSignature => {
-                    let table_entry_addr = builder.ins().table_addr(pointer_type, table, index, 0);
-                    // Set the "initialized bit". See doc-comment on
-                    // `FUNCREF_INIT_BIT` in
-                    // crates/environ/src/ref_bits.rs for details.
-                    let value_with_init_bit = builder
-                        .ins()
-                        .bor_imm(value, Imm64::from(FUNCREF_INIT_BIT as i64));
-                    let flags = ir::MemFlags::trusted().with_table();
-                    builder
-                        .ins()
-                        .store(flags, value_with_init_bit, table_entry_addr, 0);
-                    Ok(())
-                }
-            },
-
-            WasmHeapType::Extern => {
-                // Our write barrier for `externref`s being copied out of the
-                // stack and into a table is roughly equivalent to the following
-                // pseudocode:
-                //
-                // ```
-                // if value != null:
-                //     value.ref_count += 1
-                // let current_elem = table[index]
-                // table[index] = value
-                // if current_elem != null:
-                //     current_elem.ref_count -= 1
-                //     if current_elem.ref_count == 0:
-                //         call drop_externref(current_elem)
-                // ```
-                //
-                // This write barrier is responsible for ensuring that:
-                //
-                // 1. The value's ref count is incremented now that the
-                //    table is holding onto it. This is required for memory safety.
-                //
-                // 2. The old table element, if any, has its ref count
-                //    decremented, and that the wrapped data is dropped if the
-                //    ref count reaches zero. This is not required for memory
-                //    safety, but is required to avoid leaks. Furthermore, the
-                //    destructor might GC or touch this table, so we must only
-                //    drop the old table element *after* we've replaced it with
-                //    the new `value`!
-
-                builder.ensure_inserted_block();
-                let current_block = builder.current_block().unwrap();
-                let inc_ref_count_block = builder.create_block();
-                builder.insert_block_after(inc_ref_count_block, current_block);
-                let check_current_elem_block = builder.create_block();
-                builder.insert_block_after(check_current_elem_block, inc_ref_count_block);
-                let dec_ref_count_block = builder.create_block();
-                builder.insert_block_after(dec_ref_count_block, check_current_elem_block);
-                let drop_block = builder.create_block();
-                builder.insert_block_after(drop_block, dec_ref_count_block);
-                let continue_block = builder.create_block();
-                builder.insert_block_after(continue_block, drop_block);
-
-                // Calculate the table address of the current element and do
-                // bounds checks. This is the first thing we do, because we
-                // don't want to modify any ref counts if this `table.set` is
-                // going to trap.
-                let table_entry_addr = builder.ins().table_addr(pointer_type, table, index, 0);
-
-                // If value is not null, increment `value`'s ref count.
-                //
-                // This has to come *before* decrementing the current table
-                // element's ref count, because it might reach ref count == zero,
-                // causing us to deallocate the current table element. However,
-                // if `value` *is* the current table element (and therefore this
-                // whole `table.set` is a no-op), then we would incorrectly
-                // deallocate `value` and leave it in the table, leading to use
-                // after free.
-                let value_is_null = builder.ins().is_null(value);
-                builder.ins().brif(
-                    value_is_null,
-                    check_current_elem_block,
-                    &[],
-                    inc_ref_count_block,
-                    &[],
+        self.ensure_table_exists(builder.func, table_index);
+        let table_data = self.tables[table_index].as_ref().unwrap();
+        let heap_ty = plan.table.wasm_ty.heap_type;
+        match heap_ty.top() {
+            // `i31ref`s never need GC barriers, and therefore don't need to go
+            // through the GC compiler.
+            WasmHeapTopType::Any if heap_ty == WasmHeapType::I31 => {
+                let (addr, flags) = table_data.prepare_table_addr(
+                    builder,
+                    index,
+                    self.pointer_type(),
+                    self.isa.flags().enable_table_access_spectre_mitigation(),
                 );
-                builder.switch_to_block(inc_ref_count_block);
-                self.mutate_externref_ref_count(builder, value, 1);
-                builder.ins().jump(check_current_elem_block, &[]);
+                gc::unbarriered_store_gc_ref(self, builder, WasmHeapType::I31, addr, value, flags)
+            }
 
-                // Grab the current element from the table, and store the new
-                // `value` into the table.
-                //
-                // Note that we load the current element as a pointer, not a
-                // reference. This is so that if we call out-of-line to run its
-                // destructor, and its destructor triggers GC, this reference is
-                // not recorded in the stack map (which would lead to the GC
-                // saving a reference to a deallocated object, and then using it
-                // after its been freed).
-                builder.switch_to_block(check_current_elem_block);
-                let flags = ir::MemFlags::trusted().with_table();
-                let current_elem = builder.ins().load(pointer_type, flags, table_entry_addr, 0);
-                builder.ins().store(flags, value, table_entry_addr, 0);
-
-                // If the current element is non-null, decrement its reference
-                // count. And if its reference count has reached zero, then make
-                // an out-of-line call to deallocate it.
-                let current_elem_is_null =
-                    builder
-                        .ins()
-                        .icmp_imm(ir::condcodes::IntCC::Equal, current_elem, 0);
-                builder.ins().brif(
-                    current_elem_is_null,
-                    continue_block,
-                    &[],
-                    dec_ref_count_block,
-                    &[],
+            // GC-managed types.
+            WasmHeapTopType::Any | WasmHeapTopType::Extern => {
+                let (dst, flags) = table_data.prepare_table_addr(
+                    builder,
+                    index,
+                    self.pointer_type(),
+                    self.isa.flags().enable_table_access_spectre_mitigation(),
                 );
+                gc::gc_compiler(self).translate_write_gc_reference(
+                    self,
+                    builder,
+                    plan.table.wasm_ty,
+                    dst,
+                    value,
+                    flags,
+                )
+            }
 
-                builder.switch_to_block(dec_ref_count_block);
-                let prev_ref_count = self.mutate_externref_ref_count(builder, current_elem, -1);
-                let one = builder.ins().iconst(pointer_type, 1);
-                let cond = builder.ins().icmp(IntCC::Equal, one, prev_ref_count);
-                builder
-                    .ins()
-                    .brif(cond, drop_block, &[], continue_block, &[]);
-
-                // Call the `drop_externref` builtin to (you guessed it) drop
-                // the `externref`.
-                builder.switch_to_block(drop_block);
-                let builtin_idx = BuiltinFunctionIndex::drop_externref();
-                let builtin_sig = self
-                    .builtin_function_signatures
-                    .drop_externref(builder.func);
-                let (vmctx, builtin_addr) = self
-                    .translate_load_builtin_function_address(&mut builder.cursor(), builtin_idx);
-                builder
-                    .ins()
-                    .call_indirect(builtin_sig, builtin_addr, &[vmctx, current_elem]);
-                builder.ins().jump(continue_block, &[]);
-
-                builder.switch_to_block(continue_block);
-
-                builder.seal_block(inc_ref_count_block);
-                builder.seal_block(check_current_elem_block);
-                builder.seal_block(dec_ref_count_block);
-                builder.seal_block(drop_block);
-                builder.seal_block(continue_block);
-
-                Ok(())
+            // Function types.
+            WasmHeapTopType::Func => {
+                match plan.style {
+                    TableStyle::CallerChecksSignature { lazy_init } => {
+                        let (elem_addr, flags) = table_data.prepare_table_addr(
+                            builder,
+                            index,
+                            pointer_type,
+                            self.isa.flags().enable_table_access_spectre_mitigation(),
+                        );
+                        // Set the "initialized bit". See doc-comment on
+                        // `FUNCREF_INIT_BIT` in
+                        // crates/environ/src/ref_bits.rs for details.
+                        let value_with_init_bit = if lazy_init {
+                            builder
+                                .ins()
+                                .bor_imm(value, Imm64::from(FUNCREF_INIT_BIT as i64))
+                        } else {
+                            value
+                        };
+                        builder
+                            .ins()
+                            .store(flags, value_with_init_bit, elem_addr, 0);
+                        Ok(())
+                    }
+                }
             }
         }
     }
@@ -1614,43 +1701,61 @@ impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'m
         val: ir::Value,
         len: ir::Value,
     ) -> WasmResult<()> {
-        let (builtin_idx, builtin_sig) =
-            match self.module.table_plans[table_index].table.wasm_ty.heap_type {
-                WasmHeapType::Func | WasmHeapType::TypedFunc(_) => (
-                    BuiltinFunctionIndex::table_fill_func_ref(),
-                    self.builtin_function_signatures
-                        .table_fill_func_ref(&mut pos.func),
-                ),
-                WasmHeapType::Extern => (
-                    BuiltinFunctionIndex::table_fill_externref(),
-                    self.builtin_function_signatures
-                        .table_fill_externref(&mut pos.func),
-                ),
-            };
+        let ty = self.module.table_plans[table_index].table.wasm_ty.heap_type;
+        let libcall = if ty.is_vmgcref_type() {
+            gc::gc_ref_table_fill_builtin(ty, self, &mut pos.func)?
+        } else {
+            debug_assert_eq!(ty.top(), WasmHeapTopType::Func);
+            self.builtin_functions.table_fill_func_ref(&mut pos.func)
+        };
 
-        let (vmctx, builtin_addr) =
-            self.translate_load_builtin_function_address(&mut pos, builtin_idx);
+        let vmctx = self.vmctx_val(&mut pos);
 
         let table_index_arg = pos.ins().iconst(I32, table_index.as_u32() as i64);
-        pos.ins().call_indirect(
-            builtin_sig,
-            builtin_addr,
-            &[vmctx, table_index_arg, dst, val, len],
-        );
+        pos.ins()
+            .call(libcall, &[vmctx, table_index_arg, dst, val, len]);
 
         Ok(())
     }
 
+    fn translate_ref_i31(&mut self, mut pos: FuncCursor, val: ir::Value) -> WasmResult<ir::Value> {
+        debug_assert_eq!(pos.func.dfg.value_type(val), ir::types::I32);
+        let shifted = pos.ins().ishl_imm(val, 1);
+        let tagged = pos
+            .ins()
+            .bor_imm(shifted, i64::from(crate::I31_REF_DISCRIMINANT));
+        let (ref_ty, _needs_stack_map) = self.reference_type(WasmHeapType::I31);
+        debug_assert_eq!(ref_ty, ir::types::I32);
+        Ok(tagged)
+    }
+
+    fn translate_i31_get_s(
+        &mut self,
+        mut pos: FuncCursor,
+        i31ref: ir::Value,
+    ) -> WasmResult<ir::Value> {
+        pos.ins().trapz(i31ref, ir::TrapCode::NullI31Ref);
+        Ok(pos.ins().sshr_imm(i31ref, 1))
+    }
+
+    fn translate_i31_get_u(
+        &mut self,
+        mut pos: FuncCursor,
+        i31ref: ir::Value,
+    ) -> WasmResult<ir::Value> {
+        pos.ins().trapz(i31ref, ir::TrapCode::NullI31Ref);
+        Ok(pos.ins().ushr_imm(i31ref, 1))
+    }
+
     fn translate_ref_null(
         &mut self,
         mut pos: cranelift_codegen::cursor::FuncCursor,
         ht: WasmHeapType,
     ) -> WasmResult<ir::Value> {
-        Ok(match ht {
-            WasmHeapType::Func | WasmHeapType::TypedFunc(_) => {
-                pos.ins().iconst(self.pointer_type(), 0)
-            }
-            WasmHeapType::Extern => pos.ins().null(self.reference_type(ht)),
+        Ok(match ht.top() {
+            WasmHeapTopType::Func => pos.ins().iconst(self.pointer_type(), 0),
+            // NB: null GC references don't need to be in stack maps.
+            WasmHeapTopType::Any | WasmHeapTopType::Extern => pos.ins().iconst(types::I32, 0),
         })
     }
 
@@ -1659,18 +1764,10 @@ impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'m
         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!(),
-        };
-
-        Ok(pos.ins().uextend(ir::types::I32, bool_is_null))
+        let byte_is_null =
+            pos.ins()
+                .icmp_imm(cranelift_codegen::ir::condcodes::IntCC::Equal, value, 0);
+        Ok(pos.ins().uextend(ir::types::I32, byte_is_null))
     }
 
     fn translate_ref_func(
@@ -1679,67 +1776,62 @@ impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'m
         func_index: FuncIndex,
     ) -> WasmResult<ir::Value> {
         let func_index = pos.ins().iconst(I32, func_index.as_u32() as i64);
-        let builtin_index = BuiltinFunctionIndex::ref_func();
-        let builtin_sig = self.builtin_function_signatures.ref_func(&mut pos.func);
-        let (vmctx, builtin_addr) =
-            self.translate_load_builtin_function_address(&mut pos, builtin_index);
+        let ref_func = self.builtin_functions.ref_func(&mut pos.func);
+        let vmctx = self.vmctx_val(&mut pos);
 
-        let call_inst = pos
-            .ins()
-            .call_indirect(builtin_sig, builtin_addr, &[vmctx, func_index]);
+        let call_inst = pos.ins().call(ref_func, &[vmctx, func_index]);
         Ok(pos.func.dfg.first_result(call_inst))
     }
 
     fn translate_custom_global_get(
         &mut self,
-        mut pos: cranelift_codegen::cursor::FuncCursor<'_>,
+        builder: &mut FunctionBuilder,
         index: cranelift_wasm::GlobalIndex,
     ) -> WasmResult<ir::Value> {
-        debug_assert_eq!(
-            self.module.globals[index].wasm_ty,
-            WasmType::Ref(WasmRefType::EXTERNREF),
-            "We only use GlobalVariable::Custom for externref"
+        let ty = self.module.globals[index].wasm_ty;
+        debug_assert!(
+            ty.is_vmgcref_type(),
+            "We only use GlobalVariable::Custom for VMGcRef types"
         );
 
-        let builtin_index = BuiltinFunctionIndex::externref_global_get();
-        let builtin_sig = self
-            .builtin_function_signatures
-            .externref_global_get(&mut pos.func);
+        // TODO: use `GcCompiler::translate_read_gc_reference` for GC-reference
+        // globals instead of a libcall.
+        let libcall = gc::gc_ref_global_get_builtin(ty, self, &mut builder.func)?;
 
-        let (vmctx, builtin_addr) =
-            self.translate_load_builtin_function_address(&mut pos, builtin_index);
+        let vmctx = self.vmctx_val(&mut builder.cursor());
 
-        let global_index_arg = pos.ins().iconst(I32, index.as_u32() as i64);
-        let call_inst =
-            pos.ins()
-                .call_indirect(builtin_sig, builtin_addr, &[vmctx, global_index_arg]);
+        let global_index_arg = builder.ins().iconst(I32, index.as_u32() as i64);
+        let call_inst = builder.ins().call(libcall, &[vmctx, global_index_arg]);
 
-        Ok(pos.func.dfg.first_result(call_inst))
+        let val = builder.func.dfg.first_result(call_inst);
+        if ty.is_vmgcref_type_and_not_i31() {
+            builder.declare_value_needs_stack_map(val);
+        }
+        Ok(val)
     }
 
     fn translate_custom_global_set(
         &mut self,
-        mut pos: cranelift_codegen::cursor::FuncCursor<'_>,
+        builder: &mut FunctionBuilder,
         index: cranelift_wasm::GlobalIndex,
         value: ir::Value,
     ) -> WasmResult<()> {
-        debug_assert_eq!(
-            self.module.globals[index].wasm_ty,
-            WasmType::Ref(WasmRefType::EXTERNREF),
-            "We only use GlobalVariable::Custom for externref"
+        let ty = self.module.globals[index].wasm_ty;
+        debug_assert!(
+            ty.is_vmgcref_type(),
+            "We only use GlobalVariable::Custom for VMGcRef types"
         );
 
-        let builtin_index = BuiltinFunctionIndex::externref_global_set();
-        let builtin_sig = self
-            .builtin_function_signatures
-            .externref_global_set(&mut pos.func);
+        // TODO: use `GcCompiler::translate_write_gc_reference` for GC-reference
+        // globals instead of a libcall.
+        let libcall = gc::gc_ref_global_set_builtin(ty, self, &mut builder.func)?;
 
-        let (vmctx, builtin_addr) =
-            self.translate_load_builtin_function_address(&mut pos, builtin_index);
+        let vmctx = self.vmctx_val(&mut builder.cursor());
 
-        let global_index_arg = pos.ins().iconst(I32, index.as_u32() as i64);
-        pos.ins()
-            .call_indirect(builtin_sig, builtin_addr, &[vmctx, global_index_arg, value]);
+        let global_index_arg = builder.ins().iconst(I32, index.as_u32() as i64);
+        builder
+            .ins()
+            .call(libcall, &[vmctx, global_index_arg, value]);
 
         Ok(())
     }
@@ -1750,18 +1842,23 @@ impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'m
 
         let min_size = self.module.memory_plans[index]
             .memory
-            .minimum
-            .checked_mul(u64::from(WASM_PAGE_SIZE))
-            .unwrap_or_else(|| {
+            .minimum_byte_size()
+            .unwrap_or_else(|_| {
                 // The only valid Wasm memory size that won't fit in a 64-bit
                 // integer is the maximum memory64 size (2^64) which is one
                 // larger than `u64::MAX` (2^64 - 1). In this case, just say the
                 // minimum heap size is `u64::MAX`.
                 debug_assert_eq!(self.module.memory_plans[index].memory.minimum, 1 << 48);
+                debug_assert_eq!(self.module.memory_plans[index].memory.page_size(), 1 << 16);
                 u64::MAX
             });
 
-        let (ptr, base_offset, current_length_offset) = {
+        let max_size = self.module.memory_plans[index]
+            .memory
+            .maximum_byte_size()
+            .ok();
+
+        let (ptr, base_offset, current_length_offset, ptr_memtype) = {
             let vmctx = self.vmctx(func);
             if let Some(def_index) = self.module.defined_memory_index(index) {
                 if is_shared {
@@ -1770,16 +1867,17 @@ impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'m
                     // VMMemoryDefinition` to it and dereference that when
                     // atomically growing it.
                     let from_offset = self.offsets.vmctx_vmmemory_pointer(def_index);
-                    let memory = func.create_global_value(ir::GlobalValueData::Load {
-                        base: vmctx,
-                        offset: Offset32::new(i32::try_from(from_offset).unwrap()),
-                        global_type: pointer_type,
-                        readonly: true,
-                    });
+                    let (memory, def_mt) = self.load_pointer_with_memtypes(
+                        func,
+                        vmctx,
+                        from_offset,
+                        true,
+                        self.pcc_vmctx_memtype,
+                    );
                     let base_offset = i32::from(self.offsets.ptr.vmmemory_definition_base());
                     let current_length_offset =
                         i32::from(self.offsets.ptr.vmmemory_definition_current_length());
-                    (memory, base_offset, current_length_offset)
+                    (memory, base_offset, current_length_offset, def_mt)
                 } else {
                     let owned_index = self.module.owned_memory_index(def_index);
                     let owned_base_offset =
@@ -1789,72 +1887,196 @@ impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'m
                         .vmctx_vmmemory_definition_current_length(owned_index);
                     let current_base_offset = i32::try_from(owned_base_offset).unwrap();
                     let current_length_offset = i32::try_from(owned_length_offset).unwrap();
-                    (vmctx, current_base_offset, current_length_offset)
+                    (
+                        vmctx,
+                        current_base_offset,
+                        current_length_offset,
+                        self.pcc_vmctx_memtype,
+                    )
                 }
             } else {
                 let from_offset = self.offsets.vmctx_vmmemory_import_from(index);
-                let memory = func.create_global_value(ir::GlobalValueData::Load {
-                    base: vmctx,
-                    offset: Offset32::new(i32::try_from(from_offset).unwrap()),
-                    global_type: pointer_type,
-                    readonly: true,
-                });
+                let (memory, def_mt) = self.load_pointer_with_memtypes(
+                    func,
+                    vmctx,
+                    from_offset,
+                    true,
+                    self.pcc_vmctx_memtype,
+                );
                 let base_offset = i32::from(self.offsets.ptr.vmmemory_definition_base());
                 let current_length_offset =
                     i32::from(self.offsets.ptr.vmmemory_definition_current_length());
-                (memory, base_offset, current_length_offset)
+                (memory, base_offset, current_length_offset, def_mt)
             }
         };
 
+        let page_size_log2 = self.module.memory_plans[index].memory.page_size_log2;
+
         // If we have a declared maximum, we can make this a "static" heap, which is
         // allocated up front and never moved.
-        let (offset_guard_size, heap_style, readonly_base) = match self.module.memory_plans[index] {
-            MemoryPlan {
-                style: MemoryStyle::Dynamic { .. },
-                offset_guard_size,
-                pre_guard_size: _,
-                memory: _,
-            } => {
-                let heap_bound = func.create_global_value(ir::GlobalValueData::Load {
-                    base: ptr,
-                    offset: Offset32::new(current_length_offset),
-                    global_type: pointer_type,
-                    readonly: false,
-                });
-                (
+        let (offset_guard_size, heap_style, readonly_base, base_fact, memory_type) =
+            match self.module.memory_plans[index] {
+                MemoryPlan {
+                    style: MemoryStyle::Dynamic { .. },
                     offset_guard_size,
-                    HeapStyle::Dynamic {
-                        bound_gv: heap_bound,
-                    },
-                    false,
-                )
-            }
-            MemoryPlan {
-                style: MemoryStyle::Static { bound },
-                offset_guard_size,
-                pre_guard_size: _,
-                memory: _,
-            } => (
-                offset_guard_size,
-                HeapStyle::Static {
-                    bound: u64::from(bound) * u64::from(WASM_PAGE_SIZE),
-                },
-                true,
-            ),
-        };
+                    pre_guard_size: _,
+                    memory: _,
+                } => {
+                    let heap_bound = func.create_global_value(ir::GlobalValueData::Load {
+                        base: ptr,
+                        offset: Offset32::new(current_length_offset),
+                        global_type: pointer_type,
+                        flags: MemFlags::trusted(),
+                    });
 
+                    let (base_fact, data_mt) = if let Some(ptr_memtype) = ptr_memtype {
+                        // Create a memtype representing the untyped memory region.
+                        let data_mt = func.create_memory_type(ir::MemoryTypeData::DynamicMemory {
+                            gv: heap_bound,
+                            size: offset_guard_size,
+                        });
+                        // This fact applies to any pointer to the start of the memory.
+                        let base_fact = ir::Fact::dynamic_base_ptr(data_mt);
+                        // This fact applies to the length.
+                        let length_fact = ir::Fact::global_value(
+                            u16::try_from(self.isa.pointer_type().bits()).unwrap(),
+                            heap_bound,
+                        );
+                        // Create a field in the vmctx for the base pointer.
+                        match &mut func.memory_types[ptr_memtype] {
+                            ir::MemoryTypeData::Struct { size, fields } => {
+                                let base_offset = u64::try_from(base_offset).unwrap();
+                                fields.push(ir::MemoryTypeField {
+                                    offset: base_offset,
+                                    ty: self.isa.pointer_type(),
+                                    // Read-only field from the PoV of PCC checks:
+                                    // don't allow stores to this field. (Even if
+                                    // it is a dynamic memory whose base can
+                                    // change, that update happens inside the
+                                    // runtime, not in generated code.)
+                                    readonly: true,
+                                    fact: Some(base_fact.clone()),
+                                });
+                                let current_length_offset =
+                                    u64::try_from(current_length_offset).unwrap();
+                                fields.push(ir::MemoryTypeField {
+                                    offset: current_length_offset,
+                                    ty: self.isa.pointer_type(),
+                                    // As above, read-only; only the runtime modifies it.
+                                    readonly: true,
+                                    fact: Some(length_fact),
+                                });
+
+                                let pointer_size = u64::from(self.isa.pointer_type().bytes());
+                                let fields_end = std::cmp::max(
+                                    base_offset + pointer_size,
+                                    current_length_offset + pointer_size,
+                                );
+                                *size = std::cmp::max(*size, fields_end);
+                            }
+                            _ => {
+                                panic!("Bad memtype");
+                            }
+                        }
+                        // Apply a fact to the base pointer.
+                        (Some(base_fact), Some(data_mt))
+                    } else {
+                        (None, None)
+                    };
+
+                    (
+                        offset_guard_size,
+                        HeapStyle::Dynamic {
+                            bound_gv: heap_bound,
+                        },
+                        false,
+                        base_fact,
+                        data_mt,
+                    )
+                }
+                MemoryPlan {
+                    style:
+                        MemoryStyle::Static {
+                            byte_reservation: bound_bytes,
+                        },
+                    offset_guard_size,
+                    pre_guard_size: _,
+                    memory: _,
+                } => {
+                    let (base_fact, data_mt) = if let Some(ptr_memtype) = ptr_memtype {
+                        // Create a memtype representing the untyped memory region.
+                        let data_mt = func.create_memory_type(ir::MemoryTypeData::Memory {
+                            size: bound_bytes
+                                .checked_add(offset_guard_size)
+                                .expect("Memory plan has overflowing size plus guard"),
+                        });
+                        // This fact applies to any pointer to the start of the memory.
+                        let base_fact = Fact::Mem {
+                            ty: data_mt,
+                            min_offset: 0,
+                            max_offset: 0,
+                            nullable: false,
+                        };
+                        // Create a field in the vmctx for the base pointer.
+                        match &mut func.memory_types[ptr_memtype] {
+                            ir::MemoryTypeData::Struct { size, fields } => {
+                                let offset = u64::try_from(base_offset).unwrap();
+                                fields.push(ir::MemoryTypeField {
+                                    offset,
+                                    ty: self.isa.pointer_type(),
+                                    // Read-only field from the PoV of PCC checks:
+                                    // don't allow stores to this field. (Even if
+                                    // it is a dynamic memory whose base can
+                                    // change, that update happens inside the
+                                    // runtime, not in generated code.)
+                                    readonly: true,
+                                    fact: Some(base_fact.clone()),
+                                });
+                                *size = std::cmp::max(
+                                    *size,
+                                    offset + u64::from(self.isa.pointer_type().bytes()),
+                                );
+                            }
+                            _ => {
+                                panic!("Bad memtype");
+                            }
+                        }
+                        // Apply a fact to the base pointer.
+                        (Some(base_fact), Some(data_mt))
+                    } else {
+                        (None, None)
+                    };
+                    (
+                        offset_guard_size,
+                        HeapStyle::Static { bound: bound_bytes },
+                        true,
+                        base_fact,
+                        data_mt,
+                    )
+                }
+            };
+
+        let mut flags = MemFlags::trusted().with_checked();
+        if readonly_base {
+            flags.set_readonly();
+        }
         let heap_base = func.create_global_value(ir::GlobalValueData::Load {
             base: ptr,
             offset: Offset32::new(base_offset),
             global_type: pointer_type,
-            readonly: readonly_base,
+            flags,
         });
+        func.global_value_facts[heap_base] = base_fact;
+
         Ok(self.heaps.push(HeapData {
             base: heap_base,
             min_size,
+            max_size,
             offset_guard_size,
             style: heap_style,
             index_type: self.memory_index_type(index),
+            memory_type,
+            page_size_log2,
         }))
     }
 
@@ -1864,29 +2086,15 @@ impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'m
         index: GlobalIndex,
     ) -> WasmResult<GlobalVariable> {
         let ty = self.module.globals[index].wasm_ty;
-        match ty {
-            // Although `ExternRef`s live at the same memory location as any
-            // other type of global at the same index would, getting or setting
-            // them requires ref counting barriers. Therefore, we need to use
-            // `GlobalVariable::Custom`, as that is the only kind of
+
+        if ty.is_vmgcref_type() {
+            // Although reference-typed globals live at the same memory location as
+            // any other type of global at the same index would, getting or
+            // setting them requires ref counting barriers. Therefore, we need
+            // to use `GlobalVariable::Custom`, as that is the only kind of
             // `GlobalVariable` for which `cranelift-wasm` supports custom
             // access translation.
-            WasmType::Ref(WasmRefType {
-                heap_type: WasmHeapType::Extern,
-                ..
-            }) => return Ok(GlobalVariable::Custom),
-
-            // Funcrefs are represented as pointers which survive for the
-            // entire lifetime of the `Store` so there's no need for barriers.
-            // This means that they can fall through to memory as well.
-            WasmType::Ref(WasmRefType {
-                heap_type: WasmHeapType::Func | WasmHeapType::TypedFunc(_),
-                ..
-            }) => {}
-
-            // Value types all live in memory so let them fall through to a
-            // memory-based global.
-            WasmType::I32 | WasmType::I64 | WasmType::F32 | WasmType::F64 | WasmType::V128 => {}
+            return Ok(GlobalVariable::Custom);
         }
 
         let (gv, offset) = self.get_global_location(func, index);
@@ -1902,9 +2110,12 @@ impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'m
         func: &mut ir::Function,
         index: TypeIndex,
     ) -> WasmResult<ir::SigRef> {
-        let index = self.module.types[index].unwrap_function();
-        let sig = crate::wasm_call_signature(self.isa, &self.types[index], &self.tunables);
-        Ok(func.import_signature(sig))
+        let interned_index = self.module.types[index];
+        let wasm_func_ty = self.types[interned_index].unwrap_func();
+        let sig = crate::wasm_call_signature(self.isa, wasm_func_ty, &self.tunables);
+        let sig_ref = func.import_signature(sig);
+        self.sig_ref_to_ty[sig_ref] = Some(wasm_func_ty);
+        Ok(sig_ref)
     }
 
     fn make_direct_func(
@@ -1913,30 +2124,32 @@ impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'m
         index: FuncIndex,
     ) -> WasmResult<ir::FuncRef> {
         let sig = self.module.functions[index].signature;
-        let sig = crate::wasm_call_signature(self.isa, &self.types[sig], &self.tunables);
+        let wasm_func_ty = self.types[sig].unwrap_func();
+        let sig = crate::wasm_call_signature(self.isa, wasm_func_ty, &self.tunables);
         let signature = func.import_signature(sig);
+        self.sig_ref_to_ty[signature] = Some(wasm_func_ty);
         let name =
             ir::ExternalName::User(func.declare_imported_user_function(ir::UserExternalName {
-                namespace: 0,
+                namespace: crate::NS_WASM_FUNC,
                 index: index.as_u32(),
             }));
         Ok(func.import_function(ir::ExtFuncData {
             name,
             signature,
 
-            // The value of this flag determines the codegen for calls to this
-            // function. If this flag is `false` then absolute relocations will
+            // the value of this flag determines the codegen for calls to this
+            // function. if this flag is `false` then absolute relocations will
             // be generated for references to the function, which requires
-            // load-time relocation resolution. If this flag is set to `true`
+            // load-time relocation resolution. if this flag is set to `true`
             // then relative relocations are emitted which can be resolved at
             // object-link-time, just after all functions are compiled.
             //
-            // This flag is set to `true` for functions defined in the object
+            // this flag is set to `true` for functions defined in the object
             // we'll be defining in this compilation unit, or everything local
-            // to the wasm module. This means that between functions in a wasm
-            // module there's relative calls encoded. All calls external to a
+            // to the wasm module. this means that between functions in a wasm
+            // module there's relative calls encoded. all calls external to a
             // wasm module (e.g. imports or libcalls) are either encoded through
-            // the `VMContext` as relative jumps (hence no relocations) or
+            // the `vmcontext` as relative jumps (hence no relocations) or
             // they're libcalls with absolute relocations.
             colocated: self.module.defined_func_index(index).is_some(),
         }))
@@ -1946,20 +2159,12 @@ impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'m
         &mut self,
         builder: &mut FunctionBuilder,
         table_index: TableIndex,
-        table: ir::Table,
         ty_index: TypeIndex,
         sig_ref: ir::SigRef,
         callee: ir::Value,
         call_args: &[ir::Value],
-    ) -> WasmResult<ir::Inst> {
-        Call::new(builder, self).indirect_call(
-            table_index,
-            table,
-            ty_index,
-            sig_ref,
-            callee,
-            call_args,
-        )
+    ) -> WasmResult<Option<ir::Inst>> {
+        Call::new(builder, self).indirect_call(table_index, ty_index, sig_ref, callee, call_args)
     }
 
     fn translate_call(
@@ -1997,7 +2202,6 @@ impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'m
         &mut self,
         builder: &mut FunctionBuilder,
         table_index: TableIndex,
-        table: ir::Table,
         ty_index: TypeIndex,
         sig_ref: ir::SigRef,
         callee: ir::Value,
@@ -2005,7 +2209,6 @@ impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'m
     ) -> WasmResult<()> {
         Call::new_tail(builder, self).indirect_call(
             table_index,
-            table,
             ty_index,
             sig_ref,
             callee,
@@ -2032,23 +2235,16 @@ impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'m
         _heap: Heap,
         val: ir::Value,
     ) -> WasmResult<ir::Value> {
-        let func_sig = self
-            .builtin_function_signatures
-            .memory32_grow(&mut pos.func);
+        let memory_grow = self.builtin_functions.memory32_grow(&mut pos.func);
         let index_arg = index.index();
 
         let memory_index = pos.ins().iconst(I32, index_arg as i64);
-        let (vmctx, func_addr) = self.translate_load_builtin_function_address(
-            &mut pos,
-            BuiltinFunctionIndex::memory32_grow(),
-        );
+        let vmctx = self.vmctx_val(&mut pos);
 
         let val = self.cast_memory_index_to_i64(&mut pos, val, index);
-        let call_inst = pos
-            .ins()
-            .call_indirect(func_sig, func_addr, &[vmctx, val, memory_index]);
+        let call_inst = pos.ins().call(memory_grow, &[vmctx, val, memory_index]);
         let result = *pos.func.dfg.inst_results(call_inst).first().unwrap();
-        Ok(self.cast_pointer_to_memory_index(pos, result, index))
+        Ok(self.convert_memory_length_to_index_type(pos, result, index))
     }
 
     fn translate_memory_size(
@@ -2120,11 +2316,11 @@ impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'m
                 }
             }
         };
-        let current_length_in_pages = pos
-            .ins()
-            .udiv_imm(current_length_in_bytes, i64::from(WASM_PAGE_SIZE));
 
-        Ok(self.cast_pointer_to_memory_index(pos, current_length_in_pages, index))
+        let page_size_log2 = i64::from(self.module.memory_plans[index].memory.page_size_log2);
+        let current_length_in_pages = pos.ins().ushr_imm(current_length_in_bytes, page_size_log2);
+
+        Ok(self.convert_memory_length_to_index_type(pos, current_length_in_pages, index))
     }
 
     fn translate_memory_copy(
@@ -2138,10 +2334,9 @@ impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'m
         src: ir::Value,
         len: ir::Value,
     ) -> WasmResult<()> {
-        let (vmctx, func_addr) = self
-            .translate_load_builtin_function_address(&mut pos, BuiltinFunctionIndex::memory_copy());
+        let vmctx = self.vmctx_val(&mut pos);
 
-        let func_sig = self.builtin_function_signatures.memory_copy(&mut pos.func);
+        let memory_copy = self.builtin_functions.memory_copy(&mut pos.func);
         let dst = self.cast_memory_index_to_i64(&mut pos, dst, dst_index);
         let src = self.cast_memory_index_to_i64(&mut pos, src, src_index);
         // The length is 32-bit if either memory is 32-bit, but if they're both
@@ -2158,11 +2353,8 @@ impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'m
         };
         let src_index = pos.ins().iconst(I32, i64::from(src_index.as_u32()));
         let dst_index = pos.ins().iconst(I32, i64::from(dst_index.as_u32()));
-        pos.ins().call_indirect(
-            func_sig,
-            func_addr,
-            &[vmctx, dst_index, dst, src_index, src, len],
-        );
+        pos.ins()
+            .call(memory_copy, &[vmctx, dst_index, dst, src_index, src, len]);
 
         Ok(())
     }
@@ -2176,19 +2368,15 @@ impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'m
         val: ir::Value,
         len: ir::Value,
     ) -> WasmResult<()> {
-        let func_sig = self.builtin_function_signatures.memory_fill(&mut pos.func);
+        let memory_fill = self.builtin_functions.memory_fill(&mut pos.func);
         let dst = self.cast_memory_index_to_i64(&mut pos, dst, memory_index);
         let len = self.cast_memory_index_to_i64(&mut pos, len, memory_index);
         let memory_index_arg = pos.ins().iconst(I32, i64::from(memory_index.as_u32()));
 
-        let (vmctx, func_addr) = self
-            .translate_load_builtin_function_address(&mut pos, BuiltinFunctionIndex::memory_fill());
+        let vmctx = self.vmctx_val(&mut pos);
 
-        pos.ins().call_indirect(
-            func_sig,
-            func_addr,
-            &[vmctx, memory_index_arg, dst, val, len],
-        );
+        pos.ins()
+            .call(memory_fill, &[vmctx, memory_index_arg, dst, val, len]);
 
         Ok(())
     }
@@ -2203,18 +2391,17 @@ impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'m
         src: ir::Value,
         len: ir::Value,
     ) -> WasmResult<()> {
-        let (func_sig, func_idx) = self.get_memory_init_func(&mut pos.func);
+        let memory_init = self.builtin_functions.memory_init(&mut pos.func);
 
         let memory_index_arg = pos.ins().iconst(I32, memory_index.index() as i64);
         let seg_index_arg = pos.ins().iconst(I32, seg_index as i64);
 
-        let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx);
+        let vmctx = self.vmctx_val(&mut pos);
 
         let dst = self.cast_memory_index_to_i64(&mut pos, dst, memory_index);
 
-        pos.ins().call_indirect(
-            func_sig,
-            func_addr,
+        pos.ins().call(
+            memory_init,
             &[vmctx, memory_index_arg, seg_index_arg, dst, src, len],
         );
 
@@ -2222,46 +2409,40 @@ impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'m
     }
 
     fn translate_data_drop(&mut self, mut pos: FuncCursor, seg_index: u32) -> WasmResult<()> {
-        let (func_sig, func_idx) = self.get_data_drop_func(&mut pos.func);
+        let data_drop = self.builtin_functions.data_drop(&mut pos.func);
         let seg_index_arg = pos.ins().iconst(I32, seg_index as i64);
-        let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx);
-        pos.ins()
-            .call_indirect(func_sig, func_addr, &[vmctx, seg_index_arg]);
+        let vmctx = self.vmctx_val(&mut pos);
+        pos.ins().call(data_drop, &[vmctx, seg_index_arg]);
         Ok(())
     }
 
     fn translate_table_size(
         &mut self,
-        mut pos: FuncCursor,
-        _table_index: TableIndex,
-        table: ir::Table,
+        pos: FuncCursor,
+        table_index: TableIndex,
     ) -> WasmResult<ir::Value> {
-        let size_gv = pos.func.tables[table].bound_gv;
-        Ok(pos.ins().global_value(ir::types::I32, size_gv))
+        self.ensure_table_exists(pos.func, table_index);
+        let table_data = self.tables[table_index].as_ref().unwrap();
+        Ok(table_data.bound.bound(pos, ir::types::I32))
     }
 
     fn translate_table_copy(
         &mut self,
         mut pos: FuncCursor,
         dst_table_index: TableIndex,
-        _dst_table: ir::Table,
         src_table_index: TableIndex,
-        _src_table: ir::Table,
         dst: ir::Value,
         src: ir::Value,
         len: ir::Value,
     ) -> WasmResult<()> {
-        let (func_sig, dst_table_index_arg, src_table_index_arg, func_idx) =
+        let (table_copy, dst_table_index_arg, src_table_index_arg) =
             self.get_table_copy_func(&mut pos.func, dst_table_index, src_table_index);
 
         let dst_table_index_arg = pos.ins().iconst(I32, dst_table_index_arg as i64);
         let src_table_index_arg = pos.ins().iconst(I32, src_table_index_arg as i64);
-
-        let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx);
-
-        pos.ins().call_indirect(
-            func_sig,
-            func_addr,
+        let vmctx = self.vmctx_val(&mut pos);
+        pos.ins().call(
+            table_copy,
             &[
                 vmctx,
                 dst_table_index_arg,
@@ -2280,22 +2461,16 @@ impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'m
         mut pos: FuncCursor,
         seg_index: u32,
         table_index: TableIndex,
-        _table: ir::Table,
         dst: ir::Value,
         src: ir::Value,
         len: ir::Value,
     ) -> WasmResult<()> {
-        let (func_sig, table_index_arg, func_idx) =
-            self.get_table_init_func(&mut pos.func, table_index);
-
-        let table_index_arg = pos.ins().iconst(I32, table_index_arg as i64);
-        let seg_index_arg = pos.ins().iconst(I32, seg_index as i64);
-
-        let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx);
-
-        pos.ins().call_indirect(
-            func_sig,
-            func_addr,
+        let table_init = self.builtin_functions.table_init(&mut pos.func);
+        let table_index_arg = pos.ins().iconst(I32, i64::from(table_index.as_u32()));
+        let seg_index_arg = pos.ins().iconst(I32, i64::from(seg_index));
+        let vmctx = self.vmctx_val(&mut pos);
+        pos.ins().call(
+            table_init,
             &[vmctx, table_index_arg, seg_index_arg, dst, src, len],
         );
 
@@ -2303,15 +2478,10 @@ impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'m
     }
 
     fn translate_elem_drop(&mut self, mut pos: FuncCursor, elem_index: u32) -> WasmResult<()> {
-        let (func_sig, func_idx) = self.get_elem_drop_func(&mut pos.func);
-
+        let elem_drop = self.builtin_functions.elem_drop(&mut pos.func);
         let elem_index_arg = pos.ins().iconst(I32, elem_index as i64);
-
-        let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx);
-
-        pos.ins()
-            .call_indirect(func_sig, func_addr, &[vmctx, elem_index_arg]);
-
+        let vmctx = self.vmctx_val(&mut pos);
+        pos.ins().call(elem_drop, &[vmctx, elem_index_arg]);
         Ok(())
     }
 
@@ -2324,22 +2494,31 @@ impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'m
         expected: ir::Value,
         timeout: ir::Value,
     ) -> WasmResult<ir::Value> {
-        let addr = self.cast_memory_index_to_i64(&mut pos, addr, memory_index);
-        let implied_ty = pos.func.dfg.value_type(expected);
-        let (func_sig, memory_index, func_idx) =
-            self.get_memory_atomic_wait(&mut pos.func, memory_index, implied_ty);
+        #[cfg(feature = "threads")]
+        {
+            let addr = self.cast_memory_index_to_i64(&mut pos, addr, memory_index);
+            let implied_ty = pos.func.dfg.value_type(expected);
+            let (wait_func, memory_index) =
+                self.get_memory_atomic_wait(&mut pos.func, memory_index, implied_ty);
 
-        let memory_index_arg = pos.ins().iconst(I32, memory_index as i64);
+            let memory_index_arg = pos.ins().iconst(I32, memory_index as i64);
 
-        let (vmctx, func_addr) = self.translate_load_builtin_function_address(&mut pos, func_idx);
+            let vmctx = self.vmctx_val(&mut pos);
 
-        let call_inst = pos.ins().call_indirect(
-            func_sig,
-            func_addr,
-            &[vmctx, memory_index_arg, addr, expected, timeout],
-        );
+            let call_inst = pos.ins().call(
+                wait_func,
+                &[vmctx, memory_index_arg, addr, expected, timeout],
+            );
 
-        Ok(*pos.func.dfg.inst_results(call_inst).first().unwrap())
+            Ok(*pos.func.dfg.inst_results(call_inst).first().unwrap())
+        }
+        #[cfg(not(feature = "threads"))]
+        {
+            let _ = (&mut pos, memory_index, addr, expected, timeout);
+            Err(wasmtime_environ::WasmError::Unsupported(
+                "threads support disabled at compile time".to_string(),
+            ))
+        }
     }
 
     fn translate_atomic_notify(
@@ -2350,23 +2529,26 @@ impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'m
         addr: ir::Value,
         count: ir::Value,
     ) -> WasmResult<ir::Value> {
-        let addr = self.cast_memory_index_to_i64(&mut pos, addr, memory_index);
-        let func_sig = self
-            .builtin_function_signatures
-            .memory_atomic_notify(&mut pos.func);
-
-        let memory_index_arg = pos.ins().iconst(I32, memory_index.index() as i64);
-
-        let (vmctx, func_addr) = self.translate_load_builtin_function_address(
-            &mut pos,
-            BuiltinFunctionIndex::memory_atomic_notify(),
-        );
+        #[cfg(feature = "threads")]
+        {
+            let addr = self.cast_memory_index_to_i64(&mut pos, addr, memory_index);
+            let atomic_notify = self.builtin_functions.memory_atomic_notify(&mut pos.func);
 
-        let call_inst =
-            pos.ins()
-                .call_indirect(func_sig, func_addr, &[vmctx, memory_index_arg, addr, count]);
+            let memory_index_arg = pos.ins().iconst(I32, memory_index.index() as i64);
+            let vmctx = self.vmctx_val(&mut pos);
+            let call_inst = pos
+                .ins()
+                .call(atomic_notify, &[vmctx, memory_index_arg, addr, count]);
 
-        Ok(*pos.func.dfg.inst_results(call_inst).first().unwrap())
+            Ok(*pos.func.dfg.inst_results(call_inst).first().unwrap())
+        }
+        #[cfg(not(feature = "threads"))]
+        {
+            let _ = (&mut pos, memory_index, addr, count);
+            Err(wasmtime_environ::WasmError::Unsupported(
+                "threads support disabled at compile time".to_string(),
+            ))
+        }
     }
 
     fn translate_loop_header(&mut self, builder: &mut FunctionBuilder) -> WasmResult<()> {
@@ -2439,11 +2621,14 @@ impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'m
             self.epoch_function_entry(builder);
         }
 
-        let func_name = self.current_func_name(builder);
-        if func_name == Some("malloc") {
-            self.check_malloc_start(builder);
-        } else if func_name == Some("free") {
-            self.check_free_start(builder);
+        #[cfg(feature = "wmemcheck")]
+        if self.wmemcheck {
+            let func_name = self.current_func_name(builder);
+            if func_name == Some("malloc") {
+                self.check_malloc_start(builder);
+            } else if func_name == Some("free") {
+                self.check_free_start(builder);
+            }
         }
 
         Ok(())
@@ -2488,102 +2673,85 @@ impl<'module_environment> cranelift_wasm::FuncEnvironment for FuncEnvironment<'m
         self.isa.has_x86_pmaddubsw_lowering()
     }
 
-    cfg_if! {
-        if #[cfg(feature = "wmemcheck")] {
-            fn handle_before_return(
-                &mut self,
-                retvals: &[Value],
-                builder: &mut FunctionBuilder,
-            ) {
-                if self.wmemcheck {
-                    let func_name = self.current_func_name(builder);
-                    if func_name == Some("malloc") {
-                        self.hook_malloc_exit(builder, retvals);
-                    } else if func_name == Some("free") {
-                        self.hook_free_exit(builder);
-                    }
-                }
-            }
-
-            fn before_load(&mut self, builder: &mut FunctionBuilder, val_size: u8, addr: ir::Value, offset: u64) {
-                if self.wmemcheck {
-                    let check_load_sig = self.builtin_function_signatures.check_load(builder.func);
-                    let (vmctx, check_load) = self.translate_load_builtin_function_address(
-                        &mut builder.cursor(),
-                        BuiltinFunctionIndex::check_load(),
-                    );
-                    let num_bytes = builder.ins().iconst(I32, val_size as i64);
-                    let offset_val = builder.ins().iconst(I64, offset as i64);
-                    builder
-                        .ins()
-                        .call_indirect(check_load_sig, check_load, &[vmctx, num_bytes, addr, offset_val]);
-                }
-            }
-
-            fn before_store(&mut self, builder: &mut FunctionBuilder, val_size: u8, addr: ir::Value, offset: u64) {
-                if self.wmemcheck {
-                    let check_store_sig = self.builtin_function_signatures.check_store(builder.func);
-                    let (vmctx, check_store) = self.translate_load_builtin_function_address(
-                        &mut builder.cursor(),
-                        BuiltinFunctionIndex::check_store(),
-                    );
-                    let num_bytes = builder.ins().iconst(I32, val_size as i64);
-                    let offset_val = builder.ins().iconst(I64, offset as i64);
-                    builder
-                        .ins()
-                        .call_indirect(check_store_sig, check_store, &[vmctx, num_bytes, addr, offset_val]);
-                }
-            }
-
-            fn update_global(&mut self, builder: &mut FunctionBuilder, global_index: u32, value: ir::Value) {
-                if self.wmemcheck {
-                    if global_index == 0 {
-                        // We are making the assumption that global 0 is the auxiliary stack pointer.
-                        let update_stack_pointer_sig = self.builtin_function_signatures.update_stack_pointer(builder.func);
-                        let (vmctx, update_stack_pointer) = self.translate_load_builtin_function_address(
-                            &mut builder.cursor(),
-                            BuiltinFunctionIndex::update_stack_pointer(),
-                        );
-                        builder
-                            .ins()
-                            .call_indirect(update_stack_pointer_sig, update_stack_pointer, &[vmctx, value]);
-                    }
-                }
-            }
-
-            fn before_memory_grow(&mut self, builder: &mut FunctionBuilder, num_pages: ir::Value, mem_index: MemoryIndex) {
-                if self.wmemcheck && mem_index.as_u32() == 0 {
-                    let update_mem_size_sig = self.builtin_function_signatures.update_mem_size(builder.func);
-                    let (vmctx, update_mem_size) = self.translate_load_builtin_function_address(
-                        &mut builder.cursor(),
-                        BuiltinFunctionIndex::update_mem_size(),
-                    );
-                    builder
-                        .ins()
-                        .call_indirect(update_mem_size_sig, update_mem_size, &[vmctx, num_pages]);
-                }
-            }
-        } else {
-            fn handle_before_return(&mut self, _retvals: &[Value], builder: &mut FunctionBuilder) {
-                let _ = self.builtin_function_signatures.check_malloc(builder.func);
-                let _ = self.builtin_function_signatures.check_free(builder.func);
+    #[cfg(feature = "wmemcheck")]
+    fn handle_before_return(&mut self, retvals: &[ir::Value], builder: &mut FunctionBuilder) {
+        if self.wmemcheck {
+            let func_name = self.current_func_name(builder);
+            if func_name == Some("malloc") {
+                self.hook_malloc_exit(builder, retvals);
+            } else if func_name == Some("free") {
+                self.hook_free_exit(builder);
             }
+        }
+    }
 
-            fn before_load(&mut self, builder: &mut FunctionBuilder, _val_size: u8, _addr: ir::Value, _offset: u64) {
-                let _ = self.builtin_function_signatures.check_load(builder.func);
-            }
+    #[cfg(feature = "wmemcheck")]
+    fn before_load(
+        &mut self,
+        builder: &mut FunctionBuilder,
+        val_size: u8,
+        addr: ir::Value,
+        offset: u64,
+    ) {
+        if self.wmemcheck {
+            let check_load = self.builtin_functions.check_load(builder.func);
+            let vmctx = self.vmctx_val(&mut builder.cursor());
+            let num_bytes = builder.ins().iconst(I32, val_size as i64);
+            let offset_val = builder.ins().iconst(I64, offset as i64);
+            builder
+                .ins()
+                .call(check_load, &[vmctx, num_bytes, addr, offset_val]);
+        }
+    }
 
-            fn before_store(&mut self, builder: &mut FunctionBuilder, _val_size: u8, _addr: ir::Value, _offset: u64) {
-                let _ = self.builtin_function_signatures.check_store(builder.func);
-            }
+    #[cfg(feature = "wmemcheck")]
+    fn before_store(
+        &mut self,
+        builder: &mut FunctionBuilder,
+        val_size: u8,
+        addr: ir::Value,
+        offset: u64,
+    ) {
+        if self.wmemcheck {
+            let check_store = self.builtin_functions.check_store(builder.func);
+            let vmctx = self.vmctx_val(&mut builder.cursor());
+            let num_bytes = builder.ins().iconst(I32, val_size as i64);
+            let offset_val = builder.ins().iconst(I64, offset as i64);
+            builder
+                .ins()
+                .call(check_store, &[vmctx, num_bytes, addr, offset_val]);
+        }
+    }
 
-            fn update_global(&mut self, builder: &mut FunctionBuilder, _global_index: u32, _value: ir::Value) {
-                let _ = self.builtin_function_signatures.update_stack_pointer(builder.func);
+    #[cfg(feature = "wmemcheck")]
+    fn update_global(
+        &mut self,
+        builder: &mut FunctionBuilder,
+        global_index: u32,
+        value: ir::Value,
+    ) {
+        if self.wmemcheck {
+            if global_index == 0 {
+                // We are making the assumption that global 0 is the auxiliary stack pointer.
+                let update_stack_pointer =
+                    self.builtin_functions.update_stack_pointer(builder.func);
+                let vmctx = self.vmctx_val(&mut builder.cursor());
+                builder.ins().call(update_stack_pointer, &[vmctx, value]);
             }
+        }
+    }
 
-            fn before_memory_grow(&mut self, builder: &mut FunctionBuilder, _num_pages: Value, _mem_index: MemoryIndex) {
-                let _ = self.builtin_function_signatures.update_mem_size(builder.func);
-            }
+    #[cfg(feature = "wmemcheck")]
+    fn before_memory_grow(
+        &mut self,
+        builder: &mut FunctionBuilder,
+        num_pages: ir::Value,
+        mem_index: MemoryIndex,
+    ) {
+        if self.wmemcheck && mem_index.as_u32() == 0 {
+            let update_mem_size = self.builtin_functions.update_mem_size(builder.func);
+            let vmctx = self.vmctx_val(&mut builder.cursor());
+            builder.ins().call(update_mem_size, &[vmctx, num_pages]);
         }
     }
 }
diff --git a/crates/cranelift/src/gc.rs b/crates/cranelift/src/gc.rs
new file mode 100644
index 000000000000..0583dfee0221
--- /dev/null
+++ b/crates/cranelift/src/gc.rs
@@ -0,0 +1,189 @@
+//! Interface to compiling GC-related things.
+//!
+//! This module and its interface are implemented twice: once when the `gc`
+//! cargo feature is enabled and once when the feature is disabled. The goal is
+//! to have just a single `cfg(feature = "gc")` for the whole crate, which
+//! selects between these two implementations.
+
+use crate::func_environ::FuncEnvironment;
+use cranelift_codegen::ir;
+use cranelift_frontend::FunctionBuilder;
+use cranelift_wasm::{WasmHeapType, WasmRefType, WasmResult, WasmValType};
+
+#[cfg(feature = "gc")]
+mod enabled;
+#[cfg(feature = "gc")]
+use enabled as imp;
+
+#[cfg(not(feature = "gc"))]
+mod disabled;
+#[cfg(not(feature = "gc"))]
+use disabled as imp;
+
+/// Get the GC compiler configured for the given function environment.
+pub fn gc_compiler(func_env: &FuncEnvironment<'_>) -> Box<dyn GcCompiler> {
+    imp::gc_compiler(func_env)
+}
+
+/// Load a `*mut VMGcRef` into a virtual register, without any GC barriers.
+///
+/// The resulting value is an instance of the function environment's type for
+/// GC-managed references, aka `i32`. Note that a `VMGcRef` is always 4-bytes
+/// large, even when targeting 64-bit architectures.
+pub fn unbarriered_load_gc_ref(
+    func_env: &FuncEnvironment<'_>,
+    builder: &mut FunctionBuilder<'_>,
+    ty: WasmHeapType,
+    src: ir::Value,
+    flags: ir::MemFlags,
+) -> WasmResult<ir::Value> {
+    imp::unbarriered_load_gc_ref(func_env, builder, ty, src, flags)
+}
+
+/// Store `*dst = gc_ref`, without any GC barriers.
+///
+/// `dst` is a `*mut VMGcRef`.
+///
+/// `gc_ref` is an instance of the function environment's type for GC-managed
+/// references, aka `i32`. Note that a `VMGcRef` is always 4-bytes large, even
+/// when targeting 64-bit architectures.
+pub fn unbarriered_store_gc_ref(
+    func_env: &FuncEnvironment<'_>,
+    builder: &mut FunctionBuilder<'_>,
+    ty: WasmHeapType,
+    dst: ir::Value,
+    gc_ref: ir::Value,
+    flags: ir::MemFlags,
+) -> WasmResult<()> {
+    imp::unbarriered_store_gc_ref(func_env, builder, ty, dst, gc_ref, flags)
+}
+
+/// Get the index and signature of the built-in function for doing `table.grow`
+/// on GC reference tables.
+pub fn gc_ref_table_grow_builtin(
+    ty: WasmHeapType,
+    func_env: &mut FuncEnvironment<'_>,
+    func: &mut ir::Function,
+) -> WasmResult<ir::FuncRef> {
+    debug_assert!(ty.is_vmgcref_type());
+    imp::gc_ref_table_grow_builtin(ty, func_env, func)
+}
+
+/// Get the index and signature of the built-in function for doing `table.fill`
+/// on GC reference tables.
+pub fn gc_ref_table_fill_builtin(
+    ty: WasmHeapType,
+    func_env: &mut FuncEnvironment<'_>,
+    func: &mut ir::Function,
+) -> WasmResult<ir::FuncRef> {
+    debug_assert!(ty.is_vmgcref_type());
+    imp::gc_ref_table_fill_builtin(ty, func_env, func)
+}
+
+/// Get the index and signature of the built-in function for doing `global.get`
+/// on a GC reference global.
+pub fn gc_ref_global_get_builtin(
+    ty: WasmValType,
+    func_env: &mut FuncEnvironment<'_>,
+    func: &mut ir::Function,
+) -> WasmResult<ir::FuncRef> {
+    debug_assert!(ty.is_vmgcref_type());
+    imp::gc_ref_global_get_builtin(ty, func_env, func)
+}
+
+/// Get the index and signature of the built-in function for doing `global.set`
+/// on a GC reference global.
+pub fn gc_ref_global_set_builtin(
+    ty: WasmValType,
+    func_env: &mut FuncEnvironment<'_>,
+    func: &mut ir::Function,
+) -> WasmResult<ir::FuncRef> {
+    debug_assert!(ty.is_vmgcref_type());
+    imp::gc_ref_global_set_builtin(ty, func_env, func)
+}
+
+/// A trait for different collectors to emit any GC barriers they might require.
+pub trait GcCompiler {
+    /// Emit a read barrier for when we are cloning a GC reference onto the Wasm
+    /// stack.
+    ///
+    /// This is used, for example, when reading from a global or a table
+    /// element.
+    ///
+    /// In pseudocode, this is the following operation:
+    ///
+    /// ```ignore
+    /// x = *src;
+    /// ```
+    ///
+    /// Parameters:
+    ///
+    /// * `func_env`: The function environment that this GC compiler is
+    ///   operating within.
+    ///
+    /// * `builder`: Function builder. Currently at the position where the read
+    ///   should be inserted. Upon return, should be positioned where control
+    ///   continues just after the read completes. Any intermediate blocks
+    ///   created in the process of emitting the read barrier should be added to
+    ///   the layout and sealed.
+    ///
+    /// * `ty`: The Wasm reference type that is being read.
+    ///
+    /// * `src`: A pointer to the GC reference that should be read; this is an
+    ///   instance of a `*mut Option<VMGcRef>`.
+    ///
+    /// * `flags`: The memory flags that should be used when accessing `src`.
+    ///
+    /// This method should return the cloned GC reference (an instance of
+    /// `VMGcRef`) of type `i32`.
+    fn translate_read_gc_reference(
+        &mut self,
+        func_env: &mut FuncEnvironment<'_>,
+        builder: &mut FunctionBuilder,
+        ty: WasmRefType,
+        src: ir::Value,
+        flags: ir::MemFlags,
+    ) -> WasmResult<ir::Value>;
+
+    /// Emit a write barrier for when we are writing a GC reference over another
+    /// GC reference.
+    ///
+    /// This is used, for example, when writing to a global or a table element.
+    ///
+    /// In pseudocode, this is the following operation:
+    ///
+    /// ```ignore
+    /// *dst = new_val;
+    /// ```
+    ///
+    /// Parameters:
+    ///
+    /// * `func_env`: The function environment that this GC compiler is
+    ///   operating within.
+    ///
+    /// * `builder`: Function builder. Currently at the position where the write
+    ///   should be inserted. Upon return, should be positioned where control
+    ///   continues just after the write completes. Any intermediate blocks
+    ///   created in the process of emitting the read barrier should be added to
+    ///   the layout and sealed.
+    ///
+    /// * `ty`: The Wasm reference type that is being written.
+    ///
+    /// * `dst`: A pointer to the GC reference that will be overwritten; note
+    ///   that is this is an instance of a `*mut VMGcRef`, *not* a `VMGcRef`
+    ///   itself or a `*mut VMGcHeader`!
+    ///
+    /// * `new_val`: The new value that should be written into `dst`. This is a
+    ///   `VMGcRef` of Cranelift type `i32`; not a `*mut VMGcRef`.
+    ///
+    /// * `flags`: The memory flags that should be used when accessing `dst`.
+    fn translate_write_gc_reference(
+        &mut self,
+        func_env: &mut FuncEnvironment<'_>,
+        builder: &mut FunctionBuilder,
+        ty: WasmRefType,
+        dst: ir::Value,
+        new_val: ir::Value,
+        flags: ir::MemFlags,
+    ) -> WasmResult<()>;
+}
diff --git a/crates/cranelift/src/gc/disabled.rs b/crates/cranelift/src/gc/disabled.rs
new file mode 100644
index 000000000000..308806299fde
--- /dev/null
+++ b/crates/cranelift/src/gc/disabled.rs
@@ -0,0 +1,116 @@
+//! `GcCompiler` implementation when GC support is disabled.
+
+use super::GcCompiler;
+use crate::func_environ::FuncEnvironment;
+use cranelift_codegen::ir;
+use cranelift_frontend::FunctionBuilder;
+use cranelift_wasm::{wasm_unsupported, WasmHeapType, WasmRefType, WasmResult, WasmValType};
+
+/// Get the default GC compiler.
+pub fn gc_compiler(_: &FuncEnvironment<'_>) -> Box<dyn GcCompiler> {
+    Box::new(DisabledGcCompiler)
+}
+
+pub fn unbarriered_load_gc_ref(
+    _func_env: &FuncEnvironment<'_>,
+    _builder: &mut FunctionBuilder,
+    ty: WasmHeapType,
+    _ptr_to_gc_ref: ir::Value,
+    _flags: ir::MemFlags,
+) -> WasmResult<ir::Value> {
+    Err(wasm_unsupported!(
+        "support for `{ty}` references disabled at compile time because the `gc` cargo \
+         feature was not enabled"
+    ))
+}
+
+pub fn unbarriered_store_gc_ref(
+    _func_env: &FuncEnvironment<'_>,
+    _builder: &mut FunctionBuilder<'_>,
+    ty: WasmHeapType,
+    _dst: ir::Value,
+    _gc_ref: ir::Value,
+    _flags: ir::MemFlags,
+) -> WasmResult<()> {
+    Err(wasm_unsupported!(
+        "support for `{ty}` references disabled at compile time because the `gc` cargo \
+         feature was not enabled"
+    ))
+}
+
+pub fn gc_ref_table_grow_builtin(
+    ty: WasmHeapType,
+    _func_env: &mut FuncEnvironment<'_>,
+    _func: &mut ir::Function,
+) -> WasmResult<ir::FuncRef> {
+    Err(wasm_unsupported!(
+        "support for `{ty}` references disabled at compile time because the `gc` cargo \
+         feature was not enabled"
+    ))
+}
+
+pub fn gc_ref_table_fill_builtin(
+    ty: WasmHeapType,
+    _func_env: &mut FuncEnvironment<'_>,
+    _func: &mut ir::Function,
+) -> WasmResult<ir::FuncRef> {
+    Err(wasm_unsupported!(
+        "support for `{ty}` references disabled at compile time because the `gc` cargo \
+         feature was not enabled"
+    ))
+}
+
+pub fn gc_ref_global_get_builtin(
+    ty: WasmValType,
+    _func_env: &mut FuncEnvironment<'_>,
+    _func: &mut ir::Function,
+) -> WasmResult<ir::FuncRef> {
+    Err(wasm_unsupported!(
+        "support for `{ty}` disabled at compile time because the `gc` cargo \
+         feature was not enabled"
+    ))
+}
+
+pub fn gc_ref_global_set_builtin(
+    ty: WasmValType,
+    _func_env: &mut FuncEnvironment<'_>,
+    _func: &mut ir::Function,
+) -> WasmResult<ir::FuncRef> {
+    Err(wasm_unsupported!(
+        "support for `{ty}` disabled at compile time because the `gc` cargo \
+         feature was not enabled"
+    ))
+}
+
+struct DisabledGcCompiler;
+
+impl GcCompiler for DisabledGcCompiler {
+    fn translate_read_gc_reference(
+        &mut self,
+        _func_env: &mut FuncEnvironment<'_>,
+        _builder: &mut FunctionBuilder,
+        ty: WasmRefType,
+        _src: ir::Value,
+        _flags: ir::MemFlags,
+    ) -> WasmResult<ir::Value> {
+        Err(wasm_unsupported!(
+            "support for `{ty}` disabled at compile time because the `gc` cargo \
+             feature was not enabled"
+        ))
+    }
+
+    fn translate_write_gc_reference(
+        &mut self,
+        _func_env: &mut FuncEnvironment<'_>,
+        _builder: &mut FunctionBuilder,
+        ty: WasmRefType,
+        _dst: ir::Value,
+        _new_val: ir::Value,
+        _flags: ir::MemFlags,
+    ) -> WasmResult<()> {
+        Err(wasm_unsupported!(
+            "support for `{ty}` disabled at compile time because the `gc` cargo \
+             feature was not enabled"
+        ))
+    }
+}
diff --git a/crates/cranelift/src/gc/enabled.rs b/crates/cranelift/src/gc/enabled.rs
new file mode 100644
index 000000000000..f91a2492c2b5
--- /dev/null
+++ b/crates/cranelift/src/gc/enabled.rs
@@ -0,0 +1,631 @@
+use super::GcCompiler;
+use crate::func_environ::FuncEnvironment;
+use cranelift_codegen::ir::{self, condcodes::IntCC, InstBuilder};
+use cranelift_frontend::FunctionBuilder;
+use cranelift_wasm::{
+    TargetEnvironment, WasmHeapTopType, WasmHeapType, WasmRefType, WasmResult, WasmValType,
+};
+use wasmtime_environ::{PtrSize, I31_DISCRIMINANT, NON_NULL_NON_I31_MASK};
+
+/// Get the default GC compiler.
+pub fn gc_compiler(_func_env: &FuncEnvironment<'_>) -> Box<dyn GcCompiler> {
+    Box::new(DrcCompiler)
+}
+
+pub fn unbarriered_load_gc_ref(
+    func_env: &FuncEnvironment<'_>,
+    builder: &mut FunctionBuilder,
+    ty: WasmHeapType,
+    ptr_to_gc_ref: ir::Value,
+    flags: ir::MemFlags,
+) -> WasmResult<ir::Value> {
+    debug_assert!({
+        let (_, needs_stack_map) = func_env.reference_type(ty);
+        needs_stack_map
+    });
+    let gc_ref = builder.ins().load(ir::types::I32, flags, ptr_to_gc_ref, 0);
+    builder.declare_value_needs_stack_map(gc_ref);
+    Ok(gc_ref)
+}
+
+pub fn unbarriered_store_gc_ref(
+    func_env: &FuncEnvironment<'_>,
+    builder: &mut FunctionBuilder,
+    ty: WasmHeapType,
+    dst: ir::Value,
+    gc_ref: ir::Value,
+    flags: ir::MemFlags,
+) -> WasmResult<()> {
+    debug_assert!({
+        let (_, needs_stack_map) = func_env.reference_type(ty);
+        needs_stack_map
+    });
+    builder.ins().store(flags, gc_ref, dst, 0);
+    Ok(())
+}
+
+pub fn gc_ref_table_grow_builtin(
+    ty: WasmHeapType,
+    func_env: &mut FuncEnvironment<'_>,
+    func: &mut ir::Function,
+) -> WasmResult<ir::FuncRef> {
+    debug_assert!(ty.is_vmgcref_type());
+    Ok(func_env.builtin_functions.table_grow_gc_ref(func))
+}
+
+pub fn gc_ref_table_fill_builtin(
+    ty: WasmHeapType,
+    func_env: &mut FuncEnvironment<'_>,
+    func: &mut ir::Function,
+) -> WasmResult<ir::FuncRef> {
+    debug_assert!(ty.is_vmgcref_type());
+    Ok(func_env.builtin_functions.table_fill_gc_ref(func))
+}
+
+pub fn gc_ref_global_get_builtin(
+    ty: WasmValType,
+    func_env: &mut FuncEnvironment<'_>,
+    func: &mut ir::Function,
+) -> WasmResult<ir::FuncRef> {
+    debug_assert!(ty.is_vmgcref_type());
+    Ok(func_env.builtin_functions.gc_ref_global_get(func))
+}
+
+pub fn gc_ref_global_set_builtin(
+    ty: WasmValType,
+    func_env: &mut FuncEnvironment<'_>,
+    func: &mut ir::Function,
+) -> WasmResult<ir::FuncRef> {
+    debug_assert!(ty.is_vmgcref_type());
+    Ok(func_env.builtin_functions.gc_ref_global_set(func))
+}
+
+impl FuncEnvironment<'_> {
+    /// Get the GC heap's base pointer and bound.
+    fn get_gc_heap_base_bound(&mut self, builder: &mut FunctionBuilder) -> (ir::Value, ir::Value) {
+        let ptr_ty = self.pointer_type();
+        let flags = ir::MemFlags::trusted().with_readonly();
+
+        let vmctx = self.vmctx(builder.func);
+        let vmctx = builder.ins().global_value(ptr_ty, vmctx);
+
+        let base_offset = self.offsets.ptr.vmctx_gc_heap_base();
+        let base_offset = i32::from(base_offset);
+
+        let bound_offset = self.offsets.ptr.vmctx_gc_heap_bound();
+        let bound_offset = i32::from(bound_offset);
+
+        let base = builder.ins().load(ptr_ty, flags, vmctx, base_offset);
+        let bound = builder.ins().load(ptr_ty, flags, vmctx, bound_offset);
+
+        (base, bound)
+    }
+
+    /// Get the raw pointer of `gc_ref[offset]` bounds checked for an access of
+    /// `size` bytes.
+    fn prepare_gc_ref_access(
+        &mut self,
+        builder: &mut FunctionBuilder,
+        gc_ref: ir::Value,
+        offset: u32,
+        size: u32,
+    ) -> ir::Value {
+        let pointer_type = self.pointer_type();
+        let (base, bound) = self.get_gc_heap_base_bound(builder);
+
+        debug_assert_eq!(builder.func.dfg.value_type(gc_ref), ir::types::I32);
+        let index = match pointer_type {
+            ir::types::I32 => gc_ref,
+            ir::types::I64 => builder.ins().uextend(ir::types::I64, gc_ref),
+            _ => unreachable!(),
+        };
+
+        let offset = builder
+            .ins()
+            .iconst(pointer_type, i64::try_from(offset).unwrap());
+
+        // Check that `index + offset + sizeof(i64)` is in bounds.
+        let index_and_offset = builder.ins().uadd_overflow_trap(
+            index,
+            offset,
+            ir::TrapCode::User(crate::DEBUG_ASSERT_TRAP_CODE),
+        );
+        let size = builder
+            .ins()
+            .iconst(pointer_type, i64::try_from(size).unwrap());
+        let index_offset_and_size = builder.ins().uadd_overflow_trap(
+            index_and_offset,
+            size,
+            ir::TrapCode::User(crate::DEBUG_ASSERT_TRAP_CODE),
+        );
+        let in_bounds = builder.ins().icmp(
+            ir::condcodes::IntCC::UnsignedLessThan,
+            index_offset_and_size,
+            bound,
+        );
+        builder
+            .ins()
+            .trapz(in_bounds, ir::TrapCode::User(crate::DEBUG_ASSERT_TRAP_CODE));
+
+        builder.ins().iadd(base, index_and_offset)
+    }
+
+    /// Emit checks (if necessary) for whether the given `gc_ref` is null or is
+    /// an `i31ref`.
+    ///
+    /// Takes advantage of static information based on `ty` as to whether the GC
+    /// reference is nullable or can ever be an `i31`.
+    ///
+    /// Returns an `ir::Value` that will be non-zero if the GC reference is null
+    /// or is an `i31ref`.
+    ///
+    /// This method is collector-agnostic.
+    fn gc_ref_is_null_or_i31(
+        &mut self,
+        builder: &mut FunctionBuilder,
+        ty: WasmRefType,
+        gc_ref: ir::Value,
+    ) -> ir::Value {
+        assert!(ty.is_vmgcref_type_and_not_i31());
+
+        let might_be_i31 = match ty.heap_type.top() {
+            WasmHeapTopType::Any => true,
+            WasmHeapTopType::Extern | WasmHeapTopType::Func => false,
+        };
+
+        match (ty.nullable, might_be_i31) {
+            // This GC reference statically cannot be null nor an i31. (Let
+            // Cranelift's optimizer const-propagate this value and erase any
+            // unnecessary control flow resulting from branching on this value.)
+            (false, false) => builder.ins().iconst(ir::types::I32, 0),
+
+            // This GC reference is always non-null, but might be an i31.
+            (false, true) => builder.ins().band_imm(gc_ref, I31_DISCRIMINANT as i64),
+
+            // This GC reference might be null, but can never be an i31.
+            (true, false) => builder.ins().icmp_imm(IntCC::Equal, gc_ref, 0),
+
+            // Fully general case: this GC reference could be either null or an
+            // i31.
+            (true, true) => {
+                // Mask for checking whether any bits are set, other than the
+                // `i31ref` discriminant, which should not be set. This folds
+                // the null and i31ref checks together into a single `band`.
+                let mask = builder.ins().iconst(
+                    ir::types::I32,
+                    (NON_NULL_NON_I31_MASK & u32::MAX as u64) as i64,
+                );
+                let is_non_null_and_non_i31 = builder.ins().band(gc_ref, mask);
+                builder
+                    .ins()
+                    .icmp_imm(ir::condcodes::IntCC::Equal, is_non_null_and_non_i31, 0)
+            }
+        }
+    }
+}
+
+struct DrcCompiler;
+
+impl DrcCompiler {
+    /// Generate code to load the given GC reference's ref count.
+    ///
+    /// Assumes that the given `gc_ref` is a non-null, non-i31 GC reference.
+    fn load_ref_count(
+        &mut self,
+        func_env: &mut FuncEnvironment<'_>,
+        builder: &mut FunctionBuilder,
+        gc_ref: ir::Value,
+    ) -> ir::Value {
+        let offset = func_env.offsets.vm_drc_header_ref_count();
+        let size = ir::types::I64.bytes();
+        let pointer = func_env.prepare_gc_ref_access(builder, gc_ref, offset, size);
+        builder
+            .ins()
+            .load(ir::types::I64, ir::MemFlags::trusted(), pointer, 0)
+    }
+
+    /// Generate code to update the given GC reference's ref count to the new
+    /// value.
+    ///
+    /// Assumes that the given `gc_ref` is a non-null, non-i31 GC reference.
+    fn store_ref_count(
+        &mut self,
+        func_env: &mut FuncEnvironment<'_>,
+        builder: &mut FunctionBuilder,
+        gc_ref: ir::Value,
+        new_ref_count: ir::Value,
+    ) {
+        let offset = func_env.offsets.vm_drc_header_ref_count();
+        let size = ir::types::I64.bytes();
+        let pointer = func_env.prepare_gc_ref_access(builder, gc_ref, offset, size);
+        builder
+            .ins()
+            .store(ir::MemFlags::trusted(), new_ref_count, pointer, 0);
+    }
+
+    /// Generate code to increment or decrement the given GC reference's ref
+    /// count.
+    ///
+    /// The new ref count is returned.
+    ///
+    /// Assumes that the given `gc_ref` is a non-null, non-i31 GC reference.
+    fn mutate_ref_count(
+        &mut self,
+        func_env: &mut FuncEnvironment<'_>,
+        builder: &mut FunctionBuilder,
+        gc_ref: ir::Value,
+        delta: i64,
+    ) -> ir::Value {
+        debug_assert!(delta == -1 || delta == 1);
+        let old_ref_count = self.load_ref_count(func_env, builder, gc_ref);
+        let new_ref_count = builder.ins().iadd_imm(old_ref_count, delta);
+        self.store_ref_count(func_env, builder, gc_ref, new_ref_count);
+        new_ref_count
+    }
+
+    /// Load the `*mut VMGcRefActivationsTable` from the vmctx, its `next` bump
+    /// finger, and its `end` bump boundary.
+    fn load_bump_region(
+        &mut self,
+        func_env: &mut FuncEnvironment<'_>,
+        builder: &mut FunctionBuilder,
+    ) -> (ir::Value, ir::Value, ir::Value) {
+        let ptr_ty = func_env.pointer_type();
+        let vmctx = func_env.vmctx(&mut builder.func);
+        let vmctx = builder.ins().global_value(ptr_ty, vmctx);
+        let activations_table = builder.ins().load(
+            ptr_ty,
+            ir::MemFlags::trusted(),
+            vmctx,
+            i32::from(func_env.offsets.ptr.vmctx_gc_heap_data()),
+        );
+        let next = builder.ins().load(
+            ptr_ty,
+            ir::MemFlags::trusted(),
+            activations_table,
+            i32::try_from(func_env.offsets.vm_gc_ref_activation_table_next()).unwrap(),
+        );
+        let end = builder.ins().load(
+            ptr_ty,
+            ir::MemFlags::trusted(),
+            activations_table,
+            i32::try_from(func_env.offsets.vm_gc_ref_activation_table_end()).unwrap(),
+        );
+        (activations_table, next, end)
+    }
+}
+
+impl GcCompiler for DrcCompiler {
+    fn translate_read_gc_reference(
+        &mut self,
+        func_env: &mut FuncEnvironment<'_>,
+        builder: &mut FunctionBuilder,
+        ty: WasmRefType,
+        src: ir::Value,
+        flags: ir::MemFlags,
+    ) -> WasmResult<ir::Value> {
+        assert!(ty.is_vmgcref_type_and_not_i31());
+
+        let (reference_type, needs_stack_map) = func_env.reference_type(ty.heap_type);
+        debug_assert!(needs_stack_map);
+
+        // Special case for references to uninhabited bottom types: the
+        // reference must either be nullable and we can just eagerly return
+        // null, or we are in dynamically unreachable code and should just trap.
+        if let WasmHeapType::None = ty.heap_type {
+            let null = builder.ins().iconst(reference_type, 0);
+            if !ty.nullable {
+                // NB: Don't use an unconditional trap instruction, since that
+                // is a block terminator, and we still need to integrate with
+                // the rest of the surrounding code.
+                let zero = builder.ins().iconst(ir::types::I32, 0);
+                builder
+                    .ins()
+                    .trapz(zero, ir::TrapCode::User(crate::DEBUG_ASSERT_TRAP_CODE));
+            }
+            return Ok(null);
+        };
+
+        // Our read barrier for GC references is roughly equivalent to the
+        // following pseudo-CLIF:
+        //
+        // ```
+        // current_block:
+        //     ...
+        //     let gc_ref = load src
+        //     let gc_ref_is_null = is_null gc_ref
+        //     let gc_ref_is_i31 = ...
+        //     let gc_ref_is_null_or_i31 = bor gc_ref_is_null, gc_ref_is_i31
+        //     brif gc_ref_is_null_or_i31, continue_block, non_null_gc_ref_block
+        //
+        // non_null_gc_ref_block:
+        //     let (next, end) = load VMGcRefActivationsTable bump region
+        //     let bump_region_is_full = icmp eq next, end
+        //     brif bump_region_is_full, gc_block, no_gc_block
+        //
+        // no_gc_block:
+        //     let ref_count = load gc_ref.ref_count
+        //     let new_ref_count = iadd_imm ref_count, 1
+        //     store new_ref_count, gc_ref.ref_count
+        //     let new_next = iadd_imm next, size_of(reference_type)
+        //     store new_next, activations_table.next
+        //     jump continue_block
+        //
+        // cold gc_block:
+        //     ;; NB: The DRC collector is not a moving GC, so we can reuse
+        //     ;; `gc_ref`. This lets us avoid a block parameter for the
+        //     ;; `continue_block`.
+        //     let _moved_gc_ref = call gc(gc_ref)
+        //     jump continue_block
+        //
+        // continue_block:
+        //     ...
+        // ```
+        //
+        // This ensures that all GC references entering the Wasm stack are held
+        // alive by the `VMGcRefActivationsTable`.
+
+        let current_block = builder.current_block().unwrap();
+        let non_null_gc_ref_block = builder.create_block();
+        let gc_block = builder.create_block();
+        let no_gc_block = builder.create_block();
+        let continue_block = builder.create_block();
+
+        builder.set_cold_block(gc_block);
+        builder.ensure_inserted_block();
+        builder.insert_block_after(non_null_gc_ref_block, current_block);
+        builder.insert_block_after(no_gc_block, non_null_gc_ref_block);
+        builder.insert_block_after(gc_block, no_gc_block);
+        builder.insert_block_after(continue_block, gc_block);
+
+        // Load the GC reference and check for null/i31.
+        let gc_ref = unbarriered_load_gc_ref(func_env, builder, ty.heap_type, src, flags)?;
+        let gc_ref_is_null_or_i31 = func_env.gc_ref_is_null_or_i31(builder, ty, gc_ref);
+        builder.ins().brif(
+            gc_ref_is_null_or_i31,
+            continue_block,
+            &[],
+            non_null_gc_ref_block,
+            &[],
+        );
+
+        // Block for when the GC reference is not null and is not an `i31ref`.
+        //
+        // Load the `VMGcRefActivationsTable::next` bump finger and the
+        // `VMGcRefActivationsTable::end` bump boundary and check whether the
+        // bump region is full or not.
+        builder.switch_to_block(non_null_gc_ref_block);
+        builder.seal_block(non_null_gc_ref_block);
+        let (activations_table, next, end) = self.load_bump_region(func_env, builder);
+        let bump_region_is_full = builder.ins().icmp(ir::condcodes::IntCC::Equal, next, end);
+        builder
+            .ins()
+            .brif(bump_region_is_full, gc_block, &[], no_gc_block, &[]);
+
+        // Block for when the bump region is not full. We should:
+        //
+        // * increment this reference's ref count,
+        // * store the reference into the bump table at `*next`,
+        // * and finally increment the `next` bump finger.
+        builder.switch_to_block(no_gc_block);
+        builder.seal_block(no_gc_block);
+        self.mutate_ref_count(func_env, builder, gc_ref, 1);
+        builder
+            .ins()
+            .store(ir::MemFlags::trusted(), gc_ref, next, 0);
+        let new_next = builder
+            .ins()
+            .iadd_imm(next, i64::from(reference_type.bytes()));
+        builder.ins().store(
+            ir::MemFlags::trusted(),
+            new_next,
+            activations_table,
+            i32::try_from(func_env.offsets.vm_gc_ref_activation_table_next()).unwrap(),
+        );
+        builder.ins().jump(continue_block, &[]);
+
+        // Block for when the bump region is full and we need to do a GC.
+        builder.switch_to_block(gc_block);
+        builder.seal_block(gc_block);
+        let gc_libcall = func_env.builtin_functions.gc(builder.func);
+        let vmctx = func_env.vmctx_val(&mut builder.cursor());
+        builder.ins().call(gc_libcall, &[vmctx, gc_ref]);
+        builder.ins().jump(continue_block, &[]);
+
+        // Join point after we're done with the GC barrier.
+        builder.switch_to_block(continue_block);
+        builder.seal_block(continue_block);
+        Ok(gc_ref)
+    }
+
+    fn translate_write_gc_reference(
+        &mut self,
+        func_env: &mut FuncEnvironment<'_>,
+        builder: &mut FunctionBuilder,
+        ty: WasmRefType,
+        dst: ir::Value,
+        new_val: ir::Value,
+        flags: ir::MemFlags,
+    ) -> WasmResult<()> {
+        assert!(ty.is_vmgcref_type_and_not_i31());
+
+        let (ref_ty, needs_stack_map) = func_env.reference_type(ty.heap_type);
+        debug_assert!(needs_stack_map);
+
+        // Special case for references to uninhabited bottom types: either the
+        // reference must either be nullable and we can just eagerly store null
+        // into `dst`, or we are in unreachable code and should just trap.
+        if let WasmHeapType::None = ty.heap_type {
+            if ty.nullable {
+                let null = builder.ins().iconst(ref_ty, 0);
+                builder.ins().store(flags, null, dst, 0);
+            } else {
+                // NB: Don't use an unconditional trap instruction, since that
+                // is a block terminator, and we still need to integrate with
+                // the rest of the surrounding code.
+                let zero = builder.ins().iconst(ir::types::I32, 0);
+                builder
+                    .ins()
+                    .trapz(zero, ir::TrapCode::User(crate::DEBUG_ASSERT_TRAP_CODE));
+            }
+            return Ok(());
+        };
+
+        // Our write barrier for GC references being copied out of the stack and
+        // written into a table/global/etc... is roughly equivalent to the
+        // following pseudo-CLIF:
+        //
+        // ```
+        // current_block:
+        //     ...
+        //     let old_val = *dst
+        //     let new_val_is_null = ref.null new_val
+        //     let new_val_is_i31 = ...
+        //     let new_val_is_null_or_i31 = bor new_val_is_null, new_val_is_i31
+        //     brif new_val_is_null_or_i31, check_old_val_block, inc_ref_block
+        //
+        // inc_ref_block:
+        //     let ref_count = load new_val.ref_count
+        //     let new_ref_count = iadd_imm ref_count, 1
+        //     store new_val.ref_count, new_ref_count
+        //     jump check_old_val_block
+        //
+        // check_old_val_block:
+        //     store dst, new_val
+        //     let old_val_is_null = ref.null old_val
+        //     let old_val_is_i31 = ...
+        //     let old_val_is_null_or_i31 = bor old_val_is_null, old_val_is_i31
+        //     brif old_val_is_null_or_i31, continue_block, dec_ref_block
+        //
+        // dec_ref_block:
+        //     let ref_count = load old_val.ref_count
+        //     let new_ref_count = isub_imm ref_count, 1
+        //     let old_val_needs_drop = icmp_imm eq new_ref_count, 0
+        //     brif old_val_needs_drop, drop_old_val_block, store_dec_ref_block
+        //
+        // cold drop_old_val_block:
+        //     call drop_gc_ref(old_val)
+        //     jump continue_block
+        //
+        // store_dec_ref_block:
+        //     store old_val.ref_count, new_ref_count
+        //     jump continue_block
+        //
+        // continue_block:
+        //     ...
+        // ```
+        //
+        // This write barrier is responsible for ensuring that:
+        //
+        // 1. The new value's ref count is incremented now that the table is
+        //    holding onto it.
+        //
+        // 2. The old value's ref count is decremented, and that it is dropped
+        //    if the ref count reaches zero.
+        //
+        // We must do the increment before the decrement. If we did it in the
+        // other order, then when `*dst == new_val`, we could confuse ourselves
+        // by observing a zero ref count after the decrement but before it would
+        // become non-zero again with the subsequent increment.
+        //
+        // Additionally, we take care that we don't ever call out-out-of-line to
+        // drop the old value until all the new value has been written into
+        // `dst` and its reference count has been updated. This makes sure that
+        // host code has a consistent view of the world.
+
+        let current_block = builder.current_block().unwrap();
+        let inc_ref_block = builder.create_block();
+        let check_old_val_block = builder.create_block();
+        let dec_ref_block = builder.create_block();
+        let drop_old_val_block = builder.create_block();
+        let store_dec_ref_block = builder.create_block();
+        let continue_block = builder.create_block();
+
+        builder.ensure_inserted_block();
+        builder.set_cold_block(drop_old_val_block);
+
+        builder.insert_block_after(inc_ref_block, current_block);
+        builder.insert_block_after(check_old_val_block, inc_ref_block);
+        builder.insert_block_after(dec_ref_block, check_old_val_block);
+        builder.insert_block_after(drop_old_val_block, dec_ref_block);
+        builder.insert_block_after(store_dec_ref_block, drop_old_val_block);
+        builder.insert_block_after(continue_block, store_dec_ref_block);
+
+        // Load the old value and then check whether the new value is non-null
+        // and non-i31.
+        let old_val = unbarriered_load_gc_ref(func_env, builder, ty.heap_type, dst, flags)?;
+        let new_val_is_null_or_i31 = func_env.gc_ref_is_null_or_i31(builder, ty, new_val);
+        builder.ins().brif(
+            new_val_is_null_or_i31,
+            check_old_val_block,
+            &[],
+            inc_ref_block,
+            &[],
+        );
+
+        // Block to increment the ref count of the new value when it is non-null
+        // and non-i31.
+        builder.switch_to_block(inc_ref_block);
+        builder.seal_block(inc_ref_block);
+        self.mutate_ref_count(func_env, builder, new_val, 1);
+        builder.ins().jump(check_old_val_block, &[]);
+
+        // Block to store the new value into `dst` and then check whether the
+        // old value is non-null and non-i31 and therefore needs its ref count
+        // decremented.
+        builder.switch_to_block(check_old_val_block);
+        builder.seal_block(check_old_val_block);
+        unbarriered_store_gc_ref(func_env, builder, ty.heap_type, dst, new_val, flags)?;
+        let old_val_is_null_or_i31 = func_env.gc_ref_is_null_or_i31(builder, ty, old_val);
+        builder.ins().brif(
+            old_val_is_null_or_i31,
+            continue_block,
+            &[],
+            dec_ref_block,
+            &[],
+        );
+
+        // Block to decrement the ref count of the old value when it is non-null
+        // and non-i31.
+        builder.switch_to_block(dec_ref_block);
+        builder.seal_block(dec_ref_block);
+        let ref_count = self.load_ref_count(func_env, builder, old_val);
+        let new_ref_count = builder.ins().iadd_imm(ref_count, -1);
+        let old_val_needs_drop =
+            builder
+                .ins()
+                .icmp_imm(ir::condcodes::IntCC::Equal, new_ref_count, 0);
+        builder.ins().brif(
+            old_val_needs_drop,
+            drop_old_val_block,
+            &[],
+            store_dec_ref_block,
+            &[],
+        );
+
+        // Block to call out-of-line to drop a GC reference when its ref count
+        // reaches zero.
+        //
+        // Note that this libcall does its own dec-ref operation, so we only
+        // actually store `new_ref_count` back to the `old_val` object when
+        // `new_ref_count != 0`.
+        builder.switch_to_block(drop_old_val_block);
+        builder.seal_block(drop_old_val_block);
+        let drop_gc_ref_libcall = func_env.builtin_functions.drop_gc_ref(builder.func);
+        let vmctx = func_env.vmctx_val(&mut builder.cursor());
+        builder.ins().call(drop_gc_ref_libcall, &[vmctx, old_val]);
+        builder.ins().jump(continue_block, &[]);
+
+        // Block to store the new ref count back to `old_val` for when
+        // `new_ref_count != 0`, as explained above.
+        builder.switch_to_block(store_dec_ref_block);
+        builder.seal_block(store_dec_ref_block);
+        self.store_ref_count(func_env, builder, old_val, new_ref_count);
+        builder.ins().jump(continue_block, &[]);
+
+        // Join point after we're done with the GC barrier.
+        builder.switch_to_block(continue_block);
+        builder.seal_block(continue_block);
+        Ok(())
+    }
+}
diff --git a/crates/cranelift-shared/src/isa_builder.rs b/crates/cranelift/src/isa_builder.rs
similarity index 88%
rename from crates/cranelift-shared/src/isa_builder.rs
rename to crates/cranelift/src/isa_builder.rs
index ad16bb8e8591..1c01ed7ce389 100644
--- a/crates/cranelift-shared/src/isa_builder.rs
+++ b/crates/cranelift/src/isa_builder.rs
@@ -20,7 +20,7 @@ pub struct IsaBuilder<T> {
 
 impl<T> IsaBuilder<T> {
     /// Create a new ISA builder with the given lookup function.
-    pub fn new(lookup: fn(Triple) -> Result<Builder<T>>) -> Self {
+    pub fn new(triple: Option<Triple>, lookup: fn(Triple) -> Result<Builder<T>>) -> Result<Self> {
         let mut flags = settings::builder();
 
         // We don't use probestack as a stack limit mechanism
@@ -28,14 +28,18 @@ impl<T> IsaBuilder<T> {
             .set("enable_probestack", "false")
             .expect("should be valid flag");
 
-        let mut isa_flags = lookup(Triple::host()).expect("host machine is not a supported target");
-        cranelift_native::infer_native_flags(&mut isa_flags).unwrap();
+        let triple_specified = triple.is_some();
+        let triple = triple.unwrap_or_else(Triple::host);
+        let mut isa_flags = lookup(triple)?;
+        if !triple_specified {
+            cranelift_native::infer_native_flags(&mut isa_flags).unwrap();
+        }
 
-        Self {
+        Ok(Self {
             shared_flags: flags,
             inner: isa_flags,
             lookup,
-        }
+        })
     }
 
     pub fn triple(&self) -> &target_lexicon::Triple {
diff --git a/crates/cranelift/src/lib.rs b/crates/cranelift/src/lib.rs
index 439437261bce..1f1a97daa792 100644
--- a/crates/cranelift/src/lib.rs
+++ b/crates/cranelift/src/lib.rs
@@ -3,22 +3,34 @@
 //! This crate provides an implementation of the `wasmtime_environ::Compiler`
 //! and `wasmtime_environ::CompilerBuilder` traits.
 
-use cranelift_codegen::ir;
-use cranelift_codegen::isa::{CallConv, TargetIsa};
+use cranelift_codegen::{
+    binemit,
+    cursor::FuncCursor,
+    ir::{self, AbiParam, ArgumentPurpose, ExternalName, InstBuilder, Signature},
+    isa::{CallConv, TargetIsa},
+    settings, FinalizedMachReloc, FinalizedRelocTarget, MachTrap,
+};
 use cranelift_entity::PrimaryMap;
-use cranelift_wasm::{DefinedFuncIndex, WasmFuncType, WasmType};
+use cranelift_wasm::{FuncIndex, WasmFuncType, WasmHeapTopType, WasmHeapType, WasmValType};
+
 use target_lexicon::Architecture;
-use wasmtime_cranelift_shared::CompiledFunctionMetadata;
+use wasmtime_environ::{
+    BuiltinFunctionIndex, FlagValue, RelocationTarget, Trap, TrapInformation, Tunables,
+};
 
 pub use builder::builder;
-use wasmtime_environ::Tunables;
+
+pub mod isa_builder;
+mod obj;
+pub use obj::*;
+mod compiled_function;
+pub use compiled_function::*;
 
 mod builder;
 mod compiler;
 mod debug;
 mod func_environ;
-
-type CompiledFunctionsMetadata<'a> = PrimaryMap<DefinedFuncIndex, &'a CompiledFunctionMetadata>;
+mod gc;
 
 /// Trap code used for debug assertions we emit in our JIT code.
 const DEBUG_ASSERT_TRAP_CODE: u16 = u16::MAX;
@@ -39,65 +51,55 @@ fn blank_sig(isa: &dyn TargetIsa, call_conv: CallConv) -> ir::Signature {
     return sig;
 }
 
-/// Returns the corresponding cranelift type for the provided wasm type.
-fn value_type(isa: &dyn TargetIsa, ty: WasmType) -> ir::types::Type {
-    match ty {
-        WasmType::I32 => ir::types::I32,
-        WasmType::I64 => ir::types::I64,
-        WasmType::F32 => ir::types::F32,
-        WasmType::F64 => ir::types::F64,
-        WasmType::V128 => ir::types::I8X16,
-        WasmType::Ref(rt) => reference_type(rt.heap_type, isa.pointer_type()),
-    }
-}
-
-/// Get the Cranelift signature with the native calling convention for the given
-/// Wasm function type.
-///
-/// This parameters will start with the callee and caller VM contexts, followed
-/// by the translation of each of the Wasm parameter types to native types. The
-/// results are the Wasm result types translated to native types.
-///
-/// The signature uses the wasmtime variant of the target's default calling
-/// convention. The only difference from the default calling convention is how
-/// multiple results are handled.
-///
-/// When there is only a single result, or zero results, these signatures are
-/// suitable for calling from the host via
+/// Emit code for the following unbarriered memory write of the given type:
 ///
 /// ```ignore
-/// unsafe extern "C" fn(
-///     callee_vmctx: *mut VMOpaqueContext,
-///     caller_vmctx: *mut VMOpaqueContext,
-///     // ...wasm parameter types...
-/// ) -> // ...wasm result type...
+/// *(base + offset) = value
 /// ```
 ///
-/// When there are more than one results, these signatures are suitable for
-/// calling from the host via
+/// This is intended to be used with things like `ValRaw` and the array calling
+/// convention.
+fn unbarriered_store_type_at_offset(
+    pos: &mut FuncCursor,
+    flags: ir::MemFlags,
+    base: ir::Value,
+    offset: i32,
+    value: ir::Value,
+) {
+    pos.ins().store(flags, value, base, offset);
+}
+
+/// Emit code to do the following unbarriered memory read of the given type and
+/// with the given flags:
 ///
 /// ```ignore
-/// unsafe extern "C" fn(
-///     callee_vmctx: *mut VMOpaqueContext,
-///     caller_vmctx: *mut VMOpaqueContext,
-///     // ...wasm parameter types...
-///     retptr: *mut (),
-/// ) -> // ...wasm result type 0...
+/// result = *(base + offset)
 /// ```
 ///
-/// where the first result is returned directly and the rest via the return
-/// pointer.
-fn native_call_signature(isa: &dyn TargetIsa, wasm: &WasmFuncType) -> ir::Signature {
-    let mut sig = blank_sig(isa, CallConv::triple_default(isa.triple()));
-    let cvt = |ty: &WasmType| ir::AbiParam::new(value_type(isa, *ty));
-    sig.params.extend(wasm.params().iter().map(&cvt));
-    if let Some(first_ret) = wasm.returns().get(0) {
-        sig.returns.push(cvt(first_ret));
-    }
-    if wasm.returns().len() > 1 {
-        sig.params.push(ir::AbiParam::new(isa.pointer_type()));
+/// This is intended to be used with things like `ValRaw` and the array calling
+/// convention.
+fn unbarriered_load_type_at_offset(
+    isa: &dyn TargetIsa,
+    pos: &mut FuncCursor,
+    ty: WasmValType,
+    flags: ir::MemFlags,
+    base: ir::Value,
+    offset: i32,
+) -> ir::Value {
+    let ir_ty = value_type(isa, ty);
+    pos.ins().load(ir_ty, flags, base, offset)
+}
+
+/// Returns the corresponding cranelift type for the provided wasm type.
+fn value_type(isa: &dyn TargetIsa, ty: WasmValType) -> ir::types::Type {
+    match ty {
+        WasmValType::I32 => ir::types::I32,
+        WasmValType::I64 => ir::types::I64,
+        WasmValType::F32 => ir::types::F32,
+        WasmValType::F64 => ir::types::F64,
+        WasmValType::V128 => ir::types::I8X16,
+        WasmValType::Ref(rt) => reference_type(rt.heap_type, isa.pointer_type()),
     }
-    sig
 }
 
 /// Get the Cranelift signature for all array-call functions, that is:
@@ -131,56 +133,267 @@ fn wasm_call_signature(
     wasm_func_ty: &WasmFuncType,
     tunables: &Tunables,
 ) -> ir::Signature {
-    // NB: this calling convention in the near future is expected to be
-    // unconditionally switched to the "tail" calling convention once all
-    // platforms have support for tail calls.
+    // The default calling convention is `CallConv::Tail` to enable the use of
+    // tail calls in modules when needed. Note that this is used even if the
+    // tail call proposal is disabled in wasm. This is not interacted with on
+    // the host so it's purely an internal detail of wasm itself.
     //
-    // Also note that the calling convention for wasm functions is purely an
-    // internal implementation detail of cranelift and Wasmtime. Native Rust
-    // code does not interact with raw wasm functions and instead always
-    // operates through trampolines either using the `array_call_signature` or
-    // `native_call_signature` where the default platform ABI is used.
-    let call_conv = match isa.triple().architecture {
-        // If the tail calls proposal is enabled, we must use the tail calling
-        // convention. We don't use it by default yet because of
-        // https://github.com/bytecodealliance/wasmtime/issues/6759
-        arch if tunables.tail_callable => {
-            assert_ne!(
-                arch,
-                Architecture::S390x,
-                "https://github.com/bytecodealliance/wasmtime/issues/6530"
-            );
-            CallConv::Tail
-        }
-
-        // On s390x the "wasmtime" calling convention is used to give vectors
-        // little-endian lane order at the ABI layer which should reduce the
-        // need for conversion when operating on vector function arguments. By
-        // default vectors on s390x are otherwise in big-endian lane order which
-        // would require conversions.
-        Architecture::S390x => CallConv::WasmtimeSystemV,
-
-        // All other platforms pick "fast" as the calling convention since it's
-        // presumably, well, the fastest.
-        _ => CallConv::Fast,
+    // The Winch calling convention is used instead when generating trampolines
+    // which call Winch-generated functions. The winch calling convention is
+    // only implemented for x64 and aarch64, so assert that here and panic on
+    // other architectures.
+    let call_conv = if tunables.winch_callable {
+        assert!(
+            matches!(
+                isa.triple().architecture,
+                Architecture::X86_64 | Architecture::Aarch64(_)
+            ),
+            "The Winch calling convention is only implemented for x86_64 and aarch64"
+        );
+        CallConv::Winch
+    } else {
+        CallConv::Tail
     };
     let mut sig = blank_sig(isa, call_conv);
-    let cvt = |ty: &WasmType| ir::AbiParam::new(value_type(isa, *ty));
+    let cvt = |ty: &WasmValType| ir::AbiParam::new(value_type(isa, *ty));
     sig.params.extend(wasm_func_ty.params().iter().map(&cvt));
     sig.returns.extend(wasm_func_ty.returns().iter().map(&cvt));
     sig
 }
 
 /// Returns the reference type to use for the provided wasm type.
-fn reference_type(wasm_ht: cranelift_wasm::WasmHeapType, pointer_type: ir::Type) -> ir::Type {
-    match wasm_ht {
-        cranelift_wasm::WasmHeapType::Func | cranelift_wasm::WasmHeapType::TypedFunc(_) => {
-            pointer_type
-        }
-        cranelift_wasm::WasmHeapType::Extern => match pointer_type {
-            ir::types::I32 => ir::types::R32,
-            ir::types::I64 => ir::types::R64,
-            _ => panic!("unsupported pointer type"),
+fn reference_type(wasm_ht: WasmHeapType, pointer_type: ir::Type) -> ir::Type {
+    match wasm_ht.top() {
+        WasmHeapTopType::Func => pointer_type,
+        WasmHeapTopType::Any | WasmHeapTopType::Extern => ir::types::I32,
+    }
+}
+
+// List of namespaces which are processed in `mach_reloc_to_reloc` below.
+
+/// Namespace corresponding to wasm functions, the index is the index of the
+/// defined function that's being referenced.
+pub const NS_WASM_FUNC: u32 = 0;
+
+/// Namespace for builtin function trampolines. The index is the index of the
+/// builtin that's being referenced. These trampolines invoke the real host
+/// function through an indirect function call loaded by the `VMContext`.
+pub const NS_WASMTIME_BUILTIN: u32 = 1;
+
+/// A record of a relocation to perform.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Relocation {
+    /// The relocation code.
+    pub reloc: binemit::Reloc,
+    /// Relocation target.
+    pub reloc_target: RelocationTarget,
+    /// The offset where to apply the relocation.
+    pub offset: binemit::CodeOffset,
+    /// The addend to add to the relocation value.
+    pub addend: binemit::Addend,
+}
+
+/// Converts cranelift_codegen settings to the wasmtime_environ equivalent.
+pub fn clif_flags_to_wasmtime(
+    flags: impl IntoIterator<Item = settings::Value>,
+) -> Vec<(&'static str, FlagValue<'static>)> {
+    flags
+        .into_iter()
+        .map(|val| (val.name, to_flag_value(&val)))
+        .collect()
+}
+
+fn to_flag_value(v: &settings::Value) -> FlagValue<'static> {
+    match v.kind() {
+        settings::SettingKind::Enum => FlagValue::Enum(v.as_enum().unwrap()),
+        settings::SettingKind::Num => FlagValue::Num(v.as_num().unwrap()),
+        settings::SettingKind::Bool => FlagValue::Bool(v.as_bool().unwrap()),
+        settings::SettingKind::Preset => unreachable!(),
+    }
+}
+
+/// A custom code with `TrapCode::User` which is used by always-trap shims which
+/// indicates that, as expected, the always-trapping function indeed did trap.
+/// This effectively provides a better error message as opposed to a bland
+/// "unreachable code reached"
+pub const ALWAYS_TRAP_CODE: u16 = 100;
+
+/// A custom code with `TrapCode::User` corresponding to being unable to reenter
+/// a component due to its reentrance limitations. This is used in component
+/// adapters to provide a more useful error message in such situations.
+pub const CANNOT_ENTER_CODE: u16 = 101;
+
+/// Converts machine traps to trap information.
+pub fn mach_trap_to_trap(trap: &MachTrap) -> Option<TrapInformation> {
+    let &MachTrap { offset, code } = trap;
+    Some(TrapInformation {
+        code_offset: offset,
+        trap_code: match code {
+            ir::TrapCode::StackOverflow => Trap::StackOverflow,
+            ir::TrapCode::HeapOutOfBounds => Trap::MemoryOutOfBounds,
+            ir::TrapCode::HeapMisaligned => Trap::HeapMisaligned,
+            ir::TrapCode::TableOutOfBounds => Trap::TableOutOfBounds,
+            ir::TrapCode::IndirectCallToNull => Trap::IndirectCallToNull,
+            ir::TrapCode::BadSignature => Trap::BadSignature,
+            ir::TrapCode::IntegerOverflow => Trap::IntegerOverflow,
+            ir::TrapCode::IntegerDivisionByZero => Trap::IntegerDivisionByZero,
+            ir::TrapCode::BadConversionToInteger => Trap::BadConversionToInteger,
+            ir::TrapCode::UnreachableCodeReached => Trap::UnreachableCodeReached,
+            ir::TrapCode::Interrupt => Trap::Interrupt,
+            ir::TrapCode::User(ALWAYS_TRAP_CODE) => Trap::AlwaysTrapAdapter,
+            ir::TrapCode::User(CANNOT_ENTER_CODE) => Trap::CannotEnterComponent,
+            ir::TrapCode::NullReference => Trap::NullReference,
+            ir::TrapCode::NullI31Ref => Trap::NullI31Ref,
+
+            // These do not get converted to wasmtime traps, since they
+            // shouldn't ever be hit in theory. Instead of catching and handling
+            // these, we let the signal crash the process.
+            ir::TrapCode::User(DEBUG_ASSERT_TRAP_CODE) => return None,
+
+            // these should never be emitted by wasmtime-cranelift
+            ir::TrapCode::User(_) => unreachable!(),
         },
+    })
+}
+
+/// Converts machine relocations to relocation information
+/// to perform.
+fn mach_reloc_to_reloc(
+    reloc: &FinalizedMachReloc,
+    name_map: &PrimaryMap<ir::UserExternalNameRef, ir::UserExternalName>,
+) -> Relocation {
+    let &FinalizedMachReloc {
+        offset,
+        kind,
+        ref target,
+        addend,
+    } = reloc;
+    let reloc_target = match *target {
+        FinalizedRelocTarget::ExternalName(ExternalName::User(user_func_ref)) => {
+            let name = &name_map[user_func_ref];
+            match name.namespace {
+                NS_WASM_FUNC => RelocationTarget::Wasm(FuncIndex::from_u32(name.index)),
+                NS_WASMTIME_BUILTIN => {
+                    RelocationTarget::Builtin(BuiltinFunctionIndex::from_u32(name.index))
+                }
+                _ => panic!("unknown namespace {}", name.namespace),
+            }
+        }
+        FinalizedRelocTarget::ExternalName(ExternalName::LibCall(libcall)) => {
+            let libcall = libcall_cranelift_to_wasmtime(libcall);
+            RelocationTarget::HostLibcall(libcall)
+        }
+        _ => panic!("unrecognized external name"),
+    };
+    Relocation {
+        reloc: kind,
+        reloc_target,
+        offset,
+        addend,
     }
 }
+
+fn libcall_cranelift_to_wasmtime(call: ir::LibCall) -> wasmtime_environ::obj::LibCall {
+    use wasmtime_environ::obj::LibCall as LC;
+    match call {
+        ir::LibCall::FloorF32 => LC::FloorF32,
+        ir::LibCall::FloorF64 => LC::FloorF64,
+        ir::LibCall::NearestF32 => LC::NearestF32,
+        ir::LibCall::NearestF64 => LC::NearestF64,
+        ir::LibCall::CeilF32 => LC::CeilF32,
+        ir::LibCall::CeilF64 => LC::CeilF64,
+        ir::LibCall::TruncF32 => LC::TruncF32,
+        ir::LibCall::TruncF64 => LC::TruncF64,
+        ir::LibCall::FmaF32 => LC::FmaF32,
+        ir::LibCall::FmaF64 => LC::FmaF64,
+        ir::LibCall::X86Pshufb => LC::X86Pshufb,
+        _ => panic!("cranelift emitted a libcall wasmtime does not support: {call:?}"),
+    }
+}
+
+/// Helper structure for creating a `Signature` for all builtins.
+struct BuiltinFunctionSignatures {
+    pointer_type: ir::Type,
+
+    #[cfg(feature = "gc")]
+    reference_type: ir::Type,
+
+    call_conv: CallConv,
+}
+
+impl BuiltinFunctionSignatures {
+    fn new(isa: &dyn TargetIsa) -> Self {
+        Self {
+            pointer_type: isa.pointer_type(),
+            call_conv: CallConv::triple_default(isa.triple()),
+
+            #[cfg(feature = "gc")]
+            reference_type: ir::types::I32,
+        }
+    }
+
+    fn vmctx(&self) -> AbiParam {
+        AbiParam::special(self.pointer_type, ArgumentPurpose::VMContext)
+    }
+
+    #[cfg(feature = "gc")]
+    fn reference(&self) -> AbiParam {
+        AbiParam::new(self.reference_type)
+    }
+
+    fn pointer(&self) -> AbiParam {
+        AbiParam::new(self.pointer_type)
+    }
+
+    fn i32(&self) -> AbiParam {
+        // Some platform ABIs require i32 values to be zero- or sign-
+        // extended to the full register width.  We need to indicate
+        // this here by using the appropriate .uext or .sext attribute.
+        // The attribute can be added unconditionally; platforms whose
+        // ABI does not require such extensions will simply ignore it.
+        // Note that currently all i32 arguments or return values used
+        // by builtin functions are unsigned, so we always use .uext.
+        // If that ever changes, we will have to add a second type
+        // marker here.
+        AbiParam::new(ir::types::I32).uext()
+    }
+
+    fn i64(&self) -> AbiParam {
+        AbiParam::new(ir::types::I64)
+    }
+
+    fn signature(&self, builtin: BuiltinFunctionIndex) -> Signature {
+        let mut _cur = 0;
+        macro_rules! iter {
+            (
+                $(
+                    $( #[$attr:meta] )*
+                    $name:ident( $( $pname:ident: $param:ident ),* ) $( -> $result:ident )?;
+                )*
+            ) => {
+                $(
+                    $( #[$attr] )*
+                    if _cur == builtin.index() {
+                        return Signature {
+                            params: vec![ $( self.$param() ),* ],
+                            returns: vec![ $( self.$result() )? ],
+                            call_conv: self.call_conv,
+                        };
+                    }
+                    _cur += 1;
+                )*
+            };
+        }
+
+        wasmtime_environ::foreach_builtin_function!(iter);
+
+        unreachable!();
+    }
+}
+
+/// If this bit is set on a GC reference, then the GC reference is actually an
+/// unboxed `i31`.
+///
+/// Must be kept in sync with
+/// `crate::runtime::vm::gc::VMGcRef::I31_REF_DISCRIMINANT`.
+const I31_REF_DISCRIMINANT: u32 = 1;
diff --git a/crates/cranelift-shared/src/obj.rs b/crates/cranelift/src/obj.rs
similarity index 92%
rename from crates/cranelift-shared/src/obj.rs
rename to crates/cranelift/src/obj.rs
index 7713b9f635f7..d73596f68246 100644
--- a/crates/cranelift-shared/src/obj.rs
+++ b/crates/cranelift/src/obj.rs
@@ -13,10 +13,9 @@
 //! function body, the imported wasm function do not. The trampolines symbol
 //! names have format "_trampoline_N", where N is `SignatureIndex`.
 
-use crate::{CompiledFuncEnv, CompiledFunction, RelocationTarget};
+use crate::{CompiledFunction, RelocationTarget};
 use anyhow::Result;
 use cranelift_codegen::binemit::Reloc;
-use cranelift_codegen::ir::LibCall;
 use cranelift_codegen::isa::unwind::{systemv, UnwindInfo};
 use cranelift_codegen::TextSectionBuilder;
 use cranelift_control::ControlPlane;
@@ -25,13 +24,13 @@ use gimli::RunTimeEndian;
 use object::write::{Object, SectionId, StandardSegment, Symbol, SymbolId, SymbolSection};
 use object::{Architecture, SectionKind, SymbolFlags, SymbolKind, SymbolScope};
 use std::collections::HashMap;
-use std::convert::TryFrom;
 use std::ops::Range;
-use wasmtime_environ::{Compiler, FuncIndex};
+use wasmtime_environ::obj::LibCall;
+use wasmtime_environ::Compiler;
 
 const TEXT_SECTION_NAME: &[u8] = b".text";
 
-/// A helper structure used to assemble the final text section of an exectuable,
+/// A helper structure used to assemble the final text section of an executable,
 /// plus unwinding information and other related details.
 ///
 /// This builder relies on Cranelift-specific internals but assembles into a
@@ -108,8 +107,8 @@ impl<'a> ModuleTextBuilder<'a> {
     pub fn append_func(
         &mut self,
         name: &str,
-        compiled_func: &'a CompiledFunction<impl CompiledFuncEnv>,
-        resolve_reloc_target: impl Fn(FuncIndex) -> usize,
+        compiled_func: &'a CompiledFunction,
+        resolve_reloc_target: impl Fn(wasmtime_environ::RelocationTarget) -> usize,
     ) -> (SymbolId, Range<u64>) {
         let body = compiled_func.buffer.data();
         let alignment = compiled_func.alignment;
@@ -141,8 +140,8 @@ impl<'a> ModuleTextBuilder<'a> {
                 // resolve this relocation before we actually emit an object
                 // file, but if it can't handle it then we pass through the
                 // relocation.
-                RelocationTarget::UserFunc(index) => {
-                    let target = resolve_reloc_target(index);
+                RelocationTarget::Wasm(_) | RelocationTarget::Builtin(_) => {
+                    let target = resolve_reloc_target(r.reloc_target);
                     if self
                         .text
                         .resolve_reloc(off + u64::from(r.offset), r.reloc, r.addend, target)
@@ -158,7 +157,8 @@ impl<'a> ModuleTextBuilder<'a> {
                     // the final object file as well.
                     panic!(
                         "unresolved relocation could not be processed against \
-                         {index:?}: {r:?}"
+                         {:?}: {r:?}",
+                        r.reloc_target,
                     );
                 }
 
@@ -171,10 +171,10 @@ impl<'a> ModuleTextBuilder<'a> {
                 // 8-byte relocations so that's asserted here and then encoded
                 // directly into the object as a normal object relocation. This
                 // is processed at module load time to resolve the relocations.
-                RelocationTarget::LibCall(call) => {
+                RelocationTarget::HostLibcall(call) => {
                     let symbol = *self.libcall_symbols.entry(call).or_insert_with(|| {
                         self.obj.add_symbol(Symbol {
-                            name: libcall_name(call).as_bytes().to_vec(),
+                            name: call.symbol().as_bytes().to_vec(),
                             value: 0,
                             size: 0,
                             kind: SymbolKind::Text,
@@ -184,12 +184,12 @@ impl<'a> ModuleTextBuilder<'a> {
                             flags: SymbolFlags::None,
                         })
                     });
-                    let (encoding, kind, size) = match r.reloc {
-                        Reloc::Abs8 => (
-                            object::RelocationEncoding::Generic,
-                            object::RelocationKind::Absolute,
-                            8,
-                        ),
+                    let flags = match r.reloc {
+                        Reloc::Abs8 => object::RelocationFlags::Generic {
+                            encoding: object::RelocationEncoding::Generic,
+                            kind: object::RelocationKind::Absolute,
+                            size: 64,
+                        },
                         other => unimplemented!("unimplemented relocation kind {other:?}"),
                     };
                     self.obj
@@ -197,9 +197,7 @@ impl<'a> ModuleTextBuilder<'a> {
                             self.text_section,
                             object::write::Relocation {
                                 symbol,
-                                size,
-                                kind,
-                                encoding,
+                                flags,
                                 offset: off + u64::from(r.offset),
                                 addend: r.addend,
                             },
@@ -467,9 +465,10 @@ impl<'a> UnwindInfoBuilder<'a> {
         section_id: SectionId,
         text_section_size: u64,
     ) {
-        let mut cie = compiler
-            .create_systemv_cie()
-            .expect("must be able to create a CIE for system-v unwind info");
+        let mut cie = match compiler.create_systemv_cie() {
+            Some(cie) => cie,
+            None => return,
+        };
         let mut table = FrameTable::default();
         cie.fde_address_encoding = gimli::constants::DW_EH_PE_pcrel;
         let cie_id = table.add_cie(cie);
@@ -544,22 +543,3 @@ impl<'a> UnwindInfoBuilder<'a> {
         }
     }
 }
-
-fn libcall_name(call: LibCall) -> &'static str {
-    use wasmtime_environ::obj::LibCall as LC;
-    let other = match call {
-        LibCall::FloorF32 => LC::FloorF32,
-        LibCall::FloorF64 => LC::FloorF64,
-        LibCall::NearestF32 => LC::NearestF32,
-        LibCall::NearestF64 => LC::NearestF64,
-        LibCall::CeilF32 => LC::CeilF32,
-        LibCall::CeilF64 => LC::CeilF64,
-        LibCall::TruncF32 => LC::TruncF32,
-        LibCall::TruncF64 => LC::TruncF64,
-        LibCall::FmaF32 => LC::FmaF32,
-        LibCall::FmaF64 => LC::FmaF64,
-        LibCall::X86Pshufb => LC::X86Pshufb,
-        _ => panic!("unknown libcall to give a name to: {call:?}"),
-    };
-    other.symbol()
-}
diff --git a/crates/environ/Cargo.toml b/crates/environ/Cargo.toml
index b09f3cfd4276..2ae748a0b727 100644
--- a/crates/environ/Cargo.toml
+++ b/crates/environ/Cargo.toml
@@ -2,43 +2,68 @@
 name = "wasmtime-environ"
 version.workspace = true
 authors.workspace = true
-description = "Standalone environment support for WebAsssembly code in Cranelift"
+description = "Standalone environment support for WebAssembly code in Cranelift"
 license = "Apache-2.0 WITH LLVM-exception"
 repository = "https://github.com/bytecodealliance/wasmtime"
 documentation = "https://docs.rs/wasmtime-environ/"
 categories = ["wasm"]
 keywords = ["webassembly", "wasm"]
 edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
+
+[package.metadata.docs.rs]
+all-features = true
 
 [dependencies]
 anyhow = { workspace = true }
+postcard = { workspace = true }
+cpp_demangle = { version = "0.4.3", optional = true }
 cranelift-entity = { workspace = true }
+cranelift-bitset = { workspace = true, features = ['enable-serde'] }
 wasmtime-types = { workspace = true }
-wasmparser = { workspace = true }
+wasmparser = { workspace = true, features = ['validate', 'serde'] }
 indexmap = { workspace = true, features = ["serde"] }
-thiserror = { workspace = true }
-serde = "1.0.188"
-serde_derive = "1.0.188"
+serde = { workspace = true }
+serde_derive = { workspace = true }
 log = { workspace = true }
-gimli = { workspace = true, features = ["write"] }
-object = { workspace = true, features = ['write_core'] }
+gimli = { workspace = true }
+object = { workspace = true }
+rustc-demangle = { version = "0.1.16", optional = true }
 target-lexicon = { workspace = true }
 wasm-encoder = { workspace = true, optional = true }
 wasmprinter = { workspace = true, optional = true }
 wasmtime-component-util = { workspace = true, optional = true }
+semver = { workspace = true, optional = true, features = ['serde'] }
 
 [dev-dependencies]
-clap = { workspace = true }
+clap = { workspace = true, features = ['default'] }
 env_logger = { workspace = true }
 wat = { workspace = true }
 
 [[example]]
 name = "factc"
-required-features = ['component-model']
+required-features = ['component-model', 'compile']
 
 [features]
-component-model = [
+component-model = ["dep:wasmtime-component-util", "dep:semver"]
+demangle = ['std', 'dep:rustc-demangle', 'dep:cpp_demangle']
+gc = []
+compile = [
+  'gimli/write',
+  'object/write_core',
+  'std',
   "dep:wasm-encoder",
   "dep:wasmprinter",
-  "dep:wasmtime-component-util",
+]
+threads = ['std']
+wmemcheck = ['std']
+std = [
+  'wasmtime-types/std',
+  'anyhow/std',
+  'object/std',
+  'wasmparser/std',
+  'indexmap/std',
 ]
diff --git a/crates/environ/examples/factc.rs b/crates/environ/examples/factc.rs
index 6dfb7136e485..ac55c429638c 100644
--- a/crates/environ/examples/factc.rs
+++ b/crates/environ/examples/factc.rs
@@ -24,53 +24,53 @@ use wasmtime_environ::fact::Module;
 #[derive(Parser)]
 struct Factc {
     /// Whether or not debug code is inserted into the generated adapter.
-    #[clap(long)]
+    #[arg(long)]
     debug: bool,
 
     /// Whether or not the lifting options (the callee of the exported adapter)
     /// uses a 64-bit memory as opposed to a 32-bit memory.
-    #[clap(long)]
+    #[arg(long)]
     lift64: bool,
 
     /// Whether or not the lowering options (the caller of the exported adapter)
     /// uses a 64-bit memory as opposed to a 32-bit memory.
-    #[clap(long)]
+    #[arg(long)]
     lower64: bool,
 
     /// Whether or not a call to a `post-return` configured function is enabled
     /// or not.
-    #[clap(long)]
+    #[arg(long)]
     post_return: bool,
 
     /// Whether or not to skip validation of the generated adapter module.
-    #[clap(long)]
+    #[arg(long)]
     skip_validate: bool,
 
     /// Where to place the generated adapter module. Standard output is used if
     /// this is not specified.
-    #[clap(short, long)]
+    #[arg(short, long)]
     output: Option<PathBuf>,
 
     /// Output the text format for WebAssembly instead of the binary format.
-    #[clap(short, long)]
+    #[arg(short, long)]
     text: bool,
 
-    #[clap(long, value_parser = parse_string_encoding, default_value = "utf8")]
+    #[arg(long, value_parser = parse_string_encoding, default_value = "utf8")]
     lift_str: StringEncoding,
 
-    #[clap(long, value_parser = parse_string_encoding, default_value = "utf8")]
+    #[arg(long, value_parser = parse_string_encoding, default_value = "utf8")]
     lower_str: StringEncoding,
 
     /// TODO
     input: PathBuf,
 }
 
-fn parse_string_encoding(name: &str) -> anyhow::Result<StringEncoding> {
+fn parse_string_encoding(name: &str) -> Result<StringEncoding> {
     Ok(match name {
         "utf8" => StringEncoding::Utf8,
         "utf16" => StringEncoding::Utf16,
         "compact-utf16" => StringEncoding::CompactUtf16,
-        other => anyhow::bail!("invalid string encoding: `{other}`"),
+        other => bail!("invalid string encoding: `{other}`"),
     })
 }
 
@@ -82,8 +82,6 @@ impl Factc {
     fn execute(self) -> Result<()> {
         env_logger::init();
 
-        let mut types = ComponentTypesBuilder::default();
-
         // Manufactures a unique `CoreDef` so all function imports get unique
         // function imports.
         let mut next_def = 0;
@@ -118,24 +116,21 @@ impl Factc {
             }
         };
 
+        let mut validator = Validator::new();
+        let mut types = ComponentTypesBuilder::new(&validator);
+
         let mut adapters = Vec::new();
         let input = wat::parse_file(&self.input)?;
-        let mut validator = Validator::new_with_features(WasmFeatures {
-            component_model: true,
-            ..Default::default()
-        });
         let wasm_types = validator
             .validate_all(&input)
             .context("failed to validate input wasm")?;
         let wasm_types = wasm_types.as_ref();
         for i in 0..wasm_types.component_type_count() {
-            let ty = wasm_types.component_type_at(i);
-            let ty = match &wasm_types[ty] {
-                wasmparser::types::Type::ComponentFunc(_) => {
-                    types.convert_component_func_type(wasm_types, ty)?
-                }
+            let ty = match wasm_types.component_any_type_at(i) {
+                wasmparser::types::ComponentAnyTypeId::Func(id) => id,
                 _ => continue,
             };
+            let ty = types.convert_component_func_type(wasm_types, ty)?;
             adapters.push(Adapter {
                 lift_ty: ty,
                 lower_ty: ty,
@@ -193,13 +188,9 @@ impl Factc {
         }
 
         if !self.skip_validate {
-            Validator::new_with_features(WasmFeatures {
-                multi_memory: true,
-                memory64: true,
-                ..WasmFeatures::default()
-            })
-            .validate_all(&wasm)
-            .context("failed to validate generated module")?;
+            Validator::new_with_features(WasmFeatures::default() | WasmFeatures::MEMORY64)
+                .validate_all(&wasm)
+                .context("failed to validate generated module")?;
         }
 
         Ok(())
diff --git a/crates/environ/fuzz/Cargo.toml b/crates/environ/fuzz/Cargo.toml
index 2c6996b4da46..d6a1774bfef2 100644
--- a/crates/environ/fuzz/Cargo.toml
+++ b/crates/environ/fuzz/Cargo.toml
@@ -4,12 +4,13 @@ version = "0.0.0"
 authors = ["Automatically generated"]
 publish = false
 edition.workspace = true
+rust-version.workspace = true
 
 [package.metadata]
 cargo-fuzz = true
 
 [dependencies]
-arbitrary = { version = "1.1.0", features = ["derive"] }
+arbitrary = { workspace = true, features = ["derive"] }
 env_logger = { workspace = true }
 libfuzzer-sys = { workspace = true }
 wasmparser = { workspace = true }
@@ -26,4 +27,8 @@ doc = false
 required-features = ["component-model"]
 
 [features]
-component-model = ["wasmtime-environ/component-model", "dep:component-fuzz-util"]
+component-model = [
+  "wasmtime-environ/component-model",
+  "wasmtime-environ/compile",
+  "dep:component-fuzz-util",
+]
diff --git a/crates/environ/fuzz/fuzz_targets/fact-valid-module.rs b/crates/environ/fuzz/fuzz_targets/fact-valid-module.rs
index b43f8cda6c90..cb7d85e027b2 100644
--- a/crates/environ/fuzz/fuzz_targets/fact-valid-module.rs
+++ b/crates/environ/fuzz/fuzz_targets/fact-valid-module.rs
@@ -9,35 +9,79 @@
 
 #![no_main]
 
-use arbitrary::Arbitrary;
-use component_fuzz_util::TestCase;
+use arbitrary::Unstructured;
+use component_fuzz_util::{TestCase, Type, MAX_TYPE_DEPTH};
 use libfuzzer_sys::fuzz_target;
+use wasmparser::types::ComponentAnyTypeId;
 use wasmparser::{Parser, Payload, Validator, WasmFeatures};
 use wasmtime_environ::component::*;
 use wasmtime_environ::fact::Module;
 
-#[derive(Arbitrary, Debug)]
-struct GenAdapterModule {
+const TYPE_COUNT: usize = 50;
+const MAX_ARITY: u32 = 5;
+const TEST_CASE_COUNT: usize = 20;
+
+#[derive(Debug)]
+struct GenAdapterModule<'a> {
     debug: bool,
-    adapters: Vec<GenAdapter>,
+    adapters: Vec<GenAdapter<'a>>,
 }
 
-#[derive(Arbitrary, Debug)]
-struct GenAdapter {
+#[derive(Debug)]
+struct GenAdapter<'a> {
     post_return: bool,
     lift_memory64: bool,
     lower_memory64: bool,
-    test: TestCase,
+    test: TestCase<'a>,
 }
 
-fuzz_target!(|module: GenAdapterModule| {
-    target(module);
+fuzz_target!(|data: &[u8]| {
+    let _ = target(data);
 });
 
-fn target(module: GenAdapterModule) {
+fn target(data: &[u8]) -> arbitrary::Result<()> {
     drop(env_logger::try_init());
 
-    let mut types = ComponentTypesBuilder::default();
+    let mut u = Unstructured::new(data);
+
+    // First generate a set of type to select from.
+    let mut type_fuel = 1000;
+    let mut types = Vec::new();
+    for _ in 0..u.int_in_range(1..=TYPE_COUNT)? {
+        // Only discount fuel if the generation was successful,
+        // otherwise we'll get more random data and try again.
+        types.push(Type::generate(&mut u, MAX_TYPE_DEPTH, &mut type_fuel)?);
+    }
+
+    // Next generate a set of static API test cases driven by the above
+    // types.
+    let mut ret = GenAdapterModule {
+        debug: u.arbitrary()?,
+        adapters: Vec::new(),
+    };
+    for _ in 0..u.int_in_range(1..=TEST_CASE_COUNT)? {
+        let mut params = Vec::new();
+        let mut results = Vec::new();
+        for _ in 0..u.int_in_range(0..=MAX_ARITY)? {
+            params.push(u.choose(&types)?);
+        }
+        for _ in 0..u.int_in_range(0..=MAX_ARITY)? {
+            results.push(u.choose(&types)?);
+        }
+
+        let test = TestCase {
+            params,
+            results,
+            encoding1: u.arbitrary()?,
+            encoding2: u.arbitrary()?,
+        };
+        ret.adapters.push(GenAdapter {
+            test,
+            post_return: u.arbitrary()?,
+            lift_memory64: u.arbitrary()?,
+            lower_memory64: u.arbitrary()?,
+        });
+    }
 
     // Manufactures a unique `CoreDef` so all function imports get unique
     // function imports.
@@ -72,9 +116,11 @@ fn target(module: GenAdapterModule) {
             item: ExportItem::Name(String::new()),
         }
     };
+    let mut validator = Validator::new();
+    let mut types = ComponentTypesBuilder::new(&validator);
 
     let mut adapters = Vec::new();
-    for adapter in module.adapters.iter() {
+    for adapter in ret.adapters.iter() {
         let wat_decls = adapter.test.declarations();
         let wat = format!(
             "(component
@@ -87,12 +133,7 @@ fn target(module: GenAdapterModule) {
         );
         let wasm = wat::parse_str(&wat).unwrap();
 
-        let mut validator = Validator::new_with_features(WasmFeatures {
-            component_model: true,
-            ..Default::default()
-        });
-
-        types.push_type_scope();
+        let mut type_index = 0;
         for payload in Parser::new(0).parse_all(&wasm) {
             let payload = payload.unwrap();
             validator.payload(&payload).unwrap();
@@ -100,13 +141,17 @@ fn target(module: GenAdapterModule) {
                 Payload::ComponentTypeSection(s) => s,
                 _ => continue,
             };
-            for ty in section {
-                let ty = types.intern_component_type(&ty.unwrap()).unwrap();
-                types.push_component_typedef(ty);
-                let ty = match ty {
-                    TypeDef::ComponentFunc(ty) => ty,
+            for _ in section {
+                let validator_types = validator.types(0).unwrap();
+                let id = validator_types.component_any_type_at(type_index);
+                type_index += 1;
+                let id = match id {
+                    ComponentAnyTypeId::Func(id) => id,
                     _ => continue,
                 };
+                let ty = types
+                    .convert_component_func_type(validator_types, id)
+                    .unwrap();
                 adapters.push(Adapter {
                     lift_ty: ty,
                     lower_ty: ty,
@@ -140,27 +185,23 @@ fn target(module: GenAdapterModule) {
                 });
             }
         }
-        types.pop_type_scope();
+        validator.reset();
     }
 
-    let mut fact_module = Module::new(&types, module.debug);
+    let mut fact_module = Module::new(&types, ret.debug);
     for (i, adapter) in adapters.iter().enumerate() {
         fact_module.adapt(&format!("adapter{i}"), adapter);
     }
     let wasm = fact_module.encode();
-    let result = Validator::new_with_features(WasmFeatures {
-        multi_memory: true,
-        memory64: true,
-        ..WasmFeatures::default()
-    })
-    .validate_all(&wasm);
+    let result = Validator::new_with_features(WasmFeatures::default() | WasmFeatures::MEMORY64)
+        .validate_all(&wasm);
 
     let err = match result {
-        Ok(_) => return,
+        Ok(_) => return Ok(()),
         Err(e) => e,
     };
     eprintln!("invalid wasm module: {err:?}");
-    for adapter in module.adapters.iter() {
+    for adapter in ret.adapters.iter() {
         eprintln!("adapter: {adapter:?}");
     }
     std::fs::write("invalid.wasm", &wasm).unwrap();
diff --git a/crates/environ/src/address_map.rs b/crates/environ/src/address_map.rs
index 806fba8a5e6c..a707d69b4708 100644
--- a/crates/environ/src/address_map.rs
+++ b/crates/environ/src/address_map.rs
@@ -1,11 +1,7 @@
 //! Data structures to provide transformation of the source
 
-use crate::obj::ELF_WASMTIME_ADDRMAP;
-use object::write::{Object, StandardSegment};
-use object::{Bytes, LittleEndian, SectionKind, U32Bytes};
+use object::{Bytes, LittleEndian, U32Bytes};
 use serde_derive::{Deserialize, Serialize};
-use std::convert::TryFrom;
-use std::ops::Range;
 
 /// Single source location to generated address mapping.
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
@@ -53,69 +49,6 @@ impl Default for FilePos {
     }
 }
 
-/// Builder for the address map section of a wasmtime compilation image.
-///
-/// This builder is used to conveniently built the `ELF_WASMTIME_ADDRMAP`
-/// section by compilers, and provides utilities to directly insert the results
-/// into an `Object`.
-#[derive(Default)]
-pub struct AddressMapSection {
-    offsets: Vec<U32Bytes<LittleEndian>>,
-    positions: Vec<U32Bytes<LittleEndian>>,
-    last_offset: u32,
-}
-
-impl AddressMapSection {
-    /// Pushes a new set of instruction mapping information for a function added
-    /// in the exectuable.
-    ///
-    /// The `func` argument here is the range of the function, relative to the
-    /// start of the text section in the executable. The `instrs` provided are
-    /// the descriptors for instructions in the function and their various
-    /// mappings back to original source positions.
-    ///
-    /// This is required to be called for `func` values that are strictly
-    /// increasing in addresses (e.g. as the object is built). Additionally the
-    /// `instrs` map must be sorted based on code offset in the native text
-    /// section.
-    pub fn push(&mut self, func: Range<u64>, instrs: &[InstructionAddressMap]) {
-        // NB: for now this only supports <=4GB text sections in object files.
-        // Alternative schemes will need to be created for >32-bit offsets to
-        // avoid making this section overly large.
-        let func_start = u32::try_from(func.start).unwrap();
-        let func_end = u32::try_from(func.end).unwrap();
-
-        self.offsets.reserve(instrs.len());
-        self.positions.reserve(instrs.len());
-        for map in instrs {
-            // Sanity-check to ensure that functions are pushed in-order, otherwise
-            // the `offsets` array won't be sorted which is our goal.
-            let pos = func_start + map.code_offset;
-            assert!(pos >= self.last_offset);
-            self.offsets.push(U32Bytes::new(LittleEndian, pos));
-            self.positions
-                .push(U32Bytes::new(LittleEndian, map.srcloc.0));
-            self.last_offset = pos;
-        }
-        self.last_offset = func_end;
-    }
-
-    /// Finishes encoding this section into the `Object` provided.
-    pub fn append_to(self, obj: &mut Object) {
-        let section = obj.add_section(
-            obj.segment_name(StandardSegment::Data).to_vec(),
-            ELF_WASMTIME_ADDRMAP.as_bytes().to_vec(),
-            SectionKind::ReadOnlyData,
-        );
-
-        // NB: this matches the encoding expected by `lookup` below.
-        let amt = u32::try_from(self.offsets.len()).unwrap();
-        obj.append_section_data(section, &amt.to_le_bytes(), 1);
-        obj.append_section_data(section, object::bytes_of_slice(&self.offsets), 1);
-        obj.append_section_data(section, object::bytes_of_slice(&self.positions), 1);
-    }
-}
-
 /// Parse an `ELF_WASMTIME_ADDRMAP` section, returning the slice of code offsets
 /// and the slice of associated file positions for each offset.
 fn parse_address_map(
diff --git a/crates/environ/src/builtin.rs b/crates/environ/src/builtin.rs
index 07a5a03ab5dd..e9411ac9ff28 100644
--- a/crates/environ/src/builtin.rs
+++ b/crates/environ/src/builtin.rs
@@ -3,76 +3,105 @@
 macro_rules! foreach_builtin_function {
     ($mac:ident) => {
         $mac! {
-            /// Returns an index for wasm's `memory.grow` builtin function.
+            // Returns an index for wasm's `memory.grow` builtin function.
             memory32_grow(vmctx: vmctx, delta: i64, index: i32) -> pointer;
-            /// Returns an index for wasm's `table.copy` when both tables are locally
-            /// defined.
+            // Returns an index for wasm's `table.copy` when both tables are locally
+            // defined.
             table_copy(vmctx: vmctx, dst_index: i32, src_index: i32, dst: i32, src: i32, len: i32);
-            /// Returns an index for wasm's `table.init`.
+            // Returns an index for wasm's `table.init`.
             table_init(vmctx: vmctx, table: i32, elem: i32, dst: i32, src: i32, len: i32);
-            /// Returns an index for wasm's `elem.drop`.
+            // Returns an index for wasm's `elem.drop`.
             elem_drop(vmctx: vmctx, elem: i32);
-            /// Returns an index for wasm's `memory.copy`
+            // Returns an index for wasm's `memory.copy`
             memory_copy(vmctx: vmctx, dst_index: i32, dst: i64, src_index: i32, src: i64, len: i64);
-            /// Returns an index for wasm's `memory.fill` instruction.
+            // Returns an index for wasm's `memory.fill` instruction.
             memory_fill(vmctx: vmctx, memory: i32, dst: i64, val: i32, len: i64);
-            /// Returns an index for wasm's `memory.init` instruction.
+            // Returns an index for wasm's `memory.init` instruction.
             memory_init(vmctx: vmctx, memory: i32, data: i32, dst: i64, src: i32, len: i32);
-            /// Returns a value for wasm's `ref.func` instruction.
+            // Returns a value for wasm's `ref.func` instruction.
             ref_func(vmctx: vmctx, func: i32) -> pointer;
-            /// Returns an index for wasm's `data.drop` instruction.
+            // Returns an index for wasm's `data.drop` instruction.
             data_drop(vmctx: vmctx, data: i32);
-            /// Returns a table entry after lazily initializing it.
+            // Returns a table entry after lazily initializing it.
             table_get_lazy_init_func_ref(vmctx: vmctx, table: i32, index: i32) -> pointer;
-            /// Returns an index for Wasm's `table.grow` instruction for `funcref`s.
+            // Returns an index for Wasm's `table.grow` instruction for `funcref`s.
             table_grow_func_ref(vmctx: vmctx, table: i32, delta: i32, init: pointer) -> i32;
-            /// Returns an index for Wasm's `table.grow` instruction for `externref`s.
-            table_grow_externref(vmctx: vmctx, table: i32, delta: i32, init: reference) -> i32;
-            /// Returns an index for Wasm's `table.fill` instruction for `externref`s.
-            table_fill_externref(vmctx: vmctx, table: i32, dst: i32, val: reference, len: i32);
-            /// Returns an index for Wasm's `table.fill` instruction for `funcref`s.
+            // Returns an index for Wasm's `table.fill` instruction for `funcref`s.
             table_fill_func_ref(vmctx: vmctx, table: i32, dst: i32, val: pointer, len: i32);
-            /// Returns an index to drop a `VMExternRef`.
-            drop_externref(vmctx: vmctx, val: pointer);
-            /// Returns an index to do a GC and then insert a `VMExternRef` into the
-            /// `VMExternRefActivationsTable`.
-            activations_table_insert_with_gc(vmctx: vmctx, val: reference);
-            /// Returns an index for Wasm's `global.get` instruction for `externref`s.
-            externref_global_get(vmctx: vmctx, global: i32) -> reference;
-            /// Returns an index for Wasm's `global.get` instruction for `externref`s.
-            externref_global_set(vmctx: vmctx, global: i32, val: reference);
-            /// Returns an index for wasm's `memory.atomic.notify` instruction.
+            // Returns an index for wasm's `memory.atomic.notify` instruction.
+            #[cfg(feature = "threads")]
             memory_atomic_notify(vmctx: vmctx, memory: i32, addr: i64, count: i32) -> i32;
-            /// Returns an index for wasm's `memory.atomic.wait32` instruction.
+            // Returns an index for wasm's `memory.atomic.wait32` instruction.
+            #[cfg(feature = "threads")]
             memory_atomic_wait32(vmctx: vmctx, memory: i32, addr: i64, expected: i32, timeout: i64) -> i32;
-            /// Returns an index for wasm's `memory.atomic.wait64` instruction.
+            // Returns an index for wasm's `memory.atomic.wait64` instruction.
+            #[cfg(feature = "threads")]
             memory_atomic_wait64(vmctx: vmctx, memory: i32, addr: i64, expected: i64, timeout: i64) -> i32;
-            /// Invoked when fuel has run out while executing a function.
+            // Invoked when fuel has run out while executing a function.
             out_of_gas(vmctx: vmctx);
-            /// Invoked when we reach a new epoch.
+            // Invoked when we reach a new epoch.
             new_epoch(vmctx: vmctx) -> i64;
-            /// Invoked before malloc returns.
+            // Invoked before malloc returns.
+            #[cfg(feature = "wmemcheck")]
             check_malloc(vmctx: vmctx, addr: i32, len: i32) -> i32;
-            /// Invoked before the free returns.
+            // Invoked before the free returns.
+            #[cfg(feature = "wmemcheck")]
             check_free(vmctx: vmctx, addr: i32) -> i32;
-            /// Invoked before a load is executed.
+            // Invoked before a load is executed.
+            #[cfg(feature = "wmemcheck")]
             check_load(vmctx: vmctx, num_bytes: i32, addr: i32, offset: i32) -> i32;
-            /// Invoked before a store is executed.
+            // Invoked before a store is executed.
+            #[cfg(feature = "wmemcheck")]
             check_store(vmctx: vmctx, num_bytes: i32, addr: i32, offset: i32) -> i32;
-            /// Invoked after malloc is called.
+            // Invoked after malloc is called.
+            #[cfg(feature = "wmemcheck")]
             malloc_start(vmctx: vmctx);
-            /// Invoked after free is called.
+            // Invoked after free is called.
+            #[cfg(feature = "wmemcheck")]
             free_start(vmctx: vmctx);
-            /// Invoked when wasm stack pointer is updated.
+            // Invoked when wasm stack pointer is updated.
+            #[cfg(feature = "wmemcheck")]
             update_stack_pointer(vmctx: vmctx, value: i32);
-            /// Invoked before memory.grow is called.
+            // Invoked before memory.grow is called.
+            #[cfg(feature = "wmemcheck")]
             update_mem_size(vmctx: vmctx, num_bytes: i32);
+
+            // Drop a non-stack GC reference (eg an overwritten table entry)
+            // once it will no longer be used again. (Note: `val` is not of type
+            // `reference` because it needn't appear in any stack maps, as it
+            // must not be live after this call.)
+            #[cfg(feature = "gc")]
+            drop_gc_ref(vmctx: vmctx, val: i32);
+
+            // Do a GC, treating the optional `root` as a GC root and returning
+            // the updated `root` (so that, in the case of moving collectors,
+            // callers have a valid version of `root` again).
+            #[cfg(feature = "gc")]
+            gc(vmctx: vmctx, root: reference) -> reference;
+
+            // Implementation of Wasm's `global.get` instruction for globals
+            // containing GC references.
+            #[cfg(feature = "gc")]
+            gc_ref_global_get(vmctx: vmctx, global: i32) -> reference;
+
+            // Implementation of Wasm's `global.set` instruction for globals
+            // containing GC references.
+            #[cfg(feature = "gc")]
+            gc_ref_global_set(vmctx: vmctx, global: i32, val: reference);
+
+            // Returns an index for Wasm's `table.grow` instruction for GC references.
+            #[cfg(feature = "gc")]
+            table_grow_gc_ref(vmctx: vmctx, table: i32, delta: i32, init: reference) -> i32;
+
+            // Returns an index for Wasm's `table.fill` instruction for GC references.
+            #[cfg(feature = "gc")]
+            table_fill_gc_ref(vmctx: vmctx, table: i32, dst: i32, val: reference, len: i32);
         }
     };
 }
 
 /// An index type for builtin functions.
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct BuiltinFunctionIndex(u32);
 
 impl BuiltinFunctionIndex {
@@ -100,6 +129,17 @@ macro_rules! declare_indexes {
                 0;
                 $( $( #[$attr] )* $name; )*
             );
+
+            /// Returns a symbol name for this builtin.
+            pub fn name(&self) -> &'static str {
+                $(
+                    $( #[$attr] )*
+                    if *self == BuiltinFunctionIndex::$name() {
+                        return stringify!($name);
+                    }
+                )*
+                unreachable!()
+            }
         }
     };
 
@@ -128,6 +168,7 @@ macro_rules! declare_indexes {
          )*
     ) => {
         $( #[$this_attr] )*
+        #[allow(missing_docs)]
         pub const fn $this_name() -> Self {
             Self($index)
         }
diff --git a/crates/environ/src/compilation.rs b/crates/environ/src/compilation.rs
deleted file mode 100644
index eede6d3bff4a..000000000000
--- a/crates/environ/src/compilation.rs
+++ /dev/null
@@ -1,403 +0,0 @@
-//! A `Compilation` contains the compiled function bodies for a WebAssembly
-//! module.
-
-use crate::{obj, Tunables};
-use crate::{
-    DefinedFuncIndex, FilePos, FuncIndex, FunctionBodyData, ModuleTranslation, ModuleTypes,
-    PrimaryMap, StackMap, WasmError, WasmFuncType,
-};
-use anyhow::Result;
-use object::write::{Object, SymbolId};
-use object::{Architecture, BinaryFormat, FileFlags};
-use serde_derive::{Deserialize, Serialize};
-use std::any::Any;
-use std::borrow::Cow;
-use std::collections::BTreeMap;
-use std::fmt;
-use std::path;
-use std::sync::Arc;
-use thiserror::Error;
-
-/// Information about a function, such as trap information, address map,
-/// and stack maps.
-#[derive(Serialize, Deserialize, Default)]
-#[allow(missing_docs)]
-pub struct WasmFunctionInfo {
-    pub start_srcloc: FilePos,
-    pub stack_maps: Box<[StackMapInformation]>,
-}
-
-/// Description of where a function is located in the text section of a
-/// compiled image.
-#[derive(Copy, Clone, Serialize, Deserialize)]
-pub struct FunctionLoc {
-    /// The byte offset from the start of the text section where this
-    /// function starts.
-    pub start: u32,
-    /// The byte length of this function's function body.
-    pub length: u32,
-}
-
-/// The offset within a function of a GC safepoint, and its associated stack
-/// map.
-#[derive(Serialize, Deserialize, Debug)]
-pub struct StackMapInformation {
-    /// The offset of the GC safepoint within the function's native code. It is
-    /// relative to the beginning of the function.
-    pub code_offset: u32,
-
-    /// The stack map for identifying live GC refs at the GC safepoint.
-    pub stack_map: StackMap,
-}
-
-/// An error while compiling WebAssembly to machine code.
-#[derive(Error, Debug)]
-pub enum CompileError {
-    /// A wasm translation error occured.
-    #[error("WebAssembly translation error")]
-    Wasm(#[from] WasmError),
-
-    /// A compilation error occured.
-    #[error("Compilation error: {0}")]
-    Codegen(String),
-
-    /// A compilation error occured.
-    #[error("Debug info is not supported with this configuration")]
-    DebugInfoNotSupported,
-}
-
-/// Implementation of an incremental compilation's key/value cache store.
-///
-/// In theory, this could just be Cranelift's `CacheKvStore` trait, but it is not as we want to
-/// make sure that wasmtime isn't too tied to Cranelift internals (and as a matter of fact, we
-/// can't depend on the Cranelift trait here).
-pub trait CacheStore: Send + Sync + std::fmt::Debug {
-    /// Try to retrieve an arbitrary cache key entry, and returns a reference to bytes that were
-    /// inserted via `Self::insert` before.
-    fn get(&self, key: &[u8]) -> Option<Cow<[u8]>>;
-
-    /// Given an arbitrary key and bytes, stores them in the cache.
-    ///
-    /// Returns false when insertion in the cache failed.
-    fn insert(&self, key: &[u8], value: Vec<u8>) -> bool;
-}
-
-/// Abstract trait representing the ability to create a `Compiler` below.
-///
-/// This is used in Wasmtime to separate compiler implementations, currently
-/// mostly used to separate Cranelift from Wasmtime itself.
-pub trait CompilerBuilder: Send + Sync + fmt::Debug {
-    /// Sets the target of compilation to the target specified.
-    fn target(&mut self, target: target_lexicon::Triple) -> Result<()>;
-
-    /// Enables clif output in the directory specified.
-    fn clif_dir(&mut self, _path: &path::Path) -> Result<()> {
-        anyhow::bail!("clif output not supported");
-    }
-
-    /// Returns the currently configured target triple that compilation will
-    /// produce artifacts for.
-    fn triple(&self) -> &target_lexicon::Triple;
-
-    /// Compiler-specific method to configure various settings in the compiler
-    /// itself.
-    ///
-    /// This is expected to be defined per-compiler. Compilers should return
-    /// errors for unknown names/values.
-    fn set(&mut self, name: &str, val: &str) -> Result<()>;
-
-    /// Compiler-specific method for configuring settings.
-    ///
-    /// Same as [`CompilerBuilder::set`] except for enabling boolean flags.
-    /// Currently cranelift uses this to sometimes enable a family of settings.
-    fn enable(&mut self, name: &str) -> Result<()>;
-
-    /// Returns a list of all possible settings that can be configured with
-    /// [`CompilerBuilder::set`] and [`CompilerBuilder::enable`].
-    fn settings(&self) -> Vec<Setting>;
-
-    /// Enables Cranelift's incremental compilation cache, using the given `CacheStore`
-    /// implementation.
-    ///
-    /// This will return an error if the compiler does not support incremental compilation.
-    fn enable_incremental_compilation(&mut self, cache_store: Arc<dyn CacheStore>) -> Result<()>;
-
-    /// Set the tunables for this compiler.
-    fn set_tunables(&mut self, tunables: Tunables) -> Result<()>;
-
-    /// Builds a new [`Compiler`] object from this configuration.
-    fn build(&self) -> Result<Box<dyn Compiler>>;
-
-    /// Enables or disables wmemcheck during runtime according to the wmemcheck CLI flag.
-    fn wmemcheck(&mut self, _enable: bool) {}
-}
-
-/// Description of compiler settings returned by [`CompilerBuilder::settings`].
-#[derive(Clone, Copy, Debug)]
-pub struct Setting {
-    /// The name of the setting.
-    pub name: &'static str,
-    /// The description of the setting.
-    pub description: &'static str,
-    /// The kind of the setting.
-    pub kind: SettingKind,
-    /// The supported values of the setting (for enum values).
-    pub values: Option<&'static [&'static str]>,
-}
-
-/// Different kinds of [`Setting`] values that can be configured in a
-/// [`CompilerBuilder`]
-#[derive(Clone, Copy, Debug)]
-pub enum SettingKind {
-    /// The setting is an enumeration, meaning it's one of a set of values.
-    Enum,
-    /// The setting is a number.
-    Num,
-    /// The setting is a boolean.
-    Bool,
-    /// The setting is a preset.
-    Preset,
-}
-
-/// Types of objects that can be created by `Compiler::object`
-pub enum ObjectKind {
-    /// A core wasm compilation artifact
-    Module,
-    /// A component compilation artifact
-    Component,
-}
-
-/// An implementation of a compiler which can compile WebAssembly functions to
-/// machine code and perform other miscellaneous tasks needed by the JIT runtime.
-pub trait Compiler: Send + Sync {
-    /// Compiles the function `index` within `translation`.
-    ///
-    /// The body of the function is available in `data` and configuration
-    /// values are also passed in via `tunables`. Type information in
-    /// `translation` is all relative to `types`.
-    fn compile_function(
-        &self,
-        translation: &ModuleTranslation<'_>,
-        index: DefinedFuncIndex,
-        data: FunctionBodyData<'_>,
-        types: &ModuleTypes,
-    ) -> Result<(WasmFunctionInfo, Box<dyn Any + Send>), CompileError>;
-
-    /// Compile a trampoline for an array-call host function caller calling the
-    /// `index`th Wasm function.
-    ///
-    /// The trampoline should save the necessary state to record the
-    /// host-to-Wasm transition (e.g. registers used for fast stack walking).
-    fn compile_array_to_wasm_trampoline(
-        &self,
-        translation: &ModuleTranslation<'_>,
-        types: &ModuleTypes,
-        index: DefinedFuncIndex,
-    ) -> Result<Box<dyn Any + Send>, CompileError>;
-
-    /// Compile a trampoline for a native-call host function caller calling the
-    /// `index`th Wasm function.
-    ///
-    /// The trampoline should save the necessary state to record the
-    /// host-to-Wasm transition (e.g. registers used for fast stack walking).
-    fn compile_native_to_wasm_trampoline(
-        &self,
-        translation: &ModuleTranslation<'_>,
-        types: &ModuleTypes,
-        index: DefinedFuncIndex,
-    ) -> Result<Box<dyn Any + Send>, CompileError>;
-
-    /// Compile a trampoline for a Wasm caller calling a native callee with the
-    /// given signature.
-    ///
-    /// The trampoline should save the necessary state to record the
-    /// Wasm-to-host transition (e.g. registers used for fast stack walking).
-    fn compile_wasm_to_native_trampoline(
-        &self,
-        wasm_func_ty: &WasmFuncType,
-    ) -> Result<Box<dyn Any + Send>, CompileError>;
-
-    /// Appends a list of compiled functions to an in-memory object.
-    ///
-    /// This function will receive the same `Box<dyn Any>` produced as part of
-    /// compilation from functions like `compile_function`,
-    /// `compile_host_to_wasm_trampoline`, and other component-related shims.
-    /// Internally this will take all of these functions and add information to
-    /// the object such as:
-    ///
-    /// * Compiled code in a `.text` section
-    /// * Unwind information in Wasmtime-specific sections
-    /// * Relocations, if necessary, for the text section
-    ///
-    /// Each function is accompanied with its desired symbol name and the return
-    /// value of this function is the symbol for each function as well as where
-    /// each function was placed within the object.
-    ///
-    /// The `resolve_reloc` argument is intended to resolving relocations
-    /// between function, chiefly resolving intra-module calls within one core
-    /// wasm module. The closure here takes two arguments:
-    ///
-    /// 1. First, the index within `funcs` that is being resolved,
-    ///
-    /// 2. and next the `FuncIndex` which is the relocation target to
-    /// resolve.
-    ///
-    /// The return value is an index within `funcs` that the relocation points
-    /// to.
-    fn append_code(
-        &self,
-        obj: &mut Object<'static>,
-        funcs: &[(String, Box<dyn Any + Send>)],
-        resolve_reloc: &dyn Fn(usize, FuncIndex) -> usize,
-    ) -> Result<Vec<(SymbolId, FunctionLoc)>>;
-
-    /// Inserts two trampolines into `obj` for a array-call host function:
-    ///
-    /// 1. A wasm-call trampoline: A trampoline that takes arguments in their
-    ///    wasm-call locations, moves them to their array-call locations, calls
-    ///    the array-call host function, and finally moves the return values
-    ///    from the array-call locations to the wasm-call return
-    ///    locations. Additionally, this trampoline manages the wasm-to-host
-    ///    state transition for the runtime.
-    ///
-    /// 2. A native-call trampoline: A trampoline that takes arguments in their
-    ///    native-call locations, moves them to their array-call locations,
-    ///    calls the array-call host function, and finally moves the return
-    ///    values from the array-call locations to the native-call return
-    ///    locations. Does not need to manage any wasm/host state transitions,
-    ///    since both caller and callee are on the host side.
-    ///
-    /// This will configure the same sections as `append_code`, but will likely
-    /// be much smaller.
-    ///
-    /// The two returned `FunctionLoc` structures describe where to find these
-    /// trampolines in the text section, respectively.
-    ///
-    /// These trampolines are only valid for in-process JIT usage. They bake in
-    /// the function pointer to the host code.
-    fn emit_trampolines_for_array_call_host_func(
-        &self,
-        ty: &WasmFuncType,
-        // Actually `host_fn: VMArrayCallFunction` but that type is not
-        // available in `wasmtime-environ`.
-        host_fn: usize,
-        obj: &mut Object<'static>,
-    ) -> Result<(FunctionLoc, FunctionLoc)>;
-
-    /// Creates a new `Object` file which is used to build the results of a
-    /// compilation into.
-    ///
-    /// The returned object file will have an appropriate
-    /// architecture/endianness for `self.triple()`, but at this time it is
-    /// always an ELF file, regardless of target platform.
-    fn object(&self, kind: ObjectKind) -> Result<Object<'static>> {
-        use target_lexicon::Architecture::*;
-
-        let triple = self.triple();
-        let mut obj = Object::new(
-            BinaryFormat::Elf,
-            match triple.architecture {
-                X86_32(_) => Architecture::I386,
-                X86_64 => Architecture::X86_64,
-                Arm(_) => Architecture::Arm,
-                Aarch64(_) => Architecture::Aarch64,
-                S390x => Architecture::S390x,
-                Riscv64(_) => Architecture::Riscv64,
-                architecture => {
-                    anyhow::bail!("target architecture {:?} is unsupported", architecture,);
-                }
-            },
-            match triple.endianness().unwrap() {
-                target_lexicon::Endianness::Little => object::Endianness::Little,
-                target_lexicon::Endianness::Big => object::Endianness::Big,
-            },
-        );
-        obj.flags = FileFlags::Elf {
-            os_abi: obj::ELFOSABI_WASMTIME,
-            e_flags: match kind {
-                ObjectKind::Module => obj::EF_WASMTIME_MODULE,
-                ObjectKind::Component => obj::EF_WASMTIME_COMPONENT,
-            },
-            abi_version: 0,
-        };
-        Ok(obj)
-    }
-
-    /// Returns the target triple that this compiler is compiling for.
-    fn triple(&self) -> &target_lexicon::Triple;
-
-    /// Returns the alignment necessary to align values to the page size of the
-    /// compilation target. Note that this may be an upper-bound where the
-    /// alignment is larger than necessary for some platforms since it may
-    /// depend on the platform's runtime configuration.
-    fn page_size_align(&self) -> u64 {
-        use target_lexicon::*;
-        match (self.triple().operating_system, self.triple().architecture) {
-            (
-                OperatingSystem::MacOSX { .. }
-                | OperatingSystem::Darwin
-                | OperatingSystem::Ios
-                | OperatingSystem::Tvos,
-                Architecture::Aarch64(..),
-            ) => 0x4000,
-            // 64 KB is the maximal page size (i.e. memory translation granule size)
-            // supported by the architecture and is used on some platforms.
-            (_, Architecture::Aarch64(..)) => 0x10000,
-            _ => 0x1000,
-        }
-    }
-
-    /// Returns a list of configured settings for this compiler.
-    fn flags(&self) -> BTreeMap<String, FlagValue>;
-
-    /// Same as [`Compiler::flags`], but ISA-specific (a cranelift-ism)
-    fn isa_flags(&self) -> BTreeMap<String, FlagValue>;
-
-    /// Get a flag indicating whether branch protection is enabled.
-    fn is_branch_protection_enabled(&self) -> bool;
-
-    /// Returns a suitable compiler usable for component-related compliations.
-    ///
-    /// Note that the `ComponentCompiler` trait can also be implemented for
-    /// `Self` in which case this function would simply return `self`.
-    #[cfg(feature = "component-model")]
-    fn component_compiler(&self) -> &dyn crate::component::ComponentCompiler;
-
-    /// Appends generated DWARF sections to the `obj` specified for the compiled
-    /// functions.
-    fn append_dwarf(
-        &self,
-        obj: &mut Object<'_>,
-        translation: &ModuleTranslation<'_>,
-        funcs: &PrimaryMap<DefinedFuncIndex, (SymbolId, &(dyn Any + Send))>,
-    ) -> Result<()>;
-
-    /// Creates a new System V Common Information Entry for the ISA.
-    ///
-    /// Returns `None` if the ISA does not support System V unwind information.
-    fn create_systemv_cie(&self) -> Option<gimli::write::CommonInformationEntry> {
-        // By default, an ISA cannot create a System V CIE.
-        None
-    }
-}
-
-/// Value of a configured setting for a [`Compiler`]
-#[derive(Serialize, Deserialize, Hash, Eq, PartialEq, Debug)]
-pub enum FlagValue {
-    /// Name of the value that has been configured for this setting.
-    Enum(Cow<'static, str>),
-    /// The numerical value of the configured settings.
-    Num(u8),
-    /// Whether the setting is on or off.
-    Bool(bool),
-}
-
-impl fmt::Display for FlagValue {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Self::Enum(v) => v.fmt(f),
-            Self::Num(v) => v.fmt(f),
-            Self::Bool(v) => v.fmt(f),
-        }
-    }
-}
diff --git a/crates/environ/src/compile/address_map.rs b/crates/environ/src/compile/address_map.rs
new file mode 100644
index 000000000000..6bdaa0bd5af5
--- /dev/null
+++ b/crates/environ/src/compile/address_map.rs
@@ -0,0 +1,73 @@
+//! Data structures to provide transformation of the source
+
+use crate::obj::ELF_WASMTIME_ADDRMAP;
+use crate::prelude::*;
+use crate::InstructionAddressMap;
+use object::write::{Object, StandardSegment};
+use object::{LittleEndian, SectionKind, U32Bytes};
+use std::ops::Range;
+
+/// Builder for the address map section of a wasmtime compilation image.
+///
+/// This builder is used to conveniently built the `ELF_WASMTIME_ADDRMAP`
+/// section by compilers, and provides utilities to directly insert the results
+/// into an `Object`.
+#[derive(Default)]
+pub struct AddressMapSection {
+    offsets: Vec<U32Bytes<LittleEndian>>,
+    positions: Vec<U32Bytes<LittleEndian>>,
+    last_offset: u32,
+}
+
+impl AddressMapSection {
+    /// Pushes a new set of instruction mapping information for a function added
+    /// in the executable.
+    ///
+    /// The `func` argument here is the range of the function, relative to the
+    /// start of the text section in the executable. The `instrs` provided are
+    /// the descriptors for instructions in the function and their various
+    /// mappings back to original source positions.
+    ///
+    /// This is required to be called for `func` values that are strictly
+    /// increasing in addresses (e.g. as the object is built). Additionally the
+    /// `instrs` map must be sorted based on code offset in the native text
+    /// section.
+    pub fn push(&mut self, func: Range<u64>, instrs: &[InstructionAddressMap]) {
+        // NB: for now this only supports <=4GB text sections in object files.
+        // Alternative schemes will need to be created for >32-bit offsets to
+        // avoid making this section overly large.
+        let func_start = u32::try_from(func.start).unwrap();
+        let func_end = u32::try_from(func.end).unwrap();
+
+        self.offsets.reserve(instrs.len());
+        self.positions.reserve(instrs.len());
+        for map in instrs {
+            // Sanity-check to ensure that functions are pushed in-order, otherwise
+            // the `offsets` array won't be sorted which is our goal.
+            let pos = func_start + map.code_offset;
+            assert!(pos >= self.last_offset);
+            self.offsets.push(U32Bytes::new(LittleEndian, pos));
+            self.positions.push(U32Bytes::new(
+                LittleEndian,
+                map.srcloc.file_offset().unwrap_or(u32::MAX),
+            ));
+            self.last_offset = pos;
+        }
+        self.last_offset = func_end;
+    }
+
+    /// Finishes encoding this section into the `Object` provided.
+    pub fn append_to(self, obj: &mut Object) {
+        let section = obj.add_section(
+            obj.segment_name(StandardSegment::Data).to_vec(),
+            ELF_WASMTIME_ADDRMAP.as_bytes().to_vec(),
+            SectionKind::ReadOnlyData,
+        );
+
+        // NB: this matches the encoding expected by `lookup` below.
+        let amt = u32::try_from(self.offsets.len()).unwrap();
+        obj.append_section_data(section, &amt.to_le_bytes(), 1);
+        obj.append_section_data(section, object::bytes_of_slice(&self.offsets), 1);
+        obj.append_section_data(section, object::bytes_of_slice(&self.positions), 1);
+    }
+}
diff --git a/crates/environ/src/compile/mod.rs b/crates/environ/src/compile/mod.rs
new file mode 100644
index 000000000000..0af013a9f11b
--- /dev/null
+++ b/crates/environ/src/compile/mod.rs
@@ -0,0 +1,379 @@
+//! A `Compilation` contains the compiled function bodies for a WebAssembly
+//! module.
+
+use crate::prelude::*;
+use crate::{obj, Tunables};
+use crate::{
+    BuiltinFunctionIndex, DefinedFuncIndex, FlagValue, FuncIndex, FunctionLoc, ObjectKind,
+    PrimaryMap, StaticModuleIndex, WasmError, WasmFuncType, WasmFunctionInfo,
+};
+use anyhow::Result;
+use object::write::{Object, SymbolId};
+use object::{Architecture, BinaryFormat, FileFlags};
+use std::any::Any;
+use std::borrow::Cow;
+use std::fmt;
+use std::path;
+use std::sync::Arc;
+
+mod address_map;
+mod module_artifacts;
+mod module_environ;
+mod module_types;
+mod trap_encoding;
+
+pub use self::address_map::*;
+pub use self::module_artifacts::*;
+pub use self::module_environ::*;
+pub use self::module_types::*;
+pub use self::trap_encoding::*;
+
+/// An error while compiling WebAssembly to machine code.
+#[derive(Debug)]
+pub enum CompileError {
+    /// A wasm translation error occurred.
+    Wasm(WasmError),
+
+    /// A compilation error occurred.
+    Codegen(String),
+
+    /// A compilation error occurred.
+    DebugInfoNotSupported,
+}
+
+impl fmt::Display for CompileError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            CompileError::Wasm(_) => write!(f, "WebAssembly translation error"),
+            CompileError::Codegen(s) => write!(f, "Compilation error: {s}"),
+            CompileError::DebugInfoNotSupported => {
+                write!(f, "Debug info is not supported with this configuration")
+            }
+        }
+    }
+}
+
+impl From<WasmError> for CompileError {
+    fn from(err: WasmError) -> CompileError {
+        CompileError::Wasm(err)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for CompileError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            CompileError::Wasm(e) => Some(e),
+            _ => None,
+        }
+    }
+}
+
+/// What relocations can be applied against.
+///
+/// Each wasm function may refer to various other `RelocationTarget` entries.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum RelocationTarget {
+    /// This is a reference to another defined wasm function in the same module.
+    Wasm(FuncIndex),
+    /// This is a reference to a trampoline for a builtin function.
+    Builtin(BuiltinFunctionIndex),
+    /// A compiler-generated libcall.
+    HostLibcall(obj::LibCall),
+}
+
+/// Implementation of an incremental compilation's key/value cache store.
+///
+/// In theory, this could just be Cranelift's `CacheKvStore` trait, but it is not as we want to
+/// make sure that wasmtime isn't too tied to Cranelift internals (and as a matter of fact, we
+/// can't depend on the Cranelift trait here).
+pub trait CacheStore: Send + Sync + std::fmt::Debug {
+    /// Try to retrieve an arbitrary cache key entry, and returns a reference to bytes that were
+    /// inserted via `Self::insert` before.
+    fn get(&self, key: &[u8]) -> Option<Cow<[u8]>>;
+
+    /// Given an arbitrary key and bytes, stores them in the cache.
+    ///
+    /// Returns false when insertion in the cache failed.
+    fn insert(&self, key: &[u8], value: Vec<u8>) -> bool;
+}
+
+/// Abstract trait representing the ability to create a `Compiler` below.
+///
+/// This is used in Wasmtime to separate compiler implementations, currently
+/// mostly used to separate Cranelift from Wasmtime itself.
+pub trait CompilerBuilder: Send + Sync + fmt::Debug {
+    /// Sets the target of compilation to the target specified.
+    fn target(&mut self, target: target_lexicon::Triple) -> Result<()>;
+
+    /// Enables clif output in the directory specified.
+    fn clif_dir(&mut self, _path: &path::Path) -> Result<()> {
+        anyhow::bail!("clif output not supported");
+    }
+
+    /// Returns the currently configured target triple that compilation will
+    /// produce artifacts for.
+    fn triple(&self) -> &target_lexicon::Triple;
+
+    /// Compiler-specific method to configure various settings in the compiler
+    /// itself.
+    ///
+    /// This is expected to be defined per-compiler. Compilers should return
+    /// errors for unknown names/values.
+    fn set(&mut self, name: &str, val: &str) -> Result<()>;
+
+    /// Compiler-specific method for configuring settings.
+    ///
+    /// Same as [`CompilerBuilder::set`] except for enabling boolean flags.
+    /// Currently cranelift uses this to sometimes enable a family of settings.
+    fn enable(&mut self, name: &str) -> Result<()>;
+
+    /// Returns a list of all possible settings that can be configured with
+    /// [`CompilerBuilder::set`] and [`CompilerBuilder::enable`].
+    fn settings(&self) -> Vec<Setting>;
+
+    /// Enables Cranelift's incremental compilation cache, using the given `CacheStore`
+    /// implementation.
+    ///
+    /// This will return an error if the compiler does not support incremental compilation.
+    fn enable_incremental_compilation(&mut self, cache_store: Arc<dyn CacheStore>) -> Result<()>;
+
+    /// Set the tunables for this compiler.
+    fn set_tunables(&mut self, tunables: Tunables) -> Result<()>;
+
+    /// Builds a new [`Compiler`] object from this configuration.
+    fn build(&self) -> Result<Box<dyn Compiler>>;
+
+    /// Enables or disables wmemcheck during runtime according to the wmemcheck CLI flag.
+    fn wmemcheck(&mut self, _enable: bool) {}
+}
+
+/// Description of compiler settings returned by [`CompilerBuilder::settings`].
+#[derive(Clone, Copy, Debug)]
+pub struct Setting {
+    /// The name of the setting.
+    pub name: &'static str,
+    /// The description of the setting.
+    pub description: &'static str,
+    /// The kind of the setting.
+    pub kind: SettingKind,
+    /// The supported values of the setting (for enum values).
+    pub values: Option<&'static [&'static str]>,
+}
+
+/// Different kinds of [`Setting`] values that can be configured in a
+/// [`CompilerBuilder`]
+#[derive(Clone, Copy, Debug)]
+pub enum SettingKind {
+    /// The setting is an enumeration, meaning it's one of a set of values.
+    Enum,
+    /// The setting is a number.
+    Num,
+    /// The setting is a boolean.
+    Bool,
+    /// The setting is a preset.
+    Preset,
+}
+
+/// An implementation of a compiler which can compile WebAssembly functions to
+/// machine code and perform other miscellaneous tasks needed by the JIT runtime.
+pub trait Compiler: Send + Sync {
+    /// Compiles the function `index` within `translation`.
+    ///
+    /// The body of the function is available in `data` and configuration
+    /// values are also passed in via `tunables`. Type information in
+    /// `translation` is all relative to `types`.
+    ///
+    /// This function returns a tuple:
+    ///
+    /// 1. Metadata about the wasm function itself.
+    /// 2. The function itself, as an `Any` to get downcasted later when passed
+    ///    to `append_code`.
+    fn compile_function(
+        &self,
+        translation: &ModuleTranslation<'_>,
+        index: DefinedFuncIndex,
+        data: FunctionBodyData<'_>,
+        types: &ModuleTypesBuilder,
+    ) -> Result<(WasmFunctionInfo, Box<dyn Any + Send>), CompileError>;
+
+    /// Compile a trampoline for an array-call host function caller calling the
+    /// `index`th Wasm function.
+    ///
+    /// The trampoline should save the necessary state to record the
+    /// host-to-Wasm transition (e.g. registers used for fast stack walking).
+    fn compile_array_to_wasm_trampoline(
+        &self,
+        translation: &ModuleTranslation<'_>,
+        types: &ModuleTypesBuilder,
+        index: DefinedFuncIndex,
+    ) -> Result<Box<dyn Any + Send>, CompileError>;
+
+    /// Compile a trampoline for a Wasm caller calling a array callee with the
+    /// given signature.
+    ///
+    /// The trampoline should save the necessary state to record the
+    /// Wasm-to-host transition (e.g. registers used for fast stack walking).
+    fn compile_wasm_to_array_trampoline(
+        &self,
+        wasm_func_ty: &WasmFuncType,
+    ) -> Result<Box<dyn Any + Send>, CompileError>;
+
+    /// Creates a tramopline that can be used to call Wasmtime's implementation
+    /// of the builtin function specified by `index`.
+    ///
+    /// The trampoline created can technically have any ABI but currently has
+    /// the native ABI. This will then perform all the necessary duties of an
+    /// exit trampoline from wasm and then perform the actual dispatch to the
+    /// builtin function. Builtin functions in Wasmtime are stored in an array
+    /// in all `VMContext` pointers, so the call to the host is an indirect
+    /// call.
+    fn compile_wasm_to_builtin(
+        &self,
+        index: BuiltinFunctionIndex,
+    ) -> Result<Box<dyn Any + Send>, CompileError>;
+
+    /// Returns the list of relocations required for a function from one of the
+    /// previous `compile_*` functions above.
+    fn compiled_function_relocation_targets<'a>(
+        &'a self,
+        func: &'a dyn Any,
+    ) -> Box<dyn Iterator<Item = RelocationTarget> + 'a>;
+
+    /// Appends a list of compiled functions to an in-memory object.
+    ///
+    /// This function will receive the same `Box<dyn Any>` produced as part of
+    /// compilation from functions like `compile_function`,
+    /// `compile_host_to_wasm_trampoline`, and other component-related shims.
+    /// Internally this will take all of these functions and add information to
+    /// the object such as:
+    ///
+    /// * Compiled code in a `.text` section
+    /// * Unwind information in Wasmtime-specific sections
+    /// * Relocations, if necessary, for the text section
+    ///
+    /// Each function is accompanied with its desired symbol name and the return
+    /// value of this function is the symbol for each function as well as where
+    /// each function was placed within the object.
+    ///
+    /// The `resolve_reloc` argument is intended to resolving relocations
+    /// between function, chiefly resolving intra-module calls within one core
+    /// wasm module. The closure here takes two arguments:
+    ///
+    /// 1. First, the index within `funcs` that is being resolved,
+    ///
+    /// 2. and next the `RelocationTarget` which is the relocation target to
+    ///    resolve.
+    ///
+    /// The return value is an index within `funcs` that the relocation points
+    /// to.
+    fn append_code(
+        &self,
+        obj: &mut Object<'static>,
+        funcs: &[(String, Box<dyn Any + Send>)],
+        resolve_reloc: &dyn Fn(usize, RelocationTarget) -> usize,
+    ) -> Result<Vec<(SymbolId, FunctionLoc)>>;
+
+    /// Creates a new `Object` file which is used to build the results of a
+    /// compilation into.
+    ///
+    /// The returned object file will have an appropriate
+    /// architecture/endianness for `self.triple()`, but at this time it is
+    /// always an ELF file, regardless of target platform.
+    fn object(&self, kind: ObjectKind) -> Result<Object<'static>> {
+        use target_lexicon::Architecture::*;
+
+        let triple = self.triple();
+        let mut obj = Object::new(
+            BinaryFormat::Elf,
+            match triple.architecture {
+                X86_32(_) => Architecture::I386,
+                X86_64 => Architecture::X86_64,
+                Arm(_) => Architecture::Arm,
+                Aarch64(_) => Architecture::Aarch64,
+                S390x => Architecture::S390x,
+                Riscv64(_) => Architecture::Riscv64,
+                architecture => {
+                    anyhow::bail!("target architecture {:?} is unsupported", architecture,);
+                }
+            },
+            match triple.endianness().unwrap() {
+                target_lexicon::Endianness::Little => object::Endianness::Little,
+                target_lexicon::Endianness::Big => object::Endianness::Big,
+            },
+        );
+        obj.flags = FileFlags::Elf {
+            os_abi: obj::ELFOSABI_WASMTIME,
+            e_flags: match kind {
+                ObjectKind::Module => obj::EF_WASMTIME_MODULE,
+                ObjectKind::Component => obj::EF_WASMTIME_COMPONENT,
+            },
+            abi_version: 0,
+        };
+        Ok(obj)
+    }
+
+    /// Returns the target triple that this compiler is compiling for.
+    fn triple(&self) -> &target_lexicon::Triple;
+
+    /// Returns the alignment necessary to align values to the page size of the
+    /// compilation target. Note that this may be an upper-bound where the
+    /// alignment is larger than necessary for some platforms since it may
+    /// depend on the platform's runtime configuration.
+    fn page_size_align(&self) -> u64 {
+        use target_lexicon::*;
+        match (self.triple().operating_system, self.triple().architecture) {
+            (
+                OperatingSystem::MacOSX { .. }
+                | OperatingSystem::Darwin
+                | OperatingSystem::Ios
+                | OperatingSystem::Tvos,
+                Architecture::Aarch64(..),
+            ) => 0x4000,
+            // 64 KB is the maximal page size (i.e. memory translation granule size)
+            // supported by the architecture and is used on some platforms.
+            (_, Architecture::Aarch64(..)) => 0x10000,
+            _ => 0x1000,
+        }
+    }
+
+    /// Returns a list of configured settings for this compiler.
+    fn flags(&self) -> Vec<(&'static str, FlagValue<'static>)>;
+
+    /// Same as [`Compiler::flags`], but ISA-specific (a cranelift-ism)
+    fn isa_flags(&self) -> Vec<(&'static str, FlagValue<'static>)>;
+
+    /// Get a flag indicating whether branch protection is enabled.
+    fn is_branch_protection_enabled(&self) -> bool;
+
+    /// Returns a suitable compiler usable for component-related compilations.
+    ///
+    /// Note that the `ComponentCompiler` trait can also be implemented for
+    /// `Self` in which case this function would simply return `self`.
+    #[cfg(feature = "component-model")]
+    fn component_compiler(&self) -> &dyn crate::component::ComponentCompiler;
+
+    /// Appends generated DWARF sections to the `obj` specified.
+    ///
+    /// The `translations` track all compiled functions and `get_func` can be
+    /// used to acquire the metadata for a particular function within a module.
+    fn append_dwarf<'a>(
+        &self,
+        obj: &mut Object<'_>,
+        translations: &'a PrimaryMap<StaticModuleIndex, ModuleTranslation<'a>>,
+        get_func: &'a dyn Fn(
+            StaticModuleIndex,
+            DefinedFuncIndex,
+        ) -> (SymbolId, &'a (dyn Any + Send)),
+        dwarf_package_bytes: Option<&'a [u8]>,
+        tunables: &'a Tunables,
+    ) -> Result<()>;
+
+    /// Creates a new System V Common Information Entry for the ISA.
+    ///
+    /// Returns `None` if the ISA does not support System V unwind information.
+    fn create_systemv_cie(&self) -> Option<gimli::write::CommonInformationEntry> {
+        // By default, an ISA cannot create a System V CIE.
+        None
+    }
+}
diff --git a/crates/environ/src/compile/module_artifacts.rs b/crates/environ/src/compile/module_artifacts.rs
new file mode 100644
index 000000000000..8449c456d5d1
--- /dev/null
+++ b/crates/environ/src/compile/module_artifacts.rs
@@ -0,0 +1,315 @@
+//! Definitions of runtime structures and metadata which are serialized into ELF
+//! with `postcard` as part of a module's compilation process.
+
+use crate::prelude::*;
+use crate::{
+    obj, CompiledFunctionInfo, CompiledModuleInfo, DebugInfoData, DefinedFuncIndex, FunctionLoc,
+    FunctionName, MemoryInitialization, Metadata, ModuleTranslation, PrimaryMap, Tunables,
+};
+use anyhow::{bail, Result};
+use object::write::{Object, SectionId, StandardSegment, WritableBuffer};
+use object::SectionKind;
+use std::ops::Range;
+use wasmtime_types::ModuleInternedTypeIndex;
+
+/// Helper structure to create an ELF file as a compilation artifact.
+///
+/// This structure exposes the process which Wasmtime will encode a core wasm
+/// module into an ELF file, notably managing data sections and all that good
+/// business going into the final file.
+pub struct ObjectBuilder<'a> {
+    /// The `object`-crate-defined ELF file write we're using.
+    obj: Object<'a>,
+
+    /// General compilation configuration.
+    tunables: &'a Tunables,
+
+    /// The section identifier for "rodata" which is where wasm data segments
+    /// will go.
+    data: SectionId,
+
+    /// The section identifier for function name information, or otherwise where
+    /// the `name` custom section of wasm is copied into.
+    ///
+    /// This is optional and lazily created on demand.
+    names: Option<SectionId>,
+
+    /// The section identifier for dwarf information copied from the original
+    /// wasm files.
+    ///
+    /// This is optional and lazily created on demand.
+    dwarf: Option<SectionId>,
+}
+
+impl<'a> ObjectBuilder<'a> {
+    /// Creates a new builder for the `obj` specified.
+    pub fn new(mut obj: Object<'a>, tunables: &'a Tunables) -> ObjectBuilder<'a> {
+        let data = obj.add_section(
+            obj.segment_name(StandardSegment::Data).to_vec(),
+            obj::ELF_WASM_DATA.as_bytes().to_vec(),
+            SectionKind::ReadOnlyData,
+        );
+        ObjectBuilder {
+            obj,
+            tunables,
+            data,
+            names: None,
+            dwarf: None,
+        }
+    }
+
+    /// Insert the wasm raw wasm-based debuginfo into the output.
+    /// Note that this is distinct from the native debuginfo
+    /// possibly generated by the native compiler, hence these sections
+    /// getting wasm-specific names.
+    pub fn push_debuginfo(
+        &mut self,
+        dwarf: &mut Vec<(u8, Range<u64>)>,
+        debuginfo: &DebugInfoData<'_>,
+    ) {
+        self.push_debug(dwarf, &debuginfo.dwarf.debug_abbrev);
+        self.push_debug(dwarf, &debuginfo.dwarf.debug_addr);
+        self.push_debug(dwarf, &debuginfo.dwarf.debug_aranges);
+        self.push_debug(dwarf, &debuginfo.dwarf.debug_info);
+        self.push_debug(dwarf, &debuginfo.dwarf.debug_line);
+        self.push_debug(dwarf, &debuginfo.dwarf.debug_line_str);
+        self.push_debug(dwarf, &debuginfo.dwarf.debug_str);
+        self.push_debug(dwarf, &debuginfo.dwarf.debug_str_offsets);
+        self.push_debug(dwarf, &debuginfo.debug_ranges);
+        self.push_debug(dwarf, &debuginfo.debug_rnglists);
+        self.push_debug(dwarf, &debuginfo.debug_cu_index);
+
+        // Sort this for binary-search-lookup later in `symbolize_context`.
+        dwarf.sort_by_key(|(id, _)| *id);
+    }
+
+    /// Completes compilation of the `translation` specified, inserting
+    /// everything necessary into the `Object` being built.
+    ///
+    /// This function will consume the final results of compiling a wasm module
+    /// and finish the ELF image in-progress as part of `self.obj` by appending
+    /// any compiler-agnostic sections.
+    ///
+    /// The auxiliary `CompiledModuleInfo` structure returned here has also been
+    /// serialized into the object returned, but if the caller will quickly
+    /// turn-around and invoke `CompiledModule::from_artifacts` after this then
+    /// the information can be passed to that method to avoid extra
+    /// deserialization. This is done to avoid a serialize-then-deserialize for
+    /// API calls like `Module::new` where the compiled module is immediately
+    /// going to be used.
+    ///
+    /// The various arguments here are:
+    ///
+    /// * `translation` - the core wasm translation that's being completed.
+    ///
+    /// * `funcs` - compilation metadata about functions within the translation
+    ///   as well as where the functions are located in the text section and any
+    ///   associated trampolines.
+    ///
+    /// * `wasm_to_array_trampolines` - list of all trampolines necessary for
+    ///   Wasm callers calling array callees (e.g. `Func::wrap`). One for each
+    ///   function signature in the module. Must be sorted by `SignatureIndex`.
+    ///
+    /// Returns the `CompiledModuleInfo` corresponding to this core Wasm module
+    /// as a result of this append operation. This is then serialized into the
+    /// final artifact by the caller.
+    pub fn append(
+        &mut self,
+        translation: ModuleTranslation<'_>,
+        funcs: PrimaryMap<DefinedFuncIndex, CompiledFunctionInfo>,
+        wasm_to_array_trampolines: Vec<(ModuleInternedTypeIndex, FunctionLoc)>,
+    ) -> Result<CompiledModuleInfo> {
+        let ModuleTranslation {
+            mut module,
+            debuginfo,
+            has_unparsed_debuginfo,
+            data,
+            data_align,
+            passive_data,
+            ..
+        } = translation;
+
+        // Place all data from the wasm module into a section which will the
+        // source of the data later at runtime. This additionally keeps track of
+        // the offset of
+        let mut total_data_len = 0;
+        let data_offset = self
+            .obj
+            .append_section_data(self.data, &[], data_align.unwrap_or(1));
+        for (i, data) in data.iter().enumerate() {
+            // The first data segment has its alignment specified as the alignment
+            // for the entire section, but everything afterwards is adjacent so it
+            // has alignment of 1.
+            let align = if i == 0 { data_align.unwrap_or(1) } else { 1 };
+            self.obj.append_section_data(self.data, data, align);
+            total_data_len += data.len();
+        }
+        for data in passive_data.iter() {
+            self.obj.append_section_data(self.data, data, 1);
+        }
+
+        // If any names are present in the module then the `ELF_NAME_DATA` section
+        // is create and appended.
+        let mut func_names = Vec::new();
+        if debuginfo.name_section.func_names.len() > 0 {
+            let name_id = *self.names.get_or_insert_with(|| {
+                self.obj.add_section(
+                    self.obj.segment_name(StandardSegment::Data).to_vec(),
+                    obj::ELF_NAME_DATA.as_bytes().to_vec(),
+                    SectionKind::ReadOnlyData,
+                )
+            });
+            let mut sorted_names = debuginfo.name_section.func_names.iter().collect::<Vec<_>>();
+            sorted_names.sort_by_key(|(idx, _name)| *idx);
+            for (idx, name) in sorted_names {
+                let offset = self.obj.append_section_data(name_id, name.as_bytes(), 1);
+                let offset = match u32::try_from(offset) {
+                    Ok(offset) => offset,
+                    Err(_) => bail!("name section too large (> 4gb)"),
+                };
+                let len = u32::try_from(name.len()).unwrap();
+                func_names.push(FunctionName {
+                    idx: *idx,
+                    offset,
+                    len,
+                });
+            }
+        }
+
+        // Data offsets in `MemoryInitialization` are offsets within the
+        // `translation.data` list concatenated which is now present in the data
+        // segment that's appended to the object. Increase the offsets by
+        // `self.data_size` to account for any previously added module.
+        let data_offset = u32::try_from(data_offset).unwrap();
+        match &mut module.memory_initialization {
+            MemoryInitialization::Segmented(list) => {
+                for segment in list {
+                    segment.data.start = segment.data.start.checked_add(data_offset).unwrap();
+                    segment.data.end = segment.data.end.checked_add(data_offset).unwrap();
+                }
+            }
+            MemoryInitialization::Static { map } => {
+                for (_, segment) in map {
+                    if let Some(segment) = segment {
+                        segment.data.start = segment.data.start.checked_add(data_offset).unwrap();
+                        segment.data.end = segment.data.end.checked_add(data_offset).unwrap();
+                    }
+                }
+            }
+        }
+
+        // Data offsets for passive data are relative to the start of
+        // `translation.passive_data` which was appended to the data segment
+        // of this object, after active data in `translation.data`. Update the
+        // offsets to account prior modules added in addition to active data.
+        let data_offset = data_offset + u32::try_from(total_data_len).unwrap();
+        for (_, range) in module.passive_data_map.iter_mut() {
+            range.start = range.start.checked_add(data_offset).unwrap();
+            range.end = range.end.checked_add(data_offset).unwrap();
+        }
+
+        // Insert the wasm raw wasm-based debuginfo into the output, if
+        // requested. Note that this is distinct from the native debuginfo
+        // possibly generated by the native compiler, hence these sections
+        // getting wasm-specific names.
+        let mut dwarf = Vec::new();
+        if self.tunables.parse_wasm_debuginfo {
+            self.push_debuginfo(&mut dwarf, &debuginfo);
+        }
+
+        Ok(CompiledModuleInfo {
+            module,
+            funcs,
+            wasm_to_array_trampolines,
+            func_names,
+            meta: Metadata {
+                native_debug_info_present: self.tunables.generate_native_debuginfo,
+                has_unparsed_debuginfo,
+                code_section_offset: debuginfo.wasm_file.code_section_offset,
+                has_wasm_debuginfo: self.tunables.parse_wasm_debuginfo,
+                dwarf,
+            },
+        })
+    }
+
+    fn push_debug<'b, T>(&mut self, dwarf: &mut Vec<(u8, Range<u64>)>, section: &T)
+    where
+        T: gimli::Section<gimli::EndianSlice<'b, gimli::LittleEndian>>,
+    {
+        let data = section.reader().slice();
+        if data.is_empty() {
+            return;
+        }
+        let section_id = *self.dwarf.get_or_insert_with(|| {
+            self.obj.add_section(
+                self.obj.segment_name(StandardSegment::Debug).to_vec(),
+                obj::ELF_WASMTIME_DWARF.as_bytes().to_vec(),
+                SectionKind::Debug,
+            )
+        });
+        let offset = self.obj.append_section_data(section_id, data, 1);
+        dwarf.push((T::id() as u8, offset..offset + data.len() as u64));
+    }
+
+    /// Creates the `ELF_WASMTIME_INFO` section from the given serializable data
+    /// structure.
+    pub fn serialize_info<T>(&mut self, info: &T)
+    where
+        T: serde::Serialize,
+    {
+        let section = self.obj.add_section(
+            self.obj.segment_name(StandardSegment::Data).to_vec(),
+            obj::ELF_WASMTIME_INFO.as_bytes().to_vec(),
+            SectionKind::ReadOnlyData,
+        );
+        let data = postcard::to_allocvec(info).unwrap();
+        self.obj.set_section_data(section, data, 1);
+    }
+
+    /// Serializes `self` into a buffer. This can be used for execution as well
+    /// as serialization.
+    pub fn finish<T: WritableBuffer>(self, t: &mut T) -> Result<()> {
+        self.obj.emit(t).map_err(|e| e.into())
+    }
+}
+
+/// A type which can be the result of serializing an object.
+pub trait FinishedObject: Sized {
+    /// Emit the object as `Self`.
+    fn finish_object(obj: ObjectBuilder<'_>) -> Result<Self>;
+}
+
+impl FinishedObject for Vec<u8> {
+    fn finish_object(obj: ObjectBuilder<'_>) -> Result<Self> {
+        let mut result = ObjectVec::default();
+        obj.finish(&mut result)?;
+        return Ok(result.0);
+
+        #[derive(Default)]
+        struct ObjectVec(Vec<u8>);
+
+        impl WritableBuffer for ObjectVec {
+            fn len(&self) -> usize {
+                self.0.len()
+            }
+
+            fn reserve(&mut self, additional: usize) -> Result<(), ()> {
+                assert_eq!(self.0.len(), 0, "cannot reserve twice");
+                self.0 = Vec::with_capacity(additional);
+                Ok(())
+            }
+
+            fn resize(&mut self, new_len: usize) {
+                if new_len <= self.0.len() {
+                    self.0.truncate(new_len)
+                } else {
+                    self.0.extend(vec![0; new_len - self.0.len()])
+                }
+            }
+
+            fn write_bytes(&mut self, val: &[u8]) {
+                self.0.extend(val);
+            }
+        }
+    }
+}
diff --git a/crates/environ/src/compile/module_environ.rs b/crates/environ/src/compile/module_environ.rs
new file mode 100644
index 000000000000..ed4705d9b52f
--- /dev/null
+++ b/crates/environ/src/compile/module_environ.rs
@@ -0,0 +1,1264 @@
+use crate::module::{
+    FuncRefIndex, Initializer, MemoryInitialization, MemoryInitializer, MemoryPlan, Module,
+    TablePlan, TableSegment, TableSegmentElements,
+};
+use crate::prelude::*;
+use crate::{
+    DataIndex, DefinedFuncIndex, ElemIndex, EntityIndex, EntityType, FuncIndex, GlobalIndex,
+    InitMemory, MemoryIndex, ModuleTypesBuilder, PrimaryMap, StaticMemoryInitializer, TableIndex,
+    TableInitialValue, Tunables, TypeConvert, TypeIndex, Unsigned, WasmError, WasmHeapType,
+    WasmResult, WasmValType, WasmparserTypeConverter,
+};
+use anyhow::{bail, Result};
+use cranelift_entity::packed_option::ReservedValue;
+use std::borrow::Cow;
+use std::collections::HashMap;
+use std::mem;
+use std::path::PathBuf;
+use std::sync::Arc;
+use wasmparser::{
+    types::Types, CustomSectionReader, DataKind, ElementItems, ElementKind, Encoding, ExternalKind,
+    FuncToValidate, FunctionBody, KnownCustom, NameSectionReader, Naming, Parser, Payload, TypeRef,
+    Validator, ValidatorResources,
+};
+use wasmtime_types::{ConstExpr, ConstOp, ModuleInternedTypeIndex, SizeOverflow, WasmHeapTopType};
+
+/// Object containing the standalone environment information.
+pub struct ModuleEnvironment<'a, 'data> {
+    /// The current module being translated
+    result: ModuleTranslation<'data>,
+
+    /// Intern'd types for this entire translation, shared by all modules.
+    types: &'a mut ModuleTypesBuilder,
+
+    // Various bits and pieces of configuration
+    validator: &'a mut Validator,
+    tunables: &'a Tunables,
+}
+
+/// The result of translating via `ModuleEnvironment`. Function bodies are not
+/// yet translated, and data initializers have not yet been copied out of the
+/// original buffer.
+#[derive(Default)]
+pub struct ModuleTranslation<'data> {
+    /// Module information.
+    pub module: Module,
+
+    /// The input wasm binary.
+    ///
+    /// This can be useful, for example, when modules are parsed from a
+    /// component and the embedder wants access to the raw wasm modules
+    /// themselves.
+    pub wasm: &'data [u8],
+
+    /// References to the function bodies.
+    pub function_body_inputs: PrimaryMap<DefinedFuncIndex, FunctionBodyData<'data>>,
+
+    /// A list of type signatures which are considered exported from this
+    /// module, or those that can possibly be called. This list is sorted, and
+    /// trampolines for each of these signatures are required.
+    pub exported_signatures: Vec<ModuleInternedTypeIndex>,
+
+    /// DWARF debug information, if enabled, parsed from the module.
+    pub debuginfo: DebugInfoData<'data>,
+
+    /// Set if debuginfo was found but it was not parsed due to `Tunables`
+    /// configuration.
+    pub has_unparsed_debuginfo: bool,
+
+    /// List of data segments found in this module which should be concatenated
+    /// together for the final compiled artifact.
+    ///
+    /// These data segments, when concatenated, are indexed by the
+    /// `MemoryInitializer` type.
+    pub data: Vec<Cow<'data, [u8]>>,
+
+    /// The desired alignment of `data` in the final data section of the object
+    /// file that we'll emit.
+    ///
+    /// Note that this is 1 by default but `MemoryInitialization::Static` might
+    /// switch this to a higher alignment to facilitate mmap-ing data from
+    /// an object file into a linear memory.
+    pub data_align: Option<u64>,
+
+    /// Total size of all data pushed onto `data` so far.
+    total_data: u32,
+
+    /// List of passive element segments found in this module which will get
+    /// concatenated for the final artifact.
+    pub passive_data: Vec<&'data [u8]>,
+
+    /// Total size of all passive data pushed into `passive_data` so far.
+    total_passive_data: u32,
+
+    /// When we're parsing the code section this will be incremented so we know
+    /// which function is currently being defined.
+    code_index: u32,
+
+    /// The type information of the current module made available at the end of the
+    /// validation process.
+    types: Option<Types>,
+}
+
+impl<'data> ModuleTranslation<'data> {
+    /// Returns a reference to the type information of the current module.
+    pub fn get_types(&self) -> &Types {
+        self.types
+            .as_ref()
+            .expect("module type information to be available")
+    }
+}
+
+/// Contains function data: byte code and its offset in the module.
+pub struct FunctionBodyData<'a> {
+    /// The body of the function, containing code and locals.
+    pub body: FunctionBody<'a>,
+    /// Validator for the function body
+    pub validator: FuncToValidate<ValidatorResources>,
+}
+
+#[derive(Debug, Default)]
+#[allow(missing_docs)]
+pub struct DebugInfoData<'a> {
+    pub dwarf: Dwarf<'a>,
+    pub name_section: NameSection<'a>,
+    pub wasm_file: WasmFileInfo,
+    pub debug_loc: gimli::DebugLoc<Reader<'a>>,
+    pub debug_loclists: gimli::DebugLocLists<Reader<'a>>,
+    pub debug_ranges: gimli::DebugRanges<Reader<'a>>,
+    pub debug_rnglists: gimli::DebugRngLists<Reader<'a>>,
+    pub debug_cu_index: gimli::DebugCuIndex<Reader<'a>>,
+    pub debug_tu_index: gimli::DebugTuIndex<Reader<'a>>,
+}
+
+#[allow(missing_docs)]
+pub type Dwarf<'input> = gimli::Dwarf<Reader<'input>>;
+
+type Reader<'input> = gimli::EndianSlice<'input, gimli::LittleEndian>;
+
+#[derive(Debug, Default)]
+#[allow(missing_docs)]
+pub struct NameSection<'a> {
+    pub module_name: Option<&'a str>,
+    pub func_names: HashMap<FuncIndex, &'a str>,
+    pub locals_names: HashMap<FuncIndex, HashMap<u32, &'a str>>,
+}
+
+#[derive(Debug, Default)]
+#[allow(missing_docs)]
+pub struct WasmFileInfo {
+    pub path: Option<PathBuf>,
+    pub code_section_offset: u64,
+    pub imported_func_count: u32,
+    pub funcs: Vec<FunctionMetadata>,
+}
+
+#[derive(Debug)]
+#[allow(missing_docs)]
+pub struct FunctionMetadata {
+    pub params: Box<[WasmValType]>,
+    pub locals: Box<[(u32, WasmValType)]>,
+}
+
+impl<'a, 'data> ModuleEnvironment<'a, 'data> {
+    /// Allocates the environment data structures.
+    pub fn new(
+        tunables: &'a Tunables,
+        validator: &'a mut Validator,
+        types: &'a mut ModuleTypesBuilder,
+    ) -> Self {
+        Self {
+            result: ModuleTranslation::default(),
+            types,
+            tunables,
+            validator,
+        }
+    }
+
+    /// Translate a wasm module using this environment.
+    ///
+    /// This function will translate the `data` provided with `parser`,
+    /// validating everything along the way with this environment's validator.
+    ///
+    /// The result of translation, [`ModuleTranslation`], contains everything
+    /// necessary to compile functions afterwards as well as learn type
+    /// information about the module at runtime.
+    pub fn translate(
+        mut self,
+        parser: Parser,
+        data: &'data [u8],
+    ) -> Result<ModuleTranslation<'data>> {
+        self.result.wasm = data;
+
+        for payload in parser.parse_all(data) {
+            self.translate_payload(payload?)?;
+        }
+
+        Ok(self.result)
+    }
+
+    fn translate_payload(&mut self, payload: Payload<'data>) -> Result<()> {
+        match payload {
+            Payload::Version {
+                num,
+                encoding,
+                range,
+            } => {
+                self.validator.version(num, encoding, &range)?;
+                match encoding {
+                    Encoding::Module => {}
+                    Encoding::Component => {
+                        bail!("expected a WebAssembly module but was given a WebAssembly component")
+                    }
+                }
+            }
+
+            Payload::End(offset) => {
+                self.result.types = Some(self.validator.end(offset)?);
+
+                // With the `escaped_funcs` set of functions finished
+                // we can calculate the set of signatures that are exported as
+                // the set of exported functions' signatures.
+                self.result.exported_signatures = self
+                    .result
+                    .module
+                    .functions
+                    .iter()
+                    .filter_map(|(_, func)| {
+                        if func.is_escaping() {
+                            Some(func.signature)
+                        } else {
+                            None
+                        }
+                    })
+                    .collect();
+                self.result.exported_signatures.sort_unstable();
+                self.result.exported_signatures.dedup();
+            }
+
+            Payload::TypeSection(types) => {
+                self.validator.type_section(&types)?;
+
+                let count = types.count();
+                let capacity = usize::try_from(count).unwrap();
+                self.result.module.types.reserve(capacity);
+                self.types.reserve_wasm_signatures(capacity);
+
+                // Iterate over each *rec group* -- not type -- defined in the
+                // types section. Rec groups are the unit of canonicalization
+                // and therefore the unit at which we need to process at a
+                // time. `wasmparser` has already done the hard work of
+                // de-duplicating and canonicalizing the rec groups within the
+                // module for us, we just need to translate them into our data
+                // structures. Note that, if the Wasm defines duplicate rec
+                // groups, we need copy the duplicates over (shallowly) as well,
+                // so that our types index space doesn't have holes.
+                let mut type_index = 0;
+                for _ in 0..count {
+                    let validator_types = self.validator.types(0).unwrap();
+
+                    // Get the rec group for the current type index, which is
+                    // always the first type defined in a rec group.
+                    let core_type_id = validator_types.core_type_at(type_index).unwrap_sub();
+                    log::trace!(
+                        "about to intern rec group for {core_type_id:?} = {:?}",
+                        validator_types[core_type_id]
+                    );
+                    let rec_group_id = validator_types.rec_group_id_of(core_type_id);
+                    debug_assert_eq!(
+                        validator_types
+                            .rec_group_elements(rec_group_id)
+                            .position(|id| id == core_type_id),
+                        Some(0)
+                    );
+
+                    // Intern the rec group and then fill in this module's types
+                    // index space.
+                    let interned = self.types.intern_rec_group(
+                        &self.result.module,
+                        validator_types,
+                        rec_group_id,
+                    )?;
+                    let elems = self.types.rec_group_elements(interned);
+                    let len = elems.len();
+                    self.result.module.types.reserve(len);
+                    for ty in elems {
+                        self.result.module.types.push(ty);
+                    }
+
+                    // Advance `type_index` to the start of the next rec group.
+                    type_index += u32::try_from(len).unwrap();
+                }
+            }
+
+            Payload::ImportSection(imports) => {
+                self.validator.import_section(&imports)?;
+
+                let cnt = usize::try_from(imports.count()).unwrap();
+                self.result.module.initializers.reserve(cnt);
+
+                for entry in imports {
+                    let import = entry?;
+                    let ty = match import.ty {
+                        TypeRef::Func(index) => {
+                            let index = TypeIndex::from_u32(index);
+                            let interned_index = self.result.module.types[index];
+                            self.result.module.num_imported_funcs += 1;
+                            self.result.debuginfo.wasm_file.imported_func_count += 1;
+                            EntityType::Function(wasmtime_types::EngineOrModuleTypeIndex::Module(
+                                interned_index,
+                            ))
+                        }
+                        TypeRef::Memory(ty) => {
+                            self.result.module.num_imported_memories += 1;
+                            EntityType::Memory(ty.into())
+                        }
+                        TypeRef::Global(ty) => {
+                            self.result.module.num_imported_globals += 1;
+                            EntityType::Global(self.convert_global_type(&ty))
+                        }
+                        TypeRef::Table(ty) => {
+                            self.result.module.num_imported_tables += 1;
+                            EntityType::Table(self.convert_table_type(&ty)?)
+                        }
+
+                        // doesn't get past validation
+                        TypeRef::Tag(_) => unreachable!(),
+                    };
+                    self.declare_import(import.module, import.name, ty);
+                }
+            }
+
+            Payload::FunctionSection(functions) => {
+                self.validator.function_section(&functions)?;
+
+                let cnt = usize::try_from(functions.count()).unwrap();
+                self.result.module.functions.reserve_exact(cnt);
+
+                for entry in functions {
+                    let sigindex = entry?;
+                    let ty = TypeIndex::from_u32(sigindex);
+                    let interned_index = self.result.module.types[ty];
+                    self.result.module.push_function(interned_index);
+                }
+            }
+
+            Payload::TableSection(tables) => {
+                self.validator.table_section(&tables)?;
+                let cnt = usize::try_from(tables.count()).unwrap();
+                self.result.module.table_plans.reserve_exact(cnt);
+
+                for entry in tables {
+                    let wasmparser::Table { ty, init } = entry?;
+                    let table = self.convert_table_type(&ty)?;
+                    let plan = TablePlan::for_table(table, &self.tunables);
+                    self.result.module.table_plans.push(plan);
+                    let init = match init {
+                        wasmparser::TableInit::RefNull => TableInitialValue::Null {
+                            precomputed: Vec::new(),
+                        },
+                        wasmparser::TableInit::Expr(expr) => {
+                            let (init, escaped) = ConstExpr::from_wasmparser(expr)?;
+                            for f in escaped {
+                                self.flag_func_escaped(f);
+                            }
+                            TableInitialValue::Expr(init)
+                        }
+                    };
+                    self.result
+                        .module
+                        .table_initialization
+                        .initial_values
+                        .push(init);
+                }
+            }
+
+            Payload::MemorySection(memories) => {
+                self.validator.memory_section(&memories)?;
+
+                let cnt = usize::try_from(memories.count()).unwrap();
+                self.result.module.memory_plans.reserve_exact(cnt);
+
+                for entry in memories {
+                    let memory = entry?;
+                    let plan = MemoryPlan::for_memory(memory.into(), &self.tunables);
+                    self.result.module.memory_plans.push(plan);
+                }
+            }
+
+            Payload::TagSection(tags) => {
+                self.validator.tag_section(&tags)?;
+
+                // This feature isn't enabled at this time, so we should
+                // never get here.
+                unreachable!();
+            }
+
+            Payload::GlobalSection(globals) => {
+                self.validator.global_section(&globals)?;
+
+                let cnt = usize::try_from(globals.count()).unwrap();
+                self.result.module.globals.reserve_exact(cnt);
+
+                for entry in globals {
+                    let wasmparser::Global { ty, init_expr } = entry?;
+                    let (initializer, escaped) = ConstExpr::from_wasmparser(init_expr)?;
+                    for f in escaped {
+                        self.flag_func_escaped(f);
+                    }
+                    let ty = self.convert_global_type(&ty);
+                    self.result.module.globals.push(ty);
+                    self.result.module.global_initializers.push(initializer);
+                }
+            }
+
+            Payload::ExportSection(exports) => {
+                self.validator.export_section(&exports)?;
+
+                let cnt = usize::try_from(exports.count()).unwrap();
+                self.result.module.exports.reserve(cnt);
+
+                for entry in exports {
+                    let wasmparser::Export { name, kind, index } = entry?;
+                    let entity = match kind {
+                        ExternalKind::Func => {
+                            let index = FuncIndex::from_u32(index);
+                            self.flag_func_escaped(index);
+                            EntityIndex::Function(index)
+                        }
+                        ExternalKind::Table => EntityIndex::Table(TableIndex::from_u32(index)),
+                        ExternalKind::Memory => EntityIndex::Memory(MemoryIndex::from_u32(index)),
+                        ExternalKind::Global => EntityIndex::Global(GlobalIndex::from_u32(index)),
+
+                        // this never gets past validation
+                        ExternalKind::Tag => unreachable!(),
+                    };
+                    self.result
+                        .module
+                        .exports
+                        .insert(String::from(name), entity);
+                }
+            }
+
+            Payload::StartSection { func, range } => {
+                self.validator.start_section(func, &range)?;
+
+                let func_index = FuncIndex::from_u32(func);
+                self.flag_func_escaped(func_index);
+                debug_assert!(self.result.module.start_func.is_none());
+                self.result.module.start_func = Some(func_index);
+            }
+
+            Payload::ElementSection(elements) => {
+                self.validator.element_section(&elements)?;
+
+                for (index, entry) in elements.into_iter().enumerate() {
+                    let wasmparser::Element {
+                        kind,
+                        items,
+                        range: _,
+                    } = entry?;
+
+                    // Build up a list of `FuncIndex` corresponding to all the
+                    // entries listed in this segment. Note that it's not
+                    // possible to create anything other than a `ref.null
+                    // extern` for externref segments, so those just get
+                    // translated to the reserved value of `FuncIndex`.
+                    let elements = match items {
+                        ElementItems::Functions(funcs) => {
+                            let mut elems =
+                                Vec::with_capacity(usize::try_from(funcs.count()).unwrap());
+                            for func in funcs {
+                                let func = FuncIndex::from_u32(func?);
+                                self.flag_func_escaped(func);
+                                elems.push(func);
+                            }
+                            TableSegmentElements::Functions(elems.into())
+                        }
+                        ElementItems::Expressions(_ty, items) => {
+                            let mut exprs =
+                                Vec::with_capacity(usize::try_from(items.count()).unwrap());
+                            for expr in items {
+                                let (expr, escaped) = ConstExpr::from_wasmparser(expr?)?;
+                                exprs.push(expr);
+                                for func in escaped {
+                                    self.flag_func_escaped(func);
+                                }
+                            }
+                            TableSegmentElements::Expressions(exprs.into())
+                        }
+                    };
+
+                    match kind {
+                        ElementKind::Active {
+                            table_index,
+                            offset_expr,
+                        } => {
+                            let table_index = TableIndex::from_u32(table_index.unwrap_or(0));
+                            let (offset, escaped) = ConstExpr::from_wasmparser(offset_expr)?;
+                            debug_assert!(escaped.is_empty());
+
+                            self.result
+                                .module
+                                .table_initialization
+                                .segments
+                                .push(TableSegment {
+                                    table_index,
+                                    offset,
+                                    elements: elements.into(),
+                                });
+                        }
+
+                        ElementKind::Passive => {
+                            let elem_index = ElemIndex::from_u32(index as u32);
+                            let index = self.result.module.passive_elements.len();
+                            self.result.module.passive_elements.push(elements.into());
+                            self.result
+                                .module
+                                .passive_elements_map
+                                .insert(elem_index, index);
+                        }
+
+                        ElementKind::Declared => {}
+                    }
+                }
+            }
+
+            Payload::CodeSectionStart { count, range, .. } => {
+                self.validator.code_section_start(count, &range)?;
+                let cnt = usize::try_from(count).unwrap();
+                self.result.function_body_inputs.reserve_exact(cnt);
+                self.result.debuginfo.wasm_file.code_section_offset = range.start as u64;
+            }
+
+            Payload::CodeSectionEntry(body) => {
+                let validator = self.validator.code_section_entry(&body)?;
+                let func_index =
+                    self.result.code_index + self.result.module.num_imported_funcs as u32;
+                let func_index = FuncIndex::from_u32(func_index);
+
+                if self.tunables.generate_native_debuginfo {
+                    let sig_index = self.result.module.functions[func_index].signature;
+                    let sig = self.types[sig_index].unwrap_func();
+                    let mut locals = Vec::new();
+                    for pair in body.get_locals_reader()? {
+                        let (cnt, ty) = pair?;
+                        let ty = self.convert_valtype(ty);
+                        locals.push((cnt, ty));
+                    }
+                    self.result
+                        .debuginfo
+                        .wasm_file
+                        .funcs
+                        .push(FunctionMetadata {
+                            locals: locals.into_boxed_slice(),
+                            params: sig.params().into(),
+                        });
+                }
+                self.result
+                    .function_body_inputs
+                    .push(FunctionBodyData { validator, body });
+                self.result.code_index += 1;
+            }
+
+            Payload::DataSection(data) => {
+                self.validator.data_section(&data)?;
+
+                let initializers = match &mut self.result.module.memory_initialization {
+                    MemoryInitialization::Segmented(i) => i,
+                    _ => unreachable!(),
+                };
+
+                let cnt = usize::try_from(data.count()).unwrap();
+                initializers.reserve_exact(cnt);
+                self.result.data.reserve_exact(cnt);
+
+                for (index, entry) in data.into_iter().enumerate() {
+                    let wasmparser::Data {
+                        kind,
+                        data,
+                        range: _,
+                    } = entry?;
+                    let mk_range = |total: &mut u32| -> Result<_, WasmError> {
+                        let range = u32::try_from(data.len())
+                            .ok()
+                            .and_then(|size| {
+                                let start = *total;
+                                let end = start.checked_add(size)?;
+                                Some(start..end)
+                            })
+                            .ok_or_else(|| {
+                                WasmError::Unsupported(format!(
+                                    "more than 4 gigabytes of data in wasm module",
+                                ))
+                            })?;
+                        *total += range.end - range.start;
+                        Ok(range)
+                    };
+                    match kind {
+                        DataKind::Active {
+                            memory_index,
+                            offset_expr,
+                        } => {
+                            let range = mk_range(&mut self.result.total_data)?;
+                            let memory_index = MemoryIndex::from_u32(memory_index);
+                            let (offset, escaped) = ConstExpr::from_wasmparser(offset_expr)?;
+                            debug_assert!(escaped.is_empty());
+
+                            initializers.push(MemoryInitializer {
+                                memory_index,
+                                offset,
+                                data: range,
+                            });
+                            self.result.data.push(data.into());
+                        }
+                        DataKind::Passive => {
+                            let data_index = DataIndex::from_u32(index as u32);
+                            let range = mk_range(&mut self.result.total_passive_data)?;
+                            self.result.passive_data.push(data);
+                            self.result
+                                .module
+                                .passive_data_map
+                                .insert(data_index, range);
+                        }
+                    }
+                }
+            }
+
+            Payload::DataCountSection { count, range } => {
+                self.validator.data_count_section(count, &range)?;
+
+                // Note: the count passed in here is the *total* segment count
+                // There is no way to reserve for just the passive segments as
+                // they are discovered when iterating the data section entries
+                // Given that the total segment count might be much larger than
+                // the passive count, do not reserve anything here.
+            }
+
+            Payload::CustomSection(s)
+                if s.name() == "webidl-bindings" || s.name() == "wasm-interface-types" =>
+            {
+                bail!(
+                    "\
+Support for interface types has temporarily been removed from `wasmtime`.
+
+For more information about this temporary change you can read on the issue online:
+
+    https://github.com/bytecodealliance/wasmtime/issues/1271
+
+and for re-adding support for interface types you can see this issue:
+
+    https://github.com/bytecodealliance/wasmtime/issues/677
+"
+                )
+            }
+
+            Payload::CustomSection(s) => {
+                self.register_custom_section(&s);
+            }
+
+            // It's expected that validation will probably reject other
+            // payloads such as `UnknownSection` or those related to the
+            // component model. If, however, something gets past validation then
+            // that's a bug in Wasmtime as we forgot to implement something.
+            other => {
+                self.validator.payload(&other)?;
+                panic!("unimplemented section in wasm file {other:?}");
+            }
+        }
+        Ok(())
+    }
+
+    fn register_custom_section(&mut self, section: &CustomSectionReader<'data>) {
+        match section.as_known() {
+            KnownCustom::Name(name) => {
+                let result = self.name_section(name);
+                if let Err(e) = result {
+                    log::warn!("failed to parse name section {:?}", e);
+                }
+            }
+            _ => {
+                let name = section.name().trim_end_matches(".dwo");
+                if name.starts_with(".debug_") {
+                    self.dwarf_section(name, section);
+                }
+            }
+        }
+    }
+
+    fn dwarf_section(&mut self, name: &str, section: &CustomSectionReader<'data>) {
+        if !self.tunables.generate_native_debuginfo && !self.tunables.parse_wasm_debuginfo {
+            self.result.has_unparsed_debuginfo = true;
+            return;
+        }
+        let info = &mut self.result.debuginfo;
+        let dwarf = &mut info.dwarf;
+        let endian = gimli::LittleEndian;
+        let data = section.data();
+        let slice = gimli::EndianSlice::new(data, endian);
+
+        match name {
+            // `gimli::Dwarf` fields.
+            ".debug_abbrev" => dwarf.debug_abbrev = gimli::DebugAbbrev::new(data, endian),
+            ".debug_addr" => dwarf.debug_addr = gimli::DebugAddr::from(slice),
+            ".debug_info" => {
+                dwarf.debug_info = gimli::DebugInfo::new(data, endian);
+            }
+            ".debug_line" => dwarf.debug_line = gimli::DebugLine::new(data, endian),
+            ".debug_line_str" => dwarf.debug_line_str = gimli::DebugLineStr::from(slice),
+            ".debug_str" => dwarf.debug_str = gimli::DebugStr::new(data, endian),
+            ".debug_str_offsets" => dwarf.debug_str_offsets = gimli::DebugStrOffsets::from(slice),
+            ".debug_str_sup" => {
+                let mut dwarf_sup: Dwarf<'data> = Default::default();
+                dwarf_sup.debug_str = gimli::DebugStr::from(slice);
+                dwarf.sup = Some(Arc::new(dwarf_sup));
+            }
+            ".debug_types" => dwarf.debug_types = gimli::DebugTypes::from(slice),
+
+            // Additional fields.
+            ".debug_loc" => info.debug_loc = gimli::DebugLoc::from(slice),
+            ".debug_loclists" => info.debug_loclists = gimli::DebugLocLists::from(slice),
+            ".debug_ranges" => info.debug_ranges = gimli::DebugRanges::new(data, endian),
+            ".debug_rnglists" => info.debug_rnglists = gimli::DebugRngLists::new(data, endian),
+
+            // DWARF package fields
+            ".debug_cu_index" => info.debug_cu_index = gimli::DebugCuIndex::new(data, endian),
+            ".debug_tu_index" => info.debug_tu_index = gimli::DebugTuIndex::new(data, endian),
+
+            // We don't use these at the moment.
+            ".debug_aranges" | ".debug_pubnames" | ".debug_pubtypes" => return,
+            other => {
+                log::warn!("unknown debug section `{}`", other);
+                return;
+            }
+        }
+
+        dwarf.ranges = gimli::RangeLists::new(info.debug_ranges, info.debug_rnglists);
+        dwarf.locations = gimli::LocationLists::new(info.debug_loc, info.debug_loclists);
+    }
+
+    /// Declares a new import with the `module` and `field` names, importing the
+    /// `ty` specified.
+    ///
+    /// Note that this method is somewhat tricky due to the implementation of
+    /// the module linking proposal. In the module linking proposal two-level
+    /// imports are recast as single-level imports of instances. That recasting
+    /// happens here by recording an import of an instance for the first time
+    /// we see a two-level import.
+    ///
+    /// When the module linking proposal is disabled, however, disregard this
+    /// logic and instead work directly with two-level imports since no
+    /// instances are defined.
+    fn declare_import(&mut self, module: &'data str, field: &'data str, ty: EntityType) {
+        let index = self.push_type(ty);
+        self.result.module.initializers.push(Initializer::Import {
+            name: module.to_owned(),
+            field: field.to_owned(),
+            index,
+        });
+    }
+
+    fn push_type(&mut self, ty: EntityType) -> EntityIndex {
+        match ty {
+            EntityType::Function(ty) => EntityIndex::Function({
+                let func_index = self
+                    .result
+                    .module
+                    .push_function(ty.unwrap_module_type_index());
+                // Imported functions can escape; in fact, they've already done
+                // so to get here.
+                self.flag_func_escaped(func_index);
+                func_index
+            }),
+            EntityType::Table(ty) => {
+                let plan = TablePlan::for_table(ty, &self.tunables);
+                EntityIndex::Table(self.result.module.table_plans.push(plan))
+            }
+            EntityType::Memory(ty) => {
+                let plan = MemoryPlan::for_memory(ty, &self.tunables);
+                EntityIndex::Memory(self.result.module.memory_plans.push(plan))
+            }
+            EntityType::Global(ty) => EntityIndex::Global(self.result.module.globals.push(ty)),
+            EntityType::Tag(_) => unimplemented!(),
+        }
+    }
+
+    fn flag_func_escaped(&mut self, func: FuncIndex) {
+        let ty = &mut self.result.module.functions[func];
+        // If this was already assigned a funcref index no need to re-assign it.
+        if ty.is_escaping() {
+            return;
+        }
+        let index = self.result.module.num_escaped_funcs as u32;
+        ty.func_ref = FuncRefIndex::from_u32(index);
+        self.result.module.num_escaped_funcs += 1;
+    }
+
+    /// Parses the Name section of the wasm module.
+    fn name_section(&mut self, names: NameSectionReader<'data>) -> WasmResult<()> {
+        for subsection in names {
+            match subsection? {
+                wasmparser::Name::Function(names) => {
+                    for name in names {
+                        let Naming { index, name } = name?;
+                        // Skip this naming if it's naming a function that
+                        // doesn't actually exist.
+                        if (index as usize) >= self.result.module.functions.len() {
+                            continue;
+                        }
+
+                        // Store the name unconditionally, regardless of
+                        // whether we're parsing debuginfo, since function
+                        // names are almost always present in the
+                        // final compilation artifact.
+                        let index = FuncIndex::from_u32(index);
+                        self.result
+                            .debuginfo
+                            .name_section
+                            .func_names
+                            .insert(index, name);
+                    }
+                }
+                wasmparser::Name::Module { name, .. } => {
+                    self.result.module.name = Some(name.to_string());
+                    if self.tunables.generate_native_debuginfo {
+                        self.result.debuginfo.name_section.module_name = Some(name);
+                    }
+                }
+                wasmparser::Name::Local(reader) => {
+                    if !self.tunables.generate_native_debuginfo {
+                        continue;
+                    }
+                    for f in reader {
+                        let f = f?;
+                        // Skip this naming if it's naming a function that
+                        // doesn't actually exist.
+                        if (f.index as usize) >= self.result.module.functions.len() {
+                            continue;
+                        }
+                        for name in f.names {
+                            let Naming { index, name } = name?;
+
+                            self.result
+                                .debuginfo
+                                .name_section
+                                .locals_names
+                                .entry(FuncIndex::from_u32(f.index))
+                                .or_insert(HashMap::new())
+                                .insert(index, name);
+                        }
+                    }
+                }
+                wasmparser::Name::Label(_)
+                | wasmparser::Name::Type(_)
+                | wasmparser::Name::Table(_)
+                | wasmparser::Name::Global(_)
+                | wasmparser::Name::Memory(_)
+                | wasmparser::Name::Element(_)
+                | wasmparser::Name::Data(_)
+                | wasmparser::Name::Tag(_)
+                | wasmparser::Name::Field(_)
+                | wasmparser::Name::Unknown { .. } => {}
+            }
+        }
+        Ok(())
+    }
+}
+
+impl TypeConvert for ModuleEnvironment<'_, '_> {
+    fn lookup_heap_type(&self, index: wasmparser::UnpackedIndex) -> WasmHeapType {
+        WasmparserTypeConverter::new(&self.types, &self.result.module).lookup_heap_type(index)
+    }
+
+    fn lookup_type_index(
+        &self,
+        index: wasmparser::UnpackedIndex,
+    ) -> wasmtime_types::EngineOrModuleTypeIndex {
+        WasmparserTypeConverter::new(&self.types, &self.result.module).lookup_type_index(index)
+    }
+}
+
+impl ModuleTranslation<'_> {
+    /// Attempts to convert segmented memory initialization into static
+    /// initialization for the module that this translation represents.
+    ///
+    /// If this module's memory initialization is not compatible with paged
+    /// initialization then this won't change anything. Otherwise if it is
+    /// compatible then the `memory_initialization` field will be updated.
+    ///
+    /// Takes a `page_size` argument in order to ensure that all
+    /// initialization is page-aligned for mmap-ability, and
+    /// `max_image_size_always_allowed` to control how we decide
+    /// whether to use static init.
+    ///
+    /// We will try to avoid generating very sparse images, which are
+    /// possible if e.g. a module has an initializer at offset 0 and a
+    /// very high offset (say, 1 GiB). To avoid this, we use a dual
+    /// condition: we always allow images less than
+    /// `max_image_size_always_allowed`, and the embedder of Wasmtime
+    /// can set this if desired to ensure that static init should
+    /// always be done if the size of the module or its heaps is
+    /// otherwise bounded by the system. We also allow images with
+    /// static init data bigger than that, but only if it is "dense",
+    /// defined as having at least half (50%) of its pages with some
+    /// data.
+    ///
+    /// We could do something slightly better by building a dense part
+    /// and keeping a sparse list of outlier/leftover segments (see
+    /// issue #3820). This would also allow mostly-static init of
+    /// modules that have some dynamically-placed data segments. But,
+    /// for now, this is sufficient to allow a system that "knows what
+    /// it's doing" to always get static init.
+    pub fn try_static_init(&mut self, page_size: u64, max_image_size_always_allowed: u64) {
+        // This method only attempts to transform a `Segmented` memory init
+        // into a `Static` one, no other state.
+        if !self.module.memory_initialization.is_segmented() {
+            return;
+        }
+
+        // First a dry run of memory initialization is performed. This
+        // collects information about the extent of memory initialized for each
+        // memory as well as the size of all data segments being copied in.
+        struct Memory {
+            data_size: u64,
+            min_addr: u64,
+            max_addr: u64,
+            // The `usize` here is a pointer into `self.data` which is the list
+            // of data segments corresponding to what was found in the original
+            // wasm module.
+            segments: Vec<(usize, StaticMemoryInitializer)>,
+        }
+        let mut info = PrimaryMap::with_capacity(self.module.memory_plans.len());
+        for _ in 0..self.module.memory_plans.len() {
+            info.push(Memory {
+                data_size: 0,
+                min_addr: u64::MAX,
+                max_addr: 0,
+                segments: Vec::new(),
+            });
+        }
+
+        struct InitMemoryAtCompileTime<'a> {
+            module: &'a Module,
+            info: &'a mut PrimaryMap<MemoryIndex, Memory>,
+            idx: usize,
+        }
+        impl InitMemory for InitMemoryAtCompileTime<'_> {
+            fn memory_size_in_bytes(
+                &mut self,
+                memory_index: MemoryIndex,
+            ) -> Result<u64, SizeOverflow> {
+                self.module.memory_plans[memory_index]
+                    .memory
+                    .minimum_byte_size()
+            }
+
+            fn eval_offset(&mut self, memory_index: MemoryIndex, expr: &ConstExpr) -> Option<u64> {
+                let mem64 = self.module.memory_plans[memory_index].memory.memory64;
+                match expr.ops() {
+                    &[ConstOp::I32Const(offset)] if !mem64 => Some(offset.unsigned().into()),
+                    &[ConstOp::I64Const(offset)] if mem64 => Some(offset.unsigned()),
+                    _ => None,
+                }
+            }
+
+            fn write(&mut self, memory: MemoryIndex, init: &StaticMemoryInitializer) -> bool {
+                // Currently `Static` only applies to locally-defined memories,
+                // so if a data segment references an imported memory then
+                // transitioning to a `Static` memory initializer is not
+                // possible.
+                if self.module.defined_memory_index(memory).is_none() {
+                    return false;
+                };
+                let info = &mut self.info[memory];
+                let data_len = u64::from(init.data.end - init.data.start);
+                if data_len > 0 {
+                    info.data_size += data_len;
+                    info.min_addr = info.min_addr.min(init.offset);
+                    info.max_addr = info.max_addr.max(init.offset + data_len);
+                    info.segments.push((self.idx, init.clone()));
+                }
+                self.idx += 1;
+                true
+            }
+        }
+        let ok = self
+            .module
+            .memory_initialization
+            .init_memory(&mut InitMemoryAtCompileTime {
+                idx: 0,
+                module: &self.module,
+                info: &mut info,
+            });
+        if !ok {
+            return;
+        }
+
+        // Validate that the memory information collected is indeed valid for
+        // static memory initialization.
+        for (i, info) in info.iter().filter(|(_, info)| info.data_size > 0) {
+            let image_size = info.max_addr - info.min_addr;
+
+            // Simplify things for now by bailing out entirely if any memory has
+            // a page size smaller than the host's page size. This fixes a case
+            // where currently initializers are created in host-page-size units
+            // of length which means that a larger-than-the-entire-memory
+            // initializer can be created. This can be handled technically but
+            // would require some more changes to help fix the assert elsewhere
+            // that this protects against.
+            if self.module.memory_plans[i].memory.page_size() < page_size {
+                return;
+            }
+
+            // If the range of memory being initialized is less than twice the
+            // total size of the data itself then it's assumed that static
+            // initialization is ok. This means we'll at most double memory
+            // consumption during the memory image creation process, which is
+            // currently assumed to "probably be ok" but this will likely need
+            // tweaks over time.
+            if image_size < info.data_size.saturating_mul(2) {
+                continue;
+            }
+
+            // If the memory initialization image is larger than the size of all
+            // data, then we still allow memory initialization if the image will
+            // be of a relatively modest size, such as 1MB here.
+            if image_size < max_image_size_always_allowed {
+                continue;
+            }
+
+            // At this point memory initialization is concluded to be too
+            // expensive to do at compile time so it's entirely deferred to
+            // happen at runtime.
+            return;
+        }
+
+        // Here's where we've now committed to changing to static memory. The
+        // memory initialization image is built here from the page data and then
+        // it's converted to a single initializer.
+        let data = mem::replace(&mut self.data, Vec::new());
+        let mut map = PrimaryMap::with_capacity(info.len());
+        let mut module_data_size = 0u32;
+        for (memory, info) in info.iter() {
+            // Create the in-memory `image` which is the initialized contents of
+            // this linear memory.
+            let extent = if info.segments.len() > 0 {
+                (info.max_addr - info.min_addr) as usize
+            } else {
+                0
+            };
+            let mut image = Vec::with_capacity(extent);
+            for (idx, init) in info.segments.iter() {
+                let data = &data[*idx];
+                assert_eq!(data.len(), init.data.len());
+                let offset = usize::try_from(init.offset - info.min_addr).unwrap();
+                if image.len() < offset {
+                    image.resize(offset, 0u8);
+                    image.extend_from_slice(data);
+                } else {
+                    image.splice(
+                        offset..(offset + data.len()).min(image.len()),
+                        data.iter().copied(),
+                    );
+                }
+            }
+            assert_eq!(image.len(), extent);
+            assert_eq!(image.capacity(), extent);
+            let mut offset = if info.segments.len() > 0 {
+                info.min_addr
+            } else {
+                0
+            };
+
+            // Chop off trailing zeros from the image as memory is already
+            // zero-initialized. Note that `i` is the position of a nonzero
+            // entry here, so to not lose it we truncate to `i + 1`.
+            if let Some(i) = image.iter().rposition(|i| *i != 0) {
+                image.truncate(i + 1);
+            }
+
+            // Also chop off leading zeros, if any.
+            if let Some(i) = image.iter().position(|i| *i != 0) {
+                offset += i as u64;
+                image.drain(..i);
+            }
+            let mut len = u64::try_from(image.len()).unwrap();
+
+            // The goal is to enable mapping this image directly into memory, so
+            // the offset into linear memory must be a multiple of the page
+            // size. If that's not already the case then the image is padded at
+            // the front and back with extra zeros as necessary
+            if offset % page_size != 0 {
+                let zero_padding = offset % page_size;
+                self.data.push(vec![0; zero_padding as usize].into());
+                offset -= zero_padding;
+                len += zero_padding;
+            }
+            self.data.push(image.into());
+            if len % page_size != 0 {
+                let zero_padding = page_size - (len % page_size);
+                self.data.push(vec![0; zero_padding as usize].into());
+                len += zero_padding;
+            }
+
+            // Offset/length should now always be page-aligned.
+            assert!(offset % page_size == 0);
+            assert!(len % page_size == 0);
+
+            // Create the `StaticMemoryInitializer` which describes this image,
+            // only needed if the image is actually present and has a nonzero
+            // length. The `offset` has been calculates above, originally
+            // sourced from `info.min_addr`. The `data` field is the extent
+            // within the final data segment we'll emit to an ELF image, which
+            // is the concatenation of `self.data`, so here it's the size of
+            // the section-so-far plus the current segment we're appending.
+            let len = u32::try_from(len).unwrap();
+            let init = if len > 0 {
+                Some(StaticMemoryInitializer {
+                    offset,
+                    data: module_data_size..module_data_size + len,
+                })
+            } else {
+                None
+            };
+            let idx = map.push(init);
+            assert_eq!(idx, memory);
+            module_data_size += len;
+        }
+        self.data_align = Some(page_size);
+        self.module.memory_initialization = MemoryInitialization::Static { map };
+    }
+
+    /// Attempts to convert the module's table initializers to
+    /// FuncTable form where possible. This enables lazy table
+    /// initialization later by providing a one-to-one map of initial
+    /// table values, without having to parse all segments.
+    pub fn try_func_table_init(&mut self) {
+        // This should be large enough to support very large Wasm
+        // modules with huge funcref tables, but small enough to avoid
+        // OOMs or DoS on truly sparse tables.
+        const MAX_FUNC_TABLE_SIZE: u32 = 1024 * 1024;
+
+        // First convert any element-initialized tables to images of just that
+        // single function if the minimum size of the table allows doing so.
+        for ((_, init), (_, plan)) in self
+            .module
+            .table_initialization
+            .initial_values
+            .iter_mut()
+            .zip(
+                self.module
+                    .table_plans
+                    .iter()
+                    .skip(self.module.num_imported_tables),
+            )
+        {
+            let table_size = plan.table.minimum;
+            if table_size > MAX_FUNC_TABLE_SIZE {
+                continue;
+            }
+            if let TableInitialValue::Expr(expr) = init {
+                if let [ConstOp::RefFunc(f)] = expr.ops() {
+                    *init = TableInitialValue::Null {
+                        precomputed: vec![*f; table_size as usize],
+                    };
+                }
+            }
+        }
+
+        let mut segments = mem::take(&mut self.module.table_initialization.segments)
+            .into_iter()
+            .peekable();
+
+        // The goal of this loop is to interpret a table segment and apply it
+        // "statically" to a local table. This will iterate over segments and
+        // apply them one-by-one to each table.
+        //
+        // If any segment can't be applied, however, then this loop exits and
+        // all remaining segments are placed back into the segment list. This is
+        // because segments are supposed to be initialized one-at-a-time which
+        // means that intermediate state is visible with respect to traps. If
+        // anything isn't statically known to not trap it's pessimistically
+        // assumed to trap meaning all further segment initializers must be
+        // applied manually at instantiation time.
+        while let Some(segment) = segments.peek() {
+            let defined_index = match self.module.defined_table_index(segment.table_index) {
+                Some(index) => index,
+                // Skip imported tables: we can't provide a preconstructed
+                // table for them, because their values depend on the
+                // imported table overlaid with whatever segments we have.
+                None => break,
+            };
+
+            // If the base of this segment is dynamic, then we can't
+            // include it in the statically-built array of initial
+            // contents.
+            let offset = match segment.offset.ops() {
+                &[ConstOp::I32Const(offset)] => offset.unsigned(),
+                _ => break,
+            };
+
+            // Get the end of this segment. If out-of-bounds, or too
+            // large for our dense table representation, then skip the
+            // segment.
+            let top = match offset.checked_add(segment.elements.len()) {
+                Some(top) => top,
+                None => break,
+            };
+            let table_size = self.module.table_plans[segment.table_index].table.minimum;
+            if top > table_size || top > MAX_FUNC_TABLE_SIZE {
+                break;
+            }
+
+            match self.module.table_plans[segment.table_index]
+                .table
+                .wasm_ty
+                .heap_type
+                .top()
+            {
+                WasmHeapTopType::Func => {}
+                // If this is not a funcref table, then we can't support a
+                // pre-computed table of function indices. Technically this
+                // initializer won't trap so we could continue processing
+                // segments, but that's left as a future optimization if
+                // necessary.
+                WasmHeapTopType::Any | WasmHeapTopType::Extern => break,
+            }
+
+            // Function indices can be optimized here, but fully general
+            // expressions are deferred to get evaluated at runtime.
+            let function_elements = match &segment.elements {
+                TableSegmentElements::Functions(indices) => indices,
+                TableSegmentElements::Expressions(_) => break,
+            };
+
+            let precomputed =
+                match &mut self.module.table_initialization.initial_values[defined_index] {
+                    TableInitialValue::Null { precomputed } => precomputed,
+
+                    // If this table is still listed as an initial value here
+                    // then that means the initial size of the table doesn't
+                    // support a precomputed function list, so skip this.
+                    // Technically this won't trap so it's possible to process
+                    // further initializers, but that's left as a future
+                    // optimization.
+                    TableInitialValue::Expr(_) => break,
+                };
+
+            // At this point we're committing to pre-initializing the table
+            // with the `segment` that's being iterated over. This segment is
+            // applied to the `precomputed` list for the table by ensuring
+            // it's large enough to hold the segment and then copying the
+            // segment into the precomputed list.
+            if precomputed.len() < top as usize {
+                precomputed.resize(top as usize, FuncIndex::reserved_value());
+            }
+            let dst = &mut precomputed[offset as usize..top as usize];
+            dst.copy_from_slice(&function_elements);
+
+            // advance the iterator to see the next segment
+            let _ = segments.next();
+        }
+        self.module.table_initialization.segments = segments.collect();
+    }
+}
diff --git a/crates/environ/src/compile/module_types.rs b/crates/environ/src/compile/module_types.rs
new file mode 100644
index 000000000000..74632539fe14
--- /dev/null
+++ b/crates/environ/src/compile/module_types.rs
@@ -0,0 +1,471 @@
+use crate::{EntityRef, Module, ModuleTypes, TypeConvert};
+use std::{borrow::Cow, collections::HashMap, ops::Index};
+use wasmparser::{UnpackedIndex, Validator, ValidatorId};
+use wasmtime_types::{
+    EngineOrModuleTypeIndex, ModuleInternedRecGroupIndex, ModuleInternedTypeIndex, TypeIndex,
+    WasmCompositeType, WasmFuncType, WasmHeapType, WasmResult, WasmSubType,
+};
+
+/// A type marking the start of a recursion group's definition.
+///
+/// This is initialized by `ModuleTypesBuilder::start_rec_group` and then
+/// finished in `ModuleTypes::end_rec_group` after all of the types in the rec
+/// group have been defined.
+struct RecGroupStart {
+    rec_group_index: ModuleInternedRecGroupIndex,
+    start: ModuleInternedTypeIndex,
+    end: ModuleInternedTypeIndex,
+}
+
+/// A builder for [`ModuleTypes`].
+pub struct ModuleTypesBuilder {
+    /// The ID of the validator that this builder is configured for. Using a
+    /// different validator, or multiple validators, with this builder would
+    /// result in silliness because our `wasmparser::types::*Id`s are only
+    /// unique within the context of a particular validator. Getting this wrong
+    /// could result in generating calls to functions of the wrong type, for
+    /// example. So therefore we always assert that a builder instances is only
+    /// ever paired with a particular validator context.
+    validator_id: ValidatorId,
+
+    /// The canonicalized and deduplicated set of types we are building.
+    types: ModuleTypes,
+
+    /// The set of trampoline-compatible function types we have already added to
+    /// `self.types`. We do this additional level of deduping, on top of what
+    /// `wasmparser` already does, so we can quickly and easily get the
+    /// trampoline type for a given function type if we've already interned one.
+    trampoline_types: HashMap<WasmFuncType, ModuleInternedTypeIndex>,
+
+    /// A map from already-interned `wasmparser` types to their corresponding
+    /// Wasmtime type.
+    wasmparser_to_wasmtime: HashMap<wasmparser::types::CoreTypeId, ModuleInternedTypeIndex>,
+
+    /// The set of recursion groups we have already seen and interned.
+    already_seen: HashMap<wasmparser::types::RecGroupId, ModuleInternedRecGroupIndex>,
+
+    /// If we are in the middle of defining a recursion group, this is the
+    /// metadata about the recursion group we started defining.
+    defining_rec_group: Option<RecGroupStart>,
+}
+
+impl ModuleTypesBuilder {
+    /// Construct a new `ModuleTypesBuilder` using the given validator.
+    pub fn new(validator: &Validator) -> Self {
+        Self {
+            validator_id: validator.id(),
+            types: ModuleTypes::default(),
+            trampoline_types: HashMap::default(),
+            wasmparser_to_wasmtime: HashMap::default(),
+            already_seen: HashMap::default(),
+            defining_rec_group: None,
+        }
+    }
+
+    /// Reserves space for `amt` more type signatures.
+    pub fn reserve_wasm_signatures(&mut self, amt: usize) {
+        self.types.reserve(amt);
+        self.wasmparser_to_wasmtime.reserve(amt);
+        self.already_seen.reserve(amt);
+    }
+
+    /// Get the id of the validator that this builder is configured for.
+    pub fn validator_id(&self) -> ValidatorId {
+        self.validator_id
+    }
+
+    /// Intern a recursion group and all of its types into this builder.
+    ///
+    /// If the recursion group has already been interned, then it is reused.
+    ///
+    /// Panics if given types from a different validator than the one that this
+    /// builder is associated with.
+    pub fn intern_rec_group(
+        &mut self,
+        module: &Module,
+        validator_types: wasmparser::types::TypesRef<'_>,
+        rec_group_id: wasmparser::types::RecGroupId,
+    ) -> WasmResult<ModuleInternedRecGroupIndex> {
+        assert_eq!(validator_types.id(), self.validator_id);
+
+        if let Some(interned) = self.already_seen.get(&rec_group_id) {
+            return Ok(*interned);
+        }
+
+        self.define_new_rec_group(module, validator_types, rec_group_id)
+    }
+
+    /// Define a new recursion group that we haven't already interned.
+    fn define_new_rec_group(
+        &mut self,
+        module: &Module,
+        validator_types: wasmparser::types::TypesRef<'_>,
+        rec_group_id: wasmparser::types::RecGroupId,
+    ) -> WasmResult<ModuleInternedRecGroupIndex> {
+        assert_eq!(validator_types.id(), self.validator_id);
+
+        self.start_rec_group(
+            validator_types,
+            validator_types.rec_group_elements(rec_group_id),
+        );
+
+        for id in validator_types.rec_group_elements(rec_group_id) {
+            let ty = &validator_types[id];
+            let wasm_ty = WasmparserTypeConverter::new(self, module)
+                .with_rec_group(validator_types, rec_group_id)
+                .convert_sub_type(ty);
+            self.wasm_sub_type_in_rec_group(id, wasm_ty);
+        }
+
+        let rec_group_index = self.end_rec_group(rec_group_id);
+
+        // Iterate over all the types we just defined and make sure that every
+        // function type has an associated trampoline type. This needs to happen
+        // *after* we finish defining the rec group because we may need to
+        // intern new function types, which would conflict with the contiguous
+        // range of type indices we pre-reserved for the rec group elements.
+        for ty in self.rec_group_elements(rec_group_index) {
+            if self.types[ty].is_func() {
+                let trampoline = self.intern_trampoline_type(ty);
+                self.types.set_trampoline_type(ty, trampoline);
+            }
+        }
+
+        Ok(rec_group_index)
+    }
+
+    /// Get or create the trampoline function type for the given function
+    /// type. Returns the interned type index of the trampoline function type.
+    fn intern_trampoline_type(
+        &mut self,
+        for_func_ty: ModuleInternedTypeIndex,
+    ) -> ModuleInternedTypeIndex {
+        let trampoline = self.types[for_func_ty].unwrap_func().trampoline_type();
+
+        if let Some(idx) = self.trampoline_types.get(&trampoline) {
+            // We've already interned this trampoline type; reuse it.
+            *idx
+        } else {
+            // We have not already interned this trampoline type.
+            match trampoline {
+                // The trampoline type is the same as the original function
+                // type. We can reuse the definition and its index, but still
+                // need to intern the type into our `trampoline_types` map so we
+                // can reuse it in the future.
+                Cow::Borrowed(f) => {
+                    self.trampoline_types.insert(f.clone(), for_func_ty);
+                    for_func_ty
+                }
+                // The trampoline type is different from the original function
+                // type. Define the trampoline type and then intern it in
+                // `trampoline_types` so we can reuse it in the future.
+                Cow::Owned(f) => {
+                    let idx = self.types.push(WasmSubType {
+                        is_final: true,
+                        supertype: None,
+                        composite_type: WasmCompositeType::Func(f.clone()),
+                    });
+
+                    // The trampoline type is its own trampoline type.
+                    self.types.set_trampoline_type(idx, idx);
+
+                    let next = self.types.next_ty();
+                    self.types.push_rec_group(idx..next);
+                    self.trampoline_types.insert(f, idx);
+                    idx
+                }
+            }
+        }
+    }
+
+    /// Start defining a recursion group.
+    fn start_rec_group(
+        &mut self,
+        validator_types: wasmparser::types::TypesRef<'_>,
+        elems: impl ExactSizeIterator<Item = wasmparser::types::CoreTypeId>,
+    ) {
+        log::trace!("Starting rec group of length {}", elems.len());
+
+        assert!(self.defining_rec_group.is_none());
+        assert_eq!(validator_types.id(), self.validator_id);
+
+        // Eagerly define the reverse map's entries for this rec group's types
+        // so that we can use them when converting `wasmparser` types to our
+        // types.
+        let len = elems.len();
+        for (i, wasmparser_id) in elems.enumerate() {
+            let interned = ModuleInternedTypeIndex::new(self.types.len_types() + i);
+            log::trace!(
+                "Reserving {interned:?} for {wasmparser_id:?} = {:?}",
+                validator_types[wasmparser_id]
+            );
+
+            let old_entry = self.wasmparser_to_wasmtime.insert(wasmparser_id, interned);
+            debug_assert_eq!(
+                old_entry, None,
+                "should not have already inserted {wasmparser_id:?}"
+            );
+        }
+
+        self.defining_rec_group = Some(RecGroupStart {
+            rec_group_index: self.types.next_rec_group(),
+            start: self.types.next_ty(),
+            end: ModuleInternedTypeIndex::new(self.types.len_types() + len),
+        });
+    }
+
+    /// Finish defining a recursion group.
+    fn end_rec_group(
+        &mut self,
+        rec_group_id: wasmparser::types::RecGroupId,
+    ) -> ModuleInternedRecGroupIndex {
+        let RecGroupStart {
+            rec_group_index,
+            start,
+            end,
+        } = self
+            .defining_rec_group
+            .take()
+            .expect("should be defining a rec group");
+
+        log::trace!("Ending rec group {start:?}..{end:?}");
+
+        debug_assert!(start.index() < self.types.len_types());
+        debug_assert_eq!(
+            end,
+            self.types.next_ty(),
+            "should have defined the number of types declared in `start_rec_group`"
+        );
+
+        let idx = self.types.push_rec_group(start..end);
+        debug_assert_eq!(idx, rec_group_index);
+
+        self.already_seen.insert(rec_group_id, rec_group_index);
+        rec_group_index
+    }
+
+    /// Intern a type into this builder and get its Wasmtime index.
+    ///
+    /// This will intern not only the single given type, but the type's entire
+    /// rec group. This helper method is provided as a convenience so that
+    /// callers don't have to get the type's rec group, intern the rec group,
+    /// and then look up the Wasmtime index for the original type themselves.
+    pub fn intern_type(
+        &mut self,
+        module: &Module,
+        validator_types: wasmparser::types::TypesRef<'_>,
+        id: wasmparser::types::CoreTypeId,
+    ) -> WasmResult<ModuleInternedTypeIndex> {
+        assert!(self.defining_rec_group.is_none());
+        assert_eq!(validator_types.id(), self.validator_id);
+
+        let rec_group_id = validator_types.rec_group_id_of(id);
+        debug_assert!(validator_types
+            .rec_group_elements(rec_group_id)
+            .any(|e| e == id));
+
+        let interned_rec_group = self.intern_rec_group(module, validator_types, rec_group_id)?;
+
+        let interned_type = self.wasmparser_to_wasmtime[&id];
+        debug_assert!(self
+            .rec_group_elements(interned_rec_group)
+            .any(|e| e == interned_type));
+
+        Ok(interned_type)
+    }
+
+    /// Define a new Wasm type while we are defining a rec group.
+    fn wasm_sub_type_in_rec_group(
+        &mut self,
+        id: wasmparser::types::CoreTypeId,
+        ty: WasmSubType,
+    ) -> ModuleInternedTypeIndex {
+        assert!(
+            self.defining_rec_group.is_some(),
+            "must be defining a rec group to define new types"
+        );
+
+        let module_interned_index = self.types.push(ty);
+        debug_assert_eq!(
+            self.wasmparser_to_wasmtime.get(&id),
+            Some(&module_interned_index),
+            "should have reserved the right module-interned index for this wasmparser type already"
+        );
+
+        module_interned_index
+    }
+
+    /// Returns the result [`ModuleTypes`] of this builder.
+    pub fn finish(self) -> ModuleTypes {
+        self.types
+    }
+
+    /// Get the elements within an already-defined rec group.
+    pub fn rec_group_elements(
+        &self,
+        rec_group: ModuleInternedRecGroupIndex,
+    ) -> impl ExactSizeIterator<Item = ModuleInternedTypeIndex> {
+        self.types.rec_group_elements(rec_group)
+    }
+
+    /// Returns an iterator over all the unique wasm types defined thus far
+    /// within this builder.
+    pub fn wasm_types(&self) -> impl Iterator<Item = (ModuleInternedTypeIndex, &WasmSubType)> {
+        self.types.wasm_types()
+    }
+
+    /// Get an iterator over all function types and their associated trampoline
+    /// type.
+    pub fn trampoline_types(
+        &self,
+    ) -> impl Iterator<Item = (ModuleInternedTypeIndex, ModuleInternedTypeIndex)> + '_ {
+        self.types.trampoline_types()
+    }
+
+    /// Get the associated trampoline type for the given function type.
+    pub fn trampoline_type(&self, ty: ModuleInternedTypeIndex) -> ModuleInternedTypeIndex {
+        self.types.trampoline_type(ty)
+    }
+}
+
+// Forward the indexing impl to the internal `ModuleTypes`
+impl<T> Index<T> for ModuleTypesBuilder
+where
+    ModuleTypes: Index<T>,
+{
+    type Output = <ModuleTypes as Index<T>>::Output;
+
+    fn index(&self, sig: T) -> &Self::Output {
+        &self.types[sig]
+    }
+}
+
+/// A convert from `wasmparser` types to Wasmtime types.
+pub struct WasmparserTypeConverter<'a> {
+    types: &'a ModuleTypesBuilder,
+    module: &'a Module,
+    rec_group_context: Option<(
+        wasmparser::types::TypesRef<'a>,
+        wasmparser::types::RecGroupId,
+    )>,
+}
+
+impl<'a> WasmparserTypeConverter<'a> {
+    /// Construct a new type converter from `wasmparser` types to Wasmtime types.
+    pub fn new(types: &'a ModuleTypesBuilder, module: &'a Module) -> Self {
+        Self {
+            types,
+            module,
+            rec_group_context: None,
+        }
+    }
+
+    /// Configure this converter to be within the context of defining the
+    /// current rec group.
+    pub fn with_rec_group(
+        &mut self,
+        wasmparser_types: wasmparser::types::TypesRef<'a>,
+        rec_group: wasmparser::types::RecGroupId,
+    ) -> &Self {
+        self.rec_group_context = Some((wasmparser_types, rec_group));
+        self
+    }
+}
+
+impl TypeConvert for WasmparserTypeConverter<'_> {
+    fn lookup_heap_type(&self, index: UnpackedIndex) -> WasmHeapType {
+        match index {
+            UnpackedIndex::Id(id) => {
+                let interned = self.types.wasmparser_to_wasmtime[&id];
+                let index = EngineOrModuleTypeIndex::Module(interned);
+
+                // If this is a forward reference to a type in this type's rec
+                // group that we haven't converted yet, then we won't have an
+                // entry in `wasm_types` yet. In this case, fallback to a
+                // different means of determining whether this is a concrete
+                // array vs struct vs func reference. In this case, we can use
+                // the validator's type context.
+                if let Some(ty) = self.types.types.get(interned) {
+                    match &ty.composite_type {
+                        WasmCompositeType::Array(_) => WasmHeapType::ConcreteArray(index),
+                        WasmCompositeType::Func(_) => WasmHeapType::ConcreteFunc(index),
+                        WasmCompositeType::Struct(_) => WasmHeapType::ConcreteStruct(index),
+                    }
+                } else if let Some((wasmparser_types, _)) = self.rec_group_context.as_ref() {
+                    let wasmparser_ty = &wasmparser_types[id].composite_type;
+                    assert!(!wasmparser_ty.shared);
+                    match &wasmparser_ty.inner {
+                        wasmparser::CompositeInnerType::Array(_) => {
+                            WasmHeapType::ConcreteArray(index)
+                        }
+                        wasmparser::CompositeInnerType::Func(_) => {
+                            WasmHeapType::ConcreteFunc(index)
+                        }
+                        wasmparser::CompositeInnerType::Struct(_) => {
+                            WasmHeapType::ConcreteStruct(index)
+                        }
+                    }
+                } else {
+                    panic!("forward reference to type outside of rec group?")
+                }
+            }
+
+            UnpackedIndex::Module(module_index) => {
+                let module_index = TypeIndex::from_u32(module_index);
+                let interned = self.module.types[module_index];
+                let index = EngineOrModuleTypeIndex::Module(interned);
+
+                // See comment above about `wasm_types` maybe not having the
+                // converted sub type yet. However in this case we don't have a
+                // `wasmparser::types::CoreTypeId` on hand, so we have to
+                // indirectly get one by looking it up inside the current rec
+                // group.
+                if let Some(ty) = self.types.types.get(interned) {
+                    match &ty.composite_type {
+                        WasmCompositeType::Array(_) => WasmHeapType::ConcreteArray(index),
+                        WasmCompositeType::Func(_) => WasmHeapType::ConcreteFunc(index),
+                        WasmCompositeType::Struct(_) => WasmHeapType::ConcreteStruct(index),
+                    }
+                } else if let Some((parser_types, rec_group)) = self.rec_group_context.as_ref() {
+                    let rec_group_index = interned.index() - self.types.types.len_types();
+                    let id = parser_types
+                        .rec_group_elements(*rec_group)
+                        .nth(rec_group_index)
+                        .unwrap();
+                    let wasmparser_ty = &parser_types[id].composite_type;
+                    assert!(!wasmparser_ty.shared);
+                    match &wasmparser_ty.inner {
+                        wasmparser::CompositeInnerType::Array(_) => {
+                            WasmHeapType::ConcreteArray(index)
+                        }
+                        wasmparser::CompositeInnerType::Func(_) => {
+                            WasmHeapType::ConcreteFunc(index)
+                        }
+                        wasmparser::CompositeInnerType::Struct(_) => {
+                            WasmHeapType::ConcreteStruct(index)
+                        }
+                    }
+                } else {
+                    panic!("forward reference to type outside of rec group?")
+                }
+            }
+
+            UnpackedIndex::RecGroup(_) => unreachable!(),
+        }
+    }
+
+    fn lookup_type_index(&self, index: wasmparser::UnpackedIndex) -> EngineOrModuleTypeIndex {
+        match index {
+            UnpackedIndex::Id(id) => {
+                let interned = self.types.wasmparser_to_wasmtime[&id];
+                EngineOrModuleTypeIndex::Module(interned)
+            }
+            UnpackedIndex::Module(module_index) => {
+                let module_index = TypeIndex::from_u32(module_index);
+                let interned = self.module.types[module_index];
+                EngineOrModuleTypeIndex::Module(interned)
+            }
+            UnpackedIndex::RecGroup(_) => unreachable!(),
+        }
+    }
+}
diff --git a/crates/environ/src/compile/trap_encoding.rs b/crates/environ/src/compile/trap_encoding.rs
new file mode 100644
index 000000000000..73fa6994ccd4
--- /dev/null
+++ b/crates/environ/src/compile/trap_encoding.rs
@@ -0,0 +1,70 @@
+use crate::obj::ELF_WASMTIME_TRAPS;
+use crate::prelude::*;
+use crate::TrapInformation;
+use object::write::{Object, StandardSegment};
+use object::{LittleEndian, SectionKind, U32Bytes};
+use std::ops::Range;
+
+/// A helper structure to build the custom-encoded section of a wasmtime
+/// compilation image which encodes trap information.
+///
+/// This structure is incrementally fed the results of compiling individual
+/// functions and handles all the encoding internally, allowing usage of
+/// `lookup_trap_code` below with the resulting section.
+#[derive(Default)]
+pub struct TrapEncodingBuilder {
+    offsets: Vec<U32Bytes<LittleEndian>>,
+    traps: Vec<u8>,
+    last_offset: u32,
+}
+
+impl TrapEncodingBuilder {
+    /// Appends trap information about a function into this section.
+    ///
+    /// This function is called to describe traps for the `func` range
+    /// specified. The `func` offsets are specified relative to the text section
+    /// itself, and the `traps` offsets are specified relative to the start of
+    /// `func`.
+    ///
+    /// This is required to be called in-order for increasing ranges of `func`
+    /// to ensure the final array is properly sorted. Additionally `traps` must
+    /// be sorted.
+    pub fn push(&mut self, func: Range<u64>, traps: &[TrapInformation]) {
+        // NB: for now this only supports <=4GB text sections in object files.
+        // Alternative schemes will need to be created for >32-bit offsets to
+        // avoid making this section overly large.
+        let func_start = u32::try_from(func.start).unwrap();
+        let func_end = u32::try_from(func.end).unwrap();
+
+        // Sanity-check to ensure that functions are pushed in-order, otherwise
+        // the `offsets` array won't be sorted which is our goal.
+        assert!(func_start >= self.last_offset);
+
+        self.offsets.reserve(traps.len());
+        self.traps.reserve(traps.len());
+        for info in traps {
+            let pos = func_start + info.code_offset;
+            assert!(pos >= self.last_offset);
+            self.offsets.push(U32Bytes::new(LittleEndian, pos));
+            self.traps.push(info.trap_code as u8);
+            self.last_offset = pos;
+        }
+
+        self.last_offset = func_end;
+    }
+
+    /// Encodes this section into the object provided.
+    pub fn append_to(self, obj: &mut Object) {
+        let section = obj.add_section(
+            obj.segment_name(StandardSegment::Data).to_vec(),
+            ELF_WASMTIME_TRAPS.as_bytes().to_vec(),
+            SectionKind::ReadOnlyData,
+        );
+
+        // NB: this matches the encoding expected by `lookup` below.
+        let amt = u32::try_from(self.traps.len()).unwrap();
+        obj.append_section_data(section, &amt.to_le_bytes(), 1);
+        obj.append_section_data(section, object::bytes_of_slice(&self.offsets), 1);
+        obj.append_section_data(section, &self.traps, 1);
+    }
+}
diff --git a/crates/environ/src/component.rs b/crates/environ/src/component.rs
index b5537adc0016..10741a59c5e9 100644
--- a/crates/environ/src/component.rs
+++ b/crates/environ/src/component.rs
@@ -37,18 +37,32 @@ pub const MAX_FLAT_PARAMS: usize = 16;
 /// are transferred through memory.
 pub const MAX_FLAT_RESULTS: usize = 1;
 
-mod compiler;
-pub mod dfg;
+mod artifacts;
 mod info;
-mod translate;
+mod names;
 mod types;
 mod vmcomponent_offsets;
-pub use self::compiler::*;
+pub use self::artifacts::*;
 pub use self::info::*;
-pub use self::translate::*;
+pub use self::names::*;
 pub use self::types::*;
 pub use self::vmcomponent_offsets::*;
 
+#[cfg(feature = "compile")]
+mod compiler;
+#[cfg(feature = "compile")]
+pub mod dfg;
+#[cfg(feature = "compile")]
+mod translate;
+#[cfg(feature = "compile")]
+mod types_builder;
+#[cfg(feature = "compile")]
+pub use self::compiler::*;
+#[cfg(feature = "compile")]
+pub use self::translate::*;
+#[cfg(feature = "compile")]
+pub use self::types_builder::*;
+
 /// Helper macro to iterate over the transcoders that the host will provide
 /// adapter modules through libcalls.
 #[macro_export]
diff --git a/crates/environ/src/component/artifacts.rs b/crates/environ/src/component/artifacts.rs
new file mode 100644
index 000000000000..7426a75e6de3
--- /dev/null
+++ b/crates/environ/src/component/artifacts.rs
@@ -0,0 +1,68 @@
+//! Definitions of compilation artifacts of the component compilation process
+//! which are serialized with `bincode` into output ELF files.
+
+use crate::{
+    component::{Component, ComponentTypes, TrampolineIndex, TypeComponentIndex},
+    CompiledModuleInfo, FunctionLoc, PrimaryMap, StaticModuleIndex,
+};
+use serde_derive::{Deserialize, Serialize};
+
+/// Serializable state that's stored in a compilation artifact.
+#[derive(Serialize, Deserialize)]
+pub struct ComponentArtifacts {
+    /// The type of this component.
+    pub ty: TypeComponentIndex,
+    /// Information all kept available at runtime as-is.
+    pub info: CompiledComponentInfo,
+    /// Type information for this component and all contained modules.
+    pub types: ComponentTypes,
+    /// Serialized metadata about all included core wasm modules.
+    pub static_modules: PrimaryMap<StaticModuleIndex, CompiledModuleInfo>,
+}
+
+/// Runtime state that a component retains to support its operation.
+#[derive(Serialize, Deserialize)]
+pub struct CompiledComponentInfo {
+    /// Type information calculated during translation about this component.
+    pub component: Component,
+
+    /// Where lowered function trampolines are located within the `text`
+    /// section of `code_memory`.
+    ///
+    /// These are the
+    ///
+    /// 1. Wasm-call,
+    /// 2. array-call
+    ///
+    /// function pointers that end up in a `VMFuncRef` for each
+    /// lowering.
+    pub trampolines: PrimaryMap<TrampolineIndex, AllCallFunc<FunctionLoc>>,
+
+    /// The location of the wasm-to-array trampoline for the `resource.drop`
+    /// intrinsic.
+    pub resource_drop_wasm_to_array_trampoline: Option<FunctionLoc>,
+}
+
+/// A triple of related functions/trampolines variants with differing calling
+/// conventions: `{wasm,array}_call`.
+///
+/// Generic so we can use this with either the `Box<dyn Any + Send>`s that
+/// implementations of the compiler trait return or with `FunctionLoc`s inside
+/// an object file, for example.
+#[derive(Clone, Copy, Default, Serialize, Deserialize)]
+pub struct AllCallFunc<T> {
+    /// The function exposing the Wasm calling convention.
+    pub wasm_call: T,
+    /// The function exposing the array calling convention.
+    pub array_call: T,
+}
+
+impl<T> AllCallFunc<T> {
+    /// Map an `AllCallFunc<T>` into an `AllCallFunc<U>`.
+    pub fn map<U>(self, mut f: impl FnMut(T) -> U) -> AllCallFunc<U> {
+        AllCallFunc {
+            wasm_call: f(self.wasm_call),
+            array_call: f(self.array_call),
+        }
+    }
+}
diff --git a/crates/environ/src/component/compiler.rs b/crates/environ/src/component/compiler.rs
index 13b4a3a4a4c7..aec715c9d19b 100644
--- a/crates/environ/src/component/compiler.rs
+++ b/crates/environ/src/component/compiler.rs
@@ -1,35 +1,8 @@
-use crate::component::{ComponentTranslation, ComponentTypes, TrampolineIndex};
+use crate::component::{AllCallFunc, ComponentTranslation, ComponentTypesBuilder, TrampolineIndex};
+use crate::prelude::*;
 use anyhow::Result;
-use serde_derive::{Deserialize, Serialize};
 use std::any::Any;
 
-/// A triple of related functions/trampolines variants with differing calling
-/// conventions: `{wasm,array,native}_call`.
-///
-/// Generic so we can use this with either the `Box<dyn Any + Send>`s that
-/// implementations of the compiler trait return or with `FunctionLoc`s inside
-/// an object file, for example.
-#[derive(Clone, Copy, Default, Serialize, Deserialize)]
-pub struct AllCallFunc<T> {
-    /// The function exposing the Wasm calling convention.
-    pub wasm_call: T,
-    /// The function exposing the array calling convention.
-    pub array_call: T,
-    /// The function exposing the native calling convention.
-    pub native_call: T,
-}
-
-impl<T> AllCallFunc<T> {
-    /// Map an `AllCallFunc<T>` into an `AllCallFunc<U>`.
-    pub fn map<U>(self, mut f: impl FnMut(T) -> U) -> AllCallFunc<U> {
-        AllCallFunc {
-            wasm_call: f(self.wasm_call),
-            array_call: f(self.array_call),
-            native_call: f(self.native_call),
-        }
-    }
-}
-
 /// Compilation support necessary for components.
 pub trait ComponentCompiler: Send + Sync {
     /// Compiles the pieces necessary to create a `VMFuncRef` for the
@@ -41,7 +14,7 @@ pub trait ComponentCompiler: Send + Sync {
     fn compile_trampoline(
         &self,
         component: &ComponentTranslation,
-        types: &ComponentTypes,
+        types: &ComponentTypesBuilder,
         trampoline: TrampolineIndex,
     ) -> Result<AllCallFunc<Box<dyn Any + Send>>>;
 }
diff --git a/crates/environ/src/component/dfg.rs b/crates/environ/src/component/dfg.rs
index 2fab963234b4..4766ebdfe943 100644
--- a/crates/environ/src/component/dfg.rs
+++ b/crates/environ/src/component/dfg.rs
@@ -28,11 +28,15 @@
 //! fused adapters, what arguments make their way to core wasm modules, etc.
 
 use crate::component::*;
-use crate::{EntityIndex, EntityRef, PrimaryMap, SignatureIndex, WasmType};
+use crate::prelude::*;
+use crate::{EntityIndex, EntityRef, PrimaryMap, WasmValType};
+use anyhow::Result;
 use indexmap::IndexMap;
 use std::collections::HashMap;
 use std::hash::Hash;
 use std::ops::Index;
+use wasmparser::types::ComponentCoreModuleTypeId;
+use wasmtime_types::ModuleInternedTypeIndex;
 
 #[derive(Default)]
 #[allow(missing_docs)]
@@ -48,7 +52,7 @@ pub struct ComponentDfg {
 
     /// All trampolines and their type signature which will need to get
     /// compiled by Cranelift.
-    pub trampolines: Intern<TrampolineIndex, (SignatureIndex, Trampoline)>,
+    pub trampolines: Intern<TrampolineIndex, (ModuleInternedTypeIndex, Trampoline)>,
 
     /// Know reallocation functions which are used by `lowerings` (e.g. will be
     /// used by the host)
@@ -83,7 +87,7 @@ pub struct ComponentDfg {
     ///
     /// This map is not filled in on the initial creation of a `ComponentDfg`.
     /// Instead these modules are filled in by the `inline::adapt` phase where
-    /// adapter modules are identifed and filled in here.
+    /// adapter modules are identified and filled in here.
     ///
     /// The payload here is the static module index representing the core wasm
     /// adapter module that was generated as well as the arguments to the
@@ -183,9 +187,18 @@ pub enum Export {
         func: CoreDef,
         options: CanonicalOptions,
     },
-    ModuleStatic(StaticModuleIndex),
-    ModuleImport(RuntimeImportIndex),
-    Instance(IndexMap<String, Export>),
+    ModuleStatic {
+        ty: ComponentCoreModuleTypeId,
+        index: StaticModuleIndex,
+    },
+    ModuleImport {
+        ty: TypeModuleIndex,
+        import: RuntimeImportIndex,
+    },
+    Instance {
+        ty: TypeComponentInstanceIndex,
+        exports: IndexMap<String, Export>,
+    },
     Type(TypeDef),
 }
 
@@ -277,7 +290,7 @@ pub struct CanonicalOptions {
 /// Same as `info::Resource`
 #[allow(missing_docs)]
 pub struct Resource {
-    pub rep: WasmType,
+    pub rep: WasmValType,
     pub dtor: Option<CoreDef>,
     pub instance: RuntimeComponentInstanceIndex,
 }
@@ -337,7 +350,11 @@ impl<K: EntityRef, V> Default for Intern<K, V> {
 impl ComponentDfg {
     /// Consumes the intermediate `ComponentDfg` to produce a final `Component`
     /// with a linear innitializer list.
-    pub fn finish(self) -> ComponentTranslation {
+    pub fn finish(
+        self,
+        wasmtime_types: &mut ComponentTypesBuilder,
+        wasmparser_types: wasmparser::types::TypesRef<'_>,
+    ) -> Result<ComponentTranslation> {
         let mut linearize = LinearizeDfg {
             dfg: &self,
             initializers: Vec::new(),
@@ -360,20 +377,23 @@ impl ComponentDfg {
 
         // Next the exports of the instance are handled which will likely end up
         // creating some lowered imports, perhaps some saved modules, etc.
-        let exports = self
-            .exports
-            .iter()
-            .map(|(name, export)| (name.clone(), linearize.export(export)))
-            .collect();
+        let mut export_items = PrimaryMap::new();
+        let mut exports = NameMap::default();
+        for (name, export) in self.exports.iter() {
+            let export =
+                linearize.export(export, &mut export_items, wasmtime_types, wasmparser_types)?;
+            exports.insert(name, &mut NameMapNoIntern, false, export)?;
+        }
 
         // With all those pieces done the results of the dataflow-based
         // linearization are recorded into the `Component`. The number of
         // runtime values used for each index space is used from the `linearize`
         // result.
-        ComponentTranslation {
+        Ok(ComponentTranslation {
             trampolines: linearize.trampoline_defs,
             component: Component {
                 exports,
+                export_items,
                 initializers: linearize.initializers,
                 trampolines: linearize.trampolines,
                 num_lowerings: linearize.num_lowerings,
@@ -394,7 +414,7 @@ impl ComponentDfg {
                     .map(|(_, r)| r.instance)
                     .collect(),
             },
-        }
+        })
     }
 
     /// Converts the provided defined index into a normal index, adding in the
@@ -407,7 +427,7 @@ impl ComponentDfg {
 struct LinearizeDfg<'a> {
     dfg: &'a ComponentDfg,
     initializers: Vec<GlobalInitializer>,
-    trampolines: PrimaryMap<TrampolineIndex, SignatureIndex>,
+    trampolines: PrimaryMap<TrampolineIndex, ModuleInternedTypeIndex>,
     trampoline_defs: PrimaryMap<TrampolineIndex, info::Trampoline>,
     trampoline_map: HashMap<TrampolineIndex, TrampolineIndex>,
     runtime_memories: HashMap<MemoryId, RuntimeMemoryIndex>,
@@ -475,8 +495,14 @@ impl LinearizeDfg<'_> {
             }));
     }
 
-    fn export(&mut self, export: &Export) -> info::Export {
-        match export {
+    fn export(
+        &mut self,
+        export: &Export,
+        items: &mut PrimaryMap<ExportIndex, info::Export>,
+        wasmtime_types: &mut ComponentTypesBuilder,
+        wasmparser_types: wasmparser::types::TypesRef<'_>,
+    ) -> Result<ExportIndex> {
+        let item = match export {
             Export::LiftedFunction { ty, func, options } => {
                 let func = self.core_def(func);
                 let options = self.options(options);
@@ -486,15 +512,29 @@ impl LinearizeDfg<'_> {
                     options,
                 }
             }
-            Export::ModuleStatic(i) => info::Export::ModuleStatic(*i),
-            Export::ModuleImport(i) => info::Export::ModuleImport(*i),
-            Export::Instance(map) => info::Export::Instance(
-                map.iter()
-                    .map(|(name, export)| (name.clone(), self.export(export)))
-                    .collect(),
-            ),
+            Export::ModuleStatic { ty, index } => info::Export::ModuleStatic {
+                ty: wasmtime_types.convert_module(wasmparser_types, *ty)?,
+                index: *index,
+            },
+            Export::ModuleImport { ty, import } => info::Export::ModuleImport {
+                ty: *ty,
+                import: *import,
+            },
+            Export::Instance { ty, exports } => info::Export::Instance {
+                ty: *ty,
+                exports: {
+                    let mut map = NameMap::default();
+                    for (name, export) in exports {
+                        let export =
+                            self.export(export, items, wasmtime_types, wasmparser_types)?;
+                        map.insert(name, &mut NameMapNoIntern, false, export)?;
+                    }
+                    map
+                },
+            },
             Export::Type(def) => info::Export::Type(*def),
-        }
+        };
+        Ok(items.push(item))
     }
 
     fn options(&mut self, options: &CanonicalOptions) -> info::CanonicalOptions {
@@ -666,7 +706,7 @@ impl LinearizeDfg<'_> {
         V: EntityRef,
     {
         if let Some(val) = map(self).get(&key) {
-            return val.clone();
+            return *val;
         }
         let tmp = gen(self, key);
         let index = V::new(map(self).len());
diff --git a/crates/environ/src/component/info.rs b/crates/environ/src/component/info.rs
index dff80ffe9bfa..401d4bafd5e1 100644
--- a/crates/environ/src/component/info.rs
+++ b/crates/environ/src/component/info.rs
@@ -9,7 +9,7 @@
 //
 // * This representation of a `Component` avoids the need to create a
 //   `PrimaryMap` of some form for each of the index spaces within a component.
-//   This is less so an issue about allocations and moreso that this information
+//   This is less so an issue about allocations and more so that this information
 //   generally just isn't needed any time after instantiation. Avoiding creating
 //   these altogether helps components be lighter weight at runtime and
 //   additionally accelerates instantiation.
@@ -47,9 +47,10 @@
 // requirements of embeddings change over time.
 
 use crate::component::*;
-use crate::{EntityIndex, PrimaryMap, SignatureIndex, WasmType};
-use indexmap::IndexMap;
+use crate::prelude::*;
+use crate::{EntityIndex, PrimaryMap, WasmValType};
 use serde_derive::{Deserialize, Serialize};
+use wasmtime_types::ModuleInternedTypeIndex;
 
 /// Metadata as a result of compiling a component.
 pub struct ComponentTranslation {
@@ -105,8 +106,14 @@ pub struct Component {
     // best route is or whether such an optimization is even necessary here.
     pub imports: PrimaryMap<RuntimeImportIndex, (ImportIndex, Vec<String>)>,
 
-    /// A list of this component's exports, indexed by either position or name.
-    pub exports: IndexMap<String, Export>,
+    /// This component's own root exports from the component itself.
+    pub exports: NameMap<String, ExportIndex>,
+
+    /// All exports of this component and exported instances of this component.
+    ///
+    /// This is indexed by `ExportIndex` for fast lookup and `Export::Instance`
+    /// will refer back into this list.
+    pub export_items: PrimaryMap<ExportIndex, Export>,
 
     /// Initializers that must be processed when instantiating this component.
     ///
@@ -146,7 +153,7 @@ pub struct Component {
     pub num_runtime_post_returns: u32,
 
     /// WebAssembly type signature of all trampolines.
-    pub trampolines: PrimaryMap<TrampolineIndex, SignatureIndex>,
+    pub trampolines: PrimaryMap<TrampolineIndex, ModuleInternedTypeIndex>,
 
     /// The number of lowered host functions (maximum `LoweredIndex`) needed to
     /// instantiate this component.
@@ -400,12 +407,27 @@ pub enum Export {
         options: CanonicalOptions,
     },
     /// A module defined within this component is exported.
-    ModuleStatic(StaticModuleIndex),
+    ModuleStatic {
+        /// The type of this module
+        ty: TypeModuleIndex,
+        /// Which module this is referring to.
+        index: StaticModuleIndex,
+    },
     /// A module imported into this component is exported.
-    ModuleImport(RuntimeImportIndex),
+    ModuleImport {
+        /// Module type index
+        ty: TypeModuleIndex,
+        /// Module runtime import index
+        import: RuntimeImportIndex,
+    },
     /// A nested instance is being exported which has recursively defined
     /// `Export` items.
-    Instance(IndexMap<String, Export>),
+    Instance {
+        /// Instance type index, if such is assigned
+        ty: TypeComponentInstanceIndex,
+        /// Instance export map
+        exports: NameMap<String, ExportIndex>,
+    },
     /// An exported type from a component or instance, currently only
     /// informational.
     Type(TypeDef),
@@ -444,7 +466,85 @@ pub enum StringEncoding {
     CompactUtf16,
 }
 
-pub use crate::fact::{FixedEncoding, Transcode};
+/// Possible transcoding operations that must be provided by the host.
+///
+/// Note that each transcoding operation may have a unique signature depending
+/// on the precise operation.
+#[allow(missing_docs)]
+#[derive(Debug, Copy, Clone, Hash, Eq, PartialEq)]
+pub enum Transcode {
+    Copy(FixedEncoding),
+    Latin1ToUtf16,
+    Latin1ToUtf8,
+    Utf16ToCompactProbablyUtf16,
+    Utf16ToCompactUtf16,
+    Utf16ToLatin1,
+    Utf16ToUtf8,
+    Utf8ToCompactUtf16,
+    Utf8ToLatin1,
+    Utf8ToUtf16,
+}
+
+impl Transcode {
+    /// Get this transcoding's symbol fragment.
+    pub fn symbol_fragment(&self) -> &'static str {
+        match self {
+            Transcode::Copy(x) => match x {
+                FixedEncoding::Utf8 => "copy_utf8",
+                FixedEncoding::Utf16 => "copy_utf16",
+                FixedEncoding::Latin1 => "copy_latin1",
+            },
+            Transcode::Latin1ToUtf16 => "latin1_to_utf16",
+            Transcode::Latin1ToUtf8 => "latin1_to_utf8",
+            Transcode::Utf16ToCompactProbablyUtf16 => "utf16_to_compact_probably_utf16",
+            Transcode::Utf16ToCompactUtf16 => "utf16_to_compact_utf16",
+            Transcode::Utf16ToLatin1 => "utf16_to_latin1",
+            Transcode::Utf16ToUtf8 => "utf16_to_utf8",
+            Transcode::Utf8ToCompactUtf16 => "utf8_to_compact_utf16",
+            Transcode::Utf8ToLatin1 => "utf8_to_latin1",
+            Transcode::Utf8ToUtf16 => "utf8_to_utf16",
+        }
+    }
+
+    /// Returns a human-readable description for this transcoding operation.
+    pub fn desc(&self) -> &'static str {
+        match self {
+            Transcode::Copy(FixedEncoding::Utf8) => "utf8-to-utf8",
+            Transcode::Copy(FixedEncoding::Utf16) => "utf16-to-utf16",
+            Transcode::Copy(FixedEncoding::Latin1) => "latin1-to-latin1",
+            Transcode::Latin1ToUtf16 => "latin1-to-utf16",
+            Transcode::Latin1ToUtf8 => "latin1-to-utf8",
+            Transcode::Utf16ToCompactProbablyUtf16 => "utf16-to-compact-probably-utf16",
+            Transcode::Utf16ToCompactUtf16 => "utf16-to-compact-utf16",
+            Transcode::Utf16ToLatin1 => "utf16-to-latin1",
+            Transcode::Utf16ToUtf8 => "utf16-to-utf8",
+            Transcode::Utf8ToCompactUtf16 => "utf8-to-compact-utf16",
+            Transcode::Utf8ToLatin1 => "utf8-to-latin1",
+            Transcode::Utf8ToUtf16 => "utf8-to-utf16",
+        }
+    }
+}
+
+#[derive(Debug, Copy, Clone, Hash, Eq, PartialEq, Serialize, Deserialize)]
+#[allow(missing_docs)]
+pub enum FixedEncoding {
+    Utf8,
+    Utf16,
+    Latin1,
+}
+
+impl FixedEncoding {
+    /// Returns the byte width of unit loads/stores for this encoding, for
+    /// example the unit length is multiplied by this return value to get the
+    /// byte width of a string.
+    pub fn width(&self) -> u8 {
+        match self {
+            FixedEncoding::Utf8 => 1,
+            FixedEncoding::Utf16 => 2,
+            FixedEncoding::Latin1 => 1,
+        }
+    }
+}
 
 /// Description of a new resource declared in a `GlobalInitializer::Resource`
 /// variant.
@@ -456,7 +556,7 @@ pub struct Resource {
     /// The local index of the resource being defined.
     pub index: DefinedResourceIndex,
     /// Core wasm representation of this resource.
-    pub rep: WasmType,
+    pub rep: WasmValType,
     /// Optionally-specified destructor and where it comes from.
     pub dtor: Option<CoreDef>,
     /// Which component instance this resource logically belongs to.
diff --git a/crates/environ/src/component/names.rs b/crates/environ/src/component/names.rs
new file mode 100644
index 000000000000..e19cdd382f58
--- /dev/null
+++ b/crates/environ/src/component/names.rs
@@ -0,0 +1,275 @@
+use crate::prelude::*;
+use anyhow::{bail, Result};
+use core::hash::Hash;
+use semver::Version;
+use serde_derive::{Deserialize, Serialize};
+
+/// A semver-aware map for imports/exports of a component.
+///
+/// This data structure is used when looking up the names of imports/exports of
+/// a component to enable semver-compatible matching of lookups. This will
+/// enable lookups of `a:b/c@0.2.0` to match entries defined as `a:b/c@0.2.1`
+/// which is currently considered a key feature of WASI's compatibility story.
+///
+/// On the outside this looks like a map of `K` to `V`.
+#[derive(Clone, Serialize, Deserialize, Debug)]
+pub struct NameMap<K: Clone + Hash + Eq + Ord, V> {
+    /// A map of keys to the value that they define.
+    ///
+    /// Note that this map is "exact" where the name here is the exact name that
+    /// was specified when the `insert` was called. This doesn't have any
+    /// semver-mangling or anything like that.
+    ///
+    /// This map is always consulted first during lookups.
+    definitions: IndexMap<K, V>,
+
+    /// An auxiliary map tracking semver-compatible names. This is a map from
+    /// "semver compatible alternate name" to a name present in `definitions`
+    /// and the semver version it was registered at.
+    ///
+    /// An example map would be:
+    ///
+    /// ```text
+    /// {
+    ///     "a:b/c@0.2": ("a:b/c@0.2.1", 0.2.1),
+    ///     "a:b/c@2": ("a:b/c@2.0.0+abc", 2.0.0+abc),
+    /// }
+    /// ```
+    ///
+    /// As names are inserted into `definitions` each name may have up to one
+    /// semver-compatible name with extra numbers/info chopped off which is
+    /// inserted into this map. This map is the lookup table from `@0.2` to
+    /// `@0.2.x` where `x` is what was inserted manually.
+    ///
+    /// The `Version` here is tracked to ensure that when multiple versions on
+    /// one track are defined that only the maximal version here is retained.
+    alternate_lookups: IndexMap<K, (K, Version)>,
+}
+
+impl<K, V> NameMap<K, V>
+where
+    K: Clone + Hash + Eq + Ord,
+{
+    /// Inserts the `name` specified into this map.
+    ///
+    /// The name is intern'd through the `cx` argument and shadowing is
+    /// controlled by the `allow_shadowing` variable.
+    ///
+    /// This function will automatically insert an entry in
+    /// `self.alternate_lookups` if `name` is a semver-looking name.
+    ///
+    /// Returns an error if `allow_shadowing` is `false` and the `name` is
+    /// already present in this map (by exact match). Otherwise returns the
+    /// intern'd version of `name`.
+    pub fn insert<I>(&mut self, name: &str, cx: &mut I, allow_shadowing: bool, item: V) -> Result<K>
+    where
+        I: NameMapIntern<Key = K>,
+    {
+        // Always insert `name` and `item` as an exact definition.
+        let key = cx.intern(name);
+        if let Some(prev) = self.definitions.insert(key.clone(), item) {
+            if !allow_shadowing {
+                self.definitions.insert(key, prev);
+                bail!("map entry `{name}` defined twice")
+            }
+        }
+
+        // If `name` is a semver-looking thing, like `a:b/c@1.0.0`, then also
+        // insert an entry in the semver-compatible map under a key such as
+        // `a:b/c@1`.
+        //
+        // This key is used during `get` later on.
+        if let Some((alternate_key, version)) = alternate_lookup_key(name) {
+            let alternate_key = cx.intern(alternate_key);
+            if let Some((prev_key, prev_version)) = self
+                .alternate_lookups
+                .insert(alternate_key.clone(), (key.clone(), version.clone()))
+            {
+                // Prefer the latest version, so only do this if we're
+                // greater than the prior version.
+                if version < prev_version {
+                    self.alternate_lookups
+                        .insert(alternate_key, (prev_key, prev_version));
+                }
+            }
+        }
+        Ok(key)
+    }
+
+    /// Looks up `name` within this map, using the interning specified by
+    /// `cx`.
+    ///
+    /// This may return a definition even if `name` wasn't exactly defined in
+    /// this map, such as looking up `a:b/c@0.2.0` when the map only has
+    /// `a:b/c@0.2.1` defined.
+    pub fn get<I>(&self, name: &str, cx: &I) -> Option<&V>
+    where
+        I: NameMapIntern<Key = K>,
+    {
+        // First look up an exact match and if that's found return that. This
+        // enables defining multiple versions in the map and the requested
+        // version is returned if it matches exactly.
+        let candidate = cx.lookup(name).and_then(|k| self.definitions.get(&k));
+        if let Some(def) = candidate {
+            return Some(def);
+        }
+
+        // Failing that, then try to look for a semver-compatible alternative.
+        // This looks up the key based on `name`, if any, and then looks to see
+        // if that was intern'd in `strings`. Given all that look to see if it
+        // was defined in `alternate_lookups` and finally at the end that exact
+        // key is then used to look up again in `self.definitions`.
+        let (alternate_name, _version) = alternate_lookup_key(name)?;
+        let alternate_key = cx.lookup(alternate_name)?;
+        let (exact_key, _version) = self.alternate_lookups.get(&alternate_key)?;
+        self.definitions.get(exact_key)
+    }
+
+    /// Returns an iterator over inserted values in this map.
+    ///
+    /// Note that the iterator return yields intern'd keys and additionally does
+    /// not do anything special with semver names and such, it only literally
+    /// yields what's been inserted with [`NameMap::insert`].
+    pub fn raw_iter(&self) -> impl Iterator<Item = (&K, &V)> {
+        self.definitions.iter()
+    }
+
+    /// TODO
+    pub fn raw_get_mut(&mut self, key: &K) -> Option<&mut V> {
+        self.definitions.get_mut(key)
+    }
+}
+
+impl<K, V> Default for NameMap<K, V>
+where
+    K: Clone + Hash + Eq + Ord,
+{
+    fn default() -> NameMap<K, V> {
+        NameMap {
+            definitions: Default::default(),
+            alternate_lookups: Default::default(),
+        }
+    }
+}
+
+/// A helper trait used in conjunction with [`NameMap`] to optionally intern
+/// keys to non-strings.
+pub trait NameMapIntern {
+    /// The key that this interning context generates.
+    type Key;
+
+    /// Inserts `s` into `self` and returns the intern'd key `Self::Key`.
+    fn intern(&mut self, s: &str) -> Self::Key;
+
+    /// Looks up `s` in `self` returning `Some` if it was found or `None` if
+    /// it's not present.
+    fn lookup(&self, s: &str) -> Option<Self::Key>;
+}
+
+/// For use with [`NameMap`] when no interning should happen and instead string
+/// keys are copied as-is.
+pub struct NameMapNoIntern;
+
+impl NameMapIntern for NameMapNoIntern {
+    type Key = String;
+
+    fn intern(&mut self, s: &str) -> String {
+        s.to_string()
+    }
+
+    fn lookup(&self, s: &str) -> Option<String> {
+        Some(s.to_string())
+    }
+}
+
+/// Determines a version-based "alternate lookup key" for the `name` specified.
+///
+/// Some examples are:
+///
+/// * `foo` => `None`
+/// * `foo:bar/baz` => `None`
+/// * `foo:bar/baz@1.1.2` => `Some(foo:bar/baz@1)`
+/// * `foo:bar/baz@0.1.0` => `Some(foo:bar/baz@0.1)`
+/// * `foo:bar/baz@0.0.1` => `None`
+/// * `foo:bar/baz@0.1.0-rc.2` => `None`
+///
+/// This alternate lookup key is intended to serve the purpose where a
+/// semver-compatible definition can be located, if one is defined, at perhaps
+/// either a newer or an older version.
+fn alternate_lookup_key(name: &str) -> Option<(&str, Version)> {
+    let at = name.find('@')?;
+    let version_string = &name[at + 1..];
+    let version = Version::parse(version_string).ok()?;
+    if !version.pre.is_empty() {
+        // If there's a prerelease then don't consider that compatible with any
+        // other version number.
+        None
+    } else if version.major != 0 {
+        // If the major number is nonzero then compatibility is up to the major
+        // version number, so return up to the first decimal.
+        let first_dot = version_string.find('.')? + at + 1;
+        Some((&name[..first_dot], version))
+    } else if version.minor != 0 {
+        // Like the major version if the minor is nonzero then patch releases
+        // are all considered to be on a "compatible track".
+        let first_dot = version_string.find('.')? + at + 1;
+        let second_dot = name[first_dot + 1..].find('.')? + first_dot + 1;
+        Some((&name[..second_dot], version))
+    } else {
+        // If the patch number is the first nonzero entry then nothing can be
+        // compatible with this patch, e.g. 0.0.1 isn't' compatible with
+        // any other version inherently.
+        None
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{NameMap, NameMapNoIntern};
+
+    #[test]
+    fn alternate_lookup_key() {
+        fn alt(s: &str) -> Option<&str> {
+            super::alternate_lookup_key(s).map(|(s, _)| s)
+        }
+
+        assert_eq!(alt("x"), None);
+        assert_eq!(alt("x:y/z"), None);
+        assert_eq!(alt("x:y/z@1.0.0"), Some("x:y/z@1"));
+        assert_eq!(alt("x:y/z@1.1.0"), Some("x:y/z@1"));
+        assert_eq!(alt("x:y/z@1.1.2"), Some("x:y/z@1"));
+        assert_eq!(alt("x:y/z@2.1.2"), Some("x:y/z@2"));
+        assert_eq!(alt("x:y/z@2.1.2+abc"), Some("x:y/z@2"));
+        assert_eq!(alt("x:y/z@0.1.2"), Some("x:y/z@0.1"));
+        assert_eq!(alt("x:y/z@0.1.3"), Some("x:y/z@0.1"));
+        assert_eq!(alt("x:y/z@0.2.3"), Some("x:y/z@0.2"));
+        assert_eq!(alt("x:y/z@0.2.3+abc"), Some("x:y/z@0.2"));
+        assert_eq!(alt("x:y/z@0.0.1"), None);
+        assert_eq!(alt("x:y/z@0.0.1-pre"), None);
+        assert_eq!(alt("x:y/z@0.1.0-pre"), None);
+        assert_eq!(alt("x:y/z@1.0.0-pre"), None);
+    }
+
+    #[test]
+    fn name_map_smoke() {
+        let mut map = NameMap::default();
+        let mut intern = NameMapNoIntern;
+
+        map.insert("a", &mut intern, false, 0).unwrap();
+        map.insert("b", &mut intern, false, 1).unwrap();
+
+        assert!(map.insert("a", &mut intern, false, 0).is_err());
+        assert!(map.insert("a", &mut intern, true, 0).is_ok());
+
+        assert_eq!(map.get("a", &intern), Some(&0));
+        assert_eq!(map.get("b", &intern), Some(&1));
+        assert_eq!(map.get("c", &intern), None);
+
+        map.insert("a:b/c@1.0.0", &mut intern, false, 2).unwrap();
+        map.insert("a:b/c@1.0.1", &mut intern, false, 3).unwrap();
+        assert_eq!(map.get("a:b/c@1.0.0", &intern), Some(&2));
+        assert_eq!(map.get("a:b/c@1.0.1", &intern), Some(&3));
+        assert_eq!(map.get("a:b/c@1.0.2", &intern), Some(&3));
+        assert_eq!(map.get("a:b/c@1.1.0", &intern), Some(&3));
+    }
+}
diff --git a/crates/environ/src/component/translate.rs b/crates/environ/src/component/translate.rs
index b054214536a8..960aae84c085 100644
--- a/crates/environ/src/component/translate.rs
+++ b/crates/environ/src/component/translate.rs
@@ -1,15 +1,23 @@
 use crate::component::*;
+use crate::prelude::*;
+use crate::Module;
 use crate::ScopeVec;
 use crate::{
-    EntityIndex, ModuleEnvironment, ModuleTranslation, ModuleTypesBuilder, PrimaryMap,
-    SignatureIndex, Tunables, TypeConvert, WasmHeapType, WasmType,
+    EntityIndex, ModuleEnvironment, ModuleTranslation, ModuleTypesBuilder, PrimaryMap, Tunables,
+    TypeConvert, WasmHeapType, WasmValType,
 };
+use anyhow::anyhow;
 use anyhow::{bail, Result};
 use indexmap::IndexMap;
 use std::collections::HashMap;
 use std::mem;
-use wasmparser::types::{ComponentEntityType, TypeId, Types};
-use wasmparser::{Chunk, ComponentExternName, Encoding, Parser, Payload, Validator};
+use wasmparser::types::{
+    AliasableResourceId, ComponentCoreModuleTypeId, ComponentEntityType, ComponentFuncTypeId,
+    ComponentInstanceTypeId, Types,
+};
+use wasmparser::{Chunk, ComponentImportName, Encoding, Parser, Payload, Validator};
+use wasmtime_types::ModuleInternedTypeIndex;
+use wasmtime_types::WasmResult;
 
 mod adapt;
 pub use self::adapt::*;
@@ -165,25 +173,25 @@ struct Translation<'data> {
 #[allow(missing_docs)]
 enum LocalInitializer<'data> {
     // imports
-    Import(ComponentExternName<'data>, ComponentEntityType),
+    Import(ComponentImportName<'data>, ComponentEntityType),
 
     // canonical function sections
     Lower {
         func: ComponentFuncIndex,
-        lower_ty: TypeId,
-        canonical_abi: SignatureIndex,
+        lower_ty: ComponentFuncTypeId,
+        canonical_abi: ModuleInternedTypeIndex,
         options: LocalCanonicalOptions,
     },
-    Lift(TypeId, FuncIndex, LocalCanonicalOptions),
+    Lift(ComponentFuncTypeId, FuncIndex, LocalCanonicalOptions),
 
     // resources
-    Resource(TypeId, WasmType, Option<FuncIndex>),
-    ResourceNew(TypeId, SignatureIndex),
-    ResourceRep(TypeId, SignatureIndex),
-    ResourceDrop(TypeId, SignatureIndex),
+    Resource(AliasableResourceId, WasmValType, Option<FuncIndex>),
+    ResourceNew(AliasableResourceId, ModuleInternedTypeIndex),
+    ResourceRep(AliasableResourceId, ModuleInternedTypeIndex),
+    ResourceDrop(AliasableResourceId, ModuleInternedTypeIndex),
 
     // core wasm modules
-    ModuleStatic(StaticModuleIndex),
+    ModuleStatic(StaticModuleIndex, ComponentCoreModuleTypeId),
 
     // core wasm module instances
     ModuleInstantiate(ModuleIndex, HashMap<&'data str, ModuleInstanceIndex>),
@@ -193,8 +201,12 @@ enum LocalInitializer<'data> {
     ComponentStatic(StaticComponentIndex, ClosedOverVars),
 
     // component instances
-    ComponentInstantiate(ComponentIndex, HashMap<&'data str, ComponentItem>, TypeId),
-    ComponentSynthetic(HashMap<&'data str, ComponentItem>),
+    ComponentInstantiate(
+        ComponentIndex,
+        HashMap<&'data str, ComponentItem>,
+        ComponentInstanceTypeId,
+    ),
+    ComponentSynthetic(HashMap<&'data str, ComponentItem>, ComponentInstanceTypeId),
 
     // alias section
     AliasExportFunc(ModuleInstanceIndex, &'data str),
@@ -261,12 +273,14 @@ impl<'a, 'data> Translator<'a, 'data> {
         types: &'a mut ComponentTypesBuilder,
         scope_vec: &'data ScopeVec<u8>,
     ) -> Self {
+        let mut parser = Parser::new(0);
+        parser.set_features(*validator.features());
         Self {
             result: Translation::default(),
             tunables,
             validator,
             types: PreInliningComponentTypes::new(types),
-            parser: Parser::new(0),
+            parser,
             lexical_scopes: Vec::new(),
             static_components: Default::default(),
             static_modules: Default::default(),
@@ -281,7 +295,7 @@ impl<'a, 'data> Translator<'a, 'data> {
     /// `component` does not have to be valid and it will be validated during
     /// compilation.
     ///
-    /// THe result of this function is a tuple of the final component's
+    /// The result of this function is a tuple of the final component's
     /// description plus a list of core wasm modules found within the
     /// component. The component's description actually erases internal
     /// components, instances, etc, as much as it can. Instead `Component`
@@ -345,7 +359,9 @@ impl<'a, 'data> Translator<'a, 'data> {
             &self.static_components,
         )?;
         self.partition_adapter_modules(&mut component);
-        Ok((component.finish(), self.static_modules))
+        let translation =
+            component.finish(self.types.types_mut_for_inlining(), self.result.types_ref())?;
+        Ok((translation, self.static_modules))
     }
 
     fn translate_payload(
@@ -414,7 +430,9 @@ impl<'a, 'data> Translator<'a, 'data> {
                     match ty? {
                         wasmparser::ComponentType::Resource { rep, dtor } => {
                             let rep = self.types.convert_valtype(rep);
-                            let id = types.component_type_at(component_type_index);
+                            let id = types
+                                .component_any_type_at(component_type_index)
+                                .unwrap_resource();
                             let dtor = dtor.map(FuncIndex::from_u32);
                             self.result
                                 .initializers
@@ -444,7 +462,7 @@ impl<'a, 'data> Translator<'a, 'data> {
                     let import = import?;
                     let types = self.validator.types(0).unwrap();
                     let ty = types
-                        .component_entity_type_of_import(import.name.as_str())
+                        .component_entity_type_of_import(import.name.0)
                         .unwrap();
                     self.result
                         .initializers
@@ -465,7 +483,7 @@ impl<'a, 'data> Translator<'a, 'data> {
                             core_func_index,
                             options,
                         } => {
-                            let ty = types.component_type_at(type_index);
+                            let ty = types.component_any_type_at(type_index).unwrap_func();
                             let func = FuncIndex::from_u32(core_func_index);
                             let options = self.canonical_options(&options);
                             LocalInitializer::Lift(ty, func, options)
@@ -477,7 +495,7 @@ impl<'a, 'data> Translator<'a, 'data> {
                             let lower_ty = types.component_function_at(func_index);
                             let func = ComponentFuncIndex::from_u32(func_index);
                             let options = self.canonical_options(&options);
-                            let canonical_abi = self.core_func_signature(core_func_index);
+                            let canonical_abi = self.core_func_signature(core_func_index)?;
 
                             core_func_index += 1;
                             LocalInitializer::Lower {
@@ -488,20 +506,20 @@ impl<'a, 'data> Translator<'a, 'data> {
                             }
                         }
                         wasmparser::CanonicalFunction::ResourceNew { resource } => {
-                            let resource = types.component_type_at(resource);
-                            let ty = self.core_func_signature(core_func_index);
+                            let resource = types.component_any_type_at(resource).unwrap_resource();
+                            let ty = self.core_func_signature(core_func_index)?;
                             core_func_index += 1;
                             LocalInitializer::ResourceNew(resource, ty)
                         }
                         wasmparser::CanonicalFunction::ResourceDrop { resource } => {
-                            let resource = types.component_type_at(resource);
-                            let ty = self.core_func_signature(core_func_index);
+                            let resource = types.component_any_type_at(resource).unwrap_resource();
+                            let ty = self.core_func_signature(core_func_index)?;
                             core_func_index += 1;
                             LocalInitializer::ResourceDrop(resource, ty)
                         }
                         wasmparser::CanonicalFunction::ResourceRep { resource } => {
-                            let resource = types.component_type_at(resource);
-                            let ty = self.core_func_signature(core_func_index);
+                            let resource = types.component_any_type_at(resource).unwrap_resource();
+                            let ty = self.core_func_signature(core_func_index)?;
                             core_func_index += 1;
                             LocalInitializer::ResourceRep(resource, ty)
                         }
@@ -518,19 +536,38 @@ impl<'a, 'data> Translator<'a, 'data> {
             // Note that this is just initial type translation of the core wasm
             // module and actual function compilation is deferred until this
             // entire process has completed.
-            Payload::ModuleSection { parser, range } => {
-                self.validator.module_section(&range)?;
+            Payload::ModuleSection {
+                parser,
+                unchecked_range,
+            } => {
+                let index = self.validator.types(0).unwrap().module_count();
+                self.validator.module_section(&unchecked_range)?;
                 let translation = ModuleEnvironment::new(
                     self.tunables,
                     self.validator,
                     self.types.module_types_builder(),
                 )
-                .translate(parser, &component[range.start..range.end])?;
+                .translate(
+                    parser,
+                    component
+                        .get(unchecked_range.start..unchecked_range.end)
+                        .ok_or_else(|| {
+                            anyhow!(
+                                "section range {}..{} is out of bounds (bound = {})",
+                                unchecked_range.start,
+                                unchecked_range.end,
+                                component.len()
+                            )
+                            .context("wasm component contains an invalid module section")
+                        })?,
+                )?;
                 let static_idx = self.static_modules.push(translation);
+                let types = self.validator.types(0).unwrap();
+                let ty = types.module_at(index);
                 self.result
                     .initializers
-                    .push(LocalInitializer::ModuleStatic(static_idx));
-                return Ok(Action::Skip(range.end - range.start));
+                    .push(LocalInitializer::ModuleStatic(static_idx, ty));
+                return Ok(Action::Skip(unchecked_range.end - unchecked_range.start));
             }
 
             // When a sub-component is found then the current translation state
@@ -541,8 +578,11 @@ impl<'a, 'data> Translator<'a, 'data> {
             // starts empty since it will only get populated if translation of
             // the nested component ends up aliasing some outer module or
             // component.
-            Payload::ComponentSection { parser, range } => {
-                self.validator.component_section(&range)?;
+            Payload::ComponentSection {
+                parser,
+                unchecked_range,
+            } => {
+                self.validator.component_section(&unchecked_range)?;
                 self.lexical_scopes.push(LexicalScope {
                     parser: mem::replace(&mut self.parser, parser),
                     translation: mem::take(&mut self.result),
@@ -573,18 +613,18 @@ impl<'a, 'data> Translator<'a, 'data> {
                 let mut index = self.validator.types(0).unwrap().component_instance_count();
                 self.validator.component_instance_section(&s)?;
                 for instance in s {
+                    let types = self.validator.types(0).unwrap();
+                    let ty = types.component_instance_at(index);
                     let init = match instance? {
                         wasmparser::ComponentInstance::Instantiate {
                             component_index,
                             args,
                         } => {
-                            let types = self.validator.types(0).unwrap();
-                            let ty = types.component_instance_at(index);
                             let index = ComponentIndex::from_u32(component_index);
                             self.instantiate_component(index, &args, ty)?
                         }
                         wasmparser::ComponentInstance::FromExports(exports) => {
-                            self.instantiate_component_from_exports(&exports)?
+                            self.instantiate_component_from_exports(&exports, ty)?
                         }
                     };
                     self.result.initializers.push(init);
@@ -602,7 +642,7 @@ impl<'a, 'data> Translator<'a, 'data> {
                 for export in s {
                     let export = export?;
                     let item = self.kind_to_item(export.kind, export.index)?;
-                    let prev = self.result.exports.insert(export.name.as_str(), item);
+                    let prev = self.result.exports.insert(export.name.0, item);
                     assert!(prev.is_none());
                     self.result
                         .initializers
@@ -722,7 +762,7 @@ impl<'a, 'data> Translator<'a, 'data> {
         &mut self,
         component: ComponentIndex,
         raw_args: &[wasmparser::ComponentInstantiationArg<'data>],
-        ty: TypeId,
+        ty: ComponentInstanceTypeId,
     ) -> Result<LocalInitializer<'data>> {
         let mut args = HashMap::with_capacity(raw_args.len());
         for arg in raw_args {
@@ -738,14 +778,15 @@ impl<'a, 'data> Translator<'a, 'data> {
     fn instantiate_component_from_exports(
         &mut self,
         exports: &[wasmparser::ComponentExport<'data>],
+        ty: ComponentInstanceTypeId,
     ) -> Result<LocalInitializer<'data>> {
         let mut map = HashMap::with_capacity(exports.len());
         for export in exports {
             let idx = self.kind_to_item(export.kind, export.index)?;
-            map.insert(export.name.as_str(), idx);
+            map.insert(export.name.0, idx);
         }
 
-        Ok(LocalInitializer::ComponentSynthetic(map))
+        Ok(LocalInitializer::ComponentSynthetic(map, ty))
     }
 
     fn kind_to_item(
@@ -775,7 +816,7 @@ impl<'a, 'data> Translator<'a, 'data> {
             }
             wasmparser::ComponentExternalKind::Type => {
                 let types = self.validator.types(0).unwrap();
-                let ty = types.component_type_at(index);
+                let ty = types.component_any_type_at(index);
                 ComponentItem::Type(ty)
             }
         })
@@ -881,12 +922,14 @@ impl<'a, 'data> Translator<'a, 'data> {
         return ret;
     }
 
-    fn core_func_signature(&mut self, idx: u32) -> SignatureIndex {
+    /// Get the interned type index for the `index`th core function.
+    fn core_func_signature(&mut self, index: u32) -> WasmResult<ModuleInternedTypeIndex> {
         let types = self.validator.types(0).unwrap();
-        let id = types.function_at(idx);
-        let ty = types[id].unwrap_func();
-        let ty = self.types.convert_func_type(ty);
-        self.types.module_types_builder().wasm_func_type(ty)
+        let id = types.core_function_at(index);
+        let module = Module::default();
+        self.types
+            .module_types_builder()
+            .intern_type(&module, types, id)
     }
 }
 
@@ -920,7 +963,7 @@ mod pre_inlining {
         }
 
         pub fn module_types_builder(&mut self) -> &mut ModuleTypesBuilder {
-            self.types.module_types_builder()
+            self.types.module_types_builder_mut()
         }
 
         pub fn types(&self) -> &ComponentTypesBuilder {
@@ -935,9 +978,16 @@ mod pre_inlining {
     }
 
     impl TypeConvert for PreInliningComponentTypes<'_> {
-        fn lookup_heap_type(&self, index: TypeIndex) -> WasmHeapType {
+        fn lookup_heap_type(&self, index: wasmparser::UnpackedIndex) -> WasmHeapType {
             self.types.lookup_heap_type(index)
         }
+
+        fn lookup_type_index(
+            &self,
+            index: wasmparser::UnpackedIndex,
+        ) -> wasmtime_types::EngineOrModuleTypeIndex {
+            self.types.lookup_type_index(index)
+        }
     }
 }
 use pre_inlining::PreInliningComponentTypes;
diff --git a/crates/environ/src/component/translate/adapt.rs b/crates/environ/src/component/translate/adapt.rs
index e182d599708c..8989e6fce1a1 100644
--- a/crates/environ/src/component/translate/adapt.rs
+++ b/crates/environ/src/component/translate/adapt.rs
@@ -101,13 +101,13 @@
 //! algorithm is a one-pass approach to partitioning everything into adapter
 //! modules.
 //!
-//! Adapters were indentified in-order as part of the inlining phase of
+//! Adapters were identified in-order as part of the inlining phase of
 //! translation where we're guaranteed that once an adapter is identified
 //! it can't depend on anything identified later. The pass implemented here is
 //! to visit all transitive dependencies of an adapter. If one of the
 //! dependencies of an adapter is an adapter in the current adapter module
 //! being built then the current module is finished and a new adapter module is
-//! started. This should quickly parition adapters into contiugous chunks of
+//! started. This should quickly partition adapters into contiugous chunks of
 //! their index space which can be in adapter modules together.
 //!
 //! There's probably more general algorithms for this but for now this should be
@@ -119,7 +119,6 @@ use crate::component::translate::*;
 use crate::fact;
 use crate::EntityType;
 use std::collections::HashSet;
-use wasmparser::WasmFeatures;
 
 /// Metadata information about a fused adapter.
 #[derive(Debug, Clone, Hash, Eq, PartialEq)]
@@ -171,7 +170,7 @@ impl<'data> Translator<'_, 'data> {
     /// metadata for adapter modules.
     pub(super) fn partition_adapter_modules(&mut self, component: &mut dfg::ComponentDfg) {
         // Visit each adapter, in order of its original definition, during the
-        // paritioning. This allows for the guarantee that dependencies are
+        // partitioning. This allows for the guarantee that dependencies are
         // visited in a topological fashion ideally.
         let mut state = PartitionAdapterModules::default();
         for (id, adapter) in component.adapters.iter() {
@@ -212,13 +211,10 @@ impl<'data> Translator<'_, 'data> {
             // specifically enabled here since the adapter module is highly
             // likely to use that if anything is actually indirected through
             // memory.
-            let mut validator = Validator::new_with_features(WasmFeatures {
-                multi_memory: true,
-                ..*self.validator.features()
-            });
+            self.validator.reset();
             let translation = ModuleEnvironment::new(
                 self.tunables,
-                &mut validator,
+                &mut self.validator,
                 self.types.module_types_builder(),
             )
             .translate(Parser::new(0), wasm)
@@ -259,7 +255,9 @@ fn fact_import_to_core_def(
 ) -> dfg::CoreDef {
     let mut simple_intrinsic = |trampoline: dfg::Trampoline| {
         let signature = ty.unwrap_func();
-        let index = dfg.trampolines.push((signature, trampoline));
+        let index = dfg
+            .trampolines
+            .push((signature.unwrap_module_type_index(), trampoline));
         dfg::CoreDef::Trampoline(index)
     };
     match import {
@@ -285,7 +283,7 @@ fn fact_import_to_core_def(
             let to = dfg.memories.push(unwrap_memory(to));
             let signature = ty.unwrap_func();
             let index = dfg.trampolines.push((
-                signature,
+                signature.unwrap_module_type_index(),
                 dfg::Trampoline::Transcoder {
                     op: *op,
                     from,
diff --git a/crates/environ/src/component/translate/inline.rs b/crates/environ/src/component/translate/inline.rs
index dc75a404c7fc..d3a84da55ae2 100644
--- a/crates/environ/src/component/translate/inline.rs
+++ b/crates/environ/src/component/translate/inline.rs
@@ -45,11 +45,9 @@
 //! side-effectful initializers are emitted to the `GlobalInitializer` list in the
 //! final `Component`.
 
-use crate::component::translate::adapt::{Adapter, AdapterOptions};
 use crate::component::translate::*;
-use crate::{EntityType, PrimaryMap};
-use indexmap::IndexMap;
 use std::borrow::Cow;
+use wasmparser::types::{ComponentAnyTypeId, ComponentCoreModuleTypeId};
 
 pub(super) fn run(
     types: &mut ComponentTypesBuilder,
@@ -114,12 +112,9 @@ pub(super) fn run(
         if let TypeDef::Interface(_) = ty {
             continue;
         }
-        let index = inliner
-            .result
-            .import_types
-            .push((name.as_str().to_string(), ty));
+        let index = inliner.result.import_types.push((name.0.to_string(), ty));
         let path = ImportPath::root(index);
-        args.insert(name.as_str(), ComponentItemDef::from_import(path, ty)?);
+        args.insert(name.0, ComponentItemDef::from_import(path, ty)?);
     }
 
     // This will run the inliner to completion after being seeded with the
@@ -220,7 +215,7 @@ struct InlinerFrame<'a> {
     /// register resource types after instantiation has completed.
     ///
     /// This is `Some` for all subcomponents and `None` for the root component.
-    instance_ty: Option<TypeId>,
+    instance_ty: Option<ComponentInstanceTypeId>,
 }
 
 /// "Closure state" for a component which is resolved from the `ClosedOverVars`
@@ -228,7 +223,7 @@ struct InlinerFrame<'a> {
 //
 // FIXME: this is cloned quite a lot and given the internal maps if this is a
 // perf issue we may want to `Rc` these fields. Note that this is only a perf
-// hit at compile-time though which we in general don't pay too too much
+// hit at compile-time though which we in general don't pay too much
 // attention to.
 #[derive(Default, Clone)]
 struct ComponentClosure<'a> {
@@ -275,7 +270,7 @@ enum ModuleDef<'a> {
     ///
     /// The `StaticModuleIndex` indexes into the `static_modules` map in the
     /// `Inliner`.
-    Static(StaticModuleIndex),
+    Static(StaticModuleIndex, ComponentCoreModuleTypeId),
 
     /// A core wasm module that was imported from the host.
     Import(ImportPath<'a>, TypeModuleIndex),
@@ -332,7 +327,10 @@ enum ComponentInstanceDef<'a> {
     //
     // FIXME: same as the issue on `ComponentClosure` where this is cloned a lot
     // and may need `Rc`.
-    Items(IndexMap<&'a str, ComponentItemDef<'a>>),
+    Items(
+        IndexMap<&'a str, ComponentItemDef<'a>>,
+        TypeComponentInstanceIndex,
+    ),
 }
 
 #[derive(Clone)]
@@ -398,11 +396,7 @@ impl<'a> Inliner<'a> {
                     *types.resources_mut() = snapshot;
                     match frames.last_mut() {
                         Some((parent, _)) => {
-                            parent.finish_instantiate(
-                                ComponentInstanceDef::Items(exports),
-                                instance_ty.unwrap(),
-                                types,
-                            );
+                            parent.finish_instantiate(exports, instance_ty.unwrap(), types)?;
                         }
                         None => break Ok(exports),
                     }
@@ -431,7 +425,7 @@ impl<'a> Inliner<'a> {
             // was provided as an import at the instantiation-site to what was
             // needed during the component's instantiation.
             Import(name, ty) => {
-                let arg = match frame.args.get(name.as_str()) {
+                let arg = match frame.args.get(name.0) {
                     Some(arg) => arg,
 
                     // Not all arguments need to be provided for instantiation,
@@ -447,12 +441,11 @@ impl<'a> Inliner<'a> {
                     // skipped.
                     None => {
                         match ty {
-                            ComponentEntityType::Type { created, .. } => {
-                                match frame.translation.types_ref()[*created] {
-                                    wasmparser::types::Type::Resource(_) => unreachable!(),
-                                    _ => {}
-                                }
-                            }
+                            ComponentEntityType::Type {
+                                created: ComponentAnyTypeId::Resource(_),
+                                ..
+                            } => unreachable!(),
+                            ComponentEntityType::Type { .. } => {}
                             _ => unreachable!(),
                         }
                         return Ok(None);
@@ -643,16 +636,14 @@ impl<'a> Inliner<'a> {
                 // intended, though, since `ty` can't be referred to outside of
                 // this component.
                 let idx = self.result.resource_index(idx);
-                types
-                    .resources_mut()
-                    .register_resource(frame.translation.types_ref(), *ty, idx);
+                types.resources_mut().register_resource(ty.resource(), idx);
             }
 
             // Resource-related intrinsics are generally all the same.
             // Wasmparser type information is converted to wasmtime type
             // information and then new entries for each intrinsic are recorded.
             ResourceNew(id, ty) => {
-                let id = types.resource_id(frame.translation.types_ref(), *id);
+                let id = types.resource_id(id.resource());
                 let index = self
                     .result
                     .trampolines
@@ -660,7 +651,7 @@ impl<'a> Inliner<'a> {
                 frame.funcs.push(dfg::CoreDef::Trampoline(index));
             }
             ResourceRep(id, ty) => {
-                let id = types.resource_id(frame.translation.types_ref(), *id);
+                let id = types.resource_id(id.resource());
                 let index = self
                     .result
                     .trampolines
@@ -668,7 +659,7 @@ impl<'a> Inliner<'a> {
                 frame.funcs.push(dfg::CoreDef::Trampoline(index));
             }
             ResourceDrop(id, ty) => {
-                let id = types.resource_id(frame.translation.types_ref(), *id);
+                let id = types.resource_id(id.resource());
                 let index = self
                     .result
                     .trampolines
@@ -676,8 +667,8 @@ impl<'a> Inliner<'a> {
                 frame.funcs.push(dfg::CoreDef::Trampoline(index));
             }
 
-            ModuleStatic(idx) => {
-                frame.modules.push(ModuleDef::Static(*idx));
+            ModuleStatic(idx, ty) => {
+                frame.modules.push(ModuleDef::Static(*idx, *ty));
             }
 
             // Instantiation of a module is one of the meatier initializers that
@@ -694,7 +685,7 @@ impl<'a> Inliner<'a> {
             ModuleInstantiate(module, args) => {
                 let instance_module;
                 let init = match &frame.modules[*module] {
-                    ModuleDef::Static(idx) => {
+                    ModuleDef::Static(idx, _ty) => {
                         let mut defs = Vec::new();
                         for (module, name, _ty) in self.nested_modules[*idx].module.imports() {
                             let instance = args[module];
@@ -788,14 +779,16 @@ impl<'a> Inliner<'a> {
                 return Ok(Some(frame));
             }
 
-            ComponentSynthetic(map) => {
+            ComponentSynthetic(map, ty) => {
                 let items = map
                     .iter()
                     .map(|(name, index)| Ok((*name, frame.item(*index, types)?)))
                     .collect::<Result<_>>()?;
+                let types_ref = frame.translation.types_ref();
+                let ty = types.convert_instance(types_ref, *ty)?;
                 frame
                     .component_instances
-                    .push(ComponentInstanceDef::Items(items));
+                    .push(ComponentInstanceDef::Items(items, ty));
             }
 
             // Core wasm aliases, this and the cases below, are creating
@@ -851,7 +844,7 @@ impl<'a> Inliner<'a> {
                     // through instantiation of a component or through a
                     // synthetic renaming of items we just schlep around the
                     // definitions of various items here.
-                    ComponentInstanceDef::Items(map) => frame.push_item(map[*name].clone()),
+                    ComponentInstanceDef::Items(map, _) => frame.push_item(map[*name].clone()),
                 }
             }
 
@@ -930,7 +923,7 @@ impl<'a> Inliner<'a> {
             // time here.
             ModuleInstanceDef::Instantiated(instance, module) => {
                 let item = match frame.modules[*module] {
-                    ModuleDef::Static(idx) => {
+                    ModuleDef::Static(idx, _ty) => {
                         let entity = self.nested_modules[idx].module.exports[name];
                         ExportItem::Index(entity)
                     }
@@ -979,7 +972,7 @@ impl<'a> Inliner<'a> {
                 },
                 InstanceModule::Import(ty) => match &memory.item {
                     ExportItem::Name(name) => match types[*ty].exports[name] {
-                        EntityType::Memory(m) => m.memory64,
+                        wasmtime_types::EntityType::Memory(m) => m.memory64,
                         _ => unreachable!(),
                     },
                     ExportItem::Index(_) => unreachable!(),
@@ -1033,8 +1026,11 @@ impl<'a> Inliner<'a> {
             // then an initializer is recorded about where the module comes
             // from.
             ComponentItemDef::Module(module) => match module {
-                ModuleDef::Static(idx) => dfg::Export::ModuleStatic(idx),
-                ModuleDef::Import(path, _) => dfg::Export::ModuleImport(self.runtime_import(&path)),
+                ModuleDef::Static(index, ty) => dfg::Export::ModuleStatic { ty, index },
+                ModuleDef::Import(path, ty) => dfg::Export::ModuleImport {
+                    ty,
+                    import: self.runtime_import(&path),
+                },
             },
 
             ComponentItemDef::Func(func) => match func {
@@ -1056,7 +1052,7 @@ impl<'a> Inliner<'a> {
             },
 
             ComponentItemDef::Instance(instance) => {
-                let mut result = IndexMap::new();
+                let mut exports = IndexMap::new();
                 match instance {
                     // If this instance is one that was originally imported by
                     // the component itself then the imports are translated here
@@ -1069,20 +1065,21 @@ impl<'a> Inliner<'a> {
                         for (name, ty) in types[ty].exports.iter() {
                             let path = path.push(name);
                             let def = ComponentItemDef::from_import(path, *ty)?;
-                            self.record_export(name, def, types, &mut result)?;
+                            self.record_export(name, def, types, &mut exports)?;
                         }
+                        dfg::Export::Instance { ty, exports }
                     }
 
                     // An exported instance which is itself a bag of items is
-                    // translated recursively here to our `result` map which is
+                    // translated recursively here to our `exports` map which is
                     // the bag of items we're exporting.
-                    ComponentInstanceDef::Items(map) => {
+                    ComponentInstanceDef::Items(map, ty) => {
                         for (name, def) in map {
-                            self.record_export(name, def, types, &mut result)?;
+                            self.record_export(name, def, types, &mut exports)?;
                         }
+                        dfg::Export::Instance { ty, exports }
                     }
                 }
-                dfg::Export::Instance(result)
             }
 
             // FIXME(#4283) should make an official decision on whether this is
@@ -1105,7 +1102,7 @@ impl<'a> InlinerFrame<'a> {
         translation: &'a Translation<'a>,
         closure: ComponentClosure<'a>,
         args: HashMap<&'a str, ComponentItemDef<'a>>,
-        instance_ty: Option<TypeId>,
+        instance_ty: Option<ComponentInstanceTypeId>,
     ) -> Self {
         // FIXME: should iterate over the initializers of `translation` and
         // calculate the size of each index space to use `with_capacity` for
@@ -1228,20 +1225,29 @@ impl<'a> InlinerFrame<'a> {
     /// and which component instantiated it.
     fn finish_instantiate(
         &mut self,
-        def: ComponentInstanceDef<'a>,
-        ty: TypeId,
+        exports: IndexMap<&'a str, ComponentItemDef<'a>>,
+        ty: ComponentInstanceTypeId,
         types: &mut ComponentTypesBuilder,
-    ) {
-        let (resources, types) = types.resources_mut_and_types();
-        let mut path = Vec::new();
+    ) -> Result<()> {
+        let types_ref = self.translation.types_ref();
+        {
+            let (resources, types) = types.resources_mut_and_types();
+            let mut path = Vec::new();
+            resources.register_component_entity_type(
+                &types_ref,
+                ComponentEntityType::Instance(ty),
+                &mut path,
+                &mut |path| match path {
+                    [] => unreachable!(),
+                    [name, rest @ ..] => exports[name].lookup_resource(rest, types),
+                },
+            );
+        }
+        let ty = types.convert_instance(types_ref, ty)?;
+        let def = ComponentInstanceDef::Items(exports, ty);
         let arg = ComponentItemDef::Instance(def);
-        resources.register_component_entity_type(
-            &self.translation.types_ref(),
-            wasmparser::types::ComponentEntityType::Instance(ty),
-            &mut path,
-            &mut |path| arg.lookup_resource(path, types),
-        );
         self.push_item(arg);
+        Ok(())
     }
 }
 
@@ -1272,7 +1278,7 @@ impl<'a> ComponentItemDef<'a> {
             // should be treated.
             TypeDef::Component(_ty) => bail!("root-level component imports are not supported"),
             TypeDef::Interface(_) | TypeDef::Resource(_) => ComponentItemDef::Type(ty),
-            TypeDef::CoreFunc(_ty) => unreachable!(),
+            TypeDef::CoreFunc(_) => unreachable!(),
         };
         Ok(item)
     }
@@ -1297,7 +1303,7 @@ impl<'a> ComponentItemDef<'a> {
             cur = match instance {
                 // If this instance is a "bag of things" then this is as easy as
                 // looking up the name in the bag of names.
-                ComponentInstanceDef::Items(names) => names[element].clone(),
+                ComponentInstanceDef::Items(names, _) => names[element].clone(),
 
                 // If, however, this instance is an imported instance then this
                 // is a further projection within the import with one more path
diff --git a/crates/environ/src/component/types.rs b/crates/environ/src/component/types.rs
index db751bc2ef07..5e70bd6bec48 100644
--- a/crates/environ/src/component/types.rs
+++ b/crates/environ/src/component/types.rs
@@ -1,33 +1,15 @@
 use crate::component::{MAX_FLAT_PARAMS, MAX_FLAT_RESULTS};
-use crate::{
-    EntityType, ModuleTypes, ModuleTypesBuilder, PrimaryMap, SignatureIndex, TypeConvert,
-    WasmHeapType, WasmType,
-};
-use anyhow::{bail, Result};
-use cranelift_entity::EntityRef;
-use indexmap::{IndexMap, IndexSet};
+use crate::prelude::*;
+use crate::{EntityType, ModuleTypes, PrimaryMap};
+use core::hash::{Hash, Hasher};
+use core::ops::Index;
 use serde_derive::{Deserialize, Serialize};
-use std::collections::HashMap;
-use std::hash::Hash;
-use std::ops::Index;
-use wasmparser::names::KebabString;
 use wasmparser::types;
 use wasmtime_component_util::{DiscriminantSize, FlagsSize};
+use wasmtime_types::ModuleInternedTypeIndex;
 
 pub use wasmtime_types::StaticModuleIndex;
 
-mod resources;
-pub use resources::ResourcesBuilder;
-
-/// Maximum nesting depth of a type allowed in Wasmtime.
-///
-/// This constant isn't chosen via any scientific means and its main purpose is
-/// to enable most of Wasmtime to handle types via recursion without worrying
-/// about stack overflow.
-///
-/// Some more information about this can be found in #4814
-const MAX_TYPE_DEPTH: u32 = 100;
-
 macro_rules! indices {
     ($(
         $(#[$a:meta])*
@@ -215,11 +197,14 @@ indices! {
     /// component and is stored in the final compilation artifact. This does not
     /// have a direct corresponance to any wasm definition.
     pub struct TrampolineIndex(u32);
+
+    /// An index into `Component::export_items` at the end of compilation.
+    pub struct ExportIndex(u32);
 }
 
 // Reexport for convenience some core-wasm indices which are also used in the
 // component model, typically for when aliasing exports of core wasm modules.
-pub use crate::{FuncIndex, GlobalIndex, MemoryIndex, TableIndex, TypeIndex};
+pub use crate::{FuncIndex, GlobalIndex, MemoryIndex, TableIndex};
 
 /// Equivalent of `EntityIndex` but for the component model instead of core
 /// wasm.
@@ -230,7 +215,7 @@ pub enum ComponentItem {
     Module(ModuleIndex),
     Component(ComponentIndex),
     ComponentInstance(ComponentInstanceIndex),
-    Type(wasmparser::types::TypeId),
+    Type(types::ComponentAnyTypeId),
 }
 
 /// Runtime information about the type information contained within a component.
@@ -240,27 +225,27 @@ pub enum ComponentItem {
 /// will have a pointer to this value as well.
 #[derive(Default, Serialize, Deserialize)]
 pub struct ComponentTypes {
-    modules: PrimaryMap<TypeModuleIndex, TypeModule>,
-    components: PrimaryMap<TypeComponentIndex, TypeComponent>,
-    component_instances: PrimaryMap<TypeComponentInstanceIndex, TypeComponentInstance>,
-    functions: PrimaryMap<TypeFuncIndex, TypeFunc>,
-    lists: PrimaryMap<TypeListIndex, TypeList>,
-    records: PrimaryMap<TypeRecordIndex, TypeRecord>,
-    variants: PrimaryMap<TypeVariantIndex, TypeVariant>,
-    tuples: PrimaryMap<TypeTupleIndex, TypeTuple>,
-    enums: PrimaryMap<TypeEnumIndex, TypeEnum>,
-    flags: PrimaryMap<TypeFlagsIndex, TypeFlags>,
-    options: PrimaryMap<TypeOptionIndex, TypeOption>,
-    results: PrimaryMap<TypeResultIndex, TypeResult>,
-    resource_tables: PrimaryMap<TypeResourceTableIndex, TypeResourceTable>,
-
-    module_types: ModuleTypes,
+    pub(super) modules: PrimaryMap<TypeModuleIndex, TypeModule>,
+    pub(super) components: PrimaryMap<TypeComponentIndex, TypeComponent>,
+    pub(super) component_instances: PrimaryMap<TypeComponentInstanceIndex, TypeComponentInstance>,
+    pub(super) functions: PrimaryMap<TypeFuncIndex, TypeFunc>,
+    pub(super) lists: PrimaryMap<TypeListIndex, TypeList>,
+    pub(super) records: PrimaryMap<TypeRecordIndex, TypeRecord>,
+    pub(super) variants: PrimaryMap<TypeVariantIndex, TypeVariant>,
+    pub(super) tuples: PrimaryMap<TypeTupleIndex, TypeTuple>,
+    pub(super) enums: PrimaryMap<TypeEnumIndex, TypeEnum>,
+    pub(super) flags: PrimaryMap<TypeFlagsIndex, TypeFlags>,
+    pub(super) options: PrimaryMap<TypeOptionIndex, TypeOption>,
+    pub(super) results: PrimaryMap<TypeResultIndex, TypeResult>,
+    pub(super) resource_tables: PrimaryMap<TypeResourceTableIndex, TypeResourceTable>,
+
+    pub(super) module_types: Option<ModuleTypes>,
 }
 
 impl ComponentTypes {
     /// Returns the core wasm module types known within this component.
     pub fn module_types(&self) -> &ModuleTypes {
-        &self.module_types
+        self.module_types.as_ref().unwrap()
     }
 
     /// Returns the canonical ABI information about the specified type.
@@ -295,35 +280,30 @@ impl ComponentTypes {
         }
     }
 
-    /// Smaller helper method to find a `SignatureIndex` which corresponds to
-    /// the `resource.drop` intrinsic in components, namely a core wasm function
-    /// type which takes one `i32` argument and has no results.
-    ///
-    /// This is a bit of a hack right now as ideally this find operation
-    /// wouldn't be needed and instead the `SignatureIndex` itself would be
-    /// threaded through appropriately, but that's left for a future
-    /// refactoring. Try not to lean too hard on this method though.
-    pub fn find_resource_drop_signature(&self) -> Option<SignatureIndex> {
-        self.module_types
-            .wasm_signatures()
-            .find(|(_, sig)| {
-                sig.params().len() == 1
-                    && sig.returns().len() == 0
-                    && sig.params()[0] == WasmType::I32
-            })
-            .map(|(i, _)| i)
+    /// Adds a new `table` to the list of resource tables for this component.
+    pub fn push_resource_table(&mut self, table: TypeResourceTable) -> TypeResourceTableIndex {
+        self.resource_tables.push(table)
     }
 }
 
 macro_rules! impl_index {
     ($(impl Index<$ty:ident> for ComponentTypes { $output:ident => $field:ident })*) => ($(
-        impl std::ops::Index<$ty> for ComponentTypes {
+        impl core::ops::Index<$ty> for ComponentTypes {
             type Output = $output;
             #[inline]
             fn index(&self, idx: $ty) -> &$output {
                 &self.$field[idx]
             }
         }
+
+        #[cfg(feature = "compile")]
+        impl core::ops::Index<$ty> for super::ComponentTypesBuilder {
+            type Output = $output;
+            #[inline]
+            fn index(&self, idx: $ty) -> &$output {
+                &self.component_types()[idx]
+            }
+        }
     )*)
 }
 
@@ -351,579 +331,10 @@ where
 {
     type Output = <ModuleTypes as Index<T>>::Output;
     fn index(&self, idx: T) -> &Self::Output {
-        self.module_types.index(idx)
+        self.module_types.as_ref().unwrap().index(idx)
     }
 }
 
-/// Structured used to build a [`ComponentTypes`] during translation.
-///
-/// This contains tables to intern any component types found as well as
-/// managing building up core wasm [`ModuleTypes`] as well.
-#[derive(Default)]
-pub struct ComponentTypesBuilder {
-    functions: HashMap<TypeFunc, TypeFuncIndex>,
-    lists: HashMap<TypeList, TypeListIndex>,
-    records: HashMap<TypeRecord, TypeRecordIndex>,
-    variants: HashMap<TypeVariant, TypeVariantIndex>,
-    tuples: HashMap<TypeTuple, TypeTupleIndex>,
-    enums: HashMap<TypeEnum, TypeEnumIndex>,
-    flags: HashMap<TypeFlags, TypeFlagsIndex>,
-    options: HashMap<TypeOption, TypeOptionIndex>,
-    results: HashMap<TypeResult, TypeResultIndex>,
-
-    component_types: ComponentTypes,
-    module_types: ModuleTypesBuilder,
-
-    // Cache of what the "flat" representation of all types are which is only
-    // used at compile-time and not used at runtime, hence the location here
-    // as opposed to `ComponentTypes`.
-    type_info: TypeInformationCache,
-
-    resources: ResourcesBuilder,
-}
-
-macro_rules! intern_and_fill_flat_types {
-    ($me:ident, $name:ident, $val:ident) => {{
-        if let Some(idx) = $me.$name.get(&$val) {
-            return *idx;
-        }
-        let idx = $me.component_types.$name.push($val.clone());
-        let mut info = TypeInformation::new();
-        info.$name($me, &$val);
-        let idx2 = $me.type_info.$name.push(info);
-        assert_eq!(idx, idx2);
-        $me.$name.insert($val, idx);
-        return idx;
-    }};
-}
-
-impl ComponentTypesBuilder {
-    /// Finishes this list of component types and returns the finished
-    /// structure.
-    pub fn finish(mut self) -> ComponentTypes {
-        self.component_types.module_types = self.module_types.finish();
-        self.component_types
-    }
-
-    /// Returns the `ComponentTypes`-in-progress.
-    pub fn component_types(&self) -> &ComponentTypes {
-        &self.component_types
-    }
-
-    /// Returns the underlying builder used to build up core wasm module types.
-    ///
-    /// Note that this is shared across all modules found within a component to
-    /// improve the wins from deduplicating function signatures.
-    pub fn module_types_builder(&mut self) -> &mut ModuleTypesBuilder {
-        &mut self.module_types
-    }
-
-    /// Returns the number of resource tables allocated so far, or the maximum
-    /// `TypeResourceTableIndex`.
-    pub fn num_resource_tables(&self) -> usize {
-        self.component_types.resource_tables.len()
-    }
-
-    /// Returns a mutable reference to the underlying `ResourcesBuilder`.
-    pub fn resources_mut(&mut self) -> &mut ResourcesBuilder {
-        &mut self.resources
-    }
-
-    /// Work around the borrow checker to borrow two sub-fields simultaneously
-    /// externally.
-    pub fn resources_mut_and_types(&mut self) -> (&mut ResourcesBuilder, &ComponentTypes) {
-        (&mut self.resources, &self.component_types)
-    }
-
-    /// Converts a wasmparser `ComponentFuncType` into Wasmtime's type
-    /// representation.
-    pub fn convert_component_func_type(
-        &mut self,
-        types: types::TypesRef<'_>,
-        id: types::TypeId,
-    ) -> Result<TypeFuncIndex> {
-        let ty = types[id].unwrap_component_func();
-        let params = ty
-            .params
-            .iter()
-            .map(|(_name, ty)| self.valtype(types, ty))
-            .collect::<Result<_>>()?;
-        let results = ty
-            .results
-            .iter()
-            .map(|(_name, ty)| self.valtype(types, ty))
-            .collect::<Result<_>>()?;
-        let ty = TypeFunc {
-            params: self.new_tuple_type(params),
-            results: self.new_tuple_type(results),
-        };
-        Ok(self.add_func_type(ty))
-    }
-
-    /// Converts a wasmparser `ComponentEntityType` into Wasmtime's type
-    /// representation.
-    pub fn convert_component_entity_type(
-        &mut self,
-        types: types::TypesRef<'_>,
-        ty: types::ComponentEntityType,
-    ) -> Result<TypeDef> {
-        Ok(match ty {
-            types::ComponentEntityType::Module(id) => {
-                TypeDef::Module(self.convert_module(types, id)?)
-            }
-            types::ComponentEntityType::Component(id) => {
-                TypeDef::Component(self.convert_component(types, id)?)
-            }
-            types::ComponentEntityType::Instance(id) => {
-                TypeDef::ComponentInstance(self.convert_instance(types, id)?)
-            }
-            types::ComponentEntityType::Func(id) => {
-                TypeDef::ComponentFunc(self.convert_component_func_type(types, id)?)
-            }
-            types::ComponentEntityType::Type { created, .. } => match types[created] {
-                types::Type::Defined(_) => TypeDef::Interface(self.defined_type(types, created)?),
-                types::Type::Resource(_) => TypeDef::Resource(self.resource_id(types, created)),
-                _ => bail!("unsupported type export"),
-            },
-            types::ComponentEntityType::Value(_) => bail!("values not supported"),
-        })
-    }
-
-    /// Converts a wasmparser `Type` into Wasmtime's type representation.
-    pub fn convert_type(
-        &mut self,
-        types: types::TypesRef<'_>,
-        id: types::TypeId,
-    ) -> Result<TypeDef> {
-        Ok(match &types[id] {
-            types::Type::Defined(_) => TypeDef::Interface(self.defined_type(types, id)?),
-            types::Type::Module(_) => TypeDef::Module(self.convert_module(types, id)?),
-            types::Type::Component(_) => TypeDef::Component(self.convert_component(types, id)?),
-            types::Type::ComponentInstance(_) => {
-                TypeDef::ComponentInstance(self.convert_instance(types, id)?)
-            }
-            types::Type::ComponentFunc(_) => {
-                TypeDef::ComponentFunc(self.convert_component_func_type(types, id)?)
-            }
-            types::Type::Instance(_) | types::Type::Sub(_) => {
-                unreachable!()
-            }
-            types::Type::Resource(_) => TypeDef::Resource(self.resource_id(types, id)),
-        })
-    }
-
-    fn convert_component(
-        &mut self,
-        types: types::TypesRef<'_>,
-        id: types::TypeId,
-    ) -> Result<TypeComponentIndex> {
-        let ty = types[id].unwrap_component();
-        let mut result = TypeComponent::default();
-        for (name, ty) in ty.imports.iter() {
-            result.imports.insert(
-                name.clone(),
-                self.convert_component_entity_type(types, *ty)?,
-            );
-        }
-        for (name, ty) in ty.exports.iter() {
-            result.exports.insert(
-                name.clone(),
-                self.convert_component_entity_type(types, *ty)?,
-            );
-        }
-        Ok(self.component_types.components.push(result))
-    }
-
-    fn convert_instance(
-        &mut self,
-        types: types::TypesRef<'_>,
-        id: types::TypeId,
-    ) -> Result<TypeComponentInstanceIndex> {
-        let ty = types[id].unwrap_component_instance();
-        let mut result = TypeComponentInstance::default();
-        for (name, ty) in ty.exports.iter() {
-            result.exports.insert(
-                name.clone(),
-                self.convert_component_entity_type(types, *ty)?,
-            );
-        }
-        Ok(self.component_types.component_instances.push(result))
-    }
-
-    fn convert_module(
-        &mut self,
-        types: types::TypesRef<'_>,
-        id: types::TypeId,
-    ) -> Result<TypeModuleIndex> {
-        let ty = &types[id].unwrap_module();
-        let mut result = TypeModule::default();
-        for ((module, field), ty) in ty.imports.iter() {
-            result.imports.insert(
-                (module.clone(), field.clone()),
-                self.entity_type(types, ty)?,
-            );
-        }
-        for (name, ty) in ty.exports.iter() {
-            result
-                .exports
-                .insert(name.clone(), self.entity_type(types, ty)?);
-        }
-        Ok(self.component_types.modules.push(result))
-    }
-
-    fn entity_type(
-        &mut self,
-        types: types::TypesRef<'_>,
-        ty: &types::EntityType,
-    ) -> Result<EntityType> {
-        Ok(match ty {
-            types::EntityType::Func(idx) => {
-                let ty = types[*idx].unwrap_func();
-                let ty = self.convert_func_type(ty);
-                EntityType::Function(self.module_types_builder().wasm_func_type(ty))
-            }
-            types::EntityType::Table(ty) => EntityType::Table(self.convert_table_type(ty)),
-            types::EntityType::Memory(ty) => EntityType::Memory(ty.clone().into()),
-            types::EntityType::Global(ty) => EntityType::Global(self.convert_global_type(ty)),
-            types::EntityType::Tag(_) => bail!("exceptions proposal not implemented"),
-        })
-    }
-
-    fn defined_type(
-        &mut self,
-        types: types::TypesRef<'_>,
-        id: types::TypeId,
-    ) -> Result<InterfaceType> {
-        let ret = match types[id].unwrap_defined() {
-            types::ComponentDefinedType::Primitive(ty) => ty.into(),
-            types::ComponentDefinedType::Record(e) => {
-                InterfaceType::Record(self.record_type(types, e)?)
-            }
-            types::ComponentDefinedType::Variant(e) => {
-                InterfaceType::Variant(self.variant_type(types, e)?)
-            }
-            types::ComponentDefinedType::List(e) => InterfaceType::List(self.list_type(types, e)?),
-            types::ComponentDefinedType::Tuple(e) => {
-                InterfaceType::Tuple(self.tuple_type(types, e)?)
-            }
-            types::ComponentDefinedType::Flags(e) => InterfaceType::Flags(self.flags_type(e)),
-            types::ComponentDefinedType::Enum(e) => InterfaceType::Enum(self.enum_type(e)),
-            types::ComponentDefinedType::Option(e) => {
-                InterfaceType::Option(self.option_type(types, e)?)
-            }
-            types::ComponentDefinedType::Result { ok, err } => {
-                InterfaceType::Result(self.result_type(types, ok, err)?)
-            }
-            types::ComponentDefinedType::Own(r) => InterfaceType::Own(self.resource_id(types, *r)),
-            types::ComponentDefinedType::Borrow(r) => {
-                InterfaceType::Borrow(self.resource_id(types, *r))
-            }
-        };
-        let info = self.type_information(&ret);
-        if info.depth > MAX_TYPE_DEPTH {
-            bail!("type nesting is too deep");
-        }
-        Ok(ret)
-    }
-
-    fn valtype(
-        &mut self,
-        types: types::TypesRef<'_>,
-        ty: &types::ComponentValType,
-    ) -> Result<InterfaceType> {
-        match ty {
-            types::ComponentValType::Primitive(p) => Ok(p.into()),
-            types::ComponentValType::Type(id) => self.defined_type(types, *id),
-        }
-    }
-
-    fn record_type(
-        &mut self,
-        types: types::TypesRef<'_>,
-        ty: &types::RecordType,
-    ) -> Result<TypeRecordIndex> {
-        let fields = ty
-            .fields
-            .iter()
-            .map(|(name, ty)| {
-                Ok(RecordField {
-                    name: name.to_string(),
-                    ty: self.valtype(types, ty)?,
-                })
-            })
-            .collect::<Result<Box<[_]>>>()?;
-        let abi = CanonicalAbiInfo::record(
-            fields
-                .iter()
-                .map(|field| self.component_types.canonical_abi(&field.ty)),
-        );
-        Ok(self.add_record_type(TypeRecord { fields, abi }))
-    }
-
-    fn variant_type(
-        &mut self,
-        types: types::TypesRef<'_>,
-        ty: &types::VariantType,
-    ) -> Result<TypeVariantIndex> {
-        let cases = ty
-            .cases
-            .iter()
-            .map(|(name, case)| {
-                // FIXME: need to implement `refines`, not sure what that
-                // is at this time.
-                if case.refines.is_some() {
-                    bail!("refines is not supported at this time");
-                }
-                Ok(VariantCase {
-                    name: name.to_string(),
-                    ty: match &case.ty.as_ref() {
-                        Some(ty) => Some(self.valtype(types, ty)?),
-                        None => None,
-                    },
-                })
-            })
-            .collect::<Result<Box<[_]>>>()?;
-        let (info, abi) = VariantInfo::new(cases.iter().map(|c| {
-            c.ty.as_ref()
-                .map(|ty| self.component_types.canonical_abi(ty))
-        }));
-        Ok(self.add_variant_type(TypeVariant { cases, abi, info }))
-    }
-
-    fn tuple_type(
-        &mut self,
-        types: types::TypesRef<'_>,
-        ty: &types::TupleType,
-    ) -> Result<TypeTupleIndex> {
-        let types = ty
-            .types
-            .iter()
-            .map(|ty| self.valtype(types, ty))
-            .collect::<Result<Box<[_]>>>()?;
-        Ok(self.new_tuple_type(types))
-    }
-
-    fn new_tuple_type(&mut self, types: Box<[InterfaceType]>) -> TypeTupleIndex {
-        let abi = CanonicalAbiInfo::record(
-            types
-                .iter()
-                .map(|ty| self.component_types.canonical_abi(ty)),
-        );
-        self.add_tuple_type(TypeTuple { types, abi })
-    }
-
-    fn flags_type(&mut self, flags: &IndexSet<KebabString>) -> TypeFlagsIndex {
-        let flags = TypeFlags {
-            names: flags.iter().map(|s| s.to_string()).collect(),
-            abi: CanonicalAbiInfo::flags(flags.len()),
-        };
-        self.add_flags_type(flags)
-    }
-
-    fn enum_type(&mut self, variants: &IndexSet<KebabString>) -> TypeEnumIndex {
-        let names = variants.iter().map(|s| s.to_string()).collect::<Box<[_]>>();
-        let (info, abi) = VariantInfo::new(names.iter().map(|_| None));
-        self.add_enum_type(TypeEnum { names, abi, info })
-    }
-
-    fn option_type(
-        &mut self,
-        types: types::TypesRef<'_>,
-        ty: &types::ComponentValType,
-    ) -> Result<TypeOptionIndex> {
-        let ty = self.valtype(types, ty)?;
-        let (info, abi) = VariantInfo::new([None, Some(self.component_types.canonical_abi(&ty))]);
-        Ok(self.add_option_type(TypeOption { ty, abi, info }))
-    }
-
-    fn result_type(
-        &mut self,
-        types: types::TypesRef<'_>,
-        ok: &Option<types::ComponentValType>,
-        err: &Option<types::ComponentValType>,
-    ) -> Result<TypeResultIndex> {
-        let ok = match ok {
-            Some(ty) => Some(self.valtype(types, ty)?),
-            None => None,
-        };
-        let err = match err {
-            Some(ty) => Some(self.valtype(types, ty)?),
-            None => None,
-        };
-        let (info, abi) = VariantInfo::new([
-            ok.as_ref().map(|t| self.component_types.canonical_abi(t)),
-            err.as_ref().map(|t| self.component_types.canonical_abi(t)),
-        ]);
-        Ok(self.add_result_type(TypeResult { ok, err, abi, info }))
-    }
-
-    fn list_type(
-        &mut self,
-        types: types::TypesRef<'_>,
-        ty: &types::ComponentValType,
-    ) -> Result<TypeListIndex> {
-        let element = self.valtype(types, ty)?;
-        Ok(self.add_list_type(TypeList { element }))
-    }
-
-    /// Converts a wasmparser `id`, which must point to a resource, to its
-    /// corresponding `TypeResourceTableIndex`.
-    pub fn resource_id(
-        &mut self,
-        types: types::TypesRef<'_>,
-        id: types::TypeId,
-    ) -> TypeResourceTableIndex {
-        let id = types[id].unwrap_resource();
-        self.resources.convert(id, &mut self.component_types)
-    }
-
-    /// Interns a new function type within this type information.
-    pub fn add_func_type(&mut self, ty: TypeFunc) -> TypeFuncIndex {
-        intern(&mut self.functions, &mut self.component_types.functions, ty)
-    }
-
-    /// Interns a new record type within this type information.
-    pub fn add_record_type(&mut self, ty: TypeRecord) -> TypeRecordIndex {
-        intern_and_fill_flat_types!(self, records, ty)
-    }
-
-    /// Interns a new flags type within this type information.
-    pub fn add_flags_type(&mut self, ty: TypeFlags) -> TypeFlagsIndex {
-        intern_and_fill_flat_types!(self, flags, ty)
-    }
-
-    /// Interns a new tuple type within this type information.
-    pub fn add_tuple_type(&mut self, ty: TypeTuple) -> TypeTupleIndex {
-        intern_and_fill_flat_types!(self, tuples, ty)
-    }
-
-    /// Interns a new variant type within this type information.
-    pub fn add_variant_type(&mut self, ty: TypeVariant) -> TypeVariantIndex {
-        intern_and_fill_flat_types!(self, variants, ty)
-    }
-
-    /// Interns a new enum type within this type information.
-    pub fn add_enum_type(&mut self, ty: TypeEnum) -> TypeEnumIndex {
-        intern_and_fill_flat_types!(self, enums, ty)
-    }
-
-    /// Interns a new option type within this type information.
-    pub fn add_option_type(&mut self, ty: TypeOption) -> TypeOptionIndex {
-        intern_and_fill_flat_types!(self, options, ty)
-    }
-
-    /// Interns a new result type within this type information.
-    pub fn add_result_type(&mut self, ty: TypeResult) -> TypeResultIndex {
-        intern_and_fill_flat_types!(self, results, ty)
-    }
-
-    /// Interns a new type within this type information.
-    pub fn add_list_type(&mut self, ty: TypeList) -> TypeListIndex {
-        intern_and_fill_flat_types!(self, lists, ty)
-    }
-
-    /// Returns the canonical ABI information about the specified type.
-    pub fn canonical_abi(&self, ty: &InterfaceType) -> &CanonicalAbiInfo {
-        self.component_types.canonical_abi(ty)
-    }
-
-    /// Returns the "flat types" for the given interface type used in the
-    /// canonical ABI.
-    ///
-    /// Returns `None` if the type is too large to be represented via flat types
-    /// in the canonical abi.
-    pub fn flat_types(&self, ty: &InterfaceType) -> Option<FlatTypes<'_>> {
-        self.type_information(ty).flat.as_flat_types()
-    }
-
-    /// Returns whether the type specified contains any borrowed resources
-    /// within it.
-    pub fn ty_contains_borrow_resource(&self, ty: &InterfaceType) -> bool {
-        self.type_information(ty).has_borrow
-    }
-
-    fn type_information(&self, ty: &InterfaceType) -> &TypeInformation {
-        match ty {
-            InterfaceType::U8
-            | InterfaceType::S8
-            | InterfaceType::Bool
-            | InterfaceType::U16
-            | InterfaceType::S16
-            | InterfaceType::U32
-            | InterfaceType::S32
-            | InterfaceType::Char
-            | InterfaceType::Own(_) => {
-                static INFO: TypeInformation = TypeInformation::primitive(FlatType::I32);
-                &INFO
-            }
-            InterfaceType::Borrow(_) => {
-                static INFO: TypeInformation = {
-                    let mut info = TypeInformation::primitive(FlatType::I32);
-                    info.has_borrow = true;
-                    info
-                };
-                &INFO
-            }
-            InterfaceType::U64 | InterfaceType::S64 => {
-                static INFO: TypeInformation = TypeInformation::primitive(FlatType::I64);
-                &INFO
-            }
-            InterfaceType::Float32 => {
-                static INFO: TypeInformation = TypeInformation::primitive(FlatType::F32);
-                &INFO
-            }
-            InterfaceType::Float64 => {
-                static INFO: TypeInformation = TypeInformation::primitive(FlatType::F64);
-                &INFO
-            }
-            InterfaceType::String => {
-                static INFO: TypeInformation = TypeInformation::string();
-                &INFO
-            }
-
-            InterfaceType::List(i) => &self.type_info.lists[*i],
-            InterfaceType::Record(i) => &self.type_info.records[*i],
-            InterfaceType::Variant(i) => &self.type_info.variants[*i],
-            InterfaceType::Tuple(i) => &self.type_info.tuples[*i],
-            InterfaceType::Flags(i) => &self.type_info.flags[*i],
-            InterfaceType::Enum(i) => &self.type_info.enums[*i],
-            InterfaceType::Option(i) => &self.type_info.options[*i],
-            InterfaceType::Result(i) => &self.type_info.results[*i],
-        }
-    }
-}
-
-impl TypeConvert for ComponentTypesBuilder {
-    fn lookup_heap_type(&self, _index: TypeIndex) -> WasmHeapType {
-        panic!("heap types are not supported yet")
-    }
-}
-
-// Forward the indexing impl to the internal `TypeTables`
-impl<T> Index<T> for ComponentTypesBuilder
-where
-    ComponentTypes: Index<T>,
-{
-    type Output = <ComponentTypes as Index<T>>::Output;
-
-    fn index(&self, sig: T) -> &Self::Output {
-        &self.component_types[sig]
-    }
-}
-
-fn intern<T, U>(map: &mut HashMap<T, U>, list: &mut PrimaryMap<U, T>, item: T) -> U
-where
-    T: Hash + Clone + Eq,
-    U: Copy + EntityRef,
-{
-    if let Some(idx) = map.get(&item) {
-        return *idx;
-    }
-    let idx = list.push(item.clone());
-    map.insert(item, idx);
-    return idx;
-}
-
 /// Types of imports and exports in the component model.
 ///
 /// These types are what's available for import and export in components. Note
@@ -937,12 +348,12 @@ pub enum TypeDef {
     ComponentInstance(TypeComponentInstanceIndex),
     /// A component function, not to be confused with a core wasm function.
     ComponentFunc(TypeFuncIndex),
-    /// An interface type.
+    /// An type in an interface.
     Interface(InterfaceType),
     /// A core wasm module and its type.
     Module(TypeModuleIndex),
     /// A core wasm function using only core wasm types.
-    CoreFunc(SignatureIndex),
+    CoreFunc(ModuleInternedTypeIndex),
     /// A resource type which operates on the specified resource table.
     ///
     /// Note that different resource tables may point to the same underlying
@@ -950,6 +361,21 @@ pub enum TypeDef {
     Resource(TypeResourceTableIndex),
 }
 
+impl TypeDef {
+    /// A human readable description of what kind of type definition this is.
+    pub fn desc(&self) -> &str {
+        match self {
+            TypeDef::Component(_) => "component",
+            TypeDef::ComponentInstance(_) => "instance",
+            TypeDef::ComponentFunc(_) => "function",
+            TypeDef::Interface(_) => "type",
+            TypeDef::Module(_) => "core module",
+            TypeDef::CoreFunc(_) => "core function",
+            TypeDef::Resource(_) => "resource",
+        }
+    }
+}
+
 // NB: Note that maps below are stored as an `IndexMap` now but the order
 // typically does not matter. As a minor implementation detail we want the
 // serialization of this type to always be deterministic and using `IndexMap`
@@ -1051,8 +477,8 @@ impl From<&wasmparser::PrimitiveValType> for InterfaceType {
             wasmparser::PrimitiveValType::U32 => InterfaceType::U32,
             wasmparser::PrimitiveValType::S64 => InterfaceType::S64,
             wasmparser::PrimitiveValType::U64 => InterfaceType::U64,
-            wasmparser::PrimitiveValType::Float32 => InterfaceType::Float32,
-            wasmparser::PrimitiveValType::Float64 => InterfaceType::Float64,
+            wasmparser::PrimitiveValType::F32 => InterfaceType::Float32,
+            wasmparser::PrimitiveValType::F64 => InterfaceType::Float64,
             wasmparser::PrimitiveValType::Char => InterfaceType::Char,
             wasmparser::PrimitiveValType::String => InterfaceType::String,
         }
@@ -1309,6 +735,24 @@ impl CanonicalAbiInfo {
         }
     }
 
+    /// Calculates ABI information for an enum with `cases` cases.
+    pub const fn enum_(cases: usize) -> CanonicalAbiInfo {
+        // NB: this is basically a duplicate definition of
+        // `CanonicalAbiInfo::variant`, these should be kept in sync.
+
+        let discrim_size = match DiscriminantSize::from_count(cases) {
+            Some(size) => size.byte_size(),
+            None => unreachable!(),
+        };
+        CanonicalAbiInfo {
+            size32: discrim_size,
+            align32: discrim_size,
+            size64: discrim_size,
+            align64: discrim_size,
+            flat_count: Some(1),
+        }
+    }
+
     /// Returns the flat count of this ABI information so long as the count
     /// doesn't exceed the `max` specified.
     pub fn flat_count(&self, max: usize) -> Option<usize> {
@@ -1419,24 +863,26 @@ pub struct RecordField {
 /// Variants are close to Rust `enum` declarations where a value is one of many
 /// cases and each case has a unique name and an optional payload associated
 /// with it.
-#[derive(Serialize, Deserialize, Clone, Hash, Eq, PartialEq, Debug)]
+#[derive(Serialize, Deserialize, Clone, Eq, PartialEq, Debug)]
 pub struct TypeVariant {
     /// The list of cases that this variant can take.
-    pub cases: Box<[VariantCase]>,
+    pub cases: IndexMap<String, Option<InterfaceType>>,
     /// Byte information about this type in the canonical ABI.
     pub abi: CanonicalAbiInfo,
     /// Byte information about this variant type.
     pub info: VariantInfo,
 }
 
-/// One case of a `variant` type which contains the name of the variant as well
-/// as the payload.
-#[derive(Serialize, Deserialize, Clone, Hash, Eq, PartialEq, Debug)]
-pub struct VariantCase {
-    /// Name of the variant, unique amongst all cases in a variant.
-    pub name: String,
-    /// Optional type associated with this payload.
-    pub ty: Option<InterfaceType>,
+impl Hash for TypeVariant {
+    fn hash<H: Hasher>(&self, h: &mut H) {
+        let TypeVariant { cases, abi, info } = self;
+        cases.len().hash(h);
+        for pair in cases {
+            pair.hash(h);
+        }
+        abi.hash(h);
+        info.hash(h);
+    }
 }
 
 /// Shape of a "tuple" type in interface types.
@@ -1455,29 +901,52 @@ pub struct TypeTuple {
 ///
 /// This can be thought of as a record-of-bools, although the representation is
 /// more efficient as bitflags.
-#[derive(Serialize, Deserialize, Clone, Hash, Eq, PartialEq, Debug)]
+#[derive(Serialize, Deserialize, Clone, Eq, PartialEq, Debug)]
 pub struct TypeFlags {
     /// The names of all flags, all of which are unique.
-    pub names: Box<[String]>,
+    pub names: IndexSet<String>,
     /// Byte information about this type in the canonical ABI.
     pub abi: CanonicalAbiInfo,
 }
 
+impl Hash for TypeFlags {
+    fn hash<H: Hasher>(&self, h: &mut H) {
+        let TypeFlags { names, abi } = self;
+        names.len().hash(h);
+        for name in names {
+            name.hash(h);
+        }
+        abi.hash(h);
+    }
+}
+
 /// Shape of an "enum" type in interface types, not to be confused with a Rust
 /// `enum` type.
 ///
 /// In interface types enums are simply a bag of names, and can be seen as a
 /// variant where all payloads are `Unit`.
-#[derive(Serialize, Deserialize, Clone, Hash, Eq, PartialEq, Debug)]
+#[derive(Serialize, Deserialize, Clone, Eq, PartialEq, Debug)]
 pub struct TypeEnum {
     /// The names of this enum, all of which are unique.
-    pub names: Box<[String]>,
+    pub names: IndexSet<String>,
     /// Byte information about this type in the canonical ABI.
     pub abi: CanonicalAbiInfo,
     /// Byte information about this variant type.
     pub info: VariantInfo,
 }
 
+impl Hash for TypeEnum {
+    fn hash<H: Hasher>(&self, h: &mut H) {
+        let TypeEnum { names, abi, info } = self;
+        names.len().hash(h);
+        for name in names {
+            name.hash(h);
+        }
+        abi.hash(h);
+        info.hash(h);
+    }
+}
+
 /// Shape of an "option" interface type.
 #[derive(Serialize, Deserialize, Clone, Hash, Eq, PartialEq, Debug)]
 pub struct TypeOption {
@@ -1522,7 +991,8 @@ pub struct TypeList {
     pub element: InterfaceType,
 }
 
-const MAX_FLAT_TYPES: usize = if MAX_FLAT_PARAMS > MAX_FLAT_RESULTS {
+/// Maximum number of flat types, for either params or results.
+pub const MAX_FLAT_TYPES: usize = if MAX_FLAT_PARAMS > MAX_FLAT_RESULTS {
     MAX_FLAT_PARAMS
 } else {
     MAX_FLAT_RESULTS
@@ -1577,8 +1047,8 @@ impl FlatTypes<'_> {
 }
 
 // Note that this is intentionally duplicated here to keep the size to 1 byte
-// irregardless to changes in the core wasm type system since this will only
-// ever use integers/floats for the forseeable future.
+// regardless to changes in the core wasm type system since this will only
+// ever use integers/floats for the foreseeable future.
 #[derive(PartialEq, Eq, Copy, Clone)]
 #[allow(missing_docs)]
 pub enum FlatType {
@@ -1587,281 +1057,3 @@ pub enum FlatType {
     F32,
     F64,
 }
-
-struct FlatTypesStorage {
-    // This could be represented as `Vec<FlatType>` but on 64-bit architectures
-    // that's 24 bytes. Otherwise `FlatType` is 1 byte large and
-    // `MAX_FLAT_TYPES` is 16, so it should ideally be more space-efficient to
-    // use a flat array instead of a heap-based vector.
-    memory32: [FlatType; MAX_FLAT_TYPES],
-    memory64: [FlatType; MAX_FLAT_TYPES],
-
-    // Tracks the number of flat types pushed into this storage. If this is
-    // `MAX_FLAT_TYPES + 1` then this storage represents an un-reprsentable
-    // type in flat types.
-    len: u8,
-}
-
-impl FlatTypesStorage {
-    const fn new() -> FlatTypesStorage {
-        FlatTypesStorage {
-            memory32: [FlatType::I32; MAX_FLAT_TYPES],
-            memory64: [FlatType::I32; MAX_FLAT_TYPES],
-            len: 0,
-        }
-    }
-
-    fn as_flat_types(&self) -> Option<FlatTypes<'_>> {
-        let len = usize::from(self.len);
-        if len > MAX_FLAT_TYPES {
-            assert_eq!(len, MAX_FLAT_TYPES + 1);
-            None
-        } else {
-            Some(FlatTypes {
-                memory32: &self.memory32[..len],
-                memory64: &self.memory64[..len],
-            })
-        }
-    }
-
-    /// Pushes a new flat type into this list using `t32` for 32-bit memories
-    /// and `t64` for 64-bit memories.
-    ///
-    /// Returns whether the type was actually pushed or whether this list of
-    /// flat types just exceeded the maximum meaning that it is now
-    /// unrepresentable with a flat list of types.
-    fn push(&mut self, t32: FlatType, t64: FlatType) -> bool {
-        let len = usize::from(self.len);
-        if len < MAX_FLAT_TYPES {
-            self.memory32[len] = t32;
-            self.memory64[len] = t64;
-            self.len += 1;
-            true
-        } else {
-            // If this was the first one to go over then flag the length as
-            // being incompatible with a flat representation.
-            if len == MAX_FLAT_TYPES {
-                self.len += 1;
-            }
-            false
-        }
-    }
-}
-
-impl FlatType {
-    fn join(&mut self, other: FlatType) {
-        if *self == other {
-            return;
-        }
-        *self = match (*self, other) {
-            (FlatType::I32, FlatType::F32) | (FlatType::F32, FlatType::I32) => FlatType::I32,
-            _ => FlatType::I64,
-        };
-    }
-}
-
-#[derive(Default)]
-struct TypeInformationCache {
-    records: PrimaryMap<TypeRecordIndex, TypeInformation>,
-    variants: PrimaryMap<TypeVariantIndex, TypeInformation>,
-    tuples: PrimaryMap<TypeTupleIndex, TypeInformation>,
-    enums: PrimaryMap<TypeEnumIndex, TypeInformation>,
-    flags: PrimaryMap<TypeFlagsIndex, TypeInformation>,
-    options: PrimaryMap<TypeOptionIndex, TypeInformation>,
-    results: PrimaryMap<TypeResultIndex, TypeInformation>,
-    lists: PrimaryMap<TypeListIndex, TypeInformation>,
-}
-
-struct TypeInformation {
-    depth: u32,
-    flat: FlatTypesStorage,
-    has_borrow: bool,
-}
-
-impl TypeInformation {
-    const fn new() -> TypeInformation {
-        TypeInformation {
-            depth: 0,
-            flat: FlatTypesStorage::new(),
-            has_borrow: false,
-        }
-    }
-
-    const fn primitive(flat: FlatType) -> TypeInformation {
-        let mut info = TypeInformation::new();
-        info.depth = 1;
-        info.flat.memory32[0] = flat;
-        info.flat.memory64[0] = flat;
-        info.flat.len = 1;
-        info
-    }
-
-    const fn string() -> TypeInformation {
-        let mut info = TypeInformation::new();
-        info.depth = 1;
-        info.flat.memory32[0] = FlatType::I32;
-        info.flat.memory32[1] = FlatType::I32;
-        info.flat.memory64[0] = FlatType::I64;
-        info.flat.memory64[1] = FlatType::I64;
-        info.flat.len = 2;
-        info
-    }
-
-    /// Builds up all flat types internally using the specified representation
-    /// for all of the component fields of the record.
-    fn build_record<'a>(&mut self, types: impl Iterator<Item = &'a TypeInformation>) {
-        self.depth = 1;
-        for info in types {
-            self.depth = self.depth.max(1 + info.depth);
-            self.has_borrow = self.has_borrow || info.has_borrow;
-            match info.flat.as_flat_types() {
-                Some(types) => {
-                    for (t32, t64) in types.memory32.iter().zip(types.memory64) {
-                        if !self.flat.push(*t32, *t64) {
-                            break;
-                        }
-                    }
-                }
-                None => {
-                    self.flat.len = u8::try_from(MAX_FLAT_TYPES + 1).unwrap();
-                }
-            }
-        }
-    }
-
-    /// Builds up the flat types used to represent a `variant` which notably
-    /// handles "join"ing types together so each case is representable as a
-    /// single flat list of types.
-    ///
-    /// The iterator item is:
-    ///
-    /// * `None` - no payload for this case
-    /// * `Some(None)` - this case has a payload but can't be represented with
-    ///   flat types
-    /// * `Some(Some(types))` - this case has a payload and is represented with
-    ///   the types specified in the flat representation.
-    fn build_variant<'a, I>(&mut self, cases: I)
-    where
-        I: IntoIterator<Item = Option<&'a TypeInformation>>,
-    {
-        let cases = cases.into_iter();
-        self.flat.push(FlatType::I32, FlatType::I32);
-        self.depth = 1;
-
-        for info in cases {
-            let info = match info {
-                Some(info) => info,
-                // If this case doesn't have a payload then it doesn't change
-                // the depth/flat representation
-                None => continue,
-            };
-            self.depth = self.depth.max(1 + info.depth);
-            self.has_borrow = self.has_borrow || info.has_borrow;
-
-            // If this variant is already unrepresentable in a flat
-            // representation then this can be skipped.
-            if usize::from(self.flat.len) > MAX_FLAT_TYPES {
-                continue;
-            }
-
-            let types = match info.flat.as_flat_types() {
-                Some(types) => types,
-                // If this case isn't representable with a flat list of types
-                // then this variant also isn't representable.
-                None => {
-                    self.flat.len = u8::try_from(MAX_FLAT_TYPES + 1).unwrap();
-                    continue;
-                }
-            };
-            // If the case used all of the flat types then the discriminant
-            // added for this variant means that this variant is no longer
-            // representable.
-            if types.memory32.len() >= MAX_FLAT_TYPES {
-                self.flat.len = u8::try_from(MAX_FLAT_TYPES + 1).unwrap();
-                continue;
-            }
-            let dst = self
-                .flat
-                .memory32
-                .iter_mut()
-                .zip(&mut self.flat.memory64)
-                .skip(1);
-            for (i, ((t32, t64), (dst32, dst64))) in types
-                .memory32
-                .iter()
-                .zip(types.memory64)
-                .zip(dst)
-                .enumerate()
-            {
-                if i + 1 < usize::from(self.flat.len) {
-                    // If this index hs already been set by some previous case
-                    // then the types are joined together.
-                    dst32.join(*t32);
-                    dst64.join(*t64);
-                } else {
-                    // Otherwise if this is the first time that the
-                    // representation has gotten this large then the destination
-                    // is simply whatever the type is. The length is also
-                    // increased here to indicate this.
-                    self.flat.len += 1;
-                    *dst32 = *t32;
-                    *dst64 = *t64;
-                }
-            }
-        }
-    }
-
-    fn records(&mut self, types: &ComponentTypesBuilder, ty: &TypeRecord) {
-        self.build_record(ty.fields.iter().map(|f| types.type_information(&f.ty)));
-    }
-
-    fn tuples(&mut self, types: &ComponentTypesBuilder, ty: &TypeTuple) {
-        self.build_record(ty.types.iter().map(|t| types.type_information(t)));
-    }
-
-    fn enums(&mut self, _types: &ComponentTypesBuilder, _ty: &TypeEnum) {
-        self.depth = 1;
-        self.flat.push(FlatType::I32, FlatType::I32);
-    }
-
-    fn flags(&mut self, _types: &ComponentTypesBuilder, ty: &TypeFlags) {
-        self.depth = 1;
-        match FlagsSize::from_count(ty.names.len()) {
-            FlagsSize::Size0 => {}
-            FlagsSize::Size1 | FlagsSize::Size2 => {
-                self.flat.push(FlatType::I32, FlatType::I32);
-            }
-            FlagsSize::Size4Plus(n) => {
-                for _ in 0..n {
-                    self.flat.push(FlatType::I32, FlatType::I32);
-                }
-            }
-        }
-    }
-
-    fn variants(&mut self, types: &ComponentTypesBuilder, ty: &TypeVariant) {
-        self.build_variant(
-            ty.cases
-                .iter()
-                .map(|c| c.ty.as_ref().map(|ty| types.type_information(ty))),
-        )
-    }
-
-    fn results(&mut self, types: &ComponentTypesBuilder, ty: &TypeResult) {
-        self.build_variant([
-            ty.ok.as_ref().map(|ty| types.type_information(ty)),
-            ty.err.as_ref().map(|ty| types.type_information(ty)),
-        ])
-    }
-
-    fn options(&mut self, types: &ComponentTypesBuilder, ty: &TypeOption) {
-        self.build_variant([None, Some(types.type_information(&ty.ty))]);
-    }
-
-    fn lists(&mut self, types: &ComponentTypesBuilder, ty: &TypeList) {
-        *self = TypeInformation::string();
-        let info = types.type_information(&ty.element);
-        self.depth += info.depth;
-        self.has_borrow = info.has_borrow;
-    }
-}
diff --git a/crates/environ/src/component/types/resources.rs b/crates/environ/src/component/types/resources.rs
deleted file mode 100644
index 22a99d62fa8c..000000000000
--- a/crates/environ/src/component/types/resources.rs
+++ /dev/null
@@ -1,240 +0,0 @@
-//! Implementation of resource type information within Wasmtime.
-//!
-//! Resource types are one of the trickier parts of the component model. Types
-//! such as `list`, `record`, and `string` are considered "structural" where two
-//! types are considered equal if their components are equal. For example `(list
-//! $a)` and `(list $b)` are the same if `$a` and `$b` are the same. Resources,
-//! however, are not as simple.
-//!
-//! The type of a resource can "change" sort of depending on who you are and how
-//! you view it. Some examples of resources are:
-//!
-//! * When a resource is imported into a component the internal component
-//!   doesn't know the underlying resource type, but the outer component which
-//!   performed an instantiation knows that. This means that if a component
-//!   imports two unique resources but is instantiated with two copies of the
-//!   same resource the internal component can't know they're the same but the
-//!   outer component knows they're the same.
-//!
-//! * Each instantiation of a component produces new resource types. This means
-//!   that if a component instantiates a subcomponent twice then the resources
-//!   defined in that subcomponent are considered different between the two
-//!   instances.
-//!
-//! All this is basically to say that resources require special care. The
-//! purpose of resources are to provide isolation across component boundaries
-//! and strict guarantees around ownership and borrowing. Getting the type
-//! information wrong can compromise on all of these guarantees which is
-//! something Wasmtime would ideally avoid.
-//!
-//! ## Interaction with `wasmparser`
-//!
-//! The trickiness of resource types is not unique of Wasmtime and the first
-//! line of translating a component, `wasmparser`, already has quite a lot of
-//! support for handling all the various special cases of resources. Namely
-//! `wasmparser` has a `ResourceId` type which can be used to test whether two
-//! resources are the same or unique. For example in the above scenario where a
-//! component imports two resources then within that component they'll have
-//! unique ids. Externally though the outer component will be able to see that
-//! the ids are the same.
-//!
-//! Given the subtlety here the goal is to lean on `wasmparser` as much as
-//! possible for this information. The thinking is "well it got things right so
-//! let's not duplicate". This is one of the motivations for plumbing
-//! `wasmparser`'s type information throughout `LocalInitializer` structures
-//! during translation of a component. During conversion to a
-//! `GlobalInitializer` is where everything is boiled away.
-//!
-//! ## Converting to Wasmtime
-//!
-//! The purpose of this module then is to convert `wasmparser`'s view of
-//! resources into Wasmtime's view of resources. Wasmtime's goal is to
-//! determine how many tables are required for each resource within a component
-//! and then from then on purely talk about table indices. Each component
-//! instance will require a table per-resource and this figures that all out.
-//!
-//! The conversion process, however, is relatively tightly intertwined with type
-//! conversion in general. The "leaves" of a type may be resources but there are
-//! other structures in a type such as lists, records, variants, etc. This means
-//! that the `ResourcesBuilder` below is embedded within a
-//! `ComponentTypesBuilder`. This also means that it's unfortuantely not easy to
-//! disentangle pieces and have one nice standalone file that handles everything
-//! related to type information about resources. Instead this one file was
-//! chosen as the place for this doc comment but the file itself is deceptively
-//! small as much of the other handling happens elsewhere in component
-//! translation.
-//!
-//! For more details on fiddly bits see the documentation on various fields and
-//! methods below.
-
-use crate::component::{
-    ComponentTypes, ResourceIndex, RuntimeComponentInstanceIndex, TypeResourceTable,
-    TypeResourceTableIndex,
-};
-use std::collections::HashMap;
-use wasmparser::types;
-
-/// Builder state used to translate wasmparser's `ResourceId` types to
-/// Wasmtime's `TypeResourceTableIndex` type.
-///
-/// This is contained in a `ComponentTypesBuilder` but is modified quite a bit
-/// manually via the `inline` phase of component instantiation.
-///
-/// This type crucially implements the `Clone` trait which is used to "snapshot"
-/// the current state of resource translation. The purpose of `Clone` here is to
-/// record translation information just before a subcomponent is instantiated to
-/// restore it after the subcomponent's instantiation has completed. This is
-/// done to handle instantiations of the same component multiple times
-/// correctly.
-///
-/// Wasmparser produces one set of type information for a component, and not a
-/// unique set of type information about its internals for each instantiation.
-/// Each instance which results from instantiation gets a new type, but when
-/// we're translating the instantiation of a component Wasmtime will re-run all
-/// initializers. This means that if naively implemented the `ResourceId`
-/// mapping from the first instantiation will be reused by the second
-/// instantiation. The snapshotting behavior and restoration guarantees that
-/// whenever a subcomponent is visited and instantiated it's guaranteed that
-/// there's no registered information for its `ResourceId` definitions within
-/// this builder.
-///
-/// Note that `ResourceId` references are guaranteed to be "local" in the sense
-/// that if a resource is defined within a component then the ID it's assigned
-/// internally within a component is different than the ID when it's
-/// instantiated (since all instantiations produce new types). This means that
-/// when throwing away state built-up from within a component that's also
-/// reasonable because the information should never be used after a component is
-/// left anyway.
-#[derive(Default, Clone)]
-pub struct ResourcesBuilder {
-    /// A cache of previously visited `ResourceId` items and which table they
-    /// correspond to. This is lazily populated as resources are visited and is
-    /// exclusively used by the `convert` function below.
-    resource_id_to_table_index: HashMap<types::ResourceId, TypeResourceTableIndex>,
-
-    /// A cache of the origin resource type behind a `ResourceId`.
-    ///
-    /// Unlike `resource_id_to_table_index` this is required to be eagerly
-    /// populated before translation of a type occurs. This is populated by
-    /// `register_*` methods below and is manually done during the `inline`
-    /// phase. This is used to record the actual underlying type of a resource
-    /// and where it originally comes from. When a resource is later referred to
-    /// then a table is injected to be referred to.
-    resource_id_to_resource_index: HashMap<types::ResourceId, ResourceIndex>,
-
-    /// The current instance index that's being visited. This is updated as
-    /// inliner frames are processed and components are instantiated.
-    current_instance: Option<RuntimeComponentInstanceIndex>,
-}
-
-impl ResourcesBuilder {
-    /// Converts the `id` provided into a `TypeResourceTableIndex`.
-    ///
-    /// If `id` has previously been seen or converted, the prior value is
-    /// returned. Otherwise the `resource_id_to_resource_index` table must have
-    /// been previously populated and additionally `current_instance` must have
-    /// been previously set. Using these a new `TypeResourceTable` value is
-    /// allocated which produces a fresh `TypeResourceTableIndex` within the
-    /// `types` provided.
-    ///
-    /// Due to `wasmparser`'s uniqueness of resource IDs combined with the
-    /// snapshotting and restoration behavior of `ResourcesBuilder` itself this
-    /// should have the net effect of the first time a resource is seen within
-    /// any component it's assigned a new table, which is exactly what we want.
-    pub fn convert(
-        &mut self,
-        id: types::ResourceId,
-        types: &mut ComponentTypes,
-    ) -> TypeResourceTableIndex {
-        *self
-            .resource_id_to_table_index
-            .entry(id)
-            .or_insert_with(|| {
-                let ty = self.resource_id_to_resource_index[&id];
-                let instance = self.current_instance.expect("current instance not set");
-                types
-                    .resource_tables
-                    .push(TypeResourceTable { ty, instance })
-            })
-    }
-
-    /// Walks over the `ty` provided, as defined within `types`, and registers
-    /// all the defined resources found with the `register` function provided.
-    ///
-    /// This is used to register `ResourceIndex` entries within the
-    /// `resource_id_to_resource_index` table of this type for situations such
-    /// as when a resource is imported into a component. During the inlining
-    /// phase of compilation the actual underlying type of the resource is
-    /// known due to tracking dataflow and this registers that relationship.
-    ///
-    /// The `path` provided is temporary storage to pass to the `register`
-    /// function eventually.
-    ///
-    /// The `register` callback is invoked with `path` with a list of names
-    /// which correspond to exports of instances to reach the "leaf" where a
-    /// resource type is expected.
-    pub fn register_component_entity_type<'a>(
-        &mut self,
-        types: &'a types::TypesRef<'_>,
-        ty: types::ComponentEntityType,
-        path: &mut Vec<&'a str>,
-        register: &mut dyn FnMut(&[&'a str]) -> ResourceIndex,
-    ) {
-        match ty {
-            // If `ty` is itself a type, and that's a resource type, then this
-            // is where registration happens. The `register` callback is invoked
-            // with the current path and that's inserted in to
-            // `resource_id_to_resource_index` if the resource hasn't been seen
-            // yet.
-            types::ComponentEntityType::Type { created, .. } => {
-                let id = match types[created] {
-                    types::Type::Resource(id) => id,
-                    _ => return,
-                };
-                self.resource_id_to_resource_index
-                    .entry(id)
-                    .or_insert_with(|| register(path));
-            }
-
-            // Resources can be imported/defined through exports of instances so
-            // all instance exports are walked here. Note the management of
-            // `path` which is used for the recursive invocation of this method.
-            types::ComponentEntityType::Instance(id) => {
-                let ty = types[id].unwrap_component_instance();
-                for (name, ty) in ty.exports.iter() {
-                    path.push(name);
-                    self.register_component_entity_type(types, *ty, path, register);
-                    path.pop();
-                }
-            }
-
-            // None of these items can introduce a new component type, so
-            // there's no need to recurse over these.
-            types::ComponentEntityType::Func(_)
-            | types::ComponentEntityType::Module(_)
-            | types::ComponentEntityType::Component(_)
-            | types::ComponentEntityType::Value(_) => {}
-        }
-    }
-
-    /// Declares that the wasmparser `id`, which must point to a resource, is
-    /// defined by the `ty` provided.
-    ///
-    /// This is used when a local resource is defined within a component for example.
-    pub fn register_resource(
-        &mut self,
-        types: types::TypesRef<'_>,
-        id: types::TypeId,
-        ty: ResourceIndex,
-    ) {
-        let id = types[id].unwrap_resource();
-        let prev = self.resource_id_to_resource_index.insert(id, ty);
-        assert!(prev.is_none());
-    }
-
-    /// Updates the `current_instance` field to assign instance fields of future
-    /// `TypeResourceTableIndex` values produced via `convert`.
-    pub fn set_current_instance(&mut self, instance: RuntimeComponentInstanceIndex) {
-        self.current_instance = Some(instance);
-    }
-}
diff --git a/crates/environ/src/component/types_builder.rs b/crates/environ/src/component/types_builder.rs
new file mode 100644
index 000000000000..85319865b8bc
--- /dev/null
+++ b/crates/environ/src/component/types_builder.rs
@@ -0,0 +1,976 @@
+use crate::component::*;
+use crate::prelude::*;
+use crate::{
+    EntityType, Module, ModuleTypes, ModuleTypesBuilder, PrimaryMap, TypeConvert, WasmHeapType,
+    WasmValType,
+};
+use anyhow::{bail, Result};
+use cranelift_entity::EntityRef;
+use std::collections::HashMap;
+use std::hash::Hash;
+use std::ops::Index;
+use wasmparser::names::KebabString;
+use wasmparser::{types, Validator};
+use wasmtime_component_util::FlagsSize;
+use wasmtime_types::ModuleInternedTypeIndex;
+
+mod resources;
+pub use resources::ResourcesBuilder;
+
+/// Maximum nesting depth of a type allowed in Wasmtime.
+///
+/// This constant isn't chosen via any scientific means and its main purpose is
+/// to enable most of Wasmtime to handle types via recursion without worrying
+/// about stack overflow.
+///
+/// Some more information about this can be found in #4814
+const MAX_TYPE_DEPTH: u32 = 100;
+
+/// Structured used to build a [`ComponentTypes`] during translation.
+///
+/// This contains tables to intern any component types found as well as
+/// managing building up core wasm [`ModuleTypes`] as well.
+pub struct ComponentTypesBuilder {
+    functions: HashMap<TypeFunc, TypeFuncIndex>,
+    lists: HashMap<TypeList, TypeListIndex>,
+    records: HashMap<TypeRecord, TypeRecordIndex>,
+    variants: HashMap<TypeVariant, TypeVariantIndex>,
+    tuples: HashMap<TypeTuple, TypeTupleIndex>,
+    enums: HashMap<TypeEnum, TypeEnumIndex>,
+    flags: HashMap<TypeFlags, TypeFlagsIndex>,
+    options: HashMap<TypeOption, TypeOptionIndex>,
+    results: HashMap<TypeResult, TypeResultIndex>,
+
+    component_types: ComponentTypes,
+    module_types: ModuleTypesBuilder,
+
+    // Cache of what the "flat" representation of all types are which is only
+    // used at compile-time and not used at runtime, hence the location here
+    // as opposed to `ComponentTypes`.
+    type_info: TypeInformationCache,
+
+    resources: ResourcesBuilder,
+}
+
+impl<T> Index<T> for ComponentTypesBuilder
+where
+    ModuleTypes: Index<T>,
+{
+    type Output = <ModuleTypes as Index<T>>::Output;
+    fn index(&self, idx: T) -> &Self::Output {
+        self.module_types.index(idx)
+    }
+}
+
+macro_rules! intern_and_fill_flat_types {
+    ($me:ident, $name:ident, $val:ident) => {{
+        if let Some(idx) = $me.$name.get(&$val) {
+            return *idx;
+        }
+        let idx = $me.component_types.$name.push($val.clone());
+        let mut info = TypeInformation::new();
+        info.$name($me, &$val);
+        let idx2 = $me.type_info.$name.push(info);
+        assert_eq!(idx, idx2);
+        $me.$name.insert($val, idx);
+        return idx;
+    }};
+}
+
+impl ComponentTypesBuilder {
+    /// Construct a new `ComponentTypesBuilder` for use with the given validator.
+    pub fn new(validator: &Validator) -> Self {
+        Self {
+            module_types: ModuleTypesBuilder::new(validator),
+
+            functions: HashMap::default(),
+            lists: HashMap::default(),
+            records: HashMap::default(),
+            variants: HashMap::default(),
+            tuples: HashMap::default(),
+            enums: HashMap::default(),
+            flags: HashMap::default(),
+            options: HashMap::default(),
+            results: HashMap::default(),
+            component_types: ComponentTypes::default(),
+            type_info: TypeInformationCache::default(),
+            resources: ResourcesBuilder::default(),
+        }
+    }
+
+    fn export_type_def(
+        &mut self,
+        export_items: &PrimaryMap<ExportIndex, Export>,
+        idx: ExportIndex,
+    ) -> TypeDef {
+        match &export_items[idx] {
+            Export::LiftedFunction { ty, .. } => TypeDef::ComponentFunc(*ty),
+            Export::ModuleStatic { ty, .. } | Export::ModuleImport { ty, .. } => {
+                TypeDef::Module(*ty)
+            }
+            Export::Instance { ty, .. } => TypeDef::ComponentInstance(*ty),
+            Export::Type(ty) => *ty,
+        }
+    }
+
+    /// Finishes this list of component types and returns the finished
+    /// structure and the [`TypeComponentIndex`] corresponding to top-level component
+    /// with `imports` and `exports` specified.
+    pub fn finish(mut self, component: &Component) -> (ComponentTypes, TypeComponentIndex) {
+        let mut component_ty = TypeComponent::default();
+        for (_, (name, ty)) in component.import_types.iter() {
+            component_ty.imports.insert(name.clone(), *ty);
+        }
+        for (name, ty) in component.exports.raw_iter() {
+            component_ty.exports.insert(
+                name.clone(),
+                self.export_type_def(&component.export_items, *ty),
+            );
+        }
+        let ty = self.component_types.components.push(component_ty);
+
+        self.component_types.module_types = Some(self.module_types.finish());
+        (self.component_types, ty)
+    }
+
+    /// Smaller helper method to find a `ModuleInternedTypeIndex` which
+    /// corresponds to the `resource.drop` intrinsic in components, namely a
+    /// core wasm function type which takes one `i32` argument and has no
+    /// results.
+    ///
+    /// This is a bit of a hack right now as ideally this find operation
+    /// wouldn't be needed and instead the `ModuleInternedTypeIndex` itself
+    /// would be threaded through appropriately, but that's left for a future
+    /// refactoring. Try not to lean too hard on this method though.
+    pub fn find_resource_drop_signature(&self) -> Option<ModuleInternedTypeIndex> {
+        self.module_types
+            .wasm_types()
+            .find(|(_, ty)| {
+                ty.as_func().map_or(false, |sig| {
+                    sig.params().len() == 1
+                        && sig.returns().len() == 0
+                        && sig.params()[0] == WasmValType::I32
+                })
+            })
+            .map(|(i, _)| i)
+    }
+
+    /// Returns the underlying builder used to build up core wasm module types.
+    ///
+    /// Note that this is shared across all modules found within a component to
+    /// improve the wins from deduplicating function signatures.
+    pub fn module_types_builder(&self) -> &ModuleTypesBuilder {
+        &self.module_types
+    }
+
+    /// Same as `module_types_builder`, but `mut`.
+    pub fn module_types_builder_mut(&mut self) -> &mut ModuleTypesBuilder {
+        &mut self.module_types
+    }
+
+    /// Returns the internal reference to the in-progress `&ComponentTypes`.
+    pub(super) fn component_types(&self) -> &ComponentTypes {
+        &self.component_types
+    }
+
+    /// Returns the number of resource tables allocated so far, or the maximum
+    /// `TypeResourceTableIndex`.
+    pub fn num_resource_tables(&self) -> usize {
+        self.component_types.resource_tables.len()
+    }
+
+    /// Returns a mutable reference to the underlying `ResourcesBuilder`.
+    pub fn resources_mut(&mut self) -> &mut ResourcesBuilder {
+        &mut self.resources
+    }
+
+    /// Work around the borrow checker to borrow two sub-fields simultaneously
+    /// externally.
+    pub fn resources_mut_and_types(&mut self) -> (&mut ResourcesBuilder, &ComponentTypes) {
+        (&mut self.resources, &self.component_types)
+    }
+
+    /// Converts a wasmparser `ComponentFuncType` into Wasmtime's type
+    /// representation.
+    pub fn convert_component_func_type(
+        &mut self,
+        types: types::TypesRef<'_>,
+        id: types::ComponentFuncTypeId,
+    ) -> Result<TypeFuncIndex> {
+        assert_eq!(types.id(), self.module_types.validator_id());
+        let ty = &types[id];
+        let params = ty
+            .params
+            .iter()
+            .map(|(_name, ty)| self.valtype(types, ty))
+            .collect::<Result<_>>()?;
+        let results = ty
+            .results
+            .iter()
+            .map(|(_name, ty)| self.valtype(types, ty))
+            .collect::<Result<_>>()?;
+        let ty = TypeFunc {
+            params: self.new_tuple_type(params),
+            results: self.new_tuple_type(results),
+        };
+        Ok(self.add_func_type(ty))
+    }
+
+    /// Converts a wasmparser `ComponentEntityType` into Wasmtime's type
+    /// representation.
+    pub fn convert_component_entity_type(
+        &mut self,
+        types: types::TypesRef<'_>,
+        ty: types::ComponentEntityType,
+    ) -> Result<TypeDef> {
+        assert_eq!(types.id(), self.module_types.validator_id());
+        Ok(match ty {
+            types::ComponentEntityType::Module(id) => {
+                TypeDef::Module(self.convert_module(types, id)?)
+            }
+            types::ComponentEntityType::Component(id) => {
+                TypeDef::Component(self.convert_component(types, id)?)
+            }
+            types::ComponentEntityType::Instance(id) => {
+                TypeDef::ComponentInstance(self.convert_instance(types, id)?)
+            }
+            types::ComponentEntityType::Func(id) => {
+                TypeDef::ComponentFunc(self.convert_component_func_type(types, id)?)
+            }
+            types::ComponentEntityType::Type { created, .. } => match created {
+                types::ComponentAnyTypeId::Defined(id) => {
+                    TypeDef::Interface(self.defined_type(types, id)?)
+                }
+                types::ComponentAnyTypeId::Resource(id) => {
+                    TypeDef::Resource(self.resource_id(id.resource()))
+                }
+                _ => bail!("unsupported type export"),
+            },
+            types::ComponentEntityType::Value(_) => bail!("values not supported"),
+        })
+    }
+
+    /// Converts a wasmparser `Type` into Wasmtime's type representation.
+    pub fn convert_type(
+        &mut self,
+        types: types::TypesRef<'_>,
+        id: types::ComponentAnyTypeId,
+    ) -> Result<TypeDef> {
+        assert_eq!(types.id(), self.module_types.validator_id());
+        Ok(match id {
+            types::ComponentAnyTypeId::Defined(id) => {
+                TypeDef::Interface(self.defined_type(types, id)?)
+            }
+            types::ComponentAnyTypeId::Component(id) => {
+                TypeDef::Component(self.convert_component(types, id)?)
+            }
+            types::ComponentAnyTypeId::Instance(id) => {
+                TypeDef::ComponentInstance(self.convert_instance(types, id)?)
+            }
+            types::ComponentAnyTypeId::Func(id) => {
+                TypeDef::ComponentFunc(self.convert_component_func_type(types, id)?)
+            }
+            types::ComponentAnyTypeId::Resource(id) => {
+                TypeDef::Resource(self.resource_id(id.resource()))
+            }
+        })
+    }
+
+    fn convert_component(
+        &mut self,
+        types: types::TypesRef<'_>,
+        id: types::ComponentTypeId,
+    ) -> Result<TypeComponentIndex> {
+        assert_eq!(types.id(), self.module_types.validator_id());
+        let ty = &types[id];
+        let mut result = TypeComponent::default();
+        for (name, ty) in ty.imports.iter() {
+            result.imports.insert(
+                name.clone(),
+                self.convert_component_entity_type(types, *ty)?,
+            );
+        }
+        for (name, ty) in ty.exports.iter() {
+            result.exports.insert(
+                name.clone(),
+                self.convert_component_entity_type(types, *ty)?,
+            );
+        }
+        Ok(self.component_types.components.push(result))
+    }
+
+    pub(crate) fn convert_instance(
+        &mut self,
+        types: types::TypesRef<'_>,
+        id: types::ComponentInstanceTypeId,
+    ) -> Result<TypeComponentInstanceIndex> {
+        assert_eq!(types.id(), self.module_types.validator_id());
+        let ty = &types[id];
+        let mut result = TypeComponentInstance::default();
+        for (name, ty) in ty.exports.iter() {
+            result.exports.insert(
+                name.clone(),
+                self.convert_component_entity_type(types, *ty)?,
+            );
+        }
+        Ok(self.component_types.component_instances.push(result))
+    }
+
+    pub(crate) fn convert_module(
+        &mut self,
+        types: types::TypesRef<'_>,
+        id: types::ComponentCoreModuleTypeId,
+    ) -> Result<TypeModuleIndex> {
+        assert_eq!(types.id(), self.module_types.validator_id());
+        let ty = &types[id];
+        let mut result = TypeModule::default();
+        for ((module, field), ty) in ty.imports.iter() {
+            result.imports.insert(
+                (module.clone(), field.clone()),
+                self.entity_type(types, ty)?,
+            );
+        }
+        for (name, ty) in ty.exports.iter() {
+            result
+                .exports
+                .insert(name.clone(), self.entity_type(types, ty)?);
+        }
+        Ok(self.component_types.modules.push(result))
+    }
+
+    fn entity_type(
+        &mut self,
+        types: types::TypesRef<'_>,
+        ty: &types::EntityType,
+    ) -> Result<EntityType> {
+        assert_eq!(types.id(), self.module_types.validator_id());
+        Ok(match ty {
+            types::EntityType::Func(id) => EntityType::Function({
+                let module = Module::default();
+                self.module_types_builder_mut()
+                    .intern_type(&module, types, *id)?
+                    .into()
+            }),
+            types::EntityType::Table(ty) => EntityType::Table(self.convert_table_type(ty)?),
+            types::EntityType::Memory(ty) => EntityType::Memory((*ty).into()),
+            types::EntityType::Global(ty) => EntityType::Global(self.convert_global_type(ty)),
+            types::EntityType::Tag(_) => bail!("exceptions proposal not implemented"),
+        })
+    }
+
+    fn defined_type(
+        &mut self,
+        types: types::TypesRef<'_>,
+        id: types::ComponentDefinedTypeId,
+    ) -> Result<InterfaceType> {
+        assert_eq!(types.id(), self.module_types.validator_id());
+        let ret = match &types[id] {
+            types::ComponentDefinedType::Primitive(ty) => ty.into(),
+            types::ComponentDefinedType::Record(e) => {
+                InterfaceType::Record(self.record_type(types, e)?)
+            }
+            types::ComponentDefinedType::Variant(e) => {
+                InterfaceType::Variant(self.variant_type(types, e)?)
+            }
+            types::ComponentDefinedType::List(e) => InterfaceType::List(self.list_type(types, e)?),
+            types::ComponentDefinedType::Tuple(e) => {
+                InterfaceType::Tuple(self.tuple_type(types, e)?)
+            }
+            types::ComponentDefinedType::Flags(e) => InterfaceType::Flags(self.flags_type(e)),
+            types::ComponentDefinedType::Enum(e) => InterfaceType::Enum(self.enum_type(e)),
+            types::ComponentDefinedType::Option(e) => {
+                InterfaceType::Option(self.option_type(types, e)?)
+            }
+            types::ComponentDefinedType::Result { ok, err } => {
+                InterfaceType::Result(self.result_type(types, ok, err)?)
+            }
+            types::ComponentDefinedType::Own(r) => {
+                InterfaceType::Own(self.resource_id(r.resource()))
+            }
+            types::ComponentDefinedType::Borrow(r) => {
+                InterfaceType::Borrow(self.resource_id(r.resource()))
+            }
+        };
+        let info = self.type_information(&ret);
+        if info.depth > MAX_TYPE_DEPTH {
+            bail!("type nesting is too deep");
+        }
+        Ok(ret)
+    }
+
+    fn valtype(
+        &mut self,
+        types: types::TypesRef<'_>,
+        ty: &types::ComponentValType,
+    ) -> Result<InterfaceType> {
+        assert_eq!(types.id(), self.module_types.validator_id());
+        match ty {
+            types::ComponentValType::Primitive(p) => Ok(p.into()),
+            types::ComponentValType::Type(id) => self.defined_type(types, *id),
+        }
+    }
+
+    fn record_type(
+        &mut self,
+        types: types::TypesRef<'_>,
+        ty: &types::RecordType,
+    ) -> Result<TypeRecordIndex> {
+        assert_eq!(types.id(), self.module_types.validator_id());
+        let fields = ty
+            .fields
+            .iter()
+            .map(|(name, ty)| {
+                Ok(RecordField {
+                    name: name.to_string(),
+                    ty: self.valtype(types, ty)?,
+                })
+            })
+            .collect::<Result<Box<[_]>>>()?;
+        let abi = CanonicalAbiInfo::record(
+            fields
+                .iter()
+                .map(|field| self.component_types.canonical_abi(&field.ty)),
+        );
+        Ok(self.add_record_type(TypeRecord { fields, abi }))
+    }
+
+    fn variant_type(
+        &mut self,
+        types: types::TypesRef<'_>,
+        ty: &types::VariantType,
+    ) -> Result<TypeVariantIndex> {
+        assert_eq!(types.id(), self.module_types.validator_id());
+        let cases = ty
+            .cases
+            .iter()
+            .map(|(name, case)| {
+                // FIXME: need to implement `refines`, not sure what that
+                // is at this time.
+                if case.refines.is_some() {
+                    bail!("refines is not supported at this time");
+                }
+                Ok((
+                    name.to_string(),
+                    match &case.ty.as_ref() {
+                        Some(ty) => Some(self.valtype(types, ty)?),
+                        None => None,
+                    },
+                ))
+            })
+            .collect::<Result<IndexMap<_, _>>>()?;
+        let (info, abi) = VariantInfo::new(
+            cases
+                .iter()
+                .map(|(_, c)| c.as_ref().map(|ty| self.component_types.canonical_abi(ty))),
+        );
+        Ok(self.add_variant_type(TypeVariant { cases, abi, info }))
+    }
+
+    fn tuple_type(
+        &mut self,
+        types: types::TypesRef<'_>,
+        ty: &types::TupleType,
+    ) -> Result<TypeTupleIndex> {
+        assert_eq!(types.id(), self.module_types.validator_id());
+        let types = ty
+            .types
+            .iter()
+            .map(|ty| self.valtype(types, ty))
+            .collect::<Result<Box<[_]>>>()?;
+        Ok(self.new_tuple_type(types))
+    }
+
+    fn new_tuple_type(&mut self, types: Box<[InterfaceType]>) -> TypeTupleIndex {
+        let abi = CanonicalAbiInfo::record(
+            types
+                .iter()
+                .map(|ty| self.component_types.canonical_abi(ty)),
+        );
+        self.add_tuple_type(TypeTuple { types, abi })
+    }
+
+    fn flags_type(&mut self, flags: &IndexSet<KebabString>) -> TypeFlagsIndex {
+        let flags = TypeFlags {
+            names: flags.iter().map(|s| s.to_string()).collect(),
+            abi: CanonicalAbiInfo::flags(flags.len()),
+        };
+        self.add_flags_type(flags)
+    }
+
+    fn enum_type(&mut self, variants: &IndexSet<KebabString>) -> TypeEnumIndex {
+        let names = variants
+            .iter()
+            .map(|s| s.to_string())
+            .collect::<IndexSet<_>>();
+        let (info, abi) = VariantInfo::new(names.iter().map(|_| None));
+        self.add_enum_type(TypeEnum { names, abi, info })
+    }
+
+    fn option_type(
+        &mut self,
+        types: types::TypesRef<'_>,
+        ty: &types::ComponentValType,
+    ) -> Result<TypeOptionIndex> {
+        assert_eq!(types.id(), self.module_types.validator_id());
+        let ty = self.valtype(types, ty)?;
+        let (info, abi) = VariantInfo::new([None, Some(self.component_types.canonical_abi(&ty))]);
+        Ok(self.add_option_type(TypeOption { ty, abi, info }))
+    }
+
+    fn result_type(
+        &mut self,
+        types: types::TypesRef<'_>,
+        ok: &Option<types::ComponentValType>,
+        err: &Option<types::ComponentValType>,
+    ) -> Result<TypeResultIndex> {
+        assert_eq!(types.id(), self.module_types.validator_id());
+        let ok = match ok {
+            Some(ty) => Some(self.valtype(types, ty)?),
+            None => None,
+        };
+        let err = match err {
+            Some(ty) => Some(self.valtype(types, ty)?),
+            None => None,
+        };
+        let (info, abi) = VariantInfo::new([
+            ok.as_ref().map(|t| self.component_types.canonical_abi(t)),
+            err.as_ref().map(|t| self.component_types.canonical_abi(t)),
+        ]);
+        Ok(self.add_result_type(TypeResult { ok, err, abi, info }))
+    }
+
+    fn list_type(
+        &mut self,
+        types: types::TypesRef<'_>,
+        ty: &types::ComponentValType,
+    ) -> Result<TypeListIndex> {
+        assert_eq!(types.id(), self.module_types.validator_id());
+        let element = self.valtype(types, ty)?;
+        Ok(self.add_list_type(TypeList { element }))
+    }
+
+    /// Converts a wasmparser `id`, which must point to a resource, to its
+    /// corresponding `TypeResourceTableIndex`.
+    pub fn resource_id(&mut self, id: types::ResourceId) -> TypeResourceTableIndex {
+        self.resources.convert(id, &mut self.component_types)
+    }
+
+    /// Interns a new function type within this type information.
+    pub fn add_func_type(&mut self, ty: TypeFunc) -> TypeFuncIndex {
+        intern(&mut self.functions, &mut self.component_types.functions, ty)
+    }
+
+    /// Interns a new record type within this type information.
+    pub fn add_record_type(&mut self, ty: TypeRecord) -> TypeRecordIndex {
+        intern_and_fill_flat_types!(self, records, ty)
+    }
+
+    /// Interns a new flags type within this type information.
+    pub fn add_flags_type(&mut self, ty: TypeFlags) -> TypeFlagsIndex {
+        intern_and_fill_flat_types!(self, flags, ty)
+    }
+
+    /// Interns a new tuple type within this type information.
+    pub fn add_tuple_type(&mut self, ty: TypeTuple) -> TypeTupleIndex {
+        intern_and_fill_flat_types!(self, tuples, ty)
+    }
+
+    /// Interns a new variant type within this type information.
+    pub fn add_variant_type(&mut self, ty: TypeVariant) -> TypeVariantIndex {
+        intern_and_fill_flat_types!(self, variants, ty)
+    }
+
+    /// Interns a new enum type within this type information.
+    pub fn add_enum_type(&mut self, ty: TypeEnum) -> TypeEnumIndex {
+        intern_and_fill_flat_types!(self, enums, ty)
+    }
+
+    /// Interns a new option type within this type information.
+    pub fn add_option_type(&mut self, ty: TypeOption) -> TypeOptionIndex {
+        intern_and_fill_flat_types!(self, options, ty)
+    }
+
+    /// Interns a new result type within this type information.
+    pub fn add_result_type(&mut self, ty: TypeResult) -> TypeResultIndex {
+        intern_and_fill_flat_types!(self, results, ty)
+    }
+
+    /// Interns a new type within this type information.
+    pub fn add_list_type(&mut self, ty: TypeList) -> TypeListIndex {
+        intern_and_fill_flat_types!(self, lists, ty)
+    }
+
+    /// Returns the canonical ABI information about the specified type.
+    pub fn canonical_abi(&self, ty: &InterfaceType) -> &CanonicalAbiInfo {
+        self.component_types.canonical_abi(ty)
+    }
+
+    /// Returns the "flat types" for the given interface type used in the
+    /// canonical ABI.
+    ///
+    /// Returns `None` if the type is too large to be represented via flat types
+    /// in the canonical abi.
+    pub fn flat_types(&self, ty: &InterfaceType) -> Option<FlatTypes<'_>> {
+        self.type_information(ty).flat.as_flat_types()
+    }
+
+    /// Returns whether the type specified contains any borrowed resources
+    /// within it.
+    pub fn ty_contains_borrow_resource(&self, ty: &InterfaceType) -> bool {
+        self.type_information(ty).has_borrow
+    }
+
+    fn type_information(&self, ty: &InterfaceType) -> &TypeInformation {
+        match ty {
+            InterfaceType::U8
+            | InterfaceType::S8
+            | InterfaceType::Bool
+            | InterfaceType::U16
+            | InterfaceType::S16
+            | InterfaceType::U32
+            | InterfaceType::S32
+            | InterfaceType::Char
+            | InterfaceType::Own(_) => {
+                static INFO: TypeInformation = TypeInformation::primitive(FlatType::I32);
+                &INFO
+            }
+            InterfaceType::Borrow(_) => {
+                static INFO: TypeInformation = {
+                    let mut info = TypeInformation::primitive(FlatType::I32);
+                    info.has_borrow = true;
+                    info
+                };
+                &INFO
+            }
+            InterfaceType::U64 | InterfaceType::S64 => {
+                static INFO: TypeInformation = TypeInformation::primitive(FlatType::I64);
+                &INFO
+            }
+            InterfaceType::Float32 => {
+                static INFO: TypeInformation = TypeInformation::primitive(FlatType::F32);
+                &INFO
+            }
+            InterfaceType::Float64 => {
+                static INFO: TypeInformation = TypeInformation::primitive(FlatType::F64);
+                &INFO
+            }
+            InterfaceType::String => {
+                static INFO: TypeInformation = TypeInformation::string();
+                &INFO
+            }
+
+            InterfaceType::List(i) => &self.type_info.lists[*i],
+            InterfaceType::Record(i) => &self.type_info.records[*i],
+            InterfaceType::Variant(i) => &self.type_info.variants[*i],
+            InterfaceType::Tuple(i) => &self.type_info.tuples[*i],
+            InterfaceType::Flags(i) => &self.type_info.flags[*i],
+            InterfaceType::Enum(i) => &self.type_info.enums[*i],
+            InterfaceType::Option(i) => &self.type_info.options[*i],
+            InterfaceType::Result(i) => &self.type_info.results[*i],
+        }
+    }
+}
+
+impl TypeConvert for ComponentTypesBuilder {
+    fn lookup_heap_type(&self, _index: wasmparser::UnpackedIndex) -> WasmHeapType {
+        panic!("heap types are not supported yet")
+    }
+
+    fn lookup_type_index(
+        &self,
+        _index: wasmparser::UnpackedIndex,
+    ) -> wasmtime_types::EngineOrModuleTypeIndex {
+        panic!("typed references are not supported yet")
+    }
+}
+
+fn intern<T, U>(map: &mut HashMap<T, U>, list: &mut PrimaryMap<U, T>, item: T) -> U
+where
+    T: Hash + Clone + Eq,
+    U: Copy + EntityRef,
+{
+    if let Some(idx) = map.get(&item) {
+        return *idx;
+    }
+    let idx = list.push(item.clone());
+    map.insert(item, idx);
+    return idx;
+}
+
+struct FlatTypesStorage {
+    // This could be represented as `Vec<FlatType>` but on 64-bit architectures
+    // that's 24 bytes. Otherwise `FlatType` is 1 byte large and
+    // `MAX_FLAT_TYPES` is 16, so it should ideally be more space-efficient to
+    // use a flat array instead of a heap-based vector.
+    memory32: [FlatType; MAX_FLAT_TYPES],
+    memory64: [FlatType; MAX_FLAT_TYPES],
+
+    // Tracks the number of flat types pushed into this storage. If this is
+    // `MAX_FLAT_TYPES + 1` then this storage represents an un-reprsentable
+    // type in flat types.
+    len: u8,
+}
+
+impl FlatTypesStorage {
+    const fn new() -> FlatTypesStorage {
+        FlatTypesStorage {
+            memory32: [FlatType::I32; MAX_FLAT_TYPES],
+            memory64: [FlatType::I32; MAX_FLAT_TYPES],
+            len: 0,
+        }
+    }
+
+    fn as_flat_types(&self) -> Option<FlatTypes<'_>> {
+        let len = usize::from(self.len);
+        if len > MAX_FLAT_TYPES {
+            assert_eq!(len, MAX_FLAT_TYPES + 1);
+            None
+        } else {
+            Some(FlatTypes {
+                memory32: &self.memory32[..len],
+                memory64: &self.memory64[..len],
+            })
+        }
+    }
+
+    /// Pushes a new flat type into this list using `t32` for 32-bit memories
+    /// and `t64` for 64-bit memories.
+    ///
+    /// Returns whether the type was actually pushed or whether this list of
+    /// flat types just exceeded the maximum meaning that it is now
+    /// unrepresentable with a flat list of types.
+    fn push(&mut self, t32: FlatType, t64: FlatType) -> bool {
+        let len = usize::from(self.len);
+        if len < MAX_FLAT_TYPES {
+            self.memory32[len] = t32;
+            self.memory64[len] = t64;
+            self.len += 1;
+            true
+        } else {
+            // If this was the first one to go over then flag the length as
+            // being incompatible with a flat representation.
+            if len == MAX_FLAT_TYPES {
+                self.len += 1;
+            }
+            false
+        }
+    }
+}
+
+impl FlatType {
+    fn join(&mut self, other: FlatType) {
+        if *self == other {
+            return;
+        }
+        *self = match (*self, other) {
+            (FlatType::I32, FlatType::F32) | (FlatType::F32, FlatType::I32) => FlatType::I32,
+            _ => FlatType::I64,
+        };
+    }
+}
+
+#[derive(Default)]
+struct TypeInformationCache {
+    records: PrimaryMap<TypeRecordIndex, TypeInformation>,
+    variants: PrimaryMap<TypeVariantIndex, TypeInformation>,
+    tuples: PrimaryMap<TypeTupleIndex, TypeInformation>,
+    enums: PrimaryMap<TypeEnumIndex, TypeInformation>,
+    flags: PrimaryMap<TypeFlagsIndex, TypeInformation>,
+    options: PrimaryMap<TypeOptionIndex, TypeInformation>,
+    results: PrimaryMap<TypeResultIndex, TypeInformation>,
+    lists: PrimaryMap<TypeListIndex, TypeInformation>,
+}
+
+struct TypeInformation {
+    depth: u32,
+    flat: FlatTypesStorage,
+    has_borrow: bool,
+}
+
+impl TypeInformation {
+    const fn new() -> TypeInformation {
+        TypeInformation {
+            depth: 0,
+            flat: FlatTypesStorage::new(),
+            has_borrow: false,
+        }
+    }
+
+    const fn primitive(flat: FlatType) -> TypeInformation {
+        let mut info = TypeInformation::new();
+        info.depth = 1;
+        info.flat.memory32[0] = flat;
+        info.flat.memory64[0] = flat;
+        info.flat.len = 1;
+        info
+    }
+
+    const fn string() -> TypeInformation {
+        let mut info = TypeInformation::new();
+        info.depth = 1;
+        info.flat.memory32[0] = FlatType::I32;
+        info.flat.memory32[1] = FlatType::I32;
+        info.flat.memory64[0] = FlatType::I64;
+        info.flat.memory64[1] = FlatType::I64;
+        info.flat.len = 2;
+        info
+    }
+
+    /// Builds up all flat types internally using the specified representation
+    /// for all of the component fields of the record.
+    fn build_record<'a>(&mut self, types: impl Iterator<Item = &'a TypeInformation>) {
+        self.depth = 1;
+        for info in types {
+            self.depth = self.depth.max(1 + info.depth);
+            self.has_borrow = self.has_borrow || info.has_borrow;
+            match info.flat.as_flat_types() {
+                Some(types) => {
+                    for (t32, t64) in types.memory32.iter().zip(types.memory64) {
+                        if !self.flat.push(*t32, *t64) {
+                            break;
+                        }
+                    }
+                }
+                None => {
+                    self.flat.len = u8::try_from(MAX_FLAT_TYPES + 1).unwrap();
+                }
+            }
+        }
+    }
+
+    /// Builds up the flat types used to represent a `variant` which notably
+    /// handles "join"ing types together so each case is representable as a
+    /// single flat list of types.
+    ///
+    /// The iterator item is:
+    ///
+    /// * `None` - no payload for this case
+    /// * `Some(None)` - this case has a payload but can't be represented with
+    ///   flat types
+    /// * `Some(Some(types))` - this case has a payload and is represented with
+    ///   the types specified in the flat representation.
+    fn build_variant<'a, I>(&mut self, cases: I)
+    where
+        I: IntoIterator<Item = Option<&'a TypeInformation>>,
+    {
+        let cases = cases.into_iter();
+        self.flat.push(FlatType::I32, FlatType::I32);
+        self.depth = 1;
+
+        for info in cases {
+            let info = match info {
+                Some(info) => info,
+                // If this case doesn't have a payload then it doesn't change
+                // the depth/flat representation
+                None => continue,
+            };
+            self.depth = self.depth.max(1 + info.depth);
+            self.has_borrow = self.has_borrow || info.has_borrow;
+
+            // If this variant is already unrepresentable in a flat
+            // representation then this can be skipped.
+            if usize::from(self.flat.len) > MAX_FLAT_TYPES {
+                continue;
+            }
+
+            let types = match info.flat.as_flat_types() {
+                Some(types) => types,
+                // If this case isn't representable with a flat list of types
+                // then this variant also isn't representable.
+                None => {
+                    self.flat.len = u8::try_from(MAX_FLAT_TYPES + 1).unwrap();
+                    continue;
+                }
+            };
+            // If the case used all of the flat types then the discriminant
+            // added for this variant means that this variant is no longer
+            // representable.
+            if types.memory32.len() >= MAX_FLAT_TYPES {
+                self.flat.len = u8::try_from(MAX_FLAT_TYPES + 1).unwrap();
+                continue;
+            }
+            let dst = self
+                .flat
+                .memory32
+                .iter_mut()
+                .zip(&mut self.flat.memory64)
+                .skip(1);
+            for (i, ((t32, t64), (dst32, dst64))) in types
+                .memory32
+                .iter()
+                .zip(types.memory64)
+                .zip(dst)
+                .enumerate()
+            {
+                if i + 1 < usize::from(self.flat.len) {
+                    // If this index hs already been set by some previous case
+                    // then the types are joined together.
+                    dst32.join(*t32);
+                    dst64.join(*t64);
+                } else {
+                    // Otherwise if this is the first time that the
+                    // representation has gotten this large then the destination
+                    // is simply whatever the type is. The length is also
+                    // increased here to indicate this.
+                    self.flat.len += 1;
+                    *dst32 = *t32;
+                    *dst64 = *t64;
+                }
+            }
+        }
+    }
+
+    fn records(&mut self, types: &ComponentTypesBuilder, ty: &TypeRecord) {
+        self.build_record(ty.fields.iter().map(|f| types.type_information(&f.ty)));
+    }
+
+    fn tuples(&mut self, types: &ComponentTypesBuilder, ty: &TypeTuple) {
+        self.build_record(ty.types.iter().map(|t| types.type_information(t)));
+    }
+
+    fn enums(&mut self, _types: &ComponentTypesBuilder, _ty: &TypeEnum) {
+        self.depth = 1;
+        self.flat.push(FlatType::I32, FlatType::I32);
+    }
+
+    fn flags(&mut self, _types: &ComponentTypesBuilder, ty: &TypeFlags) {
+        self.depth = 1;
+        match FlagsSize::from_count(ty.names.len()) {
+            FlagsSize::Size0 => {}
+            FlagsSize::Size1 | FlagsSize::Size2 => {
+                self.flat.push(FlatType::I32, FlatType::I32);
+            }
+            FlagsSize::Size4Plus(n) => {
+                for _ in 0..n {
+                    self.flat.push(FlatType::I32, FlatType::I32);
+                }
+            }
+        }
+    }
+
+    fn variants(&mut self, types: &ComponentTypesBuilder, ty: &TypeVariant) {
+        self.build_variant(
+            ty.cases
+                .iter()
+                .map(|(_, c)| c.as_ref().map(|ty| types.type_information(ty))),
+        )
+    }
+
+    fn results(&mut self, types: &ComponentTypesBuilder, ty: &TypeResult) {
+        self.build_variant([
+            ty.ok.as_ref().map(|ty| types.type_information(ty)),
+            ty.err.as_ref().map(|ty| types.type_information(ty)),
+        ])
+    }
+
+    fn options(&mut self, types: &ComponentTypesBuilder, ty: &TypeOption) {
+        self.build_variant([None, Some(types.type_information(&ty.ty))]);
+    }
+
+    fn lists(&mut self, types: &ComponentTypesBuilder, ty: &TypeList) {
+        *self = TypeInformation::string();
+        let info = types.type_information(&ty.element);
+        self.depth += info.depth;
+        self.has_borrow = info.has_borrow;
+    }
+}
diff --git a/crates/environ/src/component/types_builder/resources.rs b/crates/environ/src/component/types_builder/resources.rs
new file mode 100644
index 000000000000..fc9e076050b6
--- /dev/null
+++ b/crates/environ/src/component/types_builder/resources.rs
@@ -0,0 +1,233 @@
+//! Implementation of resource type information within Wasmtime.
+//!
+//! Resource types are one of the trickier parts of the component model. Types
+//! such as `list`, `record`, and `string` are considered "structural" where two
+//! types are considered equal if their components are equal. For example `(list
+//! $a)` and `(list $b)` are the same if `$a` and `$b` are the same. Resources,
+//! however, are not as simple.
+//!
+//! The type of a resource can "change" sort of depending on who you are and how
+//! you view it. Some examples of resources are:
+//!
+//! * When a resource is imported into a component the internal component
+//!   doesn't know the underlying resource type, but the outer component which
+//!   performed an instantiation knows that. This means that if a component
+//!   imports two unique resources but is instantiated with two copies of the
+//!   same resource the internal component can't know they're the same but the
+//!   outer component knows they're the same.
+//!
+//! * Each instantiation of a component produces new resource types. This means
+//!   that if a component instantiates a subcomponent twice then the resources
+//!   defined in that subcomponent are considered different between the two
+//!   instances.
+//!
+//! All this is basically to say that resources require special care. The
+//! purpose of resources are to provide isolation across component boundaries
+//! and strict guarantees around ownership and borrowing. Getting the type
+//! information wrong can compromise on all of these guarantees which is
+//! something Wasmtime would ideally avoid.
+//!
+//! ## Interaction with `wasmparser`
+//!
+//! The trickiness of resource types is not unique of Wasmtime and the first
+//! line of translating a component, `wasmparser`, already has quite a lot of
+//! support for handling all the various special cases of resources. Namely
+//! `wasmparser` has a `ResourceId` type which can be used to test whether two
+//! resources are the same or unique. For example in the above scenario where a
+//! component imports two resources then within that component they'll have
+//! unique ids. Externally though the outer component will be able to see that
+//! the ids are the same.
+//!
+//! Given the subtlety here the goal is to lean on `wasmparser` as much as
+//! possible for this information. The thinking is "well it got things right so
+//! let's not duplicate". This is one of the motivations for plumbing
+//! `wasmparser`'s type information throughout `LocalInitializer` structures
+//! during translation of a component. During conversion to a
+//! `GlobalInitializer` is where everything is boiled away.
+//!
+//! ## Converting to Wasmtime
+//!
+//! The purpose of this module then is to convert `wasmparser`'s view of
+//! resources into Wasmtime's view of resources. Wasmtime's goal is to
+//! determine how many tables are required for each resource within a component
+//! and then from then on purely talk about table indices. Each component
+//! instance will require a table per-resource and this figures that all out.
+//!
+//! The conversion process, however, is relatively tightly intertwined with type
+//! conversion in general. The "leaves" of a type may be resources but there are
+//! other structures in a type such as lists, records, variants, etc. This means
+//! that the `ResourcesBuilder` below is embedded within a
+//! `ComponentTypesBuilder`. This also means that it's unfortunately not easy to
+//! disentangle pieces and have one nice standalone file that handles everything
+//! related to type information about resources. Instead this one file was
+//! chosen as the place for this doc comment but the file itself is deceptively
+//! small as much of the other handling happens elsewhere in component
+//! translation.
+//!
+//! For more details on fiddly bits see the documentation on various fields and
+//! methods below.
+
+use crate::component::{
+    ComponentTypes, ResourceIndex, RuntimeComponentInstanceIndex, TypeResourceTable,
+    TypeResourceTableIndex,
+};
+use crate::prelude::*;
+use std::collections::HashMap;
+use wasmparser::types;
+
+/// Builder state used to translate wasmparser's `ResourceId` types to
+/// Wasmtime's `TypeResourceTableIndex` type.
+///
+/// This is contained in a `ComponentTypesBuilder` but is modified quite a bit
+/// manually via the `inline` phase of component instantiation.
+///
+/// This type crucially implements the `Clone` trait which is used to "snapshot"
+/// the current state of resource translation. The purpose of `Clone` here is to
+/// record translation information just before a subcomponent is instantiated to
+/// restore it after the subcomponent's instantiation has completed. This is
+/// done to handle instantiations of the same component multiple times
+/// correctly.
+///
+/// Wasmparser produces one set of type information for a component, and not a
+/// unique set of type information about its internals for each instantiation.
+/// Each instance which results from instantiation gets a new type, but when
+/// we're translating the instantiation of a component Wasmtime will re-run all
+/// initializers. This means that if naively implemented the `ResourceId`
+/// mapping from the first instantiation will be reused by the second
+/// instantiation. The snapshotting behavior and restoration guarantees that
+/// whenever a subcomponent is visited and instantiated it's guaranteed that
+/// there's no registered information for its `ResourceId` definitions within
+/// this builder.
+///
+/// Note that `ResourceId` references are guaranteed to be "local" in the sense
+/// that if a resource is defined within a component then the ID it's assigned
+/// internally within a component is different than the ID when it's
+/// instantiated (since all instantiations produce new types). This means that
+/// when throwing away state built-up from within a component that's also
+/// reasonable because the information should never be used after a component is
+/// left anyway.
+#[derive(Default, Clone)]
+pub struct ResourcesBuilder {
+    /// A cache of previously visited `ResourceId` items and which table they
+    /// correspond to. This is lazily populated as resources are visited and is
+    /// exclusively used by the `convert` function below.
+    resource_id_to_table_index: HashMap<types::ResourceId, TypeResourceTableIndex>,
+
+    /// A cache of the origin resource type behind a `ResourceId`.
+    ///
+    /// Unlike `resource_id_to_table_index` this is required to be eagerly
+    /// populated before translation of a type occurs. This is populated by
+    /// `register_*` methods below and is manually done during the `inline`
+    /// phase. This is used to record the actual underlying type of a resource
+    /// and where it originally comes from. When a resource is later referred to
+    /// then a table is injected to be referred to.
+    resource_id_to_resource_index: HashMap<types::ResourceId, ResourceIndex>,
+
+    /// The current instance index that's being visited. This is updated as
+    /// inliner frames are processed and components are instantiated.
+    current_instance: Option<RuntimeComponentInstanceIndex>,
+}
+
+impl ResourcesBuilder {
+    /// Converts the `id` provided into a `TypeResourceTableIndex`.
+    ///
+    /// If `id` has previously been seen or converted, the prior value is
+    /// returned. Otherwise the `resource_id_to_resource_index` table must have
+    /// been previously populated and additionally `current_instance` must have
+    /// been previously set. Using these a new `TypeResourceTable` value is
+    /// allocated which produces a fresh `TypeResourceTableIndex` within the
+    /// `types` provided.
+    ///
+    /// Due to `wasmparser`'s uniqueness of resource IDs combined with the
+    /// snapshotting and restoration behavior of `ResourcesBuilder` itself this
+    /// should have the net effect of the first time a resource is seen within
+    /// any component it's assigned a new table, which is exactly what we want.
+    pub fn convert(
+        &mut self,
+        id: types::ResourceId,
+        types: &mut ComponentTypes,
+    ) -> TypeResourceTableIndex {
+        *self
+            .resource_id_to_table_index
+            .entry(id)
+            .or_insert_with(|| {
+                let ty = self.resource_id_to_resource_index[&id];
+                let instance = self.current_instance.expect("current instance not set");
+                types.push_resource_table(TypeResourceTable { ty, instance })
+            })
+    }
+
+    /// Walks over the `ty` provided, as defined within `types`, and registers
+    /// all the defined resources found with the `register` function provided.
+    ///
+    /// This is used to register `ResourceIndex` entries within the
+    /// `resource_id_to_resource_index` table of this type for situations such
+    /// as when a resource is imported into a component. During the inlining
+    /// phase of compilation the actual underlying type of the resource is
+    /// known due to tracking dataflow and this registers that relationship.
+    ///
+    /// The `path` provided is temporary storage to pass to the `register`
+    /// function eventually.
+    ///
+    /// The `register` callback is invoked with `path` with a list of names
+    /// which correspond to exports of instances to reach the "leaf" where a
+    /// resource type is expected.
+    pub fn register_component_entity_type<'a>(
+        &mut self,
+        types: &'a types::TypesRef<'_>,
+        ty: types::ComponentEntityType,
+        path: &mut Vec<&'a str>,
+        register: &mut dyn FnMut(&[&'a str]) -> ResourceIndex,
+    ) {
+        match ty {
+            // If `ty` is itself a type, and that's a resource type, then this
+            // is where registration happens. The `register` callback is invoked
+            // with the current path and that's inserted in to
+            // `resource_id_to_resource_index` if the resource hasn't been seen
+            // yet.
+            types::ComponentEntityType::Type {
+                created: types::ComponentAnyTypeId::Resource(id),
+                ..
+            } => {
+                self.resource_id_to_resource_index
+                    .entry(id.resource())
+                    .or_insert_with(|| register(path));
+            }
+
+            // Resources can be imported/defined through exports of instances so
+            // all instance exports are walked here. Note the management of
+            // `path` which is used for the recursive invocation of this method.
+            types::ComponentEntityType::Instance(id) => {
+                let ty = &types[id];
+                for (name, ty) in ty.exports.iter() {
+                    path.push(name);
+                    self.register_component_entity_type(types, *ty, path, register);
+                    path.pop();
+                }
+            }
+
+            // None of these items can introduce a new component type, so
+            // there's no need to recurse over these.
+            types::ComponentEntityType::Func(_)
+            | types::ComponentEntityType::Type { .. }
+            | types::ComponentEntityType::Module(_)
+            | types::ComponentEntityType::Component(_)
+            | types::ComponentEntityType::Value(_) => {}
+        }
+    }
+
+    /// Declares that the wasmparser `id`, which must point to a resource, is
+    /// defined by the `ty` provided.
+    ///
+    /// This is used when a local resource is defined within a component for example.
+    pub fn register_resource(&mut self, id: types::ResourceId, ty: ResourceIndex) {
+        let prev = self.resource_id_to_resource_index.insert(id, ty);
+        assert!(prev.is_none());
+    }
+
+    /// Updates the `current_instance` field to assign instance fields of future
+    /// `TypeResourceTableIndex` values produced via `convert`.
+    pub fn set_current_instance(&mut self, instance: RuntimeComponentInstanceIndex) {
+        self.current_instance = Some(instance);
+    }
+}
diff --git a/crates/environ/src/demangling.rs b/crates/environ/src/demangling.rs
new file mode 100644
index 000000000000..b197c6f10e84
--- /dev/null
+++ b/crates/environ/src/demangling.rs
@@ -0,0 +1,28 @@
+//! Helpers for demangling function names.
+
+/// Demangles a single function name into a user-readable form.
+///
+/// Currently supported: Rust/C/C++ function names.
+pub fn demangle_function_name(writer: &mut impl core::fmt::Write, name: &str) -> core::fmt::Result {
+    #[cfg(feature = "demangle")]
+    if let Ok(demangled) = rustc_demangle::try_demangle(name) {
+        return write!(writer, "{demangled}");
+    } else if let Ok(demangled) = cpp_demangle::Symbol::new(name) {
+        return write!(writer, "{demangled}");
+    }
+
+    write!(writer, "{name}")
+}
+
+/// Demangles a function name if it's provided, or returns a unified representation based on the
+/// function index otherwise.
+pub fn demangle_function_name_or_index(
+    writer: &mut impl core::fmt::Write,
+    name: Option<&str>,
+    func_id: usize,
+) -> core::fmt::Result {
+    match name {
+        Some(name) => demangle_function_name(writer, name),
+        None => write!(writer, "<wasm function {func_id}>"),
+    }
+}
diff --git a/crates/environ/src/fact.rs b/crates/environ/src/fact.rs
index 70437996c996..4afdac971ff7 100644
--- a/crates/environ/src/fact.rs
+++ b/crates/environ/src/fact.rs
@@ -1,7 +1,7 @@
 //! Wasmtime's Fused Adapter Compiler of Trampolines (FACT)
 //!
 //! This module contains a compiler which emits trampolines to implement fused
-//! adatpers for the component model. A fused adapter is when a core wasm
+//! adapters for the component model. A fused adapter is when a core wasm
 //! function is lifted from one component instance and then lowered into another
 //! component instance. This communication between components is well-defined by
 //! the spec and ends up creating what's called a "fused adapter".
@@ -14,16 +14,17 @@
 //!
 //! Note that identification of precisely what goes into an adapter module is
 //! not handled in this file, instead that's all done in `translate/adapt.rs`.
-//! Otherwise this module is only reponsible for taking a set of adapters and
+//! Otherwise this module is only responsible for taking a set of adapters and
 //! their imports and then generating a core wasm module to implement all of
 //! that.
 
 use crate::component::dfg::CoreDef;
 use crate::component::{
     Adapter, AdapterOptions as AdapterOptionsDfg, ComponentTypesBuilder, FlatType, InterfaceType,
-    StringEncoding, TypeFuncIndex,
+    StringEncoding, Transcode, TypeFuncIndex,
 };
 use crate::fact::transcode::Transcoder;
+use crate::prelude::*;
 use crate::{EntityRef, FuncIndex, GlobalIndex, MemoryIndex, PrimaryMap};
 use std::borrow::Cow;
 use std::collections::HashMap;
@@ -35,8 +36,6 @@ mod trampoline;
 mod transcode;
 mod traps;
 
-pub use self::transcode::{FixedEncoding, Transcode};
-
 /// Representation of an adapter module.
 pub struct Module<'a> {
     /// Whether or not debug code is inserted into the adapters themselves.
@@ -256,6 +255,7 @@ impl<'a> Module<'a> {
             GlobalType {
                 val_type: ValType::I32,
                 mutable: true,
+                shared: false,
             },
             CoreDef::InstanceFlags(*instance),
         );
@@ -268,6 +268,7 @@ impl<'a> Module<'a> {
                     maximum: None,
                     shared: false,
                     memory64: *memory64,
+                    page_size_log2: None,
                 },
                 memory.clone().into(),
             )
@@ -604,7 +605,7 @@ cranelift_entity::entity_impl!(FunctionId);
 
 /// A generated function to be added to an adapter module.
 ///
-/// At least one function is created per-adapter and dependeing on the type
+/// At least one function is created per-adapter and depending on the type
 /// hierarchy multiple functions may be generated per-adapter.
 struct Function {
     /// Whether or not the `body` has been finished.
@@ -628,7 +629,7 @@ struct Function {
     /// The contents of the function.
     ///
     /// See `Body` for more information, and the `Vec` here represents the
-    /// concatentation of all the `Body` fragments.
+    /// concatenation of all the `Body` fragments.
     body: Vec<Body>,
 }
 
diff --git a/crates/environ/src/fact/core_types.rs b/crates/environ/src/fact/core_types.rs
index b7699ad23c18..31c2f7eb7288 100644
--- a/crates/environ/src/fact/core_types.rs
+++ b/crates/environ/src/fact/core_types.rs
@@ -1,3 +1,4 @@
+use crate::prelude::*;
 use std::collections::HashMap;
 use wasm_encoder::{TypeSection, ValType};
 
diff --git a/crates/environ/src/fact/signature.rs b/crates/environ/src/fact/signature.rs
index 07660d4d0d61..328ec085e359 100644
--- a/crates/environ/src/fact/signature.rs
+++ b/crates/environ/src/fact/signature.rs
@@ -2,6 +2,7 @@
 
 use crate::component::{ComponentTypesBuilder, InterfaceType, MAX_FLAT_PARAMS, MAX_FLAT_RESULTS};
 use crate::fact::{AdapterOptions, Context, Options};
+use crate::prelude::*;
 use wasm_encoder::ValType;
 
 /// Metadata about a core wasm signature which is created for a component model
@@ -12,14 +13,6 @@ pub struct Signature {
     pub params: Vec<ValType>,
     /// Core wasm results.
     pub results: Vec<ValType>,
-    /// Indicator to whether parameters are indirect, meaning that the first
-    /// entry of `params` is a pointer type which all parameters are loaded
-    /// through.
-    pub params_indirect: bool,
-    /// Indicator whether results are passed indirectly. This may mean that
-    /// `results` is an `i32` or that `params` ends with an `i32` depending on
-    /// the `Context`.
-    pub results_indirect: bool,
 }
 
 impl ComponentTypesBuilder {
@@ -33,7 +26,6 @@ impl ComponentTypesBuilder {
         let ty = &self[options.ty];
         let ptr_ty = options.options.ptr();
 
-        let mut params_indirect = false;
         let mut params = match self.flatten_types(
             &options.options,
             MAX_FLAT_PARAMS,
@@ -41,20 +33,17 @@ impl ComponentTypesBuilder {
         ) {
             Some(list) => list,
             None => {
-                params_indirect = true;
                 vec![ptr_ty]
             }
         };
 
-        let mut results_indirect = false;
         let results = match self.flatten_types(
             &options.options,
             MAX_FLAT_RESULTS,
-            self[ty.results].types.iter().map(|ty| *ty),
+            self[ty.results].types.iter().copied(),
         ) {
             Some(list) => list,
             None => {
-                results_indirect = true;
                 match context {
                     // For a lifted function too-many-results gets translated to a
                     // returned pointer where results are read from. The callee
@@ -70,12 +59,7 @@ impl ComponentTypesBuilder {
                 }
             }
         };
-        Signature {
-            params,
-            results,
-            params_indirect,
-            results_indirect,
-        }
+        Signature { params, results }
     }
 
     /// Pushes the flat version of a list of component types into a final result
diff --git a/crates/environ/src/fact/trampoline.rs b/crates/environ/src/fact/trampoline.rs
index 5936de013d39..0097f801def8 100644
--- a/crates/environ/src/fact/trampoline.rs
+++ b/crates/environ/src/fact/trampoline.rs
@@ -16,18 +16,19 @@
 //! can be somewhat arbitrary, an intentional decision.
 
 use crate::component::{
-    CanonicalAbiInfo, ComponentTypesBuilder, FlatType, InterfaceType, StringEncoding,
-    TypeEnumIndex, TypeFlagsIndex, TypeListIndex, TypeOptionIndex, TypeRecordIndex,
-    TypeResourceTableIndex, TypeResultIndex, TypeTupleIndex, TypeVariantIndex, VariantInfo,
-    FLAG_MAY_ENTER, FLAG_MAY_LEAVE, MAX_FLAT_PARAMS, MAX_FLAT_RESULTS,
+    CanonicalAbiInfo, ComponentTypesBuilder, FixedEncoding as FE, FlatType, InterfaceType,
+    StringEncoding, Transcode, TypeEnumIndex, TypeFlagsIndex, TypeListIndex, TypeOptionIndex,
+    TypeRecordIndex, TypeResourceTableIndex, TypeResultIndex, TypeTupleIndex, TypeVariantIndex,
+    VariantInfo, FLAG_MAY_ENTER, FLAG_MAY_LEAVE, MAX_FLAT_PARAMS, MAX_FLAT_RESULTS,
 };
 use crate::fact::signature::Signature;
-use crate::fact::transcode::{FixedEncoding as FE, Transcode, Transcoder};
+use crate::fact::transcode::Transcoder;
 use crate::fact::traps::Trap;
 use crate::fact::{
     AdapterData, Body, Context, Function, FunctionId, Helper, HelperLocation, HelperType, Module,
     Options,
 };
+use crate::prelude::*;
 use crate::{FuncIndex, GlobalIndex};
 use std::collections::HashMap;
 use std::mem;
@@ -163,7 +164,7 @@ pub(super) fn compile_helper(module: &mut Module<'_>, result: FunctionId, helper
                 .unwrap();
             Destination::Stack(&dst_flat, &helper.dst.opts)
         }
-        // This is the same as a memroy-based source but note that the address
+        // This is the same as a memory-based source but note that the address
         // of the destination is passed as the final parameter to the function.
         HelperLocation::Memory => {
             nlocals += 1;
@@ -431,13 +432,13 @@ impl Compiler<'_, '_> {
         let src_tys = self.types[src_tys]
             .types
             .iter()
-            .map(|ty| *ty)
+            .copied()
             .collect::<Vec<_>>();
         let dst_tys = self.types[adapter.lower.ty].results;
         let dst_tys = self.types[dst_tys]
             .types
             .iter()
-            .map(|ty| *ty)
+            .copied()
             .collect::<Vec<_>>();
         let lift_opts = &adapter.lift.options;
         let lower_opts = &adapter.lower.options;
@@ -520,7 +521,7 @@ impl Compiler<'_, '_> {
         // The general goal is to avoid creating an exponentially sized function
         // for a linearly sized input (the type section). By outlining helper
         // functions there will ideally be a constant set of helper functions
-        // per type (to accomodate in-memory or on-stack transfers as well as
+        // per type (to accommodate in-memory or on-stack transfers as well as
         // src/dst options) which means that each function is at most a certain
         // size and we have a linear number of functions which should guarantee
         // an overall linear size of the output.
@@ -1228,7 +1229,7 @@ impl Compiler<'_, '_> {
         self.validate_string_length(src, src_enc);
 
         // Optimistically assume that the code unit length of the source is
-        // all that's needed in the destination. Perform that allocaiton
+        // all that's needed in the destination. Perform that allocation
         // here and proceed to transcoding below.
         self.convert_src_len_to_dst(src.len.idx, src.opts.ptr(), dst_opts.ptr());
         let dst_len = self.local_tee_new_tmp(dst_opts.ptr());
@@ -1734,7 +1735,7 @@ impl Compiler<'_, '_> {
         self.instruction(Block(BlockType::Empty));
 
         // Calculate the full byte size of memory with `memory.size`. Note that
-        // arithmetic here is done always in 64-bits to accomodate 4G memories.
+        // arithmetic here is done always in 64-bits to accommodate 4G memories.
         // Additionally it's assumed that 64-bit memories never fill up
         // entirely.
         self.instruction(MemorySize(opts.memory.unwrap().as_u32()));
@@ -2179,25 +2180,29 @@ impl Compiler<'_, '_> {
             _ => panic!("expected a variant"),
         };
 
-        let src_info = variant_info(self.types, src_ty.cases.iter().map(|c| c.ty.as_ref()));
-        let dst_info = variant_info(self.types, dst_ty.cases.iter().map(|c| c.ty.as_ref()));
+        let src_info = variant_info(self.types, src_ty.cases.iter().map(|(_, c)| c.as_ref()));
+        let dst_info = variant_info(self.types, dst_ty.cases.iter().map(|(_, c)| c.as_ref()));
 
-        let iter = src_ty.cases.iter().enumerate().map(|(src_i, src_case)| {
-            let dst_i = dst_ty
-                .cases
-                .iter()
-                .position(|c| c.name == src_case.name)
-                .unwrap();
-            let dst_case = &dst_ty.cases[dst_i];
-            let src_i = u32::try_from(src_i).unwrap();
-            let dst_i = u32::try_from(dst_i).unwrap();
-            VariantCase {
-                src_i,
-                src_ty: src_case.ty.as_ref(),
-                dst_i,
-                dst_ty: dst_case.ty.as_ref(),
-            }
-        });
+        let iter = src_ty
+            .cases
+            .iter()
+            .enumerate()
+            .map(|(src_i, (src_case, src_case_ty))| {
+                let dst_i = dst_ty
+                    .cases
+                    .iter()
+                    .position(|(c, _)| c == src_case)
+                    .unwrap();
+                let dst_case_ty = &dst_ty.cases[dst_i];
+                let src_i = u32::try_from(src_i).unwrap();
+                let dst_i = u32::try_from(dst_i).unwrap();
+                VariantCase {
+                    src_i,
+                    src_ty: src_case_ty.as_ref(),
+                    dst_i,
+                    dst_ty: dst_case_ty.as_ref(),
+                }
+            });
         self.convert_variant(src, &src_info, dst, &dst_info, iter);
     }
 
diff --git a/crates/environ/src/fact/transcode.rs b/crates/environ/src/fact/transcode.rs
index ca34a8583156..14eddfe484b9 100644
--- a/crates/environ/src/fact/transcode.rs
+++ b/crates/environ/src/fact/transcode.rs
@@ -1,6 +1,7 @@
+use crate::component::Transcode;
 use crate::fact::core_types::CoreTypes;
+use crate::prelude::*;
 use crate::MemoryIndex;
-use serde_derive::{Deserialize, Serialize};
 use wasm_encoder::{EntityType, ValType};
 
 #[derive(Copy, Clone, Hash, Eq, PartialEq)]
@@ -12,55 +13,6 @@ pub struct Transcoder {
     pub op: Transcode,
 }
 
-/// Possible transcoding operations that must be provided by the host.
-///
-/// Note that each transcoding operation may have a unique signature depending
-/// on the precise operation.
-#[allow(missing_docs)]
-#[derive(Debug, Copy, Clone, Hash, Eq, PartialEq)]
-pub enum Transcode {
-    Copy(FixedEncoding),
-    Latin1ToUtf16,
-    Latin1ToUtf8,
-    Utf16ToCompactProbablyUtf16,
-    Utf16ToCompactUtf16,
-    Utf16ToLatin1,
-    Utf16ToUtf8,
-    Utf8ToCompactUtf16,
-    Utf8ToLatin1,
-    Utf8ToUtf16,
-}
-
-impl Transcode {
-    /// Get this transcoding's symbol fragment.
-    pub fn symbol_fragment(&self) -> &'static str {
-        match self {
-            Transcode::Copy(x) => match x {
-                FixedEncoding::Utf8 => "copy_utf8",
-                FixedEncoding::Utf16 => "copy_utf16",
-                FixedEncoding::Latin1 => "copy_latin1",
-            },
-            Transcode::Latin1ToUtf16 => "latin1_to_utf16",
-            Transcode::Latin1ToUtf8 => "latin1_to_utf8",
-            Transcode::Utf16ToCompactProbablyUtf16 => "utf16_to_compact_probably_utf16",
-            Transcode::Utf16ToCompactUtf16 => "utf16_to_compact_utf16",
-            Transcode::Utf16ToLatin1 => "utf16_to_latin1",
-            Transcode::Utf16ToUtf8 => "utf16_to_utf8",
-            Transcode::Utf8ToCompactUtf16 => "utf8_to_compact_utf16",
-            Transcode::Utf8ToLatin1 => "utf8_to_latin1",
-            Transcode::Utf8ToUtf16 => "utf8_to_utf16",
-        }
-    }
-}
-
-#[derive(Debug, Copy, Clone, Hash, Eq, PartialEq, Serialize, Deserialize)]
-#[allow(missing_docs)]
-pub enum FixedEncoding {
-    Utf8,
-    Utf16,
-    Latin1,
-}
-
 impl Transcoder {
     pub fn name(&self) -> String {
         format!(
@@ -115,7 +67,7 @@ impl Transcoder {
             }
 
             // The initial step of transcoding from a fixed format to a compact
-            // format. Takes the ptr/len of the source the the destination
+            // format. Takes the ptr/len of the source the destination
             // pointer. The destination length is implicitly the same. Returns
             // how many code units were consumed in the source, which is also
             // how many bytes were written to the destination.
@@ -136,33 +88,3 @@ impl Transcoder {
         EntityType::Function(ty)
     }
 }
-
-impl Transcode {
-    /// Returns a human-readable description for this transcoding operation.
-    pub fn desc(&self) -> &'static str {
-        match self {
-            Transcode::Copy(FixedEncoding::Utf8) => "utf8-to-utf8",
-            Transcode::Copy(FixedEncoding::Utf16) => "utf16-to-utf16",
-            Transcode::Copy(FixedEncoding::Latin1) => "latin1-to-latin1",
-            Transcode::Latin1ToUtf16 => "latin1-to-utf16",
-            Transcode::Latin1ToUtf8 => "latin1-to-utf8",
-            Transcode::Utf16ToCompactProbablyUtf16 => "utf16-to-compact-probably-utf16",
-            Transcode::Utf16ToCompactUtf16 => "utf16-to-compact-utf16",
-            Transcode::Utf16ToLatin1 => "utf16-to-latin1",
-            Transcode::Utf16ToUtf8 => "utf16-to-utf8",
-            Transcode::Utf8ToCompactUtf16 => "utf8-to-compact-utf16",
-            Transcode::Utf8ToLatin1 => "utf8-to-latin1",
-            Transcode::Utf8ToUtf16 => "utf8-to-utf16",
-        }
-    }
-}
-
-impl FixedEncoding {
-    pub(crate) fn width(&self) -> u8 {
-        match self {
-            FixedEncoding::Utf8 => 1,
-            FixedEncoding::Utf16 => 2,
-            FixedEncoding::Latin1 => 1,
-        }
-    }
-}
diff --git a/crates/environ/src/fact/traps.rs b/crates/environ/src/fact/traps.rs
index e68bccfc13d5..28f1057f04b3 100644
--- a/crates/environ/src/fact/traps.rs
+++ b/crates/environ/src/fact/traps.rs
@@ -18,6 +18,7 @@
 //! This information is currently encoded as a custom section in the wasm
 //! module.
 
+use crate::prelude::*;
 use std::collections::HashMap;
 use std::fmt;
 use wasm_encoder::Encode;
@@ -109,7 +110,7 @@ impl fmt::Display for Trap {
             Trap::ListByteLengthOverflow => "byte size of list too large for i32".fmt(f),
             Trap::StringLengthTooBig => "string byte size exceeds maximum".fmt(f),
             Trap::StringLengthOverflow => "string byte size overflows i32".fmt(f),
-            Trap::AssertFailed(s) => write!(f, "assertion failure: {}", s),
+            Trap::AssertFailed(s) => write!(f, "assertion failure: {s}"),
         }
     }
 }
diff --git a/crates/environ/src/gc.rs b/crates/environ/src/gc.rs
new file mode 100644
index 000000000000..c28bfcff8e6f
--- /dev/null
+++ b/crates/environ/src/gc.rs
@@ -0,0 +1,125 @@
+//! Target- and pointer-width-agnostic definitions of GC-related types and
+//! constants.
+//!
+//! These definitions are suitable for use both during compilation and at
+//! runtime.
+//!
+//! Note: We don't bother gating these on `cfg(feature = "gc")` because that
+//! makes downstream uses pretty annoying, and the primary thing we want to gate
+//! on our various `gc` cargo features is the actual garbage collection
+//! functions and their associated impact on binary size anyways.
+
+/// Discriminant to check whether GC reference is an `i31ref` or not.
+pub const I31_DISCRIMINANT: u64 = 1;
+
+/// A mask that can be used to check for non-null and non-i31ref GC references
+/// with a single bitwise-and operation.
+pub const NON_NULL_NON_I31_MASK: u64 = !I31_DISCRIMINANT;
+
+/// The kind of an object in a GC heap.
+///
+/// Note that this type is accessed from Wasm JIT code.
+///
+/// `VMGcKind` is a bitset where to test if `a` is a subtype of an
+/// "abstract-ish" type `b`, we can simply use a single bitwise-and operation:
+///
+/// ```ignore
+/// a <: b   iff   a & b == b
+/// ```
+///
+/// For example, because `VMGcKind::AnyRef` has the high bit set, every kind
+/// representing some subtype of `anyref` also has its high bit set.
+///
+/// We say "abstract-ish" type because in addition to the abstract heap types
+/// (other than `i31`) we also have variants for `externref`s that have been
+/// converted into an `anyref` via `extern.convert_any` and `externref`s that
+/// have been converted into an `anyref` via `any.convert_extern`. Note that in
+/// the latter case, because `any.convert_extern $foo` produces a value that is
+/// not an instance of `eqref`, `VMGcKind::AnyOfExternRef & VMGcKind::EqRef !=
+/// VMGcKind::EqRef`.
+///
+/// Furthermore, this type only uses the highest 6 bits of its `u32`
+/// representation, allowing the lower 26 bytes to be bitpacked with other stuff
+/// as users see fit.
+#[repr(u32)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[rustfmt::skip]
+#[allow(missing_docs)]
+pub enum VMGcKind {
+    ExternRef      = 0b010000 << 26,
+    ExternOfAnyRef = 0b011000 << 26,
+    AnyRef         = 0b100000 << 26,
+    AnyOfExternRef = 0b100100 << 26,
+    EqRef          = 0b101000 << 26,
+    ArrayRef       = 0b101001 << 26,
+    StructRef      = 0b101010 << 26,
+}
+
+impl VMGcKind {
+    /// Mask this value with a `u32` to get just the bits that `VMGcKind` uses.
+    pub const MASK: u32 = 0b111111 << 26;
+
+    /// Mask this value with a `u32` that potentially contains a `VMGcKind` to
+    /// get the bits that `VMGcKind` doesn't use.
+    pub const UNUSED_MASK: u32 = !Self::MASK;
+
+    /// Convert the given value into a `VMGcKind` by masking off the unused
+    /// bottom bits.
+    pub fn from_high_bits_of_u32(val: u32) -> VMGcKind {
+        let masked = val & Self::MASK;
+        match masked {
+            x if x == Self::ExternRef as u32 => Self::ExternRef,
+            x if x == Self::ExternOfAnyRef as u32 => Self::ExternOfAnyRef,
+            x if x == Self::AnyRef as u32 => Self::AnyRef,
+            x if x == Self::AnyOfExternRef as u32 => Self::AnyOfExternRef,
+            x if x == Self::EqRef as u32 => Self::EqRef,
+            x if x == Self::ArrayRef as u32 => Self::ArrayRef,
+            x if x == Self::StructRef as u32 => Self::StructRef,
+            _ => panic!("invalid `VMGcKind`: {masked:#032b}"),
+        }
+    }
+
+    /// Does this kind match the other kind?
+    ///
+    /// That is, is this kind a subtype of the other kind?
+    pub fn matches(self, other: Self) -> bool {
+        (self as u32) & (other as u32) == (other as u32)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::VMGcKind::*;
+    use crate::prelude::*;
+
+    #[test]
+    fn kind_matches() {
+        let all = [
+            ExternRef,
+            ExternOfAnyRef,
+            AnyRef,
+            AnyOfExternRef,
+            EqRef,
+            ArrayRef,
+            StructRef,
+        ];
+
+        for (sup, subs) in [
+            (ExternRef, vec![ExternOfAnyRef]),
+            (ExternOfAnyRef, vec![]),
+            (AnyRef, vec![AnyOfExternRef, EqRef, ArrayRef, StructRef]),
+            (AnyOfExternRef, vec![]),
+            (EqRef, vec![ArrayRef, StructRef]),
+            (ArrayRef, vec![]),
+            (StructRef, vec![]),
+        ] {
+            assert!(sup.matches(sup));
+            for sub in &subs {
+                assert!(sub.matches(sup));
+            }
+            for kind in all.iter().filter(|k| **k != sup && !subs.contains(k)) {
+                assert!(!kind.matches(sup));
+            }
+        }
+    }
+}
diff --git a/crates/environ/src/lib.rs b/crates/environ/src/lib.rs
index be32c25b5c23..7768330b736f 100644
--- a/crates/environ/src/lib.rs
+++ b/crates/environ/src/lib.rs
@@ -3,14 +3,23 @@
 //! the translation the base addresses of regions of memory that will hold the globals, tables and
 //! linear memories.
 
-#![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)]
-#![warn(unused_import_braces)]
+#![deny(missing_docs)]
+#![warn(clippy::cast_sign_loss)]
+#![no_std]
+
+#[cfg(feature = "std")]
+#[macro_use]
+extern crate std;
+extern crate alloc;
+
+pub use wasmtime_types::prelude;
 
 mod address_map;
 mod builtin;
-mod compilation;
+mod demangling;
+mod gc;
 mod module;
-mod module_environ;
+mod module_artifacts;
 mod module_types;
 pub mod obj;
 mod ref_bits;
@@ -22,21 +31,27 @@ mod vmoffsets;
 
 pub use crate::address_map::*;
 pub use crate::builtin::*;
-pub use crate::compilation::*;
+pub use crate::demangling::*;
+pub use crate::gc::*;
 pub use crate::module::*;
-pub use crate::module_environ::*;
+pub use crate::module_artifacts::*;
 pub use crate::module_types::*;
 pub use crate::ref_bits::*;
 pub use crate::scopevec::ScopeVec;
 pub use crate::stack_map::StackMap;
 pub use crate::trap_encoding::*;
-pub use crate::tunables::Tunables;
+pub use crate::tunables::*;
 pub use crate::vmoffsets::*;
 pub use object;
 
+#[cfg(feature = "compile")]
+mod compile;
+#[cfg(feature = "compile")]
+pub use crate::compile::*;
+
 #[cfg(feature = "component-model")]
 pub mod component;
-#[cfg(feature = "component-model")]
+#[cfg(all(feature = "component-model", feature = "compile"))]
 pub mod fact;
 
 // Reexport all of these type-level since they're quite commonly used and it's
@@ -45,15 +60,5 @@ pub mod fact;
 pub use cranelift_entity::*;
 pub use wasmtime_types::*;
 
-/// WebAssembly page sizes are defined to be 64KiB.
-pub const WASM_PAGE_SIZE: u32 = 0x10000;
-
-/// The number of pages (for 32-bit modules) we can have before we run out of
-/// byte index space.
-pub const WASM32_MAX_PAGES: u64 = 1 << 16;
-/// The number of pages (for 64-bit modules) we can have before we run out of
-/// byte index space.
-pub const WASM64_MAX_PAGES: u64 = 1 << 48;
-
 /// Version number of this crate.
 pub const VERSION: &str = env!("CARGO_PKG_VERSION");
diff --git a/crates/environ/src/module.rs b/crates/environ/src/module.rs
index 5bce7ae16134..e983333c3326 100644
--- a/crates/environ/src/module.rs
+++ b/crates/environ/src/module.rs
@@ -1,13 +1,11 @@
 //! Data structures for representing decoded wasm modules.
 
-use crate::{ModuleTranslation, PrimaryMap, Tunables, WasmHeapType, WASM_PAGE_SIZE};
+use crate::prelude::*;
+use crate::{PrimaryMap, Tunables};
+use alloc::collections::BTreeMap;
+use core::ops::Range;
 use cranelift_entity::{packed_option::ReservedValue, EntityRef};
-use indexmap::IndexMap;
 use serde_derive::{Deserialize, Serialize};
-use std::collections::BTreeMap;
-use std::convert::TryFrom;
-use std::mem;
-use std::ops::Range;
 use wasmtime_types::*;
 
 /// Implementation styles for WebAssembly linear memory.
@@ -20,39 +18,45 @@ pub enum MemoryStyle {
     },
     /// Address space is allocated up front.
     Static {
-        /// The number of mapped and unmapped pages.
-        bound: u64,
+        /// The number of bytes which are reserved for this linear memory. Only
+        /// the lower bytes which represent the actual linear memory need be
+        /// mapped, but other bytes must be guaranteed to be unmapped.
+        byte_reservation: u64,
     },
 }
 
 impl MemoryStyle {
     /// Decide on an implementation style for the given `Memory`.
     pub fn for_memory(memory: Memory, tunables: &Tunables) -> (Self, u64) {
-        // 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 when not
-        // requested to use the static memory bound itself as the maximum.
-        let absolute_max_pages = if memory.memory64 {
-            crate::WASM64_MAX_PAGES
-        } else {
-            crate::WASM32_MAX_PAGES
-        };
-        let maximum = std::cmp::min(
-            memory.maximum.unwrap_or(absolute_max_pages),
-            if tunables.static_memory_bound_is_maximum {
-                std::cmp::min(tunables.static_memory_bound, absolute_max_pages)
-            } else {
-                absolute_max_pages
-            },
-        );
+        let is_static =
+            // Ideally we would compare against (an upper bound on) the target's
+            // page size, but unfortunately that is a little hard to plumb
+            // through here.
+            memory.page_size_log2 >= Memory::DEFAULT_PAGE_SIZE_LOG2
+            && match memory.maximum_byte_size() {
+                Ok(mut maximum) => {
+                    if tunables.static_memory_bound_is_maximum {
+                        maximum = maximum.min(tunables.static_memory_reservation);
+                    }
 
-        // Ensure the minimum is less than the maximum; the minimum might exceed the maximum
-        // when the memory is artificially bounded via `static_memory_bound_is_maximum` above
-        if memory.minimum <= maximum && maximum <= tunables.static_memory_bound {
+                    // Ensure the minimum is less than the maximum; the minimum might exceed the maximum
+                    // when the memory is artificially bounded via `static_memory_bound_is_maximum` above
+                    memory.minimum_byte_size().unwrap() <= maximum
+                        && maximum <= tunables.static_memory_reservation
+                }
+
+                // If the maximum size of this memory is not representable with
+                // `u64` then use the `static_memory_bound_is_maximum` to indicate
+                // whether it's a static memory or not. It should be ok to discard
+                // the linear memory's maximum size here as growth to the maximum is
+                // always fallible and never guaranteed.
+                Err(_) => tunables.static_memory_bound_is_maximum,
+            };
+
+        if is_static {
             return (
                 Self::Static {
-                    bound: tunables.static_memory_bound,
+                    byte_reservation: tunables.static_memory_reservation,
                 },
                 tunables.static_memory_offset_guard_size,
             );
@@ -104,10 +108,8 @@ impl MemoryPlan {
 pub struct MemoryInitializer {
     /// The index of a linear memory to initialize.
     pub memory_index: MemoryIndex,
-    /// Optionally, a global variable giving a base index.
-    pub base: Option<GlobalIndex>,
-    /// The offset to add to the base.
-    pub offset: u64,
+    /// The base offset to start this segment at.
+    pub offset: ConstExpr,
     /// The range of the data to write within the linear memory.
     ///
     /// This range indexes into a separately stored data section which will be
@@ -180,340 +182,6 @@ pub enum MemoryInitialization {
     },
 }
 
-impl ModuleTranslation<'_> {
-    /// Attempts to convert segmented memory initialization into static
-    /// initialization for the module that this translation represents.
-    ///
-    /// If this module's memory initialization is not compatible with paged
-    /// initialization then this won't change anything. Otherwise if it is
-    /// compatible then the `memory_initialization` field will be updated.
-    ///
-    /// Takes a `page_size` argument in order to ensure that all
-    /// initialization is page-aligned for mmap-ability, and
-    /// `max_image_size_always_allowed` to control how we decide
-    /// whether to use static init.
-    ///
-    /// We will try to avoid generating very sparse images, which are
-    /// possible if e.g. a module has an initializer at offset 0 and a
-    /// very high offset (say, 1 GiB). To avoid this, we use a dual
-    /// condition: we always allow images less than
-    /// `max_image_size_always_allowed`, and the embedder of Wasmtime
-    /// can set this if desired to ensure that static init should
-    /// always be done if the size of the module or its heaps is
-    /// otherwise bounded by the system. We also allow images with
-    /// static init data bigger than that, but only if it is "dense",
-    /// defined as having at least half (50%) of its pages with some
-    /// data.
-    ///
-    /// We could do something slightly better by building a dense part
-    /// and keeping a sparse list of outlier/leftover segments (see
-    /// issue #3820). This would also allow mostly-static init of
-    /// modules that have some dynamically-placed data segments. But,
-    /// for now, this is sufficient to allow a system that "knows what
-    /// it's doing" to always get static init.
-    pub fn try_static_init(&mut self, page_size: u64, max_image_size_always_allowed: u64) {
-        // This method only attempts to transform a `Segmented` memory init
-        // into a `Static` one, no other state.
-        if !self.module.memory_initialization.is_segmented() {
-            return;
-        }
-
-        // First a dry run of memory initialization is performed. This
-        // collects information about the extent of memory initialized for each
-        // memory as well as the size of all data segments being copied in.
-        struct Memory {
-            data_size: u64,
-            min_addr: u64,
-            max_addr: u64,
-            // The `usize` here is a pointer into `self.data` which is the list
-            // of data segments corresponding to what was found in the original
-            // wasm module.
-            segments: Vec<(usize, StaticMemoryInitializer)>,
-        }
-        let mut info = PrimaryMap::with_capacity(self.module.memory_plans.len());
-        for _ in 0..self.module.memory_plans.len() {
-            info.push(Memory {
-                data_size: 0,
-                min_addr: u64::MAX,
-                max_addr: 0,
-                segments: Vec::new(),
-            });
-        }
-        let mut idx = 0;
-        let ok = self.module.memory_initialization.init_memory(
-            &mut (),
-            InitMemory::CompileTime(&self.module),
-            |(), memory, init| {
-                // Currently `Static` only applies to locally-defined memories,
-                // so if a data segment references an imported memory then
-                // transitioning to a `Static` memory initializer is not
-                // possible.
-                if self.module.defined_memory_index(memory).is_none() {
-                    return false;
-                };
-                let info = &mut info[memory];
-                let data_len = u64::from(init.data.end - init.data.start);
-                if data_len > 0 {
-                    info.data_size += data_len;
-                    info.min_addr = info.min_addr.min(init.offset);
-                    info.max_addr = info.max_addr.max(init.offset + data_len);
-                    info.segments.push((idx, init.clone()));
-                }
-                idx += 1;
-                true
-            },
-        );
-        if !ok {
-            return;
-        }
-
-        // Validate that the memory information collected is indeed valid for
-        // static memory initialization.
-        for info in info.values().filter(|i| i.data_size > 0) {
-            let image_size = info.max_addr - info.min_addr;
-
-            // If the range of memory being initialized is less than twice the
-            // total size of the data itself then it's assumed that static
-            // initialization is ok. This means we'll at most double memory
-            // consumption during the memory image creation process, which is
-            // currently assumed to "probably be ok" but this will likely need
-            // tweaks over time.
-            if image_size < info.data_size.saturating_mul(2) {
-                continue;
-            }
-
-            // If the memory initialization image is larger than the size of all
-            // data, then we still allow memory initialization if the image will
-            // be of a relatively modest size, such as 1MB here.
-            if image_size < max_image_size_always_allowed {
-                continue;
-            }
-
-            // At this point memory initialization is concluded to be too
-            // expensive to do at compile time so it's entirely deferred to
-            // happen at runtime.
-            return;
-        }
-
-        // Here's where we've now committed to changing to static memory. The
-        // memory initialization image is built here from the page data and then
-        // it's converted to a single initializer.
-        let data = mem::replace(&mut self.data, Vec::new());
-        let mut map = PrimaryMap::with_capacity(info.len());
-        let mut module_data_size = 0u32;
-        for (memory, info) in info.iter() {
-            // Create the in-memory `image` which is the initialized contents of
-            // this linear memory.
-            let extent = if info.segments.len() > 0 {
-                (info.max_addr - info.min_addr) as usize
-            } else {
-                0
-            };
-            let mut image = Vec::with_capacity(extent);
-            for (idx, init) in info.segments.iter() {
-                let data = &data[*idx];
-                assert_eq!(data.len(), init.data.len());
-                let offset = usize::try_from(init.offset - info.min_addr).unwrap();
-                if image.len() < offset {
-                    image.resize(offset, 0u8);
-                    image.extend_from_slice(data);
-                } else {
-                    image.splice(
-                        offset..(offset + data.len()).min(image.len()),
-                        data.iter().copied(),
-                    );
-                }
-            }
-            assert_eq!(image.len(), extent);
-            assert_eq!(image.capacity(), extent);
-            let mut offset = if info.segments.len() > 0 {
-                info.min_addr
-            } else {
-                0
-            };
-
-            // Chop off trailing zeros from the image as memory is already
-            // zero-initialized. Note that `i` is the position of a nonzero
-            // entry here, so to not lose it we truncate to `i + 1`.
-            if let Some(i) = image.iter().rposition(|i| *i != 0) {
-                image.truncate(i + 1);
-            }
-
-            // Also chop off leading zeros, if any.
-            if let Some(i) = image.iter().position(|i| *i != 0) {
-                offset += i as u64;
-                image.drain(..i);
-            }
-            let mut len = u64::try_from(image.len()).unwrap();
-
-            // The goal is to enable mapping this image directly into memory, so
-            // the offset into linear memory must be a multiple of the page
-            // size. If that's not already the case then the image is padded at
-            // the front and back with extra zeros as necessary
-            if offset % page_size != 0 {
-                let zero_padding = offset % page_size;
-                self.data.push(vec![0; zero_padding as usize].into());
-                offset -= zero_padding;
-                len += zero_padding;
-            }
-            self.data.push(image.into());
-            if len % page_size != 0 {
-                let zero_padding = page_size - (len % page_size);
-                self.data.push(vec![0; zero_padding as usize].into());
-                len += zero_padding;
-            }
-
-            // Offset/length should now always be page-aligned.
-            assert!(offset % page_size == 0);
-            assert!(len % page_size == 0);
-
-            // Create the `StaticMemoryInitializer` which describes this image,
-            // only needed if the image is actually present and has a nonzero
-            // length. The `offset` has been calculates above, originally
-            // sourced from `info.min_addr`. The `data` field is the extent
-            // within the final data segment we'll emit to an ELF image, which
-            // is the concatenation of `self.data`, so here it's the size of
-            // the section-so-far plus the current segment we're appending.
-            let len = u32::try_from(len).unwrap();
-            let init = if len > 0 {
-                Some(StaticMemoryInitializer {
-                    offset,
-                    data: module_data_size..module_data_size + len,
-                })
-            } else {
-                None
-            };
-            let idx = map.push(init);
-            assert_eq!(idx, memory);
-            module_data_size += len;
-        }
-        self.data_align = Some(page_size);
-        self.module.memory_initialization = MemoryInitialization::Static { map };
-    }
-
-    /// Attempts to convert the module's table initializers to
-    /// FuncTable form where possible. This enables lazy table
-    /// initialization later by providing a one-to-one map of initial
-    /// table values, without having to parse all segments.
-    pub fn try_func_table_init(&mut self) {
-        // This should be large enough to support very large Wasm
-        // modules with huge funcref tables, but small enough to avoid
-        // OOMs or DoS on truly sparse tables.
-        const MAX_FUNC_TABLE_SIZE: u32 = 1024 * 1024;
-
-        // First convert any element-initialized tables to images of just that
-        // single function if the minimum size of the table allows doing so.
-        for ((_, init), (_, plan)) in self
-            .module
-            .table_initialization
-            .initial_values
-            .iter_mut()
-            .zip(
-                self.module
-                    .table_plans
-                    .iter()
-                    .skip(self.module.num_imported_tables),
-            )
-        {
-            let table_size = plan.table.minimum;
-            if table_size > MAX_FUNC_TABLE_SIZE {
-                continue;
-            }
-            if let TableInitialValue::FuncRef(val) = *init {
-                *init = TableInitialValue::Null {
-                    precomputed: vec![val; table_size as usize],
-                };
-            }
-        }
-
-        let mut segments = mem::take(&mut self.module.table_initialization.segments)
-            .into_iter()
-            .peekable();
-
-        // The goal of this loop is to interpret a table segment and apply it
-        // "statically" to a local table. This will iterate over segments and
-        // apply them one-by-one to each table.
-        //
-        // If any segment can't be applied, however, then this loop exits and
-        // all remaining segments are placed back into the segment list. This is
-        // because segments are supposed to be initialized one-at-a-time which
-        // means that intermediate state is visible with respect to traps. If
-        // anything isn't statically known to not trap it's pessimistically
-        // assumed to trap meaning all further segment initializers must be
-        // applied manually at instantiation time.
-        while let Some(segment) = segments.peek() {
-            let defined_index = match self.module.defined_table_index(segment.table_index) {
-                Some(index) => index,
-                // Skip imported tables: we can't provide a preconstructed
-                // table for them, because their values depend on the
-                // imported table overlaid with whatever segments we have.
-                None => break,
-            };
-
-            // If the base of this segment is dynamic, then we can't
-            // include it in the statically-built array of initial
-            // contents.
-            if segment.base.is_some() {
-                break;
-            }
-
-            // Get the end of this segment. If out-of-bounds, or too
-            // large for our dense table representation, then skip the
-            // segment.
-            let top = match segment.offset.checked_add(segment.elements.len() as u32) {
-                Some(top) => top,
-                None => break,
-            };
-            let table_size = self.module.table_plans[segment.table_index].table.minimum;
-            if top > table_size || top > MAX_FUNC_TABLE_SIZE {
-                break;
-            }
-
-            match self.module.table_plans[segment.table_index]
-                .table
-                .wasm_ty
-                .heap_type
-            {
-                WasmHeapType::Func | WasmHeapType::TypedFunc(_) => {}
-                // If this is not a funcref table, then we can't support a
-                // pre-computed table of function indices. Technically this
-                // initializer won't trap so we could continue processing
-                // segments, but that's left as a future optimization if
-                // necessary.
-                WasmHeapType::Extern => break,
-            }
-
-            let precomputed =
-                match &mut self.module.table_initialization.initial_values[defined_index] {
-                    TableInitialValue::Null { precomputed } => precomputed,
-
-                    // If this table is still listed as an initial value here
-                    // then that means the initial size of the table doesn't
-                    // support a precomputed function list, so skip this.
-                    // Technically this won't trap so it's possible to process
-                    // further initializers, but that's left as a future
-                    // optimization.
-                    TableInitialValue::FuncRef(_) => break,
-                };
-
-            // At this point we're committing to pre-initializing the table
-            // with the `segment` that's being iterated over. This segment is
-            // applied to the `precomputed` list for the table by ensuring
-            // it's large enough to hold the segment and then copying the
-            // segment into the precomputed list.
-            if precomputed.len() < top as usize {
-                precomputed.resize(top as usize, FuncIndex::reserved_value());
-            }
-            let dst = &mut precomputed[(segment.offset as usize)..(top as usize)];
-            dst.copy_from_slice(&segment.elements[..]);
-
-            // advance the iterator to see the next segment
-            let _ = segments.next();
-        }
-        self.module.table_initialization.segments = segments.collect();
-    }
-}
-
 impl Default for MemoryInitialization {
     fn default() -> Self {
         Self::Segmented(Vec::new())
@@ -537,24 +205,6 @@ impl MemoryInitialization {
     /// only be called as part of initialization, however, as it's structured to
     /// allow learning about memory ahead-of-time at compile time possibly.
     ///
-    /// The various callbacks provided here are used to drive the smaller bits
-    /// of initialization, such as:
-    ///
-    /// * `get_cur_size_in_pages` - gets the current size, in wasm pages, of the
-    ///   memory specified. For compile-time purposes this would be the memory
-    ///   type's minimum size.
-    ///
-    /// * `get_global` - gets the value of the global specified. This is
-    ///   statically, via validation, a pointer to the global of the correct
-    ///   type (either u32 or u64 depending on the memory), but the value
-    ///   returned here is `u64`. A `None` value can be returned to indicate
-    ///   that the global's value isn't known yet.
-    ///
-    /// * `write` - a callback used to actually write data. This indicates that
-    ///   the specified memory must receive the specified range of data at the
-    ///   specified offset. This can internally return an false error if it
-    ///   wants to fail.
-    ///
     /// This function will return true if all memory initializers are processed
     /// successfully. If any initializer hits an error or, for example, a
     /// global value is needed but `None` is returned, then false will be
@@ -562,12 +212,7 @@ impl MemoryInitialization {
     /// question needs to be deferred to runtime, and at runtime this means
     /// that an invalid initializer has been found and a trap should be
     /// generated.
-    pub fn init_memory<T>(
-        &self,
-        state: &mut T,
-        init: InitMemory<'_, T>,
-        mut write: impl FnMut(&mut T, MemoryIndex, &StaticMemoryInitializer) -> bool,
-    ) -> bool {
+    pub fn init_memory(&self, state: &mut dyn InitMemory) -> bool {
         let initializers = match self {
             // Fall through below to the segmented memory one-by-one
             // initialization.
@@ -581,7 +226,7 @@ impl MemoryInitialization {
             MemoryInitialization::Static { map } => {
                 for (index, init) in map {
                     if let Some(init) = init {
-                        let result = write(state, index, init);
+                        let result = state.write(index, init);
                         if !result {
                             return result;
                         }
@@ -592,28 +237,18 @@ impl MemoryInitialization {
         };
 
         for initializer in initializers {
-            let MemoryInitializer {
+            let &MemoryInitializer {
                 memory_index,
-                base,
-                offset,
+                ref offset,
                 ref data,
-            } = *initializer;
+            } = initializer;
 
             // First up determine the start/end range and verify that they're
             // in-bounds for the initial size of the memory at `memory_index`.
             // Note that this can bail if we don't have access to globals yet
             // (e.g. this is a task happening before instantiation at
             // compile-time).
-            let base = match base {
-                Some(index) => match &init {
-                    InitMemory::Runtime {
-                        get_global_as_u64, ..
-                    } => get_global_as_u64(state, index),
-                    InitMemory::CompileTime(_) => return false,
-                },
-                None => 0,
-            };
-            let start = match base.checked_add(offset) {
+            let start = match state.eval_offset(memory_index, offset) {
                 Some(start) => start,
                 None => return false,
             };
@@ -623,28 +258,20 @@ impl MemoryInitialization {
                 None => return false,
             };
 
-            let cur_size_in_pages = match &init {
-                InitMemory::CompileTime(module) => module.memory_plans[memory_index].memory.minimum,
-                InitMemory::Runtime {
-                    memory_size_in_pages,
-                    ..
-                } => memory_size_in_pages(state, memory_index),
-            };
-
-            // Note that this `minimum` can overflow if `minimum` is
-            // `1 << 48`, the maximum number of minimum pages for 64-bit
-            // memories. If this overflow happens, though, then there's no need
-            // to check the `end` value since `end` fits in a `u64` and it is
-            // naturally less than the overflowed value.
-            //
-            // This is a bit esoteric though because it's impossible to actually
-            // create a memory of `u64::MAX + 1` bytes, so this is largely just
-            // here to avoid having the multiplication here overflow in debug
-            // mode.
-            if let Some(max) = cur_size_in_pages.checked_mul(u64::from(WASM_PAGE_SIZE)) {
-                if end > max {
-                    return false;
+            match state.memory_size_in_bytes(memory_index) {
+                Ok(max) => {
+                    if end > max {
+                        return false;
+                    }
                 }
+
+                // Note that computing the minimum can overflow if the page size
+                // is the default 64KiB and the memory's minimum size in pages
+                // is `1 << 48`, the maximum number of minimum pages for 64-bit
+                // memories. We don't return `false` to signal an error here and
+                // instead defer the error to runtime, when it will be
+                // impossible to allocate that much memory anyways.
+                Err(_) => {}
             }
 
             // The limits of the data segment have been validated at this point
@@ -654,7 +281,7 @@ impl MemoryInitialization {
                 offset: start,
                 data: data.clone(),
             };
-            let result = write(state, memory_index, &init);
+            let result = state.write(memory_index, &init);
             if !result {
                 return result;
             }
@@ -664,38 +291,42 @@ impl MemoryInitialization {
     }
 }
 
-/// Argument to [`MemoryInitialization::init_memory`] indicating the current
-/// status of the instance.
-pub enum InitMemory<'a, T> {
-    /// This evaluation of memory initializers is happening at compile time.
-    /// This means that the current state of memories is whatever their initial
-    /// state is, and additionally globals are not available if data segments
-    /// have global offsets.
-    CompileTime(&'a Module),
-
-    /// Evaluation of memory initializers is happening at runtime when the
-    /// instance is available, and callbacks are provided to learn about the
-    /// instance's state.
-    Runtime {
-        /// Returns the size, in wasm pages, of the the memory specified.
-        memory_size_in_pages: &'a dyn Fn(&mut T, MemoryIndex) -> u64,
-        /// Returns the value of the global, as a `u64`. Note that this may
-        /// involve zero-extending a 32-bit global to a 64-bit number.
-        get_global_as_u64: &'a dyn Fn(&mut T, GlobalIndex) -> u64,
-    },
+/// The various callbacks provided here are used to drive the smaller bits of
+/// memory initialization.
+pub trait InitMemory {
+    /// Returns the size, in bytes, of the memory specified. For compile-time
+    /// purposes this would be the memory type's minimum size.
+    fn memory_size_in_bytes(&mut self, memory_index: MemoryIndex) -> Result<u64, SizeOverflow>;
+
+    /// Returns the value of the constant expression, as a `u64`. Note that
+    /// this may involve zero-extending a 32-bit global to a 64-bit number. May
+    /// return `None` to indicate that the expression involves a value which is
+    /// not available yet.
+    fn eval_offset(&mut self, memory_index: MemoryIndex, expr: &ConstExpr) -> Option<u64>;
+
+    /// A callback used to actually write data. This indicates that the
+    /// specified memory must receive the specified range of data at the
+    /// specified offset. This can return false on failure.
+    fn write(&mut self, memory_index: MemoryIndex, init: &StaticMemoryInitializer) -> bool;
 }
 
 /// Implementation styles for WebAssembly tables.
 #[derive(Debug, Clone, Hash, Serialize, Deserialize)]
 pub enum TableStyle {
     /// Signatures are stored in the table and checked in the caller.
-    CallerChecksSignature,
+    CallerChecksSignature {
+        /// Whether this table is initialized lazily and requires an
+        /// initialization check on every access.
+        lazy_init: bool,
+    },
 }
 
 impl TableStyle {
     /// Decide on an implementation style for the given `Table`.
-    pub fn for_table(_table: Table, _tunables: &Tunables) -> Self {
-        Self::CallerChecksSignature
+    pub fn for_table(_table: Table, tunables: &Tunables) -> Self {
+        Self::CallerChecksSignature {
+            lazy_init: tunables.table_lazy_init,
+        }
     }
 }
 
@@ -754,10 +385,8 @@ pub enum TableInitialValue {
         /// case the elements are initialized to null.
         precomputed: Vec<FuncIndex>,
     },
-
-    /// Initialize each table element to the function reference given
-    /// by the `FuncIndex`.
-    FuncRef(FuncIndex),
+    /// An arbitrary const expression.
+    Expr(ConstExpr),
 }
 
 /// A WebAssembly table initializer segment.
@@ -765,30 +394,29 @@ pub enum TableInitialValue {
 pub struct TableSegment {
     /// The index of a table to initialize.
     pub table_index: TableIndex,
-    /// Optionally, a global variable giving a base index.
-    pub base: Option<GlobalIndex>,
-    /// The offset to add to the base.
-    pub offset: u32,
+    /// The base offset to start this segment at.
+    pub offset: ConstExpr,
     /// The values to write into the table elements.
-    pub elements: Box<[FuncIndex]>,
+    pub elements: TableSegmentElements,
 }
 
-/// Different types that can appear in a module.
-///
-/// Note that each of these variants are intended to index further into a
-/// separate table.
-#[derive(Debug, Copy, Clone, Serialize, Deserialize)]
-#[allow(missing_docs)]
-pub enum ModuleType {
-    Function(SignatureIndex),
+/// Elements of a table segment, either a list of functions or list of arbitrary
+/// expressions.
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum TableSegmentElements {
+    /// A sequential list of functions where `FuncIndex::reserved_value()`
+    /// indicates a null function.
+    Functions(Box<[FuncIndex]>),
+    /// Arbitrary expressions, aka either functions, null or a load of a global.
+    Expressions(Box<[ConstExpr]>),
 }
 
-impl ModuleType {
-    /// Asserts this is a `ModuleType::Function`, returning the underlying
-    /// `SignatureIndex`.
-    pub fn unwrap_function(&self) -> SignatureIndex {
+impl TableSegmentElements {
+    /// Returns the number of elements in this segment.
+    pub fn len(&self) -> u32 {
         match self {
-            ModuleType::Function(f) => *f,
+            Self::Functions(s) => s.len() as u32,
+            Self::Expressions(s) => s.len() as u32,
         }
     }
 }
@@ -816,7 +444,7 @@ pub struct Module {
     pub memory_initialization: MemoryInitialization,
 
     /// WebAssembly passive elements.
-    pub passive_elements: Vec<Box<[FuncIndex]>>,
+    pub passive_elements: Vec<TableSegmentElements>,
 
     /// The map from passive element index (element segment index space) to index in `passive_elements`.
     pub passive_elements_map: BTreeMap<ElemIndex, usize>,
@@ -825,7 +453,7 @@ pub struct Module {
     pub passive_data_map: BTreeMap<DataIndex, Range<u32>>,
 
     /// Types declared in the wasm module.
-    pub types: PrimaryMap<TypeIndex, ModuleType>,
+    pub types: PrimaryMap<TypeIndex, ModuleInternedTypeIndex>,
 
     /// Number of imported or aliased functions in the module.
     pub num_imported_funcs: usize,
@@ -846,6 +474,9 @@ pub struct Module {
     /// an `func_ref` index (and is the maximum func_ref index).
     pub num_escaped_funcs: usize,
 
+    /// Number of call-indirect caches.
+    pub num_call_indirect_caches: usize,
+
     /// Types of functions, imported and local.
     pub functions: PrimaryMap<FuncIndex, FunctionType>,
 
@@ -859,7 +490,7 @@ pub struct Module {
     pub globals: PrimaryMap<GlobalIndex, Global>,
 
     /// WebAssembly global initializers for locally-defined globals.
-    pub global_initializers: PrimaryMap<DefinedGlobalIndex, GlobalInit>,
+    pub global_initializers: PrimaryMap<DefinedGlobalIndex, ConstExpr>,
 }
 
 /// Initialization routines for creating an instance, encompassing imports,
@@ -1022,38 +653,26 @@ impl Module {
             EntityIndex::Global(i) => EntityType::Global(self.globals[i]),
             EntityIndex::Table(i) => EntityType::Table(self.table_plans[i].table),
             EntityIndex::Memory(i) => EntityType::Memory(self.memory_plans[i].memory),
-            EntityIndex::Function(i) => EntityType::Function(self.functions[i].signature),
+            EntityIndex::Function(i) => {
+                EntityType::Function(EngineOrModuleTypeIndex::Module(self.functions[i].signature))
+            }
         }
     }
 
     /// Appends a new function to this module with the given type information,
     /// used for functions that either don't escape or aren't certain whether
     /// they escape yet.
-    pub fn push_function(&mut self, signature: SignatureIndex) -> FuncIndex {
+    pub fn push_function(&mut self, signature: ModuleInternedTypeIndex) -> FuncIndex {
         self.functions.push(FunctionType {
             signature,
             func_ref: FuncRefIndex::reserved_value(),
         })
     }
 
-    /// Appends a new function to this module with the given type information.
-    pub fn push_escaped_function(
-        &mut self,
-        signature: SignatureIndex,
-        func_ref: FuncRefIndex,
-    ) -> FuncIndex {
-        self.functions.push(FunctionType {
-            signature,
-            func_ref,
-        })
-    }
-}
-
-impl TypeConvert for Module {
-    fn lookup_heap_type(&self, index: TypeIndex) -> WasmHeapType {
-        match self.types[index] {
-            ModuleType::Function(i) => WasmHeapType::TypedFunc(i),
-        }
+    /// Returns an iterator over all of the defined function indices in this
+    /// module.
+    pub fn defined_func_indices(&self) -> impl Iterator<Item = DefinedFuncIndex> {
+        (0..self.functions.len() - self.num_imported_funcs).map(|i| DefinedFuncIndex::new(i))
     }
 }
 
@@ -1062,7 +681,7 @@ impl TypeConvert for Module {
 pub struct FunctionType {
     /// The type of this function, indexed into the module-wide type tables for
     /// a module compilation.
-    pub signature: SignatureIndex,
+    pub signature: ModuleInternedTypeIndex,
     /// The index into the funcref table, if present. Note that this is
     /// `reserved_value()` if the function does not escape from a module.
     pub func_ref: FuncRefIndex,
diff --git a/crates/environ/src/module_artifacts.rs b/crates/environ/src/module_artifacts.rs
new file mode 100644
index 000000000000..8610029e6654
--- /dev/null
+++ b/crates/environ/src/module_artifacts.rs
@@ -0,0 +1,144 @@
+//! Definitions of runtime structures and metadata which are serialized into ELF
+//! with `bincode` as part of a module's compilation process.
+
+use crate::prelude::*;
+use crate::{DefinedFuncIndex, FilePos, FuncIndex, Module, PrimaryMap, StackMap};
+use core::fmt;
+use core::ops::Range;
+use core::str;
+use serde_derive::{Deserialize, Serialize};
+use wasmtime_types::ModuleInternedTypeIndex;
+
+/// Secondary in-memory results of function compilation.
+#[derive(Serialize, Deserialize)]
+pub struct CompiledFunctionInfo {
+    /// The [`WasmFunctionInfo`] for this function.
+    pub wasm_func_info: WasmFunctionInfo,
+    /// The [`FunctionLoc`] indicating the location of this function in the text
+    /// section of the competition artifact.
+    pub wasm_func_loc: FunctionLoc,
+    /// A trampoline for array callers (e.g. `Func::new`) calling into this function (if needed).
+    pub array_to_wasm_trampoline: Option<FunctionLoc>,
+}
+
+/// Information about a function, such as trap information, address map,
+/// and stack maps.
+#[derive(Serialize, Deserialize, Default)]
+#[allow(missing_docs)]
+pub struct WasmFunctionInfo {
+    pub start_srcloc: FilePos,
+    pub stack_maps: Box<[StackMapInformation]>,
+}
+
+/// Description of where a function is located in the text section of a
+/// compiled image.
+#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
+pub struct FunctionLoc {
+    /// The byte offset from the start of the text section where this
+    /// function starts.
+    pub start: u32,
+    /// The byte length of this function's function body.
+    pub length: u32,
+}
+
+/// The offset within a function of a GC safepoint, and its associated stack
+/// map.
+#[derive(Serialize, Deserialize, Debug)]
+pub struct StackMapInformation {
+    /// The offset of the GC safepoint within the function's native code. It is
+    /// relative to the beginning of the function.
+    pub code_offset: u32,
+
+    /// The stack map for identifying live GC refs at the GC safepoint.
+    pub stack_map: StackMap,
+}
+
+/// Secondary in-memory results of module compilation.
+///
+/// This opaque structure can be optionally passed back to
+/// `CompiledModule::from_artifacts` to avoid decoding extra information there.
+#[derive(Serialize, Deserialize)]
+pub struct CompiledModuleInfo {
+    /// Type information about the compiled WebAssembly module.
+    pub module: Module,
+
+    /// Metadata about each compiled function.
+    pub funcs: PrimaryMap<DefinedFuncIndex, CompiledFunctionInfo>,
+
+    /// Sorted list, by function index, of names we have for this module.
+    pub func_names: Vec<FunctionName>,
+
+    /// Metadata about wasm-to-array trampolines. Used when exposing a native
+    /// callee (e.g. `Func::wrap`) to a Wasm caller. Sorted by signature index.
+    pub wasm_to_array_trampolines: Vec<(ModuleInternedTypeIndex, FunctionLoc)>,
+
+    /// General compilation metadata.
+    pub meta: Metadata,
+}
+
+/// The name of a function stored in the
+/// [`ELF_NAME_DATA`](crate::obj::ELF_NAME_DATA) section.
+#[derive(Serialize, Deserialize)]
+pub struct FunctionName {
+    /// The Wasm function index of this function.
+    pub idx: FuncIndex,
+    /// The offset of the name in the
+    /// [`ELF_NAME_DATA`](crate::obj::ELF_NAME_DATA) section.
+    pub offset: u32,
+    /// The length of the name in bytes.
+    pub len: u32,
+}
+
+/// Metadata associated with a compiled ELF artifact.
+#[derive(Serialize, Deserialize)]
+pub struct Metadata {
+    /// Whether or not native debug information is available in `obj`
+    pub native_debug_info_present: bool,
+
+    /// Whether or not the original wasm module contained debug information that
+    /// we skipped and did not parse.
+    pub has_unparsed_debuginfo: bool,
+
+    /// Offset in the original wasm file to the code section.
+    pub code_section_offset: u64,
+
+    /// Whether or not custom wasm-specific dwarf sections were inserted into
+    /// the ELF image.
+    ///
+    /// Note that even if this flag is `true` sections may be missing if they
+    /// weren't found in the original wasm module itself.
+    pub has_wasm_debuginfo: bool,
+
+    /// Dwarf sections and the offsets at which they're stored in the
+    /// ELF_WASMTIME_DWARF
+    pub dwarf: Vec<(u8, Range<u64>)>,
+}
+
+/// Value of a configured setting for a [`Compiler`](crate::Compiler)
+#[derive(Serialize, Deserialize, Hash, Eq, PartialEq, Debug)]
+pub enum FlagValue<'a> {
+    /// Name of the value that has been configured for this setting.
+    Enum(&'a str),
+    /// The numerical value of the configured settings.
+    Num(u8),
+    /// Whether the setting is on or off.
+    Bool(bool),
+}
+
+impl fmt::Display for FlagValue<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::Enum(v) => v.fmt(f),
+            Self::Num(v) => v.fmt(f),
+            Self::Bool(v) => v.fmt(f),
+        }
+    }
+}
+
+/// Types of objects that can be created by `Compiler::object`
+pub enum ObjectKind {
+    /// A core wasm compilation artifact
+    Module,
+    /// A component compilation artifact
+    Component,
+}
diff --git a/crates/environ/src/module_environ.rs b/crates/environ/src/module_environ.rs
deleted file mode 100644
index 00a5885c6f7e..000000000000
--- a/crates/environ/src/module_environ.rs
+++ /dev/null
@@ -1,876 +0,0 @@
-use crate::module::{
-    FuncRefIndex, Initializer, MemoryInitialization, MemoryInitializer, MemoryPlan, Module,
-    ModuleType, TablePlan, TableSegment,
-};
-use crate::{
-    DataIndex, DefinedFuncIndex, ElemIndex, EntityIndex, EntityType, FuncIndex, GlobalIndex,
-    GlobalInit, MemoryIndex, ModuleTypesBuilder, PrimaryMap, SignatureIndex, TableIndex,
-    TableInitialValue, Tunables, TypeConvert, TypeIndex, WasmError, WasmFuncType, WasmHeapType,
-    WasmResult, WasmType,
-};
-use cranelift_entity::packed_option::ReservedValue;
-use std::borrow::Cow;
-use std::collections::HashMap;
-use std::convert::TryFrom;
-use std::path::PathBuf;
-use std::sync::Arc;
-use wasmparser::{
-    types::Types, CustomSectionReader, DataKind, ElementItems, ElementKind, Encoding, ExternalKind,
-    FuncToValidate, FunctionBody, NameSectionReader, Naming, Operator, Parser, Payload, TypeRef,
-    Validator, ValidatorResources,
-};
-
-/// Object containing the standalone environment information.
-pub struct ModuleEnvironment<'a, 'data> {
-    /// The current module being translated
-    result: ModuleTranslation<'data>,
-
-    /// Intern'd types for this entire translation, shared by all modules.
-    types: &'a mut ModuleTypesBuilder,
-
-    // Various bits and pieces of configuration
-    validator: &'a mut Validator,
-    tunables: &'a Tunables,
-}
-
-/// The result of translating via `ModuleEnvironment`. Function bodies are not
-/// yet translated, and data initializers have not yet been copied out of the
-/// original buffer.
-#[derive(Default)]
-pub struct ModuleTranslation<'data> {
-    /// Module information.
-    pub module: Module,
-
-    /// The input wasm binary.
-    ///
-    /// This can be useful, for example, when modules are parsed from a
-    /// component and the embedder wants access to the raw wasm modules
-    /// themselves.
-    pub wasm: &'data [u8],
-
-    /// References to the function bodies.
-    pub function_body_inputs: PrimaryMap<DefinedFuncIndex, FunctionBodyData<'data>>,
-
-    /// A list of type signatures which are considered exported from this
-    /// module, or those that can possibly be called. This list is sorted, and
-    /// trampolines for each of these signatures are required.
-    pub exported_signatures: Vec<SignatureIndex>,
-
-    /// DWARF debug information, if enabled, parsed from the module.
-    pub debuginfo: DebugInfoData<'data>,
-
-    /// Set if debuginfo was found but it was not parsed due to `Tunables`
-    /// configuration.
-    pub has_unparsed_debuginfo: bool,
-
-    /// List of data segments found in this module which should be concatenated
-    /// together for the final compiled artifact.
-    ///
-    /// These data segments, when concatenated, are indexed by the
-    /// `MemoryInitializer` type.
-    pub data: Vec<Cow<'data, [u8]>>,
-
-    /// The desired alignment of `data` in the final data section of the object
-    /// file that we'll emit.
-    ///
-    /// Note that this is 1 by default but `MemoryInitialization::Static` might
-    /// switch this to a higher alignment to facilitate mmap-ing data from
-    /// an object file into a linear memory.
-    pub data_align: Option<u64>,
-
-    /// Total size of all data pushed onto `data` so far.
-    total_data: u32,
-
-    /// List of passive element segments found in this module which will get
-    /// concatenated for the final artifact.
-    pub passive_data: Vec<&'data [u8]>,
-
-    /// Total size of all passive data pushed into `passive_data` so far.
-    total_passive_data: u32,
-
-    /// When we're parsing the code section this will be incremented so we know
-    /// which function is currently being defined.
-    code_index: u32,
-
-    /// The type information of the current module made available at the end of the
-    /// validation process.
-    types: Option<Types>,
-}
-
-impl<'data> ModuleTranslation<'data> {
-    /// Returns a reference to the type information of the current module.
-    pub fn get_types(&self) -> &Types {
-        self.types
-            .as_ref()
-            .expect("module type information to be available")
-    }
-}
-
-/// Contains function data: byte code and its offset in the module.
-pub struct FunctionBodyData<'a> {
-    /// The body of the function, containing code and locals.
-    pub body: FunctionBody<'a>,
-    /// Validator for the function body
-    pub validator: FuncToValidate<ValidatorResources>,
-}
-
-#[derive(Debug, Default)]
-#[allow(missing_docs)]
-pub struct DebugInfoData<'a> {
-    pub dwarf: Dwarf<'a>,
-    pub name_section: NameSection<'a>,
-    pub wasm_file: WasmFileInfo,
-    debug_loc: gimli::DebugLoc<Reader<'a>>,
-    debug_loclists: gimli::DebugLocLists<Reader<'a>>,
-    pub debug_ranges: gimli::DebugRanges<Reader<'a>>,
-    pub debug_rnglists: gimli::DebugRngLists<Reader<'a>>,
-}
-
-#[allow(missing_docs)]
-pub type Dwarf<'input> = gimli::Dwarf<Reader<'input>>;
-
-type Reader<'input> = gimli::EndianSlice<'input, gimli::LittleEndian>;
-
-#[derive(Debug, Default)]
-#[allow(missing_docs)]
-pub struct NameSection<'a> {
-    pub module_name: Option<&'a str>,
-    pub func_names: HashMap<FuncIndex, &'a str>,
-    pub locals_names: HashMap<FuncIndex, HashMap<u32, &'a str>>,
-}
-
-#[derive(Debug, Default)]
-#[allow(missing_docs)]
-pub struct WasmFileInfo {
-    pub path: Option<PathBuf>,
-    pub code_section_offset: u64,
-    pub imported_func_count: u32,
-    pub funcs: Vec<FunctionMetadata>,
-}
-
-#[derive(Debug)]
-#[allow(missing_docs)]
-pub struct FunctionMetadata {
-    pub params: Box<[WasmType]>,
-    pub locals: Box<[(u32, WasmType)]>,
-}
-
-impl<'a, 'data> ModuleEnvironment<'a, 'data> {
-    /// Allocates the environment data structures.
-    pub fn new(
-        tunables: &'a Tunables,
-        validator: &'a mut Validator,
-        types: &'a mut ModuleTypesBuilder,
-    ) -> Self {
-        Self {
-            result: ModuleTranslation::default(),
-            types,
-            tunables,
-            validator,
-        }
-    }
-
-    /// Translate a wasm module using this environment.
-    ///
-    /// This function will translate the `data` provided with `parser`,
-    /// validating everything along the way with this environment's validator.
-    ///
-    /// The result of translation, [`ModuleTranslation`], contains everything
-    /// necessary to compile functions afterwards as well as learn type
-    /// information about the module at runtime.
-    pub fn translate(
-        mut self,
-        parser: Parser,
-        data: &'data [u8],
-    ) -> WasmResult<ModuleTranslation<'data>> {
-        self.result.wasm = data;
-
-        for payload in parser.parse_all(data) {
-            self.translate_payload(payload?)?;
-        }
-
-        Ok(self.result)
-    }
-
-    fn translate_payload(&mut self, payload: Payload<'data>) -> WasmResult<()> {
-        match payload {
-            Payload::Version {
-                num,
-                encoding,
-                range,
-            } => {
-                self.validator.version(num, encoding, &range)?;
-                match encoding {
-                    Encoding::Module => {}
-                    Encoding::Component => {
-                        return Err(WasmError::Unsupported(format!("component model")));
-                    }
-                }
-            }
-
-            Payload::End(offset) => {
-                self.result.types = Some(self.validator.end(offset)?);
-
-                // With the `escaped_funcs` set of functions finished
-                // we can calculate the set of signatures that are exported as
-                // the set of exported functions' signatures.
-                self.result.exported_signatures = self
-                    .result
-                    .module
-                    .functions
-                    .iter()
-                    .filter_map(|(_, func)| {
-                        if func.is_escaping() {
-                            Some(func.signature)
-                        } else {
-                            None
-                        }
-                    })
-                    .collect();
-                self.result.exported_signatures.sort_unstable();
-                self.result.exported_signatures.dedup();
-            }
-
-            Payload::TypeSection(types) => {
-                self.validator.type_section(&types)?;
-                let num = usize::try_from(types.count()).unwrap();
-                self.result.module.types.reserve(num);
-                self.types.reserve_wasm_signatures(num);
-
-                for ty in types.into_iter_err_on_gc_types() {
-                    let ty = self.convert_func_type(&ty?);
-                    self.declare_type_func(ty)?;
-                }
-            }
-
-            Payload::ImportSection(imports) => {
-                self.validator.import_section(&imports)?;
-
-                let cnt = usize::try_from(imports.count()).unwrap();
-                self.result.module.initializers.reserve(cnt);
-
-                for entry in imports {
-                    let import = entry?;
-                    let ty = match import.ty {
-                        TypeRef::Func(index) => {
-                            let index = TypeIndex::from_u32(index);
-                            let sig_index = self.result.module.types[index].unwrap_function();
-                            self.result.module.num_imported_funcs += 1;
-                            self.result.debuginfo.wasm_file.imported_func_count += 1;
-                            EntityType::Function(sig_index)
-                        }
-                        TypeRef::Memory(ty) => {
-                            self.result.module.num_imported_memories += 1;
-                            EntityType::Memory(ty.into())
-                        }
-                        TypeRef::Global(ty) => {
-                            self.result.module.num_imported_globals += 1;
-                            EntityType::Global(self.convert_global_type(&ty))
-                        }
-                        TypeRef::Table(ty) => {
-                            self.result.module.num_imported_tables += 1;
-                            EntityType::Table(self.convert_table_type(&ty))
-                        }
-
-                        // doesn't get past validation
-                        TypeRef::Tag(_) => unreachable!(),
-                    };
-                    self.declare_import(import.module, import.name, ty);
-                }
-            }
-
-            Payload::FunctionSection(functions) => {
-                self.validator.function_section(&functions)?;
-
-                let cnt = usize::try_from(functions.count()).unwrap();
-                self.result.module.functions.reserve_exact(cnt);
-
-                for entry in functions {
-                    let sigindex = entry?;
-                    let ty = TypeIndex::from_u32(sigindex);
-                    let sig_index = self.result.module.types[ty].unwrap_function();
-                    self.result.module.push_function(sig_index);
-                }
-            }
-
-            Payload::TableSection(tables) => {
-                self.validator.table_section(&tables)?;
-                let cnt = usize::try_from(tables.count()).unwrap();
-                self.result.module.table_plans.reserve_exact(cnt);
-
-                for entry in tables {
-                    let wasmparser::Table { ty, init } = entry?;
-                    let table = self.convert_table_type(&ty);
-                    let plan = TablePlan::for_table(table, &self.tunables);
-                    self.result.module.table_plans.push(plan);
-                    let init = match init {
-                        wasmparser::TableInit::RefNull => TableInitialValue::Null {
-                            precomputed: Vec::new(),
-                        },
-                        wasmparser::TableInit::Expr(cexpr) => {
-                            let mut init_expr_reader = cexpr.get_binary_reader();
-                            match init_expr_reader.read_operator()? {
-                                Operator::RefNull { hty: _ } => TableInitialValue::Null {
-                                    precomputed: Vec::new(),
-                                },
-                                Operator::RefFunc { function_index } => {
-                                    let index = FuncIndex::from_u32(function_index);
-                                    self.flag_func_escaped(index);
-                                    TableInitialValue::FuncRef(index)
-                                }
-                                s => {
-                                    return Err(WasmError::Unsupported(format!(
-                                        "unsupported init expr in table section: {:?}",
-                                        s
-                                    )));
-                                }
-                            }
-                        }
-                    };
-                    self.result
-                        .module
-                        .table_initialization
-                        .initial_values
-                        .push(init);
-                }
-            }
-
-            Payload::MemorySection(memories) => {
-                self.validator.memory_section(&memories)?;
-
-                let cnt = usize::try_from(memories.count()).unwrap();
-                self.result.module.memory_plans.reserve_exact(cnt);
-
-                for entry in memories {
-                    let memory = entry?;
-                    let plan = MemoryPlan::for_memory(memory.into(), &self.tunables);
-                    self.result.module.memory_plans.push(plan);
-                }
-            }
-
-            Payload::TagSection(tags) => {
-                self.validator.tag_section(&tags)?;
-
-                // This feature isn't enabled at this time, so we should
-                // never get here.
-                unreachable!();
-            }
-
-            Payload::GlobalSection(globals) => {
-                self.validator.global_section(&globals)?;
-
-                let cnt = usize::try_from(globals.count()).unwrap();
-                self.result.module.globals.reserve_exact(cnt);
-
-                for entry in globals {
-                    let wasmparser::Global { ty, init_expr } = entry?;
-                    let mut init_expr_reader = init_expr.get_binary_reader();
-                    let initializer = match init_expr_reader.read_operator()? {
-                        Operator::I32Const { value } => GlobalInit::I32Const(value),
-                        Operator::I64Const { value } => GlobalInit::I64Const(value),
-                        Operator::F32Const { value } => GlobalInit::F32Const(value.bits()),
-                        Operator::F64Const { value } => GlobalInit::F64Const(value.bits()),
-                        Operator::V128Const { value } => {
-                            GlobalInit::V128Const(u128::from_le_bytes(*value.bytes()))
-                        }
-                        Operator::RefNull { hty: _ } => GlobalInit::RefNullConst,
-                        Operator::RefFunc { function_index } => {
-                            let index = FuncIndex::from_u32(function_index);
-                            self.flag_func_escaped(index);
-                            GlobalInit::RefFunc(index)
-                        }
-                        Operator::GlobalGet { global_index } => {
-                            GlobalInit::GetGlobal(GlobalIndex::from_u32(global_index))
-                        }
-                        s => {
-                            return Err(WasmError::Unsupported(format!(
-                                "unsupported init expr in global section: {:?}",
-                                s
-                            )));
-                        }
-                    };
-                    let ty = self.convert_global_type(&ty);
-                    self.result.module.globals.push(ty);
-                    self.result.module.global_initializers.push(initializer);
-                }
-            }
-
-            Payload::ExportSection(exports) => {
-                self.validator.export_section(&exports)?;
-
-                let cnt = usize::try_from(exports.count()).unwrap();
-                self.result.module.exports.reserve(cnt);
-
-                for entry in exports {
-                    let wasmparser::Export { name, kind, index } = entry?;
-                    let entity = match kind {
-                        ExternalKind::Func => {
-                            let index = FuncIndex::from_u32(index);
-                            self.flag_func_escaped(index);
-                            EntityIndex::Function(index)
-                        }
-                        ExternalKind::Table => EntityIndex::Table(TableIndex::from_u32(index)),
-                        ExternalKind::Memory => EntityIndex::Memory(MemoryIndex::from_u32(index)),
-                        ExternalKind::Global => EntityIndex::Global(GlobalIndex::from_u32(index)),
-
-                        // this never gets past validation
-                        ExternalKind::Tag => unreachable!(),
-                    };
-                    self.result
-                        .module
-                        .exports
-                        .insert(String::from(name), entity);
-                }
-            }
-
-            Payload::StartSection { func, range } => {
-                self.validator.start_section(func, &range)?;
-
-                let func_index = FuncIndex::from_u32(func);
-                self.flag_func_escaped(func_index);
-                debug_assert!(self.result.module.start_func.is_none());
-                self.result.module.start_func = Some(func_index);
-            }
-
-            Payload::ElementSection(elements) => {
-                self.validator.element_section(&elements)?;
-
-                for (index, entry) in elements.into_iter().enumerate() {
-                    let wasmparser::Element {
-                        kind,
-                        items,
-                        range: _,
-                    } = entry?;
-
-                    // Build up a list of `FuncIndex` corresponding to all the
-                    // entries listed in this segment. Note that it's not
-                    // possible to create anything other than a `ref.null
-                    // extern` for externref segments, so those just get
-                    // translated to the reserved value of `FuncIndex`.
-                    let mut elements = Vec::new();
-                    match items {
-                        ElementItems::Functions(funcs) => {
-                            elements.reserve(usize::try_from(funcs.count()).unwrap());
-                            for func in funcs {
-                                let func = FuncIndex::from_u32(func?);
-                                self.flag_func_escaped(func);
-                                elements.push(func);
-                            }
-                        }
-                        ElementItems::Expressions(_ty, funcs) => {
-                            elements.reserve(usize::try_from(funcs.count()).unwrap());
-                            for func in funcs {
-                                let func = match func?.get_binary_reader().read_operator()? {
-                                    Operator::RefNull { .. } => FuncIndex::reserved_value(),
-                                    Operator::RefFunc { function_index } => {
-                                        let func = FuncIndex::from_u32(function_index);
-                                        self.flag_func_escaped(func);
-                                        func
-                                    }
-                                    s => {
-                                        return Err(WasmError::Unsupported(format!(
-                                            "unsupported init expr in element section: {:?}",
-                                            s
-                                        )));
-                                    }
-                                };
-                                elements.push(func);
-                            }
-                        }
-                    }
-
-                    match kind {
-                        ElementKind::Active {
-                            table_index,
-                            offset_expr,
-                        } => {
-                            let table_index = TableIndex::from_u32(table_index.unwrap_or(0));
-                            let mut offset_expr_reader = offset_expr.get_binary_reader();
-                            let (base, offset) = match offset_expr_reader.read_operator()? {
-                                Operator::I32Const { value } => (None, value as u32),
-                                Operator::GlobalGet { global_index } => {
-                                    (Some(GlobalIndex::from_u32(global_index)), 0)
-                                }
-                                ref s => {
-                                    return Err(WasmError::Unsupported(format!(
-                                        "unsupported init expr in element section: {:?}",
-                                        s
-                                    )));
-                                }
-                            };
-
-                            self.result
-                                .module
-                                .table_initialization
-                                .segments
-                                .push(TableSegment {
-                                    table_index,
-                                    base,
-                                    offset,
-                                    elements: elements.into(),
-                                });
-                        }
-
-                        ElementKind::Passive => {
-                            let elem_index = ElemIndex::from_u32(index as u32);
-                            let index = self.result.module.passive_elements.len();
-                            self.result.module.passive_elements.push(elements.into());
-                            self.result
-                                .module
-                                .passive_elements_map
-                                .insert(elem_index, index);
-                        }
-
-                        ElementKind::Declared => {}
-                    }
-                }
-            }
-
-            Payload::CodeSectionStart { count, range, .. } => {
-                self.validator.code_section_start(count, &range)?;
-                let cnt = usize::try_from(count).unwrap();
-                self.result.function_body_inputs.reserve_exact(cnt);
-                self.result.debuginfo.wasm_file.code_section_offset = range.start as u64;
-            }
-
-            Payload::CodeSectionEntry(mut body) => {
-                let validator = self.validator.code_section_entry(&body)?;
-                let func_index =
-                    self.result.code_index + self.result.module.num_imported_funcs as u32;
-                let func_index = FuncIndex::from_u32(func_index);
-
-                if self.tunables.generate_native_debuginfo {
-                    let sig_index = self.result.module.functions[func_index].signature;
-                    let sig = &self.types[sig_index];
-                    let mut locals = Vec::new();
-                    for pair in body.get_locals_reader()? {
-                        let (cnt, ty) = pair?;
-                        let ty = self.convert_valtype(ty);
-                        locals.push((cnt, ty));
-                    }
-                    self.result
-                        .debuginfo
-                        .wasm_file
-                        .funcs
-                        .push(FunctionMetadata {
-                            locals: locals.into_boxed_slice(),
-                            params: sig.params().into(),
-                        });
-                }
-                body.allow_memarg64(self.validator.features().memory64);
-                self.result
-                    .function_body_inputs
-                    .push(FunctionBodyData { validator, body });
-                self.result.code_index += 1;
-            }
-
-            Payload::DataSection(data) => {
-                self.validator.data_section(&data)?;
-
-                let initializers = match &mut self.result.module.memory_initialization {
-                    MemoryInitialization::Segmented(i) => i,
-                    _ => unreachable!(),
-                };
-
-                let cnt = usize::try_from(data.count()).unwrap();
-                initializers.reserve_exact(cnt);
-                self.result.data.reserve_exact(cnt);
-
-                for (index, entry) in data.into_iter().enumerate() {
-                    let wasmparser::Data {
-                        kind,
-                        data,
-                        range: _,
-                    } = entry?;
-                    let mk_range = |total: &mut u32| -> Result<_, WasmError> {
-                        let range = u32::try_from(data.len())
-                            .ok()
-                            .and_then(|size| {
-                                let start = *total;
-                                let end = start.checked_add(size)?;
-                                Some(start..end)
-                            })
-                            .ok_or_else(|| {
-                                WasmError::Unsupported(format!(
-                                    "more than 4 gigabytes of data in wasm module",
-                                ))
-                            })?;
-                        *total += range.end - range.start;
-                        Ok(range)
-                    };
-                    match kind {
-                        DataKind::Active {
-                            memory_index,
-                            offset_expr,
-                        } => {
-                            let range = mk_range(&mut self.result.total_data)?;
-                            let memory_index = MemoryIndex::from_u32(memory_index);
-                            let mut offset_expr_reader = offset_expr.get_binary_reader();
-                            let (base, offset) = match offset_expr_reader.read_operator()? {
-                                Operator::I32Const { value } => (None, value as u64),
-                                Operator::I64Const { value } => (None, value as u64),
-                                Operator::GlobalGet { global_index } => {
-                                    (Some(GlobalIndex::from_u32(global_index)), 0)
-                                }
-                                s => {
-                                    return Err(WasmError::Unsupported(format!(
-                                        "unsupported init expr in data section: {:?}",
-                                        s
-                                    )));
-                                }
-                            };
-
-                            initializers.push(MemoryInitializer {
-                                memory_index,
-                                base,
-                                offset,
-                                data: range,
-                            });
-                            self.result.data.push(data.into());
-                        }
-                        DataKind::Passive => {
-                            let data_index = DataIndex::from_u32(index as u32);
-                            let range = mk_range(&mut self.result.total_passive_data)?;
-                            self.result.passive_data.push(data);
-                            self.result
-                                .module
-                                .passive_data_map
-                                .insert(data_index, range);
-                        }
-                    }
-                }
-            }
-
-            Payload::DataCountSection { count, range } => {
-                self.validator.data_count_section(count, &range)?;
-
-                // Note: the count passed in here is the *total* segment count
-                // There is no way to reserve for just the passive segments as
-                // they are discovered when iterating the data section entries
-                // Given that the total segment count might be much larger than
-                // the passive count, do not reserve anything here.
-            }
-
-            Payload::CustomSection(s) if s.name() == "name" => {
-                let result = self.name_section(NameSectionReader::new(s.data(), s.data_offset()));
-                if let Err(e) = result {
-                    log::warn!("failed to parse name section {:?}", e);
-                }
-            }
-
-            Payload::CustomSection(s)
-                if s.name() == "webidl-bindings" || s.name() == "wasm-interface-types" =>
-            {
-                return Err(WasmError::Unsupported(
-                    "\
-Support for interface types has temporarily been removed from `wasmtime`.
-
-For more information about this temporary change you can read on the issue online:
-
-    https://github.com/bytecodealliance/wasmtime/issues/1271
-
-and for re-adding support for interface types you can see this issue:
-
-    https://github.com/bytecodealliance/wasmtime/issues/677
-"
-                    .to_string(),
-                ))
-            }
-
-            Payload::CustomSection(s) => {
-                self.register_dwarf_section(&s);
-            }
-
-            // It's expected that validation will probably reject other
-            // payloads such as `UnknownSection` or those related to the
-            // component model. If, however, something gets past validation then
-            // that's a bug in Wasmtime as we forgot to implement something.
-            other => {
-                self.validator.payload(&other)?;
-                panic!("unimplemented section in wasm file {:?}", other);
-            }
-        }
-        Ok(())
-    }
-
-    fn register_dwarf_section(&mut self, section: &CustomSectionReader<'data>) {
-        let name = section.name();
-        if !name.starts_with(".debug_") {
-            return;
-        }
-        if !self.tunables.generate_native_debuginfo && !self.tunables.parse_wasm_debuginfo {
-            self.result.has_unparsed_debuginfo = true;
-            return;
-        }
-        let info = &mut self.result.debuginfo;
-        let dwarf = &mut info.dwarf;
-        let endian = gimli::LittleEndian;
-        let data = section.data();
-        let slice = gimli::EndianSlice::new(data, endian);
-
-        match name {
-            // `gimli::Dwarf` fields.
-            ".debug_abbrev" => dwarf.debug_abbrev = gimli::DebugAbbrev::new(data, endian),
-            ".debug_addr" => dwarf.debug_addr = gimli::DebugAddr::from(slice),
-            ".debug_info" => dwarf.debug_info = gimli::DebugInfo::new(data, endian),
-            ".debug_line" => dwarf.debug_line = gimli::DebugLine::new(data, endian),
-            ".debug_line_str" => dwarf.debug_line_str = gimli::DebugLineStr::from(slice),
-            ".debug_str" => dwarf.debug_str = gimli::DebugStr::new(data, endian),
-            ".debug_str_offsets" => dwarf.debug_str_offsets = gimli::DebugStrOffsets::from(slice),
-            ".debug_str_sup" => {
-                let mut dwarf_sup: Dwarf<'data> = Default::default();
-                dwarf_sup.debug_str = gimli::DebugStr::from(slice);
-                dwarf.sup = Some(Arc::new(dwarf_sup));
-            }
-            ".debug_types" => dwarf.debug_types = gimli::DebugTypes::from(slice),
-
-            // Additional fields.
-            ".debug_loc" => info.debug_loc = gimli::DebugLoc::from(slice),
-            ".debug_loclists" => info.debug_loclists = gimli::DebugLocLists::from(slice),
-            ".debug_ranges" => info.debug_ranges = gimli::DebugRanges::new(data, endian),
-            ".debug_rnglists" => info.debug_rnglists = gimli::DebugRngLists::new(data, endian),
-
-            // We don't use these at the moment.
-            ".debug_aranges" | ".debug_pubnames" | ".debug_pubtypes" => return,
-
-            other => {
-                log::warn!("unknown debug section `{}`", other);
-                return;
-            }
-        }
-
-        dwarf.ranges = gimli::RangeLists::new(info.debug_ranges, info.debug_rnglists);
-        dwarf.locations = gimli::LocationLists::new(info.debug_loc, info.debug_loclists);
-    }
-
-    /// Declares a new import with the `module` and `field` names, importing the
-    /// `ty` specified.
-    ///
-    /// Note that this method is somewhat tricky due to the implementation of
-    /// the module linking proposal. In the module linking proposal two-level
-    /// imports are recast as single-level imports of instances. That recasting
-    /// happens here by recording an import of an instance for the first time
-    /// we see a two-level import.
-    ///
-    /// When the module linking proposal is disabled, however, disregard this
-    /// logic and instead work directly with two-level imports since no
-    /// instances are defined.
-    fn declare_import(&mut self, module: &'data str, field: &'data str, ty: EntityType) {
-        let index = self.push_type(ty);
-        self.result.module.initializers.push(Initializer::Import {
-            name: module.to_owned(),
-            field: field.to_owned(),
-            index,
-        });
-    }
-
-    fn push_type(&mut self, ty: EntityType) -> EntityIndex {
-        match ty {
-            EntityType::Function(ty) => EntityIndex::Function(self.result.module.push_function(ty)),
-            EntityType::Table(ty) => {
-                let plan = TablePlan::for_table(ty, &self.tunables);
-                EntityIndex::Table(self.result.module.table_plans.push(plan))
-            }
-            EntityType::Memory(ty) => {
-                let plan = MemoryPlan::for_memory(ty, &self.tunables);
-                EntityIndex::Memory(self.result.module.memory_plans.push(plan))
-            }
-            EntityType::Global(ty) => EntityIndex::Global(self.result.module.globals.push(ty)),
-            EntityType::Tag(_) => unimplemented!(),
-        }
-    }
-
-    fn flag_func_escaped(&mut self, func: FuncIndex) {
-        let ty = &mut self.result.module.functions[func];
-        // If this was already assigned a funcref index no need to re-assign it.
-        if ty.is_escaping() {
-            return;
-        }
-        let index = self.result.module.num_escaped_funcs as u32;
-        ty.func_ref = FuncRefIndex::from_u32(index);
-        self.result.module.num_escaped_funcs += 1;
-    }
-
-    fn declare_type_func(&mut self, wasm: WasmFuncType) -> WasmResult<()> {
-        let sig_index = self.types.wasm_func_type(wasm);
-        self.result
-            .module
-            .types
-            .push(ModuleType::Function(sig_index));
-        Ok(())
-    }
-
-    /// Parses the Name section of the wasm module.
-    fn name_section(&mut self, names: NameSectionReader<'data>) -> WasmResult<()> {
-        for subsection in names {
-            match subsection? {
-                wasmparser::Name::Function(names) => {
-                    for name in names {
-                        let Naming { index, name } = name?;
-                        // Skip this naming if it's naming a function that
-                        // doesn't actually exist.
-                        if (index as usize) >= self.result.module.functions.len() {
-                            continue;
-                        }
-
-                        // Store the name unconditionally, regardless of
-                        // whether we're parsing debuginfo, since function
-                        // names are almost always present in the
-                        // final compilation artifact.
-                        let index = FuncIndex::from_u32(index);
-                        self.result
-                            .debuginfo
-                            .name_section
-                            .func_names
-                            .insert(index, name);
-                    }
-                }
-                wasmparser::Name::Module { name, .. } => {
-                    self.result.module.name = Some(name.to_string());
-                    if self.tunables.generate_native_debuginfo {
-                        self.result.debuginfo.name_section.module_name = Some(name);
-                    }
-                }
-                wasmparser::Name::Local(reader) => {
-                    if !self.tunables.generate_native_debuginfo {
-                        continue;
-                    }
-                    for f in reader {
-                        let f = f?;
-                        // Skip this naming if it's naming a function that
-                        // doesn't actually exist.
-                        if (f.index as usize) >= self.result.module.functions.len() {
-                            continue;
-                        }
-                        for name in f.names {
-                            let Naming { index, name } = name?;
-
-                            self.result
-                                .debuginfo
-                                .name_section
-                                .locals_names
-                                .entry(FuncIndex::from_u32(f.index))
-                                .or_insert(HashMap::new())
-                                .insert(index, name);
-                        }
-                    }
-                }
-                wasmparser::Name::Label(_)
-                | wasmparser::Name::Type(_)
-                | wasmparser::Name::Table(_)
-                | wasmparser::Name::Global(_)
-                | wasmparser::Name::Memory(_)
-                | wasmparser::Name::Element(_)
-                | wasmparser::Name::Data(_)
-                | wasmparser::Name::Unknown { .. } => {}
-            }
-        }
-        Ok(())
-    }
-}
-
-impl TypeConvert for ModuleEnvironment<'_, '_> {
-    fn lookup_heap_type(&self, index: TypeIndex) -> WasmHeapType {
-        self.result.module.lookup_heap_type(index)
-    }
-}
diff --git a/crates/environ/src/module_types.rs b/crates/environ/src/module_types.rs
index 287cbb667b63..a04e36624af6 100644
--- a/crates/environ/src/module_types.rs
+++ b/crates/environ/src/module_types.rs
@@ -1,78 +1,139 @@
-use crate::{PrimaryMap, SignatureIndex, WasmFuncType};
+use crate::PrimaryMap;
+use core::ops::{Index, Range};
+use cranelift_entity::{packed_option::PackedOption, SecondaryMap};
 use serde_derive::{Deserialize, Serialize};
-use std::collections::HashMap;
-use std::ops::Index;
+use wasmtime_types::{ModuleInternedRecGroupIndex, ModuleInternedTypeIndex, WasmSubType};
 
 /// All types used in a core wasm module.
 ///
-/// At this time this only contains function types. Note, though, that function
-/// types are deduplicated within this [`ModuleTypes`].
-///
-/// Note that accesing this type is primarily done through the `Index`
+/// Note that accessing this type is primarily done through the `Index`
 /// implementations for this type.
 #[derive(Default, Serialize, Deserialize)]
-#[allow(missing_docs)]
 pub struct ModuleTypes {
-    wasm_signatures: PrimaryMap<SignatureIndex, WasmFuncType>,
+    rec_groups: PrimaryMap<ModuleInternedRecGroupIndex, Range<ModuleInternedTypeIndex>>,
+    wasm_types: PrimaryMap<ModuleInternedTypeIndex, WasmSubType>,
+    trampoline_types: SecondaryMap<ModuleInternedTypeIndex, PackedOption<ModuleInternedTypeIndex>>,
 }
 
 impl ModuleTypes {
     /// Returns an iterator over all the wasm function signatures found within
     /// this module.
-    pub fn wasm_signatures(&self) -> impl Iterator<Item = (SignatureIndex, &WasmFuncType)> {
-        self.wasm_signatures.iter()
+    pub fn wasm_types(
+        &self,
+    ) -> impl ExactSizeIterator<Item = (ModuleInternedTypeIndex, &WasmSubType)> {
+        self.wasm_types.iter()
     }
-}
 
-impl Index<SignatureIndex> for ModuleTypes {
-    type Output = WasmFuncType;
+    /// Get the type at the specified index, if it exists.
+    pub fn get(&self, ty: ModuleInternedTypeIndex) -> Option<&WasmSubType> {
+        self.wasm_types.get(ty)
+    }
 
-    fn index(&self, sig: SignatureIndex) -> &WasmFuncType {
-        &self.wasm_signatures[sig]
+    /// Get an iterator over all recursion groups defined in this module and
+    /// their elements.
+    pub fn rec_groups(
+        &self,
+    ) -> impl ExactSizeIterator<Item = (ModuleInternedRecGroupIndex, Range<ModuleInternedTypeIndex>)> + '_
+    {
+        self.rec_groups.iter().map(|(k, v)| (k, v.clone()))
+    }
+
+    /// Get the elements within an already-defined rec group.
+    pub fn rec_group_elements(
+        &self,
+        rec_group: ModuleInternedRecGroupIndex,
+    ) -> impl ExactSizeIterator<Item = ModuleInternedTypeIndex> {
+        let range = &self.rec_groups[rec_group];
+        (range.start.as_u32()..range.end.as_u32()).map(|i| ModuleInternedTypeIndex::from_u32(i))
+    }
+
+    /// Returns the number of types interned.
+    pub fn len_types(&self) -> usize {
+        self.wasm_types.len()
+    }
+
+    /// Adds a new type to this interned list of types.
+    pub fn push(&mut self, ty: WasmSubType) -> ModuleInternedTypeIndex {
+        self.wasm_types.push(ty)
     }
-}
 
-/// A builder for [`ModuleTypes`].
-#[derive(Default)]
-#[allow(missing_docs)]
-pub struct ModuleTypesBuilder {
-    types: ModuleTypes,
-    interned_func_types: HashMap<WasmFuncType, SignatureIndex>,
+    /// Iterate over the trampoline function types that this module requires.
+    ///
+    /// Yields pairs of (1) a function type and (2) its associated trampoline
+    /// type. They might be the same.
+    ///
+    /// See the docs for `WasmFuncType::trampoline_type` for details on
+    /// trampoline types.
+    pub fn trampoline_types(
+        &self,
+    ) -> impl Iterator<Item = (ModuleInternedTypeIndex, ModuleInternedTypeIndex)> + '_ {
+        self.trampoline_types
+            .iter()
+            .filter_map(|(k, v)| v.expand().map(|v| (k, v)))
+    }
+
+    /// Get the trampoline type for the given function type.
+    ///
+    /// See the docs for `WasmFuncType::trampoline_type` for details on
+    /// trampoline types.
+    pub fn trampoline_type(&self, ty: ModuleInternedTypeIndex) -> ModuleInternedTypeIndex {
+        debug_assert!(self[ty].is_func());
+        self.trampoline_types[ty].unwrap()
+    }
 }
 
-impl ModuleTypesBuilder {
-    /// Reserves space for `amt` more type signatures.
-    pub fn reserve_wasm_signatures(&mut self, amt: usize) {
-        self.types.wasm_signatures.reserve(amt);
+/// Methods that only exist for `ModuleTypesBuilder`.
+#[cfg(feature = "compile")]
+impl ModuleTypes {
+    /// Associate `trampoline_ty` as the trampoline type for `for_ty`.
+    ///
+    /// This is really only for use by the `ModuleTypesBuilder`.
+    pub fn set_trampoline_type(
+        &mut self,
+        for_ty: ModuleInternedTypeIndex,
+        trampoline_ty: ModuleInternedTypeIndex,
+    ) {
+        use cranelift_entity::packed_option::ReservedValue;
+
+        debug_assert!(!for_ty.is_reserved_value());
+        debug_assert!(!trampoline_ty.is_reserved_value());
+        debug_assert!(self.wasm_types[for_ty].is_func());
+        debug_assert!(self.trampoline_types[for_ty].is_none());
+        debug_assert!(self.wasm_types[trampoline_ty]
+            .unwrap_func()
+            .is_trampoline_type());
+
+        self.trampoline_types[for_ty] = Some(trampoline_ty).into();
+    }
+
+    /// Adds a new rec group to this interned list of types.
+    pub fn push_rec_group(
+        &mut self,
+        range: Range<ModuleInternedTypeIndex>,
+    ) -> ModuleInternedRecGroupIndex {
+        self.rec_groups.push(range)
+    }
+
+    /// Reserves space for `amt` more types.
+    pub fn reserve(&mut self, amt: usize) {
+        self.wasm_types.reserve(amt)
     }
 
-    /// Interns the `sig` specified and returns a unique `SignatureIndex` that
-    /// can be looked up within [`ModuleTypes`] to recover the [`WasmFuncType`]
-    /// at runtime.
-    pub fn wasm_func_type(&mut self, sig: WasmFuncType) -> SignatureIndex {
-        if let Some(idx) = self.interned_func_types.get(&sig) {
-            return *idx;
-        }
-
-        let idx = self.types.wasm_signatures.push(sig.clone());
-        self.interned_func_types.insert(sig, idx);
-        return idx;
+    /// Returns the next return value of `push_rec_group`.
+    pub fn next_rec_group(&self) -> ModuleInternedRecGroupIndex {
+        self.rec_groups.next_key()
     }
 
-    /// Returns the result [`ModuleTypes`] of this builder.
-    pub fn finish(self) -> ModuleTypes {
-        self.types
+    /// Returns the next return value of `push`.
+    pub fn next_ty(&self) -> ModuleInternedTypeIndex {
+        self.wasm_types.next_key()
     }
 }
 
-// Forward the indexing impl to the internal `ModuleTypes`
-impl<T> Index<T> for ModuleTypesBuilder
-where
-    ModuleTypes: Index<T>,
-{
-    type Output = <ModuleTypes as Index<T>>::Output;
+impl Index<ModuleInternedTypeIndex> for ModuleTypes {
+    type Output = WasmSubType;
 
-    fn index(&self, sig: T) -> &Self::Output {
-        &self.types[sig]
+    fn index(&self, sig: ModuleInternedTypeIndex) -> &WasmSubType {
+        &self.wasm_types[sig]
     }
 }
diff --git a/crates/environ/src/obj.rs b/crates/environ/src/obj.rs
index 6ba410c5078b..72ce32fd2e87 100644
--- a/crates/environ/src/obj.rs
+++ b/crates/environ/src/obj.rs
@@ -131,6 +131,7 @@ pub const ELF_WASMTIME_DWARF: &str = ".wasmtime.dwarf";
 
 macro_rules! libcalls {
     ($($rust:ident = $sym:tt)*) => (
+        #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Ord, PartialOrd)]
         #[allow(missing_docs)]
         pub enum LibCall {
             $($rust,)*
diff --git a/crates/environ/src/ref_bits.rs b/crates/environ/src/ref_bits.rs
index 49c48351e5b3..5b1618f35f2f 100644
--- a/crates/environ/src/ref_bits.rs
+++ b/crates/environ/src/ref_bits.rs
@@ -25,7 +25,7 @@
 /// bit every time we load.
 ///
 /// Note that we take care to set this bit and mask it off when
-/// accessing tables direclty in fastpaths in generated code as well.
+/// accessing tables directly in fastpaths in generated code as well.
 pub const FUNCREF_INIT_BIT: usize = 1;
 
 /// The mask we apply to all refs loaded from funcref tables.
diff --git a/crates/environ/src/scopevec.rs b/crates/environ/src/scopevec.rs
index 6c7e58a163e9..da779b9f51a0 100644
--- a/crates/environ/src/scopevec.rs
+++ b/crates/environ/src/scopevec.rs
@@ -1,4 +1,5 @@
-use std::cell::RefCell;
+use crate::prelude::*;
+use core::cell::RefCell;
 
 /// Small data structure to help extend the lifetime of a slice to a higher
 /// scope.
@@ -28,10 +29,12 @@ impl<T> ScopeVec<T> {
     ///
     /// The original data will be deallocated when `self` is dropped.
     pub fn push(&self, data: Vec<T>) -> &mut [T] {
-        let mut data: Box<[T]> = data.into();
-        let ptr = data.as_mut_ptr();
+        let data: Box<[T]> = data.into();
         let len = data.len();
-        self.data.borrow_mut().push(data);
+
+        let mut storage = self.data.borrow_mut();
+        storage.push(data);
+        let ptr = storage.last_mut().unwrap().as_mut_ptr();
 
         // This should be safe for a few reasons:
         //
@@ -52,6 +55,26 @@ impl<T> ScopeVec<T> {
         //
         // This all means that it should be safe to return a mutable slice of
         // all of `data` after the data has been pushed onto our internal list.
-        unsafe { std::slice::from_raw_parts_mut(ptr, len) }
+        unsafe { core::slice::from_raw_parts_mut(ptr, len) }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ScopeVec;
+    use crate::prelude::*;
+
+    #[test]
+    fn smoke() {
+        let scope = ScopeVec::new();
+        let a = scope.push(Vec::new());
+        let b = scope.push(vec![1, 2, 3]);
+        let c = scope.push(vec![4, 5, 6]);
+        assert_eq!(a.len(), 0);
+        b[0] = 4;
+        c[2] = 5;
+        assert_eq!(a, []);
+        assert_eq!(b, [4, 2, 3]);
+        assert_eq!(c, [4, 5, 5]);
     }
 }
diff --git a/crates/environ/src/stack_map.rs b/crates/environ/src/stack_map.rs
index a6cbc5a837eb..2737e2642655 100644
--- a/crates/environ/src/stack_map.rs
+++ b/crates/environ/src/stack_map.rs
@@ -1,3 +1,4 @@
+use cranelift_bitset::CompoundBitSet;
 use serde_derive::{Deserialize, Serialize};
 
 /// A map for determining where live GC references live in a stack frame.
@@ -7,30 +8,53 @@ use serde_derive::{Deserialize, Serialize};
 /// the docs over there.
 #[derive(Debug, Serialize, Deserialize)]
 pub struct StackMap {
-    bits: Box<[u32]>,
-    mapped_words: u32,
+    bits: CompoundBitSet,
+    frame_size: u32,
 }
 
 impl StackMap {
     /// Creates a new `StackMap`, typically from a preexisting
     /// `binemit::StackMap`.
-    pub fn new(mapped_words: u32, bits: impl Iterator<Item = u32>) -> StackMap {
-        StackMap {
-            bits: bits.collect(),
-            mapped_words,
-        }
+    pub fn new(frame_size: u32, bits: CompoundBitSet) -> StackMap {
+        StackMap { bits, frame_size }
     }
 
-    /// Returns a specified bit.
-    pub fn get_bit(&self, bit_index: usize) -> bool {
-        assert!(bit_index < 32 * self.bits.len());
-        let word_index = bit_index / 32;
-        let word_offset = bit_index % 32;
-        (self.bits[word_index] & (1 << word_offset)) != 0
+    /// Returns the byte size of this stack map's frame.
+    pub fn frame_size(&self) -> u32 {
+        self.frame_size
     }
 
-    /// Returns the number of words represented by this stack map.
-    pub fn mapped_words(&self) -> u32 {
-        self.mapped_words
+    /// Given a frame pointer, get the stack pointer.
+    ///
+    /// # Safety
+    ///
+    /// The `fp` must be the frame pointer at the code offset that this stack
+    /// map is associated with.
+    pub unsafe fn sp(&self, fp: *mut usize) -> *mut usize {
+        let frame_size = usize::try_from(self.frame_size).unwrap();
+        fp.byte_sub(frame_size)
+    }
+
+    /// Given the stack pointer, get a reference to each live GC reference in
+    /// the stack frame.
+    ///
+    /// # Safety
+    ///
+    /// The `sp` must be the stack pointer at the code offset that this stack
+    /// map is associated with.
+    pub unsafe fn live_gc_refs(&self, sp: *mut usize) -> impl Iterator<Item = *mut u32> + '_ {
+        self.bits.iter().map(move |i| {
+            log::trace!("Live GC ref in frame at frame offset {:#x}", i);
+            let ptr_to_gc_ref = sp.byte_add(i);
+
+            // Assert that the pointer is inside this stack map's frame.
+            assert!({
+                let delta = ptr_to_gc_ref as usize - sp as usize;
+                let frame_size = usize::try_from(self.frame_size).unwrap();
+                delta < frame_size
+            });
+
+            ptr_to_gc_ref.cast::<u32>()
+        })
     }
 }
diff --git a/crates/environ/src/trap_encoding.rs b/crates/environ/src/trap_encoding.rs
index fd714851006a..32d9e19e78f3 100644
--- a/crates/environ/src/trap_encoding.rs
+++ b/crates/environ/src/trap_encoding.rs
@@ -1,22 +1,5 @@
-use crate::obj::ELF_WASMTIME_TRAPS;
-use object::write::{Object, StandardSegment};
-use object::{Bytes, LittleEndian, SectionKind, U32Bytes};
-use std::convert::TryFrom;
-use std::fmt;
-use std::ops::Range;
-
-/// A helper structure to build the custom-encoded section of a wasmtime
-/// compilation image which encodes trap information.
-///
-/// This structure is incrementally fed the results of compiling individual
-/// functions and handles all the encoding internally, allowing usage of
-/// `lookup_trap_code` below with the resulting section.
-#[derive(Default)]
-pub struct TrapEncodingBuilder {
-    offsets: Vec<U32Bytes<LittleEndian>>,
-    traps: Vec<u8>,
-    last_offset: u32,
-}
+use core::fmt;
+use object::{Bytes, LittleEndian, U32Bytes};
 
 /// Information about trap.
 #[derive(Debug, PartialEq, Eq, Clone)]
@@ -91,6 +74,9 @@ pub enum Trap {
     /// Call to a null reference.
     NullReference,
 
+    /// Attempt to get the bits of a null `i31ref`.
+    NullI31Ref,
+
     /// When the `component-model` feature is enabled this trap represents a
     /// scenario where one component tried to call another component but it
     /// would have violated the reentrance rules of the component model,
@@ -99,6 +85,43 @@ pub enum Trap {
     // if adding a variant here be sure to update the `check!` macro below
 }
 
+impl Trap {
+    /// Converts a byte back into a `Trap` if its in-bounds
+    pub fn from_u8(byte: u8) -> Option<Trap> {
+        // FIXME: this could use some sort of derive-like thing to avoid having to
+        // deduplicate the names here.
+        //
+        // This simply converts from the a `u8`, to the `Trap` enum.
+        macro_rules! check {
+            ($($name:ident)*) => ($(if byte == Trap::$name as u8 {
+                return Some(Trap::$name);
+            })*);
+        }
+
+        check! {
+            StackOverflow
+            MemoryOutOfBounds
+            HeapMisaligned
+            TableOutOfBounds
+            IndirectCallToNull
+            BadSignature
+            IntegerOverflow
+            IntegerDivisionByZero
+            BadConversionToInteger
+            UnreachableCodeReached
+            Interrupt
+            AlwaysTrapAdapter
+            OutOfFuel
+            AtomicWaitNonSharedMemory
+            NullReference
+            NullI31Ref
+            CannotEnterComponent
+        }
+
+        None
+    }
+}
+
 impl fmt::Display for Trap {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         use Trap::*;
@@ -119,65 +142,16 @@ impl fmt::Display for Trap {
             OutOfFuel => "all fuel consumed by WebAssembly",
             AtomicWaitNonSharedMemory => "atomic wait on non-shared memory",
             NullReference => "null reference",
+            NullI31Ref => "null i31 reference",
             CannotEnterComponent => "cannot enter component instance",
         };
         write!(f, "wasm trap: {desc}")
     }
 }
 
+#[cfg(feature = "std")]
 impl std::error::Error for Trap {}
 
-impl TrapEncodingBuilder {
-    /// Appends trap information about a function into this section.
-    ///
-    /// This function is called to describe traps for the `func` range
-    /// specified. The `func` offsets are specified relative to the text section
-    /// itself, and the `traps` offsets are specified relative to the start of
-    /// `func`.
-    ///
-    /// This is required to be called in-order for increasing ranges of `func`
-    /// to ensure the final array is properly sorted. Additionally `traps` must
-    /// be sorted.
-    pub fn push(&mut self, func: Range<u64>, traps: &[TrapInformation]) {
-        // NB: for now this only supports <=4GB text sections in object files.
-        // Alternative schemes will need to be created for >32-bit offsets to
-        // avoid making this section overly large.
-        let func_start = u32::try_from(func.start).unwrap();
-        let func_end = u32::try_from(func.end).unwrap();
-
-        // Sanity-check to ensure that functions are pushed in-order, otherwise
-        // the `offsets` array won't be sorted which is our goal.
-        assert!(func_start >= self.last_offset);
-
-        self.offsets.reserve(traps.len());
-        self.traps.reserve(traps.len());
-        for info in traps {
-            let pos = func_start + info.code_offset;
-            assert!(pos >= self.last_offset);
-            self.offsets.push(U32Bytes::new(LittleEndian, pos));
-            self.traps.push(info.trap_code as u8);
-            self.last_offset = pos;
-        }
-
-        self.last_offset = func_end;
-    }
-
-    /// Encodes this section into the object provided.
-    pub fn append_to(self, obj: &mut Object) {
-        let section = obj.add_section(
-            obj.segment_name(StandardSegment::Data).to_vec(),
-            ELF_WASMTIME_TRAPS.as_bytes().to_vec(),
-            SectionKind::ReadOnlyData,
-        );
-
-        // NB: this matches the encoding expected by `lookup` below.
-        let amt = u32::try_from(self.traps.len()).unwrap();
-        obj.append_section_data(section, &amt.to_le_bytes(), 1);
-        obj.append_section_data(section, object::bytes_of_slice(&self.offsets), 1);
-        obj.append_section_data(section, &self.traps, 1);
-    }
-}
-
 /// Decodes the provided trap information section and attempts to find the trap
 /// code corresponding to the `offset` specified.
 ///
@@ -207,40 +181,9 @@ pub fn lookup_trap_code(section: &[u8], offset: usize) -> Option<Trap> {
         .binary_search_by_key(&offset, |val| val.get(LittleEndian))
         .ok()?;
     debug_assert!(index < traps.len());
-    let trap = *traps.get(index)?;
+    let byte = *traps.get(index)?;
 
-    // FIXME: this could use some sort of derive-like thing to avoid having to
-    // deduplicate the names here.
-    //
-    // This simply converts from the `trap`, a `u8`, to the `Trap` enum.
-    macro_rules! check {
-        ($($name:ident)*) => ($(if trap == Trap::$name as u8 {
-            return Some(Trap::$name);
-        })*);
-    }
-
-    check! {
-        StackOverflow
-        MemoryOutOfBounds
-        HeapMisaligned
-        TableOutOfBounds
-        IndirectCallToNull
-        BadSignature
-        IntegerOverflow
-        IntegerDivisionByZero
-        BadConversionToInteger
-        UnreachableCodeReached
-        Interrupt
-        AlwaysTrapAdapter
-        OutOfFuel
-        AtomicWaitNonSharedMemory
-        NullReference
-        CannotEnterComponent
-    }
-
-    if cfg!(debug_assertions) {
-        panic!("missing mapping for {}", trap);
-    } else {
-        None
-    }
+    let trap = Trap::from_u8(byte);
+    debug_assert!(trap.is_some(), "missing mapping for {byte}");
+    trap
 }
diff --git a/crates/environ/src/tunables.rs b/crates/environ/src/tunables.rs
index 7ba3e6fdfc9b..22b96c4abff8 100644
--- a/crates/environ/src/tunables.rs
+++ b/crates/environ/src/tunables.rs
@@ -1,11 +1,13 @@
+use anyhow::{anyhow, bail, Result};
 use serde_derive::{Deserialize, Serialize};
+use target_lexicon::{PointerWidth, Triple};
 
 /// Tunable parameters for WebAssembly compilation.
-#[derive(Clone, Hash, Serialize, Deserialize)]
+#[derive(Clone, Hash, Serialize, Deserialize, Debug)]
 pub struct Tunables {
-    /// For static heaps, the size in wasm pages of the heap protected by bounds
-    /// checking.
-    pub static_memory_bound: u64,
+    /// For static heaps, the size in bytes of virtual memory reservation for
+    /// the heap.
+    pub static_memory_reservation: u64,
 
     /// The size in bytes of the offset guard for static heaps.
     pub static_memory_offset_guard_size: u64,
@@ -40,6 +42,12 @@ pub struct Tunables {
     /// beginning of the allocation in addition to the end.
     pub guard_before_linear_memory: bool,
 
+    /// Whether to initialize tables lazily, so that instantiation is fast but
+    /// indirect calls are a little slower. If false, tables are initialized
+    /// eagerly from any active element segments that apply to them during
+    /// instantiation.
+    pub table_lazy_init: bool,
+
     /// Indicates whether an address map from compiled native code back to wasm
     /// offsets in the original file is generated.
     pub generate_address_map: bool,
@@ -52,66 +60,102 @@ pub struct Tunables {
     /// be deterministic.
     pub relaxed_simd_deterministic: bool,
 
-    /// Whether or not Wasm functions can be tail-called or not.
-    pub tail_callable: bool,
+    /// Whether or not Wasm functions target the winch abi.
+    pub winch_callable: bool,
 }
 
-impl Default for Tunables {
-    fn default() -> Self {
-        let (static_memory_bound, static_memory_offset_guard_size) = if cfg!(miri) {
+impl Tunables {
+    /// Returns a `Tunables` configuration assumed for running code on the host.
+    pub fn default_host() -> Self {
+        if cfg!(miri) {
+            Tunables::default_miri()
+        } else if cfg!(target_pointer_width = "32") {
+            Tunables::default_u32()
+        } else if cfg!(target_pointer_width = "64") {
+            Tunables::default_u64()
+        } else {
+            panic!("unsupported target_pointer_width");
+        }
+    }
+
+    /// Returns the default set of tunables for the given target triple.
+    pub fn default_for_target(target: &Triple) -> Result<Self> {
+        match target
+            .pointer_width()
+            .map_err(|_| anyhow!("failed to retrieve target pointer width"))?
+        {
+            PointerWidth::U32 => Ok(Tunables::default_u32()),
+            PointerWidth::U64 => Ok(Tunables::default_u64()),
+            _ => bail!("unsupported target pointer width"),
+        }
+    }
+
+    /// Returns the default set of tunables for running under MIRI.
+    pub fn default_miri() -> Tunables {
+        Tunables {
             // No virtual memory tricks are available on miri so make these
             // limits quite conservative.
-            ((1 << 20) / crate::WASM_PAGE_SIZE as u64, 0)
-        } else if cfg!(target_pointer_width = "64") {
+            static_memory_reservation: 1 << 20,
+            static_memory_offset_guard_size: 0,
+            dynamic_memory_offset_guard_size: 0,
+            dynamic_memory_growth_reserve: 0,
+
+            // General options which have the same defaults regardless of
+            // architecture.
+            generate_native_debuginfo: false,
+            parse_wasm_debuginfo: true,
+            consume_fuel: false,
+            epoch_interruption: false,
+            static_memory_bound_is_maximum: false,
+            guard_before_linear_memory: true,
+            table_lazy_init: true,
+            generate_address_map: true,
+            debug_adapter_modules: false,
+            relaxed_simd_deterministic: false,
+            winch_callable: false,
+        }
+    }
+
+    /// Returns the default set of tunables for running under a 32-bit host.
+    pub fn default_u32() -> Tunables {
+        Tunables {
+            // For 32-bit we scale way down to 10MB of reserved memory. This
+            // impacts performance severely but allows us to have more than a
+            // few instances running around.
+            static_memory_reservation: 10 * (1 << 20),
+            static_memory_offset_guard_size: 0x1_0000,
+            dynamic_memory_offset_guard_size: 0x1_0000,
+            dynamic_memory_growth_reserve: 1 << 20, // 1MB
+
+            ..Tunables::default_miri()
+        }
+    }
+
+    /// Returns the default set of tunables for running under a 64-bit host.
+    pub fn default_u64() -> Tunables {
+        Tunables {
             // 64-bit has tons of address space to static memories can have 4gb
             // address space reservations liberally by default, allowing us to
             // help eliminate bounds checks.
             //
             // Coupled with a 2 GiB address space guard it lets us translate
             // wasm offsets into x86 offsets as aggressively as we can.
-            (0x1_0000, 0x8000_0000)
-        } else if cfg!(target_pointer_width = "32") {
-            // For 32-bit we scale way down to 10MB of reserved memory. This
-            // impacts performance severely but allows us to have more than a
-            // few instances running around.
-            ((10 * (1 << 20)) / crate::WASM_PAGE_SIZE as u64, 0x1_0000)
-        } else {
-            panic!("unsupported target_pointer_width");
-        };
-        Self {
-            static_memory_bound,
-            static_memory_offset_guard_size,
+            static_memory_reservation: 1 << 32,
+            static_memory_offset_guard_size: 0x8000_0000,
 
             // Size in bytes of the offset guard for dynamic memories.
             //
             // Allocate a small guard to optimize common cases but without
             // wasting too much memory.
-            dynamic_memory_offset_guard_size: if cfg!(miri) { 0 } else { 0x1_0000 },
+            dynamic_memory_offset_guard_size: 0x1_0000,
 
             // We've got lots of address space on 64-bit so use a larger
             // grow-into-this area, but on 32-bit we aren't as lucky. Miri is
             // not exactly fast so reduce memory consumption instead of trying
             // to avoid memory movement.
-            dynamic_memory_growth_reserve: if cfg!(miri) {
-                0
-            } else if cfg!(target_pointer_width = "64") {
-                2 << 30 // 2GB
-            } else if cfg!(target_pointer_width = "32") {
-                1 << 20 // 1MB
-            } else {
-                panic!("unsupported target_pointer_width");
-            },
+            dynamic_memory_growth_reserve: 2 << 30, // 2GB
 
-            generate_native_debuginfo: false,
-            parse_wasm_debuginfo: true,
-            consume_fuel: false,
-            epoch_interruption: false,
-            static_memory_bound_is_maximum: false,
-            guard_before_linear_memory: true,
-            generate_address_map: true,
-            debug_adapter_modules: false,
-            relaxed_simd_deterministic: false,
-            tail_callable: false,
+            ..Tunables::default_miri()
         }
     }
 }
diff --git a/crates/environ/src/vmoffsets.rs b/crates/environ/src/vmoffsets.rs
index a9409568acd7..0868629cd362 100644
--- a/crates/environ/src/vmoffsets.rs
+++ b/crates/environ/src/vmoffsets.rs
@@ -1,5 +1,5 @@
-//! Offsets and sizes of various structs in wasmtime-runtime's vmcontext
-//! module.
+//! Offsets and sizes of various structs in `wasmtime::runtime::vm::*` that are
+//! accessed directly by compiled Wasm code.
 
 // Currently the `VMContext` allocation by field looks like this:
 //
@@ -7,11 +7,14 @@
 //      magic: u32,
 //      _padding: u32, // (On 64-bit systems)
 //      runtime_limits: *const VMRuntimeLimits,
+//      builtin_functions: *mut VMBuiltinFunctionsArray,
 //      callee: *mut VMFunctionBody,
-//      externref_activations_table: *mut VMExternRefActivationsTable,
+//      epoch_ptr: *mut AtomicU64,
+//      gc_heap_base: *mut u8,
+//      gc_heap_bound: *mut u8,
+//      gc_heap_data: *mut T, // Collector-specific pointer
 //      store: *mut dyn Store,
-//      builtins: *mut VMBuiltinFunctionsArray,
-//      signature_ids: *const VMSharedSignatureIndex,
+//      type_ids: *const VMSharedTypeIndex,
 //      imported_functions: [VMFunctionImport; module.num_imported_functions],
 //      imported_tables: [VMTableImport; module.num_imported_tables],
 //      imported_memories: [VMMemoryImport; module.num_imported_memories],
@@ -28,7 +31,6 @@ use crate::{
     GlobalIndex, MemoryIndex, Module, TableIndex,
 };
 use cranelift_entity::packed_option::ReservedValue;
-use std::convert::TryFrom;
 use wasmtime_types::OwnedMemoryIndex;
 
 #[cfg(target_pointer_width = "32")]
@@ -73,14 +75,6 @@ pub struct VMOffsets<P> {
     pub num_escaped_funcs: u32,
 
     // precalculated offsets of various member fields
-    magic: u32,
-    runtime_limits: u32,
-    callee: u32,
-    epoch_ptr: u32,
-    externref_activations_table: u32,
-    store: u32,
-    builtin_functions: u32,
-    signature_ids: u32,
     imported_functions: u32,
     imported_tables: u32,
     imported_memories: u32,
@@ -101,46 +95,45 @@ pub trait PtrSize {
     /// The offset of the `VMContext::runtime_limits` field
     fn vmcontext_runtime_limits(&self) -> u8 {
         u8::try_from(align(
-            u32::try_from(std::mem::size_of::<u32>()).unwrap(),
+            u32::try_from(core::mem::size_of::<u32>()).unwrap(),
             u32::from(self.size()),
         ))
         .unwrap()
     }
 
-    /// The offset of the `native_call` field.
-    #[inline]
-    fn vm_func_ref_native_call(&self) -> u8 {
-        0 * self.size()
+    /// The offset of the `VMContext::builtin_functions` field
+    fn vmcontext_builtin_functions(&self) -> u8 {
+        self.vmcontext_runtime_limits() + self.size()
     }
 
     /// The offset of the `array_call` field.
     #[inline]
     fn vm_func_ref_array_call(&self) -> u8 {
-        1 * self.size()
+        0 * self.size()
     }
 
     /// The offset of the `wasm_call` field.
     #[inline]
     fn vm_func_ref_wasm_call(&self) -> u8 {
-        2 * self.size()
+        1 * self.size()
     }
 
     /// The offset of the `type_index` field.
     #[inline]
     fn vm_func_ref_type_index(&self) -> u8 {
-        3 * self.size()
+        2 * self.size()
     }
 
     /// The offset of the `vmctx` field.
     #[inline]
     fn vm_func_ref_vmctx(&self) -> u8 {
-        4 * self.size()
+        3 * self.size()
     }
 
     /// Return the size of `VMFuncRef`.
     #[inline]
     fn size_of_vm_func_ref(&self) -> u8 {
-        5 * self.size()
+        4 * self.size()
     }
 
     /// Return the size of `VMGlobalDefinition`; this is the size of the largest value type (i.e. a
@@ -180,7 +173,7 @@ pub trait PtrSize {
         self.vmruntime_limits_last_wasm_exit_fp() + self.size()
     }
 
-    /// Return the offset of the `last_enty_sp` field of `VMRuntimeLimits`.
+    /// Return the offset of the `last_wasm_entry_sp` field of `VMRuntimeLimits`.
     fn vmruntime_limits_last_wasm_entry_sp(&self) -> u8 {
         self.vmruntime_limits_last_wasm_exit_pc() + self.size()
     }
@@ -213,25 +206,99 @@ pub trait PtrSize {
 
     // Offsets within `VMArrayCallHostFuncContext`.
 
-    // Offsets within `VMNativeCallHostFuncContext`.
-
-    /// Return the offset of `VMNativeCallHostFuncContext::func_ref`.
-    fn vmnative_call_host_func_context_func_ref(&self) -> u8 {
+    /// Return the offset of `VMArrayCallHostFuncContext::func_ref`.
+    fn vmarray_call_host_func_context_func_ref(&self) -> u8 {
         u8::try_from(align(
-            u32::try_from(std::mem::size_of::<u32>()).unwrap(),
+            u32::try_from(core::mem::size_of::<u32>()).unwrap(),
             u32::from(self.size()),
         ))
         .unwrap()
     }
+
+    /// Return the offset to the `magic` value in this `VMContext`.
+    #[inline]
+    fn vmctx_magic(&self) -> u8 {
+        // This is required by the implementation of `VMContext::instance` and
+        // `VMContext::instance_mut`. If this value changes then those locations
+        // need to be updated.
+        0
+    }
+
+    /// Return the offset to the `VMRuntimeLimits` structure
+    #[inline]
+    fn vmctx_runtime_limits(&self) -> u8 {
+        self.vmctx_magic() + self.size()
+    }
+
+    /// Return the offset to the `VMBuiltinFunctionsArray` structure
+    #[inline]
+    fn vmctx_builtin_functions(&self) -> u8 {
+        self.vmctx_runtime_limits() + self.size()
+    }
+
+    /// Return the offset to the `callee` member in this `VMContext`.
+    #[inline]
+    fn vmctx_callee(&self) -> u8 {
+        self.vmctx_builtin_functions() + self.size()
+    }
+
+    /// Return the offset to the `*const AtomicU64` epoch-counter
+    /// pointer.
+    #[inline]
+    fn vmctx_epoch_ptr(&self) -> u8 {
+        self.vmctx_callee() + self.size()
+    }
+
+    /// Return the offset to the GC heap base in this `VMContext`.
+    #[inline]
+    fn vmctx_gc_heap_base(&self) -> u8 {
+        self.vmctx_epoch_ptr() + self.size()
+    }
+
+    /// Return the offset to the GC heap bound in this `VMContext`.
+    #[inline]
+    fn vmctx_gc_heap_bound(&self) -> u8 {
+        self.vmctx_gc_heap_base() + self.size()
+    }
+
+    /// Return the offset to the `*mut T` collector-specific data.
+    ///
+    /// This is a pointer that different collectors can use however they see
+    /// fit.
+    #[inline]
+    fn vmctx_gc_heap_data(&self) -> u8 {
+        self.vmctx_gc_heap_bound() + self.size()
+    }
+
+    /// The offset of the `*const dyn Store` member.
+    #[inline]
+    fn vmctx_store(&self) -> u8 {
+        self.vmctx_gc_heap_data() + self.size()
+    }
+
+    /// The offset of the `type_ids` array pointer.
+    #[inline]
+    fn vmctx_type_ids_array(&self) -> u8 {
+        self.vmctx_store() + 2 * self.size()
+    }
+
+    /// The end of statically known offsets in `VMContext`.
+    ///
+    /// Data after this is dynamically sized.
+    #[inline]
+    fn vmctx_dynamic_data_start(&self) -> u8 {
+        self.vmctx_type_ids_array() + self.size()
+    }
 }
 
 /// Type representing the size of a pointer for the current compilation host
+#[derive(Clone, Copy)]
 pub struct HostPtr;
 
 impl PtrSize for HostPtr {
     #[inline]
     fn size(&self) -> u8 {
-        std::mem::size_of::<usize>() as u8
+        core::mem::size_of::<usize>() as u8
     }
 }
 
@@ -340,8 +407,11 @@ impl<P: PtrSize> VMOffsets<P> {
                     let $name = last - $name;
                     last = tmp;
                 )*
-                assert_eq!(last, 0);
-                IntoIterator::into_iter([$(($desc, $name),)*])
+                assert_ne!(last, 0);
+                IntoIterator::into_iter([
+                    $(($desc, $name),)*
+                    ("static vmctx data", last),
+                ])
             }};
         }
 
@@ -355,14 +425,6 @@ impl<P: PtrSize> VMOffsets<P> {
             imported_memories: "imported memories",
             imported_tables: "imported tables",
             imported_functions: "imported functions",
-            signature_ids: "module types",
-            builtin_functions: "jit builtin functions state",
-            store: "jit store state",
-            externref_activations_table: "jit host externref state",
-            epoch_ptr: "jit current epoch state",
-            callee: "callee function pointer",
-            runtime_limits: "jit runtime limits state",
-            magic: "magic value",
         }
     }
 }
@@ -380,14 +442,6 @@ impl<P: PtrSize> From<VMOffsetsFields<P>> for VMOffsets<P> {
             num_owned_memories: fields.num_owned_memories,
             num_defined_globals: fields.num_defined_globals,
             num_escaped_funcs: fields.num_escaped_funcs,
-            magic: 0,
-            runtime_limits: 0,
-            callee: 0,
-            epoch_ptr: 0,
-            externref_activations_table: 0,
-            store: 0,
-            builtin_functions: 0,
-            signature_ids: 0,
             imported_functions: 0,
             imported_tables: 0,
             imported_memories: 0,
@@ -414,7 +468,7 @@ impl<P: PtrSize> From<VMOffsetsFields<P>> for VMOffsets<P> {
             count.checked_mul(u32::from(size)).unwrap()
         }
 
-        let mut next_field_offset = 0;
+        let mut next_field_offset = u32::from(ret.ptr.vmctx_dynamic_data_start());
 
         macro_rules! fields {
             (size($field:ident) = $size:expr, $($rest:tt)*) => {
@@ -430,15 +484,6 @@ impl<P: PtrSize> From<VMOffsetsFields<P>> for VMOffsets<P> {
         }
 
         fields! {
-            size(magic) = 4u32,
-            align(u32::from(ret.ptr.size())),
-            size(runtime_limits) = ret.ptr.size(),
-            size(callee) = ret.ptr.size(),
-            size(epoch_ptr) = ret.ptr.size(),
-            size(externref_activations_table) = ret.ptr.size(),
-            size(store) = ret.ptr.size() * 2,
-            size(builtin_functions) = ret.pointer_size(),
-            size(signature_ids) = ret.ptr.size(),
             size(imported_functions)
                 = cmul(ret.num_imported_functions, ret.size_of_vmfunction_import()),
             size(imported_tables)
@@ -464,11 +509,6 @@ impl<P: PtrSize> From<VMOffsetsFields<P>> for VMOffsets<P> {
 
         ret.size = next_field_offset;
 
-        // This is required by the implementation of `VMContext::instance` and
-        // `VMContext::instance_mut`. If this value changes then those locations
-        // need to be updated.
-        assert_eq!(ret.magic, 0);
-
         return ret;
     }
 }
@@ -480,28 +520,22 @@ impl<P: PtrSize> VMOffsets<P> {
         0 * self.pointer_size()
     }
 
-    /// The offset of the `native_call` field.
-    #[inline]
-    pub fn vmfunction_import_native_call(&self) -> u8 {
-        1 * self.pointer_size()
-    }
-
     /// The offset of the `array_call` field.
     #[inline]
     pub fn vmfunction_import_array_call(&self) -> u8 {
-        2 * self.pointer_size()
+        1 * self.pointer_size()
     }
 
     /// The offset of the `vmctx` field.
     #[inline]
     pub fn vmfunction_import_vmctx(&self) -> u8 {
-        3 * self.pointer_size()
+        2 * self.pointer_size()
     }
 
     /// Return the size of `VMFunctionImport`.
     #[inline]
     pub fn size_of_vmfunction_import(&self) -> u8 {
-        4 * self.pointer_size()
+        3 * self.pointer_size()
     }
 }
 
@@ -596,59 +630,17 @@ impl<P: PtrSize> VMOffsets<P> {
     }
 }
 
-/// Offsets for `VMSharedSignatureIndex`.
+/// Offsets for `VMSharedTypeIndex`.
 impl<P: PtrSize> VMOffsets<P> {
-    /// Return the size of `VMSharedSignatureIndex`.
+    /// Return the size of `VMSharedTypeIndex`.
     #[inline]
-    pub fn size_of_vmshared_signature_index(&self) -> u8 {
+    pub fn size_of_vmshared_type_index(&self) -> u8 {
         4
     }
 }
 
 /// Offsets for `VMContext`.
 impl<P: PtrSize> VMOffsets<P> {
-    /// Return the offset to the `magic` value in this `VMContext`.
-    #[inline]
-    pub fn vmctx_magic(&self) -> u32 {
-        self.magic
-    }
-
-    /// Return the offset to the `VMRuntimeLimits` structure
-    #[inline]
-    pub fn vmctx_runtime_limits(&self) -> u32 {
-        self.runtime_limits
-    }
-
-    /// Return the offset to the `callee` member in this `VMContext`.
-    pub fn vmctx_callee(&self) -> u32 {
-        self.callee
-    }
-
-    /// Return the offset to the `*const AtomicU64` epoch-counter
-    /// pointer.
-    #[inline]
-    pub fn vmctx_epoch_ptr(&self) -> u32 {
-        self.epoch_ptr
-    }
-
-    /// The offset of the `*mut VMExternRefActivationsTable` member.
-    #[inline]
-    pub fn vmctx_externref_activations_table(&self) -> u32 {
-        self.externref_activations_table
-    }
-
-    /// The offset of the `*const dyn Store` member.
-    #[inline]
-    pub fn vmctx_store(&self) -> u32 {
-        self.store
-    }
-
-    /// The offset of the `signature_ids` array pointer.
-    #[inline]
-    pub fn vmctx_signature_ids_array(&self) -> u32 {
-        self.signature_ids
-    }
-
     /// The offset of the `tables` array.
     #[inline]
     pub fn vmctx_imported_functions_begin(&self) -> u32 {
@@ -703,12 +695,6 @@ impl<P: PtrSize> VMOffsets<P> {
         self.defined_func_refs
     }
 
-    /// The offset of the builtin functions array.
-    #[inline]
-    pub fn vmctx_builtin_functions(&self) -> u32 {
-        self.builtin_functions
-    }
-
     /// Return the size of the `VMContext` allocation.
     #[inline]
     pub fn size_of_vmctx(&self) -> u32 {
@@ -793,12 +779,6 @@ impl<P: PtrSize> VMOffsets<P> {
         self.vmctx_vmfunction_import(index) + u32::from(self.vmfunction_import_wasm_call())
     }
 
-    /// Return the offset to the `native_call` field in `*const VMFunctionBody` index `index`.
-    #[inline]
-    pub fn vmctx_vmfunction_import_native_call(&self, index: FuncIndex) -> u32 {
-        self.vmctx_vmfunction_import(index) + u32::from(self.vmfunction_import_native_call())
-    }
-
     /// Return the offset to the `array_call` field in `*const VMFunctionBody` index `index`.
     #[inline]
     pub fn vmctx_vmfunction_import_array_call(&self, index: FuncIndex) -> u32 {
@@ -861,26 +841,30 @@ impl<P: PtrSize> VMOffsets<P> {
     }
 }
 
-/// Offsets for `VMExternData`.
+/// Offsets for `VMDrcHeader`.
+///
+/// Should only be used when the DRC collector is enabled.
 impl<P: PtrSize> VMOffsets<P> {
-    /// Return the offset for `VMExternData::ref_count`.
+    /// Return the offset for `VMDrcHeader::ref_count`.
     #[inline]
-    pub fn vm_extern_data_ref_count(&self) -> u32 {
-        0
+    pub fn vm_drc_header_ref_count(&self) -> u32 {
+        8
     }
 }
 
-/// Offsets for `VMExternRefActivationsTable`.
+/// Offsets for `VMGcRefActivationsTable`.
+///
+/// These should only be used when the DRC collector is enabled.
 impl<P: PtrSize> VMOffsets<P> {
-    /// Return the offset for `VMExternRefActivationsTable::next`.
+    /// Return the offset for `VMGcRefActivationsTable::next`.
     #[inline]
-    pub fn vm_extern_ref_activation_table_next(&self) -> u32 {
+    pub fn vm_gc_ref_activation_table_next(&self) -> u32 {
         0
     }
 
-    /// Return the offset for `VMExternRefActivationsTable::end`.
+    /// Return the offset for `VMGcRefActivationsTable::end`.
     #[inline]
-    pub fn vm_extern_ref_activation_table_end(&self) -> u32 {
+    pub fn vm_gc_ref_activation_table_end(&self) -> u32 {
         self.pointer_size().into()
     }
 }
@@ -896,12 +880,6 @@ pub const VMCONTEXT_MAGIC: u32 = u32::from_le_bytes(*b"core");
 /// and double-checked on `VMArrayCallHostFuncContext::from_opaque`.
 pub const VM_ARRAY_CALL_HOST_FUNC_MAGIC: u32 = u32::from_le_bytes(*b"ACHF");
 
-/// Equivalent of `VMCONTEXT_MAGIC` except for native-call host functions.
-///
-/// This is stored at the start of all `VMNativeCallHostFuncContext` structures
-/// and double-checked on `VMNativeCallHostFuncContext::from_opaque`.
-pub const VM_NATIVE_CALL_HOST_FUNC_MAGIC: u32 = u32::from_le_bytes(*b"NCHF");
-
 #[cfg(test)]
 mod tests {
     use crate::vmoffsets::align;
diff --git a/crates/explorer/.prettierignore b/crates/explorer/.prettierignore
new file mode 100644
index 000000000000..bcee57726780
--- /dev/null
+++ b/crates/explorer/.prettierignore
@@ -0,0 +1,6 @@
+*.html
+*.css
+*.toml
+*.rs
+*.yml
+
diff --git a/crates/explorer/.prettierrc b/crates/explorer/.prettierrc
new file mode 100644
index 000000000000..d68aa739ec57
--- /dev/null
+++ b/crates/explorer/.prettierrc
@@ -0,0 +1,3 @@
+{
+  "arrowParens": "avoid"
+}
diff --git a/crates/explorer/Cargo.toml b/crates/explorer/Cargo.toml
index 408518e1e35b..acbd329708f2 100644
--- a/crates/explorer/Cargo.toml
+++ b/crates/explorer/Cargo.toml
@@ -4,16 +4,21 @@ authors.workspace = true
 description = "Compiler explorer for Wasmtime and Cranelift"
 documentation = "https://docs.rs/wasmtime-explorer/"
 edition.workspace = true
+rust-version.workspace = true
 license = "Apache-2.0 WITH LLVM-exception"
 repository = "https://github.com/bytecodealliance/wasmtime"
 version.workspace = true
 
+[lints]
+workspace = true
+
 [dependencies]
 anyhow = { workspace = true }
 capstone = { workspace = true }
 serde = { workspace = true }
 serde_derive = { workspace = true }
 serde_json = { workspace = true }
-target-lexicon = { workspace = true }
+target-lexicon = { workspace = true, features = ['std'] }
 wasmprinter = { workspace = true }
-wasmtime = { workspace = true, features = ["cranelift"] }
+wasmtime = { workspace = true, features = ["cranelift", "runtime"] }
+wasmtime-environ = { workspace = true }
diff --git a/crates/explorer/eslint.config.js b/crates/explorer/eslint.config.js
new file mode 100644
index 000000000000..4ad3b0ddc083
--- /dev/null
+++ b/crates/explorer/eslint.config.js
@@ -0,0 +1,12 @@
+import js from "@eslint/js";
+
+export default [
+  js.configs.recommended,
+
+  {
+    rules: {
+      "no-unused-vars": "error",
+      "no-undef": "error",
+    },
+  },
+];
diff --git a/crates/explorer/package-lock.json b/crates/explorer/package-lock.json
new file mode 100644
index 000000000000..fe6df36aaae6
--- /dev/null
+++ b/crates/explorer/package-lock.json
@@ -0,0 +1,1052 @@
+{
+  "name": "wasmtime-explorer",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "wasmtime-explorer",
+      "version": "1.0.0",
+      "license": "Apache-2.0 WITH LLVM-exception",
+      "devDependencies": {
+        "@eslint/js": "^9.3.0",
+        "eslint": "^9.3.0",
+        "prettier": "3.2.5"
+      }
+    },
+    "node_modules/@eslint-community/eslint-utils": {
+      "version": "4.4.0",
+      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.4.0.tgz",
+      "integrity": "sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==",
+      "dev": true,
+      "dependencies": {
+        "eslint-visitor-keys": "^3.3.0"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "peerDependencies": {
+        "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
+      }
+    },
+    "node_modules/@eslint-community/eslint-utils/node_modules/eslint-visitor-keys": {
+      "version": "3.4.3",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
+      "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
+      "dev": true,
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/@eslint-community/regexpp": {
+      "version": "4.10.0",
+      "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.10.0.tgz",
+      "integrity": "sha512-Cu96Sd2By9mCNTx2iyKOmq10v22jUVQv0lQnlGNy16oE9589yE+QADPbrMGCkA51cKZSg3Pu/aTJVTGfL/qjUA==",
+      "dev": true,
+      "engines": {
+        "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
+      }
+    },
+    "node_modules/@eslint/eslintrc": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.1.0.tgz",
+      "integrity": "sha512-4Bfj15dVJdoy3RfZmmo86RK1Fwzn6SstsvK9JS+BaVKqC6QQQQyXekNaC+g+LKNgkQ+2VhGAzm6hO40AhMR3zQ==",
+      "dev": true,
+      "dependencies": {
+        "ajv": "^6.12.4",
+        "debug": "^4.3.2",
+        "espree": "^10.0.1",
+        "globals": "^14.0.0",
+        "ignore": "^5.2.0",
+        "import-fresh": "^3.2.1",
+        "js-yaml": "^4.1.0",
+        "minimatch": "^3.1.2",
+        "strip-json-comments": "^3.1.1"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/@eslint/js": {
+      "version": "9.3.0",
+      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.3.0.tgz",
+      "integrity": "sha512-niBqk8iwv96+yuTwjM6bWg8ovzAPF9qkICsGtcoa5/dmqcEMfdwNAX7+/OHcJHc7wj7XqPxH98oAHytFYlw6Sw==",
+      "dev": true,
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      }
+    },
+    "node_modules/@humanwhocodes/config-array": {
+      "version": "0.13.0",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.13.0.tgz",
+      "integrity": "sha512-DZLEEqFWQFiyK6h5YIeynKx7JlvCYWL0cImfSRXZ9l4Sg2efkFGTuFf6vzXjK1cq6IYkU+Eg/JizXw+TD2vRNw==",
+      "dev": true,
+      "dependencies": {
+        "@humanwhocodes/object-schema": "^2.0.3",
+        "debug": "^4.3.1",
+        "minimatch": "^3.0.5"
+      },
+      "engines": {
+        "node": ">=10.10.0"
+      }
+    },
+    "node_modules/@humanwhocodes/module-importer": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz",
+      "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==",
+      "dev": true,
+      "engines": {
+        "node": ">=12.22"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/nzakas"
+      }
+    },
+    "node_modules/@humanwhocodes/object-schema": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-2.0.3.tgz",
+      "integrity": "sha512-93zYdMES/c1D69yZiKDBj0V24vqNzB/koF26KPaagAfd3P/4gUlh3Dys5ogAK+Exi9QyzlD8x/08Zt7wIKcDcA==",
+      "dev": true
+    },
+    "node_modules/@humanwhocodes/retry": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.3.0.tgz",
+      "integrity": "sha512-d2CGZR2o7fS6sWB7DG/3a95bGKQyHMACZ5aW8qGkkqQpUoZV6C0X7Pc7l4ZNMZkfNBf4VWNe9E1jRsf0G146Ew==",
+      "dev": true,
+      "engines": {
+        "node": ">=18.18"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/nzakas"
+      }
+    },
+    "node_modules/@nodelib/fs.scandir": {
+      "version": "2.1.5",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
+      "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
+      "dev": true,
+      "dependencies": {
+        "@nodelib/fs.stat": "2.0.5",
+        "run-parallel": "^1.1.9"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/@nodelib/fs.stat": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
+      "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
+      "dev": true,
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/@nodelib/fs.walk": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
+      "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
+      "dev": true,
+      "dependencies": {
+        "@nodelib/fs.scandir": "2.1.5",
+        "fastq": "^1.6.0"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/acorn": {
+      "version": "8.11.3",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.11.3.tgz",
+      "integrity": "sha512-Y9rRfJG5jcKOE0CLisYbojUjIrIEE7AGMzA/Sm4BslANhbS+cDMpgBdcPT91oJ7OuJ9hYJBx59RjbhxVnrF8Xg==",
+      "dev": true,
+      "bin": {
+        "acorn": "bin/acorn"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/acorn-jsx": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
+      "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
+      "dev": true,
+      "peerDependencies": {
+        "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      }
+    },
+    "node_modules/ajv": {
+      "version": "6.12.6",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
+      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
+      "dev": true,
+      "dependencies": {
+        "fast-deep-equal": "^3.1.1",
+        "fast-json-stable-stringify": "^2.0.0",
+        "json-schema-traverse": "^0.4.1",
+        "uri-js": "^4.2.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
+      }
+    },
+    "node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "dev": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dev": true,
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/argparse": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+      "dev": true
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true
+    },
+    "node_modules/brace-expansion": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
+      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "dev": true,
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/callsites": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
+      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
+      "dev": true,
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/chalk": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "dev": true,
+      "dependencies": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "dev": true,
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+      "dev": true
+    },
+    "node_modules/concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
+      "dev": true
+    },
+    "node_modules/cross-spawn": {
+      "version": "7.0.3",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz",
+      "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==",
+      "dev": true,
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/debug": {
+      "version": "4.3.4",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz",
+      "integrity": "sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==",
+      "dev": true,
+      "dependencies": {
+        "ms": "2.1.2"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/deep-is": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
+      "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==",
+      "dev": true
+    },
+    "node_modules/escape-string-regexp": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+      "dev": true,
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/eslint": {
+      "version": "9.3.0",
+      "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.3.0.tgz",
+      "integrity": "sha512-5Iv4CsZW030lpUqHBapdPo3MJetAPtejVW8B84GIcIIv8+ohFaddXsrn1Gn8uD9ijDb+kcYKFUVmC8qG8B2ORQ==",
+      "dev": true,
+      "dependencies": {
+        "@eslint-community/eslint-utils": "^4.2.0",
+        "@eslint-community/regexpp": "^4.6.1",
+        "@eslint/eslintrc": "^3.1.0",
+        "@eslint/js": "9.3.0",
+        "@humanwhocodes/config-array": "^0.13.0",
+        "@humanwhocodes/module-importer": "^1.0.1",
+        "@humanwhocodes/retry": "^0.3.0",
+        "@nodelib/fs.walk": "^1.2.8",
+        "ajv": "^6.12.4",
+        "chalk": "^4.0.0",
+        "cross-spawn": "^7.0.2",
+        "debug": "^4.3.2",
+        "escape-string-regexp": "^4.0.0",
+        "eslint-scope": "^8.0.1",
+        "eslint-visitor-keys": "^4.0.0",
+        "espree": "^10.0.1",
+        "esquery": "^1.4.2",
+        "esutils": "^2.0.2",
+        "fast-deep-equal": "^3.1.3",
+        "file-entry-cache": "^8.0.0",
+        "find-up": "^5.0.0",
+        "glob-parent": "^6.0.2",
+        "ignore": "^5.2.0",
+        "imurmurhash": "^0.1.4",
+        "is-glob": "^4.0.0",
+        "is-path-inside": "^3.0.3",
+        "json-stable-stringify-without-jsonify": "^1.0.1",
+        "levn": "^0.4.1",
+        "lodash.merge": "^4.6.2",
+        "minimatch": "^3.1.2",
+        "natural-compare": "^1.4.0",
+        "optionator": "^0.9.3",
+        "strip-ansi": "^6.0.1",
+        "text-table": "^0.2.0"
+      },
+      "bin": {
+        "eslint": "bin/eslint.js"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/eslint-scope": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.0.1.tgz",
+      "integrity": "sha512-pL8XjgP4ZOmmwfFE8mEhSxA7ZY4C+LWyqjQ3o4yWkkmD0qcMT9kkW3zWHOczhWcjTSgqycYAgwSlXvZltv65og==",
+      "dev": true,
+      "dependencies": {
+        "esrecurse": "^4.3.0",
+        "estraverse": "^5.2.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/eslint-visitor-keys": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.0.0.tgz",
+      "integrity": "sha512-OtIRv/2GyiF6o/d8K7MYKKbXrOUBIK6SfkIRM4Z0dY3w+LiQ0vy3F57m0Z71bjbyeiWFiHJ8brqnmE6H6/jEuw==",
+      "dev": true,
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/espree": {
+      "version": "10.0.1",
+      "resolved": "https://registry.npmjs.org/espree/-/espree-10.0.1.tgz",
+      "integrity": "sha512-MWkrWZbJsL2UwnjxTX3gG8FneachS/Mwg7tdGXce011sJd5b0JG54vat5KHnfSBODZ3Wvzd2WnjxyzsRoVv+ww==",
+      "dev": true,
+      "dependencies": {
+        "acorn": "^8.11.3",
+        "acorn-jsx": "^5.3.2",
+        "eslint-visitor-keys": "^4.0.0"
+      },
+      "engines": {
+        "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/esquery": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.5.0.tgz",
+      "integrity": "sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg==",
+      "dev": true,
+      "dependencies": {
+        "estraverse": "^5.1.0"
+      },
+      "engines": {
+        "node": ">=0.10"
+      }
+    },
+    "node_modules/esrecurse": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz",
+      "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
+      "dev": true,
+      "dependencies": {
+        "estraverse": "^5.2.0"
+      },
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/estraverse": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
+      "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
+      "dev": true,
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/esutils": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
+      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/fast-deep-equal": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+      "dev": true
+    },
+    "node_modules/fast-json-stable-stringify": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
+      "dev": true
+    },
+    "node_modules/fast-levenshtein": {
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
+      "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==",
+      "dev": true
+    },
+    "node_modules/fastq": {
+      "version": "1.17.1",
+      "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.17.1.tgz",
+      "integrity": "sha512-sRVD3lWVIXWg6By68ZN7vho9a1pQcN/WBFaAAsDDFzlJjvoGx0P8z7V1t72grFJfJhu3YPZBuu25f7Kaw2jN1w==",
+      "dev": true,
+      "dependencies": {
+        "reusify": "^1.0.4"
+      }
+    },
+    "node_modules/file-entry-cache": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz",
+      "integrity": "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==",
+      "dev": true,
+      "dependencies": {
+        "flat-cache": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=16.0.0"
+      }
+    },
+    "node_modules/find-up": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
+      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
+      "dev": true,
+      "dependencies": {
+        "locate-path": "^6.0.0",
+        "path-exists": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/flat-cache": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz",
+      "integrity": "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==",
+      "dev": true,
+      "dependencies": {
+        "flatted": "^3.2.9",
+        "keyv": "^4.5.4"
+      },
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/flatted": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.1.tgz",
+      "integrity": "sha512-X8cqMLLie7KsNUDSdzeN8FYK9rEt4Dt67OsG/DNGnYTSDBG4uFAJFBnUeiV+zCVAvwFy56IjM9sH51jVaEhNxw==",
+      "dev": true
+    },
+    "node_modules/glob-parent": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
+      "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
+      "dev": true,
+      "dependencies": {
+        "is-glob": "^4.0.3"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
+    "node_modules/globals": {
+      "version": "14.0.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz",
+      "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==",
+      "dev": true,
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+      "dev": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/ignore": {
+      "version": "5.3.1",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.1.tgz",
+      "integrity": "sha512-5Fytz/IraMjqpwfd34ke28PTVMjZjJG2MPn5t7OE4eUCUNf8BAa7b5WUS9/Qvr6mwOQS7Mk6vdsMno5he+T8Xw==",
+      "dev": true,
+      "engines": {
+        "node": ">= 4"
+      }
+    },
+    "node_modules/import-fresh": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz",
+      "integrity": "sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==",
+      "dev": true,
+      "dependencies": {
+        "parent-module": "^1.0.0",
+        "resolve-from": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/imurmurhash": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
+      "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.8.19"
+      }
+    },
+    "node_modules/is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-glob": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+      "dev": true,
+      "dependencies": {
+        "is-extglob": "^2.1.1"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-path-inside": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz",
+      "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==",
+      "dev": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+      "dev": true
+    },
+    "node_modules/js-yaml": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
+      "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
+      "dev": true,
+      "dependencies": {
+        "argparse": "^2.0.1"
+      },
+      "bin": {
+        "js-yaml": "bin/js-yaml.js"
+      }
+    },
+    "node_modules/json-buffer": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
+      "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
+      "dev": true
+    },
+    "node_modules/json-schema-traverse": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+      "dev": true
+    },
+    "node_modules/json-stable-stringify-without-jsonify": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
+      "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==",
+      "dev": true
+    },
+    "node_modules/keyv": {
+      "version": "4.5.4",
+      "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
+      "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
+      "dev": true,
+      "dependencies": {
+        "json-buffer": "3.0.1"
+      }
+    },
+    "node_modules/levn": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
+      "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
+      "dev": true,
+      "dependencies": {
+        "prelude-ls": "^1.2.1",
+        "type-check": "~0.4.0"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/locate-path": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
+      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
+      "dev": true,
+      "dependencies": {
+        "p-locate": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/lodash.merge": {
+      "version": "4.6.2",
+      "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
+      "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==",
+      "dev": true
+    },
+    "node_modules/minimatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+      "dev": true,
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
+      "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==",
+      "dev": true
+    },
+    "node_modules/natural-compare": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
+      "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==",
+      "dev": true
+    },
+    "node_modules/optionator": {
+      "version": "0.9.4",
+      "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
+      "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==",
+      "dev": true,
+      "dependencies": {
+        "deep-is": "^0.1.3",
+        "fast-levenshtein": "^2.0.6",
+        "levn": "^0.4.1",
+        "prelude-ls": "^1.2.1",
+        "type-check": "^0.4.0",
+        "word-wrap": "^1.2.5"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/p-limit": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
+      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
+      "dev": true,
+      "dependencies": {
+        "yocto-queue": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/p-locate": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
+      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
+      "dev": true,
+      "dependencies": {
+        "p-limit": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/parent-module": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
+      "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
+      "dev": true,
+      "dependencies": {
+        "callsites": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/path-exists": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
+      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
+      "dev": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+      "dev": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/prelude-ls": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
+      "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
+      "dev": true,
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/prettier": {
+      "version": "3.2.5",
+      "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.2.5.tgz",
+      "integrity": "sha512-3/GWa9aOC0YeD7LUfvOG2NiDyhOWRvt1k+rcKhOuYnMY24iiCphgneUfJDyFXd6rZCAnuLBv6UeAULtrhT/F4A==",
+      "dev": true,
+      "bin": {
+        "prettier": "bin/prettier.cjs"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/prettier/prettier?sponsor=1"
+      }
+    },
+    "node_modules/punycode": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
+      "dev": true,
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/queue-microtask": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
+      "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ]
+    },
+    "node_modules/resolve-from": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
+      "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
+      "dev": true,
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/reusify": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz",
+      "integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==",
+      "dev": true,
+      "engines": {
+        "iojs": ">=1.0.0",
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/run-parallel": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
+      "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "dependencies": {
+        "queue-microtask": "^1.2.2"
+      }
+    },
+    "node_modules/shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "dev": true,
+      "dependencies": {
+        "shebang-regex": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+      "dev": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "dev": true,
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/strip-json-comments": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
+      "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
+      "dev": true,
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "dev": true,
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/text-table": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz",
+      "integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==",
+      "dev": true
+    },
+    "node_modules/type-check": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
+      "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==",
+      "dev": true,
+      "dependencies": {
+        "prelude-ls": "^1.2.1"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/uri-js": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
+      "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
+      "dev": true,
+      "dependencies": {
+        "punycode": "^2.1.0"
+      }
+    },
+    "node_modules/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "dev": true,
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/node-which"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/word-wrap": {
+      "version": "1.2.5",
+      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
+      "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/yocto-queue": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
+      "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
+      "dev": true,
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    }
+  }
+}
diff --git a/crates/explorer/package.json b/crates/explorer/package.json
new file mode 100644
index 000000000000..4b3ff9421bb6
--- /dev/null
+++ b/crates/explorer/package.json
@@ -0,0 +1,28 @@
+{
+  "name": "wasmtime-explorer",
+  "version": "1.0.0",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "lint": "eslint",
+    "fmt": "prettier --write .",
+    "fmt-check": "prettier --check ."
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bytecodealliance/wasmtime.git#main"
+  },
+  "author": "The Wasmtime Project Developers",
+  "license": "Apache-2.0 WITH LLVM-exception",
+  "bugs": {
+    "url": "https://github.com/bytecodealliance/wasmtime/issues"
+  },
+  "homepage": "https://github.com/bytecodealliance/wasmtime/tree/main#readme",
+  "description": "",
+  "devDependencies": {
+    "@eslint/js": "^9.3.0",
+    "eslint": "^9.3.0",
+    "prettier": "3.2.5"
+  },
+  "type": "module"
+}
diff --git a/crates/explorer/src/index.css b/crates/explorer/src/index.css
index ba23a1fbe70d..9bba90f6150f 100644
--- a/crates/explorer/src/index.css
+++ b/crates/explorer/src/index.css
@@ -1,26 +1,33 @@
 * {
-    margin: 0;
-    padding: 0;
+  margin: 0;
+  padding: 0;
 }
 
 .hbox {
-    display: flex;
-    flex-direction: row;
+  display: flex;
+  flex-direction: row;
 }
 
-html, body {
-    width: 100%;
-    height: 100%;
+html,
+body {
+  width: 100%;
+  height: 100%;
 }
 
 #wat {
-    width: 50%;
-    height: 100%;
-    overflow: scroll;
+  flex: 1;
+  height: 100%;
+  overflow: scroll;
+}
+
+#clif {
+  flex: 1;
+  height: 100%;
+  overflow: scroll;
 }
 
 #asm {
-    width: 50%;
-    height: 100%;
-    overflow: scroll;
+  flex: 1;
+  height: 100%;
+  overflow: scroll;
 }
diff --git a/crates/explorer/src/index.js b/crates/explorer/src/index.js
index afcfac9e5bdc..4663efce6901 100644
--- a/crates/explorer/src/index.js
+++ b/crates/explorer/src/index.js
@@ -1,33 +1,21 @@
+/* global window, document */
+
 /*** State *********************************************************************/
 
 class State {
-  constructor(wat, asm) {
+  constructor(wat, clif, asm) {
     this.wat = wat;
+    this.clif = clif;
     this.asm = asm;
   }
 }
 
-const state = window.STATE = new State(window.WAT, window.ASM);
+const state = (window.STATE = new State(window.WAT, window.CLIF, window.ASM));
 
 /*** Hues for Offsets **********************************************************/
 
 const hues = [
-  80,
-  160,
-  240,
-  320,
-  40,
-  120,
-  200,
-  280,
-  20,
-  100,
-  180,
-  260,
-  340,
-  60,
-  140,
-  220,
+  80, 160, 240, 320, 40, 120, 200, 280, 20, 100, 180, 260, 340, 60, 140, 220,
   300,
 ];
 
@@ -36,7 +24,7 @@ const nextHue = (function () {
   return () => {
     return hues[++i % hues.length];
   };
-}());
+})();
 
 // NB: don't just assign hues based on something simple like `hues[offset %
 // hues.length]` since that can suffer from bias due to certain alignments
@@ -67,6 +55,9 @@ const watByOffset = new Map();
 // Get asm instruction elements by Wasm offset.
 const asmByOffset = new Map();
 
+// Get clif instruction elements by Wasm offset.
+const clifByOffset = new Map();
+
 // Get all (WAT chunk or asm instruction) elements by offset.
 const anyByOffset = new Map();
 
@@ -94,45 +85,107 @@ const addAsmElem = (offset, elem) => {
   anyByOffset.get(offset).push(elem);
 };
 
+const addClifElem = (offset, elem) => {
+  if (!clifByOffset.has(offset)) {
+    clifByOffset.set(offset, []);
+  }
+  clifByOffset.get(offset).push(elem);
+
+  if (!anyByOffset.has(offset)) {
+    anyByOffset.set(offset, []);
+  }
+  anyByOffset.get(offset).push(elem);
+};
+
 /*** Event Handlers ************************************************************/
 
 const watElem = document.getElementById("wat");
-watElem.addEventListener("click", event => {
-  if (event.target.dataset.wasmOffset == null) {
-    return;
-  }
+watElem.addEventListener(
+  "click",
+  event => {
+    if (event.target.dataset.wasmOffset == null) {
+      return;
+    }
 
-  const offset = parseInt(event.target.dataset.wasmOffset);
-  if (!asmByOffset.get(offset)) {
-    return;
-  }
+    const offset = parseInt(event.target.dataset.wasmOffset);
+    if (!asmByOffset.get(offset)) {
+      return;
+    }
 
-  const firstAsmElem = asmByOffset.get(offset)[0];
-  firstAsmElem.scrollIntoView({
-    behavior: "smooth",
-    block: "center",
-    inline: "nearest",
-  });
-}, { passive: true });
+    const firstClifElem = clifByOffset.get(offset)[0];
+    firstClifElem.scrollIntoView({
+      behavior: "smooth",
+      block: "center",
+      inline: "nearest",
+    });
+    const firstAsmElem = asmByOffset.get(offset)[0];
+    firstAsmElem.scrollIntoView({
+      behavior: "smooth",
+      block: "center",
+      inline: "nearest",
+    });
+  },
+  { passive: true },
+);
 
 const asmElem = document.getElementById("asm");
-asmElem.addEventListener("click", event => {
-  if (event.target.dataset.wasmOffset == null) {
-    return;
-  }
+asmElem.addEventListener(
+  "click",
+  event => {
+    if (event.target.dataset.wasmOffset == null) {
+      return;
+    }
 
-  const offset = parseInt(event.target.dataset.wasmOffset);
-  if (!watByOffset.get(offset)) {
-    return;
-  }
+    const offset = parseInt(event.target.dataset.wasmOffset);
+    if (!watByOffset.get(offset)) {
+      return;
+    }
 
-  const firstWatElem = watByOffset.get(offset)[0];
-  firstWatElem.scrollIntoView({
-    behavior: "smooth",
-    block: "center",
-    inline: "nearest",
-  });
-}, { passive: true });
+    const firstWatElem = watByOffset.get(offset)[0];
+    firstWatElem.scrollIntoView({
+      behavior: "smooth",
+      block: "center",
+      inline: "nearest",
+    });
+    const firstClifElem = clifByOffset.get(offset)[0];
+    firstClifElem.scrollIntoView({
+      behavior: "smooth",
+      block: "center",
+      inline: "nearest",
+    });
+  },
+  { passive: true },
+);
+const clifElem = document.getElementById("clif");
+if (clifElem) {
+  clifElem.addEventListener(
+    "click",
+    event => {
+      if (event.target.dataset.wasmOffset == null) {
+        return;
+      }
+
+      const offset = parseInt(event.target.dataset.wasmOffset);
+      if (!watByOffset.get(offset)) {
+        return;
+      }
+
+      const firstWatElem = watByOffset.get(offset)[0];
+      firstWatElem.scrollIntoView({
+        behavior: "smooth",
+        block: "center",
+        inline: "nearest",
+      });
+      const firstAsmElem = asmByOffset.get(offset)[0];
+      firstAsmElem.scrollIntoView({
+        behavior: "smooth",
+        block: "center",
+        inline: "nearest",
+      });
+    },
+    { passive: true },
+  );
+}
 
 const onMouseEnter = event => {
   if (event.target.dataset.wasmOffset == null) {
@@ -189,14 +242,53 @@ const renderInst = (mnemonic, operands) => {
   }
 };
 
+// Render the CLIF.
+
+if (clifElem) {
+  for (const func of state.clif.functions) {
+    const funcElem = document.createElement("div");
+
+    const funcHeader = document.createElement("h3");
+    let func_name =
+      func.name === null ? `function[${func.func_index}]` : func.name;
+    let demangled_name =
+      func.demangled_name !== null ? func.demangled_name : func_name;
+    funcHeader.textContent = `Intermediate Representation of function <${demangled_name}>:`;
+    funcHeader.title = `Function ${func.func_index}: ${func_name}`;
+    funcElem.appendChild(funcHeader);
+
+    const bodyElem = document.createElement("pre");
+    for (const inst of func.instructions) {
+      const instElem = document.createElement("span");
+      instElem.textContent = `${inst.clif}\n`;
+      if (inst.wasm_offset != null) {
+        instElem.setAttribute("data-wasm-offset", inst.wasm_offset);
+        const hue = hueForOffset(inst.wasm_offset);
+        instElem.style.backgroundColor = `hsl(${hue} 50% 90%)`;
+        instElem.addEventListener("mouseenter", onMouseEnter);
+        instElem.addEventListener("mouseleave", onMouseLeave);
+        addClifElem(inst.wasm_offset, instElem);
+      }
+      bodyElem.appendChild(instElem);
+    }
+    funcElem.appendChild(bodyElem);
+
+    clifElem.appendChild(funcElem);
+  }
+}
+
 // Render the ASM.
 
-let nthFunc = 0;
 for (const func of state.asm.functions) {
   const funcElem = document.createElement("div");
 
   const funcHeader = document.createElement("h3");
-  funcHeader.textContent = `Defined Function ${nthFunc}`;
+  let func_name =
+    func.name === null ? `function[${func.func_index}]` : func.name;
+  let demangled_name =
+    func.demangled_name !== null ? func.demangled_name : func_name;
+  funcHeader.textContent = `Disassembly of function <${demangled_name}>:`;
+  funcHeader.title = `Function ${func.func_index}: ${func_name}`;
   funcElem.appendChild(funcHeader);
 
   const bodyElem = document.createElement("pre");
@@ -216,7 +308,6 @@ for (const func of state.asm.functions) {
   funcElem.appendChild(bodyElem);
 
   asmElem.appendChild(funcElem);
-  nthFunc++;
 }
 
 // Render the WAT.
diff --git a/crates/explorer/src/lib.rs b/crates/explorer/src/lib.rs
index 0b92aae71412..11af007791a9 100644
--- a/crates/explorer/src/lib.rs
+++ b/crates/explorer/src/lib.rs
@@ -1,11 +1,18 @@
 use anyhow::Result;
 use capstone::arch::BuildsCapstone;
 use serde_derive::Serialize;
-use std::{io::Write, str::FromStr};
+use std::{
+    fs::File,
+    io::{read_to_string, Write},
+    path::Path,
+    str::FromStr,
+};
+use wasmtime_environ::demangle_function_name;
 
 pub fn generate(
     config: &wasmtime::Config,
     target: Option<&str>,
+    clif_dir: Option<&Path>,
     wasm: &[u8],
     dest: &mut dyn Write,
 ) -> Result<()> {
@@ -18,6 +25,12 @@ pub fn generate(
     let wat_json = serde_json::to_string(&wat)?;
     let asm = annotate_asm(config, &target, wasm)?;
     let asm_json = serde_json::to_string(&asm)?;
+    let clif_json = clif_dir
+        .map::<anyhow::Result<String>, _>(|clif_dir| {
+            let clif = annotate_clif(clif_dir, &asm)?;
+            Ok(serde_json::to_string(&clif)?)
+        })
+        .transpose()?;
 
     let index_css = include_str!("./index.css");
     let index_js = include_str!("./index.js");
@@ -35,9 +48,30 @@ pub fn generate(
   </head>
   <body class="hbox">
     <pre id="wat"></pre>
+        "#
+    )?;
+    if clif_json.is_some() {
+        write!(dest, r#"<div id="clif"></div>"#)?;
+    }
+    write!(
+        dest,
+        r#"
     <div id="asm"></div>
     <script>
       window.WAT = {wat_json};
+        "#
+    )?;
+    if let Some(clif_json) = clif_json {
+        write!(
+            dest,
+            r#"
+          window.CLIF = {clif_json};
+            "#
+        )?;
+    }
+    write!(
+        dest,
+        r#"
       window.ASM = {asm_json};
     </script>
     <script>
@@ -65,9 +99,10 @@ struct AnnotatedWatChunk {
 }
 
 fn annotate_wat(wasm: &[u8]) -> Result<AnnotatedWat> {
-    let mut printer = wasmprinter::Printer::new();
+    let printer = wasmprinter::Config::new();
+    let mut storage = String::new();
     let chunks = printer
-        .offsets_and_lines(wasm)?
+        .offsets_and_lines(wasm, &mut storage)?
         .map(|(offset, wat)| AnnotatedWatChunk {
             wasm_offset: offset.map(|o| WasmOffset(u32::try_from(o).unwrap())),
             wat: wat.to_string(),
@@ -83,6 +118,9 @@ struct AnnotatedAsm {
 
 #[derive(Serialize, Debug)]
 struct AnnotatedFunction {
+    func_index: u32,
+    name: Option<String>,
+    demangled_name: Option<String>,
     instructions: Vec<AnnotatedInstruction>,
 }
 
@@ -129,10 +167,9 @@ fn annotate_asm(
     };
 
     let functions = module
-        .function_locations()
-        .into_iter()
-        .map(|(start, len)| {
-            let body = &text[start..][..len];
+        .functions()
+        .map(|function| {
+            let body = &text[function.offset..][..function.len];
 
             let mut cs = match target.architecture {
                 target_lexicon::Architecture::Aarch64(_) => capstone::Capstone::new()
@@ -165,13 +202,13 @@ fn annotate_asm(
             cs.set_skipdata(true).unwrap();
 
             let instructions = cs
-                .disasm_all(body, start as u64)
+                .disasm_all(body, function.offset as u64)
                 .map_err(|e| anyhow::anyhow!("{e}"))?;
             let instructions = instructions
                 .iter()
                 .map(|inst| {
                     let address = u32::try_from(inst.address()).unwrap();
-                    let wasm_offset = wasm_offset_for_address(start, address);
+                    let wasm_offset = wasm_offset_for_address(function.offset, address);
                     Ok(AnnotatedInstruction {
                         wasm_offset,
                         address,
@@ -181,9 +218,82 @@ fn annotate_asm(
                     })
                 })
                 .collect::<Result<Vec<_>>>()?;
-            Ok(AnnotatedFunction { instructions })
+
+            let demangled_name = if let Some(name) = &function.name {
+                let mut demangled = String::new();
+                if demangle_function_name(&mut demangled, &name).is_ok() {
+                    Some(demangled)
+                } else {
+                    None
+                }
+            } else {
+                None
+            };
+
+            Ok(AnnotatedFunction {
+                func_index: function.index.as_u32(),
+                name: function.name,
+                demangled_name,
+                instructions,
+            })
         })
         .collect::<Result<Vec<_>>>()?;
 
     Ok(AnnotatedAsm { functions })
 }
+
+#[derive(Serialize, Debug)]
+struct AnnotatedClif {
+    functions: Vec<AnnotatedClifFunction>,
+}
+
+#[derive(Serialize, Debug)]
+struct AnnotatedClifFunction {
+    func_index: u32,
+    name: Option<String>,
+    demangled_name: Option<String>,
+    instructions: Vec<AnnotatedClifInstruction>,
+}
+
+#[derive(Serialize, Debug)]
+struct AnnotatedClifInstruction {
+    wasm_offset: Option<WasmOffset>,
+    clif: String,
+}
+
+fn annotate_clif(clif_dir: &Path, asm: &AnnotatedAsm) -> Result<AnnotatedClif> {
+    let mut clif = AnnotatedClif {
+        functions: Vec::new(),
+    };
+    for function in &asm.functions {
+        let function_path = clif_dir.join(format!("wasm_func_{}.clif", function.func_index));
+        if !function_path.exists() {
+            continue;
+        }
+        let mut clif_function = AnnotatedClifFunction {
+            func_index: function.func_index,
+            name: function.name.clone(),
+            demangled_name: function.demangled_name.clone(),
+            instructions: Vec::new(),
+        };
+        let file = File::open(&function_path)?;
+        for mut line in read_to_string(file)?.lines() {
+            if line.is_empty() {
+                continue;
+            }
+            let mut wasm_offset = None;
+            if line.starts_with('@') {
+                wasm_offset = Some(WasmOffset(u32::from_str_radix(&line[1..5], 16)?));
+                line = &line[28..];
+            } else if line.starts_with("     ") {
+                line = &line[28..];
+            }
+            clif_function.instructions.push(AnnotatedClifInstruction {
+                wasm_offset,
+                clif: line.to_string(),
+            });
+        }
+        clif.functions.push(clif_function);
+    }
+    Ok(clif)
+}
diff --git a/crates/fiber/Cargo.toml b/crates/fiber/Cargo.toml
index 4c221ee1f528..8d83fd03553f 100644
--- a/crates/fiber/Cargo.toml
+++ b/crates/fiber/Cargo.toml
@@ -6,8 +6,13 @@ description = "Fiber support for Wasmtime"
 license = "Apache-2.0 WITH LLVM-exception"
 repository = "https://github.com/bytecodealliance/wasmtime"
 edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
 
 [dependencies]
+anyhow = { workspace = true }
 cfg-if = { workspace = true }
 wasmtime-versioned-export-macros = { workspace = true }
 
diff --git a/crates/fiber/build.rs b/crates/fiber/build.rs
index 079a58167617..19e7a516259c 100644
--- a/crates/fiber/build.rs
+++ b/crates/fiber/build.rs
@@ -5,6 +5,19 @@ fn main() {
     let mut build = cc::Build::new();
     let arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap();
     let os = env::var("CARGO_CFG_TARGET_OS").unwrap();
+
+    // NB: Technically `cfg(sanitize = "address")` is not stable and requires a
+    // `#![feature]` but sort of abuse the fact that cfgs are "leaked" through
+    // into Cargo ungated via `--print cfg`. Translate that to `cfg(asan)` for
+    // us to write down in the code.
+    println!("cargo:rustc-check-cfg=cfg(asan)");
+    match env::var("CARGO_CFG_SANITIZE") {
+        Ok(s) if s == "address" => {
+            println!("cargo:rustc-cfg=asan");
+        }
+        _ => {}
+    }
+
     if os == "windows" {
         println!("cargo:rerun-if-changed=src/windows.c");
         build.file("src/windows.c");
@@ -20,7 +33,7 @@ fn main() {
         println!("cargo:rerun-if-changed=build.rs");
         return;
     }
-    build.define(&format!("CFG_TARGET_OS_{}", os), None);
-    build.define(&format!("CFG_TARGET_ARCH_{}", arch), None);
+    build.define(&format!("CFG_TARGET_OS_{os}"), None);
+    build.define(&format!("CFG_TARGET_ARCH_{arch}"), None);
     build.compile("wasmtime-fiber");
 }
diff --git a/crates/fiber/src/lib.rs b/crates/fiber/src/lib.rs
index 79d7bdaa69e4..16fb10bd2b23 100644
--- a/crates/fiber/src/lib.rs
+++ b/crates/fiber/src/lib.rs
@@ -1,3 +1,4 @@
+use anyhow::Error;
 use std::any::Any;
 use std::cell::Cell;
 use std::io;
@@ -18,7 +19,6 @@ cfg_if::cfg_if! {
 }
 
 /// Represents an execution stack to use for a fiber.
-#[derive(Debug)]
 pub struct FiberStack(imp::FiberStack);
 
 impl FiberStack {
@@ -27,6 +27,11 @@ impl FiberStack {
         Ok(Self(imp::FiberStack::new(size)?))
     }
 
+    /// Creates a new fiber stack of the given size.
+    pub fn from_custom(custom: Box<dyn RuntimeFiberStack>) -> io::Result<Self> {
+        Ok(Self(imp::FiberStack::from_custom(custom)?))
+    }
+
     /// Creates a new fiber stack with the given pointer to the bottom of the
     /// stack plus the byte length of the stack.
     ///
@@ -56,10 +61,34 @@ impl FiberStack {
     pub fn range(&self) -> Option<Range<usize>> {
         self.0.range()
     }
+
+    /// Is this a manually-managed stack created from raw parts? If so, it is up
+    /// to whoever created it to manage the stack's memory allocation.
+    pub fn is_from_raw_parts(&self) -> bool {
+        self.0.is_from_raw_parts()
+    }
+}
+
+/// A creator of RuntimeFiberStacks.
+pub unsafe trait RuntimeFiberStackCreator: Send + Sync {
+    /// Creates a new RuntimeFiberStack with the specified size, guard pages should be included,
+    /// memory should be zeroed.
+    ///
+    /// This is useful to plugin previously allocated memory instead of mmap'ing a new stack for
+    /// every instance.
+    fn new_stack(&self, size: usize) -> Result<Box<dyn RuntimeFiberStack>, Error>;
+}
+
+/// A fiber stack backed by custom memory.
+pub unsafe trait RuntimeFiberStack: Send + Sync {
+    /// The top of the allocated stack.
+    fn top(&self) -> *mut u8;
+    /// The valid range of the stack without guard pages.
+    fn range(&self) -> Range<usize>;
 }
 
 pub struct Fiber<'a, Resume, Yield, Return> {
-    stack: FiberStack,
+    stack: Option<FiberStack>,
     inner: imp::Fiber,
     done: Cell<bool>,
     _phantom: PhantomData<&'a (Resume, Yield, Return)>,
@@ -86,12 +115,12 @@ impl<'a, Resume, Yield, Return> Fiber<'a, Resume, Yield, Return> {
     /// `Fiber::suspend`.
     pub fn new(
         stack: FiberStack,
-        func: impl FnOnce(Resume, &Suspend<Resume, Yield, Return>) -> Return + 'a,
+        func: impl FnOnce(Resume, &mut Suspend<Resume, Yield, Return>) -> Return + 'a,
     ) -> io::Result<Self> {
         let inner = imp::Fiber::new(&stack.0, func)?;
 
         Ok(Self {
-            stack,
+            stack: Some(stack),
             inner,
             done: Cell::new(false),
             _phantom: PhantomData,
@@ -116,7 +145,7 @@ impl<'a, Resume, Yield, Return> Fiber<'a, Resume, Yield, Return> {
     pub fn resume(&self, val: Resume) -> Result<Return, Yield> {
         assert!(!self.done.replace(true), "cannot resume a finished fiber");
         let result = Cell::new(RunResult::Resuming(val));
-        self.inner.resume(&self.stack.0, &result);
+        self.inner.resume(&self.stack().0, &result);
         match result.into_inner() {
             RunResult::Resuming(_) | RunResult::Executing => unreachable!(),
             RunResult::Yield(y) => {
@@ -135,7 +164,13 @@ impl<'a, Resume, Yield, Return> Fiber<'a, Resume, Yield, Return> {
 
     /// Gets the stack associated with this fiber.
     pub fn stack(&self) -> &FiberStack {
-        &self.stack
+        self.stack.as_ref().unwrap()
+    }
+
+    /// When this fiber has finished executing, reclaim its stack.
+    pub fn into_stack(mut self) -> FiberStack {
+        assert!(self.done());
+        self.stack.take().unwrap()
     }
 }
 
@@ -149,7 +184,7 @@ impl<Resume, Yield, Return> Suspend<Resume, Yield, Return> {
     /// # Panics
     ///
     /// Panics if the current thread is not executing a fiber from this library.
-    pub fn suspend(&self, value: Yield) -> Resume {
+    pub fn suspend(&mut self, value: Yield) -> Resume {
         self.inner
             .switch::<Resume, Yield, Return>(RunResult::Yield(value))
     }
@@ -157,13 +192,13 @@ impl<Resume, Yield, Return> Suspend<Resume, Yield, Return> {
     fn execute(
         inner: imp::Suspend,
         initial: Resume,
-        func: impl FnOnce(Resume, &Suspend<Resume, Yield, Return>) -> Return,
+        func: impl FnOnce(Resume, &mut Suspend<Resume, Yield, Return>) -> Return,
     ) {
-        let suspend = Suspend {
+        let mut suspend = Suspend {
             inner,
             _phantom: PhantomData,
         };
-        let result = panic::catch_unwind(AssertUnwindSafe(|| (func)(initial, &suspend)));
+        let result = panic::catch_unwind(AssertUnwindSafe(|| (func)(initial, &mut suspend)));
         suspend.inner.switch::<Resume, Yield, Return>(match result {
             Ok(result) => RunResult::Returned(result),
             Err(panic) => RunResult::Panicked(panic),
@@ -236,7 +271,7 @@ mod tests {
         }
         fn assert_contains_host() {
             let trace = backtrace::Backtrace::new();
-            println!("{:?}", trace);
+            println!("{trace:?}");
             assert!(
                 trace
                 .frames()
@@ -248,6 +283,9 @@ mod tests {
                 || cfg!(windows)
                 // TODO: the system libunwind is broken (#2808)
                 || cfg!(all(target_os = "macos", target_arch = "aarch64"))
+                // TODO: see comments in `arm.rs` about how this seems to work
+                // in gdb but not at runtime, unsure why at this time.
+                || cfg!(target_arch = "arm")
             );
         }
 
diff --git a/crates/fiber/src/unix.rs b/crates/fiber/src/unix.rs
index b148ff324bca..b1600654361a 100644
--- a/crates/fiber/src/unix.rs
+++ b/crates/fiber/src/unix.rs
@@ -29,27 +29,104 @@
 //! `suspend`, which has 0xB000 so it can find this, will read that and write
 //! its own resumption information into this slot as well.
 
-#![allow(unused_macros)]
-
-use crate::RunResult;
+use crate::{RunResult, RuntimeFiberStack};
 use std::cell::Cell;
 use std::io;
 use std::ops::Range;
 use std::ptr;
 
-#[derive(Debug)]
 pub struct FiberStack {
-    // The top of the stack; for stacks allocated by the fiber implementation itself,
-    // the base address of the allocation will be `top.sub(len.unwrap())`
-    top: *mut u8,
-    // The length of the stack
+    base: *mut u8,
     len: usize,
-    // whether or not this stack was mmap'd
-    mmap: bool,
+
+    /// Stored here to ensure that when this `FiberStack` the backing storage,
+    /// if any, is additionally dropped.
+    storage: FiberStackStorage,
+}
+
+enum FiberStackStorage {
+    Mmap(#[allow(dead_code)] MmapFiberStack),
+    Unmanaged,
+    Custom(#[allow(dead_code)] Box<dyn RuntimeFiberStack>),
 }
 
 impl FiberStack {
     pub fn new(size: usize) -> io::Result<Self> {
+        // See comments in `mod asan` below for why asan has a different stack
+        // allocation strategy.
+        if cfg!(asan) {
+            return Self::from_custom(asan::new_fiber_stack(size)?);
+        }
+        let page_size = rustix::param::page_size();
+        let stack = MmapFiberStack::new(size)?;
+
+        // An `MmapFiberStack` allocates a guard page at the bottom of the
+        // region so the base and length of our stack are both offset by a
+        // single page.
+        Ok(FiberStack {
+            base: stack.mapping_base.wrapping_byte_add(page_size),
+            len: stack.mapping_len - page_size,
+            storage: FiberStackStorage::Mmap(stack),
+        })
+    }
+
+    pub unsafe fn from_raw_parts(base: *mut u8, len: usize) -> io::Result<Self> {
+        // See comments in `mod asan` below for why asan has a different stack
+        // allocation strategy.
+        if cfg!(asan) {
+            return Self::from_custom(asan::new_fiber_stack(len)?);
+        }
+        Ok(FiberStack {
+            base,
+            len,
+            storage: FiberStackStorage::Unmanaged,
+        })
+    }
+
+    pub fn is_from_raw_parts(&self) -> bool {
+        matches!(self.storage, FiberStackStorage::Unmanaged)
+    }
+
+    pub fn from_custom(custom: Box<dyn RuntimeFiberStack>) -> io::Result<Self> {
+        let range = custom.range();
+        let page_size = rustix::param::page_size();
+        let start_ptr = range.start as *mut u8;
+        assert!(
+            start_ptr.align_offset(page_size) == 0,
+            "expected fiber stack base ({start_ptr:?}) to be page aligned ({page_size:#x})",
+        );
+        let end_ptr = range.end as *const u8;
+        assert!(
+            end_ptr.align_offset(page_size) == 0,
+            "expected fiber stack end ({end_ptr:?}) to be page aligned ({page_size:#x})",
+        );
+        Ok(FiberStack {
+            base: start_ptr,
+            len: range.len(),
+            storage: FiberStackStorage::Custom(custom),
+        })
+    }
+
+    pub fn top(&self) -> Option<*mut u8> {
+        Some(self.base.wrapping_byte_add(self.len))
+    }
+
+    pub fn range(&self) -> Option<Range<usize>> {
+        let base = self.base as usize;
+        Some(base..base + self.len)
+    }
+}
+
+struct MmapFiberStack {
+    mapping_base: *mut u8,
+    mapping_len: usize,
+}
+
+unsafe impl Send for MmapFiberStack {}
+unsafe impl Sync for MmapFiberStack {}
+
+impl MmapFiberStack {
+    fn new(size: usize) -> io::Result<Self> {
         // Round up our stack size request to the nearest multiple of the
         // page size.
         let page_size = rustix::param::page_size();
@@ -70,51 +147,34 @@ impl FiberStack {
             )?;
 
             rustix::mm::mprotect(
-                mmap.cast::<u8>().add(page_size).cast(),
+                mmap.byte_add(page_size),
                 size,
                 rustix::mm::MprotectFlags::READ | rustix::mm::MprotectFlags::WRITE,
             )?;
 
-            Ok(Self {
-                top: mmap.cast::<u8>().add(mmap_len),
-                len: mmap_len,
-                mmap: true,
+            Ok(MmapFiberStack {
+                mapping_base: mmap.cast(),
+                mapping_len: mmap_len,
             })
         }
     }
-
-    pub unsafe fn from_raw_parts(base: *mut u8, len: usize) -> io::Result<Self> {
-        Ok(Self {
-            top: base.add(len),
-            len,
-            mmap: false,
-        })
-    }
-
-    pub fn top(&self) -> Option<*mut u8> {
-        Some(self.top)
-    }
-
-    pub fn range(&self) -> Option<Range<usize>> {
-        let base = unsafe { self.top.sub(self.len) as usize };
-        Some(base..base + self.len)
-    }
 }
 
-impl Drop for FiberStack {
+impl Drop for MmapFiberStack {
     fn drop(&mut self) {
         unsafe {
-            if self.mmap {
-                let ret = rustix::mm::munmap(self.top.sub(self.len) as _, self.len);
-                debug_assert!(ret.is_ok());
-            }
+            let ret = rustix::mm::munmap(self.mapping_base.cast(), self.mapping_len);
+            debug_assert!(ret.is_ok());
         }
     }
 }
 
 pub struct Fiber;
 
-pub struct Suspend(*mut u8);
+pub struct Suspend {
+    top_of_stack: *mut u8,
+    previous: asan::PreviousStack,
+}
 
 extern "C" {
     #[wasmtime_versioned_export_macros::versioned_link]
@@ -132,10 +192,17 @@ extern "C" {
 
 extern "C" fn fiber_start<F, A, B, C>(arg0: *mut u8, top_of_stack: *mut u8)
 where
-    F: FnOnce(A, &super::Suspend<A, B, C>) -> C,
+    F: FnOnce(A, &mut super::Suspend<A, B, C>) -> C,
 {
     unsafe {
-        let inner = Suspend(top_of_stack);
+        // Complete the `start_switch` AddressSanitizer handshake which would
+        // have been started in `Fiber::resume`.
+        let previous = asan::fiber_start_complete();
+
+        let inner = Suspend {
+            top_of_stack,
+            previous,
+        };
         let initial = inner.take_resume::<A, B, C>();
         super::Suspend::<A, B, C>::execute(inner, initial, Box::from_raw(arg0.cast::<F>()))
     }
@@ -144,11 +211,11 @@ where
 impl Fiber {
     pub fn new<F, A, B, C>(stack: &FiberStack, func: F) -> io::Result<Self>
     where
-        F: FnOnce(A, &super::Suspend<A, B, C>) -> C,
+        F: FnOnce(A, &mut super::Suspend<A, B, C>) -> C,
     {
         unsafe {
             let data = Box::into_raw(Box::new(func)).cast();
-            wasmtime_fiber_init(stack.top, fiber_start::<F, A, B, C>, data);
+            wasmtime_fiber_init(stack.top().unwrap(), fiber_start::<F, A, B, C>, data);
         }
 
         Ok(Self)
@@ -160,10 +227,14 @@ impl Fiber {
             // stack, otherwise known as our reserved slot for this information.
             //
             // In the diagram above this is updating address 0xAff8
-            let addr = stack.top.cast::<usize>().offset(-1);
+            let addr = stack.top().unwrap().cast::<usize>().offset(-1);
             addr.write(result as *const _ as usize);
 
-            wasmtime_fiber_switch(stack.top);
+            asan::fiber_switch(
+                stack.top().unwrap(),
+                false,
+                &mut asan::PreviousStack::new(stack),
+            );
 
             // null this out to help catch use-after-free
             addr.write(0);
@@ -172,11 +243,17 @@ impl Fiber {
 }
 
 impl Suspend {
-    pub(crate) fn switch<A, B, C>(&self, result: RunResult<A, B, C>) -> A {
+    pub(crate) fn switch<A, B, C>(&mut self, result: RunResult<A, B, C>) -> A {
         unsafe {
+            let is_finishing = match &result {
+                RunResult::Returned(_) | RunResult::Panicked(_) => true,
+                RunResult::Executing | RunResult::Resuming(_) | RunResult::Yield(_) => false,
+            };
             // Calculate 0xAff8 and then write to it
             (*self.result_location::<A, B, C>()).set(result);
-            wasmtime_fiber_switch(self.0);
+
+            asan::fiber_switch(self.top_of_stack, is_finishing, &mut self.previous);
+
             self.take_resume::<A, B, C>()
         }
     }
@@ -189,7 +266,7 @@ impl Suspend {
     }
 
     unsafe fn result_location<A, B, C>(&self) -> *const Cell<RunResult<A, B, C>> {
-        let ret = self.0.cast::<*const u8>().offset(-1).read();
+        let ret = self.top_of_stack.cast::<*const u8>().offset(-1).read();
         assert!(!ret.is_null());
         ret.cast()
     }
@@ -209,7 +286,209 @@ cfg_if::cfg_if! {
         // assembler file built with the `build.rs`.
     } else if #[cfg(target_arch = "riscv64")]  {
         mod riscv64;
-    }else {
+    } else {
         compile_error!("fibers are not supported on this CPU architecture");
     }
 }
+
+/// Support for AddressSanitizer to support stack manipulations we do in this
+/// fiber implementation.
+///
+/// This module uses, when fuzzing is enabled, special intrinsics provided by
+/// the sanitizer runtime called `__sanitizer_{start,finish}_switch_fiber`.
+/// These aren't really super heavily documented and the current implementation
+/// is inspired by googling the functions and looking at Boost & Julia's usage
+/// of them as well as the documentation for these functions in their own
+/// header file in the LLVM source tree. The general idea is that they're
+/// called around every stack switch with some other fiddly bits as well.
+#[cfg(asan)]
+mod asan {
+    use super::{FiberStack, MmapFiberStack, RuntimeFiberStack};
+    use rustix::param::page_size;
+    use std::mem::ManuallyDrop;
+    use std::ops::Range;
+    use std::sync::Mutex;
+
+    /// State for the "previous stack" maintained by asan itself and fed in for
+    /// custom stacks.
+    pub struct PreviousStack {
+        bottom: *const u8,
+        size: usize,
+    }
+
+    impl PreviousStack {
+        pub fn new(stack: &FiberStack) -> PreviousStack {
+            let range = stack.range().unwrap();
+            PreviousStack {
+                bottom: range.start as *const u8,
+                // Discount the two pointers we store at the top of the stack,
+                // so subtract two pointers.
+                size: range.len() - 2 * std::mem::size_of::<*const u8>(),
+            }
+        }
+    }
+
+    impl Default for PreviousStack {
+        fn default() -> PreviousStack {
+            PreviousStack {
+                bottom: std::ptr::null(),
+                size: 0,
+            }
+        }
+    }
+
+    /// Switches the current stack to `top_of_stack`
+    ///
+    /// * `top_of_stack` - for going to fibers this is calculated and for
+    ///   restoring back to the original stack this was saved during the initial
+    ///   transition.
+    /// * `is_finishing` - whether or not we're switching off a fiber for the
+    ///   final time; customizes how asan intrinsics are invoked.
+    /// * `prev` - the stack we're switching to initially and saves the
+    ///   stack to return to upon resumption.
+    pub unsafe fn fiber_switch(
+        top_of_stack: *mut u8,
+        is_finishing: bool,
+        prev: &mut PreviousStack,
+    ) {
+        let mut private_asan_pointer = std::ptr::null_mut();
+
+        // If this fiber is finishing then NULL is passed to asan to let it know
+        // that it can deallocate the "fake stack" that it's tracking for this
+        // fiber.
+        let private_asan_pointer_ref = if is_finishing {
+            None
+        } else {
+            Some(&mut private_asan_pointer)
+        };
+
+        // NB: in fiddling with asan an optimizations and such it appears that
+        // these functions need to be "very close to each other". If other Rust
+        // functions are invoked or added as an abstraction here that appears to
+        // trigger false positives in ASAN. That leads to the design of this
+        // module as-is where this function exists to have these three
+        // functions very close to one another.
+        __sanitizer_start_switch_fiber(private_asan_pointer_ref, prev.bottom, prev.size);
+        super::wasmtime_fiber_switch(top_of_stack);
+        __sanitizer_finish_switch_fiber(private_asan_pointer, &mut prev.bottom, &mut prev.size);
+    }
+
+    /// Hook for when a fiber first starts, used to configure ASAN.
+    pub unsafe fn fiber_start_complete() -> PreviousStack {
+        let mut ret = PreviousStack::default();
+        __sanitizer_finish_switch_fiber(std::ptr::null_mut(), &mut ret.bottom, &mut ret.size);
+        ret
+    }
+
+    // These intrinsics are provided by the address sanitizer runtime. Their C
+    // signatures were translated into Rust-isms here with `Option` and `&mut`.
+    extern "C" {
+        fn __sanitizer_start_switch_fiber(
+            private_asan_pointer_save: Option<&mut *mut u8>,
+            bottom: *const u8,
+            size: usize,
+        );
+        fn __sanitizer_finish_switch_fiber(
+            private_asan_pointer: *mut u8,
+            bottom_old: &mut *const u8,
+            size_old: &mut usize,
+        );
+    }
+
+    /// This static is a workaround for llvm/llvm-project#53891, notably this is
+    /// a global cache of all fiber stacks.
+    ///
+    /// The problem with ASAN is that if we allocate memory for a stack, use it
+    /// as a stack, deallocate the stack, and then when that memory is later
+    /// mapped as normal heap memory. This is possible due to `mmap` reusing
+    /// addresses and it ends up confusing ASAN. In this situation ASAN will
+    /// have false positives about stack overflows saying that writes to
+    /// freshly-allocated memory, which just happened to historically be a
+    /// stack, are a stack overflow.
+    ///
+    /// This static works around the issue by ensuring that, only when asan is
+    /// enabled, all stacks are cached globally. Stacks are never deallocated
+    /// and forever retained here. This only works if the number of stacks
+    /// retained here is relatively small to prevent OOM from continuously
+    /// running programs. That's hopefully the case as ASAN is mostly used in
+    /// OSS-Fuzz and our fuzzers only fuzz one thing at a time per thread
+    /// meaning that this should only ever be a relatively small set of stacks.
+    static FIBER_STACKS: Mutex<Vec<MmapFiberStack>> = Mutex::new(Vec::new());
+
+    pub fn new_fiber_stack(size: usize) -> std::io::Result<Box<dyn RuntimeFiberStack>> {
+        let needed_size = size + page_size();
+        let mut stacks = FIBER_STACKS.lock().unwrap();
+
+        let stack = match stacks.iter().position(|i| needed_size <= i.mapping_len) {
+            // If an appropriately sized stack was already allocated, then use
+            // that one.
+            Some(i) => stacks.remove(i),
+            // ... otherwise allocate a brand new stack.
+            None => MmapFiberStack::new(size)?,
+        };
+        let stack = AsanFiberStack(ManuallyDrop::new(stack));
+        Ok(Box::new(stack))
+    }
+
+    /// Custom structure used to prevent the interior mmap-allocated stack from
+    /// actually getting unmapped.
+    ///
+    /// On drop this stack will return the interior stack to the global
+    /// `FIBER_STACKS` list.
+    struct AsanFiberStack(ManuallyDrop<MmapFiberStack>);
+
+    unsafe impl RuntimeFiberStack for AsanFiberStack {
+        fn top(&self) -> *mut u8 {
+            self.0.mapping_base.wrapping_byte_add(self.0.mapping_len)
+        }
+
+        fn range(&self) -> Range<usize> {
+            let base = self.0.mapping_base as usize;
+            let end = base + self.0.mapping_len;
+            base + page_size()..end
+        }
+    }
+
+    impl Drop for AsanFiberStack {
+        fn drop(&mut self) {
+            let stack = unsafe { ManuallyDrop::take(&mut self.0) };
+            FIBER_STACKS.lock().unwrap().push(stack);
+        }
+    }
+}
+
+// Shim module that's the same as above but only has stubs.
+#[cfg(not(asan))]
+mod asan_disabled {
+    use super::{FiberStack, RuntimeFiberStack};
+
+    #[derive(Default)]
+    pub struct PreviousStack;
+
+    impl PreviousStack {
+        #[inline]
+        pub fn new(_stack: &FiberStack) -> PreviousStack {
+            PreviousStack
+        }
+    }
+
+    pub unsafe fn fiber_switch(
+        top_of_stack: *mut u8,
+        _is_finishing: bool,
+        _prev: &mut PreviousStack,
+    ) {
+        super::wasmtime_fiber_switch(top_of_stack);
+    }
+
+    #[inline]
+    pub unsafe fn fiber_start_complete() -> PreviousStack {
+        PreviousStack
+    }
+
+    pub fn new_fiber_stack(_size: usize) -> std::io::Result<Box<dyn RuntimeFiberStack>> {
+        unimplemented!()
+    }
+}
+
+#[cfg(not(asan))]
+use asan_disabled as asan;
diff --git a/crates/fiber/src/unix/arm.rs b/crates/fiber/src/unix/arm.rs
index c2b3c0f0b248..b47faefd5329 100644
--- a/crates/fiber/src/unix/arm.rs
+++ b/crates/fiber/src/unix/arm.rs
@@ -8,7 +8,7 @@
 // Also at this time this file is heavily based off the x86_64 file, so you'll
 // probably want to read that one as well.
 
-use wasmtime_asm_macros::{asm_func, asm_sym};
+use wasmtime_asm_macros::asm_func;
 
 // fn(top_of_stack(%r0): *mut u8)
 asm_func!(
@@ -36,7 +36,7 @@ asm_func!(
 asm_func!(
     wasmtime_versioned_export_macros::versioned_stringify_ident!(wasmtime_fiber_init),
     "
-        adr r3, wasmtime_fiber_start
+        adr r3, {start}
         str r3, [r0, #-0x0c] // => lr
         str r0, [r0, #-0x10] // => r11
         str r1, [r0, #-0x14] // => r10
@@ -46,6 +46,7 @@ asm_func!(
         str r3, [r0, #-0x08]
         bx lr
     ",
+    start = sym super::wasmtime_fiber_start,
 );
 
 asm_func!(
diff --git a/crates/fiber/src/unix/x86.rs b/crates/fiber/src/unix/x86.rs
index 6965560d91b2..a6a3b82c960d 100644
--- a/crates/fiber/src/unix/x86.rs
+++ b/crates/fiber/src/unix/x86.rs
@@ -10,11 +10,11 @@
 // different so the reserved space at the top of the stack is 8 bytes, not 16
 // bytes. Still two pointers though.
 
-use wasmtime_asm_macros::{asm_func, asm_sym};
+use wasmtime_asm_macros::asm_func;
 
 // fn(top_of_stack: *mut u8)
 asm_func!(
-    "wasmtime_fiber_switch",
+    wasmtime_versioned_export_macros::versioned_stringify_ident!(wasmtime_fiber_switch),
     "
         // Load our stack-to-use
         mov eax, 0x4[esp]
@@ -45,7 +45,7 @@ asm_func!(
 //    entry_arg0: *mut u8,
 // )
 asm_func!(
-    "wasmtime_fiber_init",
+    wasmtime_versioned_export_macros::versioned_stringify_ident!(wasmtime_fiber_init),
     "
         mov eax, 4[esp]
 
@@ -58,8 +58,7 @@ asm_func!(
 
         // Move our start function to the return address which the `ret` in
         // `wasmtime_fiber_start` will return to.
-        lea ecx, wasmtime_fiber_start2
-        lea ecx, wasmtime_fiber_start
+        lea ecx, {start}
         mov -0x14[eax], ecx
 
         // And move `entry_point` to get loaded into `%ebp` through the context
@@ -81,10 +80,11 @@ asm_func!(
         mov -0x08[eax], ecx
         ret
     ",
+    start = sym super::wasmtime_fiber_start,
 );
 
 asm_func!(
-    "wasmtime_fiber_start",
+    wasmtime_versioned_export_macros::versioned_stringify_ident!(wasmtime_fiber_start),
     "
         .cfi_startproc simple
         .cfi_def_cfa_offset 0
diff --git a/crates/fiber/src/windows.c b/crates/fiber/src/windows.c
index 9d4176eb1b7b..bd7c083db281 100644
--- a/crates/fiber/src/windows.c
+++ b/crates/fiber/src/windows.c
@@ -1,9 +1,9 @@
 #include <windows.h>
 
-#define CONCAT2(a, b) a ## b
-#define CONCAT(a, b) CONCAT2(a , b)
+#define CONCAT2(a, b) a##b
+#define CONCAT(a, b) CONCAT2(a, b)
 #define VERSIONED_SYMBOL(a) CONCAT(a, VERSIONED_SUFFIX)
 
 LPVOID VERSIONED_SYMBOL(wasmtime_fiber_get_current)() {
-   return GetCurrentFiber();
+  return GetCurrentFiber();
 }
diff --git a/crates/fiber/src/windows.rs b/crates/fiber/src/windows.rs
index 2e09f28b7951..e15d1bb2bc40 100644
--- a/crates/fiber/src/windows.rs
+++ b/crates/fiber/src/windows.rs
@@ -1,4 +1,4 @@
-use crate::RunResult;
+use crate::{RunResult, RuntimeFiberStack};
 use std::cell::Cell;
 use std::ffi::c_void;
 use std::io;
@@ -19,6 +19,14 @@ impl FiberStack {
         Err(io::Error::from_raw_os_error(ERROR_NOT_SUPPORTED as i32))
     }
 
+    pub fn is_from_raw_parts(&self) -> bool {
+        false
+    }
+
+    pub fn from_custom(_custom: Box<dyn RuntimeFiberStack>) -> io::Result<Self> {
+        Err(io::Error::from_raw_os_error(ERROR_NOT_SUPPORTED as i32))
+    }
+
     pub fn top(&self) -> Option<*mut u8> {
         None
     }
@@ -52,7 +60,7 @@ extern "C" {
 
 unsafe extern "system" fn fiber_start<F, A, B, C>(data: *mut c_void)
 where
-    F: FnOnce(A, &super::Suspend<A, B, C>) -> C,
+    F: FnOnce(A, &mut super::Suspend<A, B, C>) -> C,
 {
     // Set the stack guarantee to be consistent with what Rust expects for threads
     // This value is taken from:
@@ -72,7 +80,7 @@ where
 impl Fiber {
     pub fn new<F, A, B, C>(stack: &FiberStack, func: F) -> io::Result<Self>
     where
-        F: FnOnce(A, &super::Suspend<A, B, C>) -> C,
+        F: FnOnce(A, &mut super::Suspend<A, B, C>) -> C,
     {
         unsafe {
             let state = Box::new(StartState {
diff --git a/crates/fuzzing/Cargo.toml b/crates/fuzzing/Cargo.toml
index 06390fdacbb4..d93898205bf1 100644
--- a/crates/fuzzing/Cargo.toml
+++ b/crates/fuzzing/Cargo.toml
@@ -2,14 +2,18 @@
 authors.workspace = true
 description = "Fuzzing infrastructure for Wasmtime"
 edition.workspace = true
+rust-version.workspace = true
 name = "wasmtime-fuzzing"
 publish = false
 version = "0.0.0"
 license = "Apache-2.0 WITH LLVM-exception"
 
+[lints]
+workspace = true
+
 [dependencies]
 anyhow = { workspace = true }
-arbitrary = { version = "1.1.0", features = ["derive"] }
+arbitrary = { workspace = true, features = ["derive"] }
 component-test-util = { workspace = true }
 component-fuzz-util = { workspace = true }
 env_logger = { workspace = true }
@@ -19,20 +23,21 @@ target-lexicon = { workspace = true }
 tempfile = "3.3.0"
 wasmparser = { workspace = true }
 wasmprinter = { workspace = true }
-wasmtime = { workspace = true, features = ['default', 'winch'] }
+wasmtime = { workspace = true, features = ['default', 'winch', 'gc', 'memory-protection-keys'] }
 wasmtime-wast = { workspace = true }
 wasm-encoder = { workspace = true }
 wasm-smith = { workspace = true }
 wasm-mutate = { workspace = true }
 wasm-spec-interpreter = { path = "./wasm-spec-interpreter", optional = true }
-wasmi = "0.20.0"
+wasmi = "0.31.1"
+futures = { workspace = true }
 
 # We rely on precompiled v8 binaries, but rusty-v8 doesn't have a precompiled
 # binary for MinGW which is built on our CI. It does have one for Windows-msvc,
 # though, so we could use that if we wanted. For now though just simplify a bit
 # and don't depend on this on Windows.  The same applies on s390x and riscv.
 [target.'cfg(not(any(windows, target_arch = "s390x", target_arch = "riscv64")))'.dependencies]
-v8 = "0.74.1"
+v8 = "0.86.0"
 
 [dev-dependencies]
 wat = { workspace = true }
@@ -45,4 +50,7 @@ rand = { version = "0.8.0", features = ["small_rng"] }
 wasm-spec-interpreter = { path = "./wasm-spec-interpreter", optional = true, features = ['build-libinterpret'] }
 
 [features]
-fuzz-spec-interpreter = ['wasm-spec-interpreter']
+fuzz-spec-interpreter = ['dep:wasm-spec-interpreter']
+
+# Fuzz proof-carrying code. Off by default.
+fuzz-pcc = []
diff --git a/crates/fuzzing/build.rs b/crates/fuzzing/build.rs
index 428355beb7a6..316a15f21e5b 100644
--- a/crates/fuzzing/build.rs
+++ b/crates/fuzzing/build.rs
@@ -1,4 +1,4 @@
-// A small build script to include the contents of the spec test suite into the
+// A small build script to include the contents of the wast test suite into the
 // final fuzzing binary so the fuzzing binary can be run elsewhere and doesn't
 // rely on the original source tree.
 
@@ -9,22 +9,34 @@ fn main() {
     println!("cargo:rerun-if-changed=build.rs");
 
     let out_dir = PathBuf::from(env::var_os("OUT_DIR").unwrap());
-    let dir = env::current_dir()
-        .unwrap()
-        .join("../../tests/spec_testsuite");
+
+    let dirs = [
+        "tests/spec_testsuite",
+        "tests/misc_testsuite",
+        "tests/misc_testsuite/multi-memory",
+        "tests/misc_testsuite/simd",
+        "tests/misc_testsuite/threads",
+    ];
+    let mut root = env::current_dir().unwrap();
+    root.pop(); // chop off 'fuzzing'
+    root.pop(); // chop off 'crates'
     let mut code = format!("static FILES: &[(&str, &str)] = &[\n");
-    let mut entries = dir
-        .read_dir()
-        .unwrap()
-        .map(|p| p.unwrap().path().display().to_string())
-        .collect::<Vec<_>>();
+
+    let mut entries = Vec::new();
+    for dir in dirs {
+        for entry in root.join(dir).read_dir().unwrap() {
+            let entry = entry.unwrap();
+            let path = entry.path();
+            if path.extension().and_then(|s| s.to_str()) == Some("wast") {
+                entries.push(path);
+            }
+        }
+    }
     entries.sort();
     for path in entries {
-        if !path.ends_with(".wast") {
-            continue;
-        }
-        code.push_str(&format!("({:?}, include_str!({0:?})),\n", path));
+        let path = path.to_str().expect("path is not valid utf-8");
+        code.push_str(&format!("({path:?}, include_str!({path:?})),\n"));
     }
     code.push_str("];\n");
-    std::fs::write(out_dir.join("spectests.rs"), code).unwrap();
+    std::fs::write(out_dir.join("wasttests.rs"), code).unwrap();
 }
diff --git a/crates/fuzzing/src/generators.rs b/crates/fuzzing/src/generators.rs
index d7703631d8b3..de264add21e5 100644
--- a/crates/fuzzing/src/generators.rs
+++ b/crates/fuzzing/src/generators.rs
@@ -9,6 +9,7 @@
 //! `Arbitrary` trait for the wrapped external tool.
 
 pub mod api;
+mod async_config;
 mod codegen_settings;
 pub mod component_types;
 mod config;
@@ -17,19 +18,23 @@ mod memory;
 mod module;
 mod pooling_config;
 mod single_inst_module;
-mod spec_test;
 mod stacks;
 pub mod table_ops;
 mod value;
+mod wast_test;
 
+pub use async_config::AsyncConfig;
 pub use codegen_settings::CodegenSettings;
 pub use config::CompilerStrategy;
 pub use config::{Config, WasmtimeConfig};
 pub use instance_allocation_strategy::InstanceAllocationStrategy;
-pub use memory::{MemoryConfig, NormalMemoryConfig, UnalignedMemory, UnalignedMemoryCreator};
+pub use memory::{
+    HeapImage, MemoryAccesses, MemoryConfig, NormalMemoryConfig, UnalignedMemory,
+    UnalignedMemoryCreator,
+};
 pub use module::ModuleConfig;
 pub use pooling_config::PoolingAllocationConfig;
 pub use single_inst_module::SingleInstModule;
-pub use spec_test::SpecTest;
 pub use stacks::Stacks;
 pub use value::{DiffValue, DiffValueType};
+pub use wast_test::WastTest;
diff --git a/crates/fuzzing/src/generators/async_config.rs b/crates/fuzzing/src/generators/async_config.rs
new file mode 100644
index 000000000000..5e229b410033
--- /dev/null
+++ b/crates/fuzzing/src/generators/async_config.rs
@@ -0,0 +1,44 @@
+use arbitrary::{Arbitrary, Unstructured};
+use std::time::Duration;
+
+/// Configuration for async support within a store.
+///
+/// Note that the `Arbitrary` implementation for this type always returns
+/// `Disabled` because this is something that is statically chosen if the fuzzer
+/// has support for async.
+#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+pub enum AsyncConfig {
+    /// No async support enabled.
+    Disabled,
+    /// Async support is enabled and cooperative yielding is done with fuel.
+    YieldWithFuel(u64),
+    /// Async support is enabled and cooperative yielding is done with epochs.
+    YieldWithEpochs {
+        /// Duration between epoch ticks.
+        dur: Duration,
+        /// Number of ticks between yields.
+        ticks: u64,
+    },
+}
+
+impl AsyncConfig {
+    /// Applies this async configuration to the `wasmtime::Config` provided to
+    /// ensure it's ready to execute with the resulting modules.
+    pub fn configure(&self, config: &mut wasmtime::Config) {
+        match self {
+            AsyncConfig::Disabled => {}
+            AsyncConfig::YieldWithFuel(_) => {
+                config.async_support(true).consume_fuel(true);
+            }
+            AsyncConfig::YieldWithEpochs { .. } => {
+                config.async_support(true).epoch_interruption(true);
+            }
+        }
+    }
+}
+
+impl<'a> Arbitrary<'a> for AsyncConfig {
+    fn arbitrary(_: &mut Unstructured<'a>) -> arbitrary::Result<AsyncConfig> {
+        Ok(AsyncConfig::Disabled)
+    }
+}
diff --git a/crates/fuzzing/src/generators/codegen_settings.rs b/crates/fuzzing/src/generators/codegen_settings.rs
index a3e66148dfe6..62d58c4e85da 100644
--- a/crates/fuzzing/src/generators/codegen_settings.rs
+++ b/crates/fuzzing/src/generators/codegen_settings.rs
@@ -123,6 +123,7 @@ impl<'a> Arbitrary<'a> for CodegenSettings {
 
                     std: "bti" => clif: "use_bti",
                     std: "lse" => clif: "has_lse",
+                    std: "fp16" => clif: "has_fp16",
                     // even though the natural correspondence seems to be
                     // between "paca" and "has_pauth", the latter has no effect
                     // in isolation, so we actually use the setting that affects
diff --git a/crates/fuzzing/src/generators/component_types.rs b/crates/fuzzing/src/generators/component_types.rs
index 80b2838b1576..b184fa28e7a9 100644
--- a/crates/fuzzing/src/generators/component_types.rs
+++ b/crates/fuzzing/src/generators/component_types.rs
@@ -3,7 +3,7 @@
 //!
 //! Each case includes a list of arbitrary interface types to use as parameters, plus another one to use as a
 //! result, and a component which exports a function and imports a function.  The exported function forwards its
-//! parameters to the imported one and forwards the result back to the caller.  This serves to excercise Wasmtime's
+//! parameters to the imported one and forwards the result back to the caller.  This serves to exercise Wasmtime's
 //! lifting and lowering code and verify the values remain intact during both processes.
 
 use arbitrary::{Arbitrary, Unstructured};
@@ -46,77 +46,67 @@ pub fn arbitrary_val(ty: &component::Type, input: &mut Unstructured) -> arbitrar
                 Ok(ControlFlow::Continue(()))
             })?;
 
-            list.new_val(values.into()).unwrap()
+            Val::List(values.into())
         }
-        Type::Record(record) => record
-            .new_val(
-                record
-                    .fields()
-                    .map(|field| Ok((field.name, arbitrary_val(&field.ty, input)?)))
-                    .collect::<arbitrary::Result<Vec<_>>>()?,
-            )
-            .unwrap(),
-        Type::Tuple(tuple) => tuple
-            .new_val(
-                tuple
-                    .types()
-                    .map(|ty| arbitrary_val(&ty, input))
-                    .collect::<arbitrary::Result<_>>()?,
-            )
-            .unwrap(),
+        Type::Record(record) => Val::Record(
+            record
+                .fields()
+                .map(|field| Ok((field.name.to_string(), arbitrary_val(&field.ty, input)?)))
+                .collect::<arbitrary::Result<_>>()?,
+        ),
+        Type::Tuple(tuple) => Val::Tuple(
+            tuple
+                .types()
+                .map(|ty| arbitrary_val(&ty, input))
+                .collect::<arbitrary::Result<_>>()?,
+        ),
         Type::Variant(variant) => {
             let cases = variant.cases().collect::<Vec<_>>();
             let case = input.choose(&cases)?;
             let payload = match &case.ty {
-                Some(ty) => Some(arbitrary_val(ty, input)?),
+                Some(ty) => Some(Box::new(arbitrary_val(ty, input)?)),
                 None => None,
             };
-            variant.new_val(case.name, payload).unwrap()
+            Val::Variant(case.name.to_string(), payload)
         }
         Type::Enum(en) => {
             let names = en.names().collect::<Vec<_>>();
             let name = input.choose(&names)?;
-            en.new_val(name).unwrap()
+            Val::Enum(name.to_string())
         }
         Type::Option(option) => {
             let discriminant = input.int_in_range(0..=1)?;
-            option
-                .new_val(match discriminant {
-                    0 => None,
-                    1 => Some(arbitrary_val(&option.ty(), input)?),
-                    _ => unreachable!(),
-                })
-                .unwrap()
+            Val::Option(match discriminant {
+                0 => None,
+                1 => Some(Box::new(arbitrary_val(&option.ty(), input)?)),
+                _ => unreachable!(),
+            })
         }
         Type::Result(result) => {
             let discriminant = input.int_in_range(0..=1)?;
-            result
-                .new_val(match discriminant {
-                    0 => Ok(match result.ok() {
-                        Some(ty) => Some(arbitrary_val(&ty, input)?),
-                        None => None,
-                    }),
-                    1 => Err(match result.err() {
-                        Some(ty) => Some(arbitrary_val(&ty, input)?),
-                        None => None,
-                    }),
-                    _ => unreachable!(),
-                })
-                .unwrap()
+            Val::Result(match discriminant {
+                0 => Ok(match result.ok() {
+                    Some(ty) => Some(Box::new(arbitrary_val(&ty, input)?)),
+                    None => None,
+                }),
+                1 => Err(match result.err() {
+                    Some(ty) => Some(Box::new(arbitrary_val(&ty, input)?)),
+                    None => None,
+                }),
+                _ => unreachable!(),
+            })
         }
-        Type::Flags(flags) => flags
-            .new_val(
-                &flags
-                    .names()
-                    .filter_map(|name| {
-                        input
-                            .arbitrary()
-                            .map(|p| if p { Some(name) } else { None })
-                            .transpose()
-                    })
-                    .collect::<arbitrary::Result<Box<[_]>>>()?,
-            )
-            .unwrap(),
+        Type::Flags(flags) => Val::Flags(
+            flags
+                .names()
+                .filter_map(|name| {
+                    input
+                        .arbitrary()
+                        .map(|p| if p { Some(name.to_string()) } else { None })
+                        .transpose()
+                })
+                .collect::<arbitrary::Result<_>>()?,
+        ),
 
         // Resources aren't fuzzed at this time.
         Type::Own(_) | Type::Borrow(_) => unreachable!(),
@@ -137,6 +127,7 @@ where
 
     let mut config = Config::new();
     config.wasm_component_model(true);
+    config.wasm_component_model_multiple_returns(true);
     config.debug_adapter_modules(input.arbitrary()?);
     let engine = Engine::new(&config).unwrap();
     let wat = declarations.make_component();
diff --git a/crates/fuzzing/src/generators/config.rs b/crates/fuzzing/src/generators/config.rs
index 5a29e689fc2d..d6fd64824af2 100644
--- a/crates/fuzzing/src/generators/config.rs
+++ b/crates/fuzzing/src/generators/config.rs
@@ -1,7 +1,8 @@
 //! Generate a configuration for both Wasmtime and the Wasm module to execute.
 
 use super::{
-    CodegenSettings, InstanceAllocationStrategy, MemoryConfig, ModuleConfig, UnalignedMemoryCreator,
+    AsyncConfig, CodegenSettings, InstanceAllocationStrategy, MemoryConfig, ModuleConfig,
+    NormalMemoryConfig, UnalignedMemoryCreator,
 };
 use crate::oracles::{StoreLimits, Timeout};
 use anyhow::Result;
@@ -47,7 +48,8 @@ impl Config {
         // Allow a memory to be generated, but don't let it get too large.
         // Additionally require the maximum size to guarantee that the growth
         // behavior is consistent across engines.
-        config.max_memory_pages = 10;
+        config.max_memory32_bytes = 10 << 16;
+        config.max_memory64_bytes = 10 << 16;
         config.memory_max_size_required = true;
 
         // If tables are generated make sure they don't get too large to avoid
@@ -74,7 +76,7 @@ impl Config {
         if let InstanceAllocationStrategy::Pooling(pooling) = &mut self.wasmtime.strategy {
             // One single-page memory
             pooling.total_memories = config.max_memories as u32;
-            pooling.memory_pages = 10;
+            pooling.max_memory_size = 10 << 16;
             pooling.max_memories_per_module = config.max_memories as u32;
 
             pooling.total_tables = config.max_tables as u32;
@@ -82,6 +84,13 @@ impl Config {
             pooling.max_tables_per_module = config.max_tables as u32;
 
             pooling.core_instance_size = 1_000_000;
+
+            if let MemoryConfig::Normal(cfg) = &mut self.wasmtime.memory_config {
+                match &mut cfg.static_memory_maximum_size {
+                    Some(size) => *size = (*size).max(pooling.max_memory_size as u64),
+                    other @ None => *other = Some(pooling.max_memory_size as u64),
+                }
+            }
         }
     }
 
@@ -99,12 +108,12 @@ impl Config {
         self.module_config.generate(input, default_fuel)
     }
 
-    /// Tests whether this configuration is capable of running all spec tests.
-    pub fn is_spectest_compliant(&self) -> bool {
+    /// Tests whether this configuration is capable of running all wast tests.
+    pub fn is_wast_test_compliant(&self) -> bool {
         let config = &self.module_config.config;
 
         // Check for wasm features that must be disabled to run spec tests
-        if config.memory64_enabled || config.threads_enabled {
+        if config.memory64_enabled {
             return false;
         }
 
@@ -113,6 +122,8 @@ impl Config {
             || !config.reference_types_enabled
             || !config.multi_value_enabled
             || !config.simd_enabled
+            || !config.threads_enabled
+            || config.max_memories <= 1
         {
             return false;
         }
@@ -131,7 +142,7 @@ impl Config {
             if pooling.total_memories < 1
                 || pooling.total_tables < 5
                 || pooling.table_elements < 1_000
-                || pooling.memory_pages < 900
+                || pooling.max_memory_size < (900 << 16)
                 || pooling.total_core_instances < 500
                 || pooling.core_instance_size < 64 * 1024
             {
@@ -155,13 +166,13 @@ impl Config {
             .wasm_simd(self.module_config.config.simd_enabled)
             .wasm_memory64(self.module_config.config.memory64_enabled)
             .wasm_tail_call(self.module_config.config.tail_call_enabled)
+            .wasm_custom_page_sizes(self.module_config.config.custom_page_sizes_enabled)
             .wasm_threads(self.module_config.config.threads_enabled)
             .native_unwind_info(cfg!(target_os = "windows") || self.wasmtime.native_unwind_info)
             .cranelift_nan_canonicalization(self.wasmtime.canonicalize_nans)
             .cranelift_opt_level(self.wasmtime.opt_level.to_wasmtime())
             .consume_fuel(self.wasmtime.consume_fuel)
             .epoch_interruption(self.wasmtime.epoch_interruption)
-            .memory_init_cow(self.wasmtime.memory_init_cow)
             .memory_guaranteed_dense_image_size(std::cmp::min(
                 // Clamp this at 16MiB so we don't get huge in-memory
                 // images during fuzzing.
@@ -171,12 +182,23 @@ impl Config {
             .allocation_strategy(self.wasmtime.strategy.to_wasmtime())
             .generate_address_map(self.wasmtime.generate_address_map);
 
+        if !self.module_config.config.simd_enabled {
+            cfg.wasm_relaxed_simd(false);
+        }
+
         let compiler_strategy = &self.wasmtime.compiler_strategy;
         let cranelift_strategy = *compiler_strategy == CompilerStrategy::Cranelift;
         cfg.strategy(self.wasmtime.compiler_strategy.to_wasmtime());
 
         self.wasmtime.codegen.configure(&mut cfg);
 
+        // Determine whether we will actually enable PCC -- this is
+        // disabled if the module requires memory64, which is not yet
+        // compatible (due to the need for dynamic checks).
+        let pcc = cfg!(feature = "fuzz-pcc")
+            && self.wasmtime.pcc
+            && !self.module_config.config.memory64_enabled;
+
         // Only set cranelift specific flags when the Cranelift strategy is
         // chosen.
         if cranelift_strategy {
@@ -208,8 +230,15 @@ impl Config {
                     );
                 }
             }
+
+            cfg.cranelift_pcc(pcc);
+
+            // Eager init is currently only supported on Cranelift, not Winch.
+            cfg.table_lazy_init(self.wasmtime.table_lazy_init);
         }
 
+        self.wasmtime.async_config.configure(&mut cfg);
+
         // Vary the memory configuration, but only if threads are not enabled.
         // When the threads proposal is enabled we might generate shared memory,
         // which is less amenable to different memory configurations:
@@ -221,21 +250,35 @@ impl Config {
         //   `CustomUnaligned` variant isn't actually safe to use with a shared
         //   memory.
         if !self.module_config.config.threads_enabled {
-            match &self.wasmtime.memory_config {
+            // If PCC is enabled, force other options to be compatible: PCC is currently only
+            // supported when bounds checks are elided.
+            let memory_config = if pcc {
+                MemoryConfig::Normal(NormalMemoryConfig {
+                    static_memory_maximum_size: Some(4 << 30), // 4 GiB
+                    static_memory_guard_size: Some(2 << 30),   // 2 GiB
+                    dynamic_memory_guard_size: Some(0),
+                    dynamic_memory_reserved_for_growth: Some(0),
+                    guard_before_linear_memory: false,
+                    memory_init_cow: true,
+                    // Doesn't matter, only using virtual memory.
+                    cranelift_enable_heap_access_spectre_mitigations: None,
+                })
+            } else {
+                self.wasmtime.memory_config.clone()
+            };
+
+            match &memory_config {
                 MemoryConfig::Normal(memory_config) => {
-                    cfg.static_memory_maximum_size(
-                        memory_config.static_memory_maximum_size.unwrap_or(0),
-                    )
-                    .static_memory_guard_size(memory_config.static_memory_guard_size.unwrap_or(0))
-                    .dynamic_memory_guard_size(memory_config.dynamic_memory_guard_size.unwrap_or(0))
-                    .guard_before_linear_memory(memory_config.guard_before_linear_memory);
+                    memory_config.apply_to(&mut cfg);
                 }
                 MemoryConfig::CustomUnaligned => {
                     cfg.with_host_memory(Arc::new(UnalignedMemoryCreator))
                         .static_memory_maximum_size(0)
                         .dynamic_memory_guard_size(0)
+                        .dynamic_memory_reserved_for_growth(0)
                         .static_memory_guard_size(0)
-                        .guard_before_linear_memory(false);
+                        .guard_before_linear_memory(false)
+                        .memory_init_cow(false);
                 }
             }
         }
@@ -255,20 +298,26 @@ impl Config {
     /// Configures a store based on this configuration.
     pub fn configure_store(&self, store: &mut Store<StoreLimits>) {
         store.limiter(|s| s as &mut dyn wasmtime::ResourceLimiter);
-        if self.wasmtime.consume_fuel {
-            store.add_fuel(u64::max_value()).unwrap();
-        }
-        if self.wasmtime.epoch_interruption {
-            // Without fuzzing of async execution, we can't test the
-            // "update deadline and continue" behavior, but we can at
-            // least test the codegen paths and checks with the
-            // trapping behavior, which works synchronously too. We'll
-            // set the deadline one epoch tick in the future; then
-            // this works exactly like an interrupt flag. We expect no
-            // traps/interrupts unless we bump the epoch, which we do
-            // as one particular Timeout mode (`Timeout::Epoch`).
-            store.epoch_deadline_trap();
-            store.set_epoch_deadline(1);
+        match self.wasmtime.async_config {
+            AsyncConfig::Disabled => {
+                if self.wasmtime.consume_fuel {
+                    store.set_fuel(u64::MAX).unwrap();
+                }
+                if self.wasmtime.epoch_interruption {
+                    store.epoch_deadline_trap();
+                    store.set_epoch_deadline(1);
+                }
+            }
+            AsyncConfig::YieldWithFuel(amt) => {
+                assert!(self.wasmtime.consume_fuel);
+                store.fuel_async_yield_interval(Some(amt)).unwrap();
+                store.set_fuel(amt).unwrap();
+            }
+            AsyncConfig::YieldWithEpochs { ticks, .. } => {
+                assert!(self.wasmtime.epoch_interruption);
+                store.set_epoch_deadline(ticks);
+                store.epoch_deadline_async_yield_and_update(ticks);
+            }
         }
     }
 
@@ -311,6 +360,37 @@ impl Config {
         std::fs::write(&file, module.serialize().unwrap()).unwrap();
         unsafe { Ok(Module::deserialize_file(engine, &file).unwrap()) }
     }
+
+    /// Winch doesn't support the same set of wasm proposal as Cranelift at
+    /// this time, so if winch is selected be sure to disable wasm proposals
+    /// in `Config` to ensure that Winch can compile the module that
+    /// wasm-smith generates.
+    pub fn disable_unimplemented_winch_proposals(&mut self) {
+        self.module_config.config.simd_enabled = false;
+        self.module_config.config.relaxed_simd_enabled = false;
+        self.module_config.config.gc_enabled = false;
+        self.module_config.config.threads_enabled = false;
+        self.module_config.config.tail_call_enabled = false;
+        self.module_config.config.exceptions_enabled = false;
+        self.module_config.config.reference_types_enabled = false;
+    }
+
+    /// Updates this configuration to forcibly enable async support. Only useful
+    /// in fuzzers which do async calls.
+    pub fn enable_async(&mut self, u: &mut Unstructured<'_>) -> arbitrary::Result<()> {
+        if self.wasmtime.consume_fuel || u.arbitrary()? {
+            self.wasmtime.async_config =
+                AsyncConfig::YieldWithFuel(u.int_in_range(1000..=100_000)?);
+            self.wasmtime.consume_fuel = true;
+        } else {
+            self.wasmtime.async_config = AsyncConfig::YieldWithEpochs {
+                dur: Duration::from_millis(u.int_in_range(1..=10)?),
+                ticks: u.int_in_range(1..=10)?,
+            };
+            self.wasmtime.epoch_interruption = true;
+        }
+        Ok(())
+    }
 }
 
 impl<'a> Arbitrary<'a> for Config {
@@ -320,13 +400,24 @@ impl<'a> Arbitrary<'a> for Config {
             module_config: u.arbitrary()?,
         };
 
-        // This is pulled from `u` by default via `wasm-smith`, but Wasmtime
-        // doesn't implement this yet, so forcibly always disable it.
-        config.module_config.config.tail_call_enabled = false;
+        if let CompilerStrategy::Winch = config.wasmtime.compiler_strategy {
+            config.disable_unimplemented_winch_proposals();
+        }
+
+        // Wasm-smith implements the most up-to-date version of memory64 where
+        // it supports 64-bit tables as well, but Wasmtime doesn't support that
+        // yet, so disable the memory64 proposal in fuzzing for now.
+        config.module_config.config.memory64_enabled = false;
 
         // If using the pooling allocator, constrain the memory and module configurations
         // to the module limits.
         if let InstanceAllocationStrategy::Pooling(pooling) = &mut config.wasmtime.strategy {
+            // Forcibly don't use the `CustomUnaligned` memory configuration
+            // with the pooling allocator active.
+            if let MemoryConfig::CustomUnaligned = config.wasmtime.memory_config {
+                config.wasmtime.memory_config = MemoryConfig::Normal(u.arbitrary()?);
+            }
+
             let cfg = &mut config.module_config.config;
             // If the pooling allocator is used, do not allow shared memory to
             // be created. FIXME: see
@@ -335,19 +426,33 @@ impl<'a> Arbitrary<'a> for Config {
 
             // Ensure the pooling allocator can support the maximal size of
             // memory, picking the smaller of the two to win.
-            if cfg.max_memory_pages < pooling.memory_pages {
-                pooling.memory_pages = cfg.max_memory_pages;
-            } else {
-                cfg.max_memory_pages = pooling.memory_pages;
+            let min_bytes = cfg
+                .max_memory32_bytes
+                // memory64_bytes is a u128, but since we are taking the min
+                // we can truncate it down to a u64.
+                .min(cfg.max_memory64_bytes.try_into().unwrap_or(u64::MAX));
+            let mut min = min_bytes.min(pooling.max_memory_size as u64);
+            if let MemoryConfig::Normal(cfg) = &config.wasmtime.memory_config {
+                min = min.min(cfg.static_memory_maximum_size.unwrap_or(0));
             }
+            pooling.max_memory_size = min as usize;
+            cfg.max_memory32_bytes = min;
+            cfg.max_memory64_bytes = min as u128;
 
             // If traps are disallowed then memories must have at least one page
             // of memory so if we still are only allowing 0 pages of memory then
             // increase that to one here.
             if cfg.disallow_traps {
-                if pooling.memory_pages == 0 {
-                    pooling.memory_pages = 1;
-                    cfg.max_memory_pages = 1;
+                if pooling.max_memory_size < (1 << 16) {
+                    pooling.max_memory_size = 1 << 16;
+                    cfg.max_memory32_bytes = 1 << 16;
+                    cfg.max_memory64_bytes = 1 << 16;
+                    if let MemoryConfig::Normal(cfg) = &mut config.wasmtime.memory_config {
+                        match &mut cfg.static_memory_maximum_size {
+                            Some(size) => *size = (*size).max(pooling.max_memory_size as u64),
+                            size @ None => *size = Some(pooling.max_memory_size as u64),
+                        }
+                    }
                 }
                 // .. additionally update tables
                 if pooling.table_elements == 0 {
@@ -355,12 +460,6 @@ impl<'a> Arbitrary<'a> for Config {
                 }
             }
 
-            // Forcibly don't use the `CustomUnaligned` memory configuration
-            // with the pooling allocator active.
-            if let MemoryConfig::CustomUnaligned = config.wasmtime.memory_config {
-                config.wasmtime.memory_config = MemoryConfig::Normal(u.arbitrary()?);
-            }
-
             // Don't allow too many linear memories per instance since massive
             // virtual mappings can fail to get allocated.
             cfg.min_memories = cfg.min_memories.min(10);
@@ -385,7 +484,7 @@ pub struct WasmtimeConfig {
     canonicalize_nans: bool,
     interruptable: bool,
     pub(crate) consume_fuel: bool,
-    epoch_interruption: bool,
+    pub(crate) epoch_interruption: bool,
     /// The Wasmtime memory configuration to use.
     pub memory_config: MemoryConfig,
     force_jump_veneers: bool,
@@ -400,6 +499,14 @@ pub struct WasmtimeConfig {
     native_unwind_info: bool,
     /// Configuration for the compiler to use.
     pub compiler_strategy: CompilerStrategy,
+    table_lazy_init: bool,
+
+    /// Whether or not fuzzing should enable PCC.
+    pcc: bool,
+
+    /// Configuration for whether wasm is invoked in an async fashion and how
+    /// it's cooperatively time-sliced.
+    pub async_config: AsyncConfig,
 }
 
 impl WasmtimeConfig {
@@ -462,12 +569,11 @@ impl CompilerStrategy {
     }
 }
 
-// Unconditionally return `Cranelift` given that Winch is not ready to be
-// enabled by default in all the fuzzing targets. Each fuzzing target is
-// expected to explicitly override the strategy as needed. Currently only the
-// differential target overrides the compiler strategy.
 impl Arbitrary<'_> for CompilerStrategy {
     fn arbitrary(_: &mut Unstructured<'_>) -> arbitrary::Result<Self> {
+        // NB: Winch isn't selected here yet as it doesn't yet implement all the
+        // compiler features for things such as trampolines, so it's only used
+        // on fuzz targets that don't need those trampolines.
         Ok(Self::Cranelift)
     }
 }
diff --git a/crates/fuzzing/src/generators/memory.rs b/crates/fuzzing/src/generators/memory.rs
index bdf679b58319..282adc3dc964 100644
--- a/crates/fuzzing/src/generators/memory.rs
+++ b/crates/fuzzing/src/generators/memory.rs
@@ -5,6 +5,117 @@ use arbitrary::{Arbitrary, Unstructured};
 use std::ops::Range;
 use wasmtime::{LinearMemory, MemoryCreator, MemoryType};
 
+/// A description of a memory config, image, etc... that can be used to test
+/// memory accesses.
+#[derive(Debug)]
+pub struct MemoryAccesses {
+    /// The configuration to use with this test case.
+    pub config: crate::generators::Config,
+    /// The heap image to use with this test case.
+    pub image: HeapImage,
+    /// The offset immediate to encode in the `load{8,16,32,64}` functions'
+    /// various load instructions.
+    pub offset: u32,
+    /// The amount (in pages) to grow the memory.
+    pub growth: u32,
+}
+
+impl<'a> Arbitrary<'a> for MemoryAccesses {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        let image = HeapImage::arbitrary(u)?;
+
+        // Don't grow too much, since oss-fuzz/asan get upset if we try,
+        // even if we allow it to fail.
+        let one_mib = 1 << 20; // 1 MiB
+        let max_growth = one_mib / (1 << image.page_size_log2.unwrap_or(16));
+        let mut growth: u32 = u.int_in_range(0..=max_growth)?;
+
+        // Occasionally, round to a power of two, since these tend to be
+        // interesting numbers that overlap with the host page size and things
+        // like that.
+        if growth > 0 && u.ratio(1, 20)? {
+            growth = (growth - 1).next_power_of_two();
+        }
+
+        Ok(MemoryAccesses {
+            config: u.arbitrary()?,
+            image,
+            offset: u.arbitrary()?,
+            growth,
+        })
+    }
+}
+
+/// A memory heap image.
+pub struct HeapImage {
+    /// The minimum size (in pages) of this memory.
+    pub minimum: u32,
+    /// The maximum size (in pages) of this memory.
+    pub maximum: Option<u32>,
+    /// Whether this memory should be indexed with `i64` (rather than `i32`).
+    pub memory64: bool,
+    /// The log2 of the page size for this memory.
+    pub page_size_log2: Option<u32>,
+    /// Data segments for this memory.
+    pub segments: Vec<(u32, Vec<u8>)>,
+}
+
+impl std::fmt::Debug for HeapImage {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        struct Segments<'a>(&'a [(u32, Vec<u8>)]);
+        impl std::fmt::Debug for Segments<'_> {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                write!(f, "[..; {}]", self.0.len())
+            }
+        }
+
+        f.debug_struct("HeapImage")
+            .field("minimum", &self.minimum)
+            .field("maximum", &self.maximum)
+            .field("memory64", &self.memory64)
+            .field("page_size_log2", &self.page_size_log2)
+            .field("segments", &Segments(&self.segments))
+            .finish()
+    }
+}
+
+impl<'a> Arbitrary<'a> for HeapImage {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        let minimum = u.int_in_range(0..=4)?;
+        let maximum = if u.arbitrary()? {
+            Some(u.int_in_range(minimum..=10)?)
+        } else {
+            None
+        };
+        let memory64 = u.arbitrary()?;
+        let page_size_log2 = match u.int_in_range(0..=2)? {
+            0 => None,
+            1 => Some(0),
+            2 => Some(16),
+            _ => unreachable!(),
+        };
+        let mut segments = vec![];
+        if minimum > 0 {
+            for _ in 0..u.int_in_range(0..=4)? {
+                let last_addressable = (1u32 << page_size_log2.unwrap_or(16)) * minimum - 1;
+                let offset = u.int_in_range(0..=last_addressable)?;
+                let max_len =
+                    std::cmp::min(u.len(), usize::try_from(last_addressable - offset).unwrap());
+                let len = u.int_in_range(0..=max_len)?;
+                let data = u.bytes(len)?.to_vec();
+                segments.push((offset, data));
+            }
+        }
+        Ok(HeapImage {
+            minimum,
+            maximum,
+            memory64,
+            page_size_log2,
+            segments,
+        })
+    }
+}
+
 /// Configuration for linear memories in Wasmtime.
 #[derive(Arbitrary, Clone, Debug, Eq, Hash, PartialEq)]
 pub enum MemoryConfig {
@@ -27,7 +138,10 @@ pub struct NormalMemoryConfig {
     pub static_memory_maximum_size: Option<u64>,
     pub static_memory_guard_size: Option<u64>,
     pub dynamic_memory_guard_size: Option<u64>,
+    pub dynamic_memory_reserved_for_growth: Option<u64>,
     pub guard_before_linear_memory: bool,
+    pub cranelift_enable_heap_access_spectre_mitigations: Option<bool>,
+    pub memory_init_cow: bool,
 }
 
 impl<'a> Arbitrary<'a> for NormalMemoryConfig {
@@ -38,17 +152,46 @@ impl<'a> Arbitrary<'a> for NormalMemoryConfig {
             static_memory_maximum_size: <Option<u32> as Arbitrary>::arbitrary(u)?.map(Into::into),
             static_memory_guard_size: <Option<u32> as Arbitrary>::arbitrary(u)?.map(Into::into),
             dynamic_memory_guard_size: <Option<u32> as Arbitrary>::arbitrary(u)?.map(Into::into),
+            dynamic_memory_reserved_for_growth: <Option<u32> as Arbitrary>::arbitrary(u)?
+                .map(Into::into),
             guard_before_linear_memory: u.arbitrary()?,
+            cranelift_enable_heap_access_spectre_mitigations: u.arbitrary()?,
+            memory_init_cow: u.arbitrary()?,
         };
 
         if let Some(dynamic) = ret.dynamic_memory_guard_size {
             let statik = ret.static_memory_guard_size.unwrap_or(2 << 30);
             ret.static_memory_guard_size = Some(statik.max(dynamic));
         }
+
         Ok(ret)
     }
 }
 
+impl NormalMemoryConfig {
+    /// Apply this memory configuration to the given `wasmtime::Config`.
+    pub fn apply_to(&self, config: &mut wasmtime::Config) {
+        config
+            .static_memory_maximum_size(self.static_memory_maximum_size.unwrap_or(0))
+            .static_memory_guard_size(self.static_memory_guard_size.unwrap_or(0))
+            .dynamic_memory_guard_size(self.dynamic_memory_guard_size.unwrap_or(0))
+            .dynamic_memory_reserved_for_growth(
+                self.dynamic_memory_reserved_for_growth.unwrap_or(0),
+            )
+            .guard_before_linear_memory(self.guard_before_linear_memory)
+            .memory_init_cow(self.memory_init_cow);
+
+        if let Some(enable) = self.cranelift_enable_heap_access_spectre_mitigations {
+            unsafe {
+                config.cranelift_flag_set(
+                    "enable_heap_access_spectre_mitigation",
+                    &enable.to_string(),
+                );
+            }
+        }
+    }
+}
+
 /// A custom "linear memory allocator" for wasm which only works with the
 /// "dynamic" mode of configuration where wasm always does explicit bounds
 /// checks.
diff --git a/crates/fuzzing/src/generators/module.rs b/crates/fuzzing/src/generators/module.rs
index 7ff78c2b7d68..b669ff25d71c 100644
--- a/crates/fuzzing/src/generators/module.rs
+++ b/crates/fuzzing/src/generators/module.rs
@@ -1,21 +1,20 @@
 //! Generate a Wasm module and the configuration for generating it.
 
 use arbitrary::{Arbitrary, Unstructured};
-use wasm_smith::SwarmConfig;
 
 /// Default module-level configuration for fuzzing Wasmtime.
 ///
-/// Internally this uses `wasm-smith`'s own `SwarmConfig` but we further refine
+/// Internally this uses `wasm-smith`'s own `Config` but we further refine
 /// the defaults here as well.
 #[derive(Debug, Clone)]
 pub struct ModuleConfig {
     #[allow(missing_docs)]
-    pub config: SwarmConfig,
+    pub config: wasm_smith::Config,
 }
 
 impl<'a> Arbitrary<'a> for ModuleConfig {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<ModuleConfig> {
-        let mut config = SwarmConfig::arbitrary(u)?;
+        let mut config = wasm_smith::Config::arbitrary(u)?;
 
         // Allow multi-memory but make it unlikely
         if u.ratio(1, 20)? {
@@ -63,7 +62,7 @@ impl ModuleConfig {
         let mut module = wasm_smith::Module::new(self.config.clone(), input)?;
 
         if let Some(default_fuel) = default_fuel {
-            module.ensure_termination(default_fuel);
+            module.ensure_termination(default_fuel).unwrap();
         }
 
         Ok(module)
diff --git a/crates/fuzzing/src/generators/pooling_config.rs b/crates/fuzzing/src/generators/pooling_config.rs
index 9cdbd1d1319d..0e327bce3724 100644
--- a/crates/fuzzing/src/generators/pooling_config.rs
+++ b/crates/fuzzing/src/generators/pooling_config.rs
@@ -1,6 +1,7 @@
 //! Generate instance limits for the pooling allocation strategy.
 
 use arbitrary::{Arbitrary, Unstructured};
+use wasmtime::MpkEnabled;
 
 /// Configuration for `wasmtime::PoolingAllocationStrategy`.
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
@@ -12,7 +13,7 @@ pub struct PoolingAllocationConfig {
     pub total_tables: u32,
     pub total_stacks: u32,
 
-    pub memory_pages: u64,
+    pub max_memory_size: usize,
     pub table_elements: u32,
 
     pub component_instance_size: usize,
@@ -26,10 +27,14 @@ pub struct PoolingAllocationConfig {
     pub table_keep_resident: usize,
     pub linear_memory_keep_resident: usize,
 
+    pub decommit_batch_size: usize,
     pub max_unused_warm_slots: u32,
 
     pub async_stack_zeroing: bool,
     pub async_stack_keep_resident: usize,
+
+    pub memory_protection_keys: MpkEnabled,
+    pub max_memory_protection_keys: usize,
 }
 
 impl PoolingAllocationConfig {
@@ -43,7 +48,7 @@ impl PoolingAllocationConfig {
         cfg.total_tables(self.total_tables);
         cfg.total_stacks(self.total_stacks);
 
-        cfg.memory_pages(self.memory_pages);
+        cfg.max_memory_size(self.max_memory_size);
         cfg.table_elements(self.table_elements);
 
         cfg.max_component_instance_size(self.component_instance_size);
@@ -57,11 +62,14 @@ impl PoolingAllocationConfig {
         cfg.table_keep_resident(self.table_keep_resident);
         cfg.linear_memory_keep_resident(self.linear_memory_keep_resident);
 
+        cfg.decommit_batch_size(self.decommit_batch_size);
         cfg.max_unused_warm_slots(self.max_unused_warm_slots);
 
         cfg.async_stack_zeroing(self.async_stack_zeroing);
         cfg.async_stack_keep_resident(self.async_stack_keep_resident);
 
+        cfg.memory_protection_keys(self.memory_protection_keys);
+
         cfg
     }
 }
@@ -72,7 +80,7 @@ impl<'a> Arbitrary<'a> for PoolingAllocationConfig {
         const MAX_TABLES: u32 = 100;
         const MAX_MEMORIES: u32 = 100;
         const MAX_ELEMENTS: u32 = 1000;
-        const MAX_MEMORY_PAGES: u64 = 160; // 10 MiB
+        const MAX_MEMORY_SIZE: usize = 10 * (1 << 20); // 10 MiB
         const MAX_SIZE: usize = 1 << 20; // 1 MiB
         const MAX_INSTANCE_MEMORIES: u32 = 10;
         const MAX_INSTANCE_TABLES: u32 = 10;
@@ -86,7 +94,7 @@ impl<'a> Arbitrary<'a> for PoolingAllocationConfig {
             total_tables: u.int_in_range(1..=MAX_TABLES)?,
             total_stacks: u.int_in_range(1..=MAX_COUNT)?,
 
-            memory_pages: u.int_in_range(0..=MAX_MEMORY_PAGES)?,
+            max_memory_size: u.int_in_range(0..=MAX_MEMORY_SIZE)?,
             table_elements: u.int_in_range(0..=MAX_ELEMENTS)?,
 
             component_instance_size: u.int_in_range(0..=MAX_SIZE)?,
@@ -100,10 +108,14 @@ impl<'a> Arbitrary<'a> for PoolingAllocationConfig {
             table_keep_resident: u.int_in_range(0..=1 << 20)?,
             linear_memory_keep_resident: u.int_in_range(0..=1 << 20)?,
 
+            decommit_batch_size: u.int_in_range(1..=1000)?,
             max_unused_warm_slots: u.int_in_range(0..=total_memories + 10)?,
 
             async_stack_zeroing: u.arbitrary()?,
             async_stack_keep_resident: u.int_in_range(0..=1 << 20)?,
+
+            memory_protection_keys: *u.choose(&[MpkEnabled::Auto, MpkEnabled::Disable])?,
+            max_memory_protection_keys: u.int_in_range(0..=20)?,
         })
     }
 }
diff --git a/crates/fuzzing/src/generators/single_inst_module.rs b/crates/fuzzing/src/generators/single_inst_module.rs
index e42b452244a3..e368686ce114 100644
--- a/crates/fuzzing/src/generators/single_inst_module.rs
+++ b/crates/fuzzing/src/generators/single_inst_module.rs
@@ -314,11 +314,11 @@ static INSTRUCTIONS: &[SingleInstModule] = &[
     inst!(F32Ge, (f32, f32) -> i32),
     inst!(F64Ge, (f64, f64) -> i32),
     // Integer conversions ("to integer").
-    inst!(I32Extend8S, (i32) -> i32, |c| c.config.sign_extension_enabled),
-    inst!(I32Extend16S, (i32) -> i32, |c| c.config.sign_extension_enabled),
-    inst!(I64Extend8S, (i64) -> i64, |c| c.config.sign_extension_enabled),
-    inst!(I64Extend16S, (i64) -> i64, |c| c.config.sign_extension_enabled),
-    inst!(I64Extend32S, (i64) -> i64, |c| c.config.sign_extension_enabled),
+    inst!(I32Extend8S, (i32) -> i32, |c| c.config.sign_extension_ops_enabled),
+    inst!(I32Extend16S, (i32) -> i32, |c| c.config.sign_extension_ops_enabled),
+    inst!(I64Extend8S, (i64) -> i64, |c| c.config.sign_extension_ops_enabled),
+    inst!(I64Extend16S, (i64) -> i64, |c| c.config.sign_extension_ops_enabled),
+    inst!(I64Extend32S, (i64) -> i64, |c| c.config.sign_extension_ops_enabled),
     inst!(I32WrapI64, (i64) -> i32),
     inst!(I64ExtendI32S, (i32) -> i64),
     inst!(I64ExtendI32U, (i32) -> i64),
@@ -595,7 +595,8 @@ mod test {
     i32.add
   )
   (export "test" (func 0))
-)"#
+)
+"#
         )
     }
 
diff --git a/crates/fuzzing/src/generators/spec_test.rs b/crates/fuzzing/src/generators/spec_test.rs
deleted file mode 100644
index 2e11e46a1ebe..000000000000
--- a/crates/fuzzing/src/generators/spec_test.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-//! Arbitrarily choose a spec test from the list of known spec tests.
-
-use arbitrary::{Arbitrary, Unstructured};
-
-// See `build.rs` for how the `FILES` array is generated.
-include!(concat!(env!("OUT_DIR"), "/spectests.rs"));
-
-/// A spec test from the upstream wast testsuite, arbitrarily chosen from the
-/// list of known spec tests.
-#[derive(Debug)]
-pub struct SpecTest {
-    /// The filename of the spec test
-    pub file: &'static str,
-    /// The `*.wast` contents of the spec test
-    pub contents: &'static str,
-}
-
-impl<'a> Arbitrary<'a> for SpecTest {
-    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
-        // NB: this does get a uniform value in the provided range.
-        let i = u.int_in_range(0..=FILES.len() - 1)?;
-        let (file, contents) = FILES[i];
-        Ok(SpecTest { file, contents })
-    }
-
-    fn size_hint(_depth: usize) -> (usize, Option<usize>) {
-        (1, Some(std::mem::size_of::<usize>()))
-    }
-}
diff --git a/crates/fuzzing/src/generators/stacks.rs b/crates/fuzzing/src/generators/stacks.rs
index d59563bcb1ef..5e3f9daac5b6 100644
--- a/crates/fuzzing/src/generators/stacks.rs
+++ b/crates/fuzzing/src/generators/stacks.rs
@@ -1,7 +1,7 @@
 //! Generate a Wasm program that keeps track of its current stack frames.
 //!
 //! We can then compare the stack trace we observe in Wasmtime to what the Wasm
-//! program believes its stack should be. Any discrepencies between the two
+//! program believes its stack should be. Any discrepancies between the two
 //! points to a bug in either this test case generator or Wasmtime's stack
 //! walker.
 
@@ -89,7 +89,7 @@ impl Stacks {
     ///
     /// * `host.check_stack: [] -> []`: The host can check the Wasm's
     ///   understanding of its own stack against the host's understanding of the
-    ///   Wasm stack to find discrepency bugs.
+    ///   Wasm stack to find discrepancy bugs.
     ///
     /// * `host.call_func: [funcref] -> []`: The host should call the given
     ///   `funcref`, creating a call stack with multiple sequences of contiguous
@@ -159,6 +159,7 @@ impl Stacks {
             maximum: Some(1),
             memory64: false,
             shared: false,
+            page_size_log2: None,
         });
         section(&mut module, mems);
 
@@ -168,6 +169,7 @@ impl Stacks {
             wasm_encoder::GlobalType {
                 val_type: wasm_encoder::ValType::I32,
                 mutable: true,
+                shared: false,
             },
             &wasm_encoder::ConstExpr::i32_const(0),
         );
@@ -176,6 +178,7 @@ impl Stacks {
             wasm_encoder::GlobalType {
                 val_type: wasm_encoder::ValType::I32,
                 mutable: true,
+                shared: false,
             },
             &wasm_encoder::ConstExpr::i32_const(0),
         );
@@ -362,6 +365,6 @@ mod tests {
         if let Ok(text) = wasmprinter::print_bytes(wasm) {
             drop(std::fs::write("test.wat", &text));
         }
-        panic!("wasm failed to validate: {}", err);
+        panic!("wasm failed to validate: {err}");
     }
 }
diff --git a/crates/fuzzing/src/generators/table_ops.rs b/crates/fuzzing/src/generators/table_ops.rs
index 48440ba0c85b..d63de7acddc7 100644
--- a/crates/fuzzing/src/generators/table_ops.rs
+++ b/crates/fuzzing/src/generators/table_ops.rs
@@ -83,8 +83,10 @@ impl TableOps {
         let mut tables = TableSection::new();
         tables.table(TableType {
             element_type: RefType::EXTERNREF,
-            minimum: self.table_size as u32,
+            minimum: self.table_size as u64,
             maximum: None,
+            table64: false,
+            shared: false,
         });
 
         // Define our globals.
@@ -94,8 +96,9 @@ impl TableOps {
                 wasm_encoder::GlobalType {
                     val_type: wasm_encoder::ValType::EXTERNREF,
                     mutable: true,
+                    shared: false,
                 },
-                &ConstExpr::ref_null(wasm_encoder::HeapType::Extern),
+                &ConstExpr::ref_null(wasm_encoder::HeapType::EXTERN),
             );
         }
 
@@ -112,7 +115,7 @@ impl TableOps {
 
         func.instruction(&Instruction::Loop(wasm_encoder::BlockType::Empty));
         for op in &self.ops {
-            op.insert(&mut func, self.num_params as u32);
+            op.insert(&mut func, self.num_params);
         }
         func.instruction(&Instruction::Br(0));
         func.instruction(&Instruction::End);
@@ -261,7 +264,7 @@ impl TableOp {
                 func.instruction(&Instruction::Drop);
             }
             Self::Null => {
-                func.instruction(&Instruction::RefNull(wasm_encoder::HeapType::Extern));
+                func.instruction(&Instruction::RefNull(wasm_encoder::HeapType::EXTERN));
             }
         }
     }
@@ -282,11 +285,7 @@ mod tests {
             let u = Unstructured::new(&buf);
             if let Ok(ops) = TableOps::arbitrary_take_rest(u) {
                 let wasm = ops.to_wasm_binary();
-                let mut validator =
-                    wasmparser::Validator::new_with_features(wasmparser::WasmFeatures {
-                        reference_types: true,
-                        ..Default::default()
-                    });
+                let mut validator = wasmparser::Validator::new();
                 let result = validator.validate_all(&wasm);
                 assert!(result.is_ok());
             }
@@ -358,15 +357,15 @@ mod tests {
   (export "run" (func 3))
 )
 "#;
-        eprintln!("expected WAT = {}", expected);
+        eprintln!("expected WAT = {expected}");
 
         let actual = ops.to_wasm_binary();
         if let Err(e) = wasmparser::validate(&actual) {
-            panic!("TableOps should generate valid Wasm; got error: {}", e);
+            panic!("TableOps should generate valid Wasm; got error: {e}");
         }
 
         let actual = wasmprinter::print_bytes(&actual).unwrap();
-        eprintln!("actual WAT = {}", actual);
+        eprintln!("actual WAT = {actual}");
 
         assert_eq!(actual.trim(), expected.trim());
     }
diff --git a/crates/fuzzing/src/generators/value.rs b/crates/fuzzing/src/generators/value.rs
index e432bcfd769b..f12c6d3fa647 100644
--- a/crates/fuzzing/src/generators/value.rs
+++ b/crates/fuzzing/src/generators/value.rs
@@ -2,6 +2,7 @@
 
 use arbitrary::{Arbitrary, Unstructured};
 use std::hash::Hash;
+use wasmtime::HeapType;
 
 /// A value passed to and from evaluation. Note that reference types are not
 /// (yet) supported.
@@ -15,6 +16,7 @@ pub enum DiffValue {
     V128(u128),
     FuncRef { null: bool },
     ExternRef { null: bool },
+    AnyRef { null: bool },
 }
 
 impl DiffValue {
@@ -27,6 +29,7 @@ impl DiffValue {
             DiffValue::V128(_) => DiffValueType::V128,
             DiffValue::FuncRef { .. } => DiffValueType::FuncRef,
             DiffValue::ExternRef { .. } => DiffValueType::ExternRef,
+            DiffValue::AnyRef { .. } => DiffValueType::AnyRef,
         }
     }
 
@@ -57,9 +60,9 @@ impl DiffValue {
                 ];
                 let bits = biased_arbitrary_value(u, known_f32_values)?;
 
-                // If the chosen bits are NAN then always use the canonical bit
-                // pattern of nan to enable better compatibility with engines
-                // where arbitrary nan patterns can't make their way into wasm
+                // If the chosen bits are NaN then always use the canonical bit
+                // pattern of NaN to enable better compatibility with engines
+                // where arbitrary NaN patterns can't make their way into wasm
                 // (e.g. v8 through JS can't do that).
                 let bits = if f32::from_bits(bits).is_nan() {
                     f32::NAN.to_bits()
@@ -82,7 +85,7 @@ impl DiffValue {
                     f64::MAX.to_bits(),
                 ];
                 let bits = biased_arbitrary_value(u, known_f64_values)?;
-                // See `f32` above for why canonical nan patterns are always
+                // See `f32` above for why canonical NaN patterns are always
                 // used.
                 let bits = if f64::from_bits(bits).is_nan() {
                     f64::NAN.to_bits()
@@ -182,6 +185,7 @@ impl DiffValue {
             // support doing that.
             FuncRef => DiffValue::FuncRef { null: true },
             ExternRef => DiffValue::ExternRef { null: true },
+            AnyRef => DiffValue::AnyRef { null: true },
         };
         arbitrary::Result::Ok(val)
     }
@@ -227,6 +231,7 @@ impl Hash for DiffValue {
             DiffValue::V128(n) => n.hash(state),
             DiffValue::ExternRef { null } => null.hash(state),
             DiffValue::FuncRef { null } => null.hash(state),
+            DiffValue::AnyRef { null } => null.hash(state),
         }
     }
 }
@@ -278,6 +283,7 @@ pub enum DiffValueType {
     V128,
     FuncRef,
     ExternRef,
+    AnyRef,
 }
 
 impl TryFrom<wasmtime::ValType> for DiffValueType {
@@ -290,8 +296,14 @@ impl TryFrom<wasmtime::ValType> for DiffValueType {
             F32 => Ok(Self::F32),
             F64 => Ok(Self::F64),
             V128 => Ok(Self::V128),
-            FuncRef => Ok(Self::FuncRef),
-            ExternRef => Ok(Self::ExternRef),
+            Ref(r) => match (r.is_nullable(), r.heap_type()) {
+                (true, HeapType::Func) => Ok(Self::FuncRef),
+                (true, HeapType::Extern) => Ok(Self::ExternRef),
+                (true, HeapType::Any) => Ok(Self::AnyRef),
+                (true, HeapType::I31) => Ok(Self::AnyRef),
+                (true, HeapType::None) => Ok(Self::AnyRef),
+                _ => Err("non-funcref and non-externref reference types are not supported yet"),
+            },
         }
     }
 }
diff --git a/crates/fuzzing/src/generators/wast_test.rs b/crates/fuzzing/src/generators/wast_test.rs
new file mode 100644
index 000000000000..f93a387861ec
--- /dev/null
+++ b/crates/fuzzing/src/generators/wast_test.rs
@@ -0,0 +1,28 @@
+//! Arbitrarily choose a spec test from the list of known spec tests.
+
+use arbitrary::{Arbitrary, Unstructured};
+
+// See `build.rs` for how the `FILES` array is generated.
+include!(concat!(env!("OUT_DIR"), "/wasttests.rs"));
+
+/// A wast test from this repository.
+#[derive(Debug)]
+pub struct WastTest {
+    /// The filename of the spec test
+    pub file: &'static str,
+    /// The `*.wast` contents of the spec test
+    pub contents: &'static str,
+}
+
+impl<'a> Arbitrary<'a> for WastTest {
+    fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        // NB: this does get a uniform value in the provided range.
+        let i = u.int_in_range(0..=FILES.len() - 1)?;
+        let (file, contents) = FILES[i];
+        Ok(WastTest { file, contents })
+    }
+
+    fn size_hint(_depth: usize) -> (usize, Option<usize>) {
+        (1, Some(std::mem::size_of::<usize>()))
+    }
+}
diff --git a/crates/fuzzing/src/oracles.rs b/crates/fuzzing/src/oracles.rs
index d154904204b0..d28ebfd3c9f2 100644
--- a/crates/fuzzing/src/oracles.rs
+++ b/crates/fuzzing/src/oracles.rs
@@ -16,17 +16,20 @@ pub mod diff_wasmi;
 pub mod diff_wasmtime;
 pub mod dummy;
 pub mod engine;
+pub mod memory;
 mod stacks;
 
 use self::diff_wasmtime::WasmtimeInstance;
 use self::engine::{DiffEngine, DiffInstance};
 use crate::generators::{self, DiffValue, DiffValueType};
+use crate::single_module_fuzzer::KnownValid;
 use arbitrary::Arbitrary;
 pub use stacks::check_stacks;
-use std::cell::Cell;
-use std::rc::Rc;
-use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
+use std::future::Future;
+use std::pin::Pin;
+use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst};
 use std::sync::{Arc, Condvar, Mutex};
+use std::task::{Context, Poll};
 use std::time::{Duration, Instant};
 use wasmtime::*;
 use wasmtime_wast::WastContext;
@@ -46,10 +49,10 @@ pub fn log_wasm(wasm: &[u8]) {
     }
 
     let i = CNT.fetch_add(1, SeqCst);
-    let name = format!("testcase{}.wasm", i);
+    let name = format!("testcase{i}.wasm");
     std::fs::write(&name, wasm).expect("failed to write wasm file");
     log::debug!("wrote wasm file to `{}`", name);
-    let wat = format!("testcase{}.wat", i);
+    let wat = format!("testcase{i}.wat");
     match wasmprinter::print_bytes(wasm) {
         Ok(s) => std::fs::write(&wat, s).expect("failed to write wat file"),
         // If wasmprinter failed remove a `*.wat` file, if any, to avoid
@@ -62,35 +65,36 @@ pub fn log_wasm(wasm: &[u8]) {
 /// The `T` in `Store<T>` for fuzzing stores, used to limit resource
 /// consumption during fuzzing.
 #[derive(Clone)]
-pub struct StoreLimits(Rc<LimitsState>);
+pub struct StoreLimits(Arc<LimitsState>);
 
 struct LimitsState {
     /// Remaining memory, in bytes, left to allocate
-    remaining_memory: Cell<usize>,
+    remaining_memory: AtomicUsize,
     /// Whether or not an allocation request has been denied
-    oom: Cell<bool>,
+    oom: AtomicBool,
 }
 
 impl StoreLimits {
     /// Creates the default set of limits for all fuzzing stores.
     pub fn new() -> StoreLimits {
-        StoreLimits(Rc::new(LimitsState {
+        StoreLimits(Arc::new(LimitsState {
             // Limits tables/memories within a store to at most 1gb for now to
             // exercise some larger address but not overflow various limits.
-            remaining_memory: Cell::new(1 << 30),
-            oom: Cell::new(false),
+            remaining_memory: AtomicUsize::new(1 << 30),
+            oom: AtomicBool::new(false),
         }))
     }
 
     fn alloc(&mut self, amt: usize) -> bool {
         log::trace!("alloc {amt:#x} bytes");
-        match self.0.remaining_memory.get().checked_sub(amt) {
-            Some(mem) => {
-                self.0.remaining_memory.set(mem);
-                true
-            }
-            None => {
-                self.0.oom.set(true);
+        match self
+            .0
+            .remaining_memory
+            .fetch_update(SeqCst, SeqCst, |remaining| remaining.checked_sub(amt))
+        {
+            Ok(_) => true,
+            Err(_) => {
+                self.0.oom.store(true, SeqCst);
                 log::debug!("OOM hit");
                 false
             }
@@ -98,7 +102,7 @@ impl StoreLimits {
     }
 
     fn is_oom(&self) -> bool {
-        self.0.oom.get()
+        self.0.oom.load(SeqCst)
     }
 }
 
@@ -136,7 +140,12 @@ pub enum Timeout {
 /// panic or segfault or anything else that can be detected "passively".
 ///
 /// The engine will be configured using provided config.
-pub fn instantiate(wasm: &[u8], known_valid: bool, config: &generators::Config, timeout: Timeout) {
+pub fn instantiate(
+    wasm: &[u8],
+    known_valid: KnownValid,
+    config: &generators::Config,
+    timeout: Timeout,
+) {
     let mut store = config.to_store();
 
     let module = match compile_module(store.engine(), wasm, known_valid, config) {
@@ -144,9 +153,9 @@ pub fn instantiate(wasm: &[u8], known_valid: bool, config: &generators::Config,
         None => return,
     };
 
-    let mut timeout_state = SignalOnDrop::default();
+    let mut timeout_state = HelperThread::default();
     match timeout {
-        Timeout::Fuel(fuel) => set_fuel(&mut store, fuel),
+        Timeout::Fuel(fuel) => store.set_fuel(fuel).unwrap(),
 
         // If a timeout is requested then we spawn a helper thread to wait for
         // the requested time and then send us a signal to get interrupted. We
@@ -159,7 +168,7 @@ pub fn instantiate(wasm: &[u8], known_valid: bool, config: &generators::Config,
         // infrastructure.
         Timeout::Epoch(timeout) => {
             let engine = store.engine().clone();
-            timeout_state.spawn_timeout(timeout, move || engine.increment_epoch());
+            timeout_state.run_periodically(timeout, move || engine.increment_epoch());
         }
         Timeout::None => {}
     }
@@ -194,7 +203,7 @@ pub enum Command {
 /// The modules are expected to *not* have start functions as no timeouts are configured.
 pub fn instantiate_many(
     modules: &[Vec<u8>],
-    known_valid: bool,
+    known_valid: KnownValid,
     config: &generators::Config,
     commands: &[Command],
 ) {
@@ -247,13 +256,23 @@ pub fn instantiate_many(
 fn compile_module(
     engine: &Engine,
     bytes: &[u8],
-    known_valid: bool,
+    known_valid: KnownValid,
     config: &generators::Config,
 ) -> Option<Module> {
     log_wasm(bytes);
+
+    fn is_pcc_error(e: &anyhow::Error) -> bool {
+        // NOTE: please keep this predicate in sync with the display format of CodegenError,
+        // defined in `wasmtime/cranelift/codegen/src/result.rs`
+        e.to_string().to_lowercase().contains("proof-carrying-code")
+    }
+
     match config.compile(engine, bytes) {
         Ok(module) => Some(module),
-        Err(_) if !known_valid => None,
+        Err(e) if is_pcc_error(&e) => {
+            panic!("pcc error in input: {e:#?}");
+        }
+        Err(_) if known_valid == KnownValid::No => None,
         Err(e) => {
             if let generators::InstanceAllocationStrategy::Pooling(c) = &config.wasmtime.strategy {
                 // When using the pooling allocator, accept failures to compile
@@ -292,7 +311,7 @@ fn compile_module(
                 }
             }
 
-            panic!("failed to compile module: {:?}", e);
+            panic!("failed to compile module: {e:?}");
         }
     }
 }
@@ -313,7 +332,13 @@ pub fn instantiate_with_dummy(store: &mut Store<StoreLimits>, module: &Module) -
     // the two steps together to match on the error below.
     let instance =
         dummy::dummy_linker(store, module).and_then(|l| l.instantiate(&mut *store, module));
+    unwrap_instance(store, instance)
+}
 
+fn unwrap_instance(
+    store: &Store<StoreLimits>,
+    instance: anyhow::Result<Instance>,
+) -> Option<Instance> {
     let e = match instance {
         Ok(i) => return Some(i),
         Err(e) => e,
@@ -344,16 +369,13 @@ pub fn instantiate_with_dummy(store: &mut Store<StoreLimits>, module: &Module) -
     }
 
     // Also allow failures to instantiate as a result of hitting pooling limits.
-    if string.contains("maximum concurrent core instance limit")
-        || string.contains("maximum concurrent memory limit")
-        || string.contains("maximum concurrent table limit")
-    {
+    if e.is::<wasmtime::PoolConcurrencyLimitError>() {
         log::debug!("failed to instantiate: {}", string);
         return None;
     }
 
     // Everything else should be a bug in the fuzzer or a bug in wasmtime
-    panic!("failed to instantiate: {:?}", e);
+    panic!("failed to instantiate: {e:?}");
 }
 
 /// Evaluate the function identified by `name` in two different engine
@@ -548,7 +570,7 @@ pub fn make_api_calls(api: generators::api::ApiCalls) {
                 let funcs = instance
                     .exports(&mut *store)
                     .filter_map(|e| match e.into_extern() {
-                        Extern::Func(f) => Some(f.clone()),
+                        Extern::Func(f) => Some(f),
                         _ => None,
                     })
                     .collect::<Vec<_>>();
@@ -560,25 +582,40 @@ pub fn make_api_calls(api: generators::api::ApiCalls) {
                 let nth = nth % funcs.len();
                 let f = &funcs[nth];
                 let ty = f.ty(&store);
-                let params = dummy::dummy_values(ty.params());
-                let mut results = vec![Val::I32(0); ty.results().len()];
-                let _ = f.call(store, &params, &mut results);
+                if let Ok(params) = dummy::dummy_values(ty.params()) {
+                    let mut results = vec![Val::I32(0); ty.results().len()];
+                    let _ = f.call(store, &params, &mut results);
+                }
             }
         }
     }
 }
 
-/// Executes the wast `test` spectest with the `config` specified.
+/// Executes the wast `test` with the `config` specified.
 ///
-/// Ensures that spec tests pass regardless of the `Config`.
-pub fn spectest(fuzz_config: generators::Config, test: generators::SpecTest) {
+/// Ensures that wast tests pass regardless of the `Config`.
+pub fn wast_test(fuzz_config: generators::Config, test: generators::WastTest) {
     crate::init_fuzzing();
-    if !fuzz_config.is_spectest_compliant() {
+    if !fuzz_config.is_wast_test_compliant() {
         return;
     }
+
+    // Fuel and epochs don't play well with threads right now, so exclude any
+    // thread-spawning test if it looks like threads are spawned in that case.
+    if fuzz_config.wasmtime.consume_fuel || fuzz_config.wasmtime.epoch_interruption {
+        if test.contents.contains("(thread") {
+            return;
+        }
+    }
+
     log::debug!("running {:?}", test.file);
     let mut wast_context = WastContext::new(fuzz_config.to_store());
-    wast_context.register_spectest(false).unwrap();
+    wast_context
+        .register_spectest(&wasmtime_wast::SpectestConfig {
+            use_shared_memory: false,
+            suppress_prints: true,
+        })
+        .unwrap();
     wast_context
         .run_buffer(test.file, test.contents.as_bytes())
         .unwrap();
@@ -591,7 +628,7 @@ pub fn spectest(fuzz_config: generators::Config, test: generators::SpecTest) {
 pub fn table_ops(
     mut fuzz_config: generators::Config,
     ops: generators::table_ops::TableOps,
-) -> usize {
+) -> Result<usize> {
     let expected_drops = Arc::new(AtomicUsize::new(ops.num_params as usize));
     let num_dropped = Arc::new(AtomicUsize::new(0));
 
@@ -599,13 +636,13 @@ pub fn table_ops(
     {
         fuzz_config.wasmtime.consume_fuel = true;
         let mut store = fuzz_config.to_store();
-        set_fuel(&mut store, 1_000);
+        store.set_fuel(1_000).unwrap();
 
         let wasm = ops.to_wasm_binary();
         log_wasm(&wasm);
-        let module = match compile_module(store.engine(), &wasm, false, &fuzz_config) {
+        let module = match compile_module(store.engine(), &wasm, KnownValid::No, &fuzz_config) {
             Some(m) => m,
-            None => return 0,
+            None => return Ok(0),
         };
 
         let mut linker = Linker::new(store.engine());
@@ -614,125 +651,132 @@ pub fn table_ops(
         // test case.
         const MAX_GCS: usize = 5;
 
-        // NB: use `Func::new` so that this can still compile on the old x86
-        // backend, where `IntoFunc` isn't implemented for multi-value
-        // returns.
-        let func = Func::new(
-            &mut store,
-            FuncType::new(
-                vec![],
-                vec![ValType::ExternRef, ValType::ExternRef, ValType::ExternRef],
-            ),
-            {
-                let num_dropped = num_dropped.clone();
-                let expected_drops = expected_drops.clone();
-                let num_gcs = num_gcs.clone();
-                move |mut caller: Caller<'_, StoreLimits>, _params, results| {
-                    log::info!("table_ops: GC");
-                    if num_gcs.fetch_add(1, SeqCst) < MAX_GCS {
-                        caller.gc();
-                    }
+        let func_ty = FuncType::new(
+            store.engine(),
+            vec![],
+            vec![ValType::EXTERNREF, ValType::EXTERNREF, ValType::EXTERNREF],
+        );
+        let func = Func::new(&mut store, func_ty, {
+            let num_dropped = num_dropped.clone();
+            let expected_drops = expected_drops.clone();
+            let num_gcs = num_gcs.clone();
+            move |mut caller: Caller<'_, StoreLimits>, _params, results| {
+                log::info!("table_ops: GC");
+                if num_gcs.fetch_add(1, SeqCst) < MAX_GCS {
+                    caller.gc();
+                }
 
-                    let a = ExternRef::new(CountDrops(num_dropped.clone()));
-                    let b = ExternRef::new(CountDrops(num_dropped.clone()));
-                    let c = ExternRef::new(CountDrops(num_dropped.clone()));
+                let a = ExternRef::new(&mut caller, CountDrops(num_dropped.clone()))?;
+                let b = ExternRef::new(&mut caller, CountDrops(num_dropped.clone()))?;
+                let c = ExternRef::new(&mut caller, CountDrops(num_dropped.clone()))?;
 
-                    log::info!("table_ops: make_refs() -> ({:p}, {:p}, {:p})", a, b, c);
+                log::info!("table_ops: gc() -> ({:?}, {:?}, {:?})", a, b, c);
 
-                    expected_drops.fetch_add(3, SeqCst);
-                    results[0] = Some(a).into();
-                    results[1] = Some(b).into();
-                    results[2] = Some(c).into();
-                    Ok(())
-                }
-            },
-        );
+                expected_drops.fetch_add(3, SeqCst);
+                results[0] = Some(a).into();
+                results[1] = Some(b).into();
+                results[2] = Some(c).into();
+                Ok(())
+            }
+        });
         linker.define(&store, "", "gc", func).unwrap();
 
         linker
             .func_wrap("", "take_refs", {
                 let expected_drops = expected_drops.clone();
-                move |a: Option<ExternRef>, b: Option<ExternRef>, c: Option<ExternRef>| {
-                    log::info!(
-                        "table_ops: take_refs({}, {}, {})",
-                        a.as_ref().map_or_else(
-                            || format!("{:p}", std::ptr::null::<()>()),
-                            |r| format!("{:p}", *r)
-                        ),
-                        b.as_ref().map_or_else(
-                            || format!("{:p}", std::ptr::null::<()>()),
-                            |r| format!("{:p}", *r)
-                        ),
-                        c.as_ref().map_or_else(
-                            || format!("{:p}", std::ptr::null::<()>()),
-                            |r| format!("{:p}", *r)
-                        ),
-                    );
+                move |caller: Caller<'_, StoreLimits>,
+                      a: Option<Rooted<ExternRef>>,
+                      b: Option<Rooted<ExternRef>>,
+                      c: Option<Rooted<ExternRef>>|
+                      -> Result<()> {
+                    log::info!("table_ops: take_refs({a:?}, {b:?}, {c:?})",);
 
                     // Do the assertion on each ref's inner data, even though it
                     // all points to the same atomic, so that if we happen to
                     // run into a use-after-free bug with one of these refs we
                     // are more likely to trigger a segfault.
                     if let Some(a) = a {
-                        let a = a.data().downcast_ref::<CountDrops>().unwrap();
+                        let a = a.data(&caller)?.downcast_ref::<CountDrops>().unwrap();
                         assert!(a.0.load(SeqCst) <= expected_drops.load(SeqCst));
                     }
                     if let Some(b) = b {
-                        let b = b.data().downcast_ref::<CountDrops>().unwrap();
+                        let b = b.data(&caller)?.downcast_ref::<CountDrops>().unwrap();
                         assert!(b.0.load(SeqCst) <= expected_drops.load(SeqCst));
                     }
                     if let Some(c) = c {
-                        let c = c.data().downcast_ref::<CountDrops>().unwrap();
+                        let c = c.data(&caller)?.downcast_ref::<CountDrops>().unwrap();
                         assert!(c.0.load(SeqCst) <= expected_drops.load(SeqCst));
                     }
+                    Ok(())
                 }
             })
             .unwrap();
 
-        // NB: use `Func::new` so that this can still compile on the old
-        // x86 backend, where `IntoFunc` isn't implemented for
-        // multi-value returns.
-        let func = Func::new(
-            &mut store,
-            FuncType::new(
-                vec![],
-                vec![ValType::ExternRef, ValType::ExternRef, ValType::ExternRef],
-            ),
-            {
-                let num_dropped = num_dropped.clone();
-                let expected_drops = expected_drops.clone();
-                move |_caller, _params, results| {
-                    log::info!("table_ops: make_refs");
-                    expected_drops.fetch_add(3, SeqCst);
-                    results[0] = Some(ExternRef::new(CountDrops(num_dropped.clone()))).into();
-                    results[1] = Some(ExternRef::new(CountDrops(num_dropped.clone()))).into();
-                    results[2] = Some(ExternRef::new(CountDrops(num_dropped.clone()))).into();
-                    Ok(())
-                }
-            },
+        let func_ty = FuncType::new(
+            store.engine(),
+            vec![],
+            vec![ValType::EXTERNREF, ValType::EXTERNREF, ValType::EXTERNREF],
         );
+        let func = Func::new(&mut store, func_ty, {
+            let num_dropped = num_dropped.clone();
+            let expected_drops = expected_drops.clone();
+            move |mut caller, _params, results| {
+                log::info!("table_ops: make_refs");
+
+                let a = ExternRef::new(&mut caller, CountDrops(num_dropped.clone()))?;
+                let b = ExternRef::new(&mut caller, CountDrops(num_dropped.clone()))?;
+                let c = ExternRef::new(&mut caller, CountDrops(num_dropped.clone()))?;
+                expected_drops.fetch_add(3, SeqCst);
+
+                log::info!("table_ops: make_refs() -> ({:?}, {:?}, {:?})", a, b, c);
+
+                results[0] = Some(a).into();
+                results[1] = Some(b).into();
+                results[2] = Some(c).into();
+
+                Ok(())
+            }
+        });
         linker.define(&store, "", "make_refs", func).unwrap();
 
         let instance = linker.instantiate(&mut store, &module).unwrap();
         let run = instance.get_func(&mut store, "run").unwrap();
 
-        let args: Vec<_> = (0..ops.num_params)
-            .map(|_| Val::ExternRef(Some(ExternRef::new(CountDrops(num_dropped.clone())))))
-            .collect();
-
-        // The generated function should always return a trap. The only two
-        // valid traps are table-out-of-bounds which happens through `table.get`
-        // and `table.set` generated or an out-of-fuel trap. Otherwise any other
-        // error is unexpected and should fail fuzzing.
-        let trap = run
-            .call(&mut store, &args, &mut [])
-            .unwrap_err()
-            .downcast::<Trap>()
-            .unwrap();
-
-        match trap {
-            Trap::TableOutOfBounds | Trap::OutOfFuel => {}
-            _ => panic!("unexpected trap: {trap}"),
+        {
+            let mut scope = RootScope::new(&mut store);
+
+            log::info!(
+                "table_ops: begin allocating {} externref arguments",
+                ops.num_globals
+            );
+            let args: Vec<_> = (0..ops.num_params)
+                .map(|_| {
+                    Ok(Val::ExternRef(Some(ExternRef::new(
+                        &mut scope,
+                        CountDrops(num_dropped.clone()),
+                    )?)))
+                })
+                .collect::<Result<_>>()?;
+            log::info!(
+                "table_ops: end allocating {} externref arguments",
+                ops.num_globals
+            );
+
+            // The generated function should always return a trap. The only two
+            // valid traps are table-out-of-bounds which happens through `table.get`
+            // and `table.set` generated or an out-of-fuel trap. Otherwise any other
+            // error is unexpected and should fail fuzzing.
+            log::info!("table_ops: calling into Wasm `run` function");
+            let trap = run
+                .call(&mut scope, &args, &mut [])
+                .unwrap_err()
+                .downcast::<Trap>()
+                .unwrap();
+
+            match trap {
+                Trap::TableOutOfBounds | Trap::OutOfFuel => {}
+                _ => panic!("unexpected trap: {trap}"),
+            }
         }
 
         // Do a final GC after running the Wasm.
@@ -740,7 +784,7 @@ pub fn table_ops(
     }
 
     assert_eq!(num_dropped.load(SeqCst), expected_drops.load(SeqCst));
-    return num_gcs.load(SeqCst);
+    return Ok(num_gcs.load(SeqCst));
 
     struct CountDrops(Arc<AtomicUsize>);
 
@@ -774,7 +818,7 @@ fn table_ops_eventually_gcs() {
         let u = Unstructured::new(&buf);
 
         if let Ok((config, test)) = Arbitrary::arbitrary_take_rest(u) {
-            if table_ops(config, test) > 0 {
+            if table_ops(config, test).unwrap() > 0 {
                 return;
             }
         }
@@ -784,73 +828,57 @@ fn table_ops_eventually_gcs() {
 }
 
 #[derive(Default)]
-struct SignalOnDrop {
-    state: Arc<(Mutex<bool>, Condvar)>,
+struct HelperThread {
+    state: Arc<HelperThreadState>,
     thread: Option<std::thread::JoinHandle<()>>,
 }
 
-impl SignalOnDrop {
-    fn spawn_timeout(&mut self, dur: Duration, closure: impl FnOnce() + Send + 'static) {
+#[derive(Default)]
+struct HelperThreadState {
+    should_exit: Mutex<bool>,
+    should_exit_cvar: Condvar,
+}
+
+impl HelperThread {
+    fn run_periodically(&mut self, dur: Duration, mut closure: impl FnMut() + Send + 'static) {
         let state = self.state.clone();
-        let start = Instant::now();
         self.thread = Some(std::thread::spawn(move || {
             // Using our mutex/condvar we wait here for the first of `dur` to
-            // pass or the `SignalOnDrop` instance to get dropped.
-            let (lock, cvar) = &*state;
-            let mut signaled = lock.lock().unwrap();
-            while !*signaled {
-                // Adjust our requested `dur` based on how much time has passed.
-                let dur = match dur.checked_sub(start.elapsed()) {
-                    Some(dur) => dur,
-                    None => break,
-                };
-                let (lock, result) = cvar.wait_timeout(signaled, dur).unwrap();
-                signaled = lock;
+            // pass or the `HelperThread` instance to get dropped.
+            let mut should_exit = state.should_exit.lock().unwrap();
+            while !*should_exit {
+                let (lock, result) = state
+                    .should_exit_cvar
+                    .wait_timeout(should_exit, dur)
+                    .unwrap();
+                should_exit = lock;
                 // If we timed out for sure then there's no need to continue
                 // since we'll just abort on the next `checked_sub` anyway.
                 if result.timed_out() {
-                    break;
+                    closure();
                 }
             }
-            drop(signaled);
-
-            closure();
         }));
     }
 }
 
-impl Drop for SignalOnDrop {
+impl Drop for HelperThread {
     fn drop(&mut self) {
-        if let Some(thread) = self.thread.take() {
-            let (lock, cvar) = &*self.state;
-            // Signal our thread that we've been dropped and wake it up if it's
-            // blocked.
-            let mut g = lock.lock().unwrap();
-            *g = true;
-            cvar.notify_one();
-            drop(g);
-
-            // ... and then wait for the thread to exit to ensure we clean up
-            // after ourselves.
-            thread.join().unwrap();
-        }
+        let thread = match self.thread.take() {
+            Some(thread) => thread,
+            None => return,
+        };
+        // Signal our thread that it should exit and wake it up in case it's
+        // sleeping.
+        *self.state.should_exit.lock().unwrap() = true;
+        self.state.should_exit_cvar.notify_one();
+
+        // ... and then wait for the thread to exit to ensure we clean up
+        // after ourselves.
+        thread.join().unwrap();
     }
 }
 
-/// Set the amount of fuel in a store to a given value
-pub fn set_fuel<T>(store: &mut Store<T>, fuel: u64) {
-    // Determine the amount of fuel already within the store, if any, and
-    // add/consume as appropriate to set the remaining amount to` fuel`.
-    let remaining = store.consume_fuel(0).unwrap();
-    if fuel > remaining {
-        store.add_fuel(fuel - remaining).unwrap();
-    } else {
-        store.consume_fuel(remaining - fuel).unwrap();
-    }
-    // double-check that the store has the expected amount of fuel remaining
-    assert_eq!(store.consume_fuel(0).unwrap(), fuel);
-}
-
 /// Generate and execute a `crate::generators::component_types::TestCase` using the specified `input` to create
 /// arbitrary types and values.
 pub fn dynamic_component_api_target(input: &mut arbitrary::Unstructured) -> arbitrary::Result<()> {
@@ -882,6 +910,9 @@ pub fn dynamic_component_api_target(input: &mut arbitrary::Unstructured) -> arbi
     };
 
     let mut config = component_test_util::config();
+    if case.results.len() > 1 {
+        config.wasm_component_model_multiple_returns(true);
+    }
     config.debug_adapter_modules(input.arbitrary()?);
     let engine = Engine::new(&config).unwrap();
     let mut store = Store::new(&engine, (Vec::new(), None));
@@ -893,7 +924,7 @@ pub fn dynamic_component_api_target(input: &mut arbitrary::Unstructured) -> arbi
 
     linker
         .root()
-        .func_new(&component, IMPORT_FUNCTION, {
+        .func_new(IMPORT_FUNCTION, {
             move |mut cx: StoreContextMut<'_, (Vec<Val>, Option<Vec<Val>>)>,
                   params: &[Val],
                   results: &mut [Val]|
@@ -938,3 +969,205 @@ pub fn dynamic_component_api_target(input: &mut arbitrary::Unstructured) -> arbi
 
     Ok(())
 }
+
+/// Instantiates a wasm module and runs its exports with dummy values, all in
+/// an async fashion.
+///
+/// Attempts to stress yields in host functions to ensure that exiting and
+/// resuming a wasm function call works.
+pub fn call_async(wasm: &[u8], config: &generators::Config, mut poll_amts: &[u32]) {
+    let mut store = config.to_store();
+    let module = match compile_module(store.engine(), wasm, KnownValid::Yes, config) {
+        Some(module) => module,
+        None => return,
+    };
+
+    // Configure a helper thread to periodically increment the epoch to
+    // forcibly enable yields-via-epochs if epochs are in use. Note that this
+    // is required because the wasm isn't otherwise guaranteed to necessarily
+    // call any imports which will also increment the epoch.
+    let mut helper_thread = HelperThread::default();
+    if let generators::AsyncConfig::YieldWithEpochs { dur, .. } = &config.wasmtime.async_config {
+        let engine = store.engine().clone();
+        helper_thread.run_periodically(*dur, move || engine.increment_epoch());
+    }
+
+    // Generate a `Linker` where all function imports are custom-built to yield
+    // periodically and additionally increment the epoch.
+    let mut imports = Vec::new();
+    for import in module.imports() {
+        let item = match import.ty() {
+            ExternType::Func(ty) => {
+                let poll_amt = take_poll_amt(&mut poll_amts);
+                Func::new_async(&mut store, ty.clone(), move |caller, _, results| {
+                    let ty = ty.clone();
+                    Box::new(async move {
+                        caller.engine().increment_epoch();
+                        log::info!("yielding {} times in import", poll_amt);
+                        YieldN(poll_amt).await;
+                        for (ret_ty, result) in ty.results().zip(results) {
+                            *result = dummy::dummy_value(ret_ty)?;
+                        }
+                        Ok(())
+                    })
+                })
+                .into()
+            }
+            other_ty => match dummy::dummy_extern(&mut store, other_ty) {
+                Ok(item) => item,
+                Err(e) => {
+                    log::warn!("couldn't create import: {}", e);
+                    return;
+                }
+            },
+        };
+        imports.push(item);
+    }
+
+    // Run the instantiation process, asynchronously, and if everything
+    // succeeds then pull out the instance.
+    // log::info!("starting instantiation");
+    let instance = run(Timeout {
+        future: Instance::new_async(&mut store, &module, &imports),
+        polls: take_poll_amt(&mut poll_amts),
+        end: Instant::now() + Duration::from_millis(2_000),
+    });
+    let instance = match instance {
+        Ok(instantiation_result) => match unwrap_instance(&store, instantiation_result) {
+            Some(instance) => instance,
+            None => {
+                log::info!("instantiation hit a nominal error");
+                return; // resource exhaustion or limits met
+            }
+        },
+        Err(_) => {
+            log::info!("instantiation failed to complete");
+            return; // Timed out or ran out of polls
+        }
+    };
+
+    // Run each export of the instance in the same manner as instantiation
+    // above. Dummy values are passed in for argument values here:
+    //
+    // TODO: this should probably be more clever about passing in arguments for
+    // example they might be used as pointers or something and always using 0
+    // isn't too interesting.
+    let funcs = instance
+        .exports(&mut store)
+        .filter_map(|e| {
+            let name = e.name().to_string();
+            let func = e.into_extern().into_func()?;
+            Some((name, func))
+        })
+        .collect::<Vec<_>>();
+    for (name, func) in funcs {
+        let ty = func.ty(&store);
+        let params = ty
+            .params()
+            .map(|ty| dummy::dummy_value(ty).unwrap())
+            .collect::<Vec<_>>();
+        let mut results = ty
+            .results()
+            .map(|ty| dummy::dummy_value(ty).unwrap())
+            .collect::<Vec<_>>();
+
+        log::info!("invoking export {:?}", name);
+        let future = func.call_async(&mut store, &params, &mut results);
+        match run(Timeout {
+            future,
+            polls: take_poll_amt(&mut poll_amts),
+            end: Instant::now() + Duration::from_millis(2_000),
+        }) {
+            // On success or too many polls, try the next export.
+            Ok(_) | Err(Exhausted::Polls) => {}
+
+            // If time ran out then stop the current test case as we might have
+            // already sucked up a lot of time for this fuzz test case so don't
+            // keep it going.
+            Err(Exhausted::Time) => return,
+        }
+    }
+
+    fn take_poll_amt(polls: &mut &[u32]) -> u32 {
+        match polls.split_first() {
+            Some((a, rest)) => {
+                *polls = rest;
+                *a
+            }
+            None => 0,
+        }
+    }
+
+    /// Helper future to yield N times before resolving.
+    struct YieldN(u32);
+
+    impl Future for YieldN {
+        type Output = ();
+
+        fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
+            if self.0 == 0 {
+                Poll::Ready(())
+            } else {
+                self.0 -= 1;
+                cx.waker().wake_by_ref();
+                Poll::Pending
+            }
+        }
+    }
+
+    /// Helper future for applying a timeout to `future` up to either when `end`
+    /// is the current time or `polls` polls happen.
+    ///
+    /// Note that this helps to time out infinite loops in wasm, for example.
+    struct Timeout<F> {
+        future: F,
+        /// If the future isn't ready by this time then the `Timeout<F>` future
+        /// will return `None`.
+        end: Instant,
+        /// If the future doesn't resolve itself in this many calls to `poll`
+        /// then the `Timeout<F>` future will return `None`.
+        polls: u32,
+    }
+
+    enum Exhausted {
+        Time,
+        Polls,
+    }
+
+    impl<F: Future> Future for Timeout<F> {
+        type Output = Result<F::Output, Exhausted>;
+
+        fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+            let (end, polls, future) = unsafe {
+                let me = self.get_unchecked_mut();
+                (me.end, &mut me.polls, Pin::new_unchecked(&mut me.future))
+            };
+            match future.poll(cx) {
+                Poll::Ready(val) => Poll::Ready(Ok(val)),
+                Poll::Pending => {
+                    if Instant::now() >= end {
+                        log::warn!("future operation timed out");
+                        return Poll::Ready(Err(Exhausted::Time));
+                    }
+                    if *polls == 0 {
+                        log::warn!("future operation ran out of polls");
+                        return Poll::Ready(Err(Exhausted::Polls));
+                    }
+                    *polls -= 1;
+                    Poll::Pending
+                }
+            }
+        }
+    }
+
+    fn run<F: Future>(future: F) -> F::Output {
+        let mut f = Box::pin(future);
+        let mut cx = Context::from_waker(futures::task::noop_waker_ref());
+        loop {
+            match f.as_mut().poll(&mut cx) {
+                Poll::Ready(val) => break val,
+                Poll::Pending => {}
+            }
+        }
+    }
+}
diff --git a/crates/fuzzing/src/oracles/diff_spec.rs b/crates/fuzzing/src/oracles/diff_spec.rs
index 3ed92ff401a6..4073fd3cfb3e 100644
--- a/crates/fuzzing/src/oracles/diff_spec.rs
+++ b/crates/fuzzing/src/oracles/diff_spec.rs
@@ -76,7 +76,7 @@ impl DiffInstance for SpecInstance {
         if let Ok(Global(g)) = export(&self.instance, name) {
             Some(g.into())
         } else {
-            panic!("expected an exported global value at name `{}`", name)
+            panic!("expected an exported global value at name `{name}`")
         }
     }
 
@@ -85,7 +85,7 @@ impl DiffInstance for SpecInstance {
         if let Ok(Memory(m)) = export(&self.instance, name) {
             Some(m)
         } else {
-            panic!("expected an exported memory at name `{}`", name)
+            panic!("expected an exported memory at name `{name}`")
         }
     }
 }
@@ -98,7 +98,9 @@ impl From<&DiffValue> for SpecValue {
             DiffValue::F32(n) => SpecValue::F32(n as i32),
             DiffValue::F64(n) => SpecValue::F64(n as i64),
             DiffValue::V128(n) => SpecValue::V128(n.to_le_bytes().to_vec()),
-            DiffValue::FuncRef { .. } | DiffValue::ExternRef { .. } => unimplemented!(),
+            DiffValue::FuncRef { .. } | DiffValue::ExternRef { .. } | DiffValue::AnyRef { .. } => {
+                unimplemented!()
+            }
         }
     }
 }
diff --git a/crates/fuzzing/src/oracles/diff_v8.rs b/crates/fuzzing/src/oracles/diff_v8.rs
index 1d03c200411c..136b956d937c 100644
--- a/crates/fuzzing/src/oracles/diff_v8.rs
+++ b/crates/fuzzing/src/oracles/diff_v8.rs
@@ -80,22 +80,17 @@ impl DiffEngine for V8Engine {
         let v8 = err.to_string();
         let wasmtime_msg = wasmtime.to_string();
         let verify_wasmtime = |msg: &str| {
-            assert!(wasmtime_msg.contains(msg), "{}\n!=\n{}", wasmtime_msg, v8);
+            assert!(wasmtime_msg.contains(msg), "{wasmtime_msg}\n!=\n{v8}");
         };
         let verify_v8 = |msg: &[&str]| {
             assert!(
                 msg.iter().any(|msg| v8.contains(msg)),
-                "{:?}\n\t!=\n{}",
-                wasmtime_msg,
-                v8
+                "{wasmtime_msg:?}\n\t!=\n{v8}"
             );
         };
         match wasmtime {
             Trap::MemoryOutOfBounds => {
-                return verify_v8(&[
-                    "memory access out of bounds",
-                    "data segment is out of bounds",
-                ])
+                return verify_v8(&["memory access out of bounds", "is out of bounds"])
             }
             Trap::UnreachableCodeReached => {
                 return verify_v8(&[
@@ -132,6 +127,7 @@ impl DiffEngine for V8Engine {
                 return verify_v8(&[
                     "table initializer is out of bounds",
                     "table index is out of bounds",
+                    "element segment out of bounds",
                 ])
             }
             Trap::BadSignature => return verify_v8(&["function signature mismatch"]),
@@ -191,6 +187,7 @@ impl DiffInstance for V8Instance {
                 }
                 // JS doesn't support v128 parameters
                 DiffValue::V128(_) => return Ok(None),
+                DiffValue::AnyRef { .. } => unimplemented!(),
             });
         }
         // JS doesn't support v128 return values
@@ -297,7 +294,7 @@ fn get_diff_value(
     scope: &mut v8::HandleScope<'_>,
 ) -> DiffValue {
     match ty {
-        DiffValueType::I32 => DiffValue::I32(val.to_int32(scope).unwrap().value() as i32),
+        DiffValueType::I32 => DiffValue::I32(val.to_int32(scope).unwrap().value()),
         DiffValueType::I64 => {
             let (val, todo) = val.to_big_int(scope).unwrap().i64_value();
             assert!(todo);
@@ -313,6 +310,7 @@ fn get_diff_value(
         DiffValueType::ExternRef => DiffValue::ExternRef {
             null: val.is_null(),
         },
+        DiffValueType::AnyRef => unimplemented!(),
         DiffValueType::V128 => unreachable!(),
     }
 }
diff --git a/crates/fuzzing/src/oracles/diff_wasmi.rs b/crates/fuzzing/src/oracles/diff_wasmi.rs
index 0864d34d5431..45c57cefa259 100644
--- a/crates/fuzzing/src/oracles/diff_wasmi.rs
+++ b/crates/fuzzing/src/oracles/diff_wasmi.rs
@@ -13,18 +13,29 @@ pub struct WasmiEngine {
 impl WasmiEngine {
     pub(crate) fn new(config: &mut Config) -> Self {
         let config = &mut config.module_config.config;
-        config.reference_types_enabled = false;
+        // Force generated Wasm modules to never have features that Wasmi doesn't support.
         config.simd_enabled = false;
+        config.relaxed_simd_enabled = false;
         config.memory64_enabled = false;
-        config.bulk_memory_enabled = false;
         config.threads_enabled = false;
+        config.exceptions_enabled = false;
         config.max_memories = config.max_memories.min(1);
         config.min_memories = config.min_memories.min(1);
-        config.max_tables = config.max_tables.min(1);
-        config.min_tables = config.min_tables.min(1);
 
+        let mut wasmi_config = wasmi::Config::default();
+        wasmi_config
+            .consume_fuel(false)
+            .floats(true)
+            .wasm_mutable_global(true)
+            .wasm_sign_extension(config.sign_extension_ops_enabled)
+            .wasm_saturating_float_to_int(config.saturating_float_to_int_enabled)
+            .wasm_multi_value(config.multi_value_enabled)
+            .wasm_bulk_memory(config.bulk_memory_enabled)
+            .wasm_reference_types(config.reference_types_enabled)
+            .wasm_tail_call(config.tail_call_enabled)
+            .wasm_extended_const(true);
         Self {
-            engine: wasmi::Engine::default(),
+            engine: wasmi::Engine::new(&wasmi_config),
         }
     }
 }
@@ -38,7 +49,7 @@ impl DiffEngine for WasmiEngine {
         let module =
             wasmi::Module::new(&self.engine, wasm).context("unable to validate Wasm module")?;
         let mut store = wasmi::Store::new(&self.engine, ());
-        let instance = wasmi::Linker::<()>::new()
+        let instance = wasmi::Linker::<()>::new(&self.engine)
             .instantiate(&mut store, &module)
             .and_then(|i| i.start(&mut store))
             .context("unable to instantiate module in wasmi")?;
@@ -70,14 +81,17 @@ impl DiffEngine for WasmiEngine {
                 return;
             }
 
-            Some(other) => panic!("unexpected wasmi error: {}", other),
+            Some(other) => panic!("unexpected wasmi error: {other}"),
 
             None => err
                 .downcast_ref::<wasmi::core::Trap>()
-                .expect(&format!("not a trap: {:?}", err)),
+                .expect(&format!("not a trap: {err:?}")),
         };
-        assert!(wasmi.as_code().is_some());
-        assert_eq!(wasmi_to_wasmtime_trap_code(wasmi.as_code().unwrap()), *trap);
+        assert!(wasmi.trap_code().is_some());
+        assert_eq!(
+            wasmi_to_wasmtime_trap_code(wasmi.trap_code().unwrap()),
+            *trap
+        );
     }
 
     fn is_stack_overflow(&self, err: &Error) -> bool {
@@ -89,7 +103,7 @@ impl DiffEngine for WasmiEngine {
                 None => return false,
             },
         };
-        matches!(trap.as_code(), Some(wasmi::core::TrapCode::StackOverflow))
+        matches!(trap.trap_code(), Some(wasmi::core::TrapCode::StackOverflow))
     }
 }
 
@@ -97,15 +111,17 @@ impl DiffEngine for WasmiEngine {
 fn wasmi_to_wasmtime_trap_code(trap: wasmi::core::TrapCode) -> Trap {
     use wasmi::core::TrapCode;
     match trap {
-        TrapCode::Unreachable => Trap::UnreachableCodeReached,
-        TrapCode::MemoryAccessOutOfBounds => Trap::MemoryOutOfBounds,
-        TrapCode::TableAccessOutOfBounds => Trap::TableOutOfBounds,
-        TrapCode::ElemUninitialized => Trap::IndirectCallToNull,
-        TrapCode::DivisionByZero => Trap::IntegerDivisionByZero,
+        TrapCode::UnreachableCodeReached => Trap::UnreachableCodeReached,
+        TrapCode::MemoryOutOfBounds => Trap::MemoryOutOfBounds,
+        TrapCode::TableOutOfBounds => Trap::TableOutOfBounds,
+        TrapCode::IndirectCallToNull => Trap::IndirectCallToNull,
+        TrapCode::IntegerDivisionByZero => Trap::IntegerDivisionByZero,
         TrapCode::IntegerOverflow => Trap::IntegerOverflow,
-        TrapCode::InvalidConversionToInt => Trap::BadConversionToInteger,
+        TrapCode::BadConversionToInteger => Trap::BadConversionToInteger,
         TrapCode::StackOverflow => Trap::StackOverflow,
-        TrapCode::UnexpectedSignature => Trap::BadSignature,
+        TrapCode::BadSignature => Trap::BadSignature,
+        TrapCode::OutOfFuel => unimplemented!("built-in fuel metering is unused"),
+        TrapCode::GrowthOperationLimited => unimplemented!("resource limiter is unused"),
     }
 }
 
@@ -132,7 +148,7 @@ impl DiffInstance for WasmiInstance {
             .and_then(wasmi::Extern::into_func)
             .unwrap();
         let arguments: Vec<_> = arguments.iter().map(|x| x.into()).collect();
-        let mut results = vec![wasmi::core::Value::I32(0); result_tys.len()];
+        let mut results = vec![wasmi::Value::I32(0); result_tys.len()];
         function
             .call(&mut self.store, &arguments, &mut results)
             .context("wasmi function trap")?;
@@ -165,29 +181,38 @@ impl DiffInstance for WasmiInstance {
     }
 }
 
-impl From<&DiffValue> for wasmi::core::Value {
+impl From<&DiffValue> for wasmi::Value {
     fn from(v: &DiffValue) -> Self {
-        use wasmi::core::Value::*;
+        use wasmi::Value as WasmiValue;
         match *v {
-            DiffValue::I32(n) => I32(n),
-            DiffValue::I64(n) => I64(n),
-            DiffValue::F32(n) => F32(wasmi::core::F32::from_bits(n)),
-            DiffValue::F64(n) => F64(wasmi::core::F64::from_bits(n)),
-            DiffValue::V128(_) | DiffValue::FuncRef { .. } | DiffValue::ExternRef { .. } => {
-                unimplemented!()
+            DiffValue::I32(n) => WasmiValue::I32(n),
+            DiffValue::I64(n) => WasmiValue::I64(n),
+            DiffValue::F32(n) => WasmiValue::F32(wasmi::core::F32::from_bits(n)),
+            DiffValue::F64(n) => WasmiValue::F64(wasmi::core::F64::from_bits(n)),
+            DiffValue::V128(_) => unimplemented!(),
+            DiffValue::FuncRef { null } => {
+                assert!(null);
+                WasmiValue::FuncRef(wasmi::FuncRef::null())
             }
+            DiffValue::ExternRef { null } => {
+                assert!(null);
+                WasmiValue::ExternRef(wasmi::ExternRef::null())
+            }
+            DiffValue::AnyRef { .. } => unimplemented!(),
         }
     }
 }
 
-impl From<wasmi::core::Value> for DiffValue {
-    fn from(value: wasmi::core::Value) -> Self {
-        use wasmi::core::Value as WasmiValue;
+impl From<wasmi::Value> for DiffValue {
+    fn from(value: wasmi::Value) -> Self {
+        use wasmi::Value as WasmiValue;
         match value {
             WasmiValue::I32(n) => DiffValue::I32(n),
             WasmiValue::I64(n) => DiffValue::I64(n),
             WasmiValue::F32(n) => DiffValue::F32(n.to_bits()),
             WasmiValue::F64(n) => DiffValue::F64(n.to_bits()),
+            WasmiValue::FuncRef(f) => DiffValue::FuncRef { null: f.is_null() },
+            WasmiValue::ExternRef(e) => DiffValue::ExternRef { null: e.is_null() },
         }
     }
 }
diff --git a/crates/fuzzing/src/oracles/diff_wasmtime.rs b/crates/fuzzing/src/oracles/diff_wasmtime.rs
index 9333c02e6579..b232b0e8d1bd 100644
--- a/crates/fuzzing/src/oracles/diff_wasmtime.rs
+++ b/crates/fuzzing/src/oracles/diff_wasmtime.rs
@@ -1,9 +1,10 @@
 //! Evaluate an exported Wasm function using Wasmtime.
 
-use crate::generators::{self, DiffValue, DiffValueType, WasmtimeConfig};
+use crate::generators::{self, CompilerStrategy, DiffValue, DiffValueType, WasmtimeConfig};
 use crate::oracles::dummy;
 use crate::oracles::engine::DiffInstance;
 use crate::oracles::{compile_module, engine::DiffEngine, StoreLimits};
+use crate::single_module_fuzzer::KnownValid;
 use anyhow::{Context, Error, Result};
 use arbitrary::Unstructured;
 use wasmtime::{Extern, FuncType, Instance, Module, Store, Trap, Val};
@@ -18,9 +19,18 @@ impl WasmtimeEngine {
     /// later. Ideally the store and engine could be built here but
     /// `compile_module` takes a [`generators::Config`]; TODO re-factor this if
     /// that ever changes.
-    pub fn new(u: &mut Unstructured<'_>, config: &generators::Config) -> arbitrary::Result<Self> {
+    pub fn new(
+        u: &mut Unstructured<'_>,
+        config: &mut generators::Config,
+        compiler_strategy: CompilerStrategy,
+    ) -> arbitrary::Result<Self> {
+        if let CompilerStrategy::Winch = compiler_strategy {
+            config.disable_unimplemented_winch_proposals();
+        }
         let mut new_config = u.arbitrary::<WasmtimeConfig>()?;
+        new_config.compiler_strategy = compiler_strategy;
         new_config.make_compatible_with(&config.wasmtime);
+
         let config = generators::Config {
             wasmtime: new_config,
             module_config: config.module_config.clone(),
@@ -31,12 +41,15 @@ impl WasmtimeEngine {
 
 impl DiffEngine for WasmtimeEngine {
     fn name(&self) -> &'static str {
-        "wasmtime"
+        match self.config.wasmtime.compiler_strategy {
+            CompilerStrategy::Cranelift => "wasmtime",
+            CompilerStrategy::Winch => "winch",
+        }
     }
 
     fn instantiate(&mut self, wasm: &[u8]) -> Result<Box<dyn DiffInstance>> {
         let store = self.config.to_store();
-        let module = compile_module(store.engine(), wasm, true, &self.config).unwrap();
+        let module = compile_module(store.engine(), wasm, KnownValid::Yes, &self.config).unwrap();
         let instance = WasmtimeInstance::new(store, module)?;
         Ok(Box::new(instance))
     }
@@ -44,8 +57,8 @@ impl DiffEngine for WasmtimeEngine {
     fn assert_error_match(&self, trap: &Trap, err: &Error) {
         let trap2 = err
             .downcast_ref::<Trap>()
-            .expect(&format!("not a trap: {:?}", err));
-        assert_eq!(trap, trap2, "{}\nis not equal to\n{}", trap, trap2);
+            .expect(&format!("not a trap: {err:?}"));
+        assert_eq!(trap, trap2, "{trap}\nis not equal to\n{trap2}");
     }
 
     fn is_stack_overflow(&self, err: &Error) -> bool {
@@ -205,6 +218,10 @@ impl From<&DiffValue> for Val {
                 assert!(null);
                 Val::ExternRef(None)
             }
+            DiffValue::AnyRef { null } => {
+                assert!(null);
+                Val::AnyRef(None)
+            }
         }
     }
 }
@@ -217,13 +234,26 @@ impl Into<DiffValue> for Val {
             Val::F32(n) => DiffValue::F32(n),
             Val::F64(n) => DiffValue::F64(n),
             Val::V128(n) => DiffValue::V128(n.into()),
-            Val::FuncRef(f) => DiffValue::FuncRef { null: f.is_none() },
-            Val::ExternRef(e) => DiffValue::ExternRef { null: e.is_none() },
+            Val::ExternRef(r) => DiffValue::ExternRef { null: r.is_none() },
+            Val::FuncRef(r) => DiffValue::FuncRef { null: r.is_none() },
+            Val::AnyRef(r) => DiffValue::AnyRef { null: r.is_none() },
         }
     }
 }
 
 #[test]
-fn smoke() {
-    crate::oracles::engine::smoke_test_engine(|u, config| WasmtimeEngine::new(u, config))
+fn smoke_cranelift() {
+    crate::oracles::engine::smoke_test_engine(|u, config| {
+        WasmtimeEngine::new(u, config, CompilerStrategy::Cranelift)
+    })
+}
+
+#[test]
+fn smoke_winch() {
+    if !cfg!(target_arch = "x86_64") {
+        return;
+    }
+    crate::oracles::engine::smoke_test_engine(|u, config| {
+        WasmtimeEngine::new(u, config, CompilerStrategy::Winch)
+    })
 }
diff --git a/crates/fuzzing/src/oracles/dummy.rs b/crates/fuzzing/src/oracles/dummy.rs
index 69350693ae5b..2530d31d27c4 100644
--- a/crates/fuzzing/src/oracles/dummy.rs
+++ b/crates/fuzzing/src/oracles/dummy.rs
@@ -1,10 +1,10 @@
 //! Dummy implementations of things that a Wasm module can import.
 
-use anyhow::Result;
+use anyhow::ensure;
 use wasmtime::*;
 
 /// Create a set of dummy functions/globals/etc for the given imports.
-pub fn dummy_linker<'module, T>(store: &mut Store<T>, module: &Module) -> Result<Linker<T>> {
+pub fn dummy_linker<T>(store: &mut Store<T>, module: &Module) -> Result<Linker<T>> {
     let mut linker = Linker::new(store.engine());
     linker.allow_shadowing(true);
     for import in module.imports() {
@@ -19,51 +19,57 @@ pub fn dummy_linker<'module, T>(store: &mut Store<T>, module: &Module) -> Result
 /// Construct a dummy `Extern` from its type signature
 pub fn dummy_extern<T>(store: &mut Store<T>, ty: ExternType) -> Result<Extern> {
     Ok(match ty {
-        ExternType::Func(func_ty) => Extern::Func(dummy_func(store, func_ty)),
-        ExternType::Global(global_ty) => Extern::Global(dummy_global(store, global_ty)),
+        ExternType::Func(func_ty) => Extern::Func(dummy_func(store, func_ty)?),
+        ExternType::Global(global_ty) => Extern::Global(dummy_global(store, global_ty)?),
         ExternType::Table(table_ty) => Extern::Table(dummy_table(store, table_ty)?),
         ExternType::Memory(mem_ty) => Extern::Memory(dummy_memory(store, mem_ty)?),
     })
 }
 
 /// Construct a dummy function for the given function type
-pub fn dummy_func<T>(store: &mut Store<T>, ty: FuncType) -> Func {
-    Func::new(store, ty.clone(), move |_, _, results| {
-        for (ret_ty, result) in ty.results().zip(results) {
-            *result = dummy_value(ret_ty);
+pub fn dummy_func<T>(store: &mut Store<T>, ty: FuncType) -> Result<Func> {
+    let dummy_results = ty.results().map(dummy_value).collect::<Result<Vec<_>>>()?;
+    Ok(Func::new(store, ty.clone(), move |_, _, results| {
+        for (slot, dummy) in results.iter_mut().zip(&dummy_results) {
+            *slot = *dummy;
         }
         Ok(())
-    })
+    }))
 }
 
 /// Construct a dummy value for the given value type.
-pub fn dummy_value(val_ty: ValType) -> Val {
-    match val_ty {
+pub fn dummy_value(val_ty: ValType) -> Result<Val> {
+    Ok(match val_ty {
         ValType::I32 => Val::I32(0),
         ValType::I64 => Val::I64(0),
         ValType::F32 => Val::F32(0),
         ValType::F64 => Val::F64(0),
         ValType::V128 => Val::V128(0.into()),
-        ValType::ExternRef => Val::ExternRef(None),
-        ValType::FuncRef => Val::FuncRef(None),
-    }
+        ValType::Ref(r) => {
+            ensure!(
+                r.is_nullable(),
+                "cannot construct a dummy value of type `{r}`"
+            );
+            Val::null_ref(r.heap_type())
+        }
+    })
 }
 
 /// Construct a sequence of dummy values for the given types.
-pub fn dummy_values(val_tys: impl IntoIterator<Item = ValType>) -> Vec<Val> {
+pub fn dummy_values(val_tys: impl IntoIterator<Item = ValType>) -> Result<Vec<Val>> {
     val_tys.into_iter().map(dummy_value).collect()
 }
 
 /// Construct a dummy global for the given global type.
-pub fn dummy_global<T>(store: &mut Store<T>, ty: GlobalType) -> Global {
-    let val = dummy_value(ty.content().clone());
-    Global::new(store, ty, val).unwrap()
+pub fn dummy_global<T>(store: &mut Store<T>, ty: GlobalType) -> Result<Global> {
+    let val = dummy_value(ty.content().clone())?;
+    Global::new(store, ty, val)
 }
 
 /// Construct a dummy table for the given table type.
 pub fn dummy_table<T>(store: &mut Store<T>, ty: TableType) -> Result<Table> {
-    let init_val = dummy_value(ty.element().clone());
-    Table::new(store, ty, init_val)
+    let init_val = dummy_value(ty.element().clone().into())?;
+    Table::new(store, ty, init_val.ref_().unwrap())
 }
 
 /// Construct a dummy memory for the given memory type.
@@ -85,22 +91,19 @@ mod tests {
     #[test]
     fn dummy_table_import() {
         let mut store = store();
-        let table = dummy_table(&mut store, TableType::new(ValType::ExternRef, 10, None)).unwrap();
+        let table = dummy_table(&mut store, TableType::new(RefType::EXTERNREF, 10, None)).unwrap();
         assert_eq!(table.size(&store), 10);
         for i in 0..10 {
-            assert!(table
-                .get(&mut store, i)
-                .unwrap()
-                .unwrap_externref()
-                .is_none());
+            assert!(table.get(&mut store, i).unwrap().unwrap_extern().is_none());
         }
     }
 
     #[test]
     fn dummy_global_import() {
         let mut store = store();
-        let global = dummy_global(&mut store, GlobalType::new(ValType::I32, Mutability::Const));
-        assert_eq!(*global.ty(&store).content(), ValType::I32);
+        let global =
+            dummy_global(&mut store, GlobalType::new(ValType::I32, Mutability::Const)).unwrap();
+        assert!(global.ty(&store).content().is_i32());
         assert_eq!(global.ty(&store).mutability(), Mutability::Const);
     }
 
@@ -114,8 +117,9 @@ mod tests {
     #[test]
     fn dummy_function_import() {
         let mut store = store();
-        let func_ty = FuncType::new(vec![ValType::I32], vec![ValType::I64]);
-        let func = dummy_func(&mut store, func_ty.clone());
-        assert_eq!(func.ty(&store), func_ty);
+        let func_ty = FuncType::new(store.engine(), vec![ValType::I32], vec![ValType::I64]);
+        let func = dummy_func(&mut store, func_ty.clone()).unwrap();
+        let actual_ty = func.ty(&store);
+        assert!(FuncType::eq(&actual_ty, &func_ty));
     }
 }
diff --git a/crates/fuzzing/src/oracles/engine.rs b/crates/fuzzing/src/oracles/engine.rs
index 977f072321b9..77c76c583003 100644
--- a/crates/fuzzing/src/oracles/engine.rs
+++ b/crates/fuzzing/src/oracles/engine.rs
@@ -1,6 +1,6 @@
 //! Define the interface for differential evaluation of Wasm functions.
 
-use crate::generators::{Config, DiffValue, DiffValueType};
+use crate::generators::{CompilerStrategy, Config, DiffValue, DiffValueType};
 use crate::oracles::{diff_wasmi::WasmiEngine, diff_wasmtime::WasmtimeEngine};
 use anyhow::Error;
 use arbitrary::Unstructured;
@@ -16,9 +16,14 @@ pub fn build(
     config: &mut Config,
 ) -> arbitrary::Result<Option<Box<dyn DiffEngine>>> {
     let engine: Box<dyn DiffEngine> = match name {
-        "wasmtime" => Box::new(WasmtimeEngine::new(u, config)?),
+        "wasmtime" => Box::new(WasmtimeEngine::new(u, config, CompilerStrategy::Cranelift)?),
         "wasmi" => Box::new(WasmiEngine::new(config)),
 
+        #[cfg(target_arch = "x86_64")]
+        "winch" => Box::new(WasmtimeEngine::new(u, config, CompilerStrategy::Winch)?),
+        #[cfg(not(target_arch = "x86_64"))]
+        "winch" => return Ok(None),
+
         #[cfg(feature = "fuzz-spec-interpreter")]
         "spec" => Box::new(crate::oracles::diff_spec::SpecInterpreter::new(config)),
         #[cfg(not(feature = "fuzz-spec-interpreter"))]
@@ -127,10 +132,7 @@ pub fn build_allowed_env_list<'a>(
         // Check that the configured names are valid ones.
         for c in configured {
             if !defaults.contains(&&c[start..]) {
-                panic!(
-                    "invalid environment configuration `{}`; must be one of: {:?}",
-                    c, defaults
-                );
+                panic!("invalid environment configuration `{c}`; must be one of: {defaults:?}");
             }
         }
 
@@ -180,7 +182,7 @@ pub fn smoke_test_engine<T>(
         let mut engine = match mk_engine(&mut u, &mut config) {
             Ok(engine) => engine,
             Err(e) => {
-                println!("skip {:?}", e);
+                println!("skip {e:?}");
                 continue;
             }
         };
diff --git a/crates/fuzzing/src/oracles/memory.rs b/crates/fuzzing/src/oracles/memory.rs
new file mode 100644
index 000000000000..77bda60f386e
--- /dev/null
+++ b/crates/fuzzing/src/oracles/memory.rs
@@ -0,0 +1,403 @@
+//! Oracles related to memory.
+
+use crate::generators::{HeapImage, MemoryAccesses};
+use wasmtime::*;
+
+/// Oracle to perform the described memory accesses and check that they are all
+/// in- or out-of-bounds as expected
+pub fn check_memory_accesses(input: MemoryAccesses) {
+    crate::init_fuzzing();
+    log::info!("Testing memory accesses: {input:#x?}");
+
+    let offset = input.offset;
+    let growth = input.growth;
+    let wasm = build_wasm(&input.image, offset);
+    crate::oracles::log_wasm(&wasm);
+    let offset = u64::from(offset);
+
+    let mut config = input.config.to_wasmtime();
+
+    // Force-enable proposals if the heap image needs them.
+    if input.image.memory64 {
+        config.wasm_memory64(true);
+    }
+    if input.image.page_size_log2.is_some() {
+        config.wasm_custom_page_sizes(true);
+    }
+
+    let engine = Engine::new(&config).unwrap();
+    let module = match Module::new(&engine, &wasm) {
+        Ok(m) => m,
+        Err(e) => {
+            let e = format!("{e:?}");
+            log::info!("Failed to create `Module`: {e}");
+            if cfg!(feature = "fuzz-pcc") && e.contains("Compilation error: Proof-carrying-code") {
+                return;
+            }
+            assert!(
+                e.contains("bytes which exceeds the configured maximum of")
+                    || e.contains("exceeds the limit of"),
+                "bad module compilation error: {e:?}",
+            );
+            return;
+        }
+    };
+
+    let limits = super::StoreLimits::new();
+    let mut store = Store::new(&engine, limits);
+    input.config.configure_store(&mut store);
+
+    // If we are using fuel, make sure we add enough that we won't ever run out.
+    if input.config.wasmtime.consume_fuel {
+        store.set_fuel(u64::MAX).unwrap();
+    }
+
+    let instance = match Instance::new(&mut store, &module, &[]) {
+        Ok(x) => x,
+        Err(e) => {
+            log::info!("Failed to instantiate: {e:?}");
+            assert!(format!("{e:?}").contains("Cannot allocate memory"));
+            return;
+        }
+    };
+
+    let memory = instance.get_memory(&mut store, "memory").unwrap();
+    let load8 = instance
+        .get_typed_func::<u64, u32>(&mut store, "load8")
+        .unwrap();
+    let load16 = instance
+        .get_typed_func::<u64, u32>(&mut store, "load16")
+        .unwrap();
+    let load32 = instance
+        .get_typed_func::<u64, u32>(&mut store, "load32")
+        .unwrap();
+    let load64 = instance
+        .get_typed_func::<u64, u64>(&mut store, "load64")
+        .unwrap();
+
+    let do_accesses = |store: &mut Store<_>, msg: &str| {
+        let len = memory.data_size(&mut *store);
+        let len = u64::try_from(len).unwrap();
+
+        if let Some(n) = len.checked_sub(8).and_then(|n| n.checked_sub(offset)) {
+            // Test various in-bounds accesses near the bound.
+            for i in 0..=7 {
+                let addr = n + i;
+                assert!(addr + offset + 1 <= len);
+                let result = load8.call(&mut *store, addr);
+                assert!(
+                    result.is_ok(),
+                    "{msg}: len={len:#x}, offset={offset:#x}, load8({n:#x} + {i:#x} = {addr:#x}) \
+                     should be in bounds, got {result:?}"
+                );
+            }
+            for i in 0..=6 {
+                let addr = n + offset + i;
+                assert!(addr + 2 <= len);
+                let result = load16.call(&mut *store, n + i);
+                assert!(
+                    result.is_ok(),
+                    "{msg}: len={len:#x}, offset={offset:#x}, load16({n:#x} + {i:#x} = {addr:#x}) \
+                     should be in bounds, got {result:?}"
+                );
+            }
+            for i in 0..=4 {
+                let addr = n + offset + i;
+                assert!(addr + 4 <= len);
+                let result = load32.call(&mut *store, n + i);
+                assert!(
+                    result.is_ok(),
+                    "{msg}: len={len:#x}, offset={offset:#x}, load32({n:#x} + {i:#x} = {addr:#x}) \
+                     should be in bounds, got {result:?}"
+                );
+            }
+            assert!(n + offset + 8 <= len);
+            let result = load64.call(&mut *store, n);
+            assert!(
+                result.is_ok(),
+                "{msg}: len={len:#x}, offset={offset:#x}, load64({n:#x}) should be in bounds, \
+                 got {result:?}"
+            );
+
+            // Test various out-of-bounds accesses overlapping the memory bound.
+            for i in 1..2 {
+                let addr = len - i;
+                assert!(addr + offset + 2 > len);
+                let result = load16.call(&mut *store, addr);
+                assert!(
+                    result.is_err(),
+                    "{msg}: len={len:#x}, offset={offset:#x}, load16({len:#x} - {i:#x} = {addr:#x}) \
+                     should trap, got {result:?}"
+                );
+            }
+            for i in 1..4 {
+                let addr = len - i;
+                assert!(addr + offset + 4 > len);
+                let result = load32.call(&mut *store, addr);
+                assert!(
+                    result.is_err(),
+                    "{msg}: len={len:#x}, offset={offset:#x}, load32({len:#x} - {i:#x} = {addr:#x}) \
+                     should trap, got {result:?}"
+                );
+            }
+            for i in 1..8 {
+                let addr = len - i;
+                assert!(addr + offset + 8 > len);
+                let result = load64.call(&mut *store, addr);
+                assert!(
+                    result.is_err(),
+                    "{msg}: len={len:#x}, offset={offset:#x}, load64({len:#x} - {i:#x} = {addr:#x}) \
+                     should trap, got {result:?}"
+                );
+            }
+        }
+
+        // Test that out-of-bounds accesses just after the memory bound trap.
+        if let Some(n) = len.checked_sub(offset) {
+            for i in 0..=1 {
+                let addr = n + i;
+                assert!(addr + offset + 1 > len);
+                let result = load8.call(&mut *store, addr);
+                assert!(
+                    result.is_err(),
+                    "{msg}: len={len:#x}, offset={offset:#x}, load8({n:#x} + {i:#x} = {addr:#x}) \
+                     should trap, got {result:?}"
+                );
+                assert!(addr + offset + 2 > len);
+                let result = load16.call(&mut *store, addr);
+                assert!(
+                    result.is_err(),
+                    "{msg}: len={len:#x}, offset={offset:#x}, load16({n:#x} + {i:#x} = {addr:#x}) \
+                     should trap, got {result:?}"
+                );
+                assert!(addr + offset + 4 > len);
+                let result = load32.call(&mut *store, addr);
+                assert!(
+                    result.is_err(),
+                    "{msg}: len={len:#x}, offset={offset:#x}, load32({n:#x} + {i:#x} = {addr:#x}) \
+                     should trap, got {result:?}"
+                );
+                assert!(addr + offset + 8 > len);
+                let result = load64.call(&mut *store, addr);
+                assert!(
+                    result.is_err(),
+                    "{msg}: len={len:#x}, offset={offset:#x}, load64({n:#x} + {i:#x} = {addr:#x}) \
+                     should trap, got {result:?}"
+                );
+            }
+        }
+
+        // Test out-of-bounds accesses near the end of the index type's range to
+        // double check our overflow handling inside the bounds checks.
+        let len_is_4gib = len == u64::from(u32::MAX) + 1;
+        let end_delta = (input.image.memory64 && len_is_4gib) as u64;
+        let max = if input.image.memory64 {
+            u64::MAX
+        } else {
+            u64::from(u32::MAX)
+        };
+        for i in 0..(1 - end_delta) {
+            let addr = max - i;
+            let result = load8.call(&mut *store, addr);
+            assert!(
+                result.is_err(),
+                "{msg}: len={len:#x}, offset={offset:#x}, load8({max:#x} - {i:#x} = {addr:#x}) \
+                 should trap, got {result:?}"
+            );
+        }
+        for i in 0..(2 - end_delta) {
+            let addr = max - i;
+            let result = load16.call(&mut *store, addr);
+            assert!(
+                result.is_err(),
+                "{msg}: len={len:#x}, offset={offset:#x}, load16({max:#x} - {i:#x} = {addr:#x}) \
+                 should trap, got {result:?}"
+            );
+        }
+        for i in 0..(4 - end_delta) {
+            let addr = max - i;
+            let result = load32.call(&mut *store, addr);
+            assert!(
+                result.is_err(),
+                "{msg}: len={len:#x}, offset={offset:#x}, load32({max:#x} - {i:#x} = {addr:#x}) \
+                 should trap, got {result:?}"
+            );
+        }
+        for i in 0..(8 - end_delta) {
+            let addr = max - i;
+            let result = load64.call(&mut *store, addr);
+            assert!(
+                result.is_err(),
+                "{msg}: len={len:#x}, offset={offset:#x}, load64({max:#x} - {i:#x} = {addr:#x}) \
+                 should trap, got {result:?}"
+            );
+        }
+    };
+
+    do_accesses(&mut store, "initial size");
+    let _ = memory.grow(&mut store, u64::from(growth));
+    do_accesses(&mut store, "after growing");
+}
+
+/// Build a Wasm module with a single memory in the shape of the given heap
+/// image, exports that memory, and also exports four functions:
+/// `load{8,16,32,64}`. Each of these functions takes an `i64` address,
+/// truncates it to `i32` if the memory is not 64-bit, and loads its associated
+/// number of bits from memory at `address + offset`.
+///
+/// ```wat
+/// (module
+///   (memory (export "memory") ...)
+///   (func (export "load8") (param i64) (result i32)
+///     (i32.load8_u offset=${offset} (local.get 0))
+///   )
+///   ...
+/// )
+/// ```
+fn build_wasm(image: &HeapImage, offset: u32) -> Vec<u8> {
+    let mut module = wasm_encoder::Module::new();
+
+    {
+        let mut types = wasm_encoder::TypeSection::new();
+        types.function([wasm_encoder::ValType::I64], [wasm_encoder::ValType::I32]);
+        types.function([wasm_encoder::ValType::I64], [wasm_encoder::ValType::I64]);
+        module.section(&types);
+    }
+
+    {
+        let mut funcs = wasm_encoder::FunctionSection::new();
+        funcs.function(0);
+        funcs.function(0);
+        funcs.function(0);
+        funcs.function(1);
+        module.section(&funcs);
+    }
+
+    {
+        let mut memories = wasm_encoder::MemorySection::new();
+        memories.memory(wasm_encoder::MemoryType {
+            minimum: u64::from(image.minimum),
+            maximum: image.maximum.map(Into::into),
+            memory64: image.memory64,
+            shared: false,
+            page_size_log2: image.page_size_log2,
+        });
+        module.section(&memories);
+    }
+
+    {
+        let mut exports = wasm_encoder::ExportSection::new();
+        exports.export("memory", wasm_encoder::ExportKind::Memory, 0);
+        exports.export("load8", wasm_encoder::ExportKind::Func, 0);
+        exports.export("load16", wasm_encoder::ExportKind::Func, 1);
+        exports.export("load32", wasm_encoder::ExportKind::Func, 2);
+        exports.export("load64", wasm_encoder::ExportKind::Func, 3);
+        module.section(&exports);
+    }
+
+    {
+        let mut code = wasm_encoder::CodeSection::new();
+        {
+            let mut func = wasm_encoder::Function::new([]);
+            func.instruction(&wasm_encoder::Instruction::LocalGet(0));
+            if !image.memory64 {
+                func.instruction(&wasm_encoder::Instruction::I32WrapI64);
+            }
+            func.instruction(&wasm_encoder::Instruction::I32Load8U(
+                wasm_encoder::MemArg {
+                    offset: u64::from(offset),
+                    align: 0,
+                    memory_index: 0,
+                },
+            ));
+            func.instruction(&wasm_encoder::Instruction::End);
+            code.function(&func);
+        }
+        {
+            let mut func = wasm_encoder::Function::new([]);
+            func.instruction(&wasm_encoder::Instruction::LocalGet(0));
+            if !image.memory64 {
+                func.instruction(&wasm_encoder::Instruction::I32WrapI64);
+            }
+            func.instruction(&wasm_encoder::Instruction::I32Load16U(
+                wasm_encoder::MemArg {
+                    offset: u64::from(offset),
+                    align: 0,
+                    memory_index: 0,
+                },
+            ));
+            func.instruction(&wasm_encoder::Instruction::End);
+            code.function(&func);
+        }
+        {
+            let mut func = wasm_encoder::Function::new([]);
+            func.instruction(&wasm_encoder::Instruction::LocalGet(0));
+            if !image.memory64 {
+                func.instruction(&wasm_encoder::Instruction::I32WrapI64);
+            }
+            func.instruction(&wasm_encoder::Instruction::I32Load(wasm_encoder::MemArg {
+                offset: u64::from(offset),
+                align: 0,
+                memory_index: 0,
+            }));
+            func.instruction(&wasm_encoder::Instruction::End);
+            code.function(&func);
+        }
+        {
+            let mut func = wasm_encoder::Function::new([]);
+            func.instruction(&wasm_encoder::Instruction::LocalGet(0));
+            if !image.memory64 {
+                func.instruction(&wasm_encoder::Instruction::I32WrapI64);
+            }
+            func.instruction(&wasm_encoder::Instruction::I64Load(wasm_encoder::MemArg {
+                offset: u64::from(offset),
+                align: 0,
+                memory_index: 0,
+            }));
+            func.instruction(&wasm_encoder::Instruction::End);
+            code.function(&func);
+        }
+        module.section(&code);
+    }
+
+    {
+        let mut datas = wasm_encoder::DataSection::new();
+        for (offset, data) in image.segments.iter() {
+            datas.segment(wasm_encoder::DataSegment {
+                mode: wasm_encoder::DataSegmentMode::Active {
+                    memory_index: 0,
+                    offset: &if image.memory64 {
+                        wasm_encoder::ConstExpr::i64_const(*offset as i64)
+                    } else {
+                        wasm_encoder::ConstExpr::i32_const(*offset as i32)
+                    },
+                },
+                data: data.iter().copied(),
+            });
+        }
+        module.section(&datas);
+    }
+
+    module.finish()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use arbitrary::{Arbitrary, Unstructured};
+    use rand::prelude::*;
+
+    #[test]
+    fn smoke_test_memory_access() {
+        let mut rng = SmallRng::seed_from_u64(0);
+        let mut buf = vec![0; 1024];
+
+        for _ in 0..1024 {
+            rng.fill_bytes(&mut buf);
+            let u = Unstructured::new(&buf);
+            if let Ok(input) = MemoryAccesses::arbitrary_take_rest(u) {
+                check_memory_accesses(input);
+            }
+        }
+    }
+}
diff --git a/crates/fuzzing/src/oracles/stacks.rs b/crates/fuzzing/src/oracles/stacks.rs
index 8705b5887d81..d3ce4ca9892f 100644
--- a/crates/fuzzing/src/oracles/stacks.rs
+++ b/crates/fuzzing/src/oracles/stacks.rs
@@ -1,5 +1,5 @@
 use crate::generators::Stacks;
-use anyhow::{bail, Result};
+use anyhow::bail;
 use wasmtime::*;
 
 /// Run the given `Stacks` test case and assert that the host's view of the Wasm
diff --git a/crates/fuzzing/src/single_module_fuzzer.rs b/crates/fuzzing/src/single_module_fuzzer.rs
index 6e2ef0738fde..3a0f3cb13036 100644
--- a/crates/fuzzing/src/single_module_fuzzer.rs
+++ b/crates/fuzzing/src/single_module_fuzzer.rs
@@ -95,8 +95,8 @@ macro_rules! single_module_fuzzer {
 /// module.
 pub fn execute<'a, T, U>(
     input: &'a [u8],
-    run: fn(&[u8], bool, T, &mut Unstructured<'a>) -> Result<U>,
-    gen_module: fn(&mut T, &mut Unstructured<'a>) -> Result<Vec<u8>>,
+    run: fn(&[u8], KnownValid, T, &mut Unstructured<'a>) -> Result<U>,
+    gen_module: fn(&mut T, &mut Unstructured<'a>) -> Result<(Vec<u8>, KnownValid)>,
 ) -> Result<U>
 where
     T: Arbitrary<'a>,
@@ -113,12 +113,29 @@ where
     };
     let mut u = Unstructured::new(fuzz_data);
     let mut config = u.arbitrary()?;
-    let generated = gen_module(&mut config, &mut u)?;
+    let (generated, known_valid) = gen_module(&mut config, &mut u)?;
     let module = module_in_input.unwrap_or(&generated);
     if let Ok(file) = std::env::var("WRITE_FUZZ_INPUT_TO") {
         std::fs::write(file, encode_module(&module, &fuzz_data)).unwrap();
     }
-    run(module, module_in_input.is_none(), config, &mut u)
+    let known_valid = if module_in_input.is_some() {
+        KnownValid::No
+    } else {
+        known_valid
+    };
+    run(module, known_valid, config, &mut u)
+}
+
+/// Used as part of `execute` above to determine whether a module is known to
+/// be valid ahead of time.
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+pub enum KnownValid {
+    /// This module is known to be valid so it should assert compilation
+    /// succeeds for example.
+    Yes,
+    /// This module is not known to be valid and it may not compile
+    /// successfully. Note that it's also not known to compile unsuccessfully.
+    No,
 }
 
 const SECTION_NAME: &str = "wasmtime-fuzz-input";
@@ -133,7 +150,7 @@ pub fn mutate<T>(
     data: &mut [u8],
     mut size: usize,
     max_size: usize,
-    gen_module: fn(&mut T, &mut Unstructured<'_>) -> Result<Vec<u8>>,
+    gen_module: fn(&mut T, &mut Unstructured<'_>) -> Result<(Vec<u8>, KnownValid)>,
     mutate: fn(&mut [u8], usize, usize) -> usize,
 ) -> usize
 where
@@ -170,7 +187,7 @@ where
         .arbitrary()
         .and_then(|mut config| gen_module(&mut config, &mut u))
     {
-        Ok(module) => {
+        Ok((module, _known_valid)) => {
             let module = encode_module(&module, &data[..new_size]);
 
             if module.len() < max_size {
@@ -295,10 +312,10 @@ mod tests {
             let run2 = run_config::<(u32, u32)>;
 
             if let Ok((module, known_valid)) = execute(&buf[..seed_size], run1, gen) {
-                assert!(known_valid);
+                assert_eq!(known_valid, KnownValid::Yes);
                 let new_size = mutate(&mut buf, seed_size, max_size, gen, noop_mutate);
                 if let Ok((module2, known_valid)) = execute(&buf[..new_size], run2, gen) {
-                    assert!(!known_valid);
+                    assert_eq!(known_valid, KnownValid::No);
                     compares += 1;
                     if module != module2 {
                         panic!("modules differ");
@@ -313,21 +330,24 @@ mod tests {
 
         fn run_config<T>(
             data: &[u8],
-            known_valid: bool,
+            known_valid: KnownValid,
             _: T,
             _: &mut Unstructured<'_>,
-        ) -> Result<(Vec<u8>, bool)>
+        ) -> Result<(Vec<u8>, KnownValid)>
         where
             T: for<'a> Arbitrary<'a>,
         {
             Ok((data.to_vec(), known_valid))
         }
 
-        fn gen<T>(_: &mut T, u: &mut Unstructured<'_>) -> Result<Vec<u8>>
+        fn gen<T>(_: &mut T, u: &mut Unstructured<'_>) -> Result<(Vec<u8>, KnownValid)>
         where
             T: for<'a> Arbitrary<'a>,
         {
-            Ok(u.arbitrary::<wasm_smith::Module>()?.to_bytes())
+            Ok((
+                u.arbitrary::<wasm_smith::Module>()?.to_bytes(),
+                KnownValid::Yes,
+            ))
         }
 
         fn noop_mutate(_buf: &mut [u8], size: usize, _new_size: usize) -> usize {
diff --git a/crates/fuzzing/wasm-spec-interpreter/Cargo.toml b/crates/fuzzing/wasm-spec-interpreter/Cargo.toml
index 3ec8efdaccac..d33bc619d10b 100644
--- a/crates/fuzzing/wasm-spec-interpreter/Cargo.toml
+++ b/crates/fuzzing/wasm-spec-interpreter/Cargo.toml
@@ -5,8 +5,12 @@ name = "wasm-spec-interpreter"
 version = "0.0.0"
 publish = false
 edition.workspace = true
+rust-version.workspace = true
 license = "Apache-2.0 WITH LLVM-exception"
 
+[lints]
+workspace = true
+
 # Until https://gitlab.com/ocaml-rust/ocaml-boxroot/-/issues/1 is resolved and
 # this crate can use the `without-ocamlopt` feature to avoid build failures, it
 # is better to only build the OCaml dependencies when fuzzing (see the
diff --git a/crates/fuzzing/wasm-spec-interpreter/build.rs b/crates/fuzzing/wasm-spec-interpreter/build.rs
index 29aac49c6097..ecae47fad2d5 100644
--- a/crates/fuzzing/wasm-spec-interpreter/build.rs
+++ b/crates/fuzzing/wasm-spec-interpreter/build.rs
@@ -15,6 +15,8 @@ const SPEC_REPOSITORY_BRANCH: &'static str = "wasmtime_fuzzing";
 const SPEC_REPOSITORY_REV: &'static str = "c6bab4461e10229e557aae2e1027cadfce0161ce";
 
 fn main() {
+    println!("cargo:rustc-check-cfg=cfg(feature, values(\"has-libinterpret\"))");
+    println!("cargo:rustc-check-cfg=cfg(fuzzing)");
     if cfg!(feature = "build-libinterpret") {
         build();
     }
@@ -24,13 +26,13 @@ fn build() {
     let out_dir = &env::var("OUT_DIR").unwrap();
 
     // Re-run if changed.
-    println!("cargo:rerun-if-changed={}/{}.ml", OCAML_DIR, LIB_NAME);
-    println!("cargo:rerun-if-changed={}/Makefile", OCAML_DIR);
+    println!("cargo:rerun-if-changed={OCAML_DIR}/{LIB_NAME}.ml");
+    println!("cargo:rerun-if-changed={OCAML_DIR}/Makefile");
 
     if let Some(other_dir) = env::var_os("FFI_LIB_DIR") {
         // Link with a library provided in the `FFI_LIB_DIR`.
         println!("cargo:rustc-link-search={}", other_dir.to_str().unwrap());
-        println!("cargo:rustc-link-lib=static={}", LIB_NAME);
+        println!("cargo:rustc-link-lib=static={LIB_NAME}");
     } else {
         // Ensure the spec repository is present.
         if is_spec_repository_empty(SPEC_DIR) {
@@ -39,8 +41,8 @@ fn build() {
 
         // Build the library to link to.
         build_lib(out_dir, OCAML_DIR);
-        println!("cargo:rustc-link-search={}", out_dir);
-        println!("cargo:rustc-link-lib=static={}", LIB_NAME);
+        println!("cargo:rustc-link-search={out_dir}");
+        println!("cargo:rustc-link-lib=static={LIB_NAME}");
     }
 
     // Enabling this feature alerts the compiler to use the `with_library`
@@ -51,7 +53,7 @@ fn build() {
 // Build the OCaml library into Cargo's `out` directory.
 fn build_lib(out_dir: &str, ocaml_dir: &str) {
     let status = Command::new("make")
-        .arg(format!("BUILD_DIR={}", out_dir))
+        .arg(format!("BUILD_DIR={out_dir}"))
         .current_dir(ocaml_dir)
         .status()
         .expect("Failed to execute 'make' command to build OCaml library");
diff --git a/crates/jit-debug/Cargo.toml b/crates/jit-debug/Cargo.toml
index 85c6b6840db3..c073df7088b5 100644
--- a/crates/jit-debug/Cargo.toml
+++ b/crates/jit-debug/Cargo.toml
@@ -9,6 +9,10 @@ keywords = ["gdb", "jit"]
 repository = "https://github.com/bytecodealliance/wasmtime"
 readme = "README.md"
 edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
 
 [dependencies]
 once_cell = { workspace = true, optional = true }
diff --git a/crates/jit-debug/src/gdb_jit_int.rs b/crates/jit-debug/src/gdb_jit_int.rs
index 87ecd7ee4dac..be343690c40b 100644
--- a/crates/jit-debug/src/gdb_jit_int.rs
+++ b/crates/jit-debug/src/gdb_jit_int.rs
@@ -42,7 +42,7 @@ extern "C" {
 /// access to the __jit_debug_descriptor within this process.
 static GDB_REGISTRATION: Lazy<Mutex<()>> = Lazy::new(|| Mutex::new(Default::default()));
 
-/// Registeration for JIT image
+/// Registration for JIT image
 pub struct GdbJitImageRegistration {
     entry: Pin<Box<JITCodeEntry>>,
     file: Pin<Box<[u8]>>,
diff --git a/crates/jit-debug/src/perf_jitdump.rs b/crates/jit-debug/src/perf_jitdump.rs
index b5f3666dd525..4592318c0bc8 100644
--- a/crates/jit-debug/src/perf_jitdump.rs
+++ b/crates/jit-debug/src/perf_jitdump.rs
@@ -84,7 +84,7 @@ pub struct DebugEntry {
 }
 
 /// Describes debug information for a jitted function. An array of debug entries are
-/// appended to this record during writting. Note, this record must preceed the code
+/// appended to this record during writing. Note, this record must precede the code
 /// load record that describes the same jitted function.
 #[derive(Debug, Default, Clone, Copy)]
 #[repr(C)]
@@ -139,7 +139,7 @@ pub struct JitDumpFile {
 }
 
 impl JitDumpFile {
-    /// Intialize a JitDumpAgent and write out the header
+    /// Initialize a JitDumpAgent and write out the header
     pub fn new(filename: impl AsRef<Path>, e_machine: u32) -> io::Result<Self> {
         let jitdump_file = OpenOptions::new()
             .read(true)
@@ -252,8 +252,7 @@ impl JitDumpFile {
     pub fn dump_code_load_record(
         &mut self,
         method_name: &str,
-        addr: *const u8,
-        len: usize,
+        code: &[u8],
         timestamp: u64,
         pid: u32,
         tid: u32,
@@ -263,7 +262,7 @@ impl JitDumpFile {
 
         let rh = RecordHeader {
             id: RecordId::JitCodeLoad as u32,
-            record_size: size_limit as u32 + name_len as u32 + len as u32,
+            record_size: size_limit as u32 + name_len as u32 + code.len() as u32,
             timestamp,
         };
 
@@ -271,16 +270,13 @@ impl JitDumpFile {
             header: rh,
             pid,
             tid,
-            virtual_address: addr as u64,
-            address: addr as u64,
-            size: len as u64,
+            virtual_address: code.as_ptr() as u64,
+            address: code.as_ptr() as u64,
+            size: code.len() as u64,
             index: self.next_code_index(),
         };
 
-        unsafe {
-            let code_buffer: &[u8] = std::slice::from_raw_parts(addr, len);
-            self.write_code_load_record(method_name, clr, code_buffer)
-        }
+        self.write_code_load_record(method_name, clr, code)
     }
 }
 
diff --git a/crates/jit-icache-coherence/Cargo.toml b/crates/jit-icache-coherence/Cargo.toml
index 8500c7924a77..5612c2af516d 100644
--- a/crates/jit-icache-coherence/Cargo.toml
+++ b/crates/jit-icache-coherence/Cargo.toml
@@ -7,9 +7,14 @@ documentation = "https://docs.rs/jit-icache-coherence"
 license = "Apache-2.0 WITH LLVM-exception"
 repository = "https://github.com/bytecodealliance/wasmtime"
 edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
 
 [dependencies]
 cfg-if = { workspace = true }
+anyhow = { workspace = true }
 
 [target.'cfg(target_os = "windows")'.dependencies.windows-sys]
 workspace = true
@@ -20,7 +25,7 @@ features = [
 ]
 
 [target.'cfg(any(target_os = "linux", target_os = "macos", target_os = "freebsd", target_os = "android"))'.dependencies]
-libc = "0.2.42"
+libc = { workspace = true }
 
 [features]
 # Most modern CPUs are SMP (multicore). However, when only one core is present,
diff --git a/crates/jit-icache-coherence/src/lib.rs b/crates/jit-icache-coherence/src/lib.rs
index 8964372b729e..fc9a20d3a9a8 100644
--- a/crates/jit-icache-coherence/src/lib.rs
+++ b/crates/jit-icache-coherence/src/lib.rs
@@ -34,7 +34,7 @@
 //! #   len: usize,
 //! # }
 //! #
-//! # fn main() -> io::Result<()> {
+//! # fn main() -> anyhow::Result<()> {
 //! #
 //! # let run_code = || {};
 //! # let code = vec![0u8; 64];
@@ -67,8 +67,9 @@
 //!
 //! [ARM Community - Caches and Self-Modifying Code]: https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/caches-and-self-modifying-code
 
-use std::ffi::c_void;
-use std::io::Result;
+#![no_std]
+
+use core::ffi::c_void;
 
 cfg_if::cfg_if! {
     if #[cfg(target_os = "windows")] {
@@ -91,7 +92,7 @@ cfg_if::cfg_if! {
 /// after all calls to [clear_cache].
 ///
 /// If the architecture does not require a pipeline flush, this function does nothing.
-pub fn pipeline_flush_mt() -> Result<()> {
+pub fn pipeline_flush_mt() -> imp::Result<()> {
     imp::pipeline_flush_mt()
 }
 
@@ -103,6 +104,6 @@ pub fn pipeline_flush_mt() -> Result<()> {
 ///
 /// It is necessary to call [pipeline_flush_mt] after this function if you are running in a multi-threaded
 /// environment.
-pub unsafe fn clear_cache(ptr: *const c_void, len: usize) -> Result<()> {
+pub unsafe fn clear_cache(ptr: *const c_void, len: usize) -> imp::Result<()> {
     imp::clear_cache(ptr, len)
 }
diff --git a/crates/jit-icache-coherence/src/libc.rs b/crates/jit-icache-coherence/src/libc.rs
index 364658bd1813..9e90f1b587c3 100644
--- a/crates/jit-icache-coherence/src/libc.rs
+++ b/crates/jit-icache-coherence/src/libc.rs
@@ -1,11 +1,20 @@
-use std::ffi::c_void;
-use std::io::Result;
+use core::ffi::c_void;
+
+#[cfg(any(target_os = "linux", target_os = "android"))]
+extern crate std;
+#[cfg(any(target_os = "linux", target_os = "android"))]
+pub use std::io::Result;
+
+#[cfg(not(any(target_os = "linux", target_os = "android")))]
+pub use anyhow::Result;
 
 #[cfg(all(
     target_arch = "aarch64",
     any(target_os = "linux", target_os = "android")
 ))]
 mod details {
+    extern crate std;
+
     use super::*;
     use libc::{syscall, EINVAL, EPERM};
     use std::io::Error;
@@ -87,20 +96,26 @@ mod details {
     any(target_os = "linux", target_os = "android")
 )))]
 mod details {
-    pub(crate) fn pipeline_flush_mt() -> std::io::Result<()> {
+    // NB: this uses `anyhow::Result` instead of `std::io::Result` to compile on
+    // `no_std`.
+    pub(crate) fn pipeline_flush_mt() -> super::Result<()> {
         Ok(())
     }
 }
+
 #[cfg(all(target_arch = "riscv64", target_os = "linux"))]
 fn riscv_flush_icache(start: u64, end: u64) -> Result<()> {
     cfg_if::cfg_if! {
         if #[cfg(feature = "one-core")] {
-            use std::arch::asm;
+            use core::arch::asm;
+            let _ = (start, end);
             unsafe {
                 asm!("fence.i");
             };
             Ok(())
         } else {
+            extern crate std;
+
             match unsafe {
                 libc::syscall(
                     {
diff --git a/crates/jit-icache-coherence/src/miri.rs b/crates/jit-icache-coherence/src/miri.rs
index 1ff641046a87..a29e244ab37f 100644
--- a/crates/jit-icache-coherence/src/miri.rs
+++ b/crates/jit-icache-coherence/src/miri.rs
@@ -1,5 +1,5 @@
-use std::ffi::c_void;
-use std::io::Result;
+pub use anyhow::Result;
+use core::ffi::c_void;
 
 pub(crate) fn pipeline_flush_mt() -> Result<()> {
     Ok(())
diff --git a/crates/jit-icache-coherence/src/win.rs b/crates/jit-icache-coherence/src/win.rs
index 488e15f46670..83e0ff6679cc 100644
--- a/crates/jit-icache-coherence/src/win.rs
+++ b/crates/jit-icache-coherence/src/win.rs
@@ -1,9 +1,13 @@
+extern crate std;
+
 use std::ffi::c_void;
-use std::io::{Error, Result};
+use std::io::Error;
 use windows_sys::Win32::System::Diagnostics::Debug::FlushInstructionCache;
 use windows_sys::Win32::System::Threading::FlushProcessWriteBuffers;
 use windows_sys::Win32::System::Threading::GetCurrentProcess;
 
+pub use std::io::Result;
+
 /// See docs on [crate::pipeline_flush_mt] for a description of what this function is trying to do.
 #[inline]
 pub(crate) fn pipeline_flush_mt() -> Result<()> {
diff --git a/crates/jit/Cargo.toml b/crates/jit/Cargo.toml
deleted file mode 100644
index 56d8eb223e27..000000000000
--- a/crates/jit/Cargo.toml
+++ /dev/null
@@ -1,45 +0,0 @@
-[package]
-name = "wasmtime-jit"
-version.workspace = true
-authors.workspace = true
-description = "JIT-style execution for WebAsssembly code in Cranelift"
-documentation = "https://docs.rs/wasmtime-jit"
-license = "Apache-2.0 WITH LLVM-exception"
-categories = ["wasm"]
-keywords = ["webassembly", "wasm"]
-repository = "https://github.com/bytecodealliance/wasmtime"
-edition.workspace = true
-
-[dependencies]
-wasmtime-environ = { workspace = true }
-wasmtime-jit-debug = { workspace = true, features = [
-  "perf_jitdump",
-], optional = true }
-wasmtime-runtime = { workspace = true }
-target-lexicon = { workspace = true }
-anyhow = { workspace = true }
-cfg-if = { workspace = true }
-gimli = { workspace = true }
-object = { workspace = true }
-serde = "1.0.188"
-serde_derive = "1.0.188"
-addr2line = { version = "0.21.0", default-features = false }
-bincode = "1.2.1"
-rustc-demangle = "0.1.16"
-cpp_demangle = "0.3.2"
-log = { workspace = true }
-wasmtime-jit-icache-coherence = { workspace = true }
-
-[target.'cfg(target_os = "linux")'.dependencies]
-rustix = { workspace = true, features = ['thread'] }
-
-[target.'cfg(target_os = "windows")'.dependencies.windows-sys]
-workspace = true
-features = ["Win32_System_Diagnostics_Debug"]
-
-[target.'cfg(all(target_arch = "x86_64", not(target_os = "android")))'.dependencies]
-ittapi = { version = "0.3.4", optional = true }
-
-[features]
-jitdump = ['wasmtime-jit-debug']
-vtune = ['ittapi']
diff --git a/crates/jit/LICENSE b/crates/jit/LICENSE
deleted file mode 100644
index f9d81955f4bc..000000000000
--- a/crates/jit/LICENSE
+++ /dev/null
@@ -1,220 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-
-
---- LLVM Exceptions to the Apache 2.0 License ----
-
-As an exception, if, as a result of your compiling your source code, portions
-of this Software are embedded into an Object form of such source code, you
-may redistribute such embedded portions in such Object form without complying
-with the conditions of Sections 4(a), 4(b) and 4(d) of the License.
-
-In addition, if you combine or link compiled forms of this Software with
-software that is licensed under the GPLv2 ("Combined Software") and if a
-court of competent jurisdiction determines that the patent provision (Section
-3), the indemnity provision (Section 9) or other Section of the License
-conflicts with the conditions of the GPLv2, you may retroactively and
-prospectively choose to deem waived or otherwise exclude such Section(s) of
-the License, but only in their entirety and only with respect to the Combined
-Software.
-
diff --git a/crates/jit/src/debug.rs b/crates/jit/src/debug.rs
deleted file mode 100644
index 06a7ffa1ac2b..000000000000
--- a/crates/jit/src/debug.rs
+++ /dev/null
@@ -1,165 +0,0 @@
-use anyhow::{anyhow, bail, ensure, Error};
-use object::elf::*;
-use object::endian::{BigEndian, Endian, Endianness, LittleEndian};
-use object::read::elf::{FileHeader, SectionHeader};
-use object::{
-    File, NativeEndian as NE, Object, ObjectSection, ObjectSymbol, RelocationEncoding,
-    RelocationKind, RelocationTarget, U64Bytes,
-};
-use std::mem::size_of;
-
-pub fn create_gdbjit_image(
-    mut bytes: Vec<u8>,
-    code_region: (*const u8, usize),
-) -> Result<Vec<u8>, Error> {
-    let e = ensure_supported_elf_format(&bytes)?;
-
-    // patch relocs
-    relocate_dwarf_sections(&mut bytes, code_region)?;
-
-    // elf is still missing details...
-    match e {
-        Endianness::Little => {
-            convert_object_elf_to_loadable_file::<LittleEndian>(&mut bytes, code_region)
-        }
-        Endianness::Big => {
-            convert_object_elf_to_loadable_file::<BigEndian>(&mut bytes, code_region)
-        }
-    }
-
-    Ok(bytes)
-}
-
-fn relocate_dwarf_sections(bytes: &mut [u8], code_region: (*const u8, usize)) -> Result<(), Error> {
-    let mut relocations = Vec::new();
-    let obj = File::parse(&bytes[..])?;
-    for section in obj.sections() {
-        let section_start = match section.file_range() {
-            Some((start, _)) => start,
-            None => continue,
-        };
-        for (off, r) in section.relocations() {
-            if r.kind() != RelocationKind::Absolute
-                || r.encoding() != RelocationEncoding::Generic
-                || r.size() != 64
-            {
-                continue;
-            }
-
-            let sym = match r.target() {
-                RelocationTarget::Symbol(index) => match obj.symbol_by_index(index) {
-                    Ok(sym) => sym,
-                    Err(_) => continue,
-                },
-                _ => continue,
-            };
-            relocations.push((
-                section_start + off,
-                (code_region.0 as u64)
-                    .wrapping_add(sym.address())
-                    .wrapping_add(r.addend() as u64),
-            ));
-        }
-    }
-
-    for (offset, value) in relocations {
-        let (loc, _) = object::from_bytes_mut::<U64Bytes<NE>>(&mut bytes[offset as usize..])
-            .map_err(|()| anyhow!("invalid dwarf relocations"))?;
-        loc.set(NE, value);
-    }
-    Ok(())
-}
-
-fn ensure_supported_elf_format(bytes: &[u8]) -> Result<Endianness, Error> {
-    use object::elf::*;
-    use object::read::elf::*;
-
-    let kind = match object::FileKind::parse(bytes) {
-        Ok(file) => file,
-        Err(err) => {
-            bail!("Failed to parse file: {}", err);
-        }
-    };
-    let header = match kind {
-        object::FileKind::Elf64 => match object::elf::FileHeader64::<Endianness>::parse(bytes) {
-            Ok(header) => header,
-            Err(err) => {
-                bail!("Unsupported ELF file: {}", err);
-            }
-        },
-        _ => {
-            bail!("only 64-bit ELF files currently supported")
-        }
-    };
-    let e = header.endian().unwrap();
-
-    match header.e_machine.get(e) {
-        EM_AARCH64 => (),
-        EM_X86_64 => (),
-        EM_S390 => (),
-        EM_RISCV => (),
-        machine => {
-            bail!("Unsupported ELF target machine: {:x}", machine);
-        }
-    }
-    ensure!(
-        header.e_phoff.get(e) == 0 && header.e_phnum.get(e) == 0,
-        "program header table is empty"
-    );
-    let e_shentsize = header.e_shentsize.get(e);
-    let req_shentsize = match e {
-        Endianness::Little => size_of::<SectionHeader64<LittleEndian>>(),
-        Endianness::Big => size_of::<SectionHeader64<BigEndian>>(),
-    };
-    ensure!(e_shentsize as usize == req_shentsize, "size of sh");
-    Ok(e)
-}
-
-fn convert_object_elf_to_loadable_file<E: Endian>(
-    bytes: &mut Vec<u8>,
-    code_region: (*const u8, usize),
-) {
-    let e = E::default();
-
-    let header = FileHeader64::<E>::parse(&bytes[..]).unwrap();
-    let sections = header.sections(e, &bytes[..]).unwrap();
-    let text_range = match sections.section_by_name(e, b".text") {
-        Some((i, text)) => {
-            let range = text.file_range(e);
-            let off = header.e_shoff.get(e) as usize + i * header.e_shentsize.get(e) as usize;
-
-            let section: &mut SectionHeader64<E> =
-                object::from_bytes_mut(&mut bytes[off..]).unwrap().0;
-            // Patch vaddr, and save file location and its size.
-            section.sh_addr.set(e, code_region.0 as u64);
-            range
-        }
-        None => None,
-    };
-
-    // LLDB wants segment with virtual address set, placing them at the end of ELF.
-    let ph_off = bytes.len();
-    let e_phentsize = size_of::<ProgramHeader64<E>>();
-    let e_phnum = 1;
-    bytes.resize(ph_off + e_phentsize * e_phnum, 0);
-    if let Some((sh_offset, sh_size)) = text_range {
-        let (v_offset, size) = code_region;
-        let program: &mut ProgramHeader64<E> =
-            object::from_bytes_mut(&mut bytes[ph_off..]).unwrap().0;
-        program.p_type.set(e, PT_LOAD);
-        program.p_offset.set(e, sh_offset);
-        program.p_vaddr.set(e, v_offset as u64);
-        program.p_paddr.set(e, v_offset as u64);
-        program.p_filesz.set(e, sh_size);
-        program.p_memsz.set(e, size as u64);
-    } else {
-        unreachable!();
-    }
-
-    // It is somewhat loadable ELF file at this moment.
-    let header: &mut FileHeader64<E> = object::from_bytes_mut(bytes).unwrap().0;
-    header.e_type.set(e, ET_DYN);
-    header.e_phoff.set(e, ph_off as u64);
-    header.e_phentsize.set(e, e_phentsize as u16);
-    header.e_phnum.set(e, e_phnum as u16);
-}
diff --git a/crates/jit/src/demangling.rs b/crates/jit/src/demangling.rs
deleted file mode 100644
index 83b07d6f80c4..000000000000
--- a/crates/jit/src/demangling.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-//! Helpers for demangling function names.
-
-/// Demangles a single function name into a user-readable form.
-///
-/// Currently supported: Rust/C/C++ function names.
-pub fn demangle_function_name(writer: &mut impl std::fmt::Write, name: &str) -> std::fmt::Result {
-    if let Ok(demangled) = rustc_demangle::try_demangle(name) {
-        write!(writer, "{}", demangled)
-    } else if let Ok(demangled) = cpp_demangle::Symbol::new(name) {
-        write!(writer, "{}", demangled)
-    } else {
-        write!(writer, "{}", name)
-    }
-}
-
-/// Demangles a function name if it's provided, or returns a unified representation based on the
-/// function index otherwise.
-pub fn demangle_function_name_or_index(
-    writer: &mut impl std::fmt::Write,
-    name: Option<&str>,
-    func_id: usize,
-) -> std::fmt::Result {
-    match name {
-        Some(name) => demangle_function_name(writer, name),
-        None => write!(writer, "<wasm function {}>", func_id),
-    }
-}
diff --git a/crates/jit/src/instantiate.rs b/crates/jit/src/instantiate.rs
deleted file mode 100644
index d3a260deb563..000000000000
--- a/crates/jit/src/instantiate.rs
+++ /dev/null
@@ -1,762 +0,0 @@
-//! Define the `instantiate` function, which takes a byte array containing an
-//! encoded wasm module and returns a live wasm instance. Also, define
-//! `CompiledModule` to allow compiling and instantiating to be done as separate
-//! steps.
-
-use crate::code_memory::CodeMemory;
-use crate::debug::create_gdbjit_image;
-use crate::profiling::ProfilingAgent;
-use anyhow::{bail, Context, Error, Result};
-use object::write::{Object, SectionId, StandardSegment, WritableBuffer};
-use object::SectionKind;
-use serde_derive::{Deserialize, Serialize};
-use std::convert::TryFrom;
-use std::ops::Range;
-use std::str;
-use std::sync::Arc;
-use wasmtime_environ::obj;
-use wasmtime_environ::{
-    DefinedFuncIndex, FuncIndex, FunctionLoc, MemoryInitialization, Module, ModuleTranslation,
-    PrimaryMap, SignatureIndex, StackMapInformation, Tunables, WasmFunctionInfo,
-};
-use wasmtime_runtime::{
-    CompiledModuleId, CompiledModuleIdAllocator, GdbJitImageRegistration, MmapVec,
-};
-
-/// Secondary in-memory results of function compilation.
-#[derive(Serialize, Deserialize)]
-pub struct CompiledFunctionInfo {
-    wasm_func_info: WasmFunctionInfo,
-    wasm_func_loc: FunctionLoc,
-    array_to_wasm_trampoline: Option<FunctionLoc>,
-    native_to_wasm_trampoline: Option<FunctionLoc>,
-}
-
-impl CompiledFunctionInfo {
-    /// Create a new `CompiledFunctionInfo`.
-    pub fn new(
-        wasm_func_info: WasmFunctionInfo,
-        wasm_func_loc: FunctionLoc,
-        array_to_wasm_trampoline: Option<FunctionLoc>,
-        native_to_wasm_trampoline: Option<FunctionLoc>,
-    ) -> CompiledFunctionInfo {
-        CompiledFunctionInfo {
-            wasm_func_info,
-            wasm_func_loc,
-            array_to_wasm_trampoline,
-            native_to_wasm_trampoline,
-        }
-    }
-}
-
-/// Secondary in-memory results of module compilation.
-///
-/// This opaque structure can be optionally passed back to
-/// `CompiledModule::from_artifacts` to avoid decoding extra information there.
-#[derive(Serialize, Deserialize)]
-pub struct CompiledModuleInfo {
-    /// Type information about the compiled WebAssembly module.
-    pub module: Module,
-
-    /// Metadata about each compiled function.
-    funcs: PrimaryMap<DefinedFuncIndex, CompiledFunctionInfo>,
-
-    /// Sorted list, by function index, of names we have for this module.
-    func_names: Vec<FunctionName>,
-
-    /// Metadata about wasm-to-native trampolines. Used when exposing a native
-    /// callee (e.g. `Func::wrap`) to a Wasm caller. Sorted by signature index.
-    wasm_to_native_trampolines: Vec<(SignatureIndex, FunctionLoc)>,
-
-    /// General compilation metadata.
-    meta: Metadata,
-}
-
-#[derive(Serialize, Deserialize)]
-struct FunctionName {
-    idx: FuncIndex,
-    offset: u32,
-    len: u32,
-}
-
-#[derive(Serialize, Deserialize)]
-struct Metadata {
-    /// Whether or not native debug information is available in `obj`
-    native_debug_info_present: bool,
-
-    /// Whether or not the original wasm module contained debug information that
-    /// we skipped and did not parse.
-    has_unparsed_debuginfo: bool,
-
-    /// Offset in the original wasm file to the code section.
-    code_section_offset: u64,
-
-    /// Whether or not custom wasm-specific dwarf sections were inserted into
-    /// the ELF image.
-    ///
-    /// Note that even if this flag is `true` sections may be missing if they
-    /// weren't found in the original wasm module itself.
-    has_wasm_debuginfo: bool,
-
-    /// Dwarf sections and the offsets at which they're stored in the
-    /// ELF_WASMTIME_DWARF
-    dwarf: Vec<(u8, Range<u64>)>,
-}
-
-/// Helper structure to create an ELF file as a compilation artifact.
-///
-/// This structure exposes the process which Wasmtime will encode a core wasm
-/// module into an ELF file, notably managing data sections and all that good
-/// business going into the final file.
-pub struct ObjectBuilder<'a> {
-    /// The `object`-crate-defined ELF file write we're using.
-    obj: Object<'a>,
-
-    /// General compilation configuration.
-    tunables: &'a Tunables,
-
-    /// The section identifier for "rodata" which is where wasm data segments
-    /// will go.
-    data: SectionId,
-
-    /// The section identifier for function name information, or otherwise where
-    /// the `name` custom section of wasm is copied into.
-    ///
-    /// This is optional and lazily created on demand.
-    names: Option<SectionId>,
-
-    /// The section identifier for dwarf information copied from the original
-    /// wasm files.
-    ///
-    /// This is optional and lazily created on demand.
-    dwarf: Option<SectionId>,
-}
-
-impl<'a> ObjectBuilder<'a> {
-    /// Creates a new builder for the `obj` specified.
-    pub fn new(mut obj: Object<'a>, tunables: &'a Tunables) -> ObjectBuilder<'a> {
-        let data = obj.add_section(
-            obj.segment_name(StandardSegment::Data).to_vec(),
-            obj::ELF_WASM_DATA.as_bytes().to_vec(),
-            SectionKind::ReadOnlyData,
-        );
-        ObjectBuilder {
-            obj,
-            tunables,
-            data,
-            names: None,
-            dwarf: None,
-        }
-    }
-
-    /// Completes compilation of the `translation` specified, inserting
-    /// everything necessary into the `Object` being built.
-    ///
-    /// This function will consume the final results of compiling a wasm module
-    /// and finish the ELF image in-progress as part of `self.obj` by appending
-    /// any compiler-agnostic sections.
-    ///
-    /// The auxiliary `CompiledModuleInfo` structure returned here has also been
-    /// serialized into the object returned, but if the caller will quickly
-    /// turn-around and invoke `CompiledModule::from_artifacts` after this then
-    /// the information can be passed to that method to avoid extra
-    /// deserialization. This is done to avoid a serialize-then-deserialize for
-    /// API calls like `Module::new` where the compiled module is immediately
-    /// going to be used.
-    ///
-    /// The various arguments here are:
-    ///
-    /// * `translation` - the core wasm translation that's being completed.
-    ///
-    /// * `funcs` - compilation metadata about functions within the translation
-    ///   as well as where the functions are located in the text section.
-    ///
-    /// * `array_to_wasm_trampolines` - list of all trampolines necessary for
-    ///   array callers (e.g. `Func::new`) calling Wasm callees. One for each
-    ///   defined function that escapes. Must be sorted by `DefinedFuncIndex`.
-    ///
-    /// * `native_to_wasm_trampolines` - list of all trampolines necessary for
-    ///   native callers (e.g. `Func::wrap`) calling Wasm callees. One for each
-    ///   defined function that escapes. Must be sorted by `DefinedFuncIndex`.
-    ///
-    /// * `wasm_to_native_trampolines` - list of all trampolines necessary for
-    ///   Wasm callers calling native callees (e.g. `Func::wrap`). One for each
-    ///   function signature in the module. Must be sorted by `SignatureIndex`.
-    ///
-    /// Returns the `CompiledModuleInfo` corresponding to this core Wasm module
-    /// as a result of this append operation. This is then serialized into the
-    /// final artifact by the caller.
-    pub fn append(
-        &mut self,
-        translation: ModuleTranslation<'_>,
-        funcs: PrimaryMap<DefinedFuncIndex, CompiledFunctionInfo>,
-        wasm_to_native_trampolines: Vec<(SignatureIndex, FunctionLoc)>,
-    ) -> Result<CompiledModuleInfo> {
-        let ModuleTranslation {
-            mut module,
-            debuginfo,
-            has_unparsed_debuginfo,
-            data,
-            data_align,
-            passive_data,
-            ..
-        } = translation;
-
-        // Place all data from the wasm module into a section which will the
-        // source of the data later at runtime. This additionally keeps track of
-        // the offset of
-        let mut total_data_len = 0;
-        let data_offset = self
-            .obj
-            .append_section_data(self.data, &[], data_align.unwrap_or(1));
-        for (i, data) in data.iter().enumerate() {
-            // The first data segment has its alignment specified as the alignment
-            // for the entire section, but everything afterwards is adjacent so it
-            // has alignment of 1.
-            let align = if i == 0 { data_align.unwrap_or(1) } else { 1 };
-            self.obj.append_section_data(self.data, data, align);
-            total_data_len += data.len();
-        }
-        for data in passive_data.iter() {
-            self.obj.append_section_data(self.data, data, 1);
-        }
-
-        // If any names are present in the module then the `ELF_NAME_DATA` section
-        // is create and appended.
-        let mut func_names = Vec::new();
-        if debuginfo.name_section.func_names.len() > 0 {
-            let name_id = *self.names.get_or_insert_with(|| {
-                self.obj.add_section(
-                    self.obj.segment_name(StandardSegment::Data).to_vec(),
-                    obj::ELF_NAME_DATA.as_bytes().to_vec(),
-                    SectionKind::ReadOnlyData,
-                )
-            });
-            let mut sorted_names = debuginfo.name_section.func_names.iter().collect::<Vec<_>>();
-            sorted_names.sort_by_key(|(idx, _name)| *idx);
-            for (idx, name) in sorted_names {
-                let offset = self.obj.append_section_data(name_id, name.as_bytes(), 1);
-                let offset = match u32::try_from(offset) {
-                    Ok(offset) => offset,
-                    Err(_) => bail!("name section too large (> 4gb)"),
-                };
-                let len = u32::try_from(name.len()).unwrap();
-                func_names.push(FunctionName {
-                    idx: *idx,
-                    offset,
-                    len,
-                });
-            }
-        }
-
-        // Data offsets in `MemoryInitialization` are offsets within the
-        // `translation.data` list concatenated which is now present in the data
-        // segment that's appended to the object. Increase the offsets by
-        // `self.data_size` to account for any previously added module.
-        let data_offset = u32::try_from(data_offset).unwrap();
-        match &mut module.memory_initialization {
-            MemoryInitialization::Segmented(list) => {
-                for segment in list {
-                    segment.data.start = segment.data.start.checked_add(data_offset).unwrap();
-                    segment.data.end = segment.data.end.checked_add(data_offset).unwrap();
-                }
-            }
-            MemoryInitialization::Static { map } => {
-                for (_, segment) in map {
-                    if let Some(segment) = segment {
-                        segment.data.start = segment.data.start.checked_add(data_offset).unwrap();
-                        segment.data.end = segment.data.end.checked_add(data_offset).unwrap();
-                    }
-                }
-            }
-        }
-
-        // Data offsets for passive data are relative to the start of
-        // `translation.passive_data` which was appended to the data segment
-        // of this object, after active data in `translation.data`. Update the
-        // offsets to account prior modules added in addition to active data.
-        let data_offset = data_offset + u32::try_from(total_data_len).unwrap();
-        for (_, range) in module.passive_data_map.iter_mut() {
-            range.start = range.start.checked_add(data_offset).unwrap();
-            range.end = range.end.checked_add(data_offset).unwrap();
-        }
-
-        // Insert the wasm raw wasm-based debuginfo into the output, if
-        // requested. Note that this is distinct from the native debuginfo
-        // possibly generated by the native compiler, hence these sections
-        // getting wasm-specific names.
-        let mut dwarf = Vec::new();
-        if self.tunables.parse_wasm_debuginfo {
-            self.push_debug(&mut dwarf, &debuginfo.dwarf.debug_abbrev);
-            self.push_debug(&mut dwarf, &debuginfo.dwarf.debug_addr);
-            self.push_debug(&mut dwarf, &debuginfo.dwarf.debug_aranges);
-            self.push_debug(&mut dwarf, &debuginfo.dwarf.debug_info);
-            self.push_debug(&mut dwarf, &debuginfo.dwarf.debug_line);
-            self.push_debug(&mut dwarf, &debuginfo.dwarf.debug_line_str);
-            self.push_debug(&mut dwarf, &debuginfo.dwarf.debug_str);
-            self.push_debug(&mut dwarf, &debuginfo.dwarf.debug_str_offsets);
-            self.push_debug(&mut dwarf, &debuginfo.debug_ranges);
-            self.push_debug(&mut dwarf, &debuginfo.debug_rnglists);
-        }
-        // Sort this for binary-search-lookup later in `symbolize_context`.
-        dwarf.sort_by_key(|(id, _)| *id);
-
-        Ok(CompiledModuleInfo {
-            module,
-            funcs,
-            wasm_to_native_trampolines,
-            func_names,
-            meta: Metadata {
-                native_debug_info_present: self.tunables.generate_native_debuginfo,
-                has_unparsed_debuginfo,
-                code_section_offset: debuginfo.wasm_file.code_section_offset,
-                has_wasm_debuginfo: self.tunables.parse_wasm_debuginfo,
-                dwarf,
-            },
-        })
-    }
-
-    fn push_debug<'b, T>(&mut self, dwarf: &mut Vec<(u8, Range<u64>)>, section: &T)
-    where
-        T: gimli::Section<gimli::EndianSlice<'b, gimli::LittleEndian>>,
-    {
-        let data = section.reader().slice();
-        if data.is_empty() {
-            return;
-        }
-        let section_id = *self.dwarf.get_or_insert_with(|| {
-            self.obj.add_section(
-                self.obj.segment_name(StandardSegment::Debug).to_vec(),
-                obj::ELF_WASMTIME_DWARF.as_bytes().to_vec(),
-                SectionKind::Debug,
-            )
-        });
-        let offset = self.obj.append_section_data(section_id, data, 1);
-        dwarf.push((T::id() as u8, offset..offset + data.len() as u64));
-    }
-
-    /// Creates the `ELF_WASMTIME_INFO` section from the given serializable data
-    /// structure.
-    pub fn serialize_info<T>(&mut self, info: &T)
-    where
-        T: serde::Serialize,
-    {
-        let section = self.obj.add_section(
-            self.obj.segment_name(StandardSegment::Data).to_vec(),
-            obj::ELF_WASMTIME_INFO.as_bytes().to_vec(),
-            SectionKind::ReadOnlyData,
-        );
-        let data = bincode::serialize(info).unwrap();
-        self.obj.set_section_data(section, data, 1);
-    }
-
-    /// Creates a new `MmapVec` from `self.`
-    ///
-    /// The returned `MmapVec` will contain the serialized version of `self`
-    /// and is sized appropriately to the exact size of the object serialized.
-    pub fn finish(self) -> Result<MmapVec> {
-        let mut result = ObjectMmap::default();
-        return match self.obj.emit(&mut result) {
-            Ok(()) => {
-                assert!(result.mmap.is_some(), "no reserve");
-                let mmap = result.mmap.expect("reserve not called");
-                assert_eq!(mmap.len(), result.len);
-                Ok(mmap)
-            }
-            Err(e) => match result.err.take() {
-                Some(original) => Err(original.context(e)),
-                None => Err(e.into()),
-            },
-        };
-
-        /// Helper struct to implement the `WritableBuffer` trait from the `object`
-        /// crate.
-        ///
-        /// This enables writing an object directly into an mmap'd memory so it's
-        /// immediately usable for execution after compilation. This implementation
-        /// relies on a call to `reserve` happening once up front with all the needed
-        /// data, and the mmap internally does not attempt to grow afterwards.
-        #[derive(Default)]
-        struct ObjectMmap {
-            mmap: Option<MmapVec>,
-            len: usize,
-            err: Option<Error>,
-        }
-
-        impl WritableBuffer for ObjectMmap {
-            fn len(&self) -> usize {
-                self.len
-            }
-
-            fn reserve(&mut self, additional: usize) -> Result<(), ()> {
-                assert!(self.mmap.is_none(), "cannot reserve twice");
-                self.mmap = match MmapVec::with_capacity(additional) {
-                    Ok(mmap) => Some(mmap),
-                    Err(e) => {
-                        self.err = Some(e);
-                        return Err(());
-                    }
-                };
-                Ok(())
-            }
-
-            fn resize(&mut self, new_len: usize) {
-                // Resizing always appends 0 bytes and since new mmaps start out as 0
-                // bytes we don't actually need to do anything as part of this other
-                // than update our own length.
-                if new_len <= self.len {
-                    return;
-                }
-                self.len = new_len;
-            }
-
-            fn write_bytes(&mut self, val: &[u8]) {
-                let mmap = self.mmap.as_mut().expect("write before reserve");
-                mmap[self.len..][..val.len()].copy_from_slice(val);
-                self.len += val.len();
-            }
-        }
-    }
-}
-
-/// A compiled wasm module, ready to be instantiated.
-pub struct CompiledModule {
-    module: Arc<Module>,
-    funcs: PrimaryMap<DefinedFuncIndex, CompiledFunctionInfo>,
-    wasm_to_native_trampolines: Vec<(SignatureIndex, FunctionLoc)>,
-    meta: Metadata,
-    code_memory: Arc<CodeMemory>,
-    dbg_jit_registration: Option<GdbJitImageRegistration>,
-    /// A unique ID used to register this module with the engine.
-    unique_id: CompiledModuleId,
-    func_names: Vec<FunctionName>,
-}
-
-impl CompiledModule {
-    /// Creates `CompiledModule` directly from a precompiled artifact.
-    ///
-    /// The `code_memory` argument is expected to be the result of a previous
-    /// call to `ObjectBuilder::finish` above. This is an ELF image, at this
-    /// time, which contains all necessary information to create a
-    /// `CompiledModule` from a compilation.
-    ///
-    /// This method also takes `info`, an optionally-provided deserialization
-    /// of the artifacts' compilation metadata section. If this information is
-    /// not provided then the information will be
-    /// deserialized from the image of the compilation artifacts. Otherwise it
-    /// will be assumed to be what would otherwise happen if the section were
-    /// to be deserialized.
-    ///
-    /// The `profiler` argument here is used to inform JIT profiling runtimes
-    /// about new code that is loaded.
-    pub fn from_artifacts(
-        code_memory: Arc<CodeMemory>,
-        info: CompiledModuleInfo,
-        profiler: &dyn ProfilingAgent,
-        id_allocator: &CompiledModuleIdAllocator,
-    ) -> Result<Self> {
-        let mut ret = Self {
-            module: Arc::new(info.module),
-            funcs: info.funcs,
-            wasm_to_native_trampolines: info.wasm_to_native_trampolines,
-            dbg_jit_registration: None,
-            code_memory,
-            meta: info.meta,
-            unique_id: id_allocator.alloc(),
-            func_names: info.func_names,
-        };
-        ret.register_debug_and_profiling(profiler)?;
-
-        Ok(ret)
-    }
-
-    fn register_debug_and_profiling(&mut self, profiler: &dyn ProfilingAgent) -> Result<()> {
-        if self.meta.native_debug_info_present {
-            let text = self.text();
-            let bytes = create_gdbjit_image(self.mmap().to_vec(), (text.as_ptr(), text.len()))
-                .context("failed to create jit image for gdb")?;
-            let reg = GdbJitImageRegistration::register(bytes);
-            self.dbg_jit_registration = Some(reg);
-        }
-        profiler.register_module(&self.code_memory, &|addr| {
-            let (idx, _) = self.func_by_text_offset(addr)?;
-            let idx = self.module.func_index(idx);
-            let name = self.func_name(idx)?;
-            let mut demangled = String::new();
-            crate::demangling::demangle_function_name(&mut demangled, name).unwrap();
-            Some(demangled)
-        });
-        Ok(())
-    }
-
-    /// Get this module's unique ID. It is unique with respect to a
-    /// single allocator (which is ordinarily held on a Wasm engine).
-    pub fn unique_id(&self) -> CompiledModuleId {
-        self.unique_id
-    }
-
-    /// Returns the underlying memory which contains the compiled module's
-    /// image.
-    pub fn mmap(&self) -> &MmapVec {
-        self.code_memory.mmap()
-    }
-
-    /// Returns the underlying owned mmap of this compiled image.
-    pub fn code_memory(&self) -> &Arc<CodeMemory> {
-        &self.code_memory
-    }
-
-    /// Returns the text section of the ELF image for this compiled module.
-    ///
-    /// This memory should have the read/execute permissions.
-    #[inline]
-    pub fn text(&self) -> &[u8] {
-        self.code_memory.text()
-    }
-
-    /// Return a reference-counting pointer to a module.
-    pub fn module(&self) -> &Arc<Module> {
-        &self.module
-    }
-
-    /// Looks up the `name` section name for the function index `idx`, if one
-    /// was specified in the original wasm module.
-    pub fn func_name(&self, idx: FuncIndex) -> Option<&str> {
-        // Find entry for `idx`, if present.
-        let i = self.func_names.binary_search_by_key(&idx, |n| n.idx).ok()?;
-        let name = &self.func_names[i];
-
-        // Here we `unwrap` the `from_utf8` but this can theoretically be a
-        // `from_utf8_unchecked` if we really wanted since this section is
-        // guaranteed to only have valid utf-8 data. Until it's a problem it's
-        // probably best to double-check this though.
-        let data = self.code_memory().func_name_data();
-        Some(str::from_utf8(&data[name.offset as usize..][..name.len as usize]).unwrap())
-    }
-
-    /// Return a reference to a mutable module (if possible).
-    pub fn module_mut(&mut self) -> Option<&mut Module> {
-        Arc::get_mut(&mut self.module)
-    }
-
-    /// Returns an iterator over all functions defined within this module with
-    /// their index and their body in memory.
-    #[inline]
-    pub fn finished_functions(
-        &self,
-    ) -> impl ExactSizeIterator<Item = (DefinedFuncIndex, &[u8])> + '_ {
-        self.funcs
-            .iter()
-            .map(move |(i, _)| (i, self.finished_function(i)))
-    }
-
-    /// Returns the body of the function that `index` points to.
-    #[inline]
-    pub fn finished_function(&self, index: DefinedFuncIndex) -> &[u8] {
-        let loc = self.funcs[index].wasm_func_loc;
-        &self.text()[loc.start as usize..][..loc.length as usize]
-    }
-
-    /// Get the array-to-Wasm trampoline for the function `index` points to.
-    ///
-    /// If the function `index` points to does not escape, then `None` is
-    /// returned.
-    ///
-    /// These trampolines are used for array callers (e.g. `Func::new`)
-    /// calling Wasm callees.
-    pub fn array_to_wasm_trampoline(&self, index: DefinedFuncIndex) -> Option<&[u8]> {
-        let loc = self.funcs[index].array_to_wasm_trampoline?;
-        Some(&self.text()[loc.start as usize..][..loc.length as usize])
-    }
-
-    /// Get the native-to-Wasm trampoline for the function `index` points to.
-    ///
-    /// If the function `index` points to does not escape, then `None` is
-    /// returned.
-    ///
-    /// These trampolines are used for native callers (e.g. `Func::wrap`)
-    /// calling Wasm callees.
-    #[inline]
-    pub fn native_to_wasm_trampoline(&self, index: DefinedFuncIndex) -> Option<&[u8]> {
-        let loc = self.funcs[index].native_to_wasm_trampoline?;
-        Some(&self.text()[loc.start as usize..][..loc.length as usize])
-    }
-
-    /// Get the Wasm-to-native trampoline for the given signature.
-    ///
-    /// These trampolines are used for filling in
-    /// `VMFuncRef::wasm_call` for `Func::wrap`-style host funcrefs
-    /// that don't have access to a compiler when created.
-    pub fn wasm_to_native_trampoline(&self, signature: SignatureIndex) -> &[u8] {
-        let idx = self
-            .wasm_to_native_trampolines
-            .binary_search_by_key(&signature, |entry| entry.0)
-            .expect("should have a Wasm-to-native trampline for all signatures");
-        let (_, loc) = self.wasm_to_native_trampolines[idx];
-        &self.text()[loc.start as usize..][..loc.length as usize]
-    }
-
-    /// Returns the stack map information for all functions defined in this
-    /// module.
-    ///
-    /// The iterator returned iterates over the span of the compiled function in
-    /// memory with the stack maps associated with those bytes.
-    pub fn stack_maps(&self) -> impl Iterator<Item = (&[u8], &[StackMapInformation])> {
-        self.finished_functions().map(|(_, f)| f).zip(
-            self.funcs
-                .values()
-                .map(|f| &f.wasm_func_info.stack_maps[..]),
-        )
-    }
-
-    /// Lookups a defined function by a program counter value.
-    ///
-    /// Returns the defined function index and the relative address of
-    /// `text_offset` within the function itself.
-    pub fn func_by_text_offset(&self, text_offset: usize) -> Option<(DefinedFuncIndex, u32)> {
-        let text_offset = u32::try_from(text_offset).unwrap();
-
-        let index = match self.funcs.binary_search_values_by_key(&text_offset, |e| {
-            debug_assert!(e.wasm_func_loc.length > 0);
-            // Return the inclusive "end" of the function
-            e.wasm_func_loc.start + e.wasm_func_loc.length - 1
-        }) {
-            Ok(k) => {
-                // Exact match, pc is at the end of this function
-                k
-            }
-            Err(k) => {
-                // Not an exact match, k is where `pc` would be "inserted"
-                // Since we key based on the end, function `k` might contain `pc`,
-                // so we'll validate on the range check below
-                k
-            }
-        };
-
-        let CompiledFunctionInfo { wasm_func_loc, .. } = self.funcs.get(index)?;
-        let start = wasm_func_loc.start;
-        let end = wasm_func_loc.start + wasm_func_loc.length;
-
-        if text_offset < start || end < text_offset {
-            return None;
-        }
-
-        Some((index, text_offset - wasm_func_loc.start))
-    }
-
-    /// Gets the function location information for a given function index.
-    pub fn func_loc(&self, index: DefinedFuncIndex) -> &FunctionLoc {
-        &self
-            .funcs
-            .get(index)
-            .expect("defined function should be present")
-            .wasm_func_loc
-    }
-
-    /// Gets the function information for a given function index.
-    pub fn wasm_func_info(&self, index: DefinedFuncIndex) -> &WasmFunctionInfo {
-        &self
-            .funcs
-            .get(index)
-            .expect("defined function should be present")
-            .wasm_func_info
-    }
-
-    /// Creates a new symbolication context which can be used to further
-    /// symbolicate stack traces.
-    ///
-    /// Basically this makes a thing which parses debuginfo and can tell you
-    /// what filename and line number a wasm pc comes from.
-    pub fn symbolize_context(&self) -> Result<Option<SymbolizeContext<'_>>> {
-        use gimli::EndianSlice;
-        if !self.meta.has_wasm_debuginfo {
-            return Ok(None);
-        }
-        let dwarf = gimli::Dwarf::load(|id| -> Result<_> {
-            // Lookup the `id` in the `dwarf` array prepared for this module
-            // during module serialization where it's sorted by the `id` key. If
-            // found this is a range within the general module's concatenated
-            // dwarf section which is extracted here, otherwise it's just an
-            // empty list to represent that it's not present.
-            let data = self
-                .meta
-                .dwarf
-                .binary_search_by_key(&(id as u8), |(id, _)| *id)
-                .map(|i| {
-                    let (_, range) = &self.meta.dwarf[i];
-                    &self.code_memory().dwarf()[range.start as usize..range.end as usize]
-                })
-                .unwrap_or(&[]);
-            Ok(EndianSlice::new(data, gimli::LittleEndian))
-        })?;
-        let cx = addr2line::Context::from_dwarf(dwarf)
-            .context("failed to create addr2line dwarf mapping context")?;
-        Ok(Some(SymbolizeContext {
-            inner: cx,
-            code_section_offset: self.meta.code_section_offset,
-        }))
-    }
-
-    /// Returns whether the original wasm module had unparsed debug information
-    /// based on the tunables configuration.
-    pub fn has_unparsed_debuginfo(&self) -> bool {
-        self.meta.has_unparsed_debuginfo
-    }
-
-    /// Indicates whether this module came with n address map such that lookups
-    /// via `wasmtime_environ::lookup_file_pos` will succeed.
-    ///
-    /// If this function returns `false` then `lookup_file_pos` will always
-    /// return `None`.
-    pub fn has_address_map(&self) -> bool {
-        !self.code_memory.address_map_data().is_empty()
-    }
-
-    /// Returns the bounds, in host memory, of where this module's compiled
-    /// image resides.
-    pub fn image_range(&self) -> Range<usize> {
-        let base = self.mmap().as_ptr() as usize;
-        let len = self.mmap().len();
-        base..base + len
-    }
-}
-
-type Addr2LineContext<'a> = addr2line::Context<gimli::EndianSlice<'a, gimli::LittleEndian>>;
-
-/// A context which contains dwarf debug information to translate program
-/// counters back to filenames and line numbers.
-pub struct SymbolizeContext<'a> {
-    inner: Addr2LineContext<'a>,
-    code_section_offset: u64,
-}
-
-impl<'a> SymbolizeContext<'a> {
-    /// Returns access to the [`addr2line::Context`] which can be used to query
-    /// frame information with.
-    pub fn addr2line(&self) -> &Addr2LineContext<'a> {
-        &self.inner
-    }
-
-    /// Returns the offset of the code section in the original wasm file, used
-    /// to calculate lookup values into the DWARF.
-    pub fn code_section_offset(&self) -> u64 {
-        self.code_section_offset
-    }
-}
-
-/// Returns the range of `inner` within `outer`, such that `outer[range]` is the
-/// same as `inner`.
-///
-/// This method requires that `inner` is a sub-slice of `outer`, and if that
-/// isn't true then this method will panic.
-pub fn subslice_range(inner: &[u8], outer: &[u8]) -> Range<usize> {
-    if inner.len() == 0 {
-        return 0..0;
-    }
-
-    assert!(outer.as_ptr() <= inner.as_ptr());
-    assert!((&inner[inner.len() - 1] as *const _) <= (&outer[outer.len() - 1] as *const _));
-
-    let start = inner.as_ptr() as usize - outer.as_ptr() as usize;
-    start..start + inner.len()
-}
diff --git a/crates/jit/src/lib.rs b/crates/jit/src/lib.rs
deleted file mode 100644
index e3afd3bf4099..000000000000
--- a/crates/jit/src/lib.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-//! JIT-style runtime for WebAssembly using Cranelift.
-
-#![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)]
-#![warn(unused_import_braces)]
-
-mod code_memory;
-mod debug;
-mod demangling;
-mod instantiate;
-pub mod profiling;
-mod unwind;
-
-pub use crate::code_memory::CodeMemory;
-pub use crate::instantiate::{
-    subslice_range, CompiledFunctionInfo, CompiledModule, CompiledModuleInfo, ObjectBuilder,
-    SymbolizeContext,
-};
-pub use demangling::*;
-
-/// Version number of this crate.
-pub const VERSION: &str = env!("CARGO_PKG_VERSION");
diff --git a/crates/jit/src/profiling.rs b/crates/jit/src/profiling.rs
deleted file mode 100644
index 5e24344ac915..000000000000
--- a/crates/jit/src/profiling.rs
+++ /dev/null
@@ -1,108 +0,0 @@
-#![allow(missing_docs)]
-
-use crate::CodeMemory;
-#[allow(unused_imports)]
-use anyhow::{bail, Result};
-
-cfg_if::cfg_if! {
-    if #[cfg(all(feature = "jitdump", target_os = "linux"))] {
-        mod jitdump;
-        pub use jitdump::new as new_jitdump;
-    } else {
-        pub fn new_jitdump() -> Result<Box<dyn ProfilingAgent>> {
-            if cfg!(feature = "jitdump") {
-                bail!("jitdump is not supported on this platform");
-            } else {
-                bail!("jitdump support disabled at compile time");
-            }
-        }
-    }
-}
-
-cfg_if::cfg_if! {
-    if #[cfg(unix)] {
-        mod perfmap;
-        pub use perfmap::new as new_perfmap;
-    } else {
-        pub fn new_perfmap() -> Result<Box<dyn ProfilingAgent>> {
-            bail!("perfmap support not supported on this platform");
-        }
-    }
-}
-
-cfg_if::cfg_if! {
-    // Note: VTune support is disabled on windows mingw because the ittapi crate doesn't compile
-    // there; see also https://github.com/bytecodealliance/wasmtime/pull/4003 for rationale.
-    if #[cfg(all(feature = "vtune", target_arch = "x86_64", not(any(target_os = "android", all(target_os = "windows", target_env = "gnu")))))] {
-        mod vtune;
-        pub use vtune::new as new_vtune;
-    } else {
-        pub fn new_vtune() -> Result<Box<dyn ProfilingAgent>> {
-            if cfg!(feature = "vtune") {
-                bail!("VTune is not supported on this platform.");
-            } else {
-                bail!("VTune support disabled at compile time.");
-            }
-        }
-    }
-}
-
-/// Common interface for profiling tools.
-pub trait ProfilingAgent: Send + Sync + 'static {
-    fn register_function(&self, name: &str, addr: *const u8, size: usize);
-
-    fn register_module(&self, code: &CodeMemory, custom_name: &dyn Fn(usize) -> Option<String>) {
-        use object::{File, Object as _, ObjectSection, ObjectSymbol, SectionKind, SymbolKind};
-
-        let image = match File::parse(&code.mmap()[..]) {
-            Ok(image) => image,
-            Err(_) => return,
-        };
-
-        let text_base = match image.sections().find(|s| s.kind() == SectionKind::Text) {
-            Some(section) => match section.data() {
-                Ok(data) => data.as_ptr() as usize,
-                Err(_) => return,
-            },
-            None => return,
-        };
-
-        for sym in image.symbols() {
-            if !sym.is_definition() {
-                continue;
-            }
-            if sym.kind() != SymbolKind::Text {
-                continue;
-            }
-            let address = sym.address();
-            let size = sym.size();
-            if address == 0 || size == 0 {
-                continue;
-            }
-            if let Ok(name) = sym.name() {
-                let addr = text_base + address as usize;
-                let owned;
-                let name = match custom_name(address as usize) {
-                    Some(name) => {
-                        owned = name;
-                        &owned
-                    }
-                    None => name,
-                };
-                self.register_function(name, addr as *const u8, size as usize);
-            }
-        }
-    }
-}
-
-pub fn new_null() -> Box<dyn ProfilingAgent> {
-    Box::new(NullProfilerAgent)
-}
-
-#[derive(Debug, Default, Clone, Copy)]
-struct NullProfilerAgent;
-
-impl ProfilingAgent for NullProfilerAgent {
-    fn register_function(&self, _name: &str, _addr: *const u8, _size: usize) {}
-    fn register_module(&self, _code: &CodeMemory, _custom_name: &dyn Fn(usize) -> Option<String>) {}
-}
diff --git a/crates/jit/src/profiling/perfmap.rs b/crates/jit/src/profiling/perfmap.rs
deleted file mode 100644
index 3b9e0134de51..000000000000
--- a/crates/jit/src/profiling/perfmap.rs
+++ /dev/null
@@ -1,47 +0,0 @@
-use crate::profiling::ProfilingAgent;
-use anyhow::Result;
-use std::io::{self, BufWriter, Write};
-use std::process;
-use std::{fs::File, sync::Mutex};
-
-/// Process-wide perf map file. Perf only reads a unique file per process.
-static PERFMAP_FILE: Mutex<Option<BufWriter<File>>> = Mutex::new(None);
-
-/// Interface for driving the creation of jitdump files
-struct PerfMapAgent;
-
-/// Intialize a JitDumpAgent and write out the header.
-pub fn new() -> Result<Box<dyn ProfilingAgent>> {
-    let mut file = PERFMAP_FILE.lock().unwrap();
-    if file.is_none() {
-        let filename = format!("/tmp/perf-{}.map", process::id());
-        *file = Some(BufWriter::new(File::create(filename)?));
-    }
-    Ok(Box::new(PerfMapAgent))
-}
-
-impl PerfMapAgent {
-    fn make_line(
-        writer: &mut dyn Write,
-        name: &str,
-        addr: *const u8,
-        len: usize,
-    ) -> io::Result<()> {
-        // Format is documented here: https://github.com/torvalds/linux/blob/master/tools/perf/Documentation/jit-interface.txt
-        // Try our best to sanitize the name, since wasm allows for any utf8 string in there.
-        let sanitized_name = name.replace('\n', "_").replace('\r', "_");
-        write!(writer, "{:x} {:x} {}\n", addr as usize, len, sanitized_name)?;
-        writer.flush()?;
-        Ok(())
-    }
-}
-
-impl ProfilingAgent for PerfMapAgent {
-    fn register_function(&self, name: &str, addr: *const u8, size: usize) {
-        let mut file = PERFMAP_FILE.lock().unwrap();
-        let file = file.as_mut().unwrap();
-        if let Err(err) = Self::make_line(file, name, addr, size) {
-            eprintln!("Error when writing import trampoline info to the perf map file: {err}");
-        }
-    }
-}
diff --git a/crates/jit/src/unwind.rs b/crates/jit/src/unwind.rs
deleted file mode 100644
index 9ce8660f36c9..000000000000
--- a/crates/jit/src/unwind.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-cfg_if::cfg_if! {
-    if #[cfg(all(windows, any(target_arch = "x86_64", target_arch = "aarch64")))] {
-        mod winx64;
-        pub use self::winx64::*;
-    } else if #[cfg(miri)] {
-        mod miri;
-        pub use self::miri::*;
-    } else if #[cfg(unix)] {
-        mod systemv;
-        pub use self::systemv::*;
-    } else {
-        compile_error!("unsupported target platform for unwind");
-    }
-}
diff --git a/crates/jit/src/unwind/miri.rs b/crates/jit/src/unwind/miri.rs
deleted file mode 100644
index 4b4527e66834..000000000000
--- a/crates/jit/src/unwind/miri.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-use anyhow::Result;
-
-pub struct UnwindRegistration {}
-
-impl UnwindRegistration {
-    pub const SECTION_NAME: &'static str = ".eh_frame";
-
-    pub unsafe fn new(
-        _base_address: *const u8,
-        _unwind_info: *const u8,
-        _unwind_len: usize,
-    ) -> Result<UnwindRegistration> {
-        Ok(UnwindRegistration {})
-    }
-}
diff --git a/crates/jit/src/unwind/systemv.rs b/crates/jit/src/unwind/systemv.rs
deleted file mode 100644
index 2233e4dcb350..000000000000
--- a/crates/jit/src/unwind/systemv.rs
+++ /dev/null
@@ -1,90 +0,0 @@
-//! Module for System V ABI unwind registry.
-
-use anyhow::Result;
-
-/// Represents a registration of function unwind information for System V ABI.
-pub struct UnwindRegistration {
-    registrations: Vec<usize>,
-}
-
-extern "C" {
-    // libunwind import
-    fn __register_frame(fde: *const u8);
-    fn __deregister_frame(fde: *const u8);
-}
-
-impl UnwindRegistration {
-    pub const SECTION_NAME: &'static str = ".eh_frame";
-
-    /// Registers precompiled unwinding information with the system.
-    ///
-    /// The `_base_address` field is ignored here (only used on other
-    /// platforms), but the `unwind_info` and `unwind_len` parameters should
-    /// describe an in-memory representation of a `.eh_frame` section. This is
-    /// typically arranged for by the `wasmtime-obj` crate.
-    pub unsafe fn new(
-        _base_address: *const u8,
-        unwind_info: *const u8,
-        unwind_len: usize,
-    ) -> Result<UnwindRegistration> {
-        debug_assert_eq!(
-            unwind_info as usize % wasmtime_runtime::page_size(),
-            0,
-            "The unwind info must always be aligned to a page"
-        );
-
-        let mut registrations = Vec::new();
-        if cfg!(any(
-            all(target_os = "linux", target_env = "gnu"),
-            target_os = "freebsd"
-        )) {
-            // On gnu (libgcc), `__register_frame` will walk the FDEs until an
-            // entry of length 0
-            __register_frame(unwind_info);
-            registrations.push(unwind_info as usize);
-        } else {
-            // For libunwind, `__register_frame` takes a pointer to a single
-            // FDE. Note that we subtract 4 from the length of unwind info since
-            // wasmtime-encode .eh_frame sections always have a trailing 32-bit
-            // zero for the platforms above.
-            let start = unwind_info;
-            let end = start.add(unwind_len - 4);
-            let mut current = start;
-
-            // Walk all of the entries in the frame table and register them
-            while current < end {
-                let len = std::ptr::read::<u32>(current as *const u32) as usize;
-
-                // Skip over the CIE
-                if current != start {
-                    __register_frame(current);
-                    registrations.push(current as usize);
-                }
-
-                // Move to the next table entry (+4 because the length itself is
-                // not inclusive)
-                current = current.add(len + 4);
-            }
-        }
-
-        Ok(UnwindRegistration { registrations })
-    }
-}
-
-impl Drop for UnwindRegistration {
-    fn drop(&mut self) {
-        unsafe {
-            // libgcc stores the frame entries as a linked list in decreasing
-            // sort order based on the PC value of the registered entry.
-            //
-            // As we store the registrations in increasing order, it would be
-            // O(N^2) to deregister in that order.
-            //
-            // To ensure that we just pop off the first element in the list upon
-            // every deregistration, walk our list of registrations backwards.
-            for fde in self.registrations.iter().rev() {
-                __deregister_frame(*fde as *const _);
-            }
-        }
-    }
-}
diff --git a/crates/jit/src/unwind/winx64.rs b/crates/jit/src/unwind/winx64.rs
deleted file mode 100644
index 6468b87c3ec4..000000000000
--- a/crates/jit/src/unwind/winx64.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-//! Module for Windows x64 ABI unwind registry.
-
-use anyhow::{bail, Result};
-use std::mem;
-use windows_sys::Win32::System::Diagnostics::Debug::*;
-
-/// Represents a registry of function unwind information for Windows x64 ABI.
-pub struct UnwindRegistration {
-    functions: usize,
-}
-
-impl UnwindRegistration {
-    pub const SECTION_NAME: &'static str = ".pdata";
-
-    pub unsafe fn new(
-        base_address: *const u8,
-        unwind_info: *const u8,
-        unwind_len: usize,
-    ) -> Result<UnwindRegistration> {
-        assert!(unwind_info as usize % 4 == 0);
-        let unit_len = mem::size_of::<IMAGE_RUNTIME_FUNCTION_ENTRY>();
-        assert!(unwind_len % unit_len == 0);
-        if RtlAddFunctionTable(
-            unwind_info as *mut _,
-            (unwind_len / unit_len) as u32,
-            base_address as _,
-        ) == 0
-        {
-            bail!("failed to register function table");
-        }
-
-        Ok(UnwindRegistration {
-            functions: unwind_info as usize,
-        })
-    }
-}
-
-impl Drop for UnwindRegistration {
-    fn drop(&mut self) {
-        unsafe {
-            RtlDeleteFunctionTable(self.functions as _);
-        }
-    }
-}
diff --git a/crates/misc/component-fuzz-util/Cargo.toml b/crates/misc/component-fuzz-util/Cargo.toml
index c1a64c59659f..9f6f4a8e9913 100644
--- a/crates/misc/component-fuzz-util/Cargo.toml
+++ b/crates/misc/component-fuzz-util/Cargo.toml
@@ -4,11 +4,15 @@ authors = ["The Wasmtime Project Developers"]
 license = "Apache-2.0 WITH LLVM-exception"
 version = "0.0.0"
 edition.workspace = true
+rust-version.workspace = true
 publish = false
 
+[lints]
+workspace = true
+
 [dependencies]
 anyhow = { workspace = true }
-arbitrary = { version = "1.1.0", features = ["derive"] }
+arbitrary = { workspace = true, features = ["derive"] }
 proc-macro2 = "1.0"
 quote = "1.0"
 wasmtime-component-util = { workspace = true }
diff --git a/crates/misc/component-fuzz-util/src/lib.rs b/crates/misc/component-fuzz-util/src/lib.rs
index 477681b6bf49..8165195a2824 100644
--- a/crates/misc/component-fuzz-util/src/lib.rs
+++ b/crates/misc/component-fuzz-util/src/lib.rs
@@ -3,7 +3,7 @@
 //!
 //! Each case includes a list of arbitrary interface types to use as parameters, plus another one to use as a
 //! result, and a component which exports a function and imports a function.  The exported function forwards its
-//! parameters to the imported one and forwards the result back to the caller.  This serves to excercise Wasmtime's
+//! parameters to the imported one and forwards the result back to the caller.  This serves to exercise Wasmtime's
 //! lifting and lowering code and verify the values remain intact during both processes.
 
 use arbitrary::{Arbitrary, Unstructured};
@@ -176,9 +176,7 @@ impl Type {
                 err: Type::generate_opt(u, depth - 1, fuel)?.map(Box::new),
             },
             20 => {
-                // Generate 1 flag all the way up to 65 flags which exercises
-                // the 1 to 3 x u32 cases.
-                let amt = u.int_in_range(1..=(*fuel).min(65))?;
+                let amt = u.int_in_range(1..=(*fuel).min(32))?;
                 *fuel -= amt;
                 Type::Flags(amt)
             }
@@ -571,10 +569,16 @@ pub fn rust_type(ty: &Type, name_counter: &mut u32, declarations: &mut TokenStre
                 .collect::<TokenStream>();
 
             let name = make_rust_name(name_counter);
+            let repr = match count.ilog2() {
+                0..=7 => quote!(u8),
+                8..=15 => quote!(u16),
+                _ => quote!(u32),
+            };
 
             declarations.extend(quote! {
                 #[derive(ComponentType, Lift, Lower, PartialEq, Debug, Copy, Clone, Arbitrary)]
                 #[component(enum)]
+                #[repr(#repr)]
                 enum #name {
                     #cases
                 }
@@ -877,7 +881,7 @@ impl Declarations {
 pub struct TestCase<'a> {
     /// The types of parameters to pass to the function
     pub params: Vec<&'a Type>,
-    /// The result types of the the function
+    /// The result types of the function
     pub results: Vec<&'a Type>,
     /// String encoding to use from host-to-component.
     pub encoding1: StringEncoding,
diff --git a/crates/misc/component-macro-test/Cargo.toml b/crates/misc/component-macro-test/Cargo.toml
index 35e29dd51520..5bc71a5fdf3c 100644
--- a/crates/misc/component-macro-test/Cargo.toml
+++ b/crates/misc/component-macro-test/Cargo.toml
@@ -4,6 +4,7 @@ authors = ["The Wasmtime Project Developers"]
 license = "Apache-2.0 WITH LLVM-exception"
 version = "0.0.0"
 edition.workspace = true
+rust-version.workspace = true
 publish = false
 
 [lib]
diff --git a/crates/misc/component-test-util/Cargo.toml b/crates/misc/component-test-util/Cargo.toml
index 3280a5a6504e..181a2f4e3e19 100644
--- a/crates/misc/component-test-util/Cargo.toml
+++ b/crates/misc/component-test-util/Cargo.toml
@@ -4,10 +4,11 @@ authors = ["The Wasmtime Project Developers"]
 license = "Apache-2.0 WITH LLVM-exception"
 version = "0.0.0"
 edition.workspace = true
+rust-version.workspace = true
 publish = false
 
 [dependencies]
 env_logger = { workspace = true }
 anyhow = { workspace = true }
-arbitrary = { version = "1.1.0", features = ["derive"] }
+arbitrary = { workspace = true, features = ["derive"] }
 wasmtime = { workspace = true, features = ["component-model", "async"] }
diff --git a/crates/runtime/Cargo.toml b/crates/runtime/Cargo.toml
deleted file mode 100644
index 0ff9f69ae8c1..000000000000
--- a/crates/runtime/Cargo.toml
+++ /dev/null
@@ -1,67 +0,0 @@
-[package]
-name = "wasmtime-runtime"
-version.workspace = true
-authors.workspace = true
-description = "Runtime library support for Wasmtime"
-documentation = "https://docs.rs/wasmtime-runtime"
-license = "Apache-2.0 WITH LLVM-exception"
-categories = ["wasm"]
-keywords = ["webassembly", "wasm"]
-repository = "https://github.com/bytecodealliance/wasmtime"
-edition.workspace = true
-
-[dependencies]
-wasmtime-wmemcheck = { workspace = true }
-wasmtime-asm-macros = { workspace = true }
-wasmtime-environ = { workspace = true }
-wasmtime-fiber = { workspace = true, optional = true }
-wasmtime-jit-debug = { workspace = true, features = ["gdb_jit_int"] }
-wasmtime-versioned-export-macros = { workspace = true }
-libc = { version = "0.2.112", default-features = false }
-log = { workspace = true }
-memoffset = "0.9.0"
-indexmap = { workspace = true }
-cfg-if = { workspace = true }
-rand = { version = "0.8.3", features = ['small_rng'] }
-anyhow = { workspace = true }
-memfd = "0.6.2"
-paste = "1.0.3"
-encoding_rs = { version = "0.8.31", optional = true }
-sptr = "0.3.2"
-wasm-encoder = { workspace = true }
-
-[target.'cfg(target_os = "macos")'.dependencies]
-mach = "0.3.2"
-
-[target.'cfg(unix)'.dependencies]
-rustix = { workspace = true, features = ["mm"] }
-
-[target.'cfg(target_os = "windows")'.dependencies.windows-sys]
-workspace = true
-features = [
-  "Win32_Foundation",
-  "Win32_System_Kernel",
-  "Win32_System_Memory",
-  "Win32_System_Diagnostics_Debug",
-  "Win32_System_SystemInformation",
-  "Win32_Storage_FileSystem",
-  "Win32_Security",
-]
-
-[dev-dependencies]
-once_cell = { workspace = true }
-proptest = "1.0.0"
-
-[build-dependencies]
-cc = "1.0"
-wasmtime-versioned-export-macros = { workspace = true }
-
-[features]
-async = ["wasmtime-fiber"]
-
-# Enables support for the pooling instance allocator
-pooling-allocator = []
-
-component-model = ["wasmtime-environ/component-model", "dep:encoding_rs"]
-
-wmemcheck = []
diff --git a/crates/runtime/LICENSE b/crates/runtime/LICENSE
deleted file mode 100644
index f9d81955f4bc..000000000000
--- a/crates/runtime/LICENSE
+++ /dev/null
@@ -1,220 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-
-
---- LLVM Exceptions to the Apache 2.0 License ----
-
-As an exception, if, as a result of your compiling your source code, portions
-of this Software are embedded into an Object form of such source code, you
-may redistribute such embedded portions in such Object form without complying
-with the conditions of Sections 4(a), 4(b) and 4(d) of the License.
-
-In addition, if you combine or link compiled forms of this Software with
-software that is licensed under the GPLv2 ("Combined Software") and if a
-court of competent jurisdiction determines that the patent provision (Section
-3), the indemnity provision (Section 9) or other Section of the License
-conflicts with the conditions of the GPLv2, you may retroactively and
-prospectively choose to deem waived or otherwise exclude such Section(s) of
-the License, but only in their entirety and only with respect to the Combined
-Software.
-
diff --git a/crates/runtime/build.rs b/crates/runtime/build.rs
deleted file mode 100644
index 571f0c4b2267..000000000000
--- a/crates/runtime/build.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-use std::env;
-use wasmtime_versioned_export_macros::versioned_suffix;
-
-fn main() {
-    let mut build = cc::Build::new();
-    build.warnings(true);
-    let arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap();
-    let os = env::var("CARGO_CFG_TARGET_OS").unwrap();
-    build.define(&format!("CFG_TARGET_OS_{}", os), None);
-    build.define(&format!("CFG_TARGET_ARCH_{}", arch), None);
-    build.define("VERSIONED_SUFFIX", Some(versioned_suffix!()));
-    if arch == "s390x" {
-        println!("cargo:rerun-if-changed=src/trampolines/s390x.S");
-        build.file("src/trampolines/s390x.S");
-    }
-    println!("cargo:rerun-if-changed=src/helpers.c");
-    build.file("src/helpers.c");
-    build.compile("wasmtime-helpers");
-}
diff --git a/crates/runtime/proptest-regressions/instance/allocator/pooling/memory_pool.txt b/crates/runtime/proptest-regressions/instance/allocator/pooling/memory_pool.txt
deleted file mode 100644
index f95bfcd3875f..000000000000
--- a/crates/runtime/proptest-regressions/instance/allocator/pooling/memory_pool.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-# Seeds for failure cases proptest has generated in the past. It is
-# automatically read and these particular cases re-run before any
-# novel cases are generated.
-#
-# It is recommended to check this file in to source control so that
-# everyone who runs the test benefits from these saved cases.
-cc 696808084287d5d58b85c60c4720227ab4dd83ada7be6841a67162023aaf4914 # shrinks to c = SlabConstraints { max_memory_bytes: 0, num_memory_slots: 1, num_pkeys_available: 0, guard_bytes: 9223372036854775808 }
-cc cf9f6c36659f7f56ed8ea646e8c699cbf46708cef6911cdd376418ad69ea1388 # shrinks to c = SlabConstraints { max_memory_bytes: 14161452635954640438, num_memory_slots: 0, num_pkeys_available: 0, guard_bytes: 4285291437754911178 }
diff --git a/crates/runtime/src/component.rs b/crates/runtime/src/component.rs
deleted file mode 100644
index fc0d4bf2a983..000000000000
--- a/crates/runtime/src/component.rs
+++ /dev/null
@@ -1,855 +0,0 @@
-//! Runtime support for the component model in Wasmtime
-//!
-//! Currently this runtime support includes a `VMComponentContext` which is
-//! similar in purpose to `VMContext`. The context is read from
-//! cranelift-generated trampolines when entering the host from a wasm module.
-//! Eventually it's intended that module-to-module calls, which would be
-//! cranelift-compiled adapters, will use this `VMComponentContext` as well.
-
-use crate::{
-    SendSyncPtr, Store, VMArrayCallFunction, VMFuncRef, VMGlobalDefinition, VMMemoryDefinition,
-    VMNativeCallFunction, VMOpaqueContext, VMSharedSignatureIndex, VMWasmCallFunction, ValRaw,
-};
-use anyhow::Result;
-use memoffset::offset_of;
-use sptr::Strict;
-use std::alloc::{self, Layout};
-use std::any::Any;
-use std::marker;
-use std::mem;
-use std::ops::Deref;
-use std::ptr::{self, NonNull};
-use std::sync::Arc;
-use wasmtime_environ::component::*;
-use wasmtime_environ::{HostPtr, PrimaryMap};
-
-const INVALID_PTR: usize = 0xdead_dead_beef_beef_u64 as usize;
-
-mod libcalls;
-mod resources;
-
-pub use self::resources::{CallContexts, ResourceTable, ResourceTables};
-
-/// Runtime representation of a component instance and all state necessary for
-/// the instance itself.
-///
-/// This type never exists by-value, but rather it's always behind a pointer.
-/// The size of the allocation for `ComponentInstance` includes the trailing
-/// `VMComponentContext` which is variably sized based on the `offsets`
-/// contained within.
-#[repr(C)]
-pub struct ComponentInstance {
-    /// Size and offset information for the trailing `VMComponentContext`.
-    offsets: VMComponentOffsets<HostPtr>,
-
-    /// For more information about this see the documentation on
-    /// `Instance::vmctx_self_reference`.
-    vmctx_self_reference: SendSyncPtr<VMComponentContext>,
-
-    /// Runtime type information about this component.
-    runtime_info: Arc<dyn ComponentRuntimeInfo>,
-
-    /// State of resources for all `TypeResourceTableIndex` values for this
-    /// component.
-    ///
-    /// This is paired with other information to create a `ResourceTables` which
-    /// is how this field is manipulated.
-    component_resource_tables: PrimaryMap<TypeResourceTableIndex, ResourceTable>,
-
-    /// Storage for the type information about resources within this component
-    /// instance.
-    ///
-    /// This is actually `Arc<PrimaryMap<ResourceIndex, ResourceType>>` but that
-    /// can't be in this crate because `ResourceType` isn't here. Not using `dyn
-    /// Any` is left as an exercise for a future refactoring.
-    resource_types: Arc<dyn Any + Send + Sync>,
-
-    /// A zero-sized field which represents the end of the struct for the actual
-    /// `VMComponentContext` to be allocated behind.
-    vmctx: VMComponentContext,
-}
-
-/// Type signature for host-defined trampolines that are called from
-/// WebAssembly.
-///
-/// This function signature is invoked from a cranelift-compiled trampoline that
-/// adapts from the core wasm System-V ABI into the ABI provided here:
-///
-/// * `vmctx` - this is the first argument to the wasm import, and should always
-///   end up being a `VMComponentContext`.
-/// * `data` - this is the data pointer associated with the `VMLowering` for
-///   which this function pointer was registered.
-/// * `ty` - the type index, relative to the tables in `vmctx`, that is the
-///   type of the function being called.
-/// * `flags` - the component flags for may_enter/leave corresponding to the
-///   component instance that the lowering happened within.
-/// * `opt_memory` - this nullable pointer represents the memory configuration
-///   option for the canonical ABI options.
-/// * `opt_realloc` - this nullable pointer represents the realloc configuration
-///   option for the canonical ABI options.
-/// * `string_encoding` - this is the configured string encoding for the
-///   canonical ABI this lowering corresponds to.
-/// * `args_and_results` - pointer to stack-allocated space in the caller where
-///   all the arguments are stored as well as where the results will be written
-///   to. The size and initialized bytes of this depends on the core wasm type
-///   signature that this callee corresponds to.
-/// * `nargs_and_results` - the size, in units of `ValRaw`, of
-///   `args_and_results`.
-//
-// FIXME: 9 arguments is probably too many. The `data` through `string-encoding`
-// parameters should probably get packaged up into the `VMComponentContext`.
-// Needs benchmarking one way or another though to figure out what the best
-// balance is here.
-pub type VMLoweringCallee = extern "C" fn(
-    vmctx: *mut VMOpaqueContext,
-    data: *mut u8,
-    ty: TypeFuncIndex,
-    flags: InstanceFlags,
-    opt_memory: *mut VMMemoryDefinition,
-    opt_realloc: *mut VMFuncRef,
-    string_encoding: StringEncoding,
-    args_and_results: *mut mem::MaybeUninit<ValRaw>,
-    nargs_and_results: usize,
-);
-
-/// Structure describing a lowered host function stored within a
-/// `VMComponentContext` per-lowering.
-#[derive(Copy, Clone)]
-#[repr(C)]
-pub struct VMLowering {
-    /// The host function pointer that is invoked when this lowering is
-    /// invoked.
-    pub callee: VMLoweringCallee,
-    /// The host data pointer (think void* pointer) to get passed to `callee`.
-    pub data: *mut u8,
-}
-
-/// This is a marker type to represent the underlying allocation of a
-/// `VMComponentContext`.
-///
-/// This type is similar to `VMContext` for core wasm and is allocated once per
-/// component instance in Wasmtime. While the static size of this type is 0 the
-/// actual runtime size is variable depending on the shape of the component that
-/// this corresponds to. This structure always trails a `ComponentInstance`
-/// allocation and the allocation/liftetime of this allocation is managed by
-/// `ComponentInstance`.
-#[repr(C)]
-// Set an appropriate alignment for this structure where the most-aligned value
-// internally right now `VMGlobalDefinition` which has an alignment of 16 bytes.
-#[repr(align(16))]
-pub struct VMComponentContext {
-    /// For more information about this see the equivalent field in `VMContext`
-    _marker: marker::PhantomPinned,
-}
-
-impl ComponentInstance {
-    /// Converts the `vmctx` provided into a `ComponentInstance` and runs the
-    /// provided closure with that instance.
-    ///
-    /// # Unsafety
-    ///
-    /// This is `unsafe` because `vmctx` cannot be guaranteed to be a valid
-    /// pointer and it cannot be proven statically that it's safe to get a
-    /// mutable reference at this time to the instance from `vmctx`.
-    pub unsafe fn from_vmctx<R>(
-        vmctx: *mut VMComponentContext,
-        f: impl FnOnce(&mut ComponentInstance) -> R,
-    ) -> R {
-        let ptr = vmctx
-            .cast::<u8>()
-            .sub(mem::size_of::<ComponentInstance>())
-            .cast::<ComponentInstance>();
-        f(&mut *ptr)
-    }
-
-    /// Returns the layout corresponding to what would be an allocation of a
-    /// `ComponentInstance` for the `offsets` provided.
-    ///
-    /// The returned layout has space for both the `ComponentInstance` and the
-    /// trailing `VMComponentContext`.
-    fn alloc_layout(offsets: &VMComponentOffsets<HostPtr>) -> Layout {
-        let size = mem::size_of::<Self>()
-            .checked_add(usize::try_from(offsets.size_of_vmctx()).unwrap())
-            .unwrap();
-        let align = mem::align_of::<Self>();
-        Layout::from_size_align(size, align).unwrap()
-    }
-
-    /// Initializes an uninitialized pointer to a `ComponentInstance` in
-    /// addition to its trailing `VMComponentContext`.
-    ///
-    /// The `ptr` provided must be valid for `alloc_size` bytes and will be
-    /// entirely overwritten by this function call. The `offsets` correspond to
-    /// the shape of the component being instantiated and `store` is a pointer
-    /// back to the Wasmtime store for host functions to have access to.
-    unsafe fn new_at(
-        ptr: NonNull<ComponentInstance>,
-        alloc_size: usize,
-        offsets: VMComponentOffsets<HostPtr>,
-        runtime_info: Arc<dyn ComponentRuntimeInfo>,
-        resource_types: Arc<dyn Any + Send + Sync>,
-        store: *mut dyn Store,
-    ) {
-        assert!(alloc_size >= Self::alloc_layout(&offsets).size());
-
-        let num_tables = runtime_info.component().num_resource_tables;
-        let mut component_resource_tables = PrimaryMap::with_capacity(num_tables);
-        for _ in 0..num_tables {
-            component_resource_tables.push(ResourceTable::default());
-        }
-
-        ptr::write(
-            ptr.as_ptr(),
-            ComponentInstance {
-                offsets,
-                vmctx_self_reference: SendSyncPtr::new(
-                    NonNull::new(
-                        ptr.as_ptr()
-                            .cast::<u8>()
-                            .add(mem::size_of::<ComponentInstance>())
-                            .cast(),
-                    )
-                    .unwrap(),
-                ),
-                component_resource_tables,
-                runtime_info,
-                resource_types,
-                vmctx: VMComponentContext {
-                    _marker: marker::PhantomPinned,
-                },
-            },
-        );
-
-        (*ptr.as_ptr()).initialize_vmctx(store);
-    }
-
-    fn vmctx(&self) -> *mut VMComponentContext {
-        let addr = std::ptr::addr_of!(self.vmctx);
-        Strict::with_addr(self.vmctx_self_reference.as_ptr(), Strict::addr(addr))
-    }
-
-    unsafe fn vmctx_plus_offset<T>(&self, offset: u32) -> *const T {
-        self.vmctx()
-            .cast::<u8>()
-            .add(usize::try_from(offset).unwrap())
-            .cast()
-    }
-
-    unsafe fn vmctx_plus_offset_mut<T>(&mut self, offset: u32) -> *mut T {
-        self.vmctx()
-            .cast::<u8>()
-            .add(usize::try_from(offset).unwrap())
-            .cast()
-    }
-
-    /// Returns a pointer to the "may leave" flag for this instance specified
-    /// for canonical lowering and lifting operations.
-    #[inline]
-    pub fn instance_flags(&self, instance: RuntimeComponentInstanceIndex) -> InstanceFlags {
-        unsafe {
-            let ptr = self
-                .vmctx_plus_offset::<VMGlobalDefinition>(self.offsets.instance_flags(instance))
-                .cast_mut();
-            InstanceFlags(SendSyncPtr::new(NonNull::new(ptr).unwrap()))
-        }
-    }
-
-    /// Returns the store that this component was created with.
-    pub fn store(&self) -> *mut dyn Store {
-        unsafe {
-            let ret = *self.vmctx_plus_offset::<*mut dyn Store>(self.offsets.store());
-            assert!(!ret.is_null());
-            ret
-        }
-    }
-
-    /// Returns the runtime memory definition corresponding to the index of the
-    /// memory provided.
-    ///
-    /// This can only be called after `idx` has been initialized at runtime
-    /// during the instantiation process of a component.
-    pub fn runtime_memory(&self, idx: RuntimeMemoryIndex) -> *mut VMMemoryDefinition {
-        unsafe {
-            let ret = *self.vmctx_plus_offset(self.offsets.runtime_memory(idx));
-            debug_assert!(ret as usize != INVALID_PTR);
-            ret
-        }
-    }
-
-    /// Returns the realloc pointer corresponding to the index provided.
-    ///
-    /// This can only be called after `idx` has been initialized at runtime
-    /// during the instantiation process of a component.
-    pub fn runtime_realloc(&self, idx: RuntimeReallocIndex) -> NonNull<VMFuncRef> {
-        unsafe {
-            let ret = *self.vmctx_plus_offset::<NonNull<_>>(self.offsets.runtime_realloc(idx));
-            debug_assert!(ret.as_ptr() as usize != INVALID_PTR);
-            ret
-        }
-    }
-
-    /// Returns the post-return pointer corresponding to the index provided.
-    ///
-    /// This can only be called after `idx` has been initialized at runtime
-    /// during the instantiation process of a component.
-    pub fn runtime_post_return(&self, idx: RuntimePostReturnIndex) -> NonNull<VMFuncRef> {
-        unsafe {
-            let ret = *self.vmctx_plus_offset::<NonNull<_>>(self.offsets.runtime_post_return(idx));
-            debug_assert!(ret.as_ptr() as usize != INVALID_PTR);
-            ret
-        }
-    }
-
-    /// Returns the host information for the lowered function at the index
-    /// specified.
-    ///
-    /// This can only be called after `idx` has been initialized at runtime
-    /// during the instantiation process of a component.
-    pub fn lowering(&self, idx: LoweredIndex) -> VMLowering {
-        unsafe {
-            let ret = *self.vmctx_plus_offset::<VMLowering>(self.offsets.lowering(idx));
-            debug_assert!(ret.callee as usize != INVALID_PTR);
-            debug_assert!(ret.data as usize != INVALID_PTR);
-            ret
-        }
-    }
-
-    /// Returns the core wasm `funcref` corresponding to the trampoline
-    /// specified.
-    ///
-    /// The returned function is suitable to pass directly to a wasm module
-    /// instantiation and the function contains cranelift-compiled trampolines.
-    ///
-    /// This can only be called after `idx` has been initialized at runtime
-    /// during the instantiation process of a component.
-    pub fn trampoline_func_ref(&self, idx: TrampolineIndex) -> NonNull<VMFuncRef> {
-        unsafe {
-            let offset = self.offsets.trampoline_func_ref(idx);
-            let ret = self.vmctx_plus_offset::<VMFuncRef>(offset);
-            debug_assert!(
-                mem::transmute::<Option<NonNull<VMWasmCallFunction>>, usize>((*ret).wasm_call)
-                    != INVALID_PTR
-            );
-            debug_assert!((*ret).vmctx as usize != INVALID_PTR);
-            NonNull::new(ret.cast_mut()).unwrap()
-        }
-    }
-
-    /// Stores the runtime memory pointer at the index specified.
-    ///
-    /// This is intended to be called during the instantiation process of a
-    /// component once a memory is available, which may not be until part-way
-    /// through component instantiation.
-    ///
-    /// Note that it should be a property of the component model that the `ptr`
-    /// here is never needed prior to it being configured here in the instance.
-    pub fn set_runtime_memory(&mut self, idx: RuntimeMemoryIndex, ptr: *mut VMMemoryDefinition) {
-        unsafe {
-            debug_assert!(!ptr.is_null());
-            let storage = self.vmctx_plus_offset_mut(self.offsets.runtime_memory(idx));
-            debug_assert!(*storage as usize == INVALID_PTR);
-            *storage = ptr;
-        }
-    }
-
-    /// Same as `set_runtime_memory` but for realloc function pointers.
-    pub fn set_runtime_realloc(&mut self, idx: RuntimeReallocIndex, ptr: NonNull<VMFuncRef>) {
-        unsafe {
-            let storage = self.vmctx_plus_offset_mut(self.offsets.runtime_realloc(idx));
-            debug_assert!(*storage as usize == INVALID_PTR);
-            *storage = ptr.as_ptr();
-        }
-    }
-
-    /// Same as `set_runtime_memory` but for post-return function pointers.
-    pub fn set_runtime_post_return(
-        &mut self,
-        idx: RuntimePostReturnIndex,
-        ptr: NonNull<VMFuncRef>,
-    ) {
-        unsafe {
-            let storage = self.vmctx_plus_offset_mut(self.offsets.runtime_post_return(idx));
-            debug_assert!(*storage as usize == INVALID_PTR);
-            *storage = ptr.as_ptr();
-        }
-    }
-
-    /// Configures host runtime lowering information associated with imported f
-    /// functions for the `idx` specified.
-    pub fn set_lowering(&mut self, idx: LoweredIndex, lowering: VMLowering) {
-        unsafe {
-            debug_assert!(
-                *self.vmctx_plus_offset::<usize>(self.offsets.lowering_callee(idx)) == INVALID_PTR
-            );
-            debug_assert!(
-                *self.vmctx_plus_offset::<usize>(self.offsets.lowering_data(idx)) == INVALID_PTR
-            );
-            *self.vmctx_plus_offset_mut(self.offsets.lowering(idx)) = lowering;
-        }
-    }
-
-    /// Same as `set_lowering` but for the resource.drop functions.
-    pub fn set_trampoline(
-        &mut self,
-        idx: TrampolineIndex,
-        wasm_call: NonNull<VMWasmCallFunction>,
-        native_call: NonNull<VMNativeCallFunction>,
-        array_call: VMArrayCallFunction,
-        type_index: VMSharedSignatureIndex,
-    ) {
-        unsafe {
-            let offset = self.offsets.trampoline_func_ref(idx);
-            debug_assert!(*self.vmctx_plus_offset::<usize>(offset) == INVALID_PTR);
-            let vmctx = VMOpaqueContext::from_vmcomponent(self.vmctx());
-            *self.vmctx_plus_offset_mut(offset) = VMFuncRef {
-                wasm_call: Some(wasm_call),
-                native_call,
-                array_call,
-                type_index,
-                vmctx,
-            };
-        }
-    }
-
-    /// Configures the destructor for a resource at the `idx` specified.
-    ///
-    /// This is required to be called for each resource as it's defined within a
-    /// component during the instantiation process.
-    pub fn set_resource_destructor(
-        &mut self,
-        idx: ResourceIndex,
-        dtor: Option<NonNull<VMFuncRef>>,
-    ) {
-        unsafe {
-            let offset = self.offsets.resource_destructor(idx);
-            debug_assert!(*self.vmctx_plus_offset::<usize>(offset) == INVALID_PTR);
-            *self.vmctx_plus_offset_mut(offset) = dtor;
-        }
-    }
-
-    /// Returns the destructor, if any, for `idx`.
-    ///
-    /// This is only valid to call after `set_resource_destructor`, or typically
-    /// after instantiation.
-    pub fn resource_destructor(&self, idx: ResourceIndex) -> Option<NonNull<VMFuncRef>> {
-        unsafe {
-            let offset = self.offsets.resource_destructor(idx);
-            debug_assert!(*self.vmctx_plus_offset::<usize>(offset) != INVALID_PTR);
-            *self.vmctx_plus_offset(offset)
-        }
-    }
-
-    unsafe fn initialize_vmctx(&mut self, store: *mut dyn Store) {
-        *self.vmctx_plus_offset_mut(self.offsets.magic()) = VMCOMPONENT_MAGIC;
-        *self.vmctx_plus_offset_mut(self.offsets.libcalls()) = &libcalls::VMComponentLibcalls::INIT;
-        *self.vmctx_plus_offset_mut(self.offsets.store()) = store;
-        *self.vmctx_plus_offset_mut(self.offsets.limits()) = (*store).vmruntime_limits();
-
-        for i in 0..self.offsets.num_runtime_component_instances {
-            let i = RuntimeComponentInstanceIndex::from_u32(i);
-            let mut def = VMGlobalDefinition::new();
-            *def.as_i32_mut() = FLAG_MAY_ENTER | FLAG_MAY_LEAVE;
-            *self.instance_flags(i).as_raw() = def;
-        }
-
-        // In debug mode set non-null bad values to all "pointer looking" bits
-        // and pices related to lowering and such. This'll help detect any
-        // erroneous usage and enable debug assertions above as well to prevent
-        // loading these before they're configured or setting them twice.
-        if cfg!(debug_assertions) {
-            for i in 0..self.offsets.num_lowerings {
-                let i = LoweredIndex::from_u32(i);
-                let offset = self.offsets.lowering_callee(i);
-                *self.vmctx_plus_offset_mut(offset) = INVALID_PTR;
-                let offset = self.offsets.lowering_data(i);
-                *self.vmctx_plus_offset_mut(offset) = INVALID_PTR;
-            }
-            for i in 0..self.offsets.num_trampolines {
-                let i = TrampolineIndex::from_u32(i);
-                let offset = self.offsets.trampoline_func_ref(i);
-                *self.vmctx_plus_offset_mut(offset) = INVALID_PTR;
-            }
-            for i in 0..self.offsets.num_runtime_memories {
-                let i = RuntimeMemoryIndex::from_u32(i);
-                let offset = self.offsets.runtime_memory(i);
-                *self.vmctx_plus_offset_mut(offset) = INVALID_PTR;
-            }
-            for i in 0..self.offsets.num_runtime_reallocs {
-                let i = RuntimeReallocIndex::from_u32(i);
-                let offset = self.offsets.runtime_realloc(i);
-                *self.vmctx_plus_offset_mut(offset) = INVALID_PTR;
-            }
-            for i in 0..self.offsets.num_runtime_post_returns {
-                let i = RuntimePostReturnIndex::from_u32(i);
-                let offset = self.offsets.runtime_post_return(i);
-                *self.vmctx_plus_offset_mut(offset) = INVALID_PTR;
-            }
-            for i in 0..self.offsets.num_resources {
-                let i = ResourceIndex::from_u32(i);
-                let offset = self.offsets.resource_destructor(i);
-                *self.vmctx_plus_offset_mut(offset) = INVALID_PTR;
-            }
-        }
-    }
-
-    /// Returns a reference to the component type information for this instance.
-    pub fn component(&self) -> &Component {
-        self.runtime_info.component()
-    }
-
-    /// Returns the type information that this instance is instantiated with.
-    pub fn component_types(&self) -> &Arc<ComponentTypes> {
-        self.runtime_info.component_types()
-    }
-
-    /// Returns a reference to the resource type information as a `dyn Any`.
-    ///
-    /// Wasmtime is the one which then downcasts this to the appropriate type.
-    pub fn resource_types(&self) -> &Arc<dyn Any + Send + Sync> {
-        &self.resource_types
-    }
-
-    /// Returns whether the resource that `ty` points to is owned by the
-    /// instance that `ty` correspond to.
-    ///
-    /// This is used when lowering borrows to skip table management and instead
-    /// thread through the underlying representation directly.
-    pub fn resource_owned_by_own_instance(&self, ty: TypeResourceTableIndex) -> bool {
-        let resource = &self.component_types()[ty];
-        let component = self.component();
-        let idx = match component.defined_resource_index(resource.ty) {
-            Some(idx) => idx,
-            None => return false,
-        };
-        resource.instance == component.defined_resource_instances[idx]
-    }
-
-    /// Implementation of the `resource.new` intrinsic for `i32`
-    /// representations.
-    pub fn resource_new32(&mut self, resource: TypeResourceTableIndex, rep: u32) -> u32 {
-        self.resource_tables().resource_new(Some(resource), rep)
-    }
-
-    /// Implementation of the `resource.rep` intrinsic for `i32`
-    /// representations.
-    pub fn resource_rep32(&mut self, resource: TypeResourceTableIndex, idx: u32) -> Result<u32> {
-        self.resource_tables().resource_rep(Some(resource), idx)
-    }
-
-    /// Implementation of the `resource.drop` intrinsic.
-    pub fn resource_drop(
-        &mut self,
-        resource: TypeResourceTableIndex,
-        idx: u32,
-    ) -> Result<Option<u32>> {
-        self.resource_tables().resource_drop(Some(resource), idx)
-    }
-
-    /// NB: this is intended to be a private method. This does not have
-    /// `host_table` information at this time meaning it's only suitable for
-    /// working with resources specified to this component which is currently
-    /// all that this is used for.
-    ///
-    /// If necessary though it's possible to enhance the `Store` trait to thread
-    /// through the relevant information and get `host_table` to be `Some` here.
-    fn resource_tables(&mut self) -> ResourceTables<'_> {
-        ResourceTables {
-            host_table: None,
-            calls: unsafe { (&mut *self.store()).component_calls() },
-            tables: Some(&mut self.component_resource_tables),
-        }
-    }
-
-    /// Returns the runtime state of resources associated with this component.
-    #[inline]
-    pub fn component_resource_tables(
-        &mut self,
-    ) -> &mut PrimaryMap<TypeResourceTableIndex, ResourceTable> {
-        &mut self.component_resource_tables
-    }
-
-    /// Returns the destructor and instance flags for the specified resource
-    /// table type.
-    ///
-    /// This will lookup the origin definition of the `ty` table and return the
-    /// destructor/flags for that.
-    pub fn dtor_and_flags(
-        &self,
-        ty: TypeResourceTableIndex,
-    ) -> (Option<NonNull<VMFuncRef>>, Option<InstanceFlags>) {
-        let resource = self.component_types()[ty].ty;
-        let dtor = self.resource_destructor(resource);
-        let component = self.component();
-        let flags = component.defined_resource_index(resource).map(|i| {
-            let instance = component.defined_resource_instances[i];
-            self.instance_flags(instance)
-        });
-        (dtor, flags)
-    }
-
-    pub(crate) fn resource_transfer_own(
-        &mut self,
-        idx: u32,
-        src: TypeResourceTableIndex,
-        dst: TypeResourceTableIndex,
-    ) -> Result<u32> {
-        let mut tables = self.resource_tables();
-        let rep = tables.resource_lift_own(Some(src), idx)?;
-        Ok(tables.resource_lower_own(Some(dst), rep))
-    }
-
-    pub(crate) fn resource_transfer_borrow(
-        &mut self,
-        idx: u32,
-        src: TypeResourceTableIndex,
-        dst: TypeResourceTableIndex,
-    ) -> Result<u32> {
-        let dst_owns_resource = self.resource_owned_by_own_instance(dst);
-        let mut tables = self.resource_tables();
-        let rep = tables.resource_lift_borrow(Some(src), idx)?;
-        // Implement `lower_borrow`'s special case here where if a borrow's
-        // resource type is owned by `dst` then the destination receives the
-        // representation directly rather than a handle to the representation.
-        //
-        // This can perhaps become a different libcall in the future to avoid
-        // this check at runtime since we know at compile time whether the
-        // destination type owns the resource, but that's left as a future
-        // refactoring if truly necessary.
-        if dst_owns_resource {
-            return Ok(rep);
-        }
-        Ok(tables.resource_lower_borrow(Some(dst), rep))
-    }
-
-    pub(crate) fn resource_enter_call(&mut self) {
-        self.resource_tables().enter_call()
-    }
-
-    pub(crate) fn resource_exit_call(&mut self) -> Result<()> {
-        self.resource_tables().exit_call()
-    }
-}
-
-impl VMComponentContext {
-    /// Moves the `self` pointer backwards to the `ComponentInstance` pointer
-    /// that this `VMComponentContext` trails.
-    pub fn instance(&self) -> *mut ComponentInstance {
-        unsafe {
-            (self as *const Self as *mut u8)
-                .offset(-(offset_of!(ComponentInstance, vmctx) as isize))
-                as *mut ComponentInstance
-        }
-    }
-}
-
-/// An owned version of `ComponentInstance` which is akin to
-/// `Box<ComponentInstance>`.
-///
-/// This type can be dereferenced to `ComponentInstance` to access the
-/// underlying methods.
-pub struct OwnedComponentInstance {
-    ptr: SendSyncPtr<ComponentInstance>,
-}
-
-impl OwnedComponentInstance {
-    /// Allocates a new `ComponentInstance + VMComponentContext` pair on the
-    /// heap with `malloc` and configures it for the `component` specified.
-    pub fn new(
-        runtime_info: Arc<dyn ComponentRuntimeInfo>,
-        resource_types: Arc<dyn Any + Send + Sync>,
-        store: *mut dyn Store,
-    ) -> OwnedComponentInstance {
-        let component = runtime_info.component();
-        let offsets = VMComponentOffsets::new(HostPtr, component);
-        let layout = ComponentInstance::alloc_layout(&offsets);
-        unsafe {
-            // Technically it is not required to `alloc_zeroed` here. The
-            // primary reason for doing this is because a component context
-            // start is a "partly initialized" state where pointers and such are
-            // configured as the instantiation process continues. The component
-            // model should guarantee that we never access uninitialized memory
-            // in the context, but to help protect against possible bugs a
-            // zeroed allocation is done here to try to contain
-            // use-before-initialized issues.
-            let ptr = alloc::alloc_zeroed(layout) as *mut ComponentInstance;
-            let ptr = NonNull::new(ptr).unwrap();
-
-            ComponentInstance::new_at(
-                ptr,
-                layout.size(),
-                offsets,
-                runtime_info,
-                resource_types,
-                store,
-            );
-
-            let ptr = SendSyncPtr::new(ptr);
-            OwnedComponentInstance { ptr }
-        }
-    }
-
-    // Note that this is technically unsafe due to the fact that it enables
-    // `mem::swap`-ing two component instances which would get all the offsets
-    // mixed up and cause issues. This is scoped to just this module though as a
-    // convenience to forward to `&mut` methods on `ComponentInstance`.
-    unsafe fn instance_mut(&mut self) -> &mut ComponentInstance {
-        &mut *self.ptr.as_ptr()
-    }
-
-    /// Returns the underlying component instance's raw pointer.
-    pub fn instance_ptr(&self) -> *mut ComponentInstance {
-        self.ptr.as_ptr()
-    }
-
-    /// See `ComponentInstance::set_runtime_memory`
-    pub fn set_runtime_memory(&mut self, idx: RuntimeMemoryIndex, ptr: *mut VMMemoryDefinition) {
-        unsafe { self.instance_mut().set_runtime_memory(idx, ptr) }
-    }
-
-    /// See `ComponentInstance::set_runtime_realloc`
-    pub fn set_runtime_realloc(&mut self, idx: RuntimeReallocIndex, ptr: NonNull<VMFuncRef>) {
-        unsafe { self.instance_mut().set_runtime_realloc(idx, ptr) }
-    }
-
-    /// See `ComponentInstance::set_runtime_post_return`
-    pub fn set_runtime_post_return(
-        &mut self,
-        idx: RuntimePostReturnIndex,
-        ptr: NonNull<VMFuncRef>,
-    ) {
-        unsafe { self.instance_mut().set_runtime_post_return(idx, ptr) }
-    }
-
-    /// See `ComponentInstance::set_lowering`
-    pub fn set_lowering(&mut self, idx: LoweredIndex, lowering: VMLowering) {
-        unsafe { self.instance_mut().set_lowering(idx, lowering) }
-    }
-
-    /// See `ComponentInstance::set_resource_drop`
-    pub fn set_trampoline(
-        &mut self,
-        idx: TrampolineIndex,
-        wasm_call: NonNull<VMWasmCallFunction>,
-        native_call: NonNull<VMNativeCallFunction>,
-        array_call: VMArrayCallFunction,
-        type_index: VMSharedSignatureIndex,
-    ) {
-        unsafe {
-            self.instance_mut()
-                .set_trampoline(idx, wasm_call, native_call, array_call, type_index)
-        }
-    }
-
-    /// See `ComponentInstance::set_resource_destructor`
-    pub fn set_resource_destructor(
-        &mut self,
-        idx: ResourceIndex,
-        dtor: Option<NonNull<VMFuncRef>>,
-    ) {
-        unsafe { self.instance_mut().set_resource_destructor(idx, dtor) }
-    }
-
-    /// See `ComponentInstance::resource_types`
-    pub fn resource_types_mut(&mut self) -> &mut Arc<dyn Any + Send + Sync> {
-        unsafe { &mut (*self.ptr.as_ptr()).resource_types }
-    }
-}
-
-impl Deref for OwnedComponentInstance {
-    type Target = ComponentInstance;
-    fn deref(&self) -> &ComponentInstance {
-        unsafe { &*self.ptr.as_ptr() }
-    }
-}
-
-impl Drop for OwnedComponentInstance {
-    fn drop(&mut self) {
-        let layout = ComponentInstance::alloc_layout(&self.offsets);
-        unsafe {
-            ptr::drop_in_place(self.ptr.as_ptr());
-            alloc::dealloc(self.ptr.as_ptr().cast(), layout);
-        }
-    }
-}
-
-impl VMComponentContext {
-    /// Helper function to cast between context types using a debug assertion to
-    /// protect against some mistakes.
-    #[inline]
-    pub unsafe fn from_opaque(opaque: *mut VMOpaqueContext) -> *mut VMComponentContext {
-        // See comments in `VMContext::from_opaque` for this debug assert
-        debug_assert_eq!((*opaque).magic, VMCOMPONENT_MAGIC);
-        opaque.cast()
-    }
-}
-
-impl VMOpaqueContext {
-    /// Helper function to clearly indicate the cast desired
-    #[inline]
-    pub fn from_vmcomponent(ptr: *mut VMComponentContext) -> *mut VMOpaqueContext {
-        ptr.cast()
-    }
-}
-
-#[allow(missing_docs)]
-#[repr(transparent)]
-#[derive(Copy, Clone)]
-pub struct InstanceFlags(SendSyncPtr<VMGlobalDefinition>);
-
-#[allow(missing_docs)]
-impl InstanceFlags {
-    #[inline]
-    pub unsafe fn may_leave(&self) -> bool {
-        *(*self.as_raw()).as_i32() & FLAG_MAY_LEAVE != 0
-    }
-
-    #[inline]
-    pub unsafe fn set_may_leave(&mut self, val: bool) {
-        if val {
-            *(*self.as_raw()).as_i32_mut() |= FLAG_MAY_LEAVE;
-        } else {
-            *(*self.as_raw()).as_i32_mut() &= !FLAG_MAY_LEAVE;
-        }
-    }
-
-    #[inline]
-    pub unsafe fn may_enter(&self) -> bool {
-        *(*self.as_raw()).as_i32() & FLAG_MAY_ENTER != 0
-    }
-
-    #[inline]
-    pub unsafe fn set_may_enter(&mut self, val: bool) {
-        if val {
-            *(*self.as_raw()).as_i32_mut() |= FLAG_MAY_ENTER;
-        } else {
-            *(*self.as_raw()).as_i32_mut() &= !FLAG_MAY_ENTER;
-        }
-    }
-
-    #[inline]
-    pub unsafe fn needs_post_return(&self) -> bool {
-        *(*self.as_raw()).as_i32() & FLAG_NEEDS_POST_RETURN != 0
-    }
-
-    #[inline]
-    pub unsafe fn set_needs_post_return(&mut self, val: bool) {
-        if val {
-            *(*self.as_raw()).as_i32_mut() |= FLAG_NEEDS_POST_RETURN;
-        } else {
-            *(*self.as_raw()).as_i32_mut() &= !FLAG_NEEDS_POST_RETURN;
-        }
-    }
-
-    #[inline]
-    pub fn as_raw(&self) -> *mut VMGlobalDefinition {
-        self.0.as_ptr()
-    }
-}
-
-/// Runtime information about a component stored locally for reflection.
-pub trait ComponentRuntimeInfo: Send + Sync + 'static {
-    /// Returns the type information about the compiled component.
-    fn component(&self) -> &Component;
-    /// Returns a handle to the tables of type information for this component.
-    fn component_types(&self) -> &Arc<ComponentTypes>;
-}
diff --git a/crates/runtime/src/component/libcalls.rs b/crates/runtime/src/component/libcalls.rs
deleted file mode 100644
index 920a505339a3..000000000000
--- a/crates/runtime/src/component/libcalls.rs
+++ /dev/null
@@ -1,574 +0,0 @@
-//! Implementation of string transcoding required by the component model.
-
-use crate::component::{ComponentInstance, VMComponentContext};
-use anyhow::{anyhow, Result};
-use std::cell::Cell;
-use std::slice;
-use wasmtime_environ::component::TypeResourceTableIndex;
-
-const UTF16_TAG: usize = 1 << 31;
-
-#[repr(C)] // this is read by Cranelift code so it's layout must be as-written
-pub struct VMComponentLibcalls {
-    builtins: VMComponentBuiltins,
-    transcoders: VMBuiltinTranscodeArray,
-}
-
-impl VMComponentLibcalls {
-    pub const INIT: VMComponentLibcalls = VMComponentLibcalls {
-        builtins: VMComponentBuiltins::INIT,
-        transcoders: VMBuiltinTranscodeArray::INIT,
-    };
-}
-
-macro_rules! signature {
-    (@ty size) => (usize);
-    (@ty size_pair) => (usize);
-    (@ty ptr_u8) => (*mut u8);
-    (@ty ptr_u16) => (*mut u16);
-    (@ty ptr_size) => (*mut usize);
-    (@ty u32) => (u32);
-    (@ty u64) => (u64);
-    (@ty vmctx) => (*mut VMComponentContext);
-
-    (@retptr size_pair) => (*mut usize);
-    (@retptr $other:ident) => (());
-}
-
-/// Defines a `VMComponentBuiltins` structure which contains any builtins such
-/// as resource-related intrinsics.
-macro_rules! define_builtins {
-    (
-        $(
-            $( #[$attr:meta] )*
-            $name:ident( $( $pname:ident: $param:ident ),* ) $( -> $result:ident )?;
-        )*
-    ) => {
-        /// An array that stores addresses of builtin functions. We translate code
-        /// to use indirect calls. This way, we don't have to patch the code.
-        #[repr(C)]
-        struct VMComponentBuiltins {
-            $(
-                $name: unsafe extern "C" fn(
-                    $(signature!(@ty $param),)*
-                ) $( -> signature!(@ty $result))?,
-            )*
-        }
-
-        impl VMComponentBuiltins {
-            const INIT: VMComponentBuiltins = VMComponentBuiltins {
-                $($name: trampolines::$name,)*
-            };
-        }
-    };
-}
-
-wasmtime_environ::foreach_builtin_component_function!(define_builtins);
-
-/// Macro to define the `VMBuiltinTranscodeArray` type which contains all of the
-/// function pointers to the actual transcoder functions. This structure is read
-/// by Cranelift-generated code, hence the `repr(C)`.
-///
-/// Note that this references the `trampolines` module rather than the functions
-/// below as the `trampolines` module has the raw ABI.
-///
-/// This is modeled after the similar macros and usages in `libcalls.rs` and
-/// `vmcontext.rs`
-macro_rules! define_transcoders {
-    (
-        $(
-            $( #[$attr:meta] )*
-            $name:ident( $( $pname:ident: $param:ident ),* ) $( -> $result:ident )?;
-        )*
-    ) => {
-        /// An array that stores addresses of builtin functions. We translate code
-        /// to use indirect calls. This way, we don't have to patch the code.
-        #[repr(C)]
-        struct VMBuiltinTranscodeArray {
-            $(
-                $name: unsafe extern "C" fn(
-                    $(signature!(@ty $param),)*
-                ) $( -> signature!(@ty $result))?,
-            )*
-        }
-
-        impl VMBuiltinTranscodeArray {
-            const INIT: VMBuiltinTranscodeArray = VMBuiltinTranscodeArray {
-                $($name: trampolines::$name,)*
-            };
-        }
-    };
-}
-
-wasmtime_environ::foreach_transcoder!(define_transcoders);
-
-/// Submodule with macro-generated constants which are the actual libcall
-/// transcoders that are invoked by Cranelift. These functions have a specific
-/// ABI defined by the macro itself and will defer to the actual bodies of each
-/// implementation following this submodule.
-#[allow(improper_ctypes_definitions)]
-mod trampolines {
-    use super::VMComponentContext;
-
-    macro_rules! shims {
-        (
-            $(
-                $( #[$attr:meta] )*
-                $name:ident( $( $pname:ident: $param:ident ),* ) $( -> $result:ident )?;
-            )*
-        ) => (
-            $(
-                pub unsafe extern "C" fn $name(
-                    $($pname : signature!(@ty $param),)*
-                ) $( -> signature!(@ty $result))? {
-                    $(shims!(@validate_param $pname $param);)*
-
-                    // Always catch panics to avoid trying to unwind from Rust
-                    // into Cranelift-generated code which would lead to a Bad
-                    // Time.
-                    //
-                    // Additionally assume that every function below returns a
-                    // `Result` where errors turn into traps.
-                    let result = std::panic::catch_unwind(|| {
-                        shims!(@invoke $name() $($pname)*)
-                    });
-                    match result {
-                        Ok(Ok(ret)) => shims!(@convert_ret ret $($pname: $param)*),
-                        Ok(Err(err)) => crate::traphandlers::raise_trap(
-                            crate::traphandlers::TrapReason::User {
-                                error: err,
-                                needs_backtrace: true,
-                            },
-                        ),
-                        Err(panic) => crate::traphandlers::resume_panic(panic),
-                    }
-                }
-            )*
-        );
-
-        // Helper macro to convert a 2-tuple automatically when the last
-        // parameter is a `ptr_size` argument.
-        (@convert_ret $ret:ident) => ($ret);
-        (@convert_ret $ret:ident $retptr:ident: ptr_size) => ({
-            let (a, b) = $ret;
-            *$retptr = b;
-            a
-        });
-        (@convert_ret $ret:ident $name:ident: $ty:ident $($rest:tt)*) => (
-            shims!(@convert_ret $ret $($rest)*)
-        );
-
-        (@validate_param $arg:ident ptr_u16) => ({
-            // This should already be guaranteed by the canonical ABI and our
-            // adapter modules, but double-check here to be extra-sure. If this
-            // is a perf concern it can become a `debug_assert!`.
-            assert!(($arg as usize) % 2 == 0, "unaligned 16-bit pointer");
-        });
-        (@validate_param $arg:ident $ty:ident) => ();
-
-        // Helper macro to invoke `$m` with all of the tokens passed except for
-        // any argument named `ret2`
-        (@invoke $m:ident ($($args:tt)*)) => (super::$m($($args)*));
-
-        // ignore `ret2`-named arguments
-        (@invoke $m:ident ($($args:tt)*) ret2 $($rest:tt)*) => (
-            shims!(@invoke $m ($($args)*) $($rest)*)
-        );
-
-        // move all other arguments into the `$args` list
-        (@invoke $m:ident ($($args:tt)*) $param:ident $($rest:tt)*) => (
-            shims!(@invoke $m ($($args)* $param,) $($rest)*)
-        );
-    }
-
-    wasmtime_environ::foreach_builtin_component_function!(shims);
-    wasmtime_environ::foreach_transcoder!(shims);
-}
-
-/// This property should already be guaranteed by construction in the component
-/// model but assert it here to be extra sure. Nothing below is sound if regions
-/// can overlap.
-fn assert_no_overlap<T, U>(a: &[T], b: &[U]) {
-    let a_start = a.as_ptr() as usize;
-    let a_end = a_start + (a.len() * std::mem::size_of::<T>());
-    let b_start = b.as_ptr() as usize;
-    let b_end = b_start + (b.len() * std::mem::size_of::<U>());
-
-    if a_start < b_start {
-        assert!(a_end < b_start);
-    } else {
-        assert!(b_end < a_start);
-    }
-}
-
-/// Converts a utf8 string to a utf8 string.
-///
-/// The length provided is length of both the source and the destination
-/// buffers. No value is returned other than whether an invalid string was
-/// found.
-unsafe fn utf8_to_utf8(src: *mut u8, len: usize, dst: *mut u8) -> Result<()> {
-    let src = slice::from_raw_parts(src, len);
-    let dst = slice::from_raw_parts_mut(dst, len);
-    assert_no_overlap(src, dst);
-    log::trace!("utf8-to-utf8 {len}");
-    let src = std::str::from_utf8(src).map_err(|_| anyhow!("invalid utf8 encoding"))?;
-    dst.copy_from_slice(src.as_bytes());
-    Ok(())
-}
-
-/// Converts a utf16 string to a utf16 string.
-///
-/// The length provided is length of both the source and the destination
-/// buffers. No value is returned other than whether an invalid string was
-/// found.
-unsafe fn utf16_to_utf16(src: *mut u16, len: usize, dst: *mut u16) -> Result<()> {
-    let src = slice::from_raw_parts(src, len);
-    let dst = slice::from_raw_parts_mut(dst, len);
-    assert_no_overlap(src, dst);
-    log::trace!("utf16-to-utf16 {len}");
-    run_utf16_to_utf16(src, dst)?;
-    Ok(())
-}
-
-/// Transcodes utf16 to itself, returning whether all code points were inside of
-/// the latin1 space.
-fn run_utf16_to_utf16(src: &[u16], mut dst: &mut [u16]) -> Result<bool> {
-    let mut all_latin1 = true;
-    for ch in std::char::decode_utf16(src.iter().map(|i| u16::from_le(*i))) {
-        let ch = ch.map_err(|_| anyhow!("invalid utf16 encoding"))?;
-        all_latin1 = all_latin1 && u8::try_from(u32::from(ch)).is_ok();
-        let result = ch.encode_utf16(dst);
-        let size = result.len();
-        for item in result {
-            *item = item.to_le();
-        }
-        dst = &mut dst[size..];
-    }
-    Ok(all_latin1)
-}
-
-/// Converts a latin1 string to a latin1 string.
-///
-/// Given that all byte sequences are valid latin1 strings this is simply a
-/// memory copy.
-unsafe fn latin1_to_latin1(src: *mut u8, len: usize, dst: *mut u8) -> Result<()> {
-    let src = slice::from_raw_parts(src, len);
-    let dst = slice::from_raw_parts_mut(dst, len);
-    assert_no_overlap(src, dst);
-    log::trace!("latin1-to-latin1 {len}");
-    dst.copy_from_slice(src);
-    Ok(())
-}
-
-/// Converts a latin1 string to a utf16 string.
-///
-/// This simply inflates the latin1 characters to the u16 code points. The
-/// length provided is the same length of the source and destination buffers.
-unsafe fn latin1_to_utf16(src: *mut u8, len: usize, dst: *mut u16) -> Result<()> {
-    let src = slice::from_raw_parts(src, len);
-    let dst = slice::from_raw_parts_mut(dst, len);
-    assert_no_overlap(src, dst);
-    for (src, dst) in src.iter().zip(dst) {
-        *dst = u16::from(*src).to_le();
-    }
-    log::trace!("latin1-to-utf16 {len}");
-    Ok(())
-}
-
-/// Converts utf8 to utf16.
-///
-/// The length provided is the same unit length of both buffers, and the
-/// returned value from this function is how many u16 units were written.
-unsafe fn utf8_to_utf16(src: *mut u8, len: usize, dst: *mut u16) -> Result<usize> {
-    let src = slice::from_raw_parts(src, len);
-    let dst = slice::from_raw_parts_mut(dst, len);
-    assert_no_overlap(src, dst);
-
-    let result = run_utf8_to_utf16(src, dst)?;
-    log::trace!("utf8-to-utf16 {len} => {result}");
-    Ok(result)
-}
-
-fn run_utf8_to_utf16(src: &[u8], dst: &mut [u16]) -> Result<usize> {
-    let src = std::str::from_utf8(src).map_err(|_| anyhow!("invalid utf8 encoding"))?;
-    let mut amt = 0;
-    for (i, dst) in src.encode_utf16().zip(dst) {
-        *dst = i.to_le();
-        amt += 1;
-    }
-    Ok(amt)
-}
-
-/// Converts utf16 to utf8.
-///
-/// Each buffer is specified independently here and the returned value is a pair
-/// of the number of code units read and code units written. This might perform
-/// a partial transcode if the destination buffer is not large enough to hold
-/// the entire contents.
-unsafe fn utf16_to_utf8(
-    src: *mut u16,
-    src_len: usize,
-    dst: *mut u8,
-    dst_len: usize,
-) -> Result<(usize, usize)> {
-    let src = slice::from_raw_parts(src, src_len);
-    let mut dst = slice::from_raw_parts_mut(dst, dst_len);
-    assert_no_overlap(src, dst);
-
-    // This iterator will convert to native endianness and additionally count
-    // how many items have been read from the iterator so far. This
-    // count is used to return how many of the source code units were read.
-    let src_iter_read = Cell::new(0);
-    let src_iter = src.iter().map(|i| {
-        src_iter_read.set(src_iter_read.get() + 1);
-        u16::from_le(*i)
-    });
-
-    let mut src_read = 0;
-    let mut dst_written = 0;
-
-    for ch in std::char::decode_utf16(src_iter) {
-        let ch = ch.map_err(|_| anyhow!("invalid utf16 encoding"))?;
-
-        // If the destination doesn't have enough space for this character
-        // then the loop is ended and this function will be called later with a
-        // larger destination buffer.
-        if dst.len() < 4 && dst.len() < ch.len_utf8() {
-            break;
-        }
-
-        // Record that characters were read and then convert the `char` to
-        // utf-8, advancing the destination buffer.
-        src_read = src_iter_read.get();
-        let len = ch.encode_utf8(dst).len();
-        dst_written += len;
-        dst = &mut dst[len..];
-    }
-
-    log::trace!("utf16-to-utf8 {src_len}/{dst_len} => {src_read}/{dst_written}");
-    Ok((src_read, dst_written))
-}
-
-/// Converts latin1 to utf8.
-///
-/// Receives the independent size of both buffers and returns the number of code
-/// units read and code units written (both bytes in this case).
-///
-/// This may perform a partial encoding if the destination is not large enough.
-unsafe fn latin1_to_utf8(
-    src: *mut u8,
-    src_len: usize,
-    dst: *mut u8,
-    dst_len: usize,
-) -> Result<(usize, usize)> {
-    let src = slice::from_raw_parts(src, src_len);
-    let dst = slice::from_raw_parts_mut(dst, dst_len);
-    assert_no_overlap(src, dst);
-    let (read, written) = encoding_rs::mem::convert_latin1_to_utf8_partial(src, dst);
-    log::trace!("latin1-to-utf8 {src_len}/{dst_len} => ({read}, {written})");
-    Ok((read, written))
-}
-
-/// Converts utf16 to "latin1+utf16", probably using a utf16 encoding.
-///
-/// The length specified is the length of both the source and destination
-/// buffers. If the source string has any characters that don't fit in the
-/// latin1 code space (0xff and below) then a utf16-tagged length will be
-/// returned. Otherwise the string is "deflated" from a utf16 string to a latin1
-/// string and the latin1 length is returned.
-unsafe fn utf16_to_compact_probably_utf16(
-    src: *mut u16,
-    len: usize,
-    dst: *mut u16,
-) -> Result<usize> {
-    let src = slice::from_raw_parts(src, len);
-    let dst = slice::from_raw_parts_mut(dst, len);
-    assert_no_overlap(src, dst);
-    let all_latin1 = run_utf16_to_utf16(src, dst)?;
-    if all_latin1 {
-        let (left, dst, right) = dst.align_to_mut::<u8>();
-        assert!(left.is_empty());
-        assert!(right.is_empty());
-        for i in 0..len {
-            dst[i] = dst[2 * i];
-        }
-        log::trace!("utf16-to-compact-probably-utf16 {len} => latin1 {len}");
-        Ok(len)
-    } else {
-        log::trace!("utf16-to-compact-probably-utf16 {len} => utf16 {len}");
-        Ok(len | UTF16_TAG)
-    }
-}
-
-/// Converts a utf8 string to latin1.
-///
-/// The length specified is the same length of both the input and the output
-/// buffers.
-///
-/// Returns the number of code units read from the source and the number of code
-/// units written to the destination.
-///
-/// Note that this may not convert the entire source into the destination if the
-/// original utf8 string has usvs not representable in latin1.
-unsafe fn utf8_to_latin1(src: *mut u8, len: usize, dst: *mut u8) -> Result<(usize, usize)> {
-    let src = slice::from_raw_parts(src, len);
-    let dst = slice::from_raw_parts_mut(dst, len);
-    assert_no_overlap(src, dst);
-    let read = encoding_rs::mem::utf8_latin1_up_to(src);
-    let written = encoding_rs::mem::convert_utf8_to_latin1_lossy(&src[..read], dst);
-    log::trace!("utf8-to-latin1 {len} => ({read}, {written})");
-    Ok((read, written))
-}
-
-/// Converts a utf16 string to latin1
-///
-/// This is the same as `utf8_to_latin1` in terms of parameters/results.
-unsafe fn utf16_to_latin1(src: *mut u16, len: usize, dst: *mut u8) -> Result<(usize, usize)> {
-    let src = slice::from_raw_parts(src, len);
-    let dst = slice::from_raw_parts_mut(dst, len);
-    assert_no_overlap(src, dst);
-
-    let mut size = 0;
-    for (src, dst) in src.iter().zip(dst) {
-        let src = u16::from_le(*src);
-        match u8::try_from(src) {
-            Ok(src) => *dst = src,
-            Err(_) => break,
-        }
-        size += 1;
-    }
-    log::trace!("utf16-to-latin1 {len} => {size}");
-    Ok((size, size))
-}
-
-/// Converts a utf8 string to a utf16 string which has been partially converted
-/// as latin1 prior.
-///
-/// The original string has already been partially transcoded with
-/// `utf8_to_latin1` and that was determined to not be able to transcode the
-/// entire string. The substring of the source that couldn't be encoded into
-/// latin1 is passed here via `src` and `src_len`.
-///
-/// The destination buffer is specified by `dst` and `dst_len`. The first
-/// `latin1_bytes_so_far` bytes (not code units) of the `dst` buffer have
-/// already been filled in with latin1 characters and need to be inflated
-/// in-place to their utf16 equivalents.
-///
-/// After the initial latin1 code units have been inflated the entirety of `src`
-/// is then transcoded into the remaining space within `dst`.
-unsafe fn utf8_to_compact_utf16(
-    src: *mut u8,
-    src_len: usize,
-    dst: *mut u16,
-    dst_len: usize,
-    latin1_bytes_so_far: usize,
-) -> Result<usize> {
-    let src = slice::from_raw_parts(src, src_len);
-    let dst = slice::from_raw_parts_mut(dst, dst_len);
-    assert_no_overlap(src, dst);
-
-    let dst = inflate_latin1_bytes(dst, latin1_bytes_so_far);
-    let result = run_utf8_to_utf16(src, dst)?;
-    log::trace!("utf8-to-compact-utf16 {src_len}/{dst_len}/{latin1_bytes_so_far} => {result}");
-    Ok(result + latin1_bytes_so_far)
-}
-
-/// Same as `utf8_to_compact_utf16` but for utf16 source strings.
-unsafe fn utf16_to_compact_utf16(
-    src: *mut u16,
-    src_len: usize,
-    dst: *mut u16,
-    dst_len: usize,
-    latin1_bytes_so_far: usize,
-) -> Result<usize> {
-    let src = slice::from_raw_parts(src, src_len);
-    let dst = slice::from_raw_parts_mut(dst, dst_len);
-    assert_no_overlap(src, dst);
-
-    let dst = inflate_latin1_bytes(dst, latin1_bytes_so_far);
-    run_utf16_to_utf16(src, dst)?;
-    let result = src.len();
-    log::trace!("utf16-to-compact-utf16 {src_len}/{dst_len}/{latin1_bytes_so_far} => {result}");
-    Ok(result + latin1_bytes_so_far)
-}
-
-/// Inflates the `latin1_bytes_so_far` number of bytes written to the beginning
-/// of `dst` into u16 codepoints.
-///
-/// Returns the remaining space in the destination that can be transcoded into,
-/// slicing off the prefix of the string that was inflated from the latin1
-/// bytes.
-fn inflate_latin1_bytes(dst: &mut [u16], latin1_bytes_so_far: usize) -> &mut [u16] {
-    // Note that `latin1_bytes_so_far` is a byte measure while `dst` is a region
-    // of u16 units. This `split_at_mut` uses the byte index as an index into
-    // the u16 unit because each of the latin1 bytes will become a whole code
-    // unit in the destination which is 2 bytes large.
-    let (to_inflate, rest) = dst.split_at_mut(latin1_bytes_so_far);
-
-    // Use a byte-oriented view to inflate the original latin1 bytes.
-    let (left, mid, right) = unsafe { to_inflate.align_to_mut::<u8>() };
-    assert!(left.is_empty());
-    assert!(right.is_empty());
-    for i in (0..latin1_bytes_so_far).rev() {
-        mid[2 * i] = mid[i];
-        mid[2 * i + 1] = 0;
-    }
-
-    return rest;
-}
-
-unsafe fn resource_new32(vmctx: *mut VMComponentContext, resource: u32, rep: u32) -> Result<u32> {
-    let resource = TypeResourceTableIndex::from_u32(resource);
-    Ok(ComponentInstance::from_vmctx(vmctx, |instance| {
-        instance.resource_new32(resource, rep)
-    }))
-}
-
-unsafe fn resource_rep32(vmctx: *mut VMComponentContext, resource: u32, idx: u32) -> Result<u32> {
-    let resource = TypeResourceTableIndex::from_u32(resource);
-    ComponentInstance::from_vmctx(vmctx, |instance| instance.resource_rep32(resource, idx))
-}
-
-unsafe fn resource_drop(vmctx: *mut VMComponentContext, resource: u32, idx: u32) -> Result<u64> {
-    let resource = TypeResourceTableIndex::from_u32(resource);
-    ComponentInstance::from_vmctx(vmctx, |instance| {
-        Ok(match instance.resource_drop(resource, idx)? {
-            Some(rep) => (u64::from(rep) << 1) | 1,
-            None => 0,
-        })
-    })
-}
-
-unsafe fn resource_transfer_own(
-    vmctx: *mut VMComponentContext,
-    src_idx: u32,
-    src_table: u32,
-    dst_table: u32,
-) -> Result<u32> {
-    let src_table = TypeResourceTableIndex::from_u32(src_table);
-    let dst_table = TypeResourceTableIndex::from_u32(dst_table);
-    ComponentInstance::from_vmctx(vmctx, |instance| {
-        instance.resource_transfer_own(src_idx, src_table, dst_table)
-    })
-}
-
-unsafe fn resource_transfer_borrow(
-    vmctx: *mut VMComponentContext,
-    src_idx: u32,
-    src_table: u32,
-    dst_table: u32,
-) -> Result<u32> {
-    let src_table = TypeResourceTableIndex::from_u32(src_table);
-    let dst_table = TypeResourceTableIndex::from_u32(dst_table);
-    ComponentInstance::from_vmctx(vmctx, |instance| {
-        instance.resource_transfer_borrow(src_idx, src_table, dst_table)
-    })
-}
-
-unsafe fn resource_enter_call(vmctx: *mut VMComponentContext) -> Result<()> {
-    ComponentInstance::from_vmctx(vmctx, |instance| Ok(instance.resource_enter_call()))
-}
-
-unsafe fn resource_exit_call(vmctx: *mut VMComponentContext) -> Result<()> {
-    ComponentInstance::from_vmctx(vmctx, |instance| instance.resource_exit_call())
-}
diff --git a/crates/runtime/src/component/resources.rs b/crates/runtime/src/component/resources.rs
deleted file mode 100644
index 4c22db5569b0..000000000000
--- a/crates/runtime/src/component/resources.rs
+++ /dev/null
@@ -1,329 +0,0 @@
-//! Implementation of the canonical-ABI related intrinsics for resources in the
-//! component model.
-//!
-//! This module contains all the relevant gory details of the details of the
-//! component model related to lifting and lowering resources. For example
-//! intrinsics like `resource.new` will bottom out in calling this file, and
-//! this is where resource tables are actually defined and modified.
-//!
-//! The main types in this file are:
-//!
-//! * `ResourceTables` - the "here's everything" context which is required to
-//!   perform canonical ABI operations.
-//!
-//! * `ResourceTable` - an individual instance of a table of resources,
-//!   basically "just a slab" though.
-//!
-//! * `CallContexts` - store-local information about active calls and borrows
-//!   and runtime state tracking that to ensure that everything is handled
-//!   correctly.
-//!
-//! Individual operations are exposed through methods on `ResourceTables` for
-//! lifting/lowering/etc. This does mean though that some other fiddly bits
-//! about ABI details can be found in lifting/lowering thoughout Wasmtime,
-//! namely in the `Resource<T>` and `ResourceAny` types.
-
-use anyhow::{bail, Result};
-use std::mem;
-use wasmtime_environ::component::TypeResourceTableIndex;
-use wasmtime_environ::PrimaryMap;
-
-/// Contextual state necessary to perform resource-related operations.
-///
-/// This state a bit odd since it has a few optional bits, but the idea is that
-/// whenever this is constructed the bits required to perform operations are
-/// always `Some`. For example:
-///
-/// * During lifting and lowering both `tables` and `host_table` are `Some`.
-/// * During wasm's own intrinsics only `tables` is `Some`.
-/// * During embedder-invoked resource destruction calls only `host_table` is
-///   `Some`.
-///
-/// This is all packaged up into one state though to make it easier to operate
-/// on and to centralize handling of the state related to resources due to how
-/// critical it is for correctness.
-pub struct ResourceTables<'a> {
-    /// Runtime state for all resources defined in a component.
-    ///
-    /// This is required whenever a `TypeResourceTableIndex` is provided as it's
-    /// the lookup where that happens. Not present during embedder-originating
-    /// operations though such as `ResourceAny::resource_drop` which won't
-    /// consult this table as it's only operating over the host table.
-    pub tables: Option<&'a mut PrimaryMap<TypeResourceTableIndex, ResourceTable>>,
-
-    /// Runtime state for resources currently owned by the host.
-    ///
-    /// This is the single table used by the host stored within `Store<T>`. Host
-    /// resources will point into this and effectively have the same semantics
-    /// as-if they're in-component resources. The major distinction though is
-    /// that this is a heterogenous table instead of only containing a single
-    /// type.
-    pub host_table: Option<&'a mut ResourceTable>,
-
-    /// Scope information about calls actively in use to track information such
-    /// as borrow counts.
-    pub calls: &'a mut CallContexts,
-}
-
-/// An individual slab of resources used for a single table within a component.
-/// Not much fancier than a general slab data structure.
-#[derive(Default)]
-pub struct ResourceTable {
-    /// Next slot to allocate, or `self.slots.len()` if they're all full.
-    next: u32,
-    /// Runtime state of all slots.
-    slots: Vec<Slot>,
-}
-
-enum Slot {
-    /// This slot is free and points to the next free slot, forming a linked
-    /// list of free slots.
-    Free { next: u32 },
-
-    /// This slot contains an owned resource with the listed representation.
-    ///
-    /// The `lend_count` tracks how many times this has been lent out as a
-    /// `borrow` and if nonzero this can't be removed.
-    Own { rep: u32, lend_count: u32 },
-
-    /// This slot contains a `borrow` resource that's connected to the `scope`
-    /// provided. The `rep` is listed and dropping this borrow will decrement
-    /// the borrow count of the `scope`.
-    Borrow { rep: u32, scope: usize },
-}
-
-/// State related to borrows and calls within a component.
-///
-/// This is created once per `Store` and updated and modified throughout the
-/// lifetime of the store. This primarily tracks borrow counts and what slots
-/// should be updated when calls go out of scope.
-#[derive(Default)]
-pub struct CallContexts {
-    scopes: Vec<CallContext>,
-}
-
-#[derive(Default)]
-struct CallContext {
-    lenders: Vec<Lender>,
-    borrow_count: u32,
-}
-
-#[derive(Copy, Clone)]
-struct Lender {
-    ty: Option<TypeResourceTableIndex>,
-    idx: u32,
-}
-
-impl ResourceTables<'_> {
-    fn table(&mut self, ty: Option<TypeResourceTableIndex>) -> &mut ResourceTable {
-        match ty {
-            None => self.host_table.as_mut().unwrap(),
-            Some(idx) => &mut self.tables.as_mut().unwrap()[idx],
-        }
-    }
-
-    /// Implementation of the `resource.new` canonical intrinsic.
-    ///
-    /// Note that this is the same as `resource_lower_own`.
-    pub fn resource_new(&mut self, ty: Option<TypeResourceTableIndex>, rep: u32) -> u32 {
-        self.table(ty).insert(Slot::Own { rep, lend_count: 0 })
-    }
-
-    /// Implementation of the `resource.rep` canonical intrinsic.
-    ///
-    /// This one's one of the simpler ones: "just get the rep please"
-    pub fn resource_rep(&mut self, ty: Option<TypeResourceTableIndex>, idx: u32) -> Result<u32> {
-        self.table(ty).rep(idx)
-    }
-
-    /// Implementation of the `resource.drop` canonical intrinsic minus the
-    /// actual invocation of the destructor.
-    ///
-    /// This will drop the handle at the `idx` specified, removing it from the
-    /// specified table. This operation can fail if:
-    ///
-    /// * The index is invalid.
-    /// * The index points to an `own` resource which has active borrows.
-    ///
-    /// Otherwise this will return `Some(rep)` if the destructor for `rep` needs
-    /// to run. If `None` is returned then that means a `borrow` handle was
-    /// removed and no destructor is necessary.
-    pub fn resource_drop(
-        &mut self,
-        ty: Option<TypeResourceTableIndex>,
-        idx: u32,
-    ) -> Result<Option<u32>> {
-        match self.table(ty).remove(idx)? {
-            Slot::Own { rep, lend_count: 0 } => Ok(Some(rep)),
-            Slot::Own { .. } => bail!("cannot remove owned resource while borrowed"),
-            Slot::Borrow { scope, .. } => {
-                self.calls.scopes[scope].borrow_count -= 1;
-                Ok(None)
-            }
-            Slot::Free { .. } => unreachable!(),
-        }
-    }
-
-    /// Inserts a new "own" handle into the specified table.
-    ///
-    /// This will insert the specified representation into the specified type
-    /// table.
-    ///
-    /// Note that this operation is infallible, and additionally that this is
-    /// the same as `resource_new` implementation-wise.
-    ///
-    /// This is an implementation of the canonical ABI `lower_own` function.
-    pub fn resource_lower_own(&mut self, ty: Option<TypeResourceTableIndex>, rep: u32) -> u32 {
-        self.table(ty).insert(Slot::Own { rep, lend_count: 0 })
-    }
-
-    /// Attempts to remove an "own" handle from the specified table and its
-    /// index.
-    ///
-    /// This operation will fail if `idx` is invalid, if it's a `borrow` handle,
-    /// or if the own handle has currently been "lent" as a borrow.
-    ///
-    /// This is an implementation of the canonical ABI `lift_own` function.
-    pub fn resource_lift_own(
-        &mut self,
-        ty: Option<TypeResourceTableIndex>,
-        idx: u32,
-    ) -> Result<u32> {
-        match self.table(ty).remove(idx)? {
-            Slot::Own { rep, lend_count: 0 } => Ok(rep),
-            Slot::Own { .. } => bail!("cannot remove owned resource while borrowed"),
-            Slot::Borrow { .. } => bail!("cannot lift own resource from a borrow"),
-            Slot::Free { .. } => unreachable!(),
-        }
-    }
-
-    /// Extracts the underlying resource representation by lifting a "borrow"
-    /// from the tables.
-    ///
-    /// This primarily employs dynamic tracking when a borrow is created from an
-    /// "own" handle to ensure that the "own" handle isn't dropped while the
-    /// borrow is active and additionally that when the current call scope
-    /// returns the lend operation is undone.
-    ///
-    /// This is an implementation of the canonical ABI `lift_borrow` function.
-    pub fn resource_lift_borrow(
-        &mut self,
-        ty: Option<TypeResourceTableIndex>,
-        idx: u32,
-    ) -> Result<u32> {
-        match self.table(ty).get_mut(idx)? {
-            Slot::Own { rep, lend_count } => {
-                // The decrement to this count happens in `exit_call`.
-                *lend_count = lend_count.checked_add(1).unwrap();
-                let rep = *rep;
-                let scope = self.calls.scopes.last_mut().unwrap();
-                scope.lenders.push(Lender { ty, idx });
-                Ok(rep)
-            }
-            Slot::Borrow { rep, .. } => Ok(*rep),
-            Slot::Free { .. } => unreachable!(),
-        }
-    }
-
-    /// Records a new `borrow` resource with the given representation within the
-    /// current call scope.
-    ///
-    /// This requires that a call scope is active. Additionally the number of
-    /// active borrows in the latest scope will be increased and must be
-    /// decreased through a future use of `resource_drop` before the current
-    /// call scope exits.
-    ///
-    /// This some of the implementation of the canonical ABI `lower_borrow`
-    /// function. The other half of this implementation is located on
-    /// `VMComponentContext` which handles the special case of avoiding borrow
-    /// tracking entirely.
-    pub fn resource_lower_borrow(&mut self, ty: Option<TypeResourceTableIndex>, rep: u32) -> u32 {
-        let scope = self.calls.scopes.len() - 1;
-        let borrow_count = &mut self.calls.scopes.last_mut().unwrap().borrow_count;
-        *borrow_count = borrow_count.checked_add(1).unwrap();
-        self.table(ty).insert(Slot::Borrow { rep, scope })
-    }
-
-    /// Enters a new calling context, starting a fresh count of borrows and
-    /// such.
-    #[inline]
-    pub fn enter_call(&mut self) {
-        self.calls.scopes.push(CallContext::default());
-    }
-
-    /// Exits the previously pushed calling context.
-    ///
-    /// This requires all information to be available within this
-    /// `ResourceTables` and is only called during lowering/lifting operations
-    /// at this time.
-    #[inline]
-    pub fn exit_call(&mut self) -> Result<()> {
-        let cx = self.calls.scopes.pop().unwrap();
-        if cx.borrow_count > 0 {
-            bail!("borrow handles still remain at the end of the call")
-        }
-        for lender in cx.lenders.iter() {
-            // Note the panics here which should never get triggered in theory
-            // due to the dynamic tracking of borrows and such employed for
-            // resources.
-            match self.table(lender.ty).get_mut(lender.idx).unwrap() {
-                Slot::Own { lend_count, .. } => {
-                    *lend_count -= 1;
-                }
-                _ => unreachable!(),
-            }
-        }
-        Ok(())
-    }
-}
-
-impl ResourceTable {
-    fn next(&self) -> usize {
-        self.next as usize
-    }
-
-    fn insert(&mut self, new: Slot) -> u32 {
-        let next = self.next();
-        if next == self.slots.len() {
-            self.slots.push(Slot::Free {
-                next: self.next.checked_add(1).unwrap(),
-            });
-        }
-        let ret = self.next;
-        self.next = match mem::replace(&mut self.slots[next], new) {
-            Slot::Free { next } => next,
-            _ => unreachable!(),
-        };
-        u32::try_from(ret).unwrap()
-    }
-
-    fn rep(&self, idx: u32) -> Result<u32> {
-        match usize::try_from(idx).ok().and_then(|i| self.slots.get(i)) {
-            None | Some(Slot::Free { .. }) => bail!("unknown handle index {idx}"),
-            Some(Slot::Own { rep, .. } | Slot::Borrow { rep, .. }) => Ok(*rep),
-        }
-    }
-
-    fn get_mut(&mut self, idx: u32) -> Result<&mut Slot> {
-        match usize::try_from(idx)
-            .ok()
-            .and_then(|i| self.slots.get_mut(i))
-        {
-            None | Some(Slot::Free { .. }) => bail!("unknown handle index {idx}"),
-            Some(other) => Ok(other),
-        }
-    }
-
-    fn remove(&mut self, idx: u32) -> Result<Slot> {
-        match usize::try_from(idx).ok().and_then(|i| self.slots.get(i)) {
-            Some(Slot::Own { .. }) | Some(Slot::Borrow { .. }) => {}
-            _ => bail!("unknown handle index {idx}"),
-        };
-        let ret = mem::replace(
-            &mut self.slots[idx as usize],
-            Slot::Free { next: self.next },
-        );
-        self.next = idx;
-        Ok(ret)
-    }
-}
diff --git a/crates/runtime/src/cow.rs b/crates/runtime/src/cow.rs
deleted file mode 100644
index ccd34b828910..000000000000
--- a/crates/runtime/src/cow.rs
+++ /dev/null
@@ -1,1060 +0,0 @@
-//! Copy-on-write initialization support: creation of backing images for
-//! modules, and logic to support mapping these backing images into memory.
-
-#![cfg_attr(any(not(unix), miri), allow(unused_imports, unused_variables))]
-
-use crate::{MmapVec, SendSyncPtr};
-use anyhow::Result;
-use libc::c_void;
-use std::fs::File;
-use std::ptr::NonNull;
-use std::sync::Arc;
-use std::{convert::TryFrom, ops::Range};
-use wasmtime_environ::{
-    DefinedMemoryIndex, MemoryInitialization, MemoryPlan, MemoryStyle, Module, PrimaryMap,
-};
-
-/// Backing images for memories in a module.
-///
-/// This is meant to be built once, when a module is first loaded/constructed,
-/// and then used many times for instantiation.
-pub struct ModuleMemoryImages {
-    memories: PrimaryMap<DefinedMemoryIndex, Option<Arc<MemoryImage>>>,
-}
-
-impl ModuleMemoryImages {
-    /// Get the MemoryImage for a given memory.
-    pub fn get_memory_image(&self, defined_index: DefinedMemoryIndex) -> Option<&Arc<MemoryImage>> {
-        self.memories[defined_index].as_ref()
-    }
-}
-
-/// One backing image for one memory.
-#[derive(Debug, PartialEq)]
-pub struct MemoryImage {
-    /// The file descriptor source of this image.
-    ///
-    /// This might be an mmaped `*.cwasm` file or on Linux it could also be a
-    /// `Memfd` as an anonymous file in memory. In either case this is used as
-    /// the backing-source for the CoW image.
-    fd: FdSource,
-
-    /// Length of image, in bytes.
-    ///
-    /// Note that initial memory size may be larger; leading and trailing zeroes
-    /// are truncated (handled by backing fd).
-    ///
-    /// Must be a multiple of the system page size.
-    len: usize,
-
-    /// Image starts this many bytes into `fd` source.
-    ///
-    /// This is 0 for anonymous-backed memfd files and is the offset of the data
-    /// section in a `*.cwasm` file for `*.cwasm`-backed images.
-    ///
-    /// Must be a multiple of the system page size.
-    fd_offset: u64,
-
-    /// Image starts this many bytes into heap space.
-    ///
-    /// Must be a multiple of the system page size.
-    linear_memory_offset: usize,
-}
-
-#[derive(Debug)]
-enum FdSource {
-    #[cfg(all(unix, not(miri)))]
-    Mmap(Arc<File>),
-    #[cfg(all(target_os = "linux", not(miri)))]
-    Memfd(memfd::Memfd),
-}
-
-impl FdSource {
-    #[cfg(all(unix, not(miri)))]
-    fn as_file(&self) -> &File {
-        match self {
-            FdSource::Mmap(ref file) => file,
-            #[cfg(target_os = "linux")]
-            FdSource::Memfd(ref memfd) => memfd.as_file(),
-        }
-    }
-}
-
-impl PartialEq for FdSource {
-    fn eq(&self, other: &FdSource) -> bool {
-        cfg_if::cfg_if! {
-            if #[cfg(all(unix, not(miri)))] {
-                use rustix::fd::AsRawFd;
-                self.as_file().as_raw_fd() == other.as_file().as_raw_fd()
-            } else {
-                let _ = other;
-                match *self {}
-            }
-        }
-    }
-}
-
-impl MemoryImage {
-    fn new(
-        page_size: u32,
-        offset: u64,
-        data: &[u8],
-        mmap: Option<&MmapVec>,
-    ) -> Result<Option<MemoryImage>> {
-        // Sanity-check that various parameters are page-aligned.
-        let len = data.len();
-        assert_eq!(offset % u64::from(page_size), 0);
-        assert_eq!((len as u32) % page_size, 0);
-        let linear_memory_offset = match usize::try_from(offset) {
-            Ok(offset) => offset,
-            Err(_) => return Ok(None),
-        };
-
-        // If a backing `mmap` is present then `data` should be a sub-slice of
-        // the `mmap`. The sanity-checks here double-check that. Additionally
-        // compilation should have ensured that the `data` section is
-        // page-aligned within `mmap`, so that's also all double-checked here.
-        //
-        // Finally if the `mmap` itself comes from a backing file on disk, such
-        // as a `*.cwasm` file, then that's a valid source of data for the
-        // memory image so we simply return referencing that.
-        //
-        // Note that this path is platform-agnostic in the sense of all
-        // platforms we support support memory mapping copy-on-write data from
-        // files, but for now this is still a Linux-specific region of Wasmtime.
-        // Some work will be needed to get this file compiling for macOS and
-        // Windows.
-        #[cfg(not(any(windows, miri)))]
-        if let Some(mmap) = mmap {
-            let start = mmap.as_ptr() as usize;
-            let end = start + mmap.len();
-            let data_start = data.as_ptr() as usize;
-            let data_end = data_start + data.len();
-            assert!(start <= data_start && data_end <= end);
-            assert_eq!((start as u32) % page_size, 0);
-            assert_eq!((data_start as u32) % page_size, 0);
-            assert_eq!((data_end as u32) % page_size, 0);
-            assert_eq!((mmap.original_offset() as u32) % page_size, 0);
-
-            if let Some(file) = mmap.original_file() {
-                return Ok(Some(MemoryImage {
-                    fd: FdSource::Mmap(file.clone()),
-                    fd_offset: u64::try_from(mmap.original_offset() + (data_start - start))
-                        .unwrap(),
-                    linear_memory_offset,
-                    len,
-                }));
-            }
-        }
-
-        // If `mmap` doesn't come from a file then platform-specific mechanisms
-        // may be used to place the data in a form that's amenable to an mmap.
-
-        cfg_if::cfg_if! {
-            if #[cfg(all(target_os = "linux", not(miri)))] {
-                // On Linux `memfd_create` is used to create an anonymous
-                // in-memory file to represent the heap image. This anonymous
-                // file is then used as the basis for further mmaps.
-
-                use std::io::Write;
-
-                let memfd = match create_memfd()? {
-                    Some(memfd) => memfd,
-                    None => return Ok(None),
-                };
-                memfd.as_file().write_all(data)?;
-
-                // Seal the memfd's data and length.
-                //
-                // This is a defense-in-depth security mitigation. The
-                // memfd will serve as the starting point for the heap of
-                // every instance of this module. If anything were to
-                // write to this, it could affect every execution. The
-                // memfd object itself is owned by the machinery here and
-                // not exposed elsewhere, but it is still an ambient open
-                // file descriptor at the syscall level, so some other
-                // vulnerability that allowed writes to arbitrary fds
-                // could modify it. Or we could have some issue with the
-                // way that we map it into each instance. To be
-                // extra-super-sure that it never changes, and because
-                // this costs very little, we use the kernel's "seal" API
-                // to make the memfd image permanently read-only.
-                memfd.add_seals(&[
-                    memfd::FileSeal::SealGrow,
-                    memfd::FileSeal::SealShrink,
-                    memfd::FileSeal::SealWrite,
-                    memfd::FileSeal::SealSeal,
-                ])?;
-
-                Ok(Some(MemoryImage {
-                    fd: FdSource::Memfd(memfd),
-                    fd_offset: 0,
-                    linear_memory_offset,
-                    len,
-                }))
-            } else {
-                // Other platforms don't have an easily available way of
-                // representing the heap image as an mmap-source right now. We
-                // could theoretically create a file and immediately unlink it
-                // but that means that data may likely be preserved to disk
-                // which isn't what we want here.
-                Ok(None)
-            }
-        }
-    }
-
-    unsafe fn map_at(&self, base: *mut u8) -> Result<()> {
-        cfg_if::cfg_if! {
-            if #[cfg(all(unix, not(miri)))] {
-                let ptr = rustix::mm::mmap(
-                    base.add(self.linear_memory_offset).cast(),
-                    self.len,
-                    rustix::mm::ProtFlags::READ | rustix::mm::ProtFlags::WRITE,
-                    rustix::mm::MapFlags::PRIVATE | rustix::mm::MapFlags::FIXED,
-                    self.fd.as_file(),
-                    self.fd_offset,
-                )?;
-                assert_eq!(ptr, base.add(self.linear_memory_offset).cast());
-                Ok(())
-            } else {
-                match self.fd {}
-            }
-        }
-    }
-
-    unsafe fn remap_as_zeros_at(&self, base: *mut u8) -> Result<()> {
-        cfg_if::cfg_if! {
-            if #[cfg(unix)] {
-                let ptr = rustix::mm::mmap_anonymous(
-                    base.add(self.linear_memory_offset).cast(),
-                    self.len,
-                    rustix::mm::ProtFlags::READ | rustix::mm::ProtFlags::WRITE,
-                    rustix::mm::MapFlags::PRIVATE | rustix::mm::MapFlags::FIXED,
-                )?;
-                assert_eq!(ptr.cast(), base.add(self.linear_memory_offset));
-                Ok(())
-            } else {
-                match self.fd {}
-            }
-        }
-    }
-}
-
-#[cfg(all(target_os = "linux", not(miri)))]
-fn create_memfd() -> Result<Option<memfd::Memfd>> {
-    use std::io::ErrorKind;
-
-    // Create the memfd. It needs a name, but the
-    // documentation for `memfd_create()` says that names can
-    // be duplicated with no issues.
-    match memfd::MemfdOptions::new()
-        .allow_sealing(true)
-        .create("wasm-memory-image")
-    {
-        Ok(memfd) => Ok(Some(memfd)),
-        // If this kernel is old enough to not support memfd then attempt to
-        // gracefully handle that and fall back to skipping the memfd
-        // optimization.
-        Err(memfd::Error::Create(err)) if err.kind() == ErrorKind::Unsupported => Ok(None),
-        Err(e) => Err(e.into()),
-    }
-}
-
-impl ModuleMemoryImages {
-    /// Create a new `ModuleMemoryImages` for the given module. This can be
-    /// passed in as part of a `InstanceAllocationRequest` to speed up
-    /// instantiation and execution by using copy-on-write-backed memories.
-    pub fn new(
-        module: &Module,
-        wasm_data: &[u8],
-        mmap: Option<&MmapVec>,
-    ) -> Result<Option<ModuleMemoryImages>> {
-        let map = match &module.memory_initialization {
-            MemoryInitialization::Static { map } => map,
-            _ => return Ok(None),
-        };
-        let mut memories = PrimaryMap::with_capacity(map.len());
-        let page_size = crate::page_size() as u32;
-        for (memory_index, init) in map {
-            // mmap-based-initialization only works for defined memories with a
-            // known starting point of all zeros, so bail out if the mmeory is
-            // imported.
-            let defined_memory = match module.defined_memory_index(memory_index) {
-                Some(idx) => idx,
-                None => return Ok(None),
-            };
-
-            // If there's no initialization for this memory known then we don't
-            // need an image for the memory so push `None` and move on.
-            let init = match init {
-                Some(init) => init,
-                None => {
-                    memories.push(None);
-                    continue;
-                }
-            };
-
-            // Get the image for this wasm module  as a subslice of `wasm_data`,
-            // and then use that to try to create the `MemoryImage`. If this
-            // creation files then we fail creating `ModuleMemoryImages` since this
-            // memory couldn't be represented.
-            let data = &wasm_data[init.data.start as usize..init.data.end as usize];
-            let image = match MemoryImage::new(page_size, init.offset, data, mmap)? {
-                Some(image) => image,
-                None => return Ok(None),
-            };
-
-            let idx = memories.push(Some(Arc::new(image)));
-            assert_eq!(idx, defined_memory);
-        }
-
-        Ok(Some(ModuleMemoryImages { memories }))
-    }
-}
-
-/// Slot management of a copy-on-write image which can be reused for the pooling
-/// allocator.
-///
-/// This data structure manages a slot of linear memory, primarily in the
-/// pooling allocator, which optionally has a contiguous memory image in the
-/// middle of it. Pictorially this data structure manages a virtual memory
-/// region that looks like:
-///
-/// ```text
-///   +--------------------+-------------------+--------------+--------------+
-///   |   anonymous        |      optional     |   anonymous  |    PROT_NONE |
-///   |     zero           |       memory      |     zero     |     memory   |
-///   |    memory          |       image       |    memory    |              |
-///   +--------------------+-------------------+--------------+--------------+
-///   |                     <------+---------->
-///   |<-----+------------>         \
-///   |      \                   image.len
-///   |       \
-///   |  image.linear_memory_offset
-///   |
-///   \
-///  self.base is this virtual address
-///
-///    <------------------+------------------------------------------------>
-///                        \
-///                      static_size
-///
-///    <------------------+---------------------------------->
-///                        \
-///                      accessible
-/// ```
-///
-/// When a `MemoryImageSlot` is created it's told what the `static_size` and
-/// `accessible` limits are. Initially there is assumed to be no image in linear
-/// memory.
-///
-/// When `MemoryImageSlot::instantiate` is called then the method will perform
-/// a "synchronization" to take the image from its prior state to the new state
-/// for the image specified. The first instantiation for example will mmap the
-/// heap image into place. Upon reuse of a slot nothing happens except possibly
-/// shrinking `self.accessible`. When a new image is used then the old image is
-/// mapped to anonymous zero memory and then the new image is mapped in place.
-///
-/// A `MemoryImageSlot` is either `dirty` or it isn't. When a `MemoryImageSlot`
-/// is dirty then it is assumed that any memory beneath `self.accessible` could
-/// have any value. Instantiation cannot happen into a `dirty` slot, however, so
-/// the `MemoryImageSlot::clear_and_remain_ready` returns this memory back to
-/// its original state to mark `dirty = false`. This is done by resetting all
-/// anonymous memory back to zero and the image itself back to its initial
-/// contents.
-///
-/// On Linux this is achieved with the `madvise(MADV_DONTNEED)` syscall. This
-/// syscall will release the physical pages back to the OS but retain the
-/// original mappings, effectively resetting everything back to its initial
-/// state. Non-linux platforms will replace all memory below `self.accessible`
-/// with a fresh zero'd mmap, meaning that reuse is effectively not supported.
-#[derive(Debug)]
-pub struct MemoryImageSlot {
-    /// The base address in virtual memory of the actual heap memory.
-    ///
-    /// Bytes at this address are what is seen by the Wasm guest code.
-    base: SendSyncPtr<u8>,
-
-    /// The maximum static memory size which `self.accessible` can grow to.
-    static_size: usize,
-
-    /// An optional image that is currently being used in this linear memory.
-    ///
-    /// This can be `None` in which case memory is originally all zeros. When
-    /// `Some` the image describes where it's located within the image.
-    image: Option<Arc<MemoryImage>>,
-
-    /// The size of the heap that is readable and writable.
-    ///
-    /// Note that this may extend beyond the actual linear memory heap size in
-    /// the case of dynamic memories in use. Memory accesses to memory below
-    /// `self.accessible` may still page fault as pages are lazily brought in
-    /// but the faults will always be resolved by the kernel.
-    accessible: usize,
-
-    /// Whether this slot may have "dirty" pages (pages written by an
-    /// instantiation). Set by `instantiate()` and cleared by
-    /// `clear_and_remain_ready()`, and used in assertions to ensure
-    /// those methods are called properly.
-    ///
-    /// Invariant: if !dirty, then this memory slot contains a clean
-    /// CoW mapping of `image`, if `Some(..)`, and anonymous-zero
-    /// memory beyond the image up to `static_size`. The addresses
-    /// from offset 0 to `self.accessible` are R+W and set to zero or the
-    /// initial image content, as appropriate. Everything between
-    /// `self.accessible` and `self.static_size` is inaccessible.
-    dirty: bool,
-
-    /// Whether this MemoryImageSlot is responsible for mapping anonymous
-    /// memory (to hold the reservation while overwriting mappings
-    /// specific to this slot) in place when it is dropped. Default
-    /// on, unless the caller knows what they are doing.
-    clear_on_drop: bool,
-}
-
-impl MemoryImageSlot {
-    /// Create a new MemoryImageSlot. Assumes that there is an anonymous
-    /// mmap backing in the given range to start.
-    ///
-    /// The `accessible` parameter descibes how much of linear memory is
-    /// already mapped as R/W with all zero-bytes. The `static_size` value is
-    /// the maximum size of this image which `accessible` cannot grow beyond,
-    /// and all memory from `accessible` from `static_size` should be mapped as
-    /// `PROT_NONE` backed by zero-bytes.
-    pub(crate) fn create(base_addr: *mut c_void, accessible: usize, static_size: usize) -> Self {
-        MemoryImageSlot {
-            base: NonNull::new(base_addr.cast()).unwrap().into(),
-            static_size,
-            accessible,
-            image: None,
-            dirty: false,
-            clear_on_drop: true,
-        }
-    }
-
-    #[cfg(feature = "pooling-allocator")]
-    pub(crate) fn dummy() -> MemoryImageSlot {
-        MemoryImageSlot {
-            // This pointer isn't ever actually used so its value doesn't
-            // matter but we need to satisfy `NonNull` requirement so create a
-            // `dangling` pointer as a sentinel that should cause problems if
-            // it's actually used.
-            base: NonNull::dangling().into(),
-            static_size: 0,
-            image: None,
-            accessible: 0,
-            dirty: false,
-            clear_on_drop: false,
-        }
-    }
-
-    /// Inform the MemoryImageSlot that it should *not* clear the underlying
-    /// address space when dropped. This should be used only when the
-    /// caller will clear or reuse the address space in some other
-    /// way.
-    pub(crate) fn no_clear_on_drop(&mut self) {
-        self.clear_on_drop = false;
-    }
-
-    pub(crate) fn set_heap_limit(&mut self, size_bytes: usize) -> Result<()> {
-        assert!(size_bytes <= self.static_size);
-
-        // If the heap limit already addresses accessible bytes then no syscalls
-        // are necessary since the data is already mapped into the process and
-        // waiting to go.
-        //
-        // This is used for "dynamic" memories where memory is not always
-        // decommitted during recycling (but it's still always reset).
-        if size_bytes <= self.accessible {
-            return Ok(());
-        }
-
-        // Otherwise use `mprotect` to make the new pages read/write.
-        self.set_protection(self.accessible..size_bytes, true)?;
-        self.accessible = size_bytes;
-
-        Ok(())
-    }
-
-    /// Prepares this slot for the instantiation of a new instance with the
-    /// provided linear memory image.
-    ///
-    /// The `initial_size_bytes` parameter indicates the required initial size
-    /// of the heap for the instance. The `maybe_image` is an optional initial
-    /// image for linear memory to contains. The `style` is the way compiled
-    /// code will be accessing this memory.
-    ///
-    /// The purpose of this method is to take a previously pristine slot
-    /// (`!self.dirty`) and transform its prior state into state necessary for
-    /// the given parameters. This could include, for example:
-    ///
-    /// * More memory may be made read/write if `initial_size_bytes` is larger
-    ///   than `self.accessible`.
-    /// * For `MemoryStyle::Static` linear memory may be made `PROT_NONE` if
-    ///   `self.accessible` is larger than `initial_size_bytes`.
-    /// * If no image was previously in place or if the wrong image was
-    ///   previously in place then `mmap` may be used to setup the initial
-    ///   image.
-    pub(crate) fn instantiate(
-        &mut self,
-        initial_size_bytes: usize,
-        maybe_image: Option<&Arc<MemoryImage>>,
-        plan: &MemoryPlan,
-    ) -> Result<()> {
-        assert!(!self.dirty);
-        assert!(initial_size_bytes <= self.static_size);
-
-        // First order of business is to blow away the previous linear memory
-        // image if it doesn't match the image specified here. If one is
-        // detected then it's reset with anonymous memory which means that all
-        // of memory up to `self.accessible` will now be read/write and zero.
-        //
-        // Note that this intentionally a "small mmap" which only covers the
-        // extent of the prior initialization image in order to preserve
-        // resident memory that might come before or after the image.
-        if self.image.as_ref() != maybe_image {
-            self.remove_image()?;
-        }
-
-        // The next order of business is to ensure that `self.accessible` is
-        // appropriate. First up is to grow the read/write portion of memory if
-        // it's not large enough to accommodate `initial_size_bytes`.
-        if self.accessible < initial_size_bytes {
-            self.set_protection(self.accessible..initial_size_bytes, true)?;
-            self.accessible = initial_size_bytes;
-        }
-
-        // If (1) the accessible region is not in its initial state, and (2) the
-        // memory relies on virtual memory at all (i.e. has offset guard pages
-        // and/or is static), then we need to reset memory protections. Put
-        // another way, the only time it is safe to not reset protections is
-        // when we are using dynamic memory without any guard pages.
-        if initial_size_bytes < self.accessible
-            && (plan.offset_guard_size > 0 || matches!(plan.style, MemoryStyle::Static { .. }))
-        {
-            self.set_protection(initial_size_bytes..self.accessible, false)?;
-            self.accessible = initial_size_bytes;
-        }
-
-        // Now that memory is sized appropriately the final operation is to
-        // place the new image into linear memory. Note that this operation is
-        // skipped if `self.image` matches `maybe_image`.
-        assert!(initial_size_bytes <= self.accessible);
-        if self.image.as_ref() != maybe_image {
-            if let Some(image) = maybe_image.as_ref() {
-                assert!(
-                    image.linear_memory_offset.checked_add(image.len).unwrap()
-                        <= initial_size_bytes
-                );
-                if image.len > 0 {
-                    unsafe {
-                        image.map_at(self.base.as_ptr())?;
-                    }
-                }
-            }
-            self.image = maybe_image.cloned();
-        }
-
-        // Flag ourselves as `dirty` which means that the next operation on this
-        // slot is required to be `clear_and_remain_ready`.
-        self.dirty = true;
-
-        Ok(())
-    }
-
-    pub(crate) fn remove_image(&mut self) -> Result<()> {
-        if let Some(image) = &self.image {
-            unsafe {
-                image.remap_as_zeros_at(self.base.as_ptr())?;
-            }
-            self.image = None;
-        }
-        Ok(())
-    }
-
-    /// Resets this linear memory slot back to a "pristine state".
-    ///
-    /// This will reset the memory back to its original contents on Linux or
-    /// reset the contents back to zero on other platforms. The `keep_resident`
-    /// argument is the maximum amount of memory to keep resident in this
-    /// process's memory on Linux. Up to that much memory will be `memset` to
-    /// zero where the rest of it will be reset or released with `madvise`.
-    #[allow(dead_code)] // ignore warnings as this is only used in some cfgs
-    pub(crate) fn clear_and_remain_ready(&mut self, keep_resident: usize) -> Result<()> {
-        assert!(self.dirty);
-
-        unsafe {
-            self.reset_all_memory_contents(keep_resident)?;
-        }
-
-        self.dirty = false;
-        Ok(())
-    }
-
-    #[allow(dead_code)] // ignore warnings as this is only used in some cfgs
-    unsafe fn reset_all_memory_contents(&mut self, keep_resident: usize) -> Result<()> {
-        if !cfg!(target_os = "linux") || cfg!(miri) {
-            // If we're not on Linux then there's no generic platform way to
-            // reset memory back to its original state, so instead reset memory
-            // back to entirely zeros with an anonymous backing.
-            //
-            // Additionally the previous image, if any, is dropped here
-            // since it's no longer applicable to this mapping.
-            return self.reset_with_anon_memory();
-        }
-
-        match &self.image {
-            Some(image) => {
-                assert!(self.accessible >= image.linear_memory_offset + image.len);
-                if image.linear_memory_offset < keep_resident {
-                    // If the image starts below the `keep_resident` then
-                    // memory looks something like this:
-                    //
-                    //               up to `keep_resident` bytes
-                    //                          |
-                    //          +--------------------------+  remaining_memset
-                    //          |                          | /
-                    //  <-------------->                <------->
-                    //
-                    //                              image_end
-                    // 0        linear_memory_offset   |             accessible
-                    // |                |              |                  |
-                    // +----------------+--------------+---------+--------+
-                    // |  dirty memory  |    image     |   dirty memory   |
-                    // +----------------+--------------+---------+--------+
-                    //
-                    //  <------+-------> <-----+----->  <---+---> <--+--->
-                    //         |               |            |        |
-                    //         |               |            |        |
-                    //   memset (1)            /            |   madvise (4)
-                    //                  mmadvise (2)       /
-                    //                                    /
-                    //                              memset (3)
-                    //
-                    //
-                    // In this situation there are two disjoint regions that are
-                    // `memset` manually to zero. Note that `memset (3)` may be
-                    // zero bytes large. Furthermore `madvise (4)` may also be
-                    // zero bytes large.
-
-                    let image_end = image.linear_memory_offset + image.len;
-                    let mem_after_image = self.accessible - image_end;
-                    let remaining_memset =
-                        (keep_resident - image.linear_memory_offset).min(mem_after_image);
-
-                    // This is memset (1)
-                    std::ptr::write_bytes(self.base.as_ptr(), 0u8, image.linear_memory_offset);
-
-                    // This is madvise (2)
-                    self.madvise_reset(image.linear_memory_offset, image.len)?;
-
-                    // This is memset (3)
-                    std::ptr::write_bytes(self.base.as_ptr().add(image_end), 0u8, remaining_memset);
-
-                    // This is madvise (4)
-                    self.madvise_reset(
-                        image_end + remaining_memset,
-                        mem_after_image - remaining_memset,
-                    )?;
-                } else {
-                    // If the image starts after the `keep_resident` threshold
-                    // then we memset the start of linear memory and then use
-                    // madvise below for the rest of it, including the image.
-                    //
-                    // 0             keep_resident                   accessible
-                    // |                |                                 |
-                    // +----------------+---+----------+------------------+
-                    // |  dirty memory      |  image   |   dirty memory   |
-                    // +----------------+---+----------+------------------+
-                    //
-                    //  <------+-------> <-------------+----------------->
-                    //         |                       |
-                    //         |                       |
-                    //   memset (1)                 madvise (2)
-                    //
-                    // Here only a single memset is necessary since the image
-                    // started after the threshold which we're keeping resident.
-                    // Note that the memset may be zero bytes here.
-
-                    // This is memset (1)
-                    std::ptr::write_bytes(self.base.as_ptr(), 0u8, keep_resident);
-
-                    // This is madvise (2)
-                    self.madvise_reset(keep_resident, self.accessible - keep_resident)?;
-                }
-            }
-
-            // If there's no memory image for this slot then memset the first
-            // bytes in the memory back to zero while using `madvise` to purge
-            // the rest.
-            None => {
-                let size_to_memset = keep_resident.min(self.accessible);
-                std::ptr::write_bytes(self.base.as_ptr(), 0u8, size_to_memset);
-                self.madvise_reset(size_to_memset, self.accessible - size_to_memset)?;
-            }
-        }
-
-        Ok(())
-    }
-
-    #[allow(dead_code)] // ignore warnings as this is only used in some cfgs
-    unsafe fn madvise_reset(&self, base: usize, len: usize) -> Result<()> {
-        assert!(base + len <= self.accessible);
-        if len == 0 {
-            return Ok(());
-        }
-        cfg_if::cfg_if! {
-            if #[cfg(target_os = "linux")] {
-                rustix::mm::madvise(
-                    self.base.as_ptr().add(base).cast(),
-                    len,
-                    rustix::mm::Advice::LinuxDontNeed,
-                )?;
-                Ok(())
-            } else {
-                unreachable!();
-            }
-        }
-    }
-
-    fn set_protection(&self, range: Range<usize>, readwrite: bool) -> Result<()> {
-        assert!(range.start <= range.end);
-        assert!(range.end <= self.static_size);
-        if range.len() == 0 {
-            return Ok(());
-        }
-
-        unsafe {
-            let start = self.base.as_ptr().add(range.start);
-            cfg_if::cfg_if! {
-                if #[cfg(miri)] {
-                    if readwrite {
-                        std::ptr::write_bytes(start, 0u8, range.len());
-                    }
-                } else if #[cfg(unix)] {
-                    let flags = if readwrite {
-                        rustix::mm::MprotectFlags::READ | rustix::mm::MprotectFlags::WRITE
-                    } else {
-                        rustix::mm::MprotectFlags::empty()
-                    };
-                    rustix::mm::mprotect(start.cast(), range.len(), flags)?;
-                } else {
-                    use windows_sys::Win32::System::Memory::*;
-
-                    let failure = if readwrite {
-                        VirtualAlloc(start.cast(), range.len(), MEM_COMMIT, PAGE_READWRITE).is_null()
-                    } else {
-                        VirtualFree(start.cast(), range.len(), MEM_DECOMMIT) == 0
-                    };
-                    if failure {
-                        return Err(std::io::Error::last_os_error().into());
-                    }
-                }
-            }
-        }
-
-        Ok(())
-    }
-
-    pub(crate) fn has_image(&self) -> bool {
-        self.image.is_some()
-    }
-
-    #[allow(dead_code)] // ignore warnings as this is only used in some cfgs
-    pub(crate) fn is_dirty(&self) -> bool {
-        self.dirty
-    }
-
-    /// Map anonymous zeroed memory across the whole slot,
-    /// inaccessible. Used both during instantiate and during drop.
-    fn reset_with_anon_memory(&mut self) -> Result<()> {
-        if self.static_size == 0 {
-            assert!(self.image.is_none());
-            assert_eq!(self.accessible, 0);
-            return Ok(());
-        }
-
-        unsafe {
-            cfg_if::cfg_if! {
-                if #[cfg(miri)] {
-                    std::ptr::write_bytes(self.base.as_ptr(), 0, self.static_size);
-                } else if #[cfg(unix)] {
-                    let ptr = rustix::mm::mmap_anonymous(
-                        self.base.as_ptr().cast(),
-                        self.static_size,
-                        rustix::mm::ProtFlags::empty(),
-                        rustix::mm::MapFlags::PRIVATE | rustix::mm::MapFlags::FIXED,
-                    )?;
-                    assert_eq!(ptr, self.base.as_ptr().cast());
-                } else {
-                    use windows_sys::Win32::System::Memory::*;
-                    if VirtualFree(self.base.as_ptr().cast(), self.static_size, MEM_DECOMMIT) == 0 {
-                        return Err(std::io::Error::last_os_error().into());
-                    }
-                }
-            }
-        }
-
-        self.image = None;
-        self.accessible = 0;
-
-        Ok(())
-    }
-}
-
-impl Drop for MemoryImageSlot {
-    fn drop(&mut self) {
-        // The MemoryImageSlot may be dropped if there is an error during
-        // instantiation: for example, if a memory-growth limiter
-        // disallows a guest from having a memory of a certain size,
-        // after we've already initialized the MemoryImageSlot.
-        //
-        // We need to return this region of the large pool mmap to a
-        // safe state (with no module-specific mappings). The
-        // MemoryImageSlot will not be returned to the MemoryPool, so a new
-        // MemoryImageSlot will be created and overwrite the mappings anyway
-        // on the slot's next use; but for safety and to avoid
-        // resource leaks it's better not to have stale mappings to a
-        // possibly-otherwise-dead module's image.
-        //
-        // To "wipe the slate clean", let's do a mmap of anonymous
-        // memory over the whole region, with PROT_NONE. Note that we
-        // *can't* simply munmap, because that leaves a hole in the
-        // middle of the pooling allocator's big memory area that some
-        // other random mmap may swoop in and take, to be trampled
-        // over by the next MemoryImageSlot later.
-        //
-        // Since we're in drop(), we can't sanely return an error if
-        // this mmap fails. Instead though the result is unwrapped here to
-        // trigger a panic if something goes wrong. Otherwise if this
-        // reset-the-mapping fails then on reuse it might be possible, depending
-        // on precisely where errors happened, that stale memory could get
-        // leaked through.
-        //
-        // The exception to all of this is if the `clear_on_drop` flag
-        // (which is set by default) is false. If so, the owner of
-        // this MemoryImageSlot has indicated that it will clean up in some
-        // other way.
-        if self.clear_on_drop {
-            self.reset_with_anon_memory().unwrap();
-        }
-    }
-}
-
-#[cfg(all(test, target_os = "linux", not(miri)))]
-mod test {
-    use std::sync::Arc;
-
-    use super::{FdSource, MemoryImage, MemoryImageSlot, MemoryPlan, MemoryStyle};
-    use crate::mmap::Mmap;
-    use anyhow::Result;
-    use std::io::Write;
-    use wasmtime_environ::Memory;
-
-    fn create_memfd() -> Result<memfd::Memfd> {
-        Ok(super::create_memfd()?.expect("kernel doesn't support memfd"))
-    }
-
-    fn create_memfd_with_data(offset: usize, data: &[u8]) -> Result<MemoryImage> {
-        // Offset must be page-aligned.
-        let page_size = crate::page_size();
-        assert_eq!(offset & (page_size - 1), 0);
-        let memfd = create_memfd()?;
-        memfd.as_file().write_all(data)?;
-
-        // The image length is rounded up to the nearest page size
-        let image_len = (data.len() + page_size - 1) & !(page_size - 1);
-        memfd.as_file().set_len(image_len as u64)?;
-
-        Ok(MemoryImage {
-            fd: FdSource::Memfd(memfd),
-            len: image_len,
-            fd_offset: 0,
-            linear_memory_offset: offset,
-        })
-    }
-
-    fn dummy_memory_plan(style: MemoryStyle) -> MemoryPlan {
-        MemoryPlan {
-            style,
-            memory: Memory {
-                minimum: 0,
-                maximum: None,
-                shared: false,
-                memory64: false,
-            },
-            pre_guard_size: 0,
-            offset_guard_size: 0,
-        }
-    }
-
-    #[test]
-    fn instantiate_no_image() {
-        let plan = dummy_memory_plan(MemoryStyle::Static { bound: 4 << 30 });
-        // 4 MiB mmap'd area, not accessible
-        let mut mmap = Mmap::accessible_reserved(0, 4 << 20).unwrap();
-        // Create a MemoryImageSlot on top of it
-        let mut memfd = MemoryImageSlot::create(mmap.as_mut_ptr() as *mut _, 0, 4 << 20);
-        memfd.no_clear_on_drop();
-        assert!(!memfd.is_dirty());
-        // instantiate with 64 KiB initial size
-        memfd.instantiate(64 << 10, None, &plan).unwrap();
-        assert!(memfd.is_dirty());
-        // We should be able to access this 64 KiB (try both ends) and
-        // it should consist of zeroes.
-        let slice = unsafe { mmap.slice_mut(0..65536) };
-        assert_eq!(0, slice[0]);
-        assert_eq!(0, slice[65535]);
-        slice[1024] = 42;
-        assert_eq!(42, slice[1024]);
-        // grow the heap
-        memfd.set_heap_limit(128 << 10).unwrap();
-        let slice = unsafe { mmap.slice(0..1 << 20) };
-        assert_eq!(42, slice[1024]);
-        assert_eq!(0, slice[131071]);
-        // instantiate again; we should see zeroes, even as the
-        // reuse-anon-mmap-opt kicks in
-        memfd.clear_and_remain_ready(0).unwrap();
-        assert!(!memfd.is_dirty());
-        memfd.instantiate(64 << 10, None, &plan).unwrap();
-        let slice = unsafe { mmap.slice(0..65536) };
-        assert_eq!(0, slice[1024]);
-    }
-
-    #[test]
-    fn instantiate_image() {
-        let plan = dummy_memory_plan(MemoryStyle::Static { bound: 4 << 30 });
-        // 4 MiB mmap'd area, not accessible
-        let mut mmap = Mmap::accessible_reserved(0, 4 << 20).unwrap();
-        // Create a MemoryImageSlot on top of it
-        let mut memfd = MemoryImageSlot::create(mmap.as_mut_ptr() as *mut _, 0, 4 << 20);
-        memfd.no_clear_on_drop();
-        // Create an image with some data.
-        let image = Arc::new(create_memfd_with_data(4096, &[1, 2, 3, 4]).unwrap());
-        // Instantiate with this image
-        memfd.instantiate(64 << 10, Some(&image), &plan).unwrap();
-        assert!(memfd.has_image());
-        let slice = unsafe { mmap.slice_mut(0..65536) };
-        assert_eq!(&[1, 2, 3, 4], &slice[4096..4100]);
-        slice[4096] = 5;
-        // Clear and re-instantiate same image
-        memfd.clear_and_remain_ready(0).unwrap();
-        memfd.instantiate(64 << 10, Some(&image), &plan).unwrap();
-        let slice = unsafe { mmap.slice_mut(0..65536) };
-        // Should not see mutation from above
-        assert_eq!(&[1, 2, 3, 4], &slice[4096..4100]);
-        // Clear and re-instantiate no image
-        memfd.clear_and_remain_ready(0).unwrap();
-        memfd.instantiate(64 << 10, None, &plan).unwrap();
-        assert!(!memfd.has_image());
-        let slice = unsafe { mmap.slice_mut(0..65536) };
-        assert_eq!(&[0, 0, 0, 0], &slice[4096..4100]);
-        // Clear and re-instantiate image again
-        memfd.clear_and_remain_ready(0).unwrap();
-        memfd.instantiate(64 << 10, Some(&image), &plan).unwrap();
-        let slice = unsafe { mmap.slice_mut(0..65536) };
-        assert_eq!(&[1, 2, 3, 4], &slice[4096..4100]);
-        // Create another image with different data.
-        let image2 = Arc::new(create_memfd_with_data(4096, &[10, 11, 12, 13]).unwrap());
-        memfd.clear_and_remain_ready(0).unwrap();
-        memfd.instantiate(128 << 10, Some(&image2), &plan).unwrap();
-        let slice = unsafe { mmap.slice_mut(0..65536) };
-        assert_eq!(&[10, 11, 12, 13], &slice[4096..4100]);
-        // Instantiate the original image again; we should notice it's
-        // a different image and not reuse the mappings.
-        memfd.clear_and_remain_ready(0).unwrap();
-        memfd.instantiate(64 << 10, Some(&image), &plan).unwrap();
-        let slice = unsafe { mmap.slice_mut(0..65536) };
-        assert_eq!(&[1, 2, 3, 4], &slice[4096..4100]);
-    }
-
-    #[test]
-    #[cfg(target_os = "linux")]
-    fn memset_instead_of_madvise() {
-        let plan = dummy_memory_plan(MemoryStyle::Static { bound: 100 });
-        let mut mmap = Mmap::accessible_reserved(0, 4 << 20).unwrap();
-        let mut memfd = MemoryImageSlot::create(mmap.as_mut_ptr() as *mut _, 0, 4 << 20);
-        memfd.no_clear_on_drop();
-
-        // Test basics with the image
-        for image_off in [0, 4096, 8 << 10] {
-            let image = Arc::new(create_memfd_with_data(image_off, &[1, 2, 3, 4]).unwrap());
-            for amt_to_memset in [0, 4096, 10 << 12, 1 << 20, 10 << 20] {
-                memfd.instantiate(64 << 10, Some(&image), &plan).unwrap();
-                assert!(memfd.has_image());
-                let slice = unsafe { mmap.slice_mut(0..64 << 10) };
-                if image_off > 0 {
-                    assert_eq!(slice[image_off - 1], 0);
-                }
-                assert_eq!(slice[image_off + 5], 0);
-                assert_eq!(&[1, 2, 3, 4], &slice[image_off..][..4]);
-                slice[image_off] = 5;
-                assert_eq!(&[5, 2, 3, 4], &slice[image_off..][..4]);
-                memfd.clear_and_remain_ready(amt_to_memset).unwrap();
-            }
-        }
-
-        // Test without an image
-        for amt_to_memset in [0, 4096, 10 << 12, 1 << 20, 10 << 20] {
-            memfd.instantiate(64 << 10, None, &plan).unwrap();
-            let mem = unsafe { mmap.slice_mut(0..64 << 10) };
-            for chunk in mem.chunks_mut(1024) {
-                assert_eq!(chunk[0], 0);
-                chunk[0] = 5;
-            }
-            memfd.clear_and_remain_ready(amt_to_memset).unwrap();
-        }
-    }
-
-    #[test]
-    #[cfg(target_os = "linux")]
-    fn dynamic() {
-        let plan = dummy_memory_plan(MemoryStyle::Dynamic { reserve: 200 });
-
-        let mut mmap = Mmap::accessible_reserved(0, 4 << 20).unwrap();
-        let mut memfd = MemoryImageSlot::create(mmap.as_mut_ptr() as *mut _, 0, 4 << 20);
-        memfd.no_clear_on_drop();
-        let image = Arc::new(create_memfd_with_data(4096, &[1, 2, 3, 4]).unwrap());
-        let initial = 64 << 10;
-
-        // Instantiate the image and test that memory remains accessible after
-        // it's cleared.
-        memfd.instantiate(initial, Some(&image), &plan).unwrap();
-        assert!(memfd.has_image());
-        let slice = unsafe { mmap.slice_mut(0..(64 << 10) + 4096) };
-        assert_eq!(&[1, 2, 3, 4], &slice[4096..4100]);
-        slice[4096] = 5;
-        assert_eq!(&[5, 2, 3, 4], &slice[4096..4100]);
-        memfd.clear_and_remain_ready(0).unwrap();
-        assert_eq!(&[1, 2, 3, 4], &slice[4096..4100]);
-
-        // Re-instantiate make sure it preserves memory. Grow a bit and set data
-        // beyond the initial size.
-        memfd.instantiate(initial, Some(&image), &plan).unwrap();
-        assert_eq!(&[1, 2, 3, 4], &slice[4096..4100]);
-        memfd.set_heap_limit(initial * 2).unwrap();
-        assert_eq!(&[0, 0], &slice[initial..initial + 2]);
-        slice[initial] = 100;
-        assert_eq!(&[100, 0], &slice[initial..initial + 2]);
-        memfd.clear_and_remain_ready(0).unwrap();
-
-        // Test that memory is still accessible, but it's been reset
-        assert_eq!(&[0, 0], &slice[initial..initial + 2]);
-
-        // Instantiate again, and again memory beyond the initial size should
-        // still be accessible. Grow into it again and make sure it works.
-        memfd.instantiate(initial, Some(&image), &plan).unwrap();
-        assert_eq!(&[0, 0], &slice[initial..initial + 2]);
-        memfd.set_heap_limit(initial * 2).unwrap();
-        assert_eq!(&[0, 0], &slice[initial..initial + 2]);
-        slice[initial] = 100;
-        assert_eq!(&[100, 0], &slice[initial..initial + 2]);
-        memfd.clear_and_remain_ready(0).unwrap();
-
-        // Reset the image to none and double-check everything is back to zero
-        memfd.instantiate(64 << 10, None, &plan).unwrap();
-        assert!(!memfd.has_image());
-        assert_eq!(&[0, 0, 0, 0], &slice[4096..4100]);
-        assert_eq!(&[0, 0], &slice[initial..initial + 2]);
-    }
-}
diff --git a/crates/runtime/src/externref.rs b/crates/runtime/src/externref.rs
deleted file mode 100644
index 87ea76cd9e1b..000000000000
--- a/crates/runtime/src/externref.rs
+++ /dev/null
@@ -1,1073 +0,0 @@
-//! # `VMExternRef`
-//!
-//! `VMExternRef` is a reference-counted box for any kind of data that is
-//! external and opaque to running Wasm. Sometimes it might hold a Wasmtime
-//! thing, other times it might hold something from a Wasmtime embedder and is
-//! opaque even to us. It is morally equivalent to `Rc<dyn Any>` in Rust, but
-//! additionally always fits in a pointer-sized word. `VMExternRef` is
-//! non-nullable, but `Option<VMExternRef>` is a null pointer.
-//!
-//! The one part of `VMExternRef` that can't ever be opaque to us is the
-//! reference count. Even when we don't know what's inside an `VMExternRef`, we
-//! need to be able to manipulate its reference count as we add and remove
-//! references to it. And we need to do this from compiled Wasm code, so it must
-//! be `repr(C)`!
-//!
-//! ## Memory Layout
-//!
-//! `VMExternRef` itself is just a pointer to an `VMExternData`, which holds the
-//! opaque, boxed value, its reference count, and its vtable pointer.
-//!
-//! The `VMExternData` struct is *preceded* by the dynamically-sized value boxed
-//! up and referenced by one or more `VMExternRef`s:
-//!
-//! ```text
-//!      ,-------------------------------------------------------.
-//!      |                                                       |
-//!      V                                                       |
-//!     +----------------------------+-----------+-----------+   |
-//!     | dynamically-sized value... | ref_count | value_ptr |---'
-//!     +----------------------------+-----------+-----------+
-//!                                  | VMExternData          |
-//!                                  +-----------------------+
-//!                                   ^
-//! +-------------+                   |
-//! | VMExternRef |-------------------+
-//! +-------------+                   |
-//!                                   |
-//! +-------------+                   |
-//! | VMExternRef |-------------------+
-//! +-------------+                   |
-//!                                   |
-//!   ...                            ===
-//!                                   |
-//! +-------------+                   |
-//! | VMExternRef |-------------------'
-//! +-------------+
-//! ```
-//!
-//! The `value_ptr` member always points backwards to the start of the
-//! dynamically-sized value (which is also the start of the heap allocation for
-//! this value-and-`VMExternData` pair). Because it is a `dyn` pointer, it is
-//! fat, and also points to the value's `Any` vtable.
-//!
-//! The boxed value and the `VMExternRef` footer are held a single heap
-//! allocation. The layout described above is used to make satisfying the
-//! value's alignment easy: we just need to ensure that the heap allocation used
-//! to hold everything satisfies its alignment. It also ensures that we don't
-//! need a ton of excess padding between the `VMExternData` and the value for
-//! values with large alignment.
-//!
-//! ## Reference Counting, Wasm Functions, and Garbage Collection
-//!
-//! For host VM code, we use plain reference counting, where cloning increments
-//! the reference count, and dropping decrements it. We can avoid many of the
-//! on-stack increment/decrement operations that typically plague the
-//! performance of reference counting via Rust's ownership and borrowing system.
-//! Moving a `VMExternRef` avoids mutating its reference count, and borrowing it
-//! either avoids the reference count increment or delays it until if/when the
-//! `VMExternRef` is cloned.
-//!
-//! When passing a `VMExternRef` into compiled Wasm code, we don't want to do
-//! reference count mutations for every compiled `local.{get,set}`, nor for
-//! every function call. Therefore, we use a variation of **deferred reference
-//! counting**, where we only mutate reference counts when storing
-//! `VMExternRef`s somewhere that outlives the activation: into a global or
-//! table. Simultaneously, we over-approximate the set of `VMExternRef`s that
-//! are inside Wasm function activations. Periodically, we walk the stack at GC
-//! safe points, and use stack map information to precisely identify the set of
-//! `VMExternRef`s inside Wasm activations. Then we take the difference between
-//! this precise set and our over-approximation, and decrement the reference
-//! count for each of the `VMExternRef`s that are in our over-approximation but
-//! not in the precise set. Finally, the over-approximation is replaced with the
-//! precise set.
-//!
-//! The `VMExternRefActivationsTable` implements the over-approximized set of
-//! `VMExternRef`s referenced by Wasm activations. Calling a Wasm function and
-//! passing it a `VMExternRef` moves the `VMExternRef` into the table, and the
-//! compiled Wasm function logically "borrows" the `VMExternRef` from the
-//! table. Similarly, `global.get` and `table.get` operations clone the gotten
-//! `VMExternRef` into the `VMExternRefActivationsTable` and then "borrow" the
-//! reference out of the table.
-//!
-//! When a `VMExternRef` is returned to host code from a Wasm function, the host
-//! increments the reference count (because the reference is logically
-//! "borrowed" from the `VMExternRefActivationsTable` and the reference count
-//! from the table will be dropped at the next GC).
-//!
-//! For more general information on deferred reference counting, see *An
-//! Examination of Deferred Reference Counting and Cycle Detection* by Quinane:
-//! <https://openresearch-repository.anu.edu.au/bitstream/1885/42030/2/hon-thesis.pdf>
-
-use crate::{Backtrace, SendSyncPtr, VMRuntimeLimits};
-use std::alloc::Layout;
-use std::any::Any;
-use std::cell::UnsafeCell;
-use std::cmp;
-use std::collections::HashSet;
-use std::hash::{Hash, Hasher};
-use std::mem;
-use std::ops::Deref;
-use std::ptr::{self, NonNull};
-use std::sync::atomic::{self, AtomicUsize, Ordering};
-use wasmtime_environ::StackMap;
-
-/// An external reference to some opaque data.
-///
-/// `VMExternRef`s dereference to their underlying opaque data as `dyn Any`.
-///
-/// Unlike the `externref` in the Wasm spec, `VMExternRef`s are non-nullable,
-/// and always point to a valid value. You may use `Option<VMExternRef>` to
-/// represent nullable references, and `Option<VMExternRef>` is guaranteed to
-/// have the same size and alignment as a raw pointer, with `None` represented
-/// with the null pointer.
-///
-/// `VMExternRef`s are reference counted, so cloning is a cheap, shallow
-/// operation. It also means they are inherently shared, so you may not get a
-/// mutable, exclusive reference to their inner contents, only a shared,
-/// immutable reference. You may use interior mutability with `RefCell` or
-/// `Mutex` to work around this restriction, if necessary.
-///
-/// `VMExternRef`s have pointer-equality semantics, not structural-equality
-/// semantics. Given two `VMExternRef`s `a` and `b`, `a == b` only if `a` and
-/// `b` point to the same allocation. `a` and `b` are considered not equal, even
-/// if `a` and `b` are two different identical copies of the same data, if they
-/// are in two different allocations. The hashing and ordering implementations
-/// also only operate on the pointer.
-///
-/// # Example
-///
-/// ```
-/// # fn foo() -> Result<(), Box<dyn std::error::Error>> {
-/// use std::cell::RefCell;
-/// use wasmtime_runtime::VMExternRef;
-///
-/// // Open a file. Wasm doesn't know about files, but we can let Wasm instances
-/// // work with files via opaque `externref` handles.
-/// let file = std::fs::File::create("some/file/path")?;
-///
-/// // Wrap the file up as an `VMExternRef` that can be passed to Wasm.
-/// let extern_ref_to_file = VMExternRef::new(file);
-///
-/// // `VMExternRef`s dereference to `dyn Any`, so you can use `Any` methods to
-/// // perform runtime type checks and downcasts.
-///
-/// assert!(extern_ref_to_file.is::<std::fs::File>());
-/// assert!(!extern_ref_to_file.is::<String>());
-///
-/// if let Some(mut file) = extern_ref_to_file.downcast_ref::<std::fs::File>() {
-///     use std::io::Write;
-///     writeln!(&mut file, "Hello, `VMExternRef`!")?;
-/// }
-/// # Ok(())
-/// # }
-/// ```
-#[derive(Debug)]
-#[repr(transparent)]
-pub struct VMExternRef(SendSyncPtr<VMExternData>);
-
-impl std::fmt::Pointer for VMExternRef {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        std::fmt::Pointer::fmt(&self.0, f)
-    }
-}
-
-#[repr(C)]
-pub(crate) struct VMExternData {
-    // Implicit, dynamically-sized member that always preceded an
-    // `VMExternData`.
-    //
-    // value: [u8],
-    //
-    /// The reference count for this `VMExternData` and value. When it reaches
-    /// zero, we can safely destroy the value and free this heap
-    /// allocation. This is an `UnsafeCell`, rather than plain `Cell`, because
-    /// it can be modified by compiled Wasm code.
-    ///
-    /// Note: this field's offset must be kept in sync with
-    /// `wasmtime_environ::VMOffsets::vm_extern_data_ref_count()` which is
-    /// currently always zero.
-    ref_count: AtomicUsize,
-
-    /// Always points to the implicit, dynamically-sized `value` member that
-    /// precedes this `VMExternData`.
-    value_ptr: SendSyncPtr<dyn Any + Send + Sync>,
-}
-
-impl Clone for VMExternRef {
-    #[inline]
-    fn clone(&self) -> VMExternRef {
-        self.extern_data().increment_ref_count();
-        VMExternRef(self.0)
-    }
-}
-
-impl Drop for VMExternRef {
-    #[inline]
-    fn drop(&mut self) {
-        let data = self.extern_data();
-
-        // Note that the memory orderings here also match the standard library
-        // itself. Documentation is more available in the implementation of
-        // `Arc`, but the general idea is that this is a special pattern allowed
-        // by the C standard with atomic orderings where we "release" for all
-        // the decrements and only the final decrementer performs an acquire
-        // fence. This properly ensures that the final thread, which actually
-        // destroys the data, sees all the updates from all other threads.
-        if data.ref_count.fetch_sub(1, Ordering::Release) != 1 {
-            return;
-        }
-        atomic::fence(Ordering::Acquire);
-
-        unsafe {
-            VMExternData::drop_and_dealloc(self.0);
-        }
-    }
-}
-
-impl VMExternData {
-    /// Get the `Layout` for a value with the given size and alignment, and the
-    /// offset within that layout where the `VMExternData` footer resides.
-    ///
-    /// This doesn't take a `value: &T` because `VMExternRef::new_with` hasn't
-    /// constructed a `T` value yet, and it isn't generic over `T` because
-    /// `VMExternData::drop_and_dealloc` doesn't know what `T` to use, and has
-    /// to use `std::mem::{size,align}_of_val` instead.
-    unsafe fn layout_for(value_size: usize, value_align: usize) -> (Layout, usize) {
-        let extern_data_size = mem::size_of::<VMExternData>();
-        let extern_data_align = mem::align_of::<VMExternData>();
-
-        let value_and_padding_size = round_up_to_align(value_size, extern_data_align).unwrap();
-
-        let alloc_align = std::cmp::max(value_align, extern_data_align);
-        let alloc_size = value_and_padding_size + extern_data_size;
-
-        debug_assert!(
-            Layout::from_size_align(alloc_size, alloc_align).is_ok(),
-            "should create a `Layout` for size={} and align={} okay",
-            alloc_size,
-            alloc_align,
-        );
-        (
-            Layout::from_size_align_unchecked(alloc_size, alloc_align),
-            value_and_padding_size,
-        )
-    }
-
-    /// Drop the inner value and then free this `VMExternData` heap allocation.
-    pub(crate) unsafe fn drop_and_dealloc(mut data: SendSyncPtr<VMExternData>) {
-        log::trace!("Dropping externref data @ {:p}", data);
-
-        // Note: we introduce a block scope so that we drop the live
-        // reference to the data before we free the heap allocation it
-        // resides within after this block.
-        let (alloc_ptr, layout) = {
-            let data = data.as_mut();
-            debug_assert_eq!(data.ref_count.load(Ordering::SeqCst), 0);
-
-            // Same thing, but for the dropping the reference to `value` before
-            // we drop it itself.
-            let (layout, _) = {
-                let value = data.value_ptr.as_ref();
-                Self::layout_for(mem::size_of_val(value), mem::align_of_val(value))
-            };
-
-            ptr::drop_in_place(data.value_ptr.as_ptr());
-            let alloc_ptr = data.value_ptr.as_ptr().cast::<u8>();
-
-            (alloc_ptr, layout)
-        };
-
-        ptr::drop_in_place(data.as_ptr());
-        std::alloc::dealloc(alloc_ptr, layout);
-    }
-
-    #[inline]
-    fn increment_ref_count(&self) {
-        // This is only using during cloning operations, and like the standard
-        // library we use `Relaxed` here. The rationale is better documented in
-        // libstd's implementation of `Arc`, but the general gist is that we're
-        // creating a new pointer for our own thread, so there's no need to have
-        // any synchronization with orderings. The synchronization with other
-        // threads with respect to orderings happens when the pointer is sent to
-        // another thread.
-        self.ref_count.fetch_add(1, Ordering::Relaxed);
-    }
-}
-
-#[inline]
-fn round_up_to_align(n: usize, align: usize) -> Option<usize> {
-    debug_assert!(align.is_power_of_two());
-    let align_minus_one = align - 1;
-    Some(n.checked_add(align_minus_one)? & !align_minus_one)
-}
-
-impl VMExternRef {
-    /// Wrap the given value inside an `VMExternRef`.
-    pub fn new<T>(value: T) -> VMExternRef
-    where
-        T: 'static + Any + Send + Sync,
-    {
-        VMExternRef::new_with(|| value)
-    }
-
-    /// Construct a new `VMExternRef` in place by invoking `make_value`.
-    pub fn new_with<T>(make_value: impl FnOnce() -> T) -> VMExternRef
-    where
-        T: 'static + Any + Send + Sync,
-    {
-        unsafe {
-            let (layout, footer_offset) =
-                VMExternData::layout_for(mem::size_of::<T>(), mem::align_of::<T>());
-
-            let alloc_ptr = std::alloc::alloc(layout);
-            let alloc_ptr = NonNull::new(alloc_ptr).unwrap_or_else(|| {
-                std::alloc::handle_alloc_error(layout);
-            });
-
-            let value_ptr = alloc_ptr.cast::<T>();
-            ptr::write(value_ptr.as_ptr(), make_value());
-
-            let extern_data_ptr =
-                alloc_ptr.cast::<u8>().as_ptr().add(footer_offset) as *mut VMExternData;
-
-            ptr::write(
-                extern_data_ptr,
-                VMExternData {
-                    ref_count: AtomicUsize::new(1),
-                    // Cast from `*mut T` to `*mut dyn Any` here.
-                    value_ptr: SendSyncPtr::new(NonNull::new_unchecked(value_ptr.as_ptr())),
-                },
-            );
-
-            log::trace!("New externref data @ {:p}", extern_data_ptr);
-            VMExternRef(NonNull::new_unchecked(extern_data_ptr).into())
-        }
-    }
-
-    /// Turn this `VMExternRef` into a raw, untyped pointer.
-    ///
-    /// Unlike `into_raw`, this does not consume and forget `self`. It is *not*
-    /// safe to use `from_raw` on pointers returned from this method; only use
-    /// `clone_from_raw`!
-    ///
-    ///  Nor does this method increment the reference count. You must ensure
-    ///  that `self` (or some other clone of `self`) stays alive until
-    ///  `clone_from_raw` is called.
-    #[inline]
-    pub fn as_raw(&self) -> *mut u8 {
-        let ptr = self.0.as_ptr().cast::<u8>();
-        ptr
-    }
-
-    /// Consume this `VMExternRef` into a raw, untyped pointer.
-    ///
-    /// # Safety
-    ///
-    /// This method forgets self, so it is possible to create a leak of the
-    /// underlying reference counted data if not used carefully.
-    ///
-    /// Use `from_raw` to recreate the `VMExternRef`.
-    pub unsafe fn into_raw(self) -> *mut u8 {
-        let ptr = self.0.as_ptr().cast::<u8>();
-        std::mem::forget(self);
-        ptr
-    }
-
-    /// Recreate a `VMExternRef` from a pointer returned from a previous call to
-    /// `as_raw`.
-    ///
-    /// # Safety
-    ///
-    /// Unlike `clone_from_raw`, this does not increment the reference count of the
-    /// underlying data.  It is not safe to continue to use the pointer passed to this
-    /// function.
-    pub unsafe fn from_raw(ptr: *mut u8) -> Self {
-        debug_assert!(!ptr.is_null());
-        VMExternRef(NonNull::new_unchecked(ptr).cast().into())
-    }
-
-    /// Recreate a `VMExternRef` from a pointer returned from a previous call to
-    /// `as_raw`.
-    ///
-    /// # Safety
-    ///
-    /// Wildly unsafe to use with anything other than the result of a previous
-    /// `as_raw` call!
-    ///
-    /// Additionally, it is your responsibility to ensure that this raw
-    /// `VMExternRef`'s reference count has not dropped to zero. Failure to do
-    /// so will result in use after free!
-    pub unsafe fn clone_from_raw(ptr: *mut u8) -> Self {
-        debug_assert!(!ptr.is_null());
-        let x = VMExternRef(NonNull::new_unchecked(ptr).cast().into());
-        x.extern_data().increment_ref_count();
-        x
-    }
-
-    /// Get the strong reference count for this `VMExternRef`.
-    ///
-    /// Note that this loads with a `SeqCst` ordering to synchronize with other
-    /// threads.
-    pub fn strong_count(&self) -> usize {
-        self.extern_data().ref_count.load(Ordering::SeqCst)
-    }
-
-    #[inline]
-    fn extern_data(&self) -> &VMExternData {
-        unsafe { self.0.as_ref() }
-    }
-}
-
-/// Methods that would normally be trait implementations, but aren't to avoid
-/// potential footguns around `VMExternRef`'s pointer-equality semantics.
-///
-/// Note that none of these methods are on `&self`, they all require a
-/// fully-qualified `VMExternRef::foo(my_ref)` invocation.
-impl VMExternRef {
-    /// Check whether two `VMExternRef`s point to the same inner allocation.
-    ///
-    /// Note that this uses pointer-equality semantics, not structural-equality
-    /// semantics, and so only pointers are compared, and doesn't use any `Eq`
-    /// or `PartialEq` implementation of the pointed-to values.
-    #[inline]
-    pub fn eq(a: &Self, b: &Self) -> bool {
-        ptr::eq(a.0.as_ptr(), b.0.as_ptr())
-    }
-
-    /// Hash a given `VMExternRef`.
-    ///
-    /// Note that this just hashes the pointer to the inner value, it does *not*
-    /// use the inner value's `Hash` implementation (if any).
-    #[inline]
-    pub fn hash<H>(externref: &Self, hasher: &mut H)
-    where
-        H: Hasher,
-    {
-        ptr::hash(externref.0.as_ptr(), hasher);
-    }
-
-    /// Compare two `VMExternRef`s.
-    ///
-    /// Note that this uses pointer-equality semantics, not structural-equality
-    /// semantics, and so only pointers are compared, and doesn't use any `Cmp`
-    /// or `PartialCmp` implementation of the pointed-to values.
-    #[inline]
-    pub fn cmp(a: &Self, b: &Self) -> cmp::Ordering {
-        let a = a.0.as_ptr() as usize;
-        let b = b.0.as_ptr() as usize;
-        a.cmp(&b)
-    }
-}
-
-impl Deref for VMExternRef {
-    type Target = dyn Any;
-
-    fn deref(&self) -> &dyn Any {
-        unsafe { self.extern_data().value_ptr.as_ref() }
-    }
-}
-
-/// A wrapper around a `VMExternRef` that implements `Eq` and `Hash` with
-/// pointer semantics.
-///
-/// We use this so that we can morally put `VMExternRef`s inside of `HashSet`s
-/// even though they don't implement `Eq` and `Hash` to avoid foot guns.
-#[derive(Clone, Debug)]
-struct VMExternRefWithTraits(VMExternRef);
-
-impl Hash for VMExternRefWithTraits {
-    fn hash<H>(&self, hasher: &mut H)
-    where
-        H: Hasher,
-    {
-        VMExternRef::hash(&self.0, hasher)
-    }
-}
-
-impl PartialEq for VMExternRefWithTraits {
-    fn eq(&self, other: &Self) -> bool {
-        VMExternRef::eq(&self.0, &other.0)
-    }
-}
-
-impl Eq for VMExternRefWithTraits {}
-
-type TableElem = UnsafeCell<Option<VMExternRef>>;
-
-/// A table that over-approximizes the set of `VMExternRef`s that any Wasm
-/// activation on this thread is currently using.
-///
-/// Under the covers, this is a simple bump allocator that allows duplicate
-/// entries. Deduplication happens at GC time.
-#[repr(C)] // `alloc` must be the first member, it's accessed from JIT code.
-pub struct VMExternRefActivationsTable {
-    /// Structures used to perform fast bump allocation of storage of externref
-    /// values.
-    ///
-    /// This is the only member of this structure accessed from JIT code.
-    alloc: VMExternRefTableAlloc,
-
-    /// When unioned with `chunk`, this is an over-approximation of the GC roots
-    /// on the stack, inside Wasm frames.
-    ///
-    /// This is used by slow-path insertion, and when a GC cycle finishes, is
-    /// re-initialized to the just-discovered precise set of stack roots (which
-    /// immediately becomes an over-approximation again as soon as Wasm runs and
-    /// potentially drops references).
-    over_approximated_stack_roots: HashSet<VMExternRefWithTraits>,
-
-    /// The precise set of on-stack, inside-Wasm GC roots that we discover via
-    /// walking the stack and interpreting stack maps.
-    ///
-    /// This is *only* used inside the `gc` function, and is empty otherwise. It
-    /// is just part of this struct so that we can reuse the allocation, rather
-    /// than create a new hash set every GC.
-    precise_stack_roots: HashSet<VMExternRefWithTraits>,
-
-    /// A debug-only field for asserting that we are in a region of code where
-    /// GC is okay to preform.
-    #[cfg(debug_assertions)]
-    gc_okay: bool,
-}
-
-#[repr(C)] // This is accessed from JIT code.
-struct VMExternRefTableAlloc {
-    /// Bump-allocation finger within the `chunk`.
-    ///
-    /// NB: this is an `UnsafeCell` because it is written to by compiled Wasm
-    /// code.
-    next: UnsafeCell<NonNull<TableElem>>,
-
-    /// Pointer to just after the `chunk`.
-    ///
-    /// This is *not* within the current chunk and therefore is not a valid
-    /// place to insert a reference!
-    end: NonNull<TableElem>,
-
-    /// Bump allocation chunk that stores fast-path insertions.
-    ///
-    /// This is not accessed from JIT code.
-    chunk: Box<[TableElem]>,
-}
-
-// This gets around the usage of `UnsafeCell` throughout the internals of this
-// allocator, but the storage should all be Send/Sync and synchronization isn't
-// necessary since operations require `&mut self`.
-unsafe impl Send for VMExternRefTableAlloc {}
-unsafe impl Sync for VMExternRefTableAlloc {}
-
-fn _assert_send_sync() {
-    fn _assert<T: Send + Sync>() {}
-    _assert::<VMExternRefActivationsTable>();
-    _assert::<VMExternRef>();
-}
-
-impl VMExternRefActivationsTable {
-    const CHUNK_SIZE: usize = 4096 / mem::size_of::<usize>();
-
-    /// Create a new `VMExternRefActivationsTable`.
-    pub fn new() -> Self {
-        // Start with an empty chunk in case this activations table isn't used.
-        // This means that there's no space in the bump-allocation area which
-        // will force any path trying to use this to the slow gc path. The first
-        // time this happens, though, the slow gc path will allocate a new chunk
-        // for actual fast-bumping.
-        let mut chunk: Box<[TableElem]> = Box::new([]);
-        let next = chunk.as_mut_ptr();
-        let end = unsafe { next.add(chunk.len()) };
-
-        VMExternRefActivationsTable {
-            alloc: VMExternRefTableAlloc {
-                next: UnsafeCell::new(NonNull::new(next).unwrap()),
-                end: NonNull::new(end).unwrap(),
-                chunk,
-            },
-            over_approximated_stack_roots: HashSet::new(),
-            precise_stack_roots: HashSet::new(),
-            #[cfg(debug_assertions)]
-            gc_okay: true,
-        }
-    }
-
-    fn new_chunk(size: usize) -> Box<[UnsafeCell<Option<VMExternRef>>]> {
-        assert!(size >= Self::CHUNK_SIZE);
-        (0..size).map(|_| UnsafeCell::new(None)).collect()
-    }
-
-    /// Get the available capacity in the bump allocation chunk.
-    #[inline]
-    pub fn bump_capacity_remaining(&self) -> usize {
-        let end = self.alloc.end.as_ptr() as usize;
-        let next = unsafe { *self.alloc.next.get() };
-        end - next.as_ptr() as usize
-    }
-
-    /// Try and insert a `VMExternRef` into this table.
-    ///
-    /// This is a fast path that only succeeds when the bump chunk has the
-    /// capacity for the requested insertion.
-    ///
-    /// If the insertion fails, then the `VMExternRef` is given back. Callers
-    /// may attempt a GC to free up space and try again, or may call
-    /// `insert_slow_path` to infallibly insert the reference (potentially
-    /// allocating additional space in the table to hold it).
-    #[inline]
-    pub fn try_insert(&mut self, externref: VMExternRef) -> Result<(), VMExternRef> {
-        unsafe {
-            let next = *self.alloc.next.get();
-            if next == self.alloc.end {
-                return Err(externref);
-            }
-
-            debug_assert!(
-                (*next.as_ref().get()).is_none(),
-                "slots >= the `next` bump finger are always `None`"
-            );
-            ptr::write(next.as_ptr(), UnsafeCell::new(Some(externref)));
-
-            let next = NonNull::new_unchecked(next.as_ptr().add(1));
-            debug_assert!(next <= self.alloc.end);
-            *self.alloc.next.get() = next;
-
-            Ok(())
-        }
-    }
-
-    /// Insert a reference into the table, falling back on a GC to clear up
-    /// space if the table is already full.
-    ///
-    /// # Unsafety
-    ///
-    /// The same as `gc`.
-    #[inline]
-    pub unsafe fn insert_with_gc(
-        &mut self,
-        limits: *const VMRuntimeLimits,
-        externref: VMExternRef,
-        module_info_lookup: &dyn ModuleInfoLookup,
-    ) {
-        #[cfg(debug_assertions)]
-        assert!(self.gc_okay);
-
-        if let Err(externref) = self.try_insert(externref) {
-            self.gc_and_insert_slow(limits, externref, module_info_lookup);
-        }
-    }
-
-    #[inline(never)]
-    unsafe fn gc_and_insert_slow(
-        &mut self,
-        limits: *const VMRuntimeLimits,
-        externref: VMExternRef,
-        module_info_lookup: &dyn ModuleInfoLookup,
-    ) {
-        gc(limits, module_info_lookup, self);
-
-        // Might as well insert right into the hash set, rather than the bump
-        // chunk, since we are already on a slow path and we get de-duplication
-        // this way.
-        self.over_approximated_stack_roots
-            .insert(VMExternRefWithTraits(externref));
-    }
-
-    /// Insert a reference into the table, without ever performing GC.
-    #[inline]
-    pub fn insert_without_gc(&mut self, externref: VMExternRef) {
-        if let Err(externref) = self.try_insert(externref) {
-            self.insert_slow_without_gc(externref);
-        }
-    }
-
-    #[inline(never)]
-    fn insert_slow_without_gc(&mut self, externref: VMExternRef) {
-        self.over_approximated_stack_roots
-            .insert(VMExternRefWithTraits(externref));
-    }
-
-    fn num_filled_in_bump_chunk(&self) -> usize {
-        let next = unsafe { *self.alloc.next.get() };
-        let bytes_unused = (self.alloc.end.as_ptr() as usize) - (next.as_ptr() as usize);
-        let slots_unused = bytes_unused / mem::size_of::<TableElem>();
-        self.alloc.chunk.len().saturating_sub(slots_unused)
-    }
-
-    fn elements(&self, mut f: impl FnMut(&VMExternRef)) {
-        for elem in self.over_approximated_stack_roots.iter() {
-            f(&elem.0);
-        }
-
-        // The bump chunk is not all the way full, so we only iterate over its
-        // filled-in slots.
-        let num_filled = self.num_filled_in_bump_chunk();
-        for slot in self.alloc.chunk.iter().take(num_filled) {
-            if let Some(elem) = unsafe { &*slot.get() } {
-                f(elem);
-            }
-        }
-    }
-
-    fn insert_precise_stack_root(
-        precise_stack_roots: &mut HashSet<VMExternRefWithTraits>,
-        root: NonNull<VMExternData>,
-    ) {
-        let root = unsafe { VMExternRef::clone_from_raw(root.as_ptr().cast()) };
-        log::trace!("Found externref on stack: {:p}", root);
-        precise_stack_roots.insert(VMExternRefWithTraits(root));
-    }
-
-    /// Sweep the bump allocation table after we've discovered our precise stack
-    /// roots.
-    fn sweep(&mut self) {
-        log::trace!("begin GC sweep");
-
-        // Sweep our bump chunk.
-        let num_filled = self.num_filled_in_bump_chunk();
-        unsafe {
-            *self.alloc.next.get() = self.alloc.end;
-        }
-        for slot in self.alloc.chunk.iter().take(num_filled) {
-            unsafe {
-                *slot.get() = None;
-            }
-        }
-        debug_assert!(
-            self.alloc
-                .chunk
-                .iter()
-                .all(|slot| unsafe { (*slot.get()).as_ref().is_none() }),
-            "after sweeping the bump chunk, all slots should be `None`"
-        );
-
-        // If this is the first instance of gc then the initial chunk is empty,
-        // so we lazily allocate space for fast bump-allocation in the future.
-        if self.alloc.chunk.is_empty() {
-            self.alloc.chunk = Self::new_chunk(Self::CHUNK_SIZE);
-            self.alloc.end =
-                NonNull::new(unsafe { self.alloc.chunk.as_mut_ptr().add(self.alloc.chunk.len()) })
-                    .unwrap();
-        }
-
-        // Reset our `next` finger to the start of the bump allocation chunk.
-        unsafe {
-            let next = self.alloc.chunk.as_mut_ptr();
-            debug_assert!(!next.is_null());
-            *self.alloc.next.get() = NonNull::new_unchecked(next);
-        }
-
-        // The current `precise_stack_roots` becomes our new over-appoximated
-        // set for the next GC cycle.
-        mem::swap(
-            &mut self.precise_stack_roots,
-            &mut self.over_approximated_stack_roots,
-        );
-
-        // And finally, the new `precise_stack_roots` should be cleared and
-        // remain empty until the next GC cycle.
-        //
-        // Note that this may run arbitrary code as we run externref
-        // destructors. Because of our `&mut` borrow above on this table,
-        // though, we're guaranteed that nothing will touch this table.
-        self.precise_stack_roots.clear();
-
-        log::trace!("end GC sweep");
-    }
-
-    /// Set whether it is okay to GC or not right now.
-    ///
-    /// This is provided as a helper for enabling various debug-only assertions
-    /// and checking places where the `wasmtime-runtime` user expects there not
-    /// to be any GCs.
-    #[inline]
-    pub fn set_gc_okay(&mut self, okay: bool) -> bool {
-        #[cfg(debug_assertions)]
-        {
-            return std::mem::replace(&mut self.gc_okay, okay);
-        }
-        #[cfg(not(debug_assertions))]
-        {
-            let _ = okay;
-            return true;
-        }
-    }
-}
-
-/// Used by the runtime to lookup information about a module given a
-/// program counter value.
-pub trait ModuleInfoLookup {
-    /// Lookup the module information from a program counter value.
-    fn lookup(&self, pc: usize) -> Option<&dyn ModuleInfo>;
-}
-
-/// Used by the runtime to query module information.
-pub trait ModuleInfo {
-    /// Lookup the stack map at a program counter value.
-    fn lookup_stack_map(&self, pc: usize) -> Option<&StackMap>;
-}
-
-#[derive(Debug, Default)]
-struct DebugOnly<T> {
-    inner: T,
-}
-
-impl<T> std::ops::Deref for DebugOnly<T> {
-    type Target = T;
-
-    fn deref(&self) -> &T {
-        if cfg!(debug_assertions) {
-            &self.inner
-        } else {
-            panic!(
-                "only deref `DebugOnly` when `cfg(debug_assertions)` or \
-                 inside a `debug_assert!(..)`"
-            )
-        }
-    }
-}
-
-impl<T> std::ops::DerefMut for DebugOnly<T> {
-    fn deref_mut(&mut self) -> &mut T {
-        if cfg!(debug_assertions) {
-            &mut self.inner
-        } else {
-            panic!(
-                "only deref `DebugOnly` when `cfg(debug_assertions)` or \
-                 inside a `debug_assert!(..)`"
-            )
-        }
-    }
-}
-
-/// Perform garbage collection of `VMExternRef`s.
-///
-/// # Unsafety
-///
-/// You must have called `VMExternRefActivationsTable::set_stack_canary` for at
-/// least the oldest host-->Wasm stack frame transition on this thread's stack
-/// (it is idempotent to call it more than once) and keep its return value alive
-/// across the duration of that host-->Wasm call.
-///
-/// Additionally, you must have registered the stack maps for every Wasm module
-/// that has frames on the stack with the given `stack_maps_registry`.
-pub unsafe fn gc(
-    limits: *const VMRuntimeLimits,
-    module_info_lookup: &dyn ModuleInfoLookup,
-    externref_activations_table: &mut VMExternRefActivationsTable,
-) {
-    log::debug!("start GC");
-
-    #[cfg(debug_assertions)]
-    assert!(externref_activations_table.gc_okay);
-
-    debug_assert!({
-        // This set is only non-empty within this function. It is built up when
-        // walking the stack and interpreting stack maps, and then drained back
-        // into the activations table's bump-allocated space at the
-        // end. Therefore, it should always be empty upon entering this
-        // function.
-        externref_activations_table.precise_stack_roots.is_empty()
-    });
-
-    // This function proceeds by:
-    //
-    // * walking the stack,
-    //
-    // * finding the precise set of roots inside Wasm frames via our stack maps,
-    //   and
-    //
-    // * resetting our bump-allocated table's over-approximation to the
-    //   newly-discovered precise set.
-
-    // The `activations_table_set` is used for `debug_assert!`s checking that
-    // every reference we read out from the stack via stack maps is actually in
-    // the table. If that weren't true, than either we forgot to insert a
-    // reference in the table when passing it into Wasm (a bug) or we are
-    // reading invalid references from the stack (another bug).
-    let mut activations_table_set: DebugOnly<HashSet<_>> = Default::default();
-    if cfg!(debug_assertions) {
-        externref_activations_table.elements(|elem| {
-            activations_table_set.insert(elem.as_raw() as *mut VMExternData);
-        });
-    }
-
-    log::trace!("begin GC trace");
-    Backtrace::trace(limits, |frame| {
-        let pc = frame.pc();
-        debug_assert!(pc != 0, "we should always get a valid PC for Wasm frames");
-
-        let fp = frame.fp();
-        debug_assert!(
-            fp != 0,
-            "we should always get a valid frame pointer for Wasm frames"
-        );
-
-        let module_info = module_info_lookup
-            .lookup(pc)
-            .expect("should have module info for Wasm frame");
-
-        let stack_map = match module_info.lookup_stack_map(pc) {
-            Some(sm) => sm,
-            None => {
-                log::trace!("No stack map for this Wasm frame");
-                return std::ops::ControlFlow::Continue(());
-            }
-        };
-        log::trace!(
-            "We have a stack map that maps {} words in this Wasm frame",
-            stack_map.mapped_words()
-        );
-
-        let sp = fp - stack_map.mapped_words() as usize * mem::size_of::<usize>();
-
-        for i in 0..(stack_map.mapped_words() as usize) {
-            // Stack maps have one bit per word in the frame, and the
-            // zero^th bit is the *lowest* addressed word in the frame,
-            // i.e. the closest to the SP. So to get the `i`^th word in
-            // this frame, we add `i * sizeof(word)` to the SP.
-            let stack_slot = sp + i * mem::size_of::<usize>();
-
-            if !stack_map.get_bit(i) {
-                log::trace!(
-                    "Stack slot @ {:p} does not contain externrefs",
-                    stack_slot as *const (),
-                );
-                continue;
-            }
-
-            let stack_slot = stack_slot as *const *mut VMExternData;
-            let r = std::ptr::read(stack_slot);
-            log::trace!("Stack slot @ {:p} = {:p}", stack_slot, r);
-
-            debug_assert!(
-                r.is_null() || activations_table_set.contains(&r),
-                "every on-stack externref inside a Wasm frame should \
-                 have an entry in the VMExternRefActivationsTable; \
-                 {:?} is not in the table",
-                r
-            );
-
-            if let Some(r) = NonNull::new(r) {
-                VMExternRefActivationsTable::insert_precise_stack_root(
-                    &mut externref_activations_table.precise_stack_roots,
-                    r,
-                );
-            }
-        }
-
-        std::ops::ControlFlow::Continue(())
-    });
-    log::trace!("end GC trace");
-
-    externref_activations_table.sweep();
-
-    log::debug!("end GC");
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::convert::TryInto;
-
-    #[test]
-    fn extern_ref_is_pointer_sized_and_aligned() {
-        assert_eq!(mem::size_of::<VMExternRef>(), mem::size_of::<*mut ()>());
-        assert_eq!(mem::align_of::<VMExternRef>(), mem::align_of::<*mut ()>());
-        assert_eq!(
-            mem::size_of::<Option<VMExternRef>>(),
-            mem::size_of::<*mut ()>()
-        );
-        assert_eq!(
-            mem::align_of::<Option<VMExternRef>>(),
-            mem::align_of::<*mut ()>()
-        );
-    }
-
-    #[test]
-    fn ref_count_is_at_correct_offset() {
-        let s = "hi";
-        let s: &(dyn Any + Send + Sync) = &s as _;
-        let s: *const (dyn Any + Send + Sync) = s as _;
-        let s: *mut (dyn Any + Send + Sync) = s as _;
-
-        let extern_data = VMExternData {
-            ref_count: AtomicUsize::new(0),
-            value_ptr: NonNull::new(s).unwrap().into(),
-        };
-
-        let extern_data_ptr = &extern_data as *const _;
-        let ref_count_ptr = &extern_data.ref_count as *const _;
-
-        let actual_offset = (ref_count_ptr as usize) - (extern_data_ptr as usize);
-
-        let offsets = wasmtime_environ::VMOffsets::from(wasmtime_environ::VMOffsetsFields {
-            ptr: 8,
-            num_imported_functions: 0,
-            num_imported_tables: 0,
-            num_imported_memories: 0,
-            num_imported_globals: 0,
-            num_defined_tables: 0,
-            num_defined_memories: 0,
-            num_owned_memories: 0,
-            num_defined_globals: 0,
-            num_escaped_funcs: 0,
-        });
-        assert_eq!(
-            offsets.vm_extern_data_ref_count(),
-            actual_offset.try_into().unwrap(),
-        );
-    }
-
-    #[test]
-    fn table_next_is_at_correct_offset() {
-        let table = VMExternRefActivationsTable::new();
-
-        let table_ptr = &table as *const _;
-        let next_ptr = &table.alloc.next as *const _;
-
-        let actual_offset = (next_ptr as usize) - (table_ptr as usize);
-
-        let offsets = wasmtime_environ::VMOffsets::from(wasmtime_environ::VMOffsetsFields {
-            ptr: 8,
-            num_imported_functions: 0,
-            num_imported_tables: 0,
-            num_imported_memories: 0,
-            num_imported_globals: 0,
-            num_defined_tables: 0,
-            num_defined_memories: 0,
-            num_owned_memories: 0,
-            num_defined_globals: 0,
-            num_escaped_funcs: 0,
-        });
-        assert_eq!(
-            offsets.vm_extern_ref_activation_table_next() as usize,
-            actual_offset
-        );
-    }
-
-    #[test]
-    fn table_end_is_at_correct_offset() {
-        let table = VMExternRefActivationsTable::new();
-
-        let table_ptr = &table as *const _;
-        let end_ptr = &table.alloc.end as *const _;
-
-        let actual_offset = (end_ptr as usize) - (table_ptr as usize);
-
-        let offsets = wasmtime_environ::VMOffsets::from(wasmtime_environ::VMOffsetsFields {
-            ptr: 8,
-            num_imported_functions: 0,
-            num_imported_tables: 0,
-            num_imported_memories: 0,
-            num_imported_globals: 0,
-            num_defined_tables: 0,
-            num_defined_memories: 0,
-            num_owned_memories: 0,
-            num_defined_globals: 0,
-            num_escaped_funcs: 0,
-        });
-        assert_eq!(
-            offsets.vm_extern_ref_activation_table_end() as usize,
-            actual_offset
-        );
-    }
-}
diff --git a/crates/runtime/src/helpers.c b/crates/runtime/src/helpers.c
deleted file mode 100644
index e3c9bb58240b..000000000000
--- a/crates/runtime/src/helpers.c
+++ /dev/null
@@ -1,108 +0,0 @@
-#include <setjmp.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-#ifdef CFG_TARGET_OS_windows
-
-#define platform_setjmp(buf) setjmp(buf)
-#define platform_longjmp(buf, arg) longjmp(buf, arg)
-typedef jmp_buf platform_jmp_buf;
-
-#elif defined(__clang__) && (defined(__aarch64__) || defined(__s390x__))
-
-// Clang on aarch64 and s390x doesn't support `__builtin_setjmp`, so use
-//`sigsetjmp` from libc.
-//
-// Note that `sigsetjmp` and `siglongjmp` are used here where possible to
-// explicitly pass a 0 argument to `sigsetjmp` that we don't need to preserve
-// the process signal mask. This should make this call a bit faster b/c it
-// doesn't need to touch the kernel signal handling routines.
-#define platform_setjmp(buf) sigsetjmp(buf, 0)
-#define platform_longjmp(buf, arg) siglongjmp(buf, arg)
-typedef sigjmp_buf platform_jmp_buf;
-
-#else
-
-// GCC and Clang both provide `__builtin_setjmp`/`__builtin_longjmp`, which
-// differ from plain `setjmp` and `longjmp` in that they're implemented by
-// the compiler inline rather than in libc, and the compiler can avoid saving
-// and restoring most of the registers. See the [GCC docs] and [clang docs]
-// for more information.
-//
-// Per the caveat in the GCC docs, this assumes that the host compiler (which
-// may be compiling for a generic architecture family) knows about all the
-// register state that Cranelift (which may be specializing for the hardware at
-// runtime) is assuming is callee-saved.
-//
-// [GCC docs]: https://gcc.gnu.org/onlinedocs/gcc/Nonlocal-Gotos.html
-// [clang docs]: https://llvm.org/docs/ExceptionHandling.html#llvm-eh-sjlj-setjmp
-#define platform_setjmp(buf) __builtin_setjmp(buf)
-#define platform_longjmp(buf, arg) __builtin_longjmp(buf, arg)
-typedef void *platform_jmp_buf[5]; // this is the documented size; see the docs links for details.
-
-#endif
-
-#define CONCAT2(a, b) a ## b
-#define CONCAT(a, b) CONCAT2(a , b)
-#define VERSIONED_SYMBOL(a) CONCAT(a, VERSIONED_SUFFIX)
-
-int VERSIONED_SYMBOL(wasmtime_setjmp)(
-    void **buf_storage,
-    void (*body)(void*, void*),
-    void *payload,
-    void *callee) {
-  platform_jmp_buf buf;
-  if (platform_setjmp(buf) != 0) {
-    return 0;
-  }
-  *buf_storage = &buf;
-  body(payload, callee);
-  return 1;
-}
-
-void VERSIONED_SYMBOL(wasmtime_longjmp)(void *JmpBuf) {
-  platform_jmp_buf *buf = (platform_jmp_buf*) JmpBuf;
-  platform_longjmp(*buf, 1);
-}
-
-#ifdef CFG_TARGET_OS_windows
-  // export required for external access.
-__declspec(dllexport)
-#else
-  // Note the `weak` linkage here, though, which is intended to let other code
-  // override this symbol if it's defined elsewhere, since this definition doesn't
-  // matter.
-  // Just in case cross-language LTO is enabled we set the `noinline` attribute
-  // and also try to have some sort of side effect in this function with a dummy
-  // `asm` statement.
-__attribute__((weak, noinline))
-#endif
-void __jit_debug_register_code() {
-#ifndef CFG_TARGET_OS_windows
-  __asm__("");
-#endif
-}
-
-struct JITDescriptor {
-  uint32_t version_;
-  uint32_t action_flag_;
-  void* relevant_entry_;
-  void* first_entry_;
-};
-
-#ifdef CFG_TARGET_OS_windows
-  // export required for external access.
-  __declspec(dllexport)
-#else
-  // Note the `weak` linkage here which is the same purpose as above. We want to
-  // let other runtimes be able to override this since our own definition isn't
-  // important.
-  __attribute__((weak))
-#endif
-struct JITDescriptor __jit_debug_descriptor = {1, 0, NULL, NULL};
-
-
-
-struct JITDescriptor* VERSIONED_SYMBOL(wasmtime_jit_debug_descriptor)() {
-  return &__jit_debug_descriptor;
-}
diff --git a/crates/runtime/src/instance.rs b/crates/runtime/src/instance.rs
deleted file mode 100644
index 8035f5db7f4a..000000000000
--- a/crates/runtime/src/instance.rs
+++ /dev/null
@@ -1,1479 +0,0 @@
-//! An `Instance` contains all the runtime state used by execution of a
-//! wasm module (except its callstack and register state). An
-//! `InstanceHandle` is a reference-counting handle for an `Instance`.
-
-use crate::export::Export;
-use crate::externref::VMExternRefActivationsTable;
-use crate::memory::{Memory, RuntimeMemoryCreator};
-use crate::table::{Table, TableElement, TableElementType};
-use crate::vmcontext::{
-    VMBuiltinFunctionsArray, VMContext, VMFuncRef, VMFunctionImport, VMGlobalDefinition,
-    VMGlobalImport, VMMemoryDefinition, VMMemoryImport, VMOpaqueContext, VMRuntimeLimits,
-    VMTableDefinition, VMTableImport,
-};
-use crate::{
-    ExportFunction, ExportGlobal, ExportMemory, ExportTable, Imports, ModuleRuntimeInfo,
-    SendSyncPtr, Store, VMFunctionBody, VMSharedSignatureIndex, WasmFault,
-};
-use anyhow::Error;
-use anyhow::Result;
-use sptr::Strict;
-use std::alloc::{self, Layout};
-use std::any::Any;
-use std::convert::TryFrom;
-use std::ops::Range;
-use std::ptr::NonNull;
-use std::sync::atomic::AtomicU64;
-use std::sync::Arc;
-use std::{mem, ptr};
-use wasmtime_environ::{
-    packed_option::ReservedValue, DataIndex, DefinedGlobalIndex, DefinedMemoryIndex,
-    DefinedTableIndex, ElemIndex, EntityIndex, EntityRef, EntitySet, FuncIndex, GlobalIndex,
-    GlobalInit, HostPtr, MemoryIndex, MemoryPlan, Module, PrimaryMap, SignatureIndex, TableIndex,
-    TableInitialValue, Trap, VMOffsets, WasmHeapType, WasmRefType, WasmType, VMCONTEXT_MAGIC,
-};
-#[cfg(feature = "wmemcheck")]
-use wasmtime_wmemcheck::Wmemcheck;
-
-mod allocator;
-
-pub use allocator::*;
-
-/// A type that roughly corresponds to a WebAssembly instance, but is also used
-/// for host-defined objects.
-///
-/// This structure is is never allocated directly but is instead managed through
-/// an `InstanceHandle`. This structure ends with a `VMContext` which has a
-/// dynamic size corresponding to the `module` configured within. Memory
-/// management of this structure is always externalized.
-///
-/// Instances here can correspond to actual instantiated modules, but it's also
-/// used ubiquitously for host-defined objects. For example creating a
-/// host-defined memory will have a `module` that looks like it exports a single
-/// memory (and similar for other constructs).
-///
-/// This `Instance` type is used as a ubiquitous representation for WebAssembly
-/// values, whether or not they were created on the host or through a module.
-#[repr(C)] // ensure that the vmctx field is last.
-pub struct Instance {
-    /// The runtime info (corresponding to the "compiled module"
-    /// abstraction in higher layers) that is retained and needed for
-    /// lazy initialization. This provides access to the underlying
-    /// Wasm module entities, the compiled JIT code, metadata about
-    /// functions, lazy initialization state, etc.
-    runtime_info: Arc<dyn ModuleRuntimeInfo>,
-
-    /// WebAssembly linear memory data.
-    ///
-    /// This is where all runtime information about defined linear memories in
-    /// this module lives.
-    ///
-    /// The `MemoryAllocationIndex` was given from our `InstanceAllocator` and
-    /// must be given back to the instance allocator when deallocating each
-    /// memory.
-    memories: PrimaryMap<DefinedMemoryIndex, (MemoryAllocationIndex, Memory)>,
-
-    /// WebAssembly table data.
-    ///
-    /// Like memories, this is only for defined tables in the module and
-    /// contains all of their runtime state.
-    ///
-    /// The `TableAllocationIndex` was given from our `InstanceAllocator` and
-    /// must be given back to the instance allocator when deallocating each
-    /// table.
-    tables: PrimaryMap<DefinedTableIndex, (TableAllocationIndex, Table)>,
-
-    /// Stores the dropped passive element segments in this instantiation by index.
-    /// If the index is present in the set, the segment has been dropped.
-    dropped_elements: EntitySet<ElemIndex>,
-
-    /// Stores the dropped passive data segments in this instantiation by index.
-    /// If the index is present in the set, the segment has been dropped.
-    dropped_data: EntitySet<DataIndex>,
-
-    /// Hosts can store arbitrary per-instance information here.
-    ///
-    /// Most of the time from Wasmtime this is `Box::new(())`, a noop
-    /// allocation, but some host-defined objects will store their state here.
-    host_state: Box<dyn Any + Send + Sync>,
-
-    /// A pointer to the `vmctx` field at the end of the `Instance`.
-    ///
-    /// If you're looking at this a reasonable question would be "why do we need
-    /// a pointer to ourselves?" because after all the pointer's value is
-    /// trivially derivable from any `&Instance` pointer. The rationale for this
-    /// field's existence is subtle, but it's required for correctness. The
-    /// short version is "this makes miri happy".
-    ///
-    /// The long version of why this field exists is that the rules that MIRI
-    /// uses to ensure pointers are used correctly have various conditions on
-    /// them depend on how pointers are used. More specifically if `*mut T` is
-    /// derived from `&mut T`, then that invalidates all prior pointers drived
-    /// from the `&mut T`. This means that while we liberally want to re-acquire
-    /// a `*mut VMContext` throughout the implementation of `Instance` the
-    /// trivial way, a function `fn vmctx(&mut Instance) -> *mut VMContext`
-    /// would effectively invalidate all prior `*mut VMContext` pointers
-    /// acquired. The purpose of this field is to serve as a sort of
-    /// source-of-truth for where `*mut VMContext` pointers come from.
-    ///
-    /// This field is initialized when the `Instance` is created with the
-    /// original allocation's pointer. That means that the provenance of this
-    /// pointer contains the entire allocation (both instance and `VMContext`).
-    /// This provenance bit is then "carried through" where `fn vmctx` will base
-    /// all returned pointers on this pointer itself. This provides the means of
-    /// never invalidating this pointer throughout MIRI and additionally being
-    /// able to still temporarily have `&mut Instance` methods and such.
-    ///
-    /// It's important to note, though, that this is not here purely for MIRI.
-    /// The careful construction of the `fn vmctx` method has ramifications on
-    /// the LLVM IR generated, for example. A historical CVE on Wasmtime,
-    /// GHSA-ch89-5g45-qwc7, was caused due to relying on undefined behavior. By
-    /// deriving VMContext pointers from this pointer it specifically hints to
-    /// LLVM that trickery is afoot and it properly informs `noalias` and such
-    /// annotations and analysis. More-or-less this pointer is actually loaded
-    /// in LLVM IR which helps defeat otherwise present aliasing optimizations,
-    /// which we want, since writes to this should basically never be optimized
-    /// out.
-    ///
-    /// As a final note it's worth pointing out that the machine code generated
-    /// for accessing `fn vmctx` is still as one would expect. This member isn't
-    /// actually ever loaded at runtime (or at least shouldn't be). Perhaps in
-    /// the future if the memory consumption of this field is a problem we could
-    /// shrink it slightly, but for now one extra pointer per wasm instance
-    /// seems not too bad.
-    vmctx_self_reference: SendSyncPtr<VMContext>,
-
-    #[cfg(feature = "wmemcheck")]
-    pub(crate) wmemcheck_state: Option<Wmemcheck>,
-    // TODO: add support for multiple memories, wmemcheck_state corresponds to
-    // memory 0.
-    /// Additional context used by compiled wasm code. This field is last, and
-    /// represents a dynamically-sized array that extends beyond the nominal
-    /// end of the struct (similar to a flexible array member).
-    vmctx: VMContext,
-}
-
-impl Instance {
-    /// Create an instance at the given memory address.
-    ///
-    /// It is assumed the memory was properly aligned and the
-    /// allocation was `alloc_size` in bytes.
-    unsafe fn new(
-        req: InstanceAllocationRequest,
-        memories: PrimaryMap<DefinedMemoryIndex, (MemoryAllocationIndex, Memory)>,
-        tables: PrimaryMap<DefinedTableIndex, (TableAllocationIndex, Table)>,
-        memory_plans: &PrimaryMap<MemoryIndex, MemoryPlan>,
-    ) -> InstanceHandle {
-        // The allocation must be *at least* the size required of `Instance`.
-        let layout = Self::alloc_layout(req.runtime_info.offsets());
-        let ptr = alloc::alloc(layout);
-        if ptr.is_null() {
-            alloc::handle_alloc_error(layout);
-        }
-        let ptr = ptr.cast::<Instance>();
-
-        let module = req.runtime_info.module();
-        let dropped_elements = EntitySet::with_capacity(module.passive_elements.len());
-        let dropped_data = EntitySet::with_capacity(module.passive_data_map.len());
-
-        #[cfg(not(feature = "wmemcheck"))]
-        let _ = memory_plans;
-
-        ptr::write(
-            ptr,
-            Instance {
-                runtime_info: req.runtime_info.clone(),
-                memories,
-                tables,
-                dropped_elements,
-                dropped_data,
-                host_state: req.host_state,
-                vmctx_self_reference: SendSyncPtr::new(
-                    NonNull::new(ptr.cast::<u8>().add(mem::size_of::<Instance>()).cast()).unwrap(),
-                ),
-                vmctx: VMContext {
-                    _marker: std::marker::PhantomPinned,
-                },
-                #[cfg(feature = "wmemcheck")]
-                wmemcheck_state: {
-                    if req.wmemcheck {
-                        let size = memory_plans
-                            .iter()
-                            .next()
-                            .map(|plan| plan.1.memory.minimum)
-                            .unwrap_or(0)
-                            * 64
-                            * 1024;
-                        Some(Wmemcheck::new(size as usize))
-                    } else {
-                        None
-                    }
-                },
-            },
-        );
-
-        (*ptr).initialize_vmctx(module, req.runtime_info.offsets(), req.store, req.imports);
-        InstanceHandle {
-            instance: Some(SendSyncPtr::new(NonNull::new(ptr).unwrap())),
-        }
-    }
-
-    /// Converts the provided `*mut VMContext` to an `Instance` pointer and runs
-    /// the provided closure with the instance.
-    ///
-    /// This method will move the `vmctx` pointer backwards to point to the
-    /// original `Instance` that precedes it. The closure is provided a
-    /// temporary version of the `Instance` pointer with a constrained lifetime
-    /// to the closure to ensure it doesn't accidentally escape.
-    ///
-    /// # Unsafety
-    ///
-    /// Callers must validate that the `vmctx` pointer is a valid allocation
-    /// and that it's valid to acquire `&mut Instance` at this time. For example
-    /// this can't be called twice on the same `VMContext` to get two active
-    /// pointers to the same `Instance`.
-    pub unsafe fn from_vmctx<R>(vmctx: *mut VMContext, f: impl FnOnce(&mut Instance) -> R) -> R {
-        let ptr = vmctx
-            .cast::<u8>()
-            .sub(mem::size_of::<Instance>())
-            .cast::<Instance>();
-        f(&mut *ptr)
-    }
-
-    /// Helper function to access various locations offset from our `*mut
-    /// VMContext` object.
-    ///
-    /// # Safety
-    ///
-    /// This method is unsafe because the `offset` must be within bounds of the
-    /// `VMContext` object trailing this instance.
-    unsafe fn vmctx_plus_offset<T>(&self, offset: u32) -> *const T {
-        self.vmctx()
-            .cast::<u8>()
-            .add(usize::try_from(offset).unwrap())
-            .cast()
-    }
-
-    /// Dual of `vmctx_plus_offset`, but for mutability.
-    unsafe fn vmctx_plus_offset_mut<T>(&mut self, offset: u32) -> *mut T {
-        self.vmctx()
-            .cast::<u8>()
-            .add(usize::try_from(offset).unwrap())
-            .cast()
-    }
-
-    pub(crate) fn module(&self) -> &Arc<Module> {
-        self.runtime_info.module()
-    }
-
-    #[inline]
-    fn offsets(&self) -> &VMOffsets<HostPtr> {
-        self.runtime_info.offsets()
-    }
-
-    /// Return the indexed `VMFunctionImport`.
-    fn imported_function(&self, index: FuncIndex) -> &VMFunctionImport {
-        unsafe { &*self.vmctx_plus_offset(self.offsets().vmctx_vmfunction_import(index)) }
-    }
-
-    /// Return the index `VMTableImport`.
-    fn imported_table(&self, index: TableIndex) -> &VMTableImport {
-        unsafe { &*self.vmctx_plus_offset(self.offsets().vmctx_vmtable_import(index)) }
-    }
-
-    /// Return the indexed `VMMemoryImport`.
-    fn imported_memory(&self, index: MemoryIndex) -> &VMMemoryImport {
-        unsafe { &*self.vmctx_plus_offset(self.offsets().vmctx_vmmemory_import(index)) }
-    }
-
-    /// Return the indexed `VMGlobalImport`.
-    fn imported_global(&self, index: GlobalIndex) -> &VMGlobalImport {
-        unsafe { &*self.vmctx_plus_offset(self.offsets().vmctx_vmglobal_import(index)) }
-    }
-
-    /// Return the indexed `VMTableDefinition`.
-    #[allow(dead_code)]
-    fn table(&mut self, index: DefinedTableIndex) -> VMTableDefinition {
-        unsafe { *self.table_ptr(index) }
-    }
-
-    /// Updates the value for a defined table to `VMTableDefinition`.
-    fn set_table(&mut self, index: DefinedTableIndex, table: VMTableDefinition) {
-        unsafe {
-            *self.table_ptr(index) = table;
-        }
-    }
-
-    /// Return the indexed `VMTableDefinition`.
-    fn table_ptr(&mut self, index: DefinedTableIndex) -> *mut VMTableDefinition {
-        unsafe { self.vmctx_plus_offset_mut(self.offsets().vmctx_vmtable_definition(index)) }
-    }
-
-    /// Get a locally defined or imported memory.
-    pub(crate) fn get_memory(&self, index: MemoryIndex) -> VMMemoryDefinition {
-        if let Some(defined_index) = self.module().defined_memory_index(index) {
-            self.memory(defined_index)
-        } else {
-            let import = self.imported_memory(index);
-            unsafe { VMMemoryDefinition::load(import.from) }
-        }
-    }
-
-    /// Get a locally defined or imported memory.
-    pub(crate) fn get_runtime_memory(&mut self, index: MemoryIndex) -> &mut Memory {
-        if let Some(defined_index) = self.module().defined_memory_index(index) {
-            unsafe { &mut *self.get_defined_memory(defined_index) }
-        } else {
-            let import = self.imported_memory(index);
-            unsafe {
-                let ptr =
-                    Instance::from_vmctx(import.vmctx, |i| i.get_defined_memory(import.index));
-                &mut *ptr
-            }
-        }
-    }
-
-    /// Return the indexed `VMMemoryDefinition`.
-    fn memory(&self, index: DefinedMemoryIndex) -> VMMemoryDefinition {
-        unsafe { VMMemoryDefinition::load(self.memory_ptr(index)) }
-    }
-
-    /// Set the indexed memory to `VMMemoryDefinition`.
-    fn set_memory(&self, index: DefinedMemoryIndex, mem: VMMemoryDefinition) {
-        unsafe {
-            *self.memory_ptr(index) = mem;
-        }
-    }
-
-    /// Return the indexed `VMMemoryDefinition`.
-    fn memory_ptr(&self, index: DefinedMemoryIndex) -> *mut VMMemoryDefinition {
-        unsafe { *self.vmctx_plus_offset(self.offsets().vmctx_vmmemory_pointer(index)) }
-    }
-
-    /// Return the memories defined within this instance (not imported).
-    pub fn defined_memories<'a>(
-        &'a self,
-    ) -> impl ExactSizeIterator<Item = (DefinedMemoryIndex, &'a Memory)> + 'a {
-        self.memories
-            .iter()
-            .map(|(index, (_alloc_index, memory))| (index, memory))
-    }
-
-    /// Return the indexed `VMGlobalDefinition`.
-    fn global(&mut self, index: DefinedGlobalIndex) -> &VMGlobalDefinition {
-        unsafe { &*self.global_ptr(index) }
-    }
-
-    /// Return the indexed `VMGlobalDefinition`.
-    fn global_ptr(&mut self, index: DefinedGlobalIndex) -> *mut VMGlobalDefinition {
-        unsafe { self.vmctx_plus_offset_mut(self.offsets().vmctx_vmglobal_definition(index)) }
-    }
-
-    /// Get a raw pointer to the global at the given index regardless whether it
-    /// is defined locally or imported from another module.
-    ///
-    /// Panics if the index is out of bound or is the reserved value.
-    pub(crate) fn defined_or_imported_global_ptr(
-        &mut self,
-        index: GlobalIndex,
-    ) -> *mut VMGlobalDefinition {
-        if let Some(index) = self.module().defined_global_index(index) {
-            self.global_ptr(index)
-        } else {
-            self.imported_global(index).from
-        }
-    }
-
-    /// Get all globals within this instance.
-    ///
-    /// Returns both import and defined globals.
-    ///
-    /// Returns both exported and non-exported globals.
-    ///
-    /// Gives access to the full globals space.
-    pub fn all_globals<'a>(
-        &'a mut self,
-    ) -> impl ExactSizeIterator<Item = (GlobalIndex, ExportGlobal)> + 'a {
-        let module = self.module().clone();
-        module.globals.keys().map(move |idx| {
-            (
-                idx,
-                ExportGlobal {
-                    definition: self.defined_or_imported_global_ptr(idx),
-                    global: self.module().globals[idx],
-                },
-            )
-        })
-    }
-
-    /// Get the globals defined in this instance (not imported).
-    pub fn defined_globals<'a>(
-        &'a mut self,
-    ) -> impl ExactSizeIterator<Item = (DefinedGlobalIndex, ExportGlobal)> + 'a {
-        let module = self.module().clone();
-        module
-            .globals
-            .keys()
-            .skip(module.num_imported_globals)
-            .map(move |global_idx| {
-                let def_idx = module.defined_global_index(global_idx).unwrap();
-                let global = ExportGlobal {
-                    definition: self.global_ptr(def_idx),
-                    global: self.module().globals[global_idx],
-                };
-                (def_idx, global)
-            })
-    }
-
-    /// Return a pointer to the interrupts structure
-    #[inline]
-    pub fn runtime_limits(&mut self) -> *mut *const VMRuntimeLimits {
-        unsafe { self.vmctx_plus_offset_mut(self.offsets().vmctx_runtime_limits()) }
-    }
-
-    /// Return a pointer to the global epoch counter used by this instance.
-    pub fn epoch_ptr(&mut self) -> *mut *const AtomicU64 {
-        unsafe { self.vmctx_plus_offset_mut(self.offsets().vmctx_epoch_ptr()) }
-    }
-
-    /// Return a pointer to the `VMExternRefActivationsTable`.
-    pub fn externref_activations_table(&mut self) -> *mut *mut VMExternRefActivationsTable {
-        unsafe { self.vmctx_plus_offset_mut(self.offsets().vmctx_externref_activations_table()) }
-    }
-
-    /// Gets a pointer to this instance's `Store` which was originally
-    /// configured on creation.
-    ///
-    /// # Panics
-    ///
-    /// This will panic if the originally configured store was `None`. That can
-    /// happen for host functions so host functions can't be queried what their
-    /// original `Store` was since it's just retained as null (since host
-    /// functions are shared amongst threads and don't all share the same
-    /// store).
-    #[inline]
-    pub fn store(&self) -> *mut dyn Store {
-        let ptr =
-            unsafe { *self.vmctx_plus_offset::<*mut dyn Store>(self.offsets().vmctx_store()) };
-        assert!(!ptr.is_null());
-        ptr
-    }
-
-    pub(crate) unsafe fn set_store(&mut self, store: Option<*mut dyn Store>) {
-        if let Some(store) = store {
-            *self.vmctx_plus_offset_mut(self.offsets().vmctx_store()) = store;
-            *self.runtime_limits() = (*store).vmruntime_limits();
-            *self.epoch_ptr() = (*store).epoch_ptr();
-            *self.externref_activations_table() = (*store).externref_activations_table().0;
-        } else {
-            assert_eq!(
-                mem::size_of::<*mut dyn Store>(),
-                mem::size_of::<[*mut (); 2]>()
-            );
-            *self.vmctx_plus_offset_mut::<[*mut (); 2]>(self.offsets().vmctx_store()) =
-                [ptr::null_mut(), ptr::null_mut()];
-
-            *self.runtime_limits() = ptr::null_mut();
-            *self.epoch_ptr() = ptr::null_mut();
-            *self.externref_activations_table() = ptr::null_mut();
-        }
-    }
-
-    pub(crate) unsafe fn set_callee(&mut self, callee: Option<NonNull<VMFunctionBody>>) {
-        *self.vmctx_plus_offset_mut(self.offsets().vmctx_callee()) =
-            callee.map_or(ptr::null_mut(), |c| c.as_ptr());
-    }
-
-    /// Return a reference to the vmctx used by compiled wasm code.
-    #[inline]
-    pub fn vmctx(&self) -> *mut VMContext {
-        // The definition of this method is subtle but intentional. The goal
-        // here is that effectively this should return `&mut self.vmctx`, but
-        // it's not quite so simple. Some more documentation is available on the
-        // `vmctx_self_reference` field, but the general idea is that we're
-        // creating a pointer to return with proper provenance. Provenance is
-        // still in the works in Rust at the time of this writing but the load
-        // of the `self.vmctx_self_reference` field is important here as it
-        // affects how LLVM thinks about aliasing with respect to the returned
-        // pointer.
-        //
-        // The intention of this method is to codegen to machine code as `&mut
-        // self.vmctx`, however. While it doesn't show up like this in LLVM IR
-        // (there's an actual load of the field) it does look like that by the
-        // time the backend runs. (that's magic to me, the backend removing
-        // loads...)
-        //
-        // As a final minor note, strict provenance APIs are not stable on Rust
-        // today so the `sptr` crate is used. This crate provides the extension
-        // trait `Strict` but the method names conflict with the nightly methods
-        // so a different syntax is used to invoke methods here.
-        let addr = std::ptr::addr_of!(self.vmctx);
-        Strict::with_addr(self.vmctx_self_reference.as_ptr(), Strict::addr(addr))
-    }
-
-    fn get_exported_func(&mut self, index: FuncIndex) -> ExportFunction {
-        let func_ref = self.get_func_ref(index).unwrap();
-        let func_ref = NonNull::new(func_ref as *const VMFuncRef as *mut _).unwrap();
-        ExportFunction { func_ref }
-    }
-
-    fn get_exported_table(&mut self, index: TableIndex) -> ExportTable {
-        let (definition, vmctx) = if let Some(def_index) = self.module().defined_table_index(index)
-        {
-            (self.table_ptr(def_index), self.vmctx())
-        } else {
-            let import = self.imported_table(index);
-            (import.from, import.vmctx)
-        };
-        ExportTable {
-            definition,
-            vmctx,
-            table: self.module().table_plans[index].clone(),
-        }
-    }
-
-    fn get_exported_memory(&mut self, index: MemoryIndex) -> ExportMemory {
-        let (definition, vmctx, def_index) =
-            if let Some(def_index) = self.module().defined_memory_index(index) {
-                (self.memory_ptr(def_index), self.vmctx(), def_index)
-            } else {
-                let import = self.imported_memory(index);
-                (import.from, import.vmctx, import.index)
-            };
-        ExportMemory {
-            definition,
-            vmctx,
-            memory: self.module().memory_plans[index].clone(),
-            index: def_index,
-        }
-    }
-
-    fn get_exported_global(&mut self, index: GlobalIndex) -> ExportGlobal {
-        ExportGlobal {
-            definition: if let Some(def_index) = self.module().defined_global_index(index) {
-                self.global_ptr(def_index)
-            } else {
-                self.imported_global(index).from
-            },
-            global: self.module().globals[index],
-        }
-    }
-
-    /// Return an iterator over the exports of this instance.
-    ///
-    /// 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, EntityIndex> {
-        self.module().exports.iter()
-    }
-
-    /// Return a reference to the custom state attached to this instance.
-    #[inline]
-    pub fn host_state(&self) -> &dyn Any {
-        &*self.host_state
-    }
-
-    /// Return the table index for the given `VMTableDefinition`.
-    pub unsafe fn table_index(&mut self, table: &VMTableDefinition) -> DefinedTableIndex {
-        let index = DefinedTableIndex::new(
-            usize::try_from(
-                (table as *const VMTableDefinition)
-                    .offset_from(self.table_ptr(DefinedTableIndex::new(0))),
-            )
-            .unwrap(),
-        );
-        assert!(index.index() < self.tables.len());
-        index
-    }
-
-    /// Grow memory by the specified amount of pages.
-    ///
-    /// Returns `None` if memory can't be grown by the specified amount
-    /// of pages. Returns `Some` with the old size in bytes if growth was
-    /// successful.
-    pub(crate) fn memory_grow(
-        &mut self,
-        index: MemoryIndex,
-        delta: u64,
-    ) -> Result<Option<usize>, Error> {
-        match self.module().defined_memory_index(index) {
-            Some(idx) => self.defined_memory_grow(idx, delta),
-            None => {
-                let import = self.imported_memory(index);
-                unsafe {
-                    Instance::from_vmctx(import.vmctx, |i| {
-                        i.defined_memory_grow(import.index, delta)
-                    })
-                }
-            }
-        }
-    }
-
-    fn defined_memory_grow(
-        &mut self,
-        idx: DefinedMemoryIndex,
-        delta: u64,
-    ) -> Result<Option<usize>, Error> {
-        let store = unsafe { &mut *self.store() };
-        let memory = &mut self.memories[idx].1;
-
-        let result = unsafe { memory.grow(delta, Some(store)) };
-
-        // Update the state used by a non-shared Wasm memory in case the base
-        // pointer and/or the length changed.
-        if memory.as_shared_memory().is_none() {
-            let vmmemory = memory.vmmemory();
-            self.set_memory(idx, vmmemory);
-        }
-
-        result
-    }
-
-    pub(crate) fn table_element_type(&mut self, table_index: TableIndex) -> TableElementType {
-        unsafe { (*self.get_table(table_index)).element_type() }
-    }
-
-    /// Grow table by the specified amount of elements, filling them with
-    /// `init_value`.
-    ///
-    /// Returns `None` if table can't be grown by the specified amount of
-    /// elements, or if `init_value` is the wrong type of table element.
-    pub(crate) fn table_grow(
-        &mut self,
-        table_index: TableIndex,
-        delta: u32,
-        init_value: TableElement,
-    ) -> Result<Option<u32>, Error> {
-        self.with_defined_table_index_and_instance(table_index, |i, instance| {
-            instance.defined_table_grow(i, delta, init_value)
-        })
-    }
-
-    fn defined_table_grow(
-        &mut self,
-        table_index: DefinedTableIndex,
-        delta: u32,
-        init_value: TableElement,
-    ) -> Result<Option<u32>, Error> {
-        let store = unsafe { &mut *self.store() };
-        let table = &mut self
-            .tables
-            .get_mut(table_index)
-            .unwrap_or_else(|| panic!("no table for index {}", table_index.index()))
-            .1;
-
-        let result = unsafe { table.grow(delta, init_value, store) };
-
-        // Keep the `VMContext` pointers used by compiled Wasm code up to
-        // date.
-        let element = self.tables[table_index].1.vmtable();
-        self.set_table(table_index, element);
-
-        result
-    }
-
-    fn alloc_layout(offsets: &VMOffsets<HostPtr>) -> Layout {
-        let size = mem::size_of::<Self>()
-            .checked_add(usize::try_from(offsets.size_of_vmctx()).unwrap())
-            .unwrap();
-        let align = mem::align_of::<Self>();
-        Layout::from_size_align(size, align).unwrap()
-    }
-
-    /// Construct a new VMFuncRef for the given function
-    /// (imported or defined in this module) and store into the given
-    /// location. Used during lazy initialization.
-    ///
-    /// Note that our current lazy-init scheme actually calls this every
-    /// time the funcref pointer is fetched; this turns out to be better
-    /// than tracking state related to whether it's been initialized
-    /// before, because resetting that state on (re)instantiation is
-    /// very expensive if there are many funcrefs.
-    fn construct_func_ref(&mut self, index: FuncIndex, sig: SignatureIndex, into: *mut VMFuncRef) {
-        let type_index = unsafe {
-            let base: *const VMSharedSignatureIndex =
-                *self.vmctx_plus_offset_mut(self.offsets().vmctx_signature_ids_array());
-            *base.add(sig.index())
-        };
-
-        let func_ref = if let Some(def_index) = self.module().defined_func_index(index) {
-            VMFuncRef {
-                native_call: self
-                    .runtime_info
-                    .native_to_wasm_trampoline(def_index)
-                    .expect("should have native-to-Wasm trampoline for escaping function"),
-                array_call: self
-                    .runtime_info
-                    .array_to_wasm_trampoline(def_index)
-                    .expect("should have array-to-Wasm trampoline for escaping function"),
-                wasm_call: Some(self.runtime_info.function(def_index)),
-                vmctx: VMOpaqueContext::from_vmcontext(self.vmctx()),
-                type_index,
-            }
-        } else {
-            let import = self.imported_function(index);
-            VMFuncRef {
-                native_call: import.native_call,
-                array_call: import.array_call,
-                wasm_call: Some(import.wasm_call),
-                vmctx: import.vmctx,
-                type_index,
-            }
-        };
-
-        // Safety: we have a `&mut self`, so we have exclusive access
-        // to this Instance.
-        unsafe {
-            std::ptr::write(into, func_ref);
-        }
-    }
-
-    /// Get a `&VMFuncRef` for the given `FuncIndex`.
-    ///
-    /// Returns `None` if the index is the reserved index value.
-    ///
-    /// The returned reference is a stable reference that won't be moved and can
-    /// be passed into JIT code.
-    pub(crate) fn get_func_ref(&mut self, index: FuncIndex) -> Option<*mut VMFuncRef> {
-        if index == FuncIndex::reserved_value() {
-            return None;
-        }
-
-        // Safety: we have a `&mut self`, so we have exclusive access
-        // to this Instance.
-        unsafe {
-            // For now, we eagerly initialize an funcref struct in-place
-            // whenever asked for a reference to it. This is mostly
-            // fine, because in practice each funcref is unlikely to be
-            // requested more than a few times: once-ish for funcref
-            // tables used for call_indirect (the usual compilation
-            // strategy places each function in the table at most once),
-            // and once or a few times when fetching exports via API.
-            // Note that for any case driven by table accesses, the lazy
-            // table init behaves like a higher-level cache layer that
-            // protects this initialization from happening multiple
-            // times, via that particular table at least.
-            //
-            // When `ref.func` becomes more commonly used or if we
-            // otherwise see a use-case where this becomes a hotpath,
-            // we can reconsider by using some state to track
-            // "uninitialized" explicitly, for example by zeroing the
-            // funcrefs (perhaps together with other
-            // zeroed-at-instantiate-time state) or using a separate
-            // is-initialized bitmap.
-            //
-            // We arrived at this design because zeroing memory is
-            // expensive, so it's better for instantiation performance
-            // if we don't have to track "is-initialized" state at
-            // all!
-            let func = &self.module().functions[index];
-            let sig = func.signature;
-            let func_ref: *mut VMFuncRef = self
-                .vmctx_plus_offset_mut::<VMFuncRef>(self.offsets().vmctx_func_ref(func.func_ref));
-            self.construct_func_ref(index, sig, func_ref);
-
-            Some(func_ref)
-        }
-    }
-
-    /// The `table.init` operation: initializes a portion of a table with a
-    /// passive element.
-    ///
-    /// # Errors
-    ///
-    /// Returns a `Trap` error when the range within the table is out of bounds
-    /// or the range within the passive element is out of bounds.
-    pub(crate) fn table_init(
-        &mut self,
-        table_index: TableIndex,
-        elem_index: ElemIndex,
-        dst: u32,
-        src: u32,
-        len: u32,
-    ) -> Result<(), Trap> {
-        // TODO: this `clone()` shouldn't be necessary but is used for now to
-        // inform `rustc` that the lifetime of the elements here are
-        // disconnected from the lifetime of `self`.
-        let module = self.module().clone();
-
-        let elements = match module.passive_elements_map.get(&elem_index) {
-            Some(index) if !self.dropped_elements.contains(elem_index) => {
-                module.passive_elements[*index].as_ref()
-            }
-            _ => &[],
-        };
-        self.table_init_segment(table_index, elements, dst, src, len)
-    }
-
-    pub(crate) fn table_init_segment(
-        &mut self,
-        table_index: TableIndex,
-        elements: &[FuncIndex],
-        dst: u32,
-        src: u32,
-        len: u32,
-    ) -> Result<(), Trap> {
-        // https://webassembly.github.io/bulk-memory-operations/core/exec/instructions.html#exec-table-init
-
-        let table = unsafe { &mut *self.get_table(table_index) };
-
-        let elements = match elements
-            .get(usize::try_from(src).unwrap()..)
-            .and_then(|s| s.get(..usize::try_from(len).unwrap()))
-        {
-            Some(elements) => elements,
-            None => return Err(Trap::TableOutOfBounds),
-        };
-
-        match table.element_type() {
-            TableElementType::Func => {
-                table.init_funcs(
-                    dst,
-                    elements
-                        .iter()
-                        .map(|idx| self.get_func_ref(*idx).unwrap_or(std::ptr::null_mut())),
-                )?;
-            }
-
-            TableElementType::Extern => {
-                debug_assert!(elements.iter().all(|e| *e == FuncIndex::reserved_value()));
-                table.fill(dst, TableElement::ExternRef(None), len)?;
-            }
-        }
-        Ok(())
-    }
-
-    /// Drop an element.
-    pub(crate) fn elem_drop(&mut self, elem_index: ElemIndex) {
-        // https://webassembly.github.io/reference-types/core/exec/instructions.html#exec-elem-drop
-
-        self.dropped_elements.insert(elem_index);
-
-        // Note that we don't check that we actually removed a segment because
-        // dropping a non-passive segment is a no-op (not a trap).
-    }
-
-    /// Get a locally-defined memory.
-    pub fn get_defined_memory(&mut self, index: DefinedMemoryIndex) -> *mut Memory {
-        ptr::addr_of_mut!(self.memories[index].1)
-    }
-
-    /// Do a `memory.copy`
-    ///
-    /// # Errors
-    ///
-    /// Returns a `Trap` error when the source or destination ranges are out of
-    /// bounds.
-    pub(crate) fn memory_copy(
-        &mut self,
-        dst_index: MemoryIndex,
-        dst: u64,
-        src_index: MemoryIndex,
-        src: u64,
-        len: u64,
-    ) -> Result<(), Trap> {
-        // https://webassembly.github.io/reference-types/core/exec/instructions.html#exec-memory-copy
-
-        let src_mem = self.get_memory(src_index);
-        let dst_mem = self.get_memory(dst_index);
-
-        let src = self.validate_inbounds(src_mem.current_length(), src, len)?;
-        let dst = self.validate_inbounds(dst_mem.current_length(), dst, len)?;
-
-        // Bounds and casts are checked above, by this point we know that
-        // everything is safe.
-        unsafe {
-            let dst = dst_mem.base.add(dst);
-            let src = src_mem.base.add(src);
-            // FIXME audit whether this is safe in the presence of shared memory
-            // (https://github.com/bytecodealliance/wasmtime/issues/4203).
-            ptr::copy(src, dst, len as usize);
-        }
-
-        Ok(())
-    }
-
-    fn validate_inbounds(&self, max: usize, ptr: u64, len: u64) -> Result<usize, Trap> {
-        let oob = || Trap::MemoryOutOfBounds;
-        let end = ptr
-            .checked_add(len)
-            .and_then(|i| usize::try_from(i).ok())
-            .ok_or_else(oob)?;
-        if end > max {
-            Err(oob())
-        } else {
-            Ok(ptr as usize)
-        }
-    }
-
-    /// Perform the `memory.fill` operation on a locally defined memory.
-    ///
-    /// # Errors
-    ///
-    /// Returns a `Trap` error if the memory range is out of bounds.
-    pub(crate) fn memory_fill(
-        &mut self,
-        memory_index: MemoryIndex,
-        dst: u64,
-        val: u8,
-        len: u64,
-    ) -> Result<(), Trap> {
-        let memory = self.get_memory(memory_index);
-        let dst = self.validate_inbounds(memory.current_length(), dst, len)?;
-
-        // Bounds and casts are checked above, by this point we know that
-        // everything is safe.
-        unsafe {
-            let dst = memory.base.add(dst);
-            // FIXME audit whether this is safe in the presence of shared memory
-            // (https://github.com/bytecodealliance/wasmtime/issues/4203).
-            ptr::write_bytes(dst, val, len as usize);
-        }
-
-        Ok(())
-    }
-
-    /// Performs the `memory.init` operation.
-    ///
-    /// # Errors
-    ///
-    /// Returns a `Trap` error if the destination range is out of this module's
-    /// memory's bounds or if the source range is outside the data segment's
-    /// bounds.
-    pub(crate) fn memory_init(
-        &mut self,
-        memory_index: MemoryIndex,
-        data_index: DataIndex,
-        dst: u64,
-        src: u32,
-        len: u32,
-    ) -> Result<(), Trap> {
-        let range = match self.module().passive_data_map.get(&data_index).cloned() {
-            Some(range) if !self.dropped_data.contains(data_index) => range,
-            _ => 0..0,
-        };
-        self.memory_init_segment(memory_index, range, dst, src, len)
-    }
-
-    pub(crate) fn wasm_data(&self, range: Range<u32>) -> &[u8] {
-        &self.runtime_info.wasm_data()[range.start as usize..range.end as usize]
-    }
-
-    pub(crate) fn memory_init_segment(
-        &mut self,
-        memory_index: MemoryIndex,
-        range: Range<u32>,
-        dst: u64,
-        src: u32,
-        len: u32,
-    ) -> Result<(), Trap> {
-        // https://webassembly.github.io/bulk-memory-operations/core/exec/instructions.html#exec-memory-init
-
-        let memory = self.get_memory(memory_index);
-        let data = self.wasm_data(range);
-        let dst = self.validate_inbounds(memory.current_length(), dst, len.into())?;
-        let src = self.validate_inbounds(data.len(), src.into(), len.into())?;
-        let len = len as usize;
-
-        unsafe {
-            let src_start = data.as_ptr().add(src);
-            let dst_start = memory.base.add(dst);
-            // FIXME audit whether this is safe in the presence of shared memory
-            // (https://github.com/bytecodealliance/wasmtime/issues/4203).
-            ptr::copy_nonoverlapping(src_start, dst_start, len);
-        }
-
-        Ok(())
-    }
-
-    /// Drop the given data segment, truncating its length to zero.
-    pub(crate) fn data_drop(&mut self, data_index: DataIndex) {
-        self.dropped_data.insert(data_index);
-
-        // Note that we don't check that we actually removed a segment because
-        // dropping a non-passive segment is a no-op (not a trap).
-    }
-
-    /// Get a table by index regardless of whether it is locally-defined
-    /// or an imported, foreign table. Ensure that the given range of
-    /// elements in the table is lazily initialized.  We define this
-    /// operation all-in-one for safety, to ensure the lazy-init
-    /// happens.
-    ///
-    /// Takes an `Iterator` for the index-range to lazy-initialize,
-    /// for flexibility. This can be a range, single item, or empty
-    /// sequence, for example. The iterator should return indices in
-    /// increasing order, so that the break-at-out-of-bounds behavior
-    /// works correctly.
-    pub(crate) fn get_table_with_lazy_init(
-        &mut self,
-        table_index: TableIndex,
-        range: impl Iterator<Item = u32>,
-    ) -> *mut Table {
-        self.with_defined_table_index_and_instance(table_index, |idx, instance| {
-            instance.get_defined_table_with_lazy_init(idx, range)
-        })
-    }
-
-    /// Gets the raw runtime table data structure owned by this instance
-    /// given the provided `idx`.
-    ///
-    /// The `range` specified is eagerly initialized for funcref tables.
-    pub fn get_defined_table_with_lazy_init(
-        &mut self,
-        idx: DefinedTableIndex,
-        range: impl Iterator<Item = u32>,
-    ) -> *mut Table {
-        let elt_ty = self.tables[idx].1.element_type();
-
-        if elt_ty == TableElementType::Func {
-            for i in range {
-                let value = match self.tables[idx].1.get(i) {
-                    Some(value) => value,
-                    None => {
-                        // Out-of-bounds; caller will handle by likely
-                        // throwing a trap. No work to do to lazy-init
-                        // beyond the end.
-                        break;
-                    }
-                };
-
-                if !value.is_uninit() {
-                    continue;
-                }
-
-                // The table element `i` is uninitialized and is now being
-                // initialized. This must imply that a `precompiled` list of
-                // function indices is available for this table. The precompiled
-                // list is extracted and then it is consulted with `i` to
-                // determine the function that is going to be initialized. Note
-                // that `i` may be outside the limits of the static
-                // initialization so it's a fallible `get` instead of an index.
-                let module = self.module();
-                let precomputed = match &module.table_initialization.initial_values[idx] {
-                    TableInitialValue::Null { precomputed } => precomputed,
-                    TableInitialValue::FuncRef(_) => unreachable!(),
-                };
-                let func_index = precomputed.get(i as usize).cloned();
-                let func_ref = func_index
-                    .and_then(|func_index| self.get_func_ref(func_index))
-                    .unwrap_or(std::ptr::null_mut());
-                self.tables[idx]
-                    .1
-                    .set(i, TableElement::FuncRef(func_ref))
-                    .expect("Table type should match and index should be in-bounds");
-            }
-        }
-
-        ptr::addr_of_mut!(self.tables[idx].1)
-    }
-
-    /// Get a table by index regardless of whether it is locally-defined or an
-    /// imported, foreign table.
-    pub(crate) fn get_table(&mut self, table_index: TableIndex) -> *mut Table {
-        self.with_defined_table_index_and_instance(table_index, |idx, instance| {
-            ptr::addr_of_mut!(instance.tables[idx].1)
-        })
-    }
-
-    /// Get a locally-defined table.
-    pub(crate) fn get_defined_table(&mut self, index: DefinedTableIndex) -> *mut Table {
-        ptr::addr_of_mut!(self.tables[index].1)
-    }
-
-    pub(crate) fn with_defined_table_index_and_instance<R>(
-        &mut self,
-        index: TableIndex,
-        f: impl FnOnce(DefinedTableIndex, &mut Instance) -> R,
-    ) -> R {
-        if let Some(defined_table_index) = self.module().defined_table_index(index) {
-            f(defined_table_index, self)
-        } else {
-            let import = self.imported_table(index);
-            unsafe {
-                Instance::from_vmctx(import.vmctx, |foreign_instance| {
-                    let foreign_table_def = import.from;
-                    let foreign_table_index = foreign_instance.table_index(&*foreign_table_def);
-                    f(foreign_table_index, foreign_instance)
-                })
-            }
-        }
-    }
-
-    /// Initialize the VMContext data associated with this Instance.
-    ///
-    /// The `VMContext` memory is assumed to be uninitialized; any field
-    /// that we need in a certain state will be explicitly written by this
-    /// function.
-    unsafe fn initialize_vmctx(
-        &mut self,
-        module: &Module,
-        offsets: &VMOffsets<HostPtr>,
-        store: StorePtr,
-        imports: Imports,
-    ) {
-        assert!(std::ptr::eq(module, self.module().as_ref()));
-
-        *self.vmctx_plus_offset_mut(offsets.vmctx_magic()) = VMCONTEXT_MAGIC;
-        self.set_callee(None);
-        self.set_store(store.as_raw());
-
-        // Initialize shared signatures
-        let signatures = self.runtime_info.signature_ids();
-        *self.vmctx_plus_offset_mut(offsets.vmctx_signature_ids_array()) = signatures.as_ptr();
-
-        // Initialize the built-in functions
-        *self.vmctx_plus_offset_mut(offsets.vmctx_builtin_functions()) =
-            &VMBuiltinFunctionsArray::INIT;
-
-        // Initialize the imports
-        debug_assert_eq!(imports.functions.len(), module.num_imported_funcs);
-        ptr::copy_nonoverlapping(
-            imports.functions.as_ptr(),
-            self.vmctx_plus_offset_mut(offsets.vmctx_imported_functions_begin()),
-            imports.functions.len(),
-        );
-        debug_assert_eq!(imports.tables.len(), module.num_imported_tables);
-        ptr::copy_nonoverlapping(
-            imports.tables.as_ptr(),
-            self.vmctx_plus_offset_mut(offsets.vmctx_imported_tables_begin()),
-            imports.tables.len(),
-        );
-        debug_assert_eq!(imports.memories.len(), module.num_imported_memories);
-        ptr::copy_nonoverlapping(
-            imports.memories.as_ptr(),
-            self.vmctx_plus_offset_mut(offsets.vmctx_imported_memories_begin()),
-            imports.memories.len(),
-        );
-        debug_assert_eq!(imports.globals.len(), module.num_imported_globals);
-        ptr::copy_nonoverlapping(
-            imports.globals.as_ptr(),
-            self.vmctx_plus_offset_mut(offsets.vmctx_imported_globals_begin()),
-            imports.globals.len(),
-        );
-
-        // N.B.: there is no need to initialize the funcrefs array because we
-        // eagerly construct each element in it whenever asked for a reference
-        // to that element. In other words, there is no state needed to track
-        // the lazy-init, so we don't need to initialize any state now.
-
-        // Initialize the defined tables
-        let mut ptr = self.vmctx_plus_offset_mut(offsets.vmctx_tables_begin());
-        for i in 0..module.table_plans.len() - module.num_imported_tables {
-            ptr::write(ptr, self.tables[DefinedTableIndex::new(i)].1.vmtable());
-            ptr = ptr.add(1);
-        }
-
-        // Initialize the defined memories. This fills in both the
-        // `defined_memories` table and the `owned_memories` table at the same
-        // time. Entries in `defined_memories` hold a pointer to a definition
-        // (all memories) whereas the `owned_memories` hold the actual
-        // definitions of memories owned (not shared) in the module.
-        let mut ptr = self.vmctx_plus_offset_mut(offsets.vmctx_memories_begin());
-        let mut owned_ptr = self.vmctx_plus_offset_mut(offsets.vmctx_owned_memories_begin());
-        for i in 0..module.memory_plans.len() - module.num_imported_memories {
-            let defined_memory_index = DefinedMemoryIndex::new(i);
-            let memory_index = module.memory_index(defined_memory_index);
-            if module.memory_plans[memory_index].memory.shared {
-                let def_ptr = self.memories[defined_memory_index]
-                    .1
-                    .as_shared_memory()
-                    .unwrap()
-                    .vmmemory_ptr();
-                ptr::write(ptr, def_ptr.cast_mut());
-            } else {
-                ptr::write(owned_ptr, self.memories[defined_memory_index].1.vmmemory());
-                ptr::write(ptr, owned_ptr);
-                owned_ptr = owned_ptr.add(1);
-            }
-            ptr = ptr.add(1);
-        }
-
-        // Initialize the defined globals
-        self.initialize_vmctx_globals(module);
-    }
-
-    unsafe fn initialize_vmctx_globals(&mut self, module: &Module) {
-        for (index, init) in module.global_initializers.iter() {
-            let to = self.global_ptr(index);
-            let wasm_ty = module.globals[module.global_index(index)].wasm_ty;
-
-            // Initialize the global before writing to it
-            ptr::write(to, VMGlobalDefinition::new());
-
-            match *init {
-                GlobalInit::I32Const(x) => {
-                    let index = module.global_index(index);
-                    if index.index() == 0 {
-                        #[cfg(feature = "wmemcheck")]
-                        {
-                            if let Some(wmemcheck) = &mut self.wmemcheck_state {
-                                wmemcheck.set_stack_size(x as usize);
-                            }
-                        }
-                    }
-                    *(*to).as_i32_mut() = x;
-                }
-                GlobalInit::I64Const(x) => *(*to).as_i64_mut() = x,
-                GlobalInit::F32Const(x) => *(*to).as_f32_bits_mut() = x,
-                GlobalInit::F64Const(x) => *(*to).as_f64_bits_mut() = x,
-                GlobalInit::V128Const(x) => *(*to).as_u128_mut() = x,
-                GlobalInit::GetGlobal(x) => {
-                    let from = if let Some(def_x) = module.defined_global_index(x) {
-                        self.global(def_x)
-                    } else {
-                        &*self.imported_global(x).from
-                    };
-                    // Globals of type `externref` need to manage the reference
-                    // count as values move between globals, everything else is just
-                    // copy-able bits.
-                    match wasm_ty {
-                        WasmType::Ref(WasmRefType {
-                            heap_type: WasmHeapType::Extern,
-                            ..
-                        }) => *(*to).as_externref_mut() = from.as_externref().clone(),
-                        _ => ptr::copy_nonoverlapping(from, to, 1),
-                    }
-                }
-                GlobalInit::RefFunc(f) => {
-                    *(*to).as_func_ref_mut() = self.get_func_ref(f).unwrap();
-                }
-                GlobalInit::RefNullConst => match wasm_ty {
-                    // `VMGlobalDefinition::new()` already zeroed out the bits
-                    WasmType::Ref(WasmRefType { nullable: true, .. }) => {}
-                    ty => panic!("unsupported reference type for global: {:?}", ty),
-                },
-            }
-        }
-    }
-
-    fn wasm_fault(&self, addr: usize) -> Option<WasmFault> {
-        let mut fault = None;
-        for (_, (_, memory)) in self.memories.iter() {
-            let accessible = memory.wasm_accessible();
-            if accessible.start <= addr && addr < accessible.end {
-                // All linear memories should be disjoint so assert that no
-                // prior fault has been found.
-                assert!(fault.is_none());
-                fault = Some(WasmFault {
-                    memory_size: memory.byte_size(),
-                    wasm_address: u64::try_from(addr - accessible.start).unwrap(),
-                });
-            }
-        }
-        fault
-    }
-}
-
-impl Drop for Instance {
-    fn drop(&mut self) {
-        // Drop any defined globals
-        let module = self.module().clone();
-        for (idx, global) in module.globals.iter() {
-            let idx = match module.defined_global_index(idx) {
-                Some(idx) => idx,
-                None => continue,
-            };
-            match global.wasm_ty {
-                // For now only externref globals need to get destroyed
-                WasmType::Ref(WasmRefType {
-                    heap_type: WasmHeapType::Extern,
-                    ..
-                }) => {}
-                _ => continue,
-            }
-            unsafe {
-                drop((*self.global_ptr(idx)).as_externref_mut().take());
-            }
-        }
-    }
-}
-
-/// A handle holding an `Instance` of a WebAssembly module.
-pub struct InstanceHandle {
-    instance: Option<SendSyncPtr<Instance>>,
-}
-
-impl InstanceHandle {
-    /// Creates an "empty" instance handle which internally has a null pointer
-    /// to an instance.
-    pub fn null() -> InstanceHandle {
-        InstanceHandle { instance: None }
-    }
-
-    /// Return a raw pointer to the vmctx used by compiled wasm code.
-    #[inline]
-    pub fn vmctx(&self) -> *mut VMContext {
-        self.instance().vmctx()
-    }
-
-    /// Return a reference to a module.
-    pub fn module(&self) -> &Arc<Module> {
-        self.instance().module()
-    }
-
-    /// Lookup a function by index.
-    pub fn get_exported_func(&mut self, export: FuncIndex) -> ExportFunction {
-        self.instance_mut().get_exported_func(export)
-    }
-
-    /// Lookup a global by index.
-    pub fn get_exported_global(&mut self, export: GlobalIndex) -> ExportGlobal {
-        self.instance_mut().get_exported_global(export)
-    }
-
-    /// Lookup a memory by index.
-    pub fn get_exported_memory(&mut self, export: MemoryIndex) -> ExportMemory {
-        self.instance_mut().get_exported_memory(export)
-    }
-
-    /// Lookup a table by index.
-    pub fn get_exported_table(&mut self, export: TableIndex) -> ExportTable {
-        self.instance_mut().get_exported_table(export)
-    }
-
-    /// Lookup an item with the given index.
-    pub fn get_export_by_index(&mut self, export: EntityIndex) -> Export {
-        match export {
-            EntityIndex::Function(i) => Export::Function(self.get_exported_func(i)),
-            EntityIndex::Global(i) => Export::Global(self.get_exported_global(i)),
-            EntityIndex::Table(i) => Export::Table(self.get_exported_table(i)),
-            EntityIndex::Memory(i) => Export::Memory(self.get_exported_memory(i)),
-        }
-    }
-
-    /// Return an iterator over the exports of this instance.
-    ///
-    /// 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, EntityIndex> {
-        self.instance().exports()
-    }
-
-    /// Return a reference to the custom state attached to this instance.
-    pub fn host_state(&self) -> &dyn Any {
-        self.instance().host_state()
-    }
-
-    /// Get a table defined locally within this module.
-    pub fn get_defined_table(&mut self, index: DefinedTableIndex) -> *mut Table {
-        self.instance_mut().get_defined_table(index)
-    }
-
-    /// Get a table defined locally within this module, lazily
-    /// initializing the given range first.
-    pub fn get_defined_table_with_lazy_init(
-        &mut self,
-        index: DefinedTableIndex,
-        range: impl Iterator<Item = u32>,
-    ) -> *mut Table {
-        let index = self.instance().module().table_index(index);
-        self.instance_mut().get_table_with_lazy_init(index, range)
-    }
-
-    /// Get all memories within this instance.
-    ///
-    /// Returns both import and defined memories.
-    ///
-    /// Returns both exported and non-exported memories.
-    ///
-    /// Gives access to the full memories space.
-    pub fn all_memories<'a>(
-        &'a mut self,
-    ) -> impl ExactSizeIterator<Item = (MemoryIndex, ExportMemory)> + 'a {
-        let indices = (0..self.module().memory_plans.len())
-            .map(|i| MemoryIndex::new(i))
-            .collect::<Vec<_>>();
-        indices
-            .into_iter()
-            .map(|i| (i, self.get_exported_memory(i)))
-    }
-
-    /// Return the memories defined in this instance (not imported).
-    pub fn defined_memories<'a>(&'a mut self) -> impl ExactSizeIterator<Item = ExportMemory> + 'a {
-        let num_imported = self.module().num_imported_memories;
-        self.all_memories()
-            .skip(num_imported)
-            .map(|(_i, memory)| memory)
-    }
-
-    /// Get all globals within this instance.
-    ///
-    /// Returns both import and defined globals.
-    ///
-    /// Returns both exported and non-exported globals.
-    ///
-    /// Gives access to the full globals space.
-    pub fn all_globals<'a>(
-        &'a mut self,
-    ) -> impl ExactSizeIterator<Item = (GlobalIndex, ExportGlobal)> + 'a {
-        self.instance_mut().all_globals()
-    }
-
-    /// Get the globals defined in this instance (not imported).
-    pub fn defined_globals<'a>(
-        &'a mut self,
-    ) -> impl ExactSizeIterator<Item = (DefinedGlobalIndex, ExportGlobal)> + 'a {
-        self.instance_mut().defined_globals()
-    }
-
-    /// Return a reference to the contained `Instance`.
-    #[inline]
-    pub(crate) fn instance(&self) -> &Instance {
-        unsafe { &*self.instance.unwrap().as_ptr() }
-    }
-
-    pub(crate) fn instance_mut(&mut self) -> &mut Instance {
-        unsafe { &mut *self.instance.unwrap().as_ptr() }
-    }
-
-    /// Returns the `Store` pointer that was stored on creation
-    #[inline]
-    pub fn store(&self) -> *mut dyn Store {
-        self.instance().store()
-    }
-
-    /// Configure the `*mut dyn Store` internal pointer after-the-fact.
-    ///
-    /// This is provided for the original `Store` itself to configure the first
-    /// self-pointer after the original `Box` has been initialized.
-    pub unsafe fn set_store(&mut self, store: *mut dyn Store) {
-        self.instance_mut().set_store(Some(store));
-    }
-
-    /// Returns a clone of this instance.
-    ///
-    /// This is unsafe because the returned handle here is just a cheap clone
-    /// of the internals, there's no lifetime tracking around its validity.
-    /// You'll need to ensure that the returned handles all go out of scope at
-    /// the same time.
-    #[inline]
-    pub unsafe fn clone(&self) -> InstanceHandle {
-        InstanceHandle {
-            instance: self.instance,
-        }
-    }
-
-    /// Performs post-initialization of an instance after its handle has been
-    /// created and registered with a store.
-    ///
-    /// Failure of this function means that the instance still must persist
-    /// within the store since failure may indicate partial failure, or some
-    /// state could be referenced by other instances.
-    pub fn initialize(&mut self, module: &Module, is_bulk_memory: bool) -> Result<()> {
-        allocator::initialize_instance(self.instance_mut(), module, is_bulk_memory)
-    }
-
-    /// Attempts to convert from the host `addr` specified to a WebAssembly
-    /// based address recorded in `WasmFault`.
-    ///
-    /// This method will check all linear memories that this instance contains
-    /// to see if any of them contain `addr`. If one does then `Some` is
-    /// returned with metadata about the wasm fault. Otherwise `None` is
-    /// returned and `addr` doesn't belong to this instance.
-    pub fn wasm_fault(&self, addr: usize) -> Option<WasmFault> {
-        self.instance().wasm_fault(addr)
-    }
-}
diff --git a/crates/runtime/src/instance/allocator.rs b/crates/runtime/src/instance/allocator.rs
deleted file mode 100644
index 5205d87c3444..000000000000
--- a/crates/runtime/src/instance/allocator.rs
+++ /dev/null
@@ -1,712 +0,0 @@
-use crate::imports::Imports;
-use crate::instance::{Instance, InstanceHandle};
-use crate::memory::Memory;
-use crate::mpk::ProtectionKey;
-use crate::table::Table;
-use crate::{CompiledModuleId, ModuleRuntimeInfo, Store};
-use anyhow::{anyhow, bail, Result};
-use std::{alloc, any::Any, mem, ptr, sync::Arc};
-use wasmtime_environ::{
-    DefinedMemoryIndex, DefinedTableIndex, HostPtr, InitMemory, MemoryInitialization,
-    MemoryInitializer, MemoryPlan, Module, PrimaryMap, TableInitialValue, TablePlan, TableSegment,
-    Trap, VMOffsets, WasmType, WASM_PAGE_SIZE,
-};
-
-#[cfg(feature = "component-model")]
-use wasmtime_environ::{
-    component::{Component, VMComponentOffsets},
-    StaticModuleIndex,
-};
-
-mod on_demand;
-pub use self::on_demand::OnDemandInstanceAllocator;
-
-#[cfg(feature = "pooling-allocator")]
-mod pooling;
-#[cfg(feature = "pooling-allocator")]
-pub use self::pooling::{InstanceLimits, PoolingInstanceAllocator, PoolingInstanceAllocatorConfig};
-
-/// Represents a request for a new runtime instance.
-pub struct InstanceAllocationRequest<'a> {
-    /// The info related to the compiled version of this module,
-    /// needed for instantiation: function metadata, JIT code
-    /// addresses, precomputed images for lazy memory and table
-    /// initialization, and the like. This Arc is cloned and held for
-    /// the lifetime of the instance.
-    pub runtime_info: &'a Arc<dyn ModuleRuntimeInfo>,
-
-    /// The imports to use for the instantiation.
-    pub imports: Imports<'a>,
-
-    /// The host state to associate with the instance.
-    pub host_state: Box<dyn Any + Send + Sync>,
-
-    /// A pointer to the "store" for this instance to be allocated. The store
-    /// correlates with the `Store` in wasmtime itself, and lots of contextual
-    /// information about the execution of wasm can be learned through the
-    /// store.
-    ///
-    /// Note that this is a raw pointer and has a static lifetime, both of which
-    /// are a bit of a lie. This is done purely so a store can learn about
-    /// itself when it gets called as a host function, and additionally so this
-    /// runtime can access internals as necessary (such as the
-    /// VMExternRefActivationsTable or the resource limiter methods).
-    ///
-    /// Note that this ends up being a self-pointer to the instance when stored.
-    /// The reason is that the instance itself is then stored within the store.
-    /// We use a number of `PhantomPinned` declarations to indicate this to the
-    /// compiler. More info on this in `wasmtime/src/store.rs`
-    pub store: StorePtr,
-
-    /// Indicates '--wmemcheck' flag.
-    pub wmemcheck: bool,
-
-    /// Request that the instance's memories be protected by a specific
-    /// protection key.
-    pub pkey: Option<ProtectionKey>,
-}
-
-/// A pointer to a Store. This Option<*mut dyn Store> is wrapped in a struct
-/// so that the function to create a &mut dyn Store is a method on a member of
-/// InstanceAllocationRequest, rather than on a &mut InstanceAllocationRequest
-/// itself, because several use-sites require a split mut borrow on the
-/// InstanceAllocationRequest.
-pub struct StorePtr(Option<*mut dyn Store>);
-
-impl StorePtr {
-    /// A pointer to no Store.
-    pub fn empty() -> Self {
-        Self(None)
-    }
-
-    /// A pointer to a Store.
-    pub fn new(ptr: *mut dyn Store) -> Self {
-        Self(Some(ptr))
-    }
-
-    /// The raw contents of this struct
-    pub fn as_raw(&self) -> Option<*mut dyn Store> {
-        self.0.clone()
-    }
-
-    /// Use the StorePtr as a mut ref to the Store.
-    ///
-    /// Safety: must not be used outside the original lifetime of the borrow.
-    pub(crate) unsafe fn get(&mut self) -> Option<&mut dyn Store> {
-        match self.0 {
-            Some(ptr) => Some(&mut *ptr),
-            None => None,
-        }
-    }
-}
-
-/// The index of a memory allocation within an `InstanceAllocator`.
-#[derive(Clone, Copy, Debug, Eq, PartialEq, PartialOrd, Ord)]
-pub struct MemoryAllocationIndex(u32);
-
-impl Default for MemoryAllocationIndex {
-    fn default() -> Self {
-        // A default `MemoryAllocationIndex` that can be used with
-        // `InstanceAllocator`s that don't actually need indices.
-        MemoryAllocationIndex(u32::MAX)
-    }
-}
-
-impl MemoryAllocationIndex {
-    /// Get the underlying index of this `MemoryAllocationIndex`.
-    pub fn index(&self) -> usize {
-        self.0 as usize
-    }
-}
-
-/// The index of a table allocation within an `InstanceAllocator`.
-#[derive(Clone, Copy, Debug, Eq, PartialEq, PartialOrd, Ord)]
-pub struct TableAllocationIndex(u32);
-
-impl Default for TableAllocationIndex {
-    fn default() -> Self {
-        // A default `TableAllocationIndex` that can be used with
-        // `InstanceAllocator`s that don't actually need indices.
-        TableAllocationIndex(u32::MAX)
-    }
-}
-
-impl TableAllocationIndex {
-    /// Get the underlying index of this `TableAllocationIndex`.
-    pub fn index(&self) -> usize {
-        self.0 as usize
-    }
-}
-
-/// Trait that represents the hooks needed to implement an instance allocator.
-///
-/// Implement this trait when implementing new instance allocators, but don't
-/// use this trait when you need an instance allocator. Instead use the
-/// `InstanceAllocator` trait for that, which has additional helper methods and
-/// a blanket implementation for all types that implement this trait.
-///
-/// # Safety
-///
-/// This trait is unsafe as it requires knowledge of Wasmtime's runtime
-/// internals to implement correctly.
-pub unsafe trait InstanceAllocatorImpl {
-    /// Validate whether a component (including all of its contained core
-    /// modules) is allocatable by this instance allocator.
-    #[cfg(feature = "component-model")]
-    fn validate_component_impl<'a>(
-        &self,
-        component: &Component,
-        offsets: &VMComponentOffsets<HostPtr>,
-        get_module: &'a dyn Fn(StaticModuleIndex) -> &'a Module,
-    ) -> Result<()>;
-
-    /// Validate whether a module is allocatable by this instance allocator.
-    fn validate_module_impl(&self, module: &Module, offsets: &VMOffsets<HostPtr>) -> Result<()>;
-
-    /// Increment the count of concurrent component instances that are currently
-    /// allocated, if applicable.
-    ///
-    /// Not all instance allocators will have limits for the maximum number of
-    /// concurrent component instances that can be live at the same time, and
-    /// these allocators may implement this method with a no-op.
-    //
-    // Note: It would be nice to have an associated type that on construction
-    // does the increment and on drop does the decrement but there are two
-    // problems with this:
-    //
-    // 1. This trait's implementations are always used as trait objects, and
-    //    associated types are not object safe.
-    //
-    // 2. We would want a parameterized `Drop` implementation so that we could
-    //    pass in the `InstanceAllocatorImpl` on drop, but this doesn't exist in
-    //    Rust. Therefore, we would be forced to add reference counting and
-    //    stuff like that to keep a handle on the instance allocator from this
-    //    theoretical type. That's a bummer.
-    fn increment_component_instance_count(&self) -> Result<()>;
-
-    /// The dual of `increment_component_instance_count`.
-    fn decrement_component_instance_count(&self);
-
-    /// Increment the count of concurrent core module instances that are
-    /// currently allocated, if applicable.
-    ///
-    /// Not all instance allocators will have limits for the maximum number of
-    /// concurrent core module instances that can be live at the same time, and
-    /// these allocators may implement this method with a no-op.
-    fn increment_core_instance_count(&self) -> Result<()>;
-
-    /// The dual of `increment_core_instance_count`.
-    fn decrement_core_instance_count(&self);
-
-    /// Allocate a memory for an instance.
-    ///
-    /// # Unsafety
-    ///
-    /// The memory and its associated module must have already been validated by
-    /// `Self::validate_module` and passed that validation.
-    unsafe fn allocate_memory(
-        &self,
-        request: &mut InstanceAllocationRequest,
-        memory_plan: &MemoryPlan,
-        memory_index: DefinedMemoryIndex,
-    ) -> Result<(MemoryAllocationIndex, Memory)>;
-
-    /// Deallocate an instance's previously allocated memory.
-    ///
-    /// # Unsafety
-    ///
-    /// The memory must have previously been allocated by
-    /// `Self::allocate_memory`, be at the given index, and must currently be
-    /// allocated. It must never be used again.
-    unsafe fn deallocate_memory(
-        &self,
-        memory_index: DefinedMemoryIndex,
-        allocation_index: MemoryAllocationIndex,
-        memory: Memory,
-    );
-
-    /// Allocate a table for an instance.
-    ///
-    /// # Unsafety
-    ///
-    /// The table and its associated module must have already been validated by
-    /// `Self::validate_module` and passed that validation.
-    unsafe fn allocate_table(
-        &self,
-        req: &mut InstanceAllocationRequest,
-        table_plan: &TablePlan,
-        table_index: DefinedTableIndex,
-    ) -> Result<(TableAllocationIndex, Table)>;
-
-    /// Deallocate an instance's previously allocated table.
-    ///
-    /// # Unsafety
-    ///
-    /// The table must have previously been allocated by `Self::allocate_table`,
-    /// be at the given index, and must currently be allocated. It must never be
-    /// used again.
-    unsafe fn deallocate_table(
-        &self,
-        table_index: DefinedTableIndex,
-        allocation_index: TableAllocationIndex,
-        table: Table,
-    );
-
-    /// Allocates a fiber stack for calling async functions on.
-    #[cfg(feature = "async")]
-    fn allocate_fiber_stack(&self) -> Result<wasmtime_fiber::FiberStack>;
-
-    /// Deallocates a fiber stack that was previously allocated with
-    /// `allocate_fiber_stack`.
-    ///
-    /// # Safety
-    ///
-    /// The provided stack is required to have been allocated with
-    /// `allocate_fiber_stack`.
-    #[cfg(feature = "async")]
-    unsafe fn deallocate_fiber_stack(&self, stack: &wasmtime_fiber::FiberStack);
-
-    /// Purges all lingering resources related to `module` from within this
-    /// allocator.
-    ///
-    /// Primarily present for the pooling allocator to remove mappings of
-    /// this module from slots in linear memory.
-    fn purge_module(&self, module: CompiledModuleId);
-
-    /// Use the next available protection key.
-    ///
-    /// The pooling allocator can use memory protection keys (MPK) for
-    /// compressing the guard regions protecting against OOB. Each
-    /// pool-allocated store needs its own key.
-    fn next_available_pkey(&self) -> Option<ProtectionKey>;
-
-    /// Restrict access to memory regions protected by `pkey`.
-    ///
-    /// This is useful for the pooling allocator, which can use memory
-    /// protection keys (MPK). Note: this may still allow access to other
-    /// protection keys, such as the default kernel key; see implementations of
-    /// this.
-    fn restrict_to_pkey(&self, pkey: ProtectionKey);
-
-    /// Allow access to memory regions protected by any protection key.
-    fn allow_all_pkeys(&self);
-}
-
-/// A thing that can allocate instances.
-///
-/// Don't implement this trait directly, instead implement
-/// `InstanceAllocatorImpl` and you'll get this trait for free via a blanket
-/// impl.
-pub trait InstanceAllocator: InstanceAllocatorImpl {
-    /// Validate whether a component (including all of its contained core
-    /// modules) is allocatable with this instance allocator.
-    #[cfg(feature = "component-model")]
-    fn validate_component<'a>(
-        &self,
-        component: &Component,
-        offsets: &VMComponentOffsets<HostPtr>,
-        get_module: &'a dyn Fn(StaticModuleIndex) -> &'a Module,
-    ) -> Result<()> {
-        InstanceAllocatorImpl::validate_component_impl(self, component, offsets, get_module)
-    }
-
-    /// Validate whether a core module is allocatable with this instance
-    /// allocator.
-    fn validate_module(&self, module: &Module, offsets: &VMOffsets<HostPtr>) -> Result<()> {
-        InstanceAllocatorImpl::validate_module_impl(self, module, offsets)
-    }
-
-    /// Allocates a fresh `InstanceHandle` for the `req` given.
-    ///
-    /// This will allocate memories and tables internally from this allocator
-    /// and weave that altogether into a final and complete `InstanceHandle`
-    /// ready to be registered with a store.
-    ///
-    /// Note that the returned instance must still have `.initialize(..)` called
-    /// on it to complete the instantiation process.
-    ///
-    /// # Unsafety
-    ///
-    /// The request's associated module, memories, tables, and vmctx must have
-    /// already have been validated by `Self::validate_module`.
-    unsafe fn allocate_module(
-        &self,
-        mut request: InstanceAllocationRequest,
-    ) -> Result<InstanceHandle> {
-        let module = request.runtime_info.module();
-
-        #[cfg(debug_assertions)]
-        InstanceAllocatorImpl::validate_module_impl(self, module, request.runtime_info.offsets())
-            .expect("module should have already been validated before allocation");
-
-        self.increment_core_instance_count()?;
-
-        let num_defined_memories = module.memory_plans.len() - module.num_imported_memories;
-        let mut memories = PrimaryMap::with_capacity(num_defined_memories);
-
-        let num_defined_tables = module.table_plans.len() - module.num_imported_tables;
-        let mut tables = PrimaryMap::with_capacity(num_defined_tables);
-
-        match (|| {
-            self.allocate_memories(&mut request, &mut memories)?;
-            self.allocate_tables(&mut request, &mut tables)?;
-            Ok(())
-        })() {
-            Ok(_) => Ok(Instance::new(
-                request,
-                memories,
-                tables,
-                &module.memory_plans,
-            )),
-            Err(e) => {
-                self.deallocate_memories(&mut memories);
-                self.deallocate_tables(&mut tables);
-                self.decrement_core_instance_count();
-                Err(e)
-            }
-        }
-    }
-
-    /// Deallocates the provided instance.
-    ///
-    /// This will null-out the pointer within `handle` and otherwise reclaim
-    /// resources such as tables, memories, and the instance memory itself.
-    ///
-    /// # Unsafety
-    ///
-    /// The instance must have previously been allocated by `Self::allocate`.
-    unsafe fn deallocate_module(&self, handle: &mut InstanceHandle) {
-        self.deallocate_memories(&mut handle.instance_mut().memories);
-        self.deallocate_tables(&mut handle.instance_mut().tables);
-
-        let layout = Instance::alloc_layout(handle.instance().offsets());
-        let ptr = handle.instance.take().unwrap();
-        ptr::drop_in_place(ptr.as_ptr());
-        alloc::dealloc(ptr.as_ptr().cast(), layout);
-
-        self.decrement_core_instance_count();
-    }
-
-    /// Allocate the memories for the given instance allocation request, pushing
-    /// them into `memories`.
-    ///
-    /// # Unsafety
-    ///
-    /// The request's associated module and memories must have previously been
-    /// validated by `Self::validate_module`.
-    unsafe fn allocate_memories(
-        &self,
-        request: &mut InstanceAllocationRequest,
-        memories: &mut PrimaryMap<DefinedMemoryIndex, (MemoryAllocationIndex, Memory)>,
-    ) -> Result<()> {
-        let module = request.runtime_info.module();
-
-        #[cfg(debug_assertions)]
-        InstanceAllocatorImpl::validate_module_impl(self, module, request.runtime_info.offsets())
-            .expect("module should have already been validated before allocation");
-
-        for (memory_index, memory_plan) in module
-            .memory_plans
-            .iter()
-            .skip(module.num_imported_memories)
-        {
-            let memory_index = module
-                .defined_memory_index(memory_index)
-                .expect("should be a defined memory since we skipped imported ones");
-
-            memories.push(self.allocate_memory(request, memory_plan, memory_index)?);
-        }
-
-        Ok(())
-    }
-
-    /// Deallocate all the memories in the given primary map.
-    ///
-    /// # Unsafety
-    ///
-    /// The memories must have previously been allocated by
-    /// `Self::allocate_memories`.
-    unsafe fn deallocate_memories(
-        &self,
-        memories: &mut PrimaryMap<DefinedMemoryIndex, (MemoryAllocationIndex, Memory)>,
-    ) {
-        for (memory_index, (allocation_index, memory)) in mem::take(memories) {
-            // Because deallocating memory is infallible, we don't need to worry
-            // about leaking subsequent memories if the first memory failed to
-            // deallocate. If deallocating memory ever becomes fallible, we will
-            // need to be careful here!
-            self.deallocate_memory(memory_index, allocation_index, memory);
-        }
-    }
-
-    /// Allocate tables for the given instance allocation request, pushing them
-    /// into `tables`.
-    ///
-    /// # Unsafety
-    ///
-    /// The request's associated module and tables must have previously been
-    /// validated by `Self::validate_module`.
-    unsafe fn allocate_tables(
-        &self,
-        request: &mut InstanceAllocationRequest,
-        tables: &mut PrimaryMap<DefinedTableIndex, (TableAllocationIndex, Table)>,
-    ) -> Result<()> {
-        let module = request.runtime_info.module();
-
-        #[cfg(debug_assertions)]
-        InstanceAllocatorImpl::validate_module_impl(self, module, request.runtime_info.offsets())
-            .expect("module should have already been validated before allocation");
-
-        for (index, plan) in module.table_plans.iter().skip(module.num_imported_tables) {
-            let def_index = module
-                .defined_table_index(index)
-                .expect("should be a defined table since we skipped imported ones");
-
-            tables.push(self.allocate_table(request, plan, def_index)?);
-        }
-
-        Ok(())
-    }
-
-    /// Deallocate all the tables in the given primary map.
-    ///
-    /// # Unsafety
-    ///
-    /// The tables must have previously been allocated by
-    /// `Self::allocate_tables`.
-    unsafe fn deallocate_tables(
-        &self,
-        tables: &mut PrimaryMap<DefinedTableIndex, (TableAllocationIndex, Table)>,
-    ) {
-        for (table_index, (allocation_index, table)) in mem::take(tables) {
-            self.deallocate_table(table_index, allocation_index, table);
-        }
-    }
-}
-
-// Every `InstanceAllocatorImpl` is an `InstanceAllocator` when used
-// correctly. Also, no one is allowed to override this trait's methods, they
-// must use the defaults. This blanket impl provides both of those things.
-impl<T: InstanceAllocatorImpl> InstanceAllocator for T {}
-
-fn get_table_init_start(init: &TableSegment, instance: &mut Instance) -> Result<u32> {
-    match init.base {
-        Some(base) => {
-            let val = unsafe { *(*instance.defined_or_imported_global_ptr(base)).as_u32() };
-
-            init.offset
-                .checked_add(val)
-                .ok_or_else(|| anyhow!("element segment global base overflows"))
-        }
-        None => Ok(init.offset),
-    }
-}
-
-fn check_table_init_bounds(instance: &mut Instance, module: &Module) -> Result<()> {
-    for segment in module.table_initialization.segments.iter() {
-        let table = unsafe { &*instance.get_table(segment.table_index) };
-        let start = get_table_init_start(segment, instance)?;
-        let start = usize::try_from(start).unwrap();
-        let end = start.checked_add(segment.elements.len());
-
-        match end {
-            Some(end) if end <= table.size() as usize => {
-                // Initializer is in bounds
-            }
-            _ => {
-                bail!("table out of bounds: elements segment does not fit")
-            }
-        }
-    }
-
-    Ok(())
-}
-
-fn initialize_tables(instance: &mut Instance, module: &Module) -> Result<()> {
-    for (table, init) in module.table_initialization.initial_values.iter() {
-        match init {
-            // Tables are always initially null-initialized at this time
-            TableInitialValue::Null { precomputed: _ } => {}
-
-            TableInitialValue::FuncRef(idx) => {
-                let funcref = instance.get_func_ref(*idx).unwrap();
-                let table = unsafe { &mut *instance.get_defined_table(table) };
-                table.init_func(funcref)?;
-            }
-        }
-    }
-
-    // Note: if the module's table initializer state is in
-    // FuncTable mode, we will lazily initialize tables based on
-    // any statically-precomputed image of FuncIndexes, but there
-    // may still be "leftover segments" that could not be
-    // incorporated. So we have a unified handler here that
-    // iterates over all segments (Segments mode) or leftover
-    // segments (FuncTable mode) to initialize.
-    for segment in module.table_initialization.segments.iter() {
-        let start = get_table_init_start(segment, instance)?;
-        instance.table_init_segment(
-            segment.table_index,
-            &segment.elements,
-            start,
-            0,
-            segment.elements.len() as u32,
-        )?;
-    }
-
-    Ok(())
-}
-
-fn get_memory_init_start(init: &MemoryInitializer, instance: &mut Instance) -> Result<u64> {
-    match init.base {
-        Some(base) => {
-            let mem64 = instance.module().memory_plans[init.memory_index]
-                .memory
-                .memory64;
-            let val = unsafe {
-                let global = instance.defined_or_imported_global_ptr(base);
-                if mem64 {
-                    *(*global).as_u64()
-                } else {
-                    u64::from(*(*global).as_u32())
-                }
-            };
-
-            init.offset
-                .checked_add(val)
-                .ok_or_else(|| anyhow!("data segment global base overflows"))
-        }
-        None => Ok(init.offset),
-    }
-}
-
-fn check_memory_init_bounds(
-    instance: &mut Instance,
-    initializers: &[MemoryInitializer],
-) -> Result<()> {
-    for init in initializers {
-        let memory = instance.get_memory(init.memory_index);
-        let start = get_memory_init_start(init, instance)?;
-        let end = usize::try_from(start)
-            .ok()
-            .and_then(|start| start.checked_add(init.data.len()));
-
-        match end {
-            Some(end) if end <= memory.current_length() => {
-                // Initializer is in bounds
-            }
-            _ => {
-                bail!("memory out of bounds: data segment does not fit")
-            }
-        }
-    }
-
-    Ok(())
-}
-
-fn initialize_memories(instance: &mut Instance, module: &Module) -> Result<()> {
-    let memory_size_in_pages = &|instance: &mut Instance, memory| {
-        (instance.get_memory(memory).current_length() as u64) / u64::from(WASM_PAGE_SIZE)
-    };
-
-    // Loads the `global` value and returns it as a `u64`, but sign-extends
-    // 32-bit globals which can be used as the base for 32-bit memories.
-    let get_global_as_u64 = &mut |instance: &mut Instance, global| unsafe {
-        let def = instance.defined_or_imported_global_ptr(global);
-        if module.globals[global].wasm_ty == WasmType::I64 {
-            *(*def).as_u64()
-        } else {
-            u64::from(*(*def).as_u32())
-        }
-    };
-
-    // Delegates to the `init_memory` method which is sort of a duplicate of
-    // `instance.memory_init_segment` but is used at compile-time in other
-    // contexts so is shared here to have only one method of memory
-    // initialization.
-    //
-    // This call to `init_memory` notably implements all the bells and whistles
-    // so errors only happen if an out-of-bounds segment is found, in which case
-    // a trap is returned.
-    let ok = module.memory_initialization.init_memory(
-        instance,
-        InitMemory::Runtime {
-            memory_size_in_pages,
-            get_global_as_u64,
-        },
-        |instance, memory_index, init| {
-            // If this initializer applies to a defined memory but that memory
-            // doesn't need initialization, due to something like copy-on-write
-            // pre-initializing it via mmap magic, then this initializer can be
-            // skipped entirely.
-            if let Some(memory_index) = module.defined_memory_index(memory_index) {
-                if !instance.memories[memory_index].1.needs_init() {
-                    return true;
-                }
-            }
-            let memory = instance.get_memory(memory_index);
-
-            unsafe {
-                let src = instance.wasm_data(init.data.clone());
-                let dst = memory.base.add(usize::try_from(init.offset).unwrap());
-                // FIXME audit whether this is safe in the presence of shared
-                // memory
-                // (https://github.com/bytecodealliance/wasmtime/issues/4203).
-                ptr::copy_nonoverlapping(src.as_ptr(), dst, src.len())
-            }
-            true
-        },
-    );
-    if !ok {
-        return Err(Trap::MemoryOutOfBounds.into());
-    }
-
-    Ok(())
-}
-
-fn check_init_bounds(instance: &mut Instance, module: &Module) -> Result<()> {
-    check_table_init_bounds(instance, module)?;
-
-    match &module.memory_initialization {
-        MemoryInitialization::Segmented(initializers) => {
-            check_memory_init_bounds(instance, initializers)?;
-        }
-        // Statically validated already to have everything in-bounds.
-        MemoryInitialization::Static { .. } => {}
-    }
-
-    Ok(())
-}
-
-pub(super) fn initialize_instance(
-    instance: &mut Instance,
-    module: &Module,
-    is_bulk_memory: bool,
-) -> Result<()> {
-    // If bulk memory is not enabled, bounds check the data and element segments before
-    // making any changes. With bulk memory enabled, initializers are processed
-    // in-order and side effects are observed up to the point of an out-of-bounds
-    // initializer, so the early checking is not desired.
-    if !is_bulk_memory {
-        check_init_bounds(instance, module)?;
-    }
-
-    // Initialize the tables
-    initialize_tables(instance, module)?;
-
-    // Initialize the memories
-    initialize_memories(instance, &module)?;
-
-    Ok(())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn allocator_traits_are_object_safe() {
-        fn _instance_allocator(_: &dyn InstanceAllocatorImpl) {}
-        fn _instance_allocator_ext(_: &dyn InstanceAllocator) {}
-    }
-}
diff --git a/crates/runtime/src/instance/allocator/on_demand.rs b/crates/runtime/src/instance/allocator/on_demand.rs
deleted file mode 100644
index 935074729fd3..000000000000
--- a/crates/runtime/src/instance/allocator/on_demand.rs
+++ /dev/null
@@ -1,176 +0,0 @@
-use super::{
-    InstanceAllocationRequest, InstanceAllocatorImpl, MemoryAllocationIndex, TableAllocationIndex,
-};
-use crate::instance::RuntimeMemoryCreator;
-use crate::memory::{DefaultMemoryCreator, Memory};
-use crate::mpk::ProtectionKey;
-use crate::table::Table;
-use crate::CompiledModuleId;
-use anyhow::Result;
-use std::sync::Arc;
-use wasmtime_environ::{
-    DefinedMemoryIndex, DefinedTableIndex, HostPtr, MemoryPlan, Module, TablePlan, VMOffsets,
-};
-
-#[cfg(feature = "component-model")]
-use wasmtime_environ::{
-    component::{Component, VMComponentOffsets},
-    StaticModuleIndex,
-};
-
-/// Represents the on-demand instance allocator.
-#[derive(Clone)]
-pub struct OnDemandInstanceAllocator {
-    mem_creator: Option<Arc<dyn RuntimeMemoryCreator>>,
-    #[cfg(feature = "async")]
-    stack_size: usize,
-}
-
-impl OnDemandInstanceAllocator {
-    /// Creates a new on-demand instance allocator.
-    pub fn new(mem_creator: Option<Arc<dyn RuntimeMemoryCreator>>, stack_size: usize) -> Self {
-        let _ = stack_size; // suppress unused warnings w/o async feature
-        Self {
-            mem_creator,
-            #[cfg(feature = "async")]
-            stack_size,
-        }
-    }
-}
-
-impl Default for OnDemandInstanceAllocator {
-    fn default() -> Self {
-        Self {
-            mem_creator: None,
-            #[cfg(feature = "async")]
-            stack_size: 0,
-        }
-    }
-}
-
-unsafe impl InstanceAllocatorImpl for OnDemandInstanceAllocator {
-    #[cfg(feature = "component-model")]
-    fn validate_component_impl<'a>(
-        &self,
-        _component: &Component,
-        _offsets: &VMComponentOffsets<HostPtr>,
-        _get_module: &'a dyn Fn(StaticModuleIndex) -> &'a Module,
-    ) -> Result<()> {
-        Ok(())
-    }
-
-    fn validate_module_impl(&self, _module: &Module, _offsets: &VMOffsets<HostPtr>) -> Result<()> {
-        Ok(())
-    }
-
-    fn increment_component_instance_count(&self) -> Result<()> {
-        Ok(())
-    }
-
-    fn decrement_component_instance_count(&self) {}
-
-    fn increment_core_instance_count(&self) -> Result<()> {
-        Ok(())
-    }
-
-    fn decrement_core_instance_count(&self) {}
-
-    unsafe fn allocate_memory(
-        &self,
-        request: &mut InstanceAllocationRequest,
-        memory_plan: &MemoryPlan,
-        memory_index: DefinedMemoryIndex,
-    ) -> Result<(MemoryAllocationIndex, Memory)> {
-        let creator = self
-            .mem_creator
-            .as_deref()
-            .unwrap_or_else(|| &DefaultMemoryCreator);
-        let image = request.runtime_info.memory_image(memory_index)?;
-        let allocation_index = MemoryAllocationIndex::default();
-        let memory = Memory::new_dynamic(
-            memory_plan,
-            creator,
-            request
-                .store
-                .get()
-                .expect("if module has memory plans, store is not empty"),
-            image,
-        )?;
-        Ok((allocation_index, memory))
-    }
-
-    unsafe fn deallocate_memory(
-        &self,
-        _memory_index: DefinedMemoryIndex,
-        allocation_index: MemoryAllocationIndex,
-        _memory: Memory,
-    ) {
-        debug_assert_eq!(allocation_index, MemoryAllocationIndex::default());
-        // Normal destructors do all the necessary clean up.
-    }
-
-    unsafe fn allocate_table(
-        &self,
-        request: &mut InstanceAllocationRequest,
-        table_plan: &TablePlan,
-        _table_index: DefinedTableIndex,
-    ) -> Result<(TableAllocationIndex, Table)> {
-        let allocation_index = TableAllocationIndex::default();
-        let table = Table::new_dynamic(
-            table_plan,
-            request
-                .store
-                .get()
-                .expect("if module has table plans, store is not empty"),
-        )?;
-        Ok((allocation_index, table))
-    }
-
-    unsafe fn deallocate_table(
-        &self,
-        _table_index: DefinedTableIndex,
-        allocation_index: TableAllocationIndex,
-        _table: Table,
-    ) {
-        debug_assert_eq!(allocation_index, TableAllocationIndex::default());
-        // Normal destructors do all the necessary clean up.
-    }
-
-    #[cfg(feature = "async")]
-    fn allocate_fiber_stack(&self) -> Result<wasmtime_fiber::FiberStack> {
-        if self.stack_size == 0 {
-            anyhow::bail!("fiber stacks are not supported by the allocator")
-        }
-
-        let stack = wasmtime_fiber::FiberStack::new(self.stack_size)?;
-        Ok(stack)
-    }
-
-    #[cfg(feature = "async")]
-    unsafe fn deallocate_fiber_stack(&self, _stack: &wasmtime_fiber::FiberStack) {
-        // The on-demand allocator has no further bookkeeping for fiber stacks
-    }
-
-    fn purge_module(&self, _: CompiledModuleId) {}
-
-    fn next_available_pkey(&self) -> Option<ProtectionKey> {
-        // The on-demand allocator cannot use protection keys--it requires
-        // back-to-back allocation of memory slots that this allocator cannot
-        // guarantee.
-        None
-    }
-
-    fn restrict_to_pkey(&self, _: ProtectionKey) {
-        // The on-demand allocator cannot use protection keys; an on-demand
-        // allocator will never hand out protection keys to the stores its
-        // engine creates.
-        unreachable!()
-    }
-
-    fn allow_all_pkeys(&self) {
-        // The on-demand allocator cannot use protection keys; an on-demand
-        // allocator will never hand out protection keys to the stores its
-        // engine creates.
-        unreachable!()
-    }
-}
diff --git a/crates/runtime/src/instance/allocator/pooling.rs b/crates/runtime/src/instance/allocator/pooling.rs
deleted file mode 100644
index 7d00a59052bb..000000000000
--- a/crates/runtime/src/instance/allocator/pooling.rs
+++ /dev/null
@@ -1,705 +0,0 @@
-//! Implements the pooling instance allocator.
-//!
-//! The pooling instance allocator maps memory in advance and allocates
-//! instances, memories, tables, and stacks from a pool of available resources.
-//! Using the pooling instance allocator can speed up module instantiation when
-//! modules can be constrained based on configurable limits
-//! ([`InstanceLimits`]). Each new instance is stored in a "slot"; as instances
-//! are allocated and freed, these slots are either filled or emptied:
-//!
-//! ```text
-//! ┌──────┬──────┬──────┬──────┬──────┐
-//! │Slot 0│Slot 1│Slot 2│Slot 3│......│
-//! └──────┴──────┴──────┴──────┴──────┘
-//! ```
-//!
-//! Note that these slots are a useful abstraction but not exactly how this is
-//! mapped to memory in fact. Each new instance _does_ get associated with a
-//! slot number (see uses of `index` and [`SlotId`] in this module) but the
-//! parts of the instances are stored in separate pools: memories in the
-//! [`MemoryPool`], tables in the [`TablePool`], etc. What ties these various
-//! parts together is the slot number generated by an [`IndexAllocator`] .
-//!
-//! The [`MemoryPool`] protects Wasmtime from out-of-bounds memory accesses by
-//! inserting inaccessible guard regions between memory slots. The
-//! [`MemoryPool`] documentation has a more in-depth chart but one can think of
-//! memories being laid out like the following:
-//!
-//! ```text
-//! ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
-//! │Guard│Mem 0│Guard│Mem 1│Guard│Mem 2│.....│Guard│
-//! └─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘
-//! ```
-//!
-//! To complicate matters, each instance can have multiple memories, multiple
-//! tables, etc. You might think these would be stored consecutively in their
-//! respective pools (for instance `n`, table 0 is at table pool slot `n + 0`
-//! and table 1 is at `n + 1`), but for memories this is not the case. With
-//! protection keys enabled, memories do not need interleaved guard regions
-//! because the protection key will signal a fault if the wrong memory is
-//! accessed. Instead, the pooling allocator "stripes" the memories with
-//! different protection keys.
-//!
-//! This concept, dubbed [ColorGuard] in the original paper, relies on careful
-//! calculation of the memory sizes to prevent any "overlapping access": there
-//! are limited protection keys available (15) so the next memory using the same
-//! key must be at least as far away as the guard region we would insert
-//! otherwise. This ends up looking like the following, where a store for
-//! instance 0 (`I0`) "stripes" two memories (`M0` and `M1`) with the same
-//! protection key 1 and far enough apart to signal an OOB access:
-//!
-//! ```text
-//! ┌─────┬─────┬─────┬─────┬────────────────┬─────┬─────┬─────┐
-//! │.....│I0:M1│.....│.....│.<enough slots>.│I0:M2│.....│.....│
-//! ├─────┼─────┼─────┼─────┼────────────────┼─────┼─────┼─────┤
-//! │.....│key 1│key 2│key 3│..<more keys>...│key 1│key 2│.....│
-//! └─────┴─────┴─────┴─────┴────────────────┴─────┴─────┴─────┘
-//! ```
-//!
-//! [ColorGuard]: https://plas2022.github.io/files/pdf/SegueColorGuard.pdf
-
-mod index_allocator;
-mod memory_pool;
-mod table_pool;
-
-#[cfg(all(feature = "async", unix, not(miri)))]
-mod stack_pool;
-
-cfg_if::cfg_if! {
-    if #[cfg(windows)] {
-        mod windows;
-        use windows as imp;
-    } else {
-        mod unix;
-        use unix as imp;
-    }
-}
-
-use super::{
-    InstanceAllocationRequest, InstanceAllocatorImpl, MemoryAllocationIndex, TableAllocationIndex,
-};
-use crate::{
-    instance::Instance,
-    mpk::{self, MpkEnabled, ProtectionKey, ProtectionMask},
-    CompiledModuleId, Memory, Table,
-};
-use anyhow::{bail, Result};
-use memory_pool::MemoryPool;
-use std::{
-    mem,
-    sync::atomic::{AtomicU64, Ordering},
-};
-use table_pool::TablePool;
-use wasmtime_environ::{
-    DefinedMemoryIndex, DefinedTableIndex, HostPtr, MemoryPlan, Module, TablePlan, Tunables,
-    VMOffsets,
-};
-
-#[cfg(all(feature = "async", unix, not(miri)))]
-use stack_pool::StackPool;
-
-#[cfg(feature = "component-model")]
-use wasmtime_environ::{
-    component::{Component, VMComponentOffsets},
-    StaticModuleIndex,
-};
-
-fn round_up_to_pow2(n: usize, to: usize) -> usize {
-    debug_assert!(to > 0);
-    debug_assert!(to.is_power_of_two());
-    (n + to - 1) & !(to - 1)
-}
-
-/// Instance-related limit configuration for pooling.
-///
-/// More docs on this can be found at `wasmtime::PoolingAllocationConfig`.
-#[derive(Debug, Copy, Clone)]
-pub struct InstanceLimits {
-    /// The maximum number of component instances that may be allocated
-    /// concurrently.
-    pub total_component_instances: u32,
-
-    /// The maximum size of a component's `VMComponentContext`, not including
-    /// any of its inner core modules' `VMContext` sizes.
-    pub component_instance_size: usize,
-
-    /// The maximum number of core module instances that may be allocated
-    /// concurrently.
-    pub total_core_instances: u32,
-
-    /// The maximum number of core module instances that a single component may
-    /// transitively contain.
-    pub max_core_instances_per_component: u32,
-
-    /// The maximum number of Wasm linear memories that a component may
-    /// transitively contain.
-    pub max_memories_per_component: u32,
-
-    /// The maximum number of tables that a component may transitively contain.
-    pub max_tables_per_component: u32,
-
-    /// The total number of linear memories in the pool, across all instances.
-    pub total_memories: u32,
-
-    /// The total number of tables in the pool, across all instances.
-    pub total_tables: u32,
-
-    /// The total number of async stacks in the pool, across all instances.
-    #[cfg(feature = "async")]
-    pub total_stacks: u32,
-
-    /// Maximum size of a core instance's `VMContext`.
-    pub core_instance_size: usize,
-
-    /// Maximum number of tables per instance.
-    pub max_tables_per_module: u32,
-
-    /// Maximum number of table elements per table.
-    pub table_elements: u32,
-
-    /// Maximum number of linear memories per instance.
-    pub max_memories_per_module: u32,
-
-    /// Maximum number of Wasm pages for each linear memory.
-    pub memory_pages: u64,
-}
-
-impl Default for InstanceLimits {
-    fn default() -> Self {
-        // See doc comments for `wasmtime::PoolingAllocationConfig` for these
-        // default values
-        Self {
-            total_component_instances: 1000,
-            component_instance_size: 1 << 20, // 1 MiB
-            total_core_instances: 1000,
-            max_core_instances_per_component: 20,
-            max_memories_per_component: 20,
-            max_tables_per_component: 20,
-            total_memories: 1000,
-            total_tables: 1000,
-            #[cfg(feature = "async")]
-            total_stacks: 1000,
-            core_instance_size: 1 << 20, // 1 MiB
-            max_tables_per_module: 1,
-            table_elements: 10_000,
-            max_memories_per_module: 1,
-            memory_pages: 160,
-        }
-    }
-}
-
-/// Configuration options for the pooling instance allocator supplied at
-/// construction.
-#[derive(Copy, Clone, Debug)]
-pub struct PoolingInstanceAllocatorConfig {
-    /// See `PoolingAllocatorConfig::max_unused_warm_slots` in `wasmtime`
-    pub max_unused_warm_slots: u32,
-    /// The size, in bytes, of async stacks to allocate (not including the guard
-    /// page).
-    pub stack_size: usize,
-    /// The limits to apply to instances allocated within this allocator.
-    pub limits: InstanceLimits,
-    /// Whether or not async stacks are zeroed after use.
-    pub async_stack_zeroing: bool,
-    /// If async stack zeroing is enabled and the host platform is Linux this is
-    /// how much memory to zero out with `memset`.
-    ///
-    /// The rest of memory will be zeroed out with `madvise`.
-    pub async_stack_keep_resident: usize,
-    /// How much linear memory, in bytes, to keep resident after resetting for
-    /// use with the next instance. This much memory will be `memset` to zero
-    /// when a linear memory is deallocated.
-    ///
-    /// Memory exceeding this amount in the wasm linear memory will be released
-    /// with `madvise` back to the kernel.
-    ///
-    /// Only applicable on Linux.
-    pub linear_memory_keep_resident: usize,
-    /// Same as `linear_memory_keep_resident` but for tables.
-    pub table_keep_resident: usize,
-    /// Whether to enable memory protection keys.
-    pub memory_protection_keys: MpkEnabled,
-}
-
-impl Default for PoolingInstanceAllocatorConfig {
-    fn default() -> PoolingInstanceAllocatorConfig {
-        PoolingInstanceAllocatorConfig {
-            max_unused_warm_slots: 100,
-            stack_size: 2 << 20,
-            limits: InstanceLimits::default(),
-            async_stack_zeroing: false,
-            async_stack_keep_resident: 0,
-            linear_memory_keep_resident: 0,
-            table_keep_resident: 0,
-            memory_protection_keys: MpkEnabled::Disable,
-        }
-    }
-}
-
-/// Implements the pooling instance allocator.
-///
-/// This allocator internally maintains pools of instances, memories, tables,
-/// and stacks.
-///
-/// Note: the resource pools are manually dropped so that the fault handler
-/// terminates correctly.
-#[derive(Debug)]
-pub struct PoolingInstanceAllocator {
-    limits: InstanceLimits,
-
-    // The number of live core module and component instances at any given
-    // time. Note that this can temporarily go over the configured limit. This
-    // doesn't mean we have actually overshot, but that we attempted to allocate
-    // a new instance and incremented the counter, we've seen (or are about to
-    // see) that the counter is beyond the configured threshold, and are going
-    // to decrement the counter and return an error but haven't done so yet. See
-    // the increment trait methods for more details.
-    live_core_instances: AtomicU64,
-    live_component_instances: AtomicU64,
-
-    memories: MemoryPool,
-    tables: TablePool,
-
-    #[cfg(all(feature = "async", unix, not(miri)))]
-    stacks: StackPool,
-
-    #[cfg(all(feature = "async", windows))]
-    stack_size: usize,
-    #[cfg(all(feature = "async", windows))]
-    live_stacks: AtomicU64,
-}
-
-impl Drop for PoolingInstanceAllocator {
-    fn drop(&mut self) {
-        debug_assert_eq!(self.live_component_instances.load(Ordering::Acquire), 0);
-        debug_assert_eq!(self.live_core_instances.load(Ordering::Acquire), 0);
-
-        debug_assert!(self.memories.is_empty());
-        debug_assert!(self.tables.is_empty());
-
-        #[cfg(all(feature = "async", unix, not(miri)))]
-        debug_assert!(self.stacks.is_empty());
-        #[cfg(all(feature = "async", windows))]
-        debug_assert_eq!(self.live_stacks.load(Ordering::Acquire), 0);
-    }
-}
-
-impl PoolingInstanceAllocator {
-    /// Creates a new pooling instance allocator with the given strategy and limits.
-    pub fn new(config: &PoolingInstanceAllocatorConfig, tunables: &Tunables) -> Result<Self> {
-        Ok(Self {
-            limits: config.limits,
-            live_component_instances: AtomicU64::new(0),
-            live_core_instances: AtomicU64::new(0),
-            memories: MemoryPool::new(config, tunables)?,
-            tables: TablePool::new(config)?,
-            #[cfg(all(feature = "async", unix, not(miri)))]
-            stacks: StackPool::new(config)?,
-            #[cfg(all(feature = "async", windows))]
-            stack_size: config.stack_size,
-            #[cfg(all(feature = "async", windows))]
-            live_stacks: AtomicU64::new(0),
-        })
-    }
-
-    fn core_instance_size(&self) -> usize {
-        round_up_to_pow2(self.limits.core_instance_size, mem::align_of::<Instance>())
-    }
-
-    fn validate_table_plans(&self, module: &Module) -> Result<()> {
-        self.tables.validate(module)
-    }
-
-    fn validate_memory_plans(&self, module: &Module) -> Result<()> {
-        self.memories.validate(module)
-    }
-
-    fn validate_core_instance_size(&self, offsets: &VMOffsets<HostPtr>) -> Result<()> {
-        let layout = Instance::alloc_layout(offsets);
-        if layout.size() <= self.core_instance_size() {
-            return Ok(());
-        }
-
-        // If this `module` exceeds the allocation size allotted to it then an
-        // error will be reported here. The error of "required N bytes but
-        // cannot allocate that" is pretty opaque, however, because it's not
-        // clear what the breakdown of the N bytes are and what to optimize
-        // next. To help provide a better error message here some fancy-ish
-        // logic is done here to report the breakdown of the byte request into
-        // the largest portions and where it's coming from.
-        let mut message = format!(
-            "instance allocation for this module \
-             requires {} bytes which exceeds the configured maximum \
-             of {} bytes; breakdown of allocation requirement:\n\n",
-            layout.size(),
-            self.core_instance_size(),
-        );
-
-        let mut remaining = layout.size();
-        let mut push = |name: &str, bytes: usize| {
-            assert!(remaining >= bytes);
-            remaining -= bytes;
-
-            // If the `name` region is more than 5% of the allocation request
-            // then report it here, otherwise ignore it. We have less than 20
-            // fields so we're guaranteed that something should be reported, and
-            // otherwise it's not particularly interesting to learn about 5
-            // different fields that are all 8 or 0 bytes. Only try to report
-            // the "major" sources of bytes here.
-            if bytes > layout.size() / 20 {
-                message.push_str(&format!(
-                    " * {:.02}% - {} bytes - {}\n",
-                    ((bytes as f32) / (layout.size() as f32)) * 100.0,
-                    bytes,
-                    name,
-                ));
-            }
-        };
-
-        // The `Instance` itself requires some size allocated to it.
-        push("instance state management", mem::size_of::<Instance>());
-
-        // Afterwards the `VMContext`'s regions are why we're requesting bytes,
-        // so ask it for descriptions on each region's byte size.
-        for (desc, size) in offsets.region_sizes() {
-            push(desc, size as usize);
-        }
-
-        // double-check we accounted for all the bytes
-        assert_eq!(remaining, 0);
-
-        bail!("{}", message)
-    }
-
-    #[cfg(feature = "component-model")]
-    fn validate_component_instance_size(
-        &self,
-        offsets: &VMComponentOffsets<HostPtr>,
-    ) -> Result<()> {
-        if usize::try_from(offsets.size_of_vmctx()).unwrap() <= self.limits.component_instance_size
-        {
-            return Ok(());
-        }
-
-        // TODO: Add context with detailed accounting of what makes up all the
-        // `VMComponentContext`'s space like we do for module instances.
-        bail!(
-            "instance allocation for this component requires {} bytes of `VMComponentContext` \
-             space which exceeds the configured maximum of {} bytes",
-            offsets.size_of_vmctx(),
-            self.limits.component_instance_size
-        )
-    }
-}
-
-unsafe impl InstanceAllocatorImpl for PoolingInstanceAllocator {
-    #[cfg(feature = "component-model")]
-    fn validate_component_impl<'a>(
-        &self,
-        component: &Component,
-        offsets: &VMComponentOffsets<HostPtr>,
-        get_module: &'a dyn Fn(StaticModuleIndex) -> &'a Module,
-    ) -> Result<()> {
-        self.validate_component_instance_size(offsets)?;
-
-        let mut num_core_instances = 0;
-        let mut num_memories = 0;
-        let mut num_tables = 0;
-        for init in &component.initializers {
-            use wasmtime_environ::component::GlobalInitializer::*;
-            use wasmtime_environ::component::InstantiateModule;
-            match init {
-                InstantiateModule(InstantiateModule::Import(_, _)) => {
-                    num_core_instances += 1;
-                    // Can't statically account for the total vmctx size, number
-                    // of memories, and number of tables in this component.
-                }
-                InstantiateModule(InstantiateModule::Static(static_module_index, _)) => {
-                    let module = get_module(*static_module_index);
-                    let offsets = VMOffsets::new(HostPtr, &module);
-                    self.validate_module_impl(module, &offsets)?;
-                    num_core_instances += 1;
-                    num_memories += module.memory_plans.len() - module.num_imported_memories;
-                    num_tables += module.table_plans.len() - module.num_imported_tables;
-                }
-                LowerImport { .. }
-                | ExtractMemory(_)
-                | ExtractRealloc(_)
-                | ExtractPostReturn(_)
-                | Resource(_) => {}
-            }
-        }
-
-        if num_core_instances
-            > usize::try_from(self.limits.max_core_instances_per_component).unwrap()
-        {
-            bail!(
-                "The component transitively contains {num_core_instances} core module instances, \
-                 which exceeds the configured maximum of {}",
-                self.limits.max_core_instances_per_component
-            );
-        }
-
-        if num_memories > usize::try_from(self.limits.max_memories_per_component).unwrap() {
-            bail!(
-                "The component transitively contains {num_memories} Wasm linear memories, which \
-                 exceeds the configured maximum of {}",
-                self.limits.max_memories_per_component
-            );
-        }
-
-        if num_tables > usize::try_from(self.limits.max_tables_per_component).unwrap() {
-            bail!(
-                "The component transitively contains {num_tables} tables, which exceeds the \
-                 configured maximum of {}",
-                self.limits.max_tables_per_component
-            );
-        }
-
-        Ok(())
-    }
-
-    fn validate_module_impl(&self, module: &Module, offsets: &VMOffsets<HostPtr>) -> Result<()> {
-        self.validate_memory_plans(module)?;
-        self.validate_table_plans(module)?;
-        self.validate_core_instance_size(offsets)?;
-        Ok(())
-    }
-
-    fn increment_component_instance_count(&self) -> Result<()> {
-        let old_count = self.live_component_instances.fetch_add(1, Ordering::AcqRel);
-        if old_count >= u64::from(self.limits.total_component_instances) {
-            self.decrement_component_instance_count();
-            bail!(
-                "maximum concurrent component instance limit of {} reached",
-                self.limits.total_component_instances
-            );
-        }
-        Ok(())
-    }
-
-    fn decrement_component_instance_count(&self) {
-        self.live_component_instances.fetch_sub(1, Ordering::AcqRel);
-    }
-
-    fn increment_core_instance_count(&self) -> Result<()> {
-        let old_count = self.live_core_instances.fetch_add(1, Ordering::AcqRel);
-        if old_count >= u64::from(self.limits.total_core_instances) {
-            self.decrement_core_instance_count();
-            bail!(
-                "maximum concurrent core instance limit of {} reached",
-                self.limits.total_core_instances
-            );
-        }
-        Ok(())
-    }
-
-    fn decrement_core_instance_count(&self) {
-        self.live_core_instances.fetch_sub(1, Ordering::AcqRel);
-    }
-
-    unsafe fn allocate_memory(
-        &self,
-        request: &mut InstanceAllocationRequest,
-        memory_plan: &MemoryPlan,
-        memory_index: DefinedMemoryIndex,
-    ) -> Result<(MemoryAllocationIndex, Memory)> {
-        self.memories.allocate(request, memory_plan, memory_index)
-    }
-
-    unsafe fn deallocate_memory(
-        &self,
-        _memory_index: DefinedMemoryIndex,
-        allocation_index: MemoryAllocationIndex,
-        memory: Memory,
-    ) {
-        self.memories.deallocate(allocation_index, memory);
-    }
-
-    unsafe fn allocate_table(
-        &self,
-        request: &mut InstanceAllocationRequest,
-        table_plan: &TablePlan,
-        _table_index: DefinedTableIndex,
-    ) -> Result<(super::TableAllocationIndex, Table)> {
-        self.tables.allocate(request, table_plan)
-    }
-
-    unsafe fn deallocate_table(
-        &self,
-        _table_index: DefinedTableIndex,
-        allocation_index: TableAllocationIndex,
-        table: Table,
-    ) {
-        self.tables.deallocate(allocation_index, table);
-    }
-
-    #[cfg(feature = "async")]
-    fn allocate_fiber_stack(&self) -> Result<wasmtime_fiber::FiberStack> {
-        cfg_if::cfg_if! {
-            if #[cfg(miri)] {
-                unimplemented!()
-            } else if #[cfg(unix)] {
-                self.stacks.allocate()
-            } else if #[cfg(windows)] {
-                if self.stack_size == 0 {
-                    bail!("fiber stack allocation not supported")
-                }
-
-                // On windows, we don't use a stack pool as we use the native
-                // fiber implementation. We do still enforce the `total_stacks`
-                // limit, however.
-
-                let old_count = self.live_stacks.fetch_add(1, Ordering::AcqRel);
-                if old_count >= u64::from(self.limits.total_stacks) {
-                    self.live_stacks.fetch_sub(1, Ordering::AcqRel);
-                    bail!(
-                        "maximum concurrent fiber limit of {} reached",
-                        self.limits.total_stacks
-                    );
-                }
-
-                match wasmtime_fiber::FiberStack::new(self.stack_size) {
-                    Ok(stack) => Ok(stack),
-                    Err(e) => {
-                        self.live_stacks.fetch_sub(1, Ordering::AcqRel);
-                        Err(anyhow::Error::from(e))
-                    }
-                }
-            } else {
-                compile_error!("not implemented");
-            }
-        }
-    }
-
-    #[cfg(feature = "async")]
-    unsafe fn deallocate_fiber_stack(&self, stack: &wasmtime_fiber::FiberStack) {
-        cfg_if::cfg_if! {
-            if #[cfg(miri)] {
-                let _ = stack;
-                unimplemented!()
-            } else if #[cfg(unix)] {
-                self.stacks.deallocate(stack);
-            } else if #[cfg(windows)] {
-                self.live_stacks.fetch_sub(1, Ordering::AcqRel);
-                // A no-op as we don't own the fiber stack on Windows.
-                let _ = stack;
-            } else {
-                compile_error!("not implemented");
-            }
-        }
-    }
-
-    fn purge_module(&self, module: CompiledModuleId) {
-        self.memories.purge_module(module);
-    }
-
-    fn next_available_pkey(&self) -> Option<ProtectionKey> {
-        self.memories.next_available_pkey()
-    }
-
-    fn restrict_to_pkey(&self, pkey: ProtectionKey) {
-        mpk::allow(ProtectionMask::zero().or(pkey));
-    }
-
-    fn allow_all_pkeys(&self) {
-        mpk::allow(ProtectionMask::all());
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_pooling_allocator_with_memory_pages_exceeded() {
-        let config = PoolingInstanceAllocatorConfig {
-            limits: InstanceLimits {
-                total_memories: 1,
-                memory_pages: 0x10001,
-                ..Default::default()
-            },
-            ..PoolingInstanceAllocatorConfig::default()
-        };
-        assert_eq!(
-            PoolingInstanceAllocator::new(
-                &config,
-                &Tunables {
-                    static_memory_bound: 1,
-                    ..Tunables::default()
-                },
-            )
-            .map_err(|e| e.to_string())
-            .expect_err("expected a failure constructing instance allocator"),
-            "module memory page limit of 65537 exceeds the maximum of 65536"
-        );
-    }
-
-    #[cfg(all(unix, target_pointer_width = "64", feature = "async", not(miri)))]
-    #[test]
-    fn test_stack_zeroed() -> Result<()> {
-        let config = PoolingInstanceAllocatorConfig {
-            max_unused_warm_slots: 0,
-            limits: InstanceLimits {
-                total_stacks: 1,
-                total_memories: 0,
-                total_tables: 0,
-                ..Default::default()
-            },
-            stack_size: 128,
-            async_stack_zeroing: true,
-            ..PoolingInstanceAllocatorConfig::default()
-        };
-        let allocator = PoolingInstanceAllocator::new(&config, &Tunables::default())?;
-
-        unsafe {
-            for _ in 0..255 {
-                let stack = allocator.allocate_fiber_stack()?;
-
-                // The stack pointer is at the top, so decrement it first
-                let addr = stack.top().unwrap().sub(1);
-
-                assert_eq!(*addr, 0);
-                *addr = 1;
-
-                allocator.deallocate_fiber_stack(&stack);
-            }
-        }
-
-        Ok(())
-    }
-
-    #[cfg(all(unix, target_pointer_width = "64", feature = "async", not(miri)))]
-    #[test]
-    fn test_stack_unzeroed() -> Result<()> {
-        let config = PoolingInstanceAllocatorConfig {
-            max_unused_warm_slots: 0,
-            limits: InstanceLimits {
-                total_stacks: 1,
-                total_memories: 0,
-                total_tables: 0,
-                ..Default::default()
-            },
-            stack_size: 128,
-            async_stack_zeroing: false,
-            ..PoolingInstanceAllocatorConfig::default()
-        };
-        let allocator = PoolingInstanceAllocator::new(&config, &Tunables::default())?;
-
-        unsafe {
-            for i in 0..255 {
-                let stack = allocator.allocate_fiber_stack()?;
-
-                // The stack pointer is at the top, so decrement it first
-                let addr = stack.top().unwrap().sub(1);
-
-                assert_eq!(*addr, i);
-                *addr = i + 1;
-
-                allocator.deallocate_fiber_stack(&stack);
-            }
-        }
-
-        Ok(())
-    }
-}
diff --git a/crates/runtime/src/instance/allocator/pooling/stack_pool.rs b/crates/runtime/src/instance/allocator/pooling/stack_pool.rs
deleted file mode 100644
index 8265cfcf94a7..000000000000
--- a/crates/runtime/src/instance/allocator/pooling/stack_pool.rs
+++ /dev/null
@@ -1,242 +0,0 @@
-use super::{
-    imp::{commit_stack_pages, reset_stack_pages_to_zero},
-    index_allocator::{SimpleIndexAllocator, SlotId},
-    round_up_to_pow2,
-};
-use crate::{Mmap, PoolingInstanceAllocatorConfig};
-use anyhow::{anyhow, bail, Context, Result};
-
-/// Represents a pool of execution stacks (used for the async fiber implementation).
-///
-/// Each index into the pool represents a single execution stack. The maximum number of
-/// stacks is the same as the maximum number of instances.
-///
-/// As stacks grow downwards, each stack starts (lowest address) with a guard page
-/// that can be used to detect stack overflow.
-///
-/// The top of the stack (starting stack pointer) is returned when a stack is allocated
-/// from the pool.
-#[derive(Debug)]
-pub struct StackPool {
-    mapping: Mmap,
-    stack_size: usize,
-    max_stacks: usize,
-    page_size: usize,
-    index_allocator: SimpleIndexAllocator,
-    async_stack_zeroing: bool,
-    async_stack_keep_resident: usize,
-}
-
-impl StackPool {
-    pub fn new(config: &PoolingInstanceAllocatorConfig) -> Result<Self> {
-        use rustix::mm::{mprotect, MprotectFlags};
-
-        let page_size = crate::page_size();
-
-        // Add a page to the stack size for the guard page when using fiber stacks
-        let stack_size = if config.stack_size == 0 {
-            0
-        } else {
-            round_up_to_pow2(config.stack_size, page_size)
-                .checked_add(page_size)
-                .ok_or_else(|| anyhow!("stack size exceeds addressable memory"))?
-        };
-
-        let max_stacks = usize::try_from(config.limits.total_stacks).unwrap();
-
-        let allocation_size = stack_size
-            .checked_mul(max_stacks)
-            .ok_or_else(|| anyhow!("total size of execution stacks exceeds addressable memory"))?;
-
-        let mapping = Mmap::accessible_reserved(allocation_size, allocation_size)
-            .context("failed to create stack pool mapping")?;
-
-        // Set up the stack guard pages.
-        if allocation_size > 0 {
-            unsafe {
-                for i in 0..max_stacks {
-                    // Make the stack guard page inaccessible.
-                    let bottom_of_stack = mapping.as_ptr().add(i * stack_size).cast_mut();
-                    mprotect(bottom_of_stack.cast(), page_size, MprotectFlags::empty())
-                        .context("failed to protect stack guard page")?;
-                }
-            }
-        }
-
-        Ok(Self {
-            mapping,
-            stack_size,
-            max_stacks,
-            page_size,
-            async_stack_zeroing: config.async_stack_zeroing,
-            async_stack_keep_resident: config.async_stack_keep_resident,
-            index_allocator: SimpleIndexAllocator::new(config.limits.total_stacks),
-        })
-    }
-
-    /// Are there zero slots in use right now?
-    pub fn is_empty(&self) -> bool {
-        self.index_allocator.is_empty()
-    }
-
-    /// Allocate a new fiber.
-    pub fn allocate(&self) -> Result<wasmtime_fiber::FiberStack> {
-        if self.stack_size == 0 {
-            bail!("pooling allocator not configured to enable fiber stack allocation");
-        }
-
-        let index = self
-            .index_allocator
-            .alloc()
-            .ok_or_else(|| {
-                anyhow!(
-                    "maximum concurrent fiber limit of {} reached",
-                    self.max_stacks
-                )
-            })?
-            .index();
-
-        assert!(index < self.max_stacks);
-
-        unsafe {
-            // Remove the guard page from the size
-            let size_without_guard = self.stack_size - self.page_size;
-
-            let bottom_of_stack = self
-                .mapping
-                .as_ptr()
-                .add((index * self.stack_size) + self.page_size)
-                .cast_mut();
-
-            commit_stack_pages(bottom_of_stack, size_without_guard)?;
-
-            let stack =
-                wasmtime_fiber::FiberStack::from_raw_parts(bottom_of_stack, size_without_guard)?;
-            Ok(stack)
-        }
-    }
-
-    /// Deallocate a previously-allocated fiber.
-    ///
-    /// # Safety
-    ///
-    /// The fiber must have been allocated by this pool, must be in an allocated
-    /// state, and must never be used again.
-    pub unsafe fn deallocate(&self, stack: &wasmtime_fiber::FiberStack) {
-        let top = stack
-            .top()
-            .expect("fiber stack not allocated from the pool") as usize;
-
-        let base = self.mapping.as_ptr() as usize;
-        let len = self.mapping.len();
-        assert!(
-            top > base && top <= (base + len),
-            "fiber stack top pointer not in range"
-        );
-
-        // Remove the guard page from the size
-        let stack_size = self.stack_size - self.page_size;
-        let bottom_of_stack = top - stack_size;
-        let start_of_stack = bottom_of_stack - self.page_size;
-        assert!(start_of_stack >= base && start_of_stack < (base + len));
-        assert!((start_of_stack - base) % self.stack_size == 0);
-
-        let index = (start_of_stack - base) / self.stack_size;
-        assert!(index < self.max_stacks);
-
-        if self.async_stack_zeroing {
-            self.zero_stack(bottom_of_stack, stack_size);
-        }
-
-        self.index_allocator.free(SlotId(index as u32));
-    }
-
-    fn zero_stack(&self, bottom: usize, size: usize) {
-        // Manually zero the top of the stack to keep the pages resident in
-        // memory and avoid future page faults. Use the system to deallocate
-        // pages past this. This hopefully strikes a reasonable balance between:
-        //
-        // * memset for the whole range is probably expensive
-        // * madvise for the whole range incurs expensive future page faults
-        // * most threads probably don't use most of the stack anyway
-        let size_to_memset = size.min(self.async_stack_keep_resident);
-        unsafe {
-            std::ptr::write_bytes(
-                (bottom + size - size_to_memset) as *mut u8,
-                0,
-                size_to_memset,
-            );
-        }
-
-        // Use the system to reset remaining stack pages to zero.
-        reset_stack_pages_to_zero(bottom as _, size - size_to_memset).unwrap();
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::InstanceLimits;
-
-    #[cfg(all(unix, target_pointer_width = "64", feature = "async", not(miri)))]
-    #[test]
-    fn test_stack_pool() -> Result<()> {
-        let config = PoolingInstanceAllocatorConfig {
-            limits: InstanceLimits {
-                total_stacks: 10,
-                ..Default::default()
-            },
-            stack_size: 1,
-            async_stack_zeroing: true,
-            ..PoolingInstanceAllocatorConfig::default()
-        };
-        let pool = StackPool::new(&config)?;
-
-        let native_page_size = crate::page_size();
-        assert_eq!(pool.stack_size, 2 * native_page_size);
-        assert_eq!(pool.max_stacks, 10);
-        assert_eq!(pool.page_size, native_page_size);
-
-        assert_eq!(pool.index_allocator.testing_freelist(), []);
-
-        let base = pool.mapping.as_ptr() as usize;
-
-        let mut stacks = Vec::new();
-        for i in 0..10 {
-            let stack = pool.allocate().expect("allocation should succeed");
-            assert_eq!(
-                ((stack.top().unwrap() as usize - base) / pool.stack_size) - 1,
-                i
-            );
-            stacks.push(stack);
-        }
-
-        assert_eq!(pool.index_allocator.testing_freelist(), []);
-
-        pool.allocate().unwrap_err();
-
-        for stack in stacks {
-            unsafe {
-                pool.deallocate(&stack);
-            }
-        }
-
-        assert_eq!(
-            pool.index_allocator.testing_freelist(),
-            [
-                SlotId(0),
-                SlotId(1),
-                SlotId(2),
-                SlotId(3),
-                SlotId(4),
-                SlotId(5),
-                SlotId(6),
-                SlotId(7),
-                SlotId(8),
-                SlotId(9)
-            ],
-        );
-
-        Ok(())
-    }
-}
diff --git a/crates/runtime/src/instance/allocator/pooling/table_pool.rs b/crates/runtime/src/instance/allocator/pooling/table_pool.rs
deleted file mode 100644
index 81938cb0491d..000000000000
--- a/crates/runtime/src/instance/allocator/pooling/table_pool.rs
+++ /dev/null
@@ -1,221 +0,0 @@
-use super::{
-    imp::{commit_table_pages, decommit_table_pages},
-    index_allocator::{SimpleIndexAllocator, SlotId},
-    round_up_to_pow2, TableAllocationIndex,
-};
-use crate::{InstanceAllocationRequest, Mmap, PoolingInstanceAllocatorConfig, Table};
-use anyhow::{anyhow, bail, Context, Result};
-use std::mem;
-use wasmtime_environ::{Module, TablePlan};
-
-/// Represents a pool of WebAssembly tables.
-///
-/// Each instance index into the pool returns an iterator over the base addresses
-/// of the instance's tables.
-#[derive(Debug)]
-pub struct TablePool {
-    index_allocator: SimpleIndexAllocator,
-    mapping: Mmap,
-    table_size: usize,
-    max_total_tables: usize,
-    tables_per_instance: usize,
-    page_size: usize,
-    keep_resident: usize,
-    table_elements: usize,
-}
-
-impl TablePool {
-    /// Create a new `TablePool`.
-    pub fn new(config: &PoolingInstanceAllocatorConfig) -> Result<Self> {
-        let page_size = crate::page_size();
-
-        let table_size = round_up_to_pow2(
-            mem::size_of::<*mut u8>()
-                .checked_mul(config.limits.table_elements as usize)
-                .ok_or_else(|| anyhow!("table size exceeds addressable memory"))?,
-            page_size,
-        );
-
-        let max_total_tables = usize::try_from(config.limits.total_tables).unwrap();
-        let tables_per_instance = usize::try_from(config.limits.max_tables_per_module).unwrap();
-
-        let allocation_size = table_size
-            .checked_mul(max_total_tables)
-            .ok_or_else(|| anyhow!("total size of tables exceeds addressable memory"))?;
-
-        let mapping = Mmap::accessible_reserved(allocation_size, allocation_size)
-            .context("failed to create table pool mapping")?;
-
-        Ok(Self {
-            index_allocator: SimpleIndexAllocator::new(config.limits.total_tables),
-            mapping,
-            table_size,
-            max_total_tables,
-            tables_per_instance,
-            page_size,
-            keep_resident: config.table_keep_resident,
-            table_elements: usize::try_from(config.limits.table_elements).unwrap(),
-        })
-    }
-
-    /// Validate whether this module's tables are allocatable by this pool.
-    pub fn validate(&self, module: &Module) -> Result<()> {
-        let tables = module.table_plans.len() - module.num_imported_tables;
-
-        if tables > usize::try_from(self.tables_per_instance).unwrap() {
-            bail!(
-                "defined tables count of {} exceeds the per-instance limit of {}",
-                tables,
-                self.tables_per_instance,
-            );
-        }
-
-        if tables > self.max_total_tables {
-            bail!(
-                "defined tables count of {} exceeds the total tables limit of {}",
-                tables,
-                self.max_total_tables,
-            );
-        }
-
-        for (i, plan) in module.table_plans.iter().skip(module.num_imported_tables) {
-            if plan.table.minimum > u32::try_from(self.table_elements).unwrap() {
-                bail!(
-                    "table index {} has a minimum element size of {} which exceeds the limit of {}",
-                    i.as_u32(),
-                    plan.table.minimum,
-                    self.table_elements,
-                );
-            }
-        }
-        Ok(())
-    }
-
-    /// Are there zero slots in use right now?
-    pub fn is_empty(&self) -> bool {
-        self.index_allocator.is_empty()
-    }
-
-    /// Get the base pointer of the given table allocation.
-    fn get(&self, table_index: TableAllocationIndex) -> *mut u8 {
-        assert!(table_index.index() < self.max_total_tables);
-
-        unsafe {
-            self.mapping
-                .as_ptr()
-                .add(table_index.index() * self.table_size)
-                .cast_mut()
-        }
-    }
-
-    /// Allocate a single table for the given instance allocation request.
-    pub fn allocate(
-        &self,
-        request: &mut InstanceAllocationRequest,
-        table_plan: &TablePlan,
-    ) -> Result<(TableAllocationIndex, Table)> {
-        let allocation_index = self
-            .index_allocator
-            .alloc()
-            .map(|slot| TableAllocationIndex(slot.0))
-            .ok_or_else(|| {
-                anyhow!(
-                    "maximum concurrent table limit of {} reached",
-                    self.max_total_tables
-                )
-            })?;
-
-        match (|| {
-            let base = self.get(allocation_index);
-
-            commit_table_pages(
-                base as *mut u8,
-                self.table_elements * mem::size_of::<*mut u8>(),
-            )?;
-
-            Table::new_static(
-                table_plan,
-                unsafe { std::slice::from_raw_parts_mut(base.cast(), self.table_elements) },
-                unsafe { &mut *request.store.get().unwrap() },
-            )
-        })() {
-            Ok(table) => Ok((allocation_index, table)),
-            Err(e) => {
-                self.index_allocator.free(SlotId(allocation_index.0));
-                Err(e)
-            }
-        }
-    }
-
-    /// Deallocate a previously-allocated table.
-    ///
-    /// # Safety
-    ///
-    /// The table must have been previously-allocated by this pool and assigned
-    /// the given allocation index, it must currently be allocated, and it must
-    /// never be used again.
-    pub unsafe fn deallocate(&self, allocation_index: TableAllocationIndex, table: Table) {
-        assert!(table.is_static());
-
-        let size = round_up_to_pow2(
-            table.size() as usize * mem::size_of::<*mut u8>(),
-            self.page_size,
-        );
-
-        drop(table);
-
-        let base = self.get(allocation_index);
-        self.reset_table_pages_to_zero(base, size)
-            .expect("failed to decommit table pages");
-
-        self.index_allocator.free(SlotId(allocation_index.0));
-    }
-
-    fn reset_table_pages_to_zero(&self, base: *mut u8, size: usize) -> Result<()> {
-        let size_to_memset = size.min(self.keep_resident);
-        unsafe {
-            std::ptr::write_bytes(base, 0, size_to_memset);
-            decommit_table_pages(base.add(size_to_memset), size - size_to_memset)
-                .context("failed to decommit table page")?;
-        }
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::InstanceLimits;
-
-    #[cfg(target_pointer_width = "64")]
-    #[test]
-    fn test_table_pool() -> Result<()> {
-        let pool = TablePool::new(&PoolingInstanceAllocatorConfig {
-            limits: InstanceLimits {
-                total_tables: 7,
-                table_elements: 100,
-                memory_pages: 0,
-                max_memories_per_module: 0,
-                ..Default::default()
-            },
-            ..Default::default()
-        })?;
-
-        let host_page_size = crate::page_size();
-
-        assert_eq!(pool.table_size, host_page_size);
-        assert_eq!(pool.max_total_tables, 7);
-        assert_eq!(pool.page_size, host_page_size);
-        assert_eq!(pool.table_elements, 100);
-
-        let base = pool.mapping.as_ptr() as usize;
-
-        for i in 0..7 {
-            let index = TableAllocationIndex(i);
-            let ptr = pool.get(index);
-            assert_eq!(ptr as usize - base, i as usize * pool.table_size);
-        }
-
-        Ok(())
-    }
-}
diff --git a/crates/runtime/src/instance/allocator/pooling/unix.rs b/crates/runtime/src/instance/allocator/pooling/unix.rs
deleted file mode 100644
index 00259f4b0afd..000000000000
--- a/crates/runtime/src/instance/allocator/pooling/unix.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-use anyhow::Result;
-
-fn decommit(addr: *mut u8, len: usize) -> Result<()> {
-    if len == 0 {
-        return Ok(());
-    }
-
-    unsafe {
-        cfg_if::cfg_if! {
-            if #[cfg(miri)] {
-                std::ptr::write_bytes(addr, 0, len);
-            } else if #[cfg(target_os = "linux")] {
-                use rustix::mm::{madvise, Advice};
-
-                // On Linux, this is enough to cause the kernel to initialize
-                // the pages to 0 on next access
-                madvise(addr as _, len, Advice::LinuxDontNeed)?;
-            } else {
-                use rustix::mm::{mmap_anonymous, ProtFlags, MapFlags};
-
-                // By creating a new mapping at the same location, this will
-                // discard the mapping for the pages in the given range.
-                // The new mapping will be to the CoW zero page, so this
-                // effectively zeroes the pages.
-                mmap_anonymous(
-                    addr as _,
-                    len,
-                    ProtFlags::READ | ProtFlags::WRITE,
-                    MapFlags::PRIVATE | MapFlags::FIXED,
-                )?;
-            }
-        }
-    }
-
-    Ok(())
-}
-
-pub fn commit_table_pages(_addr: *mut u8, _len: usize) -> Result<()> {
-    // A no-op as table pages remain READ|WRITE
-    Ok(())
-}
-
-pub fn decommit_table_pages(addr: *mut u8, len: usize) -> Result<()> {
-    decommit(addr, len)
-}
-
-#[cfg(all(feature = "async", not(miri)))]
-pub fn commit_stack_pages(_addr: *mut u8, _len: usize) -> Result<()> {
-    // A no-op as stack pages remain READ|WRITE
-    Ok(())
-}
-
-#[cfg(all(feature = "async", not(miri)))]
-pub fn reset_stack_pages_to_zero(addr: *mut u8, len: usize) -> Result<()> {
-    decommit(addr, len)
-}
diff --git a/crates/runtime/src/instance/allocator/pooling/windows.rs b/crates/runtime/src/instance/allocator/pooling/windows.rs
deleted file mode 100644
index 5e9d0c51e414..000000000000
--- a/crates/runtime/src/instance/allocator/pooling/windows.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-use anyhow::{bail, Result};
-use windows_sys::Win32::System::Memory::*;
-
-pub fn commit(addr: *mut u8, len: usize) -> Result<()> {
-    if len == 0 {
-        return Ok(());
-    }
-
-    // Memory needs to be committed, so don't use the `region` crate
-    if unsafe { VirtualAlloc(addr as _, len, MEM_COMMIT, PAGE_READWRITE).is_null() } {
-        bail!("failed to commit memory as read/write");
-    }
-
-    Ok(())
-}
-
-pub fn decommit(addr: *mut u8, len: usize) -> Result<()> {
-    if len == 0 {
-        return Ok(());
-    }
-
-    if unsafe { VirtualFree(addr as _, len, MEM_DECOMMIT) } == 0 {
-        bail!(
-            "failed to decommit memory pages: {}",
-            std::io::Error::last_os_error()
-        );
-    }
-
-    Ok(())
-}
-
-pub fn commit_table_pages(addr: *mut u8, len: usize) -> Result<()> {
-    commit(addr, len)
-}
-
-pub fn decommit_table_pages(addr: *mut u8, len: usize) -> Result<()> {
-    decommit(addr, len)
-}
diff --git a/crates/runtime/src/lib.rs b/crates/runtime/src/lib.rs
deleted file mode 100644
index 9b5e631768be..000000000000
--- a/crates/runtime/src/lib.rs
+++ /dev/null
@@ -1,278 +0,0 @@
-//! Runtime library support for Wasmtime.
-
-#![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)]
-#![warn(unused_import_braces)]
-
-use anyhow::{Error, Result};
-use std::fmt;
-use std::ptr::NonNull;
-use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
-use std::sync::Arc;
-use wasmtime_environ::{DefinedFuncIndex, DefinedMemoryIndex, HostPtr, VMOffsets};
-
-#[macro_use]
-mod trampolines;
-
-#[cfg(feature = "component-model")]
-pub mod component;
-mod export;
-mod externref;
-mod imports;
-mod instance;
-mod memory;
-mod mmap;
-mod mmap_vec;
-mod parking_spot;
-mod send_sync_ptr;
-mod store_box;
-mod table;
-mod traphandlers;
-mod vmcontext;
-
-pub mod debug_builtins;
-pub mod libcalls;
-pub mod mpk;
-
-pub use wasmtime_jit_debug::gdb_jit_int::GdbJitImageRegistration;
-
-pub use crate::export::*;
-pub use crate::externref::*;
-pub use crate::imports::Imports;
-pub use crate::instance::{
-    Instance, InstanceAllocationRequest, InstanceAllocator, InstanceAllocatorImpl, InstanceHandle,
-    MemoryAllocationIndex, OnDemandInstanceAllocator, StorePtr, TableAllocationIndex,
-};
-#[cfg(feature = "pooling-allocator")]
-pub use crate::instance::{
-    InstanceLimits, PoolingInstanceAllocator, PoolingInstanceAllocatorConfig,
-};
-pub use crate::memory::{
-    DefaultMemoryCreator, Memory, RuntimeLinearMemory, RuntimeMemoryCreator, SharedMemory,
-};
-pub use crate::mmap::Mmap;
-pub use crate::mmap_vec::MmapVec;
-pub use crate::mpk::MpkEnabled;
-pub use crate::store_box::*;
-pub use crate::table::{Table, TableElement};
-pub use crate::traphandlers::*;
-pub use crate::vmcontext::{
-    VMArrayCallFunction, VMArrayCallHostFuncContext, VMContext, VMFuncRef, VMFunctionBody,
-    VMFunctionImport, VMGlobalDefinition, VMGlobalImport, VMInvokeArgument, VMMemoryDefinition,
-    VMMemoryImport, VMNativeCallFunction, VMNativeCallHostFuncContext, VMOpaqueContext,
-    VMRuntimeLimits, VMSharedSignatureIndex, VMTableDefinition, VMTableImport, VMWasmCallFunction,
-    ValRaw,
-};
-pub use send_sync_ptr::SendSyncPtr;
-
-mod module_id;
-pub use module_id::{CompiledModuleId, CompiledModuleIdAllocator};
-
-mod cow;
-pub use crate::cow::{MemoryImage, MemoryImageSlot, ModuleMemoryImages};
-
-/// Version number of this crate.
-pub const VERSION: &str = env!("CARGO_PKG_VERSION");
-
-/// Dynamic runtime functionality needed by this crate throughout the execution
-/// of a wasm instance.
-///
-/// This trait is used to store a raw pointer trait object within each
-/// `VMContext`. This raw pointer trait object points back to the
-/// `wasmtime::Store` internally but is type-erased so this `wasmtime_runtime`
-/// crate doesn't need the entire `wasmtime` crate to build.
-///
-/// Note that this is an extra-unsafe trait because no heed is paid to the
-/// lifetime of this store or the Send/Sync-ness of this store. All of that must
-/// be respected by embedders (e.g. the `wasmtime::Store` structure). The theory
-/// is that `wasmtime::Store` handles all this correctly.
-pub unsafe trait Store {
-    /// Returns the raw pointer in memory where this store's shared
-    /// `VMRuntimeLimits` structure is located.
-    ///
-    /// Used to configure `VMContext` initialization and store the right pointer
-    /// in the `VMContext`.
-    fn vmruntime_limits(&self) -> *mut VMRuntimeLimits;
-
-    /// Returns a pointer to the global epoch counter.
-    ///
-    /// Used to configure the `VMContext` on initialization.
-    fn epoch_ptr(&self) -> *const AtomicU64;
-
-    /// Returns the externref management structures necessary for this store.
-    ///
-    /// The first element returned is the table in which externrefs are stored
-    /// throughout wasm execution, and the second element is how to look up
-    /// module information for gc requests.
-    fn externref_activations_table(
-        &mut self,
-    ) -> (&mut VMExternRefActivationsTable, &dyn ModuleInfoLookup);
-
-    /// Callback invoked to allow the store's resource limiter to reject a
-    /// memory grow operation.
-    fn memory_growing(
-        &mut self,
-        current: usize,
-        desired: usize,
-        maximum: Option<usize>,
-    ) -> Result<bool, Error>;
-    /// Callback invoked to notify the store's resource limiter that a memory
-    /// grow operation has failed.
-    ///
-    /// Note that this is not invoked if `memory_growing` returns an error.
-    fn memory_grow_failed(&mut self, error: Error) -> Result<()>;
-    /// Callback invoked to allow the store's resource limiter to reject a
-    /// table grow operation.
-    fn table_growing(
-        &mut self,
-        current: u32,
-        desired: u32,
-        maximum: Option<u32>,
-    ) -> Result<bool, Error>;
-    /// Callback invoked to notify the store's resource limiter that a table
-    /// grow operation has failed.
-    ///
-    /// Note that this is not invoked if `table_growing` returns an error.
-    fn table_grow_failed(&mut self, error: Error) -> Result<()>;
-    /// Callback invoked whenever fuel runs out by a wasm instance. If an error
-    /// is returned that's raised as a trap. Otherwise wasm execution will
-    /// continue as normal.
-    fn out_of_gas(&mut self) -> Result<(), Error>;
-    /// Callback invoked whenever an instance observes a new epoch
-    /// number. Cannot fail; cooperative epoch-based yielding is
-    /// completely semantically transparent. Returns the new deadline.
-    fn new_epoch(&mut self) -> Result<u64, Error>;
-
-    /// Metadata required for resources for the component model.
-    #[cfg(feature = "component-model")]
-    fn component_calls(&mut self) -> &mut component::CallContexts;
-}
-
-/// Functionality required by this crate for a particular module. This
-/// is chiefly needed for lazy initialization of various bits of
-/// instance state.
-///
-/// When an instance is created, it holds an `Arc<dyn ModuleRuntimeInfo>`
-/// so that it can get to signatures, metadata on functions, memory and
-/// funcref-table images, etc. All of these things are ordinarily known
-/// by the higher-level layers of Wasmtime. Specifically, the main
-/// implementation of this trait is provided by
-/// `wasmtime::module::ModuleInner`.  Since the runtime crate sits at
-/// the bottom of the dependence DAG though, we don't know or care about
-/// that; we just need some implementor of this trait for each
-/// allocation request.
-pub trait ModuleRuntimeInfo: Send + Sync + 'static {
-    /// The underlying Module.
-    fn module(&self) -> &Arc<wasmtime_environ::Module>;
-
-    /// Returns the address, in memory, that the function `index` resides at.
-    fn function(&self, index: DefinedFuncIndex) -> NonNull<VMWasmCallFunction>;
-
-    /// Returns the address, in memory, of the trampoline that allows the given
-    /// defined Wasm function to be called by the native calling convention.
-    ///
-    /// Returns `None` for Wasm functions which do not escape, and therefore are
-    /// not callable from outside the Wasm module itself.
-    fn native_to_wasm_trampoline(
-        &self,
-        index: DefinedFuncIndex,
-    ) -> Option<NonNull<VMNativeCallFunction>>;
-
-    /// Returns the address, in memory, of the trampoline that allows the given
-    /// defined Wasm function to be called by the array calling convention.
-    ///
-    /// Returns `None` for Wasm functions which do not escape, and therefore are
-    /// not callable from outside the Wasm module itself.
-    fn array_to_wasm_trampoline(&self, index: DefinedFuncIndex) -> Option<VMArrayCallFunction>;
-
-    /// Return the address, in memory, of the trampoline that allows Wasm to
-    /// call a native function of the given signature.
-    fn wasm_to_native_trampoline(
-        &self,
-        signature: VMSharedSignatureIndex,
-    ) -> Option<NonNull<VMWasmCallFunction>>;
-
-    /// Returns the `MemoryImage` structure used for copy-on-write
-    /// initialization of the memory, if it's applicable.
-    fn memory_image(&self, memory: DefinedMemoryIndex)
-        -> anyhow::Result<Option<&Arc<MemoryImage>>>;
-
-    /// A unique ID for this particular module. This can be used to
-    /// allow for fastpaths to optimize a "re-instantiate the same
-    /// module again" case.
-    fn unique_id(&self) -> Option<CompiledModuleId>;
-
-    /// A slice pointing to all data that is referenced by this instance.
-    fn wasm_data(&self) -> &[u8];
-
-    /// Returns an array, indexed by `SignatureIndex` of all
-    /// `VMSharedSignatureIndex` entries corresponding to the `SignatureIndex`.
-    fn signature_ids(&self) -> &[VMSharedSignatureIndex];
-
-    /// Offset information for the current host.
-    fn offsets(&self) -> &VMOffsets<HostPtr>;
-}
-
-/// Returns the host OS page size, in bytes.
-pub fn page_size() -> usize {
-    static PAGE_SIZE: AtomicUsize = AtomicUsize::new(0);
-
-    return match PAGE_SIZE.load(Ordering::Relaxed) {
-        0 => {
-            let size = get_page_size();
-            assert!(size != 0);
-            PAGE_SIZE.store(size, Ordering::Relaxed);
-            size
-        }
-        n => n,
-    };
-
-    #[cfg(windows)]
-    fn get_page_size() -> usize {
-        use std::mem::MaybeUninit;
-        use windows_sys::Win32::System::SystemInformation::*;
-
-        unsafe {
-            let mut info = MaybeUninit::uninit();
-            GetSystemInfo(info.as_mut_ptr());
-            info.assume_init_ref().dwPageSize as usize
-        }
-    }
-
-    #[cfg(unix)]
-    fn get_page_size() -> usize {
-        unsafe { libc::sysconf(libc::_SC_PAGESIZE) as usize }
-    }
-}
-
-/// Result of [`Memory::atomic_wait32`] and [`Memory::atomic_wait64`]
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
-pub enum WaitResult {
-    /// Indicates that a `wait` completed by being awoken by a different thread.
-    /// This means the thread went to sleep and didn't time out.
-    Ok = 0,
-    /// Indicates that `wait` did not complete and instead returned due to the
-    /// value in memory not matching the expected value.
-    Mismatch = 1,
-    /// Indicates that `wait` completed with a timeout, meaning that the
-    /// original value matched as expected but nothing ever called `notify`.
-    TimedOut = 2,
-}
-
-/// Description about a fault that occurred in WebAssembly.
-#[derive(Debug)]
-pub struct WasmFault {
-    /// The size of memory, in bytes, at the time of the fault.
-    pub memory_size: usize,
-    /// The WebAssembly address at which the fault occurred.
-    pub wasm_address: u64,
-}
-
-impl fmt::Display for WasmFault {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "memory fault at wasm address 0x{:x} in linear memory of size 0x{:x}",
-            self.wasm_address, self.memory_size,
-        )
-    }
-}
diff --git a/crates/runtime/src/libcalls.rs b/crates/runtime/src/libcalls.rs
deleted file mode 100644
index f4c35e1bc59f..000000000000
--- a/crates/runtime/src/libcalls.rs
+++ /dev/null
@@ -1,775 +0,0 @@
-//! Runtime library calls.
-//!
-//! Note that Wasm compilers may sometimes perform these inline rather than
-//! calling them, particularly when CPUs have special instructions which compute
-//! them directly.
-//!
-//! These functions are called by compiled Wasm code, and therefore must take
-//! certain care about some things:
-//!
-//! * They must only contain basic, raw i32/i64/f32/f64/pointer parameters that
-//!   are safe to pass across the system ABI.
-//!
-//! * If any nested function propagates an `Err(trap)` out to the library
-//!   function frame, we need to raise it. This involves some nasty and quite
-//!   unsafe code under the covers! Notably, after raising the trap, drops
-//!   **will not** be run for local variables! This can lead to things like
-//!   leaking `InstanceHandle`s which leads to never deallocating JIT code,
-//!   instances, and modules if we are not careful!
-//!
-//! * The libcall must be entered via a Wasm-to-libcall trampoline that saves
-//!   the last Wasm FP and PC for stack walking purposes. (For more details, see
-//!   `crates/runtime/src/backtrace.rs`.)
-//!
-//! To make it easier to correctly handle all these things, **all** libcalls
-//! must be defined via the `libcall!` helper macro! See its doc comments below
-//! for an example, or just look at the rest of the file.
-//!
-//! ## Dealing with `externref`s
-//!
-//! When receiving a raw `*mut u8` that is actually a `VMExternRef` reference,
-//! convert it into a proper `VMExternRef` with `VMExternRef::clone_from_raw` as
-//! soon as apossible. Any GC before raw pointer is converted into a reference
-//! can potentially collect the referenced object, which could lead to use after
-//! free.
-//!
-//! Avoid this by eagerly converting into a proper `VMExternRef`! (Unfortunately
-//! there is no macro to help us automatically get this correct, so stay
-//! vigilant!)
-//!
-//! ```ignore
-//! pub unsafe extern "C" my_libcall_takes_ref(raw_extern_ref: *mut u8) {
-//!     // Before `clone_from_raw`, `raw_extern_ref` is potentially unrooted,
-//!     // and doing GC here could lead to use after free!
-//!
-//!     let my_extern_ref = if raw_extern_ref.is_null() {
-//!         None
-//!     } else {
-//!         Some(VMExternRef::clone_from_raw(raw_extern_ref))
-//!     };
-//!
-//!     // Now that we did `clone_from_raw`, it is safe to do a GC (or do
-//!     // anything else that might transitively GC, like call back into
-//!     // Wasm!)
-//! }
-//! ```
-
-use crate::externref::VMExternRef;
-use crate::table::{Table, TableElementType};
-use crate::vmcontext::VMFuncRef;
-use crate::{Instance, TrapReason};
-#[cfg(feature = "wmemcheck")]
-use anyhow::bail;
-use anyhow::Result;
-use cfg_if::cfg_if;
-use std::mem;
-use std::ptr::{self, NonNull};
-use std::time::{Duration, Instant};
-use wasmtime_environ::{
-    DataIndex, ElemIndex, FuncIndex, GlobalIndex, MemoryIndex, TableIndex, Trap,
-};
-#[cfg(feature = "wmemcheck")]
-use wasmtime_wmemcheck::AccessError::{
-    DoubleMalloc, InvalidFree, InvalidRead, InvalidWrite, OutOfBounds,
-};
-
-/// Actually public trampolines which are used by the runtime as the entrypoint
-/// for libcalls.
-///
-/// Note that the trampolines here are actually defined in inline assembly right
-/// now to ensure that the fp/sp on exit are recorded for backtraces to work
-/// properly.
-pub mod trampolines {
-    use crate::{Instance, TrapReason, VMContext};
-
-    macro_rules! libcall {
-        (
-            $(
-                $( #[$attr:meta] )*
-                $name:ident( vmctx: vmctx $(, $pname:ident: $param:ident )* ) $( -> $result:ident )?;
-            )*
-        ) => {paste::paste! {
-            $(
-                // The actual libcall itself, which has the `pub` name here, is
-                // defined via the `wasm_to_libcall_trampoline!` macro on
-                // supported platforms or otherwise in inline assembly for
-                // platforms like s390x which don't have stable `global_asm!`
-                // yet.
-                extern "C" {
-                    #[allow(missing_docs)]
-                    #[allow(improper_ctypes)]
-                    #[wasmtime_versioned_export_macros::versioned_link]
-                    pub fn $name(
-                        vmctx: *mut VMContext,
-                        $( $pname: libcall!(@ty $param), )*
-                    ) $(-> libcall!(@ty $result))?;
-                }
-
-                wasm_to_libcall_trampoline!($name ; [<impl_ $name>]);
-
-                // This is the direct entrypoint from the inline assembly which
-                // still has the same raw signature as the trampoline itself.
-                // This will delegate to the outer module to the actual
-                // implementation and automatically perform `catch_unwind` along
-                // with conversion of the return value in the face of traps.
-                //
-                // Note that rust targets which support `global_asm!` can use
-                // the `sym` operator to get the symbol here, but other targets
-                // like s390x need to use outlined assembly files which requires
-                // `no_mangle`.
-                #[cfg_attr(target_arch = "s390x", wasmtime_versioned_export_macros::versioned_export)]
-                unsafe extern "C" fn [<impl_ $name>](
-                    vmctx: *mut VMContext,
-                    $( $pname : libcall!(@ty $param), )*
-                ) $( -> libcall!(@ty $result))? {
-                    let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
-                        Instance::from_vmctx(vmctx, |instance| {
-                            super::$name(instance, $($pname),*)
-                        })
-                    }));
-                    match result {
-                        Ok(ret) => LibcallResult::convert(ret),
-                        Err(panic) => crate::traphandlers::resume_panic(panic),
-                    }
-                }
-
-                // This works around a `rustc` bug where compiling with LTO
-                // will sometimes strip out some of these symbols resulting
-                // in a linking failure.
-                #[allow(non_upper_case_globals)]
-                #[used]
-                static [<impl_ $name _ref>]: unsafe extern "C" fn(
-                    *mut VMContext,
-                    $( $pname : libcall!(@ty $param), )*
-                ) $( -> libcall!(@ty $result))? = [<impl_ $name>];
-
-            )*
-        }};
-
-        (@ty i32) => (u32);
-        (@ty i64) => (u64);
-        (@ty reference) => (*mut u8);
-        (@ty pointer) => (*mut u8);
-        (@ty vmctx) => (*mut VMContext);
-    }
-
-    wasmtime_environ::foreach_builtin_function!(libcall);
-
-    // Helper trait to convert results of libcalls below into the ABI of what
-    // the libcall expects.
-    //
-    // This basically entirely exists for the `Result` implementation which
-    // "unwraps" via a throwing of a trap.
-    trait LibcallResult {
-        type Abi;
-        unsafe fn convert(self) -> Self::Abi;
-    }
-
-    impl LibcallResult for () {
-        type Abi = ();
-        unsafe fn convert(self) {}
-    }
-
-    impl<T, E> LibcallResult for Result<T, E>
-    where
-        E: Into<TrapReason>,
-    {
-        type Abi = T;
-        unsafe fn convert(self) -> T {
-            match self {
-                Ok(t) => t,
-                Err(e) => crate::traphandlers::raise_trap(e.into()),
-            }
-        }
-    }
-
-    impl LibcallResult for *mut u8 {
-        type Abi = *mut u8;
-        unsafe fn convert(self) -> *mut u8 {
-            self
-        }
-    }
-}
-
-fn memory32_grow(
-    instance: &mut Instance,
-    delta: u64,
-    memory_index: u32,
-) -> Result<*mut u8, TrapReason> {
-    let memory_index = MemoryIndex::from_u32(memory_index);
-    let result =
-        match instance
-            .memory_grow(memory_index, delta)
-            .map_err(|error| TrapReason::User {
-                error,
-                needs_backtrace: true,
-            })? {
-            Some(size_in_bytes) => size_in_bytes / (wasmtime_environ::WASM_PAGE_SIZE as usize),
-            None => usize::max_value(),
-        };
-    Ok(result as *mut _)
-}
-
-// Implementation of `table.grow`.
-unsafe fn table_grow(
-    instance: &mut Instance,
-    table_index: u32,
-    delta: u32,
-    // NB: we don't know whether this is a pointer to a `VMFuncRef`
-    // or is a `VMExternRef` until we look at the table type.
-    init_value: *mut u8,
-) -> Result<u32> {
-    let table_index = TableIndex::from_u32(table_index);
-    let element = match instance.table_element_type(table_index) {
-        TableElementType::Func => (init_value as *mut VMFuncRef).into(),
-        TableElementType::Extern => {
-            let init_value = if init_value.is_null() {
-                None
-            } else {
-                Some(VMExternRef::clone_from_raw(init_value))
-            };
-            init_value.into()
-        }
-    };
-    Ok(match instance.table_grow(table_index, delta, element)? {
-        Some(r) => r,
-        None => -1_i32 as u32,
-    })
-}
-
-use table_grow as table_grow_func_ref;
-use table_grow as table_grow_externref;
-
-// Implementation of `table.fill`.
-unsafe fn table_fill(
-    instance: &mut Instance,
-    table_index: u32,
-    dst: u32,
-    // NB: we don't know whether this is a `VMExternRef` or a pointer to a
-    // `VMFuncRef` until we look at the table's element type.
-    val: *mut u8,
-    len: u32,
-) -> Result<(), Trap> {
-    let table_index = TableIndex::from_u32(table_index);
-    let table = &mut *instance.get_table(table_index);
-    match table.element_type() {
-        TableElementType::Func => {
-            let val = val as *mut VMFuncRef;
-            table.fill(dst, val.into(), len)
-        }
-        TableElementType::Extern => {
-            let val = if val.is_null() {
-                None
-            } else {
-                Some(VMExternRef::clone_from_raw(val))
-            };
-            table.fill(dst, val.into(), len)
-        }
-    }
-}
-
-use table_fill as table_fill_func_ref;
-use table_fill as table_fill_externref;
-
-// Implementation of `table.copy`.
-unsafe fn table_copy(
-    instance: &mut Instance,
-    dst_table_index: u32,
-    src_table_index: u32,
-    dst: u32,
-    src: u32,
-    len: u32,
-) -> Result<(), Trap> {
-    let dst_table_index = TableIndex::from_u32(dst_table_index);
-    let src_table_index = TableIndex::from_u32(src_table_index);
-    let dst_table = instance.get_table(dst_table_index);
-    // Lazy-initialize the whole range in the source table first.
-    let src_range = src..(src.checked_add(len).unwrap_or(u32::MAX));
-    let src_table = instance.get_table_with_lazy_init(src_table_index, src_range);
-    Table::copy(dst_table, src_table, dst, src, len)
-}
-
-// Implementation of `table.init`.
-fn table_init(
-    instance: &mut Instance,
-    table_index: u32,
-    elem_index: u32,
-    dst: u32,
-    src: u32,
-    len: u32,
-) -> Result<(), Trap> {
-    let table_index = TableIndex::from_u32(table_index);
-    let elem_index = ElemIndex::from_u32(elem_index);
-    instance.table_init(table_index, elem_index, dst, src, len)
-}
-
-// Implementation of `elem.drop`.
-fn elem_drop(instance: &mut Instance, elem_index: u32) {
-    let elem_index = ElemIndex::from_u32(elem_index);
-    instance.elem_drop(elem_index)
-}
-
-// Implementation of `memory.copy`.
-fn memory_copy(
-    instance: &mut Instance,
-    dst_index: u32,
-    dst: u64,
-    src_index: u32,
-    src: u64,
-    len: u64,
-) -> Result<(), Trap> {
-    let src_index = MemoryIndex::from_u32(src_index);
-    let dst_index = MemoryIndex::from_u32(dst_index);
-    instance.memory_copy(dst_index, dst, src_index, src, len)
-}
-
-// Implementation of `memory.fill` for locally defined memories.
-fn memory_fill(
-    instance: &mut Instance,
-    memory_index: u32,
-    dst: u64,
-    val: u32,
-    len: u64,
-) -> Result<(), Trap> {
-    let memory_index = MemoryIndex::from_u32(memory_index);
-    instance.memory_fill(memory_index, dst, val as u8, len)
-}
-
-// Implementation of `memory.init`.
-fn memory_init(
-    instance: &mut Instance,
-    memory_index: u32,
-    data_index: u32,
-    dst: u64,
-    src: u32,
-    len: u32,
-) -> Result<(), Trap> {
-    let memory_index = MemoryIndex::from_u32(memory_index);
-    let data_index = DataIndex::from_u32(data_index);
-    instance.memory_init(memory_index, data_index, dst, src, len)
-}
-
-// Implementation of `ref.func`.
-fn ref_func(instance: &mut Instance, func_index: u32) -> *mut u8 {
-    instance
-        .get_func_ref(FuncIndex::from_u32(func_index))
-        .expect("ref_func: funcref should always be available for given func index")
-        .cast()
-}
-
-// Implementation of `data.drop`.
-fn data_drop(instance: &mut Instance, data_index: u32) {
-    let data_index = DataIndex::from_u32(data_index);
-    instance.data_drop(data_index)
-}
-
-// Returns a table entry after lazily initializing it.
-unsafe fn table_get_lazy_init_func_ref(
-    instance: &mut Instance,
-    table_index: u32,
-    index: u32,
-) -> *mut u8 {
-    let table_index = TableIndex::from_u32(table_index);
-    let table = instance.get_table_with_lazy_init(table_index, std::iter::once(index));
-    let elem = (*table)
-        .get(index)
-        .expect("table access already bounds-checked");
-
-    elem.into_ref_asserting_initialized()
-}
-
-// Drop a `VMExternRef`.
-unsafe fn drop_externref(_instance: &mut Instance, externref: *mut u8) {
-    let externref = externref as *mut crate::externref::VMExternData;
-    let externref = NonNull::new(externref).unwrap().into();
-    crate::externref::VMExternData::drop_and_dealloc(externref);
-}
-
-// Do a GC and insert the given `externref` into the
-// `VMExternRefActivationsTable`.
-unsafe fn activations_table_insert_with_gc(instance: &mut Instance, externref: *mut u8) {
-    let externref = VMExternRef::clone_from_raw(externref);
-    let limits = *instance.runtime_limits();
-    let (activations_table, module_info_lookup) = (*instance.store()).externref_activations_table();
-
-    // Invariant: all `externref`s on the stack have an entry in the activations
-    // table. So we need to ensure that this `externref` is in the table
-    // *before* we GC, even though `insert_with_gc` will ensure that it is in
-    // the table *after* the GC. This technically results in one more hash table
-    // look up than is strictly necessary -- which we could avoid by having an
-    // additional GC method that is aware of these GC-triggering references --
-    // but it isn't really a concern because this is already a slow path.
-    activations_table.insert_without_gc(externref.clone());
-
-    activations_table.insert_with_gc(limits, externref, module_info_lookup);
-}
-
-// Perform a Wasm `global.get` for `externref` globals.
-unsafe fn externref_global_get(instance: &mut Instance, index: u32) -> *mut u8 {
-    let index = GlobalIndex::from_u32(index);
-    let limits = *instance.runtime_limits();
-    let global = instance.defined_or_imported_global_ptr(index);
-    match (*global).as_externref().clone() {
-        None => ptr::null_mut(),
-        Some(externref) => {
-            let raw = externref.as_raw();
-            let (activations_table, module_info_lookup) =
-                (*instance.store()).externref_activations_table();
-            activations_table.insert_with_gc(limits, externref, module_info_lookup);
-            raw
-        }
-    }
-}
-
-// Perform a Wasm `global.set` for `externref` globals.
-unsafe fn externref_global_set(instance: &mut Instance, index: u32, externref: *mut u8) {
-    let externref = if externref.is_null() {
-        None
-    } else {
-        Some(VMExternRef::clone_from_raw(externref))
-    };
-
-    let index = GlobalIndex::from_u32(index);
-    let global = instance.defined_or_imported_global_ptr(index);
-
-    // Swap the new `externref` value into the global before we drop the old
-    // value. This protects against an `externref` with a `Drop` implementation
-    // that calls back into Wasm and touches this global again (we want to avoid
-    // it observing a halfway-deinitialized value).
-    let old = mem::replace((*global).as_externref_mut(), externref);
-    drop(old);
-}
-
-// Implementation of `memory.atomic.notify` for locally defined memories.
-fn memory_atomic_notify(
-    instance: &mut Instance,
-    memory_index: u32,
-    addr_index: u64,
-    count: u32,
-) -> Result<u32, Trap> {
-    let memory = MemoryIndex::from_u32(memory_index);
-    instance
-        .get_runtime_memory(memory)
-        .atomic_notify(addr_index, count)
-}
-
-// Implementation of `memory.atomic.wait32` for locally defined memories.
-fn memory_atomic_wait32(
-    instance: &mut Instance,
-    memory_index: u32,
-    addr_index: u64,
-    expected: u32,
-    timeout: u64,
-) -> Result<u32, Trap> {
-    // convert timeout to Instant, before any wait happens on locking
-    let timeout = (timeout as i64 >= 0).then(|| Instant::now() + Duration::from_nanos(timeout));
-    let memory = MemoryIndex::from_u32(memory_index);
-    Ok(instance
-        .get_runtime_memory(memory)
-        .atomic_wait32(addr_index, expected, timeout)? as u32)
-}
-
-// Implementation of `memory.atomic.wait64` for locally defined memories.
-fn memory_atomic_wait64(
-    instance: &mut Instance,
-    memory_index: u32,
-    addr_index: u64,
-    expected: u64,
-    timeout: u64,
-) -> Result<u32, Trap> {
-    // convert timeout to Instant, before any wait happens on locking
-    let timeout = (timeout as i64 >= 0).then(|| Instant::now() + Duration::from_nanos(timeout));
-    let memory = MemoryIndex::from_u32(memory_index);
-    Ok(instance
-        .get_runtime_memory(memory)
-        .atomic_wait64(addr_index, expected, timeout)? as u32)
-}
-
-// Hook for when an instance runs out of fuel.
-unsafe fn out_of_gas(instance: &mut Instance) -> Result<()> {
-    (*instance.store()).out_of_gas()
-}
-
-// Hook for when an instance observes that the epoch has changed.
-unsafe fn new_epoch(instance: &mut Instance) -> Result<u64> {
-    (*instance.store()).new_epoch()
-}
-
-cfg_if! {
-    if #[cfg(feature = "wmemcheck")] {
-        // Hook for validating malloc using wmemcheck_state.
-        unsafe fn check_malloc(instance: &mut Instance, addr: u32, len: u32) -> Result<u32> {
-            if let Some(wmemcheck_state) = &mut instance.wmemcheck_state {
-                let result = wmemcheck_state.malloc(addr as usize, len as usize);
-                wmemcheck_state.memcheck_on();
-                match result {
-                    Ok(()) => {
-                        return Ok(0);
-                    }
-                    Err(DoubleMalloc { addr, len }) => {
-                        bail!("Double malloc at addr {:#x} of size {}", addr, len)
-                    }
-                    Err(OutOfBounds { addr, len }) => {
-                        bail!("Malloc out of bounds at addr {:#x} of size {}", addr, len);
-                    }
-                    _ => {
-                        panic!("unreachable")
-                    }
-                }
-            }
-            Ok(0)
-        }
-
-        // Hook for validating free using wmemcheck_state.
-        unsafe fn check_free(instance: &mut Instance, addr: u32) -> Result<u32> {
-            if let Some(wmemcheck_state) = &mut instance.wmemcheck_state {
-                let result = wmemcheck_state.free(addr as usize);
-                wmemcheck_state.memcheck_on();
-                match result {
-                    Ok(()) => {
-                        return Ok(0);
-                    }
-                    Err(InvalidFree { addr }) => {
-                        bail!("Invalid free at addr {:#x}", addr)
-                    }
-                    _ => {
-                        panic!("unreachable")
-                    }
-                }
-            }
-            Ok(0)
-        }
-
-        // Hook for validating load using wmemcheck_state.
-        fn check_load(instance: &mut Instance, num_bytes: u32, addr: u32, offset: u32) -> Result<u32> {
-            if let Some(wmemcheck_state) = &mut instance.wmemcheck_state {
-                let result = wmemcheck_state.read(addr as usize + offset as usize, num_bytes as usize);
-                match result {
-                    Ok(()) => {
-                        return Ok(0);
-                    }
-                    Err(InvalidRead { addr, len }) => {
-                        bail!("Invalid load at addr {:#x} of size {}", addr, len);
-                    }
-                    Err(OutOfBounds { addr, len }) => {
-                        bail!("Load out of bounds at addr {:#x} of size {}", addr, len);
-                    }
-                    _ => {
-                        panic!("unreachable")
-                    }
-                }
-            }
-            Ok(0)
-        }
-
-        // Hook for validating store using wmemcheck_state.
-        fn check_store(instance: &mut Instance, num_bytes: u32, addr: u32, offset: u32) -> Result<u32> {
-            if let Some(wmemcheck_state) = &mut instance.wmemcheck_state {
-                let result = wmemcheck_state.write(addr as usize + offset as usize, num_bytes as usize);
-                match result {
-                    Ok(()) => {
-                        return Ok(0);
-                    }
-                    Err(InvalidWrite { addr, len }) => {
-                        bail!("Invalid store at addr {:#x} of size {}", addr, len)
-                    }
-                    Err(OutOfBounds { addr, len }) => {
-                        bail!("Store out of bounds at addr {:#x} of size {}", addr, len)
-                    }
-                    _ => {
-                        panic!("unreachable")
-                    }
-                }
-            }
-            Ok(0)
-        }
-
-        // Hook for turning wmemcheck load/store validation off when entering a malloc function.
-        fn malloc_start(instance: &mut Instance) {
-            if let Some(wmemcheck_state) = &mut instance.wmemcheck_state {
-                wmemcheck_state.memcheck_off();
-            }
-        }
-
-        // Hook for turning wmemcheck load/store validation off when entering a free function.
-        fn free_start(instance: &mut Instance) {
-            if let Some(wmemcheck_state) = &mut instance.wmemcheck_state {
-                wmemcheck_state.memcheck_off();
-            }
-        }
-
-        // Hook for tracking wasm stack updates using wmemcheck_state.
-        fn update_stack_pointer(_instance: &mut Instance, _value: u32) {
-            // TODO: stack-tracing has yet to be finalized. All memory below
-            // the address of the top of the stack is marked as valid for
-            // loads and stores.
-            // if let Some(wmemcheck_state) = &mut instance.wmemcheck_state {
-            //     instance.wmemcheck_state.update_stack_pointer(value as usize);
-            // }
-        }
-
-        // Hook updating wmemcheck_state memory state vector every time memory.grow is called.
-        fn update_mem_size(instance: &mut Instance, num_pages: u32) {
-            if let Some(wmemcheck_state) = &mut instance.wmemcheck_state {
-                const KIB: usize = 1024;
-                let num_bytes = num_pages as usize * 64 * KIB;
-                wmemcheck_state.update_mem_size(num_bytes);
-            }
-        }
-    } else {
-        // No-op for all wmemcheck hooks.
-        unsafe fn check_malloc(_instance: &mut Instance, _addr: u32, _len: u32) -> Result<u32> { Ok(0) }
-
-        unsafe fn check_free(_instance: &mut Instance, _addr: u32) -> Result<u32> { Ok(0) }
-
-        fn check_load(_instance: &mut Instance, _num_bytes: u32, _addr: u32, _offset: u32) -> Result<u32> { Ok(0) }
-
-        fn check_store(_instance: &mut Instance, _num_bytes: u32, _addr: u32, _offset: u32) -> Result<u32> { Ok(0) }
-
-        fn malloc_start(_instance: &mut Instance) {}
-
-        fn free_start(_instance: &mut Instance) {}
-
-        fn update_stack_pointer(_instance: &mut Instance, _value: u32) {}
-
-        fn update_mem_size(_instance: &mut Instance, _num_pages: u32) {}
-    }
-}
-
-/// This module contains functions which are used for resolving relocations at
-/// runtime if necessary.
-///
-/// These functions are not used by default and currently the only platform
-/// they're used for is on x86_64 when SIMD is disabled and then SSE features
-/// are further disabled. In these configurations Cranelift isn't allowed to use
-/// native CPU instructions so it falls back to libcalls and we rely on the Rust
-/// standard library generally for implementing these.
-#[allow(missing_docs)]
-pub mod relocs {
-    pub extern "C" fn floorf32(f: f32) -> f32 {
-        f.floor()
-    }
-
-    pub extern "C" fn floorf64(f: f64) -> f64 {
-        f.floor()
-    }
-
-    pub extern "C" fn ceilf32(f: f32) -> f32 {
-        f.ceil()
-    }
-
-    pub extern "C" fn ceilf64(f: f64) -> f64 {
-        f.ceil()
-    }
-
-    pub extern "C" fn truncf32(f: f32) -> f32 {
-        f.trunc()
-    }
-
-    pub extern "C" fn truncf64(f: f64) -> f64 {
-        f.trunc()
-    }
-
-    const TOINT_32: f32 = 1.0 / f32::EPSILON;
-    const TOINT_64: f64 = 1.0 / f64::EPSILON;
-
-    // NB: replace with `round_ties_even` from libstd when it's stable as
-    // tracked by rust-lang/rust#96710
-    pub extern "C" fn nearestf32(x: f32) -> f32 {
-        // Rust doesn't have a nearest function; there's nearbyint, but it's not
-        // stabilized, so do it manually.
-        // Nearest is either ceil or floor depending on which is nearest or even.
-        // This approach exploited round half to even default mode.
-        let i = x.to_bits();
-        let e = i >> 23 & 0xff;
-        if e >= 0x7f_u32 + 23 {
-            // Check for NaNs.
-            if e == 0xff {
-                // Read the 23-bits significand.
-                if i & 0x7fffff != 0 {
-                    // Ensure it's arithmetic by setting the significand's most
-                    // significant bit to 1; it also works for canonical NaNs.
-                    return f32::from_bits(i | (1 << 22));
-                }
-            }
-            x
-        } else {
-            (x.abs() + TOINT_32 - TOINT_32).copysign(x)
-        }
-    }
-
-    pub extern "C" fn nearestf64(x: f64) -> f64 {
-        let i = x.to_bits();
-        let e = i >> 52 & 0x7ff;
-        if e >= 0x3ff_u64 + 52 {
-            // Check for NaNs.
-            if e == 0x7ff {
-                // Read the 52-bits significand.
-                if i & 0xfffffffffffff != 0 {
-                    // Ensure it's arithmetic by setting the significand's most
-                    // significant bit to 1; it also works for canonical NaNs.
-                    return f64::from_bits(i | (1 << 51));
-                }
-            }
-            x
-        } else {
-            (x.abs() + TOINT_64 - TOINT_64).copysign(x)
-        }
-    }
-
-    pub extern "C" fn fmaf32(a: f32, b: f32, c: f32) -> f32 {
-        a.mul_add(b, c)
-    }
-
-    pub extern "C" fn fmaf64(a: f64, b: f64, c: f64) -> f64 {
-        a.mul_add(b, c)
-    }
-
-    // This intrinsic is only used on x86_64 platforms as an implementation of
-    // the `pshufb` instruction when SSSE3 is not available.
-    #[cfg(target_arch = "x86_64")]
-    use std::arch::x86_64::__m128i;
-    #[cfg(target_arch = "x86_64")]
-    #[allow(improper_ctypes_definitions)]
-    pub extern "C" fn x86_pshufb(a: __m128i, b: __m128i) -> __m128i {
-        union U {
-            reg: __m128i,
-            mem: [u8; 16],
-        }
-
-        unsafe {
-            let a = U { reg: a }.mem;
-            let b = U { reg: b }.mem;
-
-            let select = |arr: &[u8; 16], byte: u8| {
-                if byte & 0x80 != 0 {
-                    0x00
-                } else {
-                    arr[(byte & 0xf) as usize]
-                }
-            };
-
-            U {
-                mem: [
-                    select(&a, b[0]),
-                    select(&a, b[1]),
-                    select(&a, b[2]),
-                    select(&a, b[3]),
-                    select(&a, b[4]),
-                    select(&a, b[5]),
-                    select(&a, b[6]),
-                    select(&a, b[7]),
-                    select(&a, b[8]),
-                    select(&a, b[9]),
-                    select(&a, b[10]),
-                    select(&a, b[11]),
-                    select(&a, b[12]),
-                    select(&a, b[13]),
-                    select(&a, b[14]),
-                    select(&a, b[15]),
-                ],
-            }
-            .reg
-        }
-    }
-}
diff --git a/crates/runtime/src/memory.rs b/crates/runtime/src/memory.rs
deleted file mode 100644
index 84d568859d0a..000000000000
--- a/crates/runtime/src/memory.rs
+++ /dev/null
@@ -1,958 +0,0 @@
-//! Memory management for linear memories.
-//!
-//! `RuntimeLinearMemory` is to WebAssembly linear memories what `Table` is to WebAssembly tables.
-
-use crate::mmap::Mmap;
-use crate::parking_spot::ParkingSpot;
-use crate::vmcontext::VMMemoryDefinition;
-use crate::{MemoryImage, MemoryImageSlot, SendSyncPtr, Store, WaitResult};
-use anyhow::Error;
-use anyhow::{bail, format_err, Result};
-use std::convert::TryFrom;
-use std::ops::Range;
-use std::ptr::NonNull;
-use std::sync::atomic::{AtomicU32, AtomicU64, Ordering};
-use std::sync::{Arc, RwLock};
-use std::time::Instant;
-use wasmtime_environ::{MemoryPlan, MemoryStyle, Trap, WASM32_MAX_PAGES, WASM64_MAX_PAGES};
-
-const WASM_PAGE_SIZE: usize = wasmtime_environ::WASM_PAGE_SIZE as usize;
-const WASM_PAGE_SIZE_U64: u64 = wasmtime_environ::WASM_PAGE_SIZE as u64;
-
-/// A memory allocator
-pub trait RuntimeMemoryCreator: Send + Sync {
-    /// Create new RuntimeLinearMemory
-    fn new_memory(
-        &self,
-        plan: &MemoryPlan,
-        minimum: usize,
-        maximum: Option<usize>,
-        // Optionally, a memory image for CoW backing.
-        memory_image: Option<&Arc<MemoryImage>>,
-    ) -> Result<Box<dyn RuntimeLinearMemory>>;
-}
-
-/// A default memory allocator used by Wasmtime
-pub struct DefaultMemoryCreator;
-
-impl RuntimeMemoryCreator for DefaultMemoryCreator {
-    /// Create new MmapMemory
-    fn new_memory(
-        &self,
-        plan: &MemoryPlan,
-        minimum: usize,
-        maximum: Option<usize>,
-        memory_image: Option<&Arc<MemoryImage>>,
-    ) -> Result<Box<dyn RuntimeLinearMemory>> {
-        Ok(Box::new(MmapMemory::new(
-            plan,
-            minimum,
-            maximum,
-            memory_image,
-        )?))
-    }
-}
-
-/// A linear memory
-pub trait RuntimeLinearMemory: Send + Sync {
-    /// Returns the number of allocated bytes.
-    fn byte_size(&self) -> usize;
-
-    /// Returns the maximum number of bytes the memory can grow to.
-    /// Returns `None` if the memory is unbounded.
-    fn maximum_byte_size(&self) -> Option<usize>;
-
-    /// Grows a memory by `delta_pages`.
-    ///
-    /// This performs the necessary checks on the growth before delegating to
-    /// the underlying `grow_to` implementation. A default implementation of
-    /// this memory is provided here since this is assumed to be the same for
-    /// most kinds of memory; one exception is shared memory, which must perform
-    /// all the steps of the default implementation *plus* the required locking.
-    ///
-    /// The `store` is used only for error reporting.
-    fn grow(
-        &mut self,
-        delta_pages: u64,
-        mut store: Option<&mut dyn Store>,
-    ) -> Result<Option<(usize, usize)>, Error> {
-        let old_byte_size = self.byte_size();
-
-        // Wasm spec: when growing by 0 pages, always return the current size.
-        if delta_pages == 0 {
-            return Ok(Some((old_byte_size, old_byte_size)));
-        }
-
-        // The largest wasm-page-aligned region of memory is possible to
-        // represent in a `usize`. This will be impossible for the system to
-        // actually allocate.
-        let absolute_max = 0usize.wrapping_sub(WASM_PAGE_SIZE);
-
-        // Calculate the byte size of the new allocation. Let it overflow up to
-        // `usize::MAX`, then clamp it down to `absolute_max`.
-        let new_byte_size = usize::try_from(delta_pages)
-            .unwrap_or(usize::MAX)
-            .saturating_mul(WASM_PAGE_SIZE)
-            .saturating_add(old_byte_size);
-        let new_byte_size = if new_byte_size > absolute_max {
-            absolute_max
-        } else {
-            new_byte_size
-        };
-
-        let maximum = self.maximum_byte_size();
-        // Store limiter gets first chance to reject memory_growing.
-        if let Some(store) = &mut store {
-            if !store.memory_growing(old_byte_size, new_byte_size, maximum)? {
-                return Ok(None);
-            }
-        }
-
-        // Never exceed maximum, even if limiter permitted it.
-        if let Some(max) = maximum {
-            if new_byte_size > max {
-                if let Some(store) = store {
-                    // FIXME: shared memories may not have an associated store
-                    // to report the growth failure to but the error should not
-                    // be dropped
-                    // (https://github.com/bytecodealliance/wasmtime/issues/4240).
-                    store.memory_grow_failed(format_err!("Memory maximum size exceeded"))?;
-                }
-                return Ok(None);
-            }
-        }
-
-        match self.grow_to(new_byte_size) {
-            Ok(_) => Ok(Some((old_byte_size, new_byte_size))),
-            Err(e) => {
-                // FIXME: shared memories may not have an associated store to
-                // report the growth failure to but the error should not be
-                // dropped
-                // (https://github.com/bytecodealliance/wasmtime/issues/4240).
-                if let Some(store) = store {
-                    store.memory_grow_failed(e)?;
-                }
-                Ok(None)
-            }
-        }
-    }
-
-    /// Grow memory to the specified amount of bytes.
-    ///
-    /// Returns an error if memory can't be grown by the specified amount
-    /// of bytes.
-    fn grow_to(&mut self, size: usize) -> Result<()>;
-
-    /// Return a `VMMemoryDefinition` for exposing the memory to compiled wasm
-    /// code.
-    fn vmmemory(&mut self) -> VMMemoryDefinition;
-
-    /// Does this memory need initialization? It may not if it already
-    /// has initial contents courtesy of the `MemoryImage` passed to
-    /// `RuntimeMemoryCreator::new_memory()`.
-    fn needs_init(&self) -> bool;
-
-    /// Used for optional dynamic downcasting.
-    fn as_any_mut(&mut self) -> &mut dyn std::any::Any;
-
-    /// Returns the range of addresses that may be reached by WebAssembly.
-    ///
-    /// This starts at the base of linear memory and ends at the end of the
-    /// guard pages, if any.
-    fn wasm_accessible(&self) -> Range<usize>;
-}
-
-/// A linear memory instance.
-#[derive(Debug)]
-pub struct MmapMemory {
-    // The underlying allocation.
-    mmap: Mmap,
-
-    // The number of bytes that are accessible in `mmap` and available for
-    // reading and writing.
-    //
-    // This region starts at `pre_guard_size` offset from the base of `mmap`.
-    accessible: usize,
-
-    // The optional maximum accessible size, in bytes, for this linear memory.
-    //
-    // Note that this maximum does not factor in guard pages, so this isn't the
-    // maximum size of the linear address space reservation for this memory.
-    maximum: Option<usize>,
-
-    // The amount of extra bytes to reserve whenever memory grows. This is
-    // specified so that the cost of repeated growth is amortized.
-    extra_to_reserve_on_growth: usize,
-
-    // Size in bytes of extra guard pages before the start and after the end to
-    // optimize loads and stores with constant offsets.
-    pre_guard_size: usize,
-    offset_guard_size: usize,
-
-    // An optional CoW mapping that provides the initial content of this
-    // MmapMemory, if mapped.
-    memory_image: Option<MemoryImageSlot>,
-}
-
-impl MmapMemory {
-    /// Create a new linear memory instance with specified minimum and maximum
-    /// number of wasm pages.
-    pub fn new(
-        plan: &MemoryPlan,
-        minimum: usize,
-        mut maximum: Option<usize>,
-        memory_image: Option<&Arc<MemoryImage>>,
-    ) -> Result<Self> {
-        // It's a programmer error for these two configuration values to exceed
-        // the host available address space, so panic if such a configuration is
-        // found (mostly an issue for hypothetical 32-bit hosts).
-        let offset_guard_bytes = usize::try_from(plan.offset_guard_size).unwrap();
-        let pre_guard_bytes = usize::try_from(plan.pre_guard_size).unwrap();
-
-        let (alloc_bytes, extra_to_reserve_on_growth) = match plan.style {
-            // Dynamic memories start with the minimum size plus the `reserve`
-            // amount specified to grow into.
-            MemoryStyle::Dynamic { reserve } => (minimum, usize::try_from(reserve).unwrap()),
-
-            // Static memories will never move in memory and consequently get
-            // their entire allocation up-front with no extra room to grow into.
-            // Note that the `maximum` is adjusted here to whatever the smaller
-            // of the two is, the `maximum` given or the `bound` specified for
-            // this memory.
-            MemoryStyle::Static { bound } => {
-                assert!(bound >= plan.memory.minimum);
-                let bound_bytes =
-                    usize::try_from(bound.checked_mul(WASM_PAGE_SIZE_U64).unwrap()).unwrap();
-                maximum = Some(bound_bytes.min(maximum.unwrap_or(usize::MAX)));
-                (bound_bytes, 0)
-            }
-        };
-
-        let request_bytes = pre_guard_bytes
-            .checked_add(alloc_bytes)
-            .and_then(|i| i.checked_add(extra_to_reserve_on_growth))
-            .and_then(|i| i.checked_add(offset_guard_bytes))
-            .ok_or_else(|| format_err!("cannot allocate {} with guard regions", minimum))?;
-        let mut mmap = Mmap::accessible_reserved(0, request_bytes)?;
-
-        if minimum > 0 {
-            mmap.make_accessible(pre_guard_bytes, minimum)?;
-        }
-
-        // If a memory image was specified, try to create the MemoryImageSlot on
-        // top of our mmap.
-        let memory_image = match memory_image {
-            Some(image) => {
-                let base = unsafe { mmap.as_mut_ptr().add(pre_guard_bytes) };
-                let mut slot = MemoryImageSlot::create(
-                    base.cast(),
-                    minimum,
-                    alloc_bytes + extra_to_reserve_on_growth,
-                );
-                slot.instantiate(minimum, Some(image), &plan)?;
-                // On drop, we will unmap our mmap'd range that this slot was
-                // mapped on top of, so there is no need for the slot to wipe
-                // it with an anonymous mapping first.
-                slot.no_clear_on_drop();
-                Some(slot)
-            }
-            None => None,
-        };
-
-        Ok(Self {
-            mmap,
-            accessible: minimum,
-            maximum,
-            pre_guard_size: pre_guard_bytes,
-            offset_guard_size: offset_guard_bytes,
-            extra_to_reserve_on_growth,
-            memory_image,
-        })
-    }
-}
-
-impl RuntimeLinearMemory for MmapMemory {
-    fn byte_size(&self) -> usize {
-        self.accessible
-    }
-
-    fn maximum_byte_size(&self) -> Option<usize> {
-        self.maximum
-    }
-
-    fn grow_to(&mut self, new_size: usize) -> Result<()> {
-        if new_size > self.mmap.len() - self.offset_guard_size - self.pre_guard_size {
-            // If the new size of this heap exceeds the current size of the
-            // allocation we have, then this must be a dynamic heap. Use
-            // `new_size` to calculate a new size of an allocation, allocate it,
-            // and then copy over the memory from before.
-            let request_bytes = self
-                .pre_guard_size
-                .checked_add(new_size)
-                .and_then(|s| s.checked_add(self.extra_to_reserve_on_growth))
-                .and_then(|s| s.checked_add(self.offset_guard_size))
-                .ok_or_else(|| format_err!("overflow calculating size of memory allocation"))?;
-
-            let mut new_mmap = Mmap::accessible_reserved(0, request_bytes)?;
-            new_mmap.make_accessible(self.pre_guard_size, new_size)?;
-
-            // This method has an exclusive reference to `self.mmap` and just
-            // created `new_mmap` so it should be safe to acquire references
-            // into both of them and copy between them.
-            unsafe {
-                let range = self.pre_guard_size..self.pre_guard_size + self.accessible;
-                let src = self.mmap.slice(range.clone());
-                let dst = new_mmap.slice_mut(range);
-                dst.copy_from_slice(src);
-            }
-
-            // Now drop the MemoryImageSlot, if any. We've lost the CoW
-            // advantages by explicitly copying all data, but we have
-            // preserved all of its content; so we no longer need the
-            // mapping. We need to do this before we (implicitly) drop the
-            // `mmap` field by overwriting it below.
-            drop(self.memory_image.take());
-
-            self.mmap = new_mmap;
-        } else if let Some(image) = self.memory_image.as_mut() {
-            // MemoryImageSlot has its own growth mechanisms; defer to its
-            // implementation.
-            image.set_heap_limit(new_size)?;
-        } else {
-            // If the new size of this heap fits within the existing allocation
-            // then all we need to do is to make the new pages accessible. This
-            // can happen either for "static" heaps which always hit this case,
-            // or "dynamic" heaps which have some space reserved after the
-            // initial allocation to grow into before the heap is moved in
-            // memory.
-            assert!(new_size > self.accessible);
-            self.mmap.make_accessible(
-                self.pre_guard_size + self.accessible,
-                new_size - self.accessible,
-            )?;
-        }
-
-        self.accessible = new_size;
-
-        Ok(())
-    }
-
-    fn vmmemory(&mut self) -> VMMemoryDefinition {
-        VMMemoryDefinition {
-            base: unsafe { self.mmap.as_mut_ptr().add(self.pre_guard_size) },
-            current_length: self.accessible.into(),
-        }
-    }
-
-    fn needs_init(&self) -> bool {
-        // If we're using a CoW mapping, then no initialization
-        // is needed.
-        self.memory_image.is_none()
-    }
-
-    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
-        self
-    }
-
-    fn wasm_accessible(&self) -> Range<usize> {
-        let base = self.mmap.as_ptr() as usize + self.pre_guard_size;
-        let end = base + (self.mmap.len() - self.pre_guard_size);
-        base..end
-    }
-}
-
-/// A "static" memory where the lifetime of the backing memory is managed
-/// elsewhere. Currently used with the pooling allocator.
-struct StaticMemory {
-    /// The base pointer of this static memory, wrapped up in a send/sync
-    /// wrapper.
-    base: SendSyncPtr<u8>,
-
-    /// The byte capacity of the `base` pointer.
-    capacity: usize,
-
-    /// The current size, in bytes, of this memory.
-    size: usize,
-
-    /// The size, in bytes, of the virtual address allocation starting at `base`
-    /// and going to the end of the guard pages at the end of the linear memory.
-    memory_and_guard_size: usize,
-
-    /// The image management, if any, for this memory. Owned here and
-    /// returned to the pooling allocator when termination occurs.
-    memory_image: MemoryImageSlot,
-}
-
-impl StaticMemory {
-    fn new(
-        base_ptr: *mut u8,
-        base_capacity: usize,
-        initial_size: usize,
-        maximum_size: Option<usize>,
-        memory_image: MemoryImageSlot,
-        memory_and_guard_size: usize,
-    ) -> Result<Self> {
-        if base_capacity < initial_size {
-            bail!(
-                "initial memory size of {} exceeds the pooling allocator's \
-                 configured maximum memory size of {} bytes",
-                initial_size,
-                base_capacity,
-            );
-        }
-
-        // Only use the part of the slice that is necessary.
-        let base_capacity = match maximum_size {
-            Some(max) if max < base_capacity => max,
-            _ => base_capacity,
-        };
-
-        Ok(Self {
-            base: SendSyncPtr::new(NonNull::new(base_ptr).unwrap()),
-            capacity: base_capacity,
-            size: initial_size,
-            memory_image,
-            memory_and_guard_size,
-        })
-    }
-}
-
-impl RuntimeLinearMemory for StaticMemory {
-    fn byte_size(&self) -> usize {
-        self.size
-    }
-
-    fn maximum_byte_size(&self) -> Option<usize> {
-        Some(self.capacity)
-    }
-
-    fn grow_to(&mut self, new_byte_size: usize) -> Result<()> {
-        // Never exceed the static memory size; this check should have been made
-        // prior to arriving here.
-        assert!(new_byte_size <= self.capacity);
-
-        self.memory_image.set_heap_limit(new_byte_size)?;
-
-        // Update our accounting of the available size.
-        self.size = new_byte_size;
-        Ok(())
-    }
-
-    fn vmmemory(&mut self) -> VMMemoryDefinition {
-        VMMemoryDefinition {
-            base: self.base.as_ptr(),
-            current_length: self.size.into(),
-        }
-    }
-
-    fn needs_init(&self) -> bool {
-        !self.memory_image.has_image()
-    }
-
-    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
-        self
-    }
-
-    fn wasm_accessible(&self) -> Range<usize> {
-        let base = self.base.as_ptr() as usize;
-        let end = base + self.memory_and_guard_size;
-        base..end
-    }
-}
-
-/// For shared memory (and only for shared memory), this lock-version restricts
-/// access when growing the memory or checking its size. This is to conform with
-/// the [thread proposal]: "When `IsSharedArrayBuffer(...)` is true, the return
-/// value should be the result of an atomic read-modify-write of the new size to
-/// the internal `length` slot."
-///
-/// [thread proposal]:
-///     https://github.com/WebAssembly/threads/blob/master/proposals/threads/Overview.md#webassemblymemoryprototypegrow
-#[derive(Clone)]
-pub struct SharedMemory(Arc<SharedMemoryInner>);
-
-struct SharedMemoryInner {
-    memory: RwLock<Box<dyn RuntimeLinearMemory>>,
-    spot: ParkingSpot,
-    ty: wasmtime_environ::Memory,
-    def: LongTermVMMemoryDefinition,
-}
-
-impl SharedMemory {
-    /// Construct a new [`SharedMemory`].
-    pub fn new(plan: MemoryPlan) -> Result<Self> {
-        let (minimum_bytes, maximum_bytes) = Memory::limit_new(&plan, None)?;
-        let mmap_memory = MmapMemory::new(&plan, minimum_bytes, maximum_bytes, None)?;
-        Self::wrap(&plan, Box::new(mmap_memory), plan.memory)
-    }
-
-    /// Wrap an existing [Memory] with the locking provided by a [SharedMemory].
-    pub fn wrap(
-        plan: &MemoryPlan,
-        mut memory: Box<dyn RuntimeLinearMemory>,
-        ty: wasmtime_environ::Memory,
-    ) -> Result<Self> {
-        if !ty.shared {
-            bail!("shared memory must have a `shared` memory type");
-        }
-        if !matches!(plan.style, MemoryStyle::Static { .. }) {
-            bail!("shared memory can only be built from a static memory allocation")
-        }
-        assert!(
-            memory.as_any_mut().type_id() != std::any::TypeId::of::<SharedMemory>(),
-            "cannot re-wrap a shared memory"
-        );
-        Ok(Self(Arc::new(SharedMemoryInner {
-            ty,
-            spot: ParkingSpot::default(),
-            def: LongTermVMMemoryDefinition(memory.vmmemory()),
-            memory: RwLock::new(memory),
-        })))
-    }
-
-    /// Return the memory type for this [`SharedMemory`].
-    pub fn ty(&self) -> wasmtime_environ::Memory {
-        self.0.ty
-    }
-
-    /// Convert this shared memory into a [`Memory`].
-    pub fn as_memory(self) -> Memory {
-        Memory(Box::new(self))
-    }
-
-    /// Return a pointer to the shared memory's [VMMemoryDefinition].
-    pub fn vmmemory_ptr(&self) -> *const VMMemoryDefinition {
-        &self.0.def.0
-    }
-
-    /// Same as `RuntimeLinearMemory::grow`, except with `&self`.
-    pub fn grow(
-        &self,
-        delta_pages: u64,
-        store: Option<&mut dyn Store>,
-    ) -> Result<Option<(usize, usize)>, Error> {
-        let mut memory = self.0.memory.write().unwrap();
-        let result = memory.grow(delta_pages, store)?;
-        if let Some((_old_size_in_bytes, new_size_in_bytes)) = result {
-            // Store the new size to the `VMMemoryDefinition` for JIT-generated
-            // code (and runtime functions) to access. No other code can be
-            // growing this memory due to the write lock, but code in other
-            // threads could have access to this shared memory and we want them
-            // to see the most consistent version of the `current_length`; a
-            // weaker consistency is possible if we accept them seeing an older,
-            // smaller memory size (assumption: memory only grows) but presently
-            // we are aiming for accuracy.
-            //
-            // Note that it could be possible to access a memory address that is
-            // now-valid due to changes to the page flags in `grow` above but
-            // beyond the `memory.size` that we are about to assign to. In these
-            // and similar cases, discussion in the thread proposal concluded
-            // that: "multiple accesses in one thread racing with another
-            // thread's `memory.grow` that are in-bounds only after the grow
-            // commits may independently succeed or trap" (see
-            // https://github.com/WebAssembly/threads/issues/26#issuecomment-433930711).
-            // In other words, some non-determinism is acceptable when using
-            // `memory.size` on work being done by `memory.grow`.
-            self.0
-                .def
-                .0
-                .current_length
-                .store(new_size_in_bytes, Ordering::SeqCst);
-        }
-        Ok(result)
-    }
-
-    /// Implementation of `memory.atomic.notify` for this shared memory.
-    pub fn atomic_notify(&self, addr_index: u64, count: u32) -> Result<u32, Trap> {
-        validate_atomic_addr(&self.0.def.0, addr_index, 4, 4)?;
-        Ok(self.0.spot.unpark(addr_index, count))
-    }
-
-    /// Implementation of `memory.atomic.wait32` for this shared memory.
-    pub fn atomic_wait32(
-        &self,
-        addr_index: u64,
-        expected: u32,
-        timeout: Option<Instant>,
-    ) -> Result<WaitResult, Trap> {
-        let addr = validate_atomic_addr(&self.0.def.0, addr_index, 4, 4)?;
-        // SAFETY: `addr_index` was validated by `validate_atomic_addr` above.
-        assert!(std::mem::size_of::<AtomicU32>() == 4);
-        assert!(std::mem::align_of::<AtomicU32>() <= 4);
-        let atomic = unsafe { &*(addr as *const AtomicU32) };
-
-        // We want the sequential consistency of `SeqCst` to ensure that the `load` sees the value that the `notify` will/would see.
-        // All WASM atomic operations are also `SeqCst`.
-        let validate = || atomic.load(Ordering::SeqCst) == expected;
-
-        Ok(self.0.spot.park(addr_index, validate, timeout))
-    }
-
-    /// Implementation of `memory.atomic.wait64` for this shared memory.
-    pub fn atomic_wait64(
-        &self,
-        addr_index: u64,
-        expected: u64,
-        timeout: Option<Instant>,
-    ) -> Result<WaitResult, Trap> {
-        let addr = validate_atomic_addr(&self.0.def.0, addr_index, 8, 8)?;
-        // SAFETY: `addr_index` was validated by `validate_atomic_addr` above.
-        assert!(std::mem::size_of::<AtomicU64>() == 8);
-        assert!(std::mem::align_of::<AtomicU64>() <= 8);
-        let atomic = unsafe { &*(addr as *const AtomicU64) };
-
-        // We want the sequential consistency of `SeqCst` to ensure that the `load` sees the value that the `notify` will/would see.
-        // All WASM atomic operations are also `SeqCst`.
-        let validate = || atomic.load(Ordering::SeqCst) == expected;
-
-        Ok(self.0.spot.park(addr_index, validate, timeout))
-    }
-}
-
-/// Shared memory needs some representation of a `VMMemoryDefinition` for
-/// JIT-generated code to access. This structure owns the base pointer and
-/// length to the actual memory and we share this definition across threads by:
-/// - never changing the base pointer; according to the specification, shared
-///   memory must be created with a known maximum size so it can be allocated
-///   once and never moved
-/// - carefully changing the length, using atomic accesses in both the runtime
-///   and JIT-generated code.
-struct LongTermVMMemoryDefinition(VMMemoryDefinition);
-unsafe impl Send for LongTermVMMemoryDefinition {}
-unsafe impl Sync for LongTermVMMemoryDefinition {}
-
-/// Proxy all calls through the [`RwLock`].
-impl RuntimeLinearMemory for SharedMemory {
-    fn byte_size(&self) -> usize {
-        self.0.memory.read().unwrap().byte_size()
-    }
-
-    fn maximum_byte_size(&self) -> Option<usize> {
-        self.0.memory.read().unwrap().maximum_byte_size()
-    }
-
-    fn grow(
-        &mut self,
-        delta_pages: u64,
-        store: Option<&mut dyn Store>,
-    ) -> Result<Option<(usize, usize)>, Error> {
-        SharedMemory::grow(self, delta_pages, store)
-    }
-
-    fn grow_to(&mut self, size: usize) -> Result<()> {
-        self.0.memory.write().unwrap().grow_to(size)
-    }
-
-    fn vmmemory(&mut self) -> VMMemoryDefinition {
-        // `vmmemory()` is used for writing the `VMMemoryDefinition` of a memory
-        // into its `VMContext`; this should never be possible for a shared
-        // memory because the only `VMMemoryDefinition` for it should be stored
-        // in its own `def` field.
-        unreachable!()
-    }
-
-    fn needs_init(&self) -> bool {
-        self.0.memory.read().unwrap().needs_init()
-    }
-
-    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
-        self
-    }
-
-    fn wasm_accessible(&self) -> Range<usize> {
-        self.0.memory.read().unwrap().wasm_accessible()
-    }
-}
-
-/// Representation of a runtime wasm linear memory.
-pub struct Memory(Box<dyn RuntimeLinearMemory>);
-
-impl Memory {
-    /// Create a new dynamic (movable) memory instance for the specified plan.
-    pub fn new_dynamic(
-        plan: &MemoryPlan,
-        creator: &dyn RuntimeMemoryCreator,
-        store: &mut dyn Store,
-        memory_image: Option<&Arc<MemoryImage>>,
-    ) -> Result<Self> {
-        let (minimum, maximum) = Self::limit_new(plan, Some(store))?;
-        let allocation = creator.new_memory(plan, minimum, maximum, memory_image)?;
-        let allocation = if plan.memory.shared {
-            Box::new(SharedMemory::wrap(plan, allocation, plan.memory)?)
-        } else {
-            allocation
-        };
-        Ok(Memory(allocation))
-    }
-
-    /// Create a new static (immovable) memory instance for the specified plan.
-    pub fn new_static(
-        plan: &MemoryPlan,
-        base_ptr: *mut u8,
-        base_capacity: usize,
-        memory_image: MemoryImageSlot,
-        memory_and_guard_size: usize,
-        store: &mut dyn Store,
-    ) -> Result<Self> {
-        let (minimum, maximum) = Self::limit_new(plan, Some(store))?;
-        let pooled_memory = StaticMemory::new(
-            base_ptr,
-            base_capacity,
-            minimum,
-            maximum,
-            memory_image,
-            memory_and_guard_size,
-        )?;
-        let allocation = Box::new(pooled_memory);
-        let allocation: Box<dyn RuntimeLinearMemory> = if plan.memory.shared {
-            // FIXME: since the pooling allocator owns the memory allocation
-            // (which is torn down with the instance), the current shared memory
-            // implementation will cause problems; see
-            // https://github.com/bytecodealliance/wasmtime/issues/4244.
-            todo!("using shared memory with the pooling allocator is a work in progress");
-        } else {
-            allocation
-        };
-        Ok(Memory(allocation))
-    }
-
-    /// Calls the `store`'s limiter to optionally prevent a memory from being allocated.
-    ///
-    /// Returns the minimum size and optional maximum size of the memory, in
-    /// bytes.
-    fn limit_new(
-        plan: &MemoryPlan,
-        store: Option<&mut dyn Store>,
-    ) -> Result<(usize, Option<usize>)> {
-        // Sanity-check what should already be true from wasm module validation.
-        let absolute_max = if plan.memory.memory64 {
-            WASM64_MAX_PAGES
-        } else {
-            WASM32_MAX_PAGES
-        };
-        assert!(plan.memory.minimum <= absolute_max);
-        assert!(plan.memory.maximum.is_none() || plan.memory.maximum.unwrap() <= absolute_max);
-
-        // This is the absolute possible maximum that the module can try to
-        // allocate, which is our entire address space minus a wasm page. That
-        // shouldn't ever actually work in terms of an allocation because
-        // presumably the kernel wants *something* for itself, but this is used
-        // to pass to the `store`'s limiter for a requested size
-        // to approximate the scale of the request that the wasm module is
-        // making. This is necessary because the limiter works on `usize` bytes
-        // whereas we're working with possibly-overflowing `u64` calculations
-        // here. To actually faithfully represent the byte requests of modules
-        // we'd have to represent things as `u128`, but that's kinda
-        // overkill for this purpose.
-        let absolute_max = 0usize.wrapping_sub(WASM_PAGE_SIZE);
-
-        // If the minimum memory size overflows the size of our own address
-        // space, then we can't satisfy this request, but defer the error to
-        // later so the `store` can be informed that an effective oom is
-        // happening.
-        let minimum = plan
-            .memory
-            .minimum
-            .checked_mul(WASM_PAGE_SIZE_U64)
-            .and_then(|m| usize::try_from(m).ok());
-
-        // The plan stores the maximum size in units of wasm pages, but we
-        // use units of bytes. Unlike for the `minimum` size we silently clamp
-        // the effective maximum size to `absolute_max` above if the maximum is
-        // too large. This should be ok since as a wasm runtime we get to
-        // arbitrarily decide the actual maximum size of memory, regardless of
-        // what's actually listed on the memory itself.
-        let mut maximum = plan.memory.maximum.map(|max| {
-            usize::try_from(max)
-                .ok()
-                .and_then(|m| m.checked_mul(WASM_PAGE_SIZE))
-                .unwrap_or(absolute_max)
-        });
-
-        // If this is a 32-bit memory and no maximum is otherwise listed then we
-        // need to still specify a maximum size of 4GB. If the host platform is
-        // 32-bit then there's no need to limit the maximum this way since no
-        // allocation of 4GB can succeed, but for 64-bit platforms this is
-        // required to limit memories to 4GB.
-        if !plan.memory.memory64 && maximum.is_none() {
-            maximum = usize::try_from(1u64 << 32).ok();
-        }
-
-        // Inform the store's limiter what's about to happen. This will let the
-        // limiter reject anything if necessary, and this also guarantees that
-        // we should call the limiter for all requested memories, even if our
-        // `minimum` calculation overflowed. This means that the `minimum` we're
-        // informing the limiter is lossy and may not be 100% accurate, but for
-        // now the expected uses of limiter means that's ok.
-        if let Some(store) = store {
-            // We ignore the store limits for shared memories since they are
-            // technically not created within a store (though, trickily, they
-            // may be associated with one in order to get a `vmctx`).
-            if !plan.memory.shared {
-                if !store.memory_growing(0, minimum.unwrap_or(absolute_max), maximum)? {
-                    bail!(
-                        "memory minimum size of {} pages exceeds memory limits",
-                        plan.memory.minimum
-                    );
-                }
-            }
-        }
-
-        // At this point we need to actually handle overflows, so bail out with
-        // an error if we made it this far.
-        let minimum = minimum.ok_or_else(|| {
-            format_err!(
-                "memory minimum size of {} pages exceeds memory limits",
-                plan.memory.minimum
-            )
-        })?;
-        Ok((minimum, maximum))
-    }
-
-    /// Returns the number of allocated wasm pages.
-    pub fn byte_size(&self) -> usize {
-        self.0.byte_size()
-    }
-
-    /// Returns the maximum number of pages the memory can grow to at runtime.
-    ///
-    /// Returns `None` if the memory is unbounded.
-    ///
-    /// The runtime maximum may not be equal to the maximum from the linear memory's
-    /// Wasm type when it is being constrained by an instance allocator.
-    pub fn maximum_byte_size(&self) -> Option<usize> {
-        self.0.maximum_byte_size()
-    }
-
-    /// Returns whether or not this memory needs initialization. It
-    /// may not if it already has initial content thanks to a CoW
-    /// mechanism.
-    pub(crate) fn needs_init(&self) -> bool {
-        self.0.needs_init()
-    }
-
-    /// Grow memory by the specified amount of wasm pages.
-    ///
-    /// Returns `None` if memory can't be grown by the specified amount
-    /// of wasm pages. Returns `Some` with the old size of memory, in bytes, on
-    /// successful growth.
-    ///
-    /// # Safety
-    ///
-    /// Resizing the memory can reallocate the memory buffer for dynamic memories.
-    /// An instance's `VMContext` may have pointers to the memory's base and will
-    /// need to be fixed up after growing the memory.
-    ///
-    /// Generally, prefer using `InstanceHandle::memory_grow`, which encapsulates
-    /// this unsafety.
-    ///
-    /// Ensure that the provided Store is not used to get access any Memory
-    /// which lives inside it.
-    pub unsafe fn grow(
-        &mut self,
-        delta_pages: u64,
-        store: Option<&mut dyn Store>,
-    ) -> Result<Option<usize>, Error> {
-        self.0
-            .grow(delta_pages, store)
-            .map(|opt| opt.map(|(old, _new)| old))
-    }
-
-    /// Return a `VMMemoryDefinition` for exposing the memory to compiled wasm code.
-    pub fn vmmemory(&mut self) -> VMMemoryDefinition {
-        self.0.vmmemory()
-    }
-
-    /// Consume the memory, returning its [`MemoryImageSlot`] if any is present.
-    /// The image should only be present for a subset of memories created with
-    /// [`Memory::new_static()`].
-    #[cfg(feature = "pooling-allocator")]
-    pub fn unwrap_static_image(mut self) -> MemoryImageSlot {
-        let mem = self.0.as_any_mut().downcast_mut::<StaticMemory>().unwrap();
-        std::mem::replace(&mut mem.memory_image, MemoryImageSlot::dummy())
-    }
-
-    /// If the [Memory] is a [SharedMemory], unwrap it and return a clone to
-    /// that shared memory.
-    pub fn as_shared_memory(&mut self) -> Option<&mut SharedMemory> {
-        let as_any = self.0.as_any_mut();
-        if let Some(m) = as_any.downcast_mut::<SharedMemory>() {
-            Some(m)
-        } else {
-            None
-        }
-    }
-
-    /// Implementation of `memory.atomic.notify` for all memories.
-    pub fn atomic_notify(&mut self, addr: u64, count: u32) -> Result<u32, Trap> {
-        match self.0.as_any_mut().downcast_mut::<SharedMemory>() {
-            Some(m) => m.atomic_notify(addr, count),
-            None => {
-                validate_atomic_addr(&self.vmmemory(), addr, 4, 4)?;
-                Ok(0)
-            }
-        }
-    }
-
-    /// Implementation of `memory.atomic.wait32` for all memories.
-    pub fn atomic_wait32(
-        &mut self,
-        addr: u64,
-        expected: u32,
-        deadline: Option<Instant>,
-    ) -> Result<WaitResult, Trap> {
-        match self.0.as_any_mut().downcast_mut::<SharedMemory>() {
-            Some(m) => m.atomic_wait32(addr, expected, deadline),
-            None => {
-                validate_atomic_addr(&self.vmmemory(), addr, 4, 4)?;
-                Err(Trap::AtomicWaitNonSharedMemory)
-            }
-        }
-    }
-
-    /// Implementation of `memory.atomic.wait64` for all memories.
-    pub fn atomic_wait64(
-        &mut self,
-        addr: u64,
-        expected: u64,
-        deadline: Option<Instant>,
-    ) -> Result<WaitResult, Trap> {
-        match self.0.as_any_mut().downcast_mut::<SharedMemory>() {
-            Some(m) => m.atomic_wait64(addr, expected, deadline),
-            None => {
-                validate_atomic_addr(&self.vmmemory(), addr, 8, 8)?;
-                Err(Trap::AtomicWaitNonSharedMemory)
-            }
-        }
-    }
-
-    /// Returns the range of bytes that WebAssembly should be able to address in
-    /// this linear memory. Note that this includes guard pages which wasm can
-    /// hit.
-    pub fn wasm_accessible(&self) -> Range<usize> {
-        self.0.wasm_accessible()
-    }
-}
-
-/// In the configurations where bounds checks were elided in JIT code (because
-/// we are using static memories with virtual memory guard pages) this manual
-/// check is here so we don't segfault from Rust. For other configurations,
-/// these checks are required anyways.
-fn validate_atomic_addr(
-    def: &VMMemoryDefinition,
-    addr: u64,
-    access_size: u64,
-    access_alignment: u64,
-) -> Result<*mut u8, Trap> {
-    debug_assert!(access_alignment.is_power_of_two());
-    if !(addr % access_alignment == 0) {
-        return Err(Trap::HeapMisaligned);
-    }
-
-    let length = u64::try_from(def.current_length()).unwrap();
-    if !(addr.saturating_add(access_size) < length) {
-        return Err(Trap::MemoryOutOfBounds);
-    }
-
-    Ok(def.base.wrapping_add(addr as usize))
-}
diff --git a/crates/runtime/src/mmap.rs b/crates/runtime/src/mmap.rs
deleted file mode 100644
index 4f9f4c64d4e5..000000000000
--- a/crates/runtime/src/mmap.rs
+++ /dev/null
@@ -1,223 +0,0 @@
-//! Low-level abstraction for allocating and managing zero-filled pages
-//! of memory.
-
-use anyhow::{Context, Result};
-use std::fs::File;
-use std::ops::Range;
-use std::path::Path;
-use std::sync::Arc;
-
-cfg_if::cfg_if! {
-    if #[cfg(windows)] {
-        mod windows;
-        use windows as sys;
-    } else if #[cfg(miri)] {
-        mod miri;
-        use miri as sys;
-    } else {
-        mod unix;
-        use unix as sys;
-    }
-}
-
-/// A simple struct consisting of a page-aligned pointer to page-aligned
-/// and initially-zeroed memory and a length.
-#[derive(Debug)]
-pub struct Mmap {
-    sys: sys::Mmap,
-    file: Option<Arc<File>>,
-}
-
-impl Mmap {
-    /// Create a new `Mmap` pointing to at least `size` bytes of page-aligned
-    /// accessible memory.
-    pub fn with_at_least(size: usize) -> Result<Self> {
-        let page_size = crate::page_size();
-        let rounded_size = (size + (page_size - 1)) & !(page_size - 1);
-        Self::accessible_reserved(rounded_size, rounded_size)
-    }
-
-    /// Creates a new `Mmap` by opening the file located at `path` and mapping
-    /// it into memory.
-    ///
-    /// The memory is mapped in read-only mode for the entire file. If portions
-    /// of the file need to be modified then the `region` crate can be use to
-    /// alter permissions of each page.
-    ///
-    /// The memory mapping and the length of the file within the mapping are
-    /// returned.
-    pub fn from_file(path: &Path) -> Result<Self> {
-        let (sys, file) = sys::Mmap::from_file(path)?;
-        Ok(Mmap {
-            sys,
-            file: Some(Arc::new(file)),
-        })
-    }
-
-    /// Create a new `Mmap` pointing to `accessible_size` bytes of page-aligned
-    /// accessible memory, within a reserved mapping of `mapping_size` bytes.
-    /// `accessible_size` and `mapping_size` must be native page-size multiples.
-    ///
-    /// # Panics
-    ///
-    /// This function will panic if `accessible_size` is greater than
-    /// `mapping_size` or if either of them are not page-aligned.
-    pub fn accessible_reserved(accessible_size: usize, mapping_size: usize) -> Result<Self> {
-        let page_size = crate::page_size();
-        assert!(accessible_size <= mapping_size);
-        assert_eq!(mapping_size & (page_size - 1), 0);
-        assert_eq!(accessible_size & (page_size - 1), 0);
-
-        if mapping_size == 0 {
-            Ok(Mmap {
-                sys: sys::Mmap::new_empty(),
-                file: None,
-            })
-        } else if accessible_size == mapping_size {
-            Ok(Mmap {
-                sys: sys::Mmap::new(mapping_size)
-                    .context(format!("mmap failed to allocate {mapping_size:#x} bytes"))?,
-                file: None,
-            })
-        } else {
-            let mut result = Mmap {
-                sys: sys::Mmap::reserve(mapping_size)
-                    .context(format!("mmap failed to reserve {mapping_size:#x} bytes"))?,
-                file: None,
-            };
-            if accessible_size > 0 {
-                result.make_accessible(0, accessible_size).context(format!(
-                    "mmap failed to allocate {accessible_size:#x} bytes"
-                ))?;
-            }
-            Ok(result)
-        }
-    }
-
-    /// Make the memory starting at `start` and extending for `len` bytes
-    /// accessible. `start` and `len` must be native page-size multiples and
-    /// describe a range within `self`'s reserved memory.
-    ///
-    /// # Panics
-    ///
-    /// This function will panic if `start` or `len` is not page aligned or if
-    /// either are outside the bounds of this mapping.
-    pub fn make_accessible(&mut self, start: usize, len: usize) -> Result<()> {
-        let page_size = crate::page_size();
-        assert_eq!(start & (page_size - 1), 0);
-        assert_eq!(len & (page_size - 1), 0);
-        assert!(len <= self.len());
-        assert!(start <= self.len() - len);
-
-        self.sys.make_accessible(start, len)
-    }
-
-    /// Return the allocated memory as a slice of u8.
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that the range of bytes is accessible to the
-    /// program and additionally has previously been initialized.
-    ///
-    /// # Panics
-    ///
-    /// Panics of the `range` provided is outside of the limits of this mmap.
-    #[inline]
-    pub unsafe fn slice(&self, range: Range<usize>) -> &[u8] {
-        assert!(range.start <= range.end);
-        assert!(range.end <= self.len());
-        std::slice::from_raw_parts(self.as_ptr().add(range.start), range.end - range.start)
-    }
-
-    /// Return the allocated memory as a mutable slice of u8.
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that the range of bytes is accessible to the
-    /// program and additionally has previously been initialized.
-    ///
-    /// # Panics
-    ///
-    /// Panics of the `range` provided is outside of the limits of this mmap.
-    pub unsafe fn slice_mut(&mut self, range: Range<usize>) -> &mut [u8] {
-        assert!(range.start <= range.end);
-        assert!(range.end <= self.len());
-        std::slice::from_raw_parts_mut(self.as_mut_ptr().add(range.start), range.end - range.start)
-    }
-
-    /// Return the allocated memory as a pointer to u8.
-    pub fn as_ptr(&self) -> *const u8 {
-        self.sys.as_ptr()
-    }
-
-    /// Return the allocated memory as a mutable pointer to u8.
-    pub fn as_mut_ptr(&mut self) -> *mut u8 {
-        self.sys.as_mut_ptr()
-    }
-
-    /// Return the length of the allocated memory.
-    ///
-    /// This is the byte length of this entire mapping which includes both
-    /// addressible and non-addressible memory.
-    pub fn len(&self) -> usize {
-        self.sys.len()
-    }
-
-    /// Return whether any memory has been allocated or reserved.
-    pub fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
-    /// Makes the specified `range` within this `Mmap` to be read/execute.
-    ///
-    /// # Unsafety
-    ///
-    /// This method is unsafe as it's generally not valid to simply make memory
-    /// executable, so it's up to the caller to ensure that everything is in
-    /// order and this doesn't overlap with other memory that should only be
-    /// read or only read/write.
-    ///
-    /// # Panics
-    ///
-    /// Panics of `range` is out-of-bounds or not page-aligned.
-    pub unsafe fn make_executable(
-        &self,
-        range: Range<usize>,
-        enable_branch_protection: bool,
-    ) -> Result<()> {
-        assert!(range.start <= self.len());
-        assert!(range.end <= self.len());
-        assert!(range.start <= range.end);
-        assert!(
-            range.start % crate::page_size() == 0,
-            "changing of protections isn't page-aligned",
-        );
-        self.sys
-            .make_executable(range, enable_branch_protection)
-            .context("failed to make memory executable")
-    }
-
-    /// Makes the specified `range` within this `Mmap` to be readonly.
-    pub unsafe fn make_readonly(&self, range: Range<usize>) -> Result<()> {
-        assert!(range.start <= self.len());
-        assert!(range.end <= self.len());
-        assert!(range.start <= range.end);
-        assert!(
-            range.start % crate::page_size() == 0,
-            "changing of protections isn't page-aligned",
-        );
-        self.sys
-            .make_readonly(range)
-            .context("failed to make memory readonly")
-    }
-
-    /// Returns the underlying file that this mmap is mapping, if present.
-    pub fn original_file(&self) -> Option<&Arc<File>> {
-        self.file.as_ref()
-    }
-}
-
-fn _assert() {
-    fn _assert_send_sync<T: Send + Sync>() {}
-    _assert_send_sync::<Mmap>();
-}
diff --git a/crates/runtime/src/mmap/miri.rs b/crates/runtime/src/mmap/miri.rs
deleted file mode 100644
index 0760c3a9fc91..000000000000
--- a/crates/runtime/src/mmap/miri.rs
+++ /dev/null
@@ -1,94 +0,0 @@
-//! A "dummy" implementation of mmaps for miri where "we do the best we can"
-//!
-//! Namely this uses `alloc` to allocate memory for the "mmap" specifically to
-//! create page-aligned allocations. This allocation doesn't handle operations
-//! like becoming executable or becoming readonly or being created from files,
-//! but it's enough to get various tests running relying on memories and such.
-
-use crate::SendSyncPtr;
-use anyhow::{bail, Result};
-use std::alloc::{self, Layout};
-use std::fs::File;
-use std::ops::Range;
-use std::path::Path;
-use std::ptr::NonNull;
-
-#[derive(Debug)]
-pub struct Mmap {
-    memory: SendSyncPtr<[u8]>,
-}
-
-impl Mmap {
-    pub fn new_empty() -> Mmap {
-        Mmap {
-            memory: SendSyncPtr::from(&mut [][..]),
-        }
-    }
-
-    pub fn new(size: usize) -> Result<Self> {
-        let mut ret = Mmap::reserve(size)?;
-        ret.make_accessible(0, size)?;
-        Ok(ret)
-    }
-
-    pub fn reserve(size: usize) -> Result<Self> {
-        let layout = Layout::from_size_align(size, crate::page_size()).unwrap();
-        let ptr = unsafe { alloc::alloc(layout) };
-        if ptr.is_null() {
-            bail!("failed to allocate memory");
-        }
-
-        let memory = std::ptr::slice_from_raw_parts_mut(ptr.cast(), size);
-        let memory = SendSyncPtr::new(NonNull::new(memory).unwrap());
-        Ok(Mmap { memory })
-    }
-
-    pub fn from_file(_path: &Path) -> Result<(Self, File)> {
-        bail!("not supported on miri");
-    }
-
-    pub fn make_accessible(&mut self, start: usize, len: usize) -> Result<()> {
-        // The memory is technically always accessible but this marks it as
-        // initialized for miri-level checking.
-        unsafe {
-            std::ptr::write_bytes(self.memory.as_ptr().cast::<u8>().add(start), 0u8, len);
-        }
-        Ok(())
-    }
-
-    pub fn as_ptr(&self) -> *const u8 {
-        self.memory.as_ptr() as *const u8
-    }
-
-    pub fn as_mut_ptr(&mut self) -> *mut u8 {
-        self.memory.as_ptr().cast()
-    }
-
-    pub fn len(&self) -> usize {
-        unsafe { (*self.memory.as_ptr()).len() }
-    }
-
-    pub unsafe fn make_executable(
-        &self,
-        _range: Range<usize>,
-        _enable_branch_protection: bool,
-    ) -> Result<()> {
-        Ok(())
-    }
-
-    pub unsafe fn make_readonly(&self, _range: Range<usize>) -> Result<()> {
-        Ok(())
-    }
-}
-
-impl Drop for Mmap {
-    fn drop(&mut self) {
-        if self.len() == 0 {
-            return;
-        }
-        unsafe {
-            let layout = Layout::from_size_align(self.len(), crate::page_size()).unwrap();
-            alloc::dealloc(self.as_mut_ptr(), layout);
-        }
-    }
-}
diff --git a/crates/runtime/src/mmap/unix.rs b/crates/runtime/src/mmap/unix.rs
deleted file mode 100644
index 3227ec3a025f..000000000000
--- a/crates/runtime/src/mmap/unix.rs
+++ /dev/null
@@ -1,148 +0,0 @@
-use crate::SendSyncPtr;
-use anyhow::{anyhow, Context, Result};
-use rustix::mm::{mprotect, MprotectFlags};
-use std::fs::File;
-use std::ops::Range;
-use std::path::Path;
-use std::ptr::{self, NonNull};
-
-#[derive(Debug)]
-pub struct Mmap {
-    memory: SendSyncPtr<[u8]>,
-}
-
-impl Mmap {
-    pub fn new_empty() -> Mmap {
-        Mmap {
-            memory: SendSyncPtr::from(&mut [][..]),
-        }
-    }
-
-    pub fn new(size: usize) -> Result<Self> {
-        let ptr = unsafe {
-            rustix::mm::mmap_anonymous(
-                ptr::null_mut(),
-                size,
-                rustix::mm::ProtFlags::READ | rustix::mm::ProtFlags::WRITE,
-                rustix::mm::MapFlags::PRIVATE,
-            )?
-        };
-        let memory = std::ptr::slice_from_raw_parts_mut(ptr.cast(), size);
-        let memory = SendSyncPtr::new(NonNull::new(memory).unwrap());
-        Ok(Mmap { memory })
-    }
-
-    pub fn reserve(size: usize) -> Result<Self> {
-        let ptr = unsafe {
-            rustix::mm::mmap_anonymous(
-                ptr::null_mut(),
-                size,
-                rustix::mm::ProtFlags::empty(),
-                rustix::mm::MapFlags::PRIVATE,
-            )?
-        };
-
-        let memory = std::ptr::slice_from_raw_parts_mut(ptr.cast(), size);
-        let memory = SendSyncPtr::new(NonNull::new(memory).unwrap());
-        Ok(Mmap { memory })
-    }
-
-    pub fn from_file(path: &Path) -> Result<(Self, File)> {
-        let file = File::open(path).context("failed to open file")?;
-        let len = file
-            .metadata()
-            .context("failed to get file metadata")?
-            .len();
-        let len = usize::try_from(len).map_err(|_| anyhow!("file too large to map"))?;
-        let ptr = unsafe {
-            rustix::mm::mmap(
-                ptr::null_mut(),
-                len,
-                rustix::mm::ProtFlags::READ | rustix::mm::ProtFlags::WRITE,
-                rustix::mm::MapFlags::PRIVATE,
-                &file,
-                0,
-            )
-            .context(format!("mmap failed to allocate {:#x} bytes", len))?
-        };
-        let memory = std::ptr::slice_from_raw_parts_mut(ptr.cast(), len);
-        let memory = SendSyncPtr::new(NonNull::new(memory).unwrap());
-
-        Ok((Mmap { memory }, file))
-    }
-
-    pub fn make_accessible(&mut self, start: usize, len: usize) -> Result<()> {
-        let ptr = self.memory.as_ptr().cast::<u8>();
-        unsafe {
-            mprotect(
-                ptr.add(start).cast(),
-                len,
-                MprotectFlags::READ | MprotectFlags::WRITE,
-            )?;
-        }
-
-        Ok(())
-    }
-
-    pub fn as_ptr(&self) -> *const u8 {
-        self.memory.as_ptr() as *const u8
-    }
-
-    pub fn as_mut_ptr(&mut self) -> *mut u8 {
-        self.memory.as_ptr().cast()
-    }
-
-    pub fn len(&self) -> usize {
-        unsafe { (*self.memory.as_ptr()).len() }
-    }
-
-    pub unsafe fn make_executable(
-        &self,
-        range: Range<usize>,
-        enable_branch_protection: bool,
-    ) -> Result<()> {
-        let base = self.memory.as_ptr().cast::<u8>().add(range.start).cast();
-        let len = range.end - range.start;
-
-        let flags = MprotectFlags::READ | MprotectFlags::EXEC;
-        let flags = if enable_branch_protection {
-            #[cfg(all(target_arch = "aarch64", target_os = "linux"))]
-            if std::arch::is_aarch64_feature_detected!("bti") {
-                MprotectFlags::from_bits_retain(flags.bits() | /* PROT_BTI */ 0x10)
-            } else {
-                flags
-            }
-
-            #[cfg(not(all(target_arch = "aarch64", target_os = "linux")))]
-            flags
-        } else {
-            flags
-        };
-
-        mprotect(base, len, flags)?;
-
-        Ok(())
-    }
-
-    pub unsafe fn make_readonly(&self, range: Range<usize>) -> Result<()> {
-        let base = self.memory.as_ptr().cast::<u8>().add(range.start).cast();
-        let len = range.end - range.start;
-
-        mprotect(base, len, MprotectFlags::READ)?;
-
-        Ok(())
-    }
-}
-
-impl Drop for Mmap {
-    fn drop(&mut self) {
-        unsafe {
-            let ptr = self.memory.as_ptr().cast();
-            let len = (*self.memory.as_ptr()).len();
-            if len == 0 {
-                return;
-            }
-            rustix::mm::munmap(ptr, len).expect("munmap failed");
-        }
-    }
-}
diff --git a/crates/runtime/src/mmap/windows.rs b/crates/runtime/src/mmap/windows.rs
deleted file mode 100644
index 5ca208b337ac..000000000000
--- a/crates/runtime/src/mmap/windows.rs
+++ /dev/null
@@ -1,208 +0,0 @@
-use crate::SendSyncPtr;
-use anyhow::{anyhow, bail, Context, Result};
-use std::fs::{File, OpenOptions};
-use std::io;
-use std::ops::Range;
-use std::os::windows::prelude::*;
-use std::path::Path;
-use std::ptr::{self, NonNull};
-use windows_sys::Win32::Foundation::*;
-use windows_sys::Win32::Storage::FileSystem::*;
-use windows_sys::Win32::System::Memory::*;
-
-#[derive(Debug)]
-pub struct Mmap {
-    memory: SendSyncPtr<[u8]>,
-    is_file: bool,
-}
-
-impl Mmap {
-    pub fn new_empty() -> Mmap {
-        Mmap {
-            memory: SendSyncPtr::from(&mut [][..]),
-            is_file: false,
-        }
-    }
-
-    pub fn new(size: usize) -> Result<Self> {
-        let ptr = unsafe {
-            VirtualAlloc(
-                ptr::null_mut(),
-                size,
-                MEM_RESERVE | MEM_COMMIT,
-                PAGE_READWRITE,
-            )
-        };
-        if ptr.is_null() {
-            bail!(io::Error::last_os_error())
-        }
-
-        let memory = std::ptr::slice_from_raw_parts_mut(ptr.cast(), size);
-        let memory = SendSyncPtr::new(NonNull::new(memory).unwrap());
-        Ok(Self {
-            memory,
-            is_file: false,
-        })
-    }
-
-    pub fn reserve(size: usize) -> Result<Self> {
-        let ptr = unsafe { VirtualAlloc(ptr::null_mut(), size, MEM_RESERVE, PAGE_NOACCESS) };
-        if ptr.is_null() {
-            bail!(io::Error::last_os_error())
-        }
-        let memory = std::ptr::slice_from_raw_parts_mut(ptr.cast(), size);
-        let memory = SendSyncPtr::new(NonNull::new(memory).unwrap());
-        Ok(Self {
-            memory,
-            is_file: false,
-        })
-    }
-
-    pub fn from_file(path: &Path) -> Result<(Self, File)> {
-        unsafe {
-            // Open the file with read/execute access and only share for
-            // read. This will enable us to perform the proper mmap below
-            // while also disallowing other processes modifying the file
-            // and having those modifications show up in our address space.
-            let file = OpenOptions::new()
-                .read(true)
-                .access_mode(FILE_GENERIC_READ | FILE_GENERIC_EXECUTE)
-                .share_mode(FILE_SHARE_READ)
-                .open(path)
-                .context("failed to open file")?;
-
-            let len = file
-                .metadata()
-                .context("failed to get file metadata")?
-                .len();
-            let len = usize::try_from(len).map_err(|_| anyhow!("file too large to map"))?;
-
-            // Create a file mapping that allows PAGE_EXECUTE_WRITECOPY.
-            // This enables up-to these permissions but we won't leave all
-            // of these permissions active at all times. Execution is
-            // necessary for the generated code from Cranelift and the
-            // WRITECOPY part is needed for possibly resolving relocations,
-            // but otherwise writes don't happen.
-            let mapping = CreateFileMappingW(
-                file.as_raw_handle() as isize,
-                ptr::null_mut(),
-                PAGE_EXECUTE_WRITECOPY,
-                0,
-                0,
-                ptr::null(),
-            );
-            if mapping == 0 {
-                return Err(io::Error::last_os_error()).context("failed to create file mapping");
-            }
-
-            // Create a view for the entire file using all our requisite
-            // permissions so that we can change the virtual permissions
-            // later on.
-            let ptr = MapViewOfFile(
-                mapping,
-                FILE_MAP_READ | FILE_MAP_EXECUTE | FILE_MAP_COPY,
-                0,
-                0,
-                len,
-            ) as *mut std::ffi::c_void;
-            let err = io::Error::last_os_error();
-            CloseHandle(mapping);
-            if ptr.is_null() {
-                return Err(err).context(format!("failed to create map view of {:#x} bytes", len));
-            }
-
-            let memory = std::ptr::slice_from_raw_parts_mut(ptr.cast(), len);
-            let memory = SendSyncPtr::new(NonNull::new(memory).unwrap());
-            let mut ret = Self {
-                memory,
-                is_file: true,
-            };
-
-            // Protect the entire file as PAGE_WRITECOPY to start (i.e.
-            // remove the execute bit)
-            let mut old = 0;
-            if VirtualProtect(ret.as_mut_ptr().cast(), ret.len(), PAGE_WRITECOPY, &mut old) == 0 {
-                return Err(io::Error::last_os_error())
-                    .context("failed change pages to `PAGE_READONLY`");
-            }
-
-            Ok((ret, file))
-        }
-    }
-
-    pub fn make_accessible(&mut self, start: usize, len: usize) -> Result<()> {
-        if unsafe {
-            VirtualAlloc(
-                self.as_ptr().add(start) as _,
-                len,
-                MEM_COMMIT,
-                PAGE_READWRITE,
-            )
-        }
-        .is_null()
-        {
-            bail!(io::Error::last_os_error())
-        }
-
-        Ok(())
-    }
-
-    pub fn as_ptr(&self) -> *const u8 {
-        self.memory.as_ptr() as *const u8
-    }
-
-    pub fn as_mut_ptr(&mut self) -> *mut u8 {
-        self.memory.as_ptr().cast()
-    }
-
-    pub fn len(&self) -> usize {
-        unsafe { (*self.memory.as_ptr()).len() }
-    }
-
-    pub unsafe fn make_executable(
-        &self,
-        range: Range<usize>,
-        enable_branch_protection: bool,
-    ) -> Result<()> {
-        let flags = if enable_branch_protection {
-            // TODO: We use this check to avoid an unused variable warning,
-            // but some of the CFG-related flags might be applicable
-            PAGE_EXECUTE_READ
-        } else {
-            PAGE_EXECUTE_READ
-        };
-        let mut old = 0;
-        let base = self.as_ptr().add(range.start);
-        let result = VirtualProtect(base as _, range.end - range.start, flags, &mut old);
-        if result == 0 {
-            bail!(io::Error::last_os_error());
-        }
-        Ok(())
-    }
-
-    pub unsafe fn make_readonly(&self, range: Range<usize>) -> Result<()> {
-        let mut old = 0;
-        let base = self.as_ptr().add(range.start);
-        let result = VirtualProtect(base as _, range.end - range.start, PAGE_READONLY, &mut old);
-        if result == 0 {
-            bail!(io::Error::last_os_error());
-        }
-        Ok(())
-    }
-}
-
-impl Drop for Mmap {
-    fn drop(&mut self) {
-        if self.len() == 0 {
-            return;
-        }
-
-        if self.is_file {
-            let r = unsafe { UnmapViewOfFile(self.as_mut_ptr() as MEMORYMAPPEDVIEW_HANDLE) };
-            assert_ne!(r, 0);
-        } else {
-            let r = unsafe { VirtualFree(self.as_mut_ptr().cast(), 0, MEM_RELEASE) };
-            assert_ne!(r, 0);
-        }
-    }
-}
diff --git a/crates/runtime/src/mmap_vec.rs b/crates/runtime/src/mmap_vec.rs
deleted file mode 100644
index c7822ffe9b4e..000000000000
--- a/crates/runtime/src/mmap_vec.rs
+++ /dev/null
@@ -1,193 +0,0 @@
-use crate::Mmap;
-use anyhow::{Context, Result};
-use std::fs::File;
-use std::ops::{Deref, DerefMut, Range};
-use std::path::Path;
-use std::sync::Arc;
-
-/// A type akin to `Vec<u8>`, but backed by `mmap` and able to be split.
-///
-/// This type is a non-growable owned list of bytes. It can be segmented into
-/// disjoint separately owned views akin to the `split_at` method on slices in
-/// Rust. An `MmapVec` is backed by an OS-level memory allocation and is not
-/// suitable for lots of small allocation (since it works at the page
-/// granularity).
-///
-/// An `MmapVec` is an owned value which means that owners have the ability to
-/// get exclusive access to the underlying bytes, enabling mutation.
-pub struct MmapVec {
-    mmap: Arc<Mmap>,
-    range: Range<usize>,
-}
-
-impl MmapVec {
-    /// Consumes an existing `mmap` and wraps it up into an `MmapVec`.
-    ///
-    /// The returned `MmapVec` will have the `size` specified, which can be
-    /// smaller than the region mapped by the `Mmap`. The returned `MmapVec`
-    /// will only have at most `size` bytes accessible.
-    pub fn new(mmap: Mmap, size: usize) -> MmapVec {
-        assert!(size <= mmap.len());
-        MmapVec {
-            mmap: Arc::new(mmap),
-            range: 0..size,
-        }
-    }
-
-    /// Creates a new zero-initialized `MmapVec` with the given `size`.
-    ///
-    /// This commit will return a new `MmapVec` suitably sized to hold `size`
-    /// bytes. All bytes will be initialized to zero since this is a fresh OS
-    /// page allocation.
-    pub fn with_capacity(size: usize) -> Result<MmapVec> {
-        Ok(MmapVec::new(Mmap::with_at_least(size)?, size))
-    }
-
-    /// Creates a new `MmapVec` from the contents of an existing `slice`.
-    ///
-    /// A new `MmapVec` is allocated to hold the contents of `slice` and then
-    /// `slice` is copied into the new mmap. It's recommended to avoid this
-    /// method if possible to avoid the need to copy data around.
-    pub fn from_slice(slice: &[u8]) -> Result<MmapVec> {
-        let mut result = MmapVec::with_capacity(slice.len())?;
-        result.copy_from_slice(slice);
-        Ok(result)
-    }
-
-    /// Creates a new `MmapVec` which is the `path` specified mmap'd into
-    /// memory.
-    ///
-    /// This function will attempt to open the file located at `path` and will
-    /// then use that file to learn about its size and map the full contents
-    /// into memory. This will return an error if the file doesn't exist or if
-    /// it's too large to be fully mapped into memory.
-    pub fn from_file(path: &Path) -> Result<MmapVec> {
-        let mmap = Mmap::from_file(path)
-            .with_context(|| format!("failed to create mmap for file: {}", path.display()))?;
-        let len = mmap.len();
-        Ok(MmapVec::new(mmap, len))
-    }
-
-    /// Splits the collection into two at the given index.
-    ///
-    /// Returns a separate `MmapVec` which shares the underlying mapping, but
-    /// only has access to elements in the range `[at, len)`. After the call,
-    /// the original `MmapVec` will be left with access to the elements in the
-    /// range `[0, at)`.
-    ///
-    /// This is an `O(1)` operation which does not involve copies.
-    pub fn split_off(&mut self, at: usize) -> MmapVec {
-        assert!(at <= self.range.len());
-
-        // Create a new `MmapVec` which refers to the same underlying mmap, but
-        // has a disjoint range from ours. Our own range is adjusted to be
-        // disjoint just after `ret` is created.
-        let ret = MmapVec {
-            mmap: self.mmap.clone(),
-            range: at..self.range.end,
-        };
-        self.range.end = self.range.start + at;
-        return ret;
-    }
-
-    /// Makes the specified `range` within this `mmap` to be read/execute.
-    pub unsafe fn make_executable(
-        &self,
-        range: Range<usize>,
-        enable_branch_protection: bool,
-    ) -> Result<()> {
-        assert!(range.start <= range.end);
-        assert!(range.end <= self.range.len());
-        self.mmap.make_executable(
-            range.start + self.range.start..range.end + self.range.start,
-            enable_branch_protection,
-        )
-    }
-
-    /// Makes the specified `range` within this `mmap` to be read-only.
-    pub unsafe fn make_readonly(&self, range: Range<usize>) -> Result<()> {
-        assert!(range.start <= range.end);
-        assert!(range.end <= self.range.len());
-        self.mmap
-            .make_readonly(range.start + self.range.start..range.end + self.range.start)
-    }
-
-    /// Returns the underlying file that this mmap is mapping, if present.
-    pub fn original_file(&self) -> Option<&Arc<File>> {
-        self.mmap.original_file()
-    }
-
-    /// Returns the offset within the original mmap that this `MmapVec` is
-    /// created from.
-    pub fn original_offset(&self) -> usize {
-        self.range.start
-    }
-}
-
-impl Deref for MmapVec {
-    type Target = [u8];
-
-    #[inline]
-    fn deref(&self) -> &[u8] {
-        // SAFETY: this mmap owns its own range of the underlying mmap so it
-        // should be all good-to-read.
-        unsafe { self.mmap.slice(self.range.clone()) }
-    }
-}
-
-impl DerefMut for MmapVec {
-    fn deref_mut(&mut self) -> &mut [u8] {
-        // SAFETY: The underlying mmap is protected behind an `Arc` which means
-        // there there can be many references to it. We are guaranteed, though,
-        // that each reference to the underlying `mmap` has a disjoint `range`
-        // listed that it can access. This means that despite having shared
-        // access to the mmap itself we have exclusive ownership of the bytes
-        // specified in `self.range`. This should allow us to safely hand out
-        // mutable access to these bytes if so desired.
-        unsafe {
-            let slice =
-                std::slice::from_raw_parts_mut(self.mmap.as_ptr().cast_mut(), self.mmap.len());
-            &mut slice[self.range.clone()]
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::MmapVec;
-
-    #[test]
-    fn smoke() {
-        let mut mmap = MmapVec::with_capacity(10).unwrap();
-        assert_eq!(mmap.len(), 10);
-        assert_eq!(&mmap[..], &[0; 10]);
-
-        mmap[0] = 1;
-        mmap[2] = 3;
-        assert!(mmap.get(10).is_none());
-        assert_eq!(mmap[0], 1);
-        assert_eq!(mmap[2], 3);
-    }
-
-    #[test]
-    fn split_off() {
-        let mut vec = Vec::from([1, 2, 3, 4]);
-        let mut mmap = MmapVec::from_slice(&vec).unwrap();
-        assert_eq!(&mmap[..], &vec[..]);
-        // remove nothing; vec length remains 4
-        assert_eq!(&mmap.split_off(4)[..], &vec.split_off(4)[..]);
-        assert_eq!(&mmap[..], &vec[..]);
-        // remove 1 element; vec length is now 3
-        assert_eq!(&mmap.split_off(3)[..], &vec.split_off(3)[..]);
-        assert_eq!(&mmap[..], &vec[..]);
-        // remove 2 elements; vec length is now 1
-        assert_eq!(&mmap.split_off(1)[..], &vec.split_off(1)[..]);
-        assert_eq!(&mmap[..], &vec[..]);
-        // remove last element; vec length is now 0
-        assert_eq!(&mmap.split_off(0)[..], &vec.split_off(0)[..]);
-        assert_eq!(&mmap[..], &vec[..]);
-        // nothing left to remove, but that's okay
-        assert_eq!(&mmap.split_off(0)[..], &vec.split_off(0)[..]);
-        assert_eq!(&mmap[..], &vec[..]);
-    }
-}
diff --git a/crates/runtime/src/module_id.rs b/crates/runtime/src/module_id.rs
deleted file mode 100644
index 3c5ed7adf193..000000000000
--- a/crates/runtime/src/module_id.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-//! Unique IDs for modules in the runtime.
-
-use std::{
-    num::NonZeroU64,
-    sync::atomic::{AtomicU64, Ordering},
-};
-
-/// A unique identifier (within an engine or similar) for a compiled
-/// module.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct CompiledModuleId(NonZeroU64);
-
-/// An allocator for compiled module IDs.
-pub struct CompiledModuleIdAllocator {
-    next: AtomicU64,
-}
-
-impl CompiledModuleIdAllocator {
-    /// Create a compiled-module ID allocator.
-    pub fn new() -> Self {
-        Self {
-            next: AtomicU64::new(1),
-        }
-    }
-
-    /// Allocate a new ID.
-    pub fn alloc(&self) -> CompiledModuleId {
-        // Note: why is `Relaxed` OK here?
-        //
-        // The only requirement we have is that IDs are unique. We
-        // don't care how one module's ID compares to another, i.e.,
-        // what order they come in. `Relaxed` means that this
-        // `fetch_add` operation does not have any particular
-        // synchronization (ordering) with respect to any other memory
-        // access in the program. However, `fetch_add` is always
-        // atomic with respect to other accesses to this variable
-        // (`self.next`). So we will always hand out separate, unique
-        // IDs correctly, just in some possibly arbitrary order (which
-        // is fine).
-        let id = self.next.fetch_add(1, Ordering::Relaxed);
-        CompiledModuleId(NonZeroU64::new(id).unwrap())
-    }
-}
diff --git a/crates/runtime/src/mpk/disabled.rs b/crates/runtime/src/mpk/disabled.rs
deleted file mode 100644
index bbeccc80e893..000000000000
--- a/crates/runtime/src/mpk/disabled.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-//! Noop implementations of MPK primitives for environments that do not support
-//! the feature.
-
-#![allow(missing_docs)]
-
-use anyhow::Result;
-
-pub fn is_supported() -> bool {
-    false
-}
-pub fn keys() -> &'static [ProtectionKey] {
-    &[]
-}
-pub fn allow(_: ProtectionMask) {}
-
-#[derive(Clone, Copy, Debug)]
-pub enum ProtectionKey {}
-impl ProtectionKey {
-    pub fn protect(&self, _: &mut [u8]) -> Result<()> {
-        match *self {}
-    }
-    pub fn as_stripe(&self) -> usize {
-        match *self {}
-    }
-}
-
-#[derive(Clone, Copy, Debug)]
-pub struct ProtectionMask;
-impl ProtectionMask {
-    pub fn all() -> Self {
-        Self
-    }
-    pub fn zero() -> Self {
-        Self
-    }
-    pub fn or(self, _: ProtectionKey) -> Self {
-        Self
-    }
-}
diff --git a/crates/runtime/src/mpk/enabled.rs b/crates/runtime/src/mpk/enabled.rs
deleted file mode 100644
index 37456ef13c44..000000000000
--- a/crates/runtime/src/mpk/enabled.rs
+++ /dev/null
@@ -1,193 +0,0 @@
-//!
-
-use super::{pkru, sys};
-use anyhow::{Context, Result};
-use std::sync::OnceLock;
-
-/// Check if the MPK feature is supported.
-pub fn is_supported() -> bool {
-    cfg!(target_os = "linux") && cfg!(target_arch = "x86_64") && pkru::has_cpuid_bit_set()
-}
-
-/// Allocate all protection keys available to this process.
-///
-/// This asks the kernel for all available keys (we expect 1-15; 0 is
-/// kernel-reserved) in a thread-safe way. This avoids interference when
-/// multiple threads try to allocate keys at the same time (e.g., during
-/// testing). It also ensures that a single copy of the keys are reserved for
-/// the lifetime of the process.
-///
-/// TODO: this is not the best-possible design. This creates global state that
-/// would prevent any other code in the process from using protection keys; the
-/// `KEYS` are never deallocated from the system with `pkey_dealloc`.
-pub fn keys() -> &'static [ProtectionKey] {
-    let keys = KEYS.get_or_init(|| {
-        let mut allocated = vec![];
-        if is_supported() {
-            while let Ok(key_id) = sys::pkey_alloc(0, 0) {
-                debug_assert!(key_id < 16);
-                // UNSAFETY: here we unsafely assume that the system-allocated pkey
-                // will exist forever.
-                let pkey = ProtectionKey(key_id);
-                debug_assert_eq!(pkey.as_stripe(), allocated.len());
-                allocated.push(pkey);
-            }
-        }
-        allocated
-    });
-    &keys
-}
-static KEYS: OnceLock<Vec<ProtectionKey>> = OnceLock::new();
-
-/// Only allow access to pages marked by the keys set in `mask`.
-///
-/// Any accesses to pages marked by another key will result in a `SIGSEGV`
-/// fault.
-pub fn allow(mask: ProtectionMask) {
-    let previous = pkru::read();
-    pkru::write(mask.0);
-    log::trace!("PKRU change: {:#034b} => {:#034b}", previous, pkru::read());
-}
-
-/// An MPK protection key.
-///
-/// The expected usage is:
-/// - receive system-allocated keys from [`keys`]
-/// - mark some regions of memory as accessible with [`ProtectionKey::protect`]
-/// - [`allow`] or disallow access to the memory regions using a
-///   [`ProtectionMask`]; any accesses to unmarked pages result in a fault
-/// - drop the key
-#[derive(Clone, Copy, Debug)]
-pub struct ProtectionKey(u32);
-
-impl ProtectionKey {
-    /// Mark a page as protected by this [`ProtectionKey`].
-    ///
-    /// This "colors" the pages of `region` via a kernel `pkey_mprotect` call to
-    /// only allow reads and writes when this [`ProtectionKey`] is activated
-    /// (see [`allow`]).
-    ///
-    /// # Errors
-    ///
-    /// This will fail if the region is not page aligned or for some unknown
-    /// kernel reason.
-    pub fn protect(&self, region: &mut [u8]) -> Result<()> {
-        let addr = region.as_mut_ptr() as usize;
-        let len = region.len();
-        let prot = sys::PROT_READ | sys::PROT_WRITE;
-        sys::pkey_mprotect(addr, len, prot, self.0).with_context(|| {
-            format!(
-                "failed to mark region with pkey (addr = {addr:#x}, len = {len}, prot = {prot:#b})"
-            )
-        })
-    }
-
-    /// Convert the [`ProtectionKey`] to its 0-based index; this is useful for
-    /// determining which allocation "stripe" a key belongs to.
-    ///
-    /// This function assumes that the kernel has allocated key 0 for itself.
-    pub fn as_stripe(&self) -> usize {
-        debug_assert!(self.0 != 0);
-        self.0 as usize - 1
-    }
-}
-
-/// A bit field indicating which protection keys should be allowed and disabled.
-///
-/// The internal representation makes it easy to use [`ProtectionMask`] directly
-/// with the PKRU register. When bits `n` and `n+1` are set, it means the
-/// protection key is *not* allowed (see the PKRU write and access disabled
-/// bits).
-pub struct ProtectionMask(u32);
-impl ProtectionMask {
-    /// Allow access from all protection keys.
-    #[inline]
-    pub fn all() -> Self {
-        Self(pkru::ALLOW_ACCESS)
-    }
-
-    /// Only allow access to memory protected with protection key 0; note that
-    /// this does not mean "none" but rather allows access from the default
-    /// kernel protection key.
-    #[inline]
-    pub fn zero() -> Self {
-        Self(pkru::DISABLE_ACCESS ^ 0b11)
-    }
-
-    /// Include `pkey` as another allowed protection key in the mask.
-    #[inline]
-    pub fn or(self, pkey: ProtectionKey) -> Self {
-        let mask = pkru::DISABLE_ACCESS ^ 0b11 << (pkey.0 * 2);
-        Self(self.0 & mask)
-    }
-}
-
-/// Helper macro for skipping tests on systems that do not have MPK enabled
-/// (e.g., older architecture, disabled by kernel, etc.)
-#[cfg(test)]
-macro_rules! skip_if_mpk_unavailable {
-    () => {
-        if !crate::mpk::is_supported() {
-            println!("> mpk is not supported: ignoring test");
-            return;
-        }
-    };
-}
-/// Necessary for inter-module access.
-#[cfg(test)]
-pub(crate) use skip_if_mpk_unavailable;
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn check_is_supported() {
-        println!("is pku supported = {}", is_supported());
-    }
-
-    #[test]
-    fn check_initialized_keys() {
-        if is_supported() {
-            assert!(!keys().is_empty())
-        }
-    }
-
-    #[test]
-    fn check_invalid_mark() {
-        skip_if_mpk_unavailable!();
-        let pkey = keys()[0];
-        let unaligned_region = unsafe {
-            let addr = 1 as *mut u8; // this is not page-aligned!
-            let len = 1;
-            std::slice::from_raw_parts_mut(addr, len)
-        };
-        let result = pkey.protect(unaligned_region);
-        assert!(result.is_err());
-        assert_eq!(
-            result.unwrap_err().to_string(),
-            "failed to mark region with pkey (addr = 0x1, len = 1, prot = 0b11)"
-        );
-    }
-
-    #[test]
-    fn check_masking() {
-        skip_if_mpk_unavailable!();
-        let original = pkru::read();
-
-        allow(ProtectionMask::all());
-        assert_eq!(0, pkru::read());
-
-        allow(ProtectionMask::all().or(ProtectionKey(5)));
-        assert_eq!(0, pkru::read());
-
-        allow(ProtectionMask::zero());
-        assert_eq!(0b11111111_11111111_11111111_11111100, pkru::read());
-
-        allow(ProtectionMask::zero().or(ProtectionKey(5)));
-        assert_eq!(0b11111111_11111111_11110011_11111100, pkru::read());
-
-        // Reset the PKRU state to what we originally observed.
-        pkru::write(original);
-    }
-}
diff --git a/crates/runtime/src/mpk/mod.rs b/crates/runtime/src/mpk/mod.rs
deleted file mode 100644
index bfffe24118f7..000000000000
--- a/crates/runtime/src/mpk/mod.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-//! Memory Protection Keys (MPK) implementation for use in striped memory
-//! allocation.
-//!
-//! MPK is an x86 feature available on relatively recent versions of Intel and
-//! AMD CPUs. In Linux, this feature is named `pku` (protection keys userspace)
-//! and consists of three new system calls: `pkey_alloc`, `pkey_free`, and
-//! `pkey_mprotect` (see the [Linux documentation]). This crate provides an
-//! abstraction, [`ProtectionKey`], that the [pooling allocator] applies to
-//! contiguous memory allocations, allowing it to avoid guard pages in some
-//! cases and more efficiently use memory. This technique was first presented in
-//! a 2022 paper: [Segue and ColorGuard: Optimizing SFI Performance and
-//! Scalability on Modern x86][colorguard].
-//!
-//! [pooling allocator]: crate::PoolingInstanceAllocator
-//! [Linux documentation]:
-//!     https://www.kernel.org/doc/html/latest/core-api/protection-keys.html
-//! [colorguard]: https://plas2022.github.io/files/pdf/SegueColorGuard.pdf
-//!
-//! On x86_64 Linux systems, this module implements the various parts necessary
-//! to use MPK in Wasmtime:
-//! - [`is_supported`] indicates whether the feature is available at runtime
-//! - [`ProtectionKey`] provides access to the kernel-allocated protection keys
-//!   (see [`keys`])
-//! - [`allow`] sets the CPU state to prevent access to regions outside the
-//!   [`ProtectionMask`]
-//! - the `sys` module bridges the gap to Linux's `pkey_*` system calls
-//! - the `pkru` module controls the x86 `PKRU` register (and other CPU state)
-//!
-//! On any other kind of machine, this module exposes noop implementations of
-//! the public interface.
-
-cfg_if::cfg_if! {
-    if #[cfg(all(target_arch = "x86_64", target_os = "linux", not(miri)))] {
-        mod enabled;
-        mod pkru;
-        mod sys;
-        pub use enabled::{allow, is_supported, keys, ProtectionKey, ProtectionMask};
-    } else {
-        mod disabled;
-        pub use disabled::{allow, is_supported, keys, ProtectionKey, ProtectionMask};
-    }
-}
-
-/// Describe the tri-state configuration of memory protection keys (MPK).
-#[derive(Clone, Copy, Debug)]
-pub enum MpkEnabled {
-    /// Use MPK if supported by the current system; fall back to guard regions
-    /// otherwise.
-    Auto,
-    /// Use MPK or fail if not supported.
-    Enable,
-    /// Do not use MPK.
-    Disable,
-}
diff --git a/crates/runtime/src/mpk/pkru.rs b/crates/runtime/src/mpk/pkru.rs
deleted file mode 100644
index 99dee74fa0f7..000000000000
--- a/crates/runtime/src/mpk/pkru.rs
+++ /dev/null
@@ -1,88 +0,0 @@
-//! Control access to the x86 `PKRU` register.
-//!
-//! As documented in the Intel Software Development Manual, vol 3a, section 2.7,
-//! the 32 bits of the `PKRU` register laid out as follows (note the
-//! little-endianness):
-//!
-//! ```text
-//! ┌───┬───┬───┬───┬───┬───┐
-//! │...│AD2│WD1│AD1│WD0│AD0│
-//! └───┴───┴───┴───┴───┴───┘
-//! ```
-//!
-//! - `ADn = 1` means "access disable key `n`"--no reads or writes allowed to
-//!   pages marked with key `n`.
-//! - `WDn = 1` means "write disable key `n`"--only reads are prevented to pages
-//!   marked with key `n`
-//! - it is unclear what it means to have both `ADn` and `WDn` set
-//!
-//! Note that this only handles the user-mode `PKRU` register; there is an
-//! equivalent supervisor-mode MSR, `IA32_PKRS`.
-
-use core::arch::asm;
-
-/// This `PKRU` register mask allows access to any pages marked with any
-/// key--in other words, reading and writing is permitted to all pages.
-pub const ALLOW_ACCESS: u32 = 0;
-
-/// This `PKRU` register mask disables access to any page marked with any
-/// key--in other words, no reading or writing to all pages.
-pub const DISABLE_ACCESS: u32 = 0b11111111_11111111_11111111_11111111;
-
-/// Read the value of the `PKRU` register.
-pub fn read() -> u32 {
-    // ECX must be 0 to prevent a general protection exception (#GP).
-    let ecx: u32 = 0;
-    let pkru: u32;
-    unsafe {
-        asm!("rdpkru", in("ecx") ecx, out("eax") pkru, out("edx") _,
-            options(nomem, nostack, preserves_flags));
-    }
-    return pkru;
-}
-
-/// Write a value to the `PKRU` register.
-pub fn write(pkru: u32) {
-    // Both ECX and EDX must be 0 to prevent a general protection exception
-    // (#GP).
-    let ecx: u32 = 0;
-    let edx: u32 = 0;
-    unsafe {
-        asm!("wrpkru", in("eax") pkru, in("ecx") ecx, in("edx") edx,
-            options(nomem, nostack, preserves_flags));
-    }
-}
-
-/// Check the `ECX.PKU` flag (bit 3) of the `07h` `CPUID` leaf; see the
-/// Intel Software Development Manual, vol 3a, section 2.7.
-pub fn has_cpuid_bit_set() -> bool {
-    let result = unsafe { std::arch::x86_64::__cpuid(0x07) };
-    (result.ecx & 0b100) != 0
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::mpk::enabled::skip_if_mpk_unavailable;
-
-    #[test]
-    #[ignore = "cannot be run with other tests that munge the PKRU register"]
-    fn check_read() {
-        skip_if_mpk_unavailable!();
-        assert_eq!(read(), DISABLE_ACCESS ^ 1);
-        // By default, the Linux kernel only allows a process to access key 0,
-        // the default kernel key.
-    }
-
-    #[test]
-    fn check_roundtrip() {
-        skip_if_mpk_unavailable!();
-        let pkru = read();
-        // Allow access to pages marked with any key.
-        write(ALLOW_ACCESS);
-        assert_eq!(read(), ALLOW_ACCESS);
-        // Restore the original value.
-        write(pkru);
-        assert_eq!(read(), pkru);
-    }
-}
diff --git a/crates/runtime/src/parking_spot.rs b/crates/runtime/src/parking_spot.rs
deleted file mode 100644
index e444164f524e..000000000000
--- a/crates/runtime/src/parking_spot.rs
+++ /dev/null
@@ -1,520 +0,0 @@
-//! Implements thread wait and notify primitives with `std::sync` primitives.
-//!
-//! This is a simplified version of the `parking_lot_core` crate.
-//!
-//! There are two main operations that can be performed:
-//!
-//! - *Parking* refers to suspending the thread while simultaneously enqueuing it
-//! on a queue keyed by some address.
-//! - *Unparking* refers to dequeuing a thread from a queue keyed by some address
-//! and resuming it.
-
-#![deny(missing_docs)]
-#![deny(unsafe_code)]
-
-use crate::WaitResult;
-use std::collections::BTreeMap;
-use std::sync::{Arc, Condvar, Mutex};
-use std::time::Instant;
-
-#[derive(Default, Debug)]
-struct Spot {
-    /// The number of threads parked on this spot.
-    num_parked: u32,
-
-    /// The number of threads that have been unparked but not yet woken up.
-    /// This is used to avoid spurious wakeups.
-    to_unpark: u32,
-
-    /// The [`Condvar`] used to notify parked threads.
-    cvar: Arc<Condvar>,
-}
-
-/// The thread global `ParkingSpot`.
-#[derive(Default, Debug)]
-pub struct ParkingSpot {
-    inner: Mutex<BTreeMap<u64, Spot>>,
-}
-
-impl ParkingSpot {
-    /// Park the current thread until it is unparked or a timeout is reached.
-    ///
-    /// The `key` is used to identify the parking spot. If another thread calls
-    /// `unpark_all` or `unpark` with the same key, the current thread will be unparked.
-    ///
-    /// The `validate` callback is called before parking.
-    /// If it returns `false`, the thread is not parked and `WaitResult::Mismatch` is returned.
-    ///
-    /// The `timeout` argument specifies the maximum amount of time the thread will be parked.
-    pub fn park(
-        &self,
-        key: u64,
-        validate: impl FnOnce() -> bool,
-        timeout: impl Into<Option<Instant>>,
-    ) -> WaitResult {
-        self.park_inner(key, validate, timeout.into())
-    }
-
-    fn park_inner(
-        &self,
-        key: u64,
-        validate: impl FnOnce() -> bool,
-        timeout: Option<Instant>,
-    ) -> WaitResult {
-        let mut inner = self
-            .inner
-            .lock()
-            .expect("failed to lock inner parking table");
-
-        // check validation with lock held
-        if !validate() {
-            return WaitResult::Mismatch;
-        }
-
-        // clone the condvar, so we can move the lock
-        let cvar = {
-            let spot = inner.entry(key).or_insert_with(Spot::default);
-            spot.num_parked = spot
-                .num_parked
-                .checked_add(1)
-                .expect("parking spot number overflow");
-            spot.cvar.clone()
-        };
-
-        loop {
-            let timed_out = if let Some(timeout) = timeout {
-                let now = Instant::now();
-                if now >= timeout {
-                    true
-                } else {
-                    let dur = timeout - now;
-                    let (lock, result) = cvar
-                        .wait_timeout(inner, dur)
-                        .expect("failed to wait for condition");
-                    inner = lock;
-                    result.timed_out()
-                }
-            } else {
-                inner = cvar.wait(inner).expect("failed to wait for condition");
-                false
-            };
-
-            let spot = inner.get_mut(&key).expect("failed to get spot");
-
-            if timed_out {
-                // If waiting on the cvar timed out then due to how system cvars
-                // are implemented we may need to continue to sleep longer. If
-                // the deadline has not been reached then turn the crank again
-                // and go back to sleep.
-                if Instant::now() < timeout.unwrap() {
-                    continue;
-                }
-
-                // Opportunistically consume `to_unpark` signals even on
-                // timeout. From the perspective of `unpark` this "agent" raced
-                // between its own timeout and receiving the unpark signal, but
-                // from unpark's perspective it's definitely going to wake up N
-                // agents as returned from the `unpark` return value.
-                //
-                // Note that this may actually prevent other threads from
-                // getting unparked. For example:
-                //
-                // * Thread A parks with a timeout
-                // * Thread B parks with no timeout
-                // * Thread C decides to unpark 1 thread
-                // * Thread A's cvar wakes up due to a timeout, blocks on the
-                //   lock
-                // * Thread C finishes unpark and signals the cvar once
-                // * Thread B wakes up
-                // * Thread A and B contend for the lock and A wins
-                // * A consumes the "to_unpark" value
-                // * B goes back to sleep since `to_unpark == 0`, thinking that
-                //   a spurious wakeup happened.
-                //
-                // It's believed that this is ok, however, since from C's
-                // perspective one agent was still woken up and is allowed to
-                // continue, notably A in this case. C doesn't know that A raced
-                // with B and "stole" its wakeup signal.
-                if spot.to_unpark > 0 {
-                    spot.to_unpark -= 1;
-                }
-            } else {
-                if spot.to_unpark == 0 {
-                    // If no timeout happen but nothing has unparked this spot (as
-                    // signaled through `to_unpark`) then this is indicative of a
-                    // spurious wakeup. In this situation turn the crank again and
-                    // go back to sleep as this interface doesn't allow for spurious
-                    // wakeups.
-                    continue;
-                }
-                // No timeout happened, and some other thread registered to
-                // unpark this thread, so consume one unpark notification.
-                spot.to_unpark -= 1;
-            }
-
-            spot.num_parked = spot
-                .num_parked
-                .checked_sub(1)
-                .expect("corrupted parking spot state");
-
-            if spot.num_parked == 0 {
-                assert_eq!(spot.to_unpark, 0);
-                inner
-                    .remove(&key)
-                    .expect("failed to remove spot from inner parking table");
-            }
-
-            if timed_out {
-                return WaitResult::TimedOut;
-            }
-
-            return WaitResult::Ok;
-        }
-    }
-
-    /// Unpark at most `n` threads that are parked with the given key.
-    ///
-    /// Returns the number of threads that were actually unparked.
-    pub fn unpark(&self, key: u64, n: u32) -> u32 {
-        if n == 0 {
-            return 0;
-        }
-        let mut num_unpark = 0;
-
-        self.with_lot(key, |spot| {
-            num_unpark = n.min(spot.num_parked - spot.to_unpark);
-            spot.to_unpark += num_unpark;
-            if n >= num_unpark {
-                spot.cvar.notify_all();
-            } else {
-                for _ in 0..num_unpark {
-                    spot.cvar.notify_one();
-                }
-            }
-        });
-
-        num_unpark
-    }
-
-    fn with_lot<F: FnMut(&mut Spot)>(&self, key: u64, mut f: F) {
-        let mut inner = self
-            .inner
-            .lock()
-            .expect("failed to lock inner parking table");
-        if let Some(spot) = inner.get_mut(&key) {
-            f(spot);
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::ParkingSpot;
-    use std::ptr::addr_of;
-    use std::sync::atomic::{AtomicU64, Ordering};
-    use std::thread;
-    use std::time::{Duration, Instant};
-
-    #[test]
-    fn atomic_wait_notify() {
-        let parking_spot = &ParkingSpot::default();
-        let atomic = &AtomicU64::new(0);
-
-        thread::scope(|s| {
-            let atomic_key = addr_of!(atomic) as u64;
-            let thread1 = s.spawn(move || {
-                atomic.store(1, Ordering::SeqCst);
-                parking_spot.unpark(atomic_key, u32::MAX);
-                parking_spot.park(atomic_key, || atomic.load(Ordering::SeqCst) == 1, None);
-            });
-
-            let thread2 = s.spawn(move || {
-                while atomic.load(Ordering::SeqCst) != 1 {
-                    parking_spot.park(atomic_key, || atomic.load(Ordering::SeqCst) != 1, None);
-                }
-                atomic.store(2, Ordering::SeqCst);
-                parking_spot.unpark(atomic_key, u32::MAX);
-                parking_spot.park(atomic_key, || atomic.load(Ordering::SeqCst) == 2, None);
-            });
-
-            let thread3 = s.spawn(move || {
-                while atomic.load(Ordering::SeqCst) != 2 {
-                    parking_spot.park(atomic_key, || atomic.load(Ordering::SeqCst) != 2, None);
-                }
-                atomic.store(3, Ordering::SeqCst);
-                parking_spot.unpark(atomic_key, u32::MAX);
-
-                parking_spot.park(atomic_key, || atomic.load(Ordering::SeqCst) == 3, None);
-            });
-
-            while atomic.load(Ordering::SeqCst) != 3 {
-                parking_spot.park(atomic_key, || atomic.load(Ordering::SeqCst) != 3, None);
-            }
-            atomic.store(4, Ordering::SeqCst);
-            parking_spot.unpark(atomic_key, u32::MAX);
-
-            thread1.join().unwrap();
-            thread2.join().unwrap();
-            thread3.join().unwrap();
-        });
-    }
-
-    mod parking_lot {
-        // This is a modified version of the parking_lot_core tests,
-        // which are licensed under the MIT and Apache 2.0 licenses.
-        use super::*;
-        use std::sync::atomic::{AtomicIsize, AtomicU32};
-        use std::sync::Arc;
-        use std::time::Duration;
-
-        macro_rules! test {
-            ( $( $name:ident(
-                repeats: $repeats:expr,
-                latches: $latches:expr,
-                delay: $delay:expr,
-                threads: $threads:expr,
-                single_unparks: $single_unparks:expr);
-            )* ) => {
-                $(
-                #[test]
-                #[cfg_attr(miri, ignore)]
-                fn $name() {
-                    if std::env::var("WASMTIME_TEST_NO_HOG_MEMORY").is_ok() {
-                        return;
-                    }
-                    let delay = Duration::from_micros($delay);
-                    for _ in 0..$repeats {
-                        run_parking_test($latches, delay, $threads, $single_unparks);
-                    }
-                })*
-            };
-        }
-
-        test! {
-            unpark_all_one_fast(
-                repeats: 10000, latches: 1, delay: 0, threads: 1, single_unparks: 0
-            );
-            unpark_all_hundred_fast(
-                repeats: 100, latches: 1, delay: 0, threads: 100, single_unparks: 0
-            );
-            unpark_one_one_fast(
-                repeats: 1000, latches: 1, delay: 0, threads: 1, single_unparks: 1
-            );
-            unpark_one_hundred_fast(
-                repeats: 20, latches: 1, delay: 0, threads: 100, single_unparks: 100
-            );
-            unpark_one_fifty_then_fifty_all_fast(
-                repeats: 50, latches: 1, delay: 0, threads: 100, single_unparks: 50
-            );
-            unpark_all_one(
-                repeats: 100, latches: 1, delay: 10000, threads: 1, single_unparks: 0
-            );
-            unpark_all_hundred(
-                repeats: 100, latches: 1, delay: 10000, threads: 100, single_unparks: 0
-            );
-            unpark_one_one(
-                repeats: 10, latches: 1, delay: 10000, threads: 1, single_unparks: 1
-            );
-            unpark_one_fifty(
-                repeats: 1, latches: 1, delay: 10000, threads: 50, single_unparks: 50
-            );
-            unpark_one_fifty_then_fifty_all(
-                repeats: 2, latches: 1, delay: 10000, threads: 100, single_unparks: 50
-            );
-            hundred_unpark_all_one_fast(
-                repeats: 100, latches: 100, delay: 0, threads: 1, single_unparks: 0
-            );
-            hundred_unpark_all_one(
-                repeats: 1, latches: 100, delay: 10000, threads: 1, single_unparks: 0
-            );
-        }
-
-        fn run_parking_test(
-            num_latches: usize,
-            delay: Duration,
-            num_threads: u32,
-            num_single_unparks: u32,
-        ) {
-            let spot = ParkingSpot::default();
-
-            thread::scope(|s| {
-                let mut tests = Vec::with_capacity(num_latches);
-
-                for _ in 0..num_latches {
-                    let test = Arc::new(SingleLatchTest::new(num_threads, &spot));
-                    let mut threads = Vec::with_capacity(num_threads as _);
-                    for _ in 0..num_threads {
-                        let test = test.clone();
-                        threads.push(s.spawn(move || test.run()));
-                    }
-                    tests.push((test, threads));
-                }
-
-                for unpark_index in 0..num_single_unparks {
-                    thread::sleep(delay);
-                    for (test, _) in &tests {
-                        test.unpark_one(unpark_index);
-                    }
-                }
-
-                for (test, threads) in tests {
-                    test.finish(num_single_unparks);
-                    for thread in threads {
-                        thread.join().expect("Test thread panic");
-                    }
-                }
-            });
-        }
-
-        struct SingleLatchTest<'a> {
-            semaphore: AtomicIsize,
-            num_awake: AtomicU32,
-            /// Total number of threads participating in this test.
-            num_threads: u32,
-            spot: &'a ParkingSpot,
-        }
-
-        impl<'a> SingleLatchTest<'a> {
-            pub fn new(num_threads: u32, spot: &'a ParkingSpot) -> Self {
-                Self {
-                    // This implements a fair (FIFO) semaphore, and it starts out unavailable.
-                    semaphore: AtomicIsize::new(0),
-                    num_awake: AtomicU32::new(0),
-                    num_threads,
-                    spot,
-                }
-            }
-
-            pub fn run(&self) {
-                // Get one slot from the semaphore
-                self.down();
-
-                self.num_awake.fetch_add(1, Ordering::SeqCst);
-            }
-
-            pub fn unpark_one(&self, _single_unpark_index: u32) {
-                let num_awake_before_up = self.num_awake.load(Ordering::SeqCst);
-
-                self.up();
-
-                // Wait for a parked thread to wake up and update num_awake + last_awoken.
-                while self.num_awake.load(Ordering::SeqCst) != num_awake_before_up + 1 {
-                    thread::yield_now();
-                }
-            }
-
-            pub fn finish(&self, num_single_unparks: u32) {
-                // The amount of threads not unparked via unpark_one
-                let mut num_threads_left =
-                    self.num_threads.checked_sub(num_single_unparks).unwrap();
-
-                // Wake remaining threads up with unpark_all. Has to be in a loop, because there might
-                // still be threads that has not yet parked.
-                while num_threads_left > 0 {
-                    let mut num_waiting_on_address = 0;
-                    self.spot.with_lot(self.semaphore_addr(), |thread_data| {
-                        num_waiting_on_address = thread_data.num_parked;
-                    });
-                    assert!(num_waiting_on_address <= num_threads_left);
-
-                    let num_awake_before_unpark = self.num_awake.load(Ordering::SeqCst);
-
-                    let num_unparked = self.spot.unpark(self.semaphore_addr(), u32::MAX);
-                    assert!(num_unparked >= num_waiting_on_address);
-                    assert!(num_unparked <= num_threads_left);
-
-                    // Wait for all unparked threads to wake up and update num_awake + last_awoken.
-                    while self.num_awake.load(Ordering::SeqCst)
-                        != num_awake_before_unpark + num_unparked
-                    {
-                        thread::yield_now();
-                    }
-
-                    num_threads_left = num_threads_left.checked_sub(num_unparked).unwrap();
-                }
-                // By now, all threads should have been woken up
-                assert_eq!(self.num_awake.load(Ordering::SeqCst), self.num_threads);
-
-                // Make sure no thread is parked on our semaphore address
-                let mut num_waiting_on_address = 0;
-                self.spot.with_lot(self.semaphore_addr(), |thread_data| {
-                    num_waiting_on_address = thread_data.num_parked;
-                });
-                assert_eq!(num_waiting_on_address, 0);
-            }
-
-            pub fn down(&self) {
-                let old_semaphore_value = self.semaphore.fetch_sub(1, Ordering::SeqCst);
-
-                if old_semaphore_value > 0 {
-                    // We acquired the semaphore. Done.
-                    return;
-                }
-
-                // We need to wait.
-                let validate = || true;
-                self.spot.park(self.semaphore_addr(), validate, None);
-            }
-
-            pub fn up(&self) {
-                let old_semaphore_value = self.semaphore.fetch_add(1, Ordering::SeqCst);
-
-                // Check if anyone was waiting on the semaphore. If they were, then pass ownership to them.
-                if old_semaphore_value < 0 {
-                    // We need to continue until we have actually unparked someone. It might be that
-                    // the thread we want to pass ownership to has decremented the semaphore counter,
-                    // but not yet parked.
-                    loop {
-                        match self.spot.unpark(self.semaphore_addr(), 1) {
-                            1 => break,
-                            0 => (),
-                            i => panic!("Should not wake up {i} threads"),
-                        }
-                    }
-                }
-            }
-
-            fn semaphore_addr(&self) -> u64 {
-                addr_of!(self.semaphore) as _
-            }
-        }
-    }
-
-    #[test]
-    fn wait_with_timeout() {
-        let parking_spot = &ParkingSpot::default();
-        let atomic = &AtomicU64::new(0);
-
-        thread::scope(|s| {
-            let atomic_key = addr_of!(atomic) as u64;
-
-            const N: u64 = 5;
-            const M: u64 = if cfg!(miri) { 10 } else { 1000 };
-
-            let thread = s.spawn(move || {
-                while atomic.load(Ordering::SeqCst) != N * M {
-                    let timeout = Instant::now() + Duration::from_millis(1);
-                    parking_spot.park(
-                        atomic_key,
-                        || atomic.load(Ordering::SeqCst) != N * M,
-                        Some(timeout),
-                    );
-                }
-            });
-
-            let mut threads = vec![thread];
-            for _ in 0..N {
-                threads.push(s.spawn(move || {
-                    for _ in 0..M {
-                        atomic.fetch_add(1, Ordering::SeqCst);
-                        parking_spot.unpark(atomic_key, 1);
-                    }
-                }));
-            }
-
-            for thread in threads {
-                thread.join().unwrap();
-            }
-        });
-    }
-}
diff --git a/crates/runtime/src/send_sync_ptr.rs b/crates/runtime/src/send_sync_ptr.rs
deleted file mode 100644
index ce9d8b422ed5..000000000000
--- a/crates/runtime/src/send_sync_ptr.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-use std::fmt;
-use std::ptr::NonNull;
-
-/// A helper type in Wasmtime to store a raw pointer to `T` while automatically
-/// inferring the `Send` and `Sync` traits for the container based on the
-/// properties of `T`.
-#[repr(transparent)]
-pub struct SendSyncPtr<T: ?Sized>(NonNull<T>);
-
-unsafe impl<T: Send + ?Sized> Send for SendSyncPtr<T> {}
-unsafe impl<T: Sync + ?Sized> Sync for SendSyncPtr<T> {}
-
-impl<T: ?Sized> SendSyncPtr<T> {
-    /// Creates a new pointer wrapping the non-nullable pointer provided.
-    pub fn new(ptr: NonNull<T>) -> SendSyncPtr<T> {
-        SendSyncPtr(ptr)
-    }
-
-    /// Returns the underlying raw pointer.
-    pub fn as_ptr(&self) -> *mut T {
-        self.0.as_ptr()
-    }
-
-    /// Unsafely assert that this is a pointer to valid contents and it's also
-    /// valid to get a shared reference to it at this time.
-    pub unsafe fn as_ref<'a>(&self) -> &'a T {
-        self.0.as_ref()
-    }
-
-    /// Unsafely assert that this is a pointer to valid contents and it's also
-    /// valid to get a mutable reference to it at this time.
-    pub unsafe fn as_mut<'a>(&mut self) -> &'a mut T {
-        self.0.as_mut()
-    }
-
-    /// Returns the underlying `NonNull<T>` wrapper.
-    pub fn as_non_null(&self) -> NonNull<T> {
-        self.0
-    }
-}
-
-impl<T: ?Sized, U> From<U> for SendSyncPtr<T>
-where
-    U: Into<NonNull<T>>,
-{
-    fn from(ptr: U) -> SendSyncPtr<T> {
-        SendSyncPtr::new(ptr.into())
-    }
-}
-
-impl<T: ?Sized> fmt::Debug for SendSyncPtr<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.as_ptr().fmt(f)
-    }
-}
-
-impl<T: ?Sized> fmt::Pointer for SendSyncPtr<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.as_ptr().fmt(f)
-    }
-}
-
-impl<T: ?Sized> Clone for SendSyncPtr<T> {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-
-impl<T: ?Sized> Copy for SendSyncPtr<T> {}
-
-impl<T: ?Sized> PartialEq for SendSyncPtr<T> {
-    fn eq(&self, other: &SendSyncPtr<T>) -> bool {
-        self.0 == other.0
-    }
-}
-
-impl<T: ?Sized> Eq for SendSyncPtr<T> {}
diff --git a/crates/runtime/src/table.rs b/crates/runtime/src/table.rs
deleted file mode 100644
index a978bc8924e5..000000000000
--- a/crates/runtime/src/table.rs
+++ /dev/null
@@ -1,598 +0,0 @@
-//! Memory management for tables.
-//!
-//! `Table` is to WebAssembly tables what `LinearMemory` is to WebAssembly linear memories.
-
-use crate::vmcontext::{VMFuncRef, VMTableDefinition};
-use crate::{SendSyncPtr, Store, VMExternRef};
-use anyhow::{bail, format_err, Error, Result};
-use sptr::Strict;
-use std::convert::{TryFrom, TryInto};
-use std::ops::Range;
-use std::ptr::{self, NonNull};
-use wasmtime_environ::{
-    TablePlan, Trap, WasmHeapType, WasmRefType, FUNCREF_INIT_BIT, FUNCREF_MASK,
-};
-
-/// An element going into or coming out of a table.
-///
-/// Table elements are stored as pointers and are default-initialized with `ptr::null_mut`.
-#[derive(Clone)]
-pub enum TableElement {
-    /// A `funcref`.
-    FuncRef(*mut VMFuncRef),
-    /// An `exrernref`.
-    ExternRef(Option<VMExternRef>),
-    /// An uninitialized funcref value. This should never be exposed
-    /// beyond the `wasmtime` crate boundary; the upper-level code
-    /// (which has access to the info needed for lazy initialization)
-    /// will replace it when fetched.
-    UninitFunc,
-}
-
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
-pub enum TableElementType {
-    Func,
-    Extern,
-}
-
-// The usage of `*mut VMFuncRef` is safe w.r.t. thread safety, this
-// just relies on thread-safety of `VMExternRef` itself.
-unsafe impl Send for TableElement where VMExternRef: Send {}
-unsafe impl Sync for TableElement where VMExternRef: Sync {}
-
-impl TableElement {
-    /// Consumes the given raw table element value into a table element.
-    ///
-    /// # Safety
-    ///
-    /// This is unsafe as it will *not* clone any externref, leaving the reference count unchanged.
-    ///
-    /// This should only be used if the raw pointer is no longer in use.
-    unsafe fn from_table_value(ty: TableElementType, ptr: TableValue) -> Self {
-        match (ty, ptr) {
-            (TableElementType::Func, None) => Self::UninitFunc,
-            (TableElementType::Func, Some(ptr)) => {
-                let ptr = ptr.as_ptr();
-                let masked = Strict::map_addr(ptr, |a| a & FUNCREF_MASK);
-                Self::FuncRef(masked.cast())
-            }
-            (TableElementType::Extern, None) => Self::ExternRef(None),
-            (TableElementType::Extern, Some(ptr)) => {
-                Self::ExternRef(Some(VMExternRef::from_raw(ptr.as_ptr())))
-            }
-        }
-    }
-
-    /// Clones a table element from the underlying table element.
-    ///
-    /// # Safety
-    ///
-    /// This is unsafe as it will clone any externref, incrementing the reference count.
-    unsafe fn clone_from_table_value(ty: TableElementType, ptr: TableValue) -> Self {
-        match ty {
-            // Functions have no ownership, so defer to the prior method.
-            TableElementType::Func => TableElement::from_table_value(ty, ptr),
-
-            TableElementType::Extern => {
-                Self::ExternRef(ptr.map(|p| VMExternRef::clone_from_raw(p.as_ptr())))
-            }
-        }
-    }
-
-    /// Consumes a table element into a raw table element value. This
-    /// includes any tag bits or other storage details that we
-    /// maintain in the table slot.
-    ///
-    /// # Safety
-    ///
-    /// This is unsafe as it will consume any underlying externref into a raw pointer without modifying
-    /// the reference count.
-    ///
-    unsafe fn into_table_value(self) -> TableValue {
-        match self {
-            Self::UninitFunc => None,
-            Self::FuncRef(e) => {
-                let tagged = Strict::map_addr(e, |e| e | FUNCREF_INIT_BIT);
-                Some(NonNull::new(tagged.cast()).unwrap().into())
-            }
-            Self::ExternRef(e) => e.map(|e| NonNull::new(e.into_raw()).unwrap().into()),
-        }
-    }
-
-    /// Consumes a table element into a pointer/reference, as it
-    /// exists outside the table itself. This strips off any tag bits
-    /// or other information that only lives inside the table.
-    ///
-    /// Can only be done to an initialized table element; lazy init
-    /// must occur first. (In other words, lazy values do not survive
-    /// beyond the table, as every table read path initializes them.)
-    ///
-    /// # Safety
-    ///
-    /// The same warnings as for `into_table_values()` apply.
-    pub(crate) unsafe fn into_ref_asserting_initialized(self) -> *mut u8 {
-        match self {
-            Self::FuncRef(e) => e.cast(),
-            Self::ExternRef(e) => e.map_or(ptr::null_mut(), |e| e.into_raw()),
-            Self::UninitFunc => panic!("Uninitialized table element value outside of table slot"),
-        }
-    }
-
-    /// Indicates whether this value is the "uninitialized element"
-    /// value.
-    pub(crate) fn is_uninit(&self) -> bool {
-        match self {
-            Self::UninitFunc => true,
-            _ => false,
-        }
-    }
-}
-
-impl From<*mut VMFuncRef> for TableElement {
-    fn from(f: *mut VMFuncRef) -> TableElement {
-        TableElement::FuncRef(f)
-    }
-}
-
-impl From<Option<VMExternRef>> for TableElement {
-    fn from(x: Option<VMExternRef>) -> TableElement {
-        TableElement::ExternRef(x)
-    }
-}
-
-impl From<VMExternRef> for TableElement {
-    fn from(x: VMExternRef) -> TableElement {
-        TableElement::ExternRef(Some(x))
-    }
-}
-
-/// Represents an instance's table.
-pub enum Table {
-    /// A "static" table where storage space is managed externally, currently
-    /// used with the pooling allocator.
-    Static {
-        /// Where data for this table is stored. The length of this list is the
-        /// maximum size of the table.
-        data: &'static mut [TableValue],
-        /// The current size of the table.
-        size: u32,
-        /// The type of this table.
-        ty: TableElementType,
-    },
-    /// A "dynamic" table where table storage space is dynamically allocated via
-    /// `malloc` (aka Rust's `Vec`).
-    Dynamic {
-        /// Dynamically managed storage space for this table. The length of this
-        /// vector is the current size of the table.
-        elements: Vec<TableValue>,
-        /// The type of this table.
-        ty: TableElementType,
-        /// Maximum size that `elements` can grow to.
-        maximum: Option<u32>,
-    },
-}
-
-pub type TableValue = Option<SendSyncPtr<u8>>;
-
-fn wasm_to_table_type(ty: WasmRefType) -> Result<TableElementType> {
-    match ty.heap_type {
-        WasmHeapType::Func => Ok(TableElementType::Func),
-        WasmHeapType::Extern => Ok(TableElementType::Extern),
-        WasmHeapType::TypedFunc(_) => Ok(TableElementType::Func),
-    }
-}
-
-impl Table {
-    /// Create a new dynamic (movable) table instance for the specified table plan.
-    pub fn new_dynamic(plan: &TablePlan, store: &mut dyn Store) -> Result<Self> {
-        Self::limit_new(plan, store)?;
-        let elements = vec![None; plan.table.minimum as usize];
-        let ty = wasm_to_table_type(plan.table.wasm_ty)?;
-        let maximum = plan.table.maximum;
-
-        Ok(Table::Dynamic {
-            elements,
-            ty,
-            maximum,
-        })
-    }
-
-    /// Create a new static (immovable) table instance for the specified table plan.
-    pub fn new_static(
-        plan: &TablePlan,
-        data: &'static mut [TableValue],
-        store: &mut dyn Store,
-    ) -> Result<Self> {
-        Self::limit_new(plan, store)?;
-        let size = plan.table.minimum;
-        let ty = wasm_to_table_type(plan.table.wasm_ty)?;
-        if data.len() < (plan.table.minimum as usize) {
-            bail!(
-                "initial table size of {} exceeds the pooling allocator's \
-                 configured maximum table size of {} elements",
-                plan.table.minimum,
-                data.len(),
-            );
-        }
-        let data = match plan.table.maximum {
-            Some(max) if (max as usize) < data.len() => &mut data[..max as usize],
-            _ => data,
-        };
-
-        Ok(Table::Static { data, size, ty })
-    }
-
-    fn limit_new(plan: &TablePlan, store: &mut dyn Store) -> Result<()> {
-        if !store.table_growing(0, plan.table.minimum, plan.table.maximum)? {
-            bail!(
-                "table minimum size of {} elements exceeds table limits",
-                plan.table.minimum
-            );
-        }
-        Ok(())
-    }
-
-    /// Returns the type of the elements in this table.
-    pub fn element_type(&self) -> TableElementType {
-        match self {
-            Table::Static { ty, .. } => *ty,
-            Table::Dynamic { ty, .. } => *ty,
-        }
-    }
-
-    /// Returns whether or not the underlying storage of the table is "static".
-    #[cfg(feature = "pooling-allocator")]
-    pub(crate) fn is_static(&self) -> bool {
-        if let Table::Static { .. } = self {
-            true
-        } else {
-            false
-        }
-    }
-
-    /// Returns the number of allocated elements.
-    pub fn size(&self) -> u32 {
-        match self {
-            Table::Static { size, .. } => *size,
-            Table::Dynamic { elements, .. } => elements.len().try_into().unwrap(),
-        }
-    }
-
-    /// Returns the maximum number of elements at runtime.
-    ///
-    /// Returns `None` if the table is unbounded.
-    ///
-    /// The runtime maximum may not be equal to the maximum from the table's Wasm type
-    /// when it is being constrained by an instance allocator.
-    pub fn maximum(&self) -> Option<u32> {
-        match self {
-            Table::Static { data, .. } => Some(data.len() as u32),
-            Table::Dynamic { maximum, .. } => maximum.clone(),
-        }
-    }
-
-    /// Initializes the contents of this table to the specified function
-    pub fn init_func(&mut self, init: *mut VMFuncRef) -> Result<(), Trap> {
-        assert!(self.element_type() == TableElementType::Func);
-        for slot in self.elements_mut().iter_mut() {
-            unsafe {
-                *slot = TableElement::FuncRef(init).into_table_value();
-            }
-        }
-        Ok(())
-    }
-
-    /// Fill `table[dst..]` with values from `items`
-    ///
-    /// Returns a trap error on out-of-bounds accesses.
-    pub fn init_funcs(
-        &mut self,
-        dst: u32,
-        items: impl ExactSizeIterator<Item = *mut VMFuncRef>,
-    ) -> Result<(), Trap> {
-        assert!(self.element_type() == TableElementType::Func);
-
-        let elements = match self
-            .elements_mut()
-            .get_mut(usize::try_from(dst).unwrap()..)
-            .and_then(|s| s.get_mut(..items.len()))
-        {
-            Some(elements) => elements,
-            None => return Err(Trap::TableOutOfBounds),
-        };
-
-        for (item, slot) in items.zip(elements) {
-            unsafe {
-                *slot = TableElement::FuncRef(item).into_table_value();
-            }
-        }
-        Ok(())
-    }
-
-    /// Fill `table[dst..dst + len]` with `val`.
-    ///
-    /// Returns a trap error on out-of-bounds accesses.
-    pub fn fill(&mut self, dst: u32, val: TableElement, len: u32) -> Result<(), Trap> {
-        let start = dst as usize;
-        let end = start
-            .checked_add(len as usize)
-            .ok_or_else(|| Trap::TableOutOfBounds)?;
-
-        if end > self.size() as usize {
-            return Err(Trap::TableOutOfBounds);
-        }
-
-        debug_assert!(self.type_matches(&val));
-
-        let ty = self.element_type();
-        if let Some((last, elements)) = self.elements_mut()[start..end].split_last_mut() {
-            for e in elements {
-                Self::set_raw(ty, e, val.clone());
-            }
-
-            Self::set_raw(ty, last, val);
-        }
-
-        Ok(())
-    }
-
-    /// Grow table by the specified amount of elements.
-    ///
-    /// Returns the previous size of the table if growth is successful.
-    ///
-    /// Returns `None` if table can't be grown by the specified amount of
-    /// elements, or if the `init_value` is the wrong kind of table element.
-    ///
-    /// # Unsafety
-    ///
-    /// Resizing the table can reallocate its internal elements buffer. This
-    /// table's instance's `VMContext` has raw pointers to the elements buffer
-    /// that are used by Wasm, and they need to be fixed up before we call into
-    /// Wasm again. Failure to do so will result in use-after-free inside Wasm.
-    ///
-    /// Generally, prefer using `InstanceHandle::table_grow`, which encapsulates
-    /// this unsafety.
-    pub unsafe fn grow(
-        &mut self,
-        delta: u32,
-        init_value: TableElement,
-        store: &mut dyn Store,
-    ) -> Result<Option<u32>, Error> {
-        let old_size = self.size();
-        let new_size = match old_size.checked_add(delta) {
-            Some(s) => s,
-            None => {
-                store.table_grow_failed(format_err!("overflow calculating new table size"))?;
-                return Ok(None);
-            }
-        };
-
-        if !store.table_growing(old_size, new_size, self.maximum())? {
-            return Ok(None);
-        }
-
-        if let Some(max) = self.maximum() {
-            if new_size > max {
-                store.table_grow_failed(format_err!("Table maximum size exceeded"))?;
-                return Ok(None);
-            }
-        }
-
-        debug_assert!(self.type_matches(&init_value));
-
-        // First resize the storage and then fill with the init value
-        match self {
-            Table::Static { size, data, .. } => {
-                debug_assert!(data[*size as usize..new_size as usize]
-                    .iter()
-                    .all(|x| x.is_none()));
-                *size = new_size;
-            }
-            Table::Dynamic { elements, .. } => {
-                elements.resize(new_size as usize, None);
-            }
-        }
-
-        self.fill(old_size, init_value, delta)
-            .expect("table should not be out of bounds");
-
-        Ok(Some(old_size))
-    }
-
-    /// Get reference to the specified element.
-    ///
-    /// Returns `None` if the index is out of bounds.
-    pub fn get(&self, index: u32) -> Option<TableElement> {
-        self.elements()
-            .get(index as usize)
-            .map(|p| unsafe { TableElement::clone_from_table_value(self.element_type(), *p) })
-    }
-
-    /// Set reference to the specified element.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if `index` is out of bounds or if this table type does
-    /// not match the element type.
-    pub fn set(&mut self, index: u32, elem: TableElement) -> Result<(), ()> {
-        if !self.type_matches(&elem) {
-            return Err(());
-        }
-
-        let ty = self.element_type();
-        let e = self.elements_mut().get_mut(index as usize).ok_or(())?;
-        Self::set_raw(ty, e, elem);
-        Ok(())
-    }
-
-    /// Copy `len` elements from `src_table[src_index..]` into `dst_table[dst_index..]`.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the range is out of bounds of either the source or
-    /// destination tables.
-    pub unsafe fn copy(
-        dst_table: *mut Self,
-        src_table: *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 > (*src_table).size())
-            || dst_index
-                .checked_add(len)
-                .map_or(true, |m| m > (*dst_table).size())
-        {
-            return Err(Trap::TableOutOfBounds);
-        }
-
-        debug_assert!(
-            (*dst_table).element_type() == (*src_table).element_type(),
-            "table element type mismatch"
-        );
-
-        let src_range = src_index as usize..src_index as usize + len as usize;
-        let dst_range = dst_index as usize..dst_index as usize + len as usize;
-
-        // Check if the tables are the same as we cannot mutably borrow and also borrow the same `RefCell`
-        if ptr::eq(dst_table, src_table) {
-            (*dst_table).copy_elements_within(dst_range, src_range);
-        } else {
-            Self::copy_elements(&mut *dst_table, &*src_table, dst_range, src_range);
-        }
-
-        Ok(())
-    }
-
-    /// Return a `VMTableDefinition` for exposing the table to compiled wasm code.
-    pub fn vmtable(&mut self) -> VMTableDefinition {
-        match self {
-            Table::Static { data, size, .. } => VMTableDefinition {
-                base: data.as_mut_ptr().cast(),
-                current_elements: *size,
-            },
-            Table::Dynamic { elements, .. } => VMTableDefinition {
-                base: elements.as_mut_ptr().cast(),
-                current_elements: elements.len().try_into().unwrap(),
-            },
-        }
-    }
-
-    fn type_matches(&self, val: &TableElement) -> bool {
-        match (&val, self.element_type()) {
-            (TableElement::FuncRef(_), TableElementType::Func) => true,
-            (TableElement::ExternRef(_), TableElementType::Extern) => true,
-            _ => false,
-        }
-    }
-
-    fn elements(&self) -> &[TableValue] {
-        match self {
-            Table::Static { data, size, .. } => &data[..*size as usize],
-            Table::Dynamic { elements, .. } => &elements[..],
-        }
-    }
-
-    fn elements_mut(&mut self) -> &mut [TableValue] {
-        match self {
-            Table::Static { data, size, .. } => &mut data[..*size as usize],
-            Table::Dynamic { elements, .. } => &mut elements[..],
-        }
-    }
-
-    fn set_raw(ty: TableElementType, elem: &mut TableValue, val: TableElement) {
-        unsafe {
-            let old = *elem;
-            *elem = val.into_table_value();
-
-            // Drop the old element
-            let _ = TableElement::from_table_value(ty, old);
-        }
-    }
-
-    fn copy_elements(
-        dst_table: &mut Self,
-        src_table: &Self,
-        dst_range: Range<usize>,
-        src_range: Range<usize>,
-    ) {
-        // This can only be used when copying between different tables
-        debug_assert!(!ptr::eq(dst_table, src_table));
-
-        let ty = dst_table.element_type();
-
-        match ty {
-            TableElementType::Func => {
-                // `funcref` are `Copy`, so just do a mempcy
-                dst_table.elements_mut()[dst_range]
-                    .copy_from_slice(&src_table.elements()[src_range]);
-            }
-            TableElementType::Extern => {
-                // We need to clone each `externref`
-                let dst = dst_table.elements_mut();
-                let src = src_table.elements();
-                for (s, d) in src_range.zip(dst_range) {
-                    let elem = unsafe { TableElement::clone_from_table_value(ty, src[s]) };
-                    Self::set_raw(ty, &mut dst[d], elem);
-                }
-            }
-        }
-    }
-
-    fn copy_elements_within(&mut self, dst_range: Range<usize>, src_range: Range<usize>) {
-        let ty = self.element_type();
-        let dst = self.elements_mut();
-        match ty {
-            TableElementType::Func => {
-                // `funcref` are `Copy`, so just do a memmove
-                dst.copy_within(src_range, dst_range.start);
-            }
-            TableElementType::Extern => {
-                // We need to clone each `externref` while handling overlapping
-                // ranges
-                if dst_range.start <= src_range.start {
-                    for (s, d) in src_range.zip(dst_range) {
-                        let elem = unsafe { TableElement::clone_from_table_value(ty, dst[s]) };
-                        Self::set_raw(ty, &mut dst[d], elem);
-                    }
-                } else {
-                    for (s, d) in src_range.rev().zip(dst_range.rev()) {
-                        let elem = unsafe { TableElement::clone_from_table_value(ty, dst[s]) };
-                        Self::set_raw(ty, &mut dst[d], elem);
-                    }
-                }
-            }
-        }
-    }
-}
-
-impl Drop for Table {
-    fn drop(&mut self) {
-        let ty = self.element_type();
-
-        // funcref tables can skip this
-        if let TableElementType::Func = ty {
-            return;
-        }
-
-        // Properly drop any table elements stored in the table
-        for element in self.elements() {
-            drop(unsafe { TableElement::from_table_value(ty, *element) });
-        }
-    }
-}
-
-// The default table representation is an empty funcref table that cannot grow.
-impl Default for Table {
-    fn default() -> Self {
-        Table::Static {
-            data: &mut [],
-            size: 0,
-            ty: TableElementType::Func,
-        }
-    }
-}
diff --git a/crates/runtime/src/trampolines.rs b/crates/runtime/src/trampolines.rs
deleted file mode 100644
index 16741075cef5..000000000000
--- a/crates/runtime/src/trampolines.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-//! Wasm-to-libcall trampolines.
-
-cfg_if::cfg_if! {
-    if #[cfg(target_arch = "x86_64")] {
-        #[macro_use]
-        mod x86_64;
-    } else if #[cfg(target_arch = "aarch64")] {
-        #[macro_use]
-        mod aarch64;
-    } else if #[cfg(target_arch = "s390x")] {
-        #[macro_use]
-        mod s390x;
-    }else if #[cfg(target_arch = "riscv64")] {
-        #[macro_use]
-        mod riscv64;
-    } else {
-        compile_error!("unsupported architecture");
-    }
-}
diff --git a/crates/runtime/src/trampolines/aarch64.rs b/crates/runtime/src/trampolines/aarch64.rs
deleted file mode 100644
index 29852bad1ae1..000000000000
--- a/crates/runtime/src/trampolines/aarch64.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-#[rustfmt::skip]
-macro_rules! wasm_to_libcall_trampoline {
-    ($libcall:ident ; $libcall_impl:ident) => {
-        wasmtime_asm_macros::asm_func!(
-            wasmtime_versioned_export_macros::versioned_stringify_ident!($libcall),
-            "
-                .cfi_startproc
-                bti c
-
-                // Load the pointer to `VMRuntimeLimits` in `x9`.
-                ldur x9, [x0, #8]
-
-                // Store the last Wasm FP into the `last_wasm_exit_fp` in the limits.
-                stur fp, [x9, #24]
-
-                // Store the last Wasm PC into the `last_wasm_exit_pc` in the limits.
-                stur lr, [x9, #32]
-
-                // Tail call to the actual implementation of this libcall.
-                b {}
-
-                .cfi_endproc
-            ",
-            sym $libcall_impl
-        );
-    };
-}
-
-#[cfg(test)]
-mod wasm_to_libcall_trampoline_offsets_tests {
-    use wasmtime_environ::{Module, PtrSize, VMOffsets};
-
-    #[test]
-    fn test() {
-        let module = Module::new();
-        let offsets = VMOffsets::new(std::mem::size_of::<*mut u8>() as u8, &module);
-
-        assert_eq!(8, offsets.vmctx_runtime_limits());
-        assert_eq!(24, offsets.ptr.vmruntime_limits_last_wasm_exit_fp());
-        assert_eq!(32, offsets.ptr.vmruntime_limits_last_wasm_exit_pc());
-    }
-}
diff --git a/crates/runtime/src/trampolines/riscv64.rs b/crates/runtime/src/trampolines/riscv64.rs
deleted file mode 100644
index e3b06863b217..000000000000
--- a/crates/runtime/src/trampolines/riscv64.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-#[rustfmt::skip]
-macro_rules! wasm_to_libcall_trampoline {
-    ($libcall:ident ; $libcall_impl:ident) => {
-        wasmtime_asm_macros::asm_func!(
-            wasmtime_versioned_export_macros::versioned_stringify_ident!($libcall),
-            concat!(
-                "
-                    .cfi_startproc
-
-                    // Load the pointer to `VMRuntimeLimits` in `t0`.
-                    ld t0, 8(a0)
-
-                    // Store the last Wasm FP into the `last_wasm_exit_fp` in the limits.
-                    sd fp, 24(t0)
-
-                    // Store the last Wasm PC into the `last_wasm_exit_pc` in the limits.
-                    sd ra, 32(t0)
-
-                    // Tail call to the actual implementation of this libcall.
-                    j {}
-
-                    .cfi_endproc
-                ",
-            ),
-            sym $libcall_impl,
-        );
-    };
-}
-
-#[cfg(test)]
-mod wasm_to_libcall_trampoline_offsets_tests {
-    use wasmtime_environ::{Module, PtrSize, VMOffsets};
-
-    #[test]
-    fn test() {
-        let module = Module::new();
-        let offsets = VMOffsets::new(std::mem::size_of::<*mut u8>() as u8, &module);
-
-        assert_eq!(8, offsets.vmctx_runtime_limits());
-        assert_eq!(24, offsets.ptr.vmruntime_limits_last_wasm_exit_fp());
-        assert_eq!(32, offsets.ptr.vmruntime_limits_last_wasm_exit_pc());
-    }
-}
diff --git a/crates/runtime/src/trampolines/s390x.rs b/crates/runtime/src/trampolines/s390x.rs
deleted file mode 100644
index f8ca65ca4fc9..000000000000
--- a/crates/runtime/src/trampolines/s390x.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-// The implementation for libcall trampolines is in the s390x.S
-// file.  We provide this dummy definition of wasm_to_libcall_trampoline
-// here to make libcalls.rs compile on s390x.  Note that this means we
-// have to duplicate the list of libcalls used in the assembler file.
-
-macro_rules! wasm_to_libcall_trampoline {
-    ($libcall:ident ; $libcall_impl:ident) => {};
-}
-
-// The wasm_to_host_trampoline implementation is in the s390x.S
-// file, but we still want to have this unit test here.
-#[cfg(test)]
-mod wasm_to_libcall_trampoline_offsets_tests {
-    use wasmtime_environ::{Module, PtrSize, VMOffsets};
-
-    #[test]
-    fn test() {
-        let module = Module::new();
-        let offsets = VMOffsets::new(std::mem::size_of::<*mut u8>() as u8, &module);
-
-        assert_eq!(8, offsets.vmctx_runtime_limits());
-        assert_eq!(24, offsets.ptr.vmruntime_limits_last_wasm_exit_fp());
-        assert_eq!(32, offsets.ptr.vmruntime_limits_last_wasm_exit_pc());
-    }
-}
diff --git a/crates/runtime/src/trampolines/x86_64.rs b/crates/runtime/src/trampolines/x86_64.rs
deleted file mode 100644
index d22bcaf1a0e3..000000000000
--- a/crates/runtime/src/trampolines/x86_64.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-// Helper macros for getting the first and second arguments according to the
-// system calling convention, as well as some callee-saved scratch registers we
-// can safely use in the trampolines.
-cfg_if::cfg_if! {
-    if #[cfg(windows)] {
-        macro_rules! callee_vmctx { () => ("rcx") }
-        #[allow(unused)] macro_rules! caller_vmctx { () => ("rdx") }
-        macro_rules! scratch0 { () => ("r10") }
-        macro_rules! scratch1 { () => ("r11") }
-    } else if #[cfg(unix)] {
-        macro_rules! callee_vmctx { () => ("rdi") }
-        #[allow(unused)] macro_rules! caller_vmctx { () => ("rsi") }
-        macro_rules! scratch0 { () => ("r10") }
-        macro_rules! scratch1 { () => ("r11") }
-    } else {
-        compile_error!("platform not supported");
-    }
-}
-
-#[rustfmt::skip]
-macro_rules! wasm_to_libcall_trampoline {
-    ($libcall:ident ; $libcall_impl:ident) => {
-        wasmtime_asm_macros::asm_func!(
-            wasmtime_versioned_export_macros::versioned_stringify_ident!($libcall),
-            concat!(
-                "
-                   .cfi_startproc simple
-                   .cfi_def_cfa_offset 0
-
-                    // Load the pointer to `VMRuntimeLimits` in `", scratch0!(), "`.
-                    mov ", scratch0!(), ", 8[", callee_vmctx!(), "]
-
-                    // Store the last Wasm FP into the `last_wasm_exit_fp` in the limits.
-                    mov 24[", scratch0!(), "], rbp
-
-                    // Store the last Wasm PC into the `last_wasm_exit_pc` in the limits.
-                    mov ", scratch1!(), ", [rsp]
-                    mov 32[", scratch0!(), "], ", scratch1!(), "
-
-                    // Tail call to the actual implementation of this libcall.
-                    jmp {}
-
-                    .cfi_endproc
-                ",
-            ),
-            sym $libcall_impl
-        );
-    };
-}
-
-#[cfg(test)]
-mod wasm_to_libcall_trampoline_offsets_tests {
-    use wasmtime_environ::{Module, PtrSize, VMOffsets};
-
-    #[test]
-    fn test() {
-        let module = Module::new();
-        let offsets = VMOffsets::new(std::mem::size_of::<*mut u8>() as u8, &module);
-
-        assert_eq!(8, offsets.vmctx_runtime_limits());
-        assert_eq!(24, offsets.ptr.vmruntime_limits_last_wasm_exit_fp());
-        assert_eq!(32, offsets.ptr.vmruntime_limits_last_wasm_exit_pc());
-    }
-}
diff --git a/crates/runtime/src/traphandlers.rs b/crates/runtime/src/traphandlers.rs
deleted file mode 100644
index 21a7a519a1d1..000000000000
--- a/crates/runtime/src/traphandlers.rs
+++ /dev/null
@@ -1,815 +0,0 @@
-//! WebAssembly trap handling, which is built on top of the lower-level
-//! signalhandling mechanisms.
-
-mod backtrace;
-mod coredump;
-
-use crate::{Instance, VMContext, VMRuntimeLimits};
-use anyhow::Error;
-use std::any::Any;
-use std::cell::{Cell, UnsafeCell};
-use std::mem::MaybeUninit;
-use std::ptr;
-use std::sync::Once;
-
-pub use self::backtrace::{Backtrace, Frame};
-pub use self::coredump::CoreDumpStack;
-pub use self::tls::{tls_eager_initialize, AsyncWasmCallState, PreviousAsyncWasmCallState};
-
-cfg_if::cfg_if! {
-    if #[cfg(miri)] {
-        // With MIRI set up just enough of a setjmp/longjmp with catching panics
-        // to get a few tests working that use this.
-        //
-        // Note that no actual JIT code runs in MIRI so this is purely here for
-        // host-to-host calls.
-
-        struct WasmtimeLongjmp;
-
-        #[wasmtime_versioned_export_macros::versioned_export]
-        unsafe extern "C" fn wasmtime_setjmp(
-            _jmp_buf: *mut *const u8,
-            callback: extern "C" fn(*mut u8, *mut VMContext),
-            payload: *mut u8,
-            callee: *mut VMContext,
-        ) -> i32 {
-            use std::panic::{self, AssertUnwindSafe};
-            let result = panic::catch_unwind(AssertUnwindSafe(|| {
-                callback(payload, callee);
-            }));
-            match result {
-                Ok(()) => 1,
-                Err(e) => {
-                    if e.is::<WasmtimeLongjmp>() {
-                        0
-                    } else {
-                        panic::resume_unwind(e)
-                    }
-                }
-            }
-        }
-
-        #[wasmtime_versioned_export_macros::versioned_export]
-        unsafe extern "C" fn wasmtime_longjmp(_jmp_buf: *const u8) -> ! {
-            std::panic::panic_any(WasmtimeLongjmp)
-        }
-    } else {
-        #[link(name = "wasmtime-helpers")]
-        extern "C" {
-            #[wasmtime_versioned_export_macros::versioned_link]
-            #[allow(improper_ctypes)]
-            fn wasmtime_setjmp(
-                jmp_buf: *mut *const u8,
-                callback: extern "C" fn(*mut u8, *mut VMContext),
-                payload: *mut u8,
-                callee: *mut VMContext,
-            ) -> i32;
-            #[wasmtime_versioned_export_macros::versioned_link]
-            fn wasmtime_longjmp(jmp_buf: *const u8) -> !;
-        }
-    }
-}
-
-cfg_if::cfg_if! {
-    if #[cfg(unix)] {
-        mod unix;
-        use unix as sys;
-    } else if #[cfg(target_os = "windows")] {
-        mod windows;
-        use windows as sys;
-    }
-}
-
-#[cfg(target_os = "macos")]
-mod macos;
-
-pub use sys::SignalHandler;
-
-/// Globally-set callback to determine whether a program counter is actually a
-/// wasm trap.
-///
-/// This is initialized during `init_traps` below. The definition lives within
-/// `wasmtime` currently.
-static mut IS_WASM_PC: fn(usize) -> bool = |_| false;
-
-/// Whether or not macOS is using mach ports.
-#[cfg(target_os = "macos")]
-static mut MACOS_USE_MACH_PORTS: bool = false;
-
-/// This function is required to be called before any WebAssembly is entered.
-/// This will configure global state such as signal handlers to prepare the
-/// process to receive wasm traps.
-///
-/// This function must not only be called globally once before entering
-/// WebAssembly but it must also be called once-per-thread that enters
-/// WebAssembly. Currently in wasmtime's integration this function is called on
-/// creation of a `Engine`.
-///
-/// The `is_wasm_pc` argument is used when a trap happens to determine if a
-/// program counter is the pc of an actual wasm trap or not. This is then used
-/// to disambiguate faults that happen due to wasm and faults that happen due to
-/// bugs in Rust or elsewhere.
-pub fn init_traps(is_wasm_pc: fn(usize) -> bool, macos_use_mach_ports: bool) {
-    static INIT: Once = Once::new();
-
-    // only used on macos, so squelch warnings about this not being used on
-    // other platform.
-    let _ = macos_use_mach_ports;
-
-    INIT.call_once(|| unsafe {
-        IS_WASM_PC = is_wasm_pc;
-        #[cfg(target_os = "macos")]
-        if macos_use_mach_ports {
-            MACOS_USE_MACH_PORTS = macos_use_mach_ports;
-            return macos::platform_init();
-        }
-        sys::platform_init();
-    });
-
-    #[cfg(target_os = "macos")]
-    unsafe {
-        assert_eq!(
-            MACOS_USE_MACH_PORTS, macos_use_mach_ports,
-            "cannot configure two different methods of signal handling in the same process"
-        );
-    }
-}
-
-fn lazy_per_thread_init() {
-    #[cfg(target_os = "macos")]
-    unsafe {
-        if MACOS_USE_MACH_PORTS {
-            return macos::lazy_per_thread_init();
-        }
-    }
-
-    sys::lazy_per_thread_init();
-}
-
-/// Raises a trap immediately.
-///
-/// This function performs as-if a wasm trap was just executed. This trap
-/// payload is then returned from `catch_traps` below.
-///
-/// # Safety
-///
-/// Only safe to call when wasm code is on the stack, aka `catch_traps` must
-/// have been previously called. Additionally no Rust destructors can be on the
-/// stack. They will be skipped and not executed.
-pub unsafe fn raise_trap(reason: TrapReason) -> ! {
-    tls::with(|info| info.unwrap().unwind_with(UnwindReason::Trap(reason)))
-}
-
-/// Raises a user-defined trap immediately.
-///
-/// This function performs as-if a wasm trap was just executed, only the trap
-/// has a dynamic payload associated with it which is user-provided. This trap
-/// payload is then returned from `catch_traps` below.
-///
-/// # Safety
-///
-/// Only safe to call when wasm code is on the stack, aka `catch_traps` must
-/// have been previously called. Additionally no Rust destructors can be on the
-/// stack. They will be skipped and not executed.
-pub unsafe fn raise_user_trap(error: Error, needs_backtrace: bool) -> ! {
-    raise_trap(TrapReason::User {
-        error,
-        needs_backtrace,
-    })
-}
-
-/// Raises a trap from inside library code immediately.
-///
-/// This function performs as-if a wasm trap was just executed. This trap
-/// payload is then returned from `catch_traps` below.
-///
-/// # Safety
-///
-/// Only safe to call when wasm code is on the stack, aka `catch_traps` must
-/// have been previously called. Additionally no Rust destructors can be on the
-/// stack. They will be skipped and not executed.
-pub unsafe fn raise_lib_trap(trap: wasmtime_environ::Trap) -> ! {
-    raise_trap(TrapReason::Wasm(trap))
-}
-
-/// Carries a Rust panic across wasm code and resumes the panic on the other
-/// side.
-///
-/// # Safety
-///
-/// Only safe to call when wasm code is on the stack, aka `catch_traps` must
-/// have been previously called. Additionally no Rust destructors can be on the
-/// stack. They will be skipped and not executed.
-pub unsafe fn resume_panic(payload: Box<dyn Any + Send>) -> ! {
-    tls::with(|info| info.unwrap().unwind_with(UnwindReason::Panic(payload)))
-}
-
-/// Stores trace message with backtrace.
-#[derive(Debug)]
-pub struct Trap {
-    /// Original reason from where this trap originated.
-    pub reason: TrapReason,
-    /// Wasm backtrace of the trap, if any.
-    pub backtrace: Option<Backtrace>,
-    /// The Wasm Coredump, if any.
-    pub coredumpstack: Option<CoreDumpStack>,
-}
-
-/// Enumeration of different methods of raising a trap.
-#[derive(Debug)]
-pub enum TrapReason {
-    /// A user-raised trap through `raise_user_trap`.
-    User {
-        /// The actual user trap error.
-        error: Error,
-        /// Whether we need to capture a backtrace for this error or not.
-        needs_backtrace: bool,
-    },
-
-    /// A trap raised from Cranelift-generated code.
-    Jit {
-        /// The program counter where this trap originated.
-        ///
-        /// This is later used with side tables from compilation to translate
-        /// the trapping address to a trap code.
-        pc: usize,
-
-        /// If the trap was a memory-related trap such as SIGSEGV then this
-        /// field will contain the address of the inaccessible data.
-        ///
-        /// Note that wasm loads/stores are not guaranteed to fill in this
-        /// information. Dynamically-bounds-checked memories, for example, will
-        /// not access an invalid address but may instead load from NULL or may
-        /// explicitly jump to a `ud2` instruction. This is only available for
-        /// fault-based traps which are one of the main ways, but not the only
-        /// way, to run wasm.
-        faulting_addr: Option<usize>,
-    },
-
-    /// A trap raised from a wasm libcall
-    Wasm(wasmtime_environ::Trap),
-}
-
-impl TrapReason {
-    /// Create a new `TrapReason::User` that does not have a backtrace yet.
-    pub fn user_without_backtrace(error: Error) -> Self {
-        TrapReason::User {
-            error,
-            needs_backtrace: true,
-        }
-    }
-
-    /// Create a new `TrapReason::User` that already has a backtrace.
-    pub fn user_with_backtrace(error: Error) -> Self {
-        TrapReason::User {
-            error,
-            needs_backtrace: false,
-        }
-    }
-
-    /// Is this a JIT trap?
-    pub fn is_jit(&self) -> bool {
-        matches!(self, TrapReason::Jit { .. })
-    }
-}
-
-impl From<Error> for TrapReason {
-    fn from(err: Error) -> Self {
-        TrapReason::user_without_backtrace(err)
-    }
-}
-
-impl From<wasmtime_environ::Trap> for TrapReason {
-    fn from(code: wasmtime_environ::Trap) -> Self {
-        TrapReason::Wasm(code)
-    }
-}
-
-/// Catches any wasm traps that happen within the execution of `closure`,
-/// returning them as a `Result`.
-///
-/// Highly unsafe since `closure` won't have any dtors run.
-pub unsafe fn catch_traps<'a, F>(
-    signal_handler: Option<*const SignalHandler<'static>>,
-    capture_backtrace: bool,
-    capture_coredump: bool,
-    caller: *mut VMContext,
-    mut closure: F,
-) -> Result<(), Box<Trap>>
-where
-    F: FnMut(*mut VMContext),
-{
-    let limits = Instance::from_vmctx(caller, |i| i.runtime_limits());
-
-    let result = CallThreadState::new(signal_handler, capture_backtrace, capture_coredump, *limits)
-        .with(|cx| {
-            wasmtime_setjmp(
-                cx.jmp_buf.as_ptr(),
-                call_closure::<F>,
-                &mut closure as *mut F as *mut u8,
-                caller,
-            )
-        });
-
-    return match result {
-        Ok(x) => Ok(x),
-        Err((UnwindReason::Trap(reason), backtrace, coredumpstack)) => Err(Box::new(Trap {
-            reason,
-            backtrace,
-            coredumpstack,
-        })),
-        Err((UnwindReason::Panic(panic), _, _)) => std::panic::resume_unwind(panic),
-    };
-
-    extern "C" fn call_closure<F>(payload: *mut u8, caller: *mut VMContext)
-    where
-        F: FnMut(*mut VMContext),
-    {
-        unsafe { (*(payload as *mut F))(caller) }
-    }
-}
-
-// Module to hide visibility of the `CallThreadState::prev` field and force
-// usage of its accessor methods.
-mod call_thread_state {
-    use super::*;
-
-    /// Temporary state stored on the stack which is registered in the `tls` module
-    /// below for calls into wasm.
-    pub struct CallThreadState {
-        pub(super) unwind:
-            UnsafeCell<MaybeUninit<(UnwindReason, Option<Backtrace>, Option<CoreDumpStack>)>>,
-        pub(super) jmp_buf: Cell<*const u8>,
-        pub(super) signal_handler: Option<*const SignalHandler<'static>>,
-        pub(super) capture_backtrace: bool,
-        pub(super) capture_coredump: bool,
-
-        pub(crate) limits: *const VMRuntimeLimits,
-
-        pub(super) prev: Cell<tls::Ptr>,
-
-        // The values of `VMRuntimeLimits::last_wasm_{exit_{pc,fp},entry_sp}`
-        // for the *previous* `CallThreadState` for this same store/limits. Our
-        // *current* last wasm PC/FP/SP are saved in `self.limits`. We save a
-        // copy of the old registers here because the `VMRuntimeLimits`
-        // typically doesn't change across nested calls into Wasm (i.e. they are
-        // typically calls back into the same store and `self.limits ==
-        // self.prev.limits`) and we must to maintain the list of
-        // contiguous-Wasm-frames stack regions for backtracing purposes.
-        old_last_wasm_exit_fp: Cell<usize>,
-        old_last_wasm_exit_pc: Cell<usize>,
-        old_last_wasm_entry_sp: Cell<usize>,
-    }
-
-    impl Drop for CallThreadState {
-        fn drop(&mut self) {
-            unsafe {
-                *(*self.limits).last_wasm_exit_fp.get() = self.old_last_wasm_exit_fp.get();
-                *(*self.limits).last_wasm_exit_pc.get() = self.old_last_wasm_exit_pc.get();
-                *(*self.limits).last_wasm_entry_sp.get() = self.old_last_wasm_entry_sp.get();
-            }
-        }
-    }
-
-    impl CallThreadState {
-        #[inline]
-        pub(super) fn new(
-            signal_handler: Option<*const SignalHandler<'static>>,
-            capture_backtrace: bool,
-            capture_coredump: bool,
-            limits: *const VMRuntimeLimits,
-        ) -> CallThreadState {
-            CallThreadState {
-                unwind: UnsafeCell::new(MaybeUninit::uninit()),
-                jmp_buf: Cell::new(ptr::null()),
-                signal_handler,
-                capture_backtrace,
-                capture_coredump,
-                limits,
-                prev: Cell::new(ptr::null()),
-                old_last_wasm_exit_fp: Cell::new(unsafe { *(*limits).last_wasm_exit_fp.get() }),
-                old_last_wasm_exit_pc: Cell::new(unsafe { *(*limits).last_wasm_exit_pc.get() }),
-                old_last_wasm_entry_sp: Cell::new(unsafe { *(*limits).last_wasm_entry_sp.get() }),
-            }
-        }
-
-        /// Get the saved FP upon exit from Wasm for the previous `CallThreadState`.
-        pub fn old_last_wasm_exit_fp(&self) -> usize {
-            self.old_last_wasm_exit_fp.get()
-        }
-
-        /// Get the saved PC upon exit from Wasm for the previous `CallThreadState`.
-        pub fn old_last_wasm_exit_pc(&self) -> usize {
-            self.old_last_wasm_exit_pc.get()
-        }
-
-        /// Get the saved SP upon entry into Wasm for the previous `CallThreadState`.
-        pub fn old_last_wasm_entry_sp(&self) -> usize {
-            self.old_last_wasm_entry_sp.get()
-        }
-
-        /// Get the previous `CallThreadState`.
-        pub fn prev(&self) -> tls::Ptr {
-            self.prev.get()
-        }
-
-        pub(crate) unsafe fn push(&self) {
-            assert!(self.prev.get().is_null());
-            self.prev.set(tls::raw::replace(self));
-        }
-
-        pub(crate) unsafe fn pop(&self) {
-            let prev = self.prev.replace(ptr::null());
-            let head = tls::raw::replace(prev);
-            assert!(std::ptr::eq(head, self));
-        }
-    }
-}
-pub use call_thread_state::*;
-
-enum UnwindReason {
-    Panic(Box<dyn Any + Send>),
-    Trap(TrapReason),
-}
-
-impl CallThreadState {
-    fn with(
-        mut self,
-        closure: impl FnOnce(&CallThreadState) -> i32,
-    ) -> Result<(), (UnwindReason, Option<Backtrace>, Option<CoreDumpStack>)> {
-        let ret = tls::set(&mut self, |me| closure(me));
-        if ret != 0 {
-            Ok(())
-        } else {
-            Err(unsafe { self.read_unwind() })
-        }
-    }
-
-    #[cold]
-    unsafe fn read_unwind(&self) -> (UnwindReason, Option<Backtrace>, Option<CoreDumpStack>) {
-        (*self.unwind.get()).as_ptr().read()
-    }
-
-    fn unwind_with(&self, reason: UnwindReason) -> ! {
-        let (backtrace, coredump) = match reason {
-            // Panics don't need backtraces. There is nowhere to attach the
-            // hypothetical backtrace to and it doesn't really make sense to try
-            // in the first place since this is a Rust problem rather than a
-            // Wasm problem.
-            UnwindReason::Panic(_)
-            // And if we are just propagating an existing trap that already has
-            // a backtrace attached to it, then there is no need to capture a
-            // new backtrace either.
-            | UnwindReason::Trap(TrapReason::User {
-                needs_backtrace: false,
-                ..
-            }) => (None, None),
-            UnwindReason::Trap(_) => (self.capture_backtrace(self.limits, None), self.capture_coredump(self.limits, None)),
-        };
-        unsafe {
-            (*self.unwind.get())
-                .as_mut_ptr()
-                .write((reason, backtrace, coredump));
-            wasmtime_longjmp(self.jmp_buf.get());
-        }
-    }
-
-    /// Trap handler using our thread-local state.
-    ///
-    /// * `pc` - the program counter the trap happened at
-    /// * `call_handler` - a closure used to invoke the platform-specific
-    ///   signal handler for each instance, if available.
-    ///
-    /// Attempts to handle the trap if it's a wasm trap. Returns a few
-    /// different things:
-    ///
-    /// * null - the trap didn't look like a wasm trap and should continue as a
-    ///   trap
-    /// * 1 as a pointer - the trap was handled by a custom trap handler on an
-    ///   instance, and the trap handler should quickly return.
-    /// * a different pointer - a jmp_buf buffer to longjmp to, meaning that
-    ///   the wasm trap was succesfully handled.
-    #[cfg_attr(target_os = "macos", allow(dead_code))] // macOS is more raw and doesn't use this
-    fn take_jmp_buf_if_trap(
-        &self,
-        pc: *const u8,
-        call_handler: impl Fn(&SignalHandler) -> bool,
-    ) -> *const u8 {
-        // If we haven't even started to handle traps yet, bail out.
-        if self.jmp_buf.get().is_null() {
-            return ptr::null();
-        }
-
-        // First up see if any instance registered has a custom trap handler,
-        // in which case run them all. If anything handles the trap then we
-        // return that the trap was handled.
-        if let Some(handler) = self.signal_handler {
-            if unsafe { call_handler(&*handler) } {
-                return 1 as *const _;
-            }
-        }
-
-        // If this fault wasn't in wasm code, then it's not our problem
-        if unsafe { !IS_WASM_PC(pc as usize) } {
-            return ptr::null();
-        }
-
-        // If all that passed then this is indeed a wasm trap, so return the
-        // `jmp_buf` passed to `wasmtime_longjmp` to resume.
-        self.jmp_buf.replace(ptr::null())
-    }
-
-    fn set_jit_trap(&self, pc: *const u8, fp: usize, faulting_addr: Option<usize>) {
-        let backtrace = self.capture_backtrace(self.limits, Some((pc as usize, fp)));
-        let coredump = self.capture_coredump(self.limits, Some((pc as usize, fp)));
-        unsafe {
-            (*self.unwind.get()).as_mut_ptr().write((
-                UnwindReason::Trap(TrapReason::Jit {
-                    pc: pc as usize,
-                    faulting_addr,
-                }),
-                backtrace,
-                coredump,
-            ));
-        }
-    }
-
-    fn capture_backtrace(
-        &self,
-        limits: *const VMRuntimeLimits,
-        trap_pc_and_fp: Option<(usize, usize)>,
-    ) -> Option<Backtrace> {
-        if !self.capture_backtrace {
-            return None;
-        }
-
-        Some(unsafe { Backtrace::new_with_trap_state(limits, self, trap_pc_and_fp) })
-    }
-
-    fn capture_coredump(
-        &self,
-        limits: *const VMRuntimeLimits,
-        trap_pc_and_fp: Option<(usize, usize)>,
-    ) -> Option<CoreDumpStack> {
-        if !self.capture_coredump {
-            return None;
-        }
-        Some(CoreDumpStack::new(&self, limits, trap_pc_and_fp))
-    }
-
-    pub(crate) fn iter<'a>(&'a self) -> impl Iterator<Item = &Self> + 'a {
-        let mut state = Some(self);
-        std::iter::from_fn(move || {
-            let this = state?;
-            state = unsafe { this.prev().as_ref() };
-            Some(this)
-        })
-    }
-}
-
-struct ResetCell<'a, T: Copy>(&'a Cell<T>, T);
-
-impl<T: Copy> Drop for ResetCell<'_, T> {
-    #[inline]
-    fn drop(&mut self) {
-        self.0.set(self.1);
-    }
-}
-
-// A private inner module for managing the TLS state that we require across
-// calls in wasm. The WebAssembly code is called from C++ and then a trap may
-// happen which requires us to read some contextual state to figure out what to
-// do with the trap. This `tls` module is used to persist that information from
-// the caller to the trap site.
-mod tls {
-    use super::CallThreadState;
-    use std::mem;
-    use std::ops::Range;
-
-    pub use raw::Ptr;
-
-    // An even *more* inner module for dealing with TLS. This actually has the
-    // thread local variable and has functions to access the variable.
-    //
-    // Note that this is specially done to fully encapsulate that the accessors
-    // for tls may or may not be inlined. Wasmtime's async support employs stack
-    // switching which can resume execution on different OS threads. This means
-    // that borrows of our TLS pointer must never live across accesses because
-    // otherwise the access may be split across two threads and cause unsafety.
-    //
-    // This also means that extra care is taken by the runtime to save/restore
-    // these TLS values when the runtime may have crossed threads.
-    //
-    // Note, though, that if async support is disabled at compile time then
-    // these functions are free to be inlined.
-    pub(super) mod raw {
-        use super::CallThreadState;
-        use std::cell::Cell;
-        use std::ptr;
-
-        pub type Ptr = *const CallThreadState;
-
-        // The first entry here is the `Ptr` which is what's used as part of the
-        // public interface of this module. The second entry is a boolean which
-        // allows the runtime to perform per-thread initialization if necessary
-        // for handling traps (e.g. setting up ports on macOS and sigaltstack on
-        // Unix).
-        thread_local!(static PTR: Cell<(Ptr, bool)> = const { Cell::new((ptr::null(), false)) });
-
-        #[cfg_attr(feature = "async", inline(never))] // see module docs
-        #[cfg_attr(not(feature = "async"), inline)]
-        pub fn replace(val: Ptr) -> Ptr {
-            PTR.with(|p| {
-                // When a new value is configured that means that we may be
-                // entering WebAssembly so check to see if this thread has
-                // performed per-thread initialization for traps.
-                let (prev, initialized) = p.get();
-                if !initialized {
-                    super::super::lazy_per_thread_init();
-                }
-                p.set((val, true));
-                prev
-            })
-        }
-
-        /// Eagerly initialize thread-local runtime functionality. This will be performed
-        /// lazily by the runtime if users do not perform it eagerly.
-        #[cfg_attr(feature = "async", inline(never))] // see module docs
-        #[cfg_attr(not(feature = "async"), inline)]
-        pub fn initialize() {
-            PTR.with(|p| {
-                let (state, initialized) = p.get();
-                if initialized {
-                    return;
-                }
-                super::super::lazy_per_thread_init();
-                p.set((state, true));
-            })
-        }
-
-        #[cfg_attr(feature = "async", inline(never))] // see module docs
-        #[cfg_attr(not(feature = "async"), inline)]
-        pub fn get() -> Ptr {
-            PTR.with(|p| p.get().0)
-        }
-    }
-
-    pub use raw::initialize as tls_eager_initialize;
-
-    /// Opaque state used to persist the state of the `CallThreadState`
-    /// activations associated with a fiber stack that's used as part of an
-    /// async wasm call.
-    pub struct AsyncWasmCallState {
-        // The head of a linked list of activations that are currently present
-        // on an async call's fiber stack. This pointer points to the oldest
-        // activation frame where the `prev` links internally link to younger
-        // activation frames.
-        //
-        // When pushed onto a thread this linked list is traversed to get pushed
-        // onto the current thread at the time.
-        state: raw::Ptr,
-    }
-
-    impl AsyncWasmCallState {
-        /// Creates new state that initially starts as null.
-        pub fn new() -> AsyncWasmCallState {
-            AsyncWasmCallState {
-                state: std::ptr::null_mut(),
-            }
-        }
-
-        /// Pushes the saved state of this wasm's call onto the current thread's
-        /// state.
-        ///
-        /// This will iterate over the linked list of states stored within
-        /// `self` and push them sequentially onto the current thread's
-        /// activation list.
-        ///
-        /// The returned `PreviousAsyncWasmCallState` captures the state of this
-        /// thread just before this operation, and it must have its `restore`
-        /// method called to restore the state when the async wasm is suspended
-        /// from.
-        ///
-        /// # Unsafety
-        ///
-        /// Must be carefully coordinated with
-        /// `PreviousAsyncWasmCallState::restore` and fiber switches to ensure
-        /// that this doesn't push stale data and the data is popped
-        /// appropriately.
-        pub unsafe fn push(self) -> PreviousAsyncWasmCallState {
-            // Our `state` pointer is a linked list of oldest-to-youngest so by
-            // pushing in order of the list we restore the youngest-to-oldest
-            // list as stored in the state of this current thread.
-            let ret = PreviousAsyncWasmCallState { state: raw::get() };
-            let mut ptr = self.state;
-            while let Some(state) = ptr.as_ref() {
-                ptr = state.prev.replace(std::ptr::null_mut());
-                state.push();
-            }
-            ret
-        }
-
-        /// Performs a runtime check that this state is indeed null.
-        pub fn assert_null(&self) {
-            assert!(self.state.is_null());
-        }
-
-        /// Asserts that the current CallThreadState pointer, if present, is not
-        /// in the `range` specified.
-        ///
-        /// This is used when exiting a future in Wasmtime to assert that the
-        /// current CallThreadState pointer does not point within the stack
-        /// we're leaving (e.g.  allocated for a fiber).
-        pub fn assert_current_state_not_in_range(range: Range<usize>) {
-            let p = raw::get() as usize;
-            assert!(p < range.start || range.end < p);
-        }
-    }
-
-    /// Opaque state used to help control TLS state across stack switches for
-    /// async support.
-    pub struct PreviousAsyncWasmCallState {
-        // The head of a linked list, similar to the TLS state. Note though that
-        // this list is stored in reverse order to assist with `push` and `pop`
-        // below.
-        //
-        // After a `push` call this stores the previous head for the current
-        // thread so we know when to stop popping during a `pop`.
-        state: raw::Ptr,
-    }
-
-    impl PreviousAsyncWasmCallState {
-        /// Pops a fiber's linked list of activations and stores them in
-        /// `AsyncWasmCallState`.
-        ///
-        /// This will pop the top activation of this current thread continuously
-        /// until it reaches whatever the current activation was when `push` was
-        /// originally called.
-        ///
-        /// # Unsafety
-        ///
-        /// Must be paired with a `push` and only performed at a time when a
-        /// fiber is being suspended.
-        pub unsafe fn restore(self) -> AsyncWasmCallState {
-            let thread_head = self.state;
-            mem::forget(self);
-            let mut ret = AsyncWasmCallState::new();
-            loop {
-                // If the current TLS state is as we originally found it, then
-                // this loop is finished.
-                let ptr = raw::get();
-                if ptr == thread_head {
-                    break ret;
-                }
-
-                // Pop this activation from the current thread's TLS state, and
-                // then afterwards push it onto our own linked list within this
-                // `AsyncWasmCallState`. Note that the linked list in `AsyncWasmCallState` is stored
-                // in reverse order so a subsequent `push` later on pushes
-                // everything in the right order.
-                (*ptr).pop();
-                if let Some(state) = ret.state.as_ref() {
-                    (*ptr).prev.set(state);
-                }
-                ret.state = ptr;
-            }
-        }
-    }
-
-    impl Drop for PreviousAsyncWasmCallState {
-        fn drop(&mut self) {
-            panic!("must be consumed with `restore`");
-        }
-    }
-
-    /// Configures thread local state such that for the duration of the
-    /// execution of `closure` any call to `with` will yield `state`, unless
-    /// this is recursively called again.
-    #[inline]
-    pub fn set<R>(state: &mut CallThreadState, closure: impl FnOnce(&CallThreadState) -> R) -> R {
-        struct Reset<'a> {
-            state: &'a CallThreadState,
-        }
-
-        impl Drop for Reset<'_> {
-            #[inline]
-            fn drop(&mut self) {
-                unsafe {
-                    self.state.pop();
-                }
-            }
-        }
-
-        unsafe {
-            state.push();
-            let reset = Reset { state };
-            closure(reset.state)
-        }
-    }
-
-    /// Returns the last pointer configured with `set` above, if any.
-    pub fn with<R>(closure: impl FnOnce(Option<&CallThreadState>) -> R) -> R {
-        let p = raw::get();
-        unsafe { closure(if p.is_null() { None } else { Some(&*p) }) }
-    }
-}
diff --git a/crates/runtime/src/traphandlers/backtrace/aarch64.rs b/crates/runtime/src/traphandlers/backtrace/aarch64.rs
deleted file mode 100644
index 8c36291e37af..000000000000
--- a/crates/runtime/src/traphandlers/backtrace/aarch64.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-// The aarch64 calling conventions save the return PC one i64 above the FP and
-// the previous FP is pointed to by the current FP:
-//
-// > Each frame shall link to the frame of its caller by means of a frame record
-// > of two 64-bit values on the stack [...] The frame record for the innermost
-// > frame [...] shall be pointed to by the frame pointer register (FP). The
-// > lowest addressed double-word shall point to the previous frame record and the
-// > highest addressed double-word shall contain the value passed in LR on entry
-// > to the current function.
-//
-// - AAPCS64 section 6.2.3 The Frame Pointer[0]
-pub unsafe fn get_next_older_pc_from_fp(fp: usize) -> usize {
-    let mut pc = *(fp as *mut usize).offset(1);
-
-    // The return address might be signed, so we need to strip the highest bits
-    // (where the authentication code might be located) in order to obtain a
-    // valid address. We use the `XPACLRI` instruction, which is executed as a
-    // no-op by processors that do not support pointer authentication, so that
-    // the implementation is backward-compatible and there is no duplication.
-    // However, this instruction requires the LR register for both its input and
-    // output.
-    std::arch::asm!(
-        "mov lr, {pc}",
-        "xpaclri",
-        "mov {pc}, lr",
-        pc = inout(reg) pc,
-        out("lr") _,
-        options(nomem, nostack, preserves_flags, pure),
-    );
-
-    pc
-}
-
-// And the current frame pointer points to the next older frame pointer.
-pub const NEXT_OLDER_FP_FROM_FP_OFFSET: usize = 0;
-
-pub fn reached_entry_sp(fp: usize, entry_sp: usize) -> bool {
-    fp >= entry_sp
-}
-
-pub fn assert_entry_sp_is_aligned(sp: usize) {
-    assert_eq!(sp % 16, 0, "stack should always be aligned to 16");
-}
-
-pub fn assert_fp_is_aligned(_fp: usize) {
-    // From AAPCS64, section 6.2.3 The Frame Pointer[0]:
-    //
-    // > The location of the frame record within a stack frame is not specified.
-    //
-    // So this presumably means that the FP can have any alignment, as its
-    // location is not specified and nothing further is said about constraining
-    // alignment.
-    //
-    // [0]: https://github.com/ARM-software/abi-aa/blob/2022Q1/aapcs64/aapcs64.rst#the-frame-pointer
-}
diff --git a/crates/runtime/src/traphandlers/backtrace/riscv64.rs b/crates/runtime/src/traphandlers/backtrace/riscv64.rs
deleted file mode 100644
index bc3f5b0840d3..000000000000
--- a/crates/runtime/src/traphandlers/backtrace/riscv64.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-pub unsafe fn get_next_older_pc_from_fp(fp: usize) -> usize {
-    *(fp as *mut usize).offset(1)
-}
-
-// And the current frame pointer points to the next older frame pointer.
-pub const NEXT_OLDER_FP_FROM_FP_OFFSET: usize = 0;
-
-pub fn reached_entry_sp(fp: usize, entry_sp: usize) -> bool {
-    fp >= entry_sp
-}
-
-pub fn assert_entry_sp_is_aligned(sp: usize) {
-    assert_eq!(sp % 16, 0, "stack should always be aligned to 16");
-}
-
-pub fn assert_fp_is_aligned(fp: usize) {
-    assert_eq!(fp % 16, 0, "stack should always be aligned to 16");
-}
diff --git a/crates/runtime/src/traphandlers/backtrace/s390x.rs b/crates/runtime/src/traphandlers/backtrace/s390x.rs
deleted file mode 100644
index 7290c4850c9a..000000000000
--- a/crates/runtime/src/traphandlers/backtrace/s390x.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-pub unsafe fn get_next_older_pc_from_fp(fp: usize) -> usize {
-    // The next older PC can be found in register %r14 at function entry, which
-    // was saved into slot 14 of the register save area pointed to by "FP" (the
-    // backchain pointer).
-    *(fp as *mut usize).offset(14)
-}
-
-// The next older "FP" (backchain pointer) was saved in the slot pointed to
-// by the current "FP".
-pub const NEXT_OLDER_FP_FROM_FP_OFFSET: usize = 0;
-
-pub fn reached_entry_sp(fp: usize, entry_sp: usize) -> bool {
-    fp > entry_sp
-}
-
-pub fn assert_entry_sp_is_aligned(sp: usize) {
-    assert_eq!(sp % 8, 0, "stack should always be aligned to 8");
-}
-
-pub fn assert_fp_is_aligned(fp: usize) {
-    assert_eq!(fp % 8, 0, "stack should always be aligned to 8");
-}
diff --git a/crates/runtime/src/traphandlers/backtrace/x86_64.rs b/crates/runtime/src/traphandlers/backtrace/x86_64.rs
deleted file mode 100644
index ed1a3eb4b14b..000000000000
--- a/crates/runtime/src/traphandlers/backtrace/x86_64.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-pub unsafe fn get_next_older_pc_from_fp(fp: usize) -> usize {
-    // The calling convention always pushes the return pointer (aka the PC of
-    // the next older frame) just before this frame.
-    *(fp as *mut usize).offset(1)
-}
-
-// And the current frame pointer points to the next older frame pointer.
-pub const NEXT_OLDER_FP_FROM_FP_OFFSET: usize = 0;
-
-pub fn reached_entry_sp(fp: usize, entry_sp: usize) -> bool {
-    fp >= entry_sp
-}
-
-pub fn assert_entry_sp_is_aligned(sp: usize) {
-    assert_eq!(sp % 16, 0, "stack should always be aligned to 16");
-}
-
-pub fn assert_fp_is_aligned(fp: usize) {
-    assert_eq!(fp % 16, 0, "stack should always be aligned to 16");
-}
diff --git a/crates/runtime/src/traphandlers/coredump.rs b/crates/runtime/src/traphandlers/coredump.rs
deleted file mode 100644
index 2216d5f75ea3..000000000000
--- a/crates/runtime/src/traphandlers/coredump.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-use wasm_encoder::CoreDumpValue;
-
-use crate::{Backtrace, VMRuntimeLimits};
-
-use super::CallThreadState;
-
-/// A WebAssembly Coredump
-#[derive(Debug)]
-pub struct CoreDumpStack {
-    /// The backtrace containing the stack frames for the CoreDump
-    pub bt: Backtrace,
-
-    /// Unimplemented
-    /// The indices of the locals and operand_stack all map to each other (ie.
-    /// index 0 is the locals for the first frame in the backtrace, etc)
-    pub locals: Vec<Vec<CoreDumpValue>>,
-
-    /// Unimplemented
-    /// The operands for each stack frame
-    pub operand_stack: Vec<Vec<CoreDumpValue>>,
-}
-
-impl CoreDumpStack {
-    /// Capture a core dump of the current wasm state
-    pub fn new(
-        cts: &CallThreadState,
-        limits: *const VMRuntimeLimits,
-        trap_pc_and_fp: Option<(usize, usize)>,
-    ) -> Self {
-        let bt = unsafe { Backtrace::new_with_trap_state(limits, cts, trap_pc_and_fp) };
-
-        Self {
-            bt,
-            locals: vec![],
-            operand_stack: vec![],
-        }
-    }
-}
diff --git a/crates/runtime/src/traphandlers/macos.rs b/crates/runtime/src/traphandlers/macos.rs
deleted file mode 100644
index 493d4b5dbcaf..000000000000
--- a/crates/runtime/src/traphandlers/macos.rs
+++ /dev/null
@@ -1,486 +0,0 @@
-//! macOS-specific handling of handling exceptions
-//!
-//! Unlike other Unix platforms macOS here uses mach ports to handle exceptions
-//! instead of signals. While macOS platforms could use signals (and
-//! historically they did!) this is incompatible when Wasmtime is linked into a
-//! project that is otherwise using mach ports for catching exceptions. This
-//! came up #2456 notably when a project like Breakpad is integrated to blanket
-//! catch exceptions and report them.
-//!
-//! Mach ports are somewhat obscure and not really heavily used in a ton of
-//! places. Needless to say the original author of this file worked with mach
-//! ports for the first time when writing this file. As such the exact specifics
-//! here may not be super well documented. This file is 100% lifted from
-//! SpiderMonkey and then adapted for Wasmtime's purposes. Credit for almost
-//! all of this file goes to SpiderMonkey for figuring out all the fiddly bits.
-//! See also
-//! <https://searchfox.org/mozilla-central/source/js/src/wasm/WasmSignalHandlers.cpp>
-//! for the original code.
-//!
-//! The high-level overview is that when using mach ports a thread is blocked
-//! when it generates an exception and then a message can be read from the
-//! port. This means that, unlike signals, threads can't fix their own traps.
-//! Instead a helper thread is spun up to service exception messages. This is
-//! also in conflict with Wasmtime's exception handling currently which is to
-//! use a thread-local to store information about how to unwind. Additionally
-//! this requires that the check of whether a pc is a wasm trap or not is a
-//! global check rather than a per-thread check. This necessitates the existence
-//! of `GlobalModuleRegistry` in the `wasmtime` crate.
-//!
-//! Otherwise this file heavily uses the `mach` Rust crate for type and
-//! function declarations. Many bits and pieces are copied or translated from
-//! the SpiderMonkey implementation and it should pass all the tests!
-
-#![allow(non_snake_case)]
-
-use crate::traphandlers::{tls, wasmtime_longjmp};
-use mach::exception_types::*;
-use mach::kern_return::*;
-use mach::mach_init::*;
-use mach::mach_port::*;
-use mach::message::*;
-use mach::port::*;
-use mach::thread_act::*;
-use mach::traps::*;
-use std::mem;
-use std::thread;
-
-/// Other `mach` declarations awaiting <https://github.com/fitzgen/mach/pull/64>
-/// to be merged.
-mod mach_addons {
-    #![allow(non_camel_case_types)]
-    #![allow(non_upper_case_globals)]
-    #![allow(dead_code)]
-
-    use mach::{
-        exception_types::*, kern_return::*, mach_types::*, message::*, port::*, thread_status::*,
-    };
-    use std::mem;
-
-    #[repr(C)]
-    #[derive(Copy, Clone, Debug)]
-    #[allow(dead_code)]
-    pub struct NDR_record_t {
-        mig_vers: libc::c_uchar,
-        if_vers: libc::c_uchar,
-        reserved1: libc::c_uchar,
-        mig_encoding: libc::c_uchar,
-        int_rep: libc::c_uchar,
-        char_rep: libc::c_uchar,
-        float_rep: libc::c_uchar,
-        reserved32: libc::c_uchar,
-    }
-
-    extern "C" {
-        pub static NDR_record: NDR_record_t;
-    }
-
-    // Note that this is copied from Gecko at
-    //
-    // https://searchfox.org/mozilla-central/rev/ed93119be4818da1509bbcb7b28e245853eeedd5/js/src/wasm/WasmSignalHandlers.cpp#583-601
-    //
-    // which distinctly diverges from the actual version of this in the header
-    // files provided by macOS, notably in the `code` field which uses `i64`
-    // instead of `i32`.
-    //
-    // Also note the `packed(4)` here which forcibly decreases alignment to 4 to
-    // additionally match what mach expects (apparently, I wish I had a better
-    // reference for this).
-    #[repr(C, packed(4))]
-    #[allow(dead_code)]
-    #[derive(Copy, Clone, Debug)]
-    pub struct __Request__exception_raise_t {
-        pub Head: mach_msg_header_t,
-        /* start of the kernel processed data */
-        pub msgh_body: mach_msg_body_t,
-        pub thread: mach_msg_port_descriptor_t,
-        pub task: mach_msg_port_descriptor_t,
-        /* end of the kernel processed data */
-        pub NDR: NDR_record_t,
-        pub exception: exception_type_t,
-        pub codeCnt: mach_msg_type_number_t,
-
-        // Note that this is a divergence from the C headers which use
-        // `integer_t` here for this field which is a `c_int`. That isn't
-        // actually reflecting reality apparently though because if `c_int` is
-        // used here then the structure is too small to receive a message.
-        pub code: [i64; 2],
-    }
-
-    #[repr(C)]
-    #[allow(dead_code)]
-    #[derive(Copy, Clone, Debug)]
-    pub struct __Reply__exception_raise_t {
-        pub Head: mach_msg_header_t,
-        pub NDR: NDR_record_t,
-        pub RetCode: kern_return_t,
-    }
-
-    #[repr(C)]
-    #[derive(Copy, Clone, Debug, Default, Hash, PartialOrd, PartialEq, Eq, Ord)]
-    pub struct arm_thread_state64_t {
-        pub __x: [u64; 29],
-        pub __fp: u64, // frame pointer x29
-        pub __lr: u64, // link register x30
-        pub __sp: u64, // stack pointer x31
-        pub __pc: u64,
-        pub __cpsr: u32,
-        pub __pad: u32,
-    }
-
-    impl arm_thread_state64_t {
-        pub fn count() -> mach_msg_type_number_t {
-            (mem::size_of::<Self>() / mem::size_of::<u32>()) as mach_msg_type_number_t
-        }
-    }
-
-    pub static ARM_THREAD_STATE64: thread_state_flavor_t = 6;
-
-    #[cfg(target_arch = "x86_64")]
-    pub static THREAD_STATE_NONE: thread_state_flavor_t = 13;
-    #[cfg(target_arch = "aarch64")]
-    pub static THREAD_STATE_NONE: thread_state_flavor_t = 5;
-
-    extern "C" {
-        pub fn thread_set_state(
-            target_act: thread_port_t,
-            flavor: thread_state_flavor_t,
-            new_state: thread_state_t,
-            new_stateCnt: mach_msg_type_number_t,
-        ) -> kern_return_t;
-
-        pub fn thread_set_exception_ports(
-            thread: thread_port_t,
-            exception_mask: exception_mask_t,
-            new_port: mach_port_t,
-            behavior: libc::c_uint,
-            new_flavor: thread_state_flavor_t,
-        ) -> kern_return_t;
-    }
-}
-
-use mach_addons::*;
-
-/// Process-global port that we use to route thread-level exceptions to.
-static mut WASMTIME_PORT: mach_port_name_t = MACH_PORT_NULL;
-
-static mut CHILD_OF_FORKED_PROCESS: bool = false;
-
-pub unsafe fn platform_init() {
-    // Mach ports do not currently work across forks, so configure Wasmtime to
-    // panic in `lazy_per_thread_init` if the child attempts to invoke
-    // WebAssembly.
-    unsafe extern "C" fn child() {
-        CHILD_OF_FORKED_PROCESS = true;
-    }
-    let rc = libc::pthread_atfork(None, None, Some(child));
-    assert_eq!(rc, 0, "failed to configure `pthread_atfork` handler");
-
-    // Allocate our WASMTIME_PORT and make sure that it can be sent to so we
-    // can receive exceptions.
-    let me = mach_task_self();
-    let kret = mach_port_allocate(me, MACH_PORT_RIGHT_RECEIVE, &mut WASMTIME_PORT);
-    assert_eq!(kret, KERN_SUCCESS, "failed to allocate port");
-    let kret = mach_port_insert_right(me, WASMTIME_PORT, WASMTIME_PORT, MACH_MSG_TYPE_MAKE_SEND);
-    assert_eq!(kret, KERN_SUCCESS, "failed to insert right");
-
-    // Spin up our handler thread which will solely exist to service exceptions
-    // generated by other threads. Note that this is a background thread that
-    // we're not very interested in so it's detached here.
-    thread::spawn(|| handler_thread());
-}
-
-// This is largely just copied from SpiderMonkey.
-#[repr(C)]
-#[allow(dead_code)]
-#[derive(Debug)]
-struct ExceptionRequest {
-    body: __Request__exception_raise_t,
-    trailer: mach_msg_trailer_t,
-}
-
-unsafe fn handler_thread() {
-    // Taken from mach_exc in /usr/include/mach/mach_exc.defs.
-    const EXCEPTION_MSG_ID: mach_msg_id_t = 2405;
-
-    loop {
-        // Block this thread reading a message from our port. This will block
-        // until some thread throws an exception. Note that messages are all
-        // expected to be exceptions here.
-        let mut request: ExceptionRequest = mem::zeroed();
-        let kret = mach_msg(
-            &mut request.body.Head,
-            MACH_RCV_MSG,
-            0,
-            mem::size_of_val(&request) as u32,
-            WASMTIME_PORT,
-            MACH_MSG_TIMEOUT_NONE,
-            MACH_PORT_NULL,
-        );
-        if kret != KERN_SUCCESS {
-            eprintln!("mach_msg failed with {} ({0:x})", kret);
-            libc::abort();
-        }
-        if request.body.Head.msgh_id != EXCEPTION_MSG_ID {
-            eprintln!("unexpected msg header id {}", request.body.Head.msgh_id);
-            libc::abort();
-        }
-
-        // Attempt to handle the exception below which will process the state
-        // of the request.
-        //
-        // We unconditionally need to send a message back on our port after
-        // this exception is received, and our reply code here dictates whether
-        // the thread crashes or whether we continue execution of the thread.
-        let reply_code = if handle_exception(&mut request) {
-            KERN_SUCCESS
-        } else {
-            KERN_FAILURE
-        };
-
-        // This magic incantation to send a reply back to the kernel was
-        // derived from the exc_server generated by
-        // 'mig -v /usr/include/mach/mach_exc.defs'.
-        let mut reply: __Reply__exception_raise_t = mem::zeroed();
-        reply.Head.msgh_bits =
-            MACH_MSGH_BITS(request.body.Head.msgh_bits & MACH_MSGH_BITS_REMOTE_MASK, 0);
-        reply.Head.msgh_size = mem::size_of_val(&reply) as u32;
-        reply.Head.msgh_remote_port = request.body.Head.msgh_remote_port;
-        reply.Head.msgh_local_port = MACH_PORT_NULL;
-        reply.Head.msgh_id = request.body.Head.msgh_id + 100;
-        reply.NDR = NDR_record;
-        reply.RetCode = reply_code;
-        mach_msg(
-            &mut reply.Head,
-            MACH_SEND_MSG,
-            mem::size_of_val(&reply) as u32,
-            0,
-            MACH_PORT_NULL,
-            MACH_MSG_TIMEOUT_NONE,
-            MACH_PORT_NULL,
-        );
-    }
-}
-
-unsafe fn handle_exception(request: &mut ExceptionRequest) -> bool {
-    // First make sure that this exception is one that we actually expect to
-    // get raised by wasm code. All other exceptions we safely ignore.
-    match request.body.exception as u32 {
-        EXC_BAD_ACCESS | EXC_BAD_INSTRUCTION | EXC_ARITHMETIC => {}
-        _ => return false,
-    }
-
-    // For `EXC_BAD_ACCESS` the faulting address is listed as the "subcode" in
-    // the second `code` field. If we're ever interested in it the first code
-    // field has a `kern_return_t` describing the kind of failure (e.g. SIGSEGV
-    // vs SIGBUS), but we're not interested in that right now.
-    let (fault1, fault2) = if request.body.exception as u32 == EXC_BAD_ACCESS {
-        (1, request.body.code[1] as usize)
-    } else {
-        (0, 0)
-    };
-
-    // Depending on the current architecture various bits and pieces of this
-    // will change. This is expected to get filled out for other macos
-    // platforms as necessary.
-    //
-    // The variables this needs to define are:
-    //
-    // * `ThreadState` - a structure read via `thread_get_state` to learn about
-    //   the register state of the thread that trapped.
-    // * `thread_state_flavor` - used to read `ThreadState`
-    // * `get_pc` - a function from `&ThreadState` to a pointer to read the
-    //   current program counter, used to test if it's an address we're
-    //   catching wasm traps for.
-    // * `resume` - a function used to modify `ThreadState` to resume in the
-    //   target thread in the `unwind` function below, passing the two
-    //   parameters as the first two arguments.
-    // * `thread_state` - a fresh instance of `ThreadState` to read into
-    // * `thread_state_count` - the size to pass to `mach_msg`.
-    cfg_if::cfg_if! {
-        if #[cfg(target_arch = "x86_64")] {
-            use mach::structs::x86_thread_state64_t;
-            use mach::thread_status::x86_THREAD_STATE64;
-
-            type ThreadState = x86_thread_state64_t;
-
-            let thread_state_flavor = x86_THREAD_STATE64;
-
-            let get_pc_and_fp = |state: &ThreadState| (
-                state.__rip as *const u8,
-                state.__rbp as usize,
-            );
-
-            let resume = |state: &mut ThreadState, pc: usize, fp: usize, fault1: usize, fault2: usize| {
-                // The x86_64 ABI requires a 16-byte stack alignment for
-                // functions, so typically we'll be 16-byte aligned. In this
-                // case we simulate a `call` instruction by decrementing the
-                // stack pointer and pushing the "return" address which in this
-                // case is the faulting address. This should help the native
-                // unwinder figure out how to find the precisely trapping
-                // function.
-                //
-                // Note, however, that if the stack is not 16-byte aligned then
-                // we don't do anything. Currently this only arises due to
-                // `ud2` in the prologue of functions when performing the
-                // initial stack check. In the old backend 0 stack manipulation
-                // happens until after the stack check passes, so if the stack
-                // check fails (hence we're running in this handler) then the
-                // stack is not 16-byte aligned due to the previous return
-                // address pushed by `call`. In this scenario we just blow away
-                // the stack frame by overwriting %rip. This technically loses
-                // the precise frame that was interrupted, but that's probably
-                // not the end of the world anyway.
-                if state.__rsp % 16 == 0 {
-                    state.__rsp -= 8;
-                    *(state.__rsp as *mut u64) = state.__rip;
-                }
-                state.__rip = unwind as u64;
-                state.__rdi = pc as u64;
-                state.__rsi = fp as u64;
-                state.__rdx = fault1 as u64;
-                state.__rcx = fault2 as u64;
-            };
-            let mut thread_state = ThreadState::new();
-        } else if #[cfg(target_arch = "aarch64")] {
-            type ThreadState = arm_thread_state64_t;
-
-            let thread_state_flavor = ARM_THREAD_STATE64;
-
-            let get_pc_and_fp = |state: &ThreadState| (
-                state.__pc as *const u8,
-                state.__fp as usize,
-            );
-
-            let resume = |state: &mut ThreadState, pc: usize, fp: usize, fault1: usize, fault2: usize| {
-                // Clobber LR with the faulting PC, so unwinding resumes at the
-                // faulting instruction. The previous value of LR has been saved
-                // by the callee (in Cranelift generated code), so no need to
-                // stash it.
-                state.__lr = pc as u64;
-
-                // Fill in the argument to unwind here, and set PC to it, so
-                // it looks like a call to unwind.
-                state.__x[0] = pc as u64;
-                state.__x[1] = fp as u64;
-                state.__x[2] = fault1 as u64;
-                state.__x[3] = fault2 as u64;
-                state.__pc = unwind as u64;
-            };
-            let mut thread_state = mem::zeroed::<ThreadState>();
-        } else {
-            compile_error!("unsupported target architecture");
-        }
-    }
-
-    // First up read our origin thread's state into the area defined above.
-    let origin_thread = request.body.thread.name;
-    let mut thread_state_count = ThreadState::count();
-    let kret = thread_get_state(
-        origin_thread,
-        thread_state_flavor,
-        &mut thread_state as *mut ThreadState as *mut u32,
-        &mut thread_state_count,
-    );
-    if kret != KERN_SUCCESS {
-        return false;
-    }
-
-    // Use our global map to determine if this program counter is indeed a wasm
-    // trap, loading the `jmp_buf` to unwind to if it is.
-    //
-    // Note that this is where things are pretty tricky. We're accessing
-    // non-`Send` state (`CallThreadState`) from the exception handling thread.
-    // While typically invalid we are guaranteed that the original thread is
-    // stopped while we're accessing it here so this should be safe.
-    //
-    // Note also that we access the `state` outside the lock of `MAP`. This
-    // again is safe because if `state` is `Some` then we're guaranteed the
-    // thread is stopped and won't be removing or invalidating its state.
-    // Finally our indirection with a pointer means that we can read the
-    // pointer value and if `MAP` changes happen after we read our entry that's
-    // ok since they won't invalidate our entry.
-    let (pc, fp) = get_pc_and_fp(&thread_state);
-    if !super::IS_WASM_PC(pc as usize) {
-        return false;
-    }
-
-    // We have determined that this is a wasm trap and we need to actually
-    // force the thread itself to trap. The thread's register state is
-    // configured to resume in the `unwind` function below, we update the
-    // thread's register state, and then we're off to the races.
-    resume(&mut thread_state, pc as usize, fp, fault1, fault2);
-    let kret = thread_set_state(
-        origin_thread,
-        thread_state_flavor,
-        &mut thread_state as *mut ThreadState as *mut u32,
-        thread_state_count,
-    );
-    kret == KERN_SUCCESS
-}
-
-/// This is a "landing pad" which is never called directly but is directly
-/// resumed into from wasm-trapped threads.
-///
-/// This is a small shim which primarily serves the purpose of simply capturing
-/// a native backtrace once we've switched back to the thread itself. After
-/// the backtrace is captured we can do the usual `longjmp` back to the source
-/// of the wasm code.
-unsafe extern "C" fn unwind(
-    wasm_pc: *const u8,
-    wasm_fp: usize,
-    has_faulting_addr: usize,
-    faulting_addr: usize,
-) -> ! {
-    let jmp_buf = tls::with(|state| {
-        let state = state.unwrap();
-        let faulting_addr = if has_faulting_addr != 0 {
-            Some(faulting_addr)
-        } else {
-            None
-        };
-        state.set_jit_trap(wasm_pc, wasm_fp, faulting_addr);
-        state.jmp_buf.get()
-    });
-    debug_assert!(!jmp_buf.is_null());
-    wasmtime_longjmp(jmp_buf);
-}
-
-/// Exceptions on macOS can be delivered to either thread-level or task-level
-/// exception ports. In wasmtime we choose to send the exceptions to
-/// thread-level ports. This means that we need to, for each thread that can
-/// generate an exception, register our thread's exception port as
-/// `WASMTIME_PORT` above.
-///
-/// Note that this choice is done because at the current time if we were to
-/// implement a task-level (process-wide) port we'd have to figure out how to
-/// forward exceptions that we're not interested to the previously registered
-/// port. At this time the author isn't sure how to even do that. SpiderMonkey
-/// calls this forwarding "dark magic" as well, and since SpiderMonkey chooses
-/// thread-level ports then I hope that's good enough for wasmtime.
-///
-/// Also note that this choice of thread-level ports should be fine in that
-/// unhandled thread-level exceptions get automatically forwarded to the
-/// task-level port which is where we'd expected things like breakpad/crashpad
-/// exception handlers to get registered.
-#[cold]
-pub fn lazy_per_thread_init() {
-    unsafe {
-        assert!(
-            !CHILD_OF_FORKED_PROCESS,
-            "cannot use Wasmtime in a forked process when mach ports are \
-             configured, see `Config::macos_use_mach_ports`"
-        );
-        assert!(WASMTIME_PORT != MACH_PORT_NULL);
-        let this_thread = mach_thread_self();
-        let kret = thread_set_exception_ports(
-            this_thread,
-            EXC_MASK_BAD_ACCESS | EXC_MASK_BAD_INSTRUCTION | EXC_MASK_ARITHMETIC,
-            WASMTIME_PORT,
-            EXCEPTION_DEFAULT | MACH_EXCEPTION_CODES,
-            mach_addons::THREAD_STATE_NONE,
-        );
-        mach_port_deallocate(mach_task_self(), this_thread);
-        assert_eq!(kret, KERN_SUCCESS, "failed to set thread exception port");
-    }
-}
diff --git a/crates/runtime/src/traphandlers/unix.rs b/crates/runtime/src/traphandlers/unix.rs
deleted file mode 100644
index 613119af77c4..000000000000
--- a/crates/runtime/src/traphandlers/unix.rs
+++ /dev/null
@@ -1,402 +0,0 @@
-use crate::traphandlers::{tls, wasmtime_longjmp};
-use std::cell::RefCell;
-use std::io;
-use std::mem::{self, MaybeUninit};
-use std::ptr::{self, null_mut};
-
-/// Function which may handle custom signals while processing traps.
-pub type SignalHandler<'a> =
-    dyn Fn(libc::c_int, *const libc::siginfo_t, *const libc::c_void) -> bool + Send + Sync + 'a;
-
-static mut PREV_SIGSEGV: MaybeUninit<libc::sigaction> = MaybeUninit::uninit();
-static mut PREV_SIGBUS: MaybeUninit<libc::sigaction> = MaybeUninit::uninit();
-static mut PREV_SIGILL: MaybeUninit<libc::sigaction> = MaybeUninit::uninit();
-static mut PREV_SIGFPE: MaybeUninit<libc::sigaction> = MaybeUninit::uninit();
-
-pub unsafe fn platform_init() {
-    if cfg!(miri) {
-        return;
-    }
-    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...
-        //
-        // SA_SIGINFO gives us access to information like the program
-        // counter from where the fault happened.
-        //
-        // SA_ONSTACK allows us to handle signals on an alternate stack,
-        // so that the handler can run in response to running out of
-        // stack space on the main stack. Rust installs an alternate
-        // stack with sigaltstack, so we rely on that.
-        //
-        // SA_NODEFER allows us to reenter the signal handler if we
-        // 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;
-        libc::sigemptyset(&mut handler.sa_mask);
-        if libc::sigaction(signal, &handler, slot.as_mut_ptr()) != 0 {
-            panic!(
-                "unable to install signal handler: {}",
-                io::Error::last_os_error(),
-            );
-        }
-    };
-
-    // Allow handling OOB with signals on all architectures
-    register(&mut PREV_SIGSEGV, libc::SIGSEGV);
-
-    // Handle `unreachable` instructions which execute `ud2` right now
-    register(&mut PREV_SIGILL, libc::SIGILL);
-
-    // x86 and s390x use SIGFPE to report division by zero
-    if cfg!(target_arch = "x86_64") || cfg!(target_arch = "s390x") {
-        register(&mut PREV_SIGFPE, libc::SIGFPE);
-    }
-
-    // Sometimes we need to handle SIGBUS too:
-    // - On Darwin, guard page accesses are raised as SIGBUS.
-    if cfg!(target_os = "macos") || cfg!(target_os = "freebsd") {
-        register(&mut PREV_SIGBUS, libc::SIGBUS);
-    }
-
-    // TODO(#1980): x86-32, if we support it, will also need a SIGFPE handler.
-    // TODO(#1173): ARM32, if we support it, will also need a SIGBUS handler.
-}
-
-unsafe extern "C" fn trap_handler(
-    signum: libc::c_int,
-    siginfo: *mut libc::siginfo_t,
-    context: *mut libc::c_void,
-) {
-    let previous = match signum {
-        libc::SIGSEGV => &PREV_SIGSEGV,
-        libc::SIGBUS => &PREV_SIGBUS,
-        libc::SIGFPE => &PREV_SIGFPE,
-        libc::SIGILL => &PREV_SIGILL,
-        _ => panic!("unknown signal: {}", signum),
-    };
-    let handled = tls::with(|info| {
-        // If no wasm code is executing, we don't handle this as a wasm
-        // trap.
-        let info = match info {
-            Some(info) => info,
-            None => return false,
-        };
-
-        // If we hit an exception while handling a previous trap, that's
-        // quite bad, so bail out and let the system handle this
-        // recursive segfault.
-        //
-        // Otherwise flag ourselves as handling a trap, do the trap
-        // handling, and reset our trap handling flag. Then we figure
-        // out what to do based on the result of the trap handling.
-        let (pc, fp) = get_pc_and_fp(context, signum);
-        let jmp_buf = info.take_jmp_buf_if_trap(pc, |handler| handler(signum, siginfo, context));
-
-        // Figure out what to do based on the result of this handling of
-        // the trap. Note that our sentinel value of 1 means that the
-        // exception was handled by a custom exception handler, so we
-        // keep executing.
-        if jmp_buf.is_null() {
-            return false;
-        }
-        if jmp_buf as usize == 1 {
-            return true;
-        }
-        let faulting_addr = match signum {
-            libc::SIGSEGV | libc::SIGBUS => Some((*siginfo).si_addr() as usize),
-            _ => None,
-        };
-        info.set_jit_trap(pc, fp, faulting_addr);
-        // On macOS this is a bit special, unfortunately. If we were to
-        // `siglongjmp` out of the signal handler that notably does
-        // *not* reset the sigaltstack state of our signal handler. This
-        // seems to trick the kernel into thinking that the sigaltstack
-        // is still in use upon delivery of the next signal, meaning
-        // that the sigaltstack is not ever used again if we immediately
-        // call `wasmtime_longjmp` here.
-        //
-        // Note that if we use `longjmp` instead of `siglongjmp` then
-        // the problem is fixed. The problem with that, however, is that
-        // `setjmp` is much slower than `sigsetjmp` due to the
-        // preservation of the proceses signal mask. The reason
-        // `longjmp` appears to work is that it seems to call a function
-        // (according to published macOS sources) called
-        // `_sigunaltstack` which updates the kernel to say the
-        // sigaltstack is no longer in use. We ideally want to call that
-        // here but I don't think there's a stable way for us to call
-        // that.
-        //
-        // Given all that, on macOS only, we do the next best thing. We
-        // return from the signal handler after updating the register
-        // context. This will cause control to return to our shim
-        // function defined here which will perform the
-        // `wasmtime_longjmp` (`siglongjmp`) for us. The reason this
-        // works is that by returning from the signal handler we'll
-        // trigger all the normal machinery for "the signal handler is
-        // done running" which will clear the sigaltstack flag and allow
-        // reusing it for the next signal. Then upon resuming in our custom
-        // code we blow away the stack anyway with a longjmp.
-        if cfg!(target_os = "macos") {
-            unsafe extern "C" fn wasmtime_longjmp_shim(jmp_buf: *const u8) {
-                wasmtime_longjmp(jmp_buf)
-            }
-            set_pc(context, wasmtime_longjmp_shim as usize, jmp_buf as usize);
-            return true;
-        }
-        wasmtime_longjmp(jmp_buf)
-    });
-
-    if handled {
-        return;
-    }
-
-    // This signal is not for any compiled wasm code we expect, so we
-    // need to forward the signal to the next handler. If there is no
-    // next handler (SIG_IGN or SIG_DFL), then it's time to crash. To do
-    // this, we set the signal back to its original disposition and
-    // return. This will cause the faulting op to be re-executed which
-    // will crash in the normal way. If there is a next handler, call
-    // it. It will either crash synchronously, fix up the instruction
-    // so that execution can continue and return, or trigger a crash by
-    // returning the signal to it's original disposition and returning.
-    let previous = &*previous.as_ptr();
-    if previous.sa_flags & libc::SA_SIGINFO != 0 {
-        mem::transmute::<usize, extern "C" fn(libc::c_int, *mut libc::siginfo_t, *mut libc::c_void)>(
-            previous.sa_sigaction,
-        )(signum, siginfo, context)
-    } else if previous.sa_sigaction == libc::SIG_DFL || previous.sa_sigaction == libc::SIG_IGN {
-        libc::sigaction(signum, previous, ptr::null_mut());
-    } else {
-        mem::transmute::<usize, extern "C" fn(libc::c_int)>(previous.sa_sigaction)(signum)
-    }
-}
-
-// FIXME(rust-lang/libc#3312) the currenty definition of `ucontext_t` in the
-// `libc` crate is incorrect on aarch64-apple-drawin so it's defined here with a
-// more accurate definition. When that PR and/or issue is resolved then this
-// should no longer be necessary.
-#[repr(C)]
-#[cfg(all(target_arch = "aarch64", target_os = "macos"))]
-struct ucontext_t {
-    uc_onstack: libc::c_int,
-    uc_sigmask: libc::sigset_t,
-    uc_stack: libc::stack_t,
-    uc_link: *mut libc::ucontext_t,
-    uc_mcsize: usize,
-    uc_mcontext: libc::mcontext_t,
-}
-
-unsafe fn get_pc_and_fp(cx: *mut libc::c_void, _signum: libc::c_int) -> (*const u8, usize) {
-    cfg_if::cfg_if! {
-        if #[cfg(all(any(target_os = "linux", target_os = "android"), target_arch = "x86_64"))] {
-            let cx = &*(cx as *const libc::ucontext_t);
-            (
-                cx.uc_mcontext.gregs[libc::REG_RIP as usize] as *const u8,
-                cx.uc_mcontext.gregs[libc::REG_RBP as usize] as usize
-            )
-        } else if #[cfg(all(any(target_os = "linux", target_os = "android"), target_arch = "aarch64"))] {
-            let cx = &*(cx as *const libc::ucontext_t);
-            (
-                cx.uc_mcontext.pc as *const u8,
-                cx.uc_mcontext.regs[29] as usize,
-            )
-        } else if #[cfg(all(target_os = "linux", target_arch = "s390x"))] {
-            // On s390x, SIGILL and SIGFPE are delivered with the PSW address
-            // pointing *after* the faulting instruction, while SIGSEGV and
-            // SIGBUS are delivered with the PSW address pointing *to* the
-            // faulting instruction.  To handle this, the code generator registers
-            // any trap that results in one of "late" signals on the last byte
-            // of the instruction, and any trap that results in one of the "early"
-            // signals on the first byte of the instruction (as usual).  This
-            // means we simply need to decrement the reported PSW address by
-            // one in the case of a "late" signal here to ensure we always
-            // correctly find the associated trap handler.
-            let trap_offset = match _signum {
-                libc::SIGILL | libc::SIGFPE => 1,
-                _ => 0,
-            };
-            let cx = &*(cx as *const libc::ucontext_t);
-            (
-                (cx.uc_mcontext.psw.addr - trap_offset) as *const u8,
-                *(cx.uc_mcontext.gregs[15] as *const usize),
-            )
-        } else if #[cfg(all(target_os = "macos", target_arch = "x86_64"))] {
-            let cx = &*(cx as *const libc::ucontext_t);
-            (
-                (*cx.uc_mcontext).__ss.__rip as *const u8,
-                (*cx.uc_mcontext).__ss.__rbp as usize,
-            )
-        } else if #[cfg(all(target_os = "macos", target_arch = "aarch64"))] {
-            let cx = &*(cx as *const ucontext_t);
-            (
-                (*cx.uc_mcontext).__ss.__pc as *const u8,
-                (*cx.uc_mcontext).__ss.__fp as usize,
-            )
-        } else if #[cfg(all(target_os = "freebsd", target_arch = "x86_64"))] {
-            let cx = &*(cx as *const libc::ucontext_t);
-            (
-                cx.uc_mcontext.mc_rip as *const u8,
-                cx.uc_mcontext.mc_rbp as usize,
-            )
-        } else if #[cfg(all(target_os = "linux", target_arch = "riscv64"))] {
-            let cx = &*(cx as *const libc::ucontext_t);
-            (
-                cx.uc_mcontext.__gregs[libc::REG_PC] as *const u8,
-                cx.uc_mcontext.__gregs[libc::REG_S0] as usize,
-            )
-        } else if #[cfg(all(target_os = "freebsd", target_arch = "aarch64"))] {
-            let cx = &*(cx as *const libc::mcontext_t);
-            (
-                cx.mc_gpregs.gp_elr as *const u8,
-                cx.mc_gpregs.gp_x[29] as usize,
-            )
-        }
-        else {
-            compile_error!("unsupported platform");
-        }
-    }
-}
-
-// This is only used on macOS targets for calling an unwinding shim
-// function to ensure that we return from the signal handler.
-//
-// See more comments above where this is called for what it's doing.
-unsafe fn set_pc(cx: *mut libc::c_void, pc: usize, arg1: usize) {
-    cfg_if::cfg_if! {
-        if #[cfg(not(target_os = "macos"))] {
-            let _ = (cx, pc, arg1);
-            unreachable!(); // not used on these platforms
-        } else if #[cfg(target_arch = "x86_64")] {
-            let cx = &mut *(cx as *mut libc::ucontext_t);
-            (*cx.uc_mcontext).__ss.__rip = pc as u64;
-            (*cx.uc_mcontext).__ss.__rdi = arg1 as u64;
-            // We're simulating a "pseudo-call" so we need to ensure
-            // stack alignment is properly respected, notably that on a
-            // `call` instruction the stack is 8/16-byte aligned, then
-            // the function adjusts itself to be 16-byte aligned.
-            //
-            // Most of the time the stack pointer is 16-byte aligned at
-            // the time of the trap but for more robust-ness with JIT
-            // code where it may ud2 in a prologue check before the
-            // stack is aligned we double-check here.
-            if (*cx.uc_mcontext).__ss.__rsp % 16 == 0 {
-                (*cx.uc_mcontext).__ss.__rsp -= 8;
-            }
-        } else if #[cfg(target_arch = "aarch64")] {
-            let cx = &mut *(cx as *mut ucontext_t);
-            (*cx.uc_mcontext).__ss.__pc = pc as u64;
-            (*cx.uc_mcontext).__ss.__x[0] = arg1 as u64;
-        } else {
-            compile_error!("unsupported macos target architecture");
-        }
-    }
-}
-
-/// A function for registering a custom alternate signal stack (sigaltstack).
-///
-/// Rust's libstd installs an alternate stack with size `SIGSTKSZ`, which is not
-/// always large enough for our signal handling code. Override it by creating
-/// and registering our own alternate stack that is large enough and has a guard
-/// page.
-#[cold]
-pub fn lazy_per_thread_init() {
-    // This thread local is purely used to register a `Stack` to get deallocated
-    // when the thread exists. Otherwise this function is only ever called at
-    // most once per-thread.
-    thread_local! {
-        static STACK: RefCell<Option<Stack>> = const { RefCell::new(None) };
-    }
-
-    /// The size of the sigaltstack (not including the guard, which will be
-    /// added). Make this large enough to run our signal handlers.
-    ///
-    /// The main current requirement of the signal handler in terms of stack
-    /// space is that `malloc`/`realloc` are called to create a `Backtrace` of
-    /// wasm frames.
-    ///
-    /// Historically this was 16k. Turns out jemalloc requires more than 16k of
-    /// stack space in debug mode, so this was bumped to 64k.
-    const MIN_STACK_SIZE: usize = 64 * 4096;
-
-    struct Stack {
-        mmap_ptr: *mut libc::c_void,
-        mmap_size: usize,
-    }
-
-    return STACK.with(|s| {
-        *s.borrow_mut() = unsafe { allocate_sigaltstack() };
-    });
-
-    unsafe fn allocate_sigaltstack() -> Option<Stack> {
-        if cfg!(miri) {
-            return None;
-        }
-
-        // 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: {}",
-            io::Error::last_os_error()
-        );
-        if old_stack.ss_flags & libc::SS_DISABLE == 0 && old_stack.ss_size >= MIN_STACK_SIZE {
-            return None;
-        }
-
-        // ... but failing that we need to allocate our own, so do all that
-        // here.
-        let page_size = crate::page_size();
-        let guard_size = page_size;
-        let alloc_size = guard_size + MIN_STACK_SIZE;
-
-        let ptr = rustix::mm::mmap_anonymous(
-            null_mut(),
-            alloc_size,
-            rustix::mm::ProtFlags::empty(),
-            rustix::mm::MapFlags::PRIVATE,
-        )
-        .expect("failed to allocate memory for sigaltstack");
-
-        // Prepare the stack with readable/writable memory and then register it
-        // with `sigaltstack`.
-        let stack_ptr = (ptr as usize + guard_size) as *mut std::ffi::c_void;
-        rustix::mm::mprotect(
-            stack_ptr,
-            MIN_STACK_SIZE,
-            rustix::mm::MprotectFlags::READ | rustix::mm::MprotectFlags::WRITE,
-        )
-        .expect("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: {}",
-            io::Error::last_os_error()
-        );
-
-        Some(Stack {
-            mmap_ptr: ptr,
-            mmap_size: alloc_size,
-        })
-    }
-
-    impl Drop for Stack {
-        fn drop(&mut self) {
-            unsafe {
-                // Deallocate the stack memory.
-                let r = rustix::mm::munmap(self.mmap_ptr, self.mmap_size);
-                debug_assert!(r.is_ok(), "munmap failed during thread shutdown");
-            }
-        }
-    }
-}
diff --git a/crates/runtime/src/traphandlers/windows.rs b/crates/runtime/src/traphandlers/windows.rs
deleted file mode 100644
index 5ad7295f5e3c..000000000000
--- a/crates/runtime/src/traphandlers/windows.rs
+++ /dev/null
@@ -1,89 +0,0 @@
-use crate::traphandlers::{tls, wasmtime_longjmp};
-use std::io;
-use windows_sys::Win32::Foundation::*;
-use windows_sys::Win32::System::Diagnostics::Debug::*;
-use windows_sys::Win32::System::Kernel::*;
-
-/// Function which may handle custom signals while processing traps.
-pub type SignalHandler<'a> = dyn Fn(*mut EXCEPTION_POINTERS) -> bool + Send + Sync + 'a;
-
-pub 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 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_INT_DIVIDE_BY_ZERO
-        && record.ExceptionCode != EXCEPTION_INT_OVERFLOW
-    {
-        return ExceptionContinueSearch;
-    }
-
-    // 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 ExceptionContinueSearch;
-    // }
-
-    // This is basically the same as the unix version above, only with a
-    // few parameters tweaked here and there.
-    tls::with(|info| {
-        let info = match info {
-            Some(info) => info,
-            None => return ExceptionContinueSearch,
-        };
-        cfg_if::cfg_if! {
-            if #[cfg(target_arch = "x86_64")] {
-                let ip = (*(*exception_info).ContextRecord).Rip as *const u8;
-                let fp = (*(*exception_info).ContextRecord).Rbp as usize;
-            } else if #[cfg(target_arch = "aarch64")] {
-                let ip = (*(*exception_info).ContextRecord).Pc as *const u8;
-                let fp = (*(*exception_info).ContextRecord).Anonymous.Anonymous.Fp as usize;
-            } else {
-                compile_error!("unsupported platform");
-            }
-        }
-        // For access violations the first element in `ExceptionInformation` is
-        // an indicator as to whether the fault was a read/write. The second
-        // element is the address of the inaccessible data causing this
-        // violation.
-        let faulting_addr = if record.ExceptionCode == EXCEPTION_ACCESS_VIOLATION {
-            assert!(record.NumberParameters >= 2);
-            Some(record.ExceptionInformation[1])
-        } else {
-            None
-        };
-        let jmp_buf = info.take_jmp_buf_if_trap(ip, |handler| handler(exception_info));
-        if jmp_buf.is_null() {
-            ExceptionContinueSearch
-        } else if jmp_buf as usize == 1 {
-            ExceptionContinueExecution
-        } else {
-            info.set_jit_trap(ip, fp, faulting_addr);
-            wasmtime_longjmp(jmp_buf)
-        }
-    })
-}
-
-pub fn lazy_per_thread_init() {
-    // Unused on Windows
-}
diff --git a/crates/runtime/src/vmcontext/vm_host_func_context.rs b/crates/runtime/src/vmcontext/vm_host_func_context.rs
deleted file mode 100644
index 547e3dcacf21..000000000000
--- a/crates/runtime/src/vmcontext/vm_host_func_context.rs
+++ /dev/null
@@ -1,137 +0,0 @@
-//! Definition of `VM*Context` variant for host functions.
-//!
-//! Keep in sync with `wasmtime_environ::VMHostFuncOffsets`.
-
-use super::VMOpaqueContext;
-use crate::{StoreBox, VMFuncRef};
-use std::any::Any;
-use wasmtime_environ::{VM_ARRAY_CALL_HOST_FUNC_MAGIC, VM_NATIVE_CALL_HOST_FUNC_MAGIC};
-
-/// The `VM*Context` for array-call host functions.
-///
-/// Its `magic` field must always be
-/// `wasmtime_environ::VM_ARRAY_CALL_HOST_FUNC_MAGIC`, and this is how you can
-/// determine whether a `VM*Context` is a `VMArrayCallHostFuncContext` versus a
-/// different kind of context.
-#[repr(C)]
-pub struct VMArrayCallHostFuncContext {
-    magic: u32,
-    // _padding: u32, // (on 64-bit systems)
-    pub(crate) func_ref: VMFuncRef,
-    host_state: Box<dyn Any + Send + Sync>,
-}
-
-impl VMArrayCallHostFuncContext {
-    /// Create the context for the given host function.
-    ///
-    /// # Safety
-    ///
-    /// The `host_func` must be a pointer to a host (not Wasm) function and it
-    /// must be `Send` and `Sync`.
-    pub unsafe fn new(
-        func_ref: VMFuncRef,
-        host_state: Box<dyn Any + Send + Sync>,
-    ) -> StoreBox<VMArrayCallHostFuncContext> {
-        debug_assert!(func_ref.vmctx.is_null());
-        let ctx = StoreBox::new(VMArrayCallHostFuncContext {
-            magic: wasmtime_environ::VM_ARRAY_CALL_HOST_FUNC_MAGIC,
-            func_ref,
-            host_state,
-        });
-        let vmctx = VMOpaqueContext::from_vm_array_call_host_func_context(ctx.get());
-        unsafe {
-            (*ctx.get()).func_ref.vmctx = vmctx;
-        }
-        ctx
-    }
-
-    /// Get the host state for this host function context.
-    #[inline]
-    pub fn host_state(&self) -> &(dyn Any + Send + Sync) {
-        &*self.host_state
-    }
-
-    /// Get this context's `VMFuncRef`.
-    #[inline]
-    pub fn func_ref(&self) -> &VMFuncRef {
-        &self.func_ref
-    }
-
-    /// Helper function to cast between context types using a debug assertion to
-    /// protect against some mistakes.
-    #[inline]
-    pub unsafe fn from_opaque(opaque: *mut VMOpaqueContext) -> *mut VMArrayCallHostFuncContext {
-        // See comments in `VMContext::from_opaque` for this debug assert
-        debug_assert_eq!((*opaque).magic, VM_ARRAY_CALL_HOST_FUNC_MAGIC);
-        opaque.cast()
-    }
-}
-
-/// The `VM*Context` for native-call host functions.
-///
-/// Its `magic` field must always be
-/// `wasmtime_environ::VM_NATIVE_CALL_HOST_FUNC_MAGIC`, and this is how you can
-/// determine whether a `VM*Context` is a `VMNativeCallHostFuncContext` versus a
-/// different kind of context.
-#[repr(C)]
-pub struct VMNativeCallHostFuncContext {
-    magic: u32,
-    // _padding: u32, // (on 64-bit systems)
-    func_ref: VMFuncRef,
-    host_state: Box<dyn Any + Send + Sync>,
-}
-
-#[test]
-fn vmnative_call_host_func_context_offsets() {
-    use memoffset::offset_of;
-    use wasmtime_environ::{HostPtr, PtrSize};
-    assert_eq!(
-        usize::from(HostPtr.vmnative_call_host_func_context_func_ref()),
-        offset_of!(VMNativeCallHostFuncContext, func_ref)
-    );
-}
-
-impl VMNativeCallHostFuncContext {
-    /// Create the context for the given host function.
-    ///
-    /// # Safety
-    ///
-    /// The `host_func` must be a pointer to a host (not Wasm) function and it
-    /// must be `Send` and `Sync`.
-    pub unsafe fn new(
-        func_ref: VMFuncRef,
-        host_state: Box<dyn Any + Send + Sync>,
-    ) -> StoreBox<VMNativeCallHostFuncContext> {
-        let ctx = StoreBox::new(VMNativeCallHostFuncContext {
-            magic: wasmtime_environ::VM_NATIVE_CALL_HOST_FUNC_MAGIC,
-            func_ref,
-            host_state,
-        });
-        let vmctx = VMOpaqueContext::from_vm_native_call_host_func_context(ctx.get());
-        unsafe {
-            (*ctx.get()).func_ref.vmctx = vmctx;
-        }
-        ctx
-    }
-
-    /// Get the host state for this host function context.
-    #[inline]
-    pub fn host_state(&self) -> &(dyn Any + Send + Sync) {
-        &*self.host_state
-    }
-
-    /// Get this context's `VMFuncRef`.
-    #[inline]
-    pub fn func_ref(&self) -> &VMFuncRef {
-        &self.func_ref
-    }
-
-    /// Helper function to cast between context types using a debug assertion to
-    /// protect against some mistakes.
-    #[inline]
-    pub unsafe fn from_opaque(opaque: *mut VMOpaqueContext) -> *mut VMNativeCallHostFuncContext {
-        // See comments in `VMContext::from_opaque` for this debug assert
-        debug_assert_eq!((*opaque).magic, VM_NATIVE_CALL_HOST_FUNC_MAGIC);
-        opaque.cast()
-    }
-}
diff --git a/crates/slab/Cargo.toml b/crates/slab/Cargo.toml
new file mode 100644
index 000000000000..b1b6c5e73c72
--- /dev/null
+++ b/crates/slab/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+authors = ["The Wasmtime Project Developers"]
+description = "Uni-typed slab with a free list for use in Wasmtime"
+edition.workspace = true
+rust-version.workspace = true
+license = "Apache-2.0 WITH LLVM-exception"
+name = "wasmtime-slab"
+repository = "https://github.com/bytecodealliance/wasmtime"
+version.workspace = true
+
+[lints]
+workspace = true
+
+[dependencies]
diff --git a/crates/slab/src/lib.rs b/crates/slab/src/lib.rs
new file mode 100644
index 000000000000..822973cee6be
--- /dev/null
+++ b/crates/slab/src/lib.rs
@@ -0,0 +1,498 @@
+//! A very simple, uniformly-typed slab arena that supports deallocation and
+//! reusing deallocated entries' space.
+//!
+//! The free list of vacant entries in the slab are stored inline in the slab's
+//! existing storage.
+//!
+//! # Example
+//!
+//! ```
+//! use wasmtime_slab::{Id, Slab};
+//!
+//! let mut slab = Slab::new();
+//!
+//! // Insert some values into the slab.
+//! let rza = slab.alloc("Robert Fitzgerald Diggs");
+//! let gza = slab.alloc("Gary Grice");
+//! let bill = slab.alloc("Bill Gates");
+//!
+//! // Allocated elements can be accessed infallibly via indexing (and missing and
+//! // deallocated entries will panic).
+//! assert_eq!(slab[rza], "Robert Fitzgerald Diggs");
+//!
+//! // Alternatively, the `get` and `get_mut` methods provide fallible lookup.
+//! if let Some(genius) = slab.get(gza) {
+//!     println!("The gza gza genius: {}", genius);
+//! }
+//! if let Some(val) = slab.get_mut(bill) {
+//!     *val = "Bill Gates doesn't belong in this set...";
+//! }
+//!
+//! // We can remove values from the slab.
+//! slab.dealloc(bill);
+//!
+//! // Allocate a new entry.
+//! let bill = slab.alloc("Bill Murray");
+//! ```
+//!
+//! # Using `Id`s with the Wrong `Slab`
+//!
+//! `Slab` does NOT check that `Id`s used to access previously-allocated values
+//! came from the current `Slab` instance (as opposed to a different `Slab`
+//! instance). Using `Id`s from a different `Slab` is safe, but will yield an
+//! unrelated value, if any at all.
+//!
+//! If you desire checking that an `Id` came from the correct `Slab` instance,
+//! it should be easy to layer that functionality on top of this crate by
+//! wrapping `Slab` and `Id` in types that additionally maintain a slab instance
+//! identifier.
+//!
+//! # The ABA Problem
+//!
+//! This `Slab` type does NOT protect against ABA bugs, such as the following
+//! sequence:
+//!
+//! * Value `A` is allocated into the slab, yielding id `i`.
+//!
+//! * `A` is deallocated, and so `i`'s associated entry is added to the slab's
+//!   free list.
+//!
+//! * Value `B` is allocated into the slab, reusing `i`'s associated entry,
+//!   yielding id `i`.
+//!
+//! * The "original" id `i` is used to access the arena, expecting the
+//!   deallocated value `A`, but getting the new value `B`.
+//!
+//! That is, it does not detect and prevent against the memory-safe version of
+//! use-after-free bugs.
+//!
+//! If you need to protect against ABA bugs, it should be easy to layer that
+//! functionality on top of this crate by wrapping `Slab` with something like
+//! the following:
+//!
+//! ```rust
+//! pub struct GenerationalId {
+//!     id: wasmtime_slab::Id,
+//!     generation: u32,
+//! }
+//!
+//! struct GenerationalEntry<T> {
+//!     value: T,
+//!     generation: u32,
+//! }
+//!
+//! pub struct GenerationalSlab<T> {
+//!     slab: wasmtime_slab::Slab<GenerationalEntry<T>>,
+//!     generation: u32,
+//! }
+//!
+//! impl<T> GenerationalSlab<T> {
+//!     pub fn alloc(&mut self, value: T) -> GenerationalId {
+//!         let generation = self.generation;
+//!         let id = self.slab.alloc(GenerationalEntry { value, generation });
+//!         GenerationalId { id, generation }
+//!     }
+//!
+//!     pub fn get(&self, id: GenerationalId) -> Option<&T> {
+//!         let entry = self.slab.get(id.id)?;
+//!
+//!         // Check that the entry's generation matches the id's generation,
+//!         // else we have an ABA bug. (Alternatively, return `None` instead
+//!         // of panicking.)
+//!         assert_eq!(id.generation, entry.generation);
+//!
+//!         Some(&entry.value)
+//!     }
+//!
+//!     pub fn dealloc(&mut self, id: GenerationalId) {
+//!         // Check that the entry's generation matches the id's generation,
+//!         // else we have an ABA bug. (Alternatively, silently return on
+//!         // double-free instead of panicking.)
+//!         assert_eq!(id.generation, self.slab[id.id].generation);
+//!
+//!         self.slab.dealloc(id.id);
+//!
+//!         // Increment our generation whenever we deallocate so that any new
+//!         // value placed in this same entry will have a different generation
+//!         // and we can detect ABA bugs.
+//!         self.generation += 1;
+//!     }
+//! }
+//! ```
+
+#![no_std]
+#![forbid(unsafe_code)]
+#![deny(missing_docs, missing_debug_implementations)]
+
+extern crate alloc;
+
+use alloc::vec::Vec;
+use core::fmt;
+use core::num::NonZeroU32;
+
+/// An identifier for an allocated value inside a `slab`.
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct Id(EntryIndex);
+
+impl fmt::Debug for Id {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("Id").field(&self.0.index()).finish()
+    }
+}
+
+impl Id {
+    /// Get the raw underlying representation of this `Id`.
+    #[inline]
+    pub fn into_raw(self) -> u32 {
+        u32::try_from(self.0.index()).unwrap()
+    }
+
+    /// Construct an `Id` from its raw underlying representation.
+    ///
+    /// `raw` should be a value that was previously created via
+    /// `Id::into_raw`. May panic if given arbitrary values.
+    #[inline]
+    pub fn from_raw(raw: u32) -> Self {
+        let raw = usize::try_from(raw).unwrap();
+        Self(EntryIndex::new(raw))
+    }
+}
+
+/// A simple, uni-typed slab arena.
+pub struct Slab<T> {
+    /// The slab's entries, each is either occupied and holding a `T` or vacant
+    /// and is a link the free list.
+    entries: Vec<Entry<T>>,
+
+    /// The index of the first free entry in the free list.
+    free: Option<EntryIndex>,
+
+    /// The number of occupied entries is this slab.
+    len: u32,
+}
+
+impl<T> fmt::Debug for Slab<T>
+where
+    T: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_map().entries(self.iter()).finish()
+    }
+}
+
+enum Entry<T> {
+    /// An occupied entry holding a `T`.
+    Occupied(T),
+
+    /// A vacant entry.
+    Free {
+        /// A link in the slab's free list, pointing to the next free entry, if
+        /// any.
+        next_free: Option<EntryIndex>,
+    },
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+struct EntryIndex(NonZeroU32);
+
+impl EntryIndex {
+    #[inline]
+    fn new(index: usize) -> Self {
+        assert!(index <= Slab::<()>::MAX_CAPACITY);
+        let x = u32::try_from(index + 1).unwrap();
+        Self(NonZeroU32::new(x).unwrap())
+    }
+
+    #[inline]
+    fn index(&self) -> usize {
+        let index = self.0.get() - 1;
+        usize::try_from(index).unwrap()
+    }
+}
+
+impl<T> Default for Slab<T> {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            entries: Vec::default(),
+            free: None,
+            len: 0,
+        }
+    }
+}
+
+impl<T> core::ops::Index<Id> for Slab<T> {
+    type Output = T;
+
+    #[inline]
+    fn index(&self, id: Id) -> &Self::Output {
+        self.get(id)
+            .expect("id from different slab or value was deallocated")
+    }
+}
+
+impl<T> core::ops::IndexMut<Id> for Slab<T> {
+    #[inline]
+    fn index_mut(&mut self, id: Id) -> &mut Self::Output {
+        self.get_mut(id)
+            .expect("id from different slab or value was deallocated")
+    }
+}
+
+impl<T> Slab<T> {
+    /// The maximum capacity any `Slab` can have: `u32::MAX - 1`.
+    pub const MAX_CAPACITY: usize = (u32::MAX - 1) as usize;
+
+    /// Construct a new, empty slab.
+    #[inline]
+    pub fn new() -> Self {
+        Slab::default()
+    }
+
+    /// Construct a new, empty slab, pre-reserving space for at least `capacity`
+    /// elements.
+    #[inline]
+    pub fn with_capacity(capacity: usize) -> Self {
+        let mut slab = Self::new();
+        slab.reserve(capacity);
+        slab
+    }
+
+    /// Ensure that there is space for at least `additional` elements in this
+    /// slab.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the new capacity exceeds `Self::MAX_CAPACITY`.
+    pub fn reserve(&mut self, additional: usize) {
+        let cap = self.capacity();
+        let len = self.len();
+        assert!(cap >= len);
+        if cap - len >= additional {
+            // Already have `additional` capacity available.
+            return;
+        }
+
+        self.entries.reserve(additional);
+
+        // Maintain the invariant that `i <= MAX_CAPACITY` for all indices `i`
+        // in `self.entries`.
+        assert!(self.entries.capacity() <= Self::MAX_CAPACITY);
+    }
+
+    fn double_capacity(&mut self) {
+        // Double our capacity to amortize the cost of resizing. But make sure
+        // we add some amount of minimum additional capacity, since doubling
+        // zero capacity isn't useful.
+        const MIN_CAPACITY: usize = 16;
+        let additional = core::cmp::max(self.entries.capacity(), MIN_CAPACITY);
+        self.reserve(additional);
+    }
+
+    /// What is the capacity of this slab? That is, how many entries can it
+    /// contain within its current underlying storage?
+    #[inline]
+    pub fn capacity(&self) -> usize {
+        self.entries.capacity()
+    }
+
+    /// How many values are currently allocated within this slab?
+    #[inline]
+    pub fn len(&self) -> usize {
+        usize::try_from(self.len).unwrap()
+    }
+
+    /// Are there zero allocated values within this slab?
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Try to allocate a `T` value within this slab.
+    ///
+    /// If there is no available capacity, ownership of the given value is
+    /// returned via `Err(value)`.
+    #[inline]
+    pub fn try_alloc(&mut self, value: T) -> Result<Id, T> {
+        if let Some(index) = self.try_alloc_index() {
+            let next_free = match self.entries[index.index()] {
+                Entry::Free { next_free } => next_free,
+                Entry::Occupied { .. } => unreachable!(),
+            };
+            self.free = next_free;
+            self.entries[index.index()] = Entry::Occupied(value);
+            self.len += 1;
+            Ok(Id(index))
+        } else {
+            Err(value)
+        }
+    }
+
+    #[inline]
+    fn try_alloc_index(&mut self) -> Option<EntryIndex> {
+        self.free.take().or_else(|| {
+            if self.entries.len() < self.entries.capacity() {
+                let index = EntryIndex::new(self.entries.len());
+                self.entries.push(Entry::Free { next_free: None });
+                Some(index)
+            } else {
+                None
+            }
+        })
+    }
+
+    /// Allocate a `T` value within this slab, allocating additional underlying
+    /// storage if there is no available capacity.
+    ///
+    /// # Panics
+    ///
+    /// Panics if allocating this value requires reallocating the underlying
+    /// storage, and the new capacity exceeds `Slab::MAX_CAPACITY`.
+    #[inline]
+    pub fn alloc(&mut self, value: T) -> Id {
+        self.try_alloc(value)
+            .unwrap_or_else(|value| self.alloc_slow(value))
+    }
+
+    /// Get the `Id` that will be returned for the next allocation in this slab.
+    #[inline]
+    pub fn next_id(&self) -> Id {
+        let index = self.free.unwrap_or_else(|| EntryIndex::new(self.len()));
+        Id(index)
+    }
+
+    #[inline(never)]
+    #[cold]
+    fn alloc_slow(&mut self, value: T) -> Id {
+        // Reserve additional capacity, since we didn't have space for the
+        // allocation.
+        self.double_capacity();
+        // After which the allocation will succeed.
+        self.try_alloc(value).ok().unwrap()
+    }
+
+    /// Get a shared borrow of the value associated with `id`.
+    ///
+    /// Returns `None` if the value has since been deallocated.
+    ///
+    /// If `id` comes from a different `Slab` instance, this method may panic,
+    /// return `None`, or return an arbitrary value.
+    #[inline]
+    pub fn get(&self, id: Id) -> Option<&T> {
+        match self
+            .entries
+            .get(id.0.index())
+            .expect("id from different slab")
+        {
+            Entry::Occupied(x) => Some(x),
+            Entry::Free { .. } => None,
+        }
+    }
+
+    /// Get an exclusive borrow of the value associated with `id`.
+    ///
+    /// Returns `None` if the value has since been deallocated.
+    ///
+    /// If `id` comes from a different `Slab` instance, this method may panic,
+    /// return `None`, or return an arbitrary value.
+    #[inline]
+    pub fn get_mut(&mut self, id: Id) -> Option<&mut T> {
+        match self
+            .entries
+            .get_mut(id.0.index())
+            .expect("id from different slab")
+        {
+            Entry::Occupied(x) => Some(x),
+            Entry::Free { .. } => None,
+        }
+    }
+
+    /// Does this slab contain an allocated value for `id`?
+    #[inline]
+    pub fn contains(&self, id: Id) -> bool {
+        match self.entries.get(id.0.index()) {
+            Some(Entry::Occupied(_)) => true,
+            None | Some(Entry::Free { .. }) => false,
+        }
+    }
+
+    /// Deallocate the value associated with the given `id`.
+    ///
+    /// If `id` comes from a different `Slab` instance, this method may panic or
+    /// deallocate an arbitrary value.
+    #[inline]
+    pub fn dealloc(&mut self, id: Id) -> T {
+        let entry = core::mem::replace(
+            self.entries
+                .get_mut(id.0.index())
+                .expect("id from a different slab"),
+            Entry::Free { next_free: None },
+        );
+        match entry {
+            Entry::Free { .. } => panic!("attempt to deallocate an entry that is already vacant"),
+            Entry::Occupied(value) => {
+                let next_free = core::mem::replace(&mut self.free, Some(id.0));
+                self.entries[id.0.index()] = Entry::Free { next_free };
+                self.len -= 1;
+                value
+            }
+        }
+    }
+
+    /// Iterate over all values currently allocated within this `Slab`.
+    ///
+    /// Yields pairs of an `Id` and the `Id`'s associated value.
+    ///
+    /// Iteration order is undefined.
+    #[inline]
+    pub fn iter(&self) -> impl Iterator<Item = (Id, &T)> + '_ {
+        assert!(self.entries.len() <= Self::MAX_CAPACITY);
+        self.entries
+            .iter()
+            .enumerate()
+            .filter_map(|(i, e)| match e {
+                Entry::Occupied(x) => Some((Id(EntryIndex::new(i)), x)),
+                Entry::Free { .. } => None,
+            })
+    }
+
+    /// Mutably iterate over all values currently allocated within this `Slab`.
+    ///
+    /// Yields pairs of an `Id` and the `Id`'s associated value.
+    ///
+    /// Iteration order is undefined.
+    #[inline]
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = (Id, &mut T)> + '_ {
+        assert!(self.entries.len() <= Self::MAX_CAPACITY);
+        self.entries
+            .iter_mut()
+            .enumerate()
+            .filter_map(|(i, e)| match e {
+                Entry::Occupied(x) => Some((Id(EntryIndex::new(i)), x)),
+                Entry::Free { .. } => None,
+            })
+    }
+
+    /// Iterate over and remove all entries in this slab.
+    ///
+    /// The slab will be empty after calling this method.
+    ///
+    /// Yields pairs of an `Id` and the `Id`'s associated value.
+    ///
+    /// Iteration order is undefined.
+    #[inline]
+    pub fn drain(&mut self) -> impl Iterator<Item = (Id, T)> + '_ {
+        assert!(self.entries.len() <= Self::MAX_CAPACITY);
+        self.len = 0;
+        self.free = None;
+        self.entries
+            .drain(..)
+            .enumerate()
+            .filter_map(|(i, e)| match e {
+                Entry::Occupied(x) => Some((Id(EntryIndex::new(i)), x)),
+                Entry::Free { .. } => None,
+            })
+    }
+}
diff --git a/crates/test-macros/Cargo.toml b/crates/test-macros/Cargo.toml
new file mode 100644
index 000000000000..c4871a35935d
--- /dev/null
+++ b/crates/test-macros/Cargo.toml
@@ -0,0 +1,23 @@
+[package]
+description = "Macros for testing Wasmtime"
+name = "wasmtime-test-macros"
+license = "Apache-2.0 WITH LLVM-exception"
+version = "0.0.0"
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+publish = false
+
+[lib]
+proc-macro = true
+test = false
+doctest = false
+
+[lints]
+workspace = true
+
+[dependencies]
+quote = "1.0"
+proc-macro2 = "1.0"
+syn = { workspace = true, features = ["full"] }
+anyhow = { workspace = true }
diff --git a/crates/test-macros/src/lib.rs b/crates/test-macros/src/lib.rs
new file mode 100644
index 000000000000..bf59adb89c8f
--- /dev/null
+++ b/crates/test-macros/src/lib.rs
@@ -0,0 +1,254 @@
+//! Wasmtime test macro.
+//!
+//! This macro is a helper to define tests that exercise multiple configuration
+//! combinations for Wasmtime. Currently compiler strategies and wasm features
+//! are supported.
+//!
+//! Usage
+//!
+//! To exclude a compiler strategy:
+//!
+//! ```rust
+//! #[wasmtime_test(strategies(not(Winch)))]
+//! fn my_test(config: &mut Config) -> Result<()> {
+//!    Ok(())
+//! }
+//! ```
+//!
+//! To explicitly indicate that a wasm features is needed
+//! ```
+//! #[wasmtime_test(wasm_features(gc))]
+//! fn my_wasm_gc_test(config: &mut Config) -> Result<()> {
+//!   Ok(())
+//! }
+//! ```
+//!
+//! If the specified wasm feature is disabled by default, the macro will enable
+//! the feature in the configuration passed to the test.
+//!
+//! If the wasm feature is not supported by any of the compiler strategies, no
+//! tests will be generated for such strategy.
+use proc_macro::TokenStream;
+use proc_macro2::Span;
+use quote::{quote, ToTokens, TokenStreamExt};
+use syn::{
+    braced,
+    meta::ParseNestedMeta,
+    parse::{Parse, ParseStream},
+    parse_macro_input, token, Attribute, Ident, Result, ReturnType, Signature, Visibility,
+};
+
+/// Test configuration.
+struct TestConfig {
+    /// Supported compiler strategies.
+    strategies: Vec<Ident>,
+    /// Known WebAssembly features that will be turned on by default in the
+    /// resulting Config.
+    /// The identifiers in this list are features that are off by default in
+    /// Wasmtime's Config, which will be explicitly turned on for a given test.
+    wasm_features: Vec<Ident>,
+    /// Flag to track if there are Wasm features not supported by Winch.
+    wasm_features_unsupported_by_winch: bool,
+}
+
+impl TestConfig {
+    fn strategies_from(&mut self, meta: &ParseNestedMeta) -> Result<()> {
+        meta.parse_nested_meta(|meta| {
+            if meta.path.is_ident("not") {
+                meta.parse_nested_meta(|meta| {
+                    if meta.path.is_ident("Winch") || meta.path.is_ident("Cranelift") {
+                        let id = meta.path.require_ident()?.clone();
+                        self.strategies.retain(|s| *s != id);
+                        Ok(())
+                    } else {
+                        Err(meta.error("Unknown strategy"))
+                    }
+                })
+            } else {
+                Err(meta.error("Unknown identifier"))
+            }
+        })?;
+
+        if self.strategies.len() == 0 {
+            Err(meta.error("Expected at least one strategy"))
+        } else {
+            Ok(())
+        }
+    }
+
+    fn wasm_features_from(&mut self, meta: &ParseNestedMeta) -> Result<()> {
+        meta.parse_nested_meta(|meta| {
+            if meta.path.is_ident("gc") || meta.path.is_ident("function_references") {
+                let feature = meta.path.require_ident()?.clone();
+                self.wasm_features.push(feature.clone());
+                self.wasm_features_unsupported_by_winch = true;
+                Ok(())
+            } else if meta.path.is_ident("simd")
+                || meta.path.is_ident("relaxed_simd")
+                || meta.path.is_ident("reference_types")
+                || meta.path.is_ident("tail_call")
+                || meta.path.is_ident("threads")
+            {
+                self.wasm_features_unsupported_by_winch = true;
+                Ok(())
+            } else {
+                Err(meta.error("Unsupported wasm feature"))
+            }
+        })?;
+
+        if self.wasm_features.len() > 2 {
+            return Err(meta.error("Expected at most 2 off-by-default wasm features"));
+        }
+
+        if self.wasm_features_unsupported_by_winch {
+            self.strategies.retain(|s| s.to_string() != "Winch");
+        }
+
+        Ok(())
+    }
+}
+
+impl Default for TestConfig {
+    fn default() -> Self {
+        Self {
+            strategies: vec![
+                Ident::new("Cranelift", Span::call_site()),
+                Ident::new("Winch", Span::call_site()),
+            ],
+            wasm_features: vec![],
+            wasm_features_unsupported_by_winch: false,
+        }
+    }
+}
+
+/// A generic function body represented as a braced [`TokenStream`].
+struct Block {
+    brace: token::Brace,
+    rest: proc_macro2::TokenStream,
+}
+
+impl Parse for Block {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let content;
+        Ok(Self {
+            brace: braced!(content in input),
+            rest: content.parse()?,
+        })
+    }
+}
+
+impl ToTokens for Block {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        self.brace.surround(tokens, |tokens| {
+            tokens.append_all(self.rest.clone());
+        });
+    }
+}
+
+/// Custom function parser.
+/// Parses the function's attributes, visibility and signature, leaving the
+/// block as an opaque [`TokenStream`].
+struct Fn {
+    attrs: Vec<Attribute>,
+    visibility: Visibility,
+    sig: Signature,
+    body: Block,
+}
+
+impl Parse for Fn {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let attrs = input.call(Attribute::parse_outer)?;
+        let visibility: Visibility = input.parse()?;
+        let sig: Signature = input.parse()?;
+        let body: Block = input.parse()?;
+
+        Ok(Self {
+            attrs,
+            visibility,
+            sig,
+            body,
+        })
+    }
+}
+
+impl ToTokens for Fn {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        for attr in &self.attrs {
+            attr.to_tokens(tokens);
+        }
+        self.visibility.to_tokens(tokens);
+        self.sig.to_tokens(tokens);
+        self.body.to_tokens(tokens);
+    }
+}
+
+#[proc_macro_attribute]
+pub fn wasmtime_test(attrs: TokenStream, item: TokenStream) -> TokenStream {
+    let mut test_config = TestConfig::default();
+
+    let config_parser = syn::meta::parser(|meta| {
+        if meta.path.is_ident("strategies") {
+            test_config.strategies_from(&meta)
+        } else if meta.path.is_ident("wasm_features") {
+            test_config.wasm_features_from(&meta)
+        } else {
+            Err(meta.error("Unsupported attributes"))
+        }
+    });
+
+    parse_macro_input!(attrs with config_parser);
+
+    match expand(&test_config, parse_macro_input!(item as Fn)) {
+        Ok(tok) => tok,
+        Err(e) => e.into_compile_error().into(),
+    }
+}
+
+fn expand(test_config: &TestConfig, func: Fn) -> Result<TokenStream> {
+    let mut tests = vec![quote! { #func }];
+    let attrs = &func.attrs;
+
+    for ident in &test_config.strategies {
+        let strategy_name = ident.to_string();
+        // Winch currently only offers support for x64.
+        let target = if strategy_name == "Winch" {
+            quote! { #[cfg(target_arch = "x86_64")] }
+        } else {
+            quote! {}
+        };
+        let func_name = &func.sig.ident;
+        let ret = match &func.sig.output {
+            ReturnType::Default => quote! { () },
+            ReturnType::Type(_, ty) => quote! { -> #ty },
+        };
+        let test_name = Ident::new(
+            &format!("{}_{}", strategy_name.to_lowercase(), func_name),
+            func_name.span(),
+        );
+
+        let config_setup = test_config.wasm_features.iter().map(|f| {
+            let method_name = Ident::new(&format!("wasm_{f}"), f.span());
+            quote! {
+                config.#method_name(true);
+            }
+        });
+
+        let tok = quote! {
+            #[test]
+            #target
+            #(#attrs)*
+            fn #test_name() #ret {
+                let mut config = Config::new();
+                config.strategy(Strategy::#ident);
+                #(#config_setup)*
+                #func_name(&mut config)
+            }
+        };
+
+        tests.push(tok);
+    }
+    Ok(quote! {
+        #(#tests)*
+    }
+    .into())
+}
diff --git a/crates/test-programs/Cargo.toml b/crates/test-programs/Cargo.toml
index 9785dc38d738..baff3bba8b79 100644
--- a/crates/test-programs/Cargo.toml
+++ b/crates/test-programs/Cargo.toml
@@ -2,46 +2,22 @@
 name = "test-programs"
 version = "0.0.0"
 authors = ["The Wasmtime Project Developers"]
-readme = "README.md"
 edition.workspace = true
+rust-version.workspace = true
 publish = false
 license = "Apache-2.0 WITH LLVM-exception"
 
-[build-dependencies]
-cfg-if = { workspace = true }
-cargo_metadata = "0.15.3"
-wit-component = { workspace = true }
-heck = { workspace = true }
+[lints]
+workspace = true
 
 [dependencies]
-anyhow = { workspace = true }
-bytes = { workspace = true }
-http = { version = "0.2.9" }
-http-body = "1.0.0-rc.2"
-http-body-util = "0.1.0-rc.2"
-hyper = { version = "1.0.0-rc.3", features = ["full"] }
-tokio = { workspace = true, features = ["net", "rt-multi-thread", "macros"] }
-tracing = { workspace = true }
-
-[dev-dependencies]
-anyhow = { workspace = true }
-tempfile = { workspace = true }
-test-log = { workspace = true }
-tracing = { workspace = true }
-tracing-subscriber = { workspace = true }
-lazy_static = "1"
-wasmtime = { workspace = true, features = ['cranelift', 'component-model'] }
-
-wasi-common = { workspace = true }
-wasi-cap-std-sync = { workspace = true }
-wasmtime-wasi = { workspace = true, default-features = true, features = [
-    "tokio",
-] }
-cap-std = { workspace = true }
-cap-rand = { workspace = true }
-tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
-
-wasmtime-wasi-http = { workspace = true, features = ["sync"] }
-
-[features]
-test_programs = []
+anyhow = { workspace = true, features = ['std'] }
+wasi = "0.11.0"
+wasi-nn = "0.6.0"
+wit-bindgen = { workspace = true, features = ['default'] }
+libc = { workspace = true }
+getrandom = "0.2.9"
+futures = { workspace = true, default-features = false, features = ['alloc'] }
+url = { workspace = true }
+sha2 = "0.10.2"
+base64 = "0.21.0"
diff --git a/crates/test-programs/README.md b/crates/test-programs/README.md
index 31f3c1bfadb6..a6b1ce5515df 100644
--- a/crates/test-programs/README.md
+++ b/crates/test-programs/README.md
@@ -1,7 +1,170 @@
-This is the `test-programs` crate, which builds and runs whole programs
-compiled to wasm32-wasi.
+# test-programs
+
+This crate contains many different binaries which are built into Wasm test
+programs for other crates in the Wasmtime workspace.
+
+Each file in `./src/bin/` is built into a distinct test binary. By convention,
+the prefix before the first underscore in each binary is the name of the test
+suite: `api`, `cli`, `http`, `nn`, `piped`, `preview1`, and `preview2`.
+
+## Test suites
+
+### api
+
+This suite is used for exercising `wasmtime`'s Rust APIs. Each test program in
+this suite has particular behavior which interacts with the tests themselves.
+
+These test programs are executed in `/crates/wasi/tests/api.rs`.
+
+### cli
+
+This suite is used for exercising the `wasmtime-cli` crate, which produces the
+`wasmtime` native executable. Each test program in this suite has particular
+behavior which interacts with the commands and arguments passed to the
+wasmtime CLI. Some use the `wasmtime run` command and others the `wasmtime
+serve` command.
+
+These test programs are executed in `/tests/all/cli_tests.rs`.
+
+### http
+
+This test suite is used for exercising the `wasmtime-wasi-http` crate. Each
+test program in this suite is a component which exports the wasi-cli command
+world's run interface (i.e. its entrypoint is defined by `fn main() {...}`),
+and is given the cli command world imports as well as the wasi-http
+outgoing-handler and types imports - in short, this is a basic executable
+which can make http requests using wasi-http.
+
+Each test program executor spawns a fresh tokio runtime on a unique local
+socket which responds to the requests made by a single test program. This
+socket address is passed to the test program using the `HTTP_SERVER`
+environment variable.
+
+These test programs are executed in `/crates/wasi-http/tests/all/sync.rs`
+and `/crates/wasi-http/tests/all/async_.rs`, which test the synchronous and
+async rust interfaces of the `wasmtime` and `wasmtime-wasi-http` crates,
+respectively.
+
+### nn
+
+This test suite is used for exercising the `wasmtime-wasi-nn` crate. It only
+tests the witx ABI of the wasi-nn proposal.
+
+These test programs are executed in `crates/wasi-nn/tests/all.rs`.
+
+### piped
+
+This suite is used for exercising the wasmtime-cli and, in particular,
+examining the behavior when the standard output of one instance is piped to
+the input of another instance. The test programs in this suite are passed
+the environment variable `PIPED_SIDE` with the value `PRODUCER` or `CONSUMER`
+to select the behavior of producing output to stdout, or consuming input
+on stdin.
+
+These test programs are executed in `/tests/all/cli_tests.rs`, which creates
+two separate `wasmtime` host processes, with the consumer process stdin file
+descriptor set to the producer process stdout file descriptor. The test
+harness asserts that both processes exit successfully.
+
+### preview1
+
+This suite is used for exercising the Wasi Preview 1 (aka Wasi 0.1) interface,
+and, additionally, provides test coverage of Wasi Preview 2 (aka Wasi 0.2)
+when used with the component adapter, as described below.
+
+Some of these tests require the stdin stream provided is always empty and
+closed, others require that the stdin stream is open and pending forever. The
+test execution provides this by inheriting the host process stdio in some test
+program invocations, and providing the default null stdio in others.
+
+All of these tests require an empty directory be provided as a preopen, and
+the path of that preopen passed as the first argument.
+
+The Wasmtime tree has three distinct ways to implement the Wasi 0.1 interface,
+which should all provide identical functionality:
+* The Wasm Module is executed against the host implementation of Wasi 0.1
+  provided by the `wasi-common` crate. The test programs are executed
+  in `/crates/wasi-common/tests/all/{sync,async_}.rs` against the synchronous
+  and async Rust interfaces of the `wasmtime` and `wasi-common` crate.
+* The Wasm Module is executed against the host implementation of Wasi 0.1
+  provided by the `wasmtime-wasi` crate. This Wasi 0.1 interface is implemented
+  using the Wasi 0.2 implementation defined in that same crate. The test
+  programs are executed in `/crates/wasi/tests/all/preview1.rs` against the
+  synchronous Rust interfaces of the `wasmtime` and `wasmtime-wasi` crates.
+* The Wasm Component created by composing the Module with the
+  `wasi-preview1-component-adapter`, which provides a pure WebAssembly
+  implementation of the Wasi 0.1 import functions in terms of the Wasi 0.2
+  import functions. When run in the host implementation of Wasi 0.2 provided
+  by the `wasmtime-wasi` crate, this mode of execution exercises the Wasi 0.2
+  interfaces, and ensures that a faithful implementation of Wasi 0.1 can be
+  provided in terms of them, without needing any support for Wasi 0.1 in the
+  host. The test programs are executed in
+  `crates/wasi/tests/all/{sync,async_}.rs` against the synchronous and async
+  Rust interfaces of the `wasmtime` and `wasmtime-wasi` crates.
+
+### preview2
+
+This suite is used for exercising the portions of Wasi Preview 2 (aka Wasi
+0.2) which are not covered by the Wasi 0.1 + component adapter, as described
+in the preview1 suite above.
+
+These test programs use `wit-bindgen` to generate bindings to Wasi 0.2
+(invoked at the root of the `test-programs` crate), and then invoke those
+bindings directly in each test. The modules created from these test programs
+still have imports of Wasi 0.1 thanks to the Rust `std` library, so those
+imports are implemented by the same `wasi-preview1-component-adapter` as in
+the preview1 suite. (When Rust stabilizes the `wasm32-wasip2` target, this
+will finally get to be removed!) However, the tests themselves should be
+exercising the Wasi 0.2 interfaces directly - in some cases, such as the
+socket tests, its exercising functionality that Wasi 0.1 lacked.
+
+These tests are executed much like the component adapted preview1 test suite
+is, in `crates/wasi/tests/all/{sync,async_}.rs`.
+
+## Building and executing these test programs
+
+These tests are built and consumed by way of the `test-programs-artifacts`
+crate. `test-programs-artifacts` has a `build.rs` which compiles this crate
+and translates some of the resulting Wasm Modules to Wasm Components. It then
+exposes the filesystem paths of these binaries as string constants, and as
+macros which iterate over the complete set of binary paths in a given test
+suite.
+
+The filesystem path to each Wasm Module built by `test-programs-artifacts`
+is provided by a `pub const <TESTNAME>: &'static str = ...;` at the top
+level of that crate, where `<TESTNAME>` is the file stem of the source file
+in `./src/bin`, in shouty snake case (all caps and underscores).
+
+The filesystem path to each Wasm Component built by `test-programs-artifacts`
+is provided by a `pub const <TESTNAME>_COMPONENT: &'static str = ...;` at the top
+level of that crate, where `<TESTNAME>` is the file stem of the source file
+in `./src/bin`, in shouty snake case (all caps and underscores), and then the
+suffix `_COMPONENT` is added to the identifier to distinguish it from the
+module.
+
+Wasm Components are not built for the `nn` test suite. All other components
+are created, using the `wasi-preview1-component-adapter` to translate Wasi 0.1
+module imports to Wasi 0.2 component imports.
+
+Each test suite is given an iterator macro in `test-programs-artifacts` named
+`foreach_<suitename>`.
+
+The iterator macro is passed the identifier of another macro which is passed
+the path of each test in the suite. You could do something very clever with
+this if you desire, but as of this writing, all use sites in the workspace
+pass it a macro `assert_test_exists` which emits a `use <testname> as _;`
+statement. This ensures that, in the rust mod where `foreach_<suitename>` is
+invoked, a `fn <testname>() {...}` is defined, which in turn makes sure that,
+if a wasmtime developer adds a new test program, they also add a test which
+executes it in the appropriate location.
+
+By convention, the expectation is that each mod that invokes
+`foreach_<suitename>!(assert_test_exists);` also defines something like:
 
-To actually run these tests, the test-programs feature must be enabled, e.g.:
 ```
-cargo test --features test-programs/test_programs --package test-programs
+#[test]
+fn <testname>() { 
+    // do something which executes <TESTNAME> or
+    // <TESTNAME>_COMPONENT here.
+}
 ```
diff --git a/crates/test-programs/artifacts/Cargo.toml b/crates/test-programs/artifacts/Cargo.toml
new file mode 100644
index 000000000000..40cc3a7bdc91
--- /dev/null
+++ b/crates/test-programs/artifacts/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+name = "test-programs-artifacts"
+version = "0.0.0"
+authors = ["The Wasmtime Project Developers"]
+edition.workspace = true
+rust-version.workspace = true
+publish = false
+license = "Apache-2.0 WITH LLVM-exception"
+
+[lints]
+workspace = true
+
+[dependencies]
+wasmtime = { workspace = true, features = ['incremental-cache', 'cranelift', 'component-model'] }
+
+[build-dependencies]
+heck = { workspace = true }
+wit-component = { workspace = true }
+cargo_metadata = "0.18.1"
diff --git a/crates/test-programs/artifacts/build.rs b/crates/test-programs/artifacts/build.rs
new file mode 100644
index 000000000000..018b5cce995b
--- /dev/null
+++ b/crates/test-programs/artifacts/build.rs
@@ -0,0 +1,192 @@
+use heck::*;
+use std::collections::BTreeMap;
+use std::env;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use wit_component::ComponentEncoder;
+
+fn main() {
+    build_and_generate_tests();
+}
+
+fn build_and_generate_tests() {
+    let out_dir = PathBuf::from(env::var_os("OUT_DIR").unwrap());
+
+    let reactor_adapter = build_adapter(&out_dir, "reactor", &[]);
+    let command_adapter = build_adapter(
+        &out_dir,
+        "command",
+        &["--no-default-features", "--features=command"],
+    );
+    let proxy_adapter = build_adapter(
+        &out_dir,
+        "proxy",
+        &["--no-default-features", "--features=proxy"],
+    );
+
+    println!("cargo:rerun-if-changed=../src");
+
+    // Build the test programs:
+    let mut cmd = cargo();
+    cmd.arg("build")
+        .arg("--target=wasm32-wasip1")
+        .arg("--package=test-programs")
+        .env("CARGO_TARGET_DIR", &out_dir)
+        .env("CARGO_PROFILE_DEV_DEBUG", "2")
+        .env("RUSTFLAGS", rustflags())
+        .env_remove("CARGO_ENCODED_RUSTFLAGS");
+    eprintln!("running: {cmd:?}");
+    let status = cmd.status().unwrap();
+    assert!(status.success());
+
+    let meta = cargo_metadata::MetadataCommand::new().exec().unwrap();
+    let targets = meta
+        .packages
+        .iter()
+        .find(|p| p.name == "test-programs")
+        .unwrap()
+        .targets
+        .iter()
+        .filter(move |t| t.kind == &["bin"])
+        .map(|t| &t.name)
+        .collect::<Vec<_>>();
+
+    let mut generated_code = String::new();
+
+    let mut kinds = BTreeMap::new();
+
+    for target in targets {
+        let camel = target.to_shouty_snake_case();
+        let wasm = out_dir
+            .join("wasm32-wasip1")
+            .join("debug")
+            .join(format!("{target}.wasm"));
+
+        generated_code += &format!("pub const {camel}: &'static str = {wasm:?};\n");
+
+        // Bucket, based on the name of the test, into a "kind" which generates
+        // a `foreach_*` macro below.
+        let kind = match target.as_str() {
+            s if s.starts_with("http_") => "http",
+            s if s.starts_with("preview1_") => "preview1",
+            s if s.starts_with("preview2_") => "preview2",
+            s if s.starts_with("cli_") => "cli",
+            s if s.starts_with("api_") => "api",
+            s if s.starts_with("nn_") => "nn",
+            s if s.starts_with("piped_") => "piped",
+            s if s.starts_with("dwarf_") => "dwarf",
+            s if s.starts_with("runtime_config_") => "runtime_config",
+            s if s.starts_with("keyvalue_") => "keyvalue",
+            // If you're reading this because you hit this panic, either add it
+            // to a test suite above or add a new "suite". The purpose of the
+            // categorization above is to have a static assertion that tests
+            // added are actually run somewhere, so as long as you're also
+            // adding test code somewhere that's ok.
+            other => {
+                panic!("don't know how to classify test name `{other}` to a kind")
+            }
+        };
+        if !kind.is_empty() {
+            kinds.entry(kind).or_insert(Vec::new()).push(target);
+        }
+
+        // Generate a component from each test.
+        if target == "dwarf_imported_memory"
+            || target == "dwarf_shared_memory"
+            || target.starts_with("nn_witx")
+        {
+            continue;
+        }
+        let adapter = match target.as_str() {
+            "reactor" => &reactor_adapter,
+            s if s.starts_with("api_proxy") => &proxy_adapter,
+            _ => &command_adapter,
+        };
+        let path = compile_component(&wasm, adapter);
+        generated_code += &format!("pub const {camel}_COMPONENT: &'static str = {path:?};\n");
+    }
+
+    for (kind, targets) in kinds {
+        generated_code += &format!("#[macro_export]");
+        generated_code += &format!("macro_rules! foreach_{kind} {{\n");
+        generated_code += &format!("    ($mac:ident) => {{\n");
+        for target in targets {
+            generated_code += &format!("$mac!({target});\n")
+        }
+        generated_code += &format!("    }}\n");
+        generated_code += &format!("}}\n");
+    }
+
+    std::fs::write(out_dir.join("gen.rs"), generated_code).unwrap();
+}
+
+// Build the WASI Preview 1 adapter, and get the binary:
+fn build_adapter(out_dir: &PathBuf, name: &str, features: &[&str]) -> Vec<u8> {
+    println!("cargo:rerun-if-changed=../../wasi-preview1-component-adapter");
+    let mut cmd = cargo();
+    cmd.arg("build")
+        .arg("--release")
+        .arg("--package=wasi-preview1-component-adapter")
+        .arg("--target=wasm32-unknown-unknown")
+        .env("CARGO_TARGET_DIR", out_dir)
+        .env("RUSTFLAGS", rustflags())
+        .env_remove("CARGO_ENCODED_RUSTFLAGS");
+    for f in features {
+        cmd.arg(f);
+    }
+    eprintln!("running: {cmd:?}");
+    let status = cmd.status().unwrap();
+    assert!(status.success());
+
+    let adapter = out_dir.join(format!("wasi_snapshot_preview1.{name}.wasm"));
+    std::fs::copy(
+        out_dir
+            .join("wasm32-unknown-unknown")
+            .join("release")
+            .join("wasi_snapshot_preview1.wasm"),
+        &adapter,
+    )
+    .unwrap();
+    println!("wasi {name} adapter: {:?}", &adapter);
+    fs::read(&adapter).unwrap()
+}
+
+fn rustflags() -> &'static str {
+    match option_env!("RUSTFLAGS") {
+        // If we're in CI which is denying warnings then deny warnings to code
+        // built here too to keep the tree warning-free.
+        Some(s) if s.contains("-D warnings") => "-D warnings",
+        _ => "",
+    }
+}
+
+// Compile a component, return the path of the binary:
+fn compile_component(wasm: &Path, adapter: &[u8]) -> PathBuf {
+    println!("creating a component from {wasm:?}");
+    let module = fs::read(wasm).expect("read wasm module");
+    let component = ComponentEncoder::default()
+        .module(module.as_slice())
+        .unwrap()
+        .validate(true)
+        .adapter("wasi_snapshot_preview1", adapter)
+        .unwrap()
+        .encode()
+        .expect("module can be translated to a component");
+    let out_dir = wasm.parent().unwrap();
+    let stem = wasm.file_stem().unwrap().to_str().unwrap();
+    let component_path = out_dir.join(format!("{stem}.component.wasm"));
+    fs::write(&component_path, component).expect("write component to disk");
+    component_path
+}
+
+fn cargo() -> Command {
+    // Miri configures its own sysroot which we don't want to use, so remove
+    // miri's own wrappers around rustc to ensure that we're using the real
+    // rustc to build these programs.
+    let mut cargo = Command::new("cargo");
+    if std::env::var("CARGO_CFG_MIRI").is_ok() {
+        cargo.env_remove("RUSTC").env_remove("RUSTC_WRAPPER");
+    }
+    cargo
+}
diff --git a/crates/test-programs/artifacts/src/lib.rs b/crates/test-programs/artifacts/src/lib.rs
new file mode 100644
index 000000000000..bea4484b1ad8
--- /dev/null
+++ b/crates/test-programs/artifacts/src/lib.rs
@@ -0,0 +1,79 @@
+include!(concat!(env!("OUT_DIR"), "/gen.rs"));
+
+use std::borrow::Cow;
+use std::collections::HashMap;
+use std::io::IsTerminal;
+use std::sync::{Arc, Mutex};
+use wasmtime::{CacheStore, Config, Engine};
+
+/// The wasi-tests binaries use these environment variables to determine their
+/// expected behavior.
+/// Used by all of the tests/ which execute the wasi-tests binaries.
+pub fn wasi_tests_environment() -> &'static [(&'static str, &'static str)] {
+    #[cfg(windows)]
+    {
+        &[
+            ("ERRNO_MODE_WINDOWS", "1"),
+            // Windows does not support dangling links or symlinks in the filesystem.
+            ("NO_DANGLING_FILESYSTEM", "1"),
+            // Windows does not support renaming a directory to an empty directory -
+            // empty directory must be deleted.
+            ("NO_RENAME_DIR_TO_EMPTY_DIR", "1"),
+        ]
+    }
+    #[cfg(all(unix, not(target_os = "macos")))]
+    {
+        &[("ERRNO_MODE_UNIX", "1")]
+    }
+    #[cfg(target_os = "macos")]
+    {
+        &[("ERRNO_MODE_MACOS", "1")]
+    }
+}
+
+pub fn stdio_is_terminal() -> bool {
+    std::io::stdin().is_terminal()
+        && std::io::stdout().is_terminal()
+        && std::io::stderr().is_terminal()
+}
+
+// Simple incremental cache used during tests to help improve test runtime.
+//
+// Many tests take a similar module (e.g. a component, a preview1 thing, sync,
+// async, etc) and run it in different contexts and this improve cache hit rates
+// across usages by sharing one incremental cache across tests.
+fn cache_store() -> Arc<dyn CacheStore> {
+    #[derive(Debug)]
+    struct MyCache;
+
+    static CACHE: Mutex<Option<HashMap<Vec<u8>, Vec<u8>>>> = Mutex::new(None);
+
+    impl CacheStore for MyCache {
+        fn get(&self, key: &[u8]) -> Option<Cow<[u8]>> {
+            let mut cache = CACHE.lock().unwrap();
+            let cache = cache.get_or_insert_with(HashMap::new);
+            cache.get(key).map(|s| s.to_vec().into())
+        }
+
+        fn insert(&self, key: &[u8], value: Vec<u8>) -> bool {
+            let mut cache = CACHE.lock().unwrap();
+            let cache = cache.get_or_insert_with(HashMap::new);
+            cache.insert(key.to_vec(), value);
+            true
+        }
+    }
+
+    Arc::new(MyCache)
+}
+
+/// Helper to create an `Engine` with a pre-configured `Config` that uses a
+/// cache for faster building of modules.
+pub fn engine(configure: impl FnOnce(&mut Config)) -> Engine {
+    let mut config = Config::new();
+    config.wasm_component_model(true);
+    config
+        .enable_incremental_compilation(cache_store())
+        .unwrap();
+    configure(&mut config);
+    Engine::new(&config).unwrap()
+}
diff --git a/crates/test-programs/build.rs b/crates/test-programs/build.rs
index efa0d20d63eb..8f055264c6c1 100644
--- a/crates/test-programs/build.rs
+++ b/crates/test-programs/build.rs
@@ -1,282 +1,6 @@
-#![cfg_attr(not(feature = "test_programs"), allow(dead_code))]
-
-use heck::ToSnakeCase;
-use std::env;
-use std::fs;
-use std::path::PathBuf;
-use std::process::Command;
-use wit_component::ComponentEncoder;
-
-// NB: this is set to `false` when a breaking change to WIT is made since the
-// wasi-http WIT is currently a submodule and can't be updated atomically with
-// the rest of Wasmtime.
-const BUILD_WASI_HTTP_TESTS: bool = true;
-
 fn main() {
-    #[cfg(feature = "test_programs")]
-    build_and_generate_tests();
-}
-
-fn build_and_generate_tests() {
-    let out_dir = PathBuf::from(env::var_os("OUT_DIR").unwrap());
-
-    let reactor_adapter = build_adapter(&out_dir, "reactor", &[]);
-    let command_adapter = build_adapter(
-        &out_dir,
-        "command",
-        &["--no-default-features", "--features=command"],
-    );
-
-    println!("cargo:rerun-if-changed=./wasi-tests");
-    println!("cargo:rerun-if-changed=./command-tests");
-    println!("cargo:rerun-if-changed=./reactor-tests");
-    println!("cargo:rerun-if-changed=./wasi-sockets-tests");
-    if BUILD_WASI_HTTP_TESTS {
-        println!("cargo:rerun-if-changed=./wasi-http-tests");
-        println!("cargo:rerun-if-changed=./wasi-http-proxy-tests");
-    } else {
-        println!("cargo:rustc-cfg=skip_wasi_http_tests");
-    }
-
-    // Build the test programs:
-    let mut cmd = Command::new("cargo");
-    cmd.arg("build")
-        .arg("--target=wasm32-wasi")
-        .arg("--package=wasi-tests")
-        .arg("--package=command-tests")
-        .arg("--package=reactor-tests")
-        .arg("--package=wasi-sockets-tests")
-        .env("CARGO_TARGET_DIR", &out_dir)
-        .env("CARGO_PROFILE_DEV_DEBUG", "1")
-        .env("RUSTFLAGS", rustflags())
-        .env_remove("CARGO_ENCODED_RUSTFLAGS");
-    if BUILD_WASI_HTTP_TESTS {
-        cmd.arg("--package=wasi-http-tests");
-        cmd.arg("--package=wasi-http-proxy-tests");
-    }
-    let status = cmd.status().unwrap();
-    assert!(status.success());
-
-    let meta = cargo_metadata::MetadataCommand::new().exec().unwrap();
-
-    modules_rs(&meta, "wasi-tests", "bin", &out_dir);
-    components_rs(&meta, "wasi-tests", "bin", &command_adapter, &out_dir);
-
-    if BUILD_WASI_HTTP_TESTS {
-        components_rs(&meta, "wasi-http-tests", "bin", &command_adapter, &out_dir);
-        components_rs(
-            &meta,
-            "wasi-http-proxy-tests",
-            "cdylib",
-            &reactor_adapter,
-            &out_dir,
-        );
-    }
-
-    components_rs(&meta, "command-tests", "bin", &command_adapter, &out_dir);
-    components_rs(&meta, "reactor-tests", "cdylib", &reactor_adapter, &out_dir);
-
-    components_rs(
-        &meta,
-        "wasi-sockets-tests",
-        "bin",
-        &command_adapter,
-        &out_dir,
-    );
-}
-
-// Creates an `${out_dir}/${package}_modules.rs` file that exposes a `get_module(&str) -> Module`,
-// and contains a `use self::{module} as _;` for each module that ensures that the user defines
-// a symbol (ideally a #[test]) corresponding to each module.
-fn modules_rs(meta: &cargo_metadata::Metadata, package: &str, kind: &str, out_dir: &PathBuf) {
-    let modules = targets_in_package(meta, package, kind)
-        .into_iter()
-        .map(|stem| {
-            (
-                stem.clone(),
-                out_dir
-                    .join("wasm32-wasi")
-                    .join("debug")
-                    .join(format!("{stem}.wasm"))
-                    .as_os_str()
-                    .to_str()
-                    .unwrap()
-                    .to_string(),
-            )
-        })
-        .collect::<Vec<_>>();
-
-    let mut decls = String::new();
-    let mut cases = String::new();
-    let mut uses = String::new();
-    for (stem, file) in modules {
-        let global = format!("{}_MODULE", stem.to_uppercase());
-        // Load the module from disk only once, in case it is used many times:
-        decls += &format!(
-            "
-            lazy_static::lazy_static!{{
-                static ref {global}: wasmtime::Module = {{
-                    wasmtime::Module::from_file(&ENGINE, {file:?}).unwrap()
-                }};
-            }}
-        "
-        );
-        // Match the stem str literal to the module. Cloning is just a ref count incr.
-        cases += &format!("{stem:?} => {global}.clone(),\n");
-        // Statically ensure that the user defines a function (ideally a #[test]) for each stem.
-        uses += &format!("#[allow(unused_imports)] use self::{stem} as _;\n");
-    }
-
-    std::fs::write(
-        out_dir.join(&format!("{}_modules.rs", package.to_snake_case())),
-        format!(
-            "
-        {decls}
-        pub fn get_module(s: &str) -> wasmtime::Module {{
-            match s {{
-                {cases}
-                _ => panic!(\"no such module: {{}}\", s),
-            }}
-        }}
-        {uses}
-        "
-        ),
-    )
-    .unwrap();
-}
-
-// Build the WASI Preview 1 adapter, and get the binary:
-fn build_adapter(out_dir: &PathBuf, name: &str, features: &[&str]) -> Vec<u8> {
-    println!("cargo:rerun-if-changed=../wasi-preview1-component-adapter");
-    let mut cmd = Command::new("cargo");
-    cmd.arg("build")
-        .arg("--release")
-        .arg("--package=wasi-preview1-component-adapter")
-        .arg("--target=wasm32-unknown-unknown")
-        .env("CARGO_TARGET_DIR", out_dir)
-        .env("RUSTFLAGS", rustflags())
-        .env_remove("CARGO_ENCODED_RUSTFLAGS");
-    for f in features {
-        cmd.arg(f);
-    }
-    let status = cmd.status().unwrap();
-    assert!(status.success());
-
-    let adapter = out_dir.join(format!("wasi_snapshot_preview1.{name}.wasm"));
-    std::fs::copy(
-        out_dir
-            .join("wasm32-unknown-unknown")
-            .join("release")
-            .join("wasi_snapshot_preview1.wasm"),
-        &adapter,
-    )
-    .unwrap();
-    println!("wasi {name} adapter: {:?}", &adapter);
-    fs::read(&adapter).unwrap()
-}
-
-fn rustflags() -> &'static str {
-    match option_env!("RUSTFLAGS") {
-        // If we're in CI which is denying warnings then deny warnings to code
-        // built here too to keep the tree warning-free.
-        Some(s) if s.contains("-D warnings") => "-D warnings",
-        _ => "",
-    }
-}
-
-// Builds components out of modules, and creates an `${out_dir}/${package}_component.rs` file that
-// exposes a `get_component(&str) -> Component`
-// and a contains a `use self::{component} as _;` for each module that ensures that the user defines
-// a symbol (ideally a #[test]) corresponding to each component.
-fn components_rs(
-    meta: &cargo_metadata::Metadata,
-    package: &str,
-    kind: &str,
-    adapter: &[u8],
-    out_dir: &PathBuf,
-) {
-    let mut decls = String::new();
-    let mut cases = String::new();
-    let mut uses = String::new();
-    for target_name in targets_in_package(&meta, package, kind) {
-        let stem = target_name.to_snake_case();
-        let file = compile_component(&stem, out_dir, adapter);
-
-        let global = format!("{}_COMPONENT", stem.to_uppercase());
-        decls += &format!(
-            "
-            lazy_static::lazy_static!{{
-                static ref {global}: wasmtime::component::Component = {{
-                    wasmtime::component::Component::from_file(&ENGINE, {file:?}).unwrap()
-                }};
-            }}
-        "
-        );
-        cases += &format!("{stem:?} => {global}.clone(),\n");
-        uses += &format!("#[allow(unused_imports)] use self::{stem} as _;\n");
-    }
-
-    std::fs::write(
-        out_dir.join(&format!("{}_components.rs", package.to_snake_case())),
-        format!(
-            "
-        {decls}
-        pub fn get_component(s: &str) -> wasmtime::component::Component {{
-            match s {{
-                {cases}
-                _ => panic!(\"no such component: {{}}\", s),
-            }}
-        }}
-        {uses}
-        "
-        ),
-    )
-    .unwrap();
-}
-
-// Compile a component, return the path of the binary:
-fn compile_component(stem: &str, out_dir: &PathBuf, adapter: &[u8]) -> PathBuf {
-    let file = out_dir
-        .join("wasm32-wasi")
-        .join("debug")
-        .join(format!("{stem}.wasm"));
-    let module = fs::read(&file).expect("read wasm module");
-    let component = ComponentEncoder::default()
-        .module(module.as_slice())
-        .unwrap()
-        .validate(true)
-        .adapter("wasi_snapshot_preview1", adapter)
-        .unwrap()
-        .encode()
-        .expect(&format!(
-            "module {:?} can be translated to a component",
-            file
-        ));
-    let component_path = out_dir.join(format!("{}.component.wasm", &stem));
-    fs::write(&component_path, component).expect("write component to disk");
-    component_path
-}
-
-// Get all targets in a given package with a given kind
-// kind is "bin" for test program crates that expose a `fn main`, and
-// "cdylib" for crates that implement a reactor.
-fn targets_in_package<'a>(
-    meta: &'a cargo_metadata::Metadata,
-    package: &'a str,
-    kind: &'a str,
-) -> Vec<String> {
-    let targets = meta
-        .packages
-        .iter()
-        .find(|p| p.name == package)
-        .unwrap()
-        .targets
-        .iter()
-        .filter(move |t| t.kind == &[kind])
-        .map(|t| t.name.to_snake_case())
-        .collect::<Vec<_>>();
-    if targets.is_empty() {
-        panic!("no targets for package {package:?} of kind {kind:?}")
-    }
-    targets
+    println!("cargo:rustc-link-arg-bin=dwarf_imported_memory=--import-memory");
+    println!("cargo:rustc-link-arg-bin=dwarf_imported_memory=--export-memory");
+    println!("cargo:rustc-link-arg-bin=dwarf_shared_memory=--no-check-features");
+    println!("cargo:rustc-link-arg-bin=dwarf_shared_memory=--shared-memory");
 }
diff --git a/crates/test-programs/command-tests/Cargo.toml b/crates/test-programs/command-tests/Cargo.toml
deleted file mode 100644
index a93cc2f0d598..000000000000
--- a/crates/test-programs/command-tests/Cargo.toml
+++ /dev/null
@@ -1,18 +0,0 @@
-[package]
-name = "command-tests"
-version = "0.0.0"
-edition = "2021"
-publish = false
-
-[dependencies]
-anyhow = { workspace = true }
-getrandom = "0.2.8"
-wit-bindgen = { workspace = true, default-features = true }
-
-# FIXME: building cap-std and rustix currently requires a nightly rust, so we
-# are not including it in the test suite.
-# The poll_stdin and file_dir_sync tests contain commented-out uses of these
-# crates. They should be re-enabled once these crates can build for
-# wasm32-wasi on stable rust.
-# rustix = { workspace = true }
-# cap-std = { workspace = true }
diff --git a/crates/test-programs/command-tests/src/bin/args.rs b/crates/test-programs/command-tests/src/bin/args.rs
deleted file mode 100644
index 8403f7de5901..000000000000
--- a/crates/test-programs/command-tests/src/bin/args.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-fn main() {
-    let args = std::env::args().collect::<Vec<_>>();
-    assert_eq!(
-        args,
-        ["hello", "this", "", "is an argument", "with 🚩 emoji"]
-    );
-}
diff --git a/crates/test-programs/command-tests/src/bin/panic.rs b/crates/test-programs/command-tests/src/bin/panic.rs
deleted file mode 100644
index bf9d3b49e41e..000000000000
--- a/crates/test-programs/command-tests/src/bin/panic.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-fn main() {
-    panic!("idk!!!");
-}
diff --git a/crates/test-programs/command-tests/src/bin/poll_stdin.rs b/crates/test-programs/command-tests/src/bin/poll_stdin.rs
deleted file mode 100644
index 71315db750ea..000000000000
--- a/crates/test-programs/command-tests/src/bin/poll_stdin.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-/* FIXME once rustix can build on stable rust, rewrite
-use rustix::io::{PollFd, PollFlags};
-
-fn main() {
-    let stdin = std::io::stdin();
-    let mut pollfds = vec![PollFd::new(&stdin, PollFlags::IN)];
-    let num = rustix::io::poll(&mut pollfds, -1).unwrap();
-    assert_eq!(num, 1);
-    assert_eq!(pollfds[0].revents(), PollFlags::IN);
-}
-*/
-fn main() {
-    println!("FIXME: this test does nothing for now");
-}
diff --git a/crates/test-programs/command-tests/src/bin/random.rs b/crates/test-programs/command-tests/src/bin/random.rs
deleted file mode 100644
index 663a01590fbd..000000000000
--- a/crates/test-programs/command-tests/src/bin/random.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-fn main() {
-    let mut bytes = [0_u8; 256];
-    getrandom::getrandom(&mut bytes).unwrap();
-
-    assert!(bytes.iter().any(|x| *x != 0));
-}
diff --git a/crates/test-programs/command-tests/src/bin/stream_pollable_lifetimes.rs b/crates/test-programs/command-tests/src/bin/stream_pollable_lifetimes.rs
deleted file mode 100644
index 8693e1f373d1..000000000000
--- a/crates/test-programs/command-tests/src/bin/stream_pollable_lifetimes.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-use command_tests::wasi::cli::environment;
-use command_tests::wasi::cli::stdin;
-use command_tests::wasi::io::poll;
-use command_tests::wasi::io::streams;
-
-fn main() {
-    let args = environment::get_arguments();
-
-    if args == &["correct"] {
-        let stdin: streams::InputStream = stdin::get_stdin();
-        let stdin_pollable = stdin.subscribe();
-        let ready = poll::poll_list(&[&stdin_pollable]);
-        assert_eq!(ready, &[0]);
-        drop(stdin_pollable);
-        drop(stdin);
-    } else if args == &["trap"] {
-        let stdin: streams::InputStream = stdin::get_stdin();
-        let stdin_pollable = stdin.subscribe();
-        let ready = poll::poll_list(&[&stdin_pollable]);
-        assert_eq!(ready, &[0]);
-        drop(stdin);
-        unreachable!(
-            "execution should have trapped in line above when stream dropped before pollable"
-        );
-    } else {
-        panic!("bad value for args: expected `[\"correct\"]` or `[\"trap\"]`, got {args:?}")
-    }
-}
diff --git a/crates/test-programs/command-tests/src/lib.rs b/crates/test-programs/command-tests/src/lib.rs
deleted file mode 100644
index 13a414db4af1..000000000000
--- a/crates/test-programs/command-tests/src/lib.rs
+++ /dev/null
@@ -1 +0,0 @@
-wit_bindgen::generate!("test-command" in "../../wasi/wit");
diff --git a/crates/test-programs/reactor-tests/Cargo.toml b/crates/test-programs/reactor-tests/Cargo.toml
deleted file mode 100644
index 28a645a9401e..000000000000
--- a/crates/test-programs/reactor-tests/Cargo.toml
+++ /dev/null
@@ -1,11 +0,0 @@
-[package]
-name = "reactor-tests"
-version = "0.1.0"
-edition = "2021"
-publish = false
-
-[lib]
-crate-type=["cdylib"]
-
-[dependencies]
-wit-bindgen = { workspace = true, features = ["macros", "realloc"] }
diff --git a/crates/test-programs/reactor-tests/src/lib.rs b/crates/test-programs/reactor-tests/src/lib.rs
deleted file mode 100644
index c5514d6a1505..000000000000
--- a/crates/test-programs/reactor-tests/src/lib.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-wit_bindgen::generate!({
-    world: "test-reactor",
-    path: "../../wasi/wit",
-    exports: {
-        world: T,
-    }
-});
-
-struct T;
-use wasi::io::poll;
-
-static mut STATE: Vec<String> = Vec::new();
-
-impl Guest for T {
-    fn add_strings(ss: Vec<String>) -> u32 {
-        for s in ss {
-            match s.split_once("$") {
-                Some((prefix, var)) if prefix.is_empty() => match std::env::var(var) {
-                    Ok(val) => unsafe { STATE.push(val) },
-                    Err(_) => unsafe { STATE.push("undefined".to_owned()) },
-                },
-                _ => unsafe { STATE.push(s) },
-            }
-        }
-        unsafe { STATE.len() as u32 }
-    }
-    fn get_strings() -> Vec<String> {
-        unsafe { STATE.clone() }
-    }
-
-    fn write_strings_to(o: OutputStream) -> Result<(), ()> {
-        let pollable = o.subscribe();
-        unsafe {
-            for s in STATE.iter() {
-                let mut out = s.as_bytes();
-                while !out.is_empty() {
-                    poll::poll_list(&[&pollable]);
-                    let n = match o.check_write() {
-                        Ok(n) => n,
-                        Err(_) => return Err(()),
-                    };
-
-                    let len = (n as usize).min(out.len());
-                    match o.write(&out[..len]) {
-                        Ok(_) => out = &out[len..],
-                        Err(_) => return Err(()),
-                    }
-                }
-            }
-
-            match o.flush() {
-                Ok(_) => {}
-                Err(_) => return Err(()),
-            }
-
-            poll::poll_list(&[&pollable]);
-            match o.check_write() {
-                Ok(_) => {}
-                Err(_) => return Err(()),
-            }
-
-            Ok(())
-        }
-    }
-    fn pass_an_imported_record(stat: wasi::filesystem::types::DescriptorStat) -> String {
-        format!("{stat:?}")
-    }
-}
diff --git a/crates/test-programs/src/bin/api_proxy.rs b/crates/test-programs/src/bin/api_proxy.rs
new file mode 100644
index 000000000000..bbbbecd1e2da
--- /dev/null
+++ b/crates/test-programs/src/bin/api_proxy.rs
@@ -0,0 +1,59 @@
+use test_programs::wasi::http::types::{
+    Headers, IncomingRequest, OutgoingBody, OutgoingResponse, ResponseOutparam,
+};
+
+struct T;
+
+test_programs::proxy::export!(T);
+
+impl test_programs::proxy::exports::wasi::http::incoming_handler::Guest for T {
+    fn handle(request: IncomingRequest, outparam: ResponseOutparam) {
+        assert!(request.scheme().is_some());
+        assert!(request.authority().is_some());
+        assert!(request.path_with_query().is_some());
+
+        test_filesystem();
+
+        let header = String::from("custom-forbidden-header");
+        let req_hdrs = request.headers();
+
+        assert!(
+            !req_hdrs.has(&header),
+            "forbidden `custom-forbidden-header` found in request"
+        );
+
+        assert!(req_hdrs.delete(&header).is_err());
+        assert!(req_hdrs.append(&header, &b"no".to_vec()).is_err());
+
+        assert!(
+            !req_hdrs.has(&header),
+            "append of forbidden header succeeded"
+        );
+
+        assert!(
+            !req_hdrs.has(&"host".to_owned()),
+            "forbidden host header present in incoming request"
+        );
+
+        let hdrs = Headers::new();
+        let resp = OutgoingResponse::new(hdrs);
+        let body = resp.body().expect("outgoing response");
+
+        ResponseOutparam::set(outparam, Ok(resp));
+
+        let out = body.write().expect("outgoing stream");
+        out.blocking_write_and_flush(b"hello, world!")
+            .expect("writing response");
+
+        drop(out);
+        OutgoingBody::finish(body, None).expect("outgoing-body.finish");
+    }
+}
+
+// Technically this should not be here for a proxy, but given the current
+// framework for tests it's required since this file is built as a `bin`
+fn main() {}
+
+fn test_filesystem() {
+    assert!(std::fs::File::open(".").is_err());
+}
diff --git a/crates/test-programs/src/bin/api_proxy_forward_request.rs b/crates/test-programs/src/bin/api_proxy_forward_request.rs
new file mode 100644
index 000000000000..8fb926cfe533
--- /dev/null
+++ b/crates/test-programs/src/bin/api_proxy_forward_request.rs
@@ -0,0 +1,42 @@
+use test_programs::wasi::http::types::{
+    Headers, IncomingRequest, OutgoingBody, OutgoingResponse, ResponseOutparam,
+};
+
+struct T;
+
+test_programs::proxy::export!(T);
+
+impl test_programs::proxy::exports::wasi::http::incoming_handler::Guest for T {
+    fn handle(request: IncomingRequest, outparam: ResponseOutparam) {
+        let res = test_programs::http::request(
+            request.method(),
+            request.scheme().unwrap(),
+            request.authority().unwrap().as_str(),
+            request.path_with_query().unwrap().as_str(),
+            None,
+            None,
+            None,
+            None,
+            None,
+        )
+        .unwrap();
+
+        let hdrs = Headers::from_list(&res.headers).unwrap();
+        let resp = OutgoingResponse::new(hdrs);
+        resp.set_status_code(res.status).expect("status code");
+        let body = resp.body().expect("outgoing response");
+
+        ResponseOutparam::set(outparam, Ok(resp));
+
+        let out = body.write().expect("outgoing stream");
+        out.blocking_write_and_flush(res.body.as_ref())
+            .expect("writing response");
+
+        drop(out);
+        OutgoingBody::finish(body, None).expect("outgoing-body.finish");
+    }
+}
+
+// Technically this should not be here for a proxy, but given the current
+// framework for tests it's required since this file is built as a `bin`
+fn main() {}
diff --git a/crates/test-programs/src/bin/api_proxy_streaming.rs b/crates/test-programs/src/bin/api_proxy_streaming.rs
new file mode 100644
index 000000000000..328e8a12d525
--- /dev/null
+++ b/crates/test-programs/src/bin/api_proxy_streaming.rs
@@ -0,0 +1,508 @@
+use anyhow::{anyhow, bail, Result};
+use futures::{future, stream, Future, SinkExt, StreamExt, TryStreamExt};
+use test_programs::wasi::http::types::{
+    Fields, IncomingRequest, IncomingResponse, Method, OutgoingBody, OutgoingRequest,
+    OutgoingResponse, ResponseOutparam, Scheme,
+};
+use url::Url;
+
+const MAX_CONCURRENCY: usize = 16;
+
+struct Handler;
+
+test_programs::proxy::export!(Handler);
+
+impl test_programs::proxy::exports::wasi::http::incoming_handler::Guest for Handler {
+    fn handle(request: IncomingRequest, response_out: ResponseOutparam) {
+        executor::run(async move {
+            handle_request(request, response_out).await;
+        })
+    }
+}
+
+async fn handle_request(request: IncomingRequest, response_out: ResponseOutparam) {
+    let headers = request.headers().entries();
+
+    assert!(request.authority().is_some());
+
+    match (request.method(), request.path_with_query().as_deref()) {
+        (Method::Get, Some("/hash-all")) => {
+            // Send outgoing GET requests to the specified URLs and stream the hashes of the response bodies as
+            // they arrive.
+
+            let urls = headers.iter().filter_map(|(k, v)| {
+                (k == "url")
+                    .then_some(v)
+                    .and_then(|v| std::str::from_utf8(v).ok())
+                    .and_then(|v| Url::parse(v).ok())
+            });
+
+            let results = urls.map(|url| async move {
+                let result = hash(&url).await;
+                (url, result)
+            });
+
+            let mut results = stream::iter(results).buffer_unordered(MAX_CONCURRENCY);
+
+            let response = OutgoingResponse::new(
+                Fields::from_list(&[("content-type".to_string(), b"text/plain".to_vec())]).unwrap(),
+            );
+
+            let mut body =
+                executor::outgoing_body(response.body().expect("response should be writable"));
+
+            ResponseOutparam::set(response_out, Ok(response));
+
+            while let Some((url, result)) = results.next().await {
+                let payload = match result {
+                    Ok(hash) => format!("{url}: {hash}\n"),
+                    Err(e) => format!("{url}: {e:?}\n"),
+                }
+                .into_bytes();
+
+                if let Err(e) = body.send(payload).await {
+                    eprintln!("Error sending payload: {e}");
+                }
+            }
+        }
+
+        (Method::Post, Some("/echo")) => {
+            // Echo the request body without buffering it.
+
+            let response = OutgoingResponse::new(
+                Fields::from_list(
+                    &headers
+                        .into_iter()
+                        .filter_map(|(k, v)| (k == "content-type").then_some((k, v)))
+                        .collect::<Vec<_>>(),
+                )
+                .unwrap(),
+            );
+
+            let mut body =
+                executor::outgoing_body(response.body().expect("response should be writable"));
+
+            ResponseOutparam::set(response_out, Ok(response));
+
+            let mut stream =
+                executor::incoming_body(request.consume().expect("request should be readable"));
+
+            while let Some(chunk) = stream.next().await {
+                match chunk {
+                    Ok(chunk) => {
+                        if let Err(e) = body.send(chunk).await {
+                            eprintln!("Error sending body: {e}");
+                            break;
+                        }
+                    }
+                    Err(e) => {
+                        eprintln!("Error receiving body: {e}");
+                        break;
+                    }
+                }
+            }
+        }
+
+        (Method::Post, Some("/double-echo")) => {
+            // Pipe the request body to an outgoing request and stream the response back to the client.
+
+            if let Some(url) = headers.iter().find_map(|(k, v)| {
+                (k == "url")
+                    .then_some(v)
+                    .and_then(|v| std::str::from_utf8(v).ok())
+                    .and_then(|v| Url::parse(v).ok())
+            }) {
+                match double_echo(request, &url).await {
+                    Ok((request_copy, response)) => {
+                        let mut stream = executor::incoming_body(
+                            response.consume().expect("response should be consumable"),
+                        );
+
+                        let response = OutgoingResponse::new(
+                            Fields::from_list(
+                                &headers
+                                    .into_iter()
+                                    .filter_map(|(k, v)| (k == "content-type").then_some((k, v)))
+                                    .collect::<Vec<_>>(),
+                            )
+                            .unwrap(),
+                        );
+
+                        let mut body = executor::outgoing_body(
+                            response.body().expect("response should be writable"),
+                        );
+
+                        ResponseOutparam::set(response_out, Ok(response));
+
+                        let response_copy = async move {
+                            while let Some(chunk) = stream.next().await {
+                                body.send(chunk?).await?;
+                            }
+                            Ok::<_, anyhow::Error>(())
+                        };
+
+                        let (request_copy, response_copy) =
+                            future::join(request_copy, response_copy).await;
+                        if let Err(e) = request_copy.and(response_copy) {
+                            eprintln!("error piping to and from {url}: {e}");
+                        }
+                    }
+
+                    Err(e) => {
+                        eprintln!("Error sending outgoing request to {url}: {e}");
+                        server_error(response_out);
+                    }
+                }
+            } else {
+                bad_request(response_out);
+            }
+        }
+
+        _ => method_not_allowed(response_out),
+    }
+}
+
+async fn double_echo(
+    incoming_request: IncomingRequest,
+    url: &Url,
+) -> Result<(impl Future<Output = Result<()>>, IncomingResponse)> {
+    let outgoing_request = OutgoingRequest::new(Fields::new());
+
+    outgoing_request
+        .set_method(&Method::Post)
+        .map_err(|()| anyhow!("failed to set method"))?;
+
+    outgoing_request
+        .set_path_with_query(Some(url.path()))
+        .map_err(|()| anyhow!("failed to set path_with_query"))?;
+
+    outgoing_request
+        .set_scheme(Some(&match url.scheme() {
+            "http" => Scheme::Http,
+            "https" => Scheme::Https,
+            scheme => Scheme::Other(scheme.into()),
+        }))
+        .map_err(|()| anyhow!("failed to set scheme"))?;
+
+    outgoing_request
+        .set_authority(Some(&format!(
+            "{}{}",
+            url.host_str().unwrap_or(""),
+            if let Some(port) = url.port() {
+                format!(":{port}")
+            } else {
+                String::new()
+            }
+        )))
+        .map_err(|()| anyhow!("failed to set authority"))?;
+
+    let mut body = executor::outgoing_body(
+        outgoing_request
+            .body()
+            .expect("request body should be writable"),
+    );
+
+    let response = executor::outgoing_request_send(outgoing_request);
+
+    let mut stream = executor::incoming_body(
+        incoming_request
+            .consume()
+            .expect("request should be consumable"),
+    );
+
+    let copy = async move {
+        while let Some(chunk) = stream.next().await {
+            body.send(chunk?).await?;
+        }
+        Ok::<_, anyhow::Error>(())
+    };
+
+    let response = response.await?;
+
+    let status = response.status();
+
+    if !(200..300).contains(&status) {
+        bail!("unexpected status: {status}");
+    }
+
+    Ok((copy, response))
+}
+
+fn server_error(response_out: ResponseOutparam) {
+    respond(500, response_out)
+}
+
+fn bad_request(response_out: ResponseOutparam) {
+    respond(400, response_out)
+}
+
+fn method_not_allowed(response_out: ResponseOutparam) {
+    respond(405, response_out)
+}
+
+fn respond(status: u16, response_out: ResponseOutparam) {
+    let response = OutgoingResponse::new(Fields::new());
+    response
+        .set_status_code(status)
+        .expect("setting status code");
+
+    let body = response.body().expect("response should be writable");
+
+    ResponseOutparam::set(response_out, Ok(response));
+
+    OutgoingBody::finish(body, None).expect("outgoing-body.finish");
+}
+
+async fn hash(url: &Url) -> Result<String> {
+    let request = OutgoingRequest::new(Fields::new());
+
+    request
+        .set_path_with_query(Some(url.path()))
+        .map_err(|()| anyhow!("failed to set path_with_query"))?;
+    request
+        .set_scheme(Some(&match url.scheme() {
+            "http" => Scheme::Http,
+            "https" => Scheme::Https,
+            scheme => Scheme::Other(scheme.into()),
+        }))
+        .map_err(|()| anyhow!("failed to set scheme"))?;
+    request
+        .set_authority(Some(&format!(
+            "{}{}",
+            url.host_str().unwrap_or(""),
+            if let Some(port) = url.port() {
+                format!(":{port}")
+            } else {
+                String::new()
+            }
+        )))
+        .map_err(|()| anyhow!("failed to set authority"))?;
+
+    let response = executor::outgoing_request_send(request).await?;
+
+    let status = response.status();
+
+    if !(200..300).contains(&status) {
+        bail!("unexpected status: {status}");
+    }
+
+    let mut body =
+        executor::incoming_body(response.consume().expect("response should be readable"));
+
+    use sha2::Digest;
+    let mut hasher = sha2::Sha256::new();
+    while let Some(chunk) = body.try_next().await? {
+        hasher.update(&chunk);
+    }
+
+    use base64::Engine;
+    Ok(base64::engine::general_purpose::STANDARD_NO_PAD.encode(hasher.finalize()))
+}
+
+// Technically this should not be here for a proxy, but given the current
+// framework for tests it's required since this file is built as a `bin`
+fn main() {}
+
+mod executor {
+    use anyhow::{anyhow, Error, Result};
+    use futures::{future, sink, stream, Sink, Stream};
+    use std::{
+        cell::RefCell,
+        future::Future,
+        mem,
+        rc::Rc,
+        sync::{Arc, Mutex},
+        task::{Context, Poll, Wake, Waker},
+    };
+    use test_programs::wasi::{
+        http::{
+            outgoing_handler,
+            types::{
+                self, IncomingBody, IncomingResponse, InputStream, OutgoingBody, OutgoingRequest,
+                OutputStream,
+            },
+        },
+        io::{self, streams::StreamError},
+    };
+
+    const READ_SIZE: u64 = 16 * 1024;
+
+    static WAKERS: Mutex<Vec<(io::poll::Pollable, Waker)>> = Mutex::new(Vec::new());
+
+    pub fn run<T>(future: impl Future<Output = T>) -> T {
+        futures::pin_mut!(future);
+
+        struct DummyWaker;
+
+        impl Wake for DummyWaker {
+            fn wake(self: Arc<Self>) {}
+        }
+
+        let waker = Arc::new(DummyWaker).into();
+
+        loop {
+            match future.as_mut().poll(&mut Context::from_waker(&waker)) {
+                Poll::Pending => {
+                    let mut new_wakers = Vec::new();
+
+                    let wakers = mem::take::<Vec<_>>(&mut WAKERS.lock().unwrap());
+
+                    assert!(!wakers.is_empty());
+
+                    let pollables = wakers
+                        .iter()
+                        .map(|(pollable, _)| pollable)
+                        .collect::<Vec<_>>();
+
+                    let mut ready = vec![false; wakers.len()];
+
+                    for index in io::poll::poll(&pollables) {
+                        ready[usize::try_from(index).unwrap()] = true;
+                    }
+
+                    for (ready, (pollable, waker)) in ready.into_iter().zip(wakers) {
+                        if ready {
+                            waker.wake()
+                        } else {
+                            new_wakers.push((pollable, waker));
+                        }
+                    }
+
+                    *WAKERS.lock().unwrap() = new_wakers;
+                }
+                Poll::Ready(result) => break result,
+            }
+        }
+    }
+
+    pub fn outgoing_body(body: OutgoingBody) -> impl Sink<Vec<u8>, Error = Error> {
+        struct Outgoing(Option<(OutputStream, OutgoingBody)>);
+
+        impl Drop for Outgoing {
+            fn drop(&mut self) {
+                if let Some((stream, body)) = self.0.take() {
+                    drop(stream);
+                    OutgoingBody::finish(body, None).expect("outgoing-body.finish");
+                }
+            }
+        }
+
+        let stream = body.write().expect("response body should be writable");
+        let pair = Rc::new(RefCell::new(Outgoing(Some((stream, body)))));
+
+        sink::unfold((), {
+            move |(), chunk: Vec<u8>| {
+                future::poll_fn({
+                    let mut offset = 0;
+                    let mut flushing = false;
+                    let pair = pair.clone();
+
+                    move |context| {
+                        let pair = pair.borrow();
+                        let (stream, _) = &pair.0.as_ref().unwrap();
+
+                        loop {
+                            match stream.check_write() {
+                                Ok(0) => {
+                                    WAKERS
+                                        .lock()
+                                        .unwrap()
+                                        .push((stream.subscribe(), context.waker().clone()));
+
+                                    break Poll::Pending;
+                                }
+                                Ok(count) => {
+                                    if offset == chunk.len() {
+                                        if flushing {
+                                            break Poll::Ready(Ok(()));
+                                        } else {
+                                            stream.flush().expect("stream should be flushable");
+                                            flushing = true;
+                                        }
+                                    } else {
+                                        let count = usize::try_from(count)
+                                            .unwrap()
+                                            .min(chunk.len() - offset);
+
+                                        match stream.write(&chunk[offset..][..count]) {
+                                            Ok(()) => {
+                                                offset += count;
+                                            }
+                                            Err(_) => break Poll::Ready(Err(anyhow!("I/O error"))),
+                                        }
+                                    }
+                                }
+                                Err(_) => break Poll::Ready(Err(anyhow!("I/O error"))),
+                            }
+                        }
+                    }
+                })
+            }
+        })
+    }
+
+    pub fn outgoing_request_send(
+        request: OutgoingRequest,
+    ) -> impl Future<Output = Result<IncomingResponse, types::ErrorCode>> {
+        future::poll_fn({
+            let response = outgoing_handler::handle(request, None);
+
+            move |context| match &response {
+                Ok(response) => {
+                    if let Some(response) = response.get() {
+                        Poll::Ready(response.unwrap())
+                    } else {
+                        WAKERS
+                            .lock()
+                            .unwrap()
+                            .push((response.subscribe(), context.waker().clone()));
+                        Poll::Pending
+                    }
+                }
+                Err(error) => Poll::Ready(Err(error.clone())),
+            }
+        })
+    }
+
+    pub fn incoming_body(body: IncomingBody) -> impl Stream<Item = Result<Vec<u8>>> {
+        struct Incoming(Option<(InputStream, IncomingBody)>);
+
+        impl Drop for Incoming {
+            fn drop(&mut self) {
+                if let Some((stream, body)) = self.0.take() {
+                    drop(stream);
+                    IncomingBody::finish(body);
+                }
+            }
+        }
+
+        stream::poll_fn({
+            let stream = body.stream().expect("response body should be readable");
+            let pair = Incoming(Some((stream, body)));
+
+            move |context| {
+                if let Some((stream, _)) = &pair.0 {
+                    match stream.read(READ_SIZE) {
+                        Ok(buffer) => {
+                            if buffer.is_empty() {
+                                WAKERS
+                                    .lock()
+                                    .unwrap()
+                                    .push((stream.subscribe(), context.waker().clone()));
+                                Poll::Pending
+                            } else {
+                                Poll::Ready(Some(Ok(buffer)))
+                            }
+                        }
+                        Err(StreamError::Closed) => Poll::Ready(None),
+                        Err(StreamError::LastOperationFailed(error)) => {
+                            Poll::Ready(Some(Err(anyhow!("{}", error.to_debug_string()))))
+                        }
+                    }
+                } else {
+                    Poll::Ready(None)
+                }
+            }
+        })
+    }
+}
diff --git a/crates/test-programs/src/bin/api_reactor.rs b/crates/test-programs/src/bin/api_reactor.rs
new file mode 100644
index 000000000000..ae8ecf9f939c
--- /dev/null
+++ b/crates/test-programs/src/bin/api_reactor.rs
@@ -0,0 +1,70 @@
+wit_bindgen::generate!({
+    world: "test-reactor",
+    path: "../wasi/wit",
+    generate_all,
+});
+
+struct T;
+
+export!(T);
+
+static mut STATE: Vec<String> = Vec::new();
+
+impl Guest for T {
+    fn add_strings(ss: Vec<String>) -> u32 {
+        for s in ss {
+            match s.split_once("$") {
+                Some((prefix, var)) if prefix.is_empty() => match std::env::var(var) {
+                    Ok(val) => unsafe { STATE.push(val) },
+                    Err(_) => unsafe { STATE.push("undefined".to_owned()) },
+                },
+                _ => unsafe { STATE.push(s) },
+            }
+        }
+        unsafe { STATE.len() as u32 }
+    }
+    fn get_strings() -> Vec<String> {
+        unsafe { STATE.clone() }
+    }
+
+    fn write_strings_to(o: OutputStream) -> Result<(), ()> {
+        let pollable = o.subscribe();
+        unsafe {
+            for s in STATE.iter() {
+                let mut out = s.as_bytes();
+                while !out.is_empty() {
+                    pollable.block();
+                    let n = match o.check_write() {
+                        Ok(n) => n,
+                        Err(_) => return Err(()),
+                    };
+
+                    let len = (n as usize).min(out.len());
+                    match o.write(&out[..len]) {
+                        Ok(_) => out = &out[len..],
+                        Err(_) => return Err(()),
+                    }
+                }
+            }
+
+            match o.flush() {
+                Ok(_) => {}
+                Err(_) => return Err(()),
+            }
+            pollable.block();
+            match o.check_write() {
+                Ok(_) => {}
+                Err(_) => return Err(()),
+            }
+
+            Ok(())
+        }
+    }
+    fn pass_an_imported_record(stat: wasi::filesystem::types::DescriptorStat) -> String {
+        format!("{stat:?}")
+    }
+}
+
+// Technically this should not be here for a reactor, but given the current
+// framework for tests it's required since this file is built as a `bin`
+fn main() {}
diff --git a/crates/test-programs/command-tests/src/bin/read_only.rs b/crates/test-programs/src/bin/api_read_only.rs
similarity index 100%
rename from crates/test-programs/command-tests/src/bin/read_only.rs
rename to crates/test-programs/src/bin/api_read_only.rs
diff --git a/crates/test-programs/command-tests/src/bin/time.rs b/crates/test-programs/src/bin/api_time.rs
similarity index 100%
rename from crates/test-programs/command-tests/src/bin/time.rs
rename to crates/test-programs/src/bin/api_time.rs
diff --git a/crates/test-programs/src/bin/cli_args.rs b/crates/test-programs/src/bin/cli_args.rs
new file mode 100644
index 000000000000..e152e452ee3f
--- /dev/null
+++ b/crates/test-programs/src/bin/cli_args.rs
@@ -0,0 +1,7 @@
+fn main() {
+    let args = std::env::args().skip(1).collect::<Vec<_>>();
+    assert_eq!(
+        args,
+        ["hello", "this", "", "is an argument", "with 🚩 emoji"]
+    );
+}
diff --git a/crates/test-programs/src/bin/cli_argv0.rs b/crates/test-programs/src/bin/cli_argv0.rs
new file mode 100644
index 000000000000..d64562fb8fa4
--- /dev/null
+++ b/crates/test-programs/src/bin/cli_argv0.rs
@@ -0,0 +1,4 @@
+fn main() {
+    let mut args = std::env::args();
+    assert_eq!(args.next(), args.next());
+}
diff --git a/crates/test-programs/command-tests/src/bin/default_clocks.rs b/crates/test-programs/src/bin/cli_default_clocks.rs
similarity index 100%
rename from crates/test-programs/command-tests/src/bin/default_clocks.rs
rename to crates/test-programs/src/bin/cli_default_clocks.rs
diff --git a/crates/test-programs/command-tests/src/bin/directory_list.rs b/crates/test-programs/src/bin/cli_directory_list.rs
similarity index 100%
rename from crates/test-programs/command-tests/src/bin/directory_list.rs
rename to crates/test-programs/src/bin/cli_directory_list.rs
diff --git a/crates/test-programs/command-tests/src/bin/env.rs b/crates/test-programs/src/bin/cli_env.rs
similarity index 100%
rename from crates/test-programs/command-tests/src/bin/env.rs
rename to crates/test-programs/src/bin/cli_env.rs
diff --git a/crates/test-programs/command-tests/src/bin/exit_default.rs b/crates/test-programs/src/bin/cli_exit_default.rs
similarity index 100%
rename from crates/test-programs/command-tests/src/bin/exit_default.rs
rename to crates/test-programs/src/bin/cli_exit_default.rs
diff --git a/crates/test-programs/command-tests/src/bin/exit_failure.rs b/crates/test-programs/src/bin/cli_exit_failure.rs
similarity index 100%
rename from crates/test-programs/command-tests/src/bin/exit_failure.rs
rename to crates/test-programs/src/bin/cli_exit_failure.rs
diff --git a/crates/test-programs/command-tests/src/bin/exit_panic.rs b/crates/test-programs/src/bin/cli_exit_panic.rs
similarity index 100%
rename from crates/test-programs/command-tests/src/bin/exit_panic.rs
rename to crates/test-programs/src/bin/cli_exit_panic.rs
diff --git a/crates/test-programs/command-tests/src/bin/exit_success.rs b/crates/test-programs/src/bin/cli_exit_success.rs
similarity index 100%
rename from crates/test-programs/command-tests/src/bin/exit_success.rs
rename to crates/test-programs/src/bin/cli_exit_success.rs
diff --git a/crates/test-programs/command-tests/src/bin/export_cabi_realloc.rs b/crates/test-programs/src/bin/cli_export_cabi_realloc.rs
similarity index 100%
rename from crates/test-programs/command-tests/src/bin/export_cabi_realloc.rs
rename to crates/test-programs/src/bin/cli_export_cabi_realloc.rs
diff --git a/crates/test-programs/command-tests/src/bin/file_append.rs b/crates/test-programs/src/bin/cli_file_append.rs
similarity index 100%
rename from crates/test-programs/command-tests/src/bin/file_append.rs
rename to crates/test-programs/src/bin/cli_file_append.rs
diff --git a/crates/test-programs/command-tests/src/bin/file_dir_sync.rs b/crates/test-programs/src/bin/cli_file_dir_sync.rs
similarity index 100%
rename from crates/test-programs/command-tests/src/bin/file_dir_sync.rs
rename to crates/test-programs/src/bin/cli_file_dir_sync.rs
diff --git a/crates/test-programs/command-tests/src/bin/file_read.rs b/crates/test-programs/src/bin/cli_file_read.rs
similarity index 100%
rename from crates/test-programs/command-tests/src/bin/file_read.rs
rename to crates/test-programs/src/bin/cli_file_read.rs
diff --git a/crates/test-programs/command-tests/src/bin/hello_stdout.rs b/crates/test-programs/src/bin/cli_hello_stdout.rs
similarity index 100%
rename from crates/test-programs/command-tests/src/bin/hello_stdout.rs
rename to crates/test-programs/src/bin/cli_hello_stdout.rs
diff --git a/crates/test-programs/src/bin/cli_large_env.rs b/crates/test-programs/src/bin/cli_large_env.rs
new file mode 100644
index 000000000000..7d4a69b5d9b3
--- /dev/null
+++ b/crates/test-programs/src/bin/cli_large_env.rs
@@ -0,0 +1,5 @@
+fn main() {
+    for (k, v) in std::env::vars() {
+        println!("{k}={v}");
+    }
+}
diff --git a/crates/test-programs/src/bin/cli_no_ip_name_lookup.rs b/crates/test-programs/src/bin/cli_no_ip_name_lookup.rs
new file mode 100644
index 000000000000..c0aeb1329ce3
--- /dev/null
+++ b/crates/test-programs/src/bin/cli_no_ip_name_lookup.rs
@@ -0,0 +1,15 @@
+//! This test assumes that it will be run without ip lookup support enabled
+use test_programs::wasi::sockets::{
+    ip_name_lookup::{ErrorCode, IpAddress},
+    network::Network,
+};
+
+fn main() {
+    let res = resolve("example.com");
+    eprintln!("Result of resolve: {res:?}");
+    assert!(matches!(res, Err(ErrorCode::PermanentResolverFailure)));
+}
+
+fn resolve(name: &str) -> Result<Vec<IpAddress>, ErrorCode> {
+    Network::default().permissive_blocking_resolve_addresses(name)
+}
diff --git a/crates/test-programs/src/bin/cli_no_tcp.rs b/crates/test-programs/src/bin/cli_no_tcp.rs
new file mode 100644
index 000000000000..58ca3de8958d
--- /dev/null
+++ b/crates/test-programs/src/bin/cli_no_tcp.rs
@@ -0,0 +1,28 @@
+//! This test assumes that it will be run without tcp support enabled
+use test_programs::wasi::sockets::{
+    network::IpAddress,
+    tcp::{ErrorCode, IpAddressFamily, IpSocketAddress, Network, TcpSocket},
+};
+
+fn main() {
+    let net = Network::default();
+    let family = IpAddressFamily::Ipv4;
+    let remote1 = IpSocketAddress::new(IpAddress::new_loopback(family), 4321);
+    let sock = TcpSocket::new(family).unwrap();
+
+    let bind = sock.blocking_bind(&net, remote1);
+    eprintln!("Result of binding: {bind:?}");
+    assert!(matches!(bind, Err(ErrorCode::AccessDenied)));
+
+    let listen = sock.blocking_listen();
+    eprintln!("Result of listen: {listen:?}");
+    assert!(matches!(listen, Err(ErrorCode::AccessDenied)));
+
+    let connect = sock.blocking_connect(&net, remote1);
+    eprintln!("Result of connect: {connect:?}");
+    assert!(matches!(connect, Err(ErrorCode::AccessDenied)));
+
+    let accept = sock.blocking_accept();
+    eprintln!("Result of accept: {accept:?}");
+    assert!(matches!(accept, Err(ErrorCode::AccessDenied)));
+}
diff --git a/crates/test-programs/src/bin/cli_no_udp.rs b/crates/test-programs/src/bin/cli_no_udp.rs
new file mode 100644
index 000000000000..1dd0240612db
--- /dev/null
+++ b/crates/test-programs/src/bin/cli_no_udp.rs
@@ -0,0 +1,16 @@
+//! This test assumes that it will be run without udp support enabled
+use test_programs::wasi::sockets::{
+    network::IpAddress,
+    udp::{ErrorCode, IpAddressFamily, IpSocketAddress, Network, UdpSocket},
+};
+
+fn main() {
+    let net = Network::default();
+    let family = IpAddressFamily::Ipv4;
+    let remote1 = IpSocketAddress::new(IpAddress::new_loopback(family), 4321);
+    let sock = UdpSocket::new(family).unwrap();
+
+    let bind = sock.blocking_bind(&net, remote1);
+    eprintln!("Result of binding: {bind:?}");
+    assert!(matches!(bind, Err(ErrorCode::AccessDenied)));
+}
diff --git a/crates/test-programs/src/bin/cli_serve_authority_and_scheme.rs b/crates/test-programs/src/bin/cli_serve_authority_and_scheme.rs
new file mode 100644
index 000000000000..604edc07c865
--- /dev/null
+++ b/crates/test-programs/src/bin/cli_serve_authority_and_scheme.rs
@@ -0,0 +1,26 @@
+use test_programs::proxy;
+use test_programs::wasi::http::types::{
+    Fields, IncomingRequest, OutgoingResponse, ResponseOutparam, Scheme,
+};
+
+struct T;
+
+proxy::export!(T);
+
+impl proxy::exports::wasi::http::incoming_handler::Guest for T {
+    fn handle(request: IncomingRequest, outparam: ResponseOutparam) {
+        let authority = request.authority();
+        let scheme = request.scheme();
+
+        assert_eq!(authority.as_deref(), Some("localhost"));
+        assert!(
+            matches!(scheme, Some(Scheme::Http)),
+            "bad scheme: {scheme:?}",
+        );
+
+        let resp = OutgoingResponse::new(Fields::new());
+        ResponseOutparam::set(outparam, Ok(resp));
+    }
+}
+
+fn main() {}
diff --git a/crates/test-programs/src/bin/cli_serve_echo_env.rs b/crates/test-programs/src/bin/cli_serve_echo_env.rs
new file mode 100644
index 000000000000..94294cc0ae83
--- /dev/null
+++ b/crates/test-programs/src/bin/cli_serve_echo_env.rs
@@ -0,0 +1,26 @@
+use test_programs::proxy;
+use test_programs::wasi::http::types::{
+    Fields, IncomingRequest, OutgoingResponse, ResponseOutparam,
+};
+
+struct T;
+
+proxy::export!(T);
+
+impl proxy::exports::wasi::http::incoming_handler::Guest for T {
+    fn handle(request: IncomingRequest, outparam: ResponseOutparam) {
+        let headers = request.headers();
+        let header_key = "env".to_string();
+        let env_var = headers.get(&header_key);
+        assert!(env_var.len() == 1, "should have exactly one `env` header");
+        let key = std::str::from_utf8(&env_var[0]).unwrap();
+        let fields = Fields::new();
+        if let Ok(val) = std::env::var(key) {
+            fields.set(&header_key, &[val.into_bytes()]).unwrap();
+        }
+        let resp = OutgoingResponse::new(fields);
+        ResponseOutparam::set(outparam, Ok(resp));
+    }
+}
+
+fn main() {}
diff --git a/crates/test-programs/src/bin/cli_serve_keyvalue.rs b/crates/test-programs/src/bin/cli_serve_keyvalue.rs
new file mode 100644
index 000000000000..be806d390b63
--- /dev/null
+++ b/crates/test-programs/src/bin/cli_serve_keyvalue.rs
@@ -0,0 +1,30 @@
+use test_programs::proxy;
+use test_programs::wasi::{
+    http::types::{Fields, IncomingRequest, OutgoingBody, OutgoingResponse, ResponseOutparam},
+    keyvalue,
+};
+
+struct T;
+
+proxy::export!(T);
+
+impl proxy::exports::wasi::http::incoming_handler::Guest for T {
+    fn handle(_: IncomingRequest, outparam: ResponseOutparam) {
+        let fields = Fields::new();
+        let resp = OutgoingResponse::new(fields);
+        let body = resp.body().expect("outgoing response");
+
+        ResponseOutparam::set(outparam, Ok(resp));
+
+        let out = body.write().expect("outgoing stream");
+        let bucket = keyvalue::store::open("").unwrap();
+        let data = bucket.get("hello").unwrap().unwrap();
+        out.blocking_write_and_flush(&data)
+            .expect("writing response");
+
+        drop(out);
+        OutgoingBody::finish(body, None).expect("outgoing-body.finish");
+    }
+}
+
+fn main() {}
diff --git a/crates/test-programs/src/bin/cli_serve_runtime_config.rs b/crates/test-programs/src/bin/cli_serve_runtime_config.rs
new file mode 100644
index 000000000000..d56227dc4039
--- /dev/null
+++ b/crates/test-programs/src/bin/cli_serve_runtime_config.rs
@@ -0,0 +1,29 @@
+use test_programs::proxy;
+use test_programs::wasi::{
+    config::runtime,
+    http::types::{Fields, IncomingRequest, OutgoingBody, OutgoingResponse, ResponseOutparam},
+};
+
+struct T;
+
+proxy::export!(T);
+
+impl proxy::exports::wasi::http::incoming_handler::Guest for T {
+    fn handle(_: IncomingRequest, outparam: ResponseOutparam) {
+        let fields = Fields::new();
+        let resp = OutgoingResponse::new(fields);
+        let body = resp.body().expect("outgoing response");
+
+        ResponseOutparam::set(outparam, Ok(resp));
+
+        let out = body.write().expect("outgoing stream");
+        let config = runtime::get("hello").unwrap().unwrap();
+        out.blocking_write_and_flush(config.as_bytes())
+            .expect("writing response");
+
+        drop(out);
+        OutgoingBody::finish(body, None).expect("outgoing-body.finish");
+    }
+}
+
+fn main() {}
diff --git a/crates/test-programs/src/bin/cli_serve_with_print.rs b/crates/test-programs/src/bin/cli_serve_with_print.rs
new file mode 100644
index 000000000000..424eb841cf47
--- /dev/null
+++ b/crates/test-programs/src/bin/cli_serve_with_print.rs
@@ -0,0 +1,30 @@
+use std::io::Write;
+use test_programs::proxy;
+use test_programs::wasi::http::types::{
+    Fields, IncomingRequest, OutgoingResponse, ResponseOutparam,
+};
+
+struct T;
+
+proxy::export!(T);
+
+impl proxy::exports::wasi::http::incoming_handler::Guest for T {
+    fn handle(_request: IncomingRequest, outparam: ResponseOutparam) {
+        print!("this is half a print ");
+        std::io::stdout().flush().unwrap();
+        println!("to stdout");
+        println!(); // empty line
+        println!("after empty");
+
+        eprint!("this is half a print ");
+        std::io::stderr().flush().unwrap();
+        eprintln!("to stderr");
+        eprintln!(); // empty line
+        eprintln!("after empty");
+
+        let resp = OutgoingResponse::new(Fields::new());
+        ResponseOutparam::set(outparam, Ok(resp));
+    }
+}
+
+fn main() {}
diff --git a/crates/test-programs/src/bin/cli_sleep.rs b/crates/test-programs/src/bin/cli_sleep.rs
new file mode 100644
index 000000000000..ff5beef8260c
--- /dev/null
+++ b/crates/test-programs/src/bin/cli_sleep.rs
@@ -0,0 +1,5 @@
+use std::time::Duration;
+
+fn main() {
+    std::thread::sleep(Duration::from_nanos(100));
+}
diff --git a/crates/test-programs/src/bin/cli_sleep_forever.rs b/crates/test-programs/src/bin/cli_sleep_forever.rs
new file mode 100644
index 000000000000..f2be9622ceab
--- /dev/null
+++ b/crates/test-programs/src/bin/cli_sleep_forever.rs
@@ -0,0 +1,5 @@
+use std::time::Duration;
+
+fn main() {
+    std::thread::sleep(Duration::from_nanos(u64::MAX));
+}
diff --git a/crates/test-programs/src/bin/cli_splice_stdin.rs b/crates/test-programs/src/bin/cli_splice_stdin.rs
new file mode 100644
index 000000000000..66e14b4f42ef
--- /dev/null
+++ b/crates/test-programs/src/bin/cli_splice_stdin.rs
@@ -0,0 +1,24 @@
+use test_programs::wasi::cli::{stdin, stdout};
+use test_programs::wasi::io::streams::StreamError;
+
+fn main() {
+    println!("before splice");
+    let stdout = stdout::get_stdout();
+    let stdin = stdin::get_stdin();
+
+    let mut spliced = 0;
+    loop {
+        match stdout.blocking_splice(&stdin, 4096) {
+            Ok(n) => spliced += n as usize,
+            Err(StreamError::Closed) => break,
+            Err(StreamError::LastOperationFailed(f)) => {
+                panic!("stream failure: {}", f.to_debug_string())
+            }
+        }
+    }
+    let _ = stdin;
+    stdout.blocking_flush().unwrap();
+    let _ = stdout;
+
+    println!("\ncompleted splicing {spliced} bytes");
+}
diff --git a/crates/test-programs/command-tests/src/bin/stdin.rs b/crates/test-programs/src/bin/cli_stdin.rs
similarity index 100%
rename from crates/test-programs/command-tests/src/bin/stdin.rs
rename to crates/test-programs/src/bin/cli_stdin.rs
diff --git a/crates/test-programs/src/bin/cli_stdio_write_flushes.rs b/crates/test-programs/src/bin/cli_stdio_write_flushes.rs
new file mode 100644
index 000000000000..64d0ccdc6443
--- /dev/null
+++ b/crates/test-programs/src/bin/cli_stdio_write_flushes.rs
@@ -0,0 +1,10 @@
+use std::io::Write;
+
+fn main() {
+    print!("> ");
+    std::io::stdout().flush().unwrap();
+
+    let mut s = String::new();
+    std::io::stdin().read_line(&mut s).unwrap();
+    assert!(s.is_empty());
+}
diff --git a/crates/test-programs/src/bin/dwarf_imported_memory.rs b/crates/test-programs/src/bin/dwarf_imported_memory.rs
new file mode 100644
index 000000000000..fe4ca3784c2d
--- /dev/null
+++ b/crates/test-programs/src/bin/dwarf_imported_memory.rs
@@ -0,0 +1 @@
+include!("./dwarf_simple.rs");
diff --git a/crates/test-programs/src/bin/dwarf_multiple_codegen_units.rs b/crates/test-programs/src/bin/dwarf_multiple_codegen_units.rs
new file mode 100644
index 000000000000..afbfa94ffc1e
--- /dev/null
+++ b/crates/test-programs/src/bin/dwarf_multiple_codegen_units.rs
@@ -0,0 +1,14 @@
+fn main() {
+    let a = 3;
+    foo::bar(a);
+}
+
+mod foo {
+    pub fn bar(x: u32) -> u32 {
+        let mut sum = 0;
+        for i in 0..x {
+            sum += i;
+        }
+        sum
+    }
+}
diff --git a/crates/test-programs/src/bin/dwarf_shared_memory.rs b/crates/test-programs/src/bin/dwarf_shared_memory.rs
new file mode 100644
index 000000000000..fe4ca3784c2d
--- /dev/null
+++ b/crates/test-programs/src/bin/dwarf_shared_memory.rs
@@ -0,0 +1 @@
+include!("./dwarf_simple.rs");
diff --git a/crates/test-programs/src/bin/dwarf_simple.rs b/crates/test-programs/src/bin/dwarf_simple.rs
new file mode 100644
index 000000000000..ce79fa54e58f
--- /dev/null
+++ b/crates/test-programs/src/bin/dwarf_simple.rs
@@ -0,0 +1,6 @@
+fn main() {
+    let mut a = 100;
+    a += 10;
+    let b = a + 7;
+    println!("{b}");
+}
diff --git a/crates/test-programs/src/bin/http_outbound_request_content_length.rs b/crates/test-programs/src/bin/http_outbound_request_content_length.rs
new file mode 100644
index 000000000000..59b6254316ab
--- /dev/null
+++ b/crates/test-programs/src/bin/http_outbound_request_content_length.rs
@@ -0,0 +1,97 @@
+use test_programs::wasi::http::types as http_types;
+
+fn make_request() -> http_types::OutgoingRequest {
+    let request = http_types::OutgoingRequest::new(
+        http_types::Headers::from_list(&[("Content-Length".to_string(), b"11".to_vec())]).unwrap(),
+    );
+
+    request
+        .set_method(&http_types::Method::Post)
+        .expect("setting method");
+    request
+        .set_scheme(Some(&http_types::Scheme::Http))
+        .expect("setting scheme");
+    let addr = std::env::var("HTTP_SERVER").unwrap();
+    request
+        .set_authority(Some(&addr))
+        .expect("setting authority");
+    request
+        .set_path_with_query(Some("/"))
+        .expect("setting path with query");
+
+    request
+}
+
+fn main() {
+    {
+        println!("writing enough");
+        let request = make_request();
+        let outgoing_body = request.body().unwrap();
+
+        {
+            let request_body = outgoing_body.write().unwrap();
+            request_body
+                .blocking_write_and_flush("long enough".as_bytes())
+                .unwrap();
+        }
+
+        http_types::OutgoingBody::finish(outgoing_body, None).expect("enough written")
+    }
+
+    {
+        println!("writing too little");
+        let request = make_request();
+        let outgoing_body = request.body().unwrap();
+
+        {
+            let request_body = outgoing_body.write().unwrap();
+            request_body
+                .blocking_write_and_flush("msg".as_bytes())
+                .unwrap();
+        }
+
+        let e =
+            http_types::OutgoingBody::finish(outgoing_body, None).expect_err("finish should fail");
+
+        assert!(
+            matches!(&e, http_types::ErrorCode::HttpRequestBodySize(Some(3))),
+            "unexpected error: {e:#?}"
+        );
+    }
+
+    {
+        println!("writing too much");
+        let request = make_request();
+        let outgoing_body = request.body().unwrap();
+
+        {
+            let request_body = outgoing_body.write().unwrap();
+            let e = request_body
+                .blocking_write_and_flush("more than 11 bytes".as_bytes())
+                .expect_err("write should fail");
+
+            let e = match e {
+                test_programs::wasi::io::streams::StreamError::LastOperationFailed(e) => {
+                    http_types::http_error_code(&e)
+                }
+                test_programs::wasi::io::streams::StreamError::Closed => panic!("request closed"),
+            };
+
+            assert!(
+                matches!(
+                    e,
+                    Some(http_types::ErrorCode::HttpRequestBodySize(Some(18)))
+                ),
+                "unexpected error {e:?}"
+            );
+        }
+
+        let e =
+            http_types::OutgoingBody::finish(outgoing_body, None).expect_err("finish should fail");
+
+        assert!(
+            matches!(&e, http_types::ErrorCode::HttpRequestBodySize(Some(18))),
+            "unexpected error: {e:#?}"
+        );
+    }
+}
diff --git a/crates/test-programs/src/bin/http_outbound_request_get.rs b/crates/test-programs/src/bin/http_outbound_request_get.rs
new file mode 100644
index 000000000000..ab12935c2ed2
--- /dev/null
+++ b/crates/test-programs/src/bin/http_outbound_request_get.rs
@@ -0,0 +1,30 @@
+use anyhow::Context;
+use test_programs::wasi::http::types::{Method, Scheme};
+
+fn main() {
+    let addr = std::env::var("HTTP_SERVER").unwrap();
+    let res = test_programs::http::request(
+        Method::Get,
+        Scheme::Http,
+        &addr,
+        "/get?some=arg&goes=here",
+        None,
+        None,
+        None,
+        None,
+        None,
+    )
+    .context("/get")
+    .unwrap();
+
+    println!("{addr} /get: {res:?}");
+    assert_eq!(res.status, 200);
+    let method = res.header("x-wasmtime-test-method").unwrap();
+    assert_eq!(std::str::from_utf8(method).unwrap(), "GET");
+    let uri = res.header("x-wasmtime-test-uri").unwrap();
+    assert_eq!(
+        std::str::from_utf8(uri).unwrap(),
+        format!("/get?some=arg&goes=here")
+    );
+    assert_eq!(res.body, b"");
+}
diff --git a/crates/test-programs/src/bin/http_outbound_request_invalid_dnsname.rs b/crates/test-programs/src/bin/http_outbound_request_invalid_dnsname.rs
new file mode 100644
index 000000000000..a566b873cdb8
--- /dev/null
+++ b/crates/test-programs/src/bin/http_outbound_request_invalid_dnsname.rs
@@ -0,0 +1,25 @@
+use test_programs::wasi::http::types::{ErrorCode, Method, Scheme};
+
+fn main() {
+    let res = test_programs::http::request(
+        Method::Get,
+        Scheme::Http,
+        "some.invalid.dnsname:3000",
+        "/",
+        None,
+        None,
+        None,
+        None,
+        None,
+    );
+
+    let e = res.unwrap_err();
+    assert!(
+        matches!(
+            e.downcast_ref::<ErrorCode>()
+                .expect("expected a wasi-http ErrorCode"),
+            ErrorCode::DnsError(_) | ErrorCode::ConnectionRefused,
+        ),
+        "Unexpected error: {e:#?}"
+    );
+}
diff --git a/crates/test-programs/src/bin/http_outbound_request_invalid_header.rs b/crates/test-programs/src/bin/http_outbound_request_invalid_header.rs
new file mode 100644
index 000000000000..1f532ee25e2c
--- /dev/null
+++ b/crates/test-programs/src/bin/http_outbound_request_invalid_header.rs
@@ -0,0 +1,83 @@
+use test_programs::wasi::http::types::{HeaderError, Headers, OutgoingRequest};
+
+fn main() {
+    let hdrs = Headers::new();
+    assert!(matches!(
+        hdrs.append(&"malformed header name".to_owned(), &b"ok value".to_vec()),
+        Err(HeaderError::InvalidSyntax)
+    ));
+
+    assert!(matches!(
+        hdrs.append(&"ok-header-name".to_owned(), &b"ok value".to_vec()),
+        Ok(())
+    ));
+
+    assert!(matches!(
+        hdrs.append(&"ok-header-name".to_owned(), &b"bad\nvalue".to_vec()),
+        Err(HeaderError::InvalidSyntax)
+    ));
+
+    assert!(matches!(
+        hdrs.append(&"Connection".to_owned(), &b"keep-alive".to_vec()),
+        Err(HeaderError::Forbidden)
+    ));
+
+    assert!(matches!(
+        hdrs.append(&"Keep-Alive".to_owned(), &b"stuff".to_vec()),
+        Err(HeaderError::Forbidden)
+    ));
+
+    assert!(matches!(
+        hdrs.append(&"Host".to_owned(), &b"example.com".to_vec()),
+        Err(HeaderError::Forbidden)
+    ));
+
+    assert!(matches!(
+        hdrs.append(
+            &"custom-forbidden-header".to_owned(),
+            &b"keep-alive".to_vec()
+        ),
+        Err(HeaderError::Forbidden)
+    ));
+
+    assert!(matches!(
+        hdrs.append(
+            &"Custom-Forbidden-Header".to_owned(),
+            &b"keep-alive".to_vec()
+        ),
+        Err(HeaderError::Forbidden)
+    ));
+
+    assert!(matches!(
+        Headers::from_list(&[("bad header".to_owned(), b"value".to_vec())]),
+        Err(HeaderError::InvalidSyntax)
+    ));
+
+    assert!(matches!(
+        Headers::from_list(&[("custom-forbidden-header".to_owned(), b"value".to_vec())]),
+        Err(HeaderError::Forbidden)
+    ));
+
+    assert!(matches!(
+        Headers::from_list(&[("ok-header-name".to_owned(), b"bad\nvalue".to_vec())]),
+        Err(HeaderError::InvalidSyntax)
+    ));
+
+    let req = OutgoingRequest::new(hdrs);
+    let hdrs = req.headers();
+
+    assert!(matches!(
+        hdrs.set(&"Content-Length".to_owned(), &[b"10".to_vec()]),
+        Err(HeaderError::Immutable),
+    ));
+
+    assert!(matches!(
+        hdrs.append(&"Content-Length".to_owned(), &b"10".to_vec()),
+        Err(HeaderError::Immutable),
+    ));
+
+    assert!(matches!(
+        hdrs.delete(&"Content-Length".to_owned()),
+        Err(HeaderError::Immutable),
+    ));
+}
diff --git a/crates/test-programs/src/bin/http_outbound_request_invalid_port.rs b/crates/test-programs/src/bin/http_outbound_request_invalid_port.rs
new file mode 100644
index 000000000000..9d22c6746d80
--- /dev/null
+++ b/crates/test-programs/src/bin/http_outbound_request_invalid_port.rs
@@ -0,0 +1,17 @@
+use test_programs::wasi::http::types::{Method, Scheme};
+
+fn main() {
+    let res = test_programs::http::request(
+        Method::Get,
+        Scheme::Http,
+        "localhost:99999",
+        "/",
+        None,
+        None,
+        None,
+        None,
+        None,
+    );
+
+    assert!(res.is_err());
+}
diff --git a/crates/test-programs/src/bin/http_outbound_request_invalid_version.rs b/crates/test-programs/src/bin/http_outbound_request_invalid_version.rs
new file mode 100644
index 000000000000..e2009324ae15
--- /dev/null
+++ b/crates/test-programs/src/bin/http_outbound_request_invalid_version.rs
@@ -0,0 +1,23 @@
+use test_programs::wasi::http::types::{ErrorCode, Method, Scheme};
+
+fn main() {
+    let addr = std::env::var("HTTP_SERVER").unwrap();
+    let res = test_programs::http::request(
+        Method::Connect,
+        Scheme::Http,
+        &addr,
+        "/",
+        None,
+        Some(&[]),
+        None,
+        None,
+        None,
+    );
+
+    assert!(matches!(
+        res.unwrap_err()
+            .downcast::<ErrorCode>()
+            .expect("expected a wasi-http ErrorCode"),
+        ErrorCode::HttpProtocolError,
+    ));
+}
diff --git a/crates/test-programs/src/bin/http_outbound_request_large_post.rs b/crates/test-programs/src/bin/http_outbound_request_large_post.rs
new file mode 100644
index 000000000000..4e07493694a6
--- /dev/null
+++ b/crates/test-programs/src/bin/http_outbound_request_large_post.rs
@@ -0,0 +1,30 @@
+use anyhow::Context;
+use std::io::{self, Read};
+use test_programs::wasi::http::types::{Method, Scheme};
+
+fn main() {
+    // TODO: ensure more than 700 bytes is allowed without error
+    const LEN: usize = 700;
+    let mut buffer = [0; LEN];
+    let addr = std::env::var("HTTP_SERVER").unwrap();
+    io::repeat(0b001).read_exact(&mut buffer).unwrap();
+    let res = test_programs::http::request(
+        Method::Post,
+        Scheme::Http,
+        &addr,
+        "/post",
+        Some(&buffer),
+        None,
+        None,
+        None,
+        None,
+    )
+    .context("/post large")
+    .unwrap();
+
+    println!("/post large: {}", res.status);
+    assert_eq!(res.status, 200);
+    let method = res.header("x-wasmtime-test-method").unwrap();
+    assert_eq!(std::str::from_utf8(method).unwrap(), "POST");
+    assert_eq!(res.body.len(), LEN);
+}
diff --git a/crates/test-programs/src/bin/http_outbound_request_missing_path_and_query.rs b/crates/test-programs/src/bin/http_outbound_request_missing_path_and_query.rs
new file mode 100644
index 000000000000..4c278ade1452
--- /dev/null
+++ b/crates/test-programs/src/bin/http_outbound_request_missing_path_and_query.rs
@@ -0,0 +1,16 @@
+use test_programs::wasi::http::outgoing_handler::{handle, OutgoingRequest};
+use test_programs::wasi::http::types::{Fields, Method, Scheme};
+
+fn main() {
+    let fields = Fields::new();
+    let req = OutgoingRequest::new(fields);
+    req.set_method(&Method::Get).unwrap();
+    req.set_scheme(Some(&Scheme::Https)).unwrap();
+    req.set_authority(Some("example.com")).unwrap();
+
+    // Don't set path/query
+    // req.set_path_with_query(Some("/")).unwrap();
+
+    let res = handle(req, None);
+    assert!(res.is_err());
+}
diff --git a/crates/test-programs/src/bin/http_outbound_request_post.rs b/crates/test-programs/src/bin/http_outbound_request_post.rs
new file mode 100644
index 000000000000..1a499a9534ba
--- /dev/null
+++ b/crates/test-programs/src/bin/http_outbound_request_post.rs
@@ -0,0 +1,27 @@
+use anyhow::Context;
+use test_programs::wasi::http::types::{Method, Scheme};
+
+fn main() {
+    let addr = std::env::var("HTTP_SERVER").unwrap();
+    let res = test_programs::http::request(
+        Method::Post,
+        Scheme::Http,
+        &addr,
+        "/post",
+        Some(b"{\"foo\": \"bar\"}"),
+        None,
+        None,
+        None,
+        None,
+    )
+    .context("/post")
+    .unwrap();
+
+    println!("/post: {res:?}");
+    assert_eq!(res.status, 200);
+    let method = res.header("x-wasmtime-test-method").unwrap();
+    assert_eq!(std::str::from_utf8(method).unwrap(), "POST");
+    let uri = res.header("x-wasmtime-test-uri").unwrap();
+    assert_eq!(std::str::from_utf8(uri).unwrap(), format!("/post"));
+    assert_eq!(res.body, b"{\"foo\": \"bar\"}", "invalid body returned");
+}
diff --git a/crates/test-programs/src/bin/http_outbound_request_put.rs b/crates/test-programs/src/bin/http_outbound_request_put.rs
new file mode 100644
index 000000000000..dd3644b513a9
--- /dev/null
+++ b/crates/test-programs/src/bin/http_outbound_request_put.rs
@@ -0,0 +1,27 @@
+use anyhow::Context;
+use test_programs::wasi::http::types::{Method, Scheme};
+
+fn main() {
+    let addr = std::env::var("HTTP_SERVER").unwrap();
+    let res = test_programs::http::request(
+        Method::Put,
+        Scheme::Http,
+        &addr,
+        "/put",
+        Some(&[]),
+        None,
+        None,
+        None,
+        None,
+    )
+    .context("/put")
+    .unwrap();
+
+    println!("/put: {res:?}");
+    assert_eq!(res.status, 200);
+    let method = res.header("x-wasmtime-test-method").unwrap();
+    assert_eq!(std::str::from_utf8(method).unwrap(), "PUT");
+    let uri = res.header("x-wasmtime-test-uri").unwrap();
+    assert_eq!(std::str::from_utf8(uri).unwrap(), format!("/put"));
+    assert_eq!(res.body, b"");
+}
diff --git a/crates/test-programs/src/bin/http_outbound_request_response_build.rs b/crates/test-programs/src/bin/http_outbound_request_response_build.rs
new file mode 100644
index 000000000000..59664ccde309
--- /dev/null
+++ b/crates/test-programs/src/bin/http_outbound_request_response_build.rs
@@ -0,0 +1,62 @@
+use test_programs::wasi::http::types as http_types;
+
+fn main() {
+    println!("Called _start");
+    {
+        let headers = http_types::Headers::from_list(&[(
+            "Content-Type".to_string(),
+            "application/json".to_string().into_bytes(),
+        )])
+        .unwrap();
+        let request = http_types::OutgoingRequest::new(headers);
+
+        request
+            .set_method(&http_types::Method::Get)
+            .expect("setting method");
+        request
+            .set_scheme(Some(&http_types::Scheme::Https))
+            .expect("setting scheme");
+        request
+            .set_authority(Some("www.example.com"))
+            .expect("setting authority");
+
+        let outgoing_body = request.body().unwrap();
+        let request_body = outgoing_body.write().unwrap();
+        request_body
+            .blocking_write_and_flush("request-body".as_bytes())
+            .unwrap();
+    }
+    {
+        let headers = http_types::Headers::from_list(&[(
+            "Content-Type".to_string(),
+            "application/text".to_string().into_bytes(),
+        )])
+        .unwrap();
+        let response = http_types::OutgoingResponse::new(headers);
+        let outgoing_body = response.body().unwrap();
+        let response_body = outgoing_body.write().unwrap();
+        response_body
+            .blocking_write_and_flush("response-body".as_bytes())
+            .unwrap();
+    }
+
+    {
+        let req = http_types::OutgoingRequest::new(http_types::Fields::new());
+
+        assert!(req
+            .set_method(&http_types::Method::Other("invalid method".to_string()))
+            .is_err());
+
+        assert!(req.set_authority(Some("bad-port:99999")).is_err());
+        assert!(req.set_authority(Some("bad-\nhost")).is_err());
+        assert!(req.set_authority(Some("too-many-ports:80:80:80")).is_err());
+
+        assert!(req
+            .set_scheme(Some(&http_types::Scheme::Other("bad\nscheme".to_string())))
+            .is_err());
+
+        assert!(req.set_path_with_query(Some("/bad\npath")).is_err());
+    }
+
+    println!("Done");
+}
diff --git a/crates/test-programs/src/bin/http_outbound_request_timeout.rs b/crates/test-programs/src/bin/http_outbound_request_timeout.rs
new file mode 100644
index 000000000000..ae0dac51201f
--- /dev/null
+++ b/crates/test-programs/src/bin/http_outbound_request_timeout.rs
@@ -0,0 +1,33 @@
+use anyhow::Context;
+use std::net::SocketAddr;
+use std::time::Duration;
+use test_programs::wasi::http::types::{ErrorCode, Method, Scheme};
+
+fn main() {
+    // This address inside the TEST-NET-3 address block is expected to time out.
+    let addr = SocketAddr::from(([203, 0, 113, 12], 80)).to_string();
+    let timeout = Duration::from_millis(200);
+    let connect_timeout: Option<u64> = Some(timeout.as_nanos() as u64);
+    let res = test_programs::http::request(
+        Method::Get,
+        Scheme::Http,
+        &addr,
+        "/get?some=arg&goes=here",
+        None,
+        None,
+        connect_timeout,
+        None,
+        None,
+    )
+    .context("/get");
+
+    assert!(res.is_err());
+    let err = res.unwrap_err();
+    assert!(
+        matches!(
+            err.downcast_ref::<ErrorCode>(),
+            Some(ErrorCode::ConnectionTimeout | ErrorCode::ConnectionRefused)
+        ),
+        "expected connection timeout: {err:?}"
+    );
+}
diff --git a/crates/test-programs/src/bin/http_outbound_request_unknown_method.rs b/crates/test-programs/src/bin/http_outbound_request_unknown_method.rs
new file mode 100644
index 000000000000..d6fd61c9dbaa
--- /dev/null
+++ b/crates/test-programs/src/bin/http_outbound_request_unknown_method.rs
@@ -0,0 +1,18 @@
+use test_programs::wasi::http::types::{Method, Scheme};
+
+fn main() {
+    let res = test_programs::http::request(
+        Method::Other("bad\nmethod".to_owned()),
+        Scheme::Http,
+        "localhost:3000",
+        "/",
+        None,
+        None,
+        None,
+        None,
+        None,
+    );
+
+    // This error arises from input validation in the `set_method` function on `OutgoingRequest`.
+    assert_eq!(res.unwrap_err().to_string(), "failed to set method");
+}
diff --git a/crates/test-programs/src/bin/http_outbound_request_unsupported_scheme.rs b/crates/test-programs/src/bin/http_outbound_request_unsupported_scheme.rs
new file mode 100644
index 000000000000..a596f2dc9249
--- /dev/null
+++ b/crates/test-programs/src/bin/http_outbound_request_unsupported_scheme.rs
@@ -0,0 +1,22 @@
+use test_programs::wasi::http::types::{ErrorCode, Method, Scheme};
+
+fn main() {
+    let res = test_programs::http::request(
+        Method::Get,
+        Scheme::Other("WS".to_owned()),
+        "localhost:3000",
+        "/",
+        None,
+        None,
+        None,
+        None,
+        None,
+    );
+
+    assert!(matches!(
+        res.unwrap_err()
+            .downcast::<ErrorCode>()
+            .expect("expected a wasi-http ErrorCode"),
+        ErrorCode::HttpProtocolError,
+    ));
+}
diff --git a/crates/test-programs/src/bin/keyvalue_main.rs b/crates/test-programs/src/bin/keyvalue_main.rs
new file mode 100644
index 000000000000..0a5dfe5bfc05
--- /dev/null
+++ b/crates/test-programs/src/bin/keyvalue_main.rs
@@ -0,0 +1,44 @@
+use test_programs::wasi::keyvalue::{atomics, batch, store};
+
+fn main() {
+    let bucket = store::open("").unwrap();
+
+    // we have preset this `atomics_key` with value 5
+    assert_eq!(atomics::increment(&bucket, "atomics_key", 1).unwrap(), 6);
+
+    let resp = bucket.list_keys(None).unwrap();
+    assert_eq!(resp.keys, vec!["atomics_key".to_string()]);
+
+    bucket.set("hello", "world".as_bytes()).unwrap();
+
+    let v = bucket.get("hello").unwrap();
+    assert_eq!(String::from_utf8(v.unwrap()).unwrap(), "world");
+
+    assert_eq!(bucket.exists("hello").unwrap(), true);
+    bucket.delete("hello").unwrap();
+    assert_eq!(bucket.exists("hello").unwrap(), false);
+
+    batch::set_many(
+        &bucket,
+        &[
+            ("a1".to_string(), "v1".as_bytes().to_vec()),
+            ("b1".to_string(), "v1".as_bytes().to_vec()),
+            ("c1".to_string(), "v1".as_bytes().to_vec()),
+        ],
+    )
+    .unwrap();
+    batch::delete_many(&bucket, &["a1".to_string(), "c1".to_string()]).unwrap();
+    let values = batch::get_many(
+        &bucket,
+        &["a1".to_string(), "b1".to_string(), "c1".to_string()],
+    )
+    .unwrap();
+    assert_eq!(
+        values,
+        vec![
+            None,
+            Some(("b1".to_string(), "v1".as_bytes().to_vec())),
+            None
+        ]
+    );
+}
diff --git a/crates/test-programs/src/bin/nn_wit_image_classification_onnx.rs b/crates/test-programs/src/bin/nn_wit_image_classification_onnx.rs
new file mode 100644
index 000000000000..6ff065ca1a6f
--- /dev/null
+++ b/crates/test-programs/src/bin/nn_wit_image_classification_onnx.rs
@@ -0,0 +1,22 @@
+use anyhow::{Context, Result};
+use std::fs;
+use test_programs::nn::{sort_results, wit};
+
+pub fn main() -> Result<()> {
+    let model = fs::read("fixture/model.onnx")
+        .context("the model file to be mapped to the fixture directory")?;
+    let graph = wit::load(
+        &[model],
+        wit::GraphEncoding::Onnx,
+        wit::ExecutionTarget::Cpu,
+    )?;
+    let tensor = fs::read("fixture/000000062808.rgb")
+        .context("the tensor file to be mapped to the fixture directory")?;
+    let results = wit::classify(graph, ("input", tensor), "output")?;
+    let top_five = &sort_results(&results)[..5];
+    // 963 is "meat loaf, meatloaf."
+    // https://github.com/onnx/models/blob/bec48b6a70e5e9042c0badbaafefe4454e072d08/validated/vision/classification/synset.txt#L963
+    assert_eq!(top_five[0].class_id(), 963);
+    println!("found results, sorted top 5: {top_five:?}");
+    Ok(())
+}
diff --git a/crates/test-programs/src/bin/nn_wit_image_classification_openvino.rs b/crates/test-programs/src/bin/nn_wit_image_classification_openvino.rs
new file mode 100644
index 000000000000..197bb0794691
--- /dev/null
+++ b/crates/test-programs/src/bin/nn_wit_image_classification_openvino.rs
@@ -0,0 +1,25 @@
+use anyhow::{Context, Result};
+use std::fs;
+use test_programs::nn::{sort_results, wit};
+
+pub fn main() -> Result<()> {
+    let xml = fs::read("fixture/model.xml")
+        .context("the model file to be mapped to the fixture directory")?;
+    let weights = fs::read("fixture/model.bin")
+        .context("the weights file to be mapped to the fixture directory")?;
+    let graph = wit::load(
+        &[xml, weights],
+        wit::GraphEncoding::Openvino,
+        wit::ExecutionTarget::Cpu,
+    )?;
+    let tensor = fs::read("fixture/tensor.bgr")
+        .context("the tensor file to be mapped to the fixture directory")?;
+    let results = wit::classify(
+        graph,
+        ("input", tensor),
+        "MobilenetV2/Predictions/Reshape_1",
+    )?;
+    let top_five = &sort_results(&results)[..5];
+    println!("found results, sorted top 5: {top_five:?}");
+    Ok(())
+}
diff --git a/crates/test-programs/src/bin/nn_wit_image_classification_openvino_named.rs b/crates/test-programs/src/bin/nn_wit_image_classification_openvino_named.rs
new file mode 100644
index 000000000000..5fb8d9266499
--- /dev/null
+++ b/crates/test-programs/src/bin/nn_wit_image_classification_openvino_named.rs
@@ -0,0 +1,17 @@
+use anyhow::{Context, Result};
+use std::fs;
+use test_programs::nn::{sort_results, wit};
+
+pub fn main() -> Result<()> {
+    let graph = wit::load_by_name("fixtures")?;
+    let tensor: Vec<u8> = fs::read("fixture/tensor.bgr")
+        .context("the tensor file to be mapped to the fixture directory")?;
+    let results = wit::classify(
+        graph,
+        ("input", tensor),
+        "MobilenetV2/Predictions/Reshape_1",
+    )?;
+    let top_five = &sort_results(&results)[..5];
+    println!("found results, sorted top 5: {top_five:?}");
+    Ok(())
+}
diff --git a/crates/test-programs/src/bin/nn_wit_image_classification_winml_named.rs b/crates/test-programs/src/bin/nn_wit_image_classification_winml_named.rs
new file mode 100644
index 000000000000..684f84f544d8
--- /dev/null
+++ b/crates/test-programs/src/bin/nn_wit_image_classification_winml_named.rs
@@ -0,0 +1,14 @@
+use anyhow::{Context, Result};
+use std::fs;
+use test_programs::nn::{sort_results, wit};
+
+pub fn main() -> Result<()> {
+    let graph = wit::load_by_name("mobilenet")?;
+    let tensor = fs::read("fixture/tensor.bgr")
+        .context("the tensor file to be mapped to the fixture directory")?;
+    let results = wit::classify(graph, ("input", tensor), "output")?;
+    let top_five = &sort_results(&results)[..5];
+    println!("found results, sorted top 5: {top_five:?}");
+    assert_eq!(top_five[0].class_id(), 284);
+    Ok(())
+}
diff --git a/crates/test-programs/src/bin/nn_witx_image_classification_onnx.rs b/crates/test-programs/src/bin/nn_witx_image_classification_onnx.rs
new file mode 100644
index 000000000000..da69c97a187c
--- /dev/null
+++ b/crates/test-programs/src/bin/nn_witx_image_classification_onnx.rs
@@ -0,0 +1,22 @@
+use anyhow::{Context, Result};
+use std::fs;
+use test_programs::nn::{sort_results, witx};
+
+pub fn main() -> Result<()> {
+    let model = fs::read("fixture/model.onnx")
+        .context("the model file to be mapped to the fixture directory")?;
+    let graph = witx::load(
+        &[&model],
+        witx::GraphEncoding::Onnx,
+        witx::ExecutionTarget::CPU,
+    )?;
+    let tensor = fs::read("fixture/000000062808.rgb")
+        .context("the tensor file to be mapped to the fixture directory")?;
+    let results = witx::classify(graph, tensor)?;
+    let top_five = &sort_results(&results)[..5];
+    // 963 is "meat loaf, meatloaf."
+    // https://github.com/onnx/models/blob/bec48b6a70e5e9042c0badbaafefe4454e072d08/validated/vision/classification/synset.txt#L963
+    assert_eq!(top_five[0].class_id(), 963);
+    println!("found results, sorted top 5: {top_five:?}");
+    Ok(())
+}
diff --git a/crates/test-programs/src/bin/nn_witx_image_classification_openvino.rs b/crates/test-programs/src/bin/nn_witx_image_classification_openvino.rs
new file mode 100644
index 000000000000..12640c744609
--- /dev/null
+++ b/crates/test-programs/src/bin/nn_witx_image_classification_openvino.rs
@@ -0,0 +1,21 @@
+use anyhow::{Context, Result};
+use std::fs;
+use test_programs::nn::{sort_results, witx};
+
+pub fn main() -> Result<()> {
+    let xml = fs::read("fixture/model.xml")
+        .context("the model file to be mapped to the fixture directory")?;
+    let weights = fs::read("fixture/model.bin")
+        .context("the weights file to be mapped to the fixture directory")?;
+    let graph = witx::load(
+        &[&xml, &weights],
+        witx::GraphEncoding::Openvino,
+        witx::ExecutionTarget::CPU,
+    )?;
+    let tensor = fs::read("fixture/tensor.bgr")
+        .context("the tensor file to be mapped to the fixture directory")?;
+    let results = witx::classify(graph, tensor)?;
+    let top_five = &sort_results(&results)[..5];
+    println!("found results, sorted top 5: {top_five:?}");
+    Ok(())
+}
diff --git a/crates/test-programs/src/bin/nn_witx_image_classification_openvino_named.rs b/crates/test-programs/src/bin/nn_witx_image_classification_openvino_named.rs
new file mode 100644
index 000000000000..30549d91e801
--- /dev/null
+++ b/crates/test-programs/src/bin/nn_witx_image_classification_openvino_named.rs
@@ -0,0 +1,17 @@
+use anyhow::{Context, Result};
+use std::fs;
+use test_programs::nn::{sort_results, witx};
+
+pub fn main() -> Result<()> {
+    let graph = witx::load_by_name(
+        "fixtures",
+        witx::GraphEncoding::Openvino,
+        witx::ExecutionTarget::CPU,
+    )?;
+    let tensor: Vec<u8> = fs::read("fixture/tensor.bgr")
+        .context("the tensor file to be mapped to the fixture directory")?;
+    let results = witx::classify(graph, tensor)?;
+    let top_five = &sort_results(&results)[..5];
+    println!("found results, sorted top 5: {top_five:?}");
+    Ok(())
+}
diff --git a/crates/test-programs/src/bin/nn_witx_image_classification_winml_named.rs b/crates/test-programs/src/bin/nn_witx_image_classification_winml_named.rs
new file mode 100644
index 000000000000..acd3ddc38111
--- /dev/null
+++ b/crates/test-programs/src/bin/nn_witx_image_classification_winml_named.rs
@@ -0,0 +1,18 @@
+use anyhow::{Context, Result};
+use std::fs;
+use test_programs::nn::{sort_results, witx};
+
+pub fn main() -> Result<()> {
+    let graph = witx::load_by_name(
+        "mobilenet",
+        witx::GraphEncoding::Onnx,
+        witx::ExecutionTarget::CPU,
+    )?;
+    let tensor = fs::read("fixture/tensor.bgr")
+        .context("the tensor file to be mapped to the fixture directory")?;
+    let results = witx::classify(graph, tensor)?;
+    let top_five = &sort_results(&results)[..5];
+    println!("found results, sorted top 5: {top_five:?}");
+    assert_eq!(top_five[0].class_id(), 284);
+    Ok(())
+}
diff --git a/crates/test-programs/src/bin/piped_multiple.rs b/crates/test-programs/src/bin/piped_multiple.rs
new file mode 100644
index 000000000000..861f62279b97
--- /dev/null
+++ b/crates/test-programs/src/bin/piped_multiple.rs
@@ -0,0 +1,34 @@
+use test_programs::wasi::cli::{stdin, stdout};
+
+fn main() {
+    match std::env::var("PIPED_SIDE")
+        .expect("piped tests require the PIPED_SIDE env var")
+        .as_str()
+    {
+        "PRODUCER" => producer(),
+        "CONSUMER" => consumer(),
+        side => panic!("unknown piped test side: {side}"),
+    }
+}
+
+const CHUNK: &[u8] = &[b'a'; 50];
+
+fn producer() {
+    let out = stdout::get_stdout();
+    let n = out.check_write().unwrap() as usize;
+    assert!(n > CHUNK.len());
+    out.write(CHUNK).unwrap();
+}
+
+fn consumer() {
+    let stdin = stdin::get_stdin();
+    let stdin_pollable1 = stdin.subscribe();
+    let stdin_pollable2 = stdin.subscribe();
+
+    // The two pollables are subscribed to the same resource, and must report the same readiness
+    stdin_pollable1.block();
+    assert!(stdin_pollable1.ready() && stdin_pollable2.ready());
+
+    let bytes = stdin.read(CHUNK.len() as u64).unwrap();
+    assert_eq!(&bytes, CHUNK);
+}
diff --git a/crates/test-programs/src/bin/piped_polling.rs b/crates/test-programs/src/bin/piped_polling.rs
new file mode 100644
index 000000000000..05f8b35a8596
--- /dev/null
+++ b/crates/test-programs/src/bin/piped_polling.rs
@@ -0,0 +1,51 @@
+use test_programs::wasi::cli::{stdin, stdout};
+
+fn main() {
+    match std::env::var("PIPED_SIDE")
+        .expect("piped tests require the PIPED_SIDE env var")
+        .as_str()
+    {
+        "PRODUCER" => producer(),
+        "CONSUMER" => consumer(),
+        side => panic!("unknown piped test side: {side}"),
+    }
+}
+
+fn producer() {
+    let out = stdout::get_stdout();
+    let out_pollable = out.subscribe();
+
+    for i in 1..100 {
+        let message = format!("{i}");
+        loop {
+            let available = out.check_write().unwrap() as usize;
+            if available >= message.len() {
+                break;
+            }
+
+            out_pollable.block();
+            assert!(out_pollable.ready());
+        }
+
+        out.write(message.as_bytes()).unwrap()
+    }
+
+    drop(out_pollable);
+}
+
+fn consumer() {
+    let stdin = stdin::get_stdin();
+    let stdin_pollable = stdin.subscribe();
+
+    for i in 1..100 {
+        let expected = format!("{i}");
+
+        stdin_pollable.block();
+        assert!(stdin_pollable.ready());
+
+        let bytes = stdin.read(expected.len() as u64).unwrap();
+        assert_eq!(&bytes, expected.as_bytes());
+    }
+
+    drop(stdin_pollable);
+}
diff --git a/crates/test-programs/src/bin/piped_simple.rs b/crates/test-programs/src/bin/piped_simple.rs
new file mode 100644
index 000000000000..323e463335aa
--- /dev/null
+++ b/crates/test-programs/src/bin/piped_simple.rs
@@ -0,0 +1,30 @@
+use test_programs::wasi::cli::{stdin, stdout};
+
+fn main() {
+    match std::env::var("PIPED_SIDE")
+        .expect("piped tests require the PIPED_SIDE env var")
+        .as_str()
+    {
+        "PRODUCER" => producer(),
+        "CONSUMER" => consumer(),
+        side => panic!("unknown piped test side: {side}"),
+    }
+}
+
+const CHUNK: &[u8] = &[b'a'; 50];
+
+fn producer() {
+    let out = stdout::get_stdout();
+    let n = out.check_write().unwrap() as usize;
+    assert!(n > CHUNK.len());
+    out.write(CHUNK).unwrap();
+}
+
+fn consumer() {
+    let stdin = stdin::get_stdin();
+    let stdin_pollable = stdin.subscribe();
+    stdin_pollable.block();
+    assert!(stdin_pollable.ready());
+    let bytes = stdin.read(CHUNK.len() as u64).unwrap();
+    assert_eq!(&bytes, CHUNK);
+}
diff --git a/crates/test-programs/wasi-tests/src/bin/big_random_buf.rs b/crates/test-programs/src/bin/preview1_big_random_buf.rs
similarity index 100%
rename from crates/test-programs/wasi-tests/src/bin/big_random_buf.rs
rename to crates/test-programs/src/bin/preview1_big_random_buf.rs
diff --git a/crates/test-programs/wasi-tests/src/bin/clock_time_get.rs b/crates/test-programs/src/bin/preview1_clock_time_get.rs
similarity index 100%
rename from crates/test-programs/wasi-tests/src/bin/clock_time_get.rs
rename to crates/test-programs/src/bin/preview1_clock_time_get.rs
diff --git a/crates/test-programs/src/bin/preview1_close_preopen.rs b/crates/test-programs/src/bin/preview1_close_preopen.rs
new file mode 100644
index 000000000000..ba191488229f
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_close_preopen.rs
@@ -0,0 +1,48 @@
+use std::{env, process};
+use test_programs::preview1::{assert_errno, open_scratch_directory};
+
+unsafe fn test_close_preopen(dir_fd: wasi::Fd) {
+    let pre_fd: wasi::Fd = (libc::STDERR_FILENO + 1) as wasi::Fd;
+
+    assert!(dir_fd > pre_fd, "dir_fd number");
+
+    // Try to close a preopened directory handle.
+    wasi::fd_close(pre_fd).expect("closing a preopened file descriptor");
+
+    // Ensure that dir_fd is still open.
+    let dir_fdstat = wasi::fd_fdstat_get(dir_fd).expect("failed fd_fdstat_get");
+    assert_eq!(
+        dir_fdstat.fs_filetype,
+        wasi::FILETYPE_DIRECTORY,
+        "expected the scratch directory to be a directory",
+    );
+
+    // Ensure that pre_fd is closed.
+    assert_errno!(
+        wasi::fd_fdstat_get(pre_fd).expect_err("failed fd_fdstat_get"),
+        wasi::ERRNO_BADF
+    );
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_close_preopen(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview1_dangling_fd.rs b/crates/test-programs/src/bin/preview1_dangling_fd.rs
new file mode 100644
index 000000000000..50217aeb1e06
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_dangling_fd.rs
@@ -0,0 +1,53 @@
+use std::{env, process};
+use test_programs::preview1::{config, open_scratch_directory};
+
+unsafe fn test_dangling_fd(dir_fd: wasi::Fd) {
+    if config().support_dangling_filesystem() {
+        // Create a file, open it, delete it without closing the handle,
+        // and then try creating it again
+        let fd = wasi::path_open(dir_fd, 0, "file", wasi::OFLAGS_CREAT, 0, 0, 0).unwrap();
+        wasi::fd_close(fd).unwrap();
+        let file_fd = wasi::path_open(dir_fd, 0, "file", 0, 0, 0, 0).expect("failed to open");
+        assert!(
+            file_fd > libc::STDERR_FILENO as wasi::Fd,
+            "file descriptor range check",
+        );
+        wasi::path_unlink_file(dir_fd, "file").expect("failed to unlink");
+        let fd = wasi::path_open(dir_fd, 0, "file", wasi::OFLAGS_CREAT, 0, 0, 0).unwrap();
+        wasi::fd_close(fd).unwrap();
+
+        // Now, repeat the same process but for a directory
+        wasi::path_create_directory(dir_fd, "subdir").expect("failed to create dir");
+        let subdir_fd = wasi::path_open(dir_fd, 0, "subdir", wasi::OFLAGS_DIRECTORY, 0, 0, 0)
+            .expect("failed to open dir");
+        assert!(
+            subdir_fd > libc::STDERR_FILENO as wasi::Fd,
+            "file descriptor range check",
+        );
+        wasi::path_remove_directory(dir_fd, "subdir").expect("failed to remove dir 2");
+        wasi::path_create_directory(dir_fd, "subdir").expect("failed to create dir 2");
+    }
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_dangling_fd(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview1_dangling_symlink.rs b/crates/test-programs/src/bin/preview1_dangling_symlink.rs
new file mode 100644
index 000000000000..f4c6d34f4d44
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_dangling_symlink.rs
@@ -0,0 +1,52 @@
+use std::{env, process};
+use test_programs::preview1::{assert_errno, config, open_scratch_directory};
+
+unsafe fn test_dangling_symlink(dir_fd: wasi::Fd) {
+    if config().support_dangling_filesystem() {
+        // First create a dangling symlink.
+        wasi::path_symlink("target", dir_fd, "symlink").expect("creating a symlink");
+
+        // Try to open it as a directory with O_NOFOLLOW.
+        assert_errno!(
+            wasi::path_open(dir_fd, 0, "symlink", wasi::OFLAGS_DIRECTORY, 0, 0, 0)
+                .expect_err("opening a dangling symlink as a directory"),
+            wasi::ERRNO_NOTDIR,
+            wasi::ERRNO_LOOP,
+            wasi::ERRNO_NOENT
+        );
+
+        // Try to open it as a file with O_NOFOLLOW.
+        assert_errno!(
+            wasi::path_open(dir_fd, 0, "symlink", 0, 0, 0, 0)
+                .expect_err("opening a dangling symlink as a file"),
+            wasi::ERRNO_LOOP,
+            wasi::ERRNO_NOENT
+        );
+
+        // Clean up.
+        wasi::path_unlink_file(dir_fd, "symlink").expect("failed to remove file");
+    }
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_dangling_symlink(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview1_dir_fd_op_failures.rs b/crates/test-programs/src/bin/preview1_dir_fd_op_failures.rs
new file mode 100644
index 000000000000..0860fadb4ddc
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_dir_fd_op_failures.rs
@@ -0,0 +1,115 @@
+use std::{env, process};
+use test_programs::preview1::open_scratch_directory;
+
+unsafe fn test_fd_dir_ops(dir_fd: wasi::Fd) {
+    let stat = wasi::fd_filestat_get(dir_fd).expect("failed to fdstat");
+    assert_eq!(stat.filetype, wasi::FILETYPE_DIRECTORY);
+
+    let (pr_fd, pr_name_len) = (3..)
+        .map_while(|fd| wasi::fd_prestat_get(fd).ok().map(|stat| (fd, stat)))
+        .find_map(|(fd, wasi::Prestat { tag, u })| {
+            (tag == wasi::PREOPENTYPE_DIR.raw()).then_some((fd, u.dir.pr_name_len))
+        })
+        .expect("failed to find preopen directory");
+
+    let mut pr_name = vec![];
+    let r = wasi::fd_prestat_dir_name(pr_fd, pr_name.as_mut_ptr(), 0);
+    assert_eq!(r, Err(wasi::ERRNO_NAMETOOLONG));
+
+    // Test that passing a larger than necessary buffer works correctly
+    let mut pr_name = vec![0; pr_name_len + 1];
+    let r = wasi::fd_prestat_dir_name(pr_fd, pr_name.as_mut_ptr(), pr_name_len + 1);
+    assert_eq!(r, Ok(()));
+
+    let mut read_buf = vec![0; 128].into_boxed_slice();
+    let iovec = wasi::Iovec {
+        buf: read_buf.as_mut_ptr(),
+        buf_len: read_buf.len(),
+    };
+    let r = wasi::fd_read(dir_fd, &[iovec]);
+    // On posix, this fails with ERRNO_ISDIR:
+    assert_eq!(r, Err(wasi::ERRNO_BADF), "fd_read error");
+
+    let r = wasi::fd_pread(dir_fd, &[iovec], 0);
+    // On posix, this fails with ERRNO_ISDIR
+    assert_eq!(r, Err(wasi::ERRNO_BADF), "fd_pread error");
+
+    let write_buf = vec![0; 128].into_boxed_slice();
+    let ciovec = wasi::Ciovec {
+        buf: write_buf.as_ptr(),
+        buf_len: write_buf.len(),
+    };
+    let r = wasi::fd_write(dir_fd, &[ciovec]);
+    // Same behavior as specified by POSIX:
+    assert_eq!(r, Err(wasi::ERRNO_BADF), "fd_write error");
+
+    let r = wasi::fd_pwrite(dir_fd, &[ciovec], 0);
+    // Same behavior as specified by POSIX:
+    assert_eq!(r, Err(wasi::ERRNO_BADF), "fd_pwrite error");
+
+    // Divergence from posix: lseek(dirfd) will return 0
+    let r = wasi::fd_seek(dir_fd, 0, wasi::WHENCE_CUR);
+    assert_eq!(r, Err(wasi::ERRNO_BADF), "fd_seek WHENCE_CUR error");
+    let r = wasi::fd_seek(dir_fd, 0, wasi::WHENCE_SET);
+    assert_eq!(r, Err(wasi::ERRNO_BADF), "fd_seek WHENCE_SET error");
+    let r = wasi::fd_seek(dir_fd, 0, wasi::WHENCE_END);
+    assert_eq!(r, Err(wasi::ERRNO_BADF), "fd_seek WHENCE_END error");
+
+    // Tell isn't in posix, its basically lseek with WHENCE_CUR above
+    let r = wasi::fd_tell(dir_fd);
+    assert_eq!(r, Err(wasi::ERRNO_BADF), "fd_tell error");
+
+    // posix_fadvise(dirfd, 0, 0, POSIX_FADV_DONTNEED) will return 0 on linux.
+    // not available on mac os.
+    let r = wasi::fd_advise(dir_fd, 0, 0, wasi::ADVICE_DONTNEED);
+    assert_eq!(r, Err(wasi::ERRNO_BADF), "fd_advise error");
+
+    // fallocate(dirfd, FALLOC_FL_ZERO_RANGE, 0, 1) will fail with errno EBADF on linux.
+    // not available on mac os.
+    let r = wasi::fd_allocate(dir_fd, 0, 0);
+    assert_eq!(r, Err(wasi::ERRNO_BADF), "fd_allocate error");
+
+    // fdatasync(dirfd) will return 0 on linux.
+    // not available on mac os.
+    let r = wasi::fd_datasync(dir_fd);
+    assert_eq!(r, Err(wasi::ERRNO_BADF), "fd_datasync error");
+
+    // fsync(dirfd) will return 0 on linux.
+    // not available on mac os.
+    let r = wasi::fd_sync(dir_fd);
+    assert_eq!(r, Err(wasi::ERRNO_BADF), "fd_sync error");
+
+    // fcntl(dirfd,  F_SETFL, O_NONBLOCK) will return 0 on linux.
+    // not available on mac os.
+    let r = wasi::fd_fdstat_set_flags(dir_fd, wasi::FDFLAGS_NONBLOCK);
+    assert_eq!(r, Err(wasi::ERRNO_BADF), "fd_fdstat_set_flags error");
+
+    // ftruncate(dirfd, 1) will fail with errno EINVAL on posix.
+    // here, we fail with EBADF instead:
+    let r = wasi::fd_filestat_set_size(dir_fd, 0);
+    assert_eq!(r, Err(wasi::ERRNO_BADF), "fd_filestat_set_size error");
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    unsafe {
+        test_fd_dir_ops(dir_fd);
+    }
+}
diff --git a/crates/test-programs/src/bin/preview1_directory_seek.rs b/crates/test-programs/src/bin/preview1_directory_seek.rs
new file mode 100644
index 000000000000..efd35870ab59
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_directory_seek.rs
@@ -0,0 +1,48 @@
+use std::{env, process};
+use test_programs::preview1::{assert_errno, open_scratch_directory};
+
+unsafe fn test_directory_seek(dir_fd: wasi::Fd) {
+    // Create a directory in the scratch directory.
+    wasi::path_create_directory(dir_fd, "dir").expect("failed to make directory");
+
+    // Open the directory and attempt to request rights for seeking.
+    let fd = wasi::path_open(dir_fd, 0, "dir", wasi::OFLAGS_DIRECTORY, 0, 0, 0)
+        .expect("failed to open file");
+    assert!(
+        fd > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+
+    // Attempt to seek.
+    assert_errno!(
+        wasi::fd_seek(fd, 0, wasi::WHENCE_CUR).expect_err("seek on a directory"),
+        wasi::ERRNO_BADF
+    );
+
+    // Clean up.
+    wasi::fd_close(fd).expect("failed to close fd");
+    wasi::path_remove_directory(dir_fd, "dir").expect("failed to remove dir");
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_directory_seek(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview1_fd_advise.rs b/crates/test-programs/src/bin/preview1_fd_advise.rs
new file mode 100644
index 000000000000..af0b2678b9b3
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_fd_advise.rs
@@ -0,0 +1,62 @@
+use std::{env, process};
+use test_programs::preview1::open_scratch_directory;
+
+unsafe fn test_fd_advise(dir_fd: wasi::Fd) {
+    // Create a file in the scratch directory.
+    let file_fd = wasi::path_open(
+        dir_fd,
+        0,
+        "file",
+        wasi::OFLAGS_CREAT,
+        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
+        0,
+        0,
+    )
+    .expect("failed to open file");
+    assert!(
+        file_fd > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+
+    // Check file size
+    let stat = wasi::fd_filestat_get(file_fd).expect("failed to fdstat");
+    assert_eq!(stat.size, 0, "file size should be 0");
+
+    // set_size it bigger
+    wasi::fd_filestat_set_size(file_fd, 100).expect("setting size");
+
+    let stat = wasi::fd_filestat_get(file_fd).expect("failed to fdstat 2");
+    assert_eq!(stat.size, 100, "file size should be 100");
+
+    // Advise the kernel
+    wasi::fd_advise(file_fd, 10, 50, wasi::ADVICE_NORMAL).expect("failed advise");
+
+    // Advise shouldn't change size
+    let stat = wasi::fd_filestat_get(file_fd).expect("failed to fdstat 3");
+    assert_eq!(stat.size, 100, "file size should be 100");
+
+    wasi::fd_close(file_fd).expect("failed to close");
+    wasi::path_unlink_file(dir_fd, "file").expect("failed to unlink");
+}
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_fd_advise(dir_fd) }
+}
diff --git a/crates/test-programs/wasi-tests/src/bin/fd_filestat_get.rs b/crates/test-programs/src/bin/preview1_fd_filestat_get.rs
similarity index 100%
rename from crates/test-programs/wasi-tests/src/bin/fd_filestat_get.rs
rename to crates/test-programs/src/bin/preview1_fd_filestat_get.rs
diff --git a/crates/test-programs/src/bin/preview1_fd_filestat_set.rs b/crates/test-programs/src/bin/preview1_fd_filestat_set.rs
new file mode 100644
index 000000000000..a4fe2e2a30f4
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_fd_filestat_set.rs
@@ -0,0 +1,149 @@
+use std::{env, process, time::Duration};
+use test_programs::preview1::{
+    assert_errno, assert_fs_time_eq, open_scratch_directory, TestConfig,
+};
+
+unsafe fn test_fd_filestat_set_size_rw(dir_fd: wasi::Fd) {
+    // Create a file in the scratch directory, opened read/write
+    let file_fd = wasi::path_open(
+        dir_fd,
+        0,
+        "file",
+        wasi::OFLAGS_CREAT,
+        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
+        0,
+        0,
+    )
+    .expect("failed to create file");
+    assert!(
+        file_fd > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+
+    // Check file size
+    let stat = wasi::fd_filestat_get(file_fd).expect("failed filestat");
+    assert_eq!(stat.size, 0, "file size should be 0");
+
+    // Check fd_filestat_set_size
+    wasi::fd_filestat_set_size(file_fd, 100).expect("fd_filestat_set_size");
+
+    let stat = wasi::fd_filestat_get(file_fd).expect("failed filestat 2");
+    assert_eq!(stat.size, 100, "file size should be 100");
+
+    wasi::fd_close(file_fd).expect("failed to close fd");
+    wasi::path_unlink_file(dir_fd, "file").expect("failed to remove file");
+}
+
+unsafe fn test_fd_filestat_set_size_ro(dir_fd: wasi::Fd) {
+    // Create a file in the scratch directory. Creating a file implies opening it for writing, so
+    // we have to close and re-open read-only to observe read-only behavior.
+    let file_fd = wasi::path_open(dir_fd, 0, "file", wasi::OFLAGS_CREAT, 0, 0, 0)
+        .expect("failed to create file");
+    wasi::fd_close(file_fd).expect("failed to close fd");
+
+    // Open the created file read-only
+    let file_fd = wasi::path_open(dir_fd, 0, "file", 0, wasi::RIGHTS_FD_READ, 0, 0)
+        .expect("failed to create file");
+
+    // Check file size
+    let stat = wasi::fd_filestat_get(file_fd).expect("failed filestat");
+    assert_eq!(stat.size, 0, "file size should be 0");
+
+    // Check fd_filestat_set_size on a file opened read-only fails with EINVAL, like ftruncate is defined to do on posix
+    assert_errno!(
+        wasi::fd_filestat_set_size(file_fd, 100)
+            .expect_err("fd_filestat_set_size should error when file is opened read-only"),
+        windows => wasi::ERRNO_ACCES,
+        wasi::ERRNO_INVAL
+    );
+
+    let stat = wasi::fd_filestat_get(file_fd).expect("failed filestat 2");
+    assert_eq!(stat.size, 0, "file size should remain 0");
+
+    wasi::fd_close(file_fd).expect("failed to close fd");
+    wasi::path_unlink_file(dir_fd, "file").expect("failed to remove file");
+}
+
+unsafe fn test_fd_filestat_set_times(dir_fd: wasi::Fd, rights: wasi::Rights) {
+    let cfg = TestConfig::from_env();
+
+    // Create a file in the scratch directory. OFLAGS_CREAT implies opening for writing, so we will
+    // close it and re-open with the desired rights (FD_READ for read only, FD_READ | FD_WRITE for
+    // readwrite)
+    let file_fd = wasi::path_open(dir_fd, 0, "file", wasi::OFLAGS_CREAT, 0, 0, 0)
+        .expect("failed to create file");
+    wasi::fd_close(file_fd).expect("failed to close fd");
+
+    // Open the file with the rights given.
+    let file_fd =
+        wasi::path_open(dir_fd, 0, "file", 0, rights, 0, 0).expect("failed to create file");
+
+    let stat = wasi::fd_filestat_get(file_fd).expect("failed filestat 2");
+
+    // Check fd_filestat_set_times
+    let old_atim = Duration::from_nanos(stat.atim);
+    let new_mtim = Duration::from_nanos(stat.mtim) - cfg.fs_time_precision() * 2;
+    wasi::fd_filestat_set_times(
+        file_fd,
+        new_mtim.as_nanos() as u64,
+        new_mtim.as_nanos() as u64,
+        wasi::FSTFLAGS_MTIM,
+    )
+    .expect("fd_filestat_set_times");
+
+    let stat = wasi::fd_filestat_get(file_fd).expect("failed filestat 3");
+    assert_eq!(stat.size, 0, "file size should remain unchanged at 0");
+
+    // Support accuracy up to at least 1ms
+    assert_fs_time_eq!(
+        Duration::from_nanos(stat.mtim),
+        new_mtim,
+        "mtim should change"
+    );
+    assert_fs_time_eq!(
+        Duration::from_nanos(stat.atim),
+        old_atim,
+        "atim should not change"
+    );
+
+    // let status = wasi_fd_filestat_set_times(file_fd, new_mtim, new_mtim, wasi::FILESTAT_SET_MTIM | wasi::FILESTAT_SET_MTIM_NOW);
+    // assert_eq!(status, wasi::EINVAL, "ATIM & ATIM_NOW can't both be set");
+
+    wasi::fd_close(file_fd).expect("failed to close fd");
+    wasi::path_unlink_file(dir_fd, "file").expect("failed to remove file");
+}
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+
+    unsafe { test_fd_filestat_set_size_rw(dir_fd) }
+    unsafe { test_fd_filestat_set_size_ro(dir_fd) }
+
+    // The fd_filestat_set_times function should behave the same whether the file
+    // descriptor is open for read-only or read-write, because the underlying
+    // permissions of the file determine whether or not the filestat can be
+    // set or not, not than the open mode.
+    if test_programs::preview1::config().support_dangling_filesystem() {
+        // Guarding to run on non-windows filesystems. Windows rejects set-times on read-only
+        // files.
+        unsafe { test_fd_filestat_set_times(dir_fd, wasi::RIGHTS_FD_READ) }
+    }
+    unsafe { test_fd_filestat_set_times(dir_fd, wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE) }
+}
diff --git a/crates/test-programs/src/bin/preview1_fd_flags_set.rs b/crates/test-programs/src/bin/preview1_fd_flags_set.rs
new file mode 100644
index 000000000000..5c0be39b31f5
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_fd_flags_set.rs
@@ -0,0 +1,160 @@
+use std::{env, process};
+use test_programs::preview1::open_scratch_directory;
+
+unsafe fn test_fd_fdstat_set_flags(dir_fd: wasi::Fd) {
+    const FILE_NAME: &str = "file";
+    let data = &[0u8; 100];
+
+    let file_fd = wasi::path_open(
+        dir_fd,
+        0,
+        FILE_NAME,
+        wasi::OFLAGS_CREAT,
+        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
+        0,
+        wasi::FDFLAGS_APPEND,
+    )
+    .expect("opening a file");
+
+    // Write some data and then verify the written data
+    assert_eq!(
+        wasi::fd_write(
+            file_fd,
+            &[wasi::Ciovec {
+                buf: data.as_ptr(),
+                buf_len: data.len(),
+            }],
+        )
+        .expect("writing to a file"),
+        data.len(),
+        "should write {} bytes",
+        data.len(),
+    );
+
+    wasi::fd_seek(file_fd, 0, wasi::WHENCE_SET).expect("seeking file");
+
+    let buffer = &mut [0u8; 100];
+
+    assert_eq!(
+        wasi::fd_read(
+            file_fd,
+            &[wasi::Iovec {
+                buf: buffer.as_mut_ptr(),
+                buf_len: buffer.len(),
+            }]
+        )
+        .expect("reading file"),
+        buffer.len(),
+        "should read {} bytes",
+        buffer.len()
+    );
+
+    assert_eq!(&data[..], &buffer[..]);
+
+    let data = &[1u8; 100];
+
+    // Seek back to the start to ensure we're in append-only mode
+    wasi::fd_seek(file_fd, 0, wasi::WHENCE_SET).expect("seeking file");
+
+    assert_eq!(
+        wasi::fd_write(
+            file_fd,
+            &[wasi::Ciovec {
+                buf: data.as_ptr(),
+                buf_len: data.len(),
+            }],
+        )
+        .expect("writing to a file"),
+        data.len(),
+        "should write {} bytes",
+        data.len(),
+    );
+
+    wasi::fd_seek(file_fd, 100, wasi::WHENCE_SET).expect("seeking file");
+
+    assert_eq!(
+        wasi::fd_read(
+            file_fd,
+            &[wasi::Iovec {
+                buf: buffer.as_mut_ptr(),
+                buf_len: buffer.len(),
+            }]
+        )
+        .expect("reading file"),
+        buffer.len(),
+        "should read {} bytes",
+        buffer.len()
+    );
+
+    assert_eq!(&data[..], &buffer[..]);
+
+    wasi::fd_fdstat_set_flags(file_fd, 0).expect("disabling flags");
+
+    // Overwrite some existing data to ensure the append mode is now off
+    wasi::fd_seek(file_fd, 0, wasi::WHENCE_SET).expect("seeking file");
+
+    let data = &[2u8; 100];
+
+    assert_eq!(
+        wasi::fd_write(
+            file_fd,
+            &[wasi::Ciovec {
+                buf: data.as_ptr(),
+                buf_len: data.len(),
+            }],
+        )
+        .expect("writing to a file"),
+        data.len(),
+        "should write {} bytes",
+        data.len(),
+    );
+
+    wasi::fd_seek(file_fd, 0, wasi::WHENCE_SET).expect("seeking file");
+
+    assert_eq!(
+        wasi::fd_read(
+            file_fd,
+            &[wasi::Iovec {
+                buf: buffer.as_mut_ptr(),
+                buf_len: buffer.len(),
+            }]
+        )
+        .expect("reading file"),
+        buffer.len(),
+        "should read {} bytes",
+        buffer.len()
+    );
+
+    assert_eq!(&data[..], &buffer[..]);
+
+    wasi::fd_close(file_fd).expect("close file");
+
+    let stat = wasi::path_filestat_get(dir_fd, 0, FILE_NAME).expect("stat path");
+
+    assert_eq!(stat.size, 200, "expected a file size of 200");
+
+    wasi::path_unlink_file(dir_fd, FILE_NAME).expect("unlinking file");
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    unsafe {
+        test_fd_fdstat_set_flags(dir_fd);
+    }
+}
diff --git a/crates/test-programs/src/bin/preview1_fd_readdir.rs b/crates/test-programs/src/bin/preview1_fd_readdir.rs
new file mode 100644
index 000000000000..021a593eedb0
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_fd_readdir.rs
@@ -0,0 +1,265 @@
+use std::{env, mem, process, slice, str};
+use test_programs::preview1::open_scratch_directory;
+
+const BUF_LEN: usize = 256;
+
+struct DirEntry {
+    dirent: wasi::Dirent,
+    name: String,
+}
+
+// Manually reading the output from fd_readdir is tedious and repetitive,
+// so encapsulate it into an iterator
+struct ReadDir<'a> {
+    buf: &'a [u8],
+}
+
+impl<'a> ReadDir<'a> {
+    fn from_slice(buf: &'a [u8]) -> Self {
+        Self { buf }
+    }
+}
+
+impl<'a> Iterator for ReadDir<'a> {
+    type Item = DirEntry;
+
+    fn next(&mut self) -> Option<DirEntry> {
+        unsafe {
+            if self.buf.len() < mem::size_of::<wasi::Dirent>() {
+                return None;
+            }
+
+            // Read the data
+            let dirent_ptr = self.buf.as_ptr() as *const wasi::Dirent;
+            let dirent = dirent_ptr.read_unaligned();
+
+            if self.buf.len() < mem::size_of::<wasi::Dirent>() + dirent.d_namlen as usize {
+                return None;
+            }
+
+            let name_ptr = dirent_ptr.offset(1) as *const u8;
+            // NOTE Linux syscall returns a NUL-terminated name, but WASI doesn't
+            let namelen = dirent.d_namlen as usize;
+            let slice = slice::from_raw_parts(name_ptr, namelen);
+            let name = str::from_utf8(slice).expect("invalid utf8").to_owned();
+
+            // Update the internal state
+            let delta = mem::size_of_val(&dirent) + namelen;
+            self.buf = &self.buf[delta..];
+
+            DirEntry { dirent, name }.into()
+        }
+    }
+}
+
+/// Return the entries plus a bool indicating EOF.
+unsafe fn exec_fd_readdir(fd: wasi::Fd, cookie: wasi::Dircookie) -> (Vec<DirEntry>, bool) {
+    let mut buf: [u8; BUF_LEN] = [0; BUF_LEN];
+    let bufused =
+        wasi::fd_readdir(fd, buf.as_mut_ptr(), BUF_LEN, cookie).expect("failed fd_readdir");
+    assert!(bufused <= BUF_LEN);
+
+    let sl = slice::from_raw_parts(buf.as_ptr(), bufused);
+    let dirs: Vec<_> = ReadDir::from_slice(sl).collect();
+    let eof = bufused < BUF_LEN;
+    (dirs, eof)
+}
+
+unsafe fn assert_empty_dir(dir_fd: wasi::Fd) {
+    let stat = wasi::fd_filestat_get(dir_fd).expect("failed filestat");
+
+    let (mut dirs, eof) = exec_fd_readdir(dir_fd, 0);
+    assert!(eof, "expected to read the entire directory");
+    dirs.sort_by_key(|d| d.name.clone());
+    assert_eq!(dirs.len(), 2, "expected two entries in an empty directory");
+    let mut dirs = dirs.into_iter();
+
+    // the first entry should be `.`
+    let dir = dirs.next().expect("first entry is None");
+    assert_eq!(dir.name, ".", "first name");
+    assert_eq!(dir.dirent.d_type, wasi::FILETYPE_DIRECTORY, "first type");
+    assert_eq!(dir.dirent.d_ino, stat.ino);
+    assert_eq!(dir.dirent.d_namlen, 1);
+
+    // the second entry should be `..`
+    let dir = dirs.next().expect("second entry is None");
+    assert_eq!(dir.name, "..", "second name");
+    assert_eq!(dir.dirent.d_type, wasi::FILETYPE_DIRECTORY, "second type");
+
+    assert!(
+        dirs.next().is_none(),
+        "the directory should be seen as empty"
+    );
+}
+
+unsafe fn test_fd_readdir(dir_fd: wasi::Fd) {
+    // Check the behavior in an empty directory
+    assert_empty_dir(dir_fd);
+
+    // Add a file and check the behavior
+    let file_fd = wasi::path_open(
+        dir_fd,
+        0,
+        "file",
+        wasi::OFLAGS_CREAT,
+        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
+        0,
+        0,
+    )
+    .expect("failed to create file");
+    assert!(
+        file_fd > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+
+    let file_stat = wasi::fd_filestat_get(file_fd).expect("failed filestat");
+    wasi::fd_close(file_fd).expect("closing a file");
+
+    wasi::path_create_directory(dir_fd, "nested").expect("create a directory");
+    let nested_fd =
+        wasi::path_open(dir_fd, 0, "nested", 0, 0, 0, 0).expect("failed to open nested directory");
+    let nested_stat = wasi::fd_filestat_get(nested_fd).expect("failed filestat");
+
+    // Execute another readdir
+    let (mut dirs, eof) = exec_fd_readdir(dir_fd, 0);
+    assert!(eof, "expected to read the entire directory");
+    assert_eq!(dirs.len(), 4, "expected four entries");
+    // Save the data about the last entry. We need to do it before sorting.
+    let lastfile_cookie = dirs[2].dirent.d_next;
+    let lastfile_name = dirs[3].name.clone();
+    dirs.sort_by_key(|d| d.name.clone());
+    let mut dirs = dirs.into_iter();
+
+    let dir = dirs.next().expect("first entry is None");
+    assert_eq!(dir.name, ".", "first name");
+    let dir = dirs.next().expect("second entry is None");
+    assert_eq!(dir.name, "..", "second name");
+    let dir = dirs.next().expect("third entry is None");
+    // check the file info
+    assert_eq!(dir.name, "file", "file name doesn't match");
+    assert_eq!(
+        dir.dirent.d_type,
+        wasi::FILETYPE_REGULAR_FILE,
+        "type for the real file"
+    );
+    assert_eq!(dir.dirent.d_ino, file_stat.ino);
+    let dir = dirs.next().expect("fourth entry is None");
+    // check the directory info
+    assert_eq!(dir.name, "nested", "nested directory name doesn't match");
+    assert_eq!(
+        dir.dirent.d_type,
+        wasi::FILETYPE_DIRECTORY,
+        "type for the nested directory"
+    );
+    assert_eq!(dir.dirent.d_ino, nested_stat.ino);
+
+    // check if cookie works as expected
+    let (dirs, eof) = exec_fd_readdir(dir_fd, lastfile_cookie);
+    assert!(eof, "expected to read the entire directory");
+    assert_eq!(dirs.len(), 1, "expected one entry");
+    assert_eq!(dirs[0].name, lastfile_name, "name of the only entry");
+
+    // check if nested directory shows up as empty
+    assert_empty_dir(nested_fd);
+    wasi::fd_close(nested_fd).expect("closing a nested directory");
+
+    wasi::path_unlink_file(dir_fd, "file").expect("removing a file");
+    wasi::path_remove_directory(dir_fd, "nested").expect("removing a nested directory");
+}
+
+unsafe fn test_fd_readdir_lots(dir_fd: wasi::Fd) {
+    // Add a file and check the behavior
+    for count in 0..1000 {
+        let file_fd = wasi::path_open(
+            dir_fd,
+            0,
+            &format!("file.{count}"),
+            wasi::OFLAGS_CREAT,
+            wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
+            0,
+            0,
+        )
+        .expect("failed to create file");
+        assert!(
+            file_fd > libc::STDERR_FILENO as wasi::Fd,
+            "file descriptor range check",
+        );
+        wasi::fd_close(file_fd).expect("closing a file");
+    }
+
+    // Count the entries to ensure that we see the correct number.
+    let mut total = 0;
+    let mut cookie = 0;
+    loop {
+        let (dirs, eof) = exec_fd_readdir(dir_fd, cookie);
+        total += dirs.len();
+        if eof {
+            break;
+        }
+        cookie = dirs[dirs.len() - 1].dirent.d_next;
+    }
+    assert_eq!(total, 1002, "expected 1000 entries plus . and ..");
+
+    for count in 0..1000 {
+        wasi::path_unlink_file(dir_fd, &format!("file.{count}")).expect("removing a file");
+    }
+}
+
+unsafe fn test_fd_readdir_unicode_boundary(dir_fd: wasi::Fd) {
+    let filename = "Действие";
+    let file_fd = wasi::path_open(
+        dir_fd,
+        0,
+        filename,
+        wasi::OFLAGS_CREAT,
+        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
+        0,
+        0,
+    )
+    .expect("failed to create file");
+    assert!(
+        file_fd > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+    wasi::fd_close(file_fd).expect("closing a file");
+
+    let mut buf = Vec::new();
+    'outer: loop {
+        let len = wasi::fd_readdir(dir_fd, buf.as_mut_ptr(), buf.capacity(), 0).unwrap();
+        buf.set_len(len);
+
+        for entry in ReadDir::from_slice(&buf) {
+            if entry.name == filename {
+                break 'outer;
+            }
+        }
+        buf = Vec::with_capacity(buf.capacity() + 1);
+    }
+
+    wasi::path_unlink_file(dir_fd, filename).expect("removing a file");
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_fd_readdir(dir_fd) }
+    unsafe { test_fd_readdir_lots(dir_fd) }
+    unsafe { test_fd_readdir_unicode_boundary(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview1_file_allocate.rs b/crates/test-programs/src/bin/preview1_file_allocate.rs
new file mode 100644
index 000000000000..987e44a93a6b
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_file_allocate.rs
@@ -0,0 +1,62 @@
+use std::{env, process};
+use test_programs::preview1::open_scratch_directory;
+
+unsafe fn test_file_allocate(dir_fd: wasi::Fd) {
+    // Create a file in the scratch directory.
+    let file_fd = wasi::path_open(
+        dir_fd,
+        0,
+        "file",
+        wasi::OFLAGS_CREAT,
+        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
+        0,
+        0,
+    )
+    .expect("opening a file");
+    assert!(
+        file_fd > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+
+    // Check file size
+    let mut stat = wasi::fd_filestat_get(file_fd).expect("reading file stats");
+    assert_eq!(stat.size, 0, "file size should be 0");
+
+    let err = wasi::fd_allocate(file_fd, 0, 100)
+        .err()
+        .expect("fd_allocate must fail");
+    assert_eq!(
+        err,
+        wasi::ERRNO_NOTSUP,
+        "fd_allocate should fail with NOTSUP"
+    );
+
+    stat = wasi::fd_filestat_get(file_fd).expect("reading file stats");
+    assert_eq!(stat.size, 0, "file size should still be 0");
+
+    wasi::fd_close(file_fd).expect("closing a file");
+    wasi::path_unlink_file(dir_fd, "file").expect("removing a file");
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_file_allocate(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview1_file_pread_pwrite.rs b/crates/test-programs/src/bin/preview1_file_pread_pwrite.rs
new file mode 100644
index 000000000000..dae3f332ebfe
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_file_pread_pwrite.rs
@@ -0,0 +1,240 @@
+use std::{env, process};
+use test_programs::preview1::open_scratch_directory;
+
+unsafe fn test_file_pread_pwrite(dir_fd: wasi::Fd) {
+    // Create a file in the scratch directory.
+    let file_fd = wasi::path_open(
+        dir_fd,
+        0,
+        "file",
+        wasi::OFLAGS_CREAT,
+        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
+        0,
+        0,
+    )
+    .expect("opening a file");
+    assert!(
+        file_fd > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+
+    let contents = &[0u8, 1, 2, 3];
+    let ciovec = wasi::Ciovec {
+        buf: contents.as_ptr() as *const _,
+        buf_len: contents.len(),
+    };
+    let mut nwritten =
+        wasi::fd_pwrite(file_fd, &mut [ciovec], 0).expect("writing bytes at offset 0");
+    assert_eq!(nwritten, 4, "nwritten bytes check");
+
+    let contents = &mut [0u8; 4];
+    let iovec = wasi::Iovec {
+        buf: contents.as_mut_ptr() as *mut _,
+        buf_len: contents.len(),
+    };
+    let mut nread = wasi::fd_pread(file_fd, &[iovec], 0).expect("reading bytes at offset 0");
+    assert_eq!(nread, 4, "nread bytes check");
+    assert_eq!(contents, &[0u8, 1, 2, 3], "written bytes equal read bytes");
+
+    // Write all the data through multiple iovecs.
+    //
+    // Note that this needs to be done with a loop, because some
+    // platforms do not support writing multiple iovecs at once.
+    // See https://github.com/rust-lang/rust/issues/74825.
+    let contents = &[0u8, 1, 2, 3];
+    let mut offset = 0usize;
+    loop {
+        let mut ciovecs: Vec<wasi::Ciovec> = Vec::new();
+        let mut remaining = contents.len() - offset;
+        if remaining > 2 {
+            ciovecs.push(wasi::Ciovec {
+                buf: contents[offset..].as_ptr() as *const _,
+                buf_len: 2,
+            });
+            remaining -= 2;
+        }
+        ciovecs.push(wasi::Ciovec {
+            buf: contents[contents.len() - remaining..].as_ptr() as *const _,
+            buf_len: remaining,
+        });
+
+        nwritten = wasi::fd_pwrite(file_fd, ciovecs.as_slice(), offset.try_into().unwrap())
+            .expect("writing bytes at offset 0");
+
+        offset += nwritten;
+        if offset == contents.len() {
+            break;
+        }
+    }
+    assert_eq!(offset, 4, "nread bytes check");
+
+    // Read all the data through multiple iovecs.
+    //
+    // Note that this needs to be done with a loop, because some
+    // platforms do not support reading multiple iovecs at once.
+    // See https://github.com/rust-lang/rust/issues/74825.
+    let contents = &mut [0u8; 4];
+    let mut offset = 0usize;
+    loop {
+        let buffer = &mut [0u8; 4];
+        let iovecs = &[
+            wasi::Iovec {
+                buf: buffer.as_mut_ptr() as *mut _,
+                buf_len: 2,
+            },
+            wasi::Iovec {
+                buf: buffer[2..].as_mut_ptr() as *mut _,
+                buf_len: 2,
+            },
+        ];
+        nread = wasi::fd_pread(file_fd, iovecs, offset as _).expect("reading bytes at offset 0");
+        if nread == 0 {
+            break;
+        }
+        contents[offset..offset + nread].copy_from_slice(&buffer[0..nread]);
+        offset += nread;
+    }
+    assert_eq!(offset, 4, "nread bytes check");
+    assert_eq!(contents, &[0u8, 1, 2, 3], "file cursor was overwritten");
+
+    let contents = &mut [0u8; 4];
+    let iovec = wasi::Iovec {
+        buf: contents.as_mut_ptr() as *mut _,
+        buf_len: contents.len(),
+    };
+    nread = wasi::fd_pread(file_fd, &[iovec], 2).expect("reading bytes at offset 2");
+    assert_eq!(nread, 2, "nread bytes check");
+    assert_eq!(contents, &[2u8, 3, 0, 0], "file cursor was overwritten");
+
+    let contents = &[1u8, 0];
+    let ciovec = wasi::Ciovec {
+        buf: contents.as_ptr() as *const _,
+        buf_len: contents.len(),
+    };
+    nwritten = wasi::fd_pwrite(file_fd, &mut [ciovec], 2).expect("writing bytes at offset 2");
+    assert_eq!(nwritten, 2, "nwritten bytes check");
+
+    let contents = &mut [0u8; 4];
+    let iovec = wasi::Iovec {
+        buf: contents.as_mut_ptr() as *mut _,
+        buf_len: contents.len(),
+    };
+    nread = wasi::fd_pread(file_fd, &[iovec], 0).expect("reading bytes at offset 0");
+    assert_eq!(nread, 4, "nread bytes check");
+    assert_eq!(contents, &[0u8, 1, 1, 0], "file cursor was overwritten");
+
+    wasi::fd_close(file_fd).expect("closing a file");
+    wasi::path_unlink_file(dir_fd, "file").expect("removing a file");
+}
+
+unsafe fn test_file_pwrite_and_file_pos(dir_fd: wasi::Fd) {
+    let path = "file2";
+    let file_fd = wasi::path_open(
+        dir_fd,
+        0,
+        path,
+        wasi::OFLAGS_CREAT,
+        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
+        0,
+        0,
+    )
+    .expect("opening a file");
+    assert!(
+        file_fd > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+
+    // Perform a 0-sized pwrite at an offset beyond the end of the file. Unix
+    // semantics should pop out where nothing is actually written and the size
+    // of the file isn't modified.
+    assert_eq!(wasi::fd_tell(file_fd).unwrap(), 0);
+    let ciovec = wasi::Ciovec {
+        buf: [].as_ptr(),
+        buf_len: 0,
+    };
+    let n = wasi::fd_pwrite(file_fd, &mut [ciovec], 50).expect("writing bytes at offset 2");
+    assert_eq!(n, 0);
+
+    assert_eq!(wasi::fd_tell(file_fd).unwrap(), 0);
+    let stat = wasi::fd_filestat_get(file_fd).unwrap();
+    assert_eq!(stat.size, 0);
+
+    // Now write a single byte and make sure it actually works
+    let buf = [0];
+    let ciovec = wasi::Ciovec {
+        buf: buf.as_ptr(),
+        buf_len: buf.len(),
+    };
+    let n = wasi::fd_pwrite(file_fd, &mut [ciovec], 50).expect("writing bytes at offset 50");
+    assert_eq!(n, 1);
+
+    assert_eq!(wasi::fd_tell(file_fd).unwrap(), 0);
+    let stat = wasi::fd_filestat_get(file_fd).unwrap();
+    assert_eq!(stat.size, 51);
+
+    wasi::fd_close(file_fd).expect("closing a file");
+    wasi::path_unlink_file(dir_fd, path).expect("removing a file");
+}
+
+unsafe fn test_file_pwrite_and_append(dir_fd: wasi::Fd) {
+    let path = "file3";
+    let file_fd = wasi::path_open(
+        dir_fd,
+        0,
+        path,
+        wasi::OFLAGS_CREAT,
+        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
+        0,
+        wasi::FDFLAGS_APPEND,
+    )
+    .expect("opening a file");
+
+    // Inherit linux semantics for `pwrite` where if the file is opened in
+    // append mode then the offset to `pwrite` is ignored.
+    let buf = [0];
+    let ciovec = wasi::Ciovec {
+        buf: buf.as_ptr(),
+        buf_len: buf.len(),
+    };
+    let n = wasi::fd_pwrite(file_fd, &[ciovec], 50).expect("writing bytes at offset 50");
+    assert_eq!(n, 1);
+
+    let stat = wasi::fd_filestat_get(file_fd).unwrap();
+    assert_eq!(stat.size, 1);
+
+    let n = wasi::fd_pwrite(file_fd, &[ciovec], 0).expect("writing bytes at offset 50");
+    assert_eq!(n, 1);
+
+    let stat = wasi::fd_filestat_get(file_fd).unwrap();
+    assert_eq!(stat.size, 2);
+
+    wasi::fd_close(file_fd).expect("closing a file");
+    wasi::path_unlink_file(dir_fd, path).expect("removing a file");
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe {
+        test_file_pread_pwrite(dir_fd);
+        test_file_pwrite_and_file_pos(dir_fd);
+        test_file_pwrite_and_append(dir_fd);
+    }
+}
diff --git a/crates/test-programs/src/bin/preview1_file_read_write.rs b/crates/test-programs/src/bin/preview1_file_read_write.rs
new file mode 100644
index 000000000000..a1558ee495d2
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_file_read_write.rs
@@ -0,0 +1,209 @@
+use std::{env, process};
+use test_programs::preview1::open_scratch_directory;
+
+unsafe fn test_file_read_write(dir_fd: wasi::Fd) {
+    // Create a file in the scratch directory.
+    let file_fd = wasi::path_open(
+        dir_fd,
+        0,
+        "file",
+        wasi::OFLAGS_CREAT,
+        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
+        0,
+        0,
+    )
+    .expect("opening a file");
+    assert!(
+        file_fd > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+
+    let contents = &[0u8, 1, 2, 3];
+    let ciovec = wasi::Ciovec {
+        buf: contents.as_ptr() as *const _,
+        buf_len: contents.len(),
+    };
+    let mut nwritten = wasi::fd_write(file_fd, &mut [ciovec]).expect("writing bytes at offset 0");
+    assert_eq!(nwritten, 4, "nwritten bytes check");
+
+    let contents = &mut [0u8; 4];
+    let iovec = wasi::Iovec {
+        buf: contents.as_mut_ptr() as *mut _,
+        buf_len: contents.len(),
+    };
+    wasi::fd_seek(file_fd, 0, wasi::WHENCE_SET).expect("seeking to offset 0");
+    let mut nread = wasi::fd_read(file_fd, &[iovec]).expect("reading bytes at offset 0");
+    assert_eq!(nread, 4, "nread bytes check");
+    assert_eq!(contents, &[0u8, 1, 2, 3], "written bytes equal read bytes");
+
+    // Write all the data through multiple iovecs.
+    //
+    // Note that this needs to be done with a loop, because some
+    // platforms do not support writing multiple iovecs at once.
+    // See https://github.com/rust-lang/rust/issues/74825.
+    let contents = &[0u8, 1, 2, 3];
+    let mut offset = 0usize;
+    wasi::fd_seek(file_fd, 0, wasi::WHENCE_SET).expect("seeking to offset 0");
+    loop {
+        let mut ciovecs: Vec<wasi::Ciovec> = Vec::new();
+        let mut remaining = contents.len() - offset;
+        if remaining > 2 {
+            ciovecs.push(wasi::Ciovec {
+                buf: contents[offset..].as_ptr() as *const _,
+                buf_len: 2,
+            });
+            remaining -= 2;
+        }
+        ciovecs.push(wasi::Ciovec {
+            buf: contents[contents.len() - remaining..].as_ptr() as *const _,
+            buf_len: remaining,
+        });
+
+        nwritten = wasi::fd_write(file_fd, ciovecs.as_slice()).expect("writing bytes at offset 0");
+
+        offset += nwritten;
+        if offset == contents.len() {
+            break;
+        }
+    }
+    assert_eq!(offset, 4, "nread bytes check");
+
+    // Read all the data through multiple iovecs.
+    //
+    // Note that this needs to be done with a loop, because some
+    // platforms do not support reading multiple iovecs at once.
+    // See https://github.com/rust-lang/rust/issues/74825.
+    let contents = &mut [0u8; 4];
+    let mut offset = 0usize;
+    wasi::fd_seek(file_fd, 0, wasi::WHENCE_SET).expect("seeking to offset 0");
+    loop {
+        let buffer = &mut [0u8; 4];
+        let iovecs = &[
+            wasi::Iovec {
+                buf: buffer.as_mut_ptr() as *mut _,
+                buf_len: 2,
+            },
+            wasi::Iovec {
+                buf: buffer[2..].as_mut_ptr() as *mut _,
+                buf_len: 2,
+            },
+        ];
+        nread = wasi::fd_read(file_fd, iovecs).expect("reading bytes at offset 0");
+        if nread == 0 {
+            break;
+        }
+        contents[offset..offset + nread].copy_from_slice(&buffer[0..nread]);
+        offset += nread;
+    }
+    assert_eq!(offset, 4, "nread bytes check");
+    assert_eq!(contents, &[0u8, 1, 2, 3], "file cursor was overwritten");
+
+    let contents = &mut [0u8; 4];
+    let iovec = wasi::Iovec {
+        buf: contents.as_mut_ptr() as *mut _,
+        buf_len: contents.len(),
+    };
+    wasi::fd_seek(file_fd, 2, wasi::WHENCE_SET).expect("seeking to offset 2");
+    nread = wasi::fd_read(file_fd, &[iovec]).expect("reading bytes at offset 2");
+    assert_eq!(nread, 2, "nread bytes check");
+    assert_eq!(contents, &[2u8, 3, 0, 0], "file cursor was overwritten");
+
+    let contents = &[1u8, 0];
+    let ciovec = wasi::Ciovec {
+        buf: contents.as_ptr() as *const _,
+        buf_len: contents.len(),
+    };
+    wasi::fd_seek(file_fd, 2, wasi::WHENCE_SET).expect("seeking to offset 2");
+    nwritten = wasi::fd_write(file_fd, &mut [ciovec]).expect("writing bytes at offset 2");
+    assert_eq!(nwritten, 2, "nwritten bytes check");
+
+    let contents = &mut [0u8; 4];
+    let iovec = wasi::Iovec {
+        buf: contents.as_mut_ptr() as *mut _,
+        buf_len: contents.len(),
+    };
+    wasi::fd_seek(file_fd, 0, wasi::WHENCE_SET).expect("seeking to offset 0");
+    nread = wasi::fd_read(file_fd, &[iovec]).expect("reading bytes at offset 0");
+    assert_eq!(nread, 4, "nread bytes check");
+    assert_eq!(contents, &[0u8, 1, 1, 0], "file cursor was overwritten");
+
+    wasi::fd_close(file_fd).expect("closing a file");
+    wasi::path_unlink_file(dir_fd, "file").expect("removing a file");
+}
+
+unsafe fn test_file_write_and_file_pos(dir_fd: wasi::Fd) {
+    let path = "file2";
+    let file_fd = wasi::path_open(
+        dir_fd,
+        0,
+        path,
+        wasi::OFLAGS_CREAT,
+        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
+        0,
+        0,
+    )
+    .expect("opening a file");
+    assert!(
+        file_fd > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+
+    // Perform a 0-sized pwrite at an offset beyond the end of the file. Unix
+    // semantics should pop out where nothing is actually written and the size
+    // of the file isn't modified.
+    assert_eq!(wasi::fd_tell(file_fd).unwrap(), 0);
+    let ciovec = wasi::Ciovec {
+        buf: [].as_ptr(),
+        buf_len: 0,
+    };
+    wasi::fd_seek(file_fd, 2, wasi::WHENCE_SET).expect("seeking to offset 2");
+    let n = wasi::fd_write(file_fd, &mut [ciovec]).expect("writing bytes at offset 2");
+    assert_eq!(n, 0);
+
+    assert_eq!(wasi::fd_tell(file_fd).unwrap(), 2);
+    let stat = wasi::fd_filestat_get(file_fd).unwrap();
+    assert_eq!(stat.size, 0);
+
+    // Now write a single byte and make sure it actually works
+    let buf = [0];
+    let ciovec = wasi::Ciovec {
+        buf: buf.as_ptr(),
+        buf_len: buf.len(),
+    };
+    wasi::fd_seek(file_fd, 50, wasi::WHENCE_SET).expect("seeking to offset 50");
+    let n = wasi::fd_write(file_fd, &mut [ciovec]).expect("writing bytes at offset 50");
+    assert_eq!(n, 1);
+
+    assert_eq!(wasi::fd_tell(file_fd).unwrap(), 51);
+    let stat = wasi::fd_filestat_get(file_fd).unwrap();
+    assert_eq!(stat.size, 51);
+
+    wasi::fd_close(file_fd).expect("closing a file");
+    wasi::path_unlink_file(dir_fd, path).expect("removing a file");
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe {
+        test_file_read_write(dir_fd);
+        test_file_write_and_file_pos(dir_fd);
+    }
+}
diff --git a/crates/test-programs/src/bin/preview1_file_seek_tell.rs b/crates/test-programs/src/bin/preview1_file_seek_tell.rs
new file mode 100644
index 000000000000..738b664e4435
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_file_seek_tell.rs
@@ -0,0 +1,148 @@
+use std::{env, process};
+use test_programs::preview1::{assert_errno, open_scratch_directory};
+
+unsafe fn test_file_seek_tell(dir_fd: wasi::Fd) {
+    // Create a file in the scratch directory.
+    let file_fd = wasi::path_open(
+        dir_fd,
+        0,
+        "file",
+        wasi::OFLAGS_CREAT,
+        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
+        0,
+        0,
+    )
+    .expect("opening a file");
+    assert!(
+        file_fd > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+
+    // Check current offset
+    let mut offset = wasi::fd_tell(file_fd).expect("getting initial file offset");
+    assert_eq!(offset, 0, "current offset should be 0");
+
+    // Write to file
+    let data = &[0u8; 100];
+    let iov = wasi::Ciovec {
+        buf: data.as_ptr() as *const _,
+        buf_len: data.len(),
+    };
+    let nwritten = wasi::fd_write(file_fd, &[iov]).expect("writing to a file");
+    assert_eq!(nwritten, 100, "should write 100 bytes to file");
+
+    // Check current offset
+    offset = wasi::fd_tell(file_fd).expect("getting file offset after writing");
+    assert_eq!(offset, 100, "offset after writing should be 100");
+
+    // Seek to middle of the file
+    let mut newoffset =
+        wasi::fd_seek(file_fd, -50, wasi::WHENCE_CUR).expect("seeking to the middle of a file");
+    assert_eq!(
+        newoffset, 50,
+        "offset after seeking to the middle should be at 50"
+    );
+
+    // Seek to the beginning of the file
+    newoffset =
+        wasi::fd_seek(file_fd, 0, wasi::WHENCE_SET).expect("seeking to the beginning of the file");
+    assert_eq!(
+        newoffset, 0,
+        "offset after seeking to the beginning of the file should be at 0"
+    );
+
+    // Seek beyond the file should be possible
+    wasi::fd_seek(file_fd, 1000, wasi::WHENCE_CUR).expect("seeking beyond the end of the file");
+
+    // Seek before byte 0 is an error though
+    assert_errno!(
+        wasi::fd_seek(file_fd, -2000, wasi::WHENCE_CUR)
+            .expect_err("seeking before byte 0 should be an error"),
+        wasi::ERRNO_INVAL
+    );
+
+    // Check that fd_read properly updates the file offset
+    wasi::fd_seek(file_fd, 0, wasi::WHENCE_SET)
+        .expect("seeking to the beginning of the file again");
+
+    let buffer = &mut [0u8; 100];
+    let iovec = wasi::Iovec {
+        buf: buffer.as_mut_ptr(),
+        buf_len: buffer.len(),
+    };
+    let nread = wasi::fd_read(file_fd, &[iovec]).expect("reading file");
+    assert_eq!(nread, buffer.len(), "should read {} bytes", buffer.len());
+
+    offset = wasi::fd_tell(file_fd).expect("getting file offset after reading");
+    assert_eq!(offset, 100, "offset after reading should be 100");
+
+    wasi::fd_close(file_fd).expect("closing a file");
+    wasi::path_unlink_file(dir_fd, "file").expect("deleting a file");
+}
+
+// Test that when a file is opened with `O_APPEND` that acquiring the current
+// position indicates the end of the file.
+unsafe fn seek_and_o_append(dir_fd: wasi::Fd) {
+    let path = "file2";
+    let file_fd = wasi::path_open(
+        dir_fd,
+        0,
+        path,
+        wasi::OFLAGS_CREAT,
+        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
+        0,
+        wasi::FDFLAGS_APPEND,
+    )
+    .expect("opening a file");
+    assert!(
+        file_fd > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+
+    let mut offset = wasi::fd_seek(file_fd, 0, wasi::WHENCE_CUR).unwrap();
+    assert_eq!(offset, 0);
+    offset = wasi::fd_tell(file_fd).unwrap();
+    assert_eq!(offset, 0);
+
+    let data = &[0u8; 100];
+    let iov = wasi::Ciovec {
+        buf: data.as_ptr() as *const _,
+        buf_len: data.len(),
+    };
+    let nwritten = wasi::fd_write(file_fd, &[iov]).unwrap();
+    assert_eq!(nwritten, 100);
+
+    let mut offset = wasi::fd_seek(file_fd, 0, wasi::WHENCE_CUR).unwrap();
+    assert_eq!(offset, 100);
+    offset = wasi::fd_tell(file_fd).unwrap();
+    assert_eq!(offset, 100);
+
+    wasi::fd_close(file_fd).unwrap();
+    wasi::path_unlink_file(dir_fd, path).unwrap();
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe {
+        test_file_seek_tell(dir_fd);
+        seek_and_o_append(dir_fd);
+    }
+}
diff --git a/crates/test-programs/src/bin/preview1_file_truncation.rs b/crates/test-programs/src/bin/preview1_file_truncation.rs
new file mode 100644
index 000000000000..42b1698bddfa
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_file_truncation.rs
@@ -0,0 +1,83 @@
+use std::{env, process};
+use test_programs::preview1::open_scratch_directory;
+
+unsafe fn test_file_truncation(dir_fd: wasi::Fd) {
+    const FILENAME: &str = "test.txt";
+
+    // Open a file for writing
+    let file_fd = wasi::path_open(
+        dir_fd,
+        0,
+        FILENAME,
+        wasi::OFLAGS_CREAT,
+        wasi::RIGHTS_FD_WRITE,
+        0,
+        0,
+    )
+    .expect("creating a file for writing");
+
+    // Write to the file
+    let content = b"this content will be truncated!";
+    let nwritten = wasi::fd_write(
+        file_fd,
+        &[wasi::Ciovec {
+            buf: content.as_ptr() as *const _,
+            buf_len: content.len(),
+        }],
+    )
+    .expect("writing file content");
+    assert_eq!(nwritten, content.len(), "nwritten bytes check");
+
+    wasi::fd_close(file_fd).expect("closing the file");
+
+    // Open the file for truncation
+    let file_fd = wasi::path_open(
+        dir_fd,
+        0,
+        FILENAME,
+        wasi::OFLAGS_CREAT | wasi::OFLAGS_TRUNC,
+        wasi::RIGHTS_FD_WRITE | wasi::RIGHTS_FD_READ,
+        0,
+        0,
+    )
+    .expect("creating a truncated file for reading");
+
+    // Read the file's contents
+    let buffer = &mut [0u8; 100];
+    let nread = wasi::fd_read(
+        file_fd,
+        &[wasi::Iovec {
+            buf: buffer.as_mut_ptr(),
+            buf_len: buffer.len(),
+        }],
+    )
+    .expect("reading file content");
+
+    // The file should be empty due to truncation
+    assert_eq!(nread, 0, "expected an empty file after truncation");
+
+    wasi::fd_close(file_fd).expect("closing the file");
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_file_truncation(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview1_file_unbuffered_write.rs b/crates/test-programs/src/bin/preview1_file_unbuffered_write.rs
new file mode 100644
index 000000000000..ba0cb52cd0a6
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_file_unbuffered_write.rs
@@ -0,0 +1,74 @@
+use std::{env, process};
+use test_programs::preview1::open_scratch_directory;
+
+unsafe fn test_file_unbuffered_write(dir_fd: wasi::Fd) {
+    // Create and open file for reading
+    let fd_read = wasi::path_open(
+        dir_fd,
+        0,
+        "file",
+        wasi::OFLAGS_CREAT,
+        wasi::RIGHTS_FD_READ,
+        0,
+        0,
+    )
+    .expect("create and open file for reading");
+    assert!(
+        fd_read > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+
+    // Open the same file but for writing
+    let fd_write = wasi::path_open(dir_fd, 0, "file", 0, wasi::RIGHTS_FD_WRITE, 0, 0)
+        .expect("opening file for writing");
+    assert!(
+        fd_write > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+
+    // Write to file
+    let contents = &[1u8];
+    let ciovec = wasi::Ciovec {
+        buf: contents.as_ptr() as *const _,
+        buf_len: contents.len(),
+    };
+    let nwritten = wasi::fd_write(fd_write, &[ciovec]).expect("writing byte to file");
+    assert_eq!(nwritten, 1, "nwritten bytes check");
+
+    // Read from file
+    let contents = &mut [0u8; 1];
+    let iovec = wasi::Iovec {
+        buf: contents.as_mut_ptr() as *mut _,
+        buf_len: contents.len(),
+    };
+    let nread = wasi::fd_read(fd_read, &[iovec]).expect("reading bytes from file");
+    assert_eq!(nread, 1, "nread bytes check");
+    assert_eq!(contents, &[1u8], "written bytes equal read bytes");
+
+    // Clean up
+    wasi::fd_close(fd_write).expect("closing a file");
+    wasi::fd_close(fd_read).expect("closing a file");
+    wasi::path_unlink_file(dir_fd, "file").expect("removing a file");
+}
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_file_unbuffered_write(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview1_file_write.rs b/crates/test-programs/src/bin/preview1_file_write.rs
new file mode 100644
index 000000000000..7047fcf25dc2
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_file_write.rs
@@ -0,0 +1,133 @@
+use std::{env, process};
+use test_programs::preview1::open_scratch_directory;
+
+unsafe fn test_file_long_write(dir_fd: wasi::Fd, filename: &str) {
+    // Open a file for writing
+    let file_fd = wasi::path_open(
+        dir_fd,
+        0,
+        filename,
+        wasi::OFLAGS_CREAT,
+        wasi::RIGHTS_FD_WRITE,
+        0,
+        0,
+    )
+    .expect("creating a file for writing");
+
+    let mut content = Vec::new();
+    // 16 byte string, 4096 times, is 64k
+    for n in 0..4096 {
+        let chunk = format!("123456789 {n:05} ");
+        assert_eq!(chunk.as_str().as_bytes().len(), 16);
+        content.extend_from_slice(chunk.as_str().as_bytes());
+    }
+
+    // Write to the file
+    let nwritten = wasi::fd_write(
+        file_fd,
+        &[wasi::Ciovec {
+            buf: content.as_slice().as_ptr() as *const _,
+            buf_len: content.len(),
+        }],
+    )
+    .expect("writing file content");
+    assert_eq!(nwritten, content.len(), "nwritten bytes check");
+
+    let stat = wasi::fd_filestat_get(file_fd).expect("reading file stats");
+    assert_eq!(
+        stat.size,
+        content.len() as u64,
+        "file should be size of content",
+    );
+
+    wasi::fd_close(file_fd).expect("closing the file");
+    // Open the file for reading
+    let file_fd = wasi::path_open(dir_fd, 0, filename, 0, wasi::RIGHTS_FD_READ, 0, 0)
+        .expect("open the file for reading");
+
+    // Read the file's contents
+    let buffer = &mut [0u8; 100];
+    let nread = wasi::fd_read(
+        file_fd,
+        &[wasi::Iovec {
+            buf: buffer.as_mut_ptr(),
+            buf_len: buffer.len(),
+        }],
+    )
+    .expect("reading first chunk file content");
+
+    assert_eq!(nread, buffer.len(), "read first chunk");
+    assert_eq!(
+        buffer,
+        &content[..buffer.len()],
+        "contents of first read chunk"
+    );
+
+    let end_cursor = content.len() - buffer.len();
+    wasi::fd_seek(file_fd, end_cursor as i64, wasi::WHENCE_SET)
+        .expect("seeking to end of file minus buffer size");
+
+    let nread = wasi::fd_read(
+        file_fd,
+        &[wasi::Iovec {
+            buf: buffer.as_mut_ptr(),
+            buf_len: buffer.len(),
+        }],
+    )
+    .expect("reading end chunk of file content");
+
+    assert_eq!(nread, buffer.len(), "read end chunk len");
+    assert_eq!(buffer, &content[end_cursor..], "contents of end read chunk");
+
+    wasi::fd_close(file_fd).expect("closing the file");
+
+    // Open a file for writing
+    let filename = "test-zero-write-fails.txt";
+    let file_fd = wasi::path_open(
+        dir_fd,
+        0,
+        filename,
+        wasi::OFLAGS_CREAT,
+        wasi::RIGHTS_FD_WRITE,
+        0,
+        0,
+    )
+    .expect("creating a file for writing");
+    wasi::fd_close(file_fd).expect("closing the file");
+    let file_fd = wasi::path_open(dir_fd, 0, filename, 0, wasi::RIGHTS_FD_READ, 0, 0)
+        .expect("opening a file for writing");
+    let res = wasi::fd_write(
+        file_fd,
+        &[wasi::Ciovec {
+            buf: 3 as *const u8,
+            buf_len: 0,
+        }],
+    );
+    assert!(
+        res == Err(wasi::ERRNO_BADF) || res == Err(wasi::ERRNO_PERM),
+        "bad result {res:?}"
+    )
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_file_long_write(dir_fd, "long_write.txt") }
+}
diff --git a/crates/test-programs/src/bin/preview1_interesting_paths.rs b/crates/test-programs/src/bin/preview1_interesting_paths.rs
new file mode 100644
index 000000000000..e91d0bc3e653
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_interesting_paths.rs
@@ -0,0 +1,116 @@
+use std::{env, process};
+use test_programs::preview1::{assert_errno, create_file, open_scratch_directory};
+
+unsafe fn test_interesting_paths(dir_fd: wasi::Fd, arg: &str) {
+    // Create a directory in the scratch directory.
+    wasi::path_create_directory(dir_fd, "dir").expect("creating dir");
+
+    // Create a directory in the directory we just created.
+    wasi::path_create_directory(dir_fd, "dir/nested").expect("creating a nested dir");
+
+    // Create a file in the nested directory.
+    create_file(dir_fd, "dir/nested/file");
+
+    // Now open it with an absolute path.
+    assert_errno!(
+        wasi::path_open(dir_fd, 0, "/dir/nested/file", 0, 0, 0, 0)
+            .expect_err("opening a file with an absolute path"),
+        wasi::ERRNO_PERM
+    );
+
+    // Now open it with a path containing "..".
+    let mut file_fd = wasi::path_open(
+        dir_fd,
+        0,
+        "dir/.//nested/../../dir/nested/../nested///./file",
+        0,
+        0,
+        0,
+        0,
+    )
+    .expect("opening a file with \"..\" in the path");
+    assert!(
+        file_fd > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+    wasi::fd_close(file_fd).expect("closing a file");
+
+    // Now open it with a trailing NUL. Windows will allow this.
+    assert_errno!(
+        wasi::path_open(dir_fd, 0, "dir/nested/file\0", 0, 0, 0, 0)
+            .expect_err("opening a file with a trailing NUL"),
+        unix => wasi::ERRNO_INVAL,
+        windows => wasi::ERRNO_NOENT
+    );
+
+    // Now open it with a trailing slash.
+    assert_errno!(
+        wasi::path_open(dir_fd, 0, "dir/nested/file/", 0, 0, 0, 0)
+            .expect_err("opening a file with a trailing slash should fail"),
+        wasi::ERRNO_NOTDIR,
+        wasi::ERRNO_NOENT
+    );
+
+    // Now open it with trailing slashes.
+    assert_errno!(
+        wasi::path_open(dir_fd, 0, "dir/nested/file///", 0, 0, 0, 0)
+            .expect_err("opening a file with trailing slashes should fail"),
+        wasi::ERRNO_NOTDIR,
+        wasi::ERRNO_NOENT
+    );
+
+    // Now open the directory with a trailing slash.
+    file_fd = wasi::path_open(dir_fd, 0, "dir/nested/", 0, 0, 0, 0)
+        .expect("opening a directory with a trailing slash");
+    assert!(
+        file_fd > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+    wasi::fd_close(file_fd).expect("closing a file");
+
+    // Now open the directory with trailing slashes.
+    file_fd = wasi::path_open(dir_fd, 0, "dir/nested///", 0, 0, 0, 0)
+        .expect("opening a directory with trailing slashes");
+    assert!(
+        file_fd > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+    wasi::fd_close(file_fd).expect("closing a file");
+
+    // Now open it with a path containing too many ".."s.
+    let bad_path = format!("dir/nested/../../../{arg}/dir/nested/file");
+    assert_errno!(
+        wasi::path_open(dir_fd, 0, &bad_path, 0, 0, 0, 0)
+            .expect_err("opening a file with too many \"..\"s in the path should fail"),
+        wasi::ERRNO_PERM
+    );
+    wasi::path_unlink_file(dir_fd, "dir/nested/file")
+        .expect("unlink_file on a symlink should succeed");
+    wasi::path_remove_directory(dir_fd, "dir/nested")
+        .expect("remove_directory on a directory should succeed");
+    wasi::path_remove_directory(dir_fd, "dir")
+        .expect("remove_directory on a directory should succeed");
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_interesting_paths(dir_fd, &arg) }
+}
diff --git a/crates/test-programs/src/bin/preview1_nofollow_errors.rs b/crates/test-programs/src/bin/preview1_nofollow_errors.rs
new file mode 100644
index 000000000000..2c5d1bcfa880
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_nofollow_errors.rs
@@ -0,0 +1,110 @@
+use std::{env, process};
+use test_programs::preview1::{assert_errno, open_scratch_directory};
+
+unsafe fn test_nofollow_errors(dir_fd: wasi::Fd) {
+    // Create a directory for the symlink to point to.
+    wasi::path_create_directory(dir_fd, "target").expect("creating a dir");
+
+    // Create a symlink.
+    wasi::path_symlink("target", dir_fd, "symlink").expect("creating a symlink");
+
+    // Try to open it as a directory with O_NOFOLLOW again.
+    assert_errno!(
+        wasi::path_open(dir_fd, 0, "symlink", wasi::OFLAGS_DIRECTORY, 0, 0, 0)
+            .expect_err("opening a directory symlink as a directory should fail"),
+        wasi::ERRNO_LOOP,
+        wasi::ERRNO_NOTDIR
+    );
+
+    // Try to open it with just O_NOFOLLOW.
+    assert_errno!(
+        wasi::path_open(dir_fd, 0, "symlink", 0, 0, 0, 0)
+            .expect_err("opening a symlink with O_NOFOLLOW should fail"),
+        wasi::ERRNO_LOOP,
+        wasi::ERRNO_ACCES
+    );
+
+    // Try to open it as a directory without O_NOFOLLOW.
+    let file_fd = wasi::path_open(
+        dir_fd,
+        wasi::LOOKUPFLAGS_SYMLINK_FOLLOW,
+        "symlink",
+        wasi::OFLAGS_DIRECTORY,
+        0,
+        0,
+        0,
+    )
+    .expect("opening a symlink as a directory");
+    assert!(
+        file_fd > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+    wasi::fd_close(file_fd).expect("closing a file");
+
+    // Replace the target directory with a file.
+    wasi::path_unlink_file(dir_fd, "symlink").expect("removing a file");
+    wasi::path_remove_directory(dir_fd, "target")
+        .expect("remove_directory on a directory should succeed");
+
+    let file_fd =
+        wasi::path_open(dir_fd, 0, "target", wasi::OFLAGS_CREAT, 0, 0, 0).expect("creating a file");
+    wasi::fd_close(file_fd).expect("closing a file");
+    wasi::path_symlink("target", dir_fd, "symlink").expect("creating a symlink");
+
+    // Try to open it as a directory with O_NOFOLLOW again.
+    assert_errno!(
+        wasi::path_open(dir_fd, 0, "symlink", wasi::OFLAGS_DIRECTORY, 0, 0, 0)
+            .expect_err("opening a directory symlink as a directory should fail"),
+        wasi::ERRNO_LOOP,
+        wasi::ERRNO_NOTDIR
+    );
+
+    // Try to open it with just O_NOFOLLOW.
+    assert_errno!(
+        wasi::path_open(dir_fd, 0, "symlink", 0, 0, 0, 0)
+            .expect_err("opening a symlink with NOFOLLOW should fail"),
+        wasi::ERRNO_LOOP
+    );
+
+    // Try to open it as a directory without O_NOFOLLOW.
+    assert_errno!(
+        wasi::path_open(
+            dir_fd,
+            wasi::LOOKUPFLAGS_SYMLINK_FOLLOW,
+            "symlink",
+            wasi::OFLAGS_DIRECTORY,
+            0,
+            0,
+            0,
+        )
+        .expect_err("opening a symlink to a file as a directory"),
+        wasi::ERRNO_NOTDIR
+    );
+
+    // Clean up.
+    wasi::path_unlink_file(dir_fd, "target").expect("removing a file");
+    wasi::path_unlink_file(dir_fd, "symlink").expect("removing a file");
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_nofollow_errors(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview1_overwrite_preopen.rs b/crates/test-programs/src/bin/preview1_overwrite_preopen.rs
new file mode 100644
index 000000000000..949bf2ee6244
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_overwrite_preopen.rs
@@ -0,0 +1,49 @@
+use std::{env, process};
+use test_programs::preview1::{assert_errno, open_scratch_directory};
+
+unsafe fn test_overwrite_preopen(dir_fd: wasi::Fd) {
+    let pre_fd: wasi::Fd = (libc::STDERR_FILENO + 1) as wasi::Fd;
+
+    assert!(dir_fd > pre_fd, "dir_fd number");
+
+    let old_dir_filestat = wasi::fd_filestat_get(dir_fd).expect("failed fd_filestat_get");
+
+    // Try to renumber over a preopened directory handle.
+    wasi::fd_renumber(dir_fd, pre_fd).expect("renumbering over a preopened file descriptor");
+
+    // Ensure that pre_fd is still open.
+    let new_dir_filestat = wasi::fd_filestat_get(pre_fd).expect("failed fd_filestat_get");
+
+    // Ensure that we renumbered.
+    assert_eq!(old_dir_filestat.dev, new_dir_filestat.dev);
+    assert_eq!(old_dir_filestat.ino, new_dir_filestat.ino);
+
+    // Ensure that dir_fd is closed.
+    assert_errno!(
+        wasi::fd_fdstat_get(dir_fd).expect_err("failed fd_fdstat_get"),
+        wasi::ERRNO_BADF
+    );
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_overwrite_preopen(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview1_path_exists.rs b/crates/test-programs/src/bin/preview1_path_exists.rs
new file mode 100644
index 000000000000..e0afe4f973df
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_path_exists.rs
@@ -0,0 +1,77 @@
+use std::{env, process};
+use test_programs::preview1::{create_file, open_scratch_directory};
+
+unsafe fn test_path_exists(dir_fd: wasi::Fd) {
+    // Create a temporary directory
+    wasi::path_create_directory(dir_fd, "subdir").expect("create directory");
+
+    // Check directory exists:
+    let file_stat = wasi::path_filestat_get(dir_fd, 0, "subdir").expect("reading file stats");
+    assert_eq!(file_stat.filetype, wasi::FILETYPE_DIRECTORY);
+
+    // Should still exist with symlink follow flag:
+    let file_stat = wasi::path_filestat_get(dir_fd, wasi::LOOKUPFLAGS_SYMLINK_FOLLOW, "subdir")
+        .expect("reading file stats");
+    assert_eq!(file_stat.filetype, wasi::FILETYPE_DIRECTORY);
+
+    // Create a file:
+    create_file(dir_fd, "subdir/file");
+    // Check directory exists:
+    let file_stat = wasi::path_filestat_get(dir_fd, 0, "subdir/file").expect("reading file stats");
+    assert_eq!(file_stat.filetype, wasi::FILETYPE_REGULAR_FILE);
+
+    // Should still exist with symlink follow flag:
+    let file_stat =
+        wasi::path_filestat_get(dir_fd, wasi::LOOKUPFLAGS_SYMLINK_FOLLOW, "subdir/file")
+            .expect("reading file stats");
+    assert_eq!(file_stat.filetype, wasi::FILETYPE_REGULAR_FILE);
+
+    // Create a symlink to a file:
+    wasi::path_symlink("subdir/file", dir_fd, "link1").expect("create symlink");
+    // Check symlink exists:
+    let file_stat = wasi::path_filestat_get(dir_fd, 0, "link1").expect("reading file stats");
+    assert_eq!(file_stat.filetype, wasi::FILETYPE_SYMBOLIC_LINK);
+
+    // Should still exist with symlink follow flag, pointing to regular file
+    let file_stat = wasi::path_filestat_get(dir_fd, wasi::LOOKUPFLAGS_SYMLINK_FOLLOW, "link1")
+        .expect("reading file stats");
+    assert_eq!(file_stat.filetype, wasi::FILETYPE_REGULAR_FILE);
+
+    // Create a symlink to a dir:
+    wasi::path_symlink("subdir", dir_fd, "link2").expect("create symlink");
+    // Check symlink exists:
+    let file_stat = wasi::path_filestat_get(dir_fd, 0, "link2").expect("reading file stats");
+    assert_eq!(file_stat.filetype, wasi::FILETYPE_SYMBOLIC_LINK);
+
+    // Should still exist with symlink follow flag, pointing to directory
+    let file_stat = wasi::path_filestat_get(dir_fd, wasi::LOOKUPFLAGS_SYMLINK_FOLLOW, "link2")
+        .expect("reading file stats");
+    assert_eq!(file_stat.filetype, wasi::FILETYPE_DIRECTORY);
+
+    wasi::path_unlink_file(dir_fd, "link1").expect("clean up");
+    wasi::path_unlink_file(dir_fd, "link2").expect("clean up");
+    wasi::path_unlink_file(dir_fd, "subdir/file").expect("clean up");
+    wasi::path_remove_directory(dir_fd, "subdir").expect("clean up");
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+    // Run the tests.
+    unsafe { test_path_exists(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview1_path_filestat.rs b/crates/test-programs/src/bin/preview1_path_filestat.rs
new file mode 100644
index 000000000000..6b25fc2e7e28
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_path_filestat.rs
@@ -0,0 +1,133 @@
+use std::{env, process, time::Duration};
+use test_programs::preview1::{
+    assert_errno, assert_fs_time_eq, open_scratch_directory, TestConfig,
+};
+
+unsafe fn test_path_filestat(dir_fd: wasi::Fd) {
+    let cfg = TestConfig::from_env();
+    let fdflags = wasi::FDFLAGS_APPEND;
+
+    // Create a file in the scratch directory.
+    let file_fd = wasi::path_open(
+        dir_fd,
+        0,
+        "file",
+        wasi::OFLAGS_CREAT,
+        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
+        0,
+        // Pass some flags for later retrieval
+        fdflags,
+    )
+    .expect("opening a file");
+    assert!(
+        file_fd > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+
+    let fdstat = wasi::fd_fdstat_get(file_fd).expect("fd_fdstat_get");
+    assert_eq!(
+        fdstat.fs_flags & wasi::FDFLAGS_APPEND,
+        wasi::FDFLAGS_APPEND,
+        "file should have the APPEND fdflag used to create the file"
+    );
+    assert_errno!(
+        wasi::path_open(
+            dir_fd,
+            0,
+            "file",
+            0,
+            wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
+            0,
+            wasi::FDFLAGS_SYNC,
+        )
+        .expect_err("FDFLAGS_SYNC not supported by platform"),
+        wasi::ERRNO_NOTSUP
+    );
+
+    // Check file size
+    let file_stat = wasi::path_filestat_get(dir_fd, 0, "file").expect("reading file stats");
+    assert_eq!(file_stat.size, 0, "file size should be 0");
+
+    // Check path_filestat_set_times
+    let new_mtim = Duration::from_nanos(file_stat.mtim) - 2 * cfg.fs_time_precision();
+    wasi::path_filestat_set_times(
+        dir_fd,
+        0,
+        "file",
+        0,
+        new_mtim.as_nanos() as u64,
+        wasi::FSTFLAGS_MTIM,
+    )
+    .expect("path_filestat_set_times should succeed");
+
+    let modified_file_stat = wasi::path_filestat_get(dir_fd, 0, "file")
+        .expect("reading file stats after path_filestat_set_times");
+
+    assert_fs_time_eq!(
+        Duration::from_nanos(modified_file_stat.mtim),
+        new_mtim,
+        "mtim should change"
+    );
+
+    assert_errno!(
+        wasi::path_filestat_set_times(
+            dir_fd,
+            0,
+            "file",
+            0,
+            new_mtim.as_nanos() as u64,
+            wasi::FSTFLAGS_MTIM | wasi::FSTFLAGS_MTIM_NOW,
+        )
+        .expect_err("MTIM and MTIM_NOW can't both be set"),
+        wasi::ERRNO_INVAL
+    );
+
+    // check if the times were untouched
+    let unmodified_file_stat = wasi::path_filestat_get(dir_fd, 0, "file")
+        .expect("reading file stats after ERRNO_INVAL fd_filestat_set_times");
+
+    assert_fs_time_eq!(
+        Duration::from_nanos(unmodified_file_stat.mtim),
+        new_mtim,
+        "mtim should not change"
+    );
+
+    // Invalid arguments to set_times:
+    assert_errno!(
+        wasi::path_filestat_set_times(
+            dir_fd,
+            0,
+            "file",
+            0,
+            0,
+            wasi::FSTFLAGS_ATIM | wasi::FSTFLAGS_ATIM_NOW,
+        )
+        .expect_err("ATIM & ATIM_NOW can't both be set"),
+        wasi::ERRNO_INVAL
+    );
+
+    wasi::fd_close(file_fd).expect("closing a file");
+    wasi::path_unlink_file(dir_fd, "file").expect("removing a file");
+}
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_path_filestat(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview1_path_link.rs b/crates/test-programs/src/bin/preview1_path_link.rs
new file mode 100644
index 000000000000..c8f30d085850
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_path_link.rs
@@ -0,0 +1,203 @@
+use std::{env, process};
+use test_programs::preview1::{assert_errno, config, create_file, open_scratch_directory};
+
+// These are all macro-rules so the panic line number shows us where
+// things went wrong.
+
+macro_rules! filestats_assert_eq {
+    ($left:ident, $right:ident) => {
+        assert_eq!($left.dev, $right.dev, "dev should be equal");
+        assert_eq!($left.ino, $right.ino, "ino should be equal");
+        assert_eq!($left.atim, $right.atim, "atim should be equal");
+        assert_eq!($left.ctim, $right.ctim, "ctim should be equal");
+        assert_eq!($left.mtim, $right.mtim, "mtim should be equal");
+        assert_eq!($left.size, $right.size, "size should be equal");
+        assert_eq!($left.nlink, $right.nlink, "nlink should be equal");
+        assert_eq!($left.filetype, $right.filetype, "filetype should be equal");
+    };
+}
+
+macro_rules! fdstats_assert_eq {
+    ($left:ident, $right:ident) => {
+        assert_eq!($left.fs_flags, $right.fs_flags, "fs_flags should be equal");
+        assert_eq!(
+            $left.fs_filetype, $right.fs_filetype,
+            "fs_filetype should be equal"
+        );
+        assert_eq!(
+            $left.fs_rights_base, $right.fs_rights_base,
+            "fs_rights_base should be equal"
+        );
+        assert_eq!(
+            $left.fs_rights_inheriting, $right.fs_rights_inheriting,
+            "fs_rights_inheriting should be equal"
+        );
+    };
+}
+
+macro_rules! check_rights {
+    ($orig_fd:ident, $link_fd:ident) => {
+        let orig_filestat =
+            wasi::fd_filestat_get($orig_fd).expect("reading filestat of the source");
+        let link_filestat = wasi::fd_filestat_get($link_fd).expect("reading filestat of the link");
+        filestats_assert_eq!(orig_filestat, link_filestat);
+
+        // Compare Fdstats
+        let orig_fdstat = wasi::fd_fdstat_get($orig_fd).expect("reading fdstat of the source");
+        let link_fdstat = wasi::fd_fdstat_get($link_fd).expect("reading fdstat of the link");
+        fdstats_assert_eq!(orig_fdstat, link_fdstat);
+    };
+}
+// Extra calls of fd_close are needed for Windows, which will not remove
+// the directory until all handles are closed.
+unsafe fn test_path_link(dir_fd: wasi::Fd) {
+    // Create a file
+    let create_fd =
+        wasi::path_open(dir_fd, 0, "file", wasi::OFLAGS_CREAT, 0, 0, 0).expect("create file");
+    wasi::fd_close(create_fd).unwrap();
+
+    // Open a fresh descriptor to the file. We won't have a write right that was implied by OFLAGS_CREAT
+    // above.
+    let file_fd = wasi::path_open(dir_fd, 0, "file", 0, 0, 0, 0).expect("open file");
+
+    // Create a link in the same directory and compare rights
+    wasi::path_link(dir_fd, 0, "file", dir_fd, "link")
+        .expect("creating a link in the same directory");
+
+    let link_fd = wasi::path_open(dir_fd, 0, "link", 0, 0, 0, 0).expect("open link");
+
+    check_rights!(file_fd, link_fd);
+    wasi::fd_close(link_fd).expect("Closing link_fd"); // needed for Windows
+    wasi::path_unlink_file(dir_fd, "link").expect("removing a link");
+
+    // Create a link in a different directory and compare rights
+    wasi::path_create_directory(dir_fd, "subdir").expect("creating a subdirectory");
+    let subdir_fd = wasi::path_open(dir_fd, 0, "subdir", wasi::OFLAGS_DIRECTORY, 0, 0, 0)
+        .expect("open subdir directory");
+    wasi::path_link(dir_fd, 0, "file", subdir_fd, "link").expect("creating a link in subdirectory");
+    let link_fd = wasi::path_open(subdir_fd, 0, "link", 0, 0, 0, 0).expect("open link in subdir");
+    check_rights!(file_fd, link_fd);
+    wasi::fd_close(link_fd).expect("Closing link_fd"); // needed for Windows
+    wasi::path_unlink_file(subdir_fd, "link").expect("removing a link");
+    wasi::fd_close(subdir_fd).expect("Closing subdir_fd"); // needed for Windows
+    wasi::path_remove_directory(dir_fd, "subdir").expect("removing a subdirectory");
+
+    // Create a link to a path that already exists
+    create_file(dir_fd, "link");
+
+    assert_errno!(
+        wasi::path_link(dir_fd, 0, "file", dir_fd, "link")
+            .expect_err("creating a link to existing path should fail"),
+        wasi::ERRNO_EXIST
+    );
+    wasi::path_unlink_file(dir_fd, "link").expect("removing a file");
+
+    // Create a link to itself
+    assert_errno!(
+        wasi::path_link(dir_fd, 0, "file", dir_fd, "file")
+            .expect_err("creating a link to itself should fail"),
+        wasi::ERRNO_EXIST
+    );
+
+    // Create a link where target is a directory
+    wasi::path_create_directory(dir_fd, "link").expect("creating a dir");
+
+    assert_errno!(
+        wasi::path_link(dir_fd, 0, "file", dir_fd, "link")
+            .expect_err("creating a link where target is a directory should fail"),
+        wasi::ERRNO_EXIST
+    );
+    wasi::path_remove_directory(dir_fd, "link").expect("removing a dir");
+
+    // Create a link to a directory
+    wasi::path_create_directory(dir_fd, "subdir").expect("creating a subdirectory");
+    let subdir_fd = wasi::path_open(dir_fd, 0, "subdir", wasi::OFLAGS_DIRECTORY, 0, 0, 0)
+        .expect("open new descriptor to subdir");
+
+    assert_errno!(
+        wasi::path_link(dir_fd, 0, "subdir", dir_fd, "link")
+            .expect_err("creating a link to a directory should fail"),
+        wasi::ERRNO_PERM,
+        wasi::ERRNO_ACCES
+    );
+    wasi::fd_close(subdir_fd).expect("close subdir before deleting it");
+    wasi::path_remove_directory(dir_fd, "subdir").expect("removing a subdirectory");
+
+    // Create a link to a file with trailing slash
+    assert_errno!(
+        wasi::path_link(dir_fd, 0, "file", dir_fd, "link/")
+            .expect_err("creating a link to a file with trailing slash should fail"),
+        wasi::ERRNO_NOENT
+    );
+
+    if config().support_dangling_filesystem() {
+        // Create a link to a dangling symlink
+        wasi::path_symlink("target", dir_fd, "symlink").expect("creating a dangling symlink");
+
+        // This should succeed, because we're not following symlinks
+        wasi::path_link(dir_fd, 0, "symlink", dir_fd, "link")
+            .expect("creating a link to a dangling symlink should succeed");
+        wasi::path_unlink_file(dir_fd, "symlink").expect("removing a symlink");
+        wasi::path_unlink_file(dir_fd, "link").expect("removing a hardlink");
+
+        // Create a link to a symlink loop
+        wasi::path_symlink("symlink", dir_fd, "symlink").expect("creating a symlink loop");
+
+        wasi::path_link(dir_fd, 0, "symlink", dir_fd, "link")
+            .expect("creating a link to a symlink loop should succeed");
+        wasi::path_unlink_file(dir_fd, "symlink").expect("removing a symlink");
+        wasi::path_unlink_file(dir_fd, "link").expect("removing a hardlink");
+
+        // Create a link where target is a dangling symlink
+        wasi::path_symlink("target", dir_fd, "symlink").expect("creating a dangling symlink");
+
+        assert_errno!(
+            wasi::path_link(dir_fd, 0, "file", dir_fd, "symlink")
+                .expect_err("creating a link where target is a dangling symlink"),
+            wasi::ERRNO_EXIST
+        );
+        wasi::path_unlink_file(dir_fd, "symlink").expect("removing a symlink");
+
+        // Create a link where target is a dangling symlink following symlinks
+        wasi::path_symlink("target", dir_fd, "symlink").expect("creating a dangling symlink");
+
+        // Symlink following with path_link is rejected
+        assert_errno!(
+            wasi::path_link(
+                dir_fd,
+                wasi::LOOKUPFLAGS_SYMLINK_FOLLOW,
+                "symlink",
+                dir_fd,
+                "link",
+            )
+            .expect_err("calling path_link with LOOKUPFLAGS_SYMLINK_FOLLOW should fail"),
+            wasi::ERRNO_INVAL
+        );
+
+        // Clean up.
+        wasi::path_unlink_file(dir_fd, "file").expect("removing a file");
+    }
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_path_link(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview1_path_open_create_existing.rs b/crates/test-programs/src/bin/preview1_path_open_create_existing.rs
new file mode 100644
index 000000000000..963e58372097
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_path_open_create_existing.rs
@@ -0,0 +1,43 @@
+use std::{env, process};
+use test_programs::preview1::{assert_errno, create_file, open_scratch_directory};
+
+unsafe fn test_path_open_create_existing(dir_fd: wasi::Fd) {
+    create_file(dir_fd, "file");
+    assert_errno!(
+        wasi::path_open(
+            dir_fd,
+            0,
+            "file",
+            wasi::OFLAGS_CREAT | wasi::OFLAGS_EXCL,
+            0,
+            0,
+            0,
+        )
+        .expect_err("trying to create a file that already exists"),
+        wasi::ERRNO_EXIST
+    );
+    wasi::path_unlink_file(dir_fd, "file").expect("removing a file");
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_path_open_create_existing(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview1_path_open_dirfd_not_dir.rs b/crates/test-programs/src/bin/preview1_path_open_dirfd_not_dir.rs
new file mode 100644
index 000000000000..de35d964f270
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_path_open_dirfd_not_dir.rs
@@ -0,0 +1,38 @@
+use std::{env, process};
+use test_programs::preview1::{assert_errno, open_scratch_directory};
+
+unsafe fn test_dirfd_not_dir(dir_fd: wasi::Fd) {
+    // Open a file.
+    let file_fd =
+        wasi::path_open(dir_fd, 0, "file", wasi::OFLAGS_CREAT, 0, 0, 0).expect("opening a file");
+    // Now try to open a file underneath it as if it were a directory.
+    assert_errno!(
+        wasi::path_open(file_fd, 0, "foo", wasi::OFLAGS_CREAT, 0, 0, 0)
+            .expect_err("non-directory base fd should get ERRNO_NOTDIR"),
+        wasi::ERRNO_NOTDIR
+    );
+    wasi::fd_close(file_fd).expect("closing a file");
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_dirfd_not_dir(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview1_path_open_lots.rs b/crates/test-programs/src/bin/preview1_path_open_lots.rs
new file mode 100644
index 000000000000..16f32be951cc
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_path_open_lots.rs
@@ -0,0 +1,107 @@
+use std::{env, process};
+use test_programs::preview1::{create_file, open_scratch_directory};
+
+unsafe fn test_path_open_lots(dir_fd: wasi::Fd) {
+    create_file(dir_fd, "file");
+
+    for _ in 0..2000 {
+        let f_readonly = wasi::path_open(dir_fd, 0, "file", 0, wasi::RIGHTS_FD_READ, 0, 0)
+            .expect("open file readonly");
+
+        let buffer = &mut [0u8; 100];
+        let iovec = wasi::Iovec {
+            buf: buffer.as_mut_ptr(),
+            buf_len: buffer.len(),
+        };
+        let nread = wasi::fd_read(f_readonly, &[iovec]).expect("reading readonly file");
+        assert_eq!(nread, 0, "readonly file is empty");
+
+        wasi::fd_close(f_readonly).expect("close readonly");
+    }
+
+    for _ in 0..2000 {
+        let f_readonly = wasi::path_open(dir_fd, 0, "file", 0, wasi::RIGHTS_FD_READ, 0, 0)
+            .expect("open file readonly");
+
+        let buffer = &mut [0u8; 100];
+        let iovec = wasi::Iovec {
+            buf: buffer.as_mut_ptr(),
+            buf_len: buffer.len(),
+        };
+        let nread = wasi::fd_pread(f_readonly, &[iovec], 0).expect("reading readonly file");
+        assert_eq!(nread, 0, "readonly file is empty");
+
+        wasi::fd_close(f_readonly).expect("close readonly");
+    }
+
+    for _ in 0..2000 {
+        let f = wasi::path_open(
+            dir_fd,
+            0,
+            "file",
+            0,
+            wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
+            0,
+            0,
+        )
+        .unwrap();
+
+        let buffer = &[0u8; 100];
+        let ciovec = wasi::Ciovec {
+            buf: buffer.as_ptr(),
+            buf_len: buffer.len(),
+        };
+        let nwritten = wasi::fd_write(f, &[ciovec]).expect("write failed");
+        assert_eq!(nwritten, 100);
+
+        wasi::fd_close(f).unwrap();
+    }
+
+    for _ in 0..2000 {
+        let f = wasi::path_open(
+            dir_fd,
+            0,
+            "file",
+            0,
+            wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
+            0,
+            0,
+        )
+        .unwrap();
+
+        let buffer = &[0u8; 100];
+        let ciovec = wasi::Ciovec {
+            buf: buffer.as_ptr(),
+            buf_len: buffer.len(),
+        };
+        let nwritten = wasi::fd_pwrite(f, &[ciovec], 0).expect("write failed");
+        assert_eq!(nwritten, 100);
+
+        wasi::fd_close(f).unwrap();
+    }
+
+    wasi::path_unlink_file(dir_fd, "file").expect("removing a file");
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_path_open_lots(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview1_path_open_missing.rs b/crates/test-programs/src/bin/preview1_path_open_missing.rs
new file mode 100644
index 000000000000..78a1623a893c
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_path_open_missing.rs
@@ -0,0 +1,36 @@
+use std::{env, process};
+use test_programs::preview1::{assert_errno, open_scratch_directory};
+
+unsafe fn test_path_open_missing(dir_fd: wasi::Fd) {
+    assert_errno!(
+        wasi::path_open(
+            dir_fd, 0, "file", 0, // not passing O_CREAT here
+            0, 0, 0,
+        )
+        .expect_err("trying to open a file that doesn't exist"),
+        wasi::ERRNO_NOENT
+    );
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_path_open_missing(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview1_path_open_nonblock.rs b/crates/test-programs/src/bin/preview1_path_open_nonblock.rs
new file mode 100644
index 000000000000..9c8b85f59ded
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_path_open_nonblock.rs
@@ -0,0 +1,30 @@
+use std::{env, process};
+use test_programs::preview1::open_scratch_directory;
+
+unsafe fn try_path_open(dir_fd: wasi::Fd) {
+    let _fd =
+        wasi::path_open(dir_fd, 0, ".", 0, 0, 0, wasi::FDFLAGS_NONBLOCK).expect("opening the dir");
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { try_path_open(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview1_path_open_preopen.rs b/crates/test-programs/src/bin/preview1_path_open_preopen.rs
new file mode 100644
index 000000000000..218446bd8a51
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_path_open_preopen.rs
@@ -0,0 +1,153 @@
+const FIRST_PREOPEN: u32 = 3;
+
+unsafe fn path_open_preopen() {
+    let prestat = wasi::fd_prestat_get(FIRST_PREOPEN).expect("fd 3 is a preopen");
+    assert_eq!(
+        prestat.tag,
+        wasi::PREOPENTYPE_DIR.raw(),
+        "prestat is a directory"
+    );
+    let mut dst = Vec::with_capacity(prestat.u.dir.pr_name_len);
+    wasi::fd_prestat_dir_name(FIRST_PREOPEN, dst.as_mut_ptr(), dst.capacity())
+        .expect("get preopen dir name");
+    dst.set_len(prestat.u.dir.pr_name_len);
+
+    let fdstat = wasi::fd_fdstat_get(FIRST_PREOPEN).expect("get fdstat");
+
+    println!(
+        "preopen dir: {:?} base {:?} inheriting {:?}",
+        String::from_utf8_lossy(&dst),
+        fdstat.fs_rights_base,
+        fdstat.fs_rights_inheriting
+    );
+    for (right, name) in directory_base_rights() {
+        assert!(
+            (fdstat.fs_rights_base & right) == right,
+            "fs_rights_base does not have required right `{name}`"
+        );
+    }
+    for (right, name) in directory_inheriting_rights() {
+        assert!(
+            (fdstat.fs_rights_inheriting & right) == right,
+            "fs_rights_inheriting does not have required right `{name}`"
+        );
+    }
+
+    // Open with same rights it has now:
+    let _ = wasi::path_open(
+        FIRST_PREOPEN,
+        0,
+        ".",
+        0,
+        fdstat.fs_rights_base,
+        fdstat.fs_rights_inheriting,
+        0,
+    )
+    .expect("open with same rights");
+
+    // Open with an empty set of rights:
+    let _ = wasi::path_open(FIRST_PREOPEN, 0, ".", 0, 0, 0, 0).expect("open with empty rights");
+
+    // Open OFLAGS_DIRECTORY with an empty set of rights:
+    let _ = wasi::path_open(FIRST_PREOPEN, 0, ".", wasi::OFLAGS_DIRECTORY, 0, 0, 0)
+        .expect("open with O_DIRECTORY empty rights");
+
+    // Open OFLAGS_DIRECTORY with just the read right:
+    let _ = wasi::path_open(
+        FIRST_PREOPEN,
+        0,
+        ".",
+        wasi::OFLAGS_DIRECTORY,
+        wasi::RIGHTS_FD_READ,
+        0,
+        0,
+    )
+    .expect("open with O_DIRECTORY and read right");
+
+    if !test_programs::preview1::config().errno_expect_windows() {
+        // Open OFLAGS_DIRECTORY and read/write rights should fail with isdir:
+        let err = wasi::path_open(
+            FIRST_PREOPEN,
+            0,
+            ".",
+            wasi::OFLAGS_DIRECTORY,
+            wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
+            0,
+            0,
+        )
+        .err()
+        .expect("open with O_DIRECTORY and read/write should fail");
+        assert_eq!(
+            err,
+            wasi::ERRNO_ISDIR,
+            "opening directory read/write should fail with ISDIR"
+        );
+    } else {
+        // Open OFLAGS_DIRECTORY and read/write rights will succeed, only on windows:
+        let _ = wasi::path_open(
+            FIRST_PREOPEN,
+            0,
+            ".",
+            wasi::OFLAGS_DIRECTORY,
+            wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
+            0,
+            0,
+        )
+        .expect("open with O_DIRECTORY and read/write should succeed on windows");
+    }
+}
+
+fn main() {
+    unsafe {
+        path_open_preopen();
+    }
+}
+
+// Hard-code the set of rights expected for a preopened directory. This is
+// more brittle than we wanted to test for, but various userland
+// implementations expect (at least) this set of rights to be present on all
+// directories:
+
+fn directory_base_rights() -> Vec<(wasi::Rights, &'static str)> {
+    vec![
+        (wasi::RIGHTS_PATH_CREATE_DIRECTORY, "PATH_CREATE_DIRECTORY"),
+        (wasi::RIGHTS_PATH_CREATE_FILE, "PATH_CREATE_FILE"),
+        (wasi::RIGHTS_PATH_LINK_SOURCE, "PATH_LINK_SOURCE"),
+        (wasi::RIGHTS_PATH_LINK_TARGET, "PATH_LINK_TARGET"),
+        (wasi::RIGHTS_PATH_OPEN, "PATH_OPEN"),
+        (wasi::RIGHTS_FD_READDIR, "FD_READDIR"),
+        (wasi::RIGHTS_PATH_READLINK, "PATH_READLINK"),
+        (wasi::RIGHTS_PATH_RENAME_SOURCE, "PATH_RENAME_SOURCE"),
+        (wasi::RIGHTS_PATH_RENAME_TARGET, "PATH_RENAME_TARGET"),
+        (wasi::RIGHTS_PATH_SYMLINK, "PATH_SYMLINK"),
+        (wasi::RIGHTS_PATH_REMOVE_DIRECTORY, "PATH_REMOVE_DIRECTORY"),
+        (wasi::RIGHTS_PATH_UNLINK_FILE, "PATH_UNLINK_FILE"),
+        (wasi::RIGHTS_PATH_FILESTAT_GET, "PATH_FILESTAT_GET"),
+        (
+            wasi::RIGHTS_PATH_FILESTAT_SET_TIMES,
+            "PATH_FILESTAT_SET_TIMES",
+        ),
+        (wasi::RIGHTS_FD_FILESTAT_GET, "FD_FILESTAT_GET"),
+        (wasi::RIGHTS_FD_FILESTAT_SET_TIMES, "FD_FILESTAT_SET_TIMES"),
+    ]
+}
+
+pub(crate) fn directory_inheriting_rights() -> Vec<(wasi::Rights, &'static str)> {
+    let mut rights = directory_base_rights();
+    rights.extend_from_slice(&[
+        (wasi::RIGHTS_FD_DATASYNC, "FD_DATASYNC"),
+        (wasi::RIGHTS_FD_READ, "FD_READ"),
+        (wasi::RIGHTS_FD_SEEK, "FD_SEEK"),
+        (wasi::RIGHTS_FD_FDSTAT_SET_FLAGS, "FD_FDSTAT_SET_FLAGS"),
+        (wasi::RIGHTS_FD_SYNC, "FD_SYNC"),
+        (wasi::RIGHTS_FD_TELL, "FD_TELL"),
+        (wasi::RIGHTS_FD_WRITE, "FD_WRITE"),
+        (wasi::RIGHTS_FD_ADVISE, "FD_ADVISE"),
+        (wasi::RIGHTS_FD_ALLOCATE, "FD_ALLOCATE"),
+        (wasi::RIGHTS_FD_FILESTAT_GET, "FD_FILESTAT_GET"),
+        (wasi::RIGHTS_FD_FILESTAT_SET_SIZE, "FD_FILESTAT_SET_SIZE"),
+        (wasi::RIGHTS_FD_FILESTAT_SET_TIMES, "FD_FILESTAT_SET_TIMES"),
+        (wasi::RIGHTS_POLL_FD_READWRITE, "POLL_FD_READWRITE"),
+    ]);
+    rights
+}
diff --git a/crates/test-programs/src/bin/preview1_path_open_read_write.rs b/crates/test-programs/src/bin/preview1_path_open_read_write.rs
new file mode 100644
index 000000000000..c8615a6177be
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_path_open_read_write.rs
@@ -0,0 +1,147 @@
+use std::{env, process};
+use test_programs::preview1::{assert_errno, create_file, open_scratch_directory};
+
+unsafe fn test_path_open_read_write(dir_fd: wasi::Fd) {
+    create_file(dir_fd, "file");
+
+    let f_readonly = wasi::path_open(dir_fd, 0, "file", 0, wasi::RIGHTS_FD_READ, 0, 0)
+        .expect("open file readonly");
+
+    let stat = wasi::fd_fdstat_get(f_readonly).expect("get fdstat readonly");
+    assert!(
+        stat.fs_rights_base & wasi::RIGHTS_FD_READ == wasi::RIGHTS_FD_READ,
+        "readonly has read right"
+    );
+    assert!(
+        stat.fs_rights_base & wasi::RIGHTS_FD_WRITE == 0,
+        "readonly does not have write right"
+    );
+
+    let buffer = &mut [0u8; 100];
+    let iovec = wasi::Iovec {
+        buf: buffer.as_mut_ptr(),
+        buf_len: buffer.len(),
+    };
+    let nread = wasi::fd_read(f_readonly, &[iovec]).expect("reading readonly file");
+    assert_eq!(nread, 0, "readonly file is empty");
+
+    let write_buffer = &[1u8; 50];
+    let ciovec = wasi::Ciovec {
+        buf: write_buffer.as_ptr(),
+        buf_len: write_buffer.len(),
+    };
+    // PERM is only the failure on windows under wasmtime-wasi. wasi-common
+    // fails on windows with BADF, so we can't use the `windows =>` syntax
+    // because that doesn't support alternatives like the agnostic syntax does.
+    assert_errno!(
+        wasi::fd_write(f_readonly, &[ciovec])
+            .err()
+            .expect("read of writeonly fails"),
+        wasi::ERRNO_PERM,
+        wasi::ERRNO_BADF
+    );
+
+    wasi::fd_close(f_readonly).expect("close readonly");
+
+    // =============== WRITE ONLY ==================
+    let f_writeonly = wasi::path_open(dir_fd, 0, "file", 0, wasi::RIGHTS_FD_WRITE, 0, 0)
+        .expect("open file writeonly");
+
+    let stat = wasi::fd_fdstat_get(f_writeonly).expect("get fdstat writeonly");
+    assert!(
+        stat.fs_rights_base & wasi::RIGHTS_FD_READ == 0,
+        "writeonly does not have read right"
+    );
+    assert!(
+        stat.fs_rights_base & wasi::RIGHTS_FD_READDIR == 0,
+        "writeonly does not have readdir right"
+    );
+    assert!(
+        stat.fs_rights_base & wasi::RIGHTS_FD_WRITE == wasi::RIGHTS_FD_WRITE,
+        "writeonly has write right"
+    );
+
+    // See above for description of PERM
+    assert_errno!(
+        wasi::fd_read(f_writeonly, &[iovec])
+            .err()
+            .expect("read of writeonly fails"),
+        wasi::ERRNO_PERM,
+        wasi::ERRNO_BADF
+    );
+    let bytes_written = wasi::fd_write(f_writeonly, &[ciovec]).expect("write to writeonly");
+    assert_eq!(bytes_written, write_buffer.len());
+
+    wasi::fd_close(f_writeonly).expect("close writeonly");
+
+    // ============== READ WRITE =======================
+
+    let f_readwrite = wasi::path_open(
+        dir_fd,
+        0,
+        "file",
+        0,
+        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
+        0,
+        0,
+    )
+    .expect("open file readwrite");
+    let stat = wasi::fd_fdstat_get(f_readwrite).expect("get fdstat readwrite");
+    assert!(
+        stat.fs_rights_base & wasi::RIGHTS_FD_READ == wasi::RIGHTS_FD_READ,
+        "readwrite has read right"
+    );
+    assert!(
+        stat.fs_rights_base & wasi::RIGHTS_FD_WRITE == wasi::RIGHTS_FD_WRITE,
+        "readwrite has write right"
+    );
+
+    let nread = wasi::fd_read(f_readwrite, &[iovec]).expect("reading readwrite file");
+    assert_eq!(
+        nread,
+        write_buffer.len(),
+        "readwrite file contains contents from writeonly open"
+    );
+
+    let write_buffer_2 = &[2u8; 25];
+    let ciovec = wasi::Ciovec {
+        buf: write_buffer_2.as_ptr(),
+        buf_len: write_buffer_2.len(),
+    };
+    let bytes_written = wasi::fd_write(f_readwrite, &[ciovec]).expect("write to readwrite");
+    assert_eq!(bytes_written, write_buffer_2.len());
+
+    let filestat = wasi::fd_filestat_get(f_readwrite).expect("get filestat readwrite");
+    assert_eq!(
+        filestat.size as usize,
+        write_buffer.len() + write_buffer_2.len(),
+        "total written is both write buffers"
+    );
+
+    wasi::fd_close(f_readwrite).expect("close readwrite");
+
+    wasi::path_unlink_file(dir_fd, "file").expect("removing a file");
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_path_open_read_write(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview1_path_rename.rs b/crates/test-programs/src/bin/preview1_path_rename.rs
new file mode 100644
index 000000000000..ba5416c952f3
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_path_rename.rs
@@ -0,0 +1,179 @@
+use std::{env, process};
+use test_programs::preview1::{assert_errno, config, create_file, open_scratch_directory};
+
+unsafe fn test_path_rename(dir_fd: wasi::Fd) {
+    // First, try renaming a dir to nonexistent path
+    // Create source directory
+    wasi::path_create_directory(dir_fd, "source").expect("creating a directory");
+
+    // Try renaming the directory
+    wasi::path_rename(dir_fd, "source", dir_fd, "target").expect("renaming a directory");
+
+    // Check that source directory doesn't exist anymore
+    assert_errno!(
+        wasi::path_open(dir_fd, 0, "source", wasi::OFLAGS_DIRECTORY, 0, 0, 0)
+            .expect_err("opening a nonexistent path as a directory should fail"),
+        wasi::ERRNO_NOENT
+    );
+
+    // Check that target directory exists
+    let mut fd = wasi::path_open(dir_fd, 0, "target", wasi::OFLAGS_DIRECTORY, 0, 0, 0)
+        .expect("opening renamed path as a directory");
+    assert!(
+        fd > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+
+    wasi::fd_close(fd).expect("closing a file");
+    wasi::path_remove_directory(dir_fd, "target").expect("removing a directory");
+
+    // Yes, renaming a dir to an empty dir is a property guaranteed by rename(2)
+    // and its fairly important that it is atomic.
+    // But, we haven't found a way to emulate it on windows. So, sometimes this
+    // behavior is just hosed. Sorry.
+    if config().support_rename_dir_to_empty_dir() {
+        // Now, try renaming renaming a dir to existing empty dir
+        wasi::path_create_directory(dir_fd, "source").expect("creating a directory");
+        wasi::path_create_directory(dir_fd, "target").expect("creating a directory");
+        wasi::path_rename(dir_fd, "source", dir_fd, "target").expect("renaming a directory");
+
+        // Check that source directory doesn't exist anymore
+        assert_errno!(
+            wasi::path_open(dir_fd, 0, "source", wasi::OFLAGS_DIRECTORY, 0, 0, 0)
+                .expect_err("opening a nonexistent path as a directory"),
+            wasi::ERRNO_NOENT
+        );
+
+        // Check that target directory exists
+        fd = wasi::path_open(dir_fd, 0, "target", wasi::OFLAGS_DIRECTORY, 0, 0, 0)
+            .expect("opening renamed path as a directory");
+        assert!(
+            fd > libc::STDERR_FILENO as wasi::Fd,
+            "file descriptor range check",
+        );
+
+        wasi::fd_close(fd).expect("closing a file");
+        wasi::path_remove_directory(dir_fd, "target").expect("removing a directory");
+    } else {
+        wasi::path_create_directory(dir_fd, "source").expect("creating a directory");
+        wasi::path_create_directory(dir_fd, "target").expect("creating a directory");
+        wasi::path_rename(dir_fd, "source", dir_fd, "target")
+            .expect_err("windows does not support renaming a directory to an empty directory");
+        wasi::path_remove_directory(dir_fd, "target").expect("removing a directory");
+        wasi::path_remove_directory(dir_fd, "source").expect("removing a directory");
+    }
+
+    // Now, try renaming a dir to existing non-empty dir
+    wasi::path_create_directory(dir_fd, "source").expect("creating a directory");
+    wasi::path_create_directory(dir_fd, "target").expect("creating a directory");
+    create_file(dir_fd, "target/file");
+
+    assert_errno!(
+        wasi::path_rename(dir_fd, "source", dir_fd, "target")
+            .expect_err("renaming directory to a nonempty directory"),
+        windows => wasi::ERRNO_ACCES,
+        unix => wasi::ERRNO_NOTEMPTY
+    );
+
+    // This is technically a different property, but the root of these divergent behaviors is in
+    // the semantics that windows gives us around renaming directories. So, it lives under the same
+    // flag.
+    if config().support_rename_dir_to_empty_dir() {
+        // Try renaming dir to a file
+        assert_errno!(
+            wasi::path_rename(dir_fd, "source", dir_fd, "target/file")
+                .expect_err("renaming a directory to a file"),
+            wasi::ERRNO_NOTDIR
+        );
+        wasi::path_unlink_file(dir_fd, "target/file").expect("removing a file");
+        wasi::path_remove_directory(dir_fd, "source").expect("removing a directory");
+    } else {
+        // Windows will let you erase a file by renaming a directory to it.
+        // WASI users can't depend on this error getting caught to prevent data loss.
+        wasi::path_rename(dir_fd, "source", dir_fd, "target/file")
+            .expect("windows happens to support renaming a directory to a file");
+        wasi::path_remove_directory(dir_fd, "target/file").expect("removing a file");
+    }
+    wasi::path_remove_directory(dir_fd, "target").expect("removing a directory");
+
+    // Now, try renaming a file to a nonexistent path
+    create_file(dir_fd, "source");
+    wasi::path_rename(dir_fd, "source", dir_fd, "target").expect("renaming a file");
+
+    // Check that source file doesn't exist anymore
+    assert_errno!(
+        wasi::path_open(dir_fd, 0, "source", 0, 0, 0, 0)
+            .expect_err("opening a nonexistent path should fail"),
+        wasi::ERRNO_NOENT
+    );
+
+    // Check that target file exists
+    fd = wasi::path_open(dir_fd, 0, "target", 0, 0, 0, 0).expect("opening renamed path");
+    assert!(
+        fd > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+
+    wasi::fd_close(fd).expect("closing a file");
+    wasi::path_unlink_file(dir_fd, "target").expect("removing a file");
+
+    // Now, try renaming file to an existing file
+    create_file(dir_fd, "source");
+    create_file(dir_fd, "target");
+
+    wasi::path_rename(dir_fd, "source", dir_fd, "target")
+        .expect("renaming file to another existing file");
+
+    // Check that source file doesn't exist anymore
+    assert_errno!(
+        wasi::path_open(dir_fd, 0, "source", 0, 0, 0, 0).expect_err("opening a nonexistent path"),
+        wasi::ERRNO_NOENT
+    );
+
+    // Check that target file exists
+    fd = wasi::path_open(dir_fd, 0, "target", 0, 0, 0, 0).expect("opening renamed path");
+    assert!(
+        fd > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+
+    wasi::fd_close(fd).expect("closing a file");
+    wasi::path_unlink_file(dir_fd, "target").expect("removing a file");
+
+    // Try renaming to an (empty) directory instead
+    create_file(dir_fd, "source");
+    wasi::path_create_directory(dir_fd, "target").expect("creating a directory");
+
+    assert_errno!(
+        wasi::path_rename(dir_fd, "source", dir_fd, "target")
+            .expect_err("renaming a file to existing directory should fail"),
+        windows => wasi::ERRNO_ACCES,
+        unix => wasi::ERRNO_ISDIR
+    );
+
+    wasi::path_remove_directory(dir_fd, "target").expect("removing a directory");
+    wasi::path_unlink_file(dir_fd, "source").expect("removing a file");
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_path_rename(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview1_path_rename_dir_trailing_slashes.rs b/crates/test-programs/src/bin/preview1_path_rename_dir_trailing_slashes.rs
new file mode 100644
index 000000000000..a5d2dd51a6b0
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_path_rename_dir_trailing_slashes.rs
@@ -0,0 +1,39 @@
+use std::{env, process};
+use test_programs::preview1::open_scratch_directory;
+
+unsafe fn test_path_rename_trailing_slashes(dir_fd: wasi::Fd) {
+    // Test renaming a directory with a trailing slash in the name.
+    wasi::path_create_directory(dir_fd, "source").expect("creating a directory");
+    wasi::path_rename(dir_fd, "source/", dir_fd, "target")
+        .expect("renaming a directory with a trailing slash in the source name");
+    wasi::path_rename(dir_fd, "target", dir_fd, "source/")
+        .expect("renaming a directory with a trailing slash in the destination name");
+    wasi::path_rename(dir_fd, "source/", dir_fd, "target/")
+        .expect("renaming a directory with a trailing slash in the source and destination names");
+    wasi::path_rename(dir_fd, "target", dir_fd, "source")
+        .expect("renaming a directory with no trailing slashes at all should work");
+    wasi::path_remove_directory(dir_fd, "source").expect("removing the directory");
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_path_rename_trailing_slashes(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview1_path_symlink_trailing_slashes.rs b/crates/test-programs/src/bin/preview1_path_symlink_trailing_slashes.rs
new file mode 100644
index 000000000000..18d3ace9f293
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_path_symlink_trailing_slashes.rs
@@ -0,0 +1,83 @@
+use std::{env, process};
+use test_programs::preview1::{assert_errno, config, create_file, open_scratch_directory};
+
+unsafe fn test_path_symlink_trailing_slashes(dir_fd: wasi::Fd) {
+    if config().support_dangling_filesystem() {
+        // Dangling symlink: Link destination shouldn't end with a slash.
+        assert_errno!(
+            wasi::path_symlink("source", dir_fd, "target/")
+                .expect_err("link destination ending with a slash should fail"),
+            wasi::ERRNO_NOENT
+        );
+
+        // Dangling symlink: Without the trailing slash, this should succeed.
+        wasi::path_symlink("source", dir_fd, "target")
+            .expect("link destination ending with a slash");
+        wasi::path_unlink_file(dir_fd, "target").expect("removing a file");
+    }
+
+    // Link destination already exists, target has trailing slash.
+    wasi::path_create_directory(dir_fd, "target").expect("creating a directory");
+    assert_errno!(
+        wasi::path_symlink("source", dir_fd, "target/")
+            .expect_err("link destination already exists"),
+        unix => wasi::ERRNO_EXIST,
+        windows => wasi::ERRNO_NOENT
+    );
+    wasi::path_remove_directory(dir_fd, "target").expect("removing a directory");
+
+    // Link destination already exists, target has no trailing slash.
+    wasi::path_create_directory(dir_fd, "target").expect("creating a directory");
+    assert_errno!(
+        wasi::path_symlink("source", dir_fd, "target")
+            .expect_err("link destination already exists"),
+        unix => wasi::ERRNO_EXIST,
+        windows => wasi::ERRNO_NOENT
+    );
+    wasi::path_remove_directory(dir_fd, "target").expect("removing a directory");
+
+    // Link destination already exists, target has trailing slash.
+    create_file(dir_fd, "target");
+
+    assert_errno!(
+        wasi::path_symlink("source", dir_fd, "target/")
+            .expect_err("link destination already exists"),
+        unix => wasi::ERRNO_NOTDIR,
+        windows => wasi::ERRNO_NOENT
+    );
+    wasi::path_unlink_file(dir_fd, "target").expect("removing a file");
+
+    // Link destination already exists, target has no trailing slash.
+    create_file(dir_fd, "target");
+
+    assert_errno!(
+        wasi::path_symlink("source", dir_fd, "target")
+            .expect_err("link destination already exists"),
+        unix => wasi::ERRNO_EXIST,
+        windows => wasi::ERRNO_NOENT
+    );
+    wasi::path_unlink_file(dir_fd, "target").expect("removing a file");
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_path_symlink_trailing_slashes(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview1_poll_oneoff_files.rs b/crates/test-programs/src/bin/preview1_poll_oneoff_files.rs
new file mode 100644
index 000000000000..08bad56e9546
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_poll_oneoff_files.rs
@@ -0,0 +1,293 @@
+use std::{env, mem::MaybeUninit, process};
+use test_programs::preview1::{assert_errno, open_scratch_directory};
+
+const CLOCK_ID: wasi::Userdata = 0x0123_45678;
+
+unsafe fn poll_oneoff_impl(r#in: &[wasi::Subscription]) -> Result<Vec<wasi::Event>, wasi::Errno> {
+    let mut out: Vec<wasi::Event> = Vec::new();
+    out.resize_with(r#in.len(), || {
+        MaybeUninit::<wasi::Event>::zeroed().assume_init()
+    });
+    let size = wasi::poll_oneoff(r#in.as_ptr(), out.as_mut_ptr(), r#in.len())?;
+    out.truncate(size);
+    Ok(out)
+}
+
+/// Repeatedly call `poll_oneoff` until all the subscriptions in `in` have
+/// seen their events occur.
+unsafe fn poll_oneoff_with_retry(
+    r#in: &[wasi::Subscription],
+) -> Result<Vec<wasi::Event>, wasi::Errno> {
+    let mut subscriptions = r#in.to_vec();
+    let mut events = Vec::new();
+    while !subscriptions.is_empty() {
+        let mut out: Vec<wasi::Event> = Vec::new();
+        out.resize_with(subscriptions.len(), || {
+            MaybeUninit::<wasi::Event>::zeroed().assume_init()
+        });
+        let size = wasi::poll_oneoff(
+            subscriptions.as_ptr(),
+            out.as_mut_ptr(),
+            subscriptions.len(),
+        )?;
+        out.truncate(size);
+
+        // Append the events from this `poll` to the result.
+        events.extend_from_slice(&out);
+
+        // Assuming userdata fields are unique, filter out any subscriptions
+        // whose event has occurred.
+        subscriptions.retain(|sub| !out.iter().any(|event| event.userdata == sub.userdata));
+    }
+    Ok(events)
+}
+
+unsafe fn test_empty_poll() {
+    let r#in = [];
+    let mut out: Vec<wasi::Event> = Vec::new();
+    assert_errno!(
+        wasi::poll_oneoff(r#in.as_ptr(), out.as_mut_ptr(), r#in.len())
+            .expect_err("empty poll_oneoff should fail"),
+        wasi::ERRNO_INVAL
+    );
+}
+
+unsafe fn test_timeout() {
+    let timeout = 5_000_000u64; // 5 milliseconds
+    let clock = wasi::SubscriptionClock {
+        id: wasi::CLOCKID_MONOTONIC,
+        timeout,
+        precision: 0,
+        flags: 0,
+    };
+    let r#in = [wasi::Subscription {
+        userdata: CLOCK_ID,
+        u: wasi::SubscriptionU {
+            tag: wasi::EVENTTYPE_CLOCK.raw(),
+            u: wasi::SubscriptionUU { clock },
+        },
+    }];
+    let before = wasi::clock_time_get(wasi::CLOCKID_MONOTONIC, 0).unwrap();
+    let out = poll_oneoff_impl(&r#in).unwrap();
+    let after = wasi::clock_time_get(wasi::CLOCKID_MONOTONIC, 0).unwrap();
+    assert_eq!(out.len(), 1, "should return 1 event");
+    let event = &out[0];
+    assert_errno!(event.error, wasi::ERRNO_SUCCESS);
+    assert_eq!(
+        event.type_,
+        wasi::EVENTTYPE_CLOCK,
+        "the event.type should equal clock"
+    );
+    assert_eq!(
+        event.userdata, CLOCK_ID,
+        "the event.userdata should contain clock_id specified by the user"
+    );
+    assert!(
+        after - before >= timeout,
+        "poll_oneoff should sleep for the specified interval of {timeout}. before: {before}, after: {after}"
+    );
+}
+
+// Like test_timeout, but uses `CLOCKID_REALTIME`, as WASI libc's sleep
+// functions do.
+unsafe fn test_sleep() {
+    let timeout = 5_000_000u64; // 5 milliseconds
+    let clock = wasi::SubscriptionClock {
+        id: wasi::CLOCKID_REALTIME,
+        timeout,
+        precision: 0,
+        flags: 0,
+    };
+    let r#in = [wasi::Subscription {
+        userdata: CLOCK_ID,
+        u: wasi::SubscriptionU {
+            tag: wasi::EVENTTYPE_CLOCK.raw(),
+            u: wasi::SubscriptionUU { clock },
+        },
+    }];
+    let before = wasi::clock_time_get(wasi::CLOCKID_MONOTONIC, 0).unwrap();
+    let out = poll_oneoff_impl(&r#in).unwrap();
+    let after = wasi::clock_time_get(wasi::CLOCKID_MONOTONIC, 0).unwrap();
+    assert_eq!(out.len(), 1, "should return 1 event");
+    let event = &out[0];
+    assert_errno!(event.error, wasi::ERRNO_SUCCESS);
+    assert_eq!(
+        event.type_,
+        wasi::EVENTTYPE_CLOCK,
+        "the event.type should equal clock"
+    );
+    assert_eq!(
+        event.userdata, CLOCK_ID,
+        "the event.userdata should contain clock_id specified by the user"
+    );
+    assert!(
+        after - before >= timeout,
+        "poll_oneoff should sleep for the specified interval of {timeout}. before: {before}, after: {after}"
+    );
+}
+
+unsafe fn test_fd_readwrite(readable_fd: wasi::Fd, writable_fd: wasi::Fd, error_code: wasi::Errno) {
+    let r#in = [
+        wasi::Subscription {
+            userdata: 1,
+            u: wasi::SubscriptionU {
+                tag: wasi::EVENTTYPE_FD_READ.raw(),
+                u: wasi::SubscriptionUU {
+                    fd_read: wasi::SubscriptionFdReadwrite {
+                        file_descriptor: readable_fd,
+                    },
+                },
+            },
+        },
+        wasi::Subscription {
+            userdata: 2,
+            u: wasi::SubscriptionU {
+                tag: wasi::EVENTTYPE_FD_WRITE.raw(),
+                u: wasi::SubscriptionUU {
+                    fd_write: wasi::SubscriptionFdReadwrite {
+                        file_descriptor: writable_fd,
+                    },
+                },
+            },
+        },
+    ];
+    let out = poll_oneoff_with_retry(&r#in).unwrap();
+    assert_eq!(out.len(), 2, "should return 2 events, got: {out:?}");
+
+    let (read, write) = if out[0].userdata == 1 {
+        (&out[0], &out[1])
+    } else {
+        (&out[1], &out[0])
+    };
+    assert_eq!(
+        read.userdata, 1,
+        "the event.userdata should contain fd userdata specified by the user"
+    );
+    assert_errno!(read.error, error_code);
+    assert_eq!(
+        read.type_,
+        wasi::EVENTTYPE_FD_READ,
+        "the event.type_ should equal FD_READ"
+    );
+    assert_eq!(
+        write.userdata, 2,
+        "the event.userdata should contain fd userdata specified by the user"
+    );
+    assert_errno!(write.error, error_code);
+    assert_eq!(
+        write.type_,
+        wasi::EVENTTYPE_FD_WRITE,
+        "the event.type_ should equal FD_WRITE"
+    );
+}
+
+unsafe fn test_fd_readwrite_valid_fd(dir_fd: wasi::Fd) {
+    // Create a file in the scratch directory.
+    let nonempty_file = wasi::path_open(
+        dir_fd,
+        0,
+        "readable_file",
+        wasi::OFLAGS_CREAT,
+        wasi::RIGHTS_FD_WRITE,
+        0,
+        0,
+    )
+    .expect("create writable file");
+    // Write to file
+    let contents = &[1u8];
+    let ciovec = wasi::Ciovec {
+        buf: contents.as_ptr() as *const _,
+        buf_len: contents.len(),
+    };
+    wasi::fd_write(nonempty_file, &[ciovec]).expect("write");
+    wasi::fd_close(nonempty_file).expect("close");
+
+    // Now open the file for reading
+    let readable_fd = wasi::path_open(dir_fd, 0, "readable_file", 0, wasi::RIGHTS_FD_READ, 0, 0)
+        .expect("opening a readable file");
+
+    assert!(
+        readable_fd > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+    // Create a file in the scratch directory.
+    let writable_fd = wasi::path_open(
+        dir_fd,
+        0,
+        "writable_file",
+        wasi::OFLAGS_CREAT,
+        wasi::RIGHTS_FD_WRITE,
+        0,
+        0,
+    )
+    .expect("opening a writable file");
+    assert!(
+        writable_fd > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+
+    test_fd_readwrite(readable_fd, writable_fd, wasi::ERRNO_SUCCESS);
+
+    wasi::fd_close(readable_fd).expect("closing readable_file");
+    wasi::fd_close(writable_fd).expect("closing writable_file");
+    wasi::path_unlink_file(dir_fd, "readable_file").expect("removing readable_file");
+    wasi::path_unlink_file(dir_fd, "writable_file").expect("removing writable_file");
+}
+
+unsafe fn test_fd_readwrite_invalid_fd() {
+    let fd_readwrite = wasi::SubscriptionFdReadwrite {
+        file_descriptor: wasi::Fd::max_value(),
+    };
+    let r#in = [
+        wasi::Subscription {
+            userdata: 1,
+            u: wasi::SubscriptionU {
+                tag: wasi::EVENTTYPE_FD_READ.raw(),
+                u: wasi::SubscriptionUU {
+                    fd_read: fd_readwrite,
+                },
+            },
+        },
+        wasi::Subscription {
+            userdata: 2,
+            u: wasi::SubscriptionU {
+                tag: wasi::EVENTTYPE_FD_WRITE.raw(),
+                u: wasi::SubscriptionUU {
+                    fd_write: fd_readwrite,
+                },
+            },
+        },
+    ];
+    let err = poll_oneoff_impl(&r#in).unwrap_err();
+    assert_eq!(err, wasi::ERRNO_BADF)
+}
+
+unsafe fn test_poll_oneoff(dir_fd: wasi::Fd) {
+    test_timeout();
+    test_sleep();
+    test_empty_poll();
+    test_fd_readwrite_valid_fd(dir_fd);
+    test_fd_readwrite_invalid_fd();
+}
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_poll_oneoff(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview1_poll_oneoff_stdio.rs b/crates/test-programs/src/bin/preview1_poll_oneoff_stdio.rs
new file mode 100644
index 000000000000..6d0616dcb101
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_poll_oneoff_stdio.rs
@@ -0,0 +1,138 @@
+use std::collections::HashMap;
+use std::mem::MaybeUninit;
+use test_programs::preview1::{assert_errno, STDERR_FD, STDIN_FD, STDOUT_FD};
+
+const TIMEOUT: u64 = 200_000_000u64; // 200 milliseconds, required to satisfy slow execution in CI
+const CLOCK_ID: wasi::Userdata = 0x0123_45678;
+const STDIN_ID: wasi::Userdata = 0x8765_43210;
+
+unsafe fn poll_oneoff_impl(r#in: &[wasi::Subscription]) -> Result<Vec<wasi::Event>, wasi::Errno> {
+    let mut out: Vec<wasi::Event> = Vec::new();
+    out.resize_with(r#in.len(), || {
+        MaybeUninit::<wasi::Event>::zeroed().assume_init()
+    });
+    let size = wasi::poll_oneoff(r#in.as_ptr(), out.as_mut_ptr(), r#in.len())?;
+    out.truncate(size);
+    Ok(out)
+}
+
+unsafe fn test_stdin_read() {
+    let clock = wasi::SubscriptionClock {
+        id: wasi::CLOCKID_MONOTONIC,
+        timeout: TIMEOUT,
+        precision: 0,
+        flags: 0,
+    };
+    let fd_readwrite = wasi::SubscriptionFdReadwrite {
+        file_descriptor: STDIN_FD,
+    };
+    // Either stdin can be ready for reading, or this poll can timeout.
+    let r#in = [
+        wasi::Subscription {
+            userdata: CLOCK_ID,
+            u: wasi::SubscriptionU {
+                tag: wasi::EVENTTYPE_CLOCK.raw(),
+                u: wasi::SubscriptionUU { clock },
+            },
+        },
+        wasi::Subscription {
+            userdata: STDIN_ID,
+            u: wasi::SubscriptionU {
+                tag: wasi::EVENTTYPE_FD_READ.raw(),
+                u: wasi::SubscriptionUU {
+                    fd_read: fd_readwrite,
+                },
+            },
+        },
+    ];
+    let out = poll_oneoff_impl(&r#in).unwrap();
+    // The result should be either a timeout, or that stdin is ready for reading.
+    // Both are valid behaviors that depend on the test environment.
+    assert!(out.len() >= 1, "stdin read should return at least 1 event");
+    for event in out {
+        if event.type_ == wasi::EVENTTYPE_CLOCK {
+            assert_errno!(event.error, wasi::ERRNO_SUCCESS);
+            assert_eq!(
+                event.userdata, CLOCK_ID,
+                "the event.userdata should contain CLOCK_ID",
+            );
+        } else if event.type_ == wasi::EVENTTYPE_FD_READ {
+            assert_errno!(event.error, wasi::ERRNO_SUCCESS);
+            assert_eq!(
+                event.userdata, STDIN_ID,
+                "the event.userdata should contain STDIN_ID",
+            );
+        } else {
+            panic!("unexpected event type {}", event.type_.raw());
+        }
+    }
+}
+
+fn writable_subs(h: &HashMap<u64, wasi::Fd>) -> Vec<wasi::Subscription> {
+    h.iter()
+        .map(|(ud, fd)| wasi::Subscription {
+            userdata: *ud,
+            u: wasi::SubscriptionU {
+                tag: wasi::EVENTTYPE_FD_WRITE.raw(),
+                u: wasi::SubscriptionUU {
+                    fd_write: wasi::SubscriptionFdReadwrite {
+                        file_descriptor: *fd,
+                    },
+                },
+            },
+        })
+        .collect()
+}
+
+unsafe fn test_stdout_stderr_write() {
+    let mut writable: HashMap<u64, wasi::Fd> =
+        [(1, STDOUT_FD), (2, STDERR_FD)].into_iter().collect();
+
+    let clock = wasi::Subscription {
+        userdata: CLOCK_ID,
+        u: wasi::SubscriptionU {
+            tag: wasi::EVENTTYPE_CLOCK.raw(),
+            u: wasi::SubscriptionUU {
+                clock: wasi::SubscriptionClock {
+                    id: wasi::CLOCKID_MONOTONIC,
+                    timeout: TIMEOUT,
+                    precision: 0,
+                    flags: 0,
+                },
+            },
+        },
+    };
+    let mut timed_out = false;
+    while !writable.is_empty() {
+        if timed_out {
+            panic!("timed out with the following pending subs: {writable:?}")
+        }
+        let mut subs = writable_subs(&writable);
+        subs.push(clock);
+        let out = poll_oneoff_impl(&subs).unwrap();
+        for event in out {
+            match event.userdata {
+                CLOCK_ID => timed_out = true,
+                ud => {
+                    if let Some(_) = writable.remove(&ud) {
+                        assert_eq!(event.type_, wasi::EVENTTYPE_FD_WRITE);
+                        assert_errno!(event.error, wasi::ERRNO_SUCCESS);
+                    } else {
+                        panic!("Unknown userdata {ud}, pending sub: {writable:?}")
+                    }
+                }
+            }
+        }
+    }
+}
+
+unsafe fn test_poll_oneoff() {
+    // NB we assume that stdin/stdout/stderr are valid and open
+    // for the duration of the test case
+    test_stdin_read();
+    test_stdout_stderr_write();
+}
+fn main() {
+    // Run the tests.
+    unsafe { test_poll_oneoff() }
+}
diff --git a/crates/test-programs/src/bin/preview1_readlink.rs b/crates/test-programs/src/bin/preview1_readlink.rs
new file mode 100644
index 000000000000..cba9d9ada79b
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_readlink.rs
@@ -0,0 +1,81 @@
+use std::{env, process};
+use test_programs::preview1::{create_file, open_scratch_directory};
+
+unsafe fn test_readlink(dir_fd: wasi::Fd) {
+    // Create a file in the scratch directory.
+    create_file(dir_fd, "target");
+
+    // Create a symlink
+    wasi::path_symlink("target", dir_fd, "symlink").expect("creating a symlink");
+
+    // Read link into the buffer
+    let buf = &mut [0u8; 10];
+    let bufused = wasi::path_readlink(dir_fd, "symlink", buf.as_mut_ptr(), buf.len())
+        .expect("readlink should succeed");
+    assert_eq!(bufused, 6, "should use 6 bytes of the buffer");
+    assert_eq!(&buf[..6], b"target", "buffer should contain 'target'");
+    assert_eq!(
+        &buf[6..],
+        &[0u8; 4],
+        "the remaining bytes should be untouched"
+    );
+
+    // Read link into smaller buffer than the actual link's length
+    let buf = &mut [0u8; 4];
+    let bufused = wasi::path_readlink(dir_fd, "symlink", buf.as_mut_ptr(), buf.len())
+        .expect("readlink with too-small buffer should silently truncate");
+    assert_eq!(bufused, 4);
+    assert_eq!(buf, b"targ");
+
+    // Clean up.
+    wasi::path_unlink_file(dir_fd, "target").expect("removing a file");
+    wasi::path_unlink_file(dir_fd, "symlink").expect("removing a file");
+}
+
+unsafe fn test_incremental_readlink(dir_fd: wasi::Fd) {
+    let filename = "Действие";
+    create_file(dir_fd, filename);
+
+    wasi::path_symlink(filename, dir_fd, "symlink").expect("creating a symlink");
+
+    let mut buf = Vec::new();
+    loop {
+        if buf.capacity() > 2 * filename.len() {
+            panic!()
+        }
+        let bufused = wasi::path_readlink(dir_fd, "symlink", buf.as_mut_ptr(), buf.capacity())
+            .expect("readlink should succeed");
+        buf.set_len(bufused);
+        if buf.capacity() > filename.len() {
+            assert!(buf.starts_with(filename.as_bytes()));
+            break;
+        }
+        buf = Vec::with_capacity(buf.capacity() + 1);
+    }
+    wasi::path_unlink_file(dir_fd, filename).expect("removing a file");
+    wasi::path_unlink_file(dir_fd, "symlink").expect("removing a file");
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_readlink(dir_fd) }
+    unsafe { test_incremental_readlink(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview1_regular_file_isatty.rs b/crates/test-programs/src/bin/preview1_regular_file_isatty.rs
new file mode 100644
index 000000000000..54f407c0a2d7
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_regular_file_isatty.rs
@@ -0,0 +1,42 @@
+use std::{env, process};
+use test_programs::preview1::open_scratch_directory;
+
+unsafe fn test_file_isatty(dir_fd: wasi::Fd) {
+    // Create a file in the scratch directory and test if it's a tty.
+    let file_fd =
+        wasi::path_open(dir_fd, 0, "file", wasi::OFLAGS_CREAT, 0, 0, 0).expect("opening a file");
+    assert!(
+        file_fd > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+    assert_eq!(
+        libc::isatty(file_fd as std::os::raw::c_int),
+        0,
+        "file is a tty"
+    );
+    wasi::fd_close(file_fd).expect("closing a file");
+    wasi::path_unlink_file(dir_fd, "file").expect("removing a file");
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_file_isatty(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview1_remove_directory.rs b/crates/test-programs/src/bin/preview1_remove_directory.rs
new file mode 100644
index 000000000000..307cbd155e0c
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_remove_directory.rs
@@ -0,0 +1,57 @@
+use std::{env, process};
+use test_programs::preview1::{assert_errno, create_file, open_scratch_directory};
+
+unsafe fn test_remove_directory(dir_fd: wasi::Fd) {
+    // Create a directory in the scratch directory.
+    wasi::path_create_directory(dir_fd, "dir").expect("creating a directory");
+
+    // Test that removing it succeeds.
+    wasi::path_remove_directory(dir_fd, "dir")
+        .expect("remove_directory on a directory should succeed");
+
+    // There isn't consistient behavior across operating systems of whether removing with a
+    // directory where the path has a trailing slash succeeds or fails, so we won't test
+    // that behavior.
+
+    // Create a temporary file.
+    create_file(dir_fd, "file");
+
+    // Test that removing it with no trailing slash fails.
+    assert_errno!(
+        wasi::path_remove_directory(dir_fd, "file")
+            .expect_err("remove_directory without a trailing slash on a file should fail"),
+        wasi::ERRNO_NOTDIR
+    );
+
+    // Test that removing it with a trailing slash fails.
+    assert_errno!(
+        wasi::path_remove_directory(dir_fd, "file/")
+            .expect_err("remove_directory with a trailing slash on a file should fail"),
+        wasi::ERRNO_NOTDIR
+    );
+
+    wasi::path_unlink_file(dir_fd, "file").expect("removing a file");
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_remove_directory(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview1_remove_nonempty_directory.rs b/crates/test-programs/src/bin/preview1_remove_nonempty_directory.rs
new file mode 100644
index 000000000000..583c63e5cacd
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_remove_nonempty_directory.rs
@@ -0,0 +1,45 @@
+use std::{env, process};
+use test_programs::preview1::{assert_errno, open_scratch_directory};
+
+unsafe fn test_remove_nonempty_directory(dir_fd: wasi::Fd) {
+    // Create a directory in the scratch directory.
+    wasi::path_create_directory(dir_fd, "dir").expect("creating a directory");
+
+    // Create a directory in the directory we just created.
+    wasi::path_create_directory(dir_fd, "dir/nested").expect("creating a subdirectory");
+
+    // Test that attempting to unlink the first directory returns the expected error code.
+    assert_errno!(
+        wasi::path_remove_directory(dir_fd, "dir")
+            .expect_err("remove_directory on a directory should return ENOTEMPTY"),
+        wasi::ERRNO_NOTEMPTY
+    );
+
+    // Removing the directories.
+    wasi::path_remove_directory(dir_fd, "dir/nested")
+        .expect("remove_directory on a nested directory should succeed");
+    wasi::path_remove_directory(dir_fd, "dir").expect("removing a directory");
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_remove_nonempty_directory(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview1_renumber.rs b/crates/test-programs/src/bin/preview1_renumber.rs
new file mode 100644
index 000000000000..233ab2b58694
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_renumber.rs
@@ -0,0 +1,98 @@
+use std::{env, process};
+use test_programs::preview1::{assert_errno, open_scratch_directory};
+
+unsafe fn test_renumber(dir_fd: wasi::Fd) {
+    let pre_fd: wasi::Fd = (libc::STDERR_FILENO + 1) as wasi::Fd;
+
+    assert!(dir_fd > pre_fd, "dir_fd number");
+
+    // Create a file in the scratch directory.
+    let fd_from = wasi::path_open(
+        dir_fd,
+        0,
+        "file1",
+        wasi::OFLAGS_CREAT,
+        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
+        0,
+        0,
+    )
+    .expect("opening a file");
+    assert!(
+        fd_from > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+
+    // Get fd_from fdstat attributes
+    let fdstat_from =
+        wasi::fd_fdstat_get(fd_from).expect("calling fd_fdstat on the open file descriptor");
+
+    // Create another file in the scratch directory.
+    let fd_to = wasi::path_open(
+        dir_fd,
+        0,
+        "file2",
+        wasi::OFLAGS_CREAT,
+        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
+        0,
+        0,
+    )
+    .expect("opening a file");
+    assert!(
+        fd_to > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+
+    // Renumber fd of file1 into fd of file2
+    wasi::fd_renumber(fd_from, fd_to).expect("renumbering two descriptors");
+
+    // Ensure that fd_from is closed
+    assert_errno!(
+        wasi::fd_close(fd_from).expect_err("closing already closed file descriptor"),
+        wasi::ERRNO_BADF
+    );
+
+    // Ensure that fd_to is still open.
+    let fdstat_to =
+        wasi::fd_fdstat_get(fd_to).expect("calling fd_fdstat on the open file descriptor");
+    assert_eq!(
+        fdstat_from.fs_filetype, fdstat_to.fs_filetype,
+        "expected fd_to have the same fdstat as fd_from"
+    );
+    assert_eq!(
+        fdstat_from.fs_flags, fdstat_to.fs_flags,
+        "expected fd_to have the same fdstat as fd_from"
+    );
+    assert_eq!(
+        fdstat_from.fs_rights_base, fdstat_to.fs_rights_base,
+        "expected fd_to have the same fdstat as fd_from"
+    );
+    assert_eq!(
+        fdstat_from.fs_rights_inheriting, fdstat_to.fs_rights_inheriting,
+        "expected fd_to have the same fdstat as fd_from"
+    );
+
+    wasi::fd_close(fd_to).expect("closing a file");
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_renumber(dir_fd) }
+}
diff --git a/crates/test-programs/wasi-tests/src/bin/sched_yield.rs b/crates/test-programs/src/bin/preview1_sched_yield.rs
similarity index 100%
rename from crates/test-programs/wasi-tests/src/bin/sched_yield.rs
rename to crates/test-programs/src/bin/preview1_sched_yield.rs
diff --git a/crates/test-programs/src/bin/preview1_stdio.rs b/crates/test-programs/src/bin/preview1_stdio.rs
new file mode 100644
index 000000000000..49d5d430c960
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_stdio.rs
@@ -0,0 +1,13 @@
+use test_programs::preview1::{STDERR_FD, STDIN_FD, STDOUT_FD};
+
+unsafe fn test_stdio() {
+    for fd in &[STDIN_FD, STDOUT_FD, STDERR_FD] {
+        wasi::fd_fdstat_get(*fd).expect("fd_fdstat_get on stdio");
+        wasi::fd_renumber(*fd, *fd + 100).expect("renumbering stdio");
+    }
+}
+
+fn main() {
+    // Run the tests.
+    unsafe { test_stdio() }
+}
diff --git a/crates/test-programs/src/bin/preview1_stdio_isatty.rs b/crates/test-programs/src/bin/preview1_stdio_isatty.rs
new file mode 100644
index 000000000000..4f1785e31f10
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_stdio_isatty.rs
@@ -0,0 +1,10 @@
+unsafe fn test_stdio_isatty() {
+    assert_eq!(libc::isatty(libc::STDIN_FILENO), 1, "stdin is a tty");
+    assert_eq!(libc::isatty(libc::STDOUT_FILENO), 1, "stdout is a tty");
+    assert_eq!(libc::isatty(libc::STDERR_FILENO), 1, "stderr is a tty");
+}
+
+fn main() {
+    // Run the tests.
+    unsafe { test_stdio_isatty() }
+}
diff --git a/crates/test-programs/src/bin/preview1_stdio_not_isatty.rs b/crates/test-programs/src/bin/preview1_stdio_not_isatty.rs
new file mode 100644
index 000000000000..aed1046aacb7
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_stdio_not_isatty.rs
@@ -0,0 +1,10 @@
+unsafe fn test_stdio_not_isatty() {
+    assert_eq!(libc::isatty(libc::STDIN_FILENO), 0, "stdin is not a tty");
+    assert_eq!(libc::isatty(libc::STDOUT_FILENO), 0, "stdout is not a tty");
+    assert_eq!(libc::isatty(libc::STDERR_FILENO), 0, "stderr is not a tty");
+}
+
+fn main() {
+    // Run the tests.
+    unsafe { test_stdio_not_isatty() }
+}
diff --git a/crates/test-programs/src/bin/preview1_symlink_create.rs b/crates/test-programs/src/bin/preview1_symlink_create.rs
new file mode 100644
index 000000000000..fac57a8a49a1
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_symlink_create.rs
@@ -0,0 +1,95 @@
+use std::{env, process};
+use test_programs::preview1::open_scratch_directory;
+
+unsafe fn create_symlink_to_file(dir_fd: wasi::Fd) {
+    // Create a directory for the symlink to point to.
+    let target_fd =
+        wasi::path_open(dir_fd, 0, "target", wasi::OFLAGS_CREAT, 0, 0, 0).expect("creating a file");
+    wasi::fd_close(target_fd).expect("closing file");
+
+    // Create a symlink.
+    wasi::path_symlink("target", dir_fd, "symlink").expect("creating a symlink");
+
+    // Try to open it as a directory without O_NOFOLLOW.
+    let target_file_via_symlink = wasi::path_open(
+        dir_fd,
+        wasi::LOOKUPFLAGS_SYMLINK_FOLLOW,
+        "symlink",
+        0,
+        0,
+        0,
+        0,
+    )
+    .expect("opening a symlink as a directory");
+    assert!(
+        target_file_via_symlink > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+    wasi::fd_close(target_file_via_symlink).expect("close the symlink file");
+
+    // Replace the target directory with a file.
+    wasi::path_unlink_file(dir_fd, "symlink").expect("removing the symlink");
+    wasi::path_unlink_file(dir_fd, "target").expect("removing the target file");
+}
+
+unsafe fn create_symlink_to_directory(dir_fd: wasi::Fd) {
+    // Create a directory for the symlink to point to.
+    wasi::path_create_directory(dir_fd, "target").expect("creating a dir");
+
+    // Create a symlink.
+    wasi::path_symlink("target", dir_fd, "symlink").expect("creating a symlink");
+
+    // Try to open it as a directory without O_NOFOLLOW.
+    let target_dir_via_symlink = wasi::path_open(
+        dir_fd,
+        wasi::LOOKUPFLAGS_SYMLINK_FOLLOW,
+        "symlink",
+        wasi::OFLAGS_DIRECTORY,
+        0,
+        0,
+        0,
+    )
+    .expect("opening a symlink as a directory");
+    assert!(
+        target_dir_via_symlink > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+    wasi::fd_close(target_dir_via_symlink).expect("closing a file");
+
+    // Replace the target directory with a file.
+    wasi::path_unlink_file(dir_fd, "symlink").expect("remove symlink to directory");
+    wasi::path_remove_directory(dir_fd, "target")
+        .expect("remove_directory on a directory should succeed");
+}
+
+unsafe fn create_symlink_to_root(dir_fd: wasi::Fd) {
+    // Create a symlink.
+    wasi::path_symlink("/", dir_fd, "symlink").expect_err("creating a symlink to an absolute path");
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe {
+        create_symlink_to_file(dir_fd);
+        create_symlink_to_directory(dir_fd);
+        create_symlink_to_root(dir_fd);
+    }
+}
diff --git a/crates/test-programs/src/bin/preview1_symlink_filestat.rs b/crates/test-programs/src/bin/preview1_symlink_filestat.rs
new file mode 100644
index 000000000000..57ec517d969c
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_symlink_filestat.rs
@@ -0,0 +1,117 @@
+use std::{env, process, time::Duration};
+use test_programs::preview1::{assert_fs_time_eq, open_scratch_directory, TestConfig};
+
+unsafe fn test_path_filestat(dir_fd: wasi::Fd) {
+    let cfg = TestConfig::from_env();
+    // Create a file in the scratch directory.
+    let file_fd = wasi::path_open(
+        dir_fd,
+        0,
+        "file",
+        wasi::OFLAGS_CREAT,
+        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
+        0,
+        0,
+    )
+    .expect("opening a file");
+    assert!(
+        file_fd > libc::STDERR_FILENO as wasi::Fd,
+        "file descriptor range check",
+    );
+
+    // Check file size
+    let file_stat = wasi::path_filestat_get(dir_fd, 0, "file").expect("reading file stats");
+    assert_eq!(file_stat.size, 0, "file size should be 0");
+
+    // Create a symlink
+    wasi::path_symlink("file", dir_fd, "symlink").expect("creating symlink to a file");
+
+    // Check path_filestat_set_times on the symlink itself
+    let sym_stat = wasi::path_filestat_get(dir_fd, 0, "symlink").expect("reading symlink stats");
+
+    // Modify mtim of symlink
+    let sym_new_mtim = Duration::from_nanos(sym_stat.mtim) - cfg.fs_time_precision() * 2;
+    wasi::path_filestat_set_times(
+        dir_fd,
+        0,
+        "symlink",
+        0,
+        sym_new_mtim.as_nanos() as u64,
+        wasi::FSTFLAGS_MTIM,
+    )
+    .expect("path_filestat_set_times should succeed on symlink");
+
+    // Check that symlink mtim motification worked
+    let modified_sym_stat = wasi::path_filestat_get(dir_fd, 0, "symlink")
+        .expect("reading file stats after path_filestat_set_times");
+
+    assert_fs_time_eq!(
+        Duration::from_nanos(modified_sym_stat.mtim),
+        sym_new_mtim,
+        "symlink mtim should change"
+    );
+
+    // Check that pointee mtim is not modified
+    let unmodified_file_stat = wasi::path_filestat_get(dir_fd, 0, "file")
+        .expect("reading file stats after path_filestat_set_times");
+
+    assert_eq!(
+        unmodified_file_stat.mtim, file_stat.mtim,
+        "file mtim should not change"
+    );
+
+    // Now, dereference the symlink
+    let deref_sym_stat =
+        wasi::path_filestat_get(dir_fd, wasi::LOOKUPFLAGS_SYMLINK_FOLLOW, "symlink")
+            .expect("reading file stats on the dereferenced symlink");
+    assert_eq!(
+        deref_sym_stat.mtim, file_stat.mtim,
+        "symlink mtim should be equal to pointee's when dereferenced"
+    );
+
+    // Finally, change stat of the original file by dereferencing the symlink
+    wasi::path_filestat_set_times(
+        dir_fd,
+        wasi::LOOKUPFLAGS_SYMLINK_FOLLOW,
+        "symlink",
+        0,
+        sym_stat.mtim,
+        wasi::FSTFLAGS_MTIM,
+    )
+    .expect("path_filestat_set_times should succeed on setting stat on original file");
+
+    let new_file_stat = wasi::path_filestat_get(dir_fd, 0, "file")
+        .expect("reading file stats after path_filestat_set_times");
+
+    assert_fs_time_eq!(
+        Duration::from_nanos(new_file_stat.mtim),
+        Duration::from_nanos(sym_stat.mtim),
+        "mtim should change"
+    );
+
+    wasi::fd_close(file_fd).expect("closing a file");
+    wasi::path_unlink_file(dir_fd, "symlink").expect("removing a symlink");
+    wasi::path_unlink_file(dir_fd, "file").expect("removing a file");
+}
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_path_filestat(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview1_symlink_loop.rs b/crates/test-programs/src/bin/preview1_symlink_loop.rs
new file mode 100644
index 000000000000..8aeb3b9e12fb
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_symlink_loop.rs
@@ -0,0 +1,42 @@
+use std::{env, process};
+use test_programs::preview1::{assert_errno, config, open_scratch_directory};
+
+unsafe fn test_symlink_loop(dir_fd: wasi::Fd) {
+    if config().support_dangling_filesystem() {
+        // Create a self-referencing symlink.
+        wasi::path_symlink("symlink", dir_fd, "symlink").expect("creating a symlink");
+
+        // Try to open it.
+        assert_errno!(
+            wasi::path_open(dir_fd, 0, "symlink", 0, 0, 0, 0)
+                .expect_err("opening a self-referencing symlink"),
+            wasi::ERRNO_LOOP
+        );
+
+        // Clean up.
+        wasi::path_unlink_file(dir_fd, "symlink").expect("removing a file");
+    }
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_symlink_loop(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview1_unicode_output.rs b/crates/test-programs/src/bin/preview1_unicode_output.rs
new file mode 100644
index 000000000000..7e88dc27c79a
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_unicode_output.rs
@@ -0,0 +1,15 @@
+use test_programs::preview1::STDOUT_FD;
+fn main() {
+    let text = "مرحبا بكم\n";
+
+    let ciovecs = [wasi::Ciovec {
+        buf: text.as_bytes().as_ptr(),
+        buf_len: text.as_bytes().len(),
+    }];
+    let written = unsafe { wasi::fd_write(STDOUT_FD, &ciovecs) }.expect("write succeeds");
+    assert_eq!(
+        written,
+        text.as_bytes().len(),
+        "full contents should be written"
+    );
+}
diff --git a/crates/test-programs/src/bin/preview1_unlink_file_trailing_slashes.rs b/crates/test-programs/src/bin/preview1_unlink_file_trailing_slashes.rs
new file mode 100644
index 000000000000..9e27dab05de7
--- /dev/null
+++ b/crates/test-programs/src/bin/preview1_unlink_file_trailing_slashes.rs
@@ -0,0 +1,65 @@
+use std::{env, process};
+use test_programs::preview1::{assert_errno, create_file, open_scratch_directory};
+
+unsafe fn test_unlink_file_trailing_slashes(dir_fd: wasi::Fd) {
+    // Create a directory in the scratch directory.
+    wasi::path_create_directory(dir_fd, "dir").expect("creating a directory");
+
+    // Test that unlinking it fails.
+    assert_errno!(
+        wasi::path_unlink_file(dir_fd, "dir")
+            .expect_err("unlink_file on a directory should fail"),
+        macos => wasi::ERRNO_PERM,
+        unix => wasi::ERRNO_ISDIR,
+        windows => wasi::ERRNO_ACCES
+    );
+
+    // Test that unlinking it with a trailing flash fails.
+    assert_errno!(
+        wasi::path_unlink_file(dir_fd, "dir/")
+            .expect_err("unlink_file on a directory should fail"),
+        macos => wasi::ERRNO_PERM,
+        unix => wasi::ERRNO_ISDIR,
+        windows => wasi::ERRNO_ACCES
+    );
+
+    // Clean up.
+    wasi::path_remove_directory(dir_fd, "dir").expect("removing a directory");
+
+    // Create a temporary file.
+    create_file(dir_fd, "file");
+
+    // Test that unlinking it with a trailing flash fails.
+    assert_errno!(
+        wasi::path_unlink_file(dir_fd, "file/")
+            .expect_err("unlink_file with a trailing slash should fail"),
+        wasi::ERRNO_NOTDIR
+    );
+
+    // Test that unlinking it with no trailing flash succeeds.
+    wasi::path_unlink_file(dir_fd, "file")
+        .expect("unlink_file with no trailing slash should succeed");
+}
+
+fn main() {
+    let mut args = env::args();
+    let prog = args.next().unwrap();
+    let arg = if let Some(arg) = args.next() {
+        arg
+    } else {
+        eprintln!("usage: {prog} <scratch directory>");
+        process::exit(1);
+    };
+
+    // Open scratch directory
+    let dir_fd = match open_scratch_directory(&arg) {
+        Ok(dir_fd) => dir_fd,
+        Err(err) => {
+            eprintln!("{err}");
+            process::exit(1)
+        }
+    };
+
+    // Run the tests.
+    unsafe { test_unlink_file_trailing_slashes(dir_fd) }
+}
diff --git a/crates/test-programs/src/bin/preview2_adapter_badfd.rs b/crates/test-programs/src/bin/preview2_adapter_badfd.rs
new file mode 100644
index 000000000000..e437dd668dcc
--- /dev/null
+++ b/crates/test-programs/src/bin/preview2_adapter_badfd.rs
@@ -0,0 +1,46 @@
+fn main() {
+    #[link(wasm_import_module = "wasi_snapshot_preview1")]
+    extern "C" {
+        #[cfg_attr(target_arch = "wasm32", link_name = "adapter_open_badfd")]
+        fn adapter_open_badfd(fd: *mut u32) -> wasi::Errno;
+
+        #[cfg_attr(target_arch = "wasm32", link_name = "adapter_close_badfd")]
+        fn adapter_close_badfd(fd: u32) -> wasi::Errno;
+    }
+
+    unsafe {
+        let mut fd = 0;
+        assert_eq!(adapter_open_badfd(&mut fd), wasi::ERRNO_SUCCESS);
+
+        assert_eq!(wasi::fd_close(fd), Err(wasi::ERRNO_BADF));
+
+        assert_eq!(wasi::fd_fdstat_get(fd).map(drop), Err(wasi::ERRNO_BADF));
+
+        assert_eq!(wasi::fd_fdstat_set_rights(fd, 0, 0), Err(wasi::ERRNO_BADF));
+
+        let mut buffer = [0_u8; 1];
+        assert_eq!(
+            wasi::fd_read(
+                fd,
+                &[wasi::Iovec {
+                    buf: buffer.as_mut_ptr(),
+                    buf_len: 1
+                }]
+            ),
+            Err(wasi::ERRNO_BADF)
+        );
+
+        assert_eq!(
+            wasi::fd_write(
+                fd,
+                &[wasi::Ciovec {
+                    buf: buffer.as_ptr(),
+                    buf_len: 1
+                }]
+            ),
+            Err(wasi::ERRNO_BADF)
+        );
+
+        assert_eq!(adapter_close_badfd(fd), wasi::ERRNO_SUCCESS);
+    }
+}
diff --git a/crates/test-programs/src/bin/preview2_file_read_write.rs b/crates/test-programs/src/bin/preview2_file_read_write.rs
new file mode 100644
index 000000000000..8c39d6de573c
--- /dev/null
+++ b/crates/test-programs/src/bin/preview2_file_read_write.rs
@@ -0,0 +1,52 @@
+use test_programs::wasi;
+use test_programs::wasi::filesystem::types::{DescriptorFlags, OpenFlags, PathFlags};
+
+fn main() {
+    let preopens = wasi::filesystem::preopens::get_directories();
+    let (dir, _) = &preopens[0];
+
+    let filename = "test.txt";
+    let file = dir
+        .open_at(
+            PathFlags::empty(),
+            filename,
+            OpenFlags::CREATE,
+            DescriptorFlags::READ | DescriptorFlags::WRITE,
+        )
+        .unwrap();
+    let stream = file.write_via_stream(5).unwrap();
+    stream.blocking_write_and_flush(b"Hello, ").unwrap();
+    stream.blocking_write_and_flush(b"World!").unwrap();
+    drop(stream);
+
+    let stream = file.read_via_stream(0).unwrap();
+    let contents = stream.blocking_read(100).unwrap();
+    assert_eq!(contents, b"\0\0\0\0\0Hello, World!");
+    drop(stream);
+
+    // Test that file read streams behave like other read streams.
+    let mut buf = Vec::new();
+    let stream = file.read_via_stream(0).unwrap();
+    let ready = stream.subscribe();
+    loop {
+        ready.block();
+
+        match stream.read(0) {
+            Ok(chunk) => assert!(chunk.is_empty()),
+            Err(wasi::io::streams::StreamError::Closed) => break,
+            Err(e) => panic!("Failed checking stream state: {e:?}"),
+        }
+
+        match stream.read(4) {
+            Ok(chunk) => buf.extend(chunk),
+            Err(wasi::io::streams::StreamError::Closed) => break,
+            Err(e) => panic!("Failed reading stream: {e:?}"),
+        }
+    }
+    assert_eq!(buf, b"\0\0\0\0\0Hello, World!");
+    drop(ready);
+    drop(stream);
+    drop(file);
+
+    dir.unlink_file_at(filename).unwrap();
+}
diff --git a/crates/test-programs/src/bin/preview2_ip_name_lookup.rs b/crates/test-programs/src/bin/preview2_ip_name_lookup.rs
new file mode 100644
index 000000000000..13ca9cbc4ce0
--- /dev/null
+++ b/crates/test-programs/src/bin/preview2_ip_name_lookup.rs
@@ -0,0 +1,61 @@
+use test_programs::wasi::sockets::instance_network::Network;
+use test_programs::wasi::sockets::network::{ErrorCode, IpAddress};
+
+fn main() {
+    // Valid domains
+    resolve("localhost").unwrap();
+    resolve("example.com").unwrap();
+
+    // NB: this is an actual real resolution, so it might time out, might cause
+    // issues, etc. This result is ignored to prevent flaky failures in CI.
+    let _ = resolve("münchen.de");
+
+    // Valid IP addresses
+    assert_eq!(resolve_one("0.0.0.0").unwrap(), IpAddress::IPV4_UNSPECIFIED);
+    assert_eq!(resolve_one("127.0.0.1").unwrap(), IpAddress::IPV4_LOOPBACK);
+    assert_eq!(
+        resolve_one("192.0.2.0").unwrap(),
+        IpAddress::Ipv4((192, 0, 2, 0))
+    );
+    assert_eq!(resolve_one("::").unwrap(), IpAddress::IPV6_UNSPECIFIED);
+    assert_eq!(resolve_one("::1").unwrap(), IpAddress::IPV6_LOOPBACK);
+    assert_eq!(resolve_one("[::]").unwrap(), IpAddress::IPV6_UNSPECIFIED);
+    assert_eq!(
+        resolve_one("2001:0db8:0:0:0:0:0:0").unwrap(),
+        IpAddress::Ipv6((0x2001, 0x0db8, 0, 0, 0, 0, 0, 0))
+    );
+    assert_eq!(
+        resolve_one("dead:beef::").unwrap(),
+        IpAddress::Ipv6((0xdead, 0xbeef, 0, 0, 0, 0, 0, 0))
+    );
+    assert_eq!(
+        resolve_one("dead:beef::0").unwrap(),
+        IpAddress::Ipv6((0xdead, 0xbeef, 0, 0, 0, 0, 0, 0))
+    );
+    assert_eq!(
+        resolve_one("DEAD:BEEF::0").unwrap(),
+        IpAddress::Ipv6((0xdead, 0xbeef, 0, 0, 0, 0, 0, 0))
+    );
+
+    // Invalid inputs
+    assert_eq!(resolve("").unwrap_err(), ErrorCode::InvalidArgument);
+    assert_eq!(resolve(" ").unwrap_err(), ErrorCode::InvalidArgument);
+    assert_eq!(resolve("a.b<&>").unwrap_err(), ErrorCode::InvalidArgument);
+    assert_eq!(
+        resolve("127.0.0.1:80").unwrap_err(),
+        ErrorCode::InvalidArgument
+    );
+    assert_eq!(resolve("[::]:80").unwrap_err(), ErrorCode::InvalidArgument);
+    assert_eq!(
+        resolve("http://example.com/").unwrap_err(),
+        ErrorCode::InvalidArgument
+    );
+}
+
+fn resolve(name: &str) -> Result<Vec<IpAddress>, ErrorCode> {
+    Network::default().permissive_blocking_resolve_addresses(name)
+}
+
+fn resolve_one(name: &str) -> Result<IpAddress, ErrorCode> {
+    Ok(resolve(name)?.first().unwrap().to_owned())
+}
diff --git a/crates/test-programs/src/bin/preview2_pollable_correct.rs b/crates/test-programs/src/bin/preview2_pollable_correct.rs
new file mode 100644
index 000000000000..3ecc8a8e7fef
--- /dev/null
+++ b/crates/test-programs/src/bin/preview2_pollable_correct.rs
@@ -0,0 +1,12 @@
+use test_programs::wasi::cli::stdin;
+
+fn main() {
+    let stdin = stdin::get_stdin();
+    let p1 = stdin.subscribe();
+    let p2 = stdin.subscribe();
+
+    // Should work:
+    // - Exactly the same pollable passed in multiple times.
+    // - Distinct pollables for the same backing resource (stdin in this case).
+    test_programs::wasi::io::poll::poll(&[&p1, &p2, &p1, &p2]);
+}
diff --git a/crates/test-programs/src/bin/preview2_pollable_traps.rs b/crates/test-programs/src/bin/preview2_pollable_traps.rs
new file mode 100644
index 000000000000..55e61a5c6cc1
--- /dev/null
+++ b/crates/test-programs/src/bin/preview2_pollable_traps.rs
@@ -0,0 +1,4 @@
+fn main() {
+    // Polling an empty list should trap:
+    test_programs::wasi::io::poll::poll(&[]);
+}
diff --git a/crates/test-programs/src/bin/preview2_random.rs b/crates/test-programs/src/bin/preview2_random.rs
new file mode 100644
index 000000000000..491037d65794
--- /dev/null
+++ b/crates/test-programs/src/bin/preview2_random.rs
@@ -0,0 +1,40 @@
+use test_programs::wasi::random;
+
+fn main() {
+    let mut bytes = [0_u8; 256];
+    getrandom::getrandom(&mut bytes).unwrap();
+
+    assert!(bytes.iter().any(|x| *x != 0));
+
+    // Acquired random bytes should be of the expected length.
+    let array = random::random::get_random_bytes(100);
+    assert_eq!(array.len(), 100);
+
+    // It shouldn't take 100+ tries to get a nonzero random integer.
+    for i in 0.. {
+        if random::random::get_random_u64() == 0 {
+            continue;
+        }
+        assert!(i < 100);
+        break;
+    }
+
+    // The `insecure_seed` API should return the same result each time.
+    let (a1, b1) = random::insecure_seed::insecure_seed();
+    let (a2, b2) = random::insecure_seed::insecure_seed();
+    assert_eq!(a1, a2);
+    assert_eq!(b1, b2);
+
+    // Acquired random bytes should be of the expected length.
+    let array = random::insecure::get_insecure_random_bytes(100);
+    assert_eq!(array.len(), 100);
+
+    // It shouldn't take 100+ tries to get a nonzero random integer.
+    for i in 0.. {
+        if random::insecure::get_insecure_random_u64() == 0 {
+            continue;
+        }
+        assert!(i < 100);
+        break;
+    }
+}
diff --git a/crates/test-programs/src/bin/preview2_sleep.rs b/crates/test-programs/src/bin/preview2_sleep.rs
new file mode 100644
index 000000000000..a6c8dae39840
--- /dev/null
+++ b/crates/test-programs/src/bin/preview2_sleep.rs
@@ -0,0 +1,33 @@
+use test_programs::wasi::clocks::monotonic_clock;
+
+fn main() {
+    sleep_10ms();
+    sleep_0ms();
+    sleep_backwards_in_time();
+}
+
+fn sleep_10ms() {
+    let dur = 10_000_000;
+    let p = monotonic_clock::subscribe_instant(monotonic_clock::now() + dur);
+    p.block();
+    let p = monotonic_clock::subscribe_duration(dur);
+    p.block();
+}
+
+fn sleep_0ms() {
+    let p = monotonic_clock::subscribe_instant(monotonic_clock::now());
+    p.block();
+    let p = monotonic_clock::subscribe_duration(0);
+    assert!(
+        p.ready(),
+        "timer subscription with duration 0 is ready immediately"
+    );
+}
+
+fn sleep_backwards_in_time() {
+    let p = monotonic_clock::subscribe_instant(monotonic_clock::now() - 1);
+    assert!(
+        p.ready(),
+        "timer subscription for instant which has passed is ready immediately"
+    );
+}
diff --git a/crates/test-programs/src/bin/preview2_stream_pollable_correct.rs b/crates/test-programs/src/bin/preview2_stream_pollable_correct.rs
new file mode 100644
index 000000000000..7b2247764fc9
--- /dev/null
+++ b/crates/test-programs/src/bin/preview2_stream_pollable_correct.rs
@@ -0,0 +1,27 @@
+use test_programs::wasi::cli::{stdin, stdout};
+
+fn main() {
+    let stdin = stdin::get_stdin();
+    let stdin_pollable = stdin.subscribe();
+    stdin_pollable.block();
+    assert!(stdin_pollable.ready(), "after blocking, pollable is ready");
+    drop(stdin_pollable);
+    drop(stdin);
+
+    // Pollables can be used many times over their lifetime
+    let stdout = stdout::get_stdout();
+    let stdout_pollable = stdout.subscribe();
+
+    let chunk = [b'a'; 50];
+    for _ in 1..10 {
+        stdout_pollable.block();
+        assert!(stdout_pollable.ready(), "after blocking, pollable is ready");
+
+        let n = stdout.check_write().unwrap() as usize;
+        assert!(n >= chunk.len());
+        stdout.write(&chunk).unwrap();
+    }
+
+    drop(stdout_pollable);
+    drop(stdout);
+}
diff --git a/crates/test-programs/src/bin/preview2_stream_pollable_traps.rs b/crates/test-programs/src/bin/preview2_stream_pollable_traps.rs
new file mode 100644
index 000000000000..bcdb958b3433
--- /dev/null
+++ b/crates/test-programs/src/bin/preview2_stream_pollable_traps.rs
@@ -0,0 +1,10 @@
+use test_programs::wasi::cli::stdin;
+use test_programs::wasi::io::streams;
+
+fn main() {
+    let stdin: streams::InputStream = stdin::get_stdin();
+    let stdin_pollable = stdin.subscribe();
+    stdin_pollable.block();
+    drop(stdin);
+    unreachable!("execution should have trapped in line above when stream dropped before pollable");
+}
diff --git a/crates/test-programs/src/bin/preview2_tcp_bind.rs b/crates/test-programs/src/bin/preview2_tcp_bind.rs
new file mode 100644
index 000000000000..5cc54022e460
--- /dev/null
+++ b/crates/test-programs/src/bin/preview2_tcp_bind.rs
@@ -0,0 +1,181 @@
+use test_programs::sockets::attempt_random_port;
+use test_programs::wasi::sockets::network::{
+    ErrorCode, IpAddress, IpAddressFamily, IpSocketAddress, Network,
+};
+use test_programs::wasi::sockets::tcp::TcpSocket;
+
+/// Bind a socket and let the system determine a port.
+fn test_tcp_bind_ephemeral_port(net: &Network, ip: IpAddress) {
+    let bind_addr = IpSocketAddress::new(ip, 0);
+
+    let sock = TcpSocket::new(ip.family()).unwrap();
+    sock.blocking_bind(net, bind_addr).unwrap();
+
+    let bound_addr = sock.local_address().unwrap();
+
+    assert_eq!(bind_addr.ip(), bound_addr.ip());
+    assert_ne!(bind_addr.port(), bound_addr.port());
+}
+
+/// Bind a socket on a specified port.
+fn test_tcp_bind_specific_port(net: &Network, ip: IpAddress) {
+    let sock = TcpSocket::new(ip.family()).unwrap();
+
+    let bind_addr =
+        attempt_random_port(ip, |bind_addr| sock.blocking_bind(net, bind_addr)).unwrap();
+
+    let bound_addr = sock.local_address().unwrap();
+
+    assert_eq!(bind_addr.ip(), bound_addr.ip());
+    assert_eq!(bind_addr.port(), bound_addr.port());
+}
+
+/// Two sockets may not be actively bound to the same address at the same time.
+fn test_tcp_bind_addrinuse(net: &Network, ip: IpAddress) {
+    let bind_addr = IpSocketAddress::new(ip, 0);
+
+    let sock1 = TcpSocket::new(ip.family()).unwrap();
+    sock1.blocking_bind(net, bind_addr).unwrap();
+    sock1.blocking_listen().unwrap();
+
+    let bound_addr = sock1.local_address().unwrap();
+
+    let sock2 = TcpSocket::new(ip.family()).unwrap();
+    assert_eq!(
+        sock2.blocking_bind(net, bound_addr),
+        Err(ErrorCode::AddressInUse)
+    );
+}
+
+// The WASI runtime should set SO_REUSEADDR for us
+fn test_tcp_bind_reuseaddr(net: &Network, ip: IpAddress) {
+    let client = TcpSocket::new(ip.family()).unwrap();
+
+    let bind_addr = {
+        let listener1 = TcpSocket::new(ip.family()).unwrap();
+
+        let bind_addr =
+            attempt_random_port(ip, |bind_addr| listener1.blocking_bind(net, bind_addr)).unwrap();
+
+        listener1.blocking_listen().unwrap();
+
+        let connect_addr =
+            IpSocketAddress::new(IpAddress::new_loopback(ip.family()), bind_addr.port());
+        client.blocking_connect(net, connect_addr).unwrap();
+
+        let (accepted_connection, accepted_input, accepted_output) =
+            listener1.blocking_accept().unwrap();
+        accepted_output.blocking_write_zeroes_and_flush(10).unwrap();
+        drop(accepted_input);
+        drop(accepted_output);
+        drop(accepted_connection);
+        drop(listener1);
+
+        bind_addr
+    };
+
+    {
+        let listener2 = TcpSocket::new(ip.family()).unwrap();
+
+        // If SO_REUSEADDR was configured correctly, the following lines shouldn't be
+        // affected by the TIME_WAIT state of the just closed `listener1` socket:
+        listener2.blocking_bind(net, bind_addr).unwrap();
+        listener2.blocking_listen().unwrap();
+    }
+
+    drop(client);
+}
+
+// Try binding to an address that is not configured on the system.
+fn test_tcp_bind_addrnotavail(net: &Network, ip: IpAddress) {
+    let bind_addr = IpSocketAddress::new(ip, 0);
+
+    let sock = TcpSocket::new(ip.family()).unwrap();
+
+    assert_eq!(
+        sock.blocking_bind(net, bind_addr),
+        Err(ErrorCode::AddressNotBindable)
+    );
+}
+
+/// Bind should validate the address family.
+fn test_tcp_bind_wrong_family(net: &Network, family: IpAddressFamily) {
+    let wrong_ip = match family {
+        IpAddressFamily::Ipv4 => IpAddress::IPV6_LOOPBACK,
+        IpAddressFamily::Ipv6 => IpAddress::IPV4_LOOPBACK,
+    };
+
+    let sock = TcpSocket::new(family).unwrap();
+    let result = sock.blocking_bind(net, IpSocketAddress::new(wrong_ip, 0));
+
+    assert!(matches!(result, Err(ErrorCode::InvalidArgument)));
+}
+
+/// Bind only works on unicast addresses.
+fn test_tcp_bind_non_unicast(net: &Network) {
+    let ipv4_broadcast = IpSocketAddress::new(IpAddress::IPV4_BROADCAST, 0);
+    let ipv4_multicast = IpSocketAddress::new(IpAddress::Ipv4((224, 254, 0, 0)), 0);
+    let ipv6_multicast = IpSocketAddress::new(IpAddress::Ipv6((0xff00, 0, 0, 0, 0, 0, 0, 0)), 0);
+
+    let sock_v4 = TcpSocket::new(IpAddressFamily::Ipv4).unwrap();
+    let sock_v6 = TcpSocket::new(IpAddressFamily::Ipv6).unwrap();
+
+    assert!(matches!(
+        sock_v4.blocking_bind(net, ipv4_broadcast),
+        Err(ErrorCode::InvalidArgument)
+    ));
+    assert!(matches!(
+        sock_v4.blocking_bind(net, ipv4_multicast),
+        Err(ErrorCode::InvalidArgument)
+    ));
+    assert!(matches!(
+        sock_v6.blocking_bind(net, ipv6_multicast),
+        Err(ErrorCode::InvalidArgument)
+    ));
+}
+
+fn test_tcp_bind_dual_stack(net: &Network) {
+    let sock = TcpSocket::new(IpAddressFamily::Ipv6).unwrap();
+    let addr = IpSocketAddress::new(IpAddress::IPV4_MAPPED_LOOPBACK, 0);
+
+    // Binding an IPv4-mapped-IPv6 address on a ipv6-only socket should fail:
+    assert!(matches!(
+        sock.blocking_bind(net, addr),
+        Err(ErrorCode::InvalidArgument)
+    ));
+}
+
+fn main() {
+    const RESERVED_IPV4_ADDRESS: IpAddress = IpAddress::Ipv4((192, 0, 2, 0)); // Reserved for documentation and examples.
+    const RESERVED_IPV6_ADDRESS: IpAddress = IpAddress::Ipv6((0x2001, 0x0db8, 0, 0, 0, 0, 0, 0)); // Reserved for documentation and examples.
+
+    let net = Network::default();
+
+    test_tcp_bind_ephemeral_port(&net, IpAddress::IPV4_LOOPBACK);
+    test_tcp_bind_ephemeral_port(&net, IpAddress::IPV6_LOOPBACK);
+    test_tcp_bind_ephemeral_port(&net, IpAddress::IPV4_UNSPECIFIED);
+    test_tcp_bind_ephemeral_port(&net, IpAddress::IPV6_UNSPECIFIED);
+
+    test_tcp_bind_specific_port(&net, IpAddress::IPV4_LOOPBACK);
+    test_tcp_bind_specific_port(&net, IpAddress::IPV6_LOOPBACK);
+    test_tcp_bind_specific_port(&net, IpAddress::IPV4_UNSPECIFIED);
+    test_tcp_bind_specific_port(&net, IpAddress::IPV6_UNSPECIFIED);
+
+    test_tcp_bind_reuseaddr(&net, IpAddress::IPV4_LOOPBACK);
+    test_tcp_bind_reuseaddr(&net, IpAddress::IPV6_LOOPBACK);
+
+    test_tcp_bind_addrinuse(&net, IpAddress::IPV4_LOOPBACK);
+    test_tcp_bind_addrinuse(&net, IpAddress::IPV6_LOOPBACK);
+    test_tcp_bind_addrinuse(&net, IpAddress::IPV4_UNSPECIFIED);
+    test_tcp_bind_addrinuse(&net, IpAddress::IPV6_UNSPECIFIED);
+
+    test_tcp_bind_addrnotavail(&net, RESERVED_IPV4_ADDRESS);
+    test_tcp_bind_addrnotavail(&net, RESERVED_IPV6_ADDRESS);
+
+    test_tcp_bind_wrong_family(&net, IpAddressFamily::Ipv4);
+    test_tcp_bind_wrong_family(&net, IpAddressFamily::Ipv6);
+
+    test_tcp_bind_non_unicast(&net);
+
+    test_tcp_bind_dual_stack(&net);
+}
diff --git a/crates/test-programs/src/bin/preview2_tcp_connect.rs b/crates/test-programs/src/bin/preview2_tcp_connect.rs
new file mode 100644
index 000000000000..d840cc5934ff
--- /dev/null
+++ b/crates/test-programs/src/bin/preview2_tcp_connect.rs
@@ -0,0 +1,113 @@
+use test_programs::wasi::sockets::network::{
+    ErrorCode, IpAddress, IpAddressFamily, IpSocketAddress, Network,
+};
+use test_programs::wasi::sockets::tcp::TcpSocket;
+
+const SOME_PORT: u16 = 47; // If the tests pass, this will never actually be connected to.
+
+/// `0.0.0.0` / `::` is not a valid remote address in WASI.
+fn test_tcp_connect_unspec(net: &Network, family: IpAddressFamily) {
+    let addr = IpSocketAddress::new(IpAddress::new_unspecified(family), SOME_PORT);
+    let sock = TcpSocket::new(family).unwrap();
+
+    assert!(matches!(
+        sock.blocking_connect(net, addr),
+        Err(ErrorCode::InvalidArgument)
+    ));
+}
+
+/// 0 is not a valid remote port.
+fn test_tcp_connect_port_0(net: &Network, family: IpAddressFamily) {
+    let addr = IpSocketAddress::new(IpAddress::new_loopback(family), 0);
+    let sock = TcpSocket::new(family).unwrap();
+
+    assert!(matches!(
+        sock.blocking_connect(net, addr),
+        Err(ErrorCode::InvalidArgument)
+    ));
+}
+
+/// Connect should validate the address family.
+fn test_tcp_connect_wrong_family(net: &Network, family: IpAddressFamily) {
+    let wrong_ip = match family {
+        IpAddressFamily::Ipv4 => IpAddress::IPV6_LOOPBACK,
+        IpAddressFamily::Ipv6 => IpAddress::IPV4_LOOPBACK,
+    };
+    let remote_addr = IpSocketAddress::new(wrong_ip, SOME_PORT);
+
+    let sock = TcpSocket::new(family).unwrap();
+
+    assert!(matches!(
+        sock.blocking_connect(net, remote_addr),
+        Err(ErrorCode::InvalidArgument)
+    ));
+}
+
+/// Can only connect to unicast addresses.
+fn test_tcp_connect_non_unicast(net: &Network) {
+    let ipv4_broadcast = IpSocketAddress::new(IpAddress::IPV4_BROADCAST, SOME_PORT);
+    let ipv4_multicast = IpSocketAddress::new(IpAddress::Ipv4((224, 254, 0, 0)), SOME_PORT);
+    let ipv6_multicast =
+        IpSocketAddress::new(IpAddress::Ipv6((0xff00, 0, 0, 0, 0, 0, 0, 0)), SOME_PORT);
+
+    let sock_v4 = TcpSocket::new(IpAddressFamily::Ipv4).unwrap();
+    let sock_v6 = TcpSocket::new(IpAddressFamily::Ipv6).unwrap();
+
+    assert!(matches!(
+        sock_v4.blocking_connect(net, ipv4_broadcast),
+        Err(ErrorCode::InvalidArgument)
+    ));
+    assert!(matches!(
+        sock_v4.blocking_connect(net, ipv4_multicast),
+        Err(ErrorCode::InvalidArgument)
+    ));
+    assert!(matches!(
+        sock_v6.blocking_connect(net, ipv6_multicast),
+        Err(ErrorCode::InvalidArgument)
+    ));
+}
+
+fn test_tcp_connect_dual_stack(net: &Network) {
+    // Set-up:
+    let v4_listener = TcpSocket::new(IpAddressFamily::Ipv4).unwrap();
+    v4_listener
+        .blocking_bind(&net, IpSocketAddress::new(IpAddress::IPV4_LOOPBACK, 0))
+        .unwrap();
+    v4_listener.blocking_listen().unwrap();
+
+    let v4_listener_addr = v4_listener.local_address().unwrap();
+    let v6_listener_addr =
+        IpSocketAddress::new(IpAddress::IPV4_MAPPED_LOOPBACK, v4_listener_addr.port());
+
+    let v6_client = TcpSocket::new(IpAddressFamily::Ipv6).unwrap();
+
+    // Tests:
+
+    // Connecting to an IPv4 address on an IPv6 socket should fail:
+    assert!(matches!(
+        v6_client.blocking_connect(net, v4_listener_addr),
+        Err(ErrorCode::InvalidArgument)
+    ));
+    // Connecting to an IPv4-mapped-IPv6 address on an IPv6 socket should fail:
+    assert!(matches!(
+        v6_client.blocking_connect(net, v6_listener_addr),
+        Err(ErrorCode::InvalidArgument)
+    ));
+}
+
+fn main() {
+    let net = Network::default();
+
+    test_tcp_connect_unspec(&net, IpAddressFamily::Ipv4);
+    test_tcp_connect_unspec(&net, IpAddressFamily::Ipv6);
+
+    test_tcp_connect_port_0(&net, IpAddressFamily::Ipv4);
+    test_tcp_connect_port_0(&net, IpAddressFamily::Ipv6);
+
+    test_tcp_connect_wrong_family(&net, IpAddressFamily::Ipv4);
+    test_tcp_connect_wrong_family(&net, IpAddressFamily::Ipv6);
+
+    test_tcp_connect_non_unicast(&net);
+
+    test_tcp_connect_dual_stack(&net);
+}
diff --git a/crates/test-programs/src/bin/preview2_tcp_sample_application.rs b/crates/test-programs/src/bin/preview2_tcp_sample_application.rs
new file mode 100644
index 000000000000..cdbacfbc92b8
--- /dev/null
+++ b/crates/test-programs/src/bin/preview2_tcp_sample_application.rs
@@ -0,0 +1,73 @@
+use test_programs::wasi::sockets::network::{
+    IpAddressFamily, IpSocketAddress, Ipv4SocketAddress, Ipv6SocketAddress, Network,
+};
+use test_programs::wasi::sockets::tcp::TcpSocket;
+
+fn test_tcp_sample_application(family: IpAddressFamily, bind_address: IpSocketAddress) {
+    let first_message = b"Hello, world!";
+    let second_message = b"Greetings, planet!";
+
+    let net = Network::default();
+    let listener = TcpSocket::new(family).unwrap();
+
+    listener.blocking_bind(&net, bind_address).unwrap();
+    listener.set_listen_backlog_size(32).unwrap();
+    listener.blocking_listen().unwrap();
+
+    let addr = listener.local_address().unwrap();
+
+    {
+        let client = TcpSocket::new(family).unwrap();
+        let (_client_input, client_output) = client.blocking_connect(&net, addr).unwrap();
+
+        client_output.blocking_write_util(&[]).unwrap();
+        client_output.blocking_write_util(first_message).unwrap();
+    }
+
+    {
+        let (_accepted, input, _output) = listener.blocking_accept().unwrap();
+
+        let empty_data = input.read(0).unwrap();
+        assert!(empty_data.is_empty());
+
+        let data = input.blocking_read(first_message.len() as u64).unwrap();
+
+        // Check that we sent and received our message!
+        assert_eq!(data, first_message); // Not guaranteed to work but should work in practice.
+    }
+
+    // Another client
+    {
+        let client = TcpSocket::new(family).unwrap();
+        let (_client_input, client_output) = client.blocking_connect(&net, addr).unwrap();
+
+        client_output.blocking_write_util(second_message).unwrap();
+    }
+
+    {
+        let (_accepted, input, _output) = listener.blocking_accept().unwrap();
+        let data = input.blocking_read(second_message.len() as u64).unwrap();
+
+        // Check that we sent and received our message!
+        assert_eq!(data, second_message); // Not guaranteed to work but should work in practice.
+    }
+}
+
+fn main() {
+    test_tcp_sample_application(
+        IpAddressFamily::Ipv4,
+        IpSocketAddress::Ipv4(Ipv4SocketAddress {
+            port: 0,                 // use any free port
+            address: (127, 0, 0, 1), // localhost
+        }),
+    );
+    test_tcp_sample_application(
+        IpAddressFamily::Ipv6,
+        IpSocketAddress::Ipv6(Ipv6SocketAddress {
+            port: 0,                           // use any free port
+            address: (0, 0, 0, 0, 0, 0, 0, 1), // localhost
+            flow_info: 0,
+            scope_id: 0,
+        }),
+    );
+}
diff --git a/crates/test-programs/src/bin/preview2_tcp_sockopts.rs b/crates/test-programs/src/bin/preview2_tcp_sockopts.rs
new file mode 100644
index 000000000000..d52f7c8f902d
--- /dev/null
+++ b/crates/test-programs/src/bin/preview2_tcp_sockopts.rs
@@ -0,0 +1,232 @@
+use test_programs::wasi::sockets::network::{
+    ErrorCode, IpAddress, IpAddressFamily, IpSocketAddress, Network,
+};
+use test_programs::wasi::sockets::tcp::TcpSocket;
+
+const SECOND: u64 = 1_000_000_000;
+
+fn test_tcp_sockopt_defaults(family: IpAddressFamily) {
+    let sock = TcpSocket::new(family).unwrap();
+
+    assert_eq!(sock.address_family(), family);
+
+    sock.keep_alive_enabled().unwrap(); // Only verify that it has a default value at all, but either value is valid.
+    assert!(sock.keep_alive_idle_time().unwrap() > 0);
+    assert!(sock.keep_alive_interval().unwrap() > 0);
+    assert!(sock.keep_alive_count().unwrap() > 0);
+    assert!(sock.hop_limit().unwrap() > 0);
+    assert!(sock.receive_buffer_size().unwrap() > 0);
+    assert!(sock.send_buffer_size().unwrap() > 0);
+}
+
+fn test_tcp_sockopt_input_ranges(family: IpAddressFamily) {
+    let sock = TcpSocket::new(family).unwrap();
+
+    assert!(matches!(
+        sock.set_listen_backlog_size(0),
+        Err(ErrorCode::InvalidArgument)
+    ));
+    assert!(matches!(sock.set_listen_backlog_size(1), Ok(_))); // Unsupported sizes should be silently capped.
+    assert!(matches!(sock.set_listen_backlog_size(u64::MAX), Ok(_))); // Unsupported sizes should be silently capped.
+
+    assert!(matches!(sock.set_keep_alive_enabled(true), Ok(_)));
+    assert!(matches!(sock.set_keep_alive_enabled(false), Ok(_)));
+
+    assert!(matches!(
+        sock.set_keep_alive_idle_time(0),
+        Err(ErrorCode::InvalidArgument)
+    ));
+    assert!(matches!(sock.set_keep_alive_idle_time(1), Ok(_))); // Unsupported sizes should be silently clamped.
+    let idle_time = sock.keep_alive_idle_time().unwrap(); // Check that the special 0/reset behavior was not triggered by the previous line.
+    assert!(idle_time > 0 && idle_time <= 1 * SECOND);
+    assert!(matches!(sock.set_keep_alive_idle_time(u64::MAX), Ok(_))); // Unsupported sizes should be silently clamped.
+
+    assert!(matches!(
+        sock.set_keep_alive_interval(0),
+        Err(ErrorCode::InvalidArgument)
+    ));
+    assert!(matches!(sock.set_keep_alive_interval(1), Ok(_))); // Unsupported sizes should be silently clamped.
+    let idle_time = sock.keep_alive_interval().unwrap(); // Check that the special 0/reset behavior was not triggered by the previous line.
+    assert!(idle_time > 0 && idle_time <= 1 * SECOND);
+    assert!(matches!(sock.set_keep_alive_interval(u64::MAX), Ok(_))); // Unsupported sizes should be silently clamped.
+
+    assert!(matches!(
+        sock.set_keep_alive_count(0),
+        Err(ErrorCode::InvalidArgument)
+    ));
+    assert!(matches!(sock.set_keep_alive_count(1), Ok(_))); // Unsupported sizes should be silently clamped.
+    assert!(matches!(sock.set_keep_alive_count(u32::MAX), Ok(_))); // Unsupported sizes should be silently clamped.
+
+    assert!(matches!(
+        sock.set_hop_limit(0),
+        Err(ErrorCode::InvalidArgument)
+    ));
+    assert!(matches!(sock.set_hop_limit(1), Ok(_)));
+    assert!(matches!(sock.set_hop_limit(u8::MAX), Ok(_)));
+
+    assert!(matches!(
+        sock.set_receive_buffer_size(0),
+        Err(ErrorCode::InvalidArgument)
+    ));
+    assert!(matches!(sock.set_receive_buffer_size(1), Ok(_))); // Unsupported sizes should be silently capped.
+    assert!(matches!(sock.set_receive_buffer_size(u64::MAX), Ok(_))); // Unsupported sizes should be silently capped.
+    assert!(matches!(
+        sock.set_send_buffer_size(0),
+        Err(ErrorCode::InvalidArgument)
+    ));
+    assert!(matches!(sock.set_send_buffer_size(1), Ok(_))); // Unsupported sizes should be silently capped.
+    assert!(matches!(sock.set_send_buffer_size(u64::MAX), Ok(_))); // Unsupported sizes should be silently capped.
+}
+
+fn test_tcp_sockopt_readback(family: IpAddressFamily) {
+    let sock = TcpSocket::new(family).unwrap();
+
+    sock.set_keep_alive_enabled(true).unwrap();
+    assert_eq!(sock.keep_alive_enabled().unwrap(), true);
+    sock.set_keep_alive_enabled(false).unwrap();
+    assert_eq!(sock.keep_alive_enabled().unwrap(), false);
+
+    sock.set_keep_alive_idle_time(42 * SECOND).unwrap();
+    assert_eq!(sock.keep_alive_idle_time().unwrap(), 42 * SECOND);
+
+    sock.set_keep_alive_interval(42 * SECOND).unwrap();
+    assert_eq!(sock.keep_alive_interval().unwrap(), 42 * SECOND);
+
+    sock.set_keep_alive_count(42).unwrap();
+    assert_eq!(sock.keep_alive_count().unwrap(), 42);
+
+    sock.set_hop_limit(42).unwrap();
+    assert_eq!(sock.hop_limit().unwrap(), 42);
+
+    sock.set_receive_buffer_size(0x10000).unwrap();
+    assert_eq!(sock.receive_buffer_size().unwrap(), 0x10000);
+
+    sock.set_send_buffer_size(0x10000).unwrap();
+    assert_eq!(sock.send_buffer_size().unwrap(), 0x10000);
+}
+
+fn test_tcp_sockopt_inheritance(net: &Network, family: IpAddressFamily) {
+    let bind_addr = IpSocketAddress::new(IpAddress::new_loopback(family), 0);
+    let listener = TcpSocket::new(family).unwrap();
+
+    let default_keep_alive = listener.keep_alive_enabled().unwrap();
+
+    // Configure options on listener:
+    {
+        listener
+            .set_keep_alive_enabled(!default_keep_alive)
+            .unwrap();
+        listener.set_keep_alive_idle_time(42 * SECOND).unwrap();
+        listener.set_keep_alive_interval(42 * SECOND).unwrap();
+        listener.set_keep_alive_count(42).unwrap();
+        listener.set_hop_limit(42).unwrap();
+        listener.set_receive_buffer_size(0x10000).unwrap();
+        listener.set_send_buffer_size(0x10000).unwrap();
+    }
+
+    listener.blocking_bind(&net, bind_addr).unwrap();
+    listener.blocking_listen().unwrap();
+    let bound_addr = listener.local_address().unwrap();
+    let client = TcpSocket::new(family).unwrap();
+    client.blocking_connect(&net, bound_addr).unwrap();
+    let (accepted_client, _, _) = listener.blocking_accept().unwrap();
+
+    // Verify options on accepted socket:
+    {
+        assert_eq!(
+            accepted_client.keep_alive_enabled().unwrap(),
+            !default_keep_alive
+        );
+        assert_eq!(accepted_client.keep_alive_idle_time().unwrap(), 42 * SECOND);
+        assert_eq!(accepted_client.keep_alive_interval().unwrap(), 42 * SECOND);
+        assert_eq!(accepted_client.keep_alive_count().unwrap(), 42);
+        assert_eq!(accepted_client.hop_limit().unwrap(), 42);
+        assert_eq!(accepted_client.receive_buffer_size().unwrap(), 0x10000);
+        assert_eq!(accepted_client.send_buffer_size().unwrap(), 0x10000);
+    }
+
+    // Update options on listener to something else:
+    {
+        listener.set_keep_alive_enabled(default_keep_alive).unwrap();
+        listener.set_keep_alive_idle_time(43 * SECOND).unwrap();
+        listener.set_keep_alive_interval(43 * SECOND).unwrap();
+        listener.set_keep_alive_count(43).unwrap();
+        listener.set_hop_limit(43).unwrap();
+        listener.set_receive_buffer_size(0x20000).unwrap();
+        listener.set_send_buffer_size(0x20000).unwrap();
+    }
+
+    // Verify that the already accepted socket was not affected:
+    {
+        assert_eq!(
+            accepted_client.keep_alive_enabled().unwrap(),
+            !default_keep_alive
+        );
+        assert_eq!(accepted_client.keep_alive_idle_time().unwrap(), 42 * SECOND);
+        assert_eq!(accepted_client.keep_alive_interval().unwrap(), 42 * SECOND);
+        assert_eq!(accepted_client.keep_alive_count().unwrap(), 42);
+        assert_eq!(accepted_client.hop_limit().unwrap(), 42);
+        assert_eq!(accepted_client.receive_buffer_size().unwrap(), 0x10000);
+        assert_eq!(accepted_client.send_buffer_size().unwrap(), 0x10000);
+    }
+}
+
+fn test_tcp_sockopt_after_listen(net: &Network, family: IpAddressFamily) {
+    let bind_addr = IpSocketAddress::new(IpAddress::new_loopback(family), 0);
+    let listener = TcpSocket::new(family).unwrap();
+    listener.blocking_bind(&net, bind_addr).unwrap();
+    listener.blocking_listen().unwrap();
+    let bound_addr = listener.local_address().unwrap();
+
+    let default_keep_alive = listener.keep_alive_enabled().unwrap();
+
+    // Update options while the socket is already listening:
+    {
+        listener
+            .set_keep_alive_enabled(!default_keep_alive)
+            .unwrap();
+        listener.set_keep_alive_idle_time(42 * SECOND).unwrap();
+        listener.set_keep_alive_interval(42 * SECOND).unwrap();
+        listener.set_keep_alive_count(42).unwrap();
+        listener.set_hop_limit(42).unwrap();
+        listener.set_receive_buffer_size(0x10000).unwrap();
+        listener.set_send_buffer_size(0x10000).unwrap();
+    }
+
+    let client = TcpSocket::new(family).unwrap();
+    client.blocking_connect(&net, bound_addr).unwrap();
+    let (accepted_client, _, _) = listener.blocking_accept().unwrap();
+
+    // Verify options on accepted socket:
+    {
+        assert_eq!(
+            accepted_client.keep_alive_enabled().unwrap(),
+            !default_keep_alive
+        );
+        assert_eq!(accepted_client.keep_alive_idle_time().unwrap(), 42 * SECOND);
+        assert_eq!(accepted_client.keep_alive_interval().unwrap(), 42 * SECOND);
+        assert_eq!(accepted_client.keep_alive_count().unwrap(), 42);
+        assert_eq!(accepted_client.hop_limit().unwrap(), 42);
+        assert_eq!(accepted_client.receive_buffer_size().unwrap(), 0x10000);
+        assert_eq!(accepted_client.send_buffer_size().unwrap(), 0x10000);
+    }
+}
+
+fn main() {
+    let net = Network::default();
+
+    test_tcp_sockopt_defaults(IpAddressFamily::Ipv4);
+    test_tcp_sockopt_defaults(IpAddressFamily::Ipv6);
+
+    test_tcp_sockopt_input_ranges(IpAddressFamily::Ipv4);
+    test_tcp_sockopt_input_ranges(IpAddressFamily::Ipv6);
+
+    test_tcp_sockopt_readback(IpAddressFamily::Ipv4);
+    test_tcp_sockopt_readback(IpAddressFamily::Ipv6);
+
+    test_tcp_sockopt_inheritance(&net, IpAddressFamily::Ipv4);
+    test_tcp_sockopt_inheritance(&net, IpAddressFamily::Ipv6);
+
+    test_tcp_sockopt_after_listen(&net, IpAddressFamily::Ipv4);
+    test_tcp_sockopt_after_listen(&net, IpAddressFamily::Ipv6);
+}
diff --git a/crates/test-programs/src/bin/preview2_tcp_states.rs b/crates/test-programs/src/bin/preview2_tcp_states.rs
new file mode 100644
index 000000000000..4d31e36cf0c7
--- /dev/null
+++ b/crates/test-programs/src/bin/preview2_tcp_states.rs
@@ -0,0 +1,229 @@
+use test_programs::wasi::sockets::network::{
+    ErrorCode, IpAddress, IpAddressFamily, IpSocketAddress, Network,
+};
+use test_programs::wasi::sockets::tcp::{ShutdownType, TcpSocket};
+
+fn test_tcp_unbound_state_invariants(family: IpAddressFamily) {
+    let sock = TcpSocket::new(family).unwrap();
+
+    // Skipping: tcp::start_bind
+    assert!(matches!(sock.finish_bind(), Err(ErrorCode::NotInProgress)));
+    // Skipping: tcp::start_connect
+    assert!(matches!(
+        sock.finish_connect(),
+        Err(ErrorCode::NotInProgress)
+    ));
+    assert!(matches!(
+        sock.start_listen(),
+        Err(ErrorCode::InvalidState) // Unlike POSIX, trying to listen without an explicit bind should fail in WASI.
+    ));
+    assert!(matches!(
+        sock.finish_listen(),
+        Err(ErrorCode::NotInProgress)
+    ));
+    assert!(matches!(sock.accept(), Err(ErrorCode::InvalidState)));
+    assert!(matches!(
+        sock.shutdown(ShutdownType::Both),
+        Err(ErrorCode::InvalidState)
+    ));
+
+    assert!(matches!(sock.local_address(), Err(ErrorCode::InvalidState)));
+    assert!(matches!(
+        sock.remote_address(),
+        Err(ErrorCode::InvalidState)
+    ));
+    assert_eq!(sock.is_listening(), false);
+    assert_eq!(sock.address_family(), family);
+
+    assert!(matches!(sock.set_listen_backlog_size(32), Ok(_)));
+    assert!(matches!(sock.keep_alive_enabled(), Ok(_)));
+    assert!(matches!(sock.set_keep_alive_enabled(false), Ok(_)));
+    assert!(matches!(sock.keep_alive_idle_time(), Ok(_)));
+    assert!(matches!(sock.set_keep_alive_idle_time(1), Ok(_)));
+    assert!(matches!(sock.keep_alive_interval(), Ok(_)));
+    assert!(matches!(sock.set_keep_alive_interval(1), Ok(_)));
+    assert!(matches!(sock.keep_alive_count(), Ok(_)));
+    assert!(matches!(sock.set_keep_alive_count(1), Ok(_)));
+    assert!(matches!(sock.hop_limit(), Ok(_)));
+    assert!(matches!(sock.set_hop_limit(255), Ok(_)));
+    assert!(matches!(sock.receive_buffer_size(), Ok(_)));
+    assert!(matches!(sock.set_receive_buffer_size(16000), Ok(_)));
+    assert!(matches!(sock.send_buffer_size(), Ok(_)));
+    assert!(matches!(sock.set_send_buffer_size(16000), Ok(_)));
+}
+
+fn test_tcp_bound_state_invariants(net: &Network, family: IpAddressFamily) {
+    let bind_address = IpSocketAddress::new(IpAddress::new_loopback(family), 0);
+    let sock = TcpSocket::new(family).unwrap();
+    sock.blocking_bind(net, bind_address).unwrap();
+
+    assert!(matches!(
+        sock.start_bind(net, bind_address),
+        Err(ErrorCode::InvalidState)
+    ));
+    assert!(matches!(sock.finish_bind(), Err(ErrorCode::NotInProgress)));
+    // Skipping: tcp::start_connect
+    assert!(matches!(
+        sock.finish_connect(),
+        Err(ErrorCode::NotInProgress)
+    ));
+    // Skipping: tcp::start_listen
+    assert!(matches!(
+        sock.finish_listen(),
+        Err(ErrorCode::NotInProgress)
+    ));
+    assert!(matches!(sock.accept(), Err(ErrorCode::InvalidState)));
+    assert!(matches!(
+        sock.shutdown(ShutdownType::Both),
+        Err(ErrorCode::InvalidState)
+    ));
+
+    assert!(matches!(sock.local_address(), Ok(_)));
+    assert!(matches!(
+        sock.remote_address(),
+        Err(ErrorCode::InvalidState)
+    ));
+    assert_eq!(sock.is_listening(), false);
+    assert_eq!(sock.address_family(), family);
+
+    assert!(matches!(sock.set_listen_backlog_size(32), Ok(_)));
+    assert!(matches!(sock.keep_alive_enabled(), Ok(_)));
+    assert!(matches!(sock.set_keep_alive_enabled(false), Ok(_)));
+    assert!(matches!(sock.keep_alive_idle_time(), Ok(_)));
+    assert!(matches!(sock.set_keep_alive_idle_time(1), Ok(_)));
+    assert!(matches!(sock.keep_alive_interval(), Ok(_)));
+    assert!(matches!(sock.set_keep_alive_interval(1), Ok(_)));
+    assert!(matches!(sock.keep_alive_count(), Ok(_)));
+    assert!(matches!(sock.set_keep_alive_count(1), Ok(_)));
+    assert!(matches!(sock.hop_limit(), Ok(_)));
+    assert!(matches!(sock.set_hop_limit(255), Ok(_)));
+    assert!(matches!(sock.receive_buffer_size(), Ok(_)));
+    assert!(matches!(sock.set_receive_buffer_size(16000), Ok(_)));
+    assert!(matches!(sock.send_buffer_size(), Ok(_)));
+    assert!(matches!(sock.set_send_buffer_size(16000), Ok(_)));
+}
+
+fn test_tcp_listening_state_invariants(net: &Network, family: IpAddressFamily) {
+    let bind_address = IpSocketAddress::new(IpAddress::new_loopback(family), 0);
+    let sock = TcpSocket::new(family).unwrap();
+    sock.blocking_bind(net, bind_address).unwrap();
+    sock.blocking_listen().unwrap();
+
+    assert!(matches!(
+        sock.start_bind(net, bind_address),
+        Err(ErrorCode::InvalidState)
+    ));
+    assert!(matches!(sock.finish_bind(), Err(ErrorCode::NotInProgress)));
+    assert!(matches!(
+        sock.start_connect(net, bind_address), // Actual address shouldn't matter
+        Err(ErrorCode::InvalidState)
+    ));
+    assert!(matches!(
+        sock.finish_connect(),
+        Err(ErrorCode::NotInProgress)
+    ));
+    assert!(matches!(sock.start_listen(), Err(ErrorCode::InvalidState)));
+    assert!(matches!(
+        sock.finish_listen(),
+        Err(ErrorCode::NotInProgress)
+    ));
+    // Skipping: tcp::accept
+    assert!(matches!(
+        sock.shutdown(ShutdownType::Both),
+        Err(ErrorCode::InvalidState)
+    ));
+
+    assert!(matches!(sock.local_address(), Ok(_)));
+    assert!(matches!(
+        sock.remote_address(),
+        Err(ErrorCode::InvalidState)
+    ));
+    assert_eq!(sock.is_listening(), true);
+    assert_eq!(sock.address_family(), family);
+
+    assert!(matches!(
+        sock.set_listen_backlog_size(32),
+        Ok(_) | Err(ErrorCode::NotSupported)
+    ));
+    assert!(matches!(sock.keep_alive_enabled(), Ok(_)));
+    assert!(matches!(sock.set_keep_alive_enabled(false), Ok(_)));
+    assert!(matches!(sock.keep_alive_idle_time(), Ok(_)));
+    assert!(matches!(sock.set_keep_alive_idle_time(1), Ok(_)));
+    assert!(matches!(sock.keep_alive_interval(), Ok(_)));
+    assert!(matches!(sock.set_keep_alive_interval(1), Ok(_)));
+    assert!(matches!(sock.keep_alive_count(), Ok(_)));
+    assert!(matches!(sock.set_keep_alive_count(1), Ok(_)));
+    assert!(matches!(sock.hop_limit(), Ok(_)));
+    assert!(matches!(sock.set_hop_limit(255), Ok(_)));
+    assert!(matches!(sock.receive_buffer_size(), Ok(_)));
+    assert!(matches!(sock.set_receive_buffer_size(16000), Ok(_)));
+    assert!(matches!(sock.send_buffer_size(), Ok(_)));
+    assert!(matches!(sock.set_send_buffer_size(16000), Ok(_)));
+}
+
+fn test_tcp_connected_state_invariants(net: &Network, family: IpAddressFamily) {
+    let bind_address = IpSocketAddress::new(IpAddress::new_loopback(family), 0);
+    let sock_listener = TcpSocket::new(family).unwrap();
+    sock_listener.blocking_bind(net, bind_address).unwrap();
+    sock_listener.blocking_listen().unwrap();
+    let addr_listener = sock_listener.local_address().unwrap();
+    let sock = TcpSocket::new(family).unwrap();
+    let (_input, _output) = sock.blocking_connect(net, addr_listener).unwrap();
+
+    assert!(matches!(
+        sock.start_bind(net, bind_address),
+        Err(ErrorCode::InvalidState)
+    ));
+    assert!(matches!(sock.finish_bind(), Err(ErrorCode::NotInProgress)));
+    assert!(matches!(
+        sock.start_connect(net, addr_listener),
+        Err(ErrorCode::InvalidState)
+    ));
+    assert!(matches!(
+        sock.finish_connect(),
+        Err(ErrorCode::NotInProgress)
+    ));
+    assert!(matches!(sock.start_listen(), Err(ErrorCode::InvalidState)));
+    assert!(matches!(
+        sock.finish_listen(),
+        Err(ErrorCode::NotInProgress)
+    ));
+    assert!(matches!(sock.accept(), Err(ErrorCode::InvalidState)));
+    // Skipping: tcp::shutdown
+
+    assert!(matches!(sock.local_address(), Ok(_)));
+    assert!(matches!(sock.remote_address(), Ok(_)));
+    assert_eq!(sock.is_listening(), false);
+    assert_eq!(sock.address_family(), family);
+
+    assert!(matches!(sock.keep_alive_enabled(), Ok(_)));
+    assert!(matches!(sock.set_keep_alive_enabled(false), Ok(_)));
+    assert!(matches!(sock.keep_alive_idle_time(), Ok(_)));
+    assert!(matches!(sock.set_keep_alive_idle_time(1), Ok(_)));
+    assert!(matches!(sock.keep_alive_interval(), Ok(_)));
+    assert!(matches!(sock.set_keep_alive_interval(1), Ok(_)));
+    assert!(matches!(sock.keep_alive_count(), Ok(_)));
+    assert!(matches!(sock.set_keep_alive_count(1), Ok(_)));
+    assert!(matches!(sock.hop_limit(), Ok(_)));
+    assert!(matches!(sock.set_hop_limit(255), Ok(_)));
+    assert!(matches!(sock.receive_buffer_size(), Ok(_)));
+    assert!(matches!(sock.set_receive_buffer_size(16000), Ok(_)));
+    assert!(matches!(sock.send_buffer_size(), Ok(_)));
+    assert!(matches!(sock.set_send_buffer_size(16000), Ok(_)));
+}
+
+fn main() {
+    let net = Network::default();
+
+    test_tcp_unbound_state_invariants(IpAddressFamily::Ipv4);
+    test_tcp_unbound_state_invariants(IpAddressFamily::Ipv6);
+
+    test_tcp_bound_state_invariants(&net, IpAddressFamily::Ipv4);
+    test_tcp_bound_state_invariants(&net, IpAddressFamily::Ipv6);
+
+    test_tcp_listening_state_invariants(&net, IpAddressFamily::Ipv4);
+    test_tcp_listening_state_invariants(&net, IpAddressFamily::Ipv6);
+
+    test_tcp_connected_state_invariants(&net, IpAddressFamily::Ipv4);
+    test_tcp_connected_state_invariants(&net, IpAddressFamily::Ipv6);
+}
diff --git a/crates/test-programs/src/bin/preview2_tcp_streams.rs b/crates/test-programs/src/bin/preview2_tcp_streams.rs
new file mode 100644
index 000000000000..688827be661e
--- /dev/null
+++ b/crates/test-programs/src/bin/preview2_tcp_streams.rs
@@ -0,0 +1,96 @@
+use test_programs::wasi::io::streams::{InputStream, OutputStream, StreamError};
+use test_programs::wasi::sockets::network::{IpAddress, IpAddressFamily, IpSocketAddress, Network};
+use test_programs::wasi::sockets::tcp::{ShutdownType, TcpSocket};
+
+/// InputStream::read should return `StreamError::Closed` after the connection has been shut down by the server.
+fn test_tcp_input_stream_should_be_closed_by_remote_shutdown(
+    net: &Network,
+    family: IpAddressFamily,
+) {
+    setup(net, family, |server, client| {
+        // Shut down the connection from the server side:
+        server.socket.shutdown(ShutdownType::Both).unwrap();
+        drop(server);
+
+        // Wait for the shutdown signal to reach the client:
+        client.input.subscribe().block();
+
+        // The input stream should immediately signal StreamError::Closed.
+        // Notably, it should _not_ return an empty list (the wasi-io equivalent of EWOULDBLOCK)
+        // See: https://github.com/bytecodealliance/wasmtime/pull/8968
+        assert!(matches!(client.input.read(10), Err(StreamError::Closed)));
+
+        // Stream should still be closed, even when requesting 0 bytes:
+        assert!(matches!(client.input.read(0), Err(StreamError::Closed)));
+    });
+}
+
+/// OutputStream should return `StreamError::Closed` after the connection has been locally shut down for sending.
+fn test_tcp_output_stream_should_be_closed_by_local_shutdown(
+    net: &Network,
+    family: IpAddressFamily,
+) {
+    setup(net, family, |_server, client| {
+        let message = b"Hi!";
+
+        // The stream should be writable:
+        assert!(client.output.check_write().unwrap() as usize >= message.len());
+
+        // Perform the shutdown
+        client.socket.shutdown(ShutdownType::Send).unwrap();
+
+        // Stream should be closed:
+        assert!(matches!(
+            client.output.write(message),
+            Err(StreamError::Closed)
+        ));
+
+        // The stream should remain closed:
+        assert!(matches!(
+            client.output.check_write(),
+            Err(StreamError::Closed)
+        ));
+        assert!(matches!(client.output.flush(), Err(StreamError::Closed)));
+    });
+}
+
+fn main() {
+    let net = Network::default();
+
+    test_tcp_input_stream_should_be_closed_by_remote_shutdown(&net, IpAddressFamily::Ipv4);
+    test_tcp_input_stream_should_be_closed_by_remote_shutdown(&net, IpAddressFamily::Ipv6);
+
+    test_tcp_output_stream_should_be_closed_by_local_shutdown(&net, IpAddressFamily::Ipv4);
+    test_tcp_output_stream_should_be_closed_by_local_shutdown(&net, IpAddressFamily::Ipv6);
+}
+
+struct Connection {
+    input: InputStream,
+    output: OutputStream,
+    socket: TcpSocket,
+}
+
+/// Set up a connected pair of sockets
+fn setup(net: &Network, family: IpAddressFamily, body: impl FnOnce(Connection, Connection)) {
+    let bind_address = IpSocketAddress::new(IpAddress::new_loopback(family), 0);
+    let listener = TcpSocket::new(family).unwrap();
+    listener.blocking_bind(&net, bind_address).unwrap();
+    listener.blocking_listen().unwrap();
+    let bound_address = listener.local_address().unwrap();
+    let client_socket = TcpSocket::new(family).unwrap();
+    let (client_input, client_output) = client_socket.blocking_connect(net, bound_address).unwrap();
+    let (accepted_socket, accepted_input, accepted_output) = listener.blocking_accept().unwrap();
+
+    body(
+        Connection {
+            input: accepted_input,
+            output: accepted_output,
+            socket: accepted_socket,
+        },
+        Connection {
+            input: client_input,
+            output: client_output,
+            socket: client_socket,
+        },
+    );
+}
diff --git a/crates/test-programs/src/bin/preview2_udp_bind.rs b/crates/test-programs/src/bin/preview2_udp_bind.rs
new file mode 100644
index 000000000000..8b366bcf9e3e
--- /dev/null
+++ b/crates/test-programs/src/bin/preview2_udp_bind.rs
@@ -0,0 +1,113 @@
+use test_programs::sockets::attempt_random_port;
+use test_programs::wasi::sockets::network::{
+    ErrorCode, IpAddress, IpAddressFamily, IpSocketAddress, Network,
+};
+use test_programs::wasi::sockets::udp::UdpSocket;
+
+/// Bind a socket and let the system determine a port.
+fn test_udp_bind_ephemeral_port(net: &Network, ip: IpAddress) {
+    let bind_addr = IpSocketAddress::new(ip, 0);
+
+    let sock = UdpSocket::new(ip.family()).unwrap();
+    sock.blocking_bind(net, bind_addr).unwrap();
+
+    let bound_addr = sock.local_address().unwrap();
+
+    assert_eq!(bind_addr.ip(), bound_addr.ip());
+    assert_ne!(bind_addr.port(), bound_addr.port());
+}
+
+/// Bind a socket on a specified port.
+fn test_udp_bind_specific_port(net: &Network, ip: IpAddress) {
+    let sock = UdpSocket::new(ip.family()).unwrap();
+
+    let bind_addr =
+        attempt_random_port(ip, |bind_addr| sock.blocking_bind(net, bind_addr)).unwrap();
+
+    let bound_addr = sock.local_address().unwrap();
+
+    assert_eq!(bind_addr.ip(), bound_addr.ip());
+    assert_eq!(bind_addr.port(), bound_addr.port());
+}
+
+/// Two sockets may not be actively bound to the same address at the same time.
+fn test_udp_bind_addrinuse(net: &Network, ip: IpAddress) {
+    let bind_addr = IpSocketAddress::new(ip, 0);
+
+    let sock1 = UdpSocket::new(ip.family()).unwrap();
+    sock1.blocking_bind(net, bind_addr).unwrap();
+
+    let bound_addr = sock1.local_address().unwrap();
+
+    let sock2 = UdpSocket::new(ip.family()).unwrap();
+    assert!(matches!(
+        sock2.blocking_bind(net, bound_addr),
+        Err(ErrorCode::AddressInUse)
+    ));
+}
+
+// Try binding to an address that is not configured on the system.
+fn test_udp_bind_addrnotavail(net: &Network, ip: IpAddress) {
+    let bind_addr = IpSocketAddress::new(ip, 0);
+
+    let sock = UdpSocket::new(ip.family()).unwrap();
+
+    assert!(matches!(
+        sock.blocking_bind(net, bind_addr),
+        Err(ErrorCode::AddressNotBindable)
+    ));
+}
+
+/// Bind should validate the address family.
+fn test_udp_bind_wrong_family(net: &Network, family: IpAddressFamily) {
+    let wrong_ip = match family {
+        IpAddressFamily::Ipv4 => IpAddress::IPV6_LOOPBACK,
+        IpAddressFamily::Ipv6 => IpAddress::IPV4_LOOPBACK,
+    };
+
+    let sock = UdpSocket::new(family).unwrap();
+    let result = sock.blocking_bind(net, IpSocketAddress::new(wrong_ip, 0));
+
+    assert!(matches!(result, Err(ErrorCode::InvalidArgument)));
+}
+
+fn test_udp_bind_dual_stack(net: &Network) {
+    let sock = UdpSocket::new(IpAddressFamily::Ipv6).unwrap();
+    let addr = IpSocketAddress::new(IpAddress::IPV4_MAPPED_LOOPBACK, 0);
+
+    // Binding an IPv4-mapped-IPv6 address on a ipv6-only socket should fail:
+    assert!(matches!(
+        sock.blocking_bind(net, addr),
+        Err(ErrorCode::InvalidArgument)
+    ));
+}
+
+fn main() {
+    const RESERVED_IPV4_ADDRESS: IpAddress = IpAddress::Ipv4((192, 0, 2, 0)); // Reserved for documentation and examples.
+    const RESERVED_IPV6_ADDRESS: IpAddress = IpAddress::Ipv6((0x2001, 0x0db8, 0, 0, 0, 0, 0, 0)); // Reserved for documentation and examples.
+
+    let net = Network::default();
+
+    test_udp_bind_ephemeral_port(&net, IpAddress::IPV4_LOOPBACK);
+    test_udp_bind_ephemeral_port(&net, IpAddress::IPV6_LOOPBACK);
+    test_udp_bind_ephemeral_port(&net, IpAddress::IPV4_UNSPECIFIED);
+    test_udp_bind_ephemeral_port(&net, IpAddress::IPV6_UNSPECIFIED);
+
+    test_udp_bind_specific_port(&net, IpAddress::IPV4_LOOPBACK);
+    test_udp_bind_specific_port(&net, IpAddress::IPV6_LOOPBACK);
+    test_udp_bind_specific_port(&net, IpAddress::IPV4_UNSPECIFIED);
+    test_udp_bind_specific_port(&net, IpAddress::IPV6_UNSPECIFIED);
+
+    test_udp_bind_addrinuse(&net, IpAddress::IPV4_LOOPBACK);
+    test_udp_bind_addrinuse(&net, IpAddress::IPV6_LOOPBACK);
+    test_udp_bind_addrinuse(&net, IpAddress::IPV4_UNSPECIFIED);
+    test_udp_bind_addrinuse(&net, IpAddress::IPV6_UNSPECIFIED);
+
+    test_udp_bind_addrnotavail(&net, RESERVED_IPV4_ADDRESS);
+    test_udp_bind_addrnotavail(&net, RESERVED_IPV6_ADDRESS);
+
+    test_udp_bind_wrong_family(&net, IpAddressFamily::Ipv4);
+    test_udp_bind_wrong_family(&net, IpAddressFamily::Ipv6);
+
+    test_udp_bind_dual_stack(&net);
+}
diff --git a/crates/test-programs/src/bin/preview2_udp_connect.rs b/crates/test-programs/src/bin/preview2_udp_connect.rs
new file mode 100644
index 000000000000..7ce1ad56f689
--- /dev/null
+++ b/crates/test-programs/src/bin/preview2_udp_connect.rs
@@ -0,0 +1,124 @@
+use test_programs::wasi::sockets::network::{
+    ErrorCode, IpAddress, IpAddressFamily, IpSocketAddress, Network,
+};
+use test_programs::wasi::sockets::udp::UdpSocket;
+
+const SOME_PORT: u16 = 47; // If the tests pass, this will never actually be connected to.
+
+fn test_udp_connect_disconnect_reconnect(net: &Network, family: IpAddressFamily) {
+    let unspecified_addr = IpSocketAddress::new(IpAddress::new_unspecified(family), 0);
+    let remote1 = IpSocketAddress::new(IpAddress::new_loopback(family), 4321);
+    let remote2 = IpSocketAddress::new(IpAddress::new_loopback(family), 4320);
+
+    let client = UdpSocket::new(family).unwrap();
+    client.blocking_bind(&net, unspecified_addr).unwrap();
+
+    _ = client.stream(None).unwrap();
+    assert_eq!(client.remote_address(), Err(ErrorCode::InvalidState));
+
+    _ = client.stream(None).unwrap();
+    assert_eq!(client.remote_address(), Err(ErrorCode::InvalidState));
+
+    _ = client.stream(Some(remote1)).unwrap();
+    assert_eq!(client.remote_address(), Ok(remote1));
+
+    _ = client.stream(Some(remote1)).unwrap();
+    assert_eq!(client.remote_address(), Ok(remote1));
+
+    _ = client.stream(Some(remote2)).unwrap();
+    assert_eq!(client.remote_address(), Ok(remote2));
+
+    _ = client.stream(None).unwrap();
+    assert_eq!(client.remote_address(), Err(ErrorCode::InvalidState));
+
+    _ = client.stream(Some(remote1)).unwrap();
+    assert_eq!(client.remote_address(), Ok(remote1));
+}
+
+/// `0.0.0.0` / `::` is not a valid remote address in WASI.
+fn test_udp_connect_unspec(net: &Network, family: IpAddressFamily) {
+    let addr = IpSocketAddress::new(IpAddress::new_unspecified(family), SOME_PORT);
+    let sock = UdpSocket::new(family).unwrap();
+    sock.blocking_bind_unspecified(&net).unwrap();
+
+    assert!(matches!(
+        sock.stream(Some(addr)),
+        Err(ErrorCode::InvalidArgument)
+    ));
+}
+
+/// 0 is not a valid remote port.
+fn test_udp_connect_port_0(net: &Network, family: IpAddressFamily) {
+    let addr = IpSocketAddress::new(IpAddress::new_loopback(family), 0);
+    let sock = UdpSocket::new(family).unwrap();
+    sock.blocking_bind_unspecified(&net).unwrap();
+
+    assert!(matches!(
+        sock.stream(Some(addr)),
+        Err(ErrorCode::InvalidArgument)
+    ));
+}
+
+/// Connect should validate the address family.
+fn test_udp_connect_wrong_family(net: &Network, family: IpAddressFamily) {
+    let wrong_ip = match family {
+        IpAddressFamily::Ipv4 => IpAddress::IPV6_LOOPBACK,
+        IpAddressFamily::Ipv6 => IpAddress::IPV4_LOOPBACK,
+    };
+    let remote_addr = IpSocketAddress::new(wrong_ip, SOME_PORT);
+
+    let sock = UdpSocket::new(family).unwrap();
+    sock.blocking_bind_unspecified(&net).unwrap();
+
+    assert!(matches!(
+        sock.stream(Some(remote_addr)),
+        Err(ErrorCode::InvalidArgument)
+    ));
+}
+
+fn test_udp_connect_dual_stack(net: &Network) {
+    // Set-up:
+    let v4_server = UdpSocket::new(IpAddressFamily::Ipv4).unwrap();
+    v4_server
+        .blocking_bind(&net, IpSocketAddress::new(IpAddress::IPV4_LOOPBACK, 0))
+        .unwrap();
+
+    let v4_server_addr = v4_server.local_address().unwrap();
+    let v6_server_addr =
+        IpSocketAddress::new(IpAddress::IPV4_MAPPED_LOOPBACK, v4_server_addr.port());
+
+    // Tests:
+    let v6_client = UdpSocket::new(IpAddressFamily::Ipv6).unwrap();
+
+    v6_client.blocking_bind_unspecified(&net).unwrap();
+
+    // Connecting to an IPv4 address on an IPv6 socket should fail:
+    assert!(matches!(
+        v6_client.stream(Some(v4_server_addr)),
+        Err(ErrorCode::InvalidArgument)
+    ));
+
+    // Connecting to an IPv4-mapped-IPv6 address on an IPv6 socket should fail:
+    assert!(matches!(
+        v6_client.stream(Some(v6_server_addr)),
+        Err(ErrorCode::InvalidArgument)
+    ));
+}
+
+fn main() {
+    let net = Network::default();
+
+    test_udp_connect_disconnect_reconnect(&net, IpAddressFamily::Ipv4);
+    test_udp_connect_disconnect_reconnect(&net, IpAddressFamily::Ipv6);
+
+    test_udp_connect_unspec(&net, IpAddressFamily::Ipv4);
+    test_udp_connect_unspec(&net, IpAddressFamily::Ipv6);
+
+    test_udp_connect_port_0(&net, IpAddressFamily::Ipv4);
+    test_udp_connect_port_0(&net, IpAddressFamily::Ipv6);
+
+    test_udp_connect_wrong_family(&net, IpAddressFamily::Ipv4);
+    test_udp_connect_wrong_family(&net, IpAddressFamily::Ipv6);
+
+    test_udp_connect_dual_stack(&net);
+}
diff --git a/crates/test-programs/src/bin/preview2_udp_sample_application.rs b/crates/test-programs/src/bin/preview2_udp_sample_application.rs
new file mode 100644
index 000000000000..ca001769f69c
--- /dev/null
+++ b/crates/test-programs/src/bin/preview2_udp_sample_application.rs
@@ -0,0 +1,92 @@
+use test_programs::wasi::sockets::network::{
+    IpAddress, IpAddressFamily, IpSocketAddress, Ipv4SocketAddress, Ipv6SocketAddress, Network,
+};
+use test_programs::wasi::sockets::udp::{OutgoingDatagram, UdpSocket};
+
+fn test_udp_sample_application(family: IpAddressFamily, bind_address: IpSocketAddress) {
+    let unspecified_addr = IpSocketAddress::new(IpAddress::new_unspecified(family), 0);
+
+    let first_message = &[];
+    let second_message = b"Hello, world!";
+    let third_message = b"Greetings, planet!";
+
+    let net = Network::default();
+
+    let server = UdpSocket::new(family).unwrap();
+
+    server.blocking_bind(&net, bind_address).unwrap();
+    let (server_incoming, _) = server.stream(None).unwrap();
+    let addr = server.local_address().unwrap();
+
+    let client_addr = {
+        let client = UdpSocket::new(family).unwrap();
+        client.blocking_bind(&net, unspecified_addr).unwrap();
+        let (_, client_outgoing) = client.stream(Some(addr)).unwrap();
+
+        let datagrams = [
+            OutgoingDatagram {
+                data: first_message.to_vec(),
+                remote_address: None,
+            },
+            OutgoingDatagram {
+                data: second_message.to_vec(),
+                remote_address: Some(addr),
+            },
+        ];
+        client_outgoing.blocking_send(&datagrams).unwrap();
+
+        client.local_address().unwrap()
+    };
+
+    {
+        // Check that we've received our sent messages.
+        let datagrams = server_incoming.blocking_receive(2..100).unwrap();
+        assert_eq!(datagrams.len(), 2);
+
+        assert_eq!(datagrams[0].data, first_message);
+        assert_eq!(datagrams[0].remote_address, client_addr);
+
+        assert_eq!(datagrams[1].data, second_message);
+        assert_eq!(datagrams[1].remote_address, client_addr);
+    }
+
+    // Another client
+    {
+        let client = UdpSocket::new(family).unwrap();
+        client.blocking_bind(&net, unspecified_addr).unwrap();
+        let (_, client_outgoing) = client.stream(None).unwrap();
+
+        let datagrams = [OutgoingDatagram {
+            data: third_message.to_vec(),
+            remote_address: Some(addr),
+        }];
+        client_outgoing.blocking_send(&datagrams).unwrap();
+    }
+
+    {
+        // Check that we sent and received our message!
+        let datagrams = server_incoming.blocking_receive(1..100).unwrap();
+        assert_eq!(datagrams.len(), 1);
+
+        assert_eq!(datagrams[0].data, third_message);
+    }
+}
+
+fn main() {
+    test_udp_sample_application(
+        IpAddressFamily::Ipv4,
+        IpSocketAddress::Ipv4(Ipv4SocketAddress {
+            port: 0,                 // use any free port
+            address: (127, 0, 0, 1), // localhost
+        }),
+    );
+    test_udp_sample_application(
+        IpAddressFamily::Ipv6,
+        IpSocketAddress::Ipv6(Ipv6SocketAddress {
+            port: 0,                           // use any free port
+            address: (0, 0, 0, 0, 0, 0, 0, 1), // localhost
+            flow_info: 0,
+            scope_id: 0,
+        }),
+    );
+}
diff --git a/crates/test-programs/src/bin/preview2_udp_sockopts.rs b/crates/test-programs/src/bin/preview2_udp_sockopts.rs
new file mode 100644
index 000000000000..893789b508b4
--- /dev/null
+++ b/crates/test-programs/src/bin/preview2_udp_sockopts.rs
@@ -0,0 +1,60 @@
+use test_programs::wasi::sockets::network::{ErrorCode, IpAddressFamily};
+use test_programs::wasi::sockets::udp::UdpSocket;
+
+fn test_udp_sockopt_defaults(family: IpAddressFamily) {
+    let sock = UdpSocket::new(family).unwrap();
+
+    assert_eq!(sock.address_family(), family);
+
+    assert!(sock.unicast_hop_limit().unwrap() > 0);
+    assert!(sock.receive_buffer_size().unwrap() > 0);
+    assert!(sock.send_buffer_size().unwrap() > 0);
+}
+
+fn test_udp_sockopt_input_ranges(family: IpAddressFamily) {
+    let sock = UdpSocket::new(family).unwrap();
+
+    assert!(matches!(
+        sock.set_unicast_hop_limit(0),
+        Err(ErrorCode::InvalidArgument)
+    ));
+    assert!(matches!(sock.set_unicast_hop_limit(1), Ok(_)));
+    assert!(matches!(sock.set_unicast_hop_limit(u8::MAX), Ok(_)));
+
+    assert!(matches!(
+        sock.set_receive_buffer_size(0),
+        Err(ErrorCode::InvalidArgument)
+    ));
+    assert!(matches!(sock.set_receive_buffer_size(1), Ok(_))); // Unsupported sizes should be silently capped.
+    assert!(matches!(sock.set_receive_buffer_size(u64::MAX), Ok(_))); // Unsupported sizes should be silently capped.
+    assert!(matches!(
+        sock.set_send_buffer_size(0),
+        Err(ErrorCode::InvalidArgument)
+    ));
+    assert!(matches!(sock.set_send_buffer_size(1), Ok(_))); // Unsupported sizes should be silently capped.
+    assert!(matches!(sock.set_send_buffer_size(u64::MAX), Ok(_))); // Unsupported sizes should be silently capped.
+}
+
+fn test_udp_sockopt_readback(family: IpAddressFamily) {
+    let sock = UdpSocket::new(family).unwrap();
+
+    sock.set_unicast_hop_limit(42).unwrap();
+    assert_eq!(sock.unicast_hop_limit().unwrap(), 42);
+
+    sock.set_receive_buffer_size(0x10000).unwrap();
+    assert_eq!(sock.receive_buffer_size().unwrap(), 0x10000);
+
+    sock.set_send_buffer_size(0x10000).unwrap();
+    assert_eq!(sock.send_buffer_size().unwrap(), 0x10000);
+}
+
+fn main() {
+    test_udp_sockopt_defaults(IpAddressFamily::Ipv4);
+    test_udp_sockopt_defaults(IpAddressFamily::Ipv6);
+
+    test_udp_sockopt_input_ranges(IpAddressFamily::Ipv4);
+    test_udp_sockopt_input_ranges(IpAddressFamily::Ipv6);
+
+    test_udp_sockopt_readback(IpAddressFamily::Ipv4);
+    test_udp_sockopt_readback(IpAddressFamily::Ipv6);
+}
diff --git a/crates/test-programs/src/bin/preview2_udp_states.rs b/crates/test-programs/src/bin/preview2_udp_states.rs
new file mode 100644
index 000000000000..314f94a25bd8
--- /dev/null
+++ b/crates/test-programs/src/bin/preview2_udp_states.rs
@@ -0,0 +1,93 @@
+use test_programs::wasi::sockets::network::{
+    ErrorCode, IpAddress, IpAddressFamily, IpSocketAddress, Network,
+};
+use test_programs::wasi::sockets::udp::UdpSocket;
+
+fn test_udp_unbound_state_invariants(family: IpAddressFamily) {
+    let sock = UdpSocket::new(family).unwrap();
+
+    // Skipping: udp::start_bind
+    assert!(matches!(sock.finish_bind(), Err(ErrorCode::NotInProgress)));
+
+    assert!(matches!(sock.stream(None), Err(ErrorCode::InvalidState)));
+
+    assert!(matches!(sock.local_address(), Err(ErrorCode::InvalidState)));
+    assert!(matches!(
+        sock.remote_address(),
+        Err(ErrorCode::InvalidState)
+    ));
+    assert_eq!(sock.address_family(), family);
+
+    assert!(matches!(sock.unicast_hop_limit(), Ok(_)));
+    assert!(matches!(sock.set_unicast_hop_limit(255), Ok(_)));
+    assert!(matches!(sock.receive_buffer_size(), Ok(_)));
+    assert!(matches!(sock.set_receive_buffer_size(16000), Ok(_)));
+    assert!(matches!(sock.send_buffer_size(), Ok(_)));
+    assert!(matches!(sock.set_send_buffer_size(16000), Ok(_)));
+}
+
+fn test_udp_bound_state_invariants(net: &Network, family: IpAddressFamily) {
+    let bind_address = IpSocketAddress::new(IpAddress::new_loopback(family), 0);
+    let sock = UdpSocket::new(family).unwrap();
+    sock.blocking_bind(net, bind_address).unwrap();
+
+    assert!(matches!(
+        sock.start_bind(net, bind_address),
+        Err(ErrorCode::InvalidState)
+    ));
+    assert!(matches!(sock.finish_bind(), Err(ErrorCode::NotInProgress)));
+    // Skipping: udp::stream
+
+    assert!(matches!(sock.local_address(), Ok(_)));
+    assert!(matches!(
+        sock.remote_address(),
+        Err(ErrorCode::InvalidState)
+    ));
+    assert_eq!(sock.address_family(), family);
+
+    assert!(matches!(sock.unicast_hop_limit(), Ok(_)));
+    assert!(matches!(sock.set_unicast_hop_limit(255), Ok(_)));
+    assert!(matches!(sock.receive_buffer_size(), Ok(_)));
+    assert!(matches!(sock.set_receive_buffer_size(16000), Ok(_)));
+    assert!(matches!(sock.send_buffer_size(), Ok(_)));
+    assert!(matches!(sock.set_send_buffer_size(16000), Ok(_)));
+}
+
+fn test_udp_connected_state_invariants(net: &Network, family: IpAddressFamily) {
+    let bind_address = IpSocketAddress::new(IpAddress::new_loopback(family), 0);
+    let connect_address = IpSocketAddress::new(IpAddress::new_loopback(family), 54321);
+    let sock = UdpSocket::new(family).unwrap();
+    sock.blocking_bind(net, bind_address).unwrap();
+    sock.stream(Some(connect_address)).unwrap();
+
+    assert!(matches!(
+        sock.start_bind(net, bind_address),
+        Err(ErrorCode::InvalidState)
+    ));
+    assert!(matches!(sock.finish_bind(), Err(ErrorCode::NotInProgress)));
+    // Skipping: udp::stream
+
+    assert!(matches!(sock.local_address(), Ok(_)));
+    assert!(matches!(sock.remote_address(), Ok(_)));
+    assert_eq!(sock.address_family(), family);
+
+    assert!(matches!(sock.unicast_hop_limit(), Ok(_)));
+    assert!(matches!(sock.set_unicast_hop_limit(255), Ok(_)));
+    assert!(matches!(sock.receive_buffer_size(), Ok(_)));
+    assert!(matches!(sock.set_receive_buffer_size(16000), Ok(_)));
+    assert!(matches!(sock.send_buffer_size(), Ok(_)));
+    assert!(matches!(sock.set_send_buffer_size(16000), Ok(_)));
+}
+
+fn main() {
+    let net = Network::default();
+
+    test_udp_unbound_state_invariants(IpAddressFamily::Ipv4);
+    test_udp_unbound_state_invariants(IpAddressFamily::Ipv6);
+
+    test_udp_bound_state_invariants(&net, IpAddressFamily::Ipv4);
+    test_udp_bound_state_invariants(&net, IpAddressFamily::Ipv6);
+
+    test_udp_connected_state_invariants(&net, IpAddressFamily::Ipv4);
+    test_udp_connected_state_invariants(&net, IpAddressFamily::Ipv6);
+}
diff --git a/crates/test-programs/src/bin/runtime_config_get.rs b/crates/test-programs/src/bin/runtime_config_get.rs
new file mode 100644
index 000000000000..e3013cdb2236
--- /dev/null
+++ b/crates/test-programs/src/bin/runtime_config_get.rs
@@ -0,0 +1,8 @@
+use test_programs::wasi::config::runtime;
+
+fn main() {
+    let v = runtime::get("hello").unwrap().unwrap();
+    assert_eq!(v, "world");
+    let config = runtime::get_all().unwrap();
+    assert_eq!(config, [("hello".to_string(), "world".to_string())])
+}
diff --git a/crates/test-programs/src/http.rs b/crates/test-programs/src/http.rs
new file mode 100644
index 000000000000..cde88cb621d6
--- /dev/null
+++ b/crates/test-programs/src/http.rs
@@ -0,0 +1,179 @@
+use crate::wasi::http::{outgoing_handler, types as http_types};
+use crate::wasi::io::streams;
+use anyhow::{anyhow, Result};
+use std::fmt;
+
+pub struct Response {
+    pub status: http_types::StatusCode,
+    pub headers: Vec<(String, Vec<u8>)>,
+    pub body: Vec<u8>,
+}
+impl fmt::Debug for Response {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut out = f.debug_struct("Response");
+        out.field("status", &self.status)
+            .field("headers", &self.headers);
+        if let Ok(body) = std::str::from_utf8(&self.body) {
+            out.field("body", &body);
+        } else {
+            out.field("body", &self.body);
+        }
+        out.finish()
+    }
+}
+
+impl Response {
+    pub fn header(&self, name: &str) -> Option<&Vec<u8>> {
+        self.headers
+            .iter()
+            .find_map(|(k, v)| if k == name { Some(v) } else { None })
+    }
+}
+
+pub fn request(
+    method: http_types::Method,
+    scheme: http_types::Scheme,
+    authority: &str,
+    path_with_query: &str,
+    body: Option<&[u8]>,
+    additional_headers: Option<&[(String, Vec<u8>)]>,
+    connect_timeout: Option<u64>,
+    first_by_timeout: Option<u64>,
+    between_bytes_timeout: Option<u64>,
+) -> Result<Response> {
+    fn header_val(v: &str) -> Vec<u8> {
+        v.to_string().into_bytes()
+    }
+    let headers = http_types::Headers::from_list(
+        &[
+            &[
+                ("User-agent".to_string(), header_val("WASI-HTTP/0.0.1")),
+                ("Content-type".to_string(), header_val("application/json")),
+            ],
+            additional_headers.unwrap_or(&[]),
+        ]
+        .concat(),
+    )?;
+
+    let request = http_types::OutgoingRequest::new(headers);
+
+    request
+        .set_method(&method)
+        .map_err(|()| anyhow!("failed to set method"))?;
+    request
+        .set_scheme(Some(&scheme))
+        .map_err(|()| anyhow!("failed to set scheme"))?;
+    request
+        .set_authority(Some(authority))
+        .map_err(|()| anyhow!("failed to set authority"))?;
+    request
+        .set_path_with_query(Some(&path_with_query))
+        .map_err(|()| anyhow!("failed to set path_with_query"))?;
+
+    let outgoing_body = request
+        .body()
+        .map_err(|_| anyhow!("outgoing request write failed"))?;
+
+    if let Some(mut buf) = body {
+        let request_body = outgoing_body
+            .write()
+            .map_err(|_| anyhow!("outgoing request write failed"))?;
+
+        let pollable = request_body.subscribe();
+        while !buf.is_empty() {
+            pollable.block();
+
+            let permit = match request_body.check_write() {
+                Ok(n) => n,
+                Err(_) => anyhow::bail!("output stream error"),
+            };
+
+            let len = buf.len().min(permit as usize);
+            let (chunk, rest) = buf.split_at(len);
+            buf = rest;
+
+            match request_body.write(chunk) {
+                Err(_) => anyhow::bail!("output stream error"),
+                _ => {}
+            }
+        }
+
+        match request_body.flush() {
+            Err(_) => anyhow::bail!("output stream error"),
+            _ => {}
+        }
+
+        pollable.block();
+
+        match request_body.check_write() {
+            Ok(_) => {}
+            Err(_) => anyhow::bail!("output stream error"),
+        };
+    }
+
+    let options = http_types::RequestOptions::new();
+    options
+        .set_connect_timeout(connect_timeout)
+        .map_err(|()| anyhow!("failed to set connect_timeout"))?;
+    options
+        .set_first_byte_timeout(first_by_timeout)
+        .map_err(|()| anyhow!("failed to set first_byte_timeout"))?;
+    options
+        .set_between_bytes_timeout(between_bytes_timeout)
+        .map_err(|()| anyhow!("failed to set between_bytes_timeout"))?;
+    let options = Some(options);
+
+    let future_response = outgoing_handler::handle(request, options)?;
+
+    http_types::OutgoingBody::finish(outgoing_body, None)?;
+
+    let incoming_response = match future_response.get() {
+        Some(result) => result.map_err(|()| anyhow!("response already taken"))?,
+        None => {
+            let pollable = future_response.subscribe();
+            pollable.block();
+            future_response
+                .get()
+                .expect("incoming response available")
+                .map_err(|()| anyhow!("response already taken"))?
+        }
+    }?;
+
+    drop(future_response);
+
+    let status = incoming_response.status();
+
+    let headers_handle = incoming_response.headers();
+    let headers = headers_handle.entries();
+    drop(headers_handle);
+
+    let incoming_body = incoming_response
+        .consume()
+        .map_err(|()| anyhow!("incoming response has no body stream"))?;
+
+    drop(incoming_response);
+
+    let input_stream = incoming_body.stream().unwrap();
+    let input_stream_pollable = input_stream.subscribe();
+
+    let mut body = Vec::new();
+    loop {
+        input_stream_pollable.block();
+
+        let mut body_chunk = match input_stream.read(1024 * 1024) {
+            Ok(c) => c,
+            Err(streams::StreamError::Closed) => break,
+            Err(e) => Err(anyhow!("input_stream read failed: {e:?}"))?,
+        };
+
+        if !body_chunk.is_empty() {
+            body.append(&mut body_chunk);
+        }
+    }
+
+    Ok(Response {
+        status,
+        headers,
+        body,
+    })
+}
diff --git a/crates/test-programs/src/lib.rs b/crates/test-programs/src/lib.rs
index f793242b3048..f7931273db84 100644
--- a/crates/test-programs/src/lib.rs
+++ b/crates/test-programs/src/lib.rs
@@ -1,47 +1,46 @@
-///! This crate exists to build crates for wasm32-wasi in build.rs, and execute
-///! these wasm programs in harnesses defined under tests/.
-use std::io::IsTerminal;
+pub mod http;
+pub mod nn;
+pub mod preview1;
+pub mod sockets;
 
-#[cfg(all(feature = "test_programs", not(skip_wasi_http_tests)))]
-pub mod http_server;
+wit_bindgen::generate!({
+    inline: "
+        package wasmtime:test;
 
-/// The wasi-tests binaries use these environment variables to determine their
-/// expected behavior.
-/// Used by all of the tests/ which execute the wasi-tests binaries.
-pub fn wasi_tests_environment() -> &'static [(&'static str, &'static str)] {
-    #[cfg(windows)]
-    {
-        &[
-            ("ERRNO_MODE_WINDOWS", "1"),
-            // Windows does not support dangling links or symlinks in the filesystem.
-            ("NO_DANGLING_FILESYSTEM", "1"),
-            // Windows does not support renaming a directory to an empty directory -
-            // empty directory must be deleted.
-            ("NO_RENAME_DIR_TO_EMPTY_DIR", "1"),
-            // cap-std-sync does not support the sync family of fdflags
-            ("NO_FDFLAGS_SYNC_SUPPORT", "1"),
-        ]
-    }
-    #[cfg(all(unix, not(target_os = "macos")))]
-    {
-        &[
-            ("ERRNO_MODE_UNIX", "1"),
-            // cap-std-sync does not support the sync family of fdflags
-            ("NO_FDFLAGS_SYNC_SUPPORT", "1"),
-        ]
-    }
-    #[cfg(target_os = "macos")]
-    {
-        &[
-            ("ERRNO_MODE_MACOS", "1"),
-            // cap-std-sync does not support the sync family of fdflags
-            ("NO_FDFLAGS_SYNC_SUPPORT", "1"),
-        ]
-    }
-}
+        world test {
+            include wasi:cli/imports@0.2.1;
+            include wasi:http/imports@0.2.1;
+            include wasi:config/imports@0.2.0-draft;
+            include wasi:keyvalue/imports@0.2.0-draft;
+        }
+    ",
+    path: [
+        "../wasi-http/wit",
+        "../wasi-runtime-config/wit",
+        "../wasi-keyvalue/wit",
+    ],
+    world: "wasmtime:test/test",
+    generate_all,
+});
 
-pub fn stdio_is_terminal() -> bool {
-    std::io::stdin().is_terminal()
-        && std::io::stdout().is_terminal()
-        && std::io::stderr().is_terminal()
+pub mod proxy {
+    wit_bindgen::generate!({
+        path: "../wasi-http/wit",
+        world: "wasi:http/proxy",
+        default_bindings_module: "test_programs::proxy",
+        pub_export_macro: true,
+        with: {
+            "wasi:http/types@0.2.1": crate::wasi::http::types,
+            "wasi:http/outgoing-handler@0.2.1": crate::wasi::http::outgoing_handler,
+            "wasi:random/random@0.2.1": crate::wasi::random::random,
+            "wasi:io/error@0.2.1": crate::wasi::io::error,
+            "wasi:io/poll@0.2.1": crate::wasi::io::poll,
+            "wasi:io/streams@0.2.1": crate::wasi::io::streams,
+            "wasi:cli/stdout@0.2.1": crate::wasi::cli::stdout,
+            "wasi:cli/stderr@0.2.1": crate::wasi::cli::stderr,
+            "wasi:cli/stdin@0.2.1": crate::wasi::cli::stdin,
+            "wasi:clocks/monotonic-clock@0.2.1": crate::wasi::clocks::monotonic_clock,
+            "wasi:clocks/wall-clock@0.2.1": crate::wasi::clocks::wall_clock,
+        },
+    });
 }
diff --git a/crates/test-programs/src/nn.rs b/crates/test-programs/src/nn.rs
new file mode 100644
index 000000000000..ebba36e1fde6
--- /dev/null
+++ b/crates/test-programs/src/nn.rs
@@ -0,0 +1,166 @@
+//! This module attempts to paper over the differences between the two
+//! implementations of wasi-nn: the legacy WITX-based version (`mod witx`) and
+//! the up-to-date WIT version (`mod wit`). Since the tests are mainly a simple
+//! classifier, this exposes a high-level `classify` function to go along with
+//! `load`, etc.
+//!
+//! This module exists solely for convenience--e.g., reduces test duplication.
+//! In the future can be safely disposed of or altered as more tests are added.
+
+/// Call `wasi-nn` functions from WebAssembly using the canonical ABI of the
+/// component model via WIT-based tooling. Used by `bin/nn_wit_*.rs` tests.
+pub mod wit {
+    use anyhow::{anyhow, Result};
+    use std::time::Instant;
+
+    // Generate the wasi-nn bindings based on the `*.wit` files.
+    wit_bindgen::generate!({
+        path: "../wasi-nn/wit",
+        world: "ml",
+        default_bindings_module: "test_programs::ml"
+    });
+    use self::wasi::nn::errors;
+    use self::wasi::nn::graph::{self, Graph};
+    pub use self::wasi::nn::graph::{ExecutionTarget, GraphEncoding}; // Used by tests.
+    use self::wasi::nn::tensor::{Tensor, TensorType};
+
+    /// Load a wasi-nn graph from a set of bytes.
+    pub fn load(
+        bytes: &[Vec<u8>],
+        encoding: GraphEncoding,
+        target: ExecutionTarget,
+    ) -> Result<Graph> {
+        graph::load(bytes, encoding, target).map_err(err_as_anyhow)
+    }
+
+    /// Load a wasi-nn graph by name.
+    pub fn load_by_name(name: &str) -> Result<Graph> {
+        graph::load_by_name(name).map_err(err_as_anyhow)
+    }
+
+    /// Run a wasi-nn inference using a simple classifier model (single input,
+    /// single output).
+    pub fn classify(graph: Graph, input: (&str, Vec<u8>), output: &str) -> Result<Vec<f32>> {
+        let context = graph.init_execution_context().map_err(err_as_anyhow)?;
+        println!("[nn] created wasi-nn execution context with ID: {context:?}");
+
+        // Many classifiers have a single input; currently, this test suite also
+        // uses tensors of the same shape, though this is not usually the case.
+        let tensor = Tensor::new(&vec![1, 3, 224, 224], TensorType::Fp32, &input.1);
+        context.set_input(input.0, tensor).map_err(err_as_anyhow)?;
+        println!("[nn] set input tensor: {} bytes", input.1.len());
+
+        let before = Instant::now();
+        context.compute().map_err(err_as_anyhow)?;
+        println!(
+            "[nn] executed graph inference in {} ms",
+            before.elapsed().as_millis()
+        );
+
+        // Many classifiers emit probabilities as floating point values; here we
+        // convert the raw bytes to `f32` knowing all models used here use that
+        // type.
+        let output = context.get_output(output).map_err(err_as_anyhow)?;
+        println!(
+            "[nn] retrieved output tensor: {} bytes",
+            output.data().len()
+        );
+        let output: Vec<f32> = output
+            .data()
+            .chunks(4)
+            .map(|b| f32::from_le_bytes([b[0], b[1], b[2], b[3]]))
+            .collect();
+        Ok(output)
+    }
+
+    fn err_as_anyhow(e: errors::Error) -> anyhow::Error {
+        anyhow!("error: {e:?}")
+    }
+}
+
+/// Call `wasi-nn` functions from WebAssembly using the legacy WITX-based
+/// tooling. This older API has been deprecated for the newer WIT-based API but
+/// retained for backwards compatibility testing--i.e., `bin/nn_witx_*.rs`
+/// tests.
+pub mod witx {
+    use anyhow::Result;
+    use std::time::Instant;
+    pub use wasi_nn::{ExecutionTarget, GraphEncoding};
+    use wasi_nn::{Graph, GraphBuilder, TensorType};
+
+    /// Load a wasi-nn graph from a set of bytes.
+    pub fn load(
+        bytes: &[&[u8]],
+        encoding: GraphEncoding,
+        target: ExecutionTarget,
+    ) -> Result<Graph> {
+        Ok(GraphBuilder::new(encoding, target).build_from_bytes(bytes)?)
+    }
+
+    /// Load a wasi-nn graph by name.
+    pub fn load_by_name(
+        name: &str,
+        encoding: GraphEncoding,
+        target: ExecutionTarget,
+    ) -> Result<Graph> {
+        Ok(GraphBuilder::new(encoding, target).build_from_cache(name)?)
+    }
+
+    /// Run a wasi-nn inference using a simple classifier model (single input,
+    /// single output).
+    pub fn classify(graph: Graph, tensor: Vec<u8>) -> Result<Vec<f32>> {
+        let mut context = graph.init_execution_context()?;
+        println!("[nn] created wasi-nn execution context with ID: {context}");
+
+        // Many classifiers have a single input; currently, this test suite also
+        // uses tensors of the same shape, though this is not usually the case.
+        context.set_input(0, TensorType::F32, &[1, 3, 224, 224], &tensor)?;
+        println!("[nn] set input tensor: {} bytes", tensor.len());
+
+        let before = Instant::now();
+        context.compute()?;
+        println!(
+            "[nn] executed graph inference in {} ms",
+            before.elapsed().as_millis()
+        );
+
+        // Many classifiers emit probabilities as floating point values; here we
+        // convert the raw bytes to `f32` knowing all models used here use that
+        // type.
+        let mut output_buffer = vec![0u8; 1001 * std::mem::size_of::<f32>()];
+        let num_bytes = context.get_output(0, &mut output_buffer)?;
+        println!("[nn] retrieved output tensor: {num_bytes} bytes");
+        let output: Vec<f32> = output_buffer[..num_bytes]
+            .chunks(4)
+            .map(|b| f32::from_le_bytes([b[0], b[1], b[2], b[3]]))
+            .collect();
+        Ok(output)
+    }
+}
+
+/// Sort some classification probabilities.
+///
+/// Many classification models output a buffer of probabilities for each class,
+/// placing the match probability for each class at the index for that class
+/// (the probability of class `N` is stored at `probabilities[N]`).
+pub fn sort_results(probabilities: &[f32]) -> Vec<InferenceResult> {
+    let mut results: Vec<InferenceResult> = probabilities
+        .iter()
+        .enumerate()
+        .map(|(c, p)| InferenceResult(c, *p))
+        .collect();
+    results.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
+    results
+}
+
+// A wrapper for class ID and match probabilities.
+#[derive(Debug, PartialEq)]
+pub struct InferenceResult(usize, f32);
+impl InferenceResult {
+    pub fn class_id(&self) -> usize {
+        self.0
+    }
+    pub fn probability(&self) -> f32 {
+        self.1
+    }
+}
diff --git a/crates/test-programs/src/preview1.rs b/crates/test-programs/src/preview1.rs
new file mode 100644
index 000000000000..bc327391edb3
--- /dev/null
+++ b/crates/test-programs/src/preview1.rs
@@ -0,0 +1,190 @@
+use std::{sync::OnceLock, time::Duration};
+
+pub fn config() -> &'static TestConfig {
+    static TESTCONFIG: OnceLock<TestConfig> = OnceLock::new();
+    TESTCONFIG.get_or_init(TestConfig::from_env)
+}
+
+// The `wasi` crate version 0.9.0 and beyond, doesn't
+// seem to define these constants, so we do it ourselves.
+pub const STDIN_FD: wasi::Fd = 0x0;
+pub const STDOUT_FD: wasi::Fd = 0x1;
+pub const STDERR_FD: wasi::Fd = 0x2;
+
+/// Opens a fresh file descriptor for `path` where `path` should be a preopened
+/// directory.
+pub fn open_scratch_directory(path: &str) -> Result<wasi::Fd, String> {
+    unsafe {
+        for i in 3.. {
+            let stat = match wasi::fd_prestat_get(i) {
+                Ok(s) => s,
+                Err(_) => break,
+            };
+            if stat.tag != wasi::PREOPENTYPE_DIR.raw() {
+                continue;
+            }
+            let mut dst = Vec::with_capacity(stat.u.dir.pr_name_len);
+            if wasi::fd_prestat_dir_name(i, dst.as_mut_ptr(), dst.capacity()).is_err() {
+                continue;
+            }
+            dst.set_len(stat.u.dir.pr_name_len);
+            if dst == path.as_bytes() {
+                return Ok(wasi::path_open(i, 0, ".", wasi::OFLAGS_DIRECTORY, 0, 0, 0)
+                    .expect("failed to open dir"));
+            }
+        }
+
+        Err(format!("failed to find scratch dir"))
+    }
+}
+
+pub unsafe fn create_file(dir_fd: wasi::Fd, filename: &str) {
+    let file_fd =
+        wasi::path_open(dir_fd, 0, filename, wasi::OFLAGS_CREAT, 0, 0, 0).expect("creating a file");
+    assert!(file_fd > STDERR_FD, "file descriptor range check",);
+    wasi::fd_close(file_fd).expect("closing a file");
+}
+
+// Small workaround to get the crate's macros, through the
+// `#[macro_export]` attribute below, also available from this module.
+pub use crate::{assert_errno, assert_fs_time_eq};
+
+#[macro_export]
+macro_rules! assert_errno {
+    ($s:expr, windows => $i:expr, $( $rest:tt )+) => {
+        let e = $s;
+        if $crate::preview1::config().errno_expect_windows() {
+            assert_errno!(e, $i);
+        } else {
+            assert_errno!(e, $($rest)+, $i);
+        }
+    };
+    ($s:expr, macos => $i:expr, $( $rest:tt )+) => {
+        let e = $s;
+        if $crate::preview1::config().errno_expect_macos() {
+            assert_errno!(e, $i);
+        } else {
+            assert_errno!(e, $($rest)+, $i);
+        }
+    };
+    ($s:expr, unix => $i:expr, $( $rest:tt )+) => {
+        let e = $s;
+        if $crate::preview1::config().errno_expect_unix() {
+            assert_errno!(e, $i);
+        } else {
+            assert_errno!(e, $($rest)+, $i);
+        }
+    };
+    ($s:expr, $( $i:expr ),+) => {
+        let e = $s;
+        {
+            // Pretty printing infrastructure
+            struct Alt<'a>(&'a [&'static str]);
+            impl<'a> std::fmt::Display for Alt<'a> {
+                fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+                    let l = self.0.len();
+                    if l == 0 {
+                        unreachable!()
+                    } else if l == 1 {
+                        f.write_str(self.0[0])
+                    } else if l == 2 {
+                        f.write_str(self.0[0])?;
+                        f.write_str(" or ")?;
+                        f.write_str(self.0[1])
+                    } else {
+                        for (ix, s) in self.0.iter().enumerate() {
+                            if ix == l - 1 {
+                                f.write_str("or ")?;
+                                f.write_str(s)?;
+                            } else {
+                                f.write_str(s)?;
+                                f.write_str(", ")?;
+                            }
+                        }
+                        Ok(())
+                    }
+                }
+            }
+            assert!( $( e == $i || )+ false,
+                "expected errno {}; got {}",
+                Alt(&[ $( $i.name() ),+ ]),
+                e.name()
+            )
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! assert_fs_time_eq {
+    ($l:expr, $r:expr, $n:literal) => {
+        let diff = if $l > $r { $l - $r } else { $r - $l };
+        assert!(diff < $crate::preview1::config().fs_time_precision(), $n);
+    };
+}
+
+pub struct TestConfig {
+    errno_mode: ErrnoMode,
+    fs_time_precision: u64,
+    no_dangling_filesystem: bool,
+    no_rename_dir_to_empty_dir: bool,
+}
+
+enum ErrnoMode {
+    Unix,
+    MacOS,
+    Windows,
+    Permissive,
+}
+
+impl TestConfig {
+    pub fn from_env() -> Self {
+        let errno_mode = if std::env::var("ERRNO_MODE_UNIX").is_ok() {
+            ErrnoMode::Unix
+        } else if std::env::var("ERRNO_MODE_MACOS").is_ok() {
+            ErrnoMode::MacOS
+        } else if std::env::var("ERRNO_MODE_WINDOWS").is_ok() {
+            ErrnoMode::Windows
+        } else {
+            ErrnoMode::Permissive
+        };
+        let fs_time_precision = match std::env::var("FS_TIME_PRECISION") {
+            Ok(p) => p.parse().unwrap(),
+            Err(_) => 100,
+        };
+        let no_dangling_filesystem = std::env::var("NO_DANGLING_FILESYSTEM").is_ok();
+        let no_rename_dir_to_empty_dir = std::env::var("NO_RENAME_DIR_TO_EMPTY_DIR").is_ok();
+        TestConfig {
+            errno_mode,
+            fs_time_precision,
+            no_dangling_filesystem,
+            no_rename_dir_to_empty_dir,
+        }
+    }
+    pub fn errno_expect_unix(&self) -> bool {
+        match self.errno_mode {
+            ErrnoMode::Unix | ErrnoMode::MacOS => true,
+            _ => false,
+        }
+    }
+    pub fn errno_expect_macos(&self) -> bool {
+        match self.errno_mode {
+            ErrnoMode::MacOS => true,
+            _ => false,
+        }
+    }
+    pub fn errno_expect_windows(&self) -> bool {
+        match self.errno_mode {
+            ErrnoMode::Windows => true,
+            _ => false,
+        }
+    }
+    pub fn fs_time_precision(&self) -> Duration {
+        Duration::from_nanos(self.fs_time_precision)
+    }
+    pub fn support_dangling_filesystem(&self) -> bool {
+        !self.no_dangling_filesystem
+    }
+    pub fn support_rename_dir_to_empty_dir(&self) -> bool {
+        !self.no_rename_dir_to_empty_dir
+    }
+}
diff --git a/crates/test-programs/src/sockets.rs b/crates/test-programs/src/sockets.rs
new file mode 100644
index 000000000000..c77ad8d7f819
--- /dev/null
+++ b/crates/test-programs/src/sockets.rs
@@ -0,0 +1,394 @@
+use crate::wasi::clocks::monotonic_clock;
+use crate::wasi::io::poll::{self, Pollable};
+use crate::wasi::io::streams::{InputStream, OutputStream, StreamError};
+use crate::wasi::random;
+use crate::wasi::sockets::instance_network;
+use crate::wasi::sockets::ip_name_lookup;
+use crate::wasi::sockets::network::{
+    ErrorCode, IpAddress, IpAddressFamily, IpSocketAddress, Ipv4SocketAddress, Ipv6SocketAddress,
+    Network,
+};
+use crate::wasi::sockets::tcp::TcpSocket;
+use crate::wasi::sockets::udp::{
+    IncomingDatagram, IncomingDatagramStream, OutgoingDatagram, OutgoingDatagramStream, UdpSocket,
+};
+use crate::wasi::sockets::{tcp_create_socket, udp_create_socket};
+use std::ops::Range;
+
+const TIMEOUT_NS: u64 = 1_000_000_000;
+
+impl Pollable {
+    pub fn block_until(&self, timeout: &Pollable) -> Result<(), ErrorCode> {
+        let ready = poll::poll(&[self, timeout]);
+        assert!(ready.len() > 0);
+        match ready[0] {
+            0 => Ok(()),
+            1 => Err(ErrorCode::Timeout),
+            _ => unreachable!(),
+        }
+    }
+}
+
+impl OutputStream {
+    pub fn blocking_write_util(&self, mut bytes: &[u8]) -> Result<(), StreamError> {
+        let timeout = monotonic_clock::subscribe_duration(TIMEOUT_NS);
+        let pollable = self.subscribe();
+
+        while !bytes.is_empty() {
+            pollable.block_until(&timeout).expect("write timed out");
+
+            let permit = self.check_write()?;
+
+            let len = bytes.len().min(permit as usize);
+            let (chunk, rest) = bytes.split_at(len);
+
+            self.write(chunk)?;
+
+            self.blocking_flush()?;
+
+            bytes = rest;
+        }
+        Ok(())
+    }
+}
+
+impl Network {
+    pub fn default() -> Network {
+        instance_network::instance_network()
+    }
+
+    pub fn blocking_resolve_addresses(&self, name: &str) -> Result<Vec<IpAddress>, ErrorCode> {
+        let stream = ip_name_lookup::resolve_addresses(&self, name)?;
+
+        let timeout = monotonic_clock::subscribe_duration(TIMEOUT_NS);
+        let pollable = stream.subscribe();
+
+        let mut addresses = vec![];
+
+        loop {
+            match stream.resolve_next_address() {
+                Ok(Some(addr)) => {
+                    addresses.push(addr);
+                }
+                Ok(None) => match addresses[..] {
+                    [] => return Err(ErrorCode::NameUnresolvable),
+                    _ => return Ok(addresses),
+                },
+                Err(ErrorCode::WouldBlock) => {
+                    pollable.block_until(&timeout)?;
+                }
+                Err(err) => return Err(err),
+            }
+        }
+    }
+
+    /// Same as `Network::blocking_resolve_addresses` but ignores post validation errors
+    ///
+    /// The ignored error codes signal that the input passed validation
+    /// and a lookup was actually attempted, but failed. These are ignored to
+    /// make the CI tests less flaky.
+    pub fn permissive_blocking_resolve_addresses(
+        &self,
+        name: &str,
+    ) -> Result<Vec<IpAddress>, ErrorCode> {
+        match self.blocking_resolve_addresses(name) {
+            Err(ErrorCode::NameUnresolvable | ErrorCode::TemporaryResolverFailure) => Ok(vec![]),
+            r => r,
+        }
+    }
+}
+
+impl TcpSocket {
+    pub fn new(address_family: IpAddressFamily) -> Result<TcpSocket, ErrorCode> {
+        tcp_create_socket::create_tcp_socket(address_family)
+    }
+
+    pub fn blocking_bind(
+        &self,
+        network: &Network,
+        local_address: IpSocketAddress,
+    ) -> Result<(), ErrorCode> {
+        let timeout = monotonic_clock::subscribe_duration(TIMEOUT_NS);
+        let sub = self.subscribe();
+
+        self.start_bind(&network, local_address)?;
+
+        loop {
+            match self.finish_bind() {
+                Err(ErrorCode::WouldBlock) => sub.block_until(&timeout)?,
+                result => return result,
+            }
+        }
+    }
+
+    pub fn blocking_listen(&self) -> Result<(), ErrorCode> {
+        let timeout = monotonic_clock::subscribe_duration(TIMEOUT_NS);
+        let sub = self.subscribe();
+
+        self.start_listen()?;
+
+        loop {
+            match self.finish_listen() {
+                Err(ErrorCode::WouldBlock) => sub.block_until(&timeout)?,
+                result => return result,
+            }
+        }
+    }
+
+    pub fn blocking_connect(
+        &self,
+        network: &Network,
+        remote_address: IpSocketAddress,
+    ) -> Result<(InputStream, OutputStream), ErrorCode> {
+        let timeout = monotonic_clock::subscribe_duration(TIMEOUT_NS);
+        let sub = self.subscribe();
+
+        self.start_connect(&network, remote_address)?;
+
+        loop {
+            match self.finish_connect() {
+                Err(ErrorCode::WouldBlock) => sub.block_until(&timeout)?,
+                result => return result,
+            }
+        }
+    }
+
+    pub fn blocking_accept(&self) -> Result<(TcpSocket, InputStream, OutputStream), ErrorCode> {
+        let timeout = monotonic_clock::subscribe_duration(TIMEOUT_NS);
+        let sub = self.subscribe();
+
+        loop {
+            match self.accept() {
+                Err(ErrorCode::WouldBlock) => sub.block_until(&timeout)?,
+                result => return result,
+            }
+        }
+    }
+}
+
+impl UdpSocket {
+    pub fn new(address_family: IpAddressFamily) -> Result<UdpSocket, ErrorCode> {
+        udp_create_socket::create_udp_socket(address_family)
+    }
+
+    pub fn blocking_bind(
+        &self,
+        network: &Network,
+        local_address: IpSocketAddress,
+    ) -> Result<(), ErrorCode> {
+        let timeout = monotonic_clock::subscribe_duration(TIMEOUT_NS);
+        let sub = self.subscribe();
+
+        self.start_bind(&network, local_address)?;
+
+        loop {
+            match self.finish_bind() {
+                Err(ErrorCode::WouldBlock) => sub.block_until(&timeout)?,
+                result => return result,
+            }
+        }
+    }
+
+    pub fn blocking_bind_unspecified(&self, network: &Network) -> Result<(), ErrorCode> {
+        let ip = IpAddress::new_unspecified(self.address_family());
+        let port = 0;
+
+        self.blocking_bind(network, IpSocketAddress::new(ip, port))
+    }
+}
+
+impl OutgoingDatagramStream {
+    fn blocking_check_send(&self, timeout: &Pollable) -> Result<u64, ErrorCode> {
+        let sub = self.subscribe();
+
+        loop {
+            match self.check_send() {
+                Ok(0) => sub.block_until(timeout)?,
+                result => return result,
+            }
+        }
+    }
+
+    pub fn blocking_send(&self, mut datagrams: &[OutgoingDatagram]) -> Result<(), ErrorCode> {
+        let timeout = monotonic_clock::subscribe_duration(TIMEOUT_NS);
+
+        while !datagrams.is_empty() {
+            let permit = self.blocking_check_send(&timeout)?;
+            let chunk_len = datagrams.len().min(permit as usize);
+            match self.send(&datagrams[..chunk_len]) {
+                Ok(0) => {}
+                Ok(packets_sent) => {
+                    let packets_sent = packets_sent as usize;
+                    datagrams = &datagrams[packets_sent..];
+                }
+                Err(err) => return Err(err),
+            }
+        }
+
+        Ok(())
+    }
+}
+
+impl IncomingDatagramStream {
+    pub fn blocking_receive(&self, count: Range<u64>) -> Result<Vec<IncomingDatagram>, ErrorCode> {
+        let timeout = monotonic_clock::subscribe_duration(TIMEOUT_NS);
+        let pollable = self.subscribe();
+        let mut datagrams = vec![];
+
+        loop {
+            match self.receive(count.end - datagrams.len() as u64) {
+                Ok(mut chunk) => {
+                    datagrams.append(&mut chunk);
+
+                    if datagrams.len() >= count.start as usize {
+                        return Ok(datagrams);
+                    } else {
+                        pollable.block_until(&timeout)?;
+                    }
+                }
+                Err(err) => return Err(err),
+            }
+        }
+    }
+}
+
+impl IpAddress {
+    pub const IPV4_BROADCAST: IpAddress = IpAddress::Ipv4((255, 255, 255, 255));
+
+    pub const IPV4_LOOPBACK: IpAddress = IpAddress::Ipv4((127, 0, 0, 1));
+    pub const IPV6_LOOPBACK: IpAddress = IpAddress::Ipv6((0, 0, 0, 0, 0, 0, 0, 1));
+
+    pub const IPV4_UNSPECIFIED: IpAddress = IpAddress::Ipv4((0, 0, 0, 0));
+    pub const IPV6_UNSPECIFIED: IpAddress = IpAddress::Ipv6((0, 0, 0, 0, 0, 0, 0, 0));
+
+    pub const IPV4_MAPPED_LOOPBACK: IpAddress =
+        IpAddress::Ipv6((0, 0, 0, 0, 0, 0xFFFF, 0x7F00, 0x0001));
+
+    pub const fn new_loopback(family: IpAddressFamily) -> IpAddress {
+        match family {
+            IpAddressFamily::Ipv4 => Self::IPV4_LOOPBACK,
+            IpAddressFamily::Ipv6 => Self::IPV6_LOOPBACK,
+        }
+    }
+
+    pub const fn new_unspecified(family: IpAddressFamily) -> IpAddress {
+        match family {
+            IpAddressFamily::Ipv4 => Self::IPV4_UNSPECIFIED,
+            IpAddressFamily::Ipv6 => Self::IPV6_UNSPECIFIED,
+        }
+    }
+
+    pub const fn family(&self) -> IpAddressFamily {
+        match self {
+            IpAddress::Ipv4(_) => IpAddressFamily::Ipv4,
+            IpAddress::Ipv6(_) => IpAddressFamily::Ipv6,
+        }
+    }
+}
+
+impl PartialEq for IpAddress {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Self::Ipv4(left), Self::Ipv4(right)) => left == right,
+            (Self::Ipv6(left), Self::Ipv6(right)) => left == right,
+            _ => false,
+        }
+    }
+}
+
+impl IpSocketAddress {
+    pub const fn new(ip: IpAddress, port: u16) -> IpSocketAddress {
+        match ip {
+            IpAddress::Ipv4(addr) => IpSocketAddress::Ipv4(Ipv4SocketAddress {
+                port: port,
+                address: addr,
+            }),
+            IpAddress::Ipv6(addr) => IpSocketAddress::Ipv6(Ipv6SocketAddress {
+                port: port,
+                address: addr,
+                flow_info: 0,
+                scope_id: 0,
+            }),
+        }
+    }
+
+    pub const fn ip(&self) -> IpAddress {
+        match self {
+            IpSocketAddress::Ipv4(addr) => IpAddress::Ipv4(addr.address),
+            IpSocketAddress::Ipv6(addr) => IpAddress::Ipv6(addr.address),
+        }
+    }
+
+    pub const fn port(&self) -> u16 {
+        match self {
+            IpSocketAddress::Ipv4(addr) => addr.port,
+            IpSocketAddress::Ipv6(addr) => addr.port,
+        }
+    }
+
+    pub const fn family(&self) -> IpAddressFamily {
+        match self {
+            IpSocketAddress::Ipv4(_) => IpAddressFamily::Ipv4,
+            IpSocketAddress::Ipv6(_) => IpAddressFamily::Ipv6,
+        }
+    }
+}
+
+impl PartialEq for Ipv4SocketAddress {
+    fn eq(&self, other: &Self) -> bool {
+        self.port == other.port && self.address == other.address
+    }
+}
+
+impl PartialEq for Ipv6SocketAddress {
+    fn eq(&self, other: &Self) -> bool {
+        self.port == other.port
+            && self.flow_info == other.flow_info
+            && self.address == other.address
+            && self.scope_id == other.scope_id
+    }
+}
+
+impl PartialEq for IpSocketAddress {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Self::Ipv4(l0), Self::Ipv4(r0)) => l0 == r0,
+            (Self::Ipv6(l0), Self::Ipv6(r0)) => l0 == r0,
+            _ => false,
+        }
+    }
+}
+
+fn generate_random_u16(range: Range<u16>) -> u16 {
+    let start = range.start as u64;
+    let end = range.end as u64;
+    let port = start + (random::random::get_random_u64() % (end - start));
+    port as u16
+}
+
+/// Execute the inner function with a randomly generated port.
+/// To prevent random failures, we make a few attempts before giving up.
+pub fn attempt_random_port<F>(
+    local_address: IpAddress,
+    mut f: F,
+) -> Result<IpSocketAddress, ErrorCode>
+where
+    F: FnMut(IpSocketAddress) -> Result<(), ErrorCode>,
+{
+    const MAX_ATTEMPTS: u32 = 10;
+    let mut i = 0;
+    loop {
+        i += 1;
+
+        let port: u16 = generate_random_u16(1024..u16::MAX);
+        let sock_addr = IpSocketAddress::new(local_address, port);
+
+        match f(sock_addr) {
+            Ok(_) => return Ok(sock_addr),
+            Err(e) if i >= MAX_ATTEMPTS => return Err(e),
+            // Try again if the port is already taken. This can sometimes show up as `AccessDenied` on Windows.
+            Err(ErrorCode::AddressInUse | ErrorCode::AccessDenied) => {}
+            Err(e) => return Err(e),
+        }
+    }
+}
diff --git a/crates/test-programs/tests/command.rs b/crates/test-programs/tests/command.rs
deleted file mode 100644
index bdba29ff3839..000000000000
--- a/crates/test-programs/tests/command.rs
+++ /dev/null
@@ -1,508 +0,0 @@
-use anyhow::Result;
-use cap_std::{ambient_authority, fs::Dir, time::Duration};
-use std::{io::Write, sync::Mutex};
-use wasmtime::{
-    component::{Component, Linker},
-    Config, Engine, Store,
-};
-use wasmtime_wasi::preview2::{
-    command::{add_to_linker, Command},
-    pipe::MemoryInputPipe,
-    DirPerms, FilePerms, HostMonotonicClock, HostWallClock, Table, WasiCtx, WasiCtxBuilder,
-    WasiView,
-};
-
-lazy_static::lazy_static! {
-    static ref ENGINE: Engine = {
-        let mut config = Config::new();
-        config.wasm_backtrace_details(wasmtime::WasmBacktraceDetails::Enable);
-        config.wasm_component_model(true);
-        config.async_support(true);
-
-        let engine = Engine::new(&config).unwrap();
-        engine
-    };
-}
-// uses ENGINE, creates a fn get_component(&str) -> Component
-include!(concat!(env!("OUT_DIR"), "/command_tests_components.rs"));
-
-struct CommandCtx {
-    table: Table,
-    wasi: WasiCtx,
-}
-
-impl WasiView for CommandCtx {
-    fn table(&self) -> &Table {
-        &self.table
-    }
-    fn table_mut(&mut self) -> &mut Table {
-        &mut self.table
-    }
-    fn ctx(&self) -> &WasiCtx {
-        &self.wasi
-    }
-    fn ctx_mut(&mut self) -> &mut WasiCtx {
-        &mut self.wasi
-    }
-}
-
-async fn instantiate(
-    component: Component,
-    ctx: CommandCtx,
-) -> Result<(Store<CommandCtx>, Command)> {
-    let mut linker = Linker::new(&ENGINE);
-    add_to_linker(&mut linker)?;
-
-    let mut store = Store::new(&ENGINE, ctx);
-
-    let (command, _instance) = Command::instantiate_async(&mut store, &component, &linker).await?;
-    Ok((store, command))
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn hello_stdout() -> Result<()> {
-    let table = Table::new();
-    let wasi = WasiCtxBuilder::new()
-        .args(&["gussie", "sparky", "willa"])
-        .build();
-    let (mut store, command) =
-        instantiate(get_component("hello_stdout"), CommandCtx { table, wasi }).await?;
-    command
-        .wasi_cli_run()
-        .call_run(&mut store)
-        .await?
-        .map_err(|()| anyhow::anyhow!("command returned with failing exit status"))
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn panic() -> Result<()> {
-    let table = Table::new();
-    let wasi = WasiCtxBuilder::new()
-        .args(&[
-            "diesel",
-            "the",
-            "cat",
-            "scratched",
-            "me",
-            "real",
-            "good",
-            "yesterday",
-        ])
-        .build();
-    let (mut store, command) =
-        instantiate(get_component("panic"), CommandCtx { table, wasi }).await?;
-    let r = command.wasi_cli_run().call_run(&mut store).await;
-    assert!(r.is_err());
-    println!("{:?}", r);
-    Ok(())
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn args() -> Result<()> {
-    let table = Table::new();
-    let wasi = WasiCtxBuilder::new()
-        .args(&["hello", "this", "", "is an argument", "with 🚩 emoji"])
-        .build();
-    let (mut store, command) =
-        instantiate(get_component("args"), CommandCtx { table, wasi }).await?;
-    command
-        .wasi_cli_run()
-        .call_run(&mut store)
-        .await?
-        .map_err(|()| anyhow::anyhow!("command returned with failing exit status"))
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn random() -> Result<()> {
-    let table = Table::new();
-    let wasi = WasiCtxBuilder::new().build();
-    let (mut store, command) =
-        instantiate(get_component("random"), CommandCtx { table, wasi }).await?;
-
-    command
-        .wasi_cli_run()
-        .call_run(&mut store)
-        .await?
-        .map_err(|()| anyhow::anyhow!("command returned with failing exit status"))
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn time() -> Result<()> {
-    struct FakeWallClock;
-
-    impl HostWallClock for FakeWallClock {
-        fn resolution(&self) -> Duration {
-            Duration::from_secs(1)
-        }
-
-        fn now(&self) -> Duration {
-            Duration::new(1431648000, 100)
-        }
-    }
-
-    struct FakeMonotonicClock {
-        now: Mutex<u64>,
-    }
-
-    impl HostMonotonicClock for FakeMonotonicClock {
-        fn resolution(&self) -> u64 {
-            1_000_000_000
-        }
-
-        fn now(&self) -> u64 {
-            let mut now = self.now.lock().unwrap();
-            let then = *now;
-            *now += 42 * 1_000_000_000;
-            then
-        }
-    }
-
-    let table = Table::new();
-    let wasi = WasiCtxBuilder::new()
-        .monotonic_clock(FakeMonotonicClock { now: Mutex::new(0) })
-        .wall_clock(FakeWallClock)
-        .build();
-
-    let (mut store, command) =
-        instantiate(get_component("time"), CommandCtx { table, wasi }).await?;
-
-    command
-        .wasi_cli_run()
-        .call_run(&mut store)
-        .await?
-        .map_err(|()| anyhow::anyhow!("command returned with failing exit status"))
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn stdin() -> Result<()> {
-    let table = Table::new();
-    let wasi = WasiCtxBuilder::new()
-        .stdin(MemoryInputPipe::new(
-            "So rested he by the Tumtum tree".into(),
-        ))
-        .build();
-
-    let (mut store, command) =
-        instantiate(get_component("stdin"), CommandCtx { table, wasi }).await?;
-
-    command
-        .wasi_cli_run()
-        .call_run(&mut store)
-        .await?
-        .map_err(|()| anyhow::anyhow!("command returned with failing exit status"))
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn poll_stdin() -> Result<()> {
-    let table = Table::new();
-    let wasi = WasiCtxBuilder::new()
-        .stdin(MemoryInputPipe::new(
-            "So rested he by the Tumtum tree".into(),
-        ))
-        .build();
-
-    let (mut store, command) =
-        instantiate(get_component("poll_stdin"), CommandCtx { table, wasi }).await?;
-
-    command
-        .wasi_cli_run()
-        .call_run(&mut store)
-        .await?
-        .map_err(|()| anyhow::anyhow!("command returned with failing exit status"))
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn env() -> Result<()> {
-    let table = Table::new();
-    let wasi = WasiCtxBuilder::new()
-        .env("frabjous", "day")
-        .env("callooh", "callay")
-        .build();
-
-    let (mut store, command) =
-        instantiate(get_component("env"), CommandCtx { table, wasi }).await?;
-
-    command
-        .wasi_cli_run()
-        .call_run(&mut store)
-        .await?
-        .map_err(|()| anyhow::anyhow!("command returned with failing exit status"))
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn file_read() -> Result<()> {
-    let dir = tempfile::tempdir()?;
-
-    std::fs::File::create(dir.path().join("bar.txt"))?.write_all(b"And stood awhile in thought")?;
-
-    let open_dir = Dir::open_ambient_dir(dir.path(), ambient_authority())?;
-
-    let table = Table::new();
-    let wasi = WasiCtxBuilder::new()
-        .preopened_dir(open_dir, DirPerms::all(), FilePerms::all(), "/")
-        .build();
-
-    let (mut store, command) =
-        instantiate(get_component("file_read"), CommandCtx { table, wasi }).await?;
-
-    command
-        .wasi_cli_run()
-        .call_run(&mut store)
-        .await?
-        .map_err(|()| anyhow::anyhow!("command returned with failing exit status"))
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn file_append() -> Result<()> {
-    let dir = tempfile::tempdir()?;
-
-    std::fs::File::create(dir.path().join("bar.txt"))?
-        .write_all(b"'Twas brillig, and the slithy toves.\n")?;
-
-    let open_dir = Dir::open_ambient_dir(dir.path(), ambient_authority())?;
-
-    let table = Table::new();
-    let wasi = WasiCtxBuilder::new()
-        .preopened_dir(open_dir, DirPerms::all(), FilePerms::all(), "/")
-        .build();
-
-    let (mut store, command) =
-        instantiate(get_component("file_append"), CommandCtx { table, wasi }).await?;
-    command
-        .wasi_cli_run()
-        .call_run(&mut store)
-        .await?
-        .map_err(|()| anyhow::anyhow!("command returned with failing exit status"))?;
-
-    let contents = std::fs::read(dir.path().join("bar.txt"))?;
-    assert_eq!(
-        std::str::from_utf8(&contents).unwrap(),
-        "'Twas brillig, and the slithy toves.\n\
-               Did gyre and gimble in the wabe;\n\
-               All mimsy were the borogoves,\n\
-               And the mome raths outgrabe.\n"
-    );
-    Ok(())
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn file_dir_sync() -> Result<()> {
-    let dir = tempfile::tempdir()?;
-
-    std::fs::File::create(dir.path().join("bar.txt"))?
-        .write_all(b"'Twas brillig, and the slithy toves.\n")?;
-
-    let open_dir = Dir::open_ambient_dir(dir.path(), ambient_authority())?;
-
-    let table = Table::new();
-    let wasi = WasiCtxBuilder::new()
-        .preopened_dir(open_dir, DirPerms::all(), FilePerms::all(), "/")
-        .build();
-
-    let (mut store, command) =
-        instantiate(get_component("file_dir_sync"), CommandCtx { table, wasi }).await?;
-
-    command
-        .wasi_cli_run()
-        .call_run(&mut store)
-        .await?
-        .map_err(|()| anyhow::anyhow!("command returned with failing exit status"))
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn exit_success() -> Result<()> {
-    let table = Table::new();
-    let wasi = WasiCtxBuilder::new().build();
-
-    let (mut store, command) =
-        instantiate(get_component("exit_success"), CommandCtx { table, wasi }).await?;
-
-    let r = command.wasi_cli_run().call_run(&mut store).await;
-    let err = r.unwrap_err();
-    let status = err
-        .downcast_ref::<wasmtime_wasi::preview2::I32Exit>()
-        .unwrap();
-    assert_eq!(status.0, 0);
-    Ok(())
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn exit_default() -> Result<()> {
-    let table = Table::new();
-    let wasi = WasiCtxBuilder::new().build();
-
-    let (mut store, command) =
-        instantiate(get_component("exit_default"), CommandCtx { table, wasi }).await?;
-
-    let r = command.wasi_cli_run().call_run(&mut store).await?;
-    assert!(r.is_ok());
-    Ok(())
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn exit_failure() -> Result<()> {
-    let table = Table::new();
-    let wasi = WasiCtxBuilder::new().build();
-
-    let (mut store, command) =
-        instantiate(get_component("exit_failure"), CommandCtx { table, wasi }).await?;
-
-    let r = command.wasi_cli_run().call_run(&mut store).await;
-    let err = r.unwrap_err();
-    let status = err
-        .downcast_ref::<wasmtime_wasi::preview2::I32Exit>()
-        .unwrap();
-    assert_eq!(status.0, 1);
-    Ok(())
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn exit_panic() -> Result<()> {
-    let table = Table::new();
-    let wasi = WasiCtxBuilder::new().build();
-
-    let (mut store, command) =
-        instantiate(get_component("exit_panic"), CommandCtx { table, wasi }).await?;
-
-    let r = command.wasi_cli_run().call_run(&mut store).await;
-    let err = r.unwrap_err();
-    // The panic should trap.
-    assert!(err
-        .downcast_ref::<wasmtime_wasi::preview2::I32Exit>()
-        .is_none());
-    Ok(())
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn directory_list() -> Result<()> {
-    let dir = tempfile::tempdir()?;
-
-    std::fs::File::create(dir.path().join("foo.txt"))?;
-    std::fs::File::create(dir.path().join("bar.txt"))?;
-    std::fs::File::create(dir.path().join("baz.txt"))?;
-    std::fs::create_dir(dir.path().join("sub"))?;
-    std::fs::File::create(dir.path().join("sub").join("wow.txt"))?;
-    std::fs::File::create(dir.path().join("sub").join("yay.txt"))?;
-
-    let open_dir = Dir::open_ambient_dir(dir.path(), ambient_authority())?;
-
-    let table = Table::new();
-    let wasi = WasiCtxBuilder::new()
-        .inherit_stdout()
-        .inherit_stderr()
-        .preopened_dir(open_dir, DirPerms::all(), FilePerms::all(), "/")
-        .build();
-
-    let (mut store, command) =
-        instantiate(get_component("directory_list"), CommandCtx { table, wasi }).await?;
-
-    command
-        .wasi_cli_run()
-        .call_run(&mut store)
-        .await?
-        .map_err(|()| anyhow::anyhow!("command returned with failing exit status"))
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn default_clocks() -> Result<()> {
-    let table = Table::new();
-    let wasi = WasiCtxBuilder::new().build();
-
-    let (mut store, command) =
-        instantiate(get_component("default_clocks"), CommandCtx { table, wasi }).await?;
-
-    command
-        .wasi_cli_run()
-        .call_run(&mut store)
-        .await?
-        .map_err(|()| anyhow::anyhow!("command returned with failing exit status"))
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn export_cabi_realloc() -> Result<()> {
-    let table = Table::new();
-    let wasi = WasiCtxBuilder::new().build();
-    let (mut store, command) = instantiate(
-        get_component("export_cabi_realloc"),
-        CommandCtx { table, wasi },
-    )
-    .await?;
-
-    command
-        .wasi_cli_run()
-        .call_run(&mut store)
-        .await?
-        .map_err(|()| anyhow::anyhow!("command returned with failing exit status"))
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn read_only() -> Result<()> {
-    let dir = tempfile::tempdir()?;
-
-    std::fs::File::create(dir.path().join("bar.txt"))?.write_all(b"And stood awhile in thought")?;
-    std::fs::create_dir(dir.path().join("sub"))?;
-
-    let table = Table::new();
-    let open_dir = Dir::open_ambient_dir(dir.path(), ambient_authority())?;
-    let wasi = WasiCtxBuilder::new()
-        .preopened_dir(open_dir, DirPerms::READ, FilePerms::READ, "/")
-        .build();
-
-    let (mut store, command) =
-        instantiate(get_component("read_only"), CommandCtx { table, wasi }).await?;
-
-    command
-        .wasi_cli_run()
-        .call_run(&mut store)
-        .await?
-        .map_err(|()| anyhow::anyhow!("command returned with failing exit status"))
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn stream_pollable_lifetimes() -> Result<()> {
-    // Test program has two modes, dispatching based on argument.
-    {
-        // Correct execution: should succeed
-        let table = Table::new();
-        let wasi = WasiCtxBuilder::new()
-            .args(&["correct"])
-            .stdin(MemoryInputPipe::new(" ".into()))
-            .build();
-
-        let (mut store, command) = instantiate(
-            get_component("stream_pollable_lifetimes"),
-            CommandCtx { table, wasi },
-        )
-        .await?;
-
-        command
-            .wasi_cli_run()
-            .call_run(&mut store)
-            .await?
-            .map_err(|()| anyhow::anyhow!("command returned with failing exit status"))?;
-    }
-    {
-        // Incorrect execution: should trap with a TableError::HasChildren
-        let table = Table::new();
-        let wasi = WasiCtxBuilder::new()
-            .args(&["trap"])
-            .stdin(MemoryInputPipe::new(" ".into()))
-            .build();
-
-        let (mut store, command) = instantiate(
-            get_component("stream_pollable_lifetimes"),
-            CommandCtx { table, wasi },
-        )
-        .await?;
-
-        let trap = command
-            .wasi_cli_run()
-            .call_run(&mut store)
-            .await
-            .err()
-            .expect("should trap");
-        use wasmtime_wasi::preview2::TableError;
-        assert!(matches!(trap.downcast_ref(), Some(TableError::HasChildren)));
-    }
-    Ok(())
-}
diff --git a/crates/test-programs/tests/reactor.rs b/crates/test-programs/tests/reactor.rs
deleted file mode 100644
index 4b20ff97ce0a..000000000000
--- a/crates/test-programs/tests/reactor.rs
+++ /dev/null
@@ -1,136 +0,0 @@
-use anyhow::Result;
-use wasmtime::{
-    component::{Component, Linker},
-    Config, Engine, Store,
-};
-use wasmtime_wasi::preview2::bindings::clocks::wall_clock;
-use wasmtime_wasi::preview2::bindings::filesystem::types as filesystem;
-use wasmtime_wasi::preview2::{self, Table, WasiCtx, WasiCtxBuilder, WasiView};
-
-lazy_static::lazy_static! {
-    static ref ENGINE: Engine = {
-        let mut config = Config::new();
-        config.wasm_backtrace_details(wasmtime::WasmBacktraceDetails::Enable);
-        config.wasm_component_model(true);
-        config.async_support(true);
-
-        let engine = Engine::new(&config).unwrap();
-        engine
-    };
-}
-
-// uses ENGINE, creates a fn get_component(&str) -> Component
-include!(concat!(env!("OUT_DIR"), "/reactor_tests_components.rs"));
-
-wasmtime::component::bindgen!({
-    path: "../wasi/wit",
-    world: "test-reactor",
-    async: true,
-    with: {
-       "wasi:io/streams": preview2::bindings::io::streams,
-       "wasi:filesystem/types": preview2::bindings::filesystem::types,
-       "wasi:filesystem/preopens": preview2::bindings::filesystem::preopens,
-       "wasi:cli/environment": preview2::bindings::cli::environment,
-       "wasi:cli/exit": preview2::bindings::cli::exit,
-       "wasi:cli/stdin": preview2::bindings::cli::stdin,
-       "wasi:cli/stdout": preview2::bindings::cli::stdout,
-       "wasi:cli/stderr": preview2::bindings::cli::stderr,
-       "wasi:cli/terminal_input": preview2::bindings::cli::terminal_input,
-       "wasi:cli/terminal_output": preview2::bindings::cli::terminal_output,
-       "wasi:cli/terminal_stdin": preview2::bindings::cli::terminal_stdin,
-       "wasi:cli/terminal_stdout": preview2::bindings::cli::terminal_stdout,
-       "wasi:cli/terminal_stderr": preview2::bindings::cli::terminal_stderr,
-    },
-    ownership: Borrowing {
-        duplicate_if_necessary: false
-    }
-});
-
-struct ReactorCtx {
-    table: Table,
-    wasi: WasiCtx,
-}
-
-impl WasiView for ReactorCtx {
-    fn table(&self) -> &Table {
-        &self.table
-    }
-    fn table_mut(&mut self) -> &mut Table {
-        &mut self.table
-    }
-    fn ctx(&self) -> &WasiCtx {
-        &self.wasi
-    }
-    fn ctx_mut(&mut self) -> &mut WasiCtx {
-        &mut self.wasi
-    }
-}
-
-async fn instantiate(
-    component: Component,
-    wasi_ctx: ReactorCtx,
-) -> Result<(Store<ReactorCtx>, TestReactor)> {
-    let mut linker = Linker::new(&ENGINE);
-    preview2::command::add_to_linker(&mut linker)?;
-
-    let mut store = Store::new(&ENGINE, wasi_ctx);
-    let (testreactor, _instance) =
-        TestReactor::instantiate_async(&mut store, &component, &linker).await?;
-    Ok((store, testreactor))
-}
-
-#[test_log::test(tokio::test)]
-async fn reactor_tests() -> Result<()> {
-    let table = Table::new();
-    let wasi = WasiCtxBuilder::new().env("GOOD_DOG", "gussie").build();
-
-    let (mut store, reactor) =
-        instantiate(get_component("reactor_tests"), ReactorCtx { table, wasi }).await?;
-
-    // Show that integration with the WASI context is working - the guest will
-    // interpolate $GOOD_DOG to gussie here using the environment:
-    let r = reactor
-        .call_add_strings(&mut store, &["hello", "$GOOD_DOG"])
-        .await?;
-    assert_eq!(r, 2);
-
-    let contents = reactor.call_get_strings(&mut store).await?;
-    assert_eq!(contents, &["hello", "gussie"]);
-
-    // Show that we can pass in a resource type whose impls are defined in the
-    // `host` and `wasi-common` crate.
-    // Note, this works because of the add_to_linker invocations using the
-    // `host` crate for `streams`, not because of `with` in the bindgen macro.
-    let writepipe = preview2::pipe::MemoryOutputPipe::new(4096);
-    let stream: preview2::OutputStream = Box::new(writepipe.clone());
-    let table_ix = store.data_mut().table_mut().push_resource(stream)?;
-    let r = reactor.call_write_strings_to(&mut store, table_ix).await?;
-    assert_eq!(r, Ok(()));
-
-    assert_eq!(writepipe.contents().as_ref(), b"hellogussie");
-
-    // Show that the `with` invocation in the macro means we get to re-use the
-    // type definitions from inside the `host` crate for these structures:
-    let ds = filesystem::DescriptorStat {
-        data_access_timestamp: Some(wall_clock::Datetime {
-            nanoseconds: 123,
-            seconds: 45,
-        }),
-        data_modification_timestamp: Some(wall_clock::Datetime {
-            nanoseconds: 789,
-            seconds: 10,
-        }),
-        link_count: 0,
-        size: 0,
-        status_change_timestamp: Some(wall_clock::Datetime {
-            nanoseconds: 0,
-            seconds: 1,
-        }),
-        type_: filesystem::DescriptorType::Unknown,
-    };
-    let expected = format!("{ds:?}");
-    let got = reactor.call_pass_an_imported_record(&mut store, ds).await?;
-    assert_eq!(expected, got);
-
-    Ok(())
-}
diff --git a/crates/test-programs/tests/wasi-cap-std-sync.rs b/crates/test-programs/tests/wasi-cap-std-sync.rs
deleted file mode 100644
index 317e427a77ba..000000000000
--- a/crates/test-programs/tests/wasi-cap-std-sync.rs
+++ /dev/null
@@ -1,297 +0,0 @@
-#![cfg(feature = "test_programs")]
-use anyhow::Result;
-use tempfile::TempDir;
-use wasi_common::pipe::WritePipe;
-use wasmtime::{Config, Engine, Linker, Store};
-
-lazy_static::lazy_static! {
-    static ref ENGINE: Engine = {
-        let mut config = Config::new();
-        config.wasm_backtrace_details(wasmtime::WasmBacktraceDetails::Enable);
-        config.wasm_component_model(false);
-        config.async_support(false);
-
-        let engine = Engine::new(&config).unwrap();
-        engine
-    };
-}
-// uses ENGINE, creates a fn get_module(&str) -> Module
-include!(concat!(env!("OUT_DIR"), "/wasi_tests_modules.rs"));
-
-pub fn prepare_workspace(exe_name: &str) -> Result<TempDir> {
-    let prefix = format!("wasi_cap_std_sync_{}_", exe_name);
-    let tempdir = tempfile::Builder::new().prefix(&prefix).tempdir()?;
-    Ok(tempdir)
-}
-
-use wasmtime_wasi::sync::{add_to_linker, WasiCtxBuilder};
-fn run(name: &str, inherit_stdio: bool) -> Result<()> {
-    let workspace = prepare_workspace(name)?;
-    let stdout = WritePipe::new_in_memory();
-    let stderr = WritePipe::new_in_memory();
-    let r = {
-        let mut linker = Linker::new(&ENGINE);
-        add_to_linker(&mut linker, |cx| cx)?;
-
-        // Create our wasi context.
-        // Additionally register any preopened directories if we have them.
-        let mut builder = WasiCtxBuilder::new();
-
-        if inherit_stdio {
-            builder.inherit_stdio();
-        } else {
-            builder
-                .stdout(Box::new(stdout.clone()))
-                .stderr(Box::new(stderr.clone()));
-        }
-        builder.arg(name)?.arg(".")?;
-        println!("preopen: {:?}", workspace);
-        let preopen_dir =
-            cap_std::fs::Dir::open_ambient_dir(workspace.path(), cap_std::ambient_authority())?;
-        builder.preopened_dir(preopen_dir, ".")?;
-        for (var, val) in test_programs::wasi_tests_environment() {
-            builder.env(var, val)?;
-        }
-
-        let mut store = Store::new(&ENGINE, builder.build());
-        let instance = linker.instantiate(&mut store, &get_module(name))?;
-        let start = instance.get_typed_func::<(), ()>(&mut store, "_start")?;
-        start.call(&mut store, ())?;
-        Ok(())
-    };
-
-    r.map_err(move |trap: anyhow::Error| {
-        let stdout = stdout
-            .try_into_inner()
-            .expect("sole ref to stdout")
-            .into_inner();
-        if !stdout.is_empty() {
-            println!("guest stdout:\n{}\n===", String::from_utf8_lossy(&stdout));
-        }
-        let stderr = stderr
-            .try_into_inner()
-            .expect("sole ref to stderr")
-            .into_inner();
-        if !stderr.is_empty() {
-            println!("guest stderr:\n{}\n===", String::from_utf8_lossy(&stderr));
-        }
-        trap.context(format!(
-            "error while testing wasi-tests {} with cap-std-sync",
-            name
-        ))
-    })?;
-    Ok(())
-}
-
-// Below here is mechanical: there should be one test for every binary in
-// wasi-tests. The only differences should be should_panic annotations for
-// tests which fail.
-#[test_log::test]
-fn big_random_buf() {
-    run("big_random_buf", true).unwrap()
-}
-#[test_log::test]
-fn clock_time_get() {
-    run("clock_time_get", true).unwrap()
-}
-#[test_log::test]
-fn close_preopen() {
-    run("close_preopen", true).unwrap()
-}
-#[test_log::test]
-fn dangling_fd() {
-    run("dangling_fd", true).unwrap()
-}
-#[test_log::test]
-fn dangling_symlink() {
-    run("dangling_symlink", true).unwrap()
-}
-#[test_log::test]
-fn directory_seek() {
-    run("directory_seek", true).unwrap()
-}
-#[test_log::test]
-fn dir_fd_op_failures() {
-    run("dir_fd_op_failures", true).unwrap()
-}
-#[test_log::test]
-fn fd_advise() {
-    run("fd_advise", true).unwrap()
-}
-#[test_log::test]
-fn fd_filestat_get() {
-    run("fd_filestat_get", true).unwrap()
-}
-#[test_log::test]
-fn fd_filestat_set() {
-    run("fd_filestat_set", true).unwrap()
-}
-#[test_log::test]
-fn fd_flags_set() {
-    run("fd_flags_set", true).unwrap()
-}
-#[test_log::test]
-fn fd_readdir() {
-    run("fd_readdir", true).unwrap()
-}
-#[test_log::test]
-fn file_allocate() {
-    run("file_allocate", true).unwrap()
-}
-#[test_log::test]
-fn file_pread_pwrite() {
-    run("file_pread_pwrite", true).unwrap()
-}
-#[test_log::test]
-fn file_seek_tell() {
-    run("file_seek_tell", true).unwrap()
-}
-#[test_log::test]
-fn file_truncation() {
-    run("file_truncation", true).unwrap()
-}
-#[test_log::test]
-fn file_unbuffered_write() {
-    run("file_unbuffered_write", true).unwrap()
-}
-#[test_log::test]
-#[cfg_attr(windows, should_panic)]
-fn interesting_paths() {
-    run("interesting_paths", true).unwrap()
-}
-#[test_log::test]
-fn regular_file_isatty() {
-    run("regular_file_isatty", true).unwrap()
-}
-#[test_log::test]
-fn nofollow_errors() {
-    run("nofollow_errors", true).unwrap()
-}
-#[test_log::test]
-fn overwrite_preopen() {
-    run("overwrite_preopen", true).unwrap()
-}
-#[test_log::test]
-fn path_exists() {
-    run("path_exists", true).unwrap()
-}
-#[test_log::test]
-fn path_filestat() {
-    run("path_filestat", true).unwrap()
-}
-#[test_log::test]
-fn path_link() {
-    run("path_link", true).unwrap()
-}
-#[test_log::test]
-fn path_open_create_existing() {
-    run("path_open_create_existing", true).unwrap()
-}
-#[test_log::test]
-fn path_open_read_write() {
-    run("path_open_read_write", true).unwrap()
-}
-#[test_log::test]
-fn path_open_dirfd_not_dir() {
-    run("path_open_dirfd_not_dir", true).unwrap()
-}
-#[test_log::test]
-fn path_open_missing() {
-    run("path_open_missing", true).unwrap()
-}
-#[test_log::test]
-fn path_open_nonblock() {
-    run("path_open_nonblock", true).unwrap()
-}
-#[test_log::test]
-fn path_rename_dir_trailing_slashes() {
-    run("path_rename_dir_trailing_slashes", true).unwrap()
-}
-#[test_log::test]
-#[should_panic]
-fn path_rename_file_trailing_slashes() {
-    run("path_rename_file_trailing_slashes", false).unwrap()
-}
-#[test_log::test]
-fn path_rename() {
-    run("path_rename", true).unwrap()
-}
-#[test_log::test]
-fn path_symlink_trailing_slashes() {
-    run("path_symlink_trailing_slashes", true).unwrap()
-}
-#[test_log::test]
-fn poll_oneoff_files() {
-    run("poll_oneoff_files", false).unwrap()
-}
-#[test_log::test]
-fn poll_oneoff_stdio() {
-    run("poll_oneoff_stdio", true).unwrap()
-}
-#[test_log::test]
-fn readlink() {
-    run("readlink", true).unwrap()
-}
-#[test_log::test]
-#[should_panic]
-fn remove_directory_trailing_slashes() {
-    run("remove_directory_trailing_slashes", false).unwrap()
-}
-#[test_log::test]
-fn remove_nonempty_directory() {
-    run("remove_nonempty_directory", true).unwrap()
-}
-#[test_log::test]
-fn renumber() {
-    run("renumber", true).unwrap()
-}
-#[test_log::test]
-fn sched_yield() {
-    run("sched_yield", true).unwrap()
-}
-#[test_log::test]
-#[should_panic]
-fn sleep() {
-    run("sleep", true).unwrap()
-}
-#[test_log::test]
-fn stdio() {
-    run("stdio", true).unwrap()
-}
-#[test_log::test]
-fn stdio_isatty() {
-    if test_programs::stdio_is_terminal() {
-        // Inherit stdio, which is a terminal in the test runner's environment:
-        run("stdio_isatty", true).unwrap()
-    }
-}
-#[test_log::test]
-fn stdio_not_isatty() {
-    // Don't inherit stdio, test asserts each is not tty:
-    run("stdio_not_isatty", false).unwrap()
-}
-
-#[test_log::test]
-fn symlink_create() {
-    run("symlink_create", true).unwrap()
-}
-#[test_log::test]
-fn symlink_filestat() {
-    run("symlink_filestat", true).unwrap()
-}
-#[test_log::test]
-fn symlink_loop() {
-    run("symlink_loop", true).unwrap()
-}
-#[test_log::test]
-fn unlink_file_trailing_slashes() {
-    run("unlink_file_trailing_slashes", true).unwrap()
-}
-#[test_log::test]
-fn path_open_preopen() {
-    run("path_open_preopen", true).unwrap()
-}
-#[test_log::test]
-fn unicode_output() {
-    run("unicode_output", true).unwrap()
-}
diff --git a/crates/test-programs/tests/wasi-http-components-sync.rs b/crates/test-programs/tests/wasi-http-components-sync.rs
deleted file mode 100644
index 1f5a196c361c..000000000000
--- a/crates/test-programs/tests/wasi-http-components-sync.rs
+++ /dev/null
@@ -1,165 +0,0 @@
-#![cfg(all(feature = "test_programs", not(skip_wasi_http_tests)))]
-
-use anyhow::Result;
-use test_programs::http_server::Server;
-use wasmtime::{
-    component::{Component, Linker},
-    Config, Engine, Store,
-};
-use wasmtime_wasi::preview2::{
-    command::sync::Command, pipe::MemoryOutputPipe, Table, WasiCtx, WasiCtxBuilder, WasiView,
-};
-use wasmtime_wasi_http::{WasiHttpCtx, WasiHttpView};
-
-lazy_static::lazy_static! {
-    static ref ENGINE: Engine = {
-        let mut config = Config::new();
-        config.wasm_backtrace_details(wasmtime::WasmBacktraceDetails::Enable);
-        config.wasm_component_model(true);
-        let engine = Engine::new(&config).unwrap();
-        engine
-    };
-}
-// uses ENGINE, creates a fn get_module(&str) -> Module
-include!(concat!(env!("OUT_DIR"), "/wasi_http_tests_components.rs"));
-
-struct Ctx {
-    table: Table,
-    wasi: WasiCtx,
-    http: WasiHttpCtx,
-}
-
-impl WasiView for Ctx {
-    fn table(&self) -> &Table {
-        &self.table
-    }
-    fn table_mut(&mut self) -> &mut Table {
-        &mut self.table
-    }
-    fn ctx(&self) -> &WasiCtx {
-        &self.wasi
-    }
-    fn ctx_mut(&mut self) -> &mut WasiCtx {
-        &mut self.wasi
-    }
-}
-
-impl WasiHttpView for Ctx {
-    fn ctx(&mut self) -> &mut WasiHttpCtx {
-        &mut self.http
-    }
-
-    fn table(&mut self) -> &mut Table {
-        &mut self.table
-    }
-}
-
-fn instantiate_component(
-    component: Component,
-    ctx: Ctx,
-) -> Result<(Store<Ctx>, Command), anyhow::Error> {
-    let mut linker = Linker::new(&ENGINE);
-    wasmtime_wasi_http::proxy::sync::add_to_linker(&mut linker)?;
-
-    let mut store = Store::new(&ENGINE, ctx);
-
-    let (command, _instance) = Command::instantiate(&mut store, &component, &linker)?;
-    Ok((store, command))
-}
-
-fn run(name: &str, server: &Server) -> Result<()> {
-    let stdout = MemoryOutputPipe::new(4096);
-    let stderr = MemoryOutputPipe::new(4096);
-    let r = {
-        let table = Table::new();
-        let component = get_component(name);
-
-        // Create our wasi context.
-        let mut builder = WasiCtxBuilder::new();
-        builder.stdout(stdout.clone());
-        builder.stderr(stderr.clone());
-        builder.arg(name);
-        for (var, val) in test_programs::wasi_tests_environment() {
-            builder.env(var, val);
-        }
-        builder.env("HTTP_SERVER", server.addr().to_string());
-        let wasi = builder.build();
-        let http = WasiHttpCtx {};
-
-        let (mut store, command) = instantiate_component(component, Ctx { table, wasi, http })?;
-        command
-            .wasi_cli_run()
-            .call_run(&mut store)?
-            .map_err(|()| anyhow::anyhow!("run returned a failure"))?;
-        Ok(())
-    };
-    r.map_err(move |trap: anyhow::Error| {
-        let stdout = stdout.try_into_inner().expect("single ref to stdout");
-        if !stdout.is_empty() {
-            println!("[guest] stdout:\n{}\n===", String::from_utf8_lossy(&stdout));
-        }
-        let stderr = stderr.try_into_inner().expect("single ref to stderr");
-        if !stderr.is_empty() {
-            println!("[guest] stderr:\n{}\n===", String::from_utf8_lossy(&stderr));
-        }
-        trap.context(format!(
-            "error while testing wasi-tests {} with http-components-sync",
-            name
-        ))
-    })?;
-    Ok(())
-}
-
-#[test_log::test]
-fn outbound_request_get() -> Result<()> {
-    let server = Server::http1()?;
-    run("outbound_request_get", &server)
-}
-
-#[test_log::test]
-fn outbound_request_post() -> Result<()> {
-    let server = Server::http1()?;
-    run("outbound_request_post", &server)
-}
-
-#[test_log::test]
-fn outbound_request_large_post() -> Result<()> {
-    let server = Server::http1()?;
-    run("outbound_request_large_post", &server)
-}
-
-#[test_log::test]
-fn outbound_request_put() -> Result<()> {
-    let server = Server::http1()?;
-    run("outbound_request_put", &server)
-}
-
-#[test_log::test]
-fn outbound_request_invalid_version() -> Result<()> {
-    let server = Server::http2()?;
-    run("outbound_request_invalid_version", &server)
-}
-
-#[test_log::test]
-fn outbound_request_unknown_method() -> Result<()> {
-    let server = Server::http1()?;
-    run("outbound_request_unknown_method", &server)
-}
-
-#[test_log::test]
-fn outbound_request_unsupported_scheme() -> Result<()> {
-    let server = Server::http1()?;
-    run("outbound_request_unsupported_scheme", &server)
-}
-
-#[test_log::test]
-fn outbound_request_invalid_port() -> Result<()> {
-    let server = Server::http1()?;
-    run("outbound_request_invalid_port", &server)
-}
-
-#[test_log::test]
-fn outbound_request_invalid_dnsname() -> Result<()> {
-    let server = Server::http1()?;
-    run("outbound_request_invalid_dnsname", &server)
-}
diff --git a/crates/test-programs/tests/wasi-http-components.rs b/crates/test-programs/tests/wasi-http-components.rs
deleted file mode 100644
index 7d70cb365036..000000000000
--- a/crates/test-programs/tests/wasi-http-components.rs
+++ /dev/null
@@ -1,163 +0,0 @@
-#![cfg(all(feature = "test_programs", not(skip_wasi_http_tests)))]
-
-use anyhow::Result;
-use test_programs::http_server::Server;
-use wasmtime::{
-    component::{Component, Linker},
-    Config, Engine, Store,
-};
-use wasmtime_wasi::preview2::{
-    command::Command, pipe::MemoryOutputPipe, Table, WasiCtx, WasiCtxBuilder, WasiView,
-};
-use wasmtime_wasi_http::{WasiHttpCtx, WasiHttpView};
-
-lazy_static::lazy_static! {
-    static ref ENGINE: Engine = {
-        let mut config = Config::new();
-        config.wasm_backtrace_details(wasmtime::WasmBacktraceDetails::Enable);
-        config.wasm_component_model(true);
-        config.async_support(true);
-        let engine = Engine::new(&config).unwrap();
-        engine
-    };
-}
-// uses ENGINE, creates a fn get_module(&str) -> Module
-include!(concat!(env!("OUT_DIR"), "/wasi_http_tests_components.rs"));
-
-struct Ctx {
-    table: Table,
-    wasi: WasiCtx,
-    http: WasiHttpCtx,
-}
-
-impl WasiView for Ctx {
-    fn table(&self) -> &Table {
-        &self.table
-    }
-    fn table_mut(&mut self) -> &mut Table {
-        &mut self.table
-    }
-    fn ctx(&self) -> &WasiCtx {
-        &self.wasi
-    }
-    fn ctx_mut(&mut self) -> &mut WasiCtx {
-        &mut self.wasi
-    }
-}
-
-impl WasiHttpView for Ctx {
-    fn table(&mut self) -> &mut Table {
-        &mut self.table
-    }
-    fn ctx(&mut self) -> &mut WasiHttpCtx {
-        &mut self.http
-    }
-}
-
-async fn instantiate_component(
-    component: Component,
-    ctx: Ctx,
-) -> Result<(Store<Ctx>, Command), anyhow::Error> {
-    let mut linker = Linker::new(&ENGINE);
-    wasmtime_wasi_http::proxy::add_to_linker(&mut linker)?;
-
-    let mut store = Store::new(&ENGINE, ctx);
-
-    let (command, _instance) = Command::instantiate_async(&mut store, &component, &linker).await?;
-    Ok((store, command))
-}
-
-async fn run(name: &str, server: &Server) -> Result<()> {
-    let stdout = MemoryOutputPipe::new(4096);
-    let stderr = MemoryOutputPipe::new(4096);
-    let r = {
-        let table = Table::new();
-        let component = get_component(name);
-
-        // Create our wasi context.
-        let mut builder = WasiCtxBuilder::new();
-        builder.stdout(stdout.clone());
-        builder.stderr(stderr.clone());
-        builder.arg(name);
-        for (var, val) in test_programs::wasi_tests_environment() {
-            builder.env(var, val);
-        }
-        builder.env("HTTP_SERVER", server.addr());
-        let wasi = builder.build();
-        let http = WasiHttpCtx;
-
-        let (mut store, command) =
-            instantiate_component(component, Ctx { table, wasi, http }).await?;
-        command.wasi_cli_run().call_run(&mut store).await
-    };
-    r.map_err(move |trap: anyhow::Error| {
-        let stdout = stdout.try_into_inner().expect("single ref to stdout");
-        if !stdout.is_empty() {
-            println!("[guest] stdout:\n{}\n===", String::from_utf8_lossy(&stdout));
-        }
-        let stderr = stderr.try_into_inner().expect("single ref to stderr");
-        if !stderr.is_empty() {
-            println!("[guest] stderr:\n{}\n===", String::from_utf8_lossy(&stderr));
-        }
-        trap.context(format!(
-            "error while testing wasi-tests {} with http-components",
-            name
-        ))
-    })?
-    .map_err(|()| anyhow::anyhow!("run returned an error"))?;
-    Ok(())
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn outbound_request_get() -> Result<()> {
-    let server = Server::http1()?;
-    run("outbound_request_get", &server).await
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn outbound_request_post() -> Result<()> {
-    let server = Server::http1()?;
-    run("outbound_request_post", &server).await
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn outbound_request_large_post() -> Result<()> {
-    let server = Server::http1()?;
-    run("outbound_request_large_post", &server).await
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn outbound_request_put() -> Result<()> {
-    let server = Server::http1()?;
-    run("outbound_request_put", &server).await
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn outbound_request_invalid_version() -> Result<()> {
-    let server = Server::http2()?;
-    run("outbound_request_invalid_version", &server).await
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn outbound_request_unknown_method() -> Result<()> {
-    let server = Server::http1()?;
-    run("outbound_request_unknown_method", &server).await
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn outbound_request_unsupported_scheme() -> Result<()> {
-    let server = Server::http1()?;
-    run("outbound_request_unsupported_scheme", &server).await
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn outbound_request_invalid_port() -> Result<()> {
-    let server = Server::http1()?;
-    run("outbound_request_invalid_port", &server).await
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn outbound_request_invalid_dnsname() -> Result<()> {
-    let server = Server::http1()?;
-    run("outbound_request_invalid_dnsname", &server).await
-}
diff --git a/crates/test-programs/tests/wasi-http-proxy.rs b/crates/test-programs/tests/wasi-http-proxy.rs
deleted file mode 100644
index 65c07872de52..000000000000
--- a/crates/test-programs/tests/wasi-http-proxy.rs
+++ /dev/null
@@ -1,146 +0,0 @@
-#![cfg(all(feature = "test_programs", not(skip_wasi_http_tests)))]
-use anyhow::Context;
-use wasmtime::{
-    component::{Component, Linker},
-    Config, Engine, Store,
-};
-use wasmtime_wasi::preview2::{
-    self, pipe::MemoryOutputPipe, Table, WasiCtx, WasiCtxBuilder, WasiView,
-};
-use wasmtime_wasi_http::{proxy::Proxy, WasiHttpCtx, WasiHttpView};
-
-lazy_static::lazy_static! {
-    static ref ENGINE: Engine = {
-        let mut config = Config::new();
-        config.wasm_backtrace_details(wasmtime::WasmBacktraceDetails::Enable);
-        config.wasm_component_model(true);
-        config.async_support(true);
-        let engine = Engine::new(&config).unwrap();
-        engine
-    };
-}
-// uses ENGINE, creates a fn get_module(&str) -> Module
-include!(concat!(
-    env!("OUT_DIR"),
-    "/wasi_http_proxy_tests_components.rs"
-));
-
-struct Ctx {
-    table: Table,
-    wasi: WasiCtx,
-    http: WasiHttpCtx,
-}
-
-impl WasiView for Ctx {
-    fn table(&self) -> &Table {
-        &self.table
-    }
-    fn table_mut(&mut self) -> &mut Table {
-        &mut self.table
-    }
-    fn ctx(&self) -> &WasiCtx {
-        &self.wasi
-    }
-    fn ctx_mut(&mut self) -> &mut WasiCtx {
-        &mut self.wasi
-    }
-}
-
-impl WasiHttpView for Ctx {
-    fn table(&mut self) -> &mut Table {
-        &mut self.table
-    }
-    fn ctx(&mut self) -> &mut WasiHttpCtx {
-        &mut self.http
-    }
-}
-
-async fn instantiate(component: Component, ctx: Ctx) -> Result<(Store<Ctx>, Proxy), anyhow::Error> {
-    let mut linker = Linker::new(&ENGINE);
-    wasmtime_wasi_http::proxy::add_to_linker(&mut linker)?;
-
-    let mut store = Store::new(&ENGINE, ctx);
-
-    let (proxy, _instance) = Proxy::instantiate_async(&mut store, &component, &linker).await?;
-    Ok((store, proxy))
-}
-
-#[test_log::test(tokio::test)]
-async fn wasi_http_proxy_tests() -> anyhow::Result<()> {
-    let stdout = MemoryOutputPipe::new(4096);
-    let stderr = MemoryOutputPipe::new(4096);
-
-    let table = Table::new();
-    let component = get_component("wasi_http_proxy_tests");
-
-    // Create our wasi context.
-    let mut builder = WasiCtxBuilder::new();
-    builder.stdout(stdout.clone());
-    builder.stderr(stderr.clone());
-    for (var, val) in test_programs::wasi_tests_environment() {
-        builder.env(var, val);
-    }
-    let wasi = builder.build();
-    let http = WasiHttpCtx;
-
-    let ctx = Ctx { table, wasi, http };
-
-    let (mut store, proxy) = instantiate(component, ctx).await?;
-
-    let req = {
-        use http_body_util::{BodyExt, Empty};
-
-        let req = hyper::Request::builder().method(http::Method::GET).body(
-            Empty::<bytes::Bytes>::new()
-                .map_err(|e| anyhow::anyhow!(e))
-                .boxed(),
-        )?;
-        store.data_mut().new_incoming_request(req)?
-    };
-
-    let (sender, receiver) = tokio::sync::oneshot::channel();
-    let out = store.data_mut().new_response_outparam(sender)?;
-
-    let handle = preview2::spawn(async move {
-        proxy
-            .wasi_http_incoming_handler()
-            .call_handle(&mut store, req, out)
-            .await?;
-
-        Ok::<_, anyhow::Error>(())
-    });
-
-    let resp = match receiver.await {
-        Ok(Ok(resp)) => {
-            use http_body_util::BodyExt;
-            let (parts, body) = resp.into_parts();
-            let collected = BodyExt::collect(body).await?;
-            Ok(hyper::Response::from_parts(parts, collected))
-        }
-
-        Ok(Err(e)) => Err(e),
-
-        // This happens if the wasm never calls `set-response-outparam`
-        Err(e) => panic!("Failed to receive a response: {e:?}"),
-    };
-
-    // Now that the response has been processed, we can wait on the wasm to finish without
-    // deadlocking.
-    handle.await.context("Component execution")?;
-
-    let stdout = stdout.contents();
-    if !stdout.is_empty() {
-        println!("[guest] stdout:\n{}\n===", String::from_utf8_lossy(&stdout));
-    }
-    let stderr = stderr.contents();
-    if !stderr.is_empty() {
-        println!("[guest] stderr:\n{}\n===", String::from_utf8_lossy(&stderr));
-    }
-
-    match resp {
-        Ok(resp) => println!("response: {resp:?}"),
-        Err(e) => panic!("Error given in response: {e:?}"),
-    };
-
-    Ok(())
-}
diff --git a/crates/test-programs/tests/wasi-preview1-host-in-preview2.rs b/crates/test-programs/tests/wasi-preview1-host-in-preview2.rs
deleted file mode 100644
index 4086694d57d2..000000000000
--- a/crates/test-programs/tests/wasi-preview1-host-in-preview2.rs
+++ /dev/null
@@ -1,336 +0,0 @@
-#![cfg(feature = "test_programs")]
-use anyhow::Result;
-use tempfile::TempDir;
-use wasmtime::{Config, Engine, Linker, Store};
-use wasmtime_wasi::preview2::{
-    pipe::MemoryOutputPipe,
-    preview1::{add_to_linker_async, WasiPreview1Adapter, WasiPreview1View},
-    DirPerms, FilePerms, Table, WasiCtx, WasiCtxBuilder, WasiView,
-};
-
-lazy_static::lazy_static! {
-    static ref ENGINE: Engine = {
-        let mut config = Config::new();
-        config.wasm_backtrace_details(wasmtime::WasmBacktraceDetails::Enable);
-        config.wasm_component_model(true);
-        config.async_support(true);
-
-        let engine = Engine::new(&config).unwrap();
-        engine
-    };
-}
-// uses ENGINE, creates a fn get_module(&str) -> Module
-include!(concat!(env!("OUT_DIR"), "/wasi_tests_modules.rs"));
-
-pub fn prepare_workspace(exe_name: &str) -> Result<TempDir> {
-    let prefix = format!("wasi_components_{}_", exe_name);
-    let tempdir = tempfile::Builder::new().prefix(&prefix).tempdir()?;
-    Ok(tempdir)
-}
-
-async fn run(name: &str, inherit_stdio: bool) -> Result<()> {
-    let workspace = prepare_workspace(name)?;
-    let stdout = MemoryOutputPipe::new(4096);
-    let stderr = MemoryOutputPipe::new(4096);
-    let r = {
-        let mut linker = Linker::new(&ENGINE);
-        add_to_linker_async(&mut linker)?;
-
-        // Create our wasi context.
-        // Additionally register any preopened directories if we have them.
-        let mut builder = WasiCtxBuilder::new();
-
-        if inherit_stdio {
-            builder.inherit_stdio();
-        } else {
-            builder.stdout(stdout.clone()).stderr(stderr.clone());
-        }
-        builder.args(&[name, "."]);
-        println!("preopen: {:?}", workspace);
-        let preopen_dir =
-            cap_std::fs::Dir::open_ambient_dir(workspace.path(), cap_std::ambient_authority())?;
-        builder.preopened_dir(preopen_dir, DirPerms::all(), FilePerms::all(), ".");
-        for (var, val) in test_programs::wasi_tests_environment() {
-            builder.env(var, val);
-        }
-
-        let table = Table::new();
-        let wasi = builder.build();
-        struct Ctx {
-            wasi: WasiCtx,
-            table: Table,
-            adapter: WasiPreview1Adapter,
-        }
-        impl WasiView for Ctx {
-            fn ctx(&self) -> &WasiCtx {
-                &self.wasi
-            }
-            fn ctx_mut(&mut self) -> &mut WasiCtx {
-                &mut self.wasi
-            }
-            fn table(&self) -> &Table {
-                &self.table
-            }
-            fn table_mut(&mut self) -> &mut Table {
-                &mut self.table
-            }
-        }
-        impl WasiPreview1View for Ctx {
-            fn adapter(&self) -> &WasiPreview1Adapter {
-                &self.adapter
-            }
-            fn adapter_mut(&mut self) -> &mut WasiPreview1Adapter {
-                &mut self.adapter
-            }
-        }
-
-        let adapter = WasiPreview1Adapter::new();
-        let ctx = Ctx {
-            wasi,
-            table,
-            adapter,
-        };
-        let mut store = Store::new(&ENGINE, ctx);
-        let instance = linker
-            .instantiate_async(&mut store, &get_module(name))
-            .await?;
-        let start = instance.get_typed_func::<(), ()>(&mut store, "_start")?;
-        start.call_async(&mut store, ()).await?;
-        Ok(())
-    };
-
-    r.map_err(move |trap: anyhow::Error| {
-        let stdout = stdout.try_into_inner().expect("sole ref to stdout");
-        if !stdout.is_empty() {
-            println!("guest stdout:\n{}\n===", String::from_utf8_lossy(&stdout));
-        }
-        let stderr = stderr.try_into_inner().expect("sole ref to stderr");
-        if !stderr.is_empty() {
-            println!("guest stderr:\n{}\n===", String::from_utf8_lossy(&stderr));
-        }
-        trap.context(format!(
-            "error while testing wasi-tests {} with cap-std-sync",
-            name
-        ))
-    })?;
-    Ok(())
-}
-
-// Below here is mechanical: there should be one test for every binary in
-// wasi-tests. The only differences should be should_panic annotations for
-// tests which fail.
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn big_random_buf() {
-    run("big_random_buf", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn clock_time_get() {
-    run("clock_time_get", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn close_preopen() {
-    run("close_preopen", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn dangling_fd() {
-    run("dangling_fd", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn dangling_symlink() {
-    run("dangling_symlink", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn directory_seek() {
-    run("directory_seek", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn dir_fd_op_failures() {
-    run("dir_fd_op_failures", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn fd_advise() {
-    run("fd_advise", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn fd_filestat_get() {
-    run("fd_filestat_get", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn fd_filestat_set() {
-    run("fd_filestat_set", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn fd_flags_set() {
-    run("fd_flags_set", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn fd_readdir() {
-    run("fd_readdir", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn file_allocate() {
-    run("file_allocate", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn file_pread_pwrite() {
-    run("file_pread_pwrite", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn file_seek_tell() {
-    run("file_seek_tell", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn file_truncation() {
-    run("file_truncation", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn file_unbuffered_write() {
-    run("file_unbuffered_write", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-#[cfg_attr(windows, should_panic)]
-async fn interesting_paths() {
-    run("interesting_paths", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn regular_file_isatty() {
-    run("regular_file_isatty", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn nofollow_errors() {
-    run("nofollow_errors", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn overwrite_preopen() {
-    run("overwrite_preopen", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_exists() {
-    run("path_exists", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_filestat() {
-    run("path_filestat", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_link() {
-    run("path_link", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_open_create_existing() {
-    run("path_open_create_existing", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_open_read_write() {
-    run("path_open_read_write", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_open_dirfd_not_dir() {
-    run("path_open_dirfd_not_dir", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_open_missing() {
-    run("path_open_missing", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_open_nonblock() {
-    run("path_open_nonblock", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_rename_dir_trailing_slashes() {
-    run("path_rename_dir_trailing_slashes", false)
-        .await
-        .unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-#[should_panic]
-async fn path_rename_file_trailing_slashes() {
-    run("path_rename_file_trailing_slashes", false)
-        .await
-        .unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_rename() {
-    run("path_rename", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_symlink_trailing_slashes() {
-    run("path_symlink_trailing_slashes", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn poll_oneoff_files() {
-    run("poll_oneoff_files", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn poll_oneoff_stdio() {
-    run("poll_oneoff_stdio", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn readlink() {
-    run("readlink", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-#[should_panic]
-async fn remove_directory_trailing_slashes() {
-    run("remove_directory_trailing_slashes", false)
-        .await
-        .unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn remove_nonempty_directory() {
-    run("remove_nonempty_directory", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn renumber() {
-    run("renumber", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn sched_yield() {
-    run("sched_yield", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-#[should_panic]
-async fn sleep() {
-    run("sleep", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn stdio() {
-    run("stdio", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn stdio_isatty() {
-    // If the test process is setup such that stdio is a terminal:
-    if test_programs::stdio_is_terminal() {
-        // Inherit stdio, test asserts each is a tty:
-        run("stdio_isatty", true).await.unwrap()
-    }
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn stdio_not_isatty() {
-    // Don't inherit stdio, test asserts each is not tty:
-    run("stdio_not_isatty", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn symlink_create() {
-    run("symlink_create", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn symlink_filestat() {
-    run("symlink_filestat", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn symlink_loop() {
-    run("symlink_loop", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn unlink_file_trailing_slashes() {
-    run("unlink_file_trailing_slashes", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_open_preopen() {
-    run("path_open_preopen", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn unicode_output() {
-    run("unicode_output", true).await.unwrap()
-}
diff --git a/crates/test-programs/tests/wasi-preview2-components-sync.rs b/crates/test-programs/tests/wasi-preview2-components-sync.rs
deleted file mode 100644
index 9772f9c8473f..000000000000
--- a/crates/test-programs/tests/wasi-preview2-components-sync.rs
+++ /dev/null
@@ -1,316 +0,0 @@
-#![cfg(feature = "test_programs")]
-use anyhow::Result;
-use tempfile::TempDir;
-use wasmtime::{component::Linker, Config, Engine, Store};
-use wasmtime_wasi::preview2::{
-    command::sync::{add_to_linker, Command},
-    pipe::MemoryOutputPipe,
-    DirPerms, FilePerms, Table, WasiCtx, WasiCtxBuilder, WasiView,
-};
-
-lazy_static::lazy_static! {
-    static ref ENGINE: Engine = {
-        let mut config = Config::new();
-        config.wasm_backtrace_details(wasmtime::WasmBacktraceDetails::Enable);
-        config.wasm_component_model(true);
-        config.async_support(false);
-
-        let engine = Engine::new(&config).unwrap();
-        engine
-    };
-}
-// uses ENGINE, creates a fn get_component(&str) -> Component
-include!(concat!(env!("OUT_DIR"), "/wasi_tests_components.rs"));
-
-pub fn prepare_workspace(exe_name: &str) -> Result<TempDir> {
-    let prefix = format!("wasi_components_{}_", exe_name);
-    let tempdir = tempfile::Builder::new().prefix(&prefix).tempdir()?;
-    Ok(tempdir)
-}
-
-fn run(name: &str, inherit_stdio: bool) -> Result<()> {
-    let workspace = prepare_workspace(name)?;
-    let stdout = MemoryOutputPipe::new(4096);
-    let stderr = MemoryOutputPipe::new(4096);
-    let r = {
-        let mut linker = Linker::new(&ENGINE);
-        add_to_linker(&mut linker)?;
-
-        // Create our wasi context.
-        // Additionally register any preopened directories if we have them.
-        let mut builder = WasiCtxBuilder::new();
-
-        if inherit_stdio {
-            builder.inherit_stdio();
-        } else {
-            builder.stdout(stdout.clone()).stderr(stderr.clone());
-        }
-        builder.args(&[name, "."]);
-        println!("preopen: {:?}", workspace);
-        let preopen_dir =
-            cap_std::fs::Dir::open_ambient_dir(workspace.path(), cap_std::ambient_authority())?;
-        builder.preopened_dir(preopen_dir, DirPerms::all(), FilePerms::all(), ".");
-        for (var, val) in test_programs::wasi_tests_environment() {
-            builder.env(var, val);
-        }
-
-        let table = Table::new();
-        let wasi = builder.build();
-        struct Ctx {
-            wasi: WasiCtx,
-            table: Table,
-        }
-        impl WasiView for Ctx {
-            fn ctx(&self) -> &WasiCtx {
-                &self.wasi
-            }
-            fn ctx_mut(&mut self) -> &mut WasiCtx {
-                &mut self.wasi
-            }
-            fn table(&self) -> &Table {
-                &self.table
-            }
-            fn table_mut(&mut self) -> &mut Table {
-                &mut self.table
-            }
-        }
-
-        let ctx = Ctx { wasi, table };
-        let mut store = Store::new(&ENGINE, ctx);
-        let (command, _instance) = Command::instantiate(&mut store, &get_component(name), &linker)?;
-        command
-            .wasi_cli_run()
-            .call_run(&mut store)?
-            .map_err(|()| anyhow::anyhow!("run returned a failure"))?;
-        Ok(())
-    };
-
-    r.map_err(move |trap: anyhow::Error| {
-        let stdout = stdout.try_into_inner().expect("single ref to stdout");
-        if !stdout.is_empty() {
-            println!("guest stdout:\n{}\n===", String::from_utf8_lossy(&stdout));
-        }
-        let stderr = stderr.try_into_inner().expect("single ref to stderr");
-        if !stderr.is_empty() {
-            println!("guest stderr:\n{}\n===", String::from_utf8_lossy(&stderr));
-        }
-        trap.context(format!(
-            "error while testing wasi-tests {} with cap-std-sync",
-            name
-        ))
-    })?;
-    Ok(())
-}
-
-// Below here is mechanical: there should be one test for every binary in
-// wasi-tests. The only differences should be should_panic annotations for
-// tests which fail.
-#[test_log::test]
-fn big_random_buf() {
-    run("big_random_buf", false).unwrap()
-}
-#[test_log::test]
-fn clock_time_get() {
-    run("clock_time_get", false).unwrap()
-}
-#[test_log::test]
-fn close_preopen() {
-    run("close_preopen", false).unwrap()
-}
-#[test_log::test]
-fn dangling_fd() {
-    run("dangling_fd", false).unwrap()
-}
-#[test_log::test]
-fn dangling_symlink() {
-    run("dangling_symlink", false).unwrap()
-}
-#[test_log::test]
-fn directory_seek() {
-    run("directory_seek", false).unwrap()
-}
-#[test_log::test]
-fn dir_fd_op_failures() {
-    run("dir_fd_op_failures", false).unwrap()
-}
-#[test_log::test]
-fn fd_advise() {
-    run("fd_advise", false).unwrap()
-}
-#[test_log::test]
-fn fd_filestat_get() {
-    run("fd_filestat_get", false).unwrap()
-}
-#[test_log::test]
-fn fd_filestat_set() {
-    run("fd_filestat_set", false).unwrap()
-}
-#[test_log::test]
-fn fd_flags_set() {
-    run("fd_flags_set", false).unwrap()
-}
-#[test_log::test]
-fn fd_readdir() {
-    run("fd_readdir", false).unwrap()
-}
-#[test_log::test]
-fn file_allocate() {
-    run("file_allocate", false).unwrap()
-}
-#[test_log::test]
-fn file_pread_pwrite() {
-    run("file_pread_pwrite", false).unwrap()
-}
-#[test_log::test]
-fn file_seek_tell() {
-    run("file_seek_tell", false).unwrap()
-}
-#[test_log::test]
-fn file_truncation() {
-    run("file_truncation", false).unwrap()
-}
-#[test_log::test]
-fn file_unbuffered_write() {
-    run("file_unbuffered_write", false).unwrap()
-}
-#[test_log::test]
-#[cfg_attr(windows, should_panic)]
-fn interesting_paths() {
-    run("interesting_paths", false).unwrap()
-}
-#[test_log::test]
-fn regular_file_isatty() {
-    run("regular_file_isatty", false).unwrap()
-}
-#[test_log::test]
-fn nofollow_errors() {
-    run("nofollow_errors", false).unwrap()
-}
-#[test_log::test]
-fn overwrite_preopen() {
-    run("overwrite_preopen", false).unwrap()
-}
-#[test_log::test]
-fn path_exists() {
-    run("path_exists", false).unwrap()
-}
-#[test_log::test]
-fn path_filestat() {
-    run("path_filestat", false).unwrap()
-}
-#[test_log::test]
-fn path_link() {
-    run("path_link", false).unwrap()
-}
-#[test_log::test]
-fn path_open_create_existing() {
-    run("path_open_create_existing", false).unwrap()
-}
-#[test_log::test]
-fn path_open_read_write() {
-    run("path_open_read_write", false).unwrap()
-}
-#[test_log::test]
-fn path_open_dirfd_not_dir() {
-    run("path_open_dirfd_not_dir", false).unwrap()
-}
-#[test_log::test]
-fn path_open_missing() {
-    run("path_open_missing", false).unwrap()
-}
-#[test_log::test]
-fn path_open_nonblock() {
-    run("path_open_nonblock", false).unwrap()
-}
-#[test_log::test]
-fn path_rename_dir_trailing_slashes() {
-    run("path_rename_dir_trailing_slashes", false).unwrap()
-}
-#[test_log::test]
-#[should_panic]
-fn path_rename_file_trailing_slashes() {
-    run("path_rename_file_trailing_slashes", false).unwrap()
-}
-#[test_log::test]
-fn path_rename() {
-    run("path_rename", false).unwrap()
-}
-#[test_log::test]
-fn path_symlink_trailing_slashes() {
-    run("path_symlink_trailing_slashes", false).unwrap()
-}
-#[test_log::test]
-fn poll_oneoff_files() {
-    run("poll_oneoff_files", false).unwrap()
-}
-
-#[test_log::test]
-fn poll_oneoff_stdio() {
-    run("poll_oneoff_stdio", true).unwrap()
-}
-#[test_log::test]
-fn readlink() {
-    run("readlink", false).unwrap()
-}
-#[test_log::test]
-#[should_panic]
-fn remove_directory_trailing_slashes() {
-    run("remove_directory_trailing_slashes", false).unwrap()
-}
-#[test_log::test]
-fn remove_nonempty_directory() {
-    run("remove_nonempty_directory", false).unwrap()
-}
-#[test_log::test]
-fn renumber() {
-    run("renumber", false).unwrap()
-}
-#[test_log::test]
-fn sched_yield() {
-    run("sched_yield", false).unwrap()
-}
-#[test_log::test]
-fn sleep() {
-    run("sleep", false).unwrap()
-}
-#[test_log::test]
-fn stdio() {
-    run("stdio", false).unwrap()
-}
-#[test_log::test]
-fn stdio_isatty() {
-    // If the test process is setup such that stdio is a terminal:
-    if test_programs::stdio_is_terminal() {
-        // Inherit stdio, test asserts each is a tty:
-        run("stdio_isatty", true).unwrap()
-    }
-}
-#[test_log::test]
-fn stdio_not_isatty() {
-    // Don't inherit stdio, test asserts not isatty:
-    run("stdio_not_isatty", false).unwrap()
-}
-#[test_log::test]
-fn symlink_create() {
-    run("symlink_create", false).unwrap()
-}
-#[test_log::test]
-fn symlink_filestat() {
-    run("symlink_filestat", false).unwrap()
-}
-#[test_log::test]
-fn symlink_loop() {
-    run("symlink_loop", false).unwrap()
-}
-#[test_log::test]
-fn unlink_file_trailing_slashes() {
-    run("unlink_file_trailing_slashes", false).unwrap()
-}
-#[test_log::test]
-fn path_open_preopen() {
-    run("path_open_preopen", false).unwrap()
-}
-#[test_log::test]
-fn unicode_output() {
-    run("unicode_output", true).unwrap()
-}
diff --git a/crates/test-programs/tests/wasi-preview2-components.rs b/crates/test-programs/tests/wasi-preview2-components.rs
deleted file mode 100644
index a2b30ed0d346..000000000000
--- a/crates/test-programs/tests/wasi-preview2-components.rs
+++ /dev/null
@@ -1,324 +0,0 @@
-#![cfg(feature = "test_programs")]
-use anyhow::Result;
-use tempfile::TempDir;
-use wasmtime::{component::Linker, Config, Engine, Store};
-use wasmtime_wasi::preview2::{
-    command::{add_to_linker, Command},
-    pipe::MemoryOutputPipe,
-    DirPerms, FilePerms, Table, WasiCtx, WasiCtxBuilder, WasiView,
-};
-
-lazy_static::lazy_static! {
-    static ref ENGINE: Engine = {
-        let mut config = Config::new();
-        config.wasm_backtrace_details(wasmtime::WasmBacktraceDetails::Enable);
-        config.wasm_component_model(true);
-        config.async_support(true);
-
-        let engine = Engine::new(&config).unwrap();
-        engine
-    };
-}
-// uses ENGINE, creates a fn get_component(&str) -> Component
-include!(concat!(env!("OUT_DIR"), "/wasi_tests_components.rs"));
-
-pub fn prepare_workspace(exe_name: &str) -> Result<TempDir> {
-    let prefix = format!("wasi_components_{}_", exe_name);
-    let tempdir = tempfile::Builder::new().prefix(&prefix).tempdir()?;
-    Ok(tempdir)
-}
-
-async fn run(name: &str, inherit_stdio: bool) -> Result<()> {
-    let workspace = prepare_workspace(name)?;
-    let stdout = MemoryOutputPipe::new(4096);
-    let stderr = MemoryOutputPipe::new(4096);
-    let r = {
-        let mut linker = Linker::new(&ENGINE);
-        add_to_linker(&mut linker)?;
-
-        // Create our wasi context.
-        // Additionally register any preopened directories if we have them.
-        let mut builder = WasiCtxBuilder::new();
-
-        if inherit_stdio {
-            builder.inherit_stdio();
-        } else {
-            builder.stdout(stdout.clone()).stderr(stderr.clone());
-        }
-        builder.args(&[name, "."]);
-        println!("preopen: {:?}", workspace);
-        let preopen_dir =
-            cap_std::fs::Dir::open_ambient_dir(workspace.path(), cap_std::ambient_authority())?;
-        builder.preopened_dir(preopen_dir, DirPerms::all(), FilePerms::all(), ".");
-        for (var, val) in test_programs::wasi_tests_environment() {
-            builder.env(var, val);
-        }
-
-        let table = Table::new();
-        let wasi = builder.build();
-        struct Ctx {
-            wasi: WasiCtx,
-            table: Table,
-        }
-        impl WasiView for Ctx {
-            fn ctx(&self) -> &WasiCtx {
-                &self.wasi
-            }
-            fn ctx_mut(&mut self) -> &mut WasiCtx {
-                &mut self.wasi
-            }
-            fn table(&self) -> &Table {
-                &self.table
-            }
-            fn table_mut(&mut self) -> &mut Table {
-                &mut self.table
-            }
-        }
-
-        let ctx = Ctx { wasi, table };
-        let mut store = Store::new(&ENGINE, ctx);
-        let (command, _instance) =
-            Command::instantiate_async(&mut store, &get_component(name), &linker).await?;
-        command
-            .wasi_cli_run()
-            .call_run(&mut store)
-            .await?
-            .map_err(|()| anyhow::anyhow!("run returned a failure"))?;
-        Ok(())
-    };
-
-    r.map_err(move |trap: anyhow::Error| {
-        let stdout = stdout.try_into_inner().expect("single ref to stdout");
-        if !stdout.is_empty() {
-            println!("guest stdout:\n{}\n===", String::from_utf8_lossy(&stdout));
-        }
-        let stderr = stderr.try_into_inner().expect("single ref to stderr");
-        if !stderr.is_empty() {
-            println!("guest stderr:\n{}\n===", String::from_utf8_lossy(&stderr));
-        }
-        trap.context(format!(
-            "error while testing wasi-tests {} with cap-std-sync",
-            name
-        ))
-    })?;
-    Ok(())
-}
-
-// Below here is mechanical: there should be one test for every binary in
-// wasi-tests. The only differences should be should_panic annotations for
-// tests which fail.
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn big_random_buf() {
-    run("big_random_buf", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn clock_time_get() {
-    run("clock_time_get", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn close_preopen() {
-    run("close_preopen", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn dangling_fd() {
-    run("dangling_fd", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn dangling_symlink() {
-    run("dangling_symlink", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn directory_seek() {
-    run("directory_seek", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn dir_fd_op_failures() {
-    run("dir_fd_op_failures", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn fd_advise() {
-    run("fd_advise", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn fd_filestat_get() {
-    run("fd_filestat_get", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn fd_filestat_set() {
-    run("fd_filestat_set", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn fd_flags_set() {
-    run("fd_flags_set", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn fd_readdir() {
-    run("fd_readdir", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn file_allocate() {
-    run("file_allocate", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn file_pread_pwrite() {
-    run("file_pread_pwrite", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn file_seek_tell() {
-    run("file_seek_tell", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn file_truncation() {
-    run("file_truncation", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn file_unbuffered_write() {
-    run("file_unbuffered_write", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-#[cfg_attr(windows, should_panic)]
-async fn interesting_paths() {
-    run("interesting_paths", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn regular_file_isatty() {
-    run("regular_file_isatty", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn nofollow_errors() {
-    run("nofollow_errors", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn overwrite_preopen() {
-    run("overwrite_preopen", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_exists() {
-    run("path_exists", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_filestat() {
-    run("path_filestat", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_link() {
-    run("path_link", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_open_create_existing() {
-    run("path_open_create_existing", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_open_read_write() {
-    run("path_open_read_write", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_open_dirfd_not_dir() {
-    run("path_open_dirfd_not_dir", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_open_missing() {
-    run("path_open_missing", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_open_nonblock() {
-    run("path_open_nonblock", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_rename_dir_trailing_slashes() {
-    run("path_rename_dir_trailing_slashes", false)
-        .await
-        .unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-#[should_panic]
-async fn path_rename_file_trailing_slashes() {
-    run("path_rename_file_trailing_slashes", false)
-        .await
-        .unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_rename() {
-    run("path_rename", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_symlink_trailing_slashes() {
-    run("path_symlink_trailing_slashes", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn poll_oneoff_files() {
-    run("poll_oneoff_files", false).await.unwrap()
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn poll_oneoff_stdio() {
-    run("poll_oneoff_stdio", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn readlink() {
-    run("readlink", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-#[should_panic]
-async fn remove_directory_trailing_slashes() {
-    run("remove_directory_trailing_slashes", false)
-        .await
-        .unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn remove_nonempty_directory() {
-    run("remove_nonempty_directory", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn renumber() {
-    run("renumber", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn sched_yield() {
-    run("sched_yield", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn sleep() {
-    run("sleep", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn stdio() {
-    run("stdio", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn stdio_isatty() {
-    // If the test process is setup such that stdio is a terminal:
-    if test_programs::stdio_is_terminal() {
-        // Inherit stdio, test asserts each is not tty:
-        run("stdio_isatty", true).await.unwrap()
-    }
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn stdio_not_isatty() {
-    // Don't inherit stdio, test asserts each is not tty:
-    run("stdio_not_isatty", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn symlink_create() {
-    run("symlink_create", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn symlink_filestat() {
-    run("symlink_filestat", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn symlink_loop() {
-    run("symlink_loop", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn unlink_file_trailing_slashes() {
-    run("unlink_file_trailing_slashes", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_open_preopen() {
-    run("path_open_preopen", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn unicode_output() {
-    run("unicode_output", true).await.unwrap()
-}
diff --git a/crates/test-programs/tests/wasi-sockets.rs b/crates/test-programs/tests/wasi-sockets.rs
deleted file mode 100644
index 8484a4f98f77..000000000000
--- a/crates/test-programs/tests/wasi-sockets.rs
+++ /dev/null
@@ -1,82 +0,0 @@
-#![cfg(all(feature = "test_programs", not(skip_wasi_sockets_tests)))]
-use cap_std::ambient_authority;
-use wasmtime::component::Linker;
-use wasmtime::{Config, Engine, Store};
-use wasmtime_wasi::preview2::{self, command::Command, Table, WasiCtx, WasiCtxBuilder, WasiView};
-
-lazy_static::lazy_static! {
-    static ref ENGINE: Engine = {
-        let mut config = Config::new();
-        config.wasm_backtrace_details(wasmtime::WasmBacktraceDetails::Enable);
-        config.wasm_component_model(true);
-        config.async_support(true);
-
-        let engine = Engine::new(&config).unwrap();
-        engine
-    };
-}
-// uses ENGINE, creates a fn get_component(&str) -> Component
-include!(concat!(
-    env!("OUT_DIR"),
-    "/wasi_sockets_tests_components.rs"
-));
-
-struct SocketsCtx {
-    table: Table,
-    wasi: WasiCtx,
-}
-
-impl WasiView for SocketsCtx {
-    fn table(&self) -> &Table {
-        &self.table
-    }
-    fn table_mut(&mut self) -> &mut Table {
-        &mut self.table
-    }
-    fn ctx(&self) -> &WasiCtx {
-        &self.wasi
-    }
-    fn ctx_mut(&mut self) -> &mut WasiCtx {
-        &mut self.wasi
-    }
-}
-
-async fn run(name: &str) -> anyhow::Result<()> {
-    let component = get_component(name);
-    let mut linker = Linker::new(&ENGINE);
-
-    preview2::command::add_to_linker(&mut linker)?;
-
-    // Create our wasi context.
-    let table = Table::new();
-    let wasi = WasiCtxBuilder::new()
-        .inherit_stdio()
-        .inherit_network(ambient_authority())
-        .allow_ip_name_lookup(true)
-        .arg(name)
-        .build();
-
-    let mut store = Store::new(&ENGINE, SocketsCtx { table, wasi });
-
-    let (command, _instance) = Command::instantiate_async(&mut store, &component, &linker).await?;
-    command
-        .wasi_cli_run()
-        .call_run(&mut store)
-        .await?
-        .map_err(|()| anyhow::anyhow!("command returned with failing exit status"))
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn tcp_v4() {
-    run("tcp_v4").await.unwrap();
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn tcp_v6() {
-    run("tcp_v6").await.unwrap();
-}
-
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn ip_name_lookup() {
-    run("ip_name_lookup").await.unwrap();
-}
diff --git a/crates/test-programs/tests/wasi-tokio.rs b/crates/test-programs/tests/wasi-tokio.rs
deleted file mode 100644
index 49280d2abefc..000000000000
--- a/crates/test-programs/tests/wasi-tokio.rs
+++ /dev/null
@@ -1,303 +0,0 @@
-#![cfg(feature = "test_programs")]
-use anyhow::Result;
-use tempfile::TempDir;
-use wasi_common::pipe::WritePipe;
-use wasmtime::{Config, Engine, Linker, Store};
-use wasmtime_wasi::tokio::{add_to_linker, WasiCtxBuilder};
-
-lazy_static::lazy_static! {
-    static ref ENGINE: Engine = {
-        let mut config = Config::new();
-        config.wasm_backtrace_details(wasmtime::WasmBacktraceDetails::Enable);
-        config.wasm_component_model(false);
-        config.async_support(true);
-
-        let engine = Engine::new(&config).unwrap();
-        engine
-    };
-}
-// uses ENGINE, creates a fn get_module(&str) -> Module
-include!(concat!(env!("OUT_DIR"), "/wasi_tests_modules.rs"));
-
-pub fn prepare_workspace(exe_name: &str) -> Result<TempDir> {
-    let prefix = format!("wasi_tokio_{}_", exe_name);
-    let tempdir = tempfile::Builder::new().prefix(&prefix).tempdir()?;
-    Ok(tempdir)
-}
-
-async fn run(name: &str, inherit_stdio: bool) -> Result<()> {
-    let workspace = prepare_workspace(name)?;
-    let stdout = WritePipe::new_in_memory();
-    let stderr = WritePipe::new_in_memory();
-    let r = {
-        let mut linker = Linker::new(&ENGINE);
-        add_to_linker(&mut linker, |cx| cx)?;
-
-        // Create our wasi context.
-        // Additionally register any preopened directories if we have them.
-        let mut builder = WasiCtxBuilder::new();
-
-        if inherit_stdio {
-            builder.inherit_stdio();
-        } else {
-            builder
-                .stdout(Box::new(stdout.clone()))
-                .stderr(Box::new(stderr.clone()));
-        }
-        builder.arg(name)?.arg(".")?;
-        println!("preopen: {:?}", workspace);
-        let preopen_dir =
-            cap_std::fs::Dir::open_ambient_dir(workspace.path(), cap_std::ambient_authority())?;
-        builder.preopened_dir(preopen_dir, ".")?;
-        for (var, val) in test_programs::wasi_tests_environment() {
-            builder.env(var, val)?;
-        }
-
-        let mut store = Store::new(&ENGINE, builder.build());
-        let instance = linker
-            .instantiate_async(&mut store, &get_module(name))
-            .await?;
-        let start = instance.get_typed_func::<(), ()>(&mut store, "_start")?;
-        start.call_async(&mut store, ()).await?;
-        Ok(())
-    };
-
-    r.map_err(move |trap: anyhow::Error| {
-        let stdout = stdout
-            .try_into_inner()
-            .expect("sole ref to stdout")
-            .into_inner();
-        if !stdout.is_empty() {
-            println!("guest stdout:\n{}\n===", String::from_utf8_lossy(&stdout));
-        }
-        let stderr = stderr
-            .try_into_inner()
-            .expect("sole ref to stderr")
-            .into_inner();
-        if !stderr.is_empty() {
-            println!("guest stderr:\n{}\n===", String::from_utf8_lossy(&stderr));
-        }
-        trap.context(format!(
-            "error while testing wasi-tests {} with cap-std-sync",
-            name
-        ))
-    })?;
-    Ok(())
-}
-
-// Below here is mechanical: there should be one test for every binary in
-// wasi-tests. The only differences should be should_panic annotations for
-// tests which fail.
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn big_random_buf() {
-    run("big_random_buf", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn clock_time_get() {
-    run("clock_time_get", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn close_preopen() {
-    run("close_preopen", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn dangling_fd() {
-    run("dangling_fd", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn dangling_symlink() {
-    run("dangling_symlink", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn directory_seek() {
-    run("directory_seek", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn dir_fd_op_failures() {
-    run("dir_fd_op_failures", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn fd_advise() {
-    run("fd_advise", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn fd_filestat_get() {
-    run("fd_filestat_get", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn fd_filestat_set() {
-    run("fd_filestat_set", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn fd_flags_set() {
-    run("fd_flags_set", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn fd_readdir() {
-    run("fd_readdir", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn file_allocate() {
-    run("file_allocate", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn file_pread_pwrite() {
-    run("file_pread_pwrite", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn file_seek_tell() {
-    run("file_seek_tell", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn file_truncation() {
-    run("file_truncation", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn file_unbuffered_write() {
-    run("file_unbuffered_write", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-#[cfg_attr(windows, should_panic)]
-async fn interesting_paths() {
-    run("interesting_paths", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn regular_file_isatty() {
-    run("regular_file_isatty", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn nofollow_errors() {
-    run("nofollow_errors", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn overwrite_preopen() {
-    run("overwrite_preopen", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_exists() {
-    run("path_exists", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_filestat() {
-    run("path_filestat", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_link() {
-    run("path_link", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_open_create_existing() {
-    run("path_open_create_existing", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_open_read_write() {
-    run("path_open_read_write", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_open_dirfd_not_dir() {
-    run("path_open_dirfd_not_dir", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_open_missing() {
-    run("path_open_missing", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_open_nonblock() {
-    run("path_open_nonblock", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_rename_dir_trailing_slashes() {
-    run("path_rename_dir_trailing_slashes", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-#[should_panic]
-async fn path_rename_file_trailing_slashes() {
-    run("path_rename_file_trailing_slashes", false)
-        .await
-        .unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_rename() {
-    run("path_rename", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_symlink_trailing_slashes() {
-    run("path_symlink_trailing_slashes", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn poll_oneoff_files() {
-    run("poll_oneoff_files", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn poll_oneoff_stdio() {
-    run("poll_oneoff_stdio", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn readlink() {
-    run("readlink", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-#[should_panic]
-async fn remove_directory_trailing_slashes() {
-    run("remove_directory_trailing_slashes", false)
-        .await
-        .unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn remove_nonempty_directory() {
-    run("remove_nonempty_directory", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn renumber() {
-    run("renumber", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn sched_yield() {
-    run("sched_yield", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-#[should_panic]
-async fn sleep() {
-    run("sleep", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn stdio() {
-    run("stdio", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn stdio_isatty() {
-    // Only a valid test if the host executable's stdio is a terminal:
-    if test_programs::stdio_is_terminal() {
-        // Inherit stdio, test asserts it is a tty:
-        run("stdio_isatty", true).await.unwrap()
-    }
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn stdio_not_isatty() {
-    // Don't inherit stdio, test asserts each is not tty:
-    run("stdio_not_isatty", false).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn symlink_create() {
-    run("symlink_create", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn symlink_filestat() {
-    run("symlink_filestat", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn symlink_loop() {
-    run("symlink_loop", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn unlink_file_trailing_slashes() {
-    run("unlink_file_trailing_slashes", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn path_open_preopen() {
-    run("path_open_preopen", true).await.unwrap()
-}
-#[test_log::test(tokio::test(flavor = "multi_thread"))]
-async fn unicode_output() {
-    run("unicode_output", true).await.unwrap()
-}
diff --git a/crates/test-programs/wasi-http-proxy-tests/Cargo.toml b/crates/test-programs/wasi-http-proxy-tests/Cargo.toml
deleted file mode 100644
index fc87dc1bce7d..000000000000
--- a/crates/test-programs/wasi-http-proxy-tests/Cargo.toml
+++ /dev/null
@@ -1,12 +0,0 @@
-[package]
-name = "wasi-http-proxy-tests"
-version = "0.0.0"
-readme = "README.md"
-edition = "2021"
-publish = false
-
-[lib]
-crate-type=["cdylib"]
-
-[dependencies]
-wit-bindgen = { workspace = true, features = ["macros", "realloc"] }
diff --git a/crates/test-programs/wasi-http-proxy-tests/src/lib.rs b/crates/test-programs/wasi-http-proxy-tests/src/lib.rs
deleted file mode 100644
index 65c7db9168c6..000000000000
--- a/crates/test-programs/wasi-http-proxy-tests/src/lib.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-pub mod bindings {
-    use super::T;
-
-    wit_bindgen::generate!({
-        path: "../../wasi-http/wit",
-        world: "wasi:http/proxy",
-        exports: {
-            "wasi:http/incoming-handler": T,
-        },
-    });
-}
-
-use bindings::wasi::http::types::{IncomingRequest, ResponseOutparam};
-
-struct T;
-
-impl bindings::exports::wasi::http::incoming_handler::Guest for T {
-    fn handle(_request: IncomingRequest, outparam: ResponseOutparam) {
-        let hdrs = bindings::wasi::http::types::Headers::new(&[]);
-        let resp = bindings::wasi::http::types::OutgoingResponse::new(200, hdrs);
-        let body = resp.write().expect("outgoing response");
-
-        bindings::wasi::http::types::ResponseOutparam::set(outparam, Ok(resp));
-
-        let out = body.write().expect("outgoing stream");
-        out.blocking_write_and_flush(b"hello, world!")
-            .expect("writing response");
-
-        drop(out);
-        bindings::wasi::http::types::OutgoingBody::finish(body, None);
-    }
-}
diff --git a/crates/test-programs/wasi-http-tests/Cargo.toml b/crates/test-programs/wasi-http-tests/Cargo.toml
deleted file mode 100644
index 14206c3bbaa4..000000000000
--- a/crates/test-programs/wasi-http-tests/Cargo.toml
+++ /dev/null
@@ -1,12 +0,0 @@
-[package]
-name = "wasi-http-tests"
-version = "0.0.0"
-readme = "README.md"
-edition = "2021"
-publish = false
-
-[dependencies]
-anyhow = { workspace = true }
-wit-bindgen = { workspace = true, default-features = false, features = [
-    "macros",
-] }
diff --git a/crates/test-programs/wasi-http-tests/src/bin/outbound_request_get.rs b/crates/test-programs/wasi-http-tests/src/bin/outbound_request_get.rs
deleted file mode 100644
index 25d71c662ca7..000000000000
--- a/crates/test-programs/wasi-http-tests/src/bin/outbound_request_get.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-use anyhow::Context;
-use wasi_http_tests::bindings::wasi::http::types::{Method, Scheme};
-
-fn main() {
-    let addr = std::env::var("HTTP_SERVER").unwrap();
-    let res = wasi_http_tests::request(
-        Method::Get,
-        Scheme::Http,
-        &addr,
-        "/get?some=arg&goes=here",
-        None,
-        None,
-    )
-    .context("/get")
-    .unwrap();
-
-    println!("{addr} /get: {res:?}");
-    assert_eq!(res.status, 200);
-    let method = res.header("x-wasmtime-test-method").unwrap();
-    assert_eq!(std::str::from_utf8(method).unwrap(), "GET");
-    let uri = res.header("x-wasmtime-test-uri").unwrap();
-    assert_eq!(
-        std::str::from_utf8(uri).unwrap(),
-        format!("http://{addr}/get?some=arg&goes=here")
-    );
-    assert_eq!(res.body, b"");
-}
diff --git a/crates/test-programs/wasi-http-tests/src/bin/outbound_request_invalid_dnsname.rs b/crates/test-programs/wasi-http-tests/src/bin/outbound_request_invalid_dnsname.rs
deleted file mode 100644
index a36e5384336e..000000000000
--- a/crates/test-programs/wasi-http-tests/src/bin/outbound_request_invalid_dnsname.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-use wasi_http_tests::bindings::wasi::http::types::{Method, Scheme};
-
-fn main() {
-    let res = wasi_http_tests::request(
-        Method::Get,
-        Scheme::Http,
-        "some.invalid.dnsname:3000",
-        "/",
-        None,
-        None,
-    );
-
-    let error = res.unwrap_err().to_string();
-    assert!(
-        error.starts_with("Error::InvalidUrl(\""),
-        "bad error: {error}"
-    );
-}
diff --git a/crates/test-programs/wasi-http-tests/src/bin/outbound_request_invalid_port.rs b/crates/test-programs/wasi-http-tests/src/bin/outbound_request_invalid_port.rs
deleted file mode 100644
index fe0290a30d21..000000000000
--- a/crates/test-programs/wasi-http-tests/src/bin/outbound_request_invalid_port.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-use wasi_http_tests::bindings::wasi::http::types::{Method, Scheme};
-
-fn main() {
-    let res = wasi_http_tests::request(
-        Method::Get,
-        Scheme::Http,
-        "localhost:99999",
-        "/",
-        None,
-        None,
-    );
-
-    let error = res.unwrap_err();
-    assert_eq!(
-        error.to_string(),
-        "Error::InvalidUrl(\"invalid port value\")"
-    );
-}
diff --git a/crates/test-programs/wasi-http-tests/src/bin/outbound_request_invalid_version.rs b/crates/test-programs/wasi-http-tests/src/bin/outbound_request_invalid_version.rs
deleted file mode 100644
index c61bfeab1b32..000000000000
--- a/crates/test-programs/wasi-http-tests/src/bin/outbound_request_invalid_version.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-use wasi_http_tests::bindings::wasi::http::types::{Method, Scheme};
-
-fn main() {
-    let addr = std::env::var("HTTP_SERVER").unwrap();
-    let res = wasi_http_tests::request(Method::Connect, Scheme::Http, &addr, "/", None, Some(&[]));
-
-    let error = res.unwrap_err().to_string();
-    if !error.starts_with("Error::ProtocolError(\"") {
-        panic!(
-            r#"assertion failed: `(left == right)`
-      left: `"{error}"`,
-      right: `"Error::ProtocolError(\"invalid HTTP version parsed\")"`
-            or `"Error::ProtocolError(\"operation was canceled\")"`)"#
-        )
-    }
-}
diff --git a/crates/test-programs/wasi-http-tests/src/bin/outbound_request_large_post.rs b/crates/test-programs/wasi-http-tests/src/bin/outbound_request_large_post.rs
deleted file mode 100644
index e5620910fd17..000000000000
--- a/crates/test-programs/wasi-http-tests/src/bin/outbound_request_large_post.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-use anyhow::Context;
-use std::io::{self, Read};
-use wasi_http_tests::bindings::wasi::http::types::{Method, Scheme};
-
-fn main() {
-    // TODO: ensure more than 700 bytes is allowed without error
-    const LEN: usize = 700;
-    let mut buffer = [0; LEN];
-    let addr = std::env::var("HTTP_SERVER").unwrap();
-    io::repeat(0b001).read_exact(&mut buffer).unwrap();
-    let res = wasi_http_tests::request(
-        Method::Post,
-        Scheme::Http,
-        &addr,
-        "/post",
-        Some(&buffer),
-        None,
-    )
-    .context("/post large")
-    .unwrap();
-
-    println!("/post large: {}", res.status);
-    assert_eq!(res.status, 200);
-    let method = res.header("x-wasmtime-test-method").unwrap();
-    assert_eq!(std::str::from_utf8(method).unwrap(), "POST");
-    assert_eq!(res.body.len(), LEN);
-}
diff --git a/crates/test-programs/wasi-http-tests/src/bin/outbound_request_post.rs b/crates/test-programs/wasi-http-tests/src/bin/outbound_request_post.rs
deleted file mode 100644
index 6fa0e9ad02df..000000000000
--- a/crates/test-programs/wasi-http-tests/src/bin/outbound_request_post.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-use anyhow::Context;
-use wasi_http_tests::bindings::wasi::http::types::{Method, Scheme};
-
-fn main() {
-    let addr = std::env::var("HTTP_SERVER").unwrap();
-    let res = wasi_http_tests::request(
-        Method::Post,
-        Scheme::Http,
-        &addr,
-        "/post",
-        Some(b"{\"foo\": \"bar\"}"),
-        None,
-    )
-    .context("/post")
-    .unwrap();
-
-    println!("/post: {res:?}");
-    assert_eq!(res.status, 200);
-    let method = res.header("x-wasmtime-test-method").unwrap();
-    assert_eq!(std::str::from_utf8(method).unwrap(), "POST");
-    assert_eq!(res.body, b"{\"foo\": \"bar\"}", "invalid body returned");
-}
diff --git a/crates/test-programs/wasi-http-tests/src/bin/outbound_request_put.rs b/crates/test-programs/wasi-http-tests/src/bin/outbound_request_put.rs
deleted file mode 100644
index 68e34f6cb578..000000000000
--- a/crates/test-programs/wasi-http-tests/src/bin/outbound_request_put.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-use anyhow::Context;
-use wasi_http_tests::bindings::wasi::http::types::{Method, Scheme};
-
-fn main() {
-    let addr = std::env::var("HTTP_SERVER").unwrap();
-    let res = wasi_http_tests::request(Method::Put, Scheme::Http, &addr, "/put", Some(&[]), None)
-        .context("/put")
-        .unwrap();
-
-    println!("/put: {res:?}");
-    assert_eq!(res.status, 200);
-    let method = res.header("x-wasmtime-test-method").unwrap();
-    assert_eq!(std::str::from_utf8(method).unwrap(), "PUT");
-    assert_eq!(res.body, b"");
-}
diff --git a/crates/test-programs/wasi-http-tests/src/bin/outbound_request_unknown_method.rs b/crates/test-programs/wasi-http-tests/src/bin/outbound_request_unknown_method.rs
deleted file mode 100644
index cb7847e3b5c1..000000000000
--- a/crates/test-programs/wasi-http-tests/src/bin/outbound_request_unknown_method.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-use wasi_http_tests::bindings::wasi::http::types::{Method, Scheme};
-
-fn main() {
-    let res = wasi_http_tests::request(
-        Method::Other("OTHER".to_owned()),
-        Scheme::Http,
-        "localhost:3000",
-        "/",
-        None,
-        None,
-    );
-
-    let error = res.unwrap_err();
-    assert_eq!(
-        error.to_string(),
-        "Error::InvalidUrl(\"unknown method OTHER\")"
-    );
-}
diff --git a/crates/test-programs/wasi-http-tests/src/bin/outbound_request_unsupported_scheme.rs b/crates/test-programs/wasi-http-tests/src/bin/outbound_request_unsupported_scheme.rs
deleted file mode 100644
index b9d198a44381..000000000000
--- a/crates/test-programs/wasi-http-tests/src/bin/outbound_request_unsupported_scheme.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-use wasi_http_tests::bindings::wasi::http::types::{Method, Scheme};
-
-fn main() {
-    let res = wasi_http_tests::request(
-        Method::Get,
-        Scheme::Other("WS".to_owned()),
-        "localhost:3000",
-        "/",
-        None,
-        None,
-    );
-
-    let error = res.unwrap_err();
-    assert_eq!(
-        error.to_string(),
-        "Error::InvalidUrl(\"unsupported scheme WS\")"
-    );
-}
diff --git a/crates/test-programs/wasi-http-tests/src/lib.rs b/crates/test-programs/wasi-http-tests/src/lib.rs
deleted file mode 100644
index 94b103414340..000000000000
--- a/crates/test-programs/wasi-http-tests/src/lib.rs
+++ /dev/null
@@ -1,170 +0,0 @@
-pub mod bindings {
-    wit_bindgen::generate!({
-        path: "../../wasi-http/wit",
-        world: "wasmtime:wasi/command-extended",
-        // macro_call_prefix: "::wasi_http_tests::bindings::",
-        // macro_export,
-    });
-}
-
-use anyhow::{anyhow, Result};
-use bindings::wasi::http::{outgoing_handler, types as http_types};
-use bindings::wasi::io::poll;
-use bindings::wasi::io::streams;
-use std::fmt;
-
-pub struct Response {
-    pub status: http_types::StatusCode,
-    pub headers: Vec<(String, Vec<u8>)>,
-    pub body: Vec<u8>,
-}
-impl fmt::Debug for Response {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut out = f.debug_struct("Response");
-        out.field("status", &self.status)
-            .field("headers", &self.headers);
-        if let Ok(body) = std::str::from_utf8(&self.body) {
-            out.field("body", &body);
-        } else {
-            out.field("body", &self.body);
-        }
-        out.finish()
-    }
-}
-
-impl Response {
-    pub fn header(&self, name: &str) -> Option<&Vec<u8>> {
-        self.headers
-            .iter()
-            .find_map(|(k, v)| if k == name { Some(v) } else { None })
-    }
-}
-
-pub fn request(
-    method: http_types::Method,
-    scheme: http_types::Scheme,
-    authority: &str,
-    path_with_query: &str,
-    body: Option<&[u8]>,
-    additional_headers: Option<&[(String, Vec<u8>)]>,
-) -> Result<Response> {
-    fn header_val(v: &str) -> Vec<u8> {
-        v.to_string().into_bytes()
-    }
-    let headers = http_types::Headers::new(
-        &[
-            &[
-                ("User-agent".to_string(), header_val("WASI-HTTP/0.0.1")),
-                ("Content-type".to_string(), header_val("application/json")),
-            ],
-            additional_headers.unwrap_or(&[]),
-        ]
-        .concat(),
-    );
-
-    let request = http_types::OutgoingRequest::new(
-        &method,
-        Some(path_with_query),
-        Some(&scheme),
-        Some(authority),
-        headers,
-    );
-
-    let outgoing_body = request
-        .write()
-        .map_err(|_| anyhow!("outgoing request write failed"))?;
-
-    if let Some(mut buf) = body {
-        let request_body = outgoing_body
-            .write()
-            .map_err(|_| anyhow!("outgoing request write failed"))?;
-
-        let pollable = request_body.subscribe();
-        while !buf.is_empty() {
-            poll::poll_list(&[&pollable]);
-
-            let permit = match request_body.check_write() {
-                Ok(n) => n,
-                Err(_) => anyhow::bail!("output stream error"),
-            };
-
-            let len = buf.len().min(permit as usize);
-            let (chunk, rest) = buf.split_at(len);
-            buf = rest;
-
-            match request_body.write(chunk) {
-                Err(_) => anyhow::bail!("output stream error"),
-                _ => {}
-            }
-        }
-
-        match request_body.flush() {
-            Err(_) => anyhow::bail!("output stream error"),
-            _ => {}
-        }
-
-        poll::poll_list(&[&pollable]);
-
-        match request_body.check_write() {
-            Ok(_) => {}
-            Err(_) => anyhow::bail!("output stream error"),
-        };
-    }
-
-    let future_response = outgoing_handler::handle(request, None)?;
-
-    http_types::OutgoingBody::finish(outgoing_body, None);
-
-    let incoming_response = match future_response.get() {
-        Some(result) => result.map_err(|_| anyhow!("incoming response errored"))?,
-        None => {
-            let pollable = future_response.subscribe();
-            let _ = poll::poll_list(&[&pollable]);
-            future_response
-                .get()
-                .expect("incoming response available")
-                .map_err(|_| anyhow!("incoming response errored"))?
-        }
-    }
-    // TODO: maybe anything that appears in the Result<_, E> position should impl
-    // Error? anyway, just use its Debug here:
-    .map_err(|e| anyhow!("{e:?}"))?;
-
-    drop(future_response);
-
-    let status = incoming_response.status();
-
-    let headers_handle = incoming_response.headers();
-    let headers = headers_handle.entries();
-    drop(headers_handle);
-
-    let incoming_body = incoming_response
-        .consume()
-        .map_err(|()| anyhow!("incoming response has no body stream"))?;
-
-    drop(incoming_response);
-
-    let input_stream = incoming_body.stream().unwrap();
-    let input_stream_pollable = input_stream.subscribe();
-
-    let mut body = Vec::new();
-    loop {
-        poll::poll_list(&[&input_stream_pollable]);
-
-        let mut body_chunk = match input_stream.read(1024 * 1024) {
-            Ok(c) => c,
-            Err(streams::StreamError::Closed) => break,
-            Err(e) => Err(anyhow!("input_stream read failed: {e:?}"))?,
-        };
-
-        if !body_chunk.is_empty() {
-            body.append(&mut body_chunk);
-        }
-    }
-
-    Ok(Response {
-        status,
-        headers,
-        body,
-    })
-}
diff --git a/crates/test-programs/wasi-sockets-tests/Cargo.toml b/crates/test-programs/wasi-sockets-tests/Cargo.toml
deleted file mode 100644
index 3dcc85370173..000000000000
--- a/crates/test-programs/wasi-sockets-tests/Cargo.toml
+++ /dev/null
@@ -1,10 +0,0 @@
-[package]
-name = "wasi-sockets-tests"
-version = "0.0.0"
-readme = "README.md"
-edition = "2021"
-publish = false
-
-[dependencies]
-anyhow = { workspace = true }
-wit-bindgen = { workspace = true, default-features = false, features = ["macros"] }
diff --git a/crates/test-programs/wasi-sockets-tests/src/bin/ip_name_lookup.rs b/crates/test-programs/wasi-sockets-tests/src/bin/ip_name_lookup.rs
deleted file mode 100644
index 50932e057c65..000000000000
--- a/crates/test-programs/wasi-sockets-tests/src/bin/ip_name_lookup.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-use wasi_sockets_tests::wasi::clocks::*;
-use wasi_sockets_tests::wasi::io::*;
-use wasi_sockets_tests::wasi::sockets::*;
-
-fn main() {
-    let network = instance_network::instance_network();
-
-    let addresses =
-        ip_name_lookup::resolve_addresses(&network, "example.com", None, false).unwrap();
-    let pollable = addresses.subscribe();
-    poll::poll_one(&pollable);
-    assert!(addresses.resolve_next_address().is_ok());
-
-    let result = ip_name_lookup::resolve_addresses(&network, "a.b<&>", None, false);
-    assert!(matches!(result, Err(network::ErrorCode::InvalidName)));
-
-    // Try resolving a valid address and ensure that it eventually terminates.
-    // To help prevent this test from being flaky this additionally times out
-    // the resolution and allows errors.
-    let addresses = ip_name_lookup::resolve_addresses(&network, "github.com", None, false).unwrap();
-    let lookup = addresses.subscribe();
-    let timeout = monotonic_clock::subscribe(1_000_000_000, false);
-    let ready = poll::poll_list(&[&lookup, &timeout]);
-    assert!(ready.len() > 0);
-    match ready[0] {
-        0 => loop {
-            match addresses.resolve_next_address() {
-                Ok(Some(_)) => {}
-                Ok(None) => break,
-                Err(_) => break,
-            }
-        },
-        1 => {}
-        _ => unreachable!(),
-    }
-}
diff --git a/crates/test-programs/wasi-sockets-tests/src/bin/tcp_v4.rs b/crates/test-programs/wasi-sockets-tests/src/bin/tcp_v4.rs
deleted file mode 100644
index cf02fdd79663..000000000000
--- a/crates/test-programs/wasi-sockets-tests/src/bin/tcp_v4.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-//! A simple TCP testcase, using IPv4.
-
-use wasi::io::poll;
-use wasi::sockets::network::{IpAddressFamily, IpSocketAddress, Ipv4SocketAddress};
-use wasi::sockets::{instance_network, tcp_create_socket};
-use wasi_sockets_tests::*;
-
-fn main() {
-    let net = instance_network::instance_network();
-
-    let sock = tcp_create_socket::create_tcp_socket(IpAddressFamily::Ipv4).unwrap();
-
-    let addr = IpSocketAddress::Ipv4(Ipv4SocketAddress {
-        port: 0,                 // use any free port
-        address: (127, 0, 0, 1), // localhost
-    });
-
-    let sub = sock.subscribe();
-
-    sock.start_bind(&net, addr).unwrap();
-
-    poll::poll_one(&sub);
-    drop(sub);
-
-    sock.finish_bind().unwrap();
-
-    example_body(net, sock, IpAddressFamily::Ipv4)
-}
diff --git a/crates/test-programs/wasi-sockets-tests/src/bin/tcp_v6.rs b/crates/test-programs/wasi-sockets-tests/src/bin/tcp_v6.rs
deleted file mode 100644
index 807db9825f1e..000000000000
--- a/crates/test-programs/wasi-sockets-tests/src/bin/tcp_v6.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-//! Like v4.rs, but with IPv6.
-
-use wasi::io::poll;
-use wasi::sockets::network::{IpAddressFamily, IpSocketAddress, Ipv6SocketAddress};
-use wasi::sockets::{instance_network, tcp_create_socket};
-use wasi_sockets_tests::*;
-
-fn main() {
-    let net = instance_network::instance_network();
-
-    let sock = tcp_create_socket::create_tcp_socket(IpAddressFamily::Ipv6).unwrap();
-
-    let addr = IpSocketAddress::Ipv6(Ipv6SocketAddress {
-        port: 0,                           // use any free port
-        address: (0, 0, 0, 0, 0, 0, 0, 1), // localhost
-        flow_info: 0,
-        scope_id: 0,
-    });
-
-    let sub = sock.subscribe();
-
-    sock.start_bind(&net, addr).unwrap();
-
-    poll::poll_one(&sub);
-    drop(sub);
-
-    sock.finish_bind().unwrap();
-
-    example_body(net, sock, IpAddressFamily::Ipv6)
-}
diff --git a/crates/test-programs/wasi-sockets-tests/src/lib.rs b/crates/test-programs/wasi-sockets-tests/src/lib.rs
deleted file mode 100644
index a46cff830c0f..000000000000
--- a/crates/test-programs/wasi-sockets-tests/src/lib.rs
+++ /dev/null
@@ -1,97 +0,0 @@
-wit_bindgen::generate!("test-command-with-sockets" in "../../wasi/wit");
-
-use wasi::io::poll;
-use wasi::io::streams;
-use wasi::sockets::{network, tcp, tcp_create_socket};
-
-pub fn write(output: &streams::OutputStream, mut bytes: &[u8]) -> Result<(), streams::StreamError> {
-    let pollable = output.subscribe();
-
-    while !bytes.is_empty() {
-        poll::poll_list(&[&pollable]);
-
-        let permit = output.check_write()?;
-
-        let len = bytes.len().min(permit as usize);
-        let (chunk, rest) = bytes.split_at(len);
-
-        output.write(chunk)?;
-
-        output.blocking_flush()?;
-
-        bytes = rest;
-    }
-    Ok(())
-}
-
-pub fn example_body(net: tcp::Network, sock: tcp::TcpSocket, family: network::IpAddressFamily) {
-    let first_message = b"Hello, world!";
-    let second_message = b"Greetings, planet!";
-
-    let sub = sock.subscribe();
-
-    sock.set_listen_backlog_size(32).unwrap();
-
-    sock.start_listen().unwrap();
-    poll::poll_one(&sub);
-    sock.finish_listen().unwrap();
-
-    let addr = sock.local_address().unwrap();
-
-    let client = tcp_create_socket::create_tcp_socket(family).unwrap();
-    let client_sub = client.subscribe();
-
-    client.start_connect(&net, addr).unwrap();
-    poll::poll_one(&client_sub);
-    let (client_input, client_output) = client.finish_connect().unwrap();
-
-    write(&client_output, &[]).unwrap();
-
-    write(&client_output, first_message).unwrap();
-
-    drop(client_input);
-    drop(client_output);
-    drop(client_sub);
-    drop(client);
-
-    poll::poll_one(&sub);
-    let (accepted, input, output) = sock.accept().unwrap();
-
-    let empty_data = input.read(0).unwrap();
-    assert!(empty_data.is_empty());
-
-    let data = input.blocking_read(first_message.len() as u64).unwrap();
-
-    drop(input);
-    drop(output);
-    drop(accepted);
-
-    // Check that we sent and recieved our message!
-    assert_eq!(data, first_message); // Not guaranteed to work but should work in practice.
-
-    // Another client
-    let client = tcp_create_socket::create_tcp_socket(family).unwrap();
-    let client_sub = client.subscribe();
-
-    client.start_connect(&net, addr).unwrap();
-    poll::poll_one(&client_sub);
-    let (client_input, client_output) = client.finish_connect().unwrap();
-
-    write(&client_output, second_message).unwrap();
-
-    drop(client_input);
-    drop(client_output);
-    drop(client_sub);
-    drop(client);
-
-    poll::poll_one(&sub);
-    let (accepted, input, output) = sock.accept().unwrap();
-    let data = input.blocking_read(second_message.len() as u64).unwrap();
-
-    drop(input);
-    drop(output);
-    drop(accepted);
-
-    // Check that we sent and recieved our message!
-    assert_eq!(data, second_message); // Not guaranteed to work but should work in practice.
-}
diff --git a/crates/test-programs/wasi-tests/Cargo.toml b/crates/test-programs/wasi-tests/Cargo.toml
deleted file mode 100644
index bf72d58ea313..000000000000
--- a/crates/test-programs/wasi-tests/Cargo.toml
+++ /dev/null
@@ -1,14 +0,0 @@
-[package]
-name = "wasi-tests"
-version = "0.0.0"
-readme = "README.md"
-edition = "2021"
-publish = false
-
-[dependencies]
-libc = "0.2.65"
-wasi = "0.11.0"
-once_cell = "1.12"
-wit-bindgen = { workspace = true, default-features = false, features = [
-    "macros",
-] }
diff --git a/crates/test-programs/wasi-tests/README.md b/crates/test-programs/wasi-tests/README.md
deleted file mode 100644
index f281fa1a8edc..000000000000
--- a/crates/test-programs/wasi-tests/README.md
+++ /dev/null
@@ -1,3 +0,0 @@
-This is the `wasi-tests` crate, which contains source code for the system-level WASI tests.
-
-Building these tests requires that the `wasm32-wasi` target be installed.
diff --git a/crates/test-programs/wasi-tests/src/bin/close_preopen.rs b/crates/test-programs/wasi-tests/src/bin/close_preopen.rs
deleted file mode 100644
index 2d8f3a344fe3..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/close_preopen.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-use std::{env, process};
-use wasi_tests::{assert_errno, open_scratch_directory};
-
-unsafe fn test_close_preopen(dir_fd: wasi::Fd) {
-    let pre_fd: wasi::Fd = (libc::STDERR_FILENO + 1) as wasi::Fd;
-
-    assert!(dir_fd > pre_fd, "dir_fd number");
-
-    // Try to close a preopened directory handle.
-    wasi::fd_close(pre_fd).expect("closing a preopened file descriptor");
-
-    // Ensure that dir_fd is still open.
-    let dir_fdstat = wasi::fd_fdstat_get(dir_fd).expect("failed fd_fdstat_get");
-    assert_eq!(
-        dir_fdstat.fs_filetype,
-        wasi::FILETYPE_DIRECTORY,
-        "expected the scratch directory to be a directory",
-    );
-
-    // Ensure that pre_fd is closed.
-    assert_errno!(
-        wasi::fd_fdstat_get(pre_fd).expect_err("failed fd_fdstat_get"),
-        wasi::ERRNO_BADF
-    );
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_close_preopen(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/dangling_fd.rs b/crates/test-programs/wasi-tests/src/bin/dangling_fd.rs
deleted file mode 100644
index 3d29c4fc7e5a..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/dangling_fd.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-use std::{env, process};
-use wasi_tests::{open_scratch_directory, TESTCONFIG};
-
-unsafe fn test_dangling_fd(dir_fd: wasi::Fd) {
-    if TESTCONFIG.support_dangling_filesystem() {
-        // Create a file, open it, delete it without closing the handle,
-        // and then try creating it again
-        let fd = wasi::path_open(dir_fd, 0, "file", wasi::OFLAGS_CREAT, 0, 0, 0).unwrap();
-        wasi::fd_close(fd).unwrap();
-        let file_fd = wasi::path_open(dir_fd, 0, "file", 0, 0, 0, 0).expect("failed to open");
-        assert!(
-            file_fd > libc::STDERR_FILENO as wasi::Fd,
-            "file descriptor range check",
-        );
-        wasi::path_unlink_file(dir_fd, "file").expect("failed to unlink");
-        let fd = wasi::path_open(dir_fd, 0, "file", wasi::OFLAGS_CREAT, 0, 0, 0).unwrap();
-        wasi::fd_close(fd).unwrap();
-
-        // Now, repeat the same process but for a directory
-        wasi::path_create_directory(dir_fd, "subdir").expect("failed to create dir");
-        let subdir_fd = wasi::path_open(dir_fd, 0, "subdir", wasi::OFLAGS_DIRECTORY, 0, 0, 0)
-            .expect("failed to open dir");
-        assert!(
-            subdir_fd > libc::STDERR_FILENO as wasi::Fd,
-            "file descriptor range check",
-        );
-        wasi::path_remove_directory(dir_fd, "subdir").expect("failed to remove dir 2");
-        wasi::path_create_directory(dir_fd, "subdir").expect("failed to create dir 2");
-    }
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_dangling_fd(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/dangling_symlink.rs b/crates/test-programs/wasi-tests/src/bin/dangling_symlink.rs
deleted file mode 100644
index f7538fc979f2..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/dangling_symlink.rs
+++ /dev/null
@@ -1,50 +0,0 @@
-use std::{env, process};
-use wasi_tests::{assert_errno, open_scratch_directory, TESTCONFIG};
-
-unsafe fn test_dangling_symlink(dir_fd: wasi::Fd) {
-    if TESTCONFIG.support_dangling_filesystem() {
-        // First create a dangling symlink.
-        wasi::path_symlink("target", dir_fd, "symlink").expect("creating a symlink");
-
-        // Try to open it as a directory with O_NOFOLLOW.
-        assert_errno!(
-            wasi::path_open(dir_fd, 0, "symlink", wasi::OFLAGS_DIRECTORY, 0, 0, 0)
-                .expect_err("opening a dangling symlink as a directory"),
-            wasi::ERRNO_NOTDIR,
-            wasi::ERRNO_LOOP
-        );
-
-        // Try to open it as a file with O_NOFOLLOW.
-        assert_errno!(
-            wasi::path_open(dir_fd, 0, "symlink", 0, 0, 0, 0)
-                .expect_err("opening a dangling symlink as a file"),
-            wasi::ERRNO_LOOP
-        );
-
-        // Clean up.
-        wasi::path_unlink_file(dir_fd, "symlink").expect("failed to remove file");
-    }
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_dangling_symlink(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/dir_fd_op_failures.rs b/crates/test-programs/wasi-tests/src/bin/dir_fd_op_failures.rs
deleted file mode 100644
index bb081c6960f1..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/dir_fd_op_failures.rs
+++ /dev/null
@@ -1,115 +0,0 @@
-use std::{env, process};
-use wasi_tests::open_scratch_directory;
-
-unsafe fn test_fd_dir_ops(dir_fd: wasi::Fd) {
-    let stat = wasi::fd_filestat_get(dir_fd).expect("failed to fdstat");
-    assert_eq!(stat.filetype, wasi::FILETYPE_DIRECTORY);
-
-    let (pr_fd, pr_name_len) = (3..)
-        .map_while(|fd| wasi::fd_prestat_get(fd).ok().map(|stat| (fd, stat)))
-        .find_map(|(fd, wasi::Prestat { tag, u })| {
-            (tag == wasi::PREOPENTYPE_DIR.raw()).then_some((fd, u.dir.pr_name_len))
-        })
-        .expect("failed to find preopen directory");
-
-    let mut pr_name = vec![];
-    let r = wasi::fd_prestat_dir_name(pr_fd, pr_name.as_mut_ptr(), 0);
-    assert_eq!(r, Err(wasi::ERRNO_NAMETOOLONG));
-
-    // Test that passing a larger than necessary buffer works correctly
-    let mut pr_name = vec![0; pr_name_len + 1];
-    let r = wasi::fd_prestat_dir_name(pr_fd, pr_name.as_mut_ptr(), pr_name_len + 1);
-    assert_eq!(r, Ok(()));
-
-    let mut read_buf = vec![0; 128].into_boxed_slice();
-    let iovec = wasi::Iovec {
-        buf: read_buf.as_mut_ptr(),
-        buf_len: read_buf.len(),
-    };
-    let r = wasi::fd_read(dir_fd, &[iovec]);
-    // On posix, this fails with ERRNO_ISDIR:
-    assert_eq!(r, Err(wasi::ERRNO_BADF), "fd_read error");
-
-    let r = wasi::fd_pread(dir_fd, &[iovec], 0);
-    // On posix, this fails with ERRNO_ISDIR
-    assert_eq!(r, Err(wasi::ERRNO_BADF), "fd_pread error");
-
-    let write_buf = vec![0; 128].into_boxed_slice();
-    let ciovec = wasi::Ciovec {
-        buf: write_buf.as_ptr(),
-        buf_len: write_buf.len(),
-    };
-    let r = wasi::fd_write(dir_fd, &[ciovec]);
-    // Same behavior as specified by POSIX:
-    assert_eq!(r, Err(wasi::ERRNO_BADF), "fd_write error");
-
-    let r = wasi::fd_pwrite(dir_fd, &[ciovec], 0);
-    // Same behavior as specified by POSIX:
-    assert_eq!(r, Err(wasi::ERRNO_BADF), "fd_pwrite error");
-
-    // Divergence from posix: lseek(dirfd) will return 0
-    let r = wasi::fd_seek(dir_fd, 0, wasi::WHENCE_CUR);
-    assert_eq!(r, Err(wasi::ERRNO_BADF), "fd_seek WHENCE_CUR error");
-    let r = wasi::fd_seek(dir_fd, 0, wasi::WHENCE_SET);
-    assert_eq!(r, Err(wasi::ERRNO_BADF), "fd_seek WHENCE_SET error");
-    let r = wasi::fd_seek(dir_fd, 0, wasi::WHENCE_END);
-    assert_eq!(r, Err(wasi::ERRNO_BADF), "fd_seek WHENCE_END error");
-
-    // Tell isnt in posix, its basically lseek with WHENCE_CUR above
-    let r = wasi::fd_tell(dir_fd);
-    assert_eq!(r, Err(wasi::ERRNO_BADF), "fd_tell error");
-
-    // posix_fadvise(dirfd, 0, 0, POSIX_FADV_DONTNEED) will return 0 on linux.
-    // not available on mac os.
-    let r = wasi::fd_advise(dir_fd, 0, 0, wasi::ADVICE_DONTNEED);
-    assert_eq!(r, Err(wasi::ERRNO_BADF), "fd_advise error");
-
-    // fallocate(dirfd, FALLOC_FL_ZERO_RANGE, 0, 1) will fail with errno EBADF on linux.
-    // not available on mac os.
-    let r = wasi::fd_allocate(dir_fd, 0, 0);
-    assert_eq!(r, Err(wasi::ERRNO_BADF), "fd_allocate error");
-
-    // fdatasync(dirfd) will return 0 on linux.
-    // not available on mac os.
-    let r = wasi::fd_datasync(dir_fd);
-    assert_eq!(r, Err(wasi::ERRNO_BADF), "fd_datasync error");
-
-    // fsync(dirfd) will return 0 on linux.
-    // not available on mac os.
-    let r = wasi::fd_sync(dir_fd);
-    assert_eq!(r, Err(wasi::ERRNO_BADF), "fd_sync error");
-
-    // fcntl(dirfd,  F_SETFL, O_NONBLOCK) will return 0 on linux.
-    // not available on mac os.
-    let r = wasi::fd_fdstat_set_flags(dir_fd, wasi::FDFLAGS_NONBLOCK);
-    assert_eq!(r, Err(wasi::ERRNO_BADF), "fd_fdstat_set_flags error");
-
-    // ftruncate(dirfd, 1) will fail with errno EINVAL on posix.
-    // here, we fail with EBADF instead:
-    let r = wasi::fd_filestat_set_size(dir_fd, 0);
-    assert_eq!(r, Err(wasi::ERRNO_BADF), "fd_filestat_set_size error");
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    unsafe {
-        test_fd_dir_ops(dir_fd);
-    }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/directory_seek.rs b/crates/test-programs/wasi-tests/src/bin/directory_seek.rs
deleted file mode 100644
index dc4fd52fb52f..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/directory_seek.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-use std::{env, process};
-use wasi_tests::{assert_errno, open_scratch_directory};
-
-unsafe fn test_directory_seek(dir_fd: wasi::Fd) {
-    // Create a directory in the scratch directory.
-    wasi::path_create_directory(dir_fd, "dir").expect("failed to make directory");
-
-    // Open the directory and attempt to request rights for seeking.
-    let fd = wasi::path_open(dir_fd, 0, "dir", wasi::OFLAGS_DIRECTORY, 0, 0, 0)
-        .expect("failed to open file");
-    assert!(
-        fd > libc::STDERR_FILENO as wasi::Fd,
-        "file descriptor range check",
-    );
-
-    // Attempt to seek.
-    assert_errno!(
-        wasi::fd_seek(fd, 0, wasi::WHENCE_CUR).expect_err("seek on a directory"),
-        wasi::ERRNO_BADF
-    );
-
-    // Clean up.
-    wasi::fd_close(fd).expect("failed to close fd");
-    wasi::path_remove_directory(dir_fd, "dir").expect("failed to remove dir");
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_directory_seek(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/fd_advise.rs b/crates/test-programs/wasi-tests/src/bin/fd_advise.rs
deleted file mode 100644
index 78a048db0f9e..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/fd_advise.rs
+++ /dev/null
@@ -1,62 +0,0 @@
-use std::{env, process};
-use wasi_tests::open_scratch_directory;
-
-unsafe fn test_fd_advise(dir_fd: wasi::Fd) {
-    // Create a file in the scratch directory.
-    let file_fd = wasi::path_open(
-        dir_fd,
-        0,
-        "file",
-        wasi::OFLAGS_CREAT,
-        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
-        0,
-        0,
-    )
-    .expect("failed to open file");
-    assert!(
-        file_fd > libc::STDERR_FILENO as wasi::Fd,
-        "file descriptor range check",
-    );
-
-    // Check file size
-    let stat = wasi::fd_filestat_get(file_fd).expect("failed to fdstat");
-    assert_eq!(stat.size, 0, "file size should be 0");
-
-    // set_size it bigger
-    wasi::fd_filestat_set_size(file_fd, 100).expect("setting size");
-
-    let stat = wasi::fd_filestat_get(file_fd).expect("failed to fdstat 2");
-    assert_eq!(stat.size, 100, "file size should be 100");
-
-    // Advise the kernel
-    wasi::fd_advise(file_fd, 10, 50, wasi::ADVICE_NORMAL).expect("failed advise");
-
-    // Advise shouldnt change size
-    let stat = wasi::fd_filestat_get(file_fd).expect("failed to fdstat 3");
-    assert_eq!(stat.size, 100, "file size should be 100");
-
-    wasi::fd_close(file_fd).expect("failed to close");
-    wasi::path_unlink_file(dir_fd, "file").expect("failed to unlink");
-}
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_fd_advise(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/fd_filestat_set.rs b/crates/test-programs/wasi-tests/src/bin/fd_filestat_set.rs
deleted file mode 100644
index de358dfff23e..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/fd_filestat_set.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-use std::{env, process};
-use wasi_tests::open_scratch_directory;
-
-unsafe fn test_fd_filestat_set(dir_fd: wasi::Fd) {
-    // Create a file in the scratch directory.
-    let file_fd = wasi::path_open(
-        dir_fd,
-        0,
-        "file",
-        wasi::OFLAGS_CREAT,
-        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
-        0,
-        0,
-    )
-    .expect("failed to create file");
-    assert!(
-        file_fd > libc::STDERR_FILENO as wasi::Fd,
-        "file descriptor range check",
-    );
-
-    // Check file size
-    let stat = wasi::fd_filestat_get(file_fd).expect("failed filestat");
-    assert_eq!(stat.size, 0, "file size should be 0");
-
-    // Check fd_filestat_set_size
-    wasi::fd_filestat_set_size(file_fd, 100).expect("fd_filestat_set_size");
-
-    let stat = wasi::fd_filestat_get(file_fd).expect("failed filestat 2");
-    assert_eq!(stat.size, 100, "file size should be 100");
-
-    // Check fd_filestat_set_times
-    let old_atim = stat.atim;
-    let new_mtim = stat.mtim - 100;
-    wasi::fd_filestat_set_times(file_fd, new_mtim, new_mtim, wasi::FSTFLAGS_MTIM)
-        .expect("fd_filestat_set_times");
-
-    let stat = wasi::fd_filestat_get(file_fd).expect("failed filestat 3");
-    assert_eq!(stat.size, 100, "file size should remain unchanged at 100");
-    assert_eq!(stat.mtim, new_mtim, "mtim should change");
-    assert_eq!(stat.atim, old_atim, "atim should not change");
-
-    // let status = wasi_fd_filestat_set_times(file_fd, new_mtim, new_mtim, wasi::FILESTAT_SET_MTIM | wasi::FILESTAT_SET_MTIM_NOW);
-    // assert_eq!(status, wasi::EINVAL, "ATIM & ATIM_NOW can't both be set");
-
-    wasi::fd_close(file_fd).expect("failed to close fd");
-    wasi::path_unlink_file(dir_fd, "file").expect("failed to remove dir");
-}
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_fd_filestat_set(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/fd_flags_set.rs b/crates/test-programs/wasi-tests/src/bin/fd_flags_set.rs
deleted file mode 100644
index 9a21fc465f42..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/fd_flags_set.rs
+++ /dev/null
@@ -1,160 +0,0 @@
-use std::{env, process};
-use wasi_tests::open_scratch_directory;
-
-unsafe fn test_fd_fdstat_set_flags(dir_fd: wasi::Fd) {
-    const FILE_NAME: &str = "file";
-    let data = &[0u8; 100];
-
-    let file_fd = wasi::path_open(
-        dir_fd,
-        0,
-        FILE_NAME,
-        wasi::OFLAGS_CREAT,
-        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
-        0,
-        wasi::FDFLAGS_APPEND,
-    )
-    .expect("opening a file");
-
-    // Write some data and then verify the written data
-    assert_eq!(
-        wasi::fd_write(
-            file_fd,
-            &[wasi::Ciovec {
-                buf: data.as_ptr(),
-                buf_len: data.len(),
-            }],
-        )
-        .expect("writing to a file"),
-        data.len(),
-        "should write {} bytes",
-        data.len(),
-    );
-
-    wasi::fd_seek(file_fd, 0, wasi::WHENCE_SET).expect("seeking file");
-
-    let buffer = &mut [0u8; 100];
-
-    assert_eq!(
-        wasi::fd_read(
-            file_fd,
-            &[wasi::Iovec {
-                buf: buffer.as_mut_ptr(),
-                buf_len: buffer.len(),
-            }]
-        )
-        .expect("reading file"),
-        buffer.len(),
-        "should read {} bytes",
-        buffer.len()
-    );
-
-    assert_eq!(&data[..], &buffer[..]);
-
-    let data = &[1u8; 100];
-
-    // Seek back to the start to ensure we're in append-only mode
-    wasi::fd_seek(file_fd, 0, wasi::WHENCE_SET).expect("seeking file");
-
-    assert_eq!(
-        wasi::fd_write(
-            file_fd,
-            &[wasi::Ciovec {
-                buf: data.as_ptr(),
-                buf_len: data.len(),
-            }],
-        )
-        .expect("writing to a file"),
-        data.len(),
-        "should write {} bytes",
-        data.len(),
-    );
-
-    wasi::fd_seek(file_fd, 100, wasi::WHENCE_SET).expect("seeking file");
-
-    assert_eq!(
-        wasi::fd_read(
-            file_fd,
-            &[wasi::Iovec {
-                buf: buffer.as_mut_ptr(),
-                buf_len: buffer.len(),
-            }]
-        )
-        .expect("reading file"),
-        buffer.len(),
-        "should read {} bytes",
-        buffer.len()
-    );
-
-    assert_eq!(&data[..], &buffer[..]);
-
-    wasi::fd_fdstat_set_flags(file_fd, 0).expect("disabling flags");
-
-    // Overwrite some existing data to ensure the append mode is now off
-    wasi::fd_seek(file_fd, 0, wasi::WHENCE_SET).expect("seeking file");
-
-    let data = &[2u8; 100];
-
-    assert_eq!(
-        wasi::fd_write(
-            file_fd,
-            &[wasi::Ciovec {
-                buf: data.as_ptr(),
-                buf_len: data.len(),
-            }],
-        )
-        .expect("writing to a file"),
-        data.len(),
-        "should write {} bytes",
-        data.len(),
-    );
-
-    wasi::fd_seek(file_fd, 0, wasi::WHENCE_SET).expect("seeking file");
-
-    assert_eq!(
-        wasi::fd_read(
-            file_fd,
-            &[wasi::Iovec {
-                buf: buffer.as_mut_ptr(),
-                buf_len: buffer.len(),
-            }]
-        )
-        .expect("reading file"),
-        buffer.len(),
-        "should read {} bytes",
-        buffer.len()
-    );
-
-    assert_eq!(&data[..], &buffer[..]);
-
-    wasi::fd_close(file_fd).expect("close file");
-
-    let stat = wasi::path_filestat_get(dir_fd, 0, FILE_NAME).expect("stat path");
-
-    assert_eq!(stat.size, 200, "expected a file size of 200");
-
-    wasi::path_unlink_file(dir_fd, FILE_NAME).expect("unlinking file");
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    unsafe {
-        test_fd_fdstat_set_flags(dir_fd);
-    }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/fd_readdir.rs b/crates/test-programs/wasi-tests/src/bin/fd_readdir.rs
deleted file mode 100644
index 3045f166b0c6..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/fd_readdir.rs
+++ /dev/null
@@ -1,265 +0,0 @@
-use std::{env, mem, process, slice, str};
-use wasi_tests::open_scratch_directory;
-
-const BUF_LEN: usize = 256;
-
-struct DirEntry {
-    dirent: wasi::Dirent,
-    name: String,
-}
-
-// Manually reading the output from fd_readdir is tedious and repetitive,
-// so encapsulate it into an iterator
-struct ReadDir<'a> {
-    buf: &'a [u8],
-}
-
-impl<'a> ReadDir<'a> {
-    fn from_slice(buf: &'a [u8]) -> Self {
-        Self { buf }
-    }
-}
-
-impl<'a> Iterator for ReadDir<'a> {
-    type Item = DirEntry;
-
-    fn next(&mut self) -> Option<DirEntry> {
-        unsafe {
-            if self.buf.len() < mem::size_of::<wasi::Dirent>() {
-                return None;
-            }
-
-            // Read the data
-            let dirent_ptr = self.buf.as_ptr() as *const wasi::Dirent;
-            let dirent = dirent_ptr.read_unaligned();
-
-            if self.buf.len() < mem::size_of::<wasi::Dirent>() + dirent.d_namlen as usize {
-                return None;
-            }
-
-            let name_ptr = dirent_ptr.offset(1) as *const u8;
-            // NOTE Linux syscall returns a NUL-terminated name, but WASI doesn't
-            let namelen = dirent.d_namlen as usize;
-            let slice = slice::from_raw_parts(name_ptr, namelen);
-            let name = str::from_utf8(slice).expect("invalid utf8").to_owned();
-
-            // Update the internal state
-            let delta = mem::size_of_val(&dirent) + namelen;
-            self.buf = &self.buf[delta..];
-
-            DirEntry { dirent, name }.into()
-        }
-    }
-}
-
-/// Return the entries plus a bool indicating EOF.
-unsafe fn exec_fd_readdir(fd: wasi::Fd, cookie: wasi::Dircookie) -> (Vec<DirEntry>, bool) {
-    let mut buf: [u8; BUF_LEN] = [0; BUF_LEN];
-    let bufused =
-        wasi::fd_readdir(fd, buf.as_mut_ptr(), BUF_LEN, cookie).expect("failed fd_readdir");
-    assert!(bufused <= BUF_LEN);
-
-    let sl = slice::from_raw_parts(buf.as_ptr(), bufused);
-    let dirs: Vec<_> = ReadDir::from_slice(sl).collect();
-    let eof = bufused < BUF_LEN;
-    (dirs, eof)
-}
-
-unsafe fn assert_empty_dir(dir_fd: wasi::Fd) {
-    let stat = wasi::fd_filestat_get(dir_fd).expect("failed filestat");
-
-    let (mut dirs, eof) = exec_fd_readdir(dir_fd, 0);
-    assert!(eof, "expected to read the entire directory");
-    dirs.sort_by_key(|d| d.name.clone());
-    assert_eq!(dirs.len(), 2, "expected two entries in an empty directory");
-    let mut dirs = dirs.into_iter();
-
-    // the first entry should be `.`
-    let dir = dirs.next().expect("first entry is None");
-    assert_eq!(dir.name, ".", "first name");
-    assert_eq!(dir.dirent.d_type, wasi::FILETYPE_DIRECTORY, "first type");
-    assert_eq!(dir.dirent.d_ino, stat.ino);
-    assert_eq!(dir.dirent.d_namlen, 1);
-
-    // the second entry should be `..`
-    let dir = dirs.next().expect("second entry is None");
-    assert_eq!(dir.name, "..", "second name");
-    assert_eq!(dir.dirent.d_type, wasi::FILETYPE_DIRECTORY, "second type");
-
-    assert!(
-        dirs.next().is_none(),
-        "the directory should be seen as empty"
-    );
-}
-
-unsafe fn test_fd_readdir(dir_fd: wasi::Fd) {
-    // Check the behavior in an empty directory
-    assert_empty_dir(dir_fd);
-
-    // Add a file and check the behavior
-    let file_fd = wasi::path_open(
-        dir_fd,
-        0,
-        "file",
-        wasi::OFLAGS_CREAT,
-        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
-        0,
-        0,
-    )
-    .expect("failed to create file");
-    assert!(
-        file_fd > libc::STDERR_FILENO as wasi::Fd,
-        "file descriptor range check",
-    );
-
-    let file_stat = wasi::fd_filestat_get(file_fd).expect("failed filestat");
-    wasi::fd_close(file_fd).expect("closing a file");
-
-    wasi::path_create_directory(dir_fd, "nested").expect("create a directory");
-    let nested_fd =
-        wasi::path_open(dir_fd, 0, "nested", 0, 0, 0, 0).expect("failed to open nested directory");
-    let nested_stat = wasi::fd_filestat_get(nested_fd).expect("failed filestat");
-
-    // Execute another readdir
-    let (mut dirs, eof) = exec_fd_readdir(dir_fd, 0);
-    assert!(eof, "expected to read the entire directory");
-    assert_eq!(dirs.len(), 4, "expected four entries");
-    // Save the data about the last entry. We need to do it before sorting.
-    let lastfile_cookie = dirs[2].dirent.d_next;
-    let lastfile_name = dirs[3].name.clone();
-    dirs.sort_by_key(|d| d.name.clone());
-    let mut dirs = dirs.into_iter();
-
-    let dir = dirs.next().expect("first entry is None");
-    assert_eq!(dir.name, ".", "first name");
-    let dir = dirs.next().expect("second entry is None");
-    assert_eq!(dir.name, "..", "second name");
-    let dir = dirs.next().expect("third entry is None");
-    // check the file info
-    assert_eq!(dir.name, "file", "file name doesn't match");
-    assert_eq!(
-        dir.dirent.d_type,
-        wasi::FILETYPE_REGULAR_FILE,
-        "type for the real file"
-    );
-    assert_eq!(dir.dirent.d_ino, file_stat.ino);
-    let dir = dirs.next().expect("fourth entry is None");
-    // check the directory info
-    assert_eq!(dir.name, "nested", "nested directory name doesn't match");
-    assert_eq!(
-        dir.dirent.d_type,
-        wasi::FILETYPE_DIRECTORY,
-        "type for the nested directory"
-    );
-    assert_eq!(dir.dirent.d_ino, nested_stat.ino);
-
-    // check if cookie works as expected
-    let (dirs, eof) = exec_fd_readdir(dir_fd, lastfile_cookie);
-    assert!(eof, "expected to read the entire directory");
-    assert_eq!(dirs.len(), 1, "expected one entry");
-    assert_eq!(dirs[0].name, lastfile_name, "name of the only entry");
-
-    // check if nested directory shows up as empty
-    assert_empty_dir(nested_fd);
-    wasi::fd_close(nested_fd).expect("closing a nested directory");
-
-    wasi::path_unlink_file(dir_fd, "file").expect("removing a file");
-    wasi::path_remove_directory(dir_fd, "nested").expect("removing a nested directory");
-}
-
-unsafe fn test_fd_readdir_lots(dir_fd: wasi::Fd) {
-    // Add a file and check the behavior
-    for count in 0..1000 {
-        let file_fd = wasi::path_open(
-            dir_fd,
-            0,
-            &format!("file.{}", count),
-            wasi::OFLAGS_CREAT,
-            wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
-            0,
-            0,
-        )
-        .expect("failed to create file");
-        assert!(
-            file_fd > libc::STDERR_FILENO as wasi::Fd,
-            "file descriptor range check",
-        );
-        wasi::fd_close(file_fd).expect("closing a file");
-    }
-
-    // Count the entries to ensure that we see the correct number.
-    let mut total = 0;
-    let mut cookie = 0;
-    loop {
-        let (dirs, eof) = exec_fd_readdir(dir_fd, cookie);
-        total += dirs.len();
-        if eof {
-            break;
-        }
-        cookie = dirs[dirs.len() - 1].dirent.d_next;
-    }
-    assert_eq!(total, 1002, "expected 1000 entries plus . and ..");
-
-    for count in 0..1000 {
-        wasi::path_unlink_file(dir_fd, &format!("file.{}", count)).expect("removing a file");
-    }
-}
-
-unsafe fn test_fd_readdir_unicode_boundary(dir_fd: wasi::Fd) {
-    let filename = "Действие";
-    let file_fd = wasi::path_open(
-        dir_fd,
-        0,
-        filename,
-        wasi::OFLAGS_CREAT,
-        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
-        0,
-        0,
-    )
-    .expect("failed to create file");
-    assert!(
-        file_fd > libc::STDERR_FILENO as wasi::Fd,
-        "file descriptor range check",
-    );
-    wasi::fd_close(file_fd).expect("closing a file");
-
-    let mut buf = Vec::new();
-    'outer: loop {
-        let len = wasi::fd_readdir(dir_fd, buf.as_mut_ptr(), buf.capacity(), 0).unwrap();
-        buf.set_len(len);
-
-        for entry in ReadDir::from_slice(&buf) {
-            if entry.name == filename {
-                break 'outer;
-            }
-        }
-        buf = Vec::with_capacity(buf.capacity() + 1);
-    }
-
-    wasi::path_unlink_file(dir_fd, filename).expect("removing a file");
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_fd_readdir(dir_fd) }
-    unsafe { test_fd_readdir_lots(dir_fd) }
-    unsafe { test_fd_readdir_unicode_boundary(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/file_allocate.rs b/crates/test-programs/wasi-tests/src/bin/file_allocate.rs
deleted file mode 100644
index 356563015b30..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/file_allocate.rs
+++ /dev/null
@@ -1,62 +0,0 @@
-use std::{env, process};
-use wasi_tests::open_scratch_directory;
-
-unsafe fn test_file_allocate(dir_fd: wasi::Fd) {
-    // Create a file in the scratch directory.
-    let file_fd = wasi::path_open(
-        dir_fd,
-        0,
-        "file",
-        wasi::OFLAGS_CREAT,
-        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
-        0,
-        0,
-    )
-    .expect("opening a file");
-    assert!(
-        file_fd > libc::STDERR_FILENO as wasi::Fd,
-        "file descriptor range check",
-    );
-
-    // Check file size
-    let mut stat = wasi::fd_filestat_get(file_fd).expect("reading file stats");
-    assert_eq!(stat.size, 0, "file size should be 0");
-
-    let err = wasi::fd_allocate(file_fd, 0, 100)
-        .err()
-        .expect("fd_allocate must fail");
-    assert_eq!(
-        err,
-        wasi::ERRNO_NOTSUP,
-        "fd_allocate should fail with NOTSUP"
-    );
-
-    stat = wasi::fd_filestat_get(file_fd).expect("reading file stats");
-    assert_eq!(stat.size, 0, "file size should still be 0");
-
-    wasi::fd_close(file_fd).expect("closing a file");
-    wasi::path_unlink_file(dir_fd, "file").expect("removing a file");
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_file_allocate(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/file_pread_pwrite.rs b/crates/test-programs/wasi-tests/src/bin/file_pread_pwrite.rs
deleted file mode 100644
index 918fec842bf1..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/file_pread_pwrite.rs
+++ /dev/null
@@ -1,152 +0,0 @@
-use std::convert::TryInto;
-use std::{env, process};
-use wasi_tests::open_scratch_directory;
-
-unsafe fn test_file_pread_pwrite(dir_fd: wasi::Fd) {
-    // Create a file in the scratch directory.
-    let file_fd = wasi::path_open(
-        dir_fd,
-        0,
-        "file",
-        wasi::OFLAGS_CREAT,
-        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
-        0,
-        0,
-    )
-    .expect("opening a file");
-    assert!(
-        file_fd > libc::STDERR_FILENO as wasi::Fd,
-        "file descriptor range check",
-    );
-
-    let contents = &[0u8, 1, 2, 3];
-    let ciovec = wasi::Ciovec {
-        buf: contents.as_ptr() as *const _,
-        buf_len: contents.len(),
-    };
-    let mut nwritten =
-        wasi::fd_pwrite(file_fd, &mut [ciovec], 0).expect("writing bytes at offset 0");
-    assert_eq!(nwritten, 4, "nwritten bytes check");
-
-    let contents = &mut [0u8; 4];
-    let iovec = wasi::Iovec {
-        buf: contents.as_mut_ptr() as *mut _,
-        buf_len: contents.len(),
-    };
-    let mut nread = wasi::fd_pread(file_fd, &[iovec], 0).expect("reading bytes at offset 0");
-    assert_eq!(nread, 4, "nread bytes check");
-    assert_eq!(contents, &[0u8, 1, 2, 3], "written bytes equal read bytes");
-
-    // Write all the data through multiple iovecs.
-    //
-    // Note that this needs to be done with a loop, because some
-    // platforms do not support writing multiple iovecs at once.
-    // See https://github.com/rust-lang/rust/issues/74825.
-    let contents = &[0u8, 1, 2, 3];
-    let mut offset = 0usize;
-    loop {
-        let mut ciovecs: Vec<wasi::Ciovec> = Vec::new();
-        let mut remaining = contents.len() - offset;
-        if remaining > 2 {
-            ciovecs.push(wasi::Ciovec {
-                buf: contents[offset..].as_ptr() as *const _,
-                buf_len: 2,
-            });
-            remaining -= 2;
-        }
-        ciovecs.push(wasi::Ciovec {
-            buf: contents[contents.len() - remaining..].as_ptr() as *const _,
-            buf_len: remaining,
-        });
-
-        nwritten = wasi::fd_pwrite(file_fd, ciovecs.as_slice(), offset.try_into().unwrap())
-            .expect("writing bytes at offset 0");
-
-        offset += nwritten;
-        if offset == contents.len() {
-            break;
-        }
-    }
-    assert_eq!(offset, 4, "nread bytes check");
-
-    // Read all the data through multiple iovecs.
-    //
-    // Note that this needs to be done with a loop, because some
-    // platforms do not support reading multiple iovecs at once.
-    // See https://github.com/rust-lang/rust/issues/74825.
-    let contents = &mut [0u8; 4];
-    let mut offset = 0usize;
-    loop {
-        let buffer = &mut [0u8; 4];
-        let iovecs = &[
-            wasi::Iovec {
-                buf: buffer.as_mut_ptr() as *mut _,
-                buf_len: 2,
-            },
-            wasi::Iovec {
-                buf: buffer[2..].as_mut_ptr() as *mut _,
-                buf_len: 2,
-            },
-        ];
-        nread = wasi::fd_pread(file_fd, iovecs, offset as _).expect("reading bytes at offset 0");
-        if nread == 0 {
-            break;
-        }
-        contents[offset..offset + nread].copy_from_slice(&buffer[0..nread]);
-        offset += nread;
-    }
-    assert_eq!(offset, 4, "nread bytes check");
-    assert_eq!(contents, &[0u8, 1, 2, 3], "file cursor was overwritten");
-
-    let contents = &mut [0u8; 4];
-    let iovec = wasi::Iovec {
-        buf: contents.as_mut_ptr() as *mut _,
-        buf_len: contents.len(),
-    };
-    nread = wasi::fd_pread(file_fd, &[iovec], 2).expect("reading bytes at offset 2");
-    assert_eq!(nread, 2, "nread bytes check");
-    assert_eq!(contents, &[2u8, 3, 0, 0], "file cursor was overwritten");
-
-    let contents = &[1u8, 0];
-    let ciovec = wasi::Ciovec {
-        buf: contents.as_ptr() as *const _,
-        buf_len: contents.len(),
-    };
-    nwritten = wasi::fd_pwrite(file_fd, &mut [ciovec], 2).expect("writing bytes at offset 2");
-    assert_eq!(nwritten, 2, "nwritten bytes check");
-
-    let contents = &mut [0u8; 4];
-    let iovec = wasi::Iovec {
-        buf: contents.as_mut_ptr() as *mut _,
-        buf_len: contents.len(),
-    };
-    nread = wasi::fd_pread(file_fd, &[iovec], 0).expect("reading bytes at offset 0");
-    assert_eq!(nread, 4, "nread bytes check");
-    assert_eq!(contents, &[0u8, 1, 1, 0], "file cursor was overwritten");
-
-    wasi::fd_close(file_fd).expect("closing a file");
-    wasi::path_unlink_file(dir_fd, "file").expect("removing a file");
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_file_pread_pwrite(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/file_seek_tell.rs b/crates/test-programs/wasi-tests/src/bin/file_seek_tell.rs
deleted file mode 100644
index a54fe14ab05c..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/file_seek_tell.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-use std::{env, process};
-use wasi_tests::{assert_errno, open_scratch_directory};
-
-unsafe fn test_file_seek_tell(dir_fd: wasi::Fd) {
-    // Create a file in the scratch directory.
-    let file_fd = wasi::path_open(
-        dir_fd,
-        0,
-        "file",
-        wasi::OFLAGS_CREAT,
-        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
-        0,
-        0,
-    )
-    .expect("opening a file");
-    assert!(
-        file_fd > libc::STDERR_FILENO as wasi::Fd,
-        "file descriptor range check",
-    );
-
-    // Check current offset
-    let mut offset = wasi::fd_tell(file_fd).expect("getting initial file offset");
-    assert_eq!(offset, 0, "current offset should be 0");
-
-    // Write to file
-    let data = &[0u8; 100];
-    let iov = wasi::Ciovec {
-        buf: data.as_ptr() as *const _,
-        buf_len: data.len(),
-    };
-    let nwritten = wasi::fd_write(file_fd, &[iov]).expect("writing to a file");
-    assert_eq!(nwritten, 100, "should write 100 bytes to file");
-
-    // Check current offset
-    offset = wasi::fd_tell(file_fd).expect("getting file offset after writing");
-    assert_eq!(offset, 100, "offset after writing should be 100");
-
-    // Seek to middle of the file
-    let mut newoffset =
-        wasi::fd_seek(file_fd, -50, wasi::WHENCE_CUR).expect("seeking to the middle of a file");
-    assert_eq!(
-        newoffset, 50,
-        "offset after seeking to the middle should be at 50"
-    );
-
-    // Seek to the beginning of the file
-    newoffset =
-        wasi::fd_seek(file_fd, 0, wasi::WHENCE_SET).expect("seeking to the beginning of the file");
-    assert_eq!(
-        newoffset, 0,
-        "offset after seeking to the beginning of the file should be at 0"
-    );
-
-    // Seek beyond the file should be possible
-    wasi::fd_seek(file_fd, 1000, wasi::WHENCE_CUR).expect("seeking beyond the end of the file");
-
-    // Seek before byte 0 is an error though
-    assert_errno!(
-        wasi::fd_seek(file_fd, -2000, wasi::WHENCE_CUR)
-            .expect_err("seeking before byte 0 should be an error"),
-        wasi::ERRNO_INVAL
-    );
-
-    // Check that fd_read properly updates the file offset
-    wasi::fd_seek(file_fd, 0, wasi::WHENCE_SET)
-        .expect("seeking to the beginning of the file again");
-
-    let buffer = &mut [0u8; 100];
-    let iovec = wasi::Iovec {
-        buf: buffer.as_mut_ptr(),
-        buf_len: buffer.len(),
-    };
-    let nread = wasi::fd_read(file_fd, &[iovec]).expect("reading file");
-    assert_eq!(nread, buffer.len(), "should read {} bytes", buffer.len());
-
-    offset = wasi::fd_tell(file_fd).expect("getting file offset after reading");
-    assert_eq!(offset, 100, "offset after reading should be 100");
-
-    wasi::fd_close(file_fd).expect("closing a file");
-    wasi::path_unlink_file(dir_fd, "file").expect("deleting a file");
-}
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_file_seek_tell(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/file_truncation.rs b/crates/test-programs/wasi-tests/src/bin/file_truncation.rs
deleted file mode 100644
index 35f511448ac7..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/file_truncation.rs
+++ /dev/null
@@ -1,83 +0,0 @@
-use std::{env, process};
-use wasi_tests::open_scratch_directory;
-
-unsafe fn test_file_truncation(dir_fd: wasi::Fd) {
-    const FILENAME: &str = "test.txt";
-
-    // Open a file for writing
-    let file_fd = wasi::path_open(
-        dir_fd,
-        0,
-        FILENAME,
-        wasi::OFLAGS_CREAT,
-        wasi::RIGHTS_FD_WRITE,
-        0,
-        0,
-    )
-    .expect("creating a file for writing");
-
-    // Write to the file
-    let content = b"this content will be truncated!";
-    let nwritten = wasi::fd_write(
-        file_fd,
-        &[wasi::Ciovec {
-            buf: content.as_ptr() as *const _,
-            buf_len: content.len(),
-        }],
-    )
-    .expect("writing file content");
-    assert_eq!(nwritten, content.len(), "nwritten bytes check");
-
-    wasi::fd_close(file_fd).expect("closing the file");
-
-    // Open the file for truncation
-    let file_fd = wasi::path_open(
-        dir_fd,
-        0,
-        FILENAME,
-        wasi::OFLAGS_CREAT | wasi::OFLAGS_TRUNC,
-        wasi::RIGHTS_FD_WRITE | wasi::RIGHTS_FD_READ,
-        0,
-        0,
-    )
-    .expect("creating a truncated file for reading");
-
-    // Read the file's contents
-    let buffer = &mut [0u8; 100];
-    let nread = wasi::fd_read(
-        file_fd,
-        &[wasi::Iovec {
-            buf: buffer.as_mut_ptr(),
-            buf_len: buffer.len(),
-        }],
-    )
-    .expect("reading file content");
-
-    // The file should be empty due to truncation
-    assert_eq!(nread, 0, "expected an empty file after truncation");
-
-    wasi::fd_close(file_fd).expect("closing the file");
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_file_truncation(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/file_unbuffered_write.rs b/crates/test-programs/wasi-tests/src/bin/file_unbuffered_write.rs
deleted file mode 100644
index 8056834fb347..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/file_unbuffered_write.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-use std::{env, process};
-use wasi_tests::open_scratch_directory;
-
-unsafe fn test_file_unbuffered_write(dir_fd: wasi::Fd) {
-    // Create and open file for reading
-    let fd_read = wasi::path_open(
-        dir_fd,
-        0,
-        "file",
-        wasi::OFLAGS_CREAT,
-        wasi::RIGHTS_FD_READ,
-        0,
-        0,
-    )
-    .expect("create and open file for reading");
-    assert!(
-        fd_read > libc::STDERR_FILENO as wasi::Fd,
-        "file descriptor range check",
-    );
-
-    // Open the same file but for writing
-    let fd_write = wasi::path_open(dir_fd, 0, "file", 0, wasi::RIGHTS_FD_WRITE, 0, 0)
-        .expect("opening file for writing");
-    assert!(
-        fd_write > libc::STDERR_FILENO as wasi::Fd,
-        "file descriptor range check",
-    );
-
-    // Write to file
-    let contents = &[1u8];
-    let ciovec = wasi::Ciovec {
-        buf: contents.as_ptr() as *const _,
-        buf_len: contents.len(),
-    };
-    let nwritten = wasi::fd_write(fd_write, &[ciovec]).expect("writing byte to file");
-    assert_eq!(nwritten, 1, "nwritten bytes check");
-
-    // Read from file
-    let contents = &mut [0u8; 1];
-    let iovec = wasi::Iovec {
-        buf: contents.as_mut_ptr() as *mut _,
-        buf_len: contents.len(),
-    };
-    let nread = wasi::fd_read(fd_read, &[iovec]).expect("reading bytes from file");
-    assert_eq!(nread, 1, "nread bytes check");
-    assert_eq!(contents, &[1u8], "written bytes equal read bytes");
-
-    // Clean up
-    wasi::fd_close(fd_write).expect("closing a file");
-    wasi::fd_close(fd_read).expect("closing a file");
-    wasi::path_unlink_file(dir_fd, "file").expect("removing a file");
-}
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_file_unbuffered_write(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/interesting_paths.rs b/crates/test-programs/wasi-tests/src/bin/interesting_paths.rs
deleted file mode 100644
index 16954c92fd4f..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/interesting_paths.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-use std::{env, process};
-use wasi_tests::{assert_errno, create_file, open_scratch_directory};
-
-unsafe fn test_interesting_paths(dir_fd: wasi::Fd, arg: &str) {
-    // Create a directory in the scratch directory.
-    wasi::path_create_directory(dir_fd, "dir").expect("creating dir");
-
-    // Create a directory in the directory we just created.
-    wasi::path_create_directory(dir_fd, "dir/nested").expect("creating a nested dir");
-
-    // Create a file in the nested directory.
-    create_file(dir_fd, "dir/nested/file");
-
-    // Now open it with an absolute path.
-    assert_errno!(
-        wasi::path_open(dir_fd, 0, "/dir/nested/file", 0, 0, 0, 0)
-            .expect_err("opening a file with an absolute path"),
-        wasi::ERRNO_PERM
-    );
-
-    // Now open it with a path containing "..".
-    let mut file_fd = wasi::path_open(
-        dir_fd,
-        0,
-        "dir/.//nested/../../dir/nested/../nested///./file",
-        0,
-        0,
-        0,
-        0,
-    )
-    .expect("opening a file with \"..\" in the path");
-    assert!(
-        file_fd > libc::STDERR_FILENO as wasi::Fd,
-        "file descriptor range check",
-    );
-    wasi::fd_close(file_fd).expect("closing a file");
-
-    // Now open it with a trailing NUL.
-    assert_errno!(
-        wasi::path_open(dir_fd, 0, "dir/nested/file\0", 0, 0, 0, 0)
-            .expect_err("opening a file with a trailing NUL"),
-        wasi::ERRNO_INVAL,
-        wasi::ERRNO_ILSEQ
-    );
-
-    // Now open it with a trailing slash.
-    assert_errno!(
-        wasi::path_open(dir_fd, 0, "dir/nested/file/", 0, 0, 0, 0)
-            .expect_err("opening a file with a trailing slash should fail"),
-        wasi::ERRNO_NOTDIR,
-        wasi::ERRNO_NOENT
-    );
-
-    // Now open it with trailing slashes.
-    assert_errno!(
-        wasi::path_open(dir_fd, 0, "dir/nested/file///", 0, 0, 0, 0)
-            .expect_err("opening a file with trailing slashes should fail"),
-        wasi::ERRNO_NOTDIR,
-        wasi::ERRNO_NOENT
-    );
-
-    // Now open the directory with a trailing slash.
-    file_fd = wasi::path_open(dir_fd, 0, "dir/nested/", 0, 0, 0, 0)
-        .expect("opening a directory with a trailing slash");
-    assert!(
-        file_fd > libc::STDERR_FILENO as wasi::Fd,
-        "file descriptor range check",
-    );
-    wasi::fd_close(file_fd).expect("closing a file");
-
-    // Now open the directory with trailing slashes.
-    file_fd = wasi::path_open(dir_fd, 0, "dir/nested///", 0, 0, 0, 0)
-        .expect("opening a directory with trailing slashes");
-    assert!(
-        file_fd > libc::STDERR_FILENO as wasi::Fd,
-        "file descriptor range check",
-    );
-    wasi::fd_close(file_fd).expect("closing a file");
-
-    // Now open it with a path containing too many ".."s.
-    let bad_path = format!("dir/nested/../../../{}/dir/nested/file", arg);
-    assert_errno!(
-        wasi::path_open(dir_fd, 0, &bad_path, 0, 0, 0, 0)
-            .expect_err("opening a file with too many \"..\"s in the path should fail"),
-        wasi::ERRNO_PERM
-    );
-    wasi::path_unlink_file(dir_fd, "dir/nested/file")
-        .expect("unlink_file on a symlink should succeed");
-    wasi::path_remove_directory(dir_fd, "dir/nested")
-        .expect("remove_directory on a directory should succeed");
-    wasi::path_remove_directory(dir_fd, "dir")
-        .expect("remove_directory on a directory should succeed");
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_interesting_paths(dir_fd, &arg) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/nofollow_errors.rs b/crates/test-programs/wasi-tests/src/bin/nofollow_errors.rs
deleted file mode 100644
index 86c6f385896b..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/nofollow_errors.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-use std::{env, process};
-use wasi_tests::{assert_errno, open_scratch_directory};
-
-unsafe fn test_nofollow_errors(dir_fd: wasi::Fd) {
-    // Create a directory for the symlink to point to.
-    wasi::path_create_directory(dir_fd, "target").expect("creating a dir");
-
-    // Create a symlink.
-    wasi::path_symlink("target", dir_fd, "symlink").expect("creating a symlink");
-
-    // Try to open it as a directory with O_NOFOLLOW again.
-    assert_errno!(
-        wasi::path_open(dir_fd, 0, "symlink", wasi::OFLAGS_DIRECTORY, 0, 0, 0)
-            .expect_err("opening a directory symlink as a directory should fail"),
-        wasi::ERRNO_LOOP,
-        wasi::ERRNO_NOTDIR
-    );
-
-    // Try to open it with just O_NOFOLLOW.
-    assert_errno!(
-        wasi::path_open(dir_fd, 0, "symlink", 0, 0, 0, 0)
-            .expect_err("opening a symlink with O_NOFOLLOW should fail"),
-        wasi::ERRNO_LOOP,
-        wasi::ERRNO_ACCES
-    );
-
-    // Try to open it as a directory without O_NOFOLLOW.
-    let file_fd = wasi::path_open(
-        dir_fd,
-        wasi::LOOKUPFLAGS_SYMLINK_FOLLOW,
-        "symlink",
-        wasi::OFLAGS_DIRECTORY,
-        0,
-        0,
-        0,
-    )
-    .expect("opening a symlink as a directory");
-    assert!(
-        file_fd > libc::STDERR_FILENO as wasi::Fd,
-        "file descriptor range check",
-    );
-    wasi::fd_close(file_fd).expect("closing a file");
-
-    // Replace the target directory with a file.
-    wasi::path_unlink_file(dir_fd, "symlink").expect("removing a file");
-    wasi::path_remove_directory(dir_fd, "target")
-        .expect("remove_directory on a directory should succeed");
-
-    let file_fd =
-        wasi::path_open(dir_fd, 0, "target", wasi::OFLAGS_CREAT, 0, 0, 0).expect("creating a file");
-    wasi::fd_close(file_fd).expect("closing a file");
-    wasi::path_symlink("target", dir_fd, "symlink").expect("creating a symlink");
-
-    // Try to open it as a directory with O_NOFOLLOW again.
-    assert_errno!(
-        wasi::path_open(dir_fd, 0, "symlink", wasi::OFLAGS_DIRECTORY, 0, 0, 0)
-            .expect_err("opening a directory symlink as a directory should fail"),
-        wasi::ERRNO_LOOP,
-        wasi::ERRNO_NOTDIR
-    );
-
-    // Try to open it with just O_NOFOLLOW.
-    assert_errno!(
-        wasi::path_open(dir_fd, 0, "symlink", 0, 0, 0, 0)
-            .expect_err("opening a symlink with NOFOLLOW should fail"),
-        wasi::ERRNO_LOOP
-    );
-
-    // Try to open it as a directory without O_NOFOLLOW.
-    assert_errno!(
-        wasi::path_open(
-            dir_fd,
-            wasi::LOOKUPFLAGS_SYMLINK_FOLLOW,
-            "symlink",
-            wasi::OFLAGS_DIRECTORY,
-            0,
-            0,
-            0,
-        )
-        .expect_err("opening a symlink to a file as a directory"),
-        wasi::ERRNO_NOTDIR
-    );
-
-    // Clean up.
-    wasi::path_unlink_file(dir_fd, "target").expect("removing a file");
-    wasi::path_unlink_file(dir_fd, "symlink").expect("removing a file");
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_nofollow_errors(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/overwrite_preopen.rs b/crates/test-programs/wasi-tests/src/bin/overwrite_preopen.rs
deleted file mode 100644
index 0721d18ab1bd..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/overwrite_preopen.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-use std::{env, process};
-use wasi_tests::{assert_errno, open_scratch_directory};
-
-unsafe fn test_overwrite_preopen(dir_fd: wasi::Fd) {
-    let pre_fd: wasi::Fd = (libc::STDERR_FILENO + 1) as wasi::Fd;
-
-    assert!(dir_fd > pre_fd, "dir_fd number");
-
-    let old_dir_filestat = wasi::fd_filestat_get(dir_fd).expect("failed fd_filestat_get");
-
-    // Try to renumber over a preopened directory handle.
-    wasi::fd_renumber(dir_fd, pre_fd).expect("renumbering over a preopened file descriptor");
-
-    // Ensure that pre_fd is still open.
-    let new_dir_filestat = wasi::fd_filestat_get(pre_fd).expect("failed fd_filestat_get");
-
-    // Ensure that we renumbered.
-    assert_eq!(old_dir_filestat.dev, new_dir_filestat.dev);
-    assert_eq!(old_dir_filestat.ino, new_dir_filestat.ino);
-
-    // Ensure that dir_fd is closed.
-    assert_errno!(
-        wasi::fd_fdstat_get(dir_fd).expect_err("failed fd_fdstat_get"),
-        wasi::ERRNO_BADF
-    );
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_overwrite_preopen(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/path_exists.rs b/crates/test-programs/wasi-tests/src/bin/path_exists.rs
deleted file mode 100644
index c4d7a04667cf..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/path_exists.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-use std::{env, process};
-use wasi_tests::{create_file, open_scratch_directory};
-
-unsafe fn test_path_exists(dir_fd: wasi::Fd) {
-    // Create a temporary directory
-    wasi::path_create_directory(dir_fd, "subdir").expect("create directory");
-
-    // Check directory exists:
-    let file_stat = wasi::path_filestat_get(dir_fd, 0, "subdir").expect("reading file stats");
-    assert_eq!(file_stat.filetype, wasi::FILETYPE_DIRECTORY);
-
-    // Should still exist with symlink follow flag:
-    let file_stat = wasi::path_filestat_get(dir_fd, wasi::LOOKUPFLAGS_SYMLINK_FOLLOW, "subdir")
-        .expect("reading file stats");
-    assert_eq!(file_stat.filetype, wasi::FILETYPE_DIRECTORY);
-
-    // Create a file:
-    create_file(dir_fd, "subdir/file");
-    // Check directory exists:
-    let file_stat = wasi::path_filestat_get(dir_fd, 0, "subdir/file").expect("reading file stats");
-    assert_eq!(file_stat.filetype, wasi::FILETYPE_REGULAR_FILE);
-
-    // Should still exist with symlink follow flag:
-    let file_stat =
-        wasi::path_filestat_get(dir_fd, wasi::LOOKUPFLAGS_SYMLINK_FOLLOW, "subdir/file")
-            .expect("reading file stats");
-    assert_eq!(file_stat.filetype, wasi::FILETYPE_REGULAR_FILE);
-
-    // Create a symlink to a file:
-    wasi::path_symlink("subdir/file", dir_fd, "link1").expect("create symlink");
-    // Check symlink exists:
-    let file_stat = wasi::path_filestat_get(dir_fd, 0, "link1").expect("reading file stats");
-    assert_eq!(file_stat.filetype, wasi::FILETYPE_SYMBOLIC_LINK);
-
-    // Should still exist with symlink follow flag, pointing to regular file
-    let file_stat = wasi::path_filestat_get(dir_fd, wasi::LOOKUPFLAGS_SYMLINK_FOLLOW, "link1")
-        .expect("reading file stats");
-    assert_eq!(file_stat.filetype, wasi::FILETYPE_REGULAR_FILE);
-
-    // Create a symlink to a dir:
-    wasi::path_symlink("subdir", dir_fd, "link2").expect("create symlink");
-    // Check symlink exists:
-    let file_stat = wasi::path_filestat_get(dir_fd, 0, "link2").expect("reading file stats");
-    assert_eq!(file_stat.filetype, wasi::FILETYPE_SYMBOLIC_LINK);
-
-    // Should still exist with symlink follow flag, pointing to directory
-    let file_stat = wasi::path_filestat_get(dir_fd, wasi::LOOKUPFLAGS_SYMLINK_FOLLOW, "link2")
-        .expect("reading file stats");
-    assert_eq!(file_stat.filetype, wasi::FILETYPE_DIRECTORY);
-
-    wasi::path_unlink_file(dir_fd, "link1").expect("clean up");
-    wasi::path_unlink_file(dir_fd, "link2").expect("clean up");
-    wasi::path_unlink_file(dir_fd, "subdir/file").expect("clean up");
-    wasi::path_remove_directory(dir_fd, "subdir").expect("clean up");
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-    // Run the tests.
-    unsafe { test_path_exists(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/path_filestat.rs b/crates/test-programs/wasi-tests/src/bin/path_filestat.rs
deleted file mode 100644
index 2c4b63a93e8c..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/path_filestat.rs
+++ /dev/null
@@ -1,130 +0,0 @@
-use std::{env, process};
-use wasi_tests::{assert_errno, open_scratch_directory, TESTCONFIG};
-
-unsafe fn test_path_filestat(dir_fd: wasi::Fd) {
-    let fdflags = if TESTCONFIG.support_fdflags_sync() {
-        wasi::FDFLAGS_APPEND | wasi::FDFLAGS_SYNC
-    } else {
-        wasi::FDFLAGS_APPEND
-    };
-
-    // Create a file in the scratch directory.
-    let file_fd = wasi::path_open(
-        dir_fd,
-        0,
-        "file",
-        wasi::OFLAGS_CREAT,
-        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
-        0,
-        // Pass some flags for later retrieval
-        fdflags,
-    )
-    .expect("opening a file");
-    assert!(
-        file_fd > libc::STDERR_FILENO as wasi::Fd,
-        "file descriptor range check",
-    );
-
-    let fdstat = wasi::fd_fdstat_get(file_fd).expect("fd_fdstat_get");
-    assert_eq!(
-        fdstat.fs_flags & wasi::FDFLAGS_APPEND,
-        wasi::FDFLAGS_APPEND,
-        "file should have the APPEND fdflag used to create the file"
-    );
-    if TESTCONFIG.support_fdflags_sync() {
-        assert_eq!(
-            fdstat.fs_flags & wasi::FDFLAGS_SYNC,
-            wasi::FDFLAGS_SYNC,
-            "file should have the SYNC fdflag used to create the file"
-        );
-    }
-
-    if !TESTCONFIG.support_fdflags_sync() {
-        assert_errno!(
-            wasi::path_open(
-                dir_fd,
-                0,
-                "file",
-                0,
-                wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
-                0,
-                wasi::FDFLAGS_SYNC,
-            )
-            .expect_err("FDFLAGS_SYNC not supported by platform"),
-            wasi::ERRNO_NOTSUP
-        );
-    }
-
-    // Check file size
-    let file_stat = wasi::path_filestat_get(dir_fd, 0, "file").expect("reading file stats");
-    assert_eq!(file_stat.size, 0, "file size should be 0");
-
-    // Check path_filestat_set_times
-    let new_mtim = file_stat.mtim - 100;
-    wasi::path_filestat_set_times(dir_fd, 0, "file", 0, new_mtim, wasi::FSTFLAGS_MTIM)
-        .expect("path_filestat_set_times should succeed");
-
-    let modified_file_stat = wasi::path_filestat_get(dir_fd, 0, "file")
-        .expect("reading file stats after path_filestat_set_times");
-    assert_eq!(modified_file_stat.mtim, new_mtim, "mtim should change");
-
-    assert_errno!(
-        wasi::path_filestat_set_times(
-            dir_fd,
-            0,
-            "file",
-            0,
-            new_mtim,
-            wasi::FSTFLAGS_MTIM | wasi::FSTFLAGS_MTIM_NOW,
-        )
-        .expect_err("MTIM and MTIM_NOW can't both be set"),
-        wasi::ERRNO_INVAL
-    );
-
-    // check if the times were untouched
-    let unmodified_file_stat = wasi::path_filestat_get(dir_fd, 0, "file")
-        .expect("reading file stats after ERRNO_INVAL fd_filestat_set_times");
-    assert_eq!(
-        unmodified_file_stat.mtim, new_mtim,
-        "mtim should not change"
-    );
-
-    // Invalid arguments to set_times:
-    assert_errno!(
-        wasi::path_filestat_set_times(
-            dir_fd,
-            0,
-            "file",
-            0,
-            0,
-            wasi::FSTFLAGS_ATIM | wasi::FSTFLAGS_ATIM_NOW,
-        )
-        .expect_err("ATIM & ATIM_NOW can't both be set"),
-        wasi::ERRNO_INVAL
-    );
-
-    wasi::fd_close(file_fd).expect("closing a file");
-    wasi::path_unlink_file(dir_fd, "file").expect("removing a file");
-}
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_path_filestat(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/path_link.rs b/crates/test-programs/wasi-tests/src/bin/path_link.rs
deleted file mode 100644
index 161d865df568..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/path_link.rs
+++ /dev/null
@@ -1,209 +0,0 @@
-use std::{env, process};
-use wasi_tests::{assert_errno, create_file, open_scratch_directory, TESTCONFIG};
-
-unsafe fn create_or_open(dir_fd: wasi::Fd, name: &str, flags: wasi::Oflags) -> wasi::Fd {
-    let file_fd = wasi::path_open(dir_fd, 0, name, flags, 0, 0, 0)
-        .unwrap_or_else(|_| panic!("opening '{}'", name));
-    assert!(
-        file_fd > libc::STDERR_FILENO as wasi::Fd,
-        "file descriptor range check",
-    );
-    file_fd
-}
-
-unsafe fn open_link(dir_fd: wasi::Fd, name: &str) -> wasi::Fd {
-    let file_fd = wasi::path_open(dir_fd, 0, name, 0, 0, 0, 0)
-        .unwrap_or_else(|_| panic!("opening a link '{}'", name));
-    assert!(
-        file_fd > libc::STDERR_FILENO as wasi::Fd,
-        "file descriptor range check",
-    );
-    file_fd
-}
-
-// This is temporary until `wasi` implements `Debug` and `PartialEq` for
-// `wasi::Filestat`.
-fn filestats_assert_eq(left: wasi::Filestat, right: wasi::Filestat) {
-    assert_eq!(left.dev, right.dev, "dev should be equal");
-    assert_eq!(left.ino, right.ino, "ino should be equal");
-    assert_eq!(left.atim, right.atim, "atim should be equal");
-    assert_eq!(left.ctim, right.ctim, "ctim should be equal");
-    assert_eq!(left.mtim, right.mtim, "mtim should be equal");
-    assert_eq!(left.size, right.size, "size should be equal");
-    assert_eq!(left.nlink, right.nlink, "nlink should be equal");
-    assert_eq!(left.filetype, right.filetype, "filetype should be equal");
-}
-
-// This is temporary until `wasi` implements `Debug` and `PartialEq` for
-// `wasi::Fdstat`.
-fn fdstats_assert_eq(left: wasi::Fdstat, right: wasi::Fdstat) {
-    assert_eq!(left.fs_flags, right.fs_flags, "fs_flags should be equal");
-    assert_eq!(
-        left.fs_filetype, right.fs_filetype,
-        "fs_filetype should be equal"
-    );
-    assert_eq!(
-        left.fs_rights_base, right.fs_rights_base,
-        "fs_rights_base should be equal"
-    );
-    assert_eq!(
-        left.fs_rights_inheriting, right.fs_rights_inheriting,
-        "fs_rights_inheriting should be equal"
-    );
-}
-
-unsafe fn check_rights(orig_fd: wasi::Fd, link_fd: wasi::Fd) {
-    // Compare Filestats
-    let orig_filestat = wasi::fd_filestat_get(orig_fd).expect("reading filestat of the source");
-    let link_filestat = wasi::fd_filestat_get(link_fd).expect("reading filestat of the link");
-    filestats_assert_eq(orig_filestat, link_filestat);
-
-    // Compare Fdstats
-    let orig_fdstat = wasi::fd_fdstat_get(orig_fd).expect("reading fdstat of the source");
-    let link_fdstat = wasi::fd_fdstat_get(link_fd).expect("reading fdstat of the link");
-    fdstats_assert_eq(orig_fdstat, link_fdstat);
-}
-
-// Extra calls of fd_close are needed for Windows, which will not remove
-// the directory until all handles are closed.
-unsafe fn test_path_link(dir_fd: wasi::Fd) {
-    // Create a file
-    let file_fd = create_or_open(dir_fd, "file", wasi::OFLAGS_CREAT);
-
-    // Create a link in the same directory and compare rights
-    wasi::path_link(dir_fd, 0, "file", dir_fd, "link")
-        .expect("creating a link in the same directory");
-    let link_fd = open_link(dir_fd, "link");
-    check_rights(file_fd, link_fd);
-    wasi::fd_close(link_fd).expect("Closing link_fd"); // needed for Windows
-    wasi::path_unlink_file(dir_fd, "link").expect("removing a link");
-
-    // Create a link in a different directory and compare rights
-    wasi::path_create_directory(dir_fd, "subdir").expect("creating a subdirectory");
-    let subdir_fd = create_or_open(dir_fd, "subdir", wasi::OFLAGS_DIRECTORY);
-    wasi::path_link(dir_fd, 0, "file", subdir_fd, "link").expect("creating a link in subdirectory");
-    let link_fd = open_link(subdir_fd, "link");
-    check_rights(file_fd, link_fd);
-    wasi::fd_close(link_fd).expect("Closing link_fd"); // needed for Windows
-    wasi::path_unlink_file(subdir_fd, "link").expect("removing a link");
-    wasi::fd_close(subdir_fd).expect("Closing subdir_fd"); // needed for Windows
-    wasi::path_remove_directory(dir_fd, "subdir").expect("removing a subdirectory");
-
-    // Create a link to a path that already exists
-    create_file(dir_fd, "link");
-
-    assert_errno!(
-        wasi::path_link(dir_fd, 0, "file", dir_fd, "link")
-            .expect_err("creating a link to existing path should fail"),
-        wasi::ERRNO_EXIST
-    );
-    wasi::path_unlink_file(dir_fd, "link").expect("removing a file");
-
-    // Create a link to itself
-    assert_errno!(
-        wasi::path_link(dir_fd, 0, "file", dir_fd, "file")
-            .expect_err("creating a link to itself should fail"),
-        wasi::ERRNO_EXIST
-    );
-
-    // Create a link where target is a directory
-    wasi::path_create_directory(dir_fd, "link").expect("creating a dir");
-
-    assert_errno!(
-        wasi::path_link(dir_fd, 0, "file", dir_fd, "link")
-            .expect_err("creating a link where target is a directory should fail"),
-        wasi::ERRNO_EXIST
-    );
-    wasi::path_remove_directory(dir_fd, "link").expect("removing a dir");
-
-    // Create a link to a directory
-    wasi::path_create_directory(dir_fd, "subdir").expect("creating a subdirectory");
-    let subdir_fd = create_or_open(dir_fd, "subdir", wasi::OFLAGS_DIRECTORY);
-
-    assert_errno!(
-        wasi::path_link(dir_fd, 0, "subdir", dir_fd, "link")
-            .expect_err("creating a link to a directory should fail"),
-        wasi::ERRNO_PERM,
-        wasi::ERRNO_ACCES
-    );
-    wasi::fd_close(subdir_fd).expect("close subdir before deleting it");
-    wasi::path_remove_directory(dir_fd, "subdir").expect("removing a subdirectory");
-
-    // Create a link to a file with trailing slash
-    assert_errno!(
-        wasi::path_link(dir_fd, 0, "file", dir_fd, "link/")
-            .expect_err("creating a link to a file with trailing slash should fail"),
-        wasi::ERRNO_NOENT
-    );
-
-    if TESTCONFIG.support_dangling_filesystem() {
-        // Create a link to a dangling symlink
-        wasi::path_symlink("target", dir_fd, "symlink").expect("creating a dangling symlink");
-
-        // This should succeed, because we're not following symlinks
-        wasi::path_link(dir_fd, 0, "symlink", dir_fd, "link")
-            .expect("creating a link to a dangling symlink should succeed");
-        wasi::path_unlink_file(dir_fd, "symlink").expect("removing a symlink");
-        wasi::path_unlink_file(dir_fd, "link").expect("removing a hardlink");
-
-        // Create a link to a symlink loop
-        wasi::path_symlink("symlink", dir_fd, "symlink").expect("creating a symlink loop");
-
-        wasi::path_link(dir_fd, 0, "symlink", dir_fd, "link")
-            .expect("creating a link to a symlink loop should succeed");
-        wasi::path_unlink_file(dir_fd, "symlink").expect("removing a symlink");
-        wasi::path_unlink_file(dir_fd, "link").expect("removing a hardlink");
-
-        // Create a link where target is a dangling symlink
-        wasi::path_symlink("target", dir_fd, "symlink").expect("creating a dangling symlink");
-
-        assert_errno!(
-            wasi::path_link(dir_fd, 0, "file", dir_fd, "symlink")
-                .expect_err("creating a link where target is a dangling symlink"),
-            wasi::ERRNO_EXIST
-        );
-        wasi::path_unlink_file(dir_fd, "symlink").expect("removing a symlink");
-
-        // Create a link where target is a dangling symlink following symlinks
-        wasi::path_symlink("target", dir_fd, "symlink").expect("creating a dangling symlink");
-
-        // Symlink following with path_link is rejected
-        assert_errno!(
-            wasi::path_link(
-                dir_fd,
-                wasi::LOOKUPFLAGS_SYMLINK_FOLLOW,
-                "symlink",
-                dir_fd,
-                "link",
-            )
-            .expect_err("calling path_link with LOOKUPFLAGS_SYMLINK_FOLLOW should fail"),
-            wasi::ERRNO_INVAL
-        );
-
-        // Clean up.
-        wasi::path_unlink_file(dir_fd, "file").expect("removing a file");
-    }
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_path_link(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/path_open_create_existing.rs b/crates/test-programs/wasi-tests/src/bin/path_open_create_existing.rs
deleted file mode 100644
index 5c4cca201689..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/path_open_create_existing.rs
+++ /dev/null
@@ -1,43 +0,0 @@
-use std::{env, process};
-use wasi_tests::{assert_errno, create_file, open_scratch_directory};
-
-unsafe fn test_path_open_create_existing(dir_fd: wasi::Fd) {
-    create_file(dir_fd, "file");
-    assert_errno!(
-        wasi::path_open(
-            dir_fd,
-            0,
-            "file",
-            wasi::OFLAGS_CREAT | wasi::OFLAGS_EXCL,
-            0,
-            0,
-            0,
-        )
-        .expect_err("trying to create a file that already exists"),
-        wasi::ERRNO_EXIST
-    );
-    wasi::path_unlink_file(dir_fd, "file").expect("removing a file");
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_path_open_create_existing(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/path_open_dirfd_not_dir.rs b/crates/test-programs/wasi-tests/src/bin/path_open_dirfd_not_dir.rs
deleted file mode 100644
index 74a0d57d2580..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/path_open_dirfd_not_dir.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-use std::{env, process};
-use wasi_tests::{assert_errno, open_scratch_directory};
-
-unsafe fn test_dirfd_not_dir(dir_fd: wasi::Fd) {
-    // Open a file.
-    let file_fd =
-        wasi::path_open(dir_fd, 0, "file", wasi::OFLAGS_CREAT, 0, 0, 0).expect("opening a file");
-    // Now try to open a file underneath it as if it were a directory.
-    assert_errno!(
-        wasi::path_open(file_fd, 0, "foo", wasi::OFLAGS_CREAT, 0, 0, 0)
-            .expect_err("non-directory base fd should get ERRNO_NOTDIR"),
-        wasi::ERRNO_NOTDIR
-    );
-    wasi::fd_close(file_fd).expect("closing a file");
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_dirfd_not_dir(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/path_open_missing.rs b/crates/test-programs/wasi-tests/src/bin/path_open_missing.rs
deleted file mode 100644
index 3f56f8d75dc4..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/path_open_missing.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-use std::{env, process};
-use wasi_tests::{assert_errno, open_scratch_directory};
-
-unsafe fn test_path_open_missing(dir_fd: wasi::Fd) {
-    assert_errno!(
-        wasi::path_open(
-            dir_fd, 0, "file", 0, // not passing O_CREAT here
-            0, 0, 0,
-        )
-        .expect_err("trying to open a file that doesn't exist"),
-        wasi::ERRNO_NOENT
-    );
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_path_open_missing(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/path_open_nonblock.rs b/crates/test-programs/wasi-tests/src/bin/path_open_nonblock.rs
deleted file mode 100644
index 3ca99418117b..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/path_open_nonblock.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-use std::{env, process};
-use wasi_tests::open_scratch_directory;
-
-unsafe fn try_path_open(dir_fd: wasi::Fd) {
-    let _fd =
-        wasi::path_open(dir_fd, 0, ".", 0, 0, 0, wasi::FDFLAGS_NONBLOCK).expect("opening the dir");
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { try_path_open(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/path_open_preopen.rs b/crates/test-programs/wasi-tests/src/bin/path_open_preopen.rs
deleted file mode 100644
index cb8e07490f6d..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/path_open_preopen.rs
+++ /dev/null
@@ -1,153 +0,0 @@
-const FIRST_PREOPEN: u32 = 3;
-
-unsafe fn path_open_preopen() {
-    let prestat = wasi::fd_prestat_get(FIRST_PREOPEN).expect("fd 3 is a preopen");
-    assert_eq!(
-        prestat.tag,
-        wasi::PREOPENTYPE_DIR.raw(),
-        "prestat is a directory"
-    );
-    let mut dst = Vec::with_capacity(prestat.u.dir.pr_name_len);
-    wasi::fd_prestat_dir_name(FIRST_PREOPEN, dst.as_mut_ptr(), dst.capacity())
-        .expect("get preopen dir name");
-    dst.set_len(prestat.u.dir.pr_name_len);
-
-    let fdstat = wasi::fd_fdstat_get(FIRST_PREOPEN).expect("get fdstat");
-
-    println!(
-        "preopen dir: {:?} base {:?} inheriting {:?}",
-        String::from_utf8_lossy(&dst),
-        fdstat.fs_rights_base,
-        fdstat.fs_rights_inheriting
-    );
-    for (right, name) in directory_base_rights() {
-        assert!(
-            (fdstat.fs_rights_base & right) == right,
-            "fs_rights_base does not have required right `{name}`"
-        );
-    }
-    for (right, name) in directory_inheriting_rights() {
-        assert!(
-            (fdstat.fs_rights_inheriting & right) == right,
-            "fs_rights_inheriting does not have required right `{name}`"
-        );
-    }
-
-    // Open with same rights it has now:
-    let _ = wasi::path_open(
-        FIRST_PREOPEN,
-        0,
-        ".",
-        0,
-        fdstat.fs_rights_base,
-        fdstat.fs_rights_inheriting,
-        0,
-    )
-    .expect("open with same rights");
-
-    // Open with an empty set of rights:
-    let _ = wasi::path_open(FIRST_PREOPEN, 0, ".", 0, 0, 0, 0).expect("open with empty rights");
-
-    // Open OFLAGS_DIRECTORY with an empty set of rights:
-    let _ = wasi::path_open(FIRST_PREOPEN, 0, ".", wasi::OFLAGS_DIRECTORY, 0, 0, 0)
-        .expect("open with O_DIRECTORY empty rights");
-
-    // Open OFLAGS_DIRECTORY with just the read right:
-    let _ = wasi::path_open(
-        FIRST_PREOPEN,
-        0,
-        ".",
-        wasi::OFLAGS_DIRECTORY,
-        wasi::RIGHTS_FD_READ,
-        0,
-        0,
-    )
-    .expect("open with O_DIRECTORY and read right");
-
-    if !wasi_tests::TESTCONFIG.errno_expect_windows() {
-        // Open OFLAGS_DIRECTORY and read/write rights should fail with isdir:
-        let err = wasi::path_open(
-            FIRST_PREOPEN,
-            0,
-            ".",
-            wasi::OFLAGS_DIRECTORY,
-            wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
-            0,
-            0,
-        )
-        .err()
-        .expect("open with O_DIRECTORY and read/write should fail");
-        assert_eq!(
-            err,
-            wasi::ERRNO_ISDIR,
-            "opening directory read/write should fail with ISDIR"
-        );
-    } else {
-        // Open OFLAGS_DIRECTORY and read/write rights will succeed, only on windows:
-        let _ = wasi::path_open(
-            FIRST_PREOPEN,
-            0,
-            ".",
-            wasi::OFLAGS_DIRECTORY,
-            wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
-            0,
-            0,
-        )
-        .expect("open with O_DIRECTORY and read/write should succeed on windows");
-    }
-}
-
-fn main() {
-    unsafe {
-        path_open_preopen();
-    }
-}
-
-// Hard-code the set of rights expected for a preopened directory. This is
-// more brittle than we wanted to test for, but various userland
-// implementations expect (at least) this set of rights to be present on all
-// directories:
-
-fn directory_base_rights() -> Vec<(wasi::Rights, &'static str)> {
-    vec![
-        (wasi::RIGHTS_PATH_CREATE_DIRECTORY, "PATH_CREATE_DIRECTORY"),
-        (wasi::RIGHTS_PATH_CREATE_FILE, "PATH_CREATE_FILE"),
-        (wasi::RIGHTS_PATH_LINK_SOURCE, "PATH_LINK_SOURCE"),
-        (wasi::RIGHTS_PATH_LINK_TARGET, "PATH_LINK_TARGET"),
-        (wasi::RIGHTS_PATH_OPEN, "PATH_OPEN"),
-        (wasi::RIGHTS_FD_READDIR, "FD_READDIR"),
-        (wasi::RIGHTS_PATH_READLINK, "PATH_READLINK"),
-        (wasi::RIGHTS_PATH_RENAME_SOURCE, "PATH_RENAME_SOURCE"),
-        (wasi::RIGHTS_PATH_RENAME_TARGET, "PATH_RENAME_TARGET"),
-        (wasi::RIGHTS_PATH_SYMLINK, "PATH_SYMLINK"),
-        (wasi::RIGHTS_PATH_REMOVE_DIRECTORY, "PATH_REMOVE_DIRECTORY"),
-        (wasi::RIGHTS_PATH_UNLINK_FILE, "PATH_UNLINK_FILE"),
-        (wasi::RIGHTS_PATH_FILESTAT_GET, "PATH_FILESTAT_GET"),
-        (
-            wasi::RIGHTS_PATH_FILESTAT_SET_TIMES,
-            "PATH_FILESTAT_SET_TIMES",
-        ),
-        (wasi::RIGHTS_FD_FILESTAT_GET, "FD_FILESTAT_GET"),
-        (wasi::RIGHTS_FD_FILESTAT_SET_TIMES, "FD_FILESTAT_SET_TIMES"),
-    ]
-}
-
-pub(crate) fn directory_inheriting_rights() -> Vec<(wasi::Rights, &'static str)> {
-    let mut rights = directory_base_rights();
-    rights.extend_from_slice(&[
-        (wasi::RIGHTS_FD_DATASYNC, "FD_DATASYNC"),
-        (wasi::RIGHTS_FD_READ, "FD_READ"),
-        (wasi::RIGHTS_FD_SEEK, "FD_SEEK"),
-        (wasi::RIGHTS_FD_FDSTAT_SET_FLAGS, "FD_FDSTAT_SET_FLAGS"),
-        (wasi::RIGHTS_FD_SYNC, "FD_SYNC"),
-        (wasi::RIGHTS_FD_TELL, "FD_TELL"),
-        (wasi::RIGHTS_FD_WRITE, "FD_WRITE"),
-        (wasi::RIGHTS_FD_ADVISE, "FD_ADVISE"),
-        (wasi::RIGHTS_FD_ALLOCATE, "FD_ALLOCATE"),
-        (wasi::RIGHTS_FD_FILESTAT_GET, "FD_FILESTAT_GET"),
-        (wasi::RIGHTS_FD_FILESTAT_SET_SIZE, "FD_FILESTAT_SET_SIZE"),
-        (wasi::RIGHTS_FD_FILESTAT_SET_TIMES, "FD_FILESTAT_SET_TIMES"),
-        (wasi::RIGHTS_POLL_FD_READWRITE, "POLL_FD_READWRITE"),
-    ]);
-    rights
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/path_open_read_write.rs b/crates/test-programs/wasi-tests/src/bin/path_open_read_write.rs
deleted file mode 100644
index 0278fbf6d4f1..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/path_open_read_write.rs
+++ /dev/null
@@ -1,137 +0,0 @@
-use std::{env, process};
-use wasi_tests::{assert_errno, create_file, open_scratch_directory};
-
-unsafe fn test_path_open_read_write(dir_fd: wasi::Fd) {
-    create_file(dir_fd, "file");
-
-    let f_readonly = wasi::path_open(dir_fd, 0, "file", 0, wasi::RIGHTS_FD_READ, 0, 0)
-        .expect("open file readonly");
-
-    let stat = wasi::fd_fdstat_get(f_readonly).expect("get fdstat readonly");
-    assert!(
-        stat.fs_rights_base & wasi::RIGHTS_FD_READ == wasi::RIGHTS_FD_READ,
-        "readonly has read right"
-    );
-    assert!(
-        stat.fs_rights_base & wasi::RIGHTS_FD_WRITE == 0,
-        "readonly does not have write right"
-    );
-
-    let buffer = &mut [0u8; 100];
-    let iovec = wasi::Iovec {
-        buf: buffer.as_mut_ptr(),
-        buf_len: buffer.len(),
-    };
-    let nread = wasi::fd_read(f_readonly, &[iovec]).expect("reading readonly file");
-    assert_eq!(nread, 0, "readonly file is empty");
-
-    let write_buffer = &[1u8; 50];
-    let ciovec = wasi::Ciovec {
-        buf: write_buffer.as_ptr(),
-        buf_len: write_buffer.len(),
-    };
-    assert_errno!(
-        wasi::fd_write(f_readonly, &[ciovec])
-            .err()
-            .expect("read of writeonly fails"),
-        wasi::ERRNO_BADF
-    );
-
-    wasi::fd_close(f_readonly).expect("close readonly");
-
-    // =============== WRITE ONLY ==================
-    let f_writeonly = wasi::path_open(dir_fd, 0, "file", 0, wasi::RIGHTS_FD_WRITE, 0, 0)
-        .expect("open file writeonly");
-
-    let stat = wasi::fd_fdstat_get(f_writeonly).expect("get fdstat writeonly");
-    assert!(
-        stat.fs_rights_base & wasi::RIGHTS_FD_READ == 0,
-        "writeonly does not have read right"
-    );
-    assert!(
-        stat.fs_rights_base & wasi::RIGHTS_FD_WRITE == wasi::RIGHTS_FD_WRITE,
-        "writeonly has write right"
-    );
-
-    assert_errno!(
-        wasi::fd_read(f_writeonly, &[iovec])
-            .err()
-            .expect("read of writeonly fails"),
-        wasi::ERRNO_BADF
-    );
-    let bytes_written = wasi::fd_write(f_writeonly, &[ciovec]).expect("write to writeonly");
-    assert_eq!(bytes_written, write_buffer.len());
-
-    wasi::fd_close(f_writeonly).expect("close writeonly");
-
-    // ============== READ WRITE =======================
-
-    let f_readwrite = wasi::path_open(
-        dir_fd,
-        0,
-        "file",
-        0,
-        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
-        0,
-        0,
-    )
-    .expect("open file readwrite");
-    let stat = wasi::fd_fdstat_get(f_readwrite).expect("get fdstat readwrite");
-    assert!(
-        stat.fs_rights_base & wasi::RIGHTS_FD_READ == wasi::RIGHTS_FD_READ,
-        "readwrite has read right"
-    );
-    assert!(
-        stat.fs_rights_base & wasi::RIGHTS_FD_WRITE == wasi::RIGHTS_FD_WRITE,
-        "readwrite has write right"
-    );
-
-    let nread = wasi::fd_read(f_readwrite, &[iovec]).expect("reading readwrite file");
-    assert_eq!(
-        nread,
-        write_buffer.len(),
-        "readwrite file contains contents from writeonly open"
-    );
-
-    let write_buffer_2 = &[2u8; 25];
-    let ciovec = wasi::Ciovec {
-        buf: write_buffer_2.as_ptr(),
-        buf_len: write_buffer_2.len(),
-    };
-    let bytes_written = wasi::fd_write(f_readwrite, &[ciovec]).expect("write to readwrite");
-    assert_eq!(bytes_written, write_buffer_2.len());
-
-    let filestat = wasi::fd_filestat_get(f_readwrite).expect("get filestat readwrite");
-    assert_eq!(
-        filestat.size as usize,
-        write_buffer.len() + write_buffer_2.len(),
-        "total written is both write buffers"
-    );
-
-    wasi::fd_close(f_readwrite).expect("close readwrite");
-
-    wasi::path_unlink_file(dir_fd, "file").expect("removing a file");
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_path_open_read_write(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/path_rename.rs b/crates/test-programs/wasi-tests/src/bin/path_rename.rs
deleted file mode 100644
index 325a8a390cde..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/path_rename.rs
+++ /dev/null
@@ -1,179 +0,0 @@
-use std::{env, process};
-use wasi_tests::{assert_errno, create_file, open_scratch_directory, TESTCONFIG};
-
-unsafe fn test_path_rename(dir_fd: wasi::Fd) {
-    // First, try renaming a dir to nonexistent path
-    // Create source directory
-    wasi::path_create_directory(dir_fd, "source").expect("creating a directory");
-
-    // Try renaming the directory
-    wasi::path_rename(dir_fd, "source", dir_fd, "target").expect("renaming a directory");
-
-    // Check that source directory doesn't exist anymore
-    assert_errno!(
-        wasi::path_open(dir_fd, 0, "source", wasi::OFLAGS_DIRECTORY, 0, 0, 0)
-            .expect_err("opening a nonexistent path as a directory should fail"),
-        wasi::ERRNO_NOENT
-    );
-
-    // Check that target directory exists
-    let mut fd = wasi::path_open(dir_fd, 0, "target", wasi::OFLAGS_DIRECTORY, 0, 0, 0)
-        .expect("opening renamed path as a directory");
-    assert!(
-        fd > libc::STDERR_FILENO as wasi::Fd,
-        "file descriptor range check",
-    );
-
-    wasi::fd_close(fd).expect("closing a file");
-    wasi::path_remove_directory(dir_fd, "target").expect("removing a directory");
-
-    // Yes, renaming a dir to an empty dir is a property guaranteed by rename(2)
-    // and its fairly important that it is atomic.
-    // But, we haven't found a way to emulate it on windows. So, sometimes this
-    // behavior is just hosed. Sorry.
-    if TESTCONFIG.support_rename_dir_to_empty_dir() {
-        // Now, try renaming renaming a dir to existing empty dir
-        wasi::path_create_directory(dir_fd, "source").expect("creating a directory");
-        wasi::path_create_directory(dir_fd, "target").expect("creating a directory");
-        wasi::path_rename(dir_fd, "source", dir_fd, "target").expect("renaming a directory");
-
-        // Check that source directory doesn't exist anymore
-        assert_errno!(
-            wasi::path_open(dir_fd, 0, "source", wasi::OFLAGS_DIRECTORY, 0, 0, 0)
-                .expect_err("opening a nonexistent path as a directory"),
-            wasi::ERRNO_NOENT
-        );
-
-        // Check that target directory exists
-        fd = wasi::path_open(dir_fd, 0, "target", wasi::OFLAGS_DIRECTORY, 0, 0, 0)
-            .expect("opening renamed path as a directory");
-        assert!(
-            fd > libc::STDERR_FILENO as wasi::Fd,
-            "file descriptor range check",
-        );
-
-        wasi::fd_close(fd).expect("closing a file");
-        wasi::path_remove_directory(dir_fd, "target").expect("removing a directory");
-    } else {
-        wasi::path_create_directory(dir_fd, "source").expect("creating a directory");
-        wasi::path_create_directory(dir_fd, "target").expect("creating a directory");
-        wasi::path_rename(dir_fd, "source", dir_fd, "target")
-            .expect_err("windows does not support renaming a directory to an empty directory");
-        wasi::path_remove_directory(dir_fd, "target").expect("removing a directory");
-        wasi::path_remove_directory(dir_fd, "source").expect("removing a directory");
-    }
-
-    // Now, try renaming a dir to existing non-empty dir
-    wasi::path_create_directory(dir_fd, "source").expect("creating a directory");
-    wasi::path_create_directory(dir_fd, "target").expect("creating a directory");
-    create_file(dir_fd, "target/file");
-
-    assert_errno!(
-        wasi::path_rename(dir_fd, "source", dir_fd, "target")
-            .expect_err("renaming directory to a nonempty directory"),
-        windows => wasi::ERRNO_ACCES,
-        unix => wasi::ERRNO_NOTEMPTY
-    );
-
-    // This is technically a different property, but the root of these divergent behaviors is in
-    // the semantics that windows gives us around renaming directories. So, it lives under the same
-    // flag.
-    if TESTCONFIG.support_rename_dir_to_empty_dir() {
-        // Try renaming dir to a file
-        assert_errno!(
-            wasi::path_rename(dir_fd, "source", dir_fd, "target/file")
-                .expect_err("renaming a directory to a file"),
-            wasi::ERRNO_NOTDIR
-        );
-        wasi::path_unlink_file(dir_fd, "target/file").expect("removing a file");
-        wasi::path_remove_directory(dir_fd, "source").expect("removing a directory");
-    } else {
-        // Windows will let you erase a file by renaming a directory to it.
-        // WASI users can't depend on this error getting caught to prevent data loss.
-        wasi::path_rename(dir_fd, "source", dir_fd, "target/file")
-            .expect("windows happens to support renaming a directory to a file");
-        wasi::path_remove_directory(dir_fd, "target/file").expect("removing a file");
-    }
-    wasi::path_remove_directory(dir_fd, "target").expect("removing a directory");
-
-    // Now, try renaming a file to a nonexistent path
-    create_file(dir_fd, "source");
-    wasi::path_rename(dir_fd, "source", dir_fd, "target").expect("renaming a file");
-
-    // Check that source file doesn't exist anymore
-    assert_errno!(
-        wasi::path_open(dir_fd, 0, "source", 0, 0, 0, 0)
-            .expect_err("opening a nonexistent path should fail"),
-        wasi::ERRNO_NOENT
-    );
-
-    // Check that target file exists
-    fd = wasi::path_open(dir_fd, 0, "target", 0, 0, 0, 0).expect("opening renamed path");
-    assert!(
-        fd > libc::STDERR_FILENO as wasi::Fd,
-        "file descriptor range check",
-    );
-
-    wasi::fd_close(fd).expect("closing a file");
-    wasi::path_unlink_file(dir_fd, "target").expect("removing a file");
-
-    // Now, try renaming file to an existing file
-    create_file(dir_fd, "source");
-    create_file(dir_fd, "target");
-
-    wasi::path_rename(dir_fd, "source", dir_fd, "target")
-        .expect("renaming file to another existing file");
-
-    // Check that source file doesn't exist anymore
-    assert_errno!(
-        wasi::path_open(dir_fd, 0, "source", 0, 0, 0, 0).expect_err("opening a nonexistent path"),
-        wasi::ERRNO_NOENT
-    );
-
-    // Check that target file exists
-    fd = wasi::path_open(dir_fd, 0, "target", 0, 0, 0, 0).expect("opening renamed path");
-    assert!(
-        fd > libc::STDERR_FILENO as wasi::Fd,
-        "file descriptor range check",
-    );
-
-    wasi::fd_close(fd).expect("closing a file");
-    wasi::path_unlink_file(dir_fd, "target").expect("removing a file");
-
-    // Try renaming to an (empty) directory instead
-    create_file(dir_fd, "source");
-    wasi::path_create_directory(dir_fd, "target").expect("creating a directory");
-
-    assert_errno!(
-        wasi::path_rename(dir_fd, "source", dir_fd, "target")
-            .expect_err("renaming a file to existing directory should fail"),
-        windows => wasi::ERRNO_ACCES,
-        unix => wasi::ERRNO_ISDIR
-    );
-
-    wasi::path_remove_directory(dir_fd, "target").expect("removing a directory");
-    wasi::path_unlink_file(dir_fd, "source").expect("removing a file");
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_path_rename(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/path_rename_dir_trailing_slashes.rs b/crates/test-programs/wasi-tests/src/bin/path_rename_dir_trailing_slashes.rs
deleted file mode 100644
index 7c27d9cbb079..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/path_rename_dir_trailing_slashes.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-use std::{env, process};
-use wasi_tests::open_scratch_directory;
-
-unsafe fn test_path_rename_trailing_slashes(dir_fd: wasi::Fd) {
-    // Test renaming a directory with a trailing slash in the name.
-    wasi::path_create_directory(dir_fd, "source").expect("creating a directory");
-    wasi::path_rename(dir_fd, "source/", dir_fd, "target")
-        .expect("renaming a directory with a trailing slash in the source name");
-    wasi::path_rename(dir_fd, "target", dir_fd, "source/")
-        .expect("renaming a directory with a trailing slash in the destination name");
-    wasi::path_rename(dir_fd, "source/", dir_fd, "target/")
-        .expect("renaming a directory with a trailing slash in the source and destination names");
-    wasi::path_rename(dir_fd, "target", dir_fd, "source")
-        .expect("renaming a directory with no trailing slashes at all should work");
-    wasi::path_remove_directory(dir_fd, "source").expect("removing the directory");
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_path_rename_trailing_slashes(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/path_rename_file_trailing_slashes.rs b/crates/test-programs/wasi-tests/src/bin/path_rename_file_trailing_slashes.rs
deleted file mode 100644
index 853b1d407176..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/path_rename_file_trailing_slashes.rs
+++ /dev/null
@@ -1,53 +0,0 @@
-use std::{env, process};
-use wasi_tests::{assert_errno, create_file, open_scratch_directory};
-
-unsafe fn test_path_rename_trailing_slashes(dir_fd: wasi::Fd) {
-    // Test renaming a file with a trailing slash in the name.
-    create_file(dir_fd, "source");
-
-    wasi::path_rename(dir_fd, "source", dir_fd, "target")
-        .expect("no trailing slashes rename works");
-    wasi::path_rename(dir_fd, "target", dir_fd, "source").expect("rename it back to source");
-
-    assert_errno!(
-        wasi::path_rename(dir_fd, "source/", dir_fd, "target")
-            .expect_err("renaming a file with a trailing slash in the source name should fail"),
-        wasi::ERRNO_NOTDIR
-    );
-    assert_errno!(
-        wasi::path_rename(dir_fd, "source", dir_fd, "target/").expect_err(
-            "renaming a file with a trailing slash in the destination name should fail"
-        ),
-        wasi::ERRNO_NOTDIR
-    );
-    assert_errno!(
-        wasi::path_rename(dir_fd, "source/", dir_fd, "target/").expect_err(
-            "renaming a file with a trailing slash in the source and destination names should fail"
-        ),
-        wasi::ERRNO_NOTDIR
-    );
-    wasi::path_unlink_file(dir_fd, "source").expect("removing a file");
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_path_rename_trailing_slashes(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/path_symlink_trailing_slashes.rs b/crates/test-programs/wasi-tests/src/bin/path_symlink_trailing_slashes.rs
deleted file mode 100644
index f27ced633ede..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/path_symlink_trailing_slashes.rs
+++ /dev/null
@@ -1,83 +0,0 @@
-use std::{env, process};
-use wasi_tests::{assert_errno, create_file, open_scratch_directory, TESTCONFIG};
-
-unsafe fn test_path_symlink_trailing_slashes(dir_fd: wasi::Fd) {
-    if TESTCONFIG.support_dangling_filesystem() {
-        // Dangling symlink: Link destination shouldn't end with a slash.
-        assert_errno!(
-            wasi::path_symlink("source", dir_fd, "target/")
-                .expect_err("link destination ending with a slash should fail"),
-            wasi::ERRNO_NOENT
-        );
-
-        // Dangling symlink: Without the trailing slash, this should succeed.
-        wasi::path_symlink("source", dir_fd, "target")
-            .expect("link destination ending with a slash");
-        wasi::path_unlink_file(dir_fd, "target").expect("removing a file");
-    }
-
-    // Link destination already exists, target has trailing slash.
-    wasi::path_create_directory(dir_fd, "target").expect("creating a directory");
-    assert_errno!(
-        wasi::path_symlink("source", dir_fd, "target/")
-            .expect_err("link destination already exists"),
-        unix => wasi::ERRNO_EXIST,
-        windows => wasi::ERRNO_NOENT
-    );
-    wasi::path_remove_directory(dir_fd, "target").expect("removing a directory");
-
-    // Link destination already exists, target has no trailing slash.
-    wasi::path_create_directory(dir_fd, "target").expect("creating a directory");
-    assert_errno!(
-        wasi::path_symlink("source", dir_fd, "target")
-            .expect_err("link destination already exists"),
-        unix => wasi::ERRNO_EXIST,
-        windows => wasi::ERRNO_NOENT
-    );
-    wasi::path_remove_directory(dir_fd, "target").expect("removing a directory");
-
-    // Link destination already exists, target has trailing slash.
-    create_file(dir_fd, "target");
-
-    assert_errno!(
-        wasi::path_symlink("source", dir_fd, "target/")
-            .expect_err("link destination already exists"),
-        unix => wasi::ERRNO_NOTDIR,
-        windows => wasi::ERRNO_NOENT
-    );
-    wasi::path_unlink_file(dir_fd, "target").expect("removing a file");
-
-    // Link destination already exists, target has no trailing slash.
-    create_file(dir_fd, "target");
-
-    assert_errno!(
-        wasi::path_symlink("source", dir_fd, "target")
-            .expect_err("link destination already exists"),
-        unix => wasi::ERRNO_EXIST,
-        windows => wasi::ERRNO_NOENT
-    );
-    wasi::path_unlink_file(dir_fd, "target").expect("removing a file");
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_path_symlink_trailing_slashes(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/poll_oneoff_files.rs b/crates/test-programs/wasi-tests/src/bin/poll_oneoff_files.rs
deleted file mode 100644
index 7ca127865f6d..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/poll_oneoff_files.rs
+++ /dev/null
@@ -1,293 +0,0 @@
-use std::{env, mem::MaybeUninit, process};
-use wasi_tests::{assert_errno, open_scratch_directory};
-
-const CLOCK_ID: wasi::Userdata = 0x0123_45678;
-
-unsafe fn poll_oneoff_impl(r#in: &[wasi::Subscription]) -> Result<Vec<wasi::Event>, wasi::Errno> {
-    let mut out: Vec<wasi::Event> = Vec::new();
-    out.resize_with(r#in.len(), || {
-        MaybeUninit::<wasi::Event>::zeroed().assume_init()
-    });
-    let size = wasi::poll_oneoff(r#in.as_ptr(), out.as_mut_ptr(), r#in.len())?;
-    out.truncate(size);
-    Ok(out)
-}
-
-/// Repeatedly call `poll_oneoff` until all the subcriptions in `in` have
-/// seen their events occur.
-unsafe fn poll_oneoff_with_retry(
-    r#in: &[wasi::Subscription],
-) -> Result<Vec<wasi::Event>, wasi::Errno> {
-    let mut subscriptions = r#in.to_vec();
-    let mut events = Vec::new();
-    while !subscriptions.is_empty() {
-        let mut out: Vec<wasi::Event> = Vec::new();
-        out.resize_with(subscriptions.len(), || {
-            MaybeUninit::<wasi::Event>::zeroed().assume_init()
-        });
-        let size = wasi::poll_oneoff(
-            subscriptions.as_ptr(),
-            out.as_mut_ptr(),
-            subscriptions.len(),
-        )?;
-        out.truncate(size);
-
-        // Append the events from this `poll` to the result.
-        events.extend_from_slice(&out);
-
-        // Assuming userdata fields are unique, filter out any subscriptions
-        // whose event has occurred.
-        subscriptions.retain(|sub| !out.iter().any(|event| event.userdata == sub.userdata));
-    }
-    Ok(events)
-}
-
-unsafe fn test_empty_poll() {
-    let r#in = [];
-    let mut out: Vec<wasi::Event> = Vec::new();
-    assert_errno!(
-        wasi::poll_oneoff(r#in.as_ptr(), out.as_mut_ptr(), r#in.len())
-            .expect_err("empty poll_oneoff should fail"),
-        wasi::ERRNO_INVAL
-    );
-}
-
-unsafe fn test_timeout() {
-    let timeout = 5_000_000u64; // 5 milliseconds
-    let clock = wasi::SubscriptionClock {
-        id: wasi::CLOCKID_MONOTONIC,
-        timeout,
-        precision: 0,
-        flags: 0,
-    };
-    let r#in = [wasi::Subscription {
-        userdata: CLOCK_ID,
-        u: wasi::SubscriptionU {
-            tag: wasi::EVENTTYPE_CLOCK.raw(),
-            u: wasi::SubscriptionUU { clock },
-        },
-    }];
-    let before = wasi::clock_time_get(wasi::CLOCKID_MONOTONIC, 0).unwrap();
-    let out = poll_oneoff_impl(&r#in).unwrap();
-    let after = wasi::clock_time_get(wasi::CLOCKID_MONOTONIC, 0).unwrap();
-    assert_eq!(out.len(), 1, "should return 1 event");
-    let event = &out[0];
-    assert_errno!(event.error, wasi::ERRNO_SUCCESS);
-    assert_eq!(
-        event.type_,
-        wasi::EVENTTYPE_CLOCK,
-        "the event.type should equal clock"
-    );
-    assert_eq!(
-        event.userdata, CLOCK_ID,
-        "the event.userdata should contain clock_id specified by the user"
-    );
-    assert!(
-        after - before >= timeout,
-        "poll_oneoff should sleep for the specified interval"
-    );
-}
-
-// Like test_timeout, but uses `CLOCKID_REALTIME`, as WASI libc's sleep
-// functions do.
-unsafe fn test_sleep() {
-    let timeout = 5_000_000u64; // 5 milliseconds
-    let clock = wasi::SubscriptionClock {
-        id: wasi::CLOCKID_REALTIME,
-        timeout,
-        precision: 0,
-        flags: 0,
-    };
-    let r#in = [wasi::Subscription {
-        userdata: CLOCK_ID,
-        u: wasi::SubscriptionU {
-            tag: wasi::EVENTTYPE_CLOCK.raw(),
-            u: wasi::SubscriptionUU { clock },
-        },
-    }];
-    let before = wasi::clock_time_get(wasi::CLOCKID_MONOTONIC, 0).unwrap();
-    let out = poll_oneoff_impl(&r#in).unwrap();
-    let after = wasi::clock_time_get(wasi::CLOCKID_MONOTONIC, 0).unwrap();
-    assert_eq!(out.len(), 1, "should return 1 event");
-    let event = &out[0];
-    assert_errno!(event.error, wasi::ERRNO_SUCCESS);
-    assert_eq!(
-        event.type_,
-        wasi::EVENTTYPE_CLOCK,
-        "the event.type should equal clock"
-    );
-    assert_eq!(
-        event.userdata, CLOCK_ID,
-        "the event.userdata should contain clock_id specified by the user"
-    );
-    assert!(
-        after - before >= timeout,
-        "poll_oneoff should sleep for the specified interval"
-    );
-}
-
-unsafe fn test_fd_readwrite(readable_fd: wasi::Fd, writable_fd: wasi::Fd, error_code: wasi::Errno) {
-    let r#in = [
-        wasi::Subscription {
-            userdata: 1,
-            u: wasi::SubscriptionU {
-                tag: wasi::EVENTTYPE_FD_READ.raw(),
-                u: wasi::SubscriptionUU {
-                    fd_read: wasi::SubscriptionFdReadwrite {
-                        file_descriptor: readable_fd,
-                    },
-                },
-            },
-        },
-        wasi::Subscription {
-            userdata: 2,
-            u: wasi::SubscriptionU {
-                tag: wasi::EVENTTYPE_FD_WRITE.raw(),
-                u: wasi::SubscriptionUU {
-                    fd_write: wasi::SubscriptionFdReadwrite {
-                        file_descriptor: writable_fd,
-                    },
-                },
-            },
-        },
-    ];
-    let out = poll_oneoff_with_retry(&r#in).unwrap();
-    assert_eq!(out.len(), 2, "should return 2 events, got: {:?}", out);
-
-    let (read, write) = if out[0].userdata == 1 {
-        (&out[0], &out[1])
-    } else {
-        (&out[1], &out[0])
-    };
-    assert_eq!(
-        read.userdata, 1,
-        "the event.userdata should contain fd userdata specified by the user"
-    );
-    assert_errno!(read.error, error_code);
-    assert_eq!(
-        read.type_,
-        wasi::EVENTTYPE_FD_READ,
-        "the event.type_ should equal FD_READ"
-    );
-    assert_eq!(
-        write.userdata, 2,
-        "the event.userdata should contain fd userdata specified by the user"
-    );
-    assert_errno!(write.error, error_code);
-    assert_eq!(
-        write.type_,
-        wasi::EVENTTYPE_FD_WRITE,
-        "the event.type_ should equal FD_WRITE"
-    );
-}
-
-unsafe fn test_fd_readwrite_valid_fd(dir_fd: wasi::Fd) {
-    // Create a file in the scratch directory.
-    let nonempty_file = wasi::path_open(
-        dir_fd,
-        0,
-        "readable_file",
-        wasi::OFLAGS_CREAT,
-        wasi::RIGHTS_FD_WRITE,
-        0,
-        0,
-    )
-    .expect("create writable file");
-    // Write to file
-    let contents = &[1u8];
-    let ciovec = wasi::Ciovec {
-        buf: contents.as_ptr() as *const _,
-        buf_len: contents.len(),
-    };
-    wasi::fd_write(nonempty_file, &[ciovec]).expect("write");
-    wasi::fd_close(nonempty_file).expect("close");
-
-    // Now open the file for reading
-    let readable_fd = wasi::path_open(dir_fd, 0, "readable_file", 0, wasi::RIGHTS_FD_READ, 0, 0)
-        .expect("opening a readable file");
-
-    assert!(
-        readable_fd > libc::STDERR_FILENO as wasi::Fd,
-        "file descriptor range check",
-    );
-    // Create a file in the scratch directory.
-    let writable_fd = wasi::path_open(
-        dir_fd,
-        0,
-        "writable_file",
-        wasi::OFLAGS_CREAT,
-        wasi::RIGHTS_FD_WRITE,
-        0,
-        0,
-    )
-    .expect("opening a writable file");
-    assert!(
-        writable_fd > libc::STDERR_FILENO as wasi::Fd,
-        "file descriptor range check",
-    );
-
-    test_fd_readwrite(readable_fd, writable_fd, wasi::ERRNO_SUCCESS);
-
-    wasi::fd_close(readable_fd).expect("closing readable_file");
-    wasi::fd_close(writable_fd).expect("closing writable_file");
-    wasi::path_unlink_file(dir_fd, "readable_file").expect("removing readable_file");
-    wasi::path_unlink_file(dir_fd, "writable_file").expect("removing writable_file");
-}
-
-unsafe fn test_fd_readwrite_invalid_fd() {
-    let fd_readwrite = wasi::SubscriptionFdReadwrite {
-        file_descriptor: wasi::Fd::max_value(),
-    };
-    let r#in = [
-        wasi::Subscription {
-            userdata: 1,
-            u: wasi::SubscriptionU {
-                tag: wasi::EVENTTYPE_FD_READ.raw(),
-                u: wasi::SubscriptionUU {
-                    fd_read: fd_readwrite,
-                },
-            },
-        },
-        wasi::Subscription {
-            userdata: 2,
-            u: wasi::SubscriptionU {
-                tag: wasi::EVENTTYPE_FD_WRITE.raw(),
-                u: wasi::SubscriptionUU {
-                    fd_write: fd_readwrite,
-                },
-            },
-        },
-    ];
-    let err = poll_oneoff_impl(&r#in).unwrap_err();
-    assert_eq!(err, wasi::ERRNO_BADF)
-}
-
-unsafe fn test_poll_oneoff(dir_fd: wasi::Fd) {
-    test_timeout();
-    test_sleep();
-    test_empty_poll();
-    test_fd_readwrite_valid_fd(dir_fd);
-    test_fd_readwrite_invalid_fd();
-}
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_poll_oneoff(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/poll_oneoff_stdio.rs b/crates/test-programs/wasi-tests/src/bin/poll_oneoff_stdio.rs
deleted file mode 100644
index 2ddc00475281..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/poll_oneoff_stdio.rs
+++ /dev/null
@@ -1,138 +0,0 @@
-use std::collections::HashMap;
-use std::mem::MaybeUninit;
-use wasi_tests::{assert_errno, STDERR_FD, STDIN_FD, STDOUT_FD};
-
-const TIMEOUT: u64 = 200_000_000u64; // 200 milliseconds, required to satisfy slow execution in CI
-const CLOCK_ID: wasi::Userdata = 0x0123_45678;
-const STDIN_ID: wasi::Userdata = 0x8765_43210;
-
-unsafe fn poll_oneoff_impl(r#in: &[wasi::Subscription]) -> Result<Vec<wasi::Event>, wasi::Errno> {
-    let mut out: Vec<wasi::Event> = Vec::new();
-    out.resize_with(r#in.len(), || {
-        MaybeUninit::<wasi::Event>::zeroed().assume_init()
-    });
-    let size = wasi::poll_oneoff(r#in.as_ptr(), out.as_mut_ptr(), r#in.len())?;
-    out.truncate(size);
-    Ok(out)
-}
-
-unsafe fn test_stdin_read() {
-    let clock = wasi::SubscriptionClock {
-        id: wasi::CLOCKID_MONOTONIC,
-        timeout: TIMEOUT,
-        precision: 0,
-        flags: 0,
-    };
-    let fd_readwrite = wasi::SubscriptionFdReadwrite {
-        file_descriptor: STDIN_FD,
-    };
-    // Either stdin can be ready for reading, or this poll can timeout.
-    let r#in = [
-        wasi::Subscription {
-            userdata: CLOCK_ID,
-            u: wasi::SubscriptionU {
-                tag: wasi::EVENTTYPE_CLOCK.raw(),
-                u: wasi::SubscriptionUU { clock },
-            },
-        },
-        wasi::Subscription {
-            userdata: STDIN_ID,
-            u: wasi::SubscriptionU {
-                tag: wasi::EVENTTYPE_FD_READ.raw(),
-                u: wasi::SubscriptionUU {
-                    fd_read: fd_readwrite,
-                },
-            },
-        },
-    ];
-    let out = poll_oneoff_impl(&r#in).unwrap();
-    // The result should be either a timeout, or that stdin is ready for reading.
-    // Both are valid behaviors that depend on the test environment.
-    assert!(out.len() >= 1, "stdin read should return at least 1 event");
-    for event in out {
-        if event.type_ == wasi::EVENTTYPE_CLOCK {
-            assert_errno!(event.error, wasi::ERRNO_SUCCESS);
-            assert_eq!(
-                event.userdata, CLOCK_ID,
-                "the event.userdata should contain CLOCK_ID",
-            );
-        } else if event.type_ == wasi::EVENTTYPE_FD_READ {
-            assert_errno!(event.error, wasi::ERRNO_SUCCESS);
-            assert_eq!(
-                event.userdata, STDIN_ID,
-                "the event.userdata should contain STDIN_ID",
-            );
-        } else {
-            panic!("unexpected event type {}", event.type_.raw());
-        }
-    }
-}
-
-fn writable_subs(h: &HashMap<u64, wasi::Fd>) -> Vec<wasi::Subscription> {
-    h.iter()
-        .map(|(ud, fd)| wasi::Subscription {
-            userdata: *ud,
-            u: wasi::SubscriptionU {
-                tag: wasi::EVENTTYPE_FD_WRITE.raw(),
-                u: wasi::SubscriptionUU {
-                    fd_write: wasi::SubscriptionFdReadwrite {
-                        file_descriptor: *fd,
-                    },
-                },
-            },
-        })
-        .collect()
-}
-
-unsafe fn test_stdout_stderr_write() {
-    let mut writable: HashMap<u64, wasi::Fd> =
-        [(1, STDOUT_FD), (2, STDERR_FD)].into_iter().collect();
-
-    let clock = wasi::Subscription {
-        userdata: CLOCK_ID,
-        u: wasi::SubscriptionU {
-            tag: wasi::EVENTTYPE_CLOCK.raw(),
-            u: wasi::SubscriptionUU {
-                clock: wasi::SubscriptionClock {
-                    id: wasi::CLOCKID_MONOTONIC,
-                    timeout: TIMEOUT,
-                    precision: 0,
-                    flags: 0,
-                },
-            },
-        },
-    };
-    let mut timed_out = false;
-    while !writable.is_empty() {
-        if timed_out {
-            panic!("timed out with the following pending subs: {:?}", writable)
-        }
-        let mut subs = writable_subs(&writable);
-        subs.push(clock.clone());
-        let out = poll_oneoff_impl(&subs).unwrap();
-        for event in out {
-            match event.userdata {
-                CLOCK_ID => timed_out = true,
-                ud => {
-                    if let Some(_) = writable.remove(&ud) {
-                        assert_eq!(event.type_, wasi::EVENTTYPE_FD_WRITE);
-                        assert_errno!(event.error, wasi::ERRNO_SUCCESS);
-                    } else {
-                        panic!("Unknown userdata {}, pending sub: {:?}", ud, writable)
-                    }
-                }
-            }
-        }
-    }
-}
-
-unsafe fn test_poll_oneoff() {
-    // NB we assume that stdin/stdout/stderr are valid and open
-    // for the duration of the test case
-    test_stdin_read();
-    test_stdout_stderr_write();
-}
-fn main() {
-    // Run the tests.
-    unsafe { test_poll_oneoff() }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/read_empty_file.rs.disabled b/crates/test-programs/wasi-tests/src/bin/read_empty_file.rs.disabled
deleted file mode 100644
index 510466eaefe0..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/read_empty_file.rs.disabled
+++ /dev/null
@@ -1,5 +0,0 @@
-fn main() {
-    let mut file = std::fs::File::open("").unwrap();
-    let mut buffer = Vec::new();
-    std::io::Read::read_to_end(&mut file, &mut buffer).unwrap();
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/readlink.rs b/crates/test-programs/wasi-tests/src/bin/readlink.rs
deleted file mode 100644
index f6bcc309587b..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/readlink.rs
+++ /dev/null
@@ -1,81 +0,0 @@
-use std::{env, process};
-use wasi_tests::{create_file, open_scratch_directory};
-
-unsafe fn test_readlink(dir_fd: wasi::Fd) {
-    // Create a file in the scratch directory.
-    create_file(dir_fd, "target");
-
-    // Create a symlink
-    wasi::path_symlink("target", dir_fd, "symlink").expect("creating a symlink");
-
-    // Read link into the buffer
-    let buf = &mut [0u8; 10];
-    let bufused = wasi::path_readlink(dir_fd, "symlink", buf.as_mut_ptr(), buf.len())
-        .expect("readlink should succeed");
-    assert_eq!(bufused, 6, "should use 6 bytes of the buffer");
-    assert_eq!(&buf[..6], b"target", "buffer should contain 'target'");
-    assert_eq!(
-        &buf[6..],
-        &[0u8; 4],
-        "the remaining bytes should be untouched"
-    );
-
-    // Read link into smaller buffer than the actual link's length
-    let buf = &mut [0u8; 4];
-    let bufused = wasi::path_readlink(dir_fd, "symlink", buf.as_mut_ptr(), buf.len())
-        .expect("readlink with too-small buffer should silently truncate");
-    assert_eq!(bufused, 4);
-    assert_eq!(buf, b"targ");
-
-    // Clean up.
-    wasi::path_unlink_file(dir_fd, "target").expect("removing a file");
-    wasi::path_unlink_file(dir_fd, "symlink").expect("removing a file");
-}
-
-unsafe fn test_incremental_readlink(dir_fd: wasi::Fd) {
-    let filename = "Действие";
-    create_file(dir_fd, filename);
-
-    wasi::path_symlink(filename, dir_fd, "symlink").expect("creating a symlink");
-
-    let mut buf = Vec::new();
-    loop {
-        if buf.capacity() > 2 * filename.len() {
-            panic!()
-        }
-        let bufused = wasi::path_readlink(dir_fd, "symlink", buf.as_mut_ptr(), buf.capacity())
-            .expect("readlink should succeed");
-        buf.set_len(bufused);
-        if buf.capacity() > filename.len() {
-            assert!(buf.starts_with(filename.as_bytes()));
-            break;
-        }
-        buf = Vec::with_capacity(buf.capacity() + 1);
-    }
-    wasi::path_unlink_file(dir_fd, filename).expect("removing a file");
-    wasi::path_unlink_file(dir_fd, "symlink").expect("removing a file");
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_readlink(dir_fd) }
-    unsafe { test_incremental_readlink(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/regular_file_isatty.rs b/crates/test-programs/wasi-tests/src/bin/regular_file_isatty.rs
deleted file mode 100644
index 6a8c821becf7..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/regular_file_isatty.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-use std::{env, process};
-use wasi_tests::open_scratch_directory;
-
-unsafe fn test_file_isatty(dir_fd: wasi::Fd) {
-    // Create a file in the scratch directory and test if it's a tty.
-    let file_fd =
-        wasi::path_open(dir_fd, 0, "file", wasi::OFLAGS_CREAT, 0, 0, 0).expect("opening a file");
-    assert!(
-        file_fd > libc::STDERR_FILENO as wasi::Fd,
-        "file descriptor range check",
-    );
-    assert_eq!(
-        libc::isatty(file_fd as std::os::raw::c_int),
-        0,
-        "file is a tty"
-    );
-    wasi::fd_close(file_fd).expect("closing a file");
-    wasi::path_unlink_file(dir_fd, "file").expect("removing a file");
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_file_isatty(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/remove_directory_trailing_slashes.rs b/crates/test-programs/wasi-tests/src/bin/remove_directory_trailing_slashes.rs
deleted file mode 100644
index 9628c7ad5c77..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/remove_directory_trailing_slashes.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-use std::{env, process};
-use wasi_tests::{assert_errno, create_file, open_scratch_directory};
-
-unsafe fn test_remove_directory_trailing_slashes(dir_fd: wasi::Fd) {
-    // Create a directory in the scratch directory.
-    wasi::path_create_directory(dir_fd, "dir").expect("creating a directory");
-
-    // Test that removing it succeeds.
-    wasi::path_remove_directory(dir_fd, "dir")
-        .expect("remove_directory on a directory should succeed");
-
-    wasi::path_create_directory(dir_fd, "dir").expect("creating a directory");
-
-    // Test that removing it with a trailing slash succeeds.
-    wasi::path_remove_directory(dir_fd, "dir/")
-        .expect("remove_directory with a trailing slash on a directory should succeed");
-
-    // Create a temporary file.
-    create_file(dir_fd, "file");
-
-    // Test that removing it with no trailing slash fails.
-    assert_errno!(
-        wasi::path_remove_directory(dir_fd, "file")
-            .expect_err("remove_directory without a trailing slash on a file should fail"),
-        wasi::ERRNO_NOTDIR
-    );
-
-    // Test that removing it with a trailing slash fails.
-    assert_errno!(
-        wasi::path_remove_directory(dir_fd, "file/")
-            .expect_err("remove_directory with a trailing slash on a file should fail"),
-        unix => wasi::ERRNO_NOTDIR,
-        windows => wasi::ERRNO_NOENT
-    );
-
-    wasi::path_unlink_file(dir_fd, "file").expect("removing a file");
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_remove_directory_trailing_slashes(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/remove_nonempty_directory.rs b/crates/test-programs/wasi-tests/src/bin/remove_nonempty_directory.rs
deleted file mode 100644
index 6732ba537e77..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/remove_nonempty_directory.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-use std::{env, process};
-use wasi_tests::{assert_errno, open_scratch_directory};
-
-unsafe fn test_remove_nonempty_directory(dir_fd: wasi::Fd) {
-    // Create a directory in the scratch directory.
-    wasi::path_create_directory(dir_fd, "dir").expect("creating a directory");
-
-    // Create a directory in the directory we just created.
-    wasi::path_create_directory(dir_fd, "dir/nested").expect("creating a subdirectory");
-
-    // Test that attempting to unlink the first directory returns the expected error code.
-    assert_errno!(
-        wasi::path_remove_directory(dir_fd, "dir")
-            .expect_err("remove_directory on a directory should return ENOTEMPTY"),
-        wasi::ERRNO_NOTEMPTY
-    );
-
-    // Removing the directories.
-    wasi::path_remove_directory(dir_fd, "dir/nested")
-        .expect("remove_directory on a nested directory should succeed");
-    wasi::path_remove_directory(dir_fd, "dir").expect("removing a directory");
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_remove_nonempty_directory(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/renumber.rs b/crates/test-programs/wasi-tests/src/bin/renumber.rs
deleted file mode 100644
index 1a50f02ade12..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/renumber.rs
+++ /dev/null
@@ -1,98 +0,0 @@
-use std::{env, process};
-use wasi_tests::{assert_errno, open_scratch_directory};
-
-unsafe fn test_renumber(dir_fd: wasi::Fd) {
-    let pre_fd: wasi::Fd = (libc::STDERR_FILENO + 1) as wasi::Fd;
-
-    assert!(dir_fd > pre_fd, "dir_fd number");
-
-    // Create a file in the scratch directory.
-    let fd_from = wasi::path_open(
-        dir_fd,
-        0,
-        "file1",
-        wasi::OFLAGS_CREAT,
-        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
-        0,
-        0,
-    )
-    .expect("opening a file");
-    assert!(
-        fd_from > libc::STDERR_FILENO as wasi::Fd,
-        "file descriptor range check",
-    );
-
-    // Get fd_from fdstat attributes
-    let fdstat_from =
-        wasi::fd_fdstat_get(fd_from).expect("calling fd_fdstat on the open file descriptor");
-
-    // Create another file in the scratch directory.
-    let fd_to = wasi::path_open(
-        dir_fd,
-        0,
-        "file2",
-        wasi::OFLAGS_CREAT,
-        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
-        0,
-        0,
-    )
-    .expect("opening a file");
-    assert!(
-        fd_to > libc::STDERR_FILENO as wasi::Fd,
-        "file descriptor range check",
-    );
-
-    // Renumber fd of file1 into fd of file2
-    wasi::fd_renumber(fd_from, fd_to).expect("renumbering two descriptors");
-
-    // Ensure that fd_from is closed
-    assert_errno!(
-        wasi::fd_close(fd_from).expect_err("closing already closed file descriptor"),
-        wasi::ERRNO_BADF
-    );
-
-    // Ensure that fd_to is still open.
-    let fdstat_to =
-        wasi::fd_fdstat_get(fd_to).expect("calling fd_fdstat on the open file descriptor");
-    assert_eq!(
-        fdstat_from.fs_filetype, fdstat_to.fs_filetype,
-        "expected fd_to have the same fdstat as fd_from"
-    );
-    assert_eq!(
-        fdstat_from.fs_flags, fdstat_to.fs_flags,
-        "expected fd_to have the same fdstat as fd_from"
-    );
-    assert_eq!(
-        fdstat_from.fs_rights_base, fdstat_to.fs_rights_base,
-        "expected fd_to have the same fdstat as fd_from"
-    );
-    assert_eq!(
-        fdstat_from.fs_rights_inheriting, fdstat_to.fs_rights_inheriting,
-        "expected fd_to have the same fdstat as fd_from"
-    );
-
-    wasi::fd_close(fd_to).expect("closing a file");
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_renumber(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/sleep.rs b/crates/test-programs/wasi-tests/src/bin/sleep.rs
deleted file mode 100644
index d382a32e1559..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/sleep.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-use crate::wasi::{clocks::monotonic_clock, io::poll};
-
-wit_bindgen::generate!({
-    path: "../../wasi/wit",
-    world: "wasmtime:wasi/command-extended",
-});
-
-fn main() {
-    // Sleep ten milliseconds.  Note that we call the relevant host functions directly rather than go through
-    // libstd, since we want to ensure we're calling `monotonic_clock::subscribe` with an `absolute` parameter of
-    // `true`, which libstd won't necessarily do (but which e.g. CPython _will_ do).
-    eprintln!("calling subscribe");
-    let p = monotonic_clock::subscribe(monotonic_clock::now() + 10_000_000, true);
-    dbg!(&p as *const _);
-    let list = &[&p];
-    dbg!(list.as_ptr());
-    eprintln!("calling poll");
-    poll::poll_list(list);
-    eprintln!("done");
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/stdio.rs b/crates/test-programs/wasi-tests/src/bin/stdio.rs
deleted file mode 100644
index 31b0a25b9b39..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/stdio.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-use wasi_tests::{STDERR_FD, STDIN_FD, STDOUT_FD};
-
-unsafe fn test_stdio() {
-    for fd in &[STDIN_FD, STDOUT_FD, STDERR_FD] {
-        wasi::fd_fdstat_get(*fd).expect("fd_fdstat_get on stdio");
-        wasi::fd_renumber(*fd, *fd + 100).expect("renumbering stdio");
-    }
-}
-
-fn main() {
-    // Run the tests.
-    unsafe { test_stdio() }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/stdio_isatty.rs b/crates/test-programs/wasi-tests/src/bin/stdio_isatty.rs
deleted file mode 100644
index 7b0f37708e93..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/stdio_isatty.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-unsafe fn test_stdio_isatty() {
-    assert_eq!(
-        libc::isatty(libc::STDIN_FILENO as std::os::raw::c_int),
-        1,
-        "stdin is a tty"
-    );
-    assert_eq!(
-        libc::isatty(libc::STDOUT_FILENO as std::os::raw::c_int),
-        1,
-        "stdout is a tty"
-    );
-    assert_eq!(
-        libc::isatty(libc::STDERR_FILENO as std::os::raw::c_int),
-        1,
-        "stderr is a tty"
-    );
-}
-
-fn main() {
-    // Run the tests.
-    unsafe { test_stdio_isatty() }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/stdio_not_isatty.rs b/crates/test-programs/wasi-tests/src/bin/stdio_not_isatty.rs
deleted file mode 100644
index c67d3cf3bfb1..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/stdio_not_isatty.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-unsafe fn test_stdio_not_isatty() {
-    assert_eq!(
-        libc::isatty(libc::STDIN_FILENO as std::os::raw::c_int),
-        0,
-        "stdin is not a tty"
-    );
-    assert_eq!(
-        libc::isatty(libc::STDOUT_FILENO as std::os::raw::c_int),
-        0,
-        "stdout is not a tty"
-    );
-    assert_eq!(
-        libc::isatty(libc::STDERR_FILENO as std::os::raw::c_int),
-        0,
-        "stderr is not a tty"
-    );
-}
-
-fn main() {
-    // Run the tests.
-    unsafe { test_stdio_not_isatty() }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/symlink_create.rs b/crates/test-programs/wasi-tests/src/bin/symlink_create.rs
deleted file mode 100644
index 2553f34fcd01..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/symlink_create.rs
+++ /dev/null
@@ -1,95 +0,0 @@
-use std::{env, process};
-use wasi_tests::open_scratch_directory;
-
-unsafe fn create_symlink_to_file(dir_fd: wasi::Fd) {
-    // Create a directory for the symlink to point to.
-    let target_fd =
-        wasi::path_open(dir_fd, 0, "target", wasi::OFLAGS_CREAT, 0, 0, 0).expect("creating a file");
-    wasi::fd_close(target_fd).expect("closing file");
-
-    // Create a symlink.
-    wasi::path_symlink("target", dir_fd, "symlink").expect("creating a symlink");
-
-    // Try to open it as a directory without O_NOFOLLOW.
-    let target_file_via_symlink = wasi::path_open(
-        dir_fd,
-        wasi::LOOKUPFLAGS_SYMLINK_FOLLOW,
-        "symlink",
-        0,
-        0,
-        0,
-        0,
-    )
-    .expect("opening a symlink as a directory");
-    assert!(
-        target_file_via_symlink > libc::STDERR_FILENO as wasi::Fd,
-        "file descriptor range check",
-    );
-    wasi::fd_close(target_file_via_symlink).expect("close the symlink file");
-
-    // Replace the target directory with a file.
-    wasi::path_unlink_file(dir_fd, "symlink").expect("removing the symlink");
-    wasi::path_unlink_file(dir_fd, "target").expect("removing the target file");
-}
-
-unsafe fn create_symlink_to_directory(dir_fd: wasi::Fd) {
-    // Create a directory for the symlink to point to.
-    wasi::path_create_directory(dir_fd, "target").expect("creating a dir");
-
-    // Create a symlink.
-    wasi::path_symlink("target", dir_fd, "symlink").expect("creating a symlink");
-
-    // Try to open it as a directory without O_NOFOLLOW.
-    let target_dir_via_symlink = wasi::path_open(
-        dir_fd,
-        wasi::LOOKUPFLAGS_SYMLINK_FOLLOW,
-        "symlink",
-        wasi::OFLAGS_DIRECTORY,
-        0,
-        0,
-        0,
-    )
-    .expect("opening a symlink as a directory");
-    assert!(
-        target_dir_via_symlink > libc::STDERR_FILENO as wasi::Fd,
-        "file descriptor range check",
-    );
-    wasi::fd_close(target_dir_via_symlink).expect("closing a file");
-
-    // Replace the target directory with a file.
-    wasi::path_unlink_file(dir_fd, "symlink").expect("remove symlink to directory");
-    wasi::path_remove_directory(dir_fd, "target")
-        .expect("remove_directory on a directory should succeed");
-}
-
-unsafe fn create_symlink_to_root(dir_fd: wasi::Fd) {
-    // Create a symlink.
-    wasi::path_symlink("/", dir_fd, "symlink").expect_err("creating a symlink to an absolute path");
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe {
-        create_symlink_to_file(dir_fd);
-        create_symlink_to_directory(dir_fd);
-        create_symlink_to_root(dir_fd);
-    }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/symlink_filestat.rs b/crates/test-programs/wasi-tests/src/bin/symlink_filestat.rs
deleted file mode 100644
index cad9dcd6c034..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/symlink_filestat.rs
+++ /dev/null
@@ -1,101 +0,0 @@
-use std::{env, process};
-use wasi_tests::open_scratch_directory;
-
-unsafe fn test_path_filestat(dir_fd: wasi::Fd) {
-    // Create a file in the scratch directory.
-    let file_fd = wasi::path_open(
-        dir_fd,
-        0,
-        "file",
-        wasi::OFLAGS_CREAT,
-        wasi::RIGHTS_FD_READ | wasi::RIGHTS_FD_WRITE,
-        0,
-        0,
-    )
-    .expect("opening a file");
-    assert!(
-        file_fd > libc::STDERR_FILENO as wasi::Fd,
-        "file descriptor range check",
-    );
-
-    // Check file size
-    let file_stat = wasi::path_filestat_get(dir_fd, 0, "file").expect("reading file stats");
-    assert_eq!(file_stat.size, 0, "file size should be 0");
-
-    // Create a symlink
-    wasi::path_symlink("file", dir_fd, "symlink").expect("creating symlink to a file");
-
-    // Check path_filestat_set_times on the symlink itself
-    let sym_stat = wasi::path_filestat_get(dir_fd, 0, "symlink").expect("reading symlink stats");
-
-    // Modify mtim of symlink
-    let sym_new_mtim = sym_stat.mtim - 200;
-    wasi::path_filestat_set_times(dir_fd, 0, "symlink", 0, sym_new_mtim, wasi::FSTFLAGS_MTIM)
-        .expect("path_filestat_set_times should succeed on symlink");
-
-    // Check that symlink mtim motification worked
-    let modified_sym_stat = wasi::path_filestat_get(dir_fd, 0, "symlink")
-        .expect("reading file stats after path_filestat_set_times");
-    assert_eq!(
-        modified_sym_stat.mtim, sym_new_mtim,
-        "symlink mtim should change"
-    );
-
-    // Check that pointee mtim is not modified
-    let unmodified_file_stat = wasi::path_filestat_get(dir_fd, 0, "file")
-        .expect("reading file stats after path_filestat_set_times");
-    assert_eq!(
-        unmodified_file_stat.mtim, file_stat.mtim,
-        "file mtim should not change"
-    );
-
-    // Now, dereference the symlink
-    let deref_sym_stat =
-        wasi::path_filestat_get(dir_fd, wasi::LOOKUPFLAGS_SYMLINK_FOLLOW, "symlink")
-            .expect("reading file stats on the dereferenced symlink");
-    assert_eq!(
-        deref_sym_stat.mtim, file_stat.mtim,
-        "symlink mtim should be equal to pointee's when dereferenced"
-    );
-
-    // Finally, change stat of the original file by dereferencing the symlink
-    wasi::path_filestat_set_times(
-        dir_fd,
-        wasi::LOOKUPFLAGS_SYMLINK_FOLLOW,
-        "symlink",
-        0,
-        sym_stat.mtim,
-        wasi::FSTFLAGS_MTIM,
-    )
-    .expect("path_filestat_set_times should succeed on setting stat on original file");
-
-    let new_file_stat = wasi::path_filestat_get(dir_fd, 0, "file")
-        .expect("reading file stats after path_filestat_set_times");
-    assert_eq!(new_file_stat.mtim, sym_stat.mtim, "mtim should change");
-
-    wasi::fd_close(file_fd).expect("closing a file");
-    wasi::path_unlink_file(dir_fd, "symlink").expect("removing a symlink");
-    wasi::path_unlink_file(dir_fd, "file").expect("removing a file");
-}
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_path_filestat(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/symlink_loop.rs b/crates/test-programs/wasi-tests/src/bin/symlink_loop.rs
deleted file mode 100644
index 1c3226adb775..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/symlink_loop.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-use std::{env, process};
-use wasi_tests::{assert_errno, open_scratch_directory, TESTCONFIG};
-
-unsafe fn test_symlink_loop(dir_fd: wasi::Fd) {
-    if TESTCONFIG.support_dangling_filesystem() {
-        // Create a self-referencing symlink.
-        wasi::path_symlink("symlink", dir_fd, "symlink").expect("creating a symlink");
-
-        // Try to open it.
-        assert_errno!(
-            wasi::path_open(dir_fd, 0, "symlink", 0, 0, 0, 0)
-                .expect_err("opening a self-referencing symlink"),
-            wasi::ERRNO_LOOP
-        );
-
-        // Clean up.
-        wasi::path_unlink_file(dir_fd, "symlink").expect("removing a file");
-    }
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_symlink_loop(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/unicode_output.rs b/crates/test-programs/wasi-tests/src/bin/unicode_output.rs
deleted file mode 100644
index 211f7905fe06..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/unicode_output.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-use wasi_tests::STDOUT_FD;
-fn main() {
-    let text = "مرحبا بكم\n";
-
-    let ciovecs = [wasi::Ciovec {
-        buf: text.as_bytes().as_ptr(),
-        buf_len: text.as_bytes().len(),
-    }];
-    let written = unsafe { wasi::fd_write(STDOUT_FD, &ciovecs) }.expect("write succeeds");
-    assert_eq!(
-        written,
-        text.as_bytes().len(),
-        "full contents should be written"
-    );
-}
diff --git a/crates/test-programs/wasi-tests/src/bin/unlink_file_trailing_slashes.rs b/crates/test-programs/wasi-tests/src/bin/unlink_file_trailing_slashes.rs
deleted file mode 100644
index 2417b5efa01b..000000000000
--- a/crates/test-programs/wasi-tests/src/bin/unlink_file_trailing_slashes.rs
+++ /dev/null
@@ -1,65 +0,0 @@
-use std::{env, process};
-use wasi_tests::{assert_errno, create_file, open_scratch_directory};
-
-unsafe fn test_unlink_file_trailing_slashes(dir_fd: wasi::Fd) {
-    // Create a directory in the scratch directory.
-    wasi::path_create_directory(dir_fd, "dir").expect("creating a directory");
-
-    // Test that unlinking it fails.
-    assert_errno!(
-        wasi::path_unlink_file(dir_fd, "dir")
-            .expect_err("unlink_file on a directory should fail"),
-        macos => wasi::ERRNO_PERM,
-        unix => wasi::ERRNO_ISDIR,
-        windows => wasi::ERRNO_ACCES
-    );
-
-    // Test that unlinking it with a trailing flash fails.
-    assert_errno!(
-        wasi::path_unlink_file(dir_fd, "dir/")
-            .expect_err("unlink_file on a directory should fail"),
-        macos => wasi::ERRNO_PERM,
-        unix => wasi::ERRNO_ISDIR,
-        windows => wasi::ERRNO_ACCES
-    );
-
-    // Clean up.
-    wasi::path_remove_directory(dir_fd, "dir").expect("removing a directory");
-
-    // Create a temporary file.
-    create_file(dir_fd, "file");
-
-    // Test that unlinking it with a trailing flash fails.
-    assert_errno!(
-        wasi::path_unlink_file(dir_fd, "file/")
-            .expect_err("unlink_file with a trailing slash should fail"),
-        wasi::ERRNO_NOTDIR
-    );
-
-    // Test that unlinking it with no trailing flash succeeds.
-    wasi::path_unlink_file(dir_fd, "file")
-        .expect("unlink_file with no trailing slash should succeed");
-}
-
-fn main() {
-    let mut args = env::args();
-    let prog = args.next().unwrap();
-    let arg = if let Some(arg) = args.next() {
-        arg
-    } else {
-        eprintln!("usage: {} <scratch directory>", prog);
-        process::exit(1);
-    };
-
-    // Open scratch directory
-    let dir_fd = match open_scratch_directory(&arg) {
-        Ok(dir_fd) => dir_fd,
-        Err(err) => {
-            eprintln!("{}", err);
-            process::exit(1)
-        }
-    };
-
-    // Run the tests.
-    unsafe { test_unlink_file_trailing_slashes(dir_fd) }
-}
diff --git a/crates/test-programs/wasi-tests/src/config.rs b/crates/test-programs/wasi-tests/src/config.rs
deleted file mode 100644
index 2c8e0c0f6832..000000000000
--- a/crates/test-programs/wasi-tests/src/config.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-pub struct TestConfig {
-    errno_mode: ErrnoMode,
-    no_dangling_filesystem: bool,
-    no_rename_dir_to_empty_dir: bool,
-    no_fdflags_sync_support: bool,
-}
-
-enum ErrnoMode {
-    Unix,
-    MacOS,
-    Windows,
-    Permissive,
-}
-
-impl TestConfig {
-    pub fn from_env() -> Self {
-        let errno_mode = if std::env::var("ERRNO_MODE_UNIX").is_ok() {
-            ErrnoMode::Unix
-        } else if std::env::var("ERRNO_MODE_MACOS").is_ok() {
-            ErrnoMode::MacOS
-        } else if std::env::var("ERRNO_MODE_WINDOWS").is_ok() {
-            ErrnoMode::Windows
-        } else {
-            ErrnoMode::Permissive
-        };
-        let no_dangling_filesystem = std::env::var("NO_DANGLING_FILESYSTEM").is_ok();
-        let no_rename_dir_to_empty_dir = std::env::var("NO_RENAME_DIR_TO_EMPTY_DIR").is_ok();
-        let no_fdflags_sync_support = std::env::var("NO_FDFLAGS_SYNC_SUPPORT").is_ok();
-        TestConfig {
-            errno_mode,
-            no_dangling_filesystem,
-            no_rename_dir_to_empty_dir,
-            no_fdflags_sync_support,
-        }
-    }
-    pub fn errno_expect_unix(&self) -> bool {
-        match self.errno_mode {
-            ErrnoMode::Unix | ErrnoMode::MacOS => true,
-            _ => false,
-        }
-    }
-    pub fn errno_expect_macos(&self) -> bool {
-        match self.errno_mode {
-            ErrnoMode::MacOS => true,
-            _ => false,
-        }
-    }
-    pub fn errno_expect_windows(&self) -> bool {
-        match self.errno_mode {
-            ErrnoMode::Windows => true,
-            _ => false,
-        }
-    }
-    pub fn support_dangling_filesystem(&self) -> bool {
-        !self.no_dangling_filesystem
-    }
-    pub fn support_rename_dir_to_empty_dir(&self) -> bool {
-        !self.no_rename_dir_to_empty_dir
-    }
-    pub fn support_fdflags_sync(&self) -> bool {
-        !self.no_fdflags_sync_support
-    }
-}
diff --git a/crates/test-programs/wasi-tests/src/lib.rs b/crates/test-programs/wasi-tests/src/lib.rs
deleted file mode 100644
index 3a701ad86335..000000000000
--- a/crates/test-programs/wasi-tests/src/lib.rs
+++ /dev/null
@@ -1,109 +0,0 @@
-pub mod config;
-use once_cell::sync::Lazy;
-
-pub static TESTCONFIG: Lazy<config::TestConfig> = Lazy::new(config::TestConfig::from_env);
-
-// The `wasi` crate version 0.9.0 and beyond, doesn't
-// seem to define these constants, so we do it ourselves.
-pub const STDIN_FD: wasi::Fd = 0x0;
-pub const STDOUT_FD: wasi::Fd = 0x1;
-pub const STDERR_FD: wasi::Fd = 0x2;
-
-/// Opens a fresh file descriptor for `path` where `path` should be a preopened
-/// directory.
-pub fn open_scratch_directory(path: &str) -> Result<wasi::Fd, String> {
-    unsafe {
-        for i in 3.. {
-            let stat = match wasi::fd_prestat_get(i) {
-                Ok(s) => s,
-                Err(_) => break,
-            };
-            if stat.tag != wasi::PREOPENTYPE_DIR.raw() {
-                continue;
-            }
-            let mut dst = Vec::with_capacity(stat.u.dir.pr_name_len);
-            if wasi::fd_prestat_dir_name(i, dst.as_mut_ptr(), dst.capacity()).is_err() {
-                continue;
-            }
-            dst.set_len(stat.u.dir.pr_name_len);
-            if dst == path.as_bytes() {
-                return Ok(wasi::path_open(i, 0, ".", wasi::OFLAGS_DIRECTORY, 0, 0, 0)
-                    .expect("failed to open dir"));
-            }
-        }
-
-        Err(format!("failed to find scratch dir"))
-    }
-}
-
-pub unsafe fn create_file(dir_fd: wasi::Fd, filename: &str) {
-    let file_fd =
-        wasi::path_open(dir_fd, 0, filename, wasi::OFLAGS_CREAT, 0, 0, 0).expect("creating a file");
-    assert!(file_fd > STDERR_FD, "file descriptor range check",);
-    wasi::fd_close(file_fd).expect("closing a file");
-}
-
-#[macro_export]
-macro_rules! assert_errno {
-    ($s:expr, windows => $i:expr, $( $rest:tt )+) => {
-        let e = $s;
-        if $crate::TESTCONFIG.errno_expect_windows() {
-            assert_errno!(e, $i);
-        } else {
-            assert_errno!(e, $($rest)+, $i);
-        }
-    };
-    ($s:expr, macos => $i:expr, $( $rest:tt )+) => {
-        let e = $s;
-        if $crate::TESTCONFIG.errno_expect_macos() {
-            assert_errno!(e, $i);
-        } else {
-            assert_errno!(e, $($rest)+, $i);
-        }
-    };
-    ($s:expr, unix => $i:expr, $( $rest:tt )+) => {
-        let e = $s;
-        if $crate::TESTCONFIG.errno_expect_unix() {
-            assert_errno!(e, $i);
-        } else {
-            assert_errno!(e, $($rest)+, $i);
-        }
-    };
-    ($s:expr, $( $i:expr ),+) => {
-        let e = $s;
-        {
-            // Pretty printing infrastructure
-            struct Alt<'a>(&'a [&'static str]);
-            impl<'a> std::fmt::Display for Alt<'a> {
-                fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-                    let l = self.0.len();
-                    if l == 0 {
-                        unreachable!()
-                    } else if l == 1 {
-                        f.write_str(self.0[0])
-                    } else if l == 2 {
-                        f.write_str(self.0[0])?;
-                        f.write_str(" or ")?;
-                        f.write_str(self.0[1])
-                    } else {
-                        for (ix, s) in self.0.iter().enumerate() {
-                            if ix == l - 1 {
-                                f.write_str("or ")?;
-                                f.write_str(s)?;
-                            } else {
-                                f.write_str(s)?;
-                                f.write_str(", ")?;
-                            }
-                        }
-                        Ok(())
-                    }
-                }
-            }
-            assert!( $( e == $i || )+ false,
-                "expected errno {}; got {}",
-                Alt(&[ $( $i.name() ),+ ]),
-                e.name()
-            )
-        }
-    };
-}
diff --git a/crates/types/Cargo.toml b/crates/types/Cargo.toml
index 33925d7b0ec6..1fbbb8fde113 100644
--- a/crates/types/Cargo.toml
+++ b/crates/types/Cargo.toml
@@ -7,10 +7,18 @@ license = "Apache-2.0 WITH LLVM-exception"
 repository = "https://github.com/bytecodealliance/wasmtime"
 documentation = "https://docs.rs/wasmtime-types"
 edition.workspace = true
+rust-version.workspace = true
 
 [dependencies]
+anyhow = { workspace = true }
 cranelift-entity = { workspace = true, features = ['enable-serde'] }
-serde = "1.0.188"
-serde_derive = "1.0.188"
-thiserror = { workspace = true }
-wasmparser = { workspace = true }
+serde = { workspace = true }
+serde_derive = { workspace = true }
+smallvec = { workspace = true, features = ["serde"] }
+wasmparser = { workspace = true, features = ["validate"] }
+
+[lints]
+workspace = true
+
+[features]
+std = ['wasmparser/std']
diff --git a/crates/types/src/error.rs b/crates/types/src/error.rs
index f88536fa5f39..37e5043e0e1b 100644
--- a/crates/types/src/error.rs
+++ b/crates/types/src/error.rs
@@ -1,16 +1,16 @@
-use thiserror::Error;
+use alloc::string::String;
+use core::fmt;
 
 /// A WebAssembly translation error.
 ///
 /// When a WebAssembly function can't be translated, one of these error codes will be returned
 /// to describe the failure.
-#[derive(Error, Debug)]
+#[derive(Debug)]
 pub enum WasmError {
     /// The input WebAssembly code is invalid.
     ///
     /// This error code is used by a WebAssembly translator when it encounters invalid WebAssembly
     /// code. This should never happen for validated WebAssembly code.
-    #[error("Invalid input WebAssembly code at offset {offset}: {message}")]
     InvalidWebAssembly {
         /// A string describing the validation error.
         message: String,
@@ -21,7 +21,6 @@ pub enum WasmError {
     /// A feature used by the WebAssembly code is not supported by the embedding environment.
     ///
     /// Embedding environments may have their own limitations and feature restrictions.
-    #[error("Unsupported feature: {0}")]
     Unsupported(String),
 
     /// An implementation limit was exceeded.
@@ -30,11 +29,9 @@ pub enum WasmError {
     /// limits][limits] that cause compilation to fail when they are exceeded.
     ///
     /// [limits]: https://github.com/bytecodealliance/wasmtime/blob/main/cranelift/docs/ir.md#implementation-limits
-    #[error("Implementation limit exceeded")]
     ImplLimitExceeded,
 
     /// Any user-defined error.
-    #[error("User error: {0}")]
     User(String),
 }
 
@@ -42,7 +39,7 @@ pub enum WasmError {
 /// on the arguments to this macro.
 #[macro_export]
 macro_rules! wasm_unsupported {
-    ($($arg:tt)*) => { $crate::WasmError::Unsupported(format!($($arg)*)) }
+    ($($arg:tt)*) => { $crate::WasmError::Unsupported($crate::__format!($($arg)*)) }
 }
 
 impl From<wasmparser::BinaryReaderError> for WasmError {
@@ -57,3 +54,28 @@ impl From<wasmparser::BinaryReaderError> for WasmError {
 
 /// A convenient alias for a `Result` that uses `WasmError` as the error type.
 pub type WasmResult<T> = Result<T, WasmError>;
+
+impl fmt::Display for WasmError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            WasmError::InvalidWebAssembly { message, offset } => {
+                write!(
+                    f,
+                    "Invalid input WebAssembly code at offset {offset}: {message}"
+                )
+            }
+            WasmError::Unsupported(s) => {
+                write!(f, "Unsupported feature: {s}")
+            }
+            WasmError::ImplLimitExceeded => {
+                write!(f, "Implementation limit exceeded")
+            }
+            WasmError::User(s) => {
+                write!(f, "User error: {s}")
+            }
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for WasmError {}
diff --git a/crates/types/src/lib.rs b/crates/types/src/lib.rs
index 125be22cea72..c5940b3e582c 100644
--- a/crates/types/src/lib.rs
+++ b/crates/types/src/lib.rs
@@ -1,18 +1,151 @@
 //! Internal dependency of Wasmtime and Cranelift that defines types for
 //! WebAssembly.
 
+#![no_std]
+
+extern crate alloc;
+#[cfg(feature = "std")]
+extern crate std;
+
 pub use wasmparser;
 
+#[doc(hidden)]
+pub use alloc::format as __format;
+
+pub mod prelude;
+
+use alloc::borrow::Cow;
+use alloc::boxed::Box;
+use core::{fmt, ops::Range};
 use cranelift_entity::entity_impl;
 use serde_derive::{Deserialize, Serialize};
-use std::fmt;
+use smallvec::SmallVec;
 
 mod error;
 pub use error::*;
 
-/// WebAssembly value type -- equivalent of `wasmparser`'s Type.
+/// A trait for things that can trace all type-to-type edges, aka all type
+/// indices within this thing.
+pub trait TypeTrace {
+    /// Visit each edge.
+    ///
+    /// The function can break out of tracing by returning `Err(E)`.
+    fn trace<F, E>(&self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(EngineOrModuleTypeIndex) -> Result<(), E>;
+
+    /// Visit each edge, mutably.
+    ///
+    /// Allows updating edges.
+    ///
+    /// The function can break out of tracing by returning `Err(E)`.
+    fn trace_mut<F, E>(&mut self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(&mut EngineOrModuleTypeIndex) -> Result<(), E>;
+
+    /// Trace all `VMSharedTypeIndex` edges, ignoring other edges.
+    fn trace_engine_indices<F, E>(&self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(VMSharedTypeIndex) -> Result<(), E>,
+    {
+        self.trace(&mut |idx| match idx {
+            EngineOrModuleTypeIndex::Engine(idx) => func(idx),
+            EngineOrModuleTypeIndex::Module(_) | EngineOrModuleTypeIndex::RecGroup(_) => Ok(()),
+        })
+    }
+
+    /// Canonicalize `self` by rewriting all type references inside `self` from
+    /// module-level interned type indices to engine-level interned type
+    /// indices.
+    ///
+    /// This produces types that are suitable for usage by the runtime (only
+    /// contains `VMSharedTypeIndex` type references).
+    ///
+    /// This does not produce types that are suitable for hash consing types
+    /// (must have recgroup-relative indices for type indices referencing other
+    /// types in the same recgroup).
+    fn canonicalize_for_runtime_usage<F>(&mut self, module_to_engine: &mut F)
+    where
+        F: FnMut(ModuleInternedTypeIndex) -> VMSharedTypeIndex,
+    {
+        self.trace_mut::<_, ()>(&mut |idx| match idx {
+            EngineOrModuleTypeIndex::Engine(_) => Ok(()),
+            EngineOrModuleTypeIndex::Module(module_index) => {
+                let engine_index = module_to_engine(*module_index);
+                *idx = EngineOrModuleTypeIndex::Engine(engine_index);
+                Ok(())
+            }
+            EngineOrModuleTypeIndex::RecGroup(_) => {
+                panic!("should not already be canonicalized for hash consing")
+            }
+        })
+        .unwrap()
+    }
+
+    /// Is this type canonicalized for runtime usage?
+    fn is_canonicalized_for_runtime_usage(&self) -> bool {
+        self.trace(&mut |idx| match idx {
+            EngineOrModuleTypeIndex::Engine(_) => Ok(()),
+            EngineOrModuleTypeIndex::Module(_) | EngineOrModuleTypeIndex::RecGroup(_) => Err(()),
+        })
+        .is_ok()
+    }
+
+    /// Canonicalize `self` by rewriting all type references inside `self` from
+    /// module-level interned type indices to either engine-level interned type
+    /// indices or recgroup-relative indices.
+    ///
+    /// This produces types that are suitable for hash consing and deduplicating
+    /// recgroups (types may have recgroup-relative indices for references to
+    /// other types within the same recgroup).
+    ///
+    /// This does *not* produce types that are suitable for usage by the runtime
+    /// (only contain `VMSharedTypeIndex` type references).
+    fn canonicalize_for_hash_consing<F>(
+        &mut self,
+        rec_group_range: Range<ModuleInternedTypeIndex>,
+        module_to_engine: &mut F,
+    ) where
+        F: FnMut(ModuleInternedTypeIndex) -> VMSharedTypeIndex,
+    {
+        self.trace_mut::<_, ()>(&mut |idx| match *idx {
+            EngineOrModuleTypeIndex::Engine(_) => Ok(()),
+            EngineOrModuleTypeIndex::Module(module_index) => {
+                *idx = if rec_group_range.start <= module_index {
+                    // Any module index within the recursion group gets
+                    // translated into a recgroup-relative index.
+                    debug_assert!(module_index < rec_group_range.end);
+                    let relative = module_index.as_u32() - rec_group_range.start.as_u32();
+                    let relative = RecGroupRelativeTypeIndex::from_u32(relative);
+                    EngineOrModuleTypeIndex::RecGroup(relative)
+                } else {
+                    // Cross-group indices are translated directly into
+                    // `VMSharedTypeIndex`es.
+                    debug_assert!(module_index < rec_group_range.start);
+                    EngineOrModuleTypeIndex::Engine(module_to_engine(module_index))
+                };
+                Ok(())
+            }
+            EngineOrModuleTypeIndex::RecGroup(_) => {
+                panic!("should not already be canonicalized for hash consing")
+            }
+        })
+        .unwrap()
+    }
+
+    /// Is this type canonicalized for hash consing?
+    fn is_canonicalized_for_hash_consing(&self) -> bool {
+        self.trace(&mut |idx| match idx {
+            EngineOrModuleTypeIndex::Engine(_) | EngineOrModuleTypeIndex::RecGroup(_) => Ok(()),
+            EngineOrModuleTypeIndex::Module(_) => Err(()),
+        })
+        .is_ok()
+    }
+}
+
+/// WebAssembly value type -- equivalent of `wasmparser::ValType`.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
-pub enum WasmType {
+pub enum WasmValType {
     /// I32 type
     I32,
     /// I64 type
@@ -27,15 +160,83 @@ pub enum WasmType {
     Ref(WasmRefType),
 }
 
-impl fmt::Display for WasmType {
+impl fmt::Display for WasmValType {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            WasmType::I32 => write!(f, "i32"),
-            WasmType::I64 => write!(f, "i64"),
-            WasmType::F32 => write!(f, "f32"),
-            WasmType::F64 => write!(f, "f64"),
-            WasmType::V128 => write!(f, "v128"),
-            WasmType::Ref(rt) => write!(f, "{rt}"),
+            WasmValType::I32 => write!(f, "i32"),
+            WasmValType::I64 => write!(f, "i64"),
+            WasmValType::F32 => write!(f, "f32"),
+            WasmValType::F64 => write!(f, "f64"),
+            WasmValType::V128 => write!(f, "v128"),
+            WasmValType::Ref(rt) => write!(f, "{rt}"),
+        }
+    }
+}
+
+impl TypeTrace for WasmValType {
+    fn trace<F, E>(&self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(EngineOrModuleTypeIndex) -> Result<(), E>,
+    {
+        match self {
+            WasmValType::Ref(r) => r.trace(func),
+            WasmValType::I32
+            | WasmValType::I64
+            | WasmValType::F32
+            | WasmValType::F64
+            | WasmValType::V128 => Ok(()),
+        }
+    }
+
+    fn trace_mut<F, E>(&mut self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(&mut EngineOrModuleTypeIndex) -> Result<(), E>,
+    {
+        match self {
+            WasmValType::Ref(r) => r.trace_mut(func),
+            WasmValType::I32
+            | WasmValType::I64
+            | WasmValType::F32
+            | WasmValType::F64
+            | WasmValType::V128 => Ok(()),
+        }
+    }
+}
+
+impl WasmValType {
+    /// Is this a type that is represented as a `VMGcRef`?
+    #[inline]
+    pub fn is_vmgcref_type(&self) -> bool {
+        match self {
+            WasmValType::Ref(r) => r.is_vmgcref_type(),
+            _ => false,
+        }
+    }
+
+    /// Is this a type that is represented as a `VMGcRef` and is additionally
+    /// not an `i31`?
+    ///
+    /// That is, is this a a type that actually refers to an object allocated in
+    /// a GC heap?
+    #[inline]
+    pub fn is_vmgcref_type_and_not_i31(&self) -> bool {
+        match self {
+            WasmValType::Ref(r) => r.is_vmgcref_type_and_not_i31(),
+            _ => false,
+        }
+    }
+
+    fn trampoline_type(&self) -> Self {
+        match self {
+            WasmValType::Ref(r) => WasmValType::Ref(WasmRefType {
+                nullable: true,
+                heap_type: r.heap_type.top().into(),
+            }),
+            WasmValType::I32
+            | WasmValType::I64
+            | WasmValType::F32
+            | WasmValType::F64
+            | WasmValType::V128 => *self,
         }
     }
 }
@@ -47,6 +248,22 @@ pub struct WasmRefType {
     pub heap_type: WasmHeapType,
 }
 
+impl TypeTrace for WasmRefType {
+    fn trace<F, E>(&self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(EngineOrModuleTypeIndex) -> Result<(), E>,
+    {
+        self.heap_type.trace(func)
+    }
+
+    fn trace_mut<F, E>(&mut self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(&mut EngineOrModuleTypeIndex) -> Result<(), E>,
+    {
+        self.heap_type.trace_mut(func)
+    }
+}
+
 impl WasmRefType {
     pub const EXTERNREF: WasmRefType = WasmRefType {
         nullable: true,
@@ -56,6 +273,22 @@ impl WasmRefType {
         nullable: true,
         heap_type: WasmHeapType::Func,
     };
+
+    /// Is this a type that is represented as a `VMGcRef`?
+    #[inline]
+    pub fn is_vmgcref_type(&self) -> bool {
+        self.heap_type.is_vmgcref_type()
+    }
+
+    /// Is this a type that is represented as a `VMGcRef` and is additionally
+    /// not an `i31`?
+    ///
+    /// That is, is this a a type that actually refers to an object allocated in
+    /// a GC heap?
+    #[inline]
+    pub fn is_vmgcref_type_and_not_i31(&self) -> bool {
+        self.heap_type.is_vmgcref_type_and_not_i31()
+    }
 }
 
 impl fmt::Display for WasmRefType {
@@ -74,90 +307,773 @@ impl fmt::Display for WasmRefType {
     }
 }
 
+/// An interned type index, either at the module or engine level.
+///
+/// Roughly equivalent to `wasmparser::UnpackedIndex`, although doesn't have to
+/// concern itself with recursion-group-local indices.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum EngineOrModuleTypeIndex {
+    /// An index within an engine, canonicalized among all modules that can
+    /// interact with each other.
+    Engine(VMSharedTypeIndex),
+
+    /// An index within the current Wasm module, canonicalized within just this
+    /// current module.
+    Module(ModuleInternedTypeIndex),
+
+    /// An index within the containing type's rec group. This is only used when
+    /// hashing and canonicalizing rec groups, and should never appear outside
+    /// of the engine's type registry.
+    RecGroup(RecGroupRelativeTypeIndex),
+}
+
+impl From<ModuleInternedTypeIndex> for EngineOrModuleTypeIndex {
+    #[inline]
+    fn from(i: ModuleInternedTypeIndex) -> Self {
+        Self::Module(i)
+    }
+}
+
+impl From<VMSharedTypeIndex> for EngineOrModuleTypeIndex {
+    #[inline]
+    fn from(i: VMSharedTypeIndex) -> Self {
+        Self::Engine(i)
+    }
+}
+
+impl From<RecGroupRelativeTypeIndex> for EngineOrModuleTypeIndex {
+    #[inline]
+    fn from(i: RecGroupRelativeTypeIndex) -> Self {
+        Self::RecGroup(i)
+    }
+}
+
+impl fmt::Display for EngineOrModuleTypeIndex {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Engine(i) => write!(f, "(engine {})", i.bits()),
+            Self::Module(i) => write!(f, "(module {})", i.as_u32()),
+            Self::RecGroup(i) => write!(f, "(recgroup {})", i.as_u32()),
+        }
+    }
+}
+
+impl EngineOrModuleTypeIndex {
+    /// Is this an engine-level type index?
+    pub fn is_engine_type_index(self) -> bool {
+        matches!(self, Self::Engine(_))
+    }
+
+    /// Get the underlying engine-level type index, if any.
+    pub fn as_engine_type_index(self) -> Option<VMSharedTypeIndex> {
+        match self {
+            Self::Engine(e) => Some(e),
+            Self::RecGroup(_) | Self::Module(_) => None,
+        }
+    }
+
+    /// Get the underlying engine-level type index, or panic.
+    pub fn unwrap_engine_type_index(self) -> VMSharedTypeIndex {
+        self.as_engine_type_index()
+            .unwrap_or_else(|| panic!("`unwrap_engine_type_index` on {self:?}"))
+    }
+
+    /// Is this an module-level type index?
+    pub fn is_module_type_index(self) -> bool {
+        matches!(self, Self::Module(_))
+    }
+
+    /// Get the underlying module-level type index, if any.
+    pub fn as_module_type_index(self) -> Option<ModuleInternedTypeIndex> {
+        match self {
+            Self::Module(e) => Some(e),
+            Self::RecGroup(_) | Self::Engine(_) => None,
+        }
+    }
+
+    /// Get the underlying module-level type index, or panic.
+    pub fn unwrap_module_type_index(self) -> ModuleInternedTypeIndex {
+        self.as_module_type_index()
+            .unwrap_or_else(|| panic!("`unwrap_module_type_index` on {self:?}"))
+    }
+
+    /// Is this an recgroup-level type index?
+    pub fn is_rec_group_type_index(self) -> bool {
+        matches!(self, Self::RecGroup(_))
+    }
+
+    /// Get the underlying recgroup-level type index, if any.
+    pub fn as_rec_group_type_index(self) -> Option<RecGroupRelativeTypeIndex> {
+        match self {
+            Self::RecGroup(r) => Some(r),
+            Self::Module(_) | Self::Engine(_) => None,
+        }
+    }
+
+    /// Get the underlying module-level type index, or panic.
+    pub fn unwrap_rec_group_type_index(self) -> RecGroupRelativeTypeIndex {
+        self.as_rec_group_type_index()
+            .unwrap_or_else(|| panic!("`unwrap_rec_group_type_index` on {self:?}"))
+    }
+}
+
 /// WebAssembly heap type -- equivalent of `wasmparser`'s HeapType
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub enum WasmHeapType {
-    Func,
+    // External types.
     Extern,
-    // FIXME: the `SignatureIndex` payload here is not suitable given all the
-    // contexts that this type is used within. For example the Engine in
-    // wasmtime hashes this index which is not appropriate because the index is
-    // not globally unique.
-    //
-    // This probably needs to become `WasmHeapType<T>` where all of translation
-    // uses `WasmHeapType<SignatureIndex>` and all of engine-level "stuff"  uses
-    // `WasmHeapType<VMSharedSignatureIndex>`. This `<T>` would need to be
-    // propagated to quite a few locations though so it's left for a future
-    // refactoring at this time.
-    TypedFunc(SignatureIndex),
+    NoExtern,
+
+    // Function types.
+    Func,
+    ConcreteFunc(EngineOrModuleTypeIndex),
+    NoFunc,
+
+    // Internal types.
+    Any,
+    Eq,
+    I31,
+    Array,
+    ConcreteArray(EngineOrModuleTypeIndex),
+    Struct,
+    ConcreteStruct(EngineOrModuleTypeIndex),
+    None,
+}
+
+impl From<WasmHeapTopType> for WasmHeapType {
+    #[inline]
+    fn from(value: WasmHeapTopType) -> Self {
+        match value {
+            WasmHeapTopType::Extern => Self::Extern,
+            WasmHeapTopType::Any => Self::Any,
+            WasmHeapTopType::Func => Self::Func,
+        }
+    }
 }
 
 impl fmt::Display for WasmHeapType {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Self::Func => write!(f, "func"),
             Self::Extern => write!(f, "extern"),
-            Self::TypedFunc(i) => write!(f, "func_sig{}", i.as_u32()),
+            Self::NoExtern => write!(f, "noextern"),
+            Self::Func => write!(f, "func"),
+            Self::ConcreteFunc(i) => write!(f, "func {i}"),
+            Self::NoFunc => write!(f, "nofunc"),
+            Self::Any => write!(f, "any"),
+            Self::Eq => write!(f, "eq"),
+            Self::I31 => write!(f, "i31"),
+            Self::Array => write!(f, "array"),
+            Self::ConcreteArray(i) => write!(f, "array {i}"),
+            Self::Struct => write!(f, "struct"),
+            Self::ConcreteStruct(i) => write!(f, "struct {i}"),
+            Self::None => write!(f, "none"),
         }
     }
 }
 
+impl TypeTrace for WasmHeapType {
+    fn trace<F, E>(&self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(EngineOrModuleTypeIndex) -> Result<(), E>,
+    {
+        match *self {
+            Self::ConcreteArray(i) => func(i),
+            Self::ConcreteFunc(i) => func(i),
+            Self::ConcreteStruct(i) => func(i),
+            _ => Ok(()),
+        }
+    }
+
+    fn trace_mut<F, E>(&mut self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(&mut EngineOrModuleTypeIndex) -> Result<(), E>,
+    {
+        match self {
+            Self::ConcreteArray(i) => func(i),
+            Self::ConcreteFunc(i) => func(i),
+            Self::ConcreteStruct(i) => func(i),
+            _ => Ok(()),
+        }
+    }
+}
+
+impl WasmHeapType {
+    /// Is this a type that is represented as a `VMGcRef`?
+    #[inline]
+    pub fn is_vmgcref_type(&self) -> bool {
+        match self.top() {
+            // All `t <: (ref null any)` and `t <: (ref null extern)` are
+            // represented as `VMGcRef`s.
+            WasmHeapTopType::Any | WasmHeapTopType::Extern => true,
+
+            // All `t <: (ref null func)` are not.
+            WasmHeapTopType::Func => false,
+        }
+    }
+
+    /// Is this a type that is represented as a `VMGcRef` and is additionally
+    /// not an `i31`?
+    ///
+    /// That is, is this a a type that actually refers to an object allocated in
+    /// a GC heap?
+    #[inline]
+    pub fn is_vmgcref_type_and_not_i31(&self) -> bool {
+        self.is_vmgcref_type() && *self != Self::I31
+    }
+
+    /// Get this type's top type.
+    #[inline]
+    pub fn top(&self) -> WasmHeapTopType {
+        match self {
+            WasmHeapType::Extern | WasmHeapType::NoExtern => WasmHeapTopType::Extern,
+
+            WasmHeapType::Func | WasmHeapType::ConcreteFunc(_) | WasmHeapType::NoFunc => {
+                WasmHeapTopType::Func
+            }
+
+            WasmHeapType::Any
+            | WasmHeapType::Eq
+            | WasmHeapType::I31
+            | WasmHeapType::Array
+            | WasmHeapType::ConcreteArray(_)
+            | WasmHeapType::Struct
+            | WasmHeapType::ConcreteStruct(_)
+            | WasmHeapType::None => WasmHeapTopType::Any,
+        }
+    }
+}
+
+/// A top heap type.
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub enum WasmHeapTopType {
+    /// The common supertype of all external references.
+    Extern,
+    /// The common supertype of all internal references.
+    Any,
+    /// The common supertype of all function references.
+    Func,
+}
+
 /// WebAssembly function type -- equivalent of `wasmparser`'s FuncType.
 #[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)]
 pub struct WasmFuncType {
-    params: Box<[WasmType]>,
-    externref_params_count: usize,
-    returns: Box<[WasmType]>,
-    externref_returns_count: usize,
+    params: Box<[WasmValType]>,
+    non_i31_gc_ref_params_count: usize,
+    returns: Box<[WasmValType]>,
+    non_i31_gc_ref_returns_count: usize,
+}
+
+impl fmt::Display for WasmFuncType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "(func")?;
+        if !self.params.is_empty() {
+            write!(f, " (param")?;
+            for p in self.params.iter() {
+                write!(f, " {p}")?;
+            }
+            write!(f, ")")?;
+        }
+        if !self.returns.is_empty() {
+            write!(f, " (result")?;
+            for r in self.returns.iter() {
+                write!(f, " {r}")?;
+            }
+            write!(f, ")")?;
+        }
+        write!(f, ")")
+    }
+}
+
+impl TypeTrace for WasmFuncType {
+    fn trace<F, E>(&self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(EngineOrModuleTypeIndex) -> Result<(), E>,
+    {
+        for p in self.params.iter() {
+            p.trace(func)?;
+        }
+        for r in self.returns.iter() {
+            r.trace(func)?;
+        }
+        Ok(())
+    }
+
+    fn trace_mut<F, E>(&mut self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(&mut EngineOrModuleTypeIndex) -> Result<(), E>,
+    {
+        for p in self.params.iter_mut() {
+            p.trace_mut(func)?;
+        }
+        for r in self.returns.iter_mut() {
+            r.trace_mut(func)?;
+        }
+        Ok(())
+    }
 }
 
 impl WasmFuncType {
     #[inline]
-    pub fn new(params: Box<[WasmType]>, returns: Box<[WasmType]>) -> Self {
-        let externref_params_count = params
+    pub fn new(params: Box<[WasmValType]>, returns: Box<[WasmValType]>) -> Self {
+        let non_i31_gc_ref_params_count = params
             .iter()
-            .filter(|p| match **p {
-                WasmType::Ref(rt) => rt.heap_type == WasmHeapType::Extern,
-                _ => false,
-            })
+            .filter(|p| p.is_vmgcref_type_and_not_i31())
             .count();
-        let externref_returns_count = returns
+        let non_i31_gc_ref_returns_count = returns
             .iter()
-            .filter(|r| match **r {
-                WasmType::Ref(rt) => rt.heap_type == WasmHeapType::Extern,
-                _ => false,
-            })
+            .filter(|r| r.is_vmgcref_type_and_not_i31())
             .count();
         WasmFuncType {
             params,
-            externref_params_count,
+            non_i31_gc_ref_params_count,
             returns,
-            externref_returns_count,
+            non_i31_gc_ref_returns_count,
         }
     }
 
     /// Function params types.
     #[inline]
-    pub fn params(&self) -> &[WasmType] {
+    pub fn params(&self) -> &[WasmValType] {
         &self.params
     }
 
     /// How many `externref`s are in this function's params?
     #[inline]
-    pub fn externref_params_count(&self) -> usize {
-        self.externref_params_count
+    pub fn non_i31_gc_ref_params_count(&self) -> usize {
+        self.non_i31_gc_ref_params_count
     }
 
     /// Returns params types.
     #[inline]
-    pub fn returns(&self) -> &[WasmType] {
+    pub fn returns(&self) -> &[WasmValType] {
         &self.returns
     }
 
     /// How many `externref`s are in this function's returns?
     #[inline]
-    pub fn externref_returns_count(&self) -> usize {
-        self.externref_returns_count
+    pub fn non_i31_gc_ref_returns_count(&self) -> usize {
+        self.non_i31_gc_ref_returns_count
+    }
+
+    /// Is this function type compatible with trampoline usage in Wasmtime?
+    pub fn is_trampoline_type(&self) -> bool {
+        self.params().iter().all(|p| *p == p.trampoline_type())
+            && self.returns().iter().all(|r| *r == r.trampoline_type())
+    }
+
+    /// Get the version of this function type that is suitable for usage as a
+    /// trampoline in Wasmtime.
+    ///
+    /// If this function is suitable for trampoline usage as-is, then a borrowed
+    /// `Cow` is returned. If it must be tweaked for trampoline usage, then an
+    /// owned `Cow` is returned.
+    ///
+    /// ## What is a trampoline type?
+    ///
+    /// All reference types in parameters and results are mapped to their
+    /// nullable top type, e.g. `(ref $my_struct_type)` becomes `(ref null
+    /// any)`.
+    ///
+    /// This allows us to share trampolines between functions whose signatures
+    /// both map to the same trampoline type. It also allows the host to satisfy
+    /// a Wasm module's function import of type `S` with a function of type `T`
+    /// where `T <: S`, even when the Wasm module never defines the type `T`
+    /// (and might never even be able to!)
+    ///
+    /// The flip side is that this adds a constraint to our trampolines: they
+    /// can only pass references around (e.g. move a reference from one calling
+    /// convention's location to another's) and may not actually inspect the
+    /// references themselves (unless the trampolines start doing explicit,
+    /// fallible downcasts, but if we ever need that, then we might want to
+    /// redesign this stuff).
+    pub fn trampoline_type(&self) -> Cow<'_, Self> {
+        if self.is_trampoline_type() {
+            return Cow::Borrowed(self);
+        }
+
+        Cow::Owned(Self::new(
+            self.params().iter().map(|p| p.trampoline_type()).collect(),
+            self.returns().iter().map(|r| r.trampoline_type()).collect(),
+        ))
+    }
+}
+
+/// Represents storage types introduced in the GC spec for array and struct fields.
+#[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)]
+pub enum WasmStorageType {
+    /// The storage type is i8.
+    I8,
+    /// The storage type is i16.
+    I16,
+    /// The storage type is a value type.
+    Val(WasmValType),
+}
+
+impl fmt::Display for WasmStorageType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            WasmStorageType::I8 => write!(f, "i8"),
+            WasmStorageType::I16 => write!(f, "i16"),
+            WasmStorageType::Val(v) => fmt::Display::fmt(v, f),
+        }
+    }
+}
+
+impl TypeTrace for WasmStorageType {
+    fn trace<F, E>(&self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(EngineOrModuleTypeIndex) -> Result<(), E>,
+    {
+        match self {
+            WasmStorageType::I8 | WasmStorageType::I16 => Ok(()),
+            WasmStorageType::Val(v) => v.trace(func),
+        }
+    }
+
+    fn trace_mut<F, E>(&mut self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(&mut EngineOrModuleTypeIndex) -> Result<(), E>,
+    {
+        match self {
+            WasmStorageType::I8 | WasmStorageType::I16 => Ok(()),
+            WasmStorageType::Val(v) => v.trace_mut(func),
+        }
+    }
+}
+
+/// The type of a struct field or array element.
+#[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)]
+pub struct WasmFieldType {
+    /// The field's element type.
+    pub element_type: WasmStorageType,
+
+    /// Whether this field can be mutated or not.
+    pub mutable: bool,
+}
+
+impl fmt::Display for WasmFieldType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.mutable {
+            write!(f, "(mut {})", self.element_type)
+        } else {
+            fmt::Display::fmt(&self.element_type, f)
+        }
+    }
+}
+
+impl TypeTrace for WasmFieldType {
+    fn trace<F, E>(&self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(EngineOrModuleTypeIndex) -> Result<(), E>,
+    {
+        self.element_type.trace(func)
+    }
+
+    fn trace_mut<F, E>(&mut self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(&mut EngineOrModuleTypeIndex) -> Result<(), E>,
+    {
+        self.element_type.trace_mut(func)
+    }
+}
+
+/// A concrete array type.
+#[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)]
+pub struct WasmArrayType(pub WasmFieldType);
+
+impl fmt::Display for WasmArrayType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "(array {})", self.0)
+    }
+}
+
+impl TypeTrace for WasmArrayType {
+    fn trace<F, E>(&self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(EngineOrModuleTypeIndex) -> Result<(), E>,
+    {
+        self.0.trace(func)
+    }
+
+    fn trace_mut<F, E>(&mut self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(&mut EngineOrModuleTypeIndex) -> Result<(), E>,
+    {
+        self.0.trace_mut(func)
+    }
+}
+
+/// A concrete struct type.
+#[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)]
+pub struct WasmStructType {
+    pub fields: Box<[WasmFieldType]>,
+}
+
+impl fmt::Display for WasmStructType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "(struct")?;
+        for ty in self.fields.iter() {
+            write!(f, " {ty}")?;
+        }
+        write!(f, ")")
+    }
+}
+
+impl TypeTrace for WasmStructType {
+    fn trace<F, E>(&self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(EngineOrModuleTypeIndex) -> Result<(), E>,
+    {
+        for f in self.fields.iter() {
+            f.trace(func)?;
+        }
+        Ok(())
+    }
+
+    fn trace_mut<F, E>(&mut self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(&mut EngineOrModuleTypeIndex) -> Result<(), E>,
+    {
+        for f in self.fields.iter_mut() {
+            f.trace_mut(func)?;
+        }
+        Ok(())
+    }
+}
+
+/// A function, array, or struct type.
+#[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)]
+pub enum WasmCompositeType {
+    Array(WasmArrayType),
+    Func(WasmFuncType),
+    Struct(WasmStructType),
+}
+
+impl fmt::Display for WasmCompositeType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            WasmCompositeType::Array(ty) => fmt::Display::fmt(ty, f),
+            WasmCompositeType::Func(ty) => fmt::Display::fmt(ty, f),
+            WasmCompositeType::Struct(ty) => fmt::Display::fmt(ty, f),
+        }
+    }
+}
+
+impl WasmCompositeType {
+    #[inline]
+    pub fn is_array(&self) -> bool {
+        matches!(self, Self::Array(_))
+    }
+
+    #[inline]
+    pub fn as_array(&self) -> Option<&WasmArrayType> {
+        match self {
+            WasmCompositeType::Array(f) => Some(f),
+            _ => None,
+        }
+    }
+
+    #[inline]
+    pub fn unwrap_array(&self) -> &WasmArrayType {
+        self.as_array().unwrap()
+    }
+
+    #[inline]
+    pub fn is_func(&self) -> bool {
+        matches!(self, Self::Func(_))
+    }
+
+    #[inline]
+    pub fn as_func(&self) -> Option<&WasmFuncType> {
+        match self {
+            WasmCompositeType::Func(f) => Some(f),
+            _ => None,
+        }
+    }
+
+    #[inline]
+    pub fn unwrap_func(&self) -> &WasmFuncType {
+        self.as_func().unwrap()
+    }
+
+    #[inline]
+    pub fn is_struct(&self) -> bool {
+        matches!(self, Self::Struct(_))
+    }
+
+    #[inline]
+    pub fn as_struct(&self) -> Option<&WasmStructType> {
+        match self {
+            WasmCompositeType::Struct(f) => Some(f),
+            _ => None,
+        }
+    }
+
+    #[inline]
+    pub fn unwrap_struct(&self) -> &WasmStructType {
+        self.as_struct().unwrap()
+    }
+}
+
+impl TypeTrace for WasmCompositeType {
+    fn trace<F, E>(&self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(EngineOrModuleTypeIndex) -> Result<(), E>,
+    {
+        match self {
+            WasmCompositeType::Array(a) => a.trace(func),
+            WasmCompositeType::Func(f) => f.trace(func),
+            WasmCompositeType::Struct(a) => a.trace(func),
+        }
+    }
+
+    fn trace_mut<F, E>(&mut self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(&mut EngineOrModuleTypeIndex) -> Result<(), E>,
+    {
+        match self {
+            WasmCompositeType::Array(a) => a.trace_mut(func),
+            WasmCompositeType::Func(f) => f.trace_mut(func),
+            WasmCompositeType::Struct(a) => a.trace_mut(func),
+        }
+    }
+}
+
+/// A concrete, user-defined (or host-defined) Wasm type.
+#[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)]
+pub struct WasmSubType {
+    /// Whether this type is forbidden from being the supertype of any other
+    /// type.
+    pub is_final: bool,
+
+    /// This type's supertype, if any.
+    pub supertype: Option<EngineOrModuleTypeIndex>,
+
+    /// The array, function, or struct that is defined.
+    pub composite_type: WasmCompositeType,
+}
+
+impl fmt::Display for WasmSubType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.is_final && self.supertype.is_none() {
+            fmt::Display::fmt(&self.composite_type, f)
+        } else {
+            write!(f, "(sub")?;
+            if self.is_final {
+                write!(f, " final")?;
+            }
+            if let Some(sup) = self.supertype {
+                write!(f, " {sup}")?;
+            }
+            write!(f, " {})", self.composite_type)
+        }
+    }
+}
+
+impl WasmSubType {
+    #[inline]
+    pub fn is_func(&self) -> bool {
+        self.composite_type.is_func()
+    }
+
+    #[inline]
+    pub fn as_func(&self) -> Option<&WasmFuncType> {
+        self.composite_type.as_func()
+    }
+
+    #[inline]
+    pub fn unwrap_func(&self) -> &WasmFuncType {
+        self.composite_type.unwrap_func()
+    }
+
+    #[inline]
+    pub fn is_array(&self) -> bool {
+        self.composite_type.is_array()
+    }
+
+    #[inline]
+    pub fn as_array(&self) -> Option<&WasmArrayType> {
+        self.composite_type.as_array()
+    }
+
+    #[inline]
+    pub fn unwrap_array(&self) -> &WasmArrayType {
+        self.composite_type.unwrap_array()
+    }
+
+    #[inline]
+    pub fn is_struct(&self) -> bool {
+        self.composite_type.is_struct()
+    }
+
+    #[inline]
+    pub fn as_struct(&self) -> Option<&WasmStructType> {
+        self.composite_type.as_struct()
+    }
+
+    #[inline]
+    pub fn unwrap_struct(&self) -> &WasmStructType {
+        self.composite_type.unwrap_struct()
+    }
+}
+
+impl TypeTrace for WasmSubType {
+    fn trace<F, E>(&self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(EngineOrModuleTypeIndex) -> Result<(), E>,
+    {
+        if let Some(sup) = self.supertype {
+            func(sup)?;
+        }
+        self.composite_type.trace(func)
+    }
+
+    fn trace_mut<F, E>(&mut self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(&mut EngineOrModuleTypeIndex) -> Result<(), E>,
+    {
+        if let Some(sup) = self.supertype.as_mut() {
+            func(sup)?;
+        }
+        self.composite_type.trace_mut(func)
+    }
+}
+
+/// A recursive type group.
+///
+/// Types within a recgroup can have forward references to each other, which
+/// allows for cyclic types, for example a function `$f` that returns a
+/// reference to a function `$g` which returns a reference to a function `$f`:
+///
+/// ```ignore
+/// (rec (type (func $f (result (ref null $g))))
+///      (type (func $g (result (ref null $f)))))
+/// ```
+#[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)]
+pub struct WasmRecGroup {
+    /// The types inside of this recgroup.
+    pub types: Box<[WasmSubType]>,
+}
+
+impl TypeTrace for WasmRecGroup {
+    fn trace<F, E>(&self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(EngineOrModuleTypeIndex) -> Result<(), E>,
+    {
+        for ty in self.types.iter() {
+            ty.trace(func)?;
+        }
+        Ok(())
+    }
+
+    fn trace_mut<F, E>(&mut self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(&mut EngineOrModuleTypeIndex) -> Result<(), E>,
+    {
+        for ty in self.types.iter_mut() {
+            ty.trace_mut(func)?;
+        }
+        Ok(())
     }
 }
 
@@ -206,10 +1122,80 @@ entity_impl!(GlobalIndex);
 pub struct MemoryIndex(u32);
 entity_impl!(MemoryIndex);
 
-/// Index type of a signature (imported or defined) inside the WebAssembly module.
+/// Index type of a canonicalized recursive type group inside a WebAssembly
+/// module (as opposed to canonicalized within the whole engine).
+#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug, Serialize, Deserialize)]
+pub struct ModuleInternedRecGroupIndex(u32);
+entity_impl!(ModuleInternedRecGroupIndex);
+
+/// Index type of a canonicalized recursive type group inside the whole engine
+/// (as opposed to canonicalized within just a single Wasm module).
+#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug, Serialize, Deserialize)]
+pub struct EngineInternedRecGroupIndex(u32);
+entity_impl!(EngineInternedRecGroupIndex);
+
+/// Index type of a type (imported or defined) inside the WebAssembly module.
+#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug, Serialize, Deserialize)]
+pub struct TypeIndex(u32);
+entity_impl!(TypeIndex);
+
+/// A canonicalized type index referencing a type within a single recursion
+/// group from another type within that same recursion group.
+///
+/// This is only suitable for use when hash consing and deduplicating rec
+/// groups.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug, Serialize, Deserialize)]
-pub struct SignatureIndex(u32);
-entity_impl!(SignatureIndex);
+pub struct RecGroupRelativeTypeIndex(u32);
+entity_impl!(RecGroupRelativeTypeIndex);
+
+/// A canonicalized type index for a type within a single WebAssembly module.
+///
+/// Note that this is deduplicated only at the level of a single WebAssembly
+/// module, not at the level of a whole store or engine. This means that these
+/// indices are only unique within the context of a single Wasm module, and
+/// therefore are not suitable for runtime type checks (which, in general, may
+/// involve entities defined in different modules).
+#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug, Serialize, Deserialize)]
+pub struct ModuleInternedTypeIndex(u32);
+entity_impl!(ModuleInternedTypeIndex);
+
+/// A canonicalized type index into an engine's shared type registry.
+///
+/// This is canonicalized/deduped at the level of a whole engine, across all the
+/// modules loaded into that engine, not just at the level of a single
+/// particular module. This means that `VMSharedTypeIndex` is usable for
+/// e.g. checking that function signatures match during an indirect call
+/// (potentially to a function defined in a different module) at runtime.
+#[repr(transparent)] // Used directly by JIT code.
+#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug, Serialize, Deserialize)]
+pub struct VMSharedTypeIndex(u32);
+entity_impl!(VMSharedTypeIndex);
+
+impl VMSharedTypeIndex {
+    /// Create a new `VMSharedTypeIndex`.
+    #[inline]
+    pub fn new(value: u32) -> Self {
+        assert_ne!(
+            value,
+            u32::MAX,
+            "u32::MAX is reserved for the default value"
+        );
+        Self(value)
+    }
+
+    /// Returns the underlying bits of the index.
+    #[inline]
+    pub fn bits(&self) -> u32 {
+        self.0
+    }
+}
+
+impl Default for VMSharedTypeIndex {
+    #[inline]
+    fn default() -> Self {
+        Self(u32::MAX)
+    }
+}
 
 /// Index type of a passive data segment inside the WebAssembly module.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug, Serialize, Deserialize)]
@@ -221,11 +1207,6 @@ entity_impl!(DataIndex);
 pub struct ElemIndex(u32);
 entity_impl!(ElemIndex);
 
-/// Index type of a type inside the WebAssembly module.
-#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug, Serialize, Deserialize)]
-pub struct TypeIndex(u32);
-entity_impl!(TypeIndex);
-
 /// Index type of an event inside the WebAssembly module.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug, Serialize, Deserialize)]
 pub struct TagIndex(u32);
@@ -291,7 +1272,33 @@ pub enum EntityType {
     Table(Table),
     /// A function type where the index points to the type section and records a
     /// function signature.
-    Function(SignatureIndex),
+    Function(EngineOrModuleTypeIndex),
+}
+
+impl TypeTrace for EntityType {
+    fn trace<F, E>(&self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(EngineOrModuleTypeIndex) -> Result<(), E>,
+    {
+        match self {
+            Self::Global(g) => g.trace(func),
+            Self::Table(t) => t.trace(func),
+            Self::Function(idx) => func(*idx),
+            Self::Memory(_) | Self::Tag(_) => Ok(()),
+        }
+    }
+
+    fn trace_mut<F, E>(&mut self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(&mut EngineOrModuleTypeIndex) -> Result<(), E>,
+    {
+        match self {
+            Self::Global(g) => g.trace_mut(func),
+            Self::Table(t) => t.trace_mut(func),
+            Self::Function(idx) => func(idx),
+            Self::Memory(_) | Self::Tag(_) => Ok(()),
+        }
+    }
 }
 
 impl EntityType {
@@ -328,7 +1335,7 @@ impl EntityType {
     }
 
     /// Assert that this entity is a function
-    pub fn unwrap_func(&self) -> SignatureIndex {
+    pub fn unwrap_func(&self) -> EngineOrModuleTypeIndex {
         match self {
             EntityType::Function(g) => *g,
             _ => panic!("not a func"),
@@ -346,30 +1353,172 @@ impl EntityType {
 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq, Serialize, Deserialize)]
 pub struct Global {
     /// The Wasm type of the value stored in the global.
-    pub wasm_ty: crate::WasmType,
+    pub wasm_ty: crate::WasmValType,
     /// A flag indicating whether the value may change at runtime.
     pub mutability: bool,
 }
 
-/// Globals are initialized via the `const` operators or by referring to another import.
-#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq, Serialize, Deserialize)]
-pub enum GlobalInit {
-    /// An `i32.const`.
+impl TypeTrace for Global {
+    fn trace<F, E>(&self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(EngineOrModuleTypeIndex) -> Result<(), E>,
+    {
+        let Global {
+            wasm_ty,
+            mutability: _,
+        } = self;
+        wasm_ty.trace(func)
+    }
+
+    fn trace_mut<F, E>(&mut self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(&mut EngineOrModuleTypeIndex) -> Result<(), E>,
+    {
+        let Global {
+            wasm_ty,
+            mutability: _,
+        } = self;
+        wasm_ty.trace_mut(func)
+    }
+}
+
+/// A constant expression.
+///
+/// These are used to initialize globals, table elements, etc...
+#[derive(Clone, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
+pub struct ConstExpr {
+    ops: SmallVec<[ConstOp; 2]>,
+}
+
+impl ConstExpr {
+    /// Create a new const expression from the given opcodes.
+    ///
+    /// Does not do any validation that the const expression is well-typed.
+    ///
+    /// Panics if given zero opcodes.
+    pub fn new(ops: impl IntoIterator<Item = ConstOp>) -> Self {
+        let ops = ops.into_iter().collect::<SmallVec<[ConstOp; 2]>>();
+        assert!(!ops.is_empty());
+        ConstExpr { ops }
+    }
+
+    /// Create a new const expression from a `wasmparser` const expression.
+    ///
+    /// Returns the new const expression as well as the escaping function
+    /// indices that appeared in `ref.func` instructions, if any.
+    pub fn from_wasmparser(
+        expr: wasmparser::ConstExpr<'_>,
+    ) -> WasmResult<(Self, SmallVec<[FuncIndex; 1]>)> {
+        let mut iter = expr
+            .get_operators_reader()
+            .into_iter_with_offsets()
+            .peekable();
+
+        let mut ops = SmallVec::<[ConstOp; 2]>::new();
+        let mut escaped = SmallVec::<[FuncIndex; 1]>::new();
+        while let Some(res) = iter.next() {
+            let (op, offset) = res?;
+
+            // If we reach an `end` instruction, and there are no more
+            // instructions after that, then we are done reading this const
+            // expression.
+            if matches!(op, wasmparser::Operator::End) && iter.peek().is_none() {
+                break;
+            }
+
+            // Track any functions that appear in `ref.func` so that callers can
+            // make sure to flag them as escaping.
+            if let wasmparser::Operator::RefFunc { function_index } = &op {
+                escaped.push(FuncIndex::from_u32(*function_index));
+            }
+
+            ops.push(ConstOp::from_wasmparser(op, offset)?);
+        }
+        Ok((Self { ops }, escaped))
+    }
+
+    /// Get the opcodes that make up this const expression.
+    pub fn ops(&self) -> &[ConstOp] {
+        &self.ops
+    }
+
+    /// Is this ConstExpr a provably nonzero integer value?
+    ///
+    /// This must be conservative: if the expression *might* be zero,
+    /// it must return `false`. It is always allowed to return `false`
+    /// for some expression kind that we don't support. However, if it
+    /// returns `true`, the expression must be actually nonzero.
+    ///
+    /// We use this for certain table optimizations that rely on
+    /// knowing for sure that index 0 is not referenced.
+    pub fn provably_nonzero_i32(&self) -> bool {
+        assert!(self.ops.len() > 0);
+        if self.ops.len() > 1 {
+            // Compound expressions not yet supported: conservatively
+            // return `false` (we can't prove nonzero).
+            return false;
+        }
+        // Exactly one op at this point.
+        match self.ops[0] {
+            // An actual zero value -- definitely not nonzero!
+            ConstOp::I32Const(0) => false,
+            // Any other constant value -- provably nonzero, if above
+            // did not match.
+            ConstOp::I32Const(_) => true,
+            // Anything else: we can't prove anything.
+            _ => false,
+        }
+    }
+}
+
+/// The subset of Wasm opcodes that are constant.
+#[allow(missing_docs)]
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
+pub enum ConstOp {
     I32Const(i32),
-    /// An `i64.const`.
     I64Const(i64),
-    /// An `f32.const`.
     F32Const(u32),
-    /// An `f64.const`.
     F64Const(u64),
-    /// A `vconst`.
     V128Const(u128),
-    /// A `global.get` of another global.
-    GetGlobal(GlobalIndex),
-    /// A `ref.null`.
-    RefNullConst,
-    /// A `ref.func <index>`.
+    GlobalGet(GlobalIndex),
+    RefI31,
+    RefNull,
     RefFunc(FuncIndex),
+    I32Add,
+    I32Sub,
+    I32Mul,
+    I64Add,
+    I64Sub,
+    I64Mul,
+}
+
+impl ConstOp {
+    /// Convert a `wasmparser::Operator` to a `ConstOp`.
+    pub fn from_wasmparser(op: wasmparser::Operator<'_>, offset: usize) -> WasmResult<Self> {
+        use wasmparser::Operator as O;
+        Ok(match op {
+            O::I32Const { value } => Self::I32Const(value),
+            O::I64Const { value } => Self::I64Const(value),
+            O::F32Const { value } => Self::F32Const(value.bits()),
+            O::F64Const { value } => Self::F64Const(value.bits()),
+            O::V128Const { value } => Self::V128Const(u128::from_le_bytes(*value.bytes())),
+            O::RefNull { hty: _ } => Self::RefNull,
+            O::RefFunc { function_index } => Self::RefFunc(FuncIndex::from_u32(function_index)),
+            O::GlobalGet { global_index } => Self::GlobalGet(GlobalIndex::from_u32(global_index)),
+            O::RefI31 => Self::RefI31,
+            O::I32Add => Self::I32Add,
+            O::I32Sub => Self::I32Sub,
+            O::I32Mul => Self::I32Mul,
+            O::I64Add => Self::I64Add,
+            O::I64Sub => Self::I64Sub,
+            O::I64Mul => Self::I64Mul,
+            op => {
+                return Err(wasm_unsupported!(
+                    "unsupported opcode in const expression at offset {offset:#x}: {op:?}",
+                ));
+            }
+        })
+    }
 }
 
 /// WebAssembly table.
@@ -383,6 +1532,32 @@ pub struct Table {
     pub maximum: Option<u32>,
 }
 
+impl TypeTrace for Table {
+    fn trace<F, E>(&self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(EngineOrModuleTypeIndex) -> Result<(), E>,
+    {
+        let Table {
+            wasm_ty,
+            minimum: _,
+            maximum: _,
+        } = self;
+        wasm_ty.trace(func)
+    }
+
+    fn trace_mut<F, E>(&mut self, func: &mut F) -> Result<(), E>
+    where
+        F: FnMut(&mut EngineOrModuleTypeIndex) -> Result<(), E>,
+    {
+        let Table {
+            wasm_ty,
+            minimum: _,
+            maximum: _,
+        } = self;
+        wasm_ty.trace_mut(func)
+    }
+}
+
 /// WebAssembly linear memory.
 #[derive(Debug, Clone, Copy, Hash, Eq, PartialEq, Serialize, Deserialize)]
 pub struct Memory {
@@ -394,15 +1569,119 @@ pub struct Memory {
     pub shared: bool,
     /// Whether or not this is a 64-bit memory
     pub memory64: bool,
+    /// The log2 of this memory's page size, in bytes.
+    ///
+    /// By default the page size is 64KiB (0x10000; 2**16; 1<<16; 65536) but the
+    /// custom-page-sizes proposal allows opting into a page size of `1`.
+    pub page_size_log2: u8,
 }
 
+/// Maximum size, in bytes, of 32-bit memories (4G)
+pub const WASM32_MAX_SIZE: u64 = 1 << 32;
+
+impl Memory {
+    /// WebAssembly page sizes are 64KiB by default.
+    pub const DEFAULT_PAGE_SIZE: u32 = 0x10000;
+
+    /// WebAssembly page sizes are 64KiB (or `2**16`) by default.
+    pub const DEFAULT_PAGE_SIZE_LOG2: u8 = {
+        let log2 = 16;
+        assert!(1 << log2 == Memory::DEFAULT_PAGE_SIZE);
+        log2
+    };
+
+    /// Returns the minimum size, in bytes, that this memory must be.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the calculation of the minimum size overflows the
+    /// `u64` return type. This means that the memory can't be allocated but
+    /// it's deferred to the caller to how to deal with that.
+    pub fn minimum_byte_size(&self) -> Result<u64, SizeOverflow> {
+        self.minimum
+            .checked_mul(self.page_size())
+            .ok_or(SizeOverflow)
+    }
+
+    /// Returns the maximum size, in bytes, that this memory is allowed to be.
+    ///
+    /// Note that the return value here is not an `Option` despite the maximum
+    /// size of a linear memory being optional in wasm. If a maximum size
+    /// is not present in the memory's type then a maximum size is selected for
+    /// it. For example the maximum size of a 32-bit memory is `1<<32`. The
+    /// maximum size of a 64-bit linear memory is chosen to be a value that
+    /// won't ever be allowed at runtime.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the calculation of the maximum size overflows the
+    /// `u64` return type. This means that the memory can't be allocated but
+    /// it's deferred to the caller to how to deal with that.
+    pub fn maximum_byte_size(&self) -> Result<u64, SizeOverflow> {
+        match self.maximum {
+            Some(max) => max.checked_mul(self.page_size()).ok_or(SizeOverflow),
+            None => {
+                let min = self.minimum_byte_size()?;
+                Ok(min.max(self.max_size_based_on_index_type()))
+            }
+        }
+    }
+
+    /// Get the size of this memory's pages, in bytes.
+    pub fn page_size(&self) -> u64 {
+        debug_assert!(
+            self.page_size_log2 == 16 || self.page_size_log2 == 0,
+            "invalid page_size_log2: {}; must be 16 or 0",
+            self.page_size_log2
+        );
+        1 << self.page_size_log2
+    }
+
+    /// Returns the maximum size memory is allowed to be only based on the
+    /// index type used by this memory.
+    ///
+    /// For example 32-bit linear memories return `1<<32` from this method.
+    pub fn max_size_based_on_index_type(&self) -> u64 {
+        if self.memory64 {
+            // Note that the true maximum size of a 64-bit linear memory, in
+            // bytes, cannot be represented in a `u64`. That would require a u65
+            // to store `1<<64`. Despite that no system can actually allocate a
+            // full 64-bit linear memory so this is instead emulated as "what if
+            // the kernel fit in a single Wasm page of linear memory". Shouldn't
+            // ever actually be possible but it provides a number to serve as an
+            // effective maximum.
+            0_u64.wrapping_sub(self.page_size())
+        } else {
+            WASM32_MAX_SIZE
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+pub struct SizeOverflow;
+
+impl fmt::Display for SizeOverflow {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("size overflow calculating memory size")
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for SizeOverflow {}
+
 impl From<wasmparser::MemoryType> for Memory {
     fn from(ty: wasmparser::MemoryType) -> Memory {
+        let page_size_log2 = u8::try_from(ty.page_size_log2.unwrap_or(16)).unwrap();
+        debug_assert!(
+            page_size_log2 == 16 || page_size_log2 == 0,
+            "invalid page_size_log2: {page_size_log2}; must be 16 or 0"
+        );
         Memory {
             minimum: ty.initial,
             maximum: ty.maximum,
             shared: ty.shared,
             memory64: ty.memory64,
+            page_size_log2,
         }
     }
 }
@@ -435,11 +1714,66 @@ pub trait TypeConvert {
     }
 
     /// Converts a wasmparser table type into a wasmtime type
-    fn convert_table_type(&self, ty: &wasmparser::TableType) -> Table {
-        Table {
+    fn convert_table_type(&self, ty: &wasmparser::TableType) -> WasmResult<Table> {
+        if ty.table64 {
+            return Err(wasm_unsupported!("wasm memory64: 64-bit table type"));
+        }
+        Ok(Table {
             wasm_ty: self.convert_ref_type(ty.element_type),
-            minimum: ty.initial,
-            maximum: ty.maximum,
+            minimum: ty.initial.try_into().unwrap(),
+            maximum: ty.maximum.map(|i| i.try_into().unwrap()),
+        })
+    }
+
+    fn convert_sub_type(&self, ty: &wasmparser::SubType) -> WasmSubType {
+        WasmSubType {
+            is_final: ty.is_final,
+            supertype: ty.supertype_idx.map(|i| self.lookup_type_index(i.unpack())),
+            composite_type: self.convert_composite_type(&ty.composite_type),
+        }
+    }
+
+    fn convert_composite_type(&self, ty: &wasmparser::CompositeType) -> WasmCompositeType {
+        assert!(!ty.shared);
+        match &ty.inner {
+            wasmparser::CompositeInnerType::Func(f) => {
+                WasmCompositeType::Func(self.convert_func_type(f))
+            }
+            wasmparser::CompositeInnerType::Array(a) => {
+                WasmCompositeType::Array(self.convert_array_type(a))
+            }
+            wasmparser::CompositeInnerType::Struct(s) => {
+                WasmCompositeType::Struct(self.convert_struct_type(s))
+            }
+        }
+    }
+
+    fn convert_struct_type(&self, ty: &wasmparser::StructType) -> WasmStructType {
+        WasmStructType {
+            fields: ty
+                .fields
+                .iter()
+                .map(|f| self.convert_field_type(f))
+                .collect(),
+        }
+    }
+
+    fn convert_array_type(&self, ty: &wasmparser::ArrayType) -> WasmArrayType {
+        WasmArrayType(self.convert_field_type(&ty.0))
+    }
+
+    fn convert_field_type(&self, ty: &wasmparser::FieldType) -> WasmFieldType {
+        WasmFieldType {
+            element_type: self.convert_storage_type(&ty.element_type),
+            mutable: ty.mutable,
+        }
+    }
+
+    fn convert_storage_type(&self, ty: &wasmparser::StorageType) -> WasmStorageType {
+        match ty {
+            wasmparser::StorageType::I8 => WasmStorageType::I8,
+            wasmparser::StorageType::I16 => WasmStorageType::I16,
+            wasmparser::StorageType::Val(v) => WasmStorageType::Val(self.convert_valtype(*v)),
         }
     }
 
@@ -459,14 +1793,14 @@ pub trait TypeConvert {
     }
 
     /// Converts a wasmparser value type to a wasmtime type
-    fn convert_valtype(&self, ty: wasmparser::ValType) -> WasmType {
+    fn convert_valtype(&self, ty: wasmparser::ValType) -> WasmValType {
         match ty {
-            wasmparser::ValType::I32 => WasmType::I32,
-            wasmparser::ValType::I64 => WasmType::I64,
-            wasmparser::ValType::F32 => WasmType::F32,
-            wasmparser::ValType::F64 => WasmType::F64,
-            wasmparser::ValType::V128 => WasmType::V128,
-            wasmparser::ValType::Ref(t) => WasmType::Ref(self.convert_ref_type(t)),
+            wasmparser::ValType::I32 => WasmValType::I32,
+            wasmparser::ValType::I64 => WasmValType::I64,
+            wasmparser::ValType::F32 => WasmValType::F32,
+            wasmparser::ValType::F64 => WasmValType::F64,
+            wasmparser::ValType::V128 => WasmValType::V128,
+            wasmparser::ValType::Ref(t) => WasmValType::Ref(self.convert_ref_type(t)),
         }
     }
 
@@ -481,24 +1815,32 @@ pub trait TypeConvert {
     /// Converts a wasmparser heap type to a wasmtime type
     fn convert_heap_type(&self, ty: wasmparser::HeapType) -> WasmHeapType {
         match ty {
-            wasmparser::HeapType::Func => WasmHeapType::Func,
-            wasmparser::HeapType::Extern => WasmHeapType::Extern,
-            wasmparser::HeapType::Indexed(i) => self.lookup_heap_type(TypeIndex::from_u32(i)),
-
-            wasmparser::HeapType::Any
-            | wasmparser::HeapType::None
-            | wasmparser::HeapType::NoExtern
-            | wasmparser::HeapType::NoFunc
-            | wasmparser::HeapType::Eq
-            | wasmparser::HeapType::Struct
-            | wasmparser::HeapType::Array
-            | wasmparser::HeapType::I31 => {
-                unimplemented!("unsupported heap type {ty:?}");
-            }
+            wasmparser::HeapType::Concrete(i) => self.lookup_heap_type(i),
+            wasmparser::HeapType::Abstract { ty, shared: false } => match ty {
+                wasmparser::AbstractHeapType::Extern => WasmHeapType::Extern,
+                wasmparser::AbstractHeapType::NoExtern => WasmHeapType::NoExtern,
+                wasmparser::AbstractHeapType::Func => WasmHeapType::Func,
+                wasmparser::AbstractHeapType::NoFunc => WasmHeapType::NoFunc,
+                wasmparser::AbstractHeapType::Any => WasmHeapType::Any,
+                wasmparser::AbstractHeapType::Eq => WasmHeapType::Eq,
+                wasmparser::AbstractHeapType::I31 => WasmHeapType::I31,
+                wasmparser::AbstractHeapType::Array => WasmHeapType::Array,
+                wasmparser::AbstractHeapType::Struct => WasmHeapType::Struct,
+                wasmparser::AbstractHeapType::None => WasmHeapType::None,
+
+                wasmparser::AbstractHeapType::Exn | wasmparser::AbstractHeapType::NoExn => {
+                    unimplemented!("unsupported heap type {ty:?}");
+                }
+            },
+            _ => unimplemented!("unsupported heap type {ty:?}"),
         }
     }
 
     /// Converts the specified type index from a heap type into a canonicalized
     /// heap type.
-    fn lookup_heap_type(&self, index: TypeIndex) -> WasmHeapType;
+    fn lookup_heap_type(&self, index: wasmparser::UnpackedIndex) -> WasmHeapType;
+
+    /// Converts the specified type index from a heap type into a canonicalized
+    /// heap type.
+    fn lookup_type_index(&self, index: wasmparser::UnpackedIndex) -> EngineOrModuleTypeIndex;
 }
diff --git a/crates/types/src/prelude.rs b/crates/types/src/prelude.rs
new file mode 100644
index 000000000000..70a430820584
--- /dev/null
+++ b/crates/types/src/prelude.rs
@@ -0,0 +1,86 @@
+//! Rust module prelude for Wasmtime crates.
+//!
+//! Wasmtime crates that use `no_std` use `core::prelude::*` by default which
+//! does not include `alloc`-related functionality such as `String` and `Vec`.
+//! To have similar ergonomics to `std` and additionally group up some common
+//! functionality this module is intended to be imported at the top of all
+//! modules with:
+//!
+//! ```rust,ignore
+//! use crate::*;
+//! ```
+//!
+//! Externally for crates that depend on `wasmtime-types` they should have this
+//! in the root of the crate:
+//!
+//! ```rust,ignore
+//! use wasmtime_types::prelude;
+//! ```
+//!
+//! and then `use crate::*` works as usual.
+
+pub use alloc::borrow::ToOwned;
+pub use alloc::boxed::Box;
+pub use alloc::format;
+pub use alloc::string::{String, ToString};
+pub use alloc::vec;
+pub use alloc::vec::Vec;
+pub use wasmparser::collections::{IndexMap, IndexSet};
+
+/// Convenience trait for converting `Result<T, E>` into `anyhow::Result<T>`
+///
+/// Typically this is automatically done with the `?` operator in Rust and
+/// by default this trait isn't necessary. With the `anyhow` crate's `std`
+/// feature disabled, however, the `?` operator won't work because the `Error`
+/// trait is not defined. This trait helps to bridge this gap.
+///
+/// This does the same thing as `?` when the `std` feature is enabled, and when
+/// `std` is disabled it'll use different trait bounds to create an
+/// `anyhow::Error`.
+///
+/// This trait is not suitable as a public interface because features change
+/// what implements the trait. It's good enough for a wasmtime internal
+/// implementation detail, however.
+pub trait Err2Anyhow<T> {
+    /// Convert `self` to `anyhow::Result<T>`.
+    fn err2anyhow(self) -> anyhow::Result<T>;
+}
+
+impl<T, E: IntoAnyhow> Err2Anyhow<T> for Result<T, E> {
+    fn err2anyhow(self) -> anyhow::Result<T> {
+        match self {
+            Ok(e) => Ok(e),
+            Err(e) => Err(e.into_anyhow()),
+        }
+    }
+}
+
+/// Convenience trait to convert a value into `anyhow::Error`
+///
+/// This trait is not a suitable public interface of Wasmtime so it's just an
+/// internal implementation detail for now. This trait is conditionally
+/// implemented on the `std` feature with different bounds.
+pub trait IntoAnyhow {
+    /// Converts `self` into an `anyhow::Error`.
+    fn into_anyhow(self) -> anyhow::Error;
+}
+
+#[cfg(feature = "std")]
+impl<T> IntoAnyhow for T
+where
+    T: Into<anyhow::Error>,
+{
+    fn into_anyhow(self) -> anyhow::Error {
+        self.into()
+    }
+}
+
+#[cfg(not(feature = "std"))]
+impl<T> IntoAnyhow for T
+where
+    T: core::fmt::Display + core::fmt::Debug + Send + Sync + 'static,
+{
+    fn into_anyhow(self) -> anyhow::Error {
+        anyhow::Error::msg(self)
+    }
+}
diff --git a/crates/versioned-export-macros/Cargo.toml b/crates/versioned-export-macros/Cargo.toml
index d9f2d9e472e5..59109a047334 100644
--- a/crates/versioned-export-macros/Cargo.toml
+++ b/crates/versioned-export-macros/Cargo.toml
@@ -2,6 +2,7 @@
 authors = ["The Wasmtime Project Developers"]
 description = "Macros for defining versioned exports in Wasmtime"
 edition.workspace = true
+rust-version.workspace = true
 license = "Apache-2.0 WITH LLVM-exception"
 name = "wasmtime-versioned-export-macros"
 repository = "https://github.com/bytecodealliance/wasmtime"
diff --git a/crates/wasi-common/Cargo.toml b/crates/wasi-common/Cargo.toml
index 3382912e63f2..e1d47d1cfe6e 100644
--- a/crates/wasi-common/Cargo.toml
+++ b/crates/wasi-common/Cargo.toml
@@ -9,30 +9,43 @@ keywords = ["webassembly", "wasm"]
 repository = "https://github.com/bytecodealliance/wasmtime"
 readme = "README.md"
 edition.workspace = true
-include = ["src/**/*", "WASI/phases/**/*", "README.md", "LICENSE", "build.rs"]
-build = "build.rs"
+rust-version.workspace = true
+include = ["src/**/*", "tests/**/*", "witx", "README.md", "LICENSE", "build.rs"]
 
-# This doesn't actually link to a native library, but it allows us to set env
-# vars like `DEP_WASI_COMMON_19_*` for crates that have build scripts and depend
-# on this crate, allowing other crates to use the same witx files.
-links = "wasi-common-19"
+[lints]
+workspace = true
 
 [dependencies]
-anyhow = { workspace = true }
+anyhow = { workspace = true, features = ['std'] }
 thiserror = { workspace = true }
 wiggle = { workspace = true }
-wasmtime = { workspace = true }
 tracing = { workspace = true }
 cap-std = { workspace = true }
 cap-rand = { workspace = true }
 bitflags = { workspace = true }
 log = { workspace = true }
 
+# Optional, enabled by wasmtime feature:
+wasmtime = { workspace = true, optional = true, features = ['runtime'] }
+# Optional, enabled by sync feature:
+cap-fs-ext = { workspace = true, optional = true }
+cap-time-ext = { workspace = true, optional = true }
+fs-set-times = { workspace = true, optional = true }
+system-interface = { workspace = true, features = ["cap_std_impls"], optional = true }
+io-lifetimes = { workspace = true, optional = true }
+# Optional, enabled by tokio feature:
+tokio = { workspace = true, features = [ "rt", "fs", "time", "io-util", "net", "io-std", "rt-multi-thread"], optional = true }
+
+# Optional, enabled by exit feature:
+libc = { workspace = true, optional = true }
+
 [target.'cfg(unix)'.dependencies]
-rustix = { workspace = true, features = ["fs"] }
+rustix = { workspace = true, features = ["fs", "event"] }
 
 [target.'cfg(windows)'.dependencies]
+once_cell = { workspace = true }
 io-extras = { workspace = true }
+rustix = { workspace = true, features = ["net"] }
 
 [target.'cfg(windows)'.dependencies.windows-sys]
 workspace = true
@@ -41,8 +54,17 @@ features = [
     "Win32_Networking_WinSock",
 ]
 
+[dev-dependencies]
+wasi-common = { path = '.', features = ['tokio'] }
+tempfile = { workspace = true }
+test-log = { workspace = true }
+tracing-subscriber = { workspace = true }
+wasmtime = { workspace = true, features = ['cranelift', 'async', 'runtime'] }
+test-programs-artifacts = { workspace = true }
+tokio = { workspace = true, features = ['macros', 'rt-multi-thread'] }
+
 [features]
-default = ["trace_log"]
+default = ["trace_log", "wasmtime", "sync"]
 # This feature enables the `tracing` logs in the calls to target the `log`
 # ecosystem of backends (e.g. `env_logger`. Disable this if you want to use
 # `tracing-subscriber`.
@@ -50,3 +72,30 @@ trace_log = [ "wiggle/tracing_log", "tracing/log" ]
 # Need to make the wiggle_metadata feature available to consumers of this
 # crate if they want the snapshots to have metadata available.
 wiggle_metadata = ["wiggle/wiggle_metadata"]
+# This feature enables integration with wasmtime.
+wasmtime = [
+    "dep:wasmtime",
+    "wiggle/wasmtime",
+]
+# This feature enables an implementation of the Wasi traits for a
+# synchronous wasmtime embedding.
+sync = [
+    "dep:cap-fs-ext",
+    "dep:cap-time-ext",
+    "dep:fs-set-times",
+    "dep:system-interface",
+    "dep:io-lifetimes",
+]
+tokio = [
+    "sync",
+    "wasmtime/async",
+    "wiggle/wasmtime_async",
+    "dep:tokio",
+]
+exit = [ "wasmtime", "dep:libc" ]
+
+[package.metadata.docs.rs]
+all-features = true
+
+[[test]]
+name = "all"
diff --git a/crates/wasi-common/README.md b/crates/wasi-common/README.md
index c406f381320e..4d0dcf2df96b 100644
--- a/crates/wasi-common/README.md
+++ b/crates/wasi-common/README.md
@@ -44,10 +44,10 @@ so stay tuned!
 
 ## Development hints
 When testing the crate, you may want to enable and run full wasm32 integration testsuite. This
-requires `wasm32-wasi` target installed which can be done as follows using [rustup]
+requires `wasm32-wasip1` target installed which can be done as follows using [rustup]
 
 ```
-rustup target add wasm32-wasi
+rustup target add wasm32-wasip1
 ```
 
 [rustup]: https://rustup.rs
diff --git a/crates/wasi-common/WASI b/crates/wasi-common/WASI
deleted file mode 160000
index 0ba0c5e2e376..000000000000
--- a/crates/wasi-common/WASI
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 0ba0c5e2e37625ca5a6d3e4255a998dfaa3efc52
diff --git a/crates/wasi-common/build.rs b/crates/wasi-common/build.rs
deleted file mode 100644
index 275d8dd6deca..000000000000
--- a/crates/wasi-common/build.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Tell any dependencies, if necessary, where our WASI submodule is so they can
-// use the same witx files if they want.
-fn main() {
-    let cwd = std::env::current_dir().unwrap();
-    let wasi = cwd.join("WASI");
-    // this will be available to dependent crates via the DEP_WASI_COMMON_19_WASI env var:
-    println!("cargo:wasi={}", wasi.display());
-    // and available to our own crate as WASI_ROOT:
-    println!("cargo:rustc-env=WASI_ROOT={}", wasi.display());
-    // and this build.rs script doesn't depend on any files.
-    println!("cargo:rerun-if-changed=build.rs");
-}
diff --git a/crates/wasi-common/cap-std-sync/Cargo.toml b/crates/wasi-common/cap-std-sync/Cargo.toml
deleted file mode 100644
index f9811bbb51f6..000000000000
--- a/crates/wasi-common/cap-std-sync/Cargo.toml
+++ /dev/null
@@ -1,42 +0,0 @@
-[package]
-name = "wasi-cap-std-sync"
-version.workspace = true
-authors.workspace = true
-description = "WASI implementation in Rust"
-license = "Apache-2.0 WITH LLVM-exception"
-categories = ["wasm"]
-keywords = ["webassembly", "wasm"]
-repository = "https://github.com/bytecodealliance/wasmtime"
-readme = "README.md"
-edition.workspace = true
-include = ["src/**/*", "README.md", "LICENSE" ]
-
-[dependencies]
-wasi-common = { workspace = true }
-async-trait = { workspace = true }
-anyhow = { workspace = true }
-cap-std = { workspace = true }
-cap-fs-ext = { workspace = true }
-cap-time-ext = { workspace = true }
-cap-rand = { workspace = true }
-fs-set-times = { workspace = true }
-system-interface = { workspace = true, features = ["cap_std_impls"] }
-tracing = { workspace = true }
-io-lifetimes = { workspace = true }
-
-[target.'cfg(unix)'.dependencies]
-rustix = { workspace = true, features = ["fs", "event"] }
-
-[target.'cfg(windows)'.dependencies]
-once_cell = { workspace = true }
-io-extras = { workspace = true }
-rustix = { workspace = true, features = ["net"] }
-
-[target.'cfg(windows)'.dependencies.windows-sys]
-workspace = true
-features = [
-    "Win32_Foundation",
-]
-
-[dev-dependencies]
-tempfile = "3.1.0"
diff --git a/crates/wasi-common/cap-std-sync/LICENSE b/crates/wasi-common/cap-std-sync/LICENSE
deleted file mode 100644
index f9d81955f4bc..000000000000
--- a/crates/wasi-common/cap-std-sync/LICENSE
+++ /dev/null
@@ -1,220 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-
-
---- LLVM Exceptions to the Apache 2.0 License ----
-
-As an exception, if, as a result of your compiling your source code, portions
-of this Software are embedded into an Object form of such source code, you
-may redistribute such embedded portions in such Object form without complying
-with the conditions of Sections 4(a), 4(b) and 4(d) of the License.
-
-In addition, if you combine or link compiled forms of this Software with
-software that is licensed under the GPLv2 ("Combined Software") and if a
-court of competent jurisdiction determines that the patent provision (Section
-3), the indemnity provision (Section 9) or other Section of the License
-conflicts with the conditions of the GPLv2, you may retroactively and
-prospectively choose to deem waived or otherwise exclude such Section(s) of
-the License, but only in their entirety and only with respect to the Combined
-Software.
-
diff --git a/crates/wasi-common/cap-std-sync/README.md b/crates/wasi-common/cap-std-sync/README.md
deleted file mode 100644
index 76497dbcf332..000000000000
--- a/crates/wasi-common/cap-std-sync/README.md
+++ /dev/null
@@ -1 +0,0 @@
-WASI implementation in Rust, using cap-std.
diff --git a/crates/wasi-common/cap-std-sync/src/clocks.rs b/crates/wasi-common/cap-std-sync/src/clocks.rs
deleted file mode 100644
index 71eb34252bb0..000000000000
--- a/crates/wasi-common/cap-std-sync/src/clocks.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-use cap_std::time::{Duration, Instant, SystemTime};
-use cap_std::{ambient_authority, AmbientAuthority};
-use cap_time_ext::{MonotonicClockExt, SystemClockExt};
-use wasi_common::clocks::{WasiClocks, WasiMonotonicClock, WasiSystemClock};
-
-pub struct SystemClock(cap_std::time::SystemClock);
-
-impl SystemClock {
-    pub fn new(ambient_authority: AmbientAuthority) -> Self {
-        SystemClock(cap_std::time::SystemClock::new(ambient_authority))
-    }
-}
-impl WasiSystemClock for SystemClock {
-    fn resolution(&self) -> Duration {
-        self.0.resolution()
-    }
-    fn now(&self, precision: Duration) -> SystemTime {
-        self.0.now_with(precision)
-    }
-}
-
-pub struct MonotonicClock(cap_std::time::MonotonicClock);
-impl MonotonicClock {
-    pub fn new(ambient_authority: AmbientAuthority) -> Self {
-        MonotonicClock(cap_std::time::MonotonicClock::new(ambient_authority))
-    }
-}
-impl WasiMonotonicClock for MonotonicClock {
-    fn resolution(&self) -> Duration {
-        self.0.resolution()
-    }
-    fn now(&self, precision: Duration) -> Instant {
-        self.0.now_with(precision)
-    }
-}
-
-pub fn clocks_ctx() -> WasiClocks {
-    WasiClocks::new()
-        .with_system(SystemClock::new(ambient_authority()))
-        .with_monotonic(MonotonicClock::new(ambient_authority()))
-}
diff --git a/crates/wasi-common/cap-std-sync/src/dir.rs b/crates/wasi-common/cap-std-sync/src/dir.rs
deleted file mode 100644
index c4ba736502d8..000000000000
--- a/crates/wasi-common/cap-std-sync/src/dir.rs
+++ /dev/null
@@ -1,464 +0,0 @@
-use crate::file::{filetype_from, File};
-use cap_fs_ext::{DirEntryExt, DirExt, MetadataExt, OpenOptionsMaybeDirExt, SystemTimeSpec};
-use cap_std::fs;
-use std::any::Any;
-use std::path::{Path, PathBuf};
-use system_interface::fs::GetSetFdFlags;
-use wasi_common::{
-    dir::{ReaddirCursor, ReaddirEntity, WasiDir},
-    file::{FdFlags, FileType, Filestat, OFlags},
-    Error, ErrorExt,
-};
-
-pub struct Dir(fs::Dir);
-
-pub enum OpenResult {
-    File(File),
-    Dir(Dir),
-}
-
-impl Dir {
-    pub fn from_cap_std(dir: fs::Dir) -> Self {
-        Dir(dir)
-    }
-
-    pub fn open_file_(
-        &self,
-        symlink_follow: bool,
-        path: &str,
-        oflags: OFlags,
-        read: bool,
-        write: bool,
-        fdflags: FdFlags,
-    ) -> Result<OpenResult, Error> {
-        use cap_fs_ext::{FollowSymlinks, OpenOptionsFollowExt};
-
-        let mut opts = fs::OpenOptions::new();
-        opts.maybe_dir(true);
-
-        if oflags.contains(OFlags::CREATE | OFlags::EXCLUSIVE) {
-            opts.create_new(true);
-            opts.write(true);
-        } else if oflags.contains(OFlags::CREATE) {
-            opts.create(true);
-            opts.write(true);
-        }
-        if oflags.contains(OFlags::TRUNCATE) {
-            opts.truncate(true);
-        }
-        if read {
-            opts.read(true);
-        }
-        if write {
-            opts.write(true);
-        } else {
-            // If not opened write, open read. This way the OS lets us open the file.
-            // If FileCaps::READ is not set, read calls will be rejected at the
-            // get_cap check.
-            opts.read(true);
-        }
-        if fdflags.contains(FdFlags::APPEND) {
-            opts.append(true);
-        }
-
-        if symlink_follow {
-            opts.follow(FollowSymlinks::Yes);
-        } else {
-            opts.follow(FollowSymlinks::No);
-        }
-        // the DSYNC, SYNC, and RSYNC flags are ignored! We do not
-        // have support for them in cap-std yet.
-        // ideally OpenOptions would just support this though:
-        // https://github.com/bytecodealliance/cap-std/issues/146
-        if fdflags.intersects(
-            wasi_common::file::FdFlags::DSYNC
-                | wasi_common::file::FdFlags::SYNC
-                | wasi_common::file::FdFlags::RSYNC,
-        ) {
-            return Err(Error::not_supported().context("SYNC family of FdFlags"));
-        }
-
-        if oflags.contains(OFlags::DIRECTORY) {
-            if oflags.contains(OFlags::CREATE)
-                || oflags.contains(OFlags::EXCLUSIVE)
-                || oflags.contains(OFlags::TRUNCATE)
-            {
-                return Err(Error::invalid_argument().context("directory oflags"));
-            }
-        }
-
-        let mut f = self.0.open_with(Path::new(path), &opts)?;
-        if f.metadata()?.is_dir() {
-            Ok(OpenResult::Dir(Dir::from_cap_std(fs::Dir::from_std_file(
-                f.into_std(),
-            ))))
-        } else if oflags.contains(OFlags::DIRECTORY) {
-            Err(Error::not_dir().context("expected directory but got file"))
-        } else {
-            // NONBLOCK does not have an OpenOption either, but we can patch that on with set_fd_flags:
-            if fdflags.contains(wasi_common::file::FdFlags::NONBLOCK) {
-                let set_fd_flags = f.new_set_fd_flags(system_interface::fs::FdFlags::NONBLOCK)?;
-                f.set_fd_flags(set_fd_flags)?;
-            }
-            Ok(OpenResult::File(File::from_cap_std(f)))
-        }
-    }
-
-    pub fn rename_(&self, src_path: &str, dest_dir: &Self, dest_path: &str) -> Result<(), Error> {
-        self.0
-            .rename(Path::new(src_path), &dest_dir.0, Path::new(dest_path))?;
-        Ok(())
-    }
-    pub fn hard_link_(
-        &self,
-        src_path: &str,
-        target_dir: &Self,
-        target_path: &str,
-    ) -> Result<(), Error> {
-        let src_path = Path::new(src_path);
-        let target_path = Path::new(target_path);
-        self.0.hard_link(src_path, &target_dir.0, target_path)?;
-        Ok(())
-    }
-}
-
-#[async_trait::async_trait]
-impl WasiDir for Dir {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-    async fn open_file(
-        &self,
-        symlink_follow: bool,
-        path: &str,
-        oflags: OFlags,
-        read: bool,
-        write: bool,
-        fdflags: FdFlags,
-    ) -> Result<wasi_common::dir::OpenResult, Error> {
-        let f = self.open_file_(symlink_follow, path, oflags, read, write, fdflags)?;
-        match f {
-            OpenResult::File(f) => Ok(wasi_common::dir::OpenResult::File(Box::new(f))),
-            OpenResult::Dir(d) => Ok(wasi_common::dir::OpenResult::Dir(Box::new(d))),
-        }
-    }
-
-    async fn create_dir(&self, path: &str) -> Result<(), Error> {
-        self.0.create_dir(Path::new(path))?;
-        Ok(())
-    }
-    async fn readdir(
-        &self,
-        cursor: ReaddirCursor,
-    ) -> Result<Box<dyn Iterator<Item = Result<ReaddirEntity, Error>> + Send>, Error> {
-        // We need to keep a full-fidelity io Error around to check for a special failure mode
-        // on windows, but also this function can fail due to an illegal byte sequence in a
-        // filename, which we can't construct an io Error to represent.
-        enum ReaddirError {
-            Io(std::io::Error),
-            IllegalSequence,
-        }
-        impl From<std::io::Error> for ReaddirError {
-            fn from(e: std::io::Error) -> ReaddirError {
-                ReaddirError::Io(e)
-            }
-        }
-
-        // cap_std's read_dir does not include . and .., we should prepend these.
-        // Why does the Ok contain a tuple? We can't construct a cap_std::fs::DirEntry, and we don't
-        // have enough info to make a ReaddirEntity yet.
-        let dir_meta = self.0.dir_metadata()?;
-        let rd = vec![
-            {
-                let name = ".".to_owned();
-                Ok::<_, ReaddirError>((FileType::Directory, dir_meta.ino(), name))
-            },
-            {
-                let name = "..".to_owned();
-                Ok((FileType::Directory, dir_meta.ino(), name))
-            },
-        ]
-        .into_iter()
-        .chain({
-            // Now process the `DirEntry`s:
-            let entries = self.0.entries()?.map(|entry| {
-                let entry = entry?;
-                let meta = entry.full_metadata()?;
-                let inode = meta.ino();
-                let filetype = filetype_from(&meta.file_type());
-                let name = entry
-                    .file_name()
-                    .into_string()
-                    .map_err(|_| ReaddirError::IllegalSequence)?;
-                Ok((filetype, inode, name))
-            });
-
-            // On Windows, filter out files like `C:\DumpStack.log.tmp` which we
-            // can't get a full metadata for.
-            #[cfg(windows)]
-            let entries = entries.filter(|entry| {
-                use windows_sys::Win32::Foundation::{
-                    ERROR_ACCESS_DENIED, ERROR_SHARING_VIOLATION,
-                };
-                if let Err(ReaddirError::Io(err)) = entry {
-                    if err.raw_os_error() == Some(ERROR_SHARING_VIOLATION as i32)
-                        || err.raw_os_error() == Some(ERROR_ACCESS_DENIED as i32)
-                    {
-                        return false;
-                    }
-                }
-                true
-            });
-
-            entries
-        })
-        // Enumeration of the iterator makes it possible to define the ReaddirCursor
-        .enumerate()
-        .map(|(ix, r)| match r {
-            Ok((filetype, inode, name)) => Ok(ReaddirEntity {
-                next: ReaddirCursor::from(ix as u64 + 1),
-                filetype,
-                inode,
-                name,
-            }),
-            Err(ReaddirError::Io(e)) => Err(e.into()),
-            Err(ReaddirError::IllegalSequence) => Err(Error::illegal_byte_sequence()),
-        })
-        .skip(u64::from(cursor) as usize);
-
-        Ok(Box::new(rd))
-    }
-
-    async fn symlink(&self, src_path: &str, dest_path: &str) -> Result<(), Error> {
-        self.0.symlink(src_path, dest_path)?;
-        Ok(())
-    }
-    async fn remove_dir(&self, path: &str) -> Result<(), Error> {
-        self.0.remove_dir(Path::new(path))?;
-        Ok(())
-    }
-
-    async fn unlink_file(&self, path: &str) -> Result<(), Error> {
-        self.0.remove_file_or_symlink(Path::new(path))?;
-        Ok(())
-    }
-    async fn read_link(&self, path: &str) -> Result<PathBuf, Error> {
-        let link = self.0.read_link(Path::new(path))?;
-        Ok(link)
-    }
-    async fn get_filestat(&self) -> Result<Filestat, Error> {
-        let meta = self.0.dir_metadata()?;
-        Ok(Filestat {
-            device_id: meta.dev(),
-            inode: meta.ino(),
-            filetype: filetype_from(&meta.file_type()),
-            nlink: meta.nlink(),
-            size: meta.len(),
-            atim: meta.accessed().map(|t| Some(t.into_std())).unwrap_or(None),
-            mtim: meta.modified().map(|t| Some(t.into_std())).unwrap_or(None),
-            ctim: meta.created().map(|t| Some(t.into_std())).unwrap_or(None),
-        })
-    }
-    async fn get_path_filestat(
-        &self,
-        path: &str,
-        follow_symlinks: bool,
-    ) -> Result<Filestat, Error> {
-        let meta = if follow_symlinks {
-            self.0.metadata(Path::new(path))?
-        } else {
-            self.0.symlink_metadata(Path::new(path))?
-        };
-        Ok(Filestat {
-            device_id: meta.dev(),
-            inode: meta.ino(),
-            filetype: filetype_from(&meta.file_type()),
-            nlink: meta.nlink(),
-            size: meta.len(),
-            atim: meta.accessed().map(|t| Some(t.into_std())).unwrap_or(None),
-            mtim: meta.modified().map(|t| Some(t.into_std())).unwrap_or(None),
-            ctim: meta.created().map(|t| Some(t.into_std())).unwrap_or(None),
-        })
-    }
-    async fn rename(
-        &self,
-        src_path: &str,
-        dest_dir: &dyn WasiDir,
-        dest_path: &str,
-    ) -> Result<(), Error> {
-        let dest_dir = dest_dir
-            .as_any()
-            .downcast_ref::<Self>()
-            .ok_or(Error::badf().context("failed downcast to cap-std Dir"))?;
-        self.rename_(src_path, dest_dir, dest_path)
-    }
-    async fn hard_link(
-        &self,
-        src_path: &str,
-        target_dir: &dyn WasiDir,
-        target_path: &str,
-    ) -> Result<(), Error> {
-        let target_dir = target_dir
-            .as_any()
-            .downcast_ref::<Self>()
-            .ok_or(Error::badf().context("failed downcast to cap-std Dir"))?;
-        self.hard_link_(src_path, target_dir, target_path)
-    }
-    async fn set_times(
-        &self,
-        path: &str,
-        atime: Option<wasi_common::SystemTimeSpec>,
-        mtime: Option<wasi_common::SystemTimeSpec>,
-        follow_symlinks: bool,
-    ) -> Result<(), Error> {
-        if follow_symlinks {
-            self.0.set_times(
-                Path::new(path),
-                convert_systimespec(atime),
-                convert_systimespec(mtime),
-            )?;
-        } else {
-            self.0.set_symlink_times(
-                Path::new(path),
-                convert_systimespec(atime),
-                convert_systimespec(mtime),
-            )?;
-        }
-        Ok(())
-    }
-}
-
-fn convert_systimespec(t: Option<wasi_common::SystemTimeSpec>) -> Option<SystemTimeSpec> {
-    match t {
-        Some(wasi_common::SystemTimeSpec::Absolute(t)) => Some(SystemTimeSpec::Absolute(t)),
-        Some(wasi_common::SystemTimeSpec::SymbolicNow) => Some(SystemTimeSpec::SymbolicNow),
-        None => None,
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::Dir;
-    use cap_std::ambient_authority;
-    use wasi_common::file::{FdFlags, OFlags};
-    #[test]
-    fn scratch_dir() {
-        let tempdir = tempfile::Builder::new()
-            .prefix("cap-std-sync")
-            .tempdir()
-            .expect("create temporary dir");
-        let preopen_dir = cap_std::fs::Dir::open_ambient_dir(tempdir.path(), ambient_authority())
-            .expect("open ambient temporary dir");
-        let preopen_dir = Dir::from_cap_std(preopen_dir);
-        run(wasi_common::WasiDir::open_file(
-            &preopen_dir,
-            false,
-            ".",
-            OFlags::empty(),
-            false,
-            false,
-            FdFlags::empty(),
-        ))
-        .expect("open the same directory via WasiDir abstraction");
-    }
-
-    // Readdir does not work on windows, so we won't test it there.
-    #[cfg(not(windows))]
-    #[test]
-    fn readdir() {
-        use std::collections::HashMap;
-        use wasi_common::dir::{ReaddirCursor, ReaddirEntity, WasiDir};
-        use wasi_common::file::{FdFlags, FileType, OFlags};
-
-        fn readdir_into_map(dir: &dyn WasiDir) -> HashMap<String, ReaddirEntity> {
-            let mut out = HashMap::new();
-            for readdir_result in
-                run(dir.readdir(ReaddirCursor::from(0))).expect("readdir succeeds")
-            {
-                let entity = readdir_result.expect("readdir entry is valid");
-                out.insert(entity.name.clone(), entity);
-            }
-            out
-        }
-
-        let tempdir = tempfile::Builder::new()
-            .prefix("cap-std-sync")
-            .tempdir()
-            .expect("create temporary dir");
-        let preopen_dir = cap_std::fs::Dir::open_ambient_dir(tempdir.path(), ambient_authority())
-            .expect("open ambient temporary dir");
-        let preopen_dir = Dir::from_cap_std(preopen_dir);
-
-        let entities = readdir_into_map(&preopen_dir);
-        assert_eq!(
-            entities.len(),
-            2,
-            "should just be . and .. in empty dir: {:?}",
-            entities
-        );
-        assert!(entities.get(".").is_some());
-        assert!(entities.get("..").is_some());
-
-        run(preopen_dir.open_file(
-            false,
-            "file1",
-            OFlags::CREATE,
-            true,
-            false,
-            FdFlags::empty(),
-        ))
-        .expect("create file1");
-
-        let entities = readdir_into_map(&preopen_dir);
-        assert_eq!(entities.len(), 3, "should be ., .., file1 {:?}", entities);
-        assert_eq!(
-            entities.get(".").expect(". entry").filetype,
-            FileType::Directory
-        );
-        assert_eq!(
-            entities.get("..").expect(".. entry").filetype,
-            FileType::Directory
-        );
-        assert_eq!(
-            entities.get("file1").expect("file1 entry").filetype,
-            FileType::RegularFile
-        );
-    }
-
-    fn run<F: std::future::Future>(future: F) -> F::Output {
-        use std::pin::Pin;
-        use std::task::{Context, Poll, RawWaker, RawWakerVTable, Waker};
-
-        let mut f = Pin::from(Box::new(future));
-        let waker = dummy_waker();
-        let mut cx = Context::from_waker(&waker);
-        match f.as_mut().poll(&mut cx) {
-            Poll::Ready(val) => return val,
-            Poll::Pending => {
-                panic!("Cannot wait on pending future: must enable wiggle \"async\" future and execute on an async Store")
-            }
-        }
-
-        fn dummy_waker() -> Waker {
-            return unsafe { Waker::from_raw(clone(5 as *const _)) };
-
-            unsafe fn clone(ptr: *const ()) -> RawWaker {
-                assert_eq!(ptr as usize, 5);
-                const VTABLE: RawWakerVTable = RawWakerVTable::new(clone, wake, wake_by_ref, drop);
-                RawWaker::new(ptr, &VTABLE)
-            }
-
-            unsafe fn wake(ptr: *const ()) {
-                assert_eq!(ptr as usize, 5);
-            }
-
-            unsafe fn wake_by_ref(ptr: *const ()) {
-                assert_eq!(ptr as usize, 5);
-            }
-
-            unsafe fn drop(ptr: *const ()) {
-                assert_eq!(ptr as usize, 5);
-            }
-        }
-    }
-}
diff --git a/crates/wasi-common/cap-std-sync/src/file.rs b/crates/wasi-common/cap-std-sync/src/file.rs
deleted file mode 100644
index e986c173404d..000000000000
--- a/crates/wasi-common/cap-std-sync/src/file.rs
+++ /dev/null
@@ -1,254 +0,0 @@
-use cap_fs_ext::MetadataExt;
-use fs_set_times::{SetTimes, SystemTimeSpec};
-use io_lifetimes::AsFilelike;
-use std::any::Any;
-use std::convert::TryInto;
-use std::io::{self, IsTerminal};
-use system_interface::{
-    fs::{FileIoExt, GetSetFdFlags},
-    io::{IoExt, ReadReady},
-};
-use wasi_common::{
-    file::{Advice, FdFlags, FileType, Filestat, WasiFile},
-    Error, ErrorExt,
-};
-
-pub struct File(cap_std::fs::File);
-
-impl File {
-    pub fn from_cap_std(file: cap_std::fs::File) -> Self {
-        File(file)
-    }
-}
-
-#[async_trait::async_trait]
-impl WasiFile for File {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-    #[cfg(unix)]
-    fn pollable(&self) -> Option<rustix::fd::BorrowedFd> {
-        Some(self.0.as_fd())
-    }
-    #[cfg(windows)]
-    fn pollable(&self) -> Option<io_extras::os::windows::RawHandleOrSocket> {
-        Some(self.0.as_raw_handle_or_socket())
-    }
-    async fn datasync(&self) -> Result<(), Error> {
-        self.0.sync_data()?;
-        Ok(())
-    }
-    async fn sync(&self) -> Result<(), Error> {
-        self.0.sync_all()?;
-        Ok(())
-    }
-    async fn get_filetype(&self) -> Result<FileType, Error> {
-        let meta = self.0.metadata()?;
-        Ok(filetype_from(&meta.file_type()))
-    }
-    async fn get_fdflags(&self) -> Result<FdFlags, Error> {
-        let fdflags = get_fd_flags(&self.0)?;
-        Ok(fdflags)
-    }
-    async fn set_fdflags(&mut self, fdflags: FdFlags) -> Result<(), Error> {
-        if fdflags.intersects(
-            wasi_common::file::FdFlags::DSYNC
-                | wasi_common::file::FdFlags::SYNC
-                | wasi_common::file::FdFlags::RSYNC,
-        ) {
-            return Err(Error::invalid_argument().context("cannot set DSYNC, SYNC, or RSYNC flag"));
-        }
-        let set_fd_flags = self.0.new_set_fd_flags(to_sysif_fdflags(fdflags))?;
-        self.0.set_fd_flags(set_fd_flags)?;
-        Ok(())
-    }
-    async fn get_filestat(&self) -> Result<Filestat, Error> {
-        let meta = self.0.metadata()?;
-        Ok(Filestat {
-            device_id: meta.dev(),
-            inode: meta.ino(),
-            filetype: filetype_from(&meta.file_type()),
-            nlink: meta.nlink(),
-            size: meta.len(),
-            atim: meta.accessed().map(|t| Some(t.into_std())).unwrap_or(None),
-            mtim: meta.modified().map(|t| Some(t.into_std())).unwrap_or(None),
-            ctim: meta.created().map(|t| Some(t.into_std())).unwrap_or(None),
-        })
-    }
-    async fn set_filestat_size(&self, size: u64) -> Result<(), Error> {
-        self.0.set_len(size)?;
-        Ok(())
-    }
-    async fn advise(&self, offset: u64, len: u64, advice: Advice) -> Result<(), Error> {
-        self.0.advise(offset, len, convert_advice(advice))?;
-        Ok(())
-    }
-    async fn set_times(
-        &self,
-        atime: Option<wasi_common::SystemTimeSpec>,
-        mtime: Option<wasi_common::SystemTimeSpec>,
-    ) -> Result<(), Error> {
-        self.0
-            .set_times(convert_systimespec(atime), convert_systimespec(mtime))?;
-        Ok(())
-    }
-    async fn read_vectored<'a>(&self, bufs: &mut [io::IoSliceMut<'a>]) -> Result<u64, Error> {
-        let n = self.0.read_vectored(bufs)?;
-        Ok(n.try_into()?)
-    }
-    async fn read_vectored_at<'a>(
-        &self,
-        bufs: &mut [io::IoSliceMut<'a>],
-        offset: u64,
-    ) -> Result<u64, Error> {
-        let n = self.0.read_vectored_at(bufs, offset)?;
-        Ok(n.try_into()?)
-    }
-    async fn write_vectored<'a>(&self, bufs: &[io::IoSlice<'a>]) -> Result<u64, Error> {
-        let n = self.0.write_vectored(bufs)?;
-        Ok(n.try_into()?)
-    }
-    async fn write_vectored_at<'a>(
-        &self,
-        bufs: &[io::IoSlice<'a>],
-        offset: u64,
-    ) -> Result<u64, Error> {
-        let n = self.0.write_vectored_at(bufs, offset)?;
-        Ok(n.try_into()?)
-    }
-    async fn seek(&self, pos: std::io::SeekFrom) -> Result<u64, Error> {
-        Ok(self.0.seek(pos)?)
-    }
-    async fn peek(&self, buf: &mut [u8]) -> Result<u64, Error> {
-        let n = self.0.peek(buf)?;
-        Ok(n.try_into()?)
-    }
-    fn num_ready_bytes(&self) -> Result<u64, Error> {
-        Ok(self.0.num_ready_bytes()?)
-    }
-    fn isatty(&self) -> bool {
-        #[cfg(unix)]
-        return self.0.as_fd().is_terminal();
-        #[cfg(windows)]
-        return self.0.as_handle().is_terminal();
-    }
-}
-
-pub fn filetype_from(ft: &cap_std::fs::FileType) -> FileType {
-    use cap_fs_ext::FileTypeExt;
-    if ft.is_dir() {
-        FileType::Directory
-    } else if ft.is_symlink() {
-        FileType::SymbolicLink
-    } else if ft.is_socket() {
-        if ft.is_block_device() {
-            FileType::SocketDgram
-        } else {
-            FileType::SocketStream
-        }
-    } else if ft.is_block_device() {
-        FileType::BlockDevice
-    } else if ft.is_char_device() {
-        FileType::CharacterDevice
-    } else if ft.is_file() {
-        FileType::RegularFile
-    } else {
-        FileType::Unknown
-    }
-}
-
-#[cfg(windows)]
-use io_lifetimes::{AsHandle, BorrowedHandle};
-#[cfg(windows)]
-impl AsHandle for File {
-    fn as_handle(&self) -> BorrowedHandle<'_> {
-        self.0.as_handle()
-    }
-}
-
-#[cfg(windows)]
-use io_extras::os::windows::{AsRawHandleOrSocket, RawHandleOrSocket};
-#[cfg(windows)]
-impl AsRawHandleOrSocket for File {
-    #[inline]
-    fn as_raw_handle_or_socket(&self) -> RawHandleOrSocket {
-        self.0.as_raw_handle_or_socket()
-    }
-}
-
-#[cfg(unix)]
-use io_lifetimes::{AsFd, BorrowedFd};
-
-#[cfg(unix)]
-impl AsFd for File {
-    fn as_fd(&self) -> BorrowedFd<'_> {
-        self.0.as_fd()
-    }
-}
-
-pub(crate) fn convert_systimespec(
-    t: Option<wasi_common::SystemTimeSpec>,
-) -> Option<SystemTimeSpec> {
-    match t {
-        Some(wasi_common::SystemTimeSpec::Absolute(t)) => {
-            Some(SystemTimeSpec::Absolute(t.into_std()))
-        }
-        Some(wasi_common::SystemTimeSpec::SymbolicNow) => Some(SystemTimeSpec::SymbolicNow),
-        None => None,
-    }
-}
-
-pub(crate) fn to_sysif_fdflags(f: wasi_common::file::FdFlags) -> system_interface::fs::FdFlags {
-    let mut out = system_interface::fs::FdFlags::empty();
-    if f.contains(wasi_common::file::FdFlags::APPEND) {
-        out |= system_interface::fs::FdFlags::APPEND;
-    }
-    if f.contains(wasi_common::file::FdFlags::DSYNC) {
-        out |= system_interface::fs::FdFlags::DSYNC;
-    }
-    if f.contains(wasi_common::file::FdFlags::NONBLOCK) {
-        out |= system_interface::fs::FdFlags::NONBLOCK;
-    }
-    if f.contains(wasi_common::file::FdFlags::RSYNC) {
-        out |= system_interface::fs::FdFlags::RSYNC;
-    }
-    if f.contains(wasi_common::file::FdFlags::SYNC) {
-        out |= system_interface::fs::FdFlags::SYNC;
-    }
-    out
-}
-
-/// Return the file-descriptor flags for a given file-like object.
-///
-/// This returns the flags needed to implement [`WasiFile::get_fdflags`].
-pub fn get_fd_flags<Filelike: AsFilelike>(f: Filelike) -> io::Result<wasi_common::file::FdFlags> {
-    let f = f.as_filelike().get_fd_flags()?;
-    let mut out = wasi_common::file::FdFlags::empty();
-    if f.contains(system_interface::fs::FdFlags::APPEND) {
-        out |= wasi_common::file::FdFlags::APPEND;
-    }
-    if f.contains(system_interface::fs::FdFlags::DSYNC) {
-        out |= wasi_common::file::FdFlags::DSYNC;
-    }
-    if f.contains(system_interface::fs::FdFlags::NONBLOCK) {
-        out |= wasi_common::file::FdFlags::NONBLOCK;
-    }
-    if f.contains(system_interface::fs::FdFlags::RSYNC) {
-        out |= wasi_common::file::FdFlags::RSYNC;
-    }
-    if f.contains(system_interface::fs::FdFlags::SYNC) {
-        out |= wasi_common::file::FdFlags::SYNC;
-    }
-    Ok(out)
-}
-
-fn convert_advice(advice: Advice) -> system_interface::fs::Advice {
-    match advice {
-        Advice::Normal => system_interface::fs::Advice::Normal,
-        Advice::Sequential => system_interface::fs::Advice::Sequential,
-        Advice::Random => system_interface::fs::Advice::Random,
-        Advice::WillNeed => system_interface::fs::Advice::WillNeed,
-        Advice::DontNeed => system_interface::fs::Advice::DontNeed,
-        Advice::NoReuse => system_interface::fs::Advice::NoReuse,
-    }
-}
diff --git a/crates/wasi-common/cap-std-sync/src/lib.rs b/crates/wasi-common/cap-std-sync/src/lib.rs
deleted file mode 100644
index 832c77cfa496..000000000000
--- a/crates/wasi-common/cap-std-sync/src/lib.rs
+++ /dev/null
@@ -1,161 +0,0 @@
-//! The `wasi-cap-std-sync` crate provides impl of `WasiFile` and `WasiDir` in
-//! terms of `cap_std::fs::{File, Dir}`. These types provide sandboxed access
-//! to the local filesystem on both Unix and Windows.
-//!
-//! All syscalls are hidden behind the `cap-std` hierarchy, with the lone
-//! exception of the `sched` implementation, which is provided for both unix
-//! and windows in separate modules.
-//!
-//! Any `wasi_common::{WasiCtx, WasiCtxBuilder}` is interoperable with the
-//! `wasi-cap-std-sync` crate. However, for convenience, `wasi-cap-std-sync`
-//! provides its own `WasiCtxBuilder` that hooks up to all of the crate's
-//! components, i.e. it fills in all of the arguments to
-//! `WasiCtx::builder(...)`, presents `preopen_dir` in terms of
-//! `cap_std::fs::Dir`, and provides convenience methods for inheriting the
-//! parent process's stdio, args, and env.
-//!
-//! For the convenience of consumers, `cap_std::fs::Dir` is re-exported from
-//! this crate. This saves consumers tracking an additional dep on the exact
-//! version of cap_std used by this crate, if they want to avoid it.
-//!
-//! The only place we expect to run into long-term compatibility issues
-//! between `wasi-cap-std-sync` and the other impl crates that will come later
-//! is in the `Sched` abstraction. Once we can build an async scheduler based
-//! on Rust `Future`s, async impls will be able to interoperate, but the
-//! synchronous scheduler depends on downcasting the `WasiFile` type down to
-//! concrete types it knows about (which in turn impl `AsFd` for passing to
-//! unix `poll`, or the analogous traits on windows).
-//!
-//! Why is this impl suffixed with `-sync`? Because `async` is coming soon!
-//! The async impl may end up depending on tokio or other relatively heavy
-//! deps, so we will retain a sync implementation so that wasi-common users
-//! have an option of not pulling in an async runtime.
-
-#![cfg_attr(io_lifetimes_use_std, feature(io_safety))]
-
-pub mod clocks;
-pub mod dir;
-pub mod file;
-pub mod net;
-pub mod sched;
-pub mod stdio;
-
-pub use cap_std::ambient_authority;
-pub use cap_std::fs::Dir;
-pub use cap_std::net::TcpListener;
-pub use clocks::clocks_ctx;
-pub use sched::sched_ctx;
-
-use crate::net::Socket;
-use cap_rand::{Rng, RngCore, SeedableRng};
-use std::mem;
-use std::path::Path;
-use wasi_common::{file::FileAccessMode, table::Table, Error, WasiCtx, WasiFile};
-
-pub struct WasiCtxBuilder {
-    ctx: WasiCtx,
-    built: bool,
-}
-
-impl WasiCtxBuilder {
-    pub fn new() -> Self {
-        WasiCtxBuilder {
-            ctx: WasiCtx::new(random_ctx(), clocks_ctx(), sched_ctx(), Table::new()),
-            built: false,
-        }
-    }
-    pub fn env(
-        &mut self,
-        var: &str,
-        value: &str,
-    ) -> Result<&mut Self, wasi_common::StringArrayError> {
-        self.ctx.push_env(var, value)?;
-        Ok(self)
-    }
-    pub fn envs(
-        &mut self,
-        env: &[(String, String)],
-    ) -> Result<&mut Self, wasi_common::StringArrayError> {
-        for (k, v) in env {
-            self.ctx.push_env(k, v)?;
-        }
-        Ok(self)
-    }
-    pub fn inherit_env(&mut self) -> Result<&mut Self, wasi_common::StringArrayError> {
-        for (key, value) in std::env::vars() {
-            self.ctx.push_env(&key, &value)?;
-        }
-        Ok(self)
-    }
-    pub fn arg(&mut self, arg: &str) -> Result<&mut Self, wasi_common::StringArrayError> {
-        self.ctx.push_arg(arg)?;
-        Ok(self)
-    }
-    pub fn args(&mut self, arg: &[String]) -> Result<&mut Self, wasi_common::StringArrayError> {
-        for a in arg {
-            self.ctx.push_arg(&a)?;
-        }
-        Ok(self)
-    }
-    pub fn inherit_args(&mut self) -> Result<&mut Self, wasi_common::StringArrayError> {
-        for arg in std::env::args() {
-            self.ctx.push_arg(&arg)?;
-        }
-        Ok(self)
-    }
-    pub fn stdin(&mut self, f: Box<dyn WasiFile>) -> &mut Self {
-        self.ctx.set_stdin(f);
-        self
-    }
-    pub fn stdout(&mut self, f: Box<dyn WasiFile>) -> &mut Self {
-        self.ctx.set_stdout(f);
-        self
-    }
-    pub fn stderr(&mut self, f: Box<dyn WasiFile>) -> &mut Self {
-        self.ctx.set_stderr(f);
-        self
-    }
-    pub fn inherit_stdin(&mut self) -> &mut Self {
-        self.stdin(Box::new(crate::stdio::stdin()))
-    }
-    pub fn inherit_stdout(&mut self) -> &mut Self {
-        self.stdout(Box::new(crate::stdio::stdout()))
-    }
-    pub fn inherit_stderr(&mut self) -> &mut Self {
-        self.stderr(Box::new(crate::stdio::stderr()))
-    }
-    pub fn inherit_stdio(&mut self) -> &mut Self {
-        self.inherit_stdin().inherit_stdout().inherit_stderr()
-    }
-    pub fn preopened_dir(
-        &mut self,
-        dir: Dir,
-        guest_path: impl AsRef<Path>,
-    ) -> Result<&mut Self, Error> {
-        let dir = Box::new(crate::dir::Dir::from_cap_std(dir));
-        self.ctx.push_preopened_dir(dir, guest_path)?;
-        Ok(self)
-    }
-    pub fn preopened_socket(
-        &mut self,
-        fd: u32,
-        socket: impl Into<Socket>,
-    ) -> Result<&mut Self, Error> {
-        let socket: Socket = socket.into();
-        let file: Box<dyn WasiFile> = socket.into();
-        self.ctx
-            .insert_file(fd, file, FileAccessMode::READ | FileAccessMode::WRITE);
-        Ok(self)
-    }
-    pub fn build(&mut self) -> WasiCtx {
-        assert!(!self.built);
-        let WasiCtxBuilder { ctx, .. } = mem::replace(self, Self::new());
-        self.built = true;
-        ctx
-    }
-}
-
-pub fn random_ctx() -> Box<dyn RngCore + Send + Sync> {
-    let mut rng = cap_rand::thread_rng(cap_rand::ambient_authority());
-    Box::new(cap_rand::rngs::StdRng::from_seed(rng.gen()))
-}
diff --git a/crates/wasi-common/cap-std-sync/src/net.rs b/crates/wasi-common/cap-std-sync/src/net.rs
deleted file mode 100644
index c0750cd83e46..000000000000
--- a/crates/wasi-common/cap-std-sync/src/net.rs
+++ /dev/null
@@ -1,402 +0,0 @@
-#[cfg(windows)]
-use io_extras::os::windows::{AsRawHandleOrSocket, RawHandleOrSocket};
-use io_lifetimes::AsSocketlike;
-#[cfg(unix)]
-use io_lifetimes::{AsFd, BorrowedFd};
-#[cfg(windows)]
-use io_lifetimes::{AsSocket, BorrowedSocket};
-use std::any::Any;
-use std::convert::TryInto;
-use std::io;
-#[cfg(unix)]
-use system_interface::fs::GetSetFdFlags;
-use system_interface::io::IoExt;
-use system_interface::io::IsReadWrite;
-use system_interface::io::ReadReady;
-use wasi_common::{
-    file::{FdFlags, FileType, RiFlags, RoFlags, SdFlags, SiFlags, WasiFile},
-    Error, ErrorExt,
-};
-
-pub enum Socket {
-    TcpListener(cap_std::net::TcpListener),
-    TcpStream(cap_std::net::TcpStream),
-    #[cfg(unix)]
-    UnixStream(cap_std::os::unix::net::UnixStream),
-    #[cfg(unix)]
-    UnixListener(cap_std::os::unix::net::UnixListener),
-}
-
-impl From<cap_std::net::TcpListener> for Socket {
-    fn from(listener: cap_std::net::TcpListener) -> Self {
-        Self::TcpListener(listener)
-    }
-}
-
-impl From<cap_std::net::TcpStream> for Socket {
-    fn from(stream: cap_std::net::TcpStream) -> Self {
-        Self::TcpStream(stream)
-    }
-}
-
-#[cfg(unix)]
-impl From<cap_std::os::unix::net::UnixListener> for Socket {
-    fn from(listener: cap_std::os::unix::net::UnixListener) -> Self {
-        Self::UnixListener(listener)
-    }
-}
-
-#[cfg(unix)]
-impl From<cap_std::os::unix::net::UnixStream> for Socket {
-    fn from(stream: cap_std::os::unix::net::UnixStream) -> Self {
-        Self::UnixStream(stream)
-    }
-}
-
-#[cfg(unix)]
-impl From<Socket> for Box<dyn WasiFile> {
-    fn from(listener: Socket) -> Self {
-        match listener {
-            Socket::TcpListener(l) => Box::new(crate::net::TcpListener::from_cap_std(l)),
-            Socket::UnixListener(l) => Box::new(crate::net::UnixListener::from_cap_std(l)),
-            Socket::TcpStream(l) => Box::new(crate::net::TcpStream::from_cap_std(l)),
-            Socket::UnixStream(l) => Box::new(crate::net::UnixStream::from_cap_std(l)),
-        }
-    }
-}
-
-#[cfg(windows)]
-impl From<Socket> for Box<dyn WasiFile> {
-    fn from(listener: Socket) -> Self {
-        match listener {
-            Socket::TcpListener(l) => Box::new(crate::net::TcpListener::from_cap_std(l)),
-            Socket::TcpStream(l) => Box::new(crate::net::TcpStream::from_cap_std(l)),
-        }
-    }
-}
-
-macro_rules! wasi_listen_write_impl {
-    ($ty:ty, $stream:ty) => {
-        #[async_trait::async_trait]
-        impl WasiFile for $ty {
-            fn as_any(&self) -> &dyn Any {
-                self
-            }
-            #[cfg(unix)]
-            fn pollable(&self) -> Option<rustix::fd::BorrowedFd> {
-                Some(self.0.as_fd())
-            }
-            #[cfg(windows)]
-            fn pollable(&self) -> Option<io_extras::os::windows::RawHandleOrSocket> {
-                Some(self.0.as_raw_handle_or_socket())
-            }
-            async fn sock_accept(&self, fdflags: FdFlags) -> Result<Box<dyn WasiFile>, Error> {
-                let (stream, _) = self.0.accept()?;
-                let mut stream = <$stream>::from_cap_std(stream);
-                stream.set_fdflags(fdflags).await?;
-                Ok(Box::new(stream))
-            }
-            async fn get_filetype(&self) -> Result<FileType, Error> {
-                Ok(FileType::SocketStream)
-            }
-            #[cfg(unix)]
-            async fn get_fdflags(&self) -> Result<FdFlags, Error> {
-                let fdflags = get_fd_flags(&self.0)?;
-                Ok(fdflags)
-            }
-            async fn set_fdflags(&mut self, fdflags: FdFlags) -> Result<(), Error> {
-                if fdflags == wasi_common::file::FdFlags::NONBLOCK {
-                    self.0.set_nonblocking(true)?;
-                } else if fdflags.is_empty() {
-                    self.0.set_nonblocking(false)?;
-                } else {
-                    return Err(
-                        Error::invalid_argument().context("cannot set anything else than NONBLOCK")
-                    );
-                }
-                Ok(())
-            }
-            fn num_ready_bytes(&self) -> Result<u64, Error> {
-                Ok(1)
-            }
-        }
-
-        #[cfg(windows)]
-        impl AsSocket for $ty {
-            #[inline]
-            fn as_socket(&self) -> BorrowedSocket<'_> {
-                self.0.as_socket()
-            }
-        }
-
-        #[cfg(windows)]
-        impl AsRawHandleOrSocket for $ty {
-            #[inline]
-            fn as_raw_handle_or_socket(&self) -> RawHandleOrSocket {
-                self.0.as_raw_handle_or_socket()
-            }
-        }
-
-        #[cfg(unix)]
-        impl AsFd for $ty {
-            fn as_fd(&self) -> BorrowedFd<'_> {
-                self.0.as_fd()
-            }
-        }
-    };
-}
-
-pub struct TcpListener(cap_std::net::TcpListener);
-
-impl TcpListener {
-    pub fn from_cap_std(cap_std: cap_std::net::TcpListener) -> Self {
-        TcpListener(cap_std)
-    }
-}
-wasi_listen_write_impl!(TcpListener, TcpStream);
-
-#[cfg(unix)]
-pub struct UnixListener(cap_std::os::unix::net::UnixListener);
-
-#[cfg(unix)]
-impl UnixListener {
-    pub fn from_cap_std(cap_std: cap_std::os::unix::net::UnixListener) -> Self {
-        UnixListener(cap_std)
-    }
-}
-
-#[cfg(unix)]
-wasi_listen_write_impl!(UnixListener, UnixStream);
-
-macro_rules! wasi_stream_write_impl {
-    ($ty:ty, $std_ty:ty) => {
-        #[async_trait::async_trait]
-        impl WasiFile for $ty {
-            fn as_any(&self) -> &dyn Any {
-                self
-            }
-            #[cfg(unix)]
-            fn pollable(&self) -> Option<rustix::fd::BorrowedFd> {
-                Some(self.0.as_fd())
-            }
-            #[cfg(windows)]
-            fn pollable(&self) -> Option<io_extras::os::windows::RawHandleOrSocket> {
-                Some(self.0.as_raw_handle_or_socket())
-            }
-            async fn get_filetype(&self) -> Result<FileType, Error> {
-                Ok(FileType::SocketStream)
-            }
-            #[cfg(unix)]
-            async fn get_fdflags(&self) -> Result<FdFlags, Error> {
-                let fdflags = get_fd_flags(&self.0)?;
-                Ok(fdflags)
-            }
-            async fn set_fdflags(&mut self, fdflags: FdFlags) -> Result<(), Error> {
-                if fdflags == wasi_common::file::FdFlags::NONBLOCK {
-                    self.0.set_nonblocking(true)?;
-                } else if fdflags.is_empty() {
-                    self.0.set_nonblocking(false)?;
-                } else {
-                    return Err(
-                        Error::invalid_argument().context("cannot set anything else than NONBLOCK")
-                    );
-                }
-                Ok(())
-            }
-            async fn read_vectored<'a>(
-                &self,
-                bufs: &mut [io::IoSliceMut<'a>],
-            ) -> Result<u64, Error> {
-                use std::io::Read;
-                let n = Read::read_vectored(&mut &*self.as_socketlike_view::<$std_ty>(), bufs)?;
-                Ok(n.try_into()?)
-            }
-            async fn write_vectored<'a>(&self, bufs: &[io::IoSlice<'a>]) -> Result<u64, Error> {
-                use std::io::Write;
-                let n = Write::write_vectored(&mut &*self.as_socketlike_view::<$std_ty>(), bufs)?;
-                Ok(n.try_into()?)
-            }
-            async fn peek(&self, buf: &mut [u8]) -> Result<u64, Error> {
-                let n = self.0.peek(buf)?;
-                Ok(n.try_into()?)
-            }
-            fn num_ready_bytes(&self) -> Result<u64, Error> {
-                let val = self.as_socketlike_view::<$std_ty>().num_ready_bytes()?;
-                Ok(val)
-            }
-            async fn readable(&self) -> Result<(), Error> {
-                let (readable, _writeable) = is_read_write(&self.0)?;
-                if readable {
-                    Ok(())
-                } else {
-                    Err(Error::io())
-                }
-            }
-            async fn writable(&self) -> Result<(), Error> {
-                let (_readable, writeable) = is_read_write(&self.0)?;
-                if writeable {
-                    Ok(())
-                } else {
-                    Err(Error::io())
-                }
-            }
-
-            async fn sock_recv<'a>(
-                &self,
-                ri_data: &mut [std::io::IoSliceMut<'a>],
-                ri_flags: RiFlags,
-            ) -> Result<(u64, RoFlags), Error> {
-                if (ri_flags & !(RiFlags::RECV_PEEK | RiFlags::RECV_WAITALL)) != RiFlags::empty() {
-                    return Err(Error::not_supported());
-                }
-
-                if ri_flags.contains(RiFlags::RECV_PEEK) {
-                    if let Some(first) = ri_data.iter_mut().next() {
-                        let n = self.0.peek(first)?;
-                        return Ok((n as u64, RoFlags::empty()));
-                    } else {
-                        return Ok((0, RoFlags::empty()));
-                    }
-                }
-
-                if ri_flags.contains(RiFlags::RECV_WAITALL) {
-                    let n: usize = ri_data.iter().map(|buf| buf.len()).sum();
-                    self.0.read_exact_vectored(ri_data)?;
-                    return Ok((n as u64, RoFlags::empty()));
-                }
-
-                let n = self.0.read_vectored(ri_data)?;
-                Ok((n as u64, RoFlags::empty()))
-            }
-
-            async fn sock_send<'a>(
-                &self,
-                si_data: &[std::io::IoSlice<'a>],
-                si_flags: SiFlags,
-            ) -> Result<u64, Error> {
-                if si_flags != SiFlags::empty() {
-                    return Err(Error::not_supported());
-                }
-
-                let n = self.0.write_vectored(si_data)?;
-                Ok(n as u64)
-            }
-
-            async fn sock_shutdown(&self, how: SdFlags) -> Result<(), Error> {
-                let how = if how == SdFlags::RD | SdFlags::WR {
-                    cap_std::net::Shutdown::Both
-                } else if how == SdFlags::RD {
-                    cap_std::net::Shutdown::Read
-                } else if how == SdFlags::WR {
-                    cap_std::net::Shutdown::Write
-                } else {
-                    return Err(Error::invalid_argument());
-                };
-                self.0.shutdown(how)?;
-                Ok(())
-            }
-        }
-        #[cfg(unix)]
-        impl AsFd for $ty {
-            fn as_fd(&self) -> BorrowedFd<'_> {
-                self.0.as_fd()
-            }
-        }
-
-        #[cfg(windows)]
-        impl AsSocket for $ty {
-            /// Borrows the socket.
-            fn as_socket(&self) -> BorrowedSocket<'_> {
-                self.0.as_socket()
-            }
-        }
-
-        #[cfg(windows)]
-        impl AsRawHandleOrSocket for TcpStream {
-            #[inline]
-            fn as_raw_handle_or_socket(&self) -> RawHandleOrSocket {
-                self.0.as_raw_handle_or_socket()
-            }
-        }
-    };
-}
-
-pub struct TcpStream(cap_std::net::TcpStream);
-
-impl TcpStream {
-    pub fn from_cap_std(socket: cap_std::net::TcpStream) -> Self {
-        TcpStream(socket)
-    }
-}
-
-wasi_stream_write_impl!(TcpStream, std::net::TcpStream);
-
-#[cfg(unix)]
-pub struct UnixStream(cap_std::os::unix::net::UnixStream);
-
-#[cfg(unix)]
-impl UnixStream {
-    pub fn from_cap_std(socket: cap_std::os::unix::net::UnixStream) -> Self {
-        UnixStream(socket)
-    }
-}
-
-#[cfg(unix)]
-wasi_stream_write_impl!(UnixStream, std::os::unix::net::UnixStream);
-
-pub fn filetype_from(ft: &cap_std::fs::FileType) -> FileType {
-    use cap_fs_ext::FileTypeExt;
-    if ft.is_block_device() {
-        FileType::SocketDgram
-    } else {
-        FileType::SocketStream
-    }
-}
-
-/// Return the file-descriptor flags for a given file-like object.
-///
-/// This returns the flags needed to implement [`WasiFile::get_fdflags`].
-pub fn get_fd_flags<Socketlike: AsSocketlike>(
-    f: Socketlike,
-) -> io::Result<wasi_common::file::FdFlags> {
-    // On Unix-family platforms, we can use the same system call that we'd use
-    // for files on sockets here.
-    #[cfg(not(windows))]
-    {
-        let mut out = wasi_common::file::FdFlags::empty();
-        if f.get_fd_flags()?
-            .contains(system_interface::fs::FdFlags::NONBLOCK)
-        {
-            out |= wasi_common::file::FdFlags::NONBLOCK;
-        }
-        Ok(out)
-    }
-
-    // On Windows, sockets are different, and there is no direct way to
-    // query for the non-blocking flag. We can get a sufficient approximation
-    // by testing whether a zero-length `recv` appears to block.
-    #[cfg(windows)]
-    match rustix::net::recv(f, &mut [], rustix::net::RecvFlags::empty()) {
-        Ok(_) => Ok(wasi_common::file::FdFlags::empty()),
-        Err(rustix::io::Errno::WOULDBLOCK) => Ok(wasi_common::file::FdFlags::NONBLOCK),
-        Err(e) => Err(e.into()),
-    }
-}
-
-/// Return the file-descriptor flags for a given file-like object.
-///
-/// This returns the flags needed to implement [`WasiFile::get_fdflags`].
-pub fn is_read_write<Socketlike: AsSocketlike>(f: Socketlike) -> io::Result<(bool, bool)> {
-    // On Unix-family platforms, we have an `IsReadWrite` impl.
-    #[cfg(not(windows))]
-    {
-        f.is_read_write()
-    }
-
-    // On Windows, we only have a `TcpStream` impl, so make a view first.
-    #[cfg(windows)]
-    {
-        f.as_socketlike_view::<std::net::TcpStream>()
-            .is_read_write()
-    }
-}
diff --git a/crates/wasi-common/cap-std-sync/src/sched.rs b/crates/wasi-common/cap-std-sync/src/sched.rs
deleted file mode 100644
index df8622f07d8b..000000000000
--- a/crates/wasi-common/cap-std-sync/src/sched.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-#[cfg(unix)]
-pub mod unix;
-#[cfg(unix)]
-pub use unix::poll_oneoff;
-
-#[cfg(windows)]
-pub mod windows;
-#[cfg(windows)]
-pub use windows::poll_oneoff;
-
-use std::thread;
-use std::time::Duration;
-use wasi_common::{
-    sched::{Poll, WasiSched},
-    Error,
-};
-
-pub struct SyncSched {}
-impl SyncSched {
-    pub fn new() -> Self {
-        Self {}
-    }
-}
-#[async_trait::async_trait]
-impl WasiSched for SyncSched {
-    async fn poll_oneoff<'a>(&self, poll: &mut Poll<'a>) -> Result<(), Error> {
-        poll_oneoff(poll).await
-    }
-    async fn sched_yield(&self) -> Result<(), Error> {
-        thread::yield_now();
-        Ok(())
-    }
-    async fn sleep(&self, duration: Duration) -> Result<(), Error> {
-        std::thread::sleep(duration);
-        Ok(())
-    }
-}
-pub fn sched_ctx() -> Box<dyn WasiSched> {
-    Box::new(SyncSched::new())
-}
diff --git a/crates/wasi-common/cap-std-sync/src/sched/unix.rs b/crates/wasi-common/cap-std-sync/src/sched/unix.rs
deleted file mode 100644
index 77176a7e272b..000000000000
--- a/crates/wasi-common/cap-std-sync/src/sched/unix.rs
+++ /dev/null
@@ -1,82 +0,0 @@
-use cap_std::time::Duration;
-use rustix::event::{PollFd, PollFlags};
-use std::convert::TryInto;
-use wasi_common::sched::subscription::{RwEventFlags, Subscription};
-use wasi_common::{sched::Poll, Error, ErrorExt};
-
-pub async fn poll_oneoff<'a>(poll: &mut Poll<'a>) -> Result<(), Error> {
-    if poll.is_empty() {
-        return Ok(());
-    }
-    let mut pollfds = Vec::new();
-    for s in poll.rw_subscriptions() {
-        match s {
-            Subscription::Read(f) => {
-                let fd = f
-                    .file
-                    .pollable()
-                    .ok_or(Error::invalid_argument().context("file is not pollable"))?;
-                pollfds.push(PollFd::from_borrowed_fd(fd, PollFlags::IN));
-            }
-
-            Subscription::Write(f) => {
-                let fd = f
-                    .file
-                    .pollable()
-                    .ok_or(Error::invalid_argument().context("file is not pollable"))?;
-                pollfds.push(PollFd::from_borrowed_fd(fd, PollFlags::OUT));
-            }
-            Subscription::MonotonicClock { .. } => unreachable!(),
-        }
-    }
-
-    let ready = loop {
-        let poll_timeout = if let Some(t) = poll.earliest_clock_deadline() {
-            let duration = t.duration_until().unwrap_or(Duration::from_secs(0));
-            (duration.as_millis() + 1) // XXX try always rounding up?
-                .try_into()
-                .map_err(|_| Error::overflow().context("poll timeout"))?
-        } else {
-            std::os::raw::c_int::max_value()
-        };
-        tracing::debug!(
-            poll_timeout = tracing::field::debug(poll_timeout),
-            poll_fds = tracing::field::debug(&pollfds),
-            "poll"
-        );
-        match rustix::event::poll(&mut pollfds, poll_timeout) {
-            Ok(ready) => break ready,
-            Err(rustix::io::Errno::INTR) => continue,
-            Err(err) => return Err(std::io::Error::from(err).into()),
-        }
-    };
-    if ready > 0 {
-        for (rwsub, pollfd) in poll.rw_subscriptions().zip(pollfds.into_iter()) {
-            let revents = pollfd.revents();
-            let (nbytes, rwsub) = match rwsub {
-                Subscription::Read(sub) => {
-                    let ready = sub.file.num_ready_bytes()?;
-                    (std::cmp::max(ready, 1), sub)
-                }
-                Subscription::Write(sub) => (0, sub),
-                _ => unreachable!(),
-            };
-            if revents.contains(PollFlags::NVAL) {
-                rwsub.error(Error::badf());
-            } else if revents.contains(PollFlags::ERR) {
-                rwsub.error(Error::io());
-            } else if revents.contains(PollFlags::HUP) {
-                rwsub.complete(nbytes, RwEventFlags::HANGUP);
-            } else {
-                rwsub.complete(nbytes, RwEventFlags::empty());
-            };
-        }
-    } else {
-        poll.earliest_clock_deadline()
-            .expect("timed out")
-            .result()
-            .expect("timer deadline is past")
-            .unwrap()
-    }
-    Ok(())
-}
diff --git a/crates/wasi-common/cap-std-sync/src/sched/windows.rs b/crates/wasi-common/cap-std-sync/src/sched/windows.rs
deleted file mode 100644
index e3eeb930523e..000000000000
--- a/crates/wasi-common/cap-std-sync/src/sched/windows.rs
+++ /dev/null
@@ -1,222 +0,0 @@
-// The windows scheduler is unmaintained and due for a rewrite.
-//
-// Rather than use a polling mechanism for file read/write readiness,
-// it checks readiness just once, before sleeping for any timer subscriptions.
-// Checking stdin readiness uses a worker thread which, once started, lives for the
-// lifetime of the process.
-//
-// We suspect there are bugs in this scheduler, however, we have not
-// taken the time to improve it. See bug #2880.
-
-use once_cell::sync::Lazy;
-use std::ops::Deref;
-use std::sync::mpsc::{self, Receiver, RecvTimeoutError, Sender, TryRecvError};
-use std::sync::Mutex;
-use std::thread;
-use std::time::Duration;
-use wasi_common::sched::subscription::{RwEventFlags, Subscription};
-use wasi_common::{file::WasiFile, sched::Poll, Error, ErrorExt};
-
-pub async fn poll_oneoff<'a>(poll: &mut Poll<'a>) -> Result<(), Error> {
-    poll_oneoff_(poll, wasi_file_is_stdin).await
-}
-
-pub async fn poll_oneoff_<'a>(
-    poll: &mut Poll<'a>,
-    file_is_stdin: impl Fn(&dyn WasiFile) -> bool,
-) -> Result<(), Error> {
-    if poll.is_empty() {
-        return Ok(());
-    }
-
-    let mut ready = false;
-    let waitmode = if let Some(t) = poll.earliest_clock_deadline() {
-        if let Some(duration) = t.duration_until() {
-            WaitMode::Timeout(duration)
-        } else {
-            WaitMode::Immediate
-        }
-    } else {
-        if ready {
-            WaitMode::Immediate
-        } else {
-            WaitMode::Infinite
-        }
-    };
-
-    let mut stdin_read_subs = Vec::new();
-    let mut immediate_reads = Vec::new();
-    let mut immediate_writes = Vec::new();
-    for s in poll.rw_subscriptions() {
-        match s {
-            Subscription::Read(r) => {
-                if file_is_stdin(r.file.deref()) {
-                    stdin_read_subs.push(r);
-                } else if r.file.pollable().is_some() {
-                    immediate_reads.push(r);
-                } else {
-                    return Err(Error::invalid_argument().context("file is not pollable"));
-                }
-            }
-            Subscription::Write(w) => {
-                if w.file.pollable().is_some() {
-                    immediate_writes.push(w);
-                } else {
-                    return Err(Error::invalid_argument().context("file is not pollable"));
-                }
-            }
-            Subscription::MonotonicClock { .. } => unreachable!(),
-        }
-    }
-
-    if !stdin_read_subs.is_empty() {
-        let state = STDIN_POLL
-            .lock()
-            .map_err(|_| Error::trap(anyhow::Error::msg("failed to take lock of STDIN_POLL")))?
-            .poll(waitmode)?;
-        for readsub in stdin_read_subs.into_iter() {
-            match state {
-                PollState::Ready => {
-                    readsub.complete(1, RwEventFlags::empty());
-                    ready = true;
-                }
-                PollState::NotReady | PollState::TimedOut => {}
-                PollState::Error(ref e) => {
-                    // Unfortunately, we need to deliver the Error to each of the
-                    // subscriptions, but there is no Clone on std::io::Error. So, we convert it to the
-                    // kind, and then back to std::io::Error, and finally to anyhow::Error.
-                    // When its time to turn this into an errno elsewhere, the error kind will
-                    // be inspected.
-                    let ekind = e.kind();
-                    let ioerror = std::io::Error::from(ekind);
-                    readsub.error(ioerror.into());
-                    ready = true;
-                }
-            }
-        }
-    }
-    for r in immediate_reads {
-        match r.file.num_ready_bytes() {
-            Ok(ready_bytes) => {
-                r.complete(ready_bytes, RwEventFlags::empty());
-                ready = true;
-            }
-            Err(e) => {
-                r.error(e);
-                ready = true;
-            }
-        }
-    }
-    for w in immediate_writes {
-        // Everything is always ready for writing, apparently?
-        w.complete(0, RwEventFlags::empty());
-        ready = true;
-    }
-
-    if !ready {
-        if let WaitMode::Timeout(duration) = waitmode {
-            thread::sleep(duration);
-        }
-    }
-
-    Ok(())
-}
-
-pub fn wasi_file_is_stdin(f: &dyn WasiFile) -> bool {
-    f.as_any().is::<crate::stdio::Stdin>()
-}
-
-enum PollState {
-    Ready,
-    NotReady, // Not ready, but did not wait
-    TimedOut, // Not ready, waited until timeout
-    Error(std::io::Error),
-}
-
-#[derive(Copy, Clone)]
-enum WaitMode {
-    Timeout(Duration),
-    Infinite,
-    Immediate,
-}
-
-struct StdinPoll {
-    request_tx: Sender<()>,
-    notify_rx: Receiver<PollState>,
-}
-
-static STDIN_POLL: Lazy<Mutex<StdinPoll>> = Lazy::new(StdinPoll::new);
-
-impl StdinPoll {
-    pub fn new() -> Mutex<Self> {
-        let (request_tx, request_rx) = mpsc::channel();
-        let (notify_tx, notify_rx) = mpsc::channel();
-        thread::spawn(move || Self::event_loop(request_rx, notify_tx));
-        Mutex::new(StdinPoll {
-            request_tx,
-            notify_rx,
-        })
-    }
-
-    // This function should not be used directly.
-    // Correctness of this function crucially depends on the fact that
-    // mpsc::Receiver is !Sync.
-    fn poll(&self, wait_mode: WaitMode) -> Result<PollState, Error> {
-        match self.notify_rx.try_recv() {
-            // Clean up possibly unread result from previous poll.
-            Ok(_) | Err(TryRecvError::Empty) => {}
-            Err(TryRecvError::Disconnected) => {
-                return Err(Error::trap(anyhow::Error::msg(
-                    "StdinPoll notify_rx channel closed",
-                )))
-            }
-        }
-
-        // Notify the worker thread to poll stdin
-        self.request_tx
-            .send(())
-            .map_err(|_| Error::trap(anyhow::Error::msg("request_tx channel closed")))?;
-
-        // Wait for the worker thread to send a readiness notification
-        match wait_mode {
-            WaitMode::Timeout(timeout) => match self.notify_rx.recv_timeout(timeout) {
-                Ok(r) => Ok(r),
-                Err(RecvTimeoutError::Timeout) => Ok(PollState::TimedOut),
-                Err(RecvTimeoutError::Disconnected) => Err(Error::trap(anyhow::Error::msg(
-                    "StdinPoll notify_rx channel closed",
-                ))),
-            },
-            WaitMode::Infinite => self
-                .notify_rx
-                .recv()
-                .map_err(|_| Error::trap(anyhow::Error::msg("StdinPoll notify_rx channel closed"))),
-            WaitMode::Immediate => match self.notify_rx.try_recv() {
-                Ok(r) => Ok(r),
-                Err(TryRecvError::Empty) => Ok(PollState::NotReady),
-                Err(TryRecvError::Disconnected) => Err(Error::trap(anyhow::Error::msg(
-                    "StdinPoll notify_rx channel closed",
-                ))),
-            },
-        }
-    }
-
-    fn event_loop(request_rx: Receiver<()>, notify_tx: Sender<PollState>) -> ! {
-        use std::io::BufRead;
-        loop {
-            // Wait on a request:
-            request_rx.recv().expect("request_rx channel");
-            // Wait for data to appear in stdin. If fill_buf returns any slice, it means
-            // that either:
-            // (a) there is some data in stdin, if non-empty,
-            // (b) EOF was recieved, if its empty
-            // Linux returns `POLLIN` in both cases, so we imitate this behavior.
-            let resp = match std::io::stdin().lock().fill_buf() {
-                Ok(_) => PollState::Ready,
-                Err(e) => PollState::Error(e),
-            };
-            // Notify about data in stdin. If the read on this channel has timed out, the
-            // next poller will have to clean the channel.
-            notify_tx.send(resp).expect("notify_tx channel");
-        }
-    }
-}
diff --git a/crates/wasi-common/cap-std-sync/src/stdio.rs b/crates/wasi-common/cap-std-sync/src/stdio.rs
deleted file mode 100644
index b2723d076c98..000000000000
--- a/crates/wasi-common/cap-std-sync/src/stdio.rs
+++ /dev/null
@@ -1,192 +0,0 @@
-use crate::file::convert_systimespec;
-use fs_set_times::SetTimes;
-use std::any::Any;
-use std::convert::TryInto;
-use std::io::{self, IsTerminal, Read, Write};
-use system_interface::io::ReadReady;
-
-#[cfg(windows)]
-use io_extras::os::windows::{AsRawHandleOrSocket, RawHandleOrSocket};
-#[cfg(unix)]
-use io_lifetimes::{AsFd, BorrowedFd};
-#[cfg(windows)]
-use io_lifetimes::{AsHandle, BorrowedHandle};
-use wasi_common::{
-    file::{FdFlags, FileType, WasiFile},
-    Error, ErrorExt,
-};
-
-pub struct Stdin(std::io::Stdin);
-
-pub fn stdin() -> Stdin {
-    Stdin(std::io::stdin())
-}
-
-#[async_trait::async_trait]
-impl WasiFile for Stdin {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    #[cfg(unix)]
-    fn pollable(&self) -> Option<rustix::fd::BorrowedFd> {
-        Some(self.0.as_fd())
-    }
-
-    #[cfg(windows)]
-    fn pollable(&self) -> Option<io_extras::os::windows::RawHandleOrSocket> {
-        Some(self.0.as_raw_handle_or_socket())
-    }
-
-    async fn get_filetype(&self) -> Result<FileType, Error> {
-        if self.isatty() {
-            Ok(FileType::CharacterDevice)
-        } else {
-            Ok(FileType::Unknown)
-        }
-    }
-    async fn read_vectored<'a>(&self, bufs: &mut [io::IoSliceMut<'a>]) -> Result<u64, Error> {
-        let n = self.0.lock().read_vectored(bufs)?;
-        Ok(n.try_into().map_err(|_| Error::range())?)
-    }
-    async fn read_vectored_at<'a>(
-        &self,
-        _bufs: &mut [io::IoSliceMut<'a>],
-        _offset: u64,
-    ) -> Result<u64, Error> {
-        Err(Error::seek_pipe())
-    }
-    async fn seek(&self, _pos: std::io::SeekFrom) -> Result<u64, Error> {
-        Err(Error::seek_pipe())
-    }
-    async fn peek(&self, _buf: &mut [u8]) -> Result<u64, Error> {
-        Err(Error::seek_pipe())
-    }
-    async fn set_times(
-        &self,
-        atime: Option<wasi_common::SystemTimeSpec>,
-        mtime: Option<wasi_common::SystemTimeSpec>,
-    ) -> Result<(), Error> {
-        self.0
-            .set_times(convert_systimespec(atime), convert_systimespec(mtime))?;
-        Ok(())
-    }
-    fn num_ready_bytes(&self) -> Result<u64, Error> {
-        Ok(self.0.num_ready_bytes()?)
-    }
-    fn isatty(&self) -> bool {
-        #[cfg(unix)]
-        return self.0.as_fd().is_terminal();
-        #[cfg(windows)]
-        return self.0.as_handle().is_terminal();
-    }
-}
-#[cfg(windows)]
-impl AsHandle for Stdin {
-    fn as_handle(&self) -> BorrowedHandle<'_> {
-        self.0.as_handle()
-    }
-}
-#[cfg(windows)]
-impl AsRawHandleOrSocket for Stdin {
-    #[inline]
-    fn as_raw_handle_or_socket(&self) -> RawHandleOrSocket {
-        self.0.as_raw_handle_or_socket()
-    }
-}
-#[cfg(unix)]
-impl AsFd for Stdin {
-    fn as_fd(&self) -> BorrowedFd<'_> {
-        self.0.as_fd()
-    }
-}
-
-macro_rules! wasi_file_write_impl {
-    ($ty:ty, $ident:ident) => {
-        #[async_trait::async_trait]
-        impl WasiFile for $ty {
-            fn as_any(&self) -> &dyn Any {
-                self
-            }
-            #[cfg(unix)]
-            fn pollable(&self) -> Option<rustix::fd::BorrowedFd> {
-                Some(self.0.as_fd())
-            }
-            #[cfg(windows)]
-            fn pollable(&self) -> Option<io_extras::os::windows::RawHandleOrSocket> {
-                Some(self.0.as_raw_handle_or_socket())
-            }
-            async fn get_filetype(&self) -> Result<FileType, Error> {
-                if self.isatty() {
-                    Ok(FileType::CharacterDevice)
-                } else {
-                    Ok(FileType::Unknown)
-                }
-            }
-            async fn get_fdflags(&self) -> Result<FdFlags, Error> {
-                Ok(FdFlags::APPEND)
-            }
-            async fn write_vectored<'a>(&self, bufs: &[io::IoSlice<'a>]) -> Result<u64, Error> {
-                let n = self.0.lock().write_vectored(bufs)?;
-                Ok(n.try_into().map_err(|_| {
-                    Error::range().context("converting write_vectored total length")
-                })?)
-            }
-            async fn write_vectored_at<'a>(
-                &self,
-                _bufs: &[io::IoSlice<'a>],
-                _offset: u64,
-            ) -> Result<u64, Error> {
-                Err(Error::seek_pipe())
-            }
-            async fn seek(&self, _pos: std::io::SeekFrom) -> Result<u64, Error> {
-                Err(Error::seek_pipe())
-            }
-            async fn set_times(
-                &self,
-                atime: Option<wasi_common::SystemTimeSpec>,
-                mtime: Option<wasi_common::SystemTimeSpec>,
-            ) -> Result<(), Error> {
-                self.0
-                    .set_times(convert_systimespec(atime), convert_systimespec(mtime))?;
-                Ok(())
-            }
-            fn isatty(&self) -> bool {
-                self.0.is_terminal()
-            }
-        }
-        #[cfg(windows)]
-        impl AsHandle for $ty {
-            fn as_handle(&self) -> BorrowedHandle<'_> {
-                self.0.as_handle()
-            }
-        }
-        #[cfg(unix)]
-        impl AsFd for $ty {
-            fn as_fd(&self) -> BorrowedFd<'_> {
-                self.0.as_fd()
-            }
-        }
-        #[cfg(windows)]
-        impl AsRawHandleOrSocket for $ty {
-            #[inline]
-            fn as_raw_handle_or_socket(&self) -> RawHandleOrSocket {
-                self.0.as_raw_handle_or_socket()
-            }
-        }
-    };
-}
-
-pub struct Stdout(std::io::Stdout);
-
-pub fn stdout() -> Stdout {
-    Stdout(std::io::stdout())
-}
-wasi_file_write_impl!(Stdout, Stdout);
-
-pub struct Stderr(std::io::Stderr);
-
-pub fn stderr() -> Stderr {
-    Stderr(std::io::stderr())
-}
-wasi_file_write_impl!(Stderr, Stderr);
diff --git a/crates/wasi-common/src/ctx.rs b/crates/wasi-common/src/ctx.rs
index 0d8d495dcfda..1c1ab361bd5b 100644
--- a/crates/wasi-common/src/ctx.rs
+++ b/crates/wasi-common/src/ctx.rs
@@ -14,7 +14,7 @@ use std::sync::{Arc, Mutex};
 /// the file descriptor table. This wrapper is only necessary due to the
 /// signature of `fd_fdstat_set_flags`; if that changes, there are a variety of
 /// improvements that can be made (TODO:
-/// https://github.com/bytecodealliance/wasmtime/issues/5643).
+/// <https://github.com/bytecodealliance/wasmtime/issues/5643)>.
 #[derive(Clone)]
 pub struct WasiCtx(Arc<WasiCtxInner>);
 
@@ -93,7 +93,7 @@ impl WasiCtx {
         let s = Arc::get_mut(&mut self.0).expect(
             "`push_env` should only be used during initialization before the context is cloned",
         );
-        s.env.push(format!("{}={}", var, value))?;
+        s.env.push(format!("{var}={value}"))?;
         Ok(())
     }
 
diff --git a/crates/wasi-common/src/error.rs b/crates/wasi-common/src/error.rs
index b1a5135bb2b0..11b43ecd4952 100644
--- a/crates/wasi-common/src/error.rs
+++ b/crates/wasi-common/src/error.rs
@@ -7,7 +7,7 @@
 //! can be provided with the [`Error::context`] method. This context is only observable with the
 //! `Display` and `Debug` impls of the error.
 
-pub use crate::snapshots::preview_1::error::{Errno, Error, ErrorExt};
+pub use crate::snapshots::preview_1::error::{Error, ErrorExt};
 use std::fmt;
 
 /// An error returned from the `proc_exit` host syscall.
diff --git a/crates/wasi-common/src/lib.rs b/crates/wasi-common/src/lib.rs
index b6da9c1f984a..9d4d4d82d573 100644
--- a/crates/wasi-common/src/lib.rs
+++ b/crates/wasi-common/src/lib.rs
@@ -1,3 +1,15 @@
+//! # wasi-common
+//!
+//! This is Wasmtime's legacy implementation of WASI 0.1 (Preview 1). The
+//! Wasmtime maintainers suggest all users upgrade to the implementation
+//! of WASI 0.1 and 0.2 provided by the `wasmtime-wasi` crate. This
+//! implementation remains in the wasmtime tree because it is required to use
+//! the `wasmtime-wasi-threads` crate, an implementation of the `wasi-threads`
+//! proposal which is not compatible with WASI 0.2.
+//!
+//! In addition to integration with Wasmtime, this implementation may be used
+//! by other runtimes by disabling the `wasmtime` feature on this crate.
+//!
 //! ## The `WasiFile` and `WasiDir` traits
 //!
 //! The WASI specification only defines one `handle` type, `fd`, on which all
@@ -28,7 +40,11 @@
 //! reason about access to the local filesystem by examining what impls are
 //! linked into an application. We found that this separation of concerns also
 //! makes it pretty enjoyable to write alternative implementations, e.g. a
-//! virtual filesystem (which will land in a future PR).
+//! virtual filesystem.
+//!
+//! Implementations of the `WasiFile` and `WasiDir` traits are provided
+//! for synchronous embeddings (i.e. Config::async_support(false)) in
+//! `wasi_common::sync` and for Tokio embeddings in `wasi_common::tokio`.
 //!
 //! ## Traits for the rest of WASI's features
 //!
@@ -39,17 +55,21 @@
 //! get with WasiFile/WasiDir:
 //!
 //! * Timekeeping: `WasiSystemClock` and `WasiMonotonicClock` provide the two
-//! interfaces for a clock. `WasiSystemClock` represents time as a
-//! `cap_std::time::SystemTime`, and `WasiMonotonicClock` represents time as
-//! `cap_std::time::Instant`.  * Randomness: we re-use the `cap_rand::RngCore`
-//! trait to represent a randomness source. A trivial `Deterministic` impl is
-//! provided.  * Scheduling: The `WasiSched` trait abstracts over the
-//! `sched_yield` and `poll_oneoff` functions.
+//!   interfaces for a clock. `WasiSystemClock` represents time as a
+//!   `cap_std::time::SystemTime`, and `WasiMonotonicClock` represents time as
+//!   `cap_std::time::Instant`.  * Randomness: we re-use the `cap_rand::RngCore`
+//!   trait to represent a randomness source. A trivial `Deterministic` impl is
+//!   provided.  * Scheduling: The `WasiSched` trait abstracts over the
+//!   `sched_yield` and `poll_oneoff` functions.
 //!
 //! Users can provide implementations of each of these interfaces to the
 //! `WasiCtx::builder(...)` function. The
 //! `wasi_cap_std_sync::WasiCtxBuilder::new()` function uses this public
 //! interface to plug in its own implementations of each of these resources.
+
+#![warn(clippy::cast_sign_loss)]
+#![cfg_attr(docsrs, feature(doc_cfg))]
+
 pub mod clocks;
 mod ctx;
 pub mod dir;
@@ -60,7 +80,13 @@ pub mod random;
 pub mod sched;
 pub mod snapshots;
 mod string_array;
+#[cfg_attr(docsrs, doc(cfg(feature = "sync")))]
+#[cfg(feature = "sync")]
+pub mod sync;
 pub mod table;
+#[cfg_attr(docsrs, doc(cfg(feature = "tokio")))]
+#[cfg(feature = "tokio")]
+pub mod tokio;
 
 pub use cap_rand::RngCore;
 pub use clocks::{SystemTimeSpec, WasiClocks, WasiMonotonicClock, WasiSystemClock};
@@ -71,3 +97,97 @@ pub use file::WasiFile;
 pub use sched::{Poll, WasiSched};
 pub use string_array::{StringArray, StringArrayError};
 pub use table::Table;
+
+// The only difference between these definitions for sync vs async is whether
+// the wasmtime::Funcs generated are async (& therefore need an async Store and an executor to run)
+// or whether they have an internal "dummy executor" that expects the implementation of all
+// the async funcs to poll to Ready immediately.
+#[cfg(feature = "wasmtime")]
+#[doc(hidden)]
+#[macro_export]
+macro_rules! define_wasi {
+    ($async_mode:tt $($bounds:tt)*) => {
+
+    use wasmtime::Linker;
+
+    pub fn add_to_linker<T, U>(
+        linker: &mut Linker<T>,
+        get_cx: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+    ) -> anyhow::Result<()>
+        where U: Send
+                + crate::snapshots::preview_0::wasi_unstable::WasiUnstable
+                + crate::snapshots::preview_1::wasi_snapshot_preview1::WasiSnapshotPreview1,
+            $($bounds)*
+    {
+        snapshots::preview_1::add_wasi_snapshot_preview1_to_linker(linker, get_cx)?;
+        snapshots::preview_0::add_wasi_unstable_to_linker(linker, get_cx)?;
+        Ok(())
+    }
+
+    pub mod snapshots {
+        pub mod preview_1 {
+            wiggle::wasmtime_integration!({
+                // The wiggle code to integrate with lives here:
+                target: crate::snapshots::preview_1,
+                witx: ["$CARGO_MANIFEST_DIR/witx/preview1/wasi_snapshot_preview1.witx"],
+                errors: { errno => trappable Error },
+                $async_mode: *
+            });
+        }
+        pub mod preview_0 {
+            wiggle::wasmtime_integration!({
+                // The wiggle code to integrate with lives here:
+                target: crate::snapshots::preview_0,
+                witx: ["$CARGO_MANIFEST_DIR/witx/preview0/wasi_unstable.witx"],
+                errors: { errno => trappable Error },
+                $async_mode: *
+            });
+        }
+    }
+}}
+
+/// Exit the process with a conventional OS error code as long as Wasmtime
+/// understands the error. If the error is not an `I32Exit` or `Trap`, return
+/// the error back to the caller for it to decide what to do.
+///
+/// Note: this function is designed for usage where it is acceptable for
+/// Wasmtime failures to terminate the parent process, such as in the Wasmtime
+/// CLI; this would not be suitable for use in multi-tenant embeddings.
+#[cfg_attr(docsrs, doc(cfg(feature = "exit")))]
+#[cfg(feature = "exit")]
+pub fn maybe_exit_on_error(e: anyhow::Error) -> anyhow::Error {
+    use std::process;
+    use wasmtime::Trap;
+
+    // If a specific WASI error code was requested then that's
+    // forwarded through to the process here without printing any
+    // extra error information.
+    let code = e.downcast_ref::<crate::I32Exit>().map(|e| e.0);
+    if let Some(exit) = code {
+        // Print the error message in the usual way.
+        // On Windows, exit status 3 indicates an abort (see below),
+        // so return 1 indicating a non-zero status to avoid ambiguity.
+        if cfg!(windows) && exit >= 3 {
+            process::exit(1);
+        }
+        process::exit(exit);
+    }
+
+    // If the program exited because of a trap, return an error code
+    // to the outside environment indicating a more severe problem
+    // than a simple failure.
+    if e.is::<Trap>() {
+        eprintln!("Error: {e:?}");
+
+        if cfg!(unix) {
+            // On Unix, return the error code of an abort.
+            process::exit(128 + libc::SIGABRT);
+        } else if cfg!(windows) {
+            // On Windows, return 3.
+            // https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/abort?view=vs-2019
+            process::exit(3);
+        }
+    }
+
+    e
+}
diff --git a/crates/wasi-common/src/pipe.rs b/crates/wasi-common/src/pipe.rs
index 1700131bd6cc..9b282917c679 100644
--- a/crates/wasi-common/src/pipe.rs
+++ b/crates/wasi-common/src/pipe.rs
@@ -12,7 +12,6 @@
 use crate::file::{FdFlags, FileType, WasiFile};
 use crate::Error;
 use std::any::Any;
-use std::convert::TryInto;
 use std::io::{self, Read, Write};
 use std::sync::{Arc, RwLock};
 
diff --git a/crates/wasi-common/src/snapshots/mod.rs b/crates/wasi-common/src/snapshots/mod.rs
index f25c8a3b090e..a8d50a611963 100644
--- a/crates/wasi-common/src/snapshots/mod.rs
+++ b/crates/wasi-common/src/snapshots/mod.rs
@@ -9,19 +9,16 @@
 //! The architectural rules for snapshots are:
 //!
 //! * Snapshots are arranged into modules under `crate::snapshots::`.
-//!
 //! * Each snapshot should invoke `wiggle::from_witx!` with `ctx:
-//! crate::WasiCtx` in its module, and impl all of the required traits.
-//!
-//!* Snapshots can be implemented in terms of other snapshots. For example,
-//! snapshot 0 is mostly implemented by calling the snapshot 1 implementation,
-//! and converting its own types back and forth with the snapshot 1 types. In a
-//! few cases, that is not feasible, so snapshot 0 carries its own
-//! implementations in terms of the `WasiFile` and `WasiSched` traits.
-//!
+//!   crate::WasiCtx` in its module, and impl all of the required traits.
+//! * Snapshots can be implemented in terms of other snapshots. For example,
+//!   snapshot 0 is mostly implemented by calling the snapshot 1 implementation,
+//!   and converting its own types back and forth with the snapshot 1 types. In a
+//!   few cases, that is not feasible, so snapshot 0 carries its own
+//!   implementations in terms of the `WasiFile` and `WasiSched` traits.
 //! * Snapshots can be implemented in terms of the `Wasi*` traits given by
-//! `WasiCtx`. No further downcasting via the `as_any` escape hatch is
-//! permitted.
+//!   `WasiCtx`. No further downcasting via the `as_any` escape hatch is
+//!   permitted.
 
 pub mod preview_0;
 pub mod preview_1;
diff --git a/crates/wasi-common/src/snapshots/preview_0.rs b/crates/wasi-common/src/snapshots/preview_0.rs
index d84ba5f3b715..d53b49cdb99c 100644
--- a/crates/wasi-common/src/snapshots/preview_0.rs
+++ b/crates/wasi-common/src/snapshots/preview_0.rs
@@ -5,17 +5,13 @@ use crate::sched::{
 };
 use crate::snapshots::preview_1::types as snapshot1_types;
 use crate::snapshots::preview_1::wasi_snapshot_preview1::WasiSnapshotPreview1 as Snapshot1;
-use crate::snapshots::preview_1::MAX_SHARED_BUFFER_SIZE;
 use crate::{ErrorExt, WasiCtx};
 use cap_std::time::Duration;
 use std::collections::HashSet;
-use std::convert::{TryFrom, TryInto};
-use std::io::{IoSlice, IoSliceMut};
-use std::ops::Deref;
-use wiggle::GuestPtr;
+use wiggle::{GuestMemory, GuestPtr};
 
 wiggle::from_witx!({
-    witx: ["$WASI_ROOT/phases/old/snapshot_0/witx/wasi_unstable.witx"],
+    witx: ["$CARGO_MANIFEST_DIR/witx/preview0/wasi_unstable.witx"],
     errors: { errno => trappable Error },
     async: *,
     wasmtime: false,
@@ -389,100 +385,128 @@ convert_flags_bidirectional!(
 // performing the no-op type conversions along the way.
 #[wiggle::async_trait]
 impl wasi_unstable::WasiUnstable for WasiCtx {
-    async fn args_get<'a>(
+    async fn args_get(
         &mut self,
-        argv: &GuestPtr<'a, GuestPtr<'a, u8>>,
-        argv_buf: &GuestPtr<'a, u8>,
+        memory: &mut GuestMemory<'_>,
+        argv: GuestPtr<GuestPtr<u8>>,
+        argv_buf: GuestPtr<u8>,
     ) -> Result<(), Error> {
-        Snapshot1::args_get(self, argv, argv_buf).await?;
+        Snapshot1::args_get(self, memory, argv, argv_buf).await?;
         Ok(())
     }
 
-    async fn args_sizes_get(&mut self) -> Result<(types::Size, types::Size), Error> {
-        let s = Snapshot1::args_sizes_get(self).await?;
+    async fn args_sizes_get(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+    ) -> Result<(types::Size, types::Size), Error> {
+        let s = Snapshot1::args_sizes_get(self, memory).await?;
         Ok(s)
     }
 
-    async fn environ_get<'a>(
+    async fn environ_get(
         &mut self,
-        environ: &GuestPtr<'a, GuestPtr<'a, u8>>,
-        environ_buf: &GuestPtr<'a, u8>,
+        memory: &mut GuestMemory<'_>,
+        environ: GuestPtr<GuestPtr<u8>>,
+        environ_buf: GuestPtr<u8>,
     ) -> Result<(), Error> {
-        Snapshot1::environ_get(self, environ, environ_buf).await?;
+        Snapshot1::environ_get(self, memory, environ, environ_buf).await?;
         Ok(())
     }
 
-    async fn environ_sizes_get(&mut self) -> Result<(types::Size, types::Size), Error> {
-        let s = Snapshot1::environ_sizes_get(self).await?;
+    async fn environ_sizes_get(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+    ) -> Result<(types::Size, types::Size), Error> {
+        let s = Snapshot1::environ_sizes_get(self, memory).await?;
         Ok(s)
     }
 
-    async fn clock_res_get(&mut self, id: types::Clockid) -> Result<types::Timestamp, Error> {
-        let t = Snapshot1::clock_res_get(self, id.into()).await?;
+    async fn clock_res_get(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        id: types::Clockid,
+    ) -> Result<types::Timestamp, Error> {
+        let t = Snapshot1::clock_res_get(self, memory, id.into()).await?;
         Ok(t)
     }
 
     async fn clock_time_get(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         id: types::Clockid,
         precision: types::Timestamp,
     ) -> Result<types::Timestamp, Error> {
-        let t = Snapshot1::clock_time_get(self, id.into(), precision).await?;
+        let t = Snapshot1::clock_time_get(self, memory, id.into(), precision).await?;
         Ok(t)
     }
 
     async fn fd_advise(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         fd: types::Fd,
         offset: types::Filesize,
         len: types::Filesize,
         advice: types::Advice,
     ) -> Result<(), Error> {
-        Snapshot1::fd_advise(self, fd.into(), offset, len, advice.into()).await?;
+        Snapshot1::fd_advise(self, memory, fd.into(), offset, len, advice.into()).await?;
         Ok(())
     }
 
     async fn fd_allocate(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         fd: types::Fd,
         offset: types::Filesize,
         len: types::Filesize,
     ) -> Result<(), Error> {
-        Snapshot1::fd_allocate(self, fd.into(), offset, len).await?;
+        Snapshot1::fd_allocate(self, memory, fd.into(), offset, len).await?;
         Ok(())
     }
 
-    async fn fd_close(&mut self, fd: types::Fd) -> Result<(), Error> {
-        Snapshot1::fd_close(self, fd.into()).await?;
+    async fn fd_close(&mut self, memory: &mut GuestMemory<'_>, fd: types::Fd) -> Result<(), Error> {
+        Snapshot1::fd_close(self, memory, fd.into()).await?;
         Ok(())
     }
 
-    async fn fd_datasync(&mut self, fd: types::Fd) -> Result<(), Error> {
-        Snapshot1::fd_datasync(self, fd.into()).await?;
+    async fn fd_datasync(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+    ) -> Result<(), Error> {
+        Snapshot1::fd_datasync(self, memory, fd.into()).await?;
         Ok(())
     }
 
-    async fn fd_fdstat_get(&mut self, fd: types::Fd) -> Result<types::Fdstat, Error> {
-        Ok(Snapshot1::fd_fdstat_get(self, fd.into()).await?.into())
+    async fn fd_fdstat_get(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+    ) -> Result<types::Fdstat, Error> {
+        Ok(Snapshot1::fd_fdstat_get(self, memory, fd.into())
+            .await?
+            .into())
     }
 
     async fn fd_fdstat_set_flags(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         fd: types::Fd,
         flags: types::Fdflags,
     ) -> Result<(), Error> {
-        Snapshot1::fd_fdstat_set_flags(self, fd.into(), flags.into()).await?;
+        Snapshot1::fd_fdstat_set_flags(self, memory, fd.into(), flags.into()).await?;
         Ok(())
     }
 
     async fn fd_fdstat_set_rights(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         fd: types::Fd,
         fs_rights_base: types::Rights,
         fs_rights_inheriting: types::Rights,
     ) -> Result<(), Error> {
         Snapshot1::fd_fdstat_set_rights(
             self,
+            memory,
             fd.into(),
             fs_rights_base.into(),
             fs_rights_inheriting.into(),
@@ -491,314 +515,184 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
         Ok(())
     }
 
-    async fn fd_filestat_get(&mut self, fd: types::Fd) -> Result<types::Filestat, Error> {
-        Ok(Snapshot1::fd_filestat_get(self, fd.into()).await?.into())
+    async fn fd_filestat_get(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+    ) -> Result<types::Filestat, Error> {
+        Ok(Snapshot1::fd_filestat_get(self, memory, fd.into())
+            .await?
+            .into())
     }
 
     async fn fd_filestat_set_size(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         fd: types::Fd,
         size: types::Filesize,
     ) -> Result<(), Error> {
-        Snapshot1::fd_filestat_set_size(self, fd.into(), size).await?;
+        Snapshot1::fd_filestat_set_size(self, memory, fd.into(), size).await?;
         Ok(())
     }
 
     async fn fd_filestat_set_times(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         fd: types::Fd,
         atim: types::Timestamp,
         mtim: types::Timestamp,
         fst_flags: types::Fstflags,
     ) -> Result<(), Error> {
-        Snapshot1::fd_filestat_set_times(self, fd.into(), atim, mtim, fst_flags.into()).await?;
+        Snapshot1::fd_filestat_set_times(self, memory, fd.into(), atim, mtim, fst_flags.into())
+            .await?;
         Ok(())
     }
 
     // NOTE on fd_read, fd_pread, fd_write, fd_pwrite implementations:
-    // Because the arguments to these function sit behind GuestPtrs, they are not values we
-    // can convert and pass to the corresponding function in Snapshot1.
-    // Instead, we have copied the implementation of these functions from the Snapshot1 code.
-    // The implementations are identical, but the `types::` in scope locally is different.
-    // The bodies of these functions is mostly about converting the GuestPtr and types::-based
-    // representation to a std::io::IoSlice(Mut) representation.
+    // these cast their pointers from preview0 vectors to preview1 vectors and
+    // this only works because the representation didn't change between preview0
+    // and preview1.
 
-    async fn fd_read<'a>(
+    async fn fd_read(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         fd: types::Fd,
-        iovs: &types::IovecArray<'a>,
+        iovs: types::IovecArray,
     ) -> Result<types::Size, Error> {
-        let f = self.table().get_file(u32::from(fd))?;
-
-        let iovs: Vec<wiggle::GuestPtr<[u8]>> = iovs
-            .iter()
-            .map(|iov_ptr| {
-                let iov_ptr = iov_ptr?;
-                let iov: types::Iovec = iov_ptr.read()?;
-                Ok(iov.buf.as_array(iov.buf_len))
-            })
-            .collect::<Result<_, Error>>()?;
-
-        // If the first iov structure is from shared memory we can safely assume
-        // all the rest will be. We then read into memory based on the memory's
-        // shared-ness:
-        // - if not shared, we copy directly into the Wasm memory
-        // - if shared, we use an intermediate buffer; this avoids Rust unsafety
-        //   due to holding on to a `&mut [u8]` of Wasm memory when we cannot
-        //   guarantee the `&mut` exclusivity--other threads could be modifying
-        //   the data as this functions writes to it. Though likely there is no
-        //   issue with OS writing to io structs in multi-threaded scenarios,
-        //   since we do not know here if `&dyn WasiFile` does anything else
-        //   (e.g., read), we cautiously incur some performance overhead by
-        //   copying twice.
-        let is_shared_memory = iovs
-            .iter()
-            .next()
-            .and_then(|s| Some(s.is_shared_memory()))
-            .unwrap_or(false);
-        let bytes_read: u64 = if is_shared_memory {
-            // For shared memory, read into an intermediate buffer. Only the
-            // first iov will be filled and even then the read is capped by the
-            // `MAX_SHARED_BUFFER_SIZE`, so users are expected to re-call.
-            let iov = iovs.into_iter().next();
-            if let Some(iov) = iov {
-                let mut buffer = vec![0; (iov.len() as usize).min(MAX_SHARED_BUFFER_SIZE)];
-                let bytes_read = f
-                    .file
-                    .read_vectored(&mut [IoSliceMut::new(&mut buffer)])
-                    .await?;
-                iov.get_range(0..bytes_read.try_into()?)
-                    .expect("it should always be possible to slice the iov smaller")
-                    .copy_from_slice(&buffer[0..bytes_read.try_into()?])?;
-                bytes_read
-            } else {
-                return Ok(0);
-            }
-        } else {
-            // Convert all of the unsafe guest slices to safe ones--this uses
-            // Wiggle's internal borrow checker to ensure no overlaps. We assume
-            // here that, because the memory is not shared, there are no other
-            // threads to access it while it is written to.
-            let mut guest_slices: Vec<wiggle::GuestSliceMut<u8>> = iovs
-                .into_iter()
-                .map(|iov| Ok(iov.as_slice_mut()?.unwrap()))
-                .collect::<Result<_, Error>>()?;
-
-            // Read directly into the Wasm memory.
-            let mut ioslices: Vec<IoSliceMut> = guest_slices
-                .iter_mut()
-                .map(|s| IoSliceMut::new(&mut *s))
-                .collect();
-            f.file.read_vectored(&mut ioslices).await?
-        };
-
-        Ok(types::Size::try_from(bytes_read)?)
-    }
-
-    async fn fd_pread<'a>(
+        Ok(Snapshot1::fd_read(self, memory, fd.into(), iovs.cast()).await?)
+    }
+
+    async fn fd_pread(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         fd: types::Fd,
-        iovs: &types::IovecArray<'a>,
+        iovs: types::IovecArray,
         offset: types::Filesize,
     ) -> Result<types::Size, Error> {
-        let f = self.table().get_file(u32::from(fd))?;
-
-        let iovs: Vec<wiggle::GuestPtr<[u8]>> = iovs
-            .iter()
-            .map(|iov_ptr| {
-                let iov_ptr = iov_ptr?;
-                let iov: types::Iovec = iov_ptr.read()?;
-                Ok(iov.buf.as_array(iov.buf_len))
-            })
-            .collect::<Result<_, Error>>()?;
-
-        // If the first iov structure is from shared memory we can safely assume
-        // all the rest will be. We then read into memory based on the memory's
-        // shared-ness:
-        // - if not shared, we copy directly into the Wasm memory
-        // - if shared, we use an intermediate buffer; this avoids Rust unsafety
-        //   due to holding on to a `&mut [u8]` of Wasm memory when we cannot
-        //   guarantee the `&mut` exclusivity--other threads could be modifying
-        //   the data as this functions writes to it. Though likely there is no
-        //   issue with OS writing to io structs in multi-threaded scenarios,
-        //   since we do not know here if `&dyn WasiFile` does anything else
-        //   (e.g., read), we cautiously incur some performance overhead by
-        //   copying twice.
-        let is_shared_memory = iovs
-            .iter()
-            .next()
-            .and_then(|s| Some(s.is_shared_memory()))
-            .unwrap_or(false);
-        let bytes_read: u64 = if is_shared_memory {
-            // For shared memory, read into an intermediate buffer. Only the
-            // first iov will be filled and even then the read is capped by the
-            // `MAX_SHARED_BUFFER_SIZE`, so users are expected to re-call.
-            let iov = iovs.into_iter().next();
-            if let Some(iov) = iov {
-                let mut buffer = vec![0; (iov.len() as usize).min(MAX_SHARED_BUFFER_SIZE)];
-                let bytes_read = f
-                    .file
-                    .read_vectored_at(&mut [IoSliceMut::new(&mut buffer)], offset)
-                    .await?;
-                iov.get_range(0..bytes_read.try_into()?)
-                    .expect("it should always be possible to slice the iov smaller")
-                    .copy_from_slice(&buffer[0..bytes_read.try_into()?])?;
-                bytes_read
-            } else {
-                return Ok(0);
-            }
-        } else {
-            // Convert all of the unsafe guest slices to safe ones--this uses
-            // Wiggle's internal borrow checker to ensure no overlaps. We assume
-            // here that, because the memory is not shared, there are no other
-            // threads to access it while it is written to.
-            let mut guest_slices: Vec<wiggle::GuestSliceMut<u8>> = iovs
-                .into_iter()
-                .map(|iov| Ok(iov.as_slice_mut()?.unwrap()))
-                .collect::<Result<_, Error>>()?;
-
-            // Read directly into the Wasm memory.
-            let mut ioslices: Vec<IoSliceMut> = guest_slices
-                .iter_mut()
-                .map(|s| IoSliceMut::new(&mut *s))
-                .collect();
-            f.file.read_vectored_at(&mut ioslices, offset).await?
-        };
-
-        Ok(types::Size::try_from(bytes_read)?)
-    }
-
-    async fn fd_write<'a>(
+        Ok(Snapshot1::fd_pread(self, memory, fd.into(), iovs.cast(), offset).await?)
+    }
+
+    async fn fd_write(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         fd: types::Fd,
-        ciovs: &types::CiovecArray<'a>,
+        ciovs: types::CiovecArray,
     ) -> Result<types::Size, Error> {
-        let f = self.table().get_file(u32::from(fd))?;
-
-        let guest_slices: Vec<wiggle::GuestCow<u8>> = ciovs
-            .iter()
-            .map(|iov_ptr| {
-                let iov_ptr = iov_ptr?;
-                let iov: types::Ciovec = iov_ptr.read()?;
-                Ok(iov.buf.as_array(iov.buf_len).as_cow()?)
-            })
-            .collect::<Result<_, Error>>()?;
-
-        let ioslices: Vec<IoSlice> = guest_slices
-            .iter()
-            .map(|s| IoSlice::new(s.deref()))
-            .collect();
-        let bytes_written = f.file.write_vectored(&ioslices).await?;
-
-        Ok(types::Size::try_from(bytes_written)?)
+        Ok(Snapshot1::fd_write(self, memory, fd.into(), ciovs.cast()).await?)
     }
 
-    async fn fd_pwrite<'a>(
+    async fn fd_pwrite(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         fd: types::Fd,
-        ciovs: &types::CiovecArray<'a>,
+        ciovs: types::CiovecArray,
         offset: types::Filesize,
     ) -> Result<types::Size, Error> {
-        let f = self.table().get_file(u32::from(fd))?;
-
-        let guest_slices: Vec<wiggle::GuestCow<u8>> = ciovs
-            .iter()
-            .map(|iov_ptr| {
-                let iov_ptr = iov_ptr?;
-                let iov: types::Ciovec = iov_ptr.read()?;
-                Ok(iov.buf.as_array(iov.buf_len).as_cow()?)
-            })
-            .collect::<Result<_, Error>>()?;
-
-        let ioslices: Vec<IoSlice> = guest_slices
-            .iter()
-            .map(|s| IoSlice::new(s.deref()))
-            .collect();
-        let bytes_written = f.file.write_vectored_at(&ioslices, offset).await?;
-
-        Ok(types::Size::try_from(bytes_written)?)
+        Ok(Snapshot1::fd_pwrite(self, memory, fd.into(), ciovs.cast(), offset).await?)
     }
 
-    async fn fd_prestat_get(&mut self, fd: types::Fd) -> Result<types::Prestat, Error> {
-        Ok(Snapshot1::fd_prestat_get(self, fd.into()).await?.into())
+    async fn fd_prestat_get(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+    ) -> Result<types::Prestat, Error> {
+        Ok(Snapshot1::fd_prestat_get(self, memory, fd.into())
+            .await?
+            .into())
     }
 
-    async fn fd_prestat_dir_name<'a>(
+    async fn fd_prestat_dir_name(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         fd: types::Fd,
-        path: &GuestPtr<'a, u8>,
+        path: GuestPtr<u8>,
         path_max_len: types::Size,
     ) -> Result<(), Error> {
-        Snapshot1::fd_prestat_dir_name(self, fd.into(), path, path_max_len).await?;
+        Snapshot1::fd_prestat_dir_name(self, memory, fd.into(), path, path_max_len).await?;
         Ok(())
     }
 
-    async fn fd_renumber(&mut self, from: types::Fd, to: types::Fd) -> Result<(), Error> {
-        Snapshot1::fd_renumber(self, from.into(), to.into()).await?;
+    async fn fd_renumber(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        from: types::Fd,
+        to: types::Fd,
+    ) -> Result<(), Error> {
+        Snapshot1::fd_renumber(self, memory, from.into(), to.into()).await?;
         Ok(())
     }
 
     async fn fd_seek(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         fd: types::Fd,
         offset: types::Filedelta,
         whence: types::Whence,
     ) -> Result<types::Filesize, Error> {
-        Ok(Snapshot1::fd_seek(self, fd.into(), offset, whence.into()).await?)
+        Ok(Snapshot1::fd_seek(self, memory, fd.into(), offset, whence.into()).await?)
     }
 
-    async fn fd_sync(&mut self, fd: types::Fd) -> Result<(), Error> {
-        Snapshot1::fd_sync(self, fd.into()).await?;
+    async fn fd_sync(&mut self, memory: &mut GuestMemory<'_>, fd: types::Fd) -> Result<(), Error> {
+        Snapshot1::fd_sync(self, memory, fd.into()).await?;
         Ok(())
     }
 
-    async fn fd_tell(&mut self, fd: types::Fd) -> Result<types::Filesize, Error> {
-        Ok(Snapshot1::fd_tell(self, fd.into()).await?)
+    async fn fd_tell(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+    ) -> Result<types::Filesize, Error> {
+        Ok(Snapshot1::fd_tell(self, memory, fd.into()).await?)
     }
 
-    async fn fd_readdir<'a>(
+    async fn fd_readdir(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         fd: types::Fd,
-        buf: &GuestPtr<'a, u8>,
+        buf: GuestPtr<u8>,
         buf_len: types::Size,
         cookie: types::Dircookie,
     ) -> Result<types::Size, Error> {
-        Ok(Snapshot1::fd_readdir(self, fd.into(), buf, buf_len, cookie).await?)
+        Ok(Snapshot1::fd_readdir(self, memory, fd.into(), buf, buf_len, cookie).await?)
     }
 
-    async fn path_create_directory<'a>(
+    async fn path_create_directory(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         dirfd: types::Fd,
-        path: &GuestPtr<'a, str>,
+        path: GuestPtr<str>,
     ) -> Result<(), Error> {
-        Snapshot1::path_create_directory(self, dirfd.into(), path).await?;
+        Snapshot1::path_create_directory(self, memory, dirfd.into(), path).await?;
         Ok(())
     }
 
-    async fn path_filestat_get<'a>(
+    async fn path_filestat_get(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         dirfd: types::Fd,
         flags: types::Lookupflags,
-        path: &GuestPtr<'a, str>,
+        path: GuestPtr<str>,
     ) -> Result<types::Filestat, Error> {
         Ok(
-            Snapshot1::path_filestat_get(self, dirfd.into(), flags.into(), path)
+            Snapshot1::path_filestat_get(self, memory, dirfd.into(), flags.into(), path)
                 .await?
                 .into(),
         )
     }
 
-    async fn path_filestat_set_times<'a>(
+    async fn path_filestat_set_times(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         dirfd: types::Fd,
         flags: types::Lookupflags,
-        path: &GuestPtr<'a, str>,
+        path: GuestPtr<str>,
         atim: types::Timestamp,
         mtim: types::Timestamp,
         fst_flags: types::Fstflags,
     ) -> Result<(), Error> {
         Snapshot1::path_filestat_set_times(
             self,
+            memory,
             dirfd.into(),
             flags.into(),
             path,
@@ -810,16 +704,18 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
         Ok(())
     }
 
-    async fn path_link<'a>(
+    async fn path_link(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         src_fd: types::Fd,
         src_flags: types::Lookupflags,
-        src_path: &GuestPtr<'a, str>,
+        src_path: GuestPtr<str>,
         target_fd: types::Fd,
-        target_path: &GuestPtr<'a, str>,
+        target_path: GuestPtr<str>,
     ) -> Result<(), Error> {
         Snapshot1::path_link(
             self,
+            memory,
             src_fd.into(),
             src_flags.into(),
             src_path,
@@ -830,11 +726,12 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
         Ok(())
     }
 
-    async fn path_open<'a>(
+    async fn path_open(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         dirfd: types::Fd,
         dirflags: types::Lookupflags,
-        path: &GuestPtr<'a, str>,
+        path: GuestPtr<str>,
         oflags: types::Oflags,
         fs_rights_base: types::Rights,
         fs_rights_inheriting: types::Rights,
@@ -842,6 +739,7 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
     ) -> Result<types::Fd, Error> {
         Ok(Snapshot1::path_open(
             self,
+            memory,
             dirfd.into(),
             dirflags.into(),
             path,
@@ -854,52 +752,65 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
         .into())
     }
 
-    async fn path_readlink<'a>(
+    async fn path_readlink(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         dirfd: types::Fd,
-        path: &GuestPtr<'a, str>,
-        buf: &GuestPtr<'a, u8>,
+        path: GuestPtr<str>,
+        buf: GuestPtr<u8>,
         buf_len: types::Size,
     ) -> Result<types::Size, Error> {
-        Ok(Snapshot1::path_readlink(self, dirfd.into(), path, buf, buf_len).await?)
+        Ok(Snapshot1::path_readlink(self, memory, dirfd.into(), path, buf, buf_len).await?)
     }
 
-    async fn path_remove_directory<'a>(
+    async fn path_remove_directory(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         dirfd: types::Fd,
-        path: &GuestPtr<'a, str>,
+        path: GuestPtr<str>,
     ) -> Result<(), Error> {
-        Snapshot1::path_remove_directory(self, dirfd.into(), path).await?;
+        Snapshot1::path_remove_directory(self, memory, dirfd.into(), path).await?;
         Ok(())
     }
 
-    async fn path_rename<'a>(
+    async fn path_rename(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         src_fd: types::Fd,
-        src_path: &GuestPtr<'a, str>,
+        src_path: GuestPtr<str>,
         dest_fd: types::Fd,
-        dest_path: &GuestPtr<'a, str>,
+        dest_path: GuestPtr<str>,
     ) -> Result<(), Error> {
-        Snapshot1::path_rename(self, src_fd.into(), src_path, dest_fd.into(), dest_path).await?;
+        Snapshot1::path_rename(
+            self,
+            memory,
+            src_fd.into(),
+            src_path,
+            dest_fd.into(),
+            dest_path,
+        )
+        .await?;
         Ok(())
     }
 
-    async fn path_symlink<'a>(
+    async fn path_symlink(
         &mut self,
-        src_path: &GuestPtr<'a, str>,
+        memory: &mut GuestMemory<'_>,
+        src_path: GuestPtr<str>,
         dirfd: types::Fd,
-        dest_path: &GuestPtr<'a, str>,
+        dest_path: GuestPtr<str>,
     ) -> Result<(), Error> {
-        Snapshot1::path_symlink(self, src_path, dirfd.into(), dest_path).await?;
+        Snapshot1::path_symlink(self, memory, src_path, dirfd.into(), dest_path).await?;
         Ok(())
     }
 
-    async fn path_unlink_file<'a>(
+    async fn path_unlink_file(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         dirfd: types::Fd,
-        path: &GuestPtr<'a, str>,
+        path: GuestPtr<str>,
     ) -> Result<(), Error> {
-        Snapshot1::path_unlink_file(self, dirfd.into(), path).await?;
+        Snapshot1::path_unlink_file(self, memory, dirfd.into(), path).await?;
         Ok(())
     }
 
@@ -910,10 +821,11 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
     // The implementations are identical, but the `types::` in scope locally is different.
     // The bodies of these functions is mostly about converting the GuestPtr and types::-based
     // representation to use the Poll abstraction.
-    async fn poll_oneoff<'a>(
+    async fn poll_oneoff(
         &mut self,
-        subs: &GuestPtr<'a, types::Subscription>,
-        events: &GuestPtr<'a, types::Event>,
+        memory: &mut GuestMemory<'_>,
+        subs: GuestPtr<types::Subscription>,
+        events: GuestPtr<types::Event>,
         nsubscriptions: types::Size,
     ) -> Result<types::Size, Error> {
         if nsubscriptions == 0 {
@@ -925,7 +837,7 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
         // functions. This supports all clock IDs, because POSIX says that
         // `clock_settime` doesn't effect relative sleeps.
         if nsubscriptions == 1 {
-            let sub = subs.read()?;
+            let sub = memory.read(subs)?;
             if let types::SubscriptionU::Clock(clocksub) = sub.u {
                 if !clocksub
                     .flags
@@ -934,12 +846,15 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
                     self.sched
                         .sleep(Duration::from_nanos(clocksub.timeout))
                         .await?;
-                    events.write(types::Event {
-                        userdata: sub.userdata,
-                        error: types::Errno::Success,
-                        type_: types::Eventtype::Clock,
-                        fd_readwrite: fd_readwrite_empty(),
-                    })?;
+                    memory.write(
+                        events,
+                        types::Event {
+                            userdata: sub.userdata,
+                            error: types::Errno::Success,
+                            type_: types::Eventtype::Clock,
+                            fd_readwrite: fd_readwrite_empty(),
+                        },
+                    )?;
                     return Ok(1);
                 }
             }
@@ -955,7 +870,7 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
         let subs = subs.as_array(nsubscriptions);
         for sub_elem in subs.iter() {
             let sub_ptr = sub_elem?;
-            let sub = sub_ptr.read()?;
+            let sub = memory.read(sub_ptr)?;
             match sub.u {
                 types::SubscriptionU::Clock(clocksub) => match clocksub.id {
                     types::Clockid::Monotonic => {
@@ -1024,106 +939,125 @@ impl wasi_unstable::WasiUnstable for WasiCtx {
         for ((result, userdata), event_elem) in results.into_iter().zip(events.iter()) {
             let event_ptr = event_elem?;
             let userdata: types::Userdata = userdata.into();
-            event_ptr.write(match result {
-                SubscriptionResult::Read(r) => {
-                    let type_ = types::Eventtype::FdRead;
-                    match r {
-                        Ok((nbytes, flags)) => types::Event {
-                            userdata,
-                            error: types::Errno::Success,
-                            type_,
-                            fd_readwrite: types::EventFdReadwrite {
-                                nbytes,
-                                flags: types::Eventrwflags::from(&flags),
+            memory.write(
+                event_ptr,
+                match result {
+                    SubscriptionResult::Read(r) => {
+                        let type_ = types::Eventtype::FdRead;
+                        match r {
+                            Ok((nbytes, flags)) => types::Event {
+                                userdata,
+                                error: types::Errno::Success,
+                                type_,
+                                fd_readwrite: types::EventFdReadwrite {
+                                    nbytes,
+                                    flags: types::Eventrwflags::from(&flags),
+                                },
                             },
-                        },
-                        Err(e) => types::Event {
-                            userdata,
-                            error: types::Errno::from(e.downcast().map_err(Error::trap)?),
-                            type_,
-                            fd_readwrite: fd_readwrite_empty(),
-                        },
+                            Err(e) => types::Event {
+                                userdata,
+                                error: types::Errno::from(e.downcast().map_err(Error::trap)?),
+                                type_,
+                                fd_readwrite: fd_readwrite_empty(),
+                            },
+                        }
                     }
-                }
-                SubscriptionResult::Write(r) => {
-                    let type_ = types::Eventtype::FdWrite;
-                    match r {
-                        Ok((nbytes, flags)) => types::Event {
-                            userdata,
-                            error: types::Errno::Success,
-                            type_,
-                            fd_readwrite: types::EventFdReadwrite {
-                                nbytes,
-                                flags: types::Eventrwflags::from(&flags),
+                    SubscriptionResult::Write(r) => {
+                        let type_ = types::Eventtype::FdWrite;
+                        match r {
+                            Ok((nbytes, flags)) => types::Event {
+                                userdata,
+                                error: types::Errno::Success,
+                                type_,
+                                fd_readwrite: types::EventFdReadwrite {
+                                    nbytes,
+                                    flags: types::Eventrwflags::from(&flags),
+                                },
                             },
-                        },
-                        Err(e) => types::Event {
+                            Err(e) => types::Event {
+                                userdata,
+                                error: types::Errno::from(e.downcast().map_err(Error::trap)?),
+                                type_,
+                                fd_readwrite: fd_readwrite_empty(),
+                            },
+                        }
+                    }
+                    SubscriptionResult::MonotonicClock(r) => {
+                        let type_ = types::Eventtype::Clock;
+                        types::Event {
                             userdata,
-                            error: types::Errno::from(e.downcast().map_err(Error::trap)?),
+                            error: match r {
+                                Ok(()) => types::Errno::Success,
+                                Err(e) => types::Errno::from(e.downcast().map_err(Error::trap)?),
+                            },
                             type_,
                             fd_readwrite: fd_readwrite_empty(),
-                        },
-                    }
-                }
-                SubscriptionResult::MonotonicClock(r) => {
-                    let type_ = types::Eventtype::Clock;
-                    types::Event {
-                        userdata,
-                        error: match r {
-                            Ok(()) => types::Errno::Success,
-                            Err(e) => types::Errno::from(e.downcast().map_err(Error::trap)?),
-                        },
-                        type_,
-                        fd_readwrite: fd_readwrite_empty(),
+                        }
                     }
-                }
-            })?;
+                },
+            )?;
         }
 
         Ok(num_results.try_into().expect("results fit into memory"))
     }
 
-    async fn proc_exit(&mut self, status: types::Exitcode) -> anyhow::Error {
-        Snapshot1::proc_exit(self, status).await
+    async fn proc_exit(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        status: types::Exitcode,
+    ) -> anyhow::Error {
+        Snapshot1::proc_exit(self, memory, status).await
     }
 
-    async fn proc_raise(&mut self, _sig: types::Signal) -> Result<(), Error> {
+    async fn proc_raise(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        _sig: types::Signal,
+    ) -> Result<(), Error> {
         Err(Error::trap(anyhow::Error::msg("proc_raise unsupported")))
     }
 
-    async fn sched_yield(&mut self) -> Result<(), Error> {
-        Snapshot1::sched_yield(self).await?;
+    async fn sched_yield(&mut self, memory: &mut GuestMemory<'_>) -> Result<(), Error> {
+        Snapshot1::sched_yield(self, memory).await?;
         Ok(())
     }
 
-    async fn random_get<'a>(
+    async fn random_get(
         &mut self,
-        buf: &GuestPtr<'a, u8>,
+        memory: &mut GuestMemory<'_>,
+        buf: GuestPtr<u8>,
         buf_len: types::Size,
     ) -> Result<(), Error> {
-        Snapshot1::random_get(self, buf, buf_len).await?;
+        Snapshot1::random_get(self, memory, buf, buf_len).await?;
         Ok(())
     }
 
-    async fn sock_recv<'a>(
+    async fn sock_recv(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         _fd: types::Fd,
-        _ri_data: &types::IovecArray<'a>,
+        _ri_data: types::IovecArray,
         _ri_flags: types::Riflags,
     ) -> Result<(types::Size, types::Roflags), Error> {
         Err(Error::trap(anyhow::Error::msg("sock_recv unsupported")))
     }
 
-    async fn sock_send<'a>(
+    async fn sock_send(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         _fd: types::Fd,
-        _si_data: &types::CiovecArray<'a>,
+        _si_data: types::CiovecArray,
         _si_flags: types::Siflags,
     ) -> Result<types::Size, Error> {
         Err(Error::trap(anyhow::Error::msg("sock_send unsupported")))
     }
 
-    async fn sock_shutdown(&mut self, _fd: types::Fd, _how: types::Sdflags) -> Result<(), Error> {
+    async fn sock_shutdown(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        _fd: types::Fd,
+        _how: types::Sdflags,
+    ) -> Result<(), Error> {
         Err(Error::trap(anyhow::Error::msg("sock_shutdown unsupported")))
     }
 }
diff --git a/crates/wasi-common/src/snapshots/preview_1.rs b/crates/wasi-common/src/snapshots/preview_1.rs
index 465af436da45..74295b8aa235 100644
--- a/crates/wasi-common/src/snapshots/preview_1.rs
+++ b/crates/wasi-common/src/snapshots/preview_1.rs
@@ -11,10 +11,11 @@ use crate::{
     I32Exit, SystemTimeSpec, WasiCtx,
 };
 use cap_std::time::{Duration, SystemClock};
-use std::convert::{TryFrom, TryInto};
+use std::borrow::Cow;
 use std::io::{IoSlice, IoSliceMut};
 use std::ops::Deref;
 use std::sync::Arc;
+use wiggle::GuestMemory;
 use wiggle::GuestPtr;
 
 pub mod error;
@@ -25,7 +26,7 @@ use error::{Error, ErrorExt};
 pub(crate) const MAX_SHARED_BUFFER_SIZE: usize = 1 << 16;
 
 wiggle::from_witx!({
-    witx: ["$WASI_ROOT/phases/snapshot/witx/wasi_snapshot_preview1.witx"],
+    witx: ["$CARGO_MANIFEST_DIR/witx/preview1/wasi_snapshot_preview1.witx"],
     errors: { errno => trappable Error },
     // Note: not every function actually needs to be async, however, nearly all of them do, and
     // keeping that set the same in this macro and the wasmtime_wiggle / lucet_wiggle macros is
@@ -42,31 +43,43 @@ impl wiggle::GuestErrorType for types::Errno {
 
 #[wiggle::async_trait]
 impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
-    async fn args_get<'b>(
+    async fn args_get(
         &mut self,
-        argv: &GuestPtr<'b, GuestPtr<'b, u8>>,
-        argv_buf: &GuestPtr<'b, u8>,
+        memory: &mut GuestMemory<'_>,
+        argv: GuestPtr<GuestPtr<u8>>,
+        argv_buf: GuestPtr<u8>,
     ) -> Result<(), Error> {
-        self.args.write_to_guest(argv_buf, argv)
+        self.args.write_to_guest(memory, argv_buf, argv)
     }
 
-    async fn args_sizes_get(&mut self) -> Result<(types::Size, types::Size), Error> {
+    async fn args_sizes_get(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+    ) -> Result<(types::Size, types::Size), Error> {
         Ok((self.args.number_elements(), self.args.cumulative_size()))
     }
 
-    async fn environ_get<'b>(
+    async fn environ_get(
         &mut self,
-        environ: &GuestPtr<'b, GuestPtr<'b, u8>>,
-        environ_buf: &GuestPtr<'b, u8>,
+        memory: &mut GuestMemory<'_>,
+        environ: GuestPtr<GuestPtr<u8>>,
+        environ_buf: GuestPtr<u8>,
     ) -> Result<(), Error> {
-        self.env.write_to_guest(environ_buf, environ)
+        self.env.write_to_guest(memory, environ_buf, environ)
     }
 
-    async fn environ_sizes_get(&mut self) -> Result<(types::Size, types::Size), Error> {
+    async fn environ_sizes_get(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+    ) -> Result<(types::Size, types::Size), Error> {
         Ok((self.env.number_elements(), self.env.cumulative_size()))
     }
 
-    async fn clock_res_get(&mut self, id: types::Clockid) -> Result<types::Timestamp, Error> {
+    async fn clock_res_get(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        id: types::Clockid,
+    ) -> Result<types::Timestamp, Error> {
         let resolution = match id {
             types::Clockid::Realtime => Ok(self.clocks.system()?.resolution()),
             types::Clockid::Monotonic => Ok(self.clocks.monotonic()?.abs_clock.resolution()),
@@ -79,6 +92,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
 
     async fn clock_time_get(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         id: types::Clockid,
         precision: types::Timestamp,
     ) -> Result<types::Timestamp, Error> {
@@ -107,6 +121,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
 
     async fn fd_advise(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         fd: types::Fd,
         offset: types::Filesize,
         len: types::Filesize,
@@ -122,6 +137,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
 
     async fn fd_allocate(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         fd: types::Fd,
         _offset: types::Filesize,
         _len: types::Filesize,
@@ -137,7 +153,11 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
         Err(Error::not_supported())
     }
 
-    async fn fd_close(&mut self, fd: types::Fd) -> Result<(), Error> {
+    async fn fd_close(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+    ) -> Result<(), Error> {
         let table = self.table();
         let fd = u32::from(fd);
 
@@ -157,7 +177,11 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
         Ok(())
     }
 
-    async fn fd_datasync(&mut self, fd: types::Fd) -> Result<(), Error> {
+    async fn fd_datasync(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+    ) -> Result<(), Error> {
         self.table()
             .get_file(u32::from(fd))?
             .file
@@ -166,7 +190,11 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
         Ok(())
     }
 
-    async fn fd_fdstat_get(&mut self, fd: types::Fd) -> Result<types::Fdstat, Error> {
+    async fn fd_fdstat_get(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+    ) -> Result<types::Fdstat, Error> {
         let table = self.table();
         let fd = u32::from(fd);
         if table.is::<FileEntry>(fd) {
@@ -189,6 +217,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
 
     async fn fd_fdstat_set_flags(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         fd: types::Fd,
         flags: types::Fdflags,
     ) -> Result<(), Error> {
@@ -206,6 +235,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
 
     async fn fd_fdstat_set_rights(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         fd: types::Fd,
         _fs_rights_base: types::Rights,
         _fs_rights_inheriting: types::Rights,
@@ -223,7 +253,11 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
         }
     }
 
-    async fn fd_filestat_get(&mut self, fd: types::Fd) -> Result<types::Filestat, Error> {
+    async fn fd_filestat_get(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+    ) -> Result<types::Filestat, Error> {
         let table = self.table();
         let fd = u32::from(fd);
         if table.is::<FileEntry>(fd) {
@@ -239,6 +273,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
 
     async fn fd_filestat_set_size(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         fd: types::Fd,
         size: types::Filesize,
     ) -> Result<(), Error> {
@@ -252,6 +287,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
 
     async fn fd_filestat_set_times(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         fd: types::Fd,
         atim: types::Timestamp,
         mtim: types::Timestamp,
@@ -287,10 +323,11 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
         }
     }
 
-    async fn fd_read<'a>(
+    async fn fd_read(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         fd: types::Fd,
-        iovs: &types::IovecArray<'a>,
+        iovs: types::IovecArray,
     ) -> Result<types::Size, Error> {
         let f = self.table().get_file(u32::from(fd))?;
         // Access mode check normalizes error returned (windows would prefer ACCES here)
@@ -303,7 +340,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
             .iter()
             .map(|iov_ptr| {
                 let iov_ptr = iov_ptr?;
-                let iov: types::Iovec = iov_ptr.read()?;
+                let iov: types::Iovec = memory.read(iov_ptr)?;
                 Ok(iov.buf.as_array(iov.buf_len))
             })
             .collect::<Result<_, Error>>()?;
@@ -320,11 +357,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
         //   since we do not know here if `&dyn WasiFile` does anything else
         //   (e.g., read), we cautiously incur some performance overhead by
         //   copying twice.
-        let is_shared_memory = iovs
-            .iter()
-            .next()
-            .and_then(|s| Some(s.is_shared_memory()))
-            .unwrap_or(false);
+        let is_shared_memory = memory.is_shared_memory();
         let bytes_read: u64 = if is_shared_memory {
             // For shared memory, read into an intermediate buffer. Only the
             // first iov will be filled and even then the read is capped by the
@@ -333,38 +366,38 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
             if let Some(iov) = iov {
                 let mut buffer = vec![0; (iov.len() as usize).min(MAX_SHARED_BUFFER_SIZE)];
                 let bytes_read = f.read_vectored(&mut [IoSliceMut::new(&mut buffer)]).await?;
-                iov.get_range(0..bytes_read.try_into()?)
-                    .expect("it should always be possible to slice the iov smaller")
-                    .copy_from_slice(&buffer[0..bytes_read.try_into()?])?;
+                let iov = iov
+                    .get_range(0..bytes_read.try_into()?)
+                    .expect("it should always be possible to slice the iov smaller");
+                memory.copy_from_slice(&buffer[0..bytes_read.try_into()?], iov)?;
                 bytes_read
             } else {
                 return Ok(0);
             }
         } else {
-            // Convert all of the unsafe guest slices to safe ones--this uses
-            // Wiggle's internal borrow checker to ensure no overlaps. We assume
-            // here that, because the memory is not shared, there are no other
-            // threads to access it while it is written to.
-            let mut guest_slices: Vec<wiggle::GuestSliceMut<u8>> = iovs
-                .into_iter()
-                .map(|iov| Ok(iov.as_slice_mut()?.unwrap()))
-                .collect::<Result<_, Error>>()?;
+            // Convert the first unsafe guest slice into a safe one--Wiggle
+            // can only track mutable borrows for an entire region, and converting
+            // all guest pointers to slices would cause a runtime borrow-checking
+            // error. As read is allowed to return less than the requested amount,
+            // it's valid (though not as efficient) for us to only perform the
+            // read of the first buffer.
+            let guest_slice: &mut [u8] = match iovs.into_iter().filter(|iov| iov.len() > 0).next() {
+                Some(iov) => memory.as_slice_mut(iov)?.unwrap(),
+                None => return Ok(0),
+            };
 
             // Read directly into the Wasm memory.
-            let mut ioslices: Vec<IoSliceMut> = guest_slices
-                .iter_mut()
-                .map(|s| IoSliceMut::new(&mut *s))
-                .collect();
-            f.read_vectored(&mut ioslices).await?
+            f.read_vectored(&mut [IoSliceMut::new(guest_slice)]).await?
         };
 
         Ok(types::Size::try_from(bytes_read)?)
     }
 
-    async fn fd_pread<'a>(
+    async fn fd_pread(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         fd: types::Fd,
-        iovs: &types::IovecArray<'a>,
+        iovs: types::IovecArray,
         offset: types::Filesize,
     ) -> Result<types::Size, Error> {
         let f = self.table().get_file(u32::from(fd))?;
@@ -378,7 +411,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
             .iter()
             .map(|iov_ptr| {
                 let iov_ptr = iov_ptr?;
-                let iov: types::Iovec = iov_ptr.read()?;
+                let iov: types::Iovec = memory.read(iov_ptr)?;
                 Ok(iov.buf.as_array(iov.buf_len))
             })
             .collect::<Result<_, Error>>()?;
@@ -395,11 +428,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
         //   since we do not know here if `&dyn WasiFile` does anything else
         //   (e.g., read), we cautiously incur some performance overhead by
         //   copying twice.
-        let is_shared_memory = iovs
-            .iter()
-            .next()
-            .and_then(|s| Some(s.is_shared_memory()))
-            .unwrap_or(false);
+        let is_shared_memory = memory.is_shared_memory();
         let bytes_read: u64 = if is_shared_memory {
             // For shared memory, read into an intermediate buffer. Only the
             // first iov will be filled and even then the read is capped by the
@@ -410,38 +439,34 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
                 let bytes_read = f
                     .read_vectored_at(&mut [IoSliceMut::new(&mut buffer)], offset)
                     .await?;
-                iov.get_range(0..bytes_read.try_into()?)
-                    .expect("it should always be possible to slice the iov smaller")
-                    .copy_from_slice(&buffer[0..bytes_read.try_into()?])?;
+                let iov = iov
+                    .get_range(0..bytes_read.try_into()?)
+                    .expect("it should always be possible to slice the iov smaller");
+                memory.copy_from_slice(&buffer[0..bytes_read.try_into()?], iov)?;
                 bytes_read
             } else {
                 return Ok(0);
             }
         } else {
-            // Convert all of the unsafe guest slices to safe ones--this uses
-            // Wiggle's internal borrow checker to ensure no overlaps. We assume
-            // here that, because the memory is not shared, there are no other
-            // threads to access it while it is written to.
-            let mut guest_slices: Vec<wiggle::GuestSliceMut<u8>> = iovs
-                .into_iter()
-                .map(|iov| Ok(iov.as_slice_mut()?.unwrap()))
-                .collect::<Result<_, Error>>()?;
+            // Convert unsafe guest slices to safe ones.
+            let guest_slice: &mut [u8] = match iovs.into_iter().filter(|iov| iov.len() > 0).next() {
+                Some(iov) => memory.as_slice_mut(iov)?.unwrap(),
+                None => return Ok(0),
+            };
 
             // Read directly into the Wasm memory.
-            let mut ioslices: Vec<IoSliceMut> = guest_slices
-                .iter_mut()
-                .map(|s| IoSliceMut::new(&mut *s))
-                .collect();
-            f.read_vectored_at(&mut ioslices, offset).await?
+            f.read_vectored_at(&mut [IoSliceMut::new(guest_slice)], offset)
+                .await?
         };
 
         Ok(types::Size::try_from(bytes_read)?)
     }
 
-    async fn fd_write<'a>(
+    async fn fd_write(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         fd: types::Fd,
-        ciovs: &types::CiovecArray<'a>,
+        ciovs: types::CiovecArray,
     ) -> Result<types::Size, Error> {
         let f = self.table().get_file(u32::from(fd))?;
         // Access mode check normalizes error returned (windows would prefer ACCES here)
@@ -450,12 +475,12 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
         }
         let f = &f.file;
 
-        let guest_slices: Vec<wiggle::GuestCow<u8>> = ciovs
+        let guest_slices: Vec<Cow<[u8]>> = ciovs
             .iter()
             .map(|iov_ptr| {
                 let iov_ptr = iov_ptr?;
-                let iov: types::Ciovec = iov_ptr.read()?;
-                Ok(iov.buf.as_array(iov.buf_len).as_cow()?)
+                let iov: types::Ciovec = memory.read(iov_ptr)?;
+                Ok(memory.as_cow(iov.buf.as_array(iov.buf_len))?)
             })
             .collect::<Result<_, Error>>()?;
 
@@ -468,10 +493,11 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
         Ok(types::Size::try_from(bytes_written)?)
     }
 
-    async fn fd_pwrite<'a>(
+    async fn fd_pwrite(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         fd: types::Fd,
-        ciovs: &types::CiovecArray<'a>,
+        ciovs: types::CiovecArray,
         offset: types::Filesize,
     ) -> Result<types::Size, Error> {
         let f = self.table().get_file(u32::from(fd))?;
@@ -481,12 +507,12 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
         }
         let f = &f.file;
 
-        let guest_slices: Vec<wiggle::GuestCow<u8>> = ciovs
+        let guest_slices: Vec<Cow<[u8]>> = ciovs
             .iter()
             .map(|iov_ptr| {
                 let iov_ptr = iov_ptr?;
-                let iov: types::Ciovec = iov_ptr.read()?;
-                Ok(iov.buf.as_array(iov.buf_len).as_cow()?)
+                let iov: types::Ciovec = memory.read(iov_ptr)?;
+                Ok(memory.as_cow(iov.buf.as_array(iov.buf_len))?)
             })
             .collect::<Result<_, Error>>()?;
 
@@ -499,7 +525,11 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
         Ok(types::Size::try_from(bytes_written)?)
     }
 
-    async fn fd_prestat_get(&mut self, fd: types::Fd) -> Result<types::Prestat, Error> {
+    async fn fd_prestat_get(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+    ) -> Result<types::Prestat, Error> {
         let table = self.table();
         let dir_entry: Arc<DirEntry> = table.get(u32::from(fd)).map_err(|_| Error::badf())?;
         if let Some(ref preopen) = dir_entry.preopen_path() {
@@ -511,10 +541,11 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
         }
     }
 
-    async fn fd_prestat_dir_name<'a>(
+    async fn fd_prestat_dir_name(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         fd: types::Fd,
-        path: &GuestPtr<'a, u8>,
+        path: GuestPtr<u8>,
         path_max_len: types::Size,
     ) -> Result<(), Error> {
         let table = self.table();
@@ -528,13 +559,19 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
             if path_len > path_max_len as usize {
                 return Err(Error::name_too_long());
             }
-            path.as_array(path_len as u32).copy_from_slice(path_bytes)?;
+            let path = path.as_array(path_len as u32);
+            memory.copy_from_slice(path_bytes, path)?;
             Ok(())
         } else {
             Err(Error::not_supported())
         }
     }
-    async fn fd_renumber(&mut self, from: types::Fd, to: types::Fd) -> Result<(), Error> {
+    async fn fd_renumber(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        from: types::Fd,
+        to: types::Fd,
+    ) -> Result<(), Error> {
         let table = self.table();
         let from = u32::from(from);
         let to = u32::from(to);
@@ -546,6 +583,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
 
     async fn fd_seek(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         fd: types::Fd,
         offset: types::Filedelta,
         whence: types::Whence,
@@ -554,7 +592,9 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
         let whence = match whence {
             types::Whence::Cur => SeekFrom::Current(offset),
             types::Whence::End => SeekFrom::End(offset),
-            types::Whence::Set => SeekFrom::Start(offset as u64),
+            types::Whence::Set => {
+                SeekFrom::Start(offset.try_into().map_err(|_| Error::invalid_argument())?)
+            }
         };
         let newoffset = self
             .table()
@@ -565,12 +605,16 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
         Ok(newoffset)
     }
 
-    async fn fd_sync(&mut self, fd: types::Fd) -> Result<(), Error> {
+    async fn fd_sync(&mut self, _memory: &mut GuestMemory<'_>, fd: types::Fd) -> Result<(), Error> {
         self.table().get_file(u32::from(fd))?.file.sync().await?;
         Ok(())
     }
 
-    async fn fd_tell(&mut self, fd: types::Fd) -> Result<types::Filesize, Error> {
+    async fn fd_tell(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+    ) -> Result<types::Filesize, Error> {
         let offset = self
             .table()
             .get_file(u32::from(fd))?
@@ -580,15 +624,15 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
         Ok(offset)
     }
 
-    async fn fd_readdir<'a>(
+    async fn fd_readdir(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         fd: types::Fd,
-        buf: &GuestPtr<'a, u8>,
+        mut buf: GuestPtr<u8>,
         buf_len: types::Size,
         cookie: types::Dircookie,
     ) -> Result<types::Size, Error> {
         let mut bufused = 0;
-        let mut buf = buf.clone();
         for entity in self
             .table()
             .get_dir(u32::from(fd))?
@@ -604,10 +648,10 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
 
             // Copy as many bytes of the dirent as we can, up to the end of the buffer
             let dirent_copy_len = std::cmp::min(dirent_len, buf_len - bufused);
-            buf.as_array(dirent_copy_len)
-                .copy_from_slice(&dirent_raw[..dirent_copy_len as usize])?;
+            let raw = buf.as_array(dirent_copy_len);
+            memory.copy_from_slice(&dirent_raw[..dirent_copy_len as usize], raw)?;
 
-            // If the dirent struct wasnt compied entirely, return that we filled the buffer, which
+            // If the dirent struct wasn't compiled entirely, return that we filled the buffer, which
             // tells libc that we're not at EOF.
             if dirent_copy_len < dirent_len {
                 return Ok(buf_len);
@@ -618,8 +662,8 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
 
             // Copy as many bytes of the name as we can, up to the end of the buffer
             let name_copy_len = std::cmp::min(name_len, buf_len - bufused);
-            buf.as_array(name_copy_len)
-                .copy_from_slice(&name_raw[..name_copy_len as usize])?;
+            let raw = buf.as_array(name_copy_len);
+            memory.copy_from_slice(&name_raw[..name_copy_len as usize], raw)?;
 
             // If the dirent struct wasn't copied entirely, return that we filled the buffer, which
             // tells libc that we're not at EOF
@@ -634,41 +678,44 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
         Ok(bufused)
     }
 
-    async fn path_create_directory<'a>(
+    async fn path_create_directory(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         dirfd: types::Fd,
-        path: &GuestPtr<'a, str>,
+        path: GuestPtr<str>,
     ) -> Result<(), Error> {
         self.table()
             .get_dir(u32::from(dirfd))?
             .dir
-            .create_dir(path.as_cow()?.deref())
+            .create_dir(memory.as_cow_str(path)?.deref())
             .await
     }
 
-    async fn path_filestat_get<'a>(
+    async fn path_filestat_get(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         dirfd: types::Fd,
         flags: types::Lookupflags,
-        path: &GuestPtr<'a, str>,
+        path: GuestPtr<str>,
     ) -> Result<types::Filestat, Error> {
         let filestat = self
             .table()
             .get_dir(u32::from(dirfd))?
             .dir
             .get_path_filestat(
-                path.as_cow()?.deref(),
+                memory.as_cow_str(path)?.deref(),
                 flags.contains(types::Lookupflags::SYMLINK_FOLLOW),
             )
             .await?;
         Ok(types::Filestat::from(filestat))
     }
 
-    async fn path_filestat_set_times<'a>(
+    async fn path_filestat_set_times(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         dirfd: types::Fd,
         flags: types::Lookupflags,
-        path: &GuestPtr<'a, str>,
+        path: GuestPtr<str>,
         atim: types::Timestamp,
         mtim: types::Timestamp,
         fst_flags: types::Fstflags,
@@ -684,7 +731,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
             .get_dir(u32::from(dirfd))?
             .dir
             .set_times(
-                path.as_cow()?.deref(),
+                memory.as_cow_str(path)?.deref(),
                 atim,
                 mtim,
                 flags.contains(types::Lookupflags::SYMLINK_FOLLOW),
@@ -692,13 +739,14 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
             .await
     }
 
-    async fn path_link<'a>(
+    async fn path_link(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         src_fd: types::Fd,
         src_flags: types::Lookupflags,
-        src_path: &GuestPtr<'a, str>,
+        src_path: GuestPtr<str>,
         target_fd: types::Fd,
-        target_path: &GuestPtr<'a, str>,
+        target_path: GuestPtr<str>,
     ) -> Result<(), Error> {
         let table = self.table();
         let src_dir = table.get_dir(u32::from(src_fd))?;
@@ -712,18 +760,19 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
         src_dir
             .dir
             .hard_link(
-                src_path.as_cow()?.deref(),
+                memory.as_cow_str(src_path)?.deref(),
                 target_dir.dir.deref(),
-                target_path.as_cow()?.deref(),
+                memory.as_cow_str(target_path)?.deref(),
             )
             .await
     }
 
-    async fn path_open<'a>(
+    async fn path_open(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         dirfd: types::Fd,
         dirflags: types::Lookupflags,
-        path: &GuestPtr<'a, str>,
+        path: GuestPtr<str>,
         oflags: types::Oflags,
         fs_rights_base: types::Rights,
         _fs_rights_inheriting: types::Rights,
@@ -740,7 +789,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
 
         let oflags = OFlags::from(&oflags);
         let fdflags = FdFlags::from(fdflags);
-        let path = path.as_cow()?;
+        let path = memory.as_cow_str(path)?;
 
         let read = fs_rights_base.contains(types::Rights::FD_READ);
         let write = fs_rights_base.contains(types::Rights::FD_WRITE);
@@ -767,18 +816,19 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
         Ok(types::Fd::from(fd))
     }
 
-    async fn path_readlink<'a>(
+    async fn path_readlink(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         dirfd: types::Fd,
-        path: &GuestPtr<'a, str>,
-        buf: &GuestPtr<'a, u8>,
+        path: GuestPtr<str>,
+        buf: GuestPtr<u8>,
         buf_len: types::Size,
     ) -> Result<types::Size, Error> {
         let link = self
             .table()
             .get_dir(u32::from(dirfd))?
             .dir
-            .read_link(path.as_cow()?.deref())
+            .read_link(memory.as_cow_str(path)?.deref())
             .await?
             .into_os_string()
             .into_string()
@@ -787,29 +837,31 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
         // Like posix readlink(2), silently truncate links when they are larger than the
         // destination buffer:
         let link_len = std::cmp::min(link_bytes.len(), buf_len as usize);
-        buf.as_array(link_len as u32)
-            .copy_from_slice(&link_bytes[..link_len])?;
+        let buf = buf.as_array(link_len as u32);
+        memory.copy_from_slice(&link_bytes[..link_len], buf)?;
         Ok(link_len as types::Size)
     }
 
-    async fn path_remove_directory<'a>(
+    async fn path_remove_directory(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         dirfd: types::Fd,
-        path: &GuestPtr<'a, str>,
+        path: GuestPtr<str>,
     ) -> Result<(), Error> {
         self.table()
             .get_dir(u32::from(dirfd))?
             .dir
-            .remove_dir(path.as_cow()?.deref())
+            .remove_dir(memory.as_cow_str(path)?.deref())
             .await
     }
 
-    async fn path_rename<'a>(
+    async fn path_rename(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         src_fd: types::Fd,
-        src_path: &GuestPtr<'a, str>,
+        src_path: GuestPtr<str>,
         dest_fd: types::Fd,
-        dest_path: &GuestPtr<'a, str>,
+        dest_path: GuestPtr<str>,
     ) -> Result<(), Error> {
         let table = self.table();
         let src_dir = table.get_dir(u32::from(src_fd))?;
@@ -817,42 +869,48 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
         src_dir
             .dir
             .rename(
-                src_path.as_cow()?.deref(),
+                memory.as_cow_str(src_path)?.deref(),
                 dest_dir.dir.deref(),
-                dest_path.as_cow()?.deref(),
+                memory.as_cow_str(dest_path)?.deref(),
             )
             .await
     }
 
-    async fn path_symlink<'a>(
+    async fn path_symlink(
         &mut self,
-        src_path: &GuestPtr<'a, str>,
+        memory: &mut GuestMemory<'_>,
+        src_path: GuestPtr<str>,
         dirfd: types::Fd,
-        dest_path: &GuestPtr<'a, str>,
+        dest_path: GuestPtr<str>,
     ) -> Result<(), Error> {
         self.table()
             .get_dir(u32::from(dirfd))?
             .dir
-            .symlink(src_path.as_cow()?.deref(), dest_path.as_cow()?.deref())
+            .symlink(
+                memory.as_cow_str(src_path)?.deref(),
+                memory.as_cow_str(dest_path)?.deref(),
+            )
             .await
     }
 
-    async fn path_unlink_file<'a>(
+    async fn path_unlink_file(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         dirfd: types::Fd,
-        path: &GuestPtr<'a, str>,
+        path: GuestPtr<str>,
     ) -> Result<(), Error> {
         self.table()
             .get_dir(u32::from(dirfd))?
             .dir
-            .unlink_file(path.as_cow()?.deref())
+            .unlink_file(memory.as_cow_str(path)?.deref())
             .await
     }
 
-    async fn poll_oneoff<'a>(
+    async fn poll_oneoff(
         &mut self,
-        subs: &GuestPtr<'a, types::Subscription>,
-        events: &GuestPtr<'a, types::Event>,
+        memory: &mut GuestMemory<'_>,
+        subs: GuestPtr<types::Subscription>,
+        events: GuestPtr<types::Event>,
         nsubscriptions: types::Size,
     ) -> Result<types::Size, Error> {
         if nsubscriptions == 0 {
@@ -864,7 +922,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
         // functions. This supports all clock IDs, because POSIX says that
         // `clock_settime` doesn't effect relative sleeps.
         if nsubscriptions == 1 {
-            let sub = subs.read()?;
+            let sub = memory.read(subs)?;
             if let types::SubscriptionU::Clock(clocksub) = sub.u {
                 if !clocksub
                     .flags
@@ -873,12 +931,15 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
                     self.sched
                         .sleep(Duration::from_nanos(clocksub.timeout))
                         .await?;
-                    events.write(types::Event {
-                        userdata: sub.userdata,
-                        error: types::Errno::Success,
-                        type_: types::Eventtype::Clock,
-                        fd_readwrite: fd_readwrite_empty(),
-                    })?;
+                    memory.write(
+                        events,
+                        types::Event {
+                            userdata: sub.userdata,
+                            error: types::Errno::Success,
+                            type_: types::Eventtype::Clock,
+                            fd_readwrite: fd_readwrite_empty(),
+                        },
+                    )?;
                     return Ok(1);
                 }
             }
@@ -894,7 +955,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
         let subs = subs.as_array(nsubscriptions);
         for sub_elem in subs.iter() {
             let sub_ptr = sub_elem?;
-            let sub = sub_ptr.read()?;
+            let sub = memory.read(sub_ptr)?;
             match sub.u {
                 types::SubscriptionU::Clock(clocksub) => match clocksub.id {
                     types::Clockid::Monotonic => {
@@ -997,66 +1058,73 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
         for ((result, userdata), event_elem) in results.into_iter().zip(events.iter()) {
             let event_ptr = event_elem?;
             let userdata: types::Userdata = userdata.into();
-            event_ptr.write(match result {
-                SubscriptionResult::Read(r) => {
-                    let type_ = types::Eventtype::FdRead;
-                    match r {
-                        Ok((nbytes, flags)) => types::Event {
-                            userdata,
-                            error: types::Errno::Success,
-                            type_,
-                            fd_readwrite: types::EventFdReadwrite {
-                                nbytes,
-                                flags: types::Eventrwflags::from(&flags),
+            memory.write(
+                event_ptr,
+                match result {
+                    SubscriptionResult::Read(r) => {
+                        let type_ = types::Eventtype::FdRead;
+                        match r {
+                            Ok((nbytes, flags)) => types::Event {
+                                userdata,
+                                error: types::Errno::Success,
+                                type_,
+                                fd_readwrite: types::EventFdReadwrite {
+                                    nbytes,
+                                    flags: types::Eventrwflags::from(&flags),
+                                },
                             },
-                        },
-                        Err(e) => types::Event {
-                            userdata,
-                            error: e.downcast().map_err(Error::trap)?,
-                            type_,
-                            fd_readwrite: fd_readwrite_empty(),
-                        },
+                            Err(e) => types::Event {
+                                userdata,
+                                error: e.downcast().map_err(Error::trap)?,
+                                type_,
+                                fd_readwrite: fd_readwrite_empty(),
+                            },
+                        }
                     }
-                }
-                SubscriptionResult::Write(r) => {
-                    let type_ = types::Eventtype::FdWrite;
-                    match r {
-                        Ok((nbytes, flags)) => types::Event {
-                            userdata,
-                            error: types::Errno::Success,
-                            type_,
-                            fd_readwrite: types::EventFdReadwrite {
-                                nbytes,
-                                flags: types::Eventrwflags::from(&flags),
+                    SubscriptionResult::Write(r) => {
+                        let type_ = types::Eventtype::FdWrite;
+                        match r {
+                            Ok((nbytes, flags)) => types::Event {
+                                userdata,
+                                error: types::Errno::Success,
+                                type_,
+                                fd_readwrite: types::EventFdReadwrite {
+                                    nbytes,
+                                    flags: types::Eventrwflags::from(&flags),
+                                },
                             },
-                        },
-                        Err(e) => types::Event {
+                            Err(e) => types::Event {
+                                userdata,
+                                error: e.downcast().map_err(Error::trap)?,
+                                type_,
+                                fd_readwrite: fd_readwrite_empty(),
+                            },
+                        }
+                    }
+                    SubscriptionResult::MonotonicClock(r) => {
+                        let type_ = types::Eventtype::Clock;
+                        types::Event {
                             userdata,
-                            error: e.downcast().map_err(Error::trap)?,
+                            error: match r {
+                                Ok(()) => types::Errno::Success,
+                                Err(e) => e.downcast().map_err(Error::trap)?,
+                            },
                             type_,
                             fd_readwrite: fd_readwrite_empty(),
-                        },
+                        }
                     }
-                }
-                SubscriptionResult::MonotonicClock(r) => {
-                    let type_ = types::Eventtype::Clock;
-                    types::Event {
-                        userdata,
-                        error: match r {
-                            Ok(()) => types::Errno::Success,
-                            Err(e) => e.downcast().map_err(Error::trap)?,
-                        },
-                        type_,
-                        fd_readwrite: fd_readwrite_empty(),
-                    }
-                }
-            })?;
+                },
+            )?;
         }
 
         Ok(num_results.try_into().expect("results fit into memory"))
     }
 
-    async fn proc_exit(&mut self, status: types::Exitcode) -> anyhow::Error {
+    async fn proc_exit(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        status: types::Exitcode,
+    ) -> anyhow::Error {
         // Check that the status is within WASI's range.
         if status < 126 {
             I32Exit(status as i32).into()
@@ -1065,21 +1133,26 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
         }
     }
 
-    async fn proc_raise(&mut self, _sig: types::Signal) -> Result<(), Error> {
+    async fn proc_raise(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        _sig: types::Signal,
+    ) -> Result<(), Error> {
         Err(Error::trap(anyhow::Error::msg("proc_raise unsupported")))
     }
 
-    async fn sched_yield(&mut self) -> Result<(), Error> {
+    async fn sched_yield(&mut self, _memory: &mut GuestMemory<'_>) -> Result<(), Error> {
         self.sched.sched_yield().await
     }
 
-    async fn random_get<'a>(
+    async fn random_get(
         &mut self,
-        buf: &GuestPtr<'a, u8>,
+        memory: &mut GuestMemory<'_>,
+        buf: GuestPtr<u8>,
         buf_len: types::Size,
     ) -> Result<(), Error> {
         let buf = buf.as_array(buf_len);
-        if buf.is_shared_memory() {
+        if memory.is_shared_memory() {
             // If the Wasm memory is shared, copy to an intermediate buffer to
             // avoid Rust unsafety (i.e., the called function could rely on
             // `&mut [u8]`'s exclusive ownership which is not guaranteed due to
@@ -1089,17 +1162,14 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
                 let len = (buf.len() - copied).min(MAX_SHARED_BUFFER_SIZE as u32);
                 let mut tmp = vec![0; len as usize];
                 self.random.lock().unwrap().try_fill_bytes(&mut tmp)?;
-                let dest = buf
-                    .get_range(copied..copied + len)
-                    .unwrap()
-                    .as_unsafe_slice_mut()?;
-                dest.copy_from_slice(&tmp)?;
+                let dest = buf.get_range(copied..copied + len).unwrap();
+                memory.copy_from_slice(&tmp, dest)?;
                 copied += len;
             }
         } else {
             // If the Wasm memory is non-shared, copy directly into the linear
             // memory.
-            let mem = &mut buf.as_slice_mut()?.unwrap();
+            let mem = &mut memory.as_slice_mut(buf)?.unwrap();
             self.random.lock().unwrap().try_fill_bytes(mem)?;
         }
         Ok(())
@@ -1107,6 +1177,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
 
     async fn sock_accept(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         fd: types::Fd,
         flags: types::Fdflags,
     ) -> Result<types::Fd, Error> {
@@ -1117,10 +1188,11 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
         Ok(types::Fd::from(fd))
     }
 
-    async fn sock_recv<'a>(
+    async fn sock_recv(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         fd: types::Fd,
-        ri_data: &types::IovecArray<'a>,
+        ri_data: types::IovecArray,
         ri_flags: types::Riflags,
     ) -> Result<(types::Size, types::Roflags), Error> {
         let f = self.table().get_file(u32::from(fd))?;
@@ -1129,7 +1201,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
             .iter()
             .map(|iov_ptr| {
                 let iov_ptr = iov_ptr?;
-                let iov: types::Iovec = iov_ptr.read()?;
+                let iov: types::Iovec = memory.read(iov_ptr)?;
                 Ok(iov.buf.as_array(iov.buf_len))
             })
             .collect::<Result<_, Error>>()?;
@@ -1146,11 +1218,7 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
         //   since we do not know here if `&dyn WasiFile` does anything else
         //   (e.g., read), we cautiously incur some performance overhead by
         //   copying twice.
-        let is_shared_memory = iovs
-            .iter()
-            .next()
-            .and_then(|s| Some(s.is_shared_memory()))
-            .unwrap_or(false);
+        let is_shared_memory = memory.is_shared_memory();
         let (bytes_read, ro_flags) = if is_shared_memory {
             // For shared memory, read into an intermediate buffer. Only the
             // first iov will be filled and even then the read is capped by the
@@ -1162,9 +1230,10 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
                     .file
                     .sock_recv(&mut [IoSliceMut::new(&mut buffer)], RiFlags::from(ri_flags))
                     .await?;
-                iov.get_range(0..bytes_read.try_into()?)
-                    .expect("it should always be possible to slice the iov smaller")
-                    .copy_from_slice(&buffer[0..bytes_read.try_into()?])?;
+                let iov = iov
+                    .get_range(0..bytes_read.try_into()?)
+                    .expect("it should always be possible to slice the iov smaller");
+                memory.copy_from_slice(&buffer[0..bytes_read.try_into()?], iov)?;
                 (bytes_read, ro_flags)
             } else {
                 return Ok((0, RoFlags::empty().into()));
@@ -1174,38 +1243,35 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
             // Wiggle's internal borrow checker to ensure no overlaps. We assume
             // here that, because the memory is not shared, there are no other
             // threads to access it while it is written to.
-            let mut guest_slices: Vec<wiggle::GuestSliceMut<u8>> = iovs
-                .into_iter()
-                .map(|iov| Ok(iov.as_slice_mut()?.unwrap()))
-                .collect::<Result<_, Error>>()?;
+            let guest_slice: &mut [u8] = match iovs.into_iter().filter(|iov| iov.len() > 0).next() {
+                Some(iov) => memory.as_slice_mut(iov)?.unwrap(),
+                None => &mut [],
+            };
 
             // Read directly into the Wasm memory.
-            let mut ioslices: Vec<IoSliceMut> = guest_slices
-                .iter_mut()
-                .map(|s| IoSliceMut::new(&mut *s))
-                .collect();
             f.file
-                .sock_recv(&mut ioslices, RiFlags::from(ri_flags))
+                .sock_recv(&mut [IoSliceMut::new(guest_slice)], RiFlags::from(ri_flags))
                 .await?
         };
 
         Ok((types::Size::try_from(bytes_read)?, ro_flags.into()))
     }
 
-    async fn sock_send<'a>(
+    async fn sock_send(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         fd: types::Fd,
-        si_data: &types::CiovecArray<'a>,
+        si_data: types::CiovecArray,
         _si_flags: types::Siflags,
     ) -> Result<types::Size, Error> {
         let f = self.table().get_file(u32::from(fd))?;
 
-        let guest_slices: Vec<wiggle::GuestCow<u8>> = si_data
+        let guest_slices: Vec<Cow<[u8]>> = si_data
             .iter()
             .map(|iov_ptr| {
                 let iov_ptr = iov_ptr?;
-                let iov: types::Ciovec = iov_ptr.read()?;
-                Ok(iov.buf.as_array(iov.buf_len).as_cow()?)
+                let iov: types::Ciovec = memory.read(iov_ptr)?;
+                Ok(memory.as_cow(iov.buf.as_array(iov.buf_len))?)
             })
             .collect::<Result<_, Error>>()?;
 
@@ -1218,7 +1284,12 @@ impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx {
         Ok(types::Size::try_from(bytes_written)?)
     }
 
-    async fn sock_shutdown(&mut self, fd: types::Fd, how: types::Sdflags) -> Result<(), Error> {
+    async fn sock_shutdown(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        how: types::Sdflags,
+    ) -> Result<(), Error> {
         let f = self.table().get_file(u32::from(fd))?;
 
         f.file.sock_shutdown(SdFlags::from(how)).await
diff --git a/crates/wasi-common/src/snapshots/preview_1/error.rs b/crates/wasi-common/src/snapshots/preview_1/error.rs
index f0b7cdf4ad94..f5b8afcfcce0 100644
--- a/crates/wasi-common/src/snapshots/preview_1/error.rs
+++ b/crates/wasi-common/src/snapshots/preview_1/error.rs
@@ -216,6 +216,7 @@ impl From<std::io::Error> for Error {
                 std::io::ErrorKind::PermissionDenied => Errno::Perm.into(),
                 std::io::ErrorKind::AlreadyExists => Errno::Exist.into(),
                 std::io::ErrorKind::InvalidInput => Errno::Inval.into(),
+                std::io::ErrorKind::WouldBlock => Errno::Again.into(),
                 _ => Error::trap(anyhow::anyhow!(err).context("Unknown OS error")),
             },
         }
diff --git a/crates/wasi-common/src/string_array.rs b/crates/wasi-common/src/string_array.rs
index 557784a9fff7..f35efe032c85 100644
--- a/crates/wasi-common/src/string_array.rs
+++ b/crates/wasi-common/src/string_array.rs
@@ -1,5 +1,5 @@
 use crate::{Error, ErrorExt};
-use wiggle::GuestPtr;
+use wiggle::{GuestMemory, GuestPtr};
 
 pub struct StringArray {
     elems: Vec<String>,
@@ -45,10 +45,11 @@ impl StringArray {
             .sum::<usize>() as u32
     }
 
-    pub fn write_to_guest<'a>(
+    pub fn write_to_guest(
         &self,
-        buffer: &GuestPtr<'a, u8>,
-        element_heads: &GuestPtr<'a, GuestPtr<'a, u8>>,
+        memory: &mut GuestMemory<'_>,
+        buffer: GuestPtr<u8>,
+        element_heads: GuestPtr<GuestPtr<u8>>,
     ) -> Result<(), Error> {
         let element_heads = element_heads.as_array(self.number_elements());
         let buffer = buffer.as_array(self.cumulative_size());
@@ -60,13 +61,13 @@ impl StringArray {
                 let elem_buffer = buffer
                     .get_range(cursor..(cursor + len))
                     .ok_or(Error::invalid_argument())?; // Elements don't fit in buffer provided
-                elem_buffer.copy_from_slice(bytes)?;
+                memory.copy_from_slice(bytes, elem_buffer)?;
             }
-            buffer
-                .get(cursor + len)
-                .ok_or(Error::invalid_argument())?
-                .write(0)?; // 0 terminate
-            head?.write(buffer.get(cursor).expect("already validated"))?;
+            memory.write(
+                buffer.get(cursor + len).ok_or(Error::invalid_argument())?,
+                0,
+            )?; // 0 terminate
+            memory.write(head?, buffer.get(cursor).expect("already validated"))?;
             cursor += len + 1;
         }
         Ok(())
diff --git a/crates/wasi-common/src/sync/clocks.rs b/crates/wasi-common/src/sync/clocks.rs
new file mode 100644
index 000000000000..1b85fe1140a4
--- /dev/null
+++ b/crates/wasi-common/src/sync/clocks.rs
@@ -0,0 +1,41 @@
+use crate::clocks::{WasiClocks, WasiMonotonicClock, WasiSystemClock};
+use cap_std::time::{Duration, Instant, SystemTime};
+use cap_std::{ambient_authority, AmbientAuthority};
+use cap_time_ext::{MonotonicClockExt, SystemClockExt};
+
+pub struct SystemClock(cap_std::time::SystemClock);
+
+impl SystemClock {
+    pub fn new(ambient_authority: AmbientAuthority) -> Self {
+        SystemClock(cap_std::time::SystemClock::new(ambient_authority))
+    }
+}
+impl WasiSystemClock for SystemClock {
+    fn resolution(&self) -> Duration {
+        self.0.resolution()
+    }
+    fn now(&self, precision: Duration) -> SystemTime {
+        self.0.now_with(precision)
+    }
+}
+
+pub struct MonotonicClock(cap_std::time::MonotonicClock);
+impl MonotonicClock {
+    pub fn new(ambient_authority: AmbientAuthority) -> Self {
+        MonotonicClock(cap_std::time::MonotonicClock::new(ambient_authority))
+    }
+}
+impl WasiMonotonicClock for MonotonicClock {
+    fn resolution(&self) -> Duration {
+        self.0.resolution()
+    }
+    fn now(&self, precision: Duration) -> Instant {
+        self.0.now_with(precision)
+    }
+}
+
+pub fn clocks_ctx() -> WasiClocks {
+    WasiClocks::new()
+        .with_system(SystemClock::new(ambient_authority()))
+        .with_monotonic(MonotonicClock::new(ambient_authority()))
+}
diff --git a/crates/wasi-common/src/sync/dir.rs b/crates/wasi-common/src/sync/dir.rs
new file mode 100644
index 000000000000..b532705d6e9c
--- /dev/null
+++ b/crates/wasi-common/src/sync/dir.rs
@@ -0,0 +1,461 @@
+use crate::sync::file::{filetype_from, File};
+use crate::{
+    dir::{ReaddirCursor, ReaddirEntity, WasiDir},
+    file::{FdFlags, FileType, Filestat, OFlags},
+    Error, ErrorExt,
+};
+use cap_fs_ext::{DirEntryExt, DirExt, MetadataExt, OpenOptionsMaybeDirExt, SystemTimeSpec};
+use cap_std::fs;
+use std::any::Any;
+use std::path::{Path, PathBuf};
+use system_interface::fs::GetSetFdFlags;
+
+pub struct Dir(fs::Dir);
+
+pub enum OpenResult {
+    File(File),
+    Dir(Dir),
+}
+
+impl Dir {
+    pub fn from_cap_std(dir: fs::Dir) -> Self {
+        Dir(dir)
+    }
+
+    pub fn open_file_(
+        &self,
+        symlink_follow: bool,
+        path: &str,
+        oflags: OFlags,
+        read: bool,
+        write: bool,
+        fdflags: FdFlags,
+    ) -> Result<OpenResult, Error> {
+        use cap_fs_ext::{FollowSymlinks, OpenOptionsFollowExt};
+
+        let mut opts = fs::OpenOptions::new();
+        opts.maybe_dir(true);
+
+        if oflags.contains(OFlags::CREATE | OFlags::EXCLUSIVE) {
+            opts.create_new(true);
+            opts.write(true);
+        } else if oflags.contains(OFlags::CREATE) {
+            opts.create(true);
+            opts.write(true);
+        }
+        if oflags.contains(OFlags::TRUNCATE) {
+            opts.truncate(true);
+        }
+        if read {
+            opts.read(true);
+        }
+        if write {
+            opts.write(true);
+        } else {
+            // If not opened write, open read. This way the OS lets us open the file.
+            // If FileCaps::READ is not set, read calls will be rejected at the
+            // get_cap check.
+            opts.read(true);
+        }
+        if fdflags.contains(FdFlags::APPEND) {
+            opts.append(true);
+        }
+
+        if symlink_follow {
+            opts.follow(FollowSymlinks::Yes);
+        } else {
+            opts.follow(FollowSymlinks::No);
+        }
+        // the DSYNC, SYNC, and RSYNC flags are ignored! We do not
+        // have support for them in cap-std yet.
+        // ideally OpenOptions would just support this though:
+        // https://github.com/bytecodealliance/cap-std/issues/146
+        if fdflags.intersects(
+            crate::file::FdFlags::DSYNC | crate::file::FdFlags::SYNC | crate::file::FdFlags::RSYNC,
+        ) {
+            return Err(Error::not_supported().context("SYNC family of FdFlags"));
+        }
+
+        if oflags.contains(OFlags::DIRECTORY) {
+            if oflags.contains(OFlags::CREATE)
+                || oflags.contains(OFlags::EXCLUSIVE)
+                || oflags.contains(OFlags::TRUNCATE)
+            {
+                return Err(Error::invalid_argument().context("directory oflags"));
+            }
+        }
+
+        let mut f = self.0.open_with(Path::new(path), &opts)?;
+        if f.metadata()?.is_dir() {
+            Ok(OpenResult::Dir(Dir::from_cap_std(fs::Dir::from_std_file(
+                f.into_std(),
+            ))))
+        } else if oflags.contains(OFlags::DIRECTORY) {
+            Err(Error::not_dir().context("expected directory but got file"))
+        } else {
+            // NONBLOCK does not have an OpenOption either, but we can patch that on with set_fd_flags:
+            if fdflags.contains(crate::file::FdFlags::NONBLOCK) {
+                let set_fd_flags = f.new_set_fd_flags(system_interface::fs::FdFlags::NONBLOCK)?;
+                f.set_fd_flags(set_fd_flags)?;
+            }
+            Ok(OpenResult::File(File::from_cap_std(f)))
+        }
+    }
+
+    pub fn rename_(&self, src_path: &str, dest_dir: &Self, dest_path: &str) -> Result<(), Error> {
+        self.0
+            .rename(Path::new(src_path), &dest_dir.0, Path::new(dest_path))?;
+        Ok(())
+    }
+    pub fn hard_link_(
+        &self,
+        src_path: &str,
+        target_dir: &Self,
+        target_path: &str,
+    ) -> Result<(), Error> {
+        let src_path = Path::new(src_path);
+        let target_path = Path::new(target_path);
+        self.0.hard_link(src_path, &target_dir.0, target_path)?;
+        Ok(())
+    }
+}
+
+#[wiggle::async_trait]
+impl WasiDir for Dir {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+    async fn open_file(
+        &self,
+        symlink_follow: bool,
+        path: &str,
+        oflags: OFlags,
+        read: bool,
+        write: bool,
+        fdflags: FdFlags,
+    ) -> Result<crate::dir::OpenResult, Error> {
+        let f = self.open_file_(symlink_follow, path, oflags, read, write, fdflags)?;
+        match f {
+            OpenResult::File(f) => Ok(crate::dir::OpenResult::File(Box::new(f))),
+            OpenResult::Dir(d) => Ok(crate::dir::OpenResult::Dir(Box::new(d))),
+        }
+    }
+
+    async fn create_dir(&self, path: &str) -> Result<(), Error> {
+        self.0.create_dir(Path::new(path))?;
+        Ok(())
+    }
+    async fn readdir(
+        &self,
+        cursor: ReaddirCursor,
+    ) -> Result<Box<dyn Iterator<Item = Result<ReaddirEntity, Error>> + Send>, Error> {
+        // We need to keep a full-fidelity io Error around to check for a special failure mode
+        // on windows, but also this function can fail due to an illegal byte sequence in a
+        // filename, which we can't construct an io Error to represent.
+        enum ReaddirError {
+            Io(std::io::Error),
+            IllegalSequence,
+        }
+        impl From<std::io::Error> for ReaddirError {
+            fn from(e: std::io::Error) -> ReaddirError {
+                ReaddirError::Io(e)
+            }
+        }
+
+        // cap_std's read_dir does not include . and .., we should prepend these.
+        // Why does the Ok contain a tuple? We can't construct a cap_std::fs::DirEntry, and we don't
+        // have enough info to make a ReaddirEntity yet.
+        let dir_meta = self.0.dir_metadata()?;
+        let rd = vec![
+            {
+                let name = ".".to_owned();
+                Ok::<_, ReaddirError>((FileType::Directory, dir_meta.ino(), name))
+            },
+            {
+                let name = "..".to_owned();
+                Ok((FileType::Directory, dir_meta.ino(), name))
+            },
+        ]
+        .into_iter()
+        .chain({
+            // Now process the `DirEntry`s:
+            let entries = self.0.entries()?.map(|entry| {
+                let entry = entry?;
+                let meta = entry.full_metadata()?;
+                let inode = meta.ino();
+                let filetype = filetype_from(&meta.file_type());
+                let name = entry
+                    .file_name()
+                    .into_string()
+                    .map_err(|_| ReaddirError::IllegalSequence)?;
+                Ok((filetype, inode, name))
+            });
+
+            // On Windows, filter out files like `C:\DumpStack.log.tmp` which we
+            // can't get a full metadata for.
+            #[cfg(windows)]
+            let entries = entries.filter(|entry| {
+                use windows_sys::Win32::Foundation::{
+                    ERROR_ACCESS_DENIED, ERROR_SHARING_VIOLATION,
+                };
+                if let Err(ReaddirError::Io(err)) = entry {
+                    if err.raw_os_error() == Some(ERROR_SHARING_VIOLATION as i32)
+                        || err.raw_os_error() == Some(ERROR_ACCESS_DENIED as i32)
+                    {
+                        return false;
+                    }
+                }
+                true
+            });
+
+            entries
+        })
+        // Enumeration of the iterator makes it possible to define the ReaddirCursor
+        .enumerate()
+        .map(|(ix, r)| match r {
+            Ok((filetype, inode, name)) => Ok(ReaddirEntity {
+                next: ReaddirCursor::from(ix as u64 + 1),
+                filetype,
+                inode,
+                name,
+            }),
+            Err(ReaddirError::Io(e)) => Err(e.into()),
+            Err(ReaddirError::IllegalSequence) => Err(Error::illegal_byte_sequence()),
+        })
+        .skip(u64::from(cursor) as usize);
+
+        Ok(Box::new(rd))
+    }
+
+    async fn symlink(&self, src_path: &str, dest_path: &str) -> Result<(), Error> {
+        self.0.symlink(src_path, dest_path)?;
+        Ok(())
+    }
+    async fn remove_dir(&self, path: &str) -> Result<(), Error> {
+        self.0.remove_dir(Path::new(path))?;
+        Ok(())
+    }
+
+    async fn unlink_file(&self, path: &str) -> Result<(), Error> {
+        self.0.remove_file_or_symlink(Path::new(path))?;
+        Ok(())
+    }
+    async fn read_link(&self, path: &str) -> Result<PathBuf, Error> {
+        let link = self.0.read_link(Path::new(path))?;
+        Ok(link)
+    }
+    async fn get_filestat(&self) -> Result<Filestat, Error> {
+        let meta = self.0.dir_metadata()?;
+        Ok(Filestat {
+            device_id: meta.dev(),
+            inode: meta.ino(),
+            filetype: filetype_from(&meta.file_type()),
+            nlink: meta.nlink(),
+            size: meta.len(),
+            atim: meta.accessed().map(|t| Some(t.into_std())).unwrap_or(None),
+            mtim: meta.modified().map(|t| Some(t.into_std())).unwrap_or(None),
+            ctim: meta.created().map(|t| Some(t.into_std())).unwrap_or(None),
+        })
+    }
+    async fn get_path_filestat(
+        &self,
+        path: &str,
+        follow_symlinks: bool,
+    ) -> Result<Filestat, Error> {
+        let meta = if follow_symlinks {
+            self.0.metadata(Path::new(path))?
+        } else {
+            self.0.symlink_metadata(Path::new(path))?
+        };
+        Ok(Filestat {
+            device_id: meta.dev(),
+            inode: meta.ino(),
+            filetype: filetype_from(&meta.file_type()),
+            nlink: meta.nlink(),
+            size: meta.len(),
+            atim: meta.accessed().map(|t| Some(t.into_std())).unwrap_or(None),
+            mtim: meta.modified().map(|t| Some(t.into_std())).unwrap_or(None),
+            ctim: meta.created().map(|t| Some(t.into_std())).unwrap_or(None),
+        })
+    }
+    async fn rename(
+        &self,
+        src_path: &str,
+        dest_dir: &dyn WasiDir,
+        dest_path: &str,
+    ) -> Result<(), Error> {
+        let dest_dir = dest_dir
+            .as_any()
+            .downcast_ref::<Self>()
+            .ok_or(Error::badf().context("failed downcast to cap-std Dir"))?;
+        self.rename_(src_path, dest_dir, dest_path)
+    }
+    async fn hard_link(
+        &self,
+        src_path: &str,
+        target_dir: &dyn WasiDir,
+        target_path: &str,
+    ) -> Result<(), Error> {
+        let target_dir = target_dir
+            .as_any()
+            .downcast_ref::<Self>()
+            .ok_or(Error::badf().context("failed downcast to cap-std Dir"))?;
+        self.hard_link_(src_path, target_dir, target_path)
+    }
+    async fn set_times(
+        &self,
+        path: &str,
+        atime: Option<crate::SystemTimeSpec>,
+        mtime: Option<crate::SystemTimeSpec>,
+        follow_symlinks: bool,
+    ) -> Result<(), Error> {
+        if follow_symlinks {
+            self.0.set_times(
+                Path::new(path),
+                convert_systimespec(atime),
+                convert_systimespec(mtime),
+            )?;
+        } else {
+            self.0.set_symlink_times(
+                Path::new(path),
+                convert_systimespec(atime),
+                convert_systimespec(mtime),
+            )?;
+        }
+        Ok(())
+    }
+}
+
+fn convert_systimespec(t: Option<crate::SystemTimeSpec>) -> Option<SystemTimeSpec> {
+    match t {
+        Some(crate::SystemTimeSpec::Absolute(t)) => Some(SystemTimeSpec::Absolute(t)),
+        Some(crate::SystemTimeSpec::SymbolicNow) => Some(SystemTimeSpec::SymbolicNow),
+        None => None,
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::Dir;
+    use crate::file::{FdFlags, OFlags};
+    use cap_std::ambient_authority;
+    #[test]
+    fn scratch_dir() {
+        let tempdir = tempfile::Builder::new()
+            .prefix("cap-std-sync")
+            .tempdir()
+            .expect("create temporary dir");
+        let preopen_dir = cap_std::fs::Dir::open_ambient_dir(tempdir.path(), ambient_authority())
+            .expect("open ambient temporary dir");
+        let preopen_dir = Dir::from_cap_std(preopen_dir);
+        run(crate::WasiDir::open_file(
+            &preopen_dir,
+            false,
+            ".",
+            OFlags::empty(),
+            false,
+            false,
+            FdFlags::empty(),
+        ))
+        .expect("open the same directory via WasiDir abstraction");
+    }
+
+    // Readdir does not work on windows, so we won't test it there.
+    #[cfg(not(windows))]
+    #[test]
+    fn readdir() {
+        use crate::dir::{ReaddirCursor, ReaddirEntity, WasiDir};
+        use crate::file::{FdFlags, FileType, OFlags};
+        use std::collections::HashMap;
+
+        fn readdir_into_map(dir: &dyn WasiDir) -> HashMap<String, ReaddirEntity> {
+            let mut out = HashMap::new();
+            for readdir_result in
+                run(dir.readdir(ReaddirCursor::from(0))).expect("readdir succeeds")
+            {
+                let entity = readdir_result.expect("readdir entry is valid");
+                out.insert(entity.name.clone(), entity);
+            }
+            out
+        }
+
+        let tempdir = tempfile::Builder::new()
+            .prefix("cap-std-sync")
+            .tempdir()
+            .expect("create temporary dir");
+        let preopen_dir = cap_std::fs::Dir::open_ambient_dir(tempdir.path(), ambient_authority())
+            .expect("open ambient temporary dir");
+        let preopen_dir = Dir::from_cap_std(preopen_dir);
+
+        let entities = readdir_into_map(&preopen_dir);
+        assert_eq!(
+            entities.len(),
+            2,
+            "should just be . and .. in empty dir: {entities:?}"
+        );
+        assert!(entities.get(".").is_some());
+        assert!(entities.get("..").is_some());
+
+        run(preopen_dir.open_file(
+            false,
+            "file1",
+            OFlags::CREATE,
+            true,
+            false,
+            FdFlags::empty(),
+        ))
+        .expect("create file1");
+
+        let entities = readdir_into_map(&preopen_dir);
+        assert_eq!(entities.len(), 3, "should be ., .., file1 {entities:?}");
+        assert_eq!(
+            entities.get(".").expect(". entry").filetype,
+            FileType::Directory
+        );
+        assert_eq!(
+            entities.get("..").expect(".. entry").filetype,
+            FileType::Directory
+        );
+        assert_eq!(
+            entities.get("file1").expect("file1 entry").filetype,
+            FileType::RegularFile
+        );
+    }
+
+    fn run<F: std::future::Future>(future: F) -> F::Output {
+        use std::pin::Pin;
+        use std::task::{Context, Poll, RawWaker, RawWakerVTable, Waker};
+
+        let mut f = Pin::from(Box::new(future));
+        let waker = dummy_waker();
+        let mut cx = Context::from_waker(&waker);
+        match f.as_mut().poll(&mut cx) {
+            Poll::Ready(val) => return val,
+            Poll::Pending => {
+                panic!("Cannot wait on pending future: must enable wiggle \"async\" future and execute on an async Store")
+            }
+        }
+
+        fn dummy_waker() -> Waker {
+            return unsafe { Waker::from_raw(clone(5 as *const _)) };
+
+            unsafe fn clone(ptr: *const ()) -> RawWaker {
+                assert_eq!(ptr as usize, 5);
+                const VTABLE: RawWakerVTable = RawWakerVTable::new(clone, wake, wake_by_ref, drop);
+                RawWaker::new(ptr, &VTABLE)
+            }
+
+            unsafe fn wake(ptr: *const ()) {
+                assert_eq!(ptr as usize, 5);
+            }
+
+            unsafe fn wake_by_ref(ptr: *const ()) {
+                assert_eq!(ptr as usize, 5);
+            }
+
+            unsafe fn drop(ptr: *const ()) {
+                assert_eq!(ptr as usize, 5);
+            }
+        }
+    }
+}
diff --git a/crates/wasi-common/src/sync/file.rs b/crates/wasi-common/src/sync/file.rs
new file mode 100644
index 000000000000..2ee6f99d1a82
--- /dev/null
+++ b/crates/wasi-common/src/sync/file.rs
@@ -0,0 +1,250 @@
+use crate::{
+    file::{Advice, FdFlags, FileType, Filestat, WasiFile},
+    Error, ErrorExt,
+};
+use cap_fs_ext::MetadataExt;
+use fs_set_times::{SetTimes, SystemTimeSpec};
+use io_lifetimes::AsFilelike;
+use std::any::Any;
+use std::io::{self, IsTerminal};
+use system_interface::{
+    fs::{FileIoExt, GetSetFdFlags},
+    io::{IoExt, ReadReady},
+};
+
+pub struct File(cap_std::fs::File);
+
+impl File {
+    pub fn from_cap_std(file: cap_std::fs::File) -> Self {
+        File(file)
+    }
+}
+
+#[wiggle::async_trait]
+impl WasiFile for File {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+    #[cfg(unix)]
+    fn pollable(&self) -> Option<rustix::fd::BorrowedFd> {
+        Some(self.0.as_fd())
+    }
+    #[cfg(windows)]
+    fn pollable(&self) -> Option<io_extras::os::windows::RawHandleOrSocket> {
+        Some(self.0.as_raw_handle_or_socket())
+    }
+    async fn datasync(&self) -> Result<(), Error> {
+        self.0.sync_data()?;
+        Ok(())
+    }
+    async fn sync(&self) -> Result<(), Error> {
+        self.0.sync_all()?;
+        Ok(())
+    }
+    async fn get_filetype(&self) -> Result<FileType, Error> {
+        let meta = self.0.metadata()?;
+        Ok(filetype_from(&meta.file_type()))
+    }
+    async fn get_fdflags(&self) -> Result<FdFlags, Error> {
+        let fdflags = get_fd_flags(&self.0)?;
+        Ok(fdflags)
+    }
+    async fn set_fdflags(&mut self, fdflags: FdFlags) -> Result<(), Error> {
+        if fdflags.intersects(
+            crate::file::FdFlags::DSYNC | crate::file::FdFlags::SYNC | crate::file::FdFlags::RSYNC,
+        ) {
+            return Err(Error::invalid_argument().context("cannot set DSYNC, SYNC, or RSYNC flag"));
+        }
+        let set_fd_flags = self.0.new_set_fd_flags(to_sysif_fdflags(fdflags))?;
+        self.0.set_fd_flags(set_fd_flags)?;
+        Ok(())
+    }
+    async fn get_filestat(&self) -> Result<Filestat, Error> {
+        let meta = self.0.metadata()?;
+        Ok(Filestat {
+            device_id: meta.dev(),
+            inode: meta.ino(),
+            filetype: filetype_from(&meta.file_type()),
+            nlink: meta.nlink(),
+            size: meta.len(),
+            atim: meta.accessed().map(|t| Some(t.into_std())).unwrap_or(None),
+            mtim: meta.modified().map(|t| Some(t.into_std())).unwrap_or(None),
+            ctim: meta.created().map(|t| Some(t.into_std())).unwrap_or(None),
+        })
+    }
+    async fn set_filestat_size(&self, size: u64) -> Result<(), Error> {
+        self.0.set_len(size)?;
+        Ok(())
+    }
+    async fn advise(&self, offset: u64, len: u64, advice: Advice) -> Result<(), Error> {
+        self.0.advise(offset, len, convert_advice(advice))?;
+        Ok(())
+    }
+    async fn set_times(
+        &self,
+        atime: Option<crate::SystemTimeSpec>,
+        mtime: Option<crate::SystemTimeSpec>,
+    ) -> Result<(), Error> {
+        self.0
+            .set_times(convert_systimespec(atime), convert_systimespec(mtime))?;
+        Ok(())
+    }
+    async fn read_vectored<'a>(&self, bufs: &mut [io::IoSliceMut<'a>]) -> Result<u64, Error> {
+        let n = self.0.read_vectored(bufs)?;
+        Ok(n.try_into()?)
+    }
+    async fn read_vectored_at<'a>(
+        &self,
+        bufs: &mut [io::IoSliceMut<'a>],
+        offset: u64,
+    ) -> Result<u64, Error> {
+        let n = self.0.read_vectored_at(bufs, offset)?;
+        Ok(n.try_into()?)
+    }
+    async fn write_vectored<'a>(&self, bufs: &[io::IoSlice<'a>]) -> Result<u64, Error> {
+        let n = self.0.write_vectored(bufs)?;
+        Ok(n.try_into()?)
+    }
+    async fn write_vectored_at<'a>(
+        &self,
+        bufs: &[io::IoSlice<'a>],
+        offset: u64,
+    ) -> Result<u64, Error> {
+        if bufs.iter().map(|i| i.len()).sum::<usize>() == 0 {
+            return Ok(0);
+        }
+        let n = self.0.write_vectored_at(bufs, offset)?;
+        Ok(n.try_into()?)
+    }
+    async fn seek(&self, pos: std::io::SeekFrom) -> Result<u64, Error> {
+        Ok(self.0.seek(pos)?)
+    }
+    async fn peek(&self, buf: &mut [u8]) -> Result<u64, Error> {
+        let n = self.0.peek(buf)?;
+        Ok(n.try_into()?)
+    }
+    fn num_ready_bytes(&self) -> Result<u64, Error> {
+        Ok(self.0.num_ready_bytes()?)
+    }
+    fn isatty(&self) -> bool {
+        #[cfg(unix)]
+        return self.0.as_fd().is_terminal();
+        #[cfg(windows)]
+        return self.0.as_handle().is_terminal();
+    }
+}
+
+pub fn filetype_from(ft: &cap_std::fs::FileType) -> FileType {
+    use cap_fs_ext::FileTypeExt;
+    if ft.is_dir() {
+        FileType::Directory
+    } else if ft.is_symlink() {
+        FileType::SymbolicLink
+    } else if ft.is_socket() {
+        if ft.is_block_device() {
+            FileType::SocketDgram
+        } else {
+            FileType::SocketStream
+        }
+    } else if ft.is_block_device() {
+        FileType::BlockDevice
+    } else if ft.is_char_device() {
+        FileType::CharacterDevice
+    } else if ft.is_file() {
+        FileType::RegularFile
+    } else {
+        FileType::Unknown
+    }
+}
+
+#[cfg(windows)]
+use io_lifetimes::{AsHandle, BorrowedHandle};
+#[cfg(windows)]
+impl AsHandle for File {
+    fn as_handle(&self) -> BorrowedHandle<'_> {
+        self.0.as_handle()
+    }
+}
+
+#[cfg(windows)]
+use io_extras::os::windows::{AsRawHandleOrSocket, RawHandleOrSocket};
+#[cfg(windows)]
+impl AsRawHandleOrSocket for File {
+    #[inline]
+    fn as_raw_handle_or_socket(&self) -> RawHandleOrSocket {
+        self.0.as_raw_handle_or_socket()
+    }
+}
+
+#[cfg(unix)]
+use io_lifetimes::{AsFd, BorrowedFd};
+
+#[cfg(unix)]
+impl AsFd for File {
+    fn as_fd(&self) -> BorrowedFd<'_> {
+        self.0.as_fd()
+    }
+}
+
+pub(crate) fn convert_systimespec(t: Option<crate::SystemTimeSpec>) -> Option<SystemTimeSpec> {
+    match t {
+        Some(crate::SystemTimeSpec::Absolute(t)) => Some(SystemTimeSpec::Absolute(t.into_std())),
+        Some(crate::SystemTimeSpec::SymbolicNow) => Some(SystemTimeSpec::SymbolicNow),
+        None => None,
+    }
+}
+
+pub(crate) fn to_sysif_fdflags(f: crate::file::FdFlags) -> system_interface::fs::FdFlags {
+    let mut out = system_interface::fs::FdFlags::empty();
+    if f.contains(crate::file::FdFlags::APPEND) {
+        out |= system_interface::fs::FdFlags::APPEND;
+    }
+    if f.contains(crate::file::FdFlags::DSYNC) {
+        out |= system_interface::fs::FdFlags::DSYNC;
+    }
+    if f.contains(crate::file::FdFlags::NONBLOCK) {
+        out |= system_interface::fs::FdFlags::NONBLOCK;
+    }
+    if f.contains(crate::file::FdFlags::RSYNC) {
+        out |= system_interface::fs::FdFlags::RSYNC;
+    }
+    if f.contains(crate::file::FdFlags::SYNC) {
+        out |= system_interface::fs::FdFlags::SYNC;
+    }
+    out
+}
+
+/// Return the file-descriptor flags for a given file-like object.
+///
+/// This returns the flags needed to implement [`WasiFile::get_fdflags`].
+pub fn get_fd_flags<Filelike: AsFilelike>(f: Filelike) -> io::Result<crate::file::FdFlags> {
+    let f = f.as_filelike().get_fd_flags()?;
+    let mut out = crate::file::FdFlags::empty();
+    if f.contains(system_interface::fs::FdFlags::APPEND) {
+        out |= crate::file::FdFlags::APPEND;
+    }
+    if f.contains(system_interface::fs::FdFlags::DSYNC) {
+        out |= crate::file::FdFlags::DSYNC;
+    }
+    if f.contains(system_interface::fs::FdFlags::NONBLOCK) {
+        out |= crate::file::FdFlags::NONBLOCK;
+    }
+    if f.contains(system_interface::fs::FdFlags::RSYNC) {
+        out |= crate::file::FdFlags::RSYNC;
+    }
+    if f.contains(system_interface::fs::FdFlags::SYNC) {
+        out |= crate::file::FdFlags::SYNC;
+    }
+    Ok(out)
+}
+
+fn convert_advice(advice: Advice) -> system_interface::fs::Advice {
+    match advice {
+        Advice::Normal => system_interface::fs::Advice::Normal,
+        Advice::Sequential => system_interface::fs::Advice::Sequential,
+        Advice::Random => system_interface::fs::Advice::Random,
+        Advice::WillNeed => system_interface::fs::Advice::WillNeed,
+        Advice::DontNeed => system_interface::fs::Advice::DontNeed,
+        Advice::NoReuse => system_interface::fs::Advice::NoReuse,
+    }
+}
diff --git a/crates/wasi-common/src/sync/mod.rs b/crates/wasi-common/src/sync/mod.rs
new file mode 100644
index 000000000000..8fe5db70226d
--- /dev/null
+++ b/crates/wasi-common/src/sync/mod.rs
@@ -0,0 +1,138 @@
+//! The `wasi-cap-std-sync` crate provides impl of `WasiFile` and `WasiDir` in
+//! terms of `cap_std::fs::{File, Dir}`. These types provide sandboxed access
+//! to the local filesystem on both Unix and Windows.
+//!
+//! All syscalls are hidden behind the `cap-std` hierarchy, with the lone
+//! exception of the `sched` implementation, which is provided for both unix
+//! and windows in separate modules.
+//!
+//! Any `wasi_common::{WasiCtx, WasiCtxBuilder}` is interoperable with the
+//! implementations provided in `wasi_common::sync`. However, for convenience,
+//! this module provides its own `WasiCtxBuilder` that hooks up to all of the
+//! crate's components, i.e. it fills in all of the arguments to
+//! `WasiCtx::builder(...)`, presents `preopen_dir` in terms of
+//! `cap_std::fs::Dir`, and provides convenience methods for inheriting the
+//! parent process's stdio, args, and env.
+
+pub mod clocks;
+pub mod dir;
+pub mod file;
+pub mod net;
+pub mod sched;
+pub mod stdio;
+
+pub use cap_std::ambient_authority;
+pub use cap_std::fs::Dir;
+pub use cap_std::net::TcpListener;
+pub use clocks::clocks_ctx;
+pub use sched::sched_ctx;
+
+use self::net::Socket;
+use crate::{file::FileAccessMode, table::Table, Error, WasiCtx, WasiFile};
+use cap_rand::{Rng, RngCore, SeedableRng};
+use std::mem;
+use std::path::Path;
+
+pub struct WasiCtxBuilder {
+    ctx: WasiCtx,
+    built: bool,
+}
+
+impl WasiCtxBuilder {
+    pub fn new() -> Self {
+        WasiCtxBuilder {
+            ctx: WasiCtx::new(random_ctx(), clocks_ctx(), sched_ctx(), Table::new()),
+            built: false,
+        }
+    }
+    pub fn env(&mut self, var: &str, value: &str) -> Result<&mut Self, crate::StringArrayError> {
+        self.ctx.push_env(var, value)?;
+        Ok(self)
+    }
+    pub fn envs(&mut self, env: &[(String, String)]) -> Result<&mut Self, crate::StringArrayError> {
+        for (k, v) in env {
+            self.ctx.push_env(k, v)?;
+        }
+        Ok(self)
+    }
+    pub fn inherit_env(&mut self) -> Result<&mut Self, crate::StringArrayError> {
+        for (key, value) in std::env::vars() {
+            self.ctx.push_env(&key, &value)?;
+        }
+        Ok(self)
+    }
+    pub fn arg(&mut self, arg: &str) -> Result<&mut Self, crate::StringArrayError> {
+        self.ctx.push_arg(arg)?;
+        Ok(self)
+    }
+    pub fn args(&mut self, arg: &[String]) -> Result<&mut Self, crate::StringArrayError> {
+        for a in arg {
+            self.ctx.push_arg(&a)?;
+        }
+        Ok(self)
+    }
+    pub fn inherit_args(&mut self) -> Result<&mut Self, crate::StringArrayError> {
+        for arg in std::env::args() {
+            self.ctx.push_arg(&arg)?;
+        }
+        Ok(self)
+    }
+    pub fn stdin(&mut self, f: Box<dyn WasiFile>) -> &mut Self {
+        self.ctx.set_stdin(f);
+        self
+    }
+    pub fn stdout(&mut self, f: Box<dyn WasiFile>) -> &mut Self {
+        self.ctx.set_stdout(f);
+        self
+    }
+    pub fn stderr(&mut self, f: Box<dyn WasiFile>) -> &mut Self {
+        self.ctx.set_stderr(f);
+        self
+    }
+    pub fn inherit_stdin(&mut self) -> &mut Self {
+        self.stdin(Box::new(crate::sync::stdio::stdin()))
+    }
+    pub fn inherit_stdout(&mut self) -> &mut Self {
+        self.stdout(Box::new(crate::sync::stdio::stdout()))
+    }
+    pub fn inherit_stderr(&mut self) -> &mut Self {
+        self.stderr(Box::new(crate::sync::stdio::stderr()))
+    }
+    pub fn inherit_stdio(&mut self) -> &mut Self {
+        self.inherit_stdin().inherit_stdout().inherit_stderr()
+    }
+    pub fn preopened_dir(
+        &mut self,
+        dir: Dir,
+        guest_path: impl AsRef<Path>,
+    ) -> Result<&mut Self, Error> {
+        let dir = Box::new(crate::sync::dir::Dir::from_cap_std(dir));
+        self.ctx.push_preopened_dir(dir, guest_path)?;
+        Ok(self)
+    }
+    pub fn preopened_socket(
+        &mut self,
+        fd: u32,
+        socket: impl Into<Socket>,
+    ) -> Result<&mut Self, Error> {
+        let socket: Socket = socket.into();
+        let file: Box<dyn WasiFile> = socket.into();
+        self.ctx
+            .insert_file(fd, file, FileAccessMode::READ | FileAccessMode::WRITE);
+        Ok(self)
+    }
+    pub fn build(&mut self) -> WasiCtx {
+        assert!(!self.built);
+        let WasiCtxBuilder { ctx, .. } = mem::replace(self, Self::new());
+        self.built = true;
+        ctx
+    }
+}
+
+pub fn random_ctx() -> Box<dyn RngCore + Send + Sync> {
+    let mut rng = cap_rand::thread_rng(cap_rand::ambient_authority());
+    Box::new(cap_rand::rngs::StdRng::from_seed(rng.gen()))
+}
+
+#[cfg(feature = "wasmtime")]
+super::define_wasi!(block_on);
diff --git a/crates/wasi-common/src/sync/net.rs b/crates/wasi-common/src/sync/net.rs
new file mode 100644
index 000000000000..f35e53c37132
--- /dev/null
+++ b/crates/wasi-common/src/sync/net.rs
@@ -0,0 +1,399 @@
+use crate::{
+    file::{FdFlags, FileType, RiFlags, RoFlags, SdFlags, SiFlags, WasiFile},
+    Error, ErrorExt,
+};
+#[cfg(windows)]
+use io_extras::os::windows::{AsRawHandleOrSocket, RawHandleOrSocket};
+use io_lifetimes::AsSocketlike;
+#[cfg(unix)]
+use io_lifetimes::{AsFd, BorrowedFd};
+#[cfg(windows)]
+use io_lifetimes::{AsSocket, BorrowedSocket};
+use std::any::Any;
+use std::io;
+#[cfg(unix)]
+use system_interface::fs::GetSetFdFlags;
+use system_interface::io::IoExt;
+use system_interface::io::IsReadWrite;
+use system_interface::io::ReadReady;
+
+pub enum Socket {
+    TcpListener(cap_std::net::TcpListener),
+    TcpStream(cap_std::net::TcpStream),
+    #[cfg(unix)]
+    UnixStream(cap_std::os::unix::net::UnixStream),
+    #[cfg(unix)]
+    UnixListener(cap_std::os::unix::net::UnixListener),
+}
+
+impl From<cap_std::net::TcpListener> for Socket {
+    fn from(listener: cap_std::net::TcpListener) -> Self {
+        Self::TcpListener(listener)
+    }
+}
+
+impl From<cap_std::net::TcpStream> for Socket {
+    fn from(stream: cap_std::net::TcpStream) -> Self {
+        Self::TcpStream(stream)
+    }
+}
+
+#[cfg(unix)]
+impl From<cap_std::os::unix::net::UnixListener> for Socket {
+    fn from(listener: cap_std::os::unix::net::UnixListener) -> Self {
+        Self::UnixListener(listener)
+    }
+}
+
+#[cfg(unix)]
+impl From<cap_std::os::unix::net::UnixStream> for Socket {
+    fn from(stream: cap_std::os::unix::net::UnixStream) -> Self {
+        Self::UnixStream(stream)
+    }
+}
+
+#[cfg(unix)]
+impl From<Socket> for Box<dyn WasiFile> {
+    fn from(listener: Socket) -> Self {
+        match listener {
+            Socket::TcpListener(l) => Box::new(crate::sync::net::TcpListener::from_cap_std(l)),
+            Socket::UnixListener(l) => Box::new(crate::sync::net::UnixListener::from_cap_std(l)),
+            Socket::TcpStream(l) => Box::new(crate::sync::net::TcpStream::from_cap_std(l)),
+            Socket::UnixStream(l) => Box::new(crate::sync::net::UnixStream::from_cap_std(l)),
+        }
+    }
+}
+
+#[cfg(windows)]
+impl From<Socket> for Box<dyn WasiFile> {
+    fn from(listener: Socket) -> Self {
+        match listener {
+            Socket::TcpListener(l) => Box::new(crate::sync::net::TcpListener::from_cap_std(l)),
+            Socket::TcpStream(l) => Box::new(crate::sync::net::TcpStream::from_cap_std(l)),
+        }
+    }
+}
+
+macro_rules! wasi_listen_write_impl {
+    ($ty:ty, $stream:ty) => {
+        #[wiggle::async_trait]
+        impl WasiFile for $ty {
+            fn as_any(&self) -> &dyn Any {
+                self
+            }
+            #[cfg(unix)]
+            fn pollable(&self) -> Option<rustix::fd::BorrowedFd> {
+                Some(self.0.as_fd())
+            }
+            #[cfg(windows)]
+            fn pollable(&self) -> Option<io_extras::os::windows::RawHandleOrSocket> {
+                Some(self.0.as_raw_handle_or_socket())
+            }
+            async fn sock_accept(&self, fdflags: FdFlags) -> Result<Box<dyn WasiFile>, Error> {
+                let (stream, _) = self.0.accept()?;
+                let mut stream = <$stream>::from_cap_std(stream);
+                stream.set_fdflags(fdflags).await?;
+                Ok(Box::new(stream))
+            }
+            async fn get_filetype(&self) -> Result<FileType, Error> {
+                Ok(FileType::SocketStream)
+            }
+            #[cfg(unix)]
+            async fn get_fdflags(&self) -> Result<FdFlags, Error> {
+                let fdflags = get_fd_flags(&self.0)?;
+                Ok(fdflags)
+            }
+            async fn set_fdflags(&mut self, fdflags: FdFlags) -> Result<(), Error> {
+                if fdflags == crate::file::FdFlags::NONBLOCK {
+                    self.0.set_nonblocking(true)?;
+                } else if fdflags.is_empty() {
+                    self.0.set_nonblocking(false)?;
+                } else {
+                    return Err(
+                        Error::invalid_argument().context("cannot set anything else than NONBLOCK")
+                    );
+                }
+                Ok(())
+            }
+            fn num_ready_bytes(&self) -> Result<u64, Error> {
+                Ok(1)
+            }
+        }
+
+        #[cfg(windows)]
+        impl AsSocket for $ty {
+            #[inline]
+            fn as_socket(&self) -> BorrowedSocket<'_> {
+                self.0.as_socket()
+            }
+        }
+
+        #[cfg(windows)]
+        impl AsRawHandleOrSocket for $ty {
+            #[inline]
+            fn as_raw_handle_or_socket(&self) -> RawHandleOrSocket {
+                self.0.as_raw_handle_or_socket()
+            }
+        }
+
+        #[cfg(unix)]
+        impl AsFd for $ty {
+            fn as_fd(&self) -> BorrowedFd<'_> {
+                self.0.as_fd()
+            }
+        }
+    };
+}
+
+pub struct TcpListener(cap_std::net::TcpListener);
+
+impl TcpListener {
+    pub fn from_cap_std(cap_std: cap_std::net::TcpListener) -> Self {
+        TcpListener(cap_std)
+    }
+}
+wasi_listen_write_impl!(TcpListener, TcpStream);
+
+#[cfg(unix)]
+pub struct UnixListener(cap_std::os::unix::net::UnixListener);
+
+#[cfg(unix)]
+impl UnixListener {
+    pub fn from_cap_std(cap_std: cap_std::os::unix::net::UnixListener) -> Self {
+        UnixListener(cap_std)
+    }
+}
+
+#[cfg(unix)]
+wasi_listen_write_impl!(UnixListener, UnixStream);
+
+macro_rules! wasi_stream_write_impl {
+    ($ty:ty, $std_ty:ty) => {
+        #[wiggle::async_trait]
+        impl WasiFile for $ty {
+            fn as_any(&self) -> &dyn Any {
+                self
+            }
+            #[cfg(unix)]
+            fn pollable(&self) -> Option<rustix::fd::BorrowedFd> {
+                Some(self.0.as_fd())
+            }
+            #[cfg(windows)]
+            fn pollable(&self) -> Option<io_extras::os::windows::RawHandleOrSocket> {
+                Some(self.0.as_raw_handle_or_socket())
+            }
+            async fn get_filetype(&self) -> Result<FileType, Error> {
+                Ok(FileType::SocketStream)
+            }
+            #[cfg(unix)]
+            async fn get_fdflags(&self) -> Result<FdFlags, Error> {
+                let fdflags = get_fd_flags(&self.0)?;
+                Ok(fdflags)
+            }
+            async fn set_fdflags(&mut self, fdflags: FdFlags) -> Result<(), Error> {
+                if fdflags == crate::file::FdFlags::NONBLOCK {
+                    self.0.set_nonblocking(true)?;
+                } else if fdflags.is_empty() {
+                    self.0.set_nonblocking(false)?;
+                } else {
+                    return Err(
+                        Error::invalid_argument().context("cannot set anything else than NONBLOCK")
+                    );
+                }
+                Ok(())
+            }
+            async fn read_vectored<'a>(
+                &self,
+                bufs: &mut [io::IoSliceMut<'a>],
+            ) -> Result<u64, Error> {
+                use std::io::Read;
+                let n = Read::read_vectored(&mut &*self.as_socketlike_view::<$std_ty>(), bufs)?;
+                Ok(n.try_into()?)
+            }
+            async fn write_vectored<'a>(&self, bufs: &[io::IoSlice<'a>]) -> Result<u64, Error> {
+                use std::io::Write;
+                let n = Write::write_vectored(&mut &*self.as_socketlike_view::<$std_ty>(), bufs)?;
+                Ok(n.try_into()?)
+            }
+            async fn peek(&self, buf: &mut [u8]) -> Result<u64, Error> {
+                let n = self.0.peek(buf)?;
+                Ok(n.try_into()?)
+            }
+            fn num_ready_bytes(&self) -> Result<u64, Error> {
+                let val = self.as_socketlike_view::<$std_ty>().num_ready_bytes()?;
+                Ok(val)
+            }
+            async fn readable(&self) -> Result<(), Error> {
+                let (readable, _writeable) = is_read_write(&self.0)?;
+                if readable {
+                    Ok(())
+                } else {
+                    Err(Error::io())
+                }
+            }
+            async fn writable(&self) -> Result<(), Error> {
+                let (_readable, writeable) = is_read_write(&self.0)?;
+                if writeable {
+                    Ok(())
+                } else {
+                    Err(Error::io())
+                }
+            }
+
+            async fn sock_recv<'a>(
+                &self,
+                ri_data: &mut [std::io::IoSliceMut<'a>],
+                ri_flags: RiFlags,
+            ) -> Result<(u64, RoFlags), Error> {
+                if (ri_flags & !(RiFlags::RECV_PEEK | RiFlags::RECV_WAITALL)) != RiFlags::empty() {
+                    return Err(Error::not_supported());
+                }
+
+                if ri_flags.contains(RiFlags::RECV_PEEK) {
+                    if let Some(first) = ri_data.iter_mut().next() {
+                        let n = self.0.peek(first)?;
+                        return Ok((n as u64, RoFlags::empty()));
+                    } else {
+                        return Ok((0, RoFlags::empty()));
+                    }
+                }
+
+                if ri_flags.contains(RiFlags::RECV_WAITALL) {
+                    let n: usize = ri_data.iter().map(|buf| buf.len()).sum();
+                    self.0.read_exact_vectored(ri_data)?;
+                    return Ok((n as u64, RoFlags::empty()));
+                }
+
+                let n = self.0.read_vectored(ri_data)?;
+                Ok((n as u64, RoFlags::empty()))
+            }
+
+            async fn sock_send<'a>(
+                &self,
+                si_data: &[std::io::IoSlice<'a>],
+                si_flags: SiFlags,
+            ) -> Result<u64, Error> {
+                if si_flags != SiFlags::empty() {
+                    return Err(Error::not_supported());
+                }
+
+                let n = self.0.write_vectored(si_data)?;
+                Ok(n as u64)
+            }
+
+            async fn sock_shutdown(&self, how: SdFlags) -> Result<(), Error> {
+                let how = if how == SdFlags::RD | SdFlags::WR {
+                    cap_std::net::Shutdown::Both
+                } else if how == SdFlags::RD {
+                    cap_std::net::Shutdown::Read
+                } else if how == SdFlags::WR {
+                    cap_std::net::Shutdown::Write
+                } else {
+                    return Err(Error::invalid_argument());
+                };
+                self.0.shutdown(how)?;
+                Ok(())
+            }
+        }
+        #[cfg(unix)]
+        impl AsFd for $ty {
+            fn as_fd(&self) -> BorrowedFd<'_> {
+                self.0.as_fd()
+            }
+        }
+
+        #[cfg(windows)]
+        impl AsSocket for $ty {
+            /// Borrows the socket.
+            fn as_socket(&self) -> BorrowedSocket<'_> {
+                self.0.as_socket()
+            }
+        }
+
+        #[cfg(windows)]
+        impl AsRawHandleOrSocket for TcpStream {
+            #[inline]
+            fn as_raw_handle_or_socket(&self) -> RawHandleOrSocket {
+                self.0.as_raw_handle_or_socket()
+            }
+        }
+    };
+}
+
+pub struct TcpStream(cap_std::net::TcpStream);
+
+impl TcpStream {
+    pub fn from_cap_std(socket: cap_std::net::TcpStream) -> Self {
+        TcpStream(socket)
+    }
+}
+
+wasi_stream_write_impl!(TcpStream, std::net::TcpStream);
+
+#[cfg(unix)]
+pub struct UnixStream(cap_std::os::unix::net::UnixStream);
+
+#[cfg(unix)]
+impl UnixStream {
+    pub fn from_cap_std(socket: cap_std::os::unix::net::UnixStream) -> Self {
+        UnixStream(socket)
+    }
+}
+
+#[cfg(unix)]
+wasi_stream_write_impl!(UnixStream, std::os::unix::net::UnixStream);
+
+pub fn filetype_from(ft: &cap_std::fs::FileType) -> FileType {
+    use cap_fs_ext::FileTypeExt;
+    if ft.is_block_device() {
+        FileType::SocketDgram
+    } else {
+        FileType::SocketStream
+    }
+}
+
+/// Return the file-descriptor flags for a given file-like object.
+///
+/// This returns the flags needed to implement [`WasiFile::get_fdflags`].
+pub fn get_fd_flags<Socketlike: AsSocketlike>(f: Socketlike) -> io::Result<crate::file::FdFlags> {
+    // On Unix-family platforms, we can use the same system call that we'd use
+    // for files on sockets here.
+    #[cfg(not(windows))]
+    {
+        let mut out = crate::file::FdFlags::empty();
+        if f.get_fd_flags()?
+            .contains(system_interface::fs::FdFlags::NONBLOCK)
+        {
+            out |= crate::file::FdFlags::NONBLOCK;
+        }
+        Ok(out)
+    }
+
+    // On Windows, sockets are different, and there is no direct way to
+    // query for the non-blocking flag. We can get a sufficient approximation
+    // by testing whether a zero-length `recv` appears to block.
+    #[cfg(windows)]
+    match rustix::net::recv(f, &mut [], rustix::net::RecvFlags::empty()) {
+        Ok(_) => Ok(crate::file::FdFlags::empty()),
+        Err(rustix::io::Errno::WOULDBLOCK) => Ok(crate::file::FdFlags::NONBLOCK),
+        Err(e) => Err(e.into()),
+    }
+}
+
+/// Return the file-descriptor flags for a given file-like object.
+///
+/// This returns the flags needed to implement [`WasiFile::get_fdflags`].
+pub fn is_read_write<Socketlike: AsSocketlike>(f: Socketlike) -> io::Result<(bool, bool)> {
+    // On Unix-family platforms, we have an `IsReadWrite` impl.
+    #[cfg(not(windows))]
+    {
+        f.is_read_write()
+    }
+
+    // On Windows, we only have a `TcpStream` impl, so make a view first.
+    #[cfg(windows)]
+    {
+        f.as_socketlike_view::<std::net::TcpStream>()
+            .is_read_write()
+    }
+}
diff --git a/crates/wasi-common/src/sync/sched.rs b/crates/wasi-common/src/sync/sched.rs
new file mode 100644
index 000000000000..e49ef46428fc
--- /dev/null
+++ b/crates/wasi-common/src/sync/sched.rs
@@ -0,0 +1,40 @@
+#[cfg(unix)]
+pub mod unix;
+#[cfg(unix)]
+pub use unix::poll_oneoff;
+
+#[cfg(windows)]
+pub mod windows;
+#[cfg(windows)]
+pub use windows::poll_oneoff;
+
+use crate::{
+    sched::{Poll, WasiSched},
+    Error,
+};
+use std::thread;
+use std::time::Duration;
+
+pub struct SyncSched {}
+impl SyncSched {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+#[wiggle::async_trait]
+impl WasiSched for SyncSched {
+    async fn poll_oneoff<'a>(&self, poll: &mut Poll<'a>) -> Result<(), Error> {
+        poll_oneoff(poll).await
+    }
+    async fn sched_yield(&self) -> Result<(), Error> {
+        thread::yield_now();
+        Ok(())
+    }
+    async fn sleep(&self, duration: Duration) -> Result<(), Error> {
+        std::thread::sleep(duration);
+        Ok(())
+    }
+}
+pub fn sched_ctx() -> Box<dyn WasiSched> {
+    Box::new(SyncSched::new())
+}
diff --git a/crates/wasi-common/src/sync/sched/unix.rs b/crates/wasi-common/src/sync/sched/unix.rs
new file mode 100644
index 000000000000..6d5bd05899ef
--- /dev/null
+++ b/crates/wasi-common/src/sync/sched/unix.rs
@@ -0,0 +1,81 @@
+use crate::sched::subscription::{RwEventFlags, Subscription};
+use crate::{sched::Poll, Error, ErrorExt};
+use cap_std::time::Duration;
+use rustix::event::{PollFd, PollFlags};
+
+pub async fn poll_oneoff<'a>(poll: &mut Poll<'a>) -> Result<(), Error> {
+    if poll.is_empty() {
+        return Ok(());
+    }
+    let mut pollfds = Vec::new();
+    for s in poll.rw_subscriptions() {
+        match s {
+            Subscription::Read(f) => {
+                let fd = f
+                    .file
+                    .pollable()
+                    .ok_or(Error::invalid_argument().context("file is not pollable"))?;
+                pollfds.push(PollFd::from_borrowed_fd(fd, PollFlags::IN));
+            }
+
+            Subscription::Write(f) => {
+                let fd = f
+                    .file
+                    .pollable()
+                    .ok_or(Error::invalid_argument().context("file is not pollable"))?;
+                pollfds.push(PollFd::from_borrowed_fd(fd, PollFlags::OUT));
+            }
+            Subscription::MonotonicClock { .. } => unreachable!(),
+        }
+    }
+
+    let ready = loop {
+        let poll_timeout = if let Some(t) = poll.earliest_clock_deadline() {
+            let duration = t.duration_until().unwrap_or(Duration::from_secs(0));
+            (duration.as_millis() + 1) // XXX try always rounding up?
+                .try_into()
+                .map_err(|_| Error::overflow().context("poll timeout"))?
+        } else {
+            std::os::raw::c_int::max_value()
+        };
+        tracing::debug!(
+            poll_timeout = tracing::field::debug(poll_timeout),
+            poll_fds = tracing::field::debug(&pollfds),
+            "poll"
+        );
+        match rustix::event::poll(&mut pollfds, poll_timeout) {
+            Ok(ready) => break ready,
+            Err(rustix::io::Errno::INTR) => continue,
+            Err(err) => return Err(std::io::Error::from(err).into()),
+        }
+    };
+    if ready > 0 {
+        for (rwsub, pollfd) in poll.rw_subscriptions().zip(pollfds.into_iter()) {
+            let revents = pollfd.revents();
+            let (nbytes, rwsub) = match rwsub {
+                Subscription::Read(sub) => {
+                    let ready = sub.file.num_ready_bytes()?;
+                    (std::cmp::max(ready, 1), sub)
+                }
+                Subscription::Write(sub) => (0, sub),
+                _ => unreachable!(),
+            };
+            if revents.contains(PollFlags::NVAL) {
+                rwsub.error(Error::badf());
+            } else if revents.contains(PollFlags::ERR) {
+                rwsub.error(Error::io());
+            } else if revents.contains(PollFlags::HUP) {
+                rwsub.complete(nbytes, RwEventFlags::HANGUP);
+            } else {
+                rwsub.complete(nbytes, RwEventFlags::empty());
+            };
+        }
+    } else {
+        poll.earliest_clock_deadline()
+            .expect("timed out")
+            .result()
+            .expect("timer deadline is past")
+            .unwrap()
+    }
+    Ok(())
+}
diff --git a/crates/wasi-common/src/sync/sched/windows.rs b/crates/wasi-common/src/sync/sched/windows.rs
new file mode 100644
index 000000000000..f412ff5f84d3
--- /dev/null
+++ b/crates/wasi-common/src/sync/sched/windows.rs
@@ -0,0 +1,221 @@
+// The windows scheduler is unmaintained and due for a rewrite.
+//
+// Rather than use a polling mechanism for file read/write readiness,
+// it checks readiness just once, before sleeping for any timer subscriptions.
+// Checking stdin readiness uses a worker thread which, once started, lives for the
+// lifetime of the process.
+//
+// We suspect there are bugs in this scheduler, however, we have not
+// taken the time to improve it. See bug #2880.
+
+use crate::sched::subscription::{RwEventFlags, Subscription};
+use crate::{file::WasiFile, sched::Poll, Error, ErrorExt};
+use once_cell::sync::Lazy;
+use std::sync::mpsc::{self, Receiver, RecvTimeoutError, Sender, TryRecvError};
+use std::sync::Mutex;
+use std::thread;
+use std::time::Duration;
+
+pub async fn poll_oneoff<'a>(poll: &mut Poll<'a>) -> Result<(), Error> {
+    poll_oneoff_(poll, wasi_file_is_stdin).await
+}
+
+pub async fn poll_oneoff_<'a>(
+    poll: &mut Poll<'a>,
+    file_is_stdin: impl Fn(&dyn WasiFile) -> bool,
+) -> Result<(), Error> {
+    if poll.is_empty() {
+        return Ok(());
+    }
+
+    let mut ready = false;
+    let waitmode = if let Some(t) = poll.earliest_clock_deadline() {
+        if let Some(duration) = t.duration_until() {
+            WaitMode::Timeout(duration)
+        } else {
+            WaitMode::Immediate
+        }
+    } else {
+        if ready {
+            WaitMode::Immediate
+        } else {
+            WaitMode::Infinite
+        }
+    };
+
+    let mut stdin_read_subs = Vec::new();
+    let mut immediate_reads = Vec::new();
+    let mut immediate_writes = Vec::new();
+    for s in poll.rw_subscriptions() {
+        match s {
+            Subscription::Read(r) => {
+                if file_is_stdin(r.file) {
+                    stdin_read_subs.push(r);
+                } else if r.file.pollable().is_some() {
+                    immediate_reads.push(r);
+                } else {
+                    return Err(Error::invalid_argument().context("file is not pollable"));
+                }
+            }
+            Subscription::Write(w) => {
+                if w.file.pollable().is_some() {
+                    immediate_writes.push(w);
+                } else {
+                    return Err(Error::invalid_argument().context("file is not pollable"));
+                }
+            }
+            Subscription::MonotonicClock { .. } => unreachable!(),
+        }
+    }
+
+    if !stdin_read_subs.is_empty() {
+        let state = STDIN_POLL
+            .lock()
+            .map_err(|_| Error::trap(anyhow::Error::msg("failed to take lock of STDIN_POLL")))?
+            .poll(waitmode)?;
+        for readsub in stdin_read_subs.into_iter() {
+            match state {
+                PollState::Ready => {
+                    readsub.complete(1, RwEventFlags::empty());
+                    ready = true;
+                }
+                PollState::NotReady | PollState::TimedOut => {}
+                PollState::Error(ref e) => {
+                    // Unfortunately, we need to deliver the Error to each of the
+                    // subscriptions, but there is no Clone on std::io::Error. So, we convert it to the
+                    // kind, and then back to std::io::Error, and finally to anyhow::Error.
+                    // When its time to turn this into an errno elsewhere, the error kind will
+                    // be inspected.
+                    let ekind = e.kind();
+                    let ioerror = std::io::Error::from(ekind);
+                    readsub.error(ioerror.into());
+                    ready = true;
+                }
+            }
+        }
+    }
+    for r in immediate_reads {
+        match r.file.num_ready_bytes() {
+            Ok(ready_bytes) => {
+                r.complete(ready_bytes, RwEventFlags::empty());
+                ready = true;
+            }
+            Err(e) => {
+                r.error(e);
+                ready = true;
+            }
+        }
+    }
+    for w in immediate_writes {
+        // Everything is always ready for writing, apparently?
+        w.complete(0, RwEventFlags::empty());
+        ready = true;
+    }
+
+    if !ready {
+        if let WaitMode::Timeout(duration) = waitmode {
+            thread::sleep(duration);
+        }
+    }
+
+    Ok(())
+}
+
+pub fn wasi_file_is_stdin(f: &dyn WasiFile) -> bool {
+    f.as_any().is::<crate::sync::stdio::Stdin>()
+}
+
+enum PollState {
+    Ready,
+    NotReady, // Not ready, but did not wait
+    TimedOut, // Not ready, waited until timeout
+    Error(std::io::Error),
+}
+
+#[derive(Copy, Clone)]
+enum WaitMode {
+    Timeout(Duration),
+    Infinite,
+    Immediate,
+}
+
+struct StdinPoll {
+    request_tx: Sender<()>,
+    notify_rx: Receiver<PollState>,
+}
+
+static STDIN_POLL: Lazy<Mutex<StdinPoll>> = Lazy::new(StdinPoll::new);
+
+impl StdinPoll {
+    pub fn new() -> Mutex<Self> {
+        let (request_tx, request_rx) = mpsc::channel();
+        let (notify_tx, notify_rx) = mpsc::channel();
+        thread::spawn(move || Self::event_loop(request_rx, notify_tx));
+        Mutex::new(StdinPoll {
+            request_tx,
+            notify_rx,
+        })
+    }
+
+    // This function should not be used directly.
+    // Correctness of this function crucially depends on the fact that
+    // mpsc::Receiver is !Sync.
+    fn poll(&self, wait_mode: WaitMode) -> Result<PollState, Error> {
+        match self.notify_rx.try_recv() {
+            // Clean up possibly unread result from previous poll.
+            Ok(_) | Err(TryRecvError::Empty) => {}
+            Err(TryRecvError::Disconnected) => {
+                return Err(Error::trap(anyhow::Error::msg(
+                    "StdinPoll notify_rx channel closed",
+                )))
+            }
+        }
+
+        // Notify the worker thread to poll stdin
+        self.request_tx
+            .send(())
+            .map_err(|_| Error::trap(anyhow::Error::msg("request_tx channel closed")))?;
+
+        // Wait for the worker thread to send a readiness notification
+        match wait_mode {
+            WaitMode::Timeout(timeout) => match self.notify_rx.recv_timeout(timeout) {
+                Ok(r) => Ok(r),
+                Err(RecvTimeoutError::Timeout) => Ok(PollState::TimedOut),
+                Err(RecvTimeoutError::Disconnected) => Err(Error::trap(anyhow::Error::msg(
+                    "StdinPoll notify_rx channel closed",
+                ))),
+            },
+            WaitMode::Infinite => self
+                .notify_rx
+                .recv()
+                .map_err(|_| Error::trap(anyhow::Error::msg("StdinPoll notify_rx channel closed"))),
+            WaitMode::Immediate => match self.notify_rx.try_recv() {
+                Ok(r) => Ok(r),
+                Err(TryRecvError::Empty) => Ok(PollState::NotReady),
+                Err(TryRecvError::Disconnected) => Err(Error::trap(anyhow::Error::msg(
+                    "StdinPoll notify_rx channel closed",
+                ))),
+            },
+        }
+    }
+
+    fn event_loop(request_rx: Receiver<()>, notify_tx: Sender<PollState>) -> ! {
+        use std::io::BufRead;
+        loop {
+            // Wait on a request:
+            request_rx.recv().expect("request_rx channel");
+            // Wait for data to appear in stdin. If fill_buf returns any slice, it means
+            // that either:
+            // (a) there is some data in stdin, if non-empty,
+            // (b) EOF was received, if its empty
+            // Linux returns `POLLIN` in both cases, so we imitate this behavior.
+            let resp = match std::io::stdin().lock().fill_buf() {
+                Ok(_) => PollState::Ready,
+                Err(e) => PollState::Error(e),
+            };
+            // Notify about data in stdin. If the read on this channel has timed out, the
+            // next poller will have to clean the channel.
+            notify_tx.send(resp).expect("notify_tx channel");
+        }
+    }
+}
diff --git a/crates/wasi-common/src/sync/stdio.rs b/crates/wasi-common/src/sync/stdio.rs
new file mode 100644
index 000000000000..5ff55632c072
--- /dev/null
+++ b/crates/wasi-common/src/sync/stdio.rs
@@ -0,0 +1,196 @@
+use crate::sync::file::convert_systimespec;
+use fs_set_times::SetTimes;
+use std::any::Any;
+use std::io::{self, IsTerminal, Read, Write};
+use system_interface::io::ReadReady;
+
+use crate::{
+    file::{FdFlags, FileType, WasiFile},
+    Error, ErrorExt,
+};
+#[cfg(windows)]
+use io_extras::os::windows::{AsRawHandleOrSocket, RawHandleOrSocket};
+#[cfg(unix)]
+use io_lifetimes::{AsFd, BorrowedFd};
+#[cfg(windows)]
+use io_lifetimes::{AsHandle, BorrowedHandle};
+
+pub struct Stdin(std::io::Stdin);
+
+pub fn stdin() -> Stdin {
+    Stdin(std::io::stdin())
+}
+
+#[wiggle::async_trait]
+impl WasiFile for Stdin {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    #[cfg(unix)]
+    fn pollable(&self) -> Option<rustix::fd::BorrowedFd> {
+        Some(self.0.as_fd())
+    }
+
+    #[cfg(windows)]
+    fn pollable(&self) -> Option<io_extras::os::windows::RawHandleOrSocket> {
+        Some(self.0.as_raw_handle_or_socket())
+    }
+
+    async fn get_filetype(&self) -> Result<FileType, Error> {
+        if self.isatty() {
+            Ok(FileType::CharacterDevice)
+        } else {
+            Ok(FileType::Unknown)
+        }
+    }
+    async fn read_vectored<'a>(&self, bufs: &mut [io::IoSliceMut<'a>]) -> Result<u64, Error> {
+        let n = self.0.lock().read_vectored(bufs)?;
+        Ok(n.try_into().map_err(|_| Error::range())?)
+    }
+    async fn read_vectored_at<'a>(
+        &self,
+        _bufs: &mut [io::IoSliceMut<'a>],
+        _offset: u64,
+    ) -> Result<u64, Error> {
+        Err(Error::seek_pipe())
+    }
+    async fn seek(&self, _pos: std::io::SeekFrom) -> Result<u64, Error> {
+        Err(Error::seek_pipe())
+    }
+    async fn peek(&self, _buf: &mut [u8]) -> Result<u64, Error> {
+        Err(Error::seek_pipe())
+    }
+    async fn set_times(
+        &self,
+        atime: Option<crate::SystemTimeSpec>,
+        mtime: Option<crate::SystemTimeSpec>,
+    ) -> Result<(), Error> {
+        self.0
+            .set_times(convert_systimespec(atime), convert_systimespec(mtime))?;
+        Ok(())
+    }
+    fn num_ready_bytes(&self) -> Result<u64, Error> {
+        Ok(self.0.num_ready_bytes()?)
+    }
+    fn isatty(&self) -> bool {
+        #[cfg(unix)]
+        return self.0.as_fd().is_terminal();
+        #[cfg(windows)]
+        return self.0.as_handle().is_terminal();
+    }
+}
+#[cfg(windows)]
+impl AsHandle for Stdin {
+    fn as_handle(&self) -> BorrowedHandle<'_> {
+        self.0.as_handle()
+    }
+}
+#[cfg(windows)]
+impl AsRawHandleOrSocket for Stdin {
+    #[inline]
+    fn as_raw_handle_or_socket(&self) -> RawHandleOrSocket {
+        self.0.as_raw_handle_or_socket()
+    }
+}
+#[cfg(unix)]
+impl AsFd for Stdin {
+    fn as_fd(&self) -> BorrowedFd<'_> {
+        self.0.as_fd()
+    }
+}
+
+macro_rules! wasi_file_write_impl {
+    ($ty:ty, $ident:ident) => {
+        #[wiggle::async_trait]
+        impl WasiFile for $ty {
+            fn as_any(&self) -> &dyn Any {
+                self
+            }
+            #[cfg(unix)]
+            fn pollable(&self) -> Option<rustix::fd::BorrowedFd> {
+                Some(self.0.as_fd())
+            }
+            #[cfg(windows)]
+            fn pollable(&self) -> Option<io_extras::os::windows::RawHandleOrSocket> {
+                Some(self.0.as_raw_handle_or_socket())
+            }
+            async fn get_filetype(&self) -> Result<FileType, Error> {
+                if self.isatty() {
+                    Ok(FileType::CharacterDevice)
+                } else {
+                    Ok(FileType::Unknown)
+                }
+            }
+            async fn get_fdflags(&self) -> Result<FdFlags, Error> {
+                Ok(FdFlags::APPEND)
+            }
+            async fn write_vectored<'a>(&self, bufs: &[io::IoSlice<'a>]) -> Result<u64, Error> {
+                let mut io = self.0.lock();
+                let n = io.write_vectored(bufs)?;
+                // On a successful write additionally flush out the bytes to
+                // handle stdio buffering done by libstd since WASI interfaces
+                // here aren't buffered.
+                io.flush()?;
+                Ok(n.try_into().map_err(|_| {
+                    Error::range().context("converting write_vectored total length")
+                })?)
+            }
+            async fn write_vectored_at<'a>(
+                &self,
+                _bufs: &[io::IoSlice<'a>],
+                _offset: u64,
+            ) -> Result<u64, Error> {
+                Err(Error::seek_pipe())
+            }
+            async fn seek(&self, _pos: std::io::SeekFrom) -> Result<u64, Error> {
+                Err(Error::seek_pipe())
+            }
+            async fn set_times(
+                &self,
+                atime: Option<crate::SystemTimeSpec>,
+                mtime: Option<crate::SystemTimeSpec>,
+            ) -> Result<(), Error> {
+                self.0
+                    .set_times(convert_systimespec(atime), convert_systimespec(mtime))?;
+                Ok(())
+            }
+            fn isatty(&self) -> bool {
+                self.0.is_terminal()
+            }
+        }
+        #[cfg(windows)]
+        impl AsHandle for $ty {
+            fn as_handle(&self) -> BorrowedHandle<'_> {
+                self.0.as_handle()
+            }
+        }
+        #[cfg(unix)]
+        impl AsFd for $ty {
+            fn as_fd(&self) -> BorrowedFd<'_> {
+                self.0.as_fd()
+            }
+        }
+        #[cfg(windows)]
+        impl AsRawHandleOrSocket for $ty {
+            #[inline]
+            fn as_raw_handle_or_socket(&self) -> RawHandleOrSocket {
+                self.0.as_raw_handle_or_socket()
+            }
+        }
+    };
+}
+
+pub struct Stdout(std::io::Stdout);
+
+pub fn stdout() -> Stdout {
+    Stdout(std::io::stdout())
+}
+wasi_file_write_impl!(Stdout, Stdout);
+
+pub struct Stderr(std::io::Stderr);
+
+pub fn stderr() -> Stderr {
+    Stderr(std::io::stderr())
+}
+wasi_file_write_impl!(Stderr, Stderr);
diff --git a/crates/wasi-common/src/tokio/dir.rs b/crates/wasi-common/src/tokio/dir.rs
new file mode 100644
index 000000000000..95347e8dc8c2
--- /dev/null
+++ b/crates/wasi-common/src/tokio/dir.rs
@@ -0,0 +1,220 @@
+use crate::tokio::{block_on_dummy_executor, file::File};
+use crate::{
+    dir::{ReaddirCursor, ReaddirEntity, WasiDir},
+    file::{FdFlags, Filestat, OFlags},
+    Error, ErrorExt,
+};
+use std::any::Any;
+use std::path::PathBuf;
+
+pub struct Dir(crate::sync::dir::Dir);
+
+impl Dir {
+    pub fn from_cap_std(dir: cap_std::fs::Dir) -> Self {
+        Dir(crate::sync::dir::Dir::from_cap_std(dir))
+    }
+}
+
+#[wiggle::async_trait]
+impl WasiDir for Dir {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+    async fn open_file(
+        &self,
+        symlink_follow: bool,
+        path: &str,
+        oflags: OFlags,
+        read: bool,
+        write: bool,
+        fdflags: FdFlags,
+    ) -> Result<crate::dir::OpenResult, Error> {
+        let f = block_on_dummy_executor(move || async move {
+            self.0
+                .open_file_(symlink_follow, path, oflags, read, write, fdflags)
+        })?;
+        match f {
+            crate::sync::dir::OpenResult::File(f) => {
+                Ok(crate::dir::OpenResult::File(Box::new(File::from_inner(f))))
+            }
+            crate::sync::dir::OpenResult::Dir(d) => {
+                Ok(crate::dir::OpenResult::Dir(Box::new(Dir(d))))
+            }
+        }
+    }
+
+    async fn create_dir(&self, path: &str) -> Result<(), Error> {
+        block_on_dummy_executor(|| self.0.create_dir(path))
+    }
+    async fn readdir(
+        &self,
+        cursor: ReaddirCursor,
+    ) -> Result<Box<dyn Iterator<Item = Result<ReaddirEntity, Error>> + Send>, Error> {
+        struct I(Box<dyn Iterator<Item = Result<ReaddirEntity, Error>> + Send>);
+        impl Iterator for I {
+            type Item = Result<ReaddirEntity, Error>;
+            fn next(&mut self) -> Option<Self::Item> {
+                tokio::task::block_in_place(move || self.0.next())
+            }
+        }
+
+        let inner = block_on_dummy_executor(move || self.0.readdir(cursor))?;
+        Ok(Box::new(I(inner)))
+    }
+
+    async fn symlink(&self, src_path: &str, dest_path: &str) -> Result<(), Error> {
+        block_on_dummy_executor(move || self.0.symlink(src_path, dest_path))
+    }
+    async fn remove_dir(&self, path: &str) -> Result<(), Error> {
+        block_on_dummy_executor(move || self.0.remove_dir(path))
+    }
+
+    async fn unlink_file(&self, path: &str) -> Result<(), Error> {
+        block_on_dummy_executor(move || self.0.unlink_file(path))
+    }
+    async fn read_link(&self, path: &str) -> Result<PathBuf, Error> {
+        block_on_dummy_executor(move || self.0.read_link(path))
+    }
+    async fn get_filestat(&self) -> Result<Filestat, Error> {
+        block_on_dummy_executor(|| self.0.get_filestat())
+    }
+    async fn get_path_filestat(
+        &self,
+        path: &str,
+        follow_symlinks: bool,
+    ) -> Result<Filestat, Error> {
+        block_on_dummy_executor(move || self.0.get_path_filestat(path, follow_symlinks))
+    }
+    async fn rename(
+        &self,
+        src_path: &str,
+        dest_dir: &dyn WasiDir,
+        dest_path: &str,
+    ) -> Result<(), Error> {
+        let dest_dir = dest_dir
+            .as_any()
+            .downcast_ref::<Self>()
+            .ok_or(Error::badf().context("failed downcast to tokio Dir"))?;
+        block_on_dummy_executor(
+            move || async move { self.0.rename_(src_path, &dest_dir.0, dest_path) },
+        )
+    }
+    async fn hard_link(
+        &self,
+        src_path: &str,
+        target_dir: &dyn WasiDir,
+        target_path: &str,
+    ) -> Result<(), Error> {
+        let target_dir = target_dir
+            .as_any()
+            .downcast_ref::<Self>()
+            .ok_or(Error::badf().context("failed downcast to tokio Dir"))?;
+        block_on_dummy_executor(move || async move {
+            self.0.hard_link_(src_path, &target_dir.0, target_path)
+        })
+    }
+    async fn set_times(
+        &self,
+        path: &str,
+        atime: Option<crate::SystemTimeSpec>,
+        mtime: Option<crate::SystemTimeSpec>,
+        follow_symlinks: bool,
+    ) -> Result<(), Error> {
+        block_on_dummy_executor(move || self.0.set_times(path, atime, mtime, follow_symlinks))
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::Dir;
+    use crate::file::{FdFlags, OFlags};
+    use cap_std::ambient_authority;
+
+    #[tokio::test(flavor = "multi_thread")]
+    async fn scratch_dir() {
+        let tempdir = tempfile::Builder::new()
+            .prefix("cap-std-sync")
+            .tempdir()
+            .expect("create temporary dir");
+        let preopen_dir = cap_std::fs::Dir::open_ambient_dir(tempdir.path(), ambient_authority())
+            .expect("open ambient temporary dir");
+        let preopen_dir = Dir::from_cap_std(preopen_dir);
+        crate::WasiDir::open_file(
+            &preopen_dir,
+            false,
+            ".",
+            OFlags::empty(),
+            false,
+            false,
+            FdFlags::empty(),
+        )
+        .await
+        .expect("open the same directory via WasiDir abstraction");
+    }
+
+    // Readdir does not work on windows, so we won't test it there.
+    #[cfg(not(windows))]
+    #[tokio::test(flavor = "multi_thread")]
+    async fn readdir() {
+        use crate::dir::{ReaddirCursor, ReaddirEntity, WasiDir};
+        use crate::file::{FdFlags, FileType, OFlags};
+        use std::collections::HashMap;
+
+        async fn readdir_into_map(dir: &dyn WasiDir) -> HashMap<String, ReaddirEntity> {
+            let mut out = HashMap::new();
+            for readdir_result in dir
+                .readdir(ReaddirCursor::from(0))
+                .await
+                .expect("readdir succeeds")
+            {
+                let entity = readdir_result.expect("readdir entry is valid");
+                out.insert(entity.name.clone(), entity);
+            }
+            out
+        }
+
+        let tempdir = tempfile::Builder::new()
+            .prefix("cap-std-sync")
+            .tempdir()
+            .expect("create temporary dir");
+        let preopen_dir = cap_std::fs::Dir::open_ambient_dir(tempdir.path(), ambient_authority())
+            .expect("open ambient temporary dir");
+        let preopen_dir = Dir::from_cap_std(preopen_dir);
+
+        let entities = readdir_into_map(&preopen_dir).await;
+        assert_eq!(
+            entities.len(),
+            2,
+            "should just be . and .. in empty dir: {entities:?}"
+        );
+        assert!(entities.get(".").is_some());
+        assert!(entities.get("..").is_some());
+
+        preopen_dir
+            .open_file(
+                false,
+                "file1",
+                OFlags::CREATE,
+                true,
+                false,
+                FdFlags::empty(),
+            )
+            .await
+            .expect("create file1");
+
+        let entities = readdir_into_map(&preopen_dir).await;
+        assert_eq!(entities.len(), 3, "should be ., .., file1 {entities:?}");
+        assert_eq!(
+            entities.get(".").expect(". entry").filetype,
+            FileType::Directory
+        );
+        assert_eq!(
+            entities.get("..").expect(".. entry").filetype,
+            FileType::Directory
+        );
+        assert_eq!(
+            entities.get("file1").expect("file1 entry").filetype,
+            FileType::RegularFile
+        );
+    }
+}
diff --git a/crates/wasi-common/src/tokio/file.rs b/crates/wasi-common/src/tokio/file.rs
new file mode 100644
index 000000000000..7aedddf33f32
--- /dev/null
+++ b/crates/wasi-common/src/tokio/file.rs
@@ -0,0 +1,247 @@
+use crate::tokio::block_on_dummy_executor;
+use crate::{
+    file::{Advice, FdFlags, FileType, Filestat, WasiFile},
+    Error,
+};
+#[cfg(windows)]
+use io_extras::os::windows::{AsRawHandleOrSocket, RawHandleOrSocket};
+#[cfg(not(windows))]
+use io_lifetimes::AsFd;
+use std::any::Any;
+use std::borrow::Borrow;
+use std::io;
+
+pub struct File(crate::sync::file::File);
+
+impl File {
+    pub(crate) fn from_inner(file: crate::sync::file::File) -> Self {
+        File(file)
+    }
+    pub fn from_cap_std(file: cap_std::fs::File) -> Self {
+        Self::from_inner(crate::sync::file::File::from_cap_std(file))
+    }
+}
+
+pub struct TcpListener(crate::sync::net::TcpListener);
+
+impl TcpListener {
+    pub(crate) fn from_inner(listener: crate::sync::net::TcpListener) -> Self {
+        TcpListener(listener)
+    }
+    pub fn from_cap_std(listener: cap_std::net::TcpListener) -> Self {
+        Self::from_inner(crate::sync::net::TcpListener::from_cap_std(listener))
+    }
+}
+
+pub struct TcpStream(crate::sync::net::TcpStream);
+
+impl TcpStream {
+    pub(crate) fn from_inner(stream: crate::sync::net::TcpStream) -> Self {
+        TcpStream(stream)
+    }
+    pub fn from_cap_std(stream: cap_std::net::TcpStream) -> Self {
+        Self::from_inner(crate::sync::net::TcpStream::from_cap_std(stream))
+    }
+}
+
+#[cfg(unix)]
+pub struct UnixListener(crate::sync::net::UnixListener);
+
+#[cfg(unix)]
+impl UnixListener {
+    pub(crate) fn from_inner(listener: crate::sync::net::UnixListener) -> Self {
+        UnixListener(listener)
+    }
+    pub fn from_cap_std(listener: cap_std::os::unix::net::UnixListener) -> Self {
+        Self::from_inner(crate::sync::net::UnixListener::from_cap_std(listener))
+    }
+}
+
+#[cfg(unix)]
+pub struct UnixStream(crate::sync::net::UnixStream);
+
+#[cfg(unix)]
+impl UnixStream {
+    fn from_inner(stream: crate::sync::net::UnixStream) -> Self {
+        UnixStream(stream)
+    }
+    pub fn from_cap_std(stream: cap_std::os::unix::net::UnixStream) -> Self {
+        Self::from_inner(crate::sync::net::UnixStream::from_cap_std(stream))
+    }
+}
+
+pub struct Stdin(crate::sync::stdio::Stdin);
+
+pub fn stdin() -> Stdin {
+    Stdin(crate::sync::stdio::stdin())
+}
+
+pub struct Stdout(crate::sync::stdio::Stdout);
+
+pub fn stdout() -> Stdout {
+    Stdout(crate::sync::stdio::stdout())
+}
+
+pub struct Stderr(crate::sync::stdio::Stderr);
+
+pub fn stderr() -> Stderr {
+    Stderr(crate::sync::stdio::stderr())
+}
+
+macro_rules! wasi_file_impl {
+    ($ty:ty) => {
+        #[wiggle::async_trait]
+        impl WasiFile for $ty {
+            fn as_any(&self) -> &dyn Any {
+                self
+            }
+            #[cfg(unix)]
+            fn pollable(&self) -> Option<rustix::fd::BorrowedFd> {
+                Some(self.0.as_fd())
+            }
+            #[cfg(windows)]
+            fn pollable(&self) -> Option<io_extras::os::windows::RawHandleOrSocket> {
+                Some(self.0.as_raw_handle_or_socket())
+            }
+            async fn datasync(&self) -> Result<(), Error> {
+                block_on_dummy_executor(|| self.0.datasync())
+            }
+            async fn sync(&self) -> Result<(), Error> {
+                block_on_dummy_executor(|| self.0.sync())
+            }
+            async fn get_filetype(&self) -> Result<FileType, Error> {
+                block_on_dummy_executor(|| self.0.get_filetype())
+            }
+            async fn get_fdflags(&self) -> Result<FdFlags, Error> {
+                block_on_dummy_executor(|| self.0.get_fdflags())
+            }
+            async fn set_fdflags(&mut self, fdflags: FdFlags) -> Result<(), Error> {
+                block_on_dummy_executor(|| self.0.set_fdflags(fdflags))
+            }
+            async fn get_filestat(&self) -> Result<Filestat, Error> {
+                block_on_dummy_executor(|| self.0.get_filestat())
+            }
+            async fn set_filestat_size(&self, size: u64) -> Result<(), Error> {
+                block_on_dummy_executor(move || self.0.set_filestat_size(size))
+            }
+            async fn advise(&self, offset: u64, len: u64, advice: Advice) -> Result<(), Error> {
+                block_on_dummy_executor(move || self.0.advise(offset, len, advice))
+            }
+            async fn read_vectored<'a>(
+                &self,
+                bufs: &mut [io::IoSliceMut<'a>],
+            ) -> Result<u64, Error> {
+                block_on_dummy_executor(move || self.0.read_vectored(bufs))
+            }
+            async fn read_vectored_at<'a>(
+                &self,
+                bufs: &mut [io::IoSliceMut<'a>],
+                offset: u64,
+            ) -> Result<u64, Error> {
+                block_on_dummy_executor(move || self.0.read_vectored_at(bufs, offset))
+            }
+            async fn write_vectored<'a>(&self, bufs: &[io::IoSlice<'a>]) -> Result<u64, Error> {
+                block_on_dummy_executor(move || self.0.write_vectored(bufs))
+            }
+            async fn write_vectored_at<'a>(
+                &self,
+                bufs: &[io::IoSlice<'a>],
+                offset: u64,
+            ) -> Result<u64, Error> {
+                if bufs.iter().map(|i| i.len()).sum::<usize>() == 0 {
+                    return Ok(0);
+                }
+                block_on_dummy_executor(move || self.0.write_vectored_at(bufs, offset))
+            }
+            async fn seek(&self, pos: std::io::SeekFrom) -> Result<u64, Error> {
+                block_on_dummy_executor(move || self.0.seek(pos))
+            }
+            async fn peek(&self, buf: &mut [u8]) -> Result<u64, Error> {
+                block_on_dummy_executor(move || self.0.peek(buf))
+            }
+            async fn set_times(
+                &self,
+                atime: Option<crate::SystemTimeSpec>,
+                mtime: Option<crate::SystemTimeSpec>,
+            ) -> Result<(), Error> {
+                block_on_dummy_executor(move || self.0.set_times(atime, mtime))
+            }
+            fn num_ready_bytes(&self) -> Result<u64, Error> {
+                self.0.num_ready_bytes()
+            }
+            fn isatty(&self) -> bool {
+                self.0.isatty()
+            }
+
+            #[cfg(not(windows))]
+            async fn readable(&self) -> Result<(), Error> {
+                // The Inner impls OwnsRaw, which asserts exclusive use of the handle by the owned object.
+                // AsyncFd needs to wrap an owned `impl std::os::unix::io::AsRawFd`. Rather than introduce
+                // mutability to let it own the `Inner`, we are depending on the `&mut self` bound on this
+                // async method to ensure this is the only Future which can access the RawFd during the
+                // lifetime of the AsyncFd.
+                use std::os::unix::io::AsRawFd;
+                use tokio::io::{unix::AsyncFd, Interest};
+                let rawfd = self.0.borrow().as_fd().as_raw_fd();
+                match AsyncFd::with_interest(rawfd, Interest::READABLE) {
+                    Ok(asyncfd) => {
+                        let _ = asyncfd.readable().await?;
+                        Ok(())
+                    }
+                    Err(e) if e.kind() == std::io::ErrorKind::PermissionDenied => {
+                        // if e is EPERM, this file isn't supported by epoll because it is immediately
+                        // available for reading:
+                        Ok(())
+                    }
+                    Err(e) => Err(e.into()),
+                }
+            }
+
+            #[cfg(not(windows))]
+            async fn writable(&self) -> Result<(), Error> {
+                // The Inner impls OwnsRaw, which asserts exclusive use of the handle by the owned object.
+                // AsyncFd needs to wrap an owned `impl std::os::unix::io::AsRawFd`. Rather than introduce
+                // mutability to let it own the `Inner`, we are depending on the `&mut self` bound on this
+                // async method to ensure this is the only Future which can access the RawFd during the
+                // lifetime of the AsyncFd.
+                use std::os::unix::io::AsRawFd;
+                use tokio::io::{unix::AsyncFd, Interest};
+                let rawfd = self.0.borrow().as_fd().as_raw_fd();
+                match AsyncFd::with_interest(rawfd, Interest::WRITABLE) {
+                    Ok(asyncfd) => {
+                        let _ = asyncfd.writable().await?;
+                        Ok(())
+                    }
+                    Err(e) if e.kind() == std::io::ErrorKind::PermissionDenied => {
+                        // if e is EPERM, this file isn't supported by epoll because it is immediately
+                        // available for writing:
+                        Ok(())
+                    }
+                    Err(e) => Err(e.into()),
+                }
+            }
+
+            async fn sock_accept(&self, fdflags: FdFlags) -> Result<Box<dyn WasiFile>, Error> {
+                block_on_dummy_executor(|| self.0.sock_accept(fdflags))
+            }
+        }
+        #[cfg(windows)]
+        impl AsRawHandleOrSocket for $ty {
+            #[inline]
+            fn as_raw_handle_or_socket(&self) -> RawHandleOrSocket {
+                self.0.borrow().as_raw_handle_or_socket()
+            }
+        }
+    };
+}
+
+wasi_file_impl!(File);
+wasi_file_impl!(TcpListener);
+wasi_file_impl!(TcpStream);
+#[cfg(unix)]
+wasi_file_impl!(UnixListener);
+#[cfg(unix)]
+wasi_file_impl!(UnixStream);
+wasi_file_impl!(Stdin);
+wasi_file_impl!(Stdout);
+wasi_file_impl!(Stderr);
diff --git a/crates/wasi-common/src/tokio/mod.rs b/crates/wasi-common/src/tokio/mod.rs
new file mode 100644
index 000000000000..ff80197f28f2
--- /dev/null
+++ b/crates/wasi-common/src/tokio/mod.rs
@@ -0,0 +1,135 @@
+mod dir;
+mod file;
+pub mod net;
+pub mod sched;
+pub mod stdio;
+
+use self::sched::sched_ctx;
+use crate::sync::net::Socket;
+pub use crate::sync::{clocks_ctx, random_ctx};
+use crate::{file::FileAccessMode, Error, Table, WasiCtx, WasiFile};
+pub use dir::Dir;
+pub use file::File;
+pub use net::*;
+use std::future::Future;
+use std::mem;
+use std::path::Path;
+
+pub struct WasiCtxBuilder {
+    ctx: WasiCtx,
+    built: bool,
+}
+
+impl WasiCtxBuilder {
+    pub fn new() -> Self {
+        WasiCtxBuilder {
+            ctx: WasiCtx::new(random_ctx(), clocks_ctx(), sched_ctx(), Table::new()),
+            built: false,
+        }
+    }
+    pub fn env(&mut self, var: &str, value: &str) -> Result<&mut Self, crate::StringArrayError> {
+        self.ctx.push_env(var, value)?;
+        Ok(self)
+    }
+    pub fn envs(&mut self, env: &[(String, String)]) -> Result<&mut Self, crate::StringArrayError> {
+        for (k, v) in env {
+            self.ctx.push_env(k, v)?;
+        }
+        Ok(self)
+    }
+    pub fn inherit_env(&mut self) -> Result<&mut Self, crate::StringArrayError> {
+        for (key, value) in std::env::vars() {
+            self.ctx.push_env(&key, &value)?;
+        }
+        Ok(self)
+    }
+    pub fn arg(&mut self, arg: &str) -> Result<&mut Self, crate::StringArrayError> {
+        self.ctx.push_arg(arg)?;
+        Ok(self)
+    }
+    pub fn args(&mut self, arg: &[String]) -> Result<&mut Self, crate::StringArrayError> {
+        for a in arg {
+            self.ctx.push_arg(&a)?;
+        }
+        Ok(self)
+    }
+    pub fn inherit_args(&mut self) -> Result<&mut Self, crate::StringArrayError> {
+        for arg in std::env::args() {
+            self.ctx.push_arg(&arg)?;
+        }
+        Ok(self)
+    }
+    pub fn stdin(&mut self, f: Box<dyn WasiFile>) -> &mut Self {
+        self.ctx.set_stdin(f);
+        self
+    }
+    pub fn stdout(&mut self, f: Box<dyn WasiFile>) -> &mut Self {
+        self.ctx.set_stdout(f);
+        self
+    }
+    pub fn stderr(&mut self, f: Box<dyn WasiFile>) -> &mut Self {
+        self.ctx.set_stderr(f);
+        self
+    }
+    pub fn inherit_stdin(&mut self) -> &mut Self {
+        self.stdin(Box::new(crate::tokio::stdio::stdin()))
+    }
+    pub fn inherit_stdout(&mut self) -> &mut Self {
+        self.stdout(Box::new(crate::tokio::stdio::stdout()))
+    }
+    pub fn inherit_stderr(&mut self) -> &mut Self {
+        self.stderr(Box::new(crate::tokio::stdio::stderr()))
+    }
+    pub fn inherit_stdio(&mut self) -> &mut Self {
+        self.inherit_stdin().inherit_stdout().inherit_stderr()
+    }
+    pub fn preopened_dir(
+        &mut self,
+        dir: cap_std::fs::Dir,
+        guest_path: impl AsRef<Path>,
+    ) -> Result<&mut Self, Error> {
+        let dir = Box::new(crate::tokio::dir::Dir::from_cap_std(dir));
+        self.ctx.push_preopened_dir(dir, guest_path)?;
+        Ok(self)
+    }
+    pub fn preopened_socket(
+        &mut self,
+        fd: u32,
+        socket: impl Into<Socket>,
+    ) -> Result<&mut Self, Error> {
+        let socket: Socket = socket.into();
+        let file: Box<dyn WasiFile> = socket.into();
+        self.ctx
+            .insert_file(fd, file, FileAccessMode::READ | FileAccessMode::WRITE);
+        Ok(self)
+    }
+
+    pub fn build(&mut self) -> WasiCtx {
+        assert!(!self.built);
+        let WasiCtxBuilder { ctx, .. } = mem::replace(self, Self::new());
+        self.built = true;
+        ctx
+    }
+}
+
+// Much of this mod is implemented in terms of `async` methods from the
+// wasmtime_wasi::sync module. These methods may be async in signature, however,
+// they are synchronous in implementation (always Poll::Ready on first poll)
+// and perform blocking syscalls.
+//
+// This function takes this blocking code and executes it using a dummy executor
+// to assert its immediate readiness. We tell tokio this is a blocking operation
+// with the block_in_place function.
+pub(crate) fn block_on_dummy_executor<'a, F, Fut, T>(f: F) -> Result<T, Error>
+where
+    F: FnOnce() -> Fut + Send + 'a,
+    Fut: Future<Output = Result<T, Error>>,
+    T: Send + 'static,
+{
+    tokio::task::block_in_place(move || {
+        wiggle::run_in_dummy_executor(f()).expect("wrapped operation should be synchronous")
+    })
+}
+
+#[cfg(feature = "wasmtime")]
+super::define_wasi!(async T: Send);
diff --git a/crates/wasi-common/src/tokio/net.rs b/crates/wasi-common/src/tokio/net.rs
new file mode 100644
index 000000000000..93a807ec8294
--- /dev/null
+++ b/crates/wasi-common/src/tokio/net.rs
@@ -0,0 +1,6 @@
+pub use super::file::TcpListener;
+pub use super::file::TcpStream;
+#[cfg(unix)]
+pub use super::file::UnixListener;
+#[cfg(unix)]
+pub use super::file::UnixStream;
diff --git a/crates/wasi-common/src/tokio/sched.rs b/crates/wasi-common/src/tokio/sched.rs
new file mode 100644
index 000000000000..e5c5a42a789d
--- /dev/null
+++ b/crates/wasi-common/src/tokio/sched.rs
@@ -0,0 +1,35 @@
+#[cfg(unix)]
+mod unix;
+#[cfg(unix)]
+pub use unix::poll_oneoff;
+
+#[cfg(windows)]
+mod windows;
+#[cfg(windows)]
+pub use windows::poll_oneoff;
+
+use crate::{
+    sched::{Duration, Poll, WasiSched},
+    Error,
+};
+
+pub fn sched_ctx() -> Box<dyn crate::WasiSched> {
+    struct AsyncSched;
+
+    #[wiggle::async_trait]
+    impl WasiSched for AsyncSched {
+        async fn poll_oneoff<'a>(&self, poll: &mut Poll<'a>) -> Result<(), Error> {
+            poll_oneoff(poll).await
+        }
+        async fn sched_yield(&self) -> Result<(), Error> {
+            tokio::task::yield_now().await;
+            Ok(())
+        }
+        async fn sleep(&self, duration: Duration) -> Result<(), Error> {
+            tokio::time::sleep(duration).await;
+            Ok(())
+        }
+    }
+
+    Box::new(AsyncSched)
+}
diff --git a/crates/wasi-common/src/tokio/sched/unix.rs b/crates/wasi-common/src/tokio/sched/unix.rs
new file mode 100644
index 000000000000..ca28242342fb
--- /dev/null
+++ b/crates/wasi-common/src/tokio/sched/unix.rs
@@ -0,0 +1,96 @@
+use crate::{
+    sched::{
+        subscription::{RwEventFlags, Subscription},
+        Poll,
+    },
+    Error,
+};
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll as FPoll};
+
+struct FirstReady<'a, T>(Vec<Pin<Box<dyn Future<Output = T> + Send + 'a>>>);
+
+impl<'a, T> FirstReady<'a, T> {
+    fn new() -> Self {
+        FirstReady(Vec::new())
+    }
+    fn push(&mut self, f: impl Future<Output = T> + Send + 'a) {
+        self.0.push(Box::pin(f));
+    }
+}
+
+impl<'a, T> Future for FirstReady<'a, T> {
+    type Output = T;
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> FPoll<T> {
+        let mut result = FPoll::Pending;
+        for f in self.as_mut().0.iter_mut() {
+            match f.as_mut().poll(cx) {
+                FPoll::Ready(r) => match result {
+                    // First ready gets to set the result. But, continue the loop so all futures
+                    // which are ready simultaneously (often on first poll) get to report their
+                    // readiness.
+                    FPoll::Pending => {
+                        result = FPoll::Ready(r);
+                    }
+                    _ => {}
+                },
+                _ => continue,
+            }
+        }
+        return result;
+    }
+}
+
+pub async fn poll_oneoff<'a>(poll: &mut Poll<'a>) -> Result<(), Error> {
+    if poll.is_empty() {
+        return Ok(());
+    }
+
+    let duration = poll
+        .earliest_clock_deadline()
+        .map(|sub| sub.duration_until());
+
+    let mut futures = FirstReady::new();
+    for s in poll.rw_subscriptions() {
+        match s {
+            Subscription::Read(f) => {
+                futures.push(async move {
+                    f.file
+                        .readable()
+                        .await
+                        .map_err(|e| e.context("readable future"))?;
+                    f.complete(
+                        f.file
+                            .num_ready_bytes()
+                            .map_err(|e| e.context("read num_ready_bytes"))?,
+                        RwEventFlags::empty(),
+                    );
+                    Ok::<(), Error>(())
+                });
+            }
+
+            Subscription::Write(f) => {
+                futures.push(async move {
+                    f.file
+                        .writable()
+                        .await
+                        .map_err(|e| e.context("writable future"))?;
+                    f.complete(0, RwEventFlags::empty());
+                    Ok(())
+                });
+            }
+            Subscription::MonotonicClock { .. } => unreachable!(),
+        }
+    }
+    if let Some(Some(remaining_duration)) = duration {
+        match tokio::time::timeout(remaining_duration, futures).await {
+            Ok(r) => r?,
+            Err(_deadline_elapsed) => {}
+        }
+    } else {
+        futures.await?;
+    }
+
+    Ok(())
+}
diff --git a/crates/wasi-common/src/tokio/sched/windows.rs b/crates/wasi-common/src/tokio/sched/windows.rs
new file mode 100644
index 000000000000..55b4f5f5374e
--- /dev/null
+++ b/crates/wasi-common/src/tokio/sched/windows.rs
@@ -0,0 +1,15 @@
+use crate::sync::sched::windows::poll_oneoff_;
+use crate::tokio::block_on_dummy_executor;
+use crate::{file::WasiFile, sched::Poll, Error};
+
+pub async fn poll_oneoff<'a>(poll: &mut Poll<'a>) -> Result<(), Error> {
+    // Tokio doesn't provide us the AsyncFd primitive on Windows, so instead
+    // we use the blocking poll_oneoff implementation from the wasi_common::sync impl.
+    // We provide a function specific to this impl's WasiFile types for downcasting
+    // to a RawHandle.
+    block_on_dummy_executor(move || poll_oneoff_(poll, wasi_file_is_stdin))
+}
+
+pub fn wasi_file_is_stdin(f: &dyn WasiFile) -> bool {
+    f.as_any().is::<crate::tokio::stdio::Stdin>()
+}
diff --git a/crates/wasi-common/src/tokio/stdio.rs b/crates/wasi-common/src/tokio/stdio.rs
new file mode 100644
index 000000000000..91590363ede3
--- /dev/null
+++ b/crates/wasi-common/src/tokio/stdio.rs
@@ -0,0 +1 @@
+pub use super::file::{stderr, stdin, stdout, Stderr, Stdin, Stdout};
diff --git a/crates/wasi-common/tests/all/async_.rs b/crates/wasi-common/tests/all/async_.rs
new file mode 100644
index 000000000000..10b70b79c471
--- /dev/null
+++ b/crates/wasi-common/tests/all/async_.rs
@@ -0,0 +1,294 @@
+use super::*;
+use test_programs_artifacts::*;
+use wasi_common::tokio::{add_to_linker, WasiCtxBuilder};
+
+foreach_preview1!(assert_test_exists);
+
+pub fn prepare_workspace(exe_name: &str) -> Result<TempDir> {
+    let prefix = format!("wasi_tokio_{exe_name}_");
+    let tempdir = tempfile::Builder::new().prefix(&prefix).tempdir()?;
+    Ok(tempdir)
+}
+
+async fn run(path: &str, inherit_stdio: bool) -> Result<()> {
+    let path = Path::new(path);
+    let name = path.file_stem().unwrap().to_str().unwrap();
+    let workspace = prepare_workspace(name)?;
+    let stdout = WritePipe::new_in_memory();
+    let stderr = WritePipe::new_in_memory();
+    let r = {
+        let engine = test_programs_artifacts::engine(|config| {
+            config.async_support(true);
+        });
+        let mut linker = Linker::new(&engine);
+        add_to_linker(&mut linker, |cx| cx)?;
+
+        // Create our wasi context.
+        // Additionally register any preopened directories if we have them.
+        let mut builder = WasiCtxBuilder::new();
+
+        if inherit_stdio {
+            builder.inherit_stdio();
+        } else {
+            builder
+                .stdout(Box::new(stdout.clone()))
+                .stderr(Box::new(stderr.clone()));
+        }
+        builder.arg(name)?.arg(".")?;
+        println!("preopen: {workspace:?}");
+        let preopen_dir =
+            cap_std::fs::Dir::open_ambient_dir(workspace.path(), cap_std::ambient_authority())?;
+        builder.preopened_dir(preopen_dir, ".")?;
+        for (var, val) in test_programs_artifacts::wasi_tests_environment() {
+            builder.env(var, val)?;
+        }
+
+        let mut store = Store::new(&engine, builder.build());
+        let module = Module::from_file(&engine, path)?;
+        let instance = linker.instantiate_async(&mut store, &module).await?;
+        let start = instance.get_typed_func::<(), ()>(&mut store, "_start")?;
+        start.call_async(&mut store, ()).await?;
+        Ok(())
+    };
+
+    r.map_err(move |trap: anyhow::Error| {
+        let stdout = stdout
+            .try_into_inner()
+            .expect("sole ref to stdout")
+            .into_inner();
+        if !stdout.is_empty() {
+            println!("guest stdout:\n{}\n===", String::from_utf8_lossy(&stdout));
+        }
+        let stderr = stderr
+            .try_into_inner()
+            .expect("sole ref to stderr")
+            .into_inner();
+        if !stderr.is_empty() {
+            println!("guest stderr:\n{}\n===", String::from_utf8_lossy(&stderr));
+        }
+        trap.context(format!(
+            "error while testing wasi-tests {name} with cap-std-sync"
+        ))
+    })?;
+    Ok(())
+}
+
+// Below here is mechanical: there should be one test for every binary in
+// wasi-tests.
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_big_random_buf() {
+    run(PREVIEW1_BIG_RANDOM_BUF, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_clock_time_get() {
+    run(PREVIEW1_CLOCK_TIME_GET, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_close_preopen() {
+    run(PREVIEW1_CLOSE_PREOPEN, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_dangling_fd() {
+    run(PREVIEW1_DANGLING_FD, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_dangling_symlink() {
+    run(PREVIEW1_DANGLING_SYMLINK, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_directory_seek() {
+    run(PREVIEW1_DIRECTORY_SEEK, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_dir_fd_op_failures() {
+    run(PREVIEW1_DIR_FD_OP_FAILURES, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_fd_advise() {
+    run(PREVIEW1_FD_ADVISE, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_fd_filestat_get() {
+    run(PREVIEW1_FD_FILESTAT_GET, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_fd_filestat_set() {
+    run(PREVIEW1_FD_FILESTAT_SET, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_fd_flags_set() {
+    run(PREVIEW1_FD_FLAGS_SET, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_fd_readdir() {
+    run(PREVIEW1_FD_READDIR, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_allocate() {
+    run(PREVIEW1_FILE_ALLOCATE, true).await.unwrap()
+}
+// see sync.rs for notes about ignores here
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+#[cfg_attr(not(target_os = "linux"), ignore)]
+async fn preview1_file_pread_pwrite() {
+    run(PREVIEW1_FILE_PREAD_PWRITE, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_read_write() {
+    run(PREVIEW1_FILE_READ_WRITE, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_seek_tell() {
+    run(PREVIEW1_FILE_SEEK_TELL, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_truncation() {
+    run(PREVIEW1_FILE_TRUNCATION, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_unbuffered_write() {
+    run(PREVIEW1_FILE_UNBUFFERED_WRITE, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_interesting_paths() {
+    run(PREVIEW1_INTERESTING_PATHS, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_regular_file_isatty() {
+    run(PREVIEW1_REGULAR_FILE_ISATTY, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_nofollow_errors() {
+    run(PREVIEW1_NOFOLLOW_ERRORS, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_overwrite_preopen() {
+    run(PREVIEW1_OVERWRITE_PREOPEN, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_exists() {
+    run(PREVIEW1_PATH_EXISTS, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_filestat() {
+    run(PREVIEW1_PATH_FILESTAT, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_link() {
+    run(PREVIEW1_PATH_LINK, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_create_existing() {
+    run(PREVIEW1_PATH_OPEN_CREATE_EXISTING, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_read_write() {
+    run(PREVIEW1_PATH_OPEN_READ_WRITE, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_dirfd_not_dir() {
+    run(PREVIEW1_PATH_OPEN_DIRFD_NOT_DIR, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_missing() {
+    run(PREVIEW1_PATH_OPEN_MISSING, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_nonblock() {
+    run(PREVIEW1_PATH_OPEN_NONBLOCK, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_rename_dir_trailing_slashes() {
+    run(PREVIEW1_PATH_RENAME_DIR_TRAILING_SLASHES, true)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_rename() {
+    run(PREVIEW1_PATH_RENAME, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_symlink_trailing_slashes() {
+    run(PREVIEW1_PATH_SYMLINK_TRAILING_SLASHES, true)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_poll_oneoff_files() {
+    run(PREVIEW1_POLL_ONEOFF_FILES, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_poll_oneoff_stdio() {
+    run(PREVIEW1_POLL_ONEOFF_STDIO, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_readlink() {
+    run(PREVIEW1_READLINK, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_remove_directory() {
+    run(PREVIEW1_REMOVE_DIRECTORY, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_remove_nonempty_directory() {
+    run(PREVIEW1_REMOVE_NONEMPTY_DIRECTORY, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_renumber() {
+    run(PREVIEW1_RENUMBER, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_sched_yield() {
+    run(PREVIEW1_SCHED_YIELD, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_stdio() {
+    run(PREVIEW1_STDIO, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_stdio_isatty() {
+    // Only a valid test if the host executable's stdio is a terminal:
+    if test_programs_artifacts::stdio_is_terminal() {
+        // Inherit stdio, test asserts it is a tty:
+        run(PREVIEW1_STDIO_ISATTY, true).await.unwrap()
+    }
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_stdio_not_isatty() {
+    // Don't inherit stdio, test asserts each is not tty:
+    run(PREVIEW1_STDIO_NOT_ISATTY, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_symlink_create() {
+    run(PREVIEW1_SYMLINK_CREATE, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_symlink_filestat() {
+    run(PREVIEW1_SYMLINK_FILESTAT, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_symlink_loop() {
+    run(PREVIEW1_SYMLINK_LOOP, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_unlink_file_trailing_slashes() {
+    run(PREVIEW1_UNLINK_FILE_TRAILING_SLASHES, true)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_preopen() {
+    run(PREVIEW1_PATH_OPEN_PREOPEN, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_unicode_output() {
+    run(PREVIEW1_UNICODE_OUTPUT, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_write() {
+    run(PREVIEW1_FILE_WRITE, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_lots() {
+    run(PREVIEW1_PATH_OPEN_LOTS, true).await.unwrap()
+}
diff --git a/crates/wasi-common/tests/all/main.rs b/crates/wasi-common/tests/all/main.rs
new file mode 100644
index 000000000000..bdad3bbe0dcd
--- /dev/null
+++ b/crates/wasi-common/tests/all/main.rs
@@ -0,0 +1,21 @@
+use anyhow::Result;
+use std::path::Path;
+use tempfile::TempDir;
+use wasi_common::pipe::WritePipe;
+use wasmtime::{Linker, Module, Store};
+
+pub fn prepare_workspace(exe_name: &str) -> Result<TempDir> {
+    let prefix = format!("wasi_common_{exe_name}_");
+    let tempdir = tempfile::Builder::new().prefix(&prefix).tempdir()?;
+    Ok(tempdir)
+}
+
+macro_rules! assert_test_exists {
+    ($name:ident) => {
+        #[allow(unused_imports)]
+        use self::$name as _;
+    };
+}
+
+mod async_;
+mod sync;
diff --git a/crates/wasi-common/tests/all/sync.rs b/crates/wasi-common/tests/all/sync.rs
new file mode 100644
index 000000000000..4e0d38ca2fca
--- /dev/null
+++ b/crates/wasi-common/tests/all/sync.rs
@@ -0,0 +1,283 @@
+use super::*;
+use test_programs_artifacts::*;
+use wasi_common::sync::{add_to_linker, WasiCtxBuilder};
+
+foreach_preview1!(assert_test_exists);
+
+fn run(path: &str, inherit_stdio: bool) -> Result<()> {
+    let path = Path::new(path);
+    let name = path.file_stem().unwrap().to_str().unwrap();
+    let workspace = prepare_workspace(name)?;
+    let stdout = WritePipe::new_in_memory();
+    let stderr = WritePipe::new_in_memory();
+    let r = {
+        let engine = test_programs_artifacts::engine(|_| {});
+        let mut linker = Linker::new(&engine);
+        add_to_linker(&mut linker, |cx| cx)?;
+
+        // Create our wasi context.
+        // Additionally register any preopened directories if we have them.
+        let mut builder = WasiCtxBuilder::new();
+
+        if inherit_stdio {
+            builder.inherit_stdio();
+        } else {
+            builder
+                .stdout(Box::new(stdout.clone()))
+                .stderr(Box::new(stderr.clone()));
+        }
+        builder.arg(name)?.arg(".")?;
+        println!("preopen: {workspace:?}");
+        let preopen_dir =
+            cap_std::fs::Dir::open_ambient_dir(workspace.path(), cap_std::ambient_authority())?;
+        builder.preopened_dir(preopen_dir, ".")?;
+        for (var, val) in test_programs_artifacts::wasi_tests_environment() {
+            builder.env(var, val)?;
+        }
+
+        let mut store = Store::new(&engine, builder.build());
+        let module = Module::from_file(&engine, path)?;
+        let instance = linker.instantiate(&mut store, &module)?;
+        let start = instance.get_typed_func::<(), ()>(&mut store, "_start")?;
+        start.call(&mut store, ())?;
+        Ok(())
+    };
+
+    r.map_err(move |trap: anyhow::Error| {
+        let stdout = stdout
+            .try_into_inner()
+            .expect("sole ref to stdout")
+            .into_inner();
+        if !stdout.is_empty() {
+            println!("guest stdout:\n{}\n===", String::from_utf8_lossy(&stdout));
+        }
+        let stderr = stderr
+            .try_into_inner()
+            .expect("sole ref to stderr")
+            .into_inner();
+        if !stderr.is_empty() {
+            println!("guest stderr:\n{}\n===", String::from_utf8_lossy(&stderr));
+        }
+        trap.context(format!(
+            "error while testing wasi-tests {name} with cap-std-sync"
+        ))
+    })?;
+    Ok(())
+}
+
+// Below here is mechanical: there should be one test for every binary in
+// wasi-tests.
+#[test_log::test]
+fn preview1_big_random_buf() {
+    run(PREVIEW1_BIG_RANDOM_BUF, true).unwrap()
+}
+#[test_log::test]
+fn preview1_clock_time_get() {
+    run(PREVIEW1_CLOCK_TIME_GET, true).unwrap()
+}
+#[test_log::test]
+fn preview1_close_preopen() {
+    run(PREVIEW1_CLOSE_PREOPEN, true).unwrap()
+}
+#[test_log::test]
+fn preview1_dangling_fd() {
+    run(PREVIEW1_DANGLING_FD, true).unwrap()
+}
+#[test_log::test]
+fn preview1_dangling_symlink() {
+    run(PREVIEW1_DANGLING_SYMLINK, true).unwrap()
+}
+#[test_log::test]
+fn preview1_directory_seek() {
+    run(PREVIEW1_DIRECTORY_SEEK, true).unwrap()
+}
+#[test_log::test]
+fn preview1_dir_fd_op_failures() {
+    run(PREVIEW1_DIR_FD_OP_FAILURES, true).unwrap()
+}
+#[test_log::test]
+fn preview1_fd_advise() {
+    run(PREVIEW1_FD_ADVISE, true).unwrap()
+}
+#[test_log::test]
+fn preview1_fd_filestat_get() {
+    run(PREVIEW1_FD_FILESTAT_GET, true).unwrap()
+}
+#[test_log::test]
+fn preview1_fd_filestat_set() {
+    run(PREVIEW1_FD_FILESTAT_SET, true).unwrap()
+}
+#[test_log::test]
+fn preview1_fd_flags_set() {
+    run(PREVIEW1_FD_FLAGS_SET, true).unwrap()
+}
+#[test_log::test]
+fn preview1_fd_readdir() {
+    run(PREVIEW1_FD_READDIR, true).unwrap()
+}
+#[test_log::test]
+fn preview1_file_allocate() {
+    run(PREVIEW1_FILE_ALLOCATE, true).unwrap()
+}
+// This test is outside of linux because the behavior of `pwrite`, which this
+// test bottoms out into, differs across platforms. The wasi-common crate
+// doesn't have the infrastructure in place to manually track the append-mode
+// flag easily, but `wasmtime-wasi` has the "correct" behavior here.
+#[test_log::test]
+#[cfg_attr(not(target_os = "linux"), ignore)]
+fn preview1_file_pread_pwrite() {
+    run(PREVIEW1_FILE_PREAD_PWRITE, true).unwrap()
+}
+#[test_log::test]
+fn preview1_file_read_write() {
+    run(PREVIEW1_FILE_READ_WRITE, true).unwrap()
+}
+#[test_log::test]
+fn preview1_file_seek_tell() {
+    run(PREVIEW1_FILE_SEEK_TELL, true).unwrap()
+}
+#[test_log::test]
+fn preview1_file_truncation() {
+    run(PREVIEW1_FILE_TRUNCATION, true).unwrap()
+}
+#[test_log::test]
+fn preview1_file_unbuffered_write() {
+    run(PREVIEW1_FILE_UNBUFFERED_WRITE, true).unwrap()
+}
+#[test_log::test]
+fn preview1_interesting_paths() {
+    run(PREVIEW1_INTERESTING_PATHS, true).unwrap()
+}
+#[test_log::test]
+fn preview1_regular_file_isatty() {
+    run(PREVIEW1_REGULAR_FILE_ISATTY, true).unwrap()
+}
+#[test_log::test]
+fn preview1_nofollow_errors() {
+    run(PREVIEW1_NOFOLLOW_ERRORS, true).unwrap()
+}
+#[test_log::test]
+fn preview1_overwrite_preopen() {
+    run(PREVIEW1_OVERWRITE_PREOPEN, true).unwrap()
+}
+#[test_log::test]
+fn preview1_path_exists() {
+    run(PREVIEW1_PATH_EXISTS, true).unwrap()
+}
+#[test_log::test]
+fn preview1_path_filestat() {
+    run(PREVIEW1_PATH_FILESTAT, true).unwrap()
+}
+#[test_log::test]
+fn preview1_path_link() {
+    run(PREVIEW1_PATH_LINK, true).unwrap()
+}
+#[test_log::test]
+fn preview1_path_open_create_existing() {
+    run(PREVIEW1_PATH_OPEN_CREATE_EXISTING, true).unwrap()
+}
+#[test_log::test]
+fn preview1_path_open_read_write() {
+    run(PREVIEW1_PATH_OPEN_READ_WRITE, true).unwrap()
+}
+#[test_log::test]
+fn preview1_path_open_dirfd_not_dir() {
+    run(PREVIEW1_PATH_OPEN_DIRFD_NOT_DIR, true).unwrap()
+}
+#[test_log::test]
+fn preview1_path_open_missing() {
+    run(PREVIEW1_PATH_OPEN_MISSING, true).unwrap()
+}
+#[test_log::test]
+fn preview1_path_open_nonblock() {
+    run(PREVIEW1_PATH_OPEN_NONBLOCK, true).unwrap()
+}
+#[test_log::test]
+fn preview1_path_rename_dir_trailing_slashes() {
+    run(PREVIEW1_PATH_RENAME_DIR_TRAILING_SLASHES, true).unwrap()
+}
+#[test_log::test]
+fn preview1_path_rename() {
+    run(PREVIEW1_PATH_RENAME, true).unwrap()
+}
+#[test_log::test]
+fn preview1_path_symlink_trailing_slashes() {
+    run(PREVIEW1_PATH_SYMLINK_TRAILING_SLASHES, true).unwrap()
+}
+#[test_log::test]
+fn preview1_poll_oneoff_files() {
+    run(PREVIEW1_POLL_ONEOFF_FILES, false).unwrap()
+}
+#[test_log::test]
+fn preview1_poll_oneoff_stdio() {
+    run(PREVIEW1_POLL_ONEOFF_STDIO, true).unwrap()
+}
+#[test_log::test]
+fn preview1_readlink() {
+    run(PREVIEW1_READLINK, true).unwrap()
+}
+#[test_log::test]
+fn preview1_remove_directory() {
+    run(PREVIEW1_REMOVE_DIRECTORY, true).unwrap()
+}
+#[test_log::test]
+fn preview1_remove_nonempty_directory() {
+    run(PREVIEW1_REMOVE_NONEMPTY_DIRECTORY, true).unwrap()
+}
+#[test_log::test]
+fn preview1_renumber() {
+    run(PREVIEW1_RENUMBER, true).unwrap()
+}
+#[test_log::test]
+fn preview1_sched_yield() {
+    run(PREVIEW1_SCHED_YIELD, true).unwrap()
+}
+#[test_log::test]
+fn preview1_stdio() {
+    run(PREVIEW1_STDIO, true).unwrap()
+}
+#[test_log::test]
+fn preview1_stdio_isatty() {
+    if test_programs_artifacts::stdio_is_terminal() {
+        // Inherit stdio, which is a terminal in the test runner's environment:
+        run(PREVIEW1_STDIO_ISATTY, true).unwrap()
+    }
+}
+#[test_log::test]
+fn preview1_stdio_not_isatty() {
+    // Don't inherit stdio, test asserts each is not tty:
+    run(PREVIEW1_STDIO_NOT_ISATTY, false).unwrap()
+}
+
+#[test_log::test]
+fn preview1_symlink_create() {
+    run(PREVIEW1_SYMLINK_CREATE, true).unwrap()
+}
+#[test_log::test]
+fn preview1_symlink_filestat() {
+    run(PREVIEW1_SYMLINK_FILESTAT, true).unwrap()
+}
+#[test_log::test]
+fn preview1_symlink_loop() {
+    run(PREVIEW1_SYMLINK_LOOP, true).unwrap()
+}
+#[test_log::test]
+fn preview1_unlink_file_trailing_slashes() {
+    run(PREVIEW1_UNLINK_FILE_TRAILING_SLASHES, true).unwrap()
+}
+#[test_log::test]
+fn preview1_path_open_preopen() {
+    run(PREVIEW1_PATH_OPEN_PREOPEN, true).unwrap()
+}
+#[test_log::test]
+fn preview1_unicode_output() {
+    run(PREVIEW1_UNICODE_OUTPUT, true).unwrap()
+}
+#[test_log::test]
+fn preview1_file_write() {
+    run(PREVIEW1_FILE_WRITE, true).unwrap()
+}
+#[test_log::test]
+fn preview1_path_open_lots() {
+    run(PREVIEW1_PATH_OPEN_LOTS, true).unwrap()
+}
diff --git a/crates/wasi-common/tokio/Cargo.toml b/crates/wasi-common/tokio/Cargo.toml
deleted file mode 100644
index 43ad576a86a9..000000000000
--- a/crates/wasi-common/tokio/Cargo.toml
+++ /dev/null
@@ -1,31 +0,0 @@
-[package]
-name = "wasi-tokio"
-version.workspace = true
-authors.workspace = true
-description = "WASI implementation in Rust"
-license = "Apache-2.0 WITH LLVM-exception"
-categories = ["wasm"]
-keywords = ["webassembly", "wasm"]
-repository = "https://github.com/bytecodealliance/wasmtime"
-edition.workspace = true
-include = ["src/**/*", "LICENSE" ]
-
-[dependencies]
-wasi-common = { workspace = true }
-wasi-cap-std-sync = { workspace = true }
-wiggle = { workspace = true }
-tokio = { workspace = true, features = [ "rt", "fs", "time", "io-util", "net", "io-std", "rt-multi-thread"] }
-cap-std = { workspace = true }
-anyhow = { workspace = true }
-io-lifetimes = { workspace = true }
-
-[target.'cfg(unix)'.dependencies]
-rustix = { workspace = true, features = ["fs"] }
-
-[target.'cfg(windows)'.dependencies]
-io-extras = { workspace = true }
-
-[dev-dependencies]
-tempfile = "3.1.0"
-tokio = { workspace = true, features = [ "macros" ] }
-cap-tempfile = { workspace = true }
diff --git a/crates/wasi-common/tokio/LICENSE b/crates/wasi-common/tokio/LICENSE
deleted file mode 100644
index f9d81955f4bc..000000000000
--- a/crates/wasi-common/tokio/LICENSE
+++ /dev/null
@@ -1,220 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-
-
---- LLVM Exceptions to the Apache 2.0 License ----
-
-As an exception, if, as a result of your compiling your source code, portions
-of this Software are embedded into an Object form of such source code, you
-may redistribute such embedded portions in such Object form without complying
-with the conditions of Sections 4(a), 4(b) and 4(d) of the License.
-
-In addition, if you combine or link compiled forms of this Software with
-software that is licensed under the GPLv2 ("Combined Software") and if a
-court of competent jurisdiction determines that the patent provision (Section
-3), the indemnity provision (Section 9) or other Section of the License
-conflicts with the conditions of the GPLv2, you may retroactively and
-prospectively choose to deem waived or otherwise exclude such Section(s) of
-the License, but only in their entirety and only with respect to the Combined
-Software.
-
diff --git a/crates/wasi-common/tokio/src/dir.rs b/crates/wasi-common/tokio/src/dir.rs
deleted file mode 100644
index 5482a08c7619..000000000000
--- a/crates/wasi-common/tokio/src/dir.rs
+++ /dev/null
@@ -1,221 +0,0 @@
-use crate::{block_on_dummy_executor, file::File};
-use std::any::Any;
-use std::path::PathBuf;
-use wasi_common::{
-    dir::{ReaddirCursor, ReaddirEntity, WasiDir},
-    file::{FdFlags, Filestat, OFlags},
-    Error, ErrorExt,
-};
-
-pub struct Dir(wasi_cap_std_sync::dir::Dir);
-
-impl Dir {
-    pub fn from_cap_std(dir: cap_std::fs::Dir) -> Self {
-        Dir(wasi_cap_std_sync::dir::Dir::from_cap_std(dir))
-    }
-}
-
-#[wiggle::async_trait]
-impl WasiDir for Dir {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-    async fn open_file(
-        &self,
-        symlink_follow: bool,
-        path: &str,
-        oflags: OFlags,
-        read: bool,
-        write: bool,
-        fdflags: FdFlags,
-    ) -> Result<wasi_common::dir::OpenResult, Error> {
-        let f = block_on_dummy_executor(move || async move {
-            self.0
-                .open_file_(symlink_follow, path, oflags, read, write, fdflags)
-        })?;
-        match f {
-            wasi_cap_std_sync::dir::OpenResult::File(f) => Ok(wasi_common::dir::OpenResult::File(
-                Box::new(File::from_inner(f)),
-            )),
-            wasi_cap_std_sync::dir::OpenResult::Dir(d) => {
-                Ok(wasi_common::dir::OpenResult::Dir(Box::new(Dir(d))))
-            }
-        }
-    }
-
-    async fn create_dir(&self, path: &str) -> Result<(), Error> {
-        block_on_dummy_executor(|| self.0.create_dir(path))
-    }
-    async fn readdir(
-        &self,
-        cursor: ReaddirCursor,
-    ) -> Result<Box<dyn Iterator<Item = Result<ReaddirEntity, Error>> + Send>, Error> {
-        struct I(Box<dyn Iterator<Item = Result<ReaddirEntity, Error>> + Send>);
-        impl Iterator for I {
-            type Item = Result<ReaddirEntity, Error>;
-            fn next(&mut self) -> Option<Self::Item> {
-                tokio::task::block_in_place(move || self.0.next())
-            }
-        }
-
-        let inner = block_on_dummy_executor(move || self.0.readdir(cursor))?;
-        Ok(Box::new(I(inner)))
-    }
-
-    async fn symlink(&self, src_path: &str, dest_path: &str) -> Result<(), Error> {
-        block_on_dummy_executor(move || self.0.symlink(src_path, dest_path))
-    }
-    async fn remove_dir(&self, path: &str) -> Result<(), Error> {
-        block_on_dummy_executor(move || self.0.remove_dir(path))
-    }
-
-    async fn unlink_file(&self, path: &str) -> Result<(), Error> {
-        block_on_dummy_executor(move || self.0.unlink_file(path))
-    }
-    async fn read_link(&self, path: &str) -> Result<PathBuf, Error> {
-        block_on_dummy_executor(move || self.0.read_link(path))
-    }
-    async fn get_filestat(&self) -> Result<Filestat, Error> {
-        block_on_dummy_executor(|| self.0.get_filestat())
-    }
-    async fn get_path_filestat(
-        &self,
-        path: &str,
-        follow_symlinks: bool,
-    ) -> Result<Filestat, Error> {
-        block_on_dummy_executor(move || self.0.get_path_filestat(path, follow_symlinks))
-    }
-    async fn rename(
-        &self,
-        src_path: &str,
-        dest_dir: &dyn WasiDir,
-        dest_path: &str,
-    ) -> Result<(), Error> {
-        let dest_dir = dest_dir
-            .as_any()
-            .downcast_ref::<Self>()
-            .ok_or(Error::badf().context("failed downcast to tokio Dir"))?;
-        block_on_dummy_executor(
-            move || async move { self.0.rename_(src_path, &dest_dir.0, dest_path) },
-        )
-    }
-    async fn hard_link(
-        &self,
-        src_path: &str,
-        target_dir: &dyn WasiDir,
-        target_path: &str,
-    ) -> Result<(), Error> {
-        let target_dir = target_dir
-            .as_any()
-            .downcast_ref::<Self>()
-            .ok_or(Error::badf().context("failed downcast to tokio Dir"))?;
-        block_on_dummy_executor(move || async move {
-            self.0.hard_link_(src_path, &target_dir.0, target_path)
-        })
-    }
-    async fn set_times(
-        &self,
-        path: &str,
-        atime: Option<wasi_common::SystemTimeSpec>,
-        mtime: Option<wasi_common::SystemTimeSpec>,
-        follow_symlinks: bool,
-    ) -> Result<(), Error> {
-        block_on_dummy_executor(move || self.0.set_times(path, atime, mtime, follow_symlinks))
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::Dir;
-    use cap_std::ambient_authority;
-    use wasi_common::file::{FdFlags, OFlags};
-
-    #[tokio::test(flavor = "multi_thread")]
-    async fn scratch_dir() {
-        let tempdir = tempfile::Builder::new()
-            .prefix("cap-std-sync")
-            .tempdir()
-            .expect("create temporary dir");
-        let preopen_dir = cap_std::fs::Dir::open_ambient_dir(tempdir.path(), ambient_authority())
-            .expect("open ambient temporary dir");
-        let preopen_dir = Dir::from_cap_std(preopen_dir);
-        wasi_common::WasiDir::open_file(
-            &preopen_dir,
-            false,
-            ".",
-            OFlags::empty(),
-            false,
-            false,
-            FdFlags::empty(),
-        )
-        .await
-        .expect("open the same directory via WasiDir abstraction");
-    }
-
-    // Readdir does not work on windows, so we won't test it there.
-    #[cfg(not(windows))]
-    #[tokio::test(flavor = "multi_thread")]
-    async fn readdir() {
-        use std::collections::HashMap;
-        use wasi_common::dir::{ReaddirCursor, ReaddirEntity, WasiDir};
-        use wasi_common::file::{FdFlags, FileType, OFlags};
-
-        async fn readdir_into_map(dir: &dyn WasiDir) -> HashMap<String, ReaddirEntity> {
-            let mut out = HashMap::new();
-            for readdir_result in dir
-                .readdir(ReaddirCursor::from(0))
-                .await
-                .expect("readdir succeeds")
-            {
-                let entity = readdir_result.expect("readdir entry is valid");
-                out.insert(entity.name.clone(), entity);
-            }
-            out
-        }
-
-        let tempdir = tempfile::Builder::new()
-            .prefix("cap-std-sync")
-            .tempdir()
-            .expect("create temporary dir");
-        let preopen_dir = cap_std::fs::Dir::open_ambient_dir(tempdir.path(), ambient_authority())
-            .expect("open ambient temporary dir");
-        let preopen_dir = Dir::from_cap_std(preopen_dir);
-
-        let entities = readdir_into_map(&preopen_dir).await;
-        assert_eq!(
-            entities.len(),
-            2,
-            "should just be . and .. in empty dir: {:?}",
-            entities
-        );
-        assert!(entities.get(".").is_some());
-        assert!(entities.get("..").is_some());
-
-        preopen_dir
-            .open_file(
-                false,
-                "file1",
-                OFlags::CREATE,
-                true,
-                false,
-                FdFlags::empty(),
-            )
-            .await
-            .expect("create file1");
-
-        let entities = readdir_into_map(&preopen_dir).await;
-        assert_eq!(entities.len(), 3, "should be ., .., file1 {:?}", entities);
-        assert_eq!(
-            entities.get(".").expect(". entry").filetype,
-            FileType::Directory
-        );
-        assert_eq!(
-            entities.get("..").expect(".. entry").filetype,
-            FileType::Directory
-        );
-        assert_eq!(
-            entities.get("file1").expect("file1 entry").filetype,
-            FileType::RegularFile
-        );
-    }
-}
diff --git a/crates/wasi-common/tokio/src/file.rs b/crates/wasi-common/tokio/src/file.rs
deleted file mode 100644
index 2fa8ddaf8639..000000000000
--- a/crates/wasi-common/tokio/src/file.rs
+++ /dev/null
@@ -1,244 +0,0 @@
-use crate::block_on_dummy_executor;
-#[cfg(windows)]
-use io_extras::os::windows::{AsRawHandleOrSocket, RawHandleOrSocket};
-#[cfg(not(windows))]
-use io_lifetimes::AsFd;
-use std::any::Any;
-use std::borrow::Borrow;
-use std::io;
-use wasi_common::{
-    file::{Advice, FdFlags, FileType, Filestat, WasiFile},
-    Error,
-};
-
-pub struct File(wasi_cap_std_sync::file::File);
-
-impl File {
-    pub(crate) fn from_inner(file: wasi_cap_std_sync::file::File) -> Self {
-        File(file)
-    }
-    pub fn from_cap_std(file: cap_std::fs::File) -> Self {
-        Self::from_inner(wasi_cap_std_sync::file::File::from_cap_std(file))
-    }
-}
-
-pub struct TcpListener(wasi_cap_std_sync::net::TcpListener);
-
-impl TcpListener {
-    pub(crate) fn from_inner(listener: wasi_cap_std_sync::net::TcpListener) -> Self {
-        TcpListener(listener)
-    }
-    pub fn from_cap_std(listener: cap_std::net::TcpListener) -> Self {
-        Self::from_inner(wasi_cap_std_sync::net::TcpListener::from_cap_std(listener))
-    }
-}
-
-pub struct TcpStream(wasi_cap_std_sync::net::TcpStream);
-
-impl TcpStream {
-    pub(crate) fn from_inner(stream: wasi_cap_std_sync::net::TcpStream) -> Self {
-        TcpStream(stream)
-    }
-    pub fn from_cap_std(stream: cap_std::net::TcpStream) -> Self {
-        Self::from_inner(wasi_cap_std_sync::net::TcpStream::from_cap_std(stream))
-    }
-}
-
-#[cfg(unix)]
-pub struct UnixListener(wasi_cap_std_sync::net::UnixListener);
-
-#[cfg(unix)]
-impl UnixListener {
-    pub(crate) fn from_inner(listener: wasi_cap_std_sync::net::UnixListener) -> Self {
-        UnixListener(listener)
-    }
-    pub fn from_cap_std(listener: cap_std::os::unix::net::UnixListener) -> Self {
-        Self::from_inner(wasi_cap_std_sync::net::UnixListener::from_cap_std(listener))
-    }
-}
-
-#[cfg(unix)]
-pub struct UnixStream(wasi_cap_std_sync::net::UnixStream);
-
-#[cfg(unix)]
-impl UnixStream {
-    fn from_inner(stream: wasi_cap_std_sync::net::UnixStream) -> Self {
-        UnixStream(stream)
-    }
-    pub fn from_cap_std(stream: cap_std::os::unix::net::UnixStream) -> Self {
-        Self::from_inner(wasi_cap_std_sync::net::UnixStream::from_cap_std(stream))
-    }
-}
-
-pub struct Stdin(wasi_cap_std_sync::stdio::Stdin);
-
-pub fn stdin() -> Stdin {
-    Stdin(wasi_cap_std_sync::stdio::stdin())
-}
-
-pub struct Stdout(wasi_cap_std_sync::stdio::Stdout);
-
-pub fn stdout() -> Stdout {
-    Stdout(wasi_cap_std_sync::stdio::stdout())
-}
-
-pub struct Stderr(wasi_cap_std_sync::stdio::Stderr);
-
-pub fn stderr() -> Stderr {
-    Stderr(wasi_cap_std_sync::stdio::stderr())
-}
-
-macro_rules! wasi_file_impl {
-    ($ty:ty) => {
-        #[wiggle::async_trait]
-        impl WasiFile for $ty {
-            fn as_any(&self) -> &dyn Any {
-                self
-            }
-            #[cfg(unix)]
-            fn pollable(&self) -> Option<rustix::fd::BorrowedFd> {
-                Some(self.0.as_fd())
-            }
-            #[cfg(windows)]
-            fn pollable(&self) -> Option<io_extras::os::windows::RawHandleOrSocket> {
-                Some(self.0.as_raw_handle_or_socket())
-            }
-            async fn datasync(&self) -> Result<(), Error> {
-                block_on_dummy_executor(|| self.0.datasync())
-            }
-            async fn sync(&self) -> Result<(), Error> {
-                block_on_dummy_executor(|| self.0.sync())
-            }
-            async fn get_filetype(&self) -> Result<FileType, Error> {
-                block_on_dummy_executor(|| self.0.get_filetype())
-            }
-            async fn get_fdflags(&self) -> Result<FdFlags, Error> {
-                block_on_dummy_executor(|| self.0.get_fdflags())
-            }
-            async fn set_fdflags(&mut self, fdflags: FdFlags) -> Result<(), Error> {
-                block_on_dummy_executor(|| self.0.set_fdflags(fdflags))
-            }
-            async fn get_filestat(&self) -> Result<Filestat, Error> {
-                block_on_dummy_executor(|| self.0.get_filestat())
-            }
-            async fn set_filestat_size(&self, size: u64) -> Result<(), Error> {
-                block_on_dummy_executor(move || self.0.set_filestat_size(size))
-            }
-            async fn advise(&self, offset: u64, len: u64, advice: Advice) -> Result<(), Error> {
-                block_on_dummy_executor(move || self.0.advise(offset, len, advice))
-            }
-            async fn read_vectored<'a>(
-                &self,
-                bufs: &mut [io::IoSliceMut<'a>],
-            ) -> Result<u64, Error> {
-                block_on_dummy_executor(move || self.0.read_vectored(bufs))
-            }
-            async fn read_vectored_at<'a>(
-                &self,
-                bufs: &mut [io::IoSliceMut<'a>],
-                offset: u64,
-            ) -> Result<u64, Error> {
-                block_on_dummy_executor(move || self.0.read_vectored_at(bufs, offset))
-            }
-            async fn write_vectored<'a>(&self, bufs: &[io::IoSlice<'a>]) -> Result<u64, Error> {
-                block_on_dummy_executor(move || self.0.write_vectored(bufs))
-            }
-            async fn write_vectored_at<'a>(
-                &self,
-                bufs: &[io::IoSlice<'a>],
-                offset: u64,
-            ) -> Result<u64, Error> {
-                block_on_dummy_executor(move || self.0.write_vectored_at(bufs, offset))
-            }
-            async fn seek(&self, pos: std::io::SeekFrom) -> Result<u64, Error> {
-                block_on_dummy_executor(move || self.0.seek(pos))
-            }
-            async fn peek(&self, buf: &mut [u8]) -> Result<u64, Error> {
-                block_on_dummy_executor(move || self.0.peek(buf))
-            }
-            async fn set_times(
-                &self,
-                atime: Option<wasi_common::SystemTimeSpec>,
-                mtime: Option<wasi_common::SystemTimeSpec>,
-            ) -> Result<(), Error> {
-                block_on_dummy_executor(move || self.0.set_times(atime, mtime))
-            }
-            fn num_ready_bytes(&self) -> Result<u64, Error> {
-                self.0.num_ready_bytes()
-            }
-            fn isatty(&self) -> bool {
-                self.0.isatty()
-            }
-
-            #[cfg(not(windows))]
-            async fn readable(&self) -> Result<(), Error> {
-                // The Inner impls OwnsRaw, which asserts exclusive use of the handle by the owned object.
-                // AsyncFd needs to wrap an owned `impl std::os::unix::io::AsRawFd`. Rather than introduce
-                // mutability to let it own the `Inner`, we are depending on the `&mut self` bound on this
-                // async method to ensure this is the only Future which can access the RawFd during the
-                // lifetime of the AsyncFd.
-                use std::os::unix::io::AsRawFd;
-                use tokio::io::{unix::AsyncFd, Interest};
-                let rawfd = self.0.borrow().as_fd().as_raw_fd();
-                match AsyncFd::with_interest(rawfd, Interest::READABLE) {
-                    Ok(asyncfd) => {
-                        let _ = asyncfd.readable().await?;
-                        Ok(())
-                    }
-                    Err(e) if e.kind() == std::io::ErrorKind::PermissionDenied => {
-                        // if e is EPERM, this file isnt supported by epoll because it is immediately
-                        // available for reading:
-                        Ok(())
-                    }
-                    Err(e) => Err(e.into()),
-                }
-            }
-
-            #[cfg(not(windows))]
-            async fn writable(&self) -> Result<(), Error> {
-                // The Inner impls OwnsRaw, which asserts exclusive use of the handle by the owned object.
-                // AsyncFd needs to wrap an owned `impl std::os::unix::io::AsRawFd`. Rather than introduce
-                // mutability to let it own the `Inner`, we are depending on the `&mut self` bound on this
-                // async method to ensure this is the only Future which can access the RawFd during the
-                // lifetime of the AsyncFd.
-                use std::os::unix::io::AsRawFd;
-                use tokio::io::{unix::AsyncFd, Interest};
-                let rawfd = self.0.borrow().as_fd().as_raw_fd();
-                match AsyncFd::with_interest(rawfd, Interest::WRITABLE) {
-                    Ok(asyncfd) => {
-                        let _ = asyncfd.writable().await?;
-                        Ok(())
-                    }
-                    Err(e) if e.kind() == std::io::ErrorKind::PermissionDenied => {
-                        // if e is EPERM, this file isnt supported by epoll because it is immediately
-                        // available for writing:
-                        Ok(())
-                    }
-                    Err(e) => Err(e.into()),
-                }
-            }
-
-            async fn sock_accept(&self, fdflags: FdFlags) -> Result<Box<dyn WasiFile>, Error> {
-                block_on_dummy_executor(|| self.0.sock_accept(fdflags))
-            }
-        }
-        #[cfg(windows)]
-        impl AsRawHandleOrSocket for $ty {
-            #[inline]
-            fn as_raw_handle_or_socket(&self) -> RawHandleOrSocket {
-                self.0.borrow().as_raw_handle_or_socket()
-            }
-        }
-    };
-}
-
-wasi_file_impl!(File);
-wasi_file_impl!(TcpListener);
-wasi_file_impl!(TcpStream);
-#[cfg(unix)]
-wasi_file_impl!(UnixListener);
-#[cfg(unix)]
-wasi_file_impl!(UnixStream);
-wasi_file_impl!(Stdin);
-wasi_file_impl!(Stdout);
-wasi_file_impl!(Stderr);
diff --git a/crates/wasi-common/tokio/src/lib.rs b/crates/wasi-common/tokio/src/lib.rs
deleted file mode 100644
index a65021c19af5..000000000000
--- a/crates/wasi-common/tokio/src/lib.rs
+++ /dev/null
@@ -1,141 +0,0 @@
-#![cfg_attr(io_lifetimes_use_std, feature(io_safety))]
-
-mod dir;
-mod file;
-pub mod net;
-pub mod sched;
-pub mod stdio;
-
-use crate::sched::sched_ctx;
-pub use dir::Dir;
-pub use file::File;
-pub use net::*;
-use std::future::Future;
-use std::mem;
-use std::path::Path;
-use wasi_cap_std_sync::net::Socket;
-pub use wasi_cap_std_sync::{clocks_ctx, random_ctx};
-use wasi_common::{file::FileAccessMode, Error, Table, WasiCtx, WasiFile};
-
-pub struct WasiCtxBuilder {
-    ctx: WasiCtx,
-    built: bool,
-}
-
-impl WasiCtxBuilder {
-    pub fn new() -> Self {
-        WasiCtxBuilder {
-            ctx: WasiCtx::new(random_ctx(), clocks_ctx(), sched_ctx(), Table::new()),
-            built: false,
-        }
-    }
-    pub fn env(
-        &mut self,
-        var: &str,
-        value: &str,
-    ) -> Result<&mut Self, wasi_common::StringArrayError> {
-        self.ctx.push_env(var, value)?;
-        Ok(self)
-    }
-    pub fn envs(
-        &mut self,
-        env: &[(String, String)],
-    ) -> Result<&mut Self, wasi_common::StringArrayError> {
-        for (k, v) in env {
-            self.ctx.push_env(k, v)?;
-        }
-        Ok(self)
-    }
-    pub fn inherit_env(&mut self) -> Result<&mut Self, wasi_common::StringArrayError> {
-        for (key, value) in std::env::vars() {
-            self.ctx.push_env(&key, &value)?;
-        }
-        Ok(self)
-    }
-    pub fn arg(&mut self, arg: &str) -> Result<&mut Self, wasi_common::StringArrayError> {
-        self.ctx.push_arg(arg)?;
-        Ok(self)
-    }
-    pub fn args(&mut self, arg: &[String]) -> Result<&mut Self, wasi_common::StringArrayError> {
-        for a in arg {
-            self.ctx.push_arg(&a)?;
-        }
-        Ok(self)
-    }
-    pub fn inherit_args(&mut self) -> Result<&mut Self, wasi_common::StringArrayError> {
-        for arg in std::env::args() {
-            self.ctx.push_arg(&arg)?;
-        }
-        Ok(self)
-    }
-    pub fn stdin(&mut self, f: Box<dyn WasiFile>) -> &mut Self {
-        self.ctx.set_stdin(f);
-        self
-    }
-    pub fn stdout(&mut self, f: Box<dyn WasiFile>) -> &mut Self {
-        self.ctx.set_stdout(f);
-        self
-    }
-    pub fn stderr(&mut self, f: Box<dyn WasiFile>) -> &mut Self {
-        self.ctx.set_stderr(f);
-        self
-    }
-    pub fn inherit_stdin(&mut self) -> &mut Self {
-        self.stdin(Box::new(crate::stdio::stdin()))
-    }
-    pub fn inherit_stdout(&mut self) -> &mut Self {
-        self.stdout(Box::new(crate::stdio::stdout()))
-    }
-    pub fn inherit_stderr(&mut self) -> &mut Self {
-        self.stderr(Box::new(crate::stdio::stderr()))
-    }
-    pub fn inherit_stdio(&mut self) -> &mut Self {
-        self.inherit_stdin().inherit_stdout().inherit_stderr()
-    }
-    pub fn preopened_dir(
-        &mut self,
-        dir: cap_std::fs::Dir,
-        guest_path: impl AsRef<Path>,
-    ) -> Result<&mut Self, Error> {
-        let dir = Box::new(crate::dir::Dir::from_cap_std(dir));
-        self.ctx.push_preopened_dir(dir, guest_path)?;
-        Ok(self)
-    }
-    pub fn preopened_socket(
-        &mut self,
-        fd: u32,
-        socket: impl Into<Socket>,
-    ) -> Result<&mut Self, Error> {
-        let socket: Socket = socket.into();
-        let file: Box<dyn WasiFile> = socket.into();
-        self.ctx
-            .insert_file(fd, file, FileAccessMode::READ | FileAccessMode::WRITE);
-        Ok(self)
-    }
-
-    pub fn build(&mut self) -> WasiCtx {
-        assert!(!self.built);
-        let WasiCtxBuilder { ctx, .. } = mem::replace(self, Self::new());
-        self.built = true;
-        ctx
-    }
-}
-
-// Much of this crate is implemented in terms of `async` methods from the
-// wasi-cap-std-sync crate. These methods may be async in signature, however,
-// they are synchronous in implementation (always Poll::Ready on first poll)
-// and perform blocking syscalls.
-//
-// This function takes this blocking code and executes it using a dummy executor
-// to assert its immediate readiness. We tell tokio this is a blocking operation
-// with the block_in_place function.
-pub(crate) fn block_on_dummy_executor<'a, F, Fut, T>(f: F) -> Result<T, Error>
-where
-    F: FnOnce() -> Fut + Send + 'a,
-    Fut: Future<Output = Result<T, Error>>,
-    T: Send + 'static,
-{
-    tokio::task::block_in_place(move || {
-        wiggle::run_in_dummy_executor(f()).expect("wrapped operation should be synchronous")
-    })
-}
diff --git a/crates/wasi-common/tokio/src/net.rs b/crates/wasi-common/tokio/src/net.rs
deleted file mode 100644
index 03e390a83bcd..000000000000
--- a/crates/wasi-common/tokio/src/net.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-pub use crate::file::TcpListener;
-pub use crate::file::TcpStream;
-#[cfg(unix)]
-pub use crate::file::UnixListener;
-#[cfg(unix)]
-pub use crate::file::UnixStream;
diff --git a/crates/wasi-common/tokio/src/sched.rs b/crates/wasi-common/tokio/src/sched.rs
deleted file mode 100644
index 1b971666415b..000000000000
--- a/crates/wasi-common/tokio/src/sched.rs
+++ /dev/null
@@ -1,35 +0,0 @@
-#[cfg(unix)]
-mod unix;
-#[cfg(unix)]
-pub use unix::poll_oneoff;
-
-#[cfg(windows)]
-mod windows;
-#[cfg(windows)]
-pub use windows::poll_oneoff;
-
-use wasi_common::{
-    sched::{Duration, Poll, WasiSched},
-    Error,
-};
-
-pub fn sched_ctx() -> Box<dyn wasi_common::WasiSched> {
-    struct AsyncSched;
-
-    #[wiggle::async_trait]
-    impl WasiSched for AsyncSched {
-        async fn poll_oneoff<'a>(&self, poll: &mut Poll<'a>) -> Result<(), Error> {
-            poll_oneoff(poll).await
-        }
-        async fn sched_yield(&self) -> Result<(), Error> {
-            tokio::task::yield_now().await;
-            Ok(())
-        }
-        async fn sleep(&self, duration: Duration) -> Result<(), Error> {
-            tokio::time::sleep(duration).await;
-            Ok(())
-        }
-    }
-
-    Box::new(AsyncSched)
-}
diff --git a/crates/wasi-common/tokio/src/sched/unix.rs b/crates/wasi-common/tokio/src/sched/unix.rs
deleted file mode 100644
index 4fd47d1cb248..000000000000
--- a/crates/wasi-common/tokio/src/sched/unix.rs
+++ /dev/null
@@ -1,96 +0,0 @@
-use std::future::Future;
-use std::pin::Pin;
-use std::task::{Context, Poll as FPoll};
-use wasi_common::{
-    sched::{
-        subscription::{RwEventFlags, Subscription},
-        Poll,
-    },
-    Error,
-};
-
-struct FirstReady<'a, T>(Vec<Pin<Box<dyn Future<Output = T> + Send + 'a>>>);
-
-impl<'a, T> FirstReady<'a, T> {
-    fn new() -> Self {
-        FirstReady(Vec::new())
-    }
-    fn push(&mut self, f: impl Future<Output = T> + Send + 'a) {
-        self.0.push(Box::pin(f));
-    }
-}
-
-impl<'a, T> Future for FirstReady<'a, T> {
-    type Output = T;
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> FPoll<T> {
-        let mut result = FPoll::Pending;
-        for f in self.as_mut().0.iter_mut() {
-            match f.as_mut().poll(cx) {
-                FPoll::Ready(r) => match result {
-                    // First ready gets to set the result. But, continue the loop so all futures
-                    // which are ready simultaneously (often on first poll) get to report their
-                    // readiness.
-                    FPoll::Pending => {
-                        result = FPoll::Ready(r);
-                    }
-                    _ => {}
-                },
-                _ => continue,
-            }
-        }
-        return result;
-    }
-}
-
-pub async fn poll_oneoff<'a>(poll: &mut Poll<'a>) -> Result<(), Error> {
-    if poll.is_empty() {
-        return Ok(());
-    }
-
-    let duration = poll
-        .earliest_clock_deadline()
-        .map(|sub| sub.duration_until());
-
-    let mut futures = FirstReady::new();
-    for s in poll.rw_subscriptions() {
-        match s {
-            Subscription::Read(f) => {
-                futures.push(async move {
-                    f.file
-                        .readable()
-                        .await
-                        .map_err(|e| e.context("readable future"))?;
-                    f.complete(
-                        f.file
-                            .num_ready_bytes()
-                            .map_err(|e| e.context("read num_ready_bytes"))?,
-                        RwEventFlags::empty(),
-                    );
-                    Ok::<(), Error>(())
-                });
-            }
-
-            Subscription::Write(f) => {
-                futures.push(async move {
-                    f.file
-                        .writable()
-                        .await
-                        .map_err(|e| e.context("writable future"))?;
-                    f.complete(0, RwEventFlags::empty());
-                    Ok(())
-                });
-            }
-            Subscription::MonotonicClock { .. } => unreachable!(),
-        }
-    }
-    if let Some(Some(remaining_duration)) = duration {
-        match tokio::time::timeout(remaining_duration, futures).await {
-            Ok(r) => r?,
-            Err(_deadline_elapsed) => {}
-        }
-    } else {
-        futures.await?;
-    }
-
-    Ok(())
-}
diff --git a/crates/wasi-common/tokio/src/sched/windows.rs b/crates/wasi-common/tokio/src/sched/windows.rs
deleted file mode 100644
index 54cf8615b69f..000000000000
--- a/crates/wasi-common/tokio/src/sched/windows.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-use crate::block_on_dummy_executor;
-use wasi_cap_std_sync::sched::windows::poll_oneoff_;
-use wasi_common::{file::WasiFile, sched::Poll, Error};
-
-pub async fn poll_oneoff<'a>(poll: &mut Poll<'a>) -> Result<(), Error> {
-    // Tokio doesn't provide us the AsyncFd primitive on Windows, so instead
-    // we use the blocking poll_oneoff implementation from the wasi-cap-std-crate.
-    // We provide a function specific to this crate's WasiFile types for downcasting
-    // to a RawHandle.
-    block_on_dummy_executor(move || poll_oneoff_(poll, wasi_file_is_stdin))
-}
-
-pub fn wasi_file_is_stdin(f: &dyn WasiFile) -> bool {
-    f.as_any().is::<crate::stdio::Stdin>()
-}
diff --git a/crates/wasi-common/tokio/src/stdio.rs b/crates/wasi-common/tokio/src/stdio.rs
deleted file mode 100644
index dd23c0555aab..000000000000
--- a/crates/wasi-common/tokio/src/stdio.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub use crate::file::{stderr, stdin, stdout, Stderr, Stdin, Stdout};
diff --git a/crates/wasi-common/tokio/tests/poll_oneoff.rs b/crates/wasi-common/tokio/tests/poll_oneoff.rs
deleted file mode 100644
index 852abce2aad2..000000000000
--- a/crates/wasi-common/tokio/tests/poll_oneoff.rs
+++ /dev/null
@@ -1,176 +0,0 @@
-use anyhow::{Context, Error};
-use cap_std::time::Duration;
-use std::collections::HashMap;
-use wasi_common::{
-    dir::OpenResult,
-    file::{FdFlags, OFlags},
-    sched::{Poll, RwEventFlags, SubscriptionResult, Userdata},
-    WasiDir, WasiFile,
-};
-use wasi_tokio::{clocks_ctx, sched::poll_oneoff, Dir};
-
-const TIMEOUT: Duration = Duration::from_millis(200); // Required for slow execution in CI
-
-#[tokio::test(flavor = "multi_thread")]
-async fn empty_file_readable() -> Result<(), Error> {
-    let clocks = clocks_ctx();
-
-    let workspace =
-        cap_tempfile::tempdir(cap_tempfile::ambient_authority()).expect("create tempdir");
-    workspace.create_dir("d").context("create dir")?;
-    let d = workspace.open_dir("d").context("open dir")?;
-    let d = Dir::from_cap_std(d);
-
-    let f = d
-        .open_file(false, "f", OFlags::CREATE, false, true, FdFlags::empty())
-        .await
-        .context("create writable file f")?;
-    let to_write: Vec<u8> = vec![0];
-    if let OpenResult::File(ref f) = f {
-        f.write_vectored(&vec![std::io::IoSlice::new(&to_write)])
-            .await
-            .context("write to f")?;
-    } else {
-        unreachable!();
-    }
-    drop(f);
-
-    let f = d
-        .open_file(false, "f", OFlags::empty(), true, false, FdFlags::empty())
-        .await
-        .context("open f as readable")?;
-
-    let mut poll = Poll::new();
-    if let OpenResult::File(ref f) = f {
-        poll.subscribe_read(f.as_ref(), Userdata::from(123));
-    } else {
-        unreachable!();
-    }
-    // Timeout bounds time in poll_oneoff
-    let monotonic = &*clocks.monotonic()?.abs_clock;
-    poll.subscribe_monotonic_clock(
-        monotonic,
-        monotonic
-            .now(monotonic.resolution())
-            .checked_add(TIMEOUT)
-            .unwrap(),
-        monotonic.resolution(),
-        Userdata::from(0),
-    );
-    poll_oneoff(&mut poll).await?;
-
-    let events = poll.results();
-
-    match events.get(0).expect("at least one event") {
-        (SubscriptionResult::Read(Ok((1, flags))), ud) => {
-            assert_eq!(*flags, RwEventFlags::empty());
-            assert_eq!(*ud, Userdata::from(123));
-        }
-        _ => panic!("expected (Read(Ok(1, empty), 123), got: {:?}", events[0]),
-    }
-
-    Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread")]
-async fn empty_file_writable() -> Result<(), Error> {
-    let clocks = clocks_ctx();
-
-    let workspace =
-        cap_tempfile::tempdir(cap_tempfile::ambient_authority()).expect("create tempdir");
-    workspace.create_dir("d").context("create dir")?;
-    let d = workspace.open_dir("d").context("open dir")?;
-    let d = Dir::from_cap_std(d);
-
-    let writable_f = d
-        .open_file(false, "f", OFlags::CREATE, true, true, FdFlags::empty())
-        .await
-        .context("create writable file")?;
-
-    let mut poll = Poll::new();
-    if let OpenResult::File(ref writable_f) = writable_f {
-        poll.subscribe_write(writable_f.as_ref(), Userdata::from(123));
-    } else {
-        unreachable!();
-    }
-    // Timeout bounds time in poll_oneoff
-    let monotonic = &*clocks.monotonic()?.abs_clock;
-    poll.subscribe_monotonic_clock(
-        monotonic,
-        monotonic
-            .now(monotonic.resolution())
-            .checked_add(TIMEOUT)
-            .unwrap(),
-        monotonic.resolution(),
-        Userdata::from(0),
-    );
-    poll_oneoff(&mut poll).await?;
-
-    let events = poll.results();
-
-    match events.get(0).expect("at least one event") {
-        (SubscriptionResult::Write(Ok((0, flags))), ud) => {
-            assert_eq!(*flags, RwEventFlags::empty());
-            assert_eq!(*ud, Userdata::from(123));
-        }
-        _ => panic!(""),
-    }
-
-    Ok(())
-}
-
-#[tokio::test(flavor = "multi_thread")]
-async fn stdio_readable() -> Result<(), Error> {
-    let clocks = clocks_ctx();
-
-    let monotonic = &*clocks.monotonic()?.abs_clock;
-    let deadline = monotonic
-        .now(monotonic.resolution())
-        .checked_add(TIMEOUT)
-        .unwrap();
-
-    let mut waiting_on: HashMap<u64, Box<dyn WasiFile>> = vec![
-        (
-            1,
-            Box::new(wasi_tokio::stdio::stdout()) as Box<dyn WasiFile>,
-        ),
-        (2, Box::new(wasi_tokio::stdio::stderr())),
-    ]
-    .into_iter()
-    .collect();
-
-    while !waiting_on.is_empty() {
-        let mut poll = Poll::new();
-
-        for (ix, file) in waiting_on.iter_mut() {
-            poll.subscribe_write(&mut **file, Userdata::from(*ix));
-        }
-        // Timeout bounds time in poll_oneoff
-        let monotonic = &*clocks.monotonic()?.abs_clock;
-        poll.subscribe_monotonic_clock(
-            monotonic,
-            deadline,
-            monotonic.resolution(),
-            Userdata::from(999),
-        );
-        poll_oneoff(&mut poll).await?;
-        let events = poll.results();
-
-        for e in events {
-            match e {
-                (SubscriptionResult::Write(Ok(_)), ud) => {
-                    let _ = waiting_on.remove(&u64::from(ud));
-                }
-                (SubscriptionResult::Write(Err(_)), ud) => {
-                    panic!("error on ix {}", u64::from(ud))
-                }
-                (SubscriptionResult::Read { .. }, _) => unreachable!(),
-                (SubscriptionResult::MonotonicClock { .. }, _) => {
-                    panic!("timed out before stdin and stdout ready for reading")
-                }
-            }
-        }
-    }
-
-    Ok(())
-}
diff --git a/crates/wasi-common/witx/preview0/typenames.witx b/crates/wasi-common/witx/preview0/typenames.witx
new file mode 100644
index 000000000000..c3213743324a
--- /dev/null
+++ b/crates/wasi-common/witx/preview0/typenames.witx
@@ -0,0 +1,746 @@
+;; Type names used by low-level WASI interfaces.
+;;
+;; Some content here is derived from [CloudABI](https://github.com/NuxiNL/cloudabi).
+;;
+;; This is a `witx` file. See [here](https://github.com/WebAssembly/WASI/tree/main/docs/witx.md)
+;; for an explanation of what that means.
+
+(typename $size u32)
+
+;;; Non-negative file size or length of a region within a file.
+(typename $filesize u64)
+
+;;; Timestamp in nanoseconds.
+(typename $timestamp u64)
+
+;;; Identifiers for clocks.
+(typename $clockid
+  (enum (@witx tag u32)
+    ;;; The clock measuring real time. Time value zero corresponds with
+    ;;; 1970-01-01T00:00:00Z.
+    $realtime
+    ;;; The store-wide monotonic clock, which is defined as a clock measuring
+    ;;; real time, whose value cannot be adjusted and which cannot have negative
+    ;;; clock jumps. The epoch of this clock is undefined. The absolute time
+    ;;; value of this clock therefore has no meaning.
+    $monotonic
+    ;;; The CPU-time clock associated with the current process.
+    $process_cputime_id
+    ;;; The CPU-time clock associated with the current thread.
+    $thread_cputime_id
+  )
+)
+
+;;; Error codes returned by functions.
+;;; Not all of these error codes are returned by the functions provided by this
+;;; API; some are used in higher-level library layers, and others are provided
+;;; merely for alignment with POSIX.
+(typename $errno
+  (enum (@witx tag u16)
+    ;;; No error occurred. System call completed successfully.
+    $success
+    ;;; Argument list too long.
+    $2big
+    ;;; Permission denied.
+    $acces
+    ;;; Address in use.
+    $addrinuse
+    ;;; Address not available.
+    $addrnotavail
+    ;;; Address family not supported.
+    $afnosupport
+    ;;; Resource unavailable, or operation would block.
+    $again
+    ;;; Connection already in progress.
+    $already
+    ;;; Bad file descriptor.
+    $badf
+    ;;; Bad message.
+    $badmsg
+    ;;; Device or resource busy.
+    $busy
+    ;;; Operation canceled.
+    $canceled
+    ;;; No child processes.
+    $child
+    ;;; Connection aborted.
+    $connaborted
+    ;;; Connection refused.
+    $connrefused
+    ;;; Connection reset.
+    $connreset
+    ;;; Resource deadlock would occur.
+    $deadlk
+    ;;; Destination address required.
+    $destaddrreq
+    ;;; Mathematics argument out of domain of function.
+    $dom
+    ;;; Reserved.
+    $dquot
+    ;;; File exists.
+    $exist
+    ;;; Bad address.
+    $fault
+    ;;; File too large.
+    $fbig
+    ;;; Host is unreachable.
+    $hostunreach
+    ;;; Identifier removed.
+    $idrm
+    ;;; Illegal byte sequence.
+    $ilseq
+    ;;; Operation in progress.
+    $inprogress
+    ;;; Interrupted function.
+    $intr
+    ;;; Invalid argument.
+    $inval
+    ;;; I/O error.
+    $io
+    ;;; Socket is connected.
+    $isconn
+    ;;; Is a directory.
+    $isdir
+    ;;; Too many levels of symbolic links.
+    $loop
+    ;;; File descriptor value too large.
+    $mfile
+    ;;; Too many links.
+    $mlink
+    ;;; Message too large.
+    $msgsize
+    ;;; Reserved.
+    $multihop
+    ;;; Filename too long.
+    $nametoolong
+    ;;; Network is down.
+    $netdown
+    ;;; Connection aborted by network.
+    $netreset
+    ;;; Network unreachable.
+    $netunreach
+    ;;; Too many files open in system.
+    $nfile
+    ;;; No buffer space available.
+    $nobufs
+    ;;; No such device.
+    $nodev
+    ;;; No such file or directory.
+    $noent
+    ;;; Executable file format error.
+    $noexec
+    ;;; No locks available.
+    $nolck
+    ;;; Reserved.
+    $nolink
+    ;;; Not enough space.
+    $nomem
+    ;;; No message of the desired type.
+    $nomsg
+    ;;; Protocol not available.
+    $noprotoopt
+    ;;; No space left on device.
+    $nospc
+    ;;; Function not supported.
+    $nosys
+    ;;; The socket is not connected.
+    $notconn
+    ;;; Not a directory or a symbolic link to a directory.
+    $notdir
+    ;;; Directory not empty.
+    $notempty
+    ;;; State not recoverable.
+    $notrecoverable
+    ;;; Not a socket.
+    $notsock
+    ;;; Not supported, or operation not supported on socket.
+    $notsup
+    ;;; Inappropriate I/O control operation.
+    $notty
+    ;;; No such device or address.
+    $nxio
+    ;;; Value too large to be stored in data type.
+    $overflow
+    ;;; Previous owner died.
+    $ownerdead
+    ;;; Operation not permitted.
+    $perm
+    ;;; Broken pipe.
+    $pipe
+    ;;; Protocol error.
+    $proto
+    ;;; Protocol not supported.
+    $protonosupport
+    ;;; Protocol wrong type for socket.
+    $prototype
+    ;;; Result too large.
+    $range
+    ;;; Read-only file system.
+    $rofs
+    ;;; Invalid seek.
+    $spipe
+    ;;; No such process.
+    $srch
+    ;;; Reserved.
+    $stale
+    ;;; Connection timed out.
+    $timedout
+    ;;; Text file busy.
+    $txtbsy
+    ;;; Cross-device link.
+    $xdev
+    ;;; Extension: Capabilities insufficient.
+    $notcapable
+  )
+)
+
+;;; File descriptor rights, determining which actions may be performed.
+(typename $rights
+  (flags (@witx repr u64)
+    ;;; The right to invoke `fd_datasync`.
+    ;;
+    ;;; If `rights::path_open` is set, includes the right to invoke
+    ;;; `path_open` with `fdflags::dsync`.
+    $fd_datasync
+    ;;; The right to invoke `fd_read` and `sock_recv`.
+    ;;
+    ;;; If `rights::fd_seek` is set, includes the right to invoke `fd_pread`.
+    $fd_read
+    ;;; The right to invoke `fd_seek`. This flag implies `rights::fd_tell`.
+    $fd_seek
+    ;;; The right to invoke `fd_fdstat_set_flags`.
+    $fd_fdstat_set_flags
+    ;;; The right to invoke `fd_sync`.
+    ;;
+    ;;; If `rights::path_open` is set, includes the right to invoke
+    ;;; `path_open` with `fdflags::rsync` and `fdflags::dsync`.
+    $fd_sync
+    ;;; The right to invoke `fd_seek` in such a way that the file offset
+    ;;; remains unaltered (i.e., `whence::cur` with offset zero), or to
+    ;;; invoke `fd_tell`.
+    $fd_tell
+    ;;; The right to invoke `fd_write` and `sock_send`.
+    ;;; If `rights::fd_seek` is set, includes the right to invoke `fd_pwrite`.
+    $fd_write
+    ;;; The right to invoke `fd_advise`.
+    $fd_advise
+    ;;; The right to invoke `fd_allocate`.
+    $fd_allocate
+    ;;; The right to invoke `path_create_directory`.
+    $path_create_directory
+    ;;; If `rights::path_open` is set, the right to invoke `path_open` with `oflags::creat`.
+    $path_create_file
+    ;;; The right to invoke `path_link` with the file descriptor as the
+    ;;; source directory.
+    $path_link_source
+    ;;; The right to invoke `path_link` with the file descriptor as the
+    ;;; target directory.
+    $path_link_target
+    ;;; The right to invoke `path_open`.
+    $path_open
+    ;;; The right to invoke `fd_readdir`.
+    $fd_readdir
+    ;;; The right to invoke `path_readlink`.
+    $path_readlink
+    ;;; The right to invoke `path_rename` with the file descriptor as the source directory.
+    $path_rename_source
+    ;;; The right to invoke `path_rename` with the file descriptor as the target directory.
+    $path_rename_target
+    ;;; The right to invoke `path_filestat_get`.
+    $path_filestat_get
+    ;;; The right to change a file's size (there is no `path_filestat_set_size`).
+    ;;; If `rights::path_open` is set, includes the right to invoke `path_open` with `oflags::trunc`.
+    $path_filestat_set_size
+    ;;; The right to invoke `path_filestat_set_times`.
+    $path_filestat_set_times
+    ;;; The right to invoke `fd_filestat_get`.
+    $fd_filestat_get
+    ;;; The right to invoke `fd_filestat_set_size`.
+    $fd_filestat_set_size
+    ;;; The right to invoke `fd_filestat_set_times`.
+    $fd_filestat_set_times
+    ;;; The right to invoke `path_symlink`.
+    $path_symlink
+    ;;; The right to invoke `path_remove_directory`.
+    $path_remove_directory
+    ;;; The right to invoke `path_unlink_file`.
+    $path_unlink_file
+    ;;; If `rights::fd_read` is set, includes the right to invoke `poll_oneoff` to subscribe to `eventtype::fd_read`.
+    ;;; If `rights::fd_write` is set, includes the right to invoke `poll_oneoff` to subscribe to `eventtype::fd_write`.
+    $poll_fd_readwrite
+    ;;; The right to invoke `sock_shutdown`.
+    $sock_shutdown
+  )
+)
+
+;;; A file descriptor handle.
+(typename $fd (handle))
+
+;;; A region of memory for scatter/gather reads.
+(typename $iovec
+  (record
+    ;;; The address of the buffer to be filled.
+    (field $buf (@witx pointer u8))
+    ;;; The length of the buffer to be filled.
+    (field $buf_len $size)
+  )
+)
+
+;;; A region of memory for scatter/gather writes.
+(typename $ciovec
+  (record
+    ;;; The address of the buffer to be written.
+    (field $buf (@witx const_pointer u8))
+    ;;; The length of the buffer to be written.
+    (field $buf_len $size)
+  )
+)
+
+(typename $iovec_array (list $iovec))
+(typename $ciovec_array (list $ciovec))
+
+;;; Relative offset within a file.
+(typename $filedelta s64)
+
+;;; The position relative to which to set the offset of the file descriptor.
+(typename $whence
+  (enum (@witx tag u8)
+    ;;; Seek relative to current position.
+    $cur
+    ;;; Seek relative to end-of-file.
+    $end
+    ;;; Seek relative to start-of-file.
+    $set
+  )
+)
+
+;;; A reference to the offset of a directory entry.
+(typename $dircookie u64)
+
+;;; The type for the `dirent::d_namlen` field of `dirent` struct.
+(typename $dirnamlen u32)
+
+;;; File serial number that is unique within its file system.
+(typename $inode u64)
+
+;;; The type of a file descriptor or file.
+(typename $filetype
+  (enum (@witx tag u8)
+    ;;; The type of the file descriptor or file is unknown or is different from any of the other types specified.
+    $unknown
+    ;;; The file descriptor or file refers to a block device inode.
+    $block_device
+    ;;; The file descriptor or file refers to a character device inode.
+    $character_device
+    ;;; The file descriptor or file refers to a directory inode.
+    $directory
+    ;;; The file descriptor or file refers to a regular file inode.
+    $regular_file
+    ;;; The file descriptor or file refers to a datagram socket.
+    $socket_dgram
+    ;;; The file descriptor or file refers to a byte-stream socket.
+    $socket_stream
+    ;;; The file refers to a symbolic link inode.
+    $symbolic_link
+  )
+)
+
+;;; A directory entry.
+(typename $dirent
+  (record
+    ;;; The offset of the next directory entry stored in this directory.
+    (field $d_next $dircookie)
+    ;;; The serial number of the file referred to by this directory entry.
+    (field $d_ino $inode)
+    ;;; The length of the name of the directory entry.
+    (field $d_namlen $dirnamlen)
+    ;;; The type of the file referred to by this directory entry.
+    (field $d_type $filetype)
+  )
+)
+
+;;; File or memory access pattern advisory information.
+(typename $advice
+  (enum (@witx tag u8)
+    ;;; The application has no advice to give on its behavior with respect to the specified data.
+    $normal
+    ;;; The application expects to access the specified data sequentially from lower offsets to higher offsets.
+    $sequential
+    ;;; The application expects to access the specified data in a random order.
+    $random
+    ;;; The application expects to access the specified data in the near future.
+    $willneed
+    ;;; The application expects that it will not access the specified data in the near future.
+    $dontneed
+    ;;; The application expects to access the specified data once and then not reuse it thereafter.
+    $noreuse
+  )
+)
+
+;;; File descriptor flags.
+(typename $fdflags
+  (flags (@witx repr u16)
+    ;;; Append mode: Data written to the file is always appended to the file's end.
+    $append
+    ;;; Write according to synchronized I/O data integrity completion. Only the data stored in the file is synchronized.
+    $dsync
+    ;;; Non-blocking mode.
+    $nonblock
+    ;;; Synchronized read I/O operations.
+    $rsync
+    ;;; Write according to synchronized I/O file integrity completion. In
+    ;;; addition to synchronizing the data stored in the file, the implementation
+    ;;; may also synchronously update the file's metadata.
+    $sync
+  )
+)
+
+;;; File descriptor attributes.
+(typename $fdstat
+  (record
+    ;;; File type.
+    (field $fs_filetype $filetype)
+    ;;; File descriptor flags.
+    (field $fs_flags $fdflags)
+    ;;; Rights that apply to this file descriptor.
+    (field $fs_rights_base $rights)
+    ;;; Maximum set of rights that may be installed on new file descriptors that
+    ;;; are created through this file descriptor, e.g., through `path_open`.
+    (field $fs_rights_inheriting $rights)
+  )
+)
+
+;;; Identifier for a device containing a file system. Can be used in combination
+;;; with `inode` to uniquely identify a file or directory in the filesystem.
+(typename $device u64)
+
+;;; Which file time attributes to adjust.
+(typename $fstflags
+  (flags (@witx repr u16)
+    ;;; Adjust the last data access timestamp to the value stored in `filestat::atim`.
+    $atim
+    ;;; Adjust the last data access timestamp to the time of clock `clockid::realtime`.
+    $atim_now
+    ;;; Adjust the last data modification timestamp to the value stored in `filestat::mtim`.
+    $mtim
+    ;;; Adjust the last data modification timestamp to the time of clock `clockid::realtime`.
+    $mtim_now
+  )
+)
+
+;;; Flags determining the method of how paths are resolved.
+(typename $lookupflags
+  (flags (@witx repr u32)
+    ;;; As long as the resolved path corresponds to a symbolic link, it is expanded.
+    $symlink_follow
+  )
+)
+
+;;; Open flags used by `path_open`.
+(typename $oflags
+  (flags (@witx repr u16)
+    ;;; Create file if it does not exist.
+    $creat
+    ;;; Fail if not a directory.
+    $directory
+    ;;; Fail if file already exists.
+    $excl
+    ;;; Truncate file to size 0.
+    $trunc
+  )
+)
+
+;;; Number of hard links to an inode.
+(typename $linkcount u32)
+
+;;; File attributes.
+(typename $filestat
+  (record
+    ;;; Device ID of device containing the file.
+    (field $dev $device)
+    ;;; File serial number.
+    (field $ino $inode)
+    ;;; File type.
+    (field $filetype $filetype)
+    ;;; Number of hard links to the file.
+    (field $nlink $linkcount)
+    ;;; For regular files, the file size in bytes. For symbolic links, the length in bytes of the pathname contained in the symbolic link.
+    (field $size $filesize)
+    ;;; Last data access timestamp.
+    (field $atim $timestamp)
+    ;;; Last data modification timestamp.
+    (field $mtim $timestamp)
+    ;;; Last file status change timestamp.
+    (field $ctim $timestamp)
+  )
+)
+
+;;; User-provided value that may be attached to objects that is retained when
+;;; extracted from the implementation.
+(typename $userdata u64)
+
+;;; Type of a subscription to an event or its occurrence.
+(typename $eventtype
+  (enum (@witx tag u8)
+    ;;; The time value of clock `subscription_clock::id` has
+    ;;; reached timestamp `subscription_clock::timeout`.
+    $clock
+    ;;; File descriptor `subscription_fd_readwrite::file_descriptor` has data
+    ;;; available for reading. This event always triggers for regular files.
+    $fd_read
+    ;;; File descriptor `subscription_fd_readwrite::file_descriptor` has capacity
+    ;;; available for writing. This event always triggers for regular files.
+    $fd_write
+  )
+)
+
+;;; The state of the file descriptor subscribed to with
+;;; `eventtype::fd_read` or `eventtype::fd_write`.
+(typename $eventrwflags
+  (flags (@witx repr u16)
+    ;;; The peer of this socket has closed or disconnected.
+    $fd_readwrite_hangup
+  )
+)
+
+;;; The contents of an `event` for the `eventtype::fd_read` and
+;;; `eventtype::fd_write` variants
+(typename $event_fd_readwrite
+  (record
+    ;;; The number of bytes available for reading or writing.
+    (field $nbytes $filesize)
+    ;;; The state of the file descriptor.
+    (field $flags $eventrwflags)
+  )
+)
+
+;;; An event that occurred.
+(typename $event
+  (record
+    ;;; User-provided value that got attached to `subscription::userdata`.
+    (field $userdata $userdata)
+    ;;; If non-zero, an error that occurred while processing the subscription request.
+    (field $error $errno)
+    ;;; The type of event that occurred
+    (field $type $eventtype)
+    ;;; The contents of the event, if it is an `eventtype::fd_read` or
+    ;;; `eventtype::fd_write`. `eventtype::clock` events ignore this field.
+    (field $fd_readwrite $event_fd_readwrite)
+  )
+)
+
+;;; Flags determining how to interpret the timestamp provided in
+;;; `subscription_clock::timeout`.
+(typename $subclockflags
+  (flags (@witx repr u16)
+    ;;; If set, treat the timestamp provided in
+    ;;; `subscription_clock::timeout` as an absolute timestamp of clock
+    ;;; `subscription_clock::id`. If clear, treat the timestamp
+    ;;; provided in `subscription_clock::timeout` relative to the
+    ;;; current time value of clock `subscription_clock::id`.
+    $subscription_clock_abstime
+  )
+)
+
+;;; The contents of a `subscription` when type is `eventtype::clock`.
+(typename $subscription_clock
+  (record
+    ;;; The user-defined unique identifier of the clock.
+    (field $identifier $userdata)
+    ;;; The clock against which to compare the timestamp.
+    (field $id $clockid)
+    ;;; The absolute or relative timestamp.
+    (field $timeout $timestamp)
+    ;;; The amount of time that the implementation may wait additionally
+    ;;; to coalesce with other events.
+    (field $precision $timestamp)
+    ;;; Flags specifying whether the timeout is absolute or relative
+    (field $flags $subclockflags)
+  )
+)
+
+;;; The contents of a `subscription` when the variant is
+;;; `eventtype::fd_read` or `eventtype::fd_write`.
+(typename $subscription_fd_readwrite
+  (record
+    ;;; The file descriptor on which to wait for it to become ready for reading or writing.
+    (field $file_descriptor $fd)
+  )
+)
+
+;;; The contents of a `subscription`.
+(typename $subscription_u
+  (union (@witx tag $eventtype)
+    $subscription_clock
+    $subscription_fd_readwrite
+    $subscription_fd_readwrite
+  )
+)
+
+;;; Subscription to an event.
+(typename $subscription
+  (record
+    ;;; User-provided value that is attached to the subscription in the
+    ;;; implementation and returned through `event::userdata`.
+    (field $userdata $userdata)
+    ;;; The type of the event to which to subscribe.
+    (field $u $subscription_u)
+  )
+)
+
+;;; Exit code generated by a process when exiting.
+(typename $exitcode u32)
+
+;;; Signal condition.
+(typename $signal
+  (enum (@witx tag u8)
+    ;;; No signal. Note that POSIX has special semantics for `kill(pid, 0)`,
+    ;;; so this value is reserved.
+    $none
+    ;;; Hangup.
+    ;;; Action: Terminates the process.
+    $hup
+    ;;; Terminate interrupt signal.
+    ;;; Action: Terminates the process.
+    $int
+    ;;; Terminal quit signal.
+    ;;; Action: Terminates the process.
+    $quit
+    ;;; Illegal instruction.
+    ;;; Action: Terminates the process.
+    $ill
+    ;;; Trace/breakpoint trap.
+    ;;; Action: Terminates the process.
+    $trap
+    ;;; Process abort signal.
+    ;;; Action: Terminates the process.
+    $abrt
+    ;;; Access to an undefined portion of a memory object.
+    ;;; Action: Terminates the process.
+    $bus
+    ;;; Erroneous arithmetic operation.
+    ;;; Action: Terminates the process.
+    $fpe
+    ;;; Kill.
+    ;;; Action: Terminates the process.
+    $kill
+    ;;; User-defined signal 1.
+    ;;; Action: Terminates the process.
+    $usr1
+    ;;; Invalid memory reference.
+    ;;; Action: Terminates the process.
+    $segv
+    ;;; User-defined signal 2.
+    ;;; Action: Terminates the process.
+    $usr2
+    ;;; Write on a pipe with no one to read it.
+    ;;; Action: Ignored.
+    $pipe
+    ;;; Alarm clock.
+    ;;; Action: Terminates the process.
+    $alrm
+    ;;; Termination signal.
+    ;;; Action: Terminates the process.
+    $term
+    ;;; Child process terminated, stopped, or continued.
+    ;;; Action: Ignored.
+    $chld
+    ;;; Continue executing, if stopped.
+    ;;; Action: Continues executing, if stopped.
+    $cont
+    ;;; Stop executing.
+    ;;; Action: Stops executing.
+    $stop
+    ;;; Terminal stop signal.
+    ;;; Action: Stops executing.
+    $tstp
+    ;;; Background process attempting read.
+    ;;; Action: Stops executing.
+    $ttin
+    ;;; Background process attempting write.
+    ;;; Action: Stops executing.
+    $ttou
+    ;;; High bandwidth data is available at a socket.
+    ;;; Action: Ignored.
+    $urg
+    ;;; CPU time limit exceeded.
+    ;;; Action: Terminates the process.
+    $xcpu
+    ;;; File size limit exceeded.
+    ;;; Action: Terminates the process.
+    $xfsz
+    ;;; Virtual timer expired.
+    ;;; Action: Terminates the process.
+    $vtalrm
+    ;;; Profiling timer expired.
+    ;;; Action: Terminates the process.
+    $prof
+    ;;; Window changed.
+    ;;; Action: Ignored.
+    $winch
+    ;;; I/O possible.
+    ;;; Action: Terminates the process.
+    $poll
+    ;;; Power failure.
+    ;;; Action: Terminates the process.
+    $pwr
+    ;;; Bad system call.
+    ;;; Action: Terminates the process.
+    $sys
+  )
+)
+
+;;; Flags provided to `sock_recv`.
+(typename $riflags
+  (flags (@witx repr u16)
+    ;;; Returns the message without removing it from the socket's receive queue.
+    $recv_peek
+    ;;; On byte-stream sockets, block until the full amount of data can be returned.
+    $recv_waitall
+  )
+)
+
+;;; Flags returned by `sock_recv`.
+(typename $roflags
+  (flags (@witx repr u16)
+    ;;; Returned by `sock_recv`: Message data has been truncated.
+    $recv_data_truncated
+  )
+)
+
+;;; Flags provided to `sock_send`. As there are currently no flags
+;;; defined, it must be set to zero.
+(typename $siflags u16)
+
+;;; Which channels on a socket to shut down.
+(typename $sdflags
+  (flags (@witx repr u8)
+    ;;; Disables further receive operations.
+    $rd
+    ;;; Disables further send operations.
+    $wr
+  )
+)
+
+;;; Identifiers for preopened capabilities.
+(typename $preopentype
+  (enum (@witx tag u8)
+    ;;; A pre-opened directory.
+    $dir
+  )
+)
+
+;;; The contents of a $prestat when type is `preopentype::dir`.
+(typename $prestat_dir
+  (record
+    ;;; The length of the directory name for use with `fd_prestat_dir_name`.
+    (field $pr_name_len $size)
+  )
+)
+
+;;; Information about a pre-opened capability.
+(typename $prestat
+  (union (@witx tag $preopentype)
+    $prestat_dir
+  )
+)
diff --git a/crates/wasi-common/witx/preview0/wasi_unstable.witx b/crates/wasi-common/witx/preview0/wasi_unstable.witx
new file mode 100644
index 000000000000..dbece2641c49
--- /dev/null
+++ b/crates/wasi-common/witx/preview0/wasi_unstable.witx
@@ -0,0 +1,513 @@
+;; WASI Preview. This is an evolution of the API that WASI initially
+;; launched with.
+;;
+;; Some content here is derived from [CloudABI](https://github.com/NuxiNL/cloudabi).
+;;
+;; This is a `witx` file. See [here](https://github.com/WebAssembly/WASI/tree/master/docs/witx.md)
+;; for an explanation of what that means.
+
+(use "typenames.witx")
+
+;;; This API predated the convention of naming modules with a `wasi_unstable_`
+;;; prefix and a version number. It is preserved here for compatibility, but
+;;; we shouldn't follow this pattern in new APIs.
+(module $wasi_unstable
+  ;;; Linear memory to be accessed by WASI functions that need it.
+  (import "memory" (memory))
+
+  ;;; Read command-line argument data.
+  ;;; The size of the array should match that returned by `args_sizes_get`.
+  ;;; Each argument is expected to be `\0` terminated.
+  (@interface func (export "args_get")
+    (param $argv (@witx pointer (@witx pointer u8)))
+    (param $argv_buf (@witx pointer u8))
+    (result $error (expected (error $errno)))
+  )
+  ;;; Return command-line argument data sizes.
+  (@interface func (export "args_sizes_get")
+    ;;; Returns the number of arguments and the size of the argument string
+    ;;; data, or an error.
+    (result $error (expected (tuple $size $size) (error $errno)))
+  )
+
+  ;;; Read environment variable data.
+  ;;; The sizes of the buffers should match that returned by `environ_sizes_get`.
+  ;;; Key/value pairs are expected to be joined with `=`s, and terminated with `\0`s.
+  (@interface func (export "environ_get")
+    (param $environ (@witx pointer (@witx pointer u8)))
+    (param $environ_buf (@witx pointer u8))
+    (result $error (expected (error $errno)))
+  )
+  ;;; Return environment variable data sizes.
+  (@interface func (export "environ_sizes_get")
+    ;;; Returns the number of environment variable arguments and the size of the
+    ;;; environment variable data.
+    (result $error (expected (tuple $size $size) (error $errno)))
+  )
+
+  ;;; Return the resolution of a clock.
+  ;;; Implementations are required to provide a non-zero value for supported clocks. For unsupported clocks, return
+  ;;; `errno::inval`.
+  ;;; Note: This is similar to `clock_getres` in POSIX.
+  (@interface func (export "clock_res_get")
+    ;;; The clock for which to return the resolution.
+    (param $id $clockid)
+    ;;; The resolution of the clock, or an error if one happened.
+    (result $error (expected $timestamp (error $errno)))
+  )
+  ;;; Return the time value of a clock.
+  ;;; Note: This is similar to `clock_gettime` in POSIX.
+  (@interface func (export "clock_time_get")
+    ;;; The clock for which to return the time.
+    (param $id $clockid)
+    ;;; The maximum lag (exclusive) that the returned time value may have, compared to its actual value.
+    (param $precision $timestamp)
+    ;;; The time value of the clock.
+    (result $error (expected $timestamp (error $errno)))
+  )
+
+  ;;; Provide file advisory information on a file descriptor.
+  ;;; Note: This is similar to `posix_fadvise` in POSIX.
+  (@interface func (export "fd_advise")
+    (param $fd $fd)
+    ;;; The offset within the file to which the advisory applies.
+    (param $offset $filesize)
+    ;;; The length of the region to which the advisory applies.
+    (param $len $filesize)
+    ;;; The advice.
+    (param $advice $advice)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Force the allocation of space in a file.
+  ;;; Note: This is similar to `posix_fallocate` in POSIX.
+  (@interface func (export "fd_allocate")
+    (param $fd $fd)
+    ;;; The offset at which to start the allocation.
+    (param $offset $filesize)
+    ;;; The length of the area that is allocated.
+    (param $len $filesize)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Close a file descriptor.
+  ;;; Note: This is similar to `close` in POSIX.
+  (@interface func (export "fd_close")
+    (param $fd $fd)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Synchronize the data of a file to disk.
+  ;;; Note: This is similar to `fdatasync` in POSIX.
+  (@interface func (export "fd_datasync")
+    (param $fd $fd)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Get the attributes of a file descriptor.
+  ;;; Note: This returns similar flags to `fsync(fd, F_GETFL)` in POSIX, as well as additional fields.
+  (@interface func (export "fd_fdstat_get")
+    (param $fd $fd)
+    ;;; The buffer where the file descriptor's attributes are stored.
+    (result $error (expected $fdstat (error $errno)))
+  )
+
+  ;;; Adjust the flags associated with a file descriptor.
+  ;;; Note: This is similar to `fcntl(fd, F_SETFL, flags)` in POSIX.
+  (@interface func (export "fd_fdstat_set_flags")
+    (param $fd $fd)
+    ;;; The desired values of the file descriptor flags.
+    (param $flags $fdflags)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Adjust the rights associated with a file descriptor.
+  ;;; This can only be used to remove rights, and returns `errno::notcapable` if called in a way that would attempt to add rights
+  (@interface func (export "fd_fdstat_set_rights")
+    (param $fd $fd)
+    ;;; The desired rights of the file descriptor.
+    (param $fs_rights_base $rights)
+    (param $fs_rights_inheriting $rights)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Return the attributes of an open file.
+  (@interface func (export "fd_filestat_get")
+    (param $fd $fd)
+    ;;; The buffer where the file's attributes are stored.
+    (result $error (expected $filestat (error $errno)))
+  )
+
+  ;;; Adjust the size of an open file. If this increases the file's size, the extra bytes are filled with zeros.
+  ;;; Note: This is similar to `ftruncate` in POSIX.
+  (@interface func (export "fd_filestat_set_size")
+    (param $fd $fd)
+    ;;; The desired file size.
+    (param $size $filesize)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Adjust the timestamps of an open file or directory.
+  ;;; Note: This is similar to `futimens` in POSIX.
+  (@interface func (export "fd_filestat_set_times")
+    (param $fd $fd)
+    ;;; The desired values of the data access timestamp.
+    (param $atim $timestamp)
+    ;;; The desired values of the data modification timestamp.
+    (param $mtim $timestamp)
+    ;;; A bitmask indicating which timestamps to adjust.
+    (param $fst_flags $fstflags)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Read from a file descriptor, without using and updating the file descriptor's offset.
+  ;;; Note: This is similar to `preadv` in POSIX.
+  (@interface func (export "fd_pread")
+    (param $fd $fd)
+    ;;; List of scatter/gather vectors in which to store data.
+    (param $iovs $iovec_array)
+    ;;; The offset within the file at which to read.
+    (param $offset $filesize)
+    ;;; The number of bytes read.
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Return a description of the given preopened file descriptor.
+  (@interface func (export "fd_prestat_get")
+    (param $fd $fd)
+    ;;; The buffer where the description is stored.
+    (result $error (expected $prestat (error $errno)))
+  )
+
+  ;;; Return a description of the given preopened file descriptor.
+  (@interface func (export "fd_prestat_dir_name")
+    (param $fd $fd)
+    ;;; A buffer into which to write the preopened directory name.
+    (param $path (@witx pointer u8))
+    (param $path_len $size)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Write to a file descriptor, without using and updating the file descriptor's offset.
+  ;;; Note: This is similar to `pwritev` in POSIX.
+  (@interface func (export "fd_pwrite")
+    (param $fd $fd)
+    ;;; List of scatter/gather vectors from which to retrieve data.
+    (param $iovs $ciovec_array)
+    ;;; The offset within the file at which to write.
+    (param $offset $filesize)
+    ;;; The number of bytes written.
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Read from a file descriptor.
+  ;;; Note: This is similar to `readv` in POSIX.
+  (@interface func (export "fd_read")
+    (param $fd $fd)
+    ;;; List of scatter/gather vectors to which to store data.
+    (param $iovs $iovec_array)
+    ;;; The number of bytes read.
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Read directory entries from a directory.
+  ;;; When successful, the contents of the output buffer consist of a sequence of
+  ;;; directory entries. Each directory entry consists of a `dirent` object,
+  ;;; followed by `dirent::d_namlen` bytes holding the name of the directory
+  ;;; entry.
+  ;;
+  ;;; This function fills the output buffer as much as possible, potentially
+  ;;; truncating the last directory entry. This allows the caller to grow its
+  ;;; read buffer size in case it's too small to fit a single large directory
+  ;;; entry, or skip the oversized directory entry.
+  (@interface func (export "fd_readdir")
+    (param $fd $fd)
+    ;;; The buffer where directory entries are stored
+    (param $buf (@witx pointer u8))
+    (param $buf_len $size)
+    ;;; The location within the directory to start reading
+    (param $cookie $dircookie)
+    ;;; The number of bytes stored in the read buffer. If less than the size of the read buffer, the end of the directory has been reached.
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Atomically replace a file descriptor by renumbering another file descriptor.
+  ;;
+  ;;; Due to the strong focus on thread safety, this environment does not provide
+  ;;; a mechanism to duplicate or renumber a file descriptor to an arbitrary
+  ;;; number, like `dup2()`. This would be prone to race conditions, as an actual
+  ;;; file descriptor with the same number could be allocated by a different
+  ;;; thread at the same time.
+  ;;
+  ;;; This function provides a way to atomically renumber file descriptors, which
+  ;;; would disappear if `dup2()` were to be removed entirely.
+  (@interface func (export "fd_renumber")
+    (param $fd $fd)
+    ;;; The file descriptor to overwrite.
+    (param $to $fd)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Move the offset of a file descriptor.
+  ;;; Note: This is similar to `lseek` in POSIX.
+  (@interface func (export "fd_seek")
+    (param $fd $fd)
+    ;;; The number of bytes to move.
+    (param $offset $filedelta)
+    ;;; The base from which the offset is relative.
+    (param $whence $whence)
+    ;;; The new offset of the file descriptor, relative to the start of the file.
+    (result $error (expected $filesize (error $errno)))
+  )
+
+  ;;; Synchronize the data and metadata of a file to disk.
+  ;;; Note: This is similar to `fsync` in POSIX.
+  (@interface func (export "fd_sync")
+    (param $fd $fd)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Return the current offset of a file descriptor.
+  ;;; Note: This is similar to `lseek(fd, 0, SEEK_CUR)` in POSIX.
+  (@interface func (export "fd_tell")
+    (param $fd $fd)
+    ;;; The current offset of the file descriptor, relative to the start of the file.
+    (result $error (expected $filesize (error $errno)))
+  )
+
+  ;;; Write to a file descriptor.
+  ;;; Note: This is similar to `writev` in POSIX.
+  (@interface func (export "fd_write")
+    (param $fd $fd)
+    ;;; List of scatter/gather vectors from which to retrieve data.
+    (param $iovs $ciovec_array)
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Create a directory.
+  ;;; Note: This is similar to `mkdirat` in POSIX.
+  (@interface func (export "path_create_directory")
+    (param $fd $fd)
+    ;;; The path at which to create the directory.
+    (param $path string)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Return the attributes of a file or directory.
+  ;;; Note: This is similar to `stat` in POSIX.
+  (@interface func (export "path_filestat_get")
+    (param $fd $fd)
+    ;;; Flags determining the method of how the path is resolved.
+    (param $flags $lookupflags)
+    ;;; The path of the file or directory to inspect.
+    (param $path string)
+    ;;; The buffer where the file's attributes are stored.
+    (result $error (expected $filestat (error $errno)))
+  )
+
+  ;;; Adjust the timestamps of a file or directory.
+  ;;; Note: This is similar to `utimensat` in POSIX.
+  (@interface func (export "path_filestat_set_times")
+    (param $fd $fd)
+    ;;; Flags determining the method of how the path is resolved.
+    (param $flags $lookupflags)
+    ;;; The path of the file or directory to operate on.
+    (param $path string)
+    ;;; The desired values of the data access timestamp.
+    (param $atim $timestamp)
+    ;;; The desired values of the data modification timestamp.
+    (param $mtim $timestamp)
+    ;;; A bitmask indicating which timestamps to adjust.
+    (param $fst_flags $fstflags)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Create a hard link.
+  ;;; Note: This is similar to `linkat` in POSIX.
+  (@interface func (export "path_link")
+    (param $old_fd $fd)
+    ;;; Flags determining the method of how the path is resolved.
+    (param $old_flags $lookupflags)
+    ;;; The source path from which to link.
+    (param $old_path string)
+    ;;; The working directory at which the resolution of the new path starts.
+    (param $new_fd $fd)
+    ;;; The destination path at which to create the hard link.
+    (param $new_path string)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Open a file or directory.
+  ;;
+  ;;; The returned file descriptor is not guaranteed to be the lowest-numbered
+  ;;; file descriptor not currently open; it is randomized to prevent
+  ;;; applications from depending on making assumptions about indexes, since this
+  ;;; is error-prone in multi-threaded contexts. The returned file descriptor is
+  ;;; guaranteed to be less than 2**31.
+  ;;
+  ;;; Note: This is similar to `openat` in POSIX.
+  (@interface func (export "path_open")
+    (param $fd $fd)
+    ;;; Flags determining the method of how the path is resolved.
+    (param $dirflags $lookupflags)
+    ;;; The relative path of the file or directory to open, relative to the
+    ;;; `path_open::fd` directory.
+    (param $path string)
+    ;;; The method by which to open the file.
+    (param $oflags $oflags)
+    ;;; The initial rights of the newly created file descriptor. The
+    ;;; implementation is allowed to return a file descriptor with fewer rights
+    ;;; than specified, if and only if those rights do not apply to the type of
+    ;;; file being opened.
+    ;;
+    ;;; The *base* rights are rights that will apply to operations using the file
+    ;;; descriptor itself, while the *inheriting* rights are rights that apply to
+    ;;; file descriptors derived from it.
+    (param $fs_rights_base $rights)
+    (param $fs_rights_inheriting $rights)
+    (param $fdflags $fdflags)
+    ;;; The file descriptor of the file that has been opened.
+    (result $error (expected $fd (error $errno)))
+  )
+
+  ;;; Read the contents of a symbolic link.
+  ;;; Note: This is similar to `readlinkat` in POSIX.
+  (@interface func (export "path_readlink")
+    (param $fd $fd)
+    ;;; The path of the symbolic link from which to read.
+    (param $path string)
+    ;;; The buffer to which to write the contents of the symbolic link.
+    (param $buf (@witx pointer u8))
+    (param $buf_len $size)
+    ;;; The number of bytes placed in the buffer.
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Remove a directory.
+  ;;; Return `errno::notempty` if the directory is not empty.
+  ;;; Note: This is similar to `unlinkat(fd, path, AT_REMOVEDIR)` in POSIX.
+  (@interface func (export "path_remove_directory")
+    (param $fd $fd)
+    ;;; The path to a directory to remove.
+    (param $path string)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Rename a file or directory.
+  ;;; Note: This is similar to `renameat` in POSIX.
+  (@interface func (export "path_rename")
+    (param $fd $fd)
+    ;;; The source path of the file or directory to rename.
+    (param $old_path string)
+    ;;; The working directory at which the resolution of the new path starts.
+    (param $new_fd $fd)
+    ;;; The destination path to which to rename the file or directory.
+    (param $new_path string)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Create a symbolic link.
+  ;;; Note: This is similar to `symlinkat` in POSIX.
+  (@interface func (export "path_symlink")
+    ;;; The contents of the symbolic link.
+    (param $old_path string)
+    (param $fd $fd)
+    ;;; The destination path at which to create the symbolic link.
+    (param $new_path string)
+    (result $error (expected (error $errno)))
+  )
+
+
+  ;;; Unlink a file.
+  ;;; Return `errno::isdir` if the path refers to a directory.
+  ;;; Note: This is similar to `unlinkat(fd, path, 0)` in POSIX.
+  (@interface func (export "path_unlink_file")
+    (param $fd $fd)
+    ;;; The path to a file to unlink.
+    (param $path string)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Concurrently poll for the occurrence of a set of events.
+  (@interface func (export "poll_oneoff")
+    ;;; The events to which to subscribe.
+    (param $in (@witx const_pointer $subscription))
+    ;;; The events that have occurred.
+    (param $out (@witx pointer $event))
+    ;;; Both the number of subscriptions and events.
+    (param $nsubscriptions $size)
+    ;;; The number of events stored.
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Terminate the process normally. An exit code of 0 indicates successful
+  ;;; termination of the program. The meanings of other values is dependent on
+  ;;; the environment.
+  (@interface func (export "proc_exit")
+    ;;; The exit code returned by the process.
+    (param $rval $exitcode)
+    (@witx noreturn)
+  )
+
+  ;;; Send a signal to the process of the calling thread.
+  ;;; Note: This is similar to `raise` in POSIX.
+  (@interface func (export "proc_raise")
+    ;;; The signal condition to trigger.
+    (param $sig $signal)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Temporarily yield execution of the calling thread.
+  ;;; Note: This is similar to `sched_yield` in POSIX.
+  (@interface func (export "sched_yield")
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Write high-quality random data into a buffer.
+  ;;; This function blocks when the implementation is unable to immediately
+  ;;; provide sufficient high-quality random data.
+  ;;; This function may execute slowly, so when large mounts of random data are
+  ;;; required, it's advisable to use this function to seed a pseudo-random
+  ;;; number generator, rather than to provide the random data directly.
+  (@interface func (export "random_get")
+    ;;; The buffer to fill with random data.
+    (param $buf (@witx pointer u8))
+    (param $buf_len $size)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Receive a message from a socket.
+  ;;; Note: This is similar to `recv` in POSIX, though it also supports reading
+  ;;; the data into multiple buffers in the manner of `readv`.
+  (@interface func (export "sock_recv")
+    (param $fd $fd)
+    ;;; List of scatter/gather vectors to which to store data.
+    (param $ri_data $iovec_array)
+    ;;; Message flags.
+    (param $ri_flags $riflags)
+    ;;; Number of bytes stored in ri_data and message flags.
+    (result $error (expected (tuple $size $roflags) (error $errno)))
+  )
+
+  ;;; Send a message on a socket.
+  ;;; Note: This is similar to `send` in POSIX, though it also supports writing
+  ;;; the data from multiple buffers in the manner of `writev`.
+  (@interface func (export "sock_send")
+    (param $fd $fd)
+    ;;; List of scatter/gather vectors to which to retrieve data
+    (param $si_data $ciovec_array)
+    ;;; Message flags.
+    (param $si_flags $siflags)
+    ;;; Number of bytes transmitted.
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Shut down socket send and receive channels.
+  ;;; Note: This is similar to `shutdown` in POSIX.
+  (@interface func (export "sock_shutdown")
+    (param $fd $fd)
+    ;;; Which channels on the socket to shut down.
+    (param $how $sdflags)
+    (result $error (expected (error $errno)))
+  )
+)
diff --git a/crates/wasi-common/witx/preview1/typenames.witx b/crates/wasi-common/witx/preview1/typenames.witx
new file mode 100644
index 000000000000..e87239127c07
--- /dev/null
+++ b/crates/wasi-common/witx/preview1/typenames.witx
@@ -0,0 +1,750 @@
+;; Type names used by low-level WASI interfaces.
+;;
+;; Some content here is derived from [CloudABI](https://github.com/NuxiNL/cloudabi).
+;;
+;; This is a `witx` file. See [here](https://github.com/WebAssembly/WASI/tree/master/docs/witx.md)
+;; for an explanation of what that means.
+
+(typename $size u32)
+
+;;; Non-negative file size or length of a region within a file.
+(typename $filesize u64)
+
+;;; Timestamp in nanoseconds.
+(typename $timestamp u64)
+
+;;; Identifiers for clocks.
+(typename $clockid
+  (enum (@witx tag u32)
+    ;;; The clock measuring real time. Time value zero corresponds with
+    ;;; 1970-01-01T00:00:00Z.
+    $realtime
+    ;;; The store-wide monotonic clock, which is defined as a clock measuring
+    ;;; real time, whose value cannot be adjusted and which cannot have negative
+    ;;; clock jumps. The epoch of this clock is undefined. The absolute time
+    ;;; value of this clock therefore has no meaning.
+    $monotonic
+    ;;; The CPU-time clock associated with the current process.
+    $process_cputime_id
+    ;;; The CPU-time clock associated with the current thread.
+    $thread_cputime_id
+  )
+)
+
+;;; Error codes returned by functions.
+;;; Not all of these error codes are returned by the functions provided by this
+;;; API; some are used in higher-level library layers, and others are provided
+;;; merely for alignment with POSIX.
+(typename $errno
+  (enum (@witx tag u16)
+    ;;; No error occurred. System call completed successfully.
+    $success
+    ;;; Argument list too long.
+    $2big
+    ;;; Permission denied.
+    $acces
+    ;;; Address in use.
+    $addrinuse
+    ;;; Address not available.
+    $addrnotavail
+    ;;; Address family not supported.
+    $afnosupport
+    ;;; Resource unavailable, or operation would block.
+    $again
+    ;;; Connection already in progress.
+    $already
+    ;;; Bad file descriptor.
+    $badf
+    ;;; Bad message.
+    $badmsg
+    ;;; Device or resource busy.
+    $busy
+    ;;; Operation canceled.
+    $canceled
+    ;;; No child processes.
+    $child
+    ;;; Connection aborted.
+    $connaborted
+    ;;; Connection refused.
+    $connrefused
+    ;;; Connection reset.
+    $connreset
+    ;;; Resource deadlock would occur.
+    $deadlk
+    ;;; Destination address required.
+    $destaddrreq
+    ;;; Mathematics argument out of domain of function.
+    $dom
+    ;;; Reserved.
+    $dquot
+    ;;; File exists.
+    $exist
+    ;;; Bad address.
+    $fault
+    ;;; File too large.
+    $fbig
+    ;;; Host is unreachable.
+    $hostunreach
+    ;;; Identifier removed.
+    $idrm
+    ;;; Illegal byte sequence.
+    $ilseq
+    ;;; Operation in progress.
+    $inprogress
+    ;;; Interrupted function.
+    $intr
+    ;;; Invalid argument.
+    $inval
+    ;;; I/O error.
+    $io
+    ;;; Socket is connected.
+    $isconn
+    ;;; Is a directory.
+    $isdir
+    ;;; Too many levels of symbolic links.
+    $loop
+    ;;; File descriptor value too large.
+    $mfile
+    ;;; Too many links.
+    $mlink
+    ;;; Message too large.
+    $msgsize
+    ;;; Reserved.
+    $multihop
+    ;;; Filename too long.
+    $nametoolong
+    ;;; Network is down.
+    $netdown
+    ;;; Connection aborted by network.
+    $netreset
+    ;;; Network unreachable.
+    $netunreach
+    ;;; Too many files open in system.
+    $nfile
+    ;;; No buffer space available.
+    $nobufs
+    ;;; No such device.
+    $nodev
+    ;;; No such file or directory.
+    $noent
+    ;;; Executable file format error.
+    $noexec
+    ;;; No locks available.
+    $nolck
+    ;;; Reserved.
+    $nolink
+    ;;; Not enough space.
+    $nomem
+    ;;; No message of the desired type.
+    $nomsg
+    ;;; Protocol not available.
+    $noprotoopt
+    ;;; No space left on device.
+    $nospc
+    ;;; Function not supported.
+    $nosys
+    ;;; The socket is not connected.
+    $notconn
+    ;;; Not a directory or a symbolic link to a directory.
+    $notdir
+    ;;; Directory not empty.
+    $notempty
+    ;;; State not recoverable.
+    $notrecoverable
+    ;;; Not a socket.
+    $notsock
+    ;;; Not supported, or operation not supported on socket.
+    $notsup
+    ;;; Inappropriate I/O control operation.
+    $notty
+    ;;; No such device or address.
+    $nxio
+    ;;; Value too large to be stored in data type.
+    $overflow
+    ;;; Previous owner died.
+    $ownerdead
+    ;;; Operation not permitted.
+    $perm
+    ;;; Broken pipe.
+    $pipe
+    ;;; Protocol error.
+    $proto
+    ;;; Protocol not supported.
+    $protonosupport
+    ;;; Protocol wrong type for socket.
+    $prototype
+    ;;; Result too large.
+    $range
+    ;;; Read-only file system.
+    $rofs
+    ;;; Invalid seek.
+    $spipe
+    ;;; No such process.
+    $srch
+    ;;; Reserved.
+    $stale
+    ;;; Connection timed out.
+    $timedout
+    ;;; Text file busy.
+    $txtbsy
+    ;;; Cross-device link.
+    $xdev
+    ;;; Extension: Capabilities insufficient.
+    $notcapable
+  )
+)
+
+;;; File descriptor rights, determining which actions may be performed.
+(typename $rights
+  (flags (@witx repr u64)
+    ;;; The right to invoke `fd_datasync`.
+    ;;
+    ;;; If `path_open` is set, includes the right to invoke
+    ;;; `path_open` with `fdflags::dsync`.
+    $fd_datasync
+    ;;; The right to invoke `fd_read` and `sock_recv`.
+    ;;
+    ;;; If `rights::fd_seek` is set, includes the right to invoke `fd_pread`.
+    $fd_read
+    ;;; The right to invoke `fd_seek`. This flag implies `rights::fd_tell`.
+    $fd_seek
+    ;;; The right to invoke `fd_fdstat_set_flags`.
+    $fd_fdstat_set_flags
+    ;;; The right to invoke `fd_sync`.
+    ;;
+    ;;; If `path_open` is set, includes the right to invoke
+    ;;; `path_open` with `fdflags::rsync` and `fdflags::dsync`.
+    $fd_sync
+    ;;; The right to invoke `fd_seek` in such a way that the file offset
+    ;;; remains unaltered (i.e., `whence::cur` with offset zero), or to
+    ;;; invoke `fd_tell`.
+    $fd_tell
+    ;;; The right to invoke `fd_write` and `sock_send`.
+    ;;; If `rights::fd_seek` is set, includes the right to invoke `fd_pwrite`.
+    $fd_write
+    ;;; The right to invoke `fd_advise`.
+    $fd_advise
+    ;;; The right to invoke `fd_allocate`.
+    $fd_allocate
+    ;;; The right to invoke `path_create_directory`.
+    $path_create_directory
+    ;;; If `path_open` is set, the right to invoke `path_open` with `oflags::creat`.
+    $path_create_file
+    ;;; The right to invoke `path_link` with the file descriptor as the
+    ;;; source directory.
+    $path_link_source
+    ;;; The right to invoke `path_link` with the file descriptor as the
+    ;;; target directory.
+    $path_link_target
+    ;;; The right to invoke `path_open`.
+    $path_open
+    ;;; The right to invoke `fd_readdir`.
+    $fd_readdir
+    ;;; The right to invoke `path_readlink`.
+    $path_readlink
+    ;;; The right to invoke `path_rename` with the file descriptor as the source directory.
+    $path_rename_source
+    ;;; The right to invoke `path_rename` with the file descriptor as the target directory.
+    $path_rename_target
+    ;;; The right to invoke `path_filestat_get`.
+    $path_filestat_get
+    ;;; The right to change a file's size (there is no `path_filestat_set_size`).
+    ;;; If `path_open` is set, includes the right to invoke `path_open` with `oflags::trunc`.
+    $path_filestat_set_size
+    ;;; The right to invoke `path_filestat_set_times`.
+    $path_filestat_set_times
+    ;;; The right to invoke `fd_filestat_get`.
+    $fd_filestat_get
+    ;;; The right to invoke `fd_filestat_set_size`.
+    $fd_filestat_set_size
+    ;;; The right to invoke `fd_filestat_set_times`.
+    $fd_filestat_set_times
+    ;;; The right to invoke `path_symlink`.
+    $path_symlink
+    ;;; The right to invoke `path_remove_directory`.
+    $path_remove_directory
+    ;;; The right to invoke `path_unlink_file`.
+    $path_unlink_file
+    ;;; If `rights::fd_read` is set, includes the right to invoke `poll_oneoff` to subscribe to `eventtype::fd_read`.
+    ;;; If `rights::fd_write` is set, includes the right to invoke `poll_oneoff` to subscribe to `eventtype::fd_write`.
+    $poll_fd_readwrite
+    ;;; The right to invoke `sock_shutdown`.
+    $sock_shutdown
+    ;;; The right to invoke `sock_accept`.
+    $sock_accept
+  )
+)
+
+;;; A file descriptor handle.
+(typename $fd (handle))
+
+;;; A region of memory for scatter/gather reads.
+(typename $iovec
+  (record
+    ;;; The address of the buffer to be filled.
+    (field $buf (@witx pointer u8))
+    ;;; The length of the buffer to be filled.
+    (field $buf_len $size)
+  )
+)
+
+;;; A region of memory for scatter/gather writes.
+(typename $ciovec
+  (record
+    ;;; The address of the buffer to be written.
+    (field $buf (@witx const_pointer u8))
+    ;;; The length of the buffer to be written.
+    (field $buf_len $size)
+  )
+)
+
+(typename $iovec_array (list $iovec))
+(typename $ciovec_array (list $ciovec))
+
+;;; Relative offset within a file.
+(typename $filedelta s64)
+
+;;; The position relative to which to set the offset of the file descriptor.
+(typename $whence
+  (enum (@witx tag u8)
+    ;;; Seek relative to start-of-file.
+    $set
+    ;;; Seek relative to current position.
+    $cur
+    ;;; Seek relative to end-of-file.
+    $end
+  )
+)
+
+;;; A reference to the offset of a directory entry.
+;;;
+;;; The value 0 signifies the start of the directory.
+(typename $dircookie u64)
+
+;;; The type for the `dirent::d_namlen` field of `dirent` struct.
+(typename $dirnamlen u32)
+
+;;; File serial number that is unique within its file system.
+(typename $inode u64)
+
+;;; The type of a file descriptor or file.
+(typename $filetype
+  (enum (@witx tag u8)
+    ;;; The type of the file descriptor or file is unknown or is different from any of the other types specified.
+    $unknown
+    ;;; The file descriptor or file refers to a block device inode.
+    $block_device
+    ;;; The file descriptor or file refers to a character device inode.
+    $character_device
+    ;;; The file descriptor or file refers to a directory inode.
+    $directory
+    ;;; The file descriptor or file refers to a regular file inode.
+    $regular_file
+    ;;; The file descriptor or file refers to a datagram socket.
+    $socket_dgram
+    ;;; The file descriptor or file refers to a byte-stream socket.
+    $socket_stream
+    ;;; The file refers to a symbolic link inode.
+    $symbolic_link
+  )
+)
+
+;;; A directory entry.
+(typename $dirent
+  (record
+    ;;; The offset of the next directory entry stored in this directory.
+    (field $d_next $dircookie)
+    ;;; The serial number of the file referred to by this directory entry.
+    (field $d_ino $inode)
+    ;;; The length of the name of the directory entry.
+    (field $d_namlen $dirnamlen)
+    ;;; The type of the file referred to by this directory entry.
+    (field $d_type $filetype)
+  )
+)
+
+;;; File or memory access pattern advisory information.
+(typename $advice
+  (enum (@witx tag u8)
+    ;;; The application has no advice to give on its behavior with respect to the specified data.
+    $normal
+    ;;; The application expects to access the specified data sequentially from lower offsets to higher offsets.
+    $sequential
+    ;;; The application expects to access the specified data in a random order.
+    $random
+    ;;; The application expects to access the specified data in the near future.
+    $willneed
+    ;;; The application expects that it will not access the specified data in the near future.
+    $dontneed
+    ;;; The application expects to access the specified data once and then not reuse it thereafter.
+    $noreuse
+  )
+)
+
+;;; File descriptor flags.
+(typename $fdflags
+  (flags (@witx repr u16)
+    ;;; Append mode: Data written to the file is always appended to the file's end.
+    $append
+    ;;; Write according to synchronized I/O data integrity completion. Only the data stored in the file is synchronized.
+    $dsync
+    ;;; Non-blocking mode.
+    $nonblock
+    ;;; Synchronized read I/O operations.
+    $rsync
+    ;;; Write according to synchronized I/O file integrity completion. In
+    ;;; addition to synchronizing the data stored in the file, the implementation
+    ;;; may also synchronously update the file's metadata.
+    $sync
+  )
+)
+
+;;; File descriptor attributes.
+(typename $fdstat
+  (record
+    ;;; File type.
+    (field $fs_filetype $filetype)
+    ;;; File descriptor flags.
+    (field $fs_flags $fdflags)
+    ;;; Rights that apply to this file descriptor.
+    (field $fs_rights_base $rights)
+    ;;; Maximum set of rights that may be installed on new file descriptors that
+    ;;; are created through this file descriptor, e.g., through `path_open`.
+    (field $fs_rights_inheriting $rights)
+  )
+)
+
+;;; Identifier for a device containing a file system. Can be used in combination
+;;; with `inode` to uniquely identify a file or directory in the filesystem.
+(typename $device u64)
+
+;;; Which file time attributes to adjust.
+(typename $fstflags
+  (flags (@witx repr u16)
+    ;;; Adjust the last data access timestamp to the value stored in `filestat::atim`.
+    $atim
+    ;;; Adjust the last data access timestamp to the time of clock `clockid::realtime`.
+    $atim_now
+    ;;; Adjust the last data modification timestamp to the value stored in `filestat::mtim`.
+    $mtim
+    ;;; Adjust the last data modification timestamp to the time of clock `clockid::realtime`.
+    $mtim_now
+  )
+)
+
+;;; Flags determining the method of how paths are resolved.
+(typename $lookupflags
+  (flags (@witx repr u32)
+    ;;; As long as the resolved path corresponds to a symbolic link, it is expanded.
+    $symlink_follow
+  )
+)
+
+;;; Open flags used by `path_open`.
+(typename $oflags
+  (flags (@witx repr u16)
+    ;;; Create file if it does not exist.
+    $creat
+    ;;; Fail if not a directory.
+    $directory
+    ;;; Fail if file already exists.
+    $excl
+    ;;; Truncate file to size 0.
+    $trunc
+  )
+)
+
+;;; Number of hard links to an inode.
+(typename $linkcount u64)
+
+;;; File attributes.
+(typename $filestat
+  (record
+    ;;; Device ID of device containing the file.
+    (field $dev $device)
+    ;;; File serial number.
+    (field $ino $inode)
+    ;;; File type.
+    (field $filetype $filetype)
+    ;;; Number of hard links to the file.
+    (field $nlink $linkcount)
+    ;;; For regular files, the file size in bytes. For symbolic links, the length in bytes of the pathname contained in the symbolic link.
+    (field $size $filesize)
+    ;;; Last data access timestamp.
+    (field $atim $timestamp)
+    ;;; Last data modification timestamp.
+    (field $mtim $timestamp)
+    ;;; Last file status change timestamp.
+    (field $ctim $timestamp)
+  )
+)
+
+;;; User-provided value that may be attached to objects that is retained when
+;;; extracted from the implementation.
+(typename $userdata u64)
+
+;;; Type of a subscription to an event or its occurrence.
+(typename $eventtype
+  (enum (@witx tag u8)
+    ;;; The time value of clock `subscription_clock::id` has
+    ;;; reached timestamp `subscription_clock::timeout`.
+    $clock
+    ;;; File descriptor `subscription_fd_readwrite::file_descriptor` has data
+    ;;; available for reading. This event always triggers for regular files.
+    $fd_read
+    ;;; File descriptor `subscription_fd_readwrite::file_descriptor` has capacity
+    ;;; available for writing. This event always triggers for regular files.
+    $fd_write
+  )
+)
+
+;;; The state of the file descriptor subscribed to with
+;;; `eventtype::fd_read` or `eventtype::fd_write`.
+(typename $eventrwflags
+  (flags (@witx repr u16)
+    ;;; The peer of this socket has closed or disconnected.
+    $fd_readwrite_hangup
+  )
+)
+
+;;; The contents of an `event` when type is `eventtype::fd_read` or
+;;; `eventtype::fd_write`.
+(typename $event_fd_readwrite
+  (record
+    ;;; The number of bytes available for reading or writing.
+    (field $nbytes $filesize)
+    ;;; The state of the file descriptor.
+    (field $flags $eventrwflags)
+  )
+)
+
+;;; An event that occurred.
+(typename $event
+  (record
+    ;;; User-provided value that got attached to `subscription::userdata`.
+    (field $userdata $userdata)
+    ;;; If non-zero, an error that occurred while processing the subscription request.
+    (field $error $errno)
+    ;;; The type of event that occurred
+    (field $type $eventtype)
+    ;;; The contents of the event, if it is an `eventtype::fd_read` or
+    ;;; `eventtype::fd_write`. `eventtype::clock` events ignore this field.
+    (field $fd_readwrite $event_fd_readwrite)
+  )
+)
+
+;;; Flags determining how to interpret the timestamp provided in
+;;; `subscription_clock::timeout`.
+(typename $subclockflags
+  (flags (@witx repr u16)
+    ;;; If set, treat the timestamp provided in
+    ;;; `subscription_clock::timeout` as an absolute timestamp of clock
+    ;;; `subscription_clock::id`. If clear, treat the timestamp
+    ;;; provided in `subscription_clock::timeout` relative to the
+    ;;; current time value of clock `subscription_clock::id`.
+    $subscription_clock_abstime
+  )
+)
+
+;;; The contents of a `subscription` when type is `eventtype::clock`.
+(typename $subscription_clock
+  (record
+    ;;; The clock against which to compare the timestamp.
+    (field $id $clockid)
+    ;;; The absolute or relative timestamp.
+    (field $timeout $timestamp)
+    ;;; The amount of time that the implementation may wait additionally
+    ;;; to coalesce with other events.
+    (field $precision $timestamp)
+    ;;; Flags specifying whether the timeout is absolute or relative
+    (field $flags $subclockflags)
+  )
+)
+
+;;; The contents of a `subscription` when type is type is
+;;; `eventtype::fd_read` or `eventtype::fd_write`.
+(typename $subscription_fd_readwrite
+  (record
+    ;;; The file descriptor on which to wait for it to become ready for reading or writing.
+    (field $file_descriptor $fd)
+  )
+)
+
+;;; The contents of a `subscription`.
+(typename $subscription_u
+  (union
+    (@witx tag $eventtype)
+    $subscription_clock
+    $subscription_fd_readwrite
+    $subscription_fd_readwrite
+  )
+)
+
+;;; Subscription to an event.
+(typename $subscription
+  (record
+    ;;; User-provided value that is attached to the subscription in the
+    ;;; implementation and returned through `event::userdata`.
+    (field $userdata $userdata)
+    ;;; The type of the event to which to subscribe, and its contents
+    (field $u $subscription_u)
+  )
+)
+
+;;; Exit code generated by a process when exiting.
+(typename $exitcode u32)
+
+;;; Signal condition.
+(typename $signal
+  (enum (@witx tag u8)
+    ;;; No signal. Note that POSIX has special semantics for `kill(pid, 0)`,
+    ;;; so this value is reserved.
+    $none
+    ;;; Hangup.
+    ;;; Action: Terminates the process.
+    $hup
+    ;;; Terminate interrupt signal.
+    ;;; Action: Terminates the process.
+    $int
+    ;;; Terminal quit signal.
+    ;;; Action: Terminates the process.
+    $quit
+    ;;; Illegal instruction.
+    ;;; Action: Terminates the process.
+    $ill
+    ;;; Trace/breakpoint trap.
+    ;;; Action: Terminates the process.
+    $trap
+    ;;; Process abort signal.
+    ;;; Action: Terminates the process.
+    $abrt
+    ;;; Access to an undefined portion of a memory object.
+    ;;; Action: Terminates the process.
+    $bus
+    ;;; Erroneous arithmetic operation.
+    ;;; Action: Terminates the process.
+    $fpe
+    ;;; Kill.
+    ;;; Action: Terminates the process.
+    $kill
+    ;;; User-defined signal 1.
+    ;;; Action: Terminates the process.
+    $usr1
+    ;;; Invalid memory reference.
+    ;;; Action: Terminates the process.
+    $segv
+    ;;; User-defined signal 2.
+    ;;; Action: Terminates the process.
+    $usr2
+    ;;; Write on a pipe with no one to read it.
+    ;;; Action: Ignored.
+    $pipe
+    ;;; Alarm clock.
+    ;;; Action: Terminates the process.
+    $alrm
+    ;;; Termination signal.
+    ;;; Action: Terminates the process.
+    $term
+    ;;; Child process terminated, stopped, or continued.
+    ;;; Action: Ignored.
+    $chld
+    ;;; Continue executing, if stopped.
+    ;;; Action: Continues executing, if stopped.
+    $cont
+    ;;; Stop executing.
+    ;;; Action: Stops executing.
+    $stop
+    ;;; Terminal stop signal.
+    ;;; Action: Stops executing.
+    $tstp
+    ;;; Background process attempting read.
+    ;;; Action: Stops executing.
+    $ttin
+    ;;; Background process attempting write.
+    ;;; Action: Stops executing.
+    $ttou
+    ;;; High bandwidth data is available at a socket.
+    ;;; Action: Ignored.
+    $urg
+    ;;; CPU time limit exceeded.
+    ;;; Action: Terminates the process.
+    $xcpu
+    ;;; File size limit exceeded.
+    ;;; Action: Terminates the process.
+    $xfsz
+    ;;; Virtual timer expired.
+    ;;; Action: Terminates the process.
+    $vtalrm
+    ;;; Profiling timer expired.
+    ;;; Action: Terminates the process.
+    $prof
+    ;;; Window changed.
+    ;;; Action: Ignored.
+    $winch
+    ;;; I/O possible.
+    ;;; Action: Terminates the process.
+    $poll
+    ;;; Power failure.
+    ;;; Action: Terminates the process.
+    $pwr
+    ;;; Bad system call.
+    ;;; Action: Terminates the process.
+    $sys
+  )
+)
+
+;;; Flags provided to `sock_recv`.
+(typename $riflags
+  (flags (@witx repr u16)
+    ;;; Returns the message without removing it from the socket's receive queue.
+    $recv_peek
+    ;;; On byte-stream sockets, block until the full amount of data can be returned.
+    $recv_waitall
+  )
+)
+
+;;; Flags returned by `sock_recv`.
+(typename $roflags
+  (flags (@witx repr u16)
+    ;;; Returned by `sock_recv`: Message data has been truncated.
+    $recv_data_truncated
+  )
+)
+
+;;; Flags provided to `sock_send`. As there are currently no flags
+;;; defined, it must be set to zero.
+(typename $siflags u16)
+
+;;; Which channels on a socket to shut down.
+(typename $sdflags
+  (flags (@witx repr u8)
+    ;;; Disables further receive operations.
+    $rd
+    ;;; Disables further send operations.
+    $wr
+  )
+)
+
+;;; Identifiers for preopened capabilities.
+(typename $preopentype
+  (enum (@witx tag u8)
+    ;;; A pre-opened directory.
+    $dir
+  )
+)
+
+;;; The contents of a $prestat when type is `preopentype::dir`.
+(typename $prestat_dir
+  (record
+    ;;; The length of the directory name for use with `fd_prestat_dir_name`.
+    (field $pr_name_len $size)
+  )
+)
+
+;;; Information about a pre-opened capability.
+(typename $prestat
+  (union (@witx tag $preopentype)
+    $prestat_dir
+  )
+)
+
diff --git a/crates/wasi/witx/wasi_snapshot_preview1.witx b/crates/wasi-common/witx/preview1/wasi_snapshot_preview1.witx
similarity index 100%
rename from crates/wasi/witx/wasi_snapshot_preview1.witx
rename to crates/wasi-common/witx/preview1/wasi_snapshot_preview1.witx
diff --git a/crates/wasi-http/Cargo.toml b/crates/wasi-http/Cargo.toml
index 354d00624525..3339fc1b5743 100644
--- a/crates/wasi-http/Cargo.toml
+++ b/crates/wasi-http/Cargo.toml
@@ -3,10 +3,14 @@ name = "wasmtime-wasi-http"
 version.workspace = true
 authors.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 repository = "https://github.com/bytecodealliance/wasmtime"
 license = "Apache-2.0 WITH LLVM-exception"
 description = "Experimental HTTP library for WebAssembly in Wasmtime"
 
+[lints]
+workspace = true
+
 [dependencies]
 anyhow = { workspace = true }
 async-trait = { workspace = true }
@@ -22,17 +26,21 @@ http = { workspace = true }
 http-body = { workspace = true }
 http-body-util = { workspace = true }
 tracing = { workspace = true }
-wasmtime-wasi = { workspace = true, default-features = false, features = [
-    "preview2",
-] }
+wasmtime-wasi = { workspace = true }
 wasmtime = { workspace = true, features = ['component-model'] }
 
 # The `ring` crate, used to implement TLS, does not build on riscv64 or s390x
 [target.'cfg(not(any(target_arch = "riscv64", target_arch = "s390x")))'.dependencies]
-tokio-rustls = { version = "0.24.0" }
-rustls = { version = "0.21.6" }
-webpki-roots = { version = "0.25.2" }
+tokio-rustls = { version = "0.25.0" }
+rustls = { version = "0.22.0" }
+webpki-roots = { version = "0.26.0" }
 
-[features]
-default = ["sync"]
-sync = ["wasmtime-wasi/sync"]
+[dev-dependencies]
+test-programs-artifacts = { workspace = true }
+test-log = { workspace = true }
+tracing-subscriber = { workspace = true }
+wasmtime = { workspace = true, features = ['cranelift'] }
+tokio = { workspace = true, features = ['macros'] }
+futures = { workspace = true, default-features = false, features = ['alloc'] }
+sha2 = "0.10.2"
+base64 = "0.21.0"
diff --git a/crates/wasi-http/src/bindings.rs b/crates/wasi-http/src/bindings.rs
new file mode 100644
index 000000000000..00054e5a644b
--- /dev/null
+++ b/crates/wasi-http/src/bindings.rs
@@ -0,0 +1,77 @@
+//! Raw bindings to the `wasi:http` package.
+
+#[allow(missing_docs)]
+mod generated {
+    use crate::body;
+    use crate::types;
+
+    wasmtime::component::bindgen!({
+        path: "wit",
+        world: "wasi:http/proxy",
+        tracing: true,
+        // Flag this as "possibly async" which will cause the exports to be
+        // generated as async, but none of the imports here are async since
+        // all the blocking-ness happens in wasi:io
+        async: {
+            only_imports: ["nonexistent"],
+        },
+        trappable_imports: true,
+        require_store_data_send: true,
+        with: {
+            // Upstream package dependencies
+            "wasi:io": wasmtime_wasi::bindings::io,
+
+            // Configure all WIT http resources to be defined types in this
+            // crate to use the `ResourceTable` helper methods.
+            "wasi:http/types/outgoing-body": body::HostOutgoingBody,
+            "wasi:http/types/future-incoming-response": types::HostFutureIncomingResponse,
+            "wasi:http/types/outgoing-response": types::HostOutgoingResponse,
+            "wasi:http/types/future-trailers": body::HostFutureTrailers,
+            "wasi:http/types/incoming-body": body::HostIncomingBody,
+            "wasi:http/types/incoming-response": types::HostIncomingResponse,
+            "wasi:http/types/response-outparam": types::HostResponseOutparam,
+            "wasi:http/types/outgoing-request": types::HostOutgoingRequest,
+            "wasi:http/types/incoming-request": types::HostIncomingRequest,
+            "wasi:http/types/fields": types::HostFields,
+            "wasi:http/types/request-options": types::HostRequestOptions,
+        },
+        trappable_error_type: {
+            "wasi:http/types/error-code" => crate::HttpError,
+        },
+    });
+}
+
+pub use self::generated::wasi::*;
+
+/// Raw bindings to the `wasi:http/proxy` exports.
+pub use self::generated::exports;
+
+/// Bindings to the `wasi:http/proxy` world.
+pub use self::generated::{Proxy, ProxyIndices, ProxyPre};
+
+/// Sync implementation of the `wasi:http/proxy` world.
+pub mod sync {
+    #[allow(missing_docs)]
+    mod generated {
+        #![allow(missing_docs)]
+        wasmtime::component::bindgen!({
+            world: "wasi:http/proxy",
+            tracing: true,
+            async: false,
+            with: {
+                "wasi:http": crate::bindings::http, // http is in this crate
+                "wasi:io": wasmtime_wasi::bindings::sync::io, // io is sync
+                "wasi": wasmtime_wasi::bindings, // everything else
+            },
+            require_store_data_send: true,
+        });
+    }
+
+    pub use self::generated::wasi::*;
+
+    /// Raw bindings to the `wasi:http/proxy` exports.
+    pub use self::generated::exports;
+
+    /// Bindings to the `wasi:http/proxy` world.
+    pub use self::generated::{Proxy, ProxyIndices, ProxyPre};
+}
diff --git a/crates/wasi-http/src/body.rs b/crates/wasi-http/src/body.rs
index 39bc30de05bb..5f16f42393f0 100644
--- a/crates/wasi-http/src/body.rs
+++ b/crates/wasi-http/src/body.rs
@@ -1,190 +1,270 @@
+//! Implementation of the `wasi:http/types` interface's various body types.
+
 use crate::{bindings::http::types, types::FieldMap};
 use anyhow::anyhow;
 use bytes::Bytes;
+use http_body::{Body, Frame};
 use http_body_util::combinators::BoxBody;
+use http_body_util::BodyExt;
 use std::future::Future;
-use std::{
-    pin::Pin,
-    sync::{Arc, Mutex},
-    time::Duration,
-};
+use std::mem;
+use std::task::{Context, Poll};
+use std::{pin::Pin, sync::Arc, time::Duration};
 use tokio::sync::{mpsc, oneshot};
-use wasmtime_wasi::preview2::{
-    self, AbortOnDropJoinHandle, HostInputStream, HostOutputStream, StreamError, Subscribe,
+use wasmtime_wasi::{
+    runtime::{poll_noop, AbortOnDropJoinHandle},
+    HostInputStream, HostOutputStream, StreamError, Subscribe,
 };
 
-pub type HyperIncomingBody = BoxBody<Bytes, anyhow::Error>;
-
-/// Holds onto the things needed to construct a [`HostIncomingBody`] until we are ready to build
-/// one. The HostIncomingBody spawns a task that starts consuming the incoming body, and we don't
-/// want to do that unless the user asks to consume the body.
-pub struct HostIncomingBodyBuilder {
-    pub body: HyperIncomingBody,
-    pub between_bytes_timeout: Duration,
-}
+/// Common type for incoming bodies.
+pub type HyperIncomingBody = BoxBody<Bytes, types::ErrorCode>;
 
-impl HostIncomingBodyBuilder {
-    /// Consume the state held in the [`HostIncomingBodyBuilder`] to spawn a task that will drive the
-    /// streaming body to completion. Data segments will be communicated out over the
-    /// [`HostIncomingBodyStream`], and a [`HostFutureTrailers`] gives a way to block on/retrieve
-    /// the trailers.
-    pub fn build(mut self) -> HostIncomingBody {
-        let (body_writer, body_receiver) = mpsc::channel(1);
-        let (trailer_writer, trailers) = oneshot::channel();
-
-        let worker = preview2::spawn(async move {
-            loop {
-                let frame = match tokio::time::timeout(
-                    self.between_bytes_timeout,
-                    http_body_util::BodyExt::frame(&mut self.body),
-                )
-                .await
-                {
-                    Ok(None) => break,
-
-                    Ok(Some(Ok(frame))) => frame,
-
-                    Ok(Some(Err(e))) => {
-                        match body_writer.send(Err(e)).await {
-                            Ok(_) => {}
-                            // If the body read end has dropped, then we report this error with the
-                            // trailers. unwrap and rewrap Err because the Ok side of these two Results
-                            // are different.
-                            Err(e) => {
-                                let _ = trailer_writer.send(Err(e.0.unwrap_err()));
-                            }
-                        }
-                        break;
-                    }
-
-                    Err(_) => {
-                        match body_writer
-                            .send(Err(types::Error::TimeoutError(
-                                "data frame timed out".to_string(),
-                            )
-                            .into()))
-                            .await
-                        {
-                            Ok(_) => {}
-                            Err(e) => {
-                                let _ = trailer_writer.send(Err(e.0.unwrap_err()));
-                            }
-                        }
-                        break;
-                    }
-                };
+/// Common type for outgoing bodies.
+pub type HyperOutgoingBody = BoxBody<Bytes, types::ErrorCode>;
 
-                if frame.is_trailers() {
-                    // We know we're not going to write any more data frames at this point, so we
-                    // explicitly drop the body_writer so that anything waiting on the read end returns
-                    // immediately.
-                    drop(body_writer);
+/// The concrete type behind a `was:http/types/incoming-body` resource.
+#[derive(Debug)]
+pub struct HostIncomingBody {
+    body: IncomingBodyState,
+    /// An optional worker task to keep alive while this body is being read.
+    /// This ensures that if the parent of this body is dropped before the body
+    /// then the backing data behind this worker is kept alive.
+    worker: Option<AbortOnDropJoinHandle<()>>,
+}
 
-                    let trailers = frame.into_trailers().unwrap();
+impl HostIncomingBody {
+    /// Create a new `HostIncomingBody` with the given `body` and a per-frame timeout
+    pub fn new(body: HyperIncomingBody, between_bytes_timeout: Duration) -> HostIncomingBody {
+        let body = BodyWithTimeout::new(body, between_bytes_timeout);
+        HostIncomingBody {
+            body: IncomingBodyState::Start(body),
+            worker: None,
+        }
+    }
 
-                    // TODO: this will fail in two cases:
-                    // 1. we've already used the channel once, which should be imposible,
-                    // 2. the read end is closed.
-                    // I'm not sure how to differentiate between these two cases, or really
-                    // if we need to do anything to handle either.
-                    let _ = trailer_writer.send(Ok(trailers));
+    /// Retain a worker task that needs to be kept alive while this body is being read.
+    pub fn retain_worker(&mut self, worker: AbortOnDropJoinHandle<()>) {
+        assert!(self.worker.is_none());
+        self.worker = Some(worker);
+    }
 
-                    break;
-                }
+    /// Try taking the stream of this body, if it's available.
+    pub fn take_stream(&mut self) -> Option<HostIncomingBodyStream> {
+        match &mut self.body {
+            IncomingBodyState::Start(_) => {}
+            IncomingBodyState::InBodyStream(_) => return None,
+        }
+        let (tx, rx) = oneshot::channel();
+        let body = match mem::replace(&mut self.body, IncomingBodyState::InBodyStream(rx)) {
+            IncomingBodyState::Start(b) => b,
+            IncomingBodyState::InBodyStream(_) => unreachable!(),
+        };
+        Some(HostIncomingBodyStream {
+            state: IncomingBodyStreamState::Open { body, tx },
+            buffer: Bytes::new(),
+            error: None,
+        })
+    }
 
-                assert!(frame.is_data(), "frame wasn't data");
+    /// Convert this body into a `HostFutureTrailers` resource.
+    pub fn into_future_trailers(self) -> HostFutureTrailers {
+        HostFutureTrailers::Waiting(self)
+    }
+}
 
-                let data = frame.into_data().unwrap();
+/// Internal state of a [`HostIncomingBody`].
+#[derive(Debug)]
+enum IncomingBodyState {
+    /// The body is stored here meaning that within `HostIncomingBody` the
+    /// `take_stream` method can be called for example.
+    Start(BodyWithTimeout),
+
+    /// The body is within a `HostIncomingBodyStream` meaning that it's not
+    /// currently owned here. The body will be sent back over this channel when
+    /// it's done, however.
+    InBodyStream(oneshot::Receiver<StreamEnd>),
+}
 
-                // If the receiver no longer exists, thats ok - in that case we want to keep the
-                // loop running to relieve backpressure, so we get to the trailers.
-                let _ = body_writer.send(Ok(data)).await;
-            }
-        });
+/// Small wrapper around [`HyperIncomingBody`] which adds a timeout to every frame.
+#[derive(Debug)]
+struct BodyWithTimeout {
+    /// Underlying stream that frames are coming from.
+    inner: HyperIncomingBody,
+    /// Currently active timeout that's reset between frames.
+    timeout: Pin<Box<tokio::time::Sleep>>,
+    /// Whether or not `timeout` needs to be reset on the next call to
+    /// `poll_frame`.
+    reset_sleep: bool,
+    /// Maximal duration between when a frame is first requested and when it's
+    /// allowed to arrive.
+    between_bytes_timeout: Duration,
+}
 
-        HostIncomingBody {
-            worker,
-            stream: Some(HostIncomingBodyStream::new(body_receiver)),
-            trailers,
+impl BodyWithTimeout {
+    fn new(inner: HyperIncomingBody, between_bytes_timeout: Duration) -> BodyWithTimeout {
+        BodyWithTimeout {
+            inner,
+            between_bytes_timeout,
+            reset_sleep: true,
+            timeout: Box::pin(wasmtime_wasi::runtime::with_ambient_tokio_runtime(|| {
+                tokio::time::sleep(Duration::new(0, 0))
+            })),
         }
     }
 }
 
-pub struct HostIncomingBody {
-    pub worker: AbortOnDropJoinHandle<()>,
-    pub stream: Option<HostIncomingBodyStream>,
-    pub trailers: oneshot::Receiver<Result<hyper::HeaderMap, anyhow::Error>>,
-}
+impl Body for BodyWithTimeout {
+    type Data = Bytes;
+    type Error = types::ErrorCode;
+
+    fn poll_frame(
+        self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Frame<Bytes>, types::ErrorCode>>> {
+        let me = Pin::into_inner(self);
+
+        // If the timeout timer needs to be reset, do that now relative to the
+        // current instant. Otherwise test the timeout timer and see if it's
+        // fired yet and if so we've timed out and return an error.
+        if me.reset_sleep {
+            me.timeout
+                .as_mut()
+                .reset(tokio::time::Instant::now() + me.between_bytes_timeout);
+            me.reset_sleep = false;
+        }
 
-impl HostIncomingBody {
-    pub fn into_future_trailers(self) -> HostFutureTrailers {
-        HostFutureTrailers {
-            _worker: self.worker,
-            state: HostFutureTrailersState::Waiting(self.trailers),
+        // Register interest in this context on the sleep timer, and if the
+        // sleep elapsed that means that we've timed out.
+        if let Poll::Ready(()) = me.timeout.as_mut().poll(cx) {
+            return Poll::Ready(Some(Err(types::ErrorCode::ConnectionReadTimeout)));
         }
+
+        // Without timeout business now handled check for the frame. If a frame
+        // arrives then the sleep timer will be reset on the next frame.
+        let result = Pin::new(&mut me.inner).poll_frame(cx);
+        me.reset_sleep = result.is_ready();
+        result
     }
 }
 
+/// Message sent when a `HostIncomingBodyStream` is done to the
+/// `HostFutureTrailers` state.
+#[derive(Debug)]
+enum StreamEnd {
+    /// The body wasn't completely read and was dropped early. May still have
+    /// trailers, but requires reading more frames.
+    Remaining(BodyWithTimeout),
+
+    /// Body was completely read and trailers were read. Here are the trailers.
+    /// Note that `None` means that the body finished without trailers.
+    Trailers(Option<FieldMap>),
+}
+
+/// The concrete type behind the `wasi:io/streams/input-stream` resource returned
+/// by `wasi:http/types/incoming-body`'s `stream` method.
+#[derive(Debug)]
 pub struct HostIncomingBodyStream {
-    pub open: bool,
-    pub receiver: mpsc::Receiver<Result<Bytes, anyhow::Error>>,
-    pub buffer: Bytes,
-    pub error: Option<anyhow::Error>,
+    state: IncomingBodyStreamState,
+    buffer: Bytes,
+    error: Option<anyhow::Error>,
 }
 
 impl HostIncomingBodyStream {
-    fn new(receiver: mpsc::Receiver<Result<Bytes, anyhow::Error>>) -> Self {
-        Self {
-            open: true,
-            receiver,
-            buffer: Bytes::new(),
-            error: None,
+    fn record_frame(&mut self, frame: Option<Result<Frame<Bytes>, types::ErrorCode>>) {
+        match frame {
+            Some(Ok(frame)) => match frame.into_data() {
+                // A data frame was received, so queue up the buffered data for
+                // the next `read` call.
+                Ok(bytes) => {
+                    assert!(self.buffer.is_empty());
+                    self.buffer = bytes;
+                }
+
+                // Trailers were received meaning that this was the final frame.
+                // Throw away the body and send the trailers along the
+                // `tx` channel to make them available.
+                Err(trailers) => {
+                    let trailers = trailers.into_trailers().unwrap();
+                    let tx = match mem::replace(&mut self.state, IncomingBodyStreamState::Closed) {
+                        IncomingBodyStreamState::Open { body: _, tx } => tx,
+                        IncomingBodyStreamState::Closed => unreachable!(),
+                    };
+
+                    // NB: ignore send failures here because if this fails then
+                    // no one was interested in the trailers.
+                    let _ = tx.send(StreamEnd::Trailers(Some(trailers)));
+                }
+            },
+
+            // An error was received meaning that the stream is now done.
+            // Destroy the body to terminate the stream while enqueueing the
+            // error to get returned from the next call to `read`.
+            Some(Err(e)) => {
+                self.error = Some(e.into());
+                self.state = IncomingBodyStreamState::Closed;
+            }
+
+            // No more frames are going to be received again, so drop the `body`
+            // and the `tx` channel we'd send the body back onto because it's
+            // not needed as frames are done.
+            None => {
+                self.state = IncomingBodyStreamState::Closed;
+            }
         }
     }
 }
 
+#[derive(Debug)]
+enum IncomingBodyStreamState {
+    /// The body is currently open for reading and present here.
+    ///
+    /// When trailers are read, or when this is dropped, the body is sent along
+    /// `tx`.
+    ///
+    /// This state is transitioned to `Closed` when an error happens, EOF
+    /// happens, or when trailers are read.
+    Open {
+        body: BodyWithTimeout,
+        tx: oneshot::Sender<StreamEnd>,
+    },
+
+    /// This body is closed and no longer available for reading, no more data
+    /// will come.
+    Closed,
+}
+
 #[async_trait::async_trait]
 impl HostInputStream for HostIncomingBodyStream {
     fn read(&mut self, size: usize) -> Result<Bytes, StreamError> {
-        use mpsc::error::TryRecvError;
-
-        if !self.buffer.is_empty() {
-            let len = size.min(self.buffer.len());
-            let chunk = self.buffer.split_to(len);
-            return Ok(chunk);
-        }
-
-        if let Some(e) = self.error.take() {
-            return Err(StreamError::LastOperationFailed(e));
-        }
-
-        if !self.open {
-            return Err(StreamError::Closed);
-        }
-
-        match self.receiver.try_recv() {
-            Ok(Ok(mut bytes)) => {
-                let len = bytes.len().min(size);
-                let chunk = bytes.split_to(len);
-                if !bytes.is_empty() {
-                    self.buffer = bytes;
-                }
-
+        loop {
+            // Handle buffered data/errors if any
+            if !self.buffer.is_empty() {
+                let len = size.min(self.buffer.len());
+                let chunk = self.buffer.split_to(len);
                 return Ok(chunk);
             }
 
-            Ok(Err(e)) => {
-                self.open = false;
+            if let Some(e) = self.error.take() {
                 return Err(StreamError::LastOperationFailed(e));
             }
 
-            Err(TryRecvError::Empty) => {
-                return Ok(Bytes::new());
-            }
+            // Extract the body that we're reading from. If present perform a
+            // non-blocking poll to see if a frame is already here. If it is
+            // then turn the loop again to operate on the results. If it's not
+            // here then return an empty buffer as no data is available at this
+            // time.
+            let body = match &mut self.state {
+                IncomingBodyStreamState::Open { body, .. } => body,
+                IncomingBodyStreamState::Closed => return Err(StreamError::Closed),
+            };
 
-            Err(TryRecvError::Disconnected) => {
-                self.open = false;
-                return Err(StreamError::Closed);
+            let future = body.frame();
+            futures::pin_mut!(future);
+            match poll_noop(future) {
+                Some(result) => {
+                    self.record_frame(result);
+                }
+                None => return Ok(Bytes::new()),
             }
         }
     }
@@ -193,71 +273,162 @@ impl HostInputStream for HostIncomingBodyStream {
 #[async_trait::async_trait]
 impl Subscribe for HostIncomingBodyStream {
     async fn ready(&mut self) {
-        if !self.buffer.is_empty() {
+        if !self.buffer.is_empty() || self.error.is_some() {
             return;
         }
 
-        if !self.open {
-            return;
-        }
-
-        match self.receiver.recv().await {
-            Some(Ok(bytes)) => self.buffer = bytes,
-
-            Some(Err(e)) => {
-                self.error = Some(e);
-                self.open = false;
-            }
-
-            None => self.open = false,
+        if let IncomingBodyStreamState::Open { body, .. } = &mut self.state {
+            let frame = body.frame().await;
+            self.record_frame(frame);
         }
     }
 }
 
-pub struct HostFutureTrailers {
-    _worker: AbortOnDropJoinHandle<()>,
-    pub state: HostFutureTrailersState,
+impl Drop for HostIncomingBodyStream {
+    fn drop(&mut self) {
+        // When a body stream is dropped, for whatever reason, attempt to send
+        // the body back to the `tx` which will provide the trailers if desired.
+        // This isn't necessary if the state is already closed. Additionally,
+        // like `record_frame` above, `send` errors are ignored as they indicate
+        // that the body/trailers aren't actually needed.
+        let prev = mem::replace(&mut self.state, IncomingBodyStreamState::Closed);
+        if let IncomingBodyStreamState::Open { body, tx } = prev {
+            let _ = tx.send(StreamEnd::Remaining(body));
+        }
+    }
 }
 
-pub enum HostFutureTrailersState {
-    Waiting(oneshot::Receiver<Result<hyper::HeaderMap, anyhow::Error>>),
-    Done(Result<FieldMap, types::Error>),
+/// The concrete type behind a `wasi:http/types/future-trailers` resource.
+#[derive(Debug)]
+pub enum HostFutureTrailers {
+    /// Trailers aren't here yet.
+    ///
+    /// This state represents two similar states:
+    ///
+    /// * The body is here and ready for reading and we're waiting to read
+    ///   trailers. This can happen for example when the actual body wasn't read
+    ///   or if the body was only partially read.
+    ///
+    /// * The body is being read by something else and we're waiting for that to
+    ///   send us the trailers (or the body itself). This state will get entered
+    ///   when the body stream is dropped for example. If the body stream reads
+    ///   the trailers itself it will also send a message over here with the
+    ///   trailers.
+    Waiting(HostIncomingBody),
+
+    /// Trailers are ready and here they are.
+    ///
+    /// Note that `Ok(None)` means that there were no trailers for this request
+    /// while `Ok(Some(_))` means that trailers were found in the request.
+    Done(Result<Option<FieldMap>, types::ErrorCode>),
+
+    /// Trailers have been consumed by `future-trailers.get`.
+    Consumed,
 }
 
 #[async_trait::async_trait]
 impl Subscribe for HostFutureTrailers {
     async fn ready(&mut self) {
-        if let HostFutureTrailersState::Waiting(rx) = &mut self.state {
-            let result = match rx.await {
-                Ok(Ok(headers)) => Ok(FieldMap::from(headers)),
-                Ok(Err(e)) => Err(types::Error::ProtocolError(format!("hyper error: {e:?}"))),
-                Err(_) => Err(types::Error::ProtocolError(
-                    "stream hung up before trailers were received".to_string(),
-                )),
-            };
-            self.state = HostFutureTrailersState::Done(result);
+        let body = match self {
+            HostFutureTrailers::Waiting(body) => body,
+            HostFutureTrailers::Done(_) => return,
+            HostFutureTrailers::Consumed => return,
+        };
+
+        // If the body is itself being read by a body stream then we need to
+        // wait for that to be done.
+        if let IncomingBodyState::InBodyStream(rx) = &mut body.body {
+            match rx.await {
+                // Trailers were read for us and here they are, so store the
+                // result.
+                Ok(StreamEnd::Trailers(t)) => *self = Self::Done(Ok(t)),
+
+                // The body wasn't fully read and was dropped before trailers
+                // were reached. It's up to us now to complete the body.
+                Ok(StreamEnd::Remaining(b)) => body.body = IncomingBodyState::Start(b),
+
+                // Technically this shouldn't be possible as the sender
+                // shouldn't get destroyed without receiving a message. Handle
+                // this just in case though.
+                Err(_) => {
+                    debug_assert!(false, "should be unreachable");
+                    *self = HostFutureTrailers::Done(Err(types::ErrorCode::ConnectionTerminated));
+                }
+            }
         }
+
+        // Here it should be guaranteed that `InBodyStream` is now gone, so if
+        // we have the body ourselves then read frames until trailers are found.
+        let body = match self {
+            HostFutureTrailers::Waiting(body) => body,
+            HostFutureTrailers::Done(_) => return,
+            HostFutureTrailers::Consumed => return,
+        };
+        let hyper_body = match &mut body.body {
+            IncomingBodyState::Start(body) => body,
+            IncomingBodyState::InBodyStream(_) => unreachable!(),
+        };
+        let result = loop {
+            match hyper_body.frame().await {
+                None => break Ok(None),
+                Some(Err(e)) => break Err(e),
+                Some(Ok(frame)) => {
+                    // If this frame is a data frame ignore it as we're only
+                    // interested in trailers.
+                    if let Ok(headers) = frame.into_trailers() {
+                        break Ok(Some(headers));
+                    }
+                }
+            }
+        };
+        *self = HostFutureTrailers::Done(result);
     }
 }
 
-pub type HyperOutgoingBody = BoxBody<Bytes, anyhow::Error>;
+#[derive(Debug, Clone)]
+struct WrittenState {
+    expected: u64,
+    written: Arc<std::sync::atomic::AtomicU64>,
+}
 
-pub enum FinishMessage {
-    Finished,
-    Trailers(hyper::HeaderMap),
-    Abort,
+impl WrittenState {
+    fn new(expected_size: u64) -> Self {
+        Self {
+            expected: expected_size,
+            written: Arc::new(std::sync::atomic::AtomicU64::new(0)),
+        }
+    }
+
+    /// The number of bytes that have been written so far.
+    fn written(&self) -> u64 {
+        self.written.load(std::sync::atomic::Ordering::Relaxed)
+    }
+
+    /// Add `len` to the total number of bytes written. Returns `false` if the new total exceeds
+    /// the number of bytes expected to be written.
+    fn update(&self, len: usize) -> bool {
+        let len = len as u64;
+        let old = self
+            .written
+            .fetch_add(len, std::sync::atomic::Ordering::Relaxed);
+        old + len <= self.expected
+    }
 }
 
+/// The concrete type behind a `wasi:http/types/outgoing-body` resource.
 pub struct HostOutgoingBody {
-    pub body_output_stream: Option<Box<dyn HostOutputStream>>,
-    pub finish_sender: Option<tokio::sync::oneshot::Sender<FinishMessage>>,
+    /// The output stream that the body is written to.
+    body_output_stream: Option<Box<dyn HostOutputStream>>,
+    context: StreamContext,
+    written: Option<WrittenState>,
+    finish_sender: Option<tokio::sync::oneshot::Sender<FinishMessage>>,
 }
 
 impl HostOutgoingBody {
-    pub fn new() -> (Self, HyperOutgoingBody) {
-        use http_body_util::BodyExt;
-        use hyper::body::{Body, Frame};
-        use std::task::{Context, Poll};
+    /// Create a new `HostOutgoingBody`
+    pub fn new(context: StreamContext, size: Option<u64>) -> (Self, HyperOutgoingBody) {
+        let written = size.map(WrittenState::new);
+
         use tokio::sync::oneshot::error::RecvError;
         struct BodyImpl {
             body_receiver: mpsc::Receiver<Bytes>,
@@ -265,7 +436,7 @@ impl HostOutgoingBody {
         }
         impl Body for BodyImpl {
             type Data = Bytes;
-            type Error = anyhow::Error;
+            type Error = types::ErrorCode;
             fn poll_frame(
                 mut self: Pin<&mut Self>,
                 cx: &mut Context<'_>,
@@ -287,9 +458,9 @@ impl HostOutgoingBody {
                                     FinishMessage::Trailers(trailers) => {
                                         Poll::Ready(Some(Ok(Frame::trailers(trailers))))
                                     }
-                                    FinishMessage::Abort => Poll::Ready(Some(Err(
-                                        anyhow::anyhow!("response corrupted"),
-                                    ))),
+                                    FinishMessage::Abort => {
+                                        Poll::Ready(Some(Err(types::ErrorCode::HttpProtocolError)))
+                                    }
                                 },
                                 Poll::Ready(Err(RecvError { .. })) => Poll::Ready(None),
                             }
@@ -301,174 +472,131 @@ impl HostOutgoingBody {
             }
         }
 
-        let (body_sender, body_receiver) = mpsc::channel(1);
+        let (body_sender, body_receiver) = mpsc::channel(2);
         let (finish_sender, finish_receiver) = oneshot::channel();
         let body_impl = BodyImpl {
             body_receiver,
             finish_receiver: Some(finish_receiver),
         }
         .boxed();
+
+        // TODO: this capacity constant is arbitrary, and should be configurable
+        let output_stream =
+            BodyWriteStream::new(context, 1024 * 1024, body_sender, written.clone());
+
         (
             Self {
-                // TODO: this capacity constant is arbitrary, and should be configurable
-                body_output_stream: Some(Box::new(BodyWriteStream::new(1024 * 1024, body_sender))),
+                body_output_stream: Some(Box::new(output_stream)),
+                context,
+                written,
                 finish_sender: Some(finish_sender),
             },
             body_impl,
         )
     }
-}
-
-// copied in from preview2::write_stream
 
-#[derive(Debug)]
-struct WorkerState {
-    alive: bool,
-    items: std::collections::VecDeque<Bytes>,
-    write_budget: usize,
-    flush_pending: bool,
-    error: Option<anyhow::Error>,
-}
+    /// Take the output stream, if it's available.
+    pub fn take_output_stream(&mut self) -> Option<Box<dyn HostOutputStream>> {
+        self.body_output_stream.take()
+    }
 
-impl WorkerState {
-    fn check_error(&mut self) -> Result<(), StreamError> {
-        if let Some(e) = self.error.take() {
-            return Err(StreamError::LastOperationFailed(e));
-        }
-        if !self.alive {
-            return Err(StreamError::Closed);
+    /// Finish the body, optionally with trailers.
+    pub fn finish(mut self, trailers: Option<FieldMap>) -> Result<(), types::ErrorCode> {
+        // Make sure that the output stream has been dropped, so that the BodyImpl poll function
+        // will immediately pick up the finish sender.
+        drop(self.body_output_stream);
+
+        let sender = self
+            .finish_sender
+            .take()
+            .expect("outgoing-body trailer_sender consumed by a non-owning function");
+
+        if let Some(w) = self.written {
+            let written = w.written();
+            if written != w.expected {
+                let _ = sender.send(FinishMessage::Abort);
+                return Err(self.context.as_body_size_error(written));
+            }
         }
-        Ok(())
-    }
-}
 
-struct Worker {
-    state: Mutex<WorkerState>,
-    new_work: tokio::sync::Notify,
-    write_ready_changed: tokio::sync::Notify,
-}
+        let message = if let Some(ts) = trailers {
+            FinishMessage::Trailers(ts)
+        } else {
+            FinishMessage::Finished
+        };
 
-enum Job {
-    Flush,
-    Write(Bytes),
-}
+        // Ignoring failure: receiver died sending body, but we can't report that here.
+        let _ = sender.send(message.into());
 
-impl Worker {
-    fn new(write_budget: usize) -> Self {
-        Self {
-            state: Mutex::new(WorkerState {
-                alive: true,
-                items: std::collections::VecDeque::new(),
-                write_budget,
-                flush_pending: false,
-                error: None,
-            }),
-            new_work: tokio::sync::Notify::new(),
-            write_ready_changed: tokio::sync::Notify::new(),
-        }
-    }
-    async fn ready(&self) {
-        loop {
-            {
-                let state = self.state();
-                if state.error.is_some()
-                    || !state.alive
-                    || (!state.flush_pending && state.write_budget > 0)
-                {
-                    return;
-                }
-            }
-            self.write_ready_changed.notified().await;
-        }
+        Ok(())
     }
-    fn check_write(&self) -> Result<usize, StreamError> {
-        let mut state = self.state();
-        if let Err(e) = state.check_error() {
-            return Err(e);
-        }
 
-        if state.flush_pending || state.write_budget == 0 {
-            return Ok(0);
-        }
+    /// Abort the body.
+    pub fn abort(mut self) {
+        // Make sure that the output stream has been dropped, so that the BodyImpl poll function
+        // will immediately pick up the finish sender.
+        drop(self.body_output_stream);
 
-        Ok(state.write_budget)
-    }
-    fn state(&self) -> std::sync::MutexGuard<WorkerState> {
-        self.state.lock().unwrap()
-    }
-    fn pop(&self) -> Option<Job> {
-        let mut state = self.state();
-        if state.items.is_empty() {
-            if state.flush_pending {
-                return Some(Job::Flush);
-            }
-        } else if let Some(bytes) = state.items.pop_front() {
-            return Some(Job::Write(bytes));
-        }
+        let sender = self
+            .finish_sender
+            .take()
+            .expect("outgoing-body trailer_sender consumed by a non-owning function");
 
-        None
+        let _ = sender.send(FinishMessage::Abort);
     }
-    fn report_error(&self, e: std::io::Error) {
-        {
-            let mut state = self.state();
-            state.alive = false;
-            state.error = Some(e.into());
-            state.flush_pending = false;
-        }
-        self.write_ready_changed.notify_one();
-    }
-
-    async fn work(&self, writer: mpsc::Sender<Bytes>) {
-        loop {
-            while let Some(job) = self.pop() {
-                match job {
-                    Job::Flush => {
-                        self.state().flush_pending = false;
-                    }
+}
 
-                    Job::Write(bytes) => {
-                        tracing::debug!("worker writing: {bytes:?}");
-                        let len = bytes.len();
-                        match writer.send(bytes).await {
-                            Err(_) => {
-                                self.report_error(std::io::Error::new(
-                                    std::io::ErrorKind::BrokenPipe,
-                                    "Outgoing stream body reader has dropped",
-                                ));
-                                return;
-                            }
-                            Ok(_) => {
-                                self.state().write_budget += len;
-                            }
-                        }
-                    }
-                }
+/// Message sent to end the `[HostOutgoingBody]` stream.
+#[derive(Debug)]
+enum FinishMessage {
+    Finished,
+    Trailers(hyper::HeaderMap),
+    Abort,
+}
 
-                self.write_ready_changed.notify_one();
-            }
+/// Whether the body is a request or response body.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum StreamContext {
+    /// The body is a request body.
+    Request,
+    /// The body is a response body.
+    Response,
+}
 
-            self.new_work.notified().await;
+impl StreamContext {
+    /// Construct the correct [`types::ErrorCode`] body size error.
+    pub fn as_body_size_error(&self, size: u64) -> types::ErrorCode {
+        match self {
+            StreamContext::Request => types::ErrorCode::HttpRequestBodySize(Some(size)),
+            StreamContext::Response => types::ErrorCode::HttpResponseBodySize(Some(size)),
         }
     }
 }
 
 /// Provides a [`HostOutputStream`] impl from a [`tokio::sync::mpsc::Sender`].
-pub struct BodyWriteStream {
-    worker: Arc<Worker>,
-    _join_handle: preview2::AbortOnDropJoinHandle<()>,
+#[derive(Debug)]
+struct BodyWriteStream {
+    context: StreamContext,
+    writer: mpsc::Sender<Bytes>,
+    write_budget: usize,
+    written: Option<WrittenState>,
 }
 
 impl BodyWriteStream {
     /// Create a [`BodyWriteStream`].
-    pub fn new(write_budget: usize, writer: mpsc::Sender<Bytes>) -> Self {
-        let worker = Arc::new(Worker::new(write_budget));
-
-        let w = Arc::clone(&worker);
-        let join_handle = preview2::spawn(async move { w.work(writer).await });
-
+    fn new(
+        context: StreamContext,
+        write_budget: usize,
+        writer: mpsc::Sender<Bytes>,
+        written: Option<WrittenState>,
+    ) -> Self {
+        // at least one capacity is required to send a message
+        assert!(writer.max_capacity() >= 1);
         BodyWriteStream {
-            worker,
-            _join_handle: join_handle,
+            context,
+            writer,
+            write_budget,
+            written,
         }
     }
 }
@@ -476,41 +604,69 @@ impl BodyWriteStream {
 #[async_trait::async_trait]
 impl HostOutputStream for BodyWriteStream {
     fn write(&mut self, bytes: Bytes) -> Result<(), StreamError> {
-        let mut state = self.worker.state();
-        state.check_error()?;
-        if state.flush_pending {
-            return Err(StreamError::Trap(anyhow!(
-                "write not permitted while flush pending"
-            )));
-        }
-        match state.write_budget.checked_sub(bytes.len()) {
-            Some(remaining_budget) => {
-                state.write_budget = remaining_budget;
-                state.items.push_back(bytes);
+        let len = bytes.len();
+        match self.writer.try_send(bytes) {
+            // If the message was sent then it's queued up now in hyper to get
+            // received.
+            Ok(()) => {
+                if let Some(written) = self.written.as_ref() {
+                    if !written.update(len) {
+                        let total = written.written();
+                        return Err(StreamError::LastOperationFailed(anyhow!(self
+                            .context
+                            .as_body_size_error(total))));
+                    }
+                }
+
+                Ok(())
             }
-            None => return Err(StreamError::Trap(anyhow!("write exceeded budget"))),
+
+            // If this channel is full then that means `check_write` wasn't
+            // called. The call to `check_write` always guarantees that there's
+            // at least one capacity if a write is allowed.
+            Err(mpsc::error::TrySendError::Full(_)) => {
+                Err(StreamError::Trap(anyhow!("write exceeded budget")))
+            }
+
+            // Hyper is gone so this stream is now closed.
+            Err(mpsc::error::TrySendError::Closed(_)) => Err(StreamError::Closed),
         }
-        drop(state);
-        self.worker.new_work.notify_one();
-        Ok(())
     }
-    fn flush(&mut self) -> Result<(), StreamError> {
-        let mut state = self.worker.state();
-        state.check_error()?;
-
-        state.flush_pending = true;
-        self.worker.new_work.notify_one();
 
-        Ok(())
+    fn flush(&mut self) -> Result<(), StreamError> {
+        // Flushing doesn't happen in this body stream since we're currently
+        // only tracking sending bytes over to hyper.
+        if self.writer.is_closed() {
+            Err(StreamError::Closed)
+        } else {
+            Ok(())
+        }
     }
 
     fn check_write(&mut self) -> Result<usize, StreamError> {
-        self.worker.check_write()
+        if self.writer.is_closed() {
+            Err(StreamError::Closed)
+        } else if self.writer.capacity() == 0 {
+            // If there is no more capacity in this sender channel then don't
+            // allow any more writes because the hyper task needs to catch up
+            // now.
+            //
+            // Note that this relies on this task being the only one sending
+            // data to ensure that no one else can steal a write into this
+            // channel.
+            Ok(0)
+        } else {
+            Ok(self.write_budget)
+        }
     }
 }
+
 #[async_trait::async_trait]
 impl Subscribe for BodyWriteStream {
     async fn ready(&mut self) {
-        self.worker.ready().await
+        // Attempt to perform a reservation for a send. If there's capacity in
+        // the channel or it's already closed then this will return immediately.
+        // If the channel is full this will block until capacity opens up.
+        let _ = self.writer.reserve().await;
     }
 }
diff --git a/crates/wasi-http/src/error.rs b/crates/wasi-http/src/error.rs
new file mode 100644
index 000000000000..1c60a4b0771e
--- /dev/null
+++ b/crates/wasi-http/src/error.rs
@@ -0,0 +1,113 @@
+use crate::bindings::http::types::ErrorCode;
+use std::error::Error;
+use std::fmt;
+use wasmtime_wasi::ResourceTableError;
+
+/// A [`Result`] type where the error type defaults to [`HttpError`].
+pub type HttpResult<T, E = HttpError> = Result<T, E>;
+
+/// A `wasi:http`-specific error type used to represent either a trap or an
+/// [`ErrorCode`].
+///
+/// Modeled after [`TrappableError`](wasmtime_wasi::TrappableError).
+#[repr(transparent)]
+pub struct HttpError {
+    err: anyhow::Error,
+}
+
+impl HttpError {
+    /// Create a new `HttpError` that represents a trap.
+    pub fn trap(err: impl Into<anyhow::Error>) -> HttpError {
+        HttpError { err: err.into() }
+    }
+
+    /// Downcast this error to an [`ErrorCode`].
+    pub fn downcast(self) -> anyhow::Result<ErrorCode> {
+        self.err.downcast()
+    }
+
+    /// Downcast this error to a reference to an [`ErrorCode`]
+    pub fn downcast_ref(&self) -> Option<&ErrorCode> {
+        self.err.downcast_ref()
+    }
+}
+
+impl From<ErrorCode> for HttpError {
+    fn from(error: ErrorCode) -> Self {
+        Self { err: error.into() }
+    }
+}
+
+impl From<ResourceTableError> for HttpError {
+    fn from(error: ResourceTableError) -> Self {
+        HttpError::trap(error)
+    }
+}
+
+impl fmt::Debug for HttpError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.err.fmt(f)
+    }
+}
+
+impl fmt::Display for HttpError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.err.fmt(f)
+    }
+}
+
+impl Error for HttpError {}
+
+pub(crate) fn dns_error(rcode: String, info_code: u16) -> ErrorCode {
+    ErrorCode::DnsError(crate::bindings::http::types::DnsErrorPayload {
+        rcode: Some(rcode),
+        info_code: Some(info_code),
+    })
+}
+
+pub(crate) fn internal_error(msg: String) -> ErrorCode {
+    ErrorCode::InternalError(Some(msg))
+}
+
+/// Translate a [`http::Error`] to a wasi-http `ErrorCode` in the context of a request.
+pub fn http_request_error(err: http::Error) -> ErrorCode {
+    if err.is::<http::uri::InvalidUri>() {
+        return ErrorCode::HttpRequestUriInvalid;
+    }
+
+    tracing::warn!("http request error: {err:?}");
+
+    ErrorCode::HttpProtocolError
+}
+
+/// Translate a [`hyper::Error`] to a wasi-http `ErrorCode` in the context of a request.
+pub fn hyper_request_error(err: hyper::Error) -> ErrorCode {
+    // If there's a source, we might be able to extract a wasi-http error from it.
+    if let Some(cause) = err.source() {
+        if let Some(err) = cause.downcast_ref::<ErrorCode>() {
+            return err.clone();
+        }
+    }
+
+    tracing::warn!("hyper request error: {err:?}");
+
+    ErrorCode::HttpProtocolError
+}
+
+/// Translate a [`hyper::Error`] to a wasi-http `ErrorCode` in the context of a response.
+pub fn hyper_response_error(err: hyper::Error) -> ErrorCode {
+    if err.is_timeout() {
+        return ErrorCode::HttpResponseTimeout;
+    }
+
+    // If there's a source, we might be able to extract a wasi-http error from it.
+    if let Some(cause) = err.source() {
+        if let Some(err) = cause.downcast_ref::<ErrorCode>() {
+            return err.clone();
+        }
+    }
+
+    tracing::warn!("hyper response error: {err:?}");
+
+    ErrorCode::HttpProtocolError
+}
diff --git a/crates/wasi-http/src/http_impl.rs b/crates/wasi-http/src/http_impl.rs
index 2df2213134de..53f3bc33b2be 100644
--- a/crates/wasi-http/src/http_impl.rs
+++ b/crates/wasi-http/src/http_impl.rs
@@ -1,84 +1,83 @@
-use crate::bindings::http::{
-    outgoing_handler,
-    types::{RequestOptions, Scheme},
+//! Implementation of the `wasi:http/outgoing-handler` interface.
+
+use crate::{
+    bindings::http::{
+        outgoing_handler,
+        types::{self, Scheme},
+    },
+    error::internal_error,
+    http_request_error,
+    types::{HostFutureIncomingResponse, HostOutgoingRequest, OutgoingRequestConfig},
+    WasiHttpImpl, WasiHttpView,
 };
-use crate::types::{self, HostFutureIncomingResponse, IncomingResponseInternal};
-use crate::WasiHttpView;
-use anyhow::Context;
 use bytes::Bytes;
 use http_body_util::{BodyExt, Empty};
 use hyper::Method;
-use std::time::Duration;
-use tokio::net::TcpStream;
-use tokio::time::timeout;
-use types::HostOutgoingRequest;
 use wasmtime::component::Resource;
-use wasmtime_wasi::preview2;
 
-impl<T: WasiHttpView> outgoing_handler::Host for T {
+impl<T> outgoing_handler::Host for WasiHttpImpl<T>
+where
+    T: WasiHttpView,
+{
     fn handle(
         &mut self,
         request_id: Resource<HostOutgoingRequest>,
-        options: Option<RequestOptions>,
-    ) -> wasmtime::Result<Result<Resource<HostFutureIncomingResponse>, outgoing_handler::Error>>
-    {
-        let connect_timeout = Duration::from_millis(
-            options
-                .and_then(|opts| opts.connect_timeout_ms)
-                .unwrap_or(600 * 1000) as u64,
-        );
-
-        let first_byte_timeout = Duration::from_millis(
-            options
-                .and_then(|opts| opts.first_byte_timeout_ms)
-                .unwrap_or(600 * 1000) as u64,
-        );
-
-        let between_bytes_timeout = Duration::from_millis(
-            options
-                .and_then(|opts| opts.between_bytes_timeout_ms)
-                .unwrap_or(600 * 1000) as u64,
-        );
-
-        let req = self.table().delete_resource(request_id)?;
-
-        let method = match req.method {
-            crate::bindings::http::types::Method::Get => Method::GET,
-            crate::bindings::http::types::Method::Head => Method::HEAD,
-            crate::bindings::http::types::Method::Post => Method::POST,
-            crate::bindings::http::types::Method::Put => Method::PUT,
-            crate::bindings::http::types::Method::Delete => Method::DELETE,
-            crate::bindings::http::types::Method::Connect => Method::CONNECT,
-            crate::bindings::http::types::Method::Options => Method::OPTIONS,
-            crate::bindings::http::types::Method::Trace => Method::TRACE,
-            crate::bindings::http::types::Method::Patch => Method::PATCH,
-            crate::bindings::http::types::Method::Other(method) => {
-                return Ok(Err(outgoing_handler::Error::InvalidUrl(format!(
-                    "unknown method {method}"
-                ))));
-            }
-        };
+        options: Option<Resource<types::RequestOptions>>,
+    ) -> crate::HttpResult<Resource<HostFutureIncomingResponse>> {
+        let opts = options.and_then(|opts| self.table().get(&opts).ok());
+
+        let connect_timeout = opts
+            .and_then(|opts| opts.connect_timeout)
+            .unwrap_or(std::time::Duration::from_secs(600));
+
+        let first_byte_timeout = opts
+            .and_then(|opts| opts.first_byte_timeout)
+            .unwrap_or(std::time::Duration::from_secs(600));
+
+        let between_bytes_timeout = opts
+            .and_then(|opts| opts.between_bytes_timeout)
+            .unwrap_or(std::time::Duration::from_secs(600));
+
+        let req = self.table().delete(request_id)?;
+        let mut builder = hyper::Request::builder();
+
+        builder = builder.method(match req.method {
+            types::Method::Get => Method::GET,
+            types::Method::Head => Method::HEAD,
+            types::Method::Post => Method::POST,
+            types::Method::Put => Method::PUT,
+            types::Method::Delete => Method::DELETE,
+            types::Method::Connect => Method::CONNECT,
+            types::Method::Options => Method::OPTIONS,
+            types::Method::Trace => Method::TRACE,
+            types::Method::Patch => Method::PATCH,
+            types::Method::Other(m) => match hyper::Method::from_bytes(m.as_bytes()) {
+                Ok(method) => method,
+                Err(_) => return Err(types::ErrorCode::HttpRequestMethodInvalid.into()),
+            },
+        });
 
-        let (use_tls, scheme, port) = match req.scheme.unwrap_or(Scheme::Https) {
-            Scheme::Http => (false, "http://", 80),
-            Scheme::Https => (true, "https://", 443),
-            Scheme::Other(scheme) => {
-                return Ok(Err(outgoing_handler::Error::InvalidUrl(format!(
-                    "unsupported scheme {scheme}"
-                ))))
-            }
-        };
+        let (use_tls, scheme) = match req.scheme.unwrap_or(Scheme::Https) {
+            Scheme::Http => (false, http::uri::Scheme::HTTP),
+            Scheme::Https => (true, http::uri::Scheme::HTTPS),
 
-        let authority = if req.authority.find(':').is_some() {
-            req.authority.clone()
-        } else {
-            format!("{}:{port}", req.authority)
+            // We can only support http/https
+            Scheme::Other(_) => return Err(types::ErrorCode::HttpProtocolError.into()),
         };
 
-        let mut builder = hyper::Request::builder()
-            .method(method)
-            .uri(format!("{scheme}{authority}{}", req.path_with_query))
-            .header(hyper::header::HOST, &authority);
+        let authority = req.authority.unwrap_or_else(String::new);
+
+        builder = builder.header(hyper::header::HOST, &authority);
+
+        let mut uri = http::Uri::builder()
+            .scheme(scheme)
+            .authority(authority.clone());
+
+        if let Some(path) = req.path_with_query {
+            uri = uri.path_and_query(path);
+        }
+
+        builder = builder.uri(uri.build().map_err(http_request_error)?);
 
         for (k, v) in req.headers.iter() {
             builder = builder.header(k, v);
@@ -86,126 +85,24 @@ impl<T: WasiHttpView> outgoing_handler::Host for T {
 
         let body = req.body.unwrap_or_else(|| {
             Empty::<Bytes>::new()
-                .map_err(|_| anyhow::anyhow!("empty error"))
+                .map_err(|_| unreachable!("Infallible error"))
                 .boxed()
         });
 
-        let request = builder.body(body).map_err(http_protocol_error)?;
-
-        let handle = preview2::spawn(async move {
-            let tcp_stream = TcpStream::connect(authority.clone())
-                .await
-                .map_err(invalid_url)?;
-
-            let (mut sender, worker) = if use_tls {
-                #[cfg(any(target_arch = "riscv64", target_arch = "s390x"))]
-                {
-                    anyhow::bail!(crate::bindings::http::types::Error::UnexpectedError(
-                        "unsupported architecture for SSL".to_string(),
-                    ));
-                }
-
-                #[cfg(not(any(target_arch = "riscv64", target_arch = "s390x")))]
-                {
-                    use tokio_rustls::rustls::OwnedTrustAnchor;
-
-                    // derived from https://github.com/tokio-rs/tls/blob/master/tokio-rustls/examples/client/src/main.rs
-                    let mut root_cert_store = rustls::RootCertStore::empty();
-                    root_cert_store.add_trust_anchors(webpki_roots::TLS_SERVER_ROOTS.iter().map(
-                        |ta| {
-                            OwnedTrustAnchor::from_subject_spki_name_constraints(
-                                ta.subject,
-                                ta.spki,
-                                ta.name_constraints,
-                            )
-                        },
-                    ));
-                    let config = rustls::ClientConfig::builder()
-                        .with_safe_defaults()
-                        .with_root_certificates(root_cert_store)
-                        .with_no_client_auth();
-                    let connector = tokio_rustls::TlsConnector::from(std::sync::Arc::new(config));
-                    let mut parts = authority.split(":");
-                    let host = parts.next().unwrap_or(&authority);
-                    let domain = rustls::ServerName::try_from(host)?;
-                    let stream = connector.connect(domain, tcp_stream).await.map_err(|e| {
-                        crate::bindings::http::types::Error::ProtocolError(e.to_string())
-                    })?;
-
-                    let (sender, conn) = timeout(
-                        connect_timeout,
-                        hyper::client::conn::http1::handshake(stream),
-                    )
-                    .await
-                    .map_err(|_| timeout_error("connection"))??;
-
-                    let worker = preview2::spawn(async move {
-                        conn.await.context("hyper connection failed")?;
-                        Ok::<_, anyhow::Error>(())
-                    });
-
-                    (sender, worker)
-                }
-            } else {
-                let (sender, conn) = timeout(
-                    connect_timeout,
-                    // TODO: we should plumb the builder through the http context, and use it here
-                    hyper::client::conn::http1::handshake(tcp_stream),
-                )
-                .await
-                .map_err(|_| timeout_error("connection"))??;
-
-                let worker = preview2::spawn(async move {
-                    conn.await.context("hyper connection failed")?;
-                    Ok::<_, anyhow::Error>(())
-                });
-
-                (sender, worker)
-            };
-
-            let resp = timeout(first_byte_timeout, sender.send_request(request))
-                .await
-                .map_err(|_| timeout_error("first byte"))?
-                .map_err(hyper_protocol_error)?
-                .map(|body| body.map_err(|e| anyhow::anyhow!(e)).boxed());
-
-            Ok(IncomingResponseInternal {
-                resp,
-                worker,
-                between_bytes_timeout,
-            })
-        });
+        let request = builder
+            .body(body)
+            .map_err(|err| internal_error(err.to_string()))?;
 
-        let fut = self
-            .table()
-            .push_resource(HostFutureIncomingResponse::new(handle))?;
+        let future = self.send_request(
+            request,
+            OutgoingRequestConfig {
+                use_tls,
+                connect_timeout,
+                first_byte_timeout,
+                between_bytes_timeout,
+            },
+        )?;
 
-        Ok(Ok(fut))
+        Ok(self.table().push(future)?)
     }
 }
-
-fn timeout_error(kind: &str) -> anyhow::Error {
-    anyhow::anyhow!(crate::bindings::http::types::Error::TimeoutError(format!(
-        "{kind} timed out"
-    )))
-}
-
-fn http_protocol_error(e: http::Error) -> anyhow::Error {
-    anyhow::anyhow!(crate::bindings::http::types::Error::ProtocolError(
-        e.to_string()
-    ))
-}
-
-fn hyper_protocol_error(e: hyper::Error) -> anyhow::Error {
-    anyhow::anyhow!(crate::bindings::http::types::Error::ProtocolError(
-        e.to_string()
-    ))
-}
-
-fn invalid_url(e: std::io::Error) -> anyhow::Error {
-    // TODO: DNS errors show up as a Custom io error, what subset of errors should we consider for
-    // InvalidUrl here?
-    anyhow::anyhow!(crate::bindings::http::types::Error::InvalidUrl(
-        e.to_string()
-    ))
-}
diff --git a/crates/wasi-http/src/io.rs b/crates/wasi-http/src/io.rs
new file mode 100644
index 000000000000..962bd58f2eea
--- /dev/null
+++ b/crates/wasi-http/src/io.rs
@@ -0,0 +1,55 @@
+//! I/O utility for bridging between `tokio::io` and `hyper::rt`.
+
+use hyper::rt::{Read, ReadBufCursor, Write};
+use std::io::Error;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
+
+/// A type that wraps any type implementing [`tokio::io::AsyncRead`] and [`tokio::io::AsyncWrite`]
+/// and itself implements [`hyper::rt::Read`] and [`hyper::rt::Write`].
+#[derive(Debug)]
+pub struct TokioIo<T> {
+    inner: T,
+}
+
+impl<T> TokioIo<T> {
+    /// Create a new `TokioIo` wrapping the given inner type.
+    pub fn new(inner: T) -> TokioIo<T> {
+        TokioIo { inner }
+    }
+}
+
+impl<T: AsyncRead + Unpin> Read for TokioIo<T> {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        mut buf: ReadBufCursor<'_>,
+    ) -> Poll<Result<(), Error>> {
+        unsafe {
+            let mut dst = ReadBuf::uninit(buf.as_mut());
+            let res = Pin::new(&mut self.inner).poll_read(cx, &mut dst);
+            let amt = dst.filled().len();
+            buf.advance(amt);
+            res
+        }
+    }
+}
+
+impl<T: AsyncWrite + Unpin> Write for TokioIo<T> {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<Result<usize, Error>> {
+        Pin::new(&mut self.inner).poll_write(cx, buf)
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Error>> {
+        Pin::new(&mut self.inner).poll_flush(cx)
+    }
+
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Error>> {
+        Pin::new(&mut self.inner).poll_shutdown(cx)
+    }
+}
diff --git a/crates/wasi-http/src/lib.rs b/crates/wasi-http/src/lib.rs
index 2fac15be2ca2..7fb5a9a4cabd 100644
--- a/crates/wasi-http/src/lib.rs
+++ b/crates/wasi-http/src/lib.rs
@@ -1,105 +1,407 @@
-pub use crate::types::{WasiHttpCtx, WasiHttpView};
+//! # Wasmtime's WASI HTTP Implementation
+//!
+//! This crate is Wasmtime's host implementation of the `wasi:http` package as
+//! part of WASIp2. This crate's implementation is primarily built on top of
+//! [`hyper`] and [`tokio`].
+//!
+//! # WASI HTTP Interfaces
+//!
+//! This crate contains implementations of the following interfaces:
+//!
+//! * [`wasi:http/incoming-handler`]
+//! * [`wasi:http/outgoing-handler`]
+//! * [`wasi:http/types`]
+//!
+//! The crate also contains an implementation of the [`wasi:http/proxy`] world.
+//!
+//! [`wasi:http/proxy`]: crate::bindings::Proxy
+//! [`wasi:http/outgoing-handler`]: crate::bindings::http::outgoing_handler::Host
+//! [`wasi:http/types`]: crate::bindings::http::types::Host
+//! [`wasi:http/incoming-handler`]: crate::bindings::exports::wasi::http::incoming_handler::Guest
+//!
+//! This crate is very similar to [`wasmtime-wasi`] in the it uses the
+//! `bindgen!` macro in Wasmtime to generate bindings to interfaces. Bindings
+//! are located in the [`bindings`] module.
+//!
+//! # The `WasiHttpView` trait
+//!
+//! All `bindgen!`-generated `Host` traits are implemented in terms of a
+//! [`WasiHttpView`] trait which provides basic access to [`WasiHttpCtx`],
+//! configuration for WASI HTTP, and a [`wasmtime_wasi::ResourceTable`], the
+//! state for all host-defined component model resources.
+//!
+//! The [`WasiHttpView`] trait additionally offers a few other configuration
+//! methods such as [`WasiHttpView::send_request`] to customize how outgoing
+//! HTTP requests are handled.
+//!
+//! # Async and Sync
+//!
+//! There are both asynchronous and synchronous bindings in this crate. For
+//! example [`add_to_linker_async`] is for asynchronous embedders and
+//! [`add_to_linker_sync`] is for synchronous embedders. Note that under the
+//! hood both versions are implemented with `async` on top of [`tokio`].
+//!
+//! # Examples
+//!
+//! Usage of this crate is done through a few steps to get everything hooked up:
+//!
+//! 1. First implement [`WasiHttpView`] for your type which is the `T` in
+//!    [`wasmtime::Store<T>`].
+//! 2. Add WASI HTTP interfaces to a [`wasmtime::component::Linker<T>`]. There
+//!    are a few options of how to do this:
+//!    * Use [`add_to_linker_async`] to bundle all interfaces in
+//!      `wasi:http/proxy` together
+//!    * Use [`add_only_http_to_linker_async`] to add only HTTP interfaces but
+//!      no others. This is useful when working with
+//!      [`wasmtime_wasi::add_to_linker_async`] for example.
+//!    * Add individual interfaces such as with the
+//!      [`bindings::http::outgoing_handler::add_to_linker_get_host`] function.
+//! 3. Use [`ProxyPre`](bindings::ProxyPre) to pre-instantiate a component
+//!    before serving requests.
+//! 4. When serving requests use
+//!    [`ProxyPre::instantiate_async`](bindings::ProxyPre::instantiate_async)
+//!    to create instances and handle HTTP requests.
+//!
+//! A standalone example of doing all this looks like:
+//!
+//! ```no_run
+//! use anyhow::bail;
+//! use hyper::server::conn::http1;
+//! use std::sync::Arc;
+//! use tokio::net::TcpListener;
+//! use wasmtime::component::{Component, Linker, ResourceTable};
+//! use wasmtime::{Config, Engine, Result, Store};
+//! use wasmtime_wasi::{WasiCtx, WasiCtxBuilder, WasiView};
+//! use wasmtime_wasi_http::bindings::ProxyPre;
+//! use wasmtime_wasi_http::bindings::http::types::Scheme;
+//! use wasmtime_wasi_http::body::HyperOutgoingBody;
+//! use wasmtime_wasi_http::io::TokioIo;
+//! use wasmtime_wasi_http::{WasiHttpCtx, WasiHttpView};
+//!
+//! #[tokio::main]
+//! async fn main() -> Result<()> {
+//!     let component = std::env::args().nth(1).unwrap();
+//!
+//!     // Prepare the `Engine` for Wasmtime
+//!     let mut config = Config::new();
+//!     config.async_support(true);
+//!     let engine = Engine::new(&config)?;
+//!
+//!     // Compile the component on the command line to machine code
+//!     let component = Component::from_file(&engine, &component)?;
+//!
+//!     // Prepare the `ProxyPre` which is a pre-instantiated version of the
+//!     // component that we have. This will make per-request instantiation
+//!     // much quicker.
+//!     let mut linker = Linker::new(&engine);
+//!     wasmtime_wasi_http::add_to_linker_async(&mut linker)?;
+//!     let pre = ProxyPre::new(linker.instantiate_pre(&component)?)?;
+//!
+//!     // Prepare our server state and start listening for connections.
+//!     let server = Arc::new(MyServer { pre });
+//!     let listener = TcpListener::bind("127.0.0.1:8000").await?;
+//!     println!("Listening on {}", listener.local_addr()?);
+//!
+//!     loop {
+//!         // Accept a TCP connection and serve all of its requests in a separate
+//!         // tokio task. Note that for now this only works with HTTP/1.1.
+//!         let (client, addr) = listener.accept().await?;
+//!         println!("serving new client from {addr}");
+//!
+//!         let server = server.clone();
+//!         tokio::task::spawn(async move {
+//!             if let Err(e) = http1::Builder::new()
+//!                 .keep_alive(true)
+//!                 .serve_connection(
+//!                     TokioIo::new(client),
+//!                     hyper::service::service_fn(move |req| {
+//!                         let server = server.clone();
+//!                         async move { server.handle_request(req).await }
+//!                     }),
+//!                 )
+//!                 .await
+//!             {
+//!                 eprintln!("error serving client[{addr}]: {e:?}");
+//!             }
+//!         });
+//!     }
+//! }
+//!
+//! struct MyServer {
+//!     pre: ProxyPre<MyClientState>,
+//! }
+//!
+//! impl MyServer {
+//!     async fn handle_request(
+//!         &self,
+//!         req: hyper::Request<hyper::body::Incoming>,
+//!     ) -> Result<hyper::Response<HyperOutgoingBody>> {
+//!         // Create per-http-request state within a `Store` and prepare the
+//!         // initial resources  passed to the `handle` function.
+//!         let mut store = Store::new(
+//!             self.pre.engine(),
+//!             MyClientState {
+//!                 table: ResourceTable::new(),
+//!                 wasi: WasiCtxBuilder::new().inherit_stdio().build(),
+//!                 http: WasiHttpCtx::new(),
+//!             },
+//!         );
+//!         let (sender, receiver) = tokio::sync::oneshot::channel();
+//!         let req = store.data_mut().new_incoming_request(Scheme::Http, req)?;
+//!         let out = store.data_mut().new_response_outparam(sender)?;
+//!         let pre = self.pre.clone();
+//!
+//!         // Run the http request itself in a separate task so the task can
+//!         // optionally continue to execute beyond after the initial
+//!         // headers/response code are sent.
+//!         let task = tokio::task::spawn(async move {
+//!             let proxy = pre.instantiate_async(&mut store).await?;
+//!
+//!             if let Err(e) = proxy
+//!                 .wasi_http_incoming_handler()
+//!                 .call_handle(store, req, out)
+//!                 .await
+//!             {
+//!                 return Err(e);
+//!             }
+//!
+//!             Ok(())
+//!         });
+//!
+//!         match receiver.await {
+//!             // If the client calls `response-outparam::set` then one of these
+//!             // methods will be called.
+//!             Ok(Ok(resp)) => Ok(resp),
+//!             Ok(Err(e)) => Err(e.into()),
+//!
+//!             // Otherwise the `sender` will get dropped along with the `Store`
+//!             // meaning that the oneshot will get disconnected and here we can
+//!             // inspect the `task` result to see what happened
+//!             Err(_) => {
+//!                 let e = match task.await {
+//!                     Ok(r) => r.unwrap_err(),
+//!                     Err(e) => e.into(),
+//!                 };
+//!                 bail!("guest never invoked `response-outparam::set` method: {e:?}")
+//!             }
+//!         }
+//!     }
+//! }
+//!
+//! struct MyClientState {
+//!     wasi: WasiCtx,
+//!     http: WasiHttpCtx,
+//!     table: ResourceTable,
+//! }
+//!
+//! impl WasiView for MyClientState {
+//!     fn ctx(&mut self) -> &mut WasiCtx {
+//!         &mut self.wasi
+//!     }
+//!     fn table(&mut self) -> &mut ResourceTable {
+//!         &mut self.table
+//!     }
+//! }
+//!
+//! impl WasiHttpView for MyClientState {
+//!     fn ctx(&mut self) -> &mut WasiHttpCtx {
+//!         &mut self.http
+//!     }
+//!     fn table(&mut self) -> &mut ResourceTable {
+//!         &mut self.table
+//!     }
+//! }
+//! ```
+
+#![deny(missing_docs)]
+#![doc(test(attr(deny(warnings))))]
+#![doc(test(attr(allow(dead_code, unused_variables, unused_mut))))]
+
+mod error;
+mod http_impl;
+mod types_impl;
 
 pub mod body;
-pub mod http_impl;
-pub mod proxy;
+pub mod io;
 pub mod types;
-pub mod types_impl;
-
-pub mod bindings {
-    wasmtime::component::bindgen!({
-        path: "wit",
-        interfaces: "
-                import wasi:http/incoming-handler
-                import wasi:http/outgoing-handler
-                import wasi:http/types
-            ",
-        tracing: true,
-        async: false,
-        with: {
-            "wasi:io/streams": wasmtime_wasi::preview2::bindings::io::streams,
-            "wasi:io/poll": wasmtime_wasi::preview2::bindings::io::poll,
-
-            "wasi:http/types/outgoing-body": super::body::HostOutgoingBody,
-            "wasi:http/types/future-incoming-response": super::types::HostFutureIncomingResponse,
-            "wasi:http/types/outgoing-response": super::types::HostOutgoingResponse,
-            "wasi:http/types/future-trailers": super::body::HostFutureTrailers,
-            "wasi:http/types/incoming-body": super::body::HostIncomingBody,
-            "wasi:http/types/incoming-response": super::types::HostIncomingResponse,
-            "wasi:http/types/response-outparam": super::types::HostResponseOutparam,
-            "wasi:http/types/outgoing-request": super::types::HostOutgoingRequest,
-            "wasi:http/types/incoming-request": super::types::HostIncomingRequest,
-            "wasi:http/types/fields": super::types::HostFields,
-        }
-    });
-
-    pub use wasi::http;
-}
 
-impl From<wasmtime_wasi::preview2::TableError> for crate::bindings::http::types::Error {
-    fn from(err: wasmtime_wasi::preview2::TableError) -> Self {
-        Self::UnexpectedError(err.to_string())
-    }
-}
+pub mod bindings;
 
-impl From<anyhow::Error> for crate::bindings::http::types::Error {
-    fn from(err: anyhow::Error) -> Self {
-        Self::UnexpectedError(err.to_string())
-    }
-}
+pub use crate::error::{
+    http_request_error, hyper_request_error, hyper_response_error, HttpError, HttpResult,
+};
+#[doc(inline)]
+pub use crate::types::{WasiHttpCtx, WasiHttpImpl, WasiHttpView};
+
+/// Add all of the `wasi:http/proxy` world's interfaces to a [`wasmtime::component::Linker`].
+///
+/// This function will add the `async` variant of all interfaces into the
+/// `Linker` provided. By `async` this means that this function is only
+/// compatible with [`Config::async_support(true)`][async]. For embeddings with
+/// async support disabled see [`add_to_linker_sync`] instead.
+///
+/// [async]: wasmtime::Config::async_support
+///
+/// # Example
+///
+/// ```
+/// use wasmtime::{Engine, Result, Config};
+/// use wasmtime::component::{ResourceTable, Linker};
+/// use wasmtime_wasi::{WasiCtx, WasiView};
+/// use wasmtime_wasi_http::{WasiHttpCtx, WasiHttpView};
+///
+/// fn main() -> Result<()> {
+///     let mut config = Config::new();
+///     config.async_support(true);
+///     let engine = Engine::new(&config)?;
+///
+///     let mut linker = Linker::<MyState>::new(&engine);
+///     wasmtime_wasi_http::add_to_linker_async(&mut linker)?;
+///     // ... add any further functionality to `linker` if desired ...
+///
+///     Ok(())
+/// }
+///
+/// struct MyState {
+///     ctx: WasiCtx,
+///     http_ctx: WasiHttpCtx,
+///     table: ResourceTable,
+/// }
+///
+/// impl WasiHttpView for MyState {
+///     fn ctx(&mut self) -> &mut WasiHttpCtx { &mut self.http_ctx }
+///     fn table(&mut self) -> &mut ResourceTable { &mut self.table }
+/// }
+/// impl WasiView for MyState {
+///     fn ctx(&mut self) -> &mut WasiCtx { &mut self.ctx }
+///     fn table(&mut self) -> &mut ResourceTable { &mut self.table }
+/// }
+/// ```
+pub fn add_to_linker_async<T>(l: &mut wasmtime::component::Linker<T>) -> anyhow::Result<()>
+where
+    T: WasiHttpView + wasmtime_wasi::WasiView,
+{
+    let closure = type_annotate_wasi::<T, _>(|t| wasmtime_wasi::WasiImpl(t));
+    wasmtime_wasi::bindings::clocks::wall_clock::add_to_linker_get_host(l, closure)?;
+    wasmtime_wasi::bindings::clocks::monotonic_clock::add_to_linker_get_host(l, closure)?;
+    wasmtime_wasi::bindings::io::poll::add_to_linker_get_host(l, closure)?;
+    wasmtime_wasi::bindings::io::error::add_to_linker_get_host(l, closure)?;
+    wasmtime_wasi::bindings::io::streams::add_to_linker_get_host(l, closure)?;
+    wasmtime_wasi::bindings::cli::stdin::add_to_linker_get_host(l, closure)?;
+    wasmtime_wasi::bindings::cli::stdout::add_to_linker_get_host(l, closure)?;
+    wasmtime_wasi::bindings::cli::stderr::add_to_linker_get_host(l, closure)?;
+    wasmtime_wasi::bindings::random::random::add_to_linker_get_host(l, closure)?;
 
-impl From<std::io::Error> for crate::bindings::http::types::Error {
-    fn from(err: std::io::Error) -> Self {
-        let message = err.to_string();
-        match err.kind() {
-            std::io::ErrorKind::InvalidInput => Self::InvalidUrl(message),
-            std::io::ErrorKind::AddrNotAvailable => Self::InvalidUrl(message),
-            _ => {
-                if message.starts_with("failed to lookup address information") {
-                    Self::InvalidUrl("invalid dnsname".to_string())
-                } else {
-                    Self::ProtocolError(message)
-                }
-            }
-        }
-    }
+    add_only_http_to_linker_async(l)
 }
 
-impl From<http::Error> for crate::bindings::http::types::Error {
-    fn from(err: http::Error) -> Self {
-        Self::InvalidUrl(err.to_string())
-    }
+// NB: workaround some rustc inference - a future refactoring may make this
+// obsolete.
+fn type_annotate_http<T, F>(val: F) -> F
+where
+    F: Fn(&mut T) -> WasiHttpImpl<&mut T>,
+{
+    val
+}
+fn type_annotate_wasi<T, F>(val: F) -> F
+where
+    F: Fn(&mut T) -> wasmtime_wasi::WasiImpl<&mut T>,
+{
+    val
 }
 
-impl From<hyper::Error> for crate::bindings::http::types::Error {
-    fn from(err: hyper::Error) -> Self {
-        let message = err.message().to_string();
-        if err.is_timeout() {
-            Self::TimeoutError(message)
-        } else if err.is_parse_status() || err.is_user() {
-            Self::InvalidUrl(message)
-        } else if err.is_body_write_aborted()
-            || err.is_canceled()
-            || err.is_closed()
-            || err.is_incomplete_message()
-            || err.is_parse()
-        {
-            Self::ProtocolError(message)
-        } else {
-            Self::UnexpectedError(message)
-        }
-    }
+/// A slimmed down version of [`add_to_linker_async`] which only adds
+/// `wasi:http` interfaces to the linker.
+///
+/// This is useful when using [`wasmtime_wasi::add_to_linker_async`] for
+/// example to avoid re-adding the same interfaces twice.
+pub fn add_only_http_to_linker_async<T>(
+    l: &mut wasmtime::component::Linker<T>,
+) -> anyhow::Result<()>
+where
+    T: WasiHttpView,
+{
+    let closure = type_annotate_http::<T, _>(|t| WasiHttpImpl(t));
+    crate::bindings::http::outgoing_handler::add_to_linker_get_host(l, closure)?;
+    crate::bindings::http::types::add_to_linker_get_host(l, closure)?;
+
+    Ok(())
 }
 
-impl From<tokio::time::error::Elapsed> for crate::bindings::http::types::Error {
-    fn from(err: tokio::time::error::Elapsed) -> Self {
-        Self::TimeoutError(err.to_string())
-    }
+/// Add all of the `wasi:http/proxy` world's interfaces to a [`wasmtime::component::Linker`].
+///
+/// This function will add the `sync` variant of all interfaces into the
+/// `Linker` provided. For embeddings with async support see
+/// [`add_to_linker_async`] instead.
+///
+/// # Example
+///
+/// ```
+/// use wasmtime::{Engine, Result, Config};
+/// use wasmtime::component::{ResourceTable, Linker};
+/// use wasmtime_wasi::{WasiCtx, WasiView};
+/// use wasmtime_wasi_http::{WasiHttpCtx, WasiHttpView};
+///
+/// fn main() -> Result<()> {
+///     let config = Config::default();
+///     let engine = Engine::new(&config)?;
+///
+///     let mut linker = Linker::<MyState>::new(&engine);
+///     wasmtime_wasi_http::add_to_linker_sync(&mut linker)?;
+///     // ... add any further functionality to `linker` if desired ...
+///
+///     Ok(())
+/// }
+///
+/// struct MyState {
+///     ctx: WasiCtx,
+///     http_ctx: WasiHttpCtx,
+///     table: ResourceTable,
+/// }
+///
+/// impl WasiHttpView for MyState {
+///     fn ctx(&mut self) -> &mut WasiHttpCtx { &mut self.http_ctx }
+///     fn table(&mut self) -> &mut ResourceTable { &mut self.table }
+/// }
+/// impl WasiView for MyState {
+///     fn ctx(&mut self) -> &mut WasiCtx { &mut self.ctx }
+///     fn table(&mut self) -> &mut ResourceTable { &mut self.table }
+/// }
+/// ```
+pub fn add_to_linker_sync<T>(l: &mut wasmtime::component::Linker<T>) -> anyhow::Result<()>
+where
+    T: WasiHttpView + wasmtime_wasi::WasiView,
+{
+    let closure = type_annotate_wasi::<T, _>(|t| wasmtime_wasi::WasiImpl(t));
+
+    wasmtime_wasi::bindings::clocks::wall_clock::add_to_linker_get_host(l, closure)?;
+    wasmtime_wasi::bindings::clocks::monotonic_clock::add_to_linker_get_host(l, closure)?;
+    wasmtime_wasi::bindings::sync::io::poll::add_to_linker_get_host(l, closure)?;
+    wasmtime_wasi::bindings::sync::io::streams::add_to_linker_get_host(l, closure)?;
+    wasmtime_wasi::bindings::io::error::add_to_linker_get_host(l, closure)?;
+    wasmtime_wasi::bindings::cli::stdin::add_to_linker_get_host(l, closure)?;
+    wasmtime_wasi::bindings::cli::stdout::add_to_linker_get_host(l, closure)?;
+    wasmtime_wasi::bindings::cli::stderr::add_to_linker_get_host(l, closure)?;
+    wasmtime_wasi::bindings::random::random::add_to_linker_get_host(l, closure)?;
+
+    add_only_http_to_linker_sync(l)?;
+
+    Ok(())
 }
 
-#[cfg(not(any(target_arch = "riscv64", target_arch = "s390x")))]
-impl From<rustls::client::InvalidDnsNameError> for crate::bindings::http::types::Error {
-    fn from(_err: rustls::client::InvalidDnsNameError) -> Self {
-        Self::InvalidUrl("invalid dnsname".to_string())
-    }
+/// A slimmed down version of [`add_to_linker_sync`] which only adds
+/// `wasi:http` interfaces to the linker.
+///
+/// This is useful when using [`wasmtime_wasi::add_to_linker_sync`] for
+/// example to avoid re-adding the same interfaces twice.
+pub fn add_only_http_to_linker_sync<T>(l: &mut wasmtime::component::Linker<T>) -> anyhow::Result<()>
+where
+    T: WasiHttpView,
+{
+    let closure = type_annotate_http::<T, _>(|t| WasiHttpImpl(t));
+
+    crate::bindings::http::outgoing_handler::add_to_linker_get_host(l, closure)?;
+    crate::bindings::http::types::add_to_linker_get_host(l, closure)?;
+
+    Ok(())
 }
diff --git a/crates/wasi-http/src/proxy.rs b/crates/wasi-http/src/proxy.rs
deleted file mode 100644
index 1a7bca511c29..000000000000
--- a/crates/wasi-http/src/proxy.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-use crate::{bindings, WasiHttpView};
-use wasmtime_wasi::preview2;
-
-wasmtime::component::bindgen!({
-    world: "wasi:http/proxy",
-    tracing: true,
-    async: true,
-    with: {
-        "wasi:cli/stderr": preview2::bindings::cli::stderr,
-        "wasi:cli/stdin": preview2::bindings::cli::stdin,
-        "wasi:cli/stdout": preview2::bindings::cli::stdout,
-        "wasi:clocks/monotonic-clock": preview2::bindings::clocks::monotonic_clock,
-        "wasi:clocks/timezone": preview2::bindings::clocks::timezone,
-        "wasi:clocks/wall-clock": preview2::bindings::clocks::wall_clock,
-        "wasi:http/incoming-handler": bindings::http::incoming_handler,
-        "wasi:http/outgoing-handler": bindings::http::outgoing_handler,
-        "wasi:http/types": bindings::http::types,
-        "wasi:io/streams": preview2::bindings::io::streams,
-        "wasi:io/poll": preview2::bindings::io::poll,
-        "wasi:random/random": preview2::bindings::random::random,
-    },
-});
-
-pub fn add_to_linker<T>(l: &mut wasmtime::component::Linker<T>) -> anyhow::Result<()>
-where
-    T: WasiHttpView + preview2::WasiView + bindings::http::types::Host,
-{
-    // TODO: this shouldn't be required, but the adapter unconditionally pulls in all of these
-    // dependencies.
-    preview2::command::add_to_linker(l)?;
-
-    bindings::http::outgoing_handler::add_to_linker(l, |t| t)?;
-    bindings::http::types::add_to_linker(l, |t| t)?;
-
-    Ok(())
-}
-
-pub mod sync {
-    use crate::{bindings, WasiHttpView};
-    use wasmtime_wasi::preview2;
-
-    wasmtime::component::bindgen!({
-        world: "wasi:http/proxy",
-        tracing: true,
-        async: false,
-        with: {
-            "wasi:cli/stderr": preview2::bindings::cli::stderr,
-            "wasi:cli/stdin": preview2::bindings::cli::stdin,
-            "wasi:cli/stdout": preview2::bindings::cli::stdout,
-            "wasi:clocks/monotonic-clock": preview2::bindings::clocks::monotonic_clock,
-            "wasi:clocks/timezone": preview2::bindings::clocks::timezone,
-            "wasi:clocks/wall-clock": preview2::bindings::clocks::wall_clock,
-            "wasi:http/incoming-handler": bindings::http::incoming_handler,
-            "wasi:http/outgoing-handler": bindings::http::outgoing_handler,
-            "wasi:http/types": bindings::http::types,
-            "wasi:io/streams": preview2::bindings::io::streams,
-            "wasi:poll/poll": preview2::bindings::poll::poll,
-            "wasi:random/random": preview2::bindings::random::random,
-        },
-    });
-
-    pub fn add_to_linker<T>(l: &mut wasmtime::component::Linker<T>) -> anyhow::Result<()>
-    where
-        T: WasiHttpView + preview2::WasiView + bindings::http::types::Host,
-    {
-        // TODO: this shouldn't be required, but the adapter unconditionally pulls in all of these
-        // dependencies.
-        preview2::command::sync::add_to_linker(l)?;
-
-        bindings::http::outgoing_handler::add_to_linker(l, |t| t)?;
-        bindings::http::types::add_to_linker(l, |t| t)?;
-
-        Ok(())
-    }
-}
diff --git a/crates/wasi-http/src/types.rs b/crates/wasi-http/src/types.rs
index 308b65283cb3..4821e65c2ee7 100644
--- a/crates/wasi-http/src/types.rs
+++ b/crates/wasi-http/src/types.rs
@@ -1,79 +1,541 @@
 //! Implements the base structure (i.e. [WasiHttpCtx]) that will provide the
 //! implementation of the wasi-http API.
 
+use crate::io::TokioIo;
 use crate::{
     bindings::http::types::{self, Method, Scheme},
-    body::{HostIncomingBodyBuilder, HyperIncomingBody, HyperOutgoingBody},
+    body::{HostIncomingBody, HyperIncomingBody, HyperOutgoingBody},
+    error::dns_error,
+    hyper_request_error,
 };
+use anyhow::bail;
+use bytes::Bytes;
+use http_body_util::BodyExt;
+use hyper::body::Body;
+use hyper::header::HeaderName;
 use std::any::Any;
-use wasmtime::component::Resource;
-use wasmtime_wasi::preview2::{AbortOnDropJoinHandle, Subscribe, Table};
+use std::time::Duration;
+use tokio::net::TcpStream;
+use tokio::time::timeout;
+use wasmtime::component::{Resource, ResourceTable};
+use wasmtime_wasi::{runtime::AbortOnDropJoinHandle, Subscribe};
 
 /// Capture the state necessary for use in the wasi-http API implementation.
-pub struct WasiHttpCtx;
+#[derive(Debug)]
+pub struct WasiHttpCtx {
+    _priv: (),
+}
 
+impl WasiHttpCtx {
+    /// Create a new context.
+    pub fn new() -> Self {
+        Self { _priv: () }
+    }
+}
+
+/// A trait which provides internal WASI HTTP state.
+///
+/// # Example
+///
+/// ```
+/// use wasmtime::component::ResourceTable;
+/// use wasmtime_wasi::{WasiCtx, WasiView, WasiCtxBuilder};
+/// use wasmtime_wasi_http::{WasiHttpCtx, WasiHttpView};
+///
+/// struct MyState {
+///     ctx: WasiCtx,
+///     http_ctx: WasiHttpCtx,
+///     table: ResourceTable,
+/// }
+///
+/// impl WasiHttpView for MyState {
+///     fn ctx(&mut self) -> &mut WasiHttpCtx { &mut self.http_ctx }
+///     fn table(&mut self) -> &mut ResourceTable { &mut self.table }
+/// }
+///
+/// impl WasiView for MyState {
+///     fn ctx(&mut self) -> &mut WasiCtx { &mut self.ctx }
+///     fn table(&mut self) -> &mut ResourceTable { &mut self.table }
+/// }
+///
+/// impl MyState {
+///     fn new() -> MyState {
+///         let mut wasi = WasiCtxBuilder::new();
+///         wasi.arg("./foo.wasm");
+///         wasi.arg("--help");
+///         wasi.env("FOO", "bar");
+///
+///         MyState {
+///             ctx: wasi.build(),
+///             table: ResourceTable::new(),
+///             http_ctx: WasiHttpCtx::new(),
+///         }
+///     }
+/// }
+/// ```
 pub trait WasiHttpView: Send {
+    /// Returns a mutable reference to the WASI HTTP context.
     fn ctx(&mut self) -> &mut WasiHttpCtx;
-    fn table(&mut self) -> &mut Table;
 
-    fn new_incoming_request(
+    /// Returns a mutable reference to the WASI HTTP resource table.
+    fn table(&mut self) -> &mut ResourceTable;
+
+    /// Create a new incoming request resource.
+    fn new_incoming_request<B>(
         &mut self,
-        req: hyper::Request<HyperIncomingBody>,
-    ) -> wasmtime::Result<Resource<HostIncomingRequest>> {
+        scheme: Scheme,
+        req: hyper::Request<B>,
+    ) -> wasmtime::Result<Resource<HostIncomingRequest>>
+    where
+        B: Body<Data = Bytes, Error = hyper::Error> + Send + Sync + 'static,
+        Self: Sized,
+    {
         let (parts, body) = req.into_parts();
-        let body = HostIncomingBodyBuilder {
+        let body = body.map_err(crate::hyper_response_error).boxed();
+        let body = HostIncomingBody::new(
             body,
             // TODO: this needs to be plumbed through
-            between_bytes_timeout: std::time::Duration::from_millis(600 * 1000),
-        };
-        Ok(self.table().push_resource(HostIncomingRequest {
-            parts,
-            body: Some(body),
-        })?)
+            std::time::Duration::from_millis(600 * 1000),
+        );
+        let incoming_req = HostIncomingRequest::new(self, parts, scheme, Some(body))?;
+        Ok(self.table().push(incoming_req)?)
     }
 
+    /// Create a new outgoing response resource.
     fn new_response_outparam(
         &mut self,
         result: tokio::sync::oneshot::Sender<
-            Result<hyper::Response<HyperOutgoingBody>, types::Error>,
+            Result<hyper::Response<HyperOutgoingBody>, types::ErrorCode>,
         >,
     ) -> wasmtime::Result<Resource<HostResponseOutparam>> {
-        let id = self
-            .table()
-            .push_resource(HostResponseOutparam { result })?;
+        let id = self.table().push(HostResponseOutparam { result })?;
         Ok(id)
     }
+
+    /// Send an outgoing request.
+    fn send_request(
+        &mut self,
+        request: hyper::Request<HyperOutgoingBody>,
+        config: OutgoingRequestConfig,
+    ) -> crate::HttpResult<HostFutureIncomingResponse> {
+        Ok(default_send_request(request, config))
+    }
+
+    /// Whether a given header should be considered forbidden and not allowed.
+    fn is_forbidden_header(&mut self, _name: &HeaderName) -> bool {
+        false
+    }
 }
 
-pub struct HostIncomingRequest {
-    pub parts: http::request::Parts,
-    pub body: Option<HostIncomingBodyBuilder>,
+impl<T: ?Sized + WasiHttpView> WasiHttpView for &mut T {
+    fn ctx(&mut self) -> &mut WasiHttpCtx {
+        T::ctx(self)
+    }
+
+    fn table(&mut self) -> &mut ResourceTable {
+        T::table(self)
+    }
+
+    fn new_response_outparam(
+        &mut self,
+        result: tokio::sync::oneshot::Sender<
+            Result<hyper::Response<HyperOutgoingBody>, types::ErrorCode>,
+        >,
+    ) -> wasmtime::Result<Resource<HostResponseOutparam>> {
+        T::new_response_outparam(self, result)
+    }
+
+    fn send_request(
+        &mut self,
+        request: hyper::Request<HyperOutgoingBody>,
+        config: OutgoingRequestConfig,
+    ) -> crate::HttpResult<HostFutureIncomingResponse> {
+        T::send_request(self, request, config)
+    }
+
+    fn is_forbidden_header(&mut self, name: &HeaderName) -> bool {
+        T::is_forbidden_header(self, name)
+    }
 }
 
-pub struct HostResponseOutparam {
-    pub result:
-        tokio::sync::oneshot::Sender<Result<hyper::Response<HyperOutgoingBody>, types::Error>>,
+impl<T: ?Sized + WasiHttpView> WasiHttpView for Box<T> {
+    fn ctx(&mut self) -> &mut WasiHttpCtx {
+        T::ctx(self)
+    }
+
+    fn table(&mut self) -> &mut ResourceTable {
+        T::table(self)
+    }
+
+    fn new_response_outparam(
+        &mut self,
+        result: tokio::sync::oneshot::Sender<
+            Result<hyper::Response<HyperOutgoingBody>, types::ErrorCode>,
+        >,
+    ) -> wasmtime::Result<Resource<HostResponseOutparam>> {
+        T::new_response_outparam(self, result)
+    }
+
+    fn send_request(
+        &mut self,
+        request: hyper::Request<HyperOutgoingBody>,
+        config: OutgoingRequestConfig,
+    ) -> crate::HttpResult<HostFutureIncomingResponse> {
+        T::send_request(self, request, config)
+    }
+
+    fn is_forbidden_header(&mut self, name: &HeaderName) -> bool {
+        T::is_forbidden_header(self, name)
+    }
 }
 
-pub struct HostOutgoingRequest {
-    pub method: Method,
-    pub scheme: Option<Scheme>,
-    pub path_with_query: String,
-    pub authority: String,
-    pub headers: FieldMap,
-    pub body: Option<HyperOutgoingBody>,
+/// A concrete structure that all generated `Host` traits are implemented for.
+///
+/// This type serves as a small newtype wrapper to implement all of the `Host`
+/// traits for `wasi:http`. This type is internally used and is only needed if
+/// you're interacting with `add_to_linker` functions generated by bindings
+/// themselves (or `add_to_linker_get_host`).
+///
+/// This type is automatically used when using
+/// [`add_to_linker_async`](crate::add_to_linker_async)
+/// or
+/// [`add_to_linker_sync`](crate::add_to_linker_sync)
+/// and doesn't need to be manually configured.
+#[repr(transparent)]
+pub struct WasiHttpImpl<T>(pub T);
+
+impl<T: WasiHttpView> WasiHttpView for WasiHttpImpl<T> {
+    fn ctx(&mut self) -> &mut WasiHttpCtx {
+        self.0.ctx()
+    }
+
+    fn table(&mut self) -> &mut ResourceTable {
+        self.0.table()
+    }
+
+    fn new_response_outparam(
+        &mut self,
+        result: tokio::sync::oneshot::Sender<
+            Result<hyper::Response<HyperOutgoingBody>, types::ErrorCode>,
+        >,
+    ) -> wasmtime::Result<Resource<HostResponseOutparam>> {
+        self.0.new_response_outparam(result)
+    }
+
+    fn send_request(
+        &mut self,
+        request: hyper::Request<HyperOutgoingBody>,
+        config: OutgoingRequestConfig,
+    ) -> crate::HttpResult<HostFutureIncomingResponse> {
+        self.0.send_request(request, config)
+    }
+
+    fn is_forbidden_header(&mut self, name: &HeaderName) -> bool {
+        self.0.is_forbidden_header(name)
+    }
 }
 
-pub struct HostIncomingResponse {
-    pub status: u16,
-    pub headers: FieldMap,
-    pub body: Option<HostIncomingBodyBuilder>,
-    pub worker: AbortOnDropJoinHandle<anyhow::Result<()>>,
+/// Returns `true` when the header is forbidden according to this [`WasiHttpView`] implementation.
+pub(crate) fn is_forbidden_header(view: &mut dyn WasiHttpView, name: &HeaderName) -> bool {
+    static FORBIDDEN_HEADERS: [HeaderName; 10] = [
+        hyper::header::CONNECTION,
+        HeaderName::from_static("keep-alive"),
+        hyper::header::PROXY_AUTHENTICATE,
+        hyper::header::PROXY_AUTHORIZATION,
+        HeaderName::from_static("proxy-connection"),
+        hyper::header::TE,
+        hyper::header::TRANSFER_ENCODING,
+        hyper::header::UPGRADE,
+        hyper::header::HOST,
+        HeaderName::from_static("http2-settings"),
+    ];
+
+    FORBIDDEN_HEADERS.contains(name) || view.is_forbidden_header(name)
+}
+
+/// Removes forbidden headers from a [`hyper::HeaderMap`].
+pub(crate) fn remove_forbidden_headers(
+    view: &mut dyn WasiHttpView,
+    headers: &mut hyper::HeaderMap,
+) {
+    let forbidden_keys = Vec::from_iter(headers.keys().filter_map(|name| {
+        if is_forbidden_header(view, name) {
+            Some(name.clone())
+        } else {
+            None
+        }
+    }));
+
+    for name in forbidden_keys {
+        headers.remove(name);
+    }
+}
+
+/// Configuration for an outgoing request.
+pub struct OutgoingRequestConfig {
+    /// Whether to use TLS for the request.
+    pub use_tls: bool,
+    /// The timeout for connecting.
+    pub connect_timeout: Duration,
+    /// The timeout until the first byte.
+    pub first_byte_timeout: Duration,
+    /// The timeout between chunks of a streaming body
+    pub between_bytes_timeout: Duration,
+}
+
+/// The default implementation of how an outgoing request is sent.
+///
+/// This implementation is used by the `wasi:http/outgoing-handler` interface
+/// default implementation.
+pub fn default_send_request(
+    request: hyper::Request<HyperOutgoingBody>,
+    config: OutgoingRequestConfig,
+) -> HostFutureIncomingResponse {
+    let handle = wasmtime_wasi::runtime::spawn(async move {
+        Ok(default_send_request_handler(request, config).await)
+    });
+    HostFutureIncomingResponse::pending(handle)
+}
+
+/// The underlying implementation of how an outgoing request is sent. This should likely be spawned
+/// in a task.
+///
+/// This is called from [default_send_request] to actually send the request.
+pub async fn default_send_request_handler(
+    mut request: hyper::Request<HyperOutgoingBody>,
+    OutgoingRequestConfig {
+        use_tls,
+        connect_timeout,
+        first_byte_timeout,
+        between_bytes_timeout,
+    }: OutgoingRequestConfig,
+) -> Result<IncomingResponse, types::ErrorCode> {
+    let authority = if let Some(authority) = request.uri().authority() {
+        if authority.port().is_some() {
+            authority.to_string()
+        } else {
+            let port = if use_tls { 443 } else { 80 };
+            format!("{}:{port}", authority.to_string())
+        }
+    } else {
+        return Err(types::ErrorCode::HttpRequestUriInvalid);
+    };
+    let tcp_stream = timeout(connect_timeout, TcpStream::connect(&authority))
+        .await
+        .map_err(|_| types::ErrorCode::ConnectionTimeout)?
+        .map_err(|e| match e.kind() {
+            std::io::ErrorKind::AddrNotAvailable => {
+                dns_error("address not available".to_string(), 0)
+            }
+
+            _ => {
+                if e.to_string()
+                    .starts_with("failed to lookup address information")
+                {
+                    dns_error("address not available".to_string(), 0)
+                } else {
+                    types::ErrorCode::ConnectionRefused
+                }
+            }
+        })?;
+
+    let (mut sender, worker) = if use_tls {
+        #[cfg(any(target_arch = "riscv64", target_arch = "s390x"))]
+        {
+            return Err(crate::bindings::http::types::ErrorCode::InternalError(
+                Some("unsupported architecture for SSL".to_string()),
+            ));
+        }
+
+        #[cfg(not(any(target_arch = "riscv64", target_arch = "s390x")))]
+        {
+            use rustls::pki_types::ServerName;
+
+            // derived from https://github.com/rustls/rustls/blob/main/examples/src/bin/simpleclient.rs
+            let root_cert_store = rustls::RootCertStore {
+                roots: webpki_roots::TLS_SERVER_ROOTS.into(),
+            };
+            let config = rustls::ClientConfig::builder()
+                .with_root_certificates(root_cert_store)
+                .with_no_client_auth();
+            let connector = tokio_rustls::TlsConnector::from(std::sync::Arc::new(config));
+            let mut parts = authority.split(":");
+            let host = parts.next().unwrap_or(&authority);
+            let domain = ServerName::try_from(host)
+                .map_err(|e| {
+                    tracing::warn!("dns lookup error: {e:?}");
+                    dns_error("invalid dns name".to_string(), 0)
+                })?
+                .to_owned();
+            let stream = connector.connect(domain, tcp_stream).await.map_err(|e| {
+                tracing::warn!("tls protocol error: {e:?}");
+                types::ErrorCode::TlsProtocolError
+            })?;
+            let stream = TokioIo::new(stream);
+
+            let (sender, conn) = timeout(
+                connect_timeout,
+                hyper::client::conn::http1::handshake(stream),
+            )
+            .await
+            .map_err(|_| types::ErrorCode::ConnectionTimeout)?
+            .map_err(hyper_request_error)?;
+
+            let worker = wasmtime_wasi::runtime::spawn(async move {
+                match conn.await {
+                    Ok(()) => {}
+                    // TODO: shouldn't throw away this error and ideally should
+                    // surface somewhere.
+                    Err(e) => tracing::warn!("dropping error {e}"),
+                }
+            });
+
+            (sender, worker)
+        }
+    } else {
+        let tcp_stream = TokioIo::new(tcp_stream);
+        let (sender, conn) = timeout(
+            connect_timeout,
+            // TODO: we should plumb the builder through the http context, and use it here
+            hyper::client::conn::http1::handshake(tcp_stream),
+        )
+        .await
+        .map_err(|_| types::ErrorCode::ConnectionTimeout)?
+        .map_err(hyper_request_error)?;
+
+        let worker = wasmtime_wasi::runtime::spawn(async move {
+            match conn.await {
+                Ok(()) => {}
+                // TODO: same as above, shouldn't throw this error away.
+                Err(e) => tracing::warn!("dropping error {e}"),
+            }
+        });
+
+        (sender, worker)
+    };
+
+    // at this point, the request contains the scheme and the authority, but
+    // the http packet should only include those if addressing a proxy, so
+    // remove them here, since SendRequest::send_request does not do it for us
+    *request.uri_mut() = http::Uri::builder()
+        .path_and_query(
+            request
+                .uri()
+                .path_and_query()
+                .map(|p| p.as_str())
+                .unwrap_or("/"),
+        )
+        .build()
+        .expect("comes from valid request");
+
+    let resp = timeout(first_byte_timeout, sender.send_request(request))
+        .await
+        .map_err(|_| types::ErrorCode::ConnectionReadTimeout)?
+        .map_err(hyper_request_error)?
+        .map(|body| body.map_err(hyper_request_error).boxed());
+
+    Ok(IncomingResponse {
+        resp,
+        worker: Some(worker),
+        between_bytes_timeout,
+    })
+}
+
+impl From<http::Method> for types::Method {
+    fn from(method: http::Method) -> Self {
+        if method == http::Method::GET {
+            types::Method::Get
+        } else if method == hyper::Method::HEAD {
+            types::Method::Head
+        } else if method == hyper::Method::POST {
+            types::Method::Post
+        } else if method == hyper::Method::PUT {
+            types::Method::Put
+        } else if method == hyper::Method::DELETE {
+            types::Method::Delete
+        } else if method == hyper::Method::CONNECT {
+            types::Method::Connect
+        } else if method == hyper::Method::OPTIONS {
+            types::Method::Options
+        } else if method == hyper::Method::TRACE {
+            types::Method::Trace
+        } else if method == hyper::Method::PATCH {
+            types::Method::Patch
+        } else {
+            types::Method::Other(method.to_string())
+        }
+    }
+}
+
+impl TryInto<http::Method> for types::Method {
+    type Error = http::method::InvalidMethod;
+
+    fn try_into(self) -> Result<http::Method, Self::Error> {
+        match self {
+            Method::Get => Ok(http::Method::GET),
+            Method::Head => Ok(http::Method::HEAD),
+            Method::Post => Ok(http::Method::POST),
+            Method::Put => Ok(http::Method::PUT),
+            Method::Delete => Ok(http::Method::DELETE),
+            Method::Connect => Ok(http::Method::CONNECT),
+            Method::Options => Ok(http::Method::OPTIONS),
+            Method::Trace => Ok(http::Method::TRACE),
+            Method::Patch => Ok(http::Method::PATCH),
+            Method::Other(s) => http::Method::from_bytes(s.as_bytes()),
+        }
+    }
+}
+
+/// The concrete type behind a `wasi:http/types/incoming-request` resource.
+#[derive(Debug)]
+pub struct HostIncomingRequest {
+    pub(crate) parts: http::request::Parts,
+    pub(crate) scheme: Scheme,
+    pub(crate) authority: String,
+    /// The body of the incoming request.
+    pub body: Option<HostIncomingBody>,
+}
+
+impl HostIncomingRequest {
+    /// Create a new `HostIncomingRequest`.
+    pub fn new(
+        view: &mut dyn WasiHttpView,
+        mut parts: http::request::Parts,
+        scheme: Scheme,
+        body: Option<HostIncomingBody>,
+    ) -> anyhow::Result<Self> {
+        let authority = match parts.uri.authority() {
+            Some(authority) => authority.to_string(),
+            None => match parts.headers.get(http::header::HOST) {
+                Some(host) => host.to_str()?.to_string(),
+                None => bail!("invalid HTTP request missing authority in URI and host header"),
+            },
+        };
+
+        remove_forbidden_headers(view, &mut parts.headers);
+        Ok(Self {
+            parts,
+            authority,
+            scheme,
+            body,
+        })
+    }
 }
 
+/// The concrete type behind a `wasi:http/types/response-outparam` resource.
+pub struct HostResponseOutparam {
+    /// The sender for sending a response.
+    pub result:
+        tokio::sync::oneshot::Sender<Result<hyper::Response<HyperOutgoingBody>, types::ErrorCode>>,
+}
+
+/// The concrete type behind a `wasi:http/types/outgoing-response` resource.
 pub struct HostOutgoingResponse {
-    pub status: u16,
+    /// The status of the response.
+    pub status: http::StatusCode,
+    /// The headers of the response.
     pub headers: FieldMap,
+    /// The body of the response.
     pub body: Option<HyperOutgoingBody>,
 }
 
@@ -83,7 +545,7 @@ impl TryFrom<HostOutgoingResponse> for hyper::Response<HyperOutgoingBody> {
     fn try_from(
         resp: HostOutgoingResponse,
     ) -> Result<hyper::Response<HyperOutgoingBody>, Self::Error> {
-        use http_body_util::{BodyExt, Empty};
+        use http_body_util::Empty;
 
         let mut builder = hyper::Response::builder().status(resp.status);
 
@@ -93,54 +555,123 @@ impl TryFrom<HostOutgoingResponse> for hyper::Response<HyperOutgoingBody> {
             Some(body) => builder.body(body),
             None => builder.body(
                 Empty::<bytes::Bytes>::new()
-                    .map_err(|_| anyhow::anyhow!("empty error"))
+                    .map_err(|_| unreachable!("Infallible error"))
                     .boxed(),
             ),
         }
     }
 }
 
-pub type FieldMap = hyper::HeaderMap;
+/// The concrete type behind a `wasi:http/types/outgoing-request` resource.
+#[derive(Debug)]
+pub struct HostOutgoingRequest {
+    /// The method of the request.
+    pub method: Method,
+    /// The scheme of the request.
+    pub scheme: Option<Scheme>,
+    /// The authority of the request.
+    pub authority: Option<String>,
+    /// The path and query of the request.
+    pub path_with_query: Option<String>,
+    /// The request headers.
+    pub headers: FieldMap,
+    /// The request body.
+    pub body: Option<HyperOutgoingBody>,
+}
+
+/// The concrete type behind a `wasi:http/types/request-options` resource.
+#[derive(Debug, Default)]
+pub struct HostRequestOptions {
+    /// How long to wait for a connection to be established.
+    pub connect_timeout: Option<std::time::Duration>,
+    /// How long to wait for the first byte of the response body.
+    pub first_byte_timeout: Option<std::time::Duration>,
+    /// How long to wait between frames of the response body.
+    pub between_bytes_timeout: Option<std::time::Duration>,
+}
+
+/// The concrete type behind a `wasi:http/types/incoming-response` resource.
+#[derive(Debug)]
+pub struct HostIncomingResponse {
+    /// The response status
+    pub status: u16,
+    /// The response headers
+    pub headers: FieldMap,
+    /// The response body
+    pub body: Option<HostIncomingBody>,
+}
 
+/// The concrete type behind a `wasi:http/types/fields` resource.
+#[derive(Debug)]
 pub enum HostFields {
+    /// A reference to the fields of a parent entry.
     Ref {
+        /// The parent resource rep.
         parent: u32,
 
+        /// The function to get the fields from the parent.
         // NOTE: there's not failure in the result here because we assume that HostFields will
         // always be registered as a child of the entry with the `parent` id. This ensures that the
         // entry will always exist while this `HostFields::Ref` entry exists in the table, thus we
         // don't need to account for failure when fetching the fields ref from the parent.
         get_fields: for<'a> fn(elem: &'a mut (dyn Any + 'static)) -> &'a mut FieldMap,
     },
+    /// An owned version of the fields.
     Owned {
+        /// The fields themselves.
         fields: FieldMap,
     },
 }
 
-pub struct IncomingResponseInternal {
+/// An owned version of `HostFields`
+pub type FieldMap = hyper::HeaderMap;
+
+/// A handle to a future incoming response.
+pub type FutureIncomingResponseHandle =
+    AbortOnDropJoinHandle<anyhow::Result<Result<IncomingResponse, types::ErrorCode>>>;
+
+/// A response that is in the process of being received.
+#[derive(Debug)]
+pub struct IncomingResponse {
+    /// The response itself.
     pub resp: hyper::Response<HyperIncomingBody>,
-    pub worker: AbortOnDropJoinHandle<anyhow::Result<()>>,
+    /// Optional worker task that continues to process the response.
+    pub worker: Option<AbortOnDropJoinHandle<()>>,
+    /// The timeout between chunks of the response.
     pub between_bytes_timeout: std::time::Duration,
 }
 
-type FutureIncomingResponseHandle = AbortOnDropJoinHandle<anyhow::Result<IncomingResponseInternal>>;
-
+/// The concrete type behind a `wasi:http/types/future-incoming-response` resource.
+#[derive(Debug)]
 pub enum HostFutureIncomingResponse {
+    /// A pending response
     Pending(FutureIncomingResponseHandle),
-    Ready(anyhow::Result<IncomingResponseInternal>),
+    /// The response is ready.
+    ///
+    /// An outer error will trap while the inner error gets returned to the guest.
+    Ready(anyhow::Result<Result<IncomingResponse, types::ErrorCode>>),
+    /// The response has been consumed.
     Consumed,
 }
 
 impl HostFutureIncomingResponse {
-    pub fn new(handle: FutureIncomingResponseHandle) -> Self {
+    /// Create a new `HostFutureIncomingResponse` that is pending on the provided task handle.
+    pub fn pending(handle: FutureIncomingResponseHandle) -> Self {
         Self::Pending(handle)
     }
 
+    /// Create a new `HostFutureIncomingResponse` that is ready.
+    pub fn ready(result: anyhow::Result<Result<IncomingResponse, types::ErrorCode>>) -> Self {
+        Self::Ready(result)
+    }
+
+    /// Returns `true` if the response is ready.
     pub fn is_ready(&self) -> bool {
         matches!(self, Self::Ready(_))
     }
 
-    pub fn unwrap_ready(self) -> anyhow::Result<IncomingResponseInternal> {
+    /// Unwrap the response, panicking if it is not ready.
+    pub fn unwrap_ready(self) -> anyhow::Result<Result<IncomingResponse, types::ErrorCode>> {
         match self {
             Self::Ready(res) => res,
             Self::Pending(_) | Self::Consumed => {
diff --git a/crates/wasi-http/src/types_impl.rs b/crates/wasi-http/src/types_impl.rs
index bc2ae97f4ed5..2b6b5c15b04e 100644
--- a/crates/wasi-http/src/types_impl.rs
+++ b/crates/wasi-http/src/types_impl.rs
@@ -1,35 +1,88 @@
-use crate::bindings::http::types::{Error, Headers, Method, Scheme, StatusCode, Trailers};
-use crate::body::{FinishMessage, HostFutureTrailers, HostFutureTrailersState};
-use crate::types::{HostIncomingRequest, HostOutgoingResponse};
-use crate::WasiHttpView;
+//! Implementation for the `wasi:http/types` interface.
+
 use crate::{
-    body::{HostIncomingBody, HostIncomingBodyBuilder, HostOutgoingBody},
+    bindings::http::types::{self, Headers, Method, Scheme, StatusCode, Trailers},
+    body::{HostFutureTrailers, HostIncomingBody, HostOutgoingBody, StreamContext},
     types::{
-        FieldMap, HostFields, HostFutureIncomingResponse, HostIncomingResponse,
-        HostOutgoingRequest, HostResponseOutparam,
+        is_forbidden_header, remove_forbidden_headers, FieldMap, HostFields,
+        HostFutureIncomingResponse, HostIncomingRequest, HostIncomingResponse, HostOutgoingRequest,
+        HostOutgoingResponse, HostResponseOutparam,
     },
+    WasiHttpImpl, WasiHttpView,
 };
 use anyhow::Context;
 use std::any::Any;
-use wasmtime::component::Resource;
-use wasmtime_wasi::preview2::{
+use std::str::FromStr;
+use wasmtime::component::{Resource, ResourceTable};
+use wasmtime_wasi::{
     bindings::io::streams::{InputStream, OutputStream},
-    Pollable, Table,
+    Pollable, ResourceTableError,
 };
 
-impl<T: WasiHttpView> crate::bindings::http::types::Host for T {}
+impl<T> crate::bindings::http::types::Host for WasiHttpImpl<T>
+where
+    T: WasiHttpView,
+{
+    fn convert_error_code(&mut self, err: crate::HttpError) -> wasmtime::Result<types::ErrorCode> {
+        err.downcast()
+    }
 
-fn get_fields_mut<'a>(
-    table: &'a mut Table,
+    fn http_error_code(
+        &mut self,
+        err: wasmtime::component::Resource<types::IoError>,
+    ) -> wasmtime::Result<Option<types::ErrorCode>> {
+        let e = self.table().get(&err)?;
+        Ok(e.downcast_ref::<types::ErrorCode>().cloned())
+    }
+}
+
+/// Extract the `Content-Length` header value from a [`FieldMap`], returning `None` if it's not
+/// present. This function will return `Err` if it's not possible to parse the `Content-Length`
+/// header.
+fn get_content_length(fields: &FieldMap) -> Result<Option<u64>, ()> {
+    let header_val = match fields.get(hyper::header::CONTENT_LENGTH) {
+        Some(val) => val,
+        None => return Ok(None),
+    };
+
+    let header_str = match header_val.to_str() {
+        Ok(val) => val,
+        Err(_) => return Err(()),
+    };
+
+    match header_str.parse() {
+        Ok(len) => Ok(Some(len)),
+        Err(_) => Err(()),
+    }
+}
+
+/// Take ownership of the underlying [`FieldMap`] associated with this fields resource. If the
+/// fields resource references another fields, the returned [`FieldMap`] will be cloned.
+fn move_fields(
+    table: &mut ResourceTable,
+    id: Resource<HostFields>,
+) -> Result<FieldMap, ResourceTableError> {
+    match table.delete(id)? {
+        HostFields::Ref { parent, get_fields } => {
+            let entry = table.get_any_mut(parent)?;
+            Ok(get_fields(entry).clone())
+        }
+
+        HostFields::Owned { fields } => Ok(fields),
+    }
+}
+
+fn get_fields<'a>(
+    table: &'a mut ResourceTable,
     id: &Resource<HostFields>,
-) -> wasmtime::Result<&'a mut FieldMap> {
-    let fields = table.get_resource(&id)?;
+) -> wasmtime::Result<&'a FieldMap> {
+    let fields = table.get(&id)?;
     if let HostFields::Ref { parent, get_fields } = *fields {
         let entry = table.get_any_mut(parent)?;
         return Ok(get_fields(entry));
     }
 
-    match table.get_resource_mut(&id)? {
+    match table.get_mut(&id)? {
         HostFields::Owned { fields } => Ok(fields),
         // NB: ideally the `if let` above would go here instead. That makes
         // the borrow-checker unhappy. Unclear why. If you, dear reader, can
@@ -38,27 +91,66 @@ fn get_fields_mut<'a>(
     }
 }
 
-impl<T: WasiHttpView> crate::bindings::http::types::HostFields for T {
-    fn new(&mut self, entries: Vec<(String, Vec<u8>)>) -> wasmtime::Result<Resource<HostFields>> {
-        let mut map = hyper::HeaderMap::new();
+fn get_fields_mut<'a>(
+    table: &'a mut ResourceTable,
+    id: &Resource<HostFields>,
+) -> wasmtime::Result<Result<&'a mut FieldMap, types::HeaderError>> {
+    match table.get_mut(&id)? {
+        HostFields::Owned { fields } => Ok(Ok(fields)),
+        HostFields::Ref { .. } => Ok(Err(types::HeaderError::Immutable)),
+    }
+}
+
+impl<T> crate::bindings::http::types::HostFields for WasiHttpImpl<T>
+where
+    T: WasiHttpView,
+{
+    fn new(&mut self) -> wasmtime::Result<Resource<HostFields>> {
+        let id = self
+            .table()
+            .push(HostFields::Owned {
+                fields: hyper::HeaderMap::new(),
+            })
+            .context("[new_fields] pushing fields")?;
+
+        Ok(id)
+    }
+
+    fn from_list(
+        &mut self,
+        entries: Vec<(String, Vec<u8>)>,
+    ) -> wasmtime::Result<Result<Resource<HostFields>, types::HeaderError>> {
+        let mut fields = hyper::HeaderMap::new();
 
         for (header, value) in entries {
-            let header = hyper::header::HeaderName::from_bytes(header.as_bytes())?;
-            let value = hyper::header::HeaderValue::from_bytes(&value)?;
-            map.append(header, value);
+            let header = match hyper::header::HeaderName::from_bytes(header.as_bytes()) {
+                Ok(header) => header,
+                Err(_) => return Ok(Err(types::HeaderError::InvalidSyntax)),
+            };
+
+            if is_forbidden_header(self, &header) {
+                return Ok(Err(types::HeaderError::Forbidden));
+            }
+
+            let value = match hyper::header::HeaderValue::from_bytes(&value) {
+                Ok(value) => value,
+                Err(_) => return Ok(Err(types::HeaderError::InvalidSyntax)),
+            };
+
+            fields.append(header, value);
         }
 
         let id = self
             .table()
-            .push_resource(HostFields::Owned { fields: map })
+            .push(HostFields::Owned { fields })
             .context("[new_fields] pushing fields")?;
 
-        Ok(id)
+        Ok(Ok(id))
     }
 
     fn drop(&mut self, fields: Resource<HostFields>) -> wasmtime::Result<()> {
         self.table()
-            .delete_resource(fields)
+            .delete(fields)
             .context("[drop_fields] deleting fields")?;
         Ok(())
     }
@@ -68,39 +160,84 @@ impl<T: WasiHttpView> crate::bindings::http::types::HostFields for T {
         fields: Resource<HostFields>,
         name: String,
     ) -> wasmtime::Result<Vec<Vec<u8>>> {
-        let res = get_fields_mut(self.table(), &fields)
-            .context("[fields_get] getting fields")?
-            .get_all(hyper::header::HeaderName::from_bytes(name.as_bytes())?)
+        let fields = get_fields(self.table(), &fields).context("[fields_get] getting fields")?;
+
+        let header = match hyper::header::HeaderName::from_bytes(name.as_bytes()) {
+            Ok(header) => header,
+            Err(_) => return Ok(vec![]),
+        };
+
+        if !fields.contains_key(&header) {
+            return Ok(vec![]);
+        }
+
+        let res = fields
+            .get_all(&header)
             .into_iter()
             .map(|val| val.as_bytes().to_owned())
             .collect();
         Ok(res)
     }
 
+    fn has(&mut self, fields: Resource<HostFields>, name: String) -> wasmtime::Result<bool> {
+        let fields = get_fields(self.table(), &fields).context("[fields_get] getting fields")?;
+
+        match hyper::header::HeaderName::from_bytes(name.as_bytes()) {
+            Ok(header) => Ok(fields.contains_key(&header)),
+            Err(_) => Ok(false),
+        }
+    }
+
     fn set(
         &mut self,
         fields: Resource<HostFields>,
         name: String,
-        values: Vec<Vec<u8>>,
-    ) -> wasmtime::Result<()> {
-        let m = get_fields_mut(self.table(), &fields)?;
+        byte_values: Vec<Vec<u8>>,
+    ) -> wasmtime::Result<Result<(), types::HeaderError>> {
+        let header = match hyper::header::HeaderName::from_bytes(name.as_bytes()) {
+            Ok(header) => header,
+            Err(_) => return Ok(Err(types::HeaderError::InvalidSyntax)),
+        };
 
-        let header = hyper::header::HeaderName::from_bytes(name.as_bytes())?;
+        if is_forbidden_header(self, &header) {
+            return Ok(Err(types::HeaderError::Forbidden));
+        }
 
-        m.remove(&header);
-        for value in values {
-            let value = hyper::header::HeaderValue::from_bytes(&value)?;
-            m.append(&header, value);
+        let mut values = Vec::with_capacity(byte_values.len());
+        for value in byte_values {
+            match hyper::header::HeaderValue::from_bytes(&value) {
+                Ok(value) => values.push(value),
+                Err(_) => return Ok(Err(types::HeaderError::InvalidSyntax)),
+            }
         }
 
-        Ok(())
+        Ok(get_fields_mut(self.table(), &fields)
+            .context("[fields_set] getting mutable fields")?
+            .map(|fields| {
+                fields.remove(&header);
+                for value in values {
+                    fields.append(&header, value);
+                }
+            }))
     }
 
-    fn delete(&mut self, fields: Resource<HostFields>, name: String) -> wasmtime::Result<()> {
-        let m = get_fields_mut(self.table(), &fields)?;
-        let header = hyper::header::HeaderName::from_bytes(name.as_bytes())?;
-        m.remove(header);
-        Ok(())
+    fn delete(
+        &mut self,
+        fields: Resource<HostFields>,
+        name: String,
+    ) -> wasmtime::Result<Result<(), types::HeaderError>> {
+        let header = match hyper::header::HeaderName::from_bytes(name.as_bytes()) {
+            Ok(header) => header,
+            Err(_) => return Ok(Err(types::HeaderError::InvalidSyntax)),
+        };
+
+        if is_forbidden_header(self, &header) {
+            return Ok(Err(types::HeaderError::Forbidden));
+        }
+
+        Ok(get_fields_mut(self.table(), &fields)?.map(|fields| {
+            fields.remove(header);
+        }))
     }
 
     fn append(
@@ -108,72 +245,65 @@ impl<T: WasiHttpView> crate::bindings::http::types::HostFields for T {
         fields: Resource<HostFields>,
         name: String,
         value: Vec<u8>,
-    ) -> wasmtime::Result<()> {
-        let m = get_fields_mut(self.table(), &fields)
-            .context("[fields_append] getting mutable fields")?;
-        let header = hyper::header::HeaderName::from_bytes(name.as_bytes())?;
-        let value = hyper::header::HeaderValue::from_bytes(&value)?;
-        m.append(header, value);
-        Ok(())
+    ) -> wasmtime::Result<Result<(), types::HeaderError>> {
+        let header = match hyper::header::HeaderName::from_bytes(name.as_bytes()) {
+            Ok(header) => header,
+            Err(_) => return Ok(Err(types::HeaderError::InvalidSyntax)),
+        };
+
+        if is_forbidden_header(self, &header) {
+            return Ok(Err(types::HeaderError::Forbidden));
+        }
+
+        let value = match hyper::header::HeaderValue::from_bytes(&value) {
+            Ok(value) => value,
+            Err(_) => return Ok(Err(types::HeaderError::InvalidSyntax)),
+        };
+
+        Ok(get_fields_mut(self.table(), &fields)
+            .context("[fields_append] getting mutable fields")?
+            .map(|fields| {
+                fields.append(header, value);
+            }))
     }
 
     fn entries(
         &mut self,
         fields: Resource<HostFields>,
     ) -> wasmtime::Result<Vec<(String, Vec<u8>)>> {
-        let fields = get_fields_mut(self.table(), &fields)?;
-        let result = fields
+        Ok(get_fields(self.table(), &fields)?
             .iter()
             .map(|(name, value)| (name.as_str().to_owned(), value.as_bytes().to_owned()))
-            .collect();
-        Ok(result)
+            .collect())
     }
 
     fn clone(&mut self, fields: Resource<HostFields>) -> wasmtime::Result<Resource<HostFields>> {
-        let fields = get_fields_mut(self.table(), &fields)
+        let fields = get_fields(self.table(), &fields)
             .context("[fields_clone] getting fields")?
             .clone();
 
         let id = self
             .table()
-            .push_resource(HostFields::Owned { fields })
+            .push(HostFields::Owned { fields })
             .context("[fields_clone] pushing fields")?;
 
         Ok(id)
     }
 }
 
-impl<T: WasiHttpView> crate::bindings::http::types::HostIncomingRequest for T {
+impl<T> crate::bindings::http::types::HostIncomingRequest for WasiHttpImpl<T>
+where
+    T: WasiHttpView,
+{
     fn method(&mut self, id: Resource<HostIncomingRequest>) -> wasmtime::Result<Method> {
-        let method = self.table().get_resource(&id)?.parts.method.as_ref();
-
-        if method == hyper::Method::GET {
-            Ok(Method::Get)
-        } else if method == hyper::Method::HEAD {
-            Ok(Method::Head)
-        } else if method == hyper::Method::POST {
-            Ok(Method::Post)
-        } else if method == hyper::Method::PUT {
-            Ok(Method::Put)
-        } else if method == hyper::Method::DELETE {
-            Ok(Method::Delete)
-        } else if method == hyper::Method::CONNECT {
-            Ok(Method::Connect)
-        } else if method == hyper::Method::OPTIONS {
-            Ok(Method::Options)
-        } else if method == hyper::Method::TRACE {
-            Ok(Method::Trace)
-        } else if method == hyper::Method::PATCH {
-            Ok(Method::Patch)
-        } else {
-            Ok(Method::Other(method.to_owned()))
-        }
+        let method = self.table().get(&id)?.parts.method.clone();
+        Ok(method.into())
     }
     fn path_with_query(
         &mut self,
         id: Resource<HostIncomingRequest>,
     ) -> wasmtime::Result<Option<String>> {
-        let req = self.table().get_resource(&id)?;
+        let req = self.table().get(&id)?;
         Ok(req
             .parts
             .uri
@@ -181,33 +311,19 @@ impl<T: WasiHttpView> crate::bindings::http::types::HostIncomingRequest for T {
             .map(|path_and_query| path_and_query.as_str().to_owned()))
     }
     fn scheme(&mut self, id: Resource<HostIncomingRequest>) -> wasmtime::Result<Option<Scheme>> {
-        let req = self.table().get_resource(&id)?;
-        Ok(req.parts.uri.scheme().map(|scheme| {
-            if scheme == &http::uri::Scheme::HTTP {
-                return Scheme::Http;
-            }
-
-            if scheme == &http::uri::Scheme::HTTPS {
-                return Scheme::Https;
-            }
-
-            Scheme::Other(req.parts.uri.scheme_str().unwrap().to_owned())
-        }))
+        let req = self.table().get(&id)?;
+        Ok(Some(req.scheme.clone()))
     }
     fn authority(&mut self, id: Resource<HostIncomingRequest>) -> wasmtime::Result<Option<String>> {
-        let req = self.table().get_resource(&id)?;
-        Ok(req
-            .parts
-            .uri
-            .authority()
-            .map(|auth| auth.as_str().to_owned()))
+        let req = self.table().get(&id)?;
+        Ok(Some(req.authority.clone()))
     }
 
     fn headers(
         &mut self,
         id: Resource<HostIncomingRequest>,
     ) -> wasmtime::Result<Resource<Headers>> {
-        let _ = self.table().get_resource(&id)?;
+        let _ = self.table().get(&id)?;
 
         fn get_fields(elem: &mut dyn Any) -> &mut FieldMap {
             &mut elem
@@ -217,7 +333,7 @@ impl<T: WasiHttpView> crate::bindings::http::types::HostIncomingRequest for T {
                 .headers
         }
 
-        let headers = self.table().push_child_resource(
+        let headers = self.table().push_child(
             HostFields::Ref {
                 parent: id.rep(),
                 get_fields,
@@ -232,10 +348,10 @@ impl<T: WasiHttpView> crate::bindings::http::types::HostIncomingRequest for T {
         &mut self,
         id: Resource<HostIncomingRequest>,
     ) -> wasmtime::Result<Result<Resource<HostIncomingBody>, ()>> {
-        let req = self.table().get_resource_mut(&id)?;
+        let req = self.table().get_mut(&id)?;
         match req.body.take() {
-            Some(builder) => {
-                let id = self.table().push_resource(builder.build())?;
+            Some(body) => {
+                let id = self.table().push(body)?;
                 Ok(Ok(id))
             }
 
@@ -244,91 +360,234 @@ impl<T: WasiHttpView> crate::bindings::http::types::HostIncomingRequest for T {
     }
 
     fn drop(&mut self, id: Resource<HostIncomingRequest>) -> wasmtime::Result<()> {
-        let _ = self.table().delete_resource(id)?;
+        let _ = self.table().delete(id)?;
         Ok(())
     }
 }
 
-impl<T: WasiHttpView> crate::bindings::http::types::HostOutgoingRequest for T {
+impl<T> crate::bindings::http::types::HostOutgoingRequest for WasiHttpImpl<T>
+where
+    T: WasiHttpView,
+{
     fn new(
         &mut self,
-        method: Method,
-        path_with_query: Option<String>,
-        scheme: Option<Scheme>,
-        authority: Option<String>,
         headers: Resource<Headers>,
     ) -> wasmtime::Result<Resource<HostOutgoingRequest>> {
-        let headers = get_fields_mut(self.table(), &headers)?.clone();
+        let headers = move_fields(self.table(), headers)?;
+
         self.table()
-            .push_resource(HostOutgoingRequest {
-                path_with_query: path_with_query.unwrap_or("".to_string()),
-                authority: authority.unwrap_or("".to_string()),
-                method,
+            .push(HostOutgoingRequest {
+                path_with_query: None,
+                authority: None,
+                method: types::Method::Get,
                 headers,
-                scheme,
+                scheme: None,
                 body: None,
             })
             .context("[new_outgoing_request] pushing request")
     }
 
-    fn write(
+    fn body(
         &mut self,
         request: Resource<HostOutgoingRequest>,
     ) -> wasmtime::Result<Result<Resource<HostOutgoingBody>, ()>> {
         let req = self
             .table()
-            .get_resource_mut(&request)
+            .get_mut(&request)
             .context("[outgoing_request_write] getting request")?;
 
         if req.body.is_some() {
             return Ok(Err(()));
         }
 
-        let (host_body, hyper_body) = HostOutgoingBody::new();
+        let size = match get_content_length(&req.headers) {
+            Ok(size) => size,
+            Err(e) => return Ok(Err(e)),
+        };
+
+        let (host_body, hyper_body) = HostOutgoingBody::new(StreamContext::Request, size);
 
         req.body = Some(hyper_body);
 
         // The output stream will necessarily outlive the request, because we could be still
         // writing to the stream after `outgoing-handler.handle` is called.
-        let outgoing_body = self.table().push_resource(host_body)?;
+        let outgoing_body = self.table().push(host_body)?;
 
         Ok(Ok(outgoing_body))
     }
 
     fn drop(&mut self, request: Resource<HostOutgoingRequest>) -> wasmtime::Result<()> {
-        let _ = self.table().delete_resource(request)?;
+        let _ = self.table().delete(request)?;
         Ok(())
     }
+
+    fn method(
+        &mut self,
+        request: wasmtime::component::Resource<types::OutgoingRequest>,
+    ) -> wasmtime::Result<Method> {
+        Ok(self.table().get(&request)?.method.clone().try_into()?)
+    }
+
+    fn set_method(
+        &mut self,
+        request: wasmtime::component::Resource<types::OutgoingRequest>,
+        method: Method,
+    ) -> wasmtime::Result<Result<(), ()>> {
+        let req = self.table().get_mut(&request)?;
+
+        if let Method::Other(s) = &method {
+            if let Err(_) = http::Method::from_str(s) {
+                return Ok(Err(()));
+            }
+        }
+
+        req.method = method;
+
+        Ok(Ok(()))
+    }
+
+    fn path_with_query(
+        &mut self,
+        request: wasmtime::component::Resource<types::OutgoingRequest>,
+    ) -> wasmtime::Result<Option<String>> {
+        Ok(self.table().get(&request)?.path_with_query.clone())
+    }
+
+    fn set_path_with_query(
+        &mut self,
+        request: wasmtime::component::Resource<types::OutgoingRequest>,
+        path_with_query: Option<String>,
+    ) -> wasmtime::Result<Result<(), ()>> {
+        let req = self.table().get_mut(&request)?;
+
+        if let Some(s) = path_with_query.as_ref() {
+            if let Err(_) = http::uri::PathAndQuery::from_str(s) {
+                return Ok(Err(()));
+            }
+        }
+
+        req.path_with_query = path_with_query;
+
+        Ok(Ok(()))
+    }
+
+    fn scheme(
+        &mut self,
+        request: wasmtime::component::Resource<types::OutgoingRequest>,
+    ) -> wasmtime::Result<Option<Scheme>> {
+        Ok(self.table().get(&request)?.scheme.clone())
+    }
+
+    fn set_scheme(
+        &mut self,
+        request: wasmtime::component::Resource<types::OutgoingRequest>,
+        scheme: Option<Scheme>,
+    ) -> wasmtime::Result<Result<(), ()>> {
+        let req = self.table().get_mut(&request)?;
+
+        if let Some(types::Scheme::Other(s)) = scheme.as_ref() {
+            if let Err(_) = http::uri::Scheme::from_str(s.as_str()) {
+                return Ok(Err(()));
+            }
+        }
+
+        req.scheme = scheme;
+
+        Ok(Ok(()))
+    }
+
+    fn authority(
+        &mut self,
+        request: wasmtime::component::Resource<types::OutgoingRequest>,
+    ) -> wasmtime::Result<Option<String>> {
+        Ok(self.table().get(&request)?.authority.clone())
+    }
+
+    fn set_authority(
+        &mut self,
+        request: wasmtime::component::Resource<types::OutgoingRequest>,
+        authority: Option<String>,
+    ) -> wasmtime::Result<Result<(), ()>> {
+        let req = self.table().get_mut(&request)?;
+
+        if let Some(s) = authority.as_ref() {
+            let auth = match http::uri::Authority::from_str(s.as_str()) {
+                Ok(auth) => auth,
+                Err(_) => return Ok(Err(())),
+            };
+
+            if s.contains(':') && auth.port_u16().is_none() {
+                return Ok(Err(()));
+            }
+        }
+
+        req.authority = authority;
+
+        Ok(Ok(()))
+    }
+
+    fn headers(
+        &mut self,
+        request: wasmtime::component::Resource<types::OutgoingRequest>,
+    ) -> wasmtime::Result<wasmtime::component::Resource<Headers>> {
+        let _ = self
+            .table()
+            .get(&request)
+            .context("[outgoing_request_headers] getting request")?;
+
+        fn get_fields(elem: &mut dyn Any) -> &mut FieldMap {
+            &mut elem
+                .downcast_mut::<types::OutgoingRequest>()
+                .unwrap()
+                .headers
+        }
+
+        let id = self.table().push_child(
+            HostFields::Ref {
+                parent: request.rep(),
+                get_fields,
+            },
+            &request,
+        )?;
+
+        Ok(id)
+    }
 }
 
-impl<T: WasiHttpView> crate::bindings::http::types::HostResponseOutparam for T {
+impl<T> crate::bindings::http::types::HostResponseOutparam for WasiHttpImpl<T>
+where
+    T: WasiHttpView,
+{
     fn drop(&mut self, id: Resource<HostResponseOutparam>) -> wasmtime::Result<()> {
-        let _ = self.table().delete_resource(id)?;
+        let _ = self.table().delete(id)?;
         Ok(())
     }
     fn set(
         &mut self,
         id: Resource<HostResponseOutparam>,
-        resp: Result<Resource<HostOutgoingResponse>, Error>,
+        resp: Result<Resource<HostOutgoingResponse>, types::ErrorCode>,
     ) -> wasmtime::Result<()> {
         let val = match resp {
-            Ok(resp) => Ok(self.table().delete_resource(resp)?.try_into()?),
+            Ok(resp) => Ok(self.table().delete(resp)?.try_into()?),
             Err(e) => Err(e),
         };
 
         self.table()
-            .delete_resource(id)?
+            .delete(id)?
             .result
             .send(val)
             .map_err(|_| anyhow::anyhow!("failed to initialize response"))
     }
 }
 
-impl<T: WasiHttpView> crate::bindings::http::types::HostIncomingResponse for T {
+impl<T> crate::bindings::http::types::HostIncomingResponse for WasiHttpImpl<T>
+where
+    T: WasiHttpView,
+{
     fn drop(&mut self, response: Resource<HostIncomingResponse>) -> wasmtime::Result<()> {
         let _ = self
             .table()
-            .delete_resource(response)
+            .delete(response)
             .context("[drop_incoming_response] deleting response")?;
         Ok(())
     }
@@ -336,7 +595,7 @@ impl<T: WasiHttpView> crate::bindings::http::types::HostIncomingResponse for T {
     fn status(&mut self, response: Resource<HostIncomingResponse>) -> wasmtime::Result<StatusCode> {
         let r = self
             .table()
-            .get_resource(&response)
+            .get(&response)
             .context("[incoming_response_status] getting response")?;
         Ok(r.status)
     }
@@ -347,14 +606,14 @@ impl<T: WasiHttpView> crate::bindings::http::types::HostIncomingResponse for T {
     ) -> wasmtime::Result<Resource<Headers>> {
         let _ = self
             .table()
-            .get_resource(&response)
+            .get(&response)
             .context("[incoming_response_headers] getting response")?;
 
         fn get_fields(elem: &mut dyn Any) -> &mut FieldMap {
             &mut elem.downcast_mut::<HostIncomingResponse>().unwrap().headers
         }
 
-        let id = self.table().push_child_resource(
+        let id = self.table().push_child(
             HostFields::Ref {
                 parent: response.rep(),
                 get_fields,
@@ -371,12 +630,12 @@ impl<T: WasiHttpView> crate::bindings::http::types::HostIncomingResponse for T {
     ) -> wasmtime::Result<Result<Resource<HostIncomingBody>, ()>> {
         let table = self.table();
         let r = table
-            .get_resource_mut(&response)
+            .get_mut(&response)
             .context("[incoming_response_consume] getting response")?;
 
         match r.body.take() {
-            Some(builder) => {
-                let id = self.table().push_resource(builder.build())?;
+            Some(body) => {
+                let id = self.table().push(body)?;
                 Ok(Ok(id))
             }
 
@@ -385,11 +644,14 @@ impl<T: WasiHttpView> crate::bindings::http::types::HostIncomingResponse for T {
     }
 }
 
-impl<T: WasiHttpView> crate::bindings::http::types::HostFutureTrailers for T {
+impl<T> crate::bindings::http::types::HostFutureTrailers for WasiHttpImpl<T>
+where
+    T: WasiHttpView,
+{
     fn drop(&mut self, id: Resource<HostFutureTrailers>) -> wasmtime::Result<()> {
         let _ = self
             .table()
-            .delete_resource(id)
+            .delete(id)
             .context("[drop future-trailers] deleting future-trailers")?;
         Ok(())
     }
@@ -398,50 +660,53 @@ impl<T: WasiHttpView> crate::bindings::http::types::HostFutureTrailers for T {
         &mut self,
         index: Resource<HostFutureTrailers>,
     ) -> wasmtime::Result<Resource<Pollable>> {
-        wasmtime_wasi::preview2::subscribe(self.table(), index)
+        wasmtime_wasi::subscribe(self.table(), index)
     }
 
     fn get(
         &mut self,
         id: Resource<HostFutureTrailers>,
-    ) -> wasmtime::Result<Option<Result<Resource<Trailers>, Error>>> {
-        let trailers = self.table().get_resource_mut(&id)?;
-        match &trailers.state {
-            HostFutureTrailersState::Waiting(_) => return Ok(None),
-            HostFutureTrailersState::Done(Err(e)) => return Ok(Some(Err(e.clone()))),
-            HostFutureTrailersState::Done(Ok(_)) => {}
-        }
+    ) -> wasmtime::Result<Option<Result<Result<Option<Resource<Trailers>>, types::ErrorCode>, ()>>>
+    {
+        let trailers = self.table().get_mut(&id)?;
+        match trailers {
+            HostFutureTrailers::Waiting(_) => return Ok(None),
+            HostFutureTrailers::Consumed => return Ok(Some(Err(()))),
+            HostFutureTrailers::Done(_) => {}
+        };
 
-        fn get_fields(elem: &mut dyn Any) -> &mut FieldMap {
-            let trailers = elem.downcast_mut::<HostFutureTrailers>().unwrap();
-            match &mut trailers.state {
-                HostFutureTrailersState::Done(Ok(e)) => e,
-                _ => unreachable!(),
-            }
-        }
+        let res = match std::mem::replace(trailers, HostFutureTrailers::Consumed) {
+            HostFutureTrailers::Done(res) => res,
+            _ => unreachable!(),
+        };
 
-        let hdrs = self.table().push_child_resource(
-            HostFields::Ref {
-                parent: id.rep(),
-                get_fields,
-            },
-            &id,
-        )?;
+        let mut fields = match res {
+            Ok(Some(fields)) => fields,
+            Ok(None) => return Ok(Some(Ok(Ok(None)))),
+            Err(e) => return Ok(Some(Ok(Err(e)))),
+        };
+
+        remove_forbidden_headers(self, &mut fields);
+
+        let ts = self.table().push(HostFields::Owned { fields })?;
 
-        Ok(Some(Ok(hdrs)))
+        Ok(Some(Ok(Ok(Some(ts)))))
     }
 }
 
-impl<T: WasiHttpView> crate::bindings::http::types::HostIncomingBody for T {
+impl<T> crate::bindings::http::types::HostIncomingBody for WasiHttpImpl<T>
+where
+    T: WasiHttpView,
+{
     fn stream(
         &mut self,
         id: Resource<HostIncomingBody>,
     ) -> wasmtime::Result<Result<Resource<InputStream>, ()>> {
-        let body = self.table().get_resource_mut(&id)?;
+        let body = self.table().get_mut(&id)?;
 
-        if let Some(stream) = body.stream.take() {
-            let stream = InputStream::Host(Box::new(stream));
-            let stream = self.table().push_child_resource(stream, &id)?;
+        if let Some(stream) = body.take_stream() {
+            let stream: InputStream = Box::new(stream);
+            let stream = self.table().push_child(stream, &id)?;
             return Ok(Ok(stream));
         }
 
@@ -452,28 +717,29 @@ impl<T: WasiHttpView> crate::bindings::http::types::HostIncomingBody for T {
         &mut self,
         id: Resource<HostIncomingBody>,
     ) -> wasmtime::Result<Resource<HostFutureTrailers>> {
-        let body = self.table().delete_resource(id)?;
-        let trailers = self.table().push_resource(body.into_future_trailers())?;
+        let body = self.table().delete(id)?;
+        let trailers = self.table().push(body.into_future_trailers())?;
         Ok(trailers)
     }
 
     fn drop(&mut self, id: Resource<HostIncomingBody>) -> wasmtime::Result<()> {
-        let _ = self.table().delete_resource(id)?;
+        let _ = self.table().delete(id)?;
         Ok(())
     }
 }
 
-impl<T: WasiHttpView> crate::bindings::http::types::HostOutgoingResponse for T {
+impl<T> crate::bindings::http::types::HostOutgoingResponse for WasiHttpImpl<T>
+where
+    T: WasiHttpView,
+{
     fn new(
         &mut self,
-        status: StatusCode,
         headers: Resource<Headers>,
     ) -> wasmtime::Result<Resource<HostOutgoingResponse>> {
-        let fields = get_fields_mut(self.table(), &headers)?.clone();
-        self.table().delete_resource(headers)?;
+        let fields = move_fields(self.table(), headers)?;
 
-        let id = self.table().push_resource(HostOutgoingResponse {
-            status,
+        let id = self.table().push(HostOutgoingResponse {
+            status: http::StatusCode::OK,
             headers: fields,
             body: None,
         })?;
@@ -481,42 +747,95 @@ impl<T: WasiHttpView> crate::bindings::http::types::HostOutgoingResponse for T {
         Ok(id)
     }
 
-    fn write(
+    fn body(
         &mut self,
         id: Resource<HostOutgoingResponse>,
     ) -> wasmtime::Result<Result<Resource<HostOutgoingBody>, ()>> {
-        let resp = self.table().get_resource_mut(&id)?;
+        let resp = self.table().get_mut(&id)?;
 
         if resp.body.is_some() {
             return Ok(Err(()));
         }
 
-        let (host, body) = HostOutgoingBody::new();
+        let size = match get_content_length(&resp.headers) {
+            Ok(size) => size,
+            Err(e) => return Ok(Err(e)),
+        };
+
+        let (host, body) = HostOutgoingBody::new(StreamContext::Response, size);
 
         resp.body.replace(body);
 
-        let id = self.table().push_resource(host)?;
+        let id = self.table().push(host)?;
 
         Ok(Ok(id))
     }
 
+    fn status_code(
+        &mut self,
+        id: Resource<HostOutgoingResponse>,
+    ) -> wasmtime::Result<types::StatusCode> {
+        Ok(self.table().get(&id)?.status.into())
+    }
+
+    fn set_status_code(
+        &mut self,
+        id: Resource<HostOutgoingResponse>,
+        status: types::StatusCode,
+    ) -> wasmtime::Result<Result<(), ()>> {
+        let resp = self.table().get_mut(&id)?;
+
+        match http::StatusCode::from_u16(status) {
+            Ok(status) => resp.status = status,
+            Err(_) => return Ok(Err(())),
+        };
+
+        Ok(Ok(()))
+    }
+
+    fn headers(
+        &mut self,
+        id: Resource<HostOutgoingResponse>,
+    ) -> wasmtime::Result<Resource<types::Headers>> {
+        // Trap if the outgoing-response doesn't exist.
+        let _ = self.table().get(&id)?;
+
+        fn get_fields(elem: &mut dyn Any) -> &mut FieldMap {
+            let resp = elem.downcast_mut::<HostOutgoingResponse>().unwrap();
+            &mut resp.headers
+        }
+
+        Ok(self.table().push_child(
+            HostFields::Ref {
+                parent: id.rep(),
+                get_fields,
+            },
+            &id,
+        )?)
+    }
+
     fn drop(&mut self, id: Resource<HostOutgoingResponse>) -> wasmtime::Result<()> {
-        let _ = self.table().delete_resource(id)?;
+        let _ = self.table().delete(id)?;
         Ok(())
     }
 }
 
-impl<T: WasiHttpView> crate::bindings::http::types::HostFutureIncomingResponse for T {
+impl<T> crate::bindings::http::types::HostFutureIncomingResponse for WasiHttpImpl<T>
+where
+    T: WasiHttpView,
+{
     fn drop(&mut self, id: Resource<HostFutureIncomingResponse>) -> wasmtime::Result<()> {
-        let _ = self.table().delete_resource(id)?;
+        let _ = self.table().delete(id)?;
         Ok(())
     }
 
     fn get(
         &mut self,
         id: Resource<HostFutureIncomingResponse>,
-    ) -> wasmtime::Result<Option<Result<Result<Resource<HostIncomingResponse>, Error>, ()>>> {
-        let resp = self.table().get_resource_mut(&id)?;
+    ) -> wasmtime::Result<
+        Option<Result<Result<Resource<HostIncomingResponse>, types::ErrorCode>, ()>>,
+    > {
+        let resp = self.table().get_mut(&id)?;
 
         match resp {
             HostFutureIncomingResponse::Pending(_) => return Ok(None),
@@ -528,43 +847,52 @@ impl<T: WasiHttpView> crate::bindings::http::types::HostFutureIncomingResponse f
             match std::mem::replace(resp, HostFutureIncomingResponse::Consumed).unwrap_ready() {
                 Err(e) => {
                     // Trapping if it's not possible to downcast to an wasi-http error
-                    let e = e.downcast::<Error>()?;
+                    let e = e.downcast::<types::ErrorCode>()?;
                     return Ok(Some(Ok(Err(e))));
                 }
 
-                Ok(resp) => resp,
+                Ok(Ok(resp)) => resp,
+                Ok(Err(e)) => return Ok(Some(Ok(Err(e)))),
             };
 
-        let (parts, body) = resp.resp.into_parts();
+        let (mut parts, body) = resp.resp.into_parts();
+
+        remove_forbidden_headers(self, &mut parts.headers);
 
-        let resp = self.table().push_resource(HostIncomingResponse {
+        let resp = self.table().push(HostIncomingResponse {
             status: parts.status.as_u16(),
-            headers: FieldMap::from(parts.headers),
-            body: Some(HostIncomingBodyBuilder {
-                body,
-                between_bytes_timeout: resp.between_bytes_timeout,
+            headers: parts.headers,
+            body: Some({
+                let mut body = HostIncomingBody::new(body, resp.between_bytes_timeout);
+                if let Some(worker) = resp.worker {
+                    body.retain_worker(worker);
+                }
+                body
             }),
-            worker: resp.worker,
         })?;
 
         Ok(Some(Ok(Ok(resp))))
     }
+
     fn subscribe(
         &mut self,
         id: Resource<HostFutureIncomingResponse>,
     ) -> wasmtime::Result<Resource<Pollable>> {
-        wasmtime_wasi::preview2::subscribe(self.table(), id)
+        wasmtime_wasi::subscribe(self.table(), id)
     }
 }
 
-impl<T: WasiHttpView> crate::bindings::http::types::HostOutgoingBody for T {
+impl<T> crate::bindings::http::types::HostOutgoingBody for WasiHttpImpl<T>
+where
+    T: WasiHttpView,
+{
     fn write(
         &mut self,
         id: Resource<HostOutgoingBody>,
     ) -> wasmtime::Result<Result<Resource<OutputStream>, ()>> {
-        let body = self.table().get_resource_mut(&id)?;
-        if let Some(stream) = body.body_output_stream.take() {
-            let id = self.table().push_child_resource(stream, &id)?;
+        let body = self.table().get_mut(&id)?;
+        if let Some(stream) = body.take_output_stream() {
+            let id = self.table().push_child(stream, &id)?;
             Ok(Ok(id))
         } else {
             Ok(Err(()))
@@ -575,37 +903,117 @@ impl<T: WasiHttpView> crate::bindings::http::types::HostOutgoingBody for T {
         &mut self,
         id: Resource<HostOutgoingBody>,
         ts: Option<Resource<Trailers>>,
-    ) -> wasmtime::Result<()> {
-        let mut body = self.table().delete_resource(id)?;
-
-        let sender = body
-            .finish_sender
-            .take()
-            .expect("outgoing-body trailer_sender consumed by a non-owning function");
+    ) -> crate::HttpResult<()> {
+        let body = self.table().delete(id)?;
 
-        let message = if let Some(ts) = ts {
-            FinishMessage::Trailers(get_fields_mut(self.table(), &ts)?.clone().into())
+        let ts = if let Some(ts) = ts {
+            Some(move_fields(self.table(), ts)?)
         } else {
-            FinishMessage::Finished
+            None
         };
 
-        // Ignoring failure: receiver died sending body, but we can't report that here.
-        let _ = sender.send(message.into());
-
+        body.finish(ts)?;
         Ok(())
     }
 
     fn drop(&mut self, id: Resource<HostOutgoingBody>) -> wasmtime::Result<()> {
-        let mut body = self.table().delete_resource(id)?;
+        self.table().delete(id)?.abort();
+        Ok(())
+    }
+}
 
-        let sender = body
-            .finish_sender
-            .take()
-            .expect("outgoing-body trailer_sender consumed by a non-owning function");
+impl<T> crate::bindings::http::types::HostRequestOptions for WasiHttpImpl<T>
+where
+    T: WasiHttpView,
+{
+    fn new(&mut self) -> wasmtime::Result<Resource<types::RequestOptions>> {
+        let id = self.table().push(types::RequestOptions::default())?;
+        Ok(id)
+    }
+
+    fn connect_timeout(
+        &mut self,
+        opts: Resource<types::RequestOptions>,
+    ) -> wasmtime::Result<Option<types::Duration>> {
+        let nanos = self
+            .table()
+            .get(&opts)?
+            .connect_timeout
+            .map(|d| d.as_nanos());
+
+        if let Some(nanos) = nanos {
+            Ok(Some(nanos.try_into()?))
+        } else {
+            Ok(None)
+        }
+    }
+
+    fn set_connect_timeout(
+        &mut self,
+        opts: Resource<types::RequestOptions>,
+        duration: Option<types::Duration>,
+    ) -> wasmtime::Result<Result<(), ()>> {
+        self.table().get_mut(&opts)?.connect_timeout =
+            duration.map(std::time::Duration::from_nanos);
+        Ok(Ok(()))
+    }
+
+    fn first_byte_timeout(
+        &mut self,
+        opts: Resource<types::RequestOptions>,
+    ) -> wasmtime::Result<Option<types::Duration>> {
+        let nanos = self
+            .table()
+            .get(&opts)?
+            .first_byte_timeout
+            .map(|d| d.as_nanos());
+
+        if let Some(nanos) = nanos {
+            Ok(Some(nanos.try_into()?))
+        } else {
+            Ok(None)
+        }
+    }
+
+    fn set_first_byte_timeout(
+        &mut self,
+        opts: Resource<types::RequestOptions>,
+        duration: Option<types::Duration>,
+    ) -> wasmtime::Result<Result<(), ()>> {
+        self.table().get_mut(&opts)?.first_byte_timeout =
+            duration.map(std::time::Duration::from_nanos);
+        Ok(Ok(()))
+    }
 
-        // Ignoring failure: receiver died sending body, but we can't report that here.
-        let _ = sender.send(FinishMessage::Abort);
+    fn between_bytes_timeout(
+        &mut self,
+        opts: Resource<types::RequestOptions>,
+    ) -> wasmtime::Result<Option<types::Duration>> {
+        let nanos = self
+            .table()
+            .get(&opts)?
+            .between_bytes_timeout
+            .map(|d| d.as_nanos());
+
+        if let Some(nanos) = nanos {
+            Ok(Some(nanos.try_into()?))
+        } else {
+            Ok(None)
+        }
+    }
+
+    fn set_between_bytes_timeout(
+        &mut self,
+        opts: Resource<types::RequestOptions>,
+        duration: Option<types::Duration>,
+    ) -> wasmtime::Result<Result<(), ()>> {
+        self.table().get_mut(&opts)?.between_bytes_timeout =
+            duration.map(std::time::Duration::from_nanos);
+        Ok(Ok(()))
+    }
 
+    fn drop(&mut self, rep: Resource<types::RequestOptions>) -> wasmtime::Result<()> {
+        let _ = self.table().delete(rep)?;
         Ok(())
     }
 }
diff --git a/crates/wasi-http/tests/all/async_.rs b/crates/wasi-http/tests/all/async_.rs
new file mode 100644
index 000000000000..4ea9c7c0782d
--- /dev/null
+++ b/crates/wasi-http/tests/all/async_.rs
@@ -0,0 +1,108 @@
+use super::*;
+use test_programs_artifacts::*;
+use wasmtime_wasi::bindings::Command;
+
+foreach_http!(assert_test_exists);
+
+async fn run(path: &str, server: &Server) -> Result<()> {
+    let engine = test_programs_artifacts::engine(|config| {
+        config.wasm_backtrace_details(wasmtime::WasmBacktraceDetails::Enable);
+        config.async_support(true);
+    });
+    let component = Component::from_file(&engine, path)?;
+    let mut store = store(&engine, server);
+    let mut linker = Linker::new(&engine);
+    wasmtime_wasi::add_to_linker_async(&mut linker)?;
+    wasmtime_wasi_http::add_only_http_to_linker_async(&mut linker)?;
+    let command = Command::instantiate_async(&mut store, &component, &linker).await?;
+    let result = command.wasi_cli_run().call_run(&mut store).await?;
+    result.map_err(|()| anyhow::anyhow!("run returned an error"))
+}
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn http_outbound_request_get() -> Result<()> {
+    let server = Server::http1()?;
+    run(HTTP_OUTBOUND_REQUEST_GET_COMPONENT, &server).await
+}
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn http_outbound_request_timeout() -> Result<()> {
+    let server = Server::http1()?;
+    run(HTTP_OUTBOUND_REQUEST_TIMEOUT_COMPONENT, &server).await
+}
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn http_outbound_request_post() -> Result<()> {
+    let server = Server::http1()?;
+    run(HTTP_OUTBOUND_REQUEST_POST_COMPONENT, &server).await
+}
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn http_outbound_request_large_post() -> Result<()> {
+    let server = Server::http1()?;
+    run(HTTP_OUTBOUND_REQUEST_LARGE_POST_COMPONENT, &server).await
+}
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn http_outbound_request_put() -> Result<()> {
+    let server = Server::http1()?;
+    run(HTTP_OUTBOUND_REQUEST_PUT_COMPONENT, &server).await
+}
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn http_outbound_request_invalid_version() -> Result<()> {
+    let server = Server::http2()?;
+    run(HTTP_OUTBOUND_REQUEST_INVALID_VERSION_COMPONENT, &server).await
+}
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn http_outbound_request_invalid_header() -> Result<()> {
+    let server = Server::http2()?;
+    run(HTTP_OUTBOUND_REQUEST_INVALID_HEADER_COMPONENT, &server).await
+}
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn http_outbound_request_unknown_method() -> Result<()> {
+    let server = Server::http1()?;
+    run(HTTP_OUTBOUND_REQUEST_UNKNOWN_METHOD_COMPONENT, &server).await
+}
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn http_outbound_request_unsupported_scheme() -> Result<()> {
+    let server = Server::http1()?;
+    run(HTTP_OUTBOUND_REQUEST_UNSUPPORTED_SCHEME_COMPONENT, &server).await
+}
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn http_outbound_request_invalid_port() -> Result<()> {
+    let server = Server::http1()?;
+    run(HTTP_OUTBOUND_REQUEST_INVALID_PORT_COMPONENT, &server).await
+}
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn http_outbound_request_invalid_dnsname() -> Result<()> {
+    let server = Server::http1()?;
+    run(HTTP_OUTBOUND_REQUEST_INVALID_DNSNAME_COMPONENT, &server).await
+}
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn http_outbound_request_response_build() -> Result<()> {
+    let server = Server::http1()?;
+    run(HTTP_OUTBOUND_REQUEST_RESPONSE_BUILD_COMPONENT, &server).await
+}
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn http_outbound_request_content_length() -> Result<()> {
+    let server = Server::http1()?;
+    run(HTTP_OUTBOUND_REQUEST_CONTENT_LENGTH_COMPONENT, &server).await
+}
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn http_outbound_request_missing_path_and_query() -> Result<()> {
+    let server = Server::http1()?;
+    run(
+        HTTP_OUTBOUND_REQUEST_MISSING_PATH_AND_QUERY_COMPONENT,
+        &server,
+    )
+    .await
+}
diff --git a/crates/test-programs/src/http_server.rs b/crates/wasi-http/tests/all/http_server.rs
similarity index 95%
rename from crates/test-programs/src/http_server.rs
rename to crates/wasi-http/tests/all/http_server.rs
index d22fe5b201bc..f1a22abf7edd 100644
--- a/crates/test-programs/src/http_server.rs
+++ b/crates/wasi-http/tests/all/http_server.rs
@@ -7,6 +7,7 @@ use std::{
     thread::JoinHandle,
 };
 use tokio::net::TcpListener;
+use wasmtime_wasi_http::io::TokioIo;
 
 async fn test(
     mut req: Request<hyper::body::Incoming>,
@@ -30,7 +31,9 @@ pub struct Server {
 }
 
 impl Server {
-    fn new<F>(run: impl FnOnce(tokio::net::TcpStream) -> F + Send + Sync + 'static) -> Result<Self>
+    fn new<F>(
+        run: impl FnOnce(TokioIo<tokio::net::TcpStream>) -> F + Send + 'static,
+    ) -> Result<Self>
     where
         F: Future<Output = Result<()>>,
     {
@@ -52,7 +55,7 @@ impl Server {
             rt.block_on(async move {
                 tracing::debug!("preparing to accept connection");
                 let (stream, _) = listener.accept().await.map_err(anyhow::Error::from)?;
-                run(stream).await
+                run(TokioIo::new(stream)).await
             })
         });
         Ok(Self {
diff --git a/crates/wasi-http/tests/all/main.rs b/crates/wasi-http/tests/all/main.rs
new file mode 100644
index 000000000000..e8cabff93bdd
--- /dev/null
+++ b/crates/wasi-http/tests/all/main.rs
@@ -0,0 +1,568 @@
+use crate::http_server::Server;
+use anyhow::{anyhow, Context, Result};
+use futures::{channel::oneshot, future, stream, FutureExt};
+use http_body::Frame;
+use http_body_util::{combinators::BoxBody, BodyExt, Collected, Empty, StreamBody};
+use hyper::{body::Bytes, server::conn::http1, service::service_fn, Method, StatusCode};
+use sha2::{Digest, Sha256};
+use std::{collections::HashMap, iter, net::Ipv4Addr, str, sync::Arc};
+use tokio::task;
+use wasmtime::{
+    component::{Component, Linker, ResourceTable},
+    Config, Engine, Store,
+};
+use wasmtime_wasi::{self, pipe::MemoryOutputPipe, WasiCtx, WasiCtxBuilder, WasiView};
+use wasmtime_wasi_http::{
+    bindings::http::types::{ErrorCode, Scheme},
+    body::HyperOutgoingBody,
+    io::TokioIo,
+    types::{self, HostFutureIncomingResponse, IncomingResponse, OutgoingRequestConfig},
+    HttpResult, WasiHttpCtx, WasiHttpView,
+};
+
+mod http_server;
+
+type RequestSender = Arc<
+    dyn Fn(hyper::Request<HyperOutgoingBody>, OutgoingRequestConfig) -> HostFutureIncomingResponse
+        + Send
+        + Sync,
+>;
+
+struct Ctx {
+    table: ResourceTable,
+    wasi: WasiCtx,
+    http: WasiHttpCtx,
+    stdout: MemoryOutputPipe,
+    stderr: MemoryOutputPipe,
+    send_request: Option<RequestSender>,
+    rejected_authority: Option<String>,
+}
+
+impl WasiView for Ctx {
+    fn table(&mut self) -> &mut ResourceTable {
+        &mut self.table
+    }
+    fn ctx(&mut self) -> &mut WasiCtx {
+        &mut self.wasi
+    }
+}
+
+impl WasiHttpView for Ctx {
+    fn ctx(&mut self) -> &mut WasiHttpCtx {
+        &mut self.http
+    }
+
+    fn table(&mut self) -> &mut ResourceTable {
+        &mut self.table
+    }
+
+    fn send_request(
+        &mut self,
+        request: hyper::Request<HyperOutgoingBody>,
+        config: OutgoingRequestConfig,
+    ) -> HttpResult<HostFutureIncomingResponse> {
+        if let Some(rejected_authority) = &self.rejected_authority {
+            let authority = request.uri().authority().map(ToString::to_string).unwrap();
+            if &authority == rejected_authority {
+                return Err(ErrorCode::HttpRequestDenied.into());
+            }
+        }
+        if let Some(send_request) = self.send_request.clone() {
+            Ok(send_request(request, config))
+        } else {
+            Ok(types::default_send_request(request, config))
+        }
+    }
+
+    fn is_forbidden_header(&mut self, name: &hyper::header::HeaderName) -> bool {
+        name.as_str() == "custom-forbidden-header"
+    }
+}
+
+fn store(engine: &Engine, server: &Server) -> Store<Ctx> {
+    let stdout = MemoryOutputPipe::new(4096);
+    let stderr = MemoryOutputPipe::new(4096);
+
+    // Create our wasi context.
+    let mut builder = WasiCtxBuilder::new();
+    builder.stdout(stdout.clone());
+    builder.stderr(stderr.clone());
+    builder.env("HTTP_SERVER", &server.addr());
+    let ctx = Ctx {
+        table: ResourceTable::new(),
+        wasi: builder.build(),
+        http: WasiHttpCtx::new(),
+        stderr,
+        stdout,
+        send_request: None,
+        rejected_authority: None,
+    };
+
+    Store::new(&engine, ctx)
+}
+
+impl Drop for Ctx {
+    fn drop(&mut self) {
+        let stdout = self.stdout.contents();
+        if !stdout.is_empty() {
+            println!("[guest] stdout:\n{}\n===", String::from_utf8_lossy(&stdout));
+        }
+        let stderr = self.stderr.contents();
+        if !stderr.is_empty() {
+            println!("[guest] stderr:\n{}\n===", String::from_utf8_lossy(&stderr));
+        }
+    }
+}
+
+// Assert that each of `sync` and `async` below are testing everything through
+// assertion of the existence of the test function itself.
+macro_rules! assert_test_exists {
+    ($name:ident) => {
+        #[allow(unused_imports)]
+        use self::$name as _;
+    };
+}
+
+mod async_;
+mod sync;
+
+async fn run_wasi_http(
+    component_filename: &str,
+    req: hyper::Request<BoxBody<Bytes, hyper::Error>>,
+    send_request: Option<RequestSender>,
+    rejected_authority: Option<String>,
+) -> anyhow::Result<Result<hyper::Response<Collected<Bytes>>, ErrorCode>> {
+    let stdout = MemoryOutputPipe::new(4096);
+    let stderr = MemoryOutputPipe::new(4096);
+    let table = ResourceTable::new();
+
+    let mut config = Config::new();
+    config.wasm_backtrace_details(wasmtime::WasmBacktraceDetails::Enable);
+    config.wasm_component_model(true);
+    config.async_support(true);
+    let engine = Engine::new(&config)?;
+    let component = Component::from_file(&engine, component_filename)?;
+
+    // Create our wasi context.
+    let mut builder = WasiCtxBuilder::new();
+    builder.stdout(stdout.clone());
+    builder.stderr(stderr.clone());
+    let wasi = builder.build();
+    let http = WasiHttpCtx::new();
+    let ctx = Ctx {
+        table,
+        wasi,
+        http,
+        stderr,
+        stdout,
+        send_request,
+        rejected_authority,
+    };
+    let mut store = Store::new(&engine, ctx);
+
+    let mut linker = Linker::new(&engine);
+    wasmtime_wasi_http::add_to_linker_async(&mut linker)?;
+    let proxy =
+        wasmtime_wasi_http::bindings::Proxy::instantiate_async(&mut store, &component, &linker)
+            .await?;
+
+    let req = store.data_mut().new_incoming_request(Scheme::Http, req)?;
+
+    let (sender, receiver) = tokio::sync::oneshot::channel();
+    let out = store.data_mut().new_response_outparam(sender)?;
+
+    let handle = wasmtime_wasi::runtime::spawn(async move {
+        proxy
+            .wasi_http_incoming_handler()
+            .call_handle(&mut store, req, out)
+            .await?;
+
+        Ok::<_, anyhow::Error>(())
+    });
+
+    let resp = match receiver.await {
+        Ok(Ok(resp)) => {
+            let (parts, body) = resp.into_parts();
+            let collected = BodyExt::collect(body).await?;
+            Some(Ok(hyper::Response::from_parts(parts, collected)))
+        }
+        Ok(Err(e)) => Some(Err(e)),
+
+        // Fall through below to the `resp.expect(...)` which will hopefully
+        // return a more specific error from `handle.await`.
+        Err(_) => None,
+    };
+
+    // Now that the response has been processed, we can wait on the wasm to
+    // finish without deadlocking.
+    handle.await.context("Component execution")?;
+
+    Ok(resp.expect("wasm never called set-response-outparam"))
+}
+
+#[test_log::test(tokio::test)]
+async fn wasi_http_proxy_tests() -> anyhow::Result<()> {
+    let req = hyper::Request::builder()
+        .header("custom-forbidden-header", "yes")
+        .uri("http://example.com:8080/test-path")
+        .method(http::Method::GET);
+
+    let resp = run_wasi_http(
+        test_programs_artifacts::API_PROXY_COMPONENT,
+        req.body(body::empty())?,
+        None,
+        None,
+    )
+    .await?;
+
+    match resp {
+        Ok(resp) => println!("response: {resp:?}"),
+        Err(e) => panic!("Error given in response: {e:?}"),
+    };
+
+    Ok(())
+}
+
+#[test_log::test(tokio::test)]
+async fn wasi_http_hash_all() -> Result<()> {
+    do_wasi_http_hash_all(false).await
+}
+
+#[test_log::test(tokio::test)]
+async fn wasi_http_hash_all_with_override() -> Result<()> {
+    do_wasi_http_hash_all(true).await
+}
+
+async fn do_wasi_http_hash_all(override_send_request: bool) -> Result<()> {
+    let bodies = Arc::new(
+        [
+            ("/a", "’Twas brillig, and the slithy toves"),
+            ("/b", "Did gyre and gimble in the wabe:"),
+            ("/c", "All mimsy were the borogoves,"),
+            ("/d", "And the mome raths outgrabe."),
+        ]
+        .into_iter()
+        .collect::<HashMap<_, _>>(),
+    );
+
+    let listener = tokio::net::TcpListener::bind((Ipv4Addr::new(127, 0, 0, 1), 0)).await?;
+
+    let prefix = format!("http://{}", listener.local_addr()?);
+
+    let (_tx, rx) = oneshot::channel::<()>();
+
+    let handle = {
+        let bodies = bodies.clone();
+
+        move |request: http::request::Parts| {
+            if let (Method::GET, Some(body)) = (request.method, bodies.get(request.uri.path())) {
+                Ok::<_, anyhow::Error>(hyper::Response::new(body::full(Bytes::copy_from_slice(
+                    body.as_bytes(),
+                ))))
+            } else {
+                Ok(hyper::Response::builder()
+                    .status(StatusCode::METHOD_NOT_ALLOWED)
+                    .body(body::empty())?)
+            }
+        }
+    };
+
+    let send_request = if override_send_request {
+        Some(Arc::new(
+            move |request: hyper::Request<HyperOutgoingBody>,
+                  OutgoingRequestConfig {
+                      between_bytes_timeout,
+                      ..
+                  }| {
+                let response = handle(request.into_parts().0).map(|resp| {
+                    Ok(IncomingResponse {
+                        resp: resp.map(|body| {
+                            body.map_err(wasmtime_wasi_http::hyper_response_error)
+                                .boxed()
+                        }),
+                        worker: None,
+                        between_bytes_timeout,
+                    })
+                });
+                HostFutureIncomingResponse::ready(response)
+            },
+        ) as RequestSender)
+    } else {
+        let server = async move {
+            loop {
+                let (stream, _) = listener.accept().await?;
+                let stream = TokioIo::new(stream);
+                let handle = handle.clone();
+                task::spawn(async move {
+                    if let Err(e) = http1::Builder::new()
+                        .keep_alive(true)
+                        .serve_connection(
+                            stream,
+                            service_fn(move |request| {
+                                let handle = handle.clone();
+                                async move { handle(request.into_parts().0) }
+                            }),
+                        )
+                        .await
+                    {
+                        eprintln!("error serving connection: {e:?}");
+                    }
+                });
+
+                // Help rustc with type inference:
+                if false {
+                    return Ok::<_, anyhow::Error>(());
+                }
+            }
+        }
+        .then(|result| {
+            if let Err(e) = result {
+                eprintln!("error listening for connections: {e:?}");
+            }
+            future::ready(())
+        })
+        .boxed();
+
+        task::spawn(async move {
+            drop(future::select(server, rx).await);
+        });
+
+        None
+    };
+
+    let mut request = hyper::Request::builder()
+        .method(http::Method::GET)
+        .uri("http://example.com:8080/hash-all");
+    for path in bodies.keys() {
+        request = request.header("url", format!("{prefix}{path}"));
+    }
+    let request = request.body(body::empty())?;
+
+    let response = run_wasi_http(
+        test_programs_artifacts::API_PROXY_STREAMING_COMPONENT,
+        request,
+        send_request,
+        None,
+    )
+    .await??;
+
+    assert_eq!(StatusCode::OK, response.status());
+    let body = response.into_body().to_bytes();
+    let body = str::from_utf8(&body)?;
+    for line in body.lines() {
+        let (url, hash) = line
+            .split_once(": ")
+            .ok_or_else(|| anyhow!("expected string of form `<url>: <sha-256>`; got {line}"))?;
+
+        let path = url
+            .strip_prefix(&prefix)
+            .ok_or_else(|| anyhow!("expected string with prefix {prefix}; got {url}"))?;
+
+        let mut hasher = Sha256::new();
+        hasher.update(
+            bodies
+                .get(path)
+                .ok_or_else(|| anyhow!("unexpected path: {path}"))?,
+        );
+
+        use base64::Engine;
+        assert_eq!(
+            hash,
+            base64::engine::general_purpose::STANDARD_NO_PAD.encode(hasher.finalize())
+        );
+    }
+
+    Ok(())
+}
+
+// ensure the runtime rejects the outgoing request
+#[test_log::test(tokio::test)]
+async fn wasi_http_hash_all_with_reject() -> Result<()> {
+    let request = hyper::Request::builder()
+        .method(http::Method::GET)
+        .uri("http://example.com:8080/hash-all");
+    let request = request.header("url", format!("http://forbidden.com"));
+    let request = request.header("url", format!("http://localhost"));
+    let request = request.body(body::empty())?;
+
+    let response = run_wasi_http(
+        test_programs_artifacts::API_PROXY_STREAMING_COMPONENT,
+        request,
+        None,
+        Some("forbidden.com".to_string()),
+    )
+    .await??;
+
+    let body = response.into_body().to_bytes();
+    let body = str::from_utf8(&body).unwrap();
+    for line in body.lines() {
+        println!("{line}");
+        if line.contains("forbidden.com") {
+            assert!(line.contains("HttpRequestDenied"));
+        }
+        if line.contains("localhost") {
+            assert!(!line.contains("HttpRequestDenied"));
+        }
+    }
+
+    Ok(())
+}
+
+#[test_log::test(tokio::test)]
+async fn wasi_http_echo() -> Result<()> {
+    do_wasi_http_echo("echo", None).await
+}
+
+#[test_log::test(tokio::test)]
+async fn wasi_http_double_echo() -> Result<()> {
+    let listener = tokio::net::TcpListener::bind((Ipv4Addr::new(127, 0, 0, 1), 0)).await?;
+
+    let prefix = format!("http://{}", listener.local_addr()?);
+
+    let (_tx, rx) = oneshot::channel::<()>();
+
+    let server = async move {
+        loop {
+            let (stream, _) = listener.accept().await?;
+            let stream = TokioIo::new(stream);
+            task::spawn(async move {
+                if let Err(e) = http1::Builder::new()
+                    .keep_alive(true)
+                    .serve_connection(
+                        stream,
+                        service_fn(
+                            move |request: hyper::Request<hyper::body::Incoming>| async move {
+                                use http_body_util::BodyExt;
+
+                                if let (&Method::POST, "/echo") =
+                                    (request.method(), request.uri().path())
+                                {
+                                    Ok::<_, anyhow::Error>(hyper::Response::new(
+                                        request.into_body().boxed(),
+                                    ))
+                                } else {
+                                    Ok(hyper::Response::builder()
+                                        .status(StatusCode::METHOD_NOT_ALLOWED)
+                                        .body(BoxBody::new(
+                                            Empty::new().map_err(|_| unreachable!()),
+                                        ))?)
+                                }
+                            },
+                        ),
+                    )
+                    .await
+                {
+                    eprintln!("error serving connection: {e:?}");
+                }
+            });
+
+            // Help rustc with type inference:
+            if false {
+                return Ok::<_, anyhow::Error>(());
+            }
+        }
+    }
+    .then(|result| {
+        if let Err(e) = result {
+            eprintln!("error listening for connections: {e:?}");
+        }
+        future::ready(())
+    })
+    .boxed();
+
+    task::spawn(async move {
+        drop(future::select(server, rx).await);
+    });
+
+    do_wasi_http_echo("double-echo", Some(&format!("{prefix}/echo"))).await
+}
+
+async fn do_wasi_http_echo(uri: &str, url_header: Option<&str>) -> Result<()> {
+    let body = {
+        // A sorta-random-ish megabyte
+        let mut n = 0_u8;
+        iter::repeat_with(move || {
+            n = n.wrapping_add(251);
+            n
+        })
+        .take(1024 * 1024)
+        .collect::<Vec<_>>()
+    };
+
+    let mut request = hyper::Request::builder()
+        .method(http::Method::POST)
+        .uri(format!("http://example.com:8080/{uri}"))
+        .header("content-type", "application/octet-stream");
+
+    if let Some(url_header) = url_header {
+        request = request.header("url", url_header);
+    }
+
+    let request = request.body(BoxBody::new(StreamBody::new(stream::iter(
+        body.chunks(16 * 1024)
+            .map(|chunk| Ok::<_, hyper::Error>(Frame::data(Bytes::copy_from_slice(chunk))))
+            .collect::<Vec<_>>(),
+    ))))?;
+
+    let response = run_wasi_http(
+        test_programs_artifacts::API_PROXY_STREAMING_COMPONENT,
+        request,
+        None,
+        None,
+    )
+    .await??;
+
+    assert_eq!(StatusCode::OK, response.status());
+    assert_eq!(
+        response.headers()["content-type"],
+        "application/octet-stream"
+    );
+    let received = Vec::from(response.into_body().to_bytes());
+    if body != received {
+        panic!(
+            "body content mismatch (expected length {}; actual length {})",
+            body.len(),
+            received.len()
+        );
+    }
+
+    Ok(())
+}
+
+#[test_log::test(tokio::test)]
+// test uses TLS but riscv/s390x don't support that yet
+#[cfg_attr(any(target_arch = "riscv64", target_arch = "s390x"), ignore)]
+async fn wasi_http_without_port() -> Result<()> {
+    let req = hyper::Request::builder()
+        .method(http::Method::GET)
+        .uri("https://httpbin.org/get");
+
+    let _response: hyper::Response<_> = run_wasi_http(
+        test_programs_artifacts::API_PROXY_FORWARD_REQUEST_COMPONENT,
+        req.body(body::empty())?,
+        None,
+        None,
+    )
+    .await??;
+
+    // NB: don't test the actual return code of `response`. This is testing a
+    // live http request against a live server and things happen. If we got this
+    // far it's already successful that the request was made and the lack of
+    // port in the URI was handled.
+
+    Ok(())
+}
+
+mod body {
+    use http_body_util::{combinators::BoxBody, BodyExt, Empty, Full};
+    use hyper::body::Bytes;
+    use hyper::Error;
+
+    pub fn full(bytes: Bytes) -> BoxBody<Bytes, Error> {
+        BoxBody::new(Full::new(bytes).map_err(|_| unreachable!()))
+    }
+
+    pub fn empty() -> BoxBody<Bytes, Error> {
+        BoxBody::new(Empty::new().map_err(|_| unreachable!()))
+    }
+}
diff --git a/crates/wasi-http/tests/all/sync.rs b/crates/wasi-http/tests/all/sync.rs
new file mode 100644
index 000000000000..64147a5a0e30
--- /dev/null
+++ b/crates/wasi-http/tests/all/sync.rs
@@ -0,0 +1,106 @@
+use super::*;
+use test_programs_artifacts::*;
+use wasmtime_wasi::bindings::sync::Command;
+
+foreach_http!(assert_test_exists);
+
+fn run(path: &str, server: &Server) -> Result<()> {
+    let engine = test_programs_artifacts::engine(|config| {
+        config.wasm_backtrace_details(wasmtime::WasmBacktraceDetails::Enable);
+    });
+    let component = Component::from_file(&engine, path)?;
+    let mut store = store(&engine, server);
+    let mut linker = Linker::new(&engine);
+    wasmtime_wasi::add_to_linker_sync(&mut linker)?;
+    wasmtime_wasi_http::add_only_http_to_linker_sync(&mut linker)?;
+    let command = Command::instantiate(&mut store, &component, &linker)?;
+    let result = command.wasi_cli_run().call_run(&mut store)?;
+    result.map_err(|()| anyhow::anyhow!("run returned an error"))
+}
+
+#[test_log::test]
+fn http_outbound_request_get() -> Result<()> {
+    let server = Server::http1()?;
+    run(HTTP_OUTBOUND_REQUEST_GET_COMPONENT, &server)
+}
+
+#[test_log::test]
+fn http_outbound_request_timeout() -> Result<()> {
+    let server = Server::http1()?;
+    run(HTTP_OUTBOUND_REQUEST_TIMEOUT_COMPONENT, &server)
+}
+
+#[test_log::test]
+fn http_outbound_request_post() -> Result<()> {
+    let server = Server::http1()?;
+    run(HTTP_OUTBOUND_REQUEST_POST_COMPONENT, &server)
+}
+
+#[test_log::test]
+fn http_outbound_request_large_post() -> Result<()> {
+    let server = Server::http1()?;
+    run(HTTP_OUTBOUND_REQUEST_LARGE_POST_COMPONENT, &server)
+}
+
+#[test_log::test]
+fn http_outbound_request_put() -> Result<()> {
+    let server = Server::http1()?;
+    run(HTTP_OUTBOUND_REQUEST_PUT_COMPONENT, &server)
+}
+
+#[test_log::test]
+fn http_outbound_request_invalid_version() -> Result<()> {
+    let server = Server::http2()?;
+    run(HTTP_OUTBOUND_REQUEST_INVALID_VERSION_COMPONENT, &server)
+}
+
+#[test_log::test]
+fn http_outbound_request_invalid_header() -> Result<()> {
+    let server = Server::http2()?;
+    run(HTTP_OUTBOUND_REQUEST_INVALID_HEADER_COMPONENT, &server)
+}
+
+#[test_log::test]
+fn http_outbound_request_unknown_method() -> Result<()> {
+    let server = Server::http1()?;
+    run(HTTP_OUTBOUND_REQUEST_UNKNOWN_METHOD_COMPONENT, &server)
+}
+
+#[test_log::test]
+fn http_outbound_request_unsupported_scheme() -> Result<()> {
+    let server = Server::http1()?;
+    run(HTTP_OUTBOUND_REQUEST_UNSUPPORTED_SCHEME_COMPONENT, &server)
+}
+
+#[test_log::test]
+fn http_outbound_request_invalid_port() -> Result<()> {
+    let server = Server::http1()?;
+    run(HTTP_OUTBOUND_REQUEST_INVALID_PORT_COMPONENT, &server)
+}
+
+#[test_log::test]
+fn http_outbound_request_invalid_dnsname() -> Result<()> {
+    let server = Server::http1()?;
+    run(HTTP_OUTBOUND_REQUEST_INVALID_DNSNAME_COMPONENT, &server)
+}
+
+#[test_log::test]
+fn http_outbound_request_response_build() -> Result<()> {
+    let server = Server::http1()?;
+    run(HTTP_OUTBOUND_REQUEST_RESPONSE_BUILD_COMPONENT, &server)
+}
+
+#[test_log::test]
+fn http_outbound_request_content_length() -> Result<()> {
+    let server = Server::http1()?;
+    run(HTTP_OUTBOUND_REQUEST_CONTENT_LENGTH_COMPONENT, &server)
+}
+
+#[test_log::test]
+fn http_outbound_request_missing_path_and_query() -> Result<()> {
+    let server = Server::http1()?;
+    run(
+        HTTP_OUTBOUND_REQUEST_MISSING_PATH_AND_QUERY_COMPONENT,
+        &server,
+    )
+}
diff --git a/crates/wasi-http/wit/command-extended.wit b/crates/wasi-http/wit/command-extended.wit
deleted file mode 100644
index 3c56808e4abe..000000000000
--- a/crates/wasi-http/wit/command-extended.wit
+++ /dev/null
@@ -1,37 +0,0 @@
-// All of the same imports and exports available in the wasi:cli/command world
-// with addition of HTTP proxy related imports:
-world command-extended {
-  import wasi:clocks/wall-clock
-  import wasi:clocks/monotonic-clock
-  import wasi:clocks/timezone
-  import wasi:filesystem/types
-  import wasi:filesystem/preopens
-  import wasi:sockets/instance-network
-  import wasi:sockets/ip-name-lookup
-  import wasi:sockets/network
-  import wasi:sockets/tcp-create-socket
-  import wasi:sockets/tcp
-  import wasi:sockets/udp-create-socket
-  import wasi:sockets/udp
-  import wasi:random/random
-  import wasi:random/insecure
-  import wasi:random/insecure-seed
-  import wasi:io/poll
-  import wasi:io/streams
-  import wasi:cli/environment
-  import wasi:cli/exit
-  import wasi:cli/stdin
-  import wasi:cli/stdout
-  import wasi:cli/stderr
-  import wasi:cli/terminal-input
-  import wasi:cli/terminal-output
-  import wasi:cli/terminal-stdin
-  import wasi:cli/terminal-stdout
-  import wasi:cli/terminal-stderr
-
-  // We should replace all others with `include self.command`
-  // as soon as the unioning of worlds is available:
-  // https://github.com/WebAssembly/component-model/issues/169
-  import wasi:logging/logging
-  import wasi:http/outgoing-handler
-}
diff --git a/crates/wasi-http/wit/deps/cli/command.wit b/crates/wasi-http/wit/deps/cli/command.wit
index d28f5f6282a4..dc064a3cd9ed 100644
--- a/crates/wasi-http/wit/deps/cli/command.wit
+++ b/crates/wasi-http/wit/deps/cli/command.wit
@@ -1,7 +1,10 @@
-package wasi:cli
+package wasi:cli@0.2.1;
 
+@since(version = 0.2.0)
 world command {
-  include reactor
+  @since(version = 0.2.0)
+  include imports;
 
-  export run
+  @since(version = 0.2.0)
+  export run;
 }
diff --git a/crates/wasi-http/wit/deps/cli/environment.wit b/crates/wasi-http/wit/deps/cli/environment.wit
index 36790fe714d2..2f449bd7c1f2 100644
--- a/crates/wasi-http/wit/deps/cli/environment.wit
+++ b/crates/wasi-http/wit/deps/cli/environment.wit
@@ -1,3 +1,4 @@
+@since(version = 0.2.0)
 interface environment {
   /// Get the POSIX-style environment variables.
   ///
@@ -7,12 +8,15 @@ interface environment {
   /// Morally, these are a value import, but until value imports are available
   /// in the component model, this import function should return the same
   /// values each time it is called.
-  get-environment: func() -> list<tuple<string, string>>
+  @since(version = 0.2.0)
+  get-environment: func() -> list<tuple<string, string>>;
 
   /// Get the POSIX-style arguments to the program.
-  get-arguments: func() -> list<string>
+  @since(version = 0.2.0)
+  get-arguments: func() -> list<string>;
 
   /// Return a path that programs should use as their initial current working
   /// directory, interpreting `.` as shorthand for this.
-  initial-cwd: func() -> option<string>
+  @since(version = 0.2.0)
+  initial-cwd: func() -> option<string>;
 }
diff --git a/crates/wasi-http/wit/deps/cli/exit.wit b/crates/wasi-http/wit/deps/cli/exit.wit
index 4831d50789af..427935c8d085 100644
--- a/crates/wasi-http/wit/deps/cli/exit.wit
+++ b/crates/wasi-http/wit/deps/cli/exit.wit
@@ -1,4 +1,17 @@
+@since(version = 0.2.0)
 interface exit {
   /// Exit the current instance and any linked instances.
-  exit: func(status: result)
+  @since(version = 0.2.0)
+  exit: func(status: result);
+
+  /// Exit the current instance and any linked instances, reporting the
+  /// specified status code to the host.
+  ///
+  /// The meaning of the code depends on the context, with 0 usually meaning
+  /// "success", and other values indicating various types of failure.
+  ///
+  /// This function does not return; the effect is analogous to a trap, but
+  /// without the connotation that something bad has happened.
+  @unstable(feature = cli-exit-with-code)
+  exit-with-code: func(status-code: u8);
 }
diff --git a/crates/wasi-http/wit/deps/cli/imports.wit b/crates/wasi-http/wit/deps/cli/imports.wit
new file mode 100644
index 000000000000..b8339d3b22e5
--- /dev/null
+++ b/crates/wasi-http/wit/deps/cli/imports.wit
@@ -0,0 +1,36 @@
+package wasi:cli@0.2.1;
+
+@since(version = 0.2.0)
+world imports {
+  @since(version = 0.2.0)
+  include wasi:clocks/imports@0.2.1;
+  @since(version = 0.2.0)
+  include wasi:filesystem/imports@0.2.1;
+  @since(version = 0.2.0)
+  include wasi:sockets/imports@0.2.1;
+  @since(version = 0.2.0)
+  include wasi:random/imports@0.2.1;
+  @since(version = 0.2.0)
+  include wasi:io/imports@0.2.1;
+
+  @since(version = 0.2.0)
+  import environment;
+  @since(version = 0.2.0)
+  import exit;
+  @since(version = 0.2.0)
+  import stdin;
+  @since(version = 0.2.0)
+  import stdout;
+  @since(version = 0.2.0)
+  import stderr;
+  @since(version = 0.2.0)
+  import terminal-input;
+  @since(version = 0.2.0)
+  import terminal-output;
+  @since(version = 0.2.0)
+  import terminal-stdin;
+  @since(version = 0.2.0)
+  import terminal-stdout;
+  @since(version = 0.2.0)
+  import terminal-stderr;
+}
diff --git a/crates/wasi-http/wit/deps/cli/reactor.wit b/crates/wasi-http/wit/deps/cli/reactor.wit
deleted file mode 100644
index 274d0644dc41..000000000000
--- a/crates/wasi-http/wit/deps/cli/reactor.wit
+++ /dev/null
@@ -1,33 +0,0 @@
-package wasi:cli
-
-world reactor {
-  import wasi:clocks/wall-clock
-  import wasi:clocks/monotonic-clock
-  import wasi:clocks/timezone
-  import wasi:filesystem/types
-  import wasi:filesystem/preopens
-  import wasi:sockets/instance-network
-  import wasi:sockets/ip-name-lookup
-  import wasi:sockets/network
-  import wasi:sockets/tcp-create-socket
-  import wasi:sockets/tcp
-  import wasi:sockets/udp-create-socket
-  import wasi:sockets/udp
-  import wasi:random/random
-  import wasi:random/insecure
-  import wasi:random/insecure-seed
-  import wasi:io/poll
-  import wasi:io/streams
-
-  import environment
-  import exit
-  import stdin
-  import stdout
-  import stderr
-  import terminal-input
-  import terminal-output
-  import terminal-stdin
-  import terminal-stdout
-  import terminal-stderr
-}
-
diff --git a/crates/wasi-http/wit/deps/cli/run.wit b/crates/wasi-http/wit/deps/cli/run.wit
index 45a1ca533f0e..655346efb6dd 100644
--- a/crates/wasi-http/wit/deps/cli/run.wit
+++ b/crates/wasi-http/wit/deps/cli/run.wit
@@ -1,4 +1,6 @@
+@since(version = 0.2.0)
 interface run {
   /// Run the program.
-  run: func() -> result
+  @since(version = 0.2.0)
+  run: func() -> result;
 }
diff --git a/crates/wasi-http/wit/deps/cli/stdio.wit b/crates/wasi-http/wit/deps/cli/stdio.wit
index 6c9d4a41a6f9..d1d26eb6153d 100644
--- a/crates/wasi-http/wit/deps/cli/stdio.wit
+++ b/crates/wasi-http/wit/deps/cli/stdio.wit
@@ -1,17 +1,26 @@
+@since(version = 0.2.0)
 interface stdin {
-  use wasi:io/streams.{input-stream}
+  @since(version = 0.2.0)
+  use wasi:io/streams@0.2.1.{input-stream};
 
-  get-stdin: func() -> input-stream
+  @since(version = 0.2.0)
+  get-stdin: func() -> input-stream;
 }
 
+@since(version = 0.2.0)
 interface stdout {
-  use wasi:io/streams.{output-stream}
+  @since(version = 0.2.0)
+  use wasi:io/streams@0.2.1.{output-stream};
 
-  get-stdout: func() -> output-stream
+  @since(version = 0.2.0)
+  get-stdout: func() -> output-stream;
 }
 
+@since(version = 0.2.0)
 interface stderr {
-  use wasi:io/streams.{output-stream}
+  @since(version = 0.2.0)
+  use wasi:io/streams@0.2.1.{output-stream};
 
-  get-stderr: func() -> output-stream
+  @since(version = 0.2.0)
+  get-stderr: func() -> output-stream;
 }
diff --git a/crates/wasi-http/wit/deps/cli/terminal.wit b/crates/wasi-http/wit/deps/cli/terminal.wit
index b0a5bec2a2c7..d305498c64de 100644
--- a/crates/wasi-http/wit/deps/cli/terminal.wit
+++ b/crates/wasi-http/wit/deps/cli/terminal.wit
@@ -1,47 +1,62 @@
+/// Terminal input.
+///
+/// In the future, this may include functions for disabling echoing,
+/// disabling input buffering so that keyboard events are sent through
+/// immediately, querying supported features, and so on.
+@since(version = 0.2.0)
 interface terminal-input {
     /// The input side of a terminal.
-    resource terminal-input
-
-    // In the future, this may include functions for disabling echoing,
-    // disabling input buffering so that keyboard events are sent through
-    // immediately, querying supported features, and so on.
+    @since(version = 0.2.0)
+    resource terminal-input;
 }
 
+/// Terminal output.
+///
+/// In the future, this may include functions for querying the terminal
+/// size, being notified of terminal size changes, querying supported
+/// features, and so on.
+@since(version = 0.2.0)
 interface terminal-output {
     /// The output side of a terminal.
-    resource terminal-output
-
-    // In the future, this may include functions for querying the terminal
-    // size, being notified of terminal size changes, querying supported
-    // features, and so on.
+    @since(version = 0.2.0)
+    resource terminal-output;
 }
 
 /// An interface providing an optional `terminal-input` for stdin as a
 /// link-time authority.
+@since(version = 0.2.0)
 interface terminal-stdin {
-    use terminal-input.{terminal-input}
+    @since(version = 0.2.0)
+    use terminal-input.{terminal-input};
 
     /// If stdin is connected to a terminal, return a `terminal-input` handle
     /// allowing further interaction with it.
-    get-terminal-stdin: func() -> option<terminal-input>
+    @since(version = 0.2.0)
+    get-terminal-stdin: func() -> option<terminal-input>;
 }
 
 /// An interface providing an optional `terminal-output` for stdout as a
 /// link-time authority.
+@since(version = 0.2.0)
 interface terminal-stdout {
-    use terminal-output.{terminal-output}
+    @since(version = 0.2.0)
+    use terminal-output.{terminal-output};
 
     /// If stdout is connected to a terminal, return a `terminal-output` handle
     /// allowing further interaction with it.
-    get-terminal-stdout: func() -> option<terminal-output>
+    @since(version = 0.2.0)
+    get-terminal-stdout: func() -> option<terminal-output>;
 }
 
 /// An interface providing an optional `terminal-output` for stderr as a
 /// link-time authority.
+@since(version = 0.2.0)
 interface terminal-stderr {
-    use terminal-output.{terminal-output}
+    @since(version = 0.2.0)
+    use terminal-output.{terminal-output};
 
     /// If stderr is connected to a terminal, return a `terminal-output` handle
     /// allowing further interaction with it.
-    get-terminal-stderr: func() -> option<terminal-output>
+    @since(version = 0.2.0)
+    get-terminal-stderr: func() -> option<terminal-output>;
 }
diff --git a/crates/wasi-http/wit/deps/clocks/monotonic-clock.wit b/crates/wasi-http/wit/deps/clocks/monotonic-clock.wit
index 703a5fb7a503..3c24840c980e 100644
--- a/crates/wasi-http/wit/deps/clocks/monotonic-clock.wit
+++ b/crates/wasi-http/wit/deps/clocks/monotonic-clock.wit
@@ -1,3 +1,4 @@
+package wasi:clocks@0.2.1;
 /// WASI Monotonic Clock is a clock API intended to let users measure elapsed
 /// time.
 ///
@@ -6,27 +7,44 @@
 ///
 /// A monotonic clock is a clock which has an unspecified initial value, and
 /// successive reads of the clock will produce non-decreasing values.
-///
-/// It is intended for measuring elapsed time.
+@since(version = 0.2.0)
 interface monotonic-clock {
-    use wasi:io/poll.{pollable}
+    @since(version = 0.2.0)
+    use wasi:io/poll@0.2.1.{pollable};
+
+    /// An instant in time, in nanoseconds. An instant is relative to an
+    /// unspecified initial value, and can only be compared to instances from
+    /// the same monotonic-clock.
+    @since(version = 0.2.0)
+    type instant = u64;
 
-    /// A timestamp in nanoseconds.
-    type instant = u64
+    /// A duration of time, in nanoseconds.
+    @since(version = 0.2.0)
+    type duration = u64;
 
     /// Read the current value of the clock.
     ///
     /// The clock is monotonic, therefore calling this function repeatedly will
     /// produce a sequence of non-decreasing values.
-    now: func() -> instant
+    @since(version = 0.2.0)
+    now: func() -> instant;
 
-    /// Query the resolution of the clock.
-    resolution: func() -> instant
+    /// Query the resolution of the clock. Returns the duration of time
+    /// corresponding to a clock tick.
+    @since(version = 0.2.0)
+    resolution: func() -> duration;
 
-    /// Create a `pollable` which will resolve once the specified time has been
-    /// reached.
-    subscribe: func(
+    /// Create a `pollable` which will resolve once the specified instant
+    /// has occurred.
+    @since(version = 0.2.0)
+    subscribe-instant: func(
         when: instant,
-        absolute: bool
-    ) -> pollable
+    ) -> pollable;
+
+    /// Create a `pollable` that will resolve after the specified duration has
+    /// elapsed from the time this function is invoked.
+    @since(version = 0.2.0)
+    subscribe-duration: func(
+        when: duration,
+    ) -> pollable;
 }
diff --git a/crates/wasi-http/wit/deps/clocks/timezone.wit b/crates/wasi-http/wit/deps/clocks/timezone.wit
index a872bffc7414..212da66821c4 100644
--- a/crates/wasi-http/wit/deps/clocks/timezone.wit
+++ b/crates/wasi-http/wit/deps/clocks/timezone.wit
@@ -1,5 +1,9 @@
+package wasi:clocks@0.2.1;
+
+@unstable(feature = clocks-timezone)
 interface timezone {
-    use wall-clock.{datetime}
+    @unstable(feature = clocks-timezone)
+    use wall-clock.{datetime};
 
     /// Return information needed to display the given `datetime`. This includes
     /// the UTC offset, the time zone name, and a flag indicating whether
@@ -8,15 +12,18 @@ interface timezone {
     /// If the timezone cannot be determined for the given `datetime`, return a
     /// `timezone-display` for `UTC` with a `utc-offset` of 0 and no daylight
     /// saving time.
-    display: func(when: datetime) -> timezone-display
+    @unstable(feature = clocks-timezone)
+    display: func(when: datetime) -> timezone-display;
 
     /// The same as `display`, but only return the UTC offset.
-    utc-offset: func(when: datetime) -> s32
+    @unstable(feature = clocks-timezone)
+    utc-offset: func(when: datetime) -> s32;
 
     /// Information useful for displaying the timezone of a specific `datetime`.
     ///
     /// This information may vary within a single `timezone` to reflect daylight
     /// saving time adjustments.
+    @unstable(feature = clocks-timezone)
     record timezone-display {
         /// The number of seconds difference between UTC time and the local
         /// time of the timezone.
diff --git a/crates/wasi-http/wit/deps/clocks/wall-clock.wit b/crates/wasi-http/wit/deps/clocks/wall-clock.wit
index dae44a7308cd..6be069a32749 100644
--- a/crates/wasi-http/wit/deps/clocks/wall-clock.wit
+++ b/crates/wasi-http/wit/deps/clocks/wall-clock.wit
@@ -1,3 +1,4 @@
+package wasi:clocks@0.2.1;
 /// WASI Wall Clock is a clock API intended to let users query the current
 /// time. The name "wall" makes an analogy to a "clock on the wall", which
 /// is not necessarily monotonic as it may be reset.
@@ -12,8 +13,10 @@
 /// monotonic, making it unsuitable for measuring elapsed time.
 ///
 /// It is intended for reporting the current date and time for humans.
+@since(version = 0.2.0)
 interface wall-clock {
     /// A time and date in seconds plus nanoseconds.
+    @since(version = 0.2.0)
     record datetime {
         seconds: u64,
         nanoseconds: u32,
@@ -32,10 +35,12 @@ interface wall-clock {
     ///
     /// [POSIX's Seconds Since the Epoch]: https://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xbd_chap04.html#tag_21_04_16
     /// [Unix Time]: https://en.wikipedia.org/wiki/Unix_time
-    now: func() -> datetime
+    @since(version = 0.2.0)
+    now: func() -> datetime;
 
     /// Query the resolution of the clock.
     ///
     /// The nanoseconds field of the output is always less than 1000000000.
-    resolution: func() -> datetime
+    @since(version = 0.2.0)
+    resolution: func() -> datetime;
 }
diff --git a/crates/wasi-http/wit/deps/clocks/world.wit b/crates/wasi-http/wit/deps/clocks/world.wit
index 5c2dd411d2d0..9251ac6456e3 100644
--- a/crates/wasi-http/wit/deps/clocks/world.wit
+++ b/crates/wasi-http/wit/deps/clocks/world.wit
@@ -1,7 +1,11 @@
-package wasi:clocks
+package wasi:clocks@0.2.1;
 
+@since(version = 0.2.0)
 world imports {
-    import monotonic-clock
-    import wall-clock
-    import timezone
+    @since(version = 0.2.0)
+    import monotonic-clock;
+    @since(version = 0.2.0)
+    import wall-clock;
+    @unstable(feature = clocks-timezone)
+    import timezone;
 }
diff --git a/crates/wasi-http/wit/deps/filesystem/preopens.wit b/crates/wasi-http/wit/deps/filesystem/preopens.wit
index f45661b8a849..ca2f726af972 100644
--- a/crates/wasi-http/wit/deps/filesystem/preopens.wit
+++ b/crates/wasi-http/wit/deps/filesystem/preopens.wit
@@ -1,6 +1,11 @@
+package wasi:filesystem@0.2.1;
+
+@since(version = 0.2.0)
 interface preopens {
-    use types.{descriptor}
+    @since(version = 0.2.0)
+    use types.{descriptor};
 
     /// Return the set of preopened directories, and their path.
-    get-directories: func() -> list<tuple<descriptor, string>>
+    @since(version = 0.2.0)
+    get-directories: func() -> list<tuple<descriptor, string>>;
 }
diff --git a/crates/wasi-http/wit/deps/filesystem/types.wit b/crates/wasi-http/wit/deps/filesystem/types.wit
index 3f69bf997a29..db3d96867bab 100644
--- a/crates/wasi-http/wit/deps/filesystem/types.wit
+++ b/crates/wasi-http/wit/deps/filesystem/types.wit
@@ -1,3 +1,4 @@
+package wasi:filesystem@0.2.1;
 /// WASI filesystem is a filesystem API primarily intended to let users run WASI
 /// programs that access their files on their existing filesystems, without
 /// significant overhead.
@@ -22,16 +23,21 @@
 /// [WASI filesystem path resolution].
 ///
 /// [WASI filesystem path resolution]: https://github.com/WebAssembly/wasi-filesystem/blob/main/path-resolution.md
+@since(version = 0.2.0)
 interface types {
-    use wasi:io/streams.{input-stream, output-stream}
-    use wasi:clocks/wall-clock.{datetime}
+    @since(version = 0.2.0)
+    use wasi:io/streams@0.2.1.{input-stream, output-stream, error};
+    @since(version = 0.2.0)
+    use wasi:clocks/wall-clock@0.2.1.{datetime};
 
     /// File size or length of a region within a file.
-    type filesize = u64
+    @since(version = 0.2.0)
+    type filesize = u64;
 
     /// The type of a filesystem object referenced by a descriptor.
     ///
     /// Note: This was called `filetype` in earlier versions of WASI.
+    @since(version = 0.2.0)
     enum descriptor-type {
         /// The type of the descriptor or file is unknown or is different from
         /// any of the other types specified.
@@ -55,6 +61,7 @@ interface types {
     /// Descriptor flags.
     ///
     /// Note: This was called `fdflags` in earlier versions of WASI.
+    @since(version = 0.2.0)
     flags descriptor-flags {
         /// Read mode: Data can be read.
         read,
@@ -76,7 +83,7 @@ interface types {
         /// WASI. At this time, it should be interpreted as a request, and not a
         /// requirement.
         data-integrity-sync,
-        /// Requests that reads be performed at the same level of integrety
+        /// Requests that reads be performed at the same level of integrity
         /// requested for writes. This is similar to `O_RSYNC` in POSIX.
         ///
         /// The precise semantics of this operation have not yet been defined for
@@ -98,6 +105,7 @@ interface types {
     /// File attributes.
     ///
     /// Note: This was called `filestat` in earlier versions of WASI.
+    @since(version = 0.2.0)
     record descriptor-stat {
         /// File type.
         %type: descriptor-type,
@@ -124,6 +132,7 @@ interface types {
     }
 
     /// Flags determining the method of how paths are resolved.
+    @since(version = 0.2.0)
     flags path-flags {
         /// As long as the resolved path corresponds to a symbolic link, it is
         /// expanded.
@@ -131,6 +140,7 @@ interface types {
     }
 
     /// Open flags used by `open-at`.
+    @since(version = 0.2.0)
     flags open-flags {
         /// Create file if it does not exist, similar to `O_CREAT` in POSIX.
         create,
@@ -142,33 +152,12 @@ interface types {
         truncate,
     }
 
-    /// Permissions mode used by `open-at`, `change-file-permissions-at`, and
-    /// similar.
-    flags modes {
-        /// True if the resource is considered readable by the containing
-        /// filesystem.
-        readable,
-        /// True if the resource is considered writable by the containing
-        /// filesystem.
-        writable,
-        /// True if the resource is considered executable by the containing
-        /// filesystem. This does not apply to directories.
-        executable,
-    }
-
-    /// Access type used by `access-at`.
-    variant access-type {
-        /// Test for readability, writeability, or executability.
-        access(modes),
-
-        /// Test whether the path exists.
-        exists,
-    }
-
     /// Number of hard links to an inode.
-    type link-count = u64
+    @since(version = 0.2.0)
+    type link-count = u64;
 
     /// When setting a timestamp, this gives the value to set it to.
+    @since(version = 0.2.0)
     variant new-timestamp {
         /// Leave the timestamp set to its previous value.
         no-change,
@@ -270,6 +259,7 @@ interface types {
     }
 
     /// File or memory access pattern advisory information.
+    @since(version = 0.2.0)
     enum advice {
         /// The application has no advice to give on its behavior with respect
         /// to the specified data.
@@ -293,6 +283,7 @@ interface types {
 
     /// A 128-bit hash value, split into parts because wasm doesn't have a
     /// 128-bit integer type.
+    @since(version = 0.2.0)
     record metadata-hash-value {
        /// 64 bits of a 128-bit hash value.
        lower: u64,
@@ -303,6 +294,7 @@ interface types {
     /// A descriptor is a reference to a filesystem object, which may be a file,
     /// directory, named pipe, special file, or other object on which filesystem
     /// calls may be made.
+    @since(version = 0.2.0)
     resource descriptor {
         /// Return a stream for reading from a file, if available.
         ///
@@ -312,10 +304,11 @@ interface types {
         /// file and they do not interfere with each other.
         ///
         /// Note: This allows using `read-stream`, which is similar to `read` in POSIX.
+        @since(version = 0.2.0)
         read-via-stream: func(
             /// The offset within the file at which to start reading.
             offset: filesize,
-        ) -> result<input-stream, error-code>
+        ) -> result<input-stream, error-code>;
 
         /// Return a stream for writing to a file, if available.
         ///
@@ -323,10 +316,11 @@ interface types {
         ///
         /// Note: This allows using `write-stream`, which is similar to `write` in
         /// POSIX.
+        @since(version = 0.2.0)
         write-via-stream: func(
             /// The offset within the file at which to start writing.
             offset: filesize,
-        ) -> result<output-stream, error-code>
+        ) -> result<output-stream, error-code>;
 
         /// Return a stream for appending to a file, if available.
         ///
@@ -334,11 +328,13 @@ interface types {
         ///
         /// Note: This allows using `write-stream`, which is similar to `write` with
         /// `O_APPEND` in in POSIX.
-        append-via-stream: func() -> result<output-stream, error-code>
+        @since(version = 0.2.0)
+        append-via-stream: func() -> result<output-stream, error-code>;
 
         /// Provide file advisory information on a descriptor.
         ///
         /// This is similar to `posix_fadvise` in POSIX.
+        @since(version = 0.2.0)
         advise: func(
             /// The offset within the file to which the advisory applies.
             offset: filesize,
@@ -346,7 +342,7 @@ interface types {
             length: filesize,
             /// The advice.
             advice: advice
-        ) -> result<_, error-code>
+        ) -> result<_, error-code>;
 
         /// Synchronize the data of a file to disk.
         ///
@@ -354,7 +350,8 @@ interface types {
         /// opened for writing.
         ///
         /// Note: This is similar to `fdatasync` in POSIX.
-        sync-data: func() -> result<_, error-code>
+        @since(version = 0.2.0)
+        sync-data: func() -> result<_, error-code>;
 
         /// Get flags associated with a descriptor.
         ///
@@ -362,7 +359,8 @@ interface types {
         ///
         /// Note: This returns the value that was the `fs_flags` value returned
         /// from `fdstat_get` in earlier versions of WASI.
-        get-flags: func() -> result<descriptor-flags, error-code>
+        @since(version = 0.2.0)
+        get-flags: func() -> result<descriptor-flags, error-code>;
 
         /// Get the dynamic type of a descriptor.
         ///
@@ -374,25 +372,28 @@ interface types {
         ///
         /// Note: This returns the value that was the `fs_filetype` value returned
         /// from `fdstat_get` in earlier versions of WASI.
-        get-type: func() -> result<descriptor-type, error-code>
+        @since(version = 0.2.0)
+        get-type: func() -> result<descriptor-type, error-code>;
 
         /// Adjust the size of an open file. If this increases the file's size, the
         /// extra bytes are filled with zeros.
         ///
         /// Note: This was called `fd_filestat_set_size` in earlier versions of WASI.
-        set-size: func(size: filesize) -> result<_, error-code>
+        @since(version = 0.2.0)
+        set-size: func(size: filesize) -> result<_, error-code>;
 
         /// Adjust the timestamps of an open file or directory.
         ///
         /// Note: This is similar to `futimens` in POSIX.
         ///
         /// Note: This was called `fd_filestat_set_times` in earlier versions of WASI.
+        @since(version = 0.2.0)
         set-times: func(
             /// The desired values of the data access timestamp.
             data-access-timestamp: new-timestamp,
             /// The desired values of the data modification timestamp.
             data-modification-timestamp: new-timestamp,
-        ) -> result<_, error-code>
+        ) -> result<_, error-code>;
 
         /// Read from a descriptor, without using and updating the descriptor's offset.
         ///
@@ -405,12 +406,13 @@ interface types {
         /// In the future, this may change to return a `stream<u8, error-code>`.
         ///
         /// Note: This is similar to `pread` in POSIX.
+        @since(version = 0.2.0)
         read: func(
             /// The maximum number of bytes to read.
             length: filesize,
             /// The offset within the file at which to read.
             offset: filesize,
-        ) -> result<tuple<list<u8>, bool>, error-code>
+        ) -> result<tuple<list<u8>, bool>, error-code>;
 
         /// Write to a descriptor, without using and updating the descriptor's offset.
         ///
@@ -421,12 +423,13 @@ interface types {
         /// In the future, this may change to take a `stream<u8, error-code>`.
         ///
         /// Note: This is similar to `pwrite` in POSIX.
+        @since(version = 0.2.0)
         write: func(
             /// Data to write
             buffer: list<u8>,
             /// The offset within the file at which to write.
             offset: filesize,
-        ) -> result<filesize, error-code>
+        ) -> result<filesize, error-code>;
 
         /// Read directory entries from a directory.
         ///
@@ -437,7 +440,8 @@ interface types {
         /// This always returns a new stream which starts at the beginning of the
         /// directory. Multiple streams may be active on the same directory, and they
         /// do not interfere with each other.
-        read-directory: func() -> result<directory-entry-stream, error-code>
+        @since(version = 0.2.0)
+        read-directory: func() -> result<directory-entry-stream, error-code>;
 
         /// Synchronize the data and metadata of a file to disk.
         ///
@@ -445,15 +449,17 @@ interface types {
         /// opened for writing.
         ///
         /// Note: This is similar to `fsync` in POSIX.
-        sync: func() -> result<_, error-code>
+        @since(version = 0.2.0)
+        sync: func() -> result<_, error-code>;
 
         /// Create a directory.
         ///
         /// Note: This is similar to `mkdirat` in POSIX.
+        @since(version = 0.2.0)
         create-directory-at: func(
             /// The relative path at which to create the directory.
             path: string,
-        ) -> result<_, error-code>
+        ) -> result<_, error-code>;
 
         /// Return the attributes of an open file or directory.
         ///
@@ -464,7 +470,8 @@ interface types {
         /// modified, use `metadata-hash`.
         ///
         /// Note: This was called `fd_filestat_get` in earlier versions of WASI.
-        stat: func() -> result<descriptor-stat, error-code>
+        @since(version = 0.2.0)
+        stat: func() -> result<descriptor-stat, error-code>;
 
         /// Return the attributes of a file or directory.
         ///
@@ -473,12 +480,13 @@ interface types {
         /// discussion of alternatives.
         ///
         /// Note: This was called `path_filestat_get` in earlier versions of WASI.
+        @since(version = 0.2.0)
         stat-at: func(
             /// Flags determining the method of how the path is resolved.
             path-flags: path-flags,
             /// The relative path of the file or directory to inspect.
             path: string,
-        ) -> result<descriptor-stat, error-code>
+        ) -> result<descriptor-stat, error-code>;
 
         /// Adjust the timestamps of a file or directory.
         ///
@@ -486,6 +494,7 @@ interface types {
         ///
         /// Note: This was called `path_filestat_set_times` in earlier versions of
         /// WASI.
+        @since(version = 0.2.0)
         set-times-at: func(
             /// Flags determining the method of how the path is resolved.
             path-flags: path-flags,
@@ -495,11 +504,12 @@ interface types {
             data-access-timestamp: new-timestamp,
             /// The desired values of the data modification timestamp.
             data-modification-timestamp: new-timestamp,
-        ) -> result<_, error-code>
+        ) -> result<_, error-code>;
 
         /// Create a hard link.
         ///
         /// Note: This is similar to `linkat` in POSIX.
+        @since(version = 0.2.0)
         link-at: func(
             /// Flags determining the method of how the path is resolved.
             old-path-flags: path-flags,
@@ -509,7 +519,7 @@ interface types {
             new-descriptor: borrow<descriptor>,
             /// The relative destination path at which to create the hard link.
             new-path: string,
-        ) -> result<_, error-code>
+        ) -> result<_, error-code>;
 
         /// Open a file or directory.
         ///
@@ -529,6 +539,7 @@ interface types {
         /// `error-code::read-only`.
         ///
         /// Note: This is similar to `openat` in POSIX.
+        @since(version = 0.2.0)
         open-at: func(
             /// Flags determining the method of how the path is resolved.
             path-flags: path-flags,
@@ -538,9 +549,7 @@ interface types {
             open-flags: open-flags,
             /// Flags to use for the resulting descriptor.
             %flags: descriptor-flags,
-            /// Permissions to use when creating a new file.
-            modes: modes
-        ) -> result<descriptor, error-code>
+        ) -> result<descriptor, error-code>;
 
         /// Read the contents of a symbolic link.
         ///
@@ -548,24 +557,27 @@ interface types {
         /// filesystem, this function fails with `error-code::not-permitted`.
         ///
         /// Note: This is similar to `readlinkat` in POSIX.
+        @since(version = 0.2.0)
         readlink-at: func(
             /// The relative path of the symbolic link from which to read.
             path: string,
-        ) -> result<string, error-code>
+        ) -> result<string, error-code>;
 
         /// Remove a directory.
         ///
         /// Return `error-code::not-empty` if the directory is not empty.
         ///
         /// Note: This is similar to `unlinkat(fd, path, AT_REMOVEDIR)` in POSIX.
+        @since(version = 0.2.0)
         remove-directory-at: func(
             /// The relative path to a directory to remove.
             path: string,
-        ) -> result<_, error-code>
+        ) -> result<_, error-code>;
 
         /// Rename a filesystem object.
         ///
         /// Note: This is similar to `renameat` in POSIX.
+        @since(version = 0.2.0)
         rename-at: func(
             /// The relative source path of the file or directory to rename.
             old-path: string,
@@ -573,7 +585,7 @@ interface types {
             new-descriptor: borrow<descriptor>,
             /// The relative destination path to which to rename the file or directory.
             new-path: string,
-        ) -> result<_, error-code>
+        ) -> result<_, error-code>;
 
         /// Create a symbolic link (also known as a "symlink").
         ///
@@ -581,173 +593,23 @@ interface types {
         /// `error-code::not-permitted`.
         ///
         /// Note: This is similar to `symlinkat` in POSIX.
+        @since(version = 0.2.0)
         symlink-at: func(
             /// The contents of the symbolic link.
             old-path: string,
             /// The relative destination path at which to create the symbolic link.
             new-path: string,
-        ) -> result<_, error-code>
-
-        /// Check accessibility of a filesystem path.
-        ///
-        /// Check whether the given filesystem path names an object which is
-        /// readable, writable, or executable, or whether it exists.
-        ///
-        /// This does not a guarantee that subsequent accesses will succeed, as
-        /// filesystem permissions may be modified asynchronously by external
-        /// entities.
-        ///
-        /// Note: This is similar to `faccessat` with the `AT_EACCESS` flag in POSIX.
-        access-at: func(
-            /// Flags determining the method of how the path is resolved.
-            path-flags: path-flags,
-            /// The relative path to check.
-            path: string,
-            /// The type of check to perform.
-            %type: access-type
-        ) -> result<_, error-code>
+        ) -> result<_, error-code>;
 
         /// Unlink a filesystem object that is not a directory.
         ///
         /// Return `error-code::is-directory` if the path refers to a directory.
         /// Note: This is similar to `unlinkat(fd, path, 0)` in POSIX.
+        @since(version = 0.2.0)
         unlink-file-at: func(
             /// The relative path to a file to unlink.
             path: string,
-        ) -> result<_, error-code>
-
-        /// Change the permissions of a filesystem object that is not a directory.
-        ///
-        /// Note that the ultimate meanings of these permissions is
-        /// filesystem-specific.
-        ///
-        /// Note: This is similar to `fchmodat` in POSIX.
-        change-file-permissions-at: func(
-            /// Flags determining the method of how the path is resolved.
-            path-flags: path-flags,
-            /// The relative path to operate on.
-            path: string,
-            /// The new permissions for the filesystem object.
-            modes: modes,
-        ) -> result<_, error-code>
-
-        /// Change the permissions of a directory.
-        ///
-        /// Note that the ultimate meanings of these permissions is
-        /// filesystem-specific.
-        ///
-        /// Unlike in POSIX, the `executable` flag is not reinterpreted as a "search"
-        /// flag. `read` on a directory implies readability and searchability, and
-        /// `execute` is not valid for directories.
-        ///
-        /// Note: This is similar to `fchmodat` in POSIX.
-        change-directory-permissions-at: func(
-            /// Flags determining the method of how the path is resolved.
-            path-flags: path-flags,
-            /// The relative path to operate on.
-            path: string,
-            /// The new permissions for the directory.
-            modes: modes,
-        ) -> result<_, error-code>
-
-        /// Request a shared advisory lock for an open file.
-        ///
-        /// This requests a *shared* lock; more than one shared lock can be held for
-        /// a file at the same time.
-        ///
-        /// If the open file has an exclusive lock, this function downgrades the lock
-        /// to a shared lock. If it has a shared lock, this function has no effect.
-        ///
-        /// This requests an *advisory* lock, meaning that the file could be accessed
-        /// by other programs that don't hold the lock.
-        ///
-        /// It is unspecified how shared locks interact with locks acquired by
-        /// non-WASI programs.
-        ///
-        /// This function blocks until the lock can be acquired.
-        ///
-        /// Not all filesystems support locking; on filesystems which don't support
-        /// locking, this function returns `error-code::unsupported`.
-        ///
-        /// Note: This is similar to `flock(fd, LOCK_SH)` in Unix.
-        lock-shared: func() -> result<_, error-code>
-
-        /// Request an exclusive advisory lock for an open file.
-        ///
-        /// This requests an *exclusive* lock; no other locks may be held for the
-        /// file while an exclusive lock is held.
-        ///
-        /// If the open file has a shared lock and there are no exclusive locks held
-        /// for the file, this function upgrades the lock to an exclusive lock. If the
-        /// open file already has an exclusive lock, this function has no effect.
-        ///
-        /// This requests an *advisory* lock, meaning that the file could be accessed
-        /// by other programs that don't hold the lock.
-        ///
-        /// It is unspecified whether this function succeeds if the file descriptor
-        /// is not opened for writing. It is unspecified how exclusive locks interact
-        /// with locks acquired by non-WASI programs.
-        ///
-        /// This function blocks until the lock can be acquired.
-        ///
-        /// Not all filesystems support locking; on filesystems which don't support
-        /// locking, this function returns `error-code::unsupported`.
-        ///
-        /// Note: This is similar to `flock(fd, LOCK_EX)` in Unix.
-        lock-exclusive: func() -> result<_, error-code>
-
-        /// Request a shared advisory lock for an open file.
-        ///
-        /// This requests a *shared* lock; more than one shared lock can be held for
-        /// a file at the same time.
-        ///
-        /// If the open file has an exclusive lock, this function downgrades the lock
-        /// to a shared lock. If it has a shared lock, this function has no effect.
-        ///
-        /// This requests an *advisory* lock, meaning that the file could be accessed
-        /// by other programs that don't hold the lock.
-        ///
-        /// It is unspecified how shared locks interact with locks acquired by
-        /// non-WASI programs.
-        ///
-        /// This function returns `error-code::would-block` if the lock cannot be
-        /// acquired.
-        ///
-        /// Not all filesystems support locking; on filesystems which don't support
-        /// locking, this function returns `error-code::unsupported`.
-        ///
-        /// Note: This is similar to `flock(fd, LOCK_SH | LOCK_NB)` in Unix.
-        try-lock-shared: func() -> result<_, error-code>
-
-        /// Request an exclusive advisory lock for an open file.
-        ///
-        /// This requests an *exclusive* lock; no other locks may be held for the
-        /// file while an exclusive lock is held.
-        ///
-        /// If the open file has a shared lock and there are no exclusive locks held
-        /// for the file, this function upgrades the lock to an exclusive lock. If the
-        /// open file already has an exclusive lock, this function has no effect.
-        ///
-        /// This requests an *advisory* lock, meaning that the file could be accessed
-        /// by other programs that don't hold the lock.
-        ///
-        /// It is unspecified whether this function succeeds if the file descriptor
-        /// is not opened for writing. It is unspecified how exclusive locks interact
-        /// with locks acquired by non-WASI programs.
-        ///
-        /// This function returns `error-code::would-block` if the lock cannot be
-        /// acquired.
-        ///
-        /// Not all filesystems support locking; on filesystems which don't support
-        /// locking, this function returns `error-code::unsupported`.
-        ///
-        /// Note: This is similar to `flock(fd, LOCK_EX | LOCK_NB)` in Unix.
-        try-lock-exclusive: func() -> result<_, error-code>
-
-        /// Release a shared or exclusive lock on an open file.
-        ///
-        /// Note: This is similar to `flock(fd, LOCK_UN)` in Unix.
-        unlock: func() -> result<_, error-code>
+        ) -> result<_, error-code>;
 
         /// Test whether two descriptors refer to the same filesystem object.
         ///
@@ -755,7 +617,8 @@ interface types {
         /// same device (`st_dev`) and inode (`st_ino` or `d_ino`) numbers.
         /// wasi-filesystem does not expose device and inode numbers, so this function
         /// may be used instead.
-        is-same-object: func(other: borrow<descriptor>) -> bool
+        @since(version = 0.2.0)
+        is-same-object: func(other: borrow<descriptor>) -> bool;
 
         /// Return a hash of the metadata associated with a filesystem object referred
         /// to by a descriptor.
@@ -776,23 +639,40 @@ interface types {
         ///    computed hash.
         ///
         /// However, none of these is required.
-        metadata-hash: func() -> result<metadata-hash-value, error-code>
+        @since(version = 0.2.0)
+        metadata-hash: func() -> result<metadata-hash-value, error-code>;
 
         /// Return a hash of the metadata associated with a filesystem object referred
         /// to by a directory descriptor and a relative path.
         ///
         /// This performs the same hash computation as `metadata-hash`.
+        @since(version = 0.2.0)
         metadata-hash-at: func(
             /// Flags determining the method of how the path is resolved.
             path-flags: path-flags,
             /// The relative path of the file or directory to inspect.
             path: string,
-        ) -> result<metadata-hash-value, error-code>
+        ) -> result<metadata-hash-value, error-code>;
     }
 
     /// A stream of directory entries.
+    @since(version = 0.2.0)
     resource directory-entry-stream {
         /// Read a single directory entry from a `directory-entry-stream`.
-        read-directory-entry: func() -> result<option<directory-entry>, error-code>
+        @since(version = 0.2.0)
+        read-directory-entry: func() -> result<option<directory-entry>, error-code>;
     }
+
+    /// Attempts to extract a filesystem-related `error-code` from the stream
+    /// `error` provided.
+    ///
+    /// Stream operations which return `stream-error::last-operation-failed`
+    /// have a payload with more information about the operation that failed.
+    /// This payload can be passed through to this function to see if there's
+    /// filesystem-related information about the error to return.
+    ///
+    /// Note that this function is fallible because not all stream-related
+    /// errors are filesystem-related errors.
+    @since(version = 0.2.0)
+    filesystem-error-code: func(err: borrow<error>) -> option<error-code>;
 }
diff --git a/crates/wasi-http/wit/deps/filesystem/world.wit b/crates/wasi-http/wit/deps/filesystem/world.wit
index 5fa7eafdb850..af0146cbc95b 100644
--- a/crates/wasi-http/wit/deps/filesystem/world.wit
+++ b/crates/wasi-http/wit/deps/filesystem/world.wit
@@ -1,6 +1,9 @@
-package wasi:filesystem
+package wasi:filesystem@0.2.1;
 
+@since(version = 0.2.0)
 world imports {
-    import types
-    import preopens
+    @since(version = 0.2.0)
+    import types;
+    @since(version = 0.2.0)
+    import preopens;
 }
diff --git a/crates/wasi-http/wit/deps/http/handler.wit b/crates/wasi-http/wit/deps/http/handler.wit
new file mode 100644
index 000000000000..6a6c62966f11
--- /dev/null
+++ b/crates/wasi-http/wit/deps/http/handler.wit
@@ -0,0 +1,49 @@
+/// This interface defines a handler of incoming HTTP Requests. It should
+/// be exported by components which can respond to HTTP Requests.
+@since(version = 0.2.0)
+interface incoming-handler {
+  @since(version = 0.2.0)
+  use types.{incoming-request, response-outparam};
+
+  /// This function is invoked with an incoming HTTP Request, and a resource
+  /// `response-outparam` which provides the capability to reply with an HTTP
+  /// Response. The response is sent by calling the `response-outparam.set`
+  /// method, which allows execution to continue after the response has been
+  /// sent. This enables both streaming to the response body, and performing other
+  /// work.
+  ///
+  /// The implementor of this function must write a response to the
+  /// `response-outparam` before returning, or else the caller will respond
+  /// with an error on its behalf.
+  @since(version = 0.2.0)
+  handle: func(
+    request: incoming-request,
+    response-out: response-outparam
+  );
+}
+
+/// This interface defines a handler of outgoing HTTP Requests. It should be
+/// imported by components which wish to make HTTP Requests.
+@since(version = 0.2.0)
+interface outgoing-handler {
+  @since(version = 0.2.0)
+  use types.{
+    outgoing-request, request-options, future-incoming-response, error-code
+  };
+
+  /// This function is invoked with an outgoing HTTP Request, and it returns
+  /// a resource `future-incoming-response` which represents an HTTP Response
+  /// which may arrive in the future.
+  ///
+  /// The `options` argument accepts optional parameters for the HTTP
+  /// protocol's transport layer.
+  ///
+  /// This function may return an error if the `outgoing-request` is invalid
+  /// or not allowed to be made. Otherwise, protocol errors are reported
+  /// through the `future-incoming-response`.
+  @since(version = 0.2.0)
+  handle: func(
+    request: outgoing-request,
+    options: option<request-options>
+  ) -> result<future-incoming-response, error-code>;
+}
diff --git a/crates/wasi-http/wit/deps/http/incoming-handler.wit b/crates/wasi-http/wit/deps/http/incoming-handler.wit
deleted file mode 100644
index ad8a43f8ccf0..000000000000
--- a/crates/wasi-http/wit/deps/http/incoming-handler.wit
+++ /dev/null
@@ -1,24 +0,0 @@
-// The `wasi:http/incoming-handler` interface is meant to be exported by
-// components and called by the host in response to a new incoming HTTP
-// response.
-//
-//   NOTE: in Preview3, this interface will be merged with
-//   `wasi:http/outgoing-handler` into a single `wasi:http/handler` interface
-//   that takes a `request` parameter and returns a `response` result.
-//
-interface incoming-handler {
-  use types.{incoming-request, response-outparam}
-
-  // The `handle` function takes an outparam instead of returning its response
-  // so that the component may stream its response while streaming any other
-  // request or response bodies. The callee MUST write a response to the
-  // `response-outparam` and then finish the response before returning. The `handle`
-  // function is allowed to continue execution after finishing the response's
-  // output stream. While this post-response execution is taken off the
-  // critical path, since there is no return value, there is no way to report
-  // its success or failure.
-  handle: func(
-    request: /* own */ incoming-request,
-    response-out: /* own */ response-outparam
-  )
-}
diff --git a/crates/wasi-http/wit/deps/http/outgoing-handler.wit b/crates/wasi-http/wit/deps/http/outgoing-handler.wit
deleted file mode 100644
index 43bd0035fc06..000000000000
--- a/crates/wasi-http/wit/deps/http/outgoing-handler.wit
+++ /dev/null
@@ -1,20 +0,0 @@
-// The `wasi:http/outgoing-handler` interface is meant to be imported by
-// components and implemented by the host.
-//
-//   NOTE: in Preview3, this interface will be merged with
-//   `wasi:http/outgoing-handler` into a single `wasi:http/handler` interface
-//   that takes a `request` parameter and returns a `response` result.
-//
-interface outgoing-handler {
-  use types.{outgoing-request, request-options, future-incoming-response, error}
-
-  // The parameter and result types of the `handle` function allow the caller
-  // to concurrently stream the bodies of the outgoing request and the incoming
-  // response.
-  // Consumes the outgoing-request. Gives an error if the outgoing-request
-  // is invalid or cannot be satisfied by this handler.
-  handle: func(
-    request: /* own */ outgoing-request,
-    options: option<request-options>
-  ) -> result<future-incoming-response, error>
-}
diff --git a/crates/wasi-http/wit/deps/http/proxy.wit b/crates/wasi-http/wit/deps/http/proxy.wit
index 162ab32b2348..415d2ee1cbcc 100644
--- a/crates/wasi-http/wit/deps/http/proxy.wit
+++ b/crates/wasi-http/wit/deps/http/proxy.wit
@@ -1,34 +1,50 @@
-package wasi:http
+package wasi:http@0.2.1;
 
-// The `wasi:http/proxy` world captures a widely-implementable intersection of
-// hosts that includes HTTP forward and reverse proxies. Components targeting
-// this world may concurrently stream in and out any number of incoming and
-// outgoing HTTP requests.
-world proxy {
-  // HTTP proxies have access to time and randomness.
-  import wasi:clocks/wall-clock
-  import wasi:clocks/monotonic-clock
-  import wasi:clocks/timezone
-  import wasi:random/random
+/// The `wasi:http/imports` world imports all the APIs for HTTP proxies.
+/// It is intended to be `include`d in other worlds.
+@since(version = 0.2.0)
+world imports {
+  /// HTTP proxies have access to time and randomness.
+  @since(version = 0.2.0)
+  import wasi:clocks/monotonic-clock@0.2.1;
+  @since(version = 0.2.0)
+  import wasi:clocks/wall-clock@0.2.1;
+  @since(version = 0.2.0)
+  import wasi:random/random@0.2.1;
+
+  /// Proxies have standard output and error streams which are expected to
+  /// terminate in a developer-facing console provided by the host.
+  @since(version = 0.2.0)
+  import wasi:cli/stdout@0.2.1;
+  @since(version = 0.2.0)
+  import wasi:cli/stderr@0.2.1;
 
-  // Proxies have standard output and error streams which are expected to
-  // terminate in a developer-facing console provided by the host.
-  import wasi:cli/stdout
-  import wasi:cli/stderr
+  /// TODO: this is a temporary workaround until component tooling is able to
+  /// gracefully handle the absence of stdin. Hosts must return an eof stream
+  /// for this import, which is what wasi-libc + tooling will do automatically
+  /// when this import is properly removed.
+  @since(version = 0.2.0)
+  import wasi:cli/stdin@0.2.1;
 
-  // TODO: this is a temporary workaround until component tooling is able to
-  // gracefully handle the absence of stdin. Hosts must return an eof stream
-  // for this import, which is what wasi-libc + tooling will do automatically
-  // when this import is properly removed.
-  import wasi:cli/stdin
+  /// This is the default handler to use when user code simply wants to make an
+  /// HTTP request (e.g., via `fetch()`).
+  @since(version = 0.2.0)
+  import outgoing-handler;
+}
 
-  // This is the default handler to use when user code simply wants to make an
-  // HTTP request (e.g., via `fetch()`).
-  import outgoing-handler
+/// The `wasi:http/proxy` world captures a widely-implementable intersection of
+/// hosts that includes HTTP forward and reverse proxies. Components targeting
+/// this world may concurrently stream in and out any number of incoming and
+/// outgoing HTTP requests.
+@since(version = 0.2.0)
+world proxy {
+  @since(version = 0.2.0)
+  include imports;
 
-  // The host delivers incoming HTTP requests to a component by calling the
-  // `handle` function of this exported interface. A host may arbitrarily reuse
-  // or not reuse component instance when delivering incoming HTTP requests and
-  // thus a component must be able to handle 0..N calls to `handle`.
-  export incoming-handler
+  /// The host delivers incoming HTTP requests to a component by calling the
+  /// `handle` function of this exported interface. A host may arbitrarily reuse
+  /// or not reuse component instance when delivering incoming HTTP requests and
+  /// thus a component must be able to handle 0..N calls to `handle`.
+  @since(version = 0.2.0)
+  export incoming-handler;
 }
diff --git a/crates/wasi-http/wit/deps/http/types.wit b/crates/wasi-http/wit/deps/http/types.wit
index aa486f3c7c7c..3c45cd08b7d3 100644
--- a/crates/wasi-http/wit/deps/http/types.wit
+++ b/crates/wasi-http/wit/deps/http/types.wit
@@ -1,11 +1,19 @@
-// The `wasi:http/types` interface is meant to be imported by components to
-// define the HTTP resource types and operations used by the component's
-// imported and exported interfaces.
+/// This interface defines all of the types and methods for implementing
+/// HTTP Requests and Responses, both incoming and outgoing, as well as
+/// their headers, trailers, and bodies.
+@since(version = 0.2.0)
 interface types {
-  use wasi:io/streams.{input-stream, output-stream}
-  use wasi:io/poll.{pollable}
-
-  // This type corresponds to HTTP standard Methods.
+  @since(version = 0.2.0)
+  use wasi:clocks/monotonic-clock@0.2.1.{duration};
+  @since(version = 0.2.0)
+  use wasi:io/streams@0.2.1.{input-stream, output-stream};
+  @since(version = 0.2.0)
+  use wasi:io/error@0.2.1.{error as io-error};
+  @since(version = 0.2.0)
+  use wasi:io/poll@0.2.1.{pollable};
+
+  /// This type corresponds to HTTP standard Methods.
+  @since(version = 0.2.0)
   variant method {
     get,
     head,
@@ -19,196 +27,629 @@ interface types {
     other(string)
   }
 
-  // This type corresponds to HTTP standard Related Schemes.
+  /// This type corresponds to HTTP standard Related Schemes.
+  @since(version = 0.2.0)
   variant scheme {
     HTTP,
     HTTPS,
     other(string)
   }
 
-  // TODO: perhaps better align with HTTP semantics?
-  // This type enumerates the different kinds of errors that may occur when
-  // initially returning a response.
-  variant error {
-    invalid-url(string),
-    timeout-error(string),
-    protocol-error(string),
-    unexpected-error(string)
+  /// These cases are inspired by the IANA HTTP Proxy Error Types:
+  ///   https://www.iana.org/assignments/http-proxy-status/http-proxy-status.xhtml#table-http-proxy-error-types
+  @since(version = 0.2.0)
+  variant error-code {
+    DNS-timeout,
+    DNS-error(DNS-error-payload),
+    destination-not-found,
+    destination-unavailable,
+    destination-IP-prohibited,
+    destination-IP-unroutable,
+    connection-refused,
+    connection-terminated,
+    connection-timeout,
+    connection-read-timeout,
+    connection-write-timeout,
+    connection-limit-reached,
+    TLS-protocol-error,
+    TLS-certificate-error,
+    TLS-alert-received(TLS-alert-received-payload),
+    HTTP-request-denied,
+    HTTP-request-length-required,
+    HTTP-request-body-size(option<u64>),
+    HTTP-request-method-invalid,
+    HTTP-request-URI-invalid,
+    HTTP-request-URI-too-long,
+    HTTP-request-header-section-size(option<u32>),
+    HTTP-request-header-size(option<field-size-payload>),
+    HTTP-request-trailer-section-size(option<u32>),
+    HTTP-request-trailer-size(field-size-payload),
+    HTTP-response-incomplete,
+    HTTP-response-header-section-size(option<u32>),
+    HTTP-response-header-size(field-size-payload),
+    HTTP-response-body-size(option<u64>),
+    HTTP-response-trailer-section-size(option<u32>),
+    HTTP-response-trailer-size(field-size-payload),
+    HTTP-response-transfer-coding(option<string>),
+    HTTP-response-content-coding(option<string>),
+    HTTP-response-timeout,
+    HTTP-upgrade-failed,
+    HTTP-protocol-error,
+    loop-detected,
+    configuration-error,
+    /// This is a catch-all error for anything that doesn't fit cleanly into a
+    /// more specific case. It also includes an optional string for an
+    /// unstructured description of the error. Users should not depend on the
+    /// string for diagnosing errors, as it's not required to be consistent
+    /// between implementations.
+    internal-error(option<string>)
   }
 
-  // This following block defines the `fields` resource which corresponds to
-  // HTTP standard Fields. Soon, when resource types are added, the `type
-  // fields = u32` type alias can be replaced by a proper `resource fields`
-  // definition containing all the functions using the method syntactic sugar.
-  resource fields {
-    // Multiple values for a header are multiple entries in the list with the
-    // same key.
-    constructor(entries: list<tuple<string,list<u8>>>)
-
-    // Values off wire are not necessarily well formed, so they are given by
-    // list<u8> instead of string.
-    get: func(name: string) -> list<list<u8>>
-
-    // Values off wire are not necessarily well formed, so they are given by
-    // list<u8> instead of string.
-    set: func(name: string, value: list<list<u8>>)
-    delete: func(name: string)
-    append: func(name: string, value: list<u8>)
-
-    // Values off wire are not necessarily well formed, so they are given by
-    // list<u8> instead of string.
-    entries: func() -> list<tuple<string,list<u8>>>
-
-    // Deep copy of all contents in a fields.
-    clone: func() -> fields
-  }
-
-  type headers = fields
-  type trailers = fields
-
-  // The following block defines the `incoming-request` and `outgoing-request`
-  // resource types that correspond to HTTP standard Requests. Soon, when
-  // resource types are added, the `u32` type aliases can be replaced by
-  // proper `resource` type definitions containing all the functions as
-  // methods. Later, Preview2 will allow both types to be merged together into
-  // a single `request` type (that uses the single `stream` type mentioned
-  // above). The `consume` and `write` methods may only be called once (and
-  // return failure thereafter).
-  resource incoming-request {
-    method: func() -> method
+  /// Defines the case payload type for `DNS-error` above:
+  @since(version = 0.2.0)
+  record DNS-error-payload {
+    rcode: option<string>,
+    info-code: option<u16>
+  }
 
-    path-with-query: func() -> option<string>
+  /// Defines the case payload type for `TLS-alert-received` above:
+  @since(version = 0.2.0)
+  record TLS-alert-received-payload {
+    alert-id: option<u8>,
+    alert-message: option<string>
+  }
 
-    scheme: func() -> option<scheme>
+  /// Defines the case payload type for `HTTP-response-{header,trailer}-size` above:
+  @since(version = 0.2.0)
+  record field-size-payload {
+    field-name: option<string>,
+    field-size: option<u32>
+  }
 
-    authority: func() -> option<string>
+  /// Attempts to extract a http-related `error` from the wasi:io `error`
+  /// provided.
+  ///
+  /// Stream operations which return
+  /// `wasi:io/stream/stream-error::last-operation-failed` have a payload of
+  /// type `wasi:io/error/error` with more information about the operation
+  /// that failed. This payload can be passed through to this function to see
+  /// if there's http-related information about the error to return.
+  ///
+  /// Note that this function is fallible because not all io-errors are
+  /// http-related errors.
+  @since(version = 0.2.0)
+  http-error-code: func(err: borrow<io-error>) -> option<error-code>;
+
+  /// This type enumerates the different kinds of errors that may occur when
+  /// setting or appending to a `fields` resource.
+  @since(version = 0.2.0)
+  variant header-error {
+    /// This error indicates that a `field-key` or `field-value` was
+    /// syntactically invalid when used with an operation that sets headers in a
+    /// `fields`.
+    invalid-syntax,
+
+    /// This error indicates that a forbidden `field-key` was used when trying
+    /// to set a header in a `fields`.
+    forbidden,
+
+    /// This error indicates that the operation on the `fields` was not
+    /// permitted because the fields are immutable.
+    immutable,
+  }
 
-    headers: func() -> /* child */ headers
-    // Will return the input-stream child at most once. If called more than
-    // once, subsequent calls will return error.
+  /// Field keys are always strings.
+  @since(version = 0.2.0)
+  type field-key = string;
+
+  /// Field values should always be ASCII strings. However, in
+  /// reality, HTTP implementations often have to interpret malformed values,
+  /// so they are provided as a list of bytes.
+  @since(version = 0.2.0)
+  type field-value = list<u8>;
+
+  /// This following block defines the `fields` resource which corresponds to
+  /// HTTP standard Fields. Fields are a common representation used for both
+  /// Headers and Trailers.
+  ///
+  /// A `fields` may be mutable or immutable. A `fields` created using the
+  /// constructor, `from-list`, or `clone` will be mutable, but a `fields`
+  /// resource given by other means (including, but not limited to,
+  /// `incoming-request.headers`, `outgoing-request.headers`) might be be
+  /// immutable. In an immutable fields, the `set`, `append`, and `delete`
+  /// operations will fail with `header-error.immutable`.
+  @since(version = 0.2.0)
+  resource fields {
 
-    consume: func() -> result< /* own */ incoming-body>
+    /// Construct an empty HTTP Fields.
+    ///
+    /// The resulting `fields` is mutable.
+    @since(version = 0.2.0)
+    constructor();
+
+    /// Construct an HTTP Fields.
+    ///
+    /// The resulting `fields` is mutable.
+    ///
+    /// The list represents each key-value pair in the Fields. Keys
+    /// which have multiple values are represented by multiple entries in this
+    /// list with the same key.
+    ///
+    /// The tuple is a pair of the field key, represented as a string, and
+    /// Value, represented as a list of bytes.
+    ///
+    /// An error result will be returned if any `field-key` or `field-value` is
+    /// syntactically invalid, or if a field is forbidden.
+    @since(version = 0.2.0)
+    from-list: static func(
+      entries: list<tuple<field-key,field-value>>
+    ) -> result<fields, header-error>;
+
+    /// Get all of the values corresponding to a key. If the key is not present
+    /// in this `fields` or is syntactically invalid, an empty list is returned.
+    /// However, if the key is present but empty, this is represented by a list
+    /// with one or more empty field-values present.
+    @since(version = 0.2.0)
+    get: func(name: field-key) -> list<field-value>;
+
+    /// Returns `true` when the key is present in this `fields`. If the key is
+    /// syntactically invalid, `false` is returned.
+    @since(version = 0.2.0)
+    has: func(name: field-key) -> bool;
+
+    /// Set all of the values for a key. Clears any existing values for that
+    /// key, if they have been set.
+    ///
+    /// Fails with `header-error.immutable` if the `fields` are immutable.
+    ///
+    /// Fails with `header-error.invalid-syntax` if the `field-key` or any of
+    /// the `field-value`s are syntactically invalid.
+    @since(version = 0.2.0)
+    set: func(name: field-key, value: list<field-value>) -> result<_, header-error>;
+
+    /// Delete all values for a key. Does nothing if no values for the key
+    /// exist.
+    ///
+    /// Fails with `header-error.immutable` if the `fields` are immutable.
+    ///
+    /// Fails with `header-error.invalid-syntax` if the `field-key` is
+    /// syntactically invalid.
+    @since(version = 0.2.0)
+    delete: func(name: field-key) -> result<_, header-error>;
+
+    /// Append a value for a key. Does not change or delete any existing
+    /// values for that key.
+    ///
+    /// Fails with `header-error.immutable` if the `fields` are immutable.
+    ///
+    /// Fails with `header-error.invalid-syntax` if the `field-key` or
+    /// `field-value` are syntactically invalid.
+    @since(version = 0.2.0)
+    append: func(name: field-key, value: field-value) -> result<_, header-error>;
+
+    /// Retrieve the full set of keys and values in the Fields. Like the
+    /// constructor, the list represents each key-value pair.
+    ///
+    /// The outer list represents each key-value pair in the Fields. Keys
+    /// which have multiple values are represented by multiple entries in this
+    /// list with the same key.
+    @since(version = 0.2.0)
+    entries: func() -> list<tuple<field-key,field-value>>;
+
+    /// Make a deep copy of the Fields. Equivalent in behavior to calling the
+    /// `fields` constructor on the return value of `entries`. The resulting
+    /// `fields` is mutable.
+    @since(version = 0.2.0)
+    clone: func() -> fields;
   }
 
-  resource outgoing-request {
-    constructor(
-      method: method,
-      path-with-query: option<string>,
-      scheme: option<scheme>,
-      authority: option<string>,
-      headers: /* borrow */ headers
-    )
+  /// Headers is an alias for Fields.
+  @since(version = 0.2.0)
+  type headers = fields;
 
-    // Will return the outgoing-body child at most once. If called more than
-    // once, subsequent calls will return error.
-    write: func() -> result< /* child */ outgoing-body>
-  }
+  /// Trailers is an alias for Fields.
+  @since(version = 0.2.0)
+  type trailers = fields;
 
-  // Additional optional parameters that can be set when making a request.
-  record request-options {
-    // The following timeouts are specific to the HTTP protocol and work
-    // independently of the overall timeouts passed to `io.poll.poll-list`.
+  /// Represents an incoming HTTP Request.
+  @since(version = 0.2.0)
+  resource incoming-request {
 
-    // The timeout for the initial connect.
-    connect-timeout-ms: option<u32>,
+    /// Returns the method of the incoming request.
+    @since(version = 0.2.0)
+    method: func() -> method;
+
+    /// Returns the path with query parameters from the request, as a string.
+    @since(version = 0.2.0)
+    path-with-query: func() -> option<string>;
+
+    /// Returns the protocol scheme from the request.
+    @since(version = 0.2.0)
+    scheme: func() -> option<scheme>;
+
+    /// Returns the authority of the Request's target URI, if present.
+    @since(version = 0.2.0)
+    authority: func() -> option<string>;
+
+    /// Get the `headers` associated with the request.
+    ///
+    /// The returned `headers` resource is immutable: `set`, `append`, and
+    /// `delete` operations will fail with `header-error.immutable`.
+    ///
+    /// The `headers` returned are a child resource: it must be dropped before
+    /// the parent `incoming-request` is dropped. Dropping this
+    /// `incoming-request` before all children are dropped will trap.
+    @since(version = 0.2.0)
+    headers: func() -> headers;
+
+    /// Gives the `incoming-body` associated with this request. Will only
+    /// return success at most once, and subsequent calls will return error.
+    @since(version = 0.2.0)
+    consume: func() -> result<incoming-body>;
+  }
+
+  /// Represents an outgoing HTTP Request.
+  @since(version = 0.2.0)
+  resource outgoing-request {
 
-    // The timeout for receiving the first byte of the response body.
-    first-byte-timeout-ms: option<u32>,
+    /// Construct a new `outgoing-request` with a default `method` of `GET`, and
+    /// `none` values for `path-with-query`, `scheme`, and `authority`.
+    ///
+    /// * `headers` is the HTTP Headers for the Request.
+    ///
+    /// It is possible to construct, or manipulate with the accessor functions
+    /// below, an `outgoing-request` with an invalid combination of `scheme`
+    /// and `authority`, or `headers` which are not permitted to be sent.
+    /// It is the obligation of the `outgoing-handler.handle` implementation
+    /// to reject invalid constructions of `outgoing-request`.
+    @since(version = 0.2.0)
+    constructor(
+      headers: headers
+    );
+
+    /// Returns the resource corresponding to the outgoing Body for this
+    /// Request.
+    ///
+    /// Returns success on the first call: the `outgoing-body` resource for
+    /// this `outgoing-request` can be retrieved at most once. Subsequent
+    /// calls will return error.
+    @since(version = 0.2.0)
+    body: func() -> result<outgoing-body>;
+
+    /// Get the Method for the Request.
+    @since(version = 0.2.0)
+    method: func() -> method;
+    /// Set the Method for the Request. Fails if the string present in a
+    /// `method.other` argument is not a syntactically valid method.
+    @since(version = 0.2.0)
+    set-method: func(method: method) -> result;
+
+    /// Get the combination of the HTTP Path and Query for the Request.
+    /// When `none`, this represents an empty Path and empty Query.
+    @since(version = 0.2.0)
+    path-with-query: func() -> option<string>;
+    /// Set the combination of the HTTP Path and Query for the Request.
+    /// When `none`, this represents an empty Path and empty Query. Fails is the
+    /// string given is not a syntactically valid path and query uri component.
+    @since(version = 0.2.0)
+    set-path-with-query: func(path-with-query: option<string>) -> result;
+
+    /// Get the HTTP Related Scheme for the Request. When `none`, the
+    /// implementation may choose an appropriate default scheme.
+    @since(version = 0.2.0)
+    scheme: func() -> option<scheme>;
+    /// Set the HTTP Related Scheme for the Request. When `none`, the
+    /// implementation may choose an appropriate default scheme. Fails if the
+    /// string given is not a syntactically valid uri scheme.
+    @since(version = 0.2.0)
+    set-scheme: func(scheme: option<scheme>) -> result;
+
+    /// Get the authority of the Request's target URI. A value of `none` may be used
+    /// with Related Schemes which do not require an authority. The HTTP and
+    /// HTTPS schemes always require an authority.
+    @since(version = 0.2.0)
+    authority: func() -> option<string>;
+    /// Set the authority of the Request's target URI. A value of `none` may be used
+    /// with Related Schemes which do not require an authority. The HTTP and
+    /// HTTPS schemes always require an authority. Fails if the string given is
+    /// not a syntactically valid URI authority.
+    @since(version = 0.2.0)
+    set-authority: func(authority: option<string>) -> result;
+
+    /// Get the headers associated with the Request.
+    ///
+    /// The returned `headers` resource is immutable: `set`, `append`, and
+    /// `delete` operations will fail with `header-error.immutable`.
+    ///
+    /// This headers resource is a child: it must be dropped before the parent
+    /// `outgoing-request` is dropped, or its ownership is transferred to
+    /// another component by e.g. `outgoing-handler.handle`.
+    @since(version = 0.2.0)
+    headers: func() -> headers;
+  }
 
-    // The timeout for receiving the next chunk of bytes in the response body
-    // stream.
-    between-bytes-timeout-ms: option<u32>
+  /// Parameters for making an HTTP Request. Each of these parameters is
+  /// currently an optional timeout applicable to the transport layer of the
+  /// HTTP protocol.
+  ///
+  /// These timeouts are separate from any the user may use to bound a
+  /// blocking call to `wasi:io/poll.poll`.
+  @since(version = 0.2.0)
+  resource request-options {
+    /// Construct a default `request-options` value.
+    @since(version = 0.2.0)
+    constructor();
+
+    /// The timeout for the initial connect to the HTTP Server.
+    @since(version = 0.2.0)
+    connect-timeout: func() -> option<duration>;
+
+    /// Set the timeout for the initial connect to the HTTP Server. An error
+    /// return value indicates that this timeout is not supported.
+    @since(version = 0.2.0)
+    set-connect-timeout: func(duration: option<duration>) -> result;
+
+    /// The timeout for receiving the first byte of the Response body.
+    @since(version = 0.2.0)
+    first-byte-timeout: func() -> option<duration>;
+
+    /// Set the timeout for receiving the first byte of the Response body. An
+    /// error return value indicates that this timeout is not supported.
+    @since(version = 0.2.0)
+    set-first-byte-timeout: func(duration: option<duration>) -> result;
+
+    /// The timeout for receiving subsequent chunks of bytes in the Response
+    /// body stream.
+    @since(version = 0.2.0)
+    between-bytes-timeout: func() -> option<duration>;
+
+    /// Set the timeout for receiving subsequent chunks of bytes in the Response
+    /// body stream. An error return value indicates that this timeout is not
+    /// supported.
+    @since(version = 0.2.0)
+    set-between-bytes-timeout: func(duration: option<duration>) -> result;
   }
 
-  // The following block defines a special resource type used by the
-  // `wasi:http/incoming-handler` interface. When resource types are added, this
-  // block can be replaced by a proper `resource response-outparam { ... }`
-  // definition. Later, with Preview3, the need for an outparam goes away entirely
-  // (the `wasi:http/handler` interface used for both incoming and outgoing can
-  // simply return a `stream`).
+  /// Represents the ability to send an HTTP Response.
+  ///
+  /// This resource is used by the `wasi:http/incoming-handler` interface to
+  /// allow a Response to be sent corresponding to the Request provided as the
+  /// other argument to `incoming-handler.handle`.
+  @since(version = 0.2.0)
   resource response-outparam {
-    set: static func(param: /* own */ response-outparam, response: result< /* own */ outgoing-response, error>)
+
+    /// Set the value of the `response-outparam` to either send a response,
+    /// or indicate an error.
+    ///
+    /// This method consumes the `response-outparam` to ensure that it is
+    /// called at most once. If it is never called, the implementation
+    /// will respond with an error.
+    ///
+    /// The user may provide an `error` to `response` to allow the
+    /// implementation determine how to respond with an HTTP error response.
+    @since(version = 0.2.0)
+    set: static func(
+      param: response-outparam,
+      response: result<outgoing-response, error-code>,
+    );
   }
 
-  // This type corresponds to the HTTP standard Status Code.
-  type status-code = u16
+  /// This type corresponds to the HTTP standard Status Code.
+  @since(version = 0.2.0)
+  type status-code = u16;
 
-  // The following block defines the `incoming-response` and `outgoing-response`
-  // resource types that correspond to HTTP standard Responses. Soon, when
-  // resource types are added, the `u32` type aliases can be replaced by proper
-  // `resource` type definitions containing all the functions as methods. Later,
-  // Preview2 will allow both types to be merged together into a single `response`
-  // type (that uses the single `stream` type mentioned above). The `consume` and
-  // `write` methods may only be called once (and return failure thereafter).
+  /// Represents an incoming HTTP Response.
+  @since(version = 0.2.0)
   resource incoming-response {
-    status: func() -> status-code
 
-    headers: func() -> /* child */ headers
-
-    // May be called at most once. returns error if called additional times.
-    // TODO: make incoming-request-consume work the same way, giving a child
-    // incoming-body.
-    consume: func() -> result</* own */ incoming-body>
+    /// Returns the status code from the incoming response.
+    @since(version = 0.2.0)
+    status: func() -> status-code;
+
+    /// Returns the headers from the incoming response.
+    ///
+    /// The returned `headers` resource is immutable: `set`, `append`, and
+    /// `delete` operations will fail with `header-error.immutable`.
+    ///
+    /// This headers resource is a child: it must be dropped before the parent
+    /// `incoming-response` is dropped.
+    @since(version = 0.2.0)
+    headers: func() -> headers;
+
+    /// Returns the incoming body. May be called at most once. Returns error
+    /// if called additional times.
+    @since(version = 0.2.0)
+    consume: func() -> result<incoming-body>;
   }
 
+  /// Represents an incoming HTTP Request or Response's Body.
+  ///
+  /// A body has both its contents - a stream of bytes - and a (possibly
+  /// empty) set of trailers, indicating that the full contents of the
+  /// body have been received. This resource represents the contents as
+  /// an `input-stream` and the delivery of trailers as a `future-trailers`,
+  /// and ensures that the user of this interface may only be consuming either
+  /// the body contents or waiting on trailers at any given time.
+  @since(version = 0.2.0)
   resource incoming-body {
-    // returned input-stream is a child - the implementation may trap if
-    // incoming-body is dropped (or consumed by call to
-    // incoming-body-finish) before the input-stream is dropped.
-    // May be called at most once. returns error if called additional times.
-    %stream: func() -> result</* child */ input-stream>
 
-    // takes ownership of incoming-body. this will trap if the
-    // incoming-body-stream child is still alive!
-    finish: static func(this: /* own */ incoming-body) ->
-    /* transitive child of the incoming-response of incoming-body */ future-trailers
+    /// Returns the contents of the body, as a stream of bytes.
+    ///
+    /// Returns success on first call: the stream representing the contents
+    /// can be retrieved at most once. Subsequent calls will return error.
+    ///
+    /// The returned `input-stream` resource is a child: it must be dropped
+    /// before the parent `incoming-body` is dropped, or consumed by
+    /// `incoming-body.finish`.
+    ///
+    /// This invariant ensures that the implementation can determine whether
+    /// the user is consuming the contents of the body, waiting on the
+    /// `future-trailers` to be ready, or neither. This allows for network
+    /// backpressure is to be applied when the user is consuming the body,
+    /// and for that backpressure to not inhibit delivery of the trailers if
+    /// the user does not read the entire body.
+    @since(version = 0.2.0)
+    %stream: func() -> result<input-stream>;
+
+    /// Takes ownership of `incoming-body`, and returns a `future-trailers`.
+    /// This function will trap if the `input-stream` child is still alive.
+    @since(version = 0.2.0)
+    finish: static func(this: incoming-body) -> future-trailers;
   }
 
+  /// Represents a future which may eventually return trailers, or an error.
+  ///
+  /// In the case that the incoming HTTP Request or Response did not have any
+  /// trailers, this future will resolve to the empty set of trailers once the
+  /// complete Request or Response body has been received.
+  @since(version = 0.2.0)
   resource future-trailers {
-    /// Pollable that resolves when the body has been fully read, and the trailers
-    /// are ready to be consumed.
-    subscribe: func() -> /* child */ pollable
 
-    /// Retrieve reference to trailers, if they are ready.
-    get: func() -> option<result</* child */ trailers, error>>
+    /// Returns a pollable which becomes ready when either the trailers have
+    /// been received, or an error has occurred. When this pollable is ready,
+    /// the `get` method will return `some`.
+    @since(version = 0.2.0)
+    subscribe: func() -> pollable;
+
+    /// Returns the contents of the trailers, or an error which occurred,
+    /// once the future is ready.
+    ///
+    /// The outer `option` represents future readiness. Users can wait on this
+    /// `option` to become `some` using the `subscribe` method.
+    ///
+    /// The outer `result` is used to retrieve the trailers or error at most
+    /// once. It will be success on the first call in which the outer option
+    /// is `some`, and error on subsequent calls.
+    ///
+    /// The inner `result` represents that either the HTTP Request or Response
+    /// body, as well as any trailers, were received successfully, or that an
+    /// error occurred receiving them. The optional `trailers` indicates whether
+    /// or not trailers were present in the body.
+    ///
+    /// When some `trailers` are returned by this method, the `trailers`
+    /// resource is immutable, and a child. Use of the `set`, `append`, or
+    /// `delete` methods will return an error, and the resource must be
+    /// dropped before the parent `future-trailers` is dropped.
+    @since(version = 0.2.0)
+    get: func() -> option<result<result<option<trailers>, error-code>>>;
   }
 
+  /// Represents an outgoing HTTP Response.
+  @since(version = 0.2.0)
   resource outgoing-response {
-    constructor(status-code: status-code, headers: /* borrow */ headers)
 
-    /// Will give the child outgoing-response at most once. subsequent calls will
-    /// return an error.
-    write: func() -> result</* own */ outgoing-body>
+    /// Construct an `outgoing-response`, with a default `status-code` of `200`.
+    /// If a different `status-code` is needed, it must be set via the
+    /// `set-status-code` method.
+    ///
+    /// * `headers` is the HTTP Headers for the Response.
+    @since(version = 0.2.0)
+    constructor(headers: headers);
+
+    /// Get the HTTP Status Code for the Response.
+    @since(version = 0.2.0)
+    status-code: func() -> status-code;
+
+    /// Set the HTTP Status Code for the Response. Fails if the status-code
+    /// given is not a valid http status code.
+    @since(version = 0.2.0)
+    set-status-code: func(status-code: status-code) -> result;
+
+    /// Get the headers associated with the Request.
+    ///
+    /// The returned `headers` resource is immutable: `set`, `append`, and
+    /// `delete` operations will fail with `header-error.immutable`.
+    ///
+    /// This headers resource is a child: it must be dropped before the parent
+    /// `outgoing-request` is dropped, or its ownership is transferred to
+    /// another component by e.g. `outgoing-handler.handle`.
+    @since(version = 0.2.0)
+    headers: func() -> headers;
+
+    /// Returns the resource corresponding to the outgoing Body for this Response.
+    ///
+    /// Returns success on the first call: the `outgoing-body` resource for
+    /// this `outgoing-response` can be retrieved at most once. Subsequent
+    /// calls will return error.
+    @since(version = 0.2.0)
+    body: func() -> result<outgoing-body>;
   }
 
+  /// Represents an outgoing HTTP Request or Response's Body.
+  ///
+  /// A body has both its contents - a stream of bytes - and a (possibly
+  /// empty) set of trailers, inducating the full contents of the body
+  /// have been sent. This resource represents the contents as an
+  /// `output-stream` child resource, and the completion of the body (with
+  /// optional trailers) with a static function that consumes the
+  /// `outgoing-body` resource, and ensures that the user of this interface
+  /// may not write to the body contents after the body has been finished.
+  ///
+  /// If the user code drops this resource, as opposed to calling the static
+  /// method `finish`, the implementation should treat the body as incomplete,
+  /// and that an error has occurred. The implementation should propagate this
+  /// error to the HTTP protocol by whatever means it has available,
+  /// including: corrupting the body on the wire, aborting the associated
+  /// Request, or sending a late status code for the Response.
+  @since(version = 0.2.0)
   resource outgoing-body {
-    /// Will give the child output-stream at most once. subsequent calls will
-    /// return an error.
-    write: func() -> result</* child */ output-stream>
+
+    /// Returns a stream for writing the body contents.
+    ///
+    /// The returned `output-stream` is a child resource: it must be dropped
+    /// before the parent `outgoing-body` resource is dropped (or finished),
+    /// otherwise the `outgoing-body` drop or `finish` will trap.
+    ///
+    /// Returns success on the first call: the `output-stream` resource for
+    /// this `outgoing-body` may be retrieved at most once. Subsequent calls
+    /// will return error.
+    @since(version = 0.2.0)
+    write: func() -> result<output-stream>;
 
     /// Finalize an outgoing body, optionally providing trailers. This must be
-    /// called to signal that the response is complete. If the `outgoing-body` is
-    /// dropped without calling `outgoing-body-finalize`, the implementation
+    /// called to signal that the response is complete. If the `outgoing-body`
+    /// is dropped without calling `outgoing-body.finalize`, the implementation
     /// should treat the body as corrupted.
-    finish: static func(this: /* own */ outgoing-body, trailers: /* own */ option<trailers>)
+    ///
+    /// Fails if the body's `outgoing-request` or `outgoing-response` was
+    /// constructed with a Content-Length header, and the contents written
+    /// to the body (via `write`) does not match the value given in the
+    /// Content-Length.
+    @since(version = 0.2.0)
+    finish: static func(
+      this: outgoing-body,
+      trailers: option<trailers>
+    ) -> result<_, error-code>;
   }
 
-  /// The following block defines a special resource type used by the
-  /// `wasi:http/outgoing-handler` interface to emulate
-  /// `future<result<response, error>>` in advance of Preview3. Given a
-  /// `future-incoming-response`, the client can call the non-blocking `get`
-  /// method to get the result if it is available. If the result is not available,
-  /// the client can call `listen` to get a `pollable` that can be passed to
-  /// `wasi:io/poll.poll-list`.
+  /// Represents a future which may eventually return an incoming HTTP
+  /// Response, or an error.
+  ///
+  /// This resource is returned by the `wasi:http/outgoing-handler` interface to
+  /// provide the HTTP Response corresponding to the sent Request.
+  @since(version = 0.2.0)
   resource future-incoming-response {
-    /// option indicates readiness.
-    /// outer result indicates you are allowed to get the
-    /// incoming-response-or-error at most once. subsequent calls after ready
-    /// will return an error here.
-    /// inner result indicates whether the incoming-response was available, or an
-    /// error occured.
-    get: func() -> option<result<result</* NOT a child*/ incoming-response, error>>>
-
-    subscribe: func() -> /* child */ pollable
+    /// Returns a pollable which becomes ready when either the Response has
+    /// been received, or an error has occurred. When this pollable is ready,
+    /// the `get` method will return `some`.
+    @since(version = 0.2.0)
+    subscribe: func() -> pollable;
+
+    /// Returns the incoming HTTP Response, or an error, once one is ready.
+    ///
+    /// The outer `option` represents future readiness. Users can wait on this
+    /// `option` to become `some` using the `subscribe` method.
+    ///
+    /// The outer `result` is used to retrieve the response or error at most
+    /// once. It will be success on the first call in which the outer option
+    /// is `some`, and error on subsequent calls.
+    ///
+    /// The inner `result` represents that either the incoming HTTP Response
+    /// status and headers have received successfully, or that an error
+    /// occurred. Errors may also occur while consuming the response body,
+    /// but those will be reported by the `incoming-body` and its
+    /// `output-stream` child.
+    @since(version = 0.2.0)
+    get: func() -> option<result<result<incoming-response, error-code>>>;
   }
 }
diff --git a/crates/wasi-http/wit/deps/io/error.wit b/crates/wasi-http/wit/deps/io/error.wit
new file mode 100644
index 000000000000..4ea29c4696b5
--- /dev/null
+++ b/crates/wasi-http/wit/deps/io/error.wit
@@ -0,0 +1,34 @@
+package wasi:io@0.2.1;
+
+@since(version = 0.2.0)
+interface error {
+    /// A resource which represents some error information.
+    ///
+    /// The only method provided by this resource is `to-debug-string`,
+    /// which provides some human-readable information about the error.
+    ///
+    /// In the `wasi:io` package, this resource is returned through the
+    /// `wasi:io/streams/stream-error` type.
+    ///
+    /// To provide more specific error information, other interfaces may
+    /// offer functions to "downcast" this error into more specific types. For example,
+    /// errors returned from streams derived from filesystem types can be described using
+    /// the filesystem's own error-code type. This is done using the function
+    /// `wasi:filesystem/types/filesystem-error-code`, which takes a `borrow<error>`
+    /// parameter and returns an `option<wasi:filesystem/types/error-code>`.
+    ///
+    /// The set of functions which can "downcast" an `error` into a more
+    /// concrete type is open.
+    @since(version = 0.2.0)
+    resource error {
+        /// Returns a string that is suitable to assist humans in debugging
+        /// this error.
+        ///
+        /// WARNING: The returned string should not be consumed mechanically!
+        /// It may change across platforms, hosts, or other implementation
+        /// details. Parsing this string is a major platform-compatibility
+        /// hazard.
+        @since(version = 0.2.0)
+        to-debug-string: func() -> string;
+    }
+}
diff --git a/crates/wasi-http/wit/deps/io/poll.wit b/crates/wasi-http/wit/deps/io/poll.wit
index e95762b915db..b25ac729ff7d 100644
--- a/crates/wasi-http/wit/deps/io/poll.wit
+++ b/crates/wasi-http/wit/deps/io/poll.wit
@@ -1,10 +1,27 @@
-package wasi:io
+package wasi:io@0.2.1;
 
 /// A poll API intended to let users wait for I/O events on multiple handles
 /// at once.
+@since(version = 0.2.0)
 interface poll {
-    /// A "pollable" handle.
-    resource pollable
+    /// `pollable` represents a single I/O event which may be ready, or not.
+    @since(version = 0.2.0)
+    resource pollable {
+
+      /// Return the readiness of a pollable. This function never blocks.
+      ///
+      /// Returns `true` when the pollable is ready, and `false` otherwise.
+      @since(version = 0.2.0)
+      ready: func() -> bool;
+
+      /// `block` returns immediately if the pollable is ready, and otherwise
+      /// blocks until ready.
+      ///
+      /// This function is equivalent to calling `poll.poll` on a list
+      /// containing only this pollable.
+      @since(version = 0.2.0)
+      block: func();
+    }
 
     /// Poll for completion on a set of pollables.
     ///
@@ -14,8 +31,9 @@ interface poll {
     /// The result `list<u32>` contains one or more indices of handles in the
     /// argument list that is ready for I/O.
     ///
-    /// If the list contains more elements than can be indexed with a `u32`
-    /// value, this function traps.
+    /// This function traps if either:
+    /// - the list is empty, or:
+    /// - the list contains more elements than can be indexed with a `u32` value.
     ///
     /// A timeout can be implemented by adding a pollable from the
     /// wasi-clocks API to the list.
@@ -23,12 +41,7 @@ interface poll {
     /// This function does not return a `result`; polling in itself does not
     /// do any I/O so it doesn't fail. If any of the I/O sources identified by
     /// the pollables has an error, it is indicated by marking the source as
-    /// being reaedy for I/O.
-    poll-list: func(in: list<borrow<pollable>>) -> list<u32>
-
-    /// Poll for completion on a single pollable.
-    ///
-    /// This function is similar to `poll-list`, but operates on only a single
-    /// pollable. When it returns, the handle is ready for I/O.
-    poll-one: func(in: borrow<pollable>)
+    /// being ready for I/O.
+    @since(version = 0.2.0)
+    poll: func(in: list<borrow<pollable>>) -> list<u32>;
 }
diff --git a/crates/wasi-http/wit/deps/io/streams.wit b/crates/wasi-http/wit/deps/io/streams.wit
index 8240507976f7..b697e24d61bf 100644
--- a/crates/wasi-http/wit/deps/io/streams.wit
+++ b/crates/wasi-http/wit/deps/io/streams.wit
@@ -1,17 +1,24 @@
-package wasi:io
+package wasi:io@0.2.1;
 
 /// WASI I/O is an I/O abstraction API which is currently focused on providing
 /// stream types.
 ///
 /// In the future, the component model is expected to add built-in stream types;
 /// when it does, they are expected to subsume this API.
+@since(version = 0.2.0)
 interface streams {
-    use poll.{pollable}
+    @since(version = 0.2.0)
+    use error.{error};
+    @since(version = 0.2.0)
+    use poll.{pollable};
 
     /// An error for input-stream and output-stream operations.
-    enum stream-error {
+    @since(version = 0.2.0)
+    variant stream-error {
         /// The last operation (a write or flush) failed before completion.
-        last-operation-failed,
+        ///
+        /// More information is available in the `error` payload.
+        last-operation-failed(error),
         /// The stream is closed: no more input will be accepted by the
         /// stream. A closed output-stream will return this error on all
         /// future operations.
@@ -26,64 +33,65 @@ interface streams {
     /// available, which could even be zero. To wait for data to be available,
     /// use the `subscribe` function to obtain a `pollable` which can be polled
     /// for using `wasi:io/poll`.
+    @since(version = 0.2.0)
     resource input-stream {
         /// Perform a non-blocking read from the stream.
         ///
-        /// This function returns a list of bytes containing the data that was
-        /// read, along with a `stream-status` which, indicates whether further
-        /// reads are expected to produce data. The returned list will contain up to
-        /// `len` bytes; it may return fewer than requested, but not more. An
-        /// empty list and `stream-status:open` indicates no more data is
-        /// available at this time, and that the pollable given by `subscribe`
-        /// will be ready when more data is available.
+        /// When the source of a `read` is binary data, the bytes from the source
+        /// are returned verbatim. When the source of a `read` is known to the
+        /// implementation to be text, bytes containing the UTF-8 encoding of the
+        /// text are returned.
+        ///
+        /// This function returns a list of bytes containing the read data,
+        /// when successful. The returned list will contain up to `len` bytes;
+        /// it may return fewer than requested, but not more. The list is
+        /// empty when no bytes are available for reading at this time. The
+        /// pollable given by `subscribe` will be ready when more bytes are
+        /// available.
         ///
-        /// Once a stream has reached the end, subsequent calls to `read` or
-        /// `skip` will always report `stream-status:ended` rather than producing more
-        /// data.
+        /// This function fails with a `stream-error` when the operation
+        /// encounters an error, giving `last-operation-failed`, or when the
+        /// stream is closed, giving `closed`.
         ///
-        /// When the caller gives a `len` of 0, it represents a request to read 0
-        /// bytes. This read should  always succeed and return an empty list and
-        /// the current `stream-status`.
+        /// When the caller gives a `len` of 0, it represents a request to
+        /// read 0 bytes. If the stream is still open, this call should
+        /// succeed and return an empty list, or otherwise fail with `closed`.
         ///
         /// The `len` parameter is a `u64`, which could represent a list of u8 which
         /// is not possible to allocate in wasm32, or not desirable to allocate as
         /// as a return value by the callee. The callee may return a list of bytes
         /// less than `len` in size while more bytes are available for reading.
+        @since(version = 0.2.0)
         read: func(
             /// The maximum number of bytes to read
             len: u64
-        ) -> result<list<u8>, stream-error>
+        ) -> result<list<u8>, stream-error>;
 
         /// Read bytes from a stream, after blocking until at least one byte can
-        /// be read. Except for blocking, identical to `read`.
+        /// be read. Except for blocking, behavior is identical to `read`.
+        @since(version = 0.2.0)
         blocking-read: func(
             /// The maximum number of bytes to read
             len: u64
-        ) -> result<list<u8>, stream-error>
+        ) -> result<list<u8>, stream-error>;
 
-        /// Skip bytes from a stream.
-        ///
-        /// This is similar to the `read` function, but avoids copying the
-        /// bytes into the instance.
-        ///
-        /// Once a stream has reached the end, subsequent calls to read or
-        /// `skip` will always report end-of-stream rather than producing more
-        /// data.
+        /// Skip bytes from a stream. Returns number of bytes skipped.
         ///
-        /// This function returns the number of bytes skipped, along with a
-        /// `stream-status` indicating whether the end of the stream was
-        /// reached. The returned value will be at most `len`; it may be less.
+        /// Behaves identical to `read`, except instead of returning a list
+        /// of bytes, returns the number of bytes consumed from the stream.
+        @since(version = 0.2.0)
         skip: func(
             /// The maximum number of bytes to skip.
             len: u64,
-        ) -> result<u64, stream-error>
+        ) -> result<u64, stream-error>;
 
         /// Skip bytes from a stream, after blocking until at least one byte
         /// can be skipped. Except for blocking behavior, identical to `skip`.
+        @since(version = 0.2.0)
         blocking-skip: func(
             /// The maximum number of bytes to skip.
             len: u64,
-        ) -> result<u64, stream-error>
+        ) -> result<u64, stream-error>;
 
         /// Create a `pollable` which will resolve once either the specified stream
         /// has bytes available to read or the other end of the stream has been
@@ -91,7 +99,8 @@ interface streams {
         /// The created `pollable` is a child resource of the `input-stream`.
         /// Implementations may trap if the `input-stream` is dropped before
         /// all derived `pollable`s created with this function are dropped.
-        subscribe: func() -> pollable
+        @since(version = 0.2.0)
+        subscribe: func() -> pollable;
     }
 
 
@@ -103,6 +112,11 @@ interface streams {
     /// promptly, which could even be zero. To wait for the stream to be ready to
     /// accept data, the `subscribe` function to obtain a `pollable` which can be
     /// polled for using `wasi:io/poll`.
+    ///
+    /// Dropping an `output-stream` while there's still an active write in
+    /// progress may result in the data being lost. Before dropping the stream,
+    /// be sure to fully flush your writes.
+    @since(version = 0.2.0)
     resource output-stream {
         /// Check readiness for writing. This function never blocks.
         ///
@@ -113,18 +127,26 @@ interface streams {
         /// When this function returns 0 bytes, the `subscribe` pollable will
         /// become ready when this function will report at least 1 byte, or an
         /// error.
-        check-write: func() -> result<u64, stream-error>
+        @since(version = 0.2.0)
+        check-write: func() -> result<u64, stream-error>;
 
         /// Perform a write. This function never blocks.
         ///
+        /// When the destination of a `write` is binary data, the bytes from
+        /// `contents` are written verbatim. When the destination of a `write` is
+        /// known to the implementation to be text, the bytes of `contents` are
+        /// transcoded from UTF-8 into the encoding of the destination and then
+        /// written.
+        ///
         /// Precondition: check-write gave permit of Ok(n) and contents has a
         /// length of less than or equal to n. Otherwise, this function will trap.
         ///
         /// returns Err(closed) without writing if the stream has closed since
         /// the last call to check-write provided a permit.
+        @since(version = 0.2.0)
         write: func(
             contents: list<u8>
-        ) -> result<_, stream-error>
+        ) -> result<_, stream-error>;
 
         /// Perform a write of up to 4096 bytes, and then flush the stream. Block
         /// until all of these operations are complete, or an error occurs.
@@ -137,7 +159,7 @@ interface streams {
         /// let pollable = this.subscribe();
         /// while !contents.is_empty() {
         ///     // Wait for the stream to become writable
-        ///     poll-one(pollable);
+        ///     pollable.block();
         ///     let Ok(n) = this.check-write(); // eliding error handling
         ///     let len = min(n, contents.len());
         ///     let (chunk, rest) = contents.split_at(len);
@@ -146,13 +168,14 @@ interface streams {
         /// }
         /// this.flush();
         /// // Wait for completion of `flush`
-        /// poll-one(pollable);
+        /// pollable.block();
         /// // Check for any errors that arose during `flush`
         /// let _ = this.check-write();         // eliding error handling
         /// ```
+        @since(version = 0.2.0)
         blocking-write-and-flush: func(
             contents: list<u8>
-        ) -> result<_, stream-error>
+        ) -> result<_, stream-error>;
 
         /// Request to flush buffered output. This function never blocks.
         ///
@@ -164,14 +187,16 @@ interface streams {
         /// writes (`check-write` will return `ok(0)`) until the flush has
         /// completed. The `subscribe` pollable will become ready when the
         /// flush has completed and the stream can accept more writes.
-        flush: func() -> result<_, stream-error>
+        @since(version = 0.2.0)
+        flush: func() -> result<_, stream-error>;
 
         /// Request to flush buffered output, and block until flush completes
         /// and stream is ready for writing again.
-        blocking-flush: func() -> result<_, stream-error>
+        @since(version = 0.2.0)
+        blocking-flush: func() -> result<_, stream-error>;
 
         /// Create a `pollable` which will resolve once the output-stream
-        /// is ready for more writing, or an error has occured. When this
+        /// is ready for more writing, or an error has occurred. When this
         /// pollable is ready, `check-write` will return `ok(n)` with n>0, or an
         /// error.
         ///
@@ -180,18 +205,19 @@ interface streams {
         /// The created `pollable` is a child resource of the `output-stream`.
         /// Implementations may trap if the `output-stream` is dropped before
         /// all derived `pollable`s created with this function are dropped.
-        subscribe: func() -> pollable
+        subscribe: func() -> pollable;
 
         /// Write zeroes to a stream.
         ///
-        /// this should be used precisely like `write` with the exact same
+        /// This should be used precisely like `write` with the exact same
         /// preconditions (must use check-write first), but instead of
         /// passing a list of bytes, you simply pass the number of zero-bytes
         /// that should be written.
+        @since(version = 0.2.0)
         write-zeroes: func(
             /// The number of zero-bytes to write
             len: u64
-        ) -> result<_, stream-error>
+        ) -> result<_, stream-error>;
 
         /// Perform a write of up to 4096 zeroes, and then flush the stream.
         /// Block until all of these operations are complete, or an error
@@ -205,7 +231,7 @@ interface streams {
         /// let pollable = this.subscribe();
         /// while num_zeroes != 0 {
         ///     // Wait for the stream to become writable
-        ///     poll-one(pollable);
+        ///     pollable.block();
         ///     let Ok(n) = this.check-write(); // eliding error handling
         ///     let len = min(n, num_zeroes);
         ///     this.write-zeroes(len);         // eliding error handling
@@ -213,55 +239,48 @@ interface streams {
         /// }
         /// this.flush();
         /// // Wait for completion of `flush`
-        /// poll-one(pollable);
+        /// pollable.block();
         /// // Check for any errors that arose during `flush`
         /// let _ = this.check-write();         // eliding error handling
         /// ```
+        @since(version = 0.2.0)
         blocking-write-zeroes-and-flush: func(
             /// The number of zero-bytes to write
             len: u64
-        ) -> result<_, stream-error>
+        ) -> result<_, stream-error>;
 
         /// Read from one stream and write to another.
         ///
+        /// The behavior of splice is equivalent to:
+        /// 1. calling `check-write` on the `output-stream`
+        /// 2. calling `read` on the `input-stream` with the smaller of the
+        /// `check-write` permitted length and the `len` provided to `splice`
+        /// 3. calling `write` on the `output-stream` with that read data.
+        ///
+        /// Any error reported by the call to `check-write`, `read`, or
+        /// `write` ends the splice and reports that error.
+        ///
         /// This function returns the number of bytes transferred; it may be less
         /// than `len`.
-        ///
-        /// Unlike other I/O functions, this function blocks until all the data
-        /// read from the input stream has been written to the output stream.
+        @since(version = 0.2.0)
         splice: func(
             /// The stream to read from
-            src: input-stream,
+            src: borrow<input-stream>,
             /// The number of bytes to splice
             len: u64,
-        ) -> result<u64, stream-error>
+        ) -> result<u64, stream-error>;
 
         /// Read from one stream and write to another, with blocking.
         ///
-        /// This is similar to `splice`, except that it blocks until at least
-        /// one byte can be read.
+        /// This is similar to `splice`, except that it blocks until the
+        /// `output-stream` is ready for writing, and the `input-stream`
+        /// is ready for reading, before performing the `splice`.
+        @since(version = 0.2.0)
         blocking-splice: func(
             /// The stream to read from
-            src: input-stream,
+            src: borrow<input-stream>,
             /// The number of bytes to splice
             len: u64,
-        ) -> result<u64, stream-error>
-
-        /// Forward the entire contents of an input stream to an output stream.
-        ///
-        /// This function repeatedly reads from the input stream and writes
-        /// the data to the output stream, until the end of the input stream
-        /// is reached, or an error is encountered.
-        ///
-        /// Unlike other I/O functions, this function blocks until the end
-        /// of the input stream is seen and all the data has been written to
-        /// the output stream.
-        ///
-        /// This function returns the number of bytes transferred, and the status of
-        /// the output stream.
-        forward: func(
-            /// The stream to read from
-            src: input-stream
-        ) -> result<u64, stream-error>
+        ) -> result<u64, stream-error>;
     }
 }
diff --git a/crates/wasi-http/wit/deps/io/world.wit b/crates/wasi-http/wit/deps/io/world.wit
index 8738dba756d9..6405a4e4820c 100644
--- a/crates/wasi-http/wit/deps/io/world.wit
+++ b/crates/wasi-http/wit/deps/io/world.wit
@@ -1,6 +1,10 @@
-package wasi:io
+package wasi:io@0.2.1;
 
+@since(version = 0.2.0)
 world imports {
-    import streams
-    import poll
+    @since(version = 0.2.0)
+    import streams;
+
+    @since(version = 0.2.0)
+    import poll;
 }
diff --git a/crates/wasi-http/wit/deps/logging/logging.wit b/crates/wasi-http/wit/deps/logging/logging.wit
deleted file mode 100644
index b0cc4514dc8f..000000000000
--- a/crates/wasi-http/wit/deps/logging/logging.wit
+++ /dev/null
@@ -1,37 +0,0 @@
-package wasi:logging
-
-/// WASI Logging is a logging API intended to let users emit log messages with
-/// simple priority levels and context values.
-interface logging {
-    /// A log level, describing a kind of message.
-    enum level {
-       /// Describes messages about the values of variables and the flow of
-       /// control within a program.
-       trace,
-
-       /// Describes messages likely to be of interest to someone debugging a
-       /// program.
-       debug,
-
-       /// Describes messages likely to be of interest to someone monitoring a
-       /// program.
-       info,
-
-       /// Describes messages indicating hazardous situations.
-       warn,
-
-       /// Describes messages indicating serious errors.
-       error,
-
-       /// Describes messages indicating fatal errors.
-       critical,
-    }
-
-    /// Emit a log message.
-    ///
-    /// A log message has a `level` describing what kind of message is being
-    /// sent, a context, which is an uninterpreted string meant to help
-    /// consumers group similar messages, and a string containing the message
-    /// text.
-    log: func(level: level, context: string, message: string)
-}
diff --git a/crates/wasi-http/wit/deps/logging/world.wit b/crates/wasi-http/wit/deps/logging/world.wit
deleted file mode 100644
index 7d49acfaddaa..000000000000
--- a/crates/wasi-http/wit/deps/logging/world.wit
+++ /dev/null
@@ -1,5 +0,0 @@
-package wasi:logging
-
-world imports {
-    import logging
-}
diff --git a/crates/wasi-http/wit/deps/random/insecure-seed.wit b/crates/wasi-http/wit/deps/random/insecure-seed.wit
index ff2ff65d0754..7e708dc52bfe 100644
--- a/crates/wasi-http/wit/deps/random/insecure-seed.wit
+++ b/crates/wasi-http/wit/deps/random/insecure-seed.wit
@@ -1,7 +1,9 @@
+package wasi:random@0.2.1;
 /// The insecure-seed interface for seeding hash-map DoS resistance.
 ///
 /// It is intended to be portable at least between Unix-family platforms and
 /// Windows.
+@since(version = 0.2.0)
 interface insecure-seed {
     /// Return a 128-bit value that may contain a pseudo-random value.
     ///
@@ -20,5 +22,6 @@ interface insecure-seed {
     /// This will likely be changed to a value import, to prevent it from being
     /// called multiple times and potentially used for purposes other than DoS
     /// protection.
-    insecure-seed: func() -> tuple<u64, u64>
+    @since(version = 0.2.0)
+    insecure-seed: func() -> tuple<u64, u64>;
 }
diff --git a/crates/wasi-http/wit/deps/random/insecure.wit b/crates/wasi-http/wit/deps/random/insecure.wit
index ff0826822d5f..3cdb53dfbb59 100644
--- a/crates/wasi-http/wit/deps/random/insecure.wit
+++ b/crates/wasi-http/wit/deps/random/insecure.wit
@@ -1,7 +1,9 @@
+package wasi:random@0.2.1;
 /// The insecure interface for insecure pseudo-random numbers.
 ///
 /// It is intended to be portable at least between Unix-family platforms and
 /// Windows.
+@since(version = 0.2.0)
 interface insecure {
     /// Return `len` insecure pseudo-random bytes.
     ///
@@ -11,11 +13,13 @@ interface insecure {
     /// There are no requirements on the values of the returned bytes, however
     /// implementations are encouraged to return evenly distributed values with
     /// a long period.
-    get-insecure-random-bytes: func(len: u64) -> list<u8>
+    @since(version = 0.2.0)
+    get-insecure-random-bytes: func(len: u64) -> list<u8>;
 
     /// Return an insecure pseudo-random `u64` value.
     ///
     /// This function returns the same type of pseudo-random data as
     /// `get-insecure-random-bytes`, represented as a `u64`.
-    get-insecure-random-u64: func() -> u64
+    @since(version = 0.2.0)
+    get-insecure-random-u64: func() -> u64;
 }
diff --git a/crates/wasi-http/wit/deps/random/random.wit b/crates/wasi-http/wit/deps/random/random.wit
index 2a282dab7eb9..2b5035d1ce7c 100644
--- a/crates/wasi-http/wit/deps/random/random.wit
+++ b/crates/wasi-http/wit/deps/random/random.wit
@@ -1,7 +1,9 @@
+package wasi:random@0.2.1;
 /// WASI Random is a random data API.
 ///
 /// It is intended to be portable at least between Unix-family platforms and
 /// Windows.
+@since(version = 0.2.0)
 interface random {
     /// Return `len` cryptographically-secure random or pseudo-random bytes.
     ///
@@ -15,11 +17,13 @@ interface random {
     /// This function must always return fresh data. Deterministic environments
     /// must omit this function, rather than implementing it with deterministic
     /// data.
-    get-random-bytes: func(len: u64) -> list<u8>
+    @since(version = 0.2.0)
+    get-random-bytes: func(len: u64) -> list<u8>;
 
     /// Return a cryptographically-secure random or pseudo-random `u64` value.
     ///
     /// This function returns the same type of data as `get-random-bytes`,
     /// represented as a `u64`.
-    get-random-u64: func() -> u64
+    @since(version = 0.2.0)
+    get-random-u64: func() -> u64;
 }
diff --git a/crates/wasi-http/wit/deps/random/world.wit b/crates/wasi-http/wit/deps/random/world.wit
index 41dc9ed10353..c615e96dc7dd 100644
--- a/crates/wasi-http/wit/deps/random/world.wit
+++ b/crates/wasi-http/wit/deps/random/world.wit
@@ -1,7 +1,13 @@
-package wasi:random
+package wasi:random@0.2.1;
 
+@since(version = 0.2.0)
 world imports {
-    import random
-    import insecure
-    import insecure-seed
+    @since(version = 0.2.0)
+    import random;
+
+    @since(version = 0.2.0)
+    import insecure;
+
+    @since(version = 0.2.0)
+    import insecure-seed;
 }
diff --git a/crates/wasi-http/wit/deps/sockets/instance-network.wit b/crates/wasi-http/wit/deps/sockets/instance-network.wit
index d911a29cc8dd..5f6e6c1cc983 100644
--- a/crates/wasi-http/wit/deps/sockets/instance-network.wit
+++ b/crates/wasi-http/wit/deps/sockets/instance-network.wit
@@ -1,9 +1,11 @@
 
 /// This interface provides a value-export of the default network handle..
+@since(version = 0.2.0)
 interface instance-network {
-	use network.{network}
-
-	/// Get a handle to the default network.
-	instance-network: func() -> network
+    @since(version = 0.2.0)
+    use network.{network};
 
+    /// Get a handle to the default network.
+    @since(version = 0.2.0)
+    instance-network: func() -> network;
 }
diff --git a/crates/wasi-http/wit/deps/sockets/ip-name-lookup.wit b/crates/wasi-http/wit/deps/sockets/ip-name-lookup.wit
index f998aae140ab..dc56f3000703 100644
--- a/crates/wasi-http/wit/deps/sockets/ip-name-lookup.wit
+++ b/crates/wasi-http/wit/deps/sockets/ip-name-lookup.wit
@@ -1,61 +1,56 @@
-
+@since(version = 0.2.0)
 interface ip-name-lookup {
-	use wasi:io/poll.{pollable}
-	use network.{network, error-code, ip-address, ip-address-family}
-
+    @since(version = 0.2.0)
+    use wasi:io/poll@0.2.1.{pollable};
+    @since(version = 0.2.0)
+    use network.{network, error-code, ip-address};
 
-	/// Resolve an internet host name to a list of IP addresses.
-	/// 
-	/// See the wasi-socket proposal README.md for a comparison with getaddrinfo.
-	/// 
-	/// # Parameters
-	/// - `name`: The name to look up. IP addresses are not allowed. Unicode domain names are automatically converted
-	///     to ASCII using IDNA encoding.
-	/// - `address-family`: If provided, limit the results to addresses of this specific address family.
-	/// - `include-unavailable`: When set to true, this function will also return addresses of which the runtime
-	///   thinks (or knows) can't be connected to at the moment. For example, this will return IPv6 addresses on
-	///   systems without an active IPv6 interface. Notes:
-	///     - Even when no public IPv6 interfaces are present or active, names like "localhost" can still resolve to an IPv6 address.
-	///     - Whatever is "available" or "unavailable" is volatile and can change everytime a network cable is unplugged.
-	/// 
-	/// This function never blocks. It either immediately fails or immediately returns successfully with a `resolve-address-stream`
-	/// that can be used to (asynchronously) fetch the results.
-	/// 
-	/// At the moment, the stream never completes successfully with 0 items. Ie. the first call
-	/// to `resolve-next-address` never returns `ok(none)`. This may change in the future.
-	/// 
-	/// # Typical errors
-	/// - `invalid-name`:                 `name` is a syntactically invalid domain name.
-	/// - `invalid-name`:                 `name` is an IP address.
-	/// - `address-family-not-supported`: The specified `address-family` is not supported. (EAI_FAMILY)
-	/// 
-	/// # References:
-	/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getaddrinfo.html>
-	/// - <https://man7.org/linux/man-pages/man3/getaddrinfo.3.html>
-	/// - <https://learn.microsoft.com/en-us/windows/win32/api/ws2tcpip/nf-ws2tcpip-getaddrinfo>
-	/// - <https://man.freebsd.org/cgi/man.cgi?query=getaddrinfo&sektion=3>
-	resolve-addresses: func(network: borrow<network>, name: string, address-family: option<ip-address-family>, include-unavailable: bool) -> result<resolve-address-stream, error-code>
+    /// Resolve an internet host name to a list of IP addresses.
+    ///
+    /// Unicode domain names are automatically converted to ASCII using IDNA encoding.
+    /// If the input is an IP address string, the address is parsed and returned
+    /// as-is without making any external requests.
+    ///
+    /// See the wasi-socket proposal README.md for a comparison with getaddrinfo.
+    ///
+    /// This function never blocks. It either immediately fails or immediately
+    /// returns successfully with a `resolve-address-stream` that can be used
+    /// to (asynchronously) fetch the results.
+    ///
+    /// # Typical errors
+    /// - `invalid-argument`: `name` is a syntactically invalid domain name or IP address.
+    ///
+    /// # References:
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getaddrinfo.html>
+    /// - <https://man7.org/linux/man-pages/man3/getaddrinfo.3.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/ws2tcpip/nf-ws2tcpip-getaddrinfo>
+    /// - <https://man.freebsd.org/cgi/man.cgi?query=getaddrinfo&sektion=3>
+    @since(version = 0.2.0)
+    resolve-addresses: func(network: borrow<network>, name: string) -> result<resolve-address-stream, error-code>;
 
-	resource resolve-address-stream {
-		/// Returns the next address from the resolver.
-		/// 
-		/// This function should be called multiple times. On each call, it will
-		/// return the next address in connection order preference. If all
-		/// addresses have been exhausted, this function returns `none`.
-		/// 
-		/// This function never returns IPv4-mapped IPv6 addresses.
-		/// 
-		/// # Typical errors
-		/// - `name-unresolvable`:          Name does not exist or has no suitable associated IP addresses. (EAI_NONAME, EAI_NODATA, EAI_ADDRFAMILY)
-		/// - `temporary-resolver-failure`: A temporary failure in name resolution occurred. (EAI_AGAIN)
-		/// - `permanent-resolver-failure`: A permanent failure in name resolution occurred. (EAI_FAIL)
-		/// - `would-block`:                A result is not available yet. (EWOULDBLOCK, EAGAIN)
-		resolve-next-address: func() -> result<option<ip-address>, error-code>
+    @since(version = 0.2.0)
+    resource resolve-address-stream {
+        /// Returns the next address from the resolver.
+        ///
+        /// This function should be called multiple times. On each call, it will
+        /// return the next address in connection order preference. If all
+        /// addresses have been exhausted, this function returns `none`.
+        ///
+        /// This function never returns IPv4-mapped IPv6 addresses.
+        ///
+        /// # Typical errors
+        /// - `name-unresolvable`:          Name does not exist or has no suitable associated IP addresses. (EAI_NONAME, EAI_NODATA, EAI_ADDRFAMILY)
+        /// - `temporary-resolver-failure`: A temporary failure in name resolution occurred. (EAI_AGAIN)
+        /// - `permanent-resolver-failure`: A permanent failure in name resolution occurred. (EAI_FAIL)
+        /// - `would-block`:                A result is not available yet. (EWOULDBLOCK, EAGAIN)
+        @since(version = 0.2.0)
+        resolve-next-address: func() -> result<option<ip-address>, error-code>;
 
-		/// Create a `pollable` which will resolve once the stream is ready for I/O.
-		/// 
-		/// Note: this function is here for WASI Preview2 only.
-		/// It's planned to be removed when `future` is natively supported in Preview3.
-		subscribe: func() -> pollable
-	}
+        /// Create a `pollable` which will resolve once the stream is ready for I/O.
+        ///
+        /// Note: this function is here for WASI Preview2 only.
+        /// It's planned to be removed when `future` is natively supported in Preview3.
+        @since(version = 0.2.0)
+        subscribe: func() -> pollable;
+    }
 }
diff --git a/crates/wasi-http/wit/deps/sockets/network.wit b/crates/wasi-http/wit/deps/sockets/network.wit
index 8214eaaf7211..8c13b348e534 100644
--- a/crates/wasi-http/wit/deps/sockets/network.wit
+++ b/crates/wasi-http/wit/deps/sockets/network.wit
@@ -1,178 +1,153 @@
-
+@since(version = 0.2.0)
 interface network {
-	/// An opaque resource that represents access to (a subset of) the network.
-	/// This enables context-based security for networking.
-	/// There is no need for this to map 1:1 to a physical network interface.
-	resource network
-
-	/// Error codes.
-	/// 
-	/// In theory, every API can return any error code.
-	/// In practice, API's typically only return the errors documented per API
-	/// combined with a couple of errors that are always possible:
-	/// - `unknown`
-	/// - `access-denied`
-	/// - `not-supported`
-	/// - `out-of-memory`
-	/// 
-	/// See each individual API for what the POSIX equivalents are. They sometimes differ per API.
-	enum error-code {
-		// ### GENERAL ERRORS ###
-
-		/// Unknown error
-		unknown,
-
-		/// Access denied.
-		/// 
-		/// POSIX equivalent: EACCES, EPERM
-		access-denied,
-
-		/// The operation is not supported.
-		/// 
-		/// POSIX equivalent: EOPNOTSUPP
-		not-supported,
-
-		/// Not enough memory to complete the operation.
-		/// 
-		/// POSIX equivalent: ENOMEM, ENOBUFS, EAI_MEMORY
-		out-of-memory,
-
-		/// The operation timed out before it could finish completely.
-		timeout,
-
-		/// This operation is incompatible with another asynchronous operation that is already in progress.
-		concurrency-conflict,
-
-		/// Trying to finish an asynchronous operation that:
-		/// - has not been started yet, or:
-		/// - was already finished by a previous `finish-*` call.
-		/// 
-		/// Note: this is scheduled to be removed when `future`s are natively supported.
-		not-in-progress,
-
-		/// The operation has been aborted because it could not be completed immediately.
-		/// 
-		/// Note: this is scheduled to be removed when `future`s are natively supported.
-		would-block,
-
-
-		// ### IP ERRORS ###
-
-		/// The specified address-family is not supported.
-		address-family-not-supported,
-
-		/// An IPv4 address was passed to an IPv6 resource, or vice versa.
-		address-family-mismatch,
-
-		/// The socket address is not a valid remote address. E.g. the IP address is set to INADDR_ANY, or the port is set to 0.
-		invalid-remote-address,
-
-		/// The operation is only supported on IPv4 resources.
-		ipv4-only-operation,
-
-		/// The operation is only supported on IPv6 resources.
-		ipv6-only-operation,
-
-
-
-		// ### TCP & UDP SOCKET ERRORS ###
-
-		/// A new socket resource could not be created because of a system limit.
-		new-socket-limit,
-		
-		/// The socket is already attached to another network.
-		already-attached,
-
-		/// The socket is already bound.
-		already-bound,
-
-		/// The socket is already in the Connection state.
-		already-connected,
-
-		/// The socket is not bound to any local address.
-		not-bound,
-
-		/// The socket is not in the Connection state.
-		not-connected,
-
-		/// A bind operation failed because the provided address is not an address that the `network` can bind to.
-		address-not-bindable,
-
-		/// A bind operation failed because the provided address is already in use.
-		address-in-use,
-
-		/// A bind operation failed because there are no ephemeral ports available.
-		ephemeral-ports-exhausted,
-
-		/// The remote address is not reachable
-		remote-unreachable,
-		
-
-		// ### TCP SOCKET ERRORS ###
-		
-		/// The socket is already in the Listener state.
-		already-listening,
-
-		/// The socket is already in the Listener state.
-		not-listening,
-
-		/// The connection was forcefully rejected
-		connection-refused,
-
-		/// The connection was reset.
-		connection-reset,
-		
-
-		// ### UDP SOCKET ERRORS ###
-		datagram-too-large,
-
-
-		// ### NAME LOOKUP ERRORS ###
-		
-		/// The provided name is a syntactically invalid domain name.
-		invalid-name,
-
-		/// Name does not exist or has no suitable associated IP addresses.
-		name-unresolvable,
-
-		/// A temporary failure in name resolution occurred.
-		temporary-resolver-failure,
-
-		/// A permanent failure in name resolution occurred.
-		permanent-resolver-failure,
-	}
-
-	enum ip-address-family {
-		/// Similar to `AF_INET` in POSIX.
-		ipv4, 
-
-		/// Similar to `AF_INET6` in POSIX.
-		ipv6,
-	}
-
-	type ipv4-address = tuple<u8, u8, u8, u8>
-	type ipv6-address = tuple<u16, u16, u16, u16, u16, u16, u16, u16>
-
-	variant ip-address {
-		ipv4(ipv4-address),
-		ipv6(ipv6-address),
-	}
-
-	record ipv4-socket-address {
-		port: u16, // sin_port
-		address: ipv4-address, // sin_addr
-	}
+    /// An opaque resource that represents access to (a subset of) the network.
+    /// This enables context-based security for networking.
+    /// There is no need for this to map 1:1 to a physical network interface.
+    @since(version = 0.2.0)
+    resource network;
 
-	record ipv6-socket-address {
-		port: u16, // sin6_port
-		flow-info: u32, // sin6_flowinfo
-		address: ipv6-address, // sin6_addr
-		scope-id: u32, // sin6_scope_id
-	}
+    /// Error codes.
+    ///
+    /// In theory, every API can return any error code.
+    /// In practice, API's typically only return the errors documented per API
+    /// combined with a couple of errors that are always possible:
+    /// - `unknown`
+    /// - `access-denied`
+    /// - `not-supported`
+    /// - `out-of-memory`
+    /// - `concurrency-conflict`
+    ///
+    /// See each individual API for what the POSIX equivalents are. They sometimes differ per API.
+    @since(version = 0.2.0)
+    enum error-code {
+        /// Unknown error
+        unknown,
+
+        /// Access denied.
+        ///
+        /// POSIX equivalent: EACCES, EPERM
+        access-denied,
+
+        /// The operation is not supported.
+        ///
+        /// POSIX equivalent: EOPNOTSUPP
+        not-supported,
+
+        /// One of the arguments is invalid.
+        ///
+        /// POSIX equivalent: EINVAL
+        invalid-argument,
+
+        /// Not enough memory to complete the operation.
+        ///
+        /// POSIX equivalent: ENOMEM, ENOBUFS, EAI_MEMORY
+        out-of-memory,
+
+        /// The operation timed out before it could finish completely.
+        timeout,
+
+        /// This operation is incompatible with another asynchronous operation that is already in progress.
+        ///
+        /// POSIX equivalent: EALREADY
+        concurrency-conflict,
+
+        /// Trying to finish an asynchronous operation that:
+        /// - has not been started yet, or:
+        /// - was already finished by a previous `finish-*` call.
+        ///
+        /// Note: this is scheduled to be removed when `future`s are natively supported.
+        not-in-progress,
+
+        /// The operation has been aborted because it could not be completed immediately.
+        ///
+        /// Note: this is scheduled to be removed when `future`s are natively supported.
+        would-block,
+
+
+        /// The operation is not valid in the socket's current state.
+        invalid-state,
+
+        /// A new socket resource could not be created because of a system limit.
+        new-socket-limit,
+
+        /// A bind operation failed because the provided address is not an address that the `network` can bind to.
+        address-not-bindable,
+
+        /// A bind operation failed because the provided address is already in use or because there are no ephemeral ports available.
+        address-in-use,
+
+        /// The remote address is not reachable
+        remote-unreachable,
+
+
+        /// The TCP connection was forcefully rejected
+        connection-refused,
+
+        /// The TCP connection was reset.
+        connection-reset,
+
+        /// A TCP connection was aborted.
+        connection-aborted,
+
+
+        /// The size of a datagram sent to a UDP socket exceeded the maximum
+        /// supported size.
+        datagram-too-large,
+
+
+        /// Name does not exist or has no suitable associated IP addresses.
+        name-unresolvable,
+
+        /// A temporary failure in name resolution occurred.
+        temporary-resolver-failure,
+
+        /// A permanent failure in name resolution occurred.
+        permanent-resolver-failure,
+    }
+
+    @since(version = 0.2.0)
+    enum ip-address-family {
+        /// Similar to `AF_INET` in POSIX.
+        ipv4,
+
+        /// Similar to `AF_INET6` in POSIX.
+        ipv6,
+    }
+
+    @since(version = 0.2.0)
+    type ipv4-address = tuple<u8, u8, u8, u8>;
+    @since(version = 0.2.0)
+    type ipv6-address = tuple<u16, u16, u16, u16, u16, u16, u16, u16>;
+
+    @since(version = 0.2.0)
+    variant ip-address {
+        ipv4(ipv4-address),
+        ipv6(ipv6-address),
+    }
+
+    @since(version = 0.2.0)
+    record ipv4-socket-address {
+        /// sin_port
+        port: u16,
+        /// sin_addr
+        address: ipv4-address,
+    }
 
-	variant ip-socket-address {
-		ipv4(ipv4-socket-address),
-		ipv6(ipv6-socket-address),
-	}
+    @since(version = 0.2.0)
+    record ipv6-socket-address {
+        /// sin6_port
+        port: u16,
+        /// sin6_flowinfo
+        flow-info: u32,
+        /// sin6_addr
+        address: ipv6-address,
+        /// sin6_scope_id
+        scope-id: u32,
+    }
 
+    @since(version = 0.2.0)
+    variant ip-socket-address {
+        ipv4(ipv4-socket-address),
+        ipv6(ipv6-socket-address),
+    }
 }
diff --git a/crates/wasi-http/wit/deps/sockets/tcp-create-socket.wit b/crates/wasi-http/wit/deps/sockets/tcp-create-socket.wit
index f43bc8979047..eedbd30768c9 100644
--- a/crates/wasi-http/wit/deps/sockets/tcp-create-socket.wit
+++ b/crates/wasi-http/wit/deps/sockets/tcp-create-socket.wit
@@ -1,27 +1,30 @@
-
+@since(version = 0.2.0)
 interface tcp-create-socket {
-	use network.{network, error-code, ip-address-family}
-	use tcp.{tcp-socket}
+    @since(version = 0.2.0)
+    use network.{network, error-code, ip-address-family};
+    @since(version = 0.2.0)
+    use tcp.{tcp-socket};
 
-	/// Create a new TCP socket.
-	/// 
-	/// Similar to `socket(AF_INET or AF_INET6, SOCK_STREAM, IPPROTO_TCP)` in POSIX.
-	/// 
-	/// This function does not require a network capability handle. This is considered to be safe because
-	/// at time of creation, the socket is not bound to any `network` yet. Up to the moment `bind`/`listen`/`connect`
-	/// is called, the socket is effectively an in-memory configuration object, unable to communicate with the outside world.
-	/// 
-	/// All sockets are non-blocking. Use the wasi-poll interface to block on asynchronous operations.
-	/// 
-	/// # Typical errors
-	/// - `not-supported`:                The host does not support TCP sockets. (EOPNOTSUPP)
-	/// - `address-family-not-supported`: The specified `address-family` is not supported. (EAFNOSUPPORT)
-	/// - `new-socket-limit`:             The new socket resource could not be created because of a system limit. (EMFILE, ENFILE)
-	/// 
-	/// # References
-	/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/socket.html>
-	/// - <https://man7.org/linux/man-pages/man2/socket.2.html>
-	/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasocketw>
-	/// - <https://man.freebsd.org/cgi/man.cgi?query=socket&sektion=2>
-	create-tcp-socket: func(address-family: ip-address-family) -> result<tcp-socket, error-code>
+    /// Create a new TCP socket.
+    ///
+    /// Similar to `socket(AF_INET or AF_INET6, SOCK_STREAM, IPPROTO_TCP)` in POSIX.
+    /// On IPv6 sockets, IPV6_V6ONLY is enabled by default and can't be configured otherwise.
+    ///
+    /// This function does not require a network capability handle. This is considered to be safe because
+    /// at time of creation, the socket is not bound to any `network` yet. Up to the moment `bind`/`connect`
+    /// is called, the socket is effectively an in-memory configuration object, unable to communicate with the outside world.
+    ///
+    /// All sockets are non-blocking. Use the wasi-poll interface to block on asynchronous operations.
+    ///
+    /// # Typical errors
+    /// - `not-supported`:     The specified `address-family` is not supported. (EAFNOSUPPORT)
+    /// - `new-socket-limit`:  The new socket resource could not be created because of a system limit. (EMFILE, ENFILE)
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/socket.html>
+    /// - <https://man7.org/linux/man-pages/man2/socket.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasocketw>
+    /// - <https://man.freebsd.org/cgi/man.cgi?query=socket&sektion=2>
+    @since(version = 0.2.0)
+    create-tcp-socket: func(address-family: ip-address-family) -> result<tcp-socket, error-code>;
 }
diff --git a/crates/wasi-http/wit/deps/sockets/tcp.wit b/crates/wasi-http/wit/deps/sockets/tcp.wit
index 175626cc7620..bae5a29eceb4 100644
--- a/crates/wasi-http/wit/deps/sockets/tcp.wit
+++ b/crates/wasi-http/wit/deps/sockets/tcp.wit
@@ -1,249 +1,387 @@
-
+@since(version = 0.2.0)
 interface tcp {
-	use wasi:io/streams.{input-stream, output-stream}
-	use wasi:io/poll.{pollable}
-	use network.{network, error-code, ip-socket-address, ip-address-family}
-
-	enum shutdown-type {
-		/// Similar to `SHUT_RD` in POSIX.
-		receive,
-
-		/// Similar to `SHUT_WR` in POSIX.
-		send,
-
-		/// Similar to `SHUT_RDWR` in POSIX.
-		both,
-	}
-
-
-	/// A TCP socket handle.
-	resource tcp-socket {
-		/// Bind the socket to a specific network on the provided IP address and port.
-		///
-		/// If the IP address is zero (`0.0.0.0` in IPv4, `::` in IPv6), it is left to the implementation to decide which
-		/// network interface(s) to bind to.
-		/// If the TCP/UDP port is zero, the socket will be bound to a random free port.
-		/// 
-		/// When a socket is not explicitly bound, the first invocation to a listen or connect operation will
-		/// implicitly bind the socket.
-		/// 
-		/// Unlike in POSIX, this function is async. This enables interactive WASI hosts to inject permission prompts.
-		/// 
-		/// # Typical `start` errors
-		/// - `address-family-mismatch`:   The `local-address` has the wrong address family. (EINVAL)
-		/// - `already-bound`:             The socket is already bound. (EINVAL)
-		/// - `concurrency-conflict`:      Another `bind`, `connect` or `listen` operation is already in progress. (EALREADY)
-		/// 
-		/// # Typical `finish` errors
-		/// - `ephemeral-ports-exhausted`: No ephemeral ports available. (EADDRINUSE, ENOBUFS on Windows)
-		/// - `address-in-use`:            Address is already in use. (EADDRINUSE)
-		/// - `address-not-bindable`:      `local-address` is not an address that the `network` can bind to. (EADDRNOTAVAIL)
-		/// - `not-in-progress`:           A `bind` operation is not in progress.
-		/// - `would-block`:               Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)
-		/// 
-		/// # References
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/bind.html>
-		/// - <https://man7.org/linux/man-pages/man2/bind.2.html>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-bind>
-		/// - <https://man.freebsd.org/cgi/man.cgi?query=bind&sektion=2&format=html>
-		start-bind: func(network: borrow<network>, local-address: ip-socket-address) -> result<_, error-code>
-		finish-bind: func() -> result<_, error-code>
-
-		/// Connect to a remote endpoint.
-		/// 
-		/// On success:
-		/// - the socket is transitioned into the Connection state
-		/// - a pair of streams is returned that can be used to read & write to the connection
-		/// 
-		/// # Typical `start` errors
-		/// - `address-family-mismatch`:   The `remote-address` has the wrong address family. (EAFNOSUPPORT)
-		/// - `invalid-remote-address`:    The IP address in `remote-address` is set to INADDR_ANY (`0.0.0.0` / `::`). (EADDRNOTAVAIL on Windows)
-		/// - `invalid-remote-address`:    The port in `remote-address` is set to 0. (EADDRNOTAVAIL on Windows)
-		/// - `already-attached`:          The socket is already attached to a different network. The `network` passed to `connect` must be identical to the one passed to `bind`.
-		/// - `already-connected`:         The socket is already in the Connection state. (EISCONN)
-		/// - `already-listening`:         The socket is already in the Listener state. (EOPNOTSUPP, EINVAL on Windows)
-		/// - `concurrency-conflict`:      Another `bind`, `connect` or `listen` operation is already in progress. (EALREADY)
-		/// 
-		/// # Typical `finish` errors
-		/// - `timeout`:                   Connection timed out. (ETIMEDOUT)
-		/// - `connection-refused`:        The connection was forcefully rejected. (ECONNREFUSED)
-		/// - `connection-reset`:          The connection was reset. (ECONNRESET)
-		/// - `remote-unreachable`:        The remote address is not reachable. (EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN)
-		/// - `ephemeral-ports-exhausted`: Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE, EADDRNOTAVAIL on Linux, EAGAIN on BSD)
-		/// - `not-in-progress`:           A `connect` operation is not in progress.
-		/// - `would-block`:               Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)
-		/// 
-		/// # References
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/connect.html>
-		/// - <https://man7.org/linux/man-pages/man2/connect.2.html>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-connect>
-		/// - <https://man.freebsd.org/cgi/man.cgi?connect>
-		start-connect: func(network: borrow<network>, remote-address: ip-socket-address) -> result<_, error-code>
-		finish-connect: func() -> result<tuple<input-stream, output-stream>, error-code>
-
-		/// Start listening for new connections.
-		/// 
-		/// Transitions the socket into the Listener state.
-		/// 
-		/// Unlike POSIX:
-		/// - this function is async. This enables interactive WASI hosts to inject permission prompts.
-		/// - the socket must already be explicitly bound.
-		/// 
-		/// # Typical `start` errors
-		/// - `not-bound`:                 The socket is not bound to any local address. (EDESTADDRREQ)
-		/// - `already-connected`:         The socket is already in the Connection state. (EISCONN, EINVAL on BSD)
-		/// - `already-listening`:         The socket is already in the Listener state.
-		/// - `concurrency-conflict`:      Another `bind`, `connect` or `listen` operation is already in progress. (EINVAL on BSD)
-		///
-		/// # Typical `finish` errors
-		/// - `ephemeral-ports-exhausted`: Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE)
-		/// - `not-in-progress`:           A `listen` operation is not in progress.
-		/// - `would-block`:               Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)
-		///
-		/// # References
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/listen.html>
-		/// - <https://man7.org/linux/man-pages/man2/listen.2.html>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-listen>
-		/// - <https://man.freebsd.org/cgi/man.cgi?query=listen&sektion=2>
-		start-listen: func() -> result<_, error-code>
-		finish-listen: func() -> result<_, error-code>
-
-		/// Accept a new client socket.
-		/// 
-		/// The returned socket is bound and in the Connection state.
-		/// 
-		/// On success, this function returns the newly accepted client socket along with
-		/// a pair of streams that can be used to read & write to the connection.
-		/// 
-		/// # Typical errors
-		/// - `not-listening`: Socket is not in the Listener state. (EINVAL)
-		/// - `would-block`:   No pending connections at the moment. (EWOULDBLOCK, EAGAIN)
-		/// 
-		/// Host implementations must skip over transient errors returned by the native accept syscall.
-		/// 
-		/// # References
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/accept.html>
-		/// - <https://man7.org/linux/man-pages/man2/accept.2.html>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-accept>
-		/// - <https://man.freebsd.org/cgi/man.cgi?query=accept&sektion=2>
-		accept: func() -> result<tuple<tcp-socket, input-stream, output-stream>, error-code>
-
-		/// Get the bound local address.
-		/// 
-		/// # Typical errors
-		/// - `not-bound`: The socket is not bound to any local address.
-		/// 
-		/// # References
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsockname.html>
-		/// - <https://man7.org/linux/man-pages/man2/getsockname.2.html>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getsockname>
-		/// - <https://man.freebsd.org/cgi/man.cgi?getsockname>
-		local-address: func() -> result<ip-socket-address, error-code>
-
-		/// Get the bound remote address.
-		/// 
-		/// # Typical errors
-		/// - `not-connected`: The socket is not connected to a remote address. (ENOTCONN)
-		/// 
-		/// # References
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpeername.html>
-		/// - <https://man7.org/linux/man-pages/man2/getpeername.2.html>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getpeername>
-		/// - <https://man.freebsd.org/cgi/man.cgi?query=getpeername&sektion=2&n=1>
-		remote-address: func() -> result<ip-socket-address, error-code>
-
-		/// Whether this is a IPv4 or IPv6 socket.
-		/// 
-		/// Equivalent to the SO_DOMAIN socket option.
-		address-family: func() -> ip-address-family
-	
-		/// Whether IPv4 compatibility (dual-stack) mode is disabled or not.
-		/// 
-		/// Equivalent to the IPV6_V6ONLY socket option.
-		/// 
-		/// # Typical errors
-		/// - `ipv6-only-operation`:  (get/set) `this` socket is an IPv4 socket.
-		/// - `already-bound`:        (set) The socket is already bound.
-		/// - `not-supported`:        (set) Host does not support dual-stack sockets. (Implementations are not required to.)
-		/// - `concurrency-conflict`: (set) A `bind`, `connect` or `listen` operation is already in progress. (EALREADY)
-		ipv6-only: func() -> result<bool, error-code>
-		set-ipv6-only: func(value: bool) -> result<_, error-code>
-
-		/// Hints the desired listen queue size. Implementations are free to ignore this.
-		/// 
-		/// # Typical errors
-		/// - `already-connected`:    (set) The socket is already in the Connection state.
-		/// - `concurrency-conflict`: (set) A `bind`, `connect` or `listen` operation is already in progress. (EALREADY)
-		set-listen-backlog-size: func(value: u64) -> result<_, error-code>
-
-		/// Equivalent to the SO_KEEPALIVE socket option.
-		/// 
-		/// # Typical errors
-		/// - `concurrency-conflict`: (set) A `bind`, `connect` or `listen` operation is already in progress. (EALREADY)
-		keep-alive: func() -> result<bool, error-code>
-		set-keep-alive: func(value: bool) -> result<_, error-code>
-
-		/// Equivalent to the TCP_NODELAY socket option.
-		/// 
-		/// # Typical errors
-		/// - `concurrency-conflict`: (set) A `bind`, `connect` or `listen` operation is already in progress. (EALREADY)
-		no-delay: func() -> result<bool, error-code>
-		set-no-delay: func(value: bool) -> result<_, error-code>
-	
-		/// Equivalent to the IP_TTL & IPV6_UNICAST_HOPS socket options.
-		/// 
-		/// # Typical errors
-		/// - `already-connected`:    (set) The socket is already in the Connection state.
-		/// - `already-listening`:    (set) The socket is already in the Listener state.
-		/// - `concurrency-conflict`: (set) A `bind`, `connect` or `listen` operation is already in progress. (EALREADY)
-		unicast-hop-limit: func() -> result<u8, error-code>
-		set-unicast-hop-limit: func(value: u8) -> result<_, error-code>
-
-		/// The kernel buffer space reserved for sends/receives on this socket.
-		/// 
-		/// Note #1: an implementation may choose to cap or round the buffer size when setting the value.
-		/// 	In other words, after setting a value, reading the same setting back may return a different value.
-		/// 
-		/// Note #2: there is not necessarily a direct relationship between the kernel buffer size and the bytes of
-		/// 	actual data to be sent/received by the application, because the kernel might also use the buffer space
-		/// 	for internal metadata structures.
-		/// 
-		/// Equivalent to the SO_RCVBUF and SO_SNDBUF socket options.
-		/// 
-		/// # Typical errors
-		/// - `already-connected`:    (set) The socket is already in the Connection state.
-		/// - `already-listening`:    (set) The socket is already in the Listener state.
-		/// - `concurrency-conflict`: (set) A `bind`, `connect` or `listen` operation is already in progress. (EALREADY)
-		receive-buffer-size: func() -> result<u64, error-code>
-		set-receive-buffer-size: func(value: u64) -> result<_, error-code>
-		send-buffer-size: func() -> result<u64, error-code>
-		set-send-buffer-size: func(value: u64) -> result<_, error-code>
-
-		/// Create a `pollable` which will resolve once the socket is ready for I/O.
-		/// 
-		/// Note: this function is here for WASI Preview2 only.
-		/// It's planned to be removed when `future` is natively supported in Preview3.
-		subscribe: func() -> pollable
-
-		/// Initiate a graceful shutdown.
-		/// 
-		/// - receive: the socket is not expecting to receive any more data from the peer. All subsequent read
-		///   operations on the `input-stream` associated with this socket will return an End Of Stream indication.
-		///   Any data still in the receive queue at time of calling `shutdown` will be discarded.
-		/// - send: the socket is not expecting to send any more data to the peer. All subsequent write
-		///   operations on the `output-stream` associated with this socket will return an error.
-		/// - both: same effect as receive & send combined.
-		/// 
-		/// The shutdown function does not close (drop) the socket.
-		/// 
-		/// # Typical errors
-		/// - `not-connected`: The socket is not in the Connection state. (ENOTCONN)
-		/// 
-		/// # References
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/shutdown.html>
-		/// - <https://man7.org/linux/man-pages/man2/shutdown.2.html>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-shutdown>
-		/// - <https://man.freebsd.org/cgi/man.cgi?query=shutdown&sektion=2>
-		shutdown: func(shutdown-type: shutdown-type) -> result<_, error-code>
-	}
+    @since(version = 0.2.0)
+    use wasi:io/streams@0.2.1.{input-stream, output-stream};
+    @since(version = 0.2.0)
+    use wasi:io/poll@0.2.1.{pollable};
+    @since(version = 0.2.0)
+    use wasi:clocks/monotonic-clock@0.2.1.{duration};
+    @since(version = 0.2.0)
+    use network.{network, error-code, ip-socket-address, ip-address-family};
+
+    @since(version = 0.2.0)
+    enum shutdown-type {
+        /// Similar to `SHUT_RD` in POSIX.
+        receive,
+
+        /// Similar to `SHUT_WR` in POSIX.
+        send,
+
+        /// Similar to `SHUT_RDWR` in POSIX.
+        both,
+    }
+    
+    /// A TCP socket resource.
+    ///
+    /// The socket can be in one of the following states:
+    /// - `unbound`
+    /// - `bind-in-progress`
+    /// - `bound` (See note below)
+    /// - `listen-in-progress`
+    /// - `listening`
+    /// - `connect-in-progress`
+    /// - `connected`
+    /// - `closed`
+    /// See <https://github.com/WebAssembly/wasi-sockets/blob/main/TcpSocketOperationalSemantics.md>
+    /// for more information.
+    ///
+    /// Note: Except where explicitly mentioned, whenever this documentation uses
+    /// the term "bound" without backticks it actually means: in the `bound` state *or higher*.
+    /// (i.e. `bound`, `listen-in-progress`, `listening`, `connect-in-progress` or `connected`)
+    ///
+    /// In addition to the general error codes documented on the
+    /// `network::error-code` type, TCP socket methods may always return
+    /// `error(invalid-state)` when in the `closed` state.
+    @since(version = 0.2.0)
+    resource tcp-socket {
+        /// Bind the socket to a specific network on the provided IP address and port.
+        ///
+        /// If the IP address is zero (`0.0.0.0` in IPv4, `::` in IPv6), it is left to the implementation to decide which
+        /// network interface(s) to bind to.
+        /// If the TCP/UDP port is zero, the socket will be bound to a random free port.
+        ///
+        /// Bind can be attempted multiple times on the same socket, even with
+        /// different arguments on each iteration. But never concurrently and
+        /// only as long as the previous bind failed. Once a bind succeeds, the
+        /// binding can't be changed anymore.
+        ///
+        /// # Typical errors
+        /// - `invalid-argument`:          The `local-address` has the wrong address family. (EAFNOSUPPORT, EFAULT on Windows)
+        /// - `invalid-argument`:          `local-address` is not a unicast address. (EINVAL)
+        /// - `invalid-argument`:          `local-address` is an IPv4-mapped IPv6 address. (EINVAL)
+        /// - `invalid-state`:             The socket is already bound. (EINVAL)
+        /// - `address-in-use`:            No ephemeral ports available. (EADDRINUSE, ENOBUFS on Windows)
+        /// - `address-in-use`:            Address is already in use. (EADDRINUSE)
+        /// - `address-not-bindable`:      `local-address` is not an address that the `network` can bind to. (EADDRNOTAVAIL)
+        /// - `not-in-progress`:           A `bind` operation is not in progress.
+        /// - `would-block`:               Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)
+        /// 
+        /// # Implementors note
+        /// When binding to a non-zero port, this bind operation shouldn't be affected by the TIME_WAIT
+        /// state of a recently closed socket on the same local address. In practice this means that the SO_REUSEADDR 
+        /// socket option should be set implicitly on all platforms, except on Windows where this is the default behavior
+        /// and SO_REUSEADDR performs something different entirely.
+        ///
+        /// Unlike in POSIX, in WASI the bind operation is async. This enables
+        /// interactive WASI hosts to inject permission prompts. Runtimes that
+        /// don't want to make use of this ability can simply call the native
+        /// `bind` as part of either `start-bind` or `finish-bind`.
+        ///
+        /// # References
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/bind.html>
+        /// - <https://man7.org/linux/man-pages/man2/bind.2.html>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-bind>
+        /// - <https://man.freebsd.org/cgi/man.cgi?query=bind&sektion=2&format=html>
+        @since(version = 0.2.0)
+        start-bind: func(network: borrow<network>, local-address: ip-socket-address) -> result<_, error-code>;
+        @since(version = 0.2.0)
+        finish-bind: func() -> result<_, error-code>;
+
+        /// Connect to a remote endpoint.
+        ///
+        /// On success:
+        /// - the socket is transitioned into the `connected` state.
+        /// - a pair of streams is returned that can be used to read & write to the connection
+        ///
+        /// After a failed connection attempt, the socket will be in the `closed`
+        /// state and the only valid action left is to `drop` the socket. A single
+        /// socket can not be used to connect more than once.
+        ///
+        /// # Typical errors
+        /// - `invalid-argument`:          The `remote-address` has the wrong address family. (EAFNOSUPPORT)
+        /// - `invalid-argument`:          `remote-address` is not a unicast address. (EINVAL, ENETUNREACH on Linux, EAFNOSUPPORT on MacOS)
+        /// - `invalid-argument`:          `remote-address` is an IPv4-mapped IPv6 address. (EINVAL, EADDRNOTAVAIL on Illumos)
+        /// - `invalid-argument`:          The IP address in `remote-address` is set to INADDR_ANY (`0.0.0.0` / `::`). (EADDRNOTAVAIL on Windows)
+        /// - `invalid-argument`:          The port in `remote-address` is set to 0. (EADDRNOTAVAIL on Windows)
+        /// - `invalid-argument`:          The socket is already attached to a different network. The `network` passed to `connect` must be identical to the one passed to `bind`.
+        /// - `invalid-state`:             The socket is already in the `connected` state. (EISCONN)
+        /// - `invalid-state`:             The socket is already in the `listening` state. (EOPNOTSUPP, EINVAL on Windows)
+        /// - `timeout`:                   Connection timed out. (ETIMEDOUT)
+        /// - `connection-refused`:        The connection was forcefully rejected. (ECONNREFUSED)
+        /// - `connection-reset`:          The connection was reset. (ECONNRESET)
+        /// - `connection-aborted`:        The connection was aborted. (ECONNABORTED)
+        /// - `remote-unreachable`:        The remote address is not reachable. (EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
+        /// - `address-in-use`:            Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE, EADDRNOTAVAIL on Linux, EAGAIN on BSD)
+        /// - `not-in-progress`:           A connect operation is not in progress.
+        /// - `would-block`:               Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)
+        ///
+        /// # Implementors note
+        /// The POSIX equivalent of `start-connect` is the regular `connect` syscall.
+        /// Because all WASI sockets are non-blocking this is expected to return
+        /// EINPROGRESS, which should be translated to `ok()` in WASI.
+        ///
+        /// The POSIX equivalent of `finish-connect` is a `poll` for event `POLLOUT`
+        /// with a timeout of 0 on the socket descriptor. Followed by a check for
+        /// the `SO_ERROR` socket option, in case the poll signaled readiness.
+        ///
+        /// # References
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/connect.html>
+        /// - <https://man7.org/linux/man-pages/man2/connect.2.html>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-connect>
+        /// - <https://man.freebsd.org/cgi/man.cgi?connect>
+        @since(version = 0.2.0)
+        start-connect: func(network: borrow<network>, remote-address: ip-socket-address) -> result<_, error-code>;
+        @since(version = 0.2.0)
+        finish-connect: func() -> result<tuple<input-stream, output-stream>, error-code>;
+
+        /// Start listening for new connections.
+        ///
+        /// Transitions the socket into the `listening` state.
+        ///
+        /// Unlike POSIX, the socket must already be explicitly bound.
+        ///
+        /// # Typical errors
+        /// - `invalid-state`:             The socket is not bound to any local address. (EDESTADDRREQ)
+        /// - `invalid-state`:             The socket is already in the `connected` state. (EISCONN, EINVAL on BSD)
+        /// - `invalid-state`:             The socket is already in the `listening` state.
+        /// - `address-in-use`:            Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE)
+        /// - `not-in-progress`:           A listen operation is not in progress.
+        /// - `would-block`:               Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)
+        ///
+        /// # Implementors note
+        /// Unlike in POSIX, in WASI the listen operation is async. This enables
+        /// interactive WASI hosts to inject permission prompts. Runtimes that
+        /// don't want to make use of this ability can simply call the native
+        /// `listen` as part of either `start-listen` or `finish-listen`.
+        ///
+        /// # References
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/listen.html>
+        /// - <https://man7.org/linux/man-pages/man2/listen.2.html>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-listen>
+        /// - <https://man.freebsd.org/cgi/man.cgi?query=listen&sektion=2>
+        @since(version = 0.2.0)
+        start-listen: func() -> result<_, error-code>;
+        @since(version = 0.2.0)
+        finish-listen: func() -> result<_, error-code>;
+
+        /// Accept a new client socket.
+        ///
+        /// The returned socket is bound and in the `connected` state. The following properties are inherited from the listener socket:
+        /// - `address-family`
+        /// - `keep-alive-enabled`
+        /// - `keep-alive-idle-time`
+        /// - `keep-alive-interval`
+        /// - `keep-alive-count`
+        /// - `hop-limit`
+        /// - `receive-buffer-size`
+        /// - `send-buffer-size`
+        ///
+        /// On success, this function returns the newly accepted client socket along with
+        /// a pair of streams that can be used to read & write to the connection.
+        ///
+        /// # Typical errors
+        /// - `invalid-state`:      Socket is not in the `listening` state. (EINVAL)
+        /// - `would-block`:        No pending connections at the moment. (EWOULDBLOCK, EAGAIN)
+        /// - `connection-aborted`: An incoming connection was pending, but was terminated by the client before this listener could accept it. (ECONNABORTED)
+        /// - `new-socket-limit`:   The new socket resource could not be created because of a system limit. (EMFILE, ENFILE)
+        ///
+        /// # References
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/accept.html>
+        /// - <https://man7.org/linux/man-pages/man2/accept.2.html>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-accept>
+        /// - <https://man.freebsd.org/cgi/man.cgi?query=accept&sektion=2>
+        @since(version = 0.2.0)
+        accept: func() -> result<tuple<tcp-socket, input-stream, output-stream>, error-code>;
+
+        /// Get the bound local address.
+        ///
+        /// POSIX mentions:
+        /// > If the socket has not been bound to a local name, the value
+        /// > stored in the object pointed to by `address` is unspecified.
+        ///
+        /// WASI is stricter and requires `local-address` to return `invalid-state` when the socket hasn't been bound yet.
+        ///
+        /// # Typical errors
+        /// - `invalid-state`: The socket is not bound to any local address.
+        ///
+        /// # References
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsockname.html>
+        /// - <https://man7.org/linux/man-pages/man2/getsockname.2.html>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getsockname>
+        /// - <https://man.freebsd.org/cgi/man.cgi?getsockname>
+        @since(version = 0.2.0)
+        local-address: func() -> result<ip-socket-address, error-code>;
+
+        /// Get the remote address.
+        ///
+        /// # Typical errors
+        /// - `invalid-state`: The socket is not connected to a remote address. (ENOTCONN)
+        ///
+        /// # References
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpeername.html>
+        /// - <https://man7.org/linux/man-pages/man2/getpeername.2.html>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getpeername>
+        /// - <https://man.freebsd.org/cgi/man.cgi?query=getpeername&sektion=2&n=1>
+        @since(version = 0.2.0)
+        remote-address: func() -> result<ip-socket-address, error-code>;
+
+        /// Whether the socket is in the `listening` state.
+        ///
+        /// Equivalent to the SO_ACCEPTCONN socket option.
+        @since(version = 0.2.0)
+        is-listening: func() -> bool;
+
+        /// Whether this is a IPv4 or IPv6 socket.
+        ///
+        /// Equivalent to the SO_DOMAIN socket option.
+        @since(version = 0.2.0)
+        address-family: func() -> ip-address-family;
+
+        /// Hints the desired listen queue size. Implementations are free to ignore this.
+        ///
+        /// If the provided value is 0, an `invalid-argument` error is returned.
+        /// Any other value will never cause an error, but it might be silently clamped and/or rounded.
+        ///
+        /// # Typical errors
+        /// - `not-supported`:        (set) The platform does not support changing the backlog size after the initial listen.
+        /// - `invalid-argument`:     (set) The provided value was 0.
+        /// - `invalid-state`:        (set) The socket is in the `connect-in-progress` or `connected` state.
+        @since(version = 0.2.0)
+        set-listen-backlog-size: func(value: u64) -> result<_, error-code>;
+
+        /// Enables or disables keepalive.
+        ///
+        /// The keepalive behavior can be adjusted using:
+        /// - `keep-alive-idle-time`
+        /// - `keep-alive-interval`
+        /// - `keep-alive-count`
+        /// These properties can be configured while `keep-alive-enabled` is false, but only come into effect when `keep-alive-enabled` is true.
+        ///
+        /// Equivalent to the SO_KEEPALIVE socket option.
+        @since(version = 0.2.0)
+        keep-alive-enabled: func() -> result<bool, error-code>;
+        @since(version = 0.2.0)
+        set-keep-alive-enabled: func(value: bool) -> result<_, error-code>;
+
+        /// Amount of time the connection has to be idle before TCP starts sending keepalive packets.
+        ///
+        /// If the provided value is 0, an `invalid-argument` error is returned.
+        /// Any other value will never cause an error, but it might be silently clamped and/or rounded.
+        /// I.e. after setting a value, reading the same setting back may return a different value.
+        ///
+        /// Equivalent to the TCP_KEEPIDLE socket option. (TCP_KEEPALIVE on MacOS)
+        ///
+        /// # Typical errors
+        /// - `invalid-argument`:     (set) The provided value was 0.
+        @since(version = 0.2.0)
+        keep-alive-idle-time: func() -> result<duration, error-code>;
+        @since(version = 0.2.0)
+        set-keep-alive-idle-time: func(value: duration) -> result<_, error-code>;
+
+        /// The time between keepalive packets.
+        ///
+        /// If the provided value is 0, an `invalid-argument` error is returned.
+        /// Any other value will never cause an error, but it might be silently clamped and/or rounded.
+        /// I.e. after setting a value, reading the same setting back may return a different value.
+        ///
+        /// Equivalent to the TCP_KEEPINTVL socket option.
+        ///
+        /// # Typical errors
+        /// - `invalid-argument`:     (set) The provided value was 0.
+        @since(version = 0.2.0)
+        keep-alive-interval: func() -> result<duration, error-code>;
+        @since(version = 0.2.0)
+        set-keep-alive-interval: func(value: duration) -> result<_, error-code>;
+
+        /// The maximum amount of keepalive packets TCP should send before aborting the connection.
+        ///
+        /// If the provided value is 0, an `invalid-argument` error is returned.
+        /// Any other value will never cause an error, but it might be silently clamped and/or rounded.
+        /// I.e. after setting a value, reading the same setting back may return a different value.
+        ///
+        /// Equivalent to the TCP_KEEPCNT socket option.
+        ///
+        /// # Typical errors
+        /// - `invalid-argument`:     (set) The provided value was 0.
+        @since(version = 0.2.0)
+        keep-alive-count: func() -> result<u32, error-code>;
+        @since(version = 0.2.0)
+        set-keep-alive-count: func(value: u32) -> result<_, error-code>;
+
+        /// Equivalent to the IP_TTL & IPV6_UNICAST_HOPS socket options.
+        ///
+        /// If the provided value is 0, an `invalid-argument` error is returned.
+        ///
+        /// # Typical errors
+        /// - `invalid-argument`:     (set) The TTL value must be 1 or higher.
+        @since(version = 0.2.0)
+        hop-limit: func() -> result<u8, error-code>;
+        @since(version = 0.2.0)
+        set-hop-limit: func(value: u8) -> result<_, error-code>;
+
+        /// The kernel buffer space reserved for sends/receives on this socket.
+        ///
+        /// If the provided value is 0, an `invalid-argument` error is returned.
+        /// Any other value will never cause an error, but it might be silently clamped and/or rounded.
+        /// I.e. after setting a value, reading the same setting back may return a different value.
+        ///
+        /// Equivalent to the SO_RCVBUF and SO_SNDBUF socket options.
+        ///
+        /// # Typical errors
+        /// - `invalid-argument`:     (set) The provided value was 0.
+        @since(version = 0.2.0)
+        receive-buffer-size: func() -> result<u64, error-code>;
+        @since(version = 0.2.0)
+        set-receive-buffer-size: func(value: u64) -> result<_, error-code>;
+        @since(version = 0.2.0)
+        send-buffer-size: func() -> result<u64, error-code>;
+        @since(version = 0.2.0)
+        set-send-buffer-size: func(value: u64) -> result<_, error-code>;
+
+        /// Create a `pollable` which can be used to poll for, or block on,
+        /// completion of any of the asynchronous operations of this socket.
+        ///
+        /// When `finish-bind`, `finish-listen`, `finish-connect` or `accept`
+        /// return `error(would-block)`, this pollable can be used to wait for
+        /// their success or failure, after which the method can be retried.
+        ///
+        /// The pollable is not limited to the async operation that happens to be
+        /// in progress at the time of calling `subscribe` (if any). Theoretically,
+        /// `subscribe` only has to be called once per socket and can then be
+        /// (re)used for the remainder of the socket's lifetime.
+        ///
+        /// See <https://github.com/WebAssembly/wasi-sockets/blob/main/TcpSocketOperationalSemantics.md#pollable-readiness>
+        /// for more information.
+        ///
+        /// Note: this function is here for WASI Preview2 only.
+        /// It's planned to be removed when `future` is natively supported in Preview3.
+        @since(version = 0.2.0)
+        subscribe: func() -> pollable;
+
+        /// Initiate a graceful shutdown.
+        ///
+        /// - `receive`: The socket is not expecting to receive any data from
+        ///   the peer. The `input-stream` associated with this socket will be
+        ///   closed. Any data still in the receive queue at time of calling
+        ///   this method will be discarded.
+        /// - `send`: The socket has no more data to send to the peer. The `output-stream`
+        ///   associated with this socket will be closed and a FIN packet will be sent.
+        /// - `both`: Same effect as `receive` & `send` combined.
+        ///
+        /// This function is idempotent; shutting down a direction more than once
+        /// has no effect and returns `ok`.
+        ///
+        /// The shutdown function does not close (drop) the socket.
+        ///
+        /// # Typical errors
+        /// - `invalid-state`: The socket is not in the `connected` state. (ENOTCONN)
+        ///
+        /// # References
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/shutdown.html>
+        /// - <https://man7.org/linux/man-pages/man2/shutdown.2.html>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-shutdown>
+        /// - <https://man.freebsd.org/cgi/man.cgi?query=shutdown&sektion=2>
+        @since(version = 0.2.0)
+        shutdown: func(shutdown-type: shutdown-type) -> result<_, error-code>;
+    }
 }
diff --git a/crates/wasi-http/wit/deps/sockets/udp-create-socket.wit b/crates/wasi-http/wit/deps/sockets/udp-create-socket.wit
index cd4c08fb1000..e8eeacbfefb4 100644
--- a/crates/wasi-http/wit/deps/sockets/udp-create-socket.wit
+++ b/crates/wasi-http/wit/deps/sockets/udp-create-socket.wit
@@ -1,27 +1,30 @@
-
+@since(version = 0.2.0)
 interface udp-create-socket {
-	use network.{network, error-code, ip-address-family}
-	use udp.{udp-socket}
+    @since(version = 0.2.0)
+    use network.{network, error-code, ip-address-family};
+    @since(version = 0.2.0)
+    use udp.{udp-socket};
 
-	/// Create a new UDP socket.
-	/// 
-	/// Similar to `socket(AF_INET or AF_INET6, SOCK_DGRAM, IPPROTO_UDP)` in POSIX.
-	/// 
-	/// This function does not require a network capability handle. This is considered to be safe because
-	/// at time of creation, the socket is not bound to any `network` yet. Up to the moment `bind`/`connect` is called,
-	/// the socket is effectively an in-memory configuration object, unable to communicate with the outside world.
-	/// 
-	/// All sockets are non-blocking. Use the wasi-poll interface to block on asynchronous operations.
-	/// 
-	/// # Typical errors
-	/// - `not-supported`:                The host does not support UDP sockets. (EOPNOTSUPP)
-	/// - `address-family-not-supported`: The specified `address-family` is not supported. (EAFNOSUPPORT)
-	/// - `new-socket-limit`:             The new socket resource could not be created because of a system limit. (EMFILE, ENFILE)
-	/// 
-	/// # References:
-	/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/socket.html>
-	/// - <https://man7.org/linux/man-pages/man2/socket.2.html>
-	/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasocketw>
-	/// - <https://man.freebsd.org/cgi/man.cgi?query=socket&sektion=2>
-	create-udp-socket: func(address-family: ip-address-family) -> result<udp-socket, error-code>
+    /// Create a new UDP socket.
+    ///
+    /// Similar to `socket(AF_INET or AF_INET6, SOCK_DGRAM, IPPROTO_UDP)` in POSIX.
+    /// On IPv6 sockets, IPV6_V6ONLY is enabled by default and can't be configured otherwise.
+    ///
+    /// This function does not require a network capability handle. This is considered to be safe because
+    /// at time of creation, the socket is not bound to any `network` yet. Up to the moment `bind` is called,
+    /// the socket is effectively an in-memory configuration object, unable to communicate with the outside world.
+    ///
+    /// All sockets are non-blocking. Use the wasi-poll interface to block on asynchronous operations.
+    ///
+    /// # Typical errors
+    /// - `not-supported`:     The specified `address-family` is not supported. (EAFNOSUPPORT)
+    /// - `new-socket-limit`:  The new socket resource could not be created because of a system limit. (EMFILE, ENFILE)
+    ///
+    /// # References:
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/socket.html>
+    /// - <https://man7.org/linux/man-pages/man2/socket.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasocketw>
+    /// - <https://man.freebsd.org/cgi/man.cgi?query=socket&sektion=2>
+    @since(version = 0.2.0)
+    create-udp-socket: func(address-family: ip-address-family) -> result<udp-socket, error-code>;
 }
diff --git a/crates/wasi-http/wit/deps/sockets/udp.wit b/crates/wasi-http/wit/deps/sockets/udp.wit
index 01e5b95b97b7..b289e4943f84 100644
--- a/crates/wasi-http/wit/deps/sockets/udp.wit
+++ b/crates/wasi-http/wit/deps/sockets/udp.wit
@@ -1,214 +1,288 @@
-
+@since(version = 0.2.0)
 interface udp {
-	use wasi:io/poll.{pollable}
-	use network.{network, error-code, ip-socket-address, ip-address-family}
-
-
-	record datagram {
-		data: list<u8>, // Theoretical max size: ~64 KiB. In practice, typically less than 1500 bytes.
-		remote-address: ip-socket-address,
-
-		/// Possible future additions:
-		/// local-address: ip-socket-address, // IP_PKTINFO / IP_RECVDSTADDR / IPV6_PKTINFO
-		/// local-interface: u32, // IP_PKTINFO / IP_RECVIF
-		/// ttl: u8, // IP_RECVTTL
-		/// dscp: u6, // IP_RECVTOS
-		/// ecn: u2, // IP_RECVTOS
-	}
-
-
-
-	/// A UDP socket handle.
-	resource udp-socket {
-		/// Bind the socket to a specific network on the provided IP address and port.
-		///
-		/// If the IP address is zero (`0.0.0.0` in IPv4, `::` in IPv6), it is left to the implementation to decide which
-		/// network interface(s) to bind to.
-		/// If the TCP/UDP port is zero, the socket will be bound to a random free port.
-		/// 
-		/// When a socket is not explicitly bound, the first invocation to connect will implicitly bind the socket.
-		/// 
-		/// Unlike in POSIX, this function is async. This enables interactive WASI hosts to inject permission prompts.
-		/// 
-		/// # Typical `start` errors
-		/// - `address-family-mismatch`:   The `local-address` has the wrong address family. (EINVAL)
-		/// - `already-bound`:             The socket is already bound. (EINVAL)
-		/// - `concurrency-conflict`:      Another `bind` or `connect` operation is already in progress. (EALREADY)
-		/// 
-		/// # Typical `finish` errors
-		/// - `ephemeral-ports-exhausted`: No ephemeral ports available. (EADDRINUSE, ENOBUFS on Windows)
-		/// - `address-in-use`:            Address is already in use. (EADDRINUSE)
-		/// - `address-not-bindable`:      `local-address` is not an address that the `network` can bind to. (EADDRNOTAVAIL)
-		/// - `not-in-progress`:           A `bind` operation is not in progress.
-		/// - `would-block`:               Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)
-		/// 
-		/// # References
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/bind.html>
-		/// - <https://man7.org/linux/man-pages/man2/bind.2.html>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-bind>
-		/// - <https://man.freebsd.org/cgi/man.cgi?query=bind&sektion=2&format=html>
-		start-bind: func(network: borrow<network>, local-address: ip-socket-address) -> result<_, error-code>
-		finish-bind: func() -> result<_, error-code>
-
-		/// Set the destination address.
-		/// 
-		/// The local-address is updated based on the best network path to `remote-address`.
-		/// 
-		/// When a destination address is set:
-		/// - all receive operations will only return datagrams sent from the provided `remote-address`.
-		/// - the `send` function can only be used to send to this destination.
-		/// 
-		/// Note that this function does not generate any network traffic and the peer is not aware of this "connection".
-		/// 
-		/// Unlike in POSIX, this function is async. This enables interactive WASI hosts to inject permission prompts.
-		/// 
-		/// # Typical `start` errors
-		/// - `address-family-mismatch`:   The `remote-address` has the wrong address family. (EAFNOSUPPORT)
-		/// - `invalid-remote-address`:    The IP address in `remote-address` is set to INADDR_ANY (`0.0.0.0` / `::`). (EDESTADDRREQ, EADDRNOTAVAIL)
-		/// - `invalid-remote-address`:    The port in `remote-address` is set to 0. (EDESTADDRREQ, EADDRNOTAVAIL)
-		/// - `already-attached`:          The socket is already bound to a different network. The `network` passed to `connect` must be identical to the one passed to `bind`.
-		/// - `concurrency-conflict`:      Another `bind` or `connect` operation is already in progress. (EALREADY)
-		/// 
-		/// # Typical `finish` errors
-		/// - `ephemeral-ports-exhausted`: Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE, EADDRNOTAVAIL on Linux, EAGAIN on BSD)
-		/// - `not-in-progress`:           A `connect` operation is not in progress.
-		/// - `would-block`:               Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)
-		/// 
-		/// # References
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/connect.html>
-		/// - <https://man7.org/linux/man-pages/man2/connect.2.html>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-connect>
-		/// - <https://man.freebsd.org/cgi/man.cgi?connect>
-		start-connect: func(network: borrow<network>, remote-address: ip-socket-address) -> result<_, error-code>
-		finish-connect: func() -> result<_, error-code>
-
-		/// Receive messages on the socket.
-		/// 
-		/// This function attempts to receive up to `max-results` datagrams on the socket without blocking.
-		/// The returned list may contain fewer elements than requested, but never more.
-		/// If `max-results` is 0, this function returns successfully with an empty list.
-		/// 
-		/// # Typical errors
-		/// - `not-bound`:          The socket is not bound to any local address. (EINVAL)
-		/// - `remote-unreachable`: The remote address is not reachable. (ECONNREFUSED, ECONNRESET, ENETRESET on Windows, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN)
-		/// - `would-block`:        There is no pending data available to be read at the moment. (EWOULDBLOCK, EAGAIN)
-		/// 
-		/// # References
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/recvfrom.html>
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/recvmsg.html>
-		/// - <https://man7.org/linux/man-pages/man2/recv.2.html>
-		/// - <https://man7.org/linux/man-pages/man2/recvmmsg.2.html>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-recv>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-recvfrom>
-		/// - <https://learn.microsoft.com/en-us/previous-versions/windows/desktop/legacy/ms741687(v=vs.85)>
-		/// - <https://man.freebsd.org/cgi/man.cgi?query=recv&sektion=2>
-		receive: func(max-results: u64) -> result<list<datagram>, error-code>
-
-		/// Send messages on the socket.
-		/// 
-		/// This function attempts to send all provided `datagrams` on the socket without blocking and
-		/// returns how many messages were actually sent (or queued for sending).
-		/// 
-		/// This function semantically behaves the same as iterating the `datagrams` list and sequentially
-		/// sending each individual datagram until either the end of the list has been reached or the first error occurred.
-		/// If at least one datagram has been sent successfully, this function never returns an error.
-		/// 
-		/// If the input list is empty, the function returns `ok(0)`.
-		/// 
-		/// The remote address option is required. To send a message to the "connected" peer,
-		/// call `remote-address` to get their address.
-		/// 
-		/// # Typical errors
-		/// - `address-family-mismatch`: The `remote-address` has the wrong address family. (EAFNOSUPPORT)
-		/// - `invalid-remote-address`:  The IP address in `remote-address` is set to INADDR_ANY (`0.0.0.0` / `::`). (EDESTADDRREQ, EADDRNOTAVAIL)
-		/// - `invalid-remote-address`:  The port in `remote-address` is set to 0. (EDESTADDRREQ, EADDRNOTAVAIL)
-		/// - `already-connected`:       The socket is in "connected" mode and the `datagram.remote-address` does not match the address passed to `connect`. (EISCONN)
-		/// - `not-bound`:               The socket is not bound to any local address. Unlike POSIX, this function does not perform an implicit bind.
-		/// - `remote-unreachable`:      The remote address is not reachable. (ECONNREFUSED, ECONNRESET, ENETRESET on Windows, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN)
-		/// - `datagram-too-large`:      The datagram is too large. (EMSGSIZE)
-		/// - `would-block`:             The send buffer is currently full. (EWOULDBLOCK, EAGAIN)
-		/// 
-		/// # References
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/sendto.html>
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/sendmsg.html>
-		/// - <https://man7.org/linux/man-pages/man2/send.2.html>
-		/// - <https://man7.org/linux/man-pages/man2/sendmmsg.2.html>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-send>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-sendto>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasendmsg>
-		/// - <https://man.freebsd.org/cgi/man.cgi?query=send&sektion=2>
-		send: func(datagrams: list<datagram>) -> result<u64, error-code>
-
-		/// Get the current bound address.
-		/// 
-		/// # Typical errors
-		/// - `not-bound`: The socket is not bound to any local address.
-		/// 
-		/// # References
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsockname.html>
-		/// - <https://man7.org/linux/man-pages/man2/getsockname.2.html>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getsockname>
-		/// - <https://man.freebsd.org/cgi/man.cgi?getsockname>
-		local-address: func() -> result<ip-socket-address, error-code>
-
-		/// Get the address set with `connect`.
-		/// 
-		/// # Typical errors
-		/// - `not-connected`: The socket is not connected to a remote address. (ENOTCONN)
-		/// 
-		/// # References
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpeername.html>
-		/// - <https://man7.org/linux/man-pages/man2/getpeername.2.html>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getpeername>
-		/// - <https://man.freebsd.org/cgi/man.cgi?query=getpeername&sektion=2&n=1>
-		remote-address: func() -> result<ip-socket-address, error-code>
-
-		/// Whether this is a IPv4 or IPv6 socket.
-		/// 
-		/// Equivalent to the SO_DOMAIN socket option.
-		address-family: func() -> ip-address-family
-
-		/// Whether IPv4 compatibility (dual-stack) mode is disabled or not.
-		/// 
-		/// Equivalent to the IPV6_V6ONLY socket option.
-		/// 
-		/// # Typical errors
-		/// - `ipv6-only-operation`:  (get/set) `this` socket is an IPv4 socket.
-		/// - `already-bound`:        (set) The socket is already bound.
-		/// - `not-supported`:        (set) Host does not support dual-stack sockets. (Implementations are not required to.)
-		/// - `concurrency-conflict`: (set) Another `bind` or `connect` operation is already in progress. (EALREADY)
-		ipv6-only: func() -> result<bool, error-code>
-		set-ipv6-only: func(value: bool) -> result<_, error-code>
-
-		/// Equivalent to the IP_TTL & IPV6_UNICAST_HOPS socket options.
-		/// 
-		/// # Typical errors
-		/// - `concurrency-conflict`: (set) Another `bind` or `connect` operation is already in progress. (EALREADY)
-		unicast-hop-limit: func() -> result<u8, error-code>
-		set-unicast-hop-limit: func(value: u8) -> result<_, error-code>
-
-		/// The kernel buffer space reserved for sends/receives on this socket.
-		/// 
-		/// Note #1: an implementation may choose to cap or round the buffer size when setting the value.
-		/// 	In other words, after setting a value, reading the same setting back may return a different value.
-		/// 
-		/// Note #2: there is not necessarily a direct relationship between the kernel buffer size and the bytes of
-		/// 	actual data to be sent/received by the application, because the kernel might also use the buffer space
-		/// 	for internal metadata structures.
-		/// 
-		/// Equivalent to the SO_RCVBUF and SO_SNDBUF socket options.
-		/// 
-		/// # Typical errors
-		/// - `concurrency-conflict`: (set) Another `bind` or `connect` operation is already in progress. (EALREADY)
-		receive-buffer-size: func() -> result<u64, error-code>
-		set-receive-buffer-size: func(value: u64) -> result<_, error-code>
-		send-buffer-size: func() -> result<u64, error-code>
-		set-send-buffer-size: func(value: u64) -> result<_, error-code>
-
-		/// Create a `pollable` which will resolve once the socket is ready for I/O.
-		/// 
-		/// Note: this function is here for WASI Preview2 only.
-		/// It's planned to be removed when `future` is natively supported in Preview3.
-		subscribe: func() -> pollable
-	}
+    @since(version = 0.2.0)
+    use wasi:io/poll@0.2.1.{pollable};
+    @since(version = 0.2.0)
+    use network.{network, error-code, ip-socket-address, ip-address-family};
+
+    /// A received datagram.
+    @since(version = 0.2.0)
+    record incoming-datagram {
+        /// The payload.
+        /// 
+        /// Theoretical max size: ~64 KiB. In practice, typically less than 1500 bytes.
+        data: list<u8>,
+
+        /// The source address.
+        ///
+        /// This field is guaranteed to match the remote address the stream was initialized with, if any.
+        ///
+        /// Equivalent to the `src_addr` out parameter of `recvfrom`.
+        remote-address: ip-socket-address,
+    }
+
+    /// A datagram to be sent out.
+    @since(version = 0.2.0)
+    record outgoing-datagram {
+        /// The payload.
+        data: list<u8>,
+
+        /// The destination address.
+        ///
+        /// The requirements on this field depend on how the stream was initialized:
+        /// - with a remote address: this field must be None or match the stream's remote address exactly.
+        /// - without a remote address: this field is required.
+        ///
+        /// If this value is None, the send operation is equivalent to `send` in POSIX. Otherwise it is equivalent to `sendto`.
+        remote-address: option<ip-socket-address>,
+    }
+
+    /// A UDP socket handle.
+    @since(version = 0.2.0)
+    resource udp-socket {
+        /// Bind the socket to a specific network on the provided IP address and port.
+        ///
+        /// If the IP address is zero (`0.0.0.0` in IPv4, `::` in IPv6), it is left to the implementation to decide which
+        /// network interface(s) to bind to.
+        /// If the port is zero, the socket will be bound to a random free port.
+        ///
+        /// # Typical errors
+        /// - `invalid-argument`:          The `local-address` has the wrong address family. (EAFNOSUPPORT, EFAULT on Windows)
+        /// - `invalid-state`:             The socket is already bound. (EINVAL)
+        /// - `address-in-use`:            No ephemeral ports available. (EADDRINUSE, ENOBUFS on Windows)
+        /// - `address-in-use`:            Address is already in use. (EADDRINUSE)
+        /// - `address-not-bindable`:      `local-address` is not an address that the `network` can bind to. (EADDRNOTAVAIL)
+        /// - `not-in-progress`:           A `bind` operation is not in progress.
+        /// - `would-block`:               Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)
+        ///
+        /// # Implementors note
+        /// Unlike in POSIX, in WASI the bind operation is async. This enables
+        /// interactive WASI hosts to inject permission prompts. Runtimes that
+        /// don't want to make use of this ability can simply call the native
+        /// `bind` as part of either `start-bind` or `finish-bind`.
+        ///
+        /// # References
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/bind.html>
+        /// - <https://man7.org/linux/man-pages/man2/bind.2.html>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-bind>
+        /// - <https://man.freebsd.org/cgi/man.cgi?query=bind&sektion=2&format=html>
+        @since(version = 0.2.0)
+        start-bind: func(network: borrow<network>, local-address: ip-socket-address) -> result<_, error-code>;
+        @since(version = 0.2.0)
+        finish-bind: func() -> result<_, error-code>;
+
+        /// Set up inbound & outbound communication channels, optionally to a specific peer.
+        ///
+        /// This function only changes the local socket configuration and does not generate any network traffic.
+        /// On success, the `remote-address` of the socket is updated. The `local-address` may be updated as well,
+        /// based on the best network path to `remote-address`.
+        ///
+        /// When a `remote-address` is provided, the returned streams are limited to communicating with that specific peer:
+        /// - `send` can only be used to send to this destination.
+        /// - `receive` will only return datagrams sent from the provided `remote-address`.
+        ///
+        /// This method may be called multiple times on the same socket to change its association, but
+        /// only the most recently returned pair of streams will be operational. Implementations may trap if
+        /// the streams returned by a previous invocation haven't been dropped yet before calling `stream` again.
+        /// 
+        /// The POSIX equivalent in pseudo-code is:
+        /// ```text
+        /// if (was previously connected) {
+        /// 	connect(s, AF_UNSPEC)
+        /// }
+        /// if (remote_address is Some) {
+        /// 	connect(s, remote_address)
+        /// }
+        /// ```
+        ///
+        /// Unlike in POSIX, the socket must already be explicitly bound.
+        /// 
+        /// # Typical errors
+        /// - `invalid-argument`:          The `remote-address` has the wrong address family. (EAFNOSUPPORT)
+        /// - `invalid-argument`:          The IP address in `remote-address` is set to INADDR_ANY (`0.0.0.0` / `::`). (EDESTADDRREQ, EADDRNOTAVAIL)
+        /// - `invalid-argument`:          The port in `remote-address` is set to 0. (EDESTADDRREQ, EADDRNOTAVAIL)
+        /// - `invalid-state`:             The socket is not bound.
+        /// - `address-in-use`:            Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE, EADDRNOTAVAIL on Linux, EAGAIN on BSD)
+        /// - `remote-unreachable`:        The remote address is not reachable. (ECONNRESET, ENETRESET, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
+        /// - `connection-refused`:        The connection was refused. (ECONNREFUSED)
+        ///
+        /// # References
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/connect.html>
+        /// - <https://man7.org/linux/man-pages/man2/connect.2.html>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-connect>
+        /// - <https://man.freebsd.org/cgi/man.cgi?connect>
+        @since(version = 0.2.0)
+        %stream: func(remote-address: option<ip-socket-address>) -> result<tuple<incoming-datagram-stream, outgoing-datagram-stream>, error-code>;
+
+        /// Get the current bound address.
+        ///
+        /// POSIX mentions:
+        /// > If the socket has not been bound to a local name, the value
+        /// > stored in the object pointed to by `address` is unspecified.
+        ///
+        /// WASI is stricter and requires `local-address` to return `invalid-state` when the socket hasn't been bound yet.
+        /// 
+        /// # Typical errors
+        /// - `invalid-state`: The socket is not bound to any local address.
+        ///
+        /// # References
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsockname.html>
+        /// - <https://man7.org/linux/man-pages/man2/getsockname.2.html>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getsockname>
+        /// - <https://man.freebsd.org/cgi/man.cgi?getsockname>
+        @since(version = 0.2.0)
+        local-address: func() -> result<ip-socket-address, error-code>;
+
+        /// Get the address the socket is currently streaming to.
+        ///
+        /// # Typical errors
+        /// - `invalid-state`: The socket is not streaming to a specific remote address. (ENOTCONN)
+        ///
+        /// # References
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpeername.html>
+        /// - <https://man7.org/linux/man-pages/man2/getpeername.2.html>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getpeername>
+        /// - <https://man.freebsd.org/cgi/man.cgi?query=getpeername&sektion=2&n=1>
+        @since(version = 0.2.0)
+        remote-address: func() -> result<ip-socket-address, error-code>;
+
+        /// Whether this is a IPv4 or IPv6 socket.
+        ///
+        /// Equivalent to the SO_DOMAIN socket option.
+        @since(version = 0.2.0)
+        address-family: func() -> ip-address-family;
+
+        /// Equivalent to the IP_TTL & IPV6_UNICAST_HOPS socket options.
+        ///
+        /// If the provided value is 0, an `invalid-argument` error is returned.
+        ///
+        /// # Typical errors
+        /// - `invalid-argument`:     (set) The TTL value must be 1 or higher.
+        @since(version = 0.2.0)
+        unicast-hop-limit: func() -> result<u8, error-code>;
+        @since(version = 0.2.0)
+        set-unicast-hop-limit: func(value: u8) -> result<_, error-code>;
+
+        /// The kernel buffer space reserved for sends/receives on this socket.
+        ///
+        /// If the provided value is 0, an `invalid-argument` error is returned.
+        /// Any other value will never cause an error, but it might be silently clamped and/or rounded.
+        /// I.e. after setting a value, reading the same setting back may return a different value.
+        ///
+        /// Equivalent to the SO_RCVBUF and SO_SNDBUF socket options.
+        ///
+        /// # Typical errors
+        /// - `invalid-argument`:     (set) The provided value was 0.
+        @since(version = 0.2.0)
+        receive-buffer-size: func() -> result<u64, error-code>;
+        @since(version = 0.2.0)
+        set-receive-buffer-size: func(value: u64) -> result<_, error-code>;
+        @since(version = 0.2.0)
+        send-buffer-size: func() -> result<u64, error-code>;
+        @since(version = 0.2.0)
+        set-send-buffer-size: func(value: u64) -> result<_, error-code>;
+
+        /// Create a `pollable` which will resolve once the socket is ready for I/O.
+        ///
+        /// Note: this function is here for WASI Preview2 only.
+        /// It's planned to be removed when `future` is natively supported in Preview3.
+        @since(version = 0.2.0)
+        subscribe: func() -> pollable;
+    }
+
+    @since(version = 0.2.0)
+    resource incoming-datagram-stream {
+        /// Receive messages on the socket.
+        ///
+        /// This function attempts to receive up to `max-results` datagrams on the socket without blocking.
+        /// The returned list may contain fewer elements than requested, but never more.
+        ///
+        /// This function returns successfully with an empty list when either:
+        /// - `max-results` is 0, or:
+        /// - `max-results` is greater than 0, but no results are immediately available.
+        /// This function never returns `error(would-block)`.
+        ///
+        /// # Typical errors
+        /// - `remote-unreachable`: The remote address is not reachable. (ECONNRESET, ENETRESET on Windows, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
+        /// - `connection-refused`: The connection was refused. (ECONNREFUSED)
+        ///
+        /// # References
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/recvfrom.html>
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/recvmsg.html>
+        /// - <https://man7.org/linux/man-pages/man2/recv.2.html>
+        /// - <https://man7.org/linux/man-pages/man2/recvmmsg.2.html>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-recv>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-recvfrom>
+        /// - <https://learn.microsoft.com/en-us/previous-versions/windows/desktop/legacy/ms741687(v=vs.85)>
+        /// - <https://man.freebsd.org/cgi/man.cgi?query=recv&sektion=2>
+        @since(version = 0.2.0)
+        receive: func(max-results: u64) -> result<list<incoming-datagram>, error-code>;
+
+        /// Create a `pollable` which will resolve once the stream is ready to receive again.
+        ///
+        /// Note: this function is here for WASI Preview2 only.
+        /// It's planned to be removed when `future` is natively supported in Preview3.
+        @since(version = 0.2.0)
+        subscribe: func() -> pollable;
+    }
+
+    @since(version = 0.2.0)
+    resource outgoing-datagram-stream {
+        /// Check readiness for sending. This function never blocks.
+        ///
+        /// Returns the number of datagrams permitted for the next call to `send`,
+        /// or an error. Calling `send` with more datagrams than this function has
+        /// permitted will trap.
+        ///
+        /// When this function returns ok(0), the `subscribe` pollable will
+        /// become ready when this function will report at least ok(1), or an
+        /// error.
+        /// 
+        /// Never returns `would-block`.
+        check-send: func() -> result<u64, error-code>;
+
+        /// Send messages on the socket.
+        ///
+        /// This function attempts to send all provided `datagrams` on the socket without blocking and
+        /// returns how many messages were actually sent (or queued for sending). This function never
+        /// returns `error(would-block)`. If none of the datagrams were able to be sent, `ok(0)` is returned.
+        ///
+        /// This function semantically behaves the same as iterating the `datagrams` list and sequentially
+        /// sending each individual datagram until either the end of the list has been reached or the first error occurred.
+        /// If at least one datagram has been sent successfully, this function never returns an error.
+        ///
+        /// If the input list is empty, the function returns `ok(0)`.
+        ///
+        /// Each call to `send` must be permitted by a preceding `check-send`. Implementations must trap if
+        /// either `check-send` was not called or `datagrams` contains more items than `check-send` permitted.
+        ///
+        /// # Typical errors
+        /// - `invalid-argument`:        The `remote-address` has the wrong address family. (EAFNOSUPPORT)
+        /// - `invalid-argument`:        The IP address in `remote-address` is set to INADDR_ANY (`0.0.0.0` / `::`). (EDESTADDRREQ, EADDRNOTAVAIL)
+        /// - `invalid-argument`:        The port in `remote-address` is set to 0. (EDESTADDRREQ, EADDRNOTAVAIL)
+        /// - `invalid-argument`:        The socket is in "connected" mode and `remote-address` is `some` value that does not match the address passed to `stream`. (EISCONN)
+        /// - `invalid-argument`:        The socket is not "connected" and no value for `remote-address` was provided. (EDESTADDRREQ)
+        /// - `remote-unreachable`:      The remote address is not reachable. (ECONNRESET, ENETRESET on Windows, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
+        /// - `connection-refused`:      The connection was refused. (ECONNREFUSED)
+        /// - `datagram-too-large`:      The datagram is too large. (EMSGSIZE)
+        ///
+        /// # References
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/sendto.html>
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/sendmsg.html>
+        /// - <https://man7.org/linux/man-pages/man2/send.2.html>
+        /// - <https://man7.org/linux/man-pages/man2/sendmmsg.2.html>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-send>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-sendto>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasendmsg>
+        /// - <https://man.freebsd.org/cgi/man.cgi?query=send&sektion=2>
+        @since(version = 0.2.0)
+        send: func(datagrams: list<outgoing-datagram>) -> result<u64, error-code>;
+        
+        /// Create a `pollable` which will resolve once the stream is ready to send again.
+        ///
+        /// Note: this function is here for WASI Preview2 only.
+        /// It's planned to be removed when `future` is natively supported in Preview3.
+        @since(version = 0.2.0)
+        subscribe: func() -> pollable;
+    }
 }
diff --git a/crates/wasi-http/wit/deps/sockets/world.wit b/crates/wasi-http/wit/deps/sockets/world.wit
index 12f3c2868177..a1d42670e64f 100644
--- a/crates/wasi-http/wit/deps/sockets/world.wit
+++ b/crates/wasi-http/wit/deps/sockets/world.wit
@@ -1,11 +1,19 @@
-package wasi:sockets
+package wasi:sockets@0.2.1;
 
+@since(version = 0.2.0)
 world imports {
-    import instance-network
-    import network
-    import udp
-    import udp-create-socket
-    import tcp
-    import tcp-create-socket
-    import ip-name-lookup
+    @since(version = 0.2.0)
+    import instance-network;
+    @since(version = 0.2.0)
+    import network;
+    @since(version = 0.2.0)
+    import udp;
+    @since(version = 0.2.0)
+    import udp-create-socket;
+    @since(version = 0.2.0)
+    import tcp;
+    @since(version = 0.2.0)
+    import tcp-create-socket;
+    @since(version = 0.2.0)
+    import ip-name-lookup;
 }
diff --git a/crates/wasi-http/wit/main.wit b/crates/wasi-http/wit/main.wit
deleted file mode 100644
index 739e1bd4ac48..000000000000
--- a/crates/wasi-http/wit/main.wit
+++ /dev/null
@@ -1,33 +0,0 @@
-package wasmtime:wasi
-
-// All of the same imports available in the wasi:cli/command world, but no
-// export required:
-world preview1-adapter-reactor {
-  import wasi:clocks/wall-clock
-  import wasi:clocks/monotonic-clock
-  import wasi:clocks/timezone
-  import wasi:filesystem/types
-  import wasi:filesystem/preopens
-  import wasi:sockets/instance-network
-  import wasi:sockets/ip-name-lookup
-  import wasi:sockets/network
-  import wasi:sockets/tcp-create-socket
-  import wasi:sockets/tcp
-  import wasi:sockets/udp-create-socket
-  import wasi:sockets/udp
-  import wasi:random/random
-  import wasi:random/insecure
-  import wasi:random/insecure-seed
-  import wasi:io/poll
-  import wasi:io/streams
-  import wasi:cli/environment
-  import wasi:cli/exit
-  import wasi:cli/stdin
-  import wasi:cli/stdout
-  import wasi:cli/stderr
-  import wasi:cli/terminal-input
-  import wasi:cli/terminal-output
-  import wasi:cli/terminal-stdin
-  import wasi:cli/terminal-stdout
-  import wasi:cli/terminal-stderr
-}
diff --git a/crates/wasi-http/wit/test.wit b/crates/wasi-http/wit/test.wit
deleted file mode 100644
index 03073513f8e6..000000000000
--- a/crates/wasi-http/wit/test.wit
+++ /dev/null
@@ -1,44 +0,0 @@
-// only used as part of `test-programs`
-world test-reactor {
-
-  import wasi:cli/environment
-  import wasi:io/poll
-  import wasi:io/streams
-  import wasi:filesystem/types
-  import wasi:filesystem/preopens
-  import wasi:cli/exit
-
-  export add-strings: func(s: list<string>) -> u32
-  export get-strings: func() -> list<string>
-
-  use wasi:io/streams.{output-stream}
-
-  export write-strings-to: func(o: output-stream) -> result
-
-  use wasi:filesystem/types.{descriptor-stat}
-  export pass-an-imported-record: func(d: descriptor-stat) -> string
-}
-
-world test-command {
-  import wasi:io/poll
-  import wasi:io/streams
-  import wasi:cli/environment
-  import wasi:cli/stdin
-  import wasi:cli/stdout
-  import wasi:cli/stderr
-}
-
-world test-command-with-sockets {
-  import wasi:io/poll
-  import wasi:io/streams
-  import wasi:cli/environment
-  import wasi:cli/stdin
-  import wasi:cli/stdout
-  import wasi:cli/stderr
-  import wasi:sockets/tcp
-  import wasi:sockets/tcp-create-socket
-  import wasi:sockets/network
-  import wasi:sockets/instance-network
-  import wasi:sockets/ip-name-lookup
-  import wasi:clocks/monotonic-clock
-}
diff --git a/crates/wasi-http/wit/world.wit b/crates/wasi-http/wit/world.wit
new file mode 100644
index 000000000000..0875bb30612f
--- /dev/null
+++ b/crates/wasi-http/wit/world.wit
@@ -0,0 +1,6 @@
+// We actually don't use this; it's just to let bindgen! find the corresponding world in wit/deps.
+package wasmtime:wasi-http;
+
+world bindings {
+  include wasi:http/proxy@0.2.1;
+}
diff --git a/crates/wasi-keyvalue/Cargo.toml b/crates/wasi-keyvalue/Cargo.toml
new file mode 100644
index 000000000000..860e37a79d41
--- /dev/null
+++ b/crates/wasi-keyvalue/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+name = "wasmtime-wasi-keyvalue"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+repository = "https://github.com/bytecodealliance/wasmtime"
+license = "Apache-2.0 WITH LLVM-exception"
+description = "Wasmtime implementation of the wasi-keyvalue API"
+
+[lints]
+workspace = true
+
+[dependencies]
+anyhow = { workspace = true }
+wasmtime = { workspace = true, features = ["runtime", "component-model", "std"] }
+
+[dev-dependencies]
+test-programs-artifacts = { workspace = true }
+wasmtime-wasi = { workspace = true }
+tokio = { workspace = true, features = ["macros"] }
diff --git a/crates/wasi-keyvalue/src/lib.rs b/crates/wasi-keyvalue/src/lib.rs
new file mode 100644
index 000000000000..c45e501f8074
--- /dev/null
+++ b/crates/wasi-keyvalue/src/lib.rs
@@ -0,0 +1,297 @@
+//! # Wasmtime's [wasi-keyvalue] Implementation
+//!
+//! This crate provides a Wasmtime host implementation of the [wasi-keyvalue]
+//! API. With this crate, the runtime can run components that call APIs in
+//! [wasi-keyvalue] and provide components with access to key-value storages.
+//!
+//! Currently supported storage backends:
+//! * In-Memory (empty identifier)
+//!
+//! # Examples
+//!
+//! The usage of this crate is very similar to other WASI API implementations
+//! such as [wasi:cli] and [wasi:http].
+//!
+//! A common scenario is accessing KV store in a [wasi:cli] component.
+//! A standalone example of doing all this looks like:
+//!
+//! ```
+//! use wasmtime::{
+//!     component::{Linker, ResourceTable},
+//!     Config, Engine, Result, Store,
+//! };
+//! use wasmtime_wasi::{WasiCtx, WasiCtxBuilder, WasiView};
+//! use wasmtime_wasi_keyvalue::{WasiKeyValue, WasiKeyValueCtx, WasiKeyValueCtxBuilder};
+//!
+//! #[tokio::main]
+//! async fn main() -> Result<()> {
+//!     let mut config = Config::new();
+//!     config.async_support(true);
+//!     let engine = Engine::new(&config)?;
+//!
+//!     let mut store = Store::new(&engine, Ctx {
+//!         table: ResourceTable::new(),
+//!         wasi_ctx: WasiCtxBuilder::new().build(),
+//!         wasi_keyvalue_ctx: WasiKeyValueCtxBuilder::new().build(),
+//!     });
+//!
+//!     let mut linker = Linker::<Ctx>::new(&engine);
+//!     wasmtime_wasi::add_to_linker_async(&mut linker)?;
+//!     // add `wasi-runtime-config` world's interfaces to the linker
+//!     wasmtime_wasi_keyvalue::add_to_linker(&mut linker, |h: &mut Ctx| {
+//!         WasiKeyValue::new(&h.wasi_keyvalue_ctx, &mut h.table)
+//!     })?;
+//!
+//!     // ... use `linker` to instantiate within `store` ...
+//!
+//!     Ok(())
+//! }
+//!
+//! struct Ctx {
+//!     table: ResourceTable,
+//!     wasi_ctx: WasiCtx,
+//!     wasi_keyvalue_ctx: WasiKeyValueCtx,
+//! }
+//!
+//! impl WasiView for Ctx {
+//!     fn table(&mut self) -> &mut ResourceTable { &mut self.table }
+//!     fn ctx(&mut self) -> &mut WasiCtx { &mut self.wasi_ctx }
+//! }
+//! ```
+//!
+//! [wasi-keyvalue]: https://github.com/WebAssembly/wasi-keyvalue
+//! [wasi:cli]: https://docs.rs/wasmtime-wasi/latest
+//! [wasi:http]: https://docs.rs/wasmtime-wasi-http/latest
+
+#![deny(missing_docs)]
+
+mod generated {
+    wasmtime::component::bindgen!({
+        path: "wit",
+        world: "wasi:keyvalue/imports",
+        trappable_imports: true,
+        with: {
+            "wasi:keyvalue/store/bucket": crate::Bucket,
+        },
+        trappable_error_type: {
+            "wasi:keyvalue/store/error" => crate::Error,
+        },
+    });
+}
+
+use self::generated::wasi::keyvalue;
+use anyhow::Result;
+use std::collections::HashMap;
+use wasmtime::component::{Resource, ResourceTable, ResourceTableError};
+
+#[doc(hidden)]
+pub enum Error {
+    NoSuchStore,
+    AccessDenied,
+    Other(String),
+}
+
+impl From<ResourceTableError> for Error {
+    fn from(err: ResourceTableError) -> Self {
+        Self::Other(err.to_string())
+    }
+}
+
+#[doc(hidden)]
+pub struct Bucket {
+    in_memory_data: HashMap<String, Vec<u8>>,
+}
+
+/// Builder-style structure used to create a [`WasiKeyValueCtx`].
+#[derive(Default)]
+pub struct WasiKeyValueCtxBuilder {
+    in_memory_data: HashMap<String, Vec<u8>>,
+}
+
+impl WasiKeyValueCtxBuilder {
+    /// Creates a builder for a new context with default parameters set.
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Preset data for the In-Memory provider.
+    pub fn in_memory_data<I, K, V>(mut self, data: I) -> Self
+    where
+        I: IntoIterator<Item = (K, V)>,
+        K: Into<String>,
+        V: Into<Vec<u8>>,
+    {
+        self.in_memory_data = data
+            .into_iter()
+            .map(|(k, v)| (k.into(), v.into()))
+            .collect();
+        self
+    }
+
+    /// Uses the configured context so far to construct the final [`WasiKeyValueCtx`].
+    pub fn build(self) -> WasiKeyValueCtx {
+        WasiKeyValueCtx {
+            in_memory_data: self.in_memory_data,
+        }
+    }
+}
+
+/// Capture the state necessary for use in the `wasi-keyvalue` API implementation.
+pub struct WasiKeyValueCtx {
+    in_memory_data: HashMap<String, Vec<u8>>,
+}
+
+impl WasiKeyValueCtx {
+    /// Convenience function for calling [`WasiKeyValueCtxBuilder::new`].
+    pub fn builder() -> WasiKeyValueCtxBuilder {
+        WasiKeyValueCtxBuilder::new()
+    }
+}
+
+/// A wrapper capturing the needed internal `wasi-keyvalue` state.
+pub struct WasiKeyValue<'a> {
+    ctx: &'a WasiKeyValueCtx,
+    table: &'a mut ResourceTable,
+}
+
+impl<'a> WasiKeyValue<'a> {
+    /// Create a new view into the `wasi-keyvalue` state.
+    pub fn new(ctx: &'a WasiKeyValueCtx, table: &'a mut ResourceTable) -> Self {
+        Self { ctx, table }
+    }
+}
+
+impl keyvalue::store::Host for WasiKeyValue<'_> {
+    fn open(&mut self, identifier: String) -> Result<Resource<Bucket>, Error> {
+        match identifier.as_str() {
+            "" => Ok(self.table.push(Bucket {
+                in_memory_data: self.ctx.in_memory_data.clone(),
+            })?),
+            _ => Err(Error::NoSuchStore),
+        }
+    }
+
+    fn convert_error(&mut self, err: Error) -> Result<keyvalue::store::Error> {
+        match err {
+            Error::NoSuchStore => Ok(keyvalue::store::Error::NoSuchStore),
+            Error::AccessDenied => Ok(keyvalue::store::Error::AccessDenied),
+            Error::Other(e) => Ok(keyvalue::store::Error::Other(e)),
+        }
+    }
+}
+
+impl keyvalue::store::HostBucket for WasiKeyValue<'_> {
+    fn get(&mut self, bucket: Resource<Bucket>, key: String) -> Result<Option<Vec<u8>>, Error> {
+        let bucket = self.table.get_mut(&bucket)?;
+        Ok(bucket.in_memory_data.get(&key).cloned())
+    }
+
+    fn set(&mut self, bucket: Resource<Bucket>, key: String, value: Vec<u8>) -> Result<(), Error> {
+        let bucket = self.table.get_mut(&bucket)?;
+        bucket.in_memory_data.insert(key, value);
+        Ok(())
+    }
+
+    fn delete(&mut self, bucket: Resource<Bucket>, key: String) -> Result<(), Error> {
+        let bucket = self.table.get_mut(&bucket)?;
+        bucket.in_memory_data.remove(&key);
+        Ok(())
+    }
+
+    fn exists(&mut self, bucket: Resource<Bucket>, key: String) -> Result<bool, Error> {
+        let bucket = self.table.get_mut(&bucket)?;
+        Ok(bucket.in_memory_data.contains_key(&key))
+    }
+
+    fn list_keys(
+        &mut self,
+        bucket: Resource<Bucket>,
+        cursor: Option<u64>,
+    ) -> Result<keyvalue::store::KeyResponse, Error> {
+        let bucket = self.table.get_mut(&bucket)?;
+        let keys: Vec<String> = bucket.in_memory_data.keys().cloned().collect();
+        let cursor = cursor.unwrap_or(0) as usize;
+        let keys_slice = &keys[cursor..];
+        Ok(keyvalue::store::KeyResponse {
+            keys: keys_slice.to_vec(),
+            cursor: None,
+        })
+    }
+
+    fn drop(&mut self, bucket: Resource<Bucket>) -> Result<()> {
+        self.table.delete(bucket)?;
+        Ok(())
+    }
+}
+
+impl keyvalue::atomics::Host for WasiKeyValue<'_> {
+    fn increment(
+        &mut self,
+        bucket: Resource<Bucket>,
+        key: String,
+        delta: u64,
+    ) -> Result<u64, Error> {
+        let bucket = self.table.get_mut(&bucket)?;
+        let value = bucket
+            .in_memory_data
+            .entry(key.clone())
+            .or_insert("0".to_string().into_bytes());
+        let current_value = String::from_utf8(value.clone())
+            .map_err(|e| Error::Other(e.to_string()))?
+            .parse::<u64>()
+            .map_err(|e| Error::Other(e.to_string()))?;
+        let new_value = current_value + delta;
+        *value = new_value.to_string().into_bytes();
+        Ok(new_value)
+    }
+}
+
+impl keyvalue::batch::Host for WasiKeyValue<'_> {
+    fn get_many(
+        &mut self,
+        bucket: Resource<Bucket>,
+        keys: Vec<String>,
+    ) -> Result<Vec<Option<(String, Vec<u8>)>>, Error> {
+        let bucket = self.table.get_mut(&bucket)?;
+        Ok(keys
+            .into_iter()
+            .map(|key| {
+                bucket
+                    .in_memory_data
+                    .get(&key)
+                    .map(|value| (key.clone(), value.clone()))
+            })
+            .collect())
+    }
+
+    fn set_many(
+        &mut self,
+        bucket: Resource<Bucket>,
+        key_values: Vec<(String, Vec<u8>)>,
+    ) -> Result<(), Error> {
+        let bucket = self.table.get_mut(&bucket)?;
+        for (key, value) in key_values {
+            bucket.in_memory_data.insert(key, value);
+        }
+        Ok(())
+    }
+
+    fn delete_many(&mut self, bucket: Resource<Bucket>, keys: Vec<String>) -> Result<(), Error> {
+        let bucket = self.table.get_mut(&bucket)?;
+        for key in keys {
+            bucket.in_memory_data.remove(&key);
+        }
+        Ok(())
+    }
+}
+
+/// Add all the `wasi-keyvalue` world's interfaces to a [`wasmtime::component::Linker`].
+pub fn add_to_linker<T: Send>(
+    l: &mut wasmtime::component::Linker<T>,
+    f: impl Fn(&mut T) -> WasiKeyValue<'_> + Send + Sync + Copy + 'static,
+) -> Result<()> {
+    keyvalue::store::add_to_linker_get_host(l, f)?;
+    keyvalue::atomics::add_to_linker_get_host(l, f)?;
+    keyvalue::batch::add_to_linker_get_host(l, f)?;
+    Ok(())
+}
diff --git a/crates/wasi-keyvalue/tests/main.rs b/crates/wasi-keyvalue/tests/main.rs
new file mode 100644
index 000000000000..f4cb5580bed1
--- /dev/null
+++ b/crates/wasi-keyvalue/tests/main.rs
@@ -0,0 +1,69 @@
+use anyhow::{anyhow, Result};
+use test_programs_artifacts::{foreach_keyvalue, KEYVALUE_MAIN_COMPONENT};
+use wasmtime::{
+    component::{Component, Linker, ResourceTable},
+    Store,
+};
+use wasmtime_wasi::{bindings::Command, WasiCtx, WasiCtxBuilder, WasiView};
+use wasmtime_wasi_keyvalue::{WasiKeyValue, WasiKeyValueCtx, WasiKeyValueCtxBuilder};
+
+struct Ctx {
+    table: ResourceTable,
+    wasi_ctx: WasiCtx,
+    wasi_keyvalue_ctx: WasiKeyValueCtx,
+}
+
+impl WasiView for Ctx {
+    fn table(&mut self) -> &mut ResourceTable {
+        &mut self.table
+    }
+
+    fn ctx(&mut self) -> &mut WasiCtx {
+        &mut self.wasi_ctx
+    }
+}
+
+async fn run_wasi(path: &str, ctx: Ctx) -> Result<()> {
+    let engine = test_programs_artifacts::engine(|config| {
+        config.async_support(true);
+    });
+    let mut store = Store::new(&engine, ctx);
+    let component = Component::from_file(&engine, path)?;
+
+    let mut linker = Linker::new(&engine);
+    wasmtime_wasi::add_to_linker_async(&mut linker)?;
+    wasmtime_wasi_keyvalue::add_to_linker(&mut linker, |h: &mut Ctx| {
+        WasiKeyValue::new(&h.wasi_keyvalue_ctx, &mut h.table)
+    })?;
+
+    let command = Command::instantiate_async(&mut store, &component, &linker).await?;
+    command
+        .wasi_cli_run()
+        .call_run(&mut store)
+        .await?
+        .map_err(|()| anyhow!("command returned with failing exit status"))
+}
+
+macro_rules! assert_test_exists {
+    ($name:ident) => {
+        #[allow(unused_imports)]
+        use self::$name as _;
+    };
+}
+
+foreach_keyvalue!(assert_test_exists);
+
+#[tokio::test(flavor = "multi_thread")]
+async fn keyvalue_main() -> Result<()> {
+    run_wasi(
+        KEYVALUE_MAIN_COMPONENT,
+        Ctx {
+            table: ResourceTable::new(),
+            wasi_ctx: WasiCtxBuilder::new().inherit_stderr().build(),
+            wasi_keyvalue_ctx: WasiKeyValueCtxBuilder::new()
+                .in_memory_data([("atomics_key", "5")])
+                .build(),
+        },
+    )
+    .await
+}
diff --git a/crates/wasi-keyvalue/wit/deps/keyvalue/atomic.wit b/crates/wasi-keyvalue/wit/deps/keyvalue/atomic.wit
new file mode 100644
index 000000000000..059efc48896b
--- /dev/null
+++ b/crates/wasi-keyvalue/wit/deps/keyvalue/atomic.wit
@@ -0,0 +1,22 @@
+/// A keyvalue interface that provides atomic operations.
+/// 
+/// Atomic operations are single, indivisible operations. When a fault causes an atomic operation to
+/// fail, it will appear to the invoker of the atomic operation that the action either completed
+/// successfully or did nothing at all.
+/// 
+/// Please note that this interface is bare functions that take a reference to a bucket. This is to
+/// get around the current lack of a way to "extend" a resource with additional methods inside of
+/// wit. Future version of the interface will instead extend these methods on the base `bucket`
+/// resource.
+interface atomics {
+  	use store.{bucket, error};
+
+  	/// Atomically increment the value associated with the key in the store by the given delta. It
+	/// returns the new value.
+	///
+	/// If the key does not exist in the store, it creates a new key-value pair with the value set
+	/// to the given delta. 
+	///
+	/// If any other error occurs, it returns an `Err(error)`.
+	increment: func(bucket: borrow<bucket>, key: string, delta: u64) -> result<u64, error>;
+}
\ No newline at end of file
diff --git a/crates/wasi-keyvalue/wit/deps/keyvalue/batch.wit b/crates/wasi-keyvalue/wit/deps/keyvalue/batch.wit
new file mode 100644
index 000000000000..70c05feb9170
--- /dev/null
+++ b/crates/wasi-keyvalue/wit/deps/keyvalue/batch.wit
@@ -0,0 +1,63 @@
+/// A keyvalue interface that provides batch operations.
+/// 
+/// A batch operation is an operation that operates on multiple keys at once.
+/// 
+/// Batch operations are useful for reducing network round-trip time. For example, if you want to
+/// get the values associated with 100 keys, you can either do 100 get operations or you can do 1
+/// batch get operation. The batch operation is faster because it only needs to make 1 network call
+/// instead of 100.
+/// 
+/// A batch operation does not guarantee atomicity, meaning that if the batch operation fails, some
+/// of the keys may have been modified and some may not. 
+/// 
+/// This interface does has the same consistency guarantees as the `store` interface, meaning that
+/// you should be able to "read your writes."
+/// 
+/// Please note that this interface is bare functions that take a reference to a bucket. This is to
+/// get around the current lack of a way to "extend" a resource with additional methods inside of
+/// wit. Future version of the interface will instead extend these methods on the base `bucket`
+/// resource.
+interface batch {
+    use store.{bucket, error};
+
+    /// Get the key-value pairs associated with the keys in the store. It returns a list of
+    /// key-value pairs.
+    ///
+    /// If any of the keys do not exist in the store, it returns a `none` value for that pair in the
+    /// list.
+    /// 
+    /// MAY show an out-of-date value if there are concurrent writes to the store.
+    /// 
+    /// If any other error occurs, it returns an `Err(error)`.
+    get-many: func(bucket: borrow<bucket>, keys: list<string>) -> result<list<option<tuple<string, list<u8>>>>, error>;
+
+    /// Set the values associated with the keys in the store. If the key already exists in the
+    /// store, it overwrites the value. 
+    /// 
+    /// Note that the key-value pairs are not guaranteed to be set in the order they are provided. 
+    ///
+    /// If any of the keys do not exist in the store, it creates a new key-value pair.
+    /// 
+    /// If any other error occurs, it returns an `Err(error)`. When an error occurs, it does not
+    /// rollback the key-value pairs that were already set. Thus, this batch operation does not
+    /// guarantee atomicity, implying that some key-value pairs could be set while others might
+    /// fail. 
+    /// 
+    /// Other concurrent operations may also be able to see the partial results.
+    set-many: func(bucket: borrow<bucket>, key-values: list<tuple<string, list<u8>>>) -> result<_, error>;
+
+    /// Delete the key-value pairs associated with the keys in the store.
+    /// 
+    /// Note that the key-value pairs are not guaranteed to be deleted in the order they are
+    /// provided.
+    /// 
+    /// If any of the keys do not exist in the store, it skips the key.
+    /// 
+    /// If any other error occurs, it returns an `Err(error)`. When an error occurs, it does not
+    /// rollback the key-value pairs that were already deleted. Thus, this batch operation does not
+    /// guarantee atomicity, implying that some key-value pairs could be deleted while others might
+    /// fail.
+    /// 
+    /// Other concurrent operations may also be able to see the partial results.
+    delete-many: func(bucket: borrow<bucket>, keys: list<string>) -> result<_, error>;
+}
diff --git a/crates/wasi-keyvalue/wit/deps/keyvalue/store.wit b/crates/wasi-keyvalue/wit/deps/keyvalue/store.wit
new file mode 100644
index 000000000000..3354ea2f326a
--- /dev/null
+++ b/crates/wasi-keyvalue/wit/deps/keyvalue/store.wit
@@ -0,0 +1,122 @@
+/// A keyvalue interface that provides eventually consistent key-value operations.
+/// 
+/// Each of these operations acts on a single key-value pair.
+/// 
+/// The value in the key-value pair is defined as a `u8` byte array and the intention is that it is
+/// the common denominator for all data types defined by different key-value stores to handle data,
+/// ensuring compatibility between different key-value stores. Note: the clients will be expecting
+/// serialization/deserialization overhead to be handled by the key-value store. The value could be
+/// a serialized object from JSON, HTML or vendor-specific data types like AWS S3 objects.
+/// 
+/// Data consistency in a key value store refers to the guarantee that once a write operation
+/// completes, all subsequent read operations will return the value that was written.
+/// 
+/// Any implementation of this interface must have enough consistency to guarantee "reading your
+/// writes." In particular, this means that the client should never get a value that is older than
+/// the one it wrote, but it MAY get a newer value if one was written around the same time. These
+/// guarantees only apply to the same client (which will likely be provided by the host or an
+/// external capability of some kind). In this context a "client" is referring to the caller or
+/// guest that is consuming this interface. Once a write request is committed by a specific client,
+/// all subsequent read requests by the same client will reflect that write or any subsequent
+/// writes. Another client running in a different context may or may not immediately see the result
+/// due to the replication lag. As an example of all of this, if a value at a given key is A, and
+/// the client writes B, then immediately reads, it should get B. If something else writes C in
+/// quick succession, then the client may get C. However, a client running in a separate context may
+/// still see A or B
+interface store {
+    /// The set of errors which may be raised by functions in this package
+    variant error {
+        /// The host does not recognize the store identifier requested.
+        no-such-store,
+
+        /// The requesting component does not have access to the specified store
+        /// (which may or may not exist).
+        access-denied,
+
+        /// Some implementation-specific error has occurred (e.g. I/O)
+        other(string)
+    }
+
+    /// A response to a `list-keys` operation.
+    record key-response {
+        /// The list of keys returned by the query.
+        keys: list<string>,
+        /// The continuation token to use to fetch the next page of keys. If this is `null`, then
+        /// there are no more keys to fetch.
+        cursor: option<u64>
+    }
+
+    /// Get the bucket with the specified identifier.
+    ///
+    /// `identifier` must refer to a bucket provided by the host.
+    ///
+    /// `error::no-such-store` will be raised if the `identifier` is not recognized.
+    open: func(identifier: string) -> result<bucket, error>;
+
+    /// A bucket is a collection of key-value pairs. Each key-value pair is stored as a entry in the
+    /// bucket, and the bucket itself acts as a collection of all these entries.
+    ///
+    /// It is worth noting that the exact terminology for bucket in key-value stores can very
+    /// depending on the specific implementation. For example:
+    ///
+    /// 1. Amazon DynamoDB calls a collection of key-value pairs a table
+    /// 2. Redis has hashes, sets, and sorted sets as different types of collections
+    /// 3. Cassandra calls a collection of key-value pairs a column family
+    /// 4. MongoDB calls a collection of key-value pairs a collection
+    /// 5. Riak calls a collection of key-value pairs a bucket
+    /// 6. Memcached calls a collection of key-value pairs a slab
+    /// 7. Azure Cosmos DB calls a collection of key-value pairs a container
+    ///
+    /// In this interface, we use the term `bucket` to refer to a collection of key-value pairs
+    resource bucket {
+        /// Get the value associated with the specified `key`
+        ///
+        /// The value is returned as an option. If the key-value pair exists in the
+        /// store, it returns `Ok(value)`. If the key does not exist in the
+        /// store, it returns `Ok(none)`. 
+        ///
+        /// If any other error occurs, it returns an `Err(error)`.
+        get: func(key: string) -> result<option<list<u8>>, error>;
+
+        /// Set the value associated with the key in the store. If the key already
+        /// exists in the store, it overwrites the value.
+        ///
+        /// If the key does not exist in the store, it creates a new key-value pair.
+        /// 
+        /// If any other error occurs, it returns an `Err(error)`.
+        set: func(key: string, value: list<u8>) -> result<_, error>;
+
+        /// Delete the key-value pair associated with the key in the store.
+        /// 
+        /// If the key does not exist in the store, it does nothing.
+        ///
+        /// If any other error occurs, it returns an `Err(error)`.
+        delete: func(key: string) -> result<_, error>;
+
+        /// Check if the key exists in the store.
+        /// 
+        /// If the key exists in the store, it returns `Ok(true)`. If the key does
+        /// not exist in the store, it returns `Ok(false)`.
+        /// 
+        /// If any other error occurs, it returns an `Err(error)`.
+        exists: func(key: string) -> result<bool, error>;
+
+        /// Get all the keys in the store with an optional cursor (for use in pagination). It
+        /// returns a list of keys. Please note that for most KeyValue implementations, this is a
+        /// can be a very expensive operation and so it should be used judiciously. Implementations
+        /// can return any number of keys in a single response, but they should never attempt to
+        /// send more data than is reasonable (i.e. on a small edge device, this may only be a few
+        /// KB, while on a large machine this could be several MB). Any response should also return
+        /// a cursor that can be used to fetch the next page of keys. See the `key-response` record
+        /// for more information.
+        /// 
+        /// Note that the keys are not guaranteed to be returned in any particular order.
+        /// 
+        /// If the store is empty, it returns an empty list.
+        /// 
+        /// MAY show an out-of-date list of keys if there are concurrent writes to the store.
+        /// 
+        /// If any error occurs, it returns an `Err(error)`.
+        list-keys: func(cursor: option<u64>) -> result<key-response, error>;
+    }
+}
diff --git a/crates/wasi-keyvalue/wit/deps/keyvalue/watch.wit b/crates/wasi-keyvalue/wit/deps/keyvalue/watch.wit
new file mode 100644
index 000000000000..ff13f7523ede
--- /dev/null
+++ b/crates/wasi-keyvalue/wit/deps/keyvalue/watch.wit
@@ -0,0 +1,16 @@
+/// A keyvalue interface that provides watch operations.
+/// 
+/// This interface is used to provide event-driven mechanisms to handle
+/// keyvalue changes.
+interface watcher {
+	/// A keyvalue interface that provides handle-watch operations.
+	use store.{bucket};
+
+	/// Handle the `set` event for the given bucket and key. It includes a reference to the `bucket`
+	/// that can be used to interact with the store.
+	on-set: func(bucket: bucket, key: string, value: list<u8>);
+
+	/// Handle the `delete` event for the given bucket and key. It includes a reference to the
+	/// `bucket` that can be used to interact with the store.
+	on-delete: func(bucket: bucket, key: string);
+}
\ No newline at end of file
diff --git a/crates/wasi-keyvalue/wit/deps/keyvalue/world.wit b/crates/wasi-keyvalue/wit/deps/keyvalue/world.wit
new file mode 100644
index 000000000000..066148c1fa82
--- /dev/null
+++ b/crates/wasi-keyvalue/wit/deps/keyvalue/world.wit
@@ -0,0 +1,26 @@
+package wasi:keyvalue@0.2.0-draft;
+
+/// The `wasi:keyvalue/imports` world provides common APIs for interacting with key-value stores.
+/// Components targeting this world will be able to do:
+/// 
+/// 1. CRUD (create, read, update, delete) operations on key-value stores.
+/// 2. Atomic `increment` and CAS (compare-and-swap) operations.
+/// 3. Batch operations that can reduce the number of round trips to the network.
+world imports {
+	/// The `store` capability allows the component to perform eventually consistent operations on
+	/// the key-value store.
+	import store;
+
+	/// The `atomic` capability allows the component to perform atomic / `increment` and CAS
+	/// (compare-and-swap) operations.
+	import atomics;
+
+	/// The `batch` capability allows the component to perform eventually consistent batch
+	/// operations that can reduce the number of round trips to the network.
+	import batch;
+}
+
+world watch-service {
+	include imports;
+	export watcher;
+}
\ No newline at end of file
diff --git a/crates/wasi-keyvalue/wit/world.wit b/crates/wasi-keyvalue/wit/world.wit
new file mode 100644
index 000000000000..af5b0bd5524b
--- /dev/null
+++ b/crates/wasi-keyvalue/wit/world.wit
@@ -0,0 +1,6 @@
+// We actually don't use this; it's just to let bindgen! find the corresponding world in wit/deps.
+package wasmtime:wasi-keyvalue;
+
+world bindings {
+  include wasi:keyvalue/imports@0.2.0-draft;
+}
diff --git a/crates/wasi-nn/Cargo.toml b/crates/wasi-nn/Cargo.toml
index 13f1501583e4..48ac66e44167 100644
--- a/crates/wasi-nn/Cargo.toml
+++ b/crates/wasi-nn/Cargo.toml
@@ -10,19 +10,66 @@ keywords = ["webassembly", "wasm", "neural-network"]
 repository = "https://github.com/bytecodealliance/wasmtime"
 readme = "README.md"
 edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
 
 [dependencies]
 # These dependencies are necessary for the WITX-generation macros to work:
-anyhow = { workspace = true }
-wiggle = { workspace = true }
+anyhow = { workspace = true, features = ['std'] }
+wiggle = { workspace = true, features = ["wasmtime"] }
 
 # This dependency is necessary for the WIT-generation macros to work:
-wasmtime = { workspace = true, features = ["component-model"] }
+wasmtime = { workspace = true, features = [
+    "component-model",
+    "runtime",
+    "std",
+] }
 
 # These dependencies are necessary for the wasi-nn implementation:
 tracing = { workspace = true }
-openvino = { version = "0.5.0", features = ["runtime-linking"] }
 thiserror = { workspace = true }
+openvino = { version = "0.7.2", features = [
+    "runtime-linking",
+], optional = true }
+
+ort = { version = "2.0.0-rc.2", default-features = false, features = [
+    "copy-dylibs",
+    "download-binaries",
+], optional = true }
+
+[target.'cfg(windows)'.dependencies.windows]
+version = "0.52"
+features = [
+    "AI_MachineLearning",
+    "Storage_Streams",
+    "Foundation_Collections",
+    # For getting IVectorView<i64> from tensor.dimensions.
+    "implement",
+]
+optional = true
 
 [build-dependencies]
 walkdir = { workspace = true }
+
+[dev-dependencies]
+cap-std = { workspace = true }
+libtest-mimic = { workspace = true }
+test-programs-artifacts = { workspace = true }
+wasmtime-wasi = { workspace = true, features = ["preview1"] }
+wasmtime = { workspace = true, features = ["cranelift"] }
+tracing-subscriber = { workspace = true }
+
+[features]
+default = ["openvino", "winml"]
+# OpenVINO is available on all platforms; it requires OpenVINO to be installed.
+openvino = ["dep:openvino"]
+# ONNX is available on all platforms.
+onnx = ["dep:ort"]
+# WinML is only available on Windows 10 1809 and later.
+winml = ["dep:windows"]
+
+[[test]]
+name = "test-programs"
+harness = false
diff --git a/crates/wasi-nn/README.md b/crates/wasi-nn/README.md
index 4933fcba339c..2f080f34fd94 100644
--- a/crates/wasi-nn/README.md
+++ b/crates/wasi-nn/README.md
@@ -35,11 +35,5 @@ To use the WIT-based ABI, compile with `--features component-model` and use `was
 
 An end-to-end example demonstrating ML classification is included in [examples]:
 `examples/classification-example` contains a standalone Rust project that uses
-the [wasi-nn] APIs and is compiled to the `wasm32-wasi` target using the
+the [wasi-nn] APIs and is compiled to the `wasm32-wasip1` target using the
 high-level `wasi-nn` [bindings].
-
-Run the example from the Wasmtime project directory:
-
-```sh
-$ ci/run-wasi-nn-example.sh
-```
diff --git a/crates/wasi-nn/build.rs b/crates/wasi-nn/build.rs
index 535d0e0f80a9..f3c018366c8b 100644
--- a/crates/wasi-nn/build.rs
+++ b/crates/wasi-nn/build.rs
@@ -1,12 +1,12 @@
 //! This build script:
-//!  - has the configuration necessary for the wiggle and witx macros.
+//!  - has the configuration necessary for the Wiggle and WITX macros.
 fn main() {
-    // This is necessary for Wiggle/Witx macros.
+    // This is necessary for Wiggle/WITX macros.
     let cwd = std::env::current_dir().unwrap();
-    let wasi_root = cwd.join("spec");
+    let wasi_root = cwd.join("witx");
     println!("cargo:rustc-env=WASI_ROOT={}", wasi_root.display());
 
-    // Also automatically rebuild if the Witx files change
+    // Also automatically rebuild if the WITX files change
     for entry in walkdir::WalkDir::new(wasi_root) {
         println!("cargo:rerun-if-changed={}", entry.unwrap().path().display());
     }
diff --git a/crates/wasi-nn/examples/classification-component-onnx/Cargo.lock b/crates/wasi-nn/examples/classification-component-onnx/Cargo.lock
new file mode 100644
index 000000000000..71d1e637a846
--- /dev/null
+++ b/crates/wasi-nn/examples/classification-component-onnx/Cargo.lock
@@ -0,0 +1,139 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
+[[package]]
+name = "bitflags"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "327762f6e5a765692301e5bb513e0d9fef63be86bbc14528052b1cd3e6f03e07"
+
+[[package]]
+name = "bytemuck"
+version = "1.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "374d28ec25809ee0e23827c2ab573d729e293f281dfe393500e7ad618baa61c6"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "classification-component-onnx"
+version = "0.1.0"
+dependencies = [
+ "image",
+ "ndarray",
+ "wit-bindgen",
+]
+
+[[package]]
+name = "color_quant"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
+
+[[package]]
+name = "image"
+version = "0.24.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f3dfdbdd72063086ff443e297b61695500514b1e41095b6fb9a5ab48a70a711"
+dependencies = [
+ "bytemuck",
+ "byteorder",
+ "color_quant",
+ "jpeg-decoder",
+ "num-rational",
+ "num-traits",
+]
+
+[[package]]
+name = "jpeg-decoder"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc0000e42512c92e31c2252315bda326620a4e034105e900c98ec492fa077b3e"
+
+[[package]]
+name = "matrixmultiply"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7574c1cf36da4798ab73da5b215bbf444f50718207754cb522201d78d1cd0ff2"
+dependencies = [
+ "autocfg",
+ "rawpointer",
+]
+
+[[package]]
+name = "ndarray"
+version = "0.15.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb12d4e967ec485a5f71c6311fe28158e9d6f4bc4a447b474184d0f91a8fa32"
+dependencies = [
+ "matrixmultiply",
+ "num-complex",
+ "num-integer",
+ "num-traits",
+ "rawpointer",
+]
+
+[[package]]
+name = "num-complex"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ba157ca0885411de85d6ca030ba7e2a83a28636056c7c699b07c8b6f7383214"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
+dependencies = [
+ "autocfg",
+ "num-traits",
+]
+
+[[package]]
+name = "num-rational"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0638a1c9d0a3c0914158145bc76cff373a75a627e6ecbfb71cbe6f453a5a19b0"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39e3200413f237f41ab11ad6d161bc7239c84dcb631773ccd7de3dfe4b5c267c"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "rawpointer"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3"
+
+[[package]]
+name = "wit-bindgen"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b76f1d099678b4f69402a421e888bbe71bf20320c2f3f3565d0e7484dbe5bc20"
+dependencies = [
+ "bitflags",
+]
diff --git a/crates/wasi-nn/examples/classification-component-onnx/Cargo.toml b/crates/wasi-nn/examples/classification-component-onnx/Cargo.toml
new file mode 100644
index 000000000000..32a34a4eaf0f
--- /dev/null
+++ b/crates/wasi-nn/examples/classification-component-onnx/Cargo.toml
@@ -0,0 +1,35 @@
+[package]
+name = "classification-component-onnx"
+version = "0.1.0"
+edition = "2021"
+authors = ["The Wasmtime Project Developers"]
+readme = "README.md"
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+
+[package.metadata.component]
+package = "component:classification-component-onnx"
+
+[package.metadata.component.target.dependencies]
+"wasi:cli" = { path = "../../../wasi/wit/deps/cli" }
+"wasi:io" = { path = "../../../wasi/wit/deps/io" }
+"wasi:clocks" = { path = "../../../wasi/wit/deps/clocks" }
+"wasi:filesystem" = { path = "../../../wasi/wit/deps/filesystem" }
+"wasi:sockets" = { path = "../../../wasi/wit/deps/sockets" }
+"wasi:random" = { path = "../../../wasi/wit/deps/random" }
+"wasi:nn" = { path = "../../spec/wit/wasi-nn.wit" }
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+wit-bindgen = { version = "0.16.0", default-features = false, features = ["realloc"] }
+image = { version = "0.24.6", default-features = false, features = ["jpeg"] }
+ndarray = "0.15.3"
+
+
+
+# This crate is built with the wasm32-wasip1 target, so it's separate
+# from the main Wasmtime build, so use this directive to exclude it
+# from the parent directory's workspace.
+[workspace]
diff --git a/crates/wasi-nn/examples/classification-component-onnx/README.md b/crates/wasi-nn/examples/classification-component-onnx/README.md
new file mode 100644
index 000000000000..a87b33c8188c
--- /dev/null
+++ b/crates/wasi-nn/examples/classification-component-onnx/README.md
@@ -0,0 +1,23 @@
+# Onnx Backend Classification Component Example
+
+This example demonstrates how to use the `wasi-nn` crate to run a classification using the
+[ONNX Runtime](https://onnxruntime.ai/) backend from a WebAssembly component.
+
+## Build
+In this directory, run the following command to build the WebAssembly component:
+```shell
+cargo component build
+```
+
+In the wasmtime root directory, run the following command to build the wasmtime CLI and run the WebAssembly component:
+```shell
+# build wasmtime with component-model and WASI-NN with ONNX runtime support
+cargo build --features component-model,wasi-nn,wasmtime-wasi-nn/onnx
+
+# run the component with wasmtime
+./target/debug/wasmtime run \
+  --wasm-features component-model \
+  --wasi-modules=experimental-wasi-nn \
+  --mapdir fixture::./crates/wasi-nn/examples/classification-component-onnx/fixture \
+  ./crates/wasi-nn/examples/classification-component-onnx/target/wasm32-wasip1/debug/classification_component_onnx.wasm
+```
diff --git a/crates/wasi-nn/examples/classification-component-onnx/fixture/images/dog.jpg b/crates/wasi-nn/examples/classification-component-onnx/fixture/images/dog.jpg
new file mode 100644
index 000000000000..97dfebe560ee
Binary files /dev/null and b/crates/wasi-nn/examples/classification-component-onnx/fixture/images/dog.jpg differ
diff --git a/crates/wasi-nn/examples/classification-component-onnx/fixture/labels/squeezenet1.1-7.txt b/crates/wasi-nn/examples/classification-component-onnx/fixture/labels/squeezenet1.1-7.txt
new file mode 100644
index 000000000000..9243b0055e63
--- /dev/null
+++ b/crates/wasi-nn/examples/classification-component-onnx/fixture/labels/squeezenet1.1-7.txt
@@ -0,0 +1,1000 @@
+n01440764 tench, Tinca tinca
+n01443537 goldfish, Carassius auratus
+n01484850 great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias
+n01491361 tiger shark, Galeocerdo cuvieri
+n01494475 hammerhead, hammerhead shark
+n01496331 electric ray, crampfish, numbfish, torpedo
+n01498041 stingray
+n01514668 cock
+n01514859 hen
+n01518878 ostrich, Struthio camelus
+n01530575 brambling, Fringilla montifringilla
+n01531178 goldfinch, Carduelis carduelis
+n01532829 house finch, linnet, Carpodacus mexicanus
+n01534433 junco, snowbird
+n01537544 indigo bunting, indigo finch, indigo bird, Passerina cyanea
+n01558993 robin, American robin, Turdus migratorius
+n01560419 bulbul
+n01580077 jay
+n01582220 magpie
+n01592084 chickadee
+n01601694 water ouzel, dipper
+n01608432 kite
+n01614925 bald eagle, American eagle, Haliaeetus leucocephalus
+n01616318 vulture
+n01622779 great grey owl, great gray owl, Strix nebulosa
+n01629819 European fire salamander, Salamandra salamandra
+n01630670 common newt, Triturus vulgaris
+n01631663 eft
+n01632458 spotted salamander, Ambystoma maculatum
+n01632777 axolotl, mud puppy, Ambystoma mexicanum
+n01641577 bullfrog, Rana catesbeiana
+n01644373 tree frog, tree-frog
+n01644900 tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui
+n01664065 loggerhead, loggerhead turtle, Caretta caretta
+n01665541 leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea
+n01667114 mud turtle
+n01667778 terrapin
+n01669191 box turtle, box tortoise
+n01675722 banded gecko
+n01677366 common iguana, iguana, Iguana iguana
+n01682714 American chameleon, anole, Anolis carolinensis
+n01685808 whiptail, whiptail lizard
+n01687978 agama
+n01688243 frilled lizard, Chlamydosaurus kingi
+n01689811 alligator lizard
+n01692333 Gila monster, Heloderma suspectum
+n01693334 green lizard, Lacerta viridis
+n01694178 African chameleon, Chamaeleo chamaeleon
+n01695060 Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis
+n01697457 African crocodile, Nile crocodile, Crocodylus niloticus
+n01698640 American alligator, Alligator mississipiensis
+n01704323 triceratops
+n01728572 thunder snake, worm snake, Carphophis amoenus
+n01728920 ringneck snake, ring-necked snake, ring snake
+n01729322 hognose snake, puff adder, sand viper
+n01729977 green snake, grass snake
+n01734418 king snake, kingsnake
+n01735189 garter snake, grass snake
+n01737021 water snake
+n01739381 vine snake
+n01740131 night snake, Hypsiglena torquata
+n01742172 boa constrictor, Constrictor constrictor
+n01744401 rock python, rock snake, Python sebae
+n01748264 Indian cobra, Naja naja
+n01749939 green mamba
+n01751748 sea snake
+n01753488 horned viper, cerastes, sand viper, horned asp, Cerastes cornutus
+n01755581 diamondback, diamondback rattlesnake, Crotalus adamanteus
+n01756291 sidewinder, horned rattlesnake, Crotalus cerastes
+n01768244 trilobite
+n01770081 harvestman, daddy longlegs, Phalangium opilio
+n01770393 scorpion
+n01773157 black and gold garden spider, Argiope aurantia
+n01773549 barn spider, Araneus cavaticus
+n01773797 garden spider, Aranea diademata
+n01774384 black widow, Latrodectus mactans
+n01774750 tarantula
+n01775062 wolf spider, hunting spider
+n01776313 tick
+n01784675 centipede
+n01795545 black grouse
+n01796340 ptarmigan
+n01797886 ruffed grouse, partridge, Bonasa umbellus
+n01798484 prairie chicken, prairie grouse, prairie fowl
+n01806143 peacock
+n01806567 quail
+n01807496 partridge
+n01817953 African grey, African gray, Psittacus erithacus
+n01818515 macaw
+n01819313 sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita
+n01820546 lorikeet
+n01824575 coucal
+n01828970 bee eater
+n01829413 hornbill
+n01833805 hummingbird
+n01843065 jacamar
+n01843383 toucan
+n01847000 drake
+n01855032 red-breasted merganser, Mergus serrator
+n01855672 goose
+n01860187 black swan, Cygnus atratus
+n01871265 tusker
+n01872401 echidna, spiny anteater, anteater
+n01873310 platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus
+n01877812 wallaby, brush kangaroo
+n01882714 koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus
+n01883070 wombat
+n01910747 jellyfish
+n01914609 sea anemone, anemone
+n01917289 brain coral
+n01924916 flatworm, platyhelminth
+n01930112 nematode, nematode worm, roundworm
+n01943899 conch
+n01944390 snail
+n01945685 slug
+n01950731 sea slug, nudibranch
+n01955084 chiton, coat-of-mail shell, sea cradle, polyplacophore
+n01968897 chambered nautilus, pearly nautilus, nautilus
+n01978287 Dungeness crab, Cancer magister
+n01978455 rock crab, Cancer irroratus
+n01980166 fiddler crab
+n01981276 king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica
+n01983481 American lobster, Northern lobster, Maine lobster, Homarus americanus
+n01984695 spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish
+n01985128 crayfish, crawfish, crawdad, crawdaddy
+n01986214 hermit crab
+n01990800 isopod
+n02002556 white stork, Ciconia ciconia
+n02002724 black stork, Ciconia nigra
+n02006656 spoonbill
+n02007558 flamingo
+n02009229 little blue heron, Egretta caerulea
+n02009912 American egret, great white heron, Egretta albus
+n02011460 bittern
+n02012849 crane
+n02013706 limpkin, Aramus pictus
+n02017213 European gallinule, Porphyrio porphyrio
+n02018207 American coot, marsh hen, mud hen, water hen, Fulica americana
+n02018795 bustard
+n02025239 ruddy turnstone, Arenaria interpres
+n02027492 red-backed sandpiper, dunlin, Erolia alpina
+n02028035 redshank, Tringa totanus
+n02033041 dowitcher
+n02037110 oystercatcher, oyster catcher
+n02051845 pelican
+n02056570 king penguin, Aptenodytes patagonica
+n02058221 albatross, mollymawk
+n02066245 grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus
+n02071294 killer whale, killer, orca, grampus, sea wolf, Orcinus orca
+n02074367 dugong, Dugong dugon
+n02077923 sea lion
+n02085620 Chihuahua
+n02085782 Japanese spaniel
+n02085936 Maltese dog, Maltese terrier, Maltese
+n02086079 Pekinese, Pekingese, Peke
+n02086240 Shih-Tzu
+n02086646 Blenheim spaniel
+n02086910 papillon
+n02087046 toy terrier
+n02087394 Rhodesian ridgeback
+n02088094 Afghan hound, Afghan
+n02088238 basset, basset hound
+n02088364 beagle
+n02088466 bloodhound, sleuthhound
+n02088632 bluetick
+n02089078 black-and-tan coonhound
+n02089867 Walker hound, Walker foxhound
+n02089973 English foxhound
+n02090379 redbone
+n02090622 borzoi, Russian wolfhound
+n02090721 Irish wolfhound
+n02091032 Italian greyhound
+n02091134 whippet
+n02091244 Ibizan hound, Ibizan Podenco
+n02091467 Norwegian elkhound, elkhound
+n02091635 otterhound, otter hound
+n02091831 Saluki, gazelle hound
+n02092002 Scottish deerhound, deerhound
+n02092339 Weimaraner
+n02093256 Staffordshire bullterrier, Staffordshire bull terrier
+n02093428 American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier
+n02093647 Bedlington terrier
+n02093754 Border terrier
+n02093859 Kerry blue terrier
+n02093991 Irish terrier
+n02094114 Norfolk terrier
+n02094258 Norwich terrier
+n02094433 Yorkshire terrier
+n02095314 wire-haired fox terrier
+n02095570 Lakeland terrier
+n02095889 Sealyham terrier, Sealyham
+n02096051 Airedale, Airedale terrier
+n02096177 cairn, cairn terrier
+n02096294 Australian terrier
+n02096437 Dandie Dinmont, Dandie Dinmont terrier
+n02096585 Boston bull, Boston terrier
+n02097047 miniature schnauzer
+n02097130 giant schnauzer
+n02097209 standard schnauzer
+n02097298 Scotch terrier, Scottish terrier, Scottie
+n02097474 Tibetan terrier, chrysanthemum dog
+n02097658 silky terrier, Sydney silky
+n02098105 soft-coated wheaten terrier
+n02098286 West Highland white terrier
+n02098413 Lhasa, Lhasa apso
+n02099267 flat-coated retriever
+n02099429 curly-coated retriever
+n02099601 golden retriever
+n02099712 Labrador retriever
+n02099849 Chesapeake Bay retriever
+n02100236 German short-haired pointer
+n02100583 vizsla, Hungarian pointer
+n02100735 English setter
+n02100877 Irish setter, red setter
+n02101006 Gordon setter
+n02101388 Brittany spaniel
+n02101556 clumber, clumber spaniel
+n02102040 English springer, English springer spaniel
+n02102177 Welsh springer spaniel
+n02102318 cocker spaniel, English cocker spaniel, cocker
+n02102480 Sussex spaniel
+n02102973 Irish water spaniel
+n02104029 kuvasz
+n02104365 schipperke
+n02105056 groenendael
+n02105162 malinois
+n02105251 briard
+n02105412 kelpie
+n02105505 komondor
+n02105641 Old English sheepdog, bobtail
+n02105855 Shetland sheepdog, Shetland sheep dog, Shetland
+n02106030 collie
+n02106166 Border collie
+n02106382 Bouvier des Flandres, Bouviers des Flandres
+n02106550 Rottweiler
+n02106662 German shepherd, German shepherd dog, German police dog, alsatian
+n02107142 Doberman, Doberman pinscher
+n02107312 miniature pinscher
+n02107574 Greater Swiss Mountain dog
+n02107683 Bernese mountain dog
+n02107908 Appenzeller
+n02108000 EntleBucher
+n02108089 boxer
+n02108422 bull mastiff
+n02108551 Tibetan mastiff
+n02108915 French bulldog
+n02109047 Great Dane
+n02109525 Saint Bernard, St Bernard
+n02109961 Eskimo dog, husky
+n02110063 malamute, malemute, Alaskan malamute
+n02110185 Siberian husky
+n02110341 dalmatian, coach dog, carriage dog
+n02110627 affenpinscher, monkey pinscher, monkey dog
+n02110806 basenji
+n02110958 pug, pug-dog
+n02111129 Leonberg
+n02111277 Newfoundland, Newfoundland dog
+n02111500 Great Pyrenees
+n02111889 Samoyed, Samoyede
+n02112018 Pomeranian
+n02112137 chow, chow chow
+n02112350 keeshond
+n02112706 Brabancon griffon
+n02113023 Pembroke, Pembroke Welsh corgi
+n02113186 Cardigan, Cardigan Welsh corgi
+n02113624 toy poodle
+n02113712 miniature poodle
+n02113799 standard poodle
+n02113978 Mexican hairless
+n02114367 timber wolf, grey wolf, gray wolf, Canis lupus
+n02114548 white wolf, Arctic wolf, Canis lupus tundrarum
+n02114712 red wolf, maned wolf, Canis rufus, Canis niger
+n02114855 coyote, prairie wolf, brush wolf, Canis latrans
+n02115641 dingo, warrigal, warragal, Canis dingo
+n02115913 dhole, Cuon alpinus
+n02116738 African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus
+n02117135 hyena, hyaena
+n02119022 red fox, Vulpes vulpes
+n02119789 kit fox, Vulpes macrotis
+n02120079 Arctic fox, white fox, Alopex lagopus
+n02120505 grey fox, gray fox, Urocyon cinereoargenteus
+n02123045 tabby, tabby cat
+n02123159 tiger cat
+n02123394 Persian cat
+n02123597 Siamese cat, Siamese
+n02124075 Egyptian cat
+n02125311 cougar, puma, catamount, mountain lion, painter, panther, Felis concolor
+n02127052 lynx, catamount
+n02128385 leopard, Panthera pardus
+n02128757 snow leopard, ounce, Panthera uncia
+n02128925 jaguar, panther, Panthera onca, Felis onca
+n02129165 lion, king of beasts, Panthera leo
+n02129604 tiger, Panthera tigris
+n02130308 cheetah, chetah, Acinonyx jubatus
+n02132136 brown bear, bruin, Ursus arctos
+n02133161 American black bear, black bear, Ursus americanus, Euarctos americanus
+n02134084 ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus
+n02134418 sloth bear, Melursus ursinus, Ursus ursinus
+n02137549 mongoose
+n02138441 meerkat, mierkat
+n02165105 tiger beetle
+n02165456 ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle
+n02167151 ground beetle, carabid beetle
+n02168699 long-horned beetle, longicorn, longicorn beetle
+n02169497 leaf beetle, chrysomelid
+n02172182 dung beetle
+n02174001 rhinoceros beetle
+n02177972 weevil
+n02190166 fly
+n02206856 bee
+n02219486 ant, emmet, pismire
+n02226429 grasshopper, hopper
+n02229544 cricket
+n02231487 walking stick, walkingstick, stick insect
+n02233338 cockroach, roach
+n02236044 mantis, mantid
+n02256656 cicada, cicala
+n02259212 leafhopper
+n02264363 lacewing, lacewing fly
+n02268443 dragonfly, darning needle, devil's darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk
+n02268853 damselfly
+n02276258 admiral
+n02277742 ringlet, ringlet butterfly
+n02279972 monarch, monarch butterfly, milkweed butterfly, Danaus plexippus
+n02280649 cabbage butterfly
+n02281406 sulphur butterfly, sulfur butterfly
+n02281787 lycaenid, lycaenid butterfly
+n02317335 starfish, sea star
+n02319095 sea urchin
+n02321529 sea cucumber, holothurian
+n02325366 wood rabbit, cottontail, cottontail rabbit
+n02326432 hare
+n02328150 Angora, Angora rabbit
+n02342885 hamster
+n02346627 porcupine, hedgehog
+n02356798 fox squirrel, eastern fox squirrel, Sciurus niger
+n02361337 marmot
+n02363005 beaver
+n02364673 guinea pig, Cavia cobaya
+n02389026 sorrel
+n02391049 zebra
+n02395406 hog, pig, grunter, squealer, Sus scrofa
+n02396427 wild boar, boar, Sus scrofa
+n02397096 warthog
+n02398521 hippopotamus, hippo, river horse, Hippopotamus amphibius
+n02403003 ox
+n02408429 water buffalo, water ox, Asiatic buffalo, Bubalus bubalis
+n02410509 bison
+n02412080 ram, tup
+n02415577 bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis
+n02417914 ibex, Capra ibex
+n02422106 hartebeest
+n02422699 impala, Aepyceros melampus
+n02423022 gazelle
+n02437312 Arabian camel, dromedary, Camelus dromedarius
+n02437616 llama
+n02441942 weasel
+n02442845 mink
+n02443114 polecat, fitch, foulmart, foumart, Mustela putorius
+n02443484 black-footed ferret, ferret, Mustela nigripes
+n02444819 otter
+n02445715 skunk, polecat, wood pussy
+n02447366 badger
+n02454379 armadillo
+n02457408 three-toed sloth, ai, Bradypus tridactylus
+n02480495 orangutan, orang, orangutang, Pongo pygmaeus
+n02480855 gorilla, Gorilla gorilla
+n02481823 chimpanzee, chimp, Pan troglodytes
+n02483362 gibbon, Hylobates lar
+n02483708 siamang, Hylobates syndactylus, Symphalangus syndactylus
+n02484975 guenon, guenon monkey
+n02486261 patas, hussar monkey, Erythrocebus patas
+n02486410 baboon
+n02487347 macaque
+n02488291 langur
+n02488702 colobus, colobus monkey
+n02489166 proboscis monkey, Nasalis larvatus
+n02490219 marmoset
+n02492035 capuchin, ringtail, Cebus capucinus
+n02492660 howler monkey, howler
+n02493509 titi, titi monkey
+n02493793 spider monkey, Ateles geoffroyi
+n02494079 squirrel monkey, Saimiri sciureus
+n02497673 Madagascar cat, ring-tailed lemur, Lemur catta
+n02500267 indri, indris, Indri indri, Indri brevicaudatus
+n02504013 Indian elephant, Elephas maximus
+n02504458 African elephant, Loxodonta africana
+n02509815 lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens
+n02510455 giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca
+n02514041 barracouta, snoek
+n02526121 eel
+n02536864 coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch
+n02606052 rock beauty, Holocanthus tricolor
+n02607072 anemone fish
+n02640242 sturgeon
+n02641379 gar, garfish, garpike, billfish, Lepisosteus osseus
+n02643566 lionfish
+n02655020 puffer, pufferfish, blowfish, globefish
+n02666196 abacus
+n02667093 abaya
+n02669723 academic gown, academic robe, judge's robe
+n02672831 accordion, piano accordion, squeeze box
+n02676566 acoustic guitar
+n02687172 aircraft carrier, carrier, flattop, attack aircraft carrier
+n02690373 airliner
+n02692877 airship, dirigible
+n02699494 altar
+n02701002 ambulance
+n02704792 amphibian, amphibious vehicle
+n02708093 analog clock
+n02727426 apiary, bee house
+n02730930 apron
+n02747177 ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin
+n02749479 assault rifle, assault gun
+n02769748 backpack, back pack, knapsack, packsack, rucksack, haversack
+n02776631 bakery, bakeshop, bakehouse
+n02777292 balance beam, beam
+n02782093 balloon
+n02783161 ballpoint, ballpoint pen, ballpen, Biro
+n02786058 Band Aid
+n02787622 banjo
+n02788148 bannister, banister, balustrade, balusters, handrail
+n02790996 barbell
+n02791124 barber chair
+n02791270 barbershop
+n02793495 barn
+n02794156 barometer
+n02795169 barrel, cask
+n02797295 barrow, garden cart, lawn cart, wheelbarrow
+n02799071 baseball
+n02802426 basketball
+n02804414 bassinet
+n02804610 bassoon
+n02807133 bathing cap, swimming cap
+n02808304 bath towel
+n02808440 bathtub, bathing tub, bath, tub
+n02814533 beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon
+n02814860 beacon, lighthouse, beacon light, pharos
+n02815834 beaker
+n02817516 bearskin, busby, shako
+n02823428 beer bottle
+n02823750 beer glass
+n02825657 bell cote, bell cot
+n02834397 bib
+n02835271 bicycle-built-for-two, tandem bicycle, tandem
+n02837789 bikini, two-piece
+n02840245 binder, ring-binder
+n02841315 binoculars, field glasses, opera glasses
+n02843684 birdhouse
+n02859443 boathouse
+n02860847 bobsled, bobsleigh, bob
+n02865351 bolo tie, bolo, bola tie, bola
+n02869837 bonnet, poke bonnet
+n02870880 bookcase
+n02871525 bookshop, bookstore, bookstall
+n02877765 bottlecap
+n02879718 bow
+n02883205 bow tie, bow-tie, bowtie
+n02892201 brass, memorial tablet, plaque
+n02892767 brassiere, bra, bandeau
+n02894605 breakwater, groin, groyne, mole, bulwark, seawall, jetty
+n02895154 breastplate, aegis, egis
+n02906734 broom
+n02909870 bucket, pail
+n02910353 buckle
+n02916936 bulletproof vest
+n02917067 bullet train, bullet
+n02927161 butcher shop, meat market
+n02930766 cab, hack, taxi, taxicab
+n02939185 caldron, cauldron
+n02948072 candle, taper, wax light
+n02950826 cannon
+n02951358 canoe
+n02951585 can opener, tin opener
+n02963159 cardigan
+n02965783 car mirror
+n02966193 carousel, carrousel, merry-go-round, roundabout, whirligig
+n02966687 carpenter's kit, tool kit
+n02971356 carton
+n02974003 car wheel
+n02977058 cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM
+n02978881 cassette
+n02979186 cassette player
+n02980441 castle
+n02981792 catamaran
+n02988304 CD player
+n02992211 cello, violoncello
+n02992529 cellular telephone, cellular phone, cellphone, cell, mobile phone
+n02999410 chain
+n03000134 chainlink fence
+n03000247 chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour
+n03000684 chain saw, chainsaw
+n03014705 chest
+n03016953 chiffonier, commode
+n03017168 chime, bell, gong
+n03018349 china cabinet, china closet
+n03026506 Christmas stocking
+n03028079 church, church building
+n03032252 cinema, movie theater, movie theatre, movie house, picture palace
+n03041632 cleaver, meat cleaver, chopper
+n03042490 cliff dwelling
+n03045698 cloak
+n03047690 clog, geta, patten, sabot
+n03062245 cocktail shaker
+n03063599 coffee mug
+n03063689 coffeepot
+n03065424 coil, spiral, volute, whorl, helix
+n03075370 combination lock
+n03085013 computer keyboard, keypad
+n03089624 confectionery, confectionary, candy store
+n03095699 container ship, containership, container vessel
+n03100240 convertible
+n03109150 corkscrew, bottle screw
+n03110669 cornet, horn, trumpet, trump
+n03124043 cowboy boot
+n03124170 cowboy hat, ten-gallon hat
+n03125729 cradle
+n03126707 crane
+n03127747 crash helmet
+n03127925 crate
+n03131574 crib, cot
+n03133878 Crock Pot
+n03134739 croquet ball
+n03141823 crutch
+n03146219 cuirass
+n03160309 dam, dike, dyke
+n03179701 desk
+n03180011 desktop computer
+n03187595 dial telephone, dial phone
+n03188531 diaper, nappy, napkin
+n03196217 digital clock
+n03197337 digital watch
+n03201208 dining table, board
+n03207743 dishrag, dishcloth
+n03207941 dishwasher, dish washer, dishwashing machine
+n03208938 disk brake, disc brake
+n03216828 dock, dockage, docking facility
+n03218198 dogsled, dog sled, dog sleigh
+n03220513 dome
+n03223299 doormat, welcome mat
+n03240683 drilling platform, offshore rig
+n03249569 drum, membranophone, tympan
+n03250847 drumstick
+n03255030 dumbbell
+n03259280 Dutch oven
+n03271574 electric fan, blower
+n03272010 electric guitar
+n03272562 electric locomotive
+n03290653 entertainment center
+n03291819 envelope
+n03297495 espresso maker
+n03314780 face powder
+n03325584 feather boa, boa
+n03337140 file, file cabinet, filing cabinet
+n03344393 fireboat
+n03345487 fire engine, fire truck
+n03347037 fire screen, fireguard
+n03355925 flagpole, flagstaff
+n03372029 flute, transverse flute
+n03376595 folding chair
+n03379051 football helmet
+n03384352 forklift
+n03388043 fountain
+n03388183 fountain pen
+n03388549 four-poster
+n03393912 freight car
+n03394916 French horn, horn
+n03400231 frying pan, frypan, skillet
+n03404251 fur coat
+n03417042 garbage truck, dustcart
+n03424325 gasmask, respirator, gas helmet
+n03425413 gas pump, gasoline pump, petrol pump, island dispenser
+n03443371 goblet
+n03444034 go-kart
+n03445777 golf ball
+n03445924 golfcart, golf cart
+n03447447 gondola
+n03447721 gong, tam-tam
+n03450230 gown
+n03452741 grand piano, grand
+n03457902 greenhouse, nursery, glasshouse
+n03459775 grille, radiator grille
+n03461385 grocery store, grocery, food market, market
+n03467068 guillotine
+n03476684 hair slide
+n03476991 hair spray
+n03478589 half track
+n03481172 hammer
+n03482405 hamper
+n03483316 hand blower, blow dryer, blow drier, hair dryer, hair drier
+n03485407 hand-held computer, hand-held microcomputer
+n03485794 handkerchief, hankie, hanky, hankey
+n03492542 hard disc, hard disk, fixed disk
+n03494278 harmonica, mouth organ, harp, mouth harp
+n03495258 harp
+n03496892 harvester, reaper
+n03498962 hatchet
+n03527444 holster
+n03529860 home theater, home theatre
+n03530642 honeycomb
+n03532672 hook, claw
+n03534580 hoopskirt, crinoline
+n03535780 horizontal bar, high bar
+n03538406 horse cart, horse-cart
+n03544143 hourglass
+n03584254 iPod
+n03584829 iron, smoothing iron
+n03590841 jack-o'-lantern
+n03594734 jean, blue jean, denim
+n03594945 jeep, landrover
+n03595614 jersey, T-shirt, tee shirt
+n03598930 jigsaw puzzle
+n03599486 jinrikisha, ricksha, rickshaw
+n03602883 joystick
+n03617480 kimono
+n03623198 knee pad
+n03627232 knot
+n03630383 lab coat, laboratory coat
+n03633091 ladle
+n03637318 lampshade, lamp shade
+n03642806 laptop, laptop computer
+n03649909 lawn mower, mower
+n03657121 lens cap, lens cover
+n03658185 letter opener, paper knife, paperknife
+n03661043 library
+n03662601 lifeboat
+n03666591 lighter, light, igniter, ignitor
+n03670208 limousine, limo
+n03673027 liner, ocean liner
+n03676483 lipstick, lip rouge
+n03680355 Loafer
+n03690938 lotion
+n03691459 loudspeaker, speaker, speaker unit, loudspeaker system, speaker system
+n03692522 loupe, jeweler's loupe
+n03697007 lumbermill, sawmill
+n03706229 magnetic compass
+n03709823 mailbag, postbag
+n03710193 mailbox, letter box
+n03710637 maillot
+n03710721 maillot, tank suit
+n03717622 manhole cover
+n03720891 maraca
+n03721384 marimba, xylophone
+n03724870 mask
+n03729826 matchstick
+n03733131 maypole
+n03733281 maze, labyrinth
+n03733805 measuring cup
+n03742115 medicine chest, medicine cabinet
+n03743016 megalith, megalithic structure
+n03759954 microphone, mike
+n03761084 microwave, microwave oven
+n03763968 military uniform
+n03764736 milk can
+n03769881 minibus
+n03770439 miniskirt, mini
+n03770679 minivan
+n03773504 missile
+n03775071 mitten
+n03775546 mixing bowl
+n03776460 mobile home, manufactured home
+n03777568 Model T
+n03777754 modem
+n03781244 monastery
+n03782006 monitor
+n03785016 moped
+n03786901 mortar
+n03787032 mortarboard
+n03788195 mosque
+n03788365 mosquito net
+n03791053 motor scooter, scooter
+n03792782 mountain bike, all-terrain bike, off-roader
+n03792972 mountain tent
+n03793489 mouse, computer mouse
+n03794056 mousetrap
+n03796401 moving van
+n03803284 muzzle
+n03804744 nail
+n03814639 neck brace
+n03814906 necklace
+n03825788 nipple
+n03832673 notebook, notebook computer
+n03837869 obelisk
+n03838899 oboe, hautboy, hautbois
+n03840681 ocarina, sweet potato
+n03841143 odometer, hodometer, mileometer, milometer
+n03843555 oil filter
+n03854065 organ, pipe organ
+n03857828 oscilloscope, scope, cathode-ray oscilloscope, CRO
+n03866082 overskirt
+n03868242 oxcart
+n03868863 oxygen mask
+n03871628 packet
+n03873416 paddle, boat paddle
+n03874293 paddlewheel, paddle wheel
+n03874599 padlock
+n03876231 paintbrush
+n03877472 pajama, pyjama, pj's, jammies
+n03877845 palace
+n03884397 panpipe, pandean pipe, syrinx
+n03887697 paper towel
+n03888257 parachute, chute
+n03888605 parallel bars, bars
+n03891251 park bench
+n03891332 parking meter
+n03895866 passenger car, coach, carriage
+n03899768 patio, terrace
+n03902125 pay-phone, pay-station
+n03903868 pedestal, plinth, footstall
+n03908618 pencil box, pencil case
+n03908714 pencil sharpener
+n03916031 perfume, essence
+n03920288 Petri dish
+n03924679 photocopier
+n03929660 pick, plectrum, plectron
+n03929855 pickelhaube
+n03930313 picket fence, paling
+n03930630 pickup, pickup truck
+n03933933 pier
+n03935335 piggy bank, penny bank
+n03937543 pill bottle
+n03938244 pillow
+n03942813 ping-pong ball
+n03944341 pinwheel
+n03947888 pirate, pirate ship
+n03950228 pitcher, ewer
+n03954731 plane, carpenter's plane, woodworking plane
+n03956157 planetarium
+n03958227 plastic bag
+n03961711 plate rack
+n03967562 plow, plough
+n03970156 plunger, plumber's helper
+n03976467 Polaroid camera, Polaroid Land camera
+n03976657 pole
+n03977966 police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria
+n03980874 poncho
+n03982430 pool table, billiard table, snooker table
+n03983396 pop bottle, soda bottle
+n03991062 pot, flowerpot
+n03992509 potter's wheel
+n03995372 power drill
+n03998194 prayer rug, prayer mat
+n04004767 printer
+n04005630 prison, prison house
+n04008634 projectile, missile
+n04009552 projector
+n04019541 puck, hockey puck
+n04023962 punching bag, punch bag, punching ball, punchball
+n04026417 purse
+n04033901 quill, quill pen
+n04033995 quilt, comforter, comfort, puff
+n04037443 racer, race car, racing car
+n04039381 racket, racquet
+n04040759 radiator
+n04041544 radio, wireless
+n04044716 radio telescope, radio reflector
+n04049303 rain barrel
+n04065272 recreational vehicle, RV, R.V.
+n04067472 reel
+n04069434 reflex camera
+n04070727 refrigerator, icebox
+n04074963 remote control, remote
+n04081281 restaurant, eating house, eating place, eatery
+n04086273 revolver, six-gun, six-shooter
+n04090263 rifle
+n04099969 rocking chair, rocker
+n04111531 rotisserie
+n04116512 rubber eraser, rubber, pencil eraser
+n04118538 rugby ball
+n04118776 rule, ruler
+n04120489 running shoe
+n04125021 safe
+n04127249 safety pin
+n04131690 saltshaker, salt shaker
+n04133789 sandal
+n04136333 sarong
+n04141076 sax, saxophone
+n04141327 scabbard
+n04141975 scale, weighing machine
+n04146614 school bus
+n04147183 schooner
+n04149813 scoreboard
+n04152593 screen, CRT screen
+n04153751 screw
+n04154565 screwdriver
+n04162706 seat belt, seatbelt
+n04179913 sewing machine
+n04192698 shield, buckler
+n04200800 shoe shop, shoe-shop, shoe store
+n04201297 shoji
+n04204238 shopping basket
+n04204347 shopping cart
+n04208210 shovel
+n04209133 shower cap
+n04209239 shower curtain
+n04228054 ski
+n04229816 ski mask
+n04235860 sleeping bag
+n04238763 slide rule, slipstick
+n04239074 sliding door
+n04243546 slot, one-armed bandit
+n04251144 snorkel
+n04252077 snowmobile
+n04252225 snowplow, snowplough
+n04254120 soap dispenser
+n04254680 soccer ball
+n04254777 sock
+n04258138 solar dish, solar collector, solar furnace
+n04259630 sombrero
+n04263257 soup bowl
+n04264628 space bar
+n04265275 space heater
+n04266014 space shuttle
+n04270147 spatula
+n04273569 speedboat
+n04275548 spider web, spider's web
+n04277352 spindle
+n04285008 sports car, sport car
+n04286575 spotlight, spot
+n04296562 stage
+n04310018 steam locomotive
+n04311004 steel arch bridge
+n04311174 steel drum
+n04317175 stethoscope
+n04325704 stole
+n04326547 stone wall
+n04328186 stopwatch, stop watch
+n04330267 stove
+n04332243 strainer
+n04335435 streetcar, tram, tramcar, trolley, trolley car
+n04336792 stretcher
+n04344873 studio couch, day bed
+n04346328 stupa, tope
+n04347754 submarine, pigboat, sub, U-boat
+n04350905 suit, suit of clothes
+n04355338 sundial
+n04355933 sunglass
+n04356056 sunglasses, dark glasses, shades
+n04357314 sunscreen, sunblock, sun blocker
+n04366367 suspension bridge
+n04367480 swab, swob, mop
+n04370456 sweatshirt
+n04371430 swimming trunks, bathing trunks
+n04371774 swing
+n04372370 switch, electric switch, electrical switch
+n04376876 syringe
+n04380533 table lamp
+n04389033 tank, army tank, armored combat vehicle, armoured combat vehicle
+n04392985 tape player
+n04398044 teapot
+n04399382 teddy, teddy bear
+n04404412 television, television system
+n04409515 tennis ball
+n04417672 thatch, thatched roof
+n04418357 theater curtain, theatre curtain
+n04423845 thimble
+n04428191 thresher, thrasher, threshing machine
+n04429376 throne
+n04435653 tile roof
+n04442312 toaster
+n04443257 tobacco shop, tobacconist shop, tobacconist
+n04447861 toilet seat
+n04456115 torch
+n04458633 totem pole
+n04461696 tow truck, tow car, wrecker
+n04462240 toyshop
+n04465501 tractor
+n04467665 trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi
+n04476259 tray
+n04479046 trench coat
+n04482393 tricycle, trike, velocipede
+n04483307 trimaran
+n04485082 tripod
+n04486054 triumphal arch
+n04487081 trolleybus, trolley coach, trackless trolley
+n04487394 trombone
+n04493381 tub, vat
+n04501370 turnstile
+n04505470 typewriter keyboard
+n04507155 umbrella
+n04509417 unicycle, monocycle
+n04515003 upright, upright piano
+n04517823 vacuum, vacuum cleaner
+n04522168 vase
+n04523525 vault
+n04525038 velvet
+n04525305 vending machine
+n04532106 vestment
+n04532670 viaduct
+n04536866 violin, fiddle
+n04540053 volleyball
+n04542943 waffle iron
+n04548280 wall clock
+n04548362 wallet, billfold, notecase, pocketbook
+n04550184 wardrobe, closet, press
+n04552348 warplane, military plane
+n04553703 washbasin, handbasin, washbowl, lavabo, wash-hand basin
+n04554684 washer, automatic washer, washing machine
+n04557648 water bottle
+n04560804 water jug
+n04562935 water tower
+n04579145 whiskey jug
+n04579432 whistle
+n04584207 wig
+n04589890 window screen
+n04590129 window shade
+n04591157 Windsor tie
+n04591713 wine bottle
+n04592741 wing
+n04596742 wok
+n04597913 wooden spoon
+n04599235 wool, woolen, woollen
+n04604644 worm fence, snake fence, snake-rail fence, Virginia fence
+n04606251 wreck
+n04612504 yawl
+n04613696 yurt
+n06359193 web site, website, internet site, site
+n06596364 comic book
+n06785654 crossword puzzle, crossword
+n06794110 street sign
+n06874185 traffic light, traffic signal, stoplight
+n07248320 book jacket, dust cover, dust jacket, dust wrapper
+n07565083 menu
+n07579787 plate
+n07583066 guacamole
+n07584110 consomme
+n07590611 hot pot, hotpot
+n07613480 trifle
+n07614500 ice cream, icecream
+n07615774 ice lolly, lolly, lollipop, popsicle
+n07684084 French loaf
+n07693725 bagel, beigel
+n07695742 pretzel
+n07697313 cheeseburger
+n07697537 hotdog, hot dog, red hot
+n07711569 mashed potato
+n07714571 head cabbage
+n07714990 broccoli
+n07715103 cauliflower
+n07716358 zucchini, courgette
+n07716906 spaghetti squash
+n07717410 acorn squash
+n07717556 butternut squash
+n07718472 cucumber, cuke
+n07718747 artichoke, globe artichoke
+n07720875 bell pepper
+n07730033 cardoon
+n07734744 mushroom
+n07742313 Granny Smith
+n07745940 strawberry
+n07747607 orange
+n07749582 lemon
+n07753113 fig
+n07753275 pineapple, ananas
+n07753592 banana
+n07754684 jackfruit, jak, jack
+n07760859 custard apple
+n07768694 pomegranate
+n07802026 hay
+n07831146 carbonara
+n07836838 chocolate sauce, chocolate syrup
+n07860988 dough
+n07871810 meat loaf, meatloaf
+n07873807 pizza, pizza pie
+n07875152 potpie
+n07880968 burrito
+n07892512 red wine
+n07920052 espresso
+n07930864 cup
+n07932039 eggnog
+n09193705 alp
+n09229709 bubble
+n09246464 cliff, drop, drop-off
+n09256479 coral reef
+n09288635 geyser
+n09332890 lakeside, lakeshore
+n09399592 promontory, headland, head, foreland
+n09421951 sandbar, sand bar
+n09428293 seashore, coast, seacoast, sea-coast
+n09468604 valley, vale
+n09472597 volcano
+n09835506 ballplayer, baseball player
+n10148035 groom, bridegroom
+n10565667 scuba diver
+n11879895 rapeseed
+n11939491 daisy
+n12057211 yellow lady's slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum
+n12144580 corn
+n12267677 acorn
+n12620546 hip, rose hip, rosehip
+n12768682 buckeye, horse chestnut, conker
+n12985857 coral fungus
+n12998815 agaric
+n13037406 gyromitra
+n13040303 stinkhorn, carrion fungus
+n13044778 earthstar
+n13052670 hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa
+n13054560 bolete
+n13133613 ear, spike, capitulum
+n15075141 toilet tissue, toilet paper, bathroom tissue
\ No newline at end of file
diff --git a/crates/wasi-nn/examples/classification-component-onnx/fixture/models/squeezenet1.1-7.onnx b/crates/wasi-nn/examples/classification-component-onnx/fixture/models/squeezenet1.1-7.onnx
new file mode 100644
index 000000000000..1804f9d7e521
Binary files /dev/null and b/crates/wasi-nn/examples/classification-component-onnx/fixture/models/squeezenet1.1-7.onnx differ
diff --git a/crates/wasi-nn/examples/classification-component-onnx/src/bindings.rs b/crates/wasi-nn/examples/classification-component-onnx/src/bindings.rs
new file mode 100644
index 000000000000..1c35694d74c7
--- /dev/null
+++ b/crates/wasi-nn/examples/classification-component-onnx/src/bindings.rs
@@ -0,0 +1,9171 @@
+// Generated by `wit-bindgen` 0.16.0. DO NOT EDIT!
+pub mod wasi {
+  pub mod cli {
+    
+    #[allow(clippy::all)]
+    pub mod environment {
+      #[used]
+      #[doc(hidden)]
+      #[cfg(target_arch = "wasm32")]
+      static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+      #[allow(unused_unsafe, clippy::all)]
+      /// Get the POSIX-style environment variables.
+      /// 
+      /// Each environment variable is provided as a pair of string variable names
+      /// and string value.
+      /// 
+      /// Morally, these are a value import, but until value imports are available
+      /// in the component model, this import function should return the same
+      /// values each time it is called.
+      pub fn get_environment() -> wit_bindgen::rt::vec::Vec::<(wit_bindgen::rt::string::String,wit_bindgen::rt::string::String,)>{
+        
+        #[allow(unused_imports)]
+        use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+        unsafe {
+          
+          #[repr(align(4))]
+          struct RetArea([u8; 8]);
+          let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+          let ptr0 = ret_area.as_mut_ptr() as i32;
+          #[cfg(target_arch = "wasm32")]
+          #[link(wasm_import_module = "wasi:cli/environment@0.2.0")]
+          extern "C" {
+            #[link_name = "get-environment"]
+            fn wit_import(_: i32, );
+          }
+          
+          #[cfg(not(target_arch = "wasm32"))]
+          fn wit_import(_: i32, ){ unreachable!() }
+          wit_import(ptr0);
+          let l1 = *((ptr0 + 0) as *const i32);
+          let l2 = *((ptr0 + 4) as *const i32);
+          let base9 = l1;
+          let len9 = l2;
+          let mut result9 = Vec::with_capacity(len9 as usize);
+          for i in 0..len9 {
+            let base = base9 + i * 16;
+            let e9 = {
+              let l3 = *((base + 0) as *const i32);
+              let l4 = *((base + 4) as *const i32);
+              let len5 = l4 as usize;
+              let bytes5 = Vec::from_raw_parts(l3 as *mut _, len5, len5);
+              let l6 = *((base + 8) as *const i32);
+              let l7 = *((base + 12) as *const i32);
+              let len8 = l7 as usize;
+              let bytes8 = Vec::from_raw_parts(l6 as *mut _, len8, len8);
+              
+              (wit_bindgen::rt::string_lift(bytes5), wit_bindgen::rt::string_lift(bytes8))
+            };
+            result9.push(e9);
+          }
+          wit_bindgen::rt::dealloc(base9, (len9 as usize) * 16, 4);
+          result9
+        }
+      }
+      #[allow(unused_unsafe, clippy::all)]
+      /// Get the POSIX-style arguments to the program.
+      pub fn get_arguments() -> wit_bindgen::rt::vec::Vec::<wit_bindgen::rt::string::String>{
+        
+        #[allow(unused_imports)]
+        use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+        unsafe {
+          
+          #[repr(align(4))]
+          struct RetArea([u8; 8]);
+          let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+          let ptr0 = ret_area.as_mut_ptr() as i32;
+          #[cfg(target_arch = "wasm32")]
+          #[link(wasm_import_module = "wasi:cli/environment@0.2.0")]
+          extern "C" {
+            #[link_name = "get-arguments"]
+            fn wit_import(_: i32, );
+          }
+          
+          #[cfg(not(target_arch = "wasm32"))]
+          fn wit_import(_: i32, ){ unreachable!() }
+          wit_import(ptr0);
+          let l1 = *((ptr0 + 0) as *const i32);
+          let l2 = *((ptr0 + 4) as *const i32);
+          let base6 = l1;
+          let len6 = l2;
+          let mut result6 = Vec::with_capacity(len6 as usize);
+          for i in 0..len6 {
+            let base = base6 + i * 8;
+            let e6 = {
+              let l3 = *((base + 0) as *const i32);
+              let l4 = *((base + 4) as *const i32);
+              let len5 = l4 as usize;
+              let bytes5 = Vec::from_raw_parts(l3 as *mut _, len5, len5);
+              
+              wit_bindgen::rt::string_lift(bytes5)
+            };
+            result6.push(e6);
+          }
+          wit_bindgen::rt::dealloc(base6, (len6 as usize) * 8, 4);
+          result6
+        }
+      }
+      #[allow(unused_unsafe, clippy::all)]
+      /// Return a path that programs should use as their initial current working
+      /// directory, interpreting `.` as shorthand for this.
+      pub fn initial_cwd() -> Option<wit_bindgen::rt::string::String>{
+        
+        #[allow(unused_imports)]
+        use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+        unsafe {
+          
+          #[repr(align(4))]
+          struct RetArea([u8; 12]);
+          let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+          let ptr0 = ret_area.as_mut_ptr() as i32;
+          #[cfg(target_arch = "wasm32")]
+          #[link(wasm_import_module = "wasi:cli/environment@0.2.0")]
+          extern "C" {
+            #[link_name = "initial-cwd"]
+            fn wit_import(_: i32, );
+          }
+          
+          #[cfg(not(target_arch = "wasm32"))]
+          fn wit_import(_: i32, ){ unreachable!() }
+          wit_import(ptr0);
+          let l1 = i32::from(*((ptr0 + 0) as *const u8));
+          match l1 {
+            0 => None,
+            1 => {
+              let e = {
+                let l2 = *((ptr0 + 4) as *const i32);
+                let l3 = *((ptr0 + 8) as *const i32);
+                let len4 = l3 as usize;
+                let bytes4 = Vec::from_raw_parts(l2 as *mut _, len4, len4);
+                
+                wit_bindgen::rt::string_lift(bytes4)
+              };
+              Some(e)
+            }
+            _ => wit_bindgen::rt::invalid_enum_discriminant(),
+          }
+        }
+      }
+      
+    }
+    
+    
+    #[allow(clippy::all)]
+    pub mod exit {
+      #[used]
+      #[doc(hidden)]
+      #[cfg(target_arch = "wasm32")]
+      static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+      #[allow(unused_unsafe, clippy::all)]
+      /// Exit the current instance and any linked instances.
+      pub fn exit(status: Result<(),()>,){
+        
+        #[allow(unused_imports)]
+        use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+        unsafe {
+          let result0 = match status {
+            Ok(_) => { 0i32 },
+            Err(_) => { 1i32 },
+          };
+          #[cfg(target_arch = "wasm32")]
+          #[link(wasm_import_module = "wasi:cli/exit@0.2.0")]
+          extern "C" {
+            #[link_name = "exit"]
+            fn wit_import(_: i32, );
+          }
+          
+          #[cfg(not(target_arch = "wasm32"))]
+          fn wit_import(_: i32, ){ unreachable!() }
+          wit_import(result0);
+        }
+      }
+      
+    }
+    
+    
+    #[allow(clippy::all)]
+    pub mod stdin {
+      #[used]
+      #[doc(hidden)]
+      #[cfg(target_arch = "wasm32")]
+      static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+      pub type InputStream = super::super::super::wasi::io::streams::InputStream;
+      #[allow(unused_unsafe, clippy::all)]
+      pub fn get_stdin() -> InputStream{
+        
+        #[allow(unused_imports)]
+        use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+        unsafe {
+          
+          #[cfg(target_arch = "wasm32")]
+          #[link(wasm_import_module = "wasi:cli/stdin@0.2.0")]
+          extern "C" {
+            #[link_name = "get-stdin"]
+            fn wit_import() -> i32;
+          }
+          
+          #[cfg(not(target_arch = "wasm32"))]
+          fn wit_import() -> i32{ unreachable!() }
+          let ret = wit_import();
+          super::super::super::wasi::io::streams::InputStream::from_handle(ret as u32)
+        }
+      }
+      
+    }
+    
+    
+    #[allow(clippy::all)]
+    pub mod stdout {
+      #[used]
+      #[doc(hidden)]
+      #[cfg(target_arch = "wasm32")]
+      static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+      pub type OutputStream = super::super::super::wasi::io::streams::OutputStream;
+      #[allow(unused_unsafe, clippy::all)]
+      pub fn get_stdout() -> OutputStream{
+        
+        #[allow(unused_imports)]
+        use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+        unsafe {
+          
+          #[cfg(target_arch = "wasm32")]
+          #[link(wasm_import_module = "wasi:cli/stdout@0.2.0")]
+          extern "C" {
+            #[link_name = "get-stdout"]
+            fn wit_import() -> i32;
+          }
+          
+          #[cfg(not(target_arch = "wasm32"))]
+          fn wit_import() -> i32{ unreachable!() }
+          let ret = wit_import();
+          super::super::super::wasi::io::streams::OutputStream::from_handle(ret as u32)
+        }
+      }
+      
+    }
+    
+    
+    #[allow(clippy::all)]
+    pub mod stderr {
+      #[used]
+      #[doc(hidden)]
+      #[cfg(target_arch = "wasm32")]
+      static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+      pub type OutputStream = super::super::super::wasi::io::streams::OutputStream;
+      #[allow(unused_unsafe, clippy::all)]
+      pub fn get_stderr() -> OutputStream{
+        
+        #[allow(unused_imports)]
+        use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+        unsafe {
+          
+          #[cfg(target_arch = "wasm32")]
+          #[link(wasm_import_module = "wasi:cli/stderr@0.2.0")]
+          extern "C" {
+            #[link_name = "get-stderr"]
+            fn wit_import() -> i32;
+          }
+          
+          #[cfg(not(target_arch = "wasm32"))]
+          fn wit_import() -> i32{ unreachable!() }
+          let ret = wit_import();
+          super::super::super::wasi::io::streams::OutputStream::from_handle(ret as u32)
+        }
+      }
+      
+    }
+    
+    
+    #[allow(clippy::all)]
+    pub mod terminal_input {
+      #[used]
+      #[doc(hidden)]
+      #[cfg(target_arch = "wasm32")]
+      static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+      /// The input side of a terminal.
+      
+      #[derive(Debug)]
+      #[repr(transparent)]
+      pub struct TerminalInput{
+        handle: wit_bindgen::rt::Resource<TerminalInput>,
+      }
+      
+      impl TerminalInput{
+        #[doc(hidden)]
+        pub unsafe fn from_handle(handle: u32) -> Self {
+          Self {
+            handle: wit_bindgen::rt::Resource::from_handle(handle),
+          }
+        }
+        
+        #[doc(hidden)]
+        pub fn into_handle(self) -> u32 {
+          wit_bindgen::rt::Resource::into_handle(self.handle)
+        }
+        
+        #[doc(hidden)]
+        pub fn handle(&self) -> u32 {
+          wit_bindgen::rt::Resource::handle(&self.handle)
+        }
+      }
+      
+      
+      unsafe impl wit_bindgen::rt::WasmResource for TerminalInput{
+        #[inline]
+        unsafe fn drop(_handle: u32) {
+          #[cfg(not(target_arch = "wasm32"))]
+          unreachable!();
+          
+          #[cfg(target_arch = "wasm32")]
+          {
+            #[link(wasm_import_module = "wasi:cli/terminal-input@0.2.0")]
+            extern "C" {
+              #[link_name = "[resource-drop]terminal-input"]
+              fn drop(_: u32);
+            }
+            
+            drop(_handle);
+          }
+        }
+      }
+      
+      
+    }
+    
+    
+    #[allow(clippy::all)]
+    pub mod terminal_output {
+      #[used]
+      #[doc(hidden)]
+      #[cfg(target_arch = "wasm32")]
+      static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+      /// The output side of a terminal.
+      
+      #[derive(Debug)]
+      #[repr(transparent)]
+      pub struct TerminalOutput{
+        handle: wit_bindgen::rt::Resource<TerminalOutput>,
+      }
+      
+      impl TerminalOutput{
+        #[doc(hidden)]
+        pub unsafe fn from_handle(handle: u32) -> Self {
+          Self {
+            handle: wit_bindgen::rt::Resource::from_handle(handle),
+          }
+        }
+        
+        #[doc(hidden)]
+        pub fn into_handle(self) -> u32 {
+          wit_bindgen::rt::Resource::into_handle(self.handle)
+        }
+        
+        #[doc(hidden)]
+        pub fn handle(&self) -> u32 {
+          wit_bindgen::rt::Resource::handle(&self.handle)
+        }
+      }
+      
+      
+      unsafe impl wit_bindgen::rt::WasmResource for TerminalOutput{
+        #[inline]
+        unsafe fn drop(_handle: u32) {
+          #[cfg(not(target_arch = "wasm32"))]
+          unreachable!();
+          
+          #[cfg(target_arch = "wasm32")]
+          {
+            #[link(wasm_import_module = "wasi:cli/terminal-output@0.2.0")]
+            extern "C" {
+              #[link_name = "[resource-drop]terminal-output"]
+              fn drop(_: u32);
+            }
+            
+            drop(_handle);
+          }
+        }
+      }
+      
+      
+    }
+    
+    
+    #[allow(clippy::all)]
+    pub mod terminal_stdin {
+      #[used]
+      #[doc(hidden)]
+      #[cfg(target_arch = "wasm32")]
+      static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+      pub type TerminalInput = super::super::super::wasi::cli::terminal_input::TerminalInput;
+      #[allow(unused_unsafe, clippy::all)]
+      /// If stdin is connected to a terminal, return a `terminal-input` handle
+      /// allowing further interaction with it.
+      pub fn get_terminal_stdin() -> Option<TerminalInput>{
+        
+        #[allow(unused_imports)]
+        use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+        unsafe {
+          
+          #[repr(align(4))]
+          struct RetArea([u8; 8]);
+          let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+          let ptr0 = ret_area.as_mut_ptr() as i32;
+          #[cfg(target_arch = "wasm32")]
+          #[link(wasm_import_module = "wasi:cli/terminal-stdin@0.2.0")]
+          extern "C" {
+            #[link_name = "get-terminal-stdin"]
+            fn wit_import(_: i32, );
+          }
+          
+          #[cfg(not(target_arch = "wasm32"))]
+          fn wit_import(_: i32, ){ unreachable!() }
+          wit_import(ptr0);
+          let l1 = i32::from(*((ptr0 + 0) as *const u8));
+          match l1 {
+            0 => None,
+            1 => {
+              let e = {
+                let l2 = *((ptr0 + 4) as *const i32);
+                
+                super::super::super::wasi::cli::terminal_input::TerminalInput::from_handle(l2 as u32)
+              };
+              Some(e)
+            }
+            _ => wit_bindgen::rt::invalid_enum_discriminant(),
+          }
+        }
+      }
+      
+    }
+    
+    
+    #[allow(clippy::all)]
+    pub mod terminal_stdout {
+      #[used]
+      #[doc(hidden)]
+      #[cfg(target_arch = "wasm32")]
+      static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+      pub type TerminalOutput = super::super::super::wasi::cli::terminal_output::TerminalOutput;
+      #[allow(unused_unsafe, clippy::all)]
+      /// If stdout is connected to a terminal, return a `terminal-output` handle
+      /// allowing further interaction with it.
+      pub fn get_terminal_stdout() -> Option<TerminalOutput>{
+        
+        #[allow(unused_imports)]
+        use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+        unsafe {
+          
+          #[repr(align(4))]
+          struct RetArea([u8; 8]);
+          let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+          let ptr0 = ret_area.as_mut_ptr() as i32;
+          #[cfg(target_arch = "wasm32")]
+          #[link(wasm_import_module = "wasi:cli/terminal-stdout@0.2.0")]
+          extern "C" {
+            #[link_name = "get-terminal-stdout"]
+            fn wit_import(_: i32, );
+          }
+          
+          #[cfg(not(target_arch = "wasm32"))]
+          fn wit_import(_: i32, ){ unreachable!() }
+          wit_import(ptr0);
+          let l1 = i32::from(*((ptr0 + 0) as *const u8));
+          match l1 {
+            0 => None,
+            1 => {
+              let e = {
+                let l2 = *((ptr0 + 4) as *const i32);
+                
+                super::super::super::wasi::cli::terminal_output::TerminalOutput::from_handle(l2 as u32)
+              };
+              Some(e)
+            }
+            _ => wit_bindgen::rt::invalid_enum_discriminant(),
+          }
+        }
+      }
+      
+    }
+    
+    
+    #[allow(clippy::all)]
+    pub mod terminal_stderr {
+      #[used]
+      #[doc(hidden)]
+      #[cfg(target_arch = "wasm32")]
+      static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+      pub type TerminalOutput = super::super::super::wasi::cli::terminal_output::TerminalOutput;
+      #[allow(unused_unsafe, clippy::all)]
+      /// If stderr is connected to a terminal, return a `terminal-output` handle
+      /// allowing further interaction with it.
+      pub fn get_terminal_stderr() -> Option<TerminalOutput>{
+        
+        #[allow(unused_imports)]
+        use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+        unsafe {
+          
+          #[repr(align(4))]
+          struct RetArea([u8; 8]);
+          let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+          let ptr0 = ret_area.as_mut_ptr() as i32;
+          #[cfg(target_arch = "wasm32")]
+          #[link(wasm_import_module = "wasi:cli/terminal-stderr@0.2.0")]
+          extern "C" {
+            #[link_name = "get-terminal-stderr"]
+            fn wit_import(_: i32, );
+          }
+          
+          #[cfg(not(target_arch = "wasm32"))]
+          fn wit_import(_: i32, ){ unreachable!() }
+          wit_import(ptr0);
+          let l1 = i32::from(*((ptr0 + 0) as *const u8));
+          match l1 {
+            0 => None,
+            1 => {
+              let e = {
+                let l2 = *((ptr0 + 4) as *const i32);
+                
+                super::super::super::wasi::cli::terminal_output::TerminalOutput::from_handle(l2 as u32)
+              };
+              Some(e)
+            }
+            _ => wit_bindgen::rt::invalid_enum_discriminant(),
+          }
+        }
+      }
+      
+    }
+    
+  }
+  pub mod clocks {
+    
+    #[allow(clippy::all)]
+    pub mod monotonic_clock {
+      #[used]
+      #[doc(hidden)]
+      #[cfg(target_arch = "wasm32")]
+      static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+      pub type Pollable = super::super::super::wasi::io::poll::Pollable;
+      /// An instant in time, in nanoseconds. An instant is relative to an
+      /// unspecified initial value, and can only be compared to instances from
+      /// the same monotonic-clock.
+      pub type Instant = u64;
+      /// A duration of time, in nanoseconds.
+      pub type Duration = u64;
+      #[allow(unused_unsafe, clippy::all)]
+      /// Read the current value of the clock.
+      /// 
+      /// The clock is monotonic, therefore calling this function repeatedly will
+      /// produce a sequence of non-decreasing values.
+      pub fn now() -> Instant{
+        
+        #[allow(unused_imports)]
+        use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+        unsafe {
+          
+          #[cfg(target_arch = "wasm32")]
+          #[link(wasm_import_module = "wasi:clocks/monotonic-clock@0.2.0")]
+          extern "C" {
+            #[link_name = "now"]
+            fn wit_import() -> i64;
+          }
+          
+          #[cfg(not(target_arch = "wasm32"))]
+          fn wit_import() -> i64{ unreachable!() }
+          let ret = wit_import();
+          ret as u64
+        }
+      }
+      #[allow(unused_unsafe, clippy::all)]
+      /// Query the resolution of the clock. Returns the duration of time
+      /// corresponding to a clock tick.
+      pub fn resolution() -> Duration{
+        
+        #[allow(unused_imports)]
+        use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+        unsafe {
+          
+          #[cfg(target_arch = "wasm32")]
+          #[link(wasm_import_module = "wasi:clocks/monotonic-clock@0.2.0")]
+          extern "C" {
+            #[link_name = "resolution"]
+            fn wit_import() -> i64;
+          }
+          
+          #[cfg(not(target_arch = "wasm32"))]
+          fn wit_import() -> i64{ unreachable!() }
+          let ret = wit_import();
+          ret as u64
+        }
+      }
+      #[allow(unused_unsafe, clippy::all)]
+      /// Create a `pollable` which will resolve once the specified instant
+      /// occurred.
+      pub fn subscribe_instant(when: Instant,) -> Pollable{
+        
+        #[allow(unused_imports)]
+        use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+        unsafe {
+          
+          #[cfg(target_arch = "wasm32")]
+          #[link(wasm_import_module = "wasi:clocks/monotonic-clock@0.2.0")]
+          extern "C" {
+            #[link_name = "subscribe-instant"]
+            fn wit_import(_: i64, ) -> i32;
+          }
+          
+          #[cfg(not(target_arch = "wasm32"))]
+          fn wit_import(_: i64, ) -> i32{ unreachable!() }
+          let ret = wit_import(wit_bindgen::rt::as_i64(when));
+          super::super::super::wasi::io::poll::Pollable::from_handle(ret as u32)
+        }
+      }
+      #[allow(unused_unsafe, clippy::all)]
+      /// Create a `pollable` which will resolve once the given duration has
+      /// elapsed, starting at the time at which this function was called.
+      /// occurred.
+      pub fn subscribe_duration(when: Duration,) -> Pollable{
+        
+        #[allow(unused_imports)]
+        use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+        unsafe {
+          
+          #[cfg(target_arch = "wasm32")]
+          #[link(wasm_import_module = "wasi:clocks/monotonic-clock@0.2.0")]
+          extern "C" {
+            #[link_name = "subscribe-duration"]
+            fn wit_import(_: i64, ) -> i32;
+          }
+          
+          #[cfg(not(target_arch = "wasm32"))]
+          fn wit_import(_: i64, ) -> i32{ unreachable!() }
+          let ret = wit_import(wit_bindgen::rt::as_i64(when));
+          super::super::super::wasi::io::poll::Pollable::from_handle(ret as u32)
+        }
+      }
+      
+    }
+    
+    
+    #[allow(clippy::all)]
+    pub mod wall_clock {
+      #[used]
+      #[doc(hidden)]
+      #[cfg(target_arch = "wasm32")]
+      static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+      /// A time and date in seconds plus nanoseconds.
+      #[repr(C)]
+      #[derive(Clone, Copy)]
+      pub struct Datetime {
+        pub seconds: u64,
+        pub nanoseconds: u32,
+      }
+      impl ::core::fmt::Debug for Datetime {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+          f.debug_struct("Datetime").field("seconds", &self.seconds).field("nanoseconds", &self.nanoseconds).finish()
+        }
+      }
+      #[allow(unused_unsafe, clippy::all)]
+      /// Read the current value of the clock.
+      /// 
+      /// This clock is not monotonic, therefore calling this function repeatedly
+      /// will not necessarily produce a sequence of non-decreasing values.
+      /// 
+      /// The returned timestamps represent the number of seconds since
+      /// 1970-01-01T00:00:00Z, also known as [POSIX's Seconds Since the Epoch],
+      /// also known as [Unix Time].
+      /// 
+      /// The nanoseconds field of the output is always less than 1000000000.
+      /// 
+      /// [POSIX's Seconds Since the Epoch]: https://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xbd_chap04.html#tag_21_04_16
+      /// [Unix Time]: https://en.wikipedia.org/wiki/Unix_time
+      pub fn now() -> Datetime{
+        
+        #[allow(unused_imports)]
+        use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+        unsafe {
+          
+          #[repr(align(8))]
+          struct RetArea([u8; 16]);
+          let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+          let ptr0 = ret_area.as_mut_ptr() as i32;
+          #[cfg(target_arch = "wasm32")]
+          #[link(wasm_import_module = "wasi:clocks/wall-clock@0.2.0")]
+          extern "C" {
+            #[link_name = "now"]
+            fn wit_import(_: i32, );
+          }
+          
+          #[cfg(not(target_arch = "wasm32"))]
+          fn wit_import(_: i32, ){ unreachable!() }
+          wit_import(ptr0);
+          let l1 = *((ptr0 + 0) as *const i64);
+          let l2 = *((ptr0 + 8) as *const i32);
+          Datetime{
+            seconds: l1 as u64,
+            nanoseconds: l2 as u32,
+          }
+        }
+      }
+      #[allow(unused_unsafe, clippy::all)]
+      /// Query the resolution of the clock.
+      /// 
+      /// The nanoseconds field of the output is always less than 1000000000.
+      pub fn resolution() -> Datetime{
+        
+        #[allow(unused_imports)]
+        use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+        unsafe {
+          
+          #[repr(align(8))]
+          struct RetArea([u8; 16]);
+          let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+          let ptr0 = ret_area.as_mut_ptr() as i32;
+          #[cfg(target_arch = "wasm32")]
+          #[link(wasm_import_module = "wasi:clocks/wall-clock@0.2.0")]
+          extern "C" {
+            #[link_name = "resolution"]
+            fn wit_import(_: i32, );
+          }
+          
+          #[cfg(not(target_arch = "wasm32"))]
+          fn wit_import(_: i32, ){ unreachable!() }
+          wit_import(ptr0);
+          let l1 = *((ptr0 + 0) as *const i64);
+          let l2 = *((ptr0 + 8) as *const i32);
+          Datetime{
+            seconds: l1 as u64,
+            nanoseconds: l2 as u32,
+          }
+        }
+      }
+      
+    }
+    
+  }
+  pub mod filesystem {
+    
+    #[allow(clippy::all)]
+    pub mod types {
+      #[used]
+      #[doc(hidden)]
+      #[cfg(target_arch = "wasm32")]
+      static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+      pub type InputStream = super::super::super::wasi::io::streams::InputStream;
+      pub type OutputStream = super::super::super::wasi::io::streams::OutputStream;
+      pub type Error = super::super::super::wasi::io::streams::Error;
+      pub type Datetime = super::super::super::wasi::clocks::wall_clock::Datetime;
+      /// File size or length of a region within a file.
+      pub type Filesize = u64;
+      /// The type of a filesystem object referenced by a descriptor.
+      /// 
+      /// Note: This was called `filetype` in earlier versions of WASI.
+      #[repr(u8)]
+      #[derive(Clone, Copy, Eq, PartialEq)]
+      pub enum DescriptorType {
+        /// The type of the descriptor or file is unknown or is different from
+        /// any of the other types specified.
+        Unknown,
+        /// The descriptor refers to a block device inode.
+        BlockDevice,
+        /// The descriptor refers to a character device inode.
+        CharacterDevice,
+        /// The descriptor refers to a directory inode.
+        Directory,
+        /// The descriptor refers to a named pipe.
+        Fifo,
+        /// The file refers to a symbolic link inode.
+        SymbolicLink,
+        /// The descriptor refers to a regular file inode.
+        RegularFile,
+        /// The descriptor refers to a socket.
+        Socket,
+      }
+      impl ::core::fmt::Debug for DescriptorType {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+          match self {
+            DescriptorType::Unknown => {
+              f.debug_tuple("DescriptorType::Unknown").finish()
+            }
+            DescriptorType::BlockDevice => {
+              f.debug_tuple("DescriptorType::BlockDevice").finish()
+            }
+            DescriptorType::CharacterDevice => {
+              f.debug_tuple("DescriptorType::CharacterDevice").finish()
+            }
+            DescriptorType::Directory => {
+              f.debug_tuple("DescriptorType::Directory").finish()
+            }
+            DescriptorType::Fifo => {
+              f.debug_tuple("DescriptorType::Fifo").finish()
+            }
+            DescriptorType::SymbolicLink => {
+              f.debug_tuple("DescriptorType::SymbolicLink").finish()
+            }
+            DescriptorType::RegularFile => {
+              f.debug_tuple("DescriptorType::RegularFile").finish()
+            }
+            DescriptorType::Socket => {
+              f.debug_tuple("DescriptorType::Socket").finish()
+            }
+          }
+        }
+      }
+      
+      impl DescriptorType{
+        pub(crate) unsafe fn _lift(val: u8) -> DescriptorType{
+          if !cfg!(debug_assertions) {
+            return ::core::mem::transmute(val);
+          }
+          
+          match val {
+            0 => DescriptorType::Unknown,
+            1 => DescriptorType::BlockDevice,
+            2 => DescriptorType::CharacterDevice,
+            3 => DescriptorType::Directory,
+            4 => DescriptorType::Fifo,
+            5 => DescriptorType::SymbolicLink,
+            6 => DescriptorType::RegularFile,
+            7 => DescriptorType::Socket,
+            
+            _ => panic!("invalid enum discriminant"),
+          }
+        }
+      }
+      
+      wit_bindgen::bitflags::bitflags! {
+        /// Descriptor flags.
+        /// 
+        /// Note: This was called `fdflags` in earlier versions of WASI.
+        #[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)]
+        pub struct DescriptorFlags: u8 {
+          /// Read mode: Data can be read.
+          const READ = 1 << 0;
+          /// Write mode: Data can be written to.
+          const WRITE = 1 << 1;
+          /// Request that writes be performed according to synchronized I/O file
+          /// integrity completion. The data stored in the file and the file's
+          /// metadata are synchronized. This is similar to `O_SYNC` in POSIX.
+          /// 
+          /// The precise semantics of this operation have not yet been defined for
+          /// WASI. At this time, it should be interpreted as a request, and not a
+          /// requirement.
+          const FILE_INTEGRITY_SYNC = 1 << 2;
+          /// Request that writes be performed according to synchronized I/O data
+          /// integrity completion. Only the data stored in the file is
+          /// synchronized. This is similar to `O_DSYNC` in POSIX.
+          /// 
+          /// The precise semantics of this operation have not yet been defined for
+          /// WASI. At this time, it should be interpreted as a request, and not a
+          /// requirement.
+          const DATA_INTEGRITY_SYNC = 1 << 3;
+          /// Requests that reads be performed at the same level of integrity
+          /// requested for writes. This is similar to `O_RSYNC` in POSIX.
+          /// 
+          /// The precise semantics of this operation have not yet been defined for
+          /// WASI. At this time, it should be interpreted as a request, and not a
+          /// requirement.
+          const REQUESTED_WRITE_SYNC = 1 << 4;
+          /// Mutating directories mode: Directory contents may be mutated.
+          /// 
+          /// When this flag is unset on a descriptor, operations using the
+          /// descriptor which would create, rename, delete, modify the data or
+          /// metadata of filesystem objects, or obtain another handle which
+          /// would permit any of those, shall fail with `error-code::read-only` if
+          /// they would otherwise succeed.
+          /// 
+          /// This may only be set on directories.
+          const MUTATE_DIRECTORY = 1 << 5;
+        }
+      }
+      wit_bindgen::bitflags::bitflags! {
+        /// Flags determining the method of how paths are resolved.
+        #[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)]
+        pub struct PathFlags: u8 {
+          /// As long as the resolved path corresponds to a symbolic link, it is
+          /// expanded.
+          const SYMLINK_FOLLOW = 1 << 0;
+        }
+      }
+      wit_bindgen::bitflags::bitflags! {
+        /// Open flags used by `open-at`.
+        #[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)]
+        pub struct OpenFlags: u8 {
+          /// Create file if it does not exist, similar to `O_CREAT` in POSIX.
+          const CREATE = 1 << 0;
+          /// Fail if not a directory, similar to `O_DIRECTORY` in POSIX.
+          const DIRECTORY = 1 << 1;
+          /// Fail if file already exists, similar to `O_EXCL` in POSIX.
+          const EXCLUSIVE = 1 << 2;
+          /// Truncate file to size 0, similar to `O_TRUNC` in POSIX.
+          const TRUNCATE = 1 << 3;
+        }
+      }
+      /// Number of hard links to an inode.
+      pub type LinkCount = u64;
+      /// File attributes.
+      /// 
+      /// Note: This was called `filestat` in earlier versions of WASI.
+      #[repr(C)]
+      #[derive(Clone, Copy)]
+      pub struct DescriptorStat {
+        /// File type.
+        pub type_: DescriptorType,
+        /// Number of hard links to the file.
+        pub link_count: LinkCount,
+        /// For regular files, the file size in bytes. For symbolic links, the
+        /// length in bytes of the pathname contained in the symbolic link.
+        pub size: Filesize,
+        /// Last data access timestamp.
+        /// 
+        /// If the `option` is none, the platform doesn't maintain an access
+        /// timestamp for this file.
+        pub data_access_timestamp: Option<Datetime>,
+        /// Last data modification timestamp.
+        /// 
+        /// If the `option` is none, the platform doesn't maintain a
+        /// modification timestamp for this file.
+        pub data_modification_timestamp: Option<Datetime>,
+        /// Last file status-change timestamp.
+        /// 
+        /// If the `option` is none, the platform doesn't maintain a
+        /// status-change timestamp for this file.
+        pub status_change_timestamp: Option<Datetime>,
+      }
+      impl ::core::fmt::Debug for DescriptorStat {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+          f.debug_struct("DescriptorStat").field("type", &self.type_).field("link-count", &self.link_count).field("size", &self.size).field("data-access-timestamp", &self.data_access_timestamp).field("data-modification-timestamp", &self.data_modification_timestamp).field("status-change-timestamp", &self.status_change_timestamp).finish()
+        }
+      }
+      /// When setting a timestamp, this gives the value to set it to.
+      #[derive(Clone, Copy)]
+      pub enum NewTimestamp{
+        /// Leave the timestamp set to its previous value.
+        NoChange,
+        /// Set the timestamp to the current time of the system clock associated
+        /// with the filesystem.
+        Now,
+        /// Set the timestamp to the given value.
+        Timestamp(Datetime),
+      }
+      impl ::core::fmt::Debug for NewTimestamp {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+          match self {
+            NewTimestamp::NoChange => {
+              f.debug_tuple("NewTimestamp::NoChange").finish()
+            }
+            NewTimestamp::Now => {
+              f.debug_tuple("NewTimestamp::Now").finish()
+            }
+            NewTimestamp::Timestamp(e) => {
+              f.debug_tuple("NewTimestamp::Timestamp").field(e).finish()
+            }
+          }
+        }
+      }
+      /// A directory entry.
+      #[derive(Clone)]
+      pub struct DirectoryEntry {
+        /// The type of the file referred to by this directory entry.
+        pub type_: DescriptorType,
+        /// The name of the object.
+        pub name: wit_bindgen::rt::string::String,
+      }
+      impl ::core::fmt::Debug for DirectoryEntry {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+          f.debug_struct("DirectoryEntry").field("type", &self.type_).field("name", &self.name).finish()
+        }
+      }
+      /// Error codes returned by functions, similar to `errno` in POSIX.
+      /// Not all of these error codes are returned by the functions provided by this
+      /// API; some are used in higher-level library layers, and others are provided
+      /// merely for alignment with POSIX.
+      #[repr(u8)]
+      #[derive(Clone, Copy, Eq, PartialEq)]
+      pub enum ErrorCode {
+        /// Permission denied, similar to `EACCES` in POSIX.
+        Access,
+        /// Resource unavailable, or operation would block, similar to `EAGAIN` and `EWOULDBLOCK` in POSIX.
+        WouldBlock,
+        /// Connection already in progress, similar to `EALREADY` in POSIX.
+        Already,
+        /// Bad descriptor, similar to `EBADF` in POSIX.
+        BadDescriptor,
+        /// Device or resource busy, similar to `EBUSY` in POSIX.
+        Busy,
+        /// Resource deadlock would occur, similar to `EDEADLK` in POSIX.
+        Deadlock,
+        /// Storage quota exceeded, similar to `EDQUOT` in POSIX.
+        Quota,
+        /// File exists, similar to `EEXIST` in POSIX.
+        Exist,
+        /// File too large, similar to `EFBIG` in POSIX.
+        FileTooLarge,
+        /// Illegal byte sequence, similar to `EILSEQ` in POSIX.
+        IllegalByteSequence,
+        /// Operation in progress, similar to `EINPROGRESS` in POSIX.
+        InProgress,
+        /// Interrupted function, similar to `EINTR` in POSIX.
+        Interrupted,
+        /// Invalid argument, similar to `EINVAL` in POSIX.
+        Invalid,
+        /// I/O error, similar to `EIO` in POSIX.
+        Io,
+        /// Is a directory, similar to `EISDIR` in POSIX.
+        IsDirectory,
+        /// Too many levels of symbolic links, similar to `ELOOP` in POSIX.
+        Loop,
+        /// Too many links, similar to `EMLINK` in POSIX.
+        TooManyLinks,
+        /// Message too large, similar to `EMSGSIZE` in POSIX.
+        MessageSize,
+        /// Filename too long, similar to `ENAMETOOLONG` in POSIX.
+        NameTooLong,
+        /// No such device, similar to `ENODEV` in POSIX.
+        NoDevice,
+        /// No such file or directory, similar to `ENOENT` in POSIX.
+        NoEntry,
+        /// No locks available, similar to `ENOLCK` in POSIX.
+        NoLock,
+        /// Not enough space, similar to `ENOMEM` in POSIX.
+        InsufficientMemory,
+        /// No space left on device, similar to `ENOSPC` in POSIX.
+        InsufficientSpace,
+        /// Not a directory or a symbolic link to a directory, similar to `ENOTDIR` in POSIX.
+        NotDirectory,
+        /// Directory not empty, similar to `ENOTEMPTY` in POSIX.
+        NotEmpty,
+        /// State not recoverable, similar to `ENOTRECOVERABLE` in POSIX.
+        NotRecoverable,
+        /// Not supported, similar to `ENOTSUP` and `ENOSYS` in POSIX.
+        Unsupported,
+        /// Inappropriate I/O control operation, similar to `ENOTTY` in POSIX.
+        NoTty,
+        /// No such device or address, similar to `ENXIO` in POSIX.
+        NoSuchDevice,
+        /// Value too large to be stored in data type, similar to `EOVERFLOW` in POSIX.
+        Overflow,
+        /// Operation not permitted, similar to `EPERM` in POSIX.
+        NotPermitted,
+        /// Broken pipe, similar to `EPIPE` in POSIX.
+        Pipe,
+        /// Read-only file system, similar to `EROFS` in POSIX.
+        ReadOnly,
+        /// Invalid seek, similar to `ESPIPE` in POSIX.
+        InvalidSeek,
+        /// Text file busy, similar to `ETXTBSY` in POSIX.
+        TextFileBusy,
+        /// Cross-device link, similar to `EXDEV` in POSIX.
+        CrossDevice,
+      }
+      impl ErrorCode{
+        pub fn name(&self) -> &'static str {
+          match self {
+            ErrorCode::Access => "access",
+            ErrorCode::WouldBlock => "would-block",
+            ErrorCode::Already => "already",
+            ErrorCode::BadDescriptor => "bad-descriptor",
+            ErrorCode::Busy => "busy",
+            ErrorCode::Deadlock => "deadlock",
+            ErrorCode::Quota => "quota",
+            ErrorCode::Exist => "exist",
+            ErrorCode::FileTooLarge => "file-too-large",
+            ErrorCode::IllegalByteSequence => "illegal-byte-sequence",
+            ErrorCode::InProgress => "in-progress",
+            ErrorCode::Interrupted => "interrupted",
+            ErrorCode::Invalid => "invalid",
+            ErrorCode::Io => "io",
+            ErrorCode::IsDirectory => "is-directory",
+            ErrorCode::Loop => "loop",
+            ErrorCode::TooManyLinks => "too-many-links",
+            ErrorCode::MessageSize => "message-size",
+            ErrorCode::NameTooLong => "name-too-long",
+            ErrorCode::NoDevice => "no-device",
+            ErrorCode::NoEntry => "no-entry",
+            ErrorCode::NoLock => "no-lock",
+            ErrorCode::InsufficientMemory => "insufficient-memory",
+            ErrorCode::InsufficientSpace => "insufficient-space",
+            ErrorCode::NotDirectory => "not-directory",
+            ErrorCode::NotEmpty => "not-empty",
+            ErrorCode::NotRecoverable => "not-recoverable",
+            ErrorCode::Unsupported => "unsupported",
+            ErrorCode::NoTty => "no-tty",
+            ErrorCode::NoSuchDevice => "no-such-device",
+            ErrorCode::Overflow => "overflow",
+            ErrorCode::NotPermitted => "not-permitted",
+            ErrorCode::Pipe => "pipe",
+            ErrorCode::ReadOnly => "read-only",
+            ErrorCode::InvalidSeek => "invalid-seek",
+            ErrorCode::TextFileBusy => "text-file-busy",
+            ErrorCode::CrossDevice => "cross-device",
+          }
+        }
+        pub fn message(&self) -> &'static str {
+          match self {
+            ErrorCode::Access => "Permission denied, similar to `EACCES` in POSIX.",
+            ErrorCode::WouldBlock => "Resource unavailable, or operation would block, similar to `EAGAIN` and `EWOULDBLOCK` in POSIX.",
+            ErrorCode::Already => "Connection already in progress, similar to `EALREADY` in POSIX.",
+            ErrorCode::BadDescriptor => "Bad descriptor, similar to `EBADF` in POSIX.",
+            ErrorCode::Busy => "Device or resource busy, similar to `EBUSY` in POSIX.",
+            ErrorCode::Deadlock => "Resource deadlock would occur, similar to `EDEADLK` in POSIX.",
+            ErrorCode::Quota => "Storage quota exceeded, similar to `EDQUOT` in POSIX.",
+            ErrorCode::Exist => "File exists, similar to `EEXIST` in POSIX.",
+            ErrorCode::FileTooLarge => "File too large, similar to `EFBIG` in POSIX.",
+            ErrorCode::IllegalByteSequence => "Illegal byte sequence, similar to `EILSEQ` in POSIX.",
+            ErrorCode::InProgress => "Operation in progress, similar to `EINPROGRESS` in POSIX.",
+            ErrorCode::Interrupted => "Interrupted function, similar to `EINTR` in POSIX.",
+            ErrorCode::Invalid => "Invalid argument, similar to `EINVAL` in POSIX.",
+            ErrorCode::Io => "I/O error, similar to `EIO` in POSIX.",
+            ErrorCode::IsDirectory => "Is a directory, similar to `EISDIR` in POSIX.",
+            ErrorCode::Loop => "Too many levels of symbolic links, similar to `ELOOP` in POSIX.",
+            ErrorCode::TooManyLinks => "Too many links, similar to `EMLINK` in POSIX.",
+            ErrorCode::MessageSize => "Message too large, similar to `EMSGSIZE` in POSIX.",
+            ErrorCode::NameTooLong => "Filename too long, similar to `ENAMETOOLONG` in POSIX.",
+            ErrorCode::NoDevice => "No such device, similar to `ENODEV` in POSIX.",
+            ErrorCode::NoEntry => "No such file or directory, similar to `ENOENT` in POSIX.",
+            ErrorCode::NoLock => "No locks available, similar to `ENOLCK` in POSIX.",
+            ErrorCode::InsufficientMemory => "Not enough space, similar to `ENOMEM` in POSIX.",
+            ErrorCode::InsufficientSpace => "No space left on device, similar to `ENOSPC` in POSIX.",
+            ErrorCode::NotDirectory => "Not a directory or a symbolic link to a directory, similar to `ENOTDIR` in POSIX.",
+            ErrorCode::NotEmpty => "Directory not empty, similar to `ENOTEMPTY` in POSIX.",
+            ErrorCode::NotRecoverable => "State not recoverable, similar to `ENOTRECOVERABLE` in POSIX.",
+            ErrorCode::Unsupported => "Not supported, similar to `ENOTSUP` and `ENOSYS` in POSIX.",
+            ErrorCode::NoTty => "Inappropriate I/O control operation, similar to `ENOTTY` in POSIX.",
+            ErrorCode::NoSuchDevice => "No such device or address, similar to `ENXIO` in POSIX.",
+            ErrorCode::Overflow => "Value too large to be stored in data type, similar to `EOVERFLOW` in POSIX.",
+            ErrorCode::NotPermitted => "Operation not permitted, similar to `EPERM` in POSIX.",
+            ErrorCode::Pipe => "Broken pipe, similar to `EPIPE` in POSIX.",
+            ErrorCode::ReadOnly => "Read-only file system, similar to `EROFS` in POSIX.",
+            ErrorCode::InvalidSeek => "Invalid seek, similar to `ESPIPE` in POSIX.",
+            ErrorCode::TextFileBusy => "Text file busy, similar to `ETXTBSY` in POSIX.",
+            ErrorCode::CrossDevice => "Cross-device link, similar to `EXDEV` in POSIX.",
+          }
+        }
+      }
+      impl ::core::fmt::Debug for ErrorCode{
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+          f.debug_struct("ErrorCode")
+          .field("code", &(*self as i32))
+          .field("name", &self.name())
+          .field("message", &self.message())
+          .finish()
+        }
+      }
+      impl ::core::fmt::Display for ErrorCode{
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+          write!(f, "{} (error {})", self.name(), *self as i32)
+        }
+      }
+      
+      impl std::error::Error for ErrorCode{}
+      
+      impl ErrorCode{
+        pub(crate) unsafe fn _lift(val: u8) -> ErrorCode{
+          if !cfg!(debug_assertions) {
+            return ::core::mem::transmute(val);
+          }
+          
+          match val {
+            0 => ErrorCode::Access,
+            1 => ErrorCode::WouldBlock,
+            2 => ErrorCode::Already,
+            3 => ErrorCode::BadDescriptor,
+            4 => ErrorCode::Busy,
+            5 => ErrorCode::Deadlock,
+            6 => ErrorCode::Quota,
+            7 => ErrorCode::Exist,
+            8 => ErrorCode::FileTooLarge,
+            9 => ErrorCode::IllegalByteSequence,
+            10 => ErrorCode::InProgress,
+            11 => ErrorCode::Interrupted,
+            12 => ErrorCode::Invalid,
+            13 => ErrorCode::Io,
+            14 => ErrorCode::IsDirectory,
+            15 => ErrorCode::Loop,
+            16 => ErrorCode::TooManyLinks,
+            17 => ErrorCode::MessageSize,
+            18 => ErrorCode::NameTooLong,
+            19 => ErrorCode::NoDevice,
+            20 => ErrorCode::NoEntry,
+            21 => ErrorCode::NoLock,
+            22 => ErrorCode::InsufficientMemory,
+            23 => ErrorCode::InsufficientSpace,
+            24 => ErrorCode::NotDirectory,
+            25 => ErrorCode::NotEmpty,
+            26 => ErrorCode::NotRecoverable,
+            27 => ErrorCode::Unsupported,
+            28 => ErrorCode::NoTty,
+            29 => ErrorCode::NoSuchDevice,
+            30 => ErrorCode::Overflow,
+            31 => ErrorCode::NotPermitted,
+            32 => ErrorCode::Pipe,
+            33 => ErrorCode::ReadOnly,
+            34 => ErrorCode::InvalidSeek,
+            35 => ErrorCode::TextFileBusy,
+            36 => ErrorCode::CrossDevice,
+            
+            _ => panic!("invalid enum discriminant"),
+          }
+        }
+      }
+      
+      /// File or memory access pattern advisory information.
+      #[repr(u8)]
+      #[derive(Clone, Copy, Eq, PartialEq)]
+      pub enum Advice {
+        /// The application has no advice to give on its behavior with respect
+        /// to the specified data.
+        Normal,
+        /// The application expects to access the specified data sequentially
+        /// from lower offsets to higher offsets.
+        Sequential,
+        /// The application expects to access the specified data in a random
+        /// order.
+        Random,
+        /// The application expects to access the specified data in the near
+        /// future.
+        WillNeed,
+        /// The application expects that it will not access the specified data
+        /// in the near future.
+        DontNeed,
+        /// The application expects to access the specified data once and then
+        /// not reuse it thereafter.
+        NoReuse,
+      }
+      impl ::core::fmt::Debug for Advice {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+          match self {
+            Advice::Normal => {
+              f.debug_tuple("Advice::Normal").finish()
+            }
+            Advice::Sequential => {
+              f.debug_tuple("Advice::Sequential").finish()
+            }
+            Advice::Random => {
+              f.debug_tuple("Advice::Random").finish()
+            }
+            Advice::WillNeed => {
+              f.debug_tuple("Advice::WillNeed").finish()
+            }
+            Advice::DontNeed => {
+              f.debug_tuple("Advice::DontNeed").finish()
+            }
+            Advice::NoReuse => {
+              f.debug_tuple("Advice::NoReuse").finish()
+            }
+          }
+        }
+      }
+      
+      impl Advice{
+        pub(crate) unsafe fn _lift(val: u8) -> Advice{
+          if !cfg!(debug_assertions) {
+            return ::core::mem::transmute(val);
+          }
+          
+          match val {
+            0 => Advice::Normal,
+            1 => Advice::Sequential,
+            2 => Advice::Random,
+            3 => Advice::WillNeed,
+            4 => Advice::DontNeed,
+            5 => Advice::NoReuse,
+            
+            _ => panic!("invalid enum discriminant"),
+          }
+        }
+      }
+      
+      /// A 128-bit hash value, split into parts because wasm doesn't have a
+      /// 128-bit integer type.
+      #[repr(C)]
+      #[derive(Clone, Copy)]
+      pub struct MetadataHashValue {
+        /// 64 bits of a 128-bit hash value.
+        pub lower: u64,
+        /// Another 64 bits of a 128-bit hash value.
+        pub upper: u64,
+      }
+      impl ::core::fmt::Debug for MetadataHashValue {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+          f.debug_struct("MetadataHashValue").field("lower", &self.lower).field("upper", &self.upper).finish()
+        }
+      }
+      /// A descriptor is a reference to a filesystem object, which may be a file,
+      /// directory, named pipe, special file, or other object on which filesystem
+      /// calls may be made.
+      
+      #[derive(Debug)]
+      #[repr(transparent)]
+      pub struct Descriptor{
+        handle: wit_bindgen::rt::Resource<Descriptor>,
+      }
+      
+      impl Descriptor{
+        #[doc(hidden)]
+        pub unsafe fn from_handle(handle: u32) -> Self {
+          Self {
+            handle: wit_bindgen::rt::Resource::from_handle(handle),
+          }
+        }
+        
+        #[doc(hidden)]
+        pub fn into_handle(self) -> u32 {
+          wit_bindgen::rt::Resource::into_handle(self.handle)
+        }
+        
+        #[doc(hidden)]
+        pub fn handle(&self) -> u32 {
+          wit_bindgen::rt::Resource::handle(&self.handle)
+        }
+      }
+      
+      
+      unsafe impl wit_bindgen::rt::WasmResource for Descriptor{
+        #[inline]
+        unsafe fn drop(_handle: u32) {
+          #[cfg(not(target_arch = "wasm32"))]
+          unreachable!();
+          
+          #[cfg(target_arch = "wasm32")]
+          {
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[resource-drop]descriptor"]
+              fn drop(_: u32);
+            }
+            
+            drop(_handle);
+          }
+        }
+      }
+      
+      /// A stream of directory entries.
+      
+      #[derive(Debug)]
+      #[repr(transparent)]
+      pub struct DirectoryEntryStream{
+        handle: wit_bindgen::rt::Resource<DirectoryEntryStream>,
+      }
+      
+      impl DirectoryEntryStream{
+        #[doc(hidden)]
+        pub unsafe fn from_handle(handle: u32) -> Self {
+          Self {
+            handle: wit_bindgen::rt::Resource::from_handle(handle),
+          }
+        }
+        
+        #[doc(hidden)]
+        pub fn into_handle(self) -> u32 {
+          wit_bindgen::rt::Resource::into_handle(self.handle)
+        }
+        
+        #[doc(hidden)]
+        pub fn handle(&self) -> u32 {
+          wit_bindgen::rt::Resource::handle(&self.handle)
+        }
+      }
+      
+      
+      unsafe impl wit_bindgen::rt::WasmResource for DirectoryEntryStream{
+        #[inline]
+        unsafe fn drop(_handle: u32) {
+          #[cfg(not(target_arch = "wasm32"))]
+          unreachable!();
+          
+          #[cfg(target_arch = "wasm32")]
+          {
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[resource-drop]directory-entry-stream"]
+              fn drop(_: u32);
+            }
+            
+            drop(_handle);
+          }
+        }
+      }
+      
+      impl Descriptor {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Return a stream for reading from a file, if available.
+        /// 
+        /// May fail with an error-code describing why the file cannot be read.
+        /// 
+        /// Multiple read, write, and append streams may be active on the same open
+        /// file and they do not interfere with each other.
+        /// 
+        /// Note: This allows using `read-stream`, which is similar to `read` in POSIX.
+        pub fn read_via_stream(&self,offset: Filesize,) -> Result<InputStream,ErrorCode>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(4))]
+            struct RetArea([u8; 8]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let ptr0 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]descriptor.read-via-stream"]
+              fn wit_import(_: i32, _: i64, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i64, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, wit_bindgen::rt::as_i64(offset), ptr0);
+            let l1 = i32::from(*((ptr0 + 0) as *const u8));
+            match l1 {
+              0 => {
+                let e = {
+                  let l2 = *((ptr0 + 4) as *const i32);
+                  
+                  super::super::super::wasi::io::streams::InputStream::from_handle(l2 as u32)
+                };
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l3 = i32::from(*((ptr0 + 4) as *const u8));
+                  
+                  ErrorCode::_lift(l3 as u8)
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl Descriptor {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Return a stream for writing to a file, if available.
+        /// 
+        /// May fail with an error-code describing why the file cannot be written.
+        /// 
+        /// Note: This allows using `write-stream`, which is similar to `write` in
+        /// POSIX.
+        pub fn write_via_stream(&self,offset: Filesize,) -> Result<OutputStream,ErrorCode>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(4))]
+            struct RetArea([u8; 8]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let ptr0 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]descriptor.write-via-stream"]
+              fn wit_import(_: i32, _: i64, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i64, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, wit_bindgen::rt::as_i64(offset), ptr0);
+            let l1 = i32::from(*((ptr0 + 0) as *const u8));
+            match l1 {
+              0 => {
+                let e = {
+                  let l2 = *((ptr0 + 4) as *const i32);
+                  
+                  super::super::super::wasi::io::streams::OutputStream::from_handle(l2 as u32)
+                };
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l3 = i32::from(*((ptr0 + 4) as *const u8));
+                  
+                  ErrorCode::_lift(l3 as u8)
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl Descriptor {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Return a stream for appending to a file, if available.
+        /// 
+        /// May fail with an error-code describing why the file cannot be appended.
+        /// 
+        /// Note: This allows using `write-stream`, which is similar to `write` with
+        /// `O_APPEND` in in POSIX.
+        pub fn append_via_stream(&self,) -> Result<OutputStream,ErrorCode>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(4))]
+            struct RetArea([u8; 8]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let ptr0 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]descriptor.append-via-stream"]
+              fn wit_import(_: i32, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, ptr0);
+            let l1 = i32::from(*((ptr0 + 0) as *const u8));
+            match l1 {
+              0 => {
+                let e = {
+                  let l2 = *((ptr0 + 4) as *const i32);
+                  
+                  super::super::super::wasi::io::streams::OutputStream::from_handle(l2 as u32)
+                };
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l3 = i32::from(*((ptr0 + 4) as *const u8));
+                  
+                  ErrorCode::_lift(l3 as u8)
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl Descriptor {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Provide file advisory information on a descriptor.
+        /// 
+        /// This is similar to `posix_fadvise` in POSIX.
+        pub fn advise(&self,offset: Filesize,length: Filesize,advice: Advice,) -> Result<(),ErrorCode>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(1))]
+            struct RetArea([u8; 2]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let ptr0 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]descriptor.advise"]
+              fn wit_import(_: i32, _: i64, _: i64, _: i32, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i64, _: i64, _: i32, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, wit_bindgen::rt::as_i64(offset), wit_bindgen::rt::as_i64(length), advice.clone() as i32, ptr0);
+            let l1 = i32::from(*((ptr0 + 0) as *const u8));
+            match l1 {
+              0 => {
+                let e = ();
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l2 = i32::from(*((ptr0 + 1) as *const u8));
+                  
+                  ErrorCode::_lift(l2 as u8)
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl Descriptor {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Synchronize the data of a file to disk.
+        /// 
+        /// This function succeeds with no effect if the file descriptor is not
+        /// opened for writing.
+        /// 
+        /// Note: This is similar to `fdatasync` in POSIX.
+        pub fn sync_data(&self,) -> Result<(),ErrorCode>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(1))]
+            struct RetArea([u8; 2]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let ptr0 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]descriptor.sync-data"]
+              fn wit_import(_: i32, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, ptr0);
+            let l1 = i32::from(*((ptr0 + 0) as *const u8));
+            match l1 {
+              0 => {
+                let e = ();
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l2 = i32::from(*((ptr0 + 1) as *const u8));
+                  
+                  ErrorCode::_lift(l2 as u8)
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl Descriptor {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Get flags associated with a descriptor.
+        /// 
+        /// Note: This returns similar flags to `fcntl(fd, F_GETFL)` in POSIX.
+        /// 
+        /// Note: This returns the value that was the `fs_flags` value returned
+        /// from `fdstat_get` in earlier versions of WASI.
+        pub fn get_flags(&self,) -> Result<DescriptorFlags,ErrorCode>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(1))]
+            struct RetArea([u8; 2]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let ptr0 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]descriptor.get-flags"]
+              fn wit_import(_: i32, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, ptr0);
+            let l1 = i32::from(*((ptr0 + 0) as *const u8));
+            match l1 {
+              0 => {
+                let e = {
+                  let l2 = i32::from(*((ptr0 + 1) as *const u8));
+                  
+                  DescriptorFlags::empty() | DescriptorFlags::from_bits_retain(((l2 as u8) << 0) as _)
+                };
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l3 = i32::from(*((ptr0 + 1) as *const u8));
+                  
+                  ErrorCode::_lift(l3 as u8)
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl Descriptor {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Get the dynamic type of a descriptor.
+        /// 
+        /// Note: This returns the same value as the `type` field of the `fd-stat`
+        /// returned by `stat`, `stat-at` and similar.
+        /// 
+        /// Note: This returns similar flags to the `st_mode & S_IFMT` value provided
+        /// by `fstat` in POSIX.
+        /// 
+        /// Note: This returns the value that was the `fs_filetype` value returned
+        /// from `fdstat_get` in earlier versions of WASI.
+        pub fn get_type(&self,) -> Result<DescriptorType,ErrorCode>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(1))]
+            struct RetArea([u8; 2]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let ptr0 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]descriptor.get-type"]
+              fn wit_import(_: i32, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, ptr0);
+            let l1 = i32::from(*((ptr0 + 0) as *const u8));
+            match l1 {
+              0 => {
+                let e = {
+                  let l2 = i32::from(*((ptr0 + 1) as *const u8));
+                  
+                  DescriptorType::_lift(l2 as u8)
+                };
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l3 = i32::from(*((ptr0 + 1) as *const u8));
+                  
+                  ErrorCode::_lift(l3 as u8)
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl Descriptor {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Adjust the size of an open file. If this increases the file's size, the
+        /// extra bytes are filled with zeros.
+        /// 
+        /// Note: This was called `fd_filestat_set_size` in earlier versions of WASI.
+        pub fn set_size(&self,size: Filesize,) -> Result<(),ErrorCode>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(1))]
+            struct RetArea([u8; 2]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let ptr0 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]descriptor.set-size"]
+              fn wit_import(_: i32, _: i64, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i64, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, wit_bindgen::rt::as_i64(size), ptr0);
+            let l1 = i32::from(*((ptr0 + 0) as *const u8));
+            match l1 {
+              0 => {
+                let e = ();
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l2 = i32::from(*((ptr0 + 1) as *const u8));
+                  
+                  ErrorCode::_lift(l2 as u8)
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl Descriptor {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Adjust the timestamps of an open file or directory.
+        /// 
+        /// Note: This is similar to `futimens` in POSIX.
+        /// 
+        /// Note: This was called `fd_filestat_set_times` in earlier versions of WASI.
+        pub fn set_times(&self,data_access_timestamp: NewTimestamp,data_modification_timestamp: NewTimestamp,) -> Result<(),ErrorCode>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(1))]
+            struct RetArea([u8; 2]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let (result1_0,result1_1,result1_2,) = match data_access_timestamp {
+              NewTimestamp::NoChange=> {
+                (0i32, 0i64, 0i32)
+              }
+              NewTimestamp::Now=> {
+                (1i32, 0i64, 0i32)
+              }
+              NewTimestamp::Timestamp(e) => {
+                let super::super::super::wasi::clocks::wall_clock::Datetime{ seconds:seconds0, nanoseconds:nanoseconds0, } = e;
+                
+                (2i32, wit_bindgen::rt::as_i64(seconds0), wit_bindgen::rt::as_i32(nanoseconds0))
+              },
+            };
+            let (result3_0,result3_1,result3_2,) = match data_modification_timestamp {
+              NewTimestamp::NoChange=> {
+                (0i32, 0i64, 0i32)
+              }
+              NewTimestamp::Now=> {
+                (1i32, 0i64, 0i32)
+              }
+              NewTimestamp::Timestamp(e) => {
+                let super::super::super::wasi::clocks::wall_clock::Datetime{ seconds:seconds2, nanoseconds:nanoseconds2, } = e;
+                
+                (2i32, wit_bindgen::rt::as_i64(seconds2), wit_bindgen::rt::as_i32(nanoseconds2))
+              },
+            };
+            let ptr4 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]descriptor.set-times"]
+              fn wit_import(_: i32, _: i32, _: i64, _: i32, _: i32, _: i64, _: i32, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i32, _: i64, _: i32, _: i32, _: i64, _: i32, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, result1_0, result1_1, result1_2, result3_0, result3_1, result3_2, ptr4);
+            let l5 = i32::from(*((ptr4 + 0) as *const u8));
+            match l5 {
+              0 => {
+                let e = ();
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l6 = i32::from(*((ptr4 + 1) as *const u8));
+                  
+                  ErrorCode::_lift(l6 as u8)
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl Descriptor {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Read from a descriptor, without using and updating the descriptor's offset.
+        /// 
+        /// This function returns a list of bytes containing the data that was
+        /// read, along with a bool which, when true, indicates that the end of the
+        /// file was reached. The returned list will contain up to `length` bytes; it
+        /// may return fewer than requested, if the end of the file is reached or
+        /// if the I/O operation is interrupted.
+        /// 
+        /// In the future, this may change to return a `stream<u8, error-code>`.
+        /// 
+        /// Note: This is similar to `pread` in POSIX.
+        pub fn read(&self,length: Filesize,offset: Filesize,) -> Result<(wit_bindgen::rt::vec::Vec::<u8>,bool,),ErrorCode>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(4))]
+            struct RetArea([u8; 16]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let ptr0 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]descriptor.read"]
+              fn wit_import(_: i32, _: i64, _: i64, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i64, _: i64, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, wit_bindgen::rt::as_i64(length), wit_bindgen::rt::as_i64(offset), ptr0);
+            let l1 = i32::from(*((ptr0 + 0) as *const u8));
+            match l1 {
+              0 => {
+                let e = {
+                  let l2 = *((ptr0 + 4) as *const i32);
+                  let l3 = *((ptr0 + 8) as *const i32);
+                  let len4 = l3 as usize;
+                  let l5 = i32::from(*((ptr0 + 12) as *const u8));
+                  
+                  (Vec::from_raw_parts(l2 as *mut _, len4, len4), wit_bindgen::rt::bool_lift(l5 as u8))
+                };
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l6 = i32::from(*((ptr0 + 4) as *const u8));
+                  
+                  ErrorCode::_lift(l6 as u8)
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl Descriptor {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Write to a descriptor, without using and updating the descriptor's offset.
+        /// 
+        /// It is valid to write past the end of a file; the file is extended to the
+        /// extent of the write, with bytes between the previous end and the start of
+        /// the write set to zero.
+        /// 
+        /// In the future, this may change to take a `stream<u8, error-code>`.
+        /// 
+        /// Note: This is similar to `pwrite` in POSIX.
+        pub fn write(&self,buffer: &[u8],offset: Filesize,) -> Result<Filesize,ErrorCode>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(8))]
+            struct RetArea([u8; 16]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let vec0 = buffer;
+            let ptr0 = vec0.as_ptr() as i32;
+            let len0 = vec0.len() as i32;
+            let ptr1 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]descriptor.write"]
+              fn wit_import(_: i32, _: i32, _: i32, _: i64, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i32, _: i32, _: i64, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, ptr0, len0, wit_bindgen::rt::as_i64(offset), ptr1);
+            let l2 = i32::from(*((ptr1 + 0) as *const u8));
+            match l2 {
+              0 => {
+                let e = {
+                  let l3 = *((ptr1 + 8) as *const i64);
+                  
+                  l3 as u64
+                };
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l4 = i32::from(*((ptr1 + 8) as *const u8));
+                  
+                  ErrorCode::_lift(l4 as u8)
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl Descriptor {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Read directory entries from a directory.
+        /// 
+        /// On filesystems where directories contain entries referring to themselves
+        /// and their parents, often named `.` and `..` respectively, these entries
+        /// are omitted.
+        /// 
+        /// This always returns a new stream which starts at the beginning of the
+        /// directory. Multiple streams may be active on the same directory, and they
+        /// do not interfere with each other.
+        pub fn read_directory(&self,) -> Result<DirectoryEntryStream,ErrorCode>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(4))]
+            struct RetArea([u8; 8]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let ptr0 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]descriptor.read-directory"]
+              fn wit_import(_: i32, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, ptr0);
+            let l1 = i32::from(*((ptr0 + 0) as *const u8));
+            match l1 {
+              0 => {
+                let e = {
+                  let l2 = *((ptr0 + 4) as *const i32);
+                  
+                  DirectoryEntryStream::from_handle(l2 as u32)
+                };
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l3 = i32::from(*((ptr0 + 4) as *const u8));
+                  
+                  ErrorCode::_lift(l3 as u8)
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl Descriptor {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Synchronize the data and metadata of a file to disk.
+        /// 
+        /// This function succeeds with no effect if the file descriptor is not
+        /// opened for writing.
+        /// 
+        /// Note: This is similar to `fsync` in POSIX.
+        pub fn sync(&self,) -> Result<(),ErrorCode>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(1))]
+            struct RetArea([u8; 2]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let ptr0 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]descriptor.sync"]
+              fn wit_import(_: i32, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, ptr0);
+            let l1 = i32::from(*((ptr0 + 0) as *const u8));
+            match l1 {
+              0 => {
+                let e = ();
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l2 = i32::from(*((ptr0 + 1) as *const u8));
+                  
+                  ErrorCode::_lift(l2 as u8)
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl Descriptor {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Create a directory.
+        /// 
+        /// Note: This is similar to `mkdirat` in POSIX.
+        pub fn create_directory_at(&self,path: &str,) -> Result<(),ErrorCode>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(1))]
+            struct RetArea([u8; 2]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let vec0 = path;
+            let ptr0 = vec0.as_ptr() as i32;
+            let len0 = vec0.len() as i32;
+            let ptr1 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]descriptor.create-directory-at"]
+              fn wit_import(_: i32, _: i32, _: i32, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i32, _: i32, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, ptr0, len0, ptr1);
+            let l2 = i32::from(*((ptr1 + 0) as *const u8));
+            match l2 {
+              0 => {
+                let e = ();
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l3 = i32::from(*((ptr1 + 1) as *const u8));
+                  
+                  ErrorCode::_lift(l3 as u8)
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl Descriptor {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Return the attributes of an open file or directory.
+        /// 
+        /// Note: This is similar to `fstat` in POSIX, except that it does not return
+        /// device and inode information. For testing whether two descriptors refer to
+        /// the same underlying filesystem object, use `is-same-object`. To obtain
+        /// additional data that can be used do determine whether a file has been
+        /// modified, use `metadata-hash`.
+        /// 
+        /// Note: This was called `fd_filestat_get` in earlier versions of WASI.
+        pub fn stat(&self,) -> Result<DescriptorStat,ErrorCode>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(8))]
+            struct RetArea([u8; 104]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let ptr0 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]descriptor.stat"]
+              fn wit_import(_: i32, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, ptr0);
+            let l1 = i32::from(*((ptr0 + 0) as *const u8));
+            match l1 {
+              0 => {
+                let e = {
+                  let l2 = i32::from(*((ptr0 + 8) as *const u8));
+                  let l3 = *((ptr0 + 16) as *const i64);
+                  let l4 = *((ptr0 + 24) as *const i64);
+                  let l5 = i32::from(*((ptr0 + 32) as *const u8));
+                  let l8 = i32::from(*((ptr0 + 56) as *const u8));
+                  let l11 = i32::from(*((ptr0 + 80) as *const u8));
+                  
+                  DescriptorStat{
+                    type_: DescriptorType::_lift(l2 as u8),
+                    link_count: l3 as u64,
+                    size: l4 as u64,
+                    data_access_timestamp: match l5 {
+                      0 => None,
+                      1 => {
+                        let e = {
+                          let l6 = *((ptr0 + 40) as *const i64);
+                          let l7 = *((ptr0 + 48) as *const i32);
+                          
+                          super::super::super::wasi::clocks::wall_clock::Datetime{
+                            seconds: l6 as u64,
+                            nanoseconds: l7 as u32,
+                          }
+                        };
+                        Some(e)
+                      }
+                      _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                    },
+                    data_modification_timestamp: match l8 {
+                      0 => None,
+                      1 => {
+                        let e = {
+                          let l9 = *((ptr0 + 64) as *const i64);
+                          let l10 = *((ptr0 + 72) as *const i32);
+                          
+                          super::super::super::wasi::clocks::wall_clock::Datetime{
+                            seconds: l9 as u64,
+                            nanoseconds: l10 as u32,
+                          }
+                        };
+                        Some(e)
+                      }
+                      _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                    },
+                    status_change_timestamp: match l11 {
+                      0 => None,
+                      1 => {
+                        let e = {
+                          let l12 = *((ptr0 + 88) as *const i64);
+                          let l13 = *((ptr0 + 96) as *const i32);
+                          
+                          super::super::super::wasi::clocks::wall_clock::Datetime{
+                            seconds: l12 as u64,
+                            nanoseconds: l13 as u32,
+                          }
+                        };
+                        Some(e)
+                      }
+                      _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                    },
+                  }
+                };
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l14 = i32::from(*((ptr0 + 8) as *const u8));
+                  
+                  ErrorCode::_lift(l14 as u8)
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl Descriptor {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Return the attributes of a file or directory.
+        /// 
+        /// Note: This is similar to `fstatat` in POSIX, except that it does not
+        /// return device and inode information. See the `stat` description for a
+        /// discussion of alternatives.
+        /// 
+        /// Note: This was called `path_filestat_get` in earlier versions of WASI.
+        pub fn stat_at(&self,path_flags: PathFlags,path: &str,) -> Result<DescriptorStat,ErrorCode>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(8))]
+            struct RetArea([u8; 104]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let flags0 = path_flags;
+            let vec1 = path;
+            let ptr1 = vec1.as_ptr() as i32;
+            let len1 = vec1.len() as i32;
+            let ptr2 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]descriptor.stat-at"]
+              fn wit_import(_: i32, _: i32, _: i32, _: i32, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i32, _: i32, _: i32, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, (flags0.bits() >> 0) as i32, ptr1, len1, ptr2);
+            let l3 = i32::from(*((ptr2 + 0) as *const u8));
+            match l3 {
+              0 => {
+                let e = {
+                  let l4 = i32::from(*((ptr2 + 8) as *const u8));
+                  let l5 = *((ptr2 + 16) as *const i64);
+                  let l6 = *((ptr2 + 24) as *const i64);
+                  let l7 = i32::from(*((ptr2 + 32) as *const u8));
+                  let l10 = i32::from(*((ptr2 + 56) as *const u8));
+                  let l13 = i32::from(*((ptr2 + 80) as *const u8));
+                  
+                  DescriptorStat{
+                    type_: DescriptorType::_lift(l4 as u8),
+                    link_count: l5 as u64,
+                    size: l6 as u64,
+                    data_access_timestamp: match l7 {
+                      0 => None,
+                      1 => {
+                        let e = {
+                          let l8 = *((ptr2 + 40) as *const i64);
+                          let l9 = *((ptr2 + 48) as *const i32);
+                          
+                          super::super::super::wasi::clocks::wall_clock::Datetime{
+                            seconds: l8 as u64,
+                            nanoseconds: l9 as u32,
+                          }
+                        };
+                        Some(e)
+                      }
+                      _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                    },
+                    data_modification_timestamp: match l10 {
+                      0 => None,
+                      1 => {
+                        let e = {
+                          let l11 = *((ptr2 + 64) as *const i64);
+                          let l12 = *((ptr2 + 72) as *const i32);
+                          
+                          super::super::super::wasi::clocks::wall_clock::Datetime{
+                            seconds: l11 as u64,
+                            nanoseconds: l12 as u32,
+                          }
+                        };
+                        Some(e)
+                      }
+                      _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                    },
+                    status_change_timestamp: match l13 {
+                      0 => None,
+                      1 => {
+                        let e = {
+                          let l14 = *((ptr2 + 88) as *const i64);
+                          let l15 = *((ptr2 + 96) as *const i32);
+                          
+                          super::super::super::wasi::clocks::wall_clock::Datetime{
+                            seconds: l14 as u64,
+                            nanoseconds: l15 as u32,
+                          }
+                        };
+                        Some(e)
+                      }
+                      _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                    },
+                  }
+                };
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l16 = i32::from(*((ptr2 + 8) as *const u8));
+                  
+                  ErrorCode::_lift(l16 as u8)
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl Descriptor {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Adjust the timestamps of a file or directory.
+        /// 
+        /// Note: This is similar to `utimensat` in POSIX.
+        /// 
+        /// Note: This was called `path_filestat_set_times` in earlier versions of
+        /// WASI.
+        pub fn set_times_at(&self,path_flags: PathFlags,path: &str,data_access_timestamp: NewTimestamp,data_modification_timestamp: NewTimestamp,) -> Result<(),ErrorCode>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(1))]
+            struct RetArea([u8; 2]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let flags0 = path_flags;
+            let vec1 = path;
+            let ptr1 = vec1.as_ptr() as i32;
+            let len1 = vec1.len() as i32;
+            let (result3_0,result3_1,result3_2,) = match data_access_timestamp {
+              NewTimestamp::NoChange=> {
+                (0i32, 0i64, 0i32)
+              }
+              NewTimestamp::Now=> {
+                (1i32, 0i64, 0i32)
+              }
+              NewTimestamp::Timestamp(e) => {
+                let super::super::super::wasi::clocks::wall_clock::Datetime{ seconds:seconds2, nanoseconds:nanoseconds2, } = e;
+                
+                (2i32, wit_bindgen::rt::as_i64(seconds2), wit_bindgen::rt::as_i32(nanoseconds2))
+              },
+            };
+            let (result5_0,result5_1,result5_2,) = match data_modification_timestamp {
+              NewTimestamp::NoChange=> {
+                (0i32, 0i64, 0i32)
+              }
+              NewTimestamp::Now=> {
+                (1i32, 0i64, 0i32)
+              }
+              NewTimestamp::Timestamp(e) => {
+                let super::super::super::wasi::clocks::wall_clock::Datetime{ seconds:seconds4, nanoseconds:nanoseconds4, } = e;
+                
+                (2i32, wit_bindgen::rt::as_i64(seconds4), wit_bindgen::rt::as_i32(nanoseconds4))
+              },
+            };
+            let ptr6 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]descriptor.set-times-at"]
+              fn wit_import(_: i32, _: i32, _: i32, _: i32, _: i32, _: i64, _: i32, _: i32, _: i64, _: i32, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i32, _: i32, _: i32, _: i32, _: i64, _: i32, _: i32, _: i64, _: i32, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, (flags0.bits() >> 0) as i32, ptr1, len1, result3_0, result3_1, result3_2, result5_0, result5_1, result5_2, ptr6);
+            let l7 = i32::from(*((ptr6 + 0) as *const u8));
+            match l7 {
+              0 => {
+                let e = ();
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l8 = i32::from(*((ptr6 + 1) as *const u8));
+                  
+                  ErrorCode::_lift(l8 as u8)
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl Descriptor {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Create a hard link.
+        /// 
+        /// Note: This is similar to `linkat` in POSIX.
+        pub fn link_at(&self,old_path_flags: PathFlags,old_path: &str,new_descriptor: &Descriptor,new_path: &str,) -> Result<(),ErrorCode>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(1))]
+            struct RetArea([u8; 2]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let flags0 = old_path_flags;
+            let vec1 = old_path;
+            let ptr1 = vec1.as_ptr() as i32;
+            let len1 = vec1.len() as i32;
+            let vec2 = new_path;
+            let ptr2 = vec2.as_ptr() as i32;
+            let len2 = vec2.len() as i32;
+            let ptr3 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]descriptor.link-at"]
+              fn wit_import(_: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, (flags0.bits() >> 0) as i32, ptr1, len1, (new_descriptor).handle() as i32, ptr2, len2, ptr3);
+            let l4 = i32::from(*((ptr3 + 0) as *const u8));
+            match l4 {
+              0 => {
+                let e = ();
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l5 = i32::from(*((ptr3 + 1) as *const u8));
+                  
+                  ErrorCode::_lift(l5 as u8)
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl Descriptor {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Open a file or directory.
+        /// 
+        /// The returned descriptor is not guaranteed to be the lowest-numbered
+        /// descriptor not currently open/ it is randomized to prevent applications
+        /// from depending on making assumptions about indexes, since this is
+        /// error-prone in multi-threaded contexts. The returned descriptor is
+        /// guaranteed to be less than 2**31.
+        /// 
+        /// If `flags` contains `descriptor-flags::mutate-directory`, and the base
+        /// descriptor doesn't have `descriptor-flags::mutate-directory` set,
+        /// `open-at` fails with `error-code::read-only`.
+        /// 
+        /// If `flags` contains `write` or `mutate-directory`, or `open-flags`
+        /// contains `truncate` or `create`, and the base descriptor doesn't have
+        /// `descriptor-flags::mutate-directory` set, `open-at` fails with
+        /// `error-code::read-only`.
+        /// 
+        /// Note: This is similar to `openat` in POSIX.
+        pub fn open_at(&self,path_flags: PathFlags,path: &str,open_flags: OpenFlags,flags: DescriptorFlags,) -> Result<Descriptor,ErrorCode>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(4))]
+            struct RetArea([u8; 8]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let flags0 = path_flags;
+            let vec1 = path;
+            let ptr1 = vec1.as_ptr() as i32;
+            let len1 = vec1.len() as i32;
+            let flags2 = open_flags;
+            let flags3 = flags;
+            let ptr4 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]descriptor.open-at"]
+              fn wit_import(_: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, (flags0.bits() >> 0) as i32, ptr1, len1, (flags2.bits() >> 0) as i32, (flags3.bits() >> 0) as i32, ptr4);
+            let l5 = i32::from(*((ptr4 + 0) as *const u8));
+            match l5 {
+              0 => {
+                let e = {
+                  let l6 = *((ptr4 + 4) as *const i32);
+                  
+                  Descriptor::from_handle(l6 as u32)
+                };
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l7 = i32::from(*((ptr4 + 4) as *const u8));
+                  
+                  ErrorCode::_lift(l7 as u8)
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl Descriptor {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Read the contents of a symbolic link.
+        /// 
+        /// If the contents contain an absolute or rooted path in the underlying
+        /// filesystem, this function fails with `error-code::not-permitted`.
+        /// 
+        /// Note: This is similar to `readlinkat` in POSIX.
+        pub fn readlink_at(&self,path: &str,) -> Result<wit_bindgen::rt::string::String,ErrorCode>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(4))]
+            struct RetArea([u8; 12]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let vec0 = path;
+            let ptr0 = vec0.as_ptr() as i32;
+            let len0 = vec0.len() as i32;
+            let ptr1 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]descriptor.readlink-at"]
+              fn wit_import(_: i32, _: i32, _: i32, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i32, _: i32, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, ptr0, len0, ptr1);
+            let l2 = i32::from(*((ptr1 + 0) as *const u8));
+            match l2 {
+              0 => {
+                let e = {
+                  let l3 = *((ptr1 + 4) as *const i32);
+                  let l4 = *((ptr1 + 8) as *const i32);
+                  let len5 = l4 as usize;
+                  let bytes5 = Vec::from_raw_parts(l3 as *mut _, len5, len5);
+                  
+                  wit_bindgen::rt::string_lift(bytes5)
+                };
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l6 = i32::from(*((ptr1 + 4) as *const u8));
+                  
+                  ErrorCode::_lift(l6 as u8)
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl Descriptor {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Remove a directory.
+        /// 
+        /// Return `error-code::not-empty` if the directory is not empty.
+        /// 
+        /// Note: This is similar to `unlinkat(fd, path, AT_REMOVEDIR)` in POSIX.
+        pub fn remove_directory_at(&self,path: &str,) -> Result<(),ErrorCode>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(1))]
+            struct RetArea([u8; 2]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let vec0 = path;
+            let ptr0 = vec0.as_ptr() as i32;
+            let len0 = vec0.len() as i32;
+            let ptr1 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]descriptor.remove-directory-at"]
+              fn wit_import(_: i32, _: i32, _: i32, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i32, _: i32, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, ptr0, len0, ptr1);
+            let l2 = i32::from(*((ptr1 + 0) as *const u8));
+            match l2 {
+              0 => {
+                let e = ();
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l3 = i32::from(*((ptr1 + 1) as *const u8));
+                  
+                  ErrorCode::_lift(l3 as u8)
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl Descriptor {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Rename a filesystem object.
+        /// 
+        /// Note: This is similar to `renameat` in POSIX.
+        pub fn rename_at(&self,old_path: &str,new_descriptor: &Descriptor,new_path: &str,) -> Result<(),ErrorCode>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(1))]
+            struct RetArea([u8; 2]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let vec0 = old_path;
+            let ptr0 = vec0.as_ptr() as i32;
+            let len0 = vec0.len() as i32;
+            let vec1 = new_path;
+            let ptr1 = vec1.as_ptr() as i32;
+            let len1 = vec1.len() as i32;
+            let ptr2 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]descriptor.rename-at"]
+              fn wit_import(_: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, ptr0, len0, (new_descriptor).handle() as i32, ptr1, len1, ptr2);
+            let l3 = i32::from(*((ptr2 + 0) as *const u8));
+            match l3 {
+              0 => {
+                let e = ();
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l4 = i32::from(*((ptr2 + 1) as *const u8));
+                  
+                  ErrorCode::_lift(l4 as u8)
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl Descriptor {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Create a symbolic link (also known as a "symlink").
+        /// 
+        /// If `old-path` starts with `/`, the function fails with
+        /// `error-code::not-permitted`.
+        /// 
+        /// Note: This is similar to `symlinkat` in POSIX.
+        pub fn symlink_at(&self,old_path: &str,new_path: &str,) -> Result<(),ErrorCode>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(1))]
+            struct RetArea([u8; 2]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let vec0 = old_path;
+            let ptr0 = vec0.as_ptr() as i32;
+            let len0 = vec0.len() as i32;
+            let vec1 = new_path;
+            let ptr1 = vec1.as_ptr() as i32;
+            let len1 = vec1.len() as i32;
+            let ptr2 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]descriptor.symlink-at"]
+              fn wit_import(_: i32, _: i32, _: i32, _: i32, _: i32, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i32, _: i32, _: i32, _: i32, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, ptr0, len0, ptr1, len1, ptr2);
+            let l3 = i32::from(*((ptr2 + 0) as *const u8));
+            match l3 {
+              0 => {
+                let e = ();
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l4 = i32::from(*((ptr2 + 1) as *const u8));
+                  
+                  ErrorCode::_lift(l4 as u8)
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl Descriptor {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Unlink a filesystem object that is not a directory.
+        /// 
+        /// Return `error-code::is-directory` if the path refers to a directory.
+        /// Note: This is similar to `unlinkat(fd, path, 0)` in POSIX.
+        pub fn unlink_file_at(&self,path: &str,) -> Result<(),ErrorCode>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(1))]
+            struct RetArea([u8; 2]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let vec0 = path;
+            let ptr0 = vec0.as_ptr() as i32;
+            let len0 = vec0.len() as i32;
+            let ptr1 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]descriptor.unlink-file-at"]
+              fn wit_import(_: i32, _: i32, _: i32, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i32, _: i32, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, ptr0, len0, ptr1);
+            let l2 = i32::from(*((ptr1 + 0) as *const u8));
+            match l2 {
+              0 => {
+                let e = ();
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l3 = i32::from(*((ptr1 + 1) as *const u8));
+                  
+                  ErrorCode::_lift(l3 as u8)
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl Descriptor {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Test whether two descriptors refer to the same filesystem object.
+        /// 
+        /// In POSIX, this corresponds to testing whether the two descriptors have the
+        /// same device (`st_dev`) and inode (`st_ino` or `d_ino`) numbers.
+        /// wasi-filesystem does not expose device and inode numbers, so this function
+        /// may be used instead.
+        pub fn is_same_object(&self,other: &Descriptor,) -> bool{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]descriptor.is-same-object"]
+              fn wit_import(_: i32, _: i32, ) -> i32;
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i32, ) -> i32{ unreachable!() }
+            let ret = wit_import((self).handle() as i32, (other).handle() as i32);
+            wit_bindgen::rt::bool_lift(ret as u8)
+          }
+        }
+      }
+      impl Descriptor {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Return a hash of the metadata associated with a filesystem object referred
+        /// to by a descriptor.
+        /// 
+        /// This returns a hash of the last-modification timestamp and file size, and
+        /// may also include the inode number, device number, birth timestamp, and
+        /// other metadata fields that may change when the file is modified or
+        /// replaced. It may also include a secret value chosen by the
+        /// implementation and not otherwise exposed.
+        /// 
+        /// Implementations are encourated to provide the following properties:
+        /// 
+        /// - If the file is not modified or replaced, the computed hash value should
+        /// usually not change.
+        /// - If the object is modified or replaced, the computed hash value should
+        /// usually change.
+        /// - The inputs to the hash should not be easily computable from the
+        /// computed hash.
+        /// 
+        /// However, none of these is required.
+        pub fn metadata_hash(&self,) -> Result<MetadataHashValue,ErrorCode>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(8))]
+            struct RetArea([u8; 24]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let ptr0 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]descriptor.metadata-hash"]
+              fn wit_import(_: i32, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, ptr0);
+            let l1 = i32::from(*((ptr0 + 0) as *const u8));
+            match l1 {
+              0 => {
+                let e = {
+                  let l2 = *((ptr0 + 8) as *const i64);
+                  let l3 = *((ptr0 + 16) as *const i64);
+                  
+                  MetadataHashValue{
+                    lower: l2 as u64,
+                    upper: l3 as u64,
+                  }
+                };
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l4 = i32::from(*((ptr0 + 8) as *const u8));
+                  
+                  ErrorCode::_lift(l4 as u8)
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl Descriptor {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Return a hash of the metadata associated with a filesystem object referred
+        /// to by a directory descriptor and a relative path.
+        /// 
+        /// This performs the same hash computation as `metadata-hash`.
+        pub fn metadata_hash_at(&self,path_flags: PathFlags,path: &str,) -> Result<MetadataHashValue,ErrorCode>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(8))]
+            struct RetArea([u8; 24]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let flags0 = path_flags;
+            let vec1 = path;
+            let ptr1 = vec1.as_ptr() as i32;
+            let len1 = vec1.len() as i32;
+            let ptr2 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]descriptor.metadata-hash-at"]
+              fn wit_import(_: i32, _: i32, _: i32, _: i32, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i32, _: i32, _: i32, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, (flags0.bits() >> 0) as i32, ptr1, len1, ptr2);
+            let l3 = i32::from(*((ptr2 + 0) as *const u8));
+            match l3 {
+              0 => {
+                let e = {
+                  let l4 = *((ptr2 + 8) as *const i64);
+                  let l5 = *((ptr2 + 16) as *const i64);
+                  
+                  MetadataHashValue{
+                    lower: l4 as u64,
+                    upper: l5 as u64,
+                  }
+                };
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l6 = i32::from(*((ptr2 + 8) as *const u8));
+                  
+                  ErrorCode::_lift(l6 as u8)
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl DirectoryEntryStream {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Read a single directory entry from a `directory-entry-stream`.
+        pub fn read_directory_entry(&self,) -> Result<Option<DirectoryEntry>,ErrorCode>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(4))]
+            struct RetArea([u8; 20]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let ptr0 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]directory-entry-stream.read-directory-entry"]
+              fn wit_import(_: i32, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, ptr0);
+            let l1 = i32::from(*((ptr0 + 0) as *const u8));
+            match l1 {
+              0 => {
+                let e = {
+                  let l2 = i32::from(*((ptr0 + 4) as *const u8));
+                  
+                  match l2 {
+                    0 => None,
+                    1 => {
+                      let e = {
+                        let l3 = i32::from(*((ptr0 + 8) as *const u8));
+                        let l4 = *((ptr0 + 12) as *const i32);
+                        let l5 = *((ptr0 + 16) as *const i32);
+                        let len6 = l5 as usize;
+                        let bytes6 = Vec::from_raw_parts(l4 as *mut _, len6, len6);
+                        
+                        DirectoryEntry{
+                          type_: DescriptorType::_lift(l3 as u8),
+                          name: wit_bindgen::rt::string_lift(bytes6),
+                        }
+                      };
+                      Some(e)
+                    }
+                    _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                  }
+                };
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l7 = i32::from(*((ptr0 + 4) as *const u8));
+                  
+                  ErrorCode::_lift(l7 as u8)
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      #[allow(unused_unsafe, clippy::all)]
+      /// Attempts to extract a filesystem-related `error-code` from the stream
+      /// `error` provided.
+      /// 
+      /// Stream operations which return `stream-error::last-operation-failed`
+      /// have a payload with more information about the operation that failed.
+      /// This payload can be passed through to this function to see if there's
+      /// filesystem-related information about the error to return.
+      /// 
+      /// Note that this function is fallible because not all stream-related
+      /// errors are filesystem-related errors.
+      pub fn filesystem_error_code(err: &Error,) -> Option<ErrorCode>{
+        
+        #[allow(unused_imports)]
+        use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+        unsafe {
+          
+          #[repr(align(1))]
+          struct RetArea([u8; 2]);
+          let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+          let ptr0 = ret_area.as_mut_ptr() as i32;
+          #[cfg(target_arch = "wasm32")]
+          #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
+          extern "C" {
+            #[link_name = "filesystem-error-code"]
+            fn wit_import(_: i32, _: i32, );
+          }
+          
+          #[cfg(not(target_arch = "wasm32"))]
+          fn wit_import(_: i32, _: i32, ){ unreachable!() }
+          wit_import((err).handle() as i32, ptr0);
+          let l1 = i32::from(*((ptr0 + 0) as *const u8));
+          match l1 {
+            0 => None,
+            1 => {
+              let e = {
+                let l2 = i32::from(*((ptr0 + 1) as *const u8));
+                
+                ErrorCode::_lift(l2 as u8)
+              };
+              Some(e)
+            }
+            _ => wit_bindgen::rt::invalid_enum_discriminant(),
+          }
+        }
+      }
+      
+    }
+    
+    
+    #[allow(clippy::all)]
+    pub mod preopens {
+      #[used]
+      #[doc(hidden)]
+      #[cfg(target_arch = "wasm32")]
+      static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+      pub type Descriptor = super::super::super::wasi::filesystem::types::Descriptor;
+      #[allow(unused_unsafe, clippy::all)]
+      /// Return the set of preopened directories, and their path.
+      pub fn get_directories() -> wit_bindgen::rt::vec::Vec::<(Descriptor,wit_bindgen::rt::string::String,)>{
+        
+        #[allow(unused_imports)]
+        use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+        unsafe {
+          
+          #[repr(align(4))]
+          struct RetArea([u8; 8]);
+          let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+          let ptr0 = ret_area.as_mut_ptr() as i32;
+          #[cfg(target_arch = "wasm32")]
+          #[link(wasm_import_module = "wasi:filesystem/preopens@0.2.0")]
+          extern "C" {
+            #[link_name = "get-directories"]
+            fn wit_import(_: i32, );
+          }
+          
+          #[cfg(not(target_arch = "wasm32"))]
+          fn wit_import(_: i32, ){ unreachable!() }
+          wit_import(ptr0);
+          let l1 = *((ptr0 + 0) as *const i32);
+          let l2 = *((ptr0 + 4) as *const i32);
+          let base7 = l1;
+          let len7 = l2;
+          let mut result7 = Vec::with_capacity(len7 as usize);
+          for i in 0..len7 {
+            let base = base7 + i * 12;
+            let e7 = {
+              let l3 = *((base + 0) as *const i32);
+              let l4 = *((base + 4) as *const i32);
+              let l5 = *((base + 8) as *const i32);
+              let len6 = l5 as usize;
+              let bytes6 = Vec::from_raw_parts(l4 as *mut _, len6, len6);
+              
+              (super::super::super::wasi::filesystem::types::Descriptor::from_handle(l3 as u32), wit_bindgen::rt::string_lift(bytes6))
+            };
+            result7.push(e7);
+          }
+          wit_bindgen::rt::dealloc(base7, (len7 as usize) * 12, 4);
+          result7
+        }
+      }
+      
+    }
+    
+  }
+  pub mod io {
+    
+    #[allow(clippy::all)]
+    pub mod error {
+      #[used]
+      #[doc(hidden)]
+      #[cfg(target_arch = "wasm32")]
+      static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+      /// A resource which represents some error information.
+      /// 
+      /// The only method provided by this resource is `to-debug-string`,
+      /// which provides some human-readable information about the error.
+      /// 
+      /// In the `wasi:io` package, this resource is returned through the
+      /// `wasi:io/streams/stream-error` type.
+      /// 
+      /// To provide more specific error information, other interfaces may
+      /// provide functions to further "downcast" this error into more specific
+      /// error information. For example, `error`s returned in streams derived
+      /// from filesystem types to be described using the filesystem's own
+      /// error-code type, using the function
+      /// `wasi:filesystem/types/filesystem-error-code`, which takes a parameter
+      /// `borrow<error>` and returns
+      /// `option<wasi:filesystem/types/error-code>`.
+      /// 
+      /// The set of functions which can "downcast" an `error` into a more
+      /// concrete type is open.
+      
+      #[derive(Debug)]
+      #[repr(transparent)]
+      pub struct Error{
+        handle: wit_bindgen::rt::Resource<Error>,
+      }
+      
+      impl Error{
+        #[doc(hidden)]
+        pub unsafe fn from_handle(handle: u32) -> Self {
+          Self {
+            handle: wit_bindgen::rt::Resource::from_handle(handle),
+          }
+        }
+        
+        #[doc(hidden)]
+        pub fn into_handle(self) -> u32 {
+          wit_bindgen::rt::Resource::into_handle(self.handle)
+        }
+        
+        #[doc(hidden)]
+        pub fn handle(&self) -> u32 {
+          wit_bindgen::rt::Resource::handle(&self.handle)
+        }
+      }
+      
+      
+      unsafe impl wit_bindgen::rt::WasmResource for Error{
+        #[inline]
+        unsafe fn drop(_handle: u32) {
+          #[cfg(not(target_arch = "wasm32"))]
+          unreachable!();
+          
+          #[cfg(target_arch = "wasm32")]
+          {
+            #[link(wasm_import_module = "wasi:io/error@0.2.0")]
+            extern "C" {
+              #[link_name = "[resource-drop]error"]
+              fn drop(_: u32);
+            }
+            
+            drop(_handle);
+          }
+        }
+      }
+      
+      impl Error {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Returns a string that is suitable to assist humans in debugging
+        /// this error.
+        /// 
+        /// WARNING: The returned string should not be consumed mechanically!
+        /// It may change across platforms, hosts, or other implementation
+        /// details. Parsing this string is a major platform-compatibility
+        /// hazard.
+        pub fn to_debug_string(&self,) -> wit_bindgen::rt::string::String{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(4))]
+            struct RetArea([u8; 8]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let ptr0 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:io/error@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]error.to-debug-string"]
+              fn wit_import(_: i32, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, ptr0);
+            let l1 = *((ptr0 + 0) as *const i32);
+            let l2 = *((ptr0 + 4) as *const i32);
+            let len3 = l2 as usize;
+            let bytes3 = Vec::from_raw_parts(l1 as *mut _, len3, len3);
+            wit_bindgen::rt::string_lift(bytes3)
+          }
+        }
+      }
+      
+    }
+    
+    
+    #[allow(clippy::all)]
+    pub mod poll {
+      #[used]
+      #[doc(hidden)]
+      #[cfg(target_arch = "wasm32")]
+      static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+      /// `pollable` represents a single I/O event which may be ready, or not.
+      
+      #[derive(Debug)]
+      #[repr(transparent)]
+      pub struct Pollable{
+        handle: wit_bindgen::rt::Resource<Pollable>,
+      }
+      
+      impl Pollable{
+        #[doc(hidden)]
+        pub unsafe fn from_handle(handle: u32) -> Self {
+          Self {
+            handle: wit_bindgen::rt::Resource::from_handle(handle),
+          }
+        }
+        
+        #[doc(hidden)]
+        pub fn into_handle(self) -> u32 {
+          wit_bindgen::rt::Resource::into_handle(self.handle)
+        }
+        
+        #[doc(hidden)]
+        pub fn handle(&self) -> u32 {
+          wit_bindgen::rt::Resource::handle(&self.handle)
+        }
+      }
+      
+      
+      unsafe impl wit_bindgen::rt::WasmResource for Pollable{
+        #[inline]
+        unsafe fn drop(_handle: u32) {
+          #[cfg(not(target_arch = "wasm32"))]
+          unreachable!();
+          
+          #[cfg(target_arch = "wasm32")]
+          {
+            #[link(wasm_import_module = "wasi:io/poll@0.2.0")]
+            extern "C" {
+              #[link_name = "[resource-drop]pollable"]
+              fn drop(_: u32);
+            }
+            
+            drop(_handle);
+          }
+        }
+      }
+      
+      impl Pollable {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Return the readiness of a pollable. This function never blocks.
+        /// 
+        /// Returns `true` when the pollable is ready, and `false` otherwise.
+        pub fn ready(&self,) -> bool{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:io/poll@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]pollable.ready"]
+              fn wit_import(_: i32, ) -> i32;
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, ) -> i32{ unreachable!() }
+            let ret = wit_import((self).handle() as i32);
+            wit_bindgen::rt::bool_lift(ret as u8)
+          }
+        }
+      }
+      impl Pollable {
+        #[allow(unused_unsafe, clippy::all)]
+        /// `block` returns immediately if the pollable is ready, and otherwise
+        /// blocks until ready.
+        /// 
+        /// This function is equivalent to calling `poll.poll` on a list
+        /// containing only this pollable.
+        pub fn block(&self,){
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:io/poll@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]pollable.block"]
+              fn wit_import(_: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32);
+          }
+        }
+      }
+      #[allow(unused_unsafe, clippy::all)]
+      /// Poll for completion on a set of pollables.
+      /// 
+      /// This function takes a list of pollables, which identify I/O sources of
+      /// interest, and waits until one or more of the events is ready for I/O.
+      /// 
+      /// The result `list<u32>` contains one or more indices of handles in the
+      /// argument list that is ready for I/O.
+      /// 
+      /// This function traps if either:
+      /// - the list is empty, or:
+      /// - the list contains more elements than can be indexed with a `u32` value.
+      /// 
+      /// A timeout can be implemented by adding a pollable from the
+      /// wasi-clocks API to the list.
+      /// 
+      /// This function does not return a `result`; polling in itself does not
+      /// do any I/O so it doesn't fail. If any of the I/O sources identified by
+      /// the pollables has an error, it is indicated by marking the source as
+      /// being ready for I/O.
+      pub fn poll(in_: &[&Pollable],) -> wit_bindgen::rt::vec::Vec::<u32>{
+        
+        #[allow(unused_imports)]
+        use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+        unsafe {
+          
+          #[repr(align(4))]
+          struct RetArea([u8; 8]);
+          let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+          let vec0 = in_;
+          let len0 = vec0.len() as i32;
+          let layout0 = alloc::Layout::from_size_align_unchecked(vec0.len() * 4, 4);
+          let result0 = if layout0.size() != 0
+          {
+            let ptr = alloc::alloc(layout0);
+            if ptr.is_null()
+            {
+              alloc::handle_alloc_error(layout0);
+            }
+            ptr
+          }else {{
+            ::core::ptr::null_mut()
+          }};
+          for (i, e) in vec0.into_iter().enumerate() {
+            let base = result0 as i32 + (i as i32) * 4;
+            {
+              *((base + 0) as *mut i32) = (e).handle() as i32;
+            }
+          }
+          let ptr1 = ret_area.as_mut_ptr() as i32;
+          #[cfg(target_arch = "wasm32")]
+          #[link(wasm_import_module = "wasi:io/poll@0.2.0")]
+          extern "C" {
+            #[link_name = "poll"]
+            fn wit_import(_: i32, _: i32, _: i32, );
+          }
+          
+          #[cfg(not(target_arch = "wasm32"))]
+          fn wit_import(_: i32, _: i32, _: i32, ){ unreachable!() }
+          wit_import(result0 as i32, len0, ptr1);
+          let l2 = *((ptr1 + 0) as *const i32);
+          let l3 = *((ptr1 + 4) as *const i32);
+          let len4 = l3 as usize;
+          if layout0.size() != 0 {
+            alloc::dealloc(result0, layout0);
+          }
+          Vec::from_raw_parts(l2 as *mut _, len4, len4)
+        }
+      }
+      
+    }
+    
+    
+    #[allow(clippy::all)]
+    pub mod streams {
+      #[used]
+      #[doc(hidden)]
+      #[cfg(target_arch = "wasm32")]
+      static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+      pub type Error = super::super::super::wasi::io::error::Error;
+      pub type Pollable = super::super::super::wasi::io::poll::Pollable;
+      /// An error for input-stream and output-stream operations.
+      pub enum StreamError{
+        /// The last operation (a write or flush) failed before completion.
+        /// 
+        /// More information is available in the `error` payload.
+        LastOperationFailed(Error),
+        /// The stream is closed: no more input will be accepted by the
+        /// stream. A closed output-stream will return this error on all
+        /// future operations.
+        Closed,
+      }
+      impl ::core::fmt::Debug for StreamError {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+          match self {
+            StreamError::LastOperationFailed(e) => {
+              f.debug_tuple("StreamError::LastOperationFailed").field(e).finish()
+            }
+            StreamError::Closed => {
+              f.debug_tuple("StreamError::Closed").finish()
+            }
+          }
+        }
+      }
+      impl ::core::fmt::Display for StreamError {
+        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+          write!(f, "{:?}", self)
+        }
+      }
+      
+      impl std::error::Error for StreamError {}
+      /// An input bytestream.
+      /// 
+      /// `input-stream`s are *non-blocking* to the extent practical on underlying
+      /// platforms. I/O operations always return promptly; if fewer bytes are
+      /// promptly available than requested, they return the number of bytes promptly
+      /// available, which could even be zero. To wait for data to be available,
+      /// use the `subscribe` function to obtain a `pollable` which can be polled
+      /// for using `wasi:io/poll`.
+      
+      #[derive(Debug)]
+      #[repr(transparent)]
+      pub struct InputStream{
+        handle: wit_bindgen::rt::Resource<InputStream>,
+      }
+      
+      impl InputStream{
+        #[doc(hidden)]
+        pub unsafe fn from_handle(handle: u32) -> Self {
+          Self {
+            handle: wit_bindgen::rt::Resource::from_handle(handle),
+          }
+        }
+        
+        #[doc(hidden)]
+        pub fn into_handle(self) -> u32 {
+          wit_bindgen::rt::Resource::into_handle(self.handle)
+        }
+        
+        #[doc(hidden)]
+        pub fn handle(&self) -> u32 {
+          wit_bindgen::rt::Resource::handle(&self.handle)
+        }
+      }
+      
+      
+      unsafe impl wit_bindgen::rt::WasmResource for InputStream{
+        #[inline]
+        unsafe fn drop(_handle: u32) {
+          #[cfg(not(target_arch = "wasm32"))]
+          unreachable!();
+          
+          #[cfg(target_arch = "wasm32")]
+          {
+            #[link(wasm_import_module = "wasi:io/streams@0.2.0")]
+            extern "C" {
+              #[link_name = "[resource-drop]input-stream"]
+              fn drop(_: u32);
+            }
+            
+            drop(_handle);
+          }
+        }
+      }
+      
+      /// An output bytestream.
+      /// 
+      /// `output-stream`s are *non-blocking* to the extent practical on
+      /// underlying platforms. Except where specified otherwise, I/O operations also
+      /// always return promptly, after the number of bytes that can be written
+      /// promptly, which could even be zero. To wait for the stream to be ready to
+      /// accept data, the `subscribe` function to obtain a `pollable` which can be
+      /// polled for using `wasi:io/poll`.
+      
+      #[derive(Debug)]
+      #[repr(transparent)]
+      pub struct OutputStream{
+        handle: wit_bindgen::rt::Resource<OutputStream>,
+      }
+      
+      impl OutputStream{
+        #[doc(hidden)]
+        pub unsafe fn from_handle(handle: u32) -> Self {
+          Self {
+            handle: wit_bindgen::rt::Resource::from_handle(handle),
+          }
+        }
+        
+        #[doc(hidden)]
+        pub fn into_handle(self) -> u32 {
+          wit_bindgen::rt::Resource::into_handle(self.handle)
+        }
+        
+        #[doc(hidden)]
+        pub fn handle(&self) -> u32 {
+          wit_bindgen::rt::Resource::handle(&self.handle)
+        }
+      }
+      
+      
+      unsafe impl wit_bindgen::rt::WasmResource for OutputStream{
+        #[inline]
+        unsafe fn drop(_handle: u32) {
+          #[cfg(not(target_arch = "wasm32"))]
+          unreachable!();
+          
+          #[cfg(target_arch = "wasm32")]
+          {
+            #[link(wasm_import_module = "wasi:io/streams@0.2.0")]
+            extern "C" {
+              #[link_name = "[resource-drop]output-stream"]
+              fn drop(_: u32);
+            }
+            
+            drop(_handle);
+          }
+        }
+      }
+      
+      impl InputStream {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Perform a non-blocking read from the stream.
+        /// 
+        /// When the source of a `read` is binary data, the bytes from the source
+        /// are returned verbatim. When the source of a `read` is known to the
+        /// implementation to be text, bytes containing the UTF-8 encoding of the
+        /// text are returned.
+        /// 
+        /// This function returns a list of bytes containing the read data,
+        /// when successful. The returned list will contain up to `len` bytes;
+        /// it may return fewer than requested, but not more. The list is
+        /// empty when no bytes are available for reading at this time. The
+        /// pollable given by `subscribe` will be ready when more bytes are
+        /// available.
+        /// 
+        /// This function fails with a `stream-error` when the operation
+        /// encounters an error, giving `last-operation-failed`, or when the
+        /// stream is closed, giving `closed`.
+        /// 
+        /// When the caller gives a `len` of 0, it represents a request to
+        /// read 0 bytes. If the stream is still open, this call should
+        /// succeed and return an empty list, or otherwise fail with `closed`.
+        /// 
+        /// The `len` parameter is a `u64`, which could represent a list of u8 which
+        /// is not possible to allocate in wasm32, or not desirable to allocate as
+        /// as a return value by the callee. The callee may return a list of bytes
+        /// less than `len` in size while more bytes are available for reading.
+        pub fn read(&self,len: u64,) -> Result<wit_bindgen::rt::vec::Vec::<u8>,StreamError>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(4))]
+            struct RetArea([u8; 12]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let ptr0 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:io/streams@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]input-stream.read"]
+              fn wit_import(_: i32, _: i64, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i64, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, wit_bindgen::rt::as_i64(len), ptr0);
+            let l1 = i32::from(*((ptr0 + 0) as *const u8));
+            match l1 {
+              0 => {
+                let e = {
+                  let l2 = *((ptr0 + 4) as *const i32);
+                  let l3 = *((ptr0 + 8) as *const i32);
+                  let len4 = l3 as usize;
+                  
+                  Vec::from_raw_parts(l2 as *mut _, len4, len4)
+                };
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l5 = i32::from(*((ptr0 + 4) as *const u8));
+                  let v7 = match l5 {
+                    0 => {
+                      let e7 = {
+                        let l6 = *((ptr0 + 8) as *const i32);
+                        
+                        super::super::super::wasi::io::error::Error::from_handle(l6 as u32)
+                      };
+                      StreamError::LastOperationFailed(e7)
+                    }
+                    n => {
+                      debug_assert_eq!(n, 1, "invalid enum discriminant");
+                      StreamError::Closed
+                    }
+                  };
+                  
+                  v7
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl InputStream {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Read bytes from a stream, after blocking until at least one byte can
+        /// be read. Except for blocking, behavior is identical to `read`.
+        pub fn blocking_read(&self,len: u64,) -> Result<wit_bindgen::rt::vec::Vec::<u8>,StreamError>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(4))]
+            struct RetArea([u8; 12]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let ptr0 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:io/streams@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]input-stream.blocking-read"]
+              fn wit_import(_: i32, _: i64, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i64, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, wit_bindgen::rt::as_i64(len), ptr0);
+            let l1 = i32::from(*((ptr0 + 0) as *const u8));
+            match l1 {
+              0 => {
+                let e = {
+                  let l2 = *((ptr0 + 4) as *const i32);
+                  let l3 = *((ptr0 + 8) as *const i32);
+                  let len4 = l3 as usize;
+                  
+                  Vec::from_raw_parts(l2 as *mut _, len4, len4)
+                };
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l5 = i32::from(*((ptr0 + 4) as *const u8));
+                  let v7 = match l5 {
+                    0 => {
+                      let e7 = {
+                        let l6 = *((ptr0 + 8) as *const i32);
+                        
+                        super::super::super::wasi::io::error::Error::from_handle(l6 as u32)
+                      };
+                      StreamError::LastOperationFailed(e7)
+                    }
+                    n => {
+                      debug_assert_eq!(n, 1, "invalid enum discriminant");
+                      StreamError::Closed
+                    }
+                  };
+                  
+                  v7
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl InputStream {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Skip bytes from a stream. Returns number of bytes skipped.
+        /// 
+        /// Behaves identical to `read`, except instead of returning a list
+        /// of bytes, returns the number of bytes consumed from the stream.
+        pub fn skip(&self,len: u64,) -> Result<u64,StreamError>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(8))]
+            struct RetArea([u8; 16]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let ptr0 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:io/streams@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]input-stream.skip"]
+              fn wit_import(_: i32, _: i64, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i64, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, wit_bindgen::rt::as_i64(len), ptr0);
+            let l1 = i32::from(*((ptr0 + 0) as *const u8));
+            match l1 {
+              0 => {
+                let e = {
+                  let l2 = *((ptr0 + 8) as *const i64);
+                  
+                  l2 as u64
+                };
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l3 = i32::from(*((ptr0 + 8) as *const u8));
+                  let v5 = match l3 {
+                    0 => {
+                      let e5 = {
+                        let l4 = *((ptr0 + 12) as *const i32);
+                        
+                        super::super::super::wasi::io::error::Error::from_handle(l4 as u32)
+                      };
+                      StreamError::LastOperationFailed(e5)
+                    }
+                    n => {
+                      debug_assert_eq!(n, 1, "invalid enum discriminant");
+                      StreamError::Closed
+                    }
+                  };
+                  
+                  v5
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl InputStream {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Skip bytes from a stream, after blocking until at least one byte
+        /// can be skipped. Except for blocking behavior, identical to `skip`.
+        pub fn blocking_skip(&self,len: u64,) -> Result<u64,StreamError>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(8))]
+            struct RetArea([u8; 16]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let ptr0 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:io/streams@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]input-stream.blocking-skip"]
+              fn wit_import(_: i32, _: i64, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i64, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, wit_bindgen::rt::as_i64(len), ptr0);
+            let l1 = i32::from(*((ptr0 + 0) as *const u8));
+            match l1 {
+              0 => {
+                let e = {
+                  let l2 = *((ptr0 + 8) as *const i64);
+                  
+                  l2 as u64
+                };
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l3 = i32::from(*((ptr0 + 8) as *const u8));
+                  let v5 = match l3 {
+                    0 => {
+                      let e5 = {
+                        let l4 = *((ptr0 + 12) as *const i32);
+                        
+                        super::super::super::wasi::io::error::Error::from_handle(l4 as u32)
+                      };
+                      StreamError::LastOperationFailed(e5)
+                    }
+                    n => {
+                      debug_assert_eq!(n, 1, "invalid enum discriminant");
+                      StreamError::Closed
+                    }
+                  };
+                  
+                  v5
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl InputStream {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Create a `pollable` which will resolve once either the specified stream
+        /// has bytes available to read or the other end of the stream has been
+        /// closed.
+        /// The created `pollable` is a child resource of the `input-stream`.
+        /// Implementations may trap if the `input-stream` is dropped before
+        /// all derived `pollable`s created with this function are dropped.
+        pub fn subscribe(&self,) -> Pollable{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:io/streams@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]input-stream.subscribe"]
+              fn wit_import(_: i32, ) -> i32;
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, ) -> i32{ unreachable!() }
+            let ret = wit_import((self).handle() as i32);
+            super::super::super::wasi::io::poll::Pollable::from_handle(ret as u32)
+          }
+        }
+      }
+      impl OutputStream {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Check readiness for writing. This function never blocks.
+        /// 
+        /// Returns the number of bytes permitted for the next call to `write`,
+        /// or an error. Calling `write` with more bytes than this function has
+        /// permitted will trap.
+        /// 
+        /// When this function returns 0 bytes, the `subscribe` pollable will
+        /// become ready when this function will report at least 1 byte, or an
+        /// error.
+        pub fn check_write(&self,) -> Result<u64,StreamError>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(8))]
+            struct RetArea([u8; 16]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let ptr0 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:io/streams@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]output-stream.check-write"]
+              fn wit_import(_: i32, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, ptr0);
+            let l1 = i32::from(*((ptr0 + 0) as *const u8));
+            match l1 {
+              0 => {
+                let e = {
+                  let l2 = *((ptr0 + 8) as *const i64);
+                  
+                  l2 as u64
+                };
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l3 = i32::from(*((ptr0 + 8) as *const u8));
+                  let v5 = match l3 {
+                    0 => {
+                      let e5 = {
+                        let l4 = *((ptr0 + 12) as *const i32);
+                        
+                        super::super::super::wasi::io::error::Error::from_handle(l4 as u32)
+                      };
+                      StreamError::LastOperationFailed(e5)
+                    }
+                    n => {
+                      debug_assert_eq!(n, 1, "invalid enum discriminant");
+                      StreamError::Closed
+                    }
+                  };
+                  
+                  v5
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl OutputStream {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Perform a write. This function never blocks.
+        /// 
+        /// When the destination of a `write` is binary data, the bytes from
+        /// `contents` are written verbatim. When the destination of a `write` is
+        /// known to the implementation to be text, the bytes of `contents` are
+        /// transcoded from UTF-8 into the encoding of the destination and then
+        /// written.
+        /// 
+        /// Precondition: check-write gave permit of Ok(n) and contents has a
+        /// length of less than or equal to n. Otherwise, this function will trap.
+        /// 
+        /// returns Err(closed) without writing if the stream has closed since
+        /// the last call to check-write provided a permit.
+        pub fn write(&self,contents: &[u8],) -> Result<(),StreamError>{
+          
+          #[allow(unused_imports)]
+          use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+          unsafe {
+            
+            #[repr(align(4))]
+            struct RetArea([u8; 12]);
+            let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+            let vec0 = contents;
+            let ptr0 = vec0.as_ptr() as i32;
+            let len0 = vec0.len() as i32;
+            let ptr1 = ret_area.as_mut_ptr() as i32;
+            #[cfg(target_arch = "wasm32")]
+            #[link(wasm_import_module = "wasi:io/streams@0.2.0")]
+            extern "C" {
+              #[link_name = "[method]output-stream.write"]
+              fn wit_import(_: i32, _: i32, _: i32, _: i32, );
+            }
+            
+            #[cfg(not(target_arch = "wasm32"))]
+            fn wit_import(_: i32, _: i32, _: i32, _: i32, ){ unreachable!() }
+            wit_import((self).handle() as i32, ptr0, len0, ptr1);
+            let l2 = i32::from(*((ptr1 + 0) as *const u8));
+            match l2 {
+              0 => {
+                let e = ();
+                Ok(e)
+              }
+              1 => {
+                let e = {
+                  let l3 = i32::from(*((ptr1 + 4) as *const u8));
+                  let v5 = match l3 {
+                    0 => {
+                      let e5 = {
+                        let l4 = *((ptr1 + 8) as *const i32);
+                        
+                        super::super::super::wasi::io::error::Error::from_handle(l4 as u32)
+                      };
+                      StreamError::LastOperationFailed(e5)
+                    }
+                    n => {
+                      debug_assert_eq!(n, 1, "invalid enum discriminant");
+                      StreamError::Closed
+                    }
+                  };
+                  
+                  v5
+                };
+                Err(e)
+              }
+              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+            }
+          }
+        }
+      }
+      impl OutputStream {
+        #[allow(unused_unsafe, clippy::all)]
+        /// Perform a write of up to 4096 bytes, and then flush the stream. Block
+        /// until all of these operations are complete, or an error occurs.
+        /// 
+        /// This is a convenience wrapper around the use of `check-write`,
+        /// `subscribe`, `write`, and `flush`, and is implemented with the
+        /// following pseudo-code:
+        /// 
+        /// ```text
+        /// let pollable = this.subscribe();
+        /// while !contents.is_empty() {
+          /// // Wait for the stream to become writable
+          /// pollable.block();
+          /// let Ok(n) = this.check-write(); // eliding error handling
+          /// let len = min(n, contents.len());
+          /// let (chunk, rest) = contents.split_at(len);
+          /// this.write(chunk  );            // eliding error handling
+          /// contents = rest;
+          /// }
+          /// this.flush();
+          /// // Wait for completion of `flush`
+          /// pollable.block();
+          /// // Check for any errors that arose during `flush`
+          /// let _ = this.check-write();         // eliding error handling
+          /// ```
+          pub fn blocking_write_and_flush(&self,contents: &[u8],) -> Result<(),StreamError>{
+            
+            #[allow(unused_imports)]
+            use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+            unsafe {
+              
+              #[repr(align(4))]
+              struct RetArea([u8; 12]);
+              let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+              let vec0 = contents;
+              let ptr0 = vec0.as_ptr() as i32;
+              let len0 = vec0.len() as i32;
+              let ptr1 = ret_area.as_mut_ptr() as i32;
+              #[cfg(target_arch = "wasm32")]
+              #[link(wasm_import_module = "wasi:io/streams@0.2.0")]
+              extern "C" {
+                #[link_name = "[method]output-stream.blocking-write-and-flush"]
+                fn wit_import(_: i32, _: i32, _: i32, _: i32, );
+              }
+              
+              #[cfg(not(target_arch = "wasm32"))]
+              fn wit_import(_: i32, _: i32, _: i32, _: i32, ){ unreachable!() }
+              wit_import((self).handle() as i32, ptr0, len0, ptr1);
+              let l2 = i32::from(*((ptr1 + 0) as *const u8));
+              match l2 {
+                0 => {
+                  let e = ();
+                  Ok(e)
+                }
+                1 => {
+                  let e = {
+                    let l3 = i32::from(*((ptr1 + 4) as *const u8));
+                    let v5 = match l3 {
+                      0 => {
+                        let e5 = {
+                          let l4 = *((ptr1 + 8) as *const i32);
+                          
+                          super::super::super::wasi::io::error::Error::from_handle(l4 as u32)
+                        };
+                        StreamError::LastOperationFailed(e5)
+                      }
+                      n => {
+                        debug_assert_eq!(n, 1, "invalid enum discriminant");
+                        StreamError::Closed
+                      }
+                    };
+                    
+                    v5
+                  };
+                  Err(e)
+                }
+                _ => wit_bindgen::rt::invalid_enum_discriminant(),
+              }
+            }
+          }
+        }
+        impl OutputStream {
+          #[allow(unused_unsafe, clippy::all)]
+          /// Request to flush buffered output. This function never blocks.
+          /// 
+          /// This tells the output-stream that the caller intends any buffered
+          /// output to be flushed. the output which is expected to be flushed
+          /// is all that has been passed to `write` prior to this call.
+          /// 
+          /// Upon calling this function, the `output-stream` will not accept any
+          /// writes (`check-write` will return `ok(0)`) until the flush has
+          /// completed. The `subscribe` pollable will become ready when the
+          /// flush has completed and the stream can accept more writes.
+          pub fn flush(&self,) -> Result<(),StreamError>{
+            
+            #[allow(unused_imports)]
+            use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+            unsafe {
+              
+              #[repr(align(4))]
+              struct RetArea([u8; 12]);
+              let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+              let ptr0 = ret_area.as_mut_ptr() as i32;
+              #[cfg(target_arch = "wasm32")]
+              #[link(wasm_import_module = "wasi:io/streams@0.2.0")]
+              extern "C" {
+                #[link_name = "[method]output-stream.flush"]
+                fn wit_import(_: i32, _: i32, );
+              }
+              
+              #[cfg(not(target_arch = "wasm32"))]
+              fn wit_import(_: i32, _: i32, ){ unreachable!() }
+              wit_import((self).handle() as i32, ptr0);
+              let l1 = i32::from(*((ptr0 + 0) as *const u8));
+              match l1 {
+                0 => {
+                  let e = ();
+                  Ok(e)
+                }
+                1 => {
+                  let e = {
+                    let l2 = i32::from(*((ptr0 + 4) as *const u8));
+                    let v4 = match l2 {
+                      0 => {
+                        let e4 = {
+                          let l3 = *((ptr0 + 8) as *const i32);
+                          
+                          super::super::super::wasi::io::error::Error::from_handle(l3 as u32)
+                        };
+                        StreamError::LastOperationFailed(e4)
+                      }
+                      n => {
+                        debug_assert_eq!(n, 1, "invalid enum discriminant");
+                        StreamError::Closed
+                      }
+                    };
+                    
+                    v4
+                  };
+                  Err(e)
+                }
+                _ => wit_bindgen::rt::invalid_enum_discriminant(),
+              }
+            }
+          }
+        }
+        impl OutputStream {
+          #[allow(unused_unsafe, clippy::all)]
+          /// Request to flush buffered output, and block until flush completes
+          /// and stream is ready for writing again.
+          pub fn blocking_flush(&self,) -> Result<(),StreamError>{
+            
+            #[allow(unused_imports)]
+            use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+            unsafe {
+              
+              #[repr(align(4))]
+              struct RetArea([u8; 12]);
+              let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+              let ptr0 = ret_area.as_mut_ptr() as i32;
+              #[cfg(target_arch = "wasm32")]
+              #[link(wasm_import_module = "wasi:io/streams@0.2.0")]
+              extern "C" {
+                #[link_name = "[method]output-stream.blocking-flush"]
+                fn wit_import(_: i32, _: i32, );
+              }
+              
+              #[cfg(not(target_arch = "wasm32"))]
+              fn wit_import(_: i32, _: i32, ){ unreachable!() }
+              wit_import((self).handle() as i32, ptr0);
+              let l1 = i32::from(*((ptr0 + 0) as *const u8));
+              match l1 {
+                0 => {
+                  let e = ();
+                  Ok(e)
+                }
+                1 => {
+                  let e = {
+                    let l2 = i32::from(*((ptr0 + 4) as *const u8));
+                    let v4 = match l2 {
+                      0 => {
+                        let e4 = {
+                          let l3 = *((ptr0 + 8) as *const i32);
+                          
+                          super::super::super::wasi::io::error::Error::from_handle(l3 as u32)
+                        };
+                        StreamError::LastOperationFailed(e4)
+                      }
+                      n => {
+                        debug_assert_eq!(n, 1, "invalid enum discriminant");
+                        StreamError::Closed
+                      }
+                    };
+                    
+                    v4
+                  };
+                  Err(e)
+                }
+                _ => wit_bindgen::rt::invalid_enum_discriminant(),
+              }
+            }
+          }
+        }
+        impl OutputStream {
+          #[allow(unused_unsafe, clippy::all)]
+          /// Create a `pollable` which will resolve once the output-stream
+          /// is ready for more writing, or an error has occurred. When this
+          /// pollable is ready, `check-write` will return `ok(n)` with n>0, or an
+          /// error.
+          /// 
+          /// If the stream is closed, this pollable is always ready immediately.
+          /// 
+          /// The created `pollable` is a child resource of the `output-stream`.
+          /// Implementations may trap if the `output-stream` is dropped before
+          /// all derived `pollable`s created with this function are dropped.
+          pub fn subscribe(&self,) -> Pollable{
+            
+            #[allow(unused_imports)]
+            use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+            unsafe {
+              
+              #[cfg(target_arch = "wasm32")]
+              #[link(wasm_import_module = "wasi:io/streams@0.2.0")]
+              extern "C" {
+                #[link_name = "[method]output-stream.subscribe"]
+                fn wit_import(_: i32, ) -> i32;
+              }
+              
+              #[cfg(not(target_arch = "wasm32"))]
+              fn wit_import(_: i32, ) -> i32{ unreachable!() }
+              let ret = wit_import((self).handle() as i32);
+              super::super::super::wasi::io::poll::Pollable::from_handle(ret as u32)
+            }
+          }
+        }
+        impl OutputStream {
+          #[allow(unused_unsafe, clippy::all)]
+          /// Write zeroes to a stream.
+          /// 
+          /// This should be used precisely like `write` with the exact same
+          /// preconditions (must use check-write first), but instead of
+          /// passing a list of bytes, you simply pass the number of zero-bytes
+          /// that should be written.
+          pub fn write_zeroes(&self,len: u64,) -> Result<(),StreamError>{
+            
+            #[allow(unused_imports)]
+            use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+            unsafe {
+              
+              #[repr(align(4))]
+              struct RetArea([u8; 12]);
+              let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+              let ptr0 = ret_area.as_mut_ptr() as i32;
+              #[cfg(target_arch = "wasm32")]
+              #[link(wasm_import_module = "wasi:io/streams@0.2.0")]
+              extern "C" {
+                #[link_name = "[method]output-stream.write-zeroes"]
+                fn wit_import(_: i32, _: i64, _: i32, );
+              }
+              
+              #[cfg(not(target_arch = "wasm32"))]
+              fn wit_import(_: i32, _: i64, _: i32, ){ unreachable!() }
+              wit_import((self).handle() as i32, wit_bindgen::rt::as_i64(len), ptr0);
+              let l1 = i32::from(*((ptr0 + 0) as *const u8));
+              match l1 {
+                0 => {
+                  let e = ();
+                  Ok(e)
+                }
+                1 => {
+                  let e = {
+                    let l2 = i32::from(*((ptr0 + 4) as *const u8));
+                    let v4 = match l2 {
+                      0 => {
+                        let e4 = {
+                          let l3 = *((ptr0 + 8) as *const i32);
+                          
+                          super::super::super::wasi::io::error::Error::from_handle(l3 as u32)
+                        };
+                        StreamError::LastOperationFailed(e4)
+                      }
+                      n => {
+                        debug_assert_eq!(n, 1, "invalid enum discriminant");
+                        StreamError::Closed
+                      }
+                    };
+                    
+                    v4
+                  };
+                  Err(e)
+                }
+                _ => wit_bindgen::rt::invalid_enum_discriminant(),
+              }
+            }
+          }
+        }
+        impl OutputStream {
+          #[allow(unused_unsafe, clippy::all)]
+          /// Perform a write of up to 4096 zeroes, and then flush the stream.
+          /// Block until all of these operations are complete, or an error
+          /// occurs.
+          /// 
+          /// This is a convenience wrapper around the use of `check-write`,
+          /// `subscribe`, `write-zeroes`, and `flush`, and is implemented with
+          /// the following pseudo-code:
+          /// 
+          /// ```text
+          /// let pollable = this.subscribe();
+          /// while num_zeroes != 0 {
+            /// // Wait for the stream to become writable
+            /// pollable.block();
+            /// let Ok(n) = this.check-write(); // eliding error handling
+            /// let len = min(n, num_zeroes);
+            /// this.write-zeroes(len);         // eliding error handling
+            /// num_zeroes -= len;
+            /// }
+            /// this.flush();
+            /// // Wait for completion of `flush`
+            /// pollable.block();
+            /// // Check for any errors that arose during `flush`
+            /// let _ = this.check-write();         // eliding error handling
+            /// ```
+            pub fn blocking_write_zeroes_and_flush(&self,len: u64,) -> Result<(),StreamError>{
+              
+              #[allow(unused_imports)]
+              use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+              unsafe {
+                
+                #[repr(align(4))]
+                struct RetArea([u8; 12]);
+                let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                let ptr0 = ret_area.as_mut_ptr() as i32;
+                #[cfg(target_arch = "wasm32")]
+                #[link(wasm_import_module = "wasi:io/streams@0.2.0")]
+                extern "C" {
+                  #[link_name = "[method]output-stream.blocking-write-zeroes-and-flush"]
+                  fn wit_import(_: i32, _: i64, _: i32, );
+                }
+                
+                #[cfg(not(target_arch = "wasm32"))]
+                fn wit_import(_: i32, _: i64, _: i32, ){ unreachable!() }
+                wit_import((self).handle() as i32, wit_bindgen::rt::as_i64(len), ptr0);
+                let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                match l1 {
+                  0 => {
+                    let e = ();
+                    Ok(e)
+                  }
+                  1 => {
+                    let e = {
+                      let l2 = i32::from(*((ptr0 + 4) as *const u8));
+                      let v4 = match l2 {
+                        0 => {
+                          let e4 = {
+                            let l3 = *((ptr0 + 8) as *const i32);
+                            
+                            super::super::super::wasi::io::error::Error::from_handle(l3 as u32)
+                          };
+                          StreamError::LastOperationFailed(e4)
+                        }
+                        n => {
+                          debug_assert_eq!(n, 1, "invalid enum discriminant");
+                          StreamError::Closed
+                        }
+                      };
+                      
+                      v4
+                    };
+                    Err(e)
+                  }
+                  _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                }
+              }
+            }
+          }
+          impl OutputStream {
+            #[allow(unused_unsafe, clippy::all)]
+            /// Read from one stream and write to another.
+            /// 
+            /// The behavior of splice is equivalent to:
+            /// 1. calling `check-write` on the `output-stream`
+            /// 2. calling `read` on the `input-stream` with the smaller of the
+            /// `check-write` permitted length and the `len` provided to `splice`
+            /// 3. calling `write` on the `output-stream` with that read data.
+            /// 
+            /// Any error reported by the call to `check-write`, `read`, or
+            /// `write` ends the splice and reports that error.
+            /// 
+            /// This function returns the number of bytes transferred; it may be less
+            /// than `len`.
+            pub fn splice(&self,src: &InputStream,len: u64,) -> Result<u64,StreamError>{
+              
+              #[allow(unused_imports)]
+              use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+              unsafe {
+                
+                #[repr(align(8))]
+                struct RetArea([u8; 16]);
+                let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                let ptr0 = ret_area.as_mut_ptr() as i32;
+                #[cfg(target_arch = "wasm32")]
+                #[link(wasm_import_module = "wasi:io/streams@0.2.0")]
+                extern "C" {
+                  #[link_name = "[method]output-stream.splice"]
+                  fn wit_import(_: i32, _: i32, _: i64, _: i32, );
+                }
+                
+                #[cfg(not(target_arch = "wasm32"))]
+                fn wit_import(_: i32, _: i32, _: i64, _: i32, ){ unreachable!() }
+                wit_import((self).handle() as i32, (src).handle() as i32, wit_bindgen::rt::as_i64(len), ptr0);
+                let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                match l1 {
+                  0 => {
+                    let e = {
+                      let l2 = *((ptr0 + 8) as *const i64);
+                      
+                      l2 as u64
+                    };
+                    Ok(e)
+                  }
+                  1 => {
+                    let e = {
+                      let l3 = i32::from(*((ptr0 + 8) as *const u8));
+                      let v5 = match l3 {
+                        0 => {
+                          let e5 = {
+                            let l4 = *((ptr0 + 12) as *const i32);
+                            
+                            super::super::super::wasi::io::error::Error::from_handle(l4 as u32)
+                          };
+                          StreamError::LastOperationFailed(e5)
+                        }
+                        n => {
+                          debug_assert_eq!(n, 1, "invalid enum discriminant");
+                          StreamError::Closed
+                        }
+                      };
+                      
+                      v5
+                    };
+                    Err(e)
+                  }
+                  _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                }
+              }
+            }
+          }
+          impl OutputStream {
+            #[allow(unused_unsafe, clippy::all)]
+            /// Read from one stream and write to another, with blocking.
+            /// 
+            /// This is similar to `splice`, except that it blocks until the
+            /// `output-stream` is ready for writing, and the `input-stream`
+            /// is ready for reading, before performing the `splice`.
+            pub fn blocking_splice(&self,src: &InputStream,len: u64,) -> Result<u64,StreamError>{
+              
+              #[allow(unused_imports)]
+              use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+              unsafe {
+                
+                #[repr(align(8))]
+                struct RetArea([u8; 16]);
+                let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                let ptr0 = ret_area.as_mut_ptr() as i32;
+                #[cfg(target_arch = "wasm32")]
+                #[link(wasm_import_module = "wasi:io/streams@0.2.0")]
+                extern "C" {
+                  #[link_name = "[method]output-stream.blocking-splice"]
+                  fn wit_import(_: i32, _: i32, _: i64, _: i32, );
+                }
+                
+                #[cfg(not(target_arch = "wasm32"))]
+                fn wit_import(_: i32, _: i32, _: i64, _: i32, ){ unreachable!() }
+                wit_import((self).handle() as i32, (src).handle() as i32, wit_bindgen::rt::as_i64(len), ptr0);
+                let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                match l1 {
+                  0 => {
+                    let e = {
+                      let l2 = *((ptr0 + 8) as *const i64);
+                      
+                      l2 as u64
+                    };
+                    Ok(e)
+                  }
+                  1 => {
+                    let e = {
+                      let l3 = i32::from(*((ptr0 + 8) as *const u8));
+                      let v5 = match l3 {
+                        0 => {
+                          let e5 = {
+                            let l4 = *((ptr0 + 12) as *const i32);
+                            
+                            super::super::super::wasi::io::error::Error::from_handle(l4 as u32)
+                          };
+                          StreamError::LastOperationFailed(e5)
+                        }
+                        n => {
+                          debug_assert_eq!(n, 1, "invalid enum discriminant");
+                          StreamError::Closed
+                        }
+                      };
+                      
+                      v5
+                    };
+                    Err(e)
+                  }
+                  _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                }
+              }
+            }
+          }
+          
+        }
+        
+      }
+      pub mod nn {
+        
+        #[allow(clippy::all)]
+        pub mod tensor {
+          #[used]
+          #[doc(hidden)]
+          #[cfg(target_arch = "wasm32")]
+          static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+          /// The dimensions of a tensor.
+          /// 
+          /// The array length matches the tensor rank and each element in the array describes the size of
+          /// each dimension
+          pub type TensorDimensions = wit_bindgen::rt::vec::Vec::<u32>;
+          /// The type of the elements in a tensor.
+          #[repr(u8)]
+          #[derive(Clone, Copy, Eq, PartialEq)]
+          pub enum TensorType {
+            Fp16,
+            Fp32,
+            Fp64,
+            Bf16,
+            U8,
+            I32,
+            I64,
+          }
+          impl ::core::fmt::Debug for TensorType {
+            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+              match self {
+                TensorType::Fp16 => {
+                  f.debug_tuple("TensorType::Fp16").finish()
+                }
+                TensorType::Fp32 => {
+                  f.debug_tuple("TensorType::Fp32").finish()
+                }
+                TensorType::Fp64 => {
+                  f.debug_tuple("TensorType::Fp64").finish()
+                }
+                TensorType::Bf16 => {
+                  f.debug_tuple("TensorType::Bf16").finish()
+                }
+                TensorType::U8 => {
+                  f.debug_tuple("TensorType::U8").finish()
+                }
+                TensorType::I32 => {
+                  f.debug_tuple("TensorType::I32").finish()
+                }
+                TensorType::I64 => {
+                  f.debug_tuple("TensorType::I64").finish()
+                }
+              }
+            }
+          }
+          
+          impl TensorType{
+            pub(crate) unsafe fn _lift(val: u8) -> TensorType{
+              if !cfg!(debug_assertions) {
+                return ::core::mem::transmute(val);
+              }
+              
+              match val {
+                0 => TensorType::Fp16,
+                1 => TensorType::Fp32,
+                2 => TensorType::Fp64,
+                3 => TensorType::Bf16,
+                4 => TensorType::U8,
+                5 => TensorType::I32,
+                6 => TensorType::I64,
+                
+                _ => panic!("invalid enum discriminant"),
+              }
+            }
+          }
+          
+          /// The tensor data.
+          /// 
+          /// Initially conceived as a sparse representation, each empty cell would be filled with zeros
+          /// and the array length must match the product of all of the dimensions and the number of bytes
+          /// in the type (e.g., a 2x2 tensor with 4-byte f32 elements would have a data array of length
+          /// 16). Naturally, this representation requires some knowledge of how to lay out data in
+          /// memory--e.g., using row-major ordering--and could perhaps be improved.
+          pub type TensorData = wit_bindgen::rt::vec::Vec::<u8>;
+          #[derive(Clone)]
+          pub struct Tensor {
+            /// Describe the size of the tensor (e.g., 2x2x2x2 -> [2, 2, 2, 2]). To represent a tensor
+            /// containing a single value, use `[1]` for the tensor dimensions.
+            pub dimensions: TensorDimensions,
+            /// Describe the type of element in the tensor (e.g., `f32`).
+            pub tensor_type: TensorType,
+            /// Contains the tensor data.
+            pub data: TensorData,
+          }
+          impl ::core::fmt::Debug for Tensor {
+            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+              f.debug_struct("Tensor").field("dimensions", &self.dimensions).field("tensor-type", &self.tensor_type).field("data", &self.data).finish()
+            }
+          }
+          
+        }
+        
+        
+        #[allow(clippy::all)]
+        pub mod errors {
+          #[used]
+          #[doc(hidden)]
+          #[cfg(target_arch = "wasm32")]
+          static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+          #[repr(u8)]
+          #[derive(Clone, Copy, Eq, PartialEq)]
+          pub enum Error {
+            /// Caller module passed an invalid argument.
+            InvalidArgument,
+            /// Invalid encoding.
+            InvalidEncoding,
+            Busy,
+            /// Runtime Error.
+            RuntimeError,
+            /// Unsupported operation.
+            UnsupportedOperation,
+            /// Graph is too large.
+            TooLarge,
+            /// Graph not found.
+            NotFound,
+          }
+          impl Error{
+            pub fn name(&self) -> &'static str {
+              match self {
+                Error::InvalidArgument => "invalid-argument",
+                Error::InvalidEncoding => "invalid-encoding",
+                Error::Busy => "busy",
+                Error::RuntimeError => "runtime-error",
+                Error::UnsupportedOperation => "unsupported-operation",
+                Error::TooLarge => "too-large",
+                Error::NotFound => "not-found",
+              }
+            }
+            pub fn message(&self) -> &'static str {
+              match self {
+                Error::InvalidArgument => "Caller module passed an invalid argument.",
+                Error::InvalidEncoding => "Invalid encoding.",
+                Error::Busy => "",
+                Error::RuntimeError => "Runtime Error.",
+                Error::UnsupportedOperation => "Unsupported operation.",
+                Error::TooLarge => "Graph is too large.",
+                Error::NotFound => "Graph not found.",
+              }
+            }
+          }
+          impl ::core::fmt::Debug for Error{
+            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+              f.debug_struct("Error")
+              .field("code", &(*self as i32))
+              .field("name", &self.name())
+              .field("message", &self.message())
+              .finish()
+            }
+          }
+          impl ::core::fmt::Display for Error{
+            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+              write!(f, "{} (error {})", self.name(), *self as i32)
+            }
+          }
+          
+          impl std::error::Error for Error{}
+          
+          impl Error{
+            pub(crate) unsafe fn _lift(val: u8) -> Error{
+              if !cfg!(debug_assertions) {
+                return ::core::mem::transmute(val);
+              }
+              
+              match val {
+                0 => Error::InvalidArgument,
+                1 => Error::InvalidEncoding,
+                2 => Error::Busy,
+                3 => Error::RuntimeError,
+                4 => Error::UnsupportedOperation,
+                5 => Error::TooLarge,
+                6 => Error::NotFound,
+                
+                _ => panic!("invalid enum discriminant"),
+              }
+            }
+          }
+          
+          
+        }
+        
+        
+        #[allow(clippy::all)]
+        pub mod graph {
+          #[used]
+          #[doc(hidden)]
+          #[cfg(target_arch = "wasm32")]
+          static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+          pub type Error = super::super::super::wasi::nn::errors::Error;
+          /// An execution graph for performing inference (i.e., a model).
+          /// 
+          /// TODO: replace with `resource` (https://github.com/WebAssembly/wasi-nn/issues/47).
+          pub type Graph = u32;
+          /// Describes the encoding of the graph. This allows the API to be implemented by various
+          /// backends that encode (i.e., serialize) their graph IR with different formats.
+          #[repr(u8)]
+          #[derive(Clone, Copy, Eq, PartialEq)]
+          pub enum GraphEncoding {
+            Openvino,
+            Onnx,
+            Tensorflow,
+            Pytorch,
+            Tensorflowlite,
+            Autodetect,
+          }
+          impl ::core::fmt::Debug for GraphEncoding {
+            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+              match self {
+                GraphEncoding::Openvino => {
+                  f.debug_tuple("GraphEncoding::Openvino").finish()
+                }
+                GraphEncoding::Onnx => {
+                  f.debug_tuple("GraphEncoding::Onnx").finish()
+                }
+                GraphEncoding::Tensorflow => {
+                  f.debug_tuple("GraphEncoding::Tensorflow").finish()
+                }
+                GraphEncoding::Pytorch => {
+                  f.debug_tuple("GraphEncoding::Pytorch").finish()
+                }
+                GraphEncoding::Tensorflowlite => {
+                  f.debug_tuple("GraphEncoding::Tensorflowlite").finish()
+                }
+                GraphEncoding::Autodetect => {
+                  f.debug_tuple("GraphEncoding::Autodetect").finish()
+                }
+              }
+            }
+          }
+          
+          impl GraphEncoding{
+            pub(crate) unsafe fn _lift(val: u8) -> GraphEncoding{
+              if !cfg!(debug_assertions) {
+                return ::core::mem::transmute(val);
+              }
+              
+              match val {
+                0 => GraphEncoding::Openvino,
+                1 => GraphEncoding::Onnx,
+                2 => GraphEncoding::Tensorflow,
+                3 => GraphEncoding::Pytorch,
+                4 => GraphEncoding::Tensorflowlite,
+                5 => GraphEncoding::Autodetect,
+                
+                _ => panic!("invalid enum discriminant"),
+              }
+            }
+          }
+          
+          /// Define where the graph should be executed.
+          #[repr(u8)]
+          #[derive(Clone, Copy, Eq, PartialEq)]
+          pub enum ExecutionTarget {
+            Cpu,
+            Gpu,
+            Tpu,
+          }
+          impl ::core::fmt::Debug for ExecutionTarget {
+            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+              match self {
+                ExecutionTarget::Cpu => {
+                  f.debug_tuple("ExecutionTarget::Cpu").finish()
+                }
+                ExecutionTarget::Gpu => {
+                  f.debug_tuple("ExecutionTarget::Gpu").finish()
+                }
+                ExecutionTarget::Tpu => {
+                  f.debug_tuple("ExecutionTarget::Tpu").finish()
+                }
+              }
+            }
+          }
+          
+          impl ExecutionTarget{
+            pub(crate) unsafe fn _lift(val: u8) -> ExecutionTarget{
+              if !cfg!(debug_assertions) {
+                return ::core::mem::transmute(val);
+              }
+              
+              match val {
+                0 => ExecutionTarget::Cpu,
+                1 => ExecutionTarget::Gpu,
+                2 => ExecutionTarget::Tpu,
+                
+                _ => panic!("invalid enum discriminant"),
+              }
+            }
+          }
+          
+          /// The graph initialization data.
+          /// 
+          /// This gets bundled up into an array of buffers because implementing backends may encode their
+          /// graph IR in parts (e.g., OpenVINO stores its IR and weights separately).
+          pub type GraphBuilder = wit_bindgen::rt::vec::Vec::<u8>;
+          #[allow(unused_unsafe, clippy::all)]
+          /// Load a `graph` from an opaque sequence of bytes to use for inference.
+          pub fn load(builder: &[GraphBuilder],encoding: GraphEncoding,target: ExecutionTarget,) -> Result<Graph,Error>{
+            
+            #[allow(unused_imports)]
+            use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+            unsafe {
+              
+              #[repr(align(4))]
+              struct RetArea([u8; 8]);
+              let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+              let vec1 = builder;
+              let len1 = vec1.len() as i32;
+              let layout1 = alloc::Layout::from_size_align_unchecked(vec1.len() * 8, 4);
+              let result1 = if layout1.size() != 0
+              {
+                let ptr = alloc::alloc(layout1);
+                if ptr.is_null()
+                {
+                  alloc::handle_alloc_error(layout1);
+                }
+                ptr
+              }else {{
+                ::core::ptr::null_mut()
+              }};
+              for (i, e) in vec1.into_iter().enumerate() {
+                let base = result1 as i32 + (i as i32) * 8;
+                {
+                  let vec0 = e;
+                  let ptr0 = vec0.as_ptr() as i32;
+                  let len0 = vec0.len() as i32;
+                  *((base + 4) as *mut i32) = len0;
+                  *((base + 0) as *mut i32) = ptr0;
+                }
+              }
+              let ptr2 = ret_area.as_mut_ptr() as i32;
+              #[cfg(target_arch = "wasm32")]
+              #[link(wasm_import_module = "wasi:nn/graph")]
+              extern "C" {
+                #[link_name = "load"]
+                fn wit_import(_: i32, _: i32, _: i32, _: i32, _: i32, );
+              }
+              
+              #[cfg(not(target_arch = "wasm32"))]
+              fn wit_import(_: i32, _: i32, _: i32, _: i32, _: i32, ){ unreachable!() }
+              wit_import(result1 as i32, len1, encoding.clone() as i32, target.clone() as i32, ptr2);
+              let l3 = i32::from(*((ptr2 + 0) as *const u8));
+              if layout1.size() != 0 {
+                alloc::dealloc(result1, layout1);
+              }
+              match l3 {
+                0 => {
+                  let e = {
+                    let l4 = *((ptr2 + 4) as *const i32);
+                    
+                    l4 as u32
+                  };
+                  Ok(e)
+                }
+                1 => {
+                  let e = {
+                    let l5 = i32::from(*((ptr2 + 4) as *const u8));
+                    
+                    super::super::super::wasi::nn::errors::Error::_lift(l5 as u8)
+                  };
+                  Err(e)
+                }
+                _ => wit_bindgen::rt::invalid_enum_discriminant(),
+              }
+            }
+          }
+          #[allow(unused_unsafe, clippy::all)]
+          /// Load a `graph` by name.
+          /// 
+          /// How the host expects the names to be passed and how it stores the graphs for retrieval via
+          /// this function is **implementation-specific**. This allows hosts to choose name schemes that
+          /// range from simple to complex (e.g., URLs?) and caching mechanisms of various kinds.
+          pub fn load_by_name(name: &str,) -> Result<Graph,Error>{
+            
+            #[allow(unused_imports)]
+            use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+            unsafe {
+              
+              #[repr(align(4))]
+              struct RetArea([u8; 8]);
+              let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+              let vec0 = name;
+              let ptr0 = vec0.as_ptr() as i32;
+              let len0 = vec0.len() as i32;
+              let ptr1 = ret_area.as_mut_ptr() as i32;
+              #[cfg(target_arch = "wasm32")]
+              #[link(wasm_import_module = "wasi:nn/graph")]
+              extern "C" {
+                #[link_name = "load-by-name"]
+                fn wit_import(_: i32, _: i32, _: i32, );
+              }
+              
+              #[cfg(not(target_arch = "wasm32"))]
+              fn wit_import(_: i32, _: i32, _: i32, ){ unreachable!() }
+              wit_import(ptr0, len0, ptr1);
+              let l2 = i32::from(*((ptr1 + 0) as *const u8));
+              match l2 {
+                0 => {
+                  let e = {
+                    let l3 = *((ptr1 + 4) as *const i32);
+                    
+                    l3 as u32
+                  };
+                  Ok(e)
+                }
+                1 => {
+                  let e = {
+                    let l4 = i32::from(*((ptr1 + 4) as *const u8));
+                    
+                    super::super::super::wasi::nn::errors::Error::_lift(l4 as u8)
+                  };
+                  Err(e)
+                }
+                _ => wit_bindgen::rt::invalid_enum_discriminant(),
+              }
+            }
+          }
+          
+        }
+        
+        
+        #[allow(clippy::all)]
+        pub mod inference {
+          #[used]
+          #[doc(hidden)]
+          #[cfg(target_arch = "wasm32")]
+          static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+          pub type Error = super::super::super::wasi::nn::errors::Error;
+          pub type Tensor = super::super::super::wasi::nn::tensor::Tensor;
+          pub type TensorData = super::super::super::wasi::nn::tensor::TensorData;
+          pub type Graph = super::super::super::wasi::nn::graph::Graph;
+          /// Bind a `graph` to the input and output tensors for an inference.
+          /// 
+          /// TODO: this is no longer necessary in WIT (https://github.com/WebAssembly/wasi-nn/issues/43)
+          pub type GraphExecutionContext = u32;
+          #[allow(unused_unsafe, clippy::all)]
+          /// Create an execution instance of a loaded graph.
+          pub fn init_execution_context(graph: Graph,) -> Result<GraphExecutionContext,Error>{
+            
+            #[allow(unused_imports)]
+            use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+            unsafe {
+              
+              #[repr(align(4))]
+              struct RetArea([u8; 8]);
+              let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+              let ptr0 = ret_area.as_mut_ptr() as i32;
+              #[cfg(target_arch = "wasm32")]
+              #[link(wasm_import_module = "wasi:nn/inference")]
+              extern "C" {
+                #[link_name = "init-execution-context"]
+                fn wit_import(_: i32, _: i32, );
+              }
+              
+              #[cfg(not(target_arch = "wasm32"))]
+              fn wit_import(_: i32, _: i32, ){ unreachable!() }
+              wit_import(wit_bindgen::rt::as_i32(graph), ptr0);
+              let l1 = i32::from(*((ptr0 + 0) as *const u8));
+              match l1 {
+                0 => {
+                  let e = {
+                    let l2 = *((ptr0 + 4) as *const i32);
+                    
+                    l2 as u32
+                  };
+                  Ok(e)
+                }
+                1 => {
+                  let e = {
+                    let l3 = i32::from(*((ptr0 + 4) as *const u8));
+                    
+                    super::super::super::wasi::nn::errors::Error::_lift(l3 as u8)
+                  };
+                  Err(e)
+                }
+                _ => wit_bindgen::rt::invalid_enum_discriminant(),
+              }
+            }
+          }
+          #[allow(unused_unsafe, clippy::all)]
+          /// Define the inputs to use for inference.
+          pub fn set_input(ctx: GraphExecutionContext,index: u32,tensor: &Tensor,) -> Result<(),Error>{
+            
+            #[allow(unused_imports)]
+            use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+            unsafe {
+              
+              #[repr(align(1))]
+              struct RetArea([u8; 2]);
+              let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+              let super::super::super::wasi::nn::tensor::Tensor{ dimensions:dimensions0, tensor_type:tensor_type0, data:data0, } = tensor;
+              let vec1 = dimensions0;
+              let ptr1 = vec1.as_ptr() as i32;
+              let len1 = vec1.len() as i32;
+              let vec2 = data0;
+              let ptr2 = vec2.as_ptr() as i32;
+              let len2 = vec2.len() as i32;
+              let ptr3 = ret_area.as_mut_ptr() as i32;
+              #[cfg(target_arch = "wasm32")]
+              #[link(wasm_import_module = "wasi:nn/inference")]
+              extern "C" {
+                #[link_name = "set-input"]
+                fn wit_import(_: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, );
+              }
+              
+              #[cfg(not(target_arch = "wasm32"))]
+              fn wit_import(_: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, ){ unreachable!() }
+              wit_import(wit_bindgen::rt::as_i32(ctx), wit_bindgen::rt::as_i32(index), ptr1, len1, tensor_type0.clone() as i32, ptr2, len2, ptr3);
+              let l4 = i32::from(*((ptr3 + 0) as *const u8));
+              match l4 {
+                0 => {
+                  let e = ();
+                  Ok(e)
+                }
+                1 => {
+                  let e = {
+                    let l5 = i32::from(*((ptr3 + 1) as *const u8));
+                    
+                    super::super::super::wasi::nn::errors::Error::_lift(l5 as u8)
+                  };
+                  Err(e)
+                }
+                _ => wit_bindgen::rt::invalid_enum_discriminant(),
+              }
+            }
+          }
+          #[allow(unused_unsafe, clippy::all)]
+          /// Compute the inference on the given inputs.
+          /// 
+          /// Note the expected sequence of calls: `set-input`, `compute`, `get-output`. TODO: this
+          /// expectation could be removed as a part of https://github.com/WebAssembly/wasi-nn/issues/43.
+          pub fn compute(ctx: GraphExecutionContext,) -> Result<(),Error>{
+            
+            #[allow(unused_imports)]
+            use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+            unsafe {
+              
+              #[repr(align(1))]
+              struct RetArea([u8; 2]);
+              let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+              let ptr0 = ret_area.as_mut_ptr() as i32;
+              #[cfg(target_arch = "wasm32")]
+              #[link(wasm_import_module = "wasi:nn/inference")]
+              extern "C" {
+                #[link_name = "compute"]
+                fn wit_import(_: i32, _: i32, );
+              }
+              
+              #[cfg(not(target_arch = "wasm32"))]
+              fn wit_import(_: i32, _: i32, ){ unreachable!() }
+              wit_import(wit_bindgen::rt::as_i32(ctx), ptr0);
+              let l1 = i32::from(*((ptr0 + 0) as *const u8));
+              match l1 {
+                0 => {
+                  let e = ();
+                  Ok(e)
+                }
+                1 => {
+                  let e = {
+                    let l2 = i32::from(*((ptr0 + 1) as *const u8));
+                    
+                    super::super::super::wasi::nn::errors::Error::_lift(l2 as u8)
+                  };
+                  Err(e)
+                }
+                _ => wit_bindgen::rt::invalid_enum_discriminant(),
+              }
+            }
+          }
+          #[allow(unused_unsafe, clippy::all)]
+          /// Extract the outputs after inference.
+          pub fn get_output(ctx: GraphExecutionContext,index: u32,) -> Result<TensorData,Error>{
+            
+            #[allow(unused_imports)]
+            use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+            unsafe {
+              
+              #[repr(align(4))]
+              struct RetArea([u8; 12]);
+              let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+              let ptr0 = ret_area.as_mut_ptr() as i32;
+              #[cfg(target_arch = "wasm32")]
+              #[link(wasm_import_module = "wasi:nn/inference")]
+              extern "C" {
+                #[link_name = "get-output"]
+                fn wit_import(_: i32, _: i32, _: i32, );
+              }
+              
+              #[cfg(not(target_arch = "wasm32"))]
+              fn wit_import(_: i32, _: i32, _: i32, ){ unreachable!() }
+              wit_import(wit_bindgen::rt::as_i32(ctx), wit_bindgen::rt::as_i32(index), ptr0);
+              let l1 = i32::from(*((ptr0 + 0) as *const u8));
+              match l1 {
+                0 => {
+                  let e = {
+                    let l2 = *((ptr0 + 4) as *const i32);
+                    let l3 = *((ptr0 + 8) as *const i32);
+                    let len4 = l3 as usize;
+                    
+                    Vec::from_raw_parts(l2 as *mut _, len4, len4)
+                  };
+                  Ok(e)
+                }
+                1 => {
+                  let e = {
+                    let l5 = i32::from(*((ptr0 + 4) as *const u8));
+                    
+                    super::super::super::wasi::nn::errors::Error::_lift(l5 as u8)
+                  };
+                  Err(e)
+                }
+                _ => wit_bindgen::rt::invalid_enum_discriminant(),
+              }
+            }
+          }
+          
+        }
+        
+      }
+      pub mod random {
+        
+        #[allow(clippy::all)]
+        pub mod random {
+          #[used]
+          #[doc(hidden)]
+          #[cfg(target_arch = "wasm32")]
+          static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+          #[allow(unused_unsafe, clippy::all)]
+          /// Return `len` cryptographically-secure random or pseudo-random bytes.
+          /// 
+          /// This function must produce data at least as cryptographically secure and
+          /// fast as an adequately seeded cryptographically-secure pseudo-random
+          /// number generator (CSPRNG). It must not block, from the perspective of
+          /// the calling program, under any circumstances, including on the first
+          /// request and on requests for numbers of bytes. The returned data must
+          /// always be unpredictable.
+          /// 
+          /// This function must always return fresh data. Deterministic environments
+          /// must omit this function, rather than implementing it with deterministic
+          /// data.
+          pub fn get_random_bytes(len: u64,) -> wit_bindgen::rt::vec::Vec::<u8>{
+            
+            #[allow(unused_imports)]
+            use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+            unsafe {
+              
+              #[repr(align(4))]
+              struct RetArea([u8; 8]);
+              let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+              let ptr0 = ret_area.as_mut_ptr() as i32;
+              #[cfg(target_arch = "wasm32")]
+              #[link(wasm_import_module = "wasi:random/random@0.2.0")]
+              extern "C" {
+                #[link_name = "get-random-bytes"]
+                fn wit_import(_: i64, _: i32, );
+              }
+              
+              #[cfg(not(target_arch = "wasm32"))]
+              fn wit_import(_: i64, _: i32, ){ unreachable!() }
+              wit_import(wit_bindgen::rt::as_i64(len), ptr0);
+              let l1 = *((ptr0 + 0) as *const i32);
+              let l2 = *((ptr0 + 4) as *const i32);
+              let len3 = l2 as usize;
+              Vec::from_raw_parts(l1 as *mut _, len3, len3)
+            }
+          }
+          #[allow(unused_unsafe, clippy::all)]
+          /// Return a cryptographically-secure random or pseudo-random `u64` value.
+          /// 
+          /// This function returns the same type of data as `get-random-bytes`,
+          /// represented as a `u64`.
+          pub fn get_random_u64() -> u64{
+            
+            #[allow(unused_imports)]
+            use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+            unsafe {
+              
+              #[cfg(target_arch = "wasm32")]
+              #[link(wasm_import_module = "wasi:random/random@0.2.0")]
+              extern "C" {
+                #[link_name = "get-random-u64"]
+                fn wit_import() -> i64;
+              }
+              
+              #[cfg(not(target_arch = "wasm32"))]
+              fn wit_import() -> i64{ unreachable!() }
+              let ret = wit_import();
+              ret as u64
+            }
+          }
+          
+        }
+        
+        
+        #[allow(clippy::all)]
+        pub mod insecure {
+          #[used]
+          #[doc(hidden)]
+          #[cfg(target_arch = "wasm32")]
+          static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+          #[allow(unused_unsafe, clippy::all)]
+          /// Return `len` insecure pseudo-random bytes.
+          /// 
+          /// This function is not cryptographically secure. Do not use it for
+          /// anything related to security.
+          /// 
+          /// There are no requirements on the values of the returned bytes, however
+          /// implementations are encouraged to return evenly distributed values with
+          /// a long period.
+          pub fn get_insecure_random_bytes(len: u64,) -> wit_bindgen::rt::vec::Vec::<u8>{
+            
+            #[allow(unused_imports)]
+            use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+            unsafe {
+              
+              #[repr(align(4))]
+              struct RetArea([u8; 8]);
+              let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+              let ptr0 = ret_area.as_mut_ptr() as i32;
+              #[cfg(target_arch = "wasm32")]
+              #[link(wasm_import_module = "wasi:random/insecure@0.2.0")]
+              extern "C" {
+                #[link_name = "get-insecure-random-bytes"]
+                fn wit_import(_: i64, _: i32, );
+              }
+              
+              #[cfg(not(target_arch = "wasm32"))]
+              fn wit_import(_: i64, _: i32, ){ unreachable!() }
+              wit_import(wit_bindgen::rt::as_i64(len), ptr0);
+              let l1 = *((ptr0 + 0) as *const i32);
+              let l2 = *((ptr0 + 4) as *const i32);
+              let len3 = l2 as usize;
+              Vec::from_raw_parts(l1 as *mut _, len3, len3)
+            }
+          }
+          #[allow(unused_unsafe, clippy::all)]
+          /// Return an insecure pseudo-random `u64` value.
+          /// 
+          /// This function returns the same type of pseudo-random data as
+          /// `get-insecure-random-bytes`, represented as a `u64`.
+          pub fn get_insecure_random_u64() -> u64{
+            
+            #[allow(unused_imports)]
+            use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+            unsafe {
+              
+              #[cfg(target_arch = "wasm32")]
+              #[link(wasm_import_module = "wasi:random/insecure@0.2.0")]
+              extern "C" {
+                #[link_name = "get-insecure-random-u64"]
+                fn wit_import() -> i64;
+              }
+              
+              #[cfg(not(target_arch = "wasm32"))]
+              fn wit_import() -> i64{ unreachable!() }
+              let ret = wit_import();
+              ret as u64
+            }
+          }
+          
+        }
+        
+        
+        #[allow(clippy::all)]
+        pub mod insecure_seed {
+          #[used]
+          #[doc(hidden)]
+          #[cfg(target_arch = "wasm32")]
+          static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+          #[allow(unused_unsafe, clippy::all)]
+          /// Return a 128-bit value that may contain a pseudo-random value.
+          /// 
+          /// The returned value is not required to be computed from a CSPRNG, and may
+          /// even be entirely deterministic. Host implementations are encouraged to
+          /// provide pseudo-random values to any program exposed to
+          /// attacker-controlled content, to enable DoS protection built into many
+          /// languages' hash-map implementations.
+          /// 
+          /// This function is intended to only be called once, by a source language
+          /// to initialize Denial Of Service (DoS) protection in its hash-map
+          /// implementation.
+          /// 
+          /// # Expected future evolution
+          /// 
+          /// This will likely be changed to a value import, to prevent it from being
+          /// called multiple times and potentially used for purposes other than DoS
+          /// protection.
+          pub fn insecure_seed() -> (u64,u64,){
+            
+            #[allow(unused_imports)]
+            use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+            unsafe {
+              
+              #[repr(align(8))]
+              struct RetArea([u8; 16]);
+              let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+              let ptr0 = ret_area.as_mut_ptr() as i32;
+              #[cfg(target_arch = "wasm32")]
+              #[link(wasm_import_module = "wasi:random/insecure-seed@0.2.0")]
+              extern "C" {
+                #[link_name = "insecure-seed"]
+                fn wit_import(_: i32, );
+              }
+              
+              #[cfg(not(target_arch = "wasm32"))]
+              fn wit_import(_: i32, ){ unreachable!() }
+              wit_import(ptr0);
+              let l1 = *((ptr0 + 0) as *const i64);
+              let l2 = *((ptr0 + 8) as *const i64);
+              (l1 as u64, l2 as u64)
+            }
+          }
+          
+        }
+        
+      }
+      pub mod sockets {
+        
+        #[allow(clippy::all)]
+        pub mod network {
+          #[used]
+          #[doc(hidden)]
+          #[cfg(target_arch = "wasm32")]
+          static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+          /// An opaque resource that represents access to (a subset of) the network.
+          /// This enables context-based security for networking.
+          /// There is no need for this to map 1:1 to a physical network interface.
+          
+          #[derive(Debug)]
+          #[repr(transparent)]
+          pub struct Network{
+            handle: wit_bindgen::rt::Resource<Network>,
+          }
+          
+          impl Network{
+            #[doc(hidden)]
+            pub unsafe fn from_handle(handle: u32) -> Self {
+              Self {
+                handle: wit_bindgen::rt::Resource::from_handle(handle),
+              }
+            }
+            
+            #[doc(hidden)]
+            pub fn into_handle(self) -> u32 {
+              wit_bindgen::rt::Resource::into_handle(self.handle)
+            }
+            
+            #[doc(hidden)]
+            pub fn handle(&self) -> u32 {
+              wit_bindgen::rt::Resource::handle(&self.handle)
+            }
+          }
+          
+          
+          unsafe impl wit_bindgen::rt::WasmResource for Network{
+            #[inline]
+            unsafe fn drop(_handle: u32) {
+              #[cfg(not(target_arch = "wasm32"))]
+              unreachable!();
+              
+              #[cfg(target_arch = "wasm32")]
+              {
+                #[link(wasm_import_module = "wasi:sockets/network@0.2.0")]
+                extern "C" {
+                  #[link_name = "[resource-drop]network"]
+                  fn drop(_: u32);
+                }
+                
+                drop(_handle);
+              }
+            }
+          }
+          
+          /// Error codes.
+          /// 
+          /// In theory, every API can return any error code.
+          /// In practice, API's typically only return the errors documented per API
+          /// combined with a couple of errors that are always possible:
+          /// - `unknown`
+          /// - `access-denied`
+          /// - `not-supported`
+          /// - `out-of-memory`
+          /// - `concurrency-conflict`
+          /// 
+          /// See each individual API for what the POSIX equivalents are. They sometimes differ per API.
+          #[repr(u8)]
+          #[derive(Clone, Copy, Eq, PartialEq)]
+          pub enum ErrorCode {
+            /// Unknown error
+            Unknown,
+            /// Access denied.
+            /// 
+            /// POSIX equivalent: EACCES, EPERM
+            AccessDenied,
+            /// The operation is not supported.
+            /// 
+            /// POSIX equivalent: EOPNOTSUPP
+            NotSupported,
+            /// One of the arguments is invalid.
+            /// 
+            /// POSIX equivalent: EINVAL
+            InvalidArgument,
+            /// Not enough memory to complete the operation.
+            /// 
+            /// POSIX equivalent: ENOMEM, ENOBUFS, EAI_MEMORY
+            OutOfMemory,
+            /// The operation timed out before it could finish completely.
+            Timeout,
+            /// This operation is incompatible with another asynchronous operation that is already in progress.
+            /// 
+            /// POSIX equivalent: EALREADY
+            ConcurrencyConflict,
+            /// Trying to finish an asynchronous operation that:
+            /// - has not been started yet, or:
+            /// - was already finished by a previous `finish-*` call.
+            /// 
+            /// Note: this is scheduled to be removed when `future`s are natively supported.
+            NotInProgress,
+            /// The operation has been aborted because it could not be completed immediately.
+            /// 
+            /// Note: this is scheduled to be removed when `future`s are natively supported.
+            WouldBlock,
+            /// The operation is not valid in the socket's current state.
+            InvalidState,
+            /// A new socket resource could not be created because of a system limit.
+            NewSocketLimit,
+            /// A bind operation failed because the provided address is not an address that the `network` can bind to.
+            AddressNotBindable,
+            /// A bind operation failed because the provided address is already in use or because there are no ephemeral ports available.
+            AddressInUse,
+            /// The remote address is not reachable
+            RemoteUnreachable,
+            /// The TCP connection was forcefully rejected
+            ConnectionRefused,
+            /// The TCP connection was reset.
+            ConnectionReset,
+            /// A TCP connection was aborted.
+            ConnectionAborted,
+            /// The size of a datagram sent to a UDP socket exceeded the maximum
+            /// supported size.
+            DatagramTooLarge,
+            /// Name does not exist or has no suitable associated IP addresses.
+            NameUnresolvable,
+            /// A temporary failure in name resolution occurred.
+            TemporaryResolverFailure,
+            /// A permanent failure in name resolution occurred.
+            PermanentResolverFailure,
+          }
+          impl ErrorCode{
+            pub fn name(&self) -> &'static str {
+              match self {
+                ErrorCode::Unknown => "unknown",
+                ErrorCode::AccessDenied => "access-denied",
+                ErrorCode::NotSupported => "not-supported",
+                ErrorCode::InvalidArgument => "invalid-argument",
+                ErrorCode::OutOfMemory => "out-of-memory",
+                ErrorCode::Timeout => "timeout",
+                ErrorCode::ConcurrencyConflict => "concurrency-conflict",
+                ErrorCode::NotInProgress => "not-in-progress",
+                ErrorCode::WouldBlock => "would-block",
+                ErrorCode::InvalidState => "invalid-state",
+                ErrorCode::NewSocketLimit => "new-socket-limit",
+                ErrorCode::AddressNotBindable => "address-not-bindable",
+                ErrorCode::AddressInUse => "address-in-use",
+                ErrorCode::RemoteUnreachable => "remote-unreachable",
+                ErrorCode::ConnectionRefused => "connection-refused",
+                ErrorCode::ConnectionReset => "connection-reset",
+                ErrorCode::ConnectionAborted => "connection-aborted",
+                ErrorCode::DatagramTooLarge => "datagram-too-large",
+                ErrorCode::NameUnresolvable => "name-unresolvable",
+                ErrorCode::TemporaryResolverFailure => "temporary-resolver-failure",
+                ErrorCode::PermanentResolverFailure => "permanent-resolver-failure",
+              }
+            }
+            pub fn message(&self) -> &'static str {
+              match self {
+                ErrorCode::Unknown => "Unknown error",
+                ErrorCode::AccessDenied => "Access denied.
+                
+                POSIX equivalent: EACCES, EPERM",
+                ErrorCode::NotSupported => "The operation is not supported.
+                
+                POSIX equivalent: EOPNOTSUPP",
+                ErrorCode::InvalidArgument => "One of the arguments is invalid.
+                
+                POSIX equivalent: EINVAL",
+                ErrorCode::OutOfMemory => "Not enough memory to complete the operation.
+                
+                POSIX equivalent: ENOMEM, ENOBUFS, EAI_MEMORY",
+                ErrorCode::Timeout => "The operation timed out before it could finish completely.",
+                ErrorCode::ConcurrencyConflict => "This operation is incompatible with another asynchronous operation that is already in progress.
+                
+                POSIX equivalent: EALREADY",
+                ErrorCode::NotInProgress => "Trying to finish an asynchronous operation that:
+                - has not been started yet, or:
+                - was already finished by a previous `finish-*` call.
+                
+                Note: this is scheduled to be removed when `future`s are natively supported.",
+                ErrorCode::WouldBlock => "The operation has been aborted because it could not be completed immediately.
+                
+                Note: this is scheduled to be removed when `future`s are natively supported.",
+                ErrorCode::InvalidState => "The operation is not valid in the socket's current state.",
+                ErrorCode::NewSocketLimit => "A new socket resource could not be created because of a system limit.",
+                ErrorCode::AddressNotBindable => "A bind operation failed because the provided address is not an address that the `network` can bind to.",
+                ErrorCode::AddressInUse => "A bind operation failed because the provided address is already in use or because there are no ephemeral ports available.",
+                ErrorCode::RemoteUnreachable => "The remote address is not reachable",
+                ErrorCode::ConnectionRefused => "The TCP connection was forcefully rejected",
+                ErrorCode::ConnectionReset => "The TCP connection was reset.",
+                ErrorCode::ConnectionAborted => "A TCP connection was aborted.",
+                ErrorCode::DatagramTooLarge => "The size of a datagram sent to a UDP socket exceeded the maximum
+                supported size.",
+                ErrorCode::NameUnresolvable => "Name does not exist or has no suitable associated IP addresses.",
+                ErrorCode::TemporaryResolverFailure => "A temporary failure in name resolution occurred.",
+                ErrorCode::PermanentResolverFailure => "A permanent failure in name resolution occurred.",
+              }
+            }
+          }
+          impl ::core::fmt::Debug for ErrorCode{
+            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+              f.debug_struct("ErrorCode")
+              .field("code", &(*self as i32))
+              .field("name", &self.name())
+              .field("message", &self.message())
+              .finish()
+            }
+          }
+          impl ::core::fmt::Display for ErrorCode{
+            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+              write!(f, "{} (error {})", self.name(), *self as i32)
+            }
+          }
+          
+          impl std::error::Error for ErrorCode{}
+          
+          impl ErrorCode{
+            pub(crate) unsafe fn _lift(val: u8) -> ErrorCode{
+              if !cfg!(debug_assertions) {
+                return ::core::mem::transmute(val);
+              }
+              
+              match val {
+                0 => ErrorCode::Unknown,
+                1 => ErrorCode::AccessDenied,
+                2 => ErrorCode::NotSupported,
+                3 => ErrorCode::InvalidArgument,
+                4 => ErrorCode::OutOfMemory,
+                5 => ErrorCode::Timeout,
+                6 => ErrorCode::ConcurrencyConflict,
+                7 => ErrorCode::NotInProgress,
+                8 => ErrorCode::WouldBlock,
+                9 => ErrorCode::InvalidState,
+                10 => ErrorCode::NewSocketLimit,
+                11 => ErrorCode::AddressNotBindable,
+                12 => ErrorCode::AddressInUse,
+                13 => ErrorCode::RemoteUnreachable,
+                14 => ErrorCode::ConnectionRefused,
+                15 => ErrorCode::ConnectionReset,
+                16 => ErrorCode::ConnectionAborted,
+                17 => ErrorCode::DatagramTooLarge,
+                18 => ErrorCode::NameUnresolvable,
+                19 => ErrorCode::TemporaryResolverFailure,
+                20 => ErrorCode::PermanentResolverFailure,
+                
+                _ => panic!("invalid enum discriminant"),
+              }
+            }
+          }
+          
+          #[repr(u8)]
+          #[derive(Clone, Copy, Eq, PartialEq)]
+          pub enum IpAddressFamily {
+            /// Similar to `AF_INET` in POSIX.
+            Ipv4,
+            /// Similar to `AF_INET6` in POSIX.
+            Ipv6,
+          }
+          impl ::core::fmt::Debug for IpAddressFamily {
+            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+              match self {
+                IpAddressFamily::Ipv4 => {
+                  f.debug_tuple("IpAddressFamily::Ipv4").finish()
+                }
+                IpAddressFamily::Ipv6 => {
+                  f.debug_tuple("IpAddressFamily::Ipv6").finish()
+                }
+              }
+            }
+          }
+          
+          impl IpAddressFamily{
+            pub(crate) unsafe fn _lift(val: u8) -> IpAddressFamily{
+              if !cfg!(debug_assertions) {
+                return ::core::mem::transmute(val);
+              }
+              
+              match val {
+                0 => IpAddressFamily::Ipv4,
+                1 => IpAddressFamily::Ipv6,
+                
+                _ => panic!("invalid enum discriminant"),
+              }
+            }
+          }
+          
+          pub type Ipv4Address = (u8,u8,u8,u8,);
+          pub type Ipv6Address = (u16,u16,u16,u16,u16,u16,u16,u16,);
+          #[derive(Clone, Copy)]
+          pub enum IpAddress{
+            Ipv4(Ipv4Address),
+            Ipv6(Ipv6Address),
+          }
+          impl ::core::fmt::Debug for IpAddress {
+            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+              match self {
+                IpAddress::Ipv4(e) => {
+                  f.debug_tuple("IpAddress::Ipv4").field(e).finish()
+                }
+                IpAddress::Ipv6(e) => {
+                  f.debug_tuple("IpAddress::Ipv6").field(e).finish()
+                }
+              }
+            }
+          }
+          #[repr(C)]
+          #[derive(Clone, Copy)]
+          pub struct Ipv4SocketAddress {
+            /// sin_port
+            pub port: u16,
+            /// sin_addr
+            pub address: Ipv4Address,
+          }
+          impl ::core::fmt::Debug for Ipv4SocketAddress {
+            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+              f.debug_struct("Ipv4SocketAddress").field("port", &self.port).field("address", &self.address).finish()
+            }
+          }
+          #[repr(C)]
+          #[derive(Clone, Copy)]
+          pub struct Ipv6SocketAddress {
+            /// sin6_port
+            pub port: u16,
+            /// sin6_flowinfo
+            pub flow_info: u32,
+            /// sin6_addr
+            pub address: Ipv6Address,
+            /// sin6_scope_id
+            pub scope_id: u32,
+          }
+          impl ::core::fmt::Debug for Ipv6SocketAddress {
+            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+              f.debug_struct("Ipv6SocketAddress").field("port", &self.port).field("flow-info", &self.flow_info).field("address", &self.address).field("scope-id", &self.scope_id).finish()
+            }
+          }
+          #[derive(Clone, Copy)]
+          pub enum IpSocketAddress{
+            Ipv4(Ipv4SocketAddress),
+            Ipv6(Ipv6SocketAddress),
+          }
+          impl ::core::fmt::Debug for IpSocketAddress {
+            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+              match self {
+                IpSocketAddress::Ipv4(e) => {
+                  f.debug_tuple("IpSocketAddress::Ipv4").field(e).finish()
+                }
+                IpSocketAddress::Ipv6(e) => {
+                  f.debug_tuple("IpSocketAddress::Ipv6").field(e).finish()
+                }
+              }
+            }
+          }
+          
+        }
+        
+        
+        #[allow(clippy::all)]
+        pub mod instance_network {
+          #[used]
+          #[doc(hidden)]
+          #[cfg(target_arch = "wasm32")]
+          static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+          pub type Network = super::super::super::wasi::sockets::network::Network;
+          #[allow(unused_unsafe, clippy::all)]
+          /// Get a handle to the default network.
+          pub fn instance_network() -> Network{
+            
+            #[allow(unused_imports)]
+            use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+            unsafe {
+              
+              #[cfg(target_arch = "wasm32")]
+              #[link(wasm_import_module = "wasi:sockets/instance-network@0.2.0")]
+              extern "C" {
+                #[link_name = "instance-network"]
+                fn wit_import() -> i32;
+              }
+              
+              #[cfg(not(target_arch = "wasm32"))]
+              fn wit_import() -> i32{ unreachable!() }
+              let ret = wit_import();
+              super::super::super::wasi::sockets::network::Network::from_handle(ret as u32)
+            }
+          }
+          
+        }
+        
+        
+        #[allow(clippy::all)]
+        pub mod udp {
+          #[used]
+          #[doc(hidden)]
+          #[cfg(target_arch = "wasm32")]
+          static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+          pub type Pollable = super::super::super::wasi::io::poll::Pollable;
+          pub type Network = super::super::super::wasi::sockets::network::Network;
+          pub type ErrorCode = super::super::super::wasi::sockets::network::ErrorCode;
+          pub type IpSocketAddress = super::super::super::wasi::sockets::network::IpSocketAddress;
+          pub type IpAddressFamily = super::super::super::wasi::sockets::network::IpAddressFamily;
+          /// A received datagram.
+          #[derive(Clone)]
+          pub struct IncomingDatagram {
+            /// The payload.
+            /// 
+            /// Theoretical max size: ~64 KiB. In practice, typically less than 1500 bytes.
+            pub data: wit_bindgen::rt::vec::Vec::<u8>,
+            /// The source address.
+            /// 
+            /// This field is guaranteed to match the remote address the stream was initialized with, if any.
+            /// 
+            /// Equivalent to the `src_addr` out parameter of `recvfrom`.
+            pub remote_address: IpSocketAddress,
+          }
+          impl ::core::fmt::Debug for IncomingDatagram {
+            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+              f.debug_struct("IncomingDatagram").field("data", &self.data).field("remote-address", &self.remote_address).finish()
+            }
+          }
+          /// A datagram to be sent out.
+          #[derive(Clone)]
+          pub struct OutgoingDatagram {
+            /// The payload.
+            pub data: wit_bindgen::rt::vec::Vec::<u8>,
+            /// The destination address.
+            /// 
+            /// The requirements on this field depend on how the stream was initialized:
+            /// - with a remote address: this field must be None or match the stream's remote address exactly.
+            /// - without a remote address: this field is required.
+            /// 
+            /// If this value is None, the send operation is equivalent to `send` in POSIX. Otherwise it is equivalent to `sendto`.
+            pub remote_address: Option<IpSocketAddress>,
+          }
+          impl ::core::fmt::Debug for OutgoingDatagram {
+            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+              f.debug_struct("OutgoingDatagram").field("data", &self.data).field("remote-address", &self.remote_address).finish()
+            }
+          }
+          /// A UDP socket handle.
+          
+          #[derive(Debug)]
+          #[repr(transparent)]
+          pub struct UdpSocket{
+            handle: wit_bindgen::rt::Resource<UdpSocket>,
+          }
+          
+          impl UdpSocket{
+            #[doc(hidden)]
+            pub unsafe fn from_handle(handle: u32) -> Self {
+              Self {
+                handle: wit_bindgen::rt::Resource::from_handle(handle),
+              }
+            }
+            
+            #[doc(hidden)]
+            pub fn into_handle(self) -> u32 {
+              wit_bindgen::rt::Resource::into_handle(self.handle)
+            }
+            
+            #[doc(hidden)]
+            pub fn handle(&self) -> u32 {
+              wit_bindgen::rt::Resource::handle(&self.handle)
+            }
+          }
+          
+          
+          unsafe impl wit_bindgen::rt::WasmResource for UdpSocket{
+            #[inline]
+            unsafe fn drop(_handle: u32) {
+              #[cfg(not(target_arch = "wasm32"))]
+              unreachable!();
+              
+              #[cfg(target_arch = "wasm32")]
+              {
+                #[link(wasm_import_module = "wasi:sockets/udp@0.2.0")]
+                extern "C" {
+                  #[link_name = "[resource-drop]udp-socket"]
+                  fn drop(_: u32);
+                }
+                
+                drop(_handle);
+              }
+            }
+          }
+          
+          
+          #[derive(Debug)]
+          #[repr(transparent)]
+          pub struct IncomingDatagramStream{
+            handle: wit_bindgen::rt::Resource<IncomingDatagramStream>,
+          }
+          
+          impl IncomingDatagramStream{
+            #[doc(hidden)]
+            pub unsafe fn from_handle(handle: u32) -> Self {
+              Self {
+                handle: wit_bindgen::rt::Resource::from_handle(handle),
+              }
+            }
+            
+            #[doc(hidden)]
+            pub fn into_handle(self) -> u32 {
+              wit_bindgen::rt::Resource::into_handle(self.handle)
+            }
+            
+            #[doc(hidden)]
+            pub fn handle(&self) -> u32 {
+              wit_bindgen::rt::Resource::handle(&self.handle)
+            }
+          }
+          
+          
+          unsafe impl wit_bindgen::rt::WasmResource for IncomingDatagramStream{
+            #[inline]
+            unsafe fn drop(_handle: u32) {
+              #[cfg(not(target_arch = "wasm32"))]
+              unreachable!();
+              
+              #[cfg(target_arch = "wasm32")]
+              {
+                #[link(wasm_import_module = "wasi:sockets/udp@0.2.0")]
+                extern "C" {
+                  #[link_name = "[resource-drop]incoming-datagram-stream"]
+                  fn drop(_: u32);
+                }
+                
+                drop(_handle);
+              }
+            }
+          }
+          
+          
+          #[derive(Debug)]
+          #[repr(transparent)]
+          pub struct OutgoingDatagramStream{
+            handle: wit_bindgen::rt::Resource<OutgoingDatagramStream>,
+          }
+          
+          impl OutgoingDatagramStream{
+            #[doc(hidden)]
+            pub unsafe fn from_handle(handle: u32) -> Self {
+              Self {
+                handle: wit_bindgen::rt::Resource::from_handle(handle),
+              }
+            }
+            
+            #[doc(hidden)]
+            pub fn into_handle(self) -> u32 {
+              wit_bindgen::rt::Resource::into_handle(self.handle)
+            }
+            
+            #[doc(hidden)]
+            pub fn handle(&self) -> u32 {
+              wit_bindgen::rt::Resource::handle(&self.handle)
+            }
+          }
+          
+          
+          unsafe impl wit_bindgen::rt::WasmResource for OutgoingDatagramStream{
+            #[inline]
+            unsafe fn drop(_handle: u32) {
+              #[cfg(not(target_arch = "wasm32"))]
+              unreachable!();
+              
+              #[cfg(target_arch = "wasm32")]
+              {
+                #[link(wasm_import_module = "wasi:sockets/udp@0.2.0")]
+                extern "C" {
+                  #[link_name = "[resource-drop]outgoing-datagram-stream"]
+                  fn drop(_: u32);
+                }
+                
+                drop(_handle);
+              }
+            }
+          }
+          
+          impl UdpSocket {
+            #[allow(unused_unsafe, clippy::all)]
+            /// Bind the socket to a specific network on the provided IP address and port.
+            /// 
+            /// If the IP address is zero (`0.0.0.0` in IPv4, `::` in IPv6), it is left to the implementation to decide which
+            /// network interface(s) to bind to.
+            /// If the port is zero, the socket will be bound to a random free port.
+            /// 
+            /// # Typical errors
+            /// - `invalid-argument`:          The `local-address` has the wrong address family. (EAFNOSUPPORT, EFAULT on Windows)
+            /// - `invalid-state`:             The socket is already bound. (EINVAL)
+            /// - `address-in-use`:            No ephemeral ports available. (EADDRINUSE, ENOBUFS on Windows)
+            /// - `address-in-use`:            Address is already in use. (EADDRINUSE)
+            /// - `address-not-bindable`:      `local-address` is not an address that the `network` can bind to. (EADDRNOTAVAIL)
+            /// - `not-in-progress`:           A `bind` operation is not in progress.
+            /// - `would-block`:               Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)
+            /// 
+            /// # Implementors note
+            /// Unlike in POSIX, in WASI the bind operation is async. This enables
+            /// interactive WASI hosts to inject permission prompts. Runtimes that
+            /// don't want to make use of this ability can simply call the native
+            /// `bind` as part of either `start-bind` or `finish-bind`.
+            /// 
+            /// # References
+            /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/bind.html>
+            /// - <https://man7.org/linux/man-pages/man2/bind.2.html>
+            /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-bind>
+            /// - <https://man.freebsd.org/cgi/man.cgi?query=bind&sektion=2&format=html>
+            pub fn start_bind(&self,network: &Network,local_address: IpSocketAddress,) -> Result<(),ErrorCode>{
+              
+              #[allow(unused_imports)]
+              use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+              unsafe {
+                
+                #[repr(align(1))]
+                struct RetArea([u8; 2]);
+                let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                use super::super::super::wasi::sockets::network::IpSocketAddress as V4;
+                let (result5_0,result5_1,result5_2,result5_3,result5_4,result5_5,result5_6,result5_7,result5_8,result5_9,result5_10,result5_11,) = match local_address {
+                  V4::Ipv4(e) => {
+                    let super::super::super::wasi::sockets::network::Ipv4SocketAddress{ port:port0, address:address0, } = e;
+                    let (t1_0, t1_1, t1_2, t1_3, ) = address0;
+                    
+                    (0i32, wit_bindgen::rt::as_i32(port0), wit_bindgen::rt::as_i32(t1_0), wit_bindgen::rt::as_i32(t1_1), wit_bindgen::rt::as_i32(t1_2), wit_bindgen::rt::as_i32(t1_3), 0i32, 0i32, 0i32, 0i32, 0i32, 0i32)
+                  },
+                  V4::Ipv6(e) => {
+                    let super::super::super::wasi::sockets::network::Ipv6SocketAddress{ port:port2, flow_info:flow_info2, address:address2, scope_id:scope_id2, } = e;
+                    let (t3_0, t3_1, t3_2, t3_3, t3_4, t3_5, t3_6, t3_7, ) = address2;
+                    
+                    (1i32, wit_bindgen::rt::as_i32(port2), wit_bindgen::rt::as_i32(flow_info2), wit_bindgen::rt::as_i32(t3_0), wit_bindgen::rt::as_i32(t3_1), wit_bindgen::rt::as_i32(t3_2), wit_bindgen::rt::as_i32(t3_3), wit_bindgen::rt::as_i32(t3_4), wit_bindgen::rt::as_i32(t3_5), wit_bindgen::rt::as_i32(t3_6), wit_bindgen::rt::as_i32(t3_7), wit_bindgen::rt::as_i32(scope_id2))
+                  },
+                };
+                let ptr6 = ret_area.as_mut_ptr() as i32;
+                #[cfg(target_arch = "wasm32")]
+                #[link(wasm_import_module = "wasi:sockets/udp@0.2.0")]
+                extern "C" {
+                  #[link_name = "[method]udp-socket.start-bind"]
+                  fn wit_import(_: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, );
+                }
+                
+                #[cfg(not(target_arch = "wasm32"))]
+                fn wit_import(_: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, ){ unreachable!() }
+                wit_import((self).handle() as i32, (network).handle() as i32, result5_0, result5_1, result5_2, result5_3, result5_4, result5_5, result5_6, result5_7, result5_8, result5_9, result5_10, result5_11, ptr6);
+                let l7 = i32::from(*((ptr6 + 0) as *const u8));
+                match l7 {
+                  0 => {
+                    let e = ();
+                    Ok(e)
+                  }
+                  1 => {
+                    let e = {
+                      let l8 = i32::from(*((ptr6 + 1) as *const u8));
+                      
+                      super::super::super::wasi::sockets::network::ErrorCode::_lift(l8 as u8)
+                    };
+                    Err(e)
+                  }
+                  _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                }
+              }
+            }
+          }
+          impl UdpSocket {
+            #[allow(unused_unsafe, clippy::all)]
+            pub fn finish_bind(&self,) -> Result<(),ErrorCode>{
+              
+              #[allow(unused_imports)]
+              use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+              unsafe {
+                
+                #[repr(align(1))]
+                struct RetArea([u8; 2]);
+                let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                let ptr0 = ret_area.as_mut_ptr() as i32;
+                #[cfg(target_arch = "wasm32")]
+                #[link(wasm_import_module = "wasi:sockets/udp@0.2.0")]
+                extern "C" {
+                  #[link_name = "[method]udp-socket.finish-bind"]
+                  fn wit_import(_: i32, _: i32, );
+                }
+                
+                #[cfg(not(target_arch = "wasm32"))]
+                fn wit_import(_: i32, _: i32, ){ unreachable!() }
+                wit_import((self).handle() as i32, ptr0);
+                let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                match l1 {
+                  0 => {
+                    let e = ();
+                    Ok(e)
+                  }
+                  1 => {
+                    let e = {
+                      let l2 = i32::from(*((ptr0 + 1) as *const u8));
+                      
+                      super::super::super::wasi::sockets::network::ErrorCode::_lift(l2 as u8)
+                    };
+                    Err(e)
+                  }
+                  _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                }
+              }
+            }
+          }
+          impl UdpSocket {
+            #[allow(unused_unsafe, clippy::all)]
+            /// Set up inbound & outbound communication channels, optionally to a specific peer.
+            /// 
+            /// This function only changes the local socket configuration and does not generate any network traffic.
+            /// On success, the `remote-address` of the socket is updated. The `local-address` may be updated as well,
+            /// based on the best network path to `remote-address`.
+            /// 
+            /// When a `remote-address` is provided, the returned streams are limited to communicating with that specific peer:
+            /// - `send` can only be used to send to this destination.
+            /// - `receive` will only return datagrams sent from the provided `remote-address`.
+            /// 
+            /// This method may be called multiple times on the same socket to change its association, but
+            /// only the most recently returned pair of streams will be operational. Implementations may trap if
+            /// the streams returned by a previous invocation haven't been dropped yet before calling `stream` again.
+            /// 
+            /// The POSIX equivalent in pseudo-code is:
+            /// ```text
+            /// if (was previously connected) {
+              /// connect(s, AF_UNSPEC)
+              /// }
+              /// if (remote_address is Some) {
+                /// connect(s, remote_address)
+                /// }
+                /// ```
+                /// 
+                /// Unlike in POSIX, the socket must already be explicitly bound.
+                /// 
+                /// # Typical errors
+                /// - `invalid-argument`:          The `remote-address` has the wrong address family. (EAFNOSUPPORT)
+                /// - `invalid-argument`:          The IP address in `remote-address` is set to INADDR_ANY (`0.0.0.0` / `::`). (EDESTADDRREQ, EADDRNOTAVAIL)
+                /// - `invalid-argument`:          The port in `remote-address` is set to 0. (EDESTADDRREQ, EADDRNOTAVAIL)
+                /// - `invalid-state`:             The socket is not bound.
+                /// - `address-in-use`:            Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE, EADDRNOTAVAIL on Linux, EAGAIN on BSD)
+                /// - `remote-unreachable`:        The remote address is not reachable. (ECONNRESET, ENETRESET, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
+                /// - `connection-refused`:        The connection was refused. (ECONNREFUSED)
+                /// 
+                /// # References
+                /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/connect.html>
+                /// - <https://man7.org/linux/man-pages/man2/connect.2.html>
+                /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-connect>
+                /// - <https://man.freebsd.org/cgi/man.cgi?connect>
+                pub fn stream(&self,remote_address: Option<IpSocketAddress>,) -> Result<(IncomingDatagramStream,OutgoingDatagramStream,),ErrorCode>{
+                  
+                  #[allow(unused_imports)]
+                  use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                  unsafe {
+                    
+                    #[repr(align(4))]
+                    struct RetArea([u8; 12]);
+                    let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                    let (result6_0,result6_1,result6_2,result6_3,result6_4,result6_5,result6_6,result6_7,result6_8,result6_9,result6_10,result6_11,result6_12,) = match remote_address {
+                      Some(e) => {
+                        use super::super::super::wasi::sockets::network::IpSocketAddress as V4;
+                        let (result5_0,result5_1,result5_2,result5_3,result5_4,result5_5,result5_6,result5_7,result5_8,result5_9,result5_10,result5_11,) = match e {
+                          V4::Ipv4(e) => {
+                            let super::super::super::wasi::sockets::network::Ipv4SocketAddress{ port:port0, address:address0, } = e;
+                            let (t1_0, t1_1, t1_2, t1_3, ) = address0;
+                            
+                            (0i32, wit_bindgen::rt::as_i32(port0), wit_bindgen::rt::as_i32(t1_0), wit_bindgen::rt::as_i32(t1_1), wit_bindgen::rt::as_i32(t1_2), wit_bindgen::rt::as_i32(t1_3), 0i32, 0i32, 0i32, 0i32, 0i32, 0i32)
+                          },
+                          V4::Ipv6(e) => {
+                            let super::super::super::wasi::sockets::network::Ipv6SocketAddress{ port:port2, flow_info:flow_info2, address:address2, scope_id:scope_id2, } = e;
+                            let (t3_0, t3_1, t3_2, t3_3, t3_4, t3_5, t3_6, t3_7, ) = address2;
+                            
+                            (1i32, wit_bindgen::rt::as_i32(port2), wit_bindgen::rt::as_i32(flow_info2), wit_bindgen::rt::as_i32(t3_0), wit_bindgen::rt::as_i32(t3_1), wit_bindgen::rt::as_i32(t3_2), wit_bindgen::rt::as_i32(t3_3), wit_bindgen::rt::as_i32(t3_4), wit_bindgen::rt::as_i32(t3_5), wit_bindgen::rt::as_i32(t3_6), wit_bindgen::rt::as_i32(t3_7), wit_bindgen::rt::as_i32(scope_id2))
+                          },
+                        };
+                        
+                        (1i32, result5_0, result5_1, result5_2, result5_3, result5_4, result5_5, result5_6, result5_7, result5_8, result5_9, result5_10, result5_11)
+                      },
+                      None => {
+                        (0i32, 0i32, 0i32, 0i32, 0i32, 0i32, 0i32, 0i32, 0i32, 0i32, 0i32, 0i32, 0i32)
+                      },
+                    };let ptr7 = ret_area.as_mut_ptr() as i32;
+                    #[cfg(target_arch = "wasm32")]
+                    #[link(wasm_import_module = "wasi:sockets/udp@0.2.0")]
+                    extern "C" {
+                      #[link_name = "[method]udp-socket.stream"]
+                      fn wit_import(_: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, );
+                    }
+                    
+                    #[cfg(not(target_arch = "wasm32"))]
+                    fn wit_import(_: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, ){ unreachable!() }
+                    wit_import((self).handle() as i32, result6_0, result6_1, result6_2, result6_3, result6_4, result6_5, result6_6, result6_7, result6_8, result6_9, result6_10, result6_11, result6_12, ptr7);
+                    let l8 = i32::from(*((ptr7 + 0) as *const u8));
+                    match l8 {
+                      0 => {
+                        let e = {
+                          let l9 = *((ptr7 + 4) as *const i32);
+                          let l10 = *((ptr7 + 8) as *const i32);
+                          
+                          (IncomingDatagramStream::from_handle(l9 as u32), OutgoingDatagramStream::from_handle(l10 as u32))
+                        };
+                        Ok(e)
+                      }
+                      1 => {
+                        let e = {
+                          let l11 = i32::from(*((ptr7 + 4) as *const u8));
+                          
+                          super::super::super::wasi::sockets::network::ErrorCode::_lift(l11 as u8)
+                        };
+                        Err(e)
+                      }
+                      _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                    }
+                  }
+                }
+              }
+              impl UdpSocket {
+                #[allow(unused_unsafe, clippy::all)]
+                /// Get the current bound address.
+                /// 
+                /// POSIX mentions:
+                /// > If the socket has not been bound to a local name, the value
+                /// > stored in the object pointed to by `address` is unspecified.
+                /// 
+                /// WASI is stricter and requires `local-address` to return `invalid-state` when the socket hasn't been bound yet.
+                /// 
+                /// # Typical errors
+                /// - `invalid-state`: The socket is not bound to any local address.
+                /// 
+                /// # References
+                /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsockname.html>
+                /// - <https://man7.org/linux/man-pages/man2/getsockname.2.html>
+                /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getsockname>
+                /// - <https://man.freebsd.org/cgi/man.cgi?getsockname>
+                pub fn local_address(&self,) -> Result<IpSocketAddress,ErrorCode>{
+                  
+                  #[allow(unused_imports)]
+                  use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                  unsafe {
+                    
+                    #[repr(align(4))]
+                    struct RetArea([u8; 36]);
+                    let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                    let ptr0 = ret_area.as_mut_ptr() as i32;
+                    #[cfg(target_arch = "wasm32")]
+                    #[link(wasm_import_module = "wasi:sockets/udp@0.2.0")]
+                    extern "C" {
+                      #[link_name = "[method]udp-socket.local-address"]
+                      fn wit_import(_: i32, _: i32, );
+                    }
+                    
+                    #[cfg(not(target_arch = "wasm32"))]
+                    fn wit_import(_: i32, _: i32, ){ unreachable!() }
+                    wit_import((self).handle() as i32, ptr0);
+                    let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                    match l1 {
+                      0 => {
+                        let e = {
+                          let l2 = i32::from(*((ptr0 + 4) as *const u8));
+                          use super::super::super::wasi::sockets::network::IpSocketAddress as V19;
+                          let v19 = match l2 {
+                            0 => {
+                              let e19 = {
+                                let l3 = i32::from(*((ptr0 + 8) as *const u16));
+                                let l4 = i32::from(*((ptr0 + 10) as *const u8));
+                                let l5 = i32::from(*((ptr0 + 11) as *const u8));
+                                let l6 = i32::from(*((ptr0 + 12) as *const u8));
+                                let l7 = i32::from(*((ptr0 + 13) as *const u8));
+                                
+                                super::super::super::wasi::sockets::network::Ipv4SocketAddress{
+                                  port: l3 as u16,
+                                  address: (l4 as u8, l5 as u8, l6 as u8, l7 as u8),
+                                }
+                              };
+                              V19::Ipv4(e19)
+                            }
+                            n => {
+                              debug_assert_eq!(n, 1, "invalid enum discriminant");
+                              let e19 = {
+                                let l8 = i32::from(*((ptr0 + 8) as *const u16));
+                                let l9 = *((ptr0 + 12) as *const i32);
+                                let l10 = i32::from(*((ptr0 + 16) as *const u16));
+                                let l11 = i32::from(*((ptr0 + 18) as *const u16));
+                                let l12 = i32::from(*((ptr0 + 20) as *const u16));
+                                let l13 = i32::from(*((ptr0 + 22) as *const u16));
+                                let l14 = i32::from(*((ptr0 + 24) as *const u16));
+                                let l15 = i32::from(*((ptr0 + 26) as *const u16));
+                                let l16 = i32::from(*((ptr0 + 28) as *const u16));
+                                let l17 = i32::from(*((ptr0 + 30) as *const u16));
+                                let l18 = *((ptr0 + 32) as *const i32);
+                                
+                                super::super::super::wasi::sockets::network::Ipv6SocketAddress{
+                                  port: l8 as u16,
+                                  flow_info: l9 as u32,
+                                  address: (l10 as u16, l11 as u16, l12 as u16, l13 as u16, l14 as u16, l15 as u16, l16 as u16, l17 as u16),
+                                  scope_id: l18 as u32,
+                                }
+                              };
+                              V19::Ipv6(e19)
+                            }
+                          };
+                          
+                          v19
+                        };
+                        Ok(e)
+                      }
+                      1 => {
+                        let e = {
+                          let l20 = i32::from(*((ptr0 + 4) as *const u8));
+                          
+                          super::super::super::wasi::sockets::network::ErrorCode::_lift(l20 as u8)
+                        };
+                        Err(e)
+                      }
+                      _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                    }
+                  }
+                }
+              }
+              impl UdpSocket {
+                #[allow(unused_unsafe, clippy::all)]
+                /// Get the address the socket is currently streaming to.
+                /// 
+                /// # Typical errors
+                /// - `invalid-state`: The socket is not streaming to a specific remote address. (ENOTCONN)
+                /// 
+                /// # References
+                /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpeername.html>
+                /// - <https://man7.org/linux/man-pages/man2/getpeername.2.html>
+                /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getpeername>
+                /// - <https://man.freebsd.org/cgi/man.cgi?query=getpeername&sektion=2&n=1>
+                pub fn remote_address(&self,) -> Result<IpSocketAddress,ErrorCode>{
+                  
+                  #[allow(unused_imports)]
+                  use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                  unsafe {
+                    
+                    #[repr(align(4))]
+                    struct RetArea([u8; 36]);
+                    let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                    let ptr0 = ret_area.as_mut_ptr() as i32;
+                    #[cfg(target_arch = "wasm32")]
+                    #[link(wasm_import_module = "wasi:sockets/udp@0.2.0")]
+                    extern "C" {
+                      #[link_name = "[method]udp-socket.remote-address"]
+                      fn wit_import(_: i32, _: i32, );
+                    }
+                    
+                    #[cfg(not(target_arch = "wasm32"))]
+                    fn wit_import(_: i32, _: i32, ){ unreachable!() }
+                    wit_import((self).handle() as i32, ptr0);
+                    let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                    match l1 {
+                      0 => {
+                        let e = {
+                          let l2 = i32::from(*((ptr0 + 4) as *const u8));
+                          use super::super::super::wasi::sockets::network::IpSocketAddress as V19;
+                          let v19 = match l2 {
+                            0 => {
+                              let e19 = {
+                                let l3 = i32::from(*((ptr0 + 8) as *const u16));
+                                let l4 = i32::from(*((ptr0 + 10) as *const u8));
+                                let l5 = i32::from(*((ptr0 + 11) as *const u8));
+                                let l6 = i32::from(*((ptr0 + 12) as *const u8));
+                                let l7 = i32::from(*((ptr0 + 13) as *const u8));
+                                
+                                super::super::super::wasi::sockets::network::Ipv4SocketAddress{
+                                  port: l3 as u16,
+                                  address: (l4 as u8, l5 as u8, l6 as u8, l7 as u8),
+                                }
+                              };
+                              V19::Ipv4(e19)
+                            }
+                            n => {
+                              debug_assert_eq!(n, 1, "invalid enum discriminant");
+                              let e19 = {
+                                let l8 = i32::from(*((ptr0 + 8) as *const u16));
+                                let l9 = *((ptr0 + 12) as *const i32);
+                                let l10 = i32::from(*((ptr0 + 16) as *const u16));
+                                let l11 = i32::from(*((ptr0 + 18) as *const u16));
+                                let l12 = i32::from(*((ptr0 + 20) as *const u16));
+                                let l13 = i32::from(*((ptr0 + 22) as *const u16));
+                                let l14 = i32::from(*((ptr0 + 24) as *const u16));
+                                let l15 = i32::from(*((ptr0 + 26) as *const u16));
+                                let l16 = i32::from(*((ptr0 + 28) as *const u16));
+                                let l17 = i32::from(*((ptr0 + 30) as *const u16));
+                                let l18 = *((ptr0 + 32) as *const i32);
+                                
+                                super::super::super::wasi::sockets::network::Ipv6SocketAddress{
+                                  port: l8 as u16,
+                                  flow_info: l9 as u32,
+                                  address: (l10 as u16, l11 as u16, l12 as u16, l13 as u16, l14 as u16, l15 as u16, l16 as u16, l17 as u16),
+                                  scope_id: l18 as u32,
+                                }
+                              };
+                              V19::Ipv6(e19)
+                            }
+                          };
+                          
+                          v19
+                        };
+                        Ok(e)
+                      }
+                      1 => {
+                        let e = {
+                          let l20 = i32::from(*((ptr0 + 4) as *const u8));
+                          
+                          super::super::super::wasi::sockets::network::ErrorCode::_lift(l20 as u8)
+                        };
+                        Err(e)
+                      }
+                      _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                    }
+                  }
+                }
+              }
+              impl UdpSocket {
+                #[allow(unused_unsafe, clippy::all)]
+                /// Whether this is a IPv4 or IPv6 socket.
+                /// 
+                /// Equivalent to the SO_DOMAIN socket option.
+                pub fn address_family(&self,) -> IpAddressFamily{
+                  
+                  #[allow(unused_imports)]
+                  use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                  unsafe {
+                    
+                    #[cfg(target_arch = "wasm32")]
+                    #[link(wasm_import_module = "wasi:sockets/udp@0.2.0")]
+                    extern "C" {
+                      #[link_name = "[method]udp-socket.address-family"]
+                      fn wit_import(_: i32, ) -> i32;
+                    }
+                    
+                    #[cfg(not(target_arch = "wasm32"))]
+                    fn wit_import(_: i32, ) -> i32{ unreachable!() }
+                    let ret = wit_import((self).handle() as i32);
+                    super::super::super::wasi::sockets::network::IpAddressFamily::_lift(ret as u8)
+                  }
+                }
+              }
+              impl UdpSocket {
+                #[allow(unused_unsafe, clippy::all)]
+                /// Equivalent to the IP_TTL & IPV6_UNICAST_HOPS socket options.
+                /// 
+                /// If the provided value is 0, an `invalid-argument` error is returned.
+                /// 
+                /// # Typical errors
+                /// - `invalid-argument`:     (set) The TTL value must be 1 or higher.
+                pub fn unicast_hop_limit(&self,) -> Result<u8,ErrorCode>{
+                  
+                  #[allow(unused_imports)]
+                  use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                  unsafe {
+                    
+                    #[repr(align(1))]
+                    struct RetArea([u8; 2]);
+                    let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                    let ptr0 = ret_area.as_mut_ptr() as i32;
+                    #[cfg(target_arch = "wasm32")]
+                    #[link(wasm_import_module = "wasi:sockets/udp@0.2.0")]
+                    extern "C" {
+                      #[link_name = "[method]udp-socket.unicast-hop-limit"]
+                      fn wit_import(_: i32, _: i32, );
+                    }
+                    
+                    #[cfg(not(target_arch = "wasm32"))]
+                    fn wit_import(_: i32, _: i32, ){ unreachable!() }
+                    wit_import((self).handle() as i32, ptr0);
+                    let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                    match l1 {
+                      0 => {
+                        let e = {
+                          let l2 = i32::from(*((ptr0 + 1) as *const u8));
+                          
+                          l2 as u8
+                        };
+                        Ok(e)
+                      }
+                      1 => {
+                        let e = {
+                          let l3 = i32::from(*((ptr0 + 1) as *const u8));
+                          
+                          super::super::super::wasi::sockets::network::ErrorCode::_lift(l3 as u8)
+                        };
+                        Err(e)
+                      }
+                      _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                    }
+                  }
+                }
+              }
+              impl UdpSocket {
+                #[allow(unused_unsafe, clippy::all)]
+                pub fn set_unicast_hop_limit(&self,value: u8,) -> Result<(),ErrorCode>{
+                  
+                  #[allow(unused_imports)]
+                  use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                  unsafe {
+                    
+                    #[repr(align(1))]
+                    struct RetArea([u8; 2]);
+                    let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                    let ptr0 = ret_area.as_mut_ptr() as i32;
+                    #[cfg(target_arch = "wasm32")]
+                    #[link(wasm_import_module = "wasi:sockets/udp@0.2.0")]
+                    extern "C" {
+                      #[link_name = "[method]udp-socket.set-unicast-hop-limit"]
+                      fn wit_import(_: i32, _: i32, _: i32, );
+                    }
+                    
+                    #[cfg(not(target_arch = "wasm32"))]
+                    fn wit_import(_: i32, _: i32, _: i32, ){ unreachable!() }
+                    wit_import((self).handle() as i32, wit_bindgen::rt::as_i32(value), ptr0);
+                    let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                    match l1 {
+                      0 => {
+                        let e = ();
+                        Ok(e)
+                      }
+                      1 => {
+                        let e = {
+                          let l2 = i32::from(*((ptr0 + 1) as *const u8));
+                          
+                          super::super::super::wasi::sockets::network::ErrorCode::_lift(l2 as u8)
+                        };
+                        Err(e)
+                      }
+                      _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                    }
+                  }
+                }
+              }
+              impl UdpSocket {
+                #[allow(unused_unsafe, clippy::all)]
+                /// The kernel buffer space reserved for sends/receives on this socket.
+                /// 
+                /// If the provided value is 0, an `invalid-argument` error is returned.
+                /// Any other value will never cause an error, but it might be silently clamped and/or rounded.
+                /// I.e. after setting a value, reading the same setting back may return a different value.
+                /// 
+                /// Equivalent to the SO_RCVBUF and SO_SNDBUF socket options.
+                /// 
+                /// # Typical errors
+                /// - `invalid-argument`:     (set) The provided value was 0.
+                pub fn receive_buffer_size(&self,) -> Result<u64,ErrorCode>{
+                  
+                  #[allow(unused_imports)]
+                  use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                  unsafe {
+                    
+                    #[repr(align(8))]
+                    struct RetArea([u8; 16]);
+                    let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                    let ptr0 = ret_area.as_mut_ptr() as i32;
+                    #[cfg(target_arch = "wasm32")]
+                    #[link(wasm_import_module = "wasi:sockets/udp@0.2.0")]
+                    extern "C" {
+                      #[link_name = "[method]udp-socket.receive-buffer-size"]
+                      fn wit_import(_: i32, _: i32, );
+                    }
+                    
+                    #[cfg(not(target_arch = "wasm32"))]
+                    fn wit_import(_: i32, _: i32, ){ unreachable!() }
+                    wit_import((self).handle() as i32, ptr0);
+                    let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                    match l1 {
+                      0 => {
+                        let e = {
+                          let l2 = *((ptr0 + 8) as *const i64);
+                          
+                          l2 as u64
+                        };
+                        Ok(e)
+                      }
+                      1 => {
+                        let e = {
+                          let l3 = i32::from(*((ptr0 + 8) as *const u8));
+                          
+                          super::super::super::wasi::sockets::network::ErrorCode::_lift(l3 as u8)
+                        };
+                        Err(e)
+                      }
+                      _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                    }
+                  }
+                }
+              }
+              impl UdpSocket {
+                #[allow(unused_unsafe, clippy::all)]
+                pub fn set_receive_buffer_size(&self,value: u64,) -> Result<(),ErrorCode>{
+                  
+                  #[allow(unused_imports)]
+                  use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                  unsafe {
+                    
+                    #[repr(align(1))]
+                    struct RetArea([u8; 2]);
+                    let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                    let ptr0 = ret_area.as_mut_ptr() as i32;
+                    #[cfg(target_arch = "wasm32")]
+                    #[link(wasm_import_module = "wasi:sockets/udp@0.2.0")]
+                    extern "C" {
+                      #[link_name = "[method]udp-socket.set-receive-buffer-size"]
+                      fn wit_import(_: i32, _: i64, _: i32, );
+                    }
+                    
+                    #[cfg(not(target_arch = "wasm32"))]
+                    fn wit_import(_: i32, _: i64, _: i32, ){ unreachable!() }
+                    wit_import((self).handle() as i32, wit_bindgen::rt::as_i64(value), ptr0);
+                    let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                    match l1 {
+                      0 => {
+                        let e = ();
+                        Ok(e)
+                      }
+                      1 => {
+                        let e = {
+                          let l2 = i32::from(*((ptr0 + 1) as *const u8));
+                          
+                          super::super::super::wasi::sockets::network::ErrorCode::_lift(l2 as u8)
+                        };
+                        Err(e)
+                      }
+                      _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                    }
+                  }
+                }
+              }
+              impl UdpSocket {
+                #[allow(unused_unsafe, clippy::all)]
+                pub fn send_buffer_size(&self,) -> Result<u64,ErrorCode>{
+                  
+                  #[allow(unused_imports)]
+                  use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                  unsafe {
+                    
+                    #[repr(align(8))]
+                    struct RetArea([u8; 16]);
+                    let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                    let ptr0 = ret_area.as_mut_ptr() as i32;
+                    #[cfg(target_arch = "wasm32")]
+                    #[link(wasm_import_module = "wasi:sockets/udp@0.2.0")]
+                    extern "C" {
+                      #[link_name = "[method]udp-socket.send-buffer-size"]
+                      fn wit_import(_: i32, _: i32, );
+                    }
+                    
+                    #[cfg(not(target_arch = "wasm32"))]
+                    fn wit_import(_: i32, _: i32, ){ unreachable!() }
+                    wit_import((self).handle() as i32, ptr0);
+                    let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                    match l1 {
+                      0 => {
+                        let e = {
+                          let l2 = *((ptr0 + 8) as *const i64);
+                          
+                          l2 as u64
+                        };
+                        Ok(e)
+                      }
+                      1 => {
+                        let e = {
+                          let l3 = i32::from(*((ptr0 + 8) as *const u8));
+                          
+                          super::super::super::wasi::sockets::network::ErrorCode::_lift(l3 as u8)
+                        };
+                        Err(e)
+                      }
+                      _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                    }
+                  }
+                }
+              }
+              impl UdpSocket {
+                #[allow(unused_unsafe, clippy::all)]
+                pub fn set_send_buffer_size(&self,value: u64,) -> Result<(),ErrorCode>{
+                  
+                  #[allow(unused_imports)]
+                  use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                  unsafe {
+                    
+                    #[repr(align(1))]
+                    struct RetArea([u8; 2]);
+                    let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                    let ptr0 = ret_area.as_mut_ptr() as i32;
+                    #[cfg(target_arch = "wasm32")]
+                    #[link(wasm_import_module = "wasi:sockets/udp@0.2.0")]
+                    extern "C" {
+                      #[link_name = "[method]udp-socket.set-send-buffer-size"]
+                      fn wit_import(_: i32, _: i64, _: i32, );
+                    }
+                    
+                    #[cfg(not(target_arch = "wasm32"))]
+                    fn wit_import(_: i32, _: i64, _: i32, ){ unreachable!() }
+                    wit_import((self).handle() as i32, wit_bindgen::rt::as_i64(value), ptr0);
+                    let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                    match l1 {
+                      0 => {
+                        let e = ();
+                        Ok(e)
+                      }
+                      1 => {
+                        let e = {
+                          let l2 = i32::from(*((ptr0 + 1) as *const u8));
+                          
+                          super::super::super::wasi::sockets::network::ErrorCode::_lift(l2 as u8)
+                        };
+                        Err(e)
+                      }
+                      _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                    }
+                  }
+                }
+              }
+              impl UdpSocket {
+                #[allow(unused_unsafe, clippy::all)]
+                /// Create a `pollable` which will resolve once the socket is ready for I/O.
+                /// 
+                /// Note: this function is here for WASI Preview2 only.
+                /// It's planned to be removed when `future` is natively supported in Preview3.
+                pub fn subscribe(&self,) -> Pollable{
+                  
+                  #[allow(unused_imports)]
+                  use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                  unsafe {
+                    
+                    #[cfg(target_arch = "wasm32")]
+                    #[link(wasm_import_module = "wasi:sockets/udp@0.2.0")]
+                    extern "C" {
+                      #[link_name = "[method]udp-socket.subscribe"]
+                      fn wit_import(_: i32, ) -> i32;
+                    }
+                    
+                    #[cfg(not(target_arch = "wasm32"))]
+                    fn wit_import(_: i32, ) -> i32{ unreachable!() }
+                    let ret = wit_import((self).handle() as i32);
+                    super::super::super::wasi::io::poll::Pollable::from_handle(ret as u32)
+                  }
+                }
+              }
+              impl IncomingDatagramStream {
+                #[allow(unused_unsafe, clippy::all)]
+                /// Receive messages on the socket.
+                /// 
+                /// This function attempts to receive up to `max-results` datagrams on the socket without blocking.
+                /// The returned list may contain fewer elements than requested, but never more.
+                /// 
+                /// This function returns successfully with an empty list when either:
+                /// - `max-results` is 0, or:
+                /// - `max-results` is greater than 0, but no results are immediately available.
+                /// This function never returns `error(would-block)`.
+                /// 
+                /// # Typical errors
+                /// - `remote-unreachable`: The remote address is not reachable. (ECONNRESET, ENETRESET on Windows, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
+                /// - `connection-refused`: The connection was refused. (ECONNREFUSED)
+                /// 
+                /// # References
+                /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/recvfrom.html>
+                /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/recvmsg.html>
+                /// - <https://man7.org/linux/man-pages/man2/recv.2.html>
+                /// - <https://man7.org/linux/man-pages/man2/recvmmsg.2.html>
+                /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-recv>
+                /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-recvfrom>
+                /// - <https://learn.microsoft.com/en-us/previous-versions/windows/desktop/legacy/ms741687(v=vs.85)>
+                /// - <https://man.freebsd.org/cgi/man.cgi?query=recv&sektion=2>
+                pub fn receive(&self,max_results: u64,) -> Result<wit_bindgen::rt::vec::Vec::<IncomingDatagram>,ErrorCode>{
+                  
+                  #[allow(unused_imports)]
+                  use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                  unsafe {
+                    
+                    #[repr(align(4))]
+                    struct RetArea([u8; 12]);
+                    let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                    let ptr0 = ret_area.as_mut_ptr() as i32;
+                    #[cfg(target_arch = "wasm32")]
+                    #[link(wasm_import_module = "wasi:sockets/udp@0.2.0")]
+                    extern "C" {
+                      #[link_name = "[method]incoming-datagram-stream.receive"]
+                      fn wit_import(_: i32, _: i64, _: i32, );
+                    }
+                    
+                    #[cfg(not(target_arch = "wasm32"))]
+                    fn wit_import(_: i32, _: i64, _: i32, ){ unreachable!() }
+                    wit_import((self).handle() as i32, wit_bindgen::rt::as_i64(max_results), ptr0);
+                    let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                    match l1 {
+                      0 => {
+                        let e = {
+                          let l2 = *((ptr0 + 4) as *const i32);
+                          let l3 = *((ptr0 + 8) as *const i32);
+                          let base25 = l2;
+                          let len25 = l3;
+                          let mut result25 = Vec::with_capacity(len25 as usize);
+                          for i in 0..len25 {
+                            let base = base25 + i * 40;
+                            let e25 = {
+                              let l4 = *((base + 0) as *const i32);
+                              let l5 = *((base + 4) as *const i32);
+                              let len6 = l5 as usize;
+                              let l7 = i32::from(*((base + 8) as *const u8));
+                              use super::super::super::wasi::sockets::network::IpSocketAddress as V24;
+                              let v24 = match l7 {
+                                0 => {
+                                  let e24 = {
+                                    let l8 = i32::from(*((base + 12) as *const u16));
+                                    let l9 = i32::from(*((base + 14) as *const u8));
+                                    let l10 = i32::from(*((base + 15) as *const u8));
+                                    let l11 = i32::from(*((base + 16) as *const u8));
+                                    let l12 = i32::from(*((base + 17) as *const u8));
+                                    
+                                    super::super::super::wasi::sockets::network::Ipv4SocketAddress{
+                                      port: l8 as u16,
+                                      address: (l9 as u8, l10 as u8, l11 as u8, l12 as u8),
+                                    }
+                                  };
+                                  V24::Ipv4(e24)
+                                }
+                                n => {
+                                  debug_assert_eq!(n, 1, "invalid enum discriminant");
+                                  let e24 = {
+                                    let l13 = i32::from(*((base + 12) as *const u16));
+                                    let l14 = *((base + 16) as *const i32);
+                                    let l15 = i32::from(*((base + 20) as *const u16));
+                                    let l16 = i32::from(*((base + 22) as *const u16));
+                                    let l17 = i32::from(*((base + 24) as *const u16));
+                                    let l18 = i32::from(*((base + 26) as *const u16));
+                                    let l19 = i32::from(*((base + 28) as *const u16));
+                                    let l20 = i32::from(*((base + 30) as *const u16));
+                                    let l21 = i32::from(*((base + 32) as *const u16));
+                                    let l22 = i32::from(*((base + 34) as *const u16));
+                                    let l23 = *((base + 36) as *const i32);
+                                    
+                                    super::super::super::wasi::sockets::network::Ipv6SocketAddress{
+                                      port: l13 as u16,
+                                      flow_info: l14 as u32,
+                                      address: (l15 as u16, l16 as u16, l17 as u16, l18 as u16, l19 as u16, l20 as u16, l21 as u16, l22 as u16),
+                                      scope_id: l23 as u32,
+                                    }
+                                  };
+                                  V24::Ipv6(e24)
+                                }
+                              };
+                              
+                              IncomingDatagram{
+                                data: Vec::from_raw_parts(l4 as *mut _, len6, len6),
+                                remote_address: v24,
+                              }
+                            };
+                            result25.push(e25);
+                          }
+                          wit_bindgen::rt::dealloc(base25, (len25 as usize) * 40, 4);
+                          
+                          result25
+                        };
+                        Ok(e)
+                      }
+                      1 => {
+                        let e = {
+                          let l26 = i32::from(*((ptr0 + 4) as *const u8));
+                          
+                          super::super::super::wasi::sockets::network::ErrorCode::_lift(l26 as u8)
+                        };
+                        Err(e)
+                      }
+                      _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                    }
+                  }
+                }
+              }
+              impl IncomingDatagramStream {
+                #[allow(unused_unsafe, clippy::all)]
+                /// Create a `pollable` which will resolve once the stream is ready to receive again.
+                /// 
+                /// Note: this function is here for WASI Preview2 only.
+                /// It's planned to be removed when `future` is natively supported in Preview3.
+                pub fn subscribe(&self,) -> Pollable{
+                  
+                  #[allow(unused_imports)]
+                  use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                  unsafe {
+                    
+                    #[cfg(target_arch = "wasm32")]
+                    #[link(wasm_import_module = "wasi:sockets/udp@0.2.0")]
+                    extern "C" {
+                      #[link_name = "[method]incoming-datagram-stream.subscribe"]
+                      fn wit_import(_: i32, ) -> i32;
+                    }
+                    
+                    #[cfg(not(target_arch = "wasm32"))]
+                    fn wit_import(_: i32, ) -> i32{ unreachable!() }
+                    let ret = wit_import((self).handle() as i32);
+                    super::super::super::wasi::io::poll::Pollable::from_handle(ret as u32)
+                  }
+                }
+              }
+              impl OutgoingDatagramStream {
+                #[allow(unused_unsafe, clippy::all)]
+                /// Check readiness for sending. This function never blocks.
+                /// 
+                /// Returns the number of datagrams permitted for the next call to `send`,
+                /// or an error. Calling `send` with more datagrams than this function has
+                /// permitted will trap.
+                /// 
+                /// When this function returns ok(0), the `subscribe` pollable will
+                /// become ready when this function will report at least ok(1), or an
+                /// error.
+                /// 
+                /// Never returns `would-block`.
+                pub fn check_send(&self,) -> Result<u64,ErrorCode>{
+                  
+                  #[allow(unused_imports)]
+                  use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                  unsafe {
+                    
+                    #[repr(align(8))]
+                    struct RetArea([u8; 16]);
+                    let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                    let ptr0 = ret_area.as_mut_ptr() as i32;
+                    #[cfg(target_arch = "wasm32")]
+                    #[link(wasm_import_module = "wasi:sockets/udp@0.2.0")]
+                    extern "C" {
+                      #[link_name = "[method]outgoing-datagram-stream.check-send"]
+                      fn wit_import(_: i32, _: i32, );
+                    }
+                    
+                    #[cfg(not(target_arch = "wasm32"))]
+                    fn wit_import(_: i32, _: i32, ){ unreachable!() }
+                    wit_import((self).handle() as i32, ptr0);
+                    let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                    match l1 {
+                      0 => {
+                        let e = {
+                          let l2 = *((ptr0 + 8) as *const i64);
+                          
+                          l2 as u64
+                        };
+                        Ok(e)
+                      }
+                      1 => {
+                        let e = {
+                          let l3 = i32::from(*((ptr0 + 8) as *const u8));
+                          
+                          super::super::super::wasi::sockets::network::ErrorCode::_lift(l3 as u8)
+                        };
+                        Err(e)
+                      }
+                      _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                    }
+                  }
+                }
+              }
+              impl OutgoingDatagramStream {
+                #[allow(unused_unsafe, clippy::all)]
+                /// Send messages on the socket.
+                /// 
+                /// This function attempts to send all provided `datagrams` on the socket without blocking and
+                /// returns how many messages were actually sent (or queued for sending). This function never
+                /// returns `error(would-block)`. If none of the datagrams were able to be sent, `ok(0)` is returned.
+                /// 
+                /// This function semantically behaves the same as iterating the `datagrams` list and sequentially
+                /// sending each individual datagram until either the end of the list has been reached or the first error occurred.
+                /// If at least one datagram has been sent successfully, this function never returns an error.
+                /// 
+                /// If the input list is empty, the function returns `ok(0)`.
+                /// 
+                /// Each call to `send` must be permitted by a preceding `check-send`. Implementations must trap if
+                /// either `check-send` was not called or `datagrams` contains more items than `check-send` permitted.
+                /// 
+                /// # Typical errors
+                /// - `invalid-argument`:        The `remote-address` has the wrong address family. (EAFNOSUPPORT)
+                /// - `invalid-argument`:        The IP address in `remote-address` is set to INADDR_ANY (`0.0.0.0` / `::`). (EDESTADDRREQ, EADDRNOTAVAIL)
+                /// - `invalid-argument`:        The port in `remote-address` is set to 0. (EDESTADDRREQ, EADDRNOTAVAIL)
+                /// - `invalid-argument`:        The socket is in "connected" mode and `remote-address` is `some` value that does not match the address passed to `stream`. (EISCONN)
+                /// - `invalid-argument`:        The socket is not "connected" and no value for `remote-address` was provided. (EDESTADDRREQ)
+                /// - `remote-unreachable`:      The remote address is not reachable. (ECONNRESET, ENETRESET on Windows, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
+                /// - `connection-refused`:      The connection was refused. (ECONNREFUSED)
+                /// - `datagram-too-large`:      The datagram is too large. (EMSGSIZE)
+                /// 
+                /// # References
+                /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/sendto.html>
+                /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/sendmsg.html>
+                /// - <https://man7.org/linux/man-pages/man2/send.2.html>
+                /// - <https://man7.org/linux/man-pages/man2/sendmmsg.2.html>
+                /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-send>
+                /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-sendto>
+                /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasendmsg>
+                /// - <https://man.freebsd.org/cgi/man.cgi?query=send&sektion=2>
+                pub fn send(&self,datagrams: &[OutgoingDatagram],) -> Result<u64,ErrorCode>{
+                  
+                  #[allow(unused_imports)]
+                  use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                  unsafe {
+                    
+                    #[repr(align(8))]
+                    struct RetArea([u8; 16]);
+                    let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                    let vec7 = datagrams;
+                    let len7 = vec7.len() as i32;
+                    let layout7 = alloc::Layout::from_size_align_unchecked(vec7.len() * 44, 4);
+                    let result7 = if layout7.size() != 0
+                    {
+                      let ptr = alloc::alloc(layout7);
+                      if ptr.is_null()
+                      {
+                        alloc::handle_alloc_error(layout7);
+                      }
+                      ptr
+                    }else {{
+                      ::core::ptr::null_mut()
+                    }};
+                    for (i, e) in vec7.into_iter().enumerate() {
+                      let base = result7 as i32 + (i as i32) * 44;
+                      {
+                        let OutgoingDatagram{ data:data0, remote_address:remote_address0, } = e;
+                        let vec1 = data0;
+                        let ptr1 = vec1.as_ptr() as i32;
+                        let len1 = vec1.len() as i32;
+                        *((base + 4) as *mut i32) = len1;
+                        *((base + 0) as *mut i32) = ptr1;
+                        match remote_address0 {
+                          Some(e) => {
+                            *((base + 8) as *mut u8) = (1i32) as u8;
+                            use super::super::super::wasi::sockets::network::IpSocketAddress as V6;
+                            match e {
+                              V6::Ipv4(e) => {
+                                *((base + 12) as *mut u8) = (0i32) as u8;
+                                let super::super::super::wasi::sockets::network::Ipv4SocketAddress{ port:port2, address:address2, } = e;
+                                *((base + 16) as *mut u16) = (wit_bindgen::rt::as_i32(port2)) as u16;
+                                let (t3_0, t3_1, t3_2, t3_3, ) = address2;
+                                *((base + 18) as *mut u8) = (wit_bindgen::rt::as_i32(t3_0)) as u8;
+                                *((base + 19) as *mut u8) = (wit_bindgen::rt::as_i32(t3_1)) as u8;
+                                *((base + 20) as *mut u8) = (wit_bindgen::rt::as_i32(t3_2)) as u8;
+                                *((base + 21) as *mut u8) = (wit_bindgen::rt::as_i32(t3_3)) as u8;
+                              },
+                              V6::Ipv6(e) => {
+                                *((base + 12) as *mut u8) = (1i32) as u8;
+                                let super::super::super::wasi::sockets::network::Ipv6SocketAddress{ port:port4, flow_info:flow_info4, address:address4, scope_id:scope_id4, } = e;
+                                *((base + 16) as *mut u16) = (wit_bindgen::rt::as_i32(port4)) as u16;
+                                *((base + 20) as *mut i32) = wit_bindgen::rt::as_i32(flow_info4);
+                                let (t5_0, t5_1, t5_2, t5_3, t5_4, t5_5, t5_6, t5_7, ) = address4;
+                                *((base + 24) as *mut u16) = (wit_bindgen::rt::as_i32(t5_0)) as u16;
+                                *((base + 26) as *mut u16) = (wit_bindgen::rt::as_i32(t5_1)) as u16;
+                                *((base + 28) as *mut u16) = (wit_bindgen::rt::as_i32(t5_2)) as u16;
+                                *((base + 30) as *mut u16) = (wit_bindgen::rt::as_i32(t5_3)) as u16;
+                                *((base + 32) as *mut u16) = (wit_bindgen::rt::as_i32(t5_4)) as u16;
+                                *((base + 34) as *mut u16) = (wit_bindgen::rt::as_i32(t5_5)) as u16;
+                                *((base + 36) as *mut u16) = (wit_bindgen::rt::as_i32(t5_6)) as u16;
+                                *((base + 38) as *mut u16) = (wit_bindgen::rt::as_i32(t5_7)) as u16;
+                                *((base + 40) as *mut i32) = wit_bindgen::rt::as_i32(scope_id4);
+                              },
+                            }
+                          },
+                          None => {
+                            {
+                              *((base + 8) as *mut u8) = (0i32) as u8;
+                            }
+                          },
+                        };}
+                      }
+                      let ptr8 = ret_area.as_mut_ptr() as i32;
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/udp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]outgoing-datagram-stream.send"]
+                        fn wit_import(_: i32, _: i32, _: i32, _: i32, );
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, _: i32, _: i32, _: i32, ){ unreachable!() }
+                      wit_import((self).handle() as i32, result7 as i32, len7, ptr8);
+                      let l9 = i32::from(*((ptr8 + 0) as *const u8));
+                      if layout7.size() != 0 {
+                        alloc::dealloc(result7, layout7);
+                      }
+                      match l9 {
+                        0 => {
+                          let e = {
+                            let l10 = *((ptr8 + 8) as *const i64);
+                            
+                            l10 as u64
+                          };
+                          Ok(e)
+                        }
+                        1 => {
+                          let e = {
+                            let l11 = i32::from(*((ptr8 + 8) as *const u8));
+                            
+                            super::super::super::wasi::sockets::network::ErrorCode::_lift(l11 as u8)
+                          };
+                          Err(e)
+                        }
+                        _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                      }
+                    }
+                  }
+                }
+                impl OutgoingDatagramStream {
+                  #[allow(unused_unsafe, clippy::all)]
+                  /// Create a `pollable` which will resolve once the stream is ready to send again.
+                  /// 
+                  /// Note: this function is here for WASI Preview2 only.
+                  /// It's planned to be removed when `future` is natively supported in Preview3.
+                  pub fn subscribe(&self,) -> Pollable{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/udp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]outgoing-datagram-stream.subscribe"]
+                        fn wit_import(_: i32, ) -> i32;
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, ) -> i32{ unreachable!() }
+                      let ret = wit_import((self).handle() as i32);
+                      super::super::super::wasi::io::poll::Pollable::from_handle(ret as u32)
+                    }
+                  }
+                }
+                
+              }
+              
+              
+              #[allow(clippy::all)]
+              pub mod udp_create_socket {
+                #[used]
+                #[doc(hidden)]
+                #[cfg(target_arch = "wasm32")]
+                static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+                pub type ErrorCode = super::super::super::wasi::sockets::network::ErrorCode;
+                pub type IpAddressFamily = super::super::super::wasi::sockets::network::IpAddressFamily;
+                pub type UdpSocket = super::super::super::wasi::sockets::udp::UdpSocket;
+                #[allow(unused_unsafe, clippy::all)]
+                /// Create a new UDP socket.
+                /// 
+                /// Similar to `socket(AF_INET or AF_INET6, SOCK_DGRAM, IPPROTO_UDP)` in POSIX.
+                /// On IPv6 sockets, IPV6_V6ONLY is enabled by default and can't be configured otherwise.
+                /// 
+                /// This function does not require a network capability handle. This is considered to be safe because
+                /// at time of creation, the socket is not bound to any `network` yet. Up to the moment `bind` is called,
+                /// the socket is effectively an in-memory configuration object, unable to communicate with the outside world.
+                /// 
+                /// All sockets are non-blocking. Use the wasi-poll interface to block on asynchronous operations.
+                /// 
+                /// # Typical errors
+                /// - `not-supported`:     The specified `address-family` is not supported. (EAFNOSUPPORT)
+                /// - `new-socket-limit`:  The new socket resource could not be created because of a system limit. (EMFILE, ENFILE)
+                /// 
+                /// # References:
+                /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/socket.html>
+                /// - <https://man7.org/linux/man-pages/man2/socket.2.html>
+                /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasocketw>
+                /// - <https://man.freebsd.org/cgi/man.cgi?query=socket&sektion=2>
+                pub fn create_udp_socket(address_family: IpAddressFamily,) -> Result<UdpSocket,ErrorCode>{
+                  
+                  #[allow(unused_imports)]
+                  use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                  unsafe {
+                    
+                    #[repr(align(4))]
+                    struct RetArea([u8; 8]);
+                    let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                    let ptr0 = ret_area.as_mut_ptr() as i32;
+                    #[cfg(target_arch = "wasm32")]
+                    #[link(wasm_import_module = "wasi:sockets/udp-create-socket@0.2.0")]
+                    extern "C" {
+                      #[link_name = "create-udp-socket"]
+                      fn wit_import(_: i32, _: i32, );
+                    }
+                    
+                    #[cfg(not(target_arch = "wasm32"))]
+                    fn wit_import(_: i32, _: i32, ){ unreachable!() }
+                    wit_import(address_family.clone() as i32, ptr0);
+                    let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                    match l1 {
+                      0 => {
+                        let e = {
+                          let l2 = *((ptr0 + 4) as *const i32);
+                          
+                          super::super::super::wasi::sockets::udp::UdpSocket::from_handle(l2 as u32)
+                        };
+                        Ok(e)
+                      }
+                      1 => {
+                        let e = {
+                          let l3 = i32::from(*((ptr0 + 4) as *const u8));
+                          
+                          super::super::super::wasi::sockets::network::ErrorCode::_lift(l3 as u8)
+                        };
+                        Err(e)
+                      }
+                      _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                    }
+                  }
+                }
+                
+              }
+              
+              
+              #[allow(clippy::all)]
+              pub mod tcp {
+                #[used]
+                #[doc(hidden)]
+                #[cfg(target_arch = "wasm32")]
+                static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+                pub type InputStream = super::super::super::wasi::io::streams::InputStream;
+                pub type OutputStream = super::super::super::wasi::io::streams::OutputStream;
+                pub type Pollable = super::super::super::wasi::io::poll::Pollable;
+                pub type Duration = super::super::super::wasi::clocks::monotonic_clock::Duration;
+                pub type Network = super::super::super::wasi::sockets::network::Network;
+                pub type ErrorCode = super::super::super::wasi::sockets::network::ErrorCode;
+                pub type IpSocketAddress = super::super::super::wasi::sockets::network::IpSocketAddress;
+                pub type IpAddressFamily = super::super::super::wasi::sockets::network::IpAddressFamily;
+                #[repr(u8)]
+                #[derive(Clone, Copy, Eq, PartialEq)]
+                pub enum ShutdownType {
+                  /// Similar to `SHUT_RD` in POSIX.
+                  Receive,
+                  /// Similar to `SHUT_WR` in POSIX.
+                  Send,
+                  /// Similar to `SHUT_RDWR` in POSIX.
+                  Both,
+                }
+                impl ::core::fmt::Debug for ShutdownType {
+                  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+                    match self {
+                      ShutdownType::Receive => {
+                        f.debug_tuple("ShutdownType::Receive").finish()
+                      }
+                      ShutdownType::Send => {
+                        f.debug_tuple("ShutdownType::Send").finish()
+                      }
+                      ShutdownType::Both => {
+                        f.debug_tuple("ShutdownType::Both").finish()
+                      }
+                    }
+                  }
+                }
+                
+                impl ShutdownType{
+                  pub(crate) unsafe fn _lift(val: u8) -> ShutdownType{
+                    if !cfg!(debug_assertions) {
+                      return ::core::mem::transmute(val);
+                    }
+                    
+                    match val {
+                      0 => ShutdownType::Receive,
+                      1 => ShutdownType::Send,
+                      2 => ShutdownType::Both,
+                      
+                      _ => panic!("invalid enum discriminant"),
+                    }
+                  }
+                }
+                
+                /// A TCP socket resource.
+                /// 
+                /// The socket can be in one of the following states:
+                /// - `unbound`
+                /// - `bind-in-progress`
+                /// - `bound` (See note below)
+                /// - `listen-in-progress`
+                /// - `listening`
+                /// - `connect-in-progress`
+                /// - `connected`
+                /// - `closed`
+                /// See <https://github.com/WebAssembly/wasi-sockets/TcpSocketOperationalSemantics.md>
+                /// for a more information.
+                /// 
+                /// Note: Except where explicitly mentioned, whenever this documentation uses
+                /// the term "bound" without backticks it actually means: in the `bound` state *or higher*.
+                /// (i.e. `bound`, `listen-in-progress`, `listening`, `connect-in-progress` or `connected`)
+                /// 
+                /// In addition to the general error codes documented on the
+                /// `network::error-code` type, TCP socket methods may always return
+                /// `error(invalid-state)` when in the `closed` state.
+                
+                #[derive(Debug)]
+                #[repr(transparent)]
+                pub struct TcpSocket{
+                  handle: wit_bindgen::rt::Resource<TcpSocket>,
+                }
+                
+                impl TcpSocket{
+                  #[doc(hidden)]
+                  pub unsafe fn from_handle(handle: u32) -> Self {
+                    Self {
+                      handle: wit_bindgen::rt::Resource::from_handle(handle),
+                    }
+                  }
+                  
+                  #[doc(hidden)]
+                  pub fn into_handle(self) -> u32 {
+                    wit_bindgen::rt::Resource::into_handle(self.handle)
+                  }
+                  
+                  #[doc(hidden)]
+                  pub fn handle(&self) -> u32 {
+                    wit_bindgen::rt::Resource::handle(&self.handle)
+                  }
+                }
+                
+                
+                unsafe impl wit_bindgen::rt::WasmResource for TcpSocket{
+                  #[inline]
+                  unsafe fn drop(_handle: u32) {
+                    #[cfg(not(target_arch = "wasm32"))]
+                    unreachable!();
+                    
+                    #[cfg(target_arch = "wasm32")]
+                    {
+                      #[link(wasm_import_module = "wasi:sockets/tcp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[resource-drop]tcp-socket"]
+                        fn drop(_: u32);
+                      }
+                      
+                      drop(_handle);
+                    }
+                  }
+                }
+                
+                impl TcpSocket {
+                  #[allow(unused_unsafe, clippy::all)]
+                  /// Bind the socket to a specific network on the provided IP address and port.
+                  /// 
+                  /// If the IP address is zero (`0.0.0.0` in IPv4, `::` in IPv6), it is left to the implementation to decide which
+                  /// network interface(s) to bind to.
+                  /// If the TCP/UDP port is zero, the socket will be bound to a random free port.
+                  /// 
+                  /// Bind can be attempted multiple times on the same socket, even with
+                  /// different arguments on each iteration. But never concurrently and
+                  /// only as long as the previous bind failed. Once a bind succeeds, the
+                  /// binding can't be changed anymore.
+                  /// 
+                  /// # Typical errors
+                  /// - `invalid-argument`:          The `local-address` has the wrong address family. (EAFNOSUPPORT, EFAULT on Windows)
+                  /// - `invalid-argument`:          `local-address` is not a unicast address. (EINVAL)
+                  /// - `invalid-argument`:          `local-address` is an IPv4-mapped IPv6 address. (EINVAL)
+                  /// - `invalid-state`:             The socket is already bound. (EINVAL)
+                  /// - `address-in-use`:            No ephemeral ports available. (EADDRINUSE, ENOBUFS on Windows)
+                  /// - `address-in-use`:            Address is already in use. (EADDRINUSE)
+                  /// - `address-not-bindable`:      `local-address` is not an address that the `network` can bind to. (EADDRNOTAVAIL)
+                  /// - `not-in-progress`:           A `bind` operation is not in progress.
+                  /// - `would-block`:               Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)
+                  /// 
+                  /// # Implementors note
+                  /// When binding to a non-zero port, this bind operation shouldn't be affected by the TIME_WAIT
+                  /// state of a recently closed socket on the same local address. In practice this means that the SO_REUSEADDR
+                  /// socket option should be set implicitly on all platforms, except on Windows where this is the default behavior
+                  /// and SO_REUSEADDR performs something different entirely.
+                  /// 
+                  /// Unlike in POSIX, in WASI the bind operation is async. This enables
+                  /// interactive WASI hosts to inject permission prompts. Runtimes that
+                  /// don't want to make use of this ability can simply call the native
+                  /// `bind` as part of either `start-bind` or `finish-bind`.
+                  /// 
+                  /// # References
+                  /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/bind.html>
+                  /// - <https://man7.org/linux/man-pages/man2/bind.2.html>
+                  /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-bind>
+                  /// - <https://man.freebsd.org/cgi/man.cgi?query=bind&sektion=2&format=html>
+                  pub fn start_bind(&self,network: &Network,local_address: IpSocketAddress,) -> Result<(),ErrorCode>{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[repr(align(1))]
+                      struct RetArea([u8; 2]);
+                      let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                      use super::super::super::wasi::sockets::network::IpSocketAddress as V4;
+                      let (result5_0,result5_1,result5_2,result5_3,result5_4,result5_5,result5_6,result5_7,result5_8,result5_9,result5_10,result5_11,) = match local_address {
+                        V4::Ipv4(e) => {
+                          let super::super::super::wasi::sockets::network::Ipv4SocketAddress{ port:port0, address:address0, } = e;
+                          let (t1_0, t1_1, t1_2, t1_3, ) = address0;
+                          
+                          (0i32, wit_bindgen::rt::as_i32(port0), wit_bindgen::rt::as_i32(t1_0), wit_bindgen::rt::as_i32(t1_1), wit_bindgen::rt::as_i32(t1_2), wit_bindgen::rt::as_i32(t1_3), 0i32, 0i32, 0i32, 0i32, 0i32, 0i32)
+                        },
+                        V4::Ipv6(e) => {
+                          let super::super::super::wasi::sockets::network::Ipv6SocketAddress{ port:port2, flow_info:flow_info2, address:address2, scope_id:scope_id2, } = e;
+                          let (t3_0, t3_1, t3_2, t3_3, t3_4, t3_5, t3_6, t3_7, ) = address2;
+                          
+                          (1i32, wit_bindgen::rt::as_i32(port2), wit_bindgen::rt::as_i32(flow_info2), wit_bindgen::rt::as_i32(t3_0), wit_bindgen::rt::as_i32(t3_1), wit_bindgen::rt::as_i32(t3_2), wit_bindgen::rt::as_i32(t3_3), wit_bindgen::rt::as_i32(t3_4), wit_bindgen::rt::as_i32(t3_5), wit_bindgen::rt::as_i32(t3_6), wit_bindgen::rt::as_i32(t3_7), wit_bindgen::rt::as_i32(scope_id2))
+                        },
+                      };
+                      let ptr6 = ret_area.as_mut_ptr() as i32;
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/tcp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]tcp-socket.start-bind"]
+                        fn wit_import(_: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, );
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, ){ unreachable!() }
+                      wit_import((self).handle() as i32, (network).handle() as i32, result5_0, result5_1, result5_2, result5_3, result5_4, result5_5, result5_6, result5_7, result5_8, result5_9, result5_10, result5_11, ptr6);
+                      let l7 = i32::from(*((ptr6 + 0) as *const u8));
+                      match l7 {
+                        0 => {
+                          let e = ();
+                          Ok(e)
+                        }
+                        1 => {
+                          let e = {
+                            let l8 = i32::from(*((ptr6 + 1) as *const u8));
+                            
+                            super::super::super::wasi::sockets::network::ErrorCode::_lift(l8 as u8)
+                          };
+                          Err(e)
+                        }
+                        _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                      }
+                    }
+                  }
+                }
+                impl TcpSocket {
+                  #[allow(unused_unsafe, clippy::all)]
+                  pub fn finish_bind(&self,) -> Result<(),ErrorCode>{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[repr(align(1))]
+                      struct RetArea([u8; 2]);
+                      let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                      let ptr0 = ret_area.as_mut_ptr() as i32;
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/tcp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]tcp-socket.finish-bind"]
+                        fn wit_import(_: i32, _: i32, );
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, _: i32, ){ unreachable!() }
+                      wit_import((self).handle() as i32, ptr0);
+                      let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                      match l1 {
+                        0 => {
+                          let e = ();
+                          Ok(e)
+                        }
+                        1 => {
+                          let e = {
+                            let l2 = i32::from(*((ptr0 + 1) as *const u8));
+                            
+                            super::super::super::wasi::sockets::network::ErrorCode::_lift(l2 as u8)
+                          };
+                          Err(e)
+                        }
+                        _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                      }
+                    }
+                  }
+                }
+                impl TcpSocket {
+                  #[allow(unused_unsafe, clippy::all)]
+                  /// Connect to a remote endpoint.
+                  /// 
+                  /// On success:
+                  /// - the socket is transitioned into the `connection` state.
+                  /// - a pair of streams is returned that can be used to read & write to the connection
+                  /// 
+                  /// After a failed connection attempt, the socket will be in the `closed`
+                  /// state and the only valid action left is to `drop` the socket. A single
+                  /// socket can not be used to connect more than once.
+                  /// 
+                  /// # Typical errors
+                  /// - `invalid-argument`:          The `remote-address` has the wrong address family. (EAFNOSUPPORT)
+                  /// - `invalid-argument`:          `remote-address` is not a unicast address. (EINVAL, ENETUNREACH on Linux, EAFNOSUPPORT on MacOS)
+                  /// - `invalid-argument`:          `remote-address` is an IPv4-mapped IPv6 address. (EINVAL, EADDRNOTAVAIL on Illumos)
+                  /// - `invalid-argument`:          The IP address in `remote-address` is set to INADDR_ANY (`0.0.0.0` / `::`). (EADDRNOTAVAIL on Windows)
+                  /// - `invalid-argument`:          The port in `remote-address` is set to 0. (EADDRNOTAVAIL on Windows)
+                  /// - `invalid-argument`:          The socket is already attached to a different network. The `network` passed to `connect` must be identical to the one passed to `bind`.
+                  /// - `invalid-state`:             The socket is already in the `connected` state. (EISCONN)
+                  /// - `invalid-state`:             The socket is already in the `listening` state. (EOPNOTSUPP, EINVAL on Windows)
+                  /// - `timeout`:                   Connection timed out. (ETIMEDOUT)
+                  /// - `connection-refused`:        The connection was forcefully rejected. (ECONNREFUSED)
+                  /// - `connection-reset`:          The connection was reset. (ECONNRESET)
+                  /// - `connection-aborted`:        The connection was aborted. (ECONNABORTED)
+                  /// - `remote-unreachable`:        The remote address is not reachable. (EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
+                  /// - `address-in-use`:            Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE, EADDRNOTAVAIL on Linux, EAGAIN on BSD)
+                  /// - `not-in-progress`:           A connect operation is not in progress.
+                  /// - `would-block`:               Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)
+                  /// 
+                  /// # Implementors note
+                  /// The POSIX equivalent of `start-connect` is the regular `connect` syscall.
+                  /// Because all WASI sockets are non-blocking this is expected to return
+                  /// EINPROGRESS, which should be translated to `ok()` in WASI.
+                  /// 
+                  /// The POSIX equivalent of `finish-connect` is a `poll` for event `POLLOUT`
+                  /// with a timeout of 0 on the socket descriptor. Followed by a check for
+                  /// the `SO_ERROR` socket option, in case the poll signaled readiness.
+                  /// 
+                  /// # References
+                  /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/connect.html>
+                  /// - <https://man7.org/linux/man-pages/man2/connect.2.html>
+                  /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-connect>
+                  /// - <https://man.freebsd.org/cgi/man.cgi?connect>
+                  pub fn start_connect(&self,network: &Network,remote_address: IpSocketAddress,) -> Result<(),ErrorCode>{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[repr(align(1))]
+                      struct RetArea([u8; 2]);
+                      let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                      use super::super::super::wasi::sockets::network::IpSocketAddress as V4;
+                      let (result5_0,result5_1,result5_2,result5_3,result5_4,result5_5,result5_6,result5_7,result5_8,result5_9,result5_10,result5_11,) = match remote_address {
+                        V4::Ipv4(e) => {
+                          let super::super::super::wasi::sockets::network::Ipv4SocketAddress{ port:port0, address:address0, } = e;
+                          let (t1_0, t1_1, t1_2, t1_3, ) = address0;
+                          
+                          (0i32, wit_bindgen::rt::as_i32(port0), wit_bindgen::rt::as_i32(t1_0), wit_bindgen::rt::as_i32(t1_1), wit_bindgen::rt::as_i32(t1_2), wit_bindgen::rt::as_i32(t1_3), 0i32, 0i32, 0i32, 0i32, 0i32, 0i32)
+                        },
+                        V4::Ipv6(e) => {
+                          let super::super::super::wasi::sockets::network::Ipv6SocketAddress{ port:port2, flow_info:flow_info2, address:address2, scope_id:scope_id2, } = e;
+                          let (t3_0, t3_1, t3_2, t3_3, t3_4, t3_5, t3_6, t3_7, ) = address2;
+                          
+                          (1i32, wit_bindgen::rt::as_i32(port2), wit_bindgen::rt::as_i32(flow_info2), wit_bindgen::rt::as_i32(t3_0), wit_bindgen::rt::as_i32(t3_1), wit_bindgen::rt::as_i32(t3_2), wit_bindgen::rt::as_i32(t3_3), wit_bindgen::rt::as_i32(t3_4), wit_bindgen::rt::as_i32(t3_5), wit_bindgen::rt::as_i32(t3_6), wit_bindgen::rt::as_i32(t3_7), wit_bindgen::rt::as_i32(scope_id2))
+                        },
+                      };
+                      let ptr6 = ret_area.as_mut_ptr() as i32;
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/tcp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]tcp-socket.start-connect"]
+                        fn wit_import(_: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, );
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, _: i32, ){ unreachable!() }
+                      wit_import((self).handle() as i32, (network).handle() as i32, result5_0, result5_1, result5_2, result5_3, result5_4, result5_5, result5_6, result5_7, result5_8, result5_9, result5_10, result5_11, ptr6);
+                      let l7 = i32::from(*((ptr6 + 0) as *const u8));
+                      match l7 {
+                        0 => {
+                          let e = ();
+                          Ok(e)
+                        }
+                        1 => {
+                          let e = {
+                            let l8 = i32::from(*((ptr6 + 1) as *const u8));
+                            
+                            super::super::super::wasi::sockets::network::ErrorCode::_lift(l8 as u8)
+                          };
+                          Err(e)
+                        }
+                        _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                      }
+                    }
+                  }
+                }
+                impl TcpSocket {
+                  #[allow(unused_unsafe, clippy::all)]
+                  pub fn finish_connect(&self,) -> Result<(InputStream,OutputStream,),ErrorCode>{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[repr(align(4))]
+                      struct RetArea([u8; 12]);
+                      let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                      let ptr0 = ret_area.as_mut_ptr() as i32;
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/tcp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]tcp-socket.finish-connect"]
+                        fn wit_import(_: i32, _: i32, );
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, _: i32, ){ unreachable!() }
+                      wit_import((self).handle() as i32, ptr0);
+                      let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                      match l1 {
+                        0 => {
+                          let e = {
+                            let l2 = *((ptr0 + 4) as *const i32);
+                            let l3 = *((ptr0 + 8) as *const i32);
+                            
+                            (super::super::super::wasi::io::streams::InputStream::from_handle(l2 as u32), super::super::super::wasi::io::streams::OutputStream::from_handle(l3 as u32))
+                          };
+                          Ok(e)
+                        }
+                        1 => {
+                          let e = {
+                            let l4 = i32::from(*((ptr0 + 4) as *const u8));
+                            
+                            super::super::super::wasi::sockets::network::ErrorCode::_lift(l4 as u8)
+                          };
+                          Err(e)
+                        }
+                        _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                      }
+                    }
+                  }
+                }
+                impl TcpSocket {
+                  #[allow(unused_unsafe, clippy::all)]
+                  /// Start listening for new connections.
+                  /// 
+                  /// Transitions the socket into the `listening` state.
+                  /// 
+                  /// Unlike POSIX, the socket must already be explicitly bound.
+                  /// 
+                  /// # Typical errors
+                  /// - `invalid-state`:             The socket is not bound to any local address. (EDESTADDRREQ)
+                  /// - `invalid-state`:             The socket is already in the `connected` state. (EISCONN, EINVAL on BSD)
+                  /// - `invalid-state`:             The socket is already in the `listening` state.
+                  /// - `address-in-use`:            Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE)
+                  /// - `not-in-progress`:           A listen operation is not in progress.
+                  /// - `would-block`:               Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)
+                  /// 
+                  /// # Implementors note
+                  /// Unlike in POSIX, in WASI the listen operation is async. This enables
+                  /// interactive WASI hosts to inject permission prompts. Runtimes that
+                  /// don't want to make use of this ability can simply call the native
+                  /// `listen` as part of either `start-listen` or `finish-listen`.
+                  /// 
+                  /// # References
+                  /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/listen.html>
+                  /// - <https://man7.org/linux/man-pages/man2/listen.2.html>
+                  /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-listen>
+                  /// - <https://man.freebsd.org/cgi/man.cgi?query=listen&sektion=2>
+                  pub fn start_listen(&self,) -> Result<(),ErrorCode>{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[repr(align(1))]
+                      struct RetArea([u8; 2]);
+                      let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                      let ptr0 = ret_area.as_mut_ptr() as i32;
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/tcp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]tcp-socket.start-listen"]
+                        fn wit_import(_: i32, _: i32, );
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, _: i32, ){ unreachable!() }
+                      wit_import((self).handle() as i32, ptr0);
+                      let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                      match l1 {
+                        0 => {
+                          let e = ();
+                          Ok(e)
+                        }
+                        1 => {
+                          let e = {
+                            let l2 = i32::from(*((ptr0 + 1) as *const u8));
+                            
+                            super::super::super::wasi::sockets::network::ErrorCode::_lift(l2 as u8)
+                          };
+                          Err(e)
+                        }
+                        _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                      }
+                    }
+                  }
+                }
+                impl TcpSocket {
+                  #[allow(unused_unsafe, clippy::all)]
+                  pub fn finish_listen(&self,) -> Result<(),ErrorCode>{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[repr(align(1))]
+                      struct RetArea([u8; 2]);
+                      let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                      let ptr0 = ret_area.as_mut_ptr() as i32;
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/tcp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]tcp-socket.finish-listen"]
+                        fn wit_import(_: i32, _: i32, );
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, _: i32, ){ unreachable!() }
+                      wit_import((self).handle() as i32, ptr0);
+                      let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                      match l1 {
+                        0 => {
+                          let e = ();
+                          Ok(e)
+                        }
+                        1 => {
+                          let e = {
+                            let l2 = i32::from(*((ptr0 + 1) as *const u8));
+                            
+                            super::super::super::wasi::sockets::network::ErrorCode::_lift(l2 as u8)
+                          };
+                          Err(e)
+                        }
+                        _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                      }
+                    }
+                  }
+                }
+                impl TcpSocket {
+                  #[allow(unused_unsafe, clippy::all)]
+                  /// Accept a new client socket.
+                  /// 
+                  /// The returned socket is bound and in the `connected` state. The following properties are inherited from the listener socket:
+                  /// - `address-family`
+                  /// - `keep-alive-enabled`
+                  /// - `keep-alive-idle-time`
+                  /// - `keep-alive-interval`
+                  /// - `keep-alive-count`
+                  /// - `hop-limit`
+                  /// - `receive-buffer-size`
+                  /// - `send-buffer-size`
+                  /// 
+                  /// On success, this function returns the newly accepted client socket along with
+                  /// a pair of streams that can be used to read & write to the connection.
+                  /// 
+                  /// # Typical errors
+                  /// - `invalid-state`:      Socket is not in the `listening` state. (EINVAL)
+                  /// - `would-block`:        No pending connections at the moment. (EWOULDBLOCK, EAGAIN)
+                  /// - `connection-aborted`: An incoming connection was pending, but was terminated by the client before this listener could accept it. (ECONNABORTED)
+                  /// - `new-socket-limit`:   The new socket resource could not be created because of a system limit. (EMFILE, ENFILE)
+                  /// 
+                  /// # References
+                  /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/accept.html>
+                  /// - <https://man7.org/linux/man-pages/man2/accept.2.html>
+                  /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-accept>
+                  /// - <https://man.freebsd.org/cgi/man.cgi?query=accept&sektion=2>
+                  pub fn accept(&self,) -> Result<(TcpSocket,InputStream,OutputStream,),ErrorCode>{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[repr(align(4))]
+                      struct RetArea([u8; 16]);
+                      let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                      let ptr0 = ret_area.as_mut_ptr() as i32;
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/tcp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]tcp-socket.accept"]
+                        fn wit_import(_: i32, _: i32, );
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, _: i32, ){ unreachable!() }
+                      wit_import((self).handle() as i32, ptr0);
+                      let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                      match l1 {
+                        0 => {
+                          let e = {
+                            let l2 = *((ptr0 + 4) as *const i32);
+                            let l3 = *((ptr0 + 8) as *const i32);
+                            let l4 = *((ptr0 + 12) as *const i32);
+                            
+                            (TcpSocket::from_handle(l2 as u32), super::super::super::wasi::io::streams::InputStream::from_handle(l3 as u32), super::super::super::wasi::io::streams::OutputStream::from_handle(l4 as u32))
+                          };
+                          Ok(e)
+                        }
+                        1 => {
+                          let e = {
+                            let l5 = i32::from(*((ptr0 + 4) as *const u8));
+                            
+                            super::super::super::wasi::sockets::network::ErrorCode::_lift(l5 as u8)
+                          };
+                          Err(e)
+                        }
+                        _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                      }
+                    }
+                  }
+                }
+                impl TcpSocket {
+                  #[allow(unused_unsafe, clippy::all)]
+                  /// Get the bound local address.
+                  /// 
+                  /// POSIX mentions:
+                  /// > If the socket has not been bound to a local name, the value
+                  /// > stored in the object pointed to by `address` is unspecified.
+                  /// 
+                  /// WASI is stricter and requires `local-address` to return `invalid-state` when the socket hasn't been bound yet.
+                  /// 
+                  /// # Typical errors
+                  /// - `invalid-state`: The socket is not bound to any local address.
+                  /// 
+                  /// # References
+                  /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsockname.html>
+                  /// - <https://man7.org/linux/man-pages/man2/getsockname.2.html>
+                  /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getsockname>
+                  /// - <https://man.freebsd.org/cgi/man.cgi?getsockname>
+                  pub fn local_address(&self,) -> Result<IpSocketAddress,ErrorCode>{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[repr(align(4))]
+                      struct RetArea([u8; 36]);
+                      let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                      let ptr0 = ret_area.as_mut_ptr() as i32;
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/tcp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]tcp-socket.local-address"]
+                        fn wit_import(_: i32, _: i32, );
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, _: i32, ){ unreachable!() }
+                      wit_import((self).handle() as i32, ptr0);
+                      let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                      match l1 {
+                        0 => {
+                          let e = {
+                            let l2 = i32::from(*((ptr0 + 4) as *const u8));
+                            use super::super::super::wasi::sockets::network::IpSocketAddress as V19;
+                            let v19 = match l2 {
+                              0 => {
+                                let e19 = {
+                                  let l3 = i32::from(*((ptr0 + 8) as *const u16));
+                                  let l4 = i32::from(*((ptr0 + 10) as *const u8));
+                                  let l5 = i32::from(*((ptr0 + 11) as *const u8));
+                                  let l6 = i32::from(*((ptr0 + 12) as *const u8));
+                                  let l7 = i32::from(*((ptr0 + 13) as *const u8));
+                                  
+                                  super::super::super::wasi::sockets::network::Ipv4SocketAddress{
+                                    port: l3 as u16,
+                                    address: (l4 as u8, l5 as u8, l6 as u8, l7 as u8),
+                                  }
+                                };
+                                V19::Ipv4(e19)
+                              }
+                              n => {
+                                debug_assert_eq!(n, 1, "invalid enum discriminant");
+                                let e19 = {
+                                  let l8 = i32::from(*((ptr0 + 8) as *const u16));
+                                  let l9 = *((ptr0 + 12) as *const i32);
+                                  let l10 = i32::from(*((ptr0 + 16) as *const u16));
+                                  let l11 = i32::from(*((ptr0 + 18) as *const u16));
+                                  let l12 = i32::from(*((ptr0 + 20) as *const u16));
+                                  let l13 = i32::from(*((ptr0 + 22) as *const u16));
+                                  let l14 = i32::from(*((ptr0 + 24) as *const u16));
+                                  let l15 = i32::from(*((ptr0 + 26) as *const u16));
+                                  let l16 = i32::from(*((ptr0 + 28) as *const u16));
+                                  let l17 = i32::from(*((ptr0 + 30) as *const u16));
+                                  let l18 = *((ptr0 + 32) as *const i32);
+                                  
+                                  super::super::super::wasi::sockets::network::Ipv6SocketAddress{
+                                    port: l8 as u16,
+                                    flow_info: l9 as u32,
+                                    address: (l10 as u16, l11 as u16, l12 as u16, l13 as u16, l14 as u16, l15 as u16, l16 as u16, l17 as u16),
+                                    scope_id: l18 as u32,
+                                  }
+                                };
+                                V19::Ipv6(e19)
+                              }
+                            };
+                            
+                            v19
+                          };
+                          Ok(e)
+                        }
+                        1 => {
+                          let e = {
+                            let l20 = i32::from(*((ptr0 + 4) as *const u8));
+                            
+                            super::super::super::wasi::sockets::network::ErrorCode::_lift(l20 as u8)
+                          };
+                          Err(e)
+                        }
+                        _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                      }
+                    }
+                  }
+                }
+                impl TcpSocket {
+                  #[allow(unused_unsafe, clippy::all)]
+                  /// Get the remote address.
+                  /// 
+                  /// # Typical errors
+                  /// - `invalid-state`: The socket is not connected to a remote address. (ENOTCONN)
+                  /// 
+                  /// # References
+                  /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpeername.html>
+                  /// - <https://man7.org/linux/man-pages/man2/getpeername.2.html>
+                  /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getpeername>
+                  /// - <https://man.freebsd.org/cgi/man.cgi?query=getpeername&sektion=2&n=1>
+                  pub fn remote_address(&self,) -> Result<IpSocketAddress,ErrorCode>{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[repr(align(4))]
+                      struct RetArea([u8; 36]);
+                      let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                      let ptr0 = ret_area.as_mut_ptr() as i32;
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/tcp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]tcp-socket.remote-address"]
+                        fn wit_import(_: i32, _: i32, );
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, _: i32, ){ unreachable!() }
+                      wit_import((self).handle() as i32, ptr0);
+                      let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                      match l1 {
+                        0 => {
+                          let e = {
+                            let l2 = i32::from(*((ptr0 + 4) as *const u8));
+                            use super::super::super::wasi::sockets::network::IpSocketAddress as V19;
+                            let v19 = match l2 {
+                              0 => {
+                                let e19 = {
+                                  let l3 = i32::from(*((ptr0 + 8) as *const u16));
+                                  let l4 = i32::from(*((ptr0 + 10) as *const u8));
+                                  let l5 = i32::from(*((ptr0 + 11) as *const u8));
+                                  let l6 = i32::from(*((ptr0 + 12) as *const u8));
+                                  let l7 = i32::from(*((ptr0 + 13) as *const u8));
+                                  
+                                  super::super::super::wasi::sockets::network::Ipv4SocketAddress{
+                                    port: l3 as u16,
+                                    address: (l4 as u8, l5 as u8, l6 as u8, l7 as u8),
+                                  }
+                                };
+                                V19::Ipv4(e19)
+                              }
+                              n => {
+                                debug_assert_eq!(n, 1, "invalid enum discriminant");
+                                let e19 = {
+                                  let l8 = i32::from(*((ptr0 + 8) as *const u16));
+                                  let l9 = *((ptr0 + 12) as *const i32);
+                                  let l10 = i32::from(*((ptr0 + 16) as *const u16));
+                                  let l11 = i32::from(*((ptr0 + 18) as *const u16));
+                                  let l12 = i32::from(*((ptr0 + 20) as *const u16));
+                                  let l13 = i32::from(*((ptr0 + 22) as *const u16));
+                                  let l14 = i32::from(*((ptr0 + 24) as *const u16));
+                                  let l15 = i32::from(*((ptr0 + 26) as *const u16));
+                                  let l16 = i32::from(*((ptr0 + 28) as *const u16));
+                                  let l17 = i32::from(*((ptr0 + 30) as *const u16));
+                                  let l18 = *((ptr0 + 32) as *const i32);
+                                  
+                                  super::super::super::wasi::sockets::network::Ipv6SocketAddress{
+                                    port: l8 as u16,
+                                    flow_info: l9 as u32,
+                                    address: (l10 as u16, l11 as u16, l12 as u16, l13 as u16, l14 as u16, l15 as u16, l16 as u16, l17 as u16),
+                                    scope_id: l18 as u32,
+                                  }
+                                };
+                                V19::Ipv6(e19)
+                              }
+                            };
+                            
+                            v19
+                          };
+                          Ok(e)
+                        }
+                        1 => {
+                          let e = {
+                            let l20 = i32::from(*((ptr0 + 4) as *const u8));
+                            
+                            super::super::super::wasi::sockets::network::ErrorCode::_lift(l20 as u8)
+                          };
+                          Err(e)
+                        }
+                        _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                      }
+                    }
+                  }
+                }
+                impl TcpSocket {
+                  #[allow(unused_unsafe, clippy::all)]
+                  /// Whether the socket is in the `listening` state.
+                  /// 
+                  /// Equivalent to the SO_ACCEPTCONN socket option.
+                  pub fn is_listening(&self,) -> bool{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/tcp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]tcp-socket.is-listening"]
+                        fn wit_import(_: i32, ) -> i32;
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, ) -> i32{ unreachable!() }
+                      let ret = wit_import((self).handle() as i32);
+                      wit_bindgen::rt::bool_lift(ret as u8)
+                    }
+                  }
+                }
+                impl TcpSocket {
+                  #[allow(unused_unsafe, clippy::all)]
+                  /// Whether this is a IPv4 or IPv6 socket.
+                  /// 
+                  /// Equivalent to the SO_DOMAIN socket option.
+                  pub fn address_family(&self,) -> IpAddressFamily{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/tcp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]tcp-socket.address-family"]
+                        fn wit_import(_: i32, ) -> i32;
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, ) -> i32{ unreachable!() }
+                      let ret = wit_import((self).handle() as i32);
+                      super::super::super::wasi::sockets::network::IpAddressFamily::_lift(ret as u8)
+                    }
+                  }
+                }
+                impl TcpSocket {
+                  #[allow(unused_unsafe, clippy::all)]
+                  /// Hints the desired listen queue size. Implementations are free to ignore this.
+                  /// 
+                  /// If the provided value is 0, an `invalid-argument` error is returned.
+                  /// Any other value will never cause an error, but it might be silently clamped and/or rounded.
+                  /// 
+                  /// # Typical errors
+                  /// - `not-supported`:        (set) The platform does not support changing the backlog size after the initial listen.
+                  /// - `invalid-argument`:     (set) The provided value was 0.
+                  /// - `invalid-state`:        (set) The socket is in the `connect-in-progress` or `connected` state.
+                  pub fn set_listen_backlog_size(&self,value: u64,) -> Result<(),ErrorCode>{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[repr(align(1))]
+                      struct RetArea([u8; 2]);
+                      let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                      let ptr0 = ret_area.as_mut_ptr() as i32;
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/tcp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]tcp-socket.set-listen-backlog-size"]
+                        fn wit_import(_: i32, _: i64, _: i32, );
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, _: i64, _: i32, ){ unreachable!() }
+                      wit_import((self).handle() as i32, wit_bindgen::rt::as_i64(value), ptr0);
+                      let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                      match l1 {
+                        0 => {
+                          let e = ();
+                          Ok(e)
+                        }
+                        1 => {
+                          let e = {
+                            let l2 = i32::from(*((ptr0 + 1) as *const u8));
+                            
+                            super::super::super::wasi::sockets::network::ErrorCode::_lift(l2 as u8)
+                          };
+                          Err(e)
+                        }
+                        _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                      }
+                    }
+                  }
+                }
+                impl TcpSocket {
+                  #[allow(unused_unsafe, clippy::all)]
+                  /// Enables or disables keepalive.
+                  /// 
+                  /// The keepalive behavior can be adjusted using:
+                  /// - `keep-alive-idle-time`
+                  /// - `keep-alive-interval`
+                  /// - `keep-alive-count`
+                  /// These properties can be configured while `keep-alive-enabled` is false, but only come into effect when `keep-alive-enabled` is true.
+                  /// 
+                  /// Equivalent to the SO_KEEPALIVE socket option.
+                  pub fn keep_alive_enabled(&self,) -> Result<bool,ErrorCode>{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[repr(align(1))]
+                      struct RetArea([u8; 2]);
+                      let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                      let ptr0 = ret_area.as_mut_ptr() as i32;
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/tcp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]tcp-socket.keep-alive-enabled"]
+                        fn wit_import(_: i32, _: i32, );
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, _: i32, ){ unreachable!() }
+                      wit_import((self).handle() as i32, ptr0);
+                      let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                      match l1 {
+                        0 => {
+                          let e = {
+                            let l2 = i32::from(*((ptr0 + 1) as *const u8));
+                            
+                            wit_bindgen::rt::bool_lift(l2 as u8)
+                          };
+                          Ok(e)
+                        }
+                        1 => {
+                          let e = {
+                            let l3 = i32::from(*((ptr0 + 1) as *const u8));
+                            
+                            super::super::super::wasi::sockets::network::ErrorCode::_lift(l3 as u8)
+                          };
+                          Err(e)
+                        }
+                        _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                      }
+                    }
+                  }
+                }
+                impl TcpSocket {
+                  #[allow(unused_unsafe, clippy::all)]
+                  pub fn set_keep_alive_enabled(&self,value: bool,) -> Result<(),ErrorCode>{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[repr(align(1))]
+                      struct RetArea([u8; 2]);
+                      let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                      let ptr0 = ret_area.as_mut_ptr() as i32;
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/tcp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]tcp-socket.set-keep-alive-enabled"]
+                        fn wit_import(_: i32, _: i32, _: i32, );
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, _: i32, _: i32, ){ unreachable!() }
+                      wit_import((self).handle() as i32, match value { true => 1, false => 0 }, ptr0);
+                      let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                      match l1 {
+                        0 => {
+                          let e = ();
+                          Ok(e)
+                        }
+                        1 => {
+                          let e = {
+                            let l2 = i32::from(*((ptr0 + 1) as *const u8));
+                            
+                            super::super::super::wasi::sockets::network::ErrorCode::_lift(l2 as u8)
+                          };
+                          Err(e)
+                        }
+                        _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                      }
+                    }
+                  }
+                }
+                impl TcpSocket {
+                  #[allow(unused_unsafe, clippy::all)]
+                  /// Amount of time the connection has to be idle before TCP starts sending keepalive packets.
+                  /// 
+                  /// If the provided value is 0, an `invalid-argument` error is returned.
+                  /// Any other value will never cause an error, but it might be silently clamped and/or rounded.
+                  /// I.e. after setting a value, reading the same setting back may return a different value.
+                  /// 
+                  /// Equivalent to the TCP_KEEPIDLE socket option. (TCP_KEEPALIVE on MacOS)
+                  /// 
+                  /// # Typical errors
+                  /// - `invalid-argument`:     (set) The provided value was 0.
+                  pub fn keep_alive_idle_time(&self,) -> Result<Duration,ErrorCode>{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[repr(align(8))]
+                      struct RetArea([u8; 16]);
+                      let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                      let ptr0 = ret_area.as_mut_ptr() as i32;
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/tcp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]tcp-socket.keep-alive-idle-time"]
+                        fn wit_import(_: i32, _: i32, );
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, _: i32, ){ unreachable!() }
+                      wit_import((self).handle() as i32, ptr0);
+                      let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                      match l1 {
+                        0 => {
+                          let e = {
+                            let l2 = *((ptr0 + 8) as *const i64);
+                            
+                            l2 as u64
+                          };
+                          Ok(e)
+                        }
+                        1 => {
+                          let e = {
+                            let l3 = i32::from(*((ptr0 + 8) as *const u8));
+                            
+                            super::super::super::wasi::sockets::network::ErrorCode::_lift(l3 as u8)
+                          };
+                          Err(e)
+                        }
+                        _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                      }
+                    }
+                  }
+                }
+                impl TcpSocket {
+                  #[allow(unused_unsafe, clippy::all)]
+                  pub fn set_keep_alive_idle_time(&self,value: Duration,) -> Result<(),ErrorCode>{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[repr(align(1))]
+                      struct RetArea([u8; 2]);
+                      let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                      let ptr0 = ret_area.as_mut_ptr() as i32;
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/tcp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]tcp-socket.set-keep-alive-idle-time"]
+                        fn wit_import(_: i32, _: i64, _: i32, );
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, _: i64, _: i32, ){ unreachable!() }
+                      wit_import((self).handle() as i32, wit_bindgen::rt::as_i64(value), ptr0);
+                      let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                      match l1 {
+                        0 => {
+                          let e = ();
+                          Ok(e)
+                        }
+                        1 => {
+                          let e = {
+                            let l2 = i32::from(*((ptr0 + 1) as *const u8));
+                            
+                            super::super::super::wasi::sockets::network::ErrorCode::_lift(l2 as u8)
+                          };
+                          Err(e)
+                        }
+                        _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                      }
+                    }
+                  }
+                }
+                impl TcpSocket {
+                  #[allow(unused_unsafe, clippy::all)]
+                  /// The time between keepalive packets.
+                  /// 
+                  /// If the provided value is 0, an `invalid-argument` error is returned.
+                  /// Any other value will never cause an error, but it might be silently clamped and/or rounded.
+                  /// I.e. after setting a value, reading the same setting back may return a different value.
+                  /// 
+                  /// Equivalent to the TCP_KEEPINTVL socket option.
+                  /// 
+                  /// # Typical errors
+                  /// - `invalid-argument`:     (set) The provided value was 0.
+                  pub fn keep_alive_interval(&self,) -> Result<Duration,ErrorCode>{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[repr(align(8))]
+                      struct RetArea([u8; 16]);
+                      let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                      let ptr0 = ret_area.as_mut_ptr() as i32;
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/tcp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]tcp-socket.keep-alive-interval"]
+                        fn wit_import(_: i32, _: i32, );
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, _: i32, ){ unreachable!() }
+                      wit_import((self).handle() as i32, ptr0);
+                      let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                      match l1 {
+                        0 => {
+                          let e = {
+                            let l2 = *((ptr0 + 8) as *const i64);
+                            
+                            l2 as u64
+                          };
+                          Ok(e)
+                        }
+                        1 => {
+                          let e = {
+                            let l3 = i32::from(*((ptr0 + 8) as *const u8));
+                            
+                            super::super::super::wasi::sockets::network::ErrorCode::_lift(l3 as u8)
+                          };
+                          Err(e)
+                        }
+                        _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                      }
+                    }
+                  }
+                }
+                impl TcpSocket {
+                  #[allow(unused_unsafe, clippy::all)]
+                  pub fn set_keep_alive_interval(&self,value: Duration,) -> Result<(),ErrorCode>{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[repr(align(1))]
+                      struct RetArea([u8; 2]);
+                      let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                      let ptr0 = ret_area.as_mut_ptr() as i32;
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/tcp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]tcp-socket.set-keep-alive-interval"]
+                        fn wit_import(_: i32, _: i64, _: i32, );
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, _: i64, _: i32, ){ unreachable!() }
+                      wit_import((self).handle() as i32, wit_bindgen::rt::as_i64(value), ptr0);
+                      let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                      match l1 {
+                        0 => {
+                          let e = ();
+                          Ok(e)
+                        }
+                        1 => {
+                          let e = {
+                            let l2 = i32::from(*((ptr0 + 1) as *const u8));
+                            
+                            super::super::super::wasi::sockets::network::ErrorCode::_lift(l2 as u8)
+                          };
+                          Err(e)
+                        }
+                        _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                      }
+                    }
+                  }
+                }
+                impl TcpSocket {
+                  #[allow(unused_unsafe, clippy::all)]
+                  /// The maximum amount of keepalive packets TCP should send before aborting the connection.
+                  /// 
+                  /// If the provided value is 0, an `invalid-argument` error is returned.
+                  /// Any other value will never cause an error, but it might be silently clamped and/or rounded.
+                  /// I.e. after setting a value, reading the same setting back may return a different value.
+                  /// 
+                  /// Equivalent to the TCP_KEEPCNT socket option.
+                  /// 
+                  /// # Typical errors
+                  /// - `invalid-argument`:     (set) The provided value was 0.
+                  pub fn keep_alive_count(&self,) -> Result<u32,ErrorCode>{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[repr(align(4))]
+                      struct RetArea([u8; 8]);
+                      let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                      let ptr0 = ret_area.as_mut_ptr() as i32;
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/tcp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]tcp-socket.keep-alive-count"]
+                        fn wit_import(_: i32, _: i32, );
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, _: i32, ){ unreachable!() }
+                      wit_import((self).handle() as i32, ptr0);
+                      let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                      match l1 {
+                        0 => {
+                          let e = {
+                            let l2 = *((ptr0 + 4) as *const i32);
+                            
+                            l2 as u32
+                          };
+                          Ok(e)
+                        }
+                        1 => {
+                          let e = {
+                            let l3 = i32::from(*((ptr0 + 4) as *const u8));
+                            
+                            super::super::super::wasi::sockets::network::ErrorCode::_lift(l3 as u8)
+                          };
+                          Err(e)
+                        }
+                        _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                      }
+                    }
+                  }
+                }
+                impl TcpSocket {
+                  #[allow(unused_unsafe, clippy::all)]
+                  pub fn set_keep_alive_count(&self,value: u32,) -> Result<(),ErrorCode>{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[repr(align(1))]
+                      struct RetArea([u8; 2]);
+                      let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                      let ptr0 = ret_area.as_mut_ptr() as i32;
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/tcp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]tcp-socket.set-keep-alive-count"]
+                        fn wit_import(_: i32, _: i32, _: i32, );
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, _: i32, _: i32, ){ unreachable!() }
+                      wit_import((self).handle() as i32, wit_bindgen::rt::as_i32(value), ptr0);
+                      let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                      match l1 {
+                        0 => {
+                          let e = ();
+                          Ok(e)
+                        }
+                        1 => {
+                          let e = {
+                            let l2 = i32::from(*((ptr0 + 1) as *const u8));
+                            
+                            super::super::super::wasi::sockets::network::ErrorCode::_lift(l2 as u8)
+                          };
+                          Err(e)
+                        }
+                        _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                      }
+                    }
+                  }
+                }
+                impl TcpSocket {
+                  #[allow(unused_unsafe, clippy::all)]
+                  /// Equivalent to the IP_TTL & IPV6_UNICAST_HOPS socket options.
+                  /// 
+                  /// If the provided value is 0, an `invalid-argument` error is returned.
+                  /// 
+                  /// # Typical errors
+                  /// - `invalid-argument`:     (set) The TTL value must be 1 or higher.
+                  pub fn hop_limit(&self,) -> Result<u8,ErrorCode>{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[repr(align(1))]
+                      struct RetArea([u8; 2]);
+                      let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                      let ptr0 = ret_area.as_mut_ptr() as i32;
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/tcp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]tcp-socket.hop-limit"]
+                        fn wit_import(_: i32, _: i32, );
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, _: i32, ){ unreachable!() }
+                      wit_import((self).handle() as i32, ptr0);
+                      let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                      match l1 {
+                        0 => {
+                          let e = {
+                            let l2 = i32::from(*((ptr0 + 1) as *const u8));
+                            
+                            l2 as u8
+                          };
+                          Ok(e)
+                        }
+                        1 => {
+                          let e = {
+                            let l3 = i32::from(*((ptr0 + 1) as *const u8));
+                            
+                            super::super::super::wasi::sockets::network::ErrorCode::_lift(l3 as u8)
+                          };
+                          Err(e)
+                        }
+                        _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                      }
+                    }
+                  }
+                }
+                impl TcpSocket {
+                  #[allow(unused_unsafe, clippy::all)]
+                  pub fn set_hop_limit(&self,value: u8,) -> Result<(),ErrorCode>{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[repr(align(1))]
+                      struct RetArea([u8; 2]);
+                      let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                      let ptr0 = ret_area.as_mut_ptr() as i32;
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/tcp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]tcp-socket.set-hop-limit"]
+                        fn wit_import(_: i32, _: i32, _: i32, );
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, _: i32, _: i32, ){ unreachable!() }
+                      wit_import((self).handle() as i32, wit_bindgen::rt::as_i32(value), ptr0);
+                      let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                      match l1 {
+                        0 => {
+                          let e = ();
+                          Ok(e)
+                        }
+                        1 => {
+                          let e = {
+                            let l2 = i32::from(*((ptr0 + 1) as *const u8));
+                            
+                            super::super::super::wasi::sockets::network::ErrorCode::_lift(l2 as u8)
+                          };
+                          Err(e)
+                        }
+                        _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                      }
+                    }
+                  }
+                }
+                impl TcpSocket {
+                  #[allow(unused_unsafe, clippy::all)]
+                  /// The kernel buffer space reserved for sends/receives on this socket.
+                  /// 
+                  /// If the provided value is 0, an `invalid-argument` error is returned.
+                  /// Any other value will never cause an error, but it might be silently clamped and/or rounded.
+                  /// I.e. after setting a value, reading the same setting back may return a different value.
+                  /// 
+                  /// Equivalent to the SO_RCVBUF and SO_SNDBUF socket options.
+                  /// 
+                  /// # Typical errors
+                  /// - `invalid-argument`:     (set) The provided value was 0.
+                  pub fn receive_buffer_size(&self,) -> Result<u64,ErrorCode>{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[repr(align(8))]
+                      struct RetArea([u8; 16]);
+                      let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                      let ptr0 = ret_area.as_mut_ptr() as i32;
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/tcp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]tcp-socket.receive-buffer-size"]
+                        fn wit_import(_: i32, _: i32, );
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, _: i32, ){ unreachable!() }
+                      wit_import((self).handle() as i32, ptr0);
+                      let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                      match l1 {
+                        0 => {
+                          let e = {
+                            let l2 = *((ptr0 + 8) as *const i64);
+                            
+                            l2 as u64
+                          };
+                          Ok(e)
+                        }
+                        1 => {
+                          let e = {
+                            let l3 = i32::from(*((ptr0 + 8) as *const u8));
+                            
+                            super::super::super::wasi::sockets::network::ErrorCode::_lift(l3 as u8)
+                          };
+                          Err(e)
+                        }
+                        _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                      }
+                    }
+                  }
+                }
+                impl TcpSocket {
+                  #[allow(unused_unsafe, clippy::all)]
+                  pub fn set_receive_buffer_size(&self,value: u64,) -> Result<(),ErrorCode>{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[repr(align(1))]
+                      struct RetArea([u8; 2]);
+                      let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                      let ptr0 = ret_area.as_mut_ptr() as i32;
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/tcp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]tcp-socket.set-receive-buffer-size"]
+                        fn wit_import(_: i32, _: i64, _: i32, );
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, _: i64, _: i32, ){ unreachable!() }
+                      wit_import((self).handle() as i32, wit_bindgen::rt::as_i64(value), ptr0);
+                      let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                      match l1 {
+                        0 => {
+                          let e = ();
+                          Ok(e)
+                        }
+                        1 => {
+                          let e = {
+                            let l2 = i32::from(*((ptr0 + 1) as *const u8));
+                            
+                            super::super::super::wasi::sockets::network::ErrorCode::_lift(l2 as u8)
+                          };
+                          Err(e)
+                        }
+                        _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                      }
+                    }
+                  }
+                }
+                impl TcpSocket {
+                  #[allow(unused_unsafe, clippy::all)]
+                  pub fn send_buffer_size(&self,) -> Result<u64,ErrorCode>{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[repr(align(8))]
+                      struct RetArea([u8; 16]);
+                      let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                      let ptr0 = ret_area.as_mut_ptr() as i32;
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/tcp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]tcp-socket.send-buffer-size"]
+                        fn wit_import(_: i32, _: i32, );
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, _: i32, ){ unreachable!() }
+                      wit_import((self).handle() as i32, ptr0);
+                      let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                      match l1 {
+                        0 => {
+                          let e = {
+                            let l2 = *((ptr0 + 8) as *const i64);
+                            
+                            l2 as u64
+                          };
+                          Ok(e)
+                        }
+                        1 => {
+                          let e = {
+                            let l3 = i32::from(*((ptr0 + 8) as *const u8));
+                            
+                            super::super::super::wasi::sockets::network::ErrorCode::_lift(l3 as u8)
+                          };
+                          Err(e)
+                        }
+                        _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                      }
+                    }
+                  }
+                }
+                impl TcpSocket {
+                  #[allow(unused_unsafe, clippy::all)]
+                  pub fn set_send_buffer_size(&self,value: u64,) -> Result<(),ErrorCode>{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[repr(align(1))]
+                      struct RetArea([u8; 2]);
+                      let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                      let ptr0 = ret_area.as_mut_ptr() as i32;
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/tcp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]tcp-socket.set-send-buffer-size"]
+                        fn wit_import(_: i32, _: i64, _: i32, );
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, _: i64, _: i32, ){ unreachable!() }
+                      wit_import((self).handle() as i32, wit_bindgen::rt::as_i64(value), ptr0);
+                      let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                      match l1 {
+                        0 => {
+                          let e = ();
+                          Ok(e)
+                        }
+                        1 => {
+                          let e = {
+                            let l2 = i32::from(*((ptr0 + 1) as *const u8));
+                            
+                            super::super::super::wasi::sockets::network::ErrorCode::_lift(l2 as u8)
+                          };
+                          Err(e)
+                        }
+                        _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                      }
+                    }
+                  }
+                }
+                impl TcpSocket {
+                  #[allow(unused_unsafe, clippy::all)]
+                  /// Create a `pollable` which can be used to poll for, or block on,
+                  /// completion of any of the asynchronous operations of this socket.
+                  /// 
+                  /// When `finish-bind`, `finish-listen`, `finish-connect` or `accept`
+                  /// return `error(would-block)`, this pollable can be used to wait for
+                  /// their success or failure, after which the method can be retried.
+                  /// 
+                  /// The pollable is not limited to the async operation that happens to be
+                  /// in progress at the time of calling `subscribe` (if any). Theoretically,
+                  /// `subscribe` only has to be called once per socket and can then be
+                  /// (re)used for the remainder of the socket's lifetime.
+                  /// 
+                  /// See <https://github.com/WebAssembly/wasi-sockets/TcpSocketOperationalSemantics.md#Pollable-readiness>
+                  /// for a more information.
+                  /// 
+                  /// Note: this function is here for WASI Preview2 only.
+                  /// It's planned to be removed when `future` is natively supported in Preview3.
+                  pub fn subscribe(&self,) -> Pollable{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/tcp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]tcp-socket.subscribe"]
+                        fn wit_import(_: i32, ) -> i32;
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, ) -> i32{ unreachable!() }
+                      let ret = wit_import((self).handle() as i32);
+                      super::super::super::wasi::io::poll::Pollable::from_handle(ret as u32)
+                    }
+                  }
+                }
+                impl TcpSocket {
+                  #[allow(unused_unsafe, clippy::all)]
+                  /// Initiate a graceful shutdown.
+                  /// 
+                  /// - `receive`: The socket is not expecting to receive any data from
+                  /// the peer. The `input-stream` associated with this socket will be
+                  /// closed. Any data still in the receive queue at time of calling
+                  /// this method will be discarded.
+                  /// - `send`: The socket has no more data to send to the peer. The `output-stream`
+                  /// associated with this socket will be closed and a FIN packet will be sent.
+                  /// - `both`: Same effect as `receive` & `send` combined.
+                  /// 
+                  /// This function is idempotent. Shutting a down a direction more than once
+                  /// has no effect and returns `ok`.
+                  /// 
+                  /// The shutdown function does not close (drop) the socket.
+                  /// 
+                  /// # Typical errors
+                  /// - `invalid-state`: The socket is not in the `connected` state. (ENOTCONN)
+                  /// 
+                  /// # References
+                  /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/shutdown.html>
+                  /// - <https://man7.org/linux/man-pages/man2/shutdown.2.html>
+                  /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-shutdown>
+                  /// - <https://man.freebsd.org/cgi/man.cgi?query=shutdown&sektion=2>
+                  pub fn shutdown(&self,shutdown_type: ShutdownType,) -> Result<(),ErrorCode>{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[repr(align(1))]
+                      struct RetArea([u8; 2]);
+                      let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                      let ptr0 = ret_area.as_mut_ptr() as i32;
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/tcp@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]tcp-socket.shutdown"]
+                        fn wit_import(_: i32, _: i32, _: i32, );
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, _: i32, _: i32, ){ unreachable!() }
+                      wit_import((self).handle() as i32, shutdown_type.clone() as i32, ptr0);
+                      let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                      match l1 {
+                        0 => {
+                          let e = ();
+                          Ok(e)
+                        }
+                        1 => {
+                          let e = {
+                            let l2 = i32::from(*((ptr0 + 1) as *const u8));
+                            
+                            super::super::super::wasi::sockets::network::ErrorCode::_lift(l2 as u8)
+                          };
+                          Err(e)
+                        }
+                        _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                      }
+                    }
+                  }
+                }
+                
+              }
+              
+              
+              #[allow(clippy::all)]
+              pub mod tcp_create_socket {
+                #[used]
+                #[doc(hidden)]
+                #[cfg(target_arch = "wasm32")]
+                static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+                pub type ErrorCode = super::super::super::wasi::sockets::network::ErrorCode;
+                pub type IpAddressFamily = super::super::super::wasi::sockets::network::IpAddressFamily;
+                pub type TcpSocket = super::super::super::wasi::sockets::tcp::TcpSocket;
+                #[allow(unused_unsafe, clippy::all)]
+                /// Create a new TCP socket.
+                /// 
+                /// Similar to `socket(AF_INET or AF_INET6, SOCK_STREAM, IPPROTO_TCP)` in POSIX.
+                /// On IPv6 sockets, IPV6_V6ONLY is enabled by default and can't be configured otherwise.
+                /// 
+                /// This function does not require a network capability handle. This is considered to be safe because
+                /// at time of creation, the socket is not bound to any `network` yet. Up to the moment `bind`/`connect`
+                /// is called, the socket is effectively an in-memory configuration object, unable to communicate with the outside world.
+                /// 
+                /// All sockets are non-blocking. Use the wasi-poll interface to block on asynchronous operations.
+                /// 
+                /// # Typical errors
+                /// - `not-supported`:     The specified `address-family` is not supported. (EAFNOSUPPORT)
+                /// - `new-socket-limit`:  The new socket resource could not be created because of a system limit. (EMFILE, ENFILE)
+                /// 
+                /// # References
+                /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/socket.html>
+                /// - <https://man7.org/linux/man-pages/man2/socket.2.html>
+                /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasocketw>
+                /// - <https://man.freebsd.org/cgi/man.cgi?query=socket&sektion=2>
+                pub fn create_tcp_socket(address_family: IpAddressFamily,) -> Result<TcpSocket,ErrorCode>{
+                  
+                  #[allow(unused_imports)]
+                  use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                  unsafe {
+                    
+                    #[repr(align(4))]
+                    struct RetArea([u8; 8]);
+                    let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                    let ptr0 = ret_area.as_mut_ptr() as i32;
+                    #[cfg(target_arch = "wasm32")]
+                    #[link(wasm_import_module = "wasi:sockets/tcp-create-socket@0.2.0")]
+                    extern "C" {
+                      #[link_name = "create-tcp-socket"]
+                      fn wit_import(_: i32, _: i32, );
+                    }
+                    
+                    #[cfg(not(target_arch = "wasm32"))]
+                    fn wit_import(_: i32, _: i32, ){ unreachable!() }
+                    wit_import(address_family.clone() as i32, ptr0);
+                    let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                    match l1 {
+                      0 => {
+                        let e = {
+                          let l2 = *((ptr0 + 4) as *const i32);
+                          
+                          super::super::super::wasi::sockets::tcp::TcpSocket::from_handle(l2 as u32)
+                        };
+                        Ok(e)
+                      }
+                      1 => {
+                        let e = {
+                          let l3 = i32::from(*((ptr0 + 4) as *const u8));
+                          
+                          super::super::super::wasi::sockets::network::ErrorCode::_lift(l3 as u8)
+                        };
+                        Err(e)
+                      }
+                      _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                    }
+                  }
+                }
+                
+              }
+              
+              
+              #[allow(clippy::all)]
+              pub mod ip_name_lookup {
+                #[used]
+                #[doc(hidden)]
+                #[cfg(target_arch = "wasm32")]
+                static __FORCE_SECTION_REF: fn() = super::super::super::__link_section;
+                pub type Pollable = super::super::super::wasi::io::poll::Pollable;
+                pub type Network = super::super::super::wasi::sockets::network::Network;
+                pub type ErrorCode = super::super::super::wasi::sockets::network::ErrorCode;
+                pub type IpAddress = super::super::super::wasi::sockets::network::IpAddress;
+                
+                #[derive(Debug)]
+                #[repr(transparent)]
+                pub struct ResolveAddressStream{
+                  handle: wit_bindgen::rt::Resource<ResolveAddressStream>,
+                }
+                
+                impl ResolveAddressStream{
+                  #[doc(hidden)]
+                  pub unsafe fn from_handle(handle: u32) -> Self {
+                    Self {
+                      handle: wit_bindgen::rt::Resource::from_handle(handle),
+                    }
+                  }
+                  
+                  #[doc(hidden)]
+                  pub fn into_handle(self) -> u32 {
+                    wit_bindgen::rt::Resource::into_handle(self.handle)
+                  }
+                  
+                  #[doc(hidden)]
+                  pub fn handle(&self) -> u32 {
+                    wit_bindgen::rt::Resource::handle(&self.handle)
+                  }
+                }
+                
+                
+                unsafe impl wit_bindgen::rt::WasmResource for ResolveAddressStream{
+                  #[inline]
+                  unsafe fn drop(_handle: u32) {
+                    #[cfg(not(target_arch = "wasm32"))]
+                    unreachable!();
+                    
+                    #[cfg(target_arch = "wasm32")]
+                    {
+                      #[link(wasm_import_module = "wasi:sockets/ip-name-lookup@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[resource-drop]resolve-address-stream"]
+                        fn drop(_: u32);
+                      }
+                      
+                      drop(_handle);
+                    }
+                  }
+                }
+                
+                #[allow(unused_unsafe, clippy::all)]
+                /// Resolve an internet host name to a list of IP addresses.
+                /// 
+                /// Unicode domain names are automatically converted to ASCII using IDNA encoding.
+                /// If the input is an IP address string, the address is parsed and returned
+                /// as-is without making any external requests.
+                /// 
+                /// See the wasi-socket proposal README.md for a comparison with getaddrinfo.
+                /// 
+                /// This function never blocks. It either immediately fails or immediately
+                /// returns successfully with a `resolve-address-stream` that can be used
+                /// to (asynchronously) fetch the results.
+                /// 
+                /// # Typical errors
+                /// - `invalid-argument`: `name` is a syntactically invalid domain name or IP address.
+                /// 
+                /// # References:
+                /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getaddrinfo.html>
+                /// - <https://man7.org/linux/man-pages/man3/getaddrinfo.3.html>
+                /// - <https://learn.microsoft.com/en-us/windows/win32/api/ws2tcpip/nf-ws2tcpip-getaddrinfo>
+                /// - <https://man.freebsd.org/cgi/man.cgi?query=getaddrinfo&sektion=3>
+                pub fn resolve_addresses(network: &Network,name: &str,) -> Result<ResolveAddressStream,ErrorCode>{
+                  
+                  #[allow(unused_imports)]
+                  use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                  unsafe {
+                    
+                    #[repr(align(4))]
+                    struct RetArea([u8; 8]);
+                    let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                    let vec0 = name;
+                    let ptr0 = vec0.as_ptr() as i32;
+                    let len0 = vec0.len() as i32;
+                    let ptr1 = ret_area.as_mut_ptr() as i32;
+                    #[cfg(target_arch = "wasm32")]
+                    #[link(wasm_import_module = "wasi:sockets/ip-name-lookup@0.2.0")]
+                    extern "C" {
+                      #[link_name = "resolve-addresses"]
+                      fn wit_import(_: i32, _: i32, _: i32, _: i32, );
+                    }
+                    
+                    #[cfg(not(target_arch = "wasm32"))]
+                    fn wit_import(_: i32, _: i32, _: i32, _: i32, ){ unreachable!() }
+                    wit_import((network).handle() as i32, ptr0, len0, ptr1);
+                    let l2 = i32::from(*((ptr1 + 0) as *const u8));
+                    match l2 {
+                      0 => {
+                        let e = {
+                          let l3 = *((ptr1 + 4) as *const i32);
+                          
+                          ResolveAddressStream::from_handle(l3 as u32)
+                        };
+                        Ok(e)
+                      }
+                      1 => {
+                        let e = {
+                          let l4 = i32::from(*((ptr1 + 4) as *const u8));
+                          
+                          super::super::super::wasi::sockets::network::ErrorCode::_lift(l4 as u8)
+                        };
+                        Err(e)
+                      }
+                      _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                    }
+                  }
+                }
+                impl ResolveAddressStream {
+                  #[allow(unused_unsafe, clippy::all)]
+                  /// Returns the next address from the resolver.
+                  /// 
+                  /// This function should be called multiple times. On each call, it will
+                  /// return the next address in connection order preference. If all
+                  /// addresses have been exhausted, this function returns `none`.
+                  /// 
+                  /// This function never returns IPv4-mapped IPv6 addresses.
+                  /// 
+                  /// # Typical errors
+                  /// - `name-unresolvable`:          Name does not exist or has no suitable associated IP addresses. (EAI_NONAME, EAI_NODATA, EAI_ADDRFAMILY)
+                  /// - `temporary-resolver-failure`: A temporary failure in name resolution occurred. (EAI_AGAIN)
+                  /// - `permanent-resolver-failure`: A permanent failure in name resolution occurred. (EAI_FAIL)
+                  /// - `would-block`:                A result is not available yet. (EWOULDBLOCK, EAGAIN)
+                  pub fn resolve_next_address(&self,) -> Result<Option<IpAddress>,ErrorCode>{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[repr(align(2))]
+                      struct RetArea([u8; 22]);
+                      let mut ret_area = ::core::mem::MaybeUninit::<RetArea>::uninit();
+                      let ptr0 = ret_area.as_mut_ptr() as i32;
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/ip-name-lookup@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]resolve-address-stream.resolve-next-address"]
+                        fn wit_import(_: i32, _: i32, );
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, _: i32, ){ unreachable!() }
+                      wit_import((self).handle() as i32, ptr0);
+                      let l1 = i32::from(*((ptr0 + 0) as *const u8));
+                      match l1 {
+                        0 => {
+                          let e = {
+                            let l2 = i32::from(*((ptr0 + 2) as *const u8));
+                            
+                            match l2 {
+                              0 => None,
+                              1 => {
+                                let e = {
+                                  let l3 = i32::from(*((ptr0 + 4) as *const u8));
+                                  use super::super::super::wasi::sockets::network::IpAddress as V16;
+                                  let v16 = match l3 {
+                                    0 => {
+                                      let e16 = {
+                                        let l4 = i32::from(*((ptr0 + 6) as *const u8));
+                                        let l5 = i32::from(*((ptr0 + 7) as *const u8));
+                                        let l6 = i32::from(*((ptr0 + 8) as *const u8));
+                                        let l7 = i32::from(*((ptr0 + 9) as *const u8));
+                                        
+                                        (l4 as u8, l5 as u8, l6 as u8, l7 as u8)
+                                      };
+                                      V16::Ipv4(e16)
+                                    }
+                                    n => {
+                                      debug_assert_eq!(n, 1, "invalid enum discriminant");
+                                      let e16 = {
+                                        let l8 = i32::from(*((ptr0 + 6) as *const u16));
+                                        let l9 = i32::from(*((ptr0 + 8) as *const u16));
+                                        let l10 = i32::from(*((ptr0 + 10) as *const u16));
+                                        let l11 = i32::from(*((ptr0 + 12) as *const u16));
+                                        let l12 = i32::from(*((ptr0 + 14) as *const u16));
+                                        let l13 = i32::from(*((ptr0 + 16) as *const u16));
+                                        let l14 = i32::from(*((ptr0 + 18) as *const u16));
+                                        let l15 = i32::from(*((ptr0 + 20) as *const u16));
+                                        
+                                        (l8 as u16, l9 as u16, l10 as u16, l11 as u16, l12 as u16, l13 as u16, l14 as u16, l15 as u16)
+                                      };
+                                      V16::Ipv6(e16)
+                                    }
+                                  };
+                                  
+                                  v16
+                                };
+                                Some(e)
+                              }
+                              _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                            }
+                          };
+                          Ok(e)
+                        }
+                        1 => {
+                          let e = {
+                            let l17 = i32::from(*((ptr0 + 2) as *const u8));
+                            
+                            super::super::super::wasi::sockets::network::ErrorCode::_lift(l17 as u8)
+                          };
+                          Err(e)
+                        }
+                        _ => wit_bindgen::rt::invalid_enum_discriminant(),
+                      }
+                    }
+                  }
+                }
+                impl ResolveAddressStream {
+                  #[allow(unused_unsafe, clippy::all)]
+                  /// Create a `pollable` which will resolve once the stream is ready for I/O.
+                  /// 
+                  /// Note: this function is here for WASI Preview2 only.
+                  /// It's planned to be removed when `future` is natively supported in Preview3.
+                  pub fn subscribe(&self,) -> Pollable{
+                    
+                    #[allow(unused_imports)]
+                    use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                    unsafe {
+                      
+                      #[cfg(target_arch = "wasm32")]
+                      #[link(wasm_import_module = "wasi:sockets/ip-name-lookup@0.2.0")]
+                      extern "C" {
+                        #[link_name = "[method]resolve-address-stream.subscribe"]
+                        fn wit_import(_: i32, ) -> i32;
+                      }
+                      
+                      #[cfg(not(target_arch = "wasm32"))]
+                      fn wit_import(_: i32, ) -> i32{ unreachable!() }
+                      let ret = wit_import((self).handle() as i32);
+                      super::super::super::wasi::io::poll::Pollable::from_handle(ret as u32)
+                    }
+                  }
+                }
+                
+              }
+              
+            }
+          }
+          pub mod exports {
+            pub mod wasi {
+              pub mod cli {
+                
+                #[allow(clippy::all)]
+                pub mod run {
+                  #[used]
+                  #[doc(hidden)]
+                  #[cfg(target_arch = "wasm32")]
+                  static __FORCE_SECTION_REF: fn() = super::super::super::super::__link_section;
+                  const _: () = {
+                    
+                    #[doc(hidden)]
+                    #[export_name = "wasi:cli/run@0.2.0#run"]
+                    #[allow(non_snake_case)]
+                    unsafe extern "C" fn __export_run() -> i32 {
+                      #[allow(unused_imports)]
+                      use wit_bindgen::rt::{alloc, vec::Vec, string::String};
+                      
+                      // Before executing any other code, use this function to run all static
+                      // constructors, if they have not yet been run. This is a hack required
+                      // to work around wasi-libc ctors calling import functions to initialize
+                      // the environment.
+                      //
+                      // This functionality will be removed once rust 1.69.0 is stable, at which
+                      // point wasi-libc will no longer have this behavior.
+                      //
+                      // See
+                      // https://github.com/bytecodealliance/preview2-prototyping/issues/99
+                      // for more details.
+                      #[cfg(target_arch="wasm32")]
+                      wit_bindgen::rt::run_ctors_once();
+                      
+                      let result0 = <_GuestImpl as Guest>::run();
+                      let result1 = match result0 {
+                        Ok(_) => { 0i32 },
+                        Err(_) => { 1i32 },
+                      };result1
+                    }
+                  };
+                  use super::super::super::super::super::Component as _GuestImpl;
+                  pub trait Guest {
+                    /// Run the program.
+                    fn run() -> Result<(),()>;
+                  }
+                  
+                }
+                
+              }
+            }
+          }
+          
+          #[cfg(target_arch = "wasm32")]
+          #[link_section = "component-type:classify"]
+          #[doc(hidden)]
+          pub static __WIT_BINDGEN_COMPONENT_TYPE: [u8; 11690] = [3, 0, 8, 99, 108, 97, 115, 115, 105, 102, 121, 0, 97, 115, 109, 13, 0, 1, 0, 7, 170, 90, 1, 65, 2, 1, 65, 85, 1, 66, 10, 1, 111, 2, 115, 115, 1, 112, 0, 1, 64, 0, 0, 1, 4, 0, 15, 103, 101, 116, 45, 101, 110, 118, 105, 114, 111, 110, 109, 101, 110, 116, 1, 2, 1, 112, 115, 1, 64, 0, 0, 3, 4, 0, 13, 103, 101, 116, 45, 97, 114, 103, 117, 109, 101, 110, 116, 115, 1, 4, 1, 107, 115, 1, 64, 0, 0, 5, 4, 0, 11, 105, 110, 105, 116, 105, 97, 108, 45, 99, 119, 100, 1, 6, 3, 1, 26, 119, 97, 115, 105, 58, 99, 108, 105, 47, 101, 110, 118, 105, 114, 111, 110, 109, 101, 110, 116, 64, 48, 46, 50, 46, 48, 5, 0, 1, 66, 3, 1, 106, 0, 0, 1, 64, 1, 6, 115, 116, 97, 116, 117, 115, 0, 1, 0, 4, 0, 4, 101, 120, 105, 116, 1, 1, 3, 1, 19, 119, 97, 115, 105, 58, 99, 108, 105, 47, 101, 120, 105, 116, 64, 48, 46, 50, 46, 48, 5, 1, 1, 66, 4, 4, 0, 5, 101, 114, 114, 111, 114, 3, 1, 1, 104, 0, 1, 64, 1, 4, 115, 101, 108, 102, 1, 0, 115, 4, 0, 29, 91, 109, 101, 116, 104, 111, 100, 93, 101, 114, 114, 111, 114, 46, 116, 111, 45, 100, 101, 98, 117, 103, 45, 115, 116, 114, 105, 110, 103, 1, 2, 3, 1, 19, 119, 97, 115, 105, 58, 105, 111, 47, 101, 114, 114, 111, 114, 64, 48, 46, 50, 46, 48, 5, 2, 1, 66, 10, 4, 0, 8, 112, 111, 108, 108, 97, 98, 108, 101, 3, 1, 1, 104, 0, 1, 64, 1, 4, 115, 101, 108, 102, 1, 0, 127, 4, 0, 22, 91, 109, 101, 116, 104, 111, 100, 93, 112, 111, 108, 108, 97, 98, 108, 101, 46, 114, 101, 97, 100, 121, 1, 2, 1, 64, 1, 4, 115, 101, 108, 102, 1, 1, 0, 4, 0, 22, 91, 109, 101, 116, 104, 111, 100, 93, 112, 111, 108, 108, 97, 98, 108, 101, 46, 98, 108, 111, 99, 107, 1, 3, 1, 112, 1, 1, 112, 121, 1, 64, 1, 2, 105, 110, 4, 0, 5, 4, 0, 4, 112, 111, 108, 108, 1, 6, 3, 1, 18, 119, 97, 115, 105, 58, 105, 111, 47, 112, 111, 108, 108, 64, 48, 46, 50, 46, 48, 5, 3, 2, 3, 0, 2, 5, 101, 114, 114, 111, 114, 2, 3, 0, 3, 8, 112, 111, 108, 108, 97, 98, 108, 101, 1, 66, 40, 2, 3, 2, 1, 4, 4, 0, 5, 101, 114, 114, 111, 114, 3, 0, 0, 2, 3, 2, 1, 5, 4, 0, 8, 112, 111, 108, 108, 97, 98, 108, 101, 3, 0, 2, 1, 105, 1, 1, 113, 2, 21, 108, 97, 115, 116, 45, 111, 112, 101, 114, 97, 116, 105, 111, 110, 45, 102, 97, 105, 108, 101, 100, 1, 4, 0, 6, 99, 108, 111, 115, 101, 100, 0, 0, 4, 0, 12, 115, 116, 114, 101, 97, 109, 45, 101, 114, 114, 111, 114, 3, 0, 5, 4, 0, 12, 105, 110, 112, 117, 116, 45, 115, 116, 114, 101, 97, 109, 3, 1, 4, 0, 13, 111, 117, 116, 112, 117, 116, 45, 115, 116, 114, 101, 97, 109, 3, 1, 1, 104, 7, 1, 112, 125, 1, 106, 1, 10, 1, 6, 1, 64, 2, 4, 115, 101, 108, 102, 9, 3, 108, 101, 110, 119, 0, 11, 4, 0, 25, 91, 109, 101, 116, 104, 111, 100, 93, 105, 110, 112, 117, 116, 45, 115, 116, 114, 101, 97, 109, 46, 114, 101, 97, 100, 1, 12, 4, 0, 34, 91, 109, 101, 116, 104, 111, 100, 93, 105, 110, 112, 117, 116, 45, 115, 116, 114, 101, 97, 109, 46, 98, 108, 111, 99, 107, 105, 110, 103, 45, 114, 101, 97, 100, 1, 12, 1, 106, 1, 119, 1, 6, 1, 64, 2, 4, 115, 101, 108, 102, 9, 3, 108, 101, 110, 119, 0, 13, 4, 0, 25, 91, 109, 101, 116, 104, 111, 100, 93, 105, 110, 112, 117, 116, 45, 115, 116, 114, 101, 97, 109, 46, 115, 107, 105, 112, 1, 14, 4, 0, 34, 91, 109, 101, 116, 104, 111, 100, 93, 105, 110, 112, 117, 116, 45, 115, 116, 114, 101, 97, 109, 46, 98, 108, 111, 99, 107, 105, 110, 103, 45, 115, 107, 105, 112, 1, 14, 1, 105, 3, 1, 64, 1, 4, 115, 101, 108, 102, 9, 0, 15, 4, 0, 30, 91, 109, 101, 116, 104, 111, 100, 93, 105, 110, 112, 117, 116, 45, 115, 116, 114, 101, 97, 109, 46, 115, 117, 98, 115, 99, 114, 105, 98, 101, 1, 16, 1, 104, 8, 1, 64, 1, 4, 115, 101, 108, 102, 17, 0, 13, 4, 0, 33, 91, 109, 101, 116, 104, 111, 100, 93, 111, 117, 116, 112, 117, 116, 45, 115, 116, 114, 101, 97, 109, 46, 99, 104, 101, 99, 107, 45, 119, 114, 105, 116, 101, 1, 18, 1, 106, 0, 1, 6, 1, 64, 2, 4, 115, 101, 108, 102, 17, 8, 99, 111, 110, 116, 101, 110, 116, 115, 10, 0, 19, 4, 0, 27, 91, 109, 101, 116, 104, 111, 100, 93, 111, 117, 116, 112, 117, 116, 45, 115, 116, 114, 101, 97, 109, 46, 119, 114, 105, 116, 101, 1, 20, 4, 0, 46, 91, 109, 101, 116, 104, 111, 100, 93, 111, 117, 116, 112, 117, 116, 45, 115, 116, 114, 101, 97, 109, 46, 98, 108, 111, 99, 107, 105, 110, 103, 45, 119, 114, 105, 116, 101, 45, 97, 110, 100, 45, 102, 108, 117, 115, 104, 1, 20, 1, 64, 1, 4, 115, 101, 108, 102, 17, 0, 19, 4, 0, 27, 91, 109, 101, 116, 104, 111, 100, 93, 111, 117, 116, 112, 117, 116, 45, 115, 116, 114, 101, 97, 109, 46, 102, 108, 117, 115, 104, 1, 21, 4, 0, 36, 91, 109, 101, 116, 104, 111, 100, 93, 111, 117, 116, 112, 117, 116, 45, 115, 116, 114, 101, 97, 109, 46, 98, 108, 111, 99, 107, 105, 110, 103, 45, 102, 108, 117, 115, 104, 1, 21, 1, 64, 1, 4, 115, 101, 108, 102, 17, 0, 15, 4, 0, 31, 91, 109, 101, 116, 104, 111, 100, 93, 111, 117, 116, 112, 117, 116, 45, 115, 116, 114, 101, 97, 109, 46, 115, 117, 98, 115, 99, 114, 105, 98, 101, 1, 22, 1, 64, 2, 4, 115, 101, 108, 102, 17, 3, 108, 101, 110, 119, 0, 19, 4, 0, 34, 91, 109, 101, 116, 104, 111, 100, 93, 111, 117, 116, 112, 117, 116, 45, 115, 116, 114, 101, 97, 109, 46, 119, 114, 105, 116, 101, 45, 122, 101, 114, 111, 101, 115, 1, 23, 4, 0, 53, 91, 109, 101, 116, 104, 111, 100, 93, 111, 117, 116, 112, 117, 116, 45, 115, 116, 114, 101, 97, 109, 46, 98, 108, 111, 99, 107, 105, 110, 103, 45, 119, 114, 105, 116, 101, 45, 122, 101, 114, 111, 101, 115, 45, 97, 110, 100, 45, 102, 108, 117, 115, 104, 1, 23, 1, 64, 3, 4, 115, 101, 108, 102, 17, 3, 115, 114, 99, 9, 3, 108, 101, 110, 119, 0, 13, 4, 0, 28, 91, 109, 101, 116, 104, 111, 100, 93, 111, 117, 116, 112, 117, 116, 45, 115, 116, 114, 101, 97, 109, 46, 115, 112, 108, 105, 99, 101, 1, 24, 4, 0, 37, 91, 109, 101, 116, 104, 111, 100, 93, 111, 117, 116, 112, 117, 116, 45, 115, 116, 114, 101, 97, 109, 46, 98, 108, 111, 99, 107, 105, 110, 103, 45, 115, 112, 108, 105, 99, 101, 1, 24, 3, 1, 21, 119, 97, 115, 105, 58, 105, 111, 47, 115, 116, 114, 101, 97, 109, 115, 64, 48, 46, 50, 46, 48, 5, 6, 2, 3, 0, 4, 12, 105, 110, 112, 117, 116, 45, 115, 116, 114, 101, 97, 109, 1, 66, 5, 2, 3, 2, 1, 7, 4, 0, 12, 105, 110, 112, 117, 116, 45, 115, 116, 114, 101, 97, 109, 3, 0, 0, 1, 105, 1, 1, 64, 0, 0, 2, 4, 0, 9, 103, 101, 116, 45, 115, 116, 100, 105, 110, 1, 3, 3, 1, 20, 119, 97, 115, 105, 58, 99, 108, 105, 47, 115, 116, 100, 105, 110, 64, 48, 46, 50, 46, 48, 5, 8, 2, 3, 0, 4, 13, 111, 117, 116, 112, 117, 116, 45, 115, 116, 114, 101, 97, 109, 1, 66, 5, 2, 3, 2, 1, 9, 4, 0, 13, 111, 117, 116, 112, 117, 116, 45, 115, 116, 114, 101, 97, 109, 3, 0, 0, 1, 105, 1, 1, 64, 0, 0, 2, 4, 0, 10, 103, 101, 116, 45, 115, 116, 100, 111, 117, 116, 1, 3, 3, 1, 21, 119, 97, 115, 105, 58, 99, 108, 105, 47, 115, 116, 100, 111, 117, 116, 64, 48, 46, 50, 46, 48, 5, 10, 1, 66, 5, 2, 3, 2, 1, 9, 4, 0, 13, 111, 117, 116, 112, 117, 116, 45, 115, 116, 114, 101, 97, 109, 3, 0, 0, 1, 105, 1, 1, 64, 0, 0, 2, 4, 0, 10, 103, 101, 116, 45, 115, 116, 100, 101, 114, 114, 1, 3, 3, 1, 21, 119, 97, 115, 105, 58, 99, 108, 105, 47, 115, 116, 100, 101, 114, 114, 64, 48, 46, 50, 46, 48, 5, 11, 1, 66, 1, 4, 0, 14, 116, 101, 114, 109, 105, 110, 97, 108, 45, 105, 110, 112, 117, 116, 3, 1, 3, 1, 29, 119, 97, 115, 105, 58, 99, 108, 105, 47, 116, 101, 114, 109, 105, 110, 97, 108, 45, 105, 110, 112, 117, 116, 64, 48, 46, 50, 46, 48, 5, 12, 1, 66, 1, 4, 0, 15, 116, 101, 114, 109, 105, 110, 97, 108, 45, 111, 117, 116, 112, 117, 116, 3, 1, 3, 1, 30, 119, 97, 115, 105, 58, 99, 108, 105, 47, 116, 101, 114, 109, 105, 110, 97, 108, 45, 111, 117, 116, 112, 117, 116, 64, 48, 46, 50, 46, 48, 5, 13, 2, 3, 0, 8, 14, 116, 101, 114, 109, 105, 110, 97, 108, 45, 105, 110, 112, 117, 116, 1, 66, 6, 2, 3, 2, 1, 14, 4, 0, 14, 116, 101, 114, 109, 105, 110, 97, 108, 45, 105, 110, 112, 117, 116, 3, 0, 0, 1, 105, 1, 1, 107, 2, 1, 64, 0, 0, 3, 4, 0, 18, 103, 101, 116, 45, 116, 101, 114, 109, 105, 110, 97, 108, 45, 115, 116, 100, 105, 110, 1, 4, 3, 1, 29, 119, 97, 115, 105, 58, 99, 108, 105, 47, 116, 101, 114, 109, 105, 110, 97, 108, 45, 115, 116, 100, 105, 110, 64, 48, 46, 50, 46, 48, 5, 15, 2, 3, 0, 9, 15, 116, 101, 114, 109, 105, 110, 97, 108, 45, 111, 117, 116, 112, 117, 116, 1, 66, 6, 2, 3, 2, 1, 16, 4, 0, 15, 116, 101, 114, 109, 105, 110, 97, 108, 45, 111, 117, 116, 112, 117, 116, 3, 0, 0, 1, 105, 1, 1, 107, 2, 1, 64, 0, 0, 3, 4, 0, 19, 103, 101, 116, 45, 116, 101, 114, 109, 105, 110, 97, 108, 45, 115, 116, 100, 111, 117, 116, 1, 4, 3, 1, 30, 119, 97, 115, 105, 58, 99, 108, 105, 47, 116, 101, 114, 109, 105, 110, 97, 108, 45, 115, 116, 100, 111, 117, 116, 64, 48, 46, 50, 46, 48, 5, 17, 1, 66, 6, 2, 3, 2, 1, 16, 4, 0, 15, 116, 101, 114, 109, 105, 110, 97, 108, 45, 111, 117, 116, 112, 117, 116, 3, 0, 0, 1, 105, 1, 1, 107, 2, 1, 64, 0, 0, 3, 4, 0, 19, 103, 101, 116, 45, 116, 101, 114, 109, 105, 110, 97, 108, 45, 115, 116, 100, 101, 114, 114, 1, 4, 3, 1, 30, 119, 97, 115, 105, 58, 99, 108, 105, 47, 116, 101, 114, 109, 105, 110, 97, 108, 45, 115, 116, 100, 101, 114, 114, 64, 48, 46, 50, 46, 48, 5, 18, 1, 66, 15, 2, 3, 2, 1, 5, 4, 0, 8, 112, 111, 108, 108, 97, 98, 108, 101, 3, 0, 0, 1, 119, 4, 0, 7, 105, 110, 115, 116, 97, 110, 116, 3, 0, 2, 1, 119, 4, 0, 8, 100, 117, 114, 97, 116, 105, 111, 110, 3, 0, 4, 1, 64, 0, 0, 3, 4, 0, 3, 110, 111, 119, 1, 6, 1, 64, 0, 0, 5, 4, 0, 10, 114, 101, 115, 111, 108, 117, 116, 105, 111, 110, 1, 7, 1, 105, 1, 1, 64, 1, 4, 119, 104, 101, 110, 3, 0, 8, 4, 0, 17, 115, 117, 98, 115, 99, 114, 105, 98, 101, 45, 105, 110, 115, 116, 97, 110, 116, 1, 9, 1, 64, 1, 4, 119, 104, 101, 110, 5, 0, 8, 4, 0, 18, 115, 117, 98, 115, 99, 114, 105, 98, 101, 45, 100, 117, 114, 97, 116, 105, 111, 110, 1, 10, 3, 1, 33, 119, 97, 115, 105, 58, 99, 108, 111, 99, 107, 115, 47, 109, 111, 110, 111, 116, 111, 110, 105, 99, 45, 99, 108, 111, 99, 107, 64, 48, 46, 50, 46, 48, 5, 19, 1, 66, 5, 1, 114, 2, 7, 115, 101, 99, 111, 110, 100, 115, 119, 11, 110, 97, 110, 111, 115, 101, 99, 111, 110, 100, 115, 121, 4, 0, 8, 100, 97, 116, 101, 116, 105, 109, 101, 3, 0, 0, 1, 64, 0, 0, 1, 4, 0, 3, 110, 111, 119, 1, 2, 4, 0, 10, 114, 101, 115, 111, 108, 117, 116, 105, 111, 110, 1, 2, 3, 1, 28, 119, 97, 115, 105, 58, 99, 108, 111, 99, 107, 115, 47, 119, 97, 108, 108, 45, 99, 108, 111, 99, 107, 64, 48, 46, 50, 46, 48, 5, 20, 2, 3, 0, 4, 5, 101, 114, 114, 111, 114, 2, 3, 0, 14, 8, 100, 97, 116, 101, 116, 105, 109, 101, 1, 66, 114, 2, 3, 2, 1, 7, 4, 0, 12, 105, 110, 112, 117, 116, 45, 115, 116, 114, 101, 97, 109, 3, 0, 0, 2, 3, 2, 1, 9, 4, 0, 13, 111, 117, 116, 112, 117, 116, 45, 115, 116, 114, 101, 97, 109, 3, 0, 2, 2, 3, 2, 1, 21, 4, 0, 5, 101, 114, 114, 111, 114, 3, 0, 4, 2, 3, 2, 1, 22, 4, 0, 8, 100, 97, 116, 101, 116, 105, 109, 101, 3, 0, 6, 1, 119, 4, 0, 8, 102, 105, 108, 101, 115, 105, 122, 101, 3, 0, 8, 1, 109, 8, 7, 117, 110, 107, 110, 111, 119, 110, 12, 98, 108, 111, 99, 107, 45, 100, 101, 118, 105, 99, 101, 16, 99, 104, 97, 114, 97, 99, 116, 101, 114, 45, 100, 101, 118, 105, 99, 101, 9, 100, 105, 114, 101, 99, 116, 111, 114, 121, 4, 102, 105, 102, 111, 13, 115, 121, 109, 98, 111, 108, 105, 99, 45, 108, 105, 110, 107, 12, 114, 101, 103, 117, 108, 97, 114, 45, 102, 105, 108, 101, 6, 115, 111, 99, 107, 101, 116, 4, 0, 15, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 45, 116, 121, 112, 101, 3, 0, 10, 1, 110, 6, 4, 114, 101, 97, 100, 5, 119, 114, 105, 116, 101, 19, 102, 105, 108, 101, 45, 105, 110, 116, 101, 103, 114, 105, 116, 121, 45, 115, 121, 110, 99, 19, 100, 97, 116, 97, 45, 105, 110, 116, 101, 103, 114, 105, 116, 121, 45, 115, 121, 110, 99, 20, 114, 101, 113, 117, 101, 115, 116, 101, 100, 45, 119, 114, 105, 116, 101, 45, 115, 121, 110, 99, 16, 109, 117, 116, 97, 116, 101, 45, 100, 105, 114, 101, 99, 116, 111, 114, 121, 4, 0, 16, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 45, 102, 108, 97, 103, 115, 3, 0, 12, 1, 110, 1, 14, 115, 121, 109, 108, 105, 110, 107, 45, 102, 111, 108, 108, 111, 119, 4, 0, 10, 112, 97, 116, 104, 45, 102, 108, 97, 103, 115, 3, 0, 14, 1, 110, 4, 6, 99, 114, 101, 97, 116, 101, 9, 100, 105, 114, 101, 99, 116, 111, 114, 121, 9, 101, 120, 99, 108, 117, 115, 105, 118, 101, 8, 116, 114, 117, 110, 99, 97, 116, 101, 4, 0, 10, 111, 112, 101, 110, 45, 102, 108, 97, 103, 115, 3, 0, 16, 1, 119, 4, 0, 10, 108, 105, 110, 107, 45, 99, 111, 117, 110, 116, 3, 0, 18, 1, 107, 7, 1, 114, 6, 4, 116, 121, 112, 101, 11, 10, 108, 105, 110, 107, 45, 99, 111, 117, 110, 116, 19, 4, 115, 105, 122, 101, 9, 21, 100, 97, 116, 97, 45, 97, 99, 99, 101, 115, 115, 45, 116, 105, 109, 101, 115, 116, 97, 109, 112, 20, 27, 100, 97, 116, 97, 45, 109, 111, 100, 105, 102, 105, 99, 97, 116, 105, 111, 110, 45, 116, 105, 109, 101, 115, 116, 97, 109, 112, 20, 23, 115, 116, 97, 116, 117, 115, 45, 99, 104, 97, 110, 103, 101, 45, 116, 105, 109, 101, 115, 116, 97, 109, 112, 20, 4, 0, 15, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 45, 115, 116, 97, 116, 3, 0, 21, 1, 113, 3, 9, 110, 111, 45, 99, 104, 97, 110, 103, 101, 0, 0, 3, 110, 111, 119, 0, 0, 9, 116, 105, 109, 101, 115, 116, 97, 109, 112, 1, 7, 0, 4, 0, 13, 110, 101, 119, 45, 116, 105, 109, 101, 115, 116, 97, 109, 112, 3, 0, 23, 1, 114, 2, 4, 116, 121, 112, 101, 11, 4, 110, 97, 109, 101, 115, 4, 0, 15, 100, 105, 114, 101, 99, 116, 111, 114, 121, 45, 101, 110, 116, 114, 121, 3, 0, 25, 1, 109, 37, 6, 97, 99, 99, 101, 115, 115, 11, 119, 111, 117, 108, 100, 45, 98, 108, 111, 99, 107, 7, 97, 108, 114, 101, 97, 100, 121, 14, 98, 97, 100, 45, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 4, 98, 117, 115, 121, 8, 100, 101, 97, 100, 108, 111, 99, 107, 5, 113, 117, 111, 116, 97, 5, 101, 120, 105, 115, 116, 14, 102, 105, 108, 101, 45, 116, 111, 111, 45, 108, 97, 114, 103, 101, 21, 105, 108, 108, 101, 103, 97, 108, 45, 98, 121, 116, 101, 45, 115, 101, 113, 117, 101, 110, 99, 101, 11, 105, 110, 45, 112, 114, 111, 103, 114, 101, 115, 115, 11, 105, 110, 116, 101, 114, 114, 117, 112, 116, 101, 100, 7, 105, 110, 118, 97, 108, 105, 100, 2, 105, 111, 12, 105, 115, 45, 100, 105, 114, 101, 99, 116, 111, 114, 121, 4, 108, 111, 111, 112, 14, 116, 111, 111, 45, 109, 97, 110, 121, 45, 108, 105, 110, 107, 115, 12, 109, 101, 115, 115, 97, 103, 101, 45, 115, 105, 122, 101, 13, 110, 97, 109, 101, 45, 116, 111, 111, 45, 108, 111, 110, 103, 9, 110, 111, 45, 100, 101, 118, 105, 99, 101, 8, 110, 111, 45, 101, 110, 116, 114, 121, 7, 110, 111, 45, 108, 111, 99, 107, 19, 105, 110, 115, 117, 102, 102, 105, 99, 105, 101, 110, 116, 45, 109, 101, 109, 111, 114, 121, 18, 105, 110, 115, 117, 102, 102, 105, 99, 105, 101, 110, 116, 45, 115, 112, 97, 99, 101, 13, 110, 111, 116, 45, 100, 105, 114, 101, 99, 116, 111, 114, 121, 9, 110, 111, 116, 45, 101, 109, 112, 116, 121, 15, 110, 111, 116, 45, 114, 101, 99, 111, 118, 101, 114, 97, 98, 108, 101, 11, 117, 110, 115, 117, 112, 112, 111, 114, 116, 101, 100, 6, 110, 111, 45, 116, 116, 121, 14, 110, 111, 45, 115, 117, 99, 104, 45, 100, 101, 118, 105, 99, 101, 8, 111, 118, 101, 114, 102, 108, 111, 119, 13, 110, 111, 116, 45, 112, 101, 114, 109, 105, 116, 116, 101, 100, 4, 112, 105, 112, 101, 9, 114, 101, 97, 100, 45, 111, 110, 108, 121, 12, 105, 110, 118, 97, 108, 105, 100, 45, 115, 101, 101, 107, 14, 116, 101, 120, 116, 45, 102, 105, 108, 101, 45, 98, 117, 115, 121, 12, 99, 114, 111, 115, 115, 45, 100, 101, 118, 105, 99, 101, 4, 0, 10, 101, 114, 114, 111, 114, 45, 99, 111, 100, 101, 3, 0, 27, 1, 109, 6, 6, 110, 111, 114, 109, 97, 108, 10, 115, 101, 113, 117, 101, 110, 116, 105, 97, 108, 6, 114, 97, 110, 100, 111, 109, 9, 119, 105, 108, 108, 45, 110, 101, 101, 100, 9, 100, 111, 110, 116, 45, 110, 101, 101, 100, 8, 110, 111, 45, 114, 101, 117, 115, 101, 4, 0, 6, 97, 100, 118, 105, 99, 101, 3, 0, 29, 1, 114, 2, 5, 108, 111, 119, 101, 114, 119, 5, 117, 112, 112, 101, 114, 119, 4, 0, 19, 109, 101, 116, 97, 100, 97, 116, 97, 45, 104, 97, 115, 104, 45, 118, 97, 108, 117, 101, 3, 0, 31, 4, 0, 10, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 3, 1, 4, 0, 22, 100, 105, 114, 101, 99, 116, 111, 114, 121, 45, 101, 110, 116, 114, 121, 45, 115, 116, 114, 101, 97, 109, 3, 1, 1, 104, 33, 1, 105, 1, 1, 106, 1, 36, 1, 28, 1, 64, 2, 4, 115, 101, 108, 102, 35, 6, 111, 102, 102, 115, 101, 116, 9, 0, 37, 4, 0, 34, 91, 109, 101, 116, 104, 111, 100, 93, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 46, 114, 101, 97, 100, 45, 118, 105, 97, 45, 115, 116, 114, 101, 97, 109, 1, 38, 1, 105, 3, 1, 106, 1, 39, 1, 28, 1, 64, 2, 4, 115, 101, 108, 102, 35, 6, 111, 102, 102, 115, 101, 116, 9, 0, 40, 4, 0, 35, 91, 109, 101, 116, 104, 111, 100, 93, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 46, 119, 114, 105, 116, 101, 45, 118, 105, 97, 45, 115, 116, 114, 101, 97, 109, 1, 41, 1, 64, 1, 4, 115, 101, 108, 102, 35, 0, 40, 4, 0, 36, 91, 109, 101, 116, 104, 111, 100, 93, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 46, 97, 112, 112, 101, 110, 100, 45, 118, 105, 97, 45, 115, 116, 114, 101, 97, 109, 1, 42, 1, 106, 0, 1, 28, 1, 64, 4, 4, 115, 101, 108, 102, 35, 6, 111, 102, 102, 115, 101, 116, 9, 6, 108, 101, 110, 103, 116, 104, 9, 6, 97, 100, 118, 105, 99, 101, 30, 0, 43, 4, 0, 25, 91, 109, 101, 116, 104, 111, 100, 93, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 46, 97, 100, 118, 105, 115, 101, 1, 44, 1, 64, 1, 4, 115, 101, 108, 102, 35, 0, 43, 4, 0, 28, 91, 109, 101, 116, 104, 111, 100, 93, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 46, 115, 121, 110, 99, 45, 100, 97, 116, 97, 1, 45, 1, 106, 1, 13, 1, 28, 1, 64, 1, 4, 115, 101, 108, 102, 35, 0, 46, 4, 0, 28, 91, 109, 101, 116, 104, 111, 100, 93, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 46, 103, 101, 116, 45, 102, 108, 97, 103, 115, 1, 47, 1, 106, 1, 11, 1, 28, 1, 64, 1, 4, 115, 101, 108, 102, 35, 0, 48, 4, 0, 27, 91, 109, 101, 116, 104, 111, 100, 93, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 46, 103, 101, 116, 45, 116, 121, 112, 101, 1, 49, 1, 64, 2, 4, 115, 101, 108, 102, 35, 4, 115, 105, 122, 101, 9, 0, 43, 4, 0, 27, 91, 109, 101, 116, 104, 111, 100, 93, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 46, 115, 101, 116, 45, 115, 105, 122, 101, 1, 50, 1, 64, 3, 4, 115, 101, 108, 102, 35, 21, 100, 97, 116, 97, 45, 97, 99, 99, 101, 115, 115, 45, 116, 105, 109, 101, 115, 116, 97, 109, 112, 24, 27, 100, 97, 116, 97, 45, 109, 111, 100, 105, 102, 105, 99, 97, 116, 105, 111, 110, 45, 116, 105, 109, 101, 115, 116, 97, 109, 112, 24, 0, 43, 4, 0, 28, 91, 109, 101, 116, 104, 111, 100, 93, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 46, 115, 101, 116, 45, 116, 105, 109, 101, 115, 1, 51, 1, 112, 125, 1, 111, 2, 52, 127, 1, 106, 1, 53, 1, 28, 1, 64, 3, 4, 115, 101, 108, 102, 35, 6, 108, 101, 110, 103, 116, 104, 9, 6, 111, 102, 102, 115, 101, 116, 9, 0, 54, 4, 0, 23, 91, 109, 101, 116, 104, 111, 100, 93, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 46, 114, 101, 97, 100, 1, 55, 1, 106, 1, 9, 1, 28, 1, 64, 3, 4, 115, 101, 108, 102, 35, 6, 98, 117, 102, 102, 101, 114, 52, 6, 111, 102, 102, 115, 101, 116, 9, 0, 56, 4, 0, 24, 91, 109, 101, 116, 104, 111, 100, 93, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 46, 119, 114, 105, 116, 101, 1, 57, 1, 105, 34, 1, 106, 1, 58, 1, 28, 1, 64, 1, 4, 115, 101, 108, 102, 35, 0, 59, 4, 0, 33, 91, 109, 101, 116, 104, 111, 100, 93, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 46, 114, 101, 97, 100, 45, 100, 105, 114, 101, 99, 116, 111, 114, 121, 1, 60, 4, 0, 23, 91, 109, 101, 116, 104, 111, 100, 93, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 46, 115, 121, 110, 99, 1, 45, 1, 64, 2, 4, 115, 101, 108, 102, 35, 4, 112, 97, 116, 104, 115, 0, 43, 4, 0, 38, 91, 109, 101, 116, 104, 111, 100, 93, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 46, 99, 114, 101, 97, 116, 101, 45, 100, 105, 114, 101, 99, 116, 111, 114, 121, 45, 97, 116, 1, 61, 1, 106, 1, 22, 1, 28, 1, 64, 1, 4, 115, 101, 108, 102, 35, 0, 62, 4, 0, 23, 91, 109, 101, 116, 104, 111, 100, 93, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 46, 115, 116, 97, 116, 1, 63, 1, 64, 3, 4, 115, 101, 108, 102, 35, 10, 112, 97, 116, 104, 45, 102, 108, 97, 103, 115, 15, 4, 112, 97, 116, 104, 115, 0, 62, 4, 0, 26, 91, 109, 101, 116, 104, 111, 100, 93, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 46, 115, 116, 97, 116, 45, 97, 116, 1, 64, 1, 64, 5, 4, 115, 101, 108, 102, 35, 10, 112, 97, 116, 104, 45, 102, 108, 97, 103, 115, 15, 4, 112, 97, 116, 104, 115, 21, 100, 97, 116, 97, 45, 97, 99, 99, 101, 115, 115, 45, 116, 105, 109, 101, 115, 116, 97, 109, 112, 24, 27, 100, 97, 116, 97, 45, 109, 111, 100, 105, 102, 105, 99, 97, 116, 105, 111, 110, 45, 116, 105, 109, 101, 115, 116, 97, 109, 112, 24, 0, 43, 4, 0, 31, 91, 109, 101, 116, 104, 111, 100, 93, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 46, 115, 101, 116, 45, 116, 105, 109, 101, 115, 45, 97, 116, 1, 65, 1, 64, 5, 4, 115, 101, 108, 102, 35, 14, 111, 108, 100, 45, 112, 97, 116, 104, 45, 102, 108, 97, 103, 115, 15, 8, 111, 108, 100, 45, 112, 97, 116, 104, 115, 14, 110, 101, 119, 45, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 35, 8, 110, 101, 119, 45, 112, 97, 116, 104, 115, 0, 43, 4, 0, 26, 91, 109, 101, 116, 104, 111, 100, 93, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 46, 108, 105, 110, 107, 45, 97, 116, 1, 66, 1, 105, 33, 1, 106, 1, 195, 0, 1, 28, 1, 64, 5, 4, 115, 101, 108, 102, 35, 10, 112, 97, 116, 104, 45, 102, 108, 97, 103, 115, 15, 4, 112, 97, 116, 104, 115, 10, 111, 112, 101, 110, 45, 102, 108, 97, 103, 115, 17, 5, 102, 108, 97, 103, 115, 13, 0, 196, 0, 4, 0, 26, 91, 109, 101, 116, 104, 111, 100, 93, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 46, 111, 112, 101, 110, 45, 97, 116, 1, 69, 1, 106, 1, 115, 1, 28, 1, 64, 2, 4, 115, 101, 108, 102, 35, 4, 112, 97, 116, 104, 115, 0, 198, 0, 4, 0, 30, 91, 109, 101, 116, 104, 111, 100, 93, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 46, 114, 101, 97, 100, 108, 105, 110, 107, 45, 97, 116, 1, 71, 4, 0, 38, 91, 109, 101, 116, 104, 111, 100, 93, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 46, 114, 101, 109, 111, 118, 101, 45, 100, 105, 114, 101, 99, 116, 111, 114, 121, 45, 97, 116, 1, 61, 1, 64, 4, 4, 115, 101, 108, 102, 35, 8, 111, 108, 100, 45, 112, 97, 116, 104, 115, 14, 110, 101, 119, 45, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 35, 8, 110, 101, 119, 45, 112, 97, 116, 104, 115, 0, 43, 4, 0, 28, 91, 109, 101, 116, 104, 111, 100, 93, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 46, 114, 101, 110, 97, 109, 101, 45, 97, 116, 1, 72, 1, 64, 3, 4, 115, 101, 108, 102, 35, 8, 111, 108, 100, 45, 112, 97, 116, 104, 115, 8, 110, 101, 119, 45, 112, 97, 116, 104, 115, 0, 43, 4, 0, 29, 91, 109, 101, 116, 104, 111, 100, 93, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 46, 115, 121, 109, 108, 105, 110, 107, 45, 97, 116, 1, 73, 4, 0, 33, 91, 109, 101, 116, 104, 111, 100, 93, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 46, 117, 110, 108, 105, 110, 107, 45, 102, 105, 108, 101, 45, 97, 116, 1, 61, 1, 64, 2, 4, 115, 101, 108, 102, 35, 5, 111, 116, 104, 101, 114, 35, 0, 127, 4, 0, 33, 91, 109, 101, 116, 104, 111, 100, 93, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 46, 105, 115, 45, 115, 97, 109, 101, 45, 111, 98, 106, 101, 99, 116, 1, 74, 1, 106, 1, 32, 1, 28, 1, 64, 1, 4, 115, 101, 108, 102, 35, 0, 203, 0, 4, 0, 32, 91, 109, 101, 116, 104, 111, 100, 93, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 46, 109, 101, 116, 97, 100, 97, 116, 97, 45, 104, 97, 115, 104, 1, 76, 1, 64, 3, 4, 115, 101, 108, 102, 35, 10, 112, 97, 116, 104, 45, 102, 108, 97, 103, 115, 15, 4, 112, 97, 116, 104, 115, 0, 203, 0, 4, 0, 35, 91, 109, 101, 116, 104, 111, 100, 93, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 46, 109, 101, 116, 97, 100, 97, 116, 97, 45, 104, 97, 115, 104, 45, 97, 116, 1, 77, 1, 104, 34, 1, 107, 26, 1, 106, 1, 207, 0, 1, 28, 1, 64, 1, 4, 115, 101, 108, 102, 206, 0, 0, 208, 0, 4, 0, 51, 91, 109, 101, 116, 104, 111, 100, 93, 100, 105, 114, 101, 99, 116, 111, 114, 121, 45, 101, 110, 116, 114, 121, 45, 115, 116, 114, 101, 97, 109, 46, 114, 101, 97, 100, 45, 100, 105, 114, 101, 99, 116, 111, 114, 121, 45, 101, 110, 116, 114, 121, 1, 81, 1, 104, 5, 1, 107, 28, 1, 64, 1, 3, 101, 114, 114, 210, 0, 0, 211, 0, 4, 0, 21, 102, 105, 108, 101, 115, 121, 115, 116, 101, 109, 45, 101, 114, 114, 111, 114, 45, 99, 111, 100, 101, 1, 84, 3, 1, 27, 119, 97, 115, 105, 58, 102, 105, 108, 101, 115, 121, 115, 116, 101, 109, 47, 116, 121, 112, 101, 115, 64, 48, 46, 50, 46, 48, 5, 23, 2, 3, 0, 15, 10, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 1, 66, 7, 2, 3, 2, 1, 24, 4, 0, 10, 100, 101, 115, 99, 114, 105, 112, 116, 111, 114, 3, 0, 0, 1, 105, 1, 1, 111, 2, 2, 115, 1, 112, 3, 1, 64, 0, 0, 4, 4, 0, 15, 103, 101, 116, 45, 100, 105, 114, 101, 99, 116, 111, 114, 105, 101, 115, 1, 5, 3, 1, 30, 119, 97, 115, 105, 58, 102, 105, 108, 101, 115, 121, 115, 116, 101, 109, 47, 112, 114, 101, 111, 112, 101, 110, 115, 64, 48, 46, 50, 46, 48, 5, 25, 1, 66, 17, 4, 0, 7, 110, 101, 116, 119, 111, 114, 107, 3, 1, 1, 109, 21, 7, 117, 110, 107, 110, 111, 119, 110, 13, 97, 99, 99, 101, 115, 115, 45, 100, 101, 110, 105, 101, 100, 13, 110, 111, 116, 45, 115, 117, 112, 112, 111, 114, 116, 101, 100, 16, 105, 110, 118, 97, 108, 105, 100, 45, 97, 114, 103, 117, 109, 101, 110, 116, 13, 111, 117, 116, 45, 111, 102, 45, 109, 101, 109, 111, 114, 121, 7, 116, 105, 109, 101, 111, 117, 116, 20, 99, 111, 110, 99, 117, 114, 114, 101, 110, 99, 121, 45, 99, 111, 110, 102, 108, 105, 99, 116, 15, 110, 111, 116, 45, 105, 110, 45, 112, 114, 111, 103, 114, 101, 115, 115, 11, 119, 111, 117, 108, 100, 45, 98, 108, 111, 99, 107, 13, 105, 110, 118, 97, 108, 105, 100, 45, 115, 116, 97, 116, 101, 16, 110, 101, 119, 45, 115, 111, 99, 107, 101, 116, 45, 108, 105, 109, 105, 116, 20, 97, 100, 100, 114, 101, 115, 115, 45, 110, 111, 116, 45, 98, 105, 110, 100, 97, 98, 108, 101, 14, 97, 100, 100, 114, 101, 115, 115, 45, 105, 110, 45, 117, 115, 101, 18, 114, 101, 109, 111, 116, 101, 45, 117, 110, 114, 101, 97, 99, 104, 97, 98, 108, 101, 18, 99, 111, 110, 110, 101, 99, 116, 105, 111, 110, 45, 114, 101, 102, 117, 115, 101, 100, 16, 99, 111, 110, 110, 101, 99, 116, 105, 111, 110, 45, 114, 101, 115, 101, 116, 18, 99, 111, 110, 110, 101, 99, 116, 105, 111, 110, 45, 97, 98, 111, 114, 116, 101, 100, 18, 100, 97, 116, 97, 103, 114, 97, 109, 45, 116, 111, 111, 45, 108, 97, 114, 103, 101, 17, 110, 97, 109, 101, 45, 117, 110, 114, 101, 115, 111, 108, 118, 97, 98, 108, 101, 26, 116, 101, 109, 112, 111, 114, 97, 114, 121, 45, 114, 101, 115, 111, 108, 118, 101, 114, 45, 102, 97, 105, 108, 117, 114, 101, 26, 112, 101, 114, 109, 97, 110, 101, 110, 116, 45, 114, 101, 115, 111, 108, 118, 101, 114, 45, 102, 97, 105, 108, 117, 114, 101, 4, 0, 10, 101, 114, 114, 111, 114, 45, 99, 111, 100, 101, 3, 0, 1, 1, 109, 2, 4, 105, 112, 118, 52, 4, 105, 112, 118, 54, 4, 0, 17, 105, 112, 45, 97, 100, 100, 114, 101, 115, 115, 45, 102, 97, 109, 105, 108, 121, 3, 0, 3, 1, 111, 4, 125, 125, 125, 125, 4, 0, 12, 105, 112, 118, 52, 45, 97, 100, 100, 114, 101, 115, 115, 3, 0, 5, 1, 111, 8, 123, 123, 123, 123, 123, 123, 123, 123, 4, 0, 12, 105, 112, 118, 54, 45, 97, 100, 100, 114, 101, 115, 115, 3, 0, 7, 1, 113, 2, 4, 105, 112, 118, 52, 1, 6, 0, 4, 105, 112, 118, 54, 1, 8, 0, 4, 0, 10, 105, 112, 45, 97, 100, 100, 114, 101, 115, 115, 3, 0, 9, 1, 114, 2, 4, 112, 111, 114, 116, 123, 7, 97, 100, 100, 114, 101, 115, 115, 6, 4, 0, 19, 105, 112, 118, 52, 45, 115, 111, 99, 107, 101, 116, 45, 97, 100, 100, 114, 101, 115, 115, 3, 0, 11, 1, 114, 4, 4, 112, 111, 114, 116, 123, 9, 102, 108, 111, 119, 45, 105, 110, 102, 111, 121, 7, 97, 100, 100, 114, 101, 115, 115, 8, 8, 115, 99, 111, 112, 101, 45, 105, 100, 121, 4, 0, 19, 105, 112, 118, 54, 45, 115, 111, 99, 107, 101, 116, 45, 97, 100, 100, 114, 101, 115, 115, 3, 0, 13, 1, 113, 2, 4, 105, 112, 118, 52, 1, 12, 0, 4, 105, 112, 118, 54, 1, 14, 0, 4, 0, 17, 105, 112, 45, 115, 111, 99, 107, 101, 116, 45, 97, 100, 100, 114, 101, 115, 115, 3, 0, 15, 3, 1, 26, 119, 97, 115, 105, 58, 115, 111, 99, 107, 101, 116, 115, 47, 110, 101, 116, 119, 111, 114, 107, 64, 48, 46, 50, 46, 48, 5, 26, 2, 3, 0, 17, 7, 110, 101, 116, 119, 111, 114, 107, 1, 66, 5, 2, 3, 2, 1, 27, 4, 0, 7, 110, 101, 116, 119, 111, 114, 107, 3, 0, 0, 1, 105, 1, 1, 64, 0, 0, 2, 4, 0, 16, 105, 110, 115, 116, 97, 110, 99, 101, 45, 110, 101, 116, 119, 111, 114, 107, 1, 3, 3, 1, 35, 119, 97, 115, 105, 58, 115, 111, 99, 107, 101, 116, 115, 47, 105, 110, 115, 116, 97, 110, 99, 101, 45, 110, 101, 116, 119, 111, 114, 107, 64, 48, 46, 50, 46, 48, 5, 28, 2, 3, 0, 17, 10, 101, 114, 114, 111, 114, 45, 99, 111, 100, 101, 2, 3, 0, 17, 17, 105, 112, 45, 115, 111, 99, 107, 101, 116, 45, 97, 100, 100, 114, 101, 115, 115, 2, 3, 0, 17, 17, 105, 112, 45, 97, 100, 100, 114, 101, 115, 115, 45, 102, 97, 109, 105, 108, 121, 1, 66, 68, 2, 3, 2, 1, 5, 4, 0, 8, 112, 111, 108, 108, 97, 98, 108, 101, 3, 0, 0, 2, 3, 2, 1, 27, 4, 0, 7, 110, 101, 116, 119, 111, 114, 107, 3, 0, 2, 2, 3, 2, 1, 29, 4, 0, 10, 101, 114, 114, 111, 114, 45, 99, 111, 100, 101, 3, 0, 4, 2, 3, 2, 1, 30, 4, 0, 17, 105, 112, 45, 115, 111, 99, 107, 101, 116, 45, 97, 100, 100, 114, 101, 115, 115, 3, 0, 6, 2, 3, 2, 1, 31, 4, 0, 17, 105, 112, 45, 97, 100, 100, 114, 101, 115, 115, 45, 102, 97, 109, 105, 108, 121, 3, 0, 8, 1, 112, 125, 1, 114, 2, 4, 100, 97, 116, 97, 10, 14, 114, 101, 109, 111, 116, 101, 45, 97, 100, 100, 114, 101, 115, 115, 7, 4, 0, 17, 105, 110, 99, 111, 109, 105, 110, 103, 45, 100, 97, 116, 97, 103, 114, 97, 109, 3, 0, 11, 1, 107, 7, 1, 114, 2, 4, 100, 97, 116, 97, 10, 14, 114, 101, 109, 111, 116, 101, 45, 97, 100, 100, 114, 101, 115, 115, 13, 4, 0, 17, 111, 117, 116, 103, 111, 105, 110, 103, 45, 100, 97, 116, 97, 103, 114, 97, 109, 3, 0, 14, 4, 0, 10, 117, 100, 112, 45, 115, 111, 99, 107, 101, 116, 3, 1, 4, 0, 24, 105, 110, 99, 111, 109, 105, 110, 103, 45, 100, 97, 116, 97, 103, 114, 97, 109, 45, 115, 116, 114, 101, 97, 109, 3, 1, 4, 0, 24, 111, 117, 116, 103, 111, 105, 110, 103, 45, 100, 97, 116, 97, 103, 114, 97, 109, 45, 115, 116, 114, 101, 97, 109, 3, 1, 1, 104, 16, 1, 104, 3, 1, 106, 0, 1, 5, 1, 64, 3, 4, 115, 101, 108, 102, 19, 7, 110, 101, 116, 119, 111, 114, 107, 20, 13, 108, 111, 99, 97, 108, 45, 97, 100, 100, 114, 101, 115, 115, 7, 0, 21, 4, 0, 29, 91, 109, 101, 116, 104, 111, 100, 93, 117, 100, 112, 45, 115, 111, 99, 107, 101, 116, 46, 115, 116, 97, 114, 116, 45, 98, 105, 110, 100, 1, 22, 1, 64, 1, 4, 115, 101, 108, 102, 19, 0, 21, 4, 0, 30, 91, 109, 101, 116, 104, 111, 100, 93, 117, 100, 112, 45, 115, 111, 99, 107, 101, 116, 46, 102, 105, 110, 105, 115, 104, 45, 98, 105, 110, 100, 1, 23, 1, 105, 17, 1, 105, 18, 1, 111, 2, 24, 25, 1, 106, 1, 26, 1, 5, 1, 64, 2, 4, 115, 101, 108, 102, 19, 14, 114, 101, 109, 111, 116, 101, 45, 97, 100, 100, 114, 101, 115, 115, 13, 0, 27, 4, 0, 25, 91, 109, 101, 116, 104, 111, 100, 93, 117, 100, 112, 45, 115, 111, 99, 107, 101, 116, 46, 115, 116, 114, 101, 97, 109, 1, 28, 1, 106, 1, 7, 1, 5, 1, 64, 1, 4, 115, 101, 108, 102, 19, 0, 29, 4, 0, 32, 91, 109, 101, 116, 104, 111, 100, 93, 117, 100, 112, 45, 115, 111, 99, 107, 101, 116, 46, 108, 111, 99, 97, 108, 45, 97, 100, 100, 114, 101, 115, 115, 1, 30, 4, 0, 33, 91, 109, 101, 116, 104, 111, 100, 93, 117, 100, 112, 45, 115, 111, 99, 107, 101, 116, 46, 114, 101, 109, 111, 116, 101, 45, 97, 100, 100, 114, 101, 115, 115, 1, 30, 1, 64, 1, 4, 115, 101, 108, 102, 19, 0, 9, 4, 0, 33, 91, 109, 101, 116, 104, 111, 100, 93, 117, 100, 112, 45, 115, 111, 99, 107, 101, 116, 46, 97, 100, 100, 114, 101, 115, 115, 45, 102, 97, 109, 105, 108, 121, 1, 31, 1, 106, 1, 125, 1, 5, 1, 64, 1, 4, 115, 101, 108, 102, 19, 0, 32, 4, 0, 36, 91, 109, 101, 116, 104, 111, 100, 93, 117, 100, 112, 45, 115, 111, 99, 107, 101, 116, 46, 117, 110, 105, 99, 97, 115, 116, 45, 104, 111, 112, 45, 108, 105, 109, 105, 116, 1, 33, 1, 64, 2, 4, 115, 101, 108, 102, 19, 5, 118, 97, 108, 117, 101, 125, 0, 21, 4, 0, 40, 91, 109, 101, 116, 104, 111, 100, 93, 117, 100, 112, 45, 115, 111, 99, 107, 101, 116, 46, 115, 101, 116, 45, 117, 110, 105, 99, 97, 115, 116, 45, 104, 111, 112, 45, 108, 105, 109, 105, 116, 1, 34, 1, 106, 1, 119, 1, 5, 1, 64, 1, 4, 115, 101, 108, 102, 19, 0, 35, 4, 0, 38, 91, 109, 101, 116, 104, 111, 100, 93, 117, 100, 112, 45, 115, 111, 99, 107, 101, 116, 46, 114, 101, 99, 101, 105, 118, 101, 45, 98, 117, 102, 102, 101, 114, 45, 115, 105, 122, 101, 1, 36, 1, 64, 2, 4, 115, 101, 108, 102, 19, 5, 118, 97, 108, 117, 101, 119, 0, 21, 4, 0, 42, 91, 109, 101, 116, 104, 111, 100, 93, 117, 100, 112, 45, 115, 111, 99, 107, 101, 116, 46, 115, 101, 116, 45, 114, 101, 99, 101, 105, 118, 101, 45, 98, 117, 102, 102, 101, 114, 45, 115, 105, 122, 101, 1, 37, 4, 0, 35, 91, 109, 101, 116, 104, 111, 100, 93, 117, 100, 112, 45, 115, 111, 99, 107, 101, 116, 46, 115, 101, 110, 100, 45, 98, 117, 102, 102, 101, 114, 45, 115, 105, 122, 101, 1, 36, 4, 0, 39, 91, 109, 101, 116, 104, 111, 100, 93, 117, 100, 112, 45, 115, 111, 99, 107, 101, 116, 46, 115, 101, 116, 45, 115, 101, 110, 100, 45, 98, 117, 102, 102, 101, 114, 45, 115, 105, 122, 101, 1, 37, 1, 105, 1, 1, 64, 1, 4, 115, 101, 108, 102, 19, 0, 38, 4, 0, 28, 91, 109, 101, 116, 104, 111, 100, 93, 117, 100, 112, 45, 115, 111, 99, 107, 101, 116, 46, 115, 117, 98, 115, 99, 114, 105, 98, 101, 1, 39, 1, 104, 17, 1, 112, 12, 1, 106, 1, 41, 1, 5, 1, 64, 2, 4, 115, 101, 108, 102, 40, 11, 109, 97, 120, 45, 114, 101, 115, 117, 108, 116, 115, 119, 0, 42, 4, 0, 40, 91, 109, 101, 116, 104, 111, 100, 93, 105, 110, 99, 111, 109, 105, 110, 103, 45, 100, 97, 116, 97, 103, 114, 97, 109, 45, 115, 116, 114, 101, 97, 109, 46, 114, 101, 99, 101, 105, 118, 101, 1, 43, 1, 64, 1, 4, 115, 101, 108, 102, 40, 0, 38, 4, 0, 42, 91, 109, 101, 116, 104, 111, 100, 93, 105, 110, 99, 111, 109, 105, 110, 103, 45, 100, 97, 116, 97, 103, 114, 97, 109, 45, 115, 116, 114, 101, 97, 109, 46, 115, 117, 98, 115, 99, 114, 105, 98, 101, 1, 44, 1, 104, 18, 1, 64, 1, 4, 115, 101, 108, 102, 45, 0, 35, 4, 0, 43, 91, 109, 101, 116, 104, 111, 100, 93, 111, 117, 116, 103, 111, 105, 110, 103, 45, 100, 97, 116, 97, 103, 114, 97, 109, 45, 115, 116, 114, 101, 97, 109, 46, 99, 104, 101, 99, 107, 45, 115, 101, 110, 100, 1, 46, 1, 112, 15, 1, 64, 2, 4, 115, 101, 108, 102, 45, 9, 100, 97, 116, 97, 103, 114, 97, 109, 115, 47, 0, 35, 4, 0, 37, 91, 109, 101, 116, 104, 111, 100, 93, 111, 117, 116, 103, 111, 105, 110, 103, 45, 100, 97, 116, 97, 103, 114, 97, 109, 45, 115, 116, 114, 101, 97, 109, 46, 115, 101, 110, 100, 1, 48, 1, 64, 1, 4, 115, 101, 108, 102, 45, 0, 38, 4, 0, 42, 91, 109, 101, 116, 104, 111, 100, 93, 111, 117, 116, 103, 111, 105, 110, 103, 45, 100, 97, 116, 97, 103, 114, 97, 109, 45, 115, 116, 114, 101, 97, 109, 46, 115, 117, 98, 115, 99, 114, 105, 98, 101, 1, 49, 3, 1, 22, 119, 97, 115, 105, 58, 115, 111, 99, 107, 101, 116, 115, 47, 117, 100, 112, 64, 48, 46, 50, 46, 48, 5, 32, 2, 3, 0, 19, 10, 117, 100, 112, 45, 115, 111, 99, 107, 101, 116, 1, 66, 12, 2, 3, 2, 1, 27, 4, 0, 7, 110, 101, 116, 119, 111, 114, 107, 3, 0, 0, 2, 3, 2, 1, 29, 4, 0, 10, 101, 114, 114, 111, 114, 45, 99, 111, 100, 101, 3, 0, 2, 2, 3, 2, 1, 31, 4, 0, 17, 105, 112, 45, 97, 100, 100, 114, 101, 115, 115, 45, 102, 97, 109, 105, 108, 121, 3, 0, 4, 2, 3, 2, 1, 33, 4, 0, 10, 117, 100, 112, 45, 115, 111, 99, 107, 101, 116, 3, 0, 6, 1, 105, 7, 1, 106, 1, 8, 1, 3, 1, 64, 1, 14, 97, 100, 100, 114, 101, 115, 115, 45, 102, 97, 109, 105, 108, 121, 5, 0, 9, 4, 0, 17, 99, 114, 101, 97, 116, 101, 45, 117, 100, 112, 45, 115, 111, 99, 107, 101, 116, 1, 10, 3, 1, 36, 119, 97, 115, 105, 58, 115, 111, 99, 107, 101, 116, 115, 47, 117, 100, 112, 45, 99, 114, 101, 97, 116, 101, 45, 115, 111, 99, 107, 101, 116, 64, 48, 46, 50, 46, 48, 5, 34, 2, 3, 0, 13, 8, 100, 117, 114, 97, 116, 105, 111, 110, 1, 66, 84, 2, 3, 2, 1, 7, 4, 0, 12, 105, 110, 112, 117, 116, 45, 115, 116, 114, 101, 97, 109, 3, 0, 0, 2, 3, 2, 1, 9, 4, 0, 13, 111, 117, 116, 112, 117, 116, 45, 115, 116, 114, 101, 97, 109, 3, 0, 2, 2, 3, 2, 1, 5, 4, 0, 8, 112, 111, 108, 108, 97, 98, 108, 101, 3, 0, 4, 2, 3, 2, 1, 35, 4, 0, 8, 100, 117, 114, 97, 116, 105, 111, 110, 3, 0, 6, 2, 3, 2, 1, 27, 4, 0, 7, 110, 101, 116, 119, 111, 114, 107, 3, 0, 8, 2, 3, 2, 1, 29, 4, 0, 10, 101, 114, 114, 111, 114, 45, 99, 111, 100, 101, 3, 0, 10, 2, 3, 2, 1, 30, 4, 0, 17, 105, 112, 45, 115, 111, 99, 107, 101, 116, 45, 97, 100, 100, 114, 101, 115, 115, 3, 0, 12, 2, 3, 2, 1, 31, 4, 0, 17, 105, 112, 45, 97, 100, 100, 114, 101, 115, 115, 45, 102, 97, 109, 105, 108, 121, 3, 0, 14, 1, 109, 3, 7, 114, 101, 99, 101, 105, 118, 101, 4, 115, 101, 110, 100, 4, 98, 111, 116, 104, 4, 0, 13, 115, 104, 117, 116, 100, 111, 119, 110, 45, 116, 121, 112, 101, 3, 0, 16, 4, 0, 10, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 3, 1, 1, 104, 18, 1, 104, 9, 1, 106, 0, 1, 11, 1, 64, 3, 4, 115, 101, 108, 102, 19, 7, 110, 101, 116, 119, 111, 114, 107, 20, 13, 108, 111, 99, 97, 108, 45, 97, 100, 100, 114, 101, 115, 115, 13, 0, 21, 4, 0, 29, 91, 109, 101, 116, 104, 111, 100, 93, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 46, 115, 116, 97, 114, 116, 45, 98, 105, 110, 100, 1, 22, 1, 64, 1, 4, 115, 101, 108, 102, 19, 0, 21, 4, 0, 30, 91, 109, 101, 116, 104, 111, 100, 93, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 46, 102, 105, 110, 105, 115, 104, 45, 98, 105, 110, 100, 1, 23, 1, 64, 3, 4, 115, 101, 108, 102, 19, 7, 110, 101, 116, 119, 111, 114, 107, 20, 14, 114, 101, 109, 111, 116, 101, 45, 97, 100, 100, 114, 101, 115, 115, 13, 0, 21, 4, 0, 32, 91, 109, 101, 116, 104, 111, 100, 93, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 46, 115, 116, 97, 114, 116, 45, 99, 111, 110, 110, 101, 99, 116, 1, 24, 1, 105, 1, 1, 105, 3, 1, 111, 2, 25, 26, 1, 106, 1, 27, 1, 11, 1, 64, 1, 4, 115, 101, 108, 102, 19, 0, 28, 4, 0, 33, 91, 109, 101, 116, 104, 111, 100, 93, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 46, 102, 105, 110, 105, 115, 104, 45, 99, 111, 110, 110, 101, 99, 116, 1, 29, 4, 0, 31, 91, 109, 101, 116, 104, 111, 100, 93, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 46, 115, 116, 97, 114, 116, 45, 108, 105, 115, 116, 101, 110, 1, 23, 4, 0, 32, 91, 109, 101, 116, 104, 111, 100, 93, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 46, 102, 105, 110, 105, 115, 104, 45, 108, 105, 115, 116, 101, 110, 1, 23, 1, 105, 18, 1, 111, 3, 30, 25, 26, 1, 106, 1, 31, 1, 11, 1, 64, 1, 4, 115, 101, 108, 102, 19, 0, 32, 4, 0, 25, 91, 109, 101, 116, 104, 111, 100, 93, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 46, 97, 99, 99, 101, 112, 116, 1, 33, 1, 106, 1, 13, 1, 11, 1, 64, 1, 4, 115, 101, 108, 102, 19, 0, 34, 4, 0, 32, 91, 109, 101, 116, 104, 111, 100, 93, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 46, 108, 111, 99, 97, 108, 45, 97, 100, 100, 114, 101, 115, 115, 1, 35, 4, 0, 33, 91, 109, 101, 116, 104, 111, 100, 93, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 46, 114, 101, 109, 111, 116, 101, 45, 97, 100, 100, 114, 101, 115, 115, 1, 35, 1, 64, 1, 4, 115, 101, 108, 102, 19, 0, 127, 4, 0, 31, 91, 109, 101, 116, 104, 111, 100, 93, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 46, 105, 115, 45, 108, 105, 115, 116, 101, 110, 105, 110, 103, 1, 36, 1, 64, 1, 4, 115, 101, 108, 102, 19, 0, 15, 4, 0, 33, 91, 109, 101, 116, 104, 111, 100, 93, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 46, 97, 100, 100, 114, 101, 115, 115, 45, 102, 97, 109, 105, 108, 121, 1, 37, 1, 64, 2, 4, 115, 101, 108, 102, 19, 5, 118, 97, 108, 117, 101, 119, 0, 21, 4, 0, 42, 91, 109, 101, 116, 104, 111, 100, 93, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 46, 115, 101, 116, 45, 108, 105, 115, 116, 101, 110, 45, 98, 97, 99, 107, 108, 111, 103, 45, 115, 105, 122, 101, 1, 38, 1, 106, 1, 127, 1, 11, 1, 64, 1, 4, 115, 101, 108, 102, 19, 0, 39, 4, 0, 37, 91, 109, 101, 116, 104, 111, 100, 93, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 46, 107, 101, 101, 112, 45, 97, 108, 105, 118, 101, 45, 101, 110, 97, 98, 108, 101, 100, 1, 40, 1, 64, 2, 4, 115, 101, 108, 102, 19, 5, 118, 97, 108, 117, 101, 127, 0, 21, 4, 0, 41, 91, 109, 101, 116, 104, 111, 100, 93, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 46, 115, 101, 116, 45, 107, 101, 101, 112, 45, 97, 108, 105, 118, 101, 45, 101, 110, 97, 98, 108, 101, 100, 1, 41, 1, 106, 1, 7, 1, 11, 1, 64, 1, 4, 115, 101, 108, 102, 19, 0, 42, 4, 0, 39, 91, 109, 101, 116, 104, 111, 100, 93, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 46, 107, 101, 101, 112, 45, 97, 108, 105, 118, 101, 45, 105, 100, 108, 101, 45, 116, 105, 109, 101, 1, 43, 1, 64, 2, 4, 115, 101, 108, 102, 19, 5, 118, 97, 108, 117, 101, 7, 0, 21, 4, 0, 43, 91, 109, 101, 116, 104, 111, 100, 93, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 46, 115, 101, 116, 45, 107, 101, 101, 112, 45, 97, 108, 105, 118, 101, 45, 105, 100, 108, 101, 45, 116, 105, 109, 101, 1, 44, 4, 0, 38, 91, 109, 101, 116, 104, 111, 100, 93, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 46, 107, 101, 101, 112, 45, 97, 108, 105, 118, 101, 45, 105, 110, 116, 101, 114, 118, 97, 108, 1, 43, 4, 0, 42, 91, 109, 101, 116, 104, 111, 100, 93, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 46, 115, 101, 116, 45, 107, 101, 101, 112, 45, 97, 108, 105, 118, 101, 45, 105, 110, 116, 101, 114, 118, 97, 108, 1, 44, 1, 106, 1, 121, 1, 11, 1, 64, 1, 4, 115, 101, 108, 102, 19, 0, 45, 4, 0, 35, 91, 109, 101, 116, 104, 111, 100, 93, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 46, 107, 101, 101, 112, 45, 97, 108, 105, 118, 101, 45, 99, 111, 117, 110, 116, 1, 46, 1, 64, 2, 4, 115, 101, 108, 102, 19, 5, 118, 97, 108, 117, 101, 121, 0, 21, 4, 0, 39, 91, 109, 101, 116, 104, 111, 100, 93, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 46, 115, 101, 116, 45, 107, 101, 101, 112, 45, 97, 108, 105, 118, 101, 45, 99, 111, 117, 110, 116, 1, 47, 1, 106, 1, 125, 1, 11, 1, 64, 1, 4, 115, 101, 108, 102, 19, 0, 48, 4, 0, 28, 91, 109, 101, 116, 104, 111, 100, 93, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 46, 104, 111, 112, 45, 108, 105, 109, 105, 116, 1, 49, 1, 64, 2, 4, 115, 101, 108, 102, 19, 5, 118, 97, 108, 117, 101, 125, 0, 21, 4, 0, 32, 91, 109, 101, 116, 104, 111, 100, 93, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 46, 115, 101, 116, 45, 104, 111, 112, 45, 108, 105, 109, 105, 116, 1, 50, 1, 106, 1, 119, 1, 11, 1, 64, 1, 4, 115, 101, 108, 102, 19, 0, 51, 4, 0, 38, 91, 109, 101, 116, 104, 111, 100, 93, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 46, 114, 101, 99, 101, 105, 118, 101, 45, 98, 117, 102, 102, 101, 114, 45, 115, 105, 122, 101, 1, 52, 4, 0, 42, 91, 109, 101, 116, 104, 111, 100, 93, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 46, 115, 101, 116, 45, 114, 101, 99, 101, 105, 118, 101, 45, 98, 117, 102, 102, 101, 114, 45, 115, 105, 122, 101, 1, 38, 4, 0, 35, 91, 109, 101, 116, 104, 111, 100, 93, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 46, 115, 101, 110, 100, 45, 98, 117, 102, 102, 101, 114, 45, 115, 105, 122, 101, 1, 52, 4, 0, 39, 91, 109, 101, 116, 104, 111, 100, 93, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 46, 115, 101, 116, 45, 115, 101, 110, 100, 45, 98, 117, 102, 102, 101, 114, 45, 115, 105, 122, 101, 1, 38, 1, 105, 5, 1, 64, 1, 4, 115, 101, 108, 102, 19, 0, 53, 4, 0, 28, 91, 109, 101, 116, 104, 111, 100, 93, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 46, 115, 117, 98, 115, 99, 114, 105, 98, 101, 1, 54, 1, 64, 2, 4, 115, 101, 108, 102, 19, 13, 115, 104, 117, 116, 100, 111, 119, 110, 45, 116, 121, 112, 101, 17, 0, 21, 4, 0, 27, 91, 109, 101, 116, 104, 111, 100, 93, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 46, 115, 104, 117, 116, 100, 111, 119, 110, 1, 55, 3, 1, 22, 119, 97, 115, 105, 58, 115, 111, 99, 107, 101, 116, 115, 47, 116, 99, 112, 64, 48, 46, 50, 46, 48, 5, 36, 2, 3, 0, 21, 10, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 1, 66, 12, 2, 3, 2, 1, 27, 4, 0, 7, 110, 101, 116, 119, 111, 114, 107, 3, 0, 0, 2, 3, 2, 1, 29, 4, 0, 10, 101, 114, 114, 111, 114, 45, 99, 111, 100, 101, 3, 0, 2, 2, 3, 2, 1, 31, 4, 0, 17, 105, 112, 45, 97, 100, 100, 114, 101, 115, 115, 45, 102, 97, 109, 105, 108, 121, 3, 0, 4, 2, 3, 2, 1, 37, 4, 0, 10, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 3, 0, 6, 1, 105, 7, 1, 106, 1, 8, 1, 3, 1, 64, 1, 14, 97, 100, 100, 114, 101, 115, 115, 45, 102, 97, 109, 105, 108, 121, 5, 0, 9, 4, 0, 17, 99, 114, 101, 97, 116, 101, 45, 116, 99, 112, 45, 115, 111, 99, 107, 101, 116, 1, 10, 3, 1, 36, 119, 97, 115, 105, 58, 115, 111, 99, 107, 101, 116, 115, 47, 116, 99, 112, 45, 99, 114, 101, 97, 116, 101, 45, 115, 111, 99, 107, 101, 116, 64, 48, 46, 50, 46, 48, 5, 38, 2, 3, 0, 17, 10, 105, 112, 45, 97, 100, 100, 114, 101, 115, 115, 1, 66, 22, 2, 3, 2, 1, 5, 4, 0, 8, 112, 111, 108, 108, 97, 98, 108, 101, 3, 0, 0, 2, 3, 2, 1, 27, 4, 0, 7, 110, 101, 116, 119, 111, 114, 107, 3, 0, 2, 2, 3, 2, 1, 29, 4, 0, 10, 101, 114, 114, 111, 114, 45, 99, 111, 100, 101, 3, 0, 4, 2, 3, 2, 1, 39, 4, 0, 10, 105, 112, 45, 97, 100, 100, 114, 101, 115, 115, 3, 0, 6, 4, 0, 22, 114, 101, 115, 111, 108, 118, 101, 45, 97, 100, 100, 114, 101, 115, 115, 45, 115, 116, 114, 101, 97, 109, 3, 1, 1, 104, 8, 1, 107, 7, 1, 106, 1, 10, 1, 5, 1, 64, 1, 4, 115, 101, 108, 102, 9, 0, 11, 4, 0, 51, 91, 109, 101, 116, 104, 111, 100, 93, 114, 101, 115, 111, 108, 118, 101, 45, 97, 100, 100, 114, 101, 115, 115, 45, 115, 116, 114, 101, 97, 109, 46, 114, 101, 115, 111, 108, 118, 101, 45, 110, 101, 120, 116, 45, 97, 100, 100, 114, 101, 115, 115, 1, 12, 1, 105, 1, 1, 64, 1, 4, 115, 101, 108, 102, 9, 0, 13, 4, 0, 40, 91, 109, 101, 116, 104, 111, 100, 93, 114, 101, 115, 111, 108, 118, 101, 45, 97, 100, 100, 114, 101, 115, 115, 45, 115, 116, 114, 101, 97, 109, 46, 115, 117, 98, 115, 99, 114, 105, 98, 101, 1, 14, 1, 104, 3, 1, 105, 8, 1, 106, 1, 16, 1, 5, 1, 64, 2, 7, 110, 101, 116, 119, 111, 114, 107, 15, 4, 110, 97, 109, 101, 115, 0, 17, 4, 0, 17, 114, 101, 115, 111, 108, 118, 101, 45, 97, 100, 100, 114, 101, 115, 115, 101, 115, 1, 18, 3, 1, 33, 119, 97, 115, 105, 58, 115, 111, 99, 107, 101, 116, 115, 47, 105, 112, 45, 110, 97, 109, 101, 45, 108, 111, 111, 107, 117, 112, 64, 48, 46, 50, 46, 48, 5, 40, 1, 66, 5, 1, 112, 125, 1, 64, 1, 3, 108, 101, 110, 119, 0, 0, 4, 0, 16, 103, 101, 116, 45, 114, 97, 110, 100, 111, 109, 45, 98, 121, 116, 101, 115, 1, 1, 1, 64, 0, 0, 119, 4, 0, 14, 103, 101, 116, 45, 114, 97, 110, 100, 111, 109, 45, 117, 54, 52, 1, 2, 3, 1, 24, 119, 97, 115, 105, 58, 114, 97, 110, 100, 111, 109, 47, 114, 97, 110, 100, 111, 109, 64, 48, 46, 50, 46, 48, 5, 41, 1, 66, 5, 1, 112, 125, 1, 64, 1, 3, 108, 101, 110, 119, 0, 0, 4, 0, 25, 103, 101, 116, 45, 105, 110, 115, 101, 99, 117, 114, 101, 45, 114, 97, 110, 100, 111, 109, 45, 98, 121, 116, 101, 115, 1, 1, 1, 64, 0, 0, 119, 4, 0, 23, 103, 101, 116, 45, 105, 110, 115, 101, 99, 117, 114, 101, 45, 114, 97, 110, 100, 111, 109, 45, 117, 54, 52, 1, 2, 3, 1, 26, 119, 97, 115, 105, 58, 114, 97, 110, 100, 111, 109, 47, 105, 110, 115, 101, 99, 117, 114, 101, 64, 48, 46, 50, 46, 48, 5, 42, 1, 66, 3, 1, 111, 2, 119, 119, 1, 64, 0, 0, 0, 4, 0, 13, 105, 110, 115, 101, 99, 117, 114, 101, 45, 115, 101, 101, 100, 1, 1, 3, 1, 31, 119, 97, 115, 105, 58, 114, 97, 110, 100, 111, 109, 47, 105, 110, 115, 101, 99, 117, 114, 101, 45, 115, 101, 101, 100, 64, 48, 46, 50, 46, 48, 5, 43, 1, 66, 8, 1, 112, 121, 4, 0, 17, 116, 101, 110, 115, 111, 114, 45, 100, 105, 109, 101, 110, 115, 105, 111, 110, 115, 3, 0, 0, 1, 109, 7, 4, 70, 80, 49, 54, 4, 70, 80, 51, 50, 4, 70, 80, 54, 52, 4, 66, 70, 49, 54, 2, 85, 56, 3, 73, 51, 50, 3, 73, 54, 52, 4, 0, 11, 116, 101, 110, 115, 111, 114, 45, 116, 121, 112, 101, 3, 0, 2, 1, 112, 125, 4, 0, 11, 116, 101, 110, 115, 111, 114, 45, 100, 97, 116, 97, 3, 0, 4, 1, 114, 3, 10, 100, 105, 109, 101, 110, 115, 105, 111, 110, 115, 1, 11, 116, 101, 110, 115, 111, 114, 45, 116, 121, 112, 101, 3, 4, 100, 97, 116, 97, 5, 4, 0, 6, 116, 101, 110, 115, 111, 114, 3, 0, 6, 3, 1, 14, 119, 97, 115, 105, 58, 110, 110, 47, 116, 101, 110, 115, 111, 114, 5, 44, 1, 66, 2, 1, 109, 7, 16, 105, 110, 118, 97, 108, 105, 100, 45, 97, 114, 103, 117, 109, 101, 110, 116, 16, 105, 110, 118, 97, 108, 105, 100, 45, 101, 110, 99, 111, 100, 105, 110, 103, 4, 98, 117, 115, 121, 13, 114, 117, 110, 116, 105, 109, 101, 45, 101, 114, 114, 111, 114, 21, 117, 110, 115, 117, 112, 112, 111, 114, 116, 101, 100, 45, 111, 112, 101, 114, 97, 116, 105, 111, 110, 9, 116, 111, 111, 45, 108, 97, 114, 103, 101, 9, 110, 111, 116, 45, 102, 111, 117, 110, 100, 4, 0, 5, 101, 114, 114, 111, 114, 3, 0, 0, 3, 1, 14, 119, 97, 115, 105, 58, 110, 110, 47, 101, 114, 114, 111, 114, 115, 5, 45, 2, 3, 0, 28, 5, 101, 114, 114, 111, 114, 2, 3, 0, 27, 6, 116, 101, 110, 115, 111, 114, 1, 66, 18, 2, 3, 2, 1, 46, 4, 0, 5, 101, 114, 114, 111, 114, 3, 0, 0, 2, 3, 2, 1, 47, 4, 0, 6, 116, 101, 110, 115, 111, 114, 3, 0, 2, 1, 121, 4, 0, 5, 103, 114, 97, 112, 104, 3, 0, 4, 1, 109, 6, 8, 111, 112, 101, 110, 118, 105, 110, 111, 4, 111, 110, 110, 120, 10, 116, 101, 110, 115, 111, 114, 102, 108, 111, 119, 7, 112, 121, 116, 111, 114, 99, 104, 14, 116, 101, 110, 115, 111, 114, 102, 108, 111, 119, 108, 105, 116, 101, 10, 97, 117, 116, 111, 100, 101, 116, 101, 99, 116, 4, 0, 14, 103, 114, 97, 112, 104, 45, 101, 110, 99, 111, 100, 105, 110, 103, 3, 0, 6, 1, 109, 3, 3, 99, 112, 117, 3, 103, 112, 117, 3, 116, 112, 117, 4, 0, 16, 101, 120, 101, 99, 117, 116, 105, 111, 110, 45, 116, 97, 114, 103, 101, 116, 3, 0, 8, 1, 112, 125, 4, 0, 13, 103, 114, 97, 112, 104, 45, 98, 117, 105, 108, 100, 101, 114, 3, 0, 10, 1, 112, 11, 1, 106, 1, 5, 1, 1, 1, 64, 3, 7, 98, 117, 105, 108, 100, 101, 114, 12, 8, 101, 110, 99, 111, 100, 105, 110, 103, 7, 6, 116, 97, 114, 103, 101, 116, 9, 0, 13, 4, 0, 4, 108, 111, 97, 100, 1, 14, 1, 64, 1, 4, 110, 97, 109, 101, 115, 0, 13, 4, 0, 12, 108, 111, 97, 100, 45, 98, 121, 45, 110, 97, 109, 101, 1, 15, 3, 1, 13, 119, 97, 115, 105, 58, 110, 110, 47, 103, 114, 97, 112, 104, 5, 48, 2, 3, 0, 27, 11, 116, 101, 110, 115, 111, 114, 45, 100, 97, 116, 97, 2, 3, 0, 29, 5, 103, 114, 97, 112, 104, 1, 66, 21, 2, 3, 2, 1, 46, 4, 0, 5, 101, 114, 114, 111, 114, 3, 0, 0, 2, 3, 2, 1, 47, 4, 0, 6, 116, 101, 110, 115, 111, 114, 3, 0, 2, 2, 3, 2, 1, 49, 4, 0, 11, 116, 101, 110, 115, 111, 114, 45, 100, 97, 116, 97, 3, 0, 4, 2, 3, 2, 1, 50, 4, 0, 5, 103, 114, 97, 112, 104, 3, 0, 6, 1, 121, 4, 0, 23, 103, 114, 97, 112, 104, 45, 101, 120, 101, 99, 117, 116, 105, 111, 110, 45, 99, 111, 110, 116, 101, 120, 116, 3, 0, 8, 1, 106, 1, 9, 1, 1, 1, 64, 1, 5, 103, 114, 97, 112, 104, 7, 0, 10, 4, 0, 22, 105, 110, 105, 116, 45, 101, 120, 101, 99, 117, 116, 105, 111, 110, 45, 99, 111, 110, 116, 101, 120, 116, 1, 11, 1, 106, 0, 1, 1, 1, 64, 3, 3, 99, 116, 120, 9, 5, 105, 110, 100, 101, 120, 121, 6, 116, 101, 110, 115, 111, 114, 3, 0, 12, 4, 0, 9, 115, 101, 116, 45, 105, 110, 112, 117, 116, 1, 13, 1, 64, 1, 3, 99, 116, 120, 9, 0, 12, 4, 0, 7, 99, 111, 109, 112, 117, 116, 101, 1, 14, 1, 106, 1, 5, 1, 1, 1, 64, 2, 3, 99, 116, 120, 9, 5, 105, 110, 100, 101, 120, 121, 0, 15, 4, 0, 10, 103, 101, 116, 45, 111, 117, 116, 112, 117, 116, 1, 16, 3, 1, 17, 119, 97, 115, 105, 58, 110, 110, 47, 105, 110, 102, 101, 114, 101, 110, 99, 101, 5, 51, 1, 66, 3, 1, 106, 0, 0, 1, 64, 0, 0, 0, 4, 0, 3, 114, 117, 110, 1, 1, 4, 1, 18, 119, 97, 115, 105, 58, 99, 108, 105, 47, 114, 117, 110, 64, 48, 46, 50, 46, 48, 5, 52, 4, 1, 32, 101, 120, 97, 109, 112, 108, 101, 58, 111, 110, 110, 120, 45, 99, 108, 97, 115, 115, 105, 102, 105, 101, 114, 47, 99, 108, 97, 115, 115, 105, 102, 121, 4, 0, 11, 14, 1, 0, 8, 99, 108, 97, 115, 115, 105, 102, 121, 3, 0, 0, 0, 16, 12, 112, 97, 99, 107, 97, 103, 101, 45, 100, 111, 99, 115, 0, 123, 125, 0, 70, 9, 112, 114, 111, 100, 117, 99, 101, 114, 115, 1, 12, 112, 114, 111, 99, 101, 115, 115, 101, 100, 45, 98, 121, 2, 13, 119, 105, 116, 45, 99, 111, 109, 112, 111, 110, 101, 110, 116, 6, 48, 46, 49, 56, 46, 50, 16, 119, 105, 116, 45, 98, 105, 110, 100, 103, 101, 110, 45, 114, 117, 115, 116, 6, 48, 46, 49, 54, 46, 48];
+          
+          #[inline(never)]
+          #[doc(hidden)]
+          #[cfg(target_arch = "wasm32")]
+          pub fn __link_section() {}
+          
diff --git a/crates/wasi-nn/examples/classification-component-onnx/src/lib.rs b/crates/wasi-nn/examples/classification-component-onnx/src/lib.rs
new file mode 100644
index 000000000000..5e75deeb2bcb
--- /dev/null
+++ b/crates/wasi-nn/examples/classification-component-onnx/src/lib.rs
@@ -0,0 +1,134 @@
+#[allow(dead_code)]
+mod bindings;
+
+use image::io::Reader;
+use image::{DynamicImage, RgbImage};
+use ndarray::{Array, Dim};
+use std::fs;
+use std::io::BufRead;
+
+const IMG_PATH: &str = "fixture/images/dog.jpg";
+
+use bindings::{
+    exports::wasi::cli::run::Guest,
+    wasi::nn::{
+        graph::{load, ExecutionTarget, GraphBuilder, GraphEncoding},
+        inference::{compute, get_output, init_execution_context, set_input},
+        tensor::{Tensor, TensorData, TensorDimensions, TensorType},
+    },
+};
+
+struct Component;
+
+impl Guest for Component {
+    fn run() -> Result<(), ()> {
+        // Load the ONNX model - SqueezeNet 1.1-7
+        // Full details: https://github.com/onnx/models/tree/main/vision/classification/squeezenet
+        let model: GraphBuilder = fs::read("fixture/models/squeezenet1.1-7.onnx").unwrap();
+        println!("Read ONNX model, size in bytes: {}", model.len());
+
+        let graph = load(&[model], GraphEncoding::Onnx, ExecutionTarget::Cpu).unwrap();
+        println!("Loaded graph into wasi-nn");
+
+        let exec_context = init_execution_context(graph).unwrap();
+        println!("Created wasi-nn execution context.");
+
+        // Load SquezeNet 1000 labels used for classification
+        let labels = fs::read("fixture/labels/squeezenet1.1-7.txt").unwrap();
+        let class_labels: Vec<String> = labels.lines().map(|line| line.unwrap()).collect();
+        println!("Read ONNX Labels, # of labels: {}", class_labels.len());
+
+        // Prepare WASI-NN tensor - Tensor data is always a bytes vector
+        let dimensions: TensorDimensions = vec![1, 3, 224, 224];
+        let data: TensorData = image_to_tensor(IMG_PATH.to_string(), 224, 224);
+        let tensor = Tensor {
+            dimensions,
+            tensor_type: TensorType::Fp32,
+            data,
+        };
+        set_input(exec_context, 0, &tensor).unwrap();
+        println!("Set input tensor");
+
+        // Execute the inferencing
+        compute(exec_context).unwrap();
+        println!("Executed graph inference");
+
+        // Get the inferencing result (bytes) and convert it to f32
+        println!("Getting inferencing output");
+        let output_data = get_output(exec_context, 0).unwrap();
+
+        println!("Retrieved output data with length: {}", output_data.len());
+        let output_f32 = bytes_to_f32_vec(output_data);
+
+        let output_shape = [1, 1000, 1, 1];
+        let output_tensor = Array::from_shape_vec(output_shape, output_f32).unwrap();
+
+        // Post-Processing requirement: compute softmax to inferencing output
+        let exp_output = output_tensor.mapv(|x| x.exp());
+        let sum_exp_output = exp_output.sum_axis(ndarray::Axis(1));
+        let softmax_output = exp_output / &sum_exp_output;
+
+        let mut sorted = softmax_output
+            .axis_iter(ndarray::Axis(1))
+            .enumerate()
+            .into_iter()
+            .map(|(i, v)| (i, v[Dim([0, 0, 0])]))
+            .collect::<Vec<(_, _)>>();
+        sorted.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
+
+        for (index, probability) in sorted.iter().take(3) {
+            println!(
+                "Index: {} - Probability: {}",
+                class_labels[*index], probability
+            );
+        }
+
+        Ok(())
+    }
+}
+
+pub fn bytes_to_f32_vec(data: Vec<u8>) -> Vec<f32> {
+    let chunks: Vec<&[u8]> = data.chunks(4).collect();
+    let v: Vec<f32> = chunks
+        .into_iter()
+        .map(|c| f32::from_le_bytes(c.try_into().unwrap()))
+        .collect();
+
+    v.into_iter().collect()
+}
+
+// Take the image located at 'path', open it, resize it to height x width, and then converts
+// the pixel precision to FP32. The resulting BGR pixel vector is then returned.
+fn image_to_tensor(path: String, height: u32, width: u32) -> Vec<u8> {
+    let pixels = Reader::open(path).unwrap().decode().unwrap();
+    let dyn_img: DynamicImage = pixels.resize_exact(width, height, image::imageops::Triangle);
+    let bgr_img: RgbImage = dyn_img.to_rgb8();
+
+    // Get an array of the pixel values
+    let raw_u8_arr: &[u8] = &bgr_img.as_raw()[..];
+
+    // Create an array to hold the f32 value of those pixels
+    let bytes_required = raw_u8_arr.len() * 4;
+    let mut u8_f32_arr: Vec<u8> = vec![0; bytes_required];
+
+    // Normalizing values for the model
+    let mean = [0.485, 0.456, 0.406];
+    let std = [0.229, 0.224, 0.225];
+
+    // Read the number as a f32 and break it into u8 bytes
+    for i in 0..raw_u8_arr.len() {
+        let u8_f32: f32 = raw_u8_arr[i] as f32;
+        let rgb_iter = i % 3;
+
+        // Normalize the pixel
+        let norm_u8_f32: f32 = (u8_f32 / 255.0 - mean[rgb_iter]) / std[rgb_iter];
+
+        // Convert it to u8 bytes and write it with new shape
+        let u8_bytes = norm_u8_f32.to_ne_bytes();
+        for j in 0..4 {
+            u8_f32_arr[(raw_u8_arr.len() * 4 * rgb_iter / 3) + (i / 3) * 4 + j] = u8_bytes[j];
+        }
+    }
+
+    return u8_f32_arr;
+}
diff --git a/crates/wasi-nn/examples/classification-component-onnx/wit/world.wit b/crates/wasi-nn/examples/classification-component-onnx/wit/world.wit
new file mode 100644
index 000000000000..451bbcfd9657
--- /dev/null
+++ b/crates/wasi-nn/examples/classification-component-onnx/wit/world.wit
@@ -0,0 +1,6 @@
+package example:onnx-classifier;
+
+world classify {
+  include wasi:cli/command@0.2.0;
+  include wasi:nn/ml;
+}
\ No newline at end of file
diff --git a/crates/wasi-nn/examples/classification-example-named/Cargo.toml b/crates/wasi-nn/examples/classification-example-named/Cargo.toml
index b4653659bd3d..2aeb939712cb 100644
--- a/crates/wasi-nn/examples/classification-example-named/Cargo.toml
+++ b/crates/wasi-nn/examples/classification-example-named/Cargo.toml
@@ -9,7 +9,7 @@ publish = false
 [dependencies]
 wasi-nn = "0.5.0"
 
-# This crate is built with the wasm32-wasi target, so it's separate
+# This crate is built with the wasm32-wasip1 target, so it's separate
 # from the main Wasmtime build, so use this directive to exclude it
 # from the parent directory's workspace.
 [workspace]
diff --git a/crates/wasi-nn/examples/classification-example-named/README.md b/crates/wasi-nn/examples/classification-example-named/README.md
index aa56ad0cbaf7..f0b4e0fa4b9d 100644
--- a/crates/wasi-nn/examples/classification-example-named/README.md
+++ b/crates/wasi-nn/examples/classification-example-named/README.md
@@ -1,2 +1,2 @@
-This example project demonstrates using the `wasi-nn` API to perform ML inference. It consists of Rust code that is 
-built using the `wasm32-wasi` target. See `ci/run-wasi-nn-example.sh` for how this is used.
+This example project demonstrates using the `wasi-nn` API to perform ML inference. It consists of Rust code that is
+built using the `wasm32-wasip1` target. See `ci/run-wasi-nn-example.sh` for how this is used.
diff --git a/crates/wasi-nn/examples/classification-example-winml/Cargo.lock b/crates/wasi-nn/examples/classification-example-winml/Cargo.lock
new file mode 100644
index 000000000000..7384312efd33
--- /dev/null
+++ b/crates/wasi-nn/examples/classification-example-winml/Cargo.lock
@@ -0,0 +1,257 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "adler"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bytemuck"
+version = "1.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "374d28ec25809ee0e23827c2ab573d729e293f281dfe393500e7ad618baa61c6"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "color_quant"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d7b894f5411737b7867f4827955924d7c254fc9f4d91a6aad6b097804b1018b"
+
+[[package]]
+name = "crc32fast"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3855a8a784b474f333699ef2bbca9db2c4a1f6d9088a90a2d25b1eb53111eaa"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "fdeflate"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f9bfee30e4dedf0ab8b422f03af778d9612b63f502710fc500a334ebe2de645"
+dependencies = [
+ "simd-adler32",
+]
+
+[[package]]
+name = "flate2"
+version = "1.0.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46303f565772937ffe1d394a4fac6f411c6013172fadde9dcdb1e147a086940e"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "image"
+version = "0.24.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f3dfdbdd72063086ff443e297b61695500514b1e41095b6fb9a5ab48a70a711"
+dependencies = [
+ "bytemuck",
+ "byteorder",
+ "color_quant",
+ "num-rational",
+ "num-traits",
+ "png",
+]
+
+[[package]]
+name = "matrixmultiply"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7574c1cf36da4798ab73da5b215bbf444f50718207754cb522201d78d1cd0ff2"
+dependencies = [
+ "autocfg",
+ "rawpointer",
+]
+
+[[package]]
+name = "miniz_oxide"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d811f3e15f28568be3407c8e7fdb6514c1cda3cb30683f15b6a1a1dc4ea14a7"
+dependencies = [
+ "adler",
+ "simd-adler32",
+]
+
+[[package]]
+name = "ndarray"
+version = "0.15.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb12d4e967ec485a5f71c6311fe28158e9d6f4bc4a447b474184d0f91a8fa32"
+dependencies = [
+ "matrixmultiply",
+ "num-complex",
+ "num-integer",
+ "num-traits",
+ "rawpointer",
+]
+
+[[package]]
+name = "num-complex"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23c6602fda94a57c990fe0df199a035d83576b496aa29f4e634a8ac6004e68a6"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
+dependencies = [
+ "autocfg",
+ "num-traits",
+]
+
+[[package]]
+name = "num-rational"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0638a1c9d0a3c0914158145bc76cff373a75a627e6ecbfb71cbe6f453a5a19b0"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39e3200413f237f41ab11ad6d161bc7239c84dcb631773ccd7de3dfe4b5c267c"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "png"
+version = "0.17.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06e4b0d3d1312775e782c86c91a111aa1f910cbb65e1337f9975b5f9a554b5e1"
+dependencies = [
+ "bitflags",
+ "crc32fast",
+ "fdeflate",
+ "flate2",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "134c189feb4956b20f6f547d2cf727d4c0fe06722b20a0eec87ed445a97f92da"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rawpointer"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3"
+
+[[package]]
+name = "simd-adler32"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe"
+
+[[package]]
+name = "syn"
+version = "2.0.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e96b79aaa137db8f61e26363a0c9b47d8b4ec75da28b7d1d614c2303e232408b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.49"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1177e8c6d7ede7afde3585fd2513e611227efd6481bd78d2e82ba1ce16557ed4"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.49"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10712f02019e9288794769fba95cd6847df9874d49d871d062172f9dd41bc4cc"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+
+[[package]]
+name = "wasi-nn"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7031683cc05a71515d9200fb159b28d717ded3c40dbb979d1602cf46f3a68f40"
+dependencies = [
+ "thiserror",
+]
+
+[[package]]
+name = "wasi-nn-example-winml"
+version = "0.0.0"
+dependencies = [
+ "image",
+ "ndarray",
+ "wasi-nn",
+]
diff --git a/crates/wasi-nn/examples/classification-example-winml/Cargo.toml b/crates/wasi-nn/examples/classification-example-winml/Cargo.toml
new file mode 100644
index 000000000000..b0a5e8de2009
--- /dev/null
+++ b/crates/wasi-nn/examples/classification-example-winml/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "wasi-nn-example-winml"
+version = "0.0.0"
+authors = ["The Wasmtime Project Developers"]
+readme = "README.md"
+edition = "2021"
+publish = false
+
+[dependencies]
+wasi-nn = "0.6.0"
+image = { version = "0.24.6", default-features = false, features = ["png"] }
+ndarray = "0.15.3"
+
+# This crate is built with the wasm32-wasip1 target, so it's separate
+# from the main Wasmtime build, so use this directive to exclude it
+# from the parent directory's workspace.
+[workspace]
diff --git a/crates/wasi-nn/examples/classification-example-winml/README.md b/crates/wasi-nn/examples/classification-example-winml/README.md
new file mode 100644
index 000000000000..bacb178505d8
--- /dev/null
+++ b/crates/wasi-nn/examples/classification-example-winml/README.md
@@ -0,0 +1,41 @@
+This example project demonstrates using the `wasi-nn` API to perform WinML-based
+inference. We first build Wasmtime, a fast and secure runtime for WebAssembly,
+and then build a WebAssembly example, which:
+- reads an input image from [`fixture/kitten.png`],
+- converts it to the correct tensor format,
+- and then classifies the image using [`fixture/mobilenet.onnx`]
+
+[`fixture/kitten.png`]: fixture/kitten.png
+[`fixture/mobilenet.onnx`]: fixture/mobilenet.onnx
+[`src/main.rs`]: src/main.rs
+[build guide]: https://docs.wasmtime.dev/contributing-building.html
+
+To run this example, perform the following steps on Windows 10 v1803 and later:
+
+1. Build Wasmtime according to the [build guide], but enable the `winml`
+   feature:
+   ```shell
+   cargo build --release --features wasmtime-wasi-nn/winml
+   ```
+1. Navigate to this directory from Wasmtime's top-level directory (referred to
+   later as `%PROJECT_DIR%).
+    ```
+    set PROJECT_DIR=%CD%
+    cd crates\wasi-nn\examples\classification-example-winml
+    ```
+1. Install the `wasm32-wasip1` Rust target:
+    ```
+    rustup target add wasm32-wasip1
+    ```
+1. Compile this example; the `wasm32-wasip1` output is a WebAssembly file:
+    ```
+    cargo build --release --target=wasm32-wasip1
+    ```
+1. Run the sample; the fixture directory containing the model and image must be
+   mapped in to be accessible to WebAssembly.
+    ```
+    %PROJECT_DIR%\target\release\wasmtime.exe --dir fixture::fixture -S nn target\wasm32-wasip1\release\wasi-nn-example-winml.wasm
+    ```
+1. The example will print the top 5 classification results. To run with a
+   different image or ONNX model, modify the files in the `fixture` directory
+   along with any path changes this may cause [`src/main.rs`].
diff --git a/crates/wasi-nn/examples/classification-example-winml/fixture/README.md b/crates/wasi-nn/examples/classification-example-winml/fixture/README.md
new file mode 100644
index 000000000000..80f4e4c45d05
--- /dev/null
+++ b/crates/wasi-nn/examples/classification-example-winml/fixture/README.md
@@ -0,0 +1,5 @@
+This folder contains files for inference example.
+
+- mobilenet.onnx is downloaded from https://github.com/onnx/models/blob/main/validated/vision/classification/mobilenet/model/mobilenetv2-7.onnx, license: https://github.com/onnx/models/blob/main/LICENSE
+- synset.txt is downloaded from https://github.com/onnx/models/blob/main/validated/vision/classification/synset.txt, license: https://github.com/onnx/models/blob/main/LICENSE
+- kitten.png is downloaded from https://github.com/microsoft/onnxruntime/blob/main/winml/test/image/images/kitten_224.png, license: https://github.com/microsoft/onnxruntime/blob/main/LICENSE
\ No newline at end of file
diff --git a/crates/wasi-nn/examples/classification-example-winml/fixture/kitten.png b/crates/wasi-nn/examples/classification-example-winml/fixture/kitten.png
new file mode 100644
index 000000000000..e47ca9486375
Binary files /dev/null and b/crates/wasi-nn/examples/classification-example-winml/fixture/kitten.png differ
diff --git a/crates/wasi-nn/examples/classification-example-winml/fixture/mobilenet.onnx b/crates/wasi-nn/examples/classification-example-winml/fixture/mobilenet.onnx
new file mode 100644
index 000000000000..b9a4f96ba122
Binary files /dev/null and b/crates/wasi-nn/examples/classification-example-winml/fixture/mobilenet.onnx differ
diff --git a/crates/wasi-nn/examples/classification-example-winml/fixture/synset.txt b/crates/wasi-nn/examples/classification-example-winml/fixture/synset.txt
new file mode 100644
index 000000000000..a9e8c7f50d14
--- /dev/null
+++ b/crates/wasi-nn/examples/classification-example-winml/fixture/synset.txt
@@ -0,0 +1,1000 @@
+n01440764 tench, Tinca tinca
+n01443537 goldfish, Carassius auratus
+n01484850 great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias
+n01491361 tiger shark, Galeocerdo cuvieri
+n01494475 hammerhead, hammerhead shark
+n01496331 electric ray, crampfish, numbfish, torpedo
+n01498041 stingray
+n01514668 cock
+n01514859 hen
+n01518878 ostrich, Struthio camelus
+n01530575 brambling, Fringilla montifringilla
+n01531178 goldfinch, Carduelis carduelis
+n01532829 house finch, linnet, Carpodacus mexicanus
+n01534433 junco, snowbird
+n01537544 indigo bunting, indigo finch, indigo bird, Passerina cyanea
+n01558993 robin, American robin, Turdus migratorius
+n01560419 bulbul
+n01580077 jay
+n01582220 magpie
+n01592084 chickadee
+n01601694 water ouzel, dipper
+n01608432 kite
+n01614925 bald eagle, American eagle, Haliaeetus leucocephalus
+n01616318 vulture
+n01622779 great grey owl, great gray owl, Strix nebulosa
+n01629819 European fire salamander, Salamandra salamandra
+n01630670 common newt, Triturus vulgaris
+n01631663 eft
+n01632458 spotted salamander, Ambystoma maculatum
+n01632777 axolotl, mud puppy, Ambystoma mexicanum
+n01641577 bullfrog, Rana catesbeiana
+n01644373 tree frog, tree-frog
+n01644900 tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui
+n01664065 loggerhead, loggerhead turtle, Caretta caretta
+n01665541 leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea
+n01667114 mud turtle
+n01667778 terrapin
+n01669191 box turtle, box tortoise
+n01675722 banded gecko
+n01677366 common iguana, iguana, Iguana iguana
+n01682714 American chameleon, anole, Anolis carolinensis
+n01685808 whiptail, whiptail lizard
+n01687978 agama
+n01688243 frilled lizard, Chlamydosaurus kingi
+n01689811 alligator lizard
+n01692333 Gila monster, Heloderma suspectum
+n01693334 green lizard, Lacerta viridis
+n01694178 African chameleon, Chamaeleo chamaeleon
+n01695060 Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis
+n01697457 African crocodile, Nile crocodile, Crocodylus niloticus
+n01698640 American alligator, Alligator mississipiensis
+n01704323 triceratops
+n01728572 thunder snake, worm snake, Carphophis amoenus
+n01728920 ringneck snake, ring-necked snake, ring snake
+n01729322 hognose snake, puff adder, sand viper
+n01729977 green snake, grass snake
+n01734418 king snake, kingsnake
+n01735189 garter snake, grass snake
+n01737021 water snake
+n01739381 vine snake
+n01740131 night snake, Hypsiglena torquata
+n01742172 boa constrictor, Constrictor constrictor
+n01744401 rock python, rock snake, Python sebae
+n01748264 Indian cobra, Naja naja
+n01749939 green mamba
+n01751748 sea snake
+n01753488 horned viper, cerastes, sand viper, horned asp, Cerastes cornutus
+n01755581 diamondback, diamondback rattlesnake, Crotalus adamanteus
+n01756291 sidewinder, horned rattlesnake, Crotalus cerastes
+n01768244 trilobite
+n01770081 harvestman, daddy longlegs, Phalangium opilio
+n01770393 scorpion
+n01773157 black and gold garden spider, Argiope aurantia
+n01773549 barn spider, Araneus cavaticus
+n01773797 garden spider, Aranea diademata
+n01774384 black widow, Latrodectus mactans
+n01774750 tarantula
+n01775062 wolf spider, hunting spider
+n01776313 tick
+n01784675 centipede
+n01795545 black grouse
+n01796340 ptarmigan
+n01797886 ruffed grouse, partridge, Bonasa umbellus
+n01798484 prairie chicken, prairie grouse, prairie fowl
+n01806143 peacock
+n01806567 quail
+n01807496 partridge
+n01817953 African grey, African gray, Psittacus erithacus
+n01818515 macaw
+n01819313 sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita
+n01820546 lorikeet
+n01824575 coucal
+n01828970 bee eater
+n01829413 hornbill
+n01833805 hummingbird
+n01843065 jacamar
+n01843383 toucan
+n01847000 drake
+n01855032 red-breasted merganser, Mergus serrator
+n01855672 goose
+n01860187 black swan, Cygnus atratus
+n01871265 tusker
+n01872401 echidna, spiny anteater, anteater
+n01873310 platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus
+n01877812 wallaby, brush kangaroo
+n01882714 koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus
+n01883070 wombat
+n01910747 jellyfish
+n01914609 sea anemone, anemone
+n01917289 brain coral
+n01924916 flatworm, platyhelminth
+n01930112 nematode, nematode worm, roundworm
+n01943899 conch
+n01944390 snail
+n01945685 slug
+n01950731 sea slug, nudibranch
+n01955084 chiton, coat-of-mail shell, sea cradle, polyplacophore
+n01968897 chambered nautilus, pearly nautilus, nautilus
+n01978287 Dungeness crab, Cancer magister
+n01978455 rock crab, Cancer irroratus
+n01980166 fiddler crab
+n01981276 king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica
+n01983481 American lobster, Northern lobster, Maine lobster, Homarus americanus
+n01984695 spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish
+n01985128 crayfish, crawfish, crawdad, crawdaddy
+n01986214 hermit crab
+n01990800 isopod
+n02002556 white stork, Ciconia ciconia
+n02002724 black stork, Ciconia nigra
+n02006656 spoonbill
+n02007558 flamingo
+n02009229 little blue heron, Egretta caerulea
+n02009912 American egret, great white heron, Egretta albus
+n02011460 bittern
+n02012849 crane
+n02013706 limpkin, Aramus pictus
+n02017213 European gallinule, Porphyrio porphyrio
+n02018207 American coot, marsh hen, mud hen, water hen, Fulica americana
+n02018795 bustard
+n02025239 ruddy turnstone, Arenaria interpres
+n02027492 red-backed sandpiper, dunlin, Erolia alpina
+n02028035 redshank, Tringa totanus
+n02033041 dowitcher
+n02037110 oystercatcher, oyster catcher
+n02051845 pelican
+n02056570 king penguin, Aptenodytes patagonica
+n02058221 albatross, mollymawk
+n02066245 grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus
+n02071294 killer whale, killer, orca, grampus, sea wolf, Orcinus orca
+n02074367 dugong, Dugong dugon
+n02077923 sea lion
+n02085620 Chihuahua
+n02085782 Japanese spaniel
+n02085936 Maltese dog, Maltese terrier, Maltese
+n02086079 Pekinese, Pekingese, Peke
+n02086240 Shih-Tzu
+n02086646 Blenheim spaniel
+n02086910 papillon
+n02087046 toy terrier
+n02087394 Rhodesian ridgeback
+n02088094 Afghan hound, Afghan
+n02088238 basset, basset hound
+n02088364 beagle
+n02088466 bloodhound, sleuthhound
+n02088632 bluetick
+n02089078 black-and-tan coonhound
+n02089867 Walker hound, Walker foxhound
+n02089973 English foxhound
+n02090379 redbone
+n02090622 borzoi, Russian wolfhound
+n02090721 Irish wolfhound
+n02091032 Italian greyhound
+n02091134 whippet
+n02091244 Ibizan hound, Ibizan Podenco
+n02091467 Norwegian elkhound, elkhound
+n02091635 otterhound, otter hound
+n02091831 Saluki, gazelle hound
+n02092002 Scottish deerhound, deerhound
+n02092339 Weimaraner
+n02093256 Staffordshire bullterrier, Staffordshire bull terrier
+n02093428 American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier
+n02093647 Bedlington terrier
+n02093754 Border terrier
+n02093859 Kerry blue terrier
+n02093991 Irish terrier
+n02094114 Norfolk terrier
+n02094258 Norwich terrier
+n02094433 Yorkshire terrier
+n02095314 wire-haired fox terrier
+n02095570 Lakeland terrier
+n02095889 Sealyham terrier, Sealyham
+n02096051 Airedale, Airedale terrier
+n02096177 cairn, cairn terrier
+n02096294 Australian terrier
+n02096437 Dandie Dinmont, Dandie Dinmont terrier
+n02096585 Boston bull, Boston terrier
+n02097047 miniature schnauzer
+n02097130 giant schnauzer
+n02097209 standard schnauzer
+n02097298 Scotch terrier, Scottish terrier, Scottie
+n02097474 Tibetan terrier, chrysanthemum dog
+n02097658 silky terrier, Sydney silky
+n02098105 soft-coated wheaten terrier
+n02098286 West Highland white terrier
+n02098413 Lhasa, Lhasa apso
+n02099267 flat-coated retriever
+n02099429 curly-coated retriever
+n02099601 golden retriever
+n02099712 Labrador retriever
+n02099849 Chesapeake Bay retriever
+n02100236 German short-haired pointer
+n02100583 vizsla, Hungarian pointer
+n02100735 English setter
+n02100877 Irish setter, red setter
+n02101006 Gordon setter
+n02101388 Brittany spaniel
+n02101556 clumber, clumber spaniel
+n02102040 English springer, English springer spaniel
+n02102177 Welsh springer spaniel
+n02102318 cocker spaniel, English cocker spaniel, cocker
+n02102480 Sussex spaniel
+n02102973 Irish water spaniel
+n02104029 kuvasz
+n02104365 schipperke
+n02105056 groenendael
+n02105162 malinois
+n02105251 briard
+n02105412 kelpie
+n02105505 komondor
+n02105641 Old English sheepdog, bobtail
+n02105855 Shetland sheepdog, Shetland sheep dog, Shetland
+n02106030 collie
+n02106166 Border collie
+n02106382 Bouvier des Flandres, Bouviers des Flandres
+n02106550 Rottweiler
+n02106662 German shepherd, German shepherd dog, German police dog, alsatian
+n02107142 Doberman, Doberman pinscher
+n02107312 miniature pinscher
+n02107574 Greater Swiss Mountain dog
+n02107683 Bernese mountain dog
+n02107908 Appenzeller
+n02108000 EntleBucher
+n02108089 boxer
+n02108422 bull mastiff
+n02108551 Tibetan mastiff
+n02108915 French bulldog
+n02109047 Great Dane
+n02109525 Saint Bernard, St Bernard
+n02109961 Eskimo dog, husky
+n02110063 malamute, malemute, Alaskan malamute
+n02110185 Siberian husky
+n02110341 dalmatian, coach dog, carriage dog
+n02110627 affenpinscher, monkey pinscher, monkey dog
+n02110806 basenji
+n02110958 pug, pug-dog
+n02111129 Leonberg
+n02111277 Newfoundland, Newfoundland dog
+n02111500 Great Pyrenees
+n02111889 Samoyed, Samoyede
+n02112018 Pomeranian
+n02112137 chow, chow chow
+n02112350 keeshond
+n02112706 Brabancon griffon
+n02113023 Pembroke, Pembroke Welsh corgi
+n02113186 Cardigan, Cardigan Welsh corgi
+n02113624 toy poodle
+n02113712 miniature poodle
+n02113799 standard poodle
+n02113978 Mexican hairless
+n02114367 timber wolf, grey wolf, gray wolf, Canis lupus
+n02114548 white wolf, Arctic wolf, Canis lupus tundrarum
+n02114712 red wolf, maned wolf, Canis rufus, Canis niger
+n02114855 coyote, prairie wolf, brush wolf, Canis latrans
+n02115641 dingo, warrigal, warragal, Canis dingo
+n02115913 dhole, Cuon alpinus
+n02116738 African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus
+n02117135 hyena, hyaena
+n02119022 red fox, Vulpes vulpes
+n02119789 kit fox, Vulpes macrotis
+n02120079 Arctic fox, white fox, Alopex lagopus
+n02120505 grey fox, gray fox, Urocyon cinereoargenteus
+n02123045 tabby, tabby cat
+n02123159 tiger cat
+n02123394 Persian cat
+n02123597 Siamese cat, Siamese
+n02124075 Egyptian cat
+n02125311 cougar, puma, catamount, mountain lion, painter, panther, Felis concolor
+n02127052 lynx, catamount
+n02128385 leopard, Panthera pardus
+n02128757 snow leopard, ounce, Panthera uncia
+n02128925 jaguar, panther, Panthera onca, Felis onca
+n02129165 lion, king of beasts, Panthera leo
+n02129604 tiger, Panthera tigris
+n02130308 cheetah, chetah, Acinonyx jubatus
+n02132136 brown bear, bruin, Ursus arctos
+n02133161 American black bear, black bear, Ursus americanus, Euarctos americanus
+n02134084 ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus
+n02134418 sloth bear, Melursus ursinus, Ursus ursinus
+n02137549 mongoose
+n02138441 meerkat, mierkat
+n02165105 tiger beetle
+n02165456 ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle
+n02167151 ground beetle, carabid beetle
+n02168699 long-horned beetle, longicorn, longicorn beetle
+n02169497 leaf beetle, chrysomelid
+n02172182 dung beetle
+n02174001 rhinoceros beetle
+n02177972 weevil
+n02190166 fly
+n02206856 bee
+n02219486 ant, emmet, pismire
+n02226429 grasshopper, hopper
+n02229544 cricket
+n02231487 walking stick, walkingstick, stick insect
+n02233338 cockroach, roach
+n02236044 mantis, mantid
+n02256656 cicada, cicala
+n02259212 leafhopper
+n02264363 lacewing, lacewing fly
+n02268443 dragonfly, darning needle, devil's darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk
+n02268853 damselfly
+n02276258 admiral
+n02277742 ringlet, ringlet butterfly
+n02279972 monarch, monarch butterfly, milkweed butterfly, Danaus plexippus
+n02280649 cabbage butterfly
+n02281406 sulphur butterfly, sulfur butterfly
+n02281787 lycaenid, lycaenid butterfly
+n02317335 starfish, sea star
+n02319095 sea urchin
+n02321529 sea cucumber, holothurian
+n02325366 wood rabbit, cottontail, cottontail rabbit
+n02326432 hare
+n02328150 Angora, Angora rabbit
+n02342885 hamster
+n02346627 porcupine, hedgehog
+n02356798 fox squirrel, eastern fox squirrel, Sciurus niger
+n02361337 marmot
+n02363005 beaver
+n02364673 guinea pig, Cavia cobaya
+n02389026 sorrel
+n02391049 zebra
+n02395406 hog, pig, grunter, squealer, Sus scrofa
+n02396427 wild boar, boar, Sus scrofa
+n02397096 warthog
+n02398521 hippopotamus, hippo, river horse, Hippopotamus amphibius
+n02403003 ox
+n02408429 water buffalo, water ox, Asiatic buffalo, Bubalus bubalis
+n02410509 bison
+n02412080 ram, tup
+n02415577 bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis
+n02417914 ibex, Capra ibex
+n02422106 hartebeest
+n02422699 impala, Aepyceros melampus
+n02423022 gazelle
+n02437312 Arabian camel, dromedary, Camelus dromedarius
+n02437616 llama
+n02441942 weasel
+n02442845 mink
+n02443114 polecat, fitch, foulmart, foumart, Mustela putorius
+n02443484 black-footed ferret, ferret, Mustela nigripes
+n02444819 otter
+n02445715 skunk, polecat, wood pussy
+n02447366 badger
+n02454379 armadillo
+n02457408 three-toed sloth, ai, Bradypus tridactylus
+n02480495 orangutan, orang, orangutang, Pongo pygmaeus
+n02480855 gorilla, Gorilla gorilla
+n02481823 chimpanzee, chimp, Pan troglodytes
+n02483362 gibbon, Hylobates lar
+n02483708 siamang, Hylobates syndactylus, Symphalangus syndactylus
+n02484975 guenon, guenon monkey
+n02486261 patas, hussar monkey, Erythrocebus patas
+n02486410 baboon
+n02487347 macaque
+n02488291 langur
+n02488702 colobus, colobus monkey
+n02489166 proboscis monkey, Nasalis larvatus
+n02490219 marmoset
+n02492035 capuchin, ringtail, Cebus capucinus
+n02492660 howler monkey, howler
+n02493509 titi, titi monkey
+n02493793 spider monkey, Ateles geoffroyi
+n02494079 squirrel monkey, Saimiri sciureus
+n02497673 Madagascar cat, ring-tailed lemur, Lemur catta
+n02500267 indri, indris, Indri indri, Indri brevicaudatus
+n02504013 Indian elephant, Elephas maximus
+n02504458 African elephant, Loxodonta africana
+n02509815 lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens
+n02510455 giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca
+n02514041 barracouta, snoek
+n02526121 eel
+n02536864 coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch
+n02606052 rock beauty, Holocanthus tricolor
+n02607072 anemone fish
+n02640242 sturgeon
+n02641379 gar, garfish, garpike, billfish, Lepisosteus osseus
+n02643566 lionfish
+n02655020 puffer, pufferfish, blowfish, globefish
+n02666196 abacus
+n02667093 abaya
+n02669723 academic gown, academic robe, judge's robe
+n02672831 accordion, piano accordion, squeeze box
+n02676566 acoustic guitar
+n02687172 aircraft carrier, carrier, flattop, attack aircraft carrier
+n02690373 airliner
+n02692877 airship, dirigible
+n02699494 altar
+n02701002 ambulance
+n02704792 amphibian, amphibious vehicle
+n02708093 analog clock
+n02727426 apiary, bee house
+n02730930 apron
+n02747177 ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin
+n02749479 assault rifle, assault gun
+n02769748 backpack, back pack, knapsack, packsack, rucksack, haversack
+n02776631 bakery, bakeshop, bakehouse
+n02777292 balance beam, beam
+n02782093 balloon
+n02783161 ballpoint, ballpoint pen, ballpen, Biro
+n02786058 Band Aid
+n02787622 banjo
+n02788148 bannister, banister, balustrade, balusters, handrail
+n02790996 barbell
+n02791124 barber chair
+n02791270 barbershop
+n02793495 barn
+n02794156 barometer
+n02795169 barrel, cask
+n02797295 barrow, garden cart, lawn cart, wheelbarrow
+n02799071 baseball
+n02802426 basketball
+n02804414 bassinet
+n02804610 bassoon
+n02807133 bathing cap, swimming cap
+n02808304 bath towel
+n02808440 bathtub, bathing tub, bath, tub
+n02814533 beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon
+n02814860 beacon, lighthouse, beacon light, pharos
+n02815834 beaker
+n02817516 bearskin, busby, shako
+n02823428 beer bottle
+n02823750 beer glass
+n02825657 bell cote, bell cot
+n02834397 bib
+n02835271 bicycle-built-for-two, tandem bicycle, tandem
+n02837789 bikini, two-piece
+n02840245 binder, ring-binder
+n02841315 binoculars, field glasses, opera glasses
+n02843684 birdhouse
+n02859443 boathouse
+n02860847 bobsled, bobsleigh, bob
+n02865351 bolo tie, bolo, bola tie, bola
+n02869837 bonnet, poke bonnet
+n02870880 bookcase
+n02871525 bookshop, bookstore, bookstall
+n02877765 bottlecap
+n02879718 bow
+n02883205 bow tie, bow-tie, bowtie
+n02892201 brass, memorial tablet, plaque
+n02892767 brassiere, bra, bandeau
+n02894605 breakwater, groin, groyne, mole, bulwark, seawall, jetty
+n02895154 breastplate, aegis, egis
+n02906734 broom
+n02909870 bucket, pail
+n02910353 buckle
+n02916936 bulletproof vest
+n02917067 bullet train, bullet
+n02927161 butcher shop, meat market
+n02930766 cab, hack, taxi, taxicab
+n02939185 caldron, cauldron
+n02948072 candle, taper, wax light
+n02950826 cannon
+n02951358 canoe
+n02951585 can opener, tin opener
+n02963159 cardigan
+n02965783 car mirror
+n02966193 carousel, carrousel, merry-go-round, roundabout, whirligig
+n02966687 carpenter's kit, tool kit
+n02971356 carton
+n02974003 car wheel
+n02977058 cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM
+n02978881 cassette
+n02979186 cassette player
+n02980441 castle
+n02981792 catamaran
+n02988304 CD player
+n02992211 cello, violoncello
+n02992529 cellular telephone, cellular phone, cellphone, cell, mobile phone
+n02999410 chain
+n03000134 chainlink fence
+n03000247 chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour
+n03000684 chain saw, chainsaw
+n03014705 chest
+n03016953 chiffonier, commode
+n03017168 chime, bell, gong
+n03018349 china cabinet, china closet
+n03026506 Christmas stocking
+n03028079 church, church building
+n03032252 cinema, movie theater, movie theatre, movie house, picture palace
+n03041632 cleaver, meat cleaver, chopper
+n03042490 cliff dwelling
+n03045698 cloak
+n03047690 clog, geta, patten, sabot
+n03062245 cocktail shaker
+n03063599 coffee mug
+n03063689 coffeepot
+n03065424 coil, spiral, volute, whorl, helix
+n03075370 combination lock
+n03085013 computer keyboard, keypad
+n03089624 confectionery, confectionary, candy store
+n03095699 container ship, containership, container vessel
+n03100240 convertible
+n03109150 corkscrew, bottle screw
+n03110669 cornet, horn, trumpet, trump
+n03124043 cowboy boot
+n03124170 cowboy hat, ten-gallon hat
+n03125729 cradle
+n03126707 crane
+n03127747 crash helmet
+n03127925 crate
+n03131574 crib, cot
+n03133878 Crock Pot
+n03134739 croquet ball
+n03141823 crutch
+n03146219 cuirass
+n03160309 dam, dike, dyke
+n03179701 desk
+n03180011 desktop computer
+n03187595 dial telephone, dial phone
+n03188531 diaper, nappy, napkin
+n03196217 digital clock
+n03197337 digital watch
+n03201208 dining table, board
+n03207743 dishrag, dishcloth
+n03207941 dishwasher, dish washer, dishwashing machine
+n03208938 disk brake, disc brake
+n03216828 dock, dockage, docking facility
+n03218198 dogsled, dog sled, dog sleigh
+n03220513 dome
+n03223299 doormat, welcome mat
+n03240683 drilling platform, offshore rig
+n03249569 drum, membranophone, tympan
+n03250847 drumstick
+n03255030 dumbbell
+n03259280 Dutch oven
+n03271574 electric fan, blower
+n03272010 electric guitar
+n03272562 electric locomotive
+n03290653 entertainment center
+n03291819 envelope
+n03297495 espresso maker
+n03314780 face powder
+n03325584 feather boa, boa
+n03337140 file, file cabinet, filing cabinet
+n03344393 fireboat
+n03345487 fire engine, fire truck
+n03347037 fire screen, fireguard
+n03355925 flagpole, flagstaff
+n03372029 flute, transverse flute
+n03376595 folding chair
+n03379051 football helmet
+n03384352 forklift
+n03388043 fountain
+n03388183 fountain pen
+n03388549 four-poster
+n03393912 freight car
+n03394916 French horn, horn
+n03400231 frying pan, frypan, skillet
+n03404251 fur coat
+n03417042 garbage truck, dustcart
+n03424325 gasmask, respirator, gas helmet
+n03425413 gas pump, gasoline pump, petrol pump, island dispenser
+n03443371 goblet
+n03444034 go-kart
+n03445777 golf ball
+n03445924 golfcart, golf cart
+n03447447 gondola
+n03447721 gong, tam-tam
+n03450230 gown
+n03452741 grand piano, grand
+n03457902 greenhouse, nursery, glasshouse
+n03459775 grille, radiator grille
+n03461385 grocery store, grocery, food market, market
+n03467068 guillotine
+n03476684 hair slide
+n03476991 hair spray
+n03478589 half track
+n03481172 hammer
+n03482405 hamper
+n03483316 hand blower, blow dryer, blow drier, hair dryer, hair drier
+n03485407 hand-held computer, hand-held microcomputer
+n03485794 handkerchief, hankie, hanky, hankey
+n03492542 hard disc, hard disk, fixed disk
+n03494278 harmonica, mouth organ, harp, mouth harp
+n03495258 harp
+n03496892 harvester, reaper
+n03498962 hatchet
+n03527444 holster
+n03529860 home theater, home theatre
+n03530642 honeycomb
+n03532672 hook, claw
+n03534580 hoopskirt, crinoline
+n03535780 horizontal bar, high bar
+n03538406 horse cart, horse-cart
+n03544143 hourglass
+n03584254 iPod
+n03584829 iron, smoothing iron
+n03590841 jack-o'-lantern
+n03594734 jean, blue jean, denim
+n03594945 jeep, landrover
+n03595614 jersey, T-shirt, tee shirt
+n03598930 jigsaw puzzle
+n03599486 jinrikisha, ricksha, rickshaw
+n03602883 joystick
+n03617480 kimono
+n03623198 knee pad
+n03627232 knot
+n03630383 lab coat, laboratory coat
+n03633091 ladle
+n03637318 lampshade, lamp shade
+n03642806 laptop, laptop computer
+n03649909 lawn mower, mower
+n03657121 lens cap, lens cover
+n03658185 letter opener, paper knife, paperknife
+n03661043 library
+n03662601 lifeboat
+n03666591 lighter, light, igniter, ignitor
+n03670208 limousine, limo
+n03673027 liner, ocean liner
+n03676483 lipstick, lip rouge
+n03680355 Loafer
+n03690938 lotion
+n03691459 loudspeaker, speaker, speaker unit, loudspeaker system, speaker system
+n03692522 loupe, jeweler's loupe
+n03697007 lumbermill, sawmill
+n03706229 magnetic compass
+n03709823 mailbag, postbag
+n03710193 mailbox, letter box
+n03710637 maillot
+n03710721 maillot, tank suit
+n03717622 manhole cover
+n03720891 maraca
+n03721384 marimba, xylophone
+n03724870 mask
+n03729826 matchstick
+n03733131 maypole
+n03733281 maze, labyrinth
+n03733805 measuring cup
+n03742115 medicine chest, medicine cabinet
+n03743016 megalith, megalithic structure
+n03759954 microphone, mike
+n03761084 microwave, microwave oven
+n03763968 military uniform
+n03764736 milk can
+n03769881 minibus
+n03770439 miniskirt, mini
+n03770679 minivan
+n03773504 missile
+n03775071 mitten
+n03775546 mixing bowl
+n03776460 mobile home, manufactured home
+n03777568 Model T
+n03777754 modem
+n03781244 monastery
+n03782006 monitor
+n03785016 moped
+n03786901 mortar
+n03787032 mortarboard
+n03788195 mosque
+n03788365 mosquito net
+n03791053 motor scooter, scooter
+n03792782 mountain bike, all-terrain bike, off-roader
+n03792972 mountain tent
+n03793489 mouse, computer mouse
+n03794056 mousetrap
+n03796401 moving van
+n03803284 muzzle
+n03804744 nail
+n03814639 neck brace
+n03814906 necklace
+n03825788 nipple
+n03832673 notebook, notebook computer
+n03837869 obelisk
+n03838899 oboe, hautboy, hautbois
+n03840681 ocarina, sweet potato
+n03841143 odometer, hodometer, mileometer, milometer
+n03843555 oil filter
+n03854065 organ, pipe organ
+n03857828 oscilloscope, scope, cathode-ray oscilloscope, CRO
+n03866082 overskirt
+n03868242 oxcart
+n03868863 oxygen mask
+n03871628 packet
+n03873416 paddle, boat paddle
+n03874293 paddlewheel, paddle wheel
+n03874599 padlock
+n03876231 paintbrush
+n03877472 pajama, pyjama, pj's, jammies
+n03877845 palace
+n03884397 panpipe, pandean pipe, syrinx
+n03887697 paper towel
+n03888257 parachute, chute
+n03888605 parallel bars, bars
+n03891251 park bench
+n03891332 parking meter
+n03895866 passenger car, coach, carriage
+n03899768 patio, terrace
+n03902125 pay-phone, pay-station
+n03903868 pedestal, plinth, footstall
+n03908618 pencil box, pencil case
+n03908714 pencil sharpener
+n03916031 perfume, essence
+n03920288 Petri dish
+n03924679 photocopier
+n03929660 pick, plectrum, plectron
+n03929855 pickelhaube
+n03930313 picket fence, paling
+n03930630 pickup, pickup truck
+n03933933 pier
+n03935335 piggy bank, penny bank
+n03937543 pill bottle
+n03938244 pillow
+n03942813 ping-pong ball
+n03944341 pinwheel
+n03947888 pirate, pirate ship
+n03950228 pitcher, ewer
+n03954731 plane, carpenter's plane, woodworking plane
+n03956157 planetarium
+n03958227 plastic bag
+n03961711 plate rack
+n03967562 plow, plough
+n03970156 plunger, plumber's helper
+n03976467 Polaroid camera, Polaroid Land camera
+n03976657 pole
+n03977966 police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria
+n03980874 poncho
+n03982430 pool table, billiard table, snooker table
+n03983396 pop bottle, soda bottle
+n03991062 pot, flowerpot
+n03992509 potter's wheel
+n03995372 power drill
+n03998194 prayer rug, prayer mat
+n04004767 printer
+n04005630 prison, prison house
+n04008634 projectile, missile
+n04009552 projector
+n04019541 puck, hockey puck
+n04023962 punching bag, punch bag, punching ball, punchball
+n04026417 purse
+n04033901 quill, quill pen
+n04033995 quilt, comforter, comfort, puff
+n04037443 racer, race car, racing car
+n04039381 racket, racquet
+n04040759 radiator
+n04041544 radio, wireless
+n04044716 radio telescope, radio reflector
+n04049303 rain barrel
+n04065272 recreational vehicle, RV, R.V.
+n04067472 reel
+n04069434 reflex camera
+n04070727 refrigerator, icebox
+n04074963 remote control, remote
+n04081281 restaurant, eating house, eating place, eatery
+n04086273 revolver, six-gun, six-shooter
+n04090263 rifle
+n04099969 rocking chair, rocker
+n04111531 rotisserie
+n04116512 rubber eraser, rubber, pencil eraser
+n04118538 rugby ball
+n04118776 rule, ruler
+n04120489 running shoe
+n04125021 safe
+n04127249 safety pin
+n04131690 saltshaker, salt shaker
+n04133789 sandal
+n04136333 sarong
+n04141076 sax, saxophone
+n04141327 scabbard
+n04141975 scale, weighing machine
+n04146614 school bus
+n04147183 schooner
+n04149813 scoreboard
+n04152593 screen, CRT screen
+n04153751 screw
+n04154565 screwdriver
+n04162706 seat belt, seatbelt
+n04179913 sewing machine
+n04192698 shield, buckler
+n04200800 shoe shop, shoe-shop, shoe store
+n04201297 shoji
+n04204238 shopping basket
+n04204347 shopping cart
+n04208210 shovel
+n04209133 shower cap
+n04209239 shower curtain
+n04228054 ski
+n04229816 ski mask
+n04235860 sleeping bag
+n04238763 slide rule, slipstick
+n04239074 sliding door
+n04243546 slot, one-armed bandit
+n04251144 snorkel
+n04252077 snowmobile
+n04252225 snowplow, snowplough
+n04254120 soap dispenser
+n04254680 soccer ball
+n04254777 sock
+n04258138 solar dish, solar collector, solar furnace
+n04259630 sombrero
+n04263257 soup bowl
+n04264628 space bar
+n04265275 space heater
+n04266014 space shuttle
+n04270147 spatula
+n04273569 speedboat
+n04275548 spider web, spider's web
+n04277352 spindle
+n04285008 sports car, sport car
+n04286575 spotlight, spot
+n04296562 stage
+n04310018 steam locomotive
+n04311004 steel arch bridge
+n04311174 steel drum
+n04317175 stethoscope
+n04325704 stole
+n04326547 stone wall
+n04328186 stopwatch, stop watch
+n04330267 stove
+n04332243 strainer
+n04335435 streetcar, tram, tramcar, trolley, trolley car
+n04336792 stretcher
+n04344873 studio couch, day bed
+n04346328 stupa, tope
+n04347754 submarine, pigboat, sub, U-boat
+n04350905 suit, suit of clothes
+n04355338 sundial
+n04355933 sunglass
+n04356056 sunglasses, dark glasses, shades
+n04357314 sunscreen, sunblock, sun blocker
+n04366367 suspension bridge
+n04367480 swab, swob, mop
+n04370456 sweatshirt
+n04371430 swimming trunks, bathing trunks
+n04371774 swing
+n04372370 switch, electric switch, electrical switch
+n04376876 syringe
+n04380533 table lamp
+n04389033 tank, army tank, armored combat vehicle, armoured combat vehicle
+n04392985 tape player
+n04398044 teapot
+n04399382 teddy, teddy bear
+n04404412 television, television system
+n04409515 tennis ball
+n04417672 thatch, thatched roof
+n04418357 theater curtain, theatre curtain
+n04423845 thimble
+n04428191 thresher, thrasher, threshing machine
+n04429376 throne
+n04435653 tile roof
+n04442312 toaster
+n04443257 tobacco shop, tobacconist shop, tobacconist
+n04447861 toilet seat
+n04456115 torch
+n04458633 totem pole
+n04461696 tow truck, tow car, wrecker
+n04462240 toyshop
+n04465501 tractor
+n04467665 trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi
+n04476259 tray
+n04479046 trench coat
+n04482393 tricycle, trike, velocipede
+n04483307 trimaran
+n04485082 tripod
+n04486054 triumphal arch
+n04487081 trolleybus, trolley coach, trackless trolley
+n04487394 trombone
+n04493381 tub, vat
+n04501370 turnstile
+n04505470 typewriter keyboard
+n04507155 umbrella
+n04509417 unicycle, monocycle
+n04515003 upright, upright piano
+n04517823 vacuum, vacuum cleaner
+n04522168 vase
+n04523525 vault
+n04525038 velvet
+n04525305 vending machine
+n04532106 vestment
+n04532670 viaduct
+n04536866 violin, fiddle
+n04540053 volleyball
+n04542943 waffle iron
+n04548280 wall clock
+n04548362 wallet, billfold, notecase, pocketbook
+n04550184 wardrobe, closet, press
+n04552348 warplane, military plane
+n04553703 washbasin, handbasin, washbowl, lavabo, wash-hand basin
+n04554684 washer, automatic washer, washing machine
+n04557648 water bottle
+n04560804 water jug
+n04562935 water tower
+n04579145 whiskey jug
+n04579432 whistle
+n04584207 wig
+n04589890 window screen
+n04590129 window shade
+n04591157 Windsor tie
+n04591713 wine bottle
+n04592741 wing
+n04596742 wok
+n04597913 wooden spoon
+n04599235 wool, woolen, woollen
+n04604644 worm fence, snake fence, snake-rail fence, Virginia fence
+n04606251 wreck
+n04612504 yawl
+n04613696 yurt
+n06359193 web site, website, internet site, site
+n06596364 comic book
+n06785654 crossword puzzle, crossword
+n06794110 street sign
+n06874185 traffic light, traffic signal, stoplight
+n07248320 book jacket, dust cover, dust jacket, dust wrapper
+n07565083 menu
+n07579787 plate
+n07583066 guacamole
+n07584110 consomme
+n07590611 hot pot, hotpot
+n07613480 trifle
+n07614500 ice cream, icecream
+n07615774 ice lolly, lolly, lollipop, popsicle
+n07684084 French loaf
+n07693725 bagel, beigel
+n07695742 pretzel
+n07697313 cheeseburger
+n07697537 hotdog, hot dog, red hot
+n07711569 mashed potato
+n07714571 head cabbage
+n07714990 broccoli
+n07715103 cauliflower
+n07716358 zucchini, courgette
+n07716906 spaghetti squash
+n07717410 acorn squash
+n07717556 butternut squash
+n07718472 cucumber, cuke
+n07718747 artichoke, globe artichoke
+n07720875 bell pepper
+n07730033 cardoon
+n07734744 mushroom
+n07742313 Granny Smith
+n07745940 strawberry
+n07747607 orange
+n07749582 lemon
+n07753113 fig
+n07753275 pineapple, ananas
+n07753592 banana
+n07754684 jackfruit, jak, jack
+n07760859 custard apple
+n07768694 pomegranate
+n07802026 hay
+n07831146 carbonara
+n07836838 chocolate sauce, chocolate syrup
+n07860988 dough
+n07871810 meat loaf, meatloaf
+n07873807 pizza, pizza pie
+n07875152 potpie
+n07880968 burrito
+n07892512 red wine
+n07920052 espresso
+n07930864 cup
+n07932039 eggnog
+n09193705 alp
+n09229709 bubble
+n09246464 cliff, drop, drop-off
+n09256479 coral reef
+n09288635 geyser
+n09332890 lakeside, lakeshore
+n09399592 promontory, headland, head, foreland
+n09421951 sandbar, sand bar
+n09428293 seashore, coast, seacoast, sea-coast
+n09468604 valley, vale
+n09472597 volcano
+n09835506 ballplayer, baseball player
+n10148035 groom, bridegroom
+n10565667 scuba diver
+n11879895 rapeseed
+n11939491 daisy
+n12057211 yellow lady's slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum
+n12144580 corn
+n12267677 acorn
+n12620546 hip, rose hip, rosehip
+n12768682 buckeye, horse chestnut, conker
+n12985857 coral fungus
+n12998815 agaric
+n13037406 gyromitra
+n13040303 stinkhorn, carrion fungus
+n13044778 earthstar
+n13052670 hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa
+n13054560 bolete
+n13133613 ear, spike, capitulum
+n15075141 toilet tissue, toilet paper, bathroom tissue
diff --git a/crates/wasi-nn/examples/classification-example-winml/src/main.rs b/crates/wasi-nn/examples/classification-example-winml/src/main.rs
new file mode 100644
index 000000000000..a435fb5f5cc3
--- /dev/null
+++ b/crates/wasi-nn/examples/classification-example-winml/src/main.rs
@@ -0,0 +1,135 @@
+use image::{DynamicImage, RgbImage};
+use ndarray::Array;
+use std::{fs, time::Instant};
+
+pub fn main() {
+    // Load model from a file.
+    let graph =
+        wasi_nn::GraphBuilder::new(wasi_nn::GraphEncoding::Onnx, wasi_nn::ExecutionTarget::CPU)
+            .build_from_files(["fixture/mobilenet.onnx"])
+            .unwrap();
+
+    let mut context = graph.init_execution_context().unwrap();
+    println!("Created an execution context.");
+
+    // Read image from file and convert it to tensor data.
+    let image_data = fs::read("fixture/kitten.png").unwrap();
+
+    // Preprocessing. Normalize data based on model requirements https://github.com/onnx/models/tree/main/validated/vision/classification/mobilenet#preprocessing
+    let tensor_data = preprocess(
+        image_data.as_slice(),
+        224,
+        224,
+        &[0.485, 0.456, 0.406],
+        &[0.229, 0.224, 0.225],
+    );
+    println!("Read input tensor, size in bytes: {}", tensor_data.len());
+
+    context
+        .set_input(0, wasi_nn::TensorType::F32, &[1, 3, 224, 224], &tensor_data)
+        .unwrap();
+
+    // Execute the inference.
+    let before_compute = Instant::now();
+    context.compute().unwrap();
+    println!(
+        "Executed graph inference, took {} ms.",
+        before_compute.elapsed().as_millis()
+    );
+
+    // Retrieve the output.
+    let mut output_buffer = vec![0f32; 1000];
+    context.get_output(0, &mut output_buffer[..]).unwrap();
+
+    // Postprocessing. Calculating the softmax probability scores.
+    let result = postprocess(output_buffer);
+
+    // Load labels for classification
+    let labels_file = fs::read("fixture/synset.txt").unwrap();
+    let labels_str = String::from_utf8(labels_file).unwrap();
+    let labels: Vec<String> = labels_str
+        .lines()
+        .map(|line| {
+            let words: Vec<&str> = line.split_whitespace().collect();
+            words[1..].join(" ")
+        })
+        .collect();
+
+    println!(
+        "Found results, sorted top 5: {:?}",
+        &sort_results(&result, &labels)[..5]
+    )
+}
+
+// Sort the buffer of probabilities. The graph places the match probability for each class at the
+// index for that class (e.g. the probability of class 42 is placed at buffer[42]). Here we convert
+// to a wrapping InferenceResult and sort the results.
+fn sort_results(buffer: &[f32], labels: &Vec<String>) -> Vec<InferenceResult> {
+    let mut results: Vec<InferenceResult> = buffer
+        .iter()
+        .enumerate()
+        .map(|(c, p)| InferenceResult(labels[c].clone(), *p))
+        .collect();
+    results.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
+    results
+}
+
+// Resize image to height x width, and then converts the pixel precision to FP32, normalize with
+// given mean and std. The resulting RGB pixel vector is then returned.
+fn preprocess(image: &[u8], height: u32, width: u32, mean: &[f32], std: &[f32]) -> Vec<u8> {
+    let dyn_img: DynamicImage = image::load_from_memory(image).unwrap().resize_exact(
+        width,
+        height,
+        image::imageops::Triangle,
+    );
+    let rgb_img: RgbImage = dyn_img.to_rgb8();
+
+    // Get an array of the pixel values
+    let raw_u8_arr: &[u8] = &rgb_img.as_raw()[..];
+
+    // Create an array to hold the f32 value of those pixels
+    let bytes_required = raw_u8_arr.len() * 4;
+    let mut u8_f32_arr: Vec<u8> = vec![0; bytes_required];
+
+    // Read the number as a f32 and break it into u8 bytes
+    for i in 0..raw_u8_arr.len() {
+        let u8_f32: f32 = raw_u8_arr[i] as f32;
+        let rgb_iter = i % 3;
+
+        // Normalize the pixel
+        let norm_u8_f32: f32 = (u8_f32 / 255.0 - mean[rgb_iter]) / std[rgb_iter];
+
+        // Convert it to u8 bytes and write it with new shape
+        let u8_bytes = norm_u8_f32.to_ne_bytes();
+        for j in 0..4 {
+            u8_f32_arr[(raw_u8_arr.len() * 4 * rgb_iter / 3) + (i / 3) * 4 + j] = u8_bytes[j];
+        }
+    }
+
+    return u8_f32_arr;
+}
+
+fn postprocess(output_tensor: Vec<f32>) -> Vec<f32> {
+    // Post-Processing requirement: compute softmax to inferencing output
+    let output_shape = [1, 1000, 1, 1];
+    let exp_output = Array::from_shape_vec(output_shape, output_tensor)
+        .unwrap()
+        .mapv(|x| x.exp());
+    let sum_exp_output = exp_output.sum_axis(ndarray::Axis(1));
+    let softmax_output = exp_output / &sum_exp_output;
+    softmax_output.into_raw_vec()
+}
+
+pub fn bytes_to_f32_vec(data: Vec<u8>) -> Vec<f32> {
+    let chunks: Vec<&[u8]> = data.chunks(4).collect();
+    let v: Vec<f32> = chunks
+        .into_iter()
+        .map(|c| f32::from_ne_bytes(c.try_into().unwrap()))
+        .collect();
+
+    v.into_iter().collect()
+}
+
+// A wrapper for class ID and match probabilities.
+#[derive(Debug, PartialEq)]
+struct InferenceResult(String, f32);
diff --git a/crates/wasi-nn/examples/classification-example/Cargo.toml b/crates/wasi-nn/examples/classification-example/Cargo.toml
index 7cedd6252c43..0d0ad0e58efc 100644
--- a/crates/wasi-nn/examples/classification-example/Cargo.toml
+++ b/crates/wasi-nn/examples/classification-example/Cargo.toml
@@ -9,7 +9,7 @@ publish = false
 [dependencies]
 wasi-nn = "0.1.0"
 
-# This crate is built with the wasm32-wasi target, so it's separate
+# This crate is built with the wasm32-wasip1 target, so it's separate
 # from the main Wasmtime build, so use this directive to exclude it
 # from the parent directory's workspace.
 [workspace]
diff --git a/crates/wasi-nn/examples/classification-example/README.md b/crates/wasi-nn/examples/classification-example/README.md
index aa56ad0cbaf7..f0b4e0fa4b9d 100644
--- a/crates/wasi-nn/examples/classification-example/README.md
+++ b/crates/wasi-nn/examples/classification-example/README.md
@@ -1,2 +1,2 @@
-This example project demonstrates using the `wasi-nn` API to perform ML inference. It consists of Rust code that is 
-built using the `wasm32-wasi` target. See `ci/run-wasi-nn-example.sh` for how this is used.
+This example project demonstrates using the `wasi-nn` API to perform ML inference. It consists of Rust code that is
+built using the `wasm32-wasip1` target. See `ci/run-wasi-nn-example.sh` for how this is used.
diff --git a/crates/wasi-nn/spec b/crates/wasi-nn/spec
deleted file mode 160000
index c1f8b87e923a..000000000000
--- a/crates/wasi-nn/spec
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit c1f8b87e923aedda02964c31b0e1d37e331ec402
diff --git a/crates/wasi-nn/src/backend/mod.rs b/crates/wasi-nn/src/backend/mod.rs
index e55b94aa411d..0409ddf523f8 100644
--- a/crates/wasi-nn/src/backend/mod.rs
+++ b/crates/wasi-nn/src/backend/mod.rs
@@ -2,18 +2,44 @@
 //! this crate. The `Box<dyn ...>` types returned by these interfaces allow
 //! implementations to maintain backend-specific state between calls.
 
+#[cfg(feature = "onnx")]
+pub mod onnx;
+#[cfg(feature = "openvino")]
 pub mod openvino;
+#[cfg(all(feature = "winml", target_os = "windows"))]
+pub mod winml;
 
+#[cfg(feature = "onnx")]
+use self::onnx::OnnxBackend;
+#[cfg(feature = "openvino")]
 use self::openvino::OpenvinoBackend;
-use crate::wit::types::{ExecutionTarget, GraphEncoding, Tensor};
+#[cfg(all(feature = "winml", target_os = "windows"))]
+use self::winml::WinMLBackend;
+
+use crate::wit::{ExecutionTarget, GraphEncoding, Tensor};
 use crate::{Backend, ExecutionContext, Graph};
+use std::fs::File;
+use std::io::Read;
 use std::path::Path;
 use thiserror::Error;
 use wiggle::GuestError;
 
 /// Return a list of all available backend frameworks.
-pub fn list() -> Vec<crate::Backend> {
-    vec![Backend::from(OpenvinoBackend::default())]
+pub fn list() -> Vec<Backend> {
+    let mut backends = vec![];
+    #[cfg(feature = "openvino")]
+    {
+        backends.push(Backend::from(OpenvinoBackend::default()));
+    }
+    #[cfg(all(feature = "winml", target_os = "windows"))]
+    {
+        backends.push(Backend::from(WinMLBackend::default()));
+    }
+    #[cfg(feature = "onnx")]
+    {
+        backends.push(Backend::from(OnnxBackend::default()));
+    }
+    backends
 }
 
 /// A [Backend] contains the necessary state to load [Graph]s.
@@ -43,9 +69,30 @@ pub trait BackendGraph: Send + Sync {
 /// A [BackendExecutionContext] performs the actual inference; this is the
 /// backing implementation for a user-facing execution context.
 pub trait BackendExecutionContext: Send + Sync {
-    fn set_input(&mut self, index: u32, tensor: &Tensor) -> Result<(), BackendError>;
+    fn set_input(&mut self, id: Id, tensor: &Tensor) -> Result<(), BackendError>;
     fn compute(&mut self) -> Result<(), BackendError>;
-    fn get_output(&mut self, index: u32, destination: &mut [u8]) -> Result<u32, BackendError>;
+    fn get_output(&mut self, id: Id) -> Result<Tensor, BackendError>;
+}
+
+/// An identifier for a tensor in a [Graph].
+#[derive(Debug)]
+pub enum Id {
+    Index(u32),
+    Name(String),
+}
+impl Id {
+    pub fn index(&self) -> Option<u32> {
+        match self {
+            Id::Index(i) => Some(*i),
+            Id::Name(_) => None,
+        }
+    }
+    pub fn name(&self) -> Option<&str> {
+        match self {
+            Id::Index(_) => None,
+            Id::Name(n) => Some(n),
+        }
+    }
 }
 
 /// Errors returned by a backend; [BackendError::BackendAccess] is a catch-all
@@ -60,4 +107,14 @@ pub enum BackendError {
     InvalidNumberOfBuilders(usize, usize),
     #[error("Not enough memory to copy tensor data of size: {0}")]
     NotEnoughMemory(usize),
+    #[error("Unsupported tensor type: {0}")]
+    UnsupportedTensorType(String),
+}
+
+/// Read a file into a byte vector.
+fn read(path: &Path) -> anyhow::Result<Vec<u8>> {
+    let mut file = File::open(path)?;
+    let mut buffer = vec![];
+    file.read_to_end(&mut buffer)?;
+    Ok(buffer)
 }
diff --git a/crates/wasi-nn/src/backend/onnx.rs b/crates/wasi-nn/src/backend/onnx.rs
new file mode 100644
index 000000000000..b6ae2ddf278e
--- /dev/null
+++ b/crates/wasi-nn/src/backend/onnx.rs
@@ -0,0 +1,338 @@
+//! Implements a `wasi-nn` [`BackendInner`] using ONNX via the `ort` crate.
+
+use super::{BackendError, BackendExecutionContext, BackendFromDir, BackendGraph, BackendInner};
+use crate::backend::{read, Id};
+use crate::wit::types::{ExecutionTarget, GraphEncoding, Tensor, TensorType};
+use crate::{ExecutionContext, Graph};
+use anyhow::Context;
+use ort::{inputs, GraphOptimizationLevel, Session};
+use std::path::Path;
+use std::sync::{Arc, Mutex};
+
+#[derive(Default)]
+pub struct OnnxBackend();
+unsafe impl Send for OnnxBackend {}
+unsafe impl Sync for OnnxBackend {}
+
+impl BackendInner for OnnxBackend {
+    fn encoding(&self) -> GraphEncoding {
+        GraphEncoding::Onnx
+    }
+
+    fn load(&mut self, builders: &[&[u8]], target: ExecutionTarget) -> Result<Graph, BackendError> {
+        if builders.len() != 1 {
+            return Err(BackendError::InvalidNumberOfBuilders(1, builders.len()).into());
+        }
+
+        let session = Session::builder()?
+            .with_optimization_level(GraphOptimizationLevel::Level3)?
+            .commit_from_memory(builders[0])?;
+
+        let box_: Box<dyn BackendGraph> =
+            Box::new(OnnxGraph(Arc::new(Mutex::new(session)), target));
+        Ok(box_.into())
+    }
+
+    fn as_dir_loadable<'a>(&'a mut self) -> Option<&'a mut dyn BackendFromDir> {
+        Some(self)
+    }
+}
+
+impl BackendFromDir for OnnxBackend {
+    fn load_from_dir(
+        &mut self,
+        path: &Path,
+        target: ExecutionTarget,
+    ) -> Result<Graph, BackendError> {
+        let model = read(&path.join("model.onnx"))?;
+        self.load(&[&model], target)
+    }
+}
+
+struct OnnxGraph(Arc<Mutex<Session>>, #[allow(dead_code)] ExecutionTarget);
+unsafe impl Send for OnnxGraph {}
+unsafe impl Sync for OnnxGraph {}
+
+impl BackendGraph for OnnxGraph {
+    fn init_execution_context(&self) -> Result<ExecutionContext, BackendError> {
+        let session = self.0.lock().unwrap();
+        // We need to hold on to the names of the inputs in order for
+        // `set_input` to work with both indexes and names. Having the
+        // dimensions and type around is useful for validation but could be
+        // retrieved from the session.
+        let mut inputs = vec![];
+        for input in &session.inputs {
+            let shape = Shape::from_onnx_input(input)?;
+            inputs.push(TensorSlot {
+                shape,
+                tensor: None,
+            });
+        }
+        // We need to keep track of the output shapes since they are used for
+        // creating the output tensor.
+        let mut outputs = vec![];
+        for output in &session.outputs {
+            let shape = Shape::from_onnx_output(output)?;
+            outputs.push(TensorSlot {
+                shape,
+                tensor: None,
+            });
+        }
+        let box_: Box<dyn BackendExecutionContext> = Box::new(OnnxExecutionContext {
+            session: self.0.clone(),
+            inputs,
+            outputs,
+        });
+        Ok(box_.into())
+    }
+}
+
+struct OnnxExecutionContext {
+    session: Arc<Mutex<Session>>,
+    inputs: Vec<TensorSlot>,
+    outputs: Vec<TensorSlot>,
+}
+
+unsafe impl Send for OnnxExecutionContext {}
+unsafe impl Sync for OnnxExecutionContext {}
+
+impl OnnxExecutionContext {
+    /// Helper function for finding the internal index of a tensor by [`Id`].
+    fn find(&self, id: Id, list: &[TensorSlot]) -> Result<usize, BackendError> {
+        let index = match id {
+            Id::Index(i) => {
+                let i = i as usize;
+                if i < list.len() {
+                    i
+                } else {
+                    return Err(BackendError::BackendAccess(anyhow::anyhow!(
+                        "incorrect tensor index: {i} >= {}",
+                        list.len()
+                    )));
+                }
+            }
+            Id::Name(n) => list.iter().position(|s| s.shape.name == n).ok_or_else(|| {
+                BackendError::BackendAccess(anyhow::anyhow!("unknown tensor name: {n}"))
+            })?,
+        };
+        Ok(index)
+    }
+}
+
+impl BackendExecutionContext for OnnxExecutionContext {
+    fn set_input(&mut self, id: Id, tensor: &Tensor) -> Result<(), BackendError> {
+        let index = self.find(id, &self.inputs)?;
+        let input = &mut self.inputs[index];
+        if let Err(e) = input.shape.matches(tensor) {
+            return Err(e.into());
+        }
+        // Hold the tensor data on the context until `compute` is called.
+        input.tensor.replace(tensor.clone());
+        Ok(())
+    }
+
+    fn compute(&mut self) -> Result<(), BackendError> {
+        let mut session_inputs: Vec<ort::SessionInputValue<'_>> = vec![];
+        for i in &self.inputs {
+            session_inputs.extend(to_input_value(i)?);
+        }
+        let session = self.session.lock().unwrap();
+        let session_outputs = session.run(session_inputs.as_slice())?;
+        for i in 0..self.outputs.len() {
+            // TODO: fix preexisting gap--this only handles f32 tensors.
+            let raw: (Vec<i64>, &[f32]) = session_outputs[i].try_extract_raw_tensor()?;
+            let f32s = raw.1.to_vec();
+            let output = &mut self.outputs[i];
+            output.tensor.replace(Tensor {
+                dimensions: output.shape.dimensions_as_u32()?,
+                ty: output.shape.ty,
+                data: f32_vec_to_bytes(f32s),
+            });
+        }
+        Ok(())
+    }
+
+    fn get_output(&mut self, id: Id) -> Result<Tensor, BackendError> {
+        let index = self.find(id, &self.outputs)?;
+        let output = &self.outputs[index];
+        if let Some(tensor) = &output.tensor {
+            Ok(tensor.clone())
+        } else {
+            Err(BackendError::BackendAccess(anyhow::anyhow!(
+                "missing output tensor: {}; has `compute` been called?",
+                output.shape.name
+            )))
+        }
+    }
+}
+
+impl From<ort::Error> for BackendError {
+    fn from(e: ort::Error) -> Self {
+        BackendError::BackendAccess(e.into())
+    }
+}
+
+/// Holds a slot for ONNX session inputs and outputs.
+///
+/// TODO: it seems unfortunate that we have to "hold" some extra data per
+/// session but in the input case, this is necessary for name-based indexing.
+struct TensorSlot {
+    shape: Shape,
+    tensor: Option<Tensor>,
+}
+
+/// Describes a tensor in ONNX terms.
+struct Shape {
+    name: String,
+    dimensions: Vec<i64>,
+    ty: TensorType,
+}
+
+impl Shape {
+    fn from_onnx_input(input: &ort::Input) -> Result<Self, BackendError> {
+        let name = input.name.clone();
+        let (dimensions, ty) = convert_value_type(&input.input_type)?;
+        Ok(Self {
+            name,
+            dimensions,
+            ty,
+        })
+    }
+
+    fn from_onnx_output(output: &ort::Output) -> Result<Self, BackendError> {
+        let name = output.name.clone();
+        let (dimensions, ty) = convert_value_type(&output.output_type)?;
+        Ok(Self {
+            name,
+            dimensions,
+            ty,
+        })
+    }
+
+    fn dimensions_as_u32(&self) -> Result<Vec<u32>, BackendError> {
+        self.dimensions
+            .iter()
+            .map(|d| if *d == -1 { Ok(1) } else { convert_i64(d) })
+            .collect()
+    }
+
+    fn matches(&self, tensor: &Tensor) -> anyhow::Result<()> {
+        if self.dimensions.len() != tensor.dimensions.len() {
+            return Err(anyhow::anyhow!(
+                "input tensor cardinality does not match model: {:?} != {:?}",
+                self.dimensions,
+                tensor.dimensions
+            ));
+        } else {
+            for (&shape_dim, &tensor_dim) in self.dimensions.iter().zip(tensor.dimensions.iter()) {
+                let tensor_dim = tensor_dim as i64;
+                if !is_dynamic_dimension(shape_dim) && shape_dim != tensor_dim {
+                    return Err(anyhow::anyhow!(
+                        "input tensor dimensions do not match model: {:?} != {:?}",
+                        self.dimensions,
+                        tensor.dimensions
+                    ));
+                }
+            }
+        }
+        if self.ty != tensor.ty {
+            return Err(anyhow::anyhow!(
+                "input tensor type does not match model: {:?} != {:?}",
+                self.ty,
+                tensor.ty
+            ));
+        }
+        Ok(())
+    }
+}
+
+fn convert_value_type(vt: &ort::ValueType) -> Result<(Vec<i64>, TensorType), BackendError> {
+    match vt {
+        ort::ValueType::Tensor { ty, dimensions } => {
+            let dims = dimensions.clone();
+            let ty = (*ty).try_into()?;
+            Ok((dims, ty))
+        }
+        _ => Err(BackendError::BackendAccess(anyhow::anyhow!(
+            "unsupported input type: {vt:?}"
+        ))),
+    }
+}
+
+fn convert_i64(i: &i64) -> Result<u32, BackendError> {
+    u32::try_from(*i).map_err(|d| -> BackendError {
+        anyhow::anyhow!("unable to convert dimension to u32: {d}").into()
+    })
+}
+
+impl TryFrom<ort::TensorElementType> for TensorType {
+    type Error = BackendError;
+    fn try_from(ty: ort::TensorElementType) -> Result<Self, Self::Error> {
+        match ty {
+            ort::TensorElementType::Float32 => Ok(TensorType::Fp32),
+            ort::TensorElementType::Float64 => Ok(TensorType::Fp64),
+            ort::TensorElementType::Uint8 => Ok(TensorType::U8),
+            ort::TensorElementType::Int32 => Ok(TensorType::I32),
+            ort::TensorElementType::Int64 => Ok(TensorType::I64),
+            _ => Err(BackendError::BackendAccess(anyhow::anyhow!(
+                "unsupported tensor type: {ty:?}"
+            ))),
+        }
+    }
+}
+
+fn to_input_value(slot: &TensorSlot) -> Result<[ort::SessionInputValue<'_>; 1], BackendError> {
+    match &slot.tensor {
+        Some(tensor) => match tensor.ty {
+            TensorType::Fp32 => {
+                let data = bytes_to_f32_vec(tensor.data.to_vec());
+                let dimensions = tensor
+                    .dimensions
+                    .iter()
+                    .map(|d| *d as i64) // TODO: fewer conversions
+                    .collect::<Vec<i64>>();
+                Ok(inputs![(dimensions, Arc::new(data.into_boxed_slice()))]
+                    .context("failed to create ONNX session input")?)
+            }
+            _ => {
+                unimplemented!("{:?} not supported by ONNX", tensor.ty);
+            }
+        },
+        None => {
+            return Err(BackendError::BackendAccess(anyhow::anyhow!(
+                "missing input tensor: {}",
+                slot.shape.name
+            )));
+        }
+    }
+}
+
+pub fn f32_vec_to_bytes(data: Vec<f32>) -> Vec<u8> {
+    let chunks: Vec<[u8; 4]> = data.into_iter().map(|f| f.to_le_bytes()).collect();
+    let result: Vec<u8> = chunks.iter().flatten().copied().collect();
+    result
+}
+
+pub fn bytes_to_f32_vec(data: Vec<u8>) -> Vec<f32> {
+    let chunks: Vec<&[u8]> = data.chunks(4).collect();
+    let v: Vec<f32> = chunks
+        .into_iter()
+        .map(|c| f32::from_le_bytes(c.try_into().unwrap()))
+        .collect();
+
+    v.into_iter().collect()
+}
+
+/// Returns whether the dimension is dynamic.
+///
+/// ONNX uses [dimensional variables] (i.e., name strings) to indicate that the
+/// value of a tensor dimension is user-defined, not fixed by the model. This is
+/// useful for batching up several inference requests, e.g. When `ort` returns a
+/// dimension of this kind, though, it uses `-1` to indicate that the dimension
+/// is dynamic.
+///
+/// [dimensional variables]:
+///     https://onnx.ai/onnx/repo-docs/IR.html#static-tensor-shapes
+fn is_dynamic_dimension(d: i64) -> bool {
+    d == -1
+}
diff --git a/crates/wasi-nn/src/backend/openvino.rs b/crates/wasi-nn/src/backend/openvino.rs
index 428e0fcbd98d..8be15bd25051 100644
--- a/crates/wasi-nn/src/backend/openvino.rs
+++ b/crates/wasi-nn/src/backend/openvino.rs
@@ -1,11 +1,13 @@
 //! Implements a `wasi-nn` [`BackendInner`] using OpenVINO.
 
-use super::{BackendError, BackendExecutionContext, BackendFromDir, BackendGraph, BackendInner};
-use crate::wit::types::{ExecutionTarget, GraphEncoding, Tensor, TensorType};
+use super::{
+    read, BackendError, BackendExecutionContext, BackendFromDir, BackendGraph, BackendInner, Id,
+};
+use crate::wit::{ExecutionTarget, GraphEncoding, Tensor, TensorType};
 use crate::{ExecutionContext, Graph};
-use openvino::{InferenceError, Layout, Precision, SetupError, TensorDesc};
+use openvino::{DeviceType, ElementType, InferenceError, SetupError, Shape, Tensor as OvTensor};
+use std::path::Path;
 use std::sync::{Arc, Mutex};
-use std::{fs::File, io::Read, path::Path};
 
 #[derive(Default)]
 pub struct OpenvinoBackend(Option<openvino::Core>);
@@ -21,41 +23,33 @@ impl BackendInner for OpenvinoBackend {
         if builders.len() != 2 {
             return Err(BackendError::InvalidNumberOfBuilders(2, builders.len()).into());
         }
-
         // Construct the context if none is present; this is done lazily (i.e.
         // upon actually loading a model) because it may fail to find and load
         // the OpenVINO libraries. The laziness limits the extent of the error
         // only to wasi-nn users, not all WASI users.
         if self.0.is_none() {
-            self.0.replace(openvino::Core::new(None)?);
+            self.0.replace(openvino::Core::new()?);
         }
-
         // Read the guest array.
-        let xml = &builders[0];
-        let weights = &builders[1];
+        let xml = builders[0];
+        let weights = builders[1];
 
-        // Construct OpenVINO graph structures: `cnn_network` contains the graph
-        // structure, `exec_network` can perform inference.
+        // Construct a new tensor for the model weights.
+        let shape = Shape::new(&[1, weights.len() as i64])?;
+        let mut weights_tensor = OvTensor::new(ElementType::U8, &shape)?;
+        let buffer = weights_tensor.get_raw_data_mut()?;
+        buffer.copy_from_slice(&weights);
+
+        // Construct OpenVINO graph structures: `model` contains the graph
+        // structure, `compiled_model` can perform inference.
         let core = self
             .0
             .as_mut()
             .expect("openvino::Core was previously constructed");
-        let mut cnn_network = core.read_network_from_buffer(&xml, &weights)?;
-
-        // TODO: this is a temporary workaround. We need a more elegant way to
-        // specify the layout in the long run. However, without this newer
-        // versions of OpenVINO will fail due to parameter mismatch.
-        for i in 0..cnn_network.get_inputs_len()? {
-            let name = cnn_network.get_input_name(i)?;
-            cnn_network.set_input_layout(&name, Layout::NHWC)?;
-        }
-
-        let exec_network =
-            core.load_network(&cnn_network, map_execution_target_to_string(target))?;
-        let box_: Box<dyn BackendGraph> = Box::new(OpenvinoGraph(
-            Arc::new(cnn_network),
-            Arc::new(Mutex::new(exec_network)),
-        ));
+        let model = core.read_model_from_buffer(&xml, Some(&weights_tensor))?;
+        let compiled_model = core.compile_model(&model, target.into())?;
+        let box_: Box<dyn BackendGraph> =
+            Box::new(OpenvinoGraph(Arc::new(Mutex::new(compiled_model))));
         Ok(box_.into())
     }
 
@@ -76,62 +70,67 @@ impl BackendFromDir for OpenvinoBackend {
     }
 }
 
-struct OpenvinoGraph(
-    Arc<openvino::CNNNetwork>,
-    Arc<Mutex<openvino::ExecutableNetwork>>,
-);
+struct OpenvinoGraph(Arc<Mutex<openvino::CompiledModel>>);
 
 unsafe impl Send for OpenvinoGraph {}
 unsafe impl Sync for OpenvinoGraph {}
 
 impl BackendGraph for OpenvinoGraph {
     fn init_execution_context(&self) -> Result<ExecutionContext, BackendError> {
-        let mut network = self.1.lock().unwrap();
-        let infer_request = network.create_infer_request()?;
+        let mut compiled_model = self.0.lock().unwrap();
+        let infer_request = compiled_model.create_infer_request()?;
         let box_: Box<dyn BackendExecutionContext> =
-            Box::new(OpenvinoExecutionContext(self.0.clone(), infer_request));
+            Box::new(OpenvinoExecutionContext(infer_request));
         Ok(box_.into())
     }
 }
 
-struct OpenvinoExecutionContext(Arc<openvino::CNNNetwork>, openvino::InferRequest);
+struct OpenvinoExecutionContext(openvino::InferRequest);
 
 impl BackendExecutionContext for OpenvinoExecutionContext {
-    fn set_input(&mut self, index: u32, tensor: &Tensor) -> Result<(), BackendError> {
-        let input_name = self.0.get_input_name(index as usize)?;
-
-        // Construct the blob structure. TODO: there must be some good way to
-        // discover the layout here; `desc` should not have to default to NHWC.
-        let precision = map_tensor_type_to_precision(tensor.tensor_type);
+    fn set_input(&mut self, id: Id, tensor: &Tensor) -> Result<(), BackendError> {
+        // Construct the tensor.
+        let precision = tensor.ty.into();
         let dimensions = tensor
             .dimensions
             .iter()
-            .map(|&d| d as usize)
+            .map(|&d| d as i64)
             .collect::<Vec<_>>();
-        let desc = TensorDesc::new(Layout::NHWC, &dimensions, precision);
-        let blob = openvino::Blob::new(&desc, &tensor.data)?;
-
-        // Actually assign the blob to the request.
-        self.1.set_blob(&input_name, &blob)?;
+        let shape = Shape::new(&dimensions)?;
+        let mut new_tensor = OvTensor::new(precision, &shape)?;
+        let buffer = new_tensor.get_raw_data_mut()?;
+        buffer.copy_from_slice(&tensor.data);
+        // Assign the tensor to the request.
+        match id {
+            Id::Index(i) => self.0.set_input_tensor_by_index(i as usize, &new_tensor)?,
+            Id::Name(name) => self.0.set_tensor(&name, &new_tensor)?,
+        };
         Ok(())
     }
 
     fn compute(&mut self) -> Result<(), BackendError> {
-        self.1.infer()?;
+        self.0.infer()?;
         Ok(())
     }
 
-    fn get_output(&mut self, index: u32, destination: &mut [u8]) -> Result<u32, BackendError> {
-        let output_name = self.0.get_output_name(index as usize)?;
-        let blob = self.1.get_blob(&output_name)?;
-        let blob_size = blob.byte_len()?;
-        if blob_size > destination.len() {
-            return Err(BackendError::NotEnoughMemory(blob_size));
-        }
-
-        // Copy the tensor data into the destination buffer.
-        destination[..blob_size].copy_from_slice(blob.buffer()?);
-        Ok(blob_size as u32)
+    fn get_output(&mut self, id: Id) -> Result<Tensor, BackendError> {
+        let output_name = match id {
+            Id::Index(i) => self.0.get_output_tensor_by_index(i as usize)?,
+            Id::Name(name) => self.0.get_tensor(&name)?,
+        };
+        let dimensions = output_name
+            .get_shape()?
+            .get_dimensions()
+            .iter()
+            .map(|&dim| dim as u32)
+            .collect::<Vec<u32>>();
+        let ty = output_name.get_element_type()?.try_into()?;
+        let data = output_name.get_raw_data()?.to_vec();
+        Ok(Tensor {
+            dimensions,
+            ty,
+            data,
+        })
     }
 }
 
@@ -149,30 +148,49 @@ impl From<SetupError> for BackendError {
 
 /// Return the execution target string expected by OpenVINO from the
 /// `ExecutionTarget` enum provided by wasi-nn.
-fn map_execution_target_to_string(target: ExecutionTarget) -> &'static str {
-    match target {
-        ExecutionTarget::Cpu => "CPU",
-        ExecutionTarget::Gpu => "GPU",
-        ExecutionTarget::Tpu => unimplemented!("OpenVINO does not support TPU execution targets"),
+impl From<ExecutionTarget> for DeviceType<'static> {
+    fn from(target: ExecutionTarget) -> Self {
+        match target {
+            ExecutionTarget::Cpu => DeviceType::CPU,
+            ExecutionTarget::Gpu => DeviceType::GPU,
+            ExecutionTarget::Tpu => {
+                unimplemented!("OpenVINO does not support TPU execution targets")
+            }
+        }
     }
 }
 
 /// Return OpenVINO's precision type for the `TensorType` enum provided by
 /// wasi-nn.
-fn map_tensor_type_to_precision(tensor_type: TensorType) -> openvino::Precision {
-    match tensor_type {
-        TensorType::Fp16 => Precision::FP16,
-        TensorType::Fp32 => Precision::FP32,
-        TensorType::U8 => Precision::U8,
-        TensorType::I32 => Precision::I32,
-        TensorType::Bf16 => todo!("not yet supported in `openvino` bindings"),
+impl From<TensorType> for ElementType {
+    fn from(tensor_type: TensorType) -> Self {
+        match tensor_type {
+            TensorType::Fp16 => ElementType::F16,
+            TensorType::Fp32 => ElementType::F32,
+            TensorType::Fp64 => ElementType::F64,
+            TensorType::U8 => ElementType::U8,
+            TensorType::I32 => ElementType::I32,
+            TensorType::I64 => ElementType::I64,
+            TensorType::Bf16 => ElementType::Bf16,
+        }
     }
 }
 
-/// Read a file into a byte vector.
-fn read(path: &Path) -> anyhow::Result<Vec<u8>> {
-    let mut file = File::open(path)?;
-    let mut buffer = vec![];
-    file.read_to_end(&mut buffer)?;
-    Ok(buffer)
+/// Return the `TensorType` enum provided by wasi-nn for OpenVINO's precision type
+impl TryFrom<ElementType> for TensorType {
+    type Error = BackendError;
+    fn try_from(element_type: ElementType) -> Result<Self, Self::Error> {
+        match element_type {
+            ElementType::F16 => Ok(TensorType::Fp16),
+            ElementType::F32 => Ok(TensorType::Fp32),
+            ElementType::F64 => Ok(TensorType::Fp64),
+            ElementType::U8 => Ok(TensorType::U8),
+            ElementType::I32 => Ok(TensorType::I32),
+            ElementType::I64 => Ok(TensorType::I64),
+            ElementType::Bf16 => Ok(TensorType::Bf16),
+            _ => Err(BackendError::UnsupportedTensorType(
+                element_type.to_string(),
+            )),
+        }
+    }
 }
diff --git a/crates/wasi-nn/src/backend/winml.rs b/crates/wasi-nn/src/backend/winml.rs
new file mode 100644
index 000000000000..4f509351cc1b
--- /dev/null
+++ b/crates/wasi-nn/src/backend/winml.rs
@@ -0,0 +1,386 @@
+//! Implements a `wasi-nn` [`BackendInner`] using WinML.
+//!
+//! Note that the [docs.rs] documentation for the `windows` crate does have the
+//! right features turned on to read about the functions used; see Microsoft's
+//! private documentation instead: [microsoft.github.io/windows-docs-rs].
+//!
+//! [docs.rs]: https://docs.rs/windows
+//! [microsoft.github.io/windows-docs-rs]: https://microsoft.github.io/windows-docs-rs/doc/windows/AI/MachineLearning
+
+use crate::backend::{
+    BackendError, BackendExecutionContext, BackendFromDir, BackendGraph, BackendInner, Id,
+};
+use crate::wit::{ExecutionTarget, GraphEncoding, Tensor, TensorType};
+use crate::{ExecutionContext, Graph};
+use std::{fs::File, io::Read, mem::size_of, path::Path};
+use windows::core::{ComInterface, Error, IInspectable, HSTRING};
+use windows::Foundation::Collections::IVectorView;
+use windows::Storage::Streams::{
+    DataWriter, InMemoryRandomAccessStream, RandomAccessStreamReference,
+};
+use windows::AI::MachineLearning::{
+    ILearningModelFeatureDescriptor, LearningModel, LearningModelBinding, LearningModelDevice,
+    LearningModelDeviceKind, LearningModelEvaluationResult, LearningModelSession,
+    TensorFeatureDescriptor, TensorFloat, TensorFloat16Bit, TensorInt64Bit, TensorKind,
+};
+
+#[derive(Default)]
+pub struct WinMLBackend();
+
+impl BackendInner for WinMLBackend {
+    fn encoding(&self) -> GraphEncoding {
+        GraphEncoding::Onnx
+    }
+
+    fn load(&mut self, builders: &[&[u8]], target: ExecutionTarget) -> Result<Graph, BackendError> {
+        if builders.len() != 1 {
+            return Err(BackendError::InvalidNumberOfBuilders(1, builders.len()).into());
+        }
+
+        let model_stream = InMemoryRandomAccessStream::new()?;
+        let model_writer = DataWriter::CreateDataWriter(&model_stream)?;
+        model_writer.WriteBytes(&builders[0])?;
+        model_writer.StoreAsync()?;
+        model_writer.FlushAsync()?;
+        let model = LearningModel::LoadFromStream(&RandomAccessStreamReference::CreateFromStream(
+            &model_stream,
+        )?)?;
+        let device_kind = match target {
+            ExecutionTarget::Cpu => LearningModelDeviceKind::Cpu,
+            ExecutionTarget::Gpu => LearningModelDeviceKind::DirectX,
+            ExecutionTarget::Tpu => unimplemented!(),
+        };
+        let graph = WinMLGraph { model, device_kind };
+
+        let box_: Box<dyn BackendGraph> = Box::new(graph);
+        Ok(box_.into())
+    }
+
+    fn as_dir_loadable(&mut self) -> Option<&mut dyn BackendFromDir> {
+        Some(self)
+    }
+}
+
+impl BackendFromDir for WinMLBackend {
+    fn load_from_dir(
+        &mut self,
+        path: &Path,
+        target: ExecutionTarget,
+    ) -> Result<Graph, BackendError> {
+        let model = read(&path.join("model.onnx"))?;
+        self.load(&[&model], target)
+    }
+}
+
+struct WinMLGraph {
+    model: LearningModel,
+    device_kind: LearningModelDeviceKind,
+}
+
+unsafe impl Send for WinMLGraph {}
+unsafe impl Sync for WinMLGraph {}
+
+impl BackendGraph for WinMLGraph {
+    fn init_execution_context(&self) -> Result<ExecutionContext, BackendError> {
+        let device = LearningModelDevice::Create(self.device_kind.clone())?;
+        let session = LearningModelSession::CreateFromModelOnDevice(&self.model, &device)?;
+        let box_: Box<dyn BackendExecutionContext> = Box::new(WinMLExecutionContext::new(session));
+        Ok(box_.into())
+    }
+}
+
+struct WinMLExecutionContext {
+    session: LearningModelSession,
+    binding: LearningModelBinding,
+    result: Option<LearningModelEvaluationResult>,
+}
+
+impl WinMLExecutionContext {
+    fn new(session: LearningModelSession) -> Self {
+        Self {
+            binding: LearningModelBinding::CreateFromSession(&session).unwrap(),
+            session,
+            result: None,
+        }
+    }
+}
+
+impl WinMLExecutionContext {
+    /// Helper function for finding the internal index of a tensor by [`Id`].
+    fn find(
+        &self,
+        id: Id,
+        list: &IVectorView<ILearningModelFeatureDescriptor>,
+    ) -> Result<u32, BackendError> {
+        let index = match id {
+            Id::Index(i) => {
+                if i < list.Size()? {
+                    i
+                } else {
+                    return Err(BackendError::BackendAccess(anyhow::anyhow!(
+                        "incorrect tensor index: {i} >= {}",
+                        list.Size()?
+                    )));
+                }
+            }
+            Id::Name(name) => list
+                .into_iter()
+                .position(|d| d.Name().unwrap() == name)
+                .ok_or_else(|| {
+                    BackendError::BackendAccess(anyhow::anyhow!("unknown tensor name: {name}"))
+                })? as u32,
+        };
+        Ok(index)
+    }
+}
+
+impl BackendExecutionContext for WinMLExecutionContext {
+    fn set_input(&mut self, id: Id, tensor: &Tensor) -> Result<(), BackendError> {
+        // TODO: Clear previous bindings when needed.
+
+        let input_features = self.session.Model()?.InputFeatures()?;
+        let index = self.find(id, &input_features)?;
+        let input = input_features.GetAt(index)?;
+
+        let inspectable = to_inspectable(tensor)?;
+        self.binding.Bind(&input.Name()?, &inspectable)?;
+
+        Ok(())
+    }
+
+    fn compute(&mut self) -> Result<(), BackendError> {
+        self.result = Some(self.session.Evaluate(&self.binding, &HSTRING::new())?);
+        Ok(())
+    }
+
+    fn get_output(&mut self, id: Id) -> Result<Tensor, BackendError> {
+        if let Some(result) = &self.result {
+            let output_features = self.session.Model()?.OutputFeatures()?;
+            let index = self.find(id, &output_features)?;
+            let output_feature = output_features.GetAt(index)?;
+            let tensor_kind = match output_feature.Kind()? {
+                windows::AI::MachineLearning::LearningModelFeatureKind::Tensor => output_feature
+                    .cast::<TensorFeatureDescriptor>()?
+                    .TensorKind()?,
+                _ => unimplemented!(
+                    "the WinML backend only supports tensors, found: {:?}",
+                    output_feature.Kind()
+                ),
+            };
+            let tensor = to_tensor(
+                result.Outputs()?.Lookup(&output_feature.Name()?)?,
+                tensor_kind,
+            );
+            tensor
+        } else {
+            return Err(BackendError::BackendAccess(anyhow::Error::msg(
+                "Output is not ready.",
+            )));
+        }
+    }
+}
+
+/// Read a file into a byte vector.
+fn read(path: &Path) -> anyhow::Result<Vec<u8>> {
+    let mut file = File::open(path)?;
+    let mut buffer = vec![];
+    file.read_to_end(&mut buffer)?;
+    Ok(buffer)
+}
+
+impl From<windows::core::Error> for BackendError {
+    fn from(e: windows::core::Error) -> Self {
+        BackendError::BackendAccess(anyhow::Error::new(e))
+    }
+}
+
+fn dimensions_as_u32(dimensions: &IVectorView<i64>) -> Result<Vec<u32>, BackendError> {
+    dimensions
+        .into_iter()
+        .map(|d| if d == -1 { Ok(1) } else { convert_i64(d) })
+        .collect()
+}
+
+fn convert_i64(i: i64) -> Result<u32, BackendError> {
+    u32::try_from(i).map_err(|d| -> BackendError {
+        anyhow::anyhow!("unable to convert dimension to u32: {d}").into()
+    })
+}
+
+// Convert from wasi-nn tensor to WinML tensor.
+fn to_inspectable(tensor: &Tensor) -> Result<IInspectable, Error> {
+    let shape = IVectorView::<i64>::try_from(
+        tensor
+            .dimensions
+            .iter()
+            .map(|&x| x as i64)
+            .collect::<Vec<i64>>(),
+    )?;
+    match tensor.ty {
+        // f16 is not official supported by stable version of Rust. https://github.com/rust-lang/rust/issues/116909
+        // Therefore we create TensorFloat16Bit from f32 array. https://microsoft.github.io/windows-docs-rs/doc/windows/AI/MachineLearning/struct.TensorFloat16Bit.html#method.CreateFromArray
+        TensorType::Fp16 => unsafe {
+            let data = std::slice::from_raw_parts(
+                tensor.data.as_ptr().cast::<f32>(),
+                tensor.data.len() / size_of::<f32>(),
+            );
+            check_alignment::<f32>(data);
+            TensorFloat16Bit::CreateFromArray(&shape, data)?.cast::<IInspectable>()
+        },
+        TensorType::Fp32 => unsafe {
+            let data = std::slice::from_raw_parts(
+                tensor.data.as_ptr().cast::<f32>(),
+                tensor.data.len() / size_of::<f32>(),
+            );
+            check_alignment::<f32>(data);
+            TensorFloat::CreateFromArray(&shape, data)?.cast::<IInspectable>()
+        },
+        TensorType::I64 => unsafe {
+            let data = std::slice::from_raw_parts(
+                tensor.data.as_ptr().cast::<i64>(),
+                tensor.data.len() / size_of::<i64>(),
+            );
+            check_alignment::<i64>(data);
+            TensorInt64Bit::CreateFromArray(&shape, data)?.cast::<IInspectable>()
+        },
+        _ => unimplemented!(),
+    }
+}
+
+// Convert from WinML tensor to wasi-nn tensor.
+fn to_tensor(inspectable: IInspectable, tensor_kind: TensorKind) -> Result<Tensor, BackendError> {
+    let tensor = match tensor_kind {
+        TensorKind::Float16 => {
+            let output_tensor = inspectable.cast::<TensorFloat16Bit>()?;
+            let dimensions = dimensions_as_u32(&output_tensor.Shape()?)?;
+            let view = output_tensor.GetAsVectorView()?;
+            // TODO: Move to f16 when it's available in stable.
+            let data = view.into_iter().flat_map(f32::to_le_bytes).collect();
+            Tensor {
+                ty: TensorType::Fp16,
+                dimensions,
+                data,
+            }
+        }
+        TensorKind::Float => {
+            let output_tensor = inspectable.cast::<TensorFloat>()?;
+            let dimensions = dimensions_as_u32(&output_tensor.Shape()?)?;
+            let view = output_tensor.GetAsVectorView()?;
+            let data = view.into_iter().flat_map(f32::to_le_bytes).collect();
+            Tensor {
+                ty: TensorType::Fp32,
+                dimensions,
+                data,
+            }
+        }
+        TensorKind::Int64 => {
+            let output_tensor = inspectable.cast::<TensorInt64Bit>()?;
+            let dimensions = dimensions_as_u32(&output_tensor.Shape()?)?;
+            let view = output_tensor.GetAsVectorView()?;
+            let data = view.into_iter().flat_map(i64::to_le_bytes).collect();
+            Tensor {
+                ty: TensorType::I64,
+                dimensions,
+                data,
+            }
+        }
+        _ => unimplemented!(),
+    };
+    Ok(tensor)
+}
+
+fn check_alignment<T>(data: &[T]) {
+    let (prefix, _slice, suffix) = unsafe { data.align_to::<T>() };
+    assert!(
+        prefix.is_empty() && suffix.is_empty(),
+        "Data is not aligned to {:?}'s alignment",
+        std::any::type_name::<T>()
+    );
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // Unit tests for different data types. Convert from wasi-nn tensor to WinML tensor and back.
+    #[test]
+    fn fp16() {
+        let data = vec![1.0_f32, 2.0, 3.0, 4.0, 5.0, 6.0];
+        let buffer = data
+            .iter()
+            .map(|f| f.to_ne_bytes())
+            .flatten()
+            .collect::<Vec<u8>>();
+        let buffer_copy = buffer.clone();
+        let tensor = Tensor {
+            ty: TensorType::Fp16,
+            dimensions: vec![2, 3],
+            data: buffer_copy,
+        };
+        let inspectable = to_inspectable(&tensor);
+        assert!(inspectable.is_ok());
+        let winml_tensor = inspectable
+            .as_ref()
+            .unwrap()
+            .cast::<TensorFloat16Bit>()
+            .unwrap();
+        let view = winml_tensor.GetAsVectorView().unwrap();
+        assert_eq!(view.into_iter().collect::<Vec<f32>>(), data);
+        // Convert back.
+        let t = to_tensor(inspectable.unwrap(), TensorKind::Float16);
+        assert!(t.as_ref().is_ok());
+        assert_eq!(t.unwrap(), tensor);
+    }
+
+    #[test]
+    fn fp32() {
+        let data = vec![1.0_f32, 2.0, 3.0, 4.0, 5.0, 6.0];
+        let mut buffer = Vec::with_capacity(data.len() * size_of::<f32>());
+        for f in &data {
+            buffer.extend(f.to_ne_bytes());
+        }
+        let buffer_copy = buffer.clone();
+        let tensor = Tensor {
+            ty: TensorType::Fp32,
+            dimensions: vec![2, 3],
+            data: buffer_copy,
+        };
+        let inspectable = to_inspectable(&tensor);
+        assert!(inspectable.is_ok());
+        let winml_tensor = inspectable.as_ref().unwrap().cast::<TensorFloat>().unwrap();
+        let view = winml_tensor.GetAsVectorView().unwrap();
+        assert_eq!(view.into_iter().collect::<Vec<f32>>(), data);
+        // Convert back.
+        let t = to_tensor(inspectable.unwrap(), TensorKind::Float);
+        assert!(t.as_ref().is_ok());
+        assert_eq!(t.unwrap(), tensor);
+    }
+
+    #[test]
+    fn i64() {
+        let data = vec![6i64, 5, 4, 3, 2, 1];
+        let mut buffer = Vec::with_capacity(data.len() * size_of::<i64>());
+        for f in &data {
+            buffer.extend(f.to_ne_bytes());
+        }
+        let buffer_copy = buffer.clone();
+        let tensor = Tensor {
+            ty: TensorType::I64,
+            dimensions: vec![1, 6],
+            data: buffer_copy,
+        };
+        let inspectable = to_inspectable(&tensor);
+        assert!(inspectable.is_ok());
+        let winml_tensor = inspectable
+            .as_ref()
+            .unwrap()
+            .cast::<TensorInt64Bit>()
+            .unwrap();
+        let view = winml_tensor.GetAsVectorView().unwrap();
+        assert_eq!(view.into_iter().collect::<Vec<i64>>(), data);
+        // Convert back.
+        let t = to_tensor(inspectable.unwrap(), TensorKind::Int64);
+        assert!(t.as_ref().is_ok());
+        assert_eq!(t.unwrap(), tensor);
+    }
+}
diff --git a/crates/wasi-nn/src/ctx.rs b/crates/wasi-nn/src/ctx.rs
deleted file mode 100644
index 40cfb9d53d2d..000000000000
--- a/crates/wasi-nn/src/ctx.rs
+++ /dev/null
@@ -1,146 +0,0 @@
-//! Implements the host state for the `wasi-nn` API: [WasiNnCtx].
-
-use crate::backend::{self, BackendError};
-use crate::wit::types::GraphEncoding;
-use crate::{Backend, ExecutionContext, Graph, InMemoryRegistry, Registry};
-use anyhow::anyhow;
-use std::{collections::HashMap, hash::Hash, path::Path};
-use thiserror::Error;
-use wiggle::GuestError;
-
-type GraphId = u32;
-type GraphExecutionContextId = u32;
-type BackendName = String;
-type GraphDirectory = String;
-
-/// Construct an in-memory registry from the available backends and a list of
-/// `(<backend name>, <graph directory>)`. This assumes graphs can be loaded
-/// from a local directory, which is a safe assumption currently for the current
-/// model types.
-pub fn preload(
-    preload_graphs: &[(BackendName, GraphDirectory)],
-) -> anyhow::Result<(impl IntoIterator<Item = Backend>, Registry)> {
-    let mut backends = backend::list();
-    let mut registry = InMemoryRegistry::new();
-    for (kind, path) in preload_graphs {
-        let kind_ = kind.parse()?;
-        let backend = backends
-            .iter_mut()
-            .find(|b| b.encoding() == kind_)
-            .ok_or(anyhow!("unsupported backend: {}", kind))?
-            .as_dir_loadable()
-            .ok_or(anyhow!("{} does not support directory loading", kind))?;
-        registry.load(backend, Path::new(path))?;
-    }
-    Ok((backends, Registry::from(registry)))
-}
-
-/// Capture the state necessary for calling into the backend ML libraries.
-pub struct WasiNnCtx {
-    pub(crate) backends: HashMap<GraphEncoding, Backend>,
-    pub(crate) registry: Registry,
-    pub(crate) graphs: Table<GraphId, Graph>,
-    pub(crate) executions: Table<GraphExecutionContextId, ExecutionContext>,
-}
-
-impl WasiNnCtx {
-    /// Make a new context from the default state.
-    pub fn new(backends: impl IntoIterator<Item = Backend>, registry: Registry) -> Self {
-        let backends = backends.into_iter().map(|b| (b.encoding(), b)).collect();
-        Self {
-            backends,
-            registry,
-            graphs: Table::default(),
-            executions: Table::default(),
-        }
-    }
-}
-
-/// Possible errors while interacting with [WasiNnCtx].
-#[derive(Debug, Error)]
-pub enum WasiNnError {
-    #[error("backend error")]
-    BackendError(#[from] BackendError),
-    #[error("guest error")]
-    GuestError(#[from] GuestError),
-    #[error("usage error")]
-    UsageError(#[from] UsageError),
-}
-
-#[derive(Debug, Error)]
-pub enum UsageError {
-    #[error("Invalid context; has the load function been called?")]
-    InvalidContext,
-    #[error("Only OpenVINO's IR is currently supported, passed encoding: {0:?}")]
-    InvalidEncoding(GraphEncoding),
-    #[error("OpenVINO expects only two buffers (i.e. [ir, weights]), passed: {0}")]
-    InvalidNumberOfBuilders(u32),
-    #[error("Invalid graph handle; has it been loaded?")]
-    InvalidGraphHandle,
-    #[error("Invalid execution context handle; has it been initialized?")]
-    InvalidExecutionContextHandle,
-    #[error("Not enough memory to copy tensor data of size: {0}")]
-    NotEnoughMemory(u32),
-    #[error("No graph found with name: {0}")]
-    NotFound(String),
-}
-
-pub(crate) type WasiNnResult<T> = std::result::Result<T, WasiNnError>;
-
-/// Record handle entries in a table.
-pub struct Table<K, V> {
-    entries: HashMap<K, V>,
-    next_key: u32,
-}
-
-impl<K, V> Default for Table<K, V> {
-    fn default() -> Self {
-        Self {
-            entries: HashMap::new(),
-            next_key: 0,
-        }
-    }
-}
-
-impl<K, V> Table<K, V>
-where
-    K: Eq + Hash + From<u32> + Copy,
-{
-    pub fn insert(&mut self, value: V) -> K {
-        let key = self.use_next_key();
-        self.entries.insert(key, value);
-        key
-    }
-
-    pub fn get(&self, key: K) -> Option<&V> {
-        self.entries.get(&key)
-    }
-
-    pub fn get_mut(&mut self, key: K) -> Option<&mut V> {
-        self.entries.get_mut(&key)
-    }
-
-    fn use_next_key(&mut self) -> K {
-        let current = self.next_key;
-        self.next_key += 1;
-        K::from(current)
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use crate::registry::GraphRegistry;
-
-    #[test]
-    fn example() {
-        struct FakeRegistry;
-        impl GraphRegistry for FakeRegistry {
-            fn get_mut(&mut self, _: &str) -> Option<&mut Graph> {
-                None
-            }
-        }
-
-        let _ctx = WasiNnCtx::new([], Registry::from(FakeRegistry));
-    }
-}
diff --git a/crates/wasi-nn/src/lib.rs b/crates/wasi-nn/src/lib.rs
index 71d089d07489..0d3f80f6dad9 100644
--- a/crates/wasi-nn/src/lib.rs
+++ b/crates/wasi-nn/src/lib.rs
@@ -1,14 +1,34 @@
-mod ctx;
-mod registry;
-
 pub mod backend;
-pub use ctx::{preload, WasiNnCtx};
-pub use registry::{GraphRegistry, InMemoryRegistry};
+mod registry;
 pub mod wit;
 pub mod witx;
 
+use anyhow::anyhow;
+use core::fmt;
+pub use registry::{GraphRegistry, InMemoryRegistry};
+use std::path::Path;
 use std::sync::Arc;
 
+/// Construct an in-memory registry from the available backends and a list of
+/// `(<backend name>, <graph directory>)`. This assumes graphs can be loaded
+/// from a local directory, which is a safe assumption currently for the current
+/// model types.
+pub fn preload(preload_graphs: &[(String, String)]) -> anyhow::Result<(Vec<Backend>, Registry)> {
+    let mut backends = backend::list();
+    let mut registry = InMemoryRegistry::new();
+    for (kind, path) in preload_graphs {
+        let kind_ = kind.parse()?;
+        let backend = backends
+            .iter_mut()
+            .find(|b| b.encoding() == kind_)
+            .ok_or(anyhow!("unsupported backend: {}", kind))?
+            .as_dir_loadable()
+            .ok_or(anyhow!("{} does not support directory loading", kind))?;
+        registry.load(backend, Path::new(path))?;
+    }
+    Ok((backends, Registry::from(registry)))
+}
+
 /// A machine learning backend.
 pub struct Backend(Box<dyn backend::BackendInner>);
 impl std::ops::Deref for Backend {
@@ -43,6 +63,27 @@ impl std::ops::Deref for Graph {
     }
 }
 
+/// A host-side tensor.
+///
+/// Eventually, this may be defined in each backend as they gain the ability to
+/// hold tensors on various devices (TODO:
+/// https://github.com/WebAssembly/wasi-nn/pull/70).
+#[derive(Clone, PartialEq)]
+pub struct Tensor {
+    dimensions: Vec<u32>,
+    ty: wit::TensorType,
+    data: Vec<u8>,
+}
+impl fmt::Debug for Tensor {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Tensor")
+            .field("dimensions", &self.dimensions)
+            .field("ty", &self.ty)
+            .field("data (bytes)", &self.data.len())
+            .finish()
+    }
+}
+
 /// A backend-defined execution context.
 pub struct ExecutionContext(Box<dyn backend::BackendExecutionContext>);
 impl From<Box<dyn backend::BackendExecutionContext>> for ExecutionContext {
diff --git a/crates/wasi-nn/src/registry/in_memory.rs b/crates/wasi-nn/src/registry/in_memory.rs
index b008f7f43684..86f81203d646 100644
--- a/crates/wasi-nn/src/registry/in_memory.rs
+++ b/crates/wasi-nn/src/registry/in_memory.rs
@@ -2,7 +2,7 @@
 
 use super::{Graph, GraphRegistry};
 use crate::backend::BackendFromDir;
-use crate::wit::types::ExecutionTarget;
+use crate::wit::ExecutionTarget;
 use anyhow::{anyhow, bail};
 use std::{collections::HashMap, path::Path};
 
@@ -37,6 +37,9 @@ impl InMemoryRegistry {
 }
 
 impl GraphRegistry for InMemoryRegistry {
+    fn get(&self, name: &str) -> Option<&Graph> {
+        self.0.get(name)
+    }
     fn get_mut(&mut self, name: &str) -> Option<&mut Graph> {
         self.0.get_mut(name)
     }
diff --git a/crates/wasi-nn/src/registry/mod.rs b/crates/wasi-nn/src/registry/mod.rs
index 83f88e4dca0e..5f4d959132dc 100644
--- a/crates/wasi-nn/src/registry/mod.rs
+++ b/crates/wasi-nn/src/registry/mod.rs
@@ -12,5 +12,6 @@ use crate::Graph;
 pub use in_memory::InMemoryRegistry;
 
 pub trait GraphRegistry: Send + Sync {
+    fn get(&self, name: &str) -> Option<&Graph>;
     fn get_mut(&mut self, name: &str) -> Option<&mut Graph>;
 }
diff --git a/crates/wasi-nn/src/wit.rs b/crates/wasi-nn/src/wit.rs
index 95bfd1dac308..adc9ca462827 100644
--- a/crates/wasi-nn/src/wit.rs
+++ b/crates/wasi-nn/src/wit.rs
@@ -15,131 +15,376 @@
 //! [`Backend`]: crate::Backend
 //! [`types`]: crate::wit::types
 
-use crate::{ctx::UsageError, WasiNnCtx};
-use std::{error::Error, fmt, hash::Hash, str::FromStr};
+use crate::backend::Id;
+use crate::{Backend, Registry};
+use anyhow::anyhow;
+use std::collections::HashMap;
+use std::hash::Hash;
+use std::{fmt, str::FromStr};
+use wasmtime::component::{Resource, ResourceTable};
+
+/// Capture the state necessary for calling into the backend ML libraries.
+pub struct WasiNnCtx {
+    pub(crate) backends: HashMap<GraphEncoding, Backend>,
+    pub(crate) registry: Registry,
+}
+
+impl WasiNnCtx {
+    /// Make a new context from the default state.
+    pub fn new(backends: impl IntoIterator<Item = Backend>, registry: Registry) -> Self {
+        let backends = backends.into_iter().map(|b| (b.encoding(), b)).collect();
+        Self { backends, registry }
+    }
+}
+
+/// A wrapper capturing the needed internal wasi-nn state.
+///
+/// Unlike other WASI proposals (see `wasmtime-wasi`, `wasmtime-wasi-http`),
+/// this wrapper is not a `trait` but rather holds the references directly. This
+/// remove one layer of abstraction for simplicity only, and could be added back
+/// in the future if embedders need more control here.
+pub struct WasiNnView<'a> {
+    ctx: &'a mut WasiNnCtx,
+    table: &'a mut ResourceTable,
+}
+
+impl<'a> WasiNnView<'a> {
+    /// Create a new view into the wasi-nn state.
+    pub fn new(table: &'a mut ResourceTable, ctx: &'a mut WasiNnCtx) -> Self {
+        Self { ctx, table }
+    }
+}
+
+/// A wasi-nn error; this appears on the Wasm side as a component model
+/// resource.
+#[derive(Debug)]
+pub struct Error {
+    code: ErrorCode,
+    data: anyhow::Error,
+}
+
+/// Construct an [`Error`] resource and immediately return it.
+///
+/// The WIT specification currently relies on "errors as resources;" this helper
+/// macro hides some of that complexity. If [#75] is adopted ("errors as
+/// records"), this macro is no longer necessary.
+///
+/// [#75]: https://github.com/WebAssembly/wasi-nn/pull/75
+macro_rules! bail {
+    ($self:ident, $code:expr, $data:expr) => {
+        let e = Error {
+            code: $code,
+            data: $data.into(),
+        };
+        tracing::error!("failure: {e:?}");
+        let r = $self.table.push(e)?;
+        return Ok(Err(r));
+    };
+}
+
+impl From<wasmtime::component::ResourceTableError> for Error {
+    fn from(error: wasmtime::component::ResourceTableError) -> Self {
+        Self {
+            code: ErrorCode::Trap,
+            data: error.into(),
+        }
+    }
+}
+
+/// The list of error codes available to the `wasi-nn` API; this should match
+/// what is specified in WIT.
+#[derive(Debug)]
+pub enum ErrorCode {
+    /// Caller module passed an invalid argument.
+    InvalidArgument,
+    /// Invalid encoding.
+    InvalidEncoding,
+    /// The operation timed out.
+    Timeout,
+    /// Runtime error.
+    RuntimeError,
+    /// Unsupported operation.
+    UnsupportedOperation,
+    /// Graph is too large.
+    TooLarge,
+    /// Graph not found.
+    NotFound,
+    /// A runtime error that Wasmtime should trap on; this will not appear in
+    /// the WIT specification.
+    Trap,
+}
 
 /// Generate the traits and types from the `wasi-nn` WIT specification.
 mod gen_ {
-    wasmtime::component::bindgen!("ml" in "spec/wit/wasi-nn.wit");
+    wasmtime::component::bindgen!({
+        world: "ml",
+        path: "wit/wasi-nn.wit",
+        trappable_imports: true,
+        with: {
+            // Configure all WIT http resources to be defined types in this
+            // crate to use the `ResourceTable` helper methods.
+            "wasi:nn/graph/graph": crate::Graph,
+            "wasi:nn/tensor/tensor": crate::Tensor,
+            "wasi:nn/inference/graph-execution-context": crate::ExecutionContext,
+            "wasi:nn/errors/error": super::Error,
+        },
+        trappable_error_type: {
+            "wasi:nn/errors/error" => super::Error,
+        },
+    });
 }
-use gen_::wasi::nn as gen; // Shortcut to the module containing the types we need.
+use gen_::wasi::nn::{self as gen}; // Shortcut to the module containing the types we need.
 
 // Export the `types` used in this crate as well as `ML::add_to_linker`.
 pub mod types {
     use super::gen;
-    pub use gen::graph::{ExecutionTarget, Graph, GraphEncoding};
+    pub use gen::errors::Error;
+    pub use gen::graph::{ExecutionTarget, Graph, GraphBuilder, GraphEncoding};
     pub use gen::inference::GraphExecutionContext;
     pub use gen::tensor::{Tensor, TensorType};
 }
+pub use gen::graph::{ExecutionTarget, Graph, GraphBuilder, GraphEncoding};
+pub use gen::inference::GraphExecutionContext;
+pub use gen::tensor::{Tensor, TensorData, TensorDimensions, TensorType};
 pub use gen_::Ml as ML;
 
-impl gen::graph::Host for WasiNnCtx {
-    /// Load an opaque sequence of bytes to use for inference.
+/// Add the WIT-based version of the `wasi-nn` API to a
+/// [`wasmtime::component::Linker`].
+pub fn add_to_linker<T>(
+    l: &mut wasmtime::component::Linker<T>,
+    f: impl Fn(&mut T) -> WasiNnView<'_> + Send + Sync + Copy + 'static,
+) -> anyhow::Result<()> {
+    gen::graph::add_to_linker_get_host(l, f)?;
+    gen::tensor::add_to_linker_get_host(l, f)?;
+    gen::inference::add_to_linker_get_host(l, f)?;
+    gen::errors::add_to_linker_get_host(l, f)?;
+    Ok(())
+}
+
+impl gen::graph::Host for WasiNnView<'_> {
     fn load(
         &mut self,
-        builders: Vec<gen::graph::GraphBuilder>,
-        encoding: gen::graph::GraphEncoding,
-        target: gen::graph::ExecutionTarget,
-    ) -> wasmtime::Result<Result<gen::graph::Graph, gen::errors::Error>> {
-        let graph = if let Some(backend) = self.backends.get_mut(&encoding) {
+        builders: Vec<GraphBuilder>,
+        encoding: GraphEncoding,
+        target: ExecutionTarget,
+    ) -> wasmtime::Result<Result<Resource<Graph>, Resource<Error>>> {
+        tracing::debug!("load {encoding:?} {target:?}");
+        if let Some(backend) = self.ctx.backends.get_mut(&encoding) {
             let slices = builders.iter().map(|s| s.as_slice()).collect::<Vec<_>>();
-            backend.load(&slices, target.into())?
+            match backend.load(&slices, target.into()) {
+                Ok(graph) => {
+                    let graph = self.table.push(graph)?;
+                    Ok(Ok(graph))
+                }
+                Err(error) => {
+                    bail!(self, ErrorCode::RuntimeError, error);
+                }
+            }
         } else {
-            return Err(UsageError::InvalidEncoding(encoding.into()).into());
-        };
-        let graph_id = self.graphs.insert(graph);
-        Ok(Ok(graph_id))
+            bail!(
+                self,
+                ErrorCode::InvalidEncoding,
+                anyhow!("unable to find a backend for this encoding")
+            );
+        }
     }
 
     fn load_by_name(
         &mut self,
         name: String,
-    ) -> wasmtime::Result<Result<gen::graph::Graph, gen::errors::Error>> {
-        if let Some(graph) = self.registry.get_mut(&name) {
-            let graph_id = self.graphs.insert(graph.clone().into());
-            Ok(Ok(graph_id))
+    ) -> wasmtime::Result<Result<Resource<Graph>, Resource<Error>>> {
+        use core::result::Result::*;
+        tracing::debug!("load by name {name:?}");
+        let registry = &self.ctx.registry;
+        if let Some(graph) = registry.get(&name) {
+            let graph = graph.clone();
+            let graph = self.table.push(graph)?;
+            Ok(Ok(graph))
         } else {
-            return Err(UsageError::NotFound(name.to_string()).into());
+            bail!(
+                self,
+                ErrorCode::NotFound,
+                anyhow!("failed to find graph with name: {name}")
+            );
         }
     }
 }
 
-impl gen::inference::Host for WasiNnCtx {
-    /// Create an execution instance of a loaded graph.
-    ///
-    /// TODO: remove completely?
+impl gen::graph::HostGraph for WasiNnView<'_> {
     fn init_execution_context(
         &mut self,
-        graph_id: gen::graph::Graph,
-    ) -> wasmtime::Result<Result<gen::inference::GraphExecutionContext, gen::errors::Error>> {
-        let exec_context = if let Some(graph) = self.graphs.get(graph_id) {
-            graph.init_execution_context()?
-        } else {
-            return Err(UsageError::InvalidGraphHandle.into());
-        };
+        graph: Resource<Graph>,
+    ) -> wasmtime::Result<Result<Resource<GraphExecutionContext>, Resource<Error>>> {
+        use core::result::Result::*;
+        tracing::debug!("initialize execution context");
+        let graph = self.table.get(&graph)?;
+        match graph.init_execution_context() {
+            Ok(exec_context) => {
+                let exec_context = self.table.push(exec_context)?;
+                Ok(Ok(exec_context))
+            }
+            Err(error) => {
+                bail!(self, ErrorCode::RuntimeError, error);
+            }
+        }
+    }
 
-        let exec_context_id = self.executions.insert(exec_context);
-        Ok(Ok(exec_context_id))
+    fn drop(&mut self, graph: Resource<Graph>) -> wasmtime::Result<()> {
+        self.table.delete(graph)?;
+        Ok(())
     }
+}
 
-    /// Define the inputs to use for inference.
+impl gen::inference::HostGraphExecutionContext for WasiNnView<'_> {
     fn set_input(
         &mut self,
-        exec_context_id: gen::inference::GraphExecutionContext,
-        index: u32,
-        tensor: gen::tensor::Tensor,
-    ) -> wasmtime::Result<Result<(), gen::errors::Error>> {
-        if let Some(exec_context) = self.executions.get_mut(exec_context_id) {
-            exec_context.set_input(index, &tensor)?;
-            Ok(Ok(()))
+        exec_context: Resource<GraphExecutionContext>,
+        name: String,
+        tensor: Resource<Tensor>,
+    ) -> wasmtime::Result<Result<(), Resource<Error>>> {
+        let tensor = self.table.get(&tensor)?;
+        tracing::debug!("set input {name:?}: {tensor:?}");
+        let tensor = tensor.clone(); // TODO: avoid copying the tensor
+        let exec_context = self.table.get_mut(&exec_context)?;
+        if let Err(error) = exec_context.set_input(Id::Name(name), &tensor) {
+            bail!(self, ErrorCode::InvalidArgument, error);
         } else {
-            Err(UsageError::InvalidGraphHandle.into())
+            Ok(Ok(()))
         }
     }
 
-    /// Compute the inference on the given inputs.
-    ///
-    /// TODO: refactor to compute(list<tensor>) -> result<list<tensor>, error>
     fn compute(
         &mut self,
-        exec_context_id: gen::inference::GraphExecutionContext,
-    ) -> wasmtime::Result<Result<(), gen::errors::Error>> {
-        if let Some(exec_context) = self.executions.get_mut(exec_context_id) {
-            exec_context.compute()?;
-            Ok(Ok(()))
-        } else {
-            Err(UsageError::InvalidExecutionContextHandle.into())
+        exec_context: Resource<GraphExecutionContext>,
+    ) -> wasmtime::Result<Result<(), Resource<Error>>> {
+        let exec_context = &mut self.table.get_mut(&exec_context)?;
+        tracing::debug!("compute");
+        match exec_context.compute() {
+            Ok(()) => Ok(Ok(())),
+            Err(error) => {
+                bail!(self, ErrorCode::RuntimeError, error);
+            }
         }
     }
 
-    /// Extract the outputs after inference.
     fn get_output(
         &mut self,
-        exec_context_id: gen::inference::GraphExecutionContext,
-        index: u32,
-    ) -> wasmtime::Result<Result<gen::tensor::TensorData, gen::errors::Error>> {
-        if let Some(exec_context) = self.executions.get_mut(exec_context_id) {
-            // Read the output bytes. TODO: this involves a hard-coded upper
-            // limit on the tensor size that is necessary because there is no
-            // way to introspect the graph outputs
-            // (https://github.com/WebAssembly/wasi-nn/issues/37).
-            let mut destination = vec![0; 1024 * 1024];
-            let bytes_read = exec_context.get_output(index, &mut destination)?;
-            destination.truncate(bytes_read as usize);
-            Ok(Ok(destination))
-        } else {
-            Err(UsageError::InvalidGraphHandle.into())
+        exec_context: Resource<GraphExecutionContext>,
+        name: String,
+    ) -> wasmtime::Result<Result<Resource<Tensor>, Resource<Error>>> {
+        let exec_context = self.table.get_mut(&exec_context)?;
+        tracing::debug!("get output {name:?}");
+        match exec_context.get_output(Id::Name(name)) {
+            Ok(tensor) => {
+                let tensor = self.table.push(tensor)?;
+                Ok(Ok(tensor))
+            }
+            Err(error) => {
+                bail!(self, ErrorCode::RuntimeError, error);
+            }
         }
     }
+
+    fn drop(&mut self, exec_context: Resource<GraphExecutionContext>) -> wasmtime::Result<()> {
+        self.table.delete(exec_context)?;
+        Ok(())
+    }
 }
 
-impl gen::errors::Host for WasiNnCtx {}
+impl gen::tensor::HostTensor for WasiNnView<'_> {
+    fn new(
+        &mut self,
+        dimensions: TensorDimensions,
+        ty: TensorType,
+        data: TensorData,
+    ) -> wasmtime::Result<Resource<Tensor>> {
+        let tensor = Tensor {
+            dimensions,
+            ty,
+            data,
+        };
+        let tensor = self.table.push(tensor)?;
+        Ok(tensor)
+    }
+
+    fn dimensions(&mut self, tensor: Resource<Tensor>) -> wasmtime::Result<TensorDimensions> {
+        let tensor = self.table.get(&tensor)?;
+        Ok(tensor.dimensions.clone())
+    }
 
-impl gen::tensor::Host for WasiNnCtx {}
+    fn ty(&mut self, tensor: Resource<Tensor>) -> wasmtime::Result<TensorType> {
+        let tensor = self.table.get(&tensor)?;
+        Ok(tensor.ty)
+    }
+
+    fn data(&mut self, tensor: Resource<Tensor>) -> wasmtime::Result<TensorData> {
+        let tensor = self.table.get(&tensor)?;
+        Ok(tensor.data.clone())
+    }
+
+    fn drop(&mut self, tensor: Resource<Tensor>) -> wasmtime::Result<()> {
+        self.table.delete(tensor)?;
+        Ok(())
+    }
+}
+
+impl gen::errors::HostError for WasiNnView<'_> {
+    fn code(&mut self, error: Resource<Error>) -> wasmtime::Result<gen::errors::ErrorCode> {
+        let error = self.table.get(&error)?;
+        match error.code {
+            ErrorCode::InvalidArgument => Ok(gen::errors::ErrorCode::InvalidArgument),
+            ErrorCode::InvalidEncoding => Ok(gen::errors::ErrorCode::InvalidEncoding),
+            ErrorCode::Timeout => Ok(gen::errors::ErrorCode::Timeout),
+            ErrorCode::RuntimeError => Ok(gen::errors::ErrorCode::RuntimeError),
+            ErrorCode::UnsupportedOperation => Ok(gen::errors::ErrorCode::UnsupportedOperation),
+            ErrorCode::TooLarge => Ok(gen::errors::ErrorCode::TooLarge),
+            ErrorCode::NotFound => Ok(gen::errors::ErrorCode::NotFound),
+            ErrorCode::Trap => Err(anyhow!(error.data.to_string())),
+        }
+    }
+
+    fn data(&mut self, error: Resource<Error>) -> wasmtime::Result<String> {
+        let error = self.table.get(&error)?;
+        Ok(error.data.to_string())
+    }
+
+    fn drop(&mut self, error: Resource<Error>) -> wasmtime::Result<()> {
+        self.table.delete(error)?;
+        Ok(())
+    }
+}
+
+impl gen::errors::Host for WasiNnView<'_> {
+    fn convert_error(&mut self, err: Error) -> wasmtime::Result<Error> {
+        if matches!(err.code, ErrorCode::Trap) {
+            Err(err.data)
+        } else {
+            Ok(err)
+        }
+    }
+}
+
+impl gen::tensor::Host for WasiNnView<'_> {}
+impl gen::inference::Host for WasiNnView<'_> {}
 
 impl Hash for gen::graph::GraphEncoding {
     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        core::mem::discriminant(self).hash(state);
+        self.to_string().hash(state)
+    }
+}
+
+impl fmt::Display for gen::graph::GraphEncoding {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use gen::graph::GraphEncoding::*;
+        match self {
+            Openvino => write!(f, "openvino"),
+            Onnx => write!(f, "onnx"),
+            Pytorch => write!(f, "pytorch"),
+            Tensorflow => write!(f, "tensorflow"),
+            Tensorflowlite => write!(f, "tensorflowlite"),
+            Autodetect => write!(f, "autodetect"),
+            Ggml => write!(f, "ggml"),
+        }
     }
 }
 
@@ -164,4 +409,4 @@ impl fmt::Display for GraphEncodingParseError {
         write!(f, "unknown graph encoding: {}", self.0)
     }
 }
-impl Error for GraphEncodingParseError {}
+impl std::error::Error for GraphEncodingParseError {}
diff --git a/crates/wasi-nn/src/witx.rs b/crates/wasi-nn/src/witx.rs
index e13e2678daaa..f4f2eab90647 100644
--- a/crates/wasi-nn/src/witx.rs
+++ b/crates/wasi-nn/src/witx.rs
@@ -13,11 +13,83 @@
 //!
 //! [`types`]: crate::wit::types
 
-use crate::ctx::{UsageError, WasiNnCtx, WasiNnError, WasiNnResult as Result};
-use wiggle::GuestPtr;
+use crate::backend::BackendError;
+use crate::backend::Id;
+use crate::wit::GraphEncoding;
+use crate::{Backend, ExecutionContext, Graph, Registry};
+use std::collections::HashMap;
+use std::hash::Hash;
+use thiserror::Error;
+use wiggle::{GuestError, GuestMemory, GuestPtr};
 
 pub use gen::wasi_ephemeral_nn::add_to_linker;
 
+pub(crate) type WasiNnResult<T> = std::result::Result<T, WasiNnError>;
+type Result<T> = WasiNnResult<T>;
+type GraphId = u32;
+type GraphExecutionContextId = u32;
+
+/// Capture the state necessary for calling into the backend ML libraries.
+pub struct WasiNnCtx {
+    pub(crate) backends: HashMap<GraphEncoding, Backend>,
+    pub(crate) registry: Registry,
+    pub(crate) graphs: Table<GraphId, Graph>,
+    pub(crate) executions: Table<GraphExecutionContextId, ExecutionContext>,
+}
+
+impl WasiNnCtx {
+    /// Make a new context from the default state.
+    pub fn new(backends: impl IntoIterator<Item = Backend>, registry: Registry) -> Self {
+        let backends = backends.into_iter().map(|b| (b.encoding(), b)).collect();
+        Self {
+            backends,
+            registry,
+            graphs: Table::default(),
+            executions: Table::default(),
+        }
+    }
+}
+
+/// Record handle entries in a table.
+pub struct Table<K, V> {
+    entries: HashMap<K, V>,
+    next_key: u32,
+}
+
+impl<K, V> Default for Table<K, V> {
+    fn default() -> Self {
+        Self {
+            entries: HashMap::new(),
+            next_key: 0,
+        }
+    }
+}
+
+impl<K, V> Table<K, V>
+where
+    K: Eq + Hash + From<u32> + Copy,
+{
+    pub fn insert(&mut self, value: V) -> K {
+        let key = self.use_next_key();
+        self.entries.insert(key, value);
+        key
+    }
+
+    pub fn get(&self, key: K) -> Option<&V> {
+        self.entries.get(&key)
+    }
+
+    pub fn get_mut(&mut self, key: K) -> Option<&mut V> {
+        self.entries.get_mut(&key)
+    }
+
+    fn use_next_key(&mut self) -> K {
+        let current = self.next_key;
+        self.next_key += 1;
+        K::from(current)
+    }
+}
+
 /// Generate the traits and types from the `wasi-nn` WITX specification.
 mod gen {
     use super::*;
@@ -35,26 +107,28 @@ mod gen {
     }
 
     /// Convert the host errors to their WITX-generated type.
-    impl<'a> types::UserErrorConversion for WasiNnCtx {
+    impl types::UserErrorConversion for WasiNnCtx {
         fn nn_errno_from_wasi_nn_error(
             &mut self,
             e: WasiNnError,
         ) -> anyhow::Result<types::NnErrno> {
             tracing::debug!("host error: {:?}", e);
             match e {
-                WasiNnError::BackendError(_) => unimplemented!(),
-                WasiNnError::GuestError(_) => unimplemented!(),
-                WasiNnError::UsageError(_) => unimplemented!(),
+                WasiNnError::BackendError(_) => Ok(types::NnErrno::RuntimeError),
+                WasiNnError::GuestError(_) => unimplemented!("guest error conversion"),
+                WasiNnError::UsageError(_) => Ok(types::NnErrno::UnsupportedOperation),
+                WasiNnError::NotEnoughMemory(_) => Ok(types::NnErrno::TooLarge),
             }
         }
     }
 }
 
 /// Wire up the WITX-generated trait to the `wasi-nn` host state.
-impl<'a> gen::wasi_ephemeral_nn::WasiEphemeralNn for WasiNnCtx {
-    fn load<'b>(
+impl gen::wasi_ephemeral_nn::WasiEphemeralNn for WasiNnCtx {
+    fn load(
         &mut self,
-        builders: &gen::types::GraphBuilderArray<'_>,
+        memory: &mut GuestMemory<'_>,
+        builders: gen::types::GraphBuilderArray,
         encoding: gen::types::GraphEncoding,
         target: gen::types::ExecutionTarget,
     ) -> Result<gen::types::Graph> {
@@ -63,10 +137,11 @@ impl<'a> gen::wasi_ephemeral_nn::WasiEphemeralNn for WasiNnCtx {
             // $graph_builder_array) as slices for a backend to operate on.
             let mut slices = vec![];
             for builder in builders.iter() {
-                let slice = builder?
-                    .read()?
-                    .as_slice()?
-                    .expect("cannot use with shared memories; see https://github.com/bytecodealliance/wasmtime/issues/5235 (TODO)");
+                let builder = memory.read(builder?)?;
+                let slice = memory.as_slice(builder)?.expect(
+                    "cannot use with shared memories; \
+                     see https://github.com/bytecodealliance/wasmtime/issues/5235 (TODO)",
+                );
                 slices.push(slice);
             }
             let slice_refs = slices.iter().map(|s| s.as_ref()).collect::<Vec<_>>();
@@ -78,8 +153,12 @@ impl<'a> gen::wasi_ephemeral_nn::WasiEphemeralNn for WasiNnCtx {
         Ok(graph_id.into())
     }
 
-    fn load_by_name<'b>(&mut self, name: &wiggle::GuestPtr<'b, str>) -> Result<gen::types::Graph> {
-        let name = name.as_str()?.unwrap();
+    fn load_by_name(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        name: wiggle::GuestPtr<str>,
+    ) -> Result<gen::types::Graph> {
+        let name = memory.as_str(name)?.unwrap();
         if let Some(graph) = self.registry.get_mut(&name) {
             let graph_id = self.graphs.insert(graph.clone().into());
             Ok(graph_id.into())
@@ -90,6 +169,7 @@ impl<'a> gen::wasi_ephemeral_nn::WasiEphemeralNn for WasiNnCtx {
 
     fn init_execution_context(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         graph_id: gen::types::Graph,
     ) -> Result<gen::types::GraphExecutionContext> {
         let exec_context = if let Some(graph) = self.graphs.get_mut(graph_id.into()) {
@@ -102,25 +182,30 @@ impl<'a> gen::wasi_ephemeral_nn::WasiEphemeralNn for WasiNnCtx {
         Ok(exec_context_id.into())
     }
 
-    fn set_input<'b>(
+    fn set_input(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         exec_context_id: gen::types::GraphExecutionContext,
         index: u32,
-        tensor: &gen::types::Tensor<'b>,
+        tensor: &gen::types::Tensor,
     ) -> Result<()> {
         if let Some(exec_context) = self.executions.get_mut(exec_context_id.into()) {
             let tensor = crate::wit::types::Tensor {
-                dimensions: tensor.dimensions.to_vec()?,
-                tensor_type: tensor.type_.into(),
-                data: tensor.data.to_vec()?,
+                dimensions: memory.to_vec(tensor.dimensions)?,
+                ty: tensor.type_.into(),
+                data: memory.to_vec(tensor.data)?,
             };
-            Ok(exec_context.set_input(index, &tensor)?)
+            Ok(exec_context.set_input(Id::Index(index), &tensor)?)
         } else {
             Err(UsageError::InvalidGraphHandle.into())
         }
     }
 
-    fn compute(&mut self, exec_context_id: gen::types::GraphExecutionContext) -> Result<()> {
+    fn compute(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        exec_context_id: gen::types::GraphExecutionContext,
+    ) -> Result<()> {
         if let Some(exec_context) = self.executions.get_mut(exec_context_id.into()) {
             Ok(exec_context.compute()?)
         } else {
@@ -128,19 +213,28 @@ impl<'a> gen::wasi_ephemeral_nn::WasiEphemeralNn for WasiNnCtx {
         }
     }
 
-    fn get_output<'b>(
+    fn get_output(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         exec_context_id: gen::types::GraphExecutionContext,
         index: u32,
-        out_buffer: &GuestPtr<'_, u8>,
+        out_buffer: GuestPtr<u8>,
         out_buffer_max_size: u32,
     ) -> Result<u32> {
         if let Some(exec_context) = self.executions.get_mut(exec_context_id.into()) {
-            let mut destination = out_buffer
-                .as_array(out_buffer_max_size)
-                .as_slice_mut()?
-                .expect("cannot use with shared memories; see https://github.com/bytecodealliance/wasmtime/issues/5235 (TODO)");
-            Ok(exec_context.get_output(index, &mut destination)?)
+            let tensor = exec_context.get_output(Id::Index(index))?;
+            let destination = memory
+                .as_slice_mut(out_buffer.as_array(out_buffer_max_size))?
+                .expect(
+                    "cannot use with shared memories; \
+                     see https://github.com/bytecodealliance/wasmtime/issues/5235 (TODO)",
+                );
+            if tensor.data.len() > destination.len() {
+                Err(WasiNnError::NotEnoughMemory(tensor.data.len()))
+            } else {
+                destination[..tensor.data.len()].copy_from_slice(&tensor.data);
+                Ok(tensor.data.len() as u32)
+            }
         } else {
             Err(UsageError::InvalidGraphHandle.into())
         }
@@ -179,6 +273,33 @@ impl From<gen::types::TensorType> for crate::wit::types::TensorType {
             gen::types::TensorType::F32 => crate::wit::types::TensorType::Fp32,
             gen::types::TensorType::U8 => crate::wit::types::TensorType::U8,
             gen::types::TensorType::I32 => crate::wit::types::TensorType::I32,
+            gen::types::TensorType::I64 => crate::wit::types::TensorType::I64,
+            gen::types::TensorType::F64 => crate::wit::types::TensorType::Fp64,
         }
     }
 }
+
+/// Possible errors while interacting with [WasiNnCtx].
+#[derive(Debug, Error)]
+pub enum WasiNnError {
+    #[error("backend error")]
+    BackendError(#[from] BackendError),
+    #[error("guest error")]
+    GuestError(#[from] GuestError),
+    #[error("usage error")]
+    UsageError(#[from] UsageError),
+    #[error("not enough memory: requested {0} bytes")]
+    NotEnoughMemory(usize),
+}
+
+#[derive(Debug, Error)]
+pub enum UsageError {
+    #[error("Only OpenVINO's IR is currently supported, passed encoding: {0:?}")]
+    InvalidEncoding(GraphEncoding),
+    #[error("Invalid graph handle; has it been loaded?")]
+    InvalidGraphHandle,
+    #[error("Invalid execution context handle; has it been initialized?")]
+    InvalidExecutionContextHandle,
+    #[error("No graph found with name: {0}")]
+    NotFound(String),
+}
diff --git a/crates/wasi-nn/tests/check/mod.rs b/crates/wasi-nn/tests/check/mod.rs
new file mode 100644
index 000000000000..9f59d38130af
--- /dev/null
+++ b/crates/wasi-nn/tests/check/mod.rs
@@ -0,0 +1,47 @@
+//! Check that the environment is set up correctly for running tests.
+//!
+//! This module checks:
+//! - that various backends can be located on the system (see sub-modules)
+//! - that certain ML model artifacts can be downloaded and cached.
+
+#[allow(unused_imports)]
+use anyhow::{anyhow, Context, Result};
+use std::{
+    env,
+    path::{Path, PathBuf},
+    process::Command,
+    sync::Mutex,
+};
+
+#[cfg(any(feature = "onnx", feature = "winml"))]
+pub mod onnx;
+#[cfg(feature = "openvino")]
+pub mod openvino;
+#[cfg(all(feature = "winml", target_os = "windows"))]
+pub mod winml;
+
+/// Protect `are_artifacts_available` from concurrent access; when running tests
+/// in parallel, we want to avoid two threads attempting to create the same
+/// directory or download the same file.
+pub static DOWNLOAD_LOCK: Mutex<()> = Mutex::new(());
+
+/// Return the directory in which the test artifacts are stored.
+pub fn artifacts_dir() -> PathBuf {
+    PathBuf::from(env!("OUT_DIR")).join("fixtures")
+}
+
+/// Retrieve the bytes at the `from` URL and place them in the `to` file.
+fn download(from: &str, to: &Path) -> anyhow::Result<()> {
+    let mut curl = Command::new("curl");
+    curl.arg("--location").arg(from).arg("--output").arg(to);
+    println!("> downloading: {:?}", &curl);
+    let result = curl.output().unwrap();
+    if !result.status.success() {
+        panic!(
+            "curl failed: {}\n{}",
+            result.status,
+            String::from_utf8_lossy(&result.stderr)
+        );
+    }
+    Ok(())
+}
diff --git a/crates/wasi-nn/tests/check/onnx.rs b/crates/wasi-nn/tests/check/onnx.rs
new file mode 100644
index 000000000000..b5a451e0373f
--- /dev/null
+++ b/crates/wasi-nn/tests/check/onnx.rs
@@ -0,0 +1,38 @@
+#![allow(unused)]
+
+use super::{artifacts_dir, download, DOWNLOAD_LOCK};
+use anyhow::{Context, Result};
+use std::sync::Mutex;
+use std::{env, fs};
+
+/// Return `Ok` if we find the cached MobileNet test artifacts; this will
+/// download the artifacts if necessary.
+pub fn are_artifacts_available() -> Result<()> {
+    let _exclusively_retrieve_artifacts = DOWNLOAD_LOCK.lock().unwrap();
+
+    const ONNX_BASE_URL: &str =
+        "https://github.com/onnx/models/raw/bec48b6a70e5e9042c0badbaafefe4454e072d08/validated/vision/classification/mobilenet/model/mobilenetv2-10.onnx?download=";
+
+    let artifacts_dir = artifacts_dir();
+    if !artifacts_dir.is_dir() {
+        fs::create_dir(&artifacts_dir)?;
+    }
+
+    for (from, to) in [(ONNX_BASE_URL.to_string(), "model.onnx")] {
+        let local_path = artifacts_dir.join(to);
+        if !local_path.is_file() {
+            download(&from, &local_path).with_context(|| "unable to retrieve test artifact")?;
+        } else {
+            println!("> using cached artifact: {}", local_path.display())
+        }
+    }
+
+    // Copy image from source tree to artifact directory.
+    let image_path = env::current_dir()?
+        .join("tests")
+        .join("fixtures")
+        .join("000000062808.rgb");
+    let dest_path = artifacts_dir.join("000000062808.rgb");
+    fs::copy(&image_path, &dest_path)?;
+    Ok(())
+}
diff --git a/crates/wasi-nn/tests/check/openvino.rs b/crates/wasi-nn/tests/check/openvino.rs
new file mode 100644
index 000000000000..4bf05ba0997d
--- /dev/null
+++ b/crates/wasi-nn/tests/check/openvino.rs
@@ -0,0 +1,46 @@
+use super::{artifacts_dir, download, DOWNLOAD_LOCK};
+use anyhow::{bail, Context, Result};
+use std::fs;
+
+/// Return `Ok` if we find a working OpenVINO installation.
+pub fn is_installed() -> Result<()> {
+    match std::panic::catch_unwind(|| {
+        println!(
+            "> found openvino version: {}",
+            openvino::version().build_number
+        )
+    }) {
+        Ok(_) => Ok(()),
+        Err(e) => bail!(
+            "unable to find an OpenVINO installation: {:?}",
+            e.downcast_ref::<String>()
+        ),
+    }
+}
+
+/// Return `Ok` if we find the cached MobileNet test artifacts; this will
+/// download the artifacts if necessary.
+pub fn are_artifacts_available() -> Result<()> {
+    let _exclusively_retrieve_artifacts = DOWNLOAD_LOCK.lock().unwrap();
+    const BASE_URL: &str =
+        "https://github.com/intel/openvino-rs/raw/main/crates/openvino/tests/fixtures/mobilenet";
+    let artifacts_dir = artifacts_dir();
+    if !artifacts_dir.is_dir() {
+        fs::create_dir(&artifacts_dir)?;
+    }
+    for (from, to) in [
+        ("mobilenet.bin", "model.bin"),
+        ("mobilenet.xml", "model.xml"),
+        ("tensor-1x224x224x3-f32.bgr", "tensor.bgr"),
+    ] {
+        let remote_url = [BASE_URL, from].join("/");
+        let local_path = artifacts_dir.join(to);
+        if !local_path.is_file() {
+            download(&remote_url, &local_path)
+                .with_context(|| "unable to retrieve test artifact")?;
+        } else {
+            println!("> using cached artifact: {}", local_path.display())
+        }
+    }
+    Ok(())
+}
diff --git a/crates/wasi-nn/tests/check/winml.rs b/crates/wasi-nn/tests/check/winml.rs
new file mode 100644
index 000000000000..fc45337a6025
--- /dev/null
+++ b/crates/wasi-nn/tests/check/winml.rs
@@ -0,0 +1,15 @@
+use anyhow::{anyhow, Result};
+use windows::AI::MachineLearning::{LearningModelDevice, LearningModelDeviceKind};
+
+/// Return `Ok` if we can use WinML.
+pub fn is_available() -> Result<()> {
+    match std::panic::catch_unwind(|| {
+        println!(
+            "> WinML learning device is available: {:?}",
+            LearningModelDevice::Create(LearningModelDeviceKind::Default)
+        )
+    }) {
+        Ok(_) => Ok(()),
+        Err(e) => Err(anyhow!("WinML learning device is not available: {:?}", e)),
+    }
+}
diff --git a/crates/wasi-nn/tests/exec/mod.rs b/crates/wasi-nn/tests/exec/mod.rs
new file mode 100644
index 000000000000..5fd25cbd3cbf
--- /dev/null
+++ b/crates/wasi-nn/tests/exec/mod.rs
@@ -0,0 +1,6 @@
+//! Provide a Wasmtime embedding for executing wasi-nn test programs.
+
+pub mod wit;
+pub mod witx;
+
+pub const PREOPENED_DIR_NAME: &str = "fixture";
diff --git a/crates/wasi-nn/tests/exec/wit.rs b/crates/wasi-nn/tests/exec/wit.rs
new file mode 100644
index 000000000000..5f2d546d667d
--- /dev/null
+++ b/crates/wasi-nn/tests/exec/wit.rs
@@ -0,0 +1,73 @@
+use super::PREOPENED_DIR_NAME;
+use crate::check::artifacts_dir;
+use anyhow::{anyhow, Result};
+use std::path::Path;
+use wasmtime::component::{Component, Linker, ResourceTable};
+use wasmtime::{Config, Engine, Store};
+use wasmtime_wasi::bindings::sync::Command;
+use wasmtime_wasi::{DirPerms, FilePerms, WasiCtx, WasiCtxBuilder};
+use wasmtime_wasi_nn::wit::WasiNnView;
+use wasmtime_wasi_nn::{wit::WasiNnCtx, Backend, InMemoryRegistry};
+
+/// Run a wasi-nn test program. This is modeled after
+/// `crates/wasi/tests/all/main.rs` but still uses the older preview1 API for
+/// file reads.
+pub fn run(path: &str, backend: Backend, preload_model: bool) -> Result<()> {
+    let path = Path::new(path);
+    let engine = Engine::new(&Config::new())?;
+    let mut linker = Linker::new(&engine);
+    wasmtime_wasi_nn::wit::add_to_linker(&mut linker, |c: &mut Ctx| {
+        WasiNnView::new(&mut c.table, &mut c.wasi_nn)
+    })?;
+    wasmtime_wasi::add_to_linker_sync(&mut linker)?;
+    let module = Component::from_file(&engine, path)?;
+    let mut store = Store::new(&engine, Ctx::new(&artifacts_dir(), preload_model, backend)?);
+    let command = Command::instantiate(&mut store, &module, &linker)?;
+    let result = command.wasi_cli_run().call_run(&mut store)?;
+    result.map_err(|_| anyhow!("failed to run command"))
+}
+
+/// The host state for running wasi-nn component tests.
+struct Ctx {
+    wasi: WasiCtx,
+    wasi_nn: WasiNnCtx,
+    table: ResourceTable,
+}
+
+impl Ctx {
+    fn new(preopen_dir: &Path, preload_model: bool, mut backend: Backend) -> Result<Self> {
+        let mut builder = WasiCtxBuilder::new();
+        builder.inherit_stdio().preopened_dir(
+            preopen_dir,
+            PREOPENED_DIR_NAME,
+            DirPerms::READ,
+            FilePerms::READ,
+        )?;
+        let wasi = builder.build();
+
+        let mut registry = InMemoryRegistry::new();
+        let mobilenet_dir = artifacts_dir();
+        if preload_model {
+            registry.load((backend).as_dir_loadable().unwrap(), &mobilenet_dir)?;
+        }
+        let wasi_nn = WasiNnCtx::new([backend.into()], registry.into());
+
+        let table = ResourceTable::new();
+
+        Ok(Self {
+            wasi,
+            wasi_nn,
+            table,
+        })
+    }
+}
+
+impl wasmtime_wasi::WasiView for Ctx {
+    fn ctx(&mut self) -> &mut WasiCtx {
+        &mut self.wasi
+    }
+
+    fn table(&mut self) -> &mut ResourceTable {
+        &mut self.table
+    }
+}
diff --git a/crates/wasi-nn/tests/exec/witx.rs b/crates/wasi-nn/tests/exec/witx.rs
new file mode 100644
index 000000000000..21feea1dd641
--- /dev/null
+++ b/crates/wasi-nn/tests/exec/witx.rs
@@ -0,0 +1,52 @@
+use super::PREOPENED_DIR_NAME;
+use crate::check::artifacts_dir;
+use anyhow::Result;
+use std::path::Path;
+use wasmtime::{Config, Engine, Linker, Module, Store};
+use wasmtime_wasi::{preview1::WasiP1Ctx, DirPerms, FilePerms, WasiCtxBuilder};
+use wasmtime_wasi_nn::{witx::WasiNnCtx, Backend, InMemoryRegistry};
+
+/// Run a wasi-nn test program. This is modeled after
+/// `crates/wasi/tests/all/main.rs` but still uses the older preview1 API
+/// for file reads.
+pub fn run(path: &str, backend: Backend, preload_model: bool) -> Result<()> {
+    let path = Path::new(path);
+    let engine = Engine::new(&Config::new())?;
+    let mut linker = Linker::new(&engine);
+    wasmtime_wasi_nn::witx::add_to_linker(&mut linker, |s: &mut Ctx| &mut s.wasi_nn)?;
+    wasmtime_wasi::preview1::add_to_linker_sync(&mut linker, |s: &mut Ctx| &mut s.wasi)?;
+    let module = Module::from_file(&engine, path)?;
+    let mut store = Store::new(&engine, Ctx::new(&artifacts_dir(), preload_model, backend)?);
+    let instance = linker.instantiate(&mut store, &module)?;
+    let start = instance.get_typed_func::<(), ()>(&mut store, "_start")?;
+    start.call(&mut store, ())?;
+    Ok(())
+}
+
+/// The host state for running wasi-nn tests.
+struct Ctx {
+    wasi: WasiP1Ctx,
+    wasi_nn: WasiNnCtx,
+}
+
+impl Ctx {
+    fn new(preopen_dir: &Path, preload_model: bool, mut backend: Backend) -> Result<Self> {
+        let mut builder = WasiCtxBuilder::new();
+        builder.inherit_stdio().preopened_dir(
+            preopen_dir,
+            PREOPENED_DIR_NAME,
+            DirPerms::READ,
+            FilePerms::READ,
+        )?;
+        let wasi = builder.build_p1();
+
+        let mut registry = InMemoryRegistry::new();
+        let mobilenet_dir = artifacts_dir();
+        if preload_model {
+            registry.load((backend).as_dir_loadable().unwrap(), &mobilenet_dir)?;
+        }
+        let wasi_nn = WasiNnCtx::new([backend.into()], registry.into());
+
+        Ok(Self { wasi, wasi_nn })
+    }
+}
diff --git a/crates/wasi-nn/tests/fixtures/000000062808.rgb b/crates/wasi-nn/tests/fixtures/000000062808.rgb
new file mode 100644
index 000000000000..ac79a904fb92
Binary files /dev/null and b/crates/wasi-nn/tests/fixtures/000000062808.rgb differ
diff --git a/crates/wasi-nn/tests/fixtures/README.md b/crates/wasi-nn/tests/fixtures/README.md
new file mode 100644
index 000000000000..7001167b666c
--- /dev/null
+++ b/crates/wasi-nn/tests/fixtures/README.md
@@ -0,0 +1,9 @@
+The original image of 000000062808.rgb is 000000062808.jpg from ImageNet
+database. It processed by following Python code with
+https://github.com/onnx/models/blob/bec48b6a70e5e9042c0badbaafefe4454e072d08/validated/vision/classification/imagenet_preprocess.py
+
+```
+image = mxnet.image.imread('000000062808.jpg')
+image = preprocess_mxnet(image)
+image.asnumpy().tofile('000000062808.rgb')
+```
\ No newline at end of file
diff --git a/crates/wasi-nn/tests/test-programs.rs b/crates/wasi-nn/tests/test-programs.rs
new file mode 100644
index 000000000000..afbed884e59e
--- /dev/null
+++ b/crates/wasi-nn/tests/test-programs.rs
@@ -0,0 +1,269 @@
+//! Run the wasi-nn tests in `crates/test-programs`.
+//!
+//! It may be difficult to run to run all tests on all platforms; we check the
+//! pre-requisites for each test dynamically (see [`check`]). Using
+//! `libtest-mimic` allows us then to dynamically ignore tests that cannot run
+//! on the current machine.
+//!
+//! There are two modes these tests run in:
+//! - "ignore if unavailable" mode: if the checks for a test fail (e.g., the
+//!   backend is not installed, test artifacts cannot download, we're on the
+//!   wrong platform), the test is ignored.
+//! - "fail if unavailable" mode: when the `CI` or `FORCE_WASINN_TEST_CHECK`
+//!   environment variables are set, any checks that fail cause the test to fail
+//!   early.
+
+mod check;
+mod exec;
+
+use anyhow::Result;
+use libtest_mimic::{Arguments, Trial};
+use std::{borrow::Cow, env};
+use test_programs_artifacts::*;
+use wasmtime_wasi_nn::{backend, Backend};
+
+fn main() -> Result<()> {
+    tracing_subscriber::fmt::init();
+
+    if cfg!(miri) {
+        return Ok(());
+    }
+
+    // Gather a list of the test-program names.
+    let mut programs = Vec::new();
+    macro_rules! add_to_list {
+        ($name:ident) => {
+            programs.push(stringify!($name));
+        };
+    }
+    foreach_nn!(add_to_list);
+
+    // Make ignored tests turn into failures.
+    let error_on_failed_check =
+        env::var_os("CI").is_some() || env::var_os("FORCE_WASINN_TEST_CHECK").is_some();
+
+    // Inform `libtest-mimic` how to run each test program.
+    let arguments = Arguments::from_args();
+    let mut trials = Vec::new();
+    for program in programs {
+        // Either ignore the test if it cannot run (i.e., downgrade `Fail` to
+        // `Ignore`) or preemptively fail it if `error_on_failed_check` is set.
+        let (run_test, mut check) = check_test_program(program);
+        if !error_on_failed_check {
+            check = check.downgrade_failure(); // Downgrade `Fail` to `Ignore`.
+        }
+        let should_ignore = check.is_ignore();
+        if arguments.nocapture && should_ignore {
+            println!("> ignoring {program}: {}", check.reason());
+        }
+        let trial = Trial::test(program, move || {
+            run_test().map_err(|e| format!("{e:?}").into())
+        })
+        .with_ignored_flag(should_ignore);
+        trials.push(trial);
+    }
+
+    // Run the tests.
+    libtest_mimic::run(&arguments, trials).exit()
+}
+
+/// Return the test program to run and a check that must pass for the test to
+/// run.
+fn check_test_program(name: &str) -> (fn() -> Result<()>, IgnoreCheck) {
+    match name {
+        // Legacy WITX-based tests:
+        "nn_witx_image_classification_openvino" => (
+            nn_witx_image_classification_openvino,
+            IgnoreCheck::for_openvino(),
+        ),
+        "nn_witx_image_classification_openvino_named" => (
+            nn_witx_image_classification_openvino_named,
+            IgnoreCheck::for_openvino(),
+        ),
+        "nn_witx_image_classification_onnx" => {
+            (nn_witx_image_classification_onnx, IgnoreCheck::for_onnx())
+        }
+        "nn_witx_image_classification_winml_named" => (
+            nn_witx_image_classification_winml_named,
+            IgnoreCheck::for_winml(),
+        ),
+        // WIT-based tests:
+        "nn_wit_image_classification_openvino" => (
+            nn_wit_image_classification_openvino,
+            IgnoreCheck::for_openvino(),
+        ),
+        "nn_wit_image_classification_openvino_named" => (
+            nn_wit_image_classification_openvino_named,
+            IgnoreCheck::for_openvino(),
+        ),
+        "nn_wit_image_classification_onnx" => {
+            (nn_wit_image_classification_onnx, IgnoreCheck::for_onnx())
+        }
+        "nn_wit_image_classification_winml_named" => (
+            nn_wit_image_classification_winml_named,
+            IgnoreCheck::for_winml(),
+        ),
+        _ => panic!("unknown test program: {name} (add to this `match`)"),
+    }
+}
+
+fn nn_witx_image_classification_openvino() -> Result<()> {
+    check::openvino::is_installed()?;
+    check::openvino::are_artifacts_available()?;
+    let backend = Backend::from(backend::openvino::OpenvinoBackend::default());
+    exec::witx::run(NN_WITX_IMAGE_CLASSIFICATION_OPENVINO, backend, false)
+}
+
+fn nn_witx_image_classification_openvino_named() -> Result<()> {
+    check::openvino::is_installed()?;
+    check::openvino::are_artifacts_available()?;
+    let backend = Backend::from(backend::openvino::OpenvinoBackend::default());
+    exec::witx::run(NN_WITX_IMAGE_CLASSIFICATION_OPENVINO_NAMED, backend, true)
+}
+
+#[cfg(feature = "onnx")]
+fn nn_witx_image_classification_onnx() -> Result<()> {
+    check::onnx::are_artifacts_available()?;
+    let backend = Backend::from(backend::onnx::OnnxBackend::default());
+    exec::witx::run(NN_WITX_IMAGE_CLASSIFICATION_ONNX, backend, false)
+}
+#[cfg(not(feature = "onnx"))]
+fn nn_witx_image_classification_onnx() -> Result<()> {
+    anyhow::bail!("this test requires the `onnx` feature")
+}
+
+#[cfg(all(feature = "winml", target_os = "windows"))]
+fn nn_witx_image_classification_winml_named() -> Result<()> {
+    check::winml::is_available()?;
+    check::onnx::are_artifacts_available()?;
+    let backend = Backend::from(backend::winml::WinMLBackend::default());
+    exec::witx::run(NN_WITX_IMAGE_CLASSIFICATION_ONNX, backend, false)
+}
+#[cfg(not(all(feature = "winml", target_os = "windows")))]
+fn nn_witx_image_classification_winml_named() -> Result<()> {
+    anyhow::bail!("this test requires the `winml` feature and only runs on windows")
+}
+
+fn nn_wit_image_classification_openvino() -> Result<()> {
+    check::openvino::is_installed()?;
+    check::openvino::are_artifacts_available()?;
+    let backend = Backend::from(backend::openvino::OpenvinoBackend::default());
+    exec::wit::run(
+        NN_WIT_IMAGE_CLASSIFICATION_OPENVINO_COMPONENT,
+        backend,
+        false,
+    )
+}
+
+fn nn_wit_image_classification_openvino_named() -> Result<()> {
+    check::openvino::is_installed()?;
+    check::openvino::are_artifacts_available()?;
+    let backend = Backend::from(backend::openvino::OpenvinoBackend::default());
+    exec::wit::run(
+        NN_WIT_IMAGE_CLASSIFICATION_OPENVINO_NAMED_COMPONENT,
+        backend,
+        true,
+    )
+}
+
+#[cfg(feature = "onnx")]
+fn nn_wit_image_classification_onnx() -> Result<()> {
+    check::onnx::are_artifacts_available()?;
+    let backend = Backend::from(backend::onnx::OnnxBackend::default());
+    exec::wit::run(NN_WIT_IMAGE_CLASSIFICATION_ONNX_COMPONENT, backend, false)
+}
+#[cfg(not(feature = "onnx"))]
+fn nn_wit_image_classification_onnx() -> Result<()> {
+    anyhow::bail!("this test requires the `onnx` feature")
+}
+
+#[cfg(all(feature = "winml", target_os = "windows"))]
+fn nn_wit_image_classification_winml_named() -> Result<()> {
+    check::winml::is_available()?;
+    check::onnx::are_artifacts_available()?;
+    let backend = Backend::from(backend::winml::WinMLBackend::default());
+    exec::wit::run(NN_WIT_IMAGE_CLASSIFICATION_ONNX_COMPONENT, backend, false)
+}
+#[cfg(not(all(feature = "winml", target_os = "windows")))]
+fn nn_wit_image_classification_winml_named() -> Result<()> {
+    anyhow::bail!("this test requires the `winml` feature and only runs on windows")
+}
+
+/// Helper for keeping track of what tests should do when pre-test checks fail.
+#[derive(Clone)]
+enum IgnoreCheck {
+    Run,
+    Ignore(Cow<'static, str>),
+    Fail(Cow<'static, str>),
+}
+
+impl IgnoreCheck {
+    fn reason(&self) -> &str {
+        match self {
+            IgnoreCheck::Run => panic!("cannot get reason for `Run`"),
+            IgnoreCheck::Ignore(reason) => reason,
+            IgnoreCheck::Fail(reason) => reason,
+        }
+    }
+
+    fn downgrade_failure(self) -> Self {
+        if let IgnoreCheck::Fail(reason) = self {
+            IgnoreCheck::Ignore(reason)
+        } else {
+            self
+        }
+    }
+
+    fn is_ignore(&self) -> bool {
+        matches!(self, IgnoreCheck::Ignore(_))
+    }
+}
+
+/// Some pre-test checks for various backends.
+impl IgnoreCheck {
+    fn for_openvino() -> IgnoreCheck {
+        use IgnoreCheck::*;
+        if !cfg!(target_arch = "x86_64") {
+            Fail("requires x86_64".into())
+        } else if !cfg!(target_os = "linux") && !cfg!(target_os = "windows") {
+            Fail("requires linux or windows or macos".into())
+        } else if let Err(e) = check::openvino::is_installed() {
+            Fail(e.to_string().into())
+        } else {
+            Run
+        }
+    }
+
+    fn for_onnx() -> Self {
+        use IgnoreCheck::*;
+        #[cfg(feature = "onnx")]
+        if !cfg!(target_arch = "x86_64") && !cfg!(target_arch = "aarch64") {
+            Fail("requires x86_64 or aarch64".into())
+        } else if !cfg!(target_os = "linux")
+            && !cfg!(target_os = "windows")
+            && !cfg!(target_os = "macos")
+        {
+            Fail("requires linux, windows, or macos".into())
+        } else {
+            Run
+        }
+        #[cfg(not(feature = "onnx"))]
+        Ignore("requires the `onnx` feature".into())
+    }
+
+    fn for_winml() -> IgnoreCheck {
+        use IgnoreCheck::*;
+        #[cfg(all(feature = "winml", target_os = "windows"))]
+        if !cfg!(target_arch = "x86_64") {
+            Fail("requires x86_64".into())
+        } else if !cfg!(target_os = "windows") {
+            Fail("requires windows".into())
+        } else if let Err(e) = check::winml::is_available() {
+            Fail(e.to_string().into())
+        } else {
+            Run
+        }
+        #[cfg(not(all(feature = "winml", target_os = "windows")))]
+        Ignore("requires the `winml` feature on windows".into())
+    }
+}
diff --git a/crates/wasi-nn/wit/wasi-nn.wit b/crates/wasi-nn/wit/wasi-nn.wit
new file mode 100644
index 000000000000..2ae50151015a
--- /dev/null
+++ b/crates/wasi-nn/wit/wasi-nn.wit
@@ -0,0 +1,166 @@
+package wasi:nn@0.2.0-rc-2024-08-19;
+
+/// `wasi-nn` is a WASI API for performing machine learning (ML) inference. The API is not (yet)
+/// capable of performing ML training. WebAssembly programs that want to use a host's ML
+/// capabilities can access these capabilities through `wasi-nn`'s core abstractions: _graphs_ and
+/// _tensors_. A user `load`s an ML model -- instantiated as a _graph_ -- to use in an ML _backend_.
+/// Then, the user passes _tensor_ inputs to the _graph_, computes the inference, and retrieves the
+/// _tensor_ outputs.
+///
+/// This example world shows how to use these primitives together.
+world ml {
+    import tensor;
+    import graph;
+    import inference;
+    import errors;
+}
+
+/// All inputs and outputs to an ML inference are represented as `tensor`s.
+interface tensor {
+    /// The dimensions of a tensor.
+    ///
+    /// The array length matches the tensor rank and each element in the array describes the size of
+    /// each dimension
+    type tensor-dimensions = list<u32>;
+
+    /// The type of the elements in a tensor.
+    enum tensor-type {
+        FP16,
+        FP32,
+        FP64,
+        BF16,
+        U8,
+        I32,
+        I64
+    }
+
+    /// The tensor data.
+    ///
+    /// Initially conceived as a sparse representation, each empty cell would be filled with zeros
+    /// and the array length must match the product of all of the dimensions and the number of bytes
+    /// in the type (e.g., a 2x2 tensor with 4-byte f32 elements would have a data array of length
+    /// 16). Naturally, this representation requires some knowledge of how to lay out data in
+    /// memory--e.g., using row-major ordering--and could perhaps be improved.
+    type tensor-data = list<u8>;
+
+    resource tensor {
+        constructor(dimensions: tensor-dimensions, ty: tensor-type, data: tensor-data);
+
+        // Describe the size of the tensor (e.g., 2x2x2x2 -> [2, 2, 2, 2]). To represent a tensor
+        // containing a single value, use `[1]` for the tensor dimensions.
+        dimensions: func() -> tensor-dimensions;
+
+        // Describe the type of element in the tensor (e.g., `f32`).
+        ty: func() -> tensor-type;
+
+        // Return the tensor data.
+        data: func() -> tensor-data;
+    }
+}
+
+/// A `graph` is a loaded instance of a specific ML model (e.g., MobileNet) for a specific ML
+/// framework (e.g., TensorFlow):
+interface graph {
+    use errors.{error};
+    use tensor.{tensor};
+    use inference.{graph-execution-context};
+
+    /// An execution graph for performing inference (i.e., a model).
+    resource graph {
+        init-execution-context: func() -> result<graph-execution-context, error>;
+    }
+
+    /// Describes the encoding of the graph. This allows the API to be implemented by various
+    /// backends that encode (i.e., serialize) their graph IR with different formats.
+    enum graph-encoding {
+        openvino,
+        onnx,
+        tensorflow,
+        pytorch,
+        tensorflowlite,
+        ggml,
+        autodetect,
+    }
+
+    /// Define where the graph should be executed.
+    enum execution-target {
+        cpu,
+        gpu,
+        tpu
+    }
+
+    /// The graph initialization data.
+    ///
+    /// This gets bundled up into an array of buffers because implementing backends may encode their
+    /// graph IR in parts (e.g., OpenVINO stores its IR and weights separately).
+    type graph-builder = list<u8>;
+
+    /// Load a `graph` from an opaque sequence of bytes to use for inference.
+    load: func(builder: list<graph-builder>, encoding: graph-encoding, target: execution-target) -> result<graph, error>;
+
+    /// Load a `graph` by name.
+    ///
+    /// How the host expects the names to be passed and how it stores the graphs for retrieval via
+    /// this function is **implementation-specific**. This allows hosts to choose name schemes that
+    /// range from simple to complex (e.g., URLs?) and caching mechanisms of various kinds.
+    load-by-name: func(name: string) -> result<graph, error>;
+}
+
+/// An inference "session" is encapsulated by a `graph-execution-context`. This structure binds a
+/// `graph` to input tensors before `compute`-ing an inference:
+interface inference {
+    use errors.{error};
+    use tensor.{tensor, tensor-data};
+
+    /// Bind a `graph` to the input and output tensors for an inference.
+    ///
+    /// TODO: this may no longer be necessary in WIT
+    /// (https://github.com/WebAssembly/wasi-nn/issues/43)
+    resource graph-execution-context {
+        /// Define the inputs to use for inference.
+        set-input: func(name: string, tensor: tensor) -> result<_, error>;
+
+        /// Compute the inference on the given inputs.
+        ///
+        /// Note the expected sequence of calls: `set-input`, `compute`, `get-output`. TODO: this
+        /// expectation could be removed as a part of
+        /// https://github.com/WebAssembly/wasi-nn/issues/43.
+        compute: func() -> result<_, error>;
+
+        /// Extract the outputs after inference.
+        get-output: func(name: string) -> result<tensor, error>;
+    }
+}
+
+/// TODO: create function-specific errors (https://github.com/WebAssembly/wasi-nn/issues/42)
+interface errors {
+    enum error-code {
+        // Caller module passed an invalid argument.
+        invalid-argument,
+        // Invalid encoding.
+        invalid-encoding,
+        // The operation timed out.
+        timeout,
+        // Runtime Error.
+        runtime-error,
+        // Unsupported operation.
+        unsupported-operation,
+        // Graph is too large.
+        too-large,
+        // Graph not found.
+        not-found,
+        // The operation is insecure or has insufficient privilege to be performed.
+        // e.g., cannot access a hardware feature requested
+        security,
+        // The operation failed for an unspecified reason.
+        unknown
+    }
+
+    resource error {
+        /// Return the error code.
+        code: func() -> error-code;
+
+        /// Errors can propagated with backend specific status through a string value.
+        data: func() -> string;
+    }
+}
diff --git a/crates/wasi-nn/witx/wasi-nn.witx b/crates/wasi-nn/witx/wasi-nn.witx
new file mode 100644
index 000000000000..e413c2e03dc3
--- /dev/null
+++ b/crates/wasi-nn/witx/wasi-nn.witx
@@ -0,0 +1,92 @@
+;; This WITX version of the wasi-nn API is retained for consistency only. See the `wit/wasi-nn.wit`
+;; version for the official specification and documentation.
+
+(typename $buffer_size u32)
+(typename $nn_errno
+  (enum (@witx tag u16)
+    $success
+    $invalid_argument
+    $invalid_encoding
+    $missing_memory
+    $busy
+    $runtime_error
+    $unsupported_operation
+    $too_large
+    $not_found
+  )
+)
+(typename $tensor_dimensions (list u32))
+(typename $tensor_type
+  (enum (@witx tag u8)
+    $f16
+    $f32
+    $f64
+    $u8
+    $i32
+    $i64
+  )
+)
+(typename $tensor_data (list u8))
+(typename $tensor
+  (record
+    (field $dimensions $tensor_dimensions)
+    (field $type $tensor_type)
+    (field $data $tensor_data)
+  )
+)
+(typename $graph_builder (list u8))
+(typename $graph_builder_array (list $graph_builder))
+(typename $graph (handle))
+(typename $graph_encoding
+  (enum (@witx tag u8)
+    $openvino
+    $onnx
+    $tensorflow
+    $pytorch
+    $tensorflowlite
+    $autodetect
+  )
+)
+(typename $execution_target
+  (enum (@witx tag u8)
+    $cpu
+    $gpu
+    $tpu
+  )
+)
+(typename $graph_execution_context (handle))
+
+(module $wasi_ephemeral_nn
+  (import "memory" (memory))
+  (@interface func (export "load")
+    (param $builder $graph_builder_array)
+    (param $encoding $graph_encoding)
+    (param $target $execution_target)
+    (result $error (expected $graph (error $nn_errno)))
+  )
+  (@interface func (export "load_by_name")
+     (param $name string)
+     (result $error (expected $graph (error $nn_errno)))
+  )
+  (@interface func (export "init_execution_context")
+    (param $graph $graph)
+    (result $error (expected $graph_execution_context (error $nn_errno)))
+  )
+  (@interface func (export "set_input")
+    (param $context $graph_execution_context)
+    (param $index u32)
+    (param $tensor $tensor)
+    (result $error (expected (error $nn_errno)))
+  )
+  (@interface func (export "get_output")
+    (param $context $graph_execution_context)
+    (param $index u32)
+    (param $out_buffer (@witx pointer u8))
+    (param $out_buffer_max_size $buffer_size)
+    (result $error (expected $buffer_size (error $nn_errno)))
+  )
+  (@interface func (export "compute")
+    (param $context $graph_execution_context)
+    (result $error (expected (error $nn_errno)))
+  )
+)
diff --git a/crates/wasi-preview1-component-adapter/Cargo.toml b/crates/wasi-preview1-component-adapter/Cargo.toml
index 12b9d3f05d7b..0eac34f1e206 100644
--- a/crates/wasi-preview1-component-adapter/Cargo.toml
+++ b/crates/wasi-preview1-component-adapter/Cargo.toml
@@ -3,23 +3,30 @@ name = "wasi-preview1-component-adapter"
 version.workspace = true
 authors.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 publish = false
 
+[lints]
+workspace = true
+
 [dependencies]
 wasi = { version = "0.11.0", default-features = false }
-wit-bindgen = { workspace = true, default-features = false, features = ["macros"] }
+wit-bindgen-rust-macro = { workspace = true }
 byte-array-literals = { workspace = true }
+bitflags = { workspace = true }
 
 [build-dependencies]
 wasm-encoder = { workspace = true }
-object = { workspace = true, default-features = false, features = ["archive"] }
+object = { workspace = true, default-features = false, features = ["archive", "std"] }
 
 [lib]
 test = false
 crate-type = ["cdylib"]
 name = "wasi_snapshot_preview1"
+doc = false
 
 [features]
 default = ["reactor"]
 reactor = []
 command = []
+proxy = []
diff --git a/crates/wasi-preview1-component-adapter/README.md b/crates/wasi-preview1-component-adapter/README.md
index ec0834318454..ffe369360f2d 100644
--- a/crates/wasi-preview1-component-adapter/README.md
+++ b/crates/wasi-preview1-component-adapter/README.md
@@ -45,7 +45,7 @@ $ cat foo.rs
 fn main() {
     println!("Hello, world!");
 }
-$ rustc foo.rs --target wasm32-wasi
+$ rustc foo.rs --target wasm32-wasip1
 $ wasm-tools print foo.wasm | grep '(import'
   (import "wasi_snapshot_preview1" "fd_write" (func ...
   (import "wasi_snapshot_preview1" "environ_get" (func ...
diff --git a/crates/wasi-preview1-component-adapter/build.rs b/crates/wasi-preview1-component-adapter/build.rs
index 09f56df1526c..2762dd6b4475 100644
--- a/crates/wasi-preview1-component-adapter/build.rs
+++ b/crates/wasi-preview1-component-adapter/build.rs
@@ -93,6 +93,7 @@ fn build_raw_intrinsics() -> Vec<u8> {
         GlobalType {
             val_type: ValType::I32,
             mutable: true,
+            shared: false,
         },
         &ConstExpr::i32_const(0),
     );
@@ -101,6 +102,7 @@ fn build_raw_intrinsics() -> Vec<u8> {
         GlobalType {
             val_type: ValType::I32,
             mutable: true,
+            shared: false,
         },
         &ConstExpr::i32_const(0),
     );
diff --git a/crates/wasi-preview1-component-adapter/byte-array-literals/Cargo.toml b/crates/wasi-preview1-component-adapter/byte-array-literals/Cargo.toml
index 5be0dd93850c..10b21a963faa 100644
--- a/crates/wasi-preview1-component-adapter/byte-array-literals/Cargo.toml
+++ b/crates/wasi-preview1-component-adapter/byte-array-literals/Cargo.toml
@@ -3,6 +3,7 @@ name = "byte-array-literals"
 version.workspace = true
 authors.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 publish = false
 
 [lib]
diff --git a/crates/wasi-preview1-component-adapter/provider/.gitignore b/crates/wasi-preview1-component-adapter/provider/.gitignore
new file mode 100644
index 000000000000..1ae47fad85cd
--- /dev/null
+++ b/crates/wasi-preview1-component-adapter/provider/.gitignore
@@ -0,0 +1 @@
+/Cargo.toml
diff --git a/crates/wasi-preview1-component-adapter/provider/Cargo.toml.in b/crates/wasi-preview1-component-adapter/provider/Cargo.toml.in
new file mode 100644
index 000000000000..a47099f951e0
--- /dev/null
+++ b/crates/wasi-preview1-component-adapter/provider/Cargo.toml.in
@@ -0,0 +1,20 @@
+[package]
+name = "wasi-preview1-component-adapter-provider"
+version.workspace = true
+authors.workspace = true
+description = "Embedded wasi-preview1-component-adapter binaries"
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+documentation = "https://docs.rs/wasi-preview1-component-adapter-provider/"
+categories = ["wasm"]
+keywords = ["webassembly", "wasm"]
+edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
+
+[package.metadata.docs.rs]
+all-features = true
+
+[dependencies]
diff --git a/crates/wasi-preview1-component-adapter/provider/README.md b/crates/wasi-preview1-component-adapter/provider/README.md
new file mode 100644
index 000000000000..aed6afb35fc7
--- /dev/null
+++ b/crates/wasi-preview1-component-adapter/provider/README.md
@@ -0,0 +1,77 @@
+<div align="center">
+  <h1><code>wasi-preview1-component-adapter-provider</code></h1>
+  <strong>A <a href="https://bytecodealliance.org/">Bytecode Alliance</a> project</strong>
+  <p>
+    <strong>
+      A utility library containing binaries for WASI Preview1 adapters for easy use from Rust.
+    </strong>
+  </p>
+
+  <p>
+    <a href="https://crates.io/crates/wasi-preview1-component-adapter-provider"><img src="https://img.shields.io/crates/v/wasi-preview1-component-adapter-provider.svg?style=flat-square" alt="Crates.io version" /></a>
+    <a href="https://crates.io/crates/wasi-preview1-component-adapter-provider"><img src="https://img.shields.io/crates/d/wasi-preview1-component-adapter-provider.svg?style=flat-square" alt="Download" /></a>
+    <a href="https://docs.rs/wasi-preview1-component-adapter-provider/"><img src="https://img.shields.io/badge/docs-latest-blue.svg?style=flat-square" alt="docs.rs docs" /></a>
+  </p>
+</div>
+
+`wasi-preview1-component-adapter-provider` contains the raw bytes of the WASI Preview1 to Preview2 adapters (Reactor, Command, and Proxy).
+
+For example, if you wanted to write the adapter bytes back into a `.wasm` binary:
+
+```rust
+use wasi_preview1_component_adapter_provider::WASI_SNAPSHOT_PREVIEW1_REACTOR_ADAPTER;
+
+fn main() {
+    std::fs::write(
+        "wasi_snapshot_preview1.reactor.wasm",
+        WASI_SNAPSHOT_PREVIEW1_REACTOR_ADAPTER
+    ).expect("failed to write bytes to file");
+}
+```
+
+A more realistic use-case is performing the *adaptation* step of preparing a WASI Preview2 component from an existing WASI Preview1 component:
+
+```rust
+use wasi_preview1_component_adapter_provider::WASI_SNAPSHOT_PREVIEW1_REACTOR_ADAPTER;
+use wit_component::ComponentEncoder;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let wasm_p1_bytes = std::fs::read("path/to/your/your-component.p1.wasm");
+
+    let wasm_p2_bytes = ComponentEncoder::default()
+        .module(&wasm_module_bytes)?
+        .adapter(
+            "wasi_snapshot_preview1",
+            WASI_SNAPSHOT_PREVIEW1_REACTOR_ADAPTER,
+        )?
+        .validate(true)
+        .encode()?;
+
+    std::fs::write("your-component.p2.wasm", wasm_p2_bytes)?;
+
+    Ok(())
+}
+```
+
+## What is a component adapter?
+
+Code compiled to WebAssembly as described by the [base WebAssembly Spec][wasm-spec] is considered a WebAssembly "module" or "core module".
+
+To robustly support rich types, composition, and easier interoperability, the [Component Model][cm] was created and is the spec that governs the idea of a "WebAssembly component". The component model wraps any existing WebAssembly core module(s) and extends them with additional features.
+
+To standardize underlying system interoperability (ex. reading files, system time) in code compiled to WebAssembly, the [WebAssembly System Interface ("WASI")][wasi] was created. WASI is implemented by language tool chains (ex. Rust supports `wasm32-wasi`/`wasm32-wasip1` as a target, with [support for `wasm32-wasip2` on the way][rust-target-wasm32-wasi]), and enables compiling a WebAssembly component that utilizes [the interfaces that make up WASI Preview1][wasi-p1-interfaces].
+
+In the ongoing work of building WASI, WASI Preview2 which contains more functionality [has been released][wasi-p2-release] -- but building directly to Preview2 is not yet integrated into language toolchains. However, Preview1 components (which *can* be produced by curren toolchains) can be *adapted* to WASI Preview2.
+
+This is where component adapters come in.
+
+**Component Adapters are WebAssembly binaries that contain logic that can take any WebAssembly binary implemented in terms of WASI Preview1 and convert them to WASI Preview2.**
+
+This crate contains the binary content of those the adapter WebAssembly binaries, made accessible as constant arrays of bytes (`const &[u8]`).
+
+[wasm-spec]: https://webassembly.github.io/spec/core
+[cm]: https://component-model.bytecodealliance.org
+[wasi]: https://wasi.dev/
+[wasi-p2-release]: https://bytecodealliance.org/articles/WASI-0.2
+[rust-target-wasm32-wasi]: https://blog.rust-lang.org/2024/04/09/updates-to-rusts-wasi-targets.html
+[wasi-p1-interfaces]: https://github.com/WebAssembly/WASI/blob/main/legacy/preview1/witx/wasi_snapshot_preview1.witx
diff --git a/crates/wasi-preview1-component-adapter/provider/artefacts/.gitignore b/crates/wasi-preview1-component-adapter/provider/artefacts/.gitignore
new file mode 100644
index 000000000000..46be8eadbf31
--- /dev/null
+++ b/crates/wasi-preview1-component-adapter/provider/artefacts/.gitignore
@@ -0,0 +1,3 @@
+/wasi_snapshot_preview1.reactor.wasm
+/wasi_snapshot_preview1.command.wasm
+/wasi_snapshot_preview1.proxy.wasm
diff --git a/crates/wasi-preview1-component-adapter/provider/src/lib.rs b/crates/wasi-preview1-component-adapter/provider/src/lib.rs
new file mode 100644
index 000000000000..0783c93bdb42
--- /dev/null
+++ b/crates/wasi-preview1-component-adapter/provider/src/lib.rs
@@ -0,0 +1,51 @@
+//! This crate contains the binaries of three WebAssembly modules:
+//!
+//! - [`WASI_SNAPSHOT_PREVIEW1_REACTOR_ADAPTER`]
+//! - [`WASI_SNAPSHOT_PREVIEW1_COMMAND_ADAPTER`]
+//! - [`WASI_SNAPSHOT_PREVIEW1_PROXY_ADAPTER`]
+//!
+//! These three modules bridge the wasip1 ABI to the wasip2 ABI of the component
+//! model.
+//!
+//! They can be given to the [`wit_component::ComponentEncoder::adapter`]
+//! method, using the [`WASI_SNAPSHOT_PREVIEW1_ADAPTER_NAME`], to translate a
+//! module from the historical WASM ABI to the canonical ABI.
+//!
+//! [`wit_component::ComponentEncoder::adapter`]: https://docs.rs/wit-component/latest/wit_component/struct.ComponentEncoder.html#method.adapter
+
+/// The name of the adapters in this crate, which may be provided to
+/// [`wit_component::ComponentEncoder::adapter`].
+///
+/// [`wit_component::ComponentEncoder::adapter`]: https://docs.rs/wit-component/latest/wit_component/struct.ComponentEncoder.html#method.adapter
+pub const WASI_SNAPSHOT_PREVIEW1_ADAPTER_NAME: &str = "wasi_snapshot_preview1";
+
+/// The "reactor" adapter provides the default adaptation from preview1 to
+/// preview2.
+///
+/// This adapter implements the [`wasi:cli/imports`] world.
+///
+/// [`wasi:cli/imports`]: https://github.com/WebAssembly/WASI/blob/01bb90d8b66cbc1d50349aaaab9ac5b143c9c98c/preview2/cli/imports.wit
+pub const WASI_SNAPSHOT_PREVIEW1_REACTOR_ADAPTER: &[u8] =
+    include_bytes!("../artefacts/wasi_snapshot_preview1.reactor.wasm");
+
+/// The "command" adapter extends the ["reactor" adapter] and additionally
+/// exports a `run` function entrypoint.
+///
+/// This adapter implements the [`wasi:cli/command`] world.
+///
+/// ["reactor" adapter]: WASI_SNAPSHOT_PREVIEW1_REACTOR_ADAPTER
+/// [`wasi:cli/command`]: https://github.com/WebAssembly/WASI/blob/01bb90d8b66cbc1d50349aaaab9ac5b143c9c98c/preview2/cli/command.wit
+pub const WASI_SNAPSHOT_PREVIEW1_COMMAND_ADAPTER: &[u8] =
+    include_bytes!("../artefacts/wasi_snapshot_preview1.command.wasm");
+
+/// The "proxy" adapter provides implements a HTTP proxy which is more
+/// restricted than the ["reactor" adapter] adapter, as it lacks filesystem,
+/// socket, environment, exit, and terminal support, but includes HTTP handlers
+/// for incoming and outgoing requests.
+///
+/// This adapter implements the [`wasi:http/proxy`] world.
+///
+/// ["reactor" adapter]: WASI_SNAPSHOT_PREVIEW1_REACTOR_ADAPTER
+/// [`wasi:http/proxy`]: https://github.com/WebAssembly/WASI/blob/01bb90d8b66cbc1d50349aaaab9ac5b143c9c98c/preview2/http/proxy.wit
+pub const WASI_SNAPSHOT_PREVIEW1_PROXY_ADAPTER: &[u8] =
+    include_bytes!("../artefacts/wasi_snapshot_preview1.proxy.wasm");
diff --git a/crates/wasi-preview1-component-adapter/src/descriptors.rs b/crates/wasi-preview1-component-adapter/src/descriptors.rs
index 997d8856b0fe..7b470b310fa4 100644
--- a/crates/wasi-preview1-component-adapter/src/descriptors.rs
+++ b/crates/wasi-preview1-component-adapter/src/descriptors.rs
@@ -1,14 +1,16 @@
-use crate::bindings::wasi::cli::{
-    stderr, stdin, stdout, terminal_stderr, terminal_stdin, terminal_stdout,
-};
-use crate::bindings::wasi::filesystem::types as filesystem;
+use crate::bindings::wasi::cli::{stderr, stdin, stdout};
 use crate::bindings::wasi::io::streams::{InputStream, OutputStream};
-use crate::bindings::wasi::sockets::tcp;
-use crate::{BlockingMode, BumpArena, File, ImportAlloc, TrappingUnwrap, WasmStr};
+use crate::{BlockingMode, ImportAlloc, State, TrappingUnwrap, WasmStr};
 use core::cell::{Cell, OnceCell, UnsafeCell};
 use core::mem::MaybeUninit;
+use core::num::NonZeroUsize;
 use wasi::{Errno, Fd};
 
+#[cfg(not(feature = "proxy"))]
+use crate::bindings::wasi::filesystem::types as filesystem;
+#[cfg(not(feature = "proxy"))]
+use crate::File;
+
 pub const MAX_DESCRIPTORS: usize = 128;
 
 #[repr(C)]
@@ -19,6 +21,8 @@ pub enum Descriptor {
 
     /// Input and/or output wasi-streams, along with stream metadata.
     Streams(Streams),
+
+    Bad,
 }
 
 /// Input and/or output wasi-streams, along with a stream type that
@@ -44,12 +48,14 @@ impl Streams {
                 let input = match &self.type_ {
                     // For directories, preview 1 behavior was to return ERRNO_BADF on attempts to read
                     // or write.
+                    #[cfg(not(feature = "proxy"))]
                     StreamType::File(File {
                         descriptor_type: filesystem::DescriptorType::Directory,
                         ..
                     }) => return Err(wasi::ERRNO_BADF),
                     // For files, we may have adjusted the position for seeking, so
                     // create a new stream.
+                    #[cfg(not(feature = "proxy"))]
                     StreamType::File(file) => {
                         let input = file.fd.read_via_stream(file.position.get())?;
                         input
@@ -70,12 +76,14 @@ impl Streams {
                 let output = match &self.type_ {
                     // For directories, preview 1 behavior was to return ERRNO_BADF on attempts to read
                     // or write.
+                    #[cfg(not(feature = "proxy"))]
                     StreamType::File(File {
                         descriptor_type: filesystem::DescriptorType::Directory,
                         ..
                     }) => return Err(wasi::ERRNO_BADF),
                     // For files, we may have adjusted the position for seeking, so
                     // create a new stream.
+                    #[cfg(not(feature = "proxy"))]
                     StreamType::File(file) => {
                         let output = if file.append {
                             file.fd.append_via_stream()?
@@ -93,28 +101,38 @@ impl Streams {
     }
 }
 
-#[allow(dead_code)] // until Socket is implemented
 pub enum StreamType {
     /// Streams for implementing stdio.
-    Stdio(IsATTY),
+    Stdio(Stdio),
 
     /// Streaming data with a file.
+    #[cfg(not(feature = "proxy"))]
     File(File),
-
-    /// Streaming data with a socket connection.
-    Socket(tcp::TcpSocket),
 }
 
-pub enum IsATTY {
-    Yes,
-    No,
+pub enum Stdio {
+    Stdin,
+    Stdout,
+    Stderr,
 }
 
-impl IsATTY {
+impl Stdio {
     pub fn filetype(&self) -> wasi::Filetype {
-        match self {
-            IsATTY::Yes => wasi::FILETYPE_CHARACTER_DEVICE,
-            IsATTY::No => wasi::FILETYPE_UNKNOWN,
+        #[cfg(not(feature = "proxy"))]
+        let is_terminal = {
+            use crate::bindings::wasi::cli;
+            match self {
+                Stdio::Stdin => cli::terminal_stdin::get_terminal_stdin().is_some(),
+                Stdio::Stdout => cli::terminal_stdout::get_terminal_stdout().is_some(),
+                Stdio::Stderr => cli::terminal_stderr::get_terminal_stderr().is_some(),
+            }
+        };
+        #[cfg(feature = "proxy")]
+        let is_terminal = false;
+        if is_terminal {
+            wasi::FILETYPE_CHARACTER_DEVICE
+        } else {
+            wasi::FILETYPE_UNKNOWN
         }
     }
 }
@@ -128,32 +146,21 @@ pub struct Descriptors {
 
     /// Points to the head of a free-list of closed file descriptors.
     closed: Option<Fd>,
+}
 
-    /// Preopened directories. Initialized lazily. Access with `State::get_preopens`
-    /// to take care of initialization.
-    preopens: Cell<Option<&'static [Preopen]>>,
+#[cfg(not(feature = "proxy"))]
+#[link(wasm_import_module = "wasi:filesystem/preopens@0.2.1")]
+extern "C" {
+    #[link_name = "get-directories"]
+    fn wasi_filesystem_get_directories(rval: *mut PreopenList);
 }
 
 impl Descriptors {
-    pub fn new(import_alloc: &ImportAlloc, arena: &BumpArena) -> Self {
+    pub fn new(state: &State) -> Self {
         let d = Descriptors {
             table: UnsafeCell::new(MaybeUninit::uninit()),
             table_len: Cell::new(0),
             closed: None,
-            preopens: Cell::new(None),
-        };
-
-        let stdin_isatty = match terminal_stdin::get_terminal_stdin() {
-            Some(_) => IsATTY::Yes,
-            None => IsATTY::No,
-        };
-        let stdout_isatty = match terminal_stdout::get_terminal_stdout() {
-            Some(_) => IsATTY::Yes,
-            None => IsATTY::No,
-        };
-        let stderr_isatty = match terminal_stderr::get_terminal_stderr() {
-            Some(_) => IsATTY::Yes,
-            None => IsATTY::No,
         };
 
         fn new_once<T>(val: T) -> OnceCell<T> {
@@ -165,63 +172,95 @@ impl Descriptors {
         d.push(Descriptor::Streams(Streams {
             input: new_once(stdin::get_stdin()),
             output: OnceCell::new(),
-            type_: StreamType::Stdio(stdin_isatty),
+            type_: StreamType::Stdio(Stdio::Stdin),
         }))
         .trapping_unwrap();
         d.push(Descriptor::Streams(Streams {
             input: OnceCell::new(),
             output: new_once(stdout::get_stdout()),
-            type_: StreamType::Stdio(stdout_isatty),
+            type_: StreamType::Stdio(Stdio::Stdout),
         }))
         .trapping_unwrap();
         d.push(Descriptor::Streams(Streams {
             input: OnceCell::new(),
             output: new_once(stderr::get_stderr()),
-            type_: StreamType::Stdio(stderr_isatty),
+            type_: StreamType::Stdio(Stdio::Stderr),
         }))
         .trapping_unwrap();
 
-        #[link(wasm_import_module = "wasi:filesystem/preopens")]
-        #[allow(improper_ctypes)] // FIXME(bytecodealliance/wit-bindgen#684)
-        extern "C" {
-            #[link_name = "get-directories"]
-            fn get_preopens_import(rval: *mut PreopenList);
+        #[cfg(not(feature = "proxy"))]
+        d.open_preopens(state);
+        d
+    }
+
+    #[cfg(not(feature = "proxy"))]
+    fn open_preopens(&self, state: &State) {
+        unsafe {
+            let alloc = ImportAlloc::CountAndDiscardStrings {
+                strings_size: 0,
+                alloc: state.temporary_alloc(),
+            };
+            let (preopens, _) = state.with_import_alloc(alloc, || {
+                let mut preopens = PreopenList {
+                    base: std::ptr::null(),
+                    len: 0,
+                };
+                wasi_filesystem_get_directories(&mut preopens);
+                preopens
+            });
+            for i in 0..preopens.len {
+                let preopen = preopens.base.add(i).read();
+                // Expectation is that the descriptor index is initialized with
+                // stdio (0,1,2) and no others, so that preopens are 3..
+                let descriptor_type = preopen.descriptor.get_type().trapping_unwrap();
+                self.push(Descriptor::Streams(Streams {
+                    input: OnceCell::new(),
+                    output: OnceCell::new(),
+                    type_: StreamType::File(File {
+                        fd: preopen.descriptor,
+                        descriptor_type,
+                        position: Cell::new(0),
+                        append: false,
+                        blocking_mode: BlockingMode::Blocking,
+                        preopen_name_len: NonZeroUsize::new(preopen.path.len),
+                    }),
+                }))
+                .trapping_unwrap();
+            }
         }
-        let mut list = PreopenList {
-            base: std::ptr::null(),
-            len: 0,
+    }
+
+    #[cfg(not(feature = "proxy"))]
+    pub unsafe fn get_preopen_path(&self, state: &State, fd: Fd, path: *mut u8, len: usize) {
+        let nth = fd - 3;
+        let alloc = ImportAlloc::GetPreopenPath {
+            cur: 0,
+            nth,
+            alloc: state.temporary_alloc(),
         };
-        import_alloc.with_arena(arena, || unsafe {
-            get_preopens_import(&mut list as *mut _)
+        let (preopens, _) = state.with_import_alloc(alloc, || {
+            let mut preopens = PreopenList {
+                base: std::ptr::null(),
+                len: 0,
+            };
+            wasi_filesystem_get_directories(&mut preopens);
+            preopens
         });
-        let preopens: &'static [Preopen] = unsafe {
-            // allocation comes from long lived arena, so it is safe to
-            // cast this to a &'static slice:
-            std::slice::from_raw_parts(list.base, list.len)
-        };
-        for preopen in preopens {
-            // Acquire ownership of the descriptor, leaving the rest of the
-            // `Preopen` struct in place.
-            let descriptor = unsafe { preopen.descriptor.assume_init_read() };
-            // Expectation is that the descriptor index is initialized with
-            // stdio (0,1,2) and no others, so that preopens are 3..
-            let descriptor_type = descriptor.get_type().trapping_unwrap();
-            d.push(Descriptor::Streams(Streams {
-                input: OnceCell::new(),
-                output: OnceCell::new(),
-                type_: StreamType::File(File {
-                    fd: descriptor,
-                    descriptor_type,
-                    position: Cell::new(0),
-                    append: false,
-                    blocking_mode: BlockingMode::Blocking,
-                }),
-            }))
-            .trapping_unwrap();
-        }
 
-        d.preopens.set(Some(preopens));
-        d
+        // NB: we just got owned handles for all preopened directories. We're
+        // only interested in one individual string allocation, however, so
+        // discard all of the descriptors and close them since we otherwise
+        // don't want to leak them.
+        for i in 0..preopens.len {
+            let preopen = preopens.base.add(i).read();
+            drop(preopen.descriptor);
+
+            if (i as u32) != nth {
+                continue;
+            }
+            assert!(preopen.path.len <= len);
+            core::ptr::copy(preopen.path.ptr, path, preopen.path.len);
+        }
     }
 
     fn push(&self, desc: Descriptor) -> Result<Fd, Errno> {
@@ -266,7 +305,7 @@ impl Descriptors {
                     Descriptor::Closed(next) => *next,
                     _ => unreachable!("impossible: freelist points to a closed descriptor"),
                 };
-                // Write descriptor to the entry at the nead of the list
+                // Write descriptor to the entry at the head of the list
                 *freelist_desc = d;
                 // Point closed to the following item
                 self.closed = next_closed;
@@ -287,13 +326,6 @@ impl Descriptors {
             .ok_or(wasi::ERRNO_BADF)
     }
 
-    pub fn get_preopen(&self, fd: Fd) -> Option<&Preopen> {
-        let preopens = self.preopens.get().trapping_unwrap();
-        // Subtract 3 for the stdio indices to compute the preopen index.
-        let index = fd.checked_sub(3)? as usize;
-        preopens.get(index)
-    }
-
     // Internal: close a fd, returning the descriptor.
     fn close_(&mut self, fd: Fd) -> Result<Descriptor, Errno> {
         // Throw an error if closing an fd which is already closed
@@ -327,7 +359,7 @@ impl Descriptors {
         // First, ensure from_fd is in bounds:
         let _ = self.get(from_fd)?;
         // Expand table until to_fd is in bounds as well:
-        while self.table_len.get() as u32 <= to_fd as u32 {
+        while self.table_len.get() as u32 <= to_fd {
             self.push_closed()?;
         }
         // Then, close from_fd and put its contents into to_fd:
@@ -347,10 +379,11 @@ impl Descriptors {
     ) -> Result<&mut Streams, Errno> {
         match self.get_mut(fd)? {
             Descriptor::Streams(streams) => Ok(streams),
-            Descriptor::Closed(_) => Err(error),
+            Descriptor::Closed(_) | Descriptor::Bad => Err(error),
         }
     }
 
+    #[cfg(not(feature = "proxy"))]
     pub fn get_file_with_error(&self, fd: Fd, error: Errno) -> Result<&File, Errno> {
         match self.get(fd)? {
             Descriptor::Streams(Streams {
@@ -370,22 +403,12 @@ impl Descriptors {
         }
     }
 
-    #[allow(dead_code)] // until Socket is implemented
-    pub fn get_socket(&self, fd: Fd) -> Result<&tcp::TcpSocket, Errno> {
-        match self.get(fd)? {
-            Descriptor::Streams(Streams {
-                type_: StreamType::Socket(socket),
-                ..
-            }) => Ok(&*socket),
-            Descriptor::Closed(_) => Err(wasi::ERRNO_BADF),
-            _ => Err(wasi::ERRNO_INVAL),
-        }
-    }
-
+    #[cfg(not(feature = "proxy"))]
     pub fn get_file(&self, fd: Fd) -> Result<&File, Errno> {
         self.get_file_with_error(fd, wasi::ERRNO_INVAL)
     }
 
+    #[cfg(not(feature = "proxy"))]
     pub fn get_dir(&self, fd: Fd) -> Result<&File, Errno> {
         match self.get(fd)? {
             Descriptor::Streams(Streams {
@@ -406,6 +429,7 @@ impl Descriptors {
         }
     }
 
+    #[cfg(not(feature = "proxy"))]
     pub fn get_seekable_file(&self, fd: Fd) -> Result<&File, Errno> {
         self.get_file_with_error(fd, wasi::ERRNO_SPIPE)
     }
@@ -417,26 +441,26 @@ impl Descriptors {
     pub fn get_read_stream(&self, fd: Fd) -> Result<&InputStream, Errno> {
         match self.get(fd)? {
             Descriptor::Streams(streams) => streams.get_read_stream(),
-            Descriptor::Closed(_) => Err(wasi::ERRNO_BADF),
+            Descriptor::Closed(_) | Descriptor::Bad => Err(wasi::ERRNO_BADF),
         }
     }
 
     pub fn get_write_stream(&self, fd: Fd) -> Result<&OutputStream, Errno> {
         match self.get(fd)? {
             Descriptor::Streams(streams) => streams.get_write_stream(),
-            Descriptor::Closed(_) => Err(wasi::ERRNO_BADF),
+            Descriptor::Closed(_) | Descriptor::Bad => Err(wasi::ERRNO_BADF),
         }
     }
 }
 
+#[cfg(not(feature = "proxy"))]
 #[repr(C)]
 pub struct Preopen {
-    /// This is `MaybeUninit` because we take ownership of the `Descriptor` to
-    /// put it in our own table.
-    pub descriptor: MaybeUninit<filesystem::Descriptor>,
+    pub descriptor: filesystem::Descriptor,
     pub path: WasmStr,
 }
 
+#[cfg(not(feature = "proxy"))]
 #[repr(C)]
 pub struct PreopenList {
     pub base: *const Preopen,
diff --git a/crates/wasi-preview1-component-adapter/src/lib.rs b/crates/wasi-preview1-component-adapter/src/lib.rs
index acbf82eea54d..b7464ff1fc86 100644
--- a/crates/wasi-preview1-component-adapter/src/lib.rs
+++ b/crates/wasi-preview1-component-adapter/src/lib.rs
@@ -1,24 +1,45 @@
-use crate::bindings::wasi::cli::exit;
+// The proxy world has no filesystem which most of this file is concerned with,
+// so disable many warnings to avoid having to contort code too much for the
+// proxy world.
+#![cfg_attr(
+    feature = "proxy",
+    allow(
+        unused_mut,
+        unused_variables,
+        dead_code,
+        unused_imports,
+        unreachable_code
+    )
+)]
+
 use crate::bindings::wasi::clocks::{monotonic_clock, wall_clock};
-use crate::bindings::wasi::filesystem::types as filesystem;
 use crate::bindings::wasi::io::poll;
 use crate::bindings::wasi::io::streams;
 use crate::bindings::wasi::random::random;
-use crate::bindings::wasi::sockets::network;
 use core::cell::OnceCell;
 use core::cell::{Cell, RefCell, RefMut, UnsafeCell};
 use core::cmp::min;
 use core::ffi::c_void;
 use core::hint::black_box;
 use core::mem::{self, align_of, forget, size_of, ManuallyDrop, MaybeUninit};
+use core::num::NonZeroUsize;
 use core::ops::{Deref, DerefMut};
 use core::ptr::{self, null_mut};
 use core::slice;
 use poll::Pollable;
 use wasi::*;
 
-#[cfg(all(feature = "command", feature = "reactor"))]
-compile_error!("only one of the `command` and `reactor` features may be selected at a time");
+#[cfg(not(feature = "proxy"))]
+use crate::bindings::wasi::filesystem::types as filesystem;
+
+#[cfg(any(
+    all(feature = "command", feature = "reactor"),
+    all(feature = "reactor", feature = "proxy"),
+    all(feature = "command", feature = "proxy"),
+))]
+compile_error!(
+    "only one of the `command`, `reactor` or `proxy` features may be selected at a time"
+);
 
 #[macro_use]
 mod macros;
@@ -28,37 +49,73 @@ use crate::descriptors::{Descriptor, Descriptors, StreamType, Streams};
 
 pub mod bindings {
     #[cfg(feature = "command")]
-    wit_bindgen::generate!({
+    wit_bindgen_rust_macro::generate!({
         path: "../wasi/wit",
         world: "wasi:cli/command",
         std_feature,
         raw_strings,
+        runtime_path: "crate::bindings::wit_bindgen_rt_shim",
         // Automatically generated bindings for these functions will allocate
         // Vecs, which in turn pulls in the panic machinery from std, which
         // creates vtables that end up in the wasm elem section, which we
         // can't support in these special core-wasm adapters.
         // Instead, we manually define the bindings for these functions in
         // terms of raw pointers.
-        skip: ["run", "get-environment", "poll-list"],
+        skip: ["run", "get-environment", "poll"],
+        generate_all,
+        disable_custom_section_link_helpers: true,
     });
 
     #[cfg(feature = "reactor")]
-    wit_bindgen::generate!({
+    wit_bindgen_rust_macro::generate!({
         path: "../wasi/wit",
-        world: "wasmtime:wasi/preview1-adapter-reactor",
+        world: "wasi:cli/imports",
         std_feature,
         raw_strings,
+        runtime_path: "crate::bindings::wit_bindgen_rt_shim",
         // Automatically generated bindings for these functions will allocate
         // Vecs, which in turn pulls in the panic machinery from std, which
         // creates vtables that end up in the wasm elem section, which we
         // can't support in these special core-wasm adapters.
         // Instead, we manually define the bindings for these functions in
         // terms of raw pointers.
-        skip: ["get-environment", "poll-list"],
+        skip: ["get-environment", "poll"],
+        generate_all,
+        disable_custom_section_link_helpers: true,
     });
+
+    #[cfg(feature = "proxy")]
+    wit_bindgen_rust_macro::generate!({
+        path: "../wasi-http/wit",
+        inline: r#"
+            package wasmtime:adapter;
+
+            world adapter {
+                import wasi:clocks/wall-clock@0.2.1;
+                import wasi:clocks/monotonic-clock@0.2.1;
+                import wasi:random/random@0.2.1;
+                import wasi:cli/stdout@0.2.1;
+                import wasi:cli/stderr@0.2.1;
+                import wasi:cli/stdin@0.2.1;
+            }
+        "#,
+        world: "wasmtime:adapter/adapter",
+        std_feature,
+        raw_strings,
+        runtime_path: "crate::bindings::wit_bindgen_rt_shim",
+        skip: ["poll"],
+        generate_all,
+        disable_custom_section_link_helpers: true,
+    });
+
+    pub mod wit_bindgen_rt_shim {
+        pub use bitflags;
+
+        pub fn maybe_link_cabi_realloc() {}
+    }
 }
 
-#[export_name = "wasi:cli/run#run"]
+#[export_name = "wasi:cli/run@0.2.1#run"]
 #[cfg(feature = "command")]
 pub unsafe extern "C" fn run() -> u32 {
     #[link(wasm_import_module = "__main_module__")]
@@ -69,6 +126,17 @@ pub unsafe extern "C" fn run() -> u32 {
     0
 }
 
+#[cfg(feature = "proxy")]
+macro_rules! cfg_filesystem_available {
+    ($($t:tt)*) => {
+        wasi::ERRNO_NOTSUP
+    };
+}
+#[cfg(not(feature = "proxy"))]
+macro_rules! cfg_filesystem_available {
+    ($($t:tt)*) => ($($t)*);
+}
+
 // The unwrap/expect methods in std pull panic when they fail, which pulls
 // in unwinding machinery that we can't use in the adapter. Instead, use this
 // extension trait to get postfixed upwrap on Option and Result.
@@ -94,6 +162,34 @@ impl<T, E> TrappingUnwrap<T> for Result<T, E> {
     }
 }
 
+/// Allocate a file descriptor which will generate an `ERRNO_BADF` if passed to
+/// any WASI Preview 1 function implemented by this adapter.
+///
+/// This is intended for use by `wasi-libc` during its incremental transition
+/// from WASI Preview 1 to Preview 2.  It will use this function to reserve
+/// descriptors for its own use, valid only for use with libc functions.
+#[no_mangle]
+pub unsafe extern "C" fn adapter_open_badfd(fd: *mut u32) -> Errno {
+    State::with(|state| {
+        *fd = state.descriptors_mut().open(Descriptor::Bad)?;
+        Ok(())
+    })
+}
+
+/// Close a descriptor previously opened using `adapter_open_badfd`.
+#[no_mangle]
+pub unsafe extern "C" fn adapter_close_badfd(fd: u32) -> Errno {
+    State::with(|state| state.descriptors_mut().close(fd))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn reset_adapter_state() {
+    let state = get_state_ptr();
+    if !state.is_null() {
+        State::init(state)
+    }
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn cabi_import_realloc(
     old_ptr: *mut u8,
@@ -101,171 +197,305 @@ pub unsafe extern "C" fn cabi_import_realloc(
     align: usize,
     new_size: usize,
 ) -> *mut u8 {
-    if !old_ptr.is_null() || old_size != 0 {
-        unreachable!();
-    }
     let mut ptr = null_mut::<u8>();
     State::with(|state| {
-        ptr = state.import_alloc.alloc(align, new_size);
+        let mut alloc = state.import_alloc.replace(ImportAlloc::None);
+        ptr = alloc.alloc(old_ptr, old_size, align, new_size);
+        state.import_alloc.set(alloc);
         Ok(())
     });
     ptr
 }
 
-/// Bump-allocated memory arena. This is a singleton - the
-/// memory will be sized according to `bump_arena_size()`.
-pub struct BumpArena {
-    data: MaybeUninit<[u8; bump_arena_size()]>,
-    position: Cell<usize>,
+/// Different ways that calling imports can allocate memory.
+///
+/// This behavior is used to customize the behavior of `cabi_import_realloc`.
+/// This is configured within `State` whenever an import is called that may
+/// invoke `cabi_import_realloc`.
+///
+/// The general idea behind these various behaviors of import allocation is
+/// that we're limited for space in the adapter here to 1 page of memory but
+/// that may not fit the total sum of arguments, environment variables, and
+/// preopens. WASIp1 APIs all provide user-provided buffers as well for these
+/// allocations so we technically don't need to store them in the adapter
+/// itself. Instead what this does is it tries to copy strings and such directly
+/// into their destination pointers where possible.
+///
+/// The types requiring allocation in the WASIp2 APIs that the WASIp1 APIs call
+/// are relatively simple. They all look like `list<T>` where `T` only has
+/// indirections in the form of `String`. This means that we can apply a
+/// "clever" hack where the alignment of an allocation is used to disambiguate
+/// whether we're allocating a string or allocating the `list<T>` allocation.
+/// This signal with alignment means that we can configure where everything
+/// goes.
+///
+/// For example consider `args_sizes_get` and `args_get`. When `args_sizes_get`
+/// is called the `list<T>` allocation happens first with alignment 4. This
+/// must be valid for the rest of the strings since the canonical ABI will fill
+/// it in, so it's allocated from `State::temporary_data`. Next all other
+/// arguments will be `string` type with alignment 1. These are also allocated
+/// within `State::temporary_data` but they're "allocated on top of one
+/// another" meaning that internal allocator state isn't updated after a string
+/// is allocated. While these strings are discarded their sizes are all summed
+/// up and returned from `args_sizes_get`.
+///
+/// Later though when `args_get` is called it's a similar allocation strategy
+/// except that strings are instead redirected to the allocation provided to
+/// `args_get` itself. This enables strings to be directly allocated into their
+/// destinations.
+///
+/// Overall this means that we're limiting the maximum number of arguments plus
+/// the size of the largest string, but otherwise we're not limiting the total
+/// size of all arguments (or env vars, preopens, etc).
+enum ImportAlloc {
+    /// A single allocation from the provided `BumpAlloc` is supported. After
+    /// the single allocation is performed all future allocations will fail.
+    OneAlloc(BumpAlloc),
+
+    /// An allocator intended for `list<T>` where `T` has string types but no
+    /// other indirections. String allocations are discarded but counted for
+    /// size.
+    ///
+    /// This allocator will use `alloc` for all allocations. Any string-related
+    /// allocation, detected via an alignment of 1, is considered "temporary"
+    /// and doesn't affect the internal state of the allocator. The allocation
+    /// is assumed to not be used after the import call returns.
+    ///
+    /// The total sum of all string sizes, however, is accumulated within
+    /// `strings_size`.
+    CountAndDiscardStrings {
+        strings_size: usize,
+        alloc: BumpAlloc,
+    },
+
+    /// An allocator intended for `list<T>` where `T` has string types but no
+    /// other indirections. String allocations go into `strings` and the
+    /// `list<..>` allocation goes into `pointers`.
+    ///
+    /// This allocator enables placing strings within a caller-supplied buffer
+    /// configured with `strings`. The `pointers` allocation is
+    /// `State::temporary_data`.
+    ///
+    /// This will additionally over-allocate strings with one extra byte to be
+    /// nul-terminated or `=`-terminated in the case of env vars.
+    SeparateStringsAndPointers {
+        strings: BumpAlloc,
+        pointers: BumpAlloc,
+    },
+
+    /// An allocator specifically for getting the nth string allocation used
+    /// for preopens.
+    ///
+    /// This will allocate everything into `alloc`. All strings other than the
+    /// `nth` string, however, will be discarded (the allocator's state is reset
+    /// after the allocation). This means that the pointer returned for the
+    /// `nth` string will be retained in `alloc` while all others will be
+    /// discarded.
+    ///
+    /// The `cur` count starts at 0 and counts up per-string.
+    GetPreopenPath {
+        cur: u32,
+        nth: u32,
+        alloc: BumpAlloc,
+    },
+
+    /// No import allocator is configured and if an allocation happens then
+    /// this will abort.
+    None,
 }
 
-impl BumpArena {
-    fn new() -> Self {
-        BumpArena {
-            data: MaybeUninit::uninit(),
-            position: Cell::new(0),
+impl ImportAlloc {
+    /// To be used by cabi_import_realloc only!
+    unsafe fn alloc(
+        &mut self,
+        old_ptr: *mut u8,
+        old_size: usize,
+        align: usize,
+        size: usize,
+    ) -> *mut u8 {
+        // This is ... a hack. This is a hack in subtle ways that is quite
+        // brittle and may break over time. There's only one case for the
+        // `realloc`-like-behavior in the canonical ABI and that's when the host
+        // is transferring a string to the guest and the host has a different
+        // string encoding. For example JS uses utf-16 (ish) and Rust/WASIp1 use
+        // utf-8. That means that when this adapter is used with a JS host
+        // realloc behavior may be triggered in which case `old_ptr` may not be
+        // null.
+        //
+        // In the case that `old_ptr` may not be null we come to the first
+        // brittle assumption: it's assumed that this is shrinking memory. In
+        // the canonical ABI overlarge allocations are made originally and then
+        // shrunk afterwards once encoding is finished. This means that the
+        // first allocation is too big and the `realloc` call is shrinking
+        // memory. This assumption may be violated in the future if the
+        // canonical ABI is updated to handle growing strings in addition to
+        // shrinking strings. (e.g. starting with an assume-ascii path and then
+        // falling back to an ok-needs-more-space path for larger unicode code
+        // points).
+        //
+        // This comes to the second brittle assumption, nothing happens here
+        // when a shrink happens. This is brittle for each of the cases below,
+        // enumerated here:
+        //
+        // * For `OneAlloc` this isn't the end of the world. That's already
+        //   asserting that only a single string is allocated. Returning the
+        //   original pointer keeps the pointer the same and the host will keep
+        //   track of the appropriate length. In this case the final length is
+        //   read out of the return value of a function, meaning that everything
+        //   actually works out here.
+        //
+        // * For `CountAndDiscardStrings` we're relying on the fact that
+        //   this is only used for `environ_sizes_get` and `args_sizes_get`. In
+        //   both situations we're actually going to return an "overlarge"
+        //   return value for the size of arguments and return values. By
+        //   assuming memory shrinks after the first allocation the return value
+        //   of `environ_sizes_get` and `args_sizes_get` will be the overlong
+        //   approximation for all strings. That means that the final exact size
+        //   won't be what's returned. This ends up being ok because technically
+        //   nothing about WASI says that those blocks have to be exact-sized.
+        //   In our case we're (ab)using that to force the caller to make an
+        //   overlarge return area which we'll allocate into. All-in-all we
+        //   don't track the shrink request and ignore the size.
+        //
+        // * For `SeparateStringsAndPointers` it's similar to the previous case
+        //   except the weird part is that the caller is providing the
+        //   argument/env space buffer to write into. It's over-large because of
+        //   the case of `CountAndDiscardStrings` above, but we'll exploit that
+        //   here and end up having space between all the arguments. Technically
+        //   WASI doesn't say all the strings have to be adjacent, so this
+        //   should work out in practice.
+        //
+        // * Finally for `GetPreopenPath` this works out only insofar that the
+        //   `State::temporary_alloc` space is used to store the path. The
+        //   WASI-provided buffer is precisely sized, not overly large, meaning
+        //   that we're forced to copy from `temporary_alloc` into the
+        //   destination buffer for this WASI call.
+        //
+        // Basically it's a case-by-case basis here that enables ignoring
+        // shrinking return calls here. Not robust.
+        if !old_ptr.is_null() {
+            assert!(old_size > size);
+            assert_eq!(align, 1);
+            return old_ptr;
         }
-    }
-    fn alloc(&self, align: usize, size: usize) -> *mut u8 {
-        let start = self.data.as_ptr() as usize;
-        let next = start + self.position.get();
-        let alloc = align_to(next, align);
-        let offset = alloc - start;
-        if offset + size > bump_arena_size() {
-            unreachable!("out of memory");
+        match self {
+            ImportAlloc::OneAlloc(alloc) => {
+                let ret = alloc.alloc(align, size);
+                *self = ImportAlloc::None;
+                ret
+            }
+            ImportAlloc::SeparateStringsAndPointers { strings, pointers } => {
+                if align == 1 {
+                    strings.alloc(align, size + 1)
+                } else {
+                    pointers.alloc(align, size)
+                }
+            }
+            ImportAlloc::CountAndDiscardStrings {
+                strings_size,
+                alloc,
+            } => {
+                if align == 1 {
+                    *strings_size += size;
+                    alloc.clone().alloc(align, size)
+                } else {
+                    alloc.alloc(align, size)
+                }
+            }
+            ImportAlloc::GetPreopenPath { cur, nth, alloc } => {
+                if align == 1 {
+                    let real_alloc = *nth == *cur;
+                    if real_alloc {
+                        alloc.alloc(align, size)
+                    } else {
+                        alloc.clone().alloc(align, size)
+                    }
+                } else {
+                    alloc.alloc(align, size)
+                }
+            }
+            ImportAlloc::None => {
+                unreachable!("no allocator configured")
+            }
         }
-        self.position.set(offset + size);
-        alloc as *mut u8
     }
 }
-fn align_to(ptr: usize, align: usize) -> usize {
-    (ptr + (align - 1)) & !(align - 1)
-}
 
-// Invariant: buffer not-null and arena is-some are never true at the same
-// time. We did not use an enum to make this invalid behavior unrepresentable
-// because we can't use RefCell to borrow() the variants of the enum - only
-// Cell provides mutability without pulling in panic machinery - so it would
-// make the accessors a lot more awkward to write.
-pub struct ImportAlloc {
-    // When not-null, allocator should use this buffer/len pair at most once
-    // to satisfy allocations.
-    buffer: Cell<*mut u8>,
-    len: Cell<usize>,
-    // When not-empty, allocator should use this arena to satisfy allocations.
-    arena: Cell<Option<&'static BumpArena>>,
+/// Helper type to manage allocations from a `base`/`len` combo.
+///
+/// This isn't really used much in an arena-style per se but it's used in
+/// combination with the `ImportAlloc` flavors above.
+#[derive(Clone)]
+struct BumpAlloc {
+    base: *mut u8,
+    len: usize,
 }
 
-impl ImportAlloc {
-    fn new() -> Self {
-        ImportAlloc {
-            buffer: Cell::new(std::ptr::null_mut()),
-            len: Cell::new(0),
-            arena: Cell::new(None),
+impl BumpAlloc {
+    unsafe fn alloc(&mut self, align: usize, size: usize) -> *mut u8 {
+        self.align_to(align);
+        if size > self.len {
+            unreachable!("allocation size is too large")
         }
+        self.len -= size;
+        let ret = self.base;
+        self.base = ret.add(size);
+        ret
     }
 
-    /// Expect at most one import allocation during execution of the provided closure.
-    /// Use the provided buffer to satisfy that import allocation. The user is responsible
-    /// for making sure allocated imports are not used beyond the lifetime of the buffer.
-    fn with_buffer<T>(&self, buffer: *mut u8, len: usize, f: impl FnOnce() -> T) -> T {
-        if self.arena.get().is_some() {
-            unreachable!("arena mode")
+    unsafe fn align_to(&mut self, align: usize) {
+        if !align.is_power_of_two() {
+            unreachable!("invalid alignment");
         }
-        let prev = self.buffer.replace(buffer);
-        if !prev.is_null() {
-            unreachable!("overwrote another buffer")
-        }
-        self.len.set(len);
-        let r = f();
-        self.buffer.set(std::ptr::null_mut());
-        r
-    }
-
-    /// Permit many import allocations during execution of the provided closure.
-    /// Use the provided BumpArena to satisfry those allocations. The user is responsible
-    /// for making sure allocated imports are not used beyond the lifetime of the arena.
-    fn with_arena<T>(&self, arena: &BumpArena, f: impl FnOnce() -> T) -> T {
-        if !self.buffer.get().is_null() {
-            unreachable!("buffer mode")
-        }
-        let prev = self.arena.replace(Some(unsafe {
-            // Safety: Need to erase the lifetime to store in the arena cell.
-            std::mem::transmute::<&'_ BumpArena, &'static BumpArena>(arena)
-        }));
-        if prev.is_some() {
-            unreachable!("overwrote another arena")
-        }
-        let r = f();
-        self.arena.set(None);
-        r
-    }
-
-    /// To be used by cabi_import_realloc only!
-    fn alloc(&self, align: usize, size: usize) -> *mut u8 {
-        if let Some(arena) = self.arena.get() {
-            arena.alloc(align, size)
-        } else {
-            let buffer = self.buffer.get();
-            if buffer.is_null() {
-                unreachable!("buffer not provided, or already used")
-            }
-            let buffer = buffer as usize;
-            let alloc = align_to(buffer, align);
-            if alloc.checked_add(size).trapping_unwrap()
-                > buffer.checked_add(self.len.get()).trapping_unwrap()
-            {
-                unreachable!("out of memory")
-            }
-            self.buffer.set(std::ptr::null_mut());
-            alloc as *mut u8
+        let align_offset = self.base.align_offset(align);
+        if align_offset >= self.len {
+            unreachable!("failed to allocate")
         }
+        self.len -= align_offset;
+        self.base = self.base.add(align_offset);
     }
 }
 
-/// This allocator is only used for the `run` entrypoint.
-///
-/// The implementation here is a bump allocator into `State::long_lived_arena` which
-/// traps when it runs out of data. This means that the total size of
-/// arguments/env/etc coming into a component is bounded by the current 64k
-/// (ish) limit. That's just an implementation limit though which can be lifted
-/// by dynamically calling the main module's allocator as necessary for more data.
-#[no_mangle]
-pub unsafe extern "C" fn cabi_export_realloc(
-    old_ptr: *mut u8,
-    old_size: usize,
-    align: usize,
-    new_size: usize,
-) -> *mut u8 {
-    if !old_ptr.is_null() || old_size != 0 {
-        unreachable!();
-    }
-    let mut ret = null_mut::<u8>();
-    State::with(|state| {
-        ret = state.long_lived_arena.alloc(align, new_size);
-        Ok(())
-    });
-    ret
+#[cfg(not(feature = "proxy"))]
+#[link(wasm_import_module = "wasi:cli/environment@0.2.1")]
+extern "C" {
+    #[link_name = "get-arguments"]
+    fn wasi_cli_get_arguments(rval: *mut WasmStrList);
+    #[link_name = "get-environment"]
+    fn wasi_cli_get_environment(rval: *mut StrTupleList);
 }
 
 /// Read command-line argument data.
 /// The size of the array should match that returned by `args_sizes_get`
 #[no_mangle]
-pub unsafe extern "C" fn args_get(mut argv: *mut *mut u8, mut argv_buf: *mut u8) -> Errno {
+pub unsafe extern "C" fn args_get(argv: *mut *mut u8, argv_buf: *mut u8) -> Errno {
     State::with(|state| {
-        for arg in state.get_args() {
-            // Copy the argument into `argv_buf` which must be sized
-            // appropriately by the caller.
-            ptr::copy_nonoverlapping(arg.ptr, argv_buf, arg.len);
-            *argv_buf.add(arg.len) = 0;
-
-            // Copy the argument pointer into the `argv` buf
-            *argv = argv_buf;
-
-            // Update our pointers past what's written to prepare for the
-            // next argument.
-            argv = argv.add(1);
-            argv_buf = argv_buf.add(arg.len + 1);
+        #[cfg(not(feature = "proxy"))]
+        {
+            let alloc = ImportAlloc::SeparateStringsAndPointers {
+                strings: BumpAlloc {
+                    base: argv_buf,
+                    len: usize::MAX,
+                },
+                pointers: state.temporary_alloc(),
+            };
+            let (list, _) = state.with_import_alloc(alloc, || unsafe {
+                let mut list = WasmStrList {
+                    base: std::ptr::null(),
+                    len: 0,
+                };
+                wasi_cli_get_arguments(&mut list);
+                list
+            });
+
+            // Fill in `argv` by walking over the returned `list` and then
+            // additionally apply the nul-termination for each argument itself
+            // here.
+            for i in 0..list.len {
+                let s = list.base.add(i).read();
+                *argv.add(i) = s.ptr.cast_mut();
+                *s.ptr.add(s.len).cast_mut() = 0;
+            }
         }
         Ok(())
     })
@@ -275,11 +505,38 @@ pub unsafe extern "C" fn args_get(mut argv: *mut *mut u8, mut argv_buf: *mut u8)
 #[no_mangle]
 pub unsafe extern "C" fn args_sizes_get(argc: *mut Size, argv_buf_size: *mut Size) -> Errno {
     State::with(|state| {
-        let args = state.get_args();
-        *argc = args.len();
-        // Add one to each length for the terminating nul byte added by
-        // the `args_get` function.
-        *argv_buf_size = args.iter().map(|s| s.len + 1).sum();
+        #[cfg(feature = "proxy")]
+        {
+            *argc = 0;
+            *argv_buf_size = 0;
+        }
+        #[cfg(not(feature = "proxy"))]
+        {
+            let alloc = ImportAlloc::CountAndDiscardStrings {
+                strings_size: 0,
+                alloc: state.temporary_alloc(),
+            };
+            let (len, alloc) = state.with_import_alloc(alloc, || unsafe {
+                let mut list = WasmStrList {
+                    base: std::ptr::null(),
+                    len: 0,
+                };
+                wasi_cli_get_arguments(&mut list);
+                list.len
+            });
+            match alloc {
+                ImportAlloc::CountAndDiscardStrings {
+                    strings_size,
+                    alloc: _,
+                } => {
+                    *argc = len;
+                    // add in bytes needed for a 0-byte at the end of each
+                    // argument.
+                    *argv_buf_size = strings_size + len;
+                }
+                _ => unreachable!(),
+            }
+        }
         Ok(())
     })
 }
@@ -287,25 +544,36 @@ pub unsafe extern "C" fn args_sizes_get(argc: *mut Size, argv_buf_size: *mut Siz
 /// Read environment variable data.
 /// The sizes of the buffers should match that returned by `environ_sizes_get`.
 #[no_mangle]
-pub unsafe extern "C" fn environ_get(environ: *mut *mut u8, environ_buf: *mut u8) -> Errno {
+pub unsafe extern "C" fn environ_get(environ: *mut *const u8, environ_buf: *mut u8) -> Errno {
     State::with(|state| {
-        let mut offsets = environ;
-        let mut buffer = environ_buf;
-        for var in state.get_environment() {
-            ptr::write(offsets, buffer);
-            offsets = offsets.add(1);
-
-            ptr::copy_nonoverlapping(var.key.ptr, buffer, var.key.len);
-            buffer = buffer.add(var.key.len);
-
-            ptr::write(buffer, b'=');
-            buffer = buffer.add(1);
-
-            ptr::copy_nonoverlapping(var.value.ptr, buffer, var.value.len);
-            buffer = buffer.add(var.value.len);
+        #[cfg(not(feature = "proxy"))]
+        {
+            let alloc = ImportAlloc::SeparateStringsAndPointers {
+                strings: BumpAlloc {
+                    base: environ_buf,
+                    len: usize::MAX,
+                },
+                pointers: state.temporary_alloc(),
+            };
+            let (list, _) = state.with_import_alloc(alloc, || unsafe {
+                let mut list = StrTupleList {
+                    base: std::ptr::null(),
+                    len: 0,
+                };
+                wasi_cli_get_environment(&mut list);
+                list
+            });
 
-            ptr::write(buffer, 0);
-            buffer = buffer.add(1);
+            // Fill in `environ` by walking over the returned `list`. Strings
+            // are guaranteed to be allocated next to each other with one
+            // extra byte at the end, so also insert the `=` between keys and
+            // the `\0` at the end of the env var.
+            for i in 0..list.len {
+                let s = list.base.add(i).read();
+                *environ.add(i) = s.key.ptr;
+                *s.key.ptr.add(s.key.len).cast_mut() = b'=';
+                *s.value.ptr.add(s.value.len).cast_mut() = 0;
+            }
         }
 
         Ok(())
@@ -318,28 +586,51 @@ pub unsafe extern "C" fn environ_sizes_get(
     environc: *mut Size,
     environ_buf_size: *mut Size,
 ) -> Errno {
-    if matches!(
+    if !matches!(
         get_allocation_state(),
         AllocationState::StackAllocated | AllocationState::StateAllocated
     ) {
-        State::with(|state| {
-            let vars = state.get_environment();
-            *environc = vars.len();
-            *environ_buf_size = {
-                let mut sum = 0;
-                for var in vars {
-                    sum += var.key.len + var.value.len + 2;
-                }
-                sum
-            };
-
-            Ok(())
-        })
-    } else {
         *environc = 0;
         *environ_buf_size = 0;
-        ERRNO_SUCCESS
+        return ERRNO_SUCCESS;
     }
+
+    State::with(|state| {
+        #[cfg(feature = "proxy")]
+        {
+            *environc = 0;
+            *environ_buf_size = 0;
+        }
+        #[cfg(not(feature = "proxy"))]
+        {
+            let alloc = ImportAlloc::CountAndDiscardStrings {
+                strings_size: 0,
+                alloc: state.temporary_alloc(),
+            };
+            let (len, alloc) = state.with_import_alloc(alloc, || unsafe {
+                let mut list = StrTupleList {
+                    base: std::ptr::null(),
+                    len: 0,
+                };
+                wasi_cli_get_environment(&mut list);
+                list.len
+            });
+            match alloc {
+                ImportAlloc::CountAndDiscardStrings {
+                    strings_size,
+                    alloc: _,
+                } => {
+                    *environc = len;
+                    // Account for `=` between keys and a 0-byte at the end of
+                    // each key.
+                    *environ_buf_size = strings_size + 2 * len;
+                }
+                _ => unreachable!(),
+            }
+        }
+
+        Ok(())
+    })
 }
 
 /// Return the resolution of a clock.
@@ -405,34 +696,38 @@ pub unsafe extern "C" fn fd_advise(
     len: Filesize,
     advice: Advice,
 ) -> Errno {
-    let advice = match advice {
-        ADVICE_NORMAL => filesystem::Advice::Normal,
-        ADVICE_SEQUENTIAL => filesystem::Advice::Sequential,
-        ADVICE_RANDOM => filesystem::Advice::Random,
-        ADVICE_WILLNEED => filesystem::Advice::WillNeed,
-        ADVICE_DONTNEED => filesystem::Advice::DontNeed,
-        ADVICE_NOREUSE => filesystem::Advice::NoReuse,
-        _ => return ERRNO_INVAL,
-    };
-    State::with(|state| {
-        let ds = state.descriptors();
-        let file = ds.get_seekable_file(fd)?;
-        file.fd.advise(offset, len, advice)?;
-        Ok(())
-    })
+    cfg_filesystem_available! {
+        let advice = match advice {
+            ADVICE_NORMAL => filesystem::Advice::Normal,
+            ADVICE_SEQUENTIAL => filesystem::Advice::Sequential,
+            ADVICE_RANDOM => filesystem::Advice::Random,
+            ADVICE_WILLNEED => filesystem::Advice::WillNeed,
+            ADVICE_DONTNEED => filesystem::Advice::DontNeed,
+            ADVICE_NOREUSE => filesystem::Advice::NoReuse,
+            _ => return ERRNO_INVAL,
+        };
+        State::with(|state| {
+            let ds = state.descriptors();
+            let file = ds.get_seekable_file(fd)?;
+            file.fd.advise(offset, len, advice)?;
+            Ok(())
+        })
+    }
 }
 
 /// Force the allocation of space in a file.
 /// Note: This is similar to `posix_fallocate` in POSIX.
 #[no_mangle]
 pub unsafe extern "C" fn fd_allocate(fd: Fd, _offset: Filesize, _len: Filesize) -> Errno {
-    State::with(|state| {
-        let ds = state.descriptors();
-        // For not-files, fail with BADF
-        ds.get_file(fd)?;
-        // For all files, fail with NOTSUP, because this call does not exist in preview 2.
-        Err(wasi::ERRNO_NOTSUP)
-    })
+    cfg_filesystem_available! {
+        State::with(|state| {
+            let ds = state.descriptors();
+            // For not-files, fail with BADF
+            ds.get_file(fd)?;
+            // For all files, fail with NOTSUP, because this call does not exist in preview 2.
+            Err(wasi::ERRNO_NOTSUP)
+        })
+    }
 }
 
 /// Close a file descriptor.
@@ -440,9 +735,14 @@ pub unsafe extern "C" fn fd_allocate(fd: Fd, _offset: Filesize, _len: Filesize)
 #[no_mangle]
 pub unsafe extern "C" fn fd_close(fd: Fd) -> Errno {
     State::with(|state| {
+        if let Descriptor::Bad = state.descriptors().get(fd)? {
+            return Err(wasi::ERRNO_BADF);
+        }
+
         // If there's a dirent cache entry for this file descriptor then drop
         // it since the descriptor is being closed and future calls to
         // `fd_readdir` should return an error.
+        #[cfg(not(feature = "proxy"))]
         if fd == state.dirent_cache.for_fd.get() {
             drop(state.dirent_cache.stream.replace(None));
         }
@@ -456,138 +756,138 @@ pub unsafe extern "C" fn fd_close(fd: Fd) -> Errno {
 /// Note: This is similar to `fdatasync` in POSIX.
 #[no_mangle]
 pub unsafe extern "C" fn fd_datasync(fd: Fd) -> Errno {
-    State::with(|state| {
-        let ds = state.descriptors();
-        let file = ds.get_file(fd)?;
-        file.fd.sync_data()?;
-        Ok(())
-    })
+    cfg_filesystem_available! {
+        State::with(|state| {
+            let ds = state.descriptors();
+            let file = ds.get_file(fd)?;
+            file.fd.sync_data()?;
+            Ok(())
+        })
+    }
 }
 
 /// Get the attributes of a file descriptor.
 /// Note: This returns similar flags to `fsync(fd, F_GETFL)` in POSIX, as well as additional fields.
 #[no_mangle]
 pub unsafe extern "C" fn fd_fdstat_get(fd: Fd, stat: *mut Fdstat) -> Errno {
-    State::with(|state| {
-        let ds = state.descriptors();
-        match ds.get(fd)? {
-            Descriptor::Streams(Streams {
-                type_: StreamType::File(file),
-                ..
-            }) => {
-                let flags = file.fd.get_flags()?;
-                let type_ = file.fd.get_type()?;
-                match type_ {
-                    filesystem::DescriptorType::Directory => {
-                        // Hard-coded set of rights expected by many userlands:
-                        let fs_rights_base = wasi::RIGHTS_PATH_CREATE_DIRECTORY
-                            | wasi::RIGHTS_PATH_CREATE_FILE
-                            | wasi::RIGHTS_PATH_LINK_SOURCE
-                            | wasi::RIGHTS_PATH_LINK_TARGET
-                            | wasi::RIGHTS_PATH_OPEN
-                            | wasi::RIGHTS_FD_READDIR
-                            | wasi::RIGHTS_PATH_READLINK
-                            | wasi::RIGHTS_PATH_RENAME_SOURCE
-                            | wasi::RIGHTS_PATH_RENAME_TARGET
-                            | wasi::RIGHTS_PATH_SYMLINK
-                            | wasi::RIGHTS_PATH_REMOVE_DIRECTORY
-                            | wasi::RIGHTS_PATH_UNLINK_FILE
-                            | wasi::RIGHTS_PATH_FILESTAT_GET
-                            | wasi::RIGHTS_PATH_FILESTAT_SET_TIMES
-                            | wasi::RIGHTS_FD_FILESTAT_GET
-                            | wasi::RIGHTS_FD_FILESTAT_SET_TIMES;
-
-                        let fs_rights_inheriting = fs_rights_base
-                            | wasi::RIGHTS_FD_DATASYNC
-                            | wasi::RIGHTS_FD_READ
-                            | wasi::RIGHTS_FD_SEEK
-                            | wasi::RIGHTS_FD_FDSTAT_SET_FLAGS
-                            | wasi::RIGHTS_FD_SYNC
-                            | wasi::RIGHTS_FD_TELL
-                            | wasi::RIGHTS_FD_WRITE
-                            | wasi::RIGHTS_FD_ADVISE
-                            | wasi::RIGHTS_FD_ALLOCATE
-                            | wasi::RIGHTS_FD_FILESTAT_GET
-                            | wasi::RIGHTS_FD_FILESTAT_SET_SIZE
-                            | wasi::RIGHTS_FD_FILESTAT_SET_TIMES
-                            | wasi::RIGHTS_POLL_FD_READWRITE;
-
-                        stat.write(Fdstat {
-                            fs_filetype: wasi::FILETYPE_DIRECTORY,
-                            fs_flags: 0,
-                            fs_rights_base,
-                            fs_rights_inheriting,
-                        });
-                        Ok(())
-                    }
-                    _ => {
-                        let fs_filetype = type_.into();
-
-                        let mut fs_flags = 0;
-                        let mut fs_rights_base = !0;
-                        if !flags.contains(filesystem::DescriptorFlags::READ) {
-                            fs_rights_base &= !RIGHTS_FD_READ;
-                        }
-                        if !flags.contains(filesystem::DescriptorFlags::WRITE) {
-                            fs_rights_base &= !RIGHTS_FD_WRITE;
-                        }
-                        if flags.contains(filesystem::DescriptorFlags::DATA_INTEGRITY_SYNC) {
-                            fs_flags |= FDFLAGS_DSYNC;
-                        }
-                        if flags.contains(filesystem::DescriptorFlags::REQUESTED_WRITE_SYNC) {
-                            fs_flags |= FDFLAGS_RSYNC;
-                        }
-                        if flags.contains(filesystem::DescriptorFlags::FILE_INTEGRITY_SYNC) {
-                            fs_flags |= FDFLAGS_SYNC;
-                        }
-                        if file.append {
-                            fs_flags |= FDFLAGS_APPEND;
+    cfg_filesystem_available! {
+        State::with(|state| {
+            let ds = state.descriptors();
+            match ds.get(fd)? {
+                Descriptor::Streams(Streams {
+                    type_: StreamType::File(file),
+                    ..
+                }) => {
+                    let flags = file.fd.get_flags()?;
+                    let type_ = file.fd.get_type()?;
+                    match type_ {
+                        filesystem::DescriptorType::Directory => {
+                            // Hard-coded set of rights expected by many userlands:
+                            let fs_rights_base = wasi::RIGHTS_PATH_CREATE_DIRECTORY
+                                | wasi::RIGHTS_PATH_CREATE_FILE
+                                | wasi::RIGHTS_PATH_LINK_SOURCE
+                                | wasi::RIGHTS_PATH_LINK_TARGET
+                                | wasi::RIGHTS_PATH_OPEN
+                                | wasi::RIGHTS_FD_READDIR
+                                | wasi::RIGHTS_PATH_READLINK
+                                | wasi::RIGHTS_PATH_RENAME_SOURCE
+                                | wasi::RIGHTS_PATH_RENAME_TARGET
+                                | wasi::RIGHTS_PATH_SYMLINK
+                                | wasi::RIGHTS_PATH_REMOVE_DIRECTORY
+                                | wasi::RIGHTS_PATH_UNLINK_FILE
+                                | wasi::RIGHTS_PATH_FILESTAT_GET
+                                | wasi::RIGHTS_PATH_FILESTAT_SET_TIMES
+                                | wasi::RIGHTS_FD_FILESTAT_GET
+                                | wasi::RIGHTS_FD_FILESTAT_SET_TIMES;
+
+                            let fs_rights_inheriting = fs_rights_base
+                                | wasi::RIGHTS_FD_DATASYNC
+                                | wasi::RIGHTS_FD_READ
+                                | wasi::RIGHTS_FD_SEEK
+                                | wasi::RIGHTS_FD_FDSTAT_SET_FLAGS
+                                | wasi::RIGHTS_FD_SYNC
+                                | wasi::RIGHTS_FD_TELL
+                                | wasi::RIGHTS_FD_WRITE
+                                | wasi::RIGHTS_FD_ADVISE
+                                | wasi::RIGHTS_FD_ALLOCATE
+                                | wasi::RIGHTS_FD_FILESTAT_GET
+                                | wasi::RIGHTS_FD_FILESTAT_SET_SIZE
+                                | wasi::RIGHTS_FD_FILESTAT_SET_TIMES
+                                | wasi::RIGHTS_POLL_FD_READWRITE;
+
+                            stat.write(Fdstat {
+                                fs_filetype: wasi::FILETYPE_DIRECTORY,
+                                fs_flags: 0,
+                                fs_rights_base,
+                                fs_rights_inheriting,
+                            });
+                            Ok(())
                         }
-                        if matches!(file.blocking_mode, BlockingMode::NonBlocking) {
-                            fs_flags |= FDFLAGS_NONBLOCK;
+                        _ => {
+                            let fs_filetype = type_.into();
+
+                            let mut fs_flags = 0;
+                            let mut fs_rights_base = !0;
+                            if !flags.contains(filesystem::DescriptorFlags::READ) {
+                                fs_rights_base &= !RIGHTS_FD_READ;
+                                fs_rights_base &= !RIGHTS_FD_READDIR;
+                            }
+                            if !flags.contains(filesystem::DescriptorFlags::WRITE) {
+                                fs_rights_base &= !RIGHTS_FD_WRITE;
+                            }
+                            if flags.contains(filesystem::DescriptorFlags::DATA_INTEGRITY_SYNC) {
+                                fs_flags |= FDFLAGS_DSYNC;
+                            }
+                            if flags.contains(filesystem::DescriptorFlags::REQUESTED_WRITE_SYNC) {
+                                fs_flags |= FDFLAGS_RSYNC;
+                            }
+                            if flags.contains(filesystem::DescriptorFlags::FILE_INTEGRITY_SYNC) {
+                                fs_flags |= FDFLAGS_SYNC;
+                            }
+                            if file.append {
+                                fs_flags |= FDFLAGS_APPEND;
+                            }
+                            if matches!(file.blocking_mode, BlockingMode::NonBlocking) {
+                                fs_flags |= FDFLAGS_NONBLOCK;
+                            }
+                            let fs_rights_inheriting = fs_rights_base;
+
+                            stat.write(Fdstat {
+                                fs_filetype,
+                                fs_flags,
+                                fs_rights_base,
+                                fs_rights_inheriting,
+                            });
+                            Ok(())
                         }
-                        let fs_rights_inheriting = fs_rights_base;
-
-                        stat.write(Fdstat {
-                            fs_filetype,
-                            fs_flags,
-                            fs_rights_base,
-                            fs_rights_inheriting,
-                        });
-                        Ok(())
                     }
                 }
-            }
-            Descriptor::Streams(Streams {
-                input,
-                output,
-                type_: StreamType::Stdio(isatty),
-            }) => {
-                let fs_flags = 0;
-                let mut fs_rights_base = 0;
-                if input.get().is_some() {
-                    fs_rights_base |= RIGHTS_FD_READ;
-                }
-                if output.get().is_some() {
-                    fs_rights_base |= RIGHTS_FD_WRITE;
+                Descriptor::Streams(Streams {
+                    input,
+                    output,
+                    type_: StreamType::Stdio(stdio),
+                }) => {
+                    let fs_flags = 0;
+                    let mut fs_rights_base = 0;
+                    if input.get().is_some() {
+                        fs_rights_base |= RIGHTS_FD_READ;
+                    }
+                    if output.get().is_some() {
+                        fs_rights_base |= RIGHTS_FD_WRITE;
+                    }
+                    let fs_rights_inheriting = fs_rights_base;
+                    stat.write(Fdstat {
+                        fs_filetype: stdio.filetype(),
+                        fs_flags,
+                        fs_rights_base,
+                        fs_rights_inheriting,
+                    });
+                    Ok(())
                 }
-                let fs_rights_inheriting = fs_rights_base;
-                stat.write(Fdstat {
-                    fs_filetype: isatty.filetype(),
-                    fs_flags,
-                    fs_rights_base,
-                    fs_rights_inheriting,
-                });
-                Ok(())
+                Descriptor::Closed(_) | Descriptor::Bad => Err(ERRNO_BADF),
             }
-            Descriptor::Closed(_) => Err(ERRNO_BADF),
-            Descriptor::Streams(Streams {
-                input: _,
-                output: _,
-                type_: StreamType::Socket(_),
-            }) => unreachable!(),
-        }
-    })
+        })
+    }
 }
 
 /// Adjust the flags associated with a file descriptor.
@@ -599,23 +899,25 @@ pub unsafe extern "C" fn fd_fdstat_set_flags(fd: Fd, flags: Fdflags) -> Errno {
         return wasi::ERRNO_INVAL;
     }
 
-    State::with(|state| {
-        let mut ds = state.descriptors_mut();
-        let file = match ds.get_mut(fd)? {
-            Descriptor::Streams(Streams {
-                type_: StreamType::File(file),
-                ..
-            }) if !file.is_dir() => file,
-            _ => Err(wasi::ERRNO_BADF)?,
-        };
-        file.append = flags & FDFLAGS_APPEND == FDFLAGS_APPEND;
-        file.blocking_mode = if flags & FDFLAGS_NONBLOCK == FDFLAGS_NONBLOCK {
-            BlockingMode::NonBlocking
-        } else {
-            BlockingMode::Blocking
-        };
-        Ok(())
-    })
+    cfg_filesystem_available! {
+        State::with(|state| {
+            let mut ds = state.descriptors_mut();
+            let file = match ds.get_mut(fd)? {
+                Descriptor::Streams(Streams {
+                    type_: StreamType::File(file),
+                    ..
+                }) if !file.is_dir() => file,
+                _ => Err(wasi::ERRNO_BADF)?,
+            };
+            file.append = flags & FDFLAGS_APPEND == FDFLAGS_APPEND;
+            file.blocking_mode = if flags & FDFLAGS_NONBLOCK == FDFLAGS_NONBLOCK {
+                BlockingMode::NonBlocking
+            } else {
+                BlockingMode::Blocking
+            };
+            Ok(())
+        })
+    }
 }
 
 /// Does not do anything if `fd` corresponds to a valid descriptor and returns [`wasi::ERRNO_BADF`] otherwise.
@@ -629,7 +931,7 @@ pub unsafe extern "C" fn fd_fdstat_set_rights(
         let ds = state.descriptors();
         match ds.get(fd)? {
             Descriptor::Streams(..) => Ok(()),
-            Descriptor::Closed(..) => Err(wasi::ERRNO_BADF),
+            Descriptor::Closed(..) | Descriptor::Bad => Err(wasi::ERRNO_BADF),
         }
     })
 }
@@ -637,62 +939,67 @@ pub unsafe extern "C" fn fd_fdstat_set_rights(
 /// Return the attributes of an open file.
 #[no_mangle]
 pub unsafe extern "C" fn fd_filestat_get(fd: Fd, buf: *mut Filestat) -> Errno {
-    State::with(|state| {
-        let ds = state.descriptors();
-        match ds.get(fd)? {
-            Descriptor::Streams(Streams {
-                type_: StreamType::File(file),
-                ..
-            }) => {
-                let stat = file.fd.stat()?;
-                let metadata_hash = file.fd.metadata_hash()?;
-                let filetype = stat.type_.into();
-                *buf = Filestat {
-                    dev: 1,
-                    ino: metadata_hash.lower,
-                    filetype,
-                    nlink: stat.link_count,
-                    size: stat.size,
-                    atim: datetime_to_timestamp(stat.data_access_timestamp),
-                    mtim: datetime_to_timestamp(stat.data_modification_timestamp),
-                    ctim: datetime_to_timestamp(stat.status_change_timestamp),
-                };
-                Ok(())
-            }
-            // Stdio is all zero fields, except for filetype character device
-            Descriptor::Streams(Streams {
-                type_: StreamType::Stdio(isatty),
-                ..
-            }) => {
-                *buf = Filestat {
-                    dev: 0,
-                    ino: 0,
-                    filetype: isatty.filetype(),
-                    nlink: 0,
-                    size: 0,
-                    atim: 0,
-                    mtim: 0,
-                    ctim: 0,
-                };
-                Ok(())
+    cfg_filesystem_available! {
+        State::with(|state| {
+            let ds = state.descriptors();
+            match ds.get(fd)? {
+                Descriptor::Streams(Streams {
+                    type_: StreamType::File(file),
+                    ..
+                }) => {
+                    let stat = file.fd.stat()?;
+                    let metadata_hash = file.fd.metadata_hash()?;
+                    let filetype = stat.type_.into();
+                    *buf = Filestat {
+                        dev: 1,
+                        ino: metadata_hash.lower,
+                        filetype,
+                        nlink: stat.link_count,
+                        size: stat.size,
+                        atim: datetime_to_timestamp(stat.data_access_timestamp),
+                        mtim: datetime_to_timestamp(stat.data_modification_timestamp),
+                        ctim: datetime_to_timestamp(stat.status_change_timestamp),
+                    };
+                    Ok(())
+                }
+                // Stdio is all zero fields, except for filetype character device
+                Descriptor::Streams(Streams {
+                    type_: StreamType::Stdio(stdio),
+                    ..
+                }) => {
+                    *buf = Filestat {
+                        dev: 0,
+                        ino: 0,
+                        filetype: stdio.filetype(),
+                        nlink: 0,
+                        size: 0,
+                        atim: 0,
+                        mtim: 0,
+                        ctim: 0,
+                    };
+                    Ok(())
+                }
+                _ => Err(wasi::ERRNO_BADF),
             }
-            _ => Err(wasi::ERRNO_BADF),
-        }
-    })
+        })
+    }
 }
 
 /// Adjust the size of an open file. If this increases the file's size, the extra bytes are filled with zeros.
 /// Note: This is similar to `ftruncate` in POSIX.
 #[no_mangle]
 pub unsafe extern "C" fn fd_filestat_set_size(fd: Fd, size: Filesize) -> Errno {
-    State::with(|state| {
-        let ds = state.descriptors();
-        let file = ds.get_file(fd)?;
-        file.fd.set_size(size)?;
-        Ok(())
-    })
+    cfg_filesystem_available! {
+        State::with(|state| {
+            let ds = state.descriptors();
+            let file = ds.get_file(fd)?;
+            file.fd.set_size(size)?;
+            Ok(())
+        })
+    }
 }
 
+#[cfg(not(feature = "proxy"))]
 fn systimespec(set: bool, ts: Timestamp, now: bool) -> Result<filesystem::NewTimestamp, Errno> {
     if set && now {
         Err(wasi::ERRNO_INVAL)
@@ -717,22 +1024,24 @@ pub unsafe extern "C" fn fd_filestat_set_times(
     mtim: Timestamp,
     fst_flags: Fstflags,
 ) -> Errno {
-    State::with(|state| {
-        let atim = systimespec(
-            fst_flags & FSTFLAGS_ATIM == FSTFLAGS_ATIM,
-            atim,
-            fst_flags & FSTFLAGS_ATIM_NOW == FSTFLAGS_ATIM_NOW,
-        )?;
-        let mtim = systimespec(
-            fst_flags & FSTFLAGS_MTIM == FSTFLAGS_MTIM,
-            mtim,
-            fst_flags & FSTFLAGS_MTIM_NOW == FSTFLAGS_MTIM_NOW,
-        )?;
-        let ds = state.descriptors();
-        let file = ds.get_file(fd)?;
-        file.fd.set_times(atim, mtim)?;
-        Ok(())
-    })
+    cfg_filesystem_available! {
+        State::with(|state| {
+            let atim = systimespec(
+                fst_flags & FSTFLAGS_ATIM == FSTFLAGS_ATIM,
+                atim,
+                fst_flags & FSTFLAGS_ATIM_NOW == FSTFLAGS_ATIM_NOW,
+            )?;
+            let mtim = systimespec(
+                fst_flags & FSTFLAGS_MTIM == FSTFLAGS_MTIM,
+                mtim,
+                fst_flags & FSTFLAGS_MTIM_NOW == FSTFLAGS_MTIM_NOW,
+            )?;
+            let ds = state.descriptors();
+            let file = ds.get_file(fd)?;
+            file.fd.set_times(atim, mtim)?;
+            Ok(())
+        })
+    }
 }
 
 /// Read from a file descriptor, without using and updating the file descriptor's offset.
@@ -745,84 +1054,109 @@ pub unsafe extern "C" fn fd_pread(
     offset: Filesize,
     nread: *mut Size,
 ) -> Errno {
-    // Advance to the first non-empty buffer.
-    while iovs_len != 0 && (*iovs_ptr).buf_len == 0 {
-        iovs_ptr = iovs_ptr.add(1);
-        iovs_len -= 1;
-    }
-    if iovs_len == 0 {
-        *nread = 0;
-        return ERRNO_SUCCESS;
-    }
+    cfg_filesystem_available! {
+        // Skip leading non-empty buffers.
+        while iovs_len > 1 && (*iovs_ptr).buf_len == 0 {
+            iovs_ptr = iovs_ptr.add(1);
+            iovs_len -= 1;
+        }
+        if iovs_len == 0 {
+            *nread = 0;
+            return ERRNO_SUCCESS;
+        }
 
-    State::with(|state| {
-        let ptr = (*iovs_ptr).buf;
-        let len = (*iovs_ptr).buf_len;
+        State::with(|state| {
+            let ptr = (*iovs_ptr).buf;
+            let len = (*iovs_ptr).buf_len;
 
-        let ds = state.descriptors();
-        let file = ds.get_file(fd)?;
-        let (data, end) = state
-            .import_alloc
-            .with_buffer(ptr, len, || file.fd.read(len as u64, offset))?;
-        assert_eq!(data.as_ptr(), ptr);
-        assert!(data.len() <= len);
-
-        let len = data.len();
-        forget(data);
-        if !end && len == 0 {
-            Err(ERRNO_INTR)
-        } else {
-            *nread = len;
-            Ok(())
-        }
-    })
+            let ds = state.descriptors();
+            let file = ds.get_file(fd)?;
+            let (data, end) = state
+                .with_one_import_alloc(ptr, len, || file.fd.read(len as u64, offset))?;
+            assert_eq!(data.as_ptr(), ptr);
+            assert!(data.len() <= len);
+
+            let len = data.len();
+            forget(data);
+            if !end && len == 0 {
+                Err(ERRNO_INTR)
+            } else {
+                *nread = len;
+                Ok(())
+            }
+        })
+    }
 }
 
 /// Return a description of the given preopened file descriptor.
 #[no_mangle]
 pub unsafe extern "C" fn fd_prestat_get(fd: Fd, buf: *mut Prestat) -> Errno {
-    if matches!(
+    if !matches!(
         get_allocation_state(),
         AllocationState::StackAllocated | AllocationState::StateAllocated
     ) {
+        return ERRNO_BADF;
+    }
+
+    // For the proxy adapter don't return `ERRNO_NOTSUP` through below, instead
+    // always return `ERRNO_BADF` which is the indicator that prestats aren't
+    // available.
+    if cfg!(feature = "proxy") {
+        return ERRNO_BADF;
+    }
+
+    cfg_filesystem_available! {
         State::with(|state| {
             let ds = state.descriptors();
-            if let Some(preopen) = ds.get_preopen(fd) {
-                buf.write(Prestat {
-                    tag: 0,
-                    u: PrestatU {
-                        dir: PrestatDir {
-                            pr_name_len: preopen.path.len,
+            match ds.get(fd)? {
+                Descriptor::Streams(Streams {
+                    type_: StreamType::File(File {
+                        preopen_name_len: Some(len),
+                        ..
+                    }),
+                    ..
+                }) => {
+                    buf.write(Prestat {
+                        tag: 0,
+                        u: PrestatU {
+                            dir: PrestatDir {
+                                pr_name_len: len.get(),
+                            },
                         },
-                    },
-                });
+                    });
 
-                Ok(())
-            } else {
-                Err(ERRNO_BADF)
+                    Ok(())
+                }
+                _ => Err(ERRNO_BADF),
             }
         })
-    } else {
-        ERRNO_BADF
     }
 }
 
 /// Return a description of the given preopened file descriptor.
 #[no_mangle]
 pub unsafe extern "C" fn fd_prestat_dir_name(fd: Fd, path: *mut u8, path_max_len: Size) -> Errno {
-    State::with(|state| {
-        let ds = state.descriptors();
-        if let Some(preopen) = ds.get_preopen(fd) {
-            if preopen.path.len > path_max_len as usize {
-                Err(ERRNO_NAMETOOLONG)
-            } else {
-                ptr::copy_nonoverlapping(preopen.path.ptr, path, preopen.path.len);
-                Ok(())
+    cfg_filesystem_available! {
+        State::with(|state| {
+            let ds = state.descriptors();
+            let preopen_len = match ds.get(fd)? {
+                Descriptor::Streams(Streams {
+                    type_: StreamType::File(File {
+                        preopen_name_len: Some(len),
+                        ..
+                    }),
+                    ..
+                }) => len.get(),
+                _ => return Err(ERRNO_BADF),
+            };
+            if preopen_len > path_max_len {
+                return Err(ERRNO_NAMETOOLONG)
             }
-        } else {
-            Err(ERRNO_NOTDIR)
-        }
-    })
+
+            ds.get_preopen_path(state, fd, path, path_max_len);
+            Ok(())
+        })
+    }
 }
 
 /// Write to a file descriptor, without using and updating the file descriptor's offset.
@@ -835,26 +1169,39 @@ pub unsafe extern "C" fn fd_pwrite(
     offset: Filesize,
     nwritten: *mut Size,
 ) -> Errno {
-    // Advance to the first non-empty buffer.
-    while iovs_len != 0 && (*iovs_ptr).buf_len == 0 {
-        iovs_ptr = iovs_ptr.add(1);
-        iovs_len -= 1;
-    }
-    if iovs_len == 0 {
-        *nwritten = 0;
-        return ERRNO_SUCCESS;
-    }
+    cfg_filesystem_available! {
+        // Skip leading non-empty buffers.
+        while iovs_len > 1 && (*iovs_ptr).buf_len == 0 {
+            iovs_ptr = iovs_ptr.add(1);
+            iovs_len -= 1;
+        }
+        if iovs_len == 0 {
+            *nwritten = 0;
+            return ERRNO_SUCCESS;
+        }
 
-    let ptr = (*iovs_ptr).buf;
-    let len = (*iovs_ptr).buf_len;
+        let ptr = (*iovs_ptr).buf;
+        let len = (*iovs_ptr).buf_len;
 
-    State::with(|state| {
-        let ds = state.descriptors();
-        let file = ds.get_seekable_file(fd)?;
-        let bytes = file.fd.write(slice::from_raw_parts(ptr, len), offset)?;
-        *nwritten = bytes as usize;
-        Ok(())
-    })
+        State::with(|state| {
+            let ds = state.descriptors();
+            let file = ds.get_seekable_file(fd)?;
+            let bytes = slice::from_raw_parts(ptr, len);
+            let bytes = if file.append {
+                match file.fd.append_via_stream()?.blocking_write_and_flush(bytes) {
+                    Ok(()) => bytes.len(),
+                    Err(streams::StreamError::Closed) => 0,
+                    Err(streams::StreamError::LastOperationFailed(e)) => {
+                        return Err(stream_error_to_errno(e))
+                    }
+                }
+            } else {
+                file.fd.write(bytes, offset)? as usize
+            };
+            *nwritten = bytes;
+            Ok(())
+        })
+    }
 }
 
 /// Read from a file descriptor.
@@ -866,8 +1213,8 @@ pub unsafe extern "C" fn fd_read(
     mut iovs_len: usize,
     nread: *mut Size,
 ) -> Errno {
-    // Advance to the first non-empty buffer.
-    while iovs_len != 0 && (*iovs_ptr).buf_len == 0 {
+    // Skip leading non-empty buffers.
+    while iovs_len > 1 && (*iovs_ptr).buf_len == 0 {
         iovs_ptr = iovs_ptr.add(1);
         iovs_len -= 1;
     }
@@ -883,36 +1230,38 @@ pub unsafe extern "C" fn fd_read(
         let ds = state.descriptors();
         match ds.get(fd)? {
             Descriptor::Streams(streams) => {
+                #[cfg(not(feature = "proxy"))]
                 let blocking_mode = if let StreamType::File(file) = &streams.type_ {
                     file.blocking_mode
                 } else {
                     BlockingMode::Blocking
                 };
+                #[cfg(feature = "proxy")]
+                let blocking_mode = BlockingMode::Blocking;
 
                 let read_len = u64::try_from(len).trapping_unwrap();
                 let wasi_stream = streams.get_read_stream()?;
                 let data = match state
-                    .import_alloc
-                    .with_buffer(ptr, len, || blocking_mode.read(wasi_stream, read_len))
+                    .with_one_import_alloc(ptr, len, || blocking_mode.read(wasi_stream, read_len))
                 {
                     Ok(data) => data,
                     Err(streams::StreamError::Closed) => {
                         *nread = 0;
                         return Ok(());
                     }
-                    Err(_) => Err(ERRNO_IO)?,
+                    Err(streams::StreamError::LastOperationFailed(e)) => {
+                        Err(stream_error_to_errno(e))?
+                    }
                 };
 
                 assert_eq!(data.as_ptr(), ptr);
                 assert!(data.len() <= len);
 
                 // If this is a file, keep the current-position pointer up to date.
+                #[cfg(not(feature = "proxy"))]
                 if let StreamType::File(file) = &streams.type_ {
                     file.position
                         .set(file.position.get() + data.len() as filesystem::Filesize);
-                    if len == 0 {
-                        return Err(ERRNO_INTR);
-                    }
                 }
 
                 let len = data.len();
@@ -920,11 +1269,21 @@ pub unsafe extern "C" fn fd_read(
                 forget(data);
                 Ok(())
             }
-            Descriptor::Closed(_) => Err(ERRNO_BADF),
+            Descriptor::Closed(_) | Descriptor::Bad => Err(ERRNO_BADF),
         }
     })
 }
 
+fn stream_error_to_errno(err: streams::Error) -> Errno {
+    #[cfg(feature = "proxy")]
+    return ERRNO_IO;
+    #[cfg(not(feature = "proxy"))]
+    match filesystem::filesystem_error_code(&err) {
+        Some(code) => code.into(),
+        None => ERRNO_IO,
+    }
+}
+
 /// Read directory entries from a directory.
 /// When successful, the contents of the output buffer consist of a sequence of
 /// directory entries. Each directory entry consists of a `dirent` object,
@@ -935,6 +1294,19 @@ pub unsafe extern "C" fn fd_read(
 /// read buffer size in case it's too small to fit a single large directory
 /// entry, or skip the oversized directory entry.
 #[no_mangle]
+#[cfg(feature = "proxy")]
+pub unsafe extern "C" fn fd_readdir(
+    fd: Fd,
+    buf: *mut u8,
+    buf_len: Size,
+    cookie: Dircookie,
+    bufused: *mut Size,
+) -> Errno {
+    wasi::ERRNO_NOTSUP
+}
+
+#[no_mangle]
+#[cfg(not(feature = "proxy"))]
 pub unsafe extern "C" fn fd_readdir(
     fd: Fd,
     buf: *mut u8,
@@ -1126,11 +1498,9 @@ pub unsafe extern "C" fn fd_readdir(
                     Ok((dirent, buffer))
                 });
             }
-            let entry = self.state.import_alloc.with_buffer(
-                self.state.path_buf.get().cast(),
-                PATH_MAX,
-                || self.stream.0.read_directory_entry(),
-            );
+            let entry = self
+                .state
+                .with_one_temporary_alloc(|| self.stream.0.read_directory_entry());
             let entry = match entry {
                 Ok(Some(entry)) => entry,
                 Ok(None) => return None,
@@ -1153,7 +1523,7 @@ pub unsafe extern "C" fn fd_readdir(
             // Extend the lifetime of `name` to the `self.state` lifetime for
             // this iterator since the data for the name lives within state.
             let name = unsafe {
-                assert_eq!(name.as_ptr(), self.state.path_buf.get().cast());
+                assert_eq!(name.as_ptr(), self.state.temporary_data.get().cast());
                 slice::from_raw_parts(name.as_ptr().cast(), name.len())
             };
             Some(Ok((dirent, name)))
@@ -1183,62 +1553,68 @@ pub unsafe extern "C" fn fd_seek(
     whence: Whence,
     newoffset: *mut Filesize,
 ) -> Errno {
-    State::with(|state| {
-        let mut ds = state.descriptors_mut();
-        let stream = ds.get_seekable_stream_mut(fd)?;
-
-        // Seeking only works on files.
-        if let StreamType::File(file) = &mut stream.type_ {
-            if let filesystem::DescriptorType::Directory = file.descriptor_type {
-                // This isn't really the "right" errno, but it is consistient with wasmtime's
-                // preview 1 tests.
-                return Err(ERRNO_BADF);
-            }
-            let from = match whence {
-                WHENCE_SET if offset >= 0 => offset,
-                WHENCE_CUR => match (file.position.get() as i64).checked_add(offset) {
-                    Some(pos) if pos >= 0 => pos,
-                    _ => return Err(ERRNO_INVAL),
-                },
-                WHENCE_END => match (file.fd.stat()?.size as i64).checked_add(offset) {
-                    Some(pos) if pos >= 0 => pos,
+    cfg_filesystem_available! {
+        State::with(|state| {
+            let mut ds = state.descriptors_mut();
+            let stream = ds.get_seekable_stream_mut(fd)?;
+
+            // Seeking only works on files.
+            if let StreamType::File(file) = &mut stream.type_ {
+                if let filesystem::DescriptorType::Directory = file.descriptor_type {
+                    // This isn't really the "right" errno, but it is consistient with wasmtime's
+                    // preview 1 tests.
+                    return Err(ERRNO_BADF);
+                }
+                let from = match whence {
+                    WHENCE_SET if offset >= 0 => offset,
+                    WHENCE_CUR => match (file.position.get() as i64).checked_add(offset) {
+                        Some(pos) if pos >= 0 => pos,
+                        _ => return Err(ERRNO_INVAL),
+                    },
+                    WHENCE_END => match (file.fd.stat()?.size as i64).checked_add(offset) {
+                        Some(pos) if pos >= 0 => pos,
+                        _ => return Err(ERRNO_INVAL),
+                    },
                     _ => return Err(ERRNO_INVAL),
-                },
-                _ => return Err(ERRNO_INVAL),
-            };
-            drop(stream.input.take());
-            drop(stream.output.take());
-            file.position.set(from as filesystem::Filesize);
-            *newoffset = from as filesystem::Filesize;
-            Ok(())
-        } else {
-            Err(ERRNO_SPIPE)
-        }
-    })
+                };
+                drop(stream.input.take());
+                drop(stream.output.take());
+                file.position.set(from as filesystem::Filesize);
+                *newoffset = from as filesystem::Filesize;
+                Ok(())
+            } else {
+                Err(ERRNO_SPIPE)
+            }
+        })
+    }
 }
 
 /// Synchronize the data and metadata of a file to disk.
 /// Note: This is similar to `fsync` in POSIX.
 #[no_mangle]
 pub unsafe extern "C" fn fd_sync(fd: Fd) -> Errno {
-    State::with(|state| {
-        let ds = state.descriptors();
-        let file = ds.get_file(fd)?;
-        file.fd.sync()?;
-        Ok(())
-    })
+    cfg_filesystem_available! {
+        State::with(|state| {
+            let ds = state.descriptors();
+            let file = ds.get_file(fd)?;
+            file.fd.sync()?;
+            Ok(())
+        })
+    }
 }
 
 /// Return the current offset of a file descriptor.
 /// Note: This is similar to `lseek(fd, 0, SEEK_CUR)` in POSIX.
 #[no_mangle]
 pub unsafe extern "C" fn fd_tell(fd: Fd, offset: *mut Filesize) -> Errno {
-    State::with(|state| {
-        let ds = state.descriptors();
-        let file = ds.get_seekable_file(fd)?;
-        *offset = file.position.get() as Filesize;
-        Ok(())
-    })
+    cfg_filesystem_available! {
+        State::with(|state| {
+            let ds = state.descriptors();
+            let file = ds.get_seekable_file(fd)?;
+            *offset = file.position.get();
+            Ok(())
+        })
+    }
 }
 
 /// Write to a file descriptor.
@@ -1250,58 +1626,68 @@ pub unsafe extern "C" fn fd_write(
     mut iovs_len: usize,
     nwritten: *mut Size,
 ) -> Errno {
-    if matches!(
+    if !matches!(
         get_allocation_state(),
         AllocationState::StackAllocated | AllocationState::StateAllocated
     ) {
-        // Advance to the first non-empty buffer.
-        while iovs_len != 0 && (*iovs_ptr).buf_len == 0 {
-            iovs_ptr = iovs_ptr.add(1);
-            iovs_len -= 1;
-        }
-        if iovs_len == 0 {
-            *nwritten = 0;
-            return ERRNO_SUCCESS;
-        }
+        *nwritten = 0;
+        return ERRNO_IO;
+    }
 
-        let ptr = (*iovs_ptr).buf;
-        let len = (*iovs_ptr).buf_len;
-        let bytes = slice::from_raw_parts(ptr, len);
+    // Skip leading empty buffers.
+    while iovs_len > 1 && (*iovs_ptr).buf_len == 0 {
+        iovs_ptr = iovs_ptr.add(1);
+        iovs_len -= 1;
+    }
+    if iovs_len == 0 {
+        *nwritten = 0;
+        return ERRNO_SUCCESS;
+    }
 
-        State::with(|state| {
-            let ds = state.descriptors();
-            match ds.get(fd)? {
-                Descriptor::Streams(streams) => {
-                    let wasi_stream = streams.get_write_stream()?;
+    let ptr = (*iovs_ptr).buf;
+    let len = (*iovs_ptr).buf_len;
+    let bytes = slice::from_raw_parts(ptr, len);
 
-                    let nbytes = if let StreamType::File(file) = &streams.type_ {
-                        file.blocking_mode.write(wasi_stream, bytes)?
-                    } else {
-                        // Use blocking writes on non-file streams (stdout, stderr, as sockets
-                        // aren't currently used).
-                        BlockingMode::Blocking.write(wasi_stream, bytes)?
-                    };
+    State::with(|state| {
+        let ds = state.descriptors();
+        match ds.get(fd)? {
+            Descriptor::Streams(streams) => {
+                let wasi_stream = streams.get_write_stream()?;
 
-                    // If this is a file, keep the current-position pointer up to date.
-                    if let StreamType::File(file) = &streams.type_ {
-                        // But don't update if we're in append mode. Strictly speaking,
-                        // we should set the position to the new end of the file, but
-                        // we don't have an API to do that atomically.
-                        if !file.append {
-                            file.position.set(file.position.get() + nbytes as u64);
-                        }
+                #[cfg(not(feature = "proxy"))]
+                let nbytes = if let StreamType::File(file) = &streams.type_ {
+                    file.blocking_mode.write(wasi_stream, bytes)?
+                } else {
+                    // Use blocking writes on non-file streams (stdout, stderr, as sockets
+                    // aren't currently used).
+                    BlockingMode::Blocking.write(wasi_stream, bytes)?
+                };
+                #[cfg(feature = "proxy")]
+                let nbytes = BlockingMode::Blocking.write(wasi_stream, bytes)?;
+
+                // If this is a file, keep the current-position pointer up
+                // to date. Note that for files that perform appending
+                // writes this function will always update the current
+                // position to the end of the file.
+                //
+                // NB: this isn't "atomic" as it doesn't necessarily account
+                // for concurrent writes, but there's not much that can be
+                // done about that.
+                #[cfg(not(feature = "proxy"))]
+                if let StreamType::File(file) = &streams.type_ {
+                    if file.append {
+                        file.position.set(file.fd.stat()?.size);
+                    } else {
+                        file.position.set(file.position.get() + nbytes as u64);
                     }
-
-                    *nwritten = nbytes;
-                    Ok(())
                 }
-                Descriptor::Closed(_) => Err(ERRNO_BADF),
+
+                *nwritten = nbytes;
+                Ok(())
             }
-        })
-    } else {
-        *nwritten = 0;
-        ERRNO_IO
-    }
+            Descriptor::Closed(_) | Descriptor::Bad => Err(ERRNO_BADF),
+        }
+    })
 }
 
 /// Create a directory.
@@ -1312,14 +1698,16 @@ pub unsafe extern "C" fn path_create_directory(
     path_ptr: *const u8,
     path_len: usize,
 ) -> Errno {
-    let path = slice::from_raw_parts(path_ptr, path_len);
+    cfg_filesystem_available! {
+        let path = slice::from_raw_parts(path_ptr, path_len);
 
-    State::with(|state| {
-        let ds = state.descriptors();
-        let file = ds.get_dir(fd)?;
-        file.fd.create_directory_at(path)?;
-        Ok(())
-    })
+        State::with(|state| {
+            let ds = state.descriptors();
+            let file = ds.get_dir(fd)?;
+            file.fd.create_directory_at(path)?;
+            Ok(())
+        })
+    }
 }
 
 /// Return the attributes of a file or directory.
@@ -1332,27 +1720,29 @@ pub unsafe extern "C" fn path_filestat_get(
     path_len: usize,
     buf: *mut Filestat,
 ) -> Errno {
-    let path = slice::from_raw_parts(path_ptr, path_len);
-    let at_flags = at_flags_from_lookupflags(flags);
+    cfg_filesystem_available! {
+        let path = slice::from_raw_parts(path_ptr, path_len);
+        let at_flags = at_flags_from_lookupflags(flags);
 
-    State::with(|state| {
-        let ds = state.descriptors();
-        let file = ds.get_dir(fd)?;
-        let stat = file.fd.stat_at(at_flags, path)?;
-        let metadata_hash = file.fd.metadata_hash_at(at_flags, path)?;
-        let filetype = stat.type_.into();
-        *buf = Filestat {
-            dev: 1,
-            ino: metadata_hash.lower,
-            filetype,
-            nlink: stat.link_count,
-            size: stat.size,
-            atim: datetime_to_timestamp(stat.data_access_timestamp),
-            mtim: datetime_to_timestamp(stat.data_modification_timestamp),
-            ctim: datetime_to_timestamp(stat.status_change_timestamp),
-        };
-        Ok(())
-    })
+        State::with(|state| {
+            let ds = state.descriptors();
+            let file = ds.get_dir(fd)?;
+            let stat = file.fd.stat_at(at_flags, path)?;
+            let metadata_hash = file.fd.metadata_hash_at(at_flags, path)?;
+            let filetype = stat.type_.into();
+            *buf = Filestat {
+                dev: 1,
+                ino: metadata_hash.lower,
+                filetype,
+                nlink: stat.link_count,
+                size: stat.size,
+                atim: datetime_to_timestamp(stat.data_access_timestamp),
+                mtim: datetime_to_timestamp(stat.data_modification_timestamp),
+                ctim: datetime_to_timestamp(stat.status_change_timestamp),
+            };
+            Ok(())
+        })
+    }
 }
 
 /// Adjust the timestamps of a file or directory.
@@ -1367,26 +1757,28 @@ pub unsafe extern "C" fn path_filestat_set_times(
     mtim: Timestamp,
     fst_flags: Fstflags,
 ) -> Errno {
-    let path = slice::from_raw_parts(path_ptr, path_len);
-    let at_flags = at_flags_from_lookupflags(flags);
+    cfg_filesystem_available! {
+        let path = slice::from_raw_parts(path_ptr, path_len);
+        let at_flags = at_flags_from_lookupflags(flags);
 
-    State::with(|state| {
-        let atim = systimespec(
-            fst_flags & FSTFLAGS_ATIM == FSTFLAGS_ATIM,
-            atim,
-            fst_flags & FSTFLAGS_ATIM_NOW == FSTFLAGS_ATIM_NOW,
-        )?;
-        let mtim = systimespec(
-            fst_flags & FSTFLAGS_MTIM == FSTFLAGS_MTIM,
-            mtim,
-            fst_flags & FSTFLAGS_MTIM_NOW == FSTFLAGS_MTIM_NOW,
-        )?;
+        State::with(|state| {
+            let atim = systimespec(
+                fst_flags & FSTFLAGS_ATIM == FSTFLAGS_ATIM,
+                atim,
+                fst_flags & FSTFLAGS_ATIM_NOW == FSTFLAGS_ATIM_NOW,
+            )?;
+            let mtim = systimespec(
+                fst_flags & FSTFLAGS_MTIM == FSTFLAGS_MTIM,
+                mtim,
+                fst_flags & FSTFLAGS_MTIM_NOW == FSTFLAGS_MTIM_NOW,
+            )?;
 
-        let ds = state.descriptors();
-        let file = ds.get_dir(fd)?;
-        file.fd.set_times_at(at_flags, path, atim, mtim)?;
-        Ok(())
-    })
+            let ds = state.descriptors();
+            let file = ds.get_dir(fd)?;
+            file.fd.set_times_at(at_flags, path, atim, mtim)?;
+            Ok(())
+        })
+    }
 }
 
 /// Create a hard link.
@@ -1401,17 +1793,19 @@ pub unsafe extern "C" fn path_link(
     new_path_ptr: *const u8,
     new_path_len: usize,
 ) -> Errno {
-    let old_path = slice::from_raw_parts(old_path_ptr, old_path_len);
-    let new_path = slice::from_raw_parts(new_path_ptr, new_path_len);
-    let at_flags = at_flags_from_lookupflags(old_flags);
+    cfg_filesystem_available! {
+        let old_path = slice::from_raw_parts(old_path_ptr, old_path_len);
+        let new_path = slice::from_raw_parts(new_path_ptr, new_path_len);
+        let at_flags = at_flags_from_lookupflags(old_flags);
 
-    State::with(|state| {
-        let ds = state.descriptors();
-        let old = &ds.get_dir(old_fd)?.fd;
-        let new = &ds.get_dir(new_fd)?.fd;
-        old.link_at(at_flags, old_path, new, new_path)?;
-        Ok(())
-    })
+        State::with(|state| {
+            let ds = state.descriptors();
+            let old = &ds.get_dir(old_fd)?.fd;
+            let new = &ds.get_dir(new_fd)?.fd;
+            old.link_at(at_flags, old_path, new, new_path)?;
+            Ok(())
+        })
+    }
 }
 
 /// Open a file or directory.
@@ -1433,42 +1827,48 @@ pub unsafe extern "C" fn path_open(
     fdflags: Fdflags,
     opened_fd: *mut Fd,
 ) -> Errno {
-    let _ = fs_rights_inheriting;
+    cfg_filesystem_available! {
+        let _ = fs_rights_inheriting;
 
-    let path = slice::from_raw_parts(path_ptr, path_len);
-    let at_flags = at_flags_from_lookupflags(dirflags);
-    let o_flags = o_flags_from_oflags(oflags);
-    let flags = descriptor_flags_from_flags(fs_rights_base, fdflags);
-    let mode = filesystem::Modes::READABLE | filesystem::Modes::WRITABLE;
-    let append = fdflags & wasi::FDFLAGS_APPEND == wasi::FDFLAGS_APPEND;
+        let path = slice::from_raw_parts(path_ptr, path_len);
+        let at_flags = at_flags_from_lookupflags(dirflags);
+        let o_flags = o_flags_from_oflags(oflags);
+        let flags = descriptor_flags_from_flags(fs_rights_base, fdflags);
+        let append = fdflags & wasi::FDFLAGS_APPEND == wasi::FDFLAGS_APPEND;
 
-    State::with(|state| {
-        let result = state
-            .descriptors()
-            .get_dir(fd)?
-            .fd
-            .open_at(at_flags, path, o_flags, flags, mode)?;
-        let descriptor_type = result.get_type()?;
-        let desc = Descriptor::Streams(Streams {
-            input: OnceCell::new(),
-            output: OnceCell::new(),
-            type_: StreamType::File(File {
-                fd: result,
-                descriptor_type,
-                position: Cell::new(0),
-                append,
-                blocking_mode: if fdflags & wasi::FDFLAGS_NONBLOCK == 0 {
-                    BlockingMode::Blocking
-                } else {
-                    BlockingMode::NonBlocking
-                },
-            }),
-        });
+        #[cfg(feature = "proxy")]
+        return wasi::ERRNO_NOTSUP;
 
-        let fd = state.descriptors_mut().open(desc)?;
-        *opened_fd = fd;
-        Ok(())
-    })
+        #[cfg(not(feature = "proxy"))]
+        State::with(|state| {
+            let result = state
+                .descriptors()
+                .get_dir(fd)?
+                .fd
+                .open_at(at_flags, path, o_flags, flags)?;
+            let descriptor_type = result.get_type()?;
+            let desc = Descriptor::Streams(Streams {
+                input: OnceCell::new(),
+                output: OnceCell::new(),
+                type_: StreamType::File(File {
+                    fd: result,
+                    descriptor_type,
+                    position: Cell::new(0),
+                    append,
+                    blocking_mode: if fdflags & wasi::FDFLAGS_NONBLOCK == 0 {
+                        BlockingMode::Blocking
+                    } else {
+                        BlockingMode::NonBlocking
+                    },
+                    preopen_name_len: None,
+                }),
+            });
+
+            let fd = state.descriptors_mut().open(desc)?;
+            *opened_fd = fd;
+            Ok(())
+        })
+    }
 }
 
 /// Read the contents of a symbolic link.
@@ -1482,44 +1882,44 @@ pub unsafe extern "C" fn path_readlink(
     buf_len: Size,
     bufused: *mut Size,
 ) -> Errno {
-    let path = slice::from_raw_parts(path_ptr, path_len);
+    cfg_filesystem_available! {
+        let path = slice::from_raw_parts(path_ptr, path_len);
 
-    State::with(|state| {
-        // If the user gave us a buffer shorter than `PATH_MAX`, it may not be
-        // long enough to accept the actual path. `cabi_realloc` can't fail,
-        // so instead we handle this case specially.
-        let use_state_buf = buf_len < PATH_MAX;
+        State::with(|state| {
+            // If the user gave us a buffer shorter than `PATH_MAX`, it may not be
+            // long enough to accept the actual path. `cabi_realloc` can't fail,
+            // so instead we handle this case specially.
+            let use_state_buf = buf_len < PATH_MAX;
 
-        let ds = state.descriptors();
-        let file = ds.get_dir(fd)?;
-        let path = if use_state_buf {
-            state
-                .import_alloc
-                .with_buffer(state.path_buf.get().cast(), PATH_MAX, || {
-                    file.fd.readlink_at(path)
-                })?
-        } else {
-            state
-                .import_alloc
-                .with_buffer(buf, buf_len, || file.fd.readlink_at(path))?
-        };
+            let ds = state.descriptors();
+            let file = ds.get_dir(fd)?;
+            let path = if use_state_buf {
+                state
+                    .with_one_temporary_alloc( || {
+                        file.fd.readlink_at(path)
+                    })?
+            } else {
+                state
+                    .with_one_import_alloc(buf, buf_len, || file.fd.readlink_at(path))?
+            };
 
-        if use_state_buf {
-            // Preview1 follows POSIX in truncating the returned path if it
-            // doesn't fit.
-            let len = min(path.len(), buf_len);
-            ptr::copy_nonoverlapping(path.as_ptr().cast(), buf, len);
-            *bufused = len;
-        } else {
-            *bufused = path.len();
-        }
+            if use_state_buf {
+                // Preview1 follows POSIX in truncating the returned path if it
+                // doesn't fit.
+                let len = min(path.len(), buf_len);
+                ptr::copy_nonoverlapping(path.as_ptr().cast(), buf, len);
+                *bufused = len;
+            } else {
+                *bufused = path.len();
+            }
 
-        // The returned string's memory was allocated in `buf`, so don't separately
-        // free it.
-        forget(path);
+            // The returned string's memory was allocated in `buf`, so don't separately
+            // free it.
+            forget(path);
 
-        Ok(())
-    })
+            Ok(())
+        })
+    }
 }
 
 /// Remove a directory.
@@ -1531,14 +1931,16 @@ pub unsafe extern "C" fn path_remove_directory(
     path_ptr: *const u8,
     path_len: usize,
 ) -> Errno {
-    let path = slice::from_raw_parts(path_ptr, path_len);
+    cfg_filesystem_available! {
+        let path = slice::from_raw_parts(path_ptr, path_len);
 
-    State::with(|state| {
-        let ds = state.descriptors();
-        let file = ds.get_dir(fd)?;
-        file.fd.remove_directory_at(path)?;
-        Ok(())
-    })
+        State::with(|state| {
+            let ds = state.descriptors();
+            let file = ds.get_dir(fd)?;
+            file.fd.remove_directory_at(path)?;
+            Ok(())
+        })
+    }
 }
 
 /// Rename a file or directory.
@@ -1552,16 +1954,18 @@ pub unsafe extern "C" fn path_rename(
     new_path_ptr: *const u8,
     new_path_len: usize,
 ) -> Errno {
-    let old_path = slice::from_raw_parts(old_path_ptr, old_path_len);
-    let new_path = slice::from_raw_parts(new_path_ptr, new_path_len);
+    cfg_filesystem_available! {
+        let old_path = slice::from_raw_parts(old_path_ptr, old_path_len);
+        let new_path = slice::from_raw_parts(new_path_ptr, new_path_len);
 
-    State::with(|state| {
-        let ds = state.descriptors();
-        let old = &ds.get_dir(old_fd)?.fd;
-        let new = &ds.get_dir(new_fd)?.fd;
-        old.rename_at(old_path, new, new_path)?;
-        Ok(())
-    })
+        State::with(|state| {
+            let ds = state.descriptors();
+            let old = &ds.get_dir(old_fd)?.fd;
+            let new = &ds.get_dir(new_fd)?.fd;
+            old.rename_at(old_path, new, new_path)?;
+            Ok(())
+        })
+    }
 }
 
 /// Create a symbolic link.
@@ -1574,15 +1978,17 @@ pub unsafe extern "C" fn path_symlink(
     new_path_ptr: *const u8,
     new_path_len: usize,
 ) -> Errno {
-    let old_path = slice::from_raw_parts(old_path_ptr, old_path_len);
-    let new_path = slice::from_raw_parts(new_path_ptr, new_path_len);
+    cfg_filesystem_available! {
+        let old_path = slice::from_raw_parts(old_path_ptr, old_path_len);
+        let new_path = slice::from_raw_parts(new_path_ptr, new_path_len);
 
-    State::with(|state| {
-        let ds = state.descriptors();
-        let file = ds.get_dir(fd)?;
-        file.fd.symlink_at(old_path, new_path)?;
-        Ok(())
-    })
+        State::with(|state| {
+            let ds = state.descriptors();
+            let file = ds.get_dir(fd)?;
+            file.fd.symlink_at(old_path, new_path)?;
+            Ok(())
+        })
+    }
 }
 
 /// Unlink a file.
@@ -1590,14 +1996,16 @@ pub unsafe extern "C" fn path_symlink(
 /// Note: This is similar to `unlinkat(fd, path, 0)` in POSIX.
 #[no_mangle]
 pub unsafe extern "C" fn path_unlink_file(fd: Fd, path_ptr: *const u8, path_len: usize) -> Errno {
-    let path = slice::from_raw_parts(path_ptr, path_len);
+    cfg_filesystem_available! {
+        let path = slice::from_raw_parts(path_ptr, path_len);
 
-    State::with(|state| {
-        let ds = state.descriptors();
-        let file = ds.get_dir(fd)?;
-        file.fd.unlink_file_at(path)?;
-        Ok(())
-    })
+        State::with(|state| {
+            let ds = state.descriptors();
+            let file = ds.get_dir(fd)?;
+            file.fd.unlink_file_at(path)?;
+            Ok(())
+        })
+    }
 }
 
 struct Pollables {
@@ -1629,26 +2037,6 @@ impl Drop for Pollables {
     }
 }
 
-impl From<network::ErrorCode> for Errno {
-    fn from(error: network::ErrorCode) -> Errno {
-        match error {
-            network::ErrorCode::Unknown => unreachable!(), // TODO
-            /* TODO
-            // Use a black box to prevent the optimizer from generating a
-            // lookup table, which would require a static initializer.
-            ConnectionAborted => black_box(ERRNO_CONNABORTED),
-            ConnectionRefused => ERRNO_CONNREFUSED,
-            ConnectionReset => ERRNO_CONNRESET,
-            HostUnreachable => ERRNO_HOSTUNREACH,
-            NetworkDown => ERRNO_NETDOWN,
-            NetworkUnreachable => ERRNO_NETUNREACH,
-            Timedout => ERRNO_TIMEDOUT,
-            */
-            _ => unreachable!(),
-        }
-    }
-}
-
 /// Concurrently poll for the occurrence of a set of events.
 #[no_mangle]
 pub unsafe extern "C" fn poll_oneoff(
@@ -1683,7 +2071,7 @@ pub unsafe extern "C" fn poll_oneoff(
                 .trapping_unwrap()
     );
     // Store the pollable handles at the beginning, and the bool results at the
-    // end, so that we don't clobber the bool results when writting the events.
+    // end, so that we don't clobber the bool results when writing the events.
     let pollables = out as *mut c_void as *mut Pollable;
     let results = out.add(nsubscriptions).cast::<u32>().sub(nsubscriptions);
 
@@ -1739,12 +2127,15 @@ pub unsafe extern "C" fn poll_oneoff(
                                 clock.timeout
                             };
 
-                            monotonic_clock::subscribe(timeout, false)
+                            monotonic_clock::subscribe_duration(timeout)
                         }
 
                         CLOCKID_MONOTONIC => {
-                            let s = monotonic_clock::subscribe(clock.timeout, absolute);
-                            s
+                            if absolute {
+                                monotonic_clock::subscribe_instant(clock.timeout)
+                            } else {
+                                monotonic_clock::subscribe_duration(clock.timeout)
+                            }
                         }
 
                         _ => return Err(ERRNO_INVAL),
@@ -1765,24 +2156,24 @@ pub unsafe extern "C" fn poll_oneoff(
             });
         }
 
-        #[link(wasm_import_module = "wasi:io/poll")]
+        #[link(wasm_import_module = "wasi:io/poll@0.2.1")]
         #[allow(improper_ctypes)] // FIXME(bytecodealliance/wit-bindgen#684)
         extern "C" {
-            #[link_name = "poll-list"]
-            fn poll_list_import(pollables: *const Pollable, len: usize, rval: *mut ReadyList);
+            #[link_name = "poll"]
+            fn poll_import(pollables: *const Pollable, len: usize, rval: *mut ReadyList);
         }
         let mut ready_list = ReadyList {
             base: std::ptr::null(),
             len: 0,
         };
 
-        state.import_alloc.with_buffer(
+        state.with_one_import_alloc(
             results.cast(),
             nsubscriptions
                 .checked_mul(size_of::<u32>())
                 .trapping_unwrap(),
             || {
-                poll_list_import(
+                poll_import(
                     pollables.pointer,
                     pollables.length,
                     &mut ready_list as *mut _,
@@ -1818,6 +2209,7 @@ pub unsafe extern "C" fn poll_oneoff(
                         .trapping_unwrap();
                     match desc {
                         Descriptor::Streams(streams) => match &streams.type_ {
+                            #[cfg(not(feature = "proxy"))]
                             StreamType::File(file) => match file.fd.stat() {
                                 Ok(stat) => {
                                     let nbytes = stat.size.saturating_sub(file.position.get());
@@ -1833,25 +2225,6 @@ pub unsafe extern "C" fn poll_oneoff(
                                 }
                                 Err(e) => (e.into(), 1, 0),
                             },
-                            StreamType::Socket(_connection) => {
-                                unreachable!() // TODO
-                                               /*
-                                               match tcp::bytes_readable(*connection) {
-                                                   Ok(result) => (
-                                                       ERRNO_SUCCESS,
-                                                       result.0,
-                                                       if result.1 {
-                                                           EVENTRWFLAGS_FD_READWRITE_HANGUP
-                                                       } else {
-                                                           0
-                                                       }
-                                                   )
-                                                   Err(e) => {
-                                                       (e.into(), 1, 0)
-                                                   }
-                                               }
-                                               */
-                            }
                             StreamType::Stdio(_) => (ERRNO_SUCCESS, 1, 0),
                         },
                         _ => unreachable!(),
@@ -1865,26 +2238,9 @@ pub unsafe extern "C" fn poll_oneoff(
                         .trapping_unwrap();
                     match desc {
                         Descriptor::Streams(streams) => match &streams.type_ {
-                            StreamType::File(_) | StreamType::Stdio(_) => (ERRNO_SUCCESS, 1, 0),
-                            StreamType::Socket(_connection) => {
-                                unreachable!() // TODO
-                                               /*
-                                               match tcp::bytes_writable(connection) {
-                                                   Ok(result) => (
-                                                       ERRNO_SUCCESS,
-                                                       result.0,
-                                                       if result.1 {
-                                                           EVENTRWFLAGS_FD_READWRITE_HANGUP
-                                                       } else {
-                                                            0
-                                                       }
-                                                   )
-                                                   Err(e) => {
-                                                       (e.into(), 0, 0)
-                                                   }
-                                               }
-                                               */
-                            }
+                            #[cfg(not(feature = "proxy"))]
+                            StreamType::File(_) => (ERRNO_SUCCESS, 1, 0),
+                            StreamType::Stdio(_) => (ERRNO_SUCCESS, 1, 0),
                         },
                         _ => unreachable!(),
                     }
@@ -1914,9 +2270,16 @@ pub unsafe extern "C" fn poll_oneoff(
 /// the environment.
 #[no_mangle]
 pub unsafe extern "C" fn proc_exit(rval: Exitcode) -> ! {
-    let status = if rval == 0 { Ok(()) } else { Err(()) };
-    exit::exit(status); // does not return
-    unreachable!("host exit implementation didn't exit!") // actually unreachable
+    #[cfg(feature = "proxy")]
+    {
+        unreachable!("no other implementation available in proxy world");
+    }
+    #[cfg(not(feature = "proxy"))]
+    {
+        let status = if rval == 0 { Ok(()) } else { Err(()) };
+        crate::bindings::wasi::cli::exit::exit(status); // does not return
+        unreachable!("host exit implementation didn't exit!") // actually unreachable
+    }
 }
 
 /// Send a signal to the process of the calling thread.
@@ -1950,8 +2313,7 @@ pub unsafe extern "C" fn random_get(buf: *mut u8, buf_len: Size) -> Errno {
         State::with(|state| {
             assert_eq!(buf_len as u32 as Size, buf_len);
             let result = state
-                .import_alloc
-                .with_buffer(buf, buf_len, || random::get_random_bytes(buf_len as u64));
+                .with_one_import_alloc(buf, buf_len, || random::get_random_bytes(buf_len as u64));
             assert_eq!(result.as_ptr(), buf);
 
             // The returned buffer's memory was allocated in `buf`, so don't separately
@@ -2008,6 +2370,7 @@ pub unsafe extern "C" fn sock_shutdown(_fd: Fd, _how: Sdflags) -> Errno {
     unreachable!()
 }
 
+#[cfg(not(feature = "proxy"))]
 fn datetime_to_timestamp(datetime: Option<filesystem::Datetime>) -> Timestamp {
     match datetime {
         Some(datetime) => u64::from(datetime.nanoseconds)
@@ -2016,6 +2379,7 @@ fn datetime_to_timestamp(datetime: Option<filesystem::Datetime>) -> Timestamp {
     }
 }
 
+#[cfg(not(feature = "proxy"))]
 fn at_flags_from_lookupflags(flags: Lookupflags) -> filesystem::PathFlags {
     if flags & LOOKUPFLAGS_SYMLINK_FOLLOW == LOOKUPFLAGS_SYMLINK_FOLLOW {
         filesystem::PathFlags::SYMLINK_FOLLOW
@@ -2024,6 +2388,7 @@ fn at_flags_from_lookupflags(flags: Lookupflags) -> filesystem::PathFlags {
     }
 }
 
+#[cfg(not(feature = "proxy"))]
 fn o_flags_from_oflags(flags: Oflags) -> filesystem::OpenFlags {
     let mut o_flags = filesystem::OpenFlags::empty();
     if flags & OFLAGS_CREAT == OFLAGS_CREAT {
@@ -2041,6 +2406,7 @@ fn o_flags_from_oflags(flags: Oflags) -> filesystem::OpenFlags {
     o_flags
 }
 
+#[cfg(not(feature = "proxy"))]
 fn descriptor_flags_from_flags(rights: Rights, fdflags: Fdflags) -> filesystem::DescriptorFlags {
     let mut flags = filesystem::DescriptorFlags::empty();
     if rights & wasi::RIGHTS_FD_READ == wasi::RIGHTS_FD_READ {
@@ -2061,6 +2427,7 @@ fn descriptor_flags_from_flags(rights: Rights, fdflags: Fdflags) -> filesystem::
     flags
 }
 
+#[cfg(not(feature = "proxy"))]
 impl From<filesystem::ErrorCode> for Errno {
     #[inline(never)] // Disable inlining as this is bulky and relatively cold.
     fn from(err: filesystem::ErrorCode) -> Errno {
@@ -2108,6 +2475,7 @@ impl From<filesystem::ErrorCode> for Errno {
     }
 }
 
+#[cfg(not(feature = "proxy"))]
 impl From<filesystem::DescriptorType> for wasi::Filetype {
     fn from(ty: filesystem::DescriptorType) -> wasi::Filetype {
         match ty {
@@ -2154,13 +2522,17 @@ impl BlockingMode {
         match self {
             BlockingMode::Blocking => {
                 let total = bytes.len();
-                while !bytes.is_empty() {
+                loop {
                     let len = bytes.len().min(4096);
                     let (chunk, rest) = bytes.split_at(len);
                     bytes = rest;
                     match output_stream.blocking_write_and_flush(chunk) {
+                        Ok(()) if bytes.is_empty() => break,
                         Ok(()) => {}
-                        Err(_) => return Err(ERRNO_IO),
+                        Err(streams::StreamError::Closed) => return Err(ERRNO_IO),
+                        Err(streams::StreamError::LastOperationFailed(e)) => {
+                            return Err(stream_error_to_errno(e))
+                        }
                     }
                 }
                 Ok(total)
@@ -2170,24 +2542,27 @@ impl BlockingMode {
                 let permit = match output_stream.check_write() {
                     Ok(n) => n,
                     Err(streams::StreamError::Closed) => 0,
-                    Err(streams::StreamError::LastOperationFailed) => return Err(ERRNO_IO),
+                    Err(streams::StreamError::LastOperationFailed(e)) => {
+                        return Err(stream_error_to_errno(e))
+                    }
                 };
 
                 let len = bytes.len().min(permit as usize);
-                if len == 0 {
-                    return Ok(0);
-                }
 
                 match output_stream.write(&bytes[..len]) {
                     Ok(_) => {}
                     Err(streams::StreamError::Closed) => return Ok(0),
-                    Err(streams::StreamError::LastOperationFailed) => return Err(ERRNO_IO),
+                    Err(streams::StreamError::LastOperationFailed(e)) => {
+                        return Err(stream_error_to_errno(e))
+                    }
                 }
 
                 match output_stream.blocking_flush() {
                     Ok(_) => {}
                     Err(streams::StreamError::Closed) => return Ok(0),
-                    Err(streams::StreamError::LastOperationFailed) => return Err(ERRNO_IO),
+                    Err(streams::StreamError::LastOperationFailed(e)) => {
+                        return Err(stream_error_to_errno(e))
+                    }
                 }
 
                 Ok(len)
@@ -2197,6 +2572,7 @@ impl BlockingMode {
 }
 
 #[repr(C)]
+#[cfg(not(feature = "proxy"))]
 pub struct File {
     /// The handle to the preview2 descriptor that this file is referencing.
     fd: filesystem::Descriptor,
@@ -2214,8 +2590,12 @@ pub struct File {
     /// blocking_check_write on the underlying streams. When false, read and write
     /// dispatch to stream's plain read and check_write.
     blocking_mode: BlockingMode,
+
+    /// TODO
+    preopen_name_len: Option<NonZeroUsize>,
 }
 
+#[cfg(not(feature = "proxy"))]
 impl File {
     fn is_dir(&self) -> bool {
         match self.descriptor_type {
@@ -2245,7 +2625,7 @@ struct State {
     magic1: u32,
 
     /// Used to coordinate allocations of `cabi_import_realloc`
-    import_alloc: ImportAlloc,
+    import_alloc: Cell<ImportAlloc>,
 
     /// Storage of mapping from preview1 file descriptors to preview2 file
     /// descriptors.
@@ -2254,30 +2634,16 @@ struct State {
     /// lazy initialization happens.
     descriptors: RefCell<Option<Descriptors>>,
 
-    /// Auxiliary storage to handle the `path_readlink` function.
-    path_buf: UnsafeCell<MaybeUninit<[u8; PATH_MAX]>>,
-
-    /// Long-lived bump allocated memory arena.
-    ///
-    /// This is used for the cabi_export_realloc to allocate data passed to the
-    /// `run` entrypoint. Allocations in this arena are safe to use for
-    /// the lifetime of the State struct. It may also be used for import allocations
-    /// which need to be long-lived, by using `import_alloc.with_arena`.
-    long_lived_arena: BumpArena,
-
-    /// Arguments. Initialized lazily. Access with `State::get_args` to take care of
-    /// initialization.
-    args: Cell<Option<&'static [WasmStr]>>,
-
-    /// Environment variables. Initialized lazily. Access with `State::get_environment`
-    /// to take care of initialization.
-    env_vars: Cell<Option<&'static [StrTuple]>>,
+    /// TODO
+    temporary_data: UnsafeCell<MaybeUninit<[u8; temporary_data_size()]>>,
 
     /// Cache for the `fd_readdir` call for a final `wasi::Dirent` plus path
     /// name that didn't fit into the caller's buffer.
+    #[cfg(not(feature = "proxy"))]
     dirent_cache: DirentCache,
 
     /// The string `..` for use by the directory iterator.
+    #[cfg(not(feature = "proxy"))]
     dotdot: [UnsafeCell<u8>; 2],
 
     /// Another canary constant located at the end of the structure to catch
@@ -2285,6 +2651,7 @@ struct State {
     magic2: u32,
 }
 
+#[cfg(not(feature = "proxy"))]
 struct DirentCache {
     stream: Cell<Option<DirectoryEntryStream>>,
     for_fd: Cell<wasi::Fd>,
@@ -2293,6 +2660,7 @@ struct DirentCache {
     path_data: UnsafeCell<MaybeUninit<[u8; DIRENT_CACHE]>>,
 }
 
+#[cfg(not(feature = "proxy"))]
 struct DirectoryEntryStream(filesystem::DirectoryEntryStream);
 
 #[repr(C)]
@@ -2327,18 +2695,20 @@ pub struct ReadyList {
     len: usize,
 }
 
-const fn bump_arena_size() -> usize {
+const fn temporary_data_size() -> usize {
     // The total size of the struct should be a page, so start there
     let mut start = PAGE_SIZE;
 
-    // Remove the big chunks of the struct, the `path_buf` and `descriptors`
-    // fields.
-    start -= PATH_MAX;
+    // Remove big chunks of the struct for its various fields.
     start -= size_of::<Descriptors>();
-    start -= size_of::<DirentCache>();
+    #[cfg(not(feature = "proxy"))]
+    {
+        start -= size_of::<DirentCache>();
+    }
 
     // Remove miscellaneous metadata also stored in state.
-    start -= 14 * size_of::<usize>();
+    let misc = if cfg!(feature = "proxy") { 8 } else { 10 };
+    start -= misc * size_of::<usize>();
 
     // Everything else is the `command_data` allocation.
     start
@@ -2364,8 +2734,8 @@ enum AllocationState {
 
 #[allow(improper_ctypes)]
 extern "C" {
-    fn get_state_ptr() -> *const State;
-    fn set_state_ptr(state: *const State);
+    fn get_state_ptr() -> *mut State;
+    fn set_state_ptr(state: *mut State);
     fn get_allocation_state() -> AllocationState;
     fn set_allocation_state(state: AllocationState);
 }
@@ -2394,7 +2764,7 @@ impl State {
     }
 
     #[cold]
-    fn new() -> &'static State {
+    fn new() -> *mut State {
         #[link(wasm_import_module = "__main_module__")]
         extern "C" {
             fn cabi_realloc(
@@ -2424,31 +2794,36 @@ impl State {
         unsafe { set_allocation_state(AllocationState::StateAllocated) };
 
         unsafe {
-            ret.write(State {
-                magic1: MAGIC,
-                magic2: MAGIC,
-                import_alloc: ImportAlloc::new(),
-                descriptors: RefCell::new(None),
-                path_buf: UnsafeCell::new(MaybeUninit::uninit()),
-                long_lived_arena: BumpArena::new(),
-                args: Cell::new(None),
-                env_vars: Cell::new(None),
-                dirent_cache: DirentCache {
-                    stream: Cell::new(None),
-                    for_fd: Cell::new(0),
-                    cookie: Cell::new(wasi::DIRCOOKIE_START),
-                    cached_dirent: Cell::new(wasi::Dirent {
-                        d_next: 0,
-                        d_ino: 0,
-                        d_type: FILETYPE_UNKNOWN,
-                        d_namlen: 0,
-                    }),
-                    path_data: UnsafeCell::new(MaybeUninit::uninit()),
-                },
-                dotdot: [UnsafeCell::new(b'.'), UnsafeCell::new(b'.')],
-            });
-            &*ret
+            Self::init(ret);
         }
+
+        ret
+    }
+
+    #[cold]
+    unsafe fn init(state: *mut State) {
+        state.write(State {
+            magic1: MAGIC,
+            magic2: MAGIC,
+            import_alloc: Cell::new(ImportAlloc::None),
+            descriptors: RefCell::new(None),
+            temporary_data: UnsafeCell::new(MaybeUninit::uninit()),
+            #[cfg(not(feature = "proxy"))]
+            dirent_cache: DirentCache {
+                stream: Cell::new(None),
+                for_fd: Cell::new(0),
+                cookie: Cell::new(wasi::DIRCOOKIE_START),
+                cached_dirent: Cell::new(wasi::Dirent {
+                    d_next: 0,
+                    d_ino: 0,
+                    d_type: FILETYPE_UNKNOWN,
+                    d_namlen: 0,
+                }),
+                path_data: UnsafeCell::new(MaybeUninit::uninit()),
+            },
+            #[cfg(not(feature = "proxy"))]
+            dotdot: [UnsafeCell::new(b'.'), UnsafeCell::new(b'.')],
+        });
     }
 
     /// Accessor for the descriptors member that ensures it is properly initialized
@@ -2458,7 +2833,7 @@ impl State {
             .try_borrow_mut()
             .unwrap_or_else(|_| unreachable!());
         if d.is_none() {
-            *d = Some(Descriptors::new(&self.import_alloc, &self.long_lived_arena));
+            *d = Some(Descriptors::new(self));
         }
         RefMut::map(d, |d| d.as_mut().unwrap_or_else(|| unreachable!()))
     }
@@ -2470,56 +2845,47 @@ impl State {
             .try_borrow_mut()
             .unwrap_or_else(|_| unreachable!());
         if d.is_none() {
-            *d = Some(Descriptors::new(&self.import_alloc, &self.long_lived_arena));
+            *d = Some(Descriptors::new(self));
         }
         RefMut::map(d, |d| d.as_mut().unwrap_or_else(|| unreachable!()))
     }
 
-    fn get_environment(&self) -> &[StrTuple] {
-        if self.env_vars.get().is_none() {
-            #[link(wasm_import_module = "wasi:cli/environment")]
-            extern "C" {
-                #[link_name = "get-environment"]
-                fn get_environment_import(rval: *mut StrTupleList);
-            }
-            let mut list = StrTupleList {
-                base: std::ptr::null(),
-                len: 0,
-            };
-            self.import_alloc
-                .with_arena(&self.long_lived_arena, || unsafe {
-                    get_environment_import(&mut list as *mut _)
-                });
-            self.env_vars.set(Some(unsafe {
-                /* allocation comes from long lived arena, so it is safe to
-                 * cast this to a &'static slice: */
-                std::slice::from_raw_parts(list.base, list.len)
-            }));
+    unsafe fn temporary_alloc(&self) -> BumpAlloc {
+        BumpAlloc {
+            base: self.temporary_data.get().cast(),
+            len: mem::size_of_val(&self.temporary_data),
         }
-        self.env_vars.get().trapping_unwrap()
     }
 
-    fn get_args(&self) -> &[WasmStr] {
-        if self.args.get().is_none() {
-            #[link(wasm_import_module = "wasi:cli/environment")]
-            extern "C" {
-                #[link_name = "get-arguments"]
-                fn get_args_import(rval: *mut WasmStrList);
-            }
-            let mut list = WasmStrList {
-                base: std::ptr::null(),
-                len: 0,
-            };
-            self.import_alloc
-                .with_arena(&self.long_lived_arena, || unsafe {
-                    get_args_import(&mut list as *mut _)
-                });
-            self.args.set(Some(unsafe {
-                /* allocation comes from long lived arena, so it is safe to
-                 * cast this to a &'static slice: */
-                std::slice::from_raw_parts(list.base, list.len)
-            }));
+    /// Configure that `cabi_import_realloc` will allocate once from
+    /// `self.temporary_data` for the duration of the closure `f`.
+    ///
+    /// Panics if the import allocator is already configured.
+    fn with_one_temporary_alloc<T>(&self, f: impl FnOnce() -> T) -> T {
+        let alloc = unsafe { self.temporary_alloc() };
+        self.with_import_alloc(ImportAlloc::OneAlloc(alloc), f).0
+    }
+
+    /// Configure that `cabi_import_realloc` will allocate once from
+    /// `base` with at most `len` bytes for the duration of `f`.
+    ///
+    /// Panics if the import allocator is already configured.
+    fn with_one_import_alloc<T>(&self, base: *mut u8, len: usize, f: impl FnOnce() -> T) -> T {
+        let alloc = BumpAlloc { base, len };
+        self.with_import_alloc(ImportAlloc::OneAlloc(alloc), f).0
+    }
+
+    /// Configures the `alloc` specified to be the allocator for
+    /// `cabi_import_realloc` for the duration of `f`.
+    ///
+    /// Panics if the import allocator is already configured.
+    fn with_import_alloc<T>(&self, alloc: ImportAlloc, f: impl FnOnce() -> T) -> (T, ImportAlloc) {
+        match self.import_alloc.replace(alloc) {
+            ImportAlloc::None => {}
+            _ => unreachable!("import allocator already set"),
         }
-        self.args.get().trapping_unwrap()
+        let r = f();
+        let alloc = self.import_alloc.replace(ImportAlloc::None);
+        (r, alloc)
     }
 }
diff --git a/crates/wasi-preview1-component-adapter/src/macros.rs b/crates/wasi-preview1-component-adapter/src/macros.rs
index c1ec4a515f2a..51091af40cd5 100644
--- a/crates/wasi-preview1-component-adapter/src/macros.rs
+++ b/crates/wasi-preview1-component-adapter/src/macros.rs
@@ -33,7 +33,14 @@ macro_rules! eprintln {
     }};
 }
 
-pub(crate) fn eprint_u32(x: u32) {
+#[allow(dead_code)]
+#[doc(hidden)]
+pub fn eprint_unreachable(line: u32) {
+    eprint!("unreachable executed at adapter line ");
+    crate::macros::eprint_u32(line);
+}
+
+fn eprint_u32(x: u32) {
     if x == 0 {
         eprint!("0");
     } else {
@@ -50,22 +57,26 @@ pub(crate) fn eprint_u32(x: u32) {
     }
 }
 
+#[allow(dead_code)]
+#[doc(hidden)]
+pub fn unreachable(line: u32) -> ! {
+    crate::macros::eprint_unreachable(line);
+    eprint!("\n");
+    #[cfg(target_arch = "wasm32")]
+    core::arch::wasm32::unreachable();
+    // This is here to keep rust-analyzer happy when building for native:
+    #[cfg(not(target_arch = "wasm32"))]
+    std::process::abort();
+}
+
 /// A minimal `unreachable`.
 macro_rules! unreachable {
     () => {{
-        eprint!("unreachable executed at adapter line ");
-        crate::macros::eprint_u32(line!());
-        eprint!("\n");
-        #[cfg(target_arch = "wasm32")]
-        core::arch::wasm32::unreachable();
-        // This is here to keep rust-analyzer happy when building for native:
-        #[cfg(not(target_arch = "wasm32"))]
-        std::process::abort();
+        crate::macros::unreachable(line!());
     }};
 
     ($arg:tt) => {{
-        eprint!("unreachable executed at adapter line ");
-        crate::macros::eprint_u32(line!());
+        crate::macros::eprint_unreachable(line!());
         eprint!(": ");
         eprintln!($arg);
         eprint!("\n");
@@ -77,11 +88,23 @@ macro_rules! unreachable {
     }};
 }
 
+#[allow(dead_code)]
+#[doc(hidden)]
+pub fn assert_fail(line: u32) -> ! {
+    eprint!("assertion failed at adapter line ");
+    crate::macros::eprint_u32(line);
+    #[cfg(target_arch = "wasm32")]
+    core::arch::wasm32::unreachable();
+    // This is here to keep rust-analyzer happy when building for native:
+    #[cfg(not(target_arch = "wasm32"))]
+    std::process::abort();
+}
+
 /// A minimal `assert`.
 macro_rules! assert {
     ($cond:expr $(,)?) => {
         if !$cond {
-            unreachable!("assertion failed")
+            crate::macros::assert_fail(line!());
         }
     };
 }
diff --git a/crates/wasi-preview1-component-adapter/verify/Cargo.toml b/crates/wasi-preview1-component-adapter/verify/Cargo.toml
index 90349f4bf9bc..52d75e0552ec 100644
--- a/crates/wasi-preview1-component-adapter/verify/Cargo.toml
+++ b/crates/wasi-preview1-component-adapter/verify/Cargo.toml
@@ -2,10 +2,14 @@
 name = "verify-component-adapter"
 version.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 authors.workspace = true
 publish = false
 
+[lints]
+workspace = true
+
 [dependencies]
-wasmparser = { workspace = true }
+wasmparser = { workspace = true, features = ['std', 'validate'] }
 wat = { workspace = true }
-anyhow = { workspace = true }
+anyhow = { workspace = true, features = ['std'] }
diff --git a/crates/wasi-runtime-config/Cargo.toml b/crates/wasi-runtime-config/Cargo.toml
new file mode 100644
index 000000000000..03df5d5bbcdd
--- /dev/null
+++ b/crates/wasi-runtime-config/Cargo.toml
@@ -0,0 +1,21 @@
+[package]
+name = "wasmtime-wasi-runtime-config"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+repository = "https://github.com/bytecodealliance/wasmtime"
+license = "Apache-2.0 WITH LLVM-exception"
+description = "Wasmtime implementation of the wasi-runtime-config API"
+
+[lints]
+workspace = true
+
+[dependencies]
+anyhow = { workspace = true }
+wasmtime = { workspace = true, features = ["runtime", "component-model"] }
+
+[dev-dependencies]
+test-programs-artifacts = { workspace = true }
+wasmtime-wasi = { workspace = true }
+tokio = { workspace = true, features = ["macros"] }
diff --git a/crates/wasi-runtime-config/src/lib.rs b/crates/wasi-runtime-config/src/lib.rs
new file mode 100644
index 000000000000..615e7b873fa5
--- /dev/null
+++ b/crates/wasi-runtime-config/src/lib.rs
@@ -0,0 +1,147 @@
+//! # Wasmtime's [wasi-runtime-config] Implementation
+//!
+//! This crate provides a Wasmtime host implementation of the [wasi-runtime-config]
+//! API. With this crate, the runtime can run components that call APIs in
+//! [wasi-runtime-config] and provide configuration variables for the component.
+//!
+//! # Examples
+//!
+//! The usage of this crate is very similar to other WASI API implementations
+//! such as [wasi:cli] and [wasi:http].
+//!
+//! A common scenario is getting runtime-passed configurations in a [wasi:cli]
+//! component. A standalone example of doing all this looks like:
+//!
+//! ```
+//! use wasmtime::{
+//!     component::{Linker, ResourceTable},
+//!     Config, Engine, Result, Store,
+//! };
+//! use wasmtime_wasi::{WasiCtx, WasiCtxBuilder, WasiView};
+//! use wasmtime_wasi_runtime_config::{WasiRuntimeConfig, WasiRuntimeConfigVariables};
+//!
+//! #[tokio::main]
+//! async fn main() -> Result<()> {
+//!     let mut config = Config::new();
+//!     config.async_support(true);
+//!     let engine = Engine::new(&config)?;
+//!
+//!     let mut store = Store::new(&engine, Ctx {
+//!         table: ResourceTable::new(),
+//!         wasi_ctx: WasiCtxBuilder::new().build(),
+//!         wasi_runtime_config_vars: WasiRuntimeConfigVariables::from_iter(vec![
+//!             ("config_key1", "value1"),
+//!             ("config_key2", "value2"),
+//!         ]),
+//!     });
+//!
+//!     let mut linker = Linker::<Ctx>::new(&engine);
+//!     wasmtime_wasi::add_to_linker_async(&mut linker)?;
+//!     // add `wasi-runtime-config` world's interfaces to the linker
+//!     wasmtime_wasi_runtime_config::add_to_linker(&mut linker, |h: &mut Ctx| {
+//!         WasiRuntimeConfig::from(&h.wasi_runtime_config_vars)
+//!     })?;
+//!
+//!     // ... use `linker` to instantiate within `store` ...
+//!
+//!     Ok(())
+//! }
+//!
+//! struct Ctx {
+//!     table: ResourceTable,
+//!     wasi_ctx: WasiCtx,
+//!     wasi_runtime_config_vars: WasiRuntimeConfigVariables,
+//! }
+//!
+//! impl WasiView for Ctx {
+//!     fn table(&mut self) -> &mut ResourceTable { &mut self.table }
+//!     fn ctx(&mut self) -> &mut WasiCtx { &mut self.wasi_ctx }
+//! }
+//! ```
+//!
+//! [wasi-runtime-config]: https://github.com/WebAssembly/wasi-runtime-config
+//! [wasi:cli]: https://docs.rs/wasmtime-wasi/latest
+//! [wasi:http]: https://docs.rs/wasmtime-wasi-http/latest
+
+#![deny(missing_docs)]
+
+use anyhow::Result;
+use std::collections::HashMap;
+
+mod gen_ {
+    wasmtime::component::bindgen!({
+        path: "wit",
+        world: "wasi:config/imports",
+        trappable_imports: true,
+    });
+}
+use self::gen_::wasi::config::runtime as generated;
+
+/// Capture the state necessary for use in the `wasi-runtime-config` API implementation.
+#[derive(Default)]
+pub struct WasiRuntimeConfigVariables(HashMap<String, String>);
+
+impl<S: Into<String>> FromIterator<(S, S)> for WasiRuntimeConfigVariables {
+    fn from_iter<I: IntoIterator<Item = (S, S)>>(iter: I) -> Self {
+        Self(
+            iter.into_iter()
+                .map(|(k, v)| (k.into(), v.into()))
+                .collect(),
+        )
+    }
+}
+
+impl WasiRuntimeConfigVariables {
+    /// Create a new runtime configuration.
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Insert a key-value pair into the configuration map.
+    pub fn insert(&mut self, key: impl Into<String>, value: impl Into<String>) -> &mut Self {
+        self.0.insert(key.into(), value.into());
+        self
+    }
+}
+
+/// A wrapper capturing the needed internal `wasi-runtime-config` state.
+pub struct WasiRuntimeConfig<'a> {
+    vars: &'a WasiRuntimeConfigVariables,
+}
+
+impl<'a> From<&'a WasiRuntimeConfigVariables> for WasiRuntimeConfig<'a> {
+    fn from(vars: &'a WasiRuntimeConfigVariables) -> Self {
+        Self { vars }
+    }
+}
+
+impl<'a> WasiRuntimeConfig<'a> {
+    /// Create a new view into the `wasi-runtime-config` state.
+    pub fn new(vars: &'a WasiRuntimeConfigVariables) -> Self {
+        Self { vars }
+    }
+}
+
+impl generated::Host for WasiRuntimeConfig<'_> {
+    fn get(&mut self, key: String) -> Result<Result<Option<String>, generated::ConfigError>> {
+        Ok(Ok(self.vars.0.get(&key).map(|s| s.to_owned())))
+    }
+
+    fn get_all(&mut self) -> Result<Result<Vec<(String, String)>, generated::ConfigError>> {
+        Ok(Ok(self
+            .vars
+            .0
+            .iter()
+            .map(|(k, v)| (k.to_string(), v.to_string()))
+            .collect()))
+    }
+}
+
+/// Add all the `wasi-runtime-config` world's interfaces to a [`wasmtime::component::Linker`].
+pub fn add_to_linker<T>(
+    l: &mut wasmtime::component::Linker<T>,
+    f: impl Fn(&mut T) -> WasiRuntimeConfig<'_> + Send + Sync + Copy + 'static,
+) -> Result<()> {
+    generated::add_to_linker_get_host(l, f)?;
+    Ok(())
+}
diff --git a/crates/wasi-runtime-config/tests/main.rs b/crates/wasi-runtime-config/tests/main.rs
new file mode 100644
index 000000000000..5c07bc9e3fc7
--- /dev/null
+++ b/crates/wasi-runtime-config/tests/main.rs
@@ -0,0 +1,69 @@
+use anyhow::{anyhow, Result};
+use test_programs_artifacts::{foreach_runtime_config, RUNTIME_CONFIG_GET_COMPONENT};
+use wasmtime::{
+    component::{Component, Linker, ResourceTable},
+    Store,
+};
+use wasmtime_wasi::{add_to_linker_async, bindings::Command, WasiCtx, WasiCtxBuilder, WasiView};
+use wasmtime_wasi_runtime_config::{WasiRuntimeConfig, WasiRuntimeConfigVariables};
+
+struct Ctx {
+    table: ResourceTable,
+    wasi_ctx: WasiCtx,
+    wasi_runtime_config_vars: WasiRuntimeConfigVariables,
+}
+
+impl WasiView for Ctx {
+    fn table(&mut self) -> &mut ResourceTable {
+        &mut self.table
+    }
+
+    fn ctx(&mut self) -> &mut WasiCtx {
+        &mut self.wasi_ctx
+    }
+}
+
+async fn run_wasi(path: &str, ctx: Ctx) -> Result<()> {
+    let engine = test_programs_artifacts::engine(|config| {
+        config.async_support(true);
+    });
+    let mut store = Store::new(&engine, ctx);
+    let component = Component::from_file(&engine, path)?;
+
+    let mut linker = Linker::new(&engine);
+    add_to_linker_async(&mut linker)?;
+    wasmtime_wasi_runtime_config::add_to_linker(&mut linker, |h: &mut Ctx| {
+        WasiRuntimeConfig::from(&h.wasi_runtime_config_vars)
+    })?;
+
+    let command = Command::instantiate_async(&mut store, &component, &linker).await?;
+    command
+        .wasi_cli_run()
+        .call_run(&mut store)
+        .await?
+        .map_err(|()| anyhow!("command returned with failing exit status"))
+}
+
+macro_rules! assert_test_exists {
+    ($name:ident) => {
+        #[allow(unused_imports)]
+        use self::$name as _;
+    };
+}
+
+foreach_runtime_config!(assert_test_exists);
+
+#[tokio::test(flavor = "multi_thread")]
+async fn runtime_config_get() -> Result<()> {
+    run_wasi(
+        RUNTIME_CONFIG_GET_COMPONENT,
+        Ctx {
+            table: ResourceTable::new(),
+            wasi_ctx: WasiCtxBuilder::new().build(),
+            wasi_runtime_config_vars: WasiRuntimeConfigVariables::from_iter(vec![(
+                "hello", "world",
+            )]),
+        },
+    )
+    .await
+}
diff --git a/crates/wasi-runtime-config/wit/deps/runtime-config/runtime_config.wit b/crates/wasi-runtime-config/wit/deps/runtime-config/runtime_config.wit
new file mode 100644
index 000000000000..29d53b1acd30
--- /dev/null
+++ b/crates/wasi-runtime-config/wit/deps/runtime-config/runtime_config.wit
@@ -0,0 +1,25 @@
+interface runtime {
+    /// An error type that encapsulates the different errors that can occur fetching config
+    variant config-error {
+        /// This indicates an error from an "upstream" config source. 
+        /// As this could be almost _anything_ (such as Vault, Kubernetes ConfigMaps, KeyValue buckets, etc), 
+        /// the error message is a string.
+        upstream(string),
+        /// This indicates an error from an I/O operation. 
+        /// As this could be almost _anything_ (such as a file read, network connection, etc), 
+        /// the error message is a string. 
+        /// Depending on how this ends up being consumed, 
+        /// we may consider moving this to use the `wasi:io/error` type instead. 
+        /// For simplicity right now in supporting multiple implementations, it is being left as a string.
+        io(string),
+    }
+
+    /// Gets a single opaque config value set at the given key if it exists
+    get: func(
+        /// A string key to fetch
+        key: string
+    ) -> result<option<string>, config-error>;
+
+    /// Gets a list of all set config data
+    get-all: func() -> result<list<tuple<string, string>>, config-error>;
+}
diff --git a/crates/wasi-runtime-config/wit/deps/runtime-config/world.wit b/crates/wasi-runtime-config/wit/deps/runtime-config/world.wit
new file mode 100644
index 000000000000..378c4a77954c
--- /dev/null
+++ b/crates/wasi-runtime-config/wit/deps/runtime-config/world.wit
@@ -0,0 +1,6 @@
+package wasi:config@0.2.0-draft;
+
+world imports {
+    /// The runtime interface for config
+    import runtime;
+}
\ No newline at end of file
diff --git a/crates/wasi-runtime-config/wit/world.wit b/crates/wasi-runtime-config/wit/world.wit
new file mode 100644
index 000000000000..35a25fd746d0
--- /dev/null
+++ b/crates/wasi-runtime-config/wit/world.wit
@@ -0,0 +1,6 @@
+// We actually don't use this; it's just to let bindgen! find the corresponding world in wit/deps.
+package wasmtime:wasi-config;
+
+world bindings {
+  include wasi:config/imports@0.2.0-draft;
+}
diff --git a/crates/wasi-threads/Cargo.toml b/crates/wasi-threads/Cargo.toml
index b1f82c463652..8ec1c9616465 100644
--- a/crates/wasi-threads/Cargo.toml
+++ b/crates/wasi-threads/Cargo.toml
@@ -5,18 +5,20 @@ authors.workspace = true
 description = "Wasmtime implementation of the wasi-threads API"
 documentation = "https://docs.rs/wasmtime-wasi-nn"
 license = "Apache-2.0 WITH LLVM-exception"
-categories = ["wasm", "parallelism", "threads"]
+categories = ["wasm"]
 keywords = ["webassembly", "wasm", "neural-network"]
 repository = "https://github.com/bytecodealliance/wasmtime"
 readme = "README.md"
 edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
 
 [dependencies]
 anyhow = { workspace = true }
 log = { workspace = true }
 rand = "0.8"
-wasi-common = { workspace = true }
-wasmtime = { workspace = true }
-wasmtime-wasi = { workspace = true, default-features = true, features = [
-    "exit",
-] }
+wasi-common = { workspace = true, features = ["exit"]}
+wasmtime = { workspace = true, features = ['threads'] }
+wasmtime-wasi = { workspace = true }
diff --git a/crates/wasi-threads/src/lib.rs b/crates/wasi-threads/src/lib.rs
index 76f12edae86a..be775f5a4c13 100644
--- a/crates/wasi-threads/src/lib.rs
+++ b/crates/wasi-threads/src/lib.rs
@@ -3,12 +3,11 @@
 //! [`wasi-threads`]: https://github.com/WebAssembly/wasi-threads
 
 use anyhow::{anyhow, Result};
-use rand::Rng;
 use std::panic::{catch_unwind, AssertUnwindSafe};
+use std::sync::atomic::{AtomicI32, Ordering};
 use std::sync::Arc;
 use std::thread;
-use wasmtime::{Caller, ExternType, InstancePre, Linker, Module, SharedMemory, Store, ValType};
-use wasmtime_wasi::maybe_exit_on_error;
+use wasmtime::{Caller, ExternType, InstancePre, Linker, Module, SharedMemory, Store};
 
 // This name is a function export designated by the wasi-threads specification:
 // https://github.com/WebAssembly/wasi-threads/#detailed-design-discussion
@@ -16,12 +15,14 @@ const WASI_ENTRY_POINT: &str = "wasi_thread_start";
 
 pub struct WasiThreadsCtx<T> {
     instance_pre: Arc<InstancePre<T>>,
+    tid: AtomicI32,
 }
 
 impl<T: Clone + Send + 'static> WasiThreadsCtx<T> {
     pub fn new(module: Module, linker: Arc<Linker<T>>) -> Result<Self> {
         let instance_pre = Arc::new(linker.instantiate_pre(&module)?);
-        Ok(Self { instance_pre })
+        let tid = AtomicI32::new(0);
+        Ok(Self { instance_pre, tid })
     }
 
     pub fn spawn(&self, host: T, thread_start_arg: i32) -> Result<i32> {
@@ -45,16 +46,29 @@ impl<T: Clone + Send + 'static> WasiThreadsCtx<T> {
             return Ok(-1);
         }
 
+        let wasi_thread_id = self.next_thread_id();
+        if wasi_thread_id.is_none() {
+            log::error!("ran out of valid thread IDs");
+            return Ok(-1);
+        }
+        let wasi_thread_id = wasi_thread_id.unwrap();
+
         // Start a Rust thread running a new instance of the current module.
-        let wasi_thread_id = random_thread_id();
-        let builder = thread::Builder::new().name(format!("wasi-thread-{}", wasi_thread_id));
+        let builder = thread::Builder::new().name(format!("wasi-thread-{wasi_thread_id}"));
         builder.spawn(move || {
             // Catch any panic failures in host code; e.g., if a WASI module
             // were to crash, we want all threads to exit, not just this one.
             let result = catch_unwind(AssertUnwindSafe(|| {
                 // Each new instance is created in its own store.
                 let mut store = Store::new(&instance_pre.module().engine(), host);
-                let instance = instance_pre.instantiate(&mut store).unwrap();
+
+                let instance = if instance_pre.module().engine().is_async() {
+                    wasmtime_wasi::runtime::in_tokio(instance_pre.instantiate_async(&mut store))
+                } else {
+                    instance_pre.instantiate(&mut store)
+                }
+                .unwrap();
+
                 let thread_entry_point = instance
                     .get_typed_func::<(i32, i32), ()>(&mut store, WASI_ENTRY_POINT)
                     .unwrap();
@@ -70,35 +84,50 @@ impl<T: Clone + Send + 'static> WasiThreadsCtx<T> {
                     WASI_ENTRY_POINT,
                     thread_start_arg
                 );
-                match thread_entry_point.call(&mut store, (wasi_thread_id, thread_start_arg)) {
+                let res = if instance_pre.module().engine().is_async() {
+                    wasmtime_wasi::runtime::in_tokio(
+                        thread_entry_point
+                            .call_async(&mut store, (wasi_thread_id, thread_start_arg)),
+                    )
+                } else {
+                    thread_entry_point.call(&mut store, (wasi_thread_id, thread_start_arg))
+                };
+                match res {
                     Ok(_) => log::trace!("exiting thread id = {} normally", wasi_thread_id),
                     Err(e) => {
                         log::trace!("exiting thread id = {} due to error", wasi_thread_id);
-                        let e = maybe_exit_on_error(e);
-                        eprintln!("Error: {:?}", e);
+                        let e = wasi_common::maybe_exit_on_error(e);
+                        eprintln!("Error: {e:?}");
                         std::process::exit(1);
                     }
                 }
             }));
 
             if let Err(e) = result {
-                eprintln!("wasi-thread-{} panicked: {:?}", wasi_thread_id, e);
+                eprintln!("wasi-thread-{wasi_thread_id} panicked: {e:?}");
                 std::process::exit(1);
             }
         })?;
 
         Ok(wasi_thread_id)
     }
-}
 
-/// Helper for generating valid WASI thread IDs (TID).
-///
-/// Callers of `wasi_thread_spawn` expect a TID >=0 to indicate a successful
-/// spawning of the thread whereas a negative return value indicates an
-/// failure to spawn.
-fn random_thread_id() -> i32 {
-    let tid: u32 = rand::thread_rng().gen();
-    (tid >> 1) as i32
+    /// Helper for generating valid WASI thread IDs (TID).
+    ///
+    /// Callers of `wasi_thread_spawn` expect a TID in range of 0 < TID <= 0x1FFFFFFF
+    /// to indicate a successful spawning of the thread whereas a negative
+    /// return value indicates an failure to spawn.
+    fn next_thread_id(&self) -> Option<i32> {
+        match self
+            .tid
+            .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |v| match v {
+                ..=0x1ffffffe => Some(v + 1),
+                _ => None,
+            }) {
+            Ok(v) => Some(v + 1),
+            Err(_) => None,
+        }
+    }
 }
 
 /// Manually add the WASI `thread_spawn` function to the linker.
@@ -121,7 +150,7 @@ pub fn add_to_linker<T: Clone + Send + 'static>(
             let ctx = get_cx(caller.data_mut());
             match ctx.spawn(host, start_arg) {
                 Ok(thread_id) => {
-                    assert!(thread_id >= 0, "thread_id = {}", thread_id);
+                    assert!(thread_id >= 0, "thread_id = {thread_id}");
                     thread_id
                 }
                 Err(e) => {
@@ -157,9 +186,13 @@ fn has_entry_point(module: &Module) -> bool {
 
 /// Check if the entry function has the correct signature `(i32, i32) -> ()`.
 fn has_correct_signature(module: &Module) -> bool {
-    use ValType::*;
     match module.get_export(WASI_ENTRY_POINT) {
-        Some(ExternType::Func(ty)) => ty.params().eq([I32, I32]) && ty.results().len() == 0,
+        Some(ExternType::Func(ty)) => {
+            ty.params().len() == 2
+                && ty.params().nth(0).unwrap().is_i32()
+                && ty.params().nth(1).unwrap().is_i32()
+                && ty.results().len() == 0
+        }
         _ => false,
     }
 }
diff --git a/crates/wasi/Cargo.toml b/crates/wasi/Cargo.toml
index 1582ddfc18b1..1f261061666e 100644
--- a/crates/wasi/Cargo.toml
+++ b/crates/wasi/Cargo.toml
@@ -9,78 +9,57 @@ keywords = ["webassembly", "wasm"]
 repository = "https://github.com/bytecodealliance/wasmtime"
 readme = "README.md"
 edition.workspace = true
-include = ["src/**/*", "README.md", "LICENSE", "build.rs", "witx/*", "wit/**/*"]
-build = "build.rs"
+rust-version.workspace = true
+include = ["src/**/*", "README.md", "LICENSE", "witx/*", "wit/**/*", "tests/*"]
+
+[lints]
+workspace = true
 
 [dependencies]
-wasmtime = { workspace = true }
+wasmtime = { workspace = true, features = ["component-model", "async", "runtime", "std"] }
 anyhow = { workspace = true }
-wasi-common = { workspace = true }
-wasi-cap-std-sync = { workspace = true, optional = true }
-wasi-tokio = { workspace = true, optional = true }
-wiggle = { workspace = true, optional = true }
-libc = { workspace = true }
-once_cell = { workspace = true }
-log = { workspace = true }
-url = { workspace = true }
-
-tokio = { workspace = true, optional = true, features = ["time", "sync", "io-std", "io-util", "rt", "rt-multi-thread", "net"] }
+wiggle = { workspace = true, optional = true, features = ["wasmtime"] }
+tokio = { workspace = true,  features = ["time", "sync", "io-std", "io-util", "rt", "rt-multi-thread", "net"] }
 bytes = { workspace = true }
-thiserror = { workspace = true, optional = true }
-tracing = { workspace = true, optional = true }
-cap-std = { workspace = true, optional = true }
-cap-rand = { workspace = true, optional = true }
-cap-fs-ext = { workspace = true, optional = true }
-cap-net-ext = { workspace = true, optional = true }
-cap-time-ext = { workspace = true, optional = true }
-io-lifetimes = { workspace = true, optional = true }
-fs-set-times = { workspace = true, optional = true }
-bitflags = { workspace = true, optional = true }
-async-trait = { workspace = true, optional = true }
-system-interface = { workspace = true, optional = true}
-futures = { workspace = true, optional = true }
+thiserror = { workspace = true }
+tracing = { workspace = true }
+cap-std = { workspace = true }
+cap-rand = { workspace = true }
+cap-fs-ext = { workspace = true }
+cap-net-ext = { workspace = true }
+cap-time-ext = { workspace = true }
+io-lifetimes = { workspace = true }
+fs-set-times = { workspace = true }
+bitflags = { workspace = true }
+async-trait = { workspace = true }
+system-interface = { workspace = true}
+futures = { workspace = true }
+url = { workspace = true }
+once_cell = { workspace = true }
 
 [dev-dependencies]
-tokio = { workspace = true, features = ["time", "sync", "io-std", "io-util", "rt", "rt-multi-thread", "net", "macros"] }
+tokio = { workspace = true, features = ["time", "sync", "io-std", "io-util", "rt", "rt-multi-thread", "net", "macros", "fs"] }
 test-log = { workspace = true }
 tracing-subscriber = { workspace = true }
+test-programs-artifacts = { workspace = true }
+tempfile = { workspace = true }
+wasmtime = { workspace = true, features = ['cranelift', 'incremental-cache'] }
 
 [target.'cfg(unix)'.dependencies]
-rustix = { workspace = true, features = ["event", "fs", "net"], optional = true }
-
-[target.'cfg(unix)'.dev-dependencies]
-libc = { workspace = true }
+rustix = { workspace = true, features = ["event", "fs", "net"] }
 
 [target.'cfg(windows)'.dependencies]
 io-extras = { workspace = true }
 windows-sys = { workspace = true }
-rustix = { workspace = true, features = ["event", "net"], optional = true }
+rustix = { workspace = true, features = ["event", "net"] }
 
 [features]
-default = ["sync", "preview2", "preview1-on-preview2"]
-sync = ["wasi-cap-std-sync", "wiggle"]
-tokio = ["wasi-tokio", "wasmtime/async", "wiggle/wasmtime_async" ]
-exit = []
-preview2 = [
-    'wasmtime/component-model',
-    'wasmtime/async',
-    'dep:thiserror',
-    'dep:tracing',
-    'dep:cap-std',
-    'dep:cap-rand',
-    'dep:cap-fs-ext',
-    'dep:cap-net-ext',
-    'dep:cap-time-ext',
-    'dep:io-lifetimes',
-    'dep:fs-set-times',
-    'dep:bitflags',
-    'dep:async-trait',
-    'dep:system-interface',
-    'dep:rustix',
-    'dep:tokio',
-    'dep:futures',
-]
-preview1-on-preview2 = [
-    "preview2",
-    "wiggle",
+default = [ "preview1"]
+preview1 = [
+    "dep:wiggle",
 ]
+
+[[test]]
+name = "process_stdin"
+harness = false
+
diff --git a/crates/wasi/build.rs b/crates/wasi/build.rs
deleted file mode 100644
index 12ace81f5b13..000000000000
--- a/crates/wasi/build.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-fn main() {
-    // wasi-common's links & build.rs ensure this variable points to the wasi root:
-    let wasi_root = std::env::var("DEP_WASI_COMMON_19_WASI").unwrap();
-    // Make it available as WASI_ROOT:
-    println!("cargo:rustc-env=WASI_ROOT={}", wasi_root);
-}
diff --git a/crates/wasi/src/bindings.rs b/crates/wasi/src/bindings.rs
new file mode 100644
index 000000000000..74392b1831b3
--- /dev/null
+++ b/crates/wasi/src/bindings.rs
@@ -0,0 +1,563 @@
+//! Auto-generated bindings for WASI interfaces.
+//!
+//! This module contains the output of the [`bindgen!`] macro when run over
+//! the `wasi:cli/command` world. That means this module has all the generated
+//! types for WASI for all of its base interfaces used by the CLI world. This
+//! module itself by default contains bindings for `async`-related traits. The
+//! [`sync`] module contains bindings for a non-`async` version of types.
+//!
+//! [`bindgen!`]: https://docs.rs/wasmtime/latest/wasmtime/component/macro.bindgen.html
+//!
+//! # Examples
+//!
+//! If you have a WIT world which refers to WASI interfaces you probably want to
+//! use this crate's bindings rather than generate fresh bindings. That can be
+//! done using the `with` option to [`bindgen!`]:
+//!
+//! ```rust
+//! use wasmtime_wasi::{WasiCtx, ResourceTable, WasiView};
+//! use wasmtime::{Result, Engine, Config};
+//! use wasmtime::component::Linker;
+//!
+//! wasmtime::component::bindgen!({
+//!     inline: "
+//!         package example:wasi;
+//!
+//!         // An example of extending the `wasi:cli/command` world with a
+//!         // custom host interface.
+//!         world my-world {
+//!             include wasi:cli/command@0.2.1;
+//!
+//!             import custom-host;
+//!         }
+//!
+//!         interface custom-host {
+//!             my-custom-function: func();
+//!         }
+//!     ",
+//!     path: "wit",
+//!     with: {
+//!         "wasi": wasmtime_wasi::bindings,
+//!     },
+//!     async: true,
+//! });
+//!
+//! struct MyState {
+//!     table: ResourceTable,
+//!     ctx: WasiCtx,
+//! }
+//!
+//! #[async_trait::async_trait]
+//! impl example::wasi::custom_host::Host for MyState {
+//!     async fn my_custom_function(&mut self) {
+//!         // ..
+//!     }
+//! }
+//!
+//! impl WasiView for MyState {
+//!     fn table(&mut self) -> &mut ResourceTable { &mut self.table }
+//!     fn ctx(&mut self) -> &mut WasiCtx { &mut self.ctx }
+//! }
+//!
+//! fn main() -> Result<()> {
+//!     let mut config = Config::default();
+//!     config.async_support(true);
+//!     let engine = Engine::new(&config)?;
+//!     let mut linker: Linker<MyState> = Linker::new(&engine);
+//!     wasmtime_wasi::add_to_linker_async(&mut linker)?;
+//!     example::wasi::custom_host::add_to_linker(&mut linker, |state| state)?;
+//!
+//!     // .. use `Linker` to instantiate component ...
+//!
+//!     Ok(())
+//! }
+//! ```
+
+/// Synchronous-generated bindings for WASI interfaces.
+///
+/// This is the same as the top-level [`bindings`](crate::bindings) module of
+/// this crate except that it's for synchronous calls.
+///
+/// # Examples
+///
+/// If you have a WIT world which refers to WASI interfaces you probably want to
+/// use this crate's bindings rather than generate fresh bindings. That can be
+/// done using the `with` option to `bindgen!`:
+///
+/// ```rust
+/// use wasmtime_wasi::{WasiCtx, ResourceTable, WasiView};
+/// use wasmtime::{Result, Engine};
+/// use wasmtime::component::Linker;
+///
+/// wasmtime::component::bindgen!({
+///     inline: "
+///         package example:wasi;
+///
+///         // An example of extending the `wasi:cli/command` world with a
+///         // custom host interface.
+///         world my-world {
+///             include wasi:cli/command@0.2.1;
+///
+///             import custom-host;
+///         }
+///
+///         interface custom-host {
+///             my-custom-function: func();
+///         }
+///     ",
+///     path: "wit",
+///     with: {
+///         "wasi": wasmtime_wasi::bindings::sync,
+///     },
+///     // This is required for bindings using `wasmtime-wasi` and it otherwise
+///     // isn't the default for non-async bindings.
+///     require_store_data_send: true,
+/// });
+///
+/// struct MyState {
+///     table: ResourceTable,
+///     ctx: WasiCtx,
+/// }
+///
+/// impl example::wasi::custom_host::Host for MyState {
+///     fn my_custom_function(&mut self) {
+///         // ..
+///     }
+/// }
+///
+/// impl WasiView for MyState {
+///     fn table(&mut self) -> &mut ResourceTable { &mut self.table }
+///     fn ctx(&mut self) -> &mut WasiCtx { &mut self.ctx }
+/// }
+///
+/// fn main() -> Result<()> {
+///     let engine = Engine::default();
+///     let mut linker: Linker<MyState> = Linker::new(&engine);
+///     wasmtime_wasi::add_to_linker_sync(&mut linker)?;
+///     example::wasi::custom_host::add_to_linker(&mut linker, |state| state)?;
+///
+///     // .. use `Linker` to instantiate component ...
+///
+///     Ok(())
+/// }
+/// ```
+pub mod sync {
+    mod generated {
+        use crate::{FsError, SocketError, StreamError};
+
+        wasmtime::component::bindgen!({
+            path: "wit",
+            world: "wasi:cli/command",
+            tracing: true,
+            trappable_error_type: {
+                "wasi:io/streams/stream-error" => StreamError,
+                "wasi:filesystem/types/error-code" => FsError,
+                "wasi:sockets/network/error-code" => SocketError,
+            },
+            trappable_imports: true,
+            with: {
+                // These interfaces come from the outer module, as it's
+                // sync/async agnostic.
+                "wasi:clocks": crate::bindings::clocks,
+                "wasi:random": crate::bindings::random,
+                "wasi:cli": crate::bindings::cli,
+                "wasi:io/error": crate::bindings::io::error,
+                "wasi:filesystem/preopens": crate::bindings::filesystem::preopens,
+                "wasi:sockets/network": crate::bindings::sockets::network,
+
+                // Configure the resource types of the bound interfaces here
+                // to be the same as the async versions of the resources, that
+                // way everything has the same type.
+                "wasi:filesystem/types/descriptor": super::super::filesystem::types::Descriptor,
+                "wasi:filesystem/types/directory-entry-stream": super::super::filesystem::types::DirectoryEntryStream,
+                "wasi:io/poll/pollable": super::super::io::poll::Pollable,
+                "wasi:io/streams/input-stream": super::super::io::streams::InputStream,
+                "wasi:io/streams/output-stream": super::super::io::streams::OutputStream,
+                "wasi:sockets/tcp/tcp-socket": super::super::sockets::tcp::TcpSocket,
+                "wasi:sockets/udp/incoming-datagram-stream": super::super::sockets::udp::IncomingDatagramStream,
+                "wasi:sockets/udp/outgoing-datagram-stream": super::super::sockets::udp::OutgoingDatagramStream,
+                "wasi:sockets/udp/udp-socket": super::super::sockets::udp::UdpSocket,
+            },
+            require_store_data_send: true,
+        });
+    }
+    pub use self::generated::exports;
+    pub use self::generated::wasi::*;
+
+    /// Synchronous bindings to execute and run a `wasi:cli/command`.
+    ///
+    /// This structure is automatically generated by `bindgen!` and is intended
+    /// to be used with [`Config::async_support(false)`][async]. For the
+    /// asynchronous version see [`bindings::Command`](super::Command).
+    ///
+    /// This can be used for a more "typed" view of executing a command
+    /// component through the [`Command::wasi_cli_run`] method plus
+    /// [`Guest::call_run`](exports::wasi::cli::run::Guest::call_run).
+    ///
+    /// [async]: wasmtime::Config::async_support
+    /// [`wasmtime_wasi::add_to_linker_sync`]: crate::add_to_linker_sync
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use wasmtime::{Engine, Result, Store, Config};
+    /// use wasmtime::component::{ResourceTable, Linker, Component};
+    /// use wasmtime_wasi::{WasiCtx, WasiView, WasiCtxBuilder};
+    /// use wasmtime_wasi::bindings::sync::Command;
+    ///
+    /// // This example is an example shim of executing a component based on the
+    /// // command line arguments provided to this program.
+    /// fn main() -> Result<()> {
+    ///     let args = std::env::args().skip(1).collect::<Vec<_>>();
+    ///
+    ///     // Configure and create `Engine`
+    ///     let engine = Engine::default();
+    ///
+    ///     // Configure a `Linker` with WASI, compile a component based on
+    ///     // command line arguments.
+    ///     let mut linker = Linker::<MyState>::new(&engine);
+    ///     wasmtime_wasi::add_to_linker_async(&mut linker)?;
+    ///     let component = Component::from_file(&engine, &args[0])?;
+    ///
+    ///
+    ///     // Configure a `WasiCtx` based on this program's environment. Then
+    ///     // build a `Store` to instantiate into.
+    ///     let mut builder = WasiCtxBuilder::new();
+    ///     builder.inherit_stdio().inherit_env().args(&args[2..]);
+    ///     let mut store = Store::new(
+    ///         &engine,
+    ///         MyState {
+    ///             ctx: builder.build(),
+    ///             table: ResourceTable::new(),
+    ///         },
+    ///     );
+    ///
+    ///     // Instantiate the component and we're off to the races.
+    ///     let command = Command::instantiate(&mut store, &component, &linker)?;
+    ///     let program_result = command.wasi_cli_run().call_run(&mut store)?;
+    ///     match program_result {
+    ///         Ok(()) => Ok(()),
+    ///         Err(()) => std::process::exit(1),
+    ///     }
+    /// }
+    ///
+    /// struct MyState {
+    ///     ctx: WasiCtx,
+    ///     table: ResourceTable,
+    /// }
+    ///
+    /// impl WasiView for MyState {
+    ///     fn ctx(&mut self) -> &mut WasiCtx { &mut self.ctx }
+    ///     fn table(&mut self) -> &mut ResourceTable { &mut self.table }
+    /// }
+    /// ```
+    ///
+    /// ---
+    pub use self::generated::Command;
+
+    /// Pre-instantiated analogue of [`Command`].
+    ///
+    /// This works the same as [`Command`] but enables front-loading work such
+    /// as export lookup to before instantiation.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use wasmtime::{Engine, Result, Store, Config};
+    /// use wasmtime::component::{ResourceTable, Linker, Component};
+    /// use wasmtime_wasi::{WasiCtx, WasiView, WasiCtxBuilder};
+    /// use wasmtime_wasi::bindings::sync::CommandPre;
+    ///
+    /// // This example is an example shim of executing a component based on the
+    /// // command line arguments provided to this program.
+    /// fn main() -> Result<()> {
+    ///     let args = std::env::args().skip(1).collect::<Vec<_>>();
+    ///
+    ///     // Configure and create `Engine`
+    ///     let engine = Engine::default();
+    ///
+    ///     // Configure a `Linker` with WASI, compile a component based on
+    ///     // command line arguments, and then pre-instantiate it.
+    ///     let mut linker = Linker::<MyState>::new(&engine);
+    ///     wasmtime_wasi::add_to_linker_async(&mut linker)?;
+    ///     let component = Component::from_file(&engine, &args[0])?;
+    ///     let pre = CommandPre::new(linker.instantiate_pre(&component)?)?;
+    ///
+    ///
+    ///     // Configure a `WasiCtx` based on this program's environment. Then
+    ///     // build a `Store` to instantiate into.
+    ///     let mut builder = WasiCtxBuilder::new();
+    ///     builder.inherit_stdio().inherit_env().args(&args);
+    ///     let mut store = Store::new(
+    ///         &engine,
+    ///         MyState {
+    ///             ctx: builder.build(),
+    ///             table: ResourceTable::new(),
+    ///         },
+    ///     );
+    ///
+    ///     // Instantiate the component and we're off to the races.
+    ///     let command = pre.instantiate(&mut store)?;
+    ///     let program_result = command.wasi_cli_run().call_run(&mut store)?;
+    ///     match program_result {
+    ///         Ok(()) => Ok(()),
+    ///         Err(()) => std::process::exit(1),
+    ///     }
+    /// }
+    ///
+    /// struct MyState {
+    ///     ctx: WasiCtx,
+    ///     table: ResourceTable,
+    /// }
+    ///
+    /// impl WasiView for MyState {
+    ///     fn ctx(&mut self) -> &mut WasiCtx { &mut self.ctx }
+    ///     fn table(&mut self) -> &mut ResourceTable { &mut self.table }
+    /// }
+    /// ```
+    ///
+    /// ---
+    pub use self::generated::CommandPre;
+
+    pub use self::generated::CommandIndices;
+}
+
+mod async_io {
+    wasmtime::component::bindgen!({
+        path: "wit",
+        world: "wasi:cli/command",
+        tracing: true,
+        trappable_imports: true,
+        async: {
+            // Only these functions are `async` and everything else is sync
+            // meaning that it basically doesn't need to block. These functions
+            // are the only ones that need to block.
+            //
+            // Note that at this time `only_imports` works on function names
+            // which in theory can be shared across interfaces, so this may
+            // need fancier syntax in the future.
+            only_imports: [
+                "[method]descriptor.access-at",
+                "[method]descriptor.advise",
+                "[method]descriptor.change-directory-permissions-at",
+                "[method]descriptor.change-file-permissions-at",
+                "[method]descriptor.create-directory-at",
+                "[method]descriptor.get-flags",
+                "[method]descriptor.get-type",
+                "[method]descriptor.is-same-object",
+                "[method]descriptor.link-at",
+                "[method]descriptor.lock-exclusive",
+                "[method]descriptor.lock-shared",
+                "[method]descriptor.metadata-hash",
+                "[method]descriptor.metadata-hash-at",
+                "[method]descriptor.open-at",
+                "[method]descriptor.read",
+                "[method]descriptor.read-directory",
+                "[method]descriptor.readlink-at",
+                "[method]descriptor.remove-directory-at",
+                "[method]descriptor.rename-at",
+                "[method]descriptor.set-size",
+                "[method]descriptor.set-times",
+                "[method]descriptor.set-times-at",
+                "[method]descriptor.stat",
+                "[method]descriptor.stat-at",
+                "[method]descriptor.symlink-at",
+                "[method]descriptor.sync",
+                "[method]descriptor.sync-data",
+                "[method]descriptor.try-lock-exclusive",
+                "[method]descriptor.try-lock-shared",
+                "[method]descriptor.unlink-file-at",
+                "[method]descriptor.unlock",
+                "[method]descriptor.write",
+                "[method]input-stream.blocking-read",
+                "[method]input-stream.blocking-skip",
+                "[drop]input-stream",
+                "[method]output-stream.blocking-splice",
+                "[method]output-stream.blocking-flush",
+                "[method]output-stream.blocking-write",
+                "[method]output-stream.blocking-write-and-flush",
+                "[method]output-stream.blocking-write-zeroes-and-flush",
+                "[drop]output-stream",
+                "[method]directory-entry-stream.read-directory-entry",
+                "poll",
+                "[method]pollable.block",
+                "[method]pollable.ready",
+                "[method]tcp-socket.start-bind",
+                "[method]tcp-socket.start-connect",
+                "[method]udp-socket.start-bind",
+                "[method]udp-socket.stream",
+                "[method]outgoing-datagram-stream.send",
+            ],
+        },
+        trappable_error_type: {
+            "wasi:io/streams/stream-error" => crate::StreamError,
+            "wasi:filesystem/types/error-code" => crate::FsError,
+            "wasi:sockets/network/error-code" => crate::SocketError,
+        },
+        with: {
+            // Configure all resources to be concrete types defined in this crate,
+            // so that way we get to use nice typed helper methods with
+            // `ResourceTable`.
+            "wasi:sockets/network/network": crate::network::Network,
+            "wasi:sockets/tcp/tcp-socket": crate::tcp::TcpSocket,
+            "wasi:sockets/udp/udp-socket": crate::udp::UdpSocket,
+            "wasi:sockets/udp/incoming-datagram-stream": crate::udp::IncomingDatagramStream,
+            "wasi:sockets/udp/outgoing-datagram-stream": crate::udp::OutgoingDatagramStream,
+            "wasi:sockets/ip-name-lookup/resolve-address-stream": crate::ip_name_lookup::ResolveAddressStream,
+            "wasi:filesystem/types/directory-entry-stream": crate::filesystem::ReaddirIterator,
+            "wasi:filesystem/types/descriptor": crate::filesystem::Descriptor,
+            "wasi:io/streams/input-stream": crate::stream::InputStream,
+            "wasi:io/streams/output-stream": crate::stream::OutputStream,
+            "wasi:io/error/error": crate::stream::Error,
+            "wasi:io/poll/pollable": crate::poll::Pollable,
+            "wasi:cli/terminal-input/terminal-input": crate::stdio::TerminalInput,
+            "wasi:cli/terminal-output/terminal-output": crate::stdio::TerminalOutput,
+        },
+    });
+}
+
+pub use self::async_io::exports;
+pub use self::async_io::wasi::*;
+
+/// Asynchronous bindings to execute and run a `wasi:cli/command`.
+///
+/// This structure is automatically generated by `bindgen!` and is intended to
+/// be used with [`Config::async_support(true)`][async]. For the synchronous
+/// version see [`bindings::sync::Command`](sync::Command).
+///
+/// This can be used for a more "typed" view of executing a command component
+/// through the [`Command::wasi_cli_run`] method plus
+/// [`Guest::call_run`](exports::wasi::cli::run::Guest::call_run).
+///
+/// [async]: wasmtime::Config::async_support
+/// [`wasmtime_wasi::add_to_linker_async`]: crate::add_to_linker_async
+///
+/// # Examples
+///
+/// ```no_run
+/// use wasmtime::{Engine, Result, Store, Config};
+/// use wasmtime::component::{ResourceTable, Linker, Component};
+/// use wasmtime_wasi::{WasiCtx, WasiView, WasiCtxBuilder};
+/// use wasmtime_wasi::bindings::Command;
+///
+/// // This example is an example shim of executing a component based on the
+/// // command line arguments provided to this program.
+/// #[tokio::main]
+/// async fn main() -> Result<()> {
+///     let args = std::env::args().skip(1).collect::<Vec<_>>();
+///
+///     // Configure and create `Engine`
+///     let mut config = Config::new();
+///     config.async_support(true);
+///     let engine = Engine::new(&config)?;
+///
+///     // Configure a `Linker` with WASI, compile a component based on
+///     // command line arguments, and then pre-instantiate it.
+///     let mut linker = Linker::<MyState>::new(&engine);
+///     wasmtime_wasi::add_to_linker_async(&mut linker)?;
+///     let component = Component::from_file(&engine, &args[0])?;
+///
+///
+///     // Configure a `WasiCtx` based on this program's environment. Then
+///     // build a `Store` to instantiate into.
+///     let mut builder = WasiCtxBuilder::new();
+///     builder.inherit_stdio().inherit_env().args(&args);
+///     let mut store = Store::new(
+///         &engine,
+///         MyState {
+///             ctx: builder.build(),
+///             table: ResourceTable::new(),
+///         },
+///     );
+///
+///     // Instantiate the component and we're off to the races.
+///     let command = Command::instantiate_async(&mut store, &component, &linker).await?;
+///     let program_result = command.wasi_cli_run().call_run(&mut store).await?;
+///     match program_result {
+///         Ok(()) => Ok(()),
+///         Err(()) => std::process::exit(1),
+///     }
+/// }
+///
+/// struct MyState {
+///     ctx: WasiCtx,
+///     table: ResourceTable,
+/// }
+///
+/// impl WasiView for MyState {
+///     fn ctx(&mut self) -> &mut WasiCtx { &mut self.ctx }
+///     fn table(&mut self) -> &mut ResourceTable { &mut self.table }
+/// }
+/// ```
+///
+/// ---
+pub use self::async_io::Command;
+
+/// Pre-instantiated analog of [`Command`]
+///
+/// This can be used to front-load work such as export lookup before
+/// instantiation.
+///
+/// # Examples
+///
+/// ```no_run
+/// use wasmtime::{Engine, Result, Store, Config};
+/// use wasmtime::component::{ResourceTable, Linker, Component};
+/// use wasmtime_wasi::{WasiCtx, WasiView, WasiCtxBuilder};
+/// use wasmtime_wasi::bindings::CommandPre;
+///
+/// // This example is an example shim of executing a component based on the
+/// // command line arguments provided to this program.
+/// #[tokio::main]
+/// async fn main() -> Result<()> {
+///     let args = std::env::args().skip(1).collect::<Vec<_>>();
+///
+///     // Configure and create `Engine`
+///     let mut config = Config::new();
+///     config.async_support(true);
+///     let engine = Engine::new(&config)?;
+///
+///     // Configure a `Linker` with WASI, compile a component based on
+///     // command line arguments, and then pre-instantiate it.
+///     let mut linker = Linker::<MyState>::new(&engine);
+///     wasmtime_wasi::add_to_linker_async(&mut linker)?;
+///     let component = Component::from_file(&engine, &args[0])?;
+///     let pre = CommandPre::new(linker.instantiate_pre(&component)?)?;
+///
+///
+///     // Configure a `WasiCtx` based on this program's environment. Then
+///     // build a `Store` to instantiate into.
+///     let mut builder = WasiCtxBuilder::new();
+///     builder.inherit_stdio().inherit_env().args(&args);
+///     let mut store = Store::new(
+///         &engine,
+///         MyState {
+///             ctx: builder.build(),
+///             table: ResourceTable::new(),
+///         },
+///     );
+///
+///     // Instantiate the component and we're off to the races.
+///     let command = pre.instantiate_async(&mut store).await?;
+///     let program_result = command.wasi_cli_run().call_run(&mut store).await?;
+///     match program_result {
+///         Ok(()) => Ok(()),
+///         Err(()) => std::process::exit(1),
+///     }
+/// }
+///
+/// struct MyState {
+///     ctx: WasiCtx,
+///     table: ResourceTable,
+/// }
+///
+/// impl WasiView for MyState {
+///     fn ctx(&mut self) -> &mut WasiCtx { &mut self.ctx }
+///     fn table(&mut self) -> &mut ResourceTable { &mut self.table }
+/// }
+/// ```
+///
+/// ---
+pub use self::async_io::CommandPre;
+
+pub use self::async_io::CommandIndices;
diff --git a/crates/wasi/src/clocks.rs b/crates/wasi/src/clocks.rs
new file mode 100644
index 000000000000..175ac1990ffc
--- /dev/null
+++ b/crates/wasi/src/clocks.rs
@@ -0,0 +1,12 @@
+pub mod host;
+use cap_std::time::Duration;
+
+pub trait HostWallClock: Send {
+    fn resolution(&self) -> Duration;
+    fn now(&self) -> Duration;
+}
+
+pub trait HostMonotonicClock: Send {
+    fn resolution(&self) -> u64;
+    fn now(&self) -> u64;
+}
diff --git a/crates/wasi/src/clocks/host.rs b/crates/wasi/src/clocks/host.rs
new file mode 100644
index 000000000000..20b35ce6438f
--- /dev/null
+++ b/crates/wasi/src/clocks/host.rs
@@ -0,0 +1,73 @@
+use super::{HostMonotonicClock, HostWallClock};
+use cap_std::time::{Duration, Instant, SystemClock};
+use cap_std::{ambient_authority, AmbientAuthority};
+use cap_time_ext::{MonotonicClockExt, SystemClockExt};
+
+pub struct WallClock {
+    /// The underlying system clock.
+    clock: cap_std::time::SystemClock,
+}
+
+impl WallClock {
+    pub fn new(ambient_authority: AmbientAuthority) -> Self {
+        Self {
+            clock: cap_std::time::SystemClock::new(ambient_authority),
+        }
+    }
+}
+
+impl HostWallClock for WallClock {
+    fn resolution(&self) -> Duration {
+        self.clock.resolution()
+    }
+
+    fn now(&self) -> Duration {
+        // WASI defines wall clocks to return "Unix time".
+        self.clock
+            .now()
+            .duration_since(SystemClock::UNIX_EPOCH)
+            .unwrap()
+    }
+}
+
+pub struct MonotonicClock {
+    /// The underlying system clock.
+    clock: cap_std::time::MonotonicClock,
+
+    /// The `Instant` this clock was created. All returned times are
+    /// durations since that time.
+    initial: Instant,
+}
+
+impl MonotonicClock {
+    pub fn new(ambient_authority: AmbientAuthority) -> Self {
+        let clock = cap_std::time::MonotonicClock::new(ambient_authority);
+        let initial = clock.now();
+        Self { clock, initial }
+    }
+}
+
+impl HostMonotonicClock for MonotonicClock {
+    fn resolution(&self) -> u64 {
+        self.clock.resolution().as_nanos().try_into().unwrap()
+    }
+
+    fn now(&self) -> u64 {
+        // Unwrap here and in `resolution` above; a `u64` is wide enough to
+        // hold over 584 years of nanoseconds.
+        self.clock
+            .now()
+            .duration_since(self.initial)
+            .as_nanos()
+            .try_into()
+            .unwrap()
+    }
+}
+
+pub fn monotonic_clock() -> Box<dyn HostMonotonicClock + Send> {
+    Box::new(MonotonicClock::new(ambient_authority()))
+}
+
+pub fn wall_clock() -> Box<dyn HostWallClock + Send> {
+    Box::new(WallClock::new(ambient_authority()))
+}
diff --git a/crates/wasi/src/ctx.rs b/crates/wasi/src/ctx.rs
new file mode 100644
index 000000000000..136047b9c887
--- /dev/null
+++ b/crates/wasi/src/ctx.rs
@@ -0,0 +1,704 @@
+use crate::{
+    clocks::{
+        host::{monotonic_clock, wall_clock},
+        HostMonotonicClock, HostWallClock,
+    },
+    filesystem::{Dir, OpenMode},
+    network::{SocketAddrCheck, SocketAddrUse},
+    pipe, random, stdio,
+    stdio::{StdinStream, StdoutStream},
+    DirPerms, FilePerms,
+};
+use anyhow::Result;
+use cap_rand::{Rng, RngCore, SeedableRng};
+use cap_std::ambient_authority;
+use std::path::Path;
+use std::sync::Arc;
+use std::{future::Future, pin::Pin};
+use std::{mem, net::SocketAddr};
+use wasmtime::component::ResourceTable;
+
+/// Builder-style structure used to create a [`WasiCtx`].
+///
+/// This type is used to create a [`WasiCtx`] that is considered per-[`Store`]
+/// state. The [`build`][WasiCtxBuilder::build] method is used to finish the
+/// building process and produce a finalized [`WasiCtx`].
+///
+/// # Examples
+///
+/// ```
+/// use wasmtime_wasi::{WasiCtxBuilder, WasiCtx};
+///
+/// let mut wasi = WasiCtxBuilder::new();
+/// wasi.arg("./foo.wasm");
+/// wasi.arg("--help");
+/// wasi.env("FOO", "bar");
+///
+/// let wasi: WasiCtx = wasi.build();
+/// ```
+///
+/// [`Store`]: wasmtime::Store
+pub struct WasiCtxBuilder {
+    stdin: Box<dyn StdinStream>,
+    stdout: Box<dyn StdoutStream>,
+    stderr: Box<dyn StdoutStream>,
+    env: Vec<(String, String)>,
+    args: Vec<String>,
+    preopens: Vec<(Dir, String)>,
+    socket_addr_check: SocketAddrCheck,
+    random: Box<dyn RngCore + Send>,
+    insecure_random: Box<dyn RngCore + Send>,
+    insecure_random_seed: u128,
+    wall_clock: Box<dyn HostWallClock + Send>,
+    monotonic_clock: Box<dyn HostMonotonicClock + Send>,
+    allowed_network_uses: AllowedNetworkUses,
+    allow_blocking_current_thread: bool,
+    built: bool,
+}
+
+impl WasiCtxBuilder {
+    /// Creates a builder for a new context with default parameters set.
+    ///
+    /// The current defaults are:
+    ///
+    /// * stdin is closed
+    /// * stdout and stderr eat all input and it doesn't go anywhere
+    /// * no env vars
+    /// * no arguments
+    /// * no preopens
+    /// * clocks use the host implementation of wall/monotonic clocks
+    /// * RNGs are all initialized with random state and suitable generator
+    ///   quality to satisfy the requirements of WASI APIs.
+    /// * TCP/UDP are allowed but all addresses are denied by default.
+    /// * `wasi:network/ip-name-lookup` is denied by default.
+    ///
+    /// These defaults can all be updated via the various builder configuration
+    /// methods below.
+    pub fn new() -> Self {
+        // For the insecure random API, use `SmallRng`, which is fast. It's
+        // also insecure, but that's the deal here.
+        let insecure_random = Box::new(
+            cap_rand::rngs::SmallRng::from_rng(cap_rand::thread_rng(cap_rand::ambient_authority()))
+                .unwrap(),
+        );
+
+        // For the insecure random seed, use a `u128` generated from
+        // `thread_rng()`, so that it's not guessable from the insecure_random
+        // API.
+        let insecure_random_seed =
+            cap_rand::thread_rng(cap_rand::ambient_authority()).gen::<u128>();
+        Self {
+            stdin: Box::new(pipe::ClosedInputStream),
+            stdout: Box::new(pipe::SinkOutputStream),
+            stderr: Box::new(pipe::SinkOutputStream),
+            env: Vec::new(),
+            args: Vec::new(),
+            preopens: Vec::new(),
+            socket_addr_check: SocketAddrCheck::default(),
+            random: random::thread_rng(),
+            insecure_random,
+            insecure_random_seed,
+            wall_clock: wall_clock(),
+            monotonic_clock: monotonic_clock(),
+            allowed_network_uses: AllowedNetworkUses::default(),
+            allow_blocking_current_thread: false,
+            built: false,
+        }
+    }
+
+    /// Provides a custom implementation of stdin to use.
+    ///
+    /// By default stdin is closed but an example of using the host's native
+    /// stdin looks like:
+    ///
+    /// ```
+    /// use wasmtime_wasi::{stdin, WasiCtxBuilder};
+    ///
+    /// let mut wasi = WasiCtxBuilder::new();
+    /// wasi.stdin(stdin());
+    /// ```
+    ///
+    /// Note that inheriting the process's stdin can also be done through
+    /// [`inherit_stdin`](WasiCtxBuilder::inherit_stdin).
+    pub fn stdin(&mut self, stdin: impl StdinStream + 'static) -> &mut Self {
+        self.stdin = Box::new(stdin);
+        self
+    }
+
+    /// Same as [`stdin`](WasiCtxBuilder::stdin), but for stdout.
+    pub fn stdout(&mut self, stdout: impl StdoutStream + 'static) -> &mut Self {
+        self.stdout = Box::new(stdout);
+        self
+    }
+
+    /// Same as [`stdin`](WasiCtxBuilder::stdin), but for stderr.
+    pub fn stderr(&mut self, stderr: impl StdoutStream + 'static) -> &mut Self {
+        self.stderr = Box::new(stderr);
+        self
+    }
+
+    /// Configures this context's stdin stream to read the host process's
+    /// stdin.
+    ///
+    /// Note that concurrent reads of stdin can produce surprising results so
+    /// when using this it's typically best to have a single wasm instance in
+    /// the process using this.
+    pub fn inherit_stdin(&mut self) -> &mut Self {
+        self.stdin(stdio::stdin())
+    }
+
+    /// Configures this context's stdout stream to write to the host process's
+    /// stdout.
+    ///
+    /// Note that unlike [`inherit_stdin`](WasiCtxBuilder::inherit_stdin)
+    /// multiple instances printing to stdout works well.
+    pub fn inherit_stdout(&mut self) -> &mut Self {
+        self.stdout(stdio::stdout())
+    }
+
+    /// Configures this context's stderr stream to write to the host process's
+    /// stderr.
+    ///
+    /// Note that unlike [`inherit_stdin`](WasiCtxBuilder::inherit_stdin)
+    /// multiple instances printing to stderr works well.
+    pub fn inherit_stderr(&mut self) -> &mut Self {
+        self.stderr(stdio::stderr())
+    }
+
+    /// Configures all of stdin, stdout, and stderr to be inherited from the
+    /// host process.
+    ///
+    /// See [`inherit_stdin`](WasiCtxBuilder::inherit_stdin) for some rationale
+    /// on why this should only be done in situations of
+    /// one-instance-per-process.
+    pub fn inherit_stdio(&mut self) -> &mut Self {
+        self.inherit_stdin().inherit_stdout().inherit_stderr()
+    }
+
+    /// Configures whether or not blocking operations made through this
+    /// `WasiCtx` are allowed to block the current thread.
+    ///
+    /// WASI is currently implemented on top of the Rust
+    /// [Tokio](https://tokio.rs/) library. While most WASI APIs are
+    /// non-blocking some are instead blocking from the perspective of
+    /// WebAssembly. For example opening a file is a blocking operation with
+    /// respect to WebAssembly but it's implemented as an asynchronous operation
+    /// on the host. This is currently done with Tokio's
+    /// [`spawn_blocking`](https://docs.rs/tokio/latest/tokio/task/fn.spawn_blocking.html).
+    ///
+    /// When WebAssembly is used in a synchronous context, for example when
+    /// [`Config::async_support`] is disabled, then this asynchronous operation
+    /// is quickly turned back into a synchronous operation with a `block_on` in
+    /// Rust. This switching back-and-forth between a blocking a non-blocking
+    /// context can have overhead, and this option exists to help alleviate this
+    /// overhead.
+    ///
+    /// This option indicates that for WASI functions that are blocking from the
+    /// perspective of WebAssembly it's ok to block the native thread as well.
+    /// This means that this back-and-forth between async and sync won't happen
+    /// and instead blocking operations are performed on-thread (such as opening
+    /// a file). This can improve the performance of WASI operations when async
+    /// support is disabled.
+    ///
+    /// [`Config::async_support`]: https://docs.rs/wasmtime/latest/wasmtime/struct.Config.html#method.async_support
+    pub fn allow_blocking_current_thread(&mut self, enable: bool) -> &mut Self {
+        self.allow_blocking_current_thread = enable;
+        self
+    }
+
+    /// Appends multiple environment variables at once for this builder.
+    ///
+    /// All environment variables are appended to the list of environment
+    /// variables that this builder will configure.
+    ///
+    /// At this time environment variables are not deduplicated and if the same
+    /// key is set twice then the guest will see two entries for the same key.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use wasmtime_wasi::{stdin, WasiCtxBuilder};
+    ///
+    /// let mut wasi = WasiCtxBuilder::new();
+    /// wasi.envs(&[
+    ///     ("FOO", "bar"),
+    ///     ("HOME", "/somewhere"),
+    /// ]);
+    /// ```
+    pub fn envs(&mut self, env: &[(impl AsRef<str>, impl AsRef<str>)]) -> &mut Self {
+        self.env.extend(
+            env.iter()
+                .map(|(k, v)| (k.as_ref().to_owned(), v.as_ref().to_owned())),
+        );
+        self
+    }
+
+    /// Appends a single environment variable for this builder.
+    ///
+    /// At this time environment variables are not deduplicated and if the same
+    /// key is set twice then the guest will see two entries for the same key.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use wasmtime_wasi::{stdin, WasiCtxBuilder};
+    ///
+    /// let mut wasi = WasiCtxBuilder::new();
+    /// wasi.env("FOO", "bar");
+    /// ```
+    pub fn env(&mut self, k: impl AsRef<str>, v: impl AsRef<str>) -> &mut Self {
+        self.env
+            .push((k.as_ref().to_owned(), v.as_ref().to_owned()));
+        self
+    }
+
+    /// Configures all environment variables to be inherited from the calling
+    /// process into this configuration.
+    ///
+    /// This will use [`envs`](WasiCtxBuilder::envs) to append all host-defined
+    /// environment variables.
+    pub fn inherit_env(&mut self) -> &mut Self {
+        self.envs(&std::env::vars().collect::<Vec<(String, String)>>())
+    }
+
+    /// Appends a list of arguments to the argument array to pass to wasm.
+    pub fn args(&mut self, args: &[impl AsRef<str>]) -> &mut Self {
+        self.args.extend(args.iter().map(|a| a.as_ref().to_owned()));
+        self
+    }
+
+    /// Appends a single argument to get passed to wasm.
+    pub fn arg(&mut self, arg: impl AsRef<str>) -> &mut Self {
+        self.args.push(arg.as_ref().to_owned());
+        self
+    }
+
+    /// Appends all host process arguments to the list of arguments to get
+    /// passed to wasm.
+    pub fn inherit_args(&mut self) -> &mut Self {
+        self.args(&std::env::args().collect::<Vec<String>>())
+    }
+
+    /// Configures a "preopened directory" to be available to WebAssembly.
+    ///
+    /// By default WebAssembly does not have access to the filesystem because
+    /// the are no preopened directories. All filesystem operations, such as
+    /// opening a file, are done through a preexisting handle. This means that
+    /// to provide WebAssembly access to a directory it must be configured
+    /// through this API.
+    ///
+    /// WASI will also prevent access outside of files provided here. For
+    /// example `..` can't be used to traverse up from the `dir` provided here
+    /// to the containing directory.
+    ///
+    /// * `host_path` - a path to a directory on the host to open and make
+    ///   accessible to WebAssembly. Note that the name of this directory in the
+    ///   guest is configured with `guest_path` below.
+    /// * `guest_path` - the name of the preopened directory from WebAssembly's
+    ///   perspective. Note that this does not need to match the host's name for
+    ///   the directory.
+    /// * `dir_perms` - this is the permissions that wasm will have to operate on
+    ///   `dir`. This can be used, for example, to provide readonly access to a
+    ///   directory.
+    /// * `file_perms` - similar to `perms` but corresponds to the maximum set
+    ///   of permissions that can be used for any file in this directory.
+    ///
+    /// # Errors
+    ///
+    /// This method will return an error if `host_path` cannot be opened.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use wasmtime_wasi::{WasiCtxBuilder, DirPerms, FilePerms};
+    ///
+    /// # fn main() {}
+    /// # fn foo() -> wasmtime::Result<()> {
+    /// let mut wasi = WasiCtxBuilder::new();
+    ///
+    /// // Make `./host-directory` available in the guest as `.`
+    /// wasi.preopened_dir("./host-directory", ".", DirPerms::all(), FilePerms::all());
+    ///
+    /// // Make `./readonly` available in the guest as `./ro`
+    /// wasi.preopened_dir("./readonly", "./ro", DirPerms::READ, FilePerms::READ);
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn preopened_dir(
+        &mut self,
+        host_path: impl AsRef<Path>,
+        guest_path: impl AsRef<str>,
+        dir_perms: DirPerms,
+        file_perms: FilePerms,
+    ) -> Result<&mut Self> {
+        let dir = cap_std::fs::Dir::open_ambient_dir(host_path.as_ref(), ambient_authority())?;
+        let mut open_mode = OpenMode::empty();
+        if dir_perms.contains(DirPerms::READ) {
+            open_mode |= OpenMode::READ;
+        }
+        if dir_perms.contains(DirPerms::MUTATE) {
+            open_mode |= OpenMode::WRITE;
+        }
+        self.preopens.push((
+            Dir::new(
+                dir,
+                dir_perms,
+                file_perms,
+                open_mode,
+                self.allow_blocking_current_thread,
+            ),
+            guest_path.as_ref().to_owned(),
+        ));
+        Ok(self)
+    }
+
+    /// Set the generator for the `wasi:random/random` number generator to the
+    /// custom generator specified.
+    ///
+    /// Note that contexts have a default RNG configured which is a suitable
+    /// generator for WASI and is configured with a random seed per-context.
+    ///
+    /// Guest code may rely on this random number generator to produce fresh
+    /// unpredictable random data in order to maintain its security invariants,
+    /// and ideally should use the insecure random API otherwise, so using any
+    /// prerecorded or otherwise predictable data may compromise security.
+    pub fn secure_random(&mut self, random: impl RngCore + Send + 'static) -> &mut Self {
+        self.random = Box::new(random);
+        self
+    }
+
+    /// Configures the generator for `wasi:random/insecure`.
+    ///
+    /// The `insecure_random` generator provided will be used for all randomness
+    /// requested by the `wasi:random/insecure` interface.
+    pub fn insecure_random(&mut self, insecure_random: impl RngCore + Send + 'static) -> &mut Self {
+        self.insecure_random = Box::new(insecure_random);
+        self
+    }
+
+    /// Configures the seed to be returned from `wasi:random/insecure-seed` to
+    /// the specified custom value.
+    ///
+    /// By default this number is randomly generated when a builder is created.
+    pub fn insecure_random_seed(&mut self, insecure_random_seed: u128) -> &mut Self {
+        self.insecure_random_seed = insecure_random_seed;
+        self
+    }
+
+    /// Configures `wasi:clocks/wall-clock` to use the `clock` specified.
+    ///
+    /// By default the host's wall clock is used.
+    pub fn wall_clock(&mut self, clock: impl HostWallClock + 'static) -> &mut Self {
+        self.wall_clock = Box::new(clock);
+        self
+    }
+
+    /// Configures `wasi:clocks/monotonic-clock` to use the `clock` specified.
+    ///
+    /// By default the host's monotonic clock is used.
+    pub fn monotonic_clock(&mut self, clock: impl HostMonotonicClock + 'static) -> &mut Self {
+        self.monotonic_clock = Box::new(clock);
+        self
+    }
+
+    /// Allow all network addresses accessible to the host.
+    ///
+    /// This method will inherit all network addresses meaning that any address
+    /// can be bound by the guest or connected to by the guest using any
+    /// protocol.
+    ///
+    /// See also [`WasiCtxBuilder::socket_addr_check`].
+    pub fn inherit_network(&mut self) -> &mut Self {
+        self.socket_addr_check(|_, _| Box::pin(async { true }))
+    }
+
+    /// A check that will be called for each socket address that is used.
+    ///
+    /// Returning `true` will permit socket connections to the `SocketAddr`,
+    /// while returning `false` will reject the connection.
+    pub fn socket_addr_check<F>(&mut self, check: F) -> &mut Self
+    where
+        F: Fn(SocketAddr, SocketAddrUse) -> Pin<Box<dyn Future<Output = bool> + Send + Sync>>
+            + Send
+            + Sync
+            + 'static,
+    {
+        self.socket_addr_check = SocketAddrCheck(Arc::new(check));
+        self
+    }
+
+    /// Allow usage of `wasi:sockets/ip-name-lookup`
+    ///
+    /// By default this is disabled.
+    pub fn allow_ip_name_lookup(&mut self, enable: bool) -> &mut Self {
+        self.allowed_network_uses.ip_name_lookup = enable;
+        self
+    }
+
+    /// Allow usage of UDP.
+    ///
+    /// This is enabled by default, but can be disabled if UDP should be blanket
+    /// disabled.
+    pub fn allow_udp(&mut self, enable: bool) -> &mut Self {
+        self.allowed_network_uses.udp = enable;
+        self
+    }
+
+    /// Allow usage of TCP
+    ///
+    /// This is enabled by default, but can be disabled if TCP should be blanket
+    /// disabled.
+    pub fn allow_tcp(&mut self, enable: bool) -> &mut Self {
+        self.allowed_network_uses.tcp = enable;
+        self
+    }
+
+    /// Uses the configured context so far to construct the final [`WasiCtx`].
+    ///
+    /// Note that each `WasiCtxBuilder` can only be used to "build" once, and
+    /// calling this method twice will panic.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this method is called twice. Each [`WasiCtxBuilder`] can be
+    /// used to create only a single [`WasiCtx`]. Repeated usage of this method
+    /// is not allowed and should use a second builder instead.
+    pub fn build(&mut self) -> WasiCtx {
+        assert!(!self.built);
+
+        let Self {
+            stdin,
+            stdout,
+            stderr,
+            env,
+            args,
+            preopens,
+            socket_addr_check,
+            random,
+            insecure_random,
+            insecure_random_seed,
+            wall_clock,
+            monotonic_clock,
+            allowed_network_uses,
+            allow_blocking_current_thread,
+            built: _,
+        } = mem::replace(self, Self::new());
+        self.built = true;
+
+        WasiCtx {
+            stdin,
+            stdout,
+            stderr,
+            env,
+            args,
+            preopens,
+            socket_addr_check,
+            random,
+            insecure_random,
+            insecure_random_seed,
+            wall_clock,
+            monotonic_clock,
+            allowed_network_uses,
+            allow_blocking_current_thread,
+        }
+    }
+
+    /// Builds a WASIp1 context instead of a [`WasiCtx`].
+    ///
+    /// This method is the same as [`build`](WasiCtxBuilder::build) but it
+    /// creates a [`WasiP1Ctx`] instead. This is intended for use with the
+    /// [`preview1`] module of this crate
+    ///
+    /// [`WasiP1Ctx`]: crate::preview1::WasiP1Ctx
+    /// [`preview1`]: crate::preview1
+    ///
+    /// # Panics
+    ///
+    /// Panics if this method is called twice. Each [`WasiCtxBuilder`] can be
+    /// used to create only a single [`WasiCtx`] or [`WasiP1Ctx`]. Repeated
+    /// usage of this method is not allowed and should use a second builder
+    /// instead.
+    #[cfg(feature = "preview1")]
+    pub fn build_p1(&mut self) -> crate::preview1::WasiP1Ctx {
+        let wasi = self.build();
+        crate::preview1::WasiP1Ctx::new(wasi)
+    }
+}
+
+/// A trait which provides access to internal WASI state.
+///
+/// This trait is the basis of implementation of all traits in this crate. All
+/// traits are implemented like:
+///
+/// ```
+/// # trait WasiView {}
+/// # mod bindings { pub mod wasi { pub trait Host {} } }
+/// impl<T: WasiView> bindings::wasi::Host for T {
+///     // ...
+/// }
+/// ```
+///
+/// For a [`Store<T>`](wasmtime::Store) this trait will be implemented
+/// for the `T`. This also corresponds to the `T` in
+/// [`Linker<T>`](wasmtime::component::Linker).
+///
+/// # Example
+///
+/// ```
+/// use wasmtime_wasi::{WasiCtx, ResourceTable, WasiView, WasiCtxBuilder};
+///
+/// struct MyState {
+///     ctx: WasiCtx,
+///     table: ResourceTable,
+/// }
+///
+/// impl WasiView for MyState {
+///     fn ctx(&mut self) -> &mut WasiCtx { &mut self.ctx }
+///     fn table(&mut self) -> &mut ResourceTable { &mut self.table }
+/// }
+///
+/// impl MyState {
+///     fn new() -> MyState {
+///         let mut wasi = WasiCtxBuilder::new();
+///         wasi.arg("./foo.wasm");
+///         wasi.arg("--help");
+///         wasi.env("FOO", "bar");
+///
+///         MyState {
+///             ctx: wasi.build(),
+///             table: ResourceTable::new(),
+///         }
+///     }
+/// }
+/// ```
+pub trait WasiView: Send {
+    /// Yields mutable access to the internal resource management that this
+    /// context contains.
+    ///
+    /// Embedders can add custom resources to this table as well to give
+    /// resources to wasm as well.
+    fn table(&mut self) -> &mut ResourceTable;
+
+    /// Yields mutable access to the configuration used for this context.
+    ///
+    /// The returned type is created through [`WasiCtxBuilder`].
+    fn ctx(&mut self) -> &mut WasiCtx;
+}
+
+impl<T: ?Sized + WasiView> WasiView for &mut T {
+    fn table(&mut self) -> &mut ResourceTable {
+        T::table(self)
+    }
+    fn ctx(&mut self) -> &mut WasiCtx {
+        T::ctx(self)
+    }
+}
+
+impl<T: ?Sized + WasiView> WasiView for Box<T> {
+    fn table(&mut self) -> &mut ResourceTable {
+        T::table(self)
+    }
+    fn ctx(&mut self) -> &mut WasiCtx {
+        T::ctx(self)
+    }
+}
+
+/// A small newtype wrapper which serves as the basis for implementations of
+/// `Host` WASI traits in this crate.
+///
+/// This type is used as the basis for the implementation of all `Host` traits
+/// generated by `bindgen!` for WASI interfaces. This is used automatically with
+/// [`add_to_linker_sync`](crate::add_to_linker_sync) and
+/// [`add_to_linker_async`](crate::add_to_linker_async).
+///
+/// This type is otherwise provided if you're calling the `add_to_linker`
+/// functions generated by `bindgen!` from the [`bindings`
+/// module](crate::bindings). In this situation you'll want to create a value of
+/// this type in the closures added to a `Linker`.
+#[repr(transparent)]
+pub struct WasiImpl<T>(pub T);
+
+impl<T: WasiView> WasiView for WasiImpl<T> {
+    fn table(&mut self) -> &mut ResourceTable {
+        T::table(&mut self.0)
+    }
+    fn ctx(&mut self) -> &mut WasiCtx {
+        T::ctx(&mut self.0)
+    }
+}
+
+/// Per-[`Store`] state which holds state necessary to implement WASI from this
+/// crate.
+///
+/// This structure is created through [`WasiCtxBuilder`] and is stored within
+/// the `T` of [`Store<T>`][`Store`]. Access to the structure is provided
+/// through the [`WasiView`] trait as an implementation on `T`.
+///
+/// Note that this structure itself does not have any accessors, it's here for
+/// internal use within the `wasmtime-wasi` crate's implementation of
+/// bindgen-generated traits.
+///
+/// [`Store`]: wasmtime::Store
+pub struct WasiCtx {
+    pub(crate) random: Box<dyn RngCore + Send>,
+    pub(crate) insecure_random: Box<dyn RngCore + Send>,
+    pub(crate) insecure_random_seed: u128,
+    pub(crate) wall_clock: Box<dyn HostWallClock + Send>,
+    pub(crate) monotonic_clock: Box<dyn HostMonotonicClock + Send>,
+    pub(crate) env: Vec<(String, String)>,
+    pub(crate) args: Vec<String>,
+    pub(crate) preopens: Vec<(Dir, String)>,
+    pub(crate) stdin: Box<dyn StdinStream>,
+    pub(crate) stdout: Box<dyn StdoutStream>,
+    pub(crate) stderr: Box<dyn StdoutStream>,
+    pub(crate) socket_addr_check: SocketAddrCheck,
+    pub(crate) allowed_network_uses: AllowedNetworkUses,
+    pub(crate) allow_blocking_current_thread: bool,
+}
+
+impl WasiCtx {
+    /// Convenience function for calling [`WasiCtxBuilder::new`].
+    pub fn builder() -> WasiCtxBuilder {
+        WasiCtxBuilder::new()
+    }
+}
+
+pub struct AllowedNetworkUses {
+    pub ip_name_lookup: bool,
+    pub udp: bool,
+    pub tcp: bool,
+}
+
+impl Default for AllowedNetworkUses {
+    fn default() -> Self {
+        Self {
+            ip_name_lookup: false,
+            udp: true,
+            tcp: true,
+        }
+    }
+}
+
+impl AllowedNetworkUses {
+    pub(crate) fn check_allowed_udp(&self) -> std::io::Result<()> {
+        if !self.udp {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::PermissionDenied,
+                "UDP is not allowed",
+            ));
+        }
+
+        Ok(())
+    }
+
+    pub(crate) fn check_allowed_tcp(&self) -> std::io::Result<()> {
+        if !self.tcp {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::PermissionDenied,
+                "TCP is not allowed",
+            ));
+        }
+
+        Ok(())
+    }
+}
diff --git a/crates/wasi/src/error.rs b/crates/wasi/src/error.rs
new file mode 100644
index 000000000000..a019b4a7a2e7
--- /dev/null
+++ b/crates/wasi/src/error.rs
@@ -0,0 +1,111 @@
+use std::error::Error;
+use std::fmt;
+use std::marker;
+
+/// An error returned from the `proc_exit` host syscall.
+///
+/// Embedders can test if an error returned from wasm is this error, in which
+/// case it may signal a non-fatal trap.
+#[derive(Debug)]
+pub struct I32Exit(pub i32);
+
+impl I32Exit {
+    /// Accessor for an exit code appropriate for calling `std::process::exit` with,
+    /// when interpreting this `I32Exit` as an exit for the parent process.
+    ///
+    /// This method masks off exit codes which are illegal on Windows.
+    pub fn process_exit_code(&self) -> i32 {
+        if cfg!(windows) && self.0 >= 3 {
+            1
+        } else {
+            self.0
+        }
+    }
+}
+
+impl fmt::Display for I32Exit {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Exited with i32 exit status {}", self.0)
+    }
+}
+
+impl std::error::Error for I32Exit {}
+
+/// A helper error type used by many other modules through type aliases.
+///
+/// This type is an `Error` itself and is intended to be a representation of
+/// either:
+///
+/// * A custom error type `T`
+/// * A trap, represented as `anyhow::Error`
+///
+/// This error is created through either the `::trap` constructor representing a
+/// full-fledged trap or the `From<T>` constructor which is intended to be used
+/// with `?`. The goal is to make normal errors `T` "automatic" but enable error
+/// paths to return a `::trap` error optionally still as necessary without extra
+/// boilerplate everywhere else.
+///
+/// Note that this type isn't used directly but instead is intended to be used
+/// as:
+///
+/// ```rust,ignore
+/// type MyError = TrappableError<bindgen::TheError>;
+/// ```
+///
+/// where `MyError` is what you'll use throughout bindings code and
+/// `bindgen::TheError` is the type that this represents as generated by the
+/// `bindgen!` macro.
+#[repr(transparent)]
+pub struct TrappableError<T> {
+    err: anyhow::Error,
+    _marker: marker::PhantomData<T>,
+}
+
+impl<T> TrappableError<T> {
+    pub fn trap(err: impl Into<anyhow::Error>) -> TrappableError<T> {
+        TrappableError {
+            err: err.into(),
+            _marker: marker::PhantomData,
+        }
+    }
+
+    pub fn downcast(self) -> anyhow::Result<T>
+    where
+        T: Error + Send + Sync + 'static,
+    {
+        self.err.downcast()
+    }
+
+    pub fn downcast_ref(&self) -> Option<&T>
+    where
+        T: Error + Send + Sync + 'static,
+    {
+        self.err.downcast_ref()
+    }
+}
+
+impl<T> From<T> for TrappableError<T>
+where
+    T: Error + Send + Sync + 'static,
+{
+    fn from(error: T) -> Self {
+        Self {
+            err: error.into(),
+            _marker: marker::PhantomData,
+        }
+    }
+}
+
+impl<T> fmt::Debug for TrappableError<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.err.fmt(f)
+    }
+}
+
+impl<T> fmt::Display for TrappableError<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.err.fmt(f)
+    }
+}
+
+impl<T> Error for TrappableError<T> {}
diff --git a/crates/wasi/src/filesystem.rs b/crates/wasi/src/filesystem.rs
new file mode 100644
index 000000000000..a924fa96a70c
--- /dev/null
+++ b/crates/wasi/src/filesystem.rs
@@ -0,0 +1,607 @@
+use crate::bindings::filesystem::types;
+use crate::runtime::{spawn_blocking, AbortOnDropJoinHandle};
+use crate::{
+    HostInputStream, HostOutputStream, StreamError, StreamResult, Subscribe, TrappableError,
+};
+use anyhow::anyhow;
+use bytes::{Bytes, BytesMut};
+use std::io;
+use std::mem;
+use std::sync::Arc;
+
+pub type FsResult<T> = Result<T, FsError>;
+
+pub type FsError = TrappableError<types::ErrorCode>;
+
+impl From<wasmtime::component::ResourceTableError> for FsError {
+    fn from(error: wasmtime::component::ResourceTableError) -> Self {
+        Self::trap(error)
+    }
+}
+
+impl From<io::Error> for FsError {
+    fn from(error: io::Error) -> Self {
+        types::ErrorCode::from(error).into()
+    }
+}
+
+pub enum Descriptor {
+    File(File),
+    Dir(Dir),
+}
+
+impl Descriptor {
+    pub fn file(&self) -> Result<&File, types::ErrorCode> {
+        match self {
+            Descriptor::File(f) => Ok(f),
+            Descriptor::Dir(_) => Err(types::ErrorCode::BadDescriptor),
+        }
+    }
+
+    pub fn dir(&self) -> Result<&Dir, types::ErrorCode> {
+        match self {
+            Descriptor::Dir(d) => Ok(d),
+            Descriptor::File(_) => Err(types::ErrorCode::NotDirectory),
+        }
+    }
+
+    pub fn is_file(&self) -> bool {
+        match self {
+            Descriptor::File(_) => true,
+            Descriptor::Dir(_) => false,
+        }
+    }
+
+    pub fn is_dir(&self) -> bool {
+        match self {
+            Descriptor::File(_) => false,
+            Descriptor::Dir(_) => true,
+        }
+    }
+}
+
+bitflags::bitflags! {
+    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
+    pub struct FilePerms: usize {
+        const READ = 0b1;
+        const WRITE = 0b10;
+    }
+}
+
+bitflags::bitflags! {
+    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
+    pub struct OpenMode: usize {
+        const READ = 0b1;
+        const WRITE = 0b10;
+    }
+}
+
+#[derive(Clone)]
+pub struct File {
+    /// The operating system File this struct is mediating access to.
+    ///
+    /// Wrapped in an Arc because the same underlying file is used for
+    /// implementing the stream types. A copy is also needed for
+    /// [`spawn_blocking`].
+    ///
+    /// [`spawn_blocking`]: Self::spawn_blocking
+    pub file: Arc<cap_std::fs::File>,
+    /// Permissions to enforce on access to the file. These permissions are
+    /// specified by a user of the `crate::WasiCtxBuilder`, and are
+    /// enforced prior to any enforced by the underlying operating system.
+    pub perms: FilePerms,
+    /// The mode the file was opened under: bits for reading, and writing.
+    /// Required to correctly report the DescriptorFlags, because cap-std
+    /// doesn't presently provide a cross-platform equivalent of reading the
+    /// oflags back out using fcntl.
+    pub open_mode: OpenMode,
+
+    allow_blocking_current_thread: bool,
+}
+
+impl File {
+    pub fn new(
+        file: cap_std::fs::File,
+        perms: FilePerms,
+        open_mode: OpenMode,
+        allow_blocking_current_thread: bool,
+    ) -> Self {
+        Self {
+            file: Arc::new(file),
+            perms,
+            open_mode,
+            allow_blocking_current_thread,
+        }
+    }
+
+    /// Execute the blocking `body` function.
+    ///
+    /// Depending on how the WasiCtx was configured, the body may either be:
+    /// - Executed directly on the current thread. In this case the `async`
+    ///   signature of this method is effectively a lie and the returned
+    ///   Future will always be immediately Ready. Or:
+    /// - Spawned on a background thread using [`tokio::task::spawn_blocking`]
+    ///   and immediately awaited.
+    ///
+    /// Intentionally blocking the executor thread might seem unorthodox, but is
+    /// not actually a problem for specific workloads. See:
+    /// - [`crate::WasiCtxBuilder::allow_blocking_current_thread`]
+    /// - [Poor performance of wasmtime file I/O maybe because tokio](https://github.com/bytecodealliance/wasmtime/issues/7973)
+    /// - [Implement opt-in for enabling WASI to block the current thread](https://github.com/bytecodealliance/wasmtime/pull/8190)
+    pub(crate) async fn run_blocking<F, R>(&self, body: F) -> R
+    where
+        F: FnOnce(&cap_std::fs::File) -> R + Send + 'static,
+        R: Send + 'static,
+    {
+        match self.as_blocking_file() {
+            Some(file) => body(file),
+            None => self.spawn_blocking(body).await,
+        }
+    }
+
+    pub(crate) fn spawn_blocking<F, R>(&self, body: F) -> AbortOnDropJoinHandle<R>
+    where
+        F: FnOnce(&cap_std::fs::File) -> R + Send + 'static,
+        R: Send + 'static,
+    {
+        let f = self.file.clone();
+        spawn_blocking(move || body(&f))
+    }
+
+    /// Returns `Some` when the current thread is allowed to block in filesystem
+    /// operations, and otherwise returns `None` to indicate that
+    /// `spawn_blocking` must be used.
+    pub(crate) fn as_blocking_file(&self) -> Option<&cap_std::fs::File> {
+        if self.allow_blocking_current_thread {
+            Some(&self.file)
+        } else {
+            None
+        }
+    }
+}
+
+bitflags::bitflags! {
+    /// Permission bits for operating on a directory.
+    ///
+    /// Directories can be limited to being readonly. This will restrict what
+    /// can be done with them, for example preventing creation of new files.
+    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
+    pub struct DirPerms: usize {
+        /// This directory can be read, for example its entries can be iterated
+        /// over and files can be opened.
+        const READ = 0b1;
+
+        /// This directory can be mutated, for example by creating new files
+        /// within it.
+        const MUTATE = 0b10;
+    }
+}
+
+#[derive(Clone)]
+pub struct Dir {
+    /// The operating system file descriptor this struct is mediating access
+    /// to.
+    ///
+    /// Wrapped in an Arc because a copy is needed for [`spawn_blocking`].
+    ///
+    /// [`spawn_blocking`]: Self::spawn_blocking
+    pub dir: Arc<cap_std::fs::Dir>,
+    /// Permissions to enforce on access to this directory. These permissions
+    /// are specified by a user of the `crate::WasiCtxBuilder`, and
+    /// are enforced prior to any enforced by the underlying operating system.
+    ///
+    /// These permissions are also enforced on any directories opened under
+    /// this directory.
+    pub perms: DirPerms,
+    /// Permissions to enforce on any files opened under this directory.
+    pub file_perms: FilePerms,
+    /// The mode the directory was opened under: bits for reading, and writing.
+    /// Required to correctly report the DescriptorFlags, because cap-std
+    /// doesn't presently provide a cross-platform equivalent of reading the
+    /// oflags back out using fcntl.
+    pub open_mode: OpenMode,
+
+    allow_blocking_current_thread: bool,
+}
+
+impl Dir {
+    pub fn new(
+        dir: cap_std::fs::Dir,
+        perms: DirPerms,
+        file_perms: FilePerms,
+        open_mode: OpenMode,
+        allow_blocking_current_thread: bool,
+    ) -> Self {
+        Dir {
+            dir: Arc::new(dir),
+            perms,
+            file_perms,
+            open_mode,
+            allow_blocking_current_thread,
+        }
+    }
+
+    /// Execute the blocking `body` function.
+    ///
+    /// Depending on how the WasiCtx was configured, the body may either be:
+    /// - Executed directly on the current thread. In this case the `async`
+    ///   signature of this method is effectively a lie and the returned
+    ///   Future will always be immediately Ready. Or:
+    /// - Spawned on a background thread using [`tokio::task::spawn_blocking`]
+    ///   and immediately awaited.
+    ///
+    /// Intentionally blocking the executor thread might seem unorthodox, but is
+    /// not actually a problem for specific workloads. See:
+    /// - [`crate::WasiCtxBuilder::allow_blocking_current_thread`]
+    /// - [Poor performance of wasmtime file I/O maybe because tokio](https://github.com/bytecodealliance/wasmtime/issues/7973)
+    /// - [Implement opt-in for enabling WASI to block the current thread](https://github.com/bytecodealliance/wasmtime/pull/8190)
+    pub(crate) async fn run_blocking<F, R>(&self, body: F) -> R
+    where
+        F: FnOnce(&cap_std::fs::Dir) -> R + Send + 'static,
+        R: Send + 'static,
+    {
+        if self.allow_blocking_current_thread {
+            body(&self.dir)
+        } else {
+            let d = self.dir.clone();
+            spawn_blocking(move || body(&d)).await
+        }
+    }
+}
+
+pub struct FileInputStream {
+    file: File,
+    position: u64,
+    state: ReadState,
+}
+enum ReadState {
+    Idle,
+    Waiting(AbortOnDropJoinHandle<ReadState>),
+    DataAvailable(Bytes),
+    Error(io::Error),
+    Closed,
+}
+impl FileInputStream {
+    pub fn new(file: &File, position: u64) -> Self {
+        Self {
+            file: file.clone(),
+            position,
+            state: ReadState::Idle,
+        }
+    }
+
+    fn blocking_read(file: &cap_std::fs::File, offset: u64, size: usize) -> ReadState {
+        use system_interface::fs::FileIoExt;
+
+        let mut buf = BytesMut::zeroed(size);
+        loop {
+            match file.read_at(&mut buf, offset) {
+                Ok(0) => return ReadState::Closed,
+                Ok(n) => {
+                    buf.truncate(n);
+                    return ReadState::DataAvailable(buf.freeze());
+                }
+                Err(e) if e.kind() == std::io::ErrorKind::Interrupted => {
+                    // Try again, continue looping
+                }
+                Err(e) => return ReadState::Error(e),
+            }
+        }
+    }
+
+    /// Wait for existing background task to finish, without starting any new background reads.
+    async fn wait_ready(&mut self) {
+        match &mut self.state {
+            ReadState::Waiting(task) => {
+                self.state = task.await;
+            }
+            _ => {}
+        }
+    }
+}
+#[async_trait::async_trait]
+impl HostInputStream for FileInputStream {
+    fn read(&mut self, size: usize) -> StreamResult<Bytes> {
+        match &mut self.state {
+            ReadState::Idle => {
+                if size == 0 {
+                    return Ok(Bytes::new());
+                }
+
+                let p = self.position;
+                self.state = ReadState::Waiting(
+                    self.file
+                        .spawn_blocking(move |f| Self::blocking_read(f, p, size)),
+                );
+                Ok(Bytes::new())
+            }
+            ReadState::DataAvailable(b) => {
+                let min_len = b.len().min(size);
+                let chunk = b.split_to(min_len);
+                if b.len() == 0 {
+                    self.state = ReadState::Idle;
+                }
+                self.position += min_len as u64;
+                Ok(chunk)
+            }
+            ReadState::Waiting(_) => Ok(Bytes::new()),
+            ReadState::Error(_) => match mem::replace(&mut self.state, ReadState::Closed) {
+                ReadState::Error(e) => Err(StreamError::LastOperationFailed(e.into())),
+                _ => unreachable!(),
+            },
+            ReadState::Closed => Err(StreamError::Closed),
+        }
+    }
+    /// Specialized blocking_* variant to bypass tokio's task spawning & joining
+    /// overhead on synchronous file I/O.
+    async fn blocking_read(&mut self, size: usize) -> StreamResult<Bytes> {
+        self.wait_ready().await;
+
+        // Before we defer to the regular `read`, make sure it has data ready to go:
+        if let ReadState::Idle = self.state {
+            let p = self.position;
+            self.state = self
+                .file
+                .run_blocking(move |f| Self::blocking_read(f, p, size))
+                .await;
+        }
+
+        self.read(size)
+    }
+    async fn cancel(&mut self) {
+        match mem::replace(&mut self.state, ReadState::Closed) {
+            ReadState::Waiting(task) => {
+                // The task was created using `spawn_blocking`, so unless we're
+                // lucky enough that the task hasn't started yet, the abort
+                // signal won't have any effect and we're forced to wait for it
+                // to run to completion.
+                // From the guest's point of view, `input-stream::drop` then
+                // appears to block. Certainly less than ideal, but arguably still
+                // better than letting the guest rack up an unbounded number of
+                // background tasks. Also, the guest is only blocked if
+                // the stream was dropped mid-read, which we don't expect to
+                // occur frequently.
+                task.abort_wait().await;
+            }
+            _ => {}
+        }
+    }
+}
+#[async_trait::async_trait]
+impl Subscribe for FileInputStream {
+    async fn ready(&mut self) {
+        if let ReadState::Idle = self.state {
+            // The guest hasn't initiated any read, but is nonetheless waiting
+            // for data to be available. We'll start a read for them:
+
+            const DEFAULT_READ_SIZE: usize = 4096;
+            let p = self.position;
+            self.state = ReadState::Waiting(
+                self.file
+                    .spawn_blocking(move |f| Self::blocking_read(f, p, DEFAULT_READ_SIZE)),
+            );
+        }
+
+        self.wait_ready().await
+    }
+}
+
+#[derive(Clone, Copy)]
+pub(crate) enum FileOutputMode {
+    Position(u64),
+    Append,
+}
+
+pub(crate) struct FileOutputStream {
+    file: File,
+    mode: FileOutputMode,
+    state: OutputState,
+}
+
+enum OutputState {
+    Ready,
+    /// Allows join future to be awaited in a cancellable manner. Gone variant indicates
+    /// no task is currently outstanding.
+    Waiting(AbortOnDropJoinHandle<io::Result<usize>>),
+    /// The last I/O operation failed with this error.
+    Error(io::Error),
+    Closed,
+}
+
+impl FileOutputStream {
+    pub fn write_at(file: &File, position: u64) -> Self {
+        Self {
+            file: file.clone(),
+            mode: FileOutputMode::Position(position),
+            state: OutputState::Ready,
+        }
+    }
+
+    pub fn append(file: &File) -> Self {
+        Self {
+            file: file.clone(),
+            mode: FileOutputMode::Append,
+            state: OutputState::Ready,
+        }
+    }
+
+    fn blocking_write(
+        file: &cap_std::fs::File,
+        mut buf: Bytes,
+        mode: FileOutputMode,
+    ) -> io::Result<usize> {
+        use system_interface::fs::FileIoExt;
+
+        match mode {
+            FileOutputMode::Position(mut p) => {
+                let mut total = 0;
+                loop {
+                    let nwritten = file.write_at(buf.as_ref(), p)?;
+                    // afterwards buf contains [nwritten, len):
+                    let _ = buf.split_to(nwritten);
+                    p += nwritten as u64;
+                    total += nwritten;
+                    if buf.is_empty() {
+                        break;
+                    }
+                }
+                Ok(total)
+            }
+            FileOutputMode::Append => {
+                let mut total = 0;
+                loop {
+                    let nwritten = file.append(buf.as_ref())?;
+                    let _ = buf.split_to(nwritten);
+                    total += nwritten;
+                    if buf.is_empty() {
+                        break;
+                    }
+                }
+                Ok(total)
+            }
+        }
+    }
+}
+
+// FIXME: configurable? determine from how much space left in file?
+const FILE_WRITE_CAPACITY: usize = 1024 * 1024;
+
+#[async_trait::async_trait]
+impl HostOutputStream for FileOutputStream {
+    fn write(&mut self, buf: Bytes) -> Result<(), StreamError> {
+        match self.state {
+            OutputState::Ready => {}
+            OutputState::Closed => return Err(StreamError::Closed),
+            OutputState::Waiting(_) | OutputState::Error(_) => {
+                // a write is pending - this call was not permitted
+                return Err(StreamError::Trap(anyhow!(
+                    "write not permitted: check_write not called first"
+                )));
+            }
+        }
+
+        let m = self.mode;
+        self.state = OutputState::Waiting(
+            self.file
+                .spawn_blocking(move |f| Self::blocking_write(f, buf, m)),
+        );
+        Ok(())
+    }
+    /// Specialized blocking_* variant to bypass tokio's task spawning & joining
+    /// overhead on synchronous file I/O.
+    async fn blocking_write_and_flush(&mut self, buf: Bytes) -> StreamResult<()> {
+        self.ready().await;
+
+        match self.state {
+            OutputState::Ready => {}
+            OutputState::Closed => return Err(StreamError::Closed),
+            OutputState::Error(_) => match mem::replace(&mut self.state, OutputState::Closed) {
+                OutputState::Error(e) => return Err(StreamError::LastOperationFailed(e.into())),
+                _ => unreachable!(),
+            },
+            OutputState::Waiting(_) => unreachable!("we've just waited for readiness"),
+        }
+
+        let m = self.mode;
+        match self
+            .file
+            .run_blocking(move |f| Self::blocking_write(f, buf, m))
+            .await
+        {
+            Ok(nwritten) => {
+                if let FileOutputMode::Position(ref mut p) = &mut self.mode {
+                    *p += nwritten as u64;
+                }
+                self.state = OutputState::Ready;
+                Ok(())
+            }
+            Err(e) => {
+                self.state = OutputState::Closed;
+                Err(StreamError::LastOperationFailed(e.into()))
+            }
+        }
+    }
+    fn flush(&mut self) -> Result<(), StreamError> {
+        match self.state {
+            // Only userland buffering of file writes is in the blocking task,
+            // so there's nothing extra that needs to be done to request a
+            // flush.
+            OutputState::Ready | OutputState::Waiting(_) => Ok(()),
+            OutputState::Closed => Err(StreamError::Closed),
+            OutputState::Error(_) => match mem::replace(&mut self.state, OutputState::Closed) {
+                OutputState::Error(e) => Err(StreamError::LastOperationFailed(e.into())),
+                _ => unreachable!(),
+            },
+        }
+    }
+    fn check_write(&mut self) -> Result<usize, StreamError> {
+        match self.state {
+            OutputState::Ready => Ok(FILE_WRITE_CAPACITY),
+            OutputState::Closed => Err(StreamError::Closed),
+            OutputState::Error(_) => match mem::replace(&mut self.state, OutputState::Closed) {
+                OutputState::Error(e) => Err(StreamError::LastOperationFailed(e.into())),
+                _ => unreachable!(),
+            },
+            OutputState::Waiting(_) => Ok(0),
+        }
+    }
+    async fn cancel(&mut self) {
+        match mem::replace(&mut self.state, OutputState::Closed) {
+            OutputState::Waiting(task) => {
+                // The task was created using `spawn_blocking`, so unless we're
+                // lucky enough that the task hasn't started yet, the abort
+                // signal won't have any effect and we're forced to wait for it
+                // to run to completion.
+                // From the guest's point of view, `output-stream::drop` then
+                // appears to block. Certainly less than ideal, but arguably still
+                // better than letting the guest rack up an unbounded number of
+                // background tasks. Also, the guest is only blocked if
+                // the stream was dropped mid-write, which we don't expect to
+                // occur frequently.
+                task.abort_wait().await;
+            }
+            _ => {}
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl Subscribe for FileOutputStream {
+    async fn ready(&mut self) {
+        if let OutputState::Waiting(task) = &mut self.state {
+            self.state = match task.await {
+                Ok(nwritten) => {
+                    if let FileOutputMode::Position(ref mut p) = &mut self.mode {
+                        *p += nwritten as u64;
+                    }
+                    OutputState::Ready
+                }
+                Err(e) => OutputState::Error(e),
+            };
+        }
+    }
+}
+
+pub struct ReaddirIterator(
+    std::sync::Mutex<Box<dyn Iterator<Item = FsResult<types::DirectoryEntry>> + Send + 'static>>,
+);
+
+impl ReaddirIterator {
+    pub(crate) fn new(
+        i: impl Iterator<Item = FsResult<types::DirectoryEntry>> + Send + 'static,
+    ) -> Self {
+        ReaddirIterator(std::sync::Mutex::new(Box::new(i)))
+    }
+    pub(crate) fn next(&self) -> FsResult<Option<types::DirectoryEntry>> {
+        self.0.lock().unwrap().next().transpose()
+    }
+}
+
+impl IntoIterator for ReaddirIterator {
+    type Item = FsResult<types::DirectoryEntry>;
+    type IntoIter = Box<dyn Iterator<Item = Self::Item> + Send>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_inner().unwrap()
+    }
+}
diff --git a/crates/wasi/src/host/clocks.rs b/crates/wasi/src/host/clocks.rs
new file mode 100644
index 000000000000..e94ca98555ff
--- /dev/null
+++ b/crates/wasi/src/host/clocks.rs
@@ -0,0 +1,109 @@
+#![allow(unused_variables)]
+
+use crate::bindings::{
+    clocks::monotonic_clock::{self, Duration as WasiDuration, Instant},
+    clocks::wall_clock::{self, Datetime},
+};
+use crate::poll::{subscribe, Subscribe};
+use crate::{Pollable, WasiImpl, WasiView};
+use cap_std::time::SystemTime;
+use std::time::Duration;
+use wasmtime::component::Resource;
+
+impl TryFrom<SystemTime> for Datetime {
+    type Error = anyhow::Error;
+
+    fn try_from(time: SystemTime) -> Result<Self, Self::Error> {
+        let duration =
+            time.duration_since(SystemTime::from_std(std::time::SystemTime::UNIX_EPOCH))?;
+
+        Ok(Datetime {
+            seconds: duration.as_secs(),
+            nanoseconds: duration.subsec_nanos(),
+        })
+    }
+}
+
+impl<T> wall_clock::Host for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn now(&mut self) -> anyhow::Result<Datetime> {
+        let now = self.ctx().wall_clock.now();
+        Ok(Datetime {
+            seconds: now.as_secs(),
+            nanoseconds: now.subsec_nanos(),
+        })
+    }
+
+    fn resolution(&mut self) -> anyhow::Result<Datetime> {
+        let res = self.ctx().wall_clock.resolution();
+        Ok(Datetime {
+            seconds: res.as_secs(),
+            nanoseconds: res.subsec_nanos(),
+        })
+    }
+}
+
+fn subscribe_to_duration(
+    table: &mut wasmtime::component::ResourceTable,
+    duration: tokio::time::Duration,
+) -> anyhow::Result<Resource<Pollable>> {
+    let sleep = if duration.is_zero() {
+        table.push(Deadline::Past)?
+    } else if let Some(deadline) = tokio::time::Instant::now().checked_add(duration) {
+        // NB: this resource created here is not actually exposed to wasm, it's
+        // only an internal implementation detail used to match the signature
+        // expected by `subscribe`.
+        table.push(Deadline::Instant(deadline))?
+    } else {
+        // If the user specifies a time so far in the future we can't
+        // represent it, wait forever rather than trap.
+        table.push(Deadline::Never)?
+    };
+    subscribe(table, sleep)
+}
+
+impl<T> monotonic_clock::Host for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn now(&mut self) -> anyhow::Result<Instant> {
+        Ok(self.ctx().monotonic_clock.now())
+    }
+
+    fn resolution(&mut self) -> anyhow::Result<Instant> {
+        Ok(self.ctx().monotonic_clock.resolution())
+    }
+
+    fn subscribe_instant(&mut self, when: Instant) -> anyhow::Result<Resource<Pollable>> {
+        let clock_now = self.ctx().monotonic_clock.now();
+        let duration = if when > clock_now {
+            Duration::from_nanos(when - clock_now)
+        } else {
+            Duration::from_nanos(0)
+        };
+        subscribe_to_duration(&mut self.table(), duration)
+    }
+
+    fn subscribe_duration(&mut self, duration: WasiDuration) -> anyhow::Result<Resource<Pollable>> {
+        subscribe_to_duration(&mut self.table(), Duration::from_nanos(duration))
+    }
+}
+
+enum Deadline {
+    Past,
+    Instant(tokio::time::Instant),
+    Never,
+}
+
+#[async_trait::async_trait]
+impl Subscribe for Deadline {
+    async fn ready(&mut self) {
+        match self {
+            Deadline::Past => {}
+            Deadline::Instant(instant) => tokio::time::sleep_until(*instant).await,
+            Deadline::Never => std::future::pending().await,
+        }
+    }
+}
diff --git a/crates/wasi/src/host/env.rs b/crates/wasi/src/host/env.rs
new file mode 100644
index 000000000000..db259d8caa14
--- /dev/null
+++ b/crates/wasi/src/host/env.rs
@@ -0,0 +1,18 @@
+use crate::bindings::cli::environment;
+use crate::{WasiImpl, WasiView};
+
+impl<T> environment::Host for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn get_environment(&mut self) -> anyhow::Result<Vec<(String, String)>> {
+        Ok(self.ctx().env.clone())
+    }
+    fn get_arguments(&mut self) -> anyhow::Result<Vec<String>> {
+        Ok(self.ctx().args.clone())
+    }
+    fn initial_cwd(&mut self) -> anyhow::Result<Option<String>> {
+        // FIXME: expose cwd in builder and save in ctx
+        Ok(None)
+    }
+}
diff --git a/crates/wasi/src/host/exit.rs b/crates/wasi/src/host/exit.rs
new file mode 100644
index 000000000000..be3129fa12fc
--- /dev/null
+++ b/crates/wasi/src/host/exit.rs
@@ -0,0 +1,14 @@
+use crate::{bindings::cli::exit, I32Exit, WasiImpl, WasiView};
+
+impl<T> exit::Host for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn exit(&mut self, status: Result<(), ()>) -> anyhow::Result<()> {
+        let status = match status {
+            Ok(()) => 0,
+            Err(()) => 1,
+        };
+        Err(anyhow::anyhow!(I32Exit(status)))
+    }
+}
diff --git a/crates/wasi/src/host/filesystem.rs b/crates/wasi/src/host/filesystem.rs
new file mode 100644
index 000000000000..04cc8670c4ad
--- /dev/null
+++ b/crates/wasi/src/host/filesystem.rs
@@ -0,0 +1,1091 @@
+use crate::bindings::clocks::wall_clock;
+use crate::bindings::filesystem::preopens;
+use crate::bindings::filesystem::types::{
+    self, ErrorCode, HostDescriptor, HostDirectoryEntryStream,
+};
+use crate::bindings::io::streams::{InputStream, OutputStream};
+use crate::filesystem::{
+    Descriptor, Dir, File, FileInputStream, FileOutputStream, OpenMode, ReaddirIterator,
+};
+use crate::{DirPerms, FilePerms, FsError, FsResult, WasiImpl, WasiView};
+use anyhow::Context;
+use wasmtime::component::Resource;
+
+mod sync;
+
+impl<T> preopens::Host for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn get_directories(
+        &mut self,
+    ) -> Result<Vec<(Resource<types::Descriptor>, String)>, anyhow::Error> {
+        let mut results = Vec::new();
+        for (dir, name) in self.ctx().preopens.clone() {
+            let fd = self
+                .table()
+                .push(Descriptor::Dir(dir))
+                .with_context(|| format!("failed to push preopen {name}"))?;
+            results.push((fd, name));
+        }
+        Ok(results)
+    }
+}
+
+#[async_trait::async_trait]
+impl<T> types::Host for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn convert_error_code(&mut self, err: FsError) -> anyhow::Result<ErrorCode> {
+        err.downcast()
+    }
+
+    fn filesystem_error_code(
+        &mut self,
+        err: Resource<anyhow::Error>,
+    ) -> anyhow::Result<Option<ErrorCode>> {
+        let err = self.table().get(&err)?;
+
+        // Currently `err` always comes from the stream implementation which
+        // uses standard reads/writes so only check for `std::io::Error` here.
+        if let Some(err) = err.downcast_ref::<std::io::Error>() {
+            return Ok(Some(ErrorCode::from(err)));
+        }
+
+        Ok(None)
+    }
+}
+
+#[async_trait::async_trait]
+impl<T> HostDescriptor for WasiImpl<T>
+where
+    T: WasiView,
+{
+    async fn advise(
+        &mut self,
+        fd: Resource<types::Descriptor>,
+        offset: types::Filesize,
+        len: types::Filesize,
+        advice: types::Advice,
+    ) -> FsResult<()> {
+        use system_interface::fs::{Advice as A, FileIoExt};
+        use types::Advice;
+
+        let advice = match advice {
+            Advice::Normal => A::Normal,
+            Advice::Sequential => A::Sequential,
+            Advice::Random => A::Random,
+            Advice::WillNeed => A::WillNeed,
+            Advice::DontNeed => A::DontNeed,
+            Advice::NoReuse => A::NoReuse,
+        };
+
+        let f = self.table().get(&fd)?.file()?;
+        f.run_blocking(move |f| f.advise(offset, len, advice))
+            .await?;
+        Ok(())
+    }
+
+    async fn sync_data(&mut self, fd: Resource<types::Descriptor>) -> FsResult<()> {
+        let descriptor = self.table().get(&fd)?;
+
+        match descriptor {
+            Descriptor::File(f) => {
+                match f.run_blocking(|f| f.sync_data()).await {
+                    Ok(()) => Ok(()),
+                    // On windows, `sync_data` uses `FileFlushBuffers` which fails with
+                    // `ERROR_ACCESS_DENIED` if the file is not upen for writing. Ignore
+                    // this error, for POSIX compatibility.
+                    #[cfg(windows)]
+                    Err(e)
+                        if e.raw_os_error()
+                            == Some(windows_sys::Win32::Foundation::ERROR_ACCESS_DENIED as _) =>
+                    {
+                        Ok(())
+                    }
+                    Err(e) => Err(e.into()),
+                }
+            }
+            Descriptor::Dir(d) => {
+                d.run_blocking(|d| Ok(d.open(std::path::Component::CurDir)?.sync_data()?))
+                    .await
+            }
+        }
+    }
+
+    async fn get_flags(
+        &mut self,
+        fd: Resource<types::Descriptor>,
+    ) -> FsResult<types::DescriptorFlags> {
+        use system_interface::fs::{FdFlags, GetSetFdFlags};
+        use types::DescriptorFlags;
+
+        fn get_from_fdflags(flags: FdFlags) -> DescriptorFlags {
+            let mut out = DescriptorFlags::empty();
+            if flags.contains(FdFlags::DSYNC) {
+                out |= DescriptorFlags::REQUESTED_WRITE_SYNC;
+            }
+            if flags.contains(FdFlags::RSYNC) {
+                out |= DescriptorFlags::DATA_INTEGRITY_SYNC;
+            }
+            if flags.contains(FdFlags::SYNC) {
+                out |= DescriptorFlags::FILE_INTEGRITY_SYNC;
+            }
+            out
+        }
+
+        let descriptor = self.table().get(&fd)?;
+        match descriptor {
+            Descriptor::File(f) => {
+                let flags = f.run_blocking(|f| f.get_fd_flags()).await?;
+                let mut flags = get_from_fdflags(flags);
+                if f.open_mode.contains(OpenMode::READ) {
+                    flags |= DescriptorFlags::READ;
+                }
+                if f.open_mode.contains(OpenMode::WRITE) {
+                    flags |= DescriptorFlags::WRITE;
+                }
+                Ok(flags)
+            }
+            Descriptor::Dir(d) => {
+                let flags = d.run_blocking(|d| d.get_fd_flags()).await?;
+                let mut flags = get_from_fdflags(flags);
+                if d.open_mode.contains(OpenMode::READ) {
+                    flags |= DescriptorFlags::READ;
+                }
+                if d.open_mode.contains(OpenMode::WRITE) {
+                    flags |= DescriptorFlags::MUTATE_DIRECTORY;
+                }
+                Ok(flags)
+            }
+        }
+    }
+
+    async fn get_type(
+        &mut self,
+        fd: Resource<types::Descriptor>,
+    ) -> FsResult<types::DescriptorType> {
+        let descriptor = self.table().get(&fd)?;
+
+        match descriptor {
+            Descriptor::File(f) => {
+                let meta = f.run_blocking(|f| f.metadata()).await?;
+                Ok(descriptortype_from(meta.file_type()))
+            }
+            Descriptor::Dir(_) => Ok(types::DescriptorType::Directory),
+        }
+    }
+
+    async fn set_size(
+        &mut self,
+        fd: Resource<types::Descriptor>,
+        size: types::Filesize,
+    ) -> FsResult<()> {
+        let f = self.table().get(&fd)?.file()?;
+        if !f.perms.contains(FilePerms::WRITE) {
+            Err(ErrorCode::NotPermitted)?;
+        }
+        f.run_blocking(move |f| f.set_len(size)).await?;
+        Ok(())
+    }
+
+    async fn set_times(
+        &mut self,
+        fd: Resource<types::Descriptor>,
+        atim: types::NewTimestamp,
+        mtim: types::NewTimestamp,
+    ) -> FsResult<()> {
+        use fs_set_times::SetTimes;
+
+        let descriptor = self.table().get(&fd)?;
+        match descriptor {
+            Descriptor::File(f) => {
+                if !f.perms.contains(FilePerms::WRITE) {
+                    return Err(ErrorCode::NotPermitted.into());
+                }
+                let atim = systemtimespec_from(atim)?;
+                let mtim = systemtimespec_from(mtim)?;
+                f.run_blocking(|f| f.set_times(atim, mtim)).await?;
+                Ok(())
+            }
+            Descriptor::Dir(d) => {
+                if !d.perms.contains(DirPerms::MUTATE) {
+                    return Err(ErrorCode::NotPermitted.into());
+                }
+                let atim = systemtimespec_from(atim)?;
+                let mtim = systemtimespec_from(mtim)?;
+                d.run_blocking(|d| d.set_times(atim, mtim)).await?;
+                Ok(())
+            }
+        }
+    }
+
+    async fn read(
+        &mut self,
+        fd: Resource<types::Descriptor>,
+        len: types::Filesize,
+        offset: types::Filesize,
+    ) -> FsResult<(Vec<u8>, bool)> {
+        use std::io::IoSliceMut;
+        use system_interface::fs::FileIoExt;
+
+        let table = self.table();
+
+        let f = table.get(&fd)?.file()?;
+        if !f.perms.contains(FilePerms::READ) {
+            return Err(ErrorCode::NotPermitted.into());
+        }
+
+        let (mut buffer, r) = f
+            .run_blocking(move |f| {
+                let mut buffer = vec![0; len.try_into().unwrap_or(usize::MAX)];
+                let r = f.read_vectored_at(&mut [IoSliceMut::new(&mut buffer)], offset);
+                (buffer, r)
+            })
+            .await;
+
+        let (bytes_read, state) = match r? {
+            0 => (0, true),
+            n => (n, false),
+        };
+
+        buffer.truncate(
+            bytes_read
+                .try_into()
+                .expect("bytes read into memory as u64 fits in usize"),
+        );
+
+        Ok((buffer, state))
+    }
+
+    async fn write(
+        &mut self,
+        fd: Resource<types::Descriptor>,
+        buf: Vec<u8>,
+        offset: types::Filesize,
+    ) -> FsResult<types::Filesize> {
+        use std::io::IoSlice;
+        use system_interface::fs::FileIoExt;
+
+        let table = self.table();
+        let f = table.get(&fd)?.file()?;
+        if !f.perms.contains(FilePerms::WRITE) {
+            return Err(ErrorCode::NotPermitted.into());
+        }
+
+        let bytes_written = f
+            .run_blocking(move |f| f.write_vectored_at(&[IoSlice::new(&buf)], offset))
+            .await?;
+
+        Ok(types::Filesize::try_from(bytes_written).expect("usize fits in Filesize"))
+    }
+
+    async fn read_directory(
+        &mut self,
+        fd: Resource<types::Descriptor>,
+    ) -> FsResult<Resource<types::DirectoryEntryStream>> {
+        let table = self.table();
+        let d = table.get(&fd)?.dir()?;
+        if !d.perms.contains(DirPerms::READ) {
+            return Err(ErrorCode::NotPermitted.into());
+        }
+
+        enum ReaddirError {
+            Io(std::io::Error),
+            IllegalSequence,
+        }
+        impl From<std::io::Error> for ReaddirError {
+            fn from(e: std::io::Error) -> ReaddirError {
+                ReaddirError::Io(e)
+            }
+        }
+
+        let entries = d
+            .run_blocking(|d| {
+                // Both `entries` and `metadata` perform syscalls, which is why they are done
+                // within this `block` call, rather than delay calculating the metadata
+                // for entries when they're demanded later in the iterator chain.
+                Ok::<_, std::io::Error>(
+                    d.entries()?
+                        .map(|entry| {
+                            let entry = entry?;
+                            let meta = entry.metadata()?;
+                            let type_ = descriptortype_from(meta.file_type());
+                            let name = entry
+                                .file_name()
+                                .into_string()
+                                .map_err(|_| ReaddirError::IllegalSequence)?;
+                            Ok(types::DirectoryEntry { type_, name })
+                        })
+                        .collect::<Vec<Result<types::DirectoryEntry, ReaddirError>>>(),
+                )
+            })
+            .await?
+            .into_iter();
+
+        // On windows, filter out files like `C:\DumpStack.log.tmp` which we
+        // can't get full metadata for.
+        #[cfg(windows)]
+        let entries = entries.filter(|entry| {
+            use windows_sys::Win32::Foundation::{ERROR_ACCESS_DENIED, ERROR_SHARING_VIOLATION};
+            if let Err(ReaddirError::Io(err)) = entry {
+                if err.raw_os_error() == Some(ERROR_SHARING_VIOLATION as i32)
+                    || err.raw_os_error() == Some(ERROR_ACCESS_DENIED as i32)
+                {
+                    return false;
+                }
+            }
+            true
+        });
+        let entries = entries.map(|r| match r {
+            Ok(r) => Ok(r),
+            Err(ReaddirError::Io(e)) => Err(e.into()),
+            Err(ReaddirError::IllegalSequence) => Err(ErrorCode::IllegalByteSequence.into()),
+        });
+        Ok(table.push(ReaddirIterator::new(entries))?)
+    }
+
+    async fn sync(&mut self, fd: Resource<types::Descriptor>) -> FsResult<()> {
+        let descriptor = self.table().get(&fd)?;
+
+        match descriptor {
+            Descriptor::File(f) => {
+                match f.run_blocking(|f| f.sync_all()).await {
+                    Ok(()) => Ok(()),
+                    // On windows, `sync_data` uses `FileFlushBuffers` which fails with
+                    // `ERROR_ACCESS_DENIED` if the file is not upen for writing. Ignore
+                    // this error, for POSIX compatibility.
+                    #[cfg(windows)]
+                    Err(e)
+                        if e.raw_os_error()
+                            == Some(windows_sys::Win32::Foundation::ERROR_ACCESS_DENIED as _) =>
+                    {
+                        Ok(())
+                    }
+                    Err(e) => Err(e.into()),
+                }
+            }
+            Descriptor::Dir(d) => {
+                d.run_blocking(|d| Ok(d.open(std::path::Component::CurDir)?.sync_all()?))
+                    .await
+            }
+        }
+    }
+
+    async fn create_directory_at(
+        &mut self,
+        fd: Resource<types::Descriptor>,
+        path: String,
+    ) -> FsResult<()> {
+        let table = self.table();
+        let d = table.get(&fd)?.dir()?;
+        if !d.perms.contains(DirPerms::MUTATE) {
+            return Err(ErrorCode::NotPermitted.into());
+        }
+        d.run_blocking(move |d| d.create_dir(&path)).await?;
+        Ok(())
+    }
+
+    async fn stat(&mut self, fd: Resource<types::Descriptor>) -> FsResult<types::DescriptorStat> {
+        let descriptor = self.table().get(&fd)?;
+        match descriptor {
+            Descriptor::File(f) => {
+                // No permissions check on stat: if opened, allowed to stat it
+                let meta = f.run_blocking(|f| f.metadata()).await?;
+                Ok(descriptorstat_from(meta))
+            }
+            Descriptor::Dir(d) => {
+                // No permissions check on stat: if opened, allowed to stat it
+                let meta = d.run_blocking(|d| d.dir_metadata()).await?;
+                Ok(descriptorstat_from(meta))
+            }
+        }
+    }
+
+    async fn stat_at(
+        &mut self,
+        fd: Resource<types::Descriptor>,
+        path_flags: types::PathFlags,
+        path: String,
+    ) -> FsResult<types::DescriptorStat> {
+        let table = self.table();
+        let d = table.get(&fd)?.dir()?;
+        if !d.perms.contains(DirPerms::READ) {
+            return Err(ErrorCode::NotPermitted.into());
+        }
+
+        let meta = if symlink_follow(path_flags) {
+            d.run_blocking(move |d| d.metadata(&path)).await?
+        } else {
+            d.run_blocking(move |d| d.symlink_metadata(&path)).await?
+        };
+        Ok(descriptorstat_from(meta))
+    }
+
+    async fn set_times_at(
+        &mut self,
+        fd: Resource<types::Descriptor>,
+        path_flags: types::PathFlags,
+        path: String,
+        atim: types::NewTimestamp,
+        mtim: types::NewTimestamp,
+    ) -> FsResult<()> {
+        use cap_fs_ext::DirExt;
+
+        let table = self.table();
+        let d = table.get(&fd)?.dir()?;
+        if !d.perms.contains(DirPerms::MUTATE) {
+            return Err(ErrorCode::NotPermitted.into());
+        }
+        let atim = systemtimespec_from(atim)?;
+        let mtim = systemtimespec_from(mtim)?;
+        if symlink_follow(path_flags) {
+            d.run_blocking(move |d| {
+                d.set_times(
+                    &path,
+                    atim.map(cap_fs_ext::SystemTimeSpec::from_std),
+                    mtim.map(cap_fs_ext::SystemTimeSpec::from_std),
+                )
+            })
+            .await?;
+        } else {
+            d.run_blocking(move |d| {
+                d.set_symlink_times(
+                    &path,
+                    atim.map(cap_fs_ext::SystemTimeSpec::from_std),
+                    mtim.map(cap_fs_ext::SystemTimeSpec::from_std),
+                )
+            })
+            .await?;
+        }
+        Ok(())
+    }
+
+    async fn link_at(
+        &mut self,
+        fd: Resource<types::Descriptor>,
+        // TODO delete the path flags from this function
+        old_path_flags: types::PathFlags,
+        old_path: String,
+        new_descriptor: Resource<types::Descriptor>,
+        new_path: String,
+    ) -> FsResult<()> {
+        let table = self.table();
+        let old_dir = table.get(&fd)?.dir()?;
+        if !old_dir.perms.contains(DirPerms::MUTATE) {
+            return Err(ErrorCode::NotPermitted.into());
+        }
+        let new_dir = table.get(&new_descriptor)?.dir()?;
+        if !new_dir.perms.contains(DirPerms::MUTATE) {
+            return Err(ErrorCode::NotPermitted.into());
+        }
+        if symlink_follow(old_path_flags) {
+            return Err(ErrorCode::Invalid.into());
+        }
+        let new_dir_handle = std::sync::Arc::clone(&new_dir.dir);
+        old_dir
+            .run_blocking(move |d| d.hard_link(&old_path, &new_dir_handle, &new_path))
+            .await?;
+        Ok(())
+    }
+
+    async fn open_at(
+        &mut self,
+        fd: Resource<types::Descriptor>,
+        path_flags: types::PathFlags,
+        path: String,
+        oflags: types::OpenFlags,
+        flags: types::DescriptorFlags,
+    ) -> FsResult<Resource<types::Descriptor>> {
+        use cap_fs_ext::{FollowSymlinks, OpenOptionsFollowExt, OpenOptionsMaybeDirExt};
+        use system_interface::fs::{FdFlags, GetSetFdFlags};
+        use types::{DescriptorFlags, OpenFlags};
+
+        let allow_blocking_current_thread = self.ctx().allow_blocking_current_thread;
+        let table = self.table();
+        let d = table.get(&fd)?.dir()?;
+        if !d.perms.contains(DirPerms::READ) {
+            Err(ErrorCode::NotPermitted)?;
+        }
+
+        if !d.perms.contains(DirPerms::MUTATE) {
+            if oflags.contains(OpenFlags::CREATE) || oflags.contains(OpenFlags::TRUNCATE) {
+                Err(ErrorCode::NotPermitted)?;
+            }
+            if flags.contains(DescriptorFlags::WRITE) {
+                Err(ErrorCode::NotPermitted)?;
+            }
+        }
+
+        // Track whether we are creating file, for permission check:
+        let mut create = false;
+        // Track open mode, for permission check and recording in created descriptor:
+        let mut open_mode = OpenMode::empty();
+        // Construct the OpenOptions to give the OS:
+        let mut opts = cap_std::fs::OpenOptions::new();
+        opts.maybe_dir(true);
+
+        if oflags.contains(OpenFlags::CREATE) {
+            if oflags.contains(OpenFlags::EXCLUSIVE) {
+                opts.create_new(true);
+            } else {
+                opts.create(true);
+            }
+            create = true;
+            opts.write(true);
+            open_mode |= OpenMode::WRITE;
+        }
+
+        if oflags.contains(OpenFlags::TRUNCATE) {
+            opts.truncate(true).write(true);
+        }
+        if flags.contains(DescriptorFlags::READ) {
+            opts.read(true);
+            open_mode |= OpenMode::READ;
+        }
+        if flags.contains(DescriptorFlags::WRITE) {
+            opts.write(true);
+            open_mode |= OpenMode::WRITE;
+        } else {
+            // If not opened write, open read. This way the OS lets us open
+            // the file, but we can use perms to reject use of the file later.
+            opts.read(true);
+            open_mode |= OpenMode::READ;
+        }
+        if symlink_follow(path_flags) {
+            opts.follow(FollowSymlinks::Yes);
+        } else {
+            opts.follow(FollowSymlinks::No);
+        }
+
+        // These flags are not yet supported in cap-std:
+        if flags.contains(DescriptorFlags::FILE_INTEGRITY_SYNC)
+            || flags.contains(DescriptorFlags::DATA_INTEGRITY_SYNC)
+            || flags.contains(DescriptorFlags::REQUESTED_WRITE_SYNC)
+        {
+            Err(ErrorCode::Unsupported)?;
+        }
+
+        if oflags.contains(OpenFlags::DIRECTORY) {
+            if oflags.contains(OpenFlags::CREATE)
+                || oflags.contains(OpenFlags::EXCLUSIVE)
+                || oflags.contains(OpenFlags::TRUNCATE)
+            {
+                Err(ErrorCode::Invalid)?;
+            }
+        }
+
+        // Now enforce this WasiCtx's permissions before letting the OS have
+        // its shot:
+        if !d.perms.contains(DirPerms::MUTATE) && create {
+            Err(ErrorCode::NotPermitted)?;
+        }
+        if !d.file_perms.contains(FilePerms::WRITE) && open_mode.contains(OpenMode::WRITE) {
+            Err(ErrorCode::NotPermitted)?;
+        }
+
+        // Represents each possible outcome from the spawn_blocking operation.
+        // This makes sure we don't have to give spawn_blocking any way to
+        // manipulate the table.
+        enum OpenResult {
+            Dir(cap_std::fs::Dir),
+            File(cap_std::fs::File),
+            NotDir,
+        }
+
+        let opened = d
+            .run_blocking::<_, std::io::Result<OpenResult>>(move |d| {
+                let mut opened = d.open_with(&path, &opts)?;
+                if opened.metadata()?.is_dir() {
+                    Ok(OpenResult::Dir(cap_std::fs::Dir::from_std_file(
+                        opened.into_std(),
+                    )))
+                } else if oflags.contains(OpenFlags::DIRECTORY) {
+                    Ok(OpenResult::NotDir)
+                } else {
+                    // FIXME cap-std needs a nonblocking open option so that files reads and writes
+                    // are nonblocking. Instead we set it after opening here:
+                    let set_fd_flags = opened.new_set_fd_flags(FdFlags::NONBLOCK)?;
+                    opened.set_fd_flags(set_fd_flags)?;
+                    Ok(OpenResult::File(opened))
+                }
+            })
+            .await?;
+
+        match opened {
+            OpenResult::Dir(dir) => Ok(table.push(Descriptor::Dir(Dir::new(
+                dir,
+                d.perms,
+                d.file_perms,
+                open_mode,
+                allow_blocking_current_thread,
+            )))?),
+
+            OpenResult::File(file) => Ok(table.push(Descriptor::File(File::new(
+                file,
+                d.file_perms,
+                open_mode,
+                allow_blocking_current_thread,
+            )))?),
+
+            OpenResult::NotDir => Err(ErrorCode::NotDirectory.into()),
+        }
+    }
+
+    fn drop(&mut self, fd: Resource<types::Descriptor>) -> anyhow::Result<()> {
+        let table = self.table();
+
+        // The Drop will close the file/dir, but if the close syscall
+        // blocks the thread, I will face god and walk backwards into hell.
+        // tokio::fs::File just uses std::fs::File's Drop impl to close, so
+        // it doesn't appear anyone else has found this to be a problem.
+        // (Not that they could solve it without async drop...)
+        table.delete(fd)?;
+
+        Ok(())
+    }
+
+    async fn readlink_at(
+        &mut self,
+        fd: Resource<types::Descriptor>,
+        path: String,
+    ) -> FsResult<String> {
+        let table = self.table();
+        let d = table.get(&fd)?.dir()?;
+        if !d.perms.contains(DirPerms::READ) {
+            return Err(ErrorCode::NotPermitted.into());
+        }
+        let link = d.run_blocking(move |d| d.read_link(&path)).await?;
+        Ok(link
+            .into_os_string()
+            .into_string()
+            .map_err(|_| ErrorCode::IllegalByteSequence)?)
+    }
+
+    async fn remove_directory_at(
+        &mut self,
+        fd: Resource<types::Descriptor>,
+        path: String,
+    ) -> FsResult<()> {
+        let table = self.table();
+        let d = table.get(&fd)?.dir()?;
+        if !d.perms.contains(DirPerms::MUTATE) {
+            return Err(ErrorCode::NotPermitted.into());
+        }
+        Ok(d.run_blocking(move |d| d.remove_dir(&path)).await?)
+    }
+
+    async fn rename_at(
+        &mut self,
+        fd: Resource<types::Descriptor>,
+        old_path: String,
+        new_fd: Resource<types::Descriptor>,
+        new_path: String,
+    ) -> FsResult<()> {
+        let table = self.table();
+        let old_dir = table.get(&fd)?.dir()?;
+        if !old_dir.perms.contains(DirPerms::MUTATE) {
+            return Err(ErrorCode::NotPermitted.into());
+        }
+        let new_dir = table.get(&new_fd)?.dir()?;
+        if !new_dir.perms.contains(DirPerms::MUTATE) {
+            return Err(ErrorCode::NotPermitted.into());
+        }
+        let new_dir_handle = std::sync::Arc::clone(&new_dir.dir);
+        Ok(old_dir
+            .run_blocking(move |d| d.rename(&old_path, &new_dir_handle, &new_path))
+            .await?)
+    }
+
+    async fn symlink_at(
+        &mut self,
+        fd: Resource<types::Descriptor>,
+        src_path: String,
+        dest_path: String,
+    ) -> FsResult<()> {
+        // On windows, Dir.symlink is provided by DirExt
+        #[cfg(windows)]
+        use cap_fs_ext::DirExt;
+
+        let table = self.table();
+        let d = table.get(&fd)?.dir()?;
+        if !d.perms.contains(DirPerms::MUTATE) {
+            return Err(ErrorCode::NotPermitted.into());
+        }
+        Ok(d.run_blocking(move |d| d.symlink(&src_path, &dest_path))
+            .await?)
+    }
+
+    async fn unlink_file_at(
+        &mut self,
+        fd: Resource<types::Descriptor>,
+        path: String,
+    ) -> FsResult<()> {
+        use cap_fs_ext::DirExt;
+
+        let table = self.table();
+        let d = table.get(&fd)?.dir()?;
+        if !d.perms.contains(DirPerms::MUTATE) {
+            return Err(ErrorCode::NotPermitted.into());
+        }
+        Ok(d.run_blocking(move |d| d.remove_file_or_symlink(&path))
+            .await?)
+    }
+
+    fn read_via_stream(
+        &mut self,
+        fd: Resource<types::Descriptor>,
+        offset: types::Filesize,
+    ) -> FsResult<Resource<InputStream>> {
+        // Trap if fd lookup fails:
+        let f = self.table().get(&fd)?.file()?;
+
+        if !f.perms.contains(FilePerms::READ) {
+            Err(types::ErrorCode::BadDescriptor)?;
+        }
+
+        // Create a stream view for it.
+        let reader: InputStream = Box::new(FileInputStream::new(f, offset));
+
+        // Insert the stream view into the table. Trap if the table is full.
+        let index = self.table().push(reader)?;
+
+        Ok(index)
+    }
+
+    fn write_via_stream(
+        &mut self,
+        fd: Resource<types::Descriptor>,
+        offset: types::Filesize,
+    ) -> FsResult<Resource<OutputStream>> {
+        // Trap if fd lookup fails:
+        let f = self.table().get(&fd)?.file()?;
+
+        if !f.perms.contains(FilePerms::WRITE) {
+            Err(types::ErrorCode::BadDescriptor)?;
+        }
+
+        // Create a stream view for it.
+        let writer = FileOutputStream::write_at(f, offset);
+        let writer: OutputStream = Box::new(writer);
+
+        // Insert the stream view into the table. Trap if the table is full.
+        let index = self.table().push(writer)?;
+
+        Ok(index)
+    }
+
+    fn append_via_stream(
+        &mut self,
+        fd: Resource<types::Descriptor>,
+    ) -> FsResult<Resource<OutputStream>> {
+        // Trap if fd lookup fails:
+        let f = self.table().get(&fd)?.file()?;
+
+        if !f.perms.contains(FilePerms::WRITE) {
+            Err(types::ErrorCode::BadDescriptor)?;
+        }
+
+        // Create a stream view for it.
+        let appender = FileOutputStream::append(f);
+        let appender: OutputStream = Box::new(appender);
+
+        // Insert the stream view into the table. Trap if the table is full.
+        let index = self.table().push(appender)?;
+
+        Ok(index)
+    }
+
+    async fn is_same_object(
+        &mut self,
+        a: Resource<types::Descriptor>,
+        b: Resource<types::Descriptor>,
+    ) -> anyhow::Result<bool> {
+        use cap_fs_ext::MetadataExt;
+        let descriptor_a = self.table().get(&a)?;
+        let meta_a = get_descriptor_metadata(descriptor_a).await?;
+        let descriptor_b = self.table().get(&b)?;
+        let meta_b = get_descriptor_metadata(descriptor_b).await?;
+        if meta_a.dev() == meta_b.dev() && meta_a.ino() == meta_b.ino() {
+            // MetadataHashValue does not derive eq, so use a pair of
+            // comparisons to check equality:
+            debug_assert_eq!(
+                calculate_metadata_hash(&meta_a).upper,
+                calculate_metadata_hash(&meta_b).upper
+            );
+            debug_assert_eq!(
+                calculate_metadata_hash(&meta_a).lower,
+                calculate_metadata_hash(&meta_b).lower
+            );
+            Ok(true)
+        } else {
+            // Hash collisions are possible, so don't assert the negative here
+            Ok(false)
+        }
+    }
+    async fn metadata_hash(
+        &mut self,
+        fd: Resource<types::Descriptor>,
+    ) -> FsResult<types::MetadataHashValue> {
+        let descriptor_a = self.table().get(&fd)?;
+        let meta = get_descriptor_metadata(descriptor_a).await?;
+        Ok(calculate_metadata_hash(&meta))
+    }
+    async fn metadata_hash_at(
+        &mut self,
+        fd: Resource<types::Descriptor>,
+        path_flags: types::PathFlags,
+        path: String,
+    ) -> FsResult<types::MetadataHashValue> {
+        let table = self.table();
+        let d = table.get(&fd)?.dir()?;
+        // No permissions check on metadata: if dir opened, allowed to stat it
+        let meta = d
+            .run_blocking(move |d| {
+                if symlink_follow(path_flags) {
+                    d.metadata(path)
+                } else {
+                    d.symlink_metadata(path)
+                }
+            })
+            .await?;
+        Ok(calculate_metadata_hash(&meta))
+    }
+}
+
+#[async_trait::async_trait]
+impl<T> HostDirectoryEntryStream for WasiImpl<T>
+where
+    T: WasiView,
+{
+    async fn read_directory_entry(
+        &mut self,
+        stream: Resource<types::DirectoryEntryStream>,
+    ) -> FsResult<Option<types::DirectoryEntry>> {
+        let table = self.table();
+        let readdir = table.get(&stream)?;
+        readdir.next()
+    }
+
+    fn drop(&mut self, stream: Resource<types::DirectoryEntryStream>) -> anyhow::Result<()> {
+        self.table().delete(stream)?;
+        Ok(())
+    }
+}
+
+async fn get_descriptor_metadata(fd: &types::Descriptor) -> FsResult<cap_std::fs::Metadata> {
+    match fd {
+        Descriptor::File(f) => {
+            // No permissions check on metadata: if opened, allowed to stat it
+            Ok(f.run_blocking(|f| f.metadata()).await?)
+        }
+        Descriptor::Dir(d) => {
+            // No permissions check on metadata: if opened, allowed to stat it
+            Ok(d.run_blocking(|d| d.dir_metadata()).await?)
+        }
+    }
+}
+
+fn calculate_metadata_hash(meta: &cap_std::fs::Metadata) -> types::MetadataHashValue {
+    use cap_fs_ext::MetadataExt;
+    // Without incurring any deps, std provides us with a 64 bit hash
+    // function:
+    use std::hash::Hasher;
+    // Note that this means that the metadata hash (which becomes a preview1 ino) may
+    // change when a different rustc release is used to build this host implementation:
+    let mut hasher = std::collections::hash_map::DefaultHasher::new();
+    hasher.write_u64(meta.dev());
+    hasher.write_u64(meta.ino());
+    let lower = hasher.finish();
+    // MetadataHashValue has a pair of 64-bit members for representing a
+    // single 128-bit number. However, we only have 64 bits of entropy. To
+    // synthesize the upper 64 bits, lets xor the lower half with an arbitrary
+    // constant, in this case the 64 bit integer corresponding to the IEEE
+    // double representation of (a number as close as possible to) pi.
+    // This seems better than just repeating the same bits in the upper and
+    // lower parts outright, which could make folks wonder if the struct was
+    // mangled in the ABI, or worse yet, lead to consumers of this interface
+    // expecting them to be equal.
+    let upper = lower ^ 4614256656552045848u64;
+    types::MetadataHashValue { lower, upper }
+}
+
+#[cfg(unix)]
+fn from_raw_os_error(err: Option<i32>) -> Option<ErrorCode> {
+    use rustix::io::Errno as RustixErrno;
+    if err.is_none() {
+        return None;
+    }
+    Some(match RustixErrno::from_raw_os_error(err.unwrap()) {
+        RustixErrno::PIPE => ErrorCode::Pipe,
+        RustixErrno::PERM => ErrorCode::NotPermitted,
+        RustixErrno::NOENT => ErrorCode::NoEntry,
+        RustixErrno::NOMEM => ErrorCode::InsufficientMemory,
+        RustixErrno::IO => ErrorCode::Io,
+        RustixErrno::BADF => ErrorCode::BadDescriptor,
+        RustixErrno::BUSY => ErrorCode::Busy,
+        RustixErrno::ACCESS => ErrorCode::Access,
+        RustixErrno::NOTDIR => ErrorCode::NotDirectory,
+        RustixErrno::ISDIR => ErrorCode::IsDirectory,
+        RustixErrno::INVAL => ErrorCode::Invalid,
+        RustixErrno::EXIST => ErrorCode::Exist,
+        RustixErrno::FBIG => ErrorCode::FileTooLarge,
+        RustixErrno::NOSPC => ErrorCode::InsufficientSpace,
+        RustixErrno::SPIPE => ErrorCode::InvalidSeek,
+        RustixErrno::MLINK => ErrorCode::TooManyLinks,
+        RustixErrno::NAMETOOLONG => ErrorCode::NameTooLong,
+        RustixErrno::NOTEMPTY => ErrorCode::NotEmpty,
+        RustixErrno::LOOP => ErrorCode::Loop,
+        RustixErrno::OVERFLOW => ErrorCode::Overflow,
+        RustixErrno::ILSEQ => ErrorCode::IllegalByteSequence,
+        RustixErrno::NOTSUP => ErrorCode::Unsupported,
+        RustixErrno::ALREADY => ErrorCode::Already,
+        RustixErrno::INPROGRESS => ErrorCode::InProgress,
+        RustixErrno::INTR => ErrorCode::Interrupted,
+
+        // On some platforms, these have the same value as other errno values.
+        #[allow(unreachable_patterns)]
+        RustixErrno::OPNOTSUPP => ErrorCode::Unsupported,
+
+        _ => return None,
+    })
+}
+#[cfg(windows)]
+fn from_raw_os_error(raw_os_error: Option<i32>) -> Option<ErrorCode> {
+    use windows_sys::Win32::Foundation;
+    Some(match raw_os_error.map(|code| code as u32) {
+        Some(Foundation::ERROR_FILE_NOT_FOUND) => ErrorCode::NoEntry,
+        Some(Foundation::ERROR_PATH_NOT_FOUND) => ErrorCode::NoEntry,
+        Some(Foundation::ERROR_ACCESS_DENIED) => ErrorCode::Access,
+        Some(Foundation::ERROR_SHARING_VIOLATION) => ErrorCode::Access,
+        Some(Foundation::ERROR_PRIVILEGE_NOT_HELD) => ErrorCode::NotPermitted,
+        Some(Foundation::ERROR_INVALID_HANDLE) => ErrorCode::BadDescriptor,
+        Some(Foundation::ERROR_INVALID_NAME) => ErrorCode::NoEntry,
+        Some(Foundation::ERROR_NOT_ENOUGH_MEMORY) => ErrorCode::InsufficientMemory,
+        Some(Foundation::ERROR_OUTOFMEMORY) => ErrorCode::InsufficientMemory,
+        Some(Foundation::ERROR_DIR_NOT_EMPTY) => ErrorCode::NotEmpty,
+        Some(Foundation::ERROR_NOT_READY) => ErrorCode::Busy,
+        Some(Foundation::ERROR_BUSY) => ErrorCode::Busy,
+        Some(Foundation::ERROR_NOT_SUPPORTED) => ErrorCode::Unsupported,
+        Some(Foundation::ERROR_FILE_EXISTS) => ErrorCode::Exist,
+        Some(Foundation::ERROR_BROKEN_PIPE) => ErrorCode::Pipe,
+        Some(Foundation::ERROR_BUFFER_OVERFLOW) => ErrorCode::NameTooLong,
+        Some(Foundation::ERROR_NOT_A_REPARSE_POINT) => ErrorCode::Invalid,
+        Some(Foundation::ERROR_NEGATIVE_SEEK) => ErrorCode::Invalid,
+        Some(Foundation::ERROR_DIRECTORY) => ErrorCode::NotDirectory,
+        Some(Foundation::ERROR_ALREADY_EXISTS) => ErrorCode::Exist,
+        Some(Foundation::ERROR_STOPPED_ON_SYMLINK) => ErrorCode::Loop,
+        Some(Foundation::ERROR_DIRECTORY_NOT_SUPPORTED) => ErrorCode::IsDirectory,
+        _ => return None,
+    })
+}
+
+impl From<std::io::Error> for ErrorCode {
+    fn from(err: std::io::Error) -> ErrorCode {
+        ErrorCode::from(&err)
+    }
+}
+
+impl<'a> From<&'a std::io::Error> for ErrorCode {
+    fn from(err: &'a std::io::Error) -> ErrorCode {
+        match from_raw_os_error(err.raw_os_error()) {
+            Some(errno) => errno,
+            None => {
+                tracing::debug!("unknown raw os error: {err}");
+                match err.kind() {
+                    std::io::ErrorKind::NotFound => ErrorCode::NoEntry,
+                    std::io::ErrorKind::PermissionDenied => ErrorCode::NotPermitted,
+                    std::io::ErrorKind::AlreadyExists => ErrorCode::Exist,
+                    std::io::ErrorKind::InvalidInput => ErrorCode::Invalid,
+                    _ => ErrorCode::Io,
+                }
+            }
+        }
+    }
+}
+
+impl From<cap_rand::Error> for ErrorCode {
+    fn from(err: cap_rand::Error) -> ErrorCode {
+        // I picked Error::Io as a 'reasonable default', FIXME dan is this ok?
+        from_raw_os_error(err.raw_os_error()).unwrap_or(ErrorCode::Io)
+    }
+}
+
+impl From<std::num::TryFromIntError> for ErrorCode {
+    fn from(_err: std::num::TryFromIntError) -> ErrorCode {
+        ErrorCode::Overflow
+    }
+}
+
+fn descriptortype_from(ft: cap_std::fs::FileType) -> types::DescriptorType {
+    use cap_fs_ext::FileTypeExt;
+    use types::DescriptorType;
+    if ft.is_dir() {
+        DescriptorType::Directory
+    } else if ft.is_symlink() {
+        DescriptorType::SymbolicLink
+    } else if ft.is_block_device() {
+        DescriptorType::BlockDevice
+    } else if ft.is_char_device() {
+        DescriptorType::CharacterDevice
+    } else if ft.is_file() {
+        DescriptorType::RegularFile
+    } else {
+        DescriptorType::Unknown
+    }
+}
+
+fn systemtimespec_from(t: types::NewTimestamp) -> FsResult<Option<fs_set_times::SystemTimeSpec>> {
+    use fs_set_times::SystemTimeSpec;
+    use types::NewTimestamp;
+    match t {
+        NewTimestamp::NoChange => Ok(None),
+        NewTimestamp::Now => Ok(Some(SystemTimeSpec::SymbolicNow)),
+        NewTimestamp::Timestamp(st) => Ok(Some(SystemTimeSpec::Absolute(systemtime_from(st)?))),
+    }
+}
+
+fn systemtime_from(t: wall_clock::Datetime) -> FsResult<std::time::SystemTime> {
+    use std::time::{Duration, SystemTime};
+    SystemTime::UNIX_EPOCH
+        .checked_add(Duration::new(t.seconds, t.nanoseconds))
+        .ok_or_else(|| ErrorCode::Overflow.into())
+}
+
+fn datetime_from(t: std::time::SystemTime) -> wall_clock::Datetime {
+    // FIXME make this infallible or handle errors properly
+    wall_clock::Datetime::try_from(cap_std::time::SystemTime::from_std(t)).unwrap()
+}
+
+fn descriptorstat_from(meta: cap_std::fs::Metadata) -> types::DescriptorStat {
+    use cap_fs_ext::MetadataExt;
+    types::DescriptorStat {
+        type_: descriptortype_from(meta.file_type()),
+        link_count: meta.nlink(),
+        size: meta.len(),
+        data_access_timestamp: meta.accessed().map(|t| datetime_from(t.into_std())).ok(),
+        data_modification_timestamp: meta.modified().map(|t| datetime_from(t.into_std())).ok(),
+        status_change_timestamp: meta.created().map(|t| datetime_from(t.into_std())).ok(),
+    }
+}
+
+fn symlink_follow(path_flags: types::PathFlags) -> bool {
+    path_flags.contains(types::PathFlags::SYMLINK_FOLLOW)
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use wasmtime::component::ResourceTable;
+
+    #[test]
+    fn table_readdir_works() {
+        let mut table = ResourceTable::new();
+        let ix = table
+            .push(ReaddirIterator::new(std::iter::empty()))
+            .unwrap();
+        let _ = table.get(&ix).unwrap();
+        table.delete(ix).unwrap();
+    }
+}
diff --git a/crates/wasi/src/host/filesystem/sync.rs b/crates/wasi/src/host/filesystem/sync.rs
new file mode 100644
index 000000000000..5de6b051921d
--- /dev/null
+++ b/crates/wasi/src/host/filesystem/sync.rs
@@ -0,0 +1,525 @@
+use crate::bindings::filesystem::types as async_filesystem;
+use crate::bindings::sync::filesystem::types as sync_filesystem;
+use crate::bindings::sync::io::streams;
+use crate::runtime::in_tokio;
+use crate::{FsError, FsResult, WasiImpl, WasiView};
+use wasmtime::component::Resource;
+
+impl<T> sync_filesystem::Host for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn convert_error_code(&mut self, err: FsError) -> anyhow::Result<sync_filesystem::ErrorCode> {
+        Ok(async_filesystem::Host::convert_error_code(self, err)?.into())
+    }
+
+    fn filesystem_error_code(
+        &mut self,
+        err: Resource<streams::Error>,
+    ) -> anyhow::Result<Option<sync_filesystem::ErrorCode>> {
+        Ok(async_filesystem::Host::filesystem_error_code(self, err)?.map(|e| e.into()))
+    }
+}
+
+impl<T> sync_filesystem::HostDescriptor for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn advise(
+        &mut self,
+        fd: Resource<sync_filesystem::Descriptor>,
+        offset: sync_filesystem::Filesize,
+        len: sync_filesystem::Filesize,
+        advice: sync_filesystem::Advice,
+    ) -> FsResult<()> {
+        in_tokio(async {
+            async_filesystem::HostDescriptor::advise(self, fd, offset, len, advice.into()).await
+        })
+    }
+
+    fn sync_data(&mut self, fd: Resource<sync_filesystem::Descriptor>) -> FsResult<()> {
+        in_tokio(async { async_filesystem::HostDescriptor::sync_data(self, fd).await })
+    }
+
+    fn get_flags(
+        &mut self,
+        fd: Resource<sync_filesystem::Descriptor>,
+    ) -> FsResult<sync_filesystem::DescriptorFlags> {
+        Ok(in_tokio(async { async_filesystem::HostDescriptor::get_flags(self, fd).await })?.into())
+    }
+
+    fn get_type(
+        &mut self,
+        fd: Resource<sync_filesystem::Descriptor>,
+    ) -> FsResult<sync_filesystem::DescriptorType> {
+        Ok(in_tokio(async { async_filesystem::HostDescriptor::get_type(self, fd).await })?.into())
+    }
+
+    fn set_size(
+        &mut self,
+        fd: Resource<sync_filesystem::Descriptor>,
+        size: sync_filesystem::Filesize,
+    ) -> FsResult<()> {
+        in_tokio(async { async_filesystem::HostDescriptor::set_size(self, fd, size).await })
+    }
+
+    fn set_times(
+        &mut self,
+        fd: Resource<sync_filesystem::Descriptor>,
+        atim: sync_filesystem::NewTimestamp,
+        mtim: sync_filesystem::NewTimestamp,
+    ) -> FsResult<()> {
+        in_tokio(async {
+            async_filesystem::HostDescriptor::set_times(self, fd, atim.into(), mtim.into()).await
+        })
+    }
+
+    fn read(
+        &mut self,
+        fd: Resource<sync_filesystem::Descriptor>,
+        len: sync_filesystem::Filesize,
+        offset: sync_filesystem::Filesize,
+    ) -> FsResult<(Vec<u8>, bool)> {
+        in_tokio(async { async_filesystem::HostDescriptor::read(self, fd, len, offset).await })
+    }
+
+    fn write(
+        &mut self,
+        fd: Resource<sync_filesystem::Descriptor>,
+        buf: Vec<u8>,
+        offset: sync_filesystem::Filesize,
+    ) -> FsResult<sync_filesystem::Filesize> {
+        in_tokio(async { async_filesystem::HostDescriptor::write(self, fd, buf, offset).await })
+    }
+
+    fn read_directory(
+        &mut self,
+        fd: Resource<sync_filesystem::Descriptor>,
+    ) -> FsResult<Resource<sync_filesystem::DirectoryEntryStream>> {
+        in_tokio(async { async_filesystem::HostDescriptor::read_directory(self, fd).await })
+    }
+
+    fn sync(&mut self, fd: Resource<sync_filesystem::Descriptor>) -> FsResult<()> {
+        in_tokio(async { async_filesystem::HostDescriptor::sync(self, fd).await })
+    }
+
+    fn create_directory_at(
+        &mut self,
+        fd: Resource<sync_filesystem::Descriptor>,
+        path: String,
+    ) -> FsResult<()> {
+        in_tokio(async {
+            async_filesystem::HostDescriptor::create_directory_at(self, fd, path).await
+        })
+    }
+
+    fn stat(
+        &mut self,
+        fd: Resource<sync_filesystem::Descriptor>,
+    ) -> FsResult<sync_filesystem::DescriptorStat> {
+        Ok(in_tokio(async { async_filesystem::HostDescriptor::stat(self, fd).await })?.into())
+    }
+
+    fn stat_at(
+        &mut self,
+        fd: Resource<sync_filesystem::Descriptor>,
+        path_flags: sync_filesystem::PathFlags,
+        path: String,
+    ) -> FsResult<sync_filesystem::DescriptorStat> {
+        Ok(in_tokio(async {
+            async_filesystem::HostDescriptor::stat_at(self, fd, path_flags.into(), path).await
+        })?
+        .into())
+    }
+
+    fn set_times_at(
+        &mut self,
+        fd: Resource<sync_filesystem::Descriptor>,
+        path_flags: sync_filesystem::PathFlags,
+        path: String,
+        atim: sync_filesystem::NewTimestamp,
+        mtim: sync_filesystem::NewTimestamp,
+    ) -> FsResult<()> {
+        in_tokio(async {
+            async_filesystem::HostDescriptor::set_times_at(
+                self,
+                fd,
+                path_flags.into(),
+                path,
+                atim.into(),
+                mtim.into(),
+            )
+            .await
+        })
+    }
+
+    fn link_at(
+        &mut self,
+        fd: Resource<sync_filesystem::Descriptor>,
+        // TODO delete the path flags from this function
+        old_path_flags: sync_filesystem::PathFlags,
+        old_path: String,
+        new_descriptor: Resource<sync_filesystem::Descriptor>,
+        new_path: String,
+    ) -> FsResult<()> {
+        in_tokio(async {
+            async_filesystem::HostDescriptor::link_at(
+                self,
+                fd,
+                old_path_flags.into(),
+                old_path,
+                new_descriptor,
+                new_path,
+            )
+            .await
+        })
+    }
+
+    fn open_at(
+        &mut self,
+        fd: Resource<sync_filesystem::Descriptor>,
+        path_flags: sync_filesystem::PathFlags,
+        path: String,
+        oflags: sync_filesystem::OpenFlags,
+        flags: sync_filesystem::DescriptorFlags,
+    ) -> FsResult<Resource<sync_filesystem::Descriptor>> {
+        in_tokio(async {
+            async_filesystem::HostDescriptor::open_at(
+                self,
+                fd,
+                path_flags.into(),
+                path,
+                oflags.into(),
+                flags.into(),
+            )
+            .await
+        })
+    }
+
+    fn drop(&mut self, fd: Resource<sync_filesystem::Descriptor>) -> anyhow::Result<()> {
+        async_filesystem::HostDescriptor::drop(self, fd)
+    }
+
+    fn readlink_at(
+        &mut self,
+        fd: Resource<sync_filesystem::Descriptor>,
+        path: String,
+    ) -> FsResult<String> {
+        in_tokio(async { async_filesystem::HostDescriptor::readlink_at(self, fd, path).await })
+    }
+
+    fn remove_directory_at(
+        &mut self,
+        fd: Resource<sync_filesystem::Descriptor>,
+        path: String,
+    ) -> FsResult<()> {
+        in_tokio(async {
+            async_filesystem::HostDescriptor::remove_directory_at(self, fd, path).await
+        })
+    }
+
+    fn rename_at(
+        &mut self,
+        fd: Resource<sync_filesystem::Descriptor>,
+        old_path: String,
+        new_fd: Resource<sync_filesystem::Descriptor>,
+        new_path: String,
+    ) -> FsResult<()> {
+        in_tokio(async {
+            async_filesystem::HostDescriptor::rename_at(self, fd, old_path, new_fd, new_path).await
+        })
+    }
+
+    fn symlink_at(
+        &mut self,
+        fd: Resource<sync_filesystem::Descriptor>,
+        src_path: String,
+        dest_path: String,
+    ) -> FsResult<()> {
+        in_tokio(async {
+            async_filesystem::HostDescriptor::symlink_at(self, fd, src_path, dest_path).await
+        })
+    }
+
+    fn unlink_file_at(
+        &mut self,
+        fd: Resource<sync_filesystem::Descriptor>,
+        path: String,
+    ) -> FsResult<()> {
+        in_tokio(async { async_filesystem::HostDescriptor::unlink_file_at(self, fd, path).await })
+    }
+
+    fn read_via_stream(
+        &mut self,
+        fd: Resource<sync_filesystem::Descriptor>,
+        offset: sync_filesystem::Filesize,
+    ) -> FsResult<Resource<streams::InputStream>> {
+        Ok(async_filesystem::HostDescriptor::read_via_stream(
+            self, fd, offset,
+        )?)
+    }
+
+    fn write_via_stream(
+        &mut self,
+        fd: Resource<sync_filesystem::Descriptor>,
+        offset: sync_filesystem::Filesize,
+    ) -> FsResult<Resource<streams::OutputStream>> {
+        Ok(async_filesystem::HostDescriptor::write_via_stream(
+            self, fd, offset,
+        )?)
+    }
+
+    fn append_via_stream(
+        &mut self,
+        fd: Resource<sync_filesystem::Descriptor>,
+    ) -> FsResult<Resource<streams::OutputStream>> {
+        Ok(async_filesystem::HostDescriptor::append_via_stream(
+            self, fd,
+        )?)
+    }
+
+    fn is_same_object(
+        &mut self,
+        a: Resource<sync_filesystem::Descriptor>,
+        b: Resource<sync_filesystem::Descriptor>,
+    ) -> anyhow::Result<bool> {
+        in_tokio(async { async_filesystem::HostDescriptor::is_same_object(self, a, b).await })
+    }
+    fn metadata_hash(
+        &mut self,
+        fd: Resource<sync_filesystem::Descriptor>,
+    ) -> FsResult<sync_filesystem::MetadataHashValue> {
+        Ok(
+            in_tokio(async { async_filesystem::HostDescriptor::metadata_hash(self, fd).await })?
+                .into(),
+        )
+    }
+    fn metadata_hash_at(
+        &mut self,
+        fd: Resource<sync_filesystem::Descriptor>,
+        path_flags: sync_filesystem::PathFlags,
+        path: String,
+    ) -> FsResult<sync_filesystem::MetadataHashValue> {
+        Ok(in_tokio(async {
+            async_filesystem::HostDescriptor::metadata_hash_at(self, fd, path_flags.into(), path)
+                .await
+        })?
+        .into())
+    }
+}
+
+impl<T> sync_filesystem::HostDirectoryEntryStream for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn read_directory_entry(
+        &mut self,
+        stream: Resource<sync_filesystem::DirectoryEntryStream>,
+    ) -> FsResult<Option<sync_filesystem::DirectoryEntry>> {
+        Ok(in_tokio(async {
+            async_filesystem::HostDirectoryEntryStream::read_directory_entry(self, stream).await
+        })?
+        .map(|e| e.into()))
+    }
+
+    fn drop(
+        &mut self,
+        stream: Resource<sync_filesystem::DirectoryEntryStream>,
+    ) -> anyhow::Result<()> {
+        async_filesystem::HostDirectoryEntryStream::drop(self, stream)
+    }
+}
+
+impl From<async_filesystem::ErrorCode> for sync_filesystem::ErrorCode {
+    fn from(other: async_filesystem::ErrorCode) -> Self {
+        use async_filesystem::ErrorCode;
+        match other {
+            ErrorCode::Access => Self::Access,
+            ErrorCode::WouldBlock => Self::WouldBlock,
+            ErrorCode::Already => Self::Already,
+            ErrorCode::BadDescriptor => Self::BadDescriptor,
+            ErrorCode::Busy => Self::Busy,
+            ErrorCode::Deadlock => Self::Deadlock,
+            ErrorCode::Quota => Self::Quota,
+            ErrorCode::Exist => Self::Exist,
+            ErrorCode::FileTooLarge => Self::FileTooLarge,
+            ErrorCode::IllegalByteSequence => Self::IllegalByteSequence,
+            ErrorCode::InProgress => Self::InProgress,
+            ErrorCode::Interrupted => Self::Interrupted,
+            ErrorCode::Invalid => Self::Invalid,
+            ErrorCode::Io => Self::Io,
+            ErrorCode::IsDirectory => Self::IsDirectory,
+            ErrorCode::Loop => Self::Loop,
+            ErrorCode::TooManyLinks => Self::TooManyLinks,
+            ErrorCode::MessageSize => Self::MessageSize,
+            ErrorCode::NameTooLong => Self::NameTooLong,
+            ErrorCode::NoDevice => Self::NoDevice,
+            ErrorCode::NoEntry => Self::NoEntry,
+            ErrorCode::NoLock => Self::NoLock,
+            ErrorCode::InsufficientMemory => Self::InsufficientMemory,
+            ErrorCode::InsufficientSpace => Self::InsufficientSpace,
+            ErrorCode::NotDirectory => Self::NotDirectory,
+            ErrorCode::NotEmpty => Self::NotEmpty,
+            ErrorCode::NotRecoverable => Self::NotRecoverable,
+            ErrorCode::Unsupported => Self::Unsupported,
+            ErrorCode::NoTty => Self::NoTty,
+            ErrorCode::NoSuchDevice => Self::NoSuchDevice,
+            ErrorCode::Overflow => Self::Overflow,
+            ErrorCode::NotPermitted => Self::NotPermitted,
+            ErrorCode::Pipe => Self::Pipe,
+            ErrorCode::ReadOnly => Self::ReadOnly,
+            ErrorCode::InvalidSeek => Self::InvalidSeek,
+            ErrorCode::TextFileBusy => Self::TextFileBusy,
+            ErrorCode::CrossDevice => Self::CrossDevice,
+        }
+    }
+}
+
+impl From<sync_filesystem::Advice> for async_filesystem::Advice {
+    fn from(other: sync_filesystem::Advice) -> Self {
+        use sync_filesystem::Advice;
+        match other {
+            Advice::Normal => Self::Normal,
+            Advice::Sequential => Self::Sequential,
+            Advice::Random => Self::Random,
+            Advice::WillNeed => Self::WillNeed,
+            Advice::DontNeed => Self::DontNeed,
+            Advice::NoReuse => Self::NoReuse,
+        }
+    }
+}
+
+impl From<async_filesystem::DescriptorFlags> for sync_filesystem::DescriptorFlags {
+    fn from(other: async_filesystem::DescriptorFlags) -> Self {
+        let mut out = Self::empty();
+        if other.contains(async_filesystem::DescriptorFlags::READ) {
+            out |= Self::READ;
+        }
+        if other.contains(async_filesystem::DescriptorFlags::WRITE) {
+            out |= Self::WRITE;
+        }
+        if other.contains(async_filesystem::DescriptorFlags::FILE_INTEGRITY_SYNC) {
+            out |= Self::FILE_INTEGRITY_SYNC;
+        }
+        if other.contains(async_filesystem::DescriptorFlags::DATA_INTEGRITY_SYNC) {
+            out |= Self::DATA_INTEGRITY_SYNC;
+        }
+        if other.contains(async_filesystem::DescriptorFlags::REQUESTED_WRITE_SYNC) {
+            out |= Self::REQUESTED_WRITE_SYNC;
+        }
+        if other.contains(async_filesystem::DescriptorFlags::MUTATE_DIRECTORY) {
+            out |= Self::MUTATE_DIRECTORY;
+        }
+        out
+    }
+}
+
+impl From<async_filesystem::DescriptorType> for sync_filesystem::DescriptorType {
+    fn from(other: async_filesystem::DescriptorType) -> Self {
+        use async_filesystem::DescriptorType;
+        match other {
+            DescriptorType::RegularFile => Self::RegularFile,
+            DescriptorType::Directory => Self::Directory,
+            DescriptorType::BlockDevice => Self::BlockDevice,
+            DescriptorType::CharacterDevice => Self::CharacterDevice,
+            DescriptorType::Fifo => Self::Fifo,
+            DescriptorType::Socket => Self::Socket,
+            DescriptorType::SymbolicLink => Self::SymbolicLink,
+            DescriptorType::Unknown => Self::Unknown,
+        }
+    }
+}
+
+impl From<async_filesystem::DirectoryEntry> for sync_filesystem::DirectoryEntry {
+    fn from(other: async_filesystem::DirectoryEntry) -> Self {
+        Self {
+            type_: other.type_.into(),
+            name: other.name,
+        }
+    }
+}
+
+impl From<async_filesystem::DescriptorStat> for sync_filesystem::DescriptorStat {
+    fn from(other: async_filesystem::DescriptorStat) -> Self {
+        Self {
+            type_: other.type_.into(),
+            link_count: other.link_count,
+            size: other.size,
+            data_access_timestamp: other.data_access_timestamp,
+            data_modification_timestamp: other.data_modification_timestamp,
+            status_change_timestamp: other.status_change_timestamp,
+        }
+    }
+}
+
+impl From<sync_filesystem::PathFlags> for async_filesystem::PathFlags {
+    fn from(other: sync_filesystem::PathFlags) -> Self {
+        let mut out = Self::empty();
+        if other.contains(sync_filesystem::PathFlags::SYMLINK_FOLLOW) {
+            out |= Self::SYMLINK_FOLLOW;
+        }
+        out
+    }
+}
+
+impl From<sync_filesystem::NewTimestamp> for async_filesystem::NewTimestamp {
+    fn from(other: sync_filesystem::NewTimestamp) -> Self {
+        use sync_filesystem::NewTimestamp;
+        match other {
+            NewTimestamp::NoChange => Self::NoChange,
+            NewTimestamp::Now => Self::Now,
+            NewTimestamp::Timestamp(datetime) => Self::Timestamp(datetime),
+        }
+    }
+}
+
+impl From<sync_filesystem::OpenFlags> for async_filesystem::OpenFlags {
+    fn from(other: sync_filesystem::OpenFlags) -> Self {
+        let mut out = Self::empty();
+        if other.contains(sync_filesystem::OpenFlags::CREATE) {
+            out |= Self::CREATE;
+        }
+        if other.contains(sync_filesystem::OpenFlags::DIRECTORY) {
+            out |= Self::DIRECTORY;
+        }
+        if other.contains(sync_filesystem::OpenFlags::EXCLUSIVE) {
+            out |= Self::EXCLUSIVE;
+        }
+        if other.contains(sync_filesystem::OpenFlags::TRUNCATE) {
+            out |= Self::TRUNCATE;
+        }
+        out
+    }
+}
+impl From<sync_filesystem::DescriptorFlags> for async_filesystem::DescriptorFlags {
+    fn from(other: sync_filesystem::DescriptorFlags) -> Self {
+        let mut out = Self::empty();
+        if other.contains(sync_filesystem::DescriptorFlags::READ) {
+            out |= Self::READ;
+        }
+        if other.contains(sync_filesystem::DescriptorFlags::WRITE) {
+            out |= Self::WRITE;
+        }
+        if other.contains(sync_filesystem::DescriptorFlags::FILE_INTEGRITY_SYNC) {
+            out |= Self::FILE_INTEGRITY_SYNC;
+        }
+        if other.contains(sync_filesystem::DescriptorFlags::DATA_INTEGRITY_SYNC) {
+            out |= Self::DATA_INTEGRITY_SYNC;
+        }
+        if other.contains(sync_filesystem::DescriptorFlags::REQUESTED_WRITE_SYNC) {
+            out |= Self::REQUESTED_WRITE_SYNC;
+        }
+        if other.contains(sync_filesystem::DescriptorFlags::MUTATE_DIRECTORY) {
+            out |= Self::MUTATE_DIRECTORY;
+        }
+        out
+    }
+}
+impl From<async_filesystem::MetadataHashValue> for sync_filesystem::MetadataHashValue {
+    fn from(other: async_filesystem::MetadataHashValue) -> Self {
+        Self {
+            lower: other.lower,
+            upper: other.upper,
+        }
+    }
+}
diff --git a/crates/wasi/src/host/instance_network.rs b/crates/wasi/src/host/instance_network.rs
new file mode 100644
index 000000000000..edf097d8679c
--- /dev/null
+++ b/crates/wasi/src/host/instance_network.rs
@@ -0,0 +1,18 @@
+use crate::bindings::sockets::instance_network;
+use crate::network::Network;
+use crate::{WasiImpl, WasiView};
+use wasmtime::component::Resource;
+
+impl<T> instance_network::Host for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn instance_network(&mut self) -> Result<Resource<Network>, anyhow::Error> {
+        let network = Network {
+            socket_addr_check: self.ctx().socket_addr_check.clone(),
+            allow_ip_name_lookup: self.ctx().allowed_network_uses.ip_name_lookup,
+        };
+        let network = self.table().push(network)?;
+        Ok(network)
+    }
+}
diff --git a/crates/wasi/src/host/io.rs b/crates/wasi/src/host/io.rs
new file mode 100644
index 000000000000..b5cecca8132c
--- /dev/null
+++ b/crates/wasi/src/host/io.rs
@@ -0,0 +1,372 @@
+use crate::{
+    bindings::io::error,
+    bindings::io::streams::{self, InputStream, OutputStream},
+    poll::subscribe,
+    Pollable, StreamError, StreamResult, WasiImpl, WasiView,
+};
+use wasmtime::component::Resource;
+
+impl<T> error::Host for WasiImpl<T> where T: WasiView {}
+
+impl<T> streams::Host for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn convert_stream_error(&mut self, err: StreamError) -> anyhow::Result<streams::StreamError> {
+        match err {
+            StreamError::Closed => Ok(streams::StreamError::Closed),
+            StreamError::LastOperationFailed(e) => Ok(streams::StreamError::LastOperationFailed(
+                self.table().push(e)?,
+            )),
+            StreamError::Trap(e) => Err(e),
+        }
+    }
+}
+
+impl<T> error::HostError for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn drop(&mut self, err: Resource<streams::Error>) -> anyhow::Result<()> {
+        self.table().delete(err)?;
+        Ok(())
+    }
+
+    fn to_debug_string(&mut self, err: Resource<streams::Error>) -> anyhow::Result<String> {
+        Ok(format!("{:?}", self.table().get(&err)?))
+    }
+}
+
+#[async_trait::async_trait]
+impl<T> streams::HostOutputStream for WasiImpl<T>
+where
+    T: WasiView,
+{
+    async fn drop(&mut self, stream: Resource<OutputStream>) -> anyhow::Result<()> {
+        self.table().delete(stream)?.cancel().await;
+        Ok(())
+    }
+
+    fn check_write(&mut self, stream: Resource<OutputStream>) -> StreamResult<u64> {
+        let bytes = self.table().get_mut(&stream)?.check_write()?;
+        Ok(bytes as u64)
+    }
+
+    fn write(&mut self, stream: Resource<OutputStream>, bytes: Vec<u8>) -> StreamResult<()> {
+        self.table().get_mut(&stream)?.write(bytes.into())?;
+        Ok(())
+    }
+
+    fn subscribe(&mut self, stream: Resource<OutputStream>) -> anyhow::Result<Resource<Pollable>> {
+        subscribe(self.table(), stream)
+    }
+
+    async fn blocking_write_and_flush(
+        &mut self,
+        stream: Resource<OutputStream>,
+        bytes: Vec<u8>,
+    ) -> StreamResult<()> {
+        if bytes.len() > 4096 {
+            return Err(StreamError::trap(
+                "Buffer too large for blocking-write-and-flush (expected at most 4096)",
+            ));
+        }
+
+        self.table()
+            .get_mut(&stream)?
+            .blocking_write_and_flush(bytes.into())
+            .await
+    }
+
+    async fn blocking_write_zeroes_and_flush(
+        &mut self,
+        stream: Resource<OutputStream>,
+        len: u64,
+    ) -> StreamResult<()> {
+        if len > 4096 {
+            return Err(StreamError::trap(
+                "Buffer too large for blocking-write-zeroes-and-flush (expected at most 4096)",
+            ));
+        }
+
+        self.table()
+            .get_mut(&stream)?
+            .blocking_write_zeroes_and_flush(len as usize)
+            .await
+    }
+
+    fn write_zeroes(&mut self, stream: Resource<OutputStream>, len: u64) -> StreamResult<()> {
+        self.table().get_mut(&stream)?.write_zeroes(len as usize)?;
+        Ok(())
+    }
+
+    fn flush(&mut self, stream: Resource<OutputStream>) -> StreamResult<()> {
+        self.table().get_mut(&stream)?.flush()?;
+        Ok(())
+    }
+
+    async fn blocking_flush(&mut self, stream: Resource<OutputStream>) -> StreamResult<()> {
+        let s = self.table().get_mut(&stream)?;
+        s.flush()?;
+        s.write_ready().await?;
+        Ok(())
+    }
+
+    fn splice(
+        &mut self,
+        dest: Resource<OutputStream>,
+        src: Resource<InputStream>,
+        len: u64,
+    ) -> StreamResult<u64> {
+        let len = len.try_into().unwrap_or(usize::MAX);
+
+        let permit = {
+            let output = self.table().get_mut(&dest)?;
+            output.check_write()?
+        };
+        let len = len.min(permit);
+        if len == 0 {
+            return Ok(0);
+        }
+
+        let contents = self.table().get_mut(&src)?.read(len)?;
+
+        let len = contents.len();
+        if len == 0 {
+            return Ok(0);
+        }
+
+        let output = self.table().get_mut(&dest)?;
+        output.write(contents)?;
+        Ok(len.try_into().expect("usize can fit in u64"))
+    }
+
+    async fn blocking_splice(
+        &mut self,
+        dest: Resource<OutputStream>,
+        src: Resource<InputStream>,
+        len: u64,
+    ) -> StreamResult<u64> {
+        let len = len.try_into().unwrap_or(usize::MAX);
+
+        let permit = {
+            let output = self.table().get_mut(&dest)?;
+            output.write_ready().await?
+        };
+        let len = len.min(permit);
+        if len == 0 {
+            return Ok(0);
+        }
+
+        let contents = self.table().get_mut(&src)?.blocking_read(len).await?;
+
+        let len = contents.len();
+        if len == 0 {
+            return Ok(0);
+        }
+
+        let output = self.table().get_mut(&dest)?;
+        output.blocking_write_and_flush(contents).await?;
+        Ok(len.try_into().expect("usize can fit in u64"))
+    }
+}
+
+#[async_trait::async_trait]
+impl<T> streams::HostInputStream for WasiImpl<T>
+where
+    T: WasiView,
+{
+    async fn drop(&mut self, stream: Resource<InputStream>) -> anyhow::Result<()> {
+        self.table().delete(stream)?.cancel().await;
+        Ok(())
+    }
+
+    fn read(&mut self, stream: Resource<InputStream>, len: u64) -> StreamResult<Vec<u8>> {
+        let len = len.try_into().unwrap_or(usize::MAX);
+        let bytes = self.table().get_mut(&stream)?.read(len)?;
+        debug_assert!(bytes.len() <= len);
+        Ok(bytes.into())
+    }
+
+    async fn blocking_read(
+        &mut self,
+        stream: Resource<InputStream>,
+        len: u64,
+    ) -> StreamResult<Vec<u8>> {
+        let len = len.try_into().unwrap_or(usize::MAX);
+        let bytes = self.table().get_mut(&stream)?.blocking_read(len).await?;
+        debug_assert!(bytes.len() <= len);
+        Ok(bytes.into())
+    }
+
+    fn skip(&mut self, stream: Resource<InputStream>, len: u64) -> StreamResult<u64> {
+        let len = len.try_into().unwrap_or(usize::MAX);
+        let written = self.table().get_mut(&stream)?.skip(len)?;
+        Ok(written.try_into().expect("usize always fits in u64"))
+    }
+
+    async fn blocking_skip(
+        &mut self,
+        stream: Resource<InputStream>,
+        len: u64,
+    ) -> StreamResult<u64> {
+        let len = len.try_into().unwrap_or(usize::MAX);
+        let written = self.table().get_mut(&stream)?.blocking_skip(len).await?;
+        Ok(written.try_into().expect("usize always fits in u64"))
+    }
+
+    fn subscribe(&mut self, stream: Resource<InputStream>) -> anyhow::Result<Resource<Pollable>> {
+        crate::poll::subscribe(self.table(), stream)
+    }
+}
+
+pub mod sync {
+    use crate::{
+        bindings::io::streams::{
+            self as async_streams, Host as AsyncHost, HostInputStream as AsyncHostInputStream,
+            HostOutputStream as AsyncHostOutputStream,
+        },
+        bindings::sync::io::poll::Pollable,
+        bindings::sync::io::streams::{self, InputStream, OutputStream},
+        runtime::in_tokio,
+        StreamError, StreamResult, WasiImpl, WasiView,
+    };
+    use wasmtime::component::Resource;
+
+    impl From<async_streams::StreamError> for streams::StreamError {
+        fn from(other: async_streams::StreamError) -> Self {
+            match other {
+                async_streams::StreamError::LastOperationFailed(e) => Self::LastOperationFailed(e),
+                async_streams::StreamError::Closed => Self::Closed,
+            }
+        }
+    }
+
+    impl<T> streams::Host for WasiImpl<T>
+    where
+        T: WasiView,
+    {
+        fn convert_stream_error(
+            &mut self,
+            err: StreamError,
+        ) -> anyhow::Result<streams::StreamError> {
+            Ok(AsyncHost::convert_stream_error(self, err)?.into())
+        }
+    }
+
+    impl<T> streams::HostOutputStream for WasiImpl<T>
+    where
+        T: WasiView,
+    {
+        fn drop(&mut self, stream: Resource<OutputStream>) -> anyhow::Result<()> {
+            in_tokio(async { AsyncHostOutputStream::drop(self, stream).await })
+        }
+
+        fn check_write(&mut self, stream: Resource<OutputStream>) -> StreamResult<u64> {
+            Ok(AsyncHostOutputStream::check_write(self, stream)?)
+        }
+
+        fn write(&mut self, stream: Resource<OutputStream>, bytes: Vec<u8>) -> StreamResult<()> {
+            Ok(AsyncHostOutputStream::write(self, stream, bytes)?)
+        }
+
+        fn blocking_write_and_flush(
+            &mut self,
+            stream: Resource<OutputStream>,
+            bytes: Vec<u8>,
+        ) -> StreamResult<()> {
+            in_tokio(async {
+                AsyncHostOutputStream::blocking_write_and_flush(self, stream, bytes).await
+            })
+        }
+
+        fn blocking_write_zeroes_and_flush(
+            &mut self,
+            stream: Resource<OutputStream>,
+            len: u64,
+        ) -> StreamResult<()> {
+            in_tokio(async {
+                AsyncHostOutputStream::blocking_write_zeroes_and_flush(self, stream, len).await
+            })
+        }
+
+        fn subscribe(
+            &mut self,
+            stream: Resource<OutputStream>,
+        ) -> anyhow::Result<Resource<Pollable>> {
+            Ok(AsyncHostOutputStream::subscribe(self, stream)?)
+        }
+
+        fn write_zeroes(&mut self, stream: Resource<OutputStream>, len: u64) -> StreamResult<()> {
+            Ok(AsyncHostOutputStream::write_zeroes(self, stream, len)?)
+        }
+
+        fn flush(&mut self, stream: Resource<OutputStream>) -> StreamResult<()> {
+            Ok(AsyncHostOutputStream::flush(
+                self,
+                Resource::new_borrow(stream.rep()),
+            )?)
+        }
+
+        fn blocking_flush(&mut self, stream: Resource<OutputStream>) -> StreamResult<()> {
+            in_tokio(async {
+                AsyncHostOutputStream::blocking_flush(self, Resource::new_borrow(stream.rep()))
+                    .await
+            })
+        }
+
+        fn splice(
+            &mut self,
+            dst: Resource<OutputStream>,
+            src: Resource<InputStream>,
+            len: u64,
+        ) -> StreamResult<u64> {
+            AsyncHostOutputStream::splice(self, dst, src, len)
+        }
+
+        fn blocking_splice(
+            &mut self,
+            dst: Resource<OutputStream>,
+            src: Resource<InputStream>,
+            len: u64,
+        ) -> StreamResult<u64> {
+            in_tokio(async { AsyncHostOutputStream::blocking_splice(self, dst, src, len).await })
+        }
+    }
+
+    impl<T> streams::HostInputStream for WasiImpl<T>
+    where
+        T: WasiView,
+    {
+        fn drop(&mut self, stream: Resource<InputStream>) -> anyhow::Result<()> {
+            in_tokio(async { AsyncHostInputStream::drop(self, stream).await })
+        }
+
+        fn read(&mut self, stream: Resource<InputStream>, len: u64) -> StreamResult<Vec<u8>> {
+            AsyncHostInputStream::read(self, stream, len)
+        }
+
+        fn blocking_read(
+            &mut self,
+            stream: Resource<InputStream>,
+            len: u64,
+        ) -> StreamResult<Vec<u8>> {
+            in_tokio(async { AsyncHostInputStream::blocking_read(self, stream, len).await })
+        }
+
+        fn skip(&mut self, stream: Resource<InputStream>, len: u64) -> StreamResult<u64> {
+            AsyncHostInputStream::skip(self, stream, len)
+        }
+
+        fn blocking_skip(&mut self, stream: Resource<InputStream>, len: u64) -> StreamResult<u64> {
+            in_tokio(async { AsyncHostInputStream::blocking_skip(self, stream, len).await })
+        }
+
+        fn subscribe(
+            &mut self,
+            stream: Resource<InputStream>,
+        ) -> anyhow::Result<Resource<Pollable>> {
+            AsyncHostInputStream::subscribe(self, stream)
+        }
+    }
+}
diff --git a/crates/wasi/src/host/mod.rs b/crates/wasi/src/host/mod.rs
new file mode 100644
index 000000000000..7aa4a8741a9b
--- /dev/null
+++ b/crates/wasi/src/host/mod.rs
@@ -0,0 +1,12 @@
+mod clocks;
+mod env;
+mod exit;
+pub(crate) mod filesystem;
+mod instance_network;
+mod io;
+pub(crate) mod network;
+mod random;
+mod tcp;
+mod tcp_create_socket;
+mod udp;
+mod udp_create_socket;
diff --git a/crates/wasi/src/host/network.rs b/crates/wasi/src/host/network.rs
new file mode 100644
index 000000000000..6772db788ace
--- /dev/null
+++ b/crates/wasi/src/host/network.rs
@@ -0,0 +1,545 @@
+use crate::bindings::sockets::network::{
+    self, ErrorCode, IpAddress, IpAddressFamily, IpSocketAddress, Ipv4SocketAddress,
+    Ipv6SocketAddress,
+};
+use crate::network::{from_ipv4_addr, from_ipv6_addr, to_ipv4_addr, to_ipv6_addr};
+use crate::{SocketError, WasiImpl, WasiView};
+use rustix::io::Errno;
+use std::io;
+use wasmtime::component::Resource;
+
+impl<T> network::Host for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn convert_error_code(&mut self, error: SocketError) -> anyhow::Result<ErrorCode> {
+        error.downcast()
+    }
+}
+
+impl<T> crate::bindings::sockets::network::HostNetwork for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn drop(&mut self, this: Resource<network::Network>) -> Result<(), anyhow::Error> {
+        let table = self.table();
+
+        table.delete(this)?;
+
+        Ok(())
+    }
+}
+
+impl From<io::Error> for ErrorCode {
+    fn from(value: io::Error) -> Self {
+        // Attempt the more detailed native error code first:
+        if let Some(errno) = Errno::from_io_error(&value) {
+            return errno.into();
+        }
+
+        match value.kind() {
+            std::io::ErrorKind::AddrInUse => ErrorCode::AddressInUse,
+            std::io::ErrorKind::AddrNotAvailable => ErrorCode::AddressNotBindable,
+            std::io::ErrorKind::ConnectionAborted => ErrorCode::ConnectionAborted,
+            std::io::ErrorKind::ConnectionRefused => ErrorCode::ConnectionRefused,
+            std::io::ErrorKind::ConnectionReset => ErrorCode::ConnectionReset,
+            std::io::ErrorKind::Interrupted => ErrorCode::WouldBlock,
+            std::io::ErrorKind::InvalidInput => ErrorCode::InvalidArgument,
+            std::io::ErrorKind::NotConnected => ErrorCode::InvalidState,
+            std::io::ErrorKind::OutOfMemory => ErrorCode::OutOfMemory,
+            std::io::ErrorKind::PermissionDenied => ErrorCode::AccessDenied,
+            std::io::ErrorKind::TimedOut => ErrorCode::Timeout,
+            std::io::ErrorKind::Unsupported => ErrorCode::NotSupported,
+            std::io::ErrorKind::WouldBlock => ErrorCode::WouldBlock,
+
+            _ => {
+                tracing::debug!("unknown I/O error: {value}");
+                ErrorCode::Unknown
+            }
+        }
+    }
+}
+
+impl From<Errno> for ErrorCode {
+    fn from(value: Errno) -> Self {
+        match value {
+            Errno::WOULDBLOCK => ErrorCode::WouldBlock,
+            #[allow(unreachable_patterns)] // EWOULDBLOCK and EAGAIN can have the same value.
+            Errno::AGAIN => ErrorCode::WouldBlock,
+            Errno::INTR => ErrorCode::WouldBlock,
+            #[cfg(not(windows))]
+            Errno::PERM => ErrorCode::AccessDenied,
+            Errno::ACCESS => ErrorCode::AccessDenied,
+            Errno::ADDRINUSE => ErrorCode::AddressInUse,
+            Errno::ADDRNOTAVAIL => ErrorCode::AddressNotBindable,
+            Errno::ALREADY => ErrorCode::ConcurrencyConflict,
+            Errno::TIMEDOUT => ErrorCode::Timeout,
+            Errno::CONNREFUSED => ErrorCode::ConnectionRefused,
+            Errno::CONNRESET => ErrorCode::ConnectionReset,
+            Errno::CONNABORTED => ErrorCode::ConnectionAborted,
+            Errno::INVAL => ErrorCode::InvalidArgument,
+            Errno::HOSTUNREACH => ErrorCode::RemoteUnreachable,
+            Errno::HOSTDOWN => ErrorCode::RemoteUnreachable,
+            Errno::NETDOWN => ErrorCode::RemoteUnreachable,
+            Errno::NETUNREACH => ErrorCode::RemoteUnreachable,
+            #[cfg(target_os = "linux")]
+            Errno::NONET => ErrorCode::RemoteUnreachable,
+            Errno::ISCONN => ErrorCode::InvalidState,
+            Errno::NOTCONN => ErrorCode::InvalidState,
+            Errno::DESTADDRREQ => ErrorCode::InvalidState,
+            #[cfg(not(windows))]
+            Errno::NFILE => ErrorCode::NewSocketLimit,
+            Errno::MFILE => ErrorCode::NewSocketLimit,
+            Errno::MSGSIZE => ErrorCode::DatagramTooLarge,
+            #[cfg(not(windows))]
+            Errno::NOMEM => ErrorCode::OutOfMemory,
+            Errno::NOBUFS => ErrorCode::OutOfMemory,
+            Errno::OPNOTSUPP => ErrorCode::NotSupported,
+            Errno::NOPROTOOPT => ErrorCode::NotSupported,
+            Errno::PFNOSUPPORT => ErrorCode::NotSupported,
+            Errno::PROTONOSUPPORT => ErrorCode::NotSupported,
+            Errno::PROTOTYPE => ErrorCode::NotSupported,
+            Errno::SOCKTNOSUPPORT => ErrorCode::NotSupported,
+            Errno::AFNOSUPPORT => ErrorCode::NotSupported,
+
+            // FYI, EINPROGRESS should have already been handled by connect.
+            _ => {
+                tracing::debug!("unknown I/O error: {value}");
+                ErrorCode::Unknown
+            }
+        }
+    }
+}
+
+impl From<std::net::IpAddr> for IpAddress {
+    fn from(addr: std::net::IpAddr) -> Self {
+        match addr {
+            std::net::IpAddr::V4(v4) => Self::Ipv4(from_ipv4_addr(v4)),
+            std::net::IpAddr::V6(v6) => Self::Ipv6(from_ipv6_addr(v6)),
+        }
+    }
+}
+
+impl From<IpSocketAddress> for std::net::SocketAddr {
+    fn from(addr: IpSocketAddress) -> Self {
+        match addr {
+            IpSocketAddress::Ipv4(ipv4) => Self::V4(ipv4.into()),
+            IpSocketAddress::Ipv6(ipv6) => Self::V6(ipv6.into()),
+        }
+    }
+}
+
+impl From<std::net::SocketAddr> for IpSocketAddress {
+    fn from(addr: std::net::SocketAddr) -> Self {
+        match addr {
+            std::net::SocketAddr::V4(v4) => Self::Ipv4(v4.into()),
+            std::net::SocketAddr::V6(v6) => Self::Ipv6(v6.into()),
+        }
+    }
+}
+
+impl From<Ipv4SocketAddress> for std::net::SocketAddrV4 {
+    fn from(addr: Ipv4SocketAddress) -> Self {
+        Self::new(to_ipv4_addr(addr.address), addr.port)
+    }
+}
+
+impl From<std::net::SocketAddrV4> for Ipv4SocketAddress {
+    fn from(addr: std::net::SocketAddrV4) -> Self {
+        Self {
+            address: from_ipv4_addr(*addr.ip()),
+            port: addr.port(),
+        }
+    }
+}
+
+impl From<Ipv6SocketAddress> for std::net::SocketAddrV6 {
+    fn from(addr: Ipv6SocketAddress) -> Self {
+        Self::new(
+            to_ipv6_addr(addr.address),
+            addr.port,
+            addr.flow_info,
+            addr.scope_id,
+        )
+    }
+}
+
+impl From<std::net::SocketAddrV6> for Ipv6SocketAddress {
+    fn from(addr: std::net::SocketAddrV6) -> Self {
+        Self {
+            address: from_ipv6_addr(*addr.ip()),
+            port: addr.port(),
+            flow_info: addr.flowinfo(),
+            scope_id: addr.scope_id(),
+        }
+    }
+}
+
+impl std::net::ToSocketAddrs for IpSocketAddress {
+    type Iter = <std::net::SocketAddr as std::net::ToSocketAddrs>::Iter;
+
+    fn to_socket_addrs(&self) -> io::Result<Self::Iter> {
+        std::net::SocketAddr::from(*self).to_socket_addrs()
+    }
+}
+
+impl std::net::ToSocketAddrs for Ipv4SocketAddress {
+    type Iter = <std::net::SocketAddrV4 as std::net::ToSocketAddrs>::Iter;
+
+    fn to_socket_addrs(&self) -> io::Result<Self::Iter> {
+        std::net::SocketAddrV4::from(*self).to_socket_addrs()
+    }
+}
+
+impl std::net::ToSocketAddrs for Ipv6SocketAddress {
+    type Iter = <std::net::SocketAddrV6 as std::net::ToSocketAddrs>::Iter;
+
+    fn to_socket_addrs(&self) -> io::Result<Self::Iter> {
+        std::net::SocketAddrV6::from(*self).to_socket_addrs()
+    }
+}
+
+impl From<IpAddressFamily> for cap_net_ext::AddressFamily {
+    fn from(family: IpAddressFamily) -> Self {
+        match family {
+            IpAddressFamily::Ipv4 => cap_net_ext::AddressFamily::Ipv4,
+            IpAddressFamily::Ipv6 => cap_net_ext::AddressFamily::Ipv6,
+        }
+    }
+}
+
+impl From<cap_net_ext::AddressFamily> for IpAddressFamily {
+    fn from(family: cap_net_ext::AddressFamily) -> Self {
+        match family {
+            cap_net_ext::AddressFamily::Ipv4 => IpAddressFamily::Ipv4,
+            cap_net_ext::AddressFamily::Ipv6 => IpAddressFamily::Ipv6,
+        }
+    }
+}
+
+pub(crate) mod util {
+    use std::io;
+    use std::net::{IpAddr, Ipv6Addr, SocketAddr};
+    use std::time::Duration;
+
+    use crate::network::SocketAddressFamily;
+    use cap_net_ext::{AddressFamily, Blocking, UdpSocketExt};
+    use rustix::fd::{AsFd, OwnedFd};
+    use rustix::io::Errno;
+    use rustix::net::sockopt;
+
+    pub fn validate_unicast(addr: &SocketAddr) -> io::Result<()> {
+        match to_canonical(&addr.ip()) {
+            IpAddr::V4(ipv4) => {
+                if ipv4.is_multicast() || ipv4.is_broadcast() {
+                    Err(io::Error::new(
+                        io::ErrorKind::InvalidInput,
+                        "Both IPv4 broadcast and multicast addresses are not supported",
+                    ))
+                } else {
+                    Ok(())
+                }
+            }
+            IpAddr::V6(ipv6) => {
+                if ipv6.is_multicast() {
+                    Err(io::Error::new(
+                        io::ErrorKind::InvalidInput,
+                        "IPv6 multicast addresses are not supported",
+                    ))
+                } else {
+                    Ok(())
+                }
+            }
+        }
+    }
+
+    pub fn validate_remote_address(addr: &SocketAddr) -> io::Result<()> {
+        if to_canonical(&addr.ip()).is_unspecified() {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Remote address may not be `0.0.0.0` or `::`",
+            ));
+        }
+
+        if addr.port() == 0 {
+            return Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Remote port may not be 0",
+            ));
+        }
+
+        Ok(())
+    }
+
+    pub fn validate_address_family(
+        addr: &SocketAddr,
+        socket_family: &SocketAddressFamily,
+    ) -> io::Result<()> {
+        match (socket_family, addr.ip()) {
+            (SocketAddressFamily::Ipv4, IpAddr::V4(_)) => Ok(()),
+            (SocketAddressFamily::Ipv6, IpAddr::V6(ipv6)) => {
+                if is_deprecated_ipv4_compatible(&ipv6) {
+                    // Reject IPv4-*compatible* IPv6 addresses. They have been deprecated
+                    // since 2006, OS handling of them is inconsistent and our own
+                    // validations don't take them into account either.
+                    // Note that these are not the same as IPv4-*mapped* IPv6 addresses.
+                    Err(io::Error::new(
+                        io::ErrorKind::InvalidInput,
+                        "IPv4-compatible IPv6 addresses are not supported",
+                    ))
+                } else if ipv6.to_ipv4_mapped().is_some() {
+                    Err(io::Error::new(
+                        io::ErrorKind::InvalidInput,
+                        "IPv4-mapped IPv6 address passed to an IPv6-only socket",
+                    ))
+                } else {
+                    Ok(())
+                }
+            }
+            _ => Err(io::Error::new(
+                io::ErrorKind::InvalidInput,
+                "Address family mismatch",
+            )),
+        }
+    }
+
+    // Can be removed once `IpAddr::to_canonical` becomes stable.
+    pub fn to_canonical(addr: &IpAddr) -> IpAddr {
+        match addr {
+            IpAddr::V4(ipv4) => IpAddr::V4(*ipv4),
+            IpAddr::V6(ipv6) => {
+                if let Some(ipv4) = ipv6.to_ipv4_mapped() {
+                    IpAddr::V4(ipv4)
+                } else {
+                    IpAddr::V6(*ipv6)
+                }
+            }
+        }
+    }
+
+    fn is_deprecated_ipv4_compatible(addr: &Ipv6Addr) -> bool {
+        matches!(addr.segments(), [0, 0, 0, 0, 0, 0, _, _])
+            && *addr != Ipv6Addr::UNSPECIFIED
+            && *addr != Ipv6Addr::LOCALHOST
+    }
+
+    /*
+     * Syscalls wrappers with (opinionated) portability fixes.
+     */
+
+    pub fn udp_socket(family: AddressFamily, blocking: Blocking) -> io::Result<OwnedFd> {
+        // Delegate socket creation to cap_net_ext. They handle a couple of things for us:
+        // - On Windows: call WSAStartup if not done before.
+        // - Set the NONBLOCK and CLOEXEC flags. Either immediately during socket creation,
+        //   or afterwards using ioctl or fcntl. Exact method depends on the platform.
+
+        let socket = cap_std::net::UdpSocket::new(family, blocking)?;
+        Ok(OwnedFd::from(socket))
+    }
+
+    pub fn udp_bind<Fd: AsFd>(sockfd: Fd, addr: &SocketAddr) -> rustix::io::Result<()> {
+        rustix::net::bind(sockfd, addr).map_err(|error| match error {
+            // See: https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-bind#:~:text=WSAENOBUFS
+            // Windows returns WSAENOBUFS when the ephemeral ports have been exhausted.
+            #[cfg(windows)]
+            Errno::NOBUFS => Errno::ADDRINUSE,
+            _ => error,
+        })
+    }
+
+    pub fn udp_disconnect<Fd: AsFd>(sockfd: Fd) -> rustix::io::Result<()> {
+        match rustix::net::connect_unspec(sockfd) {
+            // BSD platforms return an error even if the UDP socket was disconnected successfully.
+            //
+            // MacOS was kind enough to document this: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/connect.2.html
+            // > Datagram sockets may dissolve the association by connecting to an
+            // > invalid address, such as a null address or an address with the address
+            // > family set to AF_UNSPEC (the error EAFNOSUPPORT will be harmlessly
+            // > returned).
+            //
+            // ... except that this appears to be incomplete, because experiments
+            // have shown that MacOS actually returns EINVAL, depending on the
+            // address family of the socket.
+            #[cfg(target_os = "macos")]
+            Err(Errno::INVAL | Errno::AFNOSUPPORT) => Ok(()),
+            r => r,
+        }
+    }
+
+    // Even though SO_REUSEADDR is a SOL_* level option, this function contain a
+    // compatibility fix specific to TCP. That's why it contains the `_tcp_` infix instead of `_socket_`.
+    #[allow(unused_variables)] // Parameters are not used on Windows
+    pub fn set_tcp_reuseaddr<Fd: AsFd>(sockfd: Fd, value: bool) -> rustix::io::Result<()> {
+        // When a TCP socket is closed, the system may
+        // temporarily reserve that specific address+port pair in a so called
+        // TIME_WAIT state. During that period, any attempt to rebind to that pair
+        // will fail. Setting SO_REUSEADDR to true bypasses that behaviour. Unlike
+        // the name "SO_REUSEADDR" might suggest, it does not allow multiple
+        // active sockets to share the same local address.
+
+        // On Windows that behavior is the default, so there is no need to manually
+        // configure such an option. But (!), Windows _does_ have an identically
+        // named socket option which allows users to "hijack" active sockets.
+        // This is definitely not what we want to do here.
+
+        // Microsoft's own documentation[1] states that we should set SO_EXCLUSIVEADDRUSE
+        // instead (to the inverse value), however the github issue below[2] seems
+        // to indicate that that may no longer be correct.
+        // [1]: https://docs.microsoft.com/en-us/windows/win32/winsock/using-so-reuseaddr-and-so-exclusiveaddruse
+        // [2]: https://github.com/python-trio/trio/issues/928
+
+        #[cfg(not(windows))]
+        sockopt::set_socket_reuseaddr(sockfd, value)?;
+
+        Ok(())
+    }
+
+    pub fn set_tcp_keepidle<Fd: AsFd>(sockfd: Fd, value: Duration) -> rustix::io::Result<()> {
+        if value <= Duration::ZERO {
+            // WIT: "If the provided value is 0, an `invalid-argument` error is returned."
+            return Err(Errno::INVAL);
+        }
+
+        // Ensure that the value passed to the actual syscall never gets rounded down to 0.
+        const MIN_SECS: u64 = 1;
+
+        // Cap it at Linux' maximum, which appears to have the lowest limit across our supported platforms.
+        const MAX_SECS: u64 = i16::MAX as u64;
+
+        sockopt::set_tcp_keepidle(
+            sockfd,
+            value.clamp(Duration::from_secs(MIN_SECS), Duration::from_secs(MAX_SECS)),
+        )
+    }
+
+    pub fn set_tcp_keepintvl<Fd: AsFd>(sockfd: Fd, value: Duration) -> rustix::io::Result<()> {
+        if value <= Duration::ZERO {
+            // WIT: "If the provided value is 0, an `invalid-argument` error is returned."
+            return Err(Errno::INVAL);
+        }
+
+        // Ensure that any fractional value passed to the actual syscall never gets rounded down to 0.
+        const MIN_SECS: u64 = 1;
+
+        // Cap it at Linux' maximum, which appears to have the lowest limit across our supported platforms.
+        const MAX_SECS: u64 = i16::MAX as u64;
+
+        sockopt::set_tcp_keepintvl(
+            sockfd,
+            value.clamp(Duration::from_secs(MIN_SECS), Duration::from_secs(MAX_SECS)),
+        )
+    }
+
+    pub fn set_tcp_keepcnt<Fd: AsFd>(sockfd: Fd, value: u32) -> rustix::io::Result<()> {
+        if value == 0 {
+            // WIT: "If the provided value is 0, an `invalid-argument` error is returned."
+            return Err(Errno::INVAL);
+        }
+
+        const MIN_CNT: u32 = 1;
+        // Cap it at Linux' maximum, which appears to have the lowest limit across our supported platforms.
+        const MAX_CNT: u32 = i8::MAX as u32;
+
+        sockopt::set_tcp_keepcnt(sockfd, value.clamp(MIN_CNT, MAX_CNT))
+    }
+
+    pub fn get_ip_ttl<Fd: AsFd>(sockfd: Fd) -> rustix::io::Result<u8> {
+        sockopt::get_ip_ttl(sockfd)?
+            .try_into()
+            .map_err(|_| Errno::OPNOTSUPP)
+    }
+
+    pub fn get_ipv6_unicast_hops<Fd: AsFd>(sockfd: Fd) -> rustix::io::Result<u8> {
+        sockopt::get_ipv6_unicast_hops(sockfd)
+    }
+
+    pub fn set_ip_ttl<Fd: AsFd>(sockfd: Fd, value: u8) -> rustix::io::Result<()> {
+        match value {
+            // WIT: "If the provided value is 0, an `invalid-argument` error is returned."
+            //
+            // A well-behaved IP application should never send out new packets with TTL 0.
+            // We validate the value ourselves because OS'es are not consistent in this.
+            // On Linux the validation is even inconsistent between their IPv4 and IPv6 implementation.
+            0 => Err(Errno::INVAL),
+            _ => sockopt::set_ip_ttl(sockfd, value.into()),
+        }
+    }
+
+    pub fn set_ipv6_unicast_hops<Fd: AsFd>(sockfd: Fd, value: u8) -> rustix::io::Result<()> {
+        match value {
+            0 => Err(Errno::INVAL), // See `set_ip_ttl`
+            _ => sockopt::set_ipv6_unicast_hops(sockfd, Some(value)),
+        }
+    }
+
+    fn normalize_get_buffer_size(value: usize) -> usize {
+        if cfg!(target_os = "linux") {
+            // Linux doubles the value passed to setsockopt to allow space for bookkeeping overhead.
+            // getsockopt returns this internally doubled value.
+            // We'll half the value to at least get it back into the same ballpark that the application requested it in.
+            //
+            // This normalized behavior is tested for in: test-programs/src/bin/preview2_tcp_sockopts.rs
+            value / 2
+        } else {
+            value
+        }
+    }
+
+    fn normalize_set_buffer_size(value: usize) -> usize {
+        value.clamp(1, i32::MAX as usize)
+    }
+
+    pub fn get_socket_recv_buffer_size<Fd: AsFd>(sockfd: Fd) -> rustix::io::Result<usize> {
+        let value = sockopt::get_socket_recv_buffer_size(sockfd)?;
+        Ok(normalize_get_buffer_size(value))
+    }
+
+    pub fn get_socket_send_buffer_size<Fd: AsFd>(sockfd: Fd) -> rustix::io::Result<usize> {
+        let value = sockopt::get_socket_send_buffer_size(sockfd)?;
+        Ok(normalize_get_buffer_size(value))
+    }
+
+    pub fn set_socket_recv_buffer_size<Fd: AsFd>(
+        sockfd: Fd,
+        value: usize,
+    ) -> rustix::io::Result<()> {
+        if value == 0 {
+            // WIT: "If the provided value is 0, an `invalid-argument` error is returned."
+            return Err(Errno::INVAL);
+        }
+
+        let value = normalize_set_buffer_size(value);
+
+        match sockopt::set_socket_recv_buffer_size(sockfd, value) {
+            // Most platforms (Linux, Windows, Fuchsia, Solaris, Illumos, Haiku, ESP-IDF, ..and more?) treat the value
+            // passed to SO_SNDBUF/SO_RCVBUF as a performance tuning hint and silently clamp the input if it exceeds
+            // their capability.
+            // As far as I can see, only the *BSD family views this option as a hard requirement and fails when the
+            // value is out of range. We normalize this behavior in favor of the more commonly understood
+            // "performance hint" semantics. In other words; even ENOBUFS is "Ok".
+            // A future improvement could be to query the corresponding sysctl on *BSD platforms and clamp the input
+            // `size` ourselves, to completely close the gap with other platforms.
+            //
+            // This normalized behavior is tested for in: test-programs/src/bin/preview2_tcp_sockopts.rs
+            Err(Errno::NOBUFS) => Ok(()),
+            r => r,
+        }
+    }
+
+    pub fn set_socket_send_buffer_size<Fd: AsFd>(
+        sockfd: Fd,
+        value: usize,
+    ) -> rustix::io::Result<()> {
+        if value == 0 {
+            // WIT: "If the provided value is 0, an `invalid-argument` error is returned."
+            return Err(Errno::INVAL);
+        }
+
+        let value = normalize_set_buffer_size(value);
+
+        match sockopt::set_socket_send_buffer_size(sockfd, value) {
+            Err(Errno::NOBUFS) => Ok(()), // See set_socket_recv_buffer_size
+            r => r,
+        }
+    }
+}
diff --git a/crates/wasi/src/host/random.rs b/crates/wasi/src/host/random.rs
new file mode 100644
index 000000000000..a3fe59487d3f
--- /dev/null
+++ b/crates/wasi/src/host/random.rs
@@ -0,0 +1,45 @@
+use crate::bindings::random::{insecure, insecure_seed, random};
+use crate::{WasiImpl, WasiView};
+use cap_rand::{distributions::Standard, Rng};
+
+impl<T> random::Host for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn get_random_bytes(&mut self, len: u64) -> anyhow::Result<Vec<u8>> {
+        Ok((&mut self.ctx().random)
+            .sample_iter(Standard)
+            .take(len as usize)
+            .collect())
+    }
+
+    fn get_random_u64(&mut self) -> anyhow::Result<u64> {
+        Ok(self.ctx().random.sample(Standard))
+    }
+}
+
+impl<T> insecure::Host for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn get_insecure_random_bytes(&mut self, len: u64) -> anyhow::Result<Vec<u8>> {
+        Ok((&mut self.ctx().insecure_random)
+            .sample_iter(Standard)
+            .take(len as usize)
+            .collect())
+    }
+
+    fn get_insecure_random_u64(&mut self) -> anyhow::Result<u64> {
+        Ok(self.ctx().insecure_random.sample(Standard))
+    }
+}
+
+impl<T> insecure_seed::Host for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn insecure_seed(&mut self) -> anyhow::Result<(u64, u64)> {
+        let seed: u128 = self.ctx().insecure_random_seed;
+        Ok((seed as u64, (seed >> 64) as u64))
+    }
+}
diff --git a/crates/wasi/src/host/tcp.rs b/crates/wasi/src/host/tcp.rs
new file mode 100644
index 000000000000..2f20cdc2590e
--- /dev/null
+++ b/crates/wasi/src/host/tcp.rs
@@ -0,0 +1,547 @@
+use crate::network::SocketAddrUse;
+use crate::{
+    bindings::{
+        io::streams::{InputStream, OutputStream},
+        sockets::network::{IpAddressFamily, IpSocketAddress, Network},
+        sockets::tcp::{self, ShutdownType},
+    },
+    network::SocketAddressFamily,
+};
+use crate::{Pollable, SocketResult, WasiImpl, WasiView};
+use std::net::SocketAddr;
+use std::time::Duration;
+use wasmtime::component::Resource;
+
+impl<T> tcp::Host for WasiImpl<T> where T: WasiView {}
+
+#[async_trait::async_trait]
+impl<T> crate::host::tcp::tcp::HostTcpSocket for WasiImpl<T>
+where
+    T: WasiView,
+{
+    async fn start_bind(
+        &mut self,
+        this: Resource<tcp::TcpSocket>,
+        network: Resource<Network>,
+        local_address: IpSocketAddress,
+    ) -> SocketResult<()> {
+        self.ctx().allowed_network_uses.check_allowed_tcp()?;
+        let table = self.table();
+        let network = table.get(&network)?;
+        let local_address: SocketAddr = local_address.into();
+
+        // Ensure that we're allowed to connect to this address.
+        network
+            .check_socket_addr(local_address, SocketAddrUse::TcpBind)
+            .await?;
+
+        // Bind to the address.
+        table.get_mut(&this)?.start_bind(local_address)?;
+
+        Ok(())
+    }
+
+    fn finish_bind(&mut self, this: Resource<tcp::TcpSocket>) -> SocketResult<()> {
+        let table = self.table();
+        let socket = table.get_mut(&this)?;
+
+        socket.finish_bind()
+    }
+
+    async fn start_connect(
+        &mut self,
+        this: Resource<tcp::TcpSocket>,
+        network: Resource<Network>,
+        remote_address: IpSocketAddress,
+    ) -> SocketResult<()> {
+        self.ctx().allowed_network_uses.check_allowed_tcp()?;
+        let table = self.table();
+        let network = table.get(&network)?;
+        let remote_address: SocketAddr = remote_address.into();
+
+        // Ensure that we're allowed to connect to this address.
+        network
+            .check_socket_addr(remote_address, SocketAddrUse::TcpConnect)
+            .await?;
+
+        // Start connection
+        table.get_mut(&this)?.start_connect(remote_address)?;
+
+        Ok(())
+    }
+
+    fn finish_connect(
+        &mut self,
+        this: Resource<tcp::TcpSocket>,
+    ) -> SocketResult<(Resource<InputStream>, Resource<OutputStream>)> {
+        let table = self.table();
+        let socket = table.get_mut(&this)?;
+
+        let (input, output) = socket.finish_connect()?;
+
+        let input_stream = self.table().push_child(input, &this)?;
+        let output_stream = self.table().push_child(output, &this)?;
+
+        Ok((input_stream, output_stream))
+    }
+
+    fn start_listen(&mut self, this: Resource<tcp::TcpSocket>) -> SocketResult<()> {
+        self.ctx().allowed_network_uses.check_allowed_tcp()?;
+        let table = self.table();
+        let socket = table.get_mut(&this)?;
+
+        socket.start_listen()
+    }
+
+    fn finish_listen(&mut self, this: Resource<tcp::TcpSocket>) -> SocketResult<()> {
+        let table = self.table();
+        let socket = table.get_mut(&this)?;
+        socket.finish_listen()
+    }
+
+    fn accept(
+        &mut self,
+        this: Resource<tcp::TcpSocket>,
+    ) -> SocketResult<(
+        Resource<tcp::TcpSocket>,
+        Resource<InputStream>,
+        Resource<OutputStream>,
+    )> {
+        self.ctx().allowed_network_uses.check_allowed_tcp()?;
+        let table = self.table();
+        let socket = table.get_mut(&this)?;
+
+        let (tcp_socket, input, output) = socket.accept()?;
+
+        let tcp_socket = self.table().push(tcp_socket)?;
+        let input_stream = self.table().push_child(input, &tcp_socket)?;
+        let output_stream = self.table().push_child(output, &tcp_socket)?;
+
+        Ok((tcp_socket, input_stream, output_stream))
+    }
+
+    fn local_address(&mut self, this: Resource<tcp::TcpSocket>) -> SocketResult<IpSocketAddress> {
+        let table = self.table();
+        let socket = table.get(&this)?;
+
+        socket.local_address().map(Into::into)
+    }
+
+    fn remote_address(&mut self, this: Resource<tcp::TcpSocket>) -> SocketResult<IpSocketAddress> {
+        let table = self.table();
+        let socket = table.get(&this)?;
+
+        socket.remote_address().map(Into::into)
+    }
+
+    fn is_listening(&mut self, this: Resource<tcp::TcpSocket>) -> Result<bool, anyhow::Error> {
+        let table = self.table();
+        let socket = table.get(&this)?;
+
+        Ok(socket.is_listening())
+    }
+
+    fn address_family(
+        &mut self,
+        this: Resource<tcp::TcpSocket>,
+    ) -> Result<IpAddressFamily, anyhow::Error> {
+        let table = self.table();
+        let socket = table.get(&this)?;
+
+        match socket.address_family() {
+            SocketAddressFamily::Ipv4 => Ok(IpAddressFamily::Ipv4),
+            SocketAddressFamily::Ipv6 => Ok(IpAddressFamily::Ipv6),
+        }
+    }
+
+    fn set_listen_backlog_size(
+        &mut self,
+        this: Resource<tcp::TcpSocket>,
+        value: u64,
+    ) -> SocketResult<()> {
+        let table = self.table();
+        let socket = table.get_mut(&this)?;
+
+        // Silently clamp backlog size. This is OK for us to do, because operating systems do this too.
+        let value = value.try_into().unwrap_or(u32::MAX);
+
+        socket.set_listen_backlog_size(value)
+    }
+
+    fn keep_alive_enabled(&mut self, this: Resource<tcp::TcpSocket>) -> SocketResult<bool> {
+        let table = self.table();
+        let socket = table.get(&this)?;
+        socket.keep_alive_enabled()
+    }
+
+    fn set_keep_alive_enabled(
+        &mut self,
+        this: Resource<tcp::TcpSocket>,
+        value: bool,
+    ) -> SocketResult<()> {
+        let table = self.table();
+        let socket = table.get(&this)?;
+        socket.set_keep_alive_enabled(value)
+    }
+
+    fn keep_alive_idle_time(&mut self, this: Resource<tcp::TcpSocket>) -> SocketResult<u64> {
+        let table = self.table();
+        let socket = table.get(&this)?;
+        Ok(socket.keep_alive_idle_time()?.as_nanos() as u64)
+    }
+
+    fn set_keep_alive_idle_time(
+        &mut self,
+        this: Resource<tcp::TcpSocket>,
+        value: u64,
+    ) -> SocketResult<()> {
+        let table = self.table();
+        let socket = table.get_mut(&this)?;
+        let duration = Duration::from_nanos(value);
+        socket.set_keep_alive_idle_time(duration)
+    }
+
+    fn keep_alive_interval(&mut self, this: Resource<tcp::TcpSocket>) -> SocketResult<u64> {
+        let table = self.table();
+        let socket = table.get(&this)?;
+        Ok(socket.keep_alive_interval()?.as_nanos() as u64)
+    }
+
+    fn set_keep_alive_interval(
+        &mut self,
+        this: Resource<tcp::TcpSocket>,
+        value: u64,
+    ) -> SocketResult<()> {
+        let table = self.table();
+        let socket = table.get(&this)?;
+        socket.set_keep_alive_interval(Duration::from_nanos(value))
+    }
+
+    fn keep_alive_count(&mut self, this: Resource<tcp::TcpSocket>) -> SocketResult<u32> {
+        let table = self.table();
+        let socket = table.get(&this)?;
+        socket.keep_alive_count()
+    }
+
+    fn set_keep_alive_count(
+        &mut self,
+        this: Resource<tcp::TcpSocket>,
+        value: u32,
+    ) -> SocketResult<()> {
+        let table = self.table();
+        let socket = table.get(&this)?;
+        socket.set_keep_alive_count(value)
+    }
+
+    fn hop_limit(&mut self, this: Resource<tcp::TcpSocket>) -> SocketResult<u8> {
+        let table = self.table();
+        let socket = table.get(&this)?;
+        socket.hop_limit()
+    }
+
+    fn set_hop_limit(&mut self, this: Resource<tcp::TcpSocket>, value: u8) -> SocketResult<()> {
+        let table = self.table();
+        let socket = table.get_mut(&this)?;
+        socket.set_hop_limit(value)
+    }
+
+    fn receive_buffer_size(&mut self, this: Resource<tcp::TcpSocket>) -> SocketResult<u64> {
+        let table = self.table();
+        let socket = table.get(&this)?;
+
+        Ok(socket.receive_buffer_size()? as u64)
+    }
+
+    fn set_receive_buffer_size(
+        &mut self,
+        this: Resource<tcp::TcpSocket>,
+        value: u64,
+    ) -> SocketResult<()> {
+        let table = self.table();
+        let socket = table.get_mut(&this)?;
+        let value = value.try_into().unwrap_or(usize::MAX);
+        socket.set_receive_buffer_size(value)
+    }
+
+    fn send_buffer_size(&mut self, this: Resource<tcp::TcpSocket>) -> SocketResult<u64> {
+        let table = self.table();
+        let socket = table.get(&this)?;
+
+        Ok(socket.send_buffer_size()? as u64)
+    }
+
+    fn set_send_buffer_size(
+        &mut self,
+        this: Resource<tcp::TcpSocket>,
+        value: u64,
+    ) -> SocketResult<()> {
+        let table = self.table();
+        let socket = table.get_mut(&this)?;
+        let value = value.try_into().unwrap_or(usize::MAX);
+        socket.set_send_buffer_size(value)
+    }
+
+    fn subscribe(&mut self, this: Resource<tcp::TcpSocket>) -> anyhow::Result<Resource<Pollable>> {
+        crate::poll::subscribe(self.table(), this)
+    }
+
+    fn shutdown(
+        &mut self,
+        this: Resource<tcp::TcpSocket>,
+        shutdown_type: ShutdownType,
+    ) -> SocketResult<()> {
+        let table = self.table();
+        let socket = table.get(&this)?;
+
+        let how = match shutdown_type {
+            ShutdownType::Receive => std::net::Shutdown::Read,
+            ShutdownType::Send => std::net::Shutdown::Write,
+            ShutdownType::Both => std::net::Shutdown::Both,
+        };
+        Ok(socket.shutdown(how)?)
+    }
+
+    fn drop(&mut self, this: Resource<tcp::TcpSocket>) -> Result<(), anyhow::Error> {
+        let table = self.table();
+
+        // As in the filesystem implementation, we assume closing a socket
+        // doesn't block.
+        let dropped = table.delete(this)?;
+        drop(dropped);
+
+        Ok(())
+    }
+}
+
+pub mod sync {
+    use wasmtime::component::Resource;
+
+    use crate::{
+        bindings::{
+            sockets::{
+                network::Network,
+                tcp::{self as async_tcp, HostTcpSocket as AsyncHostTcpSocket},
+            },
+            sync::sockets::tcp::{
+                self, Duration, HostTcpSocket, InputStream, IpAddressFamily, IpSocketAddress,
+                OutputStream, Pollable, ShutdownType, TcpSocket,
+            },
+        },
+        runtime::in_tokio,
+        SocketError, WasiImpl, WasiView,
+    };
+
+    impl<T> tcp::Host for WasiImpl<T> where T: WasiView {}
+
+    impl<T> HostTcpSocket for WasiImpl<T>
+    where
+        T: WasiView,
+    {
+        fn start_bind(
+            &mut self,
+            self_: Resource<TcpSocket>,
+            network: Resource<Network>,
+            local_address: IpSocketAddress,
+        ) -> Result<(), SocketError> {
+            in_tokio(async {
+                AsyncHostTcpSocket::start_bind(self, self_, network, local_address).await
+            })
+        }
+
+        fn finish_bind(&mut self, self_: Resource<TcpSocket>) -> Result<(), SocketError> {
+            AsyncHostTcpSocket::finish_bind(self, self_)
+        }
+
+        fn start_connect(
+            &mut self,
+            self_: Resource<TcpSocket>,
+            network: Resource<Network>,
+            remote_address: IpSocketAddress,
+        ) -> Result<(), SocketError> {
+            in_tokio(async {
+                AsyncHostTcpSocket::start_connect(self, self_, network, remote_address).await
+            })
+        }
+
+        fn finish_connect(
+            &mut self,
+            self_: Resource<TcpSocket>,
+        ) -> Result<(Resource<InputStream>, Resource<OutputStream>), SocketError> {
+            AsyncHostTcpSocket::finish_connect(self, self_)
+        }
+
+        fn start_listen(&mut self, self_: Resource<TcpSocket>) -> Result<(), SocketError> {
+            AsyncHostTcpSocket::start_listen(self, self_)
+        }
+
+        fn finish_listen(&mut self, self_: Resource<TcpSocket>) -> Result<(), SocketError> {
+            AsyncHostTcpSocket::finish_listen(self, self_)
+        }
+
+        fn accept(
+            &mut self,
+            self_: Resource<TcpSocket>,
+        ) -> Result<
+            (
+                Resource<TcpSocket>,
+                Resource<InputStream>,
+                Resource<OutputStream>,
+            ),
+            SocketError,
+        > {
+            AsyncHostTcpSocket::accept(self, self_)
+        }
+
+        fn local_address(
+            &mut self,
+            self_: Resource<TcpSocket>,
+        ) -> Result<IpSocketAddress, SocketError> {
+            AsyncHostTcpSocket::local_address(self, self_)
+        }
+
+        fn remote_address(
+            &mut self,
+            self_: Resource<TcpSocket>,
+        ) -> Result<IpSocketAddress, SocketError> {
+            AsyncHostTcpSocket::remote_address(self, self_)
+        }
+
+        fn is_listening(&mut self, self_: Resource<TcpSocket>) -> wasmtime::Result<bool> {
+            AsyncHostTcpSocket::is_listening(self, self_)
+        }
+
+        fn address_family(
+            &mut self,
+            self_: Resource<TcpSocket>,
+        ) -> wasmtime::Result<IpAddressFamily> {
+            AsyncHostTcpSocket::address_family(self, self_)
+        }
+
+        fn set_listen_backlog_size(
+            &mut self,
+            self_: Resource<TcpSocket>,
+            value: u64,
+        ) -> Result<(), SocketError> {
+            AsyncHostTcpSocket::set_listen_backlog_size(self, self_, value)
+        }
+
+        fn keep_alive_enabled(&mut self, self_: Resource<TcpSocket>) -> Result<bool, SocketError> {
+            AsyncHostTcpSocket::keep_alive_enabled(self, self_)
+        }
+
+        fn set_keep_alive_enabled(
+            &mut self,
+            self_: Resource<TcpSocket>,
+            value: bool,
+        ) -> Result<(), SocketError> {
+            AsyncHostTcpSocket::set_keep_alive_enabled(self, self_, value)
+        }
+
+        fn keep_alive_idle_time(
+            &mut self,
+            self_: Resource<TcpSocket>,
+        ) -> Result<Duration, SocketError> {
+            AsyncHostTcpSocket::keep_alive_idle_time(self, self_)
+        }
+
+        fn set_keep_alive_idle_time(
+            &mut self,
+            self_: Resource<TcpSocket>,
+            value: Duration,
+        ) -> Result<(), SocketError> {
+            AsyncHostTcpSocket::set_keep_alive_idle_time(self, self_, value)
+        }
+
+        fn keep_alive_interval(
+            &mut self,
+            self_: Resource<TcpSocket>,
+        ) -> Result<Duration, SocketError> {
+            AsyncHostTcpSocket::keep_alive_interval(self, self_)
+        }
+
+        fn set_keep_alive_interval(
+            &mut self,
+            self_: Resource<TcpSocket>,
+            value: Duration,
+        ) -> Result<(), SocketError> {
+            AsyncHostTcpSocket::set_keep_alive_interval(self, self_, value)
+        }
+
+        fn keep_alive_count(&mut self, self_: Resource<TcpSocket>) -> Result<u32, SocketError> {
+            AsyncHostTcpSocket::keep_alive_count(self, self_)
+        }
+
+        fn set_keep_alive_count(
+            &mut self,
+            self_: Resource<TcpSocket>,
+            value: u32,
+        ) -> Result<(), SocketError> {
+            AsyncHostTcpSocket::set_keep_alive_count(self, self_, value)
+        }
+
+        fn hop_limit(&mut self, self_: Resource<TcpSocket>) -> Result<u8, SocketError> {
+            AsyncHostTcpSocket::hop_limit(self, self_)
+        }
+
+        fn set_hop_limit(
+            &mut self,
+            self_: Resource<TcpSocket>,
+            value: u8,
+        ) -> Result<(), SocketError> {
+            AsyncHostTcpSocket::set_hop_limit(self, self_, value)
+        }
+
+        fn receive_buffer_size(&mut self, self_: Resource<TcpSocket>) -> Result<u64, SocketError> {
+            AsyncHostTcpSocket::receive_buffer_size(self, self_)
+        }
+
+        fn set_receive_buffer_size(
+            &mut self,
+            self_: Resource<TcpSocket>,
+            value: u64,
+        ) -> Result<(), SocketError> {
+            AsyncHostTcpSocket::set_receive_buffer_size(self, self_, value)
+        }
+
+        fn send_buffer_size(&mut self, self_: Resource<TcpSocket>) -> Result<u64, SocketError> {
+            AsyncHostTcpSocket::send_buffer_size(self, self_)
+        }
+
+        fn set_send_buffer_size(
+            &mut self,
+            self_: Resource<TcpSocket>,
+            value: u64,
+        ) -> Result<(), SocketError> {
+            AsyncHostTcpSocket::set_send_buffer_size(self, self_, value)
+        }
+
+        fn subscribe(
+            &mut self,
+            self_: Resource<TcpSocket>,
+        ) -> wasmtime::Result<Resource<Pollable>> {
+            AsyncHostTcpSocket::subscribe(self, self_)
+        }
+
+        fn shutdown(
+            &mut self,
+            self_: Resource<TcpSocket>,
+            shutdown_type: ShutdownType,
+        ) -> Result<(), SocketError> {
+            AsyncHostTcpSocket::shutdown(self, self_, shutdown_type.into())
+        }
+
+        fn drop(&mut self, rep: Resource<TcpSocket>) -> wasmtime::Result<()> {
+            AsyncHostTcpSocket::drop(self, rep)
+        }
+    }
+
+    impl From<ShutdownType> for async_tcp::ShutdownType {
+        fn from(other: ShutdownType) -> Self {
+            match other {
+                ShutdownType::Receive => async_tcp::ShutdownType::Receive,
+                ShutdownType::Send => async_tcp::ShutdownType::Send,
+                ShutdownType::Both => async_tcp::ShutdownType::Both,
+            }
+        }
+    }
+}
diff --git a/crates/wasi/src/host/tcp_create_socket.rs b/crates/wasi/src/host/tcp_create_socket.rs
new file mode 100644
index 000000000000..eadacce05b58
--- /dev/null
+++ b/crates/wasi/src/host/tcp_create_socket.rs
@@ -0,0 +1,18 @@
+use crate::bindings::{sockets::network::IpAddressFamily, sockets::tcp_create_socket};
+use crate::tcp::TcpSocket;
+use crate::{SocketResult, WasiImpl, WasiView};
+use wasmtime::component::Resource;
+
+impl<T> tcp_create_socket::Host for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn create_tcp_socket(
+        &mut self,
+        address_family: IpAddressFamily,
+    ) -> SocketResult<Resource<TcpSocket>> {
+        let socket = TcpSocket::new(address_family.into())?;
+        let socket = self.table().push(socket)?;
+        Ok(socket)
+    }
+}
diff --git a/crates/wasi/src/host/udp.rs b/crates/wasi/src/host/udp.rs
new file mode 100644
index 000000000000..d1ea5d204b6b
--- /dev/null
+++ b/crates/wasi/src/host/udp.rs
@@ -0,0 +1,762 @@
+use crate::host::network::util;
+use crate::network::{SocketAddrUse, SocketAddressFamily};
+use crate::{
+    bindings::{
+        sockets::network::{ErrorCode, IpAddressFamily, IpSocketAddress, Network},
+        sockets::udp,
+    },
+    udp::{IncomingDatagramStream, OutgoingDatagramStream, SendState, UdpState},
+    Subscribe,
+};
+use crate::{Pollable, SocketError, SocketResult, WasiImpl, WasiView};
+use anyhow::anyhow;
+use async_trait::async_trait;
+use io_lifetimes::AsSocketlike;
+use rustix::io::Errno;
+use std::net::SocketAddr;
+use tokio::io::Interest;
+use wasmtime::component::Resource;
+
+/// Theoretical maximum byte size of a UDP datagram, the real limit is lower,
+/// but we do not account for e.g. the transport layer here for simplicity.
+/// In practice, datagrams are typically less than 1500 bytes.
+const MAX_UDP_DATAGRAM_SIZE: usize = u16::MAX as usize;
+
+impl<T> udp::Host for WasiImpl<T> where T: WasiView {}
+
+#[async_trait::async_trait]
+impl<T> udp::HostUdpSocket for WasiImpl<T>
+where
+    T: WasiView,
+{
+    async fn start_bind(
+        &mut self,
+        this: Resource<udp::UdpSocket>,
+        network: Resource<Network>,
+        local_address: IpSocketAddress,
+    ) -> SocketResult<()> {
+        self.ctx().allowed_network_uses.check_allowed_udp()?;
+        let table = self.table();
+
+        match table.get(&this)?.udp_state {
+            UdpState::Default => {}
+            UdpState::BindStarted => return Err(ErrorCode::ConcurrencyConflict.into()),
+            UdpState::Bound | UdpState::Connected => return Err(ErrorCode::InvalidState.into()),
+        }
+
+        // Set the socket addr check on the socket so later functions have access to it through the socket handle
+        let check = table.get(&network)?.socket_addr_check.clone();
+        table
+            .get_mut(&this)?
+            .socket_addr_check
+            .replace(check.clone());
+
+        let socket = table.get(&this)?;
+        let local_address: SocketAddr = local_address.into();
+
+        util::validate_address_family(&local_address, &socket.family)?;
+
+        {
+            check.check(local_address, SocketAddrUse::UdpBind).await?;
+
+            // Perform the OS bind call.
+            util::udp_bind(socket.udp_socket(), &local_address).map_err(|error| match error {
+                // From https://pubs.opengroup.org/onlinepubs/9699919799/functions/bind.html:
+                // > [EAFNOSUPPORT] The specified address is not a valid address for the address family of the specified socket
+                //
+                // The most common reasons for this error should have already
+                // been handled by our own validation slightly higher up in this
+                // function. This error mapping is here just in case there is
+                // an edge case we didn't catch.
+                Errno::AFNOSUPPORT => ErrorCode::InvalidArgument,
+                _ => ErrorCode::from(error),
+            })?;
+        }
+
+        let socket = table.get_mut(&this)?;
+        socket.udp_state = UdpState::BindStarted;
+
+        Ok(())
+    }
+
+    fn finish_bind(&mut self, this: Resource<udp::UdpSocket>) -> SocketResult<()> {
+        let table = self.table();
+        let socket = table.get_mut(&this)?;
+
+        match socket.udp_state {
+            UdpState::BindStarted => {
+                socket.udp_state = UdpState::Bound;
+                Ok(())
+            }
+            _ => Err(ErrorCode::NotInProgress.into()),
+        }
+    }
+
+    async fn stream(
+        &mut self,
+        this: Resource<udp::UdpSocket>,
+        remote_address: Option<IpSocketAddress>,
+    ) -> SocketResult<(
+        Resource<udp::IncomingDatagramStream>,
+        Resource<udp::OutgoingDatagramStream>,
+    )> {
+        let table = self.table();
+
+        let has_active_streams = table
+            .iter_children(&this)?
+            .any(|c| c.is::<IncomingDatagramStream>() || c.is::<OutgoingDatagramStream>());
+
+        if has_active_streams {
+            return Err(SocketError::trap(anyhow!("UDP streams not dropped yet")));
+        }
+
+        let socket = table.get_mut(&this)?;
+        let remote_address = remote_address.map(SocketAddr::from);
+
+        match socket.udp_state {
+            UdpState::Bound | UdpState::Connected => {}
+            _ => return Err(ErrorCode::InvalidState.into()),
+        }
+
+        // We disconnect & (re)connect in two distinct steps for two reasons:
+        // - To leave our socket instance in a consistent state in case the
+        //   connect fails.
+        // - When reconnecting to a different address, Linux sometimes fails
+        //   if there isn't a disconnect in between.
+
+        // Step #1: Disconnect
+        if let UdpState::Connected = socket.udp_state {
+            util::udp_disconnect(socket.udp_socket())?;
+            socket.udp_state = UdpState::Bound;
+        }
+
+        // Step #2: (Re)connect
+        if let Some(connect_addr) = remote_address {
+            let Some(check) = socket.socket_addr_check.as_ref() else {
+                return Err(ErrorCode::InvalidState.into());
+            };
+            util::validate_remote_address(&connect_addr)?;
+            util::validate_address_family(&connect_addr, &socket.family)?;
+            check.check(connect_addr, SocketAddrUse::UdpConnect).await?;
+
+            rustix::net::connect(socket.udp_socket(), &connect_addr).map_err(
+                |error| match error {
+                    Errno::AFNOSUPPORT => ErrorCode::InvalidArgument, // See `bind` implementation.
+                    Errno::INPROGRESS => {
+                        tracing::debug!(
+                            "UDP connect returned EINPROGRESS, which should never happen"
+                        );
+                        ErrorCode::Unknown
+                    }
+                    _ => ErrorCode::from(error),
+                },
+            )?;
+            socket.udp_state = UdpState::Connected;
+        }
+
+        let incoming_stream = IncomingDatagramStream {
+            inner: socket.inner.clone(),
+            remote_address,
+        };
+        let outgoing_stream = OutgoingDatagramStream {
+            inner: socket.inner.clone(),
+            remote_address,
+            family: socket.family,
+            send_state: SendState::Idle,
+            socket_addr_check: socket.socket_addr_check.clone(),
+        };
+
+        Ok((
+            self.table().push_child(incoming_stream, &this)?,
+            self.table().push_child(outgoing_stream, &this)?,
+        ))
+    }
+
+    fn local_address(&mut self, this: Resource<udp::UdpSocket>) -> SocketResult<IpSocketAddress> {
+        let table = self.table();
+        let socket = table.get(&this)?;
+
+        match socket.udp_state {
+            UdpState::Default => return Err(ErrorCode::InvalidState.into()),
+            UdpState::BindStarted => return Err(ErrorCode::ConcurrencyConflict.into()),
+            _ => {}
+        }
+
+        let addr = socket
+            .udp_socket()
+            .as_socketlike_view::<std::net::UdpSocket>()
+            .local_addr()?;
+        Ok(addr.into())
+    }
+
+    fn remote_address(&mut self, this: Resource<udp::UdpSocket>) -> SocketResult<IpSocketAddress> {
+        let table = self.table();
+        let socket = table.get(&this)?;
+
+        match socket.udp_state {
+            UdpState::Connected => {}
+            _ => return Err(ErrorCode::InvalidState.into()),
+        }
+
+        let addr = socket
+            .udp_socket()
+            .as_socketlike_view::<std::net::UdpSocket>()
+            .peer_addr()?;
+        Ok(addr.into())
+    }
+
+    fn address_family(
+        &mut self,
+        this: Resource<udp::UdpSocket>,
+    ) -> Result<IpAddressFamily, anyhow::Error> {
+        let table = self.table();
+        let socket = table.get(&this)?;
+
+        match socket.family {
+            SocketAddressFamily::Ipv4 => Ok(IpAddressFamily::Ipv4),
+            SocketAddressFamily::Ipv6 => Ok(IpAddressFamily::Ipv6),
+        }
+    }
+
+    fn unicast_hop_limit(&mut self, this: Resource<udp::UdpSocket>) -> SocketResult<u8> {
+        let table = self.table();
+        let socket = table.get(&this)?;
+
+        let ttl = match socket.family {
+            SocketAddressFamily::Ipv4 => util::get_ip_ttl(socket.udp_socket())?,
+            SocketAddressFamily::Ipv6 => util::get_ipv6_unicast_hops(socket.udp_socket())?,
+        };
+
+        Ok(ttl)
+    }
+
+    fn set_unicast_hop_limit(
+        &mut self,
+        this: Resource<udp::UdpSocket>,
+        value: u8,
+    ) -> SocketResult<()> {
+        let table = self.table();
+        let socket = table.get(&this)?;
+
+        match socket.family {
+            SocketAddressFamily::Ipv4 => util::set_ip_ttl(socket.udp_socket(), value)?,
+            SocketAddressFamily::Ipv6 => util::set_ipv6_unicast_hops(socket.udp_socket(), value)?,
+        }
+
+        Ok(())
+    }
+
+    fn receive_buffer_size(&mut self, this: Resource<udp::UdpSocket>) -> SocketResult<u64> {
+        let table = self.table();
+        let socket = table.get(&this)?;
+
+        let value = util::get_socket_recv_buffer_size(socket.udp_socket())?;
+        Ok(value as u64)
+    }
+
+    fn set_receive_buffer_size(
+        &mut self,
+        this: Resource<udp::UdpSocket>,
+        value: u64,
+    ) -> SocketResult<()> {
+        let table = self.table();
+        let socket = table.get(&this)?;
+        let value = value.try_into().unwrap_or(usize::MAX);
+
+        util::set_socket_recv_buffer_size(socket.udp_socket(), value)?;
+        Ok(())
+    }
+
+    fn send_buffer_size(&mut self, this: Resource<udp::UdpSocket>) -> SocketResult<u64> {
+        let table = self.table();
+        let socket = table.get(&this)?;
+
+        let value = util::get_socket_send_buffer_size(socket.udp_socket())?;
+        Ok(value as u64)
+    }
+
+    fn set_send_buffer_size(
+        &mut self,
+        this: Resource<udp::UdpSocket>,
+        value: u64,
+    ) -> SocketResult<()> {
+        let table = self.table();
+        let socket = table.get(&this)?;
+        let value = value.try_into().unwrap_or(usize::MAX);
+
+        util::set_socket_send_buffer_size(socket.udp_socket(), value)?;
+        Ok(())
+    }
+
+    fn subscribe(&mut self, this: Resource<udp::UdpSocket>) -> anyhow::Result<Resource<Pollable>> {
+        crate::poll::subscribe(self.table(), this)
+    }
+
+    fn drop(&mut self, this: Resource<udp::UdpSocket>) -> Result<(), anyhow::Error> {
+        let table = self.table();
+
+        // As in the filesystem implementation, we assume closing a socket
+        // doesn't block.
+        let dropped = table.delete(this)?;
+        drop(dropped);
+
+        Ok(())
+    }
+}
+
+impl<T> udp::HostIncomingDatagramStream for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn receive(
+        &mut self,
+        this: Resource<udp::IncomingDatagramStream>,
+        max_results: u64,
+    ) -> SocketResult<Vec<udp::IncomingDatagram>> {
+        // Returns Ok(None) when the message was dropped.
+        fn recv_one(
+            stream: &IncomingDatagramStream,
+        ) -> SocketResult<Option<udp::IncomingDatagram>> {
+            let mut buf = [0; MAX_UDP_DATAGRAM_SIZE];
+            let (size, received_addr) = stream.inner.try_recv_from(&mut buf)?;
+            debug_assert!(size <= buf.len());
+
+            match stream.remote_address {
+                Some(connected_addr) if connected_addr != received_addr => {
+                    // Normally, this should have already been checked for us by the OS.
+                    return Ok(None);
+                }
+                _ => {}
+            }
+
+            Ok(Some(udp::IncomingDatagram {
+                data: buf[..size].into(),
+                remote_address: received_addr.into(),
+            }))
+        }
+
+        let table = self.table();
+        let stream = table.get(&this)?;
+        let max_results: usize = max_results.try_into().unwrap_or(usize::MAX);
+
+        if max_results == 0 {
+            return Ok(vec![]);
+        }
+
+        let mut datagrams = vec![];
+
+        while datagrams.len() < max_results {
+            match recv_one(stream) {
+                Ok(Some(datagram)) => {
+                    datagrams.push(datagram);
+                }
+                Ok(None) => {
+                    // Message was dropped
+                }
+                Err(_) if datagrams.len() > 0 => {
+                    return Ok(datagrams);
+                }
+                Err(e) if matches!(e.downcast_ref(), Some(ErrorCode::WouldBlock)) => {
+                    return Ok(datagrams);
+                }
+                Err(e) => {
+                    return Err(e);
+                }
+            }
+        }
+
+        Ok(datagrams)
+    }
+
+    fn subscribe(
+        &mut self,
+        this: Resource<udp::IncomingDatagramStream>,
+    ) -> anyhow::Result<Resource<Pollable>> {
+        crate::poll::subscribe(self.table(), this)
+    }
+
+    fn drop(&mut self, this: Resource<udp::IncomingDatagramStream>) -> Result<(), anyhow::Error> {
+        let table = self.table();
+
+        // As in the filesystem implementation, we assume closing a socket
+        // doesn't block.
+        let dropped = table.delete(this)?;
+        drop(dropped);
+
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl Subscribe for IncomingDatagramStream {
+    async fn ready(&mut self) {
+        // FIXME: Add `Interest::ERROR` when we update to tokio 1.32.
+        self.inner
+            .ready(Interest::READABLE)
+            .await
+            .expect("failed to await UDP socket readiness");
+    }
+}
+
+#[async_trait::async_trait]
+impl<T> udp::HostOutgoingDatagramStream for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn check_send(&mut self, this: Resource<udp::OutgoingDatagramStream>) -> SocketResult<u64> {
+        let table = self.table();
+        let stream = table.get_mut(&this)?;
+
+        let permit = match stream.send_state {
+            SendState::Idle => {
+                const PERMIT: usize = 16;
+                stream.send_state = SendState::Permitted(PERMIT);
+                PERMIT
+            }
+            SendState::Permitted(n) => n,
+            SendState::Waiting => 0,
+        };
+
+        Ok(permit.try_into().unwrap())
+    }
+
+    async fn send(
+        &mut self,
+        this: Resource<udp::OutgoingDatagramStream>,
+        datagrams: Vec<udp::OutgoingDatagram>,
+    ) -> SocketResult<u64> {
+        async fn send_one(
+            stream: &OutgoingDatagramStream,
+            datagram: &udp::OutgoingDatagram,
+        ) -> SocketResult<()> {
+            if datagram.data.len() > MAX_UDP_DATAGRAM_SIZE {
+                return Err(ErrorCode::DatagramTooLarge.into());
+            }
+
+            let provided_addr = datagram.remote_address.map(SocketAddr::from);
+            let addr = match (stream.remote_address, provided_addr) {
+                (None, Some(addr)) => {
+                    let Some(check) = stream.socket_addr_check.as_ref() else {
+                        return Err(ErrorCode::InvalidState.into());
+                    };
+                    check
+                        .check(addr, SocketAddrUse::UdpOutgoingDatagram)
+                        .await?;
+                    addr
+                }
+                (Some(addr), None) => addr,
+                (Some(connected_addr), Some(provided_addr)) if connected_addr == provided_addr => {
+                    connected_addr
+                }
+                _ => return Err(ErrorCode::InvalidArgument.into()),
+            };
+
+            util::validate_remote_address(&addr)?;
+            util::validate_address_family(&addr, &stream.family)?;
+
+            if stream.remote_address == Some(addr) {
+                stream.inner.try_send(&datagram.data)?;
+            } else {
+                stream.inner.try_send_to(&datagram.data, addr)?;
+            }
+
+            Ok(())
+        }
+
+        let table = self.table();
+        let stream = table.get_mut(&this)?;
+
+        match stream.send_state {
+            SendState::Permitted(n) if n >= datagrams.len() => {
+                stream.send_state = SendState::Idle;
+            }
+            SendState::Permitted(_) => {
+                return Err(SocketError::trap(anyhow::anyhow!(
+                    "unpermitted: argument exceeds permitted size"
+                )))
+            }
+            SendState::Idle | SendState::Waiting => {
+                return Err(SocketError::trap(anyhow::anyhow!(
+                    "unpermitted: must call check-send first"
+                )))
+            }
+        }
+
+        if datagrams.is_empty() {
+            return Ok(0);
+        }
+
+        let mut count = 0;
+
+        for datagram in datagrams {
+            match send_one(stream, &datagram).await {
+                Ok(_) => count += 1,
+                Err(_) if count > 0 => {
+                    // WIT: "If at least one datagram has been sent successfully, this function never returns an error."
+                    return Ok(count);
+                }
+                Err(e) if matches!(e.downcast_ref(), Some(ErrorCode::WouldBlock)) => {
+                    stream.send_state = SendState::Waiting;
+                    return Ok(count);
+                }
+                Err(e) => {
+                    return Err(e);
+                }
+            }
+        }
+
+        Ok(count)
+    }
+
+    fn subscribe(
+        &mut self,
+        this: Resource<udp::OutgoingDatagramStream>,
+    ) -> anyhow::Result<Resource<Pollable>> {
+        crate::poll::subscribe(self.table(), this)
+    }
+
+    fn drop(&mut self, this: Resource<udp::OutgoingDatagramStream>) -> Result<(), anyhow::Error> {
+        let table = self.table();
+
+        // As in the filesystem implementation, we assume closing a socket
+        // doesn't block.
+        let dropped = table.delete(this)?;
+        drop(dropped);
+
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl Subscribe for OutgoingDatagramStream {
+    async fn ready(&mut self) {
+        match self.send_state {
+            SendState::Idle | SendState::Permitted(_) => {}
+            SendState::Waiting => {
+                // FIXME: Add `Interest::ERROR` when we update to tokio 1.32.
+                self.inner
+                    .ready(Interest::WRITABLE)
+                    .await
+                    .expect("failed to await UDP socket readiness");
+                self.send_state = SendState::Idle;
+            }
+        }
+    }
+}
+
+pub mod sync {
+    use wasmtime::component::Resource;
+
+    use crate::{
+        bindings::{
+            sockets::{
+                network::Network,
+                udp::{
+                    self as async_udp,
+                    HostIncomingDatagramStream as AsyncHostIncomingDatagramStream,
+                    HostOutgoingDatagramStream as AsyncHostOutgoingDatagramStream,
+                    HostUdpSocket as AsyncHostUdpSocket, IncomingDatagramStream,
+                    OutgoingDatagramStream,
+                },
+            },
+            sync::sockets::udp::{
+                self, HostIncomingDatagramStream, HostOutgoingDatagramStream, HostUdpSocket,
+                IncomingDatagram, IpAddressFamily, IpSocketAddress, OutgoingDatagram, Pollable,
+                UdpSocket,
+            },
+        },
+        runtime::in_tokio,
+        SocketError, WasiImpl, WasiView,
+    };
+
+    impl<T> udp::Host for WasiImpl<T> where T: WasiView {}
+
+    impl<T> HostUdpSocket for WasiImpl<T>
+    where
+        T: WasiView,
+    {
+        fn start_bind(
+            &mut self,
+            self_: Resource<UdpSocket>,
+            network: Resource<Network>,
+            local_address: IpSocketAddress,
+        ) -> Result<(), SocketError> {
+            in_tokio(async {
+                AsyncHostUdpSocket::start_bind(self, self_, network, local_address).await
+            })
+        }
+
+        fn finish_bind(&mut self, self_: Resource<UdpSocket>) -> Result<(), SocketError> {
+            AsyncHostUdpSocket::finish_bind(self, self_)
+        }
+
+        fn stream(
+            &mut self,
+            self_: Resource<UdpSocket>,
+            remote_address: Option<IpSocketAddress>,
+        ) -> Result<
+            (
+                Resource<IncomingDatagramStream>,
+                Resource<OutgoingDatagramStream>,
+            ),
+            SocketError,
+        > {
+            in_tokio(async { AsyncHostUdpSocket::stream(self, self_, remote_address).await })
+        }
+
+        fn local_address(
+            &mut self,
+            self_: Resource<UdpSocket>,
+        ) -> Result<IpSocketAddress, SocketError> {
+            AsyncHostUdpSocket::local_address(self, self_)
+        }
+
+        fn remote_address(
+            &mut self,
+            self_: Resource<UdpSocket>,
+        ) -> Result<IpSocketAddress, SocketError> {
+            AsyncHostUdpSocket::remote_address(self, self_)
+        }
+
+        fn address_family(
+            &mut self,
+            self_: Resource<UdpSocket>,
+        ) -> wasmtime::Result<IpAddressFamily> {
+            AsyncHostUdpSocket::address_family(self, self_)
+        }
+
+        fn unicast_hop_limit(&mut self, self_: Resource<UdpSocket>) -> Result<u8, SocketError> {
+            AsyncHostUdpSocket::unicast_hop_limit(self, self_)
+        }
+
+        fn set_unicast_hop_limit(
+            &mut self,
+            self_: Resource<UdpSocket>,
+            value: u8,
+        ) -> Result<(), SocketError> {
+            AsyncHostUdpSocket::set_unicast_hop_limit(self, self_, value)
+        }
+
+        fn receive_buffer_size(&mut self, self_: Resource<UdpSocket>) -> Result<u64, SocketError> {
+            AsyncHostUdpSocket::receive_buffer_size(self, self_)
+        }
+
+        fn set_receive_buffer_size(
+            &mut self,
+            self_: Resource<UdpSocket>,
+            value: u64,
+        ) -> Result<(), SocketError> {
+            AsyncHostUdpSocket::set_receive_buffer_size(self, self_, value)
+        }
+
+        fn send_buffer_size(&mut self, self_: Resource<UdpSocket>) -> Result<u64, SocketError> {
+            AsyncHostUdpSocket::send_buffer_size(self, self_)
+        }
+
+        fn set_send_buffer_size(
+            &mut self,
+            self_: Resource<UdpSocket>,
+            value: u64,
+        ) -> Result<(), SocketError> {
+            AsyncHostUdpSocket::set_send_buffer_size(self, self_, value)
+        }
+
+        fn subscribe(
+            &mut self,
+            self_: Resource<UdpSocket>,
+        ) -> wasmtime::Result<Resource<Pollable>> {
+            AsyncHostUdpSocket::subscribe(self, self_)
+        }
+
+        fn drop(&mut self, rep: Resource<UdpSocket>) -> wasmtime::Result<()> {
+            AsyncHostUdpSocket::drop(self, rep)
+        }
+    }
+
+    impl<T> HostIncomingDatagramStream for WasiImpl<T>
+    where
+        T: WasiView,
+    {
+        fn receive(
+            &mut self,
+            self_: Resource<IncomingDatagramStream>,
+            max_results: u64,
+        ) -> Result<Vec<IncomingDatagram>, SocketError> {
+            Ok(
+                AsyncHostIncomingDatagramStream::receive(self, self_, max_results)?
+                    .into_iter()
+                    .map(Into::into)
+                    .collect(),
+            )
+        }
+
+        fn subscribe(
+            &mut self,
+            self_: Resource<IncomingDatagramStream>,
+        ) -> wasmtime::Result<Resource<Pollable>> {
+            AsyncHostIncomingDatagramStream::subscribe(self, self_)
+        }
+
+        fn drop(&mut self, rep: Resource<IncomingDatagramStream>) -> wasmtime::Result<()> {
+            AsyncHostIncomingDatagramStream::drop(self, rep)
+        }
+    }
+
+    impl From<async_udp::IncomingDatagram> for IncomingDatagram {
+        fn from(other: async_udp::IncomingDatagram) -> Self {
+            let async_udp::IncomingDatagram {
+                data,
+                remote_address,
+            } = other;
+            Self {
+                data,
+                remote_address,
+            }
+        }
+    }
+
+    impl<T> HostOutgoingDatagramStream for WasiImpl<T>
+    where
+        T: WasiView,
+    {
+        fn check_send(
+            &mut self,
+            self_: Resource<OutgoingDatagramStream>,
+        ) -> Result<u64, SocketError> {
+            AsyncHostOutgoingDatagramStream::check_send(self, self_)
+        }
+
+        fn send(
+            &mut self,
+            self_: Resource<OutgoingDatagramStream>,
+            datagrams: Vec<OutgoingDatagram>,
+        ) -> Result<u64, SocketError> {
+            let datagrams = datagrams.into_iter().map(Into::into).collect();
+            in_tokio(async { AsyncHostOutgoingDatagramStream::send(self, self_, datagrams).await })
+        }
+
+        fn subscribe(
+            &mut self,
+            self_: Resource<OutgoingDatagramStream>,
+        ) -> wasmtime::Result<Resource<Pollable>> {
+            AsyncHostOutgoingDatagramStream::subscribe(self, self_)
+        }
+
+        fn drop(&mut self, rep: Resource<OutgoingDatagramStream>) -> wasmtime::Result<()> {
+            AsyncHostOutgoingDatagramStream::drop(self, rep)
+        }
+    }
+
+    impl From<OutgoingDatagram> for async_udp::OutgoingDatagram {
+        fn from(other: OutgoingDatagram) -> Self {
+            let OutgoingDatagram {
+                data,
+                remote_address,
+            } = other;
+            Self {
+                data,
+                remote_address,
+            }
+        }
+    }
+}
diff --git a/crates/wasi/src/host/udp_create_socket.rs b/crates/wasi/src/host/udp_create_socket.rs
new file mode 100644
index 000000000000..f27b574b99ee
--- /dev/null
+++ b/crates/wasi/src/host/udp_create_socket.rs
@@ -0,0 +1,18 @@
+use crate::bindings::{sockets::network::IpAddressFamily, sockets::udp_create_socket};
+use crate::udp::UdpSocket;
+use crate::{SocketResult, WasiImpl, WasiView};
+use wasmtime::component::Resource;
+
+impl<T> udp_create_socket::Host for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn create_udp_socket(
+        &mut self,
+        address_family: IpAddressFamily,
+    ) -> SocketResult<Resource<UdpSocket>> {
+        let socket = UdpSocket::new(address_family.into())?;
+        let socket = self.table().push(socket)?;
+        Ok(socket)
+    }
+}
diff --git a/crates/wasi/src/ip_name_lookup.rs b/crates/wasi/src/ip_name_lookup.rs
new file mode 100644
index 000000000000..900d90800265
--- /dev/null
+++ b/crates/wasi/src/ip_name_lookup.rs
@@ -0,0 +1,132 @@
+use crate::bindings::sockets::ip_name_lookup::{Host, HostResolveAddressStream};
+use crate::bindings::sockets::network::{ErrorCode, IpAddress, Network};
+use crate::host::network::util;
+use crate::poll::{subscribe, Pollable, Subscribe};
+use crate::runtime::{spawn_blocking, AbortOnDropJoinHandle};
+use crate::{SocketError, WasiImpl, WasiView};
+use anyhow::Result;
+use std::mem;
+use std::net::{Ipv6Addr, ToSocketAddrs};
+use std::pin::Pin;
+use std::str::FromStr;
+use std::vec;
+use wasmtime::component::Resource;
+
+use super::network::{from_ipv4_addr, from_ipv6_addr};
+
+pub enum ResolveAddressStream {
+    Waiting(AbortOnDropJoinHandle<Result<Vec<IpAddress>, SocketError>>),
+    Done(Result<vec::IntoIter<IpAddress>, SocketError>),
+}
+
+#[async_trait::async_trait]
+impl<T> Host for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn resolve_addresses(
+        &mut self,
+        network: Resource<Network>,
+        name: String,
+    ) -> Result<Resource<ResolveAddressStream>, SocketError> {
+        let network = self.table().get(&network)?;
+
+        let host = parse(&name)?;
+
+        if !network.allow_ip_name_lookup {
+            return Err(ErrorCode::PermanentResolverFailure.into());
+        }
+
+        let task = spawn_blocking(move || blocking_resolve(&host));
+        let resource = self.table().push(ResolveAddressStream::Waiting(task))?;
+        Ok(resource)
+    }
+}
+
+#[async_trait::async_trait]
+impl<T> HostResolveAddressStream for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn resolve_next_address(
+        &mut self,
+        resource: Resource<ResolveAddressStream>,
+    ) -> Result<Option<IpAddress>, SocketError> {
+        let stream: &mut ResolveAddressStream = self.table().get_mut(&resource)?;
+        loop {
+            match stream {
+                ResolveAddressStream::Waiting(future) => {
+                    match crate::runtime::poll_noop(Pin::new(future)) {
+                        Some(result) => {
+                            *stream = ResolveAddressStream::Done(result.map(|v| v.into_iter()));
+                        }
+                        None => return Err(ErrorCode::WouldBlock.into()),
+                    }
+                }
+                ResolveAddressStream::Done(slot @ Err(_)) => {
+                    mem::replace(slot, Ok(Vec::new().into_iter()))?;
+                    unreachable!();
+                }
+                ResolveAddressStream::Done(Ok(iter)) => return Ok(iter.next()),
+            }
+        }
+    }
+
+    fn subscribe(
+        &mut self,
+        resource: Resource<ResolveAddressStream>,
+    ) -> Result<Resource<Pollable>> {
+        subscribe(self.table(), resource)
+    }
+
+    fn drop(&mut self, resource: Resource<ResolveAddressStream>) -> Result<()> {
+        self.table().delete(resource)?;
+        Ok(())
+    }
+}
+
+#[async_trait::async_trait]
+impl Subscribe for ResolveAddressStream {
+    async fn ready(&mut self) {
+        if let ResolveAddressStream::Waiting(future) = self {
+            *self = ResolveAddressStream::Done(future.await.map(|v| v.into_iter()));
+        }
+    }
+}
+
+fn parse(name: &str) -> Result<url::Host, SocketError> {
+    // `url::Host::parse` serves us two functions:
+    // 1. validate the input is a valid domain name or IP,
+    // 2. convert unicode domains to punycode.
+    match url::Host::parse(&name) {
+        Ok(host) => Ok(host),
+
+        // `url::Host::parse` doesn't understand bare IPv6 addresses without [brackets]
+        Err(_) => {
+            if let Ok(addr) = Ipv6Addr::from_str(name) {
+                Ok(url::Host::Ipv6(addr))
+            } else {
+                Err(ErrorCode::InvalidArgument.into())
+            }
+        }
+    }
+}
+
+fn blocking_resolve(host: &url::Host) -> Result<Vec<IpAddress>, SocketError> {
+    match host {
+        url::Host::Ipv4(v4addr) => Ok(vec![IpAddress::Ipv4(from_ipv4_addr(*v4addr))]),
+        url::Host::Ipv6(v6addr) => Ok(vec![IpAddress::Ipv6(from_ipv6_addr(*v6addr))]),
+        url::Host::Domain(domain) => {
+            // For now use the standard library to perform actual resolution through
+            // the usage of the `ToSocketAddrs` trait. This is only
+            // resolving names, not ports, so force the port to be 0.
+            let addresses = (domain.as_str(), 0)
+                .to_socket_addrs()
+                .map_err(|_| ErrorCode::NameUnresolvable)? // If/when we use `getaddrinfo` directly, map the error properly.
+                .map(|addr| util::to_canonical(&addr.ip()).into())
+                .collect();
+
+            Ok(addresses)
+        }
+    }
+}
diff --git a/crates/wasi/src/lib.rs b/crates/wasi/src/lib.rs
index 70671b6172ba..fe8594c74c75 100644
--- a/crates/wasi/src/lib.rs
+++ b/crates/wasi/src/lib.rs
@@ -1,135 +1,419 @@
-//! `wasmtime-wasi` now supports using multiple snapshots to interface to the
-//! same `WasiCtx`!
+//! # Wasmtime's WASI Implementation
 //!
-//! `wasmtime_wasi::Wasi::new(&Store, WasiCtx)` is a struct which owns your
-//! `WasiCtx` and provides linkage to every available snapshot.
+//! This crate provides a Wasmtime host implementation of WASI 0.2 (aka WASIp2
+//! aka Preview 2) and WASI 0.1 (aka WASIp1 aka Preview 1). WASI is implemented
+//! with the Rust crates [`tokio`] and [`cap-std`] primarily, meaning that
+//! operations are implemented in terms of their native platform equivalents by
+//! default.
 //!
-//! Individual snapshots are available through
-//! `wasmtime_wasi::snapshots::preview_{0, 1}::Wasi::new(&Store, Rc<RefCell<WasiCtx>>)`.
-
-#[cfg(feature = "preview2")]
-pub mod preview2;
-
-pub use wasi_common::{Error, I32Exit, WasiCtx, WasiDir, WasiFile};
+//! For components and WASIp2, continue reading below. For WASIp1 and core
+//! modules, see the [`preview1`] module documentation.
+//!
+//! # WASIp2 interfaces
+//!
+//! This crate contains implementations of the following interfaces:
+//!
+//! * [`wasi:cli/environment`]
+//! * [`wasi:cli/exit`]
+//! * [`wasi:cli/stderr`]
+//! * [`wasi:cli/stdin`]
+//! * [`wasi:cli/stdout`]
+//! * [`wasi:cli/terminal-input`]
+//! * [`wasi:cli/terminal-output`]
+//! * [`wasi:cli/terminal-stderr`]
+//! * [`wasi:cli/terminal-stdin`]
+//! * [`wasi:cli/terminal-stdout`]
+//! * [`wasi:clocks/monotonic-clock`]
+//! * [`wasi:clocks/wall-clock`]
+//! * [`wasi:filesystem/preopens`]
+//! * [`wasi:filesystem/types`]
+//! * [`wasi:io/error`]
+//! * [`wasi:io/poll`]
+//! * [`wasi:io/streams`]
+//! * [`wasi:random/insecure-seed`]
+//! * [`wasi:random/insecure`]
+//! * [`wasi:random/random`]
+//! * [`wasi:sockets/instance-network`]
+//! * [`wasi:sockets/ip-name-lookup`]
+//! * [`wasi:sockets/network`]
+//! * [`wasi:sockets/tcp-create-socket`]
+//! * [`wasi:sockets/tcp`]
+//! * [`wasi:sockets/udp-create-socket`]
+//! * [`wasi:sockets/udp`]
+//!
+//! All traits are implemented in terms of a [`WasiView`] trait which provides
+//! basic access to [`WasiCtx`], configuration for WASI, and [`ResourceTable`],
+//! the state for all host-defined component model resources.
+//!
+//! # Generated Bindings
+//!
+//! This crate uses [`wasmtime::component::bindgen!`] to generate bindings for
+//! all WASI interfaces. Raw bindings are available in the [`bindings`] module
+//! of this crate. Downstream users can either implement these traits themselves
+//! or you can use the built-in implementations in this crate for
+//! `WasiImpl<T: WasiView>`.
+//!
+//! # The `WasiView` trait
+//!
+//! This crate's implementation of WASI is done in terms of an implementation of
+//! [`WasiView`]. This trait provides a "view" into WASI-related state that is
+//! contained within a [`Store<T>`](wasmtime::Store). All implementations of
+//! traits look like:
+//!
+//! ```
+//! # use wasmtime_wasi::WasiImpl;
+//! # trait WasiView {}
+//! # mod bindings { pub mod wasi { pub trait Host {} } }
+//! impl<T: WasiView> bindings::wasi::Host for WasiImpl<T> {
+//!     // ...
+//! }
+//! ```
+//!
+//! The [`add_to_linker_sync`] and [`add_to_linker_async`] function then require
+//! that `T: WasiView` with [`Linker<T>`](wasmtime::component::Linker).
+//!
+//! To implement the [`WasiView`] trait you will first select a `T` to put in
+//! `Store<T>`. Next you'll implement the [`WasiView`] trait for `T`. Somewhere
+//! within `T` you'll store:
+//!
+//! * [`WasiCtx`] - created through [`WasiCtxBuilder`].
+//! * [`ResourceTable`] - created through default constructors.
+//!
+//! These two fields are then accessed through the methods of [`WasiView`].
+//!
+//! # Async and Sync
+//!
+//! Many WASI functions are not blocking from WebAssembly's point of view, but
+//! for those that do they're provided in two flavors: asynchronous and
+//! synchronous. Which version you will use depends on how
+//! [`Config::async_support`][async] is set.
+//!
+//! * For non-async users (the default of `Config`), use [`add_to_linker_sync`].
+//! * For async users, use [`add_to_linker_async`].
+//!
+//! Note that bindings are generated once for async and once for sync. Most
+//! interfaces do not change, however, so only interfaces with blocking
+//! functions have bindings generated twice. Bindings are organized as:
+//!
+//! * [`bindings`] - default location of all bindings, blocking functions are
+//!   `async`
+//! * [`bindings::sync`] - blocking interfaces have synchronous versions here.
+//!
+//! # Crate-specific traits
+//!
+//! This crate's default implementation of WASI bindings to native primitives
+//! for the platform that it is compiled for. For example opening a TCP socket
+//! uses the native platform to open a TCP socket (so long as [`WasiCtxBuilder`]
+//! allows it). There are a few important traits, however, that are specific to
+//! this crate.
+//!
+//! * [`HostInputStream`] and [`HostOutputStream`] - these are the host traits
+//!   behind the WASI `input-stream` and `output-stream` types in the
+//!   `wasi:io/streams` interface. These enable embedders to build their own
+//!   custom stream and insert them into a [`ResourceTable`] to be used from
+//!   wasm.
+//!
+//! * [`Subscribe`] - this trait enables building arbitrary logic to get hooked
+//!   into a `pollable` resource from `wasi:io/poll`. A pollable resource is
+//!   created through the [`subscribe`] function.
+//!
+//! * [`HostWallClock`] and [`HostMonotonicClock`] are used in conjunction with
+//!   [`WasiCtxBuilder::wall_clock`] and [`WasiCtxBuilder::monotonic_clock`] if
+//!   the defaults host's clock should not be used.
+//!
+//! * [`StdinStream`] and [`StdoutStream`] are used to provide custom
+//!   stdin/stdout streams if they're not inherited (or null, which is the
+//!   default).
+//!
+//! These traits enable embedders to customize small portions of WASI interfaces
+//! provided while still providing all other interfaces.
+//!
+//! # Examples
+//!
+//! Usage of this crate is done through a few steps to get everything hooked up:
+//!
+//! 1. First implement [`WasiView`] for your type which is the `T` in
+//!    `Store<T>`.
+//! 2. Add WASI interfaces to a `wasmtime::component::Linker<T>`. This is either
+//!    done through top-level functions like [`add_to_linker_sync`] or through
+//!    individual `add_to_linker` functions in generated bindings throughout
+//!    this crate.
+//! 3. Create a [`WasiCtx`] for each `Store<T>` through [`WasiCtxBuilder`]. Each
+//!    WASI context is "null" or "empty" by default, so items must be explicitly
+//!    added to get accessed by wasm (such as env vars or program arguments).
+//! 4. Use the previous `Linker<T>` to instantiate a `Component` within a
+//!    `Store<T>`.
+//!
+//! For examples see each of [`WasiView`], [`WasiCtx`], [`WasiCtxBuilder`],
+//! [`add_to_linker_sync`], and [`bindings::Command`].
+//!
+//! [`wasmtime::component::bindgen!`]: https://docs.rs/wasmtime/latest/wasmtime/component/macro.bindgen.html
+//! [`tokio`]: https://crates.io/crates/tokio
+//! [`cap-std`]: https://crates.io/crates/cap-std
+//! [`wasi:cli/environment`]: bindings::cli::environment::Host
+//! [`wasi:cli/exit`]: bindings::cli::exit::Host
+//! [`wasi:cli/stderr`]: bindings::cli::stderr::Host
+//! [`wasi:cli/stdin`]: bindings::cli::stdin::Host
+//! [`wasi:cli/stdout`]: bindings::cli::stdout::Host
+//! [`wasi:cli/terminal-input`]: bindings::cli::terminal_input::Host
+//! [`wasi:cli/terminal-output`]: bindings::cli::terminal_output::Host
+//! [`wasi:cli/terminal-stdin`]: bindings::cli::terminal_stdin::Host
+//! [`wasi:cli/terminal-stdout`]: bindings::cli::terminal_stdout::Host
+//! [`wasi:cli/terminal-stderr`]: bindings::cli::terminal_stderr::Host
+//! [`wasi:clocks/monotonic-clock`]: bindings::clocks::monotonic_clock::Host
+//! [`wasi:clocks/wall-clock`]: bindings::clocks::wall_clock::Host
+//! [`wasi:filesystem/preopens`]: bindings::filesystem::preopens::Host
+//! [`wasi:filesystem/types`]: bindings::filesystem::types::Host
+//! [`wasi:io/error`]: bindings::io::error::Host
+//! [`wasi:io/poll`]: bindings::io::poll::Host
+//! [`wasi:io/streams`]: bindings::io::streams::Host
+//! [`wasi:random/insecure-seed`]: bindings::random::insecure_seed::Host
+//! [`wasi:random/insecure`]: bindings::random::insecure::Host
+//! [`wasi:random/random`]: bindings::random::random::Host
+//! [`wasi:sockets/instance-network`]: bindings::sockets::instance_network::Host
+//! [`wasi:sockets/ip-name-lookup`]: bindings::sockets::ip_name_lookup::Host
+//! [`wasi:sockets/network`]: bindings::sockets::network::Host
+//! [`wasi:sockets/tcp-create-socket`]: bindings::sockets::tcp_create_socket::Host
+//! [`wasi:sockets/tcp`]: bindings::sockets::tcp::Host
+//! [`wasi:sockets/udp-create-socket`]: bindings::sockets::udp_create_socket::Host
+//! [`wasi:sockets/udp`]: bindings::sockets::udp::Host
+//! [async]: https://docs.rs/wasmtime/latest/wasmtime/struct.Config.html#method.async_support
+//! [`ResourceTable`]: wasmtime::component::ResourceTable
 
-/// Re-export the commonly used wasi-cap-std-sync crate here. This saves
-/// consumers of this library from having to keep additional dependencies
-/// in sync.
-#[cfg(feature = "sync")]
-pub mod sync {
-    pub use wasi_cap_std_sync::*;
-    super::define_wasi!(block_on);
-}
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
 
-/// Sync mode is the "default" of this crate, so we also export it at the top
-/// level.
-#[cfg(feature = "sync")]
-pub use sync::*;
+use wasmtime::component::Linker;
 
-/// Re-export the wasi-tokio crate here. This saves consumers of this library from having
-/// to keep additional dependencies in sync.
-#[cfg(feature = "tokio")]
-pub mod tokio {
-    pub use wasi_tokio::*;
-    super::define_wasi!(async T: Send);
-}
+pub mod bindings;
+mod clocks;
+mod ctx;
+mod error;
+mod filesystem;
+mod host;
+mod ip_name_lookup;
+mod network;
+pub mod pipe;
+mod poll;
+#[cfg(feature = "preview1")]
+pub mod preview0;
+#[cfg(feature = "preview1")]
+pub mod preview1;
+mod random;
+pub mod runtime;
+mod stdio;
+mod stream;
+mod tcp;
+mod udp;
+mod write_stream;
 
-// The only difference between these definitions for sync vs async is whether
-// the wasmtime::Funcs generated are async (& therefore need an async Store and an executor to run)
-// or whether they have an internal "dummy executor" that expects the implementation of all
-// the async funcs to poll to Ready immediately.
-#[doc(hidden)]
-#[macro_export]
-macro_rules! define_wasi {
-    ($async_mode:tt $($bounds:tt)*) => {
+pub use self::clocks::{HostMonotonicClock, HostWallClock};
+pub use self::ctx::{WasiCtx, WasiCtxBuilder, WasiImpl, WasiView};
+pub use self::error::{I32Exit, TrappableError};
+pub use self::filesystem::{DirPerms, FileInputStream, FilePerms, FsError, FsResult};
+pub use self::network::{Network, SocketAddrUse, SocketError, SocketResult};
+pub use self::poll::{subscribe, ClosureFuture, MakeFuture, Pollable, PollableFuture, Subscribe};
+pub use self::random::{thread_rng, Deterministic};
+pub use self::stdio::{
+    stderr, stdin, stdout, AsyncStdinStream, AsyncStdoutStream, IsATTY, OutputFile, Stderr, Stdin,
+    StdinStream, Stdout, StdoutStream,
+};
+pub use self::stream::{
+    HostInputStream, HostOutputStream, InputStream, OutputStream, StreamError, StreamResult,
+};
+#[doc(no_inline)]
+pub use async_trait::async_trait;
+#[doc(no_inline)]
+pub use cap_fs_ext::SystemTimeSpec;
+#[doc(no_inline)]
+pub use cap_rand::RngCore;
+#[doc(no_inline)]
+pub use wasmtime::component::{ResourceTable, ResourceTableError};
 
-use wasmtime::Linker;
+/// Add all WASI interfaces from this crate into the `linker` provided.
+///
+/// This function will add the `async` variant of all interfaces into the
+/// [`Linker`] provided. By `async` this means that this function is only
+/// compatible with [`Config::async_support(true)`][async]. For embeddings with
+/// async support disabled see [`add_to_linker_sync`] instead.
+///
+/// This function will add all interfaces implemented by this crate to the
+/// [`Linker`], which corresponds to the `wasi:cli/imports` world supported by
+/// this crate.
+///
+/// [async]: wasmtime::Config::async_support
+///
+/// # Example
+///
+/// ```
+/// use wasmtime::{Engine, Result, Store, Config};
+/// use wasmtime::component::{ResourceTable, Linker};
+/// use wasmtime_wasi::{WasiCtx, WasiView, WasiCtxBuilder};
+///
+/// fn main() -> Result<()> {
+///     let mut config = Config::new();
+///     config.async_support(true);
+///     let engine = Engine::new(&config)?;
+///
+///     let mut linker = Linker::<MyState>::new(&engine);
+///     wasmtime_wasi::add_to_linker_async(&mut linker)?;
+///     // ... add any further functionality to `linker` if desired ...
+///
+///     let mut builder = WasiCtxBuilder::new();
+///
+///     // ... configure `builder` more to add env vars, args, etc ...
+///
+///     let mut store = Store::new(
+///         &engine,
+///         MyState {
+///             ctx: builder.build(),
+///             table: ResourceTable::new(),
+///         },
+///     );
+///
+///     // ... use `linker` to instantiate within `store` ...
+///
+///     Ok(())
+/// }
+///
+/// struct MyState {
+///     ctx: WasiCtx,
+///     table: ResourceTable,
+/// }
+///
+/// impl WasiView for MyState {
+///     fn ctx(&mut self) -> &mut WasiCtx { &mut self.ctx }
+///     fn table(&mut self) -> &mut ResourceTable { &mut self.table }
+/// }
+/// ```
+pub fn add_to_linker_async<T: WasiView>(linker: &mut Linker<T>) -> anyhow::Result<()> {
+    let l = linker;
+    let closure = type_annotate::<T, _>(|t| WasiImpl(t));
 
-pub fn add_to_linker<T, U>(
-    linker: &mut Linker<T>,
-    get_cx: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
-) -> anyhow::Result<()>
-    where U: Send
-            + wasi_common::snapshots::preview_0::wasi_unstable::WasiUnstable
-            + wasi_common::snapshots::preview_1::wasi_snapshot_preview1::WasiSnapshotPreview1,
-        $($bounds)*
-{
-    snapshots::preview_1::add_wasi_snapshot_preview1_to_linker(linker, get_cx)?;
-    snapshots::preview_0::add_wasi_unstable_to_linker(linker, get_cx)?;
+    crate::bindings::clocks::wall_clock::add_to_linker_get_host(l, closure)?;
+    crate::bindings::clocks::monotonic_clock::add_to_linker_get_host(l, closure)?;
+    crate::bindings::filesystem::types::add_to_linker_get_host(l, closure)?;
+    crate::bindings::filesystem::preopens::add_to_linker_get_host(l, closure)?;
+    crate::bindings::io::error::add_to_linker_get_host(l, closure)?;
+    crate::bindings::io::poll::add_to_linker_get_host(l, closure)?;
+    crate::bindings::io::streams::add_to_linker_get_host(l, closure)?;
+    crate::bindings::random::random::add_to_linker_get_host(l, closure)?;
+    crate::bindings::random::insecure::add_to_linker_get_host(l, closure)?;
+    crate::bindings::random::insecure_seed::add_to_linker_get_host(l, closure)?;
+    crate::bindings::cli::exit::add_to_linker_get_host(l, closure)?;
+    crate::bindings::cli::environment::add_to_linker_get_host(l, closure)?;
+    crate::bindings::cli::stdin::add_to_linker_get_host(l, closure)?;
+    crate::bindings::cli::stdout::add_to_linker_get_host(l, closure)?;
+    crate::bindings::cli::stderr::add_to_linker_get_host(l, closure)?;
+    crate::bindings::cli::terminal_input::add_to_linker_get_host(l, closure)?;
+    crate::bindings::cli::terminal_output::add_to_linker_get_host(l, closure)?;
+    crate::bindings::cli::terminal_stdin::add_to_linker_get_host(l, closure)?;
+    crate::bindings::cli::terminal_stdout::add_to_linker_get_host(l, closure)?;
+    crate::bindings::cli::terminal_stderr::add_to_linker_get_host(l, closure)?;
+    crate::bindings::sockets::tcp::add_to_linker_get_host(l, closure)?;
+    crate::bindings::sockets::tcp_create_socket::add_to_linker_get_host(l, closure)?;
+    crate::bindings::sockets::udp::add_to_linker_get_host(l, closure)?;
+    crate::bindings::sockets::udp_create_socket::add_to_linker_get_host(l, closure)?;
+    crate::bindings::sockets::instance_network::add_to_linker_get_host(l, closure)?;
+    crate::bindings::sockets::network::add_to_linker_get_host(l, closure)?;
+    crate::bindings::sockets::ip_name_lookup::add_to_linker_get_host(l, closure)?;
     Ok(())
 }
 
-pub mod snapshots {
-    pub mod preview_1 {
-        wiggle::wasmtime_integration!({
-            // The wiggle code to integrate with lives here:
-            target: wasi_common::snapshots::preview_1,
-            // This must be the same witx document as used above. This should be ensured by
-            // the `WASI_ROOT` env variable, which is set in wasi-common's `build.rs`.
-            witx: ["$WASI_ROOT/phases/snapshot/witx/wasi_snapshot_preview1.witx"],
-            errors: { errno => trappable Error },
-            $async_mode: *
-        });
-    }
-    pub mod preview_0 {
-        wiggle::wasmtime_integration!({
-            // The wiggle code to integrate with lives here:
-            target: wasi_common::snapshots::preview_0,
-            // This must be the same witx document as used above. This should be ensured by
-            // the `WASI_ROOT` env variable, which is set in wasi-common's `build.rs`.
-            witx: ["$WASI_ROOT/phases/old/snapshot_0/witx/wasi_unstable.witx"],
-            errors: { errno => trappable Error },
-            $async_mode: *
-        });
-    }
-}
-}
-}
-
-/// Exit the process with a conventional OS error code as long as Wasmtime
-/// understands the error. If the error is not an `I32Exit` or `Trap`, return
-/// the error back to the caller for it to decide what to do.
-///
-/// Note: this function is designed for usage where it is acceptable for
-/// Wasmtime failures to terminate the parent process, such as in the Wasmtime
-/// CLI; this would not be suitable for use in multi-tenant embeddings.
-#[cfg(feature = "exit")]
-pub fn maybe_exit_on_error(e: anyhow::Error) -> anyhow::Error {
-    use std::process;
-    use wasmtime::Trap;
-
-    // If a specific WASI error code was requested then that's
-    // forwarded through to the process here without printing any
-    // extra error information.
-    let code = e
-        .downcast_ref::<I32Exit>()
-        .map(|e| e.0)
-        .or_else(|| e.downcast_ref::<preview2::I32Exit>().map(|e| e.0));
-    if let Some(exit) = code {
-        // Print the error message in the usual way.
-        // On Windows, exit status 3 indicates an abort (see below),
-        // so return 1 indicating a non-zero status to avoid ambiguity.
-        if cfg!(windows) && exit >= 3 {
-            process::exit(1);
-        }
-        process::exit(exit);
-    }
-
-    // If the program exited because of a trap, return an error code
-    // to the outside environment indicating a more severe problem
-    // than a simple failure.
-    if e.is::<Trap>() {
-        eprintln!("Error: {:?}", e);
+/// Add all WASI interfaces from this crate into the `linker` provided.
+///
+/// This function will add the synchronous variant of all interfaces into the
+/// [`Linker`] provided. By synchronous this means that this function is only
+/// compatible with [`Config::async_support(false)`][async]. For embeddings
+/// with async support enabled see [`add_to_linker_async`] instead.
+///
+/// This function will add all interfaces implemented by this crate to the
+/// [`Linker`], which corresponds to the `wasi:cli/imports` world supported by
+/// this crate.
+///
+/// [async]: wasmtime::Config::async_support
+///
+/// # Example
+///
+/// ```
+/// use wasmtime::{Engine, Result, Store, Config};
+/// use wasmtime::component::{ResourceTable, Linker};
+/// use wasmtime_wasi::{WasiCtx, WasiView, WasiCtxBuilder};
+///
+/// fn main() -> Result<()> {
+///     let engine = Engine::default();
+///
+///     let mut linker = Linker::<MyState>::new(&engine);
+///     wasmtime_wasi::add_to_linker_sync(&mut linker)?;
+///     // ... add any further functionality to `linker` if desired ...
+///
+///     let mut builder = WasiCtxBuilder::new();
+///
+///     // ... configure `builder` more to add env vars, args, etc ...
+///
+///     let mut store = Store::new(
+///         &engine,
+///         MyState {
+///             ctx: builder.build(),
+///             table: ResourceTable::new(),
+///         },
+///     );
+///
+///     // ... use `linker` to instantiate within `store` ...
+///
+///     Ok(())
+/// }
+///
+/// struct MyState {
+///     ctx: WasiCtx,
+///     table: ResourceTable,
+/// }
+///
+/// impl WasiView for MyState {
+///     fn ctx(&mut self) -> &mut WasiCtx { &mut self.ctx }
+///     fn table(&mut self) -> &mut ResourceTable { &mut self.table }
+/// }
+/// ```
+pub fn add_to_linker_sync<T: WasiView>(
+    linker: &mut wasmtime::component::Linker<T>,
+) -> anyhow::Result<()> {
+    let l = linker;
+    let closure = type_annotate::<T, _>(|t| WasiImpl(t));
 
-        if cfg!(unix) {
-            // On Unix, return the error code of an abort.
-            process::exit(128 + libc::SIGABRT);
-        } else if cfg!(windows) {
-            // On Windows, return 3.
-            // https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/abort?view=vs-2019
-            process::exit(3);
-        }
-    }
+    crate::bindings::clocks::wall_clock::add_to_linker_get_host(l, closure)?;
+    crate::bindings::clocks::monotonic_clock::add_to_linker_get_host(l, closure)?;
+    crate::bindings::sync::filesystem::types::add_to_linker_get_host(l, closure)?;
+    crate::bindings::filesystem::preopens::add_to_linker_get_host(l, closure)?;
+    crate::bindings::io::error::add_to_linker_get_host(l, closure)?;
+    crate::bindings::sync::io::poll::add_to_linker_get_host(l, closure)?;
+    crate::bindings::sync::io::streams::add_to_linker_get_host(l, closure)?;
+    crate::bindings::random::random::add_to_linker_get_host(l, closure)?;
+    crate::bindings::random::insecure::add_to_linker_get_host(l, closure)?;
+    crate::bindings::random::insecure_seed::add_to_linker_get_host(l, closure)?;
+    crate::bindings::cli::exit::add_to_linker_get_host(l, closure)?;
+    crate::bindings::cli::environment::add_to_linker_get_host(l, closure)?;
+    crate::bindings::cli::stdin::add_to_linker_get_host(l, closure)?;
+    crate::bindings::cli::stdout::add_to_linker_get_host(l, closure)?;
+    crate::bindings::cli::stderr::add_to_linker_get_host(l, closure)?;
+    crate::bindings::cli::terminal_input::add_to_linker_get_host(l, closure)?;
+    crate::bindings::cli::terminal_output::add_to_linker_get_host(l, closure)?;
+    crate::bindings::cli::terminal_stdin::add_to_linker_get_host(l, closure)?;
+    crate::bindings::cli::terminal_stdout::add_to_linker_get_host(l, closure)?;
+    crate::bindings::cli::terminal_stderr::add_to_linker_get_host(l, closure)?;
+    crate::bindings::sync::sockets::tcp::add_to_linker_get_host(l, closure)?;
+    crate::bindings::sockets::tcp_create_socket::add_to_linker_get_host(l, closure)?;
+    crate::bindings::sync::sockets::udp::add_to_linker_get_host(l, closure)?;
+    crate::bindings::sockets::udp_create_socket::add_to_linker_get_host(l, closure)?;
+    crate::bindings::sockets::instance_network::add_to_linker_get_host(l, closure)?;
+    crate::bindings::sockets::network::add_to_linker_get_host(l, closure)?;
+    crate::bindings::sockets::ip_name_lookup::add_to_linker_get_host(l, closure)?;
+    Ok(())
+}
 
-    e
+// NB: workaround some rustc inference - a future refactoring may make this
+// obsolete.
+fn type_annotate<T: WasiView, F>(val: F) -> F
+where
+    F: Fn(&mut T) -> WasiImpl<&mut T>,
+{
+    val
 }
diff --git a/crates/wasi/src/network.rs b/crates/wasi/src/network.rs
new file mode 100644
index 000000000000..c435accf213f
--- /dev/null
+++ b/crates/wasi/src/network.rs
@@ -0,0 +1,113 @@
+use crate::bindings::sockets::network::{ErrorCode, Ipv4Address, Ipv6Address};
+use crate::TrappableError;
+use std::future::Future;
+use std::net::SocketAddr;
+use std::pin::Pin;
+use std::sync::Arc;
+
+pub struct Network {
+    pub socket_addr_check: SocketAddrCheck,
+    pub allow_ip_name_lookup: bool,
+}
+
+impl Network {
+    pub async fn check_socket_addr(
+        &self,
+        addr: SocketAddr,
+        reason: SocketAddrUse,
+    ) -> std::io::Result<()> {
+        self.socket_addr_check.check(addr, reason).await
+    }
+}
+
+/// A check that will be called for each socket address that is used of whether the address is permitted.
+#[derive(Clone)]
+pub struct SocketAddrCheck(
+    pub(crate)  Arc<
+        dyn Fn(SocketAddr, SocketAddrUse) -> Pin<Box<dyn Future<Output = bool> + Send + Sync>>
+            + Send
+            + Sync,
+    >,
+);
+
+impl SocketAddrCheck {
+    pub async fn check(&self, addr: SocketAddr, reason: SocketAddrUse) -> std::io::Result<()> {
+        if (self.0)(addr, reason).await {
+            Ok(())
+        } else {
+            Err(std::io::Error::new(
+                std::io::ErrorKind::PermissionDenied,
+                "An address was not permitted by the socket address check.",
+            ))
+        }
+    }
+}
+
+impl Default for SocketAddrCheck {
+    fn default() -> Self {
+        Self(Arc::new(|_, _| Box::pin(async { false })))
+    }
+}
+
+/// The reason what a socket address is being used for.
+#[derive(Clone, Copy, Debug)]
+pub enum SocketAddrUse {
+    /// Binding TCP socket
+    TcpBind,
+    /// Connecting TCP socket
+    TcpConnect,
+    /// Binding UDP socket
+    UdpBind,
+    /// Connecting UDP socket
+    UdpConnect,
+    /// Sending datagram on non-connected UDP socket
+    UdpOutgoingDatagram,
+}
+
+pub type SocketResult<T> = Result<T, SocketError>;
+
+pub type SocketError = TrappableError<ErrorCode>;
+
+impl From<wasmtime::component::ResourceTableError> for SocketError {
+    fn from(error: wasmtime::component::ResourceTableError) -> Self {
+        Self::trap(error)
+    }
+}
+
+impl From<std::io::Error> for SocketError {
+    fn from(error: std::io::Error) -> Self {
+        ErrorCode::from(error).into()
+    }
+}
+
+impl From<rustix::io::Errno> for SocketError {
+    fn from(error: rustix::io::Errno) -> Self {
+        ErrorCode::from(error).into()
+    }
+}
+
+#[derive(Copy, Clone)]
+pub enum SocketAddressFamily {
+    Ipv4,
+    Ipv6,
+}
+
+pub(crate) fn to_ipv4_addr(addr: Ipv4Address) -> std::net::Ipv4Addr {
+    let (x0, x1, x2, x3) = addr;
+    std::net::Ipv4Addr::new(x0, x1, x2, x3)
+}
+
+pub(crate) fn from_ipv4_addr(addr: std::net::Ipv4Addr) -> Ipv4Address {
+    let [x0, x1, x2, x3] = addr.octets();
+    (x0, x1, x2, x3)
+}
+
+pub(crate) fn to_ipv6_addr(addr: Ipv6Address) -> std::net::Ipv6Addr {
+    let (x0, x1, x2, x3, x4, x5, x6, x7) = addr;
+    std::net::Ipv6Addr::new(x0, x1, x2, x3, x4, x5, x6, x7)
+}
+
+pub(crate) fn from_ipv6_addr(addr: std::net::Ipv6Addr) -> Ipv6Address {
+    let [x0, x1, x2, x3, x4, x5, x6, x7] = addr.segments();
+    (x0, x1, x2, x3, x4, x5, x6, x7)
+}
diff --git a/crates/wasi/src/preview2/pipe.rs b/crates/wasi/src/pipe.rs
similarity index 96%
rename from crates/wasi/src/preview2/pipe.rs
rename to crates/wasi/src/pipe.rs
index bc8d20b1de56..4b723cc0c13a 100644
--- a/crates/wasi/src/preview2/pipe.rs
+++ b/crates/wasi/src/pipe.rs
@@ -7,14 +7,14 @@
 //! Some convenience constructors are included for common backing types like `Vec<u8>` and `String`,
 //! but the virtual pipes can be instantiated with any `Read` or `Write` type.
 //!
-use crate::preview2::poll::Subscribe;
-use crate::preview2::{HostInputStream, HostOutputStream, StreamError};
+use crate::poll::Subscribe;
+use crate::{HostInputStream, HostOutputStream, StreamError};
 use anyhow::anyhow;
 use bytes::Bytes;
 use std::sync::{Arc, Mutex};
 use tokio::sync::mpsc;
 
-pub use crate::preview2::write_stream::AsyncWriteStream;
+pub use crate::write_stream::AsyncWriteStream;
 
 #[derive(Debug, Clone)]
 pub struct MemoryInputPipe {
@@ -22,9 +22,9 @@ pub struct MemoryInputPipe {
 }
 
 impl MemoryInputPipe {
-    pub fn new(bytes: Bytes) -> Self {
+    pub fn new(bytes: impl Into<Bytes>) -> Self {
         Self {
-            buffer: Arc::new(Mutex::new(bytes)),
+            buffer: Arc::new(Mutex::new(bytes.into())),
         }
     }
 
@@ -112,15 +112,15 @@ pub struct AsyncReadStream {
     closed: bool,
     buffer: Option<Result<Bytes, StreamError>>,
     receiver: mpsc::Receiver<Result<Bytes, StreamError>>,
-    _join_handle: crate::preview2::AbortOnDropJoinHandle<()>,
+    join_handle: Option<crate::runtime::AbortOnDropJoinHandle<()>>,
 }
 
 impl AsyncReadStream {
     /// Create a [`AsyncReadStream`]. In order to use the [`HostInputStream`] impl
     /// provided by this struct, the argument must impl [`tokio::io::AsyncRead`].
-    pub fn new<T: tokio::io::AsyncRead + Send + Sync + Unpin + 'static>(mut reader: T) -> Self {
+    pub fn new<T: tokio::io::AsyncRead + Send + Unpin + 'static>(mut reader: T) -> Self {
         let (sender, receiver) = mpsc::channel(1);
-        let join_handle = crate::preview2::spawn(async move {
+        let join_handle = crate::runtime::spawn(async move {
             loop {
                 use tokio::io::AsyncReadExt;
                 let mut buf = bytes::BytesMut::with_capacity(4096);
@@ -143,7 +143,7 @@ impl AsyncReadStream {
             closed: false,
             buffer: None,
             receiver,
-            _join_handle: join_handle,
+            join_handle: Some(join_handle),
         }
     }
 }
@@ -190,6 +190,13 @@ impl HostInputStream for AsyncReadStream {
             ))),
         }
     }
+
+    async fn cancel(&mut self) {
+        match self.join_handle.take() {
+            Some(task) => _ = task.abort_wait().await,
+            None => {}
+        }
+    }
 }
 #[async_trait::async_trait]
 impl Subscribe for AsyncReadStream {
@@ -354,7 +361,7 @@ mod test {
         assert_eq!(bs.len(), 0);
     }
 
-    async fn finite_async_reader(contents: &[u8]) -> impl AsyncRead + Send + Sync + 'static {
+    async fn finite_async_reader(contents: &[u8]) -> impl AsyncRead + Send + 'static {
         let (r, mut w) = simplex(contents.len());
         w.write_all(contents).await.unwrap();
         r
@@ -459,7 +466,7 @@ mod test {
     // suitable design for all applications, and we will probably make a knob or change the
     // behavior at some point, but this test shows the behavior as it is implemented:
     async fn backpressure_read_stream() {
-        let (r, mut w) = simplex(16 * 1024); // Make sure this buffer isnt a bottleneck
+        let (r, mut w) = simplex(16 * 1024); // Make sure this buffer isn't a bottleneck
         let mut reader = AsyncReadStream::new(r);
 
         let writer_task = tokio::task::spawn(async move {
@@ -590,7 +597,7 @@ mod test {
                     "expected a LastOperationFailed before we see Closed. {write_ready_res:?}"
                 );
             }
-            // Also possible the worker hasnt processed write yet:
+            // Also possible the worker hasn't processed write yet:
             Ok(()) => {}
             Err(e) => panic!("unexpected flush error: {e:?} {write_ready_res:?}"),
         }
@@ -724,7 +731,7 @@ mod test {
         // back-pressure because now both buffers (simplex and worker) are full.
         writer.write(chunk.clone()).expect("write does not trap");
 
-        // Try shoving even more down there, and it shouldnt accept more input:
+        // Try shoving even more down there, and it shouldn't accept more input:
         writer
             .write(chunk.clone())
             .err()
@@ -789,7 +796,7 @@ mod test {
         // Writes should be refused until this flush succeeds.
         writer.flush().expect("flush succeeds");
 
-        // Try shoving even more down there, and it shouldnt accept more input:
+        // Try shoving even more down there, and it shouldn't accept more input:
         writer
             .write(chunk.clone())
             .err()
diff --git a/crates/wasi/src/poll.rs b/crates/wasi/src/poll.rs
new file mode 100644
index 000000000000..8bb51ce2878c
--- /dev/null
+++ b/crates/wasi/src/poll.rs
@@ -0,0 +1,245 @@
+use crate::{bindings::io::poll, WasiImpl, WasiView};
+use anyhow::{anyhow, Result};
+use std::any::Any;
+use std::collections::HashMap;
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use wasmtime::component::{Resource, ResourceTable};
+
+pub type PollableFuture<'a> = Pin<Box<dyn Future<Output = ()> + Send + 'a>>;
+pub type MakeFuture = for<'a> fn(&'a mut dyn Any) -> PollableFuture<'a>;
+pub type ClosureFuture = Box<dyn Fn() -> PollableFuture<'static> + Send + 'static>;
+
+/// A host representation of the `wasi:io/poll.pollable` resource.
+///
+/// A pollable is not the same thing as a Rust Future: the same pollable may be used to
+/// repeatedly check for readiness of a given condition, e.g. if a stream is readable
+/// or writable. So, rather than containing a Future, which can only become Ready once, a
+/// Pollable contains a way to create a Future in each call to `poll`.
+pub struct Pollable {
+    index: u32,
+    make_future: MakeFuture,
+    remove_index_on_delete: Option<fn(&mut ResourceTable, u32) -> Result<()>>,
+}
+
+/// A trait used internally within a [`Pollable`] to create a `pollable`
+/// resource in `wasi:io/poll`.
+///
+/// This trait is the internal implementation detail of any pollable resource in
+/// this crate's implementation of WASI. The `ready` function is an `async fn`
+/// which resolves when the implementation is ready. Using native `async` Rust
+/// enables this type's readiness to compose with other types' readiness
+/// throughout the WASI implementation.
+///
+/// This trait is used in conjunction with [`subscribe`] to create a `pollable`
+/// resource.
+///
+/// # Example
+///
+/// This is a simple example of creating a `Pollable` resource from a few
+/// parameters.
+///
+/// ```
+/// use tokio::time::{self, Duration, Instant};
+/// use wasmtime_wasi::{WasiView, Subscribe, subscribe, Pollable, async_trait};
+/// use wasmtime::component::Resource;
+/// use wasmtime::Result;
+///
+/// fn sleep(cx: &mut dyn WasiView, dur: Duration) -> Result<Resource<Pollable>> {
+///     let end = Instant::now() + dur;
+///     let sleep = MySleep { end };
+///     let sleep_resource = cx.table().push(sleep)?;
+///     subscribe(cx.table(), sleep_resource)
+/// }
+///
+/// struct MySleep {
+///     end: Instant,
+/// }
+///
+/// #[async_trait]
+/// impl Subscribe for MySleep {
+///     async fn ready(&mut self) {
+///         tokio::time::sleep_until(self.end).await;
+///     }
+/// }
+/// ```
+#[async_trait::async_trait]
+pub trait Subscribe: Send + 'static {
+    /// An asynchronous function which resolves when this object's readiness
+    /// operation is ready.
+    ///
+    /// This function is invoked as part of `poll` in `wasi:io/poll`. The
+    /// meaning of when this function Returns depends on what object this
+    /// [`Subscribe`] is attached to. When the returned future resolves then the
+    /// corresponding call to `wasi:io/poll` will return.
+    ///
+    /// Note that this method does not return an error. Returning an error
+    /// should be done through accessors on the object that this `pollable` is
+    /// connected to. The call to `wasi:io/poll` itself does not return errors,
+    /// only a list of ready objects.
+    async fn ready(&mut self);
+}
+
+/// Creates a `pollable` resource which is subscribed to the provided
+/// `resource`.
+///
+/// If `resource` is an owned resource then it will be deleted when the returned
+/// resource is deleted. Otherwise the returned resource is considered a "child"
+/// of the given `resource` which means that the given resource cannot be
+/// deleted while the `pollable` is still alive.
+pub fn subscribe<T>(table: &mut ResourceTable, resource: Resource<T>) -> Result<Resource<Pollable>>
+where
+    T: Subscribe,
+{
+    fn make_future<'a, T>(stream: &'a mut dyn Any) -> PollableFuture<'a>
+    where
+        T: Subscribe,
+    {
+        stream.downcast_mut::<T>().unwrap().ready()
+    }
+
+    let pollable = Pollable {
+        index: resource.rep(),
+        remove_index_on_delete: if resource.owned() {
+            Some(|table, idx| {
+                let resource = Resource::<T>::new_own(idx);
+                table.delete(resource)?;
+                Ok(())
+            })
+        } else {
+            None
+        },
+        make_future: make_future::<T>,
+    };
+
+    Ok(table.push_child(pollable, &resource)?)
+}
+
+#[async_trait::async_trait]
+impl<T> poll::Host for WasiImpl<T>
+where
+    T: WasiView,
+{
+    async fn poll(&mut self, pollables: Vec<Resource<Pollable>>) -> Result<Vec<u32>> {
+        type ReadylistIndex = u32;
+
+        if pollables.is_empty() {
+            return Err(anyhow!("empty poll list"));
+        }
+
+        let table = self.table();
+
+        let mut table_futures: HashMap<u32, (MakeFuture, Vec<ReadylistIndex>)> = HashMap::new();
+
+        for (ix, p) in pollables.iter().enumerate() {
+            let ix: u32 = ix.try_into()?;
+
+            let pollable = table.get(p)?;
+            let (_, list) = table_futures
+                .entry(pollable.index)
+                .or_insert((pollable.make_future, Vec::new()));
+            list.push(ix);
+        }
+
+        let mut futures: Vec<(PollableFuture<'_>, Vec<ReadylistIndex>)> = Vec::new();
+        for (entry, (make_future, readylist_indices)) in table.iter_entries(table_futures) {
+            let entry = entry?;
+            futures.push((make_future(entry), readylist_indices));
+        }
+
+        struct PollList<'a> {
+            futures: Vec<(PollableFuture<'a>, Vec<ReadylistIndex>)>,
+        }
+        impl<'a> Future for PollList<'a> {
+            type Output = Vec<u32>;
+
+            fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+                let mut any_ready = false;
+                let mut results = Vec::new();
+                for (fut, readylist_indicies) in self.futures.iter_mut() {
+                    match fut.as_mut().poll(cx) {
+                        Poll::Ready(()) => {
+                            results.extend_from_slice(readylist_indicies);
+                            any_ready = true;
+                        }
+                        Poll::Pending => {}
+                    }
+                }
+                if any_ready {
+                    Poll::Ready(results)
+                } else {
+                    Poll::Pending
+                }
+            }
+        }
+
+        Ok(PollList { futures }.await)
+    }
+}
+
+#[async_trait::async_trait]
+impl<T> crate::bindings::io::poll::HostPollable for WasiImpl<T>
+where
+    T: WasiView,
+{
+    async fn block(&mut self, pollable: Resource<Pollable>) -> Result<()> {
+        let table = self.table();
+        let pollable = table.get(&pollable)?;
+        let ready = (pollable.make_future)(table.get_any_mut(pollable.index)?);
+        ready.await;
+        Ok(())
+    }
+    async fn ready(&mut self, pollable: Resource<Pollable>) -> Result<bool> {
+        let table = self.table();
+        let pollable = table.get(&pollable)?;
+        let ready = (pollable.make_future)(table.get_any_mut(pollable.index)?);
+        futures::pin_mut!(ready);
+        Ok(matches!(
+            futures::future::poll_immediate(ready).await,
+            Some(())
+        ))
+    }
+    fn drop(&mut self, pollable: Resource<Pollable>) -> Result<()> {
+        let pollable = self.table().delete(pollable)?;
+        if let Some(delete) = pollable.remove_index_on_delete {
+            delete(self.table(), pollable.index)?;
+        }
+        Ok(())
+    }
+}
+
+pub mod sync {
+    use crate::{
+        bindings::io::poll as async_poll,
+        bindings::sync::io::poll::{self, Pollable},
+        runtime::in_tokio,
+        WasiImpl, WasiView,
+    };
+    use anyhow::Result;
+    use wasmtime::component::Resource;
+
+    impl<T> poll::Host for WasiImpl<T>
+    where
+        T: WasiView,
+    {
+        fn poll(&mut self, pollables: Vec<Resource<Pollable>>) -> Result<Vec<u32>> {
+            in_tokio(async { async_poll::Host::poll(self, pollables).await })
+        }
+    }
+
+    impl<T> crate::bindings::sync::io::poll::HostPollable for WasiImpl<T>
+    where
+        T: WasiView,
+    {
+        fn ready(&mut self, pollable: Resource<Pollable>) -> Result<bool> {
+            in_tokio(async { async_poll::HostPollable::ready(self, pollable).await })
+        }
+        fn block(&mut self, pollable: Resource<Pollable>) -> Result<()> {
+            in_tokio(async { async_poll::HostPollable::block(self, pollable).await })
+        }
+        fn drop(&mut self, pollable: Resource<Pollable>) -> Result<()> {
+            async_poll::HostPollable::drop(self, pollable)
+        }
+    }
+}
diff --git a/crates/wasi/src/preview0.rs b/crates/wasi/src/preview0.rs
new file mode 100644
index 000000000000..038b98b40df2
--- /dev/null
+++ b/crates/wasi/src/preview0.rs
@@ -0,0 +1,983 @@
+//! Bindings for WASIp0 aka Preview 0 aka `wasi_unstable`.
+//!
+//! This module is purely here for backwards compatibility in the Wasmtime CLI.
+//! You probably want to use [`preview1`](crate::preview1) instead.
+
+use crate::preview0::types::Error;
+use crate::preview1::types as snapshot1_types;
+use crate::preview1::wasi_snapshot_preview1::WasiSnapshotPreview1 as Snapshot1;
+use crate::preview1::WasiP1Ctx;
+use wiggle::{GuestError, GuestMemory, GuestPtr};
+
+pub fn add_to_linker_async<T: Send>(
+    linker: &mut wasmtime::Linker<T>,
+    f: impl Fn(&mut T) -> &mut WasiP1Ctx + Copy + Send + Sync + 'static,
+) -> anyhow::Result<()> {
+    wasi_unstable::add_to_linker(linker, f)
+}
+
+pub fn add_to_linker_sync<T: Send>(
+    linker: &mut wasmtime::Linker<T>,
+    f: impl Fn(&mut T) -> &mut WasiP1Ctx + Copy + Send + Sync + 'static,
+) -> anyhow::Result<()> {
+    sync::add_wasi_unstable_to_linker(linker, f)
+}
+
+wiggle::from_witx!({
+    witx: ["$CARGO_MANIFEST_DIR/witx/preview0/wasi_unstable.witx"],
+    async: {
+        wasi_unstable::{
+            fd_advise, fd_close, fd_datasync, fd_fdstat_get, fd_filestat_get, fd_filestat_set_size,
+            fd_filestat_set_times, fd_read, fd_pread, fd_seek, fd_sync, fd_readdir, fd_write,
+            fd_pwrite, poll_oneoff, path_create_directory, path_filestat_get,
+            path_filestat_set_times, path_link, path_open, path_readlink, path_remove_directory,
+            path_rename, path_symlink, path_unlink_file
+        }
+    },
+    errors: { errno => trappable Error },
+});
+
+mod sync {
+    use anyhow::Result;
+    use std::future::Future;
+
+    wiggle::wasmtime_integration!({
+        witx: ["$CARGO_MANIFEST_DIR/witx/preview0/wasi_unstable.witx"],
+        target: super,
+        block_on[in_tokio]: {
+            wasi_unstable::{
+                fd_advise, fd_close, fd_datasync, fd_fdstat_get, fd_filestat_get, fd_filestat_set_size,
+                fd_filestat_set_times, fd_read, fd_pread, fd_seek, fd_sync, fd_readdir, fd_write,
+                fd_pwrite, poll_oneoff, path_create_directory, path_filestat_get,
+                path_filestat_set_times, path_link, path_open, path_readlink, path_remove_directory,
+                path_rename, path_symlink, path_unlink_file
+            }
+        },
+        errors: { errno => trappable Error },
+    });
+
+    // Small wrapper around `in_tokio` to add a `Result` layer which is always
+    // `Ok`
+    fn in_tokio<F: Future>(future: F) -> Result<F::Output> {
+        Ok(crate::runtime::in_tokio(future))
+    }
+}
+
+impl wiggle::GuestErrorType for types::Errno {
+    fn success() -> Self {
+        Self::Success
+    }
+}
+
+#[wiggle::async_trait]
+impl<T: Snapshot1 + Send> wasi_unstable::WasiUnstable for T {
+    fn args_get(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        argv: GuestPtr<GuestPtr<u8>>,
+        argv_buf: GuestPtr<u8>,
+    ) -> Result<(), Error> {
+        Snapshot1::args_get(self, memory, argv, argv_buf)?;
+        Ok(())
+    }
+
+    fn args_sizes_get(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+    ) -> Result<(types::Size, types::Size), Error> {
+        let s = Snapshot1::args_sizes_get(self, memory)?;
+        Ok(s)
+    }
+
+    fn environ_get(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        environ: GuestPtr<GuestPtr<u8>>,
+        environ_buf: GuestPtr<u8>,
+    ) -> Result<(), Error> {
+        Snapshot1::environ_get(self, memory, environ, environ_buf)?;
+        Ok(())
+    }
+
+    fn environ_sizes_get(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+    ) -> Result<(types::Size, types::Size), Error> {
+        let s = Snapshot1::environ_sizes_get(self, memory)?;
+        Ok(s)
+    }
+
+    fn clock_res_get(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        id: types::Clockid,
+    ) -> Result<types::Timestamp, Error> {
+        let t = Snapshot1::clock_res_get(self, memory, id.into())?;
+        Ok(t)
+    }
+
+    fn clock_time_get(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        id: types::Clockid,
+        precision: types::Timestamp,
+    ) -> Result<types::Timestamp, Error> {
+        let t = Snapshot1::clock_time_get(self, memory, id.into(), precision)?;
+        Ok(t)
+    }
+
+    async fn fd_advise(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        offset: types::Filesize,
+        len: types::Filesize,
+        advice: types::Advice,
+    ) -> Result<(), Error> {
+        Snapshot1::fd_advise(self, memory, fd.into(), offset, len, advice.into()).await?;
+        Ok(())
+    }
+
+    fn fd_allocate(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        offset: types::Filesize,
+        len: types::Filesize,
+    ) -> Result<(), Error> {
+        Snapshot1::fd_allocate(self, memory, fd.into(), offset, len)?;
+        Ok(())
+    }
+
+    async fn fd_close(&mut self, memory: &mut GuestMemory<'_>, fd: types::Fd) -> Result<(), Error> {
+        Snapshot1::fd_close(self, memory, fd.into()).await?;
+        Ok(())
+    }
+
+    async fn fd_datasync(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+    ) -> Result<(), Error> {
+        Snapshot1::fd_datasync(self, memory, fd.into()).await?;
+        Ok(())
+    }
+
+    async fn fd_fdstat_get(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+    ) -> Result<types::Fdstat, Error> {
+        Ok(Snapshot1::fd_fdstat_get(self, memory, fd.into())
+            .await?
+            .into())
+    }
+
+    fn fd_fdstat_set_flags(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        flags: types::Fdflags,
+    ) -> Result<(), Error> {
+        Snapshot1::fd_fdstat_set_flags(self, memory, fd.into(), flags.into())?;
+        Ok(())
+    }
+
+    fn fd_fdstat_set_rights(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        fs_rights_base: types::Rights,
+        fs_rights_inheriting: types::Rights,
+    ) -> Result<(), Error> {
+        Snapshot1::fd_fdstat_set_rights(
+            self,
+            memory,
+            fd.into(),
+            fs_rights_base.into(),
+            fs_rights_inheriting.into(),
+        )?;
+        Ok(())
+    }
+
+    async fn fd_filestat_get(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+    ) -> Result<types::Filestat, Error> {
+        Ok(Snapshot1::fd_filestat_get(self, memory, fd.into())
+            .await?
+            .into())
+    }
+
+    async fn fd_filestat_set_size(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        size: types::Filesize,
+    ) -> Result<(), Error> {
+        Snapshot1::fd_filestat_set_size(self, memory, fd.into(), size).await?;
+        Ok(())
+    }
+
+    async fn fd_filestat_set_times(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        atim: types::Timestamp,
+        mtim: types::Timestamp,
+        fst_flags: types::Fstflags,
+    ) -> Result<(), Error> {
+        Snapshot1::fd_filestat_set_times(self, memory, fd.into(), atim, mtim, fst_flags.into())
+            .await?;
+        Ok(())
+    }
+
+    async fn fd_read(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        iovs: types::IovecArray,
+    ) -> Result<types::Size, Error> {
+        assert_iovec_array_same();
+        let result = Snapshot1::fd_read(self, memory, fd.into(), iovs.cast()).await?;
+        Ok(result)
+    }
+
+    async fn fd_pread(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        iovs: types::IovecArray,
+        offset: types::Filesize,
+    ) -> Result<types::Size, Error> {
+        assert_iovec_array_same();
+        let result = Snapshot1::fd_pread(self, memory, fd.into(), iovs.cast(), offset).await?;
+        Ok(result)
+    }
+
+    async fn fd_write(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        ciovs: types::CiovecArray,
+    ) -> Result<types::Size, Error> {
+        assert_ciovec_array_same();
+        let result = Snapshot1::fd_write(self, memory, fd.into(), ciovs.cast()).await?;
+        Ok(result)
+    }
+
+    async fn fd_pwrite(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        ciovs: types::CiovecArray,
+        offset: types::Filesize,
+    ) -> Result<types::Size, Error> {
+        assert_ciovec_array_same();
+        let result = Snapshot1::fd_pwrite(self, memory, fd.into(), ciovs.cast(), offset).await?;
+        Ok(result)
+    }
+
+    fn fd_prestat_get(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+    ) -> Result<types::Prestat, Error> {
+        Ok(Snapshot1::fd_prestat_get(self, memory, fd.into())?.into())
+    }
+
+    fn fd_prestat_dir_name(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        path: GuestPtr<u8>,
+        path_max_len: types::Size,
+    ) -> Result<(), Error> {
+        Snapshot1::fd_prestat_dir_name(self, memory, fd.into(), path, path_max_len)?;
+        Ok(())
+    }
+
+    fn fd_renumber(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        from: types::Fd,
+        to: types::Fd,
+    ) -> Result<(), Error> {
+        Snapshot1::fd_renumber(self, memory, from.into(), to.into())?;
+        Ok(())
+    }
+
+    async fn fd_seek(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        offset: types::Filedelta,
+        whence: types::Whence,
+    ) -> Result<types::Filesize, Error> {
+        Ok(Snapshot1::fd_seek(self, memory, fd.into(), offset, whence.into()).await?)
+    }
+
+    async fn fd_sync(&mut self, memory: &mut GuestMemory<'_>, fd: types::Fd) -> Result<(), Error> {
+        Snapshot1::fd_sync(self, memory, fd.into()).await?;
+        Ok(())
+    }
+
+    fn fd_tell(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+    ) -> Result<types::Filesize, Error> {
+        Ok(Snapshot1::fd_tell(self, memory, fd.into())?)
+    }
+
+    async fn fd_readdir(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        buf: GuestPtr<u8>,
+        buf_len: types::Size,
+        cookie: types::Dircookie,
+    ) -> Result<types::Size, Error> {
+        Ok(Snapshot1::fd_readdir(self, memory, fd.into(), buf, buf_len, cookie).await?)
+    }
+
+    async fn path_create_directory(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        dirfd: types::Fd,
+        path: GuestPtr<str>,
+    ) -> Result<(), Error> {
+        Snapshot1::path_create_directory(self, memory, dirfd.into(), path).await?;
+        Ok(())
+    }
+
+    async fn path_filestat_get(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        dirfd: types::Fd,
+        flags: types::Lookupflags,
+        path: GuestPtr<str>,
+    ) -> Result<types::Filestat, Error> {
+        Ok(
+            Snapshot1::path_filestat_get(self, memory, dirfd.into(), flags.into(), path)
+                .await?
+                .into(),
+        )
+    }
+
+    async fn path_filestat_set_times(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        dirfd: types::Fd,
+        flags: types::Lookupflags,
+        path: GuestPtr<str>,
+        atim: types::Timestamp,
+        mtim: types::Timestamp,
+        fst_flags: types::Fstflags,
+    ) -> Result<(), Error> {
+        Snapshot1::path_filestat_set_times(
+            self,
+            memory,
+            dirfd.into(),
+            flags.into(),
+            path,
+            atim,
+            mtim,
+            fst_flags.into(),
+        )
+        .await?;
+        Ok(())
+    }
+
+    async fn path_link(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        src_fd: types::Fd,
+        src_flags: types::Lookupflags,
+        src_path: GuestPtr<str>,
+        target_fd: types::Fd,
+        target_path: GuestPtr<str>,
+    ) -> Result<(), Error> {
+        Snapshot1::path_link(
+            self,
+            memory,
+            src_fd.into(),
+            src_flags.into(),
+            src_path,
+            target_fd.into(),
+            target_path,
+        )
+        .await?;
+        Ok(())
+    }
+
+    async fn path_open(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        dirfd: types::Fd,
+        dirflags: types::Lookupflags,
+        path: GuestPtr<str>,
+        oflags: types::Oflags,
+        fs_rights_base: types::Rights,
+        fs_rights_inheriting: types::Rights,
+        fdflags: types::Fdflags,
+    ) -> Result<types::Fd, Error> {
+        Ok(Snapshot1::path_open(
+            self,
+            memory,
+            dirfd.into(),
+            dirflags.into(),
+            path,
+            oflags.into(),
+            fs_rights_base.into(),
+            fs_rights_inheriting.into(),
+            fdflags.into(),
+        )
+        .await?
+        .into())
+    }
+
+    async fn path_readlink(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        dirfd: types::Fd,
+        path: GuestPtr<str>,
+        buf: GuestPtr<u8>,
+        buf_len: types::Size,
+    ) -> Result<types::Size, Error> {
+        Ok(Snapshot1::path_readlink(self, memory, dirfd.into(), path, buf, buf_len).await?)
+    }
+
+    async fn path_remove_directory(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        dirfd: types::Fd,
+        path: GuestPtr<str>,
+    ) -> Result<(), Error> {
+        Snapshot1::path_remove_directory(self, memory, dirfd.into(), path).await?;
+        Ok(())
+    }
+
+    async fn path_rename(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        src_fd: types::Fd,
+        src_path: GuestPtr<str>,
+        dest_fd: types::Fd,
+        dest_path: GuestPtr<str>,
+    ) -> Result<(), Error> {
+        Snapshot1::path_rename(
+            self,
+            memory,
+            src_fd.into(),
+            src_path,
+            dest_fd.into(),
+            dest_path,
+        )
+        .await?;
+        Ok(())
+    }
+
+    async fn path_symlink(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        src_path: GuestPtr<str>,
+        dirfd: types::Fd,
+        dest_path: GuestPtr<str>,
+    ) -> Result<(), Error> {
+        Snapshot1::path_symlink(self, memory, src_path, dirfd.into(), dest_path).await?;
+        Ok(())
+    }
+
+    async fn path_unlink_file(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        dirfd: types::Fd,
+        path: GuestPtr<str>,
+    ) -> Result<(), Error> {
+        Snapshot1::path_unlink_file(self, memory, dirfd.into(), path).await?;
+        Ok(())
+    }
+
+    // The representation of `SubscriptionClock` is different in preview0 and
+    // preview1 so a bit of a hack is employed here. The change was to remove a
+    // field from `SubscriptionClock` so to implement this without copying too
+    // much the `subs` field is overwritten with preview1-compatible structures
+    // and then the preview1 implementation is used. Before returning though
+    // the old values are restored to pretend like we didn't overwrite them.
+    //
+    // Surely no one would pass overlapping pointers to this API right?
+    async fn poll_oneoff(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        subs: GuestPtr<types::Subscription>,
+        events: GuestPtr<types::Event>,
+        nsubscriptions: types::Size,
+    ) -> Result<types::Size, Error> {
+        let subs_array = subs.as_array(nsubscriptions);
+        let mut old_subs = Vec::new();
+        for slot in subs_array.iter() {
+            let slot = slot?;
+            let sub = memory.read(slot)?;
+            old_subs.push(sub.clone());
+            memory.write(
+                slot.cast(),
+                snapshot1_types::Subscription {
+                    userdata: sub.userdata,
+                    u: match sub.u {
+                        types::SubscriptionU::Clock(c) => {
+                            snapshot1_types::SubscriptionU::Clock(c.into())
+                        }
+                        types::SubscriptionU::FdRead(c) => {
+                            snapshot1_types::SubscriptionU::FdRead(c.into())
+                        }
+                        types::SubscriptionU::FdWrite(c) => {
+                            snapshot1_types::SubscriptionU::FdWrite(c.into())
+                        }
+                    },
+                },
+            )?;
+        }
+        let ret = Snapshot1::poll_oneoff(self, memory, subs.cast(), events.cast(), nsubscriptions)
+            .await?;
+        for (sub, slot) in old_subs.into_iter().zip(subs_array.iter()) {
+            memory.write(slot?, sub)?;
+        }
+        Ok(ret)
+    }
+
+    fn proc_exit(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        status: types::Exitcode,
+    ) -> anyhow::Error {
+        Snapshot1::proc_exit(self, memory, status)
+    }
+
+    fn proc_raise(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        sig: types::Signal,
+    ) -> Result<(), Error> {
+        Snapshot1::proc_raise(self, memory, sig.into())?;
+        Ok(())
+    }
+
+    fn sched_yield(&mut self, memory: &mut GuestMemory<'_>) -> Result<(), Error> {
+        Snapshot1::sched_yield(self, memory)?;
+        Ok(())
+    }
+
+    fn random_get(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        buf: GuestPtr<u8>,
+        buf_len: types::Size,
+    ) -> Result<(), Error> {
+        Snapshot1::random_get(self, memory, buf, buf_len)?;
+        Ok(())
+    }
+
+    fn sock_recv(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        _fd: types::Fd,
+        _ri_data: types::IovecArray,
+        _ri_flags: types::Riflags,
+    ) -> Result<(types::Size, types::Roflags), Error> {
+        Err(Error::trap(anyhow::Error::msg("sock_recv unsupported")))
+    }
+
+    fn sock_send(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        _fd: types::Fd,
+        _si_data: types::CiovecArray,
+        _si_flags: types::Siflags,
+    ) -> Result<types::Size, Error> {
+        Err(Error::trap(anyhow::Error::msg("sock_send unsupported")))
+    }
+
+    fn sock_shutdown(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        _fd: types::Fd,
+        _how: types::Sdflags,
+    ) -> Result<(), Error> {
+        Err(Error::trap(anyhow::Error::msg("sock_shutdown unsupported")))
+    }
+}
+
+fn assert_iovec_array_same() {
+    // NB: this isn't enough to assert the types are the same, but it's
+    // something. Additionally preview1 and preview0 aren't changing any more
+    // and it's been manually verified that these two types are the same, so
+    // it's ok to cast between them.
+    assert_eq!(
+        std::mem::size_of::<types::IovecArray>(),
+        std::mem::size_of::<snapshot1_types::IovecArray>()
+    );
+}
+
+fn assert_ciovec_array_same() {
+    // NB: see above too
+    assert_eq!(
+        std::mem::size_of::<types::CiovecArray>(),
+        std::mem::size_of::<snapshot1_types::CiovecArray>()
+    );
+}
+
+impl From<snapshot1_types::Error> for Error {
+    fn from(error: snapshot1_types::Error) -> Error {
+        match error.downcast() {
+            Ok(errno) => Error::from(types::Errno::from(errno)),
+            Err(trap) => Error::trap(trap),
+        }
+    }
+}
+
+/// Fd is a newtype wrapper around u32. Unwrap and wrap it.
+impl From<types::Fd> for snapshot1_types::Fd {
+    fn from(fd: types::Fd) -> snapshot1_types::Fd {
+        u32::from(fd).into()
+    }
+}
+
+/// Fd is a newtype wrapper around u32. Unwrap and wrap it.
+impl From<snapshot1_types::Fd> for types::Fd {
+    fn from(fd: snapshot1_types::Fd) -> types::Fd {
+        u32::from(fd).into()
+    }
+}
+
+/// Trivial conversion between two c-style enums that have the exact same set of variants.
+/// Could we do something unsafe and not list all these variants out? Probably, but doing
+/// it this way doesn't bother me much. I copy-pasted the list of variants out of the
+/// rendered rustdocs.
+/// LLVM ought to compile these From impls into no-ops, inshallah
+macro_rules! convert_enum {
+    ($from:ty, $to:ty, $($var:ident),+) => {
+        impl From<$from> for $to {
+            fn from(e: $from) -> $to {
+                match e {
+                    $( <$from>::$var => <$to>::$var, )+
+                }
+            }
+        }
+    }
+}
+convert_enum!(
+    snapshot1_types::Errno,
+    types::Errno,
+    Success,
+    TooBig,
+    Acces,
+    Addrinuse,
+    Addrnotavail,
+    Afnosupport,
+    Again,
+    Already,
+    Badf,
+    Badmsg,
+    Busy,
+    Canceled,
+    Child,
+    Connaborted,
+    Connrefused,
+    Connreset,
+    Deadlk,
+    Destaddrreq,
+    Dom,
+    Dquot,
+    Exist,
+    Fault,
+    Fbig,
+    Hostunreach,
+    Idrm,
+    Ilseq,
+    Inprogress,
+    Intr,
+    Inval,
+    Io,
+    Isconn,
+    Isdir,
+    Loop,
+    Mfile,
+    Mlink,
+    Msgsize,
+    Multihop,
+    Nametoolong,
+    Netdown,
+    Netreset,
+    Netunreach,
+    Nfile,
+    Nobufs,
+    Nodev,
+    Noent,
+    Noexec,
+    Nolck,
+    Nolink,
+    Nomem,
+    Nomsg,
+    Noprotoopt,
+    Nospc,
+    Nosys,
+    Notconn,
+    Notdir,
+    Notempty,
+    Notrecoverable,
+    Notsock,
+    Notsup,
+    Notty,
+    Nxio,
+    Overflow,
+    Ownerdead,
+    Perm,
+    Pipe,
+    Proto,
+    Protonosupport,
+    Prototype,
+    Range,
+    Rofs,
+    Spipe,
+    Srch,
+    Stale,
+    Timedout,
+    Txtbsy,
+    Xdev,
+    Notcapable
+);
+convert_enum!(
+    types::Clockid,
+    snapshot1_types::Clockid,
+    Realtime,
+    Monotonic,
+    ProcessCputimeId,
+    ThreadCputimeId
+);
+
+convert_enum!(
+    types::Advice,
+    snapshot1_types::Advice,
+    Normal,
+    Sequential,
+    Random,
+    Willneed,
+    Dontneed,
+    Noreuse
+);
+convert_enum!(
+    snapshot1_types::Filetype,
+    types::Filetype,
+    Directory,
+    BlockDevice,
+    CharacterDevice,
+    RegularFile,
+    SocketDgram,
+    SocketStream,
+    SymbolicLink,
+    Unknown
+);
+convert_enum!(types::Whence, snapshot1_types::Whence, Cur, End, Set);
+
+convert_enum!(
+    types::Signal,
+    snapshot1_types::Signal,
+    None,
+    Hup,
+    Int,
+    Quit,
+    Ill,
+    Trap,
+    Abrt,
+    Bus,
+    Fpe,
+    Kill,
+    Usr1,
+    Segv,
+    Usr2,
+    Pipe,
+    Alrm,
+    Term,
+    Chld,
+    Cont,
+    Stop,
+    Tstp,
+    Ttin,
+    Ttou,
+    Urg,
+    Xcpu,
+    Xfsz,
+    Vtalrm,
+    Prof,
+    Winch,
+    Poll,
+    Pwr,
+    Sys
+);
+
+/// Prestat isn't a c-style enum, its a union where the variant has a payload. Its the only one of
+/// those we need to convert, so write it by hand.
+impl From<snapshot1_types::Prestat> for types::Prestat {
+    fn from(p: snapshot1_types::Prestat) -> types::Prestat {
+        match p {
+            snapshot1_types::Prestat::Dir(d) => types::Prestat::Dir(d.into()),
+        }
+    }
+}
+
+/// Trivial conversion between two structs that have the exact same set of fields,
+/// with recursive descent into the field types.
+macro_rules! convert_struct {
+    ($from:ty, $to:path, $($field:ident),+) => {
+        impl From<$from> for $to {
+            fn from(e: $from) -> $to {
+                $to {
+                    $( $field: e.$field.into(), )+
+                }
+            }
+        }
+    }
+}
+
+convert_struct!(snapshot1_types::PrestatDir, types::PrestatDir, pr_name_len);
+convert_struct!(
+    snapshot1_types::Fdstat,
+    types::Fdstat,
+    fs_filetype,
+    fs_rights_base,
+    fs_rights_inheriting,
+    fs_flags
+);
+convert_struct!(
+    types::SubscriptionClock,
+    snapshot1_types::SubscriptionClock,
+    id,
+    timeout,
+    precision,
+    flags
+);
+convert_struct!(
+    types::SubscriptionFdReadwrite,
+    snapshot1_types::SubscriptionFdReadwrite,
+    file_descriptor
+);
+
+/// Snapshot1 Filestat is incompatible with Snapshot0 Filestat - the nlink
+/// field is u32 on this Filestat, and u64 on theirs. If you've got more than
+/// 2^32 links I don't know what to tell you
+impl From<snapshot1_types::Filestat> for types::Filestat {
+    fn from(f: snapshot1_types::Filestat) -> types::Filestat {
+        types::Filestat {
+            dev: f.dev.into(),
+            ino: f.ino.into(),
+            filetype: f.filetype.into(),
+            nlink: f.nlink.try_into().unwrap_or(u32::MAX),
+            size: f.size.into(),
+            atim: f.atim.into(),
+            mtim: f.mtim.into(),
+            ctim: f.ctim.into(),
+        }
+    }
+}
+
+/// Trivial conversion between two bitflags that have the exact same set of flags.
+macro_rules! convert_flags {
+    ($from:ty, $to:ty, $($flag:ident),+) => {
+        impl From<$from> for $to {
+            fn from(f: $from) -> $to {
+                let mut out = <$to>::empty();
+                $(
+                    if f.contains(<$from>::$flag) {
+                        out |= <$to>::$flag;
+                    }
+                )+
+                out
+            }
+        }
+    }
+}
+
+/// Need to convert in both directions? This saves listing out the flags twice
+macro_rules! convert_flags_bidirectional {
+    ($from:ty, $to:ty, $($flag:tt)*) => {
+        convert_flags!($from, $to, $($flag)*);
+        convert_flags!($to, $from, $($flag)*);
+    }
+}
+
+convert_flags_bidirectional!(
+    snapshot1_types::Fdflags,
+    types::Fdflags,
+    APPEND,
+    DSYNC,
+    NONBLOCK,
+    RSYNC,
+    SYNC
+);
+convert_flags!(
+    types::Lookupflags,
+    snapshot1_types::Lookupflags,
+    SYMLINK_FOLLOW
+);
+convert_flags!(
+    types::Fstflags,
+    snapshot1_types::Fstflags,
+    ATIM,
+    ATIM_NOW,
+    MTIM,
+    MTIM_NOW
+);
+convert_flags!(
+    types::Oflags,
+    snapshot1_types::Oflags,
+    CREAT,
+    DIRECTORY,
+    EXCL,
+    TRUNC
+);
+convert_flags_bidirectional!(
+    types::Rights,
+    snapshot1_types::Rights,
+    FD_DATASYNC,
+    FD_READ,
+    FD_SEEK,
+    FD_FDSTAT_SET_FLAGS,
+    FD_SYNC,
+    FD_TELL,
+    FD_WRITE,
+    FD_ADVISE,
+    FD_ALLOCATE,
+    PATH_CREATE_DIRECTORY,
+    PATH_CREATE_FILE,
+    PATH_LINK_SOURCE,
+    PATH_LINK_TARGET,
+    PATH_OPEN,
+    FD_READDIR,
+    PATH_READLINK,
+    PATH_RENAME_SOURCE,
+    PATH_RENAME_TARGET,
+    PATH_FILESTAT_GET,
+    PATH_FILESTAT_SET_SIZE,
+    PATH_FILESTAT_SET_TIMES,
+    FD_FILESTAT_GET,
+    FD_FILESTAT_SET_SIZE,
+    FD_FILESTAT_SET_TIMES,
+    PATH_SYMLINK,
+    PATH_REMOVE_DIRECTORY,
+    PATH_UNLINK_FILE,
+    POLL_FD_READWRITE,
+    SOCK_SHUTDOWN
+);
+convert_flags!(
+    types::Subclockflags,
+    snapshot1_types::Subclockflags,
+    SUBSCRIPTION_CLOCK_ABSTIME
+);
+
+impl From<GuestError> for types::Error {
+    fn from(err: GuestError) -> Self {
+        snapshot1_types::Error::from(err).into()
+    }
+}
diff --git a/crates/wasi/src/preview1.rs b/crates/wasi/src/preview1.rs
new file mode 100644
index 000000000000..62022ab109e5
--- /dev/null
+++ b/crates/wasi/src/preview1.rs
@@ -0,0 +1,2764 @@
+//! Bindings for WASIp1 aka Preview 1 aka `wasi_snapshot_preview1`.
+//!
+//! This module contains runtime support for configuring and executing
+//! WASIp1-using core WebAssembly modules. Support for WASIp1 is built on top of
+//! support for WASIp2 available at [the crate root](crate), but that's just an
+//! internal implementation detail.
+//!
+//! Unlike the crate root, support for WASIp1 centers around two APIs:
+//!
+//! * [`WasiP1Ctx`]
+//! * [`add_to_linker_sync`] (or [`add_to_linker_async`])
+//!
+//! First a [`WasiCtxBuilder`] will be used and finalized with the [`build_p1`]
+//! method to create a [`WasiCtx`]. Next a [`wasmtime::Linker`] is configured
+//! with WASI imports by using the `add_to_linker_*` desired (sync or async
+//! depending on [`Config::async_support`]).
+//!
+//! Note that WASIp1 is not as extensible or configurable as WASIp2 so the
+//! support in this module is enough to run wasm modules but any customization
+//! beyond that [`WasiCtxBuilder`] already supports is not possible yet.
+//!
+//! [`WasiCtxBuilder`]: crate::WasiCtxBuilder
+//! [`build_p1`]: crate::WasiCtxBuilder::build_p1
+//! [`Config::async_support`]: wasmtime::Config::async_support
+//!
+//! # Components vs Modules
+//!
+//! Note that WASIp1 does not work for components at this time, only core wasm
+//! modules. That means this module is only for users of [`wasmtime::Module`]
+//! and [`wasmtime::Linker`], for example. If you're using
+//! [`wasmtime::component::Component`] or [`wasmtime::component::Linker`] you'll
+//! want the WASIp2 [support this crate has](crate) instead.
+//!
+//! # Examples
+//!
+//! ```no_run
+//! use wasmtime::{Result, Engine, Linker, Module, Store};
+//! use wasmtime_wasi::preview1::{self, WasiP1Ctx};
+//! use wasmtime_wasi::WasiCtxBuilder;
+//!
+//! // An example of executing a WASIp1 "command"
+//! fn main() -> Result<()> {
+//!     let args = std::env::args().skip(1).collect::<Vec<_>>();
+//!     let engine = Engine::default();
+//!     let module = Module::from_file(&engine, &args[0])?;
+//!
+//!     let mut linker: Linker<WasiP1Ctx> = Linker::new(&engine);
+//!     preview1::add_to_linker_async(&mut linker, |t| t)?;
+//!     let pre = linker.instantiate_pre(&module)?;
+//!
+//!     let wasi_ctx = WasiCtxBuilder::new()
+//!         .inherit_stdio()
+//!         .inherit_env()
+//!         .args(&args)
+//!         .build_p1();
+//!
+//!     let mut store = Store::new(&engine, wasi_ctx);
+//!     let instance = pre.instantiate(&mut store)?;
+//!     let func = instance.get_typed_func::<(), ()>(&mut store, "_start")?;
+//!     func.call(&mut store, ())?;
+//!
+//!     Ok(())
+//! }
+//! ```
+
+use crate::bindings::{
+    cli::{
+        stderr::Host as _, stdin::Host as _, stdout::Host as _, terminal_input, terminal_output,
+        terminal_stderr::Host as _, terminal_stdin::Host as _, terminal_stdout::Host as _,
+    },
+    clocks::{monotonic_clock, wall_clock},
+    filesystem::{preopens::Host as _, types as filesystem},
+    io::streams,
+};
+use crate::{
+    FsError, IsATTY, ResourceTable, StreamError, StreamResult, WasiCtx, WasiImpl, WasiView,
+};
+use anyhow::{bail, Context};
+use std::collections::{BTreeMap, HashSet};
+use std::mem::{self, size_of, size_of_val};
+use std::ops::{Deref, DerefMut};
+use std::slice;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::Arc;
+use system_interface::fs::FileIoExt;
+use wasmtime::component::Resource;
+use wiggle::tracing::instrument;
+use wiggle::{GuestError, GuestMemory, GuestPtr, GuestType};
+
+// Bring all WASI traits in scope that this implementation builds on.
+use crate::bindings::cli::environment::Host as _;
+use crate::bindings::filesystem::types::HostDescriptor as _;
+use crate::bindings::io::poll::Host as _;
+use crate::bindings::random::random::Host as _;
+
+/// Structure containing state for WASIp1.
+///
+/// This structure is created through [`WasiCtxBuilder::build_p1`] and is
+/// configured through the various methods of [`WasiCtxBuilder`]. This structure
+/// itself implements generated traits for WASIp1 as well as [`WasiView`] to
+/// have access to WASIp2.
+///
+/// Instances of [`WasiP1Ctx`] are typically stored within the `T` of
+/// [`Store<T>`](wasmtime::Store).
+///
+/// [`WasiCtxBuilder::build_p1`]: crate::WasiCtxBuilder::build_p1
+/// [`WasiCtxBuilder`]: crate::WasiCtxBuilder
+///
+/// # Examples
+///
+/// ```no_run
+/// use wasmtime::{Result, Linker};
+/// use wasmtime_wasi::preview1::{self, WasiP1Ctx};
+/// use wasmtime_wasi::WasiCtxBuilder;
+///
+/// struct MyState {
+///     // ... custom state as necessary ...
+///
+///     wasi: WasiP1Ctx,
+/// }
+///
+/// impl MyState {
+///     fn new() -> MyState {
+///         MyState {
+///             // .. initialize custom state if needed ..
+///
+///             wasi: WasiCtxBuilder::new()
+///                 .arg("./foo.wasm")
+///                 // .. more customization if necesssary ..
+///                 .build_p1(),
+///         }
+///     }
+/// }
+///
+/// fn add_to_linker(linker: &mut Linker<MyState>) -> Result<()> {
+///     preview1::add_to_linker_sync(linker, |my_state| &mut my_state.wasi)?;
+///     Ok(())
+/// }
+/// ```
+pub struct WasiP1Ctx {
+    table: ResourceTable,
+    wasi: WasiCtx,
+    adapter: WasiPreview1Adapter,
+}
+
+impl WasiP1Ctx {
+    pub(crate) fn new(wasi: WasiCtx) -> Self {
+        Self {
+            table: ResourceTable::new(),
+            wasi,
+            adapter: WasiPreview1Adapter::new(),
+        }
+    }
+
+    fn as_wasi_impl(&mut self) -> WasiImpl<&mut Self> {
+        WasiImpl(self)
+    }
+}
+
+impl WasiView for WasiP1Ctx {
+    fn table(&mut self) -> &mut ResourceTable {
+        &mut self.table
+    }
+    fn ctx(&mut self) -> &mut WasiCtx {
+        &mut self.wasi
+    }
+}
+
+#[derive(Debug)]
+struct File {
+    /// The handle to the preview2 descriptor of type [`crate::filesystem::Descriptor::File`].
+    fd: Resource<filesystem::Descriptor>,
+
+    /// The current-position pointer.
+    position: Arc<AtomicU64>,
+
+    /// In append mode, all writes append to the file.
+    append: bool,
+
+    /// When blocking, read and write calls dispatch to blocking_read and
+    /// blocking_check_write on the underlying streams. When false, read and write
+    /// dispatch to stream's plain read and check_write.
+    blocking_mode: BlockingMode,
+}
+
+/// NB: preview1 files always use blocking writes regardless of what
+/// they're configured to use since OSes don't have nonblocking
+/// reads/writes anyway. This behavior originated in the first
+/// implementation of WASIp1 where flags were propagated to the
+/// OS and the OS ignored the nonblocking flag for files
+/// generally.
+#[derive(Clone, Copy, Debug)]
+enum BlockingMode {
+    Blocking,
+    NonBlocking,
+}
+impl BlockingMode {
+    fn from_fdflags(flags: &types::Fdflags) -> Self {
+        if flags.contains(types::Fdflags::NONBLOCK) {
+            BlockingMode::NonBlocking
+        } else {
+            BlockingMode::Blocking
+        }
+    }
+    async fn read(
+        &self,
+        host: &mut impl streams::HostInputStream,
+        input_stream: Resource<streams::InputStream>,
+        max_size: usize,
+    ) -> Result<Vec<u8>, types::Error> {
+        let max_size = max_size.try_into().unwrap_or(u64::MAX);
+        match streams::HostInputStream::blocking_read(host, input_stream, max_size).await {
+            Ok(r) if r.is_empty() => Err(types::Errno::Intr.into()),
+            Ok(r) => Ok(r),
+            Err(StreamError::Closed) => Ok(Vec::new()),
+            Err(e) => Err(e.into()),
+        }
+    }
+    async fn write(
+        &self,
+        memory: &mut GuestMemory<'_>,
+        host: &mut impl streams::HostOutputStream,
+        output_stream: Resource<streams::OutputStream>,
+        bytes: GuestPtr<[u8]>,
+    ) -> StreamResult<usize> {
+        use streams::HostOutputStream as Streams;
+
+        let bytes = memory
+            .as_cow(bytes)
+            .map_err(|e| StreamError::Trap(e.into()))?;
+        let mut bytes = &bytes[..];
+
+        let total = bytes.len();
+        while !bytes.is_empty() {
+            // NOTE: blocking_write_and_flush takes at most one 4k buffer.
+            let len = bytes.len().min(4096);
+            let (chunk, rest) = bytes.split_at(len);
+            bytes = rest;
+
+            Streams::blocking_write_and_flush(host, output_stream.borrowed(), Vec::from(chunk))
+                .await?
+        }
+
+        Ok(total)
+    }
+}
+
+#[derive(Debug)]
+enum Descriptor {
+    Stdin {
+        stream: Resource<streams::InputStream>,
+        isatty: IsATTY,
+    },
+    Stdout {
+        stream: Resource<streams::OutputStream>,
+        isatty: IsATTY,
+    },
+    Stderr {
+        stream: Resource<streams::OutputStream>,
+        isatty: IsATTY,
+    },
+    /// A fd of type [`crate::filesystem::Descriptor::Dir`]
+    Directory {
+        fd: Resource<filesystem::Descriptor>,
+        /// The path this directory was preopened as.
+        /// `None` means this directory was opened using `open-at`.
+        preopen_path: Option<String>,
+    },
+    /// A fd of type [`crate::filesystem::Descriptor::File`]
+    File(File),
+}
+
+#[derive(Debug, Default)]
+struct WasiPreview1Adapter {
+    descriptors: Option<Descriptors>,
+}
+
+#[derive(Debug, Default)]
+struct Descriptors {
+    used: BTreeMap<u32, Descriptor>,
+    free: Vec<u32>,
+}
+
+impl Deref for Descriptors {
+    type Target = BTreeMap<u32, Descriptor>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.used
+    }
+}
+
+impl DerefMut for Descriptors {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.used
+    }
+}
+
+impl Descriptors {
+    /// Initializes [Self] using `preopens`
+    fn new(mut host: WasiImpl<&mut WasiP1Ctx>) -> Result<Self, types::Error> {
+        let mut descriptors = Self::default();
+        descriptors.push(Descriptor::Stdin {
+            stream: host
+                .get_stdin()
+                .context("failed to call `get-stdin`")
+                .map_err(types::Error::trap)?,
+            isatty: if let Some(term_in) = host
+                .get_terminal_stdin()
+                .context("failed to call `get-terminal-stdin`")
+                .map_err(types::Error::trap)?
+            {
+                terminal_input::HostTerminalInput::drop(&mut host, term_in)
+                    .context("failed to call `drop-terminal-input`")
+                    .map_err(types::Error::trap)?;
+                IsATTY::Yes
+            } else {
+                IsATTY::No
+            },
+        })?;
+        descriptors.push(Descriptor::Stdout {
+            stream: host
+                .get_stdout()
+                .context("failed to call `get-stdout`")
+                .map_err(types::Error::trap)?,
+            isatty: if let Some(term_out) = host
+                .get_terminal_stdout()
+                .context("failed to call `get-terminal-stdout`")
+                .map_err(types::Error::trap)?
+            {
+                terminal_output::HostTerminalOutput::drop(&mut host, term_out)
+                    .context("failed to call `drop-terminal-output`")
+                    .map_err(types::Error::trap)?;
+                IsATTY::Yes
+            } else {
+                IsATTY::No
+            },
+        })?;
+        descriptors.push(Descriptor::Stderr {
+            stream: host
+                .get_stderr()
+                .context("failed to call `get-stderr`")
+                .map_err(types::Error::trap)?,
+            isatty: if let Some(term_out) = host
+                .get_terminal_stderr()
+                .context("failed to call `get-terminal-stderr`")
+                .map_err(types::Error::trap)?
+            {
+                terminal_output::HostTerminalOutput::drop(&mut host, term_out)
+                    .context("failed to call `drop-terminal-output`")
+                    .map_err(types::Error::trap)?;
+                IsATTY::Yes
+            } else {
+                IsATTY::No
+            },
+        })?;
+
+        for dir in host
+            .get_directories()
+            .context("failed to call `get-directories`")
+            .map_err(types::Error::trap)?
+        {
+            descriptors.push(Descriptor::Directory {
+                fd: dir.0,
+                preopen_path: Some(dir.1),
+            })?;
+        }
+        Ok(descriptors)
+    }
+
+    /// Returns next descriptor number, which was never assigned
+    fn unused(&self) -> Result<u32> {
+        match self.last_key_value() {
+            Some((fd, _)) => {
+                if let Some(fd) = fd.checked_add(1) {
+                    return Ok(fd);
+                }
+                if self.len() == u32::MAX as usize {
+                    return Err(types::Errno::Loop.into());
+                }
+                // TODO: Optimize
+                Ok((0..u32::MAX)
+                    .rev()
+                    .find(|fd| !self.contains_key(fd))
+                    .expect("failed to find an unused file descriptor"))
+            }
+            None => Ok(0),
+        }
+    }
+
+    /// Removes the [Descriptor] corresponding to `fd`
+    fn remove(&mut self, fd: types::Fd) -> Option<Descriptor> {
+        let fd = fd.into();
+        let desc = self.used.remove(&fd)?;
+        self.free.push(fd);
+        Some(desc)
+    }
+
+    /// Pushes the [Descriptor] returning corresponding number.
+    /// This operation will try to reuse numbers previously removed via [`Self::remove`]
+    /// and rely on [`Self::unused`] if no free numbers are recorded
+    fn push(&mut self, desc: Descriptor) -> Result<u32> {
+        let fd = if let Some(fd) = self.free.pop() {
+            fd
+        } else {
+            self.unused()?
+        };
+        assert!(self.insert(fd, desc).is_none());
+        Ok(fd)
+    }
+}
+
+impl WasiPreview1Adapter {
+    fn new() -> Self {
+        Self::default()
+    }
+}
+
+/// A mutably-borrowed [`WasiPreview1View`] implementation, which provides access to the stored
+/// state. It can be thought of as an in-flight [`WasiPreview1Adapter`] transaction, all
+/// changes will be recorded in the underlying [`WasiPreview1Adapter`] returned by
+/// [`WasiPreview1View::adapter_mut`] on [`Drop`] of this struct.
+// NOTE: This exists for the most part just due to the fact that `bindgen` generates methods with
+// `&mut self` receivers and so this struct lets us extend the lifetime of the `&mut self` borrow
+// of the [`WasiPreview1View`] to provide means to return mutably and immutably borrowed [`Descriptors`]
+// without having to rely on something like `Arc<Mutex<Descriptors>>`, while also being able to
+// call methods like [`Descriptor::is_file`] and hiding complexity from preview1 method implementations.
+struct Transaction<'a> {
+    view: &'a mut WasiP1Ctx,
+    descriptors: Descriptors,
+}
+
+impl Drop for Transaction<'_> {
+    /// Record changes in the [`WasiPreview1Adapter`] returned by [`WasiPreview1View::adapter_mut`]
+    fn drop(&mut self) {
+        let descriptors = mem::take(&mut self.descriptors);
+        self.view.adapter.descriptors = Some(descriptors);
+    }
+}
+
+impl Transaction<'_> {
+    /// Borrows [`Descriptor`] corresponding to `fd`.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`types::Errno::Badf`] if no [`Descriptor`] is found
+    fn get_descriptor(&self, fd: types::Fd) -> Result<&Descriptor> {
+        let fd = fd.into();
+        let desc = self.descriptors.get(&fd).ok_or(types::Errno::Badf)?;
+        Ok(desc)
+    }
+
+    /// Borrows [`File`] corresponding to `fd`
+    /// if it describes a [`Descriptor::File`]
+    fn get_file(&self, fd: types::Fd) -> Result<&File> {
+        let fd = fd.into();
+        match self.descriptors.get(&fd) {
+            Some(Descriptor::File(file)) => Ok(file),
+            _ => Err(types::Errno::Badf.into()),
+        }
+    }
+
+    /// Mutably borrows [`File`] corresponding to `fd`
+    /// if it describes a [`Descriptor::File`]
+    fn get_file_mut(&mut self, fd: types::Fd) -> Result<&mut File> {
+        let fd = fd.into();
+        match self.descriptors.get_mut(&fd) {
+            Some(Descriptor::File(file)) => Ok(file),
+            _ => Err(types::Errno::Badf.into()),
+        }
+    }
+
+    /// Borrows [`File`] corresponding to `fd`
+    /// if it describes a [`Descriptor::File`]
+    ///
+    /// # Errors
+    ///
+    /// Returns [`types::Errno::Spipe`] if the descriptor corresponds to stdio
+    fn get_seekable(&self, fd: types::Fd) -> Result<&File> {
+        let fd = fd.into();
+        match self.descriptors.get(&fd) {
+            Some(Descriptor::File(file)) => Ok(file),
+            Some(
+                Descriptor::Stdin { .. } | Descriptor::Stdout { .. } | Descriptor::Stderr { .. },
+            ) => {
+                // NOTE: legacy implementation returns SPIPE here
+                Err(types::Errno::Spipe.into())
+            }
+            _ => Err(types::Errno::Badf.into()),
+        }
+    }
+
+    /// Returns [`filesystem::Descriptor`] corresponding to `fd`
+    fn get_fd(&self, fd: types::Fd) -> Result<Resource<filesystem::Descriptor>> {
+        match self.get_descriptor(fd)? {
+            Descriptor::File(File { fd, .. }) => Ok(fd.borrowed()),
+            Descriptor::Directory { fd, .. } => Ok(fd.borrowed()),
+            Descriptor::Stdin { .. } | Descriptor::Stdout { .. } | Descriptor::Stderr { .. } => {
+                Err(types::Errno::Badf.into())
+            }
+        }
+    }
+
+    /// Returns [`filesystem::Descriptor`] corresponding to `fd`
+    /// if it describes a [`Descriptor::File`]
+    fn get_file_fd(&self, fd: types::Fd) -> Result<Resource<filesystem::Descriptor>> {
+        self.get_file(fd).map(|File { fd, .. }| fd.borrowed())
+    }
+
+    /// Returns [`filesystem::Descriptor`] corresponding to `fd`
+    /// if it describes a [`Descriptor::Directory`]
+    fn get_dir_fd(&self, fd: types::Fd) -> Result<Resource<filesystem::Descriptor>> {
+        let fd = fd.into();
+        match self.descriptors.get(&fd) {
+            Some(Descriptor::Directory { fd, .. }) => Ok(fd.borrowed()),
+            _ => Err(types::Errno::Badf.into()),
+        }
+    }
+}
+
+impl WasiP1Ctx {
+    /// Lazily initializes [`WasiPreview1Adapter`] returned by [`WasiPreview1View::adapter_mut`]
+    /// and returns [`Transaction`] on success
+    fn transact(&mut self) -> Result<Transaction<'_>, types::Error> {
+        let descriptors = if let Some(descriptors) = self.adapter.descriptors.take() {
+            descriptors
+        } else {
+            Descriptors::new(self.as_wasi_impl())?
+        }
+        .into();
+        Ok(Transaction {
+            view: self,
+            descriptors,
+        })
+    }
+
+    /// Lazily initializes [`WasiPreview1Adapter`] returned by [`WasiPreview1View::adapter_mut`]
+    /// and returns [`filesystem::Descriptor`] corresponding to `fd`
+    fn get_fd(&mut self, fd: types::Fd) -> Result<Resource<filesystem::Descriptor>, types::Error> {
+        let st = self.transact()?;
+        let fd = st.get_fd(fd)?;
+        Ok(fd)
+    }
+
+    /// Lazily initializes [`WasiPreview1Adapter`] returned by [`WasiPreview1View::adapter_mut`]
+    /// and returns [`filesystem::Descriptor`] corresponding to `fd`
+    /// if it describes a [`Descriptor::File`] of [`crate::filesystem::File`] type
+    fn get_file_fd(
+        &mut self,
+        fd: types::Fd,
+    ) -> Result<Resource<filesystem::Descriptor>, types::Error> {
+        let st = self.transact()?;
+        let fd = st.get_file_fd(fd)?;
+        Ok(fd)
+    }
+
+    /// Lazily initializes [`WasiPreview1Adapter`] returned by [`WasiPreview1View::adapter_mut`]
+    /// and returns [`filesystem::Descriptor`] corresponding to `fd`
+    /// if it describes a [`Descriptor::File`] or [`Descriptor::PreopenDirectory`]
+    /// of [`crate::filesystem::Dir`] type
+    fn get_dir_fd(
+        &mut self,
+        fd: types::Fd,
+    ) -> Result<Resource<filesystem::Descriptor>, types::Error> {
+        let st = self.transact()?;
+        let fd = st.get_dir_fd(fd)?;
+        Ok(fd)
+    }
+
+    /// Shared implementation of `fd_write` and `fd_pwrite`.
+    async fn fd_write_impl(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        ciovs: types::CiovecArray,
+        write: FdWrite,
+    ) -> Result<types::Size, types::Error> {
+        let t = self.transact()?;
+        let desc = t.get_descriptor(fd)?;
+        match desc {
+            Descriptor::File(File {
+                fd,
+                append,
+                position,
+                // NB: files always use blocking writes regardless of what
+                // they're configured to use since OSes don't have nonblocking
+                // reads/writes anyway. This behavior originated in the first
+                // implementation of WASIp1 where flags were propagated to the
+                // OS and the OS ignored the nonblocking flag for files
+                // generally.
+                blocking_mode: _,
+            }) => {
+                let fd = fd.borrowed();
+                let position = position.clone();
+                let pos = position.load(Ordering::Relaxed);
+                let append = *append;
+                drop(t);
+                let f = self.table().get(&fd)?.file()?;
+                let buf = first_non_empty_ciovec(memory, ciovs)?;
+
+                let do_write = move |f: &cap_std::fs::File, buf: &[u8]| match (append, write) {
+                    // Note that this is implementing Linux semantics of
+                    // `pwrite` where the offset is ignored if the file was
+                    // opened in append mode.
+                    (true, _) => f.append(&buf),
+                    (false, FdWrite::At(pos)) => f.write_at(&buf, pos),
+                    (false, FdWrite::AtCur) => f.write_at(&buf, pos),
+                };
+
+                let nwritten = match f.as_blocking_file() {
+                    // If we can block then skip the copy out of wasm memory and
+                    // write directly to `f`.
+                    Some(f) => do_write(f, &memory.as_cow(buf)?),
+                    // ... otherwise copy out of wasm memory and use
+                    // `spawn_blocking` to do this write in a thread that can
+                    // block.
+                    None => {
+                        let buf = memory.to_vec(buf)?;
+                        f.run_blocking(move |f| do_write(f, &buf)).await
+                    }
+                };
+
+                let nwritten = nwritten.map_err(|e| StreamError::LastOperationFailed(e.into()))?;
+
+                // If this was a write at the current position then update the
+                // current position with the result, otherwise the current
+                // position is left unmodified.
+                if let FdWrite::AtCur = write {
+                    if append {
+                        let len = self.as_wasi_impl().stat(fd).await?;
+                        position.store(len.size, Ordering::Relaxed);
+                    } else {
+                        let pos = pos
+                            .checked_add(nwritten as u64)
+                            .ok_or(types::Errno::Overflow)?;
+                        position.store(pos, Ordering::Relaxed);
+                    }
+                }
+                Ok(nwritten.try_into()?)
+            }
+            Descriptor::Stdout { stream, .. } | Descriptor::Stderr { stream, .. } => {
+                match write {
+                    // Reject calls to `fd_pwrite` on stdio descriptors...
+                    FdWrite::At(_) => return Err(types::Errno::Spipe.into()),
+                    // ... but allow calls to `fd_write`
+                    FdWrite::AtCur => {}
+                }
+                let stream = stream.borrowed();
+                drop(t);
+                let buf = first_non_empty_ciovec(memory, ciovs)?;
+                let n = BlockingMode::Blocking
+                    .write(memory, &mut self.as_wasi_impl(), stream, buf)
+                    .await?
+                    .try_into()?;
+                Ok(n)
+            }
+            _ => Err(types::Errno::Badf.into()),
+        }
+    }
+}
+
+#[derive(Copy, Clone)]
+enum FdWrite {
+    At(u64),
+    AtCur,
+}
+
+/// Adds asynchronous versions of all WASIp1 functions to the
+/// [`wasmtime::Linker`] provided.
+///
+/// This method will add WASIp1 functions to `linker`. The `f` closure provided
+/// is used to project from the `T` state that `Linker` is associated with to a
+/// [`WasiP1Ctx`]. If `T` is `WasiP1Ctx` itself then this is the identity
+/// closure, but otherwise it must project out the field where `WasiP1Ctx` is
+/// stored within `T`.
+///
+/// The state provided by `f` is used to implement all WASIp1 functions and
+/// provides configuration to know what to return.
+///
+/// Note that this function is intended for use with
+/// [`Config::async_support(true)`]. If you're looking for a synchronous version
+/// see [`add_to_linker_sync`].
+///
+/// [`Config::async_support(true)`]: wasmtime::Config::async_support
+///
+/// # Examples
+///
+/// If the `T` in `Linker<T>` is just `WasiP1Ctx`:
+///
+/// ```no_run
+/// use wasmtime::{Result, Linker, Engine, Config};
+/// use wasmtime_wasi::preview1::{self, WasiP1Ctx};
+///
+/// fn main() -> Result<()> {
+///     let mut config = Config::new();
+///     config.async_support(true);
+///     let engine = Engine::new(&config)?;
+///
+///     let mut linker: Linker<WasiP1Ctx> = Linker::new(&engine);
+///     preview1::add_to_linker_async(&mut linker, |cx| cx)?;
+///
+///     // ... continue to add more to `linker` as necessary and use it ...
+///
+///     Ok(())
+/// }
+/// ```
+///
+/// If the `T` in `Linker<T>` is custom state:
+///
+/// ```no_run
+/// use wasmtime::{Result, Linker, Engine, Config};
+/// use wasmtime_wasi::preview1::{self, WasiP1Ctx};
+///
+/// struct MyState {
+///     // .. other custom state here ..
+///
+///     wasi: WasiP1Ctx,
+/// }
+///
+/// fn main() -> Result<()> {
+///     let mut config = Config::new();
+///     config.async_support(true);
+///     let engine = Engine::new(&config)?;
+///
+///     let mut linker: Linker<MyState> = Linker::new(&engine);
+///     preview1::add_to_linker_async(&mut linker, |cx| &mut cx.wasi)?;
+///
+///     // ... continue to add more to `linker` as necessary and use it ...
+///
+///     Ok(())
+/// }
+/// ```
+pub fn add_to_linker_async<T: Send>(
+    linker: &mut wasmtime::Linker<T>,
+    f: impl Fn(&mut T) -> &mut WasiP1Ctx + Copy + Send + Sync + 'static,
+) -> anyhow::Result<()> {
+    crate::preview1::wasi_snapshot_preview1::add_to_linker(linker, f)
+}
+
+/// Adds synchronous versions of all WASIp1 functions to the
+/// [`wasmtime::Linker`] provided.
+///
+/// This method will add WASIp1 functions to `linker`. The `f` closure provided
+/// is used to project from the `T` state that `Linker` is associated with to a
+/// [`WasiP1Ctx`]. If `T` is `WasiP1Ctx` itself then this is the identity
+/// closure, but otherwise it must project out the field where `WasiP1Ctx` is
+/// stored within `T`.
+///
+/// The state provided by `f` is used to implement all WASIp1 functions and
+/// provides configuration to know what to return.
+///
+/// Note that this function is intended for use with
+/// [`Config::async_support(false)`]. If you're looking for a synchronous version
+/// see [`add_to_linker_async`].
+///
+/// [`Config::async_support(false)`]: wasmtime::Config::async_support
+///
+/// # Examples
+///
+/// If the `T` in `Linker<T>` is just `WasiP1Ctx`:
+///
+/// ```no_run
+/// use wasmtime::{Result, Linker, Engine, Config};
+/// use wasmtime_wasi::preview1::{self, WasiP1Ctx};
+///
+/// fn main() -> Result<()> {
+///     let mut config = Config::new();
+///     config.async_support(true);
+///     let engine = Engine::new(&config)?;
+///
+///     let mut linker: Linker<WasiP1Ctx> = Linker::new(&engine);
+///     preview1::add_to_linker_async(&mut linker, |cx| cx)?;
+///
+///     // ... continue to add more to `linker` as necessary and use it ...
+///
+///     Ok(())
+/// }
+/// ```
+///
+/// If the `T` in `Linker<T>` is custom state:
+///
+/// ```no_run
+/// use wasmtime::{Result, Linker, Engine, Config};
+/// use wasmtime_wasi::preview1::{self, WasiP1Ctx};
+///
+/// struct MyState {
+///     // .. other custom state here ..
+///
+///     wasi: WasiP1Ctx,
+/// }
+///
+/// fn main() -> Result<()> {
+///     let mut config = Config::new();
+///     config.async_support(true);
+///     let engine = Engine::new(&config)?;
+///
+///     let mut linker: Linker<MyState> = Linker::new(&engine);
+///     preview1::add_to_linker_async(&mut linker, |cx| &mut cx.wasi)?;
+///
+///     // ... continue to add more to `linker` as necessary and use it ...
+///
+///     Ok(())
+/// }
+/// ```
+pub fn add_to_linker_sync<T: Send>(
+    linker: &mut wasmtime::Linker<T>,
+    f: impl Fn(&mut T) -> &mut WasiP1Ctx + Copy + Send + Sync + 'static,
+) -> anyhow::Result<()> {
+    crate::preview1::sync::add_wasi_snapshot_preview1_to_linker(linker, f)
+}
+
+// Generate the wasi_snapshot_preview1::WasiSnapshotPreview1 trait,
+// and the module types.
+// None of the generated modules, traits, or types should be used externally
+// to this module.
+wiggle::from_witx!({
+    witx: ["$CARGO_MANIFEST_DIR/witx/preview1/wasi_snapshot_preview1.witx"],
+    async: {
+        wasi_snapshot_preview1::{
+            fd_advise, fd_close, fd_datasync, fd_fdstat_get, fd_filestat_get, fd_filestat_set_size,
+            fd_filestat_set_times, fd_read, fd_pread, fd_seek, fd_sync, fd_readdir, fd_write,
+            fd_pwrite, poll_oneoff, path_create_directory, path_filestat_get,
+            path_filestat_set_times, path_link, path_open, path_readlink, path_remove_directory,
+            path_rename, path_symlink, path_unlink_file
+        }
+    },
+    errors: { errno => trappable Error },
+});
+
+pub(crate) mod sync {
+    use anyhow::Result;
+    use std::future::Future;
+
+    wiggle::wasmtime_integration!({
+        witx: ["$CARGO_MANIFEST_DIR/witx/preview1/wasi_snapshot_preview1.witx"],
+        target: super,
+        block_on[in_tokio]: {
+            wasi_snapshot_preview1::{
+                fd_advise, fd_close, fd_datasync, fd_fdstat_get, fd_filestat_get, fd_filestat_set_size,
+                fd_filestat_set_times, fd_read, fd_pread, fd_seek, fd_sync, fd_readdir, fd_write,
+                fd_pwrite, poll_oneoff, path_create_directory, path_filestat_get,
+                path_filestat_set_times, path_link, path_open, path_readlink, path_remove_directory,
+                path_rename, path_symlink, path_unlink_file
+            }
+        },
+        errors: { errno => trappable Error },
+    });
+
+    // Small wrapper around `in_tokio` to add a `Result` layer which is always
+    // `Ok`
+    fn in_tokio<F: Future>(future: F) -> Result<F::Output> {
+        Ok(crate::runtime::in_tokio(future))
+    }
+}
+
+impl wiggle::GuestErrorType for types::Errno {
+    fn success() -> Self {
+        Self::Success
+    }
+}
+
+impl From<StreamError> for types::Error {
+    fn from(err: StreamError) -> Self {
+        match err {
+            StreamError::Closed => types::Errno::Io.into(),
+            StreamError::LastOperationFailed(e) => match e.downcast::<std::io::Error>() {
+                Ok(err) => filesystem::ErrorCode::from(err).into(),
+                Err(e) => {
+                    tracing::debug!("dropping error {e:?}");
+                    types::Errno::Io.into()
+                }
+            },
+            StreamError::Trap(e) => types::Error::trap(e),
+        }
+    }
+}
+
+impl From<FsError> for types::Error {
+    fn from(err: FsError) -> Self {
+        match err.downcast() {
+            Ok(code) => code.into(),
+            Err(e) => types::Error::trap(e),
+        }
+    }
+}
+
+fn systimespec(set: bool, ts: types::Timestamp, now: bool) -> Result<filesystem::NewTimestamp> {
+    if set && now {
+        Err(types::Errno::Inval.into())
+    } else if set {
+        Ok(filesystem::NewTimestamp::Timestamp(filesystem::Datetime {
+            seconds: ts / 1_000_000_000,
+            nanoseconds: (ts % 1_000_000_000) as _,
+        }))
+    } else if now {
+        Ok(filesystem::NewTimestamp::Now)
+    } else {
+        Ok(filesystem::NewTimestamp::NoChange)
+    }
+}
+
+impl TryFrom<wall_clock::Datetime> for types::Timestamp {
+    type Error = types::Errno;
+
+    fn try_from(
+        wall_clock::Datetime {
+            seconds,
+            nanoseconds,
+        }: wall_clock::Datetime,
+    ) -> Result<Self, Self::Error> {
+        types::Timestamp::from(seconds)
+            .checked_mul(1_000_000_000)
+            .and_then(|ns| ns.checked_add(nanoseconds.into()))
+            .ok_or(types::Errno::Overflow)
+    }
+}
+
+impl From<types::Lookupflags> for filesystem::PathFlags {
+    fn from(flags: types::Lookupflags) -> Self {
+        if flags.contains(types::Lookupflags::SYMLINK_FOLLOW) {
+            filesystem::PathFlags::SYMLINK_FOLLOW
+        } else {
+            filesystem::PathFlags::empty()
+        }
+    }
+}
+
+impl From<types::Oflags> for filesystem::OpenFlags {
+    fn from(flags: types::Oflags) -> Self {
+        let mut out = filesystem::OpenFlags::empty();
+        if flags.contains(types::Oflags::CREAT) {
+            out |= filesystem::OpenFlags::CREATE;
+        }
+        if flags.contains(types::Oflags::DIRECTORY) {
+            out |= filesystem::OpenFlags::DIRECTORY;
+        }
+        if flags.contains(types::Oflags::EXCL) {
+            out |= filesystem::OpenFlags::EXCLUSIVE;
+        }
+        if flags.contains(types::Oflags::TRUNC) {
+            out |= filesystem::OpenFlags::TRUNCATE;
+        }
+        out
+    }
+}
+
+impl From<types::Advice> for filesystem::Advice {
+    fn from(advice: types::Advice) -> Self {
+        match advice {
+            types::Advice::Normal => filesystem::Advice::Normal,
+            types::Advice::Sequential => filesystem::Advice::Sequential,
+            types::Advice::Random => filesystem::Advice::Random,
+            types::Advice::Willneed => filesystem::Advice::WillNeed,
+            types::Advice::Dontneed => filesystem::Advice::DontNeed,
+            types::Advice::Noreuse => filesystem::Advice::NoReuse,
+        }
+    }
+}
+
+impl TryFrom<filesystem::DescriptorType> for types::Filetype {
+    type Error = anyhow::Error;
+
+    fn try_from(ty: filesystem::DescriptorType) -> Result<Self, Self::Error> {
+        match ty {
+            filesystem::DescriptorType::RegularFile => Ok(types::Filetype::RegularFile),
+            filesystem::DescriptorType::Directory => Ok(types::Filetype::Directory),
+            filesystem::DescriptorType::BlockDevice => Ok(types::Filetype::BlockDevice),
+            filesystem::DescriptorType::CharacterDevice => Ok(types::Filetype::CharacterDevice),
+            // preview1 never had a FIFO code.
+            filesystem::DescriptorType::Fifo => Ok(types::Filetype::Unknown),
+            // TODO: Add a way to disginguish between FILETYPE_SOCKET_STREAM and
+            // FILETYPE_SOCKET_DGRAM.
+            filesystem::DescriptorType::Socket => {
+                bail!("sockets are not currently supported")
+            }
+            filesystem::DescriptorType::SymbolicLink => Ok(types::Filetype::SymbolicLink),
+            filesystem::DescriptorType::Unknown => Ok(types::Filetype::Unknown),
+        }
+    }
+}
+
+impl From<IsATTY> for types::Filetype {
+    fn from(isatty: IsATTY) -> Self {
+        match isatty {
+            IsATTY::Yes => types::Filetype::CharacterDevice,
+            IsATTY::No => types::Filetype::Unknown,
+        }
+    }
+}
+
+impl From<filesystem::ErrorCode> for types::Errno {
+    fn from(code: filesystem::ErrorCode) -> Self {
+        match code {
+            filesystem::ErrorCode::Access => types::Errno::Acces,
+            filesystem::ErrorCode::WouldBlock => types::Errno::Again,
+            filesystem::ErrorCode::Already => types::Errno::Already,
+            filesystem::ErrorCode::BadDescriptor => types::Errno::Badf,
+            filesystem::ErrorCode::Busy => types::Errno::Busy,
+            filesystem::ErrorCode::Deadlock => types::Errno::Deadlk,
+            filesystem::ErrorCode::Quota => types::Errno::Dquot,
+            filesystem::ErrorCode::Exist => types::Errno::Exist,
+            filesystem::ErrorCode::FileTooLarge => types::Errno::Fbig,
+            filesystem::ErrorCode::IllegalByteSequence => types::Errno::Ilseq,
+            filesystem::ErrorCode::InProgress => types::Errno::Inprogress,
+            filesystem::ErrorCode::Interrupted => types::Errno::Intr,
+            filesystem::ErrorCode::Invalid => types::Errno::Inval,
+            filesystem::ErrorCode::Io => types::Errno::Io,
+            filesystem::ErrorCode::IsDirectory => types::Errno::Isdir,
+            filesystem::ErrorCode::Loop => types::Errno::Loop,
+            filesystem::ErrorCode::TooManyLinks => types::Errno::Mlink,
+            filesystem::ErrorCode::MessageSize => types::Errno::Msgsize,
+            filesystem::ErrorCode::NameTooLong => types::Errno::Nametoolong,
+            filesystem::ErrorCode::NoDevice => types::Errno::Nodev,
+            filesystem::ErrorCode::NoEntry => types::Errno::Noent,
+            filesystem::ErrorCode::NoLock => types::Errno::Nolck,
+            filesystem::ErrorCode::InsufficientMemory => types::Errno::Nomem,
+            filesystem::ErrorCode::InsufficientSpace => types::Errno::Nospc,
+            filesystem::ErrorCode::Unsupported => types::Errno::Notsup,
+            filesystem::ErrorCode::NotDirectory => types::Errno::Notdir,
+            filesystem::ErrorCode::NotEmpty => types::Errno::Notempty,
+            filesystem::ErrorCode::NotRecoverable => types::Errno::Notrecoverable,
+            filesystem::ErrorCode::NoTty => types::Errno::Notty,
+            filesystem::ErrorCode::NoSuchDevice => types::Errno::Nxio,
+            filesystem::ErrorCode::Overflow => types::Errno::Overflow,
+            filesystem::ErrorCode::NotPermitted => types::Errno::Perm,
+            filesystem::ErrorCode::Pipe => types::Errno::Pipe,
+            filesystem::ErrorCode::ReadOnly => types::Errno::Rofs,
+            filesystem::ErrorCode::InvalidSeek => types::Errno::Spipe,
+            filesystem::ErrorCode::TextFileBusy => types::Errno::Txtbsy,
+            filesystem::ErrorCode::CrossDevice => types::Errno::Xdev,
+        }
+    }
+}
+
+impl From<std::num::TryFromIntError> for types::Error {
+    fn from(_: std::num::TryFromIntError) -> Self {
+        types::Errno::Overflow.into()
+    }
+}
+
+impl From<GuestError> for types::Error {
+    fn from(err: GuestError) -> Self {
+        use wiggle::GuestError::*;
+        match err {
+            InvalidFlagValue { .. } => types::Errno::Inval.into(),
+            InvalidEnumValue { .. } => types::Errno::Inval.into(),
+            // As per
+            // https://github.com/WebAssembly/wasi/blob/main/legacy/tools/witx-docs.md#pointers
+            //
+            // > If a misaligned pointer is passed to a function, the function
+            // > shall trap.
+            // >
+            // > If an out-of-bounds pointer is passed to a function and the
+            // > function needs to dereference it, the function shall trap.
+            //
+            // so this turns OOB and misalignment errors into traps.
+            PtrOverflow { .. } | PtrOutOfBounds { .. } | PtrNotAligned { .. } => {
+                types::Error::trap(err.into())
+            }
+            PtrBorrowed { .. } => types::Errno::Fault.into(),
+            InvalidUtf8 { .. } => types::Errno::Ilseq.into(),
+            TryFromIntError { .. } => types::Errno::Overflow.into(),
+            SliceLengthsDiffer { .. } => types::Errno::Fault.into(),
+            BorrowCheckerOutOfHandles { .. } => types::Errno::Fault.into(),
+            InFunc { err, .. } => types::Error::from(*err),
+        }
+    }
+}
+
+impl From<filesystem::ErrorCode> for types::Error {
+    fn from(code: filesystem::ErrorCode) -> Self {
+        types::Errno::from(code).into()
+    }
+}
+
+impl From<wasmtime::component::ResourceTableError> for types::Error {
+    fn from(err: wasmtime::component::ResourceTableError) -> Self {
+        types::Error::trap(err.into())
+    }
+}
+
+type Result<T, E = types::Error> = std::result::Result<T, E>;
+
+fn write_bytes(
+    memory: &mut GuestMemory<'_>,
+    ptr: GuestPtr<u8>,
+    buf: &[u8],
+) -> Result<GuestPtr<u8>, types::Error> {
+    // NOTE: legacy implementation always returns Inval errno
+
+    let len = u32::try_from(buf.len())?;
+
+    memory.copy_from_slice(buf, ptr.as_array(len))?;
+    let next = ptr.add(len)?;
+    Ok(next)
+}
+
+fn write_byte(memory: &mut GuestMemory<'_>, ptr: GuestPtr<u8>, byte: u8) -> Result<GuestPtr<u8>> {
+    memory.write(ptr, byte)?;
+    let next = ptr.add(1)?;
+    Ok(next)
+}
+
+fn read_string<'a>(memory: &'a GuestMemory<'_>, ptr: GuestPtr<str>) -> Result<String> {
+    Ok(memory.as_cow_str(ptr)?.into_owned())
+}
+
+// Returns the first non-empty buffer in `ciovs` or a single empty buffer if
+// they're all empty.
+fn first_non_empty_ciovec(
+    memory: &GuestMemory<'_>,
+    ciovs: types::CiovecArray,
+) -> Result<GuestPtr<[u8]>> {
+    for iov in ciovs.iter() {
+        let iov = memory.read(iov?)?;
+        if iov.buf_len == 0 {
+            continue;
+        }
+        return Ok(iov.buf.as_array(iov.buf_len));
+    }
+    Ok(GuestPtr::new((0, 0)))
+}
+
+// Returns the first non-empty buffer in `iovs` or a single empty buffer if
+// they're all empty.
+fn first_non_empty_iovec(
+    memory: &GuestMemory<'_>,
+    iovs: types::IovecArray,
+) -> Result<GuestPtr<[u8]>> {
+    for iov in iovs.iter() {
+        let iov = memory.read(iov?)?;
+        if iov.buf_len == 0 {
+            continue;
+        }
+        return Ok(iov.buf.as_array(iov.buf_len));
+    }
+    Ok(GuestPtr::new((0, 0)))
+}
+
+#[async_trait::async_trait]
+// Implement the WasiSnapshotPreview1 trait using only the traits that are
+// required for T, i.e., in terms of the preview 2 wit interface, and state
+// stored in the WasiPreview1Adapter struct.
+impl wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiP1Ctx {
+    #[instrument(skip(self, memory))]
+    fn args_get(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        argv: GuestPtr<GuestPtr<u8>>,
+        argv_buf: GuestPtr<u8>,
+    ) -> Result<(), types::Error> {
+        self.as_wasi_impl()
+            .get_arguments()
+            .context("failed to call `get-arguments`")
+            .map_err(types::Error::trap)?
+            .into_iter()
+            .try_fold((argv, argv_buf), |(argv, argv_buf), arg| -> Result<_> {
+                memory.write(argv, argv_buf)?;
+                let argv = argv.add(1)?;
+
+                let argv_buf = write_bytes(memory, argv_buf, arg.as_bytes())?;
+                let argv_buf = write_byte(memory, argv_buf, 0)?;
+
+                Ok((argv, argv_buf))
+            })?;
+        Ok(())
+    }
+
+    #[instrument(skip(self, _memory))]
+    fn args_sizes_get(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+    ) -> Result<(types::Size, types::Size), types::Error> {
+        let args = self
+            .as_wasi_impl()
+            .get_arguments()
+            .context("failed to call `get-arguments`")
+            .map_err(types::Error::trap)?;
+        let num = args.len().try_into().map_err(|_| types::Errno::Overflow)?;
+        let len = args
+            .iter()
+            .map(|buf| buf.len() + 1) // Each argument is expected to be `\0` terminated.
+            .sum::<usize>()
+            .try_into()
+            .map_err(|_| types::Errno::Overflow)?;
+        Ok((num, len))
+    }
+
+    #[instrument(skip(self, memory))]
+    fn environ_get(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        environ: GuestPtr<GuestPtr<u8>>,
+        environ_buf: GuestPtr<u8>,
+    ) -> Result<(), types::Error> {
+        self.as_wasi_impl()
+            .get_environment()
+            .context("failed to call `get-environment`")
+            .map_err(types::Error::trap)?
+            .into_iter()
+            .try_fold(
+                (environ, environ_buf),
+                |(environ, environ_buf), (k, v)| -> Result<_, types::Error> {
+                    memory.write(environ, environ_buf)?;
+                    let environ = environ.add(1)?;
+
+                    let environ_buf = write_bytes(memory, environ_buf, k.as_bytes())?;
+                    let environ_buf = write_byte(memory, environ_buf, b'=')?;
+                    let environ_buf = write_bytes(memory, environ_buf, v.as_bytes())?;
+                    let environ_buf = write_byte(memory, environ_buf, 0)?;
+
+                    Ok((environ, environ_buf))
+                },
+            )?;
+        Ok(())
+    }
+
+    #[instrument(skip(self, _memory))]
+    fn environ_sizes_get(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+    ) -> Result<(types::Size, types::Size), types::Error> {
+        let environ = self
+            .as_wasi_impl()
+            .get_environment()
+            .context("failed to call `get-environment`")
+            .map_err(types::Error::trap)?;
+        let num = environ.len().try_into()?;
+        let len = environ
+            .iter()
+            .map(|(k, v)| k.len() + 1 + v.len() + 1) // Key/value pairs are expected to be joined with `=`s, and terminated with `\0`s.
+            .sum::<usize>()
+            .try_into()?;
+        Ok((num, len))
+    }
+
+    #[instrument(skip(self, _memory))]
+    fn clock_res_get(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        id: types::Clockid,
+    ) -> Result<types::Timestamp, types::Error> {
+        let res = match id {
+            types::Clockid::Realtime => wall_clock::Host::resolution(&mut self.as_wasi_impl())
+                .context("failed to call `wall_clock::resolution`")
+                .map_err(types::Error::trap)?
+                .try_into()?,
+            types::Clockid::Monotonic => {
+                monotonic_clock::Host::resolution(&mut self.as_wasi_impl())
+                    .context("failed to call `monotonic_clock::resolution`")
+                    .map_err(types::Error::trap)?
+            }
+            types::Clockid::ProcessCputimeId | types::Clockid::ThreadCputimeId => {
+                return Err(types::Errno::Badf.into())
+            }
+        };
+        Ok(res)
+    }
+
+    #[instrument(skip(self, _memory))]
+    fn clock_time_get(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        id: types::Clockid,
+        _precision: types::Timestamp,
+    ) -> Result<types::Timestamp, types::Error> {
+        let now = match id {
+            types::Clockid::Realtime => wall_clock::Host::now(&mut self.as_wasi_impl())
+                .context("failed to call `wall_clock::now`")
+                .map_err(types::Error::trap)?
+                .try_into()?,
+            types::Clockid::Monotonic => monotonic_clock::Host::now(&mut self.as_wasi_impl())
+                .context("failed to call `monotonic_clock::now`")
+                .map_err(types::Error::trap)?,
+            types::Clockid::ProcessCputimeId | types::Clockid::ThreadCputimeId => {
+                return Err(types::Errno::Badf.into())
+            }
+        };
+        Ok(now)
+    }
+
+    #[instrument(skip(self, _memory))]
+    async fn fd_advise(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        offset: types::Filesize,
+        len: types::Filesize,
+        advice: types::Advice,
+    ) -> Result<(), types::Error> {
+        let fd = self.get_file_fd(fd)?;
+        self.as_wasi_impl()
+            .advise(fd, offset, len, advice.into())
+            .await
+            .map_err(|e| {
+                e.try_into()
+                    .context("failed to call `advise`")
+                    .unwrap_or_else(types::Error::trap)
+            })
+    }
+
+    /// Force the allocation of space in a file.
+    /// NOTE: This is similar to `posix_fallocate` in POSIX.
+    #[instrument(skip(self, _memory))]
+    fn fd_allocate(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        _offset: types::Filesize,
+        _len: types::Filesize,
+    ) -> Result<(), types::Error> {
+        self.get_file_fd(fd)?;
+        Err(types::Errno::Notsup.into())
+    }
+
+    /// Close a file descriptor.
+    /// NOTE: This is similar to `close` in POSIX.
+    #[instrument(skip(self, _memory))]
+    async fn fd_close(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+    ) -> Result<(), types::Error> {
+        let desc = self
+            .transact()?
+            .descriptors
+            .remove(fd)
+            .ok_or(types::Errno::Badf)?;
+        match desc {
+            Descriptor::Stdin { stream, .. } => {
+                streams::HostInputStream::drop(&mut self.as_wasi_impl(), stream)
+                    .await
+                    .context("failed to call `drop` on `input-stream`")
+            }
+            Descriptor::Stdout { stream, .. } | Descriptor::Stderr { stream, .. } => {
+                streams::HostOutputStream::drop(&mut self.as_wasi_impl(), stream)
+                    .await
+                    .context("failed to call `drop` on `output-stream`")
+            }
+            Descriptor::File(File { fd, .. }) | Descriptor::Directory { fd, .. } => {
+                filesystem::HostDescriptor::drop(&mut self.as_wasi_impl(), fd)
+                    .context("failed to call `drop`")
+            }
+        }
+        .map_err(types::Error::trap)
+    }
+
+    /// Synchronize the data of a file to disk.
+    /// NOTE: This is similar to `fdatasync` in POSIX.
+    #[instrument(skip(self, _memory))]
+    async fn fd_datasync(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+    ) -> Result<(), types::Error> {
+        let fd = self.get_file_fd(fd)?;
+        self.as_wasi_impl().sync_data(fd).await.map_err(|e| {
+            e.try_into()
+                .context("failed to call `sync-data`")
+                .unwrap_or_else(types::Error::trap)
+        })
+    }
+
+    /// Get the attributes of a file descriptor.
+    /// NOTE: This returns similar flags to `fsync(fd, F_GETFL)` in POSIX, as well as additional fields.
+    #[instrument(skip(self, _memory))]
+    async fn fd_fdstat_get(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+    ) -> Result<types::Fdstat, types::Error> {
+        let (fd, blocking, append) = match self.transact()?.get_descriptor(fd)? {
+            Descriptor::Stdin { isatty, .. } => {
+                let fs_rights_base = types::Rights::FD_READ;
+                return Ok(types::Fdstat {
+                    fs_filetype: (*isatty).into(),
+                    fs_flags: types::Fdflags::empty(),
+                    fs_rights_base,
+                    fs_rights_inheriting: fs_rights_base,
+                });
+            }
+            Descriptor::Stdout { isatty, .. } | Descriptor::Stderr { isatty, .. } => {
+                let fs_rights_base = types::Rights::FD_WRITE;
+                return Ok(types::Fdstat {
+                    fs_filetype: (*isatty).into(),
+                    fs_flags: types::Fdflags::empty(),
+                    fs_rights_base,
+                    fs_rights_inheriting: fs_rights_base,
+                });
+            }
+            Descriptor::Directory {
+                preopen_path: Some(_),
+                ..
+            } => {
+                // Hard-coded set or rights expected by many userlands:
+                let fs_rights_base = types::Rights::PATH_CREATE_DIRECTORY
+                    | types::Rights::PATH_CREATE_FILE
+                    | types::Rights::PATH_LINK_SOURCE
+                    | types::Rights::PATH_LINK_TARGET
+                    | types::Rights::PATH_OPEN
+                    | types::Rights::FD_READDIR
+                    | types::Rights::PATH_READLINK
+                    | types::Rights::PATH_RENAME_SOURCE
+                    | types::Rights::PATH_RENAME_TARGET
+                    | types::Rights::PATH_SYMLINK
+                    | types::Rights::PATH_REMOVE_DIRECTORY
+                    | types::Rights::PATH_UNLINK_FILE
+                    | types::Rights::PATH_FILESTAT_GET
+                    | types::Rights::PATH_FILESTAT_SET_TIMES
+                    | types::Rights::FD_FILESTAT_GET
+                    | types::Rights::FD_FILESTAT_SET_TIMES;
+
+                let fs_rights_inheriting = fs_rights_base
+                    | types::Rights::FD_DATASYNC
+                    | types::Rights::FD_READ
+                    | types::Rights::FD_SEEK
+                    | types::Rights::FD_FDSTAT_SET_FLAGS
+                    | types::Rights::FD_SYNC
+                    | types::Rights::FD_TELL
+                    | types::Rights::FD_WRITE
+                    | types::Rights::FD_ADVISE
+                    | types::Rights::FD_ALLOCATE
+                    | types::Rights::FD_FILESTAT_GET
+                    | types::Rights::FD_FILESTAT_SET_SIZE
+                    | types::Rights::FD_FILESTAT_SET_TIMES
+                    | types::Rights::POLL_FD_READWRITE;
+
+                return Ok(types::Fdstat {
+                    fs_filetype: types::Filetype::Directory,
+                    fs_flags: types::Fdflags::empty(),
+                    fs_rights_base,
+                    fs_rights_inheriting,
+                });
+            }
+            Descriptor::Directory { fd, .. } => (fd.borrowed(), BlockingMode::Blocking, false),
+            Descriptor::File(File {
+                fd,
+                blocking_mode,
+                append,
+                ..
+            }) => (fd.borrowed(), *blocking_mode, *append),
+        };
+        let flags = self
+            .as_wasi_impl()
+            .get_flags(fd.borrowed())
+            .await
+            .map_err(|e| {
+                e.try_into()
+                    .context("failed to call `get-flags`")
+                    .unwrap_or_else(types::Error::trap)
+            })?;
+        let fs_filetype = self
+            .as_wasi_impl()
+            .get_type(fd.borrowed())
+            .await
+            .map_err(|e| {
+                e.try_into()
+                    .context("failed to call `get-type`")
+                    .unwrap_or_else(types::Error::trap)
+            })?
+            .try_into()
+            .map_err(types::Error::trap)?;
+        let mut fs_flags = types::Fdflags::empty();
+        let mut fs_rights_base = types::Rights::all();
+        if let types::Filetype::Directory = fs_filetype {
+            fs_rights_base &= !types::Rights::FD_SEEK;
+            fs_rights_base &= !types::Rights::FD_FILESTAT_SET_SIZE;
+        }
+        if !flags.contains(filesystem::DescriptorFlags::READ) {
+            fs_rights_base &= !types::Rights::FD_READ;
+            fs_rights_base &= !types::Rights::FD_READDIR;
+        }
+        if !flags.contains(filesystem::DescriptorFlags::WRITE) {
+            fs_rights_base &= !types::Rights::FD_WRITE;
+        }
+        if flags.contains(filesystem::DescriptorFlags::DATA_INTEGRITY_SYNC) {
+            fs_flags |= types::Fdflags::DSYNC;
+        }
+        if flags.contains(filesystem::DescriptorFlags::REQUESTED_WRITE_SYNC) {
+            fs_flags |= types::Fdflags::RSYNC;
+        }
+        if flags.contains(filesystem::DescriptorFlags::FILE_INTEGRITY_SYNC) {
+            fs_flags |= types::Fdflags::SYNC;
+        }
+        if append {
+            fs_flags |= types::Fdflags::APPEND;
+        }
+        if matches!(blocking, BlockingMode::NonBlocking) {
+            fs_flags |= types::Fdflags::NONBLOCK;
+        }
+        Ok(types::Fdstat {
+            fs_filetype,
+            fs_flags,
+            fs_rights_base,
+            fs_rights_inheriting: fs_rights_base,
+        })
+    }
+
+    /// Adjust the flags associated with a file descriptor.
+    /// NOTE: This is similar to `fcntl(fd, F_SETFL, flags)` in POSIX.
+    #[instrument(skip(self, _memory))]
+    fn fd_fdstat_set_flags(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        flags: types::Fdflags,
+    ) -> Result<(), types::Error> {
+        let mut st = self.transact()?;
+        let File {
+            append,
+            blocking_mode,
+            ..
+        } = st.get_file_mut(fd)?;
+
+        // Only support changing the NONBLOCK or APPEND flags.
+        if flags.contains(types::Fdflags::DSYNC)
+            || flags.contains(types::Fdflags::SYNC)
+            || flags.contains(types::Fdflags::RSYNC)
+        {
+            return Err(types::Errno::Inval.into());
+        }
+        *append = flags.contains(types::Fdflags::APPEND);
+        *blocking_mode = BlockingMode::from_fdflags(&flags);
+        Ok(())
+    }
+
+    /// Does not do anything if `fd` corresponds to a valid descriptor and returns `[types::Errno::Badf]` error otherwise.
+    #[instrument(skip(self, _memory))]
+    fn fd_fdstat_set_rights(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        _fs_rights_base: types::Rights,
+        _fs_rights_inheriting: types::Rights,
+    ) -> Result<(), types::Error> {
+        self.get_fd(fd)?;
+        Ok(())
+    }
+
+    /// Return the attributes of an open file.
+    #[instrument(skip(self, _memory))]
+    async fn fd_filestat_get(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+    ) -> Result<types::Filestat, types::Error> {
+        let t = self.transact()?;
+        let desc = t.get_descriptor(fd)?;
+        match desc {
+            Descriptor::Stdin { isatty, .. }
+            | Descriptor::Stdout { isatty, .. }
+            | Descriptor::Stderr { isatty, .. } => Ok(types::Filestat {
+                dev: 0,
+                ino: 0,
+                filetype: (*isatty).into(),
+                nlink: 0,
+                size: 0,
+                atim: 0,
+                mtim: 0,
+                ctim: 0,
+            }),
+            Descriptor::Directory { fd, .. } | Descriptor::File(File { fd, .. }) => {
+                let fd = fd.borrowed();
+                drop(t);
+                let filesystem::DescriptorStat {
+                    type_,
+                    link_count: nlink,
+                    size,
+                    data_access_timestamp,
+                    data_modification_timestamp,
+                    status_change_timestamp,
+                } = self.as_wasi_impl().stat(fd.borrowed()).await.map_err(|e| {
+                    e.try_into()
+                        .context("failed to call `stat`")
+                        .unwrap_or_else(types::Error::trap)
+                })?;
+                let metadata_hash = self.as_wasi_impl().metadata_hash(fd).await.map_err(|e| {
+                    e.try_into()
+                        .context("failed to call `metadata_hash`")
+                        .unwrap_or_else(types::Error::trap)
+                })?;
+                let filetype = type_.try_into().map_err(types::Error::trap)?;
+                let zero = wall_clock::Datetime {
+                    seconds: 0,
+                    nanoseconds: 0,
+                };
+                let atim = data_access_timestamp.unwrap_or(zero).try_into()?;
+                let mtim = data_modification_timestamp.unwrap_or(zero).try_into()?;
+                let ctim = status_change_timestamp.unwrap_or(zero).try_into()?;
+                Ok(types::Filestat {
+                    dev: 1,
+                    ino: metadata_hash.lower,
+                    filetype,
+                    nlink,
+                    size,
+                    atim,
+                    mtim,
+                    ctim,
+                })
+            }
+        }
+    }
+
+    /// Adjust the size of an open file. If this increases the file's size, the extra bytes are filled with zeros.
+    /// NOTE: This is similar to `ftruncate` in POSIX.
+    #[instrument(skip(self, _memory))]
+    async fn fd_filestat_set_size(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        size: types::Filesize,
+    ) -> Result<(), types::Error> {
+        let fd = self.get_file_fd(fd)?;
+        self.as_wasi_impl().set_size(fd, size).await.map_err(|e| {
+            e.try_into()
+                .context("failed to call `set-size`")
+                .unwrap_or_else(types::Error::trap)
+        })
+    }
+
+    /// Adjust the timestamps of an open file or directory.
+    /// NOTE: This is similar to `futimens` in POSIX.
+    #[instrument(skip(self, _memory))]
+    async fn fd_filestat_set_times(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        atim: types::Timestamp,
+        mtim: types::Timestamp,
+        fst_flags: types::Fstflags,
+    ) -> Result<(), types::Error> {
+        let atim = systimespec(
+            fst_flags.contains(types::Fstflags::ATIM),
+            atim,
+            fst_flags.contains(types::Fstflags::ATIM_NOW),
+        )?;
+        let mtim = systimespec(
+            fst_flags.contains(types::Fstflags::MTIM),
+            mtim,
+            fst_flags.contains(types::Fstflags::MTIM_NOW),
+        )?;
+
+        let fd = self.get_fd(fd)?;
+        self.as_wasi_impl()
+            .set_times(fd, atim, mtim)
+            .await
+            .map_err(|e| {
+                e.try_into()
+                    .context("failed to call `set-times`")
+                    .unwrap_or_else(types::Error::trap)
+            })
+    }
+
+    /// Read from a file descriptor.
+    /// NOTE: This is similar to `readv` in POSIX.
+    #[instrument(skip(self, memory))]
+    async fn fd_read(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        iovs: types::IovecArray,
+    ) -> Result<types::Size, types::Error> {
+        let t = self.transact()?;
+        let desc = t.get_descriptor(fd)?;
+        match desc {
+            Descriptor::File(File {
+                fd,
+                position,
+                // NB: the nonblocking flag is intentionally ignored here and
+                // blocking reads/writes are always performed.
+                blocking_mode: _,
+                ..
+            }) => {
+                let fd = fd.borrowed();
+                let position = position.clone();
+                drop(t);
+                let pos = position.load(Ordering::Relaxed);
+                let file = self.table().get(&fd)?.file()?;
+                let iov = first_non_empty_iovec(memory, iovs)?;
+                let bytes_read = match (file.as_blocking_file(), memory.as_slice_mut(iov)?) {
+                    // Try to read directly into wasm memory where possible
+                    // when the current thread can block and additionally wasm
+                    // memory isn't shared.
+                    (Some(file), Some(mut buf)) => file
+                        .read_at(&mut buf, pos)
+                        .map_err(|e| StreamError::LastOperationFailed(e.into()))?,
+                    // ... otherwise fall back to performing the read on a
+                    // blocking thread and which copies the data back into wasm
+                    // memory.
+                    (_, buf) => {
+                        drop(buf);
+                        let mut buf = vec![0; iov.len() as usize];
+                        let buf = file
+                            .run_blocking(move |file| -> Result<_, types::Error> {
+                                let bytes_read = file
+                                    .read_at(&mut buf, pos)
+                                    .map_err(|e| StreamError::LastOperationFailed(e.into()))?;
+                                buf.truncate(bytes_read);
+                                Ok(buf)
+                            })
+                            .await?;
+                        let iov = iov.get_range(0..u32::try_from(buf.len())?).unwrap();
+                        memory.copy_from_slice(&buf, iov)?;
+                        buf.len()
+                    }
+                };
+
+                let pos = pos
+                    .checked_add(bytes_read.try_into()?)
+                    .ok_or(types::Errno::Overflow)?;
+                position.store(pos, Ordering::Relaxed);
+
+                Ok(bytes_read.try_into()?)
+            }
+            Descriptor::Stdin { stream, .. } => {
+                let stream = stream.borrowed();
+                drop(t);
+                let buf = first_non_empty_iovec(memory, iovs)?;
+                let read = BlockingMode::Blocking
+                    .read(&mut self.as_wasi_impl(), stream, buf.len().try_into()?)
+                    .await?;
+                if read.len() > buf.len().try_into()? {
+                    return Err(types::Errno::Range.into());
+                }
+                let buf = buf.get_range(0..u32::try_from(read.len())?).unwrap();
+                memory.copy_from_slice(&read, buf)?;
+                let n = read.len().try_into()?;
+                Ok(n)
+            }
+            _ => return Err(types::Errno::Badf.into()),
+        }
+    }
+
+    /// Read from a file descriptor, without using and updating the file descriptor's offset.
+    /// NOTE: This is similar to `preadv` in POSIX.
+    #[instrument(skip(self, memory))]
+    async fn fd_pread(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        iovs: types::IovecArray,
+        offset: types::Filesize,
+    ) -> Result<types::Size, types::Error> {
+        let t = self.transact()?;
+        let desc = t.get_descriptor(fd)?;
+        let (buf, read) = match desc {
+            Descriptor::File(File {
+                fd, blocking_mode, ..
+            }) => {
+                let fd = fd.borrowed();
+                let blocking_mode = *blocking_mode;
+                drop(t);
+                let buf = first_non_empty_iovec(memory, iovs)?;
+
+                let stream = self
+                    .as_wasi_impl()
+                    .read_via_stream(fd, offset)
+                    .map_err(|e| {
+                        e.try_into()
+                            .context("failed to call `read-via-stream`")
+                            .unwrap_or_else(types::Error::trap)
+                    })?;
+                let read = blocking_mode
+                    .read(
+                        &mut self.as_wasi_impl(),
+                        stream.borrowed(),
+                        buf.len().try_into()?,
+                    )
+                    .await;
+                streams::HostInputStream::drop(&mut self.as_wasi_impl(), stream)
+                    .await
+                    .map_err(|e| types::Error::trap(e))?;
+                (buf, read?)
+            }
+            Descriptor::Stdin { .. } => {
+                // NOTE: legacy implementation returns SPIPE here
+                return Err(types::Errno::Spipe.into());
+            }
+            _ => return Err(types::Errno::Badf.into()),
+        };
+        if read.len() > buf.len().try_into()? {
+            return Err(types::Errno::Range.into());
+        }
+        let buf = buf.get_range(0..u32::try_from(read.len())?).unwrap();
+        memory.copy_from_slice(&read, buf)?;
+        let n = read.len().try_into()?;
+        Ok(n)
+    }
+
+    /// Write to a file descriptor.
+    /// NOTE: This is similar to `writev` in POSIX.
+    #[instrument(skip(self, memory))]
+    async fn fd_write(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        ciovs: types::CiovecArray,
+    ) -> Result<types::Size, types::Error> {
+        self.fd_write_impl(memory, fd, ciovs, FdWrite::AtCur).await
+    }
+
+    /// Write to a file descriptor, without using and updating the file descriptor's offset.
+    /// NOTE: This is similar to `pwritev` in POSIX.
+    #[instrument(skip(self, memory))]
+    async fn fd_pwrite(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        ciovs: types::CiovecArray,
+        offset: types::Filesize,
+    ) -> Result<types::Size, types::Error> {
+        self.fd_write_impl(memory, fd, ciovs, FdWrite::At(offset))
+            .await
+    }
+
+    /// Return a description of the given preopened file descriptor.
+    #[instrument(skip(self, _memory))]
+    fn fd_prestat_get(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+    ) -> Result<types::Prestat, types::Error> {
+        if let Descriptor::Directory {
+            preopen_path: Some(p),
+            ..
+        } = self.transact()?.get_descriptor(fd)?
+        {
+            let pr_name_len = p.len().try_into()?;
+            return Ok(types::Prestat::Dir(types::PrestatDir { pr_name_len }));
+        }
+        Err(types::Errno::Badf.into()) // NOTE: legacy implementation returns BADF here
+    }
+
+    /// Return a description of the given preopened file descriptor.
+    #[instrument(skip(self, memory))]
+    fn fd_prestat_dir_name(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        path: GuestPtr<u8>,
+        path_max_len: types::Size,
+    ) -> Result<(), types::Error> {
+        let path_max_len = path_max_len.try_into()?;
+        if let Descriptor::Directory {
+            preopen_path: Some(p),
+            ..
+        } = self.transact()?.get_descriptor(fd)?
+        {
+            if p.len() > path_max_len {
+                return Err(types::Errno::Nametoolong.into());
+            }
+            write_bytes(memory, path, p.as_bytes())?;
+            return Ok(());
+        }
+        Err(types::Errno::Notdir.into()) // NOTE: legacy implementation returns NOTDIR here
+    }
+
+    /// Atomically replace a file descriptor by renumbering another file descriptor.
+    #[instrument(skip(self, _memory))]
+    fn fd_renumber(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        from: types::Fd,
+        to: types::Fd,
+    ) -> Result<(), types::Error> {
+        let mut st = self.transact()?;
+        let desc = st.descriptors.remove(from).ok_or(types::Errno::Badf)?;
+        st.descriptors.insert(to.into(), desc);
+        Ok(())
+    }
+
+    /// Move the offset of a file descriptor.
+    /// NOTE: This is similar to `lseek` in POSIX.
+    #[instrument(skip(self, _memory))]
+    async fn fd_seek(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        offset: types::Filedelta,
+        whence: types::Whence,
+    ) -> Result<types::Filesize, types::Error> {
+        let t = self.transact()?;
+        let File { fd, position, .. } = t.get_seekable(fd)?;
+        let fd = fd.borrowed();
+        let position = position.clone();
+        drop(t);
+        let pos = match whence {
+            types::Whence::Set if offset >= 0 => {
+                offset.try_into().map_err(|_| types::Errno::Inval)?
+            }
+            types::Whence::Cur => position
+                .load(Ordering::Relaxed)
+                .checked_add_signed(offset)
+                .ok_or(types::Errno::Inval)?,
+            types::Whence::End => {
+                let filesystem::DescriptorStat { size, .. } =
+                    self.as_wasi_impl().stat(fd).await.map_err(|e| {
+                        e.try_into()
+                            .context("failed to call `stat`")
+                            .unwrap_or_else(types::Error::trap)
+                    })?;
+                size.checked_add_signed(offset).ok_or(types::Errno::Inval)?
+            }
+            _ => return Err(types::Errno::Inval.into()),
+        };
+        position.store(pos, Ordering::Relaxed);
+        Ok(pos)
+    }
+
+    /// Synchronize the data and metadata of a file to disk.
+    /// NOTE: This is similar to `fsync` in POSIX.
+    #[instrument(skip(self, _memory))]
+    async fn fd_sync(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+    ) -> Result<(), types::Error> {
+        let fd = self.get_file_fd(fd)?;
+        self.as_wasi_impl().sync(fd).await.map_err(|e| {
+            e.try_into()
+                .context("failed to call `sync`")
+                .unwrap_or_else(types::Error::trap)
+        })
+    }
+
+    /// Return the current offset of a file descriptor.
+    /// NOTE: This is similar to `lseek(fd, 0, SEEK_CUR)` in POSIX.
+    #[instrument(skip(self, _memory))]
+    fn fd_tell(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+    ) -> Result<types::Filesize, types::Error> {
+        let pos = self
+            .transact()?
+            .get_seekable(fd)
+            .map(|File { position, .. }| position.load(Ordering::Relaxed))?;
+        Ok(pos)
+    }
+
+    #[instrument(skip(self, memory))]
+    async fn fd_readdir(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        buf: GuestPtr<u8>,
+        buf_len: types::Size,
+        cookie: types::Dircookie,
+    ) -> Result<types::Size, types::Error> {
+        let fd = self.get_dir_fd(fd)?;
+        let stream = self
+            .as_wasi_impl()
+            .read_directory(fd.borrowed())
+            .await
+            .map_err(|e| {
+                e.try_into()
+                    .context("failed to call `read-directory`")
+                    .unwrap_or_else(types::Error::trap)
+            })?;
+        let dir_metadata_hash = self
+            .as_wasi_impl()
+            .metadata_hash(fd.borrowed())
+            .await
+            .map_err(|e| {
+                e.try_into()
+                    .context("failed to call `metadata-hash`")
+                    .unwrap_or_else(types::Error::trap)
+            })?;
+        let cookie = cookie.try_into().map_err(|_| types::Errno::Overflow)?;
+
+        let head = [
+            (
+                types::Dirent {
+                    d_next: 1u64.to_le(),
+                    d_ino: dir_metadata_hash.lower.to_le(),
+                    d_type: types::Filetype::Directory,
+                    d_namlen: 1u32.to_le(),
+                },
+                ".".into(),
+            ),
+            (
+                types::Dirent {
+                    d_next: 2u64.to_le(),
+                    d_ino: dir_metadata_hash.lower.to_le(), // NOTE: incorrect, but legacy implementation returns `fd` inode here
+                    d_type: types::Filetype::Directory,
+                    d_namlen: 2u32.to_le(),
+                },
+                "..".into(),
+            ),
+        ];
+
+        let mut dir = Vec::new();
+        for (entry, d_next) in self
+            .table()
+            // remove iterator from table and use it directly:
+            .delete(stream)?
+            .into_iter()
+            .zip(3u64..)
+        {
+            let filesystem::DirectoryEntry { type_, name } = entry.map_err(|e| {
+                e.try_into()
+                    .context("failed to inspect `read-directory` entry")
+                    .unwrap_or_else(types::Error::trap)
+            })?;
+            let metadata_hash = self
+                .as_wasi_impl()
+                .metadata_hash_at(fd.borrowed(), filesystem::PathFlags::empty(), name.clone())
+                .await
+                .map_err(|e| {
+                    e.try_into()
+                        .context("failed to call `metadata-hash-at`")
+                        .unwrap_or_else(types::Error::trap)
+                })?;
+            let d_type = type_.try_into().map_err(types::Error::trap)?;
+            let d_namlen: u32 = name.len().try_into().map_err(|_| types::Errno::Overflow)?;
+            dir.push((
+                types::Dirent {
+                    d_next: d_next.to_le(),
+                    d_ino: metadata_hash.lower.to_le(),
+                    d_type, // endian-invariant
+                    d_namlen: d_namlen.to_le(),
+                },
+                name,
+            ))
+        }
+
+        // assume that `types::Dirent` size always fits in `u32`
+        const DIRENT_SIZE: u32 = size_of::<types::Dirent>() as _;
+        assert_eq!(
+            types::Dirent::guest_size(),
+            DIRENT_SIZE,
+            "Dirent guest repr and host repr should match"
+        );
+        let mut buf = buf;
+        let mut cap = buf_len;
+        for (ref entry, path) in head.into_iter().chain(dir.into_iter()).skip(cookie) {
+            let mut path = path.into_bytes();
+            assert_eq!(
+                1,
+                size_of_val(&entry.d_type),
+                "Dirent member d_type should be endian-invariant"
+            );
+            let entry_len = cap.min(DIRENT_SIZE);
+            let entry = entry as *const _ as _;
+            let entry = unsafe { slice::from_raw_parts(entry, entry_len as _) };
+            cap = cap.checked_sub(entry_len).unwrap();
+            buf = write_bytes(memory, buf, entry)?;
+            if cap == 0 {
+                return Ok(buf_len);
+            }
+
+            if let Ok(cap) = cap.try_into() {
+                // `path` cannot be longer than `usize`, only truncate if `cap` fits in `usize`
+                path.truncate(cap);
+            }
+            cap = cap.checked_sub(path.len() as _).unwrap();
+            buf = write_bytes(memory, buf, &path)?;
+            if cap == 0 {
+                return Ok(buf_len);
+            }
+        }
+        Ok(buf_len.checked_sub(cap).unwrap())
+    }
+
+    #[instrument(skip(self, memory))]
+    async fn path_create_directory(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        dirfd: types::Fd,
+        path: GuestPtr<str>,
+    ) -> Result<(), types::Error> {
+        let dirfd = self.get_dir_fd(dirfd)?;
+        let path = read_string(memory, path)?;
+        self.as_wasi_impl()
+            .create_directory_at(dirfd.borrowed(), path)
+            .await
+            .map_err(|e| {
+                e.try_into()
+                    .context("failed to call `create-directory-at`")
+                    .unwrap_or_else(types::Error::trap)
+            })
+    }
+
+    /// Return the attributes of a file or directory.
+    /// NOTE: This is similar to `stat` in POSIX.
+    #[instrument(skip(self, memory))]
+    async fn path_filestat_get(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        dirfd: types::Fd,
+        flags: types::Lookupflags,
+        path: GuestPtr<str>,
+    ) -> Result<types::Filestat, types::Error> {
+        let dirfd = self.get_dir_fd(dirfd)?;
+        let path = read_string(memory, path)?;
+        let filesystem::DescriptorStat {
+            type_,
+            link_count: nlink,
+            size,
+            data_access_timestamp,
+            data_modification_timestamp,
+            status_change_timestamp,
+        } = self
+            .as_wasi_impl()
+            .stat_at(dirfd.borrowed(), flags.into(), path.clone())
+            .await
+            .map_err(|e| {
+                e.try_into()
+                    .context("failed to call `stat-at`")
+                    .unwrap_or_else(types::Error::trap)
+            })?;
+        let metadata_hash = self
+            .as_wasi_impl()
+            .metadata_hash_at(dirfd, flags.into(), path)
+            .await
+            .map_err(|e| {
+                e.try_into()
+                    .context("failed to call `metadata-hash-at`")
+                    .unwrap_or_else(types::Error::trap)
+            })?;
+        let filetype = type_.try_into().map_err(types::Error::trap)?;
+        let zero = wall_clock::Datetime {
+            seconds: 0,
+            nanoseconds: 0,
+        };
+        let atim = data_access_timestamp.unwrap_or(zero).try_into()?;
+        let mtim = data_modification_timestamp.unwrap_or(zero).try_into()?;
+        let ctim = status_change_timestamp.unwrap_or(zero).try_into()?;
+        Ok(types::Filestat {
+            dev: 1,
+            ino: metadata_hash.lower,
+            filetype,
+            nlink,
+            size,
+            atim,
+            mtim,
+            ctim,
+        })
+    }
+
+    /// Adjust the timestamps of a file or directory.
+    /// NOTE: This is similar to `utimensat` in POSIX.
+    #[instrument(skip(self, memory))]
+    async fn path_filestat_set_times(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        dirfd: types::Fd,
+        flags: types::Lookupflags,
+        path: GuestPtr<str>,
+        atim: types::Timestamp,
+        mtim: types::Timestamp,
+        fst_flags: types::Fstflags,
+    ) -> Result<(), types::Error> {
+        let atim = systimespec(
+            fst_flags.contains(types::Fstflags::ATIM),
+            atim,
+            fst_flags.contains(types::Fstflags::ATIM_NOW),
+        )?;
+        let mtim = systimespec(
+            fst_flags.contains(types::Fstflags::MTIM),
+            mtim,
+            fst_flags.contains(types::Fstflags::MTIM_NOW),
+        )?;
+
+        let dirfd = self.get_dir_fd(dirfd)?;
+        let path = read_string(memory, path)?;
+        self.as_wasi_impl()
+            .set_times_at(dirfd, flags.into(), path, atim, mtim)
+            .await
+            .map_err(|e| {
+                e.try_into()
+                    .context("failed to call `set-times-at`")
+                    .unwrap_or_else(types::Error::trap)
+            })
+    }
+
+    /// Create a hard link.
+    /// NOTE: This is similar to `linkat` in POSIX.
+    #[instrument(skip(self, memory))]
+    async fn path_link(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        src_fd: types::Fd,
+        src_flags: types::Lookupflags,
+        src_path: GuestPtr<str>,
+        target_fd: types::Fd,
+        target_path: GuestPtr<str>,
+    ) -> Result<(), types::Error> {
+        let src_fd = self.get_dir_fd(src_fd)?;
+        let target_fd = self.get_dir_fd(target_fd)?;
+        let src_path = read_string(memory, src_path)?;
+        let target_path = read_string(memory, target_path)?;
+        self.as_wasi_impl()
+            .link_at(src_fd, src_flags.into(), src_path, target_fd, target_path)
+            .await
+            .map_err(|e| {
+                e.try_into()
+                    .context("failed to call `link-at`")
+                    .unwrap_or_else(types::Error::trap)
+            })
+    }
+
+    /// Open a file or directory.
+    /// NOTE: This is similar to `openat` in POSIX.
+    #[instrument(skip(self, memory))]
+    async fn path_open(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        dirfd: types::Fd,
+        dirflags: types::Lookupflags,
+        path: GuestPtr<str>,
+        oflags: types::Oflags,
+        fs_rights_base: types::Rights,
+        _fs_rights_inheriting: types::Rights,
+        fdflags: types::Fdflags,
+    ) -> Result<types::Fd, types::Error> {
+        let path = read_string(memory, path)?;
+
+        let mut flags = filesystem::DescriptorFlags::empty();
+        if fs_rights_base.contains(types::Rights::FD_READ) {
+            flags |= filesystem::DescriptorFlags::READ;
+        }
+        if fs_rights_base.contains(types::Rights::FD_WRITE) {
+            flags |= filesystem::DescriptorFlags::WRITE;
+        }
+        if fdflags.contains(types::Fdflags::SYNC) {
+            flags |= filesystem::DescriptorFlags::FILE_INTEGRITY_SYNC;
+        }
+        if fdflags.contains(types::Fdflags::DSYNC) {
+            flags |= filesystem::DescriptorFlags::DATA_INTEGRITY_SYNC;
+        }
+        if fdflags.contains(types::Fdflags::RSYNC) {
+            flags |= filesystem::DescriptorFlags::REQUESTED_WRITE_SYNC;
+        }
+
+        let t = self.transact()?;
+        let dirfd = match t.get_descriptor(dirfd)? {
+            Descriptor::Directory { fd, .. } => fd.borrowed(),
+            Descriptor::File(_) => return Err(types::Errno::Notdir.into()),
+            _ => return Err(types::Errno::Badf.into()),
+        };
+        drop(t);
+        let fd = self
+            .as_wasi_impl()
+            .open_at(dirfd, dirflags.into(), path, oflags.into(), flags)
+            .await
+            .map_err(|e| {
+                e.try_into()
+                    .context("failed to call `open-at`")
+                    .unwrap_or_else(types::Error::trap)
+            })?;
+        let mut t = self.transact()?;
+        let desc = match t.view.table().get(&fd)? {
+            crate::filesystem::Descriptor::Dir(_) => Descriptor::Directory {
+                fd,
+                preopen_path: None,
+            },
+            crate::filesystem::Descriptor::File(_) => Descriptor::File(File {
+                fd,
+                position: Default::default(),
+                append: fdflags.contains(types::Fdflags::APPEND),
+                blocking_mode: BlockingMode::from_fdflags(&fdflags),
+            }),
+        };
+        let fd = t.descriptors.push(desc)?;
+        Ok(fd.into())
+    }
+
+    /// Read the contents of a symbolic link.
+    /// NOTE: This is similar to `readlinkat` in POSIX.
+    #[instrument(skip(self, memory))]
+    async fn path_readlink(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        dirfd: types::Fd,
+        path: GuestPtr<str>,
+        buf: GuestPtr<u8>,
+        buf_len: types::Size,
+    ) -> Result<types::Size, types::Error> {
+        let dirfd = self.get_dir_fd(dirfd)?;
+        let path = read_string(memory, path)?;
+        let mut path = self
+            .as_wasi_impl()
+            .readlink_at(dirfd, path)
+            .await
+            .map_err(|e| {
+                e.try_into()
+                    .context("failed to call `readlink-at`")
+                    .unwrap_or_else(types::Error::trap)
+            })?
+            .into_bytes();
+        if let Ok(buf_len) = buf_len.try_into() {
+            // `path` cannot be longer than `usize`, only truncate if `buf_len` fits in `usize`
+            path.truncate(buf_len);
+        }
+        let n = path.len().try_into().map_err(|_| types::Errno::Overflow)?;
+        write_bytes(memory, buf, &path)?;
+        Ok(n)
+    }
+
+    #[instrument(skip(self, memory))]
+    async fn path_remove_directory(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        dirfd: types::Fd,
+        path: GuestPtr<str>,
+    ) -> Result<(), types::Error> {
+        let dirfd = self.get_dir_fd(dirfd)?;
+        let path = read_string(memory, path)?;
+        self.as_wasi_impl()
+            .remove_directory_at(dirfd, path)
+            .await
+            .map_err(|e| {
+                e.try_into()
+                    .context("failed to call `remove-directory-at`")
+                    .unwrap_or_else(types::Error::trap)
+            })
+    }
+
+    /// Rename a file or directory.
+    /// NOTE: This is similar to `renameat` in POSIX.
+    #[instrument(skip(self, memory))]
+    async fn path_rename(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        src_fd: types::Fd,
+        src_path: GuestPtr<str>,
+        dest_fd: types::Fd,
+        dest_path: GuestPtr<str>,
+    ) -> Result<(), types::Error> {
+        let src_fd = self.get_dir_fd(src_fd)?;
+        let dest_fd = self.get_dir_fd(dest_fd)?;
+        let src_path = read_string(memory, src_path)?;
+        let dest_path = read_string(memory, dest_path)?;
+        self.as_wasi_impl()
+            .rename_at(src_fd, src_path, dest_fd, dest_path)
+            .await
+            .map_err(|e| {
+                e.try_into()
+                    .context("failed to call `rename-at`")
+                    .unwrap_or_else(types::Error::trap)
+            })
+    }
+
+    #[instrument(skip(self, memory))]
+    async fn path_symlink(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        src_path: GuestPtr<str>,
+        dirfd: types::Fd,
+        dest_path: GuestPtr<str>,
+    ) -> Result<(), types::Error> {
+        let dirfd = self.get_dir_fd(dirfd)?;
+        let src_path = read_string(memory, src_path)?;
+        let dest_path = read_string(memory, dest_path)?;
+        self.as_wasi_impl()
+            .symlink_at(dirfd.borrowed(), src_path, dest_path)
+            .await
+            .map_err(|e| {
+                e.try_into()
+                    .context("failed to call `symlink-at`")
+                    .unwrap_or_else(types::Error::trap)
+            })
+    }
+
+    #[instrument(skip(self, memory))]
+    async fn path_unlink_file(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        dirfd: types::Fd,
+        path: GuestPtr<str>,
+    ) -> Result<(), types::Error> {
+        let dirfd = self.get_dir_fd(dirfd)?;
+        let path = memory.as_cow_str(path)?.into_owned();
+        self.as_wasi_impl()
+            .unlink_file_at(dirfd.borrowed(), path)
+            .await
+            .map_err(|e| {
+                e.try_into()
+                    .context("failed to call `unlink-file-at`")
+                    .unwrap_or_else(types::Error::trap)
+            })
+    }
+
+    #[instrument(skip(self, memory))]
+    async fn poll_oneoff(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        subs: GuestPtr<types::Subscription>,
+        events: GuestPtr<types::Event>,
+        nsubscriptions: types::Size,
+    ) -> Result<types::Size, types::Error> {
+        if nsubscriptions == 0 {
+            // Indefinite sleeping is not supported in preview1.
+            return Err(types::Errno::Inval.into());
+        }
+
+        // This is a special case where `poll_oneoff` is just sleeping
+        // on a single relative timer event. This special case was added
+        // after experimental observations showed that std::thread::sleep
+        // results in more consistent sleep times. This design ensures that
+        // wasmtime can handle real-time requirements more accurately.
+        if nsubscriptions == 1 {
+            let sub = memory.read(subs)?;
+            if let types::SubscriptionU::Clock(clocksub) = sub.u {
+                if !clocksub
+                    .flags
+                    .contains(types::Subclockflags::SUBSCRIPTION_CLOCK_ABSTIME)
+                    && self.ctx().allow_blocking_current_thread
+                {
+                    std::thread::sleep(std::time::Duration::from_nanos(clocksub.timeout));
+                    memory.write(
+                        events,
+                        types::Event {
+                            userdata: sub.userdata,
+                            error: types::Errno::Success,
+                            type_: types::Eventtype::Clock,
+                            fd_readwrite: types::EventFdReadwrite {
+                                flags: types::Eventrwflags::empty(),
+                                nbytes: 1,
+                            },
+                        },
+                    )?;
+                    return Ok(1);
+                }
+            }
+        }
+
+        let subs = subs.as_array(nsubscriptions);
+        let events = events.as_array(nsubscriptions);
+
+        let n = usize::try_from(nsubscriptions).unwrap_or(usize::MAX);
+        let mut pollables = Vec::with_capacity(n);
+        for sub in subs.iter() {
+            let sub = memory.read(sub?)?;
+            let p = match sub.u {
+                types::SubscriptionU::Clock(types::SubscriptionClock {
+                    id,
+                    timeout,
+                    flags,
+                    ..
+                }) => {
+                    let absolute = flags.contains(types::Subclockflags::SUBSCRIPTION_CLOCK_ABSTIME);
+                    let (timeout, absolute) = match id {
+                        types::Clockid::Monotonic => (timeout, absolute),
+                        types::Clockid::Realtime if !absolute => (timeout, false),
+                        types::Clockid::Realtime => {
+                            let now = wall_clock::Host::now(&mut self.as_wasi_impl())
+                                .context("failed to call `wall_clock::now`")
+                                .map_err(types::Error::trap)?;
+
+                            // Convert `timeout` to `Datetime` format.
+                            let seconds = timeout / 1_000_000_000;
+                            let nanoseconds = timeout % 1_000_000_000;
+
+                            let timeout = if now.seconds < seconds
+                                || now.seconds == seconds
+                                    && u64::from(now.nanoseconds) < nanoseconds
+                            {
+                                // `now` is less than `timeout`, which is expressible as u64,
+                                // subtract the nanosecond counts directly
+                                now.seconds * 1_000_000_000 + u64::from(now.nanoseconds) - timeout
+                            } else {
+                                0
+                            };
+                            (timeout, false)
+                        }
+                        _ => return Err(types::Errno::Inval.into()),
+                    };
+                    if absolute {
+                        monotonic_clock::Host::subscribe_instant(&mut self.as_wasi_impl(), timeout)
+                            .context("failed to call `monotonic_clock::subscribe_instant`")
+                            .map_err(types::Error::trap)?
+                    } else {
+                        monotonic_clock::Host::subscribe_duration(&mut self.as_wasi_impl(), timeout)
+                            .context("failed to call `monotonic_clock::subscribe_duration`")
+                            .map_err(types::Error::trap)?
+                    }
+                }
+                types::SubscriptionU::FdRead(types::SubscriptionFdReadwrite {
+                    file_descriptor,
+                }) => {
+                    let stream = {
+                        let t = self.transact()?;
+                        let desc = t.get_descriptor(file_descriptor)?;
+                        match desc {
+                            Descriptor::Stdin { stream, .. } => stream.borrowed(),
+                            Descriptor::File(File { fd, position, .. }) => {
+                                let pos = position.load(Ordering::Relaxed);
+                                let fd = fd.borrowed();
+                                drop(t);
+                                self.as_wasi_impl().read_via_stream(fd, pos).map_err(|e| {
+                                    e.try_into()
+                                        .context("failed to call `read-via-stream`")
+                                        .unwrap_or_else(types::Error::trap)
+                                })?
+                            }
+                            // TODO: Support sockets
+                            _ => return Err(types::Errno::Badf.into()),
+                        }
+                    };
+                    streams::HostInputStream::subscribe(&mut self.as_wasi_impl(), stream)
+                        .context("failed to call `subscribe` on `input-stream`")
+                        .map_err(types::Error::trap)?
+                }
+                types::SubscriptionU::FdWrite(types::SubscriptionFdReadwrite {
+                    file_descriptor,
+                }) => {
+                    let stream = {
+                        let t = self.transact()?;
+                        let desc = t.get_descriptor(file_descriptor)?;
+                        match desc {
+                            Descriptor::Stdout { stream, .. }
+                            | Descriptor::Stderr { stream, .. } => stream.borrowed(),
+                            Descriptor::File(File {
+                                fd,
+                                position,
+                                append,
+                                ..
+                            }) => {
+                                let fd = fd.borrowed();
+                                let position = position.clone();
+                                let append = *append;
+                                drop(t);
+                                if append {
+                                    self.as_wasi_impl().append_via_stream(fd).map_err(|e| {
+                                        e.try_into()
+                                            .context("failed to call `append-via-stream`")
+                                            .unwrap_or_else(types::Error::trap)
+                                    })?
+                                } else {
+                                    let pos = position.load(Ordering::Relaxed);
+                                    self.as_wasi_impl().write_via_stream(fd, pos).map_err(|e| {
+                                        e.try_into()
+                                            .context("failed to call `write-via-stream`")
+                                            .unwrap_or_else(types::Error::trap)
+                                    })?
+                                }
+                            }
+                            // TODO: Support sockets
+                            _ => return Err(types::Errno::Badf.into()),
+                        }
+                    };
+                    streams::HostOutputStream::subscribe(&mut self.as_wasi_impl(), stream)
+                        .context("failed to call `subscribe` on `output-stream`")
+                        .map_err(types::Error::trap)?
+                }
+            };
+            pollables.push(p);
+        }
+        let ready: HashSet<_> = self
+            .as_wasi_impl()
+            .poll(pollables)
+            .await
+            .context("failed to call `poll-oneoff`")
+            .map_err(types::Error::trap)?
+            .into_iter()
+            .collect();
+
+        let mut count: types::Size = 0;
+        for (sub, event) in (0..)
+            .zip(subs.iter())
+            .filter_map(|(idx, sub)| ready.contains(&idx).then_some(sub))
+            .zip(events.iter())
+        {
+            let sub = memory.read(sub?)?;
+            let event = event?;
+            let e = match sub.u {
+                types::SubscriptionU::Clock(..) => types::Event {
+                    userdata: sub.userdata,
+                    error: types::Errno::Success,
+                    type_: types::Eventtype::Clock,
+                    fd_readwrite: types::EventFdReadwrite {
+                        flags: types::Eventrwflags::empty(),
+                        nbytes: 0,
+                    },
+                },
+                types::SubscriptionU::FdRead(types::SubscriptionFdReadwrite {
+                    file_descriptor,
+                }) => {
+                    let t = self.transact()?;
+                    let desc = t.get_descriptor(file_descriptor)?;
+                    match desc {
+                        Descriptor::Stdin { .. } => types::Event {
+                            userdata: sub.userdata,
+                            error: types::Errno::Success,
+                            type_: types::Eventtype::FdRead,
+                            fd_readwrite: types::EventFdReadwrite {
+                                flags: types::Eventrwflags::empty(),
+                                nbytes: 1,
+                            },
+                        },
+                        Descriptor::File(File { fd, position, .. }) => {
+                            let fd = fd.borrowed();
+                            let position = position.clone();
+                            drop(t);
+                            match self.as_wasi_impl().stat(fd).await? {
+                                filesystem::DescriptorStat { size, .. } => {
+                                    let pos = position.load(Ordering::Relaxed);
+                                    let nbytes = size.saturating_sub(pos);
+                                    types::Event {
+                                        userdata: sub.userdata,
+                                        error: types::Errno::Success,
+                                        type_: types::Eventtype::FdRead,
+                                        fd_readwrite: types::EventFdReadwrite {
+                                            flags: if nbytes == 0 {
+                                                types::Eventrwflags::FD_READWRITE_HANGUP
+                                            } else {
+                                                types::Eventrwflags::empty()
+                                            },
+                                            nbytes: 1,
+                                        },
+                                    }
+                                }
+                            }
+                        }
+                        // TODO: Support sockets
+                        _ => return Err(types::Errno::Badf.into()),
+                    }
+                }
+                types::SubscriptionU::FdWrite(types::SubscriptionFdReadwrite {
+                    file_descriptor,
+                }) => {
+                    let t = self.transact()?;
+                    let desc = t.get_descriptor(file_descriptor)?;
+                    match desc {
+                        Descriptor::Stdout { .. } | Descriptor::Stderr { .. } => types::Event {
+                            userdata: sub.userdata,
+                            error: types::Errno::Success,
+                            type_: types::Eventtype::FdWrite,
+                            fd_readwrite: types::EventFdReadwrite {
+                                flags: types::Eventrwflags::empty(),
+                                nbytes: 1,
+                            },
+                        },
+                        Descriptor::File(_) => types::Event {
+                            userdata: sub.userdata,
+                            error: types::Errno::Success,
+                            type_: types::Eventtype::FdWrite,
+                            fd_readwrite: types::EventFdReadwrite {
+                                flags: types::Eventrwflags::empty(),
+                                nbytes: 1,
+                            },
+                        },
+                        // TODO: Support sockets
+                        _ => return Err(types::Errno::Badf.into()),
+                    }
+                }
+            };
+            memory.write(event, e)?;
+            count = count
+                .checked_add(1)
+                .ok_or_else(|| types::Error::from(types::Errno::Overflow))?
+        }
+        Ok(count)
+    }
+
+    #[instrument(skip(self, _memory))]
+    fn proc_exit(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        status: types::Exitcode,
+    ) -> anyhow::Error {
+        // Check that the status is within WASI's range.
+        if status >= 126 {
+            return anyhow::Error::msg("exit with invalid exit status outside of [0..126)");
+        }
+        crate::I32Exit(status as i32).into()
+    }
+
+    #[instrument(skip(self, _memory))]
+    fn proc_raise(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        _sig: types::Signal,
+    ) -> Result<(), types::Error> {
+        Err(types::Errno::Notsup.into())
+    }
+
+    #[instrument(skip(self, _memory))]
+    fn sched_yield(&mut self, _memory: &mut GuestMemory<'_>) -> Result<(), types::Error> {
+        // No such thing in preview 2. Intentionally left empty.
+        Ok(())
+    }
+
+    #[instrument(skip(self, memory))]
+    fn random_get(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        buf: GuestPtr<u8>,
+        buf_len: types::Size,
+    ) -> Result<(), types::Error> {
+        let rand = self
+            .as_wasi_impl()
+            .get_random_bytes(buf_len.into())
+            .context("failed to call `get-random-bytes`")
+            .map_err(types::Error::trap)?;
+        write_bytes(memory, buf, &rand)?;
+        Ok(())
+    }
+
+    #[allow(unused_variables)]
+    #[instrument(skip(self, _memory))]
+    fn sock_accept(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        flags: types::Fdflags,
+    ) -> Result<types::Fd, types::Error> {
+        tracing::warn!("preview1 sock_accept is not implemented");
+        self.transact()?.get_descriptor(fd)?;
+        Err(types::Errno::Notsock.into())
+    }
+
+    #[allow(unused_variables)]
+    #[instrument(skip(self, _memory))]
+    fn sock_recv(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        ri_data: types::IovecArray,
+        ri_flags: types::Riflags,
+    ) -> Result<(types::Size, types::Roflags), types::Error> {
+        tracing::warn!("preview1 sock_recv is not implemented");
+        self.transact()?.get_descriptor(fd)?;
+        Err(types::Errno::Notsock.into())
+    }
+
+    #[allow(unused_variables)]
+    #[instrument(skip(self, _memory))]
+    fn sock_send(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        si_data: types::CiovecArray,
+        _si_flags: types::Siflags,
+    ) -> Result<types::Size, types::Error> {
+        tracing::warn!("preview1 sock_send is not implemented");
+        self.transact()?.get_descriptor(fd)?;
+        Err(types::Errno::Notsock.into())
+    }
+
+    #[allow(unused_variables)]
+    #[instrument(skip(self, _memory))]
+    fn sock_shutdown(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+        how: types::Sdflags,
+    ) -> Result<(), types::Error> {
+        tracing::warn!("preview1 sock_shutdown is not implemented");
+        self.transact()?.get_descriptor(fd)?;
+        Err(types::Errno::Notsock.into())
+    }
+}
+
+trait ResourceExt<T> {
+    fn borrowed(&self) -> Resource<T>;
+}
+
+impl<T: 'static> ResourceExt<T> for Resource<T> {
+    fn borrowed(&self) -> Resource<T> {
+        Resource::new_borrow(self.rep())
+    }
+}
diff --git a/crates/wasi/src/preview2/clocks.rs b/crates/wasi/src/preview2/clocks.rs
deleted file mode 100644
index 53bca0507058..000000000000
--- a/crates/wasi/src/preview2/clocks.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-pub mod host;
-use cap_std::time::Duration;
-
-pub trait HostWallClock: Send + Sync {
-    fn resolution(&self) -> Duration;
-    fn now(&self) -> Duration;
-}
-
-pub trait HostMonotonicClock: Send + Sync {
-    fn resolution(&self) -> u64;
-    fn now(&self) -> u64;
-}
diff --git a/crates/wasi/src/preview2/clocks/host.rs b/crates/wasi/src/preview2/clocks/host.rs
deleted file mode 100644
index e0c9906c7598..000000000000
--- a/crates/wasi/src/preview2/clocks/host.rs
+++ /dev/null
@@ -1,73 +0,0 @@
-use super::{HostMonotonicClock, HostWallClock};
-use cap_std::time::{Duration, Instant, SystemClock};
-use cap_std::{ambient_authority, AmbientAuthority};
-use cap_time_ext::{MonotonicClockExt, SystemClockExt};
-
-pub struct WallClock {
-    /// The underlying system clock.
-    clock: cap_std::time::SystemClock,
-}
-
-impl WallClock {
-    pub fn new(ambient_authority: AmbientAuthority) -> Self {
-        Self {
-            clock: cap_std::time::SystemClock::new(ambient_authority),
-        }
-    }
-}
-
-impl HostWallClock for WallClock {
-    fn resolution(&self) -> Duration {
-        self.clock.resolution()
-    }
-
-    fn now(&self) -> Duration {
-        // WASI defines wall clocks to return "Unix time".
-        self.clock
-            .now()
-            .duration_since(SystemClock::UNIX_EPOCH)
-            .unwrap()
-    }
-}
-
-pub struct MonotonicClock {
-    /// The underlying system clock.
-    clock: cap_std::time::MonotonicClock,
-
-    /// The `Instant` this clock was created. All returned times are
-    /// durations since that time.
-    initial: Instant,
-}
-
-impl MonotonicClock {
-    pub fn new(ambient_authority: AmbientAuthority) -> Self {
-        let clock = cap_std::time::MonotonicClock::new(ambient_authority);
-        let initial = clock.now();
-        Self { clock, initial }
-    }
-}
-
-impl HostMonotonicClock for MonotonicClock {
-    fn resolution(&self) -> u64 {
-        self.clock.resolution().as_nanos().try_into().unwrap()
-    }
-
-    fn now(&self) -> u64 {
-        // Unwrap here and in `resolution` above; a `u64` is wide enough to
-        // hold over 584 years of nanoseconds.
-        self.clock
-            .now()
-            .duration_since(self.initial)
-            .as_nanos()
-            .try_into()
-            .unwrap()
-    }
-}
-
-pub fn monotonic_clock() -> Box<dyn HostMonotonicClock + Send + Sync> {
-    Box::new(MonotonicClock::new(ambient_authority()))
-}
-
-pub fn wall_clock() -> Box<dyn HostWallClock + Send + Sync> {
-    Box::new(WallClock::new(ambient_authority()))
-}
diff --git a/crates/wasi/src/preview2/command.rs b/crates/wasi/src/preview2/command.rs
deleted file mode 100644
index 7702e2a706da..000000000000
--- a/crates/wasi/src/preview2/command.rs
+++ /dev/null
@@ -1,123 +0,0 @@
-use crate::preview2::WasiView;
-
-wasmtime::component::bindgen!({
-    world: "wasi:cli/command",
-    tracing: true,
-    async: true,
-    trappable_error_type: {
-        "wasi:filesystem/types"::"error-code": Error,
-        "wasi:sockets/tcp"::"error-code": Error,
-    },
-    with: {
-       "wasi:filesystem/types": crate::preview2::bindings::filesystem::types,
-       "wasi:filesystem/preopens": crate::preview2::bindings::filesystem::preopens,
-       "wasi:sockets/tcp": crate::preview2::bindings::sockets::tcp,
-       "wasi:clocks/monotonic_clock": crate::preview2::bindings::clocks::monotonic_clock,
-       "wasi:io/poll": crate::preview2::bindings::io::poll,
-       "wasi:io/streams": crate::preview2::bindings::io::streams,
-       "wasi:clocks/timezone": crate::preview2::bindings::clocks::timezone,
-       "wasi:clocks/wall_clock": crate::preview2::bindings::clocks::wall_clock,
-       "wasi:random/random": crate::preview2::bindings::random::random,
-       "wasi:cli/environment": crate::preview2::bindings::cli::environment,
-       "wasi:cli/exit": crate::preview2::bindings::cli::exit,
-       "wasi:cli/stdin": crate::preview2::bindings::cli::stdin,
-       "wasi:cli/stdout": crate::preview2::bindings::cli::stdout,
-       "wasi:cli/stderr": crate::preview2::bindings::cli::stderr,
-       "wasi:cli/terminal-input": crate::preview2::bindings::cli::terminal_input,
-       "wasi:cli/terminal-output": crate::preview2::bindings::cli::terminal_output,
-       "wasi:cli/terminal-stdin": crate::preview2::bindings::cli::terminal_stdin,
-       "wasi:cli/terminal-stdout": crate::preview2::bindings::cli::terminal_stdout,
-       "wasi:cli/terminal-stderr": crate::preview2::bindings::cli::terminal_stderr,
-    },
-});
-
-pub fn add_to_linker<T: WasiView>(l: &mut wasmtime::component::Linker<T>) -> anyhow::Result<()> {
-    crate::preview2::bindings::clocks::wall_clock::add_to_linker(l, |t| t)?;
-    crate::preview2::bindings::clocks::monotonic_clock::add_to_linker(l, |t| t)?;
-    crate::preview2::bindings::clocks::timezone::add_to_linker(l, |t| t)?;
-    crate::preview2::bindings::filesystem::types::add_to_linker(l, |t| t)?;
-    crate::preview2::bindings::filesystem::preopens::add_to_linker(l, |t| t)?;
-    crate::preview2::bindings::io::poll::add_to_linker(l, |t| t)?;
-    crate::preview2::bindings::io::streams::add_to_linker(l, |t| t)?;
-    crate::preview2::bindings::random::random::add_to_linker(l, |t| t)?;
-    crate::preview2::bindings::cli::exit::add_to_linker(l, |t| t)?;
-    crate::preview2::bindings::cli::environment::add_to_linker(l, |t| t)?;
-    crate::preview2::bindings::cli::stdin::add_to_linker(l, |t| t)?;
-    crate::preview2::bindings::cli::stdout::add_to_linker(l, |t| t)?;
-    crate::preview2::bindings::cli::stderr::add_to_linker(l, |t| t)?;
-    crate::preview2::bindings::cli::terminal_input::add_to_linker(l, |t| t)?;
-    crate::preview2::bindings::cli::terminal_output::add_to_linker(l, |t| t)?;
-    crate::preview2::bindings::cli::terminal_stdin::add_to_linker(l, |t| t)?;
-    crate::preview2::bindings::cli::terminal_stdout::add_to_linker(l, |t| t)?;
-    crate::preview2::bindings::cli::terminal_stderr::add_to_linker(l, |t| t)?;
-    crate::preview2::bindings::sockets::tcp::add_to_linker(l, |t| t)?;
-    crate::preview2::bindings::sockets::tcp_create_socket::add_to_linker(l, |t| t)?;
-    crate::preview2::bindings::sockets::instance_network::add_to_linker(l, |t| t)?;
-    crate::preview2::bindings::sockets::network::add_to_linker(l, |t| t)?;
-    crate::preview2::bindings::sockets::ip_name_lookup::add_to_linker(l, |t| t)?;
-    Ok(())
-}
-
-pub mod sync {
-    use crate::preview2::WasiView;
-
-    wasmtime::component::bindgen!({
-        world: "wasi:cli/command",
-        tracing: true,
-        async: false,
-        trappable_error_type: {
-            "wasi:filesystem/types"::"error-code": Error,
-            "wasi:sockets/tcp"::"error-code": Error,
-        },
-        with: {
-           "wasi:filesystem/types": crate::preview2::bindings::sync_io::filesystem::types,
-           "wasi:filesystem/preopens": crate::preview2::bindings::filesystem::preopens,
-           "wasi:sockets/tcp": crate::preview2::bindings::sockets::tcp,
-           "wasi:clocks/monotonic_clock": crate::preview2::bindings::clocks::monotonic_clock,
-           "wasi:io/poll": crate::preview2::bindings::sync_io::io::poll,
-           "wasi:io/streams": crate::preview2::bindings::sync_io::io::streams,
-           "wasi:clocks/timezone": crate::preview2::bindings::clocks::timezone,
-           "wasi:clocks/wall_clock": crate::preview2::bindings::clocks::wall_clock,
-           "wasi:random/random": crate::preview2::bindings::random::random,
-           "wasi:cli/environment": crate::preview2::bindings::cli::environment,
-           "wasi:cli/exit": crate::preview2::bindings::cli::exit,
-           "wasi:cli/stdin": crate::preview2::bindings::cli::stdin,
-           "wasi:cli/stdout": crate::preview2::bindings::cli::stdout,
-           "wasi:cli/stderr": crate::preview2::bindings::cli::stderr,
-           "wasi:cli/terminal-input": crate::preview2::bindings::cli::terminal_input,
-           "wasi:cli/terminal-output": crate::preview2::bindings::cli::terminal_output,
-           "wasi:cli/terminal-stdin": crate::preview2::bindings::cli::terminal_stdin,
-           "wasi:cli/terminal-stdout": crate::preview2::bindings::cli::terminal_stdout,
-           "wasi:cli/terminal-stderr": crate::preview2::bindings::cli::terminal_stderr,
-        },
-    });
-
-    pub fn add_to_linker<T: WasiView>(
-        l: &mut wasmtime::component::Linker<T>,
-    ) -> anyhow::Result<()> {
-        crate::preview2::bindings::clocks::wall_clock::add_to_linker(l, |t| t)?;
-        crate::preview2::bindings::clocks::monotonic_clock::add_to_linker(l, |t| t)?;
-        crate::preview2::bindings::clocks::timezone::add_to_linker(l, |t| t)?;
-        crate::preview2::bindings::sync_io::filesystem::types::add_to_linker(l, |t| t)?;
-        crate::preview2::bindings::filesystem::preopens::add_to_linker(l, |t| t)?;
-        crate::preview2::bindings::sync_io::io::poll::add_to_linker(l, |t| t)?;
-        crate::preview2::bindings::sync_io::io::streams::add_to_linker(l, |t| t)?;
-        crate::preview2::bindings::random::random::add_to_linker(l, |t| t)?;
-        crate::preview2::bindings::cli::exit::add_to_linker(l, |t| t)?;
-        crate::preview2::bindings::cli::environment::add_to_linker(l, |t| t)?;
-        crate::preview2::bindings::cli::stdin::add_to_linker(l, |t| t)?;
-        crate::preview2::bindings::cli::stdout::add_to_linker(l, |t| t)?;
-        crate::preview2::bindings::cli::stderr::add_to_linker(l, |t| t)?;
-        crate::preview2::bindings::cli::terminal_input::add_to_linker(l, |t| t)?;
-        crate::preview2::bindings::cli::terminal_output::add_to_linker(l, |t| t)?;
-        crate::preview2::bindings::cli::terminal_stdin::add_to_linker(l, |t| t)?;
-        crate::preview2::bindings::cli::terminal_stdout::add_to_linker(l, |t| t)?;
-        crate::preview2::bindings::cli::terminal_stderr::add_to_linker(l, |t| t)?;
-        crate::preview2::bindings::sockets::tcp::add_to_linker(l, |t| t)?;
-        crate::preview2::bindings::sockets::tcp_create_socket::add_to_linker(l, |t| t)?;
-        crate::preview2::bindings::sockets::instance_network::add_to_linker(l, |t| t)?;
-        crate::preview2::bindings::sockets::network::add_to_linker(l, |t| t)?;
-        crate::preview2::bindings::sockets::ip_name_lookup::add_to_linker(l, |t| t)?;
-        Ok(())
-    }
-}
diff --git a/crates/wasi/src/preview2/ctx.rs b/crates/wasi/src/preview2/ctx.rs
deleted file mode 100644
index 344a4a3c12da..000000000000
--- a/crates/wasi/src/preview2/ctx.rs
+++ /dev/null
@@ -1,327 +0,0 @@
-use super::clocks::host::{monotonic_clock, wall_clock};
-use crate::preview2::{
-    clocks::{self, HostMonotonicClock, HostWallClock},
-    filesystem::Dir,
-    pipe, random, stdio,
-    stdio::{StdinStream, StdoutStream},
-    DirPerms, FilePerms, Table,
-};
-use cap_rand::{Rng, RngCore, SeedableRng};
-use cap_std::ipnet::{self, IpNet};
-use cap_std::net::Pool;
-use cap_std::{ambient_authority, AmbientAuthority};
-use std::mem;
-use std::net::{Ipv4Addr, Ipv6Addr};
-
-pub struct WasiCtxBuilder {
-    stdin: Box<dyn StdinStream>,
-    stdout: Box<dyn StdoutStream>,
-    stderr: Box<dyn StdoutStream>,
-    env: Vec<(String, String)>,
-    args: Vec<String>,
-    preopens: Vec<(Dir, String)>,
-
-    pool: Pool,
-    random: Box<dyn RngCore + Send + Sync>,
-    insecure_random: Box<dyn RngCore + Send + Sync>,
-    insecure_random_seed: u128,
-    wall_clock: Box<dyn HostWallClock + Send + Sync>,
-    monotonic_clock: Box<dyn HostMonotonicClock + Send + Sync>,
-    allow_ip_name_lookup: bool,
-    built: bool,
-}
-
-impl WasiCtxBuilder {
-    /// Creates a builder for a new context with default parameters set.
-    ///
-    /// The current defaults are:
-    ///
-    /// * stdin is closed
-    /// * stdout and stderr eat all input but it doesn't go anywhere
-    /// * no env vars
-    /// * no arguments
-    /// * no preopens
-    /// * clocks use the host implementation of wall/monotonic clocks
-    /// * RNGs are all initialized with random state and suitable generator
-    ///   quality to satisfy the requirements of WASI APIs.
-    ///
-    /// These defaults can all be updated via the various builder configuration
-    /// methods below.
-    ///
-    /// Note that each builder can only be used once to produce a [`WasiCtx`].
-    /// Invoking the [`build`](WasiCtxBuilder::build) method will panic on the
-    /// second attempt.
-    pub fn new() -> Self {
-        // For the insecure random API, use `SmallRng`, which is fast. It's
-        // also insecure, but that's the deal here.
-        let insecure_random = Box::new(
-            cap_rand::rngs::SmallRng::from_rng(cap_rand::thread_rng(cap_rand::ambient_authority()))
-                .unwrap(),
-        );
-
-        // For the insecure random seed, use a `u128` generated from
-        // `thread_rng()`, so that it's not guessable from the insecure_random
-        // API.
-        let insecure_random_seed =
-            cap_rand::thread_rng(cap_rand::ambient_authority()).gen::<u128>();
-        Self {
-            stdin: Box::new(pipe::ClosedInputStream),
-            stdout: Box::new(pipe::SinkOutputStream),
-            stderr: Box::new(pipe::SinkOutputStream),
-            env: Vec::new(),
-            args: Vec::new(),
-            preopens: Vec::new(),
-            pool: Pool::new(),
-            random: random::thread_rng(),
-            insecure_random,
-            insecure_random_seed,
-            wall_clock: wall_clock(),
-            monotonic_clock: monotonic_clock(),
-            allow_ip_name_lookup: false,
-            built: false,
-        }
-    }
-
-    pub fn stdin(&mut self, stdin: impl StdinStream + 'static) -> &mut Self {
-        self.stdin = Box::new(stdin);
-        self
-    }
-
-    pub fn stdout(&mut self, stdout: impl StdoutStream + 'static) -> &mut Self {
-        self.stdout = Box::new(stdout);
-        self
-    }
-
-    pub fn stderr(&mut self, stderr: impl StdoutStream + 'static) -> &mut Self {
-        self.stderr = Box::new(stderr);
-        self
-    }
-
-    pub fn inherit_stdin(&mut self) -> &mut Self {
-        self.stdin(stdio::stdin())
-    }
-
-    pub fn inherit_stdout(&mut self) -> &mut Self {
-        self.stdout(stdio::stdout())
-    }
-
-    pub fn inherit_stderr(&mut self) -> &mut Self {
-        self.stderr(stdio::stderr())
-    }
-
-    pub fn inherit_stdio(&mut self) -> &mut Self {
-        self.inherit_stdin().inherit_stdout().inherit_stderr()
-    }
-
-    pub fn envs(&mut self, env: &[(impl AsRef<str>, impl AsRef<str>)]) -> &mut Self {
-        self.env.extend(
-            env.iter()
-                .map(|(k, v)| (k.as_ref().to_owned(), v.as_ref().to_owned())),
-        );
-        self
-    }
-
-    pub fn env(&mut self, k: impl AsRef<str>, v: impl AsRef<str>) -> &mut Self {
-        self.env
-            .push((k.as_ref().to_owned(), v.as_ref().to_owned()));
-        self
-    }
-
-    pub fn args(&mut self, args: &[impl AsRef<str>]) -> &mut Self {
-        self.args.extend(args.iter().map(|a| a.as_ref().to_owned()));
-        self
-    }
-
-    pub fn arg(&mut self, arg: impl AsRef<str>) -> &mut Self {
-        self.args.push(arg.as_ref().to_owned());
-        self
-    }
-
-    pub fn preopened_dir(
-        &mut self,
-        dir: cap_std::fs::Dir,
-        perms: DirPerms,
-        file_perms: FilePerms,
-        path: impl AsRef<str>,
-    ) -> &mut Self {
-        self.preopens
-            .push((Dir::new(dir, perms, file_perms), path.as_ref().to_owned()));
-        self
-    }
-
-    /// Set the generator for the secure random number generator to the custom
-    /// generator specified.
-    ///
-    /// Note that contexts have a default RNG configured which is a suitable
-    /// generator for WASI and is configured with a random seed per-context.
-    ///
-    /// Guest code may rely on this random number generator to produce fresh
-    /// unpredictable random data in order to maintain its security invariants,
-    /// and ideally should use the insecure random API otherwise, so using any
-    /// prerecorded or otherwise predictable data may compromise security.
-    pub fn secure_random(&mut self, random: impl RngCore + Send + Sync + 'static) -> &mut Self {
-        self.random = Box::new(random);
-        self
-    }
-
-    pub fn insecure_random(
-        &mut self,
-        insecure_random: impl RngCore + Send + Sync + 'static,
-    ) -> &mut Self {
-        self.insecure_random = Box::new(insecure_random);
-        self
-    }
-    pub fn insecure_random_seed(&mut self, insecure_random_seed: u128) -> &mut Self {
-        self.insecure_random_seed = insecure_random_seed;
-        self
-    }
-
-    pub fn wall_clock(&mut self, clock: impl clocks::HostWallClock + 'static) -> &mut Self {
-        self.wall_clock = Box::new(clock);
-        self
-    }
-
-    pub fn monotonic_clock(
-        &mut self,
-        clock: impl clocks::HostMonotonicClock + 'static,
-    ) -> &mut Self {
-        self.monotonic_clock = Box::new(clock);
-        self
-    }
-
-    /// Add all network addresses accessable to the host to the pool.
-    pub fn inherit_network(&mut self, ambient_authority: AmbientAuthority) -> &mut Self {
-        self.pool.insert_ip_net_port_any(
-            IpNet::new(Ipv4Addr::UNSPECIFIED.into(), 0).unwrap(),
-            ambient_authority,
-        );
-        self.pool.insert_ip_net_port_any(
-            IpNet::new(Ipv6Addr::UNSPECIFIED.into(), 0).unwrap(),
-            ambient_authority,
-        );
-        self
-    }
-
-    /// Add network addresses to the pool.
-    pub fn insert_addr<A: cap_std::net::ToSocketAddrs>(
-        &mut self,
-        addrs: A,
-    ) -> std::io::Result<&mut Self> {
-        self.pool.insert(addrs, ambient_authority())?;
-        Ok(self)
-    }
-
-    /// Add a specific [`cap_std::net::SocketAddr`] to the pool.
-    pub fn insert_socket_addr(&mut self, addr: cap_std::net::SocketAddr) -> &mut Self {
-        self.pool.insert_socket_addr(addr, ambient_authority());
-        self
-    }
-
-    /// Add a range of network addresses, accepting any port, to the pool.
-    ///
-    /// Unlike `insert_ip_net`, this function grants access to any requested port.
-    pub fn insert_ip_net_port_any(&mut self, ip_net: ipnet::IpNet) -> &mut Self {
-        self.pool
-            .insert_ip_net_port_any(ip_net, ambient_authority());
-        self
-    }
-
-    /// Add a range of network addresses, accepting a range of ports, to
-    /// per-instance networks.
-    ///
-    /// This grants access to the port range starting at `ports_start` and, if
-    /// `ports_end` is provided, ending before `ports_end`.
-    pub fn insert_ip_net_port_range(
-        &mut self,
-        ip_net: ipnet::IpNet,
-        ports_start: u16,
-        ports_end: Option<u16>,
-    ) -> &mut Self {
-        self.pool
-            .insert_ip_net_port_range(ip_net, ports_start, ports_end, ambient_authority());
-        self
-    }
-
-    /// Add a range of network addresses with a specific port to the pool.
-    pub fn insert_ip_net(&mut self, ip_net: ipnet::IpNet, port: u16) -> &mut Self {
-        self.pool.insert_ip_net(ip_net, port, ambient_authority());
-        self
-    }
-
-    /// Allow usage of `wasi:sockets/ip-name-lookup`
-    pub fn allow_ip_name_lookup(&mut self, enable: bool) -> &mut Self {
-        self.allow_ip_name_lookup = enable;
-        self
-    }
-
-    /// Uses the configured context so far to construct the final `WasiCtx`.
-    ///
-    /// This will insert resources into the provided `table`.
-    ///
-    /// Note that each `WasiCtxBuilder` can only be used to "build" once, and
-    /// calling this method twice will panic.
-    ///
-    /// # Panics
-    ///
-    /// Panics if this method is called twice.
-    pub fn build(&mut self) -> WasiCtx {
-        assert!(!self.built);
-
-        let Self {
-            stdin,
-            stdout,
-            stderr,
-            env,
-            args,
-            preopens,
-            pool,
-            random,
-            insecure_random,
-            insecure_random_seed,
-            wall_clock,
-            monotonic_clock,
-            allow_ip_name_lookup,
-            built: _,
-        } = mem::replace(self, Self::new());
-        self.built = true;
-
-        WasiCtx {
-            stdin,
-            stdout,
-            stderr,
-            env,
-            args,
-            preopens,
-            pool,
-            random,
-            insecure_random,
-            insecure_random_seed,
-            wall_clock,
-            monotonic_clock,
-            allow_ip_name_lookup,
-        }
-    }
-}
-
-pub trait WasiView: Send {
-    fn table(&self) -> &Table;
-    fn table_mut(&mut self) -> &mut Table;
-    fn ctx(&self) -> &WasiCtx;
-    fn ctx_mut(&mut self) -> &mut WasiCtx;
-}
-
-pub struct WasiCtx {
-    pub(crate) random: Box<dyn RngCore + Send + Sync>,
-    pub(crate) insecure_random: Box<dyn RngCore + Send + Sync>,
-    pub(crate) insecure_random_seed: u128,
-    pub(crate) wall_clock: Box<dyn HostWallClock + Send + Sync>,
-    pub(crate) monotonic_clock: Box<dyn HostMonotonicClock + Send + Sync>,
-    pub(crate) env: Vec<(String, String)>,
-    pub(crate) args: Vec<String>,
-    pub(crate) preopens: Vec<(Dir, String)>,
-    pub(crate) stdin: Box<dyn StdinStream>,
-    pub(crate) stdout: Box<dyn StdoutStream>,
-    pub(crate) stderr: Box<dyn StdoutStream>,
-    pub(crate) pool: Pool,
-    pub(crate) allow_ip_name_lookup: bool,
-}
diff --git a/crates/wasi/src/preview2/error.rs b/crates/wasi/src/preview2/error.rs
deleted file mode 100644
index c3493b238bee..000000000000
--- a/crates/wasi/src/preview2/error.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-use std::fmt;
-
-/// An error returned from the `proc_exit` host syscall.
-///
-/// Embedders can test if an error returned from wasm is this error, in which
-/// case it may signal a non-fatal trap.
-#[derive(Debug)]
-pub struct I32Exit(pub i32);
-
-impl fmt::Display for I32Exit {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "Exited with i32 exit status {}", self.0)
-    }
-}
-
-impl std::error::Error for I32Exit {}
diff --git a/crates/wasi/src/preview2/filesystem.rs b/crates/wasi/src/preview2/filesystem.rs
deleted file mode 100644
index 9b8467a86ed3..000000000000
--- a/crates/wasi/src/preview2/filesystem.rs
+++ /dev/null
@@ -1,302 +0,0 @@
-use crate::preview2::bindings::filesystem::types;
-use crate::preview2::{
-    spawn_blocking, AbortOnDropJoinHandle, HostOutputStream, StreamError, Subscribe,
-};
-use anyhow::anyhow;
-use bytes::{Bytes, BytesMut};
-use std::io;
-use std::mem;
-use std::sync::Arc;
-
-pub enum Descriptor {
-    File(File),
-    Dir(Dir),
-}
-
-impl Descriptor {
-    pub fn file(&self) -> Result<&File, types::ErrorCode> {
-        match self {
-            Descriptor::File(f) => Ok(f),
-            Descriptor::Dir(_) => Err(types::ErrorCode::BadDescriptor),
-        }
-    }
-
-    pub fn dir(&self) -> Result<&Dir, types::ErrorCode> {
-        match self {
-            Descriptor::Dir(d) => Ok(d),
-            Descriptor::File(_) => Err(types::ErrorCode::NotDirectory),
-        }
-    }
-
-    pub fn is_file(&self) -> bool {
-        match self {
-            Descriptor::File(_) => true,
-            Descriptor::Dir(_) => false,
-        }
-    }
-
-    pub fn is_dir(&self) -> bool {
-        match self {
-            Descriptor::File(_) => false,
-            Descriptor::Dir(_) => true,
-        }
-    }
-}
-
-bitflags::bitflags! {
-    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-    pub struct FilePerms: usize {
-        const READ = 0b1;
-        const WRITE = 0b10;
-    }
-}
-
-pub struct File {
-    /// Wrapped in an Arc because the same underlying file is used for
-    /// implementing the stream types. Also needed for [`spawn_blocking`].
-    ///
-    /// [`spawn_blocking`]: Self::spawn_blocking
-    pub file: Arc<cap_std::fs::File>,
-    pub perms: FilePerms,
-}
-
-impl File {
-    pub fn new(file: cap_std::fs::File, perms: FilePerms) -> Self {
-        Self {
-            file: Arc::new(file),
-            perms,
-        }
-    }
-
-    /// Spawn a task on tokio's blocking thread for performing blocking
-    /// syscalls on the underlying [`cap_std::fs::File`].
-    pub(crate) async fn spawn_blocking<F, R>(&self, body: F) -> R
-    where
-        F: FnOnce(&cap_std::fs::File) -> R + Send + 'static,
-        R: Send + 'static,
-    {
-        let f = self.file.clone();
-        spawn_blocking(move || body(&f)).await
-    }
-}
-
-bitflags::bitflags! {
-    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-    pub struct DirPerms: usize {
-        const READ = 0b1;
-        const MUTATE = 0b10;
-    }
-}
-
-#[derive(Clone)]
-pub struct Dir {
-    pub dir: Arc<cap_std::fs::Dir>,
-    pub perms: DirPerms,
-    pub file_perms: FilePerms,
-}
-
-impl Dir {
-    pub fn new(dir: cap_std::fs::Dir, perms: DirPerms, file_perms: FilePerms) -> Self {
-        Dir {
-            dir: Arc::new(dir),
-            perms,
-            file_perms,
-        }
-    }
-
-    /// Spawn a task on tokio's blocking thread for performing blocking
-    /// syscalls on the underlying [`cap_std::fs::Dir`].
-    pub(crate) async fn spawn_blocking<F, R>(&self, body: F) -> R
-    where
-        F: FnOnce(&cap_std::fs::Dir) -> R + Send + 'static,
-        R: Send + 'static,
-    {
-        let d = self.dir.clone();
-        spawn_blocking(move || body(&d)).await
-    }
-}
-
-pub struct FileInputStream {
-    file: Arc<cap_std::fs::File>,
-    position: u64,
-}
-impl FileInputStream {
-    pub fn new(file: Arc<cap_std::fs::File>, position: u64) -> Self {
-        Self { file, position }
-    }
-
-    pub async fn read(&mut self, size: usize) -> Result<Bytes, StreamError> {
-        use system_interface::fs::FileIoExt;
-        let f = Arc::clone(&self.file);
-        let p = self.position;
-        let (r, mut buf) = spawn_blocking(move || {
-            let mut buf = BytesMut::zeroed(size);
-            let r = f.read_at(&mut buf, p);
-            (r, buf)
-        })
-        .await;
-        let n = read_result(r)?;
-        buf.truncate(n);
-        self.position += n as u64;
-        Ok(buf.freeze())
-    }
-
-    pub async fn skip(&mut self, nelem: usize) -> Result<usize, StreamError> {
-        let bs = self.read(nelem).await?;
-        Ok(bs.len())
-    }
-}
-
-fn read_result(r: io::Result<usize>) -> Result<usize, StreamError> {
-    match r {
-        Ok(0) => Err(StreamError::Closed),
-        Ok(n) => Ok(n),
-        Err(e) if e.kind() == std::io::ErrorKind::Interrupted => Ok(0),
-        Err(e) => Err(StreamError::LastOperationFailed(e.into())),
-    }
-}
-
-#[derive(Clone, Copy)]
-pub(crate) enum FileOutputMode {
-    Position(u64),
-    Append,
-}
-
-pub(crate) struct FileOutputStream {
-    file: Arc<cap_std::fs::File>,
-    mode: FileOutputMode,
-    state: OutputState,
-}
-
-enum OutputState {
-    Ready,
-    /// Allows join future to be awaited in a cancellable manner. Gone variant indicates
-    /// no task is currently outstanding.
-    Waiting(AbortOnDropJoinHandle<io::Result<()>>),
-    /// The last I/O operation failed with this error.
-    Error(io::Error),
-    Closed,
-}
-
-impl FileOutputStream {
-    pub fn write_at(file: Arc<cap_std::fs::File>, position: u64) -> Self {
-        Self {
-            file,
-            mode: FileOutputMode::Position(position),
-            state: OutputState::Ready,
-        }
-    }
-    pub fn append(file: Arc<cap_std::fs::File>) -> Self {
-        Self {
-            file,
-            mode: FileOutputMode::Append,
-            state: OutputState::Ready,
-        }
-    }
-}
-
-// FIXME: configurable? determine from how much space left in file?
-const FILE_WRITE_CAPACITY: usize = 1024 * 1024;
-
-impl HostOutputStream for FileOutputStream {
-    fn write(&mut self, buf: Bytes) -> Result<(), StreamError> {
-        use system_interface::fs::FileIoExt;
-        match self.state {
-            OutputState::Ready => {}
-            OutputState::Closed => return Err(StreamError::Closed),
-            OutputState::Waiting(_) | OutputState::Error(_) => {
-                // a write is pending - this call was not permitted
-                return Err(StreamError::Trap(anyhow!(
-                    "write not permitted: check_write not called first"
-                )));
-            }
-        }
-
-        let f = Arc::clone(&self.file);
-        let m = self.mode;
-        let task = spawn_blocking(move || match m {
-            FileOutputMode::Position(mut p) => {
-                let mut buf = buf;
-                while !buf.is_empty() {
-                    let nwritten = f.write_at(buf.as_ref(), p)?;
-                    // afterwards buf contains [nwritten, len):
-                    let _ = buf.split_to(nwritten);
-                    p += nwritten as u64;
-                }
-                Ok(())
-            }
-            FileOutputMode::Append => {
-                let mut buf = buf;
-                while !buf.is_empty() {
-                    let nwritten = f.append(buf.as_ref())?;
-                    let _ = buf.split_to(nwritten);
-                }
-                Ok(())
-            }
-        });
-        self.state = OutputState::Waiting(task);
-        Ok(())
-    }
-    fn flush(&mut self) -> Result<(), StreamError> {
-        match self.state {
-            // Only userland buffering of file writes is in the blocking task,
-            // so there's nothing extra that needs to be done to request a
-            // flush.
-            OutputState::Ready | OutputState::Waiting(_) => Ok(()),
-            OutputState::Closed => Err(StreamError::Closed),
-            OutputState::Error(_) => match mem::replace(&mut self.state, OutputState::Closed) {
-                OutputState::Error(e) => Err(StreamError::LastOperationFailed(e.into())),
-                _ => unreachable!(),
-            },
-        }
-    }
-    fn check_write(&mut self) -> Result<usize, StreamError> {
-        match self.state {
-            OutputState::Ready => Ok(FILE_WRITE_CAPACITY),
-            OutputState::Closed => Err(StreamError::Closed),
-            OutputState::Error(_) => match mem::replace(&mut self.state, OutputState::Closed) {
-                OutputState::Error(e) => Err(StreamError::LastOperationFailed(e.into())),
-                _ => unreachable!(),
-            },
-            OutputState::Waiting(_) => Ok(0),
-        }
-    }
-}
-
-#[async_trait::async_trait]
-impl Subscribe for FileOutputStream {
-    async fn ready(&mut self) {
-        if let OutputState::Waiting(task) = &mut self.state {
-            self.state = match task.await {
-                Ok(()) => OutputState::Ready,
-                Err(e) => OutputState::Error(e),
-            };
-        }
-    }
-}
-
-pub struct ReaddirIterator(
-    std::sync::Mutex<
-        Box<dyn Iterator<Item = Result<types::DirectoryEntry, types::Error>> + Send + 'static>,
-    >,
-);
-
-impl ReaddirIterator {
-    pub(crate) fn new(
-        i: impl Iterator<Item = Result<types::DirectoryEntry, types::Error>> + Send + 'static,
-    ) -> Self {
-        ReaddirIterator(std::sync::Mutex::new(Box::new(i)))
-    }
-    pub(crate) fn next(&self) -> Result<Option<types::DirectoryEntry>, types::Error> {
-        self.0.lock().unwrap().next().transpose()
-    }
-}
-
-impl IntoIterator for ReaddirIterator {
-    type Item = Result<types::DirectoryEntry, types::Error>;
-    type IntoIter = Box<dyn Iterator<Item = Self::Item> + Send>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.0.into_inner().unwrap()
-    }
-}
diff --git a/crates/wasi/src/preview2/host/clocks.rs b/crates/wasi/src/preview2/host/clocks.rs
deleted file mode 100644
index 105f8b3ee47f..000000000000
--- a/crates/wasi/src/preview2/host/clocks.rs
+++ /dev/null
@@ -1,90 +0,0 @@
-#![allow(unused_variables)]
-
-use crate::preview2::bindings::{
-    clocks::monotonic_clock::{self, Instant},
-    clocks::timezone::{self, TimezoneDisplay},
-    clocks::wall_clock::{self, Datetime},
-};
-use crate::preview2::poll::{subscribe, Subscribe};
-use crate::preview2::{Pollable, WasiView};
-use cap_std::time::SystemTime;
-use std::time::Duration;
-use wasmtime::component::Resource;
-
-impl TryFrom<SystemTime> for Datetime {
-    type Error = anyhow::Error;
-
-    fn try_from(time: SystemTime) -> Result<Self, Self::Error> {
-        let duration =
-            time.duration_since(SystemTime::from_std(std::time::SystemTime::UNIX_EPOCH))?;
-
-        Ok(Datetime {
-            seconds: duration.as_secs(),
-            nanoseconds: duration.subsec_nanos(),
-        })
-    }
-}
-
-impl<T: WasiView> wall_clock::Host for T {
-    fn now(&mut self) -> anyhow::Result<Datetime> {
-        let now = self.ctx().wall_clock.now();
-        Ok(Datetime {
-            seconds: now.as_secs(),
-            nanoseconds: now.subsec_nanos(),
-        })
-    }
-
-    fn resolution(&mut self) -> anyhow::Result<Datetime> {
-        let res = self.ctx().wall_clock.resolution();
-        Ok(Datetime {
-            seconds: res.as_secs(),
-            nanoseconds: res.subsec_nanos(),
-        })
-    }
-}
-
-impl<T: WasiView> monotonic_clock::Host for T {
-    fn now(&mut self) -> anyhow::Result<Instant> {
-        Ok(self.ctx().monotonic_clock.now())
-    }
-
-    fn resolution(&mut self) -> anyhow::Result<Instant> {
-        Ok(self.ctx().monotonic_clock.resolution())
-    }
-
-    fn subscribe(&mut self, when: Instant, absolute: bool) -> anyhow::Result<Resource<Pollable>> {
-        let clock_now = self.ctx().monotonic_clock.now();
-        let duration = if absolute {
-            Duration::from_nanos(when - clock_now)
-        } else {
-            Duration::from_nanos(when)
-        };
-        let deadline = tokio::time::Instant::now()
-            .checked_add(duration)
-            .ok_or_else(|| anyhow::anyhow!("time overflow: duration {duration:?}"))?;
-        // NB: this resource created here is not actually exposed to wasm, it's
-        // only an internal implementation detail used to match the signature
-        // expected by `subscribe`.
-        let sleep = self.table_mut().push_resource(Sleep(deadline))?;
-        subscribe(self.table_mut(), sleep)
-    }
-}
-
-struct Sleep(tokio::time::Instant);
-
-#[async_trait::async_trait]
-impl Subscribe for Sleep {
-    async fn ready(&mut self) {
-        tokio::time::sleep_until(self.0).await;
-    }
-}
-
-impl<T: WasiView> timezone::Host for T {
-    fn display(&mut self, when: Datetime) -> anyhow::Result<TimezoneDisplay> {
-        todo!("timezone display is not implemented")
-    }
-
-    fn utc_offset(&mut self, when: Datetime) -> anyhow::Result<i32> {
-        todo!("timezone utc_offset is not implemented")
-    }
-}
diff --git a/crates/wasi/src/preview2/host/env.rs b/crates/wasi/src/preview2/host/env.rs
deleted file mode 100644
index e765dbd817f0..000000000000
--- a/crates/wasi/src/preview2/host/env.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-use crate::preview2::bindings::cli::environment;
-use crate::preview2::WasiView;
-
-impl<T: WasiView> environment::Host for T {
-    fn get_environment(&mut self) -> anyhow::Result<Vec<(String, String)>> {
-        Ok(self.ctx().env.clone())
-    }
-    fn get_arguments(&mut self) -> anyhow::Result<Vec<String>> {
-        Ok(self.ctx().args.clone())
-    }
-    fn initial_cwd(&mut self) -> anyhow::Result<Option<String>> {
-        // FIXME: expose cwd in builder and save in ctx
-        Ok(None)
-    }
-}
diff --git a/crates/wasi/src/preview2/host/exit.rs b/crates/wasi/src/preview2/host/exit.rs
deleted file mode 100644
index d95866a9a9ec..000000000000
--- a/crates/wasi/src/preview2/host/exit.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-use crate::preview2::{bindings::cli::exit, I32Exit, WasiView};
-
-impl<T: WasiView> exit::Host for T {
-    fn exit(&mut self, status: Result<(), ()>) -> anyhow::Result<()> {
-        let status = match status {
-            Ok(()) => 0,
-            Err(()) => 1,
-        };
-        Err(anyhow::anyhow!(I32Exit(status)))
-    }
-}
diff --git a/crates/wasi/src/preview2/host/filesystem.rs b/crates/wasi/src/preview2/host/filesystem.rs
deleted file mode 100644
index a9a57e46c489..000000000000
--- a/crates/wasi/src/preview2/host/filesystem.rs
+++ /dev/null
@@ -1,1114 +0,0 @@
-use crate::preview2::bindings::clocks::wall_clock;
-use crate::preview2::bindings::filesystem::types::{HostDescriptor, HostDirectoryEntryStream};
-use crate::preview2::bindings::filesystem::{preopens, types};
-use crate::preview2::bindings::io::streams::{InputStream, OutputStream};
-use crate::preview2::filesystem::{Descriptor, Dir, File, ReaddirIterator};
-use crate::preview2::filesystem::{FileInputStream, FileOutputStream};
-use crate::preview2::{DirPerms, FilePerms, Table, TableError, WasiView};
-use anyhow::Context;
-use wasmtime::component::Resource;
-
-use types::ErrorCode;
-
-mod sync;
-
-impl From<TableError> for types::Error {
-    fn from(error: TableError) -> Self {
-        Self::trap(error.into())
-    }
-}
-
-impl<T: WasiView> preopens::Host for T {
-    fn get_directories(
-        &mut self,
-    ) -> Result<Vec<(Resource<types::Descriptor>, String)>, anyhow::Error> {
-        let mut results = Vec::new();
-        for (dir, name) in self.ctx().preopens.clone() {
-            let fd = self
-                .table_mut()
-                .push_resource(Descriptor::Dir(dir))
-                .with_context(|| format!("failed to push preopen {name}"))?;
-            results.push((fd, name));
-        }
-        Ok(results)
-    }
-}
-
-#[async_trait::async_trait]
-impl<T: WasiView> types::Host for T {}
-
-#[async_trait::async_trait]
-impl<T: WasiView> HostDescriptor for T {
-    async fn advise(
-        &mut self,
-        fd: Resource<types::Descriptor>,
-        offset: types::Filesize,
-        len: types::Filesize,
-        advice: types::Advice,
-    ) -> Result<(), types::Error> {
-        use system_interface::fs::{Advice as A, FileIoExt};
-        use types::Advice;
-
-        let advice = match advice {
-            Advice::Normal => A::Normal,
-            Advice::Sequential => A::Sequential,
-            Advice::Random => A::Random,
-            Advice::WillNeed => A::WillNeed,
-            Advice::DontNeed => A::DontNeed,
-            Advice::NoReuse => A::NoReuse,
-        };
-
-        let f = self.table().get_resource(&fd)?.file()?;
-        f.spawn_blocking(move |f| f.advise(offset, len, advice))
-            .await?;
-        Ok(())
-    }
-
-    async fn sync_data(&mut self, fd: Resource<types::Descriptor>) -> Result<(), types::Error> {
-        let table = self.table();
-
-        match table.get_resource(&fd)? {
-            Descriptor::File(f) => {
-                match f.spawn_blocking(|f| f.sync_data()).await {
-                    Ok(()) => Ok(()),
-                    // On windows, `sync_data` uses `FileFlushBuffers` which fails with
-                    // `ERROR_ACCESS_DENIED` if the file is not upen for writing. Ignore
-                    // this error, for POSIX compatibility.
-                    #[cfg(windows)]
-                    Err(e)
-                        if e.raw_os_error()
-                            == Some(windows_sys::Win32::Foundation::ERROR_ACCESS_DENIED as _) =>
-                    {
-                        Ok(())
-                    }
-                    Err(e) => Err(e.into()),
-                }
-            }
-            Descriptor::Dir(d) => {
-                d.spawn_blocking(|d| Ok(d.open(std::path::Component::CurDir)?.sync_data()?))
-                    .await
-            }
-        }
-    }
-
-    async fn get_flags(
-        &mut self,
-        fd: Resource<types::Descriptor>,
-    ) -> Result<types::DescriptorFlags, types::Error> {
-        use system_interface::fs::{FdFlags, GetSetFdFlags};
-        use types::DescriptorFlags;
-
-        fn get_from_fdflags(flags: FdFlags) -> DescriptorFlags {
-            let mut out = DescriptorFlags::empty();
-            if flags.contains(FdFlags::DSYNC) {
-                out |= DescriptorFlags::REQUESTED_WRITE_SYNC;
-            }
-            if flags.contains(FdFlags::RSYNC) {
-                out |= DescriptorFlags::DATA_INTEGRITY_SYNC;
-            }
-            if flags.contains(FdFlags::SYNC) {
-                out |= DescriptorFlags::FILE_INTEGRITY_SYNC;
-            }
-            out
-        }
-
-        let table = self.table();
-        match table.get_resource(&fd)? {
-            Descriptor::File(f) => {
-                let flags = f.spawn_blocking(|f| f.get_fd_flags()).await?;
-                let mut flags = get_from_fdflags(flags);
-                if f.perms.contains(FilePerms::READ) {
-                    flags |= DescriptorFlags::READ;
-                }
-                if f.perms.contains(FilePerms::WRITE) {
-                    flags |= DescriptorFlags::WRITE;
-                }
-                Ok(flags)
-            }
-            Descriptor::Dir(d) => {
-                let flags = d.spawn_blocking(|d| d.get_fd_flags()).await?;
-                let mut flags = get_from_fdflags(flags);
-                if d.perms.contains(DirPerms::READ) {
-                    flags |= DescriptorFlags::READ;
-                }
-                if d.perms.contains(DirPerms::MUTATE) {
-                    flags |= DescriptorFlags::MUTATE_DIRECTORY;
-                }
-                Ok(flags)
-            }
-        }
-    }
-
-    async fn get_type(
-        &mut self,
-        fd: Resource<types::Descriptor>,
-    ) -> Result<types::DescriptorType, types::Error> {
-        let table = self.table();
-
-        match table.get_resource(&fd)? {
-            Descriptor::File(f) => {
-                let meta = f.spawn_blocking(|f| f.metadata()).await?;
-                Ok(descriptortype_from(meta.file_type()))
-            }
-            Descriptor::Dir(_) => Ok(types::DescriptorType::Directory),
-        }
-    }
-
-    async fn set_size(
-        &mut self,
-        fd: Resource<types::Descriptor>,
-        size: types::Filesize,
-    ) -> Result<(), types::Error> {
-        let f = self.table().get_resource(&fd)?.file()?;
-        if !f.perms.contains(FilePerms::WRITE) {
-            Err(ErrorCode::NotPermitted)?;
-        }
-        f.spawn_blocking(move |f| f.set_len(size)).await?;
-        Ok(())
-    }
-
-    async fn set_times(
-        &mut self,
-        fd: Resource<types::Descriptor>,
-        atim: types::NewTimestamp,
-        mtim: types::NewTimestamp,
-    ) -> Result<(), types::Error> {
-        use fs_set_times::SetTimes;
-
-        let table = self.table();
-        match table.get_resource(&fd)? {
-            Descriptor::File(f) => {
-                if !f.perms.contains(FilePerms::WRITE) {
-                    return Err(ErrorCode::NotPermitted.into());
-                }
-                let atim = systemtimespec_from(atim)?;
-                let mtim = systemtimespec_from(mtim)?;
-                f.spawn_blocking(|f| f.set_times(atim, mtim)).await?;
-                Ok(())
-            }
-            Descriptor::Dir(d) => {
-                if !d.perms.contains(DirPerms::MUTATE) {
-                    return Err(ErrorCode::NotPermitted.into());
-                }
-                let atim = systemtimespec_from(atim)?;
-                let mtim = systemtimespec_from(mtim)?;
-                d.spawn_blocking(|d| d.set_times(atim, mtim)).await?;
-                Ok(())
-            }
-        }
-    }
-
-    async fn read(
-        &mut self,
-        fd: Resource<types::Descriptor>,
-        len: types::Filesize,
-        offset: types::Filesize,
-    ) -> Result<(Vec<u8>, bool), types::Error> {
-        use std::io::IoSliceMut;
-        use system_interface::fs::FileIoExt;
-
-        let table = self.table();
-
-        let f = table.get_resource(&fd)?.file()?;
-        if !f.perms.contains(FilePerms::READ) {
-            return Err(ErrorCode::NotPermitted.into());
-        }
-
-        let (mut buffer, r) = f
-            .spawn_blocking(move |f| {
-                let mut buffer = vec![0; len.try_into().unwrap_or(usize::MAX)];
-                let r = f.read_vectored_at(&mut [IoSliceMut::new(&mut buffer)], offset);
-                (buffer, r)
-            })
-            .await;
-
-        let (bytes_read, state) = match r? {
-            0 => (0, true),
-            n => (n, false),
-        };
-
-        buffer.truncate(
-            bytes_read
-                .try_into()
-                .expect("bytes read into memory as u64 fits in usize"),
-        );
-
-        Ok((buffer, state))
-    }
-
-    async fn write(
-        &mut self,
-        fd: Resource<types::Descriptor>,
-        buf: Vec<u8>,
-        offset: types::Filesize,
-    ) -> Result<types::Filesize, types::Error> {
-        use std::io::IoSlice;
-        use system_interface::fs::FileIoExt;
-
-        let table = self.table();
-        let f = table.get_resource(&fd)?.file()?;
-        if !f.perms.contains(FilePerms::WRITE) {
-            return Err(ErrorCode::NotPermitted.into());
-        }
-
-        let bytes_written = f
-            .spawn_blocking(move |f| f.write_vectored_at(&[IoSlice::new(&buf)], offset))
-            .await?;
-
-        Ok(types::Filesize::try_from(bytes_written).expect("usize fits in Filesize"))
-    }
-
-    async fn read_directory(
-        &mut self,
-        fd: Resource<types::Descriptor>,
-    ) -> Result<Resource<types::DirectoryEntryStream>, types::Error> {
-        let table = self.table_mut();
-        let d = table.get_resource(&fd)?.dir()?;
-        if !d.perms.contains(DirPerms::READ) {
-            return Err(ErrorCode::NotPermitted.into());
-        }
-
-        enum ReaddirError {
-            Io(std::io::Error),
-            IllegalSequence,
-        }
-        impl From<std::io::Error> for ReaddirError {
-            fn from(e: std::io::Error) -> ReaddirError {
-                ReaddirError::Io(e)
-            }
-        }
-
-        let entries = d
-            .spawn_blocking(|d| {
-                // Both `entries` and `metadata` perform syscalls, which is why they are done
-                // within this `block` call, rather than delay calculating the metadata
-                // for entries when they're demanded later in the iterator chain.
-                Ok::<_, std::io::Error>(
-                    d.entries()?
-                        .map(|entry| {
-                            let entry = entry?;
-                            let meta = entry.metadata()?;
-                            let type_ = descriptortype_from(meta.file_type());
-                            let name = entry
-                                .file_name()
-                                .into_string()
-                                .map_err(|_| ReaddirError::IllegalSequence)?;
-                            Ok(types::DirectoryEntry { type_, name })
-                        })
-                        .collect::<Vec<Result<types::DirectoryEntry, ReaddirError>>>(),
-                )
-            })
-            .await?
-            .into_iter();
-
-        // On windows, filter out files like `C:\DumpStack.log.tmp` which we
-        // can't get full metadata for.
-        #[cfg(windows)]
-        let entries = entries.filter(|entry| {
-            use windows_sys::Win32::Foundation::{ERROR_ACCESS_DENIED, ERROR_SHARING_VIOLATION};
-            if let Err(ReaddirError::Io(err)) = entry {
-                if err.raw_os_error() == Some(ERROR_SHARING_VIOLATION as i32)
-                    || err.raw_os_error() == Some(ERROR_ACCESS_DENIED as i32)
-                {
-                    return false;
-                }
-            }
-            true
-        });
-        let entries = entries.map(|r| match r {
-            Ok(r) => Ok(r),
-            Err(ReaddirError::Io(e)) => Err(types::Error::from(e)),
-            Err(ReaddirError::IllegalSequence) => Err(ErrorCode::IllegalByteSequence.into()),
-        });
-        Ok(table.push_resource(ReaddirIterator::new(entries))?)
-    }
-
-    async fn sync(&mut self, fd: Resource<types::Descriptor>) -> Result<(), types::Error> {
-        let table = self.table();
-
-        match table.get_resource(&fd)? {
-            Descriptor::File(f) => {
-                match f.spawn_blocking(|f| f.sync_all()).await {
-                    Ok(()) => Ok(()),
-                    // On windows, `sync_data` uses `FileFlushBuffers` which fails with
-                    // `ERROR_ACCESS_DENIED` if the file is not upen for writing. Ignore
-                    // this error, for POSIX compatibility.
-                    #[cfg(windows)]
-                    Err(e)
-                        if e.raw_os_error()
-                            == Some(windows_sys::Win32::Foundation::ERROR_ACCESS_DENIED as _) =>
-                    {
-                        Ok(())
-                    }
-                    Err(e) => Err(e.into()),
-                }
-            }
-            Descriptor::Dir(d) => {
-                d.spawn_blocking(|d| Ok(d.open(std::path::Component::CurDir)?.sync_all()?))
-                    .await
-            }
-        }
-    }
-
-    async fn create_directory_at(
-        &mut self,
-        fd: Resource<types::Descriptor>,
-        path: String,
-    ) -> Result<(), types::Error> {
-        let table = self.table();
-        let d = table.get_resource(&fd)?.dir()?;
-        if !d.perms.contains(DirPerms::MUTATE) {
-            return Err(ErrorCode::NotPermitted.into());
-        }
-        d.spawn_blocking(move |d| d.create_dir(&path)).await?;
-        Ok(())
-    }
-
-    async fn stat(
-        &mut self,
-        fd: Resource<types::Descriptor>,
-    ) -> Result<types::DescriptorStat, types::Error> {
-        let table = self.table();
-        match table.get_resource(&fd)? {
-            Descriptor::File(f) => {
-                // No permissions check on stat: if opened, allowed to stat it
-                let meta = f.spawn_blocking(|f| f.metadata()).await?;
-                Ok(descriptorstat_from(meta))
-            }
-            Descriptor::Dir(d) => {
-                // No permissions check on stat: if opened, allowed to stat it
-                let meta = d.spawn_blocking(|d| d.dir_metadata()).await?;
-                Ok(descriptorstat_from(meta))
-            }
-        }
-    }
-
-    async fn stat_at(
-        &mut self,
-        fd: Resource<types::Descriptor>,
-        path_flags: types::PathFlags,
-        path: String,
-    ) -> Result<types::DescriptorStat, types::Error> {
-        let table = self.table();
-        let d = table.get_resource(&fd)?.dir()?;
-        if !d.perms.contains(DirPerms::READ) {
-            return Err(ErrorCode::NotPermitted.into());
-        }
-
-        let meta = if symlink_follow(path_flags) {
-            d.spawn_blocking(move |d| d.metadata(&path)).await?
-        } else {
-            d.spawn_blocking(move |d| d.symlink_metadata(&path)).await?
-        };
-        Ok(descriptorstat_from(meta))
-    }
-
-    async fn set_times_at(
-        &mut self,
-        fd: Resource<types::Descriptor>,
-        path_flags: types::PathFlags,
-        path: String,
-        atim: types::NewTimestamp,
-        mtim: types::NewTimestamp,
-    ) -> Result<(), types::Error> {
-        use cap_fs_ext::DirExt;
-
-        let table = self.table();
-        let d = table.get_resource(&fd)?.dir()?;
-        if !d.perms.contains(DirPerms::MUTATE) {
-            return Err(ErrorCode::NotPermitted.into());
-        }
-        let atim = systemtimespec_from(atim)?;
-        let mtim = systemtimespec_from(mtim)?;
-        if symlink_follow(path_flags) {
-            d.spawn_blocking(move |d| {
-                d.set_times(
-                    &path,
-                    atim.map(cap_fs_ext::SystemTimeSpec::from_std),
-                    mtim.map(cap_fs_ext::SystemTimeSpec::from_std),
-                )
-            })
-            .await?;
-        } else {
-            d.spawn_blocking(move |d| {
-                d.set_symlink_times(
-                    &path,
-                    atim.map(cap_fs_ext::SystemTimeSpec::from_std),
-                    mtim.map(cap_fs_ext::SystemTimeSpec::from_std),
-                )
-            })
-            .await?;
-        }
-        Ok(())
-    }
-
-    async fn link_at(
-        &mut self,
-        fd: Resource<types::Descriptor>,
-        // TODO delete the path flags from this function
-        old_path_flags: types::PathFlags,
-        old_path: String,
-        new_descriptor: Resource<types::Descriptor>,
-        new_path: String,
-    ) -> Result<(), types::Error> {
-        let table = self.table();
-        let old_dir = table.get_resource(&fd)?.dir()?;
-        if !old_dir.perms.contains(DirPerms::MUTATE) {
-            return Err(ErrorCode::NotPermitted.into());
-        }
-        let new_dir = table.get_resource(&new_descriptor)?.dir()?;
-        if !new_dir.perms.contains(DirPerms::MUTATE) {
-            return Err(ErrorCode::NotPermitted.into());
-        }
-        if symlink_follow(old_path_flags) {
-            return Err(ErrorCode::Invalid.into());
-        }
-        let new_dir_handle = std::sync::Arc::clone(&new_dir.dir);
-        old_dir
-            .spawn_blocking(move |d| d.hard_link(&old_path, &new_dir_handle, &new_path))
-            .await?;
-        Ok(())
-    }
-
-    async fn open_at(
-        &mut self,
-        fd: Resource<types::Descriptor>,
-        path_flags: types::PathFlags,
-        path: String,
-        oflags: types::OpenFlags,
-        flags: types::DescriptorFlags,
-        // TODO: These are the permissions to use when creating a new file.
-        // Not implemented yet.
-        _mode: types::Modes,
-    ) -> Result<Resource<types::Descriptor>, types::Error> {
-        use cap_fs_ext::{FollowSymlinks, OpenOptionsFollowExt, OpenOptionsMaybeDirExt};
-        use system_interface::fs::{FdFlags, GetSetFdFlags};
-        use types::{DescriptorFlags, OpenFlags};
-
-        let table = self.table_mut();
-        let d = table.get_resource(&fd)?.dir()?;
-        if !d.perms.contains(DirPerms::READ) {
-            Err(ErrorCode::NotPermitted)?;
-        }
-
-        if !d.perms.contains(DirPerms::MUTATE) {
-            if oflags.contains(OpenFlags::CREATE) || oflags.contains(OpenFlags::TRUNCATE) {
-                Err(ErrorCode::NotPermitted)?;
-            }
-            if flags.contains(DescriptorFlags::WRITE) {
-                Err(ErrorCode::NotPermitted)?;
-            }
-        }
-
-        let mut opts = cap_std::fs::OpenOptions::new();
-        opts.maybe_dir(true);
-
-        if oflags.contains(OpenFlags::CREATE | OpenFlags::EXCLUSIVE) {
-            opts.create_new(true);
-            opts.write(true);
-        } else if oflags.contains(OpenFlags::CREATE) {
-            opts.create(true);
-            opts.write(true);
-        }
-        if oflags.contains(OpenFlags::TRUNCATE) {
-            opts.truncate(true);
-        }
-        if flags.contains(DescriptorFlags::READ) {
-            opts.read(true);
-        }
-        if flags.contains(DescriptorFlags::WRITE) {
-            opts.write(true);
-        } else {
-            // If not opened write, open read. This way the OS lets us open
-            // the file, but we can use perms to reject use of the file later.
-            opts.read(true);
-        }
-        if symlink_follow(path_flags) {
-            opts.follow(FollowSymlinks::Yes);
-        } else {
-            opts.follow(FollowSymlinks::No);
-        }
-
-        // These flags are not yet supported in cap-std:
-        if flags.contains(DescriptorFlags::FILE_INTEGRITY_SYNC)
-            | flags.contains(DescriptorFlags::DATA_INTEGRITY_SYNC)
-            | flags.contains(DescriptorFlags::REQUESTED_WRITE_SYNC)
-        {
-            Err(ErrorCode::Unsupported)?;
-        }
-
-        if oflags.contains(OpenFlags::DIRECTORY) {
-            if oflags.contains(OpenFlags::CREATE)
-                || oflags.contains(OpenFlags::EXCLUSIVE)
-                || oflags.contains(OpenFlags::TRUNCATE)
-            {
-                Err(ErrorCode::Invalid)?;
-            }
-        }
-
-        // Represents each possible outcome from the spawn_blocking operation.
-        // This makes sure we don't have to give spawn_blocking any way to
-        // manipulate the table.
-        enum OpenResult {
-            Dir(cap_std::fs::Dir),
-            File(cap_std::fs::File),
-            NotDir,
-        }
-
-        let opened = d
-            .spawn_blocking::<_, std::io::Result<OpenResult>>(move |d| {
-                let mut opened = d.open_with(&path, &opts)?;
-                if opened.metadata()?.is_dir() {
-                    Ok(OpenResult::Dir(cap_std::fs::Dir::from_std_file(
-                        opened.into_std(),
-                    )))
-                } else if oflags.contains(OpenFlags::DIRECTORY) {
-                    Ok(OpenResult::NotDir)
-                } else {
-                    // FIXME cap-std needs a nonblocking open option so that files reads and writes
-                    // are nonblocking. Instead we set it after opening here:
-                    let set_fd_flags = opened.new_set_fd_flags(FdFlags::NONBLOCK)?;
-                    opened.set_fd_flags(set_fd_flags)?;
-                    Ok(OpenResult::File(opened))
-                }
-            })
-            .await?;
-
-        match opened {
-            OpenResult::Dir(dir) => {
-                Ok(table.push_resource(Descriptor::Dir(Dir::new(dir, d.perms, d.file_perms)))?)
-            }
-
-            OpenResult::File(file) => Ok(table.push_resource(Descriptor::File(File::new(
-                file,
-                mask_file_perms(d.file_perms, flags),
-            )))?),
-
-            OpenResult::NotDir => Err(ErrorCode::NotDirectory.into()),
-        }
-    }
-
-    fn drop(&mut self, fd: Resource<types::Descriptor>) -> anyhow::Result<()> {
-        let table = self.table_mut();
-
-        // The Drop will close the file/dir, but if the close syscall
-        // blocks the thread, I will face god and walk backwards into hell.
-        // tokio::fs::File just uses std::fs::File's Drop impl to close, so
-        // it doesn't appear anyone else has found this to be a problem.
-        // (Not that they could solve it without async drop...)
-        table.delete_resource(fd)?;
-
-        Ok(())
-    }
-
-    async fn readlink_at(
-        &mut self,
-        fd: Resource<types::Descriptor>,
-        path: String,
-    ) -> Result<String, types::Error> {
-        let table = self.table();
-        let d = table.get_resource(&fd)?.dir()?;
-        if !d.perms.contains(DirPerms::READ) {
-            return Err(ErrorCode::NotPermitted.into());
-        }
-        let link = d.spawn_blocking(move |d| d.read_link(&path)).await?;
-        Ok(link
-            .into_os_string()
-            .into_string()
-            .map_err(|_| ErrorCode::IllegalByteSequence)?)
-    }
-
-    async fn remove_directory_at(
-        &mut self,
-        fd: Resource<types::Descriptor>,
-        path: String,
-    ) -> Result<(), types::Error> {
-        let table = self.table();
-        let d = table.get_resource(&fd)?.dir()?;
-        if !d.perms.contains(DirPerms::MUTATE) {
-            return Err(ErrorCode::NotPermitted.into());
-        }
-        Ok(d.spawn_blocking(move |d| d.remove_dir(&path)).await?)
-    }
-
-    async fn rename_at(
-        &mut self,
-        fd: Resource<types::Descriptor>,
-        old_path: String,
-        new_fd: Resource<types::Descriptor>,
-        new_path: String,
-    ) -> Result<(), types::Error> {
-        let table = self.table();
-        let old_dir = table.get_resource(&fd)?.dir()?;
-        if !old_dir.perms.contains(DirPerms::MUTATE) {
-            return Err(ErrorCode::NotPermitted.into());
-        }
-        let new_dir = table.get_resource(&new_fd)?.dir()?;
-        if !new_dir.perms.contains(DirPerms::MUTATE) {
-            return Err(ErrorCode::NotPermitted.into());
-        }
-        let new_dir_handle = std::sync::Arc::clone(&new_dir.dir);
-        Ok(old_dir
-            .spawn_blocking(move |d| d.rename(&old_path, &new_dir_handle, &new_path))
-            .await?)
-    }
-
-    async fn symlink_at(
-        &mut self,
-        fd: Resource<types::Descriptor>,
-        src_path: String,
-        dest_path: String,
-    ) -> Result<(), types::Error> {
-        // On windows, Dir.symlink is provided by DirExt
-        #[cfg(windows)]
-        use cap_fs_ext::DirExt;
-
-        let table = self.table();
-        let d = table.get_resource(&fd)?.dir()?;
-        if !d.perms.contains(DirPerms::MUTATE) {
-            return Err(ErrorCode::NotPermitted.into());
-        }
-        Ok(d.spawn_blocking(move |d| d.symlink(&src_path, &dest_path))
-            .await?)
-    }
-
-    async fn unlink_file_at(
-        &mut self,
-        fd: Resource<types::Descriptor>,
-        path: String,
-    ) -> Result<(), types::Error> {
-        use cap_fs_ext::DirExt;
-
-        let table = self.table();
-        let d = table.get_resource(&fd)?.dir()?;
-        if !d.perms.contains(DirPerms::MUTATE) {
-            return Err(ErrorCode::NotPermitted.into());
-        }
-        Ok(d.spawn_blocking(move |d| d.remove_file_or_symlink(&path))
-            .await?)
-    }
-
-    async fn access_at(
-        &mut self,
-        _fd: Resource<types::Descriptor>,
-        _path_flags: types::PathFlags,
-        _path: String,
-        _access: types::AccessType,
-    ) -> Result<(), types::Error> {
-        todo!("filesystem access_at is not implemented")
-    }
-
-    async fn change_file_permissions_at(
-        &mut self,
-        _fd: Resource<types::Descriptor>,
-        _path_flags: types::PathFlags,
-        _path: String,
-        _mode: types::Modes,
-    ) -> Result<(), types::Error> {
-        todo!("filesystem change_file_permissions_at is not implemented")
-    }
-
-    async fn change_directory_permissions_at(
-        &mut self,
-        _fd: Resource<types::Descriptor>,
-        _path_flags: types::PathFlags,
-        _path: String,
-        _mode: types::Modes,
-    ) -> Result<(), types::Error> {
-        todo!("filesystem change_directory_permissions_at is not implemented")
-    }
-
-    async fn lock_shared(&mut self, _fd: Resource<types::Descriptor>) -> Result<(), types::Error> {
-        todo!("filesystem lock_shared is not implemented")
-    }
-
-    async fn lock_exclusive(
-        &mut self,
-        _fd: Resource<types::Descriptor>,
-    ) -> Result<(), types::Error> {
-        todo!("filesystem lock_exclusive is not implemented")
-    }
-
-    async fn try_lock_shared(
-        &mut self,
-        _fd: Resource<types::Descriptor>,
-    ) -> Result<(), types::Error> {
-        todo!("filesystem try_lock_shared is not implemented")
-    }
-
-    async fn try_lock_exclusive(
-        &mut self,
-        _fd: Resource<types::Descriptor>,
-    ) -> Result<(), types::Error> {
-        todo!("filesystem try_lock_exclusive is not implemented")
-    }
-
-    async fn unlock(&mut self, _fd: Resource<types::Descriptor>) -> Result<(), types::Error> {
-        todo!("filesystem unlock is not implemented")
-    }
-
-    fn read_via_stream(
-        &mut self,
-        fd: Resource<types::Descriptor>,
-        offset: types::Filesize,
-    ) -> Result<Resource<InputStream>, types::Error> {
-        // Trap if fd lookup fails:
-        let f = self.table().get_resource(&fd)?.file()?;
-
-        if !f.perms.contains(FilePerms::READ) {
-            Err(types::ErrorCode::BadDescriptor)?;
-        }
-        // Duplicate the file descriptor so that we get an indepenent lifetime.
-        let clone = std::sync::Arc::clone(&f.file);
-
-        // Create a stream view for it.
-        let reader = FileInputStream::new(clone, offset);
-
-        // Insert the stream view into the table. Trap if the table is full.
-        let index = self.table_mut().push_resource(InputStream::File(reader))?;
-
-        Ok(index)
-    }
-
-    fn write_via_stream(
-        &mut self,
-        fd: Resource<types::Descriptor>,
-        offset: types::Filesize,
-    ) -> Result<Resource<OutputStream>, types::Error> {
-        // Trap if fd lookup fails:
-        let f = self.table().get_resource(&fd)?.file()?;
-
-        if !f.perms.contains(FilePerms::WRITE) {
-            Err(types::ErrorCode::BadDescriptor)?;
-        }
-
-        // Duplicate the file descriptor so that we get an indepenent lifetime.
-        let clone = std::sync::Arc::clone(&f.file);
-
-        // Create a stream view for it.
-        let writer = FileOutputStream::write_at(clone, offset);
-        let writer: OutputStream = Box::new(writer);
-
-        // Insert the stream view into the table. Trap if the table is full.
-        let index = self.table_mut().push_resource(writer)?;
-
-        Ok(index)
-    }
-
-    fn append_via_stream(
-        &mut self,
-        fd: Resource<types::Descriptor>,
-    ) -> Result<Resource<OutputStream>, types::Error> {
-        // Trap if fd lookup fails:
-        let f = self.table().get_resource(&fd)?.file()?;
-
-        if !f.perms.contains(FilePerms::WRITE) {
-            Err(types::ErrorCode::BadDescriptor)?;
-        }
-        // Duplicate the file descriptor so that we get an indepenent lifetime.
-        let clone = std::sync::Arc::clone(&f.file);
-
-        // Create a stream view for it.
-        let appender = FileOutputStream::append(clone);
-        let appender: OutputStream = Box::new(appender);
-
-        // Insert the stream view into the table. Trap if the table is full.
-        let index = self.table_mut().push_resource(appender)?;
-
-        Ok(index)
-    }
-
-    async fn is_same_object(
-        &mut self,
-        a: Resource<types::Descriptor>,
-        b: Resource<types::Descriptor>,
-    ) -> anyhow::Result<bool> {
-        use cap_fs_ext::MetadataExt;
-        let table = self.table();
-        let meta_a = get_descriptor_metadata(table, a).await?;
-        let meta_b = get_descriptor_metadata(table, b).await?;
-        if meta_a.dev() == meta_b.dev() && meta_a.ino() == meta_b.ino() {
-            // MetadataHashValue does not derive eq, so use a pair of
-            // comparisons to check equality:
-            debug_assert_eq!(
-                calculate_metadata_hash(&meta_a).upper,
-                calculate_metadata_hash(&meta_b).upper
-            );
-            debug_assert_eq!(
-                calculate_metadata_hash(&meta_a).lower,
-                calculate_metadata_hash(&meta_b).lower
-            );
-            Ok(true)
-        } else {
-            // Hash collisions are possible, so don't assert the negative here
-            Ok(false)
-        }
-    }
-    async fn metadata_hash(
-        &mut self,
-        fd: Resource<types::Descriptor>,
-    ) -> Result<types::MetadataHashValue, types::Error> {
-        let table = self.table();
-        let meta = get_descriptor_metadata(table, fd).await?;
-        Ok(calculate_metadata_hash(&meta))
-    }
-    async fn metadata_hash_at(
-        &mut self,
-        fd: Resource<types::Descriptor>,
-        path_flags: types::PathFlags,
-        path: String,
-    ) -> Result<types::MetadataHashValue, types::Error> {
-        let table = self.table();
-        let d = table.get_resource(&fd)?.dir()?;
-        // No permissions check on metadata: if dir opened, allowed to stat it
-        let meta = d
-            .spawn_blocking(move |d| {
-                if symlink_follow(path_flags) {
-                    d.metadata(path)
-                } else {
-                    d.symlink_metadata(path)
-                }
-            })
-            .await?;
-        Ok(calculate_metadata_hash(&meta))
-    }
-}
-
-#[async_trait::async_trait]
-impl<T: WasiView> HostDirectoryEntryStream for T {
-    async fn read_directory_entry(
-        &mut self,
-        stream: Resource<types::DirectoryEntryStream>,
-    ) -> Result<Option<types::DirectoryEntry>, types::Error> {
-        let table = self.table();
-        let readdir = table.get_resource(&stream)?;
-        readdir.next()
-    }
-
-    fn drop(&mut self, stream: Resource<types::DirectoryEntryStream>) -> anyhow::Result<()> {
-        self.table_mut().delete_resource(stream)?;
-        Ok(())
-    }
-}
-
-async fn get_descriptor_metadata(
-    table: &Table,
-    fd: Resource<types::Descriptor>,
-) -> Result<cap_std::fs::Metadata, types::Error> {
-    match table.get_resource(&fd)? {
-        Descriptor::File(f) => {
-            // No permissions check on metadata: if opened, allowed to stat it
-            Ok(f.spawn_blocking(|f| f.metadata()).await?)
-        }
-        Descriptor::Dir(d) => {
-            // No permissions check on metadata: if opened, allowed to stat it
-            Ok(d.spawn_blocking(|d| d.dir_metadata()).await?)
-        }
-    }
-}
-
-fn calculate_metadata_hash(meta: &cap_std::fs::Metadata) -> types::MetadataHashValue {
-    use cap_fs_ext::MetadataExt;
-    // Without incurring any deps, std provides us with a 64 bit hash
-    // function:
-    use std::hash::Hasher;
-    // Note that this means that the metadata hash (which becomes a preview1 ino) may
-    // change when a different rustc release is used to build this host implementation:
-    let mut hasher = std::collections::hash_map::DefaultHasher::new();
-    hasher.write_u64(meta.dev());
-    hasher.write_u64(meta.ino());
-    let lower = hasher.finish();
-    // MetadataHashValue has a pair of 64-bit members for representing a
-    // single 128-bit number. However, we only have 64 bits of entropy. To
-    // synthesize the upper 64 bits, lets xor the lower half with an arbitrary
-    // constant, in this case the 64 bit integer corresponding to the IEEE
-    // double representation of (a number as close as possible to) pi.
-    // This seems better than just repeating the same bits in the upper and
-    // lower parts outright, which could make folks wonder if the struct was
-    // mangled in the ABI, or worse yet, lead to consumers of this interface
-    // expecting them to be equal.
-    let upper = lower ^ 4614256656552045848u64;
-    types::MetadataHashValue { lower, upper }
-}
-
-#[cfg(unix)]
-fn from_raw_os_error(err: Option<i32>) -> Option<types::Error> {
-    use rustix::io::Errno as RustixErrno;
-    if err.is_none() {
-        return None;
-    }
-    Some(match RustixErrno::from_raw_os_error(err.unwrap()) {
-        RustixErrno::PIPE => ErrorCode::Pipe.into(),
-        RustixErrno::PERM => ErrorCode::NotPermitted.into(),
-        RustixErrno::NOENT => ErrorCode::NoEntry.into(),
-        RustixErrno::NOMEM => ErrorCode::InsufficientMemory.into(),
-        RustixErrno::IO => ErrorCode::Io.into(),
-        RustixErrno::BADF => ErrorCode::BadDescriptor.into(),
-        RustixErrno::BUSY => ErrorCode::Busy.into(),
-        RustixErrno::ACCESS => ErrorCode::Access.into(),
-        RustixErrno::NOTDIR => ErrorCode::NotDirectory.into(),
-        RustixErrno::ISDIR => ErrorCode::IsDirectory.into(),
-        RustixErrno::INVAL => ErrorCode::Invalid.into(),
-        RustixErrno::EXIST => ErrorCode::Exist.into(),
-        RustixErrno::FBIG => ErrorCode::FileTooLarge.into(),
-        RustixErrno::NOSPC => ErrorCode::InsufficientSpace.into(),
-        RustixErrno::SPIPE => ErrorCode::InvalidSeek.into(),
-        RustixErrno::MLINK => ErrorCode::TooManyLinks.into(),
-        RustixErrno::NAMETOOLONG => ErrorCode::NameTooLong.into(),
-        RustixErrno::NOTEMPTY => ErrorCode::NotEmpty.into(),
-        RustixErrno::LOOP => ErrorCode::Loop.into(),
-        RustixErrno::OVERFLOW => ErrorCode::Overflow.into(),
-        RustixErrno::ILSEQ => ErrorCode::IllegalByteSequence.into(),
-        RustixErrno::NOTSUP => ErrorCode::Unsupported.into(),
-        RustixErrno::ALREADY => ErrorCode::Already.into(),
-        RustixErrno::INPROGRESS => ErrorCode::InProgress.into(),
-        RustixErrno::INTR => ErrorCode::Interrupted.into(),
-
-        // On some platforms.into(), these have the same value as other errno values.
-        #[allow(unreachable_patterns)]
-        RustixErrno::OPNOTSUPP => ErrorCode::Unsupported.into(),
-
-        _ => return None,
-    })
-}
-#[cfg(windows)]
-fn from_raw_os_error(raw_os_error: Option<i32>) -> Option<types::Error> {
-    use windows_sys::Win32::Foundation;
-    Some(match raw_os_error.map(|code| code as u32) {
-        Some(Foundation::ERROR_FILE_NOT_FOUND) => ErrorCode::NoEntry.into(),
-        Some(Foundation::ERROR_PATH_NOT_FOUND) => ErrorCode::NoEntry.into(),
-        Some(Foundation::ERROR_ACCESS_DENIED) => ErrorCode::Access.into(),
-        Some(Foundation::ERROR_SHARING_VIOLATION) => ErrorCode::Access.into(),
-        Some(Foundation::ERROR_PRIVILEGE_NOT_HELD) => ErrorCode::NotPermitted.into(),
-        Some(Foundation::ERROR_INVALID_HANDLE) => ErrorCode::BadDescriptor.into(),
-        Some(Foundation::ERROR_INVALID_NAME) => ErrorCode::NoEntry.into(),
-        Some(Foundation::ERROR_NOT_ENOUGH_MEMORY) => ErrorCode::InsufficientMemory.into(),
-        Some(Foundation::ERROR_OUTOFMEMORY) => ErrorCode::InsufficientMemory.into(),
-        Some(Foundation::ERROR_DIR_NOT_EMPTY) => ErrorCode::NotEmpty.into(),
-        Some(Foundation::ERROR_NOT_READY) => ErrorCode::Busy.into(),
-        Some(Foundation::ERROR_BUSY) => ErrorCode::Busy.into(),
-        Some(Foundation::ERROR_NOT_SUPPORTED) => ErrorCode::Unsupported.into(),
-        Some(Foundation::ERROR_FILE_EXISTS) => ErrorCode::Exist.into(),
-        Some(Foundation::ERROR_BROKEN_PIPE) => ErrorCode::Pipe.into(),
-        Some(Foundation::ERROR_BUFFER_OVERFLOW) => ErrorCode::NameTooLong.into(),
-        Some(Foundation::ERROR_NOT_A_REPARSE_POINT) => ErrorCode::Invalid.into(),
-        Some(Foundation::ERROR_NEGATIVE_SEEK) => ErrorCode::Invalid.into(),
-        Some(Foundation::ERROR_DIRECTORY) => ErrorCode::NotDirectory.into(),
-        Some(Foundation::ERROR_ALREADY_EXISTS) => ErrorCode::Exist.into(),
-        Some(Foundation::ERROR_STOPPED_ON_SYMLINK) => ErrorCode::Loop.into(),
-        Some(Foundation::ERROR_DIRECTORY_NOT_SUPPORTED) => ErrorCode::IsDirectory.into(),
-        _ => return None,
-    })
-}
-
-impl From<std::io::Error> for types::Error {
-    fn from(err: std::io::Error) -> types::Error {
-        match from_raw_os_error(err.raw_os_error()) {
-            Some(errno) => errno,
-            None => match err.kind() {
-                std::io::ErrorKind::NotFound => ErrorCode::NoEntry.into(),
-                std::io::ErrorKind::PermissionDenied => ErrorCode::NotPermitted.into(),
-                std::io::ErrorKind::AlreadyExists => ErrorCode::Exist.into(),
-                std::io::ErrorKind::InvalidInput => ErrorCode::Invalid.into(),
-                _ => types::Error::trap(anyhow::anyhow!(err).context("Unknown OS error")),
-            },
-        }
-    }
-}
-
-impl From<cap_rand::Error> for types::Error {
-    fn from(err: cap_rand::Error) -> types::Error {
-        // I picked Error::Io as a 'reasonable default', FIXME dan is this ok?
-        from_raw_os_error(err.raw_os_error()).unwrap_or_else(|| types::Error::from(ErrorCode::Io))
-    }
-}
-
-impl From<std::num::TryFromIntError> for types::Error {
-    fn from(_err: std::num::TryFromIntError) -> types::Error {
-        ErrorCode::Overflow.into()
-    }
-}
-
-fn descriptortype_from(ft: cap_std::fs::FileType) -> types::DescriptorType {
-    use cap_fs_ext::FileTypeExt;
-    use types::DescriptorType;
-    if ft.is_dir() {
-        DescriptorType::Directory
-    } else if ft.is_symlink() {
-        DescriptorType::SymbolicLink
-    } else if ft.is_block_device() {
-        DescriptorType::BlockDevice
-    } else if ft.is_char_device() {
-        DescriptorType::CharacterDevice
-    } else if ft.is_file() {
-        DescriptorType::RegularFile
-    } else {
-        DescriptorType::Unknown
-    }
-}
-
-fn systemtimespec_from(
-    t: types::NewTimestamp,
-) -> Result<Option<fs_set_times::SystemTimeSpec>, types::Error> {
-    use fs_set_times::SystemTimeSpec;
-    use types::NewTimestamp;
-    match t {
-        NewTimestamp::NoChange => Ok(None),
-        NewTimestamp::Now => Ok(Some(SystemTimeSpec::SymbolicNow)),
-        NewTimestamp::Timestamp(st) => Ok(Some(SystemTimeSpec::Absolute(systemtime_from(st)?))),
-    }
-}
-
-fn systemtime_from(t: wall_clock::Datetime) -> Result<std::time::SystemTime, types::Error> {
-    use std::time::{Duration, SystemTime};
-    SystemTime::UNIX_EPOCH
-        .checked_add(Duration::new(t.seconds, t.nanoseconds))
-        .ok_or_else(|| ErrorCode::Overflow.into())
-}
-
-fn datetime_from(t: std::time::SystemTime) -> wall_clock::Datetime {
-    // FIXME make this infallible or handle errors properly
-    wall_clock::Datetime::try_from(cap_std::time::SystemTime::from_std(t)).unwrap()
-}
-
-fn descriptorstat_from(meta: cap_std::fs::Metadata) -> types::DescriptorStat {
-    use cap_fs_ext::MetadataExt;
-    types::DescriptorStat {
-        type_: descriptortype_from(meta.file_type()),
-        link_count: meta.nlink(),
-        size: meta.len(),
-        data_access_timestamp: meta.accessed().map(|t| datetime_from(t.into_std())).ok(),
-        data_modification_timestamp: meta.modified().map(|t| datetime_from(t.into_std())).ok(),
-        status_change_timestamp: meta.created().map(|t| datetime_from(t.into_std())).ok(),
-    }
-}
-
-fn symlink_follow(path_flags: types::PathFlags) -> bool {
-    path_flags.contains(types::PathFlags::SYMLINK_FOLLOW)
-}
-
-fn mask_file_perms(p: FilePerms, flags: types::DescriptorFlags) -> FilePerms {
-    use types::DescriptorFlags;
-    let mut out = FilePerms::empty();
-    if p.contains(FilePerms::READ) && flags.contains(DescriptorFlags::READ) {
-        out |= FilePerms::READ;
-    }
-    if p.contains(FilePerms::WRITE) && flags.contains(DescriptorFlags::WRITE) {
-        out |= FilePerms::WRITE;
-    }
-    out
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    #[test]
-    fn table_readdir_works() {
-        let mut table = Table::new();
-        let ix = table
-            .push_resource(ReaddirIterator::new(std::iter::empty()))
-            .unwrap();
-        let _ = table.get_resource(&ix).unwrap();
-        table.delete_resource(ix).unwrap();
-    }
-}
diff --git a/crates/wasi/src/preview2/host/filesystem/sync.rs b/crates/wasi/src/preview2/host/filesystem/sync.rs
deleted file mode 100644
index 36bb244b5719..000000000000
--- a/crates/wasi/src/preview2/host/filesystem/sync.rs
+++ /dev/null
@@ -1,667 +0,0 @@
-use crate::preview2::bindings::filesystem::types as async_filesystem;
-use crate::preview2::bindings::sync_io::filesystem::types as sync_filesystem;
-use crate::preview2::bindings::sync_io::io::streams;
-use crate::preview2::in_tokio;
-use wasmtime::component::Resource;
-
-impl<T: async_filesystem::Host> sync_filesystem::Host for T {}
-
-impl<T: async_filesystem::HostDescriptor> sync_filesystem::HostDescriptor for T {
-    fn advise(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-        offset: sync_filesystem::Filesize,
-        len: sync_filesystem::Filesize,
-        advice: sync_filesystem::Advice,
-    ) -> Result<(), sync_filesystem::Error> {
-        Ok(in_tokio(async {
-            async_filesystem::HostDescriptor::advise(self, fd, offset, len, advice.into()).await
-        })?)
-    }
-
-    fn sync_data(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-    ) -> Result<(), sync_filesystem::Error> {
-        Ok(in_tokio(async {
-            async_filesystem::HostDescriptor::sync_data(self, fd).await
-        })?)
-    }
-
-    fn get_flags(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-    ) -> Result<sync_filesystem::DescriptorFlags, sync_filesystem::Error> {
-        Ok(in_tokio(async { async_filesystem::HostDescriptor::get_flags(self, fd).await })?.into())
-    }
-
-    fn get_type(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-    ) -> Result<sync_filesystem::DescriptorType, sync_filesystem::Error> {
-        Ok(in_tokio(async { async_filesystem::HostDescriptor::get_type(self, fd).await })?.into())
-    }
-
-    fn set_size(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-        size: sync_filesystem::Filesize,
-    ) -> Result<(), sync_filesystem::Error> {
-        Ok(in_tokio(async {
-            async_filesystem::HostDescriptor::set_size(self, fd, size).await
-        })?)
-    }
-
-    fn set_times(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-        atim: sync_filesystem::NewTimestamp,
-        mtim: sync_filesystem::NewTimestamp,
-    ) -> Result<(), sync_filesystem::Error> {
-        Ok(in_tokio(async {
-            async_filesystem::HostDescriptor::set_times(self, fd, atim.into(), mtim.into()).await
-        })?)
-    }
-
-    fn read(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-        len: sync_filesystem::Filesize,
-        offset: sync_filesystem::Filesize,
-    ) -> Result<(Vec<u8>, bool), sync_filesystem::Error> {
-        Ok(in_tokio(async {
-            async_filesystem::HostDescriptor::read(self, fd, len, offset).await
-        })?)
-    }
-
-    fn write(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-        buf: Vec<u8>,
-        offset: sync_filesystem::Filesize,
-    ) -> Result<sync_filesystem::Filesize, sync_filesystem::Error> {
-        Ok(in_tokio(async {
-            async_filesystem::HostDescriptor::write(self, fd, buf, offset).await
-        })?)
-    }
-
-    fn read_directory(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-    ) -> Result<Resource<sync_filesystem::DirectoryEntryStream>, sync_filesystem::Error> {
-        Ok(in_tokio(async {
-            async_filesystem::HostDescriptor::read_directory(self, fd).await
-        })?)
-    }
-
-    fn sync(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-    ) -> Result<(), sync_filesystem::Error> {
-        Ok(in_tokio(async {
-            async_filesystem::HostDescriptor::sync(self, fd).await
-        })?)
-    }
-
-    fn create_directory_at(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-        path: String,
-    ) -> Result<(), sync_filesystem::Error> {
-        Ok(in_tokio(async {
-            async_filesystem::HostDescriptor::create_directory_at(self, fd, path).await
-        })?)
-    }
-
-    fn stat(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-    ) -> Result<sync_filesystem::DescriptorStat, sync_filesystem::Error> {
-        Ok(in_tokio(async { async_filesystem::HostDescriptor::stat(self, fd).await })?.into())
-    }
-
-    fn stat_at(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-        path_flags: sync_filesystem::PathFlags,
-        path: String,
-    ) -> Result<sync_filesystem::DescriptorStat, sync_filesystem::Error> {
-        Ok(in_tokio(async {
-            async_filesystem::HostDescriptor::stat_at(self, fd, path_flags.into(), path).await
-        })?
-        .into())
-    }
-
-    fn set_times_at(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-        path_flags: sync_filesystem::PathFlags,
-        path: String,
-        atim: sync_filesystem::NewTimestamp,
-        mtim: sync_filesystem::NewTimestamp,
-    ) -> Result<(), sync_filesystem::Error> {
-        Ok(in_tokio(async {
-            async_filesystem::HostDescriptor::set_times_at(
-                self,
-                fd,
-                path_flags.into(),
-                path,
-                atim.into(),
-                mtim.into(),
-            )
-            .await
-        })?)
-    }
-
-    fn link_at(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-        // TODO delete the path flags from this function
-        old_path_flags: sync_filesystem::PathFlags,
-        old_path: String,
-        new_descriptor: Resource<sync_filesystem::Descriptor>,
-        new_path: String,
-    ) -> Result<(), sync_filesystem::Error> {
-        Ok(in_tokio(async {
-            async_filesystem::HostDescriptor::link_at(
-                self,
-                fd,
-                old_path_flags.into(),
-                old_path,
-                new_descriptor,
-                new_path,
-            )
-            .await
-        })?)
-    }
-
-    fn open_at(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-        path_flags: sync_filesystem::PathFlags,
-        path: String,
-        oflags: sync_filesystem::OpenFlags,
-        flags: sync_filesystem::DescriptorFlags,
-        mode: sync_filesystem::Modes,
-    ) -> Result<Resource<sync_filesystem::Descriptor>, sync_filesystem::Error> {
-        Ok(in_tokio(async {
-            async_filesystem::HostDescriptor::open_at(
-                self,
-                fd,
-                path_flags.into(),
-                path,
-                oflags.into(),
-                flags.into(),
-                mode.into(),
-            )
-            .await
-        })?)
-    }
-
-    fn drop(&mut self, fd: Resource<sync_filesystem::Descriptor>) -> anyhow::Result<()> {
-        async_filesystem::HostDescriptor::drop(self, fd)
-    }
-
-    fn readlink_at(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-        path: String,
-    ) -> Result<String, sync_filesystem::Error> {
-        Ok(in_tokio(async {
-            async_filesystem::HostDescriptor::readlink_at(self, fd, path).await
-        })?)
-    }
-
-    fn remove_directory_at(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-        path: String,
-    ) -> Result<(), sync_filesystem::Error> {
-        Ok(in_tokio(async {
-            async_filesystem::HostDescriptor::remove_directory_at(self, fd, path).await
-        })?)
-    }
-
-    fn rename_at(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-        old_path: String,
-        new_fd: Resource<sync_filesystem::Descriptor>,
-        new_path: String,
-    ) -> Result<(), sync_filesystem::Error> {
-        Ok(in_tokio(async {
-            async_filesystem::HostDescriptor::rename_at(self, fd, old_path, new_fd, new_path).await
-        })?)
-    }
-
-    fn symlink_at(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-        src_path: String,
-        dest_path: String,
-    ) -> Result<(), sync_filesystem::Error> {
-        Ok(in_tokio(async {
-            async_filesystem::HostDescriptor::symlink_at(self, fd, src_path, dest_path).await
-        })?)
-    }
-
-    fn unlink_file_at(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-        path: String,
-    ) -> Result<(), sync_filesystem::Error> {
-        Ok(in_tokio(async {
-            async_filesystem::HostDescriptor::unlink_file_at(self, fd, path).await
-        })?)
-    }
-
-    fn access_at(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-        path_flags: sync_filesystem::PathFlags,
-        path: String,
-        access: sync_filesystem::AccessType,
-    ) -> Result<(), sync_filesystem::Error> {
-        Ok(in_tokio(async {
-            async_filesystem::HostDescriptor::access_at(
-                self,
-                fd,
-                path_flags.into(),
-                path,
-                access.into(),
-            )
-            .await
-        })?)
-    }
-
-    fn change_file_permissions_at(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-        path_flags: sync_filesystem::PathFlags,
-        path: String,
-        mode: sync_filesystem::Modes,
-    ) -> Result<(), sync_filesystem::Error> {
-        Ok(in_tokio(async {
-            async_filesystem::HostDescriptor::change_file_permissions_at(
-                self,
-                fd,
-                path_flags.into(),
-                path,
-                mode.into(),
-            )
-            .await
-        })?)
-    }
-
-    fn change_directory_permissions_at(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-        path_flags: sync_filesystem::PathFlags,
-        path: String,
-        mode: sync_filesystem::Modes,
-    ) -> Result<(), sync_filesystem::Error> {
-        Ok(in_tokio(async {
-            async_filesystem::HostDescriptor::change_directory_permissions_at(
-                self,
-                fd,
-                path_flags.into(),
-                path,
-                mode.into(),
-            )
-            .await
-        })?)
-    }
-
-    fn lock_shared(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-    ) -> Result<(), sync_filesystem::Error> {
-        Ok(in_tokio(async {
-            async_filesystem::HostDescriptor::lock_shared(self, fd).await
-        })?)
-    }
-
-    fn lock_exclusive(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-    ) -> Result<(), sync_filesystem::Error> {
-        Ok(in_tokio(async {
-            async_filesystem::HostDescriptor::lock_exclusive(self, fd).await
-        })?)
-    }
-
-    fn try_lock_shared(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-    ) -> Result<(), sync_filesystem::Error> {
-        Ok(in_tokio(async {
-            async_filesystem::HostDescriptor::try_lock_shared(self, fd).await
-        })?)
-    }
-
-    fn try_lock_exclusive(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-    ) -> Result<(), sync_filesystem::Error> {
-        Ok(in_tokio(async {
-            async_filesystem::HostDescriptor::try_lock_exclusive(self, fd).await
-        })?)
-    }
-
-    fn unlock(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-    ) -> Result<(), sync_filesystem::Error> {
-        Ok(in_tokio(async {
-            async_filesystem::HostDescriptor::unlock(self, fd).await
-        })?)
-    }
-
-    fn read_via_stream(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-        offset: sync_filesystem::Filesize,
-    ) -> Result<Resource<streams::InputStream>, sync_filesystem::Error> {
-        Ok(async_filesystem::HostDescriptor::read_via_stream(
-            self, fd, offset,
-        )?)
-    }
-
-    fn write_via_stream(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-        offset: sync_filesystem::Filesize,
-    ) -> Result<Resource<streams::OutputStream>, sync_filesystem::Error> {
-        Ok(async_filesystem::HostDescriptor::write_via_stream(
-            self, fd, offset,
-        )?)
-    }
-
-    fn append_via_stream(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-    ) -> Result<Resource<streams::OutputStream>, sync_filesystem::Error> {
-        Ok(async_filesystem::HostDescriptor::append_via_stream(
-            self, fd,
-        )?)
-    }
-
-    fn is_same_object(
-        &mut self,
-        a: Resource<sync_filesystem::Descriptor>,
-        b: Resource<sync_filesystem::Descriptor>,
-    ) -> anyhow::Result<bool> {
-        Ok(in_tokio(async {
-            async_filesystem::HostDescriptor::is_same_object(self, a, b).await
-        })?)
-    }
-    fn metadata_hash(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-    ) -> Result<sync_filesystem::MetadataHashValue, sync_filesystem::Error> {
-        Ok(
-            in_tokio(async { async_filesystem::HostDescriptor::metadata_hash(self, fd).await })?
-                .into(),
-        )
-    }
-    fn metadata_hash_at(
-        &mut self,
-        fd: Resource<sync_filesystem::Descriptor>,
-        path_flags: sync_filesystem::PathFlags,
-        path: String,
-    ) -> Result<sync_filesystem::MetadataHashValue, sync_filesystem::Error> {
-        Ok(in_tokio(async {
-            async_filesystem::HostDescriptor::metadata_hash_at(self, fd, path_flags.into(), path)
-                .await
-        })?
-        .into())
-    }
-}
-
-impl<T: async_filesystem::HostDirectoryEntryStream> sync_filesystem::HostDirectoryEntryStream
-    for T
-{
-    fn read_directory_entry(
-        &mut self,
-        stream: Resource<sync_filesystem::DirectoryEntryStream>,
-    ) -> Result<Option<sync_filesystem::DirectoryEntry>, sync_filesystem::Error> {
-        Ok(in_tokio(async {
-            async_filesystem::HostDirectoryEntryStream::read_directory_entry(self, stream).await
-        })?
-        .map(|e| e.into()))
-    }
-
-    fn drop(
-        &mut self,
-        stream: Resource<sync_filesystem::DirectoryEntryStream>,
-    ) -> anyhow::Result<()> {
-        async_filesystem::HostDirectoryEntryStream::drop(self, stream)
-    }
-}
-
-impl From<async_filesystem::ErrorCode> for sync_filesystem::ErrorCode {
-    fn from(other: async_filesystem::ErrorCode) -> Self {
-        use async_filesystem::ErrorCode;
-        match other {
-            ErrorCode::Access => Self::Access,
-            ErrorCode::WouldBlock => Self::WouldBlock,
-            ErrorCode::Already => Self::Already,
-            ErrorCode::BadDescriptor => Self::BadDescriptor,
-            ErrorCode::Busy => Self::Busy,
-            ErrorCode::Deadlock => Self::Deadlock,
-            ErrorCode::Quota => Self::Quota,
-            ErrorCode::Exist => Self::Exist,
-            ErrorCode::FileTooLarge => Self::FileTooLarge,
-            ErrorCode::IllegalByteSequence => Self::IllegalByteSequence,
-            ErrorCode::InProgress => Self::InProgress,
-            ErrorCode::Interrupted => Self::Interrupted,
-            ErrorCode::Invalid => Self::Invalid,
-            ErrorCode::Io => Self::Io,
-            ErrorCode::IsDirectory => Self::IsDirectory,
-            ErrorCode::Loop => Self::Loop,
-            ErrorCode::TooManyLinks => Self::TooManyLinks,
-            ErrorCode::MessageSize => Self::MessageSize,
-            ErrorCode::NameTooLong => Self::NameTooLong,
-            ErrorCode::NoDevice => Self::NoDevice,
-            ErrorCode::NoEntry => Self::NoEntry,
-            ErrorCode::NoLock => Self::NoLock,
-            ErrorCode::InsufficientMemory => Self::InsufficientMemory,
-            ErrorCode::InsufficientSpace => Self::InsufficientSpace,
-            ErrorCode::NotDirectory => Self::NotDirectory,
-            ErrorCode::NotEmpty => Self::NotEmpty,
-            ErrorCode::NotRecoverable => Self::NotRecoverable,
-            ErrorCode::Unsupported => Self::Unsupported,
-            ErrorCode::NoTty => Self::NoTty,
-            ErrorCode::NoSuchDevice => Self::NoSuchDevice,
-            ErrorCode::Overflow => Self::Overflow,
-            ErrorCode::NotPermitted => Self::NotPermitted,
-            ErrorCode::Pipe => Self::Pipe,
-            ErrorCode::ReadOnly => Self::ReadOnly,
-            ErrorCode::InvalidSeek => Self::InvalidSeek,
-            ErrorCode::TextFileBusy => Self::TextFileBusy,
-            ErrorCode::CrossDevice => Self::CrossDevice,
-        }
-    }
-}
-
-impl From<async_filesystem::Error> for sync_filesystem::Error {
-    fn from(other: async_filesystem::Error) -> Self {
-        match other.downcast() {
-            Ok(errorcode) => Self::from(sync_filesystem::ErrorCode::from(errorcode)),
-            Err(other) => Self::trap(other),
-        }
-    }
-}
-
-impl From<sync_filesystem::Advice> for async_filesystem::Advice {
-    fn from(other: sync_filesystem::Advice) -> Self {
-        use sync_filesystem::Advice;
-        match other {
-            Advice::Normal => Self::Normal,
-            Advice::Sequential => Self::Sequential,
-            Advice::Random => Self::Random,
-            Advice::WillNeed => Self::WillNeed,
-            Advice::DontNeed => Self::DontNeed,
-            Advice::NoReuse => Self::NoReuse,
-        }
-    }
-}
-
-impl From<async_filesystem::DescriptorFlags> for sync_filesystem::DescriptorFlags {
-    fn from(other: async_filesystem::DescriptorFlags) -> Self {
-        let mut out = Self::empty();
-        if other.contains(async_filesystem::DescriptorFlags::READ) {
-            out |= Self::READ;
-        }
-        if other.contains(async_filesystem::DescriptorFlags::WRITE) {
-            out |= Self::WRITE;
-        }
-        if other.contains(async_filesystem::DescriptorFlags::FILE_INTEGRITY_SYNC) {
-            out |= Self::FILE_INTEGRITY_SYNC;
-        }
-        if other.contains(async_filesystem::DescriptorFlags::DATA_INTEGRITY_SYNC) {
-            out |= Self::DATA_INTEGRITY_SYNC;
-        }
-        if other.contains(async_filesystem::DescriptorFlags::REQUESTED_WRITE_SYNC) {
-            out |= Self::REQUESTED_WRITE_SYNC;
-        }
-        if other.contains(async_filesystem::DescriptorFlags::MUTATE_DIRECTORY) {
-            out |= Self::MUTATE_DIRECTORY;
-        }
-        out
-    }
-}
-
-impl From<async_filesystem::DescriptorType> for sync_filesystem::DescriptorType {
-    fn from(other: async_filesystem::DescriptorType) -> Self {
-        use async_filesystem::DescriptorType;
-        match other {
-            DescriptorType::RegularFile => Self::RegularFile,
-            DescriptorType::Directory => Self::Directory,
-            DescriptorType::BlockDevice => Self::BlockDevice,
-            DescriptorType::CharacterDevice => Self::CharacterDevice,
-            DescriptorType::Fifo => Self::Fifo,
-            DescriptorType::Socket => Self::Socket,
-            DescriptorType::SymbolicLink => Self::SymbolicLink,
-            DescriptorType::Unknown => Self::Unknown,
-        }
-    }
-}
-
-impl From<async_filesystem::DirectoryEntry> for sync_filesystem::DirectoryEntry {
-    fn from(other: async_filesystem::DirectoryEntry) -> Self {
-        Self {
-            type_: other.type_.into(),
-            name: other.name,
-        }
-    }
-}
-
-impl From<async_filesystem::DescriptorStat> for sync_filesystem::DescriptorStat {
-    fn from(other: async_filesystem::DescriptorStat) -> Self {
-        Self {
-            type_: other.type_.into(),
-            link_count: other.link_count,
-            size: other.size,
-            data_access_timestamp: other.data_access_timestamp,
-            data_modification_timestamp: other.data_modification_timestamp,
-            status_change_timestamp: other.status_change_timestamp,
-        }
-    }
-}
-
-impl From<sync_filesystem::PathFlags> for async_filesystem::PathFlags {
-    fn from(other: sync_filesystem::PathFlags) -> Self {
-        let mut out = Self::empty();
-        if other.contains(sync_filesystem::PathFlags::SYMLINK_FOLLOW) {
-            out |= Self::SYMLINK_FOLLOW;
-        }
-        out
-    }
-}
-
-impl From<sync_filesystem::NewTimestamp> for async_filesystem::NewTimestamp {
-    fn from(other: sync_filesystem::NewTimestamp) -> Self {
-        use sync_filesystem::NewTimestamp;
-        match other {
-            NewTimestamp::NoChange => Self::NoChange,
-            NewTimestamp::Now => Self::Now,
-            NewTimestamp::Timestamp(datetime) => Self::Timestamp(datetime),
-        }
-    }
-}
-
-impl From<sync_filesystem::OpenFlags> for async_filesystem::OpenFlags {
-    fn from(other: sync_filesystem::OpenFlags) -> Self {
-        let mut out = Self::empty();
-        if other.contains(sync_filesystem::OpenFlags::CREATE) {
-            out |= Self::CREATE;
-        }
-        if other.contains(sync_filesystem::OpenFlags::DIRECTORY) {
-            out |= Self::DIRECTORY;
-        }
-        if other.contains(sync_filesystem::OpenFlags::EXCLUSIVE) {
-            out |= Self::EXCLUSIVE;
-        }
-        if other.contains(sync_filesystem::OpenFlags::TRUNCATE) {
-            out |= Self::TRUNCATE;
-        }
-        out
-    }
-}
-impl From<sync_filesystem::DescriptorFlags> for async_filesystem::DescriptorFlags {
-    fn from(other: sync_filesystem::DescriptorFlags) -> Self {
-        let mut out = Self::empty();
-        if other.contains(sync_filesystem::DescriptorFlags::READ) {
-            out |= Self::READ;
-        }
-        if other.contains(sync_filesystem::DescriptorFlags::WRITE) {
-            out |= Self::WRITE;
-        }
-        if other.contains(sync_filesystem::DescriptorFlags::FILE_INTEGRITY_SYNC) {
-            out |= Self::FILE_INTEGRITY_SYNC;
-        }
-        if other.contains(sync_filesystem::DescriptorFlags::DATA_INTEGRITY_SYNC) {
-            out |= Self::DATA_INTEGRITY_SYNC;
-        }
-        if other.contains(sync_filesystem::DescriptorFlags::REQUESTED_WRITE_SYNC) {
-            out |= Self::REQUESTED_WRITE_SYNC;
-        }
-        if other.contains(sync_filesystem::DescriptorFlags::MUTATE_DIRECTORY) {
-            out |= Self::MUTATE_DIRECTORY;
-        }
-        out
-    }
-}
-impl From<sync_filesystem::Modes> for async_filesystem::Modes {
-    fn from(other: sync_filesystem::Modes) -> Self {
-        let mut out = Self::empty();
-        if other.contains(sync_filesystem::Modes::READABLE) {
-            out |= Self::READABLE;
-        }
-        if other.contains(sync_filesystem::Modes::WRITABLE) {
-            out |= Self::WRITABLE;
-        }
-        if other.contains(sync_filesystem::Modes::EXECUTABLE) {
-            out |= Self::EXECUTABLE;
-        }
-        out
-    }
-}
-impl From<sync_filesystem::AccessType> for async_filesystem::AccessType {
-    fn from(other: sync_filesystem::AccessType) -> Self {
-        use sync_filesystem::AccessType;
-        match other {
-            AccessType::Access(modes) => Self::Access(modes.into()),
-            AccessType::Exists => Self::Exists,
-        }
-    }
-}
-impl From<async_filesystem::MetadataHashValue> for sync_filesystem::MetadataHashValue {
-    fn from(other: async_filesystem::MetadataHashValue) -> Self {
-        Self {
-            lower: other.lower,
-            upper: other.upper,
-        }
-    }
-}
diff --git a/crates/wasi/src/preview2/host/instance_network.rs b/crates/wasi/src/preview2/host/instance_network.rs
deleted file mode 100644
index 627cc359f6d2..000000000000
--- a/crates/wasi/src/preview2/host/instance_network.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-use crate::preview2::bindings::sockets::instance_network;
-use crate::preview2::network::Network;
-use crate::preview2::WasiView;
-use wasmtime::component::Resource;
-
-impl<T: WasiView> instance_network::Host for T {
-    fn instance_network(&mut self) -> Result<Resource<Network>, anyhow::Error> {
-        let network = Network {
-            pool: self.ctx().pool.clone(),
-            allow_ip_name_lookup: self.ctx().allow_ip_name_lookup,
-        };
-        let network = self.table_mut().push_resource(network)?;
-        Ok(network)
-    }
-}
diff --git a/crates/wasi/src/preview2/host/io.rs b/crates/wasi/src/preview2/host/io.rs
deleted file mode 100644
index 92cfa0cdb0de..000000000000
--- a/crates/wasi/src/preview2/host/io.rs
+++ /dev/null
@@ -1,451 +0,0 @@
-use crate::preview2::{
-    bindings::io::streams::{self, InputStream, OutputStream},
-    poll::subscribe,
-    stream::StreamError,
-    Pollable, TableError, WasiView,
-};
-use wasmtime::component::Resource;
-
-impl From<TableError> for streams::Error {
-    fn from(e: TableError) -> streams::Error {
-        streams::Error::trap(e.into())
-    }
-}
-impl From<StreamError> for streams::Error {
-    fn from(e: StreamError) -> streams::Error {
-        match e {
-            StreamError::Closed => streams::StreamError::Closed.into(),
-            StreamError::LastOperationFailed(e) => {
-                tracing::debug!("streams::StreamError::LastOperationFailed: {e:?}");
-                streams::StreamError::LastOperationFailed.into()
-            }
-            StreamError::Trap(e) => streams::Error::trap(e),
-        }
-    }
-}
-
-#[async_trait::async_trait]
-impl<T: WasiView> streams::Host for T {}
-
-#[async_trait::async_trait]
-impl<T: WasiView> streams::HostOutputStream for T {
-    fn drop(&mut self, stream: Resource<OutputStream>) -> anyhow::Result<()> {
-        self.table_mut().delete_resource(stream)?;
-        Ok(())
-    }
-
-    fn check_write(&mut self, stream: Resource<OutputStream>) -> Result<u64, streams::Error> {
-        let bytes = self.table_mut().get_resource_mut(&stream)?.check_write()?;
-        Ok(bytes as u64)
-    }
-
-    fn write(
-        &mut self,
-        stream: Resource<OutputStream>,
-        bytes: Vec<u8>,
-    ) -> Result<(), streams::Error> {
-        self.table_mut()
-            .get_resource_mut(&stream)?
-            .write(bytes.into())?;
-        Ok(())
-    }
-
-    fn subscribe(&mut self, stream: Resource<OutputStream>) -> anyhow::Result<Resource<Pollable>> {
-        subscribe(self.table_mut(), stream)
-    }
-
-    async fn blocking_write_and_flush(
-        &mut self,
-        stream: Resource<OutputStream>,
-        bytes: Vec<u8>,
-    ) -> Result<(), streams::Error> {
-        let s = self.table_mut().get_resource_mut(&stream)?;
-
-        if bytes.len() > 4096 {
-            return Err(streams::Error::trap(anyhow::anyhow!(
-                "Buffer too large for blocking-write-and-flush (expected at most 4096)"
-            )));
-        }
-
-        let mut bytes = bytes::Bytes::from(bytes);
-        while !bytes.is_empty() {
-            let permit = s.write_ready().await?;
-            let len = bytes.len().min(permit);
-            let chunk = bytes.split_to(len);
-            s.write(chunk)?;
-        }
-
-        s.flush()?;
-        s.write_ready().await?;
-
-        Ok(())
-    }
-
-    async fn blocking_write_zeroes_and_flush(
-        &mut self,
-        stream: Resource<OutputStream>,
-        len: u64,
-    ) -> Result<(), streams::Error> {
-        let s = self.table_mut().get_resource_mut(&stream)?;
-
-        if len > 4096 {
-            return Err(streams::Error::trap(anyhow::anyhow!(
-                "Buffer too large for blocking-write-zeroes-and-flush (expected at most 4096)"
-            )));
-        }
-
-        let mut len = len;
-        while len > 0 {
-            let permit = s.write_ready().await?;
-            let this_len = len.min(permit as u64);
-            s.write_zeroes(this_len as usize)?;
-            len -= this_len;
-        }
-
-        s.flush()?;
-        s.write_ready().await?;
-
-        Ok(())
-    }
-
-    fn write_zeroes(
-        &mut self,
-        stream: Resource<OutputStream>,
-        len: u64,
-    ) -> Result<(), streams::Error> {
-        self.table_mut()
-            .get_resource_mut(&stream)?
-            .write_zeroes(len as usize)?;
-        Ok(())
-    }
-
-    fn flush(&mut self, stream: Resource<OutputStream>) -> Result<(), streams::Error> {
-        self.table_mut().get_resource_mut(&stream)?.flush()?;
-        Ok(())
-    }
-
-    async fn blocking_flush(
-        &mut self,
-        stream: Resource<OutputStream>,
-    ) -> Result<(), streams::Error> {
-        let s = self.table_mut().get_resource_mut(&stream)?;
-        s.flush()?;
-        s.write_ready().await?;
-        Ok(())
-    }
-
-    async fn splice(
-        &mut self,
-        _dst: Resource<OutputStream>,
-        _src: Resource<InputStream>,
-        _len: u64,
-    ) -> Result<u64, streams::Error> {
-        // TODO: We can't get two streams at the same time because they both
-        // carry the exclusive lifetime of `ctx`. When [`get_many_mut`] is
-        // stabilized, that could allow us to add a `get_many_stream_mut` or
-        // so which lets us do this.
-        //
-        // [`get_many_mut`]: https://doc.rust-lang.org/stable/std/collections/hash_map/struct.HashMap.html#method.get_many_mut
-        /*
-        let s: &mut Box<dyn crate::InputStream> = ctx
-            .table_mut()
-            .get_input_stream_mut(src)
-            ?;
-        let d: &mut Box<dyn crate::OutputStream> = ctx
-            .table_mut()
-            .get_resource_mut(dst)
-            ?;
-
-        let bytes_spliced: u64 = s.splice(&mut **d, len).await?;
-
-        Ok(bytes_spliced)
-        */
-        todo!("stream splice is not implemented")
-    }
-
-    async fn blocking_splice(
-        &mut self,
-        _dst: Resource<OutputStream>,
-        _src: Resource<InputStream>,
-        _len: u64,
-    ) -> Result<u64, streams::Error> {
-        // TODO: once splice is implemented, figure out what the blocking semantics are for waiting
-        // on src and dest here.
-        todo!("stream splice is not implemented")
-    }
-
-    async fn forward(
-        &mut self,
-        _dst: Resource<OutputStream>,
-        _src: Resource<InputStream>,
-    ) -> Result<u64, streams::Error> {
-        // TODO: We can't get two streams at the same time because they both
-        // carry the exclusive lifetime of `ctx`. When [`get_many_mut`] is
-        // stabilized, that could allow us to add a `get_many_stream_mut` or
-        // so which lets us do this.
-        //
-        // [`get_many_mut`]: https://doc.rust-lang.org/stable/std/collections/hash_map/struct.HashMap.html#method.get_many_mut
-        /*
-        let s: &mut Box<dyn crate::InputStream> = ctx
-            .table_mut()
-            .get_input_stream_mut(src)
-            ?;
-        let d: &mut Box<dyn crate::OutputStream> = ctx
-            .table_mut()
-            .get_resource_mut(dst)
-            ?;
-
-        let bytes_spliced: u64 = s.splice(&mut **d, len).await?;
-
-        Ok(bytes_spliced)
-        */
-
-        todo!("stream forward is not implemented")
-    }
-}
-
-impl From<std::num::TryFromIntError> for streams::Error {
-    fn from(e: std::num::TryFromIntError) -> Self {
-        streams::Error::trap(anyhow::anyhow!("length overflow: {e:?}"))
-    }
-}
-#[async_trait::async_trait]
-impl<T: WasiView> streams::HostInputStream for T {
-    fn drop(&mut self, stream: Resource<InputStream>) -> anyhow::Result<()> {
-        self.table_mut().delete_resource(stream)?;
-        Ok(())
-    }
-
-    async fn read(
-        &mut self,
-        stream: Resource<InputStream>,
-        len: u64,
-    ) -> Result<Vec<u8>, streams::Error> {
-        let len = len.try_into()?;
-        let bytes = match self.table_mut().get_resource_mut(&stream)? {
-            InputStream::Host(s) => s.read(len)?,
-            InputStream::File(s) => s.read(len).await?,
-        };
-        debug_assert!(bytes.len() <= len as usize);
-        Ok(bytes.into())
-    }
-
-    async fn blocking_read(
-        &mut self,
-        stream: Resource<InputStream>,
-        len: u64,
-    ) -> Result<Vec<u8>, streams::Error> {
-        if let InputStream::Host(s) = self.table_mut().get_resource_mut(&stream)? {
-            s.ready().await;
-        }
-        self.read(stream, len).await
-    }
-
-    async fn skip(
-        &mut self,
-        stream: Resource<InputStream>,
-        len: u64,
-    ) -> Result<u64, streams::Error> {
-        let len = len.try_into()?;
-        let written = match self.table_mut().get_resource_mut(&stream)? {
-            InputStream::Host(s) => s.skip(len)?,
-            InputStream::File(s) => s.skip(len).await?,
-        };
-        Ok(written.try_into().expect("usize always fits in u64"))
-    }
-
-    async fn blocking_skip(
-        &mut self,
-        stream: Resource<InputStream>,
-        len: u64,
-    ) -> Result<u64, streams::Error> {
-        if let InputStream::Host(s) = self.table_mut().get_resource_mut(&stream)? {
-            s.ready().await;
-        }
-        self.skip(stream, len).await
-    }
-
-    fn subscribe(&mut self, stream: Resource<InputStream>) -> anyhow::Result<Resource<Pollable>> {
-        crate::preview2::poll::subscribe(self.table_mut(), stream)
-    }
-}
-
-pub mod sync {
-    use crate::preview2::{
-        bindings::io::streams::{
-            self as async_streams, HostInputStream as AsyncHostInputStream,
-            HostOutputStream as AsyncHostOutputStream,
-        },
-        bindings::sync_io::io::poll::Pollable,
-        bindings::sync_io::io::streams::{self, InputStream, OutputStream},
-        in_tokio, WasiView,
-    };
-    use wasmtime::component::Resource;
-
-    impl From<async_streams::StreamError> for streams::StreamError {
-        fn from(other: async_streams::StreamError) -> Self {
-            match other {
-                async_streams::StreamError::LastOperationFailed => Self::LastOperationFailed,
-                async_streams::StreamError::Closed => Self::Closed,
-            }
-        }
-    }
-    impl From<async_streams::Error> for streams::Error {
-        fn from(other: async_streams::Error) -> Self {
-            match other.downcast() {
-                Ok(write_error) => streams::Error::from(streams::StreamError::from(write_error)),
-                Err(e) => streams::Error::trap(e),
-            }
-        }
-    }
-
-    impl<T: WasiView> streams::Host for T {}
-
-    impl<T: WasiView> streams::HostOutputStream for T {
-        fn drop(&mut self, stream: Resource<OutputStream>) -> anyhow::Result<()> {
-            AsyncHostOutputStream::drop(self, stream)
-        }
-
-        fn check_write(&mut self, stream: Resource<OutputStream>) -> Result<u64, streams::Error> {
-            Ok(AsyncHostOutputStream::check_write(self, stream)?)
-        }
-
-        fn write(
-            &mut self,
-            stream: Resource<OutputStream>,
-            bytes: Vec<u8>,
-        ) -> Result<(), streams::Error> {
-            Ok(AsyncHostOutputStream::write(self, stream, bytes)?)
-        }
-
-        fn blocking_write_and_flush(
-            &mut self,
-            stream: Resource<OutputStream>,
-            bytes: Vec<u8>,
-        ) -> Result<(), streams::Error> {
-            Ok(in_tokio(async {
-                AsyncHostOutputStream::blocking_write_and_flush(self, stream, bytes).await
-            })?)
-        }
-
-        fn blocking_write_zeroes_and_flush(
-            &mut self,
-            stream: Resource<OutputStream>,
-            len: u64,
-        ) -> Result<(), streams::Error> {
-            Ok(in_tokio(async {
-                AsyncHostOutputStream::blocking_write_zeroes_and_flush(self, stream, len).await
-            })?)
-        }
-
-        fn subscribe(
-            &mut self,
-            stream: Resource<OutputStream>,
-        ) -> anyhow::Result<Resource<Pollable>> {
-            Ok(AsyncHostOutputStream::subscribe(self, stream)?)
-        }
-
-        fn write_zeroes(
-            &mut self,
-            stream: Resource<OutputStream>,
-            len: u64,
-        ) -> Result<(), streams::Error> {
-            Ok(AsyncHostOutputStream::write_zeroes(self, stream, len)?)
-        }
-
-        fn flush(&mut self, stream: Resource<OutputStream>) -> Result<(), streams::Error> {
-            Ok(AsyncHostOutputStream::flush(
-                self,
-                Resource::new_borrow(stream.rep()),
-            )?)
-        }
-
-        fn blocking_flush(&mut self, stream: Resource<OutputStream>) -> Result<(), streams::Error> {
-            Ok(in_tokio(async {
-                AsyncHostOutputStream::blocking_flush(self, Resource::new_borrow(stream.rep()))
-                    .await
-            })?)
-        }
-
-        fn splice(
-            &mut self,
-            dst: Resource<OutputStream>,
-            src: Resource<InputStream>,
-            len: u64,
-        ) -> Result<u64, streams::Error> {
-            Ok(in_tokio(async {
-                AsyncHostOutputStream::splice(self, dst, src, len).await
-            })?)
-        }
-
-        fn blocking_splice(
-            &mut self,
-            dst: Resource<OutputStream>,
-            src: Resource<InputStream>,
-            len: u64,
-        ) -> Result<u64, streams::Error> {
-            Ok(in_tokio(async {
-                AsyncHostOutputStream::blocking_splice(self, dst, src, len).await
-            })?)
-        }
-
-        fn forward(
-            &mut self,
-            dst: Resource<OutputStream>,
-            src: Resource<InputStream>,
-        ) -> Result<u64, streams::Error> {
-            Ok(in_tokio(async {
-                AsyncHostOutputStream::forward(self, dst, src).await
-            })?)
-        }
-    }
-
-    impl<T: WasiView> streams::HostInputStream for T {
-        fn drop(&mut self, stream: Resource<InputStream>) -> anyhow::Result<()> {
-            AsyncHostInputStream::drop(self, stream)
-        }
-
-        fn read(
-            &mut self,
-            stream: Resource<InputStream>,
-            len: u64,
-        ) -> Result<Vec<u8>, streams::Error> {
-            Ok(in_tokio(async {
-                AsyncHostInputStream::read(self, stream, len).await
-            })?)
-        }
-
-        fn blocking_read(
-            &mut self,
-            stream: Resource<InputStream>,
-            len: u64,
-        ) -> Result<Vec<u8>, streams::Error> {
-            Ok(in_tokio(async {
-                AsyncHostInputStream::blocking_read(self, stream, len).await
-            })?)
-        }
-
-        fn skip(&mut self, stream: Resource<InputStream>, len: u64) -> Result<u64, streams::Error> {
-            Ok(in_tokio(async {
-                AsyncHostInputStream::skip(self, stream, len).await
-            })?)
-        }
-
-        fn blocking_skip(
-            &mut self,
-            stream: Resource<InputStream>,
-            len: u64,
-        ) -> Result<u64, streams::Error> {
-            Ok(in_tokio(async {
-                AsyncHostInputStream::blocking_skip(self, stream, len).await
-            })?)
-        }
-
-        fn subscribe(
-            &mut self,
-            stream: Resource<InputStream>,
-        ) -> anyhow::Result<Resource<Pollable>> {
-            AsyncHostInputStream::subscribe(self, stream)
-        }
-    }
-}
diff --git a/crates/wasi/src/preview2/host/mod.rs b/crates/wasi/src/preview2/host/mod.rs
deleted file mode 100644
index 138166731565..000000000000
--- a/crates/wasi/src/preview2/host/mod.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-mod clocks;
-mod env;
-mod exit;
-pub(crate) mod filesystem;
-mod instance_network;
-mod io;
-mod network;
-mod random;
-mod tcp;
-mod tcp_create_socket;
diff --git a/crates/wasi/src/preview2/host/network.rs b/crates/wasi/src/preview2/host/network.rs
deleted file mode 100644
index 811213050e8e..000000000000
--- a/crates/wasi/src/preview2/host/network.rs
+++ /dev/null
@@ -1,192 +0,0 @@
-use crate::preview2::bindings::sockets::network::{
-    self, ErrorCode, IpAddressFamily, IpSocketAddress, Ipv4Address, Ipv4SocketAddress, Ipv6Address,
-    Ipv6SocketAddress,
-};
-use crate::preview2::{TableError, WasiView};
-use std::io;
-use wasmtime::component::Resource;
-
-impl<T: WasiView> network::Host for T {}
-
-impl<T: WasiView> crate::preview2::bindings::sockets::network::HostNetwork for T {
-    fn drop(&mut self, this: Resource<network::Network>) -> Result<(), anyhow::Error> {
-        let table = self.table_mut();
-
-        table.delete_resource(this)?;
-
-        Ok(())
-    }
-}
-
-impl From<TableError> for network::Error {
-    fn from(error: TableError) -> Self {
-        Self::trap(error.into())
-    }
-}
-
-impl From<io::Error> for network::Error {
-    fn from(error: io::Error) -> Self {
-        match error.kind() {
-            // Errors that we can directly map.
-            io::ErrorKind::PermissionDenied => ErrorCode::AccessDenied,
-            io::ErrorKind::ConnectionRefused => ErrorCode::ConnectionRefused,
-            io::ErrorKind::ConnectionReset => ErrorCode::ConnectionReset,
-            io::ErrorKind::NotConnected => ErrorCode::NotConnected,
-            io::ErrorKind::AddrInUse => ErrorCode::AddressInUse,
-            io::ErrorKind::AddrNotAvailable => ErrorCode::AddressNotBindable,
-            io::ErrorKind::WouldBlock => ErrorCode::WouldBlock,
-            io::ErrorKind::TimedOut => ErrorCode::Timeout,
-            io::ErrorKind::Unsupported => ErrorCode::NotSupported,
-            io::ErrorKind::OutOfMemory => ErrorCode::OutOfMemory,
-
-            // Errors we don't expect to see here.
-            io::ErrorKind::Interrupted | io::ErrorKind::ConnectionAborted => {
-                // Transient errors should be skipped.
-                return Self::trap(error.into());
-            }
-
-            // Errors not expected from network APIs.
-            io::ErrorKind::WriteZero
-            | io::ErrorKind::InvalidInput
-            | io::ErrorKind::InvalidData
-            | io::ErrorKind::BrokenPipe
-            | io::ErrorKind::NotFound
-            | io::ErrorKind::UnexpectedEof
-            | io::ErrorKind::AlreadyExists => return Self::trap(error.into()),
-
-            // Errors that don't correspond to a Rust `io::ErrorKind`.
-            io::ErrorKind::Other => match error.raw_os_error() {
-                None => return Self::trap(error.into()),
-                Some(libc::ENOBUFS) | Some(libc::ENOMEM) => ErrorCode::OutOfMemory,
-                Some(libc::EOPNOTSUPP) => ErrorCode::NotSupported,
-                Some(libc::ENETUNREACH) | Some(libc::EHOSTUNREACH) | Some(libc::ENETDOWN) => {
-                    ErrorCode::RemoteUnreachable
-                }
-                Some(libc::ECONNRESET) => ErrorCode::ConnectionReset,
-                Some(libc::ECONNREFUSED) => ErrorCode::ConnectionRefused,
-                Some(libc::EADDRINUSE) => ErrorCode::AddressInUse,
-                Some(_) => return Self::trap(error.into()),
-            },
-
-            _ => {
-                log::debug!("unknown I/O error: {error}");
-                ErrorCode::Unknown
-            }
-        }
-        .into()
-    }
-}
-
-impl From<rustix::io::Errno> for network::Error {
-    fn from(error: rustix::io::Errno) -> Self {
-        std::io::Error::from(error).into()
-    }
-}
-
-impl From<IpSocketAddress> for std::net::SocketAddr {
-    fn from(addr: IpSocketAddress) -> Self {
-        match addr {
-            IpSocketAddress::Ipv4(ipv4) => Self::V4(ipv4.into()),
-            IpSocketAddress::Ipv6(ipv6) => Self::V6(ipv6.into()),
-        }
-    }
-}
-
-impl From<std::net::SocketAddr> for IpSocketAddress {
-    fn from(addr: std::net::SocketAddr) -> Self {
-        match addr {
-            std::net::SocketAddr::V4(v4) => Self::Ipv4(v4.into()),
-            std::net::SocketAddr::V6(v6) => Self::Ipv6(v6.into()),
-        }
-    }
-}
-
-impl From<Ipv4SocketAddress> for std::net::SocketAddrV4 {
-    fn from(addr: Ipv4SocketAddress) -> Self {
-        Self::new(to_ipv4_addr(addr.address), addr.port)
-    }
-}
-
-impl From<std::net::SocketAddrV4> for Ipv4SocketAddress {
-    fn from(addr: std::net::SocketAddrV4) -> Self {
-        Self {
-            address: from_ipv4_addr(*addr.ip()),
-            port: addr.port(),
-        }
-    }
-}
-
-impl From<Ipv6SocketAddress> for std::net::SocketAddrV6 {
-    fn from(addr: Ipv6SocketAddress) -> Self {
-        Self::new(
-            to_ipv6_addr(addr.address),
-            addr.port,
-            addr.flow_info,
-            addr.scope_id,
-        )
-    }
-}
-
-impl From<std::net::SocketAddrV6> for Ipv6SocketAddress {
-    fn from(addr: std::net::SocketAddrV6) -> Self {
-        Self {
-            address: from_ipv6_addr(*addr.ip()),
-            port: addr.port(),
-            flow_info: addr.flowinfo(),
-            scope_id: addr.scope_id(),
-        }
-    }
-}
-
-fn to_ipv4_addr(addr: Ipv4Address) -> std::net::Ipv4Addr {
-    let (x0, x1, x2, x3) = addr;
-    std::net::Ipv4Addr::new(x0, x1, x2, x3)
-}
-
-fn from_ipv4_addr(addr: std::net::Ipv4Addr) -> Ipv4Address {
-    let [x0, x1, x2, x3] = addr.octets();
-    (x0, x1, x2, x3)
-}
-
-fn to_ipv6_addr(addr: Ipv6Address) -> std::net::Ipv6Addr {
-    let (x0, x1, x2, x3, x4, x5, x6, x7) = addr;
-    std::net::Ipv6Addr::new(x0, x1, x2, x3, x4, x5, x6, x7)
-}
-
-fn from_ipv6_addr(addr: std::net::Ipv6Addr) -> Ipv6Address {
-    let [x0, x1, x2, x3, x4, x5, x6, x7] = addr.segments();
-    (x0, x1, x2, x3, x4, x5, x6, x7)
-}
-
-impl std::net::ToSocketAddrs for IpSocketAddress {
-    type Iter = <std::net::SocketAddr as std::net::ToSocketAddrs>::Iter;
-
-    fn to_socket_addrs(&self) -> io::Result<Self::Iter> {
-        std::net::SocketAddr::from(*self).to_socket_addrs()
-    }
-}
-
-impl std::net::ToSocketAddrs for Ipv4SocketAddress {
-    type Iter = <std::net::SocketAddrV4 as std::net::ToSocketAddrs>::Iter;
-
-    fn to_socket_addrs(&self) -> io::Result<Self::Iter> {
-        std::net::SocketAddrV4::from(*self).to_socket_addrs()
-    }
-}
-
-impl std::net::ToSocketAddrs for Ipv6SocketAddress {
-    type Iter = <std::net::SocketAddrV6 as std::net::ToSocketAddrs>::Iter;
-
-    fn to_socket_addrs(&self) -> io::Result<Self::Iter> {
-        std::net::SocketAddrV6::from(*self).to_socket_addrs()
-    }
-}
-
-impl From<IpAddressFamily> for cap_net_ext::AddressFamily {
-    fn from(family: IpAddressFamily) -> Self {
-        match family {
-            IpAddressFamily::Ipv4 => cap_net_ext::AddressFamily::Ipv4,
-            IpAddressFamily::Ipv6 => cap_net_ext::AddressFamily::Ipv6,
-        }
-    }
-}
diff --git a/crates/wasi/src/preview2/host/random.rs b/crates/wasi/src/preview2/host/random.rs
deleted file mode 100644
index d2483b39f9b9..000000000000
--- a/crates/wasi/src/preview2/host/random.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-use crate::preview2::bindings::random::{insecure, insecure_seed, random};
-use crate::preview2::WasiView;
-use cap_rand::{distributions::Standard, Rng};
-
-impl<T: WasiView> random::Host for T {
-    fn get_random_bytes(&mut self, len: u64) -> anyhow::Result<Vec<u8>> {
-        Ok((&mut self.ctx_mut().random)
-            .sample_iter(Standard)
-            .take(len as usize)
-            .collect())
-    }
-
-    fn get_random_u64(&mut self) -> anyhow::Result<u64> {
-        Ok(self.ctx_mut().random.sample(Standard))
-    }
-}
-
-impl<T: WasiView> insecure::Host for T {
-    fn get_insecure_random_bytes(&mut self, len: u64) -> anyhow::Result<Vec<u8>> {
-        Ok((&mut self.ctx_mut().insecure_random)
-            .sample_iter(Standard)
-            .take(len as usize)
-            .collect())
-    }
-
-    fn get_insecure_random_u64(&mut self) -> anyhow::Result<u64> {
-        Ok(self.ctx_mut().insecure_random.sample(Standard))
-    }
-}
-
-impl<T: WasiView> insecure_seed::Host for T {
-    fn insecure_seed(&mut self) -> anyhow::Result<(u64, u64)> {
-        let seed: u128 = self.ctx_mut().insecure_random_seed;
-        Ok((seed as u64, (seed >> 64) as u64))
-    }
-}
diff --git a/crates/wasi/src/preview2/host/tcp.rs b/crates/wasi/src/preview2/host/tcp.rs
deleted file mode 100644
index 6565a589413a..000000000000
--- a/crates/wasi/src/preview2/host/tcp.rs
+++ /dev/null
@@ -1,531 +0,0 @@
-use crate::preview2::bindings::{
-    io::streams::{InputStream, OutputStream},
-    sockets::network::{self, ErrorCode, IpAddressFamily, IpSocketAddress, Network},
-    sockets::tcp::{self, ShutdownType},
-};
-use crate::preview2::tcp::{TcpSocket, TcpState};
-use crate::preview2::{Pollable, WasiView};
-use cap_net_ext::{Blocking, PoolExt, TcpListenerExt};
-use cap_std::net::TcpListener;
-use io_lifetimes::AsSocketlike;
-use rustix::io::Errno;
-use rustix::net::sockopt;
-use tokio::io::Interest;
-use wasmtime::component::Resource;
-
-impl<T: WasiView> tcp::Host for T {}
-
-impl<T: WasiView> crate::preview2::host::tcp::tcp::HostTcpSocket for T {
-    fn start_bind(
-        &mut self,
-        this: Resource<tcp::TcpSocket>,
-        network: Resource<Network>,
-        local_address: IpSocketAddress,
-    ) -> Result<(), network::Error> {
-        let table = self.table_mut();
-        let socket = table.get_resource(&this)?;
-
-        match socket.tcp_state {
-            TcpState::Default => {}
-            _ => return Err(ErrorCode::NotInProgress.into()),
-        }
-
-        let network = table.get_resource(&network)?;
-        let binder = network.pool.tcp_binder(local_address)?;
-
-        // Perform the OS bind call.
-        binder.bind_existing_tcp_listener(
-            &*socket.tcp_socket().as_socketlike_view::<TcpListener>(),
-        )?;
-
-        let socket = table.get_resource_mut(&this)?;
-        socket.tcp_state = TcpState::BindStarted;
-
-        Ok(())
-    }
-
-    fn finish_bind(&mut self, this: Resource<tcp::TcpSocket>) -> Result<(), network::Error> {
-        let table = self.table_mut();
-        let socket = table.get_resource_mut(&this)?;
-
-        match socket.tcp_state {
-            TcpState::BindStarted => {}
-            _ => return Err(ErrorCode::NotInProgress.into()),
-        }
-
-        socket.tcp_state = TcpState::Bound;
-
-        Ok(())
-    }
-
-    fn start_connect(
-        &mut self,
-        this: Resource<tcp::TcpSocket>,
-        network: Resource<Network>,
-        remote_address: IpSocketAddress,
-    ) -> Result<(), network::Error> {
-        let table = self.table_mut();
-        let r = {
-            let socket = table.get_resource(&this)?;
-
-            match socket.tcp_state {
-                TcpState::Default => {}
-                TcpState::Connected => return Err(ErrorCode::AlreadyConnected.into()),
-                _ => return Err(ErrorCode::NotInProgress.into()),
-            }
-
-            let network = table.get_resource(&network)?;
-            let connecter = network.pool.tcp_connecter(remote_address)?;
-
-            // Do an OS `connect`. Our socket is non-blocking, so it'll either...
-            {
-                let view = &*socket.tcp_socket().as_socketlike_view::<TcpListener>();
-                let r = connecter.connect_existing_tcp_listener(view);
-                r
-            }
-        };
-
-        match r {
-            // succeed immediately,
-            Ok(()) => {
-                let socket = table.get_resource_mut(&this)?;
-                socket.tcp_state = TcpState::ConnectReady;
-                return Ok(());
-            }
-            // continue in progress,
-            Err(err) if err.raw_os_error() == Some(INPROGRESS.raw_os_error()) => {}
-            // or fail immediately.
-            Err(err) => return Err(err.into()),
-        }
-
-        let socket = table.get_resource_mut(&this)?;
-        socket.tcp_state = TcpState::Connecting;
-
-        Ok(())
-    }
-
-    fn finish_connect(
-        &mut self,
-        this: Resource<tcp::TcpSocket>,
-    ) -> Result<(Resource<InputStream>, Resource<OutputStream>), network::Error> {
-        let table = self.table_mut();
-        let socket = table.get_resource_mut(&this)?;
-
-        match socket.tcp_state {
-            TcpState::ConnectReady => {}
-            TcpState::Connecting => {
-                // Do a `poll` to test for completion, using a timeout of zero
-                // to avoid blocking.
-                match rustix::event::poll(
-                    &mut [rustix::event::PollFd::new(
-                        socket.tcp_socket(),
-                        rustix::event::PollFlags::OUT,
-                    )],
-                    0,
-                ) {
-                    Ok(0) => return Err(ErrorCode::WouldBlock.into()),
-                    Ok(_) => (),
-                    Err(err) => Err(err).unwrap(),
-                }
-
-                // Check whether the connect succeeded.
-                match sockopt::get_socket_error(socket.tcp_socket()) {
-                    Ok(Ok(())) => {}
-                    Err(err) | Ok(Err(err)) => return Err(err.into()),
-                }
-            }
-            _ => return Err(ErrorCode::NotInProgress.into()),
-        };
-
-        socket.tcp_state = TcpState::Connected;
-        let (input, output) = socket.as_split();
-        let input_stream = self.table_mut().push_child_resource(input, &this)?;
-        let output_stream = self.table_mut().push_child_resource(output, &this)?;
-
-        Ok((input_stream, output_stream))
-    }
-
-    fn start_listen(&mut self, this: Resource<tcp::TcpSocket>) -> Result<(), network::Error> {
-        let table = self.table_mut();
-        let socket = table.get_resource_mut(&this)?;
-
-        match socket.tcp_state {
-            TcpState::Bound => {}
-            TcpState::ListenStarted => return Err(ErrorCode::AlreadyListening.into()),
-            TcpState::Connected => return Err(ErrorCode::AlreadyConnected.into()),
-            _ => return Err(ErrorCode::NotInProgress.into()),
-        }
-
-        socket
-            .tcp_socket()
-            .as_socketlike_view::<TcpListener>()
-            .listen(socket.listen_backlog_size)?;
-
-        socket.tcp_state = TcpState::ListenStarted;
-
-        Ok(())
-    }
-
-    fn finish_listen(&mut self, this: Resource<tcp::TcpSocket>) -> Result<(), network::Error> {
-        let table = self.table_mut();
-        let socket = table.get_resource_mut(&this)?;
-
-        match socket.tcp_state {
-            TcpState::ListenStarted => {}
-            _ => return Err(ErrorCode::NotInProgress.into()),
-        }
-
-        socket.tcp_state = TcpState::Listening;
-
-        Ok(())
-    }
-
-    fn accept(
-        &mut self,
-        this: Resource<tcp::TcpSocket>,
-    ) -> Result<
-        (
-            Resource<tcp::TcpSocket>,
-            Resource<InputStream>,
-            Resource<OutputStream>,
-        ),
-        network::Error,
-    > {
-        let table = self.table();
-        let socket = table.get_resource(&this)?;
-
-        match socket.tcp_state {
-            TcpState::Listening => {}
-            TcpState::Connected => return Err(ErrorCode::AlreadyConnected.into()),
-            _ => return Err(ErrorCode::NotInProgress.into()),
-        }
-
-        // Do the OS accept call.
-        let tcp_socket = socket.tcp_socket();
-        let (connection, _addr) = tcp_socket.try_io(Interest::READABLE, || {
-            tcp_socket
-                .as_socketlike_view::<TcpListener>()
-                .accept_with(Blocking::No)
-        })?;
-        let mut tcp_socket = TcpSocket::from_tcp_stream(connection)?;
-
-        // Mark the socket as connected so that we can exit early from methods like `start-bind`.
-        tcp_socket.tcp_state = TcpState::Connected;
-
-        let (input, output) = tcp_socket.as_split();
-        let output: OutputStream = output;
-
-        let tcp_socket = self.table_mut().push_resource(tcp_socket)?;
-        let input_stream = self.table_mut().push_child_resource(input, &tcp_socket)?;
-        let output_stream = self.table_mut().push_child_resource(output, &tcp_socket)?;
-
-        Ok((tcp_socket, input_stream, output_stream))
-    }
-
-    fn local_address(
-        &mut self,
-        this: Resource<tcp::TcpSocket>,
-    ) -> Result<IpSocketAddress, network::Error> {
-        let table = self.table();
-        let socket = table.get_resource(&this)?;
-        let addr = socket
-            .tcp_socket()
-            .as_socketlike_view::<std::net::TcpStream>()
-            .local_addr()?;
-        Ok(addr.into())
-    }
-
-    fn remote_address(
-        &mut self,
-        this: Resource<tcp::TcpSocket>,
-    ) -> Result<IpSocketAddress, network::Error> {
-        let table = self.table();
-        let socket = table.get_resource(&this)?;
-        let addr = socket
-            .tcp_socket()
-            .as_socketlike_view::<std::net::TcpStream>()
-            .peer_addr()?;
-        Ok(addr.into())
-    }
-
-    fn address_family(
-        &mut self,
-        this: Resource<tcp::TcpSocket>,
-    ) -> Result<IpAddressFamily, anyhow::Error> {
-        let table = self.table();
-        let socket = table.get_resource(&this)?;
-
-        // If `SO_DOMAIN` is available, use it.
-        //
-        // TODO: OpenBSD also supports this; upstream PRs are posted.
-        #[cfg(not(any(
-            windows,
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd"
-        )))]
-        {
-            use rustix::net::AddressFamily;
-
-            let family = sockopt::get_socket_domain(socket.tcp_socket())?;
-            let family = match family {
-                AddressFamily::INET => IpAddressFamily::Ipv4,
-                AddressFamily::INET6 => IpAddressFamily::Ipv6,
-                _ => return Err(ErrorCode::NotSupported.into()),
-            };
-            Ok(family)
-        }
-
-        // When `SO_DOMAIN` is not available, emulate it.
-        #[cfg(any(
-            windows,
-            target_os = "ios",
-            target_os = "macos",
-            target_os = "netbsd",
-            target_os = "openbsd"
-        ))]
-        {
-            if let Ok(_) = sockopt::get_ipv6_unicast_hops(socket.tcp_socket()) {
-                return Ok(IpAddressFamily::Ipv6);
-            }
-            if let Ok(_) = sockopt::get_ip_ttl(socket.tcp_socket()) {
-                return Ok(IpAddressFamily::Ipv4);
-            }
-            Err(ErrorCode::NotSupported.into())
-        }
-    }
-
-    fn ipv6_only(&mut self, this: Resource<tcp::TcpSocket>) -> Result<bool, network::Error> {
-        let table = self.table();
-        let socket = table.get_resource(&this)?;
-        Ok(sockopt::get_ipv6_v6only(socket.tcp_socket())?)
-    }
-
-    fn set_ipv6_only(
-        &mut self,
-        this: Resource<tcp::TcpSocket>,
-        value: bool,
-    ) -> Result<(), network::Error> {
-        let table = self.table();
-        let socket = table.get_resource(&this)?;
-        Ok(sockopt::set_ipv6_v6only(socket.tcp_socket(), value)?)
-    }
-
-    fn set_listen_backlog_size(
-        &mut self,
-        this: Resource<tcp::TcpSocket>,
-        value: u64,
-    ) -> Result<(), network::Error> {
-        const MIN_BACKLOG: i32 = 1;
-        const MAX_BACKLOG: i32 = i32::MAX; // OS'es will most likely limit it down even further.
-
-        let table = self.table_mut();
-        let socket = table.get_resource_mut(&this)?;
-
-        // Silently clamp backlog size. This is OK for us to do, because operating systems do this too.
-        let value = value
-            .try_into()
-            .unwrap_or(i32::MAX)
-            .clamp(MIN_BACKLOG, MAX_BACKLOG);
-
-        match socket.tcp_state {
-            TcpState::Default | TcpState::BindStarted | TcpState::Bound => {
-                // Socket not listening yet. Stash value for first invocation to `listen`.
-                socket.listen_backlog_size = Some(value);
-
-                Ok(())
-            }
-            TcpState::Listening => {
-                // Try to update the backlog by calling `listen` again.
-                // Not all platforms support this. We'll only update our own value if the OS supports changing the backlog size after the fact.
-
-                rustix::net::listen(socket.tcp_socket(), value)
-                    .map_err(|_| ErrorCode::AlreadyListening)?;
-
-                socket.listen_backlog_size = Some(value);
-
-                Ok(())
-            }
-            TcpState::Connected => Err(ErrorCode::AlreadyConnected.into()),
-            TcpState::Connecting | TcpState::ConnectReady | TcpState::ListenStarted => {
-                Err(ErrorCode::ConcurrencyConflict.into())
-            }
-        }
-    }
-
-    fn keep_alive(&mut self, this: Resource<tcp::TcpSocket>) -> Result<bool, network::Error> {
-        let table = self.table();
-        let socket = table.get_resource(&this)?;
-        Ok(sockopt::get_socket_keepalive(socket.tcp_socket())?)
-    }
-
-    fn set_keep_alive(
-        &mut self,
-        this: Resource<tcp::TcpSocket>,
-        value: bool,
-    ) -> Result<(), network::Error> {
-        let table = self.table();
-        let socket = table.get_resource(&this)?;
-        Ok(sockopt::set_socket_keepalive(socket.tcp_socket(), value)?)
-    }
-
-    fn no_delay(&mut self, this: Resource<tcp::TcpSocket>) -> Result<bool, network::Error> {
-        let table = self.table();
-        let socket = table.get_resource(&this)?;
-        Ok(sockopt::get_tcp_nodelay(socket.tcp_socket())?)
-    }
-
-    fn set_no_delay(
-        &mut self,
-        this: Resource<tcp::TcpSocket>,
-        value: bool,
-    ) -> Result<(), network::Error> {
-        let table = self.table();
-        let socket = table.get_resource(&this)?;
-        Ok(sockopt::set_tcp_nodelay(socket.tcp_socket(), value)?)
-    }
-
-    fn unicast_hop_limit(&mut self, this: Resource<tcp::TcpSocket>) -> Result<u8, network::Error> {
-        let table = self.table();
-        let socket = table.get_resource(&this)?;
-
-        // We don't track whether the socket is IPv4 or IPv6 so try one and
-        // fall back to the other.
-        match sockopt::get_ipv6_unicast_hops(socket.tcp_socket()) {
-            Ok(value) => Ok(value),
-            Err(Errno::NOPROTOOPT) => {
-                let value = sockopt::get_ip_ttl(socket.tcp_socket())?;
-                let value = value.try_into().unwrap();
-                Ok(value)
-            }
-            Err(err) => Err(err.into()),
-        }
-    }
-
-    fn set_unicast_hop_limit(
-        &mut self,
-        this: Resource<tcp::TcpSocket>,
-        value: u8,
-    ) -> Result<(), network::Error> {
-        let table = self.table();
-        let socket = table.get_resource(&this)?;
-
-        // We don't track whether the socket is IPv4 or IPv6 so try one and
-        // fall back to the other.
-        match sockopt::set_ipv6_unicast_hops(socket.tcp_socket(), Some(value)) {
-            Ok(()) => Ok(()),
-            Err(Errno::NOPROTOOPT) => Ok(sockopt::set_ip_ttl(socket.tcp_socket(), value.into())?),
-            Err(err) => Err(err.into()),
-        }
-    }
-
-    fn receive_buffer_size(
-        &mut self,
-        this: Resource<tcp::TcpSocket>,
-    ) -> Result<u64, network::Error> {
-        let table = self.table();
-        let socket = table.get_resource(&this)?;
-        Ok(sockopt::get_socket_recv_buffer_size(socket.tcp_socket())? as u64)
-    }
-
-    fn set_receive_buffer_size(
-        &mut self,
-        this: Resource<tcp::TcpSocket>,
-        value: u64,
-    ) -> Result<(), network::Error> {
-        let table = self.table();
-        let socket = table.get_resource(&this)?;
-        let value = value.try_into().map_err(|_| ErrorCode::OutOfMemory)?;
-        Ok(sockopt::set_socket_recv_buffer_size(
-            socket.tcp_socket(),
-            value,
-        )?)
-    }
-
-    fn send_buffer_size(&mut self, this: Resource<tcp::TcpSocket>) -> Result<u64, network::Error> {
-        let table = self.table();
-        let socket = table.get_resource(&this)?;
-        Ok(sockopt::get_socket_send_buffer_size(socket.tcp_socket())? as u64)
-    }
-
-    fn set_send_buffer_size(
-        &mut self,
-        this: Resource<tcp::TcpSocket>,
-        value: u64,
-    ) -> Result<(), network::Error> {
-        let table = self.table();
-        let socket = table.get_resource(&this)?;
-        let value = value.try_into().map_err(|_| ErrorCode::OutOfMemory)?;
-        Ok(sockopt::set_socket_send_buffer_size(
-            socket.tcp_socket(),
-            value,
-        )?)
-    }
-
-    fn subscribe(&mut self, this: Resource<tcp::TcpSocket>) -> anyhow::Result<Resource<Pollable>> {
-        crate::preview2::poll::subscribe(self.table_mut(), this)
-    }
-
-    fn shutdown(
-        &mut self,
-        this: Resource<tcp::TcpSocket>,
-        shutdown_type: ShutdownType,
-    ) -> Result<(), network::Error> {
-        let table = self.table();
-        let socket = table.get_resource(&this)?;
-
-        let how = match shutdown_type {
-            ShutdownType::Receive => std::net::Shutdown::Read,
-            ShutdownType::Send => std::net::Shutdown::Write,
-            ShutdownType::Both => std::net::Shutdown::Both,
-        };
-
-        socket
-            .tcp_socket()
-            .as_socketlike_view::<std::net::TcpStream>()
-            .shutdown(how)?;
-        Ok(())
-    }
-
-    fn drop(&mut self, this: Resource<tcp::TcpSocket>) -> Result<(), anyhow::Error> {
-        let table = self.table_mut();
-
-        // As in the filesystem implementation, we assume closing a socket
-        // doesn't block.
-        let dropped = table.delete_resource(this)?;
-
-        // If we might have an `event::poll` waiting on the socket, wake it up.
-        #[cfg(not(unix))]
-        {
-            match dropped.tcp_state {
-                TcpState::Default
-                | TcpState::BindStarted
-                | TcpState::Bound
-                | TcpState::ListenStarted
-                | TcpState::ConnectReady => {}
-
-                TcpState::Listening | TcpState::Connecting | TcpState::Connected => {
-                    match rustix::net::shutdown(&*dropped.inner, rustix::net::Shutdown::ReadWrite) {
-                        Ok(()) | Err(Errno::NOTCONN) => {}
-                        Err(err) => Err(err).unwrap(),
-                    }
-                }
-            }
-        }
-
-        drop(dropped);
-
-        Ok(())
-    }
-}
-
-// On POSIX, non-blocking TCP socket `connect` uses `EINPROGRESS`.
-// <https://pubs.opengroup.org/onlinepubs/9699919799/functions/connect.html>
-#[cfg(not(windows))]
-const INPROGRESS: Errno = Errno::INPROGRESS;
-
-// On Windows, non-blocking TCP socket `connect` uses `WSAEWOULDBLOCK`.
-// <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-connect>
-#[cfg(windows)]
-const INPROGRESS: Errno = Errno::WOULDBLOCK;
diff --git a/crates/wasi/src/preview2/host/tcp_create_socket.rs b/crates/wasi/src/preview2/host/tcp_create_socket.rs
deleted file mode 100644
index 60fc34482399..000000000000
--- a/crates/wasi/src/preview2/host/tcp_create_socket.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-use crate::preview2::bindings::{
-    sockets::network::{self, IpAddressFamily},
-    sockets::tcp_create_socket,
-};
-use crate::preview2::tcp::TcpSocket;
-use crate::preview2::WasiView;
-use wasmtime::component::Resource;
-
-impl<T: WasiView> tcp_create_socket::Host for T {
-    fn create_tcp_socket(
-        &mut self,
-        address_family: IpAddressFamily,
-    ) -> Result<Resource<TcpSocket>, network::Error> {
-        let socket = TcpSocket::new(address_family.into())?;
-        let socket = self.table_mut().push_resource(socket)?;
-        Ok(socket)
-    }
-}
diff --git a/crates/wasi/src/preview2/ip_name_lookup.rs b/crates/wasi/src/preview2/ip_name_lookup.rs
deleted file mode 100644
index b4a02427b475..000000000000
--- a/crates/wasi/src/preview2/ip_name_lookup.rs
+++ /dev/null
@@ -1,137 +0,0 @@
-use crate::preview2::bindings::sockets::ip_name_lookup::{Host, HostResolveAddressStream};
-use crate::preview2::bindings::sockets::network::{
-    Error, ErrorCode, IpAddress, IpAddressFamily, Network,
-};
-use crate::preview2::poll::{subscribe, Pollable, Subscribe};
-use crate::preview2::{spawn_blocking, AbortOnDropJoinHandle, WasiView};
-use anyhow::Result;
-use std::io;
-use std::mem;
-use std::net::{SocketAddr, ToSocketAddrs};
-use std::pin::Pin;
-use std::vec;
-use wasmtime::component::Resource;
-
-pub enum ResolveAddressStream {
-    Waiting(AbortOnDropJoinHandle<io::Result<Vec<IpAddress>>>),
-    Done(io::Result<vec::IntoIter<IpAddress>>),
-}
-
-#[async_trait::async_trait]
-impl<T: WasiView> Host for T {
-    fn resolve_addresses(
-        &mut self,
-        network: Resource<Network>,
-        name: String,
-        family: Option<IpAddressFamily>,
-        include_unavailable: bool,
-    ) -> Result<Resource<ResolveAddressStream>, Error> {
-        let network = self.table().get_resource(&network)?;
-
-        // `Host::parse` serves us two functions:
-        // 1. validate the input is not an IP address,
-        // 2. convert unicode domains to punycode.
-        let name = match url::Host::parse(&name).map_err(|_| ErrorCode::InvalidName)? {
-            url::Host::Domain(name) => name,
-            url::Host::Ipv4(_) => return Err(ErrorCode::InvalidName.into()),
-            url::Host::Ipv6(_) => return Err(ErrorCode::InvalidName.into()),
-        };
-
-        if !network.allow_ip_name_lookup {
-            return Err(ErrorCode::PermanentResolverFailure.into());
-        }
-
-        // ignored for now, should probably have a future PR to actually take
-        // this into account. This would require invoking `getaddrinfo` directly
-        // rather than using the standard library to do it for us.
-        let _ = include_unavailable;
-
-        // For now use the standard library to perform actual resolution through
-        // the usage of the `ToSocketAddrs` trait. This blocks the current
-        // thread, so use `spawn_blocking`. Finally note that this is only
-        // resolving names, not ports, so force the port to be 0.
-        let task = spawn_blocking(move || -> io::Result<Vec<_>> {
-            let result = (name.as_str(), 0).to_socket_addrs()?;
-            Ok(result
-                .filter_map(|addr| {
-                    // In lieu of preventing these addresses from being resolved
-                    // in the first place, filter them out here.
-                    match addr {
-                        SocketAddr::V4(addr) => match family {
-                            None | Some(IpAddressFamily::Ipv4) => {
-                                let [a, b, c, d] = addr.ip().octets();
-                                Some(IpAddress::Ipv4((a, b, c, d)))
-                            }
-                            Some(IpAddressFamily::Ipv6) => None,
-                        },
-                        SocketAddr::V6(addr) => match family {
-                            None | Some(IpAddressFamily::Ipv6) => {
-                                let [a, b, c, d, e, f, g, h] = addr.ip().segments();
-                                Some(IpAddress::Ipv6((a, b, c, d, e, f, g, h)))
-                            }
-                            Some(IpAddressFamily::Ipv4) => None,
-                        },
-                    }
-                })
-                .collect())
-        });
-        let resource = self
-            .table_mut()
-            .push_resource(ResolveAddressStream::Waiting(task))?;
-        Ok(resource)
-    }
-}
-
-#[async_trait::async_trait]
-impl<T: WasiView> HostResolveAddressStream for T {
-    fn resolve_next_address(
-        &mut self,
-        resource: Resource<ResolveAddressStream>,
-    ) -> Result<Option<IpAddress>, Error> {
-        let stream = self.table_mut().get_resource_mut(&resource)?;
-        loop {
-            match stream {
-                ResolveAddressStream::Waiting(future) => {
-                    match crate::preview2::poll_noop(Pin::new(future)) {
-                        Some(result) => {
-                            *stream = ResolveAddressStream::Done(result.map(|v| v.into_iter()));
-                        }
-                        None => return Err(ErrorCode::WouldBlock.into()),
-                    }
-                }
-                ResolveAddressStream::Done(slot @ Err(_)) => {
-                    // TODO: this `?` is what converts `io::Error` into `Error`
-                    // and the conversion is not great right now. The standard
-                    // library doesn't expose a ton of information through the
-                    // return value of `getaddrinfo` right now so supporting a
-                    // richer conversion here will probably require calling
-                    // `getaddrinfo` directly.
-                    mem::replace(slot, Ok(Vec::new().into_iter()))?;
-                    unreachable!();
-                }
-                ResolveAddressStream::Done(Ok(iter)) => return Ok(iter.next()),
-            }
-        }
-    }
-
-    fn subscribe(
-        &mut self,
-        resource: Resource<ResolveAddressStream>,
-    ) -> Result<Resource<Pollable>> {
-        subscribe(self.table_mut(), resource)
-    }
-
-    fn drop(&mut self, resource: Resource<ResolveAddressStream>) -> Result<()> {
-        self.table_mut().delete_resource(resource)?;
-        Ok(())
-    }
-}
-
-#[async_trait::async_trait]
-impl Subscribe for ResolveAddressStream {
-    async fn ready(&mut self) {
-        if let ResolveAddressStream::Waiting(future) = self {
-            *self = ResolveAddressStream::Done(future.await.map(|v| v.into_iter()));
-        }
-    }
-}
diff --git a/crates/wasi/src/preview2/mod.rs b/crates/wasi/src/preview2/mod.rs
deleted file mode 100644
index 9b4a273b8af9..000000000000
--- a/crates/wasi/src/preview2/mod.rs
+++ /dev/null
@@ -1,263 +0,0 @@
-//! # Wasmtime's WASI Preview 2 Implementation
-//!
-//! Welcome to the (new!) WASI implementation from the Wasmtime team. The goal
-//! of this implementation is to support WASI Preview 2 via the Component
-//! Model, as well as to provide legacy Preview 1 host support with an adapter
-//! that is implemented in terms of the Preview 2 interfaces.
-//!
-//! Presently, this crate is experimental. We don't yet recommend you use it
-//! in production. Specifically:
-//! * the wit files in tree describing preview 2 are not faithful to the
-//! standards repos
-//!
-//! Once these issues are resolved, we expect to move this namespace up to the
-//! root of the wasmtime-wasi crate, and move its other exports underneath a
-//! `pub mod legacy` with an off-by-default feature flag, and after 2
-//! releases, retire and remove that code from our tree.
-
-use std::future::Future;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-mod clocks;
-pub mod command;
-mod ctx;
-mod error;
-mod filesystem;
-mod host;
-mod ip_name_lookup;
-mod network;
-pub mod pipe;
-mod poll;
-#[cfg(feature = "preview1-on-preview2")]
-pub mod preview1;
-mod random;
-mod stdio;
-mod stream;
-mod table;
-mod tcp;
-mod write_stream;
-
-pub use self::clocks::{HostMonotonicClock, HostWallClock};
-pub use self::ctx::{WasiCtx, WasiCtxBuilder, WasiView};
-pub use self::error::I32Exit;
-pub use self::filesystem::{DirPerms, FilePerms};
-pub use self::poll::{subscribe, ClosureFuture, MakeFuture, Pollable, PollableFuture, Subscribe};
-pub use self::random::{thread_rng, Deterministic};
-pub use self::stdio::{
-    stderr, stdin, stdout, IsATTY, Stderr, Stdin, StdinStream, Stdout, StdoutStream,
-};
-pub use self::stream::{HostInputStream, HostOutputStream, InputStream, OutputStream, StreamError};
-pub use self::table::{Table, TableError};
-pub use cap_fs_ext::SystemTimeSpec;
-pub use cap_rand::RngCore;
-
-pub mod bindings {
-    // Generate traits for synchronous bindings.
-    //
-    // Note that this is only done for interfaces which can block, or those which
-    // have some functions in `only_imports` below for being async.
-    pub mod sync_io {
-        pub(crate) mod _internal {
-            wasmtime::component::bindgen!({
-                path: "wit",
-                interfaces: "
-                    import wasi:io/poll
-                    import wasi:io/streams
-                    import wasi:filesystem/types
-                ",
-                tracing: true,
-                trappable_error_type: {
-                    "wasi:io/streams"::"stream-error": Error,
-                    "wasi:filesystem/types"::"error-code": Error,
-                },
-                with: {
-                    "wasi:clocks/wall-clock": crate::preview2::bindings::clocks::wall_clock,
-                    "wasi:filesystem/types/descriptor": super::super::filesystem::types::Descriptor,
-                    "wasi:filesystem/types/directory-entry-stream": super::super::filesystem::types::DirectoryEntryStream,
-                    "wasi:io/poll/pollable": super::super::io::poll::Pollable,
-                    "wasi:io/streams/input-stream": super::super::io::streams::InputStream,
-                    "wasi:io/streams/output-stream": super::super::io::streams::OutputStream,
-                }
-            });
-        }
-        pub use self::_internal::wasi::{filesystem, io};
-    }
-
-    wasmtime::component::bindgen!({
-        path: "wit",
-        interfaces: "include wasi:cli/reactor",
-        tracing: true,
-        async: {
-            // Only these functions are `async` and everything else is sync
-            // meaning that it basically doesn't need to block. These functions
-            // are the only ones that need to block.
-            //
-            // Note that at this time `only_imports` works on function names
-            // which in theory can be shared across interfaces, so this may
-            // need fancier syntax in the future.
-            only_imports: [
-                "[method]descriptor.access-at",
-                "[method]descriptor.advise",
-                "[method]descriptor.change-directory-permissions-at",
-                "[method]descriptor.change-file-permissions-at",
-                "[method]descriptor.create-directory-at",
-                "[method]descriptor.get-flags",
-                "[method]descriptor.get-type",
-                "[method]descriptor.is-same-object",
-                "[method]descriptor.link-at",
-                "[method]descriptor.lock-exclusive",
-                "[method]descriptor.lock-shared",
-                "[method]descriptor.metadata-hash",
-                "[method]descriptor.metadata-hash-at",
-                "[method]descriptor.open-at",
-                "[method]descriptor.read",
-                "[method]descriptor.read-directory",
-                "[method]descriptor.readlink-at",
-                "[method]descriptor.remove-directory-at",
-                "[method]descriptor.rename-at",
-                "[method]descriptor.set-size",
-                "[method]descriptor.set-times",
-                "[method]descriptor.set-times-at",
-                "[method]descriptor.stat",
-                "[method]descriptor.stat-at",
-                "[method]descriptor.symlink-at",
-                "[method]descriptor.sync",
-                "[method]descriptor.sync-data",
-                "[method]descriptor.try-lock-exclusive",
-                "[method]descriptor.try-lock-shared",
-                "[method]descriptor.unlink-file-at",
-                "[method]descriptor.unlock",
-                "[method]descriptor.write",
-                "[method]input-stream.read",
-                "[method]input-stream.blocking-read",
-                "[method]input-stream.blocking-skip",
-                "[method]input-stream.skip",
-                "[method]output-stream.forward",
-                "[method]output-stream.splice",
-                "[method]output-stream.blocking-splice",
-                "[method]output-stream.blocking-flush",
-                "[method]output-stream.blocking-write",
-                "[method]output-stream.blocking-write-and-flush",
-                "[method]output-stream.blocking-write-zeroes-and-flush",
-                "[method]directory-entry-stream.read-directory-entry",
-                "poll-list",
-                "poll-one",
-            ],
-        },
-        with: {
-            "wasi:sockets/ip-name-lookup/resolve-address-stream": super::ip_name_lookup::ResolveAddressStream,
-        },
-        trappable_error_type: {
-            "wasi:io/streams"::"stream-error": Error,
-            "wasi:filesystem/types"::"error-code": Error,
-            "wasi:sockets/network"::"error-code": Error,
-        },
-        with: {
-            "wasi:sockets/network/network": super::network::Network,
-            "wasi:sockets/tcp/tcp-socket": super::tcp::TcpSocket,
-            "wasi:filesystem/types/directory-entry-stream": super::filesystem::ReaddirIterator,
-            "wasi:filesystem/types/descriptor": super::filesystem::Descriptor,
-            "wasi:io/streams/input-stream": super::stream::InputStream,
-            "wasi:io/streams/output-stream": super::stream::OutputStream,
-            "wasi:io/poll/pollable": super::poll::Pollable,
-            "wasi:cli/terminal-input/terminal-input": super::stdio::TerminalInput,
-            "wasi:cli/terminal-output/terminal-output": super::stdio::TerminalOutput,
-        },
-    });
-
-    pub use wasi::*;
-}
-
-pub(crate) static RUNTIME: once_cell::sync::Lazy<tokio::runtime::Runtime> =
-    once_cell::sync::Lazy::new(|| {
-        tokio::runtime::Builder::new_current_thread()
-            .enable_time()
-            .enable_io()
-            .build()
-            .unwrap()
-    });
-
-pub struct AbortOnDropJoinHandle<T>(tokio::task::JoinHandle<T>);
-impl<T> Drop for AbortOnDropJoinHandle<T> {
-    fn drop(&mut self) {
-        self.0.abort()
-    }
-}
-impl<T> std::ops::Deref for AbortOnDropJoinHandle<T> {
-    type Target = tokio::task::JoinHandle<T>;
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-impl<T> std::ops::DerefMut for AbortOnDropJoinHandle<T> {
-    fn deref_mut(&mut self) -> &mut tokio::task::JoinHandle<T> {
-        &mut self.0
-    }
-}
-impl<T> From<tokio::task::JoinHandle<T>> for AbortOnDropJoinHandle<T> {
-    fn from(jh: tokio::task::JoinHandle<T>) -> Self {
-        AbortOnDropJoinHandle(jh)
-    }
-}
-impl<T> Future for AbortOnDropJoinHandle<T> {
-    type Output = T;
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        match Pin::new(&mut self.as_mut().0).poll(cx) {
-            Poll::Pending => Poll::Pending,
-            Poll::Ready(r) => Poll::Ready(r.expect("child task panicked")),
-        }
-    }
-}
-
-pub fn spawn<F>(f: F) -> AbortOnDropJoinHandle<F::Output>
-where
-    F: Future + Send + 'static,
-    F::Output: Send + 'static,
-{
-    let j = with_ambient_tokio_runtime(|| tokio::task::spawn(f));
-    AbortOnDropJoinHandle(j)
-}
-
-pub fn spawn_blocking<F, R>(f: F) -> AbortOnDropJoinHandle<R>
-where
-    F: FnOnce() -> R + Send + 'static,
-    R: Send + 'static,
-{
-    let j = with_ambient_tokio_runtime(|| tokio::task::spawn_blocking(f));
-    AbortOnDropJoinHandle(j)
-}
-
-pub fn in_tokio<F: Future>(f: F) -> F::Output {
-    match tokio::runtime::Handle::try_current() {
-        Ok(h) => {
-            let _enter = h.enter();
-            h.block_on(f)
-        }
-        Err(_) => {
-            let _enter = RUNTIME.enter();
-            RUNTIME.block_on(f)
-        }
-    }
-}
-
-fn with_ambient_tokio_runtime<R>(f: impl FnOnce() -> R) -> R {
-    match tokio::runtime::Handle::try_current() {
-        Ok(_) => f(),
-        Err(_) => {
-            let _enter = RUNTIME.enter();
-            f()
-        }
-    }
-}
-
-fn poll_noop<F>(future: Pin<&mut F>) -> Option<F::Output>
-where
-    F: Future,
-{
-    let mut task = Context::from_waker(futures::task::noop_waker_ref());
-    match future.poll(&mut task) {
-        Poll::Ready(result) => Some(result),
-        Poll::Pending => None,
-    }
-}
diff --git a/crates/wasi/src/preview2/network.rs b/crates/wasi/src/preview2/network.rs
deleted file mode 100644
index 614130392d29..000000000000
--- a/crates/wasi/src/preview2/network.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-use cap_std::net::Pool;
-
-pub struct Network {
-    pub pool: Pool,
-    pub allow_ip_name_lookup: bool,
-}
diff --git a/crates/wasi/src/preview2/poll.rs b/crates/wasi/src/preview2/poll.rs
deleted file mode 100644
index 54962aa3672c..000000000000
--- a/crates/wasi/src/preview2/poll.rs
+++ /dev/null
@@ -1,165 +0,0 @@
-use crate::preview2::{bindings::io::poll, Table, WasiView};
-use anyhow::Result;
-use std::any::Any;
-use std::collections::HashMap;
-use std::future::Future;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use wasmtime::component::Resource;
-
-pub type PollableFuture<'a> = Pin<Box<dyn Future<Output = ()> + Send + 'a>>;
-pub type MakeFuture = for<'a> fn(&'a mut dyn Any) -> PollableFuture<'a>;
-pub type ClosureFuture = Box<dyn Fn() -> PollableFuture<'static> + Send + Sync + 'static>;
-
-/// A host representation of the `wasi:io/poll.pollable` resource.
-///
-/// A pollable is not the same thing as a Rust Future: the same pollable may be used to
-/// repeatedly check for readiness of a given condition, e.g. if a stream is readable
-/// or writable. So, rather than containing a Future, which can only become Ready once, a
-/// Pollable contains a way to create a Future in each call to `poll_list`.
-pub struct Pollable {
-    index: u32,
-    make_future: MakeFuture,
-    remove_index_on_delete: Option<fn(&mut Table, u32) -> Result<()>>,
-}
-
-#[async_trait::async_trait]
-pub trait Subscribe: Send + Sync + 'static {
-    async fn ready(&mut self);
-}
-
-/// Creates a `pollable` resource which is susbcribed to the provided
-/// `resource`.
-///
-/// If `resource` is an owned resource then it will be deleted when the returned
-/// resource is deleted. Otherwise the returned resource is considered a "child"
-/// of the given `resource` which means that the given resource cannot be
-/// deleted while the `pollable` is still alive.
-pub fn subscribe<T>(table: &mut Table, resource: Resource<T>) -> Result<Resource<Pollable>>
-where
-    T: Subscribe,
-{
-    fn make_future<'a, T>(stream: &'a mut dyn Any) -> PollableFuture<'a>
-    where
-        T: Subscribe,
-    {
-        stream.downcast_mut::<T>().unwrap().ready()
-    }
-
-    let pollable = Pollable {
-        index: resource.rep(),
-        remove_index_on_delete: if resource.owned() {
-            Some(|table, idx| {
-                let resource = Resource::<T>::new_own(idx);
-                table.delete_resource(resource)?;
-                Ok(())
-            })
-        } else {
-            None
-        },
-        make_future: make_future::<T>,
-    };
-
-    Ok(table.push_child_resource(pollable, &resource)?)
-}
-
-#[async_trait::async_trait]
-impl<T: WasiView> poll::Host for T {
-    async fn poll_list(&mut self, pollables: Vec<Resource<Pollable>>) -> Result<Vec<u32>> {
-        type ReadylistIndex = u32;
-
-        let table = self.table_mut();
-
-        let mut table_futures: HashMap<u32, (MakeFuture, Vec<ReadylistIndex>)> = HashMap::new();
-
-        for (ix, p) in pollables.iter().enumerate() {
-            let ix: u32 = ix.try_into()?;
-
-            let pollable = table.get_resource(p)?;
-            let (_, list) = table_futures
-                .entry(pollable.index)
-                .or_insert((pollable.make_future, Vec::new()));
-            list.push(ix);
-        }
-
-        let mut futures: Vec<(PollableFuture<'_>, Vec<ReadylistIndex>)> = Vec::new();
-        for (entry, (make_future, readylist_indices)) in table.iter_entries(table_futures) {
-            let entry = entry?;
-            futures.push((make_future(entry), readylist_indices));
-        }
-
-        struct PollList<'a> {
-            futures: Vec<(PollableFuture<'a>, Vec<ReadylistIndex>)>,
-        }
-        impl<'a> Future for PollList<'a> {
-            type Output = Vec<u32>;
-
-            fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-                let mut any_ready = false;
-                let mut results = Vec::new();
-                for (fut, readylist_indicies) in self.futures.iter_mut() {
-                    match fut.as_mut().poll(cx) {
-                        Poll::Ready(()) => {
-                            results.extend_from_slice(readylist_indicies);
-                            any_ready = true;
-                        }
-                        Poll::Pending => {}
-                    }
-                }
-                if any_ready {
-                    Poll::Ready(results)
-                } else {
-                    Poll::Pending
-                }
-            }
-        }
-
-        Ok(PollList { futures }.await)
-    }
-
-    async fn poll_one(&mut self, pollable: Resource<Pollable>) -> Result<()> {
-        let table = self.table_mut();
-
-        let pollable = table.get_resource(&pollable)?;
-        let ready = (pollable.make_future)(table.get_as_any_mut(pollable.index)?);
-        ready.await;
-        Ok(())
-    }
-}
-
-#[async_trait::async_trait]
-impl<T: WasiView> crate::preview2::bindings::io::poll::HostPollable for T {
-    fn drop(&mut self, pollable: Resource<Pollable>) -> Result<()> {
-        let pollable = self.table_mut().delete_resource(pollable)?;
-        if let Some(delete) = pollable.remove_index_on_delete {
-            delete(self.table_mut(), pollable.index)?;
-        }
-        Ok(())
-    }
-}
-
-pub mod sync {
-    use crate::preview2::{
-        bindings::io::poll as async_poll,
-        bindings::sync_io::io::poll::{self, Pollable},
-        in_tokio, WasiView,
-    };
-    use anyhow::Result;
-    use wasmtime::component::Resource;
-
-    impl<T: WasiView> poll::Host for T {
-        fn poll_list(&mut self, pollables: Vec<Resource<Pollable>>) -> Result<Vec<u32>> {
-            in_tokio(async { async_poll::Host::poll_list(self, pollables).await })
-        }
-
-        fn poll_one(&mut self, pollable: Resource<Pollable>) -> Result<()> {
-            in_tokio(async { async_poll::Host::poll_one(self, pollable).await })
-        }
-    }
-
-    impl<T: WasiView> crate::preview2::bindings::sync_io::io::poll::HostPollable for T {
-        fn drop(&mut self, pollable: Resource<Pollable>) -> Result<()> {
-            async_poll::HostPollable::drop(self, pollable)
-        }
-    }
-}
diff --git a/crates/wasi/src/preview2/preview1.rs b/crates/wasi/src/preview2/preview1.rs
deleted file mode 100644
index a4bdada9b7f6..000000000000
--- a/crates/wasi/src/preview2/preview1.rs
+++ /dev/null
@@ -1,2397 +0,0 @@
-use crate::preview2::bindings::{
-    self,
-    cli::{
-        stderr, stdin, stdout, terminal_input, terminal_output, terminal_stderr, terminal_stdin,
-        terminal_stdout,
-    },
-    clocks::{monotonic_clock, wall_clock},
-    filesystem::{preopens, types as filesystem},
-    io::{poll, streams},
-};
-use crate::preview2::{IsATTY, StreamError, TableError, WasiView};
-use anyhow::{anyhow, bail, Context};
-use std::borrow::Borrow;
-use std::collections::{BTreeMap, HashSet};
-use std::mem::{self, size_of, size_of_val};
-use std::ops::{Deref, DerefMut};
-use std::slice;
-use std::sync::atomic::{AtomicU64, Ordering};
-use std::sync::Arc;
-use wasmtime::component::Resource;
-use wiggle::tracing::instrument;
-use wiggle::{GuestError, GuestPtr, GuestSlice, GuestSliceMut, GuestStrCow, GuestType};
-
-#[derive(Debug)]
-struct File {
-    /// The handle to the preview2 descriptor that this file is referencing.
-    fd: Resource<filesystem::Descriptor>,
-
-    /// The current-position pointer.
-    position: Arc<AtomicU64>,
-
-    /// In append mode, all writes append to the file.
-    append: bool,
-
-    /// When blocking, read and write calls dispatch to blocking_read and
-    /// blocking_check_write on the underlying streams. When false, read and write
-    /// dispatch to stream's plain read and check_write.
-    blocking_mode: BlockingMode,
-}
-
-#[derive(Clone, Copy, Debug)]
-enum BlockingMode {
-    Blocking,
-    NonBlocking,
-}
-impl BlockingMode {
-    fn from_fdflags(flags: &types::Fdflags) -> Self {
-        if flags.contains(types::Fdflags::NONBLOCK) {
-            BlockingMode::NonBlocking
-        } else {
-            BlockingMode::Blocking
-        }
-    }
-    async fn read(
-        &self,
-        host: &mut impl streams::Host,
-        input_stream: Resource<streams::InputStream>,
-        max_size: usize,
-    ) -> Result<Vec<u8>, types::Error> {
-        let max_size = max_size.try_into().unwrap_or(u64::MAX);
-        match self {
-            BlockingMode::Blocking => {
-                match streams::HostInputStream::blocking_read(host, input_stream, max_size).await {
-                    Ok(r) if r.is_empty() => Err(types::Errno::Intr.into()),
-                    Ok(r) => Ok(r),
-                    Err(e) if matches!(e.downcast_ref(), Some(streams::StreamError::Closed)) => {
-                        Ok(Vec::new())
-                    }
-                    Err(e) => {
-                        tracing::trace!("throwing away read error to report as Errno::Io: {e:?}");
-                        Err(types::Errno::Io.into())
-                    }
-                }
-            }
-
-            BlockingMode::NonBlocking => {
-                match streams::HostInputStream::read(host, input_stream, max_size).await {
-                    Ok(r) => Ok(r),
-                    Err(e) if matches!(e.downcast_ref(), Some(streams::StreamError::Closed)) => {
-                        Ok(Vec::new())
-                    }
-                    Err(e) => {
-                        tracing::trace!("throwing away read error to report as Errno::Io: {e:?}");
-                        Err(types::Errno::Io.into())
-                    }
-                }
-            }
-        }
-    }
-    async fn write(
-        &self,
-        host: &mut (impl streams::Host + poll::Host),
-        output_stream: Resource<streams::OutputStream>,
-        mut bytes: &[u8],
-    ) -> Result<usize, streams::Error> {
-        use streams::HostOutputStream as Streams;
-
-        match self {
-            BlockingMode::Blocking => {
-                let total = bytes.len();
-                while !bytes.is_empty() {
-                    // NOTE: blocking_write_and_flush takes at most one 4k buffer.
-                    let len = bytes.len().min(4096);
-                    let (chunk, rest) = bytes.split_at(len);
-                    bytes = rest;
-
-                    Streams::blocking_write_and_flush(
-                        host,
-                        output_stream.borrowed(),
-                        Vec::from(chunk),
-                    )
-                    .await?
-                }
-
-                Ok(total)
-            }
-            BlockingMode::NonBlocking => {
-                let n = match Streams::check_write(host, output_stream.borrowed()) {
-                    Ok(n) => n,
-                    Err(e) if matches!(e.downcast_ref(), Some(streams::StreamError::Closed)) => 0,
-                    Err(e) => Err(e)?,
-                };
-
-                let len = bytes.len().min(n as usize);
-                if len == 0 {
-                    return Ok(0);
-                }
-
-                match Streams::write(host, output_stream.borrowed(), bytes[..len].to_vec()) {
-                    Ok(()) => {}
-                    Err(e) if matches!(e.downcast_ref(), Some(streams::StreamError::Closed)) => {
-                        return Ok(0)
-                    }
-                    Err(e) => Err(e)?,
-                }
-
-                match Streams::blocking_flush(host, output_stream.borrowed()).await {
-                    Ok(()) => {}
-                    Err(e) if matches!(e.downcast_ref(), Some(streams::StreamError::Closed)) => {
-                        return Ok(0)
-                    }
-                    Err(e) => Err(e)?,
-                };
-
-                Ok(len)
-            }
-        }
-    }
-}
-
-#[derive(Debug)]
-enum Descriptor {
-    Stdin {
-        stream: Resource<streams::InputStream>,
-        isatty: IsATTY,
-    },
-    Stdout {
-        stream: Resource<streams::OutputStream>,
-        isatty: IsATTY,
-    },
-    Stderr {
-        stream: Resource<streams::OutputStream>,
-        isatty: IsATTY,
-    },
-    PreopenDirectory((Resource<filesystem::Descriptor>, String)),
-    File(File),
-}
-
-#[derive(Debug, Default)]
-pub struct WasiPreview1Adapter {
-    descriptors: Option<Descriptors>,
-}
-
-#[derive(Debug, Default)]
-struct Descriptors {
-    used: BTreeMap<u32, Descriptor>,
-    free: Vec<u32>,
-}
-
-impl Deref for Descriptors {
-    type Target = BTreeMap<u32, Descriptor>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.used
-    }
-}
-
-impl DerefMut for Descriptors {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.used
-    }
-}
-
-impl Descriptors {
-    /// Initializes [Self] using `preopens`
-    fn new(
-        host: &mut (impl preopens::Host
-                  + stdin::Host
-                  + stdout::Host
-                  + stderr::Host
-                  + terminal_stdin::Host
-                  + terminal_stdout::Host
-                  + terminal_stderr::Host
-                  + terminal_input::Host
-                  + terminal_output::Host
-                  + ?Sized),
-    ) -> Result<Self, types::Error> {
-        let mut descriptors = Self::default();
-        descriptors.push(Descriptor::Stdin {
-            stream: host
-                .get_stdin()
-                .context("failed to call `get-stdin`")
-                .map_err(types::Error::trap)?,
-            isatty: if let Some(term_in) = host
-                .get_terminal_stdin()
-                .context("failed to call `get-terminal-stdin`")
-                .map_err(types::Error::trap)?
-            {
-                terminal_input::HostTerminalInput::drop(host, term_in)
-                    .context("failed to call `drop-terminal-input`")
-                    .map_err(types::Error::trap)?;
-                IsATTY::Yes
-            } else {
-                IsATTY::No
-            },
-        })?;
-        descriptors.push(Descriptor::Stdout {
-            stream: host
-                .get_stdout()
-                .context("failed to call `get-stdout`")
-                .map_err(types::Error::trap)?,
-            isatty: if let Some(term_out) = host
-                .get_terminal_stdout()
-                .context("failed to call `get-terminal-stdout`")
-                .map_err(types::Error::trap)?
-            {
-                terminal_output::HostTerminalOutput::drop(host, term_out)
-                    .context("failed to call `drop-terminal-output`")
-                    .map_err(types::Error::trap)?;
-                IsATTY::Yes
-            } else {
-                IsATTY::No
-            },
-        })?;
-        descriptors.push(Descriptor::Stderr {
-            stream: host
-                .get_stderr()
-                .context("failed to call `get-stderr`")
-                .map_err(types::Error::trap)?,
-            isatty: if let Some(term_out) = host
-                .get_terminal_stderr()
-                .context("failed to call `get-terminal-stderr`")
-                .map_err(types::Error::trap)?
-            {
-                terminal_output::HostTerminalOutput::drop(host, term_out)
-                    .context("failed to call `drop-terminal-output`")
-                    .map_err(types::Error::trap)?;
-                IsATTY::Yes
-            } else {
-                IsATTY::No
-            },
-        })?;
-
-        for dir in host
-            .get_directories()
-            .context("failed to call `get-directories`")
-            .map_err(types::Error::trap)?
-        {
-            descriptors.push(Descriptor::PreopenDirectory((dir.0, dir.1)))?;
-        }
-        Ok(descriptors)
-    }
-
-    /// Returns next descriptor number, which was never assigned
-    fn unused(&self) -> Result<u32> {
-        match self.last_key_value() {
-            Some((fd, _)) => {
-                if let Some(fd) = fd.checked_add(1) {
-                    return Ok(fd);
-                }
-                if self.len() == u32::MAX as usize {
-                    return Err(types::Errno::Loop.into());
-                }
-                // TODO: Optimize
-                Ok((0..u32::MAX)
-                    .rev()
-                    .find(|fd| !self.contains_key(fd))
-                    .expect("failed to find an unused file descriptor"))
-            }
-            None => Ok(0),
-        }
-    }
-
-    /// Removes the [Descriptor] corresponding to `fd`
-    fn remove(&mut self, fd: types::Fd) -> Option<Descriptor> {
-        let fd = fd.into();
-        let desc = self.used.remove(&fd)?;
-        self.free.push(fd);
-        Some(desc)
-    }
-
-    /// Pushes the [Descriptor] returning corresponding number.
-    /// This operation will try to reuse numbers previously removed via [`Self::remove`]
-    /// and rely on [`Self::unused`] if no free numbers are recorded
-    fn push(&mut self, desc: Descriptor) -> Result<u32> {
-        let fd = if let Some(fd) = self.free.pop() {
-            fd
-        } else {
-            self.unused()?
-        };
-        assert!(self.insert(fd, desc).is_none());
-        Ok(fd)
-    }
-
-    /// Like [Self::push], but for [`File`]
-    fn push_file(&mut self, file: File) -> Result<u32> {
-        self.push(Descriptor::File(file))
-    }
-}
-
-impl WasiPreview1Adapter {
-    pub fn new() -> Self {
-        Self::default()
-    }
-}
-
-// Any context that needs to support preview 1 will impl this trait. They can
-// construct the needed member with WasiPreview1Adapter::new().
-pub trait WasiPreview1View: WasiView {
-    fn adapter(&self) -> &WasiPreview1Adapter;
-    fn adapter_mut(&mut self) -> &mut WasiPreview1Adapter;
-}
-
-/// A mutably-borrowed [`WasiPreview1View`] implementation, which provides access to the stored
-/// state. It can be thought of as an in-flight [`WasiPreview1Adapter`] transaction, all
-/// changes will be recorded in the underlying [`WasiPreview1Adapter`] returned by
-/// [`WasiPreview1View::adapter_mut`] on [`Drop`] of this struct.
-// NOTE: This exists for the most part just due to the fact that `bindgen` generates methods with
-// `&mut self` receivers and so this struct lets us extend the lifetime of the `&mut self` borrow
-// of the [`WasiPreview1View`] to provide means to return mutably and immutably borrowed [`Descriptors`]
-// without having to rely on something like `Arc<Mutex<Descriptors>>`, while also being able to
-// call methods like [`TableFsExt::is_file`] and hiding complexity from preview1 method implementations.
-struct Transaction<'a, T: WasiPreview1View + ?Sized> {
-    view: &'a mut T,
-    descriptors: Descriptors,
-}
-
-impl<T: WasiPreview1View + ?Sized> Drop for Transaction<'_, T> {
-    /// Record changes in the [`WasiPreview1Adapter`] returned by [`WasiPreview1View::adapter_mut`]
-    fn drop(&mut self) {
-        let descriptors = mem::take(&mut self.descriptors);
-        self.view.adapter_mut().descriptors = Some(descriptors);
-    }
-}
-
-impl<T: WasiPreview1View + ?Sized> Transaction<'_, T> {
-    /// Borrows [`Descriptor`] corresponding to `fd`.
-    ///
-    /// # Errors
-    ///
-    /// Returns [`types::Errno::Badf`] if no [`Descriptor`] is found
-    fn get_descriptor(&self, fd: types::Fd) -> Result<&Descriptor> {
-        let fd = fd.into();
-        let desc = self.descriptors.get(&fd).ok_or(types::Errno::Badf)?;
-        Ok(desc)
-    }
-
-    /// Borrows [`File`] corresponding to `fd`
-    /// if it describes a [`Descriptor::File`] of [`crate::preview2::filesystem::File`] type
-    fn get_file(&self, fd: types::Fd) -> Result<&File> {
-        let fd = fd.into();
-        match self.descriptors.get(&fd) {
-            Some(Descriptor::File(file @ File { fd, .. })) => {
-                self.view.table().get_resource(fd)?.file()?;
-                Ok(file)
-            }
-            _ => Err(types::Errno::Badf.into()),
-        }
-    }
-
-    /// Mutably borrows [`File`] corresponding to `fd`
-    /// if it describes a [`Descriptor::File`] of [`crate::preview2::filesystem::File`] type
-    fn get_file_mut(&mut self, fd: types::Fd) -> Result<&mut File> {
-        let fd = fd.into();
-        match self.descriptors.get_mut(&fd) {
-            Some(Descriptor::File(file)) => {
-                self.view.table().get_resource(&file.fd)?.file()?;
-                Ok(file)
-            }
-            _ => Err(types::Errno::Badf.into()),
-        }
-    }
-
-    /// Borrows [`File`] corresponding to `fd`
-    /// if it describes a [`Descriptor::File`] of [`crate::preview2::filesystem::File`] type.
-    ///
-    /// # Errors
-    ///
-    /// Returns [`types::Errno::Spipe`] if the descriptor corresponds to stdio
-    fn get_seekable(&self, fd: types::Fd) -> Result<&File> {
-        let fd = fd.into();
-        match self.descriptors.get(&fd) {
-            Some(Descriptor::File(file @ File { fd, .. }))
-                if self.view.table().get_resource(fd)?.is_file() =>
-            {
-                Ok(file)
-            }
-            Some(
-                Descriptor::Stdin { .. } | Descriptor::Stdout { .. } | Descriptor::Stderr { .. },
-            ) => {
-                // NOTE: legacy implementation returns SPIPE here
-                Err(types::Errno::Spipe.into())
-            }
-            _ => Err(types::Errno::Badf.into()),
-        }
-    }
-
-    /// Returns [`filesystem::Descriptor`] corresponding to `fd`
-    fn get_fd(&self, fd: types::Fd) -> Result<Resource<filesystem::Descriptor>> {
-        match self.get_descriptor(fd)? {
-            Descriptor::File(File { fd, .. }) => Ok(fd.borrowed()),
-            Descriptor::PreopenDirectory((fd, _)) => Ok(fd.borrowed()),
-            Descriptor::Stdin { .. } | Descriptor::Stdout { .. } | Descriptor::Stderr { .. } => {
-                Err(types::Errno::Badf.into())
-            }
-        }
-    }
-
-    /// Returns [`filesystem::Descriptor`] corresponding to `fd`
-    /// if it describes a [`Descriptor::File`] of [`crate::preview2::filesystem::File`] type
-    fn get_file_fd(&self, fd: types::Fd) -> Result<Resource<filesystem::Descriptor>> {
-        self.get_file(fd).map(|File { fd, .. }| fd.borrowed())
-    }
-
-    /// Returns [`filesystem::Descriptor`] corresponding to `fd`
-    /// if it describes a [`Descriptor::File`] or [`Descriptor::PreopenDirectory`]
-    /// of [`crate::preview2::filesystem::Dir`] type
-    fn get_dir_fd(&self, fd: types::Fd) -> Result<Resource<filesystem::Descriptor>> {
-        let fd = fd.into();
-        match self.descriptors.get(&fd) {
-            Some(Descriptor::File(File { fd, .. }))
-                if self.view.table().get_resource(fd)?.is_dir() =>
-            {
-                Ok(fd.borrowed())
-            }
-            Some(Descriptor::PreopenDirectory((fd, _))) => Ok(fd.borrowed()),
-            _ => Err(types::Errno::Badf.into()),
-        }
-    }
-}
-
-trait WasiPreview1ViewExt:
-    WasiPreview1View
-    + preopens::Host
-    + stdin::Host
-    + stdout::Host
-    + stderr::Host
-    + terminal_input::Host
-    + terminal_output::Host
-    + terminal_stdin::Host
-    + terminal_stdout::Host
-    + terminal_stderr::Host
-{
-    /// Lazily initializes [`WasiPreview1Adapter`] returned by [`WasiPreview1View::adapter_mut`]
-    /// and returns [`Transaction`] on success
-    fn transact(&mut self) -> Result<Transaction<'_, Self>, types::Error> {
-        let descriptors = if let Some(descriptors) = self.adapter_mut().descriptors.take() {
-            descriptors
-        } else {
-            Descriptors::new(self)?
-        }
-        .into();
-        Ok(Transaction {
-            view: self,
-            descriptors,
-        })
-    }
-
-    /// Lazily initializes [`WasiPreview1Adapter`] returned by [`WasiPreview1View::adapter_mut`]
-    /// and returns [`filesystem::Descriptor`] corresponding to `fd`
-    fn get_fd(&mut self, fd: types::Fd) -> Result<Resource<filesystem::Descriptor>, types::Error> {
-        let st = self.transact()?;
-        let fd = st.get_fd(fd)?;
-        Ok(fd)
-    }
-
-    /// Lazily initializes [`WasiPreview1Adapter`] returned by [`WasiPreview1View::adapter_mut`]
-    /// and returns [`filesystem::Descriptor`] corresponding to `fd`
-    /// if it describes a [`Descriptor::File`] of [`crate::preview2::filesystem::File`] type
-    fn get_file_fd(
-        &mut self,
-        fd: types::Fd,
-    ) -> Result<Resource<filesystem::Descriptor>, types::Error> {
-        let st = self.transact()?;
-        let fd = st.get_file_fd(fd)?;
-        Ok(fd)
-    }
-
-    /// Lazily initializes [`WasiPreview1Adapter`] returned by [`WasiPreview1View::adapter_mut`]
-    /// and returns [`filesystem::Descriptor`] corresponding to `fd`
-    /// if it describes a [`Descriptor::File`] or [`Descriptor::PreopenDirectory`]
-    /// of [`crate::preview2::filesystem::Dir`] type
-    fn get_dir_fd(
-        &mut self,
-        fd: types::Fd,
-    ) -> Result<Resource<filesystem::Descriptor>, types::Error> {
-        let st = self.transact()?;
-        let fd = st.get_dir_fd(fd)?;
-        Ok(fd)
-    }
-}
-
-impl<T: WasiPreview1View + preopens::Host> WasiPreview1ViewExt for T {}
-
-pub fn add_to_linker_async<T: WasiPreview1View + Sync>(
-    linker: &mut wasmtime::Linker<T>,
-) -> anyhow::Result<()> {
-    wasi_snapshot_preview1::add_to_linker(linker, |t| t)
-}
-
-pub fn add_to_linker_sync<T: WasiPreview1View + Sync>(
-    linker: &mut wasmtime::Linker<T>,
-) -> anyhow::Result<()> {
-    sync::add_wasi_snapshot_preview1_to_linker(linker, |t| t)
-}
-
-// Generate the wasi_snapshot_preview1::WasiSnapshotPreview1 trait,
-// and the module types.
-// None of the generated modules, traits, or types should be used externally
-// to this module.
-wiggle::from_witx!({
-    witx: ["$CARGO_MANIFEST_DIR/witx/wasi_snapshot_preview1.witx"],
-    async: {
-        wasi_snapshot_preview1::{
-            fd_advise, fd_close, fd_datasync, fd_fdstat_get, fd_filestat_get, fd_filestat_set_size,
-            fd_filestat_set_times, fd_read, fd_pread, fd_seek, fd_sync, fd_readdir, fd_write,
-            fd_pwrite, poll_oneoff, path_create_directory, path_filestat_get,
-            path_filestat_set_times, path_link, path_open, path_readlink, path_remove_directory,
-            path_rename, path_symlink, path_unlink_file
-        }
-    },
-    errors: { errno => trappable Error },
-});
-
-mod sync {
-    use anyhow::Result;
-    use std::future::Future;
-
-    wiggle::wasmtime_integration!({
-        witx: ["$CARGO_MANIFEST_DIR/witx/wasi_snapshot_preview1.witx"],
-        target: super,
-        block_on[in_tokio]: {
-            wasi_snapshot_preview1::{
-                fd_advise, fd_close, fd_datasync, fd_fdstat_get, fd_filestat_get, fd_filestat_set_size,
-                fd_filestat_set_times, fd_read, fd_pread, fd_seek, fd_sync, fd_readdir, fd_write,
-                fd_pwrite, poll_oneoff, path_create_directory, path_filestat_get,
-                path_filestat_set_times, path_link, path_open, path_readlink, path_remove_directory,
-                path_rename, path_symlink, path_unlink_file
-            }
-        },
-        errors: { errno => trappable Error },
-    });
-
-    // Small wrapper around `in_tokio` to add a `Result` layer which is always
-    // `Ok`
-    fn in_tokio<F: Future>(future: F) -> Result<F::Output> {
-        Ok(crate::preview2::in_tokio(future))
-    }
-}
-
-impl wiggle::GuestErrorType for types::Errno {
-    fn success() -> Self {
-        Self::Success
-    }
-}
-
-impl From<StreamError> for types::Error {
-    fn from(err: StreamError) -> Self {
-        types::Error::from(streams::Error::from(err))
-    }
-}
-
-impl From<streams::Error> for types::Error {
-    fn from(err: streams::Error) -> Self {
-        match err.downcast() {
-            Ok(se) => se.into(),
-            Err(t) => types::Error::trap(t),
-        }
-    }
-}
-
-impl From<streams::StreamError> for types::Error {
-    fn from(err: streams::StreamError) -> Self {
-        match err {
-            streams::StreamError::Closed | streams::StreamError::LastOperationFailed => {
-                types::Errno::Io.into()
-            }
-        }
-    }
-}
-
-fn systimespec(set: bool, ts: types::Timestamp, now: bool) -> Result<filesystem::NewTimestamp> {
-    if set && now {
-        Err(types::Errno::Inval.into())
-    } else if set {
-        Ok(filesystem::NewTimestamp::Timestamp(filesystem::Datetime {
-            seconds: ts / 1_000_000_000,
-            nanoseconds: (ts % 1_000_000_000) as _,
-        }))
-    } else if now {
-        Ok(filesystem::NewTimestamp::Now)
-    } else {
-        Ok(filesystem::NewTimestamp::NoChange)
-    }
-}
-
-impl TryFrom<wall_clock::Datetime> for types::Timestamp {
-    type Error = types::Errno;
-
-    fn try_from(
-        wall_clock::Datetime {
-            seconds,
-            nanoseconds,
-        }: wall_clock::Datetime,
-    ) -> Result<Self, Self::Error> {
-        types::Timestamp::from(seconds)
-            .checked_mul(1_000_000_000)
-            .and_then(|ns| ns.checked_add(nanoseconds.into()))
-            .ok_or(types::Errno::Overflow)
-    }
-}
-
-impl From<types::Lookupflags> for filesystem::PathFlags {
-    fn from(flags: types::Lookupflags) -> Self {
-        if flags.contains(types::Lookupflags::SYMLINK_FOLLOW) {
-            filesystem::PathFlags::SYMLINK_FOLLOW
-        } else {
-            filesystem::PathFlags::empty()
-        }
-    }
-}
-
-impl From<types::Oflags> for filesystem::OpenFlags {
-    fn from(flags: types::Oflags) -> Self {
-        let mut out = filesystem::OpenFlags::empty();
-        if flags.contains(types::Oflags::CREAT) {
-            out |= filesystem::OpenFlags::CREATE;
-        }
-        if flags.contains(types::Oflags::DIRECTORY) {
-            out |= filesystem::OpenFlags::DIRECTORY;
-        }
-        if flags.contains(types::Oflags::EXCL) {
-            out |= filesystem::OpenFlags::EXCLUSIVE;
-        }
-        if flags.contains(types::Oflags::TRUNC) {
-            out |= filesystem::OpenFlags::TRUNCATE;
-        }
-        out
-    }
-}
-
-impl From<types::Advice> for filesystem::Advice {
-    fn from(advice: types::Advice) -> Self {
-        match advice {
-            types::Advice::Normal => filesystem::Advice::Normal,
-            types::Advice::Sequential => filesystem::Advice::Sequential,
-            types::Advice::Random => filesystem::Advice::Random,
-            types::Advice::Willneed => filesystem::Advice::WillNeed,
-            types::Advice::Dontneed => filesystem::Advice::DontNeed,
-            types::Advice::Noreuse => filesystem::Advice::NoReuse,
-        }
-    }
-}
-
-impl TryFrom<filesystem::DescriptorType> for types::Filetype {
-    type Error = anyhow::Error;
-
-    fn try_from(ty: filesystem::DescriptorType) -> Result<Self, Self::Error> {
-        match ty {
-            filesystem::DescriptorType::RegularFile => Ok(types::Filetype::RegularFile),
-            filesystem::DescriptorType::Directory => Ok(types::Filetype::Directory),
-            filesystem::DescriptorType::BlockDevice => Ok(types::Filetype::BlockDevice),
-            filesystem::DescriptorType::CharacterDevice => Ok(types::Filetype::CharacterDevice),
-            // preview1 never had a FIFO code.
-            filesystem::DescriptorType::Fifo => Ok(types::Filetype::Unknown),
-            // TODO: Add a way to disginguish between FILETYPE_SOCKET_STREAM and
-            // FILETYPE_SOCKET_DGRAM.
-            filesystem::DescriptorType::Socket => {
-                bail!("sockets are not currently supported")
-            }
-            filesystem::DescriptorType::SymbolicLink => Ok(types::Filetype::SymbolicLink),
-            filesystem::DescriptorType::Unknown => Ok(types::Filetype::Unknown),
-        }
-    }
-}
-
-impl From<IsATTY> for types::Filetype {
-    fn from(isatty: IsATTY) -> Self {
-        match isatty {
-            IsATTY::Yes => types::Filetype::CharacterDevice,
-            IsATTY::No => types::Filetype::Unknown,
-        }
-    }
-}
-
-impl From<filesystem::ErrorCode> for types::Errno {
-    fn from(code: filesystem::ErrorCode) -> Self {
-        match code {
-            filesystem::ErrorCode::Access => types::Errno::Acces,
-            filesystem::ErrorCode::WouldBlock => types::Errno::Again,
-            filesystem::ErrorCode::Already => types::Errno::Already,
-            filesystem::ErrorCode::BadDescriptor => types::Errno::Badf,
-            filesystem::ErrorCode::Busy => types::Errno::Busy,
-            filesystem::ErrorCode::Deadlock => types::Errno::Deadlk,
-            filesystem::ErrorCode::Quota => types::Errno::Dquot,
-            filesystem::ErrorCode::Exist => types::Errno::Exist,
-            filesystem::ErrorCode::FileTooLarge => types::Errno::Fbig,
-            filesystem::ErrorCode::IllegalByteSequence => types::Errno::Ilseq,
-            filesystem::ErrorCode::InProgress => types::Errno::Inprogress,
-            filesystem::ErrorCode::Interrupted => types::Errno::Intr,
-            filesystem::ErrorCode::Invalid => types::Errno::Inval,
-            filesystem::ErrorCode::Io => types::Errno::Io,
-            filesystem::ErrorCode::IsDirectory => types::Errno::Isdir,
-            filesystem::ErrorCode::Loop => types::Errno::Loop,
-            filesystem::ErrorCode::TooManyLinks => types::Errno::Mlink,
-            filesystem::ErrorCode::MessageSize => types::Errno::Msgsize,
-            filesystem::ErrorCode::NameTooLong => types::Errno::Nametoolong,
-            filesystem::ErrorCode::NoDevice => types::Errno::Nodev,
-            filesystem::ErrorCode::NoEntry => types::Errno::Noent,
-            filesystem::ErrorCode::NoLock => types::Errno::Nolck,
-            filesystem::ErrorCode::InsufficientMemory => types::Errno::Nomem,
-            filesystem::ErrorCode::InsufficientSpace => types::Errno::Nospc,
-            filesystem::ErrorCode::Unsupported => types::Errno::Notsup,
-            filesystem::ErrorCode::NotDirectory => types::Errno::Notdir,
-            filesystem::ErrorCode::NotEmpty => types::Errno::Notempty,
-            filesystem::ErrorCode::NotRecoverable => types::Errno::Notrecoverable,
-            filesystem::ErrorCode::NoTty => types::Errno::Notty,
-            filesystem::ErrorCode::NoSuchDevice => types::Errno::Nxio,
-            filesystem::ErrorCode::Overflow => types::Errno::Overflow,
-            filesystem::ErrorCode::NotPermitted => types::Errno::Perm,
-            filesystem::ErrorCode::Pipe => types::Errno::Pipe,
-            filesystem::ErrorCode::ReadOnly => types::Errno::Rofs,
-            filesystem::ErrorCode::InvalidSeek => types::Errno::Spipe,
-            filesystem::ErrorCode::TextFileBusy => types::Errno::Txtbsy,
-            filesystem::ErrorCode::CrossDevice => types::Errno::Xdev,
-        }
-    }
-}
-
-impl From<std::num::TryFromIntError> for types::Error {
-    fn from(_: std::num::TryFromIntError) -> Self {
-        types::Errno::Overflow.into()
-    }
-}
-
-impl From<GuestError> for types::Error {
-    fn from(err: GuestError) -> Self {
-        use wiggle::GuestError::*;
-        match err {
-            InvalidFlagValue { .. } => types::Errno::Inval.into(),
-            InvalidEnumValue { .. } => types::Errno::Inval.into(),
-            // As per
-            // https://github.com/WebAssembly/wasi/blob/main/legacy/tools/witx-docs.md#pointers
-            //
-            // > If a misaligned pointer is passed to a function, the function
-            // > shall trap.
-            // >
-            // > If an out-of-bounds pointer is passed to a function and the
-            // > function needs to dereference it, the function shall trap.
-            //
-            // so this turns OOB and misalignment errors into traps.
-            PtrOverflow { .. } | PtrOutOfBounds { .. } | PtrNotAligned { .. } => {
-                types::Error::trap(err.into())
-            }
-            PtrBorrowed { .. } => types::Errno::Fault.into(),
-            InvalidUtf8 { .. } => types::Errno::Ilseq.into(),
-            TryFromIntError { .. } => types::Errno::Overflow.into(),
-            SliceLengthsDiffer { .. } => types::Errno::Fault.into(),
-            BorrowCheckerOutOfHandles { .. } => types::Errno::Fault.into(),
-            InFunc { err, .. } => types::Error::from(*err),
-        }
-    }
-}
-
-impl From<filesystem::ErrorCode> for types::Error {
-    fn from(code: filesystem::ErrorCode) -> Self {
-        types::Errno::from(code).into()
-    }
-}
-
-impl TryFrom<filesystem::Error> for types::Errno {
-    type Error = anyhow::Error;
-
-    fn try_from(err: filesystem::Error) -> Result<Self, Self::Error> {
-        match err.downcast() {
-            Ok(code) => Ok(code.into()),
-            Err(e) => Err(e),
-        }
-    }
-}
-
-impl TryFrom<filesystem::Error> for types::Error {
-    type Error = anyhow::Error;
-
-    fn try_from(err: filesystem::Error) -> Result<Self, Self::Error> {
-        match err.downcast() {
-            Ok(code) => Ok(code.into()),
-            Err(e) => Err(e),
-        }
-    }
-}
-
-impl From<TableError> for types::Error {
-    fn from(err: TableError) -> Self {
-        types::Error::trap(err.into())
-    }
-}
-
-type Result<T, E = types::Error> = std::result::Result<T, E>;
-
-fn write_bytes<'a>(
-    ptr: impl Borrow<GuestPtr<'a, u8>>,
-    buf: &[u8],
-) -> Result<GuestPtr<'a, u8>, types::Error> {
-    // NOTE: legacy implementation always returns Inval errno
-
-    let buf = buf.as_ref();
-    let len = buf.len().try_into()?;
-
-    let ptr = ptr.borrow();
-    ptr.as_array(len).copy_from_slice(buf)?;
-    let next = ptr.add(len)?;
-    Ok(next)
-}
-
-fn write_byte<'a>(ptr: impl Borrow<GuestPtr<'a, u8>>, byte: u8) -> Result<GuestPtr<'a, u8>> {
-    let ptr = ptr.borrow();
-    ptr.write(byte)?;
-    let next = ptr.add(1)?;
-    Ok(next)
-}
-
-fn read_str<'a>(ptr: impl Borrow<GuestPtr<'a, str>>) -> Result<GuestStrCow<'a>> {
-    let s = ptr.borrow().as_cow()?;
-    Ok(s)
-}
-
-fn read_string<'a>(ptr: impl Borrow<GuestPtr<'a, str>>) -> Result<String> {
-    read_str(ptr).map(|s| s.to_string())
-}
-
-// Find first non-empty buffer.
-fn first_non_empty_ciovec<'a, 'b>(
-    ciovs: &'a types::CiovecArray<'b>,
-) -> Result<Option<GuestSlice<'a, u8>>> {
-    for iov in ciovs.iter() {
-        let iov = iov?.read()?;
-        if iov.buf_len == 0 {
-            continue;
-        }
-        return Ok(iov.buf.as_array(iov.buf_len).as_slice()?);
-    }
-    Ok(None)
-}
-
-// Find first non-empty buffer.
-fn first_non_empty_iovec<'a>(
-    iovs: &types::IovecArray<'a>,
-) -> Result<Option<GuestSliceMut<'a, u8>>> {
-    iovs.iter()
-        .map(|iov| {
-            let iov = iov?.read()?;
-            if iov.buf_len == 0 {
-                return Ok(None);
-            }
-            let slice = iov.buf.as_array(iov.buf_len).as_slice_mut()?;
-            Ok(slice)
-        })
-        .find_map(Result::transpose)
-        .transpose()
-}
-
-#[async_trait::async_trait]
-// Implement the WasiSnapshotPreview1 trait using only the traits that are
-// required for T, i.e., in terms of the preview 2 wit interface, and state
-// stored in the WasiPreview1Adapter struct.
-impl<
-        T: WasiPreview1View
-            + bindings::cli::environment::Host
-            + bindings::cli::exit::Host
-            + bindings::filesystem::preopens::Host
-            + bindings::filesystem::types::Host
-            + bindings::io::poll::Host
-            + bindings::random::random::Host
-            + bindings::io::streams::Host
-            + bindings::clocks::monotonic_clock::Host
-            + bindings::clocks::wall_clock::Host,
-    > wasi_snapshot_preview1::WasiSnapshotPreview1 for T
-{
-    #[instrument(skip(self))]
-    fn args_get<'b>(
-        &mut self,
-        argv: &GuestPtr<'b, GuestPtr<'b, u8>>,
-        argv_buf: &GuestPtr<'b, u8>,
-    ) -> Result<(), types::Error> {
-        self.get_arguments()
-            .context("failed to call `get-arguments`")
-            .map_err(types::Error::trap)?
-            .into_iter()
-            .try_fold((*argv, *argv_buf), |(argv, argv_buf), arg| -> Result<_> {
-                argv.write(argv_buf)?;
-                let argv = argv.add(1)?;
-
-                let argv_buf = write_bytes(argv_buf, arg.as_bytes())?;
-                let argv_buf = write_byte(argv_buf, 0)?;
-
-                Ok((argv, argv_buf))
-            })?;
-        Ok(())
-    }
-
-    #[instrument(skip(self))]
-    fn args_sizes_get(&mut self) -> Result<(types::Size, types::Size), types::Error> {
-        let args = self
-            .get_arguments()
-            .context("failed to call `get-arguments`")
-            .map_err(types::Error::trap)?;
-        let num = args.len().try_into().map_err(|_| types::Errno::Overflow)?;
-        let len = args
-            .iter()
-            .map(|buf| buf.len() + 1) // Each argument is expected to be `\0` terminated.
-            .sum::<usize>()
-            .try_into()
-            .map_err(|_| types::Errno::Overflow)?;
-        Ok((num, len))
-    }
-
-    #[instrument(skip(self))]
-    fn environ_get<'b>(
-        &mut self,
-        environ: &GuestPtr<'b, GuestPtr<'b, u8>>,
-        environ_buf: &GuestPtr<'b, u8>,
-    ) -> Result<(), types::Error> {
-        self.get_environment()
-            .context("failed to call `get-environment`")
-            .map_err(types::Error::trap)?
-            .into_iter()
-            .try_fold(
-                (*environ, *environ_buf),
-                |(environ, environ_buf), (k, v)| -> Result<_, types::Error> {
-                    environ.write(environ_buf)?;
-                    let environ = environ.add(1)?;
-
-                    let environ_buf = write_bytes(environ_buf, k.as_bytes())?;
-                    let environ_buf = write_byte(environ_buf, b'=')?;
-                    let environ_buf = write_bytes(environ_buf, v.as_bytes())?;
-                    let environ_buf = write_byte(environ_buf, 0)?;
-
-                    Ok((environ, environ_buf))
-                },
-            )?;
-        Ok(())
-    }
-
-    #[instrument(skip(self))]
-    fn environ_sizes_get(&mut self) -> Result<(types::Size, types::Size), types::Error> {
-        let environ = self
-            .get_environment()
-            .context("failed to call `get-environment`")
-            .map_err(types::Error::trap)?;
-        let num = environ.len().try_into()?;
-        let len = environ
-            .iter()
-            .map(|(k, v)| k.len() + 1 + v.len() + 1) // Key/value pairs are expected to be joined with `=`s, and terminated with `\0`s.
-            .sum::<usize>()
-            .try_into()?;
-        Ok((num, len))
-    }
-
-    #[instrument(skip(self))]
-    fn clock_res_get(&mut self, id: types::Clockid) -> Result<types::Timestamp, types::Error> {
-        let res = match id {
-            types::Clockid::Realtime => wall_clock::Host::resolution(self)
-                .context("failed to call `wall_clock::resolution`")
-                .map_err(types::Error::trap)?
-                .try_into()?,
-            types::Clockid::Monotonic => monotonic_clock::Host::resolution(self)
-                .context("failed to call `monotonic_clock::resolution`")
-                .map_err(types::Error::trap)?,
-            types::Clockid::ProcessCputimeId | types::Clockid::ThreadCputimeId => {
-                return Err(types::Errno::Badf.into())
-            }
-        };
-        Ok(res)
-    }
-
-    #[instrument(skip(self))]
-    fn clock_time_get(
-        &mut self,
-        id: types::Clockid,
-        _precision: types::Timestamp,
-    ) -> Result<types::Timestamp, types::Error> {
-        let now = match id {
-            types::Clockid::Realtime => wall_clock::Host::now(self)
-                .context("failed to call `wall_clock::now`")
-                .map_err(types::Error::trap)?
-                .try_into()?,
-            types::Clockid::Monotonic => monotonic_clock::Host::now(self)
-                .context("failed to call `monotonic_clock::now`")
-                .map_err(types::Error::trap)?,
-            types::Clockid::ProcessCputimeId | types::Clockid::ThreadCputimeId => {
-                return Err(types::Errno::Badf.into())
-            }
-        };
-        Ok(now)
-    }
-
-    #[instrument(skip(self))]
-    async fn fd_advise(
-        &mut self,
-        fd: types::Fd,
-        offset: types::Filesize,
-        len: types::Filesize,
-        advice: types::Advice,
-    ) -> Result<(), types::Error> {
-        let fd = self.get_file_fd(fd)?;
-        self.advise(fd, offset, len, advice.into())
-            .await
-            .map_err(|e| {
-                e.try_into()
-                    .context("failed to call `advise`")
-                    .unwrap_or_else(types::Error::trap)
-            })
-    }
-
-    /// Force the allocation of space in a file.
-    /// NOTE: This is similar to `posix_fallocate` in POSIX.
-    #[instrument(skip(self))]
-    fn fd_allocate(
-        &mut self,
-        fd: types::Fd,
-        _offset: types::Filesize,
-        _len: types::Filesize,
-    ) -> Result<(), types::Error> {
-        self.get_file_fd(fd)?;
-        Err(types::Errno::Notsup.into())
-    }
-
-    /// Close a file descriptor.
-    /// NOTE: This is similar to `close` in POSIX.
-    #[instrument(skip(self))]
-    async fn fd_close(&mut self, fd: types::Fd) -> Result<(), types::Error> {
-        let desc = self
-            .transact()?
-            .descriptors
-            .remove(fd)
-            .ok_or(types::Errno::Badf)?;
-        match desc {
-            Descriptor::Stdin { stream, .. } => streams::HostInputStream::drop(self, stream)
-                .context("failed to call `drop` on `input-stream`"),
-            Descriptor::Stdout { stream, .. } | Descriptor::Stderr { stream, .. } => {
-                streams::HostOutputStream::drop(self, stream)
-                    .context("failed to call `drop` on `output-stream`")
-            }
-            Descriptor::File(File { fd, .. }) | Descriptor::PreopenDirectory((fd, _)) => {
-                filesystem::HostDescriptor::drop(self, fd).context("failed to call `drop`")
-            }
-        }
-        .map_err(types::Error::trap)
-    }
-
-    /// Synchronize the data of a file to disk.
-    /// NOTE: This is similar to `fdatasync` in POSIX.
-    #[instrument(skip(self))]
-    async fn fd_datasync(&mut self, fd: types::Fd) -> Result<(), types::Error> {
-        let fd = self.get_file_fd(fd)?;
-        self.sync_data(fd).await.map_err(|e| {
-            e.try_into()
-                .context("failed to call `sync-data`")
-                .unwrap_or_else(types::Error::trap)
-        })
-    }
-
-    /// Get the attributes of a file descriptor.
-    /// NOTE: This returns similar flags to `fsync(fd, F_GETFL)` in POSIX, as well as additional fields.
-    #[instrument(skip(self))]
-    async fn fd_fdstat_get(&mut self, fd: types::Fd) -> Result<types::Fdstat, types::Error> {
-        let (fd, blocking, append) = match self.transact()?.get_descriptor(fd)? {
-            Descriptor::Stdin { isatty, .. } => {
-                let fs_rights_base = types::Rights::FD_READ;
-                return Ok(types::Fdstat {
-                    fs_filetype: (*isatty).into(),
-                    fs_flags: types::Fdflags::empty(),
-                    fs_rights_base,
-                    fs_rights_inheriting: fs_rights_base,
-                });
-            }
-            Descriptor::Stdout { isatty, .. } | Descriptor::Stderr { isatty, .. } => {
-                let fs_rights_base = types::Rights::FD_WRITE;
-                return Ok(types::Fdstat {
-                    fs_filetype: (*isatty).into(),
-                    fs_flags: types::Fdflags::empty(),
-                    fs_rights_base,
-                    fs_rights_inheriting: fs_rights_base,
-                });
-            }
-            Descriptor::PreopenDirectory((_, _)) => {
-                // Hard-coded set or rights expected by many userlands:
-                let fs_rights_base = types::Rights::PATH_CREATE_DIRECTORY
-                    | types::Rights::PATH_CREATE_FILE
-                    | types::Rights::PATH_LINK_SOURCE
-                    | types::Rights::PATH_LINK_TARGET
-                    | types::Rights::PATH_OPEN
-                    | types::Rights::FD_READDIR
-                    | types::Rights::PATH_READLINK
-                    | types::Rights::PATH_RENAME_SOURCE
-                    | types::Rights::PATH_RENAME_TARGET
-                    | types::Rights::PATH_SYMLINK
-                    | types::Rights::PATH_REMOVE_DIRECTORY
-                    | types::Rights::PATH_UNLINK_FILE
-                    | types::Rights::PATH_FILESTAT_GET
-                    | types::Rights::PATH_FILESTAT_SET_TIMES
-                    | types::Rights::FD_FILESTAT_GET
-                    | types::Rights::FD_FILESTAT_SET_TIMES;
-
-                let fs_rights_inheriting = fs_rights_base
-                    | types::Rights::FD_DATASYNC
-                    | types::Rights::FD_READ
-                    | types::Rights::FD_SEEK
-                    | types::Rights::FD_FDSTAT_SET_FLAGS
-                    | types::Rights::FD_SYNC
-                    | types::Rights::FD_TELL
-                    | types::Rights::FD_WRITE
-                    | types::Rights::FD_ADVISE
-                    | types::Rights::FD_ALLOCATE
-                    | types::Rights::FD_FILESTAT_GET
-                    | types::Rights::FD_FILESTAT_SET_SIZE
-                    | types::Rights::FD_FILESTAT_SET_TIMES
-                    | types::Rights::POLL_FD_READWRITE;
-
-                return Ok(types::Fdstat {
-                    fs_filetype: types::Filetype::Directory,
-                    fs_flags: types::Fdflags::empty(),
-                    fs_rights_base,
-                    fs_rights_inheriting,
-                });
-            }
-            Descriptor::File(File {
-                fd,
-                blocking_mode,
-                append,
-                ..
-            }) => (fd.borrowed(), *blocking_mode, *append),
-        };
-        let flags = self.get_flags(fd.borrowed()).await.map_err(|e| {
-            e.try_into()
-                .context("failed to call `get-flags`")
-                .unwrap_or_else(types::Error::trap)
-        })?;
-        let fs_filetype = self
-            .get_type(fd.borrowed())
-            .await
-            .map_err(|e| {
-                e.try_into()
-                    .context("failed to call `get-type`")
-                    .unwrap_or_else(types::Error::trap)
-            })?
-            .try_into()
-            .map_err(types::Error::trap)?;
-        let mut fs_flags = types::Fdflags::empty();
-        let mut fs_rights_base = types::Rights::all();
-        if !flags.contains(filesystem::DescriptorFlags::READ) {
-            fs_rights_base &= !types::Rights::FD_READ;
-        }
-        if !flags.contains(filesystem::DescriptorFlags::WRITE) {
-            fs_rights_base &= !types::Rights::FD_WRITE;
-        }
-        if flags.contains(filesystem::DescriptorFlags::DATA_INTEGRITY_SYNC) {
-            fs_flags |= types::Fdflags::DSYNC;
-        }
-        if flags.contains(filesystem::DescriptorFlags::REQUESTED_WRITE_SYNC) {
-            fs_flags |= types::Fdflags::RSYNC;
-        }
-        if flags.contains(filesystem::DescriptorFlags::FILE_INTEGRITY_SYNC) {
-            fs_flags |= types::Fdflags::SYNC;
-        }
-        if append {
-            fs_flags |= types::Fdflags::APPEND;
-        }
-        if matches!(blocking, BlockingMode::NonBlocking) {
-            fs_flags |= types::Fdflags::NONBLOCK;
-        }
-        Ok(types::Fdstat {
-            fs_filetype,
-            fs_flags,
-            fs_rights_base,
-            fs_rights_inheriting: fs_rights_base,
-        })
-    }
-
-    /// Adjust the flags associated with a file descriptor.
-    /// NOTE: This is similar to `fcntl(fd, F_SETFL, flags)` in POSIX.
-    #[instrument(skip(self))]
-    fn fd_fdstat_set_flags(
-        &mut self,
-        fd: types::Fd,
-        flags: types::Fdflags,
-    ) -> Result<(), types::Error> {
-        let mut st = self.transact()?;
-        let File {
-            append,
-            blocking_mode,
-            ..
-        } = st.get_file_mut(fd)?;
-
-        // Only support changing the NONBLOCK or APPEND flags.
-        if flags.contains(types::Fdflags::DSYNC)
-            || flags.contains(types::Fdflags::SYNC)
-            || flags.contains(types::Fdflags::RSYNC)
-        {
-            return Err(types::Errno::Inval.into());
-        }
-        *append = flags.contains(types::Fdflags::APPEND);
-        *blocking_mode = BlockingMode::from_fdflags(&flags);
-        Ok(())
-    }
-
-    /// Does not do anything if `fd` corresponds to a valid descriptor and returns `[types::Errno::Badf]` error otherwise.
-    #[instrument(skip(self))]
-    fn fd_fdstat_set_rights(
-        &mut self,
-        fd: types::Fd,
-        _fs_rights_base: types::Rights,
-        _fs_rights_inheriting: types::Rights,
-    ) -> Result<(), types::Error> {
-        self.get_fd(fd)?;
-        Ok(())
-    }
-
-    /// Return the attributes of an open file.
-    #[instrument(skip(self))]
-    async fn fd_filestat_get(&mut self, fd: types::Fd) -> Result<types::Filestat, types::Error> {
-        let t = self.transact()?;
-        let desc = t.get_descriptor(fd)?;
-        match desc {
-            Descriptor::Stdin { isatty, .. }
-            | Descriptor::Stdout { isatty, .. }
-            | Descriptor::Stderr { isatty, .. } => Ok(types::Filestat {
-                dev: 0,
-                ino: 0,
-                filetype: (*isatty).into(),
-                nlink: 0,
-                size: 0,
-                atim: 0,
-                mtim: 0,
-                ctim: 0,
-            }),
-            Descriptor::PreopenDirectory((fd, _)) | Descriptor::File(File { fd, .. }) => {
-                let fd = fd.borrowed();
-                drop(t);
-                let filesystem::DescriptorStat {
-                    type_,
-                    link_count: nlink,
-                    size,
-                    data_access_timestamp,
-                    data_modification_timestamp,
-                    status_change_timestamp,
-                } = self.stat(fd.borrowed()).await.map_err(|e| {
-                    e.try_into()
-                        .context("failed to call `stat`")
-                        .unwrap_or_else(types::Error::trap)
-                })?;
-                let metadata_hash = self.metadata_hash(fd).await.map_err(|e| {
-                    e.try_into()
-                        .context("failed to call `metadata_hash`")
-                        .unwrap_or_else(types::Error::trap)
-                })?;
-                let filetype = type_.try_into().map_err(types::Error::trap)?;
-                let zero = wall_clock::Datetime {
-                    seconds: 0,
-                    nanoseconds: 0,
-                };
-                let atim = data_access_timestamp.unwrap_or(zero).try_into()?;
-                let mtim = data_modification_timestamp.unwrap_or(zero).try_into()?;
-                let ctim = status_change_timestamp.unwrap_or(zero).try_into()?;
-                Ok(types::Filestat {
-                    dev: 1,
-                    ino: metadata_hash.lower,
-                    filetype,
-                    nlink,
-                    size,
-                    atim,
-                    mtim,
-                    ctim,
-                })
-            }
-        }
-    }
-
-    /// Adjust the size of an open file. If this increases the file's size, the extra bytes are filled with zeros.
-    /// NOTE: This is similar to `ftruncate` in POSIX.
-    #[instrument(skip(self))]
-    async fn fd_filestat_set_size(
-        &mut self,
-        fd: types::Fd,
-        size: types::Filesize,
-    ) -> Result<(), types::Error> {
-        let fd = self.get_file_fd(fd)?;
-        self.set_size(fd, size).await.map_err(|e| {
-            e.try_into()
-                .context("failed to call `set-size`")
-                .unwrap_or_else(types::Error::trap)
-        })
-    }
-
-    /// Adjust the timestamps of an open file or directory.
-    /// NOTE: This is similar to `futimens` in POSIX.
-    #[instrument(skip(self))]
-    async fn fd_filestat_set_times(
-        &mut self,
-        fd: types::Fd,
-        atim: types::Timestamp,
-        mtim: types::Timestamp,
-        fst_flags: types::Fstflags,
-    ) -> Result<(), types::Error> {
-        let atim = systimespec(
-            fst_flags.contains(types::Fstflags::ATIM),
-            atim,
-            fst_flags.contains(types::Fstflags::ATIM_NOW),
-        )?;
-        let mtim = systimespec(
-            fst_flags.contains(types::Fstflags::MTIM),
-            mtim,
-            fst_flags.contains(types::Fstflags::MTIM_NOW),
-        )?;
-
-        let fd = self.get_fd(fd)?;
-        self.set_times(fd, atim, mtim).await.map_err(|e| {
-            e.try_into()
-                .context("failed to call `set-times`")
-                .unwrap_or_else(types::Error::trap)
-        })
-    }
-
-    /// Read from a file descriptor.
-    /// NOTE: This is similar to `readv` in POSIX.
-    #[instrument(skip(self))]
-    async fn fd_read<'a>(
-        &mut self,
-        fd: types::Fd,
-        iovs: &types::IovecArray<'a>,
-    ) -> Result<types::Size, types::Error> {
-        let t = self.transact()?;
-        let desc = t.get_descriptor(fd)?;
-        let (mut buf, read) = match desc {
-            Descriptor::File(File {
-                fd,
-                blocking_mode,
-                position,
-                ..
-            }) if t.view.table().get_resource(fd)?.is_file() => {
-                let fd = fd.borrowed();
-                let blocking_mode = *blocking_mode;
-                let position = position.clone();
-                drop(t);
-                let Some(buf) = first_non_empty_iovec(iovs)? else {
-                    return Ok(0);
-                };
-
-                let pos = position.load(Ordering::Relaxed);
-                let stream = self.read_via_stream(fd.borrowed(), pos).map_err(|e| {
-                    e.try_into()
-                        .context("failed to call `read-via-stream`")
-                        .unwrap_or_else(types::Error::trap)
-                })?;
-                let read = blocking_mode.read(self, stream, buf.len()).await?;
-                let n = read.len().try_into()?;
-                let pos = pos.checked_add(n).ok_or(types::Errno::Overflow)?;
-                position.store(pos, Ordering::Relaxed);
-
-                (buf, read)
-            }
-            Descriptor::Stdin { stream, .. } => {
-                let stream = stream.borrowed();
-                drop(t);
-                let Some(buf) = first_non_empty_iovec(iovs)? else {
-                    return Ok(0);
-                };
-                let read = BlockingMode::Blocking.read(self, stream, buf.len()).await?;
-                (buf, read)
-            }
-            _ => return Err(types::Errno::Badf.into()),
-        };
-        if read.len() > buf.len() {
-            return Err(types::Errno::Range.into());
-        }
-        let (buf, _) = buf.split_at_mut(read.len());
-        buf.copy_from_slice(&read);
-        let n = read.len().try_into()?;
-        Ok(n)
-    }
-
-    /// Read from a file descriptor, without using and updating the file descriptor's offset.
-    /// NOTE: This is similar to `preadv` in POSIX.
-    #[instrument(skip(self))]
-    async fn fd_pread<'a>(
-        &mut self,
-        fd: types::Fd,
-        iovs: &types::IovecArray<'a>,
-        offset: types::Filesize,
-    ) -> Result<types::Size, types::Error> {
-        let t = self.transact()?;
-        let desc = t.get_descriptor(fd)?;
-        let (mut buf, read) = match desc {
-            Descriptor::File(File {
-                fd, blocking_mode, ..
-            }) if t.view.table().get_resource(fd)?.is_file() => {
-                let fd = fd.borrowed();
-                let blocking_mode = *blocking_mode;
-                drop(t);
-                let Some(buf) = first_non_empty_iovec(iovs)? else {
-                    return Ok(0);
-                };
-
-                let stream = self.read_via_stream(fd, offset).map_err(|e| {
-                    e.try_into()
-                        .context("failed to call `read-via-stream`")
-                        .unwrap_or_else(types::Error::trap)
-                })?;
-                let read = blocking_mode.read(self, stream, buf.len()).await?;
-                (buf, read)
-            }
-            Descriptor::Stdin { .. } => {
-                // NOTE: legacy implementation returns SPIPE here
-                return Err(types::Errno::Spipe.into());
-            }
-            _ => return Err(types::Errno::Badf.into()),
-        };
-        if read.len() > buf.len() {
-            return Err(types::Errno::Range.into());
-        }
-        let (buf, _) = buf.split_at_mut(read.len());
-        buf.copy_from_slice(&read);
-        let n = read.len().try_into()?;
-        Ok(n)
-    }
-
-    /// Write to a file descriptor.
-    /// NOTE: This is similar to `writev` in POSIX.
-    #[instrument(skip(self))]
-    async fn fd_write<'a>(
-        &mut self,
-        fd: types::Fd,
-        ciovs: &types::CiovecArray<'a>,
-    ) -> Result<types::Size, types::Error> {
-        let t = self.transact()?;
-        let desc = t.get_descriptor(fd)?;
-        match desc {
-            Descriptor::File(File {
-                fd,
-                blocking_mode,
-                append,
-                position,
-            }) if t.view.table().get_resource(fd)?.is_file() => {
-                let fd = fd.borrowed();
-                let blocking_mode = *blocking_mode;
-                let position = position.clone();
-                let append = *append;
-                drop(t);
-                let Some(buf) = first_non_empty_ciovec(ciovs)? else {
-                    return Ok(0);
-                };
-                let (stream, pos) = if append {
-                    let stream = self.append_via_stream(fd).map_err(|e| {
-                        e.try_into()
-                            .context("failed to call `append-via-stream`")
-                            .unwrap_or_else(types::Error::trap)
-                    })?;
-                    (stream, 0)
-                } else {
-                    let pos = position.load(Ordering::Relaxed);
-                    let stream = self.write_via_stream(fd, pos).map_err(|e| {
-                        e.try_into()
-                            .context("failed to call `write-via-stream`")
-                            .unwrap_or_else(types::Error::trap)
-                    })?;
-                    (stream, pos)
-                };
-                let n = blocking_mode.write(self, stream, &buf).await?;
-                if !append {
-                    let pos = pos.checked_add(n as u64).ok_or(types::Errno::Overflow)?;
-                    position.store(pos, Ordering::Relaxed);
-                }
-                let n = n.try_into()?;
-                Ok(n)
-            }
-            Descriptor::Stdout { stream, .. } | Descriptor::Stderr { stream, .. } => {
-                let stream = stream.borrowed();
-                drop(t);
-                let Some(buf) = first_non_empty_ciovec(ciovs)? else {
-                    return Ok(0);
-                };
-                let n = BlockingMode::Blocking
-                    .write(self, stream, &buf)
-                    .await?
-                    .try_into()?;
-                Ok(n)
-            }
-            _ => Err(types::Errno::Badf.into()),
-        }
-    }
-
-    /// Write to a file descriptor, without using and updating the file descriptor's offset.
-    /// NOTE: This is similar to `pwritev` in POSIX.
-    #[instrument(skip(self))]
-    async fn fd_pwrite<'a>(
-        &mut self,
-        fd: types::Fd,
-        ciovs: &types::CiovecArray<'a>,
-        offset: types::Filesize,
-    ) -> Result<types::Size, types::Error> {
-        let t = self.transact()?;
-        let desc = t.get_descriptor(fd)?;
-        let n = match desc {
-            Descriptor::File(File {
-                fd, blocking_mode, ..
-            }) if t.view.table().get_resource(fd)?.is_file() => {
-                let fd = fd.borrowed();
-                let blocking_mode = *blocking_mode;
-                drop(t);
-                let Some(buf) = first_non_empty_ciovec(ciovs)? else {
-                    return Ok(0);
-                };
-                let stream = self.write_via_stream(fd, offset).map_err(|e| {
-                    e.try_into()
-                        .context("failed to call `write-via-stream`")
-                        .unwrap_or_else(types::Error::trap)
-                })?;
-                blocking_mode.write(self, stream, &buf).await?
-            }
-            Descriptor::Stdout { .. } | Descriptor::Stderr { .. } => {
-                // NOTE: legacy implementation returns SPIPE here
-                return Err(types::Errno::Spipe.into());
-            }
-            _ => return Err(types::Errno::Badf.into()),
-        };
-        Ok(n.try_into()?)
-    }
-
-    /// Return a description of the given preopened file descriptor.
-    #[instrument(skip(self))]
-    fn fd_prestat_get(&mut self, fd: types::Fd) -> Result<types::Prestat, types::Error> {
-        if let Descriptor::PreopenDirectory((_, p)) = self.transact()?.get_descriptor(fd)? {
-            let pr_name_len = p.len().try_into()?;
-            return Ok(types::Prestat::Dir(types::PrestatDir { pr_name_len }));
-        }
-        Err(types::Errno::Badf.into()) // NOTE: legacy implementation returns BADF here
-    }
-
-    /// Return a description of the given preopened file descriptor.
-    #[instrument(skip(self))]
-    fn fd_prestat_dir_name<'a>(
-        &mut self,
-        fd: types::Fd,
-        path: &GuestPtr<'a, u8>,
-        path_max_len: types::Size,
-    ) -> Result<(), types::Error> {
-        let path_max_len = path_max_len.try_into()?;
-        if let Descriptor::PreopenDirectory((_, p)) = self.transact()?.get_descriptor(fd)? {
-            if p.len() > path_max_len {
-                return Err(types::Errno::Nametoolong.into());
-            }
-            write_bytes(path, p.as_bytes())?;
-            return Ok(());
-        }
-        Err(types::Errno::Notdir.into()) // NOTE: legacy implementation returns NOTDIR here
-    }
-
-    /// Atomically replace a file descriptor by renumbering another file descriptor.
-    #[instrument(skip(self))]
-    fn fd_renumber(&mut self, from: types::Fd, to: types::Fd) -> Result<(), types::Error> {
-        let mut st = self.transact()?;
-        let desc = st.descriptors.remove(from).ok_or(types::Errno::Badf)?;
-        st.descriptors.insert(to.into(), desc);
-        Ok(())
-    }
-
-    /// Move the offset of a file descriptor.
-    /// NOTE: This is similar to `lseek` in POSIX.
-    #[instrument(skip(self))]
-    async fn fd_seek(
-        &mut self,
-        fd: types::Fd,
-        offset: types::Filedelta,
-        whence: types::Whence,
-    ) -> Result<types::Filesize, types::Error> {
-        let t = self.transact()?;
-        let File { fd, position, .. } = t.get_seekable(fd)?;
-        let fd = fd.borrowed();
-        let position = position.clone();
-        drop(t);
-        let pos = match whence {
-            types::Whence::Set if offset >= 0 => offset as _,
-            types::Whence::Cur => position
-                .load(Ordering::Relaxed)
-                .checked_add_signed(offset)
-                .ok_or(types::Errno::Inval)?,
-            types::Whence::End => {
-                let filesystem::DescriptorStat { size, .. } = self.stat(fd).await.map_err(|e| {
-                    e.try_into()
-                        .context("failed to call `stat`")
-                        .unwrap_or_else(types::Error::trap)
-                })?;
-                size.checked_add_signed(offset).ok_or(types::Errno::Inval)?
-            }
-            _ => return Err(types::Errno::Inval.into()),
-        };
-        position.store(pos, Ordering::Relaxed);
-        Ok(pos)
-    }
-
-    /// Synchronize the data and metadata of a file to disk.
-    /// NOTE: This is similar to `fsync` in POSIX.
-    #[instrument(skip(self))]
-    async fn fd_sync(&mut self, fd: types::Fd) -> Result<(), types::Error> {
-        let fd = self.get_file_fd(fd)?;
-        self.sync(fd).await.map_err(|e| {
-            e.try_into()
-                .context("failed to call `sync`")
-                .unwrap_or_else(types::Error::trap)
-        })
-    }
-
-    /// Return the current offset of a file descriptor.
-    /// NOTE: This is similar to `lseek(fd, 0, SEEK_CUR)` in POSIX.
-    #[instrument(skip(self))]
-    fn fd_tell(&mut self, fd: types::Fd) -> Result<types::Filesize, types::Error> {
-        let pos = self
-            .transact()?
-            .get_seekable(fd)
-            .map(|File { position, .. }| position.load(Ordering::Relaxed))?;
-        Ok(pos)
-    }
-
-    #[instrument(skip(self))]
-    async fn fd_readdir<'a>(
-        &mut self,
-        fd: types::Fd,
-        buf: &GuestPtr<'a, u8>,
-        buf_len: types::Size,
-        cookie: types::Dircookie,
-    ) -> Result<types::Size, types::Error> {
-        let fd = self.get_dir_fd(fd)?;
-        let stream = self.read_directory(fd.borrowed()).await.map_err(|e| {
-            e.try_into()
-                .context("failed to call `read-directory`")
-                .unwrap_or_else(types::Error::trap)
-        })?;
-        let dir_metadata_hash = self.metadata_hash(fd.borrowed()).await.map_err(|e| {
-            e.try_into()
-                .context("failed to call `metadata-hash`")
-                .unwrap_or_else(types::Error::trap)
-        })?;
-        let cookie = cookie.try_into().map_err(|_| types::Errno::Overflow)?;
-
-        let head = [
-            (
-                types::Dirent {
-                    d_next: 1u64.to_le(),
-                    d_ino: dir_metadata_hash.lower.to_le(),
-                    d_type: types::Filetype::Directory,
-                    d_namlen: 1u32.to_le(),
-                },
-                ".".into(),
-            ),
-            (
-                types::Dirent {
-                    d_next: 2u64.to_le(),
-                    d_ino: dir_metadata_hash.lower.to_le(), // NOTE: incorrect, but legacy implementation returns `fd` inode here
-                    d_type: types::Filetype::Directory,
-                    d_namlen: 2u32.to_le(),
-                },
-                "..".into(),
-            ),
-        ];
-
-        let mut dir = Vec::new();
-        for (entry, d_next) in self
-            .table_mut()
-            // remove iterator from table and use it directly:
-            .delete_resource(stream)?
-            .into_iter()
-            .zip(3u64..)
-        {
-            let filesystem::DirectoryEntry { type_, name } = entry.map_err(|e| {
-                e.try_into()
-                    .context("failed to inspect `read-directory` entry")
-                    .unwrap_or_else(types::Error::trap)
-            })?;
-            let metadata_hash = self
-                .metadata_hash_at(fd.borrowed(), filesystem::PathFlags::empty(), name.clone())
-                .await
-                .map_err(|e| {
-                    e.try_into()
-                        .context("failed to call `metadata-hash-at`")
-                        .unwrap_or_else(types::Error::trap)
-                })?;
-            let d_type = type_.try_into().map_err(types::Error::trap)?;
-            let d_namlen: u32 = name.len().try_into().map_err(|_| types::Errno::Overflow)?;
-            dir.push((
-                types::Dirent {
-                    d_next: d_next.to_le(),
-                    d_ino: metadata_hash.lower.to_le(),
-                    d_type, // endian-invariant
-                    d_namlen: d_namlen.to_le(),
-                },
-                name,
-            ))
-        }
-
-        // assume that `types::Dirent` size always fits in `u32`
-        const DIRENT_SIZE: u32 = size_of::<types::Dirent>() as _;
-        assert_eq!(
-            types::Dirent::guest_size(),
-            DIRENT_SIZE,
-            "Dirent guest repr and host repr should match"
-        );
-        let mut buf = *buf;
-        let mut cap = buf_len;
-        for (ref entry, path) in head.into_iter().chain(dir.into_iter()).skip(cookie) {
-            let mut path = path.into_bytes();
-            assert_eq!(
-                1,
-                size_of_val(&entry.d_type),
-                "Dirent member d_type should be endian-invariant"
-            );
-            let entry_len = cap.min(DIRENT_SIZE);
-            let entry = entry as *const _ as _;
-            let entry = unsafe { slice::from_raw_parts(entry, entry_len as _) };
-            cap = cap.checked_sub(entry_len).unwrap();
-            buf = write_bytes(buf, entry)?;
-            if cap == 0 {
-                return Ok(buf_len);
-            }
-
-            if let Ok(cap) = cap.try_into() {
-                // `path` cannot be longer than `usize`, only truncate if `cap` fits in `usize`
-                path.truncate(cap);
-            }
-            cap = cap.checked_sub(path.len() as _).unwrap();
-            buf = write_bytes(buf, &path)?;
-            if cap == 0 {
-                return Ok(buf_len);
-            }
-        }
-        Ok(buf_len.checked_sub(cap).unwrap())
-    }
-
-    #[instrument(skip(self))]
-    async fn path_create_directory<'a>(
-        &mut self,
-        dirfd: types::Fd,
-        path: &GuestPtr<'a, str>,
-    ) -> Result<(), types::Error> {
-        let dirfd = self.get_dir_fd(dirfd)?;
-        let path = read_string(path)?;
-        self.create_directory_at(dirfd.borrowed(), path)
-            .await
-            .map_err(|e| {
-                e.try_into()
-                    .context("failed to call `create-directory-at`")
-                    .unwrap_or_else(types::Error::trap)
-            })
-    }
-
-    /// Return the attributes of a file or directory.
-    /// NOTE: This is similar to `stat` in POSIX.
-    #[instrument(skip(self))]
-    async fn path_filestat_get<'a>(
-        &mut self,
-        dirfd: types::Fd,
-        flags: types::Lookupflags,
-        path: &GuestPtr<'a, str>,
-    ) -> Result<types::Filestat, types::Error> {
-        let dirfd = self.get_dir_fd(dirfd)?;
-        let path = read_string(path)?;
-        let filesystem::DescriptorStat {
-            type_,
-            link_count: nlink,
-            size,
-            data_access_timestamp,
-            data_modification_timestamp,
-            status_change_timestamp,
-        } = self
-            .stat_at(dirfd.borrowed(), flags.into(), path.clone())
-            .await
-            .map_err(|e| {
-                e.try_into()
-                    .context("failed to call `stat-at`")
-                    .unwrap_or_else(types::Error::trap)
-            })?;
-        let metadata_hash = self
-            .metadata_hash_at(dirfd, flags.into(), path)
-            .await
-            .map_err(|e| {
-                e.try_into()
-                    .context("failed to call `metadata-hash-at`")
-                    .unwrap_or_else(types::Error::trap)
-            })?;
-        let filetype = type_.try_into().map_err(types::Error::trap)?;
-        let zero = wall_clock::Datetime {
-            seconds: 0,
-            nanoseconds: 0,
-        };
-        let atim = data_access_timestamp.unwrap_or(zero).try_into()?;
-        let mtim = data_modification_timestamp.unwrap_or(zero).try_into()?;
-        let ctim = status_change_timestamp.unwrap_or(zero).try_into()?;
-        Ok(types::Filestat {
-            dev: 1,
-            ino: metadata_hash.lower,
-            filetype,
-            nlink,
-            size,
-            atim,
-            mtim,
-            ctim,
-        })
-    }
-
-    /// Adjust the timestamps of a file or directory.
-    /// NOTE: This is similar to `utimensat` in POSIX.
-    #[instrument(skip(self))]
-    async fn path_filestat_set_times<'a>(
-        &mut self,
-        dirfd: types::Fd,
-        flags: types::Lookupflags,
-        path: &GuestPtr<'a, str>,
-        atim: types::Timestamp,
-        mtim: types::Timestamp,
-        fst_flags: types::Fstflags,
-    ) -> Result<(), types::Error> {
-        let atim = systimespec(
-            fst_flags.contains(types::Fstflags::ATIM),
-            atim,
-            fst_flags.contains(types::Fstflags::ATIM_NOW),
-        )?;
-        let mtim = systimespec(
-            fst_flags.contains(types::Fstflags::MTIM),
-            mtim,
-            fst_flags.contains(types::Fstflags::MTIM_NOW),
-        )?;
-
-        let dirfd = self.get_dir_fd(dirfd)?;
-        let path = read_string(path)?;
-        self.set_times_at(dirfd, flags.into(), path, atim, mtim)
-            .await
-            .map_err(|e| {
-                e.try_into()
-                    .context("failed to call `set-times-at`")
-                    .unwrap_or_else(types::Error::trap)
-            })
-    }
-
-    /// Create a hard link.
-    /// NOTE: This is similar to `linkat` in POSIX.
-    #[instrument(skip(self))]
-    async fn path_link<'a>(
-        &mut self,
-        src_fd: types::Fd,
-        src_flags: types::Lookupflags,
-        src_path: &GuestPtr<'a, str>,
-        target_fd: types::Fd,
-        target_path: &GuestPtr<'a, str>,
-    ) -> Result<(), types::Error> {
-        let src_fd = self.get_dir_fd(src_fd)?;
-        let target_fd = self.get_dir_fd(target_fd)?;
-        let src_path = read_string(src_path)?;
-        let target_path = read_string(target_path)?;
-        self.link_at(src_fd, src_flags.into(), src_path, target_fd, target_path)
-            .await
-            .map_err(|e| {
-                e.try_into()
-                    .context("failed to call `link-at`")
-                    .unwrap_or_else(types::Error::trap)
-            })
-    }
-
-    /// Open a file or directory.
-    /// NOTE: This is similar to `openat` in POSIX.
-    #[instrument(skip(self))]
-    async fn path_open<'a>(
-        &mut self,
-        dirfd: types::Fd,
-        dirflags: types::Lookupflags,
-        path: &GuestPtr<'a, str>,
-        oflags: types::Oflags,
-        fs_rights_base: types::Rights,
-        _fs_rights_inheriting: types::Rights,
-        fdflags: types::Fdflags,
-    ) -> Result<types::Fd, types::Error> {
-        let path = read_string(path)?;
-
-        let mut flags = filesystem::DescriptorFlags::empty();
-        if fs_rights_base.contains(types::Rights::FD_READ) {
-            flags |= filesystem::DescriptorFlags::READ;
-        }
-        if fs_rights_base.contains(types::Rights::FD_WRITE) {
-            flags |= filesystem::DescriptorFlags::WRITE;
-        }
-        if fdflags.contains(types::Fdflags::SYNC) {
-            flags |= filesystem::DescriptorFlags::FILE_INTEGRITY_SYNC;
-        }
-        if fdflags.contains(types::Fdflags::DSYNC) {
-            flags |= filesystem::DescriptorFlags::DATA_INTEGRITY_SYNC;
-        }
-        if fdflags.contains(types::Fdflags::RSYNC) {
-            flags |= filesystem::DescriptorFlags::REQUESTED_WRITE_SYNC;
-        }
-
-        let t = self.transact()?;
-        let dirfd = match t.get_descriptor(dirfd)? {
-            Descriptor::PreopenDirectory((fd, _)) => fd.borrowed(),
-            Descriptor::File(File { fd, .. }) => {
-                t.view.table().get_resource(fd)?.dir()?;
-                fd.borrowed()
-            }
-            _ => return Err(types::Errno::Badf.into()),
-        };
-        drop(t);
-        let fd = self
-            .open_at(
-                dirfd,
-                dirflags.into(),
-                path,
-                oflags.into(),
-                flags,
-                filesystem::Modes::READABLE | filesystem::Modes::WRITABLE,
-            )
-            .await
-            .map_err(|e| {
-                e.try_into()
-                    .context("failed to call `open-at`")
-                    .unwrap_or_else(types::Error::trap)
-            })?;
-        let fd = self.transact()?.descriptors.push_file(File {
-            fd,
-            position: Default::default(),
-            append: fdflags.contains(types::Fdflags::APPEND),
-            blocking_mode: BlockingMode::from_fdflags(&fdflags),
-        })?;
-        Ok(fd.into())
-    }
-
-    /// Read the contents of a symbolic link.
-    /// NOTE: This is similar to `readlinkat` in POSIX.
-    #[instrument(skip(self))]
-    async fn path_readlink<'a>(
-        &mut self,
-        dirfd: types::Fd,
-        path: &GuestPtr<'a, str>,
-        buf: &GuestPtr<'a, u8>,
-        buf_len: types::Size,
-    ) -> Result<types::Size, types::Error> {
-        let dirfd = self.get_dir_fd(dirfd)?;
-        let path = read_string(path)?;
-        let mut path = self
-            .readlink_at(dirfd, path)
-            .await
-            .map_err(|e| {
-                e.try_into()
-                    .context("failed to call `readlink-at`")
-                    .unwrap_or_else(types::Error::trap)
-            })?
-            .into_bytes();
-        if let Ok(buf_len) = buf_len.try_into() {
-            // `path` cannot be longer than `usize`, only truncate if `buf_len` fits in `usize`
-            path.truncate(buf_len);
-        }
-        let n = path.len().try_into().map_err(|_| types::Errno::Overflow)?;
-        write_bytes(buf, &path)?;
-        Ok(n)
-    }
-
-    #[instrument(skip(self))]
-    async fn path_remove_directory<'a>(
-        &mut self,
-        dirfd: types::Fd,
-        path: &GuestPtr<'a, str>,
-    ) -> Result<(), types::Error> {
-        let dirfd = self.get_dir_fd(dirfd)?;
-        let path = read_string(path)?;
-        self.remove_directory_at(dirfd, path).await.map_err(|e| {
-            e.try_into()
-                .context("failed to call `remove-directory-at`")
-                .unwrap_or_else(types::Error::trap)
-        })
-    }
-
-    /// Rename a file or directory.
-    /// NOTE: This is similar to `renameat` in POSIX.
-    #[instrument(skip(self))]
-    async fn path_rename<'a>(
-        &mut self,
-        src_fd: types::Fd,
-        src_path: &GuestPtr<'a, str>,
-        dest_fd: types::Fd,
-        dest_path: &GuestPtr<'a, str>,
-    ) -> Result<(), types::Error> {
-        let src_fd = self.get_dir_fd(src_fd)?;
-        let dest_fd = self.get_dir_fd(dest_fd)?;
-        let src_path = read_string(src_path)?;
-        let dest_path = read_string(dest_path)?;
-        self.rename_at(src_fd, src_path, dest_fd, dest_path)
-            .await
-            .map_err(|e| {
-                e.try_into()
-                    .context("failed to call `rename-at`")
-                    .unwrap_or_else(types::Error::trap)
-            })
-    }
-
-    #[instrument(skip(self))]
-    async fn path_symlink<'a>(
-        &mut self,
-        src_path: &GuestPtr<'a, str>,
-        dirfd: types::Fd,
-        dest_path: &GuestPtr<'a, str>,
-    ) -> Result<(), types::Error> {
-        let dirfd = self.get_dir_fd(dirfd)?;
-        let src_path = read_string(src_path)?;
-        let dest_path = read_string(dest_path)?;
-        self.symlink_at(dirfd.borrowed(), src_path, dest_path)
-            .await
-            .map_err(|e| {
-                e.try_into()
-                    .context("failed to call `symlink-at`")
-                    .unwrap_or_else(types::Error::trap)
-            })
-    }
-
-    #[instrument(skip(self))]
-    async fn path_unlink_file<'a>(
-        &mut self,
-        dirfd: types::Fd,
-        path: &GuestPtr<'a, str>,
-    ) -> Result<(), types::Error> {
-        let dirfd = self.get_dir_fd(dirfd)?;
-        let path = path.as_cow()?.to_string();
-        self.unlink_file_at(dirfd.borrowed(), path)
-            .await
-            .map_err(|e| {
-                e.try_into()
-                    .context("failed to call `unlink-file-at`")
-                    .unwrap_or_else(types::Error::trap)
-            })
-    }
-
-    #[instrument(skip(self))]
-    async fn poll_oneoff<'a>(
-        &mut self,
-        subs: &GuestPtr<'a, types::Subscription>,
-        events: &GuestPtr<'a, types::Event>,
-        nsubscriptions: types::Size,
-    ) -> Result<types::Size, types::Error> {
-        if nsubscriptions == 0 {
-            // Indefinite sleeping is not supported in preview1.
-            return Err(types::Errno::Inval.into());
-        }
-        let subs = subs.as_array(nsubscriptions);
-        let events = events.as_array(nsubscriptions);
-
-        let n = usize::try_from(nsubscriptions).unwrap_or(usize::MAX);
-        let mut pollables = Vec::with_capacity(n);
-        for sub in subs.iter() {
-            let sub = sub?.read()?;
-            let p = match sub.u {
-                types::SubscriptionU::Clock(types::SubscriptionClock {
-                    id,
-                    timeout,
-                    flags,
-                    ..
-                }) => {
-                    let absolute = flags.contains(types::Subclockflags::SUBSCRIPTION_CLOCK_ABSTIME);
-                    let (timeout, absolute) = match id {
-                        types::Clockid::Monotonic => (timeout, absolute),
-                        types::Clockid::Realtime if !absolute => (timeout, false),
-                        types::Clockid::Realtime => {
-                            let now = wall_clock::Host::now(self)
-                                .context("failed to call `wall_clock::now`")
-                                .map_err(types::Error::trap)?;
-
-                            // Convert `timeout` to `Datetime` format.
-                            let seconds = timeout / 1_000_000_000;
-                            let nanoseconds = timeout % 1_000_000_000;
-
-                            let timeout = if now.seconds < seconds
-                                || now.seconds == seconds
-                                    && u64::from(now.nanoseconds) < nanoseconds
-                            {
-                                // `now` is less than `timeout`, which is expressable as u64,
-                                // substract the nanosecond counts directly
-                                now.seconds * 1_000_000_000 + u64::from(now.nanoseconds) - timeout
-                            } else {
-                                0
-                            };
-                            (timeout, false)
-                        }
-                        _ => return Err(types::Errno::Inval.into()),
-                    };
-                    monotonic_clock::Host::subscribe(self, timeout, absolute)
-                        .context("failed to call `monotonic_clock::subscribe`")
-                        .map_err(types::Error::trap)?
-                }
-                types::SubscriptionU::FdRead(types::SubscriptionFdReadwrite {
-                    file_descriptor,
-                }) => {
-                    let stream = {
-                        let t = self.transact()?;
-                        let desc = t.get_descriptor(file_descriptor)?;
-                        match desc {
-                            Descriptor::Stdin { stream, .. } => stream.borrowed(),
-                            Descriptor::File(File { fd, position, .. })
-                                if t.view.table().get_resource(fd)?.is_file() =>
-                            {
-                                let pos = position.load(Ordering::Relaxed);
-                                let fd = fd.borrowed();
-                                drop(t);
-                                self.read_via_stream(fd, pos).map_err(|e| {
-                                    e.try_into()
-                                        .context("failed to call `read-via-stream`")
-                                        .unwrap_or_else(types::Error::trap)
-                                })?
-                            }
-                            // TODO: Support sockets
-                            _ => return Err(types::Errno::Badf.into()),
-                        }
-                    };
-                    streams::HostInputStream::subscribe(self, stream)
-                        .context("failed to call `subscribe` on `input-stream`")
-                        .map_err(types::Error::trap)?
-                }
-                types::SubscriptionU::FdWrite(types::SubscriptionFdReadwrite {
-                    file_descriptor,
-                }) => {
-                    let stream = {
-                        let t = self.transact()?;
-                        let desc = t.get_descriptor(file_descriptor)?;
-                        match desc {
-                            Descriptor::Stdout { stream, .. }
-                            | Descriptor::Stderr { stream, .. } => stream.borrowed(),
-                            Descriptor::File(File {
-                                fd,
-                                position,
-                                append,
-                                ..
-                            }) if t.view.table().get_resource(fd)?.is_file() => {
-                                let fd = fd.borrowed();
-                                let position = position.clone();
-                                let append = *append;
-                                drop(t);
-                                if append {
-                                    self.append_via_stream(fd).map_err(|e| {
-                                        e.try_into()
-                                            .context("failed to call `append-via-stream`")
-                                            .unwrap_or_else(types::Error::trap)
-                                    })?
-                                } else {
-                                    let pos = position.load(Ordering::Relaxed);
-                                    self.write_via_stream(fd, pos).map_err(|e| {
-                                        e.try_into()
-                                            .context("failed to call `write-via-stream`")
-                                            .unwrap_or_else(types::Error::trap)
-                                    })?
-                                }
-                            }
-                            // TODO: Support sockets
-                            _ => return Err(types::Errno::Badf.into()),
-                        }
-                    };
-                    streams::HostOutputStream::subscribe(self, stream)
-                        .context("failed to call `subscribe` on `output-stream`")
-                        .map_err(types::Error::trap)?
-                }
-            };
-            pollables.push(p);
-        }
-        let ready: HashSet<_> = self
-            .poll_list(pollables)
-            .await
-            .context("failed to call `poll-oneoff`")
-            .map_err(types::Error::trap)?
-            .into_iter()
-            .collect();
-
-        let mut count: types::Size = 0;
-        for (sub, event) in (0..)
-            .zip(subs.iter())
-            .filter_map(|(idx, sub)| ready.contains(&idx).then_some(sub))
-            .zip(events.iter())
-        {
-            let sub = sub?.read()?;
-            let event = event?;
-            let e = match sub.u {
-                types::SubscriptionU::Clock(..) => types::Event {
-                    userdata: sub.userdata,
-                    error: types::Errno::Success,
-                    type_: types::Eventtype::Clock,
-                    fd_readwrite: types::EventFdReadwrite {
-                        flags: types::Eventrwflags::empty(),
-                        nbytes: 0,
-                    },
-                },
-                types::SubscriptionU::FdRead(types::SubscriptionFdReadwrite {
-                    file_descriptor,
-                }) => {
-                    let t = self.transact()?;
-                    let desc = t.get_descriptor(file_descriptor)?;
-                    match desc {
-                        Descriptor::Stdin { .. } => types::Event {
-                            userdata: sub.userdata,
-                            error: types::Errno::Success,
-                            type_: types::Eventtype::FdRead,
-                            fd_readwrite: types::EventFdReadwrite {
-                                flags: types::Eventrwflags::empty(),
-                                nbytes: 1,
-                            },
-                        },
-                        Descriptor::File(File { fd, position, .. })
-                            if t.view.table().get_resource(fd)?.is_file() =>
-                        {
-                            let fd = fd.borrowed();
-                            let position = position.clone();
-                            drop(t);
-                            match self
-                                .stat(fd)
-                                .await
-                                .map_err(|e| e.try_into().context("failed to call `stat`"))
-                            {
-                                Ok(filesystem::DescriptorStat { size, .. }) => {
-                                    let pos = position.load(Ordering::Relaxed);
-                                    let nbytes = size.saturating_sub(pos);
-                                    types::Event {
-                                        userdata: sub.userdata,
-                                        error: types::Errno::Success,
-                                        type_: types::Eventtype::FdRead,
-                                        fd_readwrite: types::EventFdReadwrite {
-                                            flags: if nbytes == 0 {
-                                                types::Eventrwflags::FD_READWRITE_HANGUP
-                                            } else {
-                                                types::Eventrwflags::empty()
-                                            },
-                                            nbytes: 1,
-                                        },
-                                    }
-                                }
-                                Err(Ok(error)) => types::Event {
-                                    userdata: sub.userdata,
-                                    error,
-                                    type_: types::Eventtype::FdRead,
-                                    fd_readwrite: types::EventFdReadwrite {
-                                        flags: types::Eventrwflags::empty(),
-                                        nbytes: 1,
-                                    },
-                                },
-                                Err(Err(error)) => return Err(types::Error::trap(error)),
-                            }
-                        }
-                        // TODO: Support sockets
-                        _ => return Err(types::Errno::Badf.into()),
-                    }
-                }
-                types::SubscriptionU::FdWrite(types::SubscriptionFdReadwrite {
-                    file_descriptor,
-                }) => {
-                    let t = self.transact()?;
-                    let desc = t.get_descriptor(file_descriptor)?;
-                    match desc {
-                        Descriptor::Stdout { .. } | Descriptor::Stderr { .. } => types::Event {
-                            userdata: sub.userdata,
-                            error: types::Errno::Success,
-                            type_: types::Eventtype::FdWrite,
-                            fd_readwrite: types::EventFdReadwrite {
-                                flags: types::Eventrwflags::empty(),
-                                nbytes: 1,
-                            },
-                        },
-                        Descriptor::File(File { fd, .. })
-                            if t.view.table().get_resource(fd)?.is_file() =>
-                        {
-                            types::Event {
-                                userdata: sub.userdata,
-                                error: types::Errno::Success,
-                                type_: types::Eventtype::FdWrite,
-                                fd_readwrite: types::EventFdReadwrite {
-                                    flags: types::Eventrwflags::empty(),
-                                    nbytes: 1,
-                                },
-                            }
-                        }
-                        // TODO: Support sockets
-                        _ => return Err(types::Errno::Badf.into()),
-                    }
-                }
-            };
-            event.write(e)?;
-            count = count
-                .checked_add(1)
-                .ok_or_else(|| types::Error::from(types::Errno::Overflow))?
-        }
-        Ok(count)
-    }
-
-    #[instrument(skip(self))]
-    fn proc_exit(&mut self, status: types::Exitcode) -> anyhow::Error {
-        let status = match status {
-            0 => Ok(()),
-            _ => Err(()),
-        };
-        match self.exit(status) {
-            Err(e) => e,
-            Ok(()) => anyhow!("`exit` did not return an error"),
-        }
-    }
-
-    #[instrument(skip(self))]
-    fn proc_raise(&mut self, _sig: types::Signal) -> Result<(), types::Error> {
-        Err(types::Errno::Notsup.into())
-    }
-
-    #[instrument(skip(self))]
-    fn sched_yield(&mut self) -> Result<(), types::Error> {
-        // No such thing in preview 2. Intentionally left empty.
-        Ok(())
-    }
-
-    #[instrument(skip(self))]
-    fn random_get<'a>(
-        &mut self,
-        buf: &GuestPtr<'a, u8>,
-        buf_len: types::Size,
-    ) -> Result<(), types::Error> {
-        let rand = self
-            .get_random_bytes(buf_len.into())
-            .context("failed to call `get-random-bytes`")
-            .map_err(types::Error::trap)?;
-        write_bytes(buf, &rand)?;
-        Ok(())
-    }
-
-    #[allow(unused_variables)]
-    #[instrument(skip(self))]
-    fn sock_accept(
-        &mut self,
-        fd: types::Fd,
-        flags: types::Fdflags,
-    ) -> Result<types::Fd, types::Error> {
-        todo!("preview1 sock_accept is not implemented")
-    }
-
-    #[allow(unused_variables)]
-    #[instrument(skip(self))]
-    fn sock_recv<'a>(
-        &mut self,
-        fd: types::Fd,
-        ri_data: &types::IovecArray<'a>,
-        ri_flags: types::Riflags,
-    ) -> Result<(types::Size, types::Roflags), types::Error> {
-        todo!("preview1 sock_recv is not implemented")
-    }
-
-    #[allow(unused_variables)]
-    #[instrument(skip(self))]
-    fn sock_send<'a>(
-        &mut self,
-        fd: types::Fd,
-        si_data: &types::CiovecArray<'a>,
-        _si_flags: types::Siflags,
-    ) -> Result<types::Size, types::Error> {
-        todo!("preview1 sock_send is not implemented")
-    }
-
-    #[allow(unused_variables)]
-    #[instrument(skip(self))]
-    fn sock_shutdown(&mut self, fd: types::Fd, how: types::Sdflags) -> Result<(), types::Error> {
-        todo!("preview1 sock_shutdown is not implemented")
-    }
-}
-
-trait ResourceExt<T> {
-    fn borrowed(&self) -> Resource<T>;
-}
-
-impl<T: 'static> ResourceExt<T> for Resource<T> {
-    fn borrowed(&self) -> Resource<T> {
-        Resource::new_borrow(self.rep())
-    }
-}
diff --git a/crates/wasi/src/preview2/random.rs b/crates/wasi/src/preview2/random.rs
deleted file mode 100644
index 9660699e87c1..000000000000
--- a/crates/wasi/src/preview2/random.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-use cap_rand::RngCore;
-
-/// Implement `insecure-random` using a deterministic cycle of bytes.
-pub struct Deterministic {
-    cycle: std::iter::Cycle<std::vec::IntoIter<u8>>,
-}
-
-impl Deterministic {
-    pub fn new(bytes: Vec<u8>) -> Self {
-        Deterministic {
-            cycle: bytes.into_iter().cycle(),
-        }
-    }
-}
-
-impl RngCore for Deterministic {
-    fn next_u32(&mut self) -> u32 {
-        let b0 = self.cycle.next().expect("infinite sequence");
-        let b1 = self.cycle.next().expect("infinite sequence");
-        let b2 = self.cycle.next().expect("infinite sequence");
-        let b3 = self.cycle.next().expect("infinite sequence");
-        ((b0 as u32) << 24) + ((b1 as u32) << 16) + ((b2 as u32) << 8) + (b3 as u32)
-    }
-    fn next_u64(&mut self) -> u64 {
-        let w0 = self.next_u32();
-        let w1 = self.next_u32();
-        ((w0 as u64) << 32) + (w1 as u64)
-    }
-    fn fill_bytes(&mut self, buf: &mut [u8]) {
-        for b in buf.iter_mut() {
-            *b = self.cycle.next().expect("infinite sequence");
-        }
-    }
-    fn try_fill_bytes(&mut self, buf: &mut [u8]) -> Result<(), cap_rand::Error> {
-        self.fill_bytes(buf);
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    #[test]
-    fn deterministic() {
-        let mut det = Deterministic::new(vec![1, 2, 3, 4]);
-        let mut buf = vec![0; 1024];
-        det.try_fill_bytes(&mut buf).expect("get randomness");
-        for (ix, b) in buf.iter().enumerate() {
-            assert_eq!(*b, (ix % 4) as u8 + 1)
-        }
-    }
-}
-
-pub fn thread_rng() -> Box<dyn RngCore + Send + Sync> {
-    use cap_rand::{Rng, SeedableRng};
-    let mut rng = cap_rand::thread_rng(cap_rand::ambient_authority());
-    Box::new(cap_rand::rngs::StdRng::from_seed(rng.gen()))
-}
diff --git a/crates/wasi/src/preview2/stdio.rs b/crates/wasi/src/preview2/stdio.rs
deleted file mode 100644
index 9a4e93b86f5f..000000000000
--- a/crates/wasi/src/preview2/stdio.rs
+++ /dev/null
@@ -1,419 +0,0 @@
-use crate::preview2::bindings::cli::{
-    stderr, stdin, stdout, terminal_input, terminal_output, terminal_stderr, terminal_stdin,
-    terminal_stdout,
-};
-use crate::preview2::bindings::io::streams;
-use crate::preview2::pipe::{self, AsyncWriteStream};
-use crate::preview2::{HostInputStream, HostOutputStream, WasiView};
-use std::io::IsTerminal;
-use wasmtime::component::Resource;
-
-/// A trait used to represent the standard input to a guest program.
-///
-/// This is used to implement various WASI APIs via the method implementations
-/// below.
-///
-/// Built-in implementations are provided for [`Stdin`],
-/// [`pipe::MemoryInputPipe`], and [`pipe::ClosedInputStream`].
-pub trait StdinStream: Send + Sync {
-    /// Creates a fresh stream which is reading stdin.
-    ///
-    /// Note that the returned stream must share state with all other streams
-    /// previously created. Guests may create multiple handles to the same stdin
-    /// and they should all be synchronized in their progress through the
-    /// program's input.
-    ///
-    /// Note that this means that if one handle becomes ready for reading they
-    /// all become ready for reading. Subsequently if one is read from it may
-    /// mean that all the others are no longer ready for reading. This is
-    /// basically a consequence of the way the WIT APIs are designed today.
-    fn stream(&self) -> Box<dyn HostInputStream>;
-
-    /// Returns whether this stream is backed by a TTY.
-    fn isatty(&self) -> bool;
-}
-
-impl StdinStream for pipe::MemoryInputPipe {
-    fn stream(&self) -> Box<dyn HostInputStream> {
-        Box::new(self.clone())
-    }
-
-    fn isatty(&self) -> bool {
-        false
-    }
-}
-
-impl StdinStream for pipe::ClosedInputStream {
-    fn stream(&self) -> Box<dyn HostInputStream> {
-        Box::new(self.clone())
-    }
-
-    fn isatty(&self) -> bool {
-        false
-    }
-}
-
-mod worker_thread_stdin;
-pub use self::worker_thread_stdin::{stdin, Stdin};
-
-// blocking-write-and-flush must accept 4k. It doesn't seem likely that we need to
-// buffer more than that to implement a wrapper on the host process's stdio. If users
-// really need more, they can write their own implementation using AsyncWriteStream
-// and tokio's stdout/err.
-const STDIO_BUFFER_SIZE: usize = 4096;
-
-/// Similar to [`StdinStream`], except for output.
-pub trait StdoutStream: Send + Sync {
-    /// Returns a fresh new stream which can write to this output stream.
-    ///
-    /// Note that all output streams should output to the same logical source.
-    /// This means that it's possible for each independent stream to acquire a
-    /// separate "permit" to write and then act on that permit. Note that
-    /// additionally at this time once a permit is "acquired" there's no way to
-    /// release it, for example you can wait for readiness and then never
-    /// actually write in WASI. This means that acquisition of a permit for one
-    /// stream cannot discount the size of a permit another stream could
-    /// obtain.
-    ///
-    /// Implementations must be able to handle this
-    fn stream(&self) -> Box<dyn HostOutputStream>;
-
-    /// Returns whether this stream is backed by a TTY.
-    fn isatty(&self) -> bool;
-}
-
-impl StdoutStream for pipe::MemoryOutputPipe {
-    fn stream(&self) -> Box<dyn HostOutputStream> {
-        Box::new(self.clone())
-    }
-
-    fn isatty(&self) -> bool {
-        false
-    }
-}
-
-impl StdoutStream for pipe::SinkOutputStream {
-    fn stream(&self) -> Box<dyn HostOutputStream> {
-        Box::new(self.clone())
-    }
-
-    fn isatty(&self) -> bool {
-        false
-    }
-}
-
-impl StdoutStream for pipe::ClosedOutputStream {
-    fn stream(&self) -> Box<dyn HostOutputStream> {
-        Box::new(self.clone())
-    }
-
-    fn isatty(&self) -> bool {
-        false
-    }
-}
-
-pub struct Stdout;
-
-pub fn stdout() -> Stdout {
-    Stdout
-}
-
-impl StdoutStream for Stdout {
-    fn stream(&self) -> Box<dyn HostOutputStream> {
-        Box::new(AsyncWriteStream::new(
-            STDIO_BUFFER_SIZE,
-            tokio::io::stdout(),
-        ))
-    }
-
-    fn isatty(&self) -> bool {
-        std::io::stdout().is_terminal()
-    }
-}
-
-pub struct Stderr;
-
-pub fn stderr() -> Stderr {
-    Stderr
-}
-
-impl StdoutStream for Stderr {
-    fn stream(&self) -> Box<dyn HostOutputStream> {
-        Box::new(AsyncWriteStream::new(
-            STDIO_BUFFER_SIZE,
-            tokio::io::stderr(),
-        ))
-    }
-
-    fn isatty(&self) -> bool {
-        std::io::stderr().is_terminal()
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum IsATTY {
-    Yes,
-    No,
-}
-
-impl<T: WasiView> stdin::Host for T {
-    fn get_stdin(&mut self) -> Result<Resource<streams::InputStream>, anyhow::Error> {
-        let stream = self.ctx_mut().stdin.stream();
-        Ok(self
-            .table_mut()
-            .push_resource(streams::InputStream::Host(stream))?)
-    }
-}
-
-impl<T: WasiView> stdout::Host for T {
-    fn get_stdout(&mut self) -> Result<Resource<streams::OutputStream>, anyhow::Error> {
-        let stream = self.ctx_mut().stdout.stream();
-        Ok(self.table_mut().push_resource(stream)?)
-    }
-}
-
-impl<T: WasiView> stderr::Host for T {
-    fn get_stderr(&mut self) -> Result<Resource<streams::OutputStream>, anyhow::Error> {
-        let stream = self.ctx_mut().stderr.stream();
-        Ok(self.table_mut().push_resource(stream)?)
-    }
-}
-
-pub struct TerminalInput;
-pub struct TerminalOutput;
-
-impl<T: WasiView> terminal_input::Host for T {}
-impl<T: WasiView> terminal_input::HostTerminalInput for T {
-    fn drop(&mut self, r: Resource<TerminalInput>) -> anyhow::Result<()> {
-        self.table_mut().delete_resource(r)?;
-        Ok(())
-    }
-}
-impl<T: WasiView> terminal_output::Host for T {}
-impl<T: WasiView> terminal_output::HostTerminalOutput for T {
-    fn drop(&mut self, r: Resource<TerminalOutput>) -> anyhow::Result<()> {
-        self.table_mut().delete_resource(r)?;
-        Ok(())
-    }
-}
-impl<T: WasiView> terminal_stdin::Host for T {
-    fn get_terminal_stdin(&mut self) -> anyhow::Result<Option<Resource<TerminalInput>>> {
-        if self.ctx().stdin.isatty() {
-            let fd = self.table_mut().push_resource(TerminalInput)?;
-            Ok(Some(fd))
-        } else {
-            Ok(None)
-        }
-    }
-}
-impl<T: WasiView> terminal_stdout::Host for T {
-    fn get_terminal_stdout(&mut self) -> anyhow::Result<Option<Resource<TerminalOutput>>> {
-        if self.ctx().stdout.isatty() {
-            let fd = self.table_mut().push_resource(TerminalOutput)?;
-            Ok(Some(fd))
-        } else {
-            Ok(None)
-        }
-    }
-}
-impl<T: WasiView> terminal_stderr::Host for T {
-    fn get_terminal_stderr(&mut self) -> anyhow::Result<Option<Resource<TerminalOutput>>> {
-        if self.ctx().stderr.isatty() {
-            let fd = self.table_mut().push_resource(TerminalOutput)?;
-            Ok(Some(fd))
-        } else {
-            Ok(None)
-        }
-    }
-}
-
-#[cfg(all(unix, test))]
-mod test {
-    use crate::preview2::HostInputStream;
-    use libc;
-    use std::fs::File;
-    use std::io::{BufRead, BufReader, Write};
-    use std::os::fd::FromRawFd;
-
-    fn test_child_stdin<T, P>(child: T, parent: P)
-    where
-        T: FnOnce(File),
-        P: FnOnce(File, BufReader<File>),
-    {
-        unsafe {
-            // Make pipe for emulating stdin.
-            let mut stdin_fds: [libc::c_int; 2] = [0; 2];
-            assert_eq!(
-                libc::pipe(stdin_fds.as_mut_ptr()),
-                0,
-                "Failed to create stdin pipe"
-            );
-            let [stdin_read, stdin_write] = stdin_fds;
-
-            // Make pipe for getting results.
-            let mut result_fds: [libc::c_int; 2] = [0; 2];
-            assert_eq!(
-                libc::pipe(result_fds.as_mut_ptr()),
-                0,
-                "Failed to create result pipe"
-            );
-            let [result_read, result_write] = result_fds;
-
-            let child_pid = libc::fork();
-            if child_pid == 0 {
-                libc::close(stdin_write);
-                libc::close(result_read);
-
-                libc::close(libc::STDIN_FILENO);
-                libc::dup2(stdin_read, libc::STDIN_FILENO);
-
-                let result_write = File::from_raw_fd(result_write);
-                child(result_write);
-            } else {
-                libc::close(stdin_read);
-                libc::close(result_write);
-
-                let stdin_write = File::from_raw_fd(stdin_write);
-                let result_read = BufReader::new(File::from_raw_fd(result_read));
-                parent(stdin_write, result_read);
-            }
-        }
-    }
-
-    // This could even be parameterized somehow to use the worker thread stdin vs the asyncfd
-    // stdin.
-    fn test_stdin_by_forking<S, T>(mk_stdin: T)
-    where
-        S: HostInputStream,
-        T: Fn() -> S,
-    {
-        test_child_stdin(
-            |mut result_write| {
-                let mut child_running = true;
-                while child_running {
-                    tokio::runtime::Builder::new_multi_thread()
-                        .enable_all()
-                        .build()
-                        .unwrap()
-                        .block_on(async {
-                            'task: loop {
-                                println!("child: creating stdin");
-                                let mut stdin = mk_stdin();
-
-                                println!("child: checking that stdin is not ready");
-                                assert!(
-                                    tokio::time::timeout(
-                                        std::time::Duration::from_millis(100),
-                                        stdin.ready()
-                                    )
-                                    .await
-                                    .is_err(),
-                                    "stdin available too soon"
-                                );
-
-                                writeln!(&mut result_write, "start").unwrap();
-
-                                println!("child: started");
-
-                                let mut buffer = String::new();
-                                loop {
-                                    println!("child: waiting for stdin to be ready");
-                                    stdin.ready().await;
-
-                                    println!("child: reading input");
-                                    // We can't effectively test for the case where stdin was closed, so panic if it is...
-                                    let bytes = stdin.read(1024).unwrap();
-
-                                    println!("child got: {:?}", bytes);
-
-                                    buffer.push_str(std::str::from_utf8(bytes.as_ref()).unwrap());
-                                    if let Some((line, rest)) = buffer.split_once('\n') {
-                                        if line == "all done" {
-                                            writeln!(&mut result_write, "done").unwrap();
-                                            println!("child: exiting...");
-                                            child_running = false;
-                                            break 'task;
-                                        } else if line == "restart_runtime" {
-                                            writeln!(&mut result_write, "restarting").unwrap();
-                                            println!("child: restarting runtime...");
-                                            break 'task;
-                                        } else if line == "restart_task" {
-                                            writeln!(&mut result_write, "restarting").unwrap();
-                                            println!("child: restarting task...");
-                                            continue 'task;
-                                        } else {
-                                            writeln!(&mut result_write, "{}", line).unwrap();
-                                        }
-
-                                        buffer = rest.to_owned();
-                                    }
-                                }
-                            }
-                        });
-                    println!("runtime exited");
-                }
-                println!("child exited");
-            },
-            |mut stdin_write, mut result_read| {
-                let mut line = String::new();
-                result_read.read_line(&mut line).unwrap();
-                assert_eq!(line, "start\n");
-
-                for i in 0..5 {
-                    let message = format!("some bytes {}\n", i);
-                    stdin_write.write_all(message.as_bytes()).unwrap();
-                    line.clear();
-                    result_read.read_line(&mut line).unwrap();
-                    assert_eq!(line, message);
-                }
-
-                writeln!(&mut stdin_write, "restart_task").unwrap();
-                line.clear();
-                result_read.read_line(&mut line).unwrap();
-                assert_eq!(line, "restarting\n");
-                line.clear();
-
-                result_read.read_line(&mut line).unwrap();
-                assert_eq!(line, "start\n");
-
-                for i in 0..10 {
-                    let message = format!("more bytes {}\n", i);
-                    stdin_write.write_all(message.as_bytes()).unwrap();
-                    line.clear();
-                    result_read.read_line(&mut line).unwrap();
-                    assert_eq!(line, message);
-                }
-
-                writeln!(&mut stdin_write, "restart_runtime").unwrap();
-                line.clear();
-                result_read.read_line(&mut line).unwrap();
-                assert_eq!(line, "restarting\n");
-                line.clear();
-
-                result_read.read_line(&mut line).unwrap();
-                assert_eq!(line, "start\n");
-
-                for i in 0..17 {
-                    let message = format!("even more bytes {}\n", i);
-                    stdin_write.write_all(message.as_bytes()).unwrap();
-                    line.clear();
-                    result_read.read_line(&mut line).unwrap();
-                    assert_eq!(line, message);
-                }
-
-                writeln!(&mut stdin_write, "all done").unwrap();
-
-                line.clear();
-                result_read.read_line(&mut line).unwrap();
-                assert_eq!(line, "done\n");
-            },
-        )
-    }
-
-    // This test doesn't work under qemu because of the use of fork in the test helper.
-    #[test]
-    #[cfg_attr(not(target_arch = "x86_64"), ignore)]
-    fn test_worker_thread_stdin() {
-        test_stdin_by_forking(super::worker_thread_stdin::stdin);
-    }
-}
diff --git a/crates/wasi/src/preview2/stream.rs b/crates/wasi/src/preview2/stream.rs
deleted file mode 100644
index 4143b9ad86c2..000000000000
--- a/crates/wasi/src/preview2/stream.rs
+++ /dev/null
@@ -1,158 +0,0 @@
-use crate::preview2::filesystem::FileInputStream;
-use crate::preview2::poll::Subscribe;
-use anyhow::Result;
-use bytes::Bytes;
-
-/// Host trait for implementing the `wasi:io/streams.input-stream` resource: A
-/// bytestream which can be read from.
-#[async_trait::async_trait]
-pub trait HostInputStream: Subscribe {
-    /// Reads up to `size` bytes, returning a buffer holding these bytes on
-    /// success.
-    ///
-    /// This function does not block the current thread and is the equivalent of
-    /// a non-blocking read. On success all bytes read are returned through
-    /// `Bytes`, which is no larger than the `size` provided. If the returned
-    /// list of `Bytes` is empty then no data is ready to be read at this time.
-    ///
-    /// # Errors
-    ///
-    /// The [`StreamError`] return value communicates when this stream is
-    /// closed, when a read fails, or when a trap should be generated.
-    fn read(&mut self, size: usize) -> Result<Bytes, StreamError>;
-
-    /// Same as the `read` method except that bytes are skipped.
-    ///
-    /// Note that this method is non-blocking like `read` and returns the same
-    /// errors.
-    fn skip(&mut self, nelem: usize) -> Result<usize, StreamError> {
-        let bs = self.read(nelem)?;
-        Ok(bs.len())
-    }
-}
-
-#[derive(Debug)]
-pub enum StreamError {
-    Closed,
-    LastOperationFailed(anyhow::Error),
-    Trap(anyhow::Error),
-}
-impl std::fmt::Display for StreamError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            StreamError::Closed => write!(f, "closed"),
-            StreamError::LastOperationFailed(e) => write!(f, "last operation failed: {e}"),
-            StreamError::Trap(e) => write!(f, "trap: {e}"),
-        }
-    }
-}
-impl std::error::Error for StreamError {
-    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        match self {
-            StreamError::Closed => None,
-            StreamError::LastOperationFailed(e) | StreamError::Trap(e) => e.source(),
-        }
-    }
-}
-
-/// Host trait for implementing the `wasi:io/streams.output-stream` resource:
-/// A bytestream which can be written to.
-#[async_trait::async_trait]
-pub trait HostOutputStream: Subscribe {
-    /// Write bytes after obtaining a permit to write those bytes
-    ///
-    /// Prior to calling [`write`](Self::write) the caller must call
-    /// [`check_write`](Self::check_write), which resolves to a non-zero permit
-    ///
-    /// This method must never block.  The [`check_write`](Self::check_write)
-    /// permit indicates the maximum amount of bytes that are permitted to be
-    /// written in a single [`write`](Self::write) following the
-    /// [`check_write`](Self::check_write) resolution.
-    ///
-    /// # Errors
-    ///
-    /// Returns a [`StreamError`] if:
-    /// - stream is closed
-    /// - prior operation ([`write`](Self::write) or [`flush`](Self::flush)) failed
-    /// - caller performed an illegal operation (e.g. wrote more bytes than were permitted)
-    fn write(&mut self, bytes: Bytes) -> Result<(), StreamError>;
-
-    /// Trigger a flush of any bytes buffered in this stream implementation.
-    ///
-    /// This method may be called at any time and must never block.
-    ///
-    /// After this method is called, [`check_write`](Self::check_write) must
-    /// pend until flush is complete.
-    ///
-    /// When [`check_write`](Self::check_write) becomes ready after a flush,
-    /// that guarantees that all prior writes have been flushed from the
-    /// implementation successfully, or that any error associated with those
-    /// writes is reported in the return value of [`flush`](Self::flush) or
-    /// [`check_write`](Self::check_write)
-    ///
-    /// # Errors
-    ///
-    /// Returns a [`StreamError`] if:
-    /// - stream is closed
-    /// - prior operation ([`write`](Self::write) or [`flush`](Self::flush)) failed
-    /// - caller performed an illegal operation (e.g. wrote more bytes than were permitted)
-    fn flush(&mut self) -> Result<(), StreamError>;
-
-    /// Returns the number of bytes that are ready to be written to this stream.
-    ///
-    /// Zero bytes indicates that this stream is not currently ready for writing
-    /// and `ready()` must be awaited first.
-    ///
-    /// Note that this method does not block.
-    ///
-    /// # Errors
-    ///
-    /// Returns an [`StreamError`] if:
-    /// - stream is closed
-    /// - prior operation ([`write`](Self::write) or [`flush`](Self::flush)) failed
-    fn check_write(&mut self) -> Result<usize, StreamError>;
-
-    /// Repeatedly write a byte to a stream.
-    /// Important: this write must be non-blocking!
-    /// Returning an Err which downcasts to a [`StreamError`] will be
-    /// reported to Wasm as the empty error result. Otherwise, errors will trap.
-    fn write_zeroes(&mut self, nelem: usize) -> Result<(), StreamError> {
-        // TODO: We could optimize this to not allocate one big zeroed buffer, and instead write
-        // repeatedly from a 'static buffer of zeros.
-        let bs = Bytes::from_iter(core::iter::repeat(0 as u8).take(nelem));
-        self.write(bs)?;
-        Ok(())
-    }
-
-    /// Simultaneously waits for this stream to be writable and then returns how
-    /// much may be written or the last error that happened.
-    async fn write_ready(&mut self) -> Result<usize, StreamError> {
-        self.ready().await;
-        self.check_write()
-    }
-}
-
-#[async_trait::async_trait]
-impl Subscribe for Box<dyn HostOutputStream> {
-    async fn ready(&mut self) {
-        (**self).ready().await
-    }
-}
-
-pub enum InputStream {
-    Host(Box<dyn HostInputStream>),
-    File(FileInputStream),
-}
-
-#[async_trait::async_trait]
-impl Subscribe for InputStream {
-    async fn ready(&mut self) {
-        match self {
-            InputStream::Host(stream) => stream.ready().await,
-            // Files are always ready
-            InputStream::File(_) => {}
-        }
-    }
-}
-
-pub type OutputStream = Box<dyn HostOutputStream>;
diff --git a/crates/wasi/src/preview2/table.rs b/crates/wasi/src/preview2/table.rs
deleted file mode 100644
index 151ca2a0124f..000000000000
--- a/crates/wasi/src/preview2/table.rs
+++ /dev/null
@@ -1,317 +0,0 @@
-use std::any::Any;
-use std::collections::{BTreeSet, HashMap};
-use wasmtime::component::Resource;
-
-#[derive(thiserror::Error, Debug)]
-pub enum TableError {
-    #[error("table has no free keys")]
-    Full,
-    #[error("value not present")]
-    NotPresent,
-    #[error("value is of another type")]
-    WrongType,
-    #[error("entry still has children")]
-    HasChildren,
-}
-
-/// The `Table` type is designed to map u32 handles to resources. The table is now part of the
-/// public interface to a `WasiCtx` - it is reference counted so that it can be shared beyond a
-/// `WasiCtx` with other WASI proposals (e.g. `wasi-crypto` and `wasi-nn`) to manage their
-/// resources. Elements in the `Table` are `Any` typed.
-///
-/// The `Table` type is intended to model how the Interface Types concept of Resources is shaping
-/// up. Right now it is just an approximation.
-#[derive(Debug)]
-pub struct Table {
-    map: HashMap<u32, TableEntry>,
-    next_key: u32,
-}
-
-/// This structure tracks parent and child relationships for a given table entry.
-///
-/// Parents and children are referred to by table index. We maintain the
-/// following invariants to prevent orphans and cycles:
-/// * parent can only be assigned on creating the entry.
-/// * parent, if some, must exist when creating the entry.
-/// * whenever a child is created, its index is added to children.
-/// * whenever a child is deleted, its index is removed from children.
-/// * an entry with children may not be deleted.
-#[derive(Debug)]
-struct TableEntry {
-    /// The entry in the table, as a boxed dynamically-typed object
-    entry: Box<dyn Any + Send + Sync>,
-    /// The index of the parent of this entry, if it has one.
-    parent: Option<u32>,
-    /// The indicies of any children of this entry.
-    children: BTreeSet<u32>,
-}
-
-impl TableEntry {
-    fn new(entry: Box<dyn Any + Send + Sync>, parent: Option<u32>) -> Self {
-        Self {
-            entry,
-            parent,
-            children: BTreeSet::new(),
-        }
-    }
-    fn add_child(&mut self, child: u32) {
-        debug_assert!(!self.children.contains(&child));
-        self.children.insert(child);
-    }
-    fn remove_child(&mut self, child: u32) {
-        let was_removed = self.children.remove(&child);
-        debug_assert!(was_removed);
-    }
-}
-
-impl Table {
-    /// Create an empty table
-    pub fn new() -> Self {
-        Table {
-            map: HashMap::new(),
-            // 0, 1 and 2 are formerly (preview 1) for stdio. To prevent users from assuming these
-            // indicies are still valid ways to access stdio, they are deliberately left empty.
-            // Once we have a full implementation of resources, this confusion should hopefully be
-            // impossible :)
-            next_key: 3,
-        }
-    }
-
-    /// Insert a resource at the next available index.
-    pub fn push(&mut self, entry: Box<dyn Any + Send + Sync>) -> Result<u32, TableError> {
-        self.push_(TableEntry::new(entry, None))
-    }
-
-    /// Same as `push`, but typed.
-    pub fn push_resource<T>(&mut self, entry: T) -> Result<Resource<T>, TableError>
-    where
-        T: Send + Sync + 'static,
-    {
-        let idx = self.push(Box::new(entry))?;
-        Ok(Resource::new_own(idx))
-    }
-
-    /// Insert a resource at the next available index, and track that it has a
-    /// parent resource.
-    ///
-    /// The parent must exist to create a child. All children resources must
-    /// be destroyed before a parent can be destroyed - otherwise [`Table::delete`]
-    /// will fail with [`TableError::HasChildren`].
-    ///
-    /// Parent-child relationships are tracked inside the table to ensure that
-    /// a parent resource is not deleted while it has live children. This
-    /// allows child resources to hold "references" to a parent by table
-    /// index, to avoid needing e.g. an `Arc<Mutex<parent>>` and the associated
-    /// locking overhead and design issues, such as child existence extending
-    /// lifetime of parent referent even after parent resource is destroyed,
-    /// possibility for deadlocks.
-    ///
-    /// Parent-child relationships may not be modified once created. There
-    /// is no way to observe these relationships through the [`Table`] methods
-    /// except for erroring on deletion, or the [`std::fmt::Debug`] impl.
-    pub fn push_child(
-        &mut self,
-        entry: Box<dyn Any + Send + Sync>,
-        parent: u32,
-    ) -> Result<u32, TableError> {
-        if !self.contains_key(parent) {
-            return Err(TableError::NotPresent);
-        }
-        let child = self.push_(TableEntry::new(entry, Some(parent)))?;
-        self.map
-            .get_mut(&parent)
-            .expect("parent existence assured above")
-            .add_child(child);
-        Ok(child)
-    }
-
-    /// Same as `push_child`, but typed.
-    pub fn push_child_resource<T, U>(
-        &mut self,
-        entry: T,
-        parent: &Resource<U>,
-    ) -> Result<Resource<T>, TableError>
-    where
-        T: Send + Sync + 'static,
-        U: 'static,
-    {
-        let idx = self.push_child(Box::new(entry), parent.rep())?;
-        Ok(Resource::new_own(idx))
-    }
-
-    fn push_(&mut self, e: TableEntry) -> Result<u32, TableError> {
-        // NOTE: The performance of this new key calculation could be very bad once keys wrap
-        // around.
-        if self.map.len() == u32::MAX as usize {
-            return Err(TableError::Full);
-        }
-        loop {
-            let key = self.next_key;
-            self.next_key = self.next_key.wrapping_add(1);
-            if self.map.contains_key(&key) {
-                continue;
-            }
-            self.map.insert(key, e);
-            return Ok(key);
-        }
-    }
-
-    /// Check if the table has a resource at the given index.
-    pub fn contains_key(&self, key: u32) -> bool {
-        self.map.contains_key(&key)
-    }
-
-    /// Check if the resource at a given index can be downcast to a given type.
-    /// Note: this will always fail if the resource is already borrowed.
-    pub fn is<T: Any + Sized>(&self, key: u32) -> bool {
-        if let Some(r) = self.map.get(&key) {
-            r.entry.is::<T>()
-        } else {
-            false
-        }
-    }
-
-    /// Get a mutable reference to the underlying untyped cell for an entry in the table.
-    pub fn get_any_mut(&mut self, key: u32) -> Result<&mut dyn Any, TableError> {
-        if let Some(r) = self.map.get_mut(&key) {
-            Ok(&mut *r.entry)
-        } else {
-            Err(TableError::NotPresent)
-        }
-    }
-
-    /// Get an immutable reference to a resource of a given type at a given index. Multiple
-    /// immutable references can be borrowed at any given time. Borrow failure
-    /// results in a trapping error.
-    pub fn get<T: Any + Sized>(&self, key: u32) -> Result<&T, TableError> {
-        if let Some(r) = self.map.get(&key) {
-            r.entry
-                .downcast_ref::<T>()
-                .ok_or_else(|| TableError::WrongType)
-        } else {
-            Err(TableError::NotPresent)
-        }
-    }
-
-    /// Get a mutable reference to a resource of a given type at a given index.
-    pub fn get_mut<T: Any + Sized>(&mut self, key: u32) -> Result<&mut T, TableError> {
-        if let Some(r) = self.map.get_mut(&key) {
-            r.entry
-                .downcast_mut::<T>()
-                .ok_or_else(|| TableError::WrongType)
-        } else {
-            Err(TableError::NotPresent)
-        }
-    }
-
-    /// Get a mutable reference to a resource a a `&mut dyn Any`.
-    pub fn get_as_any_mut(&mut self, key: u32) -> Result<&mut dyn Any, TableError> {
-        if let Some(r) = self.map.get_mut(&key) {
-            Ok(&mut *r.entry)
-        } else {
-            Err(TableError::NotPresent)
-        }
-    }
-
-    /// Same as `get`, but typed
-    pub fn get_resource<T: Any + Sized>(&self, key: &Resource<T>) -> Result<&T, TableError> {
-        self.get(key.rep())
-    }
-
-    /// Same as `get_mut`, but typed
-    pub fn get_resource_mut<T: Any + Sized>(
-        &mut self,
-        key: &Resource<T>,
-    ) -> Result<&mut T, TableError> {
-        self.get_mut(key.rep())
-    }
-
-    fn delete_entry(&mut self, key: u32) -> Result<TableEntry, TableError> {
-        if !self
-            .map
-            .get(&key)
-            .ok_or(TableError::NotPresent)?
-            .children
-            .is_empty()
-        {
-            return Err(TableError::HasChildren);
-        }
-        let e = self.map.remove(&key).unwrap();
-        if let Some(parent) = e.parent {
-            // Remove deleted resource from parent's child list.
-            // Parent must still be present because it cant be deleted while still having
-            // children:
-            self.map
-                .get_mut(&parent)
-                .expect("missing parent")
-                .remove_child(key);
-        }
-        Ok(e)
-    }
-
-    /// Remove a resource at a given index from the table.
-    ///
-    /// If this method fails, the resource remains in the table.
-    ///
-    /// May fail with [`TableError::HasChildren`] if the resource has any live
-    /// children.
-    pub fn delete<T: Any + Sized>(&mut self, key: u32) -> Result<T, TableError> {
-        let e = self.delete_entry(key)?;
-        match e.entry.downcast::<T>() {
-            Ok(v) => Ok(*v),
-            Err(entry) => {
-                // Re-insert into parent list
-                if let Some(parent) = e.parent {
-                    self.map
-                        .get_mut(&parent)
-                        .expect("already checked parent exists")
-                        .add_child(key);
-                }
-                // Insert the value back
-                self.map.insert(
-                    key,
-                    TableEntry {
-                        entry,
-                        children: e.children,
-                        parent: e.parent,
-                    },
-                );
-                Err(TableError::WrongType)
-            }
-        }
-    }
-
-    /// Same as `delete`, but typed
-    pub fn delete_resource<T>(&mut self, resource: Resource<T>) -> Result<T, TableError>
-    where
-        T: Any,
-    {
-        debug_assert!(resource.owned());
-        self.delete(resource.rep())
-    }
-
-    /// Zip the values of the map with mutable references to table entries corresponding to each
-    /// key. As the keys in the [HashMap] are unique, this iterator can give mutable references
-    /// with the same lifetime as the mutable reference to the [Table].
-    pub fn iter_entries<'a, T>(
-        &'a mut self,
-        map: HashMap<u32, T>,
-    ) -> impl Iterator<Item = (Result<&'a mut dyn Any, TableError>, T)> {
-        map.into_iter().map(move |(k, v)| {
-            let item = self
-                .map
-                .get_mut(&k)
-                .map(|e| Box::as_mut(&mut e.entry))
-                // Safety: extending the lifetime of the mutable reference.
-                .map(|item| unsafe { &mut *(item as *mut dyn Any) })
-                .ok_or(TableError::NotPresent);
-            (item, v)
-        })
-    }
-}
-
-impl Default for Table {
-    fn default() -> Self {
-        Table::new()
-    }
-}
diff --git a/crates/wasi/src/preview2/tcp.rs b/crates/wasi/src/preview2/tcp.rs
deleted file mode 100644
index 434eeb3aeead..000000000000
--- a/crates/wasi/src/preview2/tcp.rs
+++ /dev/null
@@ -1,296 +0,0 @@
-use super::{HostInputStream, HostOutputStream, StreamError};
-use crate::preview2::{
-    with_ambient_tokio_runtime, AbortOnDropJoinHandle, InputStream, OutputStream, Subscribe,
-};
-use anyhow::{Error, Result};
-use cap_net_ext::{AddressFamily, Blocking, TcpListenerExt};
-use cap_std::net::TcpListener;
-use io_lifetimes::raw::{FromRawSocketlike, IntoRawSocketlike};
-use std::io;
-use std::mem;
-use std::sync::Arc;
-use tokio::io::Interest;
-
-/// The state of a TCP socket.
-///
-/// This represents the various states a socket can be in during the
-/// activities of binding, listening, accepting, and connecting.
-pub(crate) enum TcpState {
-    /// The initial state for a newly-created socket.
-    Default,
-
-    /// Binding started via `start_bind`.
-    BindStarted,
-
-    /// Binding finished via `finish_bind`. The socket has an address but
-    /// is not yet listening for connections.
-    Bound,
-
-    /// Listening started via `listen_start`.
-    ListenStarted,
-
-    /// The socket is now listening and waiting for an incoming connection.
-    Listening,
-
-    /// An outgoing connection is started via `start_connect`.
-    Connecting,
-
-    /// An outgoing connection is ready to be established.
-    ConnectReady,
-
-    /// An outgoing connection has been established.
-    Connected,
-}
-
-/// A host TCP socket, plus associated bookkeeping.
-///
-/// The inner state is wrapped in an Arc because the same underlying socket is
-/// used for implementing the stream types.
-pub struct TcpSocket {
-    /// The part of a `TcpSocket` which is reference-counted so that we
-    /// can pass it to async tasks.
-    pub(crate) inner: Arc<tokio::net::TcpStream>,
-
-    /// The current state in the bind/listen/accept/connect progression.
-    pub(crate) tcp_state: TcpState,
-
-    /// The desired listen queue size. Set to None to use the system's default.
-    pub(crate) listen_backlog_size: Option<i32>,
-}
-
-pub(crate) struct TcpReadStream {
-    stream: Arc<tokio::net::TcpStream>,
-    closed: bool,
-}
-
-impl TcpReadStream {
-    fn new(stream: Arc<tokio::net::TcpStream>) -> Self {
-        Self {
-            stream,
-            closed: false,
-        }
-    }
-}
-
-#[async_trait::async_trait]
-impl HostInputStream for TcpReadStream {
-    fn read(&mut self, size: usize) -> Result<bytes::Bytes, StreamError> {
-        if self.closed {
-            return Err(StreamError::Closed);
-        }
-        if size == 0 {
-            return Ok(bytes::Bytes::new());
-        }
-
-        let mut buf = bytes::BytesMut::with_capacity(size);
-        let n = match self.stream.try_read_buf(&mut buf) {
-            // A 0-byte read indicates that the stream has closed.
-            Ok(0) => {
-                self.closed = true;
-                0
-            }
-            Ok(n) => n,
-
-            // Failing with `EWOULDBLOCK` is how we differentiate between a closed channel and no
-            // data to read right now.
-            Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => 0,
-
-            Err(e) => {
-                self.closed = true;
-                return Err(StreamError::LastOperationFailed(e.into()));
-            }
-        };
-
-        buf.truncate(n);
-        Ok(buf.freeze())
-    }
-}
-
-#[async_trait::async_trait]
-impl Subscribe for TcpReadStream {
-    async fn ready(&mut self) {
-        if self.closed {
-            return;
-        }
-        self.stream.readable().await.unwrap();
-    }
-}
-
-const SOCKET_READY_SIZE: usize = 1024 * 1024 * 1024;
-
-pub(crate) struct TcpWriteStream {
-    stream: Arc<tokio::net::TcpStream>,
-    last_write: LastWrite,
-}
-
-enum LastWrite {
-    Waiting(AbortOnDropJoinHandle<Result<()>>),
-    Error(Error),
-    Done,
-}
-
-impl TcpWriteStream {
-    pub(crate) fn new(stream: Arc<tokio::net::TcpStream>) -> Self {
-        Self {
-            stream,
-            last_write: LastWrite::Done,
-        }
-    }
-
-    /// Write `bytes` in a background task, remembering the task handle for use in a future call to
-    /// `write_ready`
-    fn background_write(&mut self, mut bytes: bytes::Bytes) {
-        assert!(matches!(self.last_write, LastWrite::Done));
-
-        let stream = self.stream.clone();
-        self.last_write = LastWrite::Waiting(crate::preview2::spawn(async move {
-            // Note: we are not using the AsyncWrite impl here, and instead using the TcpStream
-            // primitive try_write, which goes directly to attempt a write with mio. This has
-            // two advantages: 1. this operation takes a &TcpStream instead of a &mut TcpStream
-            // required to AsyncWrite, and 2. it eliminates any buffering in tokio we may need
-            // to flush.
-            while !bytes.is_empty() {
-                stream.writable().await?;
-                match stream.try_write(&bytes) {
-                    Ok(n) => {
-                        let _ = bytes.split_to(n);
-                    }
-                    Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => continue,
-                    Err(e) => return Err(e.into()),
-                }
-            }
-
-            Ok(())
-        }));
-    }
-}
-
-impl HostOutputStream for TcpWriteStream {
-    fn write(&mut self, mut bytes: bytes::Bytes) -> Result<(), StreamError> {
-        match self.last_write {
-            LastWrite::Done => {}
-            LastWrite::Waiting(_) | LastWrite::Error(_) => {
-                return Err(StreamError::Trap(anyhow::anyhow!(
-                    "unpermitted: must call check_write first"
-                )));
-            }
-        }
-        while !bytes.is_empty() {
-            match self.stream.try_write(&bytes) {
-                Ok(n) => {
-                    let _ = bytes.split_to(n);
-                }
-
-                Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => {
-                    // As `try_write` indicated that it would have blocked, we'll perform the write
-                    // in the background to allow us to return immediately.
-                    self.background_write(bytes);
-
-                    return Ok(());
-                }
-
-                Err(e) => return Err(StreamError::LastOperationFailed(e.into())),
-            }
-        }
-
-        Ok(())
-    }
-
-    fn flush(&mut self) -> Result<(), StreamError> {
-        // `flush` is a no-op here, as we're not managing any internal buffer. Additionally,
-        // `write_ready` will join the background write task if it's active, so following `flush`
-        // with `write_ready` will have the desired effect.
-        Ok(())
-    }
-
-    fn check_write(&mut self) -> Result<usize, StreamError> {
-        match mem::replace(&mut self.last_write, LastWrite::Done) {
-            LastWrite::Waiting(task) => {
-                self.last_write = LastWrite::Waiting(task);
-                return Ok(0);
-            }
-            LastWrite::Done => {}
-            LastWrite::Error(e) => return Err(StreamError::LastOperationFailed(e.into())),
-        }
-
-        let writable = self.stream.writable();
-        futures::pin_mut!(writable);
-        if super::poll_noop(writable).is_none() {
-            return Ok(0);
-        }
-        Ok(SOCKET_READY_SIZE)
-    }
-}
-
-#[async_trait::async_trait]
-impl Subscribe for TcpWriteStream {
-    async fn ready(&mut self) {
-        if let LastWrite::Waiting(task) = &mut self.last_write {
-            self.last_write = match task.await {
-                Ok(()) => LastWrite::Done,
-                Err(e) => LastWrite::Error(e),
-            };
-        }
-        if let LastWrite::Done = self.last_write {
-            self.stream.writable().await.unwrap();
-        }
-    }
-}
-
-impl TcpSocket {
-    /// Create a new socket in the given family.
-    pub fn new(family: AddressFamily) -> io::Result<Self> {
-        // Create a new host socket and set it to non-blocking, which is needed
-        // by our async implementation.
-        let tcp_listener = TcpListener::new(family, Blocking::No)?;
-        Self::from_tcp_listener(tcp_listener)
-    }
-
-    /// Create a `TcpSocket` from an existing socket.
-    ///
-    /// The socket must be in non-blocking mode.
-    pub fn from_tcp_stream(tcp_socket: cap_std::net::TcpStream) -> io::Result<Self> {
-        let tcp_listener = TcpListener::from(rustix::fd::OwnedFd::from(tcp_socket));
-        Self::from_tcp_listener(tcp_listener)
-    }
-
-    pub fn from_tcp_listener(tcp_listener: cap_std::net::TcpListener) -> io::Result<Self> {
-        let fd = tcp_listener.into_raw_socketlike();
-        let std_stream = unsafe { std::net::TcpStream::from_raw_socketlike(fd) };
-        let stream = with_ambient_tokio_runtime(|| tokio::net::TcpStream::try_from(std_stream))?;
-
-        Ok(Self {
-            inner: Arc::new(stream),
-            tcp_state: TcpState::Default,
-            listen_backlog_size: None,
-        })
-    }
-
-    pub fn tcp_socket(&self) -> &tokio::net::TcpStream {
-        &self.inner
-    }
-
-    /// Create the input/output stream pair for a tcp socket.
-    pub fn as_split(&self) -> (InputStream, OutputStream) {
-        let input = Box::new(TcpReadStream::new(self.inner.clone()));
-        let output = Box::new(TcpWriteStream::new(self.inner.clone()));
-        (InputStream::Host(input), output)
-    }
-}
-
-#[async_trait::async_trait]
-impl Subscribe for TcpSocket {
-    async fn ready(&mut self) {
-        // Some states are ready immediately.
-        match self.tcp_state {
-            TcpState::BindStarted | TcpState::ListenStarted | TcpState::ConnectReady => return,
-            _ => {}
-        }
-
-        // FIXME: Add `Interest::ERROR` when we update to tokio 1.32.
-        self.inner
-            .ready(Interest::READABLE | Interest::WRITABLE)
-            .await
-            .unwrap();
-    }
-}
diff --git a/crates/wasi/src/random.rs b/crates/wasi/src/random.rs
new file mode 100644
index 000000000000..4a0b33f29ab5
--- /dev/null
+++ b/crates/wasi/src/random.rs
@@ -0,0 +1,58 @@
+use cap_rand::RngCore;
+
+/// Implement `insecure-random` using a deterministic cycle of bytes.
+pub struct Deterministic {
+    cycle: std::iter::Cycle<std::vec::IntoIter<u8>>,
+}
+
+impl Deterministic {
+    pub fn new(bytes: Vec<u8>) -> Self {
+        Deterministic {
+            cycle: bytes.into_iter().cycle(),
+        }
+    }
+}
+
+impl RngCore for Deterministic {
+    fn next_u32(&mut self) -> u32 {
+        let b0 = self.cycle.next().expect("infinite sequence");
+        let b1 = self.cycle.next().expect("infinite sequence");
+        let b2 = self.cycle.next().expect("infinite sequence");
+        let b3 = self.cycle.next().expect("infinite sequence");
+        ((b0 as u32) << 24) + ((b1 as u32) << 16) + ((b2 as u32) << 8) + (b3 as u32)
+    }
+    fn next_u64(&mut self) -> u64 {
+        let w0 = self.next_u32();
+        let w1 = self.next_u32();
+        ((w0 as u64) << 32) + (w1 as u64)
+    }
+    fn fill_bytes(&mut self, buf: &mut [u8]) {
+        for b in buf.iter_mut() {
+            *b = self.cycle.next().expect("infinite sequence");
+        }
+    }
+    fn try_fill_bytes(&mut self, buf: &mut [u8]) -> Result<(), cap_rand::Error> {
+        self.fill_bytes(buf);
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    #[test]
+    fn deterministic() {
+        let mut det = Deterministic::new(vec![1, 2, 3, 4]);
+        let mut buf = vec![0; 1024];
+        det.try_fill_bytes(&mut buf).expect("get randomness");
+        for (ix, b) in buf.iter().enumerate() {
+            assert_eq!(*b, (ix % 4) as u8 + 1)
+        }
+    }
+}
+
+pub fn thread_rng() -> Box<dyn RngCore + Send> {
+    use cap_rand::{Rng, SeedableRng};
+    let mut rng = cap_rand::thread_rng(cap_rand::ambient_authority());
+    Box::new(cap_rand::rngs::StdRng::from_seed(rng.gen()))
+}
diff --git a/crates/wasi/src/runtime.rs b/crates/wasi/src/runtime.rs
new file mode 100644
index 000000000000..dc29fef97239
--- /dev/null
+++ b/crates/wasi/src/runtime.rs
@@ -0,0 +1,188 @@
+//! This module provides an "ambient Tokio runtime"
+//! [`with_ambient_tokio_runtime`]. Embedders of wasmtime-wasi may do so from
+//! synchronous Rust, and not use tokio directly. The implementation of
+//! wasmtime-wasi requires a tokio executor in a way that is [deeply tied to
+//! its
+//! design](https://github.com/bytecodealliance/wasmtime/issues/7973#issuecomment-1960513214).
+//! When used from a sychrnonous wasmtime context, this module provides the
+//! wrapper function [`in_tokio`] used throughout the shim implementations of
+//! synchronous component binding `Host` traits in terms of the async ones.
+//!
+//! This module also provides a thin wrapper on tokio's tasks.
+//! [`AbortOnDropJoinHandle`], which is exactly like a
+//! [`tokio::task::JoinHandle`] except for the obvious behavioral change. This
+//! whole crate, and any child crates which spawn tasks as part of their
+//! implementations, should please use this crate's [`spawn`] and
+//! [`spawn_blocking`] over tokio's. so we wanted the type name to stick out
+//! if someone misses it.
+//!
+//! Each of these facilities should be used by dependencies of wasmtime-wasi
+//! which when implementing component bindings.
+
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+pub(crate) static RUNTIME: once_cell::sync::Lazy<tokio::runtime::Runtime> =
+    once_cell::sync::Lazy::new(|| {
+        tokio::runtime::Builder::new_multi_thread()
+            .enable_time()
+            .enable_io()
+            .build()
+            .unwrap()
+    });
+
+/// Exactly like a [`tokio::task::JoinHandle`], except that it aborts the task when
+/// the handle is dropped.
+///
+/// This behavior makes it easier to tie a worker task to the lifetime of a Resource
+/// by keeping this handle owned by the Resource.
+#[derive(Debug)]
+pub struct AbortOnDropJoinHandle<T>(tokio::task::JoinHandle<T>);
+impl<T> AbortOnDropJoinHandle<T> {
+    /// Abort the task and wait for it to finish. Optionally returns the result
+    /// of the task if it ran to completion prior to being aborted.
+    pub(crate) async fn abort_wait(mut self) -> Option<T> {
+        self.0.abort();
+        match (&mut self.0).await {
+            Ok(value) => Some(value),
+            Err(err) if err.is_cancelled() => None,
+            Err(err) => std::panic::resume_unwind(err.into_panic()),
+        }
+    }
+}
+impl<T> Drop for AbortOnDropJoinHandle<T> {
+    fn drop(&mut self) {
+        self.0.abort()
+    }
+}
+impl<T> std::ops::Deref for AbortOnDropJoinHandle<T> {
+    type Target = tokio::task::JoinHandle<T>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+impl<T> std::ops::DerefMut for AbortOnDropJoinHandle<T> {
+    fn deref_mut(&mut self) -> &mut tokio::task::JoinHandle<T> {
+        &mut self.0
+    }
+}
+impl<T> From<tokio::task::JoinHandle<T>> for AbortOnDropJoinHandle<T> {
+    fn from(jh: tokio::task::JoinHandle<T>) -> Self {
+        AbortOnDropJoinHandle(jh)
+    }
+}
+impl<T> Future for AbortOnDropJoinHandle<T> {
+    type Output = T;
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        match Pin::new(&mut self.as_mut().0).poll(cx) {
+            Poll::Pending => Poll::Pending,
+            Poll::Ready(r) => Poll::Ready(r.expect("child task panicked")),
+        }
+    }
+}
+
+pub fn spawn<F>(f: F) -> AbortOnDropJoinHandle<F::Output>
+where
+    F: Future + Send + 'static,
+    F::Output: Send + 'static,
+{
+    let j = with_ambient_tokio_runtime(|| tokio::task::spawn(f));
+    AbortOnDropJoinHandle(j)
+}
+
+pub fn spawn_blocking<F, R>(f: F) -> AbortOnDropJoinHandle<R>
+where
+    F: FnOnce() -> R + Send + 'static,
+    R: Send + 'static,
+{
+    let j = with_ambient_tokio_runtime(|| tokio::task::spawn_blocking(f));
+    AbortOnDropJoinHandle(j)
+}
+
+pub fn in_tokio<F: Future>(f: F) -> F::Output {
+    match tokio::runtime::Handle::try_current() {
+        Ok(h) => {
+            let _enter = h.enter();
+            h.block_on(f)
+        }
+        // The `yield_now` here is non-obvious and if you're reading this
+        // you're likely curious about why it's here. This is currently required
+        // to get some features of "sync mode" working correctly, such as with
+        // the CLI. To illustrate why this is required, consider a program
+        // organized as:
+        //
+        // * A program has a `pollable` that it's waiting on.
+        // * This `pollable` is always ready .
+        // * Actually making the corresponding operation ready, however,
+        //   requires some background work on Tokio's part.
+        // * The program is looping on "wait for readiness" coupled with
+        //   performing the operation.
+        //
+        // In this situation this program ends up infinitely looping in waiting
+        // for pollables. The reason appears to be that when we enter the tokio
+        // runtime here it doesn't necessary yield to background work because
+        // the provided future `f` is ready immediately. The future `f` will run
+        // through the list of pollables and determine one of them is ready.
+        //
+        // Historically this happened with UDP sockets. A test send a datagram
+        // from one socket to another and the other socket infinitely didn't
+        // receive the data. This appeared to be because the server socket was
+        // waiting on `READABLE | WRITABLE` (which is itself a bug but ignore
+        // that) and the socket was currently in the "writable" state but never
+        // ended up receiving a notification for the "readable" state. Moving
+        // the socket to "readable" would require Tokio to perform some
+        // background work via epoll/kqueue/handle events but if the future
+        // provided here is always ready, then that never happened.
+        //
+        // Thus the `yield_now()` is an attempt to force Tokio to go do some
+        // background work eventually and look at new interest masks for
+        // example. This is a bit of a kludge but everything's already a bit
+        // wonky in synchronous mode anyway. Note that this is hypothesized to
+        // not be an issue in async mode because async mode typically has the
+        // Tokio runtime in a separate thread or otherwise participating in a
+        // larger application, it's only here in synchronous mode where we
+        // effectively own the runtime that we need some special care.
+        Err(_) => {
+            let _enter = RUNTIME.enter();
+            RUNTIME.block_on(async move {
+                tokio::task::yield_now().await;
+                f.await
+            })
+        }
+    }
+}
+
+/// Executes the closure `f` with an "ambient Tokio runtime" which basically
+/// means that if code in `f` tries to get a runtime `Handle` it'll succeed.
+///
+/// If a `Handle` is already available, e.g. in async contexts, then `f` is run
+/// immediately. Otherwise for synchronous contexts this crate's fallback
+/// runtime is configured and then `f` is executed.
+pub fn with_ambient_tokio_runtime<R>(f: impl FnOnce() -> R) -> R {
+    match tokio::runtime::Handle::try_current() {
+        Ok(_) => f(),
+        Err(_) => {
+            let _enter = RUNTIME.enter();
+            f()
+        }
+    }
+}
+
+/// Attempts to get the result of a `future`.
+///
+/// This function does not block and will poll the provided future once. If the
+/// result is here then `Some` is returned, otherwise `None` is returned.
+///
+/// Note that by polling `future` this means that `future` must be re-polled
+/// later if it's to wake up a task.
+pub fn poll_noop<F>(future: Pin<&mut F>) -> Option<F::Output>
+where
+    F: Future,
+{
+    let mut task = Context::from_waker(futures::task::noop_waker_ref());
+    match future.poll(&mut task) {
+        Poll::Ready(result) => Some(result),
+        Poll::Pending => None,
+    }
+}
diff --git a/crates/wasi/src/stdio.rs b/crates/wasi/src/stdio.rs
new file mode 100644
index 000000000000..4fb359f394fb
--- /dev/null
+++ b/crates/wasi/src/stdio.rs
@@ -0,0 +1,616 @@
+use crate::bindings::cli::{
+    stderr, stdin, stdout, terminal_input, terminal_output, terminal_stderr, terminal_stdin,
+    terminal_stdout,
+};
+use crate::bindings::io::streams;
+use crate::pipe;
+use crate::{
+    HostInputStream, HostOutputStream, StreamError, StreamResult, Subscribe, WasiImpl, WasiView,
+};
+use bytes::Bytes;
+use std::io::IsTerminal;
+use std::sync::Arc;
+use tokio::sync::Mutex;
+use wasmtime::component::Resource;
+
+/// A trait used to represent the standard input to a guest program.
+///
+/// This is used to implement various WASI APIs via the method implementations
+/// below.
+///
+/// Built-in implementations are provided for [`Stdin`],
+/// [`pipe::MemoryInputPipe`], and [`pipe::ClosedInputStream`].
+pub trait StdinStream: Send {
+    /// Creates a fresh stream which is reading stdin.
+    ///
+    /// Note that the returned stream must share state with all other streams
+    /// previously created. Guests may create multiple handles to the same stdin
+    /// and they should all be synchronized in their progress through the
+    /// program's input.
+    ///
+    /// Note that this means that if one handle becomes ready for reading they
+    /// all become ready for reading. Subsequently if one is read from it may
+    /// mean that all the others are no longer ready for reading. This is
+    /// basically a consequence of the way the WIT APIs are designed today.
+    fn stream(&self) -> Box<dyn HostInputStream>;
+
+    /// Returns whether this stream is backed by a TTY.
+    fn isatty(&self) -> bool;
+}
+
+impl StdinStream for pipe::MemoryInputPipe {
+    fn stream(&self) -> Box<dyn HostInputStream> {
+        Box::new(self.clone())
+    }
+
+    fn isatty(&self) -> bool {
+        false
+    }
+}
+
+impl StdinStream for pipe::ClosedInputStream {
+    fn stream(&self) -> Box<dyn HostInputStream> {
+        Box::new(*self)
+    }
+
+    fn isatty(&self) -> bool {
+        false
+    }
+}
+
+/// An impl of [`StdinStream`] built on top of [`crate::pipe::AsyncReadStream`].
+//
+// Note the usage of `tokio::sync::Mutex` here as opposed to a
+// `std::sync::Mutex`. This is intentionally done to implement the `Subscribe`
+// variant of this trait. Note that in doing so we're left with the quandry of
+// how to implement methods of `HostInputStream` since those methods are not
+// `async`. They're currently implemented with `try_lock`, which then raises the
+// question of what to do on contention. Currently traps are returned.
+//
+// Why should it be ok to return a trap? In general concurrency/contention
+// shouldn't return a trap since it should be able to happen normally. The
+// current assumption, though, is that WASI stdin/stdout streams are special
+// enough that the contention case should never come up in practice. Currently
+// in WASI there is no actually concurrency, there's just the items in a single
+// `Store` and that store owns all of its I/O in a single Tokio task. There's no
+// means to actually spawn multiple Tokio tasks that use the same store. This
+// means at the very least that there's zero parallelism. Due to the lack of
+// multiple tasks that also means that there's no concurrency either.
+//
+// This `AsyncStdinStream` wrapper is only intended to be used by the WASI
+// bindings themselves. It's possible for the host to take this and work with it
+// on its own task, but that's niche enough it's not designed for.
+//
+// Overall that means that the guest is either calling `Subscribe` or it's
+// calling `HostInputStream` methods. This means that there should never be
+// contention between the two at this time. This may all change in the future
+// with WASI 0.3, but perhaps we'll have a better story for stdio at that time
+// (see the doc block on the `HostOutputStream` impl below)
+pub struct AsyncStdinStream(Arc<Mutex<crate::pipe::AsyncReadStream>>);
+
+impl AsyncStdinStream {
+    pub fn new(s: crate::pipe::AsyncReadStream) -> Self {
+        Self(Arc::new(Mutex::new(s)))
+    }
+}
+
+impl StdinStream for AsyncStdinStream {
+    fn stream(&self) -> Box<dyn HostInputStream> {
+        Box::new(Self(self.0.clone()))
+    }
+    fn isatty(&self) -> bool {
+        false
+    }
+}
+
+#[async_trait::async_trait]
+impl HostInputStream for AsyncStdinStream {
+    fn read(&mut self, size: usize) -> Result<bytes::Bytes, StreamError> {
+        match self.0.try_lock() {
+            Ok(mut stream) => stream.read(size),
+            Err(_) => Err(StreamError::trap("concurrent reads are not supported")),
+        }
+    }
+    fn skip(&mut self, size: usize) -> Result<usize, StreamError> {
+        match self.0.try_lock() {
+            Ok(mut stream) => stream.skip(size),
+            Err(_) => Err(StreamError::trap("concurrent skips are not supported")),
+        }
+    }
+    async fn cancel(&mut self) {
+        // Cancel the inner stream if we're the last reference to it:
+        if let Some(mutex) = Arc::get_mut(&mut self.0) {
+            match mutex.try_lock() {
+                Ok(mut stream) => stream.cancel().await,
+                Err(_) => {}
+            }
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl Subscribe for AsyncStdinStream {
+    async fn ready(&mut self) {
+        self.0.lock().await.ready().await
+    }
+}
+
+mod worker_thread_stdin;
+pub use self::worker_thread_stdin::{stdin, Stdin};
+
+/// Similar to [`StdinStream`], except for output.
+pub trait StdoutStream: Send {
+    /// Returns a fresh new stream which can write to this output stream.
+    ///
+    /// Note that all output streams should output to the same logical source.
+    /// This means that it's possible for each independent stream to acquire a
+    /// separate "permit" to write and then act on that permit. Note that
+    /// additionally at this time once a permit is "acquired" there's no way to
+    /// release it, for example you can wait for readiness and then never
+    /// actually write in WASI. This means that acquisition of a permit for one
+    /// stream cannot discount the size of a permit another stream could
+    /// obtain.
+    ///
+    /// Implementations must be able to handle this
+    fn stream(&self) -> Box<dyn HostOutputStream>;
+
+    /// Returns whether this stream is backed by a TTY.
+    fn isatty(&self) -> bool;
+}
+
+impl StdoutStream for pipe::MemoryOutputPipe {
+    fn stream(&self) -> Box<dyn HostOutputStream> {
+        Box::new(self.clone())
+    }
+
+    fn isatty(&self) -> bool {
+        false
+    }
+}
+
+impl StdoutStream for pipe::SinkOutputStream {
+    fn stream(&self) -> Box<dyn HostOutputStream> {
+        Box::new(*self)
+    }
+
+    fn isatty(&self) -> bool {
+        false
+    }
+}
+
+impl StdoutStream for pipe::ClosedOutputStream {
+    fn stream(&self) -> Box<dyn HostOutputStream> {
+        Box::new(*self)
+    }
+
+    fn isatty(&self) -> bool {
+        false
+    }
+}
+
+/// This implementation will yield output streams that block on writes, and
+/// output directly to a file. If truly async output is required, [`AsyncStdoutStream`]
+/// should be used instead.
+pub struct OutputFile {
+    file: Arc<std::fs::File>,
+}
+
+impl OutputFile {
+    pub fn new(file: std::fs::File) -> Self {
+        Self {
+            file: Arc::new(file),
+        }
+    }
+}
+
+impl StdoutStream for OutputFile {
+    fn stream(&self) -> Box<dyn HostOutputStream> {
+        Box::new(OutputFileStream {
+            file: Arc::clone(&self.file),
+        })
+    }
+
+    fn isatty(&self) -> bool {
+        false
+    }
+}
+
+struct OutputFileStream {
+    file: Arc<std::fs::File>,
+}
+
+#[async_trait::async_trait]
+impl Subscribe for OutputFileStream {
+    async fn ready(&mut self) {}
+}
+
+impl HostOutputStream for OutputFileStream {
+    fn write(&mut self, bytes: Bytes) -> StreamResult<()> {
+        use std::io::Write;
+        self.file
+            .write_all(&bytes)
+            .map_err(|e| StreamError::LastOperationFailed(anyhow::anyhow!(e)))
+    }
+
+    fn flush(&mut self) -> StreamResult<()> {
+        use std::io::Write;
+        self.file
+            .flush()
+            .map_err(|e| StreamError::LastOperationFailed(anyhow::anyhow!(e)))
+    }
+
+    fn check_write(&mut self) -> StreamResult<usize> {
+        Ok(1024 * 1024)
+    }
+}
+
+/// This implementation will yield output streams that block on writes, as they
+/// inherit the implementation directly from the rust std library. A different
+/// implementation of [`StdoutStream`] will be necessary if truly async output
+/// streams are required.
+pub struct Stdout;
+
+/// Returns a stream that represents the host's standard out.
+///
+/// Suitable for passing to
+/// [`WasiCtxBuilder::stdout`](crate::WasiCtxBuilder::stdout).
+pub fn stdout() -> Stdout {
+    Stdout
+}
+
+impl StdoutStream for Stdout {
+    fn stream(&self) -> Box<dyn HostOutputStream> {
+        Box::new(OutputStream::Stdout)
+    }
+
+    fn isatty(&self) -> bool {
+        std::io::stdout().is_terminal()
+    }
+}
+
+/// This implementation will yield output streams that block on writes, as they
+/// inherit the implementation directly from the rust std library. A different
+/// implementation of [`StdoutStream`] will be necessary if truly async output
+/// streams are required.
+pub struct Stderr;
+
+/// Returns a stream that represents the host's standard err.
+///
+/// Suitable for passing to
+/// [`WasiCtxBuilder::stderr`](crate::WasiCtxBuilder::stderr).
+pub fn stderr() -> Stderr {
+    Stderr
+}
+
+impl StdoutStream for Stderr {
+    fn stream(&self) -> Box<dyn HostOutputStream> {
+        Box::new(OutputStream::Stderr)
+    }
+
+    fn isatty(&self) -> bool {
+        std::io::stderr().is_terminal()
+    }
+}
+
+enum OutputStream {
+    Stdout,
+    Stderr,
+}
+
+impl HostOutputStream for OutputStream {
+    fn write(&mut self, bytes: Bytes) -> StreamResult<()> {
+        use std::io::Write;
+        match self {
+            OutputStream::Stdout => std::io::stdout().write_all(&bytes),
+            OutputStream::Stderr => std::io::stderr().write_all(&bytes),
+        }
+        .map_err(|e| StreamError::LastOperationFailed(anyhow::anyhow!(e)))
+    }
+
+    fn flush(&mut self) -> StreamResult<()> {
+        use std::io::Write;
+        match self {
+            OutputStream::Stdout => std::io::stdout().flush(),
+            OutputStream::Stderr => std::io::stderr().flush(),
+        }
+        .map_err(|e| StreamError::LastOperationFailed(anyhow::anyhow!(e)))
+    }
+
+    fn check_write(&mut self) -> StreamResult<usize> {
+        Ok(1024 * 1024)
+    }
+}
+
+#[async_trait::async_trait]
+impl Subscribe for OutputStream {
+    async fn ready(&mut self) {}
+}
+
+/// A wrapper of [`crate::pipe::AsyncWriteStream`] that implements
+/// [`StdoutStream`]. Note that the [`HostOutputStream`] impl for this is not
+/// correct when used for interleaved async IO.
+//
+// Note that the use of `tokio::sync::Mutex` here is intentional, in addition to
+// the `try_lock()` calls below in the implementation of `HostOutputStream`. For
+// more information see the documentation on `AsyncStdinStream`.
+pub struct AsyncStdoutStream(Arc<Mutex<crate::pipe::AsyncWriteStream>>);
+
+impl AsyncStdoutStream {
+    pub fn new(s: crate::pipe::AsyncWriteStream) -> Self {
+        Self(Arc::new(Mutex::new(s)))
+    }
+}
+
+impl StdoutStream for AsyncStdoutStream {
+    fn stream(&self) -> Box<dyn HostOutputStream> {
+        Box::new(Self(self.0.clone()))
+    }
+    fn isatty(&self) -> bool {
+        false
+    }
+}
+
+// This implementation is known to be bogus. All check-writes and writes are
+// directed at the same underlying stream. The check-write/write protocol does
+// require the size returned by a check-write to be accepted by write, even if
+// other side-effects happen between those calls, and this implementation
+// permits another view (created by StdoutStream::stream()) of the same
+// underlying stream to accept a write which will invalidate a prior
+// check-write of another view.
+// Ultimately, the Std{in,out}Stream::stream() methods exist because many
+// different places in a linked component (which may itself contain many
+// modules) may need to access stdio without any coordination to keep those
+// accesses all using pointing to the same resource. So, we allow many
+// resources to be created. We have the reasonable expectation that programs
+// won't attempt to interleave async IO from these disparate uses of stdio.
+// If that expectation doesn't turn out to be true, and you find yourself at
+// this comment to correct it: sorry about that.
+#[async_trait::async_trait]
+impl HostOutputStream for AsyncStdoutStream {
+    fn check_write(&mut self) -> Result<usize, StreamError> {
+        match self.0.try_lock() {
+            Ok(mut stream) => stream.check_write(),
+            Err(_) => Err(StreamError::trap("concurrent writes are not supported")),
+        }
+    }
+    fn write(&mut self, bytes: Bytes) -> Result<(), StreamError> {
+        match self.0.try_lock() {
+            Ok(mut stream) => stream.write(bytes),
+            Err(_) => Err(StreamError::trap("concurrent writes not supported yet")),
+        }
+    }
+    fn flush(&mut self) -> Result<(), StreamError> {
+        match self.0.try_lock() {
+            Ok(mut stream) => stream.flush(),
+            Err(_) => Err(StreamError::trap("concurrent flushes not supported yet")),
+        }
+    }
+    async fn cancel(&mut self) {
+        // Cancel the inner stream if we're the last reference to it:
+        if let Some(mutex) = Arc::get_mut(&mut self.0) {
+            match mutex.try_lock() {
+                Ok(mut stream) => stream.cancel().await,
+                Err(_) => {}
+            }
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl Subscribe for AsyncStdoutStream {
+    async fn ready(&mut self) {
+        self.0.lock().await.ready().await
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum IsATTY {
+    Yes,
+    No,
+}
+
+impl<T> stdin::Host for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn get_stdin(&mut self) -> Result<Resource<streams::InputStream>, anyhow::Error> {
+        let stream = self.ctx().stdin.stream();
+        Ok(self.table().push(stream)?)
+    }
+}
+
+impl<T> stdout::Host for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn get_stdout(&mut self) -> Result<Resource<streams::OutputStream>, anyhow::Error> {
+        let stream = self.ctx().stdout.stream();
+        Ok(self.table().push(stream)?)
+    }
+}
+
+impl<T> stderr::Host for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn get_stderr(&mut self) -> Result<Resource<streams::OutputStream>, anyhow::Error> {
+        let stream = self.ctx().stderr.stream();
+        Ok(self.table().push(stream)?)
+    }
+}
+
+pub struct TerminalInput;
+pub struct TerminalOutput;
+
+impl<T> terminal_input::Host for WasiImpl<T> where T: WasiView {}
+impl<T> terminal_input::HostTerminalInput for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn drop(&mut self, r: Resource<TerminalInput>) -> anyhow::Result<()> {
+        self.table().delete(r)?;
+        Ok(())
+    }
+}
+impl<T> terminal_output::Host for WasiImpl<T> where T: WasiView {}
+impl<T> terminal_output::HostTerminalOutput for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn drop(&mut self, r: Resource<TerminalOutput>) -> anyhow::Result<()> {
+        self.table().delete(r)?;
+        Ok(())
+    }
+}
+impl<T> terminal_stdin::Host for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn get_terminal_stdin(&mut self) -> anyhow::Result<Option<Resource<TerminalInput>>> {
+        if self.ctx().stdin.isatty() {
+            let fd = self.table().push(TerminalInput)?;
+            Ok(Some(fd))
+        } else {
+            Ok(None)
+        }
+    }
+}
+impl<T> terminal_stdout::Host for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn get_terminal_stdout(&mut self) -> anyhow::Result<Option<Resource<TerminalOutput>>> {
+        if self.ctx().stdout.isatty() {
+            let fd = self.table().push(TerminalOutput)?;
+            Ok(Some(fd))
+        } else {
+            Ok(None)
+        }
+    }
+}
+impl<T> terminal_stderr::Host for WasiImpl<T>
+where
+    T: WasiView,
+{
+    fn get_terminal_stderr(&mut self) -> anyhow::Result<Option<Resource<TerminalOutput>>> {
+        if self.ctx().stderr.isatty() {
+            let fd = self.table().push(TerminalOutput)?;
+            Ok(Some(fd))
+        } else {
+            Ok(None)
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::stdio::StdoutStream;
+    use crate::write_stream::AsyncWriteStream;
+    use crate::{AsyncStdoutStream, HostOutputStream};
+    use anyhow::Result;
+    use bytes::Bytes;
+    use tokio::io::AsyncReadExt;
+
+    #[test]
+    fn memory_stdin_stream() {
+        // A StdinStream has the property that there are multiple
+        // HostInputStreams created, using the stream() method which are each
+        // views on the same shared state underneath. Consuming input on one
+        // stream results in consuming that input on all streams.
+        //
+        // The simplest way to measure this is to check if the MemoryInputPipe
+        // impl of StdinStream follows this property.
+
+        let pipe = super::pipe::MemoryInputPipe::new(
+            "the quick brown fox jumped over the three lazy dogs",
+        );
+
+        use super::StdinStream;
+
+        let mut view1 = pipe.stream();
+        let mut view2 = pipe.stream();
+
+        let read1 = view1.read(10).expect("read first 10 bytes");
+        assert_eq!(read1, "the quick ".as_bytes(), "first 10 bytes");
+        let read2 = view2.read(10).expect("read second 10 bytes");
+        assert_eq!(read2, "brown fox ".as_bytes(), "second 10 bytes");
+        let read3 = view1.read(10).expect("read third 10 bytes");
+        assert_eq!(read3, "jumped ove".as_bytes(), "third 10 bytes");
+        let read4 = view2.read(10).expect("read fourth 10 bytes");
+        assert_eq!(read4, "r the thre".as_bytes(), "fourth 10 bytes");
+    }
+
+    #[tokio::test]
+    async fn async_stdin_stream() {
+        // A StdinStream has the property that there are multiple
+        // HostInputStreams created, using the stream() method which are each
+        // views on the same shared state underneath. Consuming input on one
+        // stream results in consuming that input on all streams.
+        //
+        // AsyncStdinStream is a slightly more complex impl of StdinStream
+        // than the MemoryInputPipe above. We can create an AsyncReadStream
+        // from a file on the disk, and an AsyncStdinStream from that common
+        // stream, then check that the same property holds as above.
+
+        let dir = tempfile::tempdir().unwrap();
+        let mut path = std::path::PathBuf::from(dir.path());
+        path.push("file");
+        std::fs::write(&path, "the quick brown fox jumped over the three lazy dogs").unwrap();
+
+        let file = tokio::fs::File::open(&path)
+            .await
+            .expect("open created file");
+        let stdin_stream = super::AsyncStdinStream::new(crate::pipe::AsyncReadStream::new(file));
+
+        use super::StdinStream;
+
+        let mut view1 = stdin_stream.stream();
+        let mut view2 = stdin_stream.stream();
+
+        view1.ready().await;
+
+        let read1 = view1.read(10).expect("read first 10 bytes");
+        assert_eq!(read1, "the quick ".as_bytes(), "first 10 bytes");
+        let read2 = view2.read(10).expect("read second 10 bytes");
+        assert_eq!(read2, "brown fox ".as_bytes(), "second 10 bytes");
+        let read3 = view1.read(10).expect("read third 10 bytes");
+        assert_eq!(read3, "jumped ove".as_bytes(), "third 10 bytes");
+        let read4 = view2.read(10).expect("read fourth 10 bytes");
+        assert_eq!(read4, "r the thre".as_bytes(), "fourth 10 bytes");
+    }
+
+    #[tokio::test]
+    async fn async_stdout_stream_unblocks() {
+        let (mut read, write) = tokio::io::duplex(32);
+        let stdout = AsyncStdoutStream::new(AsyncWriteStream::new(32, write));
+
+        let task = tokio::task::spawn(async move {
+            let mut stream = stdout.stream();
+            blocking_write_and_flush(&mut *stream, "x".into())
+                .await
+                .unwrap();
+        });
+
+        let mut buf = [0; 100];
+        let n = read.read(&mut buf).await.unwrap();
+        assert_eq!(&buf[..n], b"x");
+
+        task.await.unwrap();
+    }
+
+    async fn blocking_write_and_flush(
+        s: &mut dyn HostOutputStream,
+        mut bytes: Bytes,
+    ) -> Result<()> {
+        while !bytes.is_empty() {
+            let permit = s.write_ready().await?;
+            let len = bytes.len().min(permit);
+            let chunk = bytes.split_to(len);
+            s.write(chunk)?;
+        }
+
+        s.flush()?;
+        s.write_ready().await?;
+        Ok(())
+    }
+}
diff --git a/crates/wasi/src/preview2/stdio/worker_thread_stdin.rs b/crates/wasi/src/stdio/worker_thread_stdin.rs
similarity index 95%
rename from crates/wasi/src/preview2/stdio/worker_thread_stdin.rs
rename to crates/wasi/src/stdio/worker_thread_stdin.rs
index cb2f50f2c61b..894bdd61affd 100644
--- a/crates/wasi/src/preview2/stdio/worker_thread_stdin.rs
+++ b/crates/wasi/src/stdio/worker_thread_stdin.rs
@@ -23,9 +23,9 @@
 //! This module is one that's likely to change over time though as new systems
 //! are encountered along with preexisting bugs.
 
-use crate::preview2::poll::Subscribe;
-use crate::preview2::stdio::StdinStream;
-use crate::preview2::{HostInputStream, StreamError};
+use crate::poll::Subscribe;
+use crate::stdio::StdinStream;
+use crate::{HostInputStream, StreamError};
 use bytes::{Bytes, BytesMut};
 use std::io::{IsTerminal, Read};
 use std::mem;
@@ -100,6 +100,10 @@ fn create() -> GlobalStdin {
 #[derive(Clone)]
 pub struct Stdin;
 
+/// Returns a stream that represents the host's standard input.
+///
+/// Suitable for passing to
+/// [`WasiCtxBuilder::stdin`](crate::WasiCtxBuilder::stdin).
 pub fn stdin() -> Stdin {
     Stdin
 }
diff --git a/crates/wasi/src/stream.rs b/crates/wasi/src/stream.rs
new file mode 100644
index 000000000000..251133cdac66
--- /dev/null
+++ b/crates/wasi/src/stream.rs
@@ -0,0 +1,265 @@
+use crate::poll::Subscribe;
+use anyhow::Result;
+use bytes::Bytes;
+
+/// Host trait for implementing the `wasi:io/streams.input-stream` resource: A
+/// bytestream which can be read from.
+#[async_trait::async_trait]
+pub trait HostInputStream: Subscribe {
+    /// Reads up to `size` bytes, returning a buffer holding these bytes on
+    /// success.
+    ///
+    /// This function does not block the current thread and is the equivalent of
+    /// a non-blocking read. On success all bytes read are returned through
+    /// `Bytes`, which is no larger than the `size` provided. If the returned
+    /// list of `Bytes` is empty then no data is ready to be read at this time.
+    ///
+    /// # Errors
+    ///
+    /// The [`StreamError`] return value communicates when this stream is
+    /// closed, when a read fails, or when a trap should be generated.
+    fn read(&mut self, size: usize) -> StreamResult<Bytes>;
+
+    /// Similar to `read`, except that it blocks until at least one byte can be
+    /// read.
+    async fn blocking_read(&mut self, size: usize) -> StreamResult<Bytes> {
+        self.ready().await;
+        self.read(size)
+    }
+
+    /// Same as the `read` method except that bytes are skipped.
+    ///
+    /// Note that this method is non-blocking like `read` and returns the same
+    /// errors.
+    fn skip(&mut self, nelem: usize) -> StreamResult<usize> {
+        let bs = self.read(nelem)?;
+        Ok(bs.len())
+    }
+
+    /// Similar to `skip`, except that it blocks until at least one byte can be
+    /// skipped.
+    async fn blocking_skip(&mut self, nelem: usize) -> StreamResult<usize> {
+        let bs = self.blocking_read(nelem).await?;
+        Ok(bs.len())
+    }
+
+    /// Cancel any asynchronous work and wait for it to wrap up.
+    async fn cancel(&mut self) {}
+}
+
+/// Representation of the `error` resource type in the `wasi:io/error`
+/// interface.
+///
+/// This is currently `anyhow::Error` to retain full type information for
+/// errors.
+pub type Error = anyhow::Error;
+
+pub type StreamResult<T> = Result<T, StreamError>;
+
+#[derive(Debug)]
+pub enum StreamError {
+    Closed,
+    LastOperationFailed(anyhow::Error),
+    Trap(anyhow::Error),
+}
+
+impl StreamError {
+    pub fn trap(msg: &str) -> StreamError {
+        StreamError::Trap(anyhow::anyhow!("{msg}"))
+    }
+}
+
+impl std::fmt::Display for StreamError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            StreamError::Closed => write!(f, "closed"),
+            StreamError::LastOperationFailed(e) => write!(f, "last operation failed: {e}"),
+            StreamError::Trap(e) => write!(f, "trap: {e}"),
+        }
+    }
+}
+
+impl std::error::Error for StreamError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            StreamError::Closed => None,
+            StreamError::LastOperationFailed(e) | StreamError::Trap(e) => e.source(),
+        }
+    }
+}
+
+impl From<wasmtime::component::ResourceTableError> for StreamError {
+    fn from(error: wasmtime::component::ResourceTableError) -> Self {
+        Self::Trap(error.into())
+    }
+}
+
+/// Host trait for implementing the `wasi:io/streams.output-stream` resource:
+/// A bytestream which can be written to.
+#[async_trait::async_trait]
+pub trait HostOutputStream: Subscribe {
+    /// Write bytes after obtaining a permit to write those bytes
+    ///
+    /// Prior to calling [`write`](Self::write) the caller must call
+    /// [`check_write`](Self::check_write), which resolves to a non-zero permit
+    ///
+    /// This method must never block.  The [`check_write`](Self::check_write)
+    /// permit indicates the maximum amount of bytes that are permitted to be
+    /// written in a single [`write`](Self::write) following the
+    /// [`check_write`](Self::check_write) resolution.
+    ///
+    /// # Errors
+    ///
+    /// Returns a [`StreamError`] if:
+    /// - stream is closed
+    /// - prior operation ([`write`](Self::write) or [`flush`](Self::flush)) failed
+    /// - caller performed an illegal operation (e.g. wrote more bytes than were permitted)
+    fn write(&mut self, bytes: Bytes) -> StreamResult<()>;
+
+    /// Trigger a flush of any bytes buffered in this stream implementation.
+    ///
+    /// This method may be called at any time and must never block.
+    ///
+    /// After this method is called, [`check_write`](Self::check_write) must
+    /// pend until flush is complete.
+    ///
+    /// When [`check_write`](Self::check_write) becomes ready after a flush,
+    /// that guarantees that all prior writes have been flushed from the
+    /// implementation successfully, or that any error associated with those
+    /// writes is reported in the return value of [`flush`](Self::flush) or
+    /// [`check_write`](Self::check_write)
+    ///
+    /// # Errors
+    ///
+    /// Returns a [`StreamError`] if:
+    /// - stream is closed
+    /// - prior operation ([`write`](Self::write) or [`flush`](Self::flush)) failed
+    /// - caller performed an illegal operation (e.g. wrote more bytes than were permitted)
+    fn flush(&mut self) -> StreamResult<()>;
+
+    /// Returns the number of bytes that are ready to be written to this stream.
+    ///
+    /// Zero bytes indicates that this stream is not currently ready for writing
+    /// and `ready()` must be awaited first.
+    ///
+    /// Note that this method does not block.
+    ///
+    /// # Errors
+    ///
+    /// Returns an [`StreamError`] if:
+    /// - stream is closed
+    /// - prior operation ([`write`](Self::write) or [`flush`](Self::flush)) failed
+    fn check_write(&mut self) -> StreamResult<usize>;
+
+    /// Perform a write of up to 4096 bytes, and then flush the stream. Block
+    /// until all of these operations are complete, or an error occurs.
+    ///
+    /// This is a convenience wrapper around the use of `check-write`,
+    /// `subscribe`, `write`, and `flush`, and is implemented with the
+    /// following pseudo-code:
+    ///
+    /// ```text
+    /// let pollable = this.subscribe();
+    /// while !contents.is_empty() {
+    ///     // Wait for the stream to become writable
+    ///     pollable.block();
+    ///     let Ok(n) = this.check-write(); // eliding error handling
+    ///     let len = min(n, contents.len());
+    ///     let (chunk, rest) = contents.split_at(len);
+    ///     this.write(chunk  );            // eliding error handling
+    ///     contents = rest;
+    /// }
+    /// this.flush();
+    /// // Wait for completion of `flush`
+    /// pollable.block();
+    /// // Check for any errors that arose during `flush`
+    /// let _ = this.check-write();         // eliding error handling
+    /// ```
+    async fn blocking_write_and_flush(&mut self, mut bytes: Bytes) -> StreamResult<()> {
+        loop {
+            let permit = self.write_ready().await?;
+            let len = bytes.len().min(permit);
+            let chunk = bytes.split_to(len);
+            self.write(chunk)?;
+            if bytes.is_empty() {
+                break;
+            }
+        }
+
+        self.flush()?;
+        self.write_ready().await?;
+
+        Ok(())
+    }
+
+    /// Repeatedly write a byte to a stream.
+    /// Important: this write must be non-blocking!
+    /// Returning an Err which downcasts to a [`StreamError`] will be
+    /// reported to Wasm as the empty error result. Otherwise, errors will trap.
+    fn write_zeroes(&mut self, nelem: usize) -> StreamResult<()> {
+        // TODO: We could optimize this to not allocate one big zeroed buffer, and instead write
+        // repeatedly from a 'static buffer of zeros.
+        let bs = Bytes::from_iter(core::iter::repeat(0).take(nelem));
+        self.write(bs)?;
+        Ok(())
+    }
+
+    /// Perform a write of up to 4096 zeroes, and then flush the stream.
+    /// Block until all of these operations are complete, or an error
+    /// occurs.
+    ///
+    /// This is a convenience wrapper around the use of `check-write`,
+    /// `subscribe`, `write-zeroes`, and `flush`, and is implemented with
+    /// the following pseudo-code:
+    ///
+    /// ```text
+    /// let pollable = this.subscribe();
+    /// while num_zeroes != 0 {
+    ///     // Wait for the stream to become writable
+    ///     pollable.block();
+    ///     let Ok(n) = this.check-write(); // eliding error handling
+    ///     let len = min(n, num_zeroes);
+    ///     this.write-zeroes(len);         // eliding error handling
+    ///     num_zeroes -= len;
+    /// }
+    /// this.flush();
+    /// // Wait for completion of `flush`
+    /// pollable.block();
+    /// // Check for any errors that arose during `flush`
+    /// let _ = this.check-write();         // eliding error handling
+    /// ```
+    async fn blocking_write_zeroes_and_flush(&mut self, nelem: usize) -> StreamResult<()> {
+        // TODO: We could optimize this to not allocate one big zeroed buffer, and instead write
+        // repeatedly from a 'static buffer of zeros.
+        let bs = Bytes::from_iter(core::iter::repeat(0).take(nelem));
+        self.blocking_write_and_flush(bs).await
+    }
+
+    /// Simultaneously waits for this stream to be writable and then returns how
+    /// much may be written or the last error that happened.
+    async fn write_ready(&mut self) -> StreamResult<usize> {
+        self.ready().await;
+        self.check_write()
+    }
+
+    /// Cancel any asynchronous work and wait for it to wrap up.
+    async fn cancel(&mut self) {}
+}
+
+#[async_trait::async_trait]
+impl Subscribe for Box<dyn HostOutputStream> {
+    async fn ready(&mut self) {
+        (**self).ready().await
+    }
+}
+
+#[async_trait::async_trait]
+impl Subscribe for Box<dyn HostInputStream> {
+    async fn ready(&mut self) {
+        (**self).ready().await
+    }
+}
+
+pub type InputStream = Box<dyn HostInputStream>;
+
+pub type OutputStream = Box<dyn HostOutputStream>;
diff --git a/crates/wasi/src/tcp.rs b/crates/wasi/src/tcp.rs
new file mode 100644
index 000000000000..32feef95a683
--- /dev/null
+++ b/crates/wasi/src/tcp.rs
@@ -0,0 +1,877 @@
+use crate::bindings::sockets::tcp::ErrorCode;
+use crate::host::network;
+use crate::network::SocketAddressFamily;
+use crate::runtime::{with_ambient_tokio_runtime, AbortOnDropJoinHandle};
+use crate::{
+    HostInputStream, HostOutputStream, InputStream, OutputStream, SocketResult, StreamError,
+    Subscribe,
+};
+use anyhow::{Error, Result};
+use cap_net_ext::AddressFamily;
+use futures::Future;
+use io_lifetimes::views::SocketlikeView;
+use io_lifetimes::AsSocketlike;
+use rustix::io::Errno;
+use rustix::net::sockopt;
+use std::io;
+use std::mem;
+use std::net::SocketAddr;
+use std::pin::Pin;
+use std::sync::Arc;
+use std::task::Poll;
+
+/// Value taken from rust std library.
+const DEFAULT_BACKLOG: u32 = 128;
+
+/// The state of a TCP socket.
+///
+/// This represents the various states a socket can be in during the
+/// activities of binding, listening, accepting, and connecting.
+enum TcpState {
+    /// The initial state for a newly-created socket.
+    Default(tokio::net::TcpSocket),
+
+    /// Binding started via `start_bind`.
+    BindStarted(tokio::net::TcpSocket),
+
+    /// Binding finished via `finish_bind`. The socket has an address but
+    /// is not yet listening for connections.
+    Bound(tokio::net::TcpSocket),
+
+    /// Listening started via `listen_start`.
+    ListenStarted(tokio::net::TcpSocket),
+
+    /// The socket is now listening and waiting for an incoming connection.
+    Listening {
+        listener: tokio::net::TcpListener,
+        pending_accept: Option<io::Result<tokio::net::TcpStream>>,
+    },
+
+    /// An outgoing connection is started via `start_connect`.
+    Connecting(Pin<Box<dyn Future<Output = io::Result<tokio::net::TcpStream>> + Send>>),
+
+    /// An outgoing connection is ready to be established.
+    ConnectReady(io::Result<tokio::net::TcpStream>),
+
+    /// An outgoing connection has been established.
+    Connected(Arc<tokio::net::TcpStream>),
+
+    Closed,
+}
+
+impl std::fmt::Debug for TcpState {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Default(_) => f.debug_tuple("Default").finish(),
+            Self::BindStarted(_) => f.debug_tuple("BindStarted").finish(),
+            Self::Bound(_) => f.debug_tuple("Bound").finish(),
+            Self::ListenStarted(_) => f.debug_tuple("ListenStarted").finish(),
+            Self::Listening { pending_accept, .. } => f
+                .debug_struct("Listening")
+                .field("pending_accept", pending_accept)
+                .finish(),
+            Self::Connecting(_) => f.debug_tuple("Connecting").finish(),
+            Self::ConnectReady(_) => f.debug_tuple("ConnectReady").finish(),
+            Self::Connected(_) => f.debug_tuple("Connected").finish(),
+            Self::Closed => write!(f, "Closed"),
+        }
+    }
+}
+
+/// A host TCP socket, plus associated bookkeeping.
+pub struct TcpSocket {
+    /// The current state in the bind/listen/accept/connect progression.
+    tcp_state: TcpState,
+
+    /// The desired listen queue size.
+    listen_backlog_size: u32,
+
+    family: SocketAddressFamily,
+
+    // The socket options below are not automatically inherited from the listener
+    // on all platforms. So we keep track of which options have been explicitly
+    // set and manually apply those values to newly accepted clients.
+    #[cfg(target_os = "macos")]
+    receive_buffer_size: Option<usize>,
+    #[cfg(target_os = "macos")]
+    send_buffer_size: Option<usize>,
+    #[cfg(target_os = "macos")]
+    hop_limit: Option<u8>,
+    #[cfg(target_os = "macos")]
+    keep_alive_idle_time: Option<std::time::Duration>,
+}
+
+impl TcpSocket {
+    /// Create a new socket in the given family.
+    pub fn new(family: AddressFamily) -> io::Result<Self> {
+        with_ambient_tokio_runtime(|| {
+            let (socket, family) = match family {
+                AddressFamily::Ipv4 => {
+                    let socket = tokio::net::TcpSocket::new_v4()?;
+                    (socket, SocketAddressFamily::Ipv4)
+                }
+                AddressFamily::Ipv6 => {
+                    let socket = tokio::net::TcpSocket::new_v6()?;
+                    sockopt::set_ipv6_v6only(&socket, true)?;
+                    (socket, SocketAddressFamily::Ipv6)
+                }
+            };
+
+            Self::from_state(TcpState::Default(socket), family)
+        })
+    }
+
+    /// Create a `TcpSocket` from an existing socket.
+    fn from_state(state: TcpState, family: SocketAddressFamily) -> io::Result<Self> {
+        Ok(Self {
+            tcp_state: state,
+            listen_backlog_size: DEFAULT_BACKLOG,
+            family,
+            #[cfg(target_os = "macos")]
+            receive_buffer_size: None,
+            #[cfg(target_os = "macos")]
+            send_buffer_size: None,
+            #[cfg(target_os = "macos")]
+            hop_limit: None,
+            #[cfg(target_os = "macos")]
+            keep_alive_idle_time: None,
+        })
+    }
+
+    fn as_std_view(&self) -> SocketResult<SocketlikeView<'_, std::net::TcpStream>> {
+        use crate::bindings::sockets::network::ErrorCode;
+
+        match &self.tcp_state {
+            TcpState::Default(socket) | TcpState::Bound(socket) => {
+                Ok(socket.as_socketlike_view::<std::net::TcpStream>())
+            }
+            TcpState::Connected(stream) => Ok(stream.as_socketlike_view::<std::net::TcpStream>()),
+            TcpState::Listening { listener, .. } => {
+                Ok(listener.as_socketlike_view::<std::net::TcpStream>())
+            }
+
+            TcpState::BindStarted(..)
+            | TcpState::ListenStarted(..)
+            | TcpState::Connecting(..)
+            | TcpState::ConnectReady(..)
+            | TcpState::Closed => Err(ErrorCode::InvalidState.into()),
+        }
+    }
+}
+
+impl TcpSocket {
+    pub fn start_bind(&mut self, local_address: SocketAddr) -> io::Result<()> {
+        let tokio_socket = match &self.tcp_state {
+            TcpState::Default(socket) => socket,
+            TcpState::BindStarted(..) => return Err(Errno::ALREADY.into()),
+            _ => return Err(Errno::ISCONN.into()),
+        };
+
+        network::util::validate_unicast(&local_address)?;
+        network::util::validate_address_family(&local_address, &self.family)?;
+
+        {
+            // Automatically bypass the TIME_WAIT state when the user is trying
+            // to bind to a specific port:
+            let reuse_addr = local_address.port() > 0;
+
+            // Unconditionally (re)set SO_REUSEADDR, even when the value is false.
+            // This ensures we're not accidentally affected by any socket option
+            // state left behind by a previous failed call to this method (start_bind).
+            network::util::set_tcp_reuseaddr(&tokio_socket, reuse_addr)?;
+
+            // Perform the OS bind call.
+            tokio_socket.bind(local_address).map_err(|error| {
+                match Errno::from_io_error(&error) {
+                    // From https://pubs.opengroup.org/onlinepubs/9699919799/functions/bind.html:
+                    // > [EAFNOSUPPORT] The specified address is not a valid address for the address family of the specified socket
+                    //
+                    // The most common reasons for this error should have already
+                    // been handled by our own validation slightly higher up in this
+                    // function. This error mapping is here just in case there is
+                    // an edge case we didn't catch.
+                    Some(Errno::AFNOSUPPORT) =>  io::Error::new(
+                        io::ErrorKind::InvalidInput,
+                        "The specified address is not a valid address for the address family of the specified socket",
+                    ),
+
+                    // See: https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-bind#:~:text=WSAENOBUFS
+                    // Windows returns WSAENOBUFS when the ephemeral ports have been exhausted.
+                    #[cfg(windows)]
+                    Some(Errno::NOBUFS) => io::Error::new(io::ErrorKind::AddrInUse, "no more free local ports"),
+
+                    _ => error,
+                }
+            })?;
+
+            self.tcp_state = match std::mem::replace(&mut self.tcp_state, TcpState::Closed) {
+                TcpState::Default(socket) => TcpState::BindStarted(socket),
+                _ => unreachable!(),
+            };
+
+            Ok(())
+        }
+    }
+
+    pub fn finish_bind(&mut self) -> SocketResult<()> {
+        match std::mem::replace(&mut self.tcp_state, TcpState::Closed) {
+            TcpState::BindStarted(socket) => {
+                self.tcp_state = TcpState::Bound(socket);
+                Ok(())
+            }
+            current_state => {
+                // Reset the state so that the outside world doesn't see this socket as closed
+                self.tcp_state = current_state;
+                Err(ErrorCode::NotInProgress.into())
+            }
+        }
+    }
+
+    pub fn start_connect(&mut self, remote_address: SocketAddr) -> SocketResult<()> {
+        match self.tcp_state {
+            TcpState::Default(..) => {}
+
+            TcpState::Connecting(..) | TcpState::ConnectReady(..) => {
+                return Err(ErrorCode::ConcurrencyConflict.into())
+            }
+
+            _ => return Err(ErrorCode::InvalidState.into()),
+        };
+
+        network::util::validate_unicast(&remote_address)?;
+        network::util::validate_remote_address(&remote_address)?;
+        network::util::validate_address_family(&remote_address, &self.family)?;
+
+        let TcpState::Default(tokio_socket) =
+            std::mem::replace(&mut self.tcp_state, TcpState::Closed)
+        else {
+            unreachable!();
+        };
+
+        let future = tokio_socket.connect(remote_address);
+
+        self.tcp_state = TcpState::Connecting(Box::pin(future));
+        Ok(())
+    }
+
+    pub fn finish_connect(&mut self) -> SocketResult<(InputStream, OutputStream)> {
+        let previous_state = std::mem::replace(&mut self.tcp_state, TcpState::Closed);
+        let result = match previous_state {
+            TcpState::ConnectReady(result) => result,
+            TcpState::Connecting(mut future) => {
+                let mut cx = std::task::Context::from_waker(futures::task::noop_waker_ref());
+                match with_ambient_tokio_runtime(|| future.as_mut().poll(&mut cx)) {
+                    Poll::Ready(result) => result,
+                    Poll::Pending => {
+                        self.tcp_state = TcpState::Connecting(future);
+                        return Err(ErrorCode::WouldBlock.into());
+                    }
+                }
+            }
+            previous_state => {
+                self.tcp_state = previous_state;
+                return Err(ErrorCode::NotInProgress.into());
+            }
+        };
+
+        match result {
+            Ok(stream) => {
+                let stream = Arc::new(stream);
+                self.tcp_state = TcpState::Connected(stream.clone());
+                let input: InputStream = Box::new(TcpReadStream::new(stream.clone()));
+                let output: OutputStream = Box::new(TcpWriteStream::new(stream));
+                Ok((input, output))
+            }
+            Err(err) => {
+                self.tcp_state = TcpState::Closed;
+                Err(err.into())
+            }
+        }
+    }
+
+    pub fn start_listen(&mut self) -> SocketResult<()> {
+        match std::mem::replace(&mut self.tcp_state, TcpState::Closed) {
+            TcpState::Bound(tokio_socket) => {
+                self.tcp_state = TcpState::ListenStarted(tokio_socket);
+                Ok(())
+            }
+            TcpState::ListenStarted(tokio_socket) => {
+                self.tcp_state = TcpState::ListenStarted(tokio_socket);
+                Err(ErrorCode::ConcurrencyConflict.into())
+            }
+            previous_state => {
+                self.tcp_state = previous_state;
+                Err(ErrorCode::InvalidState.into())
+            }
+        }
+    }
+
+    pub fn finish_listen(&mut self) -> SocketResult<()> {
+        let tokio_socket = match std::mem::replace(&mut self.tcp_state, TcpState::Closed) {
+            TcpState::ListenStarted(tokio_socket) => tokio_socket,
+            previous_state => {
+                self.tcp_state = previous_state;
+                return Err(ErrorCode::NotInProgress.into());
+            }
+        };
+
+        match with_ambient_tokio_runtime(|| tokio_socket.listen(self.listen_backlog_size)) {
+            Ok(listener) => {
+                self.tcp_state = TcpState::Listening {
+                    listener,
+                    pending_accept: None,
+                };
+                Ok(())
+            }
+            Err(err) => {
+                self.tcp_state = TcpState::Closed;
+
+                Err(match Errno::from_io_error(&err) {
+                    // See: https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-listen#:~:text=WSAEMFILE
+                    // According to the docs, `listen` can return EMFILE on Windows.
+                    // This is odd, because we're not trying to create a new socket
+                    // or file descriptor of any kind. So we rewrite it to less
+                    // surprising error code.
+                    //
+                    // At the time of writing, this behavior has never been experimentally
+                    // observed by any of the wasmtime authors, so we're relying fully
+                    // on Microsoft's documentation here.
+                    #[cfg(windows)]
+                    Some(Errno::MFILE) => Errno::NOBUFS.into(),
+
+                    _ => err.into(),
+                })
+            }
+        }
+    }
+
+    pub fn accept(&mut self) -> SocketResult<(Self, InputStream, OutputStream)> {
+        let TcpState::Listening {
+            listener,
+            pending_accept,
+        } = &mut self.tcp_state
+        else {
+            return Err(ErrorCode::InvalidState.into());
+        };
+
+        let result = match pending_accept.take() {
+            Some(result) => result,
+            None => {
+                let mut cx = std::task::Context::from_waker(futures::task::noop_waker_ref());
+                match with_ambient_tokio_runtime(|| listener.poll_accept(&mut cx))
+                    .map_ok(|(stream, _)| stream)
+                {
+                    Poll::Ready(result) => result,
+                    Poll::Pending => Err(Errno::WOULDBLOCK.into()),
+                }
+            }
+        };
+
+        let client = result.map_err(|err| match Errno::from_io_error(&err) {
+            // From: https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-accept#:~:text=WSAEINPROGRESS
+            // > WSAEINPROGRESS: A blocking Windows Sockets 1.1 call is in progress,
+            // > or the service provider is still processing a callback function.
+            //
+            // wasi-sockets doesn't have an equivalent to the EINPROGRESS error,
+            // because in POSIX this error is only returned by a non-blocking
+            // `connect` and wasi-sockets has a different solution for that.
+            #[cfg(windows)]
+            Some(Errno::INPROGRESS) => Errno::INTR.into(),
+
+            // Normalize Linux' non-standard behavior.
+            //
+            // From https://man7.org/linux/man-pages/man2/accept.2.html:
+            // > Linux accept() passes already-pending network errors on the
+            // > new socket as an error code from accept(). This behavior
+            // > differs from other BSD socket implementations. (...)
+            #[cfg(target_os = "linux")]
+            Some(
+                Errno::CONNRESET
+                | Errno::NETRESET
+                | Errno::HOSTUNREACH
+                | Errno::HOSTDOWN
+                | Errno::NETDOWN
+                | Errno::NETUNREACH
+                | Errno::PROTO
+                | Errno::NOPROTOOPT
+                | Errno::NONET
+                | Errno::OPNOTSUPP,
+            ) => Errno::CONNABORTED.into(),
+
+            _ => err,
+        })?;
+
+        #[cfg(target_os = "macos")]
+        {
+            // Manually inherit socket options from listener. We only have to
+            // do this on platforms that don't already do this automatically
+            // and only if a specific value was explicitly set on the listener.
+
+            if let Some(size) = self.receive_buffer_size {
+                _ = network::util::set_socket_recv_buffer_size(&client, size); // Ignore potential error.
+            }
+
+            if let Some(size) = self.send_buffer_size {
+                _ = network::util::set_socket_send_buffer_size(&client, size); // Ignore potential error.
+            }
+
+            // For some reason, IP_TTL is inherited, but IPV6_UNICAST_HOPS isn't.
+            if let (SocketAddressFamily::Ipv6, Some(ttl)) = (self.family, self.hop_limit) {
+                _ = network::util::set_ipv6_unicast_hops(&client, ttl); // Ignore potential error.
+            }
+
+            if let Some(value) = self.keep_alive_idle_time {
+                _ = network::util::set_tcp_keepidle(&client, value); // Ignore potential error.
+            }
+        }
+
+        let client = Arc::new(client);
+
+        let input: InputStream = Box::new(TcpReadStream::new(client.clone()));
+        let output: OutputStream = Box::new(TcpWriteStream::new(client.clone()));
+        let tcp_socket = TcpSocket::from_state(TcpState::Connected(client), self.family)?;
+
+        Ok((tcp_socket, input, output))
+    }
+
+    pub fn local_address(&self) -> SocketResult<SocketAddr> {
+        let view = match self.tcp_state {
+            TcpState::Default(..) => return Err(ErrorCode::InvalidState.into()),
+            TcpState::BindStarted(..) => return Err(ErrorCode::ConcurrencyConflict.into()),
+            _ => self.as_std_view()?,
+        };
+
+        Ok(view.local_addr()?)
+    }
+
+    pub fn remote_address(&self) -> SocketResult<SocketAddr> {
+        let view = match self.tcp_state {
+            TcpState::Connected(..) => self.as_std_view()?,
+            TcpState::Connecting(..) | TcpState::ConnectReady(..) => {
+                return Err(ErrorCode::ConcurrencyConflict.into())
+            }
+            _ => return Err(ErrorCode::InvalidState.into()),
+        };
+
+        Ok(view.peer_addr()?)
+    }
+
+    pub fn is_listening(&self) -> bool {
+        matches!(self.tcp_state, TcpState::Listening { .. })
+    }
+
+    pub fn address_family(&self) -> SocketAddressFamily {
+        self.family
+    }
+
+    pub fn set_listen_backlog_size(&mut self, value: u32) -> SocketResult<()> {
+        const MIN_BACKLOG: u32 = 1;
+        const MAX_BACKLOG: u32 = i32::MAX as u32; // OS'es will most likely limit it down even further.
+
+        if value == 0 {
+            return Err(ErrorCode::InvalidArgument.into());
+        }
+
+        // Silently clamp backlog size. This is OK for us to do, because operating systems do this too.
+        let value = value.clamp(MIN_BACKLOG, MAX_BACKLOG);
+
+        match &self.tcp_state {
+            TcpState::Default(..) | TcpState::Bound(..) => {
+                // Socket not listening yet. Stash value for first invocation to `listen`.
+            }
+            TcpState::Listening { listener, .. } => {
+                // Try to update the backlog by calling `listen` again.
+                // Not all platforms support this. We'll only update our own value if the OS supports changing the backlog size after the fact.
+
+                rustix::net::listen(&listener, value.try_into().unwrap())
+                    .map_err(|_| ErrorCode::NotSupported)?;
+            }
+            _ => return Err(ErrorCode::InvalidState.into()),
+        }
+        self.listen_backlog_size = value;
+
+        Ok(())
+    }
+
+    pub fn keep_alive_enabled(&self) -> SocketResult<bool> {
+        let view = &*self.as_std_view()?;
+        Ok(sockopt::get_socket_keepalive(view)?)
+    }
+
+    pub fn set_keep_alive_enabled(&self, value: bool) -> SocketResult<()> {
+        let view = &*self.as_std_view()?;
+        Ok(sockopt::set_socket_keepalive(view, value)?)
+    }
+
+    pub fn keep_alive_idle_time(&self) -> SocketResult<std::time::Duration> {
+        let view = &*self.as_std_view()?;
+        Ok(sockopt::get_tcp_keepidle(view)?)
+    }
+
+    pub fn set_keep_alive_idle_time(&mut self, duration: std::time::Duration) -> SocketResult<()> {
+        {
+            let view = &*self.as_std_view()?;
+            network::util::set_tcp_keepidle(view, duration)?;
+        }
+
+        #[cfg(target_os = "macos")]
+        {
+            self.keep_alive_idle_time = Some(duration);
+        }
+
+        Ok(())
+    }
+
+    pub fn keep_alive_interval(&self) -> SocketResult<std::time::Duration> {
+        let view = &*self.as_std_view()?;
+        Ok(sockopt::get_tcp_keepintvl(view)?)
+    }
+
+    pub fn set_keep_alive_interval(&self, duration: std::time::Duration) -> SocketResult<()> {
+        let view = &*self.as_std_view()?;
+        Ok(network::util::set_tcp_keepintvl(view, duration)?)
+    }
+
+    pub fn keep_alive_count(&self) -> SocketResult<u32> {
+        let view = &*self.as_std_view()?;
+        Ok(sockopt::get_tcp_keepcnt(view)?)
+    }
+
+    pub fn set_keep_alive_count(&self, value: u32) -> SocketResult<()> {
+        let view = &*self.as_std_view()?;
+        Ok(network::util::set_tcp_keepcnt(view, value)?)
+    }
+
+    pub fn hop_limit(&self) -> SocketResult<u8> {
+        let view = &*self.as_std_view()?;
+
+        let ttl = match self.family {
+            SocketAddressFamily::Ipv4 => network::util::get_ip_ttl(view)?,
+            SocketAddressFamily::Ipv6 => network::util::get_ipv6_unicast_hops(view)?,
+        };
+
+        Ok(ttl)
+    }
+
+    pub fn set_hop_limit(&mut self, value: u8) -> SocketResult<()> {
+        {
+            let view = &*self.as_std_view()?;
+
+            match self.family {
+                SocketAddressFamily::Ipv4 => network::util::set_ip_ttl(view, value)?,
+                SocketAddressFamily::Ipv6 => network::util::set_ipv6_unicast_hops(view, value)?,
+            }
+        }
+
+        #[cfg(target_os = "macos")]
+        {
+            self.hop_limit = Some(value);
+        }
+
+        Ok(())
+    }
+
+    pub fn receive_buffer_size(&self) -> SocketResult<usize> {
+        let view = &*self.as_std_view()?;
+
+        Ok(network::util::get_socket_recv_buffer_size(view)?)
+    }
+
+    pub fn set_receive_buffer_size(&mut self, value: usize) -> SocketResult<()> {
+        {
+            let view = &*self.as_std_view()?;
+
+            network::util::set_socket_recv_buffer_size(view, value)?;
+        }
+
+        #[cfg(target_os = "macos")]
+        {
+            self.receive_buffer_size = Some(value);
+        }
+
+        Ok(())
+    }
+
+    pub fn send_buffer_size(&self) -> SocketResult<usize> {
+        let view = &*self.as_std_view()?;
+
+        Ok(network::util::get_socket_send_buffer_size(view)?)
+    }
+
+    pub fn set_send_buffer_size(&mut self, value: usize) -> SocketResult<()> {
+        {
+            let view = &*self.as_std_view()?;
+
+            network::util::set_socket_send_buffer_size(view, value)?;
+        }
+
+        #[cfg(target_os = "macos")]
+        {
+            self.send_buffer_size = Some(value);
+        }
+
+        Ok(())
+    }
+
+    pub fn shutdown(&self, how: std::net::Shutdown) -> io::Result<()> {
+        let stream = match &self.tcp_state {
+            TcpState::Connected(stream) => stream,
+            _ => {
+                return Err(io::Error::new(
+                    io::ErrorKind::NotConnected,
+                    "socket not connected",
+                ))
+            }
+        };
+
+        stream
+            .as_socketlike_view::<std::net::TcpStream>()
+            .shutdown(how)?;
+        Ok(())
+    }
+}
+
+#[async_trait::async_trait]
+impl Subscribe for TcpSocket {
+    async fn ready(&mut self) {
+        match &mut self.tcp_state {
+            TcpState::Default(..)
+            | TcpState::BindStarted(..)
+            | TcpState::Bound(..)
+            | TcpState::ListenStarted(..)
+            | TcpState::ConnectReady(..)
+            | TcpState::Closed
+            | TcpState::Connected(..) => {
+                // No async operation in progress.
+            }
+            TcpState::Connecting(future) => {
+                self.tcp_state = TcpState::ConnectReady(future.as_mut().await);
+            }
+            TcpState::Listening {
+                listener,
+                pending_accept,
+            } => match pending_accept {
+                Some(_) => {}
+                None => {
+                    let result = futures::future::poll_fn(|cx| {
+                        listener.poll_accept(cx).map_ok(|(stream, _)| stream)
+                    })
+                    .await;
+                    *pending_accept = Some(result);
+                }
+            },
+        }
+    }
+}
+
+struct TcpReadStream {
+    stream: Arc<tokio::net::TcpStream>,
+    closed: bool,
+}
+
+impl TcpReadStream {
+    fn new(stream: Arc<tokio::net::TcpStream>) -> Self {
+        Self {
+            stream,
+            closed: false,
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl HostInputStream for TcpReadStream {
+    fn read(&mut self, size: usize) -> Result<bytes::Bytes, StreamError> {
+        if self.closed {
+            return Err(StreamError::Closed);
+        }
+        if size == 0 {
+            return Ok(bytes::Bytes::new());
+        }
+
+        let mut buf = bytes::BytesMut::with_capacity(size);
+        let n = match self.stream.try_read_buf(&mut buf) {
+            // A 0-byte read indicates that the stream has closed.
+            Ok(0) => {
+                self.closed = true;
+                return Err(StreamError::Closed);
+            }
+            Ok(n) => n,
+
+            // Failing with `EWOULDBLOCK` is how we differentiate between a closed channel and no
+            // data to read right now.
+            Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => 0,
+
+            Err(e) => {
+                self.closed = true;
+                return Err(StreamError::LastOperationFailed(e.into()));
+            }
+        };
+
+        buf.truncate(n);
+        Ok(buf.freeze())
+    }
+}
+
+#[async_trait::async_trait]
+impl Subscribe for TcpReadStream {
+    async fn ready(&mut self) {
+        if self.closed {
+            return;
+        }
+        self.stream.readable().await.unwrap();
+    }
+}
+
+const SOCKET_READY_SIZE: usize = 1024 * 1024 * 1024;
+
+struct TcpWriteStream {
+    stream: Arc<tokio::net::TcpStream>,
+    last_write: LastWrite,
+}
+
+enum LastWrite {
+    Waiting(AbortOnDropJoinHandle<Result<()>>),
+    Error(Error),
+    Done,
+    Closed,
+}
+
+impl TcpWriteStream {
+    fn new(stream: Arc<tokio::net::TcpStream>) -> Self {
+        Self {
+            stream,
+            last_write: LastWrite::Done,
+        }
+    }
+
+    fn try_write_portable(stream: &tokio::net::TcpStream, buf: &[u8]) -> io::Result<usize> {
+        stream.try_write(buf).map_err(|error| {
+            match Errno::from_io_error(&error) {
+                // Windows returns `WSAESHUTDOWN` when writing to a shut down socket.
+                // We normalize this to EPIPE, because that is what the other platforms return.
+                // See: https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-send#:~:text=WSAESHUTDOWN
+                #[cfg(windows)]
+                Some(Errno::SHUTDOWN) => io::Error::new(io::ErrorKind::BrokenPipe, error),
+
+                _ => error,
+            }
+        })
+    }
+
+    /// Write `bytes` in a background task, remembering the task handle for use in a future call to
+    /// `write_ready`
+    fn background_write(&mut self, mut bytes: bytes::Bytes) {
+        assert!(matches!(self.last_write, LastWrite::Done));
+
+        let stream = self.stream.clone();
+        self.last_write = LastWrite::Waiting(crate::runtime::spawn(async move {
+            // Note: we are not using the AsyncWrite impl here, and instead using the TcpStream
+            // primitive try_write, which goes directly to attempt a write with mio. This has
+            // two advantages: 1. this operation takes a &TcpStream instead of a &mut TcpStream
+            // required to AsyncWrite, and 2. it eliminates any buffering in tokio we may need
+            // to flush.
+            while !bytes.is_empty() {
+                stream.writable().await?;
+                match Self::try_write_portable(&stream, &bytes) {
+                    Ok(n) => {
+                        let _ = bytes.split_to(n);
+                    }
+                    Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => continue,
+                    Err(e) => return Err(e.into()),
+                }
+            }
+
+            Ok(())
+        }));
+    }
+}
+
+#[async_trait::async_trait]
+impl HostOutputStream for TcpWriteStream {
+    fn write(&mut self, mut bytes: bytes::Bytes) -> Result<(), StreamError> {
+        match self.last_write {
+            LastWrite::Done => {}
+            LastWrite::Waiting(_) | LastWrite::Error(_) | LastWrite::Closed => {
+                return Err(StreamError::Trap(anyhow::anyhow!(
+                    "unpermitted: must call check_write first"
+                )));
+            }
+        }
+        while !bytes.is_empty() {
+            match Self::try_write_portable(&self.stream, &bytes) {
+                Ok(n) => {
+                    let _ = bytes.split_to(n);
+                }
+
+                Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => {
+                    // As `try_write` indicated that it would have blocked, we'll perform the write
+                    // in the background to allow us to return immediately.
+                    self.background_write(bytes);
+
+                    return Ok(());
+                }
+
+                Err(e) if e.kind() == std::io::ErrorKind::BrokenPipe => {
+                    self.last_write = LastWrite::Closed;
+                    return Err(StreamError::Closed);
+                }
+
+                Err(e) => return Err(StreamError::LastOperationFailed(e.into())),
+            }
+        }
+
+        Ok(())
+    }
+
+    fn flush(&mut self) -> Result<(), StreamError> {
+        // `flush` is a no-op here, as we're not managing any internal buffer. Additionally,
+        // `write_ready` will join the background write task if it's active, so following `flush`
+        // with `write_ready` will have the desired effect.
+        match self.last_write {
+            LastWrite::Done | LastWrite::Waiting(_) | LastWrite::Error(_) => Ok(()),
+            LastWrite::Closed => Err(StreamError::Closed),
+        }
+    }
+
+    fn check_write(&mut self) -> Result<usize, StreamError> {
+        match mem::replace(&mut self.last_write, LastWrite::Closed) {
+            LastWrite::Waiting(task) => {
+                self.last_write = LastWrite::Waiting(task);
+                return Ok(0);
+            }
+            LastWrite::Done => {
+                self.last_write = LastWrite::Done;
+            }
+            LastWrite::Closed => return Err(StreamError::Closed),
+            LastWrite::Error(e) => return Err(StreamError::LastOperationFailed(e.into())),
+        }
+
+        let writable = self.stream.writable();
+        futures::pin_mut!(writable);
+        if crate::runtime::poll_noop(writable).is_none() {
+            return Ok(0);
+        }
+        Ok(SOCKET_READY_SIZE)
+    }
+    async fn cancel(&mut self) {
+        match mem::replace(&mut self.last_write, LastWrite::Closed) {
+            LastWrite::Waiting(task) => _ = task.abort_wait().await,
+            _ => {}
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl Subscribe for TcpWriteStream {
+    async fn ready(&mut self) {
+        if let LastWrite::Waiting(task) = &mut self.last_write {
+            self.last_write = match task.await {
+                Ok(()) => LastWrite::Done,
+                Err(e) => LastWrite::Error(e),
+            };
+        }
+        if let LastWrite::Done = self.last_write {
+            self.stream.writable().await.unwrap();
+        }
+    }
+}
diff --git a/crates/wasi/src/udp.rs b/crates/wasi/src/udp.rs
new file mode 100644
index 000000000000..1e0b1a199cf4
--- /dev/null
+++ b/crates/wasi/src/udp.rs
@@ -0,0 +1,125 @@
+use crate::host::network::util;
+use crate::poll::Subscribe;
+use crate::runtime::with_ambient_tokio_runtime;
+use async_trait::async_trait;
+use cap_net_ext::{AddressFamily, Blocking};
+use io_lifetimes::raw::{FromRawSocketlike, IntoRawSocketlike};
+use std::io;
+use std::net::SocketAddr;
+use std::sync::Arc;
+
+use super::network::{SocketAddrCheck, SocketAddressFamily};
+
+/// The state of a UDP socket.
+///
+/// This represents the various states a socket can be in during the
+/// activities of binding, and connecting.
+pub(crate) enum UdpState {
+    /// The initial state for a newly-created socket.
+    Default,
+
+    /// Binding started via `start_bind`.
+    BindStarted,
+
+    /// Binding finished via `finish_bind`. The socket has an address but
+    /// is not yet listening for connections.
+    Bound,
+
+    /// The socket is "connected" to a peer address.
+    Connected,
+}
+
+/// A host UDP socket, plus associated bookkeeping.
+///
+/// The inner state is wrapped in an Arc because the same underlying socket is
+/// used for implementing the stream types.
+pub struct UdpSocket {
+    /// The part of a `UdpSocket` which is reference-counted so that we
+    /// can pass it to async tasks.
+    pub(crate) inner: Arc<tokio::net::UdpSocket>,
+
+    /// The current state in the bind/connect progression.
+    pub(crate) udp_state: UdpState,
+
+    /// Socket address family.
+    pub(crate) family: SocketAddressFamily,
+
+    /// The check of allowed addresses
+    pub(crate) socket_addr_check: Option<SocketAddrCheck>,
+}
+
+#[async_trait]
+impl Subscribe for UdpSocket {
+    async fn ready(&mut self) {
+        // None of the socket-level operations block natively
+    }
+}
+
+impl UdpSocket {
+    /// Create a new socket in the given family.
+    pub fn new(family: AddressFamily) -> io::Result<Self> {
+        // Create a new host socket and set it to non-blocking, which is needed
+        // by our async implementation.
+        let fd = util::udp_socket(family, Blocking::No)?;
+
+        let socket_address_family = match family {
+            AddressFamily::Ipv4 => SocketAddressFamily::Ipv4,
+            AddressFamily::Ipv6 => {
+                rustix::net::sockopt::set_ipv6_v6only(&fd, true)?;
+                SocketAddressFamily::Ipv6
+            }
+        };
+
+        let socket = Self::setup_tokio_udp_socket(fd)?;
+
+        Ok(UdpSocket {
+            inner: Arc::new(socket),
+            udp_state: UdpState::Default,
+            family: socket_address_family,
+            socket_addr_check: None,
+        })
+    }
+
+    fn setup_tokio_udp_socket(fd: rustix::fd::OwnedFd) -> io::Result<tokio::net::UdpSocket> {
+        let std_socket =
+            unsafe { std::net::UdpSocket::from_raw_socketlike(fd.into_raw_socketlike()) };
+        with_ambient_tokio_runtime(|| tokio::net::UdpSocket::try_from(std_socket))
+    }
+
+    pub fn udp_socket(&self) -> &tokio::net::UdpSocket {
+        &self.inner
+    }
+}
+
+pub struct IncomingDatagramStream {
+    pub(crate) inner: Arc<tokio::net::UdpSocket>,
+
+    /// If this has a value, the stream is "connected".
+    pub(crate) remote_address: Option<SocketAddr>,
+}
+
+pub struct OutgoingDatagramStream {
+    pub(crate) inner: Arc<tokio::net::UdpSocket>,
+
+    /// If this has a value, the stream is "connected".
+    pub(crate) remote_address: Option<SocketAddr>,
+
+    /// Socket address family.
+    pub(crate) family: SocketAddressFamily,
+
+    pub(crate) send_state: SendState,
+
+    /// The check of allowed addresses
+    pub(crate) socket_addr_check: Option<SocketAddrCheck>,
+}
+
+pub(crate) enum SendState {
+    /// Waiting for the API consumer to call `check-send`.
+    Idle,
+
+    /// Ready to send up to x datagrams.
+    Permitted(usize),
+
+    /// Waiting for the OS.
+    Waiting,
+}
diff --git a/crates/wasi/src/preview2/write_stream.rs b/crates/wasi/src/write_stream.rs
similarity index 90%
rename from crates/wasi/src/preview2/write_stream.rs
rename to crates/wasi/src/write_stream.rs
index afc2305f007a..33ae910481b7 100644
--- a/crates/wasi/src/preview2/write_stream.rs
+++ b/crates/wasi/src/write_stream.rs
@@ -1,4 +1,4 @@
-use crate::preview2::{HostOutputStream, StreamError, Subscribe};
+use crate::{HostOutputStream, StreamError, Subscribe};
 use anyhow::anyhow;
 use bytes::Bytes;
 use std::sync::{Arc, Mutex};
@@ -99,7 +99,7 @@ impl Worker {
         }
         self.write_ready_changed.notify_one();
     }
-    async fn work<T: tokio::io::AsyncWrite + Send + Sync + Unpin + 'static>(&self, mut writer: T) {
+    async fn work<T: tokio::io::AsyncWrite + Send + Unpin + 'static>(&self, mut writer: T) {
         use tokio::io::AsyncWriteExt;
         loop {
             while let Some(job) = self.pop() {
@@ -139,28 +139,29 @@ impl Worker {
 /// Provides a [`HostOutputStream`] impl from a [`tokio::io::AsyncWrite`] impl
 pub struct AsyncWriteStream {
     worker: Arc<Worker>,
-    _join_handle: crate::preview2::AbortOnDropJoinHandle<()>,
+    join_handle: Option<crate::runtime::AbortOnDropJoinHandle<()>>,
 }
 
 impl AsyncWriteStream {
     /// Create a [`AsyncWriteStream`]. In order to use the [`HostOutputStream`] impl
     /// provided by this struct, the argument must impl [`tokio::io::AsyncWrite`].
-    pub fn new<T: tokio::io::AsyncWrite + Send + Sync + Unpin + 'static>(
+    pub fn new<T: tokio::io::AsyncWrite + Send + Unpin + 'static>(
         write_budget: usize,
         writer: T,
     ) -> Self {
         let worker = Arc::new(Worker::new(write_budget));
 
         let w = Arc::clone(&worker);
-        let join_handle = crate::preview2::spawn(async move { w.work(writer).await });
+        let join_handle = crate::runtime::spawn(async move { w.work(writer).await });
 
         AsyncWriteStream {
             worker,
-            _join_handle: join_handle,
+            join_handle: Some(join_handle),
         }
     }
 }
 
+#[async_trait::async_trait]
 impl HostOutputStream for AsyncWriteStream {
     fn write(&mut self, bytes: Bytes) -> Result<(), StreamError> {
         let mut state = self.worker.state();
@@ -194,6 +195,13 @@ impl HostOutputStream for AsyncWriteStream {
     fn check_write(&mut self) -> Result<usize, StreamError> {
         self.worker.check_write()
     }
+
+    async fn cancel(&mut self) {
+        match self.join_handle.take() {
+            Some(task) => _ = task.abort_wait().await,
+            None => {}
+        }
+    }
 }
 #[async_trait::async_trait]
 impl Subscribe for AsyncWriteStream {
diff --git a/crates/wasi/tests/all/api.rs b/crates/wasi/tests/all/api.rs
new file mode 100644
index 000000000000..bd5e65b0bada
--- /dev/null
+++ b/crates/wasi/tests/all/api.rs
@@ -0,0 +1,197 @@
+use anyhow::Result;
+use std::io::Write;
+use std::sync::Mutex;
+use std::time::Duration;
+use wasmtime::component::{Component, Linker, ResourceTable};
+use wasmtime::Store;
+use wasmtime_wasi::bindings::Command;
+use wasmtime_wasi::{
+    add_to_linker_async,
+    bindings::{clocks::wall_clock, filesystem::types as filesystem},
+    DirPerms, FilePerms, HostMonotonicClock, HostWallClock, WasiCtx, WasiCtxBuilder, WasiView,
+};
+
+struct CommandCtx {
+    table: ResourceTable,
+    wasi: WasiCtx,
+}
+
+impl WasiView for CommandCtx {
+    fn table(&mut self) -> &mut ResourceTable {
+        &mut self.table
+    }
+    fn ctx(&mut self) -> &mut WasiCtx {
+        &mut self.wasi
+    }
+}
+
+use test_programs_artifacts::*;
+
+foreach_api!(assert_test_exists);
+
+async fn instantiate(path: &str, ctx: CommandCtx) -> Result<(Store<CommandCtx>, Command)> {
+    let engine = test_programs_artifacts::engine(|config| {
+        config.async_support(true);
+    });
+    let mut linker = Linker::new(&engine);
+    add_to_linker_async(&mut linker)?;
+
+    let mut store = Store::new(&engine, ctx);
+    let component = Component::from_file(&engine, path)?;
+    let command = Command::instantiate_async(&mut store, &component, &linker).await?;
+    Ok((store, command))
+}
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn api_time() -> Result<()> {
+    struct FakeWallClock;
+
+    impl HostWallClock for FakeWallClock {
+        fn resolution(&self) -> Duration {
+            Duration::from_secs(1)
+        }
+
+        fn now(&self) -> Duration {
+            Duration::new(1431648000, 100)
+        }
+    }
+
+    struct FakeMonotonicClock {
+        now: Mutex<u64>,
+    }
+
+    impl HostMonotonicClock for FakeMonotonicClock {
+        fn resolution(&self) -> u64 {
+            1_000_000_000
+        }
+
+        fn now(&self) -> u64 {
+            let mut now = self.now.lock().unwrap();
+            let then = *now;
+            *now += 42 * 1_000_000_000;
+            then
+        }
+    }
+
+    let table = ResourceTable::new();
+    let wasi = WasiCtxBuilder::new()
+        .monotonic_clock(FakeMonotonicClock { now: Mutex::new(0) })
+        .wall_clock(FakeWallClock)
+        .build();
+
+    let (mut store, command) = instantiate(API_TIME_COMPONENT, CommandCtx { table, wasi }).await?;
+
+    command
+        .wasi_cli_run()
+        .call_run(&mut store)
+        .await?
+        .map_err(|()| anyhow::anyhow!("command returned with failing exit status"))
+}
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn api_read_only() -> Result<()> {
+    let dir = tempfile::tempdir()?;
+
+    std::fs::File::create(dir.path().join("bar.txt"))?.write_all(b"And stood awhile in thought")?;
+    std::fs::create_dir(dir.path().join("sub"))?;
+
+    let table = ResourceTable::new();
+    let wasi = WasiCtxBuilder::new()
+        .preopened_dir(dir.path(), "/", DirPerms::READ, FilePerms::READ)?
+        .build();
+
+    let (mut store, command) =
+        instantiate(API_READ_ONLY_COMPONENT, CommandCtx { table, wasi }).await?;
+
+    command
+        .wasi_cli_run()
+        .call_run(&mut store)
+        .await?
+        .map_err(|()| anyhow::anyhow!("command returned with failing exit status"))
+}
+
+// This is tested in the wasi-http crate, but need to satisfy the `foreach_api!`
+// macro above.
+#[allow(dead_code)]
+fn api_proxy() {}
+
+// This is tested in the wasi-http crate, but need to satisfy the `foreach_api!`
+// macro above.
+#[allow(dead_code)]
+fn api_proxy_streaming() {}
+
+// This is tested in the wasi-http crate, but need to satisfy the `foreach_api!`
+// macro above.
+#[allow(dead_code)]
+fn api_proxy_forward_request() {}
+
+wasmtime::component::bindgen!({
+    world: "test-reactor",
+    async: true,
+    with: { "wasi": wasmtime_wasi::bindings },
+    ownership: Borrowing {
+        duplicate_if_necessary: false
+    }
+});
+
+#[test_log::test(tokio::test)]
+async fn api_reactor() -> Result<()> {
+    let table = ResourceTable::new();
+    let wasi = WasiCtxBuilder::new().env("GOOD_DOG", "gussie").build();
+    let engine = test_programs_artifacts::engine(|config| {
+        config.async_support(true);
+    });
+    let mut linker = Linker::new(&engine);
+    add_to_linker_async(&mut linker)?;
+
+    let mut store = Store::new(&engine, CommandCtx { table, wasi });
+    let component = Component::from_file(&engine, API_REACTOR_COMPONENT)?;
+    let reactor = TestReactor::instantiate_async(&mut store, &component, &linker).await?;
+
+    // Show that integration with the WASI context is working - the guest will
+    // interpolate $GOOD_DOG to gussie here using the environment:
+    let r = reactor
+        .call_add_strings(&mut store, &["hello", "$GOOD_DOG"])
+        .await?;
+    assert_eq!(r, 2);
+
+    let contents = reactor.call_get_strings(&mut store).await?;
+    assert_eq!(contents, &["hello", "gussie"]);
+
+    // Show that we can pass in a resource type whose impls are defined in the
+    // `host` and `wasi-common` crate.
+    // Note, this works because of the add_to_linker invocations using the
+    // `host` crate for `streams`, not because of `with` in the bindgen macro.
+    let writepipe = wasmtime_wasi::pipe::MemoryOutputPipe::new(4096);
+    let stream: wasmtime_wasi::OutputStream = Box::new(writepipe.clone());
+    let table_ix = store.data_mut().table().push(stream)?;
+    let r = reactor.call_write_strings_to(&mut store, table_ix).await?;
+    assert_eq!(r, Ok(()));
+
+    assert_eq!(writepipe.contents().as_ref(), b"hellogussie");
+
+    // Show that the `with` invocation in the macro means we get to re-use the
+    // type definitions from inside the `host` crate for these structures:
+    let ds = filesystem::DescriptorStat {
+        data_access_timestamp: Some(wall_clock::Datetime {
+            nanoseconds: 123,
+            seconds: 45,
+        }),
+        data_modification_timestamp: Some(wall_clock::Datetime {
+            nanoseconds: 789,
+            seconds: 10,
+        }),
+        link_count: 0,
+        size: 0,
+        status_change_timestamp: Some(wall_clock::Datetime {
+            nanoseconds: 0,
+            seconds: 1,
+        }),
+        type_: filesystem::DescriptorType::Unknown,
+    };
+    let expected = format!("{ds:?}");
+    let got = reactor.call_pass_an_imported_record(&mut store, ds).await?;
+    assert_eq!(expected, got);
+
+    Ok(())
+}
diff --git a/crates/wasi/tests/all/async_.rs b/crates/wasi/tests/all/async_.rs
new file mode 100644
index 000000000000..7d25423726b2
--- /dev/null
+++ b/crates/wasi/tests/all/async_.rs
@@ -0,0 +1,401 @@
+use super::*;
+use std::path::Path;
+use test_programs_artifacts::*;
+use wasmtime_wasi::add_to_linker_async;
+use wasmtime_wasi::bindings::Command;
+
+async fn run(path: &str, inherit_stdio: bool) -> Result<()> {
+    let path = Path::new(path);
+    let name = path.file_stem().unwrap().to_str().unwrap();
+    let engine = test_programs_artifacts::engine(|config| {
+        config.async_support(true);
+    });
+    let mut linker = Linker::new(&engine);
+    add_to_linker_async(&mut linker)?;
+
+    let (mut store, _td) = store(&engine, name, |builder| {
+        if inherit_stdio {
+            builder.inherit_stdio();
+        }
+    })?;
+    let component = Component::from_file(&engine, path)?;
+    let command = Command::instantiate_async(&mut store, &component, &linker).await?;
+    command
+        .wasi_cli_run()
+        .call_run(&mut store)
+        .await?
+        .map_err(|()| anyhow::anyhow!("run returned a failure"))
+}
+
+foreach_preview1!(assert_test_exists);
+foreach_preview2!(assert_test_exists);
+
+// Below here is mechanical: there should be one test for every binary in
+// wasi-tests.
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_big_random_buf() {
+    run(PREVIEW1_BIG_RANDOM_BUF_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_clock_time_get() {
+    run(PREVIEW1_CLOCK_TIME_GET_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_close_preopen() {
+    run(PREVIEW1_CLOSE_PREOPEN_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_dangling_fd() {
+    run(PREVIEW1_DANGLING_FD_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_dangling_symlink() {
+    run(PREVIEW1_DANGLING_SYMLINK_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_directory_seek() {
+    run(PREVIEW1_DIRECTORY_SEEK_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_dir_fd_op_failures() {
+    run(PREVIEW1_DIR_FD_OP_FAILURES_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_fd_advise() {
+    run(PREVIEW1_FD_ADVISE_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_fd_filestat_get() {
+    run(PREVIEW1_FD_FILESTAT_GET_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_fd_filestat_set() {
+    run(PREVIEW1_FD_FILESTAT_SET_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_fd_flags_set() {
+    run(PREVIEW1_FD_FLAGS_SET_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_fd_readdir() {
+    run(PREVIEW1_FD_READDIR_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_allocate() {
+    run(PREVIEW1_FILE_ALLOCATE_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_pread_pwrite() {
+    run(PREVIEW1_FILE_PREAD_PWRITE_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_read_write() {
+    run(PREVIEW1_FILE_READ_WRITE_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_seek_tell() {
+    run(PREVIEW1_FILE_SEEK_TELL_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_truncation() {
+    run(PREVIEW1_FILE_TRUNCATION_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_unbuffered_write() {
+    run(PREVIEW1_FILE_UNBUFFERED_WRITE_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_interesting_paths() {
+    run(PREVIEW1_INTERESTING_PATHS_COMPONENT, true)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_regular_file_isatty() {
+    run(PREVIEW1_REGULAR_FILE_ISATTY_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_nofollow_errors() {
+    run(PREVIEW1_NOFOLLOW_ERRORS_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_overwrite_preopen() {
+    run(PREVIEW1_OVERWRITE_PREOPEN_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_exists() {
+    run(PREVIEW1_PATH_EXISTS_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_filestat() {
+    run(PREVIEW1_PATH_FILESTAT_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_link() {
+    run(PREVIEW1_PATH_LINK_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_create_existing() {
+    run(PREVIEW1_PATH_OPEN_CREATE_EXISTING_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_read_write() {
+    run(PREVIEW1_PATH_OPEN_READ_WRITE_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_dirfd_not_dir() {
+    run(PREVIEW1_PATH_OPEN_DIRFD_NOT_DIR_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_missing() {
+    run(PREVIEW1_PATH_OPEN_MISSING_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_nonblock() {
+    run(PREVIEW1_PATH_OPEN_NONBLOCK_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_rename_dir_trailing_slashes() {
+    run(PREVIEW1_PATH_RENAME_DIR_TRAILING_SLASHES_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_rename() {
+    run(PREVIEW1_PATH_RENAME_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_symlink_trailing_slashes() {
+    run(PREVIEW1_PATH_SYMLINK_TRAILING_SLASHES_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_poll_oneoff_files() {
+    run(PREVIEW1_POLL_ONEOFF_FILES_COMPONENT, false)
+        .await
+        .unwrap()
+}
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_poll_oneoff_stdio() {
+    run(PREVIEW1_POLL_ONEOFF_STDIO_COMPONENT, true)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_readlink() {
+    run(PREVIEW1_READLINK_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_remove_directory() {
+    run(PREVIEW1_REMOVE_DIRECTORY_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_remove_nonempty_directory() {
+    run(PREVIEW1_REMOVE_NONEMPTY_DIRECTORY_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_renumber() {
+    run(PREVIEW1_RENUMBER_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_sched_yield() {
+    run(PREVIEW1_SCHED_YIELD_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_stdio() {
+    run(PREVIEW1_STDIO_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_stdio_isatty() {
+    // If the test process is setup such that stdio is a terminal:
+    if test_programs_artifacts::stdio_is_terminal() {
+        // Inherit stdio, test asserts each is not tty:
+        run(PREVIEW1_STDIO_ISATTY_COMPONENT, true).await.unwrap()
+    }
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_stdio_not_isatty() {
+    // Don't inherit stdio, test asserts each is not tty:
+    run(PREVIEW1_STDIO_NOT_ISATTY_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_symlink_create() {
+    run(PREVIEW1_SYMLINK_CREATE_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_symlink_filestat() {
+    run(PREVIEW1_SYMLINK_FILESTAT_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_symlink_loop() {
+    run(PREVIEW1_SYMLINK_LOOP_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_unlink_file_trailing_slashes() {
+    run(PREVIEW1_UNLINK_FILE_TRAILING_SLASHES_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_preopen() {
+    run(PREVIEW1_PATH_OPEN_PREOPEN_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_unicode_output() {
+    run(PREVIEW1_UNICODE_OUTPUT_COMPONENT, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_write() {
+    run(PREVIEW1_FILE_WRITE_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_lots() {
+    run(PREVIEW1_PATH_OPEN_LOTS_COMPONENT, false).await.unwrap()
+}
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_sleep() {
+    run(PREVIEW2_SLEEP_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_random() {
+    run(PREVIEW2_RANDOM_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_ip_name_lookup() {
+    run(PREVIEW2_IP_NAME_LOOKUP_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_tcp_sockopts() {
+    run(PREVIEW2_TCP_SOCKOPTS_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_tcp_sample_application() {
+    run(PREVIEW2_TCP_SAMPLE_APPLICATION_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_tcp_states() {
+    run(PREVIEW2_TCP_STATES_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_tcp_streams() {
+    run(PREVIEW2_TCP_STREAMS_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_tcp_bind() {
+    run(PREVIEW2_TCP_BIND_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_tcp_connect() {
+    run(PREVIEW2_TCP_CONNECT_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_udp_sockopts() {
+    run(PREVIEW2_UDP_SOCKOPTS_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_udp_sample_application() {
+    run(PREVIEW2_UDP_SAMPLE_APPLICATION_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_udp_states() {
+    run(PREVIEW2_UDP_STATES_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_udp_bind() {
+    run(PREVIEW2_UDP_BIND_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_udp_connect() {
+    run(PREVIEW2_UDP_CONNECT_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_stream_pollable_correct() {
+    run(PREVIEW2_STREAM_POLLABLE_CORRECT_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_stream_pollable_traps() {
+    let e = run(PREVIEW2_STREAM_POLLABLE_TRAPS_COMPONENT, false)
+        .await
+        .unwrap_err();
+    assert_eq!(
+        format!("{}", e.source().expect("trap source")),
+        "resource has children"
+    )
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_pollable_correct() {
+    run(PREVIEW2_POLLABLE_CORRECT_COMPONENT, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_pollable_traps() {
+    let e = run(PREVIEW2_POLLABLE_TRAPS_COMPONENT, false)
+        .await
+        .unwrap_err();
+    assert_eq!(
+        format!("{}", e.source().expect("trap source")),
+        "empty poll list"
+    )
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_adapter_badfd() {
+    run(PREVIEW2_ADAPTER_BADFD_COMPONENT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview2_file_read_write() {
+    run(PREVIEW2_FILE_READ_WRITE_COMPONENT, false)
+        .await
+        .unwrap()
+}
diff --git a/crates/wasi/tests/all/main.rs b/crates/wasi/tests/all/main.rs
new file mode 100644
index 000000000000..db99fa49561e
--- /dev/null
+++ b/crates/wasi/tests/all/main.rs
@@ -0,0 +1,91 @@
+use anyhow::Result;
+use tempfile::TempDir;
+use wasmtime::{
+    component::{Component, Linker, ResourceTable},
+    Engine, Store,
+};
+use wasmtime_wasi::preview1::WasiP1Ctx;
+use wasmtime_wasi::{
+    pipe::MemoryOutputPipe, DirPerms, FilePerms, WasiCtx, WasiCtxBuilder, WasiView,
+};
+
+struct Ctx {
+    stdout: MemoryOutputPipe,
+    stderr: MemoryOutputPipe,
+    wasi: WasiP1Ctx,
+}
+
+impl WasiView for Ctx {
+    fn table(&mut self) -> &mut ResourceTable {
+        self.wasi.table()
+    }
+    fn ctx(&mut self) -> &mut WasiCtx {
+        self.wasi.ctx()
+    }
+}
+
+fn prepare_workspace(exe_name: &str) -> Result<TempDir> {
+    let prefix = format!("wasi_components_{exe_name}_");
+    let tempdir = tempfile::Builder::new().prefix(&prefix).tempdir()?;
+    Ok(tempdir)
+}
+
+fn store(
+    engine: &Engine,
+    name: &str,
+    configure: impl FnOnce(&mut WasiCtxBuilder),
+) -> Result<(Store<Ctx>, TempDir)> {
+    let stdout = MemoryOutputPipe::new(4096);
+    let stderr = MemoryOutputPipe::new(4096);
+    let workspace = prepare_workspace(name)?;
+
+    // Create our wasi context.
+    let mut builder = WasiCtxBuilder::new();
+    builder.stdout(stdout.clone()).stderr(stderr.clone());
+
+    builder
+        .args(&[name, "."])
+        .inherit_network()
+        .allow_ip_name_lookup(true);
+    println!("preopen: {workspace:?}");
+    builder.preopened_dir(workspace.path(), ".", DirPerms::all(), FilePerms::all())?;
+    for (var, val) in test_programs_artifacts::wasi_tests_environment() {
+        builder.env(var, val);
+    }
+
+    configure(&mut builder);
+    let ctx = Ctx {
+        wasi: builder.build_p1(),
+        stderr,
+        stdout,
+    };
+
+    Ok((Store::new(&engine, ctx), workspace))
+}
+
+impl Drop for Ctx {
+    fn drop(&mut self) {
+        let stdout = self.stdout.contents();
+        if !stdout.is_empty() {
+            println!("[guest] stdout:\n{}\n===", String::from_utf8_lossy(&stdout));
+        }
+        let stderr = self.stderr.contents();
+        if !stderr.is_empty() {
+            println!("[guest] stderr:\n{}\n===", String::from_utf8_lossy(&stderr));
+        }
+    }
+}
+
+// Assert that each of `sync` and `async` below are testing everything through
+// assertion of the existence of the test function itself.
+macro_rules! assert_test_exists {
+    ($name:ident) => {
+        #[allow(unused_imports)]
+        use self::$name as _;
+    };
+}
+
+mod api;
+mod async_;
+mod preview1;
+mod sync;
diff --git a/crates/wasi/tests/all/preview1.rs b/crates/wasi/tests/all/preview1.rs
new file mode 100644
index 000000000000..6bd21d8e4594
--- /dev/null
+++ b/crates/wasi/tests/all/preview1.rs
@@ -0,0 +1,251 @@
+use super::*;
+use std::path::Path;
+use test_programs_artifacts::*;
+use wasmtime::{Linker, Module};
+use wasmtime_wasi::preview1::add_to_linker_async;
+
+async fn run(path: &str, inherit_stdio: bool) -> Result<()> {
+    let path = Path::new(path);
+    let name = path.file_stem().unwrap().to_str().unwrap();
+    let engine = test_programs_artifacts::engine(|config| {
+        config.async_support(true);
+    });
+    let mut linker = Linker::<Ctx>::new(&engine);
+    add_to_linker_async(&mut linker, |t| &mut t.wasi)?;
+
+    let module = Module::from_file(&engine, path)?;
+    let (mut store, _td) = store(&engine, name, |builder| {
+        if inherit_stdio {
+            builder.inherit_stdio();
+        }
+    })?;
+    let instance = linker.instantiate_async(&mut store, &module).await?;
+    let start = instance.get_typed_func::<(), ()>(&mut store, "_start")?;
+    start.call_async(&mut store, ()).await?;
+    Ok(())
+}
+
+foreach_preview1!(assert_test_exists);
+
+// Below here is mechanical: there should be one test for every binary in
+// wasi-tests.
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_big_random_buf() {
+    run(PREVIEW1_BIG_RANDOM_BUF, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_clock_time_get() {
+    run(PREVIEW1_CLOCK_TIME_GET, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_close_preopen() {
+    run(PREVIEW1_CLOSE_PREOPEN, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_dangling_fd() {
+    run(PREVIEW1_DANGLING_FD, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_dangling_symlink() {
+    run(PREVIEW1_DANGLING_SYMLINK, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_directory_seek() {
+    run(PREVIEW1_DIRECTORY_SEEK, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_dir_fd_op_failures() {
+    run(PREVIEW1_DIR_FD_OP_FAILURES, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_fd_advise() {
+    run(PREVIEW1_FD_ADVISE, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_fd_filestat_get() {
+    run(PREVIEW1_FD_FILESTAT_GET, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_fd_filestat_set() {
+    run(PREVIEW1_FD_FILESTAT_SET, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_fd_flags_set() {
+    run(PREVIEW1_FD_FLAGS_SET, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_fd_readdir() {
+    run(PREVIEW1_FD_READDIR, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_allocate() {
+    run(PREVIEW1_FILE_ALLOCATE, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_pread_pwrite() {
+    run(PREVIEW1_FILE_PREAD_PWRITE, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_read_write() {
+    run(PREVIEW1_FILE_READ_WRITE, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_seek_tell() {
+    run(PREVIEW1_FILE_SEEK_TELL, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_truncation() {
+    run(PREVIEW1_FILE_TRUNCATION, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_unbuffered_write() {
+    run(PREVIEW1_FILE_UNBUFFERED_WRITE, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_interesting_paths() {
+    run(PREVIEW1_INTERESTING_PATHS, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_regular_file_isatty() {
+    run(PREVIEW1_REGULAR_FILE_ISATTY, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_nofollow_errors() {
+    run(PREVIEW1_NOFOLLOW_ERRORS, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_overwrite_preopen() {
+    run(PREVIEW1_OVERWRITE_PREOPEN, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_exists() {
+    run(PREVIEW1_PATH_EXISTS, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_filestat() {
+    run(PREVIEW1_PATH_FILESTAT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_link() {
+    run(PREVIEW1_PATH_LINK, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_create_existing() {
+    run(PREVIEW1_PATH_OPEN_CREATE_EXISTING, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_read_write() {
+    run(PREVIEW1_PATH_OPEN_READ_WRITE, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_dirfd_not_dir() {
+    run(PREVIEW1_PATH_OPEN_DIRFD_NOT_DIR, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_missing() {
+    run(PREVIEW1_PATH_OPEN_MISSING, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_nonblock() {
+    run(PREVIEW1_PATH_OPEN_NONBLOCK, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_rename_dir_trailing_slashes() {
+    run(PREVIEW1_PATH_RENAME_DIR_TRAILING_SLASHES, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_rename() {
+    run(PREVIEW1_PATH_RENAME, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_symlink_trailing_slashes() {
+    run(PREVIEW1_PATH_SYMLINK_TRAILING_SLASHES, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_poll_oneoff_files() {
+    run(PREVIEW1_POLL_ONEOFF_FILES, false).await.unwrap()
+}
+
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_poll_oneoff_stdio() {
+    run(PREVIEW1_POLL_ONEOFF_STDIO, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_readlink() {
+    run(PREVIEW1_READLINK, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_remove_directory() {
+    run(PREVIEW1_REMOVE_DIRECTORY, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_remove_nonempty_directory() {
+    run(PREVIEW1_REMOVE_NONEMPTY_DIRECTORY, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_renumber() {
+    run(PREVIEW1_RENUMBER, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_sched_yield() {
+    run(PREVIEW1_SCHED_YIELD, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_stdio() {
+    run(PREVIEW1_STDIO, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_stdio_isatty() {
+    // If the test process is setup such that stdio is a terminal:
+    if test_programs_artifacts::stdio_is_terminal() {
+        // Inherit stdio, test asserts each is not tty:
+        run(PREVIEW1_STDIO_ISATTY, true).await.unwrap()
+    }
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_stdio_not_isatty() {
+    // Don't inherit stdio, test asserts each is not tty:
+    run(PREVIEW1_STDIO_NOT_ISATTY, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_symlink_create() {
+    run(PREVIEW1_SYMLINK_CREATE, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_symlink_filestat() {
+    run(PREVIEW1_SYMLINK_FILESTAT, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_symlink_loop() {
+    run(PREVIEW1_SYMLINK_LOOP, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_unlink_file_trailing_slashes() {
+    run(PREVIEW1_UNLINK_FILE_TRAILING_SLASHES, false)
+        .await
+        .unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_preopen() {
+    run(PREVIEW1_PATH_OPEN_PREOPEN, false).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_unicode_output() {
+    run(PREVIEW1_UNICODE_OUTPUT, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_file_write() {
+    run(PREVIEW1_FILE_WRITE, true).await.unwrap()
+}
+#[test_log::test(tokio::test(flavor = "multi_thread"))]
+async fn preview1_path_open_lots() {
+    run(PREVIEW1_PATH_OPEN_LOTS, true).await.unwrap()
+}
diff --git a/crates/wasi/tests/all/sync.rs b/crates/wasi/tests/all/sync.rs
new file mode 100644
index 000000000000..5629d5d3ffd8
--- /dev/null
+++ b/crates/wasi/tests/all/sync.rs
@@ -0,0 +1,335 @@
+use super::*;
+use std::path::Path;
+use test_programs_artifacts::*;
+use wasmtime_wasi::add_to_linker_sync;
+use wasmtime_wasi::bindings::sync::Command;
+
+fn run(path: &str, inherit_stdio: bool) -> Result<()> {
+    let path = Path::new(path);
+    let name = path.file_stem().unwrap().to_str().unwrap();
+    let engine = test_programs_artifacts::engine(|_| {});
+    let mut linker = Linker::new(&engine);
+    add_to_linker_sync(&mut linker)?;
+
+    let component = Component::from_file(&engine, path)?;
+
+    for blocking in [false, true] {
+        let (mut store, _td) = store(&engine, name, |builder| {
+            if inherit_stdio {
+                builder.inherit_stdio();
+            }
+            builder.allow_blocking_current_thread(blocking);
+        })?;
+        let command = Command::instantiate(&mut store, &component, &linker)?;
+        command
+            .wasi_cli_run()
+            .call_run(&mut store)?
+            .map_err(|()| anyhow::anyhow!("run returned a failure"))?;
+    }
+    Ok(())
+}
+
+foreach_preview1!(assert_test_exists);
+foreach_preview2!(assert_test_exists);
+
+// Below here is mechanical: there should be one test for every binary in
+// wasi-tests.
+#[test_log::test]
+fn preview1_big_random_buf() {
+    run(PREVIEW1_BIG_RANDOM_BUF_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_clock_time_get() {
+    run(PREVIEW1_CLOCK_TIME_GET_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_close_preopen() {
+    run(PREVIEW1_CLOSE_PREOPEN_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_dangling_fd() {
+    run(PREVIEW1_DANGLING_FD_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_dangling_symlink() {
+    run(PREVIEW1_DANGLING_SYMLINK_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_directory_seek() {
+    run(PREVIEW1_DIRECTORY_SEEK_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_dir_fd_op_failures() {
+    run(PREVIEW1_DIR_FD_OP_FAILURES_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_fd_advise() {
+    run(PREVIEW1_FD_ADVISE_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_fd_filestat_get() {
+    run(PREVIEW1_FD_FILESTAT_GET_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_fd_filestat_set() {
+    run(PREVIEW1_FD_FILESTAT_SET_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_fd_flags_set() {
+    run(PREVIEW1_FD_FLAGS_SET_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_fd_readdir() {
+    run(PREVIEW1_FD_READDIR_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_file_allocate() {
+    run(PREVIEW1_FILE_ALLOCATE_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_file_pread_pwrite() {
+    run(PREVIEW1_FILE_PREAD_PWRITE_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_file_read_write() {
+    run(PREVIEW1_FILE_READ_WRITE_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_file_seek_tell() {
+    run(PREVIEW1_FILE_SEEK_TELL_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_file_truncation() {
+    run(PREVIEW1_FILE_TRUNCATION_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_file_unbuffered_write() {
+    run(PREVIEW1_FILE_UNBUFFERED_WRITE_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_interesting_paths() {
+    run(PREVIEW1_INTERESTING_PATHS_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_regular_file_isatty() {
+    run(PREVIEW1_REGULAR_FILE_ISATTY_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_nofollow_errors() {
+    run(PREVIEW1_NOFOLLOW_ERRORS_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_overwrite_preopen() {
+    run(PREVIEW1_OVERWRITE_PREOPEN_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_path_exists() {
+    run(PREVIEW1_PATH_EXISTS_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_path_filestat() {
+    run(PREVIEW1_PATH_FILESTAT_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_path_link() {
+    run(PREVIEW1_PATH_LINK_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_path_open_create_existing() {
+    run(PREVIEW1_PATH_OPEN_CREATE_EXISTING_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_path_open_read_write() {
+    run(PREVIEW1_PATH_OPEN_READ_WRITE_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_path_open_dirfd_not_dir() {
+    run(PREVIEW1_PATH_OPEN_DIRFD_NOT_DIR_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_path_open_missing() {
+    run(PREVIEW1_PATH_OPEN_MISSING_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_path_open_nonblock() {
+    run(PREVIEW1_PATH_OPEN_NONBLOCK_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_path_rename_dir_trailing_slashes() {
+    run(PREVIEW1_PATH_RENAME_DIR_TRAILING_SLASHES_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_path_rename() {
+    run(PREVIEW1_PATH_RENAME_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_path_symlink_trailing_slashes() {
+    run(PREVIEW1_PATH_SYMLINK_TRAILING_SLASHES_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_poll_oneoff_files() {
+    run(PREVIEW1_POLL_ONEOFF_FILES_COMPONENT, false).unwrap()
+}
+
+#[test_log::test]
+fn preview1_poll_oneoff_stdio() {
+    run(PREVIEW1_POLL_ONEOFF_STDIO_COMPONENT, true).unwrap()
+}
+#[test_log::test]
+fn preview1_readlink() {
+    run(PREVIEW1_READLINK_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_remove_directory() {
+    run(PREVIEW1_REMOVE_DIRECTORY_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_remove_nonempty_directory() {
+    run(PREVIEW1_REMOVE_NONEMPTY_DIRECTORY_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_renumber() {
+    run(PREVIEW1_RENUMBER_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_sched_yield() {
+    run(PREVIEW1_SCHED_YIELD_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_stdio() {
+    run(PREVIEW1_STDIO_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_stdio_isatty() {
+    // If the test process is setup such that stdio is a terminal:
+    if test_programs_artifacts::stdio_is_terminal() {
+        // Inherit stdio, test asserts each is not tty:
+        run(PREVIEW1_STDIO_ISATTY_COMPONENT, true).unwrap()
+    }
+}
+#[test_log::test]
+fn preview1_stdio_not_isatty() {
+    // Don't inherit stdio, test asserts each is not tty:
+    run(PREVIEW1_STDIO_NOT_ISATTY_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_symlink_create() {
+    run(PREVIEW1_SYMLINK_CREATE_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_symlink_filestat() {
+    run(PREVIEW1_SYMLINK_FILESTAT_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_symlink_loop() {
+    run(PREVIEW1_SYMLINK_LOOP_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_unlink_file_trailing_slashes() {
+    run(PREVIEW1_UNLINK_FILE_TRAILING_SLASHES_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_path_open_preopen() {
+    run(PREVIEW1_PATH_OPEN_PREOPEN_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_unicode_output() {
+    run(PREVIEW1_UNICODE_OUTPUT_COMPONENT, true).unwrap()
+}
+#[test_log::test]
+fn preview1_file_write() {
+    run(PREVIEW1_FILE_WRITE_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview1_path_open_lots() {
+    run(PREVIEW1_PATH_OPEN_LOTS_COMPONENT, false).unwrap()
+}
+
+#[test_log::test]
+fn preview2_sleep() {
+    run(PREVIEW2_SLEEP_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_random() {
+    run(PREVIEW2_RANDOM_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_ip_name_lookup() {
+    run(PREVIEW2_IP_NAME_LOOKUP_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_tcp_sockopts() {
+    run(PREVIEW2_TCP_SOCKOPTS_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_tcp_sample_application() {
+    run(PREVIEW2_TCP_SAMPLE_APPLICATION_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_tcp_states() {
+    run(PREVIEW2_TCP_STATES_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_tcp_streams() {
+    run(PREVIEW2_TCP_STREAMS_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_tcp_bind() {
+    run(PREVIEW2_TCP_BIND_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_tcp_connect() {
+    run(PREVIEW2_TCP_CONNECT_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_udp_sockopts() {
+    run(PREVIEW2_UDP_SOCKOPTS_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_udp_sample_application() {
+    run(PREVIEW2_UDP_SAMPLE_APPLICATION_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_udp_states() {
+    run(PREVIEW2_UDP_STATES_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_udp_bind() {
+    run(PREVIEW2_UDP_BIND_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_udp_connect() {
+    run(PREVIEW2_UDP_CONNECT_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_stream_pollable_correct() {
+    run(PREVIEW2_STREAM_POLLABLE_CORRECT_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_stream_pollable_traps() {
+    let e = run(PREVIEW2_STREAM_POLLABLE_TRAPS_COMPONENT, false).unwrap_err();
+    assert_eq!(
+        format!("{}", e.source().expect("trap source")),
+        "resource has children"
+    )
+}
+#[test_log::test]
+fn preview2_pollable_correct() {
+    run(PREVIEW2_POLLABLE_CORRECT_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_pollable_traps() {
+    let e = run(PREVIEW2_POLLABLE_TRAPS_COMPONENT, false).unwrap_err();
+    assert_eq!(
+        format!("{}", e.source().expect("trap source")),
+        "empty poll list"
+    )
+}
+#[test_log::test]
+fn preview2_adapter_badfd() {
+    run(PREVIEW2_ADAPTER_BADFD_COMPONENT, false).unwrap()
+}
+#[test_log::test]
+fn preview2_file_read_write() {
+    run(PREVIEW2_FILE_READ_WRITE_COMPONENT, false).unwrap()
+}
diff --git a/crates/wasi/tests/process_stdin.rs b/crates/wasi/tests/process_stdin.rs
new file mode 100644
index 000000000000..df1aeff7d815
--- /dev/null
+++ b/crates/wasi/tests/process_stdin.rs
@@ -0,0 +1,165 @@
+use std::io::{BufRead, Write};
+use std::process::Command;
+use wasmtime_wasi::{HostInputStream, Subscribe};
+
+const VAR_NAME: &str = "__CHILD_PROCESS";
+
+fn main() {
+    if cfg!(miri) {
+        return;
+    }
+    // Skip this tests if it looks like we're in a cross-compiled situation and
+    // we're emulating this test for a different platform. In that scenario
+    // emulators (like QEMU) tend to not report signals the same way and such.
+    if std::env::vars()
+        .filter(|(k, _v)| k.starts_with("CARGO_TARGET") && k.ends_with("RUNNER"))
+        .count()
+        > 0
+    {
+        return;
+    }
+
+    match std::env::var(VAR_NAME) {
+        Ok(_) => child_process(),
+        Err(_) => parent_process(),
+    }
+
+    fn child_process() {
+        let mut result_write = std::io::stderr();
+        let mut child_running = true;
+        while child_running {
+            tokio::runtime::Builder::new_multi_thread()
+                .enable_all()
+                .build()
+                .unwrap()
+                .block_on(async {
+                    'task: loop {
+                        println!("child: creating stdin");
+                        let mut stdin = wasmtime_wasi::stdin();
+
+                        println!("child: checking that stdin is not ready");
+                        assert!(
+                            tokio::time::timeout(
+                                std::time::Duration::from_millis(100),
+                                stdin.ready()
+                            )
+                            .await
+                            .is_err(),
+                            "stdin available too soon"
+                        );
+
+                        writeln!(&mut result_write, "start").unwrap();
+
+                        println!("child: started");
+
+                        let mut buffer = String::new();
+                        loop {
+                            println!("child: waiting for stdin to be ready");
+                            stdin.ready().await;
+
+                            println!("child: reading input");
+                            // We can't effectively test for the case where stdin was closed, so panic if it is...
+                            let bytes = stdin.read(1024).unwrap();
+
+                            println!("child got: {bytes:?}");
+
+                            buffer.push_str(std::str::from_utf8(bytes.as_ref()).unwrap());
+                            if let Some((line, rest)) = buffer.split_once('\n') {
+                                if line == "all done" {
+                                    writeln!(&mut result_write, "done").unwrap();
+                                    println!("child: exiting...");
+                                    child_running = false;
+                                    break 'task;
+                                } else if line == "restart_runtime" {
+                                    writeln!(&mut result_write, "restarting").unwrap();
+                                    println!("child: restarting runtime...");
+                                    break 'task;
+                                } else if line == "restart_task" {
+                                    writeln!(&mut result_write, "restarting").unwrap();
+                                    println!("child: restarting task...");
+                                    continue 'task;
+                                } else {
+                                    writeln!(&mut result_write, "{line}").unwrap();
+                                }
+
+                                buffer = rest.to_owned();
+                            }
+                        }
+                    }
+                });
+            println!("child: runtime exited");
+        }
+        println!("child: exiting");
+    }
+}
+
+fn parent_process() {
+    let me = std::env::current_exe().unwrap();
+    let mut cmd = Command::new(me);
+    cmd.env(VAR_NAME, "1");
+    cmd.stdin(std::process::Stdio::piped());
+
+    if std::env::args().any(|arg| arg == "--nocapture") {
+        cmd.stdout(std::process::Stdio::inherit());
+    } else {
+        cmd.stdout(std::process::Stdio::null());
+    }
+
+    cmd.stderr(std::process::Stdio::piped());
+    let mut child = cmd.spawn().unwrap();
+
+    let mut stdin_write = child.stdin.take().unwrap();
+    let mut result_read = std::io::BufReader::new(child.stderr.take().unwrap());
+
+    let mut line = String::new();
+    result_read.read_line(&mut line).unwrap();
+    assert_eq!(line, "start\n");
+
+    for i in 0..5 {
+        let message = format!("some bytes {i}\n");
+        stdin_write.write_all(message.as_bytes()).unwrap();
+        line.clear();
+        result_read.read_line(&mut line).unwrap();
+        assert_eq!(line, message);
+    }
+
+    writeln!(&mut stdin_write, "restart_task").unwrap();
+    line.clear();
+    result_read.read_line(&mut line).unwrap();
+    assert_eq!(line, "restarting\n");
+    line.clear();
+
+    result_read.read_line(&mut line).unwrap();
+    assert_eq!(line, "start\n");
+
+    for i in 0..10 {
+        let message = format!("more bytes {i}\n");
+        stdin_write.write_all(message.as_bytes()).unwrap();
+        line.clear();
+        result_read.read_line(&mut line).unwrap();
+        assert_eq!(line, message);
+    }
+
+    writeln!(&mut stdin_write, "restart_runtime").unwrap();
+    line.clear();
+    result_read.read_line(&mut line).unwrap();
+    assert_eq!(line, "restarting\n");
+    line.clear();
+
+    result_read.read_line(&mut line).unwrap();
+    assert_eq!(line, "start\n");
+
+    for i in 0..17 {
+        let message = format!("even more bytes {i}\n");
+        stdin_write.write_all(message.as_bytes()).unwrap();
+        line.clear();
+        result_read.read_line(&mut line).unwrap();
+        assert_eq!(line, message);
+    }
+
+    writeln!(&mut stdin_write, "all done").unwrap();
+
+    line.clear();
+    result_read.read_line(&mut line).unwrap();
+    assert_eq!(line, "done\n");
+}
diff --git a/crates/wasi/wit/command-extended.wit b/crates/wasi/wit/command-extended.wit
deleted file mode 100644
index 3c56808e4abe..000000000000
--- a/crates/wasi/wit/command-extended.wit
+++ /dev/null
@@ -1,37 +0,0 @@
-// All of the same imports and exports available in the wasi:cli/command world
-// with addition of HTTP proxy related imports:
-world command-extended {
-  import wasi:clocks/wall-clock
-  import wasi:clocks/monotonic-clock
-  import wasi:clocks/timezone
-  import wasi:filesystem/types
-  import wasi:filesystem/preopens
-  import wasi:sockets/instance-network
-  import wasi:sockets/ip-name-lookup
-  import wasi:sockets/network
-  import wasi:sockets/tcp-create-socket
-  import wasi:sockets/tcp
-  import wasi:sockets/udp-create-socket
-  import wasi:sockets/udp
-  import wasi:random/random
-  import wasi:random/insecure
-  import wasi:random/insecure-seed
-  import wasi:io/poll
-  import wasi:io/streams
-  import wasi:cli/environment
-  import wasi:cli/exit
-  import wasi:cli/stdin
-  import wasi:cli/stdout
-  import wasi:cli/stderr
-  import wasi:cli/terminal-input
-  import wasi:cli/terminal-output
-  import wasi:cli/terminal-stdin
-  import wasi:cli/terminal-stdout
-  import wasi:cli/terminal-stderr
-
-  // We should replace all others with `include self.command`
-  // as soon as the unioning of worlds is available:
-  // https://github.com/WebAssembly/component-model/issues/169
-  import wasi:logging/logging
-  import wasi:http/outgoing-handler
-}
diff --git a/crates/wasi/wit/deps/cli/command.wit b/crates/wasi/wit/deps/cli/command.wit
index d28f5f6282a4..dc064a3cd9ed 100644
--- a/crates/wasi/wit/deps/cli/command.wit
+++ b/crates/wasi/wit/deps/cli/command.wit
@@ -1,7 +1,10 @@
-package wasi:cli
+package wasi:cli@0.2.1;
 
+@since(version = 0.2.0)
 world command {
-  include reactor
+  @since(version = 0.2.0)
+  include imports;
 
-  export run
+  @since(version = 0.2.0)
+  export run;
 }
diff --git a/crates/wasi/wit/deps/cli/environment.wit b/crates/wasi/wit/deps/cli/environment.wit
index 36790fe714d2..2f449bd7c1f2 100644
--- a/crates/wasi/wit/deps/cli/environment.wit
+++ b/crates/wasi/wit/deps/cli/environment.wit
@@ -1,3 +1,4 @@
+@since(version = 0.2.0)
 interface environment {
   /// Get the POSIX-style environment variables.
   ///
@@ -7,12 +8,15 @@ interface environment {
   /// Morally, these are a value import, but until value imports are available
   /// in the component model, this import function should return the same
   /// values each time it is called.
-  get-environment: func() -> list<tuple<string, string>>
+  @since(version = 0.2.0)
+  get-environment: func() -> list<tuple<string, string>>;
 
   /// Get the POSIX-style arguments to the program.
-  get-arguments: func() -> list<string>
+  @since(version = 0.2.0)
+  get-arguments: func() -> list<string>;
 
   /// Return a path that programs should use as their initial current working
   /// directory, interpreting `.` as shorthand for this.
-  initial-cwd: func() -> option<string>
+  @since(version = 0.2.0)
+  initial-cwd: func() -> option<string>;
 }
diff --git a/crates/wasi/wit/deps/cli/exit.wit b/crates/wasi/wit/deps/cli/exit.wit
index 4831d50789af..427935c8d085 100644
--- a/crates/wasi/wit/deps/cli/exit.wit
+++ b/crates/wasi/wit/deps/cli/exit.wit
@@ -1,4 +1,17 @@
+@since(version = 0.2.0)
 interface exit {
   /// Exit the current instance and any linked instances.
-  exit: func(status: result)
+  @since(version = 0.2.0)
+  exit: func(status: result);
+
+  /// Exit the current instance and any linked instances, reporting the
+  /// specified status code to the host.
+  ///
+  /// The meaning of the code depends on the context, with 0 usually meaning
+  /// "success", and other values indicating various types of failure.
+  ///
+  /// This function does not return; the effect is analogous to a trap, but
+  /// without the connotation that something bad has happened.
+  @unstable(feature = cli-exit-with-code)
+  exit-with-code: func(status-code: u8);
 }
diff --git a/crates/wasi/wit/deps/cli/imports.wit b/crates/wasi/wit/deps/cli/imports.wit
new file mode 100644
index 000000000000..b8339d3b22e5
--- /dev/null
+++ b/crates/wasi/wit/deps/cli/imports.wit
@@ -0,0 +1,36 @@
+package wasi:cli@0.2.1;
+
+@since(version = 0.2.0)
+world imports {
+  @since(version = 0.2.0)
+  include wasi:clocks/imports@0.2.1;
+  @since(version = 0.2.0)
+  include wasi:filesystem/imports@0.2.1;
+  @since(version = 0.2.0)
+  include wasi:sockets/imports@0.2.1;
+  @since(version = 0.2.0)
+  include wasi:random/imports@0.2.1;
+  @since(version = 0.2.0)
+  include wasi:io/imports@0.2.1;
+
+  @since(version = 0.2.0)
+  import environment;
+  @since(version = 0.2.0)
+  import exit;
+  @since(version = 0.2.0)
+  import stdin;
+  @since(version = 0.2.0)
+  import stdout;
+  @since(version = 0.2.0)
+  import stderr;
+  @since(version = 0.2.0)
+  import terminal-input;
+  @since(version = 0.2.0)
+  import terminal-output;
+  @since(version = 0.2.0)
+  import terminal-stdin;
+  @since(version = 0.2.0)
+  import terminal-stdout;
+  @since(version = 0.2.0)
+  import terminal-stderr;
+}
diff --git a/crates/wasi/wit/deps/cli/reactor.wit b/crates/wasi/wit/deps/cli/reactor.wit
deleted file mode 100644
index 274d0644dc41..000000000000
--- a/crates/wasi/wit/deps/cli/reactor.wit
+++ /dev/null
@@ -1,33 +0,0 @@
-package wasi:cli
-
-world reactor {
-  import wasi:clocks/wall-clock
-  import wasi:clocks/monotonic-clock
-  import wasi:clocks/timezone
-  import wasi:filesystem/types
-  import wasi:filesystem/preopens
-  import wasi:sockets/instance-network
-  import wasi:sockets/ip-name-lookup
-  import wasi:sockets/network
-  import wasi:sockets/tcp-create-socket
-  import wasi:sockets/tcp
-  import wasi:sockets/udp-create-socket
-  import wasi:sockets/udp
-  import wasi:random/random
-  import wasi:random/insecure
-  import wasi:random/insecure-seed
-  import wasi:io/poll
-  import wasi:io/streams
-
-  import environment
-  import exit
-  import stdin
-  import stdout
-  import stderr
-  import terminal-input
-  import terminal-output
-  import terminal-stdin
-  import terminal-stdout
-  import terminal-stderr
-}
-
diff --git a/crates/wasi/wit/deps/cli/run.wit b/crates/wasi/wit/deps/cli/run.wit
index 45a1ca533f0e..655346efb6dd 100644
--- a/crates/wasi/wit/deps/cli/run.wit
+++ b/crates/wasi/wit/deps/cli/run.wit
@@ -1,4 +1,6 @@
+@since(version = 0.2.0)
 interface run {
   /// Run the program.
-  run: func() -> result
+  @since(version = 0.2.0)
+  run: func() -> result;
 }
diff --git a/crates/wasi/wit/deps/cli/stdio.wit b/crates/wasi/wit/deps/cli/stdio.wit
index 6c9d4a41a6f9..d1d26eb6153d 100644
--- a/crates/wasi/wit/deps/cli/stdio.wit
+++ b/crates/wasi/wit/deps/cli/stdio.wit
@@ -1,17 +1,26 @@
+@since(version = 0.2.0)
 interface stdin {
-  use wasi:io/streams.{input-stream}
+  @since(version = 0.2.0)
+  use wasi:io/streams@0.2.1.{input-stream};
 
-  get-stdin: func() -> input-stream
+  @since(version = 0.2.0)
+  get-stdin: func() -> input-stream;
 }
 
+@since(version = 0.2.0)
 interface stdout {
-  use wasi:io/streams.{output-stream}
+  @since(version = 0.2.0)
+  use wasi:io/streams@0.2.1.{output-stream};
 
-  get-stdout: func() -> output-stream
+  @since(version = 0.2.0)
+  get-stdout: func() -> output-stream;
 }
 
+@since(version = 0.2.0)
 interface stderr {
-  use wasi:io/streams.{output-stream}
+  @since(version = 0.2.0)
+  use wasi:io/streams@0.2.1.{output-stream};
 
-  get-stderr: func() -> output-stream
+  @since(version = 0.2.0)
+  get-stderr: func() -> output-stream;
 }
diff --git a/crates/wasi/wit/deps/cli/terminal.wit b/crates/wasi/wit/deps/cli/terminal.wit
index b0a5bec2a2c7..d305498c64de 100644
--- a/crates/wasi/wit/deps/cli/terminal.wit
+++ b/crates/wasi/wit/deps/cli/terminal.wit
@@ -1,47 +1,62 @@
+/// Terminal input.
+///
+/// In the future, this may include functions for disabling echoing,
+/// disabling input buffering so that keyboard events are sent through
+/// immediately, querying supported features, and so on.
+@since(version = 0.2.0)
 interface terminal-input {
     /// The input side of a terminal.
-    resource terminal-input
-
-    // In the future, this may include functions for disabling echoing,
-    // disabling input buffering so that keyboard events are sent through
-    // immediately, querying supported features, and so on.
+    @since(version = 0.2.0)
+    resource terminal-input;
 }
 
+/// Terminal output.
+///
+/// In the future, this may include functions for querying the terminal
+/// size, being notified of terminal size changes, querying supported
+/// features, and so on.
+@since(version = 0.2.0)
 interface terminal-output {
     /// The output side of a terminal.
-    resource terminal-output
-
-    // In the future, this may include functions for querying the terminal
-    // size, being notified of terminal size changes, querying supported
-    // features, and so on.
+    @since(version = 0.2.0)
+    resource terminal-output;
 }
 
 /// An interface providing an optional `terminal-input` for stdin as a
 /// link-time authority.
+@since(version = 0.2.0)
 interface terminal-stdin {
-    use terminal-input.{terminal-input}
+    @since(version = 0.2.0)
+    use terminal-input.{terminal-input};
 
     /// If stdin is connected to a terminal, return a `terminal-input` handle
     /// allowing further interaction with it.
-    get-terminal-stdin: func() -> option<terminal-input>
+    @since(version = 0.2.0)
+    get-terminal-stdin: func() -> option<terminal-input>;
 }
 
 /// An interface providing an optional `terminal-output` for stdout as a
 /// link-time authority.
+@since(version = 0.2.0)
 interface terminal-stdout {
-    use terminal-output.{terminal-output}
+    @since(version = 0.2.0)
+    use terminal-output.{terminal-output};
 
     /// If stdout is connected to a terminal, return a `terminal-output` handle
     /// allowing further interaction with it.
-    get-terminal-stdout: func() -> option<terminal-output>
+    @since(version = 0.2.0)
+    get-terminal-stdout: func() -> option<terminal-output>;
 }
 
 /// An interface providing an optional `terminal-output` for stderr as a
 /// link-time authority.
+@since(version = 0.2.0)
 interface terminal-stderr {
-    use terminal-output.{terminal-output}
+    @since(version = 0.2.0)
+    use terminal-output.{terminal-output};
 
     /// If stderr is connected to a terminal, return a `terminal-output` handle
     /// allowing further interaction with it.
-    get-terminal-stderr: func() -> option<terminal-output>
+    @since(version = 0.2.0)
+    get-terminal-stderr: func() -> option<terminal-output>;
 }
diff --git a/crates/wasi/wit/deps/clocks/monotonic-clock.wit b/crates/wasi/wit/deps/clocks/monotonic-clock.wit
index 703a5fb7a503..3c24840c980e 100644
--- a/crates/wasi/wit/deps/clocks/monotonic-clock.wit
+++ b/crates/wasi/wit/deps/clocks/monotonic-clock.wit
@@ -1,3 +1,4 @@
+package wasi:clocks@0.2.1;
 /// WASI Monotonic Clock is a clock API intended to let users measure elapsed
 /// time.
 ///
@@ -6,27 +7,44 @@
 ///
 /// A monotonic clock is a clock which has an unspecified initial value, and
 /// successive reads of the clock will produce non-decreasing values.
-///
-/// It is intended for measuring elapsed time.
+@since(version = 0.2.0)
 interface monotonic-clock {
-    use wasi:io/poll.{pollable}
+    @since(version = 0.2.0)
+    use wasi:io/poll@0.2.1.{pollable};
+
+    /// An instant in time, in nanoseconds. An instant is relative to an
+    /// unspecified initial value, and can only be compared to instances from
+    /// the same monotonic-clock.
+    @since(version = 0.2.0)
+    type instant = u64;
 
-    /// A timestamp in nanoseconds.
-    type instant = u64
+    /// A duration of time, in nanoseconds.
+    @since(version = 0.2.0)
+    type duration = u64;
 
     /// Read the current value of the clock.
     ///
     /// The clock is monotonic, therefore calling this function repeatedly will
     /// produce a sequence of non-decreasing values.
-    now: func() -> instant
+    @since(version = 0.2.0)
+    now: func() -> instant;
 
-    /// Query the resolution of the clock.
-    resolution: func() -> instant
+    /// Query the resolution of the clock. Returns the duration of time
+    /// corresponding to a clock tick.
+    @since(version = 0.2.0)
+    resolution: func() -> duration;
 
-    /// Create a `pollable` which will resolve once the specified time has been
-    /// reached.
-    subscribe: func(
+    /// Create a `pollable` which will resolve once the specified instant
+    /// has occurred.
+    @since(version = 0.2.0)
+    subscribe-instant: func(
         when: instant,
-        absolute: bool
-    ) -> pollable
+    ) -> pollable;
+
+    /// Create a `pollable` that will resolve after the specified duration has
+    /// elapsed from the time this function is invoked.
+    @since(version = 0.2.0)
+    subscribe-duration: func(
+        when: duration,
+    ) -> pollable;
 }
diff --git a/crates/wasi/wit/deps/clocks/timezone.wit b/crates/wasi/wit/deps/clocks/timezone.wit
index a872bffc7414..212da66821c4 100644
--- a/crates/wasi/wit/deps/clocks/timezone.wit
+++ b/crates/wasi/wit/deps/clocks/timezone.wit
@@ -1,5 +1,9 @@
+package wasi:clocks@0.2.1;
+
+@unstable(feature = clocks-timezone)
 interface timezone {
-    use wall-clock.{datetime}
+    @unstable(feature = clocks-timezone)
+    use wall-clock.{datetime};
 
     /// Return information needed to display the given `datetime`. This includes
     /// the UTC offset, the time zone name, and a flag indicating whether
@@ -8,15 +12,18 @@ interface timezone {
     /// If the timezone cannot be determined for the given `datetime`, return a
     /// `timezone-display` for `UTC` with a `utc-offset` of 0 and no daylight
     /// saving time.
-    display: func(when: datetime) -> timezone-display
+    @unstable(feature = clocks-timezone)
+    display: func(when: datetime) -> timezone-display;
 
     /// The same as `display`, but only return the UTC offset.
-    utc-offset: func(when: datetime) -> s32
+    @unstable(feature = clocks-timezone)
+    utc-offset: func(when: datetime) -> s32;
 
     /// Information useful for displaying the timezone of a specific `datetime`.
     ///
     /// This information may vary within a single `timezone` to reflect daylight
     /// saving time adjustments.
+    @unstable(feature = clocks-timezone)
     record timezone-display {
         /// The number of seconds difference between UTC time and the local
         /// time of the timezone.
diff --git a/crates/wasi/wit/deps/clocks/wall-clock.wit b/crates/wasi/wit/deps/clocks/wall-clock.wit
index dae44a7308cd..6be069a32749 100644
--- a/crates/wasi/wit/deps/clocks/wall-clock.wit
+++ b/crates/wasi/wit/deps/clocks/wall-clock.wit
@@ -1,3 +1,4 @@
+package wasi:clocks@0.2.1;
 /// WASI Wall Clock is a clock API intended to let users query the current
 /// time. The name "wall" makes an analogy to a "clock on the wall", which
 /// is not necessarily monotonic as it may be reset.
@@ -12,8 +13,10 @@
 /// monotonic, making it unsuitable for measuring elapsed time.
 ///
 /// It is intended for reporting the current date and time for humans.
+@since(version = 0.2.0)
 interface wall-clock {
     /// A time and date in seconds plus nanoseconds.
+    @since(version = 0.2.0)
     record datetime {
         seconds: u64,
         nanoseconds: u32,
@@ -32,10 +35,12 @@ interface wall-clock {
     ///
     /// [POSIX's Seconds Since the Epoch]: https://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xbd_chap04.html#tag_21_04_16
     /// [Unix Time]: https://en.wikipedia.org/wiki/Unix_time
-    now: func() -> datetime
+    @since(version = 0.2.0)
+    now: func() -> datetime;
 
     /// Query the resolution of the clock.
     ///
     /// The nanoseconds field of the output is always less than 1000000000.
-    resolution: func() -> datetime
+    @since(version = 0.2.0)
+    resolution: func() -> datetime;
 }
diff --git a/crates/wasi/wit/deps/clocks/world.wit b/crates/wasi/wit/deps/clocks/world.wit
index 5c2dd411d2d0..9251ac6456e3 100644
--- a/crates/wasi/wit/deps/clocks/world.wit
+++ b/crates/wasi/wit/deps/clocks/world.wit
@@ -1,7 +1,11 @@
-package wasi:clocks
+package wasi:clocks@0.2.1;
 
+@since(version = 0.2.0)
 world imports {
-    import monotonic-clock
-    import wall-clock
-    import timezone
+    @since(version = 0.2.0)
+    import monotonic-clock;
+    @since(version = 0.2.0)
+    import wall-clock;
+    @unstable(feature = clocks-timezone)
+    import timezone;
 }
diff --git a/crates/wasi/wit/deps/filesystem/preopens.wit b/crates/wasi/wit/deps/filesystem/preopens.wit
index f45661b8a849..ca2f726af972 100644
--- a/crates/wasi/wit/deps/filesystem/preopens.wit
+++ b/crates/wasi/wit/deps/filesystem/preopens.wit
@@ -1,6 +1,11 @@
+package wasi:filesystem@0.2.1;
+
+@since(version = 0.2.0)
 interface preopens {
-    use types.{descriptor}
+    @since(version = 0.2.0)
+    use types.{descriptor};
 
     /// Return the set of preopened directories, and their path.
-    get-directories: func() -> list<tuple<descriptor, string>>
+    @since(version = 0.2.0)
+    get-directories: func() -> list<tuple<descriptor, string>>;
 }
diff --git a/crates/wasi/wit/deps/filesystem/types.wit b/crates/wasi/wit/deps/filesystem/types.wit
index 3f69bf997a29..db3d96867bab 100644
--- a/crates/wasi/wit/deps/filesystem/types.wit
+++ b/crates/wasi/wit/deps/filesystem/types.wit
@@ -1,3 +1,4 @@
+package wasi:filesystem@0.2.1;
 /// WASI filesystem is a filesystem API primarily intended to let users run WASI
 /// programs that access their files on their existing filesystems, without
 /// significant overhead.
@@ -22,16 +23,21 @@
 /// [WASI filesystem path resolution].
 ///
 /// [WASI filesystem path resolution]: https://github.com/WebAssembly/wasi-filesystem/blob/main/path-resolution.md
+@since(version = 0.2.0)
 interface types {
-    use wasi:io/streams.{input-stream, output-stream}
-    use wasi:clocks/wall-clock.{datetime}
+    @since(version = 0.2.0)
+    use wasi:io/streams@0.2.1.{input-stream, output-stream, error};
+    @since(version = 0.2.0)
+    use wasi:clocks/wall-clock@0.2.1.{datetime};
 
     /// File size or length of a region within a file.
-    type filesize = u64
+    @since(version = 0.2.0)
+    type filesize = u64;
 
     /// The type of a filesystem object referenced by a descriptor.
     ///
     /// Note: This was called `filetype` in earlier versions of WASI.
+    @since(version = 0.2.0)
     enum descriptor-type {
         /// The type of the descriptor or file is unknown or is different from
         /// any of the other types specified.
@@ -55,6 +61,7 @@ interface types {
     /// Descriptor flags.
     ///
     /// Note: This was called `fdflags` in earlier versions of WASI.
+    @since(version = 0.2.0)
     flags descriptor-flags {
         /// Read mode: Data can be read.
         read,
@@ -76,7 +83,7 @@ interface types {
         /// WASI. At this time, it should be interpreted as a request, and not a
         /// requirement.
         data-integrity-sync,
-        /// Requests that reads be performed at the same level of integrety
+        /// Requests that reads be performed at the same level of integrity
         /// requested for writes. This is similar to `O_RSYNC` in POSIX.
         ///
         /// The precise semantics of this operation have not yet been defined for
@@ -98,6 +105,7 @@ interface types {
     /// File attributes.
     ///
     /// Note: This was called `filestat` in earlier versions of WASI.
+    @since(version = 0.2.0)
     record descriptor-stat {
         /// File type.
         %type: descriptor-type,
@@ -124,6 +132,7 @@ interface types {
     }
 
     /// Flags determining the method of how paths are resolved.
+    @since(version = 0.2.0)
     flags path-flags {
         /// As long as the resolved path corresponds to a symbolic link, it is
         /// expanded.
@@ -131,6 +140,7 @@ interface types {
     }
 
     /// Open flags used by `open-at`.
+    @since(version = 0.2.0)
     flags open-flags {
         /// Create file if it does not exist, similar to `O_CREAT` in POSIX.
         create,
@@ -142,33 +152,12 @@ interface types {
         truncate,
     }
 
-    /// Permissions mode used by `open-at`, `change-file-permissions-at`, and
-    /// similar.
-    flags modes {
-        /// True if the resource is considered readable by the containing
-        /// filesystem.
-        readable,
-        /// True if the resource is considered writable by the containing
-        /// filesystem.
-        writable,
-        /// True if the resource is considered executable by the containing
-        /// filesystem. This does not apply to directories.
-        executable,
-    }
-
-    /// Access type used by `access-at`.
-    variant access-type {
-        /// Test for readability, writeability, or executability.
-        access(modes),
-
-        /// Test whether the path exists.
-        exists,
-    }
-
     /// Number of hard links to an inode.
-    type link-count = u64
+    @since(version = 0.2.0)
+    type link-count = u64;
 
     /// When setting a timestamp, this gives the value to set it to.
+    @since(version = 0.2.0)
     variant new-timestamp {
         /// Leave the timestamp set to its previous value.
         no-change,
@@ -270,6 +259,7 @@ interface types {
     }
 
     /// File or memory access pattern advisory information.
+    @since(version = 0.2.0)
     enum advice {
         /// The application has no advice to give on its behavior with respect
         /// to the specified data.
@@ -293,6 +283,7 @@ interface types {
 
     /// A 128-bit hash value, split into parts because wasm doesn't have a
     /// 128-bit integer type.
+    @since(version = 0.2.0)
     record metadata-hash-value {
        /// 64 bits of a 128-bit hash value.
        lower: u64,
@@ -303,6 +294,7 @@ interface types {
     /// A descriptor is a reference to a filesystem object, which may be a file,
     /// directory, named pipe, special file, or other object on which filesystem
     /// calls may be made.
+    @since(version = 0.2.0)
     resource descriptor {
         /// Return a stream for reading from a file, if available.
         ///
@@ -312,10 +304,11 @@ interface types {
         /// file and they do not interfere with each other.
         ///
         /// Note: This allows using `read-stream`, which is similar to `read` in POSIX.
+        @since(version = 0.2.0)
         read-via-stream: func(
             /// The offset within the file at which to start reading.
             offset: filesize,
-        ) -> result<input-stream, error-code>
+        ) -> result<input-stream, error-code>;
 
         /// Return a stream for writing to a file, if available.
         ///
@@ -323,10 +316,11 @@ interface types {
         ///
         /// Note: This allows using `write-stream`, which is similar to `write` in
         /// POSIX.
+        @since(version = 0.2.0)
         write-via-stream: func(
             /// The offset within the file at which to start writing.
             offset: filesize,
-        ) -> result<output-stream, error-code>
+        ) -> result<output-stream, error-code>;
 
         /// Return a stream for appending to a file, if available.
         ///
@@ -334,11 +328,13 @@ interface types {
         ///
         /// Note: This allows using `write-stream`, which is similar to `write` with
         /// `O_APPEND` in in POSIX.
-        append-via-stream: func() -> result<output-stream, error-code>
+        @since(version = 0.2.0)
+        append-via-stream: func() -> result<output-stream, error-code>;
 
         /// Provide file advisory information on a descriptor.
         ///
         /// This is similar to `posix_fadvise` in POSIX.
+        @since(version = 0.2.0)
         advise: func(
             /// The offset within the file to which the advisory applies.
             offset: filesize,
@@ -346,7 +342,7 @@ interface types {
             length: filesize,
             /// The advice.
             advice: advice
-        ) -> result<_, error-code>
+        ) -> result<_, error-code>;
 
         /// Synchronize the data of a file to disk.
         ///
@@ -354,7 +350,8 @@ interface types {
         /// opened for writing.
         ///
         /// Note: This is similar to `fdatasync` in POSIX.
-        sync-data: func() -> result<_, error-code>
+        @since(version = 0.2.0)
+        sync-data: func() -> result<_, error-code>;
 
         /// Get flags associated with a descriptor.
         ///
@@ -362,7 +359,8 @@ interface types {
         ///
         /// Note: This returns the value that was the `fs_flags` value returned
         /// from `fdstat_get` in earlier versions of WASI.
-        get-flags: func() -> result<descriptor-flags, error-code>
+        @since(version = 0.2.0)
+        get-flags: func() -> result<descriptor-flags, error-code>;
 
         /// Get the dynamic type of a descriptor.
         ///
@@ -374,25 +372,28 @@ interface types {
         ///
         /// Note: This returns the value that was the `fs_filetype` value returned
         /// from `fdstat_get` in earlier versions of WASI.
-        get-type: func() -> result<descriptor-type, error-code>
+        @since(version = 0.2.0)
+        get-type: func() -> result<descriptor-type, error-code>;
 
         /// Adjust the size of an open file. If this increases the file's size, the
         /// extra bytes are filled with zeros.
         ///
         /// Note: This was called `fd_filestat_set_size` in earlier versions of WASI.
-        set-size: func(size: filesize) -> result<_, error-code>
+        @since(version = 0.2.0)
+        set-size: func(size: filesize) -> result<_, error-code>;
 
         /// Adjust the timestamps of an open file or directory.
         ///
         /// Note: This is similar to `futimens` in POSIX.
         ///
         /// Note: This was called `fd_filestat_set_times` in earlier versions of WASI.
+        @since(version = 0.2.0)
         set-times: func(
             /// The desired values of the data access timestamp.
             data-access-timestamp: new-timestamp,
             /// The desired values of the data modification timestamp.
             data-modification-timestamp: new-timestamp,
-        ) -> result<_, error-code>
+        ) -> result<_, error-code>;
 
         /// Read from a descriptor, without using and updating the descriptor's offset.
         ///
@@ -405,12 +406,13 @@ interface types {
         /// In the future, this may change to return a `stream<u8, error-code>`.
         ///
         /// Note: This is similar to `pread` in POSIX.
+        @since(version = 0.2.0)
         read: func(
             /// The maximum number of bytes to read.
             length: filesize,
             /// The offset within the file at which to read.
             offset: filesize,
-        ) -> result<tuple<list<u8>, bool>, error-code>
+        ) -> result<tuple<list<u8>, bool>, error-code>;
 
         /// Write to a descriptor, without using and updating the descriptor's offset.
         ///
@@ -421,12 +423,13 @@ interface types {
         /// In the future, this may change to take a `stream<u8, error-code>`.
         ///
         /// Note: This is similar to `pwrite` in POSIX.
+        @since(version = 0.2.0)
         write: func(
             /// Data to write
             buffer: list<u8>,
             /// The offset within the file at which to write.
             offset: filesize,
-        ) -> result<filesize, error-code>
+        ) -> result<filesize, error-code>;
 
         /// Read directory entries from a directory.
         ///
@@ -437,7 +440,8 @@ interface types {
         /// This always returns a new stream which starts at the beginning of the
         /// directory. Multiple streams may be active on the same directory, and they
         /// do not interfere with each other.
-        read-directory: func() -> result<directory-entry-stream, error-code>
+        @since(version = 0.2.0)
+        read-directory: func() -> result<directory-entry-stream, error-code>;
 
         /// Synchronize the data and metadata of a file to disk.
         ///
@@ -445,15 +449,17 @@ interface types {
         /// opened for writing.
         ///
         /// Note: This is similar to `fsync` in POSIX.
-        sync: func() -> result<_, error-code>
+        @since(version = 0.2.0)
+        sync: func() -> result<_, error-code>;
 
         /// Create a directory.
         ///
         /// Note: This is similar to `mkdirat` in POSIX.
+        @since(version = 0.2.0)
         create-directory-at: func(
             /// The relative path at which to create the directory.
             path: string,
-        ) -> result<_, error-code>
+        ) -> result<_, error-code>;
 
         /// Return the attributes of an open file or directory.
         ///
@@ -464,7 +470,8 @@ interface types {
         /// modified, use `metadata-hash`.
         ///
         /// Note: This was called `fd_filestat_get` in earlier versions of WASI.
-        stat: func() -> result<descriptor-stat, error-code>
+        @since(version = 0.2.0)
+        stat: func() -> result<descriptor-stat, error-code>;
 
         /// Return the attributes of a file or directory.
         ///
@@ -473,12 +480,13 @@ interface types {
         /// discussion of alternatives.
         ///
         /// Note: This was called `path_filestat_get` in earlier versions of WASI.
+        @since(version = 0.2.0)
         stat-at: func(
             /// Flags determining the method of how the path is resolved.
             path-flags: path-flags,
             /// The relative path of the file or directory to inspect.
             path: string,
-        ) -> result<descriptor-stat, error-code>
+        ) -> result<descriptor-stat, error-code>;
 
         /// Adjust the timestamps of a file or directory.
         ///
@@ -486,6 +494,7 @@ interface types {
         ///
         /// Note: This was called `path_filestat_set_times` in earlier versions of
         /// WASI.
+        @since(version = 0.2.0)
         set-times-at: func(
             /// Flags determining the method of how the path is resolved.
             path-flags: path-flags,
@@ -495,11 +504,12 @@ interface types {
             data-access-timestamp: new-timestamp,
             /// The desired values of the data modification timestamp.
             data-modification-timestamp: new-timestamp,
-        ) -> result<_, error-code>
+        ) -> result<_, error-code>;
 
         /// Create a hard link.
         ///
         /// Note: This is similar to `linkat` in POSIX.
+        @since(version = 0.2.0)
         link-at: func(
             /// Flags determining the method of how the path is resolved.
             old-path-flags: path-flags,
@@ -509,7 +519,7 @@ interface types {
             new-descriptor: borrow<descriptor>,
             /// The relative destination path at which to create the hard link.
             new-path: string,
-        ) -> result<_, error-code>
+        ) -> result<_, error-code>;
 
         /// Open a file or directory.
         ///
@@ -529,6 +539,7 @@ interface types {
         /// `error-code::read-only`.
         ///
         /// Note: This is similar to `openat` in POSIX.
+        @since(version = 0.2.0)
         open-at: func(
             /// Flags determining the method of how the path is resolved.
             path-flags: path-flags,
@@ -538,9 +549,7 @@ interface types {
             open-flags: open-flags,
             /// Flags to use for the resulting descriptor.
             %flags: descriptor-flags,
-            /// Permissions to use when creating a new file.
-            modes: modes
-        ) -> result<descriptor, error-code>
+        ) -> result<descriptor, error-code>;
 
         /// Read the contents of a symbolic link.
         ///
@@ -548,24 +557,27 @@ interface types {
         /// filesystem, this function fails with `error-code::not-permitted`.
         ///
         /// Note: This is similar to `readlinkat` in POSIX.
+        @since(version = 0.2.0)
         readlink-at: func(
             /// The relative path of the symbolic link from which to read.
             path: string,
-        ) -> result<string, error-code>
+        ) -> result<string, error-code>;
 
         /// Remove a directory.
         ///
         /// Return `error-code::not-empty` if the directory is not empty.
         ///
         /// Note: This is similar to `unlinkat(fd, path, AT_REMOVEDIR)` in POSIX.
+        @since(version = 0.2.0)
         remove-directory-at: func(
             /// The relative path to a directory to remove.
             path: string,
-        ) -> result<_, error-code>
+        ) -> result<_, error-code>;
 
         /// Rename a filesystem object.
         ///
         /// Note: This is similar to `renameat` in POSIX.
+        @since(version = 0.2.0)
         rename-at: func(
             /// The relative source path of the file or directory to rename.
             old-path: string,
@@ -573,7 +585,7 @@ interface types {
             new-descriptor: borrow<descriptor>,
             /// The relative destination path to which to rename the file or directory.
             new-path: string,
-        ) -> result<_, error-code>
+        ) -> result<_, error-code>;
 
         /// Create a symbolic link (also known as a "symlink").
         ///
@@ -581,173 +593,23 @@ interface types {
         /// `error-code::not-permitted`.
         ///
         /// Note: This is similar to `symlinkat` in POSIX.
+        @since(version = 0.2.0)
         symlink-at: func(
             /// The contents of the symbolic link.
             old-path: string,
             /// The relative destination path at which to create the symbolic link.
             new-path: string,
-        ) -> result<_, error-code>
-
-        /// Check accessibility of a filesystem path.
-        ///
-        /// Check whether the given filesystem path names an object which is
-        /// readable, writable, or executable, or whether it exists.
-        ///
-        /// This does not a guarantee that subsequent accesses will succeed, as
-        /// filesystem permissions may be modified asynchronously by external
-        /// entities.
-        ///
-        /// Note: This is similar to `faccessat` with the `AT_EACCESS` flag in POSIX.
-        access-at: func(
-            /// Flags determining the method of how the path is resolved.
-            path-flags: path-flags,
-            /// The relative path to check.
-            path: string,
-            /// The type of check to perform.
-            %type: access-type
-        ) -> result<_, error-code>
+        ) -> result<_, error-code>;
 
         /// Unlink a filesystem object that is not a directory.
         ///
         /// Return `error-code::is-directory` if the path refers to a directory.
         /// Note: This is similar to `unlinkat(fd, path, 0)` in POSIX.
+        @since(version = 0.2.0)
         unlink-file-at: func(
             /// The relative path to a file to unlink.
             path: string,
-        ) -> result<_, error-code>
-
-        /// Change the permissions of a filesystem object that is not a directory.
-        ///
-        /// Note that the ultimate meanings of these permissions is
-        /// filesystem-specific.
-        ///
-        /// Note: This is similar to `fchmodat` in POSIX.
-        change-file-permissions-at: func(
-            /// Flags determining the method of how the path is resolved.
-            path-flags: path-flags,
-            /// The relative path to operate on.
-            path: string,
-            /// The new permissions for the filesystem object.
-            modes: modes,
-        ) -> result<_, error-code>
-
-        /// Change the permissions of a directory.
-        ///
-        /// Note that the ultimate meanings of these permissions is
-        /// filesystem-specific.
-        ///
-        /// Unlike in POSIX, the `executable` flag is not reinterpreted as a "search"
-        /// flag. `read` on a directory implies readability and searchability, and
-        /// `execute` is not valid for directories.
-        ///
-        /// Note: This is similar to `fchmodat` in POSIX.
-        change-directory-permissions-at: func(
-            /// Flags determining the method of how the path is resolved.
-            path-flags: path-flags,
-            /// The relative path to operate on.
-            path: string,
-            /// The new permissions for the directory.
-            modes: modes,
-        ) -> result<_, error-code>
-
-        /// Request a shared advisory lock for an open file.
-        ///
-        /// This requests a *shared* lock; more than one shared lock can be held for
-        /// a file at the same time.
-        ///
-        /// If the open file has an exclusive lock, this function downgrades the lock
-        /// to a shared lock. If it has a shared lock, this function has no effect.
-        ///
-        /// This requests an *advisory* lock, meaning that the file could be accessed
-        /// by other programs that don't hold the lock.
-        ///
-        /// It is unspecified how shared locks interact with locks acquired by
-        /// non-WASI programs.
-        ///
-        /// This function blocks until the lock can be acquired.
-        ///
-        /// Not all filesystems support locking; on filesystems which don't support
-        /// locking, this function returns `error-code::unsupported`.
-        ///
-        /// Note: This is similar to `flock(fd, LOCK_SH)` in Unix.
-        lock-shared: func() -> result<_, error-code>
-
-        /// Request an exclusive advisory lock for an open file.
-        ///
-        /// This requests an *exclusive* lock; no other locks may be held for the
-        /// file while an exclusive lock is held.
-        ///
-        /// If the open file has a shared lock and there are no exclusive locks held
-        /// for the file, this function upgrades the lock to an exclusive lock. If the
-        /// open file already has an exclusive lock, this function has no effect.
-        ///
-        /// This requests an *advisory* lock, meaning that the file could be accessed
-        /// by other programs that don't hold the lock.
-        ///
-        /// It is unspecified whether this function succeeds if the file descriptor
-        /// is not opened for writing. It is unspecified how exclusive locks interact
-        /// with locks acquired by non-WASI programs.
-        ///
-        /// This function blocks until the lock can be acquired.
-        ///
-        /// Not all filesystems support locking; on filesystems which don't support
-        /// locking, this function returns `error-code::unsupported`.
-        ///
-        /// Note: This is similar to `flock(fd, LOCK_EX)` in Unix.
-        lock-exclusive: func() -> result<_, error-code>
-
-        /// Request a shared advisory lock for an open file.
-        ///
-        /// This requests a *shared* lock; more than one shared lock can be held for
-        /// a file at the same time.
-        ///
-        /// If the open file has an exclusive lock, this function downgrades the lock
-        /// to a shared lock. If it has a shared lock, this function has no effect.
-        ///
-        /// This requests an *advisory* lock, meaning that the file could be accessed
-        /// by other programs that don't hold the lock.
-        ///
-        /// It is unspecified how shared locks interact with locks acquired by
-        /// non-WASI programs.
-        ///
-        /// This function returns `error-code::would-block` if the lock cannot be
-        /// acquired.
-        ///
-        /// Not all filesystems support locking; on filesystems which don't support
-        /// locking, this function returns `error-code::unsupported`.
-        ///
-        /// Note: This is similar to `flock(fd, LOCK_SH | LOCK_NB)` in Unix.
-        try-lock-shared: func() -> result<_, error-code>
-
-        /// Request an exclusive advisory lock for an open file.
-        ///
-        /// This requests an *exclusive* lock; no other locks may be held for the
-        /// file while an exclusive lock is held.
-        ///
-        /// If the open file has a shared lock and there are no exclusive locks held
-        /// for the file, this function upgrades the lock to an exclusive lock. If the
-        /// open file already has an exclusive lock, this function has no effect.
-        ///
-        /// This requests an *advisory* lock, meaning that the file could be accessed
-        /// by other programs that don't hold the lock.
-        ///
-        /// It is unspecified whether this function succeeds if the file descriptor
-        /// is not opened for writing. It is unspecified how exclusive locks interact
-        /// with locks acquired by non-WASI programs.
-        ///
-        /// This function returns `error-code::would-block` if the lock cannot be
-        /// acquired.
-        ///
-        /// Not all filesystems support locking; on filesystems which don't support
-        /// locking, this function returns `error-code::unsupported`.
-        ///
-        /// Note: This is similar to `flock(fd, LOCK_EX | LOCK_NB)` in Unix.
-        try-lock-exclusive: func() -> result<_, error-code>
-
-        /// Release a shared or exclusive lock on an open file.
-        ///
-        /// Note: This is similar to `flock(fd, LOCK_UN)` in Unix.
-        unlock: func() -> result<_, error-code>
+        ) -> result<_, error-code>;
 
         /// Test whether two descriptors refer to the same filesystem object.
         ///
@@ -755,7 +617,8 @@ interface types {
         /// same device (`st_dev`) and inode (`st_ino` or `d_ino`) numbers.
         /// wasi-filesystem does not expose device and inode numbers, so this function
         /// may be used instead.
-        is-same-object: func(other: borrow<descriptor>) -> bool
+        @since(version = 0.2.0)
+        is-same-object: func(other: borrow<descriptor>) -> bool;
 
         /// Return a hash of the metadata associated with a filesystem object referred
         /// to by a descriptor.
@@ -776,23 +639,40 @@ interface types {
         ///    computed hash.
         ///
         /// However, none of these is required.
-        metadata-hash: func() -> result<metadata-hash-value, error-code>
+        @since(version = 0.2.0)
+        metadata-hash: func() -> result<metadata-hash-value, error-code>;
 
         /// Return a hash of the metadata associated with a filesystem object referred
         /// to by a directory descriptor and a relative path.
         ///
         /// This performs the same hash computation as `metadata-hash`.
+        @since(version = 0.2.0)
         metadata-hash-at: func(
             /// Flags determining the method of how the path is resolved.
             path-flags: path-flags,
             /// The relative path of the file or directory to inspect.
             path: string,
-        ) -> result<metadata-hash-value, error-code>
+        ) -> result<metadata-hash-value, error-code>;
     }
 
     /// A stream of directory entries.
+    @since(version = 0.2.0)
     resource directory-entry-stream {
         /// Read a single directory entry from a `directory-entry-stream`.
-        read-directory-entry: func() -> result<option<directory-entry>, error-code>
+        @since(version = 0.2.0)
+        read-directory-entry: func() -> result<option<directory-entry>, error-code>;
     }
+
+    /// Attempts to extract a filesystem-related `error-code` from the stream
+    /// `error` provided.
+    ///
+    /// Stream operations which return `stream-error::last-operation-failed`
+    /// have a payload with more information about the operation that failed.
+    /// This payload can be passed through to this function to see if there's
+    /// filesystem-related information about the error to return.
+    ///
+    /// Note that this function is fallible because not all stream-related
+    /// errors are filesystem-related errors.
+    @since(version = 0.2.0)
+    filesystem-error-code: func(err: borrow<error>) -> option<error-code>;
 }
diff --git a/crates/wasi/wit/deps/filesystem/world.wit b/crates/wasi/wit/deps/filesystem/world.wit
index 5fa7eafdb850..af0146cbc95b 100644
--- a/crates/wasi/wit/deps/filesystem/world.wit
+++ b/crates/wasi/wit/deps/filesystem/world.wit
@@ -1,6 +1,9 @@
-package wasi:filesystem
+package wasi:filesystem@0.2.1;
 
+@since(version = 0.2.0)
 world imports {
-    import types
-    import preopens
+    @since(version = 0.2.0)
+    import types;
+    @since(version = 0.2.0)
+    import preopens;
 }
diff --git a/crates/wasi/wit/deps/http/incoming-handler.wit b/crates/wasi/wit/deps/http/incoming-handler.wit
deleted file mode 100644
index ad8a43f8ccf0..000000000000
--- a/crates/wasi/wit/deps/http/incoming-handler.wit
+++ /dev/null
@@ -1,24 +0,0 @@
-// The `wasi:http/incoming-handler` interface is meant to be exported by
-// components and called by the host in response to a new incoming HTTP
-// response.
-//
-//   NOTE: in Preview3, this interface will be merged with
-//   `wasi:http/outgoing-handler` into a single `wasi:http/handler` interface
-//   that takes a `request` parameter and returns a `response` result.
-//
-interface incoming-handler {
-  use types.{incoming-request, response-outparam}
-
-  // The `handle` function takes an outparam instead of returning its response
-  // so that the component may stream its response while streaming any other
-  // request or response bodies. The callee MUST write a response to the
-  // `response-outparam` and then finish the response before returning. The `handle`
-  // function is allowed to continue execution after finishing the response's
-  // output stream. While this post-response execution is taken off the
-  // critical path, since there is no return value, there is no way to report
-  // its success or failure.
-  handle: func(
-    request: /* own */ incoming-request,
-    response-out: /* own */ response-outparam
-  )
-}
diff --git a/crates/wasi/wit/deps/http/outgoing-handler.wit b/crates/wasi/wit/deps/http/outgoing-handler.wit
deleted file mode 100644
index 43bd0035fc06..000000000000
--- a/crates/wasi/wit/deps/http/outgoing-handler.wit
+++ /dev/null
@@ -1,20 +0,0 @@
-// The `wasi:http/outgoing-handler` interface is meant to be imported by
-// components and implemented by the host.
-//
-//   NOTE: in Preview3, this interface will be merged with
-//   `wasi:http/outgoing-handler` into a single `wasi:http/handler` interface
-//   that takes a `request` parameter and returns a `response` result.
-//
-interface outgoing-handler {
-  use types.{outgoing-request, request-options, future-incoming-response, error}
-
-  // The parameter and result types of the `handle` function allow the caller
-  // to concurrently stream the bodies of the outgoing request and the incoming
-  // response.
-  // Consumes the outgoing-request. Gives an error if the outgoing-request
-  // is invalid or cannot be satisfied by this handler.
-  handle: func(
-    request: /* own */ outgoing-request,
-    options: option<request-options>
-  ) -> result<future-incoming-response, error>
-}
diff --git a/crates/wasi/wit/deps/http/proxy.wit b/crates/wasi/wit/deps/http/proxy.wit
deleted file mode 100644
index 162ab32b2348..000000000000
--- a/crates/wasi/wit/deps/http/proxy.wit
+++ /dev/null
@@ -1,34 +0,0 @@
-package wasi:http
-
-// The `wasi:http/proxy` world captures a widely-implementable intersection of
-// hosts that includes HTTP forward and reverse proxies. Components targeting
-// this world may concurrently stream in and out any number of incoming and
-// outgoing HTTP requests.
-world proxy {
-  // HTTP proxies have access to time and randomness.
-  import wasi:clocks/wall-clock
-  import wasi:clocks/monotonic-clock
-  import wasi:clocks/timezone
-  import wasi:random/random
-
-  // Proxies have standard output and error streams which are expected to
-  // terminate in a developer-facing console provided by the host.
-  import wasi:cli/stdout
-  import wasi:cli/stderr
-
-  // TODO: this is a temporary workaround until component tooling is able to
-  // gracefully handle the absence of stdin. Hosts must return an eof stream
-  // for this import, which is what wasi-libc + tooling will do automatically
-  // when this import is properly removed.
-  import wasi:cli/stdin
-
-  // This is the default handler to use when user code simply wants to make an
-  // HTTP request (e.g., via `fetch()`).
-  import outgoing-handler
-
-  // The host delivers incoming HTTP requests to a component by calling the
-  // `handle` function of this exported interface. A host may arbitrarily reuse
-  // or not reuse component instance when delivering incoming HTTP requests and
-  // thus a component must be able to handle 0..N calls to `handle`.
-  export incoming-handler
-}
diff --git a/crates/wasi/wit/deps/http/types.wit b/crates/wasi/wit/deps/http/types.wit
deleted file mode 100644
index aa486f3c7c7c..000000000000
--- a/crates/wasi/wit/deps/http/types.wit
+++ /dev/null
@@ -1,214 +0,0 @@
-// The `wasi:http/types` interface is meant to be imported by components to
-// define the HTTP resource types and operations used by the component's
-// imported and exported interfaces.
-interface types {
-  use wasi:io/streams.{input-stream, output-stream}
-  use wasi:io/poll.{pollable}
-
-  // This type corresponds to HTTP standard Methods.
-  variant method {
-    get,
-    head,
-    post,
-    put,
-    delete,
-    connect,
-    options,
-    trace,
-    patch,
-    other(string)
-  }
-
-  // This type corresponds to HTTP standard Related Schemes.
-  variant scheme {
-    HTTP,
-    HTTPS,
-    other(string)
-  }
-
-  // TODO: perhaps better align with HTTP semantics?
-  // This type enumerates the different kinds of errors that may occur when
-  // initially returning a response.
-  variant error {
-    invalid-url(string),
-    timeout-error(string),
-    protocol-error(string),
-    unexpected-error(string)
-  }
-
-  // This following block defines the `fields` resource which corresponds to
-  // HTTP standard Fields. Soon, when resource types are added, the `type
-  // fields = u32` type alias can be replaced by a proper `resource fields`
-  // definition containing all the functions using the method syntactic sugar.
-  resource fields {
-    // Multiple values for a header are multiple entries in the list with the
-    // same key.
-    constructor(entries: list<tuple<string,list<u8>>>)
-
-    // Values off wire are not necessarily well formed, so they are given by
-    // list<u8> instead of string.
-    get: func(name: string) -> list<list<u8>>
-
-    // Values off wire are not necessarily well formed, so they are given by
-    // list<u8> instead of string.
-    set: func(name: string, value: list<list<u8>>)
-    delete: func(name: string)
-    append: func(name: string, value: list<u8>)
-
-    // Values off wire are not necessarily well formed, so they are given by
-    // list<u8> instead of string.
-    entries: func() -> list<tuple<string,list<u8>>>
-
-    // Deep copy of all contents in a fields.
-    clone: func() -> fields
-  }
-
-  type headers = fields
-  type trailers = fields
-
-  // The following block defines the `incoming-request` and `outgoing-request`
-  // resource types that correspond to HTTP standard Requests. Soon, when
-  // resource types are added, the `u32` type aliases can be replaced by
-  // proper `resource` type definitions containing all the functions as
-  // methods. Later, Preview2 will allow both types to be merged together into
-  // a single `request` type (that uses the single `stream` type mentioned
-  // above). The `consume` and `write` methods may only be called once (and
-  // return failure thereafter).
-  resource incoming-request {
-    method: func() -> method
-
-    path-with-query: func() -> option<string>
-
-    scheme: func() -> option<scheme>
-
-    authority: func() -> option<string>
-
-    headers: func() -> /* child */ headers
-    // Will return the input-stream child at most once. If called more than
-    // once, subsequent calls will return error.
-
-    consume: func() -> result< /* own */ incoming-body>
-  }
-
-  resource outgoing-request {
-    constructor(
-      method: method,
-      path-with-query: option<string>,
-      scheme: option<scheme>,
-      authority: option<string>,
-      headers: /* borrow */ headers
-    )
-
-    // Will return the outgoing-body child at most once. If called more than
-    // once, subsequent calls will return error.
-    write: func() -> result< /* child */ outgoing-body>
-  }
-
-  // Additional optional parameters that can be set when making a request.
-  record request-options {
-    // The following timeouts are specific to the HTTP protocol and work
-    // independently of the overall timeouts passed to `io.poll.poll-list`.
-
-    // The timeout for the initial connect.
-    connect-timeout-ms: option<u32>,
-
-    // The timeout for receiving the first byte of the response body.
-    first-byte-timeout-ms: option<u32>,
-
-    // The timeout for receiving the next chunk of bytes in the response body
-    // stream.
-    between-bytes-timeout-ms: option<u32>
-  }
-
-  // The following block defines a special resource type used by the
-  // `wasi:http/incoming-handler` interface. When resource types are added, this
-  // block can be replaced by a proper `resource response-outparam { ... }`
-  // definition. Later, with Preview3, the need for an outparam goes away entirely
-  // (the `wasi:http/handler` interface used for both incoming and outgoing can
-  // simply return a `stream`).
-  resource response-outparam {
-    set: static func(param: /* own */ response-outparam, response: result< /* own */ outgoing-response, error>)
-  }
-
-  // This type corresponds to the HTTP standard Status Code.
-  type status-code = u16
-
-  // The following block defines the `incoming-response` and `outgoing-response`
-  // resource types that correspond to HTTP standard Responses. Soon, when
-  // resource types are added, the `u32` type aliases can be replaced by proper
-  // `resource` type definitions containing all the functions as methods. Later,
-  // Preview2 will allow both types to be merged together into a single `response`
-  // type (that uses the single `stream` type mentioned above). The `consume` and
-  // `write` methods may only be called once (and return failure thereafter).
-  resource incoming-response {
-    status: func() -> status-code
-
-    headers: func() -> /* child */ headers
-
-    // May be called at most once. returns error if called additional times.
-    // TODO: make incoming-request-consume work the same way, giving a child
-    // incoming-body.
-    consume: func() -> result</* own */ incoming-body>
-  }
-
-  resource incoming-body {
-    // returned input-stream is a child - the implementation may trap if
-    // incoming-body is dropped (or consumed by call to
-    // incoming-body-finish) before the input-stream is dropped.
-    // May be called at most once. returns error if called additional times.
-    %stream: func() -> result</* child */ input-stream>
-
-    // takes ownership of incoming-body. this will trap if the
-    // incoming-body-stream child is still alive!
-    finish: static func(this: /* own */ incoming-body) ->
-    /* transitive child of the incoming-response of incoming-body */ future-trailers
-  }
-
-  resource future-trailers {
-    /// Pollable that resolves when the body has been fully read, and the trailers
-    /// are ready to be consumed.
-    subscribe: func() -> /* child */ pollable
-
-    /// Retrieve reference to trailers, if they are ready.
-    get: func() -> option<result</* child */ trailers, error>>
-  }
-
-  resource outgoing-response {
-    constructor(status-code: status-code, headers: /* borrow */ headers)
-
-    /// Will give the child outgoing-response at most once. subsequent calls will
-    /// return an error.
-    write: func() -> result</* own */ outgoing-body>
-  }
-
-  resource outgoing-body {
-    /// Will give the child output-stream at most once. subsequent calls will
-    /// return an error.
-    write: func() -> result</* child */ output-stream>
-
-    /// Finalize an outgoing body, optionally providing trailers. This must be
-    /// called to signal that the response is complete. If the `outgoing-body` is
-    /// dropped without calling `outgoing-body-finalize`, the implementation
-    /// should treat the body as corrupted.
-    finish: static func(this: /* own */ outgoing-body, trailers: /* own */ option<trailers>)
-  }
-
-  /// The following block defines a special resource type used by the
-  /// `wasi:http/outgoing-handler` interface to emulate
-  /// `future<result<response, error>>` in advance of Preview3. Given a
-  /// `future-incoming-response`, the client can call the non-blocking `get`
-  /// method to get the result if it is available. If the result is not available,
-  /// the client can call `listen` to get a `pollable` that can be passed to
-  /// `wasi:io/poll.poll-list`.
-  resource future-incoming-response {
-    /// option indicates readiness.
-    /// outer result indicates you are allowed to get the
-    /// incoming-response-or-error at most once. subsequent calls after ready
-    /// will return an error here.
-    /// inner result indicates whether the incoming-response was available, or an
-    /// error occured.
-    get: func() -> option<result<result</* NOT a child*/ incoming-response, error>>>
-
-    subscribe: func() -> /* child */ pollable
-  }
-}
diff --git a/crates/wasi/wit/deps/io/error.wit b/crates/wasi/wit/deps/io/error.wit
new file mode 100644
index 000000000000..4ea29c4696b5
--- /dev/null
+++ b/crates/wasi/wit/deps/io/error.wit
@@ -0,0 +1,34 @@
+package wasi:io@0.2.1;
+
+@since(version = 0.2.0)
+interface error {
+    /// A resource which represents some error information.
+    ///
+    /// The only method provided by this resource is `to-debug-string`,
+    /// which provides some human-readable information about the error.
+    ///
+    /// In the `wasi:io` package, this resource is returned through the
+    /// `wasi:io/streams/stream-error` type.
+    ///
+    /// To provide more specific error information, other interfaces may
+    /// offer functions to "downcast" this error into more specific types. For example,
+    /// errors returned from streams derived from filesystem types can be described using
+    /// the filesystem's own error-code type. This is done using the function
+    /// `wasi:filesystem/types/filesystem-error-code`, which takes a `borrow<error>`
+    /// parameter and returns an `option<wasi:filesystem/types/error-code>`.
+    ///
+    /// The set of functions which can "downcast" an `error` into a more
+    /// concrete type is open.
+    @since(version = 0.2.0)
+    resource error {
+        /// Returns a string that is suitable to assist humans in debugging
+        /// this error.
+        ///
+        /// WARNING: The returned string should not be consumed mechanically!
+        /// It may change across platforms, hosts, or other implementation
+        /// details. Parsing this string is a major platform-compatibility
+        /// hazard.
+        @since(version = 0.2.0)
+        to-debug-string: func() -> string;
+    }
+}
diff --git a/crates/wasi/wit/deps/io/poll.wit b/crates/wasi/wit/deps/io/poll.wit
index e95762b915db..b25ac729ff7d 100644
--- a/crates/wasi/wit/deps/io/poll.wit
+++ b/crates/wasi/wit/deps/io/poll.wit
@@ -1,10 +1,27 @@
-package wasi:io
+package wasi:io@0.2.1;
 
 /// A poll API intended to let users wait for I/O events on multiple handles
 /// at once.
+@since(version = 0.2.0)
 interface poll {
-    /// A "pollable" handle.
-    resource pollable
+    /// `pollable` represents a single I/O event which may be ready, or not.
+    @since(version = 0.2.0)
+    resource pollable {
+
+      /// Return the readiness of a pollable. This function never blocks.
+      ///
+      /// Returns `true` when the pollable is ready, and `false` otherwise.
+      @since(version = 0.2.0)
+      ready: func() -> bool;
+
+      /// `block` returns immediately if the pollable is ready, and otherwise
+      /// blocks until ready.
+      ///
+      /// This function is equivalent to calling `poll.poll` on a list
+      /// containing only this pollable.
+      @since(version = 0.2.0)
+      block: func();
+    }
 
     /// Poll for completion on a set of pollables.
     ///
@@ -14,8 +31,9 @@ interface poll {
     /// The result `list<u32>` contains one or more indices of handles in the
     /// argument list that is ready for I/O.
     ///
-    /// If the list contains more elements than can be indexed with a `u32`
-    /// value, this function traps.
+    /// This function traps if either:
+    /// - the list is empty, or:
+    /// - the list contains more elements than can be indexed with a `u32` value.
     ///
     /// A timeout can be implemented by adding a pollable from the
     /// wasi-clocks API to the list.
@@ -23,12 +41,7 @@ interface poll {
     /// This function does not return a `result`; polling in itself does not
     /// do any I/O so it doesn't fail. If any of the I/O sources identified by
     /// the pollables has an error, it is indicated by marking the source as
-    /// being reaedy for I/O.
-    poll-list: func(in: list<borrow<pollable>>) -> list<u32>
-
-    /// Poll for completion on a single pollable.
-    ///
-    /// This function is similar to `poll-list`, but operates on only a single
-    /// pollable. When it returns, the handle is ready for I/O.
-    poll-one: func(in: borrow<pollable>)
+    /// being ready for I/O.
+    @since(version = 0.2.0)
+    poll: func(in: list<borrow<pollable>>) -> list<u32>;
 }
diff --git a/crates/wasi/wit/deps/io/streams.wit b/crates/wasi/wit/deps/io/streams.wit
index 8240507976f7..b697e24d61bf 100644
--- a/crates/wasi/wit/deps/io/streams.wit
+++ b/crates/wasi/wit/deps/io/streams.wit
@@ -1,17 +1,24 @@
-package wasi:io
+package wasi:io@0.2.1;
 
 /// WASI I/O is an I/O abstraction API which is currently focused on providing
 /// stream types.
 ///
 /// In the future, the component model is expected to add built-in stream types;
 /// when it does, they are expected to subsume this API.
+@since(version = 0.2.0)
 interface streams {
-    use poll.{pollable}
+    @since(version = 0.2.0)
+    use error.{error};
+    @since(version = 0.2.0)
+    use poll.{pollable};
 
     /// An error for input-stream and output-stream operations.
-    enum stream-error {
+    @since(version = 0.2.0)
+    variant stream-error {
         /// The last operation (a write or flush) failed before completion.
-        last-operation-failed,
+        ///
+        /// More information is available in the `error` payload.
+        last-operation-failed(error),
         /// The stream is closed: no more input will be accepted by the
         /// stream. A closed output-stream will return this error on all
         /// future operations.
@@ -26,64 +33,65 @@ interface streams {
     /// available, which could even be zero. To wait for data to be available,
     /// use the `subscribe` function to obtain a `pollable` which can be polled
     /// for using `wasi:io/poll`.
+    @since(version = 0.2.0)
     resource input-stream {
         /// Perform a non-blocking read from the stream.
         ///
-        /// This function returns a list of bytes containing the data that was
-        /// read, along with a `stream-status` which, indicates whether further
-        /// reads are expected to produce data. The returned list will contain up to
-        /// `len` bytes; it may return fewer than requested, but not more. An
-        /// empty list and `stream-status:open` indicates no more data is
-        /// available at this time, and that the pollable given by `subscribe`
-        /// will be ready when more data is available.
+        /// When the source of a `read` is binary data, the bytes from the source
+        /// are returned verbatim. When the source of a `read` is known to the
+        /// implementation to be text, bytes containing the UTF-8 encoding of the
+        /// text are returned.
+        ///
+        /// This function returns a list of bytes containing the read data,
+        /// when successful. The returned list will contain up to `len` bytes;
+        /// it may return fewer than requested, but not more. The list is
+        /// empty when no bytes are available for reading at this time. The
+        /// pollable given by `subscribe` will be ready when more bytes are
+        /// available.
         ///
-        /// Once a stream has reached the end, subsequent calls to `read` or
-        /// `skip` will always report `stream-status:ended` rather than producing more
-        /// data.
+        /// This function fails with a `stream-error` when the operation
+        /// encounters an error, giving `last-operation-failed`, or when the
+        /// stream is closed, giving `closed`.
         ///
-        /// When the caller gives a `len` of 0, it represents a request to read 0
-        /// bytes. This read should  always succeed and return an empty list and
-        /// the current `stream-status`.
+        /// When the caller gives a `len` of 0, it represents a request to
+        /// read 0 bytes. If the stream is still open, this call should
+        /// succeed and return an empty list, or otherwise fail with `closed`.
         ///
         /// The `len` parameter is a `u64`, which could represent a list of u8 which
         /// is not possible to allocate in wasm32, or not desirable to allocate as
         /// as a return value by the callee. The callee may return a list of bytes
         /// less than `len` in size while more bytes are available for reading.
+        @since(version = 0.2.0)
         read: func(
             /// The maximum number of bytes to read
             len: u64
-        ) -> result<list<u8>, stream-error>
+        ) -> result<list<u8>, stream-error>;
 
         /// Read bytes from a stream, after blocking until at least one byte can
-        /// be read. Except for blocking, identical to `read`.
+        /// be read. Except for blocking, behavior is identical to `read`.
+        @since(version = 0.2.0)
         blocking-read: func(
             /// The maximum number of bytes to read
             len: u64
-        ) -> result<list<u8>, stream-error>
+        ) -> result<list<u8>, stream-error>;
 
-        /// Skip bytes from a stream.
-        ///
-        /// This is similar to the `read` function, but avoids copying the
-        /// bytes into the instance.
-        ///
-        /// Once a stream has reached the end, subsequent calls to read or
-        /// `skip` will always report end-of-stream rather than producing more
-        /// data.
+        /// Skip bytes from a stream. Returns number of bytes skipped.
         ///
-        /// This function returns the number of bytes skipped, along with a
-        /// `stream-status` indicating whether the end of the stream was
-        /// reached. The returned value will be at most `len`; it may be less.
+        /// Behaves identical to `read`, except instead of returning a list
+        /// of bytes, returns the number of bytes consumed from the stream.
+        @since(version = 0.2.0)
         skip: func(
             /// The maximum number of bytes to skip.
             len: u64,
-        ) -> result<u64, stream-error>
+        ) -> result<u64, stream-error>;
 
         /// Skip bytes from a stream, after blocking until at least one byte
         /// can be skipped. Except for blocking behavior, identical to `skip`.
+        @since(version = 0.2.0)
         blocking-skip: func(
             /// The maximum number of bytes to skip.
             len: u64,
-        ) -> result<u64, stream-error>
+        ) -> result<u64, stream-error>;
 
         /// Create a `pollable` which will resolve once either the specified stream
         /// has bytes available to read or the other end of the stream has been
@@ -91,7 +99,8 @@ interface streams {
         /// The created `pollable` is a child resource of the `input-stream`.
         /// Implementations may trap if the `input-stream` is dropped before
         /// all derived `pollable`s created with this function are dropped.
-        subscribe: func() -> pollable
+        @since(version = 0.2.0)
+        subscribe: func() -> pollable;
     }
 
 
@@ -103,6 +112,11 @@ interface streams {
     /// promptly, which could even be zero. To wait for the stream to be ready to
     /// accept data, the `subscribe` function to obtain a `pollable` which can be
     /// polled for using `wasi:io/poll`.
+    ///
+    /// Dropping an `output-stream` while there's still an active write in
+    /// progress may result in the data being lost. Before dropping the stream,
+    /// be sure to fully flush your writes.
+    @since(version = 0.2.0)
     resource output-stream {
         /// Check readiness for writing. This function never blocks.
         ///
@@ -113,18 +127,26 @@ interface streams {
         /// When this function returns 0 bytes, the `subscribe` pollable will
         /// become ready when this function will report at least 1 byte, or an
         /// error.
-        check-write: func() -> result<u64, stream-error>
+        @since(version = 0.2.0)
+        check-write: func() -> result<u64, stream-error>;
 
         /// Perform a write. This function never blocks.
         ///
+        /// When the destination of a `write` is binary data, the bytes from
+        /// `contents` are written verbatim. When the destination of a `write` is
+        /// known to the implementation to be text, the bytes of `contents` are
+        /// transcoded from UTF-8 into the encoding of the destination and then
+        /// written.
+        ///
         /// Precondition: check-write gave permit of Ok(n) and contents has a
         /// length of less than or equal to n. Otherwise, this function will trap.
         ///
         /// returns Err(closed) without writing if the stream has closed since
         /// the last call to check-write provided a permit.
+        @since(version = 0.2.0)
         write: func(
             contents: list<u8>
-        ) -> result<_, stream-error>
+        ) -> result<_, stream-error>;
 
         /// Perform a write of up to 4096 bytes, and then flush the stream. Block
         /// until all of these operations are complete, or an error occurs.
@@ -137,7 +159,7 @@ interface streams {
         /// let pollable = this.subscribe();
         /// while !contents.is_empty() {
         ///     // Wait for the stream to become writable
-        ///     poll-one(pollable);
+        ///     pollable.block();
         ///     let Ok(n) = this.check-write(); // eliding error handling
         ///     let len = min(n, contents.len());
         ///     let (chunk, rest) = contents.split_at(len);
@@ -146,13 +168,14 @@ interface streams {
         /// }
         /// this.flush();
         /// // Wait for completion of `flush`
-        /// poll-one(pollable);
+        /// pollable.block();
         /// // Check for any errors that arose during `flush`
         /// let _ = this.check-write();         // eliding error handling
         /// ```
+        @since(version = 0.2.0)
         blocking-write-and-flush: func(
             contents: list<u8>
-        ) -> result<_, stream-error>
+        ) -> result<_, stream-error>;
 
         /// Request to flush buffered output. This function never blocks.
         ///
@@ -164,14 +187,16 @@ interface streams {
         /// writes (`check-write` will return `ok(0)`) until the flush has
         /// completed. The `subscribe` pollable will become ready when the
         /// flush has completed and the stream can accept more writes.
-        flush: func() -> result<_, stream-error>
+        @since(version = 0.2.0)
+        flush: func() -> result<_, stream-error>;
 
         /// Request to flush buffered output, and block until flush completes
         /// and stream is ready for writing again.
-        blocking-flush: func() -> result<_, stream-error>
+        @since(version = 0.2.0)
+        blocking-flush: func() -> result<_, stream-error>;
 
         /// Create a `pollable` which will resolve once the output-stream
-        /// is ready for more writing, or an error has occured. When this
+        /// is ready for more writing, or an error has occurred. When this
         /// pollable is ready, `check-write` will return `ok(n)` with n>0, or an
         /// error.
         ///
@@ -180,18 +205,19 @@ interface streams {
         /// The created `pollable` is a child resource of the `output-stream`.
         /// Implementations may trap if the `output-stream` is dropped before
         /// all derived `pollable`s created with this function are dropped.
-        subscribe: func() -> pollable
+        subscribe: func() -> pollable;
 
         /// Write zeroes to a stream.
         ///
-        /// this should be used precisely like `write` with the exact same
+        /// This should be used precisely like `write` with the exact same
         /// preconditions (must use check-write first), but instead of
         /// passing a list of bytes, you simply pass the number of zero-bytes
         /// that should be written.
+        @since(version = 0.2.0)
         write-zeroes: func(
             /// The number of zero-bytes to write
             len: u64
-        ) -> result<_, stream-error>
+        ) -> result<_, stream-error>;
 
         /// Perform a write of up to 4096 zeroes, and then flush the stream.
         /// Block until all of these operations are complete, or an error
@@ -205,7 +231,7 @@ interface streams {
         /// let pollable = this.subscribe();
         /// while num_zeroes != 0 {
         ///     // Wait for the stream to become writable
-        ///     poll-one(pollable);
+        ///     pollable.block();
         ///     let Ok(n) = this.check-write(); // eliding error handling
         ///     let len = min(n, num_zeroes);
         ///     this.write-zeroes(len);         // eliding error handling
@@ -213,55 +239,48 @@ interface streams {
         /// }
         /// this.flush();
         /// // Wait for completion of `flush`
-        /// poll-one(pollable);
+        /// pollable.block();
         /// // Check for any errors that arose during `flush`
         /// let _ = this.check-write();         // eliding error handling
         /// ```
+        @since(version = 0.2.0)
         blocking-write-zeroes-and-flush: func(
             /// The number of zero-bytes to write
             len: u64
-        ) -> result<_, stream-error>
+        ) -> result<_, stream-error>;
 
         /// Read from one stream and write to another.
         ///
+        /// The behavior of splice is equivalent to:
+        /// 1. calling `check-write` on the `output-stream`
+        /// 2. calling `read` on the `input-stream` with the smaller of the
+        /// `check-write` permitted length and the `len` provided to `splice`
+        /// 3. calling `write` on the `output-stream` with that read data.
+        ///
+        /// Any error reported by the call to `check-write`, `read`, or
+        /// `write` ends the splice and reports that error.
+        ///
         /// This function returns the number of bytes transferred; it may be less
         /// than `len`.
-        ///
-        /// Unlike other I/O functions, this function blocks until all the data
-        /// read from the input stream has been written to the output stream.
+        @since(version = 0.2.0)
         splice: func(
             /// The stream to read from
-            src: input-stream,
+            src: borrow<input-stream>,
             /// The number of bytes to splice
             len: u64,
-        ) -> result<u64, stream-error>
+        ) -> result<u64, stream-error>;
 
         /// Read from one stream and write to another, with blocking.
         ///
-        /// This is similar to `splice`, except that it blocks until at least
-        /// one byte can be read.
+        /// This is similar to `splice`, except that it blocks until the
+        /// `output-stream` is ready for writing, and the `input-stream`
+        /// is ready for reading, before performing the `splice`.
+        @since(version = 0.2.0)
         blocking-splice: func(
             /// The stream to read from
-            src: input-stream,
+            src: borrow<input-stream>,
             /// The number of bytes to splice
             len: u64,
-        ) -> result<u64, stream-error>
-
-        /// Forward the entire contents of an input stream to an output stream.
-        ///
-        /// This function repeatedly reads from the input stream and writes
-        /// the data to the output stream, until the end of the input stream
-        /// is reached, or an error is encountered.
-        ///
-        /// Unlike other I/O functions, this function blocks until the end
-        /// of the input stream is seen and all the data has been written to
-        /// the output stream.
-        ///
-        /// This function returns the number of bytes transferred, and the status of
-        /// the output stream.
-        forward: func(
-            /// The stream to read from
-            src: input-stream
-        ) -> result<u64, stream-error>
+        ) -> result<u64, stream-error>;
     }
 }
diff --git a/crates/wasi/wit/deps/io/world.wit b/crates/wasi/wit/deps/io/world.wit
index 8738dba756d9..6405a4e4820c 100644
--- a/crates/wasi/wit/deps/io/world.wit
+++ b/crates/wasi/wit/deps/io/world.wit
@@ -1,6 +1,10 @@
-package wasi:io
+package wasi:io@0.2.1;
 
+@since(version = 0.2.0)
 world imports {
-    import streams
-    import poll
+    @since(version = 0.2.0)
+    import streams;
+
+    @since(version = 0.2.0)
+    import poll;
 }
diff --git a/crates/wasi/wit/deps/logging/logging.wit b/crates/wasi/wit/deps/logging/logging.wit
deleted file mode 100644
index b0cc4514dc8f..000000000000
--- a/crates/wasi/wit/deps/logging/logging.wit
+++ /dev/null
@@ -1,37 +0,0 @@
-package wasi:logging
-
-/// WASI Logging is a logging API intended to let users emit log messages with
-/// simple priority levels and context values.
-interface logging {
-    /// A log level, describing a kind of message.
-    enum level {
-       /// Describes messages about the values of variables and the flow of
-       /// control within a program.
-       trace,
-
-       /// Describes messages likely to be of interest to someone debugging a
-       /// program.
-       debug,
-
-       /// Describes messages likely to be of interest to someone monitoring a
-       /// program.
-       info,
-
-       /// Describes messages indicating hazardous situations.
-       warn,
-
-       /// Describes messages indicating serious errors.
-       error,
-
-       /// Describes messages indicating fatal errors.
-       critical,
-    }
-
-    /// Emit a log message.
-    ///
-    /// A log message has a `level` describing what kind of message is being
-    /// sent, a context, which is an uninterpreted string meant to help
-    /// consumers group similar messages, and a string containing the message
-    /// text.
-    log: func(level: level, context: string, message: string)
-}
diff --git a/crates/wasi/wit/deps/logging/world.wit b/crates/wasi/wit/deps/logging/world.wit
deleted file mode 100644
index 7d49acfaddaa..000000000000
--- a/crates/wasi/wit/deps/logging/world.wit
+++ /dev/null
@@ -1,5 +0,0 @@
-package wasi:logging
-
-world imports {
-    import logging
-}
diff --git a/crates/wasi/wit/deps/random/insecure-seed.wit b/crates/wasi/wit/deps/random/insecure-seed.wit
index ff2ff65d0754..7e708dc52bfe 100644
--- a/crates/wasi/wit/deps/random/insecure-seed.wit
+++ b/crates/wasi/wit/deps/random/insecure-seed.wit
@@ -1,7 +1,9 @@
+package wasi:random@0.2.1;
 /// The insecure-seed interface for seeding hash-map DoS resistance.
 ///
 /// It is intended to be portable at least between Unix-family platforms and
 /// Windows.
+@since(version = 0.2.0)
 interface insecure-seed {
     /// Return a 128-bit value that may contain a pseudo-random value.
     ///
@@ -20,5 +22,6 @@ interface insecure-seed {
     /// This will likely be changed to a value import, to prevent it from being
     /// called multiple times and potentially used for purposes other than DoS
     /// protection.
-    insecure-seed: func() -> tuple<u64, u64>
+    @since(version = 0.2.0)
+    insecure-seed: func() -> tuple<u64, u64>;
 }
diff --git a/crates/wasi/wit/deps/random/insecure.wit b/crates/wasi/wit/deps/random/insecure.wit
index ff0826822d5f..3cdb53dfbb59 100644
--- a/crates/wasi/wit/deps/random/insecure.wit
+++ b/crates/wasi/wit/deps/random/insecure.wit
@@ -1,7 +1,9 @@
+package wasi:random@0.2.1;
 /// The insecure interface for insecure pseudo-random numbers.
 ///
 /// It is intended to be portable at least between Unix-family platforms and
 /// Windows.
+@since(version = 0.2.0)
 interface insecure {
     /// Return `len` insecure pseudo-random bytes.
     ///
@@ -11,11 +13,13 @@ interface insecure {
     /// There are no requirements on the values of the returned bytes, however
     /// implementations are encouraged to return evenly distributed values with
     /// a long period.
-    get-insecure-random-bytes: func(len: u64) -> list<u8>
+    @since(version = 0.2.0)
+    get-insecure-random-bytes: func(len: u64) -> list<u8>;
 
     /// Return an insecure pseudo-random `u64` value.
     ///
     /// This function returns the same type of pseudo-random data as
     /// `get-insecure-random-bytes`, represented as a `u64`.
-    get-insecure-random-u64: func() -> u64
+    @since(version = 0.2.0)
+    get-insecure-random-u64: func() -> u64;
 }
diff --git a/crates/wasi/wit/deps/random/random.wit b/crates/wasi/wit/deps/random/random.wit
index 2a282dab7eb9..2b5035d1ce7c 100644
--- a/crates/wasi/wit/deps/random/random.wit
+++ b/crates/wasi/wit/deps/random/random.wit
@@ -1,7 +1,9 @@
+package wasi:random@0.2.1;
 /// WASI Random is a random data API.
 ///
 /// It is intended to be portable at least between Unix-family platforms and
 /// Windows.
+@since(version = 0.2.0)
 interface random {
     /// Return `len` cryptographically-secure random or pseudo-random bytes.
     ///
@@ -15,11 +17,13 @@ interface random {
     /// This function must always return fresh data. Deterministic environments
     /// must omit this function, rather than implementing it with deterministic
     /// data.
-    get-random-bytes: func(len: u64) -> list<u8>
+    @since(version = 0.2.0)
+    get-random-bytes: func(len: u64) -> list<u8>;
 
     /// Return a cryptographically-secure random or pseudo-random `u64` value.
     ///
     /// This function returns the same type of data as `get-random-bytes`,
     /// represented as a `u64`.
-    get-random-u64: func() -> u64
+    @since(version = 0.2.0)
+    get-random-u64: func() -> u64;
 }
diff --git a/crates/wasi/wit/deps/random/world.wit b/crates/wasi/wit/deps/random/world.wit
index 41dc9ed10353..c615e96dc7dd 100644
--- a/crates/wasi/wit/deps/random/world.wit
+++ b/crates/wasi/wit/deps/random/world.wit
@@ -1,7 +1,13 @@
-package wasi:random
+package wasi:random@0.2.1;
 
+@since(version = 0.2.0)
 world imports {
-    import random
-    import insecure
-    import insecure-seed
+    @since(version = 0.2.0)
+    import random;
+
+    @since(version = 0.2.0)
+    import insecure;
+
+    @since(version = 0.2.0)
+    import insecure-seed;
 }
diff --git a/crates/wasi/wit/deps/sockets/instance-network.wit b/crates/wasi/wit/deps/sockets/instance-network.wit
index d911a29cc8dd..5f6e6c1cc983 100644
--- a/crates/wasi/wit/deps/sockets/instance-network.wit
+++ b/crates/wasi/wit/deps/sockets/instance-network.wit
@@ -1,9 +1,11 @@
 
 /// This interface provides a value-export of the default network handle..
+@since(version = 0.2.0)
 interface instance-network {
-	use network.{network}
-
-	/// Get a handle to the default network.
-	instance-network: func() -> network
+    @since(version = 0.2.0)
+    use network.{network};
 
+    /// Get a handle to the default network.
+    @since(version = 0.2.0)
+    instance-network: func() -> network;
 }
diff --git a/crates/wasi/wit/deps/sockets/ip-name-lookup.wit b/crates/wasi/wit/deps/sockets/ip-name-lookup.wit
index f998aae140ab..dc56f3000703 100644
--- a/crates/wasi/wit/deps/sockets/ip-name-lookup.wit
+++ b/crates/wasi/wit/deps/sockets/ip-name-lookup.wit
@@ -1,61 +1,56 @@
-
+@since(version = 0.2.0)
 interface ip-name-lookup {
-	use wasi:io/poll.{pollable}
-	use network.{network, error-code, ip-address, ip-address-family}
-
+    @since(version = 0.2.0)
+    use wasi:io/poll@0.2.1.{pollable};
+    @since(version = 0.2.0)
+    use network.{network, error-code, ip-address};
 
-	/// Resolve an internet host name to a list of IP addresses.
-	/// 
-	/// See the wasi-socket proposal README.md for a comparison with getaddrinfo.
-	/// 
-	/// # Parameters
-	/// - `name`: The name to look up. IP addresses are not allowed. Unicode domain names are automatically converted
-	///     to ASCII using IDNA encoding.
-	/// - `address-family`: If provided, limit the results to addresses of this specific address family.
-	/// - `include-unavailable`: When set to true, this function will also return addresses of which the runtime
-	///   thinks (or knows) can't be connected to at the moment. For example, this will return IPv6 addresses on
-	///   systems without an active IPv6 interface. Notes:
-	///     - Even when no public IPv6 interfaces are present or active, names like "localhost" can still resolve to an IPv6 address.
-	///     - Whatever is "available" or "unavailable" is volatile and can change everytime a network cable is unplugged.
-	/// 
-	/// This function never blocks. It either immediately fails or immediately returns successfully with a `resolve-address-stream`
-	/// that can be used to (asynchronously) fetch the results.
-	/// 
-	/// At the moment, the stream never completes successfully with 0 items. Ie. the first call
-	/// to `resolve-next-address` never returns `ok(none)`. This may change in the future.
-	/// 
-	/// # Typical errors
-	/// - `invalid-name`:                 `name` is a syntactically invalid domain name.
-	/// - `invalid-name`:                 `name` is an IP address.
-	/// - `address-family-not-supported`: The specified `address-family` is not supported. (EAI_FAMILY)
-	/// 
-	/// # References:
-	/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getaddrinfo.html>
-	/// - <https://man7.org/linux/man-pages/man3/getaddrinfo.3.html>
-	/// - <https://learn.microsoft.com/en-us/windows/win32/api/ws2tcpip/nf-ws2tcpip-getaddrinfo>
-	/// - <https://man.freebsd.org/cgi/man.cgi?query=getaddrinfo&sektion=3>
-	resolve-addresses: func(network: borrow<network>, name: string, address-family: option<ip-address-family>, include-unavailable: bool) -> result<resolve-address-stream, error-code>
+    /// Resolve an internet host name to a list of IP addresses.
+    ///
+    /// Unicode domain names are automatically converted to ASCII using IDNA encoding.
+    /// If the input is an IP address string, the address is parsed and returned
+    /// as-is without making any external requests.
+    ///
+    /// See the wasi-socket proposal README.md for a comparison with getaddrinfo.
+    ///
+    /// This function never blocks. It either immediately fails or immediately
+    /// returns successfully with a `resolve-address-stream` that can be used
+    /// to (asynchronously) fetch the results.
+    ///
+    /// # Typical errors
+    /// - `invalid-argument`: `name` is a syntactically invalid domain name or IP address.
+    ///
+    /// # References:
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getaddrinfo.html>
+    /// - <https://man7.org/linux/man-pages/man3/getaddrinfo.3.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/ws2tcpip/nf-ws2tcpip-getaddrinfo>
+    /// - <https://man.freebsd.org/cgi/man.cgi?query=getaddrinfo&sektion=3>
+    @since(version = 0.2.0)
+    resolve-addresses: func(network: borrow<network>, name: string) -> result<resolve-address-stream, error-code>;
 
-	resource resolve-address-stream {
-		/// Returns the next address from the resolver.
-		/// 
-		/// This function should be called multiple times. On each call, it will
-		/// return the next address in connection order preference. If all
-		/// addresses have been exhausted, this function returns `none`.
-		/// 
-		/// This function never returns IPv4-mapped IPv6 addresses.
-		/// 
-		/// # Typical errors
-		/// - `name-unresolvable`:          Name does not exist or has no suitable associated IP addresses. (EAI_NONAME, EAI_NODATA, EAI_ADDRFAMILY)
-		/// - `temporary-resolver-failure`: A temporary failure in name resolution occurred. (EAI_AGAIN)
-		/// - `permanent-resolver-failure`: A permanent failure in name resolution occurred. (EAI_FAIL)
-		/// - `would-block`:                A result is not available yet. (EWOULDBLOCK, EAGAIN)
-		resolve-next-address: func() -> result<option<ip-address>, error-code>
+    @since(version = 0.2.0)
+    resource resolve-address-stream {
+        /// Returns the next address from the resolver.
+        ///
+        /// This function should be called multiple times. On each call, it will
+        /// return the next address in connection order preference. If all
+        /// addresses have been exhausted, this function returns `none`.
+        ///
+        /// This function never returns IPv4-mapped IPv6 addresses.
+        ///
+        /// # Typical errors
+        /// - `name-unresolvable`:          Name does not exist or has no suitable associated IP addresses. (EAI_NONAME, EAI_NODATA, EAI_ADDRFAMILY)
+        /// - `temporary-resolver-failure`: A temporary failure in name resolution occurred. (EAI_AGAIN)
+        /// - `permanent-resolver-failure`: A permanent failure in name resolution occurred. (EAI_FAIL)
+        /// - `would-block`:                A result is not available yet. (EWOULDBLOCK, EAGAIN)
+        @since(version = 0.2.0)
+        resolve-next-address: func() -> result<option<ip-address>, error-code>;
 
-		/// Create a `pollable` which will resolve once the stream is ready for I/O.
-		/// 
-		/// Note: this function is here for WASI Preview2 only.
-		/// It's planned to be removed when `future` is natively supported in Preview3.
-		subscribe: func() -> pollable
-	}
+        /// Create a `pollable` which will resolve once the stream is ready for I/O.
+        ///
+        /// Note: this function is here for WASI Preview2 only.
+        /// It's planned to be removed when `future` is natively supported in Preview3.
+        @since(version = 0.2.0)
+        subscribe: func() -> pollable;
+    }
 }
diff --git a/crates/wasi/wit/deps/sockets/network.wit b/crates/wasi/wit/deps/sockets/network.wit
index 8214eaaf7211..8c13b348e534 100644
--- a/crates/wasi/wit/deps/sockets/network.wit
+++ b/crates/wasi/wit/deps/sockets/network.wit
@@ -1,178 +1,153 @@
-
+@since(version = 0.2.0)
 interface network {
-	/// An opaque resource that represents access to (a subset of) the network.
-	/// This enables context-based security for networking.
-	/// There is no need for this to map 1:1 to a physical network interface.
-	resource network
-
-	/// Error codes.
-	/// 
-	/// In theory, every API can return any error code.
-	/// In practice, API's typically only return the errors documented per API
-	/// combined with a couple of errors that are always possible:
-	/// - `unknown`
-	/// - `access-denied`
-	/// - `not-supported`
-	/// - `out-of-memory`
-	/// 
-	/// See each individual API for what the POSIX equivalents are. They sometimes differ per API.
-	enum error-code {
-		// ### GENERAL ERRORS ###
-
-		/// Unknown error
-		unknown,
-
-		/// Access denied.
-		/// 
-		/// POSIX equivalent: EACCES, EPERM
-		access-denied,
-
-		/// The operation is not supported.
-		/// 
-		/// POSIX equivalent: EOPNOTSUPP
-		not-supported,
-
-		/// Not enough memory to complete the operation.
-		/// 
-		/// POSIX equivalent: ENOMEM, ENOBUFS, EAI_MEMORY
-		out-of-memory,
-
-		/// The operation timed out before it could finish completely.
-		timeout,
-
-		/// This operation is incompatible with another asynchronous operation that is already in progress.
-		concurrency-conflict,
-
-		/// Trying to finish an asynchronous operation that:
-		/// - has not been started yet, or:
-		/// - was already finished by a previous `finish-*` call.
-		/// 
-		/// Note: this is scheduled to be removed when `future`s are natively supported.
-		not-in-progress,
-
-		/// The operation has been aborted because it could not be completed immediately.
-		/// 
-		/// Note: this is scheduled to be removed when `future`s are natively supported.
-		would-block,
-
-
-		// ### IP ERRORS ###
-
-		/// The specified address-family is not supported.
-		address-family-not-supported,
-
-		/// An IPv4 address was passed to an IPv6 resource, or vice versa.
-		address-family-mismatch,
-
-		/// The socket address is not a valid remote address. E.g. the IP address is set to INADDR_ANY, or the port is set to 0.
-		invalid-remote-address,
-
-		/// The operation is only supported on IPv4 resources.
-		ipv4-only-operation,
-
-		/// The operation is only supported on IPv6 resources.
-		ipv6-only-operation,
-
-
-
-		// ### TCP & UDP SOCKET ERRORS ###
-
-		/// A new socket resource could not be created because of a system limit.
-		new-socket-limit,
-		
-		/// The socket is already attached to another network.
-		already-attached,
-
-		/// The socket is already bound.
-		already-bound,
-
-		/// The socket is already in the Connection state.
-		already-connected,
-
-		/// The socket is not bound to any local address.
-		not-bound,
-
-		/// The socket is not in the Connection state.
-		not-connected,
-
-		/// A bind operation failed because the provided address is not an address that the `network` can bind to.
-		address-not-bindable,
-
-		/// A bind operation failed because the provided address is already in use.
-		address-in-use,
-
-		/// A bind operation failed because there are no ephemeral ports available.
-		ephemeral-ports-exhausted,
-
-		/// The remote address is not reachable
-		remote-unreachable,
-		
-
-		// ### TCP SOCKET ERRORS ###
-		
-		/// The socket is already in the Listener state.
-		already-listening,
-
-		/// The socket is already in the Listener state.
-		not-listening,
-
-		/// The connection was forcefully rejected
-		connection-refused,
-
-		/// The connection was reset.
-		connection-reset,
-		
-
-		// ### UDP SOCKET ERRORS ###
-		datagram-too-large,
-
-
-		// ### NAME LOOKUP ERRORS ###
-		
-		/// The provided name is a syntactically invalid domain name.
-		invalid-name,
-
-		/// Name does not exist or has no suitable associated IP addresses.
-		name-unresolvable,
-
-		/// A temporary failure in name resolution occurred.
-		temporary-resolver-failure,
-
-		/// A permanent failure in name resolution occurred.
-		permanent-resolver-failure,
-	}
-
-	enum ip-address-family {
-		/// Similar to `AF_INET` in POSIX.
-		ipv4, 
-
-		/// Similar to `AF_INET6` in POSIX.
-		ipv6,
-	}
-
-	type ipv4-address = tuple<u8, u8, u8, u8>
-	type ipv6-address = tuple<u16, u16, u16, u16, u16, u16, u16, u16>
-
-	variant ip-address {
-		ipv4(ipv4-address),
-		ipv6(ipv6-address),
-	}
-
-	record ipv4-socket-address {
-		port: u16, // sin_port
-		address: ipv4-address, // sin_addr
-	}
+    /// An opaque resource that represents access to (a subset of) the network.
+    /// This enables context-based security for networking.
+    /// There is no need for this to map 1:1 to a physical network interface.
+    @since(version = 0.2.0)
+    resource network;
 
-	record ipv6-socket-address {
-		port: u16, // sin6_port
-		flow-info: u32, // sin6_flowinfo
-		address: ipv6-address, // sin6_addr
-		scope-id: u32, // sin6_scope_id
-	}
+    /// Error codes.
+    ///
+    /// In theory, every API can return any error code.
+    /// In practice, API's typically only return the errors documented per API
+    /// combined with a couple of errors that are always possible:
+    /// - `unknown`
+    /// - `access-denied`
+    /// - `not-supported`
+    /// - `out-of-memory`
+    /// - `concurrency-conflict`
+    ///
+    /// See each individual API for what the POSIX equivalents are. They sometimes differ per API.
+    @since(version = 0.2.0)
+    enum error-code {
+        /// Unknown error
+        unknown,
+
+        /// Access denied.
+        ///
+        /// POSIX equivalent: EACCES, EPERM
+        access-denied,
+
+        /// The operation is not supported.
+        ///
+        /// POSIX equivalent: EOPNOTSUPP
+        not-supported,
+
+        /// One of the arguments is invalid.
+        ///
+        /// POSIX equivalent: EINVAL
+        invalid-argument,
+
+        /// Not enough memory to complete the operation.
+        ///
+        /// POSIX equivalent: ENOMEM, ENOBUFS, EAI_MEMORY
+        out-of-memory,
+
+        /// The operation timed out before it could finish completely.
+        timeout,
+
+        /// This operation is incompatible with another asynchronous operation that is already in progress.
+        ///
+        /// POSIX equivalent: EALREADY
+        concurrency-conflict,
+
+        /// Trying to finish an asynchronous operation that:
+        /// - has not been started yet, or:
+        /// - was already finished by a previous `finish-*` call.
+        ///
+        /// Note: this is scheduled to be removed when `future`s are natively supported.
+        not-in-progress,
+
+        /// The operation has been aborted because it could not be completed immediately.
+        ///
+        /// Note: this is scheduled to be removed when `future`s are natively supported.
+        would-block,
+
+
+        /// The operation is not valid in the socket's current state.
+        invalid-state,
+
+        /// A new socket resource could not be created because of a system limit.
+        new-socket-limit,
+
+        /// A bind operation failed because the provided address is not an address that the `network` can bind to.
+        address-not-bindable,
+
+        /// A bind operation failed because the provided address is already in use or because there are no ephemeral ports available.
+        address-in-use,
+
+        /// The remote address is not reachable
+        remote-unreachable,
+
+
+        /// The TCP connection was forcefully rejected
+        connection-refused,
+
+        /// The TCP connection was reset.
+        connection-reset,
+
+        /// A TCP connection was aborted.
+        connection-aborted,
+
+
+        /// The size of a datagram sent to a UDP socket exceeded the maximum
+        /// supported size.
+        datagram-too-large,
+
+
+        /// Name does not exist or has no suitable associated IP addresses.
+        name-unresolvable,
+
+        /// A temporary failure in name resolution occurred.
+        temporary-resolver-failure,
+
+        /// A permanent failure in name resolution occurred.
+        permanent-resolver-failure,
+    }
+
+    @since(version = 0.2.0)
+    enum ip-address-family {
+        /// Similar to `AF_INET` in POSIX.
+        ipv4,
+
+        /// Similar to `AF_INET6` in POSIX.
+        ipv6,
+    }
+
+    @since(version = 0.2.0)
+    type ipv4-address = tuple<u8, u8, u8, u8>;
+    @since(version = 0.2.0)
+    type ipv6-address = tuple<u16, u16, u16, u16, u16, u16, u16, u16>;
+
+    @since(version = 0.2.0)
+    variant ip-address {
+        ipv4(ipv4-address),
+        ipv6(ipv6-address),
+    }
+
+    @since(version = 0.2.0)
+    record ipv4-socket-address {
+        /// sin_port
+        port: u16,
+        /// sin_addr
+        address: ipv4-address,
+    }
 
-	variant ip-socket-address {
-		ipv4(ipv4-socket-address),
-		ipv6(ipv6-socket-address),
-	}
+    @since(version = 0.2.0)
+    record ipv6-socket-address {
+        /// sin6_port
+        port: u16,
+        /// sin6_flowinfo
+        flow-info: u32,
+        /// sin6_addr
+        address: ipv6-address,
+        /// sin6_scope_id
+        scope-id: u32,
+    }
 
+    @since(version = 0.2.0)
+    variant ip-socket-address {
+        ipv4(ipv4-socket-address),
+        ipv6(ipv6-socket-address),
+    }
 }
diff --git a/crates/wasi/wit/deps/sockets/tcp-create-socket.wit b/crates/wasi/wit/deps/sockets/tcp-create-socket.wit
index f43bc8979047..eedbd30768c9 100644
--- a/crates/wasi/wit/deps/sockets/tcp-create-socket.wit
+++ b/crates/wasi/wit/deps/sockets/tcp-create-socket.wit
@@ -1,27 +1,30 @@
-
+@since(version = 0.2.0)
 interface tcp-create-socket {
-	use network.{network, error-code, ip-address-family}
-	use tcp.{tcp-socket}
+    @since(version = 0.2.0)
+    use network.{network, error-code, ip-address-family};
+    @since(version = 0.2.0)
+    use tcp.{tcp-socket};
 
-	/// Create a new TCP socket.
-	/// 
-	/// Similar to `socket(AF_INET or AF_INET6, SOCK_STREAM, IPPROTO_TCP)` in POSIX.
-	/// 
-	/// This function does not require a network capability handle. This is considered to be safe because
-	/// at time of creation, the socket is not bound to any `network` yet. Up to the moment `bind`/`listen`/`connect`
-	/// is called, the socket is effectively an in-memory configuration object, unable to communicate with the outside world.
-	/// 
-	/// All sockets are non-blocking. Use the wasi-poll interface to block on asynchronous operations.
-	/// 
-	/// # Typical errors
-	/// - `not-supported`:                The host does not support TCP sockets. (EOPNOTSUPP)
-	/// - `address-family-not-supported`: The specified `address-family` is not supported. (EAFNOSUPPORT)
-	/// - `new-socket-limit`:             The new socket resource could not be created because of a system limit. (EMFILE, ENFILE)
-	/// 
-	/// # References
-	/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/socket.html>
-	/// - <https://man7.org/linux/man-pages/man2/socket.2.html>
-	/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasocketw>
-	/// - <https://man.freebsd.org/cgi/man.cgi?query=socket&sektion=2>
-	create-tcp-socket: func(address-family: ip-address-family) -> result<tcp-socket, error-code>
+    /// Create a new TCP socket.
+    ///
+    /// Similar to `socket(AF_INET or AF_INET6, SOCK_STREAM, IPPROTO_TCP)` in POSIX.
+    /// On IPv6 sockets, IPV6_V6ONLY is enabled by default and can't be configured otherwise.
+    ///
+    /// This function does not require a network capability handle. This is considered to be safe because
+    /// at time of creation, the socket is not bound to any `network` yet. Up to the moment `bind`/`connect`
+    /// is called, the socket is effectively an in-memory configuration object, unable to communicate with the outside world.
+    ///
+    /// All sockets are non-blocking. Use the wasi-poll interface to block on asynchronous operations.
+    ///
+    /// # Typical errors
+    /// - `not-supported`:     The specified `address-family` is not supported. (EAFNOSUPPORT)
+    /// - `new-socket-limit`:  The new socket resource could not be created because of a system limit. (EMFILE, ENFILE)
+    ///
+    /// # References
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/socket.html>
+    /// - <https://man7.org/linux/man-pages/man2/socket.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasocketw>
+    /// - <https://man.freebsd.org/cgi/man.cgi?query=socket&sektion=2>
+    @since(version = 0.2.0)
+    create-tcp-socket: func(address-family: ip-address-family) -> result<tcp-socket, error-code>;
 }
diff --git a/crates/wasi/wit/deps/sockets/tcp.wit b/crates/wasi/wit/deps/sockets/tcp.wit
index 175626cc7620..bae5a29eceb4 100644
--- a/crates/wasi/wit/deps/sockets/tcp.wit
+++ b/crates/wasi/wit/deps/sockets/tcp.wit
@@ -1,249 +1,387 @@
-
+@since(version = 0.2.0)
 interface tcp {
-	use wasi:io/streams.{input-stream, output-stream}
-	use wasi:io/poll.{pollable}
-	use network.{network, error-code, ip-socket-address, ip-address-family}
-
-	enum shutdown-type {
-		/// Similar to `SHUT_RD` in POSIX.
-		receive,
-
-		/// Similar to `SHUT_WR` in POSIX.
-		send,
-
-		/// Similar to `SHUT_RDWR` in POSIX.
-		both,
-	}
-
-
-	/// A TCP socket handle.
-	resource tcp-socket {
-		/// Bind the socket to a specific network on the provided IP address and port.
-		///
-		/// If the IP address is zero (`0.0.0.0` in IPv4, `::` in IPv6), it is left to the implementation to decide which
-		/// network interface(s) to bind to.
-		/// If the TCP/UDP port is zero, the socket will be bound to a random free port.
-		/// 
-		/// When a socket is not explicitly bound, the first invocation to a listen or connect operation will
-		/// implicitly bind the socket.
-		/// 
-		/// Unlike in POSIX, this function is async. This enables interactive WASI hosts to inject permission prompts.
-		/// 
-		/// # Typical `start` errors
-		/// - `address-family-mismatch`:   The `local-address` has the wrong address family. (EINVAL)
-		/// - `already-bound`:             The socket is already bound. (EINVAL)
-		/// - `concurrency-conflict`:      Another `bind`, `connect` or `listen` operation is already in progress. (EALREADY)
-		/// 
-		/// # Typical `finish` errors
-		/// - `ephemeral-ports-exhausted`: No ephemeral ports available. (EADDRINUSE, ENOBUFS on Windows)
-		/// - `address-in-use`:            Address is already in use. (EADDRINUSE)
-		/// - `address-not-bindable`:      `local-address` is not an address that the `network` can bind to. (EADDRNOTAVAIL)
-		/// - `not-in-progress`:           A `bind` operation is not in progress.
-		/// - `would-block`:               Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)
-		/// 
-		/// # References
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/bind.html>
-		/// - <https://man7.org/linux/man-pages/man2/bind.2.html>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-bind>
-		/// - <https://man.freebsd.org/cgi/man.cgi?query=bind&sektion=2&format=html>
-		start-bind: func(network: borrow<network>, local-address: ip-socket-address) -> result<_, error-code>
-		finish-bind: func() -> result<_, error-code>
-
-		/// Connect to a remote endpoint.
-		/// 
-		/// On success:
-		/// - the socket is transitioned into the Connection state
-		/// - a pair of streams is returned that can be used to read & write to the connection
-		/// 
-		/// # Typical `start` errors
-		/// - `address-family-mismatch`:   The `remote-address` has the wrong address family. (EAFNOSUPPORT)
-		/// - `invalid-remote-address`:    The IP address in `remote-address` is set to INADDR_ANY (`0.0.0.0` / `::`). (EADDRNOTAVAIL on Windows)
-		/// - `invalid-remote-address`:    The port in `remote-address` is set to 0. (EADDRNOTAVAIL on Windows)
-		/// - `already-attached`:          The socket is already attached to a different network. The `network` passed to `connect` must be identical to the one passed to `bind`.
-		/// - `already-connected`:         The socket is already in the Connection state. (EISCONN)
-		/// - `already-listening`:         The socket is already in the Listener state. (EOPNOTSUPP, EINVAL on Windows)
-		/// - `concurrency-conflict`:      Another `bind`, `connect` or `listen` operation is already in progress. (EALREADY)
-		/// 
-		/// # Typical `finish` errors
-		/// - `timeout`:                   Connection timed out. (ETIMEDOUT)
-		/// - `connection-refused`:        The connection was forcefully rejected. (ECONNREFUSED)
-		/// - `connection-reset`:          The connection was reset. (ECONNRESET)
-		/// - `remote-unreachable`:        The remote address is not reachable. (EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN)
-		/// - `ephemeral-ports-exhausted`: Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE, EADDRNOTAVAIL on Linux, EAGAIN on BSD)
-		/// - `not-in-progress`:           A `connect` operation is not in progress.
-		/// - `would-block`:               Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)
-		/// 
-		/// # References
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/connect.html>
-		/// - <https://man7.org/linux/man-pages/man2/connect.2.html>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-connect>
-		/// - <https://man.freebsd.org/cgi/man.cgi?connect>
-		start-connect: func(network: borrow<network>, remote-address: ip-socket-address) -> result<_, error-code>
-		finish-connect: func() -> result<tuple<input-stream, output-stream>, error-code>
-
-		/// Start listening for new connections.
-		/// 
-		/// Transitions the socket into the Listener state.
-		/// 
-		/// Unlike POSIX:
-		/// - this function is async. This enables interactive WASI hosts to inject permission prompts.
-		/// - the socket must already be explicitly bound.
-		/// 
-		/// # Typical `start` errors
-		/// - `not-bound`:                 The socket is not bound to any local address. (EDESTADDRREQ)
-		/// - `already-connected`:         The socket is already in the Connection state. (EISCONN, EINVAL on BSD)
-		/// - `already-listening`:         The socket is already in the Listener state.
-		/// - `concurrency-conflict`:      Another `bind`, `connect` or `listen` operation is already in progress. (EINVAL on BSD)
-		///
-		/// # Typical `finish` errors
-		/// - `ephemeral-ports-exhausted`: Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE)
-		/// - `not-in-progress`:           A `listen` operation is not in progress.
-		/// - `would-block`:               Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)
-		///
-		/// # References
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/listen.html>
-		/// - <https://man7.org/linux/man-pages/man2/listen.2.html>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-listen>
-		/// - <https://man.freebsd.org/cgi/man.cgi?query=listen&sektion=2>
-		start-listen: func() -> result<_, error-code>
-		finish-listen: func() -> result<_, error-code>
-
-		/// Accept a new client socket.
-		/// 
-		/// The returned socket is bound and in the Connection state.
-		/// 
-		/// On success, this function returns the newly accepted client socket along with
-		/// a pair of streams that can be used to read & write to the connection.
-		/// 
-		/// # Typical errors
-		/// - `not-listening`: Socket is not in the Listener state. (EINVAL)
-		/// - `would-block`:   No pending connections at the moment. (EWOULDBLOCK, EAGAIN)
-		/// 
-		/// Host implementations must skip over transient errors returned by the native accept syscall.
-		/// 
-		/// # References
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/accept.html>
-		/// - <https://man7.org/linux/man-pages/man2/accept.2.html>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-accept>
-		/// - <https://man.freebsd.org/cgi/man.cgi?query=accept&sektion=2>
-		accept: func() -> result<tuple<tcp-socket, input-stream, output-stream>, error-code>
-
-		/// Get the bound local address.
-		/// 
-		/// # Typical errors
-		/// - `not-bound`: The socket is not bound to any local address.
-		/// 
-		/// # References
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsockname.html>
-		/// - <https://man7.org/linux/man-pages/man2/getsockname.2.html>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getsockname>
-		/// - <https://man.freebsd.org/cgi/man.cgi?getsockname>
-		local-address: func() -> result<ip-socket-address, error-code>
-
-		/// Get the bound remote address.
-		/// 
-		/// # Typical errors
-		/// - `not-connected`: The socket is not connected to a remote address. (ENOTCONN)
-		/// 
-		/// # References
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpeername.html>
-		/// - <https://man7.org/linux/man-pages/man2/getpeername.2.html>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getpeername>
-		/// - <https://man.freebsd.org/cgi/man.cgi?query=getpeername&sektion=2&n=1>
-		remote-address: func() -> result<ip-socket-address, error-code>
-
-		/// Whether this is a IPv4 or IPv6 socket.
-		/// 
-		/// Equivalent to the SO_DOMAIN socket option.
-		address-family: func() -> ip-address-family
-	
-		/// Whether IPv4 compatibility (dual-stack) mode is disabled or not.
-		/// 
-		/// Equivalent to the IPV6_V6ONLY socket option.
-		/// 
-		/// # Typical errors
-		/// - `ipv6-only-operation`:  (get/set) `this` socket is an IPv4 socket.
-		/// - `already-bound`:        (set) The socket is already bound.
-		/// - `not-supported`:        (set) Host does not support dual-stack sockets. (Implementations are not required to.)
-		/// - `concurrency-conflict`: (set) A `bind`, `connect` or `listen` operation is already in progress. (EALREADY)
-		ipv6-only: func() -> result<bool, error-code>
-		set-ipv6-only: func(value: bool) -> result<_, error-code>
-
-		/// Hints the desired listen queue size. Implementations are free to ignore this.
-		/// 
-		/// # Typical errors
-		/// - `already-connected`:    (set) The socket is already in the Connection state.
-		/// - `concurrency-conflict`: (set) A `bind`, `connect` or `listen` operation is already in progress. (EALREADY)
-		set-listen-backlog-size: func(value: u64) -> result<_, error-code>
-
-		/// Equivalent to the SO_KEEPALIVE socket option.
-		/// 
-		/// # Typical errors
-		/// - `concurrency-conflict`: (set) A `bind`, `connect` or `listen` operation is already in progress. (EALREADY)
-		keep-alive: func() -> result<bool, error-code>
-		set-keep-alive: func(value: bool) -> result<_, error-code>
-
-		/// Equivalent to the TCP_NODELAY socket option.
-		/// 
-		/// # Typical errors
-		/// - `concurrency-conflict`: (set) A `bind`, `connect` or `listen` operation is already in progress. (EALREADY)
-		no-delay: func() -> result<bool, error-code>
-		set-no-delay: func(value: bool) -> result<_, error-code>
-	
-		/// Equivalent to the IP_TTL & IPV6_UNICAST_HOPS socket options.
-		/// 
-		/// # Typical errors
-		/// - `already-connected`:    (set) The socket is already in the Connection state.
-		/// - `already-listening`:    (set) The socket is already in the Listener state.
-		/// - `concurrency-conflict`: (set) A `bind`, `connect` or `listen` operation is already in progress. (EALREADY)
-		unicast-hop-limit: func() -> result<u8, error-code>
-		set-unicast-hop-limit: func(value: u8) -> result<_, error-code>
-
-		/// The kernel buffer space reserved for sends/receives on this socket.
-		/// 
-		/// Note #1: an implementation may choose to cap or round the buffer size when setting the value.
-		/// 	In other words, after setting a value, reading the same setting back may return a different value.
-		/// 
-		/// Note #2: there is not necessarily a direct relationship between the kernel buffer size and the bytes of
-		/// 	actual data to be sent/received by the application, because the kernel might also use the buffer space
-		/// 	for internal metadata structures.
-		/// 
-		/// Equivalent to the SO_RCVBUF and SO_SNDBUF socket options.
-		/// 
-		/// # Typical errors
-		/// - `already-connected`:    (set) The socket is already in the Connection state.
-		/// - `already-listening`:    (set) The socket is already in the Listener state.
-		/// - `concurrency-conflict`: (set) A `bind`, `connect` or `listen` operation is already in progress. (EALREADY)
-		receive-buffer-size: func() -> result<u64, error-code>
-		set-receive-buffer-size: func(value: u64) -> result<_, error-code>
-		send-buffer-size: func() -> result<u64, error-code>
-		set-send-buffer-size: func(value: u64) -> result<_, error-code>
-
-		/// Create a `pollable` which will resolve once the socket is ready for I/O.
-		/// 
-		/// Note: this function is here for WASI Preview2 only.
-		/// It's planned to be removed when `future` is natively supported in Preview3.
-		subscribe: func() -> pollable
-
-		/// Initiate a graceful shutdown.
-		/// 
-		/// - receive: the socket is not expecting to receive any more data from the peer. All subsequent read
-		///   operations on the `input-stream` associated with this socket will return an End Of Stream indication.
-		///   Any data still in the receive queue at time of calling `shutdown` will be discarded.
-		/// - send: the socket is not expecting to send any more data to the peer. All subsequent write
-		///   operations on the `output-stream` associated with this socket will return an error.
-		/// - both: same effect as receive & send combined.
-		/// 
-		/// The shutdown function does not close (drop) the socket.
-		/// 
-		/// # Typical errors
-		/// - `not-connected`: The socket is not in the Connection state. (ENOTCONN)
-		/// 
-		/// # References
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/shutdown.html>
-		/// - <https://man7.org/linux/man-pages/man2/shutdown.2.html>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-shutdown>
-		/// - <https://man.freebsd.org/cgi/man.cgi?query=shutdown&sektion=2>
-		shutdown: func(shutdown-type: shutdown-type) -> result<_, error-code>
-	}
+    @since(version = 0.2.0)
+    use wasi:io/streams@0.2.1.{input-stream, output-stream};
+    @since(version = 0.2.0)
+    use wasi:io/poll@0.2.1.{pollable};
+    @since(version = 0.2.0)
+    use wasi:clocks/monotonic-clock@0.2.1.{duration};
+    @since(version = 0.2.0)
+    use network.{network, error-code, ip-socket-address, ip-address-family};
+
+    @since(version = 0.2.0)
+    enum shutdown-type {
+        /// Similar to `SHUT_RD` in POSIX.
+        receive,
+
+        /// Similar to `SHUT_WR` in POSIX.
+        send,
+
+        /// Similar to `SHUT_RDWR` in POSIX.
+        both,
+    }
+    
+    /// A TCP socket resource.
+    ///
+    /// The socket can be in one of the following states:
+    /// - `unbound`
+    /// - `bind-in-progress`
+    /// - `bound` (See note below)
+    /// - `listen-in-progress`
+    /// - `listening`
+    /// - `connect-in-progress`
+    /// - `connected`
+    /// - `closed`
+    /// See <https://github.com/WebAssembly/wasi-sockets/blob/main/TcpSocketOperationalSemantics.md>
+    /// for more information.
+    ///
+    /// Note: Except where explicitly mentioned, whenever this documentation uses
+    /// the term "bound" without backticks it actually means: in the `bound` state *or higher*.
+    /// (i.e. `bound`, `listen-in-progress`, `listening`, `connect-in-progress` or `connected`)
+    ///
+    /// In addition to the general error codes documented on the
+    /// `network::error-code` type, TCP socket methods may always return
+    /// `error(invalid-state)` when in the `closed` state.
+    @since(version = 0.2.0)
+    resource tcp-socket {
+        /// Bind the socket to a specific network on the provided IP address and port.
+        ///
+        /// If the IP address is zero (`0.0.0.0` in IPv4, `::` in IPv6), it is left to the implementation to decide which
+        /// network interface(s) to bind to.
+        /// If the TCP/UDP port is zero, the socket will be bound to a random free port.
+        ///
+        /// Bind can be attempted multiple times on the same socket, even with
+        /// different arguments on each iteration. But never concurrently and
+        /// only as long as the previous bind failed. Once a bind succeeds, the
+        /// binding can't be changed anymore.
+        ///
+        /// # Typical errors
+        /// - `invalid-argument`:          The `local-address` has the wrong address family. (EAFNOSUPPORT, EFAULT on Windows)
+        /// - `invalid-argument`:          `local-address` is not a unicast address. (EINVAL)
+        /// - `invalid-argument`:          `local-address` is an IPv4-mapped IPv6 address. (EINVAL)
+        /// - `invalid-state`:             The socket is already bound. (EINVAL)
+        /// - `address-in-use`:            No ephemeral ports available. (EADDRINUSE, ENOBUFS on Windows)
+        /// - `address-in-use`:            Address is already in use. (EADDRINUSE)
+        /// - `address-not-bindable`:      `local-address` is not an address that the `network` can bind to. (EADDRNOTAVAIL)
+        /// - `not-in-progress`:           A `bind` operation is not in progress.
+        /// - `would-block`:               Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)
+        /// 
+        /// # Implementors note
+        /// When binding to a non-zero port, this bind operation shouldn't be affected by the TIME_WAIT
+        /// state of a recently closed socket on the same local address. In practice this means that the SO_REUSEADDR 
+        /// socket option should be set implicitly on all platforms, except on Windows where this is the default behavior
+        /// and SO_REUSEADDR performs something different entirely.
+        ///
+        /// Unlike in POSIX, in WASI the bind operation is async. This enables
+        /// interactive WASI hosts to inject permission prompts. Runtimes that
+        /// don't want to make use of this ability can simply call the native
+        /// `bind` as part of either `start-bind` or `finish-bind`.
+        ///
+        /// # References
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/bind.html>
+        /// - <https://man7.org/linux/man-pages/man2/bind.2.html>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-bind>
+        /// - <https://man.freebsd.org/cgi/man.cgi?query=bind&sektion=2&format=html>
+        @since(version = 0.2.0)
+        start-bind: func(network: borrow<network>, local-address: ip-socket-address) -> result<_, error-code>;
+        @since(version = 0.2.0)
+        finish-bind: func() -> result<_, error-code>;
+
+        /// Connect to a remote endpoint.
+        ///
+        /// On success:
+        /// - the socket is transitioned into the `connected` state.
+        /// - a pair of streams is returned that can be used to read & write to the connection
+        ///
+        /// After a failed connection attempt, the socket will be in the `closed`
+        /// state and the only valid action left is to `drop` the socket. A single
+        /// socket can not be used to connect more than once.
+        ///
+        /// # Typical errors
+        /// - `invalid-argument`:          The `remote-address` has the wrong address family. (EAFNOSUPPORT)
+        /// - `invalid-argument`:          `remote-address` is not a unicast address. (EINVAL, ENETUNREACH on Linux, EAFNOSUPPORT on MacOS)
+        /// - `invalid-argument`:          `remote-address` is an IPv4-mapped IPv6 address. (EINVAL, EADDRNOTAVAIL on Illumos)
+        /// - `invalid-argument`:          The IP address in `remote-address` is set to INADDR_ANY (`0.0.0.0` / `::`). (EADDRNOTAVAIL on Windows)
+        /// - `invalid-argument`:          The port in `remote-address` is set to 0. (EADDRNOTAVAIL on Windows)
+        /// - `invalid-argument`:          The socket is already attached to a different network. The `network` passed to `connect` must be identical to the one passed to `bind`.
+        /// - `invalid-state`:             The socket is already in the `connected` state. (EISCONN)
+        /// - `invalid-state`:             The socket is already in the `listening` state. (EOPNOTSUPP, EINVAL on Windows)
+        /// - `timeout`:                   Connection timed out. (ETIMEDOUT)
+        /// - `connection-refused`:        The connection was forcefully rejected. (ECONNREFUSED)
+        /// - `connection-reset`:          The connection was reset. (ECONNRESET)
+        /// - `connection-aborted`:        The connection was aborted. (ECONNABORTED)
+        /// - `remote-unreachable`:        The remote address is not reachable. (EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
+        /// - `address-in-use`:            Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE, EADDRNOTAVAIL on Linux, EAGAIN on BSD)
+        /// - `not-in-progress`:           A connect operation is not in progress.
+        /// - `would-block`:               Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)
+        ///
+        /// # Implementors note
+        /// The POSIX equivalent of `start-connect` is the regular `connect` syscall.
+        /// Because all WASI sockets are non-blocking this is expected to return
+        /// EINPROGRESS, which should be translated to `ok()` in WASI.
+        ///
+        /// The POSIX equivalent of `finish-connect` is a `poll` for event `POLLOUT`
+        /// with a timeout of 0 on the socket descriptor. Followed by a check for
+        /// the `SO_ERROR` socket option, in case the poll signaled readiness.
+        ///
+        /// # References
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/connect.html>
+        /// - <https://man7.org/linux/man-pages/man2/connect.2.html>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-connect>
+        /// - <https://man.freebsd.org/cgi/man.cgi?connect>
+        @since(version = 0.2.0)
+        start-connect: func(network: borrow<network>, remote-address: ip-socket-address) -> result<_, error-code>;
+        @since(version = 0.2.0)
+        finish-connect: func() -> result<tuple<input-stream, output-stream>, error-code>;
+
+        /// Start listening for new connections.
+        ///
+        /// Transitions the socket into the `listening` state.
+        ///
+        /// Unlike POSIX, the socket must already be explicitly bound.
+        ///
+        /// # Typical errors
+        /// - `invalid-state`:             The socket is not bound to any local address. (EDESTADDRREQ)
+        /// - `invalid-state`:             The socket is already in the `connected` state. (EISCONN, EINVAL on BSD)
+        /// - `invalid-state`:             The socket is already in the `listening` state.
+        /// - `address-in-use`:            Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE)
+        /// - `not-in-progress`:           A listen operation is not in progress.
+        /// - `would-block`:               Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)
+        ///
+        /// # Implementors note
+        /// Unlike in POSIX, in WASI the listen operation is async. This enables
+        /// interactive WASI hosts to inject permission prompts. Runtimes that
+        /// don't want to make use of this ability can simply call the native
+        /// `listen` as part of either `start-listen` or `finish-listen`.
+        ///
+        /// # References
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/listen.html>
+        /// - <https://man7.org/linux/man-pages/man2/listen.2.html>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-listen>
+        /// - <https://man.freebsd.org/cgi/man.cgi?query=listen&sektion=2>
+        @since(version = 0.2.0)
+        start-listen: func() -> result<_, error-code>;
+        @since(version = 0.2.0)
+        finish-listen: func() -> result<_, error-code>;
+
+        /// Accept a new client socket.
+        ///
+        /// The returned socket is bound and in the `connected` state. The following properties are inherited from the listener socket:
+        /// - `address-family`
+        /// - `keep-alive-enabled`
+        /// - `keep-alive-idle-time`
+        /// - `keep-alive-interval`
+        /// - `keep-alive-count`
+        /// - `hop-limit`
+        /// - `receive-buffer-size`
+        /// - `send-buffer-size`
+        ///
+        /// On success, this function returns the newly accepted client socket along with
+        /// a pair of streams that can be used to read & write to the connection.
+        ///
+        /// # Typical errors
+        /// - `invalid-state`:      Socket is not in the `listening` state. (EINVAL)
+        /// - `would-block`:        No pending connections at the moment. (EWOULDBLOCK, EAGAIN)
+        /// - `connection-aborted`: An incoming connection was pending, but was terminated by the client before this listener could accept it. (ECONNABORTED)
+        /// - `new-socket-limit`:   The new socket resource could not be created because of a system limit. (EMFILE, ENFILE)
+        ///
+        /// # References
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/accept.html>
+        /// - <https://man7.org/linux/man-pages/man2/accept.2.html>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-accept>
+        /// - <https://man.freebsd.org/cgi/man.cgi?query=accept&sektion=2>
+        @since(version = 0.2.0)
+        accept: func() -> result<tuple<tcp-socket, input-stream, output-stream>, error-code>;
+
+        /// Get the bound local address.
+        ///
+        /// POSIX mentions:
+        /// > If the socket has not been bound to a local name, the value
+        /// > stored in the object pointed to by `address` is unspecified.
+        ///
+        /// WASI is stricter and requires `local-address` to return `invalid-state` when the socket hasn't been bound yet.
+        ///
+        /// # Typical errors
+        /// - `invalid-state`: The socket is not bound to any local address.
+        ///
+        /// # References
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsockname.html>
+        /// - <https://man7.org/linux/man-pages/man2/getsockname.2.html>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getsockname>
+        /// - <https://man.freebsd.org/cgi/man.cgi?getsockname>
+        @since(version = 0.2.0)
+        local-address: func() -> result<ip-socket-address, error-code>;
+
+        /// Get the remote address.
+        ///
+        /// # Typical errors
+        /// - `invalid-state`: The socket is not connected to a remote address. (ENOTCONN)
+        ///
+        /// # References
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpeername.html>
+        /// - <https://man7.org/linux/man-pages/man2/getpeername.2.html>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getpeername>
+        /// - <https://man.freebsd.org/cgi/man.cgi?query=getpeername&sektion=2&n=1>
+        @since(version = 0.2.0)
+        remote-address: func() -> result<ip-socket-address, error-code>;
+
+        /// Whether the socket is in the `listening` state.
+        ///
+        /// Equivalent to the SO_ACCEPTCONN socket option.
+        @since(version = 0.2.0)
+        is-listening: func() -> bool;
+
+        /// Whether this is a IPv4 or IPv6 socket.
+        ///
+        /// Equivalent to the SO_DOMAIN socket option.
+        @since(version = 0.2.0)
+        address-family: func() -> ip-address-family;
+
+        /// Hints the desired listen queue size. Implementations are free to ignore this.
+        ///
+        /// If the provided value is 0, an `invalid-argument` error is returned.
+        /// Any other value will never cause an error, but it might be silently clamped and/or rounded.
+        ///
+        /// # Typical errors
+        /// - `not-supported`:        (set) The platform does not support changing the backlog size after the initial listen.
+        /// - `invalid-argument`:     (set) The provided value was 0.
+        /// - `invalid-state`:        (set) The socket is in the `connect-in-progress` or `connected` state.
+        @since(version = 0.2.0)
+        set-listen-backlog-size: func(value: u64) -> result<_, error-code>;
+
+        /// Enables or disables keepalive.
+        ///
+        /// The keepalive behavior can be adjusted using:
+        /// - `keep-alive-idle-time`
+        /// - `keep-alive-interval`
+        /// - `keep-alive-count`
+        /// These properties can be configured while `keep-alive-enabled` is false, but only come into effect when `keep-alive-enabled` is true.
+        ///
+        /// Equivalent to the SO_KEEPALIVE socket option.
+        @since(version = 0.2.0)
+        keep-alive-enabled: func() -> result<bool, error-code>;
+        @since(version = 0.2.0)
+        set-keep-alive-enabled: func(value: bool) -> result<_, error-code>;
+
+        /// Amount of time the connection has to be idle before TCP starts sending keepalive packets.
+        ///
+        /// If the provided value is 0, an `invalid-argument` error is returned.
+        /// Any other value will never cause an error, but it might be silently clamped and/or rounded.
+        /// I.e. after setting a value, reading the same setting back may return a different value.
+        ///
+        /// Equivalent to the TCP_KEEPIDLE socket option. (TCP_KEEPALIVE on MacOS)
+        ///
+        /// # Typical errors
+        /// - `invalid-argument`:     (set) The provided value was 0.
+        @since(version = 0.2.0)
+        keep-alive-idle-time: func() -> result<duration, error-code>;
+        @since(version = 0.2.0)
+        set-keep-alive-idle-time: func(value: duration) -> result<_, error-code>;
+
+        /// The time between keepalive packets.
+        ///
+        /// If the provided value is 0, an `invalid-argument` error is returned.
+        /// Any other value will never cause an error, but it might be silently clamped and/or rounded.
+        /// I.e. after setting a value, reading the same setting back may return a different value.
+        ///
+        /// Equivalent to the TCP_KEEPINTVL socket option.
+        ///
+        /// # Typical errors
+        /// - `invalid-argument`:     (set) The provided value was 0.
+        @since(version = 0.2.0)
+        keep-alive-interval: func() -> result<duration, error-code>;
+        @since(version = 0.2.0)
+        set-keep-alive-interval: func(value: duration) -> result<_, error-code>;
+
+        /// The maximum amount of keepalive packets TCP should send before aborting the connection.
+        ///
+        /// If the provided value is 0, an `invalid-argument` error is returned.
+        /// Any other value will never cause an error, but it might be silently clamped and/or rounded.
+        /// I.e. after setting a value, reading the same setting back may return a different value.
+        ///
+        /// Equivalent to the TCP_KEEPCNT socket option.
+        ///
+        /// # Typical errors
+        /// - `invalid-argument`:     (set) The provided value was 0.
+        @since(version = 0.2.0)
+        keep-alive-count: func() -> result<u32, error-code>;
+        @since(version = 0.2.0)
+        set-keep-alive-count: func(value: u32) -> result<_, error-code>;
+
+        /// Equivalent to the IP_TTL & IPV6_UNICAST_HOPS socket options.
+        ///
+        /// If the provided value is 0, an `invalid-argument` error is returned.
+        ///
+        /// # Typical errors
+        /// - `invalid-argument`:     (set) The TTL value must be 1 or higher.
+        @since(version = 0.2.0)
+        hop-limit: func() -> result<u8, error-code>;
+        @since(version = 0.2.0)
+        set-hop-limit: func(value: u8) -> result<_, error-code>;
+
+        /// The kernel buffer space reserved for sends/receives on this socket.
+        ///
+        /// If the provided value is 0, an `invalid-argument` error is returned.
+        /// Any other value will never cause an error, but it might be silently clamped and/or rounded.
+        /// I.e. after setting a value, reading the same setting back may return a different value.
+        ///
+        /// Equivalent to the SO_RCVBUF and SO_SNDBUF socket options.
+        ///
+        /// # Typical errors
+        /// - `invalid-argument`:     (set) The provided value was 0.
+        @since(version = 0.2.0)
+        receive-buffer-size: func() -> result<u64, error-code>;
+        @since(version = 0.2.0)
+        set-receive-buffer-size: func(value: u64) -> result<_, error-code>;
+        @since(version = 0.2.0)
+        send-buffer-size: func() -> result<u64, error-code>;
+        @since(version = 0.2.0)
+        set-send-buffer-size: func(value: u64) -> result<_, error-code>;
+
+        /// Create a `pollable` which can be used to poll for, or block on,
+        /// completion of any of the asynchronous operations of this socket.
+        ///
+        /// When `finish-bind`, `finish-listen`, `finish-connect` or `accept`
+        /// return `error(would-block)`, this pollable can be used to wait for
+        /// their success or failure, after which the method can be retried.
+        ///
+        /// The pollable is not limited to the async operation that happens to be
+        /// in progress at the time of calling `subscribe` (if any). Theoretically,
+        /// `subscribe` only has to be called once per socket and can then be
+        /// (re)used for the remainder of the socket's lifetime.
+        ///
+        /// See <https://github.com/WebAssembly/wasi-sockets/blob/main/TcpSocketOperationalSemantics.md#pollable-readiness>
+        /// for more information.
+        ///
+        /// Note: this function is here for WASI Preview2 only.
+        /// It's planned to be removed when `future` is natively supported in Preview3.
+        @since(version = 0.2.0)
+        subscribe: func() -> pollable;
+
+        /// Initiate a graceful shutdown.
+        ///
+        /// - `receive`: The socket is not expecting to receive any data from
+        ///   the peer. The `input-stream` associated with this socket will be
+        ///   closed. Any data still in the receive queue at time of calling
+        ///   this method will be discarded.
+        /// - `send`: The socket has no more data to send to the peer. The `output-stream`
+        ///   associated with this socket will be closed and a FIN packet will be sent.
+        /// - `both`: Same effect as `receive` & `send` combined.
+        ///
+        /// This function is idempotent; shutting down a direction more than once
+        /// has no effect and returns `ok`.
+        ///
+        /// The shutdown function does not close (drop) the socket.
+        ///
+        /// # Typical errors
+        /// - `invalid-state`: The socket is not in the `connected` state. (ENOTCONN)
+        ///
+        /// # References
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/shutdown.html>
+        /// - <https://man7.org/linux/man-pages/man2/shutdown.2.html>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-shutdown>
+        /// - <https://man.freebsd.org/cgi/man.cgi?query=shutdown&sektion=2>
+        @since(version = 0.2.0)
+        shutdown: func(shutdown-type: shutdown-type) -> result<_, error-code>;
+    }
 }
diff --git a/crates/wasi/wit/deps/sockets/udp-create-socket.wit b/crates/wasi/wit/deps/sockets/udp-create-socket.wit
index cd4c08fb1000..e8eeacbfefb4 100644
--- a/crates/wasi/wit/deps/sockets/udp-create-socket.wit
+++ b/crates/wasi/wit/deps/sockets/udp-create-socket.wit
@@ -1,27 +1,30 @@
-
+@since(version = 0.2.0)
 interface udp-create-socket {
-	use network.{network, error-code, ip-address-family}
-	use udp.{udp-socket}
+    @since(version = 0.2.0)
+    use network.{network, error-code, ip-address-family};
+    @since(version = 0.2.0)
+    use udp.{udp-socket};
 
-	/// Create a new UDP socket.
-	/// 
-	/// Similar to `socket(AF_INET or AF_INET6, SOCK_DGRAM, IPPROTO_UDP)` in POSIX.
-	/// 
-	/// This function does not require a network capability handle. This is considered to be safe because
-	/// at time of creation, the socket is not bound to any `network` yet. Up to the moment `bind`/`connect` is called,
-	/// the socket is effectively an in-memory configuration object, unable to communicate with the outside world.
-	/// 
-	/// All sockets are non-blocking. Use the wasi-poll interface to block on asynchronous operations.
-	/// 
-	/// # Typical errors
-	/// - `not-supported`:                The host does not support UDP sockets. (EOPNOTSUPP)
-	/// - `address-family-not-supported`: The specified `address-family` is not supported. (EAFNOSUPPORT)
-	/// - `new-socket-limit`:             The new socket resource could not be created because of a system limit. (EMFILE, ENFILE)
-	/// 
-	/// # References:
-	/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/socket.html>
-	/// - <https://man7.org/linux/man-pages/man2/socket.2.html>
-	/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasocketw>
-	/// - <https://man.freebsd.org/cgi/man.cgi?query=socket&sektion=2>
-	create-udp-socket: func(address-family: ip-address-family) -> result<udp-socket, error-code>
+    /// Create a new UDP socket.
+    ///
+    /// Similar to `socket(AF_INET or AF_INET6, SOCK_DGRAM, IPPROTO_UDP)` in POSIX.
+    /// On IPv6 sockets, IPV6_V6ONLY is enabled by default and can't be configured otherwise.
+    ///
+    /// This function does not require a network capability handle. This is considered to be safe because
+    /// at time of creation, the socket is not bound to any `network` yet. Up to the moment `bind` is called,
+    /// the socket is effectively an in-memory configuration object, unable to communicate with the outside world.
+    ///
+    /// All sockets are non-blocking. Use the wasi-poll interface to block on asynchronous operations.
+    ///
+    /// # Typical errors
+    /// - `not-supported`:     The specified `address-family` is not supported. (EAFNOSUPPORT)
+    /// - `new-socket-limit`:  The new socket resource could not be created because of a system limit. (EMFILE, ENFILE)
+    ///
+    /// # References:
+    /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/socket.html>
+    /// - <https://man7.org/linux/man-pages/man2/socket.2.html>
+    /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasocketw>
+    /// - <https://man.freebsd.org/cgi/man.cgi?query=socket&sektion=2>
+    @since(version = 0.2.0)
+    create-udp-socket: func(address-family: ip-address-family) -> result<udp-socket, error-code>;
 }
diff --git a/crates/wasi/wit/deps/sockets/udp.wit b/crates/wasi/wit/deps/sockets/udp.wit
index 01e5b95b97b7..b289e4943f84 100644
--- a/crates/wasi/wit/deps/sockets/udp.wit
+++ b/crates/wasi/wit/deps/sockets/udp.wit
@@ -1,214 +1,288 @@
-
+@since(version = 0.2.0)
 interface udp {
-	use wasi:io/poll.{pollable}
-	use network.{network, error-code, ip-socket-address, ip-address-family}
-
-
-	record datagram {
-		data: list<u8>, // Theoretical max size: ~64 KiB. In practice, typically less than 1500 bytes.
-		remote-address: ip-socket-address,
-
-		/// Possible future additions:
-		/// local-address: ip-socket-address, // IP_PKTINFO / IP_RECVDSTADDR / IPV6_PKTINFO
-		/// local-interface: u32, // IP_PKTINFO / IP_RECVIF
-		/// ttl: u8, // IP_RECVTTL
-		/// dscp: u6, // IP_RECVTOS
-		/// ecn: u2, // IP_RECVTOS
-	}
-
-
-
-	/// A UDP socket handle.
-	resource udp-socket {
-		/// Bind the socket to a specific network on the provided IP address and port.
-		///
-		/// If the IP address is zero (`0.0.0.0` in IPv4, `::` in IPv6), it is left to the implementation to decide which
-		/// network interface(s) to bind to.
-		/// If the TCP/UDP port is zero, the socket will be bound to a random free port.
-		/// 
-		/// When a socket is not explicitly bound, the first invocation to connect will implicitly bind the socket.
-		/// 
-		/// Unlike in POSIX, this function is async. This enables interactive WASI hosts to inject permission prompts.
-		/// 
-		/// # Typical `start` errors
-		/// - `address-family-mismatch`:   The `local-address` has the wrong address family. (EINVAL)
-		/// - `already-bound`:             The socket is already bound. (EINVAL)
-		/// - `concurrency-conflict`:      Another `bind` or `connect` operation is already in progress. (EALREADY)
-		/// 
-		/// # Typical `finish` errors
-		/// - `ephemeral-ports-exhausted`: No ephemeral ports available. (EADDRINUSE, ENOBUFS on Windows)
-		/// - `address-in-use`:            Address is already in use. (EADDRINUSE)
-		/// - `address-not-bindable`:      `local-address` is not an address that the `network` can bind to. (EADDRNOTAVAIL)
-		/// - `not-in-progress`:           A `bind` operation is not in progress.
-		/// - `would-block`:               Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)
-		/// 
-		/// # References
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/bind.html>
-		/// - <https://man7.org/linux/man-pages/man2/bind.2.html>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-bind>
-		/// - <https://man.freebsd.org/cgi/man.cgi?query=bind&sektion=2&format=html>
-		start-bind: func(network: borrow<network>, local-address: ip-socket-address) -> result<_, error-code>
-		finish-bind: func() -> result<_, error-code>
-
-		/// Set the destination address.
-		/// 
-		/// The local-address is updated based on the best network path to `remote-address`.
-		/// 
-		/// When a destination address is set:
-		/// - all receive operations will only return datagrams sent from the provided `remote-address`.
-		/// - the `send` function can only be used to send to this destination.
-		/// 
-		/// Note that this function does not generate any network traffic and the peer is not aware of this "connection".
-		/// 
-		/// Unlike in POSIX, this function is async. This enables interactive WASI hosts to inject permission prompts.
-		/// 
-		/// # Typical `start` errors
-		/// - `address-family-mismatch`:   The `remote-address` has the wrong address family. (EAFNOSUPPORT)
-		/// - `invalid-remote-address`:    The IP address in `remote-address` is set to INADDR_ANY (`0.0.0.0` / `::`). (EDESTADDRREQ, EADDRNOTAVAIL)
-		/// - `invalid-remote-address`:    The port in `remote-address` is set to 0. (EDESTADDRREQ, EADDRNOTAVAIL)
-		/// - `already-attached`:          The socket is already bound to a different network. The `network` passed to `connect` must be identical to the one passed to `bind`.
-		/// - `concurrency-conflict`:      Another `bind` or `connect` operation is already in progress. (EALREADY)
-		/// 
-		/// # Typical `finish` errors
-		/// - `ephemeral-ports-exhausted`: Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE, EADDRNOTAVAIL on Linux, EAGAIN on BSD)
-		/// - `not-in-progress`:           A `connect` operation is not in progress.
-		/// - `would-block`:               Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)
-		/// 
-		/// # References
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/connect.html>
-		/// - <https://man7.org/linux/man-pages/man2/connect.2.html>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-connect>
-		/// - <https://man.freebsd.org/cgi/man.cgi?connect>
-		start-connect: func(network: borrow<network>, remote-address: ip-socket-address) -> result<_, error-code>
-		finish-connect: func() -> result<_, error-code>
-
-		/// Receive messages on the socket.
-		/// 
-		/// This function attempts to receive up to `max-results` datagrams on the socket without blocking.
-		/// The returned list may contain fewer elements than requested, but never more.
-		/// If `max-results` is 0, this function returns successfully with an empty list.
-		/// 
-		/// # Typical errors
-		/// - `not-bound`:          The socket is not bound to any local address. (EINVAL)
-		/// - `remote-unreachable`: The remote address is not reachable. (ECONNREFUSED, ECONNRESET, ENETRESET on Windows, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN)
-		/// - `would-block`:        There is no pending data available to be read at the moment. (EWOULDBLOCK, EAGAIN)
-		/// 
-		/// # References
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/recvfrom.html>
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/recvmsg.html>
-		/// - <https://man7.org/linux/man-pages/man2/recv.2.html>
-		/// - <https://man7.org/linux/man-pages/man2/recvmmsg.2.html>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-recv>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-recvfrom>
-		/// - <https://learn.microsoft.com/en-us/previous-versions/windows/desktop/legacy/ms741687(v=vs.85)>
-		/// - <https://man.freebsd.org/cgi/man.cgi?query=recv&sektion=2>
-		receive: func(max-results: u64) -> result<list<datagram>, error-code>
-
-		/// Send messages on the socket.
-		/// 
-		/// This function attempts to send all provided `datagrams` on the socket without blocking and
-		/// returns how many messages were actually sent (or queued for sending).
-		/// 
-		/// This function semantically behaves the same as iterating the `datagrams` list and sequentially
-		/// sending each individual datagram until either the end of the list has been reached or the first error occurred.
-		/// If at least one datagram has been sent successfully, this function never returns an error.
-		/// 
-		/// If the input list is empty, the function returns `ok(0)`.
-		/// 
-		/// The remote address option is required. To send a message to the "connected" peer,
-		/// call `remote-address` to get their address.
-		/// 
-		/// # Typical errors
-		/// - `address-family-mismatch`: The `remote-address` has the wrong address family. (EAFNOSUPPORT)
-		/// - `invalid-remote-address`:  The IP address in `remote-address` is set to INADDR_ANY (`0.0.0.0` / `::`). (EDESTADDRREQ, EADDRNOTAVAIL)
-		/// - `invalid-remote-address`:  The port in `remote-address` is set to 0. (EDESTADDRREQ, EADDRNOTAVAIL)
-		/// - `already-connected`:       The socket is in "connected" mode and the `datagram.remote-address` does not match the address passed to `connect`. (EISCONN)
-		/// - `not-bound`:               The socket is not bound to any local address. Unlike POSIX, this function does not perform an implicit bind.
-		/// - `remote-unreachable`:      The remote address is not reachable. (ECONNREFUSED, ECONNRESET, ENETRESET on Windows, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN)
-		/// - `datagram-too-large`:      The datagram is too large. (EMSGSIZE)
-		/// - `would-block`:             The send buffer is currently full. (EWOULDBLOCK, EAGAIN)
-		/// 
-		/// # References
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/sendto.html>
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/sendmsg.html>
-		/// - <https://man7.org/linux/man-pages/man2/send.2.html>
-		/// - <https://man7.org/linux/man-pages/man2/sendmmsg.2.html>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-send>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-sendto>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasendmsg>
-		/// - <https://man.freebsd.org/cgi/man.cgi?query=send&sektion=2>
-		send: func(datagrams: list<datagram>) -> result<u64, error-code>
-
-		/// Get the current bound address.
-		/// 
-		/// # Typical errors
-		/// - `not-bound`: The socket is not bound to any local address.
-		/// 
-		/// # References
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsockname.html>
-		/// - <https://man7.org/linux/man-pages/man2/getsockname.2.html>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getsockname>
-		/// - <https://man.freebsd.org/cgi/man.cgi?getsockname>
-		local-address: func() -> result<ip-socket-address, error-code>
-
-		/// Get the address set with `connect`.
-		/// 
-		/// # Typical errors
-		/// - `not-connected`: The socket is not connected to a remote address. (ENOTCONN)
-		/// 
-		/// # References
-		/// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpeername.html>
-		/// - <https://man7.org/linux/man-pages/man2/getpeername.2.html>
-		/// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getpeername>
-		/// - <https://man.freebsd.org/cgi/man.cgi?query=getpeername&sektion=2&n=1>
-		remote-address: func() -> result<ip-socket-address, error-code>
-
-		/// Whether this is a IPv4 or IPv6 socket.
-		/// 
-		/// Equivalent to the SO_DOMAIN socket option.
-		address-family: func() -> ip-address-family
-
-		/// Whether IPv4 compatibility (dual-stack) mode is disabled or not.
-		/// 
-		/// Equivalent to the IPV6_V6ONLY socket option.
-		/// 
-		/// # Typical errors
-		/// - `ipv6-only-operation`:  (get/set) `this` socket is an IPv4 socket.
-		/// - `already-bound`:        (set) The socket is already bound.
-		/// - `not-supported`:        (set) Host does not support dual-stack sockets. (Implementations are not required to.)
-		/// - `concurrency-conflict`: (set) Another `bind` or `connect` operation is already in progress. (EALREADY)
-		ipv6-only: func() -> result<bool, error-code>
-		set-ipv6-only: func(value: bool) -> result<_, error-code>
-
-		/// Equivalent to the IP_TTL & IPV6_UNICAST_HOPS socket options.
-		/// 
-		/// # Typical errors
-		/// - `concurrency-conflict`: (set) Another `bind` or `connect` operation is already in progress. (EALREADY)
-		unicast-hop-limit: func() -> result<u8, error-code>
-		set-unicast-hop-limit: func(value: u8) -> result<_, error-code>
-
-		/// The kernel buffer space reserved for sends/receives on this socket.
-		/// 
-		/// Note #1: an implementation may choose to cap or round the buffer size when setting the value.
-		/// 	In other words, after setting a value, reading the same setting back may return a different value.
-		/// 
-		/// Note #2: there is not necessarily a direct relationship between the kernel buffer size and the bytes of
-		/// 	actual data to be sent/received by the application, because the kernel might also use the buffer space
-		/// 	for internal metadata structures.
-		/// 
-		/// Equivalent to the SO_RCVBUF and SO_SNDBUF socket options.
-		/// 
-		/// # Typical errors
-		/// - `concurrency-conflict`: (set) Another `bind` or `connect` operation is already in progress. (EALREADY)
-		receive-buffer-size: func() -> result<u64, error-code>
-		set-receive-buffer-size: func(value: u64) -> result<_, error-code>
-		send-buffer-size: func() -> result<u64, error-code>
-		set-send-buffer-size: func(value: u64) -> result<_, error-code>
-
-		/// Create a `pollable` which will resolve once the socket is ready for I/O.
-		/// 
-		/// Note: this function is here for WASI Preview2 only.
-		/// It's planned to be removed when `future` is natively supported in Preview3.
-		subscribe: func() -> pollable
-	}
+    @since(version = 0.2.0)
+    use wasi:io/poll@0.2.1.{pollable};
+    @since(version = 0.2.0)
+    use network.{network, error-code, ip-socket-address, ip-address-family};
+
+    /// A received datagram.
+    @since(version = 0.2.0)
+    record incoming-datagram {
+        /// The payload.
+        /// 
+        /// Theoretical max size: ~64 KiB. In practice, typically less than 1500 bytes.
+        data: list<u8>,
+
+        /// The source address.
+        ///
+        /// This field is guaranteed to match the remote address the stream was initialized with, if any.
+        ///
+        /// Equivalent to the `src_addr` out parameter of `recvfrom`.
+        remote-address: ip-socket-address,
+    }
+
+    /// A datagram to be sent out.
+    @since(version = 0.2.0)
+    record outgoing-datagram {
+        /// The payload.
+        data: list<u8>,
+
+        /// The destination address.
+        ///
+        /// The requirements on this field depend on how the stream was initialized:
+        /// - with a remote address: this field must be None or match the stream's remote address exactly.
+        /// - without a remote address: this field is required.
+        ///
+        /// If this value is None, the send operation is equivalent to `send` in POSIX. Otherwise it is equivalent to `sendto`.
+        remote-address: option<ip-socket-address>,
+    }
+
+    /// A UDP socket handle.
+    @since(version = 0.2.0)
+    resource udp-socket {
+        /// Bind the socket to a specific network on the provided IP address and port.
+        ///
+        /// If the IP address is zero (`0.0.0.0` in IPv4, `::` in IPv6), it is left to the implementation to decide which
+        /// network interface(s) to bind to.
+        /// If the port is zero, the socket will be bound to a random free port.
+        ///
+        /// # Typical errors
+        /// - `invalid-argument`:          The `local-address` has the wrong address family. (EAFNOSUPPORT, EFAULT on Windows)
+        /// - `invalid-state`:             The socket is already bound. (EINVAL)
+        /// - `address-in-use`:            No ephemeral ports available. (EADDRINUSE, ENOBUFS on Windows)
+        /// - `address-in-use`:            Address is already in use. (EADDRINUSE)
+        /// - `address-not-bindable`:      `local-address` is not an address that the `network` can bind to. (EADDRNOTAVAIL)
+        /// - `not-in-progress`:           A `bind` operation is not in progress.
+        /// - `would-block`:               Can't finish the operation, it is still in progress. (EWOULDBLOCK, EAGAIN)
+        ///
+        /// # Implementors note
+        /// Unlike in POSIX, in WASI the bind operation is async. This enables
+        /// interactive WASI hosts to inject permission prompts. Runtimes that
+        /// don't want to make use of this ability can simply call the native
+        /// `bind` as part of either `start-bind` or `finish-bind`.
+        ///
+        /// # References
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/bind.html>
+        /// - <https://man7.org/linux/man-pages/man2/bind.2.html>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-bind>
+        /// - <https://man.freebsd.org/cgi/man.cgi?query=bind&sektion=2&format=html>
+        @since(version = 0.2.0)
+        start-bind: func(network: borrow<network>, local-address: ip-socket-address) -> result<_, error-code>;
+        @since(version = 0.2.0)
+        finish-bind: func() -> result<_, error-code>;
+
+        /// Set up inbound & outbound communication channels, optionally to a specific peer.
+        ///
+        /// This function only changes the local socket configuration and does not generate any network traffic.
+        /// On success, the `remote-address` of the socket is updated. The `local-address` may be updated as well,
+        /// based on the best network path to `remote-address`.
+        ///
+        /// When a `remote-address` is provided, the returned streams are limited to communicating with that specific peer:
+        /// - `send` can only be used to send to this destination.
+        /// - `receive` will only return datagrams sent from the provided `remote-address`.
+        ///
+        /// This method may be called multiple times on the same socket to change its association, but
+        /// only the most recently returned pair of streams will be operational. Implementations may trap if
+        /// the streams returned by a previous invocation haven't been dropped yet before calling `stream` again.
+        /// 
+        /// The POSIX equivalent in pseudo-code is:
+        /// ```text
+        /// if (was previously connected) {
+        /// 	connect(s, AF_UNSPEC)
+        /// }
+        /// if (remote_address is Some) {
+        /// 	connect(s, remote_address)
+        /// }
+        /// ```
+        ///
+        /// Unlike in POSIX, the socket must already be explicitly bound.
+        /// 
+        /// # Typical errors
+        /// - `invalid-argument`:          The `remote-address` has the wrong address family. (EAFNOSUPPORT)
+        /// - `invalid-argument`:          The IP address in `remote-address` is set to INADDR_ANY (`0.0.0.0` / `::`). (EDESTADDRREQ, EADDRNOTAVAIL)
+        /// - `invalid-argument`:          The port in `remote-address` is set to 0. (EDESTADDRREQ, EADDRNOTAVAIL)
+        /// - `invalid-state`:             The socket is not bound.
+        /// - `address-in-use`:            Tried to perform an implicit bind, but there were no ephemeral ports available. (EADDRINUSE, EADDRNOTAVAIL on Linux, EAGAIN on BSD)
+        /// - `remote-unreachable`:        The remote address is not reachable. (ECONNRESET, ENETRESET, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
+        /// - `connection-refused`:        The connection was refused. (ECONNREFUSED)
+        ///
+        /// # References
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/connect.html>
+        /// - <https://man7.org/linux/man-pages/man2/connect.2.html>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-connect>
+        /// - <https://man.freebsd.org/cgi/man.cgi?connect>
+        @since(version = 0.2.0)
+        %stream: func(remote-address: option<ip-socket-address>) -> result<tuple<incoming-datagram-stream, outgoing-datagram-stream>, error-code>;
+
+        /// Get the current bound address.
+        ///
+        /// POSIX mentions:
+        /// > If the socket has not been bound to a local name, the value
+        /// > stored in the object pointed to by `address` is unspecified.
+        ///
+        /// WASI is stricter and requires `local-address` to return `invalid-state` when the socket hasn't been bound yet.
+        /// 
+        /// # Typical errors
+        /// - `invalid-state`: The socket is not bound to any local address.
+        ///
+        /// # References
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsockname.html>
+        /// - <https://man7.org/linux/man-pages/man2/getsockname.2.html>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getsockname>
+        /// - <https://man.freebsd.org/cgi/man.cgi?getsockname>
+        @since(version = 0.2.0)
+        local-address: func() -> result<ip-socket-address, error-code>;
+
+        /// Get the address the socket is currently streaming to.
+        ///
+        /// # Typical errors
+        /// - `invalid-state`: The socket is not streaming to a specific remote address. (ENOTCONN)
+        ///
+        /// # References
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpeername.html>
+        /// - <https://man7.org/linux/man-pages/man2/getpeername.2.html>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getpeername>
+        /// - <https://man.freebsd.org/cgi/man.cgi?query=getpeername&sektion=2&n=1>
+        @since(version = 0.2.0)
+        remote-address: func() -> result<ip-socket-address, error-code>;
+
+        /// Whether this is a IPv4 or IPv6 socket.
+        ///
+        /// Equivalent to the SO_DOMAIN socket option.
+        @since(version = 0.2.0)
+        address-family: func() -> ip-address-family;
+
+        /// Equivalent to the IP_TTL & IPV6_UNICAST_HOPS socket options.
+        ///
+        /// If the provided value is 0, an `invalid-argument` error is returned.
+        ///
+        /// # Typical errors
+        /// - `invalid-argument`:     (set) The TTL value must be 1 or higher.
+        @since(version = 0.2.0)
+        unicast-hop-limit: func() -> result<u8, error-code>;
+        @since(version = 0.2.0)
+        set-unicast-hop-limit: func(value: u8) -> result<_, error-code>;
+
+        /// The kernel buffer space reserved for sends/receives on this socket.
+        ///
+        /// If the provided value is 0, an `invalid-argument` error is returned.
+        /// Any other value will never cause an error, but it might be silently clamped and/or rounded.
+        /// I.e. after setting a value, reading the same setting back may return a different value.
+        ///
+        /// Equivalent to the SO_RCVBUF and SO_SNDBUF socket options.
+        ///
+        /// # Typical errors
+        /// - `invalid-argument`:     (set) The provided value was 0.
+        @since(version = 0.2.0)
+        receive-buffer-size: func() -> result<u64, error-code>;
+        @since(version = 0.2.0)
+        set-receive-buffer-size: func(value: u64) -> result<_, error-code>;
+        @since(version = 0.2.0)
+        send-buffer-size: func() -> result<u64, error-code>;
+        @since(version = 0.2.0)
+        set-send-buffer-size: func(value: u64) -> result<_, error-code>;
+
+        /// Create a `pollable` which will resolve once the socket is ready for I/O.
+        ///
+        /// Note: this function is here for WASI Preview2 only.
+        /// It's planned to be removed when `future` is natively supported in Preview3.
+        @since(version = 0.2.0)
+        subscribe: func() -> pollable;
+    }
+
+    @since(version = 0.2.0)
+    resource incoming-datagram-stream {
+        /// Receive messages on the socket.
+        ///
+        /// This function attempts to receive up to `max-results` datagrams on the socket without blocking.
+        /// The returned list may contain fewer elements than requested, but never more.
+        ///
+        /// This function returns successfully with an empty list when either:
+        /// - `max-results` is 0, or:
+        /// - `max-results` is greater than 0, but no results are immediately available.
+        /// This function never returns `error(would-block)`.
+        ///
+        /// # Typical errors
+        /// - `remote-unreachable`: The remote address is not reachable. (ECONNRESET, ENETRESET on Windows, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
+        /// - `connection-refused`: The connection was refused. (ECONNREFUSED)
+        ///
+        /// # References
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/recvfrom.html>
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/recvmsg.html>
+        /// - <https://man7.org/linux/man-pages/man2/recv.2.html>
+        /// - <https://man7.org/linux/man-pages/man2/recvmmsg.2.html>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-recv>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-recvfrom>
+        /// - <https://learn.microsoft.com/en-us/previous-versions/windows/desktop/legacy/ms741687(v=vs.85)>
+        /// - <https://man.freebsd.org/cgi/man.cgi?query=recv&sektion=2>
+        @since(version = 0.2.0)
+        receive: func(max-results: u64) -> result<list<incoming-datagram>, error-code>;
+
+        /// Create a `pollable` which will resolve once the stream is ready to receive again.
+        ///
+        /// Note: this function is here for WASI Preview2 only.
+        /// It's planned to be removed when `future` is natively supported in Preview3.
+        @since(version = 0.2.0)
+        subscribe: func() -> pollable;
+    }
+
+    @since(version = 0.2.0)
+    resource outgoing-datagram-stream {
+        /// Check readiness for sending. This function never blocks.
+        ///
+        /// Returns the number of datagrams permitted for the next call to `send`,
+        /// or an error. Calling `send` with more datagrams than this function has
+        /// permitted will trap.
+        ///
+        /// When this function returns ok(0), the `subscribe` pollable will
+        /// become ready when this function will report at least ok(1), or an
+        /// error.
+        /// 
+        /// Never returns `would-block`.
+        check-send: func() -> result<u64, error-code>;
+
+        /// Send messages on the socket.
+        ///
+        /// This function attempts to send all provided `datagrams` on the socket without blocking and
+        /// returns how many messages were actually sent (or queued for sending). This function never
+        /// returns `error(would-block)`. If none of the datagrams were able to be sent, `ok(0)` is returned.
+        ///
+        /// This function semantically behaves the same as iterating the `datagrams` list and sequentially
+        /// sending each individual datagram until either the end of the list has been reached or the first error occurred.
+        /// If at least one datagram has been sent successfully, this function never returns an error.
+        ///
+        /// If the input list is empty, the function returns `ok(0)`.
+        ///
+        /// Each call to `send` must be permitted by a preceding `check-send`. Implementations must trap if
+        /// either `check-send` was not called or `datagrams` contains more items than `check-send` permitted.
+        ///
+        /// # Typical errors
+        /// - `invalid-argument`:        The `remote-address` has the wrong address family. (EAFNOSUPPORT)
+        /// - `invalid-argument`:        The IP address in `remote-address` is set to INADDR_ANY (`0.0.0.0` / `::`). (EDESTADDRREQ, EADDRNOTAVAIL)
+        /// - `invalid-argument`:        The port in `remote-address` is set to 0. (EDESTADDRREQ, EADDRNOTAVAIL)
+        /// - `invalid-argument`:        The socket is in "connected" mode and `remote-address` is `some` value that does not match the address passed to `stream`. (EISCONN)
+        /// - `invalid-argument`:        The socket is not "connected" and no value for `remote-address` was provided. (EDESTADDRREQ)
+        /// - `remote-unreachable`:      The remote address is not reachable. (ECONNRESET, ENETRESET on Windows, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
+        /// - `connection-refused`:      The connection was refused. (ECONNREFUSED)
+        /// - `datagram-too-large`:      The datagram is too large. (EMSGSIZE)
+        ///
+        /// # References
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/sendto.html>
+        /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/sendmsg.html>
+        /// - <https://man7.org/linux/man-pages/man2/send.2.html>
+        /// - <https://man7.org/linux/man-pages/man2/sendmmsg.2.html>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-send>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-sendto>
+        /// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasendmsg>
+        /// - <https://man.freebsd.org/cgi/man.cgi?query=send&sektion=2>
+        @since(version = 0.2.0)
+        send: func(datagrams: list<outgoing-datagram>) -> result<u64, error-code>;
+        
+        /// Create a `pollable` which will resolve once the stream is ready to send again.
+        ///
+        /// Note: this function is here for WASI Preview2 only.
+        /// It's planned to be removed when `future` is natively supported in Preview3.
+        @since(version = 0.2.0)
+        subscribe: func() -> pollable;
+    }
 }
diff --git a/crates/wasi/wit/deps/sockets/world.wit b/crates/wasi/wit/deps/sockets/world.wit
index 12f3c2868177..a1d42670e64f 100644
--- a/crates/wasi/wit/deps/sockets/world.wit
+++ b/crates/wasi/wit/deps/sockets/world.wit
@@ -1,11 +1,19 @@
-package wasi:sockets
+package wasi:sockets@0.2.1;
 
+@since(version = 0.2.0)
 world imports {
-    import instance-network
-    import network
-    import udp
-    import udp-create-socket
-    import tcp
-    import tcp-create-socket
-    import ip-name-lookup
+    @since(version = 0.2.0)
+    import instance-network;
+    @since(version = 0.2.0)
+    import network;
+    @since(version = 0.2.0)
+    import udp;
+    @since(version = 0.2.0)
+    import udp-create-socket;
+    @since(version = 0.2.0)
+    import tcp;
+    @since(version = 0.2.0)
+    import tcp-create-socket;
+    @since(version = 0.2.0)
+    import ip-name-lookup;
 }
diff --git a/crates/wasi/wit/main.wit b/crates/wasi/wit/main.wit
deleted file mode 100644
index 739e1bd4ac48..000000000000
--- a/crates/wasi/wit/main.wit
+++ /dev/null
@@ -1,33 +0,0 @@
-package wasmtime:wasi
-
-// All of the same imports available in the wasi:cli/command world, but no
-// export required:
-world preview1-adapter-reactor {
-  import wasi:clocks/wall-clock
-  import wasi:clocks/monotonic-clock
-  import wasi:clocks/timezone
-  import wasi:filesystem/types
-  import wasi:filesystem/preopens
-  import wasi:sockets/instance-network
-  import wasi:sockets/ip-name-lookup
-  import wasi:sockets/network
-  import wasi:sockets/tcp-create-socket
-  import wasi:sockets/tcp
-  import wasi:sockets/udp-create-socket
-  import wasi:sockets/udp
-  import wasi:random/random
-  import wasi:random/insecure
-  import wasi:random/insecure-seed
-  import wasi:io/poll
-  import wasi:io/streams
-  import wasi:cli/environment
-  import wasi:cli/exit
-  import wasi:cli/stdin
-  import wasi:cli/stdout
-  import wasi:cli/stderr
-  import wasi:cli/terminal-input
-  import wasi:cli/terminal-output
-  import wasi:cli/terminal-stdin
-  import wasi:cli/terminal-stdout
-  import wasi:cli/terminal-stderr
-}
diff --git a/crates/wasi/wit/test.wit b/crates/wasi/wit/test.wit
index 03073513f8e6..14e531d08d14 100644
--- a/crates/wasi/wit/test.wit
+++ b/crates/wasi/wit/test.wit
@@ -1,44 +1,13 @@
-// only used as part of `test-programs`
 world test-reactor {
+  include wasi:cli/imports@0.2.1;
 
-  import wasi:cli/environment
-  import wasi:io/poll
-  import wasi:io/streams
-  import wasi:filesystem/types
-  import wasi:filesystem/preopens
-  import wasi:cli/exit
+  export add-strings: func(s: list<string>) -> u32;
+  export get-strings: func() -> list<string>;
 
-  export add-strings: func(s: list<string>) -> u32
-  export get-strings: func() -> list<string>
+  use wasi:io/streams@0.2.1.{output-stream};
 
-  use wasi:io/streams.{output-stream}
+  export write-strings-to: func(o: output-stream) -> result;
 
-  export write-strings-to: func(o: output-stream) -> result
-
-  use wasi:filesystem/types.{descriptor-stat}
-  export pass-an-imported-record: func(d: descriptor-stat) -> string
-}
-
-world test-command {
-  import wasi:io/poll
-  import wasi:io/streams
-  import wasi:cli/environment
-  import wasi:cli/stdin
-  import wasi:cli/stdout
-  import wasi:cli/stderr
-}
-
-world test-command-with-sockets {
-  import wasi:io/poll
-  import wasi:io/streams
-  import wasi:cli/environment
-  import wasi:cli/stdin
-  import wasi:cli/stdout
-  import wasi:cli/stderr
-  import wasi:sockets/tcp
-  import wasi:sockets/tcp-create-socket
-  import wasi:sockets/network
-  import wasi:sockets/instance-network
-  import wasi:sockets/ip-name-lookup
-  import wasi:clocks/monotonic-clock
+  use wasi:filesystem/types@0.2.1.{descriptor-stat};
+  export pass-an-imported-record: func(d: descriptor-stat) -> string;
 }
diff --git a/crates/wasi/wit/world.wit b/crates/wasi/wit/world.wit
new file mode 100644
index 000000000000..e540b1f6d8ef
--- /dev/null
+++ b/crates/wasi/wit/world.wit
@@ -0,0 +1,6 @@
+// We actually don't use this; it's just to let bindgen! find the corresponding world in wit/deps.
+package wasmtime:wasi;
+
+world bindings {
+  include wasi:cli/imports@0.2.1;
+}
diff --git a/crates/wasi/witx/preview0/typenames.witx b/crates/wasi/witx/preview0/typenames.witx
new file mode 100644
index 000000000000..c3213743324a
--- /dev/null
+++ b/crates/wasi/witx/preview0/typenames.witx
@@ -0,0 +1,746 @@
+;; Type names used by low-level WASI interfaces.
+;;
+;; Some content here is derived from [CloudABI](https://github.com/NuxiNL/cloudabi).
+;;
+;; This is a `witx` file. See [here](https://github.com/WebAssembly/WASI/tree/main/docs/witx.md)
+;; for an explanation of what that means.
+
+(typename $size u32)
+
+;;; Non-negative file size or length of a region within a file.
+(typename $filesize u64)
+
+;;; Timestamp in nanoseconds.
+(typename $timestamp u64)
+
+;;; Identifiers for clocks.
+(typename $clockid
+  (enum (@witx tag u32)
+    ;;; The clock measuring real time. Time value zero corresponds with
+    ;;; 1970-01-01T00:00:00Z.
+    $realtime
+    ;;; The store-wide monotonic clock, which is defined as a clock measuring
+    ;;; real time, whose value cannot be adjusted and which cannot have negative
+    ;;; clock jumps. The epoch of this clock is undefined. The absolute time
+    ;;; value of this clock therefore has no meaning.
+    $monotonic
+    ;;; The CPU-time clock associated with the current process.
+    $process_cputime_id
+    ;;; The CPU-time clock associated with the current thread.
+    $thread_cputime_id
+  )
+)
+
+;;; Error codes returned by functions.
+;;; Not all of these error codes are returned by the functions provided by this
+;;; API; some are used in higher-level library layers, and others are provided
+;;; merely for alignment with POSIX.
+(typename $errno
+  (enum (@witx tag u16)
+    ;;; No error occurred. System call completed successfully.
+    $success
+    ;;; Argument list too long.
+    $2big
+    ;;; Permission denied.
+    $acces
+    ;;; Address in use.
+    $addrinuse
+    ;;; Address not available.
+    $addrnotavail
+    ;;; Address family not supported.
+    $afnosupport
+    ;;; Resource unavailable, or operation would block.
+    $again
+    ;;; Connection already in progress.
+    $already
+    ;;; Bad file descriptor.
+    $badf
+    ;;; Bad message.
+    $badmsg
+    ;;; Device or resource busy.
+    $busy
+    ;;; Operation canceled.
+    $canceled
+    ;;; No child processes.
+    $child
+    ;;; Connection aborted.
+    $connaborted
+    ;;; Connection refused.
+    $connrefused
+    ;;; Connection reset.
+    $connreset
+    ;;; Resource deadlock would occur.
+    $deadlk
+    ;;; Destination address required.
+    $destaddrreq
+    ;;; Mathematics argument out of domain of function.
+    $dom
+    ;;; Reserved.
+    $dquot
+    ;;; File exists.
+    $exist
+    ;;; Bad address.
+    $fault
+    ;;; File too large.
+    $fbig
+    ;;; Host is unreachable.
+    $hostunreach
+    ;;; Identifier removed.
+    $idrm
+    ;;; Illegal byte sequence.
+    $ilseq
+    ;;; Operation in progress.
+    $inprogress
+    ;;; Interrupted function.
+    $intr
+    ;;; Invalid argument.
+    $inval
+    ;;; I/O error.
+    $io
+    ;;; Socket is connected.
+    $isconn
+    ;;; Is a directory.
+    $isdir
+    ;;; Too many levels of symbolic links.
+    $loop
+    ;;; File descriptor value too large.
+    $mfile
+    ;;; Too many links.
+    $mlink
+    ;;; Message too large.
+    $msgsize
+    ;;; Reserved.
+    $multihop
+    ;;; Filename too long.
+    $nametoolong
+    ;;; Network is down.
+    $netdown
+    ;;; Connection aborted by network.
+    $netreset
+    ;;; Network unreachable.
+    $netunreach
+    ;;; Too many files open in system.
+    $nfile
+    ;;; No buffer space available.
+    $nobufs
+    ;;; No such device.
+    $nodev
+    ;;; No such file or directory.
+    $noent
+    ;;; Executable file format error.
+    $noexec
+    ;;; No locks available.
+    $nolck
+    ;;; Reserved.
+    $nolink
+    ;;; Not enough space.
+    $nomem
+    ;;; No message of the desired type.
+    $nomsg
+    ;;; Protocol not available.
+    $noprotoopt
+    ;;; No space left on device.
+    $nospc
+    ;;; Function not supported.
+    $nosys
+    ;;; The socket is not connected.
+    $notconn
+    ;;; Not a directory or a symbolic link to a directory.
+    $notdir
+    ;;; Directory not empty.
+    $notempty
+    ;;; State not recoverable.
+    $notrecoverable
+    ;;; Not a socket.
+    $notsock
+    ;;; Not supported, or operation not supported on socket.
+    $notsup
+    ;;; Inappropriate I/O control operation.
+    $notty
+    ;;; No such device or address.
+    $nxio
+    ;;; Value too large to be stored in data type.
+    $overflow
+    ;;; Previous owner died.
+    $ownerdead
+    ;;; Operation not permitted.
+    $perm
+    ;;; Broken pipe.
+    $pipe
+    ;;; Protocol error.
+    $proto
+    ;;; Protocol not supported.
+    $protonosupport
+    ;;; Protocol wrong type for socket.
+    $prototype
+    ;;; Result too large.
+    $range
+    ;;; Read-only file system.
+    $rofs
+    ;;; Invalid seek.
+    $spipe
+    ;;; No such process.
+    $srch
+    ;;; Reserved.
+    $stale
+    ;;; Connection timed out.
+    $timedout
+    ;;; Text file busy.
+    $txtbsy
+    ;;; Cross-device link.
+    $xdev
+    ;;; Extension: Capabilities insufficient.
+    $notcapable
+  )
+)
+
+;;; File descriptor rights, determining which actions may be performed.
+(typename $rights
+  (flags (@witx repr u64)
+    ;;; The right to invoke `fd_datasync`.
+    ;;
+    ;;; If `rights::path_open` is set, includes the right to invoke
+    ;;; `path_open` with `fdflags::dsync`.
+    $fd_datasync
+    ;;; The right to invoke `fd_read` and `sock_recv`.
+    ;;
+    ;;; If `rights::fd_seek` is set, includes the right to invoke `fd_pread`.
+    $fd_read
+    ;;; The right to invoke `fd_seek`. This flag implies `rights::fd_tell`.
+    $fd_seek
+    ;;; The right to invoke `fd_fdstat_set_flags`.
+    $fd_fdstat_set_flags
+    ;;; The right to invoke `fd_sync`.
+    ;;
+    ;;; If `rights::path_open` is set, includes the right to invoke
+    ;;; `path_open` with `fdflags::rsync` and `fdflags::dsync`.
+    $fd_sync
+    ;;; The right to invoke `fd_seek` in such a way that the file offset
+    ;;; remains unaltered (i.e., `whence::cur` with offset zero), or to
+    ;;; invoke `fd_tell`.
+    $fd_tell
+    ;;; The right to invoke `fd_write` and `sock_send`.
+    ;;; If `rights::fd_seek` is set, includes the right to invoke `fd_pwrite`.
+    $fd_write
+    ;;; The right to invoke `fd_advise`.
+    $fd_advise
+    ;;; The right to invoke `fd_allocate`.
+    $fd_allocate
+    ;;; The right to invoke `path_create_directory`.
+    $path_create_directory
+    ;;; If `rights::path_open` is set, the right to invoke `path_open` with `oflags::creat`.
+    $path_create_file
+    ;;; The right to invoke `path_link` with the file descriptor as the
+    ;;; source directory.
+    $path_link_source
+    ;;; The right to invoke `path_link` with the file descriptor as the
+    ;;; target directory.
+    $path_link_target
+    ;;; The right to invoke `path_open`.
+    $path_open
+    ;;; The right to invoke `fd_readdir`.
+    $fd_readdir
+    ;;; The right to invoke `path_readlink`.
+    $path_readlink
+    ;;; The right to invoke `path_rename` with the file descriptor as the source directory.
+    $path_rename_source
+    ;;; The right to invoke `path_rename` with the file descriptor as the target directory.
+    $path_rename_target
+    ;;; The right to invoke `path_filestat_get`.
+    $path_filestat_get
+    ;;; The right to change a file's size (there is no `path_filestat_set_size`).
+    ;;; If `rights::path_open` is set, includes the right to invoke `path_open` with `oflags::trunc`.
+    $path_filestat_set_size
+    ;;; The right to invoke `path_filestat_set_times`.
+    $path_filestat_set_times
+    ;;; The right to invoke `fd_filestat_get`.
+    $fd_filestat_get
+    ;;; The right to invoke `fd_filestat_set_size`.
+    $fd_filestat_set_size
+    ;;; The right to invoke `fd_filestat_set_times`.
+    $fd_filestat_set_times
+    ;;; The right to invoke `path_symlink`.
+    $path_symlink
+    ;;; The right to invoke `path_remove_directory`.
+    $path_remove_directory
+    ;;; The right to invoke `path_unlink_file`.
+    $path_unlink_file
+    ;;; If `rights::fd_read` is set, includes the right to invoke `poll_oneoff` to subscribe to `eventtype::fd_read`.
+    ;;; If `rights::fd_write` is set, includes the right to invoke `poll_oneoff` to subscribe to `eventtype::fd_write`.
+    $poll_fd_readwrite
+    ;;; The right to invoke `sock_shutdown`.
+    $sock_shutdown
+  )
+)
+
+;;; A file descriptor handle.
+(typename $fd (handle))
+
+;;; A region of memory for scatter/gather reads.
+(typename $iovec
+  (record
+    ;;; The address of the buffer to be filled.
+    (field $buf (@witx pointer u8))
+    ;;; The length of the buffer to be filled.
+    (field $buf_len $size)
+  )
+)
+
+;;; A region of memory for scatter/gather writes.
+(typename $ciovec
+  (record
+    ;;; The address of the buffer to be written.
+    (field $buf (@witx const_pointer u8))
+    ;;; The length of the buffer to be written.
+    (field $buf_len $size)
+  )
+)
+
+(typename $iovec_array (list $iovec))
+(typename $ciovec_array (list $ciovec))
+
+;;; Relative offset within a file.
+(typename $filedelta s64)
+
+;;; The position relative to which to set the offset of the file descriptor.
+(typename $whence
+  (enum (@witx tag u8)
+    ;;; Seek relative to current position.
+    $cur
+    ;;; Seek relative to end-of-file.
+    $end
+    ;;; Seek relative to start-of-file.
+    $set
+  )
+)
+
+;;; A reference to the offset of a directory entry.
+(typename $dircookie u64)
+
+;;; The type for the `dirent::d_namlen` field of `dirent` struct.
+(typename $dirnamlen u32)
+
+;;; File serial number that is unique within its file system.
+(typename $inode u64)
+
+;;; The type of a file descriptor or file.
+(typename $filetype
+  (enum (@witx tag u8)
+    ;;; The type of the file descriptor or file is unknown or is different from any of the other types specified.
+    $unknown
+    ;;; The file descriptor or file refers to a block device inode.
+    $block_device
+    ;;; The file descriptor or file refers to a character device inode.
+    $character_device
+    ;;; The file descriptor or file refers to a directory inode.
+    $directory
+    ;;; The file descriptor or file refers to a regular file inode.
+    $regular_file
+    ;;; The file descriptor or file refers to a datagram socket.
+    $socket_dgram
+    ;;; The file descriptor or file refers to a byte-stream socket.
+    $socket_stream
+    ;;; The file refers to a symbolic link inode.
+    $symbolic_link
+  )
+)
+
+;;; A directory entry.
+(typename $dirent
+  (record
+    ;;; The offset of the next directory entry stored in this directory.
+    (field $d_next $dircookie)
+    ;;; The serial number of the file referred to by this directory entry.
+    (field $d_ino $inode)
+    ;;; The length of the name of the directory entry.
+    (field $d_namlen $dirnamlen)
+    ;;; The type of the file referred to by this directory entry.
+    (field $d_type $filetype)
+  )
+)
+
+;;; File or memory access pattern advisory information.
+(typename $advice
+  (enum (@witx tag u8)
+    ;;; The application has no advice to give on its behavior with respect to the specified data.
+    $normal
+    ;;; The application expects to access the specified data sequentially from lower offsets to higher offsets.
+    $sequential
+    ;;; The application expects to access the specified data in a random order.
+    $random
+    ;;; The application expects to access the specified data in the near future.
+    $willneed
+    ;;; The application expects that it will not access the specified data in the near future.
+    $dontneed
+    ;;; The application expects to access the specified data once and then not reuse it thereafter.
+    $noreuse
+  )
+)
+
+;;; File descriptor flags.
+(typename $fdflags
+  (flags (@witx repr u16)
+    ;;; Append mode: Data written to the file is always appended to the file's end.
+    $append
+    ;;; Write according to synchronized I/O data integrity completion. Only the data stored in the file is synchronized.
+    $dsync
+    ;;; Non-blocking mode.
+    $nonblock
+    ;;; Synchronized read I/O operations.
+    $rsync
+    ;;; Write according to synchronized I/O file integrity completion. In
+    ;;; addition to synchronizing the data stored in the file, the implementation
+    ;;; may also synchronously update the file's metadata.
+    $sync
+  )
+)
+
+;;; File descriptor attributes.
+(typename $fdstat
+  (record
+    ;;; File type.
+    (field $fs_filetype $filetype)
+    ;;; File descriptor flags.
+    (field $fs_flags $fdflags)
+    ;;; Rights that apply to this file descriptor.
+    (field $fs_rights_base $rights)
+    ;;; Maximum set of rights that may be installed on new file descriptors that
+    ;;; are created through this file descriptor, e.g., through `path_open`.
+    (field $fs_rights_inheriting $rights)
+  )
+)
+
+;;; Identifier for a device containing a file system. Can be used in combination
+;;; with `inode` to uniquely identify a file or directory in the filesystem.
+(typename $device u64)
+
+;;; Which file time attributes to adjust.
+(typename $fstflags
+  (flags (@witx repr u16)
+    ;;; Adjust the last data access timestamp to the value stored in `filestat::atim`.
+    $atim
+    ;;; Adjust the last data access timestamp to the time of clock `clockid::realtime`.
+    $atim_now
+    ;;; Adjust the last data modification timestamp to the value stored in `filestat::mtim`.
+    $mtim
+    ;;; Adjust the last data modification timestamp to the time of clock `clockid::realtime`.
+    $mtim_now
+  )
+)
+
+;;; Flags determining the method of how paths are resolved.
+(typename $lookupflags
+  (flags (@witx repr u32)
+    ;;; As long as the resolved path corresponds to a symbolic link, it is expanded.
+    $symlink_follow
+  )
+)
+
+;;; Open flags used by `path_open`.
+(typename $oflags
+  (flags (@witx repr u16)
+    ;;; Create file if it does not exist.
+    $creat
+    ;;; Fail if not a directory.
+    $directory
+    ;;; Fail if file already exists.
+    $excl
+    ;;; Truncate file to size 0.
+    $trunc
+  )
+)
+
+;;; Number of hard links to an inode.
+(typename $linkcount u32)
+
+;;; File attributes.
+(typename $filestat
+  (record
+    ;;; Device ID of device containing the file.
+    (field $dev $device)
+    ;;; File serial number.
+    (field $ino $inode)
+    ;;; File type.
+    (field $filetype $filetype)
+    ;;; Number of hard links to the file.
+    (field $nlink $linkcount)
+    ;;; For regular files, the file size in bytes. For symbolic links, the length in bytes of the pathname contained in the symbolic link.
+    (field $size $filesize)
+    ;;; Last data access timestamp.
+    (field $atim $timestamp)
+    ;;; Last data modification timestamp.
+    (field $mtim $timestamp)
+    ;;; Last file status change timestamp.
+    (field $ctim $timestamp)
+  )
+)
+
+;;; User-provided value that may be attached to objects that is retained when
+;;; extracted from the implementation.
+(typename $userdata u64)
+
+;;; Type of a subscription to an event or its occurrence.
+(typename $eventtype
+  (enum (@witx tag u8)
+    ;;; The time value of clock `subscription_clock::id` has
+    ;;; reached timestamp `subscription_clock::timeout`.
+    $clock
+    ;;; File descriptor `subscription_fd_readwrite::file_descriptor` has data
+    ;;; available for reading. This event always triggers for regular files.
+    $fd_read
+    ;;; File descriptor `subscription_fd_readwrite::file_descriptor` has capacity
+    ;;; available for writing. This event always triggers for regular files.
+    $fd_write
+  )
+)
+
+;;; The state of the file descriptor subscribed to with
+;;; `eventtype::fd_read` or `eventtype::fd_write`.
+(typename $eventrwflags
+  (flags (@witx repr u16)
+    ;;; The peer of this socket has closed or disconnected.
+    $fd_readwrite_hangup
+  )
+)
+
+;;; The contents of an `event` for the `eventtype::fd_read` and
+;;; `eventtype::fd_write` variants
+(typename $event_fd_readwrite
+  (record
+    ;;; The number of bytes available for reading or writing.
+    (field $nbytes $filesize)
+    ;;; The state of the file descriptor.
+    (field $flags $eventrwflags)
+  )
+)
+
+;;; An event that occurred.
+(typename $event
+  (record
+    ;;; User-provided value that got attached to `subscription::userdata`.
+    (field $userdata $userdata)
+    ;;; If non-zero, an error that occurred while processing the subscription request.
+    (field $error $errno)
+    ;;; The type of event that occurred
+    (field $type $eventtype)
+    ;;; The contents of the event, if it is an `eventtype::fd_read` or
+    ;;; `eventtype::fd_write`. `eventtype::clock` events ignore this field.
+    (field $fd_readwrite $event_fd_readwrite)
+  )
+)
+
+;;; Flags determining how to interpret the timestamp provided in
+;;; `subscription_clock::timeout`.
+(typename $subclockflags
+  (flags (@witx repr u16)
+    ;;; If set, treat the timestamp provided in
+    ;;; `subscription_clock::timeout` as an absolute timestamp of clock
+    ;;; `subscription_clock::id`. If clear, treat the timestamp
+    ;;; provided in `subscription_clock::timeout` relative to the
+    ;;; current time value of clock `subscription_clock::id`.
+    $subscription_clock_abstime
+  )
+)
+
+;;; The contents of a `subscription` when type is `eventtype::clock`.
+(typename $subscription_clock
+  (record
+    ;;; The user-defined unique identifier of the clock.
+    (field $identifier $userdata)
+    ;;; The clock against which to compare the timestamp.
+    (field $id $clockid)
+    ;;; The absolute or relative timestamp.
+    (field $timeout $timestamp)
+    ;;; The amount of time that the implementation may wait additionally
+    ;;; to coalesce with other events.
+    (field $precision $timestamp)
+    ;;; Flags specifying whether the timeout is absolute or relative
+    (field $flags $subclockflags)
+  )
+)
+
+;;; The contents of a `subscription` when the variant is
+;;; `eventtype::fd_read` or `eventtype::fd_write`.
+(typename $subscription_fd_readwrite
+  (record
+    ;;; The file descriptor on which to wait for it to become ready for reading or writing.
+    (field $file_descriptor $fd)
+  )
+)
+
+;;; The contents of a `subscription`.
+(typename $subscription_u
+  (union (@witx tag $eventtype)
+    $subscription_clock
+    $subscription_fd_readwrite
+    $subscription_fd_readwrite
+  )
+)
+
+;;; Subscription to an event.
+(typename $subscription
+  (record
+    ;;; User-provided value that is attached to the subscription in the
+    ;;; implementation and returned through `event::userdata`.
+    (field $userdata $userdata)
+    ;;; The type of the event to which to subscribe.
+    (field $u $subscription_u)
+  )
+)
+
+;;; Exit code generated by a process when exiting.
+(typename $exitcode u32)
+
+;;; Signal condition.
+(typename $signal
+  (enum (@witx tag u8)
+    ;;; No signal. Note that POSIX has special semantics for `kill(pid, 0)`,
+    ;;; so this value is reserved.
+    $none
+    ;;; Hangup.
+    ;;; Action: Terminates the process.
+    $hup
+    ;;; Terminate interrupt signal.
+    ;;; Action: Terminates the process.
+    $int
+    ;;; Terminal quit signal.
+    ;;; Action: Terminates the process.
+    $quit
+    ;;; Illegal instruction.
+    ;;; Action: Terminates the process.
+    $ill
+    ;;; Trace/breakpoint trap.
+    ;;; Action: Terminates the process.
+    $trap
+    ;;; Process abort signal.
+    ;;; Action: Terminates the process.
+    $abrt
+    ;;; Access to an undefined portion of a memory object.
+    ;;; Action: Terminates the process.
+    $bus
+    ;;; Erroneous arithmetic operation.
+    ;;; Action: Terminates the process.
+    $fpe
+    ;;; Kill.
+    ;;; Action: Terminates the process.
+    $kill
+    ;;; User-defined signal 1.
+    ;;; Action: Terminates the process.
+    $usr1
+    ;;; Invalid memory reference.
+    ;;; Action: Terminates the process.
+    $segv
+    ;;; User-defined signal 2.
+    ;;; Action: Terminates the process.
+    $usr2
+    ;;; Write on a pipe with no one to read it.
+    ;;; Action: Ignored.
+    $pipe
+    ;;; Alarm clock.
+    ;;; Action: Terminates the process.
+    $alrm
+    ;;; Termination signal.
+    ;;; Action: Terminates the process.
+    $term
+    ;;; Child process terminated, stopped, or continued.
+    ;;; Action: Ignored.
+    $chld
+    ;;; Continue executing, if stopped.
+    ;;; Action: Continues executing, if stopped.
+    $cont
+    ;;; Stop executing.
+    ;;; Action: Stops executing.
+    $stop
+    ;;; Terminal stop signal.
+    ;;; Action: Stops executing.
+    $tstp
+    ;;; Background process attempting read.
+    ;;; Action: Stops executing.
+    $ttin
+    ;;; Background process attempting write.
+    ;;; Action: Stops executing.
+    $ttou
+    ;;; High bandwidth data is available at a socket.
+    ;;; Action: Ignored.
+    $urg
+    ;;; CPU time limit exceeded.
+    ;;; Action: Terminates the process.
+    $xcpu
+    ;;; File size limit exceeded.
+    ;;; Action: Terminates the process.
+    $xfsz
+    ;;; Virtual timer expired.
+    ;;; Action: Terminates the process.
+    $vtalrm
+    ;;; Profiling timer expired.
+    ;;; Action: Terminates the process.
+    $prof
+    ;;; Window changed.
+    ;;; Action: Ignored.
+    $winch
+    ;;; I/O possible.
+    ;;; Action: Terminates the process.
+    $poll
+    ;;; Power failure.
+    ;;; Action: Terminates the process.
+    $pwr
+    ;;; Bad system call.
+    ;;; Action: Terminates the process.
+    $sys
+  )
+)
+
+;;; Flags provided to `sock_recv`.
+(typename $riflags
+  (flags (@witx repr u16)
+    ;;; Returns the message without removing it from the socket's receive queue.
+    $recv_peek
+    ;;; On byte-stream sockets, block until the full amount of data can be returned.
+    $recv_waitall
+  )
+)
+
+;;; Flags returned by `sock_recv`.
+(typename $roflags
+  (flags (@witx repr u16)
+    ;;; Returned by `sock_recv`: Message data has been truncated.
+    $recv_data_truncated
+  )
+)
+
+;;; Flags provided to `sock_send`. As there are currently no flags
+;;; defined, it must be set to zero.
+(typename $siflags u16)
+
+;;; Which channels on a socket to shut down.
+(typename $sdflags
+  (flags (@witx repr u8)
+    ;;; Disables further receive operations.
+    $rd
+    ;;; Disables further send operations.
+    $wr
+  )
+)
+
+;;; Identifiers for preopened capabilities.
+(typename $preopentype
+  (enum (@witx tag u8)
+    ;;; A pre-opened directory.
+    $dir
+  )
+)
+
+;;; The contents of a $prestat when type is `preopentype::dir`.
+(typename $prestat_dir
+  (record
+    ;;; The length of the directory name for use with `fd_prestat_dir_name`.
+    (field $pr_name_len $size)
+  )
+)
+
+;;; Information about a pre-opened capability.
+(typename $prestat
+  (union (@witx tag $preopentype)
+    $prestat_dir
+  )
+)
diff --git a/crates/wasi/witx/preview0/wasi_unstable.witx b/crates/wasi/witx/preview0/wasi_unstable.witx
new file mode 100644
index 000000000000..dbece2641c49
--- /dev/null
+++ b/crates/wasi/witx/preview0/wasi_unstable.witx
@@ -0,0 +1,513 @@
+;; WASI Preview. This is an evolution of the API that WASI initially
+;; launched with.
+;;
+;; Some content here is derived from [CloudABI](https://github.com/NuxiNL/cloudabi).
+;;
+;; This is a `witx` file. See [here](https://github.com/WebAssembly/WASI/tree/master/docs/witx.md)
+;; for an explanation of what that means.
+
+(use "typenames.witx")
+
+;;; This API predated the convention of naming modules with a `wasi_unstable_`
+;;; prefix and a version number. It is preserved here for compatibility, but
+;;; we shouldn't follow this pattern in new APIs.
+(module $wasi_unstable
+  ;;; Linear memory to be accessed by WASI functions that need it.
+  (import "memory" (memory))
+
+  ;;; Read command-line argument data.
+  ;;; The size of the array should match that returned by `args_sizes_get`.
+  ;;; Each argument is expected to be `\0` terminated.
+  (@interface func (export "args_get")
+    (param $argv (@witx pointer (@witx pointer u8)))
+    (param $argv_buf (@witx pointer u8))
+    (result $error (expected (error $errno)))
+  )
+  ;;; Return command-line argument data sizes.
+  (@interface func (export "args_sizes_get")
+    ;;; Returns the number of arguments and the size of the argument string
+    ;;; data, or an error.
+    (result $error (expected (tuple $size $size) (error $errno)))
+  )
+
+  ;;; Read environment variable data.
+  ;;; The sizes of the buffers should match that returned by `environ_sizes_get`.
+  ;;; Key/value pairs are expected to be joined with `=`s, and terminated with `\0`s.
+  (@interface func (export "environ_get")
+    (param $environ (@witx pointer (@witx pointer u8)))
+    (param $environ_buf (@witx pointer u8))
+    (result $error (expected (error $errno)))
+  )
+  ;;; Return environment variable data sizes.
+  (@interface func (export "environ_sizes_get")
+    ;;; Returns the number of environment variable arguments and the size of the
+    ;;; environment variable data.
+    (result $error (expected (tuple $size $size) (error $errno)))
+  )
+
+  ;;; Return the resolution of a clock.
+  ;;; Implementations are required to provide a non-zero value for supported clocks. For unsupported clocks, return
+  ;;; `errno::inval`.
+  ;;; Note: This is similar to `clock_getres` in POSIX.
+  (@interface func (export "clock_res_get")
+    ;;; The clock for which to return the resolution.
+    (param $id $clockid)
+    ;;; The resolution of the clock, or an error if one happened.
+    (result $error (expected $timestamp (error $errno)))
+  )
+  ;;; Return the time value of a clock.
+  ;;; Note: This is similar to `clock_gettime` in POSIX.
+  (@interface func (export "clock_time_get")
+    ;;; The clock for which to return the time.
+    (param $id $clockid)
+    ;;; The maximum lag (exclusive) that the returned time value may have, compared to its actual value.
+    (param $precision $timestamp)
+    ;;; The time value of the clock.
+    (result $error (expected $timestamp (error $errno)))
+  )
+
+  ;;; Provide file advisory information on a file descriptor.
+  ;;; Note: This is similar to `posix_fadvise` in POSIX.
+  (@interface func (export "fd_advise")
+    (param $fd $fd)
+    ;;; The offset within the file to which the advisory applies.
+    (param $offset $filesize)
+    ;;; The length of the region to which the advisory applies.
+    (param $len $filesize)
+    ;;; The advice.
+    (param $advice $advice)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Force the allocation of space in a file.
+  ;;; Note: This is similar to `posix_fallocate` in POSIX.
+  (@interface func (export "fd_allocate")
+    (param $fd $fd)
+    ;;; The offset at which to start the allocation.
+    (param $offset $filesize)
+    ;;; The length of the area that is allocated.
+    (param $len $filesize)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Close a file descriptor.
+  ;;; Note: This is similar to `close` in POSIX.
+  (@interface func (export "fd_close")
+    (param $fd $fd)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Synchronize the data of a file to disk.
+  ;;; Note: This is similar to `fdatasync` in POSIX.
+  (@interface func (export "fd_datasync")
+    (param $fd $fd)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Get the attributes of a file descriptor.
+  ;;; Note: This returns similar flags to `fsync(fd, F_GETFL)` in POSIX, as well as additional fields.
+  (@interface func (export "fd_fdstat_get")
+    (param $fd $fd)
+    ;;; The buffer where the file descriptor's attributes are stored.
+    (result $error (expected $fdstat (error $errno)))
+  )
+
+  ;;; Adjust the flags associated with a file descriptor.
+  ;;; Note: This is similar to `fcntl(fd, F_SETFL, flags)` in POSIX.
+  (@interface func (export "fd_fdstat_set_flags")
+    (param $fd $fd)
+    ;;; The desired values of the file descriptor flags.
+    (param $flags $fdflags)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Adjust the rights associated with a file descriptor.
+  ;;; This can only be used to remove rights, and returns `errno::notcapable` if called in a way that would attempt to add rights
+  (@interface func (export "fd_fdstat_set_rights")
+    (param $fd $fd)
+    ;;; The desired rights of the file descriptor.
+    (param $fs_rights_base $rights)
+    (param $fs_rights_inheriting $rights)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Return the attributes of an open file.
+  (@interface func (export "fd_filestat_get")
+    (param $fd $fd)
+    ;;; The buffer where the file's attributes are stored.
+    (result $error (expected $filestat (error $errno)))
+  )
+
+  ;;; Adjust the size of an open file. If this increases the file's size, the extra bytes are filled with zeros.
+  ;;; Note: This is similar to `ftruncate` in POSIX.
+  (@interface func (export "fd_filestat_set_size")
+    (param $fd $fd)
+    ;;; The desired file size.
+    (param $size $filesize)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Adjust the timestamps of an open file or directory.
+  ;;; Note: This is similar to `futimens` in POSIX.
+  (@interface func (export "fd_filestat_set_times")
+    (param $fd $fd)
+    ;;; The desired values of the data access timestamp.
+    (param $atim $timestamp)
+    ;;; The desired values of the data modification timestamp.
+    (param $mtim $timestamp)
+    ;;; A bitmask indicating which timestamps to adjust.
+    (param $fst_flags $fstflags)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Read from a file descriptor, without using and updating the file descriptor's offset.
+  ;;; Note: This is similar to `preadv` in POSIX.
+  (@interface func (export "fd_pread")
+    (param $fd $fd)
+    ;;; List of scatter/gather vectors in which to store data.
+    (param $iovs $iovec_array)
+    ;;; The offset within the file at which to read.
+    (param $offset $filesize)
+    ;;; The number of bytes read.
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Return a description of the given preopened file descriptor.
+  (@interface func (export "fd_prestat_get")
+    (param $fd $fd)
+    ;;; The buffer where the description is stored.
+    (result $error (expected $prestat (error $errno)))
+  )
+
+  ;;; Return a description of the given preopened file descriptor.
+  (@interface func (export "fd_prestat_dir_name")
+    (param $fd $fd)
+    ;;; A buffer into which to write the preopened directory name.
+    (param $path (@witx pointer u8))
+    (param $path_len $size)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Write to a file descriptor, without using and updating the file descriptor's offset.
+  ;;; Note: This is similar to `pwritev` in POSIX.
+  (@interface func (export "fd_pwrite")
+    (param $fd $fd)
+    ;;; List of scatter/gather vectors from which to retrieve data.
+    (param $iovs $ciovec_array)
+    ;;; The offset within the file at which to write.
+    (param $offset $filesize)
+    ;;; The number of bytes written.
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Read from a file descriptor.
+  ;;; Note: This is similar to `readv` in POSIX.
+  (@interface func (export "fd_read")
+    (param $fd $fd)
+    ;;; List of scatter/gather vectors to which to store data.
+    (param $iovs $iovec_array)
+    ;;; The number of bytes read.
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Read directory entries from a directory.
+  ;;; When successful, the contents of the output buffer consist of a sequence of
+  ;;; directory entries. Each directory entry consists of a `dirent` object,
+  ;;; followed by `dirent::d_namlen` bytes holding the name of the directory
+  ;;; entry.
+  ;;
+  ;;; This function fills the output buffer as much as possible, potentially
+  ;;; truncating the last directory entry. This allows the caller to grow its
+  ;;; read buffer size in case it's too small to fit a single large directory
+  ;;; entry, or skip the oversized directory entry.
+  (@interface func (export "fd_readdir")
+    (param $fd $fd)
+    ;;; The buffer where directory entries are stored
+    (param $buf (@witx pointer u8))
+    (param $buf_len $size)
+    ;;; The location within the directory to start reading
+    (param $cookie $dircookie)
+    ;;; The number of bytes stored in the read buffer. If less than the size of the read buffer, the end of the directory has been reached.
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Atomically replace a file descriptor by renumbering another file descriptor.
+  ;;
+  ;;; Due to the strong focus on thread safety, this environment does not provide
+  ;;; a mechanism to duplicate or renumber a file descriptor to an arbitrary
+  ;;; number, like `dup2()`. This would be prone to race conditions, as an actual
+  ;;; file descriptor with the same number could be allocated by a different
+  ;;; thread at the same time.
+  ;;
+  ;;; This function provides a way to atomically renumber file descriptors, which
+  ;;; would disappear if `dup2()` were to be removed entirely.
+  (@interface func (export "fd_renumber")
+    (param $fd $fd)
+    ;;; The file descriptor to overwrite.
+    (param $to $fd)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Move the offset of a file descriptor.
+  ;;; Note: This is similar to `lseek` in POSIX.
+  (@interface func (export "fd_seek")
+    (param $fd $fd)
+    ;;; The number of bytes to move.
+    (param $offset $filedelta)
+    ;;; The base from which the offset is relative.
+    (param $whence $whence)
+    ;;; The new offset of the file descriptor, relative to the start of the file.
+    (result $error (expected $filesize (error $errno)))
+  )
+
+  ;;; Synchronize the data and metadata of a file to disk.
+  ;;; Note: This is similar to `fsync` in POSIX.
+  (@interface func (export "fd_sync")
+    (param $fd $fd)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Return the current offset of a file descriptor.
+  ;;; Note: This is similar to `lseek(fd, 0, SEEK_CUR)` in POSIX.
+  (@interface func (export "fd_tell")
+    (param $fd $fd)
+    ;;; The current offset of the file descriptor, relative to the start of the file.
+    (result $error (expected $filesize (error $errno)))
+  )
+
+  ;;; Write to a file descriptor.
+  ;;; Note: This is similar to `writev` in POSIX.
+  (@interface func (export "fd_write")
+    (param $fd $fd)
+    ;;; List of scatter/gather vectors from which to retrieve data.
+    (param $iovs $ciovec_array)
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Create a directory.
+  ;;; Note: This is similar to `mkdirat` in POSIX.
+  (@interface func (export "path_create_directory")
+    (param $fd $fd)
+    ;;; The path at which to create the directory.
+    (param $path string)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Return the attributes of a file or directory.
+  ;;; Note: This is similar to `stat` in POSIX.
+  (@interface func (export "path_filestat_get")
+    (param $fd $fd)
+    ;;; Flags determining the method of how the path is resolved.
+    (param $flags $lookupflags)
+    ;;; The path of the file or directory to inspect.
+    (param $path string)
+    ;;; The buffer where the file's attributes are stored.
+    (result $error (expected $filestat (error $errno)))
+  )
+
+  ;;; Adjust the timestamps of a file or directory.
+  ;;; Note: This is similar to `utimensat` in POSIX.
+  (@interface func (export "path_filestat_set_times")
+    (param $fd $fd)
+    ;;; Flags determining the method of how the path is resolved.
+    (param $flags $lookupflags)
+    ;;; The path of the file or directory to operate on.
+    (param $path string)
+    ;;; The desired values of the data access timestamp.
+    (param $atim $timestamp)
+    ;;; The desired values of the data modification timestamp.
+    (param $mtim $timestamp)
+    ;;; A bitmask indicating which timestamps to adjust.
+    (param $fst_flags $fstflags)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Create a hard link.
+  ;;; Note: This is similar to `linkat` in POSIX.
+  (@interface func (export "path_link")
+    (param $old_fd $fd)
+    ;;; Flags determining the method of how the path is resolved.
+    (param $old_flags $lookupflags)
+    ;;; The source path from which to link.
+    (param $old_path string)
+    ;;; The working directory at which the resolution of the new path starts.
+    (param $new_fd $fd)
+    ;;; The destination path at which to create the hard link.
+    (param $new_path string)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Open a file or directory.
+  ;;
+  ;;; The returned file descriptor is not guaranteed to be the lowest-numbered
+  ;;; file descriptor not currently open; it is randomized to prevent
+  ;;; applications from depending on making assumptions about indexes, since this
+  ;;; is error-prone in multi-threaded contexts. The returned file descriptor is
+  ;;; guaranteed to be less than 2**31.
+  ;;
+  ;;; Note: This is similar to `openat` in POSIX.
+  (@interface func (export "path_open")
+    (param $fd $fd)
+    ;;; Flags determining the method of how the path is resolved.
+    (param $dirflags $lookupflags)
+    ;;; The relative path of the file or directory to open, relative to the
+    ;;; `path_open::fd` directory.
+    (param $path string)
+    ;;; The method by which to open the file.
+    (param $oflags $oflags)
+    ;;; The initial rights of the newly created file descriptor. The
+    ;;; implementation is allowed to return a file descriptor with fewer rights
+    ;;; than specified, if and only if those rights do not apply to the type of
+    ;;; file being opened.
+    ;;
+    ;;; The *base* rights are rights that will apply to operations using the file
+    ;;; descriptor itself, while the *inheriting* rights are rights that apply to
+    ;;; file descriptors derived from it.
+    (param $fs_rights_base $rights)
+    (param $fs_rights_inheriting $rights)
+    (param $fdflags $fdflags)
+    ;;; The file descriptor of the file that has been opened.
+    (result $error (expected $fd (error $errno)))
+  )
+
+  ;;; Read the contents of a symbolic link.
+  ;;; Note: This is similar to `readlinkat` in POSIX.
+  (@interface func (export "path_readlink")
+    (param $fd $fd)
+    ;;; The path of the symbolic link from which to read.
+    (param $path string)
+    ;;; The buffer to which to write the contents of the symbolic link.
+    (param $buf (@witx pointer u8))
+    (param $buf_len $size)
+    ;;; The number of bytes placed in the buffer.
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Remove a directory.
+  ;;; Return `errno::notempty` if the directory is not empty.
+  ;;; Note: This is similar to `unlinkat(fd, path, AT_REMOVEDIR)` in POSIX.
+  (@interface func (export "path_remove_directory")
+    (param $fd $fd)
+    ;;; The path to a directory to remove.
+    (param $path string)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Rename a file or directory.
+  ;;; Note: This is similar to `renameat` in POSIX.
+  (@interface func (export "path_rename")
+    (param $fd $fd)
+    ;;; The source path of the file or directory to rename.
+    (param $old_path string)
+    ;;; The working directory at which the resolution of the new path starts.
+    (param $new_fd $fd)
+    ;;; The destination path to which to rename the file or directory.
+    (param $new_path string)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Create a symbolic link.
+  ;;; Note: This is similar to `symlinkat` in POSIX.
+  (@interface func (export "path_symlink")
+    ;;; The contents of the symbolic link.
+    (param $old_path string)
+    (param $fd $fd)
+    ;;; The destination path at which to create the symbolic link.
+    (param $new_path string)
+    (result $error (expected (error $errno)))
+  )
+
+
+  ;;; Unlink a file.
+  ;;; Return `errno::isdir` if the path refers to a directory.
+  ;;; Note: This is similar to `unlinkat(fd, path, 0)` in POSIX.
+  (@interface func (export "path_unlink_file")
+    (param $fd $fd)
+    ;;; The path to a file to unlink.
+    (param $path string)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Concurrently poll for the occurrence of a set of events.
+  (@interface func (export "poll_oneoff")
+    ;;; The events to which to subscribe.
+    (param $in (@witx const_pointer $subscription))
+    ;;; The events that have occurred.
+    (param $out (@witx pointer $event))
+    ;;; Both the number of subscriptions and events.
+    (param $nsubscriptions $size)
+    ;;; The number of events stored.
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Terminate the process normally. An exit code of 0 indicates successful
+  ;;; termination of the program. The meanings of other values is dependent on
+  ;;; the environment.
+  (@interface func (export "proc_exit")
+    ;;; The exit code returned by the process.
+    (param $rval $exitcode)
+    (@witx noreturn)
+  )
+
+  ;;; Send a signal to the process of the calling thread.
+  ;;; Note: This is similar to `raise` in POSIX.
+  (@interface func (export "proc_raise")
+    ;;; The signal condition to trigger.
+    (param $sig $signal)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Temporarily yield execution of the calling thread.
+  ;;; Note: This is similar to `sched_yield` in POSIX.
+  (@interface func (export "sched_yield")
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Write high-quality random data into a buffer.
+  ;;; This function blocks when the implementation is unable to immediately
+  ;;; provide sufficient high-quality random data.
+  ;;; This function may execute slowly, so when large mounts of random data are
+  ;;; required, it's advisable to use this function to seed a pseudo-random
+  ;;; number generator, rather than to provide the random data directly.
+  (@interface func (export "random_get")
+    ;;; The buffer to fill with random data.
+    (param $buf (@witx pointer u8))
+    (param $buf_len $size)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Receive a message from a socket.
+  ;;; Note: This is similar to `recv` in POSIX, though it also supports reading
+  ;;; the data into multiple buffers in the manner of `readv`.
+  (@interface func (export "sock_recv")
+    (param $fd $fd)
+    ;;; List of scatter/gather vectors to which to store data.
+    (param $ri_data $iovec_array)
+    ;;; Message flags.
+    (param $ri_flags $riflags)
+    ;;; Number of bytes stored in ri_data and message flags.
+    (result $error (expected (tuple $size $roflags) (error $errno)))
+  )
+
+  ;;; Send a message on a socket.
+  ;;; Note: This is similar to `send` in POSIX, though it also supports writing
+  ;;; the data from multiple buffers in the manner of `writev`.
+  (@interface func (export "sock_send")
+    (param $fd $fd)
+    ;;; List of scatter/gather vectors to which to retrieve data
+    (param $si_data $ciovec_array)
+    ;;; Message flags.
+    (param $si_flags $siflags)
+    ;;; Number of bytes transmitted.
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Shut down socket send and receive channels.
+  ;;; Note: This is similar to `shutdown` in POSIX.
+  (@interface func (export "sock_shutdown")
+    (param $fd $fd)
+    ;;; Which channels on the socket to shut down.
+    (param $how $sdflags)
+    (result $error (expected (error $errno)))
+  )
+)
diff --git a/crates/wasi/witx/preview1/typenames.witx b/crates/wasi/witx/preview1/typenames.witx
new file mode 100644
index 000000000000..e87239127c07
--- /dev/null
+++ b/crates/wasi/witx/preview1/typenames.witx
@@ -0,0 +1,750 @@
+;; Type names used by low-level WASI interfaces.
+;;
+;; Some content here is derived from [CloudABI](https://github.com/NuxiNL/cloudabi).
+;;
+;; This is a `witx` file. See [here](https://github.com/WebAssembly/WASI/tree/master/docs/witx.md)
+;; for an explanation of what that means.
+
+(typename $size u32)
+
+;;; Non-negative file size or length of a region within a file.
+(typename $filesize u64)
+
+;;; Timestamp in nanoseconds.
+(typename $timestamp u64)
+
+;;; Identifiers for clocks.
+(typename $clockid
+  (enum (@witx tag u32)
+    ;;; The clock measuring real time. Time value zero corresponds with
+    ;;; 1970-01-01T00:00:00Z.
+    $realtime
+    ;;; The store-wide monotonic clock, which is defined as a clock measuring
+    ;;; real time, whose value cannot be adjusted and which cannot have negative
+    ;;; clock jumps. The epoch of this clock is undefined. The absolute time
+    ;;; value of this clock therefore has no meaning.
+    $monotonic
+    ;;; The CPU-time clock associated with the current process.
+    $process_cputime_id
+    ;;; The CPU-time clock associated with the current thread.
+    $thread_cputime_id
+  )
+)
+
+;;; Error codes returned by functions.
+;;; Not all of these error codes are returned by the functions provided by this
+;;; API; some are used in higher-level library layers, and others are provided
+;;; merely for alignment with POSIX.
+(typename $errno
+  (enum (@witx tag u16)
+    ;;; No error occurred. System call completed successfully.
+    $success
+    ;;; Argument list too long.
+    $2big
+    ;;; Permission denied.
+    $acces
+    ;;; Address in use.
+    $addrinuse
+    ;;; Address not available.
+    $addrnotavail
+    ;;; Address family not supported.
+    $afnosupport
+    ;;; Resource unavailable, or operation would block.
+    $again
+    ;;; Connection already in progress.
+    $already
+    ;;; Bad file descriptor.
+    $badf
+    ;;; Bad message.
+    $badmsg
+    ;;; Device or resource busy.
+    $busy
+    ;;; Operation canceled.
+    $canceled
+    ;;; No child processes.
+    $child
+    ;;; Connection aborted.
+    $connaborted
+    ;;; Connection refused.
+    $connrefused
+    ;;; Connection reset.
+    $connreset
+    ;;; Resource deadlock would occur.
+    $deadlk
+    ;;; Destination address required.
+    $destaddrreq
+    ;;; Mathematics argument out of domain of function.
+    $dom
+    ;;; Reserved.
+    $dquot
+    ;;; File exists.
+    $exist
+    ;;; Bad address.
+    $fault
+    ;;; File too large.
+    $fbig
+    ;;; Host is unreachable.
+    $hostunreach
+    ;;; Identifier removed.
+    $idrm
+    ;;; Illegal byte sequence.
+    $ilseq
+    ;;; Operation in progress.
+    $inprogress
+    ;;; Interrupted function.
+    $intr
+    ;;; Invalid argument.
+    $inval
+    ;;; I/O error.
+    $io
+    ;;; Socket is connected.
+    $isconn
+    ;;; Is a directory.
+    $isdir
+    ;;; Too many levels of symbolic links.
+    $loop
+    ;;; File descriptor value too large.
+    $mfile
+    ;;; Too many links.
+    $mlink
+    ;;; Message too large.
+    $msgsize
+    ;;; Reserved.
+    $multihop
+    ;;; Filename too long.
+    $nametoolong
+    ;;; Network is down.
+    $netdown
+    ;;; Connection aborted by network.
+    $netreset
+    ;;; Network unreachable.
+    $netunreach
+    ;;; Too many files open in system.
+    $nfile
+    ;;; No buffer space available.
+    $nobufs
+    ;;; No such device.
+    $nodev
+    ;;; No such file or directory.
+    $noent
+    ;;; Executable file format error.
+    $noexec
+    ;;; No locks available.
+    $nolck
+    ;;; Reserved.
+    $nolink
+    ;;; Not enough space.
+    $nomem
+    ;;; No message of the desired type.
+    $nomsg
+    ;;; Protocol not available.
+    $noprotoopt
+    ;;; No space left on device.
+    $nospc
+    ;;; Function not supported.
+    $nosys
+    ;;; The socket is not connected.
+    $notconn
+    ;;; Not a directory or a symbolic link to a directory.
+    $notdir
+    ;;; Directory not empty.
+    $notempty
+    ;;; State not recoverable.
+    $notrecoverable
+    ;;; Not a socket.
+    $notsock
+    ;;; Not supported, or operation not supported on socket.
+    $notsup
+    ;;; Inappropriate I/O control operation.
+    $notty
+    ;;; No such device or address.
+    $nxio
+    ;;; Value too large to be stored in data type.
+    $overflow
+    ;;; Previous owner died.
+    $ownerdead
+    ;;; Operation not permitted.
+    $perm
+    ;;; Broken pipe.
+    $pipe
+    ;;; Protocol error.
+    $proto
+    ;;; Protocol not supported.
+    $protonosupport
+    ;;; Protocol wrong type for socket.
+    $prototype
+    ;;; Result too large.
+    $range
+    ;;; Read-only file system.
+    $rofs
+    ;;; Invalid seek.
+    $spipe
+    ;;; No such process.
+    $srch
+    ;;; Reserved.
+    $stale
+    ;;; Connection timed out.
+    $timedout
+    ;;; Text file busy.
+    $txtbsy
+    ;;; Cross-device link.
+    $xdev
+    ;;; Extension: Capabilities insufficient.
+    $notcapable
+  )
+)
+
+;;; File descriptor rights, determining which actions may be performed.
+(typename $rights
+  (flags (@witx repr u64)
+    ;;; The right to invoke `fd_datasync`.
+    ;;
+    ;;; If `path_open` is set, includes the right to invoke
+    ;;; `path_open` with `fdflags::dsync`.
+    $fd_datasync
+    ;;; The right to invoke `fd_read` and `sock_recv`.
+    ;;
+    ;;; If `rights::fd_seek` is set, includes the right to invoke `fd_pread`.
+    $fd_read
+    ;;; The right to invoke `fd_seek`. This flag implies `rights::fd_tell`.
+    $fd_seek
+    ;;; The right to invoke `fd_fdstat_set_flags`.
+    $fd_fdstat_set_flags
+    ;;; The right to invoke `fd_sync`.
+    ;;
+    ;;; If `path_open` is set, includes the right to invoke
+    ;;; `path_open` with `fdflags::rsync` and `fdflags::dsync`.
+    $fd_sync
+    ;;; The right to invoke `fd_seek` in such a way that the file offset
+    ;;; remains unaltered (i.e., `whence::cur` with offset zero), or to
+    ;;; invoke `fd_tell`.
+    $fd_tell
+    ;;; The right to invoke `fd_write` and `sock_send`.
+    ;;; If `rights::fd_seek` is set, includes the right to invoke `fd_pwrite`.
+    $fd_write
+    ;;; The right to invoke `fd_advise`.
+    $fd_advise
+    ;;; The right to invoke `fd_allocate`.
+    $fd_allocate
+    ;;; The right to invoke `path_create_directory`.
+    $path_create_directory
+    ;;; If `path_open` is set, the right to invoke `path_open` with `oflags::creat`.
+    $path_create_file
+    ;;; The right to invoke `path_link` with the file descriptor as the
+    ;;; source directory.
+    $path_link_source
+    ;;; The right to invoke `path_link` with the file descriptor as the
+    ;;; target directory.
+    $path_link_target
+    ;;; The right to invoke `path_open`.
+    $path_open
+    ;;; The right to invoke `fd_readdir`.
+    $fd_readdir
+    ;;; The right to invoke `path_readlink`.
+    $path_readlink
+    ;;; The right to invoke `path_rename` with the file descriptor as the source directory.
+    $path_rename_source
+    ;;; The right to invoke `path_rename` with the file descriptor as the target directory.
+    $path_rename_target
+    ;;; The right to invoke `path_filestat_get`.
+    $path_filestat_get
+    ;;; The right to change a file's size (there is no `path_filestat_set_size`).
+    ;;; If `path_open` is set, includes the right to invoke `path_open` with `oflags::trunc`.
+    $path_filestat_set_size
+    ;;; The right to invoke `path_filestat_set_times`.
+    $path_filestat_set_times
+    ;;; The right to invoke `fd_filestat_get`.
+    $fd_filestat_get
+    ;;; The right to invoke `fd_filestat_set_size`.
+    $fd_filestat_set_size
+    ;;; The right to invoke `fd_filestat_set_times`.
+    $fd_filestat_set_times
+    ;;; The right to invoke `path_symlink`.
+    $path_symlink
+    ;;; The right to invoke `path_remove_directory`.
+    $path_remove_directory
+    ;;; The right to invoke `path_unlink_file`.
+    $path_unlink_file
+    ;;; If `rights::fd_read` is set, includes the right to invoke `poll_oneoff` to subscribe to `eventtype::fd_read`.
+    ;;; If `rights::fd_write` is set, includes the right to invoke `poll_oneoff` to subscribe to `eventtype::fd_write`.
+    $poll_fd_readwrite
+    ;;; The right to invoke `sock_shutdown`.
+    $sock_shutdown
+    ;;; The right to invoke `sock_accept`.
+    $sock_accept
+  )
+)
+
+;;; A file descriptor handle.
+(typename $fd (handle))
+
+;;; A region of memory for scatter/gather reads.
+(typename $iovec
+  (record
+    ;;; The address of the buffer to be filled.
+    (field $buf (@witx pointer u8))
+    ;;; The length of the buffer to be filled.
+    (field $buf_len $size)
+  )
+)
+
+;;; A region of memory for scatter/gather writes.
+(typename $ciovec
+  (record
+    ;;; The address of the buffer to be written.
+    (field $buf (@witx const_pointer u8))
+    ;;; The length of the buffer to be written.
+    (field $buf_len $size)
+  )
+)
+
+(typename $iovec_array (list $iovec))
+(typename $ciovec_array (list $ciovec))
+
+;;; Relative offset within a file.
+(typename $filedelta s64)
+
+;;; The position relative to which to set the offset of the file descriptor.
+(typename $whence
+  (enum (@witx tag u8)
+    ;;; Seek relative to start-of-file.
+    $set
+    ;;; Seek relative to current position.
+    $cur
+    ;;; Seek relative to end-of-file.
+    $end
+  )
+)
+
+;;; A reference to the offset of a directory entry.
+;;;
+;;; The value 0 signifies the start of the directory.
+(typename $dircookie u64)
+
+;;; The type for the `dirent::d_namlen` field of `dirent` struct.
+(typename $dirnamlen u32)
+
+;;; File serial number that is unique within its file system.
+(typename $inode u64)
+
+;;; The type of a file descriptor or file.
+(typename $filetype
+  (enum (@witx tag u8)
+    ;;; The type of the file descriptor or file is unknown or is different from any of the other types specified.
+    $unknown
+    ;;; The file descriptor or file refers to a block device inode.
+    $block_device
+    ;;; The file descriptor or file refers to a character device inode.
+    $character_device
+    ;;; The file descriptor or file refers to a directory inode.
+    $directory
+    ;;; The file descriptor or file refers to a regular file inode.
+    $regular_file
+    ;;; The file descriptor or file refers to a datagram socket.
+    $socket_dgram
+    ;;; The file descriptor or file refers to a byte-stream socket.
+    $socket_stream
+    ;;; The file refers to a symbolic link inode.
+    $symbolic_link
+  )
+)
+
+;;; A directory entry.
+(typename $dirent
+  (record
+    ;;; The offset of the next directory entry stored in this directory.
+    (field $d_next $dircookie)
+    ;;; The serial number of the file referred to by this directory entry.
+    (field $d_ino $inode)
+    ;;; The length of the name of the directory entry.
+    (field $d_namlen $dirnamlen)
+    ;;; The type of the file referred to by this directory entry.
+    (field $d_type $filetype)
+  )
+)
+
+;;; File or memory access pattern advisory information.
+(typename $advice
+  (enum (@witx tag u8)
+    ;;; The application has no advice to give on its behavior with respect to the specified data.
+    $normal
+    ;;; The application expects to access the specified data sequentially from lower offsets to higher offsets.
+    $sequential
+    ;;; The application expects to access the specified data in a random order.
+    $random
+    ;;; The application expects to access the specified data in the near future.
+    $willneed
+    ;;; The application expects that it will not access the specified data in the near future.
+    $dontneed
+    ;;; The application expects to access the specified data once and then not reuse it thereafter.
+    $noreuse
+  )
+)
+
+;;; File descriptor flags.
+(typename $fdflags
+  (flags (@witx repr u16)
+    ;;; Append mode: Data written to the file is always appended to the file's end.
+    $append
+    ;;; Write according to synchronized I/O data integrity completion. Only the data stored in the file is synchronized.
+    $dsync
+    ;;; Non-blocking mode.
+    $nonblock
+    ;;; Synchronized read I/O operations.
+    $rsync
+    ;;; Write according to synchronized I/O file integrity completion. In
+    ;;; addition to synchronizing the data stored in the file, the implementation
+    ;;; may also synchronously update the file's metadata.
+    $sync
+  )
+)
+
+;;; File descriptor attributes.
+(typename $fdstat
+  (record
+    ;;; File type.
+    (field $fs_filetype $filetype)
+    ;;; File descriptor flags.
+    (field $fs_flags $fdflags)
+    ;;; Rights that apply to this file descriptor.
+    (field $fs_rights_base $rights)
+    ;;; Maximum set of rights that may be installed on new file descriptors that
+    ;;; are created through this file descriptor, e.g., through `path_open`.
+    (field $fs_rights_inheriting $rights)
+  )
+)
+
+;;; Identifier for a device containing a file system. Can be used in combination
+;;; with `inode` to uniquely identify a file or directory in the filesystem.
+(typename $device u64)
+
+;;; Which file time attributes to adjust.
+(typename $fstflags
+  (flags (@witx repr u16)
+    ;;; Adjust the last data access timestamp to the value stored in `filestat::atim`.
+    $atim
+    ;;; Adjust the last data access timestamp to the time of clock `clockid::realtime`.
+    $atim_now
+    ;;; Adjust the last data modification timestamp to the value stored in `filestat::mtim`.
+    $mtim
+    ;;; Adjust the last data modification timestamp to the time of clock `clockid::realtime`.
+    $mtim_now
+  )
+)
+
+;;; Flags determining the method of how paths are resolved.
+(typename $lookupflags
+  (flags (@witx repr u32)
+    ;;; As long as the resolved path corresponds to a symbolic link, it is expanded.
+    $symlink_follow
+  )
+)
+
+;;; Open flags used by `path_open`.
+(typename $oflags
+  (flags (@witx repr u16)
+    ;;; Create file if it does not exist.
+    $creat
+    ;;; Fail if not a directory.
+    $directory
+    ;;; Fail if file already exists.
+    $excl
+    ;;; Truncate file to size 0.
+    $trunc
+  )
+)
+
+;;; Number of hard links to an inode.
+(typename $linkcount u64)
+
+;;; File attributes.
+(typename $filestat
+  (record
+    ;;; Device ID of device containing the file.
+    (field $dev $device)
+    ;;; File serial number.
+    (field $ino $inode)
+    ;;; File type.
+    (field $filetype $filetype)
+    ;;; Number of hard links to the file.
+    (field $nlink $linkcount)
+    ;;; For regular files, the file size in bytes. For symbolic links, the length in bytes of the pathname contained in the symbolic link.
+    (field $size $filesize)
+    ;;; Last data access timestamp.
+    (field $atim $timestamp)
+    ;;; Last data modification timestamp.
+    (field $mtim $timestamp)
+    ;;; Last file status change timestamp.
+    (field $ctim $timestamp)
+  )
+)
+
+;;; User-provided value that may be attached to objects that is retained when
+;;; extracted from the implementation.
+(typename $userdata u64)
+
+;;; Type of a subscription to an event or its occurrence.
+(typename $eventtype
+  (enum (@witx tag u8)
+    ;;; The time value of clock `subscription_clock::id` has
+    ;;; reached timestamp `subscription_clock::timeout`.
+    $clock
+    ;;; File descriptor `subscription_fd_readwrite::file_descriptor` has data
+    ;;; available for reading. This event always triggers for regular files.
+    $fd_read
+    ;;; File descriptor `subscription_fd_readwrite::file_descriptor` has capacity
+    ;;; available for writing. This event always triggers for regular files.
+    $fd_write
+  )
+)
+
+;;; The state of the file descriptor subscribed to with
+;;; `eventtype::fd_read` or `eventtype::fd_write`.
+(typename $eventrwflags
+  (flags (@witx repr u16)
+    ;;; The peer of this socket has closed or disconnected.
+    $fd_readwrite_hangup
+  )
+)
+
+;;; The contents of an `event` when type is `eventtype::fd_read` or
+;;; `eventtype::fd_write`.
+(typename $event_fd_readwrite
+  (record
+    ;;; The number of bytes available for reading or writing.
+    (field $nbytes $filesize)
+    ;;; The state of the file descriptor.
+    (field $flags $eventrwflags)
+  )
+)
+
+;;; An event that occurred.
+(typename $event
+  (record
+    ;;; User-provided value that got attached to `subscription::userdata`.
+    (field $userdata $userdata)
+    ;;; If non-zero, an error that occurred while processing the subscription request.
+    (field $error $errno)
+    ;;; The type of event that occurred
+    (field $type $eventtype)
+    ;;; The contents of the event, if it is an `eventtype::fd_read` or
+    ;;; `eventtype::fd_write`. `eventtype::clock` events ignore this field.
+    (field $fd_readwrite $event_fd_readwrite)
+  )
+)
+
+;;; Flags determining how to interpret the timestamp provided in
+;;; `subscription_clock::timeout`.
+(typename $subclockflags
+  (flags (@witx repr u16)
+    ;;; If set, treat the timestamp provided in
+    ;;; `subscription_clock::timeout` as an absolute timestamp of clock
+    ;;; `subscription_clock::id`. If clear, treat the timestamp
+    ;;; provided in `subscription_clock::timeout` relative to the
+    ;;; current time value of clock `subscription_clock::id`.
+    $subscription_clock_abstime
+  )
+)
+
+;;; The contents of a `subscription` when type is `eventtype::clock`.
+(typename $subscription_clock
+  (record
+    ;;; The clock against which to compare the timestamp.
+    (field $id $clockid)
+    ;;; The absolute or relative timestamp.
+    (field $timeout $timestamp)
+    ;;; The amount of time that the implementation may wait additionally
+    ;;; to coalesce with other events.
+    (field $precision $timestamp)
+    ;;; Flags specifying whether the timeout is absolute or relative
+    (field $flags $subclockflags)
+  )
+)
+
+;;; The contents of a `subscription` when type is type is
+;;; `eventtype::fd_read` or `eventtype::fd_write`.
+(typename $subscription_fd_readwrite
+  (record
+    ;;; The file descriptor on which to wait for it to become ready for reading or writing.
+    (field $file_descriptor $fd)
+  )
+)
+
+;;; The contents of a `subscription`.
+(typename $subscription_u
+  (union
+    (@witx tag $eventtype)
+    $subscription_clock
+    $subscription_fd_readwrite
+    $subscription_fd_readwrite
+  )
+)
+
+;;; Subscription to an event.
+(typename $subscription
+  (record
+    ;;; User-provided value that is attached to the subscription in the
+    ;;; implementation and returned through `event::userdata`.
+    (field $userdata $userdata)
+    ;;; The type of the event to which to subscribe, and its contents
+    (field $u $subscription_u)
+  )
+)
+
+;;; Exit code generated by a process when exiting.
+(typename $exitcode u32)
+
+;;; Signal condition.
+(typename $signal
+  (enum (@witx tag u8)
+    ;;; No signal. Note that POSIX has special semantics for `kill(pid, 0)`,
+    ;;; so this value is reserved.
+    $none
+    ;;; Hangup.
+    ;;; Action: Terminates the process.
+    $hup
+    ;;; Terminate interrupt signal.
+    ;;; Action: Terminates the process.
+    $int
+    ;;; Terminal quit signal.
+    ;;; Action: Terminates the process.
+    $quit
+    ;;; Illegal instruction.
+    ;;; Action: Terminates the process.
+    $ill
+    ;;; Trace/breakpoint trap.
+    ;;; Action: Terminates the process.
+    $trap
+    ;;; Process abort signal.
+    ;;; Action: Terminates the process.
+    $abrt
+    ;;; Access to an undefined portion of a memory object.
+    ;;; Action: Terminates the process.
+    $bus
+    ;;; Erroneous arithmetic operation.
+    ;;; Action: Terminates the process.
+    $fpe
+    ;;; Kill.
+    ;;; Action: Terminates the process.
+    $kill
+    ;;; User-defined signal 1.
+    ;;; Action: Terminates the process.
+    $usr1
+    ;;; Invalid memory reference.
+    ;;; Action: Terminates the process.
+    $segv
+    ;;; User-defined signal 2.
+    ;;; Action: Terminates the process.
+    $usr2
+    ;;; Write on a pipe with no one to read it.
+    ;;; Action: Ignored.
+    $pipe
+    ;;; Alarm clock.
+    ;;; Action: Terminates the process.
+    $alrm
+    ;;; Termination signal.
+    ;;; Action: Terminates the process.
+    $term
+    ;;; Child process terminated, stopped, or continued.
+    ;;; Action: Ignored.
+    $chld
+    ;;; Continue executing, if stopped.
+    ;;; Action: Continues executing, if stopped.
+    $cont
+    ;;; Stop executing.
+    ;;; Action: Stops executing.
+    $stop
+    ;;; Terminal stop signal.
+    ;;; Action: Stops executing.
+    $tstp
+    ;;; Background process attempting read.
+    ;;; Action: Stops executing.
+    $ttin
+    ;;; Background process attempting write.
+    ;;; Action: Stops executing.
+    $ttou
+    ;;; High bandwidth data is available at a socket.
+    ;;; Action: Ignored.
+    $urg
+    ;;; CPU time limit exceeded.
+    ;;; Action: Terminates the process.
+    $xcpu
+    ;;; File size limit exceeded.
+    ;;; Action: Terminates the process.
+    $xfsz
+    ;;; Virtual timer expired.
+    ;;; Action: Terminates the process.
+    $vtalrm
+    ;;; Profiling timer expired.
+    ;;; Action: Terminates the process.
+    $prof
+    ;;; Window changed.
+    ;;; Action: Ignored.
+    $winch
+    ;;; I/O possible.
+    ;;; Action: Terminates the process.
+    $poll
+    ;;; Power failure.
+    ;;; Action: Terminates the process.
+    $pwr
+    ;;; Bad system call.
+    ;;; Action: Terminates the process.
+    $sys
+  )
+)
+
+;;; Flags provided to `sock_recv`.
+(typename $riflags
+  (flags (@witx repr u16)
+    ;;; Returns the message without removing it from the socket's receive queue.
+    $recv_peek
+    ;;; On byte-stream sockets, block until the full amount of data can be returned.
+    $recv_waitall
+  )
+)
+
+;;; Flags returned by `sock_recv`.
+(typename $roflags
+  (flags (@witx repr u16)
+    ;;; Returned by `sock_recv`: Message data has been truncated.
+    $recv_data_truncated
+  )
+)
+
+;;; Flags provided to `sock_send`. As there are currently no flags
+;;; defined, it must be set to zero.
+(typename $siflags u16)
+
+;;; Which channels on a socket to shut down.
+(typename $sdflags
+  (flags (@witx repr u8)
+    ;;; Disables further receive operations.
+    $rd
+    ;;; Disables further send operations.
+    $wr
+  )
+)
+
+;;; Identifiers for preopened capabilities.
+(typename $preopentype
+  (enum (@witx tag u8)
+    ;;; A pre-opened directory.
+    $dir
+  )
+)
+
+;;; The contents of a $prestat when type is `preopentype::dir`.
+(typename $prestat_dir
+  (record
+    ;;; The length of the directory name for use with `fd_prestat_dir_name`.
+    (field $pr_name_len $size)
+  )
+)
+
+;;; Information about a pre-opened capability.
+(typename $prestat
+  (union (@witx tag $preopentype)
+    $prestat_dir
+  )
+)
+
diff --git a/crates/wasi/witx/preview1/wasi_snapshot_preview1.witx b/crates/wasi/witx/preview1/wasi_snapshot_preview1.witx
new file mode 100644
index 000000000000..100d852b3ec8
--- /dev/null
+++ b/crates/wasi/witx/preview1/wasi_snapshot_preview1.witx
@@ -0,0 +1,521 @@
+;; WASI Preview. This is an evolution of the API that WASI initially
+;; launched with.
+;;
+;; Some content here is derived from [CloudABI](https://github.com/NuxiNL/cloudabi).
+;;
+;; This is a `witx` file. See [here](https://github.com/WebAssembly/WASI/tree/master/docs/witx.md)
+;; for an explanation of what that means.
+
+(use "typenames.witx")
+
+(module $wasi_snapshot_preview1
+  ;;; Linear memory to be accessed by WASI functions that need it.
+  (import "memory" (memory))
+
+  ;;; Read command-line argument data.
+  ;;; The size of the array should match that returned by `args_sizes_get`.
+  ;;; Each argument is expected to be `\0` terminated.
+  (@interface func (export "args_get")
+    (param $argv (@witx pointer (@witx pointer u8)))
+    (param $argv_buf (@witx pointer u8))
+    (result $error (expected (error $errno)))
+  )
+  ;;; Return command-line argument data sizes.
+  (@interface func (export "args_sizes_get")
+    ;;; Returns the number of arguments and the size of the argument string
+    ;;; data, or an error.
+    (result $error (expected (tuple $size $size) (error $errno)))
+  )
+
+  ;;; Read environment variable data.
+  ;;; The sizes of the buffers should match that returned by `environ_sizes_get`.
+  ;;; Key/value pairs are expected to be joined with `=`s, and terminated with `\0`s.
+  (@interface func (export "environ_get")
+    (param $environ (@witx pointer (@witx pointer u8)))
+    (param $environ_buf (@witx pointer u8))
+    (result $error (expected (error $errno)))
+  )
+  ;;; Return environment variable data sizes.
+  (@interface func (export "environ_sizes_get")
+    ;;; Returns the number of environment variable arguments and the size of the
+    ;;; environment variable data.
+    (result $error (expected (tuple $size $size) (error $errno)))
+  )
+
+  ;;; Return the resolution of a clock.
+  ;;; Implementations are required to provide a non-zero value for supported clocks. For unsupported clocks,
+  ;;; return `errno::inval`.
+  ;;; Note: This is similar to `clock_getres` in POSIX.
+  (@interface func (export "clock_res_get")
+    ;;; The clock for which to return the resolution.
+    (param $id $clockid)
+    ;;; The resolution of the clock, or an error if one happened.
+    (result $error (expected $timestamp (error $errno)))
+  )
+  ;;; Return the time value of a clock.
+  ;;; Note: This is similar to `clock_gettime` in POSIX.
+  (@interface func (export "clock_time_get")
+    ;;; The clock for which to return the time.
+    (param $id $clockid)
+    ;;; The maximum lag (exclusive) that the returned time value may have, compared to its actual value.
+    (param $precision $timestamp)
+    ;;; The time value of the clock.
+    (result $error (expected $timestamp (error $errno)))
+  )
+
+  ;;; Provide file advisory information on a file descriptor.
+  ;;; Note: This is similar to `posix_fadvise` in POSIX.
+  (@interface func (export "fd_advise")
+    (param $fd $fd)
+    ;;; The offset within the file to which the advisory applies.
+    (param $offset $filesize)
+    ;;; The length of the region to which the advisory applies.
+    (param $len $filesize)
+    ;;; The advice.
+    (param $advice $advice)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Force the allocation of space in a file.
+  ;;; Note: This is similar to `posix_fallocate` in POSIX.
+  (@interface func (export "fd_allocate")
+    (param $fd $fd)
+    ;;; The offset at which to start the allocation.
+    (param $offset $filesize)
+    ;;; The length of the area that is allocated.
+    (param $len $filesize)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Close a file descriptor.
+  ;;; Note: This is similar to `close` in POSIX.
+  (@interface func (export "fd_close")
+    (param $fd $fd)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Synchronize the data of a file to disk.
+  ;;; Note: This is similar to `fdatasync` in POSIX.
+  (@interface func (export "fd_datasync")
+    (param $fd $fd)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Get the attributes of a file descriptor.
+  ;;; Note: This returns similar flags to `fsync(fd, F_GETFL)` in POSIX, as well as additional fields.
+  (@interface func (export "fd_fdstat_get")
+    (param $fd $fd)
+    ;;; The buffer where the file descriptor's attributes are stored.
+    (result $error (expected $fdstat (error $errno)))
+  )
+
+  ;;; Adjust the flags associated with a file descriptor.
+  ;;; Note: This is similar to `fcntl(fd, F_SETFL, flags)` in POSIX.
+  (@interface func (export "fd_fdstat_set_flags")
+    (param $fd $fd)
+    ;;; The desired values of the file descriptor flags.
+    (param $flags $fdflags)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Adjust the rights associated with a file descriptor.
+  ;;; This can only be used to remove rights, and returns `errno::notcapable` if called in a way that would attempt to add rights
+  (@interface func (export "fd_fdstat_set_rights")
+    (param $fd $fd)
+    ;;; The desired rights of the file descriptor.
+    (param $fs_rights_base $rights)
+    (param $fs_rights_inheriting $rights)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Return the attributes of an open file.
+  (@interface func (export "fd_filestat_get")
+    (param $fd $fd)
+    ;;; The buffer where the file's attributes are stored.
+    (result $error (expected $filestat (error $errno)))
+  )
+
+  ;;; Adjust the size of an open file. If this increases the file's size, the extra bytes are filled with zeros.
+  ;;; Note: This is similar to `ftruncate` in POSIX.
+  (@interface func (export "fd_filestat_set_size")
+    (param $fd $fd)
+    ;;; The desired file size.
+    (param $size $filesize)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Adjust the timestamps of an open file or directory.
+  ;;; Note: This is similar to `futimens` in POSIX.
+  (@interface func (export "fd_filestat_set_times")
+    (param $fd $fd)
+    ;;; The desired values of the data access timestamp.
+    (param $atim $timestamp)
+    ;;; The desired values of the data modification timestamp.
+    (param $mtim $timestamp)
+    ;;; A bitmask indicating which timestamps to adjust.
+    (param $fst_flags $fstflags)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Read from a file descriptor, without using and updating the file descriptor's offset.
+  ;;; Note: This is similar to `preadv` in POSIX.
+  (@interface func (export "fd_pread")
+    (param $fd $fd)
+    ;;; List of scatter/gather vectors in which to store data.
+    (param $iovs $iovec_array)
+    ;;; The offset within the file at which to read.
+    (param $offset $filesize)
+    ;;; The number of bytes read.
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Return a description of the given preopened file descriptor.
+  (@interface func (export "fd_prestat_get")
+    (param $fd $fd)
+    ;;; The buffer where the description is stored.
+    (result $error (expected $prestat (error $errno)))
+  )
+
+  ;;; Return a description of the given preopened file descriptor.
+  (@interface func (export "fd_prestat_dir_name")
+    (param $fd $fd)
+    ;;; A buffer into which to write the preopened directory name.
+    (param $path (@witx pointer u8))
+    (param $path_len $size)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Write to a file descriptor, without using and updating the file descriptor's offset.
+  ;;; Note: This is similar to `pwritev` in POSIX.
+  (@interface func (export "fd_pwrite")
+    (param $fd $fd)
+    ;;; List of scatter/gather vectors from which to retrieve data.
+    (param $iovs $ciovec_array)
+    ;;; The offset within the file at which to write.
+    (param $offset $filesize)
+    ;;; The number of bytes written.
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Read from a file descriptor.
+  ;;; Note: This is similar to `readv` in POSIX.
+  (@interface func (export "fd_read")
+    (param $fd $fd)
+    ;;; List of scatter/gather vectors to which to store data.
+    (param $iovs $iovec_array)
+    ;;; The number of bytes read.
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Read directory entries from a directory.
+  ;;; When successful, the contents of the output buffer consist of a sequence of
+  ;;; directory entries. Each directory entry consists of a `dirent` object,
+  ;;; followed by `dirent::d_namlen` bytes holding the name of the directory
+  ;;; entry.
+  ;;
+  ;;; This function fills the output buffer as much as possible, potentially
+  ;;; truncating the last directory entry. This allows the caller to grow its
+  ;;; read buffer size in case it's too small to fit a single large directory
+  ;;; entry, or skip the oversized directory entry.
+  (@interface func (export "fd_readdir")
+    (param $fd $fd)
+    ;;; The buffer where directory entries are stored
+    (param $buf (@witx pointer u8))
+    (param $buf_len $size)
+    ;;; The location within the directory to start reading
+    (param $cookie $dircookie)
+    ;;; The number of bytes stored in the read buffer. If less than the size of the read buffer, the end of the directory has been reached.
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Atomically replace a file descriptor by renumbering another file descriptor.
+  ;;
+  ;;; Due to the strong focus on thread safety, this environment does not provide
+  ;;; a mechanism to duplicate or renumber a file descriptor to an arbitrary
+  ;;; number, like `dup2()`. This would be prone to race conditions, as an actual
+  ;;; file descriptor with the same number could be allocated by a different
+  ;;; thread at the same time.
+  ;;
+  ;;; This function provides a way to atomically renumber file descriptors, which
+  ;;; would disappear if `dup2()` were to be removed entirely.
+  (@interface func (export "fd_renumber")
+    (param $fd $fd)
+    ;;; The file descriptor to overwrite.
+    (param $to $fd)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Move the offset of a file descriptor.
+  ;;; Note: This is similar to `lseek` in POSIX.
+  (@interface func (export "fd_seek")
+    (param $fd $fd)
+    ;;; The number of bytes to move.
+    (param $offset $filedelta)
+    ;;; The base from which the offset is relative.
+    (param $whence $whence)
+    ;;; The new offset of the file descriptor, relative to the start of the file.
+    (result $error (expected $filesize (error $errno)))
+  )
+
+  ;;; Synchronize the data and metadata of a file to disk.
+  ;;; Note: This is similar to `fsync` in POSIX.
+  (@interface func (export "fd_sync")
+    (param $fd $fd)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Return the current offset of a file descriptor.
+  ;;; Note: This is similar to `lseek(fd, 0, SEEK_CUR)` in POSIX.
+  (@interface func (export "fd_tell")
+    (param $fd $fd)
+    ;;; The current offset of the file descriptor, relative to the start of the file.
+    (result $error (expected $filesize (error $errno)))
+  )
+
+  ;;; Write to a file descriptor.
+  ;;; Note: This is similar to `writev` in POSIX.
+  (@interface func (export "fd_write")
+    (param $fd $fd)
+    ;;; List of scatter/gather vectors from which to retrieve data.
+    (param $iovs $ciovec_array)
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Create a directory.
+  ;;; Note: This is similar to `mkdirat` in POSIX.
+  (@interface func (export "path_create_directory")
+    (param $fd $fd)
+    ;;; The path at which to create the directory.
+    (param $path string)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Return the attributes of a file or directory.
+  ;;; Note: This is similar to `stat` in POSIX.
+  (@interface func (export "path_filestat_get")
+    (param $fd $fd)
+    ;;; Flags determining the method of how the path is resolved.
+    (param $flags $lookupflags)
+    ;;; The path of the file or directory to inspect.
+    (param $path string)
+    ;;; The buffer where the file's attributes are stored.
+    (result $error (expected $filestat (error $errno)))
+  )
+
+  ;;; Adjust the timestamps of a file or directory.
+  ;;; Note: This is similar to `utimensat` in POSIX.
+  (@interface func (export "path_filestat_set_times")
+    (param $fd $fd)
+    ;;; Flags determining the method of how the path is resolved.
+    (param $flags $lookupflags)
+    ;;; The path of the file or directory to operate on.
+    (param $path string)
+    ;;; The desired values of the data access timestamp.
+    (param $atim $timestamp)
+    ;;; The desired values of the data modification timestamp.
+    (param $mtim $timestamp)
+    ;;; A bitmask indicating which timestamps to adjust.
+    (param $fst_flags $fstflags)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Create a hard link.
+  ;;; Note: This is similar to `linkat` in POSIX.
+  (@interface func (export "path_link")
+    (param $old_fd $fd)
+    ;;; Flags determining the method of how the path is resolved.
+    (param $old_flags $lookupflags)
+    ;;; The source path from which to link.
+    (param $old_path string)
+    ;;; The working directory at which the resolution of the new path starts.
+    (param $new_fd $fd)
+    ;;; The destination path at which to create the hard link.
+    (param $new_path string)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Open a file or directory.
+  ;;
+  ;;; The returned file descriptor is not guaranteed to be the lowest-numbered
+  ;;; file descriptor not currently open; it is randomized to prevent
+  ;;; applications from depending on making assumptions about indexes, since this
+  ;;; is error-prone in multi-threaded contexts. The returned file descriptor is
+  ;;; guaranteed to be less than 2**31.
+  ;;
+  ;;; Note: This is similar to `openat` in POSIX.
+  (@interface func (export "path_open")
+    (param $fd $fd)
+    ;;; Flags determining the method of how the path is resolved.
+    (param $dirflags $lookupflags)
+    ;;; The relative path of the file or directory to open, relative to the
+    ;;; `path_open::fd` directory.
+    (param $path string)
+    ;;; The method by which to open the file.
+    (param $oflags $oflags)
+    ;;; The initial rights of the newly created file descriptor. The
+    ;;; implementation is allowed to return a file descriptor with fewer rights
+    ;;; than specified, if and only if those rights do not apply to the type of
+    ;;; file being opened.
+    ;;
+    ;;; The *base* rights are rights that will apply to operations using the file
+    ;;; descriptor itself, while the *inheriting* rights are rights that apply to
+    ;;; file descriptors derived from it.
+    (param $fs_rights_base $rights)
+    (param $fs_rights_inheriting $rights)
+    (param $fdflags $fdflags)
+    ;;; The file descriptor of the file that has been opened.
+    (result $error (expected $fd (error $errno)))
+  )
+
+  ;;; Read the contents of a symbolic link.
+  ;;; Note: This is similar to `readlinkat` in POSIX.
+  (@interface func (export "path_readlink")
+    (param $fd $fd)
+    ;;; The path of the symbolic link from which to read.
+    (param $path string)
+    ;;; The buffer to which to write the contents of the symbolic link.
+    (param $buf (@witx pointer u8))
+    (param $buf_len $size)
+    ;;; The number of bytes placed in the buffer.
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Remove a directory.
+  ;;; Return `errno::notempty` if the directory is not empty.
+  ;;; Note: This is similar to `unlinkat(fd, path, AT_REMOVEDIR)` in POSIX.
+  (@interface func (export "path_remove_directory")
+    (param $fd $fd)
+    ;;; The path to a directory to remove.
+    (param $path string)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Rename a file or directory.
+  ;;; Note: This is similar to `renameat` in POSIX.
+  (@interface func (export "path_rename")
+    (param $fd $fd)
+    ;;; The source path of the file or directory to rename.
+    (param $old_path string)
+    ;;; The working directory at which the resolution of the new path starts.
+    (param $new_fd $fd)
+    ;;; The destination path to which to rename the file or directory.
+    (param $new_path string)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Create a symbolic link.
+  ;;; Note: This is similar to `symlinkat` in POSIX.
+  (@interface func (export "path_symlink")
+    ;;; The contents of the symbolic link.
+    (param $old_path string)
+    (param $fd $fd)
+    ;;; The destination path at which to create the symbolic link.
+    (param $new_path string)
+    (result $error (expected (error $errno)))
+  )
+
+
+  ;;; Unlink a file.
+  ;;; Return `errno::isdir` if the path refers to a directory.
+  ;;; Note: This is similar to `unlinkat(fd, path, 0)` in POSIX.
+  (@interface func (export "path_unlink_file")
+    (param $fd $fd)
+    ;;; The path to a file to unlink.
+    (param $path string)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Concurrently poll for the occurrence of a set of events.
+  (@interface func (export "poll_oneoff")
+    ;;; The events to which to subscribe.
+    (param $in (@witx const_pointer $subscription))
+    ;;; The events that have occurred.
+    (param $out (@witx pointer $event))
+    ;;; Both the number of subscriptions and events.
+    (param $nsubscriptions $size)
+    ;;; The number of events stored.
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Terminate the process normally. An exit code of 0 indicates successful
+  ;;; termination of the program. The meanings of other values is dependent on
+  ;;; the environment.
+  (@interface func (export "proc_exit")
+    ;;; The exit code returned by the process.
+    (param $rval $exitcode)
+    (@witx noreturn)
+  )
+
+  ;;; Send a signal to the process of the calling thread.
+  ;;; Note: This is similar to `raise` in POSIX.
+  (@interface func (export "proc_raise")
+    ;;; The signal condition to trigger.
+    (param $sig $signal)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Temporarily yield execution of the calling thread.
+  ;;; Note: This is similar to `sched_yield` in POSIX.
+  (@interface func (export "sched_yield")
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Write high-quality random data into a buffer.
+  ;;; This function blocks when the implementation is unable to immediately
+  ;;; provide sufficient high-quality random data.
+  ;;; This function may execute slowly, so when large mounts of random data are
+  ;;; required, it's advisable to use this function to seed a pseudo-random
+  ;;; number generator, rather than to provide the random data directly.
+  (@interface func (export "random_get")
+    ;;; The buffer to fill with random data.
+    (param $buf (@witx pointer u8))
+    (param $buf_len $size)
+    (result $error (expected (error $errno)))
+  )
+
+  ;;; Accept a new incoming connection.
+  ;;; Note: This is similar to `accept` in POSIX.
+  (@interface func (export "sock_accept")
+    ;;; The listening socket.
+    (param $fd $fd)
+    ;;; The desired values of the file descriptor flags.
+    (param $flags $fdflags)
+    ;;; New socket connection
+    (result $error (expected $fd (error $errno)))
+  )
+
+  ;;; Receive a message from a socket.
+  ;;; Note: This is similar to `recv` in POSIX, though it also supports reading
+  ;;; the data into multiple buffers in the manner of `readv`.
+  (@interface func (export "sock_recv")
+    (param $fd $fd)
+    ;;; List of scatter/gather vectors to which to store data.
+    (param $ri_data $iovec_array)
+    ;;; Message flags.
+    (param $ri_flags $riflags)
+    ;;; Number of bytes stored in ri_data and message flags.
+    (result $error (expected (tuple $size $roflags) (error $errno)))
+  )
+
+  ;;; Send a message on a socket.
+  ;;; Note: This is similar to `send` in POSIX, though it also supports writing
+  ;;; the data from multiple buffers in the manner of `writev`.
+  (@interface func (export "sock_send")
+    (param $fd $fd)
+    ;;; List of scatter/gather vectors to which to retrieve data
+    (param $si_data $ciovec_array)
+    ;;; Message flags.
+    (param $si_flags $siflags)
+    ;;; Number of bytes transmitted.
+    (result $error (expected $size (error $errno)))
+  )
+
+  ;;; Shut down socket send and receive channels.
+  ;;; Note: This is similar to `shutdown` in POSIX.
+  (@interface func (export "sock_shutdown")
+    (param $fd $fd)
+    ;;; Which channels on the socket to shut down.
+    (param $how $sdflags)
+    (result $error (expected (error $errno)))
+  )
+)
diff --git a/crates/wasi/witx/typenames.witx b/crates/wasi/witx/typenames.witx
deleted file mode 100644
index 893e5b288541..000000000000
--- a/crates/wasi/witx/typenames.witx
+++ /dev/null
@@ -1,750 +0,0 @@
-;; Type names used by low-level WASI interfaces.
-;;
-;; Some content here is derived from [CloudABI](https://github.com/NuxiNL/cloudabi).
-;;
-;; This is a `witx` file. See [here](https://github.com/WebAssembly/WASI/tree/master/docs/witx.md)
-;; for an explanation of what that means.
-
-(typename $size u32)
-
-;;; Non-negative file size or length of a region within a file.
-(typename $filesize u64)
-
-;;; Timestamp in nanoseconds.
-(typename $timestamp u64)
-
-;;; Identifiers for clocks.
-(typename $clockid
-  (enum (@witx tag u32)
-    ;;; The clock measuring real time. Time value zero corresponds with
-    ;;; 1970-01-01T00:00:00Z.
-    $realtime
-    ;;; The store-wide monotonic clock, which is defined as a clock measuring
-    ;;; real time, whose value cannot be adjusted and which cannot have negative
-    ;;; clock jumps. The epoch of this clock is undefined. The absolute time
-    ;;; value of this clock therefore has no meaning.
-    $monotonic
-    ;;; The CPU-time clock associated with the current process.
-    $process_cputime_id
-    ;;; The CPU-time clock associated with the current thread.
-    $thread_cputime_id
-  )
-)
-
-;;; Error codes returned by functions.
-;;; Not all of these error codes are returned by the functions provided by this
-;;; API; some are used in higher-level library layers, and others are provided
-;;; merely for alignment with POSIX.
-(typename $errno
-  (enum (@witx tag u16)
-    ;;; No error occurred. System call completed successfully.
-    $success
-    ;;; Argument list too long.
-    $2big
-    ;;; Permission denied.
-    $acces
-    ;;; Address in use.
-    $addrinuse
-    ;;; Address not available.
-    $addrnotavail
-    ;;; Address family not supported.
-    $afnosupport
-    ;;; Resource unavailable, or operation would block.
-    $again
-    ;;; Connection already in progress.
-    $already
-    ;;; Bad file descriptor.
-    $badf
-    ;;; Bad message.
-    $badmsg
-    ;;; Device or resource busy.
-    $busy
-    ;;; Operation canceled.
-    $canceled
-    ;;; No child processes.
-    $child
-    ;;; Connection aborted.
-    $connaborted
-    ;;; Connection refused.
-    $connrefused
-    ;;; Connection reset.
-    $connreset
-    ;;; Resource deadlock would occur.
-    $deadlk
-    ;;; Destination address required.
-    $destaddrreq
-    ;;; Mathematics argument out of domain of function.
-    $dom
-    ;;; Reserved.
-    $dquot
-    ;;; File exists.
-    $exist
-    ;;; Bad address.
-    $fault
-    ;;; File too large.
-    $fbig
-    ;;; Host is unreachable.
-    $hostunreach
-    ;;; Identifier removed.
-    $idrm
-    ;;; Illegal byte sequence.
-    $ilseq
-    ;;; Operation in progress.
-    $inprogress
-    ;;; Interrupted function.
-    $intr
-    ;;; Invalid argument.
-    $inval
-    ;;; I/O error.
-    $io
-    ;;; Socket is connected.
-    $isconn
-    ;;; Is a directory.
-    $isdir
-    ;;; Too many levels of symbolic links.
-    $loop
-    ;;; File descriptor value too large.
-    $mfile
-    ;;; Too many links.
-    $mlink
-    ;;; Message too large.
-    $msgsize
-    ;;; Reserved.
-    $multihop
-    ;;; Filename too long.
-    $nametoolong
-    ;;; Network is down.
-    $netdown
-    ;;; Connection aborted by network.
-    $netreset
-    ;;; Network unreachable.
-    $netunreach
-    ;;; Too many files open in system.
-    $nfile
-    ;;; No buffer space available.
-    $nobufs
-    ;;; No such device.
-    $nodev
-    ;;; No such file or directory.
-    $noent
-    ;;; Executable file format error.
-    $noexec
-    ;;; No locks available.
-    $nolck
-    ;;; Reserved.
-    $nolink
-    ;;; Not enough space.
-    $nomem
-    ;;; No message of the desired type.
-    $nomsg
-    ;;; Protocol not available.
-    $noprotoopt
-    ;;; No space left on device.
-    $nospc
-    ;;; Function not supported.
-    $nosys
-    ;;; The socket is not connected.
-    $notconn
-    ;;; Not a directory or a symbolic link to a directory.
-    $notdir
-    ;;; Directory not empty.
-    $notempty
-    ;;; State not recoverable.
-    $notrecoverable
-    ;;; Not a socket.
-    $notsock
-    ;;; Not supported, or operation not supported on socket.
-    $notsup
-    ;;; Inappropriate I/O control operation.
-    $notty
-    ;;; No such device or address.
-    $nxio
-    ;;; Value too large to be stored in data type.
-    $overflow
-    ;;; Previous owner died.
-    $ownerdead
-    ;;; Operation not permitted.
-    $perm
-    ;;; Broken pipe.
-    $pipe
-    ;;; Protocol error.
-    $proto
-    ;;; Protocol not supported.
-    $protonosupport
-    ;;; Protocol wrong type for socket.
-    $prototype
-    ;;; Result too large.
-    $range
-    ;;; Read-only file system.
-    $rofs
-    ;;; Invalid seek.
-    $spipe
-    ;;; No such process.
-    $srch
-    ;;; Reserved.
-    $stale
-    ;;; Connection timed out.
-    $timedout
-    ;;; Text file busy.
-    $txtbsy
-    ;;; Cross-device link.
-    $xdev
-    ;;; Extension: Capabilities insufficient.
-    $notcapable
-  )
-)
-
-;;; File descriptor rights, determining which actions may be performed.
-(typename $rights
-  (flags (@witx repr u64)
-    ;;; The right to invoke `fd_datasync`.
-    ;;
-    ;;; If `path_open` is set, includes the right to invoke
-    ;;; `path_open` with `fdflags::dsync`.
-    $fd_datasync
-    ;;; The right to invoke `fd_read` and `sock_recv`.
-    ;;
-    ;;; If `rights::fd_seek` is set, includes the right to invoke `fd_pread`.
-    $fd_read
-    ;;; The right to invoke `fd_seek`. This flag implies `rights::fd_tell`.
-    $fd_seek
-    ;;; The right to invoke `fd_fdstat_set_flags`.
-    $fd_fdstat_set_flags
-    ;;; The right to invoke `fd_sync`.
-    ;;
-    ;;; If `path_open` is set, includes the right to invoke
-    ;;; `path_open` with `fdflags::rsync` and `fdflags::dsync`.
-    $fd_sync
-    ;;; The right to invoke `fd_seek` in such a way that the file offset
-    ;;; remains unaltered (i.e., `whence::cur` with offset zero), or to
-    ;;; invoke `fd_tell`.
-    $fd_tell
-    ;;; The right to invoke `fd_write` and `sock_send`.
-    ;;; If `rights::fd_seek` is set, includes the right to invoke `fd_pwrite`.
-    $fd_write
-    ;;; The right to invoke `fd_advise`.
-    $fd_advise
-    ;;; The right to invoke `fd_allocate`.
-    $fd_allocate
-    ;;; The right to invoke `path_create_directory`.
-    $path_create_directory
-    ;;; If `path_open` is set, the right to invoke `path_open` with `oflags::creat`.
-    $path_create_file
-    ;;; The right to invoke `path_link` with the file descriptor as the
-    ;;; source directory.
-    $path_link_source
-    ;;; The right to invoke `path_link` with the file descriptor as the
-    ;;; target directory.
-    $path_link_target
-    ;;; The right to invoke `path_open`.
-    $path_open
-    ;;; The right to invoke `fd_readdir`.
-    $fd_readdir
-    ;;; The right to invoke `path_readlink`.
-    $path_readlink
-    ;;; The right to invoke `path_rename` with the file descriptor as the source directory.
-    $path_rename_source
-    ;;; The right to invoke `path_rename` with the file descriptor as the target directory.
-    $path_rename_target
-    ;;; The right to invoke `path_filestat_get`.
-    $path_filestat_get
-    ;;; The right to change a file's size (there is no `path_filestat_set_size`).
-    ;;; If `path_open` is set, includes the right to invoke `path_open` with `oflags::trunc`.
-    $path_filestat_set_size
-    ;;; The right to invoke `path_filestat_set_times`.
-    $path_filestat_set_times
-    ;;; The right to invoke `fd_filestat_get`.
-    $fd_filestat_get
-    ;;; The right to invoke `fd_filestat_set_size`.
-    $fd_filestat_set_size
-    ;;; The right to invoke `fd_filestat_set_times`.
-    $fd_filestat_set_times
-    ;;; The right to invoke `path_symlink`.
-    $path_symlink
-    ;;; The right to invoke `path_remove_directory`.
-    $path_remove_directory
-    ;;; The right to invoke `path_unlink_file`.
-    $path_unlink_file
-    ;;; If `rights::fd_read` is set, includes the right to invoke `poll_oneoff` to subscribe to `eventtype::fd_read`.
-    ;;; If `rights::fd_write` is set, includes the right to invoke `poll_oneoff` to subscribe to `eventtype::fd_write`.
-    $poll_fd_readwrite
-    ;;; The right to invoke `sock_shutdown`.
-    $sock_shutdown
-    ;;; The right to invoke `sock_accept`.
-    $sock_accept
-  )
-)
-
-;;; A file descriptor handle.
-(typename $fd (handle))
-
-;;; A region of memory for scatter/gather reads.
-(typename $iovec
-  (record
-    ;;; The address of the buffer to be filled.
-    (field $buf (@witx pointer u8))
-    ;;; The length of the buffer to be filled.
-    (field $buf_len $size)
-  )
-)
-
-;;; A region of memory for scatter/gather writes.
-(typename $ciovec
-  (record
-    ;;; The address of the buffer to be written.
-    (field $buf (@witx const_pointer u8))
-    ;;; The length of the buffer to be written.
-    (field $buf_len $size)
-  )
-)
-
-(typename $iovec_array (list $iovec))
-(typename $ciovec_array (list $ciovec))
-
-;;; Relative offset within a file.
-(typename $filedelta s64)
-
-;;; The position relative to which to set the offset of the file descriptor.
-(typename $whence
-  (enum (@witx tag u8)
-    ;;; Seek relative to start-of-file.
-    $set
-    ;;; Seek relative to current position.
-    $cur
-    ;;; Seek relative to end-of-file.
-    $end
-  )
-)
-
-;;; A reference to the offset of a directory entry.
-;;;
-;;; The value 0 signifies the start of the directory.
-(typename $dircookie u64)
-
-;;; The type for the `dirent::d_namlen` field of `dirent` struct.
-(typename $dirnamlen u32)
-
-;;; File serial number that is unique within its file system.
-(typename $inode u64)
-
-;;; The type of a file descriptor or file.
-(typename $filetype
-  (enum (@witx tag u8)
-    ;;; The type of the file descriptor or file is unknown or is different from any of the other types specified.
-    $unknown
-    ;;; The file descriptor or file refers to a block device inode.
-    $block_device
-    ;;; The file descriptor or file refers to a character device inode.
-    $character_device
-    ;;; The file descriptor or file refers to a directory inode.
-    $directory
-    ;;; The file descriptor or file refers to a regular file inode.
-    $regular_file
-    ;;; The file descriptor or file refers to a datagram socket.
-    $socket_dgram
-    ;;; The file descriptor or file refers to a byte-stream socket.
-    $socket_stream
-    ;;; The file refers to a symbolic link inode.
-    $symbolic_link
-  )
-)
-
-;;; A directory entry.
-(typename $dirent
-  (record
-    ;;; The offset of the next directory entry stored in this directory.
-    (field $d_next $dircookie)
-    ;;; The serial number of the file referred to by this directory entry.
-    (field $d_ino $inode)
-    ;;; The length of the name of the directory entry.
-    (field $d_namlen $dirnamlen)
-    ;;; The type of the file referred to by this directory entry.
-    (field $d_type $filetype)
-  )
-)
-
-;;; File or memory access pattern advisory information.
-(typename $advice
-  (enum (@witx tag u8)
-    ;;; The application has no advice to give on its behavior with respect to the specified data.
-    $normal
-    ;;; The application expects to access the specified data sequentially from lower offsets to higher offsets.
-    $sequential
-    ;;; The application expects to access the specified data in a random order.
-    $random
-    ;;; The application expects to access the specified data in the near future.
-    $willneed
-    ;;; The application expects that it will not access the specified data in the near future.
-    $dontneed
-    ;;; The application expects to access the specified data once and then not reuse it thereafter.
-    $noreuse
-  )
-)
-
-;;; File descriptor flags.
-(typename $fdflags
-  (flags (@witx repr u16)
-    ;;; Append mode: Data written to the file is always appended to the file's end.
-    $append
-    ;;; Write according to synchronized I/O data integrity completion. Only the data stored in the file is synchronized.
-    $dsync
-    ;;; Non-blocking mode.
-    $nonblock
-    ;;; Synchronized read I/O operations.
-    $rsync
-    ;;; Write according to synchronized I/O file integrity completion. In
-    ;;; addition to synchronizing the data stored in the file, the implementation
-    ;;; may also synchronously update the file's metadata.
-    $sync
-  )
-)
-
-;;; File descriptor attributes.
-(typename $fdstat
-  (record
-    ;;; File type.
-    (field $fs_filetype $filetype)
-    ;;; File descriptor flags.
-    (field $fs_flags $fdflags)
-    ;;; Rights that apply to this file descriptor.
-    (field $fs_rights_base $rights)
-    ;;; Maximum set of rights that may be installed on new file descriptors that
-    ;;; are created through this file descriptor, e.g., through `path_open`.
-    (field $fs_rights_inheriting $rights)
-  )
-)
-
-;;; Identifier for a device containing a file system. Can be used in combination
-;;; with `inode` to uniquely identify a file or directory in the filesystem.
-(typename $device u64)
-
-;;; Which file time attributes to adjust.
-(typename $fstflags
-  (flags (@witx repr u16)
-    ;;; Adjust the last data access timestamp to the value stored in `filestat::atim`.
-    $atim
-    ;;; Adjust the last data access timestamp to the time of clock `clockid::realtime`.
-    $atim_now
-    ;;; Adjust the last data modification timestamp to the value stored in `filestat::mtim`.
-    $mtim
-    ;;; Adjust the last data modification timestamp to the time of clock `clockid::realtime`.
-    $mtim_now
-  )
-)
-
-;;; Flags determining the method of how paths are resolved.
-(typename $lookupflags
-  (flags (@witx repr u32)
-    ;;; As long as the resolved path corresponds to a symbolic link, it is expanded.
-    $symlink_follow
-  )
-)
-
-;;; Open flags used by `path_open`.
-(typename $oflags
-  (flags (@witx repr u16)
-    ;;; Create file if it does not exist.
-    $creat
-    ;;; Fail if not a directory.
-    $directory
-    ;;; Fail if file already exists.
-    $excl
-    ;;; Truncate file to size 0.
-    $trunc
-  )
-)
-
-;;; Number of hard links to an inode.
-(typename $linkcount u64)
-
-;;; File attributes.
-(typename $filestat
-  (record
-    ;;; Device ID of device containing the file.
-    (field $dev $device)
-    ;;; File serial number.
-    (field $ino $inode)
-    ;;; File type.
-    (field $filetype $filetype)
-    ;;; Number of hard links to the file.
-    (field $nlink $linkcount)
-    ;;; For regular files, the file size in bytes. For symbolic links, the length in bytes of the pathname contained in the symbolic link.
-    (field $size $filesize)
-    ;;; Last data access timestamp.
-    (field $atim $timestamp)
-    ;;; Last data modification timestamp.
-    (field $mtim $timestamp)
-    ;;; Last file status change timestamp.
-    (field $ctim $timestamp)
-  )
-)
-
-;;; User-provided value that may be attached to objects that is retained when
-;;; extracted from the implementation.
-(typename $userdata u64)
-
-;;; Type of a subscription to an event or its occurrence.
-(typename $eventtype
-  (enum (@witx tag u8)
-    ;;; The time value of clock `subscription_clock::id` has
-    ;;; reached timestamp `subscription_clock::timeout`.
-    $clock
-    ;;; File descriptor `subscription_fd_readwrite::file_descriptor` has data
-    ;;; available for reading. This event always triggers for regular files.
-    $fd_read
-    ;;; File descriptor `subscription_fd_readwrite::file_descriptor` has capacity
-    ;;; available for writing. This event always triggers for regular files.
-    $fd_write
-  )
-)
-
-;;; The state of the file descriptor subscribed to with
-;;; `eventtype::fd_read` or `eventtype::fd_write`.
-(typename $eventrwflags
-  (flags (@witx repr u16)
-    ;;; The peer of this socket has closed or disconnected.
-    $fd_readwrite_hangup
-  )
-)
-
-;;; The contents of an `event` when type is `eventtype::fd_read` or
-;;; `eventtype::fd_write`.
-(typename $event_fd_readwrite
-  (record
-    ;;; The number of bytes available for reading or writing.
-    (field $nbytes $filesize)
-    ;;; The state of the file descriptor.
-    (field $flags $eventrwflags)
-  )
-)
-
-;;; An event that occurred.
-(typename $event
-  (record
-    ;;; User-provided value that got attached to `subscription::userdata`.
-    (field $userdata $userdata)
-    ;;; If non-zero, an error that occurred while processing the subscription request.
-    (field $error $errno)
-    ;;; The type of event that occured
-    (field $type $eventtype)
-    ;;; The contents of the event, if it is an `eventtype::fd_read` or
-    ;;; `eventtype::fd_write`. `eventtype::clock` events ignore this field.
-    (field $fd_readwrite $event_fd_readwrite)
-  )
-)
-
-;;; Flags determining how to interpret the timestamp provided in
-;;; `subscription_clock::timeout`.
-(typename $subclockflags
-  (flags (@witx repr u16)
-    ;;; If set, treat the timestamp provided in
-    ;;; `subscription_clock::timeout` as an absolute timestamp of clock
-    ;;; `subscription_clock::id`. If clear, treat the timestamp
-    ;;; provided in `subscription_clock::timeout` relative to the
-    ;;; current time value of clock `subscription_clock::id`.
-    $subscription_clock_abstime
-  )
-)
-
-;;; The contents of a `subscription` when type is `eventtype::clock`.
-(typename $subscription_clock
-  (record
-    ;;; The clock against which to compare the timestamp.
-    (field $id $clockid)
-    ;;; The absolute or relative timestamp.
-    (field $timeout $timestamp)
-    ;;; The amount of time that the implementation may wait additionally
-    ;;; to coalesce with other events.
-    (field $precision $timestamp)
-    ;;; Flags specifying whether the timeout is absolute or relative
-    (field $flags $subclockflags)
-  )
-)
-
-;;; The contents of a `subscription` when type is type is
-;;; `eventtype::fd_read` or `eventtype::fd_write`.
-(typename $subscription_fd_readwrite
-  (record
-    ;;; The file descriptor on which to wait for it to become ready for reading or writing.
-    (field $file_descriptor $fd)
-  )
-)
-
-;;; The contents of a `subscription`.
-(typename $subscription_u
-  (union
-    (@witx tag $eventtype)
-    $subscription_clock
-    $subscription_fd_readwrite
-    $subscription_fd_readwrite
-  )
-)
-
-;;; Subscription to an event.
-(typename $subscription
-  (record
-    ;;; User-provided value that is attached to the subscription in the
-    ;;; implementation and returned through `event::userdata`.
-    (field $userdata $userdata)
-    ;;; The type of the event to which to subscribe, and its contents
-    (field $u $subscription_u)
-  )
-)
-
-;;; Exit code generated by a process when exiting.
-(typename $exitcode u32)
-
-;;; Signal condition.
-(typename $signal
-  (enum (@witx tag u8)
-    ;;; No signal. Note that POSIX has special semantics for `kill(pid, 0)`,
-    ;;; so this value is reserved.
-    $none
-    ;;; Hangup.
-    ;;; Action: Terminates the process.
-    $hup
-    ;;; Terminate interrupt signal.
-    ;;; Action: Terminates the process.
-    $int
-    ;;; Terminal quit signal.
-    ;;; Action: Terminates the process.
-    $quit
-    ;;; Illegal instruction.
-    ;;; Action: Terminates the process.
-    $ill
-    ;;; Trace/breakpoint trap.
-    ;;; Action: Terminates the process.
-    $trap
-    ;;; Process abort signal.
-    ;;; Action: Terminates the process.
-    $abrt
-    ;;; Access to an undefined portion of a memory object.
-    ;;; Action: Terminates the process.
-    $bus
-    ;;; Erroneous arithmetic operation.
-    ;;; Action: Terminates the process.
-    $fpe
-    ;;; Kill.
-    ;;; Action: Terminates the process.
-    $kill
-    ;;; User-defined signal 1.
-    ;;; Action: Terminates the process.
-    $usr1
-    ;;; Invalid memory reference.
-    ;;; Action: Terminates the process.
-    $segv
-    ;;; User-defined signal 2.
-    ;;; Action: Terminates the process.
-    $usr2
-    ;;; Write on a pipe with no one to read it.
-    ;;; Action: Ignored.
-    $pipe
-    ;;; Alarm clock.
-    ;;; Action: Terminates the process.
-    $alrm
-    ;;; Termination signal.
-    ;;; Action: Terminates the process.
-    $term
-    ;;; Child process terminated, stopped, or continued.
-    ;;; Action: Ignored.
-    $chld
-    ;;; Continue executing, if stopped.
-    ;;; Action: Continues executing, if stopped.
-    $cont
-    ;;; Stop executing.
-    ;;; Action: Stops executing.
-    $stop
-    ;;; Terminal stop signal.
-    ;;; Action: Stops executing.
-    $tstp
-    ;;; Background process attempting read.
-    ;;; Action: Stops executing.
-    $ttin
-    ;;; Background process attempting write.
-    ;;; Action: Stops executing.
-    $ttou
-    ;;; High bandwidth data is available at a socket.
-    ;;; Action: Ignored.
-    $urg
-    ;;; CPU time limit exceeded.
-    ;;; Action: Terminates the process.
-    $xcpu
-    ;;; File size limit exceeded.
-    ;;; Action: Terminates the process.
-    $xfsz
-    ;;; Virtual timer expired.
-    ;;; Action: Terminates the process.
-    $vtalrm
-    ;;; Profiling timer expired.
-    ;;; Action: Terminates the process.
-    $prof
-    ;;; Window changed.
-    ;;; Action: Ignored.
-    $winch
-    ;;; I/O possible.
-    ;;; Action: Terminates the process.
-    $poll
-    ;;; Power failure.
-    ;;; Action: Terminates the process.
-    $pwr
-    ;;; Bad system call.
-    ;;; Action: Terminates the process.
-    $sys
-  )
-)
-
-;;; Flags provided to `sock_recv`.
-(typename $riflags
-  (flags (@witx repr u16)
-    ;;; Returns the message without removing it from the socket's receive queue.
-    $recv_peek
-    ;;; On byte-stream sockets, block until the full amount of data can be returned.
-    $recv_waitall
-  )
-)
-
-;;; Flags returned by `sock_recv`.
-(typename $roflags
-  (flags (@witx repr u16)
-    ;;; Returned by `sock_recv`: Message data has been truncated.
-    $recv_data_truncated
-  )
-)
-
-;;; Flags provided to `sock_send`. As there are currently no flags
-;;; defined, it must be set to zero.
-(typename $siflags u16)
-
-;;; Which channels on a socket to shut down.
-(typename $sdflags
-  (flags (@witx repr u8)
-    ;;; Disables further receive operations.
-    $rd
-    ;;; Disables further send operations.
-    $wr
-  )
-)
-
-;;; Identifiers for preopened capabilities.
-(typename $preopentype
-  (enum (@witx tag u8)
-    ;;; A pre-opened directory.
-    $dir
-  )
-)
-
-;;; The contents of a $prestat when type is `preopentype::dir`.
-(typename $prestat_dir
-  (record
-    ;;; The length of the directory name for use with `fd_prestat_dir_name`.
-    (field $pr_name_len $size)
-  )
-)
-
-;;; Information about a pre-opened capability.
-(typename $prestat
-  (union (@witx tag $preopentype)
-    $prestat_dir
-  )
-)
-
diff --git a/crates/wasmtime/Cargo.toml b/crates/wasmtime/Cargo.toml
index d735b74b6feb..7eff216cb081 100644
--- a/crates/wasmtime/Cargo.toml
+++ b/crates/wasmtime/Cargo.toml
@@ -10,35 +10,39 @@ readme = "README.md"
 edition.workspace = true
 rust-version.workspace = true
 
+[lints]
+workspace = true
+
 [package.metadata.docs.rs]
-rustdoc-args = ["--cfg", "nightlydoc"]
-# Docs.rs will use the `component-model` feature for documentation;
-# so this feature also passed in to the `cargo doc` invocation in CI.
-# See .github/workflows/main.yml
-features = ["component-model"]
+all-features = true
 
 [dependencies]
-wasmtime-runtime = { workspace = true }
+wasmtime-asm-macros = { workspace = true, optional = true }
 wasmtime-environ = { workspace = true }
-wasmtime-jit = { workspace = true }
+wasmtime-jit-debug = { workspace = true, features = ["gdb_jit_int", "perf_jitdump"], optional = true }
+wasmtime-jit-icache-coherence = { workspace = true, optional = true }
 wasmtime-cache = { workspace = true, optional = true }
 wasmtime-fiber = { workspace = true, optional = true }
 wasmtime-cranelift = { workspace = true, optional = true }
 wasmtime-winch = { workspace = true, optional = true }
 wasmtime-component-macro = { workspace = true, optional = true }
 wasmtime-component-util = { workspace = true, optional = true }
+wasmtime-slab = { workspace = true, optional = true }
+wasmtime-versioned-export-macros = { workspace = true }
+wasmtime-wmemcheck = { workspace = true, optional = true }
 target-lexicon = { workspace = true }
 wasmparser = { workspace = true }
-wasm-encoder = { workspace = true }
+wasm-encoder = { workspace = true, optional = true }
 anyhow = { workspace = true }
-libc = "0.2"
+libc = { workspace = true }
 cfg-if = { workspace = true }
 log = { workspace = true }
 wat = { workspace = true, optional = true }
-serde = "1.0.188"
-serde_derive = "1.0.188"
-serde_json = { workspace = true }
-bincode = "1.2.1"
+serde = { workspace = true }
+serde_derive = { workspace = true }
+serde_json = { workspace = true, optional = true }
+sptr = { workspace = true }
+postcard = { workspace = true }
 indexmap = { workspace = true }
 paste = "1.0.3"
 once_cell = { workspace = true }
@@ -47,79 +51,131 @@ object = { workspace = true }
 async-trait = { workspace = true, optional = true }
 encoding_rs = { version = "0.8.31", optional = true }
 bumpalo = "3.11.0"
-fxprof-processed-profile = "0.6.0"
+fxprof-processed-profile = { version = "0.6.0", optional = true }
+gimli = { workspace = true, optional = true }
+addr2line = { workspace = true, optional = true }
+semver = { workspace = true, optional = true }
+smallvec = { workspace = true, optional = true }
+hashbrown = { workspace = true }
+libm = "0.2.7"
+bitflags = { workspace = true }
 
 [target.'cfg(target_os = "windows")'.dependencies.windows-sys]
 workspace = true
+optional = true
 features = [
+  "Win32_Foundation",
+  "Win32_System_Kernel",
+  "Win32_System_Memory",
   "Win32_System_Diagnostics_Debug",
+  "Win32_System_SystemInformation",
+  "Win32_Storage_FileSystem",
+  "Win32_Security",
 ]
 
+[target.'cfg(all(target_arch = "x86_64", not(target_os = "android")))'.dependencies]
+ittapi = { version = "0.4.0", optional = true }
+
+[target.'cfg(target_os = "linux")'.dependencies]
+memfd = { workspace = true, optional = true }
+
+[target.'cfg(target_os = "macos")'.dependencies]
+mach2 = { workspace = true, optional = true }
+
+[target.'cfg(unix)'.dependencies]
+rustix = { workspace = true, optional = true }
+
 [target.'cfg(target_arch = "s390x")'.dependencies]
-psm = "0.1.11"
+psm = { workspace = true, optional = true }
 
 [dev-dependencies]
-tempfile = "3.0"
-wasmtime-wasi = { path = "../wasi", default-features = true }
-wasi-cap-std-sync = { path = "../wasi-common/cap-std-sync" }
+env_logger = { workspace = true }
+proptest = { workspace = true }
+rand = { workspace = true }
+tempfile = { workspace = true }
+wasi-common = { path = "../wasi-common", default-features = true }
 
+[build-dependencies]
+cc = { workspace = true, optional = true }
+wasmtime-versioned-export-macros = { workspace = true, optional = true }
+
+# =============================================================================
+#
+# Features for the Wasmtime crate.
+#
+# This section contains the compile-time features of the `wasmtime` crate. These
+# features can be used to add more functionality and APIs exposed from the
+# crate's API. Most of them are enabled by default. Disabling features can be
+# done to cut down on binary size by disabling features that are not required
+# for a particular embedding.
 [features]
 default = [
   'async',
   'cache',
+  'gc',
   'wat',
-  'jitdump',
+  'profiling',
   'parallel-compilation',
   'cranelift',
   'pooling-allocator',
-  'vtune',
+  'demangle',
+  'addr2line',
+  'coredump',
+  'debug-builtins',
+  'runtime',
+  'component-model',
+  'threads',
+  'std',
 ]
 
 # An on-by-default feature enabling runtime compilation of WebAssembly modules
 # with the Cranelift compiler. Cranelift is the default compilation backend of
 # Wasmtime. If disabled then WebAssembly modules can only be created from
 # precompiled WebAssembly modules.
-cranelift = ["dep:wasmtime-cranelift"]
+cranelift = ["dep:wasmtime-cranelift", "std"]
 
 # Enables support for winch, the WebAssembly baseline compiler. The Winch compiler
 # strategy in `Config` will be available. It is currently in active development
 # and shouldn't be used in production applications.
-winch = ["dep:wasmtime-winch"]
+winch = ["dep:wasmtime-winch", "std"]
 
 # Enables support for incremental compilation cache to be enabled in `Config`.
-incremental-cache = ["wasmtime-cranelift?/incremental-cache"]
-
-# Enables support for the `perf` jitdump profiler
-jitdump = ["wasmtime-jit/jitdump"]
+incremental-cache = ["wasmtime-cranelift?/incremental-cache", "std"]
 
-# Enables support for the `VTune` profiler
-vtune = ["wasmtime-jit/vtune"]
+# Enables support for profiling guest modules.
+profiling = [
+  "dep:fxprof-processed-profile",
+  "dep:wasmtime-jit-debug",
+  "dep:ittapi",
+  "dep:rustix",
+  "rustix/thread",
+  "dep:serde_json",
+  "std",
+]
 
 # Enables parallel compilation of WebAssembly code.
-parallel-compilation = ["dep:rayon"]
+parallel-compilation = ["dep:rayon", "std"]
 
 # Enables support for automatic cache configuration to be enabled in `Config`.
-cache = ["dep:wasmtime-cache"]
+cache = ["dep:wasmtime-cache", "std"]
 
 # Enables support for "async stores" as well as defining host functions as
 # `async fn` and calling functions asynchronously.
 async = [
   "dep:wasmtime-fiber",
-  "wasmtime-runtime/async",
   "dep:async-trait",
   "wasmtime-component-macro?/async",
+  "runtime",
+  "std",
 ]
 
 # Enables support for the pooling instance allocation strategy
-pooling-allocator = ["wasmtime-runtime/pooling-allocator"]
+pooling-allocator = ["runtime", "std"]
 
 # Enables support for all architectures in Cranelift, allowing
 # cross-compilation using the `wasmtime` crate's API, notably the
 # `Engine::precompile_module` function.
-all-arch = [
-  "wasmtime-cranelift?/all-arch",
-  "wasmtime-winch?/all-arch",
-]
+all-arch = ["wasmtime-cranelift?/all-arch", "wasmtime-winch?/all-arch"]
 
 # Enables in-progress support for the component model. Note that this feature is
 # in-progress, buggy, and incomplete. This is primarily here for internal
@@ -128,10 +184,88 @@ component-model = [
   "wasmtime-environ/component-model",
   "wasmtime-cranelift?/component-model",
   "wasmtime-winch?/component-model",
-  "wasmtime-runtime/component-model",
   "dep:wasmtime-component-macro",
   "dep:wasmtime-component-util",
   "dep:encoding_rs",
+  "dep:semver",
+]
+
+wmemcheck = [
+  "dep:wasmtime-wmemcheck",
+  "wasmtime-cranelift?/wmemcheck",
+  "wasmtime-environ/wmemcheck",
+  "std",
 ]
 
-wmemcheck = ["wasmtime-runtime/wmemcheck", "wasmtime-cranelift?/wmemcheck"]
+# Enables support for demangling WebAssembly function names at runtime in
+# errors such as backtraces.
+demangle = ["wasmtime-environ/demangle", "std"]
+
+# Enable support for generating core dumps on traps.
+coredump = ["dep:wasm-encoder", "runtime", "std"]
+
+# Export some symbols from the final binary to assist in debugging
+# Cranelift-generated code with native debuggers like GDB and LLDB.
+debug-builtins = ["dep:wasmtime-jit-debug", "std"]
+
+# Enable support for executing compiled Wasm modules.
+runtime = [
+  "dep:cc",
+  "dep:smallvec",
+  "dep:mach2",
+  "dep:memfd",
+  "dep:wasmtime-asm-macros",
+  "dep:wasmtime-jit-icache-coherence",
+  "dep:wasmtime-slab",
+  "dep:wasmtime-versioned-export-macros",
+  "dep:windows-sys",
+  "dep:psm",
+  "dep:rustix",
+  "rustix/mm"
+]
+
+# Enable support for garbage collection-related things.
+#
+# This Cargo feature is required to compile or run Wasm that uses any of the
+# following Wasm proposals:
+#
+# * Reference types: https://github.com/WebAssembly/reference-types/
+# * Typed function references: https://github.com/WebAssembly/function-references/
+# * Garbage collection: https://github.com/WebAssembly/gc
+#
+# When a compiler Cargo feature (`cranelift` or `winch`) is enabled, this
+# feature gates the ability to compile Wasm that uses those proposals.
+#
+# When the `runtime` Cargo feature is enabled, this feature gates the ability to
+# load and run Wasm that uses those proposals.
+gc = ["wasmtime-environ/gc", "wasmtime-cranelift?/gc"]
+
+# Enable runtime support for the WebAssembly threads proposal.
+threads = ["wasmtime-cranelift?/threads", "std"]
+
+# Controls whether backtraces will attempt to parse DWARF information in
+# WebAssembly modules and components to provide filenames and line numbers in
+# stack traces.
+addr2line = ["dep:addr2line", "dep:gimli", "std"]
+
+# Enables support for the Rust standard library, enabling APIs that require
+# types and traits from Rust's `std` such as `Path` and `Error`.
+#
+# Many features of the Wasmtime crate implicitly require this `std` feature.
+# This will be automatically enabled if necessary.
+std = [
+  'postcard/use-std',
+  'wasmtime-component-macro?/std',
+  'wasmtime-environ/std',
+  'object/std',
+  'once_cell/std',
+]
+
+# Enables support for the `Store::call_hook` API which enables injecting custom
+# logic around all entries/exits from WebAssembly. This has a slight performance
+# cost for all host functions.
+call-hook = []
+
+# Enables support for "memory protection keys" which can be used in conjunction
+# with the pooling allocator on x64 to compact linear memory allocations.
+memory-protection-keys = ["pooling-allocator"]
diff --git a/crates/wasmtime/build.rs b/crates/wasmtime/build.rs
new file mode 100644
index 000000000000..e2572c9cc7ad
--- /dev/null
+++ b/crates/wasmtime/build.rs
@@ -0,0 +1,38 @@
+fn main() {
+    println!("cargo:rerun-if-changed=build.rs");
+
+    #[cfg(feature = "runtime")]
+    build_c_helpers();
+}
+
+#[cfg(feature = "runtime")]
+fn build_c_helpers() {
+    use wasmtime_versioned_export_macros::versioned_suffix;
+
+    // NB: duplicating a workaround in the wasmtime-fiber build script.
+    println!("cargo:rustc-check-cfg=cfg(asan)");
+    match std::env::var("CARGO_CFG_SANITIZE") {
+        Ok(s) if s == "address" => {
+            println!("cargo:rustc-cfg=asan");
+        }
+        _ => {}
+    }
+
+    // If this platform is neither unix nor windows then there's no default need
+    // for a C helper library since `helpers.c` is tailored for just these
+    // platforms currently.
+    if std::env::var("CARGO_CFG_UNIX").is_err() && std::env::var("CARGO_CFG_WINDOWS").is_err() {
+        return;
+    }
+
+    let mut build = cc::Build::new();
+    build.warnings(true);
+    let arch = std::env::var("CARGO_CFG_TARGET_ARCH").unwrap();
+    let os = std::env::var("CARGO_CFG_TARGET_OS").unwrap();
+    build.define(&format!("CFG_TARGET_OS_{os}"), None);
+    build.define(&format!("CFG_TARGET_ARCH_{arch}"), None);
+    build.define("VERSIONED_SUFFIX", Some(versioned_suffix!()));
+    println!("cargo:rerun-if-changed=src/runtime/vm/helpers.c");
+    build.file("src/runtime/vm/helpers.c");
+    build.compile("wasmtime-helpers");
+}
diff --git a/crates/wasmtime/proptest-regressions/runtime/vm/instance/allocator/pooling/memory_pool.txt b/crates/wasmtime/proptest-regressions/runtime/vm/instance/allocator/pooling/memory_pool.txt
new file mode 100644
index 000000000000..c1d3c19df592
--- /dev/null
+++ b/crates/wasmtime/proptest-regressions/runtime/vm/instance/allocator/pooling/memory_pool.txt
@@ -0,0 +1,9 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+cc 696808084287d5d58b85c60c4720227ab4dd83ada7be6841a67162023aaf4914 # shrinks to c = SlabConstraints { max_memory_bytes: 0, num_memory_slots: 1, num_pkeys_available: 0, guard_bytes: 9223372036854775808 }
+cc cf9f6c36659f7f56ed8ea646e8c699cbf46708cef6911cdd376418ad69ea1388 # shrinks to c = SlabConstraints { max_memory_bytes: 14161452635954640438, num_memory_slots: 0, num_pkeys_available: 0, guard_bytes: 4285291437754911178 }
+cc 58f42405c4fbfb4b464950f372995d4d08a77d6884335e38c2e68d590cacf7d8 # shrinks to c = SlabConstraints { expected_slot_bytes: 0, max_memory_bytes: 8483846582232735745, num_slots: 0, num_pkeys_available: 0, guard_bytes: 0, guard_before_slots: false }
diff --git a/crates/wasmtime/src/compile.rs b/crates/wasmtime/src/compile.rs
new file mode 100644
index 000000000000..35877008ebb4
--- /dev/null
+++ b/crates/wasmtime/src/compile.rs
@@ -0,0 +1,881 @@
+//! Wasm compilation orchestration.
+//!
+//! It works roughly like this:
+//!
+//! * We walk over the Wasm module/component and make a list of all the things
+//!   we need to compile. This is a `CompileInputs`.
+//!
+//! * The `CompileInputs::compile` method compiles each of these in parallel,
+//!   producing a `UnlinkedCompileOutputs`. This is an unlinked set of compiled
+//!   functions, bucketed by type of function.
+//!
+//! * The `UnlinkedCompileOutputs::pre_link` method re-arranges the compiled
+//!   functions into a flat list. This is the order we will place them within
+//!   the ELF file, so we must also keep track of all the functions' indices
+//!   within this list, because we will need them for resolving
+//!   relocations. These indices are kept track of in the resulting
+//!   `FunctionIndices`.
+//!
+//! * The `FunctionIndices::link_and_append_code` method appends the functions
+//!   to the given ELF file and resolves relocations. It produces an `Artifacts`
+//!   which contains the data needed at runtime to find and call Wasm
+//!   functions. It is up to the caller to serialize the relevant parts of the
+//!   `Artifacts` into the ELF file.
+
+use crate::prelude::*;
+use crate::Engine;
+use std::{
+    any::Any,
+    borrow::Cow,
+    collections::{btree_map, BTreeMap, BTreeSet, HashMap, HashSet},
+    mem,
+};
+
+#[cfg(feature = "component-model")]
+use wasmtime_environ::component::Translator;
+use wasmtime_environ::{
+    BuiltinFunctionIndex, CompiledFunctionInfo, CompiledModuleInfo, Compiler, DefinedFuncIndex,
+    FinishedObject, FunctionBodyData, ModuleEnvironment, ModuleInternedTypeIndex,
+    ModuleTranslation, ModuleTypes, ModuleTypesBuilder, ObjectKind, PrimaryMap, RelocationTarget,
+    StaticModuleIndex, WasmFunctionInfo,
+};
+
+mod code_builder;
+pub use self::code_builder::{CodeBuilder, CodeHint, HashedEngineCompileEnv};
+
+#[cfg(feature = "runtime")]
+mod runtime;
+
+/// Converts an input binary-encoded WebAssembly module to compilation
+/// artifacts and type information.
+///
+/// This is where compilation actually happens of WebAssembly modules and
+/// translation/parsing/validation of the binary input occurs. The binary
+/// artifact represented in the `MmapVec` returned here is an in-memory ELF
+/// file in an owned area of virtual linear memory where permissions (such
+/// as the executable bit) can be applied.
+///
+/// Additionally compilation returns an `Option` here which is always
+/// `Some`, notably compiled metadata about the module in addition to the
+/// type information found within.
+pub(crate) fn build_artifacts<T: FinishedObject>(
+    engine: &Engine,
+    wasm: &[u8],
+    dwarf_package: Option<&[u8]>,
+) -> Result<(T, Option<(CompiledModuleInfo, ModuleTypes)>)> {
+    let tunables = engine.tunables();
+
+    // First a `ModuleEnvironment` is created which records type information
+    // about the wasm module. This is where the WebAssembly is parsed and
+    // validated. Afterwards `types` will have all the type information for
+    // this module.
+    let mut parser = wasmparser::Parser::new(0);
+    let mut validator = wasmparser::Validator::new_with_features(engine.features());
+    parser.set_features(*validator.features());
+    let mut types = ModuleTypesBuilder::new(&validator);
+    let mut translation = ModuleEnvironment::new(tunables, &mut validator, &mut types)
+        .translate(parser, wasm)
+        .context("failed to parse WebAssembly module")?;
+    let functions = mem::take(&mut translation.function_body_inputs);
+
+    let compile_inputs = CompileInputs::for_module(&types, &translation, functions);
+    let unlinked_compile_outputs = compile_inputs.compile(engine)?;
+    let (compiled_funcs, function_indices) = unlinked_compile_outputs.pre_link();
+
+    // Emplace all compiled functions into the object file with any other
+    // sections associated with code as well.
+    let mut object = engine.compiler().object(ObjectKind::Module)?;
+    // Insert `Engine` and type-level information into the compiled
+    // artifact so if this module is deserialized later it contains all
+    // information necessary.
+    //
+    // Note that `append_compiler_info` and `append_types` here in theory
+    // can both be skipped if this module will never get serialized.
+    // They're only used during deserialization and not during runtime for
+    // the module itself. Currently there's no need for that, however, so
+    // it's left as an exercise for later.
+    engine.append_compiler_info(&mut object);
+    engine.append_bti(&mut object);
+
+    let (mut object, compilation_artifacts) = function_indices.link_and_append_code(
+        &types,
+        object,
+        engine,
+        compiled_funcs,
+        std::iter::once(translation).collect(),
+        dwarf_package,
+    )?;
+
+    let info = compilation_artifacts.unwrap_as_module_info();
+    let types = types.finish();
+    object.serialize_info(&(&info, &types));
+    let result = T::finish_object(object)?;
+
+    Ok((result, Some((info, types))))
+}
+
+/// Performs the compilation phase for a component, translating and
+/// validating the provided wasm binary to machine code.
+///
+/// This method will compile all nested core wasm binaries in addition to
+/// any necessary extra functions required for operation with components.
+/// The output artifact here is the serialized object file contained within
+/// an owned mmap along with metadata about the compilation itself.
+#[cfg(feature = "component-model")]
+pub(crate) fn build_component_artifacts<T: FinishedObject>(
+    engine: &Engine,
+    binary: &[u8],
+    _dwarf_package: Option<&[u8]>,
+) -> Result<(T, Option<wasmtime_environ::component::ComponentArtifacts>)> {
+    use wasmtime_environ::component::{
+        CompiledComponentInfo, ComponentArtifacts, ComponentTypesBuilder,
+    };
+    use wasmtime_environ::ScopeVec;
+
+    let tunables = engine.tunables();
+    let compiler = engine.compiler();
+
+    let scope = ScopeVec::new();
+    let mut validator = wasmparser::Validator::new_with_features(engine.features());
+    let mut types = ComponentTypesBuilder::new(&validator);
+    let (component, mut module_translations) =
+        Translator::new(tunables, &mut validator, &mut types, &scope)
+            .translate(binary)
+            .context("failed to parse WebAssembly module")?;
+
+    let compile_inputs = CompileInputs::for_component(
+        &types,
+        &component,
+        module_translations.iter_mut().map(|(i, translation)| {
+            let functions = mem::take(&mut translation.function_body_inputs);
+            (i, &*translation, functions)
+        }),
+    );
+    let unlinked_compile_outputs = compile_inputs.compile(&engine)?;
+
+    let (compiled_funcs, function_indices) = unlinked_compile_outputs.pre_link();
+
+    let mut object = compiler.object(ObjectKind::Component)?;
+    engine.append_compiler_info(&mut object);
+    engine.append_bti(&mut object);
+
+    let (mut object, compilation_artifacts) = function_indices.link_and_append_code(
+        types.module_types_builder(),
+        object,
+        engine,
+        compiled_funcs,
+        module_translations,
+        None, // TODO: Support dwarf packages for components.
+    )?;
+    let (types, ty) = types.finish(&component.component);
+
+    let info = CompiledComponentInfo {
+        component: component.component,
+        trampolines: compilation_artifacts.trampolines,
+        resource_drop_wasm_to_array_trampoline: compilation_artifacts
+            .resource_drop_wasm_to_array_trampoline,
+    };
+    let artifacts = ComponentArtifacts {
+        info,
+        ty,
+        types,
+        static_modules: compilation_artifacts.modules,
+    };
+    object.serialize_info(&artifacts);
+
+    let result = T::finish_object(object)?;
+    Ok((result, Some(artifacts)))
+}
+
+type CompileInput<'a> = Box<dyn FnOnce(&dyn Compiler) -> Result<CompileOutput> + Send + 'a>;
+
+/// A sortable, comparable key for a compilation output.
+///
+/// Two `u32`s to align with `cranelift_codegen::ir::UserExternalName`.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+struct CompileKey {
+    // The namespace field is bitpacked like:
+    //
+    //     [ kind:i3 module:i29 ]
+    namespace: u32,
+
+    index: u32,
+}
+
+impl CompileKey {
+    const KIND_BITS: u32 = 3;
+    const KIND_OFFSET: u32 = 32 - Self::KIND_BITS;
+    const KIND_MASK: u32 = ((1 << Self::KIND_BITS) - 1) << Self::KIND_OFFSET;
+
+    fn kind(&self) -> u32 {
+        self.namespace & Self::KIND_MASK
+    }
+
+    fn module(&self) -> StaticModuleIndex {
+        StaticModuleIndex::from_u32(self.namespace & !Self::KIND_MASK)
+    }
+
+    const WASM_FUNCTION_KIND: u32 = Self::new_kind(0);
+    const ARRAY_TO_WASM_TRAMPOLINE_KIND: u32 = Self::new_kind(1);
+    const WASM_TO_ARRAY_TRAMPOLINE_KIND: u32 = Self::new_kind(2);
+    const WASM_TO_BUILTIN_TRAMPOLINE_KIND: u32 = Self::new_kind(3);
+
+    const fn new_kind(kind: u32) -> u32 {
+        assert!(kind < (1 << Self::KIND_BITS));
+        kind << Self::KIND_OFFSET
+    }
+
+    // NB: more kinds in the other `impl` block.
+
+    fn wasm_function(module: StaticModuleIndex, index: DefinedFuncIndex) -> Self {
+        debug_assert_eq!(module.as_u32() & Self::KIND_MASK, 0);
+        Self {
+            namespace: Self::WASM_FUNCTION_KIND | module.as_u32(),
+            index: index.as_u32(),
+        }
+    }
+
+    fn array_to_wasm_trampoline(module: StaticModuleIndex, index: DefinedFuncIndex) -> Self {
+        debug_assert_eq!(module.as_u32() & Self::KIND_MASK, 0);
+        Self {
+            namespace: Self::ARRAY_TO_WASM_TRAMPOLINE_KIND | module.as_u32(),
+            index: index.as_u32(),
+        }
+    }
+
+    fn wasm_to_array_trampoline(index: ModuleInternedTypeIndex) -> Self {
+        Self {
+            namespace: Self::WASM_TO_ARRAY_TRAMPOLINE_KIND,
+            index: index.as_u32(),
+        }
+    }
+
+    fn wasm_to_builtin_trampoline(index: BuiltinFunctionIndex) -> Self {
+        Self {
+            namespace: Self::WASM_TO_BUILTIN_TRAMPOLINE_KIND,
+            index: index.index(),
+        }
+    }
+}
+
+#[cfg(feature = "component-model")]
+impl CompileKey {
+    const TRAMPOLINE_KIND: u32 = Self::new_kind(4);
+    const RESOURCE_DROP_WASM_TO_ARRAY_KIND: u32 = Self::new_kind(5);
+
+    fn trampoline(index: wasmtime_environ::component::TrampolineIndex) -> Self {
+        Self {
+            namespace: Self::TRAMPOLINE_KIND,
+            index: index.as_u32(),
+        }
+    }
+
+    fn resource_drop_wasm_to_array_trampoline() -> Self {
+        Self {
+            namespace: Self::RESOURCE_DROP_WASM_TO_ARRAY_KIND,
+            index: 0,
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+enum CompiledFunction<T> {
+    Function(T),
+    #[cfg(feature = "component-model")]
+    AllCallFunc(wasmtime_environ::component::AllCallFunc<T>),
+}
+
+impl<T> CompiledFunction<T> {
+    fn unwrap_function(self) -> T {
+        match self {
+            Self::Function(f) => f,
+            #[cfg(feature = "component-model")]
+            Self::AllCallFunc(_) => panic!("CompiledFunction::unwrap_function"),
+        }
+    }
+
+    #[cfg(feature = "component-model")]
+    fn unwrap_all_call_func(self) -> wasmtime_environ::component::AllCallFunc<T> {
+        match self {
+            Self::AllCallFunc(f) => f,
+            Self::Function(_) => panic!("CompiledFunction::unwrap_all_call_func"),
+        }
+    }
+}
+
+#[cfg(feature = "component-model")]
+impl<T> From<wasmtime_environ::component::AllCallFunc<T>> for CompiledFunction<T> {
+    fn from(f: wasmtime_environ::component::AllCallFunc<T>) -> Self {
+        Self::AllCallFunc(f)
+    }
+}
+
+struct CompileOutput {
+    key: CompileKey,
+    symbol: String,
+    function: CompiledFunction<Box<dyn Any + Send>>,
+    info: Option<WasmFunctionInfo>,
+}
+
+/// The collection of things we need to compile for a Wasm module or component.
+#[derive(Default)]
+struct CompileInputs<'a> {
+    inputs: Vec<CompileInput<'a>>,
+}
+
+impl<'a> CompileInputs<'a> {
+    fn push_input(&mut self, f: impl FnOnce(&dyn Compiler) -> Result<CompileOutput> + Send + 'a) {
+        self.inputs.push(Box::new(f));
+    }
+
+    /// Create the `CompileInputs` for a core Wasm module.
+    fn for_module(
+        types: &'a ModuleTypesBuilder,
+        translation: &'a ModuleTranslation<'a>,
+        functions: PrimaryMap<DefinedFuncIndex, FunctionBodyData<'a>>,
+    ) -> Self {
+        let mut ret = Self::default();
+        let module_index = StaticModuleIndex::from_u32(0);
+
+        ret.collect_inputs_in_translations(types, [(module_index, translation, functions)]);
+
+        ret
+    }
+
+    /// Create a `CompileInputs` for a component.
+    #[cfg(feature = "component-model")]
+    fn for_component(
+        types: &'a wasmtime_environ::component::ComponentTypesBuilder,
+        component: &'a wasmtime_environ::component::ComponentTranslation,
+        module_translations: impl IntoIterator<
+            Item = (
+                StaticModuleIndex,
+                &'a ModuleTranslation<'a>,
+                PrimaryMap<DefinedFuncIndex, FunctionBodyData<'a>>,
+            ),
+        >,
+    ) -> Self {
+        let mut ret = CompileInputs::default();
+
+        ret.collect_inputs_in_translations(types.module_types_builder(), module_translations);
+
+        for (idx, trampoline) in component.trampolines.iter() {
+            ret.push_input(move |compiler| {
+                Ok(CompileOutput {
+                    key: CompileKey::trampoline(idx),
+                    symbol: trampoline.symbol_name(),
+                    function: compiler
+                        .component_compiler()
+                        .compile_trampoline(component, types, idx)?
+                        .into(),
+                    info: None,
+                })
+            });
+        }
+
+        // If there are any resources defined within this component, the
+        // signature for `resource.drop` is mentioned somewhere, and the
+        // wasm-to-native trampoline for `resource.drop` hasn't been created yet
+        // then insert that here. This is possibly required by destruction of
+        // resources from the embedder and otherwise won't be explicitly
+        // requested through initializers above or such.
+        if component.component.num_resources > 0 {
+            if let Some(sig) = types.find_resource_drop_signature() {
+                ret.push_input(move |compiler| {
+                    let trampoline =
+                        compiler.compile_wasm_to_array_trampoline(types[sig].unwrap_func())?;
+                    Ok(CompileOutput {
+                        key: CompileKey::resource_drop_wasm_to_array_trampoline(),
+                        symbol: "resource_drop_trampoline".to_string(),
+                        function: CompiledFunction::Function(trampoline),
+                        info: None,
+                    })
+                });
+            }
+        }
+
+        ret
+    }
+
+    fn clean_symbol(name: &str) -> Cow<str> {
+        /// Maximum length of symbols generated in objects.
+        const MAX_SYMBOL_LEN: usize = 96;
+
+        // Just to be on the safe side, filter out characters that could
+        // pose issues to tools such as "perf" or "objdump".  To avoid
+        // having to update a list of allowed characters for each different
+        // language that compiles to Wasm, allows only graphic ASCII
+        // characters; replace runs of everything else with a "?".
+        let bad_char = |c: char| !c.is_ascii_graphic();
+        if name.chars().any(bad_char) {
+            let mut last_char_seen = '\u{0000}';
+            Cow::Owned(
+                name.chars()
+                    .map(|c| if bad_char(c) { '?' } else { c })
+                    .filter(|c| {
+                        let skip = last_char_seen == '?' && *c == '?';
+                        last_char_seen = *c;
+                        !skip
+                    })
+                    .take(MAX_SYMBOL_LEN)
+                    .collect::<String>(),
+            )
+        } else if name.len() <= MAX_SYMBOL_LEN {
+            Cow::Borrowed(&name[..])
+        } else {
+            Cow::Borrowed(&name[..MAX_SYMBOL_LEN])
+        }
+    }
+
+    fn collect_inputs_in_translations(
+        &mut self,
+        types: &'a ModuleTypesBuilder,
+        translations: impl IntoIterator<
+            Item = (
+                StaticModuleIndex,
+                &'a ModuleTranslation<'a>,
+                PrimaryMap<DefinedFuncIndex, FunctionBodyData<'a>>,
+            ),
+        >,
+    ) {
+        for (module, translation, functions) in translations {
+            for (def_func_index, func_body) in functions {
+                self.push_input(move |compiler| {
+                    let func_index = translation.module.func_index(def_func_index);
+                    let (info, function) =
+                        compiler.compile_function(translation, def_func_index, func_body, types)?;
+                    let symbol = match translation
+                        .debuginfo
+                        .name_section
+                        .func_names
+                        .get(&func_index)
+                    {
+                        Some(name) => format!(
+                            "wasm[{}]::function[{}]::{}",
+                            module.as_u32(),
+                            func_index.as_u32(),
+                            Self::clean_symbol(&name)
+                        ),
+                        None => format!(
+                            "wasm[{}]::function[{}]",
+                            module.as_u32(),
+                            func_index.as_u32()
+                        ),
+                    };
+
+                    Ok(CompileOutput {
+                        key: CompileKey::wasm_function(module, def_func_index),
+                        symbol,
+                        function: CompiledFunction::Function(function),
+                        info: Some(info),
+                    })
+                });
+
+                let func_index = translation.module.func_index(def_func_index);
+                if translation.module.functions[func_index].is_escaping() {
+                    self.push_input(move |compiler| {
+                        let func_index = translation.module.func_index(def_func_index);
+                        let trampoline = compiler.compile_array_to_wasm_trampoline(
+                            translation,
+                            types,
+                            def_func_index,
+                        )?;
+                        Ok(CompileOutput {
+                            key: CompileKey::array_to_wasm_trampoline(module, def_func_index),
+                            symbol: format!(
+                                "wasm[{}]::array_to_wasm_trampoline[{}]",
+                                module.as_u32(),
+                                func_index.as_u32()
+                            ),
+                            function: CompiledFunction::Function(trampoline),
+                            info: None,
+                        })
+                    });
+                }
+            }
+        }
+
+        let mut trampoline_types_seen = HashSet::new();
+        for (_func_type_index, trampoline_type_index) in types.trampoline_types() {
+            let is_new = trampoline_types_seen.insert(trampoline_type_index);
+            if !is_new {
+                continue;
+            }
+            let trampoline_func_ty = types[trampoline_type_index].unwrap_func();
+            self.push_input(move |compiler| {
+                let trampoline = compiler.compile_wasm_to_array_trampoline(trampoline_func_ty)?;
+                Ok(CompileOutput {
+                    key: CompileKey::wasm_to_array_trampoline(trampoline_type_index),
+                    symbol: format!(
+                        "signatures[{}]::wasm_to_array_trampoline",
+                        trampoline_type_index.as_u32()
+                    ),
+                    function: CompiledFunction::Function(trampoline),
+                    info: None,
+                })
+            });
+        }
+    }
+
+    /// Compile these `CompileInput`s (maybe in parallel) and return the
+    /// resulting `UnlinkedCompileOutput`s.
+    fn compile(self, engine: &Engine) -> Result<UnlinkedCompileOutputs> {
+        let compiler = engine.compiler();
+
+        // Compile each individual input in parallel.
+        let mut raw_outputs = engine.run_maybe_parallel(self.inputs, |f| f(compiler))?;
+
+        // Now that all functions have been compiled see if any
+        // wasmtime-builtin functions are necessary. If so those need to be
+        // collected and then those trampolines additionally need to be
+        // compiled.
+        compile_required_builtins(engine, &mut raw_outputs)?;
+
+        // Bucket the outputs by kind.
+        let mut outputs: BTreeMap<u32, Vec<CompileOutput>> = BTreeMap::new();
+        for output in raw_outputs {
+            outputs.entry(output.key.kind()).or_default().push(output);
+        }
+
+        Ok(UnlinkedCompileOutputs { outputs })
+    }
+}
+
+fn compile_required_builtins(engine: &Engine, raw_outputs: &mut Vec<CompileOutput>) -> Result<()> {
+    let compiler = engine.compiler();
+    let mut builtins = HashSet::new();
+    let mut new_inputs: Vec<CompileInput<'_>> = Vec::new();
+
+    let compile_builtin = |builtin: BuiltinFunctionIndex| {
+        Box::new(move |compiler: &dyn Compiler| {
+            let symbol = format!("wasmtime_builtin_{}", builtin.name());
+            Ok(CompileOutput {
+                key: CompileKey::wasm_to_builtin_trampoline(builtin),
+                symbol,
+                function: CompiledFunction::Function(compiler.compile_wasm_to_builtin(builtin)?),
+                info: None,
+            })
+        })
+    };
+
+    for output in raw_outputs.iter() {
+        let f = match &output.function {
+            CompiledFunction::Function(f) => f,
+            #[cfg(feature = "component-model")]
+            CompiledFunction::AllCallFunc(_) => continue,
+        };
+        for reloc in compiler.compiled_function_relocation_targets(&**f) {
+            match reloc {
+                RelocationTarget::Builtin(i) => {
+                    if builtins.insert(i) {
+                        new_inputs.push(compile_builtin(i));
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+    raw_outputs.extend(engine.run_maybe_parallel(new_inputs, |c| c(compiler))?);
+    Ok(())
+}
+
+#[derive(Default)]
+struct UnlinkedCompileOutputs {
+    // A map from kind to `CompileOutput`.
+    outputs: BTreeMap<u32, Vec<CompileOutput>>,
+}
+
+impl UnlinkedCompileOutputs {
+    /// Flatten all our functions into a single list and remember each of their
+    /// indices within it.
+    fn pre_link(self) -> (Vec<(String, Box<dyn Any + Send>)>, FunctionIndices) {
+        // The order the functions end up within `compiled_funcs` is the order
+        // that they will be laid out in the ELF file, so try and group hot and
+        // cold functions together as best we can. However, because we bucket by
+        // kind, we shouldn't have any issues with, e.g., cold trampolines
+        // appearing in between hot Wasm functions.
+        let mut compiled_funcs = vec![];
+        let mut indices = FunctionIndices::default();
+        for x in self.outputs.into_iter().flat_map(|(_kind, xs)| xs) {
+            let index = match x.function {
+                CompiledFunction::Function(f) => {
+                    let index = compiled_funcs.len();
+                    compiled_funcs.push((x.symbol, f));
+                    CompiledFunction::Function(index)
+                }
+                #[cfg(feature = "component-model")]
+                CompiledFunction::AllCallFunc(f) => {
+                    let array_call = compiled_funcs.len();
+                    compiled_funcs.push((format!("{}_array_call", x.symbol), f.array_call));
+                    let wasm_call = compiled_funcs.len();
+                    compiled_funcs.push((format!("{}_wasm_call", x.symbol), f.wasm_call));
+                    CompiledFunction::AllCallFunc(wasmtime_environ::component::AllCallFunc {
+                        array_call,
+                        wasm_call,
+                    })
+                }
+            };
+
+            if x.key.kind() == CompileKey::WASM_FUNCTION_KIND
+                || x.key.kind() == CompileKey::ARRAY_TO_WASM_TRAMPOLINE_KIND
+            {
+                indices
+                    .compiled_func_index_to_module
+                    .insert(index.unwrap_function(), x.key.module());
+                if let Some(info) = x.info {
+                    indices.wasm_function_infos.insert(x.key, info);
+                }
+            }
+
+            indices
+                .indices
+                .entry(x.key.kind())
+                .or_default()
+                .insert(x.key, index);
+        }
+        (compiled_funcs, indices)
+    }
+}
+
+#[derive(Default)]
+struct FunctionIndices {
+    // A reverse map from an index in `compiled_funcs` to the
+    // `StaticModuleIndex` for that function.
+    compiled_func_index_to_module: HashMap<usize, StaticModuleIndex>,
+
+    // A map from Wasm functions' compile keys to their infos.
+    wasm_function_infos: HashMap<CompileKey, WasmFunctionInfo>,
+
+    // The index of each compiled function, bucketed by compile key kind.
+    indices: BTreeMap<u32, BTreeMap<CompileKey, CompiledFunction<usize>>>,
+}
+
+impl FunctionIndices {
+    /// Link the compiled functions together, resolving relocations, and append
+    /// them to the given ELF file.
+    fn link_and_append_code<'a>(
+        mut self,
+        types: &ModuleTypesBuilder,
+        mut obj: object::write::Object<'static>,
+        engine: &'a Engine,
+        compiled_funcs: Vec<(String, Box<dyn Any + Send>)>,
+        translations: PrimaryMap<StaticModuleIndex, ModuleTranslation<'_>>,
+        dwarf_package_bytes: Option<&[u8]>,
+    ) -> Result<(wasmtime_environ::ObjectBuilder<'a>, Artifacts)> {
+        // Append all the functions to the ELF file.
+        //
+        // The result is a vector parallel to `compiled_funcs` where
+        // `symbol_ids_and_locs[i]` is the symbol ID and function location of
+        // `compiled_funcs[i]`.
+        let compiler = engine.compiler();
+        let tunables = engine.tunables();
+        let symbol_ids_and_locs = compiler.append_code(
+            &mut obj,
+            &compiled_funcs,
+            &|caller_index: usize, callee: RelocationTarget| match callee {
+                RelocationTarget::Wasm(callee_index) => {
+                    let module = self
+                        .compiled_func_index_to_module
+                        .get(&caller_index)
+                        .copied()
+                        .expect("should only reloc inside wasm function callers");
+                    let def_func_index = translations[module]
+                        .module
+                        .defined_func_index(callee_index)
+                        .unwrap();
+                    self.indices[&CompileKey::WASM_FUNCTION_KIND]
+                        [&CompileKey::wasm_function(module, def_func_index)]
+                        .unwrap_function()
+                }
+                RelocationTarget::Builtin(builtin) => self.indices
+                    [&CompileKey::WASM_TO_BUILTIN_TRAMPOLINE_KIND]
+                    [&CompileKey::wasm_to_builtin_trampoline(builtin)]
+                    .unwrap_function(),
+                RelocationTarget::HostLibcall(_) => {
+                    unreachable!("relocation is resolved at runtime, not compile time");
+                }
+            },
+        )?;
+
+        // If requested, generate and add DWARF information.
+        if tunables.generate_native_debuginfo {
+            compiler.append_dwarf(
+                &mut obj,
+                &translations,
+                &|module, func| {
+                    let bucket = &self.indices[&CompileKey::WASM_FUNCTION_KIND];
+                    let i = bucket[&CompileKey::wasm_function(module, func)].unwrap_function();
+                    (symbol_ids_and_locs[i].0, &*compiled_funcs[i].1)
+                },
+                dwarf_package_bytes,
+                tunables,
+            )?;
+        }
+
+        let mut obj = wasmtime_environ::ObjectBuilder::new(obj, tunables);
+        let mut artifacts = Artifacts::default();
+
+        // Remove this as it's not needed by anything below and we'll debug
+        // assert `self.indices` is empty, so this is acknowledgement that this
+        // is a pure runtime implementation detail and not needed in any
+        // metadata generated below.
+        self.indices
+            .remove(&CompileKey::WASM_TO_BUILTIN_TRAMPOLINE_KIND);
+
+        // Finally, build our binary artifacts that map things like `FuncIndex`
+        // to a function location and all of that using the indices we saved
+        // earlier and the function locations we just received after appending
+        // the code.
+
+        let mut wasm_functions = self
+            .indices
+            .remove(&CompileKey::WASM_FUNCTION_KIND)
+            .unwrap_or_default()
+            .into_iter()
+            .peekable();
+
+        fn wasm_functions_for_module(
+            wasm_functions: &mut std::iter::Peekable<
+                btree_map::IntoIter<CompileKey, CompiledFunction<usize>>,
+            >,
+            module: StaticModuleIndex,
+        ) -> impl Iterator<Item = (CompileKey, CompiledFunction<usize>)> + '_ {
+            std::iter::from_fn(move || {
+                let (key, _) = wasm_functions.peek()?;
+                if key.module() == module {
+                    wasm_functions.next()
+                } else {
+                    None
+                }
+            })
+        }
+
+        let mut array_to_wasm_trampolines = self
+            .indices
+            .remove(&CompileKey::ARRAY_TO_WASM_TRAMPOLINE_KIND)
+            .unwrap_or_default();
+
+        // NB: unlike the above maps this is not emptied out during iteration
+        // since each module may reach into different portions of this map.
+        let wasm_to_array_trampolines = self
+            .indices
+            .remove(&CompileKey::WASM_TO_ARRAY_TRAMPOLINE_KIND)
+            .unwrap_or_default();
+
+        artifacts.modules = translations
+            .into_iter()
+            .map(|(module, mut translation)| {
+                // If configured attempt to use static memory initialization which
+                // can either at runtime be implemented as a single memcpy to
+                // initialize memory or otherwise enabling virtual-memory-tricks
+                // such as mmap'ing from a file to get copy-on-write.
+                if engine.config().memory_init_cow {
+                    let align = compiler.page_size_align();
+                    let max_always_allowed = engine.config().memory_guaranteed_dense_image_size;
+                    translation.try_static_init(align, max_always_allowed);
+                }
+
+                // Attempt to convert table initializer segments to
+                // FuncTable representation where possible, to enable
+                // table lazy init.
+                if engine.tunables().table_lazy_init {
+                    translation.try_func_table_init();
+                }
+
+                let funcs: PrimaryMap<DefinedFuncIndex, CompiledFunctionInfo> =
+                    wasm_functions_for_module(&mut wasm_functions, module)
+                        .map(|(key, wasm_func_index)| {
+                            let wasm_func_index = wasm_func_index.unwrap_function();
+                            let wasm_func_loc = symbol_ids_and_locs[wasm_func_index].1;
+                            let wasm_func_info = self.wasm_function_infos.remove(&key).unwrap();
+
+                            let array_to_wasm_trampoline = array_to_wasm_trampolines
+                                .remove(&CompileKey::array_to_wasm_trampoline(
+                                    key.module(),
+                                    DefinedFuncIndex::from_u32(key.index),
+                                ))
+                                .map(|x| symbol_ids_and_locs[x.unwrap_function()].1);
+
+                            CompiledFunctionInfo {
+                                wasm_func_info,
+                                wasm_func_loc,
+                                array_to_wasm_trampoline,
+                            }
+                        })
+                        .collect();
+
+                let unique_and_sorted_trampoline_sigs = translation
+                    .module
+                    .types
+                    .iter()
+                    .map(|(_, ty)| *ty)
+                    .filter(|idx| types[*idx].is_func())
+                    .map(|idx| types.trampoline_type(idx))
+                    .collect::<BTreeSet<_>>();
+                let wasm_to_array_trampolines = unique_and_sorted_trampoline_sigs
+                    .iter()
+                    .map(|idx| {
+                        let trampoline = types.trampoline_type(*idx);
+                        let key = CompileKey::wasm_to_array_trampoline(trampoline);
+                        let compiled = wasm_to_array_trampolines[&key];
+                        (*idx, symbol_ids_and_locs[compiled.unwrap_function()].1)
+                    })
+                    .collect();
+
+                obj.append(translation, funcs, wasm_to_array_trampolines)
+            })
+            .collect::<Result<PrimaryMap<_, _>>>()?;
+
+        #[cfg(feature = "component-model")]
+        {
+            artifacts.trampolines = self
+                .indices
+                .remove(&CompileKey::TRAMPOLINE_KIND)
+                .unwrap_or_default()
+                .into_iter()
+                .map(|(_id, x)| x.unwrap_all_call_func().map(|i| symbol_ids_and_locs[i].1))
+                .collect();
+            let map = self
+                .indices
+                .remove(&CompileKey::RESOURCE_DROP_WASM_TO_ARRAY_KIND)
+                .unwrap_or_default();
+            assert!(map.len() <= 1);
+            artifacts.resource_drop_wasm_to_array_trampoline = map
+                .into_iter()
+                .next()
+                .map(|(_id, x)| symbol_ids_and_locs[x.unwrap_function()].1);
+        }
+
+        debug_assert!(
+            self.indices.is_empty(),
+            "Should have processed all compile outputs"
+        );
+
+        Ok((obj, artifacts))
+    }
+}
+
+/// The artifacts necessary for finding and calling Wasm functions at runtime,
+/// to be serialized into an ELF file.
+#[derive(Default)]
+struct Artifacts {
+    modules: PrimaryMap<StaticModuleIndex, CompiledModuleInfo>,
+    #[cfg(feature = "component-model")]
+    trampolines: PrimaryMap<
+        wasmtime_environ::component::TrampolineIndex,
+        wasmtime_environ::component::AllCallFunc<wasmtime_environ::FunctionLoc>,
+    >,
+    #[cfg(feature = "component-model")]
+    resource_drop_wasm_to_array_trampoline: Option<wasmtime_environ::FunctionLoc>,
+}
+
+impl Artifacts {
+    /// Assuming this compilation was for a single core Wasm module, get the
+    /// resulting `CompiledModuleInfo`.
+    fn unwrap_as_module_info(self) -> CompiledModuleInfo {
+        assert_eq!(self.modules.len(), 1);
+        #[cfg(feature = "component-model")]
+        assert!(self.trampolines.is_empty());
+        self.modules.into_iter().next().unwrap().1
+    }
+}
diff --git a/crates/wasmtime/src/compile/code_builder.rs b/crates/wasmtime/src/compile/code_builder.rs
new file mode 100644
index 000000000000..ec8b543292c7
--- /dev/null
+++ b/crates/wasmtime/src/compile/code_builder.rs
@@ -0,0 +1,317 @@
+use crate::prelude::*;
+use crate::Engine;
+use std::borrow::Cow;
+use std::path::Path;
+
+/// Builder-style structure used to create a [`Module`](crate::module::Module) or
+/// pre-compile a module to a serialized list of bytes.
+///
+/// This structure can be used for more advanced configuration when compiling a
+/// WebAssembly module. Most configuration can use simpler constructors such as:
+///
+/// * [`Module::new`](crate::Module::new)
+/// * [`Module::from_file`](crate::Module::from_file)
+/// * [`Module::from_binary`](crate::Module::from_binary)
+///
+/// Note that a [`CodeBuilder`] always involves compiling WebAssembly bytes
+/// to machine code. To deserialize a list of bytes use
+/// [`Module::deserialize`](crate::Module::deserialize) instead.
+///
+/// A [`CodeBuilder`] requires a source of WebAssembly bytes to be configured
+/// before calling [`compile_module_serialized`] or [`compile_module`]. This can
+/// be provided with either the [`wasm_binary`] or [`wasm_binary_file`] method.
+/// Note that only a single source of bytes can be provided.
+///
+/// # WebAssembly Text Format
+///
+/// This builder supports the WebAssembly Text Format (`*.wat` files) through
+/// the [`CodeBuilder::wasm_binary_or_text`] and
+/// [`CodeBuilder::wasm_binary_or_text_file`] methods. These methods
+/// automatically convert WebAssembly text files to binary. Note though that
+/// this behavior is disabled if the `wat` crate feature is not enabled.
+///
+/// [`compile_module_serialized`]: CodeBuilder::compile_module_serialized
+/// [`compile_module`]: CodeBuilder::compile_module
+/// [`wasm_binary`]: CodeBuilder::wasm_binary
+/// [`wasm_binary_file`]: CodeBuilder::wasm_binary_file
+pub struct CodeBuilder<'a> {
+    pub(super) engine: &'a Engine,
+    wasm: Option<Cow<'a, [u8]>>,
+    wasm_path: Option<Cow<'a, Path>>,
+    dwarf_package: Option<Cow<'a, [u8]>>,
+    dwarf_package_path: Option<Cow<'a, Path>>,
+}
+
+/// Return value of [`CodeBuilder::hint`]
+pub enum CodeHint {
+    /// Hint that the code being compiled is a module.
+    Module,
+    /// Hint that the code being compiled is a component.
+    Component,
+}
+
+impl<'a> CodeBuilder<'a> {
+    /// Creates a new builder which will insert modules into the specified
+    /// [`Engine`].
+    pub fn new(engine: &'a Engine) -> CodeBuilder<'a> {
+        CodeBuilder {
+            engine,
+            wasm: None,
+            wasm_path: None,
+            dwarf_package: None,
+            dwarf_package_path: None,
+        }
+    }
+
+    /// Configures the WebAssembly binary that is being compiled.
+    ///
+    /// The `wasm_bytes` parameter must be a binary WebAssembly file.
+    /// This will be stored within the [`CodeBuilder`] for processing later when
+    /// compilation is finalized.
+    ///
+    /// The optional `wasm_path` parameter is the path to the `wasm_bytes` on
+    /// disk, if any. This may be used for diagnostics and other
+    /// debugging-related purposes, but this method will not read the path
+    /// specified.
+    ///
+    /// # Errors
+    ///
+    /// This method will return an error if WebAssembly bytes have already been
+    /// configured.
+    pub fn wasm_binary(
+        &mut self,
+        wasm_bytes: impl Into<Cow<'a, [u8]>>,
+        wasm_path: Option<&'a Path>,
+    ) -> Result<&mut Self> {
+        if self.wasm.is_some() {
+            bail!("cannot configure wasm bytes twice");
+        }
+        self.wasm = Some(wasm_bytes.into());
+        self.wasm_path = wasm_path.map(|p| p.into());
+
+        if self.wasm_path.is_some() {
+            self.dwarf_package_from_wasm_path()?;
+        }
+
+        Ok(self)
+    }
+
+    /// Equivalent of [`CodeBuilder::wasm_binary`] that also accepts the
+    /// WebAssembly text format.
+    ///
+    /// This method will configure the WebAssembly binary to be compiled. The
+    /// input `wasm_bytes` may either be the wasm text format or the binary
+    /// format. If the `wat` crate feature is enabled, which is enabled by
+    /// default, then the text format will automatically be converted to the
+    /// binary format.
+    ///
+    /// # Errors
+    ///
+    /// This method will return an error if WebAssembly bytes have already been
+    /// configured. This method will also return an error if `wasm_bytes` is the
+    /// wasm text format and the text syntax is not valid.
+    pub fn wasm_binary_or_text(
+        &mut self,
+        wasm_bytes: &'a [u8],
+        wasm_path: Option<&'a Path>,
+    ) -> Result<&mut Self> {
+        #[cfg(feature = "wat")]
+        let wasm_bytes = wat::parse_bytes(wasm_bytes).map_err(|mut e| {
+            if let Some(path) = wasm_path {
+                e.set_path(path);
+            }
+            e
+        })?;
+        self.wasm_binary(wasm_bytes, wasm_path)
+    }
+
+    /// Reads the `file` specified for the WebAssembly bytes that are going to
+    /// be compiled.
+    ///
+    /// This method will read `file` from the filesystem and interpret it
+    /// as a WebAssembly binary.
+    ///
+    /// A DWARF package file will be probed using the root of `file` and with a
+    /// `.dwp` extension. If found, it will be loaded and DWARF fusion
+    /// performed.
+    ///
+    /// # Errors
+    ///
+    /// This method will return an error if WebAssembly bytes have already been
+    /// configured.
+    ///
+    /// If `file` can't be read or an error happens reading it then that will
+    /// also be returned.
+    ///
+    /// If DWARF fusion is performed and the DWARF packaged file cannot be read
+    /// then an error will be returned.
+    pub fn wasm_binary_file(&mut self, file: &'a Path) -> Result<&mut Self> {
+        let wasm = std::fs::read(file)
+            .with_context(|| format!("failed to read input file: {}", file.display()))?;
+        self.wasm_binary(wasm, Some(file))
+    }
+
+    /// Equivalent of [`CodeBuilder::wasm_binary_file`] that also accepts the
+    /// WebAssembly text format.
+    ///
+    /// This method is will read the file at `path` and interpret the contents
+    /// to determine if it's the wasm text format or binary format. The file
+    /// extension of `file` is not consulted. The text format is automatically
+    /// converted to the binary format if the crate feature `wat` is active.
+    ///
+    /// # Errors
+    ///
+    /// In addition to the errors returned by [`CodeBuilder::wasm_binary_file`]
+    /// this may also fail if the text format is read and the syntax is invalid.
+    pub fn wasm_binary_or_text_file(&mut self, file: &'a Path) -> Result<&mut Self> {
+        #[cfg(feature = "wat")]
+        {
+            let wasm = wat::parse_file(file)?;
+            self.wasm_binary(wasm, Some(file))
+        }
+        #[cfg(not(feature = "wat"))]
+        {
+            self.wasm_binary_file(file)
+        }
+    }
+
+    pub(super) fn get_wasm(&self) -> Result<&[u8]> {
+        self.wasm
+            .as_deref()
+            .ok_or_else(|| anyhow!("no wasm bytes have been configured"))
+    }
+
+    /// Explicitly specify DWARF `.dwp` path.
+    ///
+    /// # Errors
+    ///
+    /// This method will return an error if the `.dwp` file has already been set
+    /// through [`CodeBuilder::dwarf_package`] or auto-detection in
+    /// [`CodeBuilder::wasm_binary_file`].
+    ///
+    /// This method will also return an error if `file` cannot be read.
+    pub fn dwarf_package_file(&mut self, file: &Path) -> Result<&mut Self> {
+        if self.dwarf_package.is_some() {
+            bail!("cannot call `dwarf_package` or `dwarf_package_file` twice");
+        }
+
+        let dwarf_package = std::fs::read(file)
+            .with_context(|| format!("failed to read dwarf input file: {}", file.display()))?;
+        self.dwarf_package_path = Some(Cow::Owned(file.to_owned()));
+        self.dwarf_package = Some(dwarf_package.into());
+
+        Ok(self)
+    }
+
+    fn dwarf_package_from_wasm_path(&mut self) -> Result<&mut Self> {
+        let dwarf_package_path_buf = self.wasm_path.as_ref().unwrap().with_extension("dwp");
+        if dwarf_package_path_buf.exists() {
+            return self.dwarf_package_file(dwarf_package_path_buf.as_path());
+        }
+
+        Ok(self)
+    }
+
+    /// Gets the DWARF package.
+    pub(super) fn get_dwarf_package(&self) -> Option<&[u8]> {
+        self.dwarf_package.as_deref()
+    }
+
+    /// Set the DWARF package binary.
+    ///
+    /// Initializes `dwarf_package` from `dwp_bytes` in preparation for
+    /// DWARF fusion. Allows the DWARF package to be supplied as a byte array
+    /// when the file probing performed in `wasm_file` is not appropriate.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the `*.dwp` file is already set via auto-probing in
+    /// [`CodeBuilder::wasm_binary_file`] or explicitly via
+    /// [`CodeBuilder::dwarf_package_file`].
+    pub fn dwarf_package(&mut self, dwp_bytes: &'a [u8]) -> Result<&mut Self> {
+        if self.dwarf_package.is_some() {
+            bail!("cannot call `dwarf_package` or `dwarf_package_file` twice");
+        }
+        self.dwarf_package = Some(dwp_bytes.into());
+        Ok(self)
+    }
+
+    /// Returns a hint, if possible, of what the provided bytes are.
+    ///
+    /// This method can be use to detect what the previously supplied bytes to
+    /// methods such as [`CodeBuilder::wasm_binary_or_text`] are. This will
+    /// return whether a module or a component was found in the provided bytes.
+    ///
+    /// This method will return `None` if wasm bytes have not been configured
+    /// or if the provided bytes don't look like either a component or a
+    /// module.
+    pub fn hint(&self) -> Option<CodeHint> {
+        let wasm = self.wasm.as_ref()?;
+        if wasmparser::Parser::is_component(wasm) {
+            Some(CodeHint::Component)
+        } else if wasmparser::Parser::is_core_wasm(wasm) {
+            Some(CodeHint::Module)
+        } else {
+            None
+        }
+    }
+
+    /// Finishes this compilation and produces a serialized list of bytes.
+    ///
+    /// This method requires that either [`CodeBuilder::wasm_binary`] or
+    /// related methods were invoked prior to indicate what is being compiled.
+    ///
+    /// This method will block the current thread until compilation has
+    /// finished, and when done the serialized artifact will be returned.
+    ///
+    /// Note that this method will never cache compilations, even if the
+    /// `cache` feature is enabled.
+    ///
+    /// # Errors
+    ///
+    /// This can fail if the input wasm module was not valid or if another
+    /// compilation-related error is encountered.
+    pub fn compile_module_serialized(&self) -> Result<Vec<u8>> {
+        let wasm = self.get_wasm()?;
+        let dwarf_package = self.get_dwarf_package();
+        let (v, _) = super::build_artifacts(self.engine, &wasm, dwarf_package.as_deref())?;
+        Ok(v)
+    }
+
+    /// Same as [`CodeBuilder::compile_module_serialized`] except that it
+    /// compiles a serialized [`Component`](crate::component::Component)
+    /// instead of a module.
+    #[cfg(feature = "component-model")]
+    pub fn compile_component_serialized(&self) -> Result<Vec<u8>> {
+        let bytes = self.get_wasm()?;
+        let (v, _) = super::build_component_artifacts(self.engine, &bytes, None)?;
+        Ok(v)
+    }
+}
+
+/// This is a helper struct used when caching to hash the state of an `Engine`
+/// used for module compilation.
+///
+/// The hash computed for this structure is used to key the global wasmtime
+/// cache and dictates whether artifacts are reused. Consequently the contents
+/// of this hash dictate when artifacts are or aren't re-used.
+pub struct HashedEngineCompileEnv<'a>(pub &'a Engine);
+
+impl std::hash::Hash for HashedEngineCompileEnv<'_> {
+    fn hash<H: std::hash::Hasher>(&self, hasher: &mut H) {
+        // Hash the compiler's state based on its target and configuration.
+        let compiler = self.0.compiler();
+        compiler.triple().hash(hasher);
+        compiler.flags().hash(hasher);
+        compiler.isa_flags().hash(hasher);
+
+        // Hash configuration state read for compilation
+        let config = self.0.config();
+        self.0.tunables().hash(hasher);
+        self.0.features().hash(hasher);
+        config.wmemcheck.hash(hasher);
+
+        // Catch accidental bugs of reusing across crate versions.
+        config.module_version.hash(hasher);
+    }
+}
diff --git a/crates/wasmtime/src/compile/runtime.rs b/crates/wasmtime/src/compile/runtime.rs
new file mode 100644
index 000000000000..57ae9c7960e9
--- /dev/null
+++ b/crates/wasmtime/src/compile/runtime.rs
@@ -0,0 +1,167 @@
+use crate::compile::HashedEngineCompileEnv;
+#[cfg(feature = "component-model")]
+use crate::component::Component;
+use crate::prelude::*;
+use crate::runtime::vm::MmapVec;
+use crate::{CodeBuilder, CodeMemory, Engine, Module};
+use object::write::WritableBuffer;
+use std::sync::Arc;
+use wasmtime_environ::{FinishedObject, ObjectBuilder, ObjectKind};
+
+impl<'a> CodeBuilder<'a> {
+    fn compile_cached<T>(
+        &self,
+        build_artifacts: fn(&Engine, &[u8], Option<&[u8]>) -> Result<(MmapVecWrapper, Option<T>)>,
+    ) -> Result<(Arc<CodeMemory>, Option<T>)> {
+        let wasm = self.get_wasm()?;
+        let dwarf_package = self.get_dwarf_package();
+
+        self.engine
+            .check_compatible_with_native_host()
+            .context("compilation settings are not compatible with the native host")?;
+
+        #[cfg(feature = "cache")]
+        {
+            let state = (
+                HashedEngineCompileEnv(self.engine),
+                &wasm,
+                &dwarf_package,
+                // Don't hash this as it's just its own "pure" function pointer.
+                NotHashed(build_artifacts),
+            );
+            let (code, info_and_types) =
+                wasmtime_cache::ModuleCacheEntry::new("wasmtime", self.engine.cache_config())
+                    .get_data_raw(
+                        &state,
+                        // Cache miss, compute the actual artifacts
+                        |(engine, wasm, dwarf_package, build_artifacts)| -> Result<_> {
+                            let (mmap, info) =
+                                (build_artifacts.0)(engine.0, wasm, dwarf_package.as_deref())?;
+                            let code = publish_mmap(mmap.0)?;
+                            Ok((code, info))
+                        },
+                        // Implementation of how to serialize artifacts
+                        |(_engine, _wasm, _, _), (code, _info_and_types)| {
+                            Some(code.mmap().to_vec())
+                        },
+                        // Cache hit, deserialize the provided artifacts
+                        |(engine, wasm, _, _), serialized_bytes| {
+                            let kind = if wasmparser::Parser::is_component(&wasm) {
+                                ObjectKind::Component
+                            } else {
+                                ObjectKind::Module
+                            };
+                            let code = engine.0.load_code_bytes(&serialized_bytes, kind).ok()?;
+                            Some((code, None))
+                        },
+                    )?;
+            return Ok((code, info_and_types));
+        }
+
+        #[cfg(not(feature = "cache"))]
+        {
+            let (mmap, info_and_types) =
+                build_artifacts(self.engine, &wasm, dwarf_package.as_deref())?;
+            let code = publish_mmap(mmap.0)?;
+            return Ok((code, info_and_types));
+        }
+
+        struct NotHashed<T>(T);
+
+        impl<T> std::hash::Hash for NotHashed<T> {
+            fn hash<H: std::hash::Hasher>(&self, _hasher: &mut H) {}
+        }
+    }
+
+    /// Same as [`CodeBuilder::compile_module_serialized`] except that a
+    /// [`Module`](crate::Module) is produced instead.
+    ///
+    /// Note that this method will cache compilations if the `cache` feature is
+    /// enabled and turned on in [`Config`](crate::Config).
+    pub fn compile_module(&self) -> Result<Module> {
+        let (code, info_and_types) = self.compile_cached(super::build_artifacts)?;
+        Module::from_parts(self.engine, code, info_and_types)
+    }
+
+    /// Same as [`CodeBuilder::compile_module`] except that it compiles a
+    /// [`Component`] instead of a module.
+    #[cfg(feature = "component-model")]
+    pub fn compile_component(&self) -> Result<Component> {
+        let (code, artifacts) = self.compile_cached(super::build_component_artifacts)?;
+        Component::from_parts(self.engine, code, artifacts)
+    }
+}
+
+fn publish_mmap(mmap: MmapVec) -> Result<Arc<CodeMemory>> {
+    let mut code = CodeMemory::new(mmap)?;
+    code.publish()?;
+    Ok(Arc::new(code))
+}
+
+pub(crate) struct MmapVecWrapper(pub MmapVec);
+
+impl FinishedObject for MmapVecWrapper {
+    fn finish_object(obj: ObjectBuilder<'_>) -> Result<Self> {
+        let mut result = ObjectMmap::default();
+        return match obj.finish(&mut result) {
+            Ok(()) => {
+                assert!(result.mmap.is_some(), "no reserve");
+                let mmap = result.mmap.expect("reserve not called");
+                assert_eq!(mmap.len(), result.len);
+                Ok(MmapVecWrapper(mmap))
+            }
+            Err(e) => match result.err.take() {
+                Some(original) => Err(original.context(e)),
+                None => Err(e.into()),
+            },
+        };
+
+        /// Helper struct to implement the `WritableBuffer` trait from the `object`
+        /// crate.
+        ///
+        /// This enables writing an object directly into an mmap'd memory so it's
+        /// immediately usable for execution after compilation. This implementation
+        /// relies on a call to `reserve` happening once up front with all the needed
+        /// data, and the mmap internally does not attempt to grow afterwards.
+        #[derive(Default)]
+        struct ObjectMmap {
+            mmap: Option<MmapVec>,
+            len: usize,
+            err: Option<Error>,
+        }
+
+        impl WritableBuffer for ObjectMmap {
+            fn len(&self) -> usize {
+                self.len
+            }
+
+            fn reserve(&mut self, additional: usize) -> Result<(), ()> {
+                assert!(self.mmap.is_none(), "cannot reserve twice");
+                self.mmap = match MmapVec::with_capacity(additional) {
+                    Ok(mmap) => Some(mmap),
+                    Err(e) => {
+                        self.err = Some(e);
+                        return Err(());
+                    }
+                };
+                Ok(())
+            }
+
+            fn resize(&mut self, new_len: usize) {
+                // Resizing always appends 0 bytes and since new mmaps start out as 0
+                // bytes we don't actually need to do anything as part of this other
+                // than update our own length.
+                if new_len <= self.len {
+                    return;
+                }
+                self.len = new_len;
+            }
+
+            fn write_bytes(&mut self, val: &[u8]) {
+                let mmap = self.mmap.as_mut().expect("write before reserve");
+                mmap[self.len..][..val.len()].copy_from_slice(val);
+                self.len += val.len();
+            }
+        }
+    }
+}
diff --git a/crates/wasmtime/src/compiler.rs b/crates/wasmtime/src/compiler.rs
deleted file mode 100644
index 33856f4b2198..000000000000
--- a/crates/wasmtime/src/compiler.rs
+++ /dev/null
@@ -1,666 +0,0 @@
-//! Wasm compilation orchestration.
-//!
-//! It works roughly like this:
-//!
-//! * We walk over the Wasm module/component and make a list of all the things
-//!   we need to compile. This is a `CompileInputs`.
-//!
-//! * The `CompileInputs::compile` method compiles each of these in parallel,
-//!   producing a `UnlinkedCompileOutputs`. This is an unlinked set of compiled
-//!   functions, bucketed by type of function.
-//!
-//! * The `UnlinkedCompileOutputs::pre_link` method re-arranges the compiled
-//!   functions into a flat list. This is the order we will place them within
-//!   the ELF file, so we must also keep track of all the functions' indices
-//!   within this list, because we will need them for resolving
-//!   relocations. These indices are kept track of in the resulting
-//!   `FunctionIndices`.
-//!
-//! * The `FunctionIndices::link_and_append_code` method appends the functions
-//!   to the given ELF file and resolves relocations. It produces an `Artifacts`
-//!   which contains the data needed at runtime to find and call Wasm
-//!   functions. It is up to the caller to serialize the relevant parts of the
-//!   `Artifacts` into the ELF file.
-
-use crate::Engine;
-use anyhow::Result;
-use std::collections::{btree_map, BTreeMap, BTreeSet};
-use std::{any::Any, collections::HashMap};
-use wasmtime_environ::{
-    Compiler, DefinedFuncIndex, FuncIndex, FunctionBodyData, ModuleTranslation, ModuleType,
-    ModuleTypes, PrimaryMap, SignatureIndex, StaticModuleIndex, Tunables, WasmFunctionInfo,
-};
-use wasmtime_jit::{CompiledFunctionInfo, CompiledModuleInfo};
-
-type CompileInput<'a> = Box<dyn FnOnce(&dyn Compiler) -> Result<CompileOutput> + Send + 'a>;
-
-/// A sortable, comparable key for a compilation output.
-///
-/// Two `u32`s to align with `cranelift_codegen::ir::UserExternalName`.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-struct CompileKey {
-    // [ kind:i4 module:i28 ]
-    namespace: u32,
-    index: u32,
-}
-
-impl CompileKey {
-    const KIND_BITS: u32 = 3;
-    const KIND_OFFSET: u32 = 32 - Self::KIND_BITS;
-    const KIND_MASK: u32 = ((1 << Self::KIND_BITS) - 1) << Self::KIND_OFFSET;
-
-    fn kind(&self) -> u32 {
-        self.namespace & Self::KIND_MASK
-    }
-
-    fn module(&self) -> StaticModuleIndex {
-        StaticModuleIndex::from_u32(self.namespace & !Self::KIND_MASK)
-    }
-
-    const WASM_FUNCTION_KIND: u32 = Self::new_kind(0);
-    const ARRAY_TO_WASM_TRAMPOLINE_KIND: u32 = Self::new_kind(1);
-    const NATIVE_TO_WASM_TRAMPOLINE_KIND: u32 = Self::new_kind(2);
-    const WASM_TO_NATIVE_TRAMPOLINE_KIND: u32 = Self::new_kind(3);
-
-    const fn new_kind(kind: u32) -> u32 {
-        assert!(kind < (1 << Self::KIND_BITS));
-        kind << Self::KIND_OFFSET
-    }
-
-    // NB: more kinds in the other `impl` block.
-
-    fn wasm_function(module: StaticModuleIndex, index: DefinedFuncIndex) -> Self {
-        debug_assert_eq!(module.as_u32() & Self::KIND_MASK, 0);
-        Self {
-            namespace: Self::WASM_FUNCTION_KIND | module.as_u32(),
-            index: index.as_u32(),
-        }
-    }
-
-    fn array_to_wasm_trampoline(module: StaticModuleIndex, index: DefinedFuncIndex) -> Self {
-        debug_assert_eq!(module.as_u32() & Self::KIND_MASK, 0);
-        Self {
-            namespace: Self::ARRAY_TO_WASM_TRAMPOLINE_KIND | module.as_u32(),
-            index: index.as_u32(),
-        }
-    }
-
-    fn native_to_wasm_trampoline(module: StaticModuleIndex, index: DefinedFuncIndex) -> Self {
-        debug_assert_eq!(module.as_u32() & Self::KIND_MASK, 0);
-        Self {
-            namespace: Self::NATIVE_TO_WASM_TRAMPOLINE_KIND | module.as_u32(),
-            index: index.as_u32(),
-        }
-    }
-
-    fn wasm_to_native_trampoline(index: SignatureIndex) -> Self {
-        Self {
-            namespace: Self::WASM_TO_NATIVE_TRAMPOLINE_KIND,
-            index: index.as_u32(),
-        }
-    }
-}
-
-#[cfg(feature = "component-model")]
-impl CompileKey {
-    const TRAMPOLINE_KIND: u32 = Self::new_kind(4);
-    const RESOURCE_DROP_WASM_TO_NATIVE_KIND: u32 = Self::new_kind(5);
-
-    fn trampoline(index: wasmtime_environ::component::TrampolineIndex) -> Self {
-        Self {
-            namespace: Self::TRAMPOLINE_KIND,
-            index: index.as_u32(),
-        }
-    }
-
-    fn resource_drop_wasm_to_native_trampoline() -> Self {
-        Self {
-            namespace: Self::RESOURCE_DROP_WASM_TO_NATIVE_KIND,
-            index: 0,
-        }
-    }
-}
-
-#[derive(Clone, Copy)]
-enum CompiledFunction<T> {
-    Function(T),
-    #[cfg(feature = "component-model")]
-    AllCallFunc(wasmtime_environ::component::AllCallFunc<T>),
-}
-
-impl<T> CompiledFunction<T> {
-    fn unwrap_function(self) -> T {
-        match self {
-            Self::Function(f) => f,
-            #[cfg(feature = "component-model")]
-            Self::AllCallFunc(_) => panic!("CompiledFunction::unwrap_function"),
-        }
-    }
-
-    #[cfg(feature = "component-model")]
-    fn unwrap_all_call_func(self) -> wasmtime_environ::component::AllCallFunc<T> {
-        match self {
-            Self::AllCallFunc(f) => f,
-            Self::Function(_) => panic!("CompiledFunction::unwrap_all_call_func"),
-        }
-    }
-}
-
-#[cfg(feature = "component-model")]
-impl<T> From<wasmtime_environ::component::AllCallFunc<T>> for CompiledFunction<T> {
-    fn from(f: wasmtime_environ::component::AllCallFunc<T>) -> Self {
-        Self::AllCallFunc(f)
-    }
-}
-
-struct CompileOutput {
-    key: CompileKey,
-    symbol: String,
-    function: CompiledFunction<Box<dyn Any + Send>>,
-    info: Option<WasmFunctionInfo>,
-}
-
-/// The collection of things we need to compile for a Wasm module or component.
-#[derive(Default)]
-pub struct CompileInputs<'a> {
-    inputs: Vec<CompileInput<'a>>,
-}
-
-impl<'a> CompileInputs<'a> {
-    fn push_input(&mut self, f: impl FnOnce(&dyn Compiler) -> Result<CompileOutput> + Send + 'a) {
-        self.inputs.push(Box::new(f));
-    }
-
-    /// Create the `CompileInputs` for a core Wasm module.
-    pub fn for_module(
-        types: &'a ModuleTypes,
-        translation: &'a ModuleTranslation<'a>,
-        functions: PrimaryMap<DefinedFuncIndex, FunctionBodyData<'a>>,
-    ) -> Self {
-        let mut ret = Self::default();
-        let module_index = StaticModuleIndex::from_u32(0);
-
-        ret.collect_inputs_in_translations(types, [(module_index, translation, functions)]);
-
-        ret
-    }
-
-    /// Create a `CompileInputs` for a component.
-    #[cfg(feature = "component-model")]
-    pub fn for_component(
-        types: &'a wasmtime_environ::component::ComponentTypes,
-        component: &'a wasmtime_environ::component::ComponentTranslation,
-        module_translations: impl IntoIterator<
-            Item = (
-                StaticModuleIndex,
-                &'a ModuleTranslation<'a>,
-                PrimaryMap<DefinedFuncIndex, FunctionBodyData<'a>>,
-            ),
-        >,
-    ) -> Self {
-        let mut ret = CompileInputs::default();
-
-        ret.collect_inputs_in_translations(types.module_types(), module_translations);
-
-        for (idx, trampoline) in component.trampolines.iter() {
-            ret.push_input(move |compiler| {
-                Ok(CompileOutput {
-                    key: CompileKey::trampoline(idx),
-                    symbol: trampoline.symbol_name(),
-                    function: compiler
-                        .component_compiler()
-                        .compile_trampoline(component, types, idx)?
-                        .into(),
-                    info: None,
-                })
-            });
-        }
-
-        // If there are any resources defined within this component, the
-        // signature for `resource.drop` is mentioned somewhere, and the
-        // wasm-to-native trampoline for `resource.drop` hasn't been created yet
-        // then insert that here. This is possibly required by destruction of
-        // resources from the embedder and otherwise won't be explicitly
-        // requested through initializers above or such.
-        if component.component.num_resources > 0 {
-            if let Some(sig) = types.find_resource_drop_signature() {
-                ret.push_input(move |compiler| {
-                    let trampoline = compiler.compile_wasm_to_native_trampoline(&types[sig])?;
-                    Ok(CompileOutput {
-                        key: CompileKey::resource_drop_wasm_to_native_trampoline(),
-                        symbol: "resource_drop_trampoline".to_string(),
-                        function: CompiledFunction::Function(trampoline),
-                        info: None,
-                    })
-                });
-            }
-        }
-
-        ret
-    }
-
-    fn collect_inputs_in_translations(
-        &mut self,
-        types: &'a ModuleTypes,
-        translations: impl IntoIterator<
-            Item = (
-                StaticModuleIndex,
-                &'a ModuleTranslation<'a>,
-                PrimaryMap<DefinedFuncIndex, FunctionBodyData<'a>>,
-            ),
-        >,
-    ) {
-        let mut sigs = BTreeSet::new();
-
-        for (module, translation, functions) in translations {
-            for (def_func_index, func_body) in functions {
-                self.push_input(move |compiler| {
-                    let func_index = translation.module.func_index(def_func_index);
-                    let (info, function) =
-                        compiler.compile_function(translation, def_func_index, func_body, types)?;
-                    Ok(CompileOutput {
-                        key: CompileKey::wasm_function(module, def_func_index),
-                        symbol: format!(
-                            "wasm[{}]::function[{}]",
-                            module.as_u32(),
-                            func_index.as_u32()
-                        ),
-                        function: CompiledFunction::Function(function),
-                        info: Some(info),
-                    })
-                });
-
-                let func_index = translation.module.func_index(def_func_index);
-                if translation.module.functions[func_index].is_escaping() {
-                    self.push_input(move |compiler| {
-                        let func_index = translation.module.func_index(def_func_index);
-                        let trampoline = compiler.compile_array_to_wasm_trampoline(
-                            translation,
-                            types,
-                            def_func_index,
-                        )?;
-                        Ok(CompileOutput {
-                            key: CompileKey::array_to_wasm_trampoline(module, def_func_index),
-                            symbol: format!(
-                                "wasm[{}]::array_to_wasm_trampoline[{}]",
-                                module.as_u32(),
-                                func_index.as_u32()
-                            ),
-                            function: CompiledFunction::Function(trampoline),
-                            info: None,
-                        })
-                    });
-
-                    self.push_input(move |compiler| {
-                        let func_index = translation.module.func_index(def_func_index);
-                        let trampoline = compiler.compile_native_to_wasm_trampoline(
-                            translation,
-                            types,
-                            def_func_index,
-                        )?;
-                        Ok(CompileOutput {
-                            key: CompileKey::native_to_wasm_trampoline(module, def_func_index),
-                            symbol: format!(
-                                "wasm[{}]::native_to_wasm_trampoline[{}]",
-                                module.as_u32(),
-                                func_index.as_u32()
-                            ),
-                            function: CompiledFunction::Function(trampoline),
-                            info: None,
-                        })
-                    });
-                }
-            }
-
-            sigs.extend(translation.module.types.iter().map(|(_, ty)| match ty {
-                ModuleType::Function(ty) => *ty,
-            }));
-        }
-
-        for signature in sigs {
-            self.push_input(move |compiler| {
-                let wasm_func_ty = &types[signature];
-                let trampoline = compiler.compile_wasm_to_native_trampoline(wasm_func_ty)?;
-                Ok(CompileOutput {
-                    key: CompileKey::wasm_to_native_trampoline(signature),
-                    symbol: format!(
-                        "signatures[{}]::wasm_to_native_trampoline",
-                        signature.as_u32()
-                    ),
-                    function: CompiledFunction::Function(trampoline),
-                    info: None,
-                })
-            });
-        }
-    }
-
-    /// Compile these `CompileInput`s (maybe in parallel) and return the
-    /// resulting `UnlinkedCompileOutput`s.
-    pub fn compile(self, engine: &Engine) -> Result<UnlinkedCompileOutputs> {
-        let compiler = engine.compiler();
-
-        // Compile each individual input in parallel.
-        let raw_outputs = engine.run_maybe_parallel(self.inputs, |f| f(compiler))?;
-
-        // Bucket the outputs by kind.
-        let mut outputs: BTreeMap<u32, Vec<CompileOutput>> = BTreeMap::new();
-        for output in raw_outputs {
-            outputs.entry(output.key.kind()).or_default().push(output);
-        }
-
-        // Assert that the elements within a bucket are all sorted as we expect
-        // them to be.
-        fn is_sorted_by_key<T, K>(items: &[T], f: impl Fn(&T) -> K) -> bool
-        where
-            K: PartialOrd,
-        {
-            items
-                .windows(2)
-                .all(|window| f(&window[0]) <= f(&window[1]))
-        }
-        debug_assert!(outputs
-            .values()
-            .all(|funcs| is_sorted_by_key(funcs, |x| x.key)));
-
-        Ok(UnlinkedCompileOutputs { outputs })
-    }
-}
-
-#[derive(Default)]
-pub struct UnlinkedCompileOutputs {
-    // A map from kind to `CompileOutput`.
-    outputs: BTreeMap<u32, Vec<CompileOutput>>,
-}
-
-impl UnlinkedCompileOutputs {
-    /// Flatten all our functions into a single list and remember each of their
-    /// indices within it.
-    pub fn pre_link(self) -> (Vec<(String, Box<dyn Any + Send>)>, FunctionIndices) {
-        // The order the functions end up within `compiled_funcs` is the order
-        // that they will be laid out in the ELF file, so try and group hot and
-        // cold functions together as best we can. However, because we bucket by
-        // kind, we shouldn't have any issues with, e.g., cold trampolines
-        // appearing in between hot Wasm functions.
-        let mut compiled_funcs = vec![];
-        let mut indices = FunctionIndices::default();
-        for x in self.outputs.into_iter().flat_map(|(_kind, xs)| xs) {
-            let index = match x.function {
-                CompiledFunction::Function(f) => {
-                    let index = compiled_funcs.len();
-                    compiled_funcs.push((x.symbol, f));
-                    CompiledFunction::Function(index)
-                }
-                #[cfg(feature = "component-model")]
-                CompiledFunction::AllCallFunc(f) => {
-                    let array_call = compiled_funcs.len();
-                    compiled_funcs.push((format!("{}_array_call", x.symbol), f.array_call));
-                    let native_call = compiled_funcs.len();
-                    compiled_funcs.push((format!("{}_native_call", x.symbol), f.native_call));
-                    let wasm_call = compiled_funcs.len();
-                    compiled_funcs.push((format!("{}_wasm_call", x.symbol), f.wasm_call));
-                    CompiledFunction::AllCallFunc(wasmtime_environ::component::AllCallFunc {
-                        array_call,
-                        native_call,
-                        wasm_call,
-                    })
-                }
-            };
-
-            if x.key.kind() == CompileKey::WASM_FUNCTION_KIND
-                || x.key.kind() == CompileKey::ARRAY_TO_WASM_TRAMPOLINE_KIND
-                || x.key.kind() == CompileKey::NATIVE_TO_WASM_TRAMPOLINE_KIND
-            {
-                indices
-                    .compiled_func_index_to_module
-                    .insert(index.unwrap_function(), x.key.module());
-                if let Some(info) = x.info {
-                    indices.wasm_function_infos.insert(x.key, info);
-                }
-            }
-
-            indices
-                .indices
-                .entry(x.key.kind())
-                .or_default()
-                .insert(x.key, index);
-        }
-        (compiled_funcs, indices)
-    }
-}
-
-#[derive(Default)]
-pub struct FunctionIndices {
-    // A reverse map from an index in `compiled_funcs` to the
-    // `StaticModuleIndex` for that function.
-    compiled_func_index_to_module: HashMap<usize, StaticModuleIndex>,
-
-    // A map from Wasm functions' compile keys to their infos.
-    wasm_function_infos: HashMap<CompileKey, WasmFunctionInfo>,
-
-    // The index of each compiled function, bucketed by compile key kind.
-    indices: BTreeMap<u32, BTreeMap<CompileKey, CompiledFunction<usize>>>,
-}
-
-impl FunctionIndices {
-    /// Link the compiled functions together, resolving relocations, and append
-    /// them to the given ELF file.
-    pub fn link_and_append_code<'a>(
-        mut self,
-        mut obj: object::write::Object<'static>,
-        tunables: &'a Tunables,
-        compiler: &dyn Compiler,
-        compiled_funcs: Vec<(String, Box<dyn Any + Send>)>,
-        translations: PrimaryMap<StaticModuleIndex, ModuleTranslation<'_>>,
-    ) -> Result<(wasmtime_jit::ObjectBuilder<'a>, Artifacts)> {
-        // Append all the functions to the ELF file.
-        //
-        // The result is a vector parallel to `compiled_funcs` where
-        // `symbol_ids_and_locs[i]` is the symbol ID and function location of
-        // `compiled_funcs[i]`.
-        let symbol_ids_and_locs = compiler.append_code(
-            &mut obj,
-            &compiled_funcs,
-            &|caller_index: usize, callee_index: FuncIndex| {
-                let module = self
-                    .compiled_func_index_to_module
-                    .get(&caller_index)
-                    .copied()
-                    .expect("should only reloc inside wasm function callers");
-                let def_func_index = translations[module]
-                    .module
-                    .defined_func_index(callee_index)
-                    .unwrap();
-                self.indices[&CompileKey::WASM_FUNCTION_KIND]
-                    [&CompileKey::wasm_function(module, def_func_index)]
-                    .unwrap_function()
-            },
-        )?;
-
-        // If requested, generate and add DWARF information.
-        if tunables.generate_native_debuginfo &&
-            // We can only add DWARF once. Supporting DWARF for components of
-            // multiple Wasm modules will require merging the DWARF sections
-            // together.
-            translations.len() == 1
-        {
-            for (module, translation) in &translations {
-                let funcs: PrimaryMap<_, _> = self
-                    .indices
-                    .get(&CompileKey::WASM_FUNCTION_KIND)
-                    .map(|xs| {
-                        xs.range(
-                            CompileKey::wasm_function(module, DefinedFuncIndex::from_u32(0))
-                                ..=CompileKey::wasm_function(
-                                    module,
-                                    DefinedFuncIndex::from_u32(u32::MAX - 1),
-                                ),
-                        )
-                    })
-                    .into_iter()
-                    .flat_map(|x| x)
-                    .map(|(_, x)| {
-                        let i = x.unwrap_function();
-                        (symbol_ids_and_locs[i].0, &*compiled_funcs[i].1)
-                    })
-                    .collect();
-                if !funcs.is_empty() {
-                    compiler.append_dwarf(&mut obj, translation, &funcs)?;
-                }
-            }
-        }
-
-        let mut obj = wasmtime_jit::ObjectBuilder::new(obj, tunables);
-        let mut artifacts = Artifacts::default();
-
-        // Finally, build our binary artifacts that map things like `FuncIndex`
-        // to a function location and all of that using the indices we saved
-        // earlier and the function locations we just received after appending
-        // the code.
-
-        let mut wasm_functions = self
-            .indices
-            .remove(&CompileKey::WASM_FUNCTION_KIND)
-            .unwrap_or_default()
-            .into_iter()
-            .peekable();
-
-        fn wasm_functions_for_module(
-            wasm_functions: &mut std::iter::Peekable<
-                btree_map::IntoIter<CompileKey, CompiledFunction<usize>>,
-            >,
-            module: StaticModuleIndex,
-        ) -> impl Iterator<Item = (CompileKey, CompiledFunction<usize>)> + '_ {
-            std::iter::from_fn(move || {
-                let (key, _) = wasm_functions.peek()?;
-                if key.module() == module {
-                    wasm_functions.next()
-                } else {
-                    None
-                }
-            })
-        }
-
-        let mut array_to_wasm_trampolines = self
-            .indices
-            .remove(&CompileKey::ARRAY_TO_WASM_TRAMPOLINE_KIND)
-            .unwrap_or_default();
-
-        let mut native_to_wasm_trampolines = self
-            .indices
-            .remove(&CompileKey::NATIVE_TO_WASM_TRAMPOLINE_KIND)
-            .unwrap_or_default();
-
-        // NB: unlike the above maps this is not emptied out during iteration
-        // since each module may reach into different portions of this map.
-        let wasm_to_native_trampolines = self
-            .indices
-            .remove(&CompileKey::WASM_TO_NATIVE_TRAMPOLINE_KIND)
-            .unwrap_or_default();
-
-        artifacts.modules = translations
-            .into_iter()
-            .map(|(module, translation)| {
-                let funcs: PrimaryMap<DefinedFuncIndex, CompiledFunctionInfo> =
-                    wasm_functions_for_module(&mut wasm_functions, module)
-                        .map(|(key, wasm_func_index)| {
-                            let wasm_func_index = wasm_func_index.unwrap_function();
-                            let wasm_func_loc = symbol_ids_and_locs[wasm_func_index].1;
-                            let wasm_func_info = self.wasm_function_infos.remove(&key).unwrap();
-
-                            let array_to_wasm_trampoline = array_to_wasm_trampolines
-                                .remove(&CompileKey::array_to_wasm_trampoline(
-                                    key.module(),
-                                    DefinedFuncIndex::from_u32(key.index),
-                                ))
-                                .map(|x| symbol_ids_and_locs[x.unwrap_function()].1);
-
-                            let native_to_wasm_trampoline = native_to_wasm_trampolines
-                                .remove(&CompileKey::native_to_wasm_trampoline(
-                                    key.module(),
-                                    DefinedFuncIndex::from_u32(key.index),
-                                ))
-                                .map(|x| symbol_ids_and_locs[x.unwrap_function()].1);
-
-                            CompiledFunctionInfo::new(
-                                wasm_func_info,
-                                wasm_func_loc,
-                                array_to_wasm_trampoline,
-                                native_to_wasm_trampoline,
-                            )
-                        })
-                        .collect();
-
-                let unique_and_sorted_sigs = translation
-                    .module
-                    .types
-                    .iter()
-                    .map(|(_, ty)| match ty {
-                        ModuleType::Function(ty) => *ty,
-                    })
-                    .collect::<BTreeSet<_>>();
-                let wasm_to_native_trampolines = unique_and_sorted_sigs
-                    .iter()
-                    .map(|idx| {
-                        let key = CompileKey::wasm_to_native_trampoline(*idx);
-                        let compiled = wasm_to_native_trampolines[&key];
-                        (*idx, symbol_ids_and_locs[compiled.unwrap_function()].1)
-                    })
-                    .collect();
-
-                obj.append(translation, funcs, wasm_to_native_trampolines)
-            })
-            .collect::<Result<PrimaryMap<_, _>>>()?;
-
-        #[cfg(feature = "component-model")]
-        {
-            artifacts.trampolines = self
-                .indices
-                .remove(&CompileKey::TRAMPOLINE_KIND)
-                .unwrap_or_default()
-                .into_iter()
-                .map(|(_id, x)| x.unwrap_all_call_func().map(|i| symbol_ids_and_locs[i].1))
-                .collect();
-            let map = self
-                .indices
-                .remove(&CompileKey::RESOURCE_DROP_WASM_TO_NATIVE_KIND)
-                .unwrap_or_default();
-            assert!(map.len() <= 1);
-            artifacts.resource_drop_wasm_to_native_trampoline = map
-                .into_iter()
-                .next()
-                .map(|(_id, x)| symbol_ids_and_locs[x.unwrap_function()].1);
-        }
-
-        debug_assert!(
-            self.indices.is_empty(),
-            "Should have processed all compile outputs"
-        );
-
-        Ok((obj, artifacts))
-    }
-}
-
-/// The artifacts necessary for finding and calling Wasm functions at runtime,
-/// to be serialized into an ELF file.
-#[derive(Default)]
-pub struct Artifacts {
-    pub modules: PrimaryMap<StaticModuleIndex, CompiledModuleInfo>,
-    #[cfg(feature = "component-model")]
-    pub trampolines: PrimaryMap<
-        wasmtime_environ::component::TrampolineIndex,
-        wasmtime_environ::component::AllCallFunc<wasmtime_environ::FunctionLoc>,
-    >,
-    #[cfg(feature = "component-model")]
-    pub resource_drop_wasm_to_native_trampoline: Option<wasmtime_environ::FunctionLoc>,
-}
-
-impl Artifacts {
-    /// Assuming this compilation was for a single core Wasm module, get the
-    /// resulting `CompiledModuleInfo`.
-    pub fn unwrap_as_module_info(self) -> CompiledModuleInfo {
-        assert_eq!(self.modules.len(), 1);
-        #[cfg(feature = "component-model")]
-        assert!(self.trampolines.is_empty());
-        self.modules.into_iter().next().unwrap().1
-    }
-}
diff --git a/crates/wasmtime/src/component/component.rs b/crates/wasmtime/src/component/component.rs
deleted file mode 100644
index 013f93bd79e0..000000000000
--- a/crates/wasmtime/src/component/component.rs
+++ /dev/null
@@ -1,475 +0,0 @@
-use crate::code::CodeObject;
-use crate::signatures::SignatureCollection;
-use crate::{Engine, Module, ResourcesRequired};
-use anyhow::{bail, Context, Result};
-use serde_derive::{Deserialize, Serialize};
-use std::fs;
-use std::mem;
-use std::path::Path;
-use std::ptr::NonNull;
-use std::sync::Arc;
-use wasmtime_environ::component::{
-    AllCallFunc, ComponentTypes, GlobalInitializer, InstantiateModule, StaticModuleIndex,
-    TrampolineIndex, Translator, VMComponentOffsets,
-};
-use wasmtime_environ::{FunctionLoc, HostPtr, ObjectKind, PrimaryMap, ScopeVec};
-use wasmtime_jit::{CodeMemory, CompiledModuleInfo};
-use wasmtime_runtime::component::ComponentRuntimeInfo;
-use wasmtime_runtime::{
-    MmapVec, VMArrayCallFunction, VMFuncRef, VMFunctionBody, VMNativeCallFunction,
-    VMWasmCallFunction,
-};
-
-/// A compiled WebAssembly Component.
-//
-// FIXME: need to write more docs here.
-#[derive(Clone)]
-pub struct Component {
-    inner: Arc<ComponentInner>,
-}
-
-struct ComponentInner {
-    /// Core wasm modules that the component defined internally, indexed by the
-    /// compile-time-assigned `ModuleUpvarIndex`.
-    static_modules: PrimaryMap<StaticModuleIndex, Module>,
-
-    /// Code-related information such as the compiled artifact, type
-    /// information, etc.
-    ///
-    /// Note that the `Arc` here is used to share this allocation with internal
-    /// modules.
-    code: Arc<CodeObject>,
-
-    /// Metadata produced during compilation.
-    info: CompiledComponentInfo,
-}
-
-#[derive(Serialize, Deserialize)]
-struct CompiledComponentInfo {
-    /// Type information calculated during translation about this component.
-    component: wasmtime_environ::component::Component,
-
-    /// Where lowered function trampolines are located within the `text`
-    /// section of `code_memory`.
-    ///
-    /// These are the
-    ///
-    /// 1. Wasm-call,
-    /// 2. array-call, and
-    /// 3. native-call
-    ///
-    /// function pointers that end up in a `VMFuncRef` for each
-    /// lowering.
-    trampolines: PrimaryMap<TrampolineIndex, AllCallFunc<FunctionLoc>>,
-
-    /// The location of the wasm-to-native trampoline for the `resource.drop`
-    /// intrinsic.
-    resource_drop_wasm_to_native_trampoline: Option<FunctionLoc>,
-}
-
-pub(crate) struct AllCallFuncPointers {
-    pub wasm_call: NonNull<VMWasmCallFunction>,
-    pub array_call: VMArrayCallFunction,
-    pub native_call: NonNull<VMNativeCallFunction>,
-}
-
-#[derive(Serialize, Deserialize)]
-pub(crate) struct ComponentArtifacts {
-    info: CompiledComponentInfo,
-    types: ComponentTypes,
-    static_modules: PrimaryMap<StaticModuleIndex, CompiledModuleInfo>,
-}
-
-impl Component {
-    /// Compiles a new WebAssembly component from the in-memory wasm image
-    /// provided.
-    //
-    // FIXME: need to write more docs here.
-    #[cfg(any(feature = "cranelift", feature = "winch"))]
-    #[cfg_attr(nightlydoc, doc(cfg(any(feature = "cranelift", feature = "winch"))))]
-    pub fn new(engine: &Engine, bytes: impl AsRef<[u8]>) -> Result<Component> {
-        let bytes = bytes.as_ref();
-        #[cfg(feature = "wat")]
-        let bytes = wat::parse_bytes(bytes)?;
-        Component::from_binary(engine, &bytes)
-    }
-
-    /// Compiles a new WebAssembly component from a wasm file on disk pointed to
-    /// by `file`.
-    //
-    // FIXME: need to write more docs here.
-    #[cfg(any(feature = "cranelift", feature = "winch"))]
-    #[cfg_attr(nightlydoc, doc(cfg(any(feature = "cranelift", feature = "winch"))))]
-    pub fn from_file(engine: &Engine, file: impl AsRef<Path>) -> Result<Component> {
-        match Self::new(
-            engine,
-            &fs::read(&file).with_context(|| "failed to read input file")?,
-        ) {
-            Ok(m) => Ok(m),
-            Err(e) => {
-                cfg_if::cfg_if! {
-                    if #[cfg(feature = "wat")] {
-                        let mut e = e.downcast::<wat::Error>()?;
-                        e.set_path(file);
-                        bail!(e)
-                    } else {
-                        Err(e)
-                    }
-                }
-            }
-        }
-    }
-
-    /// Compiles a new WebAssembly component from the in-memory wasm image
-    /// provided.
-    //
-    // FIXME: need to write more docs here.
-    #[cfg(any(feature = "cranelift", feature = "winch"))]
-    #[cfg_attr(nightlydoc, doc(cfg(any(feature = "cranelift", feature = "winch"))))]
-    pub fn from_binary(engine: &Engine, binary: &[u8]) -> Result<Component> {
-        engine
-            .check_compatible_with_native_host()
-            .context("compilation settings are not compatible with the native host")?;
-
-        let (mmap, artifacts) = Component::build_artifacts(engine, binary)?;
-        let mut code_memory = CodeMemory::new(mmap)?;
-        code_memory.publish()?;
-        Component::from_parts(engine, Arc::new(code_memory), Some(artifacts))
-    }
-
-    /// Same as [`Module::deserialize`], but for components.
-    ///
-    /// Note that the file referenced here must contain contents previously
-    /// produced by [`Engine::precompile_component`] or
-    /// [`Component::serialize`].
-    ///
-    /// For more information see the [`Module::deserialize`] method.
-    ///
-    /// [`Module::deserialize`]: crate::Module::deserialize
-    pub unsafe fn deserialize(engine: &Engine, bytes: impl AsRef<[u8]>) -> Result<Component> {
-        let code = engine.load_code_bytes(bytes.as_ref(), ObjectKind::Component)?;
-        Component::from_parts(engine, code, None)
-    }
-
-    /// Same as [`Module::deserialize_file`], but for components.
-    ///
-    /// For more information see the [`Component::deserialize`] and
-    /// [`Module::deserialize_file`] methods.
-    ///
-    /// [`Module::deserialize_file`]: crate::Module::deserialize_file
-    pub unsafe fn deserialize_file(engine: &Engine, path: impl AsRef<Path>) -> Result<Component> {
-        let code = engine.load_code_file(path.as_ref(), ObjectKind::Component)?;
-        Component::from_parts(engine, code, None)
-    }
-
-    /// Performs the compilation phase for a component, translating and
-    /// validating the provided wasm binary to machine code.
-    ///
-    /// This method will compile all nested core wasm binaries in addition to
-    /// any necessary extra functions required for operation with components.
-    /// The output artifact here is the serialized object file contained within
-    /// an owned mmap along with metadata about the compilation itself.
-    #[cfg(any(feature = "cranelift", feature = "winch"))]
-    pub(crate) fn build_artifacts(
-        engine: &Engine,
-        binary: &[u8],
-    ) -> Result<(MmapVec, ComponentArtifacts)> {
-        use crate::compiler::CompileInputs;
-
-        let tunables = &engine.config().tunables;
-        let compiler = engine.compiler();
-
-        let scope = ScopeVec::new();
-        let mut validator =
-            wasmparser::Validator::new_with_features(engine.config().features.clone());
-        let mut types = Default::default();
-        let (component, mut module_translations) =
-            Translator::new(tunables, &mut validator, &mut types, &scope)
-                .translate(binary)
-                .context("failed to parse WebAssembly module")?;
-        let types = types.finish();
-
-        let compile_inputs = CompileInputs::for_component(
-            &types,
-            &component,
-            module_translations.iter_mut().map(|(i, translation)| {
-                let functions = mem::take(&mut translation.function_body_inputs);
-                (i, &*translation, functions)
-            }),
-        );
-        let unlinked_compile_outputs = compile_inputs.compile(&engine)?;
-        let (compiled_funcs, function_indices) = unlinked_compile_outputs.pre_link();
-
-        let mut object = compiler.object(ObjectKind::Component)?;
-        engine.append_compiler_info(&mut object);
-        engine.append_bti(&mut object);
-
-        let (mut object, compilation_artifacts) = function_indices.link_and_append_code(
-            object,
-            &engine.config().tunables,
-            compiler,
-            compiled_funcs,
-            module_translations,
-        )?;
-
-        let info = CompiledComponentInfo {
-            component: component.component,
-            trampolines: compilation_artifacts.trampolines,
-            resource_drop_wasm_to_native_trampoline: compilation_artifacts
-                .resource_drop_wasm_to_native_trampoline,
-        };
-        let artifacts = ComponentArtifacts {
-            info,
-            types,
-            static_modules: compilation_artifacts.modules,
-        };
-        object.serialize_info(&artifacts);
-
-        let mmap = object.finish()?;
-        Ok((mmap, artifacts))
-    }
-
-    /// Final assembly step for a component from its in-memory representation.
-    ///
-    /// If the `artifacts` are specified as `None` here then they will be
-    /// deserialized from `code_memory`.
-    fn from_parts(
-        engine: &Engine,
-        code_memory: Arc<CodeMemory>,
-        artifacts: Option<ComponentArtifacts>,
-    ) -> Result<Component> {
-        let ComponentArtifacts {
-            info,
-            types,
-            static_modules,
-        } = match artifacts {
-            Some(artifacts) => artifacts,
-            None => bincode::deserialize(code_memory.wasmtime_info())?,
-        };
-
-        // Validate that the component can be used with the current instance
-        // allocator.
-        engine.allocator().validate_component(
-            &info.component,
-            &VMComponentOffsets::new(HostPtr, &info.component),
-            &|module_index| &static_modules[module_index].module,
-        )?;
-
-        // Create a signature registration with the `Engine` for all trampolines
-        // and core wasm types found within this component, both for the
-        // component and for all included core wasm modules.
-        let signatures =
-            SignatureCollection::new_for_module(engine.signatures(), types.module_types());
-
-        // Assemble the `CodeObject` artifact which is shared by all core wasm
-        // modules as well as the final component.
-        let types = Arc::new(types);
-        let code = Arc::new(CodeObject::new(code_memory, signatures, types.into()));
-
-        // Convert all information about static core wasm modules into actual
-        // `Module` instances by converting each `CompiledModuleInfo`, the
-        // `types` type information, and the code memory to a runtime object.
-        let static_modules = static_modules
-            .into_iter()
-            .map(|(_, info)| Module::from_parts_raw(engine, code.clone(), info, false))
-            .collect::<Result<_>>()?;
-
-        Ok(Component {
-            inner: Arc::new(ComponentInner {
-                static_modules,
-                code,
-                info,
-            }),
-        })
-    }
-
-    pub(crate) fn env_component(&self) -> &wasmtime_environ::component::Component {
-        &self.inner.info.component
-    }
-
-    pub(crate) fn static_module(&self, idx: StaticModuleIndex) -> &Module {
-        &self.inner.static_modules[idx]
-    }
-
-    #[inline]
-    pub(crate) fn types(&self) -> &Arc<ComponentTypes> {
-        self.inner.component_types()
-    }
-
-    pub(crate) fn signatures(&self) -> &SignatureCollection {
-        self.inner.code.signatures()
-    }
-
-    pub(crate) fn text(&self) -> &[u8] {
-        self.inner.code.code_memory().text()
-    }
-
-    pub(crate) fn trampoline_ptrs(&self, index: TrampolineIndex) -> AllCallFuncPointers {
-        let AllCallFunc {
-            wasm_call,
-            array_call,
-            native_call,
-        } = &self.inner.info.trampolines[index];
-        AllCallFuncPointers {
-            wasm_call: self.func(wasm_call).cast(),
-            array_call: unsafe {
-                mem::transmute::<NonNull<VMFunctionBody>, VMArrayCallFunction>(
-                    self.func(array_call),
-                )
-            },
-            native_call: self.func(native_call).cast(),
-        }
-    }
-
-    fn func(&self, loc: &FunctionLoc) -> NonNull<VMFunctionBody> {
-        let text = self.text();
-        let trampoline = &text[loc.start as usize..][..loc.length as usize];
-        NonNull::new(trampoline.as_ptr() as *mut VMFunctionBody).unwrap()
-    }
-
-    pub(crate) fn code_object(&self) -> &Arc<CodeObject> {
-        &self.inner.code
-    }
-
-    /// Same as [`Module::serialize`], except for a component.
-    ///
-    /// Note that the artifact produced here must be passed to
-    /// [`Component::deserialize`] and is not compatible for use with
-    /// [`Module`].
-    ///
-    /// [`Module::serialize`]: crate::Module::serialize
-    /// [`Module`]: crate::Module
-    pub fn serialize(&self) -> Result<Vec<u8>> {
-        Ok(self.code_object().code_memory().mmap().to_vec())
-    }
-
-    pub(crate) fn runtime_info(&self) -> Arc<dyn ComponentRuntimeInfo> {
-        self.inner.clone()
-    }
-
-    /// Creates a new `VMFuncRef` with all fields filled out for the destructor
-    /// specified.
-    ///
-    /// The `dtor`'s own `VMFuncRef` won't have `wasm_call` filled out but this
-    /// component may have `resource_drop_wasm_to_native_trampoline` filled out
-    /// if necessary in which case it's filled in here.
-    pub(crate) fn resource_drop_func_ref(&self, dtor: &crate::func::HostFunc) -> VMFuncRef {
-        // Host functions never have their `wasm_call` filled in at this time.
-        assert!(dtor.func_ref().wasm_call.is_none());
-
-        // Note that if `resource_drop_wasm_to_native_trampoline` is not present
-        // then this can't be called by the component, so it's ok to leave it
-        // blank.
-        let wasm_call = self
-            .inner
-            .info
-            .resource_drop_wasm_to_native_trampoline
-            .as_ref()
-            .map(|i| self.func(i).cast());
-        VMFuncRef {
-            wasm_call,
-            ..*dtor.func_ref()
-        }
-    }
-
-    /// Returns a summary of the resources required to instantiate this
-    /// [`Component`][crate::component::Component].
-    ///
-    /// Note that when a component imports and instantiates another component or
-    /// core module, we cannot determine ahead of time how many resources
-    /// instantiating this component will require, and therefore this method
-    /// will return `None` in these scenarios.
-    ///
-    /// Potential uses of the returned information:
-    ///
-    /// * Determining whether your pooling allocator configuration supports
-    ///   instantiating this component.
-    ///
-    /// * Deciding how many of which `Component` you want to instantiate within
-    ///   a fixed amount of resources, e.g. determining whether to create 5
-    ///   instances of component X or 10 instances of component Y.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # fn main() -> wasmtime::Result<()> {
-    /// use wasmtime::{Config, Engine, component::Component};
-    ///
-    /// let mut config = Config::new();
-    /// config.wasm_multi_memory(true);
-    /// config.wasm_component_model(true);
-    /// let engine = Engine::new(&config)?;
-    ///
-    /// let component = Component::new(&engine, &r#"
-    ///     (component
-    ///         ;; Define a core module that uses two memories.
-    ///         (core module $m
-    ///             (memory 1)
-    ///             (memory 6)
-    ///         )
-    ///
-    ///         ;; Instantiate that core module three times.
-    ///         (core instance $i1 (instantiate (module $m)))
-    ///         (core instance $i2 (instantiate (module $m)))
-    ///         (core instance $i3 (instantiate (module $m)))
-    ///     )
-    /// "#)?;
-    ///
-    /// let resources = component.resources_required()
-    ///     .expect("this component does not import any core modules or instances");
-    ///
-    /// // Instantiating the component will require allocating two memories per
-    /// // core instance, and there are three instances, so six total memories.
-    /// assert_eq!(resources.num_memories, 6);
-    /// assert_eq!(resources.max_initial_memory_size, Some(6));
-    ///
-    /// // The component doesn't need any tables.
-    /// assert_eq!(resources.num_tables, 0);
-    /// assert_eq!(resources.max_initial_table_size, None);
-    /// # Ok(()) }
-    /// ```
-    pub fn resources_required(&self) -> Option<ResourcesRequired> {
-        let mut resources = ResourcesRequired {
-            num_memories: 0,
-            max_initial_memory_size: None,
-            num_tables: 0,
-            max_initial_table_size: None,
-        };
-        for init in &self.env_component().initializers {
-            match init {
-                GlobalInitializer::InstantiateModule(inst) => match inst {
-                    InstantiateModule::Static(index, _) => {
-                        let module = self.static_module(*index);
-                        resources.add(&module.resources_required());
-                    }
-                    InstantiateModule::Import(_, _) => {
-                        // We can't statically determine the resources required
-                        // to instantiate this component.
-                        return None;
-                    }
-                },
-                GlobalInitializer::LowerImport { .. }
-                | GlobalInitializer::ExtractMemory(_)
-                | GlobalInitializer::ExtractRealloc(_)
-                | GlobalInitializer::ExtractPostReturn(_)
-                | GlobalInitializer::Resource(_) => {}
-            }
-        }
-        Some(resources)
-    }
-}
-
-impl ComponentRuntimeInfo for ComponentInner {
-    fn component(&self) -> &wasmtime_environ::component::Component {
-        &self.info.component
-    }
-
-    fn component_types(&self) -> &Arc<ComponentTypes> {
-        match self.code.types() {
-            crate::code::Types::Component(types) => types,
-            // The only creator of a `Component` is itself which uses the other
-            // variant, so this shouldn't be possible.
-            crate::code::Types::Module(_) => unreachable!(),
-        }
-    }
-}
diff --git a/crates/wasmtime/src/component/func.rs b/crates/wasmtime/src/component/func.rs
deleted file mode 100644
index 0b69aff34d8c..000000000000
--- a/crates/wasmtime/src/component/func.rs
+++ /dev/null
@@ -1,720 +0,0 @@
-use crate::component::instance::{Instance, InstanceData};
-use crate::component::storage::storage_as_slice;
-use crate::component::types::Type;
-use crate::component::values::Val;
-use crate::store::{StoreOpaque, Stored};
-use crate::{AsContext, AsContextMut, StoreContextMut, ValRaw};
-use anyhow::{bail, Context, Result};
-use std::mem::{self, MaybeUninit};
-use std::ptr::NonNull;
-use std::sync::Arc;
-use wasmtime_environ::component::{
-    CanonicalOptions, ComponentTypes, CoreDef, InterfaceType, RuntimeComponentInstanceIndex,
-    TypeFuncIndex, TypeTuple, MAX_FLAT_PARAMS, MAX_FLAT_RESULTS,
-};
-use wasmtime_runtime::component::ResourceTables;
-use wasmtime_runtime::{Export, ExportFunction};
-
-/// A helper macro to safely map `MaybeUninit<T>` to `MaybeUninit<U>` where `U`
-/// is a field projection within `T`.
-///
-/// This is intended to be invoked as:
-///
-/// ```ignore
-/// struct MyType {
-///     field: u32,
-/// }
-///
-/// let initial: &mut MaybeUninit<MyType> = ...;
-/// let field: &mut MaybeUninit<u32> = map_maybe_uninit!(initial.field);
-/// ```
-///
-/// Note that array accesses are also supported:
-///
-/// ```ignore
-///
-/// let initial: &mut MaybeUninit<[u32; 2]> = ...;
-/// let element: &mut MaybeUninit<u32> = map_maybe_uninit!(initial[1]);
-/// ```
-#[doc(hidden)]
-#[macro_export]
-macro_rules! map_maybe_uninit {
-    ($maybe_uninit:ident $($field:tt)*) => ({
-        #[allow(unused_unsafe)]
-        {
-            unsafe {
-                use $crate::component::__internal::MaybeUninitExt;
-
-                let m: &mut std::mem::MaybeUninit<_> = $maybe_uninit;
-                // Note the usage of `addr_of_mut!` here which is an attempt to "stay
-                // safe" here where we never accidentally create `&mut T` where `T` is
-                // actually uninitialized, hopefully appeasing the Rust unsafe
-                // guidelines gods.
-                m.map(|p| std::ptr::addr_of_mut!((*p)$($field)*))
-            }
-        }
-    })
-}
-
-#[doc(hidden)]
-pub trait MaybeUninitExt<T> {
-    /// Maps `MaybeUninit<T>` to `MaybeUninit<U>` using the closure provided.
-    ///
-    /// Note that this is `unsafe` as there is no guarantee that `U` comes from
-    /// `T`.
-    unsafe fn map<U>(&mut self, f: impl FnOnce(*mut T) -> *mut U) -> &mut MaybeUninit<U>;
-}
-
-impl<T> MaybeUninitExt<T> for MaybeUninit<T> {
-    unsafe fn map<U>(&mut self, f: impl FnOnce(*mut T) -> *mut U) -> &mut MaybeUninit<U> {
-        let new_ptr = f(self.as_mut_ptr());
-        std::mem::transmute::<*mut U, &mut MaybeUninit<U>>(new_ptr)
-    }
-}
-
-mod host;
-mod options;
-mod typed;
-pub use self::host::*;
-pub use self::options::*;
-pub use self::typed::*;
-
-#[repr(C)]
-union ParamsAndResults<Params: Copy, Return: Copy> {
-    params: Params,
-    ret: Return,
-}
-
-/// A WebAssembly component function.
-//
-// FIXME: write more docs here
-#[derive(Copy, Clone, Debug)]
-pub struct Func(Stored<FuncData>);
-
-#[doc(hidden)]
-pub struct FuncData {
-    export: ExportFunction,
-    ty: TypeFuncIndex,
-    types: Arc<ComponentTypes>,
-    options: Options,
-    instance: Instance,
-    component_instance: RuntimeComponentInstanceIndex,
-    post_return: Option<ExportFunction>,
-    post_return_arg: Option<ValRaw>,
-}
-
-impl Func {
-    pub(crate) fn from_lifted_func(
-        store: &mut StoreOpaque,
-        instance: &Instance,
-        data: &InstanceData,
-        ty: TypeFuncIndex,
-        func: &CoreDef,
-        options: &CanonicalOptions,
-    ) -> Func {
-        let export = match data.lookup_def(store, func) {
-            Export::Function(f) => f,
-            _ => unreachable!(),
-        };
-        let memory = options
-            .memory
-            .map(|i| NonNull::new(data.instance().runtime_memory(i)).unwrap());
-        let realloc = options.realloc.map(|i| data.instance().runtime_realloc(i));
-        let post_return = options.post_return.map(|i| {
-            let func_ref = data.instance().runtime_post_return(i);
-            ExportFunction { func_ref }
-        });
-        let component_instance = options.instance;
-        let options = unsafe { Options::new(store.id(), memory, realloc, options.string_encoding) };
-        Func(store.store_data_mut().insert(FuncData {
-            export,
-            options,
-            ty,
-            types: data.component_types().clone(),
-            instance: *instance,
-            component_instance,
-            post_return,
-            post_return_arg: None,
-        }))
-    }
-
-    /// Attempt to cast this [`Func`] to a statically typed [`TypedFunc`] with
-    /// the provided `Params` and `Return`.
-    ///
-    /// This function will perform a type-check at runtime that the [`Func`]
-    /// takes `Params` as parameters and returns `Return`. If the type-check
-    /// passes then a [`TypedFunc`] will be returned which can be used to
-    /// invoke the function in an efficient, statically-typed, and ergonomic
-    /// manner.
-    ///
-    /// The `Params` type parameter here is a tuple of the parameters to the
-    /// function. A function which takes no arguments should use `()`, a
-    /// function with one argument should use `(T,)`, etc. Note that all
-    /// `Params` must also implement the [`Lower`] trait since they're going tin
-    /// to wasm.
-    ///
-    /// The `Return` type parameter is the return value of this function. A
-    /// return value of `()` means that there's no return (similar to a Rust
-    /// unit return) and otherwise a type `T` can be specified. Note that the
-    /// `Return` must also implement the [`Lift`] trait since it's coming from
-    /// wasm.
-    ///
-    /// Types specified here must implement the [`ComponentType`] trait. This
-    /// trait is implemented for built-in types to Rust such as integer
-    /// primitives, floats, `Option<T>`, `Result<T, E>`, strings, `Vec<T>`, and
-    /// more. As parameters you'll be passing native Rust types.
-    ///
-    /// # Errors
-    ///
-    /// If the function does not actually take `Params` as its parameters or
-    /// return `Return` then an error will be returned.
-    ///
-    /// # Panics
-    ///
-    /// This function will panic if `self` is not owned by the `store`
-    /// specified.
-    ///
-    /// # Examples
-    ///
-    /// Calling a function which takes no parameters and has no return value:
-    ///
-    /// ```
-    /// # use wasmtime::component::Func;
-    /// # use wasmtime::Store;
-    /// # fn foo(func: &Func, store: &mut Store<()>) -> anyhow::Result<()> {
-    /// let typed = func.typed::<(), ()>(&store)?;
-    /// typed.call(store, ())?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    ///
-    /// Calling a function which takes one string parameter and returns a
-    /// string:
-    ///
-    /// ```
-    /// # use wasmtime::component::Func;
-    /// # use wasmtime::Store;
-    /// # fn foo(func: &Func, mut store: Store<()>) -> anyhow::Result<()> {
-    /// let typed = func.typed::<(&str,), (String,)>(&store)?;
-    /// let ret = typed.call(&mut store, ("Hello, ",))?.0;
-    /// println!("returned string was: {}", ret);
-    /// # Ok(())
-    /// # }
-    /// ```
-    ///
-    /// Calling a function which takes multiple parameters and returns a boolean:
-    ///
-    /// ```
-    /// # use wasmtime::component::Func;
-    /// # use wasmtime::Store;
-    /// # fn foo(func: &Func, mut store: Store<()>) -> anyhow::Result<()> {
-    /// let typed = func.typed::<(u32, Option<&str>, &[u8]), (bool,)>(&store)?;
-    /// let ok: bool = typed.call(&mut store, (1, Some("hello"), b"bytes!"))?.0;
-    /// println!("return value was: {ok}");
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn typed<Params, Return>(&self, store: impl AsContext) -> Result<TypedFunc<Params, Return>>
-    where
-        Params: ComponentNamedList + Lower,
-        Return: ComponentNamedList + Lift,
-    {
-        self._typed(store.as_context().0, None)
-    }
-
-    pub(crate) fn _typed<Params, Return>(
-        &self,
-        store: &StoreOpaque,
-        instance: Option<&InstanceData>,
-    ) -> Result<TypedFunc<Params, Return>>
-    where
-        Params: ComponentNamedList + Lower,
-        Return: ComponentNamedList + Lift,
-    {
-        self.typecheck::<Params, Return>(store, instance)?;
-        unsafe { Ok(TypedFunc::new_unchecked(*self)) }
-    }
-
-    fn typecheck<Params, Return>(
-        &self,
-        store: &StoreOpaque,
-        instance: Option<&InstanceData>,
-    ) -> Result<()>
-    where
-        Params: ComponentNamedList + Lower,
-        Return: ComponentNamedList + Lift,
-    {
-        let data = &store[self.0];
-        let cx = instance
-            .unwrap_or_else(|| &store[data.instance.0].as_ref().unwrap())
-            .ty();
-        let ty = &cx.types[data.ty];
-
-        Params::typecheck(&InterfaceType::Tuple(ty.params), &cx)
-            .context("type mismatch with parameters")?;
-        Return::typecheck(&InterfaceType::Tuple(ty.results), &cx)
-            .context("type mismatch with results")?;
-
-        Ok(())
-    }
-
-    /// Get the parameter types for this function.
-    pub fn params(&self, store: impl AsContext) -> Box<[Type]> {
-        let store = store.as_context();
-        let data = &store[self.0];
-        let instance = store[data.instance.0].as_ref().unwrap();
-        data.types[data.types[data.ty].params]
-            .types
-            .iter()
-            .map(|ty| Type::from(ty, &instance.ty()))
-            .collect()
-    }
-
-    /// Get the result types for this function.
-    pub fn results(&self, store: impl AsContext) -> Box<[Type]> {
-        let store = store.as_context();
-        let data = &store[self.0];
-        let instance = store[data.instance.0].as_ref().unwrap();
-        data.types[data.types[data.ty].results]
-            .types
-            .iter()
-            .map(|ty| Type::from(ty, &instance.ty()))
-            .collect()
-    }
-
-    /// Invokes this function with the `params` given and returns the result.
-    ///
-    /// The `params` here must match the type signature of this `Func`, or this will return an error. If a trap
-    /// occurs while executing this function, then an error will also be returned.
-    // TODO: say more -- most of the docs for `TypedFunc::call` apply here, too
-    //
-    // # Panics
-    //
-    // Panics if this is called on a function in an asyncronous store. This only works
-    // with functions defined within a synchronous store. Also panics if `store`
-    // does not own this function.
-    pub fn call(
-        &self,
-        mut store: impl AsContextMut,
-        params: &[Val],
-        results: &mut [Val],
-    ) -> Result<()> {
-        let mut store = store.as_context_mut();
-        assert!(
-            !store.0.async_support(),
-            "must use `call_async` when async support is enabled on the config"
-        );
-        self.call_impl(&mut store.as_context_mut(), params, results)
-    }
-
-    /// Exactly like [`Self::call`] except for use on async stores.
-    ///
-    /// # Panics
-    ///
-    /// Panics if this is called on a function in a synchronous store. This only works
-    /// with functions defined within an asynchronous store. Also panics if `store`
-    /// does not own this function.
-    #[cfg(feature = "async")]
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "async")))]
-    pub async fn call_async<T>(
-        &self,
-        mut store: impl AsContextMut<Data = T>,
-        params: &[Val],
-        results: &mut [Val],
-    ) -> Result<()>
-    where
-        T: Send,
-    {
-        let mut store = store.as_context_mut();
-        assert!(
-            store.0.async_support(),
-            "cannot use `call_async` without enabling async support in the config"
-        );
-        store
-            .on_fiber(|store| self.call_impl(store, params, results))
-            .await?
-    }
-
-    fn call_impl(
-        &self,
-        mut store: impl AsContextMut,
-        params: &[Val],
-        results: &mut [Val],
-    ) -> Result<()> {
-        let store = &mut store.as_context_mut();
-
-        let param_tys = self.params(&store);
-        let result_tys = self.results(&store);
-
-        if param_tys.len() != params.len() {
-            bail!(
-                "expected {} argument(s), got {}",
-                param_tys.len(),
-                params.len()
-            );
-        }
-        if result_tys.len() != results.len() {
-            bail!(
-                "expected {} results(s), got {}",
-                result_tys.len(),
-                results.len()
-            );
-        }
-
-        for (param, ty) in params.iter().zip(param_tys.iter()) {
-            ty.check(param).context("type mismatch with parameters")?;
-        }
-
-        self.call_raw(
-            store,
-            params,
-            |cx, params, params_ty, dst: &mut MaybeUninit<[ValRaw; MAX_FLAT_PARAMS]>| {
-                let params_ty = match params_ty {
-                    InterfaceType::Tuple(i) => &cx.types[i],
-                    _ => unreachable!(),
-                };
-                if params_ty.abi.flat_count(MAX_FLAT_PARAMS).is_some() {
-                    let dst = &mut unsafe {
-                        mem::transmute::<_, &mut [MaybeUninit<ValRaw>; MAX_FLAT_PARAMS]>(dst)
-                    }
-                    .iter_mut();
-
-                    params
-                        .iter()
-                        .zip(params_ty.types.iter())
-                        .try_for_each(|(param, ty)| param.lower(cx, *ty, dst))
-                } else {
-                    self.store_args(cx, &params_ty, params, dst)
-                }
-            },
-            |cx, results_ty, src: &[ValRaw; MAX_FLAT_RESULTS]| {
-                let results_ty = match results_ty {
-                    InterfaceType::Tuple(i) => &cx.types[i],
-                    _ => unreachable!(),
-                };
-                if results_ty.abi.flat_count(MAX_FLAT_RESULTS).is_some() {
-                    let mut flat = src.iter();
-                    for (ty, slot) in results_ty.types.iter().zip(results) {
-                        *slot = Val::lift(cx, *ty, &mut flat)?;
-                    }
-                    Ok(())
-                } else {
-                    Self::load_results(cx, results_ty, results, &mut src.iter())
-                }
-            },
-        )
-    }
-
-    /// Invokes the underlying wasm function, lowering arguments and lifting the
-    /// result.
-    ///
-    /// The `lower` function and `lift` function provided here are what actually
-    /// do the lowering and lifting. The `LowerParams` and `LowerReturn` types
-    /// are what will be allocated on the stack for this function call. They
-    /// should be appropriately sized for the lowering/lifting operation
-    /// happening.
-    fn call_raw<T, Params: ?Sized, Return, LowerParams, LowerReturn>(
-        &self,
-        store: &mut StoreContextMut<'_, T>,
-        params: &Params,
-        lower: impl FnOnce(
-            &mut LowerContext<'_, T>,
-            &Params,
-            InterfaceType,
-            &mut MaybeUninit<LowerParams>,
-        ) -> Result<()>,
-        lift: impl FnOnce(&mut LiftContext<'_>, InterfaceType, &LowerReturn) -> Result<Return>,
-    ) -> Result<Return>
-    where
-        LowerParams: Copy,
-        LowerReturn: Copy,
-    {
-        let FuncData {
-            export,
-            options,
-            instance,
-            component_instance,
-            ty,
-            ..
-        } = store.0[self.0];
-
-        let space = &mut MaybeUninit::<ParamsAndResults<LowerParams, LowerReturn>>::uninit();
-
-        // Double-check the size/alignemnt of `space`, just in case.
-        //
-        // Note that this alone is not enough to guarantee the validity of the
-        // `unsafe` block below, but it's definitely required. In any case LLVM
-        // should be able to trivially see through these assertions and remove
-        // them in release mode.
-        let val_size = mem::size_of::<ValRaw>();
-        let val_align = mem::align_of::<ValRaw>();
-        assert!(mem::size_of_val(space) % val_size == 0);
-        assert!(mem::size_of_val(map_maybe_uninit!(space.params)) % val_size == 0);
-        assert!(mem::size_of_val(map_maybe_uninit!(space.ret)) % val_size == 0);
-        assert!(mem::align_of_val(space) == val_align);
-        assert!(mem::align_of_val(map_maybe_uninit!(space.params)) == val_align);
-        assert!(mem::align_of_val(map_maybe_uninit!(space.ret)) == val_align);
-
-        let instance = store.0[instance.0].as_ref().unwrap();
-        let types = instance.component_types().clone();
-        let mut flags = instance.instance().instance_flags(component_instance);
-
-        unsafe {
-            // Test the "may enter" flag which is a "lock" on this instance.
-            // This is immediately set to `false` afterwards and note that
-            // there's no on-cleanup setting this flag back to true. That's an
-            // intentional design aspect where if anything goes wrong internally
-            // from this point on the instance is considered "poisoned" and can
-            // never be entered again. The only time this flag is set to `true`
-            // again is after post-return logic has completed successfully.
-            if !flags.may_enter() {
-                bail!(crate::Trap::CannotEnterComponent);
-            }
-            flags.set_may_enter(false);
-
-            debug_assert!(flags.may_leave());
-            flags.set_may_leave(false);
-            let instance_ptr = instance.instance_ptr();
-            let mut cx = LowerContext::new(store.as_context_mut(), &options, &types, instance_ptr);
-            cx.enter_call();
-            let result = lower(
-                &mut cx,
-                params,
-                InterfaceType::Tuple(types[ty].params),
-                map_maybe_uninit!(space.params),
-            );
-            flags.set_may_leave(true);
-            result?;
-
-            // This is unsafe as we are providing the guarantee that all the
-            // inputs are valid. The various pointers passed in for the function
-            // are all valid since they're coming from our store, and the
-            // `params_and_results` should have the correct layout for the core
-            // wasm function we're calling. Note that this latter point relies
-            // on the correctness of this module and `ComponentType`
-            // implementations, hence `ComponentType` being an `unsafe` trait.
-            crate::Func::call_unchecked_raw(
-                store,
-                export.func_ref,
-                space.as_mut_ptr().cast(),
-                mem::size_of_val(space) / mem::size_of::<ValRaw>(),
-            )?;
-
-            // Note that `.assume_init_ref()` here is unsafe but we're relying
-            // on the correctness of the structure of `LowerReturn` and the
-            // type-checking performed to acquire the `TypedFunc` to make this
-            // safe. It should be the case that `LowerReturn` is the exact
-            // representation of the return value when interpreted as
-            // `[ValRaw]`, and additionally they should have the correct types
-            // for the function we just called (which filled in the return
-            // values).
-            let ret = map_maybe_uninit!(space.ret).assume_init_ref();
-
-            // Lift the result into the host while managing post-return state
-            // here as well.
-            //
-            // After a successful lift the return value of the function, which
-            // is currently required to be 0 or 1 values according to the
-            // canonical ABI, is saved within the `Store`'s `FuncData`. This'll
-            // later get used in post-return.
-            flags.set_needs_post_return(true);
-            let val = lift(
-                &mut LiftContext::new(store.0, &options, &types, instance_ptr),
-                InterfaceType::Tuple(types[ty].results),
-                ret,
-            )?;
-            let ret_slice = storage_as_slice(ret);
-            let data = &mut store.0[self.0];
-            assert!(data.post_return_arg.is_none());
-            match ret_slice.len() {
-                0 => data.post_return_arg = Some(ValRaw::i32(0)),
-                1 => data.post_return_arg = Some(ret_slice[0]),
-                _ => unreachable!(),
-            }
-            return Ok(val);
-        }
-    }
-
-    /// Invokes the `post-return` canonical ABI option, if specified, after a
-    /// [`Func::call`] has finished.
-    ///
-    /// For some more information on when to use this function see the
-    /// documentation for post-return in the [`Func::call`] method.
-    /// Otherwise though this function is a required method call after a
-    /// [`Func::call`] completes successfully. After the embedder has
-    /// finished processing the return value then this function must be invoked.
-    ///
-    /// # Errors
-    ///
-    /// This function will return an error in the case of a WebAssembly trap
-    /// happening during the execution of the `post-return` function, if
-    /// specified.
-    ///
-    /// # Panics
-    ///
-    /// This function will panic if it's not called under the correct
-    /// conditions. This can only be called after a previous invocation of
-    /// [`Func::call`] completes successfully, and this function can only
-    /// be called for the same [`Func`] that was `call`'d.
-    ///
-    /// If this function is called when [`Func::call`] was not previously
-    /// called, then it will panic. If a different [`Func`] for the same
-    /// component instance was invoked then this function will also panic
-    /// because the `post-return` needs to happen for the other function.
-    ///
-    /// Panics if this is called on a function in an asynchronous store.
-    /// This only works with functions defined within a synchronous store.
-    #[inline]
-    pub fn post_return(&self, mut store: impl AsContextMut) -> Result<()> {
-        let store = store.as_context_mut();
-        assert!(
-            !store.0.async_support(),
-            "must use `post_return_async` when async support is enabled on the config"
-        );
-        self.post_return_impl(store)
-    }
-
-    /// Exactly like [`Self::post_return`] except for use on async stores.
-    ///
-    /// # Panics
-    ///
-    /// Panics if this is called on a function in a synchronous store. This
-    /// only works with functions defined within an asynchronous store.
-    #[cfg(feature = "async")]
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "async")))]
-    pub async fn post_return_async<T: Send>(
-        &self,
-        mut store: impl AsContextMut<Data = T>,
-    ) -> Result<()> {
-        let mut store = store.as_context_mut();
-        assert!(
-            store.0.async_support(),
-            "cannot use `call_async` without enabling async support in the config"
-        );
-        // Future optimization opportunity: conditionally use a fiber here since
-        // some func's post_return will not need the async context (i.e. end up
-        // calling async host functionality)
-        store.on_fiber(|store| self.post_return_impl(store)).await?
-    }
-
-    #[inline]
-    fn post_return_impl(&self, mut store: impl AsContextMut) -> Result<()> {
-        let mut store = store.as_context_mut();
-        let data = &mut store.0[self.0];
-        let instance = data.instance;
-        let post_return = data.post_return;
-        let component_instance = data.component_instance;
-        let post_return_arg = data.post_return_arg.take();
-        let instance = store.0[instance.0].as_ref().unwrap().instance_ptr();
-
-        unsafe {
-            let mut flags = (*instance).instance_flags(component_instance);
-
-            // First assert that the instance is in a "needs post return" state.
-            // This will ensure that the previous action on the instance was a
-            // function call above. This flag is only set after a component
-            // function returns so this also can't be called (as expected)
-            // during a host import for example.
-            //
-            // Note, though, that this assert is not sufficient because it just
-            // means some function on this instance needs its post-return
-            // called. We need a precise post-return for a particular function
-            // which is the second assert here (the `.expect`). That will assert
-            // that this function itself needs to have its post-return called.
-            //
-            // The theory at least is that these two asserts ensure component
-            // model semantics are upheld where the host properly calls
-            // `post_return` on the right function despite the call being a
-            // separate step in the API.
-            assert!(
-                flags.needs_post_return(),
-                "post_return can only be called after a function has previously been called",
-            );
-            let post_return_arg = post_return_arg.expect("calling post_return on wrong function");
-
-            // This is a sanity-check assert which shouldn't ever trip.
-            assert!(!flags.may_enter());
-
-            // Unset the "needs post return" flag now that post-return is being
-            // processed. This will cause future invocations of this method to
-            // panic, even if the function call below traps.
-            flags.set_needs_post_return(false);
-
-            // If the function actually had a `post-return` configured in its
-            // canonical options that's executed here.
-            //
-            // Note that if this traps (returns an error) this function
-            // intentionally leaves the instance in a "poisoned" state where it
-            // can no longer be entered because `may_enter` is `false`.
-            if let Some(func) = post_return {
-                crate::Func::call_unchecked_raw(
-                    &mut store,
-                    func.func_ref,
-                    &post_return_arg as *const ValRaw as *mut ValRaw,
-                    1,
-                )?;
-            }
-
-            // And finally if everything completed successfully then the "may
-            // enter" flag is set to `true` again here which enables further use
-            // of the component.
-            flags.set_may_enter(true);
-
-            let (calls, host_table) = store.0.component_calls_and_host_table();
-            ResourceTables {
-                calls,
-                host_table: Some(host_table),
-                tables: Some((*instance).component_resource_tables()),
-            }
-            .exit_call()?;
-        }
-        Ok(())
-    }
-
-    fn store_args<T>(
-        &self,
-        cx: &mut LowerContext<'_, T>,
-        params_ty: &TypeTuple,
-        args: &[Val],
-        dst: &mut MaybeUninit<[ValRaw; MAX_FLAT_PARAMS]>,
-    ) -> Result<()> {
-        let size = usize::try_from(params_ty.abi.size32).unwrap();
-        let ptr = cx.realloc(0, 0, params_ty.abi.align32, size)?;
-        let mut offset = ptr;
-        for (ty, arg) in params_ty.types.iter().zip(args) {
-            let abi = cx.types.canonical_abi(ty);
-            arg.store(cx, *ty, abi.next_field32_size(&mut offset))?;
-        }
-
-        map_maybe_uninit!(dst[0]).write(ValRaw::i64(ptr as i64));
-
-        Ok(())
-    }
-
-    fn load_results(
-        cx: &mut LiftContext<'_>,
-        results_ty: &TypeTuple,
-        results: &mut [Val],
-        src: &mut std::slice::Iter<'_, ValRaw>,
-    ) -> Result<()> {
-        // FIXME: needs to read an i64 for memory64
-        let ptr = usize::try_from(src.next().unwrap().get_u32())?;
-        if ptr % usize::try_from(results_ty.abi.align32)? != 0 {
-            bail!("return pointer not aligned");
-        }
-
-        let bytes = cx
-            .memory()
-            .get(ptr..)
-            .and_then(|b| b.get(..usize::try_from(results_ty.abi.size32).unwrap()))
-            .ok_or_else(|| anyhow::anyhow!("pointer out of bounds of memory"))?;
-
-        let mut offset = 0;
-        for (ty, slot) in results_ty.types.iter().zip(results) {
-            let abi = cx.types.canonical_abi(ty);
-            let offset = abi.next_field32_size(&mut offset);
-            *slot = Val::load(cx, *ty, &bytes[offset..][..abi.size32 as usize])?;
-        }
-        Ok(())
-    }
-}
diff --git a/crates/wasmtime/src/component/func/host.rs b/crates/wasmtime/src/component/func/host.rs
deleted file mode 100644
index a048275b9090..000000000000
--- a/crates/wasmtime/src/component/func/host.rs
+++ /dev/null
@@ -1,456 +0,0 @@
-use crate::component::func::{LiftContext, LowerContext, Options};
-use crate::component::matching::InstanceType;
-use crate::component::storage::slice_to_storage_mut;
-use crate::component::{ComponentNamedList, ComponentType, Lift, Lower, Type, Val};
-use crate::{AsContextMut, StoreContextMut, ValRaw};
-use anyhow::{anyhow, bail, Context, Result};
-use std::any::Any;
-use std::mem::{self, MaybeUninit};
-use std::panic::{self, AssertUnwindSafe};
-use std::ptr::NonNull;
-use std::sync::Arc;
-use wasmtime_environ::component::{
-    CanonicalAbiInfo, ComponentTypes, InterfaceType, StringEncoding, TypeFuncIndex,
-    MAX_FLAT_PARAMS, MAX_FLAT_RESULTS,
-};
-use wasmtime_runtime::component::{
-    InstanceFlags, VMComponentContext, VMLowering, VMLoweringCallee,
-};
-use wasmtime_runtime::{VMFuncRef, VMMemoryDefinition, VMOpaqueContext};
-
-pub struct HostFunc {
-    entrypoint: VMLoweringCallee,
-    typecheck: Box<dyn (Fn(TypeFuncIndex, &InstanceType<'_>) -> Result<()>) + Send + Sync>,
-    func: Box<dyn Any + Send + Sync>,
-}
-
-impl HostFunc {
-    pub(crate) fn from_closure<T, F, P, R>(func: F) -> Arc<HostFunc>
-    where
-        F: Fn(StoreContextMut<T>, P) -> Result<R> + Send + Sync + 'static,
-        P: ComponentNamedList + Lift + 'static,
-        R: ComponentNamedList + Lower + 'static,
-    {
-        let entrypoint = Self::entrypoint::<T, F, P, R>;
-        Arc::new(HostFunc {
-            entrypoint,
-            typecheck: Box::new(typecheck::<P, R>),
-            func: Box::new(func),
-        })
-    }
-
-    extern "C" fn entrypoint<T, F, P, R>(
-        cx: *mut VMOpaqueContext,
-        data: *mut u8,
-        ty: TypeFuncIndex,
-        flags: InstanceFlags,
-        memory: *mut VMMemoryDefinition,
-        realloc: *mut VMFuncRef,
-        string_encoding: StringEncoding,
-        storage: *mut MaybeUninit<ValRaw>,
-        storage_len: usize,
-    ) where
-        F: Fn(StoreContextMut<T>, P) -> Result<R>,
-        P: ComponentNamedList + Lift + 'static,
-        R: ComponentNamedList + Lower + 'static,
-    {
-        let data = data as *const F;
-        unsafe {
-            handle_result(|| {
-                call_host::<_, _, _, _>(
-                    cx,
-                    ty,
-                    flags,
-                    memory,
-                    realloc,
-                    string_encoding,
-                    std::slice::from_raw_parts_mut(storage, storage_len),
-                    |store, args| (*data)(store, args),
-                )
-            })
-        }
-    }
-
-    pub(crate) fn new_dynamic<T, F>(
-        func: F,
-        index: TypeFuncIndex,
-        types: &Arc<ComponentTypes>,
-    ) -> Arc<HostFunc>
-    where
-        F: Fn(StoreContextMut<'_, T>, &[Val], &mut [Val]) -> Result<()> + Send + Sync + 'static,
-    {
-        Arc::new(HostFunc {
-            entrypoint: dynamic_entrypoint::<T, F>,
-            typecheck: Box::new({
-                let types = types.clone();
-
-                move |expected_index, expected_types| {
-                    if index == expected_index && std::ptr::eq(&*types, &**expected_types.types) {
-                        Ok(())
-                    } else {
-                        Err(anyhow!("function type mismatch"))
-                    }
-                }
-            }),
-            func: Box::new(func),
-        })
-    }
-
-    pub fn typecheck(&self, ty: TypeFuncIndex, types: &InstanceType<'_>) -> Result<()> {
-        (self.typecheck)(ty, types)
-    }
-
-    pub fn lowering(&self) -> VMLowering {
-        let data = &*self.func as *const (dyn Any + Send + Sync) as *mut u8;
-        VMLowering {
-            callee: self.entrypoint,
-            data,
-        }
-    }
-}
-
-fn typecheck<P, R>(ty: TypeFuncIndex, types: &InstanceType<'_>) -> Result<()>
-where
-    P: ComponentNamedList + Lift,
-    R: ComponentNamedList + Lower,
-{
-    let ty = &types.types[ty];
-    P::typecheck(&InterfaceType::Tuple(ty.params), types)
-        .context("type mismatch with parameters")?;
-    R::typecheck(&InterfaceType::Tuple(ty.results), types).context("type mismatch with results")?;
-    Ok(())
-}
-
-/// The "meat" of calling a host function from wasm.
-///
-/// This function is delegated to from implementations of
-/// `HostFunc::from_closure`. Most of the arguments from the `entrypoint` are
-/// forwarded here except for the `data` pointer which is encapsulated in the
-/// `closure` argument here.
-///
-/// This function is parameterized over:
-///
-/// * `T` - the type of store this function works with (an unsafe assertion)
-/// * `Params` - the parameters to the host function, viewed as a tuple
-/// * `Return` - the result of the host function
-/// * `F` - the `closure` to actually receive the `Params` and return the
-///   `Return`
-///
-/// It's expected that `F` will "un-tuple" the arguments to pass to a host
-/// closure.
-///
-/// This function is in general `unsafe` as the validity of all the parameters
-/// must be upheld. Generally that's done by ensuring this is only called from
-/// the select few places it's intended to be called from.
-unsafe fn call_host<T, Params, Return, F>(
-    cx: *mut VMOpaqueContext,
-    ty: TypeFuncIndex,
-    mut flags: InstanceFlags,
-    memory: *mut VMMemoryDefinition,
-    realloc: *mut VMFuncRef,
-    string_encoding: StringEncoding,
-    storage: &mut [MaybeUninit<ValRaw>],
-    closure: F,
-) -> Result<()>
-where
-    Params: Lift,
-    Return: Lower,
-    F: FnOnce(StoreContextMut<'_, T>, Params) -> Result<Return>,
-{
-    /// Representation of arguments to this function when a return pointer is in
-    /// use, namely the argument list is followed by a single value which is the
-    /// return pointer.
-    #[repr(C)]
-    struct ReturnPointer<T> {
-        args: T,
-        retptr: ValRaw,
-    }
-
-    /// Representation of arguments to this function when the return value is
-    /// returned directly, namely the arguments and return value all start from
-    /// the beginning (aka this is a `union`, not a `struct`).
-    #[repr(C)]
-    union ReturnStack<T: Copy, U: Copy> {
-        args: T,
-        ret: U,
-    }
-
-    let cx = VMComponentContext::from_opaque(cx);
-    let instance = (*cx).instance();
-    let mut cx = StoreContextMut::from_raw((*instance).store());
-
-    let options = Options::new(
-        cx.0.id(),
-        NonNull::new(memory),
-        NonNull::new(realloc),
-        string_encoding,
-    );
-
-    // Perform a dynamic check that this instance can indeed be left. Exiting
-    // the component is disallowed, for example, when the `realloc` function
-    // calls a canonical import.
-    if !flags.may_leave() {
-        bail!("cannot leave component instance");
-    }
-
-    let types = (*instance).component_types();
-    let ty = &types[ty];
-    let param_tys = InterfaceType::Tuple(ty.params);
-    let result_tys = InterfaceType::Tuple(ty.results);
-
-    // There's a 2x2 matrix of whether parameters and results are stored on the
-    // stack or on the heap. Each of the 4 branches here have a different
-    // representation of the storage of arguments/returns.
-    //
-    // Also note that while four branches are listed here only one is taken for
-    // any particular `Params` and `Return` combination. This should be
-    // trivially DCE'd by LLVM. Perhaps one day with enough const programming in
-    // Rust we can make monomorphizations of this function codegen only one
-    // branch, but today is not that day.
-    let mut storage: Storage<'_, Params, Return> = if Params::flatten_count() <= MAX_FLAT_PARAMS {
-        if Return::flatten_count() <= MAX_FLAT_RESULTS {
-            Storage::Direct(slice_to_storage_mut(storage))
-        } else {
-            Storage::ResultsIndirect(slice_to_storage_mut(storage).assume_init_ref())
-        }
-    } else {
-        if Return::flatten_count() <= MAX_FLAT_RESULTS {
-            Storage::ParamsIndirect(slice_to_storage_mut(storage))
-        } else {
-            Storage::Indirect(slice_to_storage_mut(storage).assume_init_ref())
-        }
-    };
-    let mut lift = LiftContext::new(cx.0, &options, types, instance);
-    lift.enter_call();
-    let params = storage.lift_params(&mut lift, param_tys)?;
-
-    let ret = closure(cx.as_context_mut(), params)?;
-    flags.set_may_leave(false);
-    let mut lower = LowerContext::new(cx, &options, types, instance);
-    storage.lower_results(&mut lower, result_tys, ret)?;
-    flags.set_may_leave(true);
-
-    lower.exit_call()?;
-
-    return Ok(());
-
-    enum Storage<'a, P: ComponentType, R: ComponentType> {
-        Direct(&'a mut MaybeUninit<ReturnStack<P::Lower, R::Lower>>),
-        ParamsIndirect(&'a mut MaybeUninit<ReturnStack<ValRaw, R::Lower>>),
-        ResultsIndirect(&'a ReturnPointer<P::Lower>),
-        Indirect(&'a ReturnPointer<ValRaw>),
-    }
-
-    impl<P, R> Storage<'_, P, R>
-    where
-        P: ComponentType + Lift,
-        R: ComponentType + Lower,
-    {
-        unsafe fn lift_params(&self, cx: &mut LiftContext<'_>, ty: InterfaceType) -> Result<P> {
-            match self {
-                Storage::Direct(storage) => P::lift(cx, ty, &storage.assume_init_ref().args),
-                Storage::ResultsIndirect(storage) => P::lift(cx, ty, &storage.args),
-                Storage::ParamsIndirect(storage) => {
-                    let ptr = validate_inbounds::<P>(cx.memory(), &storage.assume_init_ref().args)?;
-                    P::load(cx, ty, &cx.memory()[ptr..][..P::SIZE32])
-                }
-                Storage::Indirect(storage) => {
-                    let ptr = validate_inbounds::<P>(cx.memory(), &storage.args)?;
-                    P::load(cx, ty, &cx.memory()[ptr..][..P::SIZE32])
-                }
-            }
-        }
-
-        unsafe fn lower_results<T>(
-            &mut self,
-            cx: &mut LowerContext<'_, T>,
-            ty: InterfaceType,
-            ret: R,
-        ) -> Result<()> {
-            match self {
-                Storage::Direct(storage) => ret.lower(cx, ty, map_maybe_uninit!(storage.ret)),
-                Storage::ParamsIndirect(storage) => {
-                    ret.lower(cx, ty, map_maybe_uninit!(storage.ret))
-                }
-                Storage::ResultsIndirect(storage) => {
-                    let ptr = validate_inbounds::<R>(cx.as_slice_mut(), &storage.retptr)?;
-                    ret.store(cx, ty, ptr)
-                }
-                Storage::Indirect(storage) => {
-                    let ptr = validate_inbounds::<R>(cx.as_slice_mut(), &storage.retptr)?;
-                    ret.store(cx, ty, ptr)
-                }
-            }
-        }
-    }
-}
-
-fn validate_inbounds<T: ComponentType>(memory: &[u8], ptr: &ValRaw) -> Result<usize> {
-    // FIXME: needs memory64 support
-    let ptr = usize::try_from(ptr.get_u32())?;
-    if ptr % usize::try_from(T::ALIGN32)? != 0 {
-        bail!("pointer not aligned");
-    }
-    let end = match ptr.checked_add(T::SIZE32) {
-        Some(n) => n,
-        None => bail!("pointer size overflow"),
-    };
-    if end > memory.len() {
-        bail!("pointer out of bounds")
-    }
-    Ok(ptr)
-}
-
-unsafe fn handle_result(func: impl FnOnce() -> Result<()>) {
-    match panic::catch_unwind(AssertUnwindSafe(func)) {
-        Ok(Ok(())) => {}
-        Ok(Err(e)) => crate::trap::raise(e),
-        Err(e) => wasmtime_runtime::resume_panic(e),
-    }
-}
-
-unsafe fn call_host_dynamic<T, F>(
-    cx: *mut VMOpaqueContext,
-    ty: TypeFuncIndex,
-    mut flags: InstanceFlags,
-    memory: *mut VMMemoryDefinition,
-    realloc: *mut VMFuncRef,
-    string_encoding: StringEncoding,
-    storage: &mut [MaybeUninit<ValRaw>],
-    closure: F,
-) -> Result<()>
-where
-    F: FnOnce(StoreContextMut<'_, T>, &[Val], &mut [Val]) -> Result<()>,
-{
-    let cx = VMComponentContext::from_opaque(cx);
-    let instance = (*cx).instance();
-    let mut store = StoreContextMut::from_raw((*instance).store());
-    let types = (*instance).component_types();
-    let options = Options::new(
-        store.0.id(),
-        NonNull::new(memory),
-        NonNull::new(realloc),
-        string_encoding,
-    );
-
-    // Perform a dynamic check that this instance can indeed be left. Exiting
-    // the component is disallowed, for example, when the `realloc` function
-    // calls a canonical import.
-    if !flags.may_leave() {
-        bail!("cannot leave component instance");
-    }
-
-    let args;
-    let ret_index;
-
-    let func_ty = &types[ty];
-    let param_tys = &types[func_ty.params];
-    let result_tys = &types[func_ty.results];
-    let mut cx = LiftContext::new(store.0, &options, types, instance);
-    cx.enter_call();
-    if let Some(param_count) = param_tys.abi.flat_count(MAX_FLAT_PARAMS) {
-        // NB: can use `MaybeUninit::slice_assume_init_ref` when that's stable
-        let mut iter =
-            mem::transmute::<&[MaybeUninit<ValRaw>], &[ValRaw]>(&storage[..param_count]).iter();
-        args = param_tys
-            .types
-            .iter()
-            .map(|ty| Val::lift(&mut cx, *ty, &mut iter))
-            .collect::<Result<Box<[_]>>>()?;
-        ret_index = param_count;
-        assert!(iter.next().is_none());
-    } else {
-        let mut offset =
-            validate_inbounds_dynamic(&param_tys.abi, cx.memory(), storage[0].assume_init_ref())?;
-        args = param_tys
-            .types
-            .iter()
-            .map(|ty| {
-                let abi = types.canonical_abi(ty);
-                let size = usize::try_from(abi.size32).unwrap();
-                let memory = &cx.memory()[abi.next_field32_size(&mut offset)..][..size];
-                Val::load(&mut cx, *ty, memory)
-            })
-            .collect::<Result<Box<[_]>>>()?;
-        ret_index = 1;
-    };
-
-    let mut result_vals = Vec::with_capacity(result_tys.types.len());
-    for _ in result_tys.types.iter() {
-        result_vals.push(Val::Bool(false));
-    }
-    closure(store.as_context_mut(), &args, &mut result_vals)?;
-    flags.set_may_leave(false);
-
-    let mut cx = LowerContext::new(store, &options, types, instance);
-    let instance = cx.instance_type();
-    for (val, ty) in result_vals.iter().zip(result_tys.types.iter()) {
-        Type::from(ty, &instance).check(val)?;
-    }
-    if let Some(cnt) = result_tys.abi.flat_count(MAX_FLAT_RESULTS) {
-        let mut dst = storage[..cnt].iter_mut();
-        for (val, ty) in result_vals.iter().zip(result_tys.types.iter()) {
-            val.lower(&mut cx, *ty, &mut dst)?;
-        }
-        assert!(dst.next().is_none());
-    } else {
-        let ret_ptr = storage[ret_index].assume_init_ref();
-        let mut ptr = validate_inbounds_dynamic(&result_tys.abi, cx.as_slice_mut(), ret_ptr)?;
-        for (val, ty) in result_vals.iter().zip(result_tys.types.iter()) {
-            let offset = types.canonical_abi(ty).next_field32_size(&mut ptr);
-            val.store(&mut cx, *ty, offset)?;
-        }
-    }
-
-    flags.set_may_leave(true);
-
-    cx.exit_call()?;
-
-    return Ok(());
-}
-
-fn validate_inbounds_dynamic(abi: &CanonicalAbiInfo, memory: &[u8], ptr: &ValRaw) -> Result<usize> {
-    // FIXME: needs memory64 support
-    let ptr = usize::try_from(ptr.get_u32())?;
-    if ptr % usize::try_from(abi.align32)? != 0 {
-        bail!("pointer not aligned");
-    }
-    let end = match ptr.checked_add(usize::try_from(abi.size32).unwrap()) {
-        Some(n) => n,
-        None => bail!("pointer size overflow"),
-    };
-    if end > memory.len() {
-        bail!("pointer out of bounds")
-    }
-    Ok(ptr)
-}
-
-extern "C" fn dynamic_entrypoint<T, F>(
-    cx: *mut VMOpaqueContext,
-    data: *mut u8,
-    ty: TypeFuncIndex,
-    flags: InstanceFlags,
-    memory: *mut VMMemoryDefinition,
-    realloc: *mut VMFuncRef,
-    string_encoding: StringEncoding,
-    storage: *mut MaybeUninit<ValRaw>,
-    storage_len: usize,
-) where
-    F: Fn(StoreContextMut<'_, T>, &[Val], &mut [Val]) -> Result<()> + Send + Sync + 'static,
-{
-    let data = data as *const F;
-    unsafe {
-        handle_result(|| {
-            call_host_dynamic::<T, _>(
-                cx,
-                ty,
-                flags,
-                memory,
-                realloc,
-                string_encoding,
-                std::slice::from_raw_parts_mut(storage, storage_len),
-                |store, params, results| (*data)(store, params, results),
-            )
-        })
-    }
-}
diff --git a/crates/wasmtime/src/component/func/typed.rs b/crates/wasmtime/src/component/func/typed.rs
deleted file mode 100644
index 1b43cec321d7..000000000000
--- a/crates/wasmtime/src/component/func/typed.rs
+++ /dev/null
@@ -1,2398 +0,0 @@
-use crate::component::func::{Func, LiftContext, LowerContext, Options};
-use crate::component::matching::InstanceType;
-use crate::component::storage::{storage_as_slice, storage_as_slice_mut};
-use crate::{AsContextMut, StoreContext, StoreContextMut, ValRaw};
-use anyhow::{anyhow, bail, Context, Result};
-use std::borrow::Cow;
-use std::fmt;
-use std::marker;
-use std::mem::{self, MaybeUninit};
-use std::ptr::NonNull;
-use std::str;
-use std::sync::Arc;
-use wasmtime_environ::component::{
-    CanonicalAbiInfo, ComponentTypes, InterfaceType, StringEncoding, VariantInfo, MAX_FLAT_PARAMS,
-    MAX_FLAT_RESULTS,
-};
-use wasmtime_runtime::component::ComponentInstance;
-use wasmtime_runtime::SendSyncPtr;
-
-/// A statically-typed version of [`Func`] which takes `Params` as input and
-/// returns `Return`.
-///
-/// This is an efficient way to invoke a WebAssembly component where if the
-/// inputs and output are statically known this can eschew the vast majority of
-/// machinery and checks when calling WebAssembly. This is the most optimized
-/// way to call a WebAssembly component.
-///
-/// Note that like [`Func`] this is a pointer within a [`Store`](crate::Store)
-/// and usage will panic if used with the wrong store.
-///
-/// This type is primarily created with the [`Func::typed`] API.
-pub struct TypedFunc<Params, Return> {
-    func: Func,
-
-    // The definition of this field is somewhat subtle and may be surprising.
-    // Naively one might expect something like
-    //
-    //      _marker: marker::PhantomData<fn(Params) -> Return>,
-    //
-    // Since this is a function pointer after all. The problem with this
-    // definition though is that it imposes the wrong variance on `Params` from
-    // what we want. Abstractly a `fn(Params)` is able to store `Params` within
-    // it meaning you can only give it `Params` that live longer than the
-    // function pointer.
-    //
-    // With a component model function, however, we're always copying data from
-    // the host into the guest, so we are never storing pointers to `Params`
-    // into the guest outside the duration of a `call`, meaning we can actually
-    // accept values in `TypedFunc::call` which live for a shorter duration
-    // than the `Params` argument on the struct.
-    //
-    // This all means that we don't use a phantom function pointer, but instead
-    // feign phantom storage here to get the variance desired.
-    _marker: marker::PhantomData<(Params, Return)>,
-}
-
-impl<Params, Return> Copy for TypedFunc<Params, Return> {}
-
-impl<Params, Return> Clone for TypedFunc<Params, Return> {
-    fn clone(&self) -> TypedFunc<Params, Return> {
-        *self
-    }
-}
-
-impl<Params, Return> TypedFunc<Params, Return>
-where
-    Params: ComponentNamedList + Lower,
-    Return: ComponentNamedList + Lift,
-{
-    /// Creates a new [`TypedFunc`] from the provided component [`Func`],
-    /// unsafely asserting that the underlying function takes `Params` as
-    /// input and returns `Return`.
-    ///
-    /// # Unsafety
-    ///
-    /// This is an unsafe function because it does not verify that the [`Func`]
-    /// provided actually implements this signature. It's up to the caller to
-    /// have performed some other sort of check to ensure that the signature is
-    /// correct.
-    pub unsafe fn new_unchecked(func: Func) -> TypedFunc<Params, Return> {
-        TypedFunc {
-            _marker: marker::PhantomData,
-            func,
-        }
-    }
-
-    /// Returns the underlying un-typed [`Func`] that this [`TypedFunc`]
-    /// references.
-    pub fn func(&self) -> &Func {
-        &self.func
-    }
-
-    /// Calls the underlying WebAssembly component function using the provided
-    /// `params` as input.
-    ///
-    /// This method is used to enter into a component. Execution happens within
-    /// the `store` provided. The `params` are copied into WebAssembly memory
-    /// as appropriate and a core wasm function is invoked.
-    ///
-    /// # Post-return
-    ///
-    /// In the component model each function can have a "post return" specified
-    /// which allows cleaning up the arguments returned to the host. For example
-    /// if WebAssembly returns a string to the host then it might be a uniquely
-    /// allocated string which, after the host finishes processing it, needs to
-    /// be deallocated in the wasm instance's own linear memory to prevent
-    /// memory leaks in wasm itself. The `post-return` canonical abi option is
-    /// used to configured this.
-    ///
-    /// To accommodate this feature of the component model after invoking a
-    /// function via [`TypedFunc::call`] you must next invoke
-    /// [`TypedFunc::post_return`]. Note that the return value of the function
-    /// should be processed between these two function calls. The return value
-    /// continues to be usable from an embedder's perspective after
-    /// `post_return` is called, but after `post_return` is invoked it may no
-    /// longer retain the same value that the wasm module originally returned.
-    ///
-    /// Also note that [`TypedFunc::post_return`] must be invoked irrespective
-    /// of whether the canonical ABI option `post-return` was configured or not.
-    /// This means that embedders must unconditionally call
-    /// [`TypedFunc::post_return`] when a function returns. If this function
-    /// call returns an error, however, then [`TypedFunc::post_return`] is not
-    /// required.
-    ///
-    /// # Errors
-    ///
-    /// This function can return an error for a number of reasons:
-    ///
-    /// * If the wasm itself traps during execution.
-    /// * If the wasm traps while copying arguments into memory.
-    /// * If the wasm provides bad allocation pointers when copying arguments
-    ///   into memory.
-    /// * If the wasm returns a value which violates the canonical ABI.
-    /// * If this function's instances cannot be entered, for example if the
-    ///   instance is currently calling a host function.
-    /// * If a previous function call occurred and the corresponding
-    ///   `post_return` hasn't been invoked yet.
-    ///
-    /// In general there are many ways that things could go wrong when copying
-    /// types in and out of a wasm module with the canonical ABI, and certain
-    /// error conditions are specific to certain types. For example a
-    /// WebAssembly module can't return an invalid `char`. When allocating space
-    /// for this host to copy a string into the returned pointer must be
-    /// in-bounds in memory.
-    ///
-    /// If an error happens then the error should contain detailed enough
-    /// information to understand which part of the canonical ABI went wrong
-    /// and what to inspect.
-    ///
-    /// # Panics
-    ///
-    /// Panics if this is called on a function in an asynchronous store. This
-    /// only works with functions defined within a synchonous store. Also
-    /// panics if `store` does not own this function.
-    pub fn call(&self, store: impl AsContextMut, params: Params) -> Result<Return> {
-        assert!(
-            !store.as_context().async_support(),
-            "must use `call_async` when async support is enabled on the config"
-        );
-        self.call_impl(store, params)
-    }
-
-    /// Exactly like [`Self::call`], except for use on asynchronous stores.
-    ///
-    /// # Panics
-    ///
-    /// Panics if this is called on a function in a synchronous store. This
-    /// only works with functions defined within an asynchronous store. Also
-    /// panics if `store` does not own this function.
-    #[cfg(feature = "async")]
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "async")))]
-    pub async fn call_async<T>(
-        &self,
-        mut store: impl AsContextMut<Data = T>,
-        params: Params,
-    ) -> Result<Return>
-    where
-        T: Send,
-        Params: Send + Sync,
-        Return: Send + Sync,
-    {
-        let mut store = store.as_context_mut();
-        assert!(
-            store.0.async_support(),
-            "cannot use `call_async` when async support is not enabled on the config"
-        );
-        store
-            .on_fiber(|store| self.call_impl(store, params))
-            .await?
-    }
-
-    fn call_impl(&self, mut store: impl AsContextMut, params: Params) -> Result<Return> {
-        let store = &mut store.as_context_mut();
-        // Note that this is in theory simpler than it might read at this time.
-        // Here we're doing a runtime dispatch on the `flatten_count` for the
-        // params/results to see whether they're inbounds. This creates 4 cases
-        // to handle. In reality this is a highly optimizable branch where LLVM
-        // will easily figure out that only one branch here is taken.
-        //
-        // Otherwise this current construction is done to ensure that the stack
-        // space reserved for the params/results is always of the appropriate
-        // size (as the params/results needed differ depending on the "flatten"
-        // count)
-        if Params::flatten_count() <= MAX_FLAT_PARAMS {
-            if Return::flatten_count() <= MAX_FLAT_RESULTS {
-                self.func.call_raw(
-                    store,
-                    &params,
-                    Self::lower_stack_args,
-                    Self::lift_stack_result,
-                )
-            } else {
-                self.func.call_raw(
-                    store,
-                    &params,
-                    Self::lower_stack_args,
-                    Self::lift_heap_result,
-                )
-            }
-        } else {
-            if Return::flatten_count() <= MAX_FLAT_RESULTS {
-                self.func.call_raw(
-                    store,
-                    &params,
-                    Self::lower_heap_args,
-                    Self::lift_stack_result,
-                )
-            } else {
-                self.func.call_raw(
-                    store,
-                    &params,
-                    Self::lower_heap_args,
-                    Self::lift_heap_result,
-                )
-            }
-        }
-    }
-
-    /// Lower parameters directly onto the stack specified by the `dst`
-    /// location.
-    ///
-    /// This is only valid to call when the "flatten count" is small enough, or
-    /// when the canonical ABI says arguments go through the stack rather than
-    /// the heap.
-    fn lower_stack_args<T>(
-        cx: &mut LowerContext<'_, T>,
-        params: &Params,
-        ty: InterfaceType,
-        dst: &mut MaybeUninit<Params::Lower>,
-    ) -> Result<()> {
-        assert!(Params::flatten_count() <= MAX_FLAT_PARAMS);
-        params.lower(cx, ty, dst)?;
-        Ok(())
-    }
-
-    /// Lower parameters onto a heap-allocated location.
-    ///
-    /// This is used when the stack space to be used for the arguments is above
-    /// the `MAX_FLAT_PARAMS` threshold. Here the wasm's `realloc` function is
-    /// invoked to allocate space and then parameters are stored at that heap
-    /// pointer location.
-    fn lower_heap_args<T>(
-        cx: &mut LowerContext<'_, T>,
-        params: &Params,
-        ty: InterfaceType,
-        dst: &mut MaybeUninit<ValRaw>,
-    ) -> Result<()> {
-        assert!(Params::flatten_count() > MAX_FLAT_PARAMS);
-
-        // Memory must exist via validation if the arguments are stored on the
-        // heap, so we can create a `MemoryMut` at this point. Afterwards
-        // `realloc` is used to allocate space for all the arguments and then
-        // they're all stored in linear memory.
-        //
-        // Note that `realloc` will bake in a check that the returned pointer is
-        // in-bounds.
-        let ptr = cx.realloc(0, 0, Params::ALIGN32, Params::SIZE32)?;
-        params.store(cx, ty, ptr)?;
-
-        // Note that the pointer here is stored as a 64-bit integer. This allows
-        // this to work with either 32 or 64-bit memories. For a 32-bit memory
-        // it'll just ignore the upper 32 zero bits, and for 64-bit memories
-        // this'll have the full 64-bits. Note that for 32-bit memories the call
-        // to `realloc` above guarantees that the `ptr` is in-bounds meaning
-        // that we will know that the zero-extended upper bits of `ptr` are
-        // guaranteed to be zero.
-        //
-        // This comment about 64-bit integers is also referred to below with
-        // "WRITEPTR64".
-        dst.write(ValRaw::i64(ptr as i64));
-
-        Ok(())
-    }
-
-    /// Lift the result of a function directly from the stack result.
-    ///
-    /// This is only used when the result fits in the maximum number of stack
-    /// slots.
-    fn lift_stack_result(
-        cx: &mut LiftContext<'_>,
-        ty: InterfaceType,
-        dst: &Return::Lower,
-    ) -> Result<Return> {
-        assert!(Return::flatten_count() <= MAX_FLAT_RESULTS);
-        Return::lift(cx, ty, dst)
-    }
-
-    /// Lift the result of a function where the result is stored indirectly on
-    /// the heap.
-    fn lift_heap_result(
-        cx: &mut LiftContext<'_>,
-        ty: InterfaceType,
-        dst: &ValRaw,
-    ) -> Result<Return> {
-        assert!(Return::flatten_count() > MAX_FLAT_RESULTS);
-        // FIXME: needs to read an i64 for memory64
-        let ptr = usize::try_from(dst.get_u32())?;
-        if ptr % usize::try_from(Return::ALIGN32)? != 0 {
-            bail!("return pointer not aligned");
-        }
-
-        let bytes = cx
-            .memory()
-            .get(ptr..)
-            .and_then(|b| b.get(..Return::SIZE32))
-            .ok_or_else(|| anyhow::anyhow!("pointer out of bounds of memory"))?;
-        Return::load(cx, ty, bytes)
-    }
-
-    /// See [`Func::post_return`]
-    pub fn post_return(&self, store: impl AsContextMut) -> Result<()> {
-        self.func.post_return(store)
-    }
-
-    /// See [`Func::post_return_async`]
-    #[cfg(feature = "async")]
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "async")))]
-    pub async fn post_return_async<T: Send>(
-        &self,
-        store: impl AsContextMut<Data = T>,
-    ) -> Result<()> {
-        self.func.post_return_async(store).await
-    }
-}
-
-/// A trait representing a static list of named types that can be passed to or
-/// returned from a [`TypedFunc`].
-///
-/// This trait is implemented for a number of tuple types and is not expected
-/// to be implemented externally. The contents of this trait are hidden as it's
-/// intended to be an implementation detail of Wasmtime. The contents of this
-/// trait are not covered by Wasmtime's stability guarantees.
-///
-/// For more information about this trait see [`Func::typed`] and
-/// [`TypedFunc`].
-//
-// Note that this is an `unsafe` trait, and the unsafety means that
-// implementations of this trait must be correct or otherwise [`TypedFunc`]
-// would not be memory safe. The main reason this is `unsafe` is the
-// `typecheck` function which must operate correctly relative to the `AsTuple`
-// interpretation of the implementor.
-pub unsafe trait ComponentNamedList: ComponentType {}
-
-/// A trait representing types which can be passed to and read from components
-/// with the canonical ABI.
-///
-/// This trait is implemented for Rust types which can be communicated to
-/// components. This is implemented for Rust types which correspond to
-/// interface types in the component model of WebAssembly. The [`Func::typed`]
-/// and [`TypedFunc`] Rust items are the main consumers of this trait.
-///
-/// For more information on this trait see the examples in [`Func::typed`].
-///
-/// The contents of this trait are hidden as it's intended to be an
-/// implementation detail of Wasmtime. The contents of this trait are not
-/// covered by Wasmtime's stability guarantees.
-//
-// Note that this is an `unsafe` trait as `TypedFunc`'s safety heavily relies on
-// the correctness of the implementations of this trait. Some ways in which this
-// trait must be correct to be safe are:
-//
-// * The `Lower` associated type must be a `ValRaw` sequence. It doesn't have to
-//   literally be `[ValRaw; N]` but when laid out in memory it must be adjacent
-//   `ValRaw` values and have a multiple of the size of `ValRaw` and the same
-//   alignment.
-//
-// * The `lower` function must initialize the bits within `Lower` that are going
-//   to be read by the trampoline that's used to enter core wasm. A trampoline
-//   is passed `*mut Lower` and will read the canonical abi arguments in
-//   sequence, so all of the bits must be correctly initialized.
-//
-// * The `size` and `align` functions must be correct for this value stored in
-//   the canonical ABI. The `Cursor<T>` iteration of these bytes rely on this
-//   for correctness as they otherwise eschew bounds-checking.
-//
-// There are likely some other correctness issues which aren't documented as
-// well, this isn't intended to be an exhaustive list. It suffices to say,
-// though, that correctness bugs in this trait implementation are highly likely
-// to lead to security bugs, which again leads to the `unsafe` in the trait.
-//
-// Also note that this trait specifically is not sealed because we have a proc
-// macro that generates implementations of this trait for external types in a
-// `#[derive]`-like fashion.
-pub unsafe trait ComponentType {
-    /// Representation of the "lowered" form of this component value.
-    ///
-    /// Lowerings lower into core wasm values which are represented by `ValRaw`.
-    /// This `Lower` type must be a list of `ValRaw` as either a literal array
-    /// or a struct where every field is a `ValRaw`. This must be `Copy` (as
-    /// `ValRaw` is `Copy`) and support all byte patterns. This being correct is
-    /// one reason why the trait is unsafe.
-    #[doc(hidden)]
-    type Lower: Copy;
-
-    /// The information about this type's canonical ABI (size/align/etc).
-    #[doc(hidden)]
-    const ABI: CanonicalAbiInfo;
-
-    #[doc(hidden)]
-    const SIZE32: usize = Self::ABI.size32 as usize;
-    #[doc(hidden)]
-    const ALIGN32: u32 = Self::ABI.align32;
-
-    #[doc(hidden)]
-    const IS_RUST_UNIT_TYPE: bool = false;
-
-    /// Returns the number of core wasm abi values will be used to represent
-    /// this type in its lowered form.
-    ///
-    /// This divides the size of `Self::Lower` by the size of `ValRaw`.
-    #[doc(hidden)]
-    fn flatten_count() -> usize {
-        assert!(mem::size_of::<Self::Lower>() % mem::size_of::<ValRaw>() == 0);
-        assert!(mem::align_of::<Self::Lower>() == mem::align_of::<ValRaw>());
-        mem::size_of::<Self::Lower>() / mem::size_of::<ValRaw>()
-    }
-
-    /// Performs a type-check to see whether this component value type matches
-    /// the interface type `ty` provided.
-    #[doc(hidden)]
-    fn typecheck(ty: &InterfaceType, types: &InstanceType<'_>) -> Result<()>;
-}
-
-#[doc(hidden)]
-pub unsafe trait ComponentVariant: ComponentType {
-    const CASES: &'static [Option<CanonicalAbiInfo>];
-    const INFO: VariantInfo = VariantInfo::new_static(Self::CASES);
-    const PAYLOAD_OFFSET32: usize = Self::INFO.payload_offset32 as usize;
-}
-
-/// Host types which can be passed to WebAssembly components.
-///
-/// This trait is implemented for all types that can be passed to components
-/// either as parameters of component exports or returns of component imports.
-/// This trait represents the ability to convert from the native host
-/// representation to the canonical ABI.
-//
-// TODO: #[derive(Lower)]
-// TODO: more docs here
-pub unsafe trait Lower: ComponentType {
-    /// Performs the "lower" function in the canonical ABI.
-    ///
-    /// This method will lower the current value into a component. The `lower`
-    /// function performs a "flat" lowering into the `dst` specified which is
-    /// allowed to be uninitialized entering this method but is guaranteed to be
-    /// fully initialized if the method returns `Ok(())`.
-    ///
-    /// The `cx` context provided is the context within which this lowering is
-    /// happening. This contains information such as canonical options specified
-    /// (e.g. string encodings, memories, etc), the store itself, along with
-    /// type information.
-    ///
-    /// The `ty` parameter is the destination type that is being lowered into.
-    /// For example this is the component's "view" of the type that is being
-    /// lowered. This is guaranteed to have passed a `typecheck` earlier.
-    ///
-    /// This will only be called if `typecheck` passes for `Op::Lower`.
-    #[doc(hidden)]
-    fn lower<T>(
-        &self,
-        cx: &mut LowerContext<'_, T>,
-        ty: InterfaceType,
-        dst: &mut MaybeUninit<Self::Lower>,
-    ) -> Result<()>;
-
-    /// Performs the "store" operation in the canonical ABI.
-    ///
-    /// This function will store `self` into the linear memory described by
-    /// `cx` at the `offset` provided.
-    ///
-    /// It is expected that `offset` is a valid offset in memory for
-    /// `Self::SIZE32` bytes. At this time that's not an unsafe contract as it's
-    /// always re-checked on all stores, but this is something that will need to
-    /// be improved in the future to remove extra bounds checks. For now this
-    /// function will panic if there's a bug and `offset` isn't valid within
-    /// memory.
-    ///
-    /// The `ty` type information passed here is the same as the type
-    /// information passed to `lower` above, and is the component's own view of
-    /// what the resulting type should be.
-    ///
-    /// This will only be called if `typecheck` passes for `Op::Lower`.
-    #[doc(hidden)]
-    fn store<T>(
-        &self,
-        cx: &mut LowerContext<'_, T>,
-        ty: InterfaceType,
-        offset: usize,
-    ) -> Result<()>;
-
-    /// Provided method to lower a list of `Self` into memory.
-    ///
-    /// Requires that `offset` has already been checked for alignment and
-    /// validity in terms of being in-bounds, otherwise this may panic.
-    ///
-    /// This is primarily here to get overridden for implementations of integers
-    /// which can avoid some extra fluff and use a pattern that's more easily
-    /// optimizable by LLVM.
-    #[doc(hidden)]
-    fn store_list<T>(
-        cx: &mut LowerContext<'_, T>,
-        ty: InterfaceType,
-        mut offset: usize,
-        items: &[Self],
-    ) -> Result<()>
-    where
-        Self: Sized,
-    {
-        for item in items {
-            item.store(cx, ty, offset)?;
-            offset += Self::SIZE32;
-        }
-        Ok(())
-    }
-}
-
-/// Host types which can be created from the canonical ABI.
-//
-// TODO: #[derive(Lower)]
-// TODO: more docs here
-pub unsafe trait Lift: Sized + ComponentType {
-    /// Performs the "lift" operation in the canonical ABI.
-    ///
-    /// This function performs a "flat" lift operation from the `src` specified
-    /// which is a sequence of core wasm values. The lifting operation will
-    /// validate core wasm values and produce a `Self` on success.
-    ///
-    /// The `cx` provided contains contextual information such as the store
-    /// that's being loaded from, canonical options, and type information.
-    ///
-    /// The `ty` parameter is the origin component's specification for what the
-    /// type that is being lifted is. For example this is the record type or the
-    /// resource type that is being lifted.
-    ///
-    /// Note that this has a default implementation but if `typecheck` passes
-    /// for `Op::Lift` this needs to be overridden.
-    #[doc(hidden)]
-    fn lift(cx: &mut LiftContext<'_>, ty: InterfaceType, src: &Self::Lower) -> Result<Self>;
-
-    /// Performs the "load" operation in the canonical ABI.
-    ///
-    /// This will read the `bytes` provided, which are a sub-slice into the
-    /// linear memory described by `cx`. The `bytes` array provided is
-    /// guaranteed to be `Self::SIZE32` bytes large. All of memory is then also
-    /// available through `cx` for bounds-checks and such as necessary for
-    /// strings/lists.
-    ///
-    /// The `ty` argument is the type that's being loaded, as described by the
-    /// original component.
-    ///
-    /// Note that this has a default implementation but if `typecheck` passes
-    /// for `Op::Lift` this needs to be overridden.
-    #[doc(hidden)]
-    fn load(cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Self>;
-
-    /// Converts `list` into a `Vec<T>`, used in `Lift for Vec<T>`.
-    ///
-    /// This is primarily here to get overridden for implementations of integers
-    /// which can avoid some extra fluff and use a pattern that's more easily
-    /// optimizable by LLVM.
-    #[doc(hidden)]
-    fn load_list(cx: &mut LiftContext<'_>, list: &WasmList<Self>) -> Result<Vec<Self>>
-    where
-        Self: Sized,
-    {
-        (0..list.len)
-            .map(|index| list.get_from_store(cx, index).unwrap())
-            .collect()
-    }
-}
-
-// Macro to help generate "forwarding implementations" of `ComponentType` to
-// another type, used for wrappers in Rust like `&T`, `Box<T>`, etc. Note that
-// these wrappers only implement lowering because lifting native Rust types
-// cannot be done.
-macro_rules! forward_type_impls {
-    ($(($($generics:tt)*) $a:ty => $b:ty,)*) => ($(
-        unsafe impl <$($generics)*> ComponentType for $a {
-            type Lower = <$b as ComponentType>::Lower;
-
-            const ABI: CanonicalAbiInfo = <$b as ComponentType>::ABI;
-
-            #[inline]
-            fn typecheck(ty: &InterfaceType, types: &InstanceType<'_>) -> Result<()> {
-                <$b as ComponentType>::typecheck(ty, types)
-            }
-        }
-    )*)
-}
-
-forward_type_impls! {
-    (T: ComponentType + ?Sized) &'_ T => T,
-    (T: ComponentType + ?Sized) Box<T> => T,
-    (T: ComponentType + ?Sized) std::rc::Rc<T> => T,
-    (T: ComponentType + ?Sized) std::sync::Arc<T> => T,
-    () String => str,
-    (T: ComponentType) Vec<T> => [T],
-}
-
-macro_rules! forward_lowers {
-    ($(($($generics:tt)*) $a:ty => $b:ty,)*) => ($(
-        unsafe impl <$($generics)*> Lower for $a {
-            fn lower<U>(
-                &self,
-                cx: &mut LowerContext<'_, U>,
-                ty: InterfaceType,
-                dst: &mut MaybeUninit<Self::Lower>,
-            ) -> Result<()> {
-                <$b as Lower>::lower(self, cx, ty, dst)
-            }
-
-            fn store<U>(
-                &self,
-                cx: &mut LowerContext<'_, U>,
-                ty: InterfaceType,
-                offset: usize,
-            ) -> Result<()> {
-                <$b as Lower>::store(self, cx, ty, offset)
-            }
-        }
-    )*)
-}
-
-forward_lowers! {
-    (T: Lower + ?Sized) &'_ T => T,
-    (T: Lower + ?Sized) Box<T> => T,
-    (T: Lower + ?Sized) std::rc::Rc<T> => T,
-    (T: Lower + ?Sized) std::sync::Arc<T> => T,
-    () String => str,
-    (T: Lower) Vec<T> => [T],
-}
-
-macro_rules! forward_string_lifts {
-    ($($a:ty,)*) => ($(
-        unsafe impl Lift for $a {
-            #[inline]
-            fn lift(cx: &mut LiftContext<'_>, ty: InterfaceType, src: &Self::Lower) -> Result<Self> {
-                Ok(<WasmStr as Lift>::lift(cx, ty, src)?.to_str_from_memory(cx.memory())?.into())
-            }
-
-            #[inline]
-            fn load(cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Self> {
-                Ok(<WasmStr as Lift>::load(cx, ty, bytes)?.to_str_from_memory(cx.memory())?.into())
-            }
-        }
-    )*)
-}
-
-forward_string_lifts! {
-    Box<str>,
-    std::rc::Rc<str>,
-    std::sync::Arc<str>,
-    String,
-}
-
-macro_rules! forward_list_lifts {
-    ($($a:ty,)*) => ($(
-        unsafe impl <T: Lift> Lift for $a {
-            fn lift(cx: &mut LiftContext<'_>, ty: InterfaceType, src: &Self::Lower) -> Result<Self> {
-                let list = <WasmList::<T> as Lift>::lift(cx, ty, src)?;
-                Ok(T::load_list(cx, &list)?.into())
-            }
-
-            fn load(cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Self> {
-                let list = <WasmList::<T> as Lift>::load(cx, ty, bytes)?;
-                Ok(T::load_list(cx, &list)?.into())
-            }
-        }
-    )*)
-}
-
-forward_list_lifts! {
-    Box<[T]>,
-    std::rc::Rc<[T]>,
-    std::sync::Arc<[T]>,
-    Vec<T>,
-}
-
-// Macro to help generate `ComponentType` implementations for primitive types
-// such as integers, char, bool, etc.
-macro_rules! integers {
-    ($($primitive:ident = $ty:ident in $field:ident/$get:ident with abi:$abi:ident,)*) => ($(
-        unsafe impl ComponentType for $primitive {
-            type Lower = ValRaw;
-
-            const ABI: CanonicalAbiInfo = CanonicalAbiInfo::$abi;
-
-            fn typecheck(ty: &InterfaceType, _types: &InstanceType<'_>) -> Result<()> {
-                match ty {
-                    InterfaceType::$ty => Ok(()),
-                    other => bail!("expected `{}` found `{}`", desc(&InterfaceType::$ty), desc(other))
-                }
-            }
-        }
-
-        unsafe impl Lower for $primitive {
-            #[inline]
-            fn lower<T>(
-                &self,
-                _cx: &mut LowerContext<'_, T>,
-                ty: InterfaceType,
-                dst: &mut MaybeUninit<Self::Lower>,
-            ) -> Result<()> {
-                debug_assert!(matches!(ty, InterfaceType::$ty));
-                dst.write(ValRaw::$field(*self as $field));
-                Ok(())
-            }
-
-            #[inline]
-            fn store<T>(
-                &self,
-                cx: &mut LowerContext<'_, T>,
-                ty: InterfaceType,
-                offset: usize,
-            ) -> Result<()> {
-                debug_assert!(matches!(ty, InterfaceType::$ty));
-                debug_assert!(offset % Self::SIZE32 == 0);
-                *cx.get(offset) = self.to_le_bytes();
-                Ok(())
-            }
-
-            fn store_list<T>(
-                cx: &mut LowerContext<'_, T>,
-                ty: InterfaceType,
-                offset: usize,
-                items: &[Self],
-            ) -> Result<()> {
-                debug_assert!(matches!(ty, InterfaceType::$ty));
-
-                // Double-check that the CM alignment is at least the host's
-                // alignment for this type which should be true for all
-                // platforms.
-                assert!((Self::ALIGN32 as usize) >= mem::align_of::<Self>());
-
-                // Slice `cx`'s memory to the window that we'll be modifying.
-                // This should all have already been verified in terms of
-                // alignment and sizing meaning that these assertions here are
-                // not truly necessary but are instead double-checks.
-                //
-                // Note that we're casting a `[u8]` slice to `[Self]` with
-                // `align_to_mut` which is not safe in general but is safe in
-                // our specific case as all `u8` patterns are valid `Self`
-                // patterns since `Self` is an integral type.
-                let dst = &mut cx.as_slice_mut()[offset..][..items.len() * Self::SIZE32];
-                let (before, middle, end) = unsafe { dst.align_to_mut::<Self>() };
-                assert!(before.is_empty() && end.is_empty());
-                assert_eq!(middle.len(), items.len());
-
-                // And with all that out of the way perform the copying loop.
-                // This is not a `copy_from_slice` because endianness needs to
-                // be handled here, but LLVM should pretty easily transform this
-                // into a memcpy on little-endian platforms.
-                for (dst, src) in middle.iter_mut().zip(items) {
-                    *dst = src.to_le();
-                }
-                Ok(())
-            }
-        }
-
-        unsafe impl Lift for $primitive {
-            #[inline]
-            fn lift(_cx: &mut LiftContext<'_>, ty: InterfaceType, src: &Self::Lower) -> Result<Self> {
-                debug_assert!(matches!(ty, InterfaceType::$ty));
-                Ok(src.$get() as $primitive)
-            }
-
-            #[inline]
-            fn load(_cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Self> {
-                debug_assert!(matches!(ty, InterfaceType::$ty));
-                debug_assert!((bytes.as_ptr() as usize) % Self::SIZE32 == 0);
-                Ok($primitive::from_le_bytes(bytes.try_into().unwrap()))
-            }
-
-            fn load_list(cx: &mut LiftContext<'_>, list: &WasmList<Self>) -> Result<Vec<Self>> {
-                Ok(
-                    list._as_le_slice(cx.memory())
-                        .iter()
-                        .map(|i| Self::from_le(*i))
-                        .collect(),
-                )
-            }
-        }
-    )*)
-}
-
-integers! {
-    i8 = S8 in i32/get_i32 with abi:SCALAR1,
-    u8 = U8 in u32/get_u32 with abi:SCALAR1,
-    i16 = S16 in i32/get_i32 with abi:SCALAR2,
-    u16 = U16 in u32/get_u32 with abi:SCALAR2,
-    i32 = S32 in i32/get_i32 with abi:SCALAR4,
-    u32 = U32 in u32/get_u32 with abi:SCALAR4,
-    i64 = S64 in i64/get_i64 with abi:SCALAR8,
-    u64 = U64 in u64/get_u64 with abi:SCALAR8,
-}
-
-macro_rules! floats {
-    ($($float:ident/$get_float:ident = $ty:ident with abi:$abi:ident)*) => ($(const _: () = {
-        /// All floats in-and-out of the canonical abi always have their nan
-        /// payloads canonicalized. conveniently the `NAN` constant in rust has
-        /// the same representation as canonical nan, so we can use that for the
-        /// nan value.
-        #[inline]
-        fn canonicalize(float: $float) -> $float {
-            if float.is_nan() {
-                $float::NAN
-            } else {
-                float
-            }
-        }
-
-        unsafe impl ComponentType for $float {
-            type Lower = ValRaw;
-
-            const ABI: CanonicalAbiInfo = CanonicalAbiInfo::$abi;
-
-            fn typecheck(ty: &InterfaceType, _types: &InstanceType<'_>) -> Result<()> {
-                match ty {
-                    InterfaceType::$ty => Ok(()),
-                    other => bail!("expected `{}` found `{}`", desc(&InterfaceType::$ty), desc(other))
-                }
-            }
-        }
-
-        unsafe impl Lower for $float {
-            #[inline]
-            fn lower<T>(
-                &self,
-                _cx: &mut LowerContext<'_, T>,
-                ty: InterfaceType,
-                dst: &mut MaybeUninit<Self::Lower>,
-            ) -> Result<()> {
-                debug_assert!(matches!(ty, InterfaceType::$ty));
-                dst.write(ValRaw::$float(canonicalize(*self).to_bits()));
-                Ok(())
-            }
-
-            #[inline]
-            fn store<T>(
-                &self,
-                cx: &mut LowerContext<'_, T>,
-                ty: InterfaceType,
-                offset: usize,
-            ) -> Result<()> {
-                debug_assert!(matches!(ty, InterfaceType::$ty));
-                debug_assert!(offset % Self::SIZE32 == 0);
-                let ptr = cx.get(offset);
-                *ptr = canonicalize(*self).to_bits().to_le_bytes();
-                Ok(())
-            }
-        }
-
-        unsafe impl Lift for $float {
-            #[inline]
-            fn lift(_cx: &mut LiftContext<'_>, ty: InterfaceType, src: &Self::Lower) -> Result<Self> {
-                debug_assert!(matches!(ty, InterfaceType::$ty));
-                Ok(canonicalize($float::from_bits(src.$get_float())))
-            }
-
-            #[inline]
-            fn load(_cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Self> {
-                debug_assert!(matches!(ty, InterfaceType::$ty));
-                debug_assert!((bytes.as_ptr() as usize) % Self::SIZE32 == 0);
-                Ok(canonicalize($float::from_le_bytes(bytes.try_into().unwrap())))
-            }
-        }
-    };)*)
-}
-
-floats! {
-    f32/get_f32 = Float32 with abi:SCALAR4
-    f64/get_f64 = Float64 with abi:SCALAR8
-}
-
-unsafe impl ComponentType for bool {
-    type Lower = ValRaw;
-
-    const ABI: CanonicalAbiInfo = CanonicalAbiInfo::SCALAR1;
-
-    fn typecheck(ty: &InterfaceType, _types: &InstanceType<'_>) -> Result<()> {
-        match ty {
-            InterfaceType::Bool => Ok(()),
-            other => bail!("expected `bool` found `{}`", desc(other)),
-        }
-    }
-}
-
-unsafe impl Lower for bool {
-    fn lower<T>(
-        &self,
-        _cx: &mut LowerContext<'_, T>,
-        ty: InterfaceType,
-        dst: &mut MaybeUninit<Self::Lower>,
-    ) -> Result<()> {
-        debug_assert!(matches!(ty, InterfaceType::Bool));
-        dst.write(ValRaw::i32(*self as i32));
-        Ok(())
-    }
-
-    fn store<T>(
-        &self,
-        cx: &mut LowerContext<'_, T>,
-        ty: InterfaceType,
-        offset: usize,
-    ) -> Result<()> {
-        debug_assert!(matches!(ty, InterfaceType::Bool));
-        debug_assert!(offset % Self::SIZE32 == 0);
-        cx.get::<1>(offset)[0] = *self as u8;
-        Ok(())
-    }
-}
-
-unsafe impl Lift for bool {
-    #[inline]
-    fn lift(_cx: &mut LiftContext<'_>, ty: InterfaceType, src: &Self::Lower) -> Result<Self> {
-        debug_assert!(matches!(ty, InterfaceType::Bool));
-        match src.get_i32() {
-            0 => Ok(false),
-            _ => Ok(true),
-        }
-    }
-
-    #[inline]
-    fn load(_cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Self> {
-        debug_assert!(matches!(ty, InterfaceType::Bool));
-        match bytes[0] {
-            0 => Ok(false),
-            _ => Ok(true),
-        }
-    }
-}
-
-unsafe impl ComponentType for char {
-    type Lower = ValRaw;
-
-    const ABI: CanonicalAbiInfo = CanonicalAbiInfo::SCALAR4;
-
-    fn typecheck(ty: &InterfaceType, _types: &InstanceType<'_>) -> Result<()> {
-        match ty {
-            InterfaceType::Char => Ok(()),
-            other => bail!("expected `char` found `{}`", desc(other)),
-        }
-    }
-}
-
-unsafe impl Lower for char {
-    #[inline]
-    fn lower<T>(
-        &self,
-        _cx: &mut LowerContext<'_, T>,
-        ty: InterfaceType,
-        dst: &mut MaybeUninit<Self::Lower>,
-    ) -> Result<()> {
-        debug_assert!(matches!(ty, InterfaceType::Char));
-        dst.write(ValRaw::u32(u32::from(*self)));
-        Ok(())
-    }
-
-    #[inline]
-    fn store<T>(
-        &self,
-        cx: &mut LowerContext<'_, T>,
-        ty: InterfaceType,
-        offset: usize,
-    ) -> Result<()> {
-        debug_assert!(matches!(ty, InterfaceType::Char));
-        debug_assert!(offset % Self::SIZE32 == 0);
-        *cx.get::<4>(offset) = u32::from(*self).to_le_bytes();
-        Ok(())
-    }
-}
-
-unsafe impl Lift for char {
-    #[inline]
-    fn lift(_cx: &mut LiftContext<'_>, ty: InterfaceType, src: &Self::Lower) -> Result<Self> {
-        debug_assert!(matches!(ty, InterfaceType::Char));
-        Ok(char::try_from(src.get_u32())?)
-    }
-
-    #[inline]
-    fn load(_cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Self> {
-        debug_assert!(matches!(ty, InterfaceType::Char));
-        debug_assert!((bytes.as_ptr() as usize) % Self::SIZE32 == 0);
-        let bits = u32::from_le_bytes(bytes.try_into().unwrap());
-        Ok(char::try_from(bits)?)
-    }
-}
-
-// TODO: these probably need different constants for memory64
-const UTF16_TAG: usize = 1 << 31;
-const MAX_STRING_BYTE_LENGTH: usize = (1 << 31) - 1;
-
-// Note that this is similar to `ComponentType for WasmStr` except it can only
-// be used for lowering, not lifting.
-unsafe impl ComponentType for str {
-    type Lower = [ValRaw; 2];
-
-    const ABI: CanonicalAbiInfo = CanonicalAbiInfo::POINTER_PAIR;
-
-    fn typecheck(ty: &InterfaceType, _types: &InstanceType<'_>) -> Result<()> {
-        match ty {
-            InterfaceType::String => Ok(()),
-            other => bail!("expected `string` found `{}`", desc(other)),
-        }
-    }
-}
-
-unsafe impl Lower for str {
-    fn lower<T>(
-        &self,
-        cx: &mut LowerContext<'_, T>,
-        ty: InterfaceType,
-        dst: &mut MaybeUninit<[ValRaw; 2]>,
-    ) -> Result<()> {
-        debug_assert!(matches!(ty, InterfaceType::String));
-        let (ptr, len) = lower_string(cx, self)?;
-        // See "WRITEPTR64" above for why this is always storing a 64-bit
-        // integer.
-        map_maybe_uninit!(dst[0]).write(ValRaw::i64(ptr as i64));
-        map_maybe_uninit!(dst[1]).write(ValRaw::i64(len as i64));
-        Ok(())
-    }
-
-    fn store<T>(
-        &self,
-        cx: &mut LowerContext<'_, T>,
-        ty: InterfaceType,
-        offset: usize,
-    ) -> Result<()> {
-        debug_assert!(matches!(ty, InterfaceType::String));
-        debug_assert!(offset % (Self::ALIGN32 as usize) == 0);
-        let (ptr, len) = lower_string(cx, self)?;
-        // FIXME: needs memory64 handling
-        *cx.get(offset + 0) = (ptr as i32).to_le_bytes();
-        *cx.get(offset + 4) = (len as i32).to_le_bytes();
-        Ok(())
-    }
-}
-
-fn lower_string<T>(cx: &mut LowerContext<'_, T>, string: &str) -> Result<(usize, usize)> {
-    // Note that in general the wasm module can't assume anything about what the
-    // host strings are encoded as. Additionally hosts are allowed to have
-    // differently-encoded strings at runtime. Finally when copying a string
-    // into wasm it's somewhat strict in the sense that the various patterns of
-    // allocation and such are already dictated for us.
-    //
-    // In general what this means is that when copying a string from the host
-    // into the destination we need to follow one of the cases of copying into
-    // WebAssembly. It doesn't particularly matter which case as long as it ends
-    // up in the right encoding. For example a destination encoding of
-    // latin1+utf16 has a number of ways to get copied into and we do something
-    // here that isn't the default "utf8 to latin1+utf16" since we have access
-    // to simd-accelerated helpers in the `encoding_rs` crate. This is ok though
-    // because we can fake that the host string was already stored in latin1
-    // format and follow that copy pattern instead.
-    match cx.options.string_encoding() {
-        // This corresponds to `store_string_copy` in the canonical ABI where
-        // the host's representation is utf-8 and the wasm module wants utf-8 so
-        // a copy is all that's needed (and the `realloc` can be precise for the
-        // initial memory allocation).
-        StringEncoding::Utf8 => {
-            if string.len() > MAX_STRING_BYTE_LENGTH {
-                bail!(
-                    "string length of {} too large to copy into wasm",
-                    string.len()
-                );
-            }
-            let ptr = cx.realloc(0, 0, 1, string.len())?;
-            cx.as_slice_mut()[ptr..][..string.len()].copy_from_slice(string.as_bytes());
-            Ok((ptr, string.len()))
-        }
-
-        // This corresponds to `store_utf8_to_utf16` in the canonical ABI. Here
-        // an over-large allocation is performed and then shrunk afterwards if
-        // necessary.
-        StringEncoding::Utf16 => {
-            let size = string.len() * 2;
-            if size > MAX_STRING_BYTE_LENGTH {
-                bail!(
-                    "string length of {} too large to copy into wasm",
-                    string.len()
-                );
-            }
-            let mut ptr = cx.realloc(0, 0, 2, size)?;
-            let mut copied = 0;
-            let bytes = &mut cx.as_slice_mut()[ptr..][..size];
-            for (u, bytes) in string.encode_utf16().zip(bytes.chunks_mut(2)) {
-                let u_bytes = u.to_le_bytes();
-                bytes[0] = u_bytes[0];
-                bytes[1] = u_bytes[1];
-                copied += 1;
-            }
-            if (copied * 2) < size {
-                ptr = cx.realloc(ptr, size, 2, copied * 2)?;
-            }
-            Ok((ptr, copied))
-        }
-
-        StringEncoding::CompactUtf16 => {
-            // This corresponds to `store_string_to_latin1_or_utf16`
-            let bytes = string.as_bytes();
-            let mut iter = string.char_indices();
-            let mut ptr = cx.realloc(0, 0, 2, bytes.len())?;
-            let mut dst = &mut cx.as_slice_mut()[ptr..][..bytes.len()];
-            let mut result = 0;
-            while let Some((i, ch)) = iter.next() {
-                // Test if this `char` fits into the latin1 encoding.
-                if let Ok(byte) = u8::try_from(u32::from(ch)) {
-                    dst[result] = byte;
-                    result += 1;
-                    continue;
-                }
-
-                // .. if utf16 is forced to be used then the allocation is
-                // bumped up to the maximum size.
-                let worst_case = bytes
-                    .len()
-                    .checked_mul(2)
-                    .ok_or_else(|| anyhow!("byte length overflow"))?;
-                if worst_case > MAX_STRING_BYTE_LENGTH {
-                    bail!("byte length too large");
-                }
-                ptr = cx.realloc(ptr, bytes.len(), 2, worst_case)?;
-                dst = &mut cx.as_slice_mut()[ptr..][..worst_case];
-
-                // Previously encoded latin1 bytes are inflated to their 16-bit
-                // size for utf16
-                for i in (0..result).rev() {
-                    dst[2 * i] = dst[i];
-                    dst[2 * i + 1] = 0;
-                }
-
-                // and then the remainder of the string is encoded.
-                for (u, bytes) in string[i..]
-                    .encode_utf16()
-                    .zip(dst[2 * result..].chunks_mut(2))
-                {
-                    let u_bytes = u.to_le_bytes();
-                    bytes[0] = u_bytes[0];
-                    bytes[1] = u_bytes[1];
-                    result += 1;
-                }
-                if worst_case > 2 * result {
-                    ptr = cx.realloc(ptr, worst_case, 2, 2 * result)?;
-                }
-                return Ok((ptr, result | UTF16_TAG));
-            }
-            if result < bytes.len() {
-                ptr = cx.realloc(ptr, bytes.len(), 2, result)?;
-            }
-            Ok((ptr, result))
-        }
-    }
-}
-
-/// Representation of a string located in linear memory in a WebAssembly
-/// instance.
-///
-/// This type is used with [`TypedFunc`], for example, when WebAssembly returns
-/// a string. This type cannot be used to give a string to WebAssembly, instead
-/// `&str` should be used for that (since it's coming from the host).
-///
-/// Note that this type represents an in-bounds string in linear memory, but it
-/// does not represent a valid string (e.g. valid utf-8). Validation happens
-/// when [`WasmStr::to_str`] is called.
-//
-// TODO: should probably expand this with examples
-pub struct WasmStr {
-    ptr: usize,
-    len: usize,
-    options: Options,
-}
-
-impl WasmStr {
-    fn new(ptr: usize, len: usize, cx: &mut LiftContext<'_>) -> Result<WasmStr> {
-        let byte_len = match cx.options.string_encoding() {
-            StringEncoding::Utf8 => Some(len),
-            StringEncoding::Utf16 => len.checked_mul(2),
-            StringEncoding::CompactUtf16 => {
-                if len & UTF16_TAG == 0 {
-                    Some(len)
-                } else {
-                    (len ^ UTF16_TAG).checked_mul(2)
-                }
-            }
-        };
-        match byte_len.and_then(|len| ptr.checked_add(len)) {
-            Some(n) if n <= cx.memory().len() => {}
-            _ => bail!("string pointer/length out of bounds of memory"),
-        }
-        Ok(WasmStr {
-            ptr,
-            len,
-            options: *cx.options,
-        })
-    }
-
-    /// Returns the underlying string that this cursor points to.
-    ///
-    /// Note that this will internally decode the string from the wasm's
-    /// encoding to utf-8 and additionally perform validation.
-    ///
-    /// The `store` provided must be the store where this string lives to
-    /// access the correct memory.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the string wasn't encoded correctly (e.g. invalid
-    /// utf-8).
-    ///
-    /// # Panics
-    ///
-    /// Panics if this string is not owned by `store`.
-    //
-    // TODO: should add accessors for specifically utf-8 and utf-16 that perhaps
-    // in an opt-in basis don't do validation. Additionally there should be some
-    // method that returns `[u16]` after validating to avoid the utf16-to-utf8
-    // transcode.
-    pub fn to_str<'a, T: 'a>(&self, store: impl Into<StoreContext<'a, T>>) -> Result<Cow<'a, str>> {
-        let store = store.into().0;
-        let memory = self.options.memory(store);
-        self.to_str_from_memory(memory)
-    }
-
-    fn to_str_from_memory<'a>(&self, memory: &'a [u8]) -> Result<Cow<'a, str>> {
-        match self.options.string_encoding() {
-            StringEncoding::Utf8 => self.decode_utf8(memory),
-            StringEncoding::Utf16 => self.decode_utf16(memory, self.len),
-            StringEncoding::CompactUtf16 => {
-                if self.len & UTF16_TAG == 0 {
-                    self.decode_latin1(memory)
-                } else {
-                    self.decode_utf16(memory, self.len ^ UTF16_TAG)
-                }
-            }
-        }
-    }
-
-    fn decode_utf8<'a>(&self, memory: &'a [u8]) -> Result<Cow<'a, str>> {
-        // Note that bounds-checking already happen in construction of `WasmStr`
-        // so this is never expected to panic. This could theoretically be
-        // unchecked indexing if we're feeling wild enough.
-        Ok(str::from_utf8(&memory[self.ptr..][..self.len])?.into())
-    }
-
-    fn decode_utf16<'a>(&self, memory: &'a [u8], len: usize) -> Result<Cow<'a, str>> {
-        // See notes in `decode_utf8` for why this is panicking indexing.
-        let memory = &memory[self.ptr..][..len * 2];
-        Ok(std::char::decode_utf16(
-            memory
-                .chunks(2)
-                .map(|chunk| u16::from_le_bytes(chunk.try_into().unwrap())),
-        )
-        .collect::<Result<String, _>>()?
-        .into())
-    }
-
-    fn decode_latin1<'a>(&self, memory: &'a [u8]) -> Result<Cow<'a, str>> {
-        // See notes in `decode_utf8` for why this is panicking indexing.
-        Ok(encoding_rs::mem::decode_latin1(
-            &memory[self.ptr..][..self.len],
-        ))
-    }
-}
-
-// Note that this is similar to `ComponentType for str` except it can only be
-// used for lifting, not lowering.
-unsafe impl ComponentType for WasmStr {
-    type Lower = <str as ComponentType>::Lower;
-
-    const ABI: CanonicalAbiInfo = CanonicalAbiInfo::POINTER_PAIR;
-
-    fn typecheck(ty: &InterfaceType, _types: &InstanceType<'_>) -> Result<()> {
-        match ty {
-            InterfaceType::String => Ok(()),
-            other => bail!("expected `string` found `{}`", desc(other)),
-        }
-    }
-}
-
-unsafe impl Lift for WasmStr {
-    #[inline]
-    fn lift(cx: &mut LiftContext<'_>, ty: InterfaceType, src: &Self::Lower) -> Result<Self> {
-        debug_assert!(matches!(ty, InterfaceType::String));
-        // FIXME: needs memory64 treatment
-        let ptr = src[0].get_u32();
-        let len = src[1].get_u32();
-        let (ptr, len) = (usize::try_from(ptr)?, usize::try_from(len)?);
-        WasmStr::new(ptr, len, cx)
-    }
-
-    #[inline]
-    fn load(cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Self> {
-        debug_assert!(matches!(ty, InterfaceType::String));
-        debug_assert!((bytes.as_ptr() as usize) % (Self::ALIGN32 as usize) == 0);
-        // FIXME: needs memory64 treatment
-        let ptr = u32::from_le_bytes(bytes[..4].try_into().unwrap());
-        let len = u32::from_le_bytes(bytes[4..].try_into().unwrap());
-        let (ptr, len) = (usize::try_from(ptr)?, usize::try_from(len)?);
-        WasmStr::new(ptr, len, cx)
-    }
-}
-
-unsafe impl<T> ComponentType for [T]
-where
-    T: ComponentType,
-{
-    type Lower = [ValRaw; 2];
-
-    const ABI: CanonicalAbiInfo = CanonicalAbiInfo::POINTER_PAIR;
-
-    fn typecheck(ty: &InterfaceType, types: &InstanceType<'_>) -> Result<()> {
-        match ty {
-            InterfaceType::List(t) => T::typecheck(&types.types[*t].element, types),
-            other => bail!("expected `list` found `{}`", desc(other)),
-        }
-    }
-}
-
-unsafe impl<T> Lower for [T]
-where
-    T: Lower,
-{
-    fn lower<U>(
-        &self,
-        cx: &mut LowerContext<'_, U>,
-        ty: InterfaceType,
-        dst: &mut MaybeUninit<[ValRaw; 2]>,
-    ) -> Result<()> {
-        let elem = match ty {
-            InterfaceType::List(i) => cx.types[i].element,
-            _ => bad_type_info(),
-        };
-        let (ptr, len) = lower_list(cx, elem, self)?;
-        // See "WRITEPTR64" above for why this is always storing a 64-bit
-        // integer.
-        map_maybe_uninit!(dst[0]).write(ValRaw::i64(ptr as i64));
-        map_maybe_uninit!(dst[1]).write(ValRaw::i64(len as i64));
-        Ok(())
-    }
-
-    fn store<U>(
-        &self,
-        cx: &mut LowerContext<'_, U>,
-        ty: InterfaceType,
-        offset: usize,
-    ) -> Result<()> {
-        let elem = match ty {
-            InterfaceType::List(i) => cx.types[i].element,
-            _ => bad_type_info(),
-        };
-        debug_assert!(offset % (Self::ALIGN32 as usize) == 0);
-        let (ptr, len) = lower_list(cx, elem, self)?;
-        *cx.get(offset + 0) = (ptr as i32).to_le_bytes();
-        *cx.get(offset + 4) = (len as i32).to_le_bytes();
-        Ok(())
-    }
-}
-
-// FIXME: this is not a memcpy for `T` where `T` is something like `u8`.
-//
-// Some attempts to fix this have proved not fruitful. In isolation an attempt
-// was made where:
-//
-// * `MemoryMut` stored a `*mut [u8]` as its "last view" of memory to avoid
-//   reloading the base pointer constantly. This view is reset on `realloc`.
-// * The bounds-checks in `MemoryMut::get` were removed (replaced with unsafe
-//   indexing)
-//
-// Even then though this didn't correctly vectorized for `Vec<u8>`. It's not
-// entirely clear why but it appeared that it's related to reloading the base
-// pointer fo memory (I guess from `MemoryMut` itself?). Overall I'm not really
-// clear on what's happening there, but this is surely going to be a performance
-// bottleneck in the future.
-fn lower_list<T, U>(
-    cx: &mut LowerContext<'_, U>,
-    ty: InterfaceType,
-    list: &[T],
-) -> Result<(usize, usize)>
-where
-    T: Lower,
-{
-    let elem_size = T::SIZE32;
-    let size = list
-        .len()
-        .checked_mul(elem_size)
-        .ok_or_else(|| anyhow!("size overflow copying a list"))?;
-    let ptr = cx.realloc(0, 0, T::ALIGN32, size)?;
-    T::store_list(cx, ty, ptr, list)?;
-    Ok((ptr, list.len()))
-}
-
-/// Representation of a list of values that are owned by a WebAssembly instance.
-///
-/// This type is used whenever a `(list T)` is returned from a [`TypedFunc`],
-/// for example. This type represents a list of values that are stored in linear
-/// memory which are waiting to be read.
-///
-/// Note that this type represents only a valid range of bytes for the list
-/// itself, it does not represent validity of the elements themselves and that's
-/// performed when they're iterated.
-pub struct WasmList<T> {
-    ptr: usize,
-    len: usize,
-    options: Options,
-    elem: InterfaceType,
-    // NB: it would probably be more efficient to store a non-atomic index-style
-    // reference to something inside a `StoreOpaque`, but that's not easily
-    // available at this time, so it's left as a future exercise.
-    types: Arc<ComponentTypes>,
-    instance: SendSyncPtr<ComponentInstance>,
-    _marker: marker::PhantomData<T>,
-}
-
-impl<T: Lift> WasmList<T> {
-    fn new(
-        ptr: usize,
-        len: usize,
-        cx: &mut LiftContext<'_>,
-        elem: InterfaceType,
-    ) -> Result<WasmList<T>> {
-        match len
-            .checked_mul(T::SIZE32)
-            .and_then(|len| ptr.checked_add(len))
-        {
-            Some(n) if n <= cx.memory().len() => {}
-            _ => bail!("list pointer/length out of bounds of memory"),
-        }
-        if ptr % usize::try_from(T::ALIGN32)? != 0 {
-            bail!("list pointer is not aligned")
-        }
-        Ok(WasmList {
-            ptr,
-            len,
-            options: *cx.options,
-            elem,
-            types: cx.types.clone(),
-            instance: SendSyncPtr::new(NonNull::new(cx.instance_ptr()).unwrap()),
-            _marker: marker::PhantomData,
-        })
-    }
-
-    /// Returns the item length of this vector
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.len
-    }
-
-    /// Gets the `n`th element of this list.
-    ///
-    /// Returns `None` if `index` is out of bounds. Returns `Some(Err(..))` if
-    /// the value couldn't be decoded (it was invalid). Returns `Some(Ok(..))`
-    /// if the value is valid.
-    ///
-    /// # Panics
-    ///
-    /// This function will panic if the string did not originally come from the
-    /// `store` specified.
-    //
-    // TODO: given that interface values are intended to be consumed in one go
-    // should we even expose a random access iteration API? In theory all
-    // consumers should be validating through the iterator.
-    pub fn get(&self, mut store: impl AsContextMut, index: usize) -> Option<Result<T>> {
-        let store = store.as_context_mut().0;
-        self.options.store_id().assert_belongs_to(store.id());
-        // This should be safe because the unsafety lies in the `self.instance`
-        // pointer passed in has previously been validated by the lifting
-        // context this was originally created within and with the check above
-        // this is guaranteed to be the same store. This means that this should
-        // be carrying over the original assertion from the original creation of
-        // the lifting context that created this type.
-        let mut cx =
-            unsafe { LiftContext::new(store, &self.options, &self.types, self.instance.as_ptr()) };
-        self.get_from_store(&mut cx, index)
-    }
-
-    fn get_from_store(&self, cx: &mut LiftContext<'_>, index: usize) -> Option<Result<T>> {
-        if index >= self.len {
-            return None;
-        }
-        // Note that this is using panicking indexing and this is expected to
-        // never fail. The bounds-checking here happened during the construction
-        // of the `WasmList` itself which means these should always be in-bounds
-        // (and wasm memory can only grow). This could theoretically be
-        // unchecked indexing if we're confident enough and it's actually a perf
-        // issue one day.
-        let bytes = &cx.memory()[self.ptr + index * T::SIZE32..][..T::SIZE32];
-        Some(T::load(cx, self.elem, bytes))
-    }
-
-    /// Returns an iterator over the elements of this list.
-    ///
-    /// Each item of the list may fail to decode and is represented through the
-    /// `Result` value of the iterator.
-    pub fn iter<'a, U: 'a>(
-        &'a self,
-        store: impl Into<StoreContextMut<'a, U>>,
-    ) -> impl ExactSizeIterator<Item = Result<T>> + 'a {
-        let store = store.into().0;
-        self.options.store_id().assert_belongs_to(store.id());
-        // See comments about unsafety in the `get` method.
-        let mut cx =
-            unsafe { LiftContext::new(store, &self.options, &self.types, self.instance.as_ptr()) };
-        (0..self.len).map(move |i| self.get_from_store(&mut cx, i).unwrap())
-    }
-}
-
-macro_rules! raw_wasm_list_accessors {
-    ($($i:ident)*) => ($(
-        impl WasmList<$i> {
-            /// Get access to the raw underlying memory for this list.
-            ///
-            /// This method will return a direct slice into the original wasm
-            /// module's linear memory where the data for this slice is stored.
-            /// This allows the embedder to have efficient access to the
-            /// underlying memory if needed and avoid copies and such if
-            /// desired.
-            ///
-            /// Note that multi-byte integers are stored in little-endian format
-            /// so portable processing of this slice must be aware of the host's
-            /// byte-endianness. The `from_le` constructors in the Rust standard
-            /// library should be suitable for converting from little-endian.
-            ///
-            /// # Panics
-            ///
-            /// Panics if the `store` provided is not the one from which this
-            /// slice originated.
-            pub fn as_le_slice<'a, T: 'a>(&self, store: impl Into<StoreContext<'a, T>>) -> &'a [$i] {
-                let memory = self.options.memory(store.into().0);
-                self._as_le_slice(memory)
-            }
-
-            fn _as_le_slice<'a>(&self, all_of_memory: &'a [u8]) -> &'a [$i] {
-                // See comments in `WasmList::get` for the panicking indexing
-                let byte_size = self.len * mem::size_of::<$i>();
-                let bytes = &all_of_memory[self.ptr..][..byte_size];
-
-                // The canonical ABI requires that everything is aligned to its
-                // own size, so this should be an aligned array. Furthermore the
-                // alignment of primitive integers for hosts should be smaller
-                // than or equal to the size of the primitive itself, meaning
-                // that a wasm canonical-abi-aligned list is also aligned for
-                // the host. That should mean that the head/tail slices here are
-                // empty.
-                //
-                // Also note that the `unsafe` here is needed since the type
-                // we're aligning to isn't guaranteed to be valid, but in our
-                // case it's just integers and bytes so this should be safe.
-                unsafe {
-                    let (head, body, tail) = bytes.align_to::<$i>();
-                    assert!(head.is_empty() && tail.is_empty());
-                    body
-                }
-            }
-        }
-    )*)
-}
-
-raw_wasm_list_accessors! {
-    i8 i16 i32 i64
-    u8 u16 u32 u64
-}
-
-// Note that this is similar to `ComponentType for str` except it can only be
-// used for lifting, not lowering.
-unsafe impl<T: ComponentType> ComponentType for WasmList<T> {
-    type Lower = <[T] as ComponentType>::Lower;
-
-    const ABI: CanonicalAbiInfo = CanonicalAbiInfo::POINTER_PAIR;
-
-    fn typecheck(ty: &InterfaceType, types: &InstanceType<'_>) -> Result<()> {
-        <[T] as ComponentType>::typecheck(ty, types)
-    }
-}
-
-unsafe impl<T: Lift> Lift for WasmList<T> {
-    fn lift(cx: &mut LiftContext<'_>, ty: InterfaceType, src: &Self::Lower) -> Result<Self> {
-        let elem = match ty {
-            InterfaceType::List(i) => cx.types[i].element,
-            _ => bad_type_info(),
-        };
-        // FIXME: needs memory64 treatment
-        let ptr = src[0].get_u32();
-        let len = src[1].get_u32();
-        let (ptr, len) = (usize::try_from(ptr)?, usize::try_from(len)?);
-        WasmList::new(ptr, len, cx, elem)
-    }
-
-    fn load(cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Self> {
-        let elem = match ty {
-            InterfaceType::List(i) => cx.types[i].element,
-            _ => bad_type_info(),
-        };
-        debug_assert!((bytes.as_ptr() as usize) % (Self::ALIGN32 as usize) == 0);
-        // FIXME: needs memory64 treatment
-        let ptr = u32::from_le_bytes(bytes[..4].try_into().unwrap());
-        let len = u32::from_le_bytes(bytes[4..].try_into().unwrap());
-        let (ptr, len) = (usize::try_from(ptr)?, usize::try_from(len)?);
-        WasmList::new(ptr, len, cx, elem)
-    }
-}
-
-/// Verify that the given wasm type is a tuple with the expected fields in the right order.
-fn typecheck_tuple(
-    ty: &InterfaceType,
-    types: &InstanceType<'_>,
-    expected: &[fn(&InterfaceType, &InstanceType<'_>) -> Result<()>],
-) -> Result<()> {
-    match ty {
-        InterfaceType::Tuple(t) => {
-            let tuple = &types.types[*t];
-            if tuple.types.len() != expected.len() {
-                bail!(
-                    "expected {}-tuple, found {}-tuple",
-                    expected.len(),
-                    tuple.types.len()
-                );
-            }
-            for (ty, check) in tuple.types.iter().zip(expected) {
-                check(ty, types)?;
-            }
-            Ok(())
-        }
-        other => bail!("expected `tuple` found `{}`", desc(other)),
-    }
-}
-
-/// Verify that the given wasm type is a record with the expected fields in the right order and with the right
-/// names.
-pub fn typecheck_record(
-    ty: &InterfaceType,
-    types: &InstanceType<'_>,
-    expected: &[(&str, fn(&InterfaceType, &InstanceType<'_>) -> Result<()>)],
-) -> Result<()> {
-    match ty {
-        InterfaceType::Record(index) => {
-            let fields = &types.types[*index].fields;
-
-            if fields.len() != expected.len() {
-                bail!(
-                    "expected record of {} fields, found {} fields",
-                    expected.len(),
-                    fields.len()
-                );
-            }
-
-            for (field, &(name, check)) in fields.iter().zip(expected) {
-                check(&field.ty, types)
-                    .with_context(|| format!("type mismatch for field {}", name))?;
-
-                if field.name != name {
-                    bail!("expected record field named {}, found {}", name, field.name);
-                }
-            }
-
-            Ok(())
-        }
-        other => bail!("expected `record` found `{}`", desc(other)),
-    }
-}
-
-/// Verify that the given wasm type is a variant with the expected cases in the right order and with the right
-/// names.
-pub fn typecheck_variant(
-    ty: &InterfaceType,
-    types: &InstanceType<'_>,
-    expected: &[(
-        &str,
-        Option<fn(&InterfaceType, &InstanceType<'_>) -> Result<()>>,
-    )],
-) -> Result<()> {
-    match ty {
-        InterfaceType::Variant(index) => {
-            let cases = &types.types[*index].cases;
-
-            if cases.len() != expected.len() {
-                bail!(
-                    "expected variant of {} cases, found {} cases",
-                    expected.len(),
-                    cases.len()
-                );
-            }
-
-            for (case, &(name, check)) in cases.iter().zip(expected) {
-                if case.name != name {
-                    bail!("expected variant case named {name}, found {}", case.name);
-                }
-
-                match (check, &case.ty) {
-                    (Some(check), Some(ty)) => check(ty, types)
-                        .with_context(|| format!("type mismatch for case {name}"))?,
-                    (None, None) => {}
-                    (Some(_), None) => {
-                        bail!("case `{name}` has no type but one was expected")
-                    }
-                    (None, Some(_)) => {
-                        bail!("case `{name}` has a type but none was expected")
-                    }
-                }
-            }
-
-            Ok(())
-        }
-        other => bail!("expected `variant` found `{}`", desc(other)),
-    }
-}
-
-/// Verify that the given wasm type is a enum with the expected cases in the right order and with the right
-/// names.
-pub fn typecheck_enum(
-    ty: &InterfaceType,
-    types: &InstanceType<'_>,
-    expected: &[&str],
-) -> Result<()> {
-    match ty {
-        InterfaceType::Enum(index) => {
-            let names = &types.types[*index].names;
-
-            if names.len() != expected.len() {
-                bail!(
-                    "expected enum of {} names, found {} names",
-                    expected.len(),
-                    names.len()
-                );
-            }
-
-            for (name, expected) in names.iter().zip(expected) {
-                if name != expected {
-                    bail!("expected enum case named {}, found {}", expected, name);
-                }
-            }
-
-            Ok(())
-        }
-        other => bail!("expected `enum` found `{}`", desc(other)),
-    }
-}
-
-/// Verify that the given wasm type is a flags type with the expected flags in the right order and with the right
-/// names.
-pub fn typecheck_flags(
-    ty: &InterfaceType,
-    types: &InstanceType<'_>,
-    expected: &[&str],
-) -> Result<()> {
-    match ty {
-        InterfaceType::Flags(index) => {
-            let names = &types.types[*index].names;
-
-            if names.len() != expected.len() {
-                bail!(
-                    "expected flags type with {} names, found {} names",
-                    expected.len(),
-                    names.len()
-                );
-            }
-
-            for (name, expected) in names.iter().zip(expected) {
-                if name != expected {
-                    bail!("expected flag named {}, found {}", expected, name);
-                }
-            }
-
-            Ok(())
-        }
-        other => bail!("expected `flags` found `{}`", desc(other)),
-    }
-}
-
-/// Format the specified bitflags using the specified names for debugging
-pub fn format_flags(bits: &[u32], names: &[&str], f: &mut fmt::Formatter) -> fmt::Result {
-    f.write_str("(")?;
-    let mut wrote = false;
-    for (index, name) in names.iter().enumerate() {
-        if ((bits[index / 32] >> (index % 32)) & 1) != 0 {
-            if wrote {
-                f.write_str("|")?;
-            } else {
-                wrote = true;
-            }
-
-            f.write_str(name)?;
-        }
-    }
-    f.write_str(")")
-}
-
-unsafe impl<T> ComponentType for Option<T>
-where
-    T: ComponentType,
-{
-    type Lower = TupleLower2<<u32 as ComponentType>::Lower, T::Lower>;
-
-    const ABI: CanonicalAbiInfo = CanonicalAbiInfo::variant_static(&[None, Some(T::ABI)]);
-
-    fn typecheck(ty: &InterfaceType, types: &InstanceType<'_>) -> Result<()> {
-        match ty {
-            InterfaceType::Option(t) => T::typecheck(&types.types[*t].ty, types),
-            other => bail!("expected `option` found `{}`", desc(other)),
-        }
-    }
-}
-
-unsafe impl<T> ComponentVariant for Option<T>
-where
-    T: ComponentType,
-{
-    const CASES: &'static [Option<CanonicalAbiInfo>] = &[None, Some(T::ABI)];
-}
-
-unsafe impl<T> Lower for Option<T>
-where
-    T: Lower,
-{
-    fn lower<U>(
-        &self,
-        cx: &mut LowerContext<'_, U>,
-        ty: InterfaceType,
-        dst: &mut MaybeUninit<Self::Lower>,
-    ) -> Result<()> {
-        let payload = match ty {
-            InterfaceType::Option(ty) => cx.types[ty].ty,
-            _ => bad_type_info(),
-        };
-        match self {
-            None => {
-                map_maybe_uninit!(dst.A1).write(ValRaw::i32(0));
-                // Note that this is unsafe as we're writing an arbitrary
-                // bit-pattern to an arbitrary type, but part of the unsafe
-                // contract of the `ComponentType` trait is that we can assign
-                // any bit-pattern. By writing all zeros here we're ensuring
-                // that the core wasm arguments this translates to will all be
-                // zeros (as the canonical ABI requires).
-                unsafe {
-                    map_maybe_uninit!(dst.A2).as_mut_ptr().write_bytes(0u8, 1);
-                }
-            }
-            Some(val) => {
-                map_maybe_uninit!(dst.A1).write(ValRaw::i32(1));
-                val.lower(cx, payload, map_maybe_uninit!(dst.A2))?;
-            }
-        }
-        Ok(())
-    }
-
-    fn store<U>(
-        &self,
-        cx: &mut LowerContext<'_, U>,
-        ty: InterfaceType,
-        offset: usize,
-    ) -> Result<()> {
-        debug_assert!(offset % (Self::ALIGN32 as usize) == 0);
-        let payload = match ty {
-            InterfaceType::Option(ty) => cx.types[ty].ty,
-            _ => bad_type_info(),
-        };
-        match self {
-            None => {
-                cx.get::<1>(offset)[0] = 0;
-            }
-            Some(val) => {
-                cx.get::<1>(offset)[0] = 1;
-                val.store(cx, payload, offset + (Self::INFO.payload_offset32 as usize))?;
-            }
-        }
-        Ok(())
-    }
-}
-
-unsafe impl<T> Lift for Option<T>
-where
-    T: Lift,
-{
-    fn lift(cx: &mut LiftContext<'_>, ty: InterfaceType, src: &Self::Lower) -> Result<Self> {
-        let payload = match ty {
-            InterfaceType::Option(ty) => cx.types[ty].ty,
-            _ => bad_type_info(),
-        };
-        Ok(match src.A1.get_i32() {
-            0 => None,
-            1 => Some(T::lift(cx, payload, &src.A2)?),
-            _ => bail!("invalid option discriminant"),
-        })
-    }
-
-    fn load(cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Self> {
-        debug_assert!((bytes.as_ptr() as usize) % (Self::ALIGN32 as usize) == 0);
-        let payload_ty = match ty {
-            InterfaceType::Option(ty) => cx.types[ty].ty,
-            _ => bad_type_info(),
-        };
-        let discrim = bytes[0];
-        let payload = &bytes[Self::INFO.payload_offset32 as usize..];
-        match discrim {
-            0 => Ok(None),
-            1 => Ok(Some(T::load(cx, payload_ty, payload)?)),
-            _ => bail!("invalid option discriminant"),
-        }
-    }
-}
-
-#[derive(Clone, Copy)]
-#[repr(C)]
-pub struct ResultLower<T: Copy, E: Copy> {
-    tag: ValRaw,
-    payload: ResultLowerPayload<T, E>,
-}
-
-#[derive(Clone, Copy)]
-#[repr(C)]
-union ResultLowerPayload<T: Copy, E: Copy> {
-    ok: T,
-    err: E,
-}
-
-unsafe impl<T, E> ComponentType for Result<T, E>
-where
-    T: ComponentType,
-    E: ComponentType,
-{
-    type Lower = ResultLower<T::Lower, E::Lower>;
-
-    const ABI: CanonicalAbiInfo = CanonicalAbiInfo::variant_static(&[Some(T::ABI), Some(E::ABI)]);
-
-    fn typecheck(ty: &InterfaceType, types: &InstanceType<'_>) -> Result<()> {
-        match ty {
-            InterfaceType::Result(r) => {
-                let result = &types.types[*r];
-                match &result.ok {
-                    Some(ty) => T::typecheck(ty, types)?,
-                    None if T::IS_RUST_UNIT_TYPE => {}
-                    None => bail!("expected no `ok` type"),
-                }
-                match &result.err {
-                    Some(ty) => E::typecheck(ty, types)?,
-                    None if E::IS_RUST_UNIT_TYPE => {}
-                    None => bail!("expected no `err` type"),
-                }
-                Ok(())
-            }
-            other => bail!("expected `result` found `{}`", desc(other)),
-        }
-    }
-}
-
-/// Lowers the payload of a variant into the storage for the entire payload,
-/// handling writing zeros at the end of the representation if this payload is
-/// smaller than the entire flat representation.
-///
-/// * `payload` - the flat storage space for the entire payload of the variant
-/// * `typed_payload` - projection from the payload storage space to the
-///   individaul storage space for this variant.
-/// * `lower` - lowering operation used to initialize the `typed_payload` return
-///   value.
-///
-/// For more information on this se the comments in the `Lower for Result`
-/// implementation below.
-pub unsafe fn lower_payload<P, T>(
-    payload: &mut MaybeUninit<P>,
-    typed_payload: impl FnOnce(&mut MaybeUninit<P>) -> &mut MaybeUninit<T>,
-    lower: impl FnOnce(&mut MaybeUninit<T>) -> Result<()>,
-) -> Result<()> {
-    let typed = typed_payload(payload);
-    lower(typed)?;
-
-    let typed_len = storage_as_slice(typed).len();
-    let payload = storage_as_slice_mut(payload);
-    for slot in payload[typed_len..].iter_mut() {
-        *slot = ValRaw::u64(0);
-    }
-    Ok(())
-}
-
-unsafe impl<T, E> ComponentVariant for Result<T, E>
-where
-    T: ComponentType,
-    E: ComponentType,
-{
-    const CASES: &'static [Option<CanonicalAbiInfo>] = &[Some(T::ABI), Some(E::ABI)];
-}
-
-unsafe impl<T, E> Lower for Result<T, E>
-where
-    T: Lower,
-    E: Lower,
-{
-    fn lower<U>(
-        &self,
-        cx: &mut LowerContext<'_, U>,
-        ty: InterfaceType,
-        dst: &mut MaybeUninit<Self::Lower>,
-    ) -> Result<()> {
-        let (ok, err) = match ty {
-            InterfaceType::Result(ty) => {
-                let ty = &cx.types[ty];
-                (ty.ok, ty.err)
-            }
-            _ => bad_type_info(),
-        };
-
-        // This implementation of `Lower::lower`, if you're reading these from
-        // the top of this file, is the first location that the "join" logic of
-        // the component model's canonical ABI encountered. The rough problem is
-        // that let's say we have a component model type of the form:
-        //
-        //      (result u64 (error (tuple f32 u16)))
-        //
-        // The flat representation of this is actually pretty tricky. Currently
-        // it is:
-        //
-        //      i32 i64 i32
-        //
-        // The first `i32` is the discriminant for the `result`, and the payload
-        // is represented by `i64 i32`. The "ok" variant will only use the `i64`
-        // and the "err" variant will use both `i64` and `i32`.
-        //
-        // In the "ok" variant the first issue is encountered. The size of one
-        // variant may not match the size of the other variants. All variants
-        // start at the "front" but when lowering a type we need to be sure to
-        // initialize the later variants (lest we leak random host memory into
-        // the guest module). Due to how the `Lower` type is represented as a
-        // `union` of all the variants what ends up happening here is that
-        // internally within the `lower_payload` after the typed payload is
-        // lowered the remaining bits of the payload that weren't initialized
-        // are all set to zero. This will guarantee that we'll write to all the
-        // slots for each variant.
-        //
-        // The "err" variant encounters the second issue, however, which is that
-        // the flat representation for each type may differ between payloads. In
-        // the "ok" arm an `i64` is written, but the `lower` implementation for
-        // the "err" arm will write an `f32` and then an `i32`. For this
-        // implementation of `lower` to be valid the `f32` needs to get inflated
-        // to an `i64` with zero-padding in the upper bits. What may be
-        // surprising, however, is that none of this is handled in this file.
-        // This implementation looks like it's blindly deferring to `E::lower`
-        // and hoping it does the right thing.
-        //
-        // In reality, however, the correctness of variant lowering relies on
-        // two subtle details of the `ValRaw` implementation in Wasmtime:
-        //
-        // 1. First the `ValRaw` value always contains little-endian values.
-        //    This means that if a `u32` is written, a `u64` is read, and then
-        //    the `u64` has its upper bits truncated the original value will
-        //    always be retained. This is primarily here for big-endian
-        //    platforms where if it weren't little endian then the opposite
-        //    would occur and the wrong value would be read.
-        //
-        // 2. Second, and perhaps even more subtly, the `ValRaw` constructors
-        //    for 32-bit types actually always initialize 64-bits of the
-        //    `ValRaw`. In the component model flat ABI only 32 and 64-bit types
-        //    are used so 64-bits is big enough to contain everything. This
-        //    means that when a `ValRaw` is written into the destination it will
-        //    always, whether it's needed or not, be "ready" to get extended up
-        //    to 64-bits.
-        //
-        // Put together these two subtle guarantees means that all `Lower`
-        // implementations can be written "naturally" as one might naively
-        // expect. Variants will, on each arm, zero out remaining fields and all
-        // writes to the flat representation will automatically be 64-bit writes
-        // meaning that if the value is read as a 64-bit value, which isn't
-        // known at the time of the write, it'll still be correct.
-        match self {
-            Ok(e) => {
-                map_maybe_uninit!(dst.tag).write(ValRaw::i32(0));
-                unsafe {
-                    lower_payload(
-                        map_maybe_uninit!(dst.payload),
-                        |payload| map_maybe_uninit!(payload.ok),
-                        |dst| match ok {
-                            Some(ok) => e.lower(cx, ok, dst),
-                            None => Ok(()),
-                        },
-                    )
-                }
-            }
-            Err(e) => {
-                map_maybe_uninit!(dst.tag).write(ValRaw::i32(1));
-                unsafe {
-                    lower_payload(
-                        map_maybe_uninit!(dst.payload),
-                        |payload| map_maybe_uninit!(payload.err),
-                        |dst| match err {
-                            Some(err) => e.lower(cx, err, dst),
-                            None => Ok(()),
-                        },
-                    )
-                }
-            }
-        }
-    }
-
-    fn store<U>(
-        &self,
-        cx: &mut LowerContext<'_, U>,
-        ty: InterfaceType,
-        offset: usize,
-    ) -> Result<()> {
-        let (ok, err) = match ty {
-            InterfaceType::Result(ty) => {
-                let ty = &cx.types[ty];
-                (ty.ok, ty.err)
-            }
-            _ => bad_type_info(),
-        };
-        debug_assert!(offset % (Self::ALIGN32 as usize) == 0);
-        let payload_offset = Self::INFO.payload_offset32 as usize;
-        match self {
-            Ok(e) => {
-                cx.get::<1>(offset)[0] = 0;
-                if let Some(ok) = ok {
-                    e.store(cx, ok, offset + payload_offset)?;
-                }
-            }
-            Err(e) => {
-                cx.get::<1>(offset)[0] = 1;
-                if let Some(err) = err {
-                    e.store(cx, err, offset + payload_offset)?;
-                }
-            }
-        }
-        Ok(())
-    }
-}
-
-unsafe impl<T, E> Lift for Result<T, E>
-where
-    T: Lift,
-    E: Lift,
-{
-    #[inline]
-    fn lift(cx: &mut LiftContext<'_>, ty: InterfaceType, src: &Self::Lower) -> Result<Self> {
-        let (ok, err) = match ty {
-            InterfaceType::Result(ty) => {
-                let ty = &cx.types[ty];
-                (ty.ok, ty.err)
-            }
-            _ => bad_type_info(),
-        };
-        // Note that this implementation specifically isn't trying to actually
-        // reinterpret or alter the bits of `lower` depending on which variant
-        // we're lifting. This ends up all working out because the value is
-        // stored in little-endian format.
-        //
-        // When stored in little-endian format the `{T,E}::Lower`, when each
-        // individual `ValRaw` is read, means that if an i64 value, extended
-        // from an i32 value, was stored then when the i32 value is read it'll
-        // automatically ignore the upper bits.
-        //
-        // This "trick" allows us to seamlessly pass through the `Self::Lower`
-        // representation into the lifting/lowering without trying to handle
-        // "join"ed types as per the canonical ABI. It just so happens that i64
-        // bits will naturally be reinterpreted as f64. Additionally if the
-        // joined type is i64 but only the lower bits are read that's ok and we
-        // don't need to validate the upper bits.
-        //
-        // This is largely enabled by WebAssembly/component-model#35 where no
-        // validation needs to be performed for ignored bits and bytes here.
-        Ok(match src.tag.get_i32() {
-            0 => Ok(unsafe { lift_option(cx, ok, &src.payload.ok)? }),
-            1 => Err(unsafe { lift_option(cx, err, &src.payload.err)? }),
-            _ => bail!("invalid expected discriminant"),
-        })
-    }
-
-    #[inline]
-    fn load(cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Self> {
-        debug_assert!((bytes.as_ptr() as usize) % (Self::ALIGN32 as usize) == 0);
-        let discrim = bytes[0];
-        let payload = &bytes[Self::INFO.payload_offset32 as usize..];
-        let (ok, err) = match ty {
-            InterfaceType::Result(ty) => {
-                let ty = &cx.types[ty];
-                (ty.ok, ty.err)
-            }
-            _ => bad_type_info(),
-        };
-        match discrim {
-            0 => Ok(Ok(load_option(cx, ok, &payload[..T::SIZE32])?)),
-            1 => Ok(Err(load_option(cx, err, &payload[..E::SIZE32])?)),
-            _ => bail!("invalid expected discriminant"),
-        }
-    }
-}
-
-fn lift_option<T>(cx: &mut LiftContext<'_>, ty: Option<InterfaceType>, src: &T::Lower) -> Result<T>
-where
-    T: Lift,
-{
-    match ty {
-        Some(ty) => T::lift(cx, ty, src),
-        None => Ok(empty_lift()),
-    }
-}
-
-fn load_option<T>(cx: &mut LiftContext<'_>, ty: Option<InterfaceType>, bytes: &[u8]) -> Result<T>
-where
-    T: Lift,
-{
-    match ty {
-        Some(ty) => T::load(cx, ty, bytes),
-        None => Ok(empty_lift()),
-    }
-}
-
-fn empty_lift<T>() -> T
-where
-    T: Lift,
-{
-    assert!(T::IS_RUST_UNIT_TYPE);
-    assert_eq!(mem::size_of::<T>(), 0);
-    unsafe { MaybeUninit::uninit().assume_init() }
-}
-
-macro_rules! impl_component_ty_for_tuples {
-    ($n:tt $($t:ident)*) => {paste::paste!{
-        #[allow(non_snake_case)]
-        #[doc(hidden)]
-        #[derive(Clone, Copy)]
-        #[repr(C)]
-        pub struct [<TupleLower$n>]<$($t),*> {
-            $($t: $t,)*
-            _align_tuple_lower0_correctly: [ValRaw; 0],
-        }
-
-        #[allow(non_snake_case)]
-        unsafe impl<$($t,)*> ComponentType for ($($t,)*)
-            where $($t: ComponentType),*
-        {
-            type Lower = [<TupleLower$n>]<$($t::Lower),*>;
-
-            const ABI: CanonicalAbiInfo = CanonicalAbiInfo::record_static(&[
-                $($t::ABI),*
-            ]);
-
-            const IS_RUST_UNIT_TYPE: bool = {
-                let mut _is_unit = true;
-                $(
-                    let _anything_to_bind_the_macro_variable = $t::IS_RUST_UNIT_TYPE;
-                    _is_unit = false;
-                )*
-                _is_unit
-            };
-
-            fn typecheck(
-                ty: &InterfaceType,
-                types: &InstanceType<'_>,
-            ) -> Result<()> {
-                typecheck_tuple(ty, types, &[$($t::typecheck),*])
-            }
-        }
-
-        #[allow(non_snake_case)]
-        unsafe impl<$($t,)*> Lower for ($($t,)*)
-            where $($t: Lower),*
-        {
-            fn lower<U>(
-                &self,
-                cx: &mut LowerContext<'_, U>,
-                ty: InterfaceType,
-                _dst: &mut MaybeUninit<Self::Lower>,
-            ) -> Result<()> {
-                let types = match ty {
-                    InterfaceType::Tuple(t) => &cx.types[t].types,
-                    _ => bad_type_info(),
-                };
-                let ($($t,)*) = self;
-                let mut _types = types.iter();
-                $(
-                    let ty = *_types.next().unwrap_or_else(bad_type_info);
-                    $t.lower(cx, ty, map_maybe_uninit!(_dst.$t))?;
-                )*
-                Ok(())
-            }
-
-            fn store<U>(
-                &self,
-                cx: &mut LowerContext<'_, U>,
-                ty: InterfaceType,
-                mut _offset: usize,
-            ) -> Result<()> {
-                debug_assert!(_offset % (Self::ALIGN32 as usize) == 0);
-                let types = match ty {
-                    InterfaceType::Tuple(t) => &cx.types[t].types,
-                    _ => bad_type_info(),
-                };
-                let ($($t,)*) = self;
-                let mut _types = types.iter();
-                $(
-                    let ty = *_types.next().unwrap_or_else(bad_type_info);
-                    $t.store(cx, ty, $t::ABI.next_field32_size(&mut _offset))?;
-                )*
-                Ok(())
-            }
-        }
-
-        #[allow(non_snake_case)]
-        unsafe impl<$($t,)*> Lift for ($($t,)*)
-            where $($t: Lift),*
-        {
-            #[inline]
-            fn lift(cx: &mut LiftContext<'_>, ty: InterfaceType, _src: &Self::Lower) -> Result<Self> {
-                let types = match ty {
-                    InterfaceType::Tuple(t) => &cx.types[t].types,
-                    _ => bad_type_info(),
-                };
-                let mut _types = types.iter();
-                Ok(($(
-                    $t::lift(
-                        cx,
-                        *_types.next().unwrap_or_else(bad_type_info),
-                        &_src.$t,
-                    )?,
-                )*))
-            }
-
-            #[inline]
-            fn load(cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Self> {
-                debug_assert!((bytes.as_ptr() as usize) % (Self::ALIGN32 as usize) == 0);
-                let types = match ty {
-                    InterfaceType::Tuple(t) => &cx.types[t].types,
-                    _ => bad_type_info(),
-                };
-                let mut _types = types.iter();
-                let mut _offset = 0;
-                $(
-                    let ty = *_types.next().unwrap_or_else(bad_type_info);
-                    let $t = $t::load(cx, ty, &bytes[$t::ABI.next_field32_size(&mut _offset)..][..$t::SIZE32])?;
-                )*
-                Ok(($($t,)*))
-            }
-        }
-
-        #[allow(non_snake_case)]
-        unsafe impl<$($t,)*> ComponentNamedList for ($($t,)*)
-            where $($t: ComponentType),*
-        {}
-    }};
-}
-
-for_each_function_signature!(impl_component_ty_for_tuples);
-
-pub fn desc(ty: &InterfaceType) -> &'static str {
-    match ty {
-        InterfaceType::U8 => "u8",
-        InterfaceType::S8 => "s8",
-        InterfaceType::U16 => "u16",
-        InterfaceType::S16 => "s16",
-        InterfaceType::U32 => "u32",
-        InterfaceType::S32 => "s32",
-        InterfaceType::U64 => "u64",
-        InterfaceType::S64 => "s64",
-        InterfaceType::Float32 => "f32",
-        InterfaceType::Float64 => "f64",
-        InterfaceType::Bool => "bool",
-        InterfaceType::Char => "char",
-        InterfaceType::String => "string",
-        InterfaceType::List(_) => "list",
-        InterfaceType::Tuple(_) => "tuple",
-        InterfaceType::Option(_) => "option",
-        InterfaceType::Result(_) => "result",
-
-        InterfaceType::Record(_) => "record",
-        InterfaceType::Variant(_) => "variant",
-        InterfaceType::Flags(_) => "flags",
-        InterfaceType::Enum(_) => "enum",
-        InterfaceType::Own(_) => "owned resource",
-        InterfaceType::Borrow(_) => "borrowed resource",
-    }
-}
-
-#[cold]
-#[doc(hidden)]
-pub fn bad_type_info<T>() -> T {
-    // NB: should consider something like `unreachable_unchecked` here if this
-    // becomes a performance bottleneck at some point, but that also comes with
-    // a tradeoff of propagating a lot of unsafety, so it may not be worth it.
-    panic!("bad type information detected");
-}
diff --git a/crates/wasmtime/src/component/instance.rs b/crates/wasmtime/src/component/instance.rs
deleted file mode 100644
index b81afef82272..000000000000
--- a/crates/wasmtime/src/component/instance.rs
+++ /dev/null
@@ -1,797 +0,0 @@
-use crate::component::func::HostFunc;
-use crate::component::matching::InstanceType;
-use crate::component::{Component, ComponentNamedList, Func, Lift, Lower, ResourceType, TypedFunc};
-use crate::instance::OwnedImports;
-use crate::linker::DefinitionType;
-use crate::store::{StoreOpaque, Stored};
-use crate::{AsContextMut, Module, StoreContextMut};
-use anyhow::{anyhow, Context, Result};
-use indexmap::IndexMap;
-use std::marker;
-use std::ptr::NonNull;
-use std::sync::Arc;
-use wasmtime_environ::component::*;
-use wasmtime_environ::{EntityIndex, EntityType, Global, PrimaryMap, WasmType};
-use wasmtime_runtime::component::{ComponentInstance, OwnedComponentInstance};
-use wasmtime_runtime::VMFuncRef;
-
-/// An instantiated component.
-///
-/// This is similar to [`crate::Instance`] except that it represents an
-/// instantiated component instead of an instantiated module. Otherwise though
-/// the two behave similarly.
-//
-// FIXME: need to write more docs here.
-#[derive(Copy, Clone)]
-pub struct Instance(pub(crate) Stored<Option<Box<InstanceData>>>);
-
-pub(crate) struct InstanceData {
-    instances: PrimaryMap<RuntimeInstanceIndex, crate::Instance>,
-
-    // NB: in the future if necessary it would be possible to avoid storing an
-    // entire `Component` here and instead storing only information such as:
-    //
-    // * Some reference to `Arc<ComponentTypes>`
-    // * Necessary references to closed-over modules which are exported from the
-    //   component itself.
-    //
-    // Otherwise the full guts of this component should only ever be used during
-    // the instantiation of this instance, meaning that after instantiation much
-    // of the component can be thrown away (theoretically).
-    component: Component,
-
-    state: OwnedComponentInstance,
-
-    /// Arguments that this instance used to be instantiated.
-    ///
-    /// Strong references are stored to these arguments since pointers are saved
-    /// into the structures such as functions within the
-    /// `OwnedComponentInstance` but it's our job to keep them alive.
-    ///
-    /// One purpose of this storage is to enable embedders to drop a `Linker`,
-    /// for example, after a component is instantiated. In that situation if the
-    /// arguments weren't held here then they might be dropped, and structures
-    /// such as `.lowering()` which point back into the original function would
-    /// become stale and use-after-free conditions when used. By preserving the
-    /// entire list here though we're guaranteed that nothing is lost for the
-    /// duration of the lifetime of this instance.
-    imports: Arc<PrimaryMap<RuntimeImportIndex, RuntimeImport>>,
-}
-
-impl Instance {
-    /// Returns information about the exports of this instance.
-    ///
-    /// This method can be used to extract exported values from this component
-    /// instance. The argument to this method be a handle to the store that
-    /// this instance was instantiated into.
-    ///
-    /// The returned [`Exports`] value can be used to lookup exported items by
-    /// name.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `store` does not own this instance.
-    pub fn exports<'a, T: 'a>(&self, store: impl Into<StoreContextMut<'a, T>>) -> Exports<'a> {
-        let store = store.into();
-        Exports::new(store.0, self)
-    }
-
-    /// Looks up a function by name within this [`Instance`].
-    ///
-    /// This is a convenience method for calling [`Instance::exports`] followed
-    /// by [`ExportInstance::func`].
-    ///
-    /// # Panics
-    ///
-    /// Panics if `store` does not own this instance.
-    pub fn get_func(&self, mut store: impl AsContextMut, name: &str) -> Option<Func> {
-        self.exports(store.as_context_mut()).root().func(name)
-    }
-
-    /// Looks up an exported [`Func`] value by name and with its type.
-    ///
-    /// This function is a convenience wrapper over [`Instance::get_func`] and
-    /// [`Func::typed`]. For more information see the linked documentation.
-    ///
-    /// Returns an error if `name` isn't a function export or if the export's
-    /// type did not match `Params` or `Results`
-    ///
-    /// # Panics
-    ///
-    /// Panics if `store` does not own this instance.
-    pub fn get_typed_func<Params, Results>(
-        &self,
-        mut store: impl AsContextMut,
-        name: &str,
-    ) -> Result<TypedFunc<Params, Results>>
-    where
-        Params: ComponentNamedList + Lower,
-        Results: ComponentNamedList + Lift,
-    {
-        let f = self
-            .get_func(store.as_context_mut(), name)
-            .ok_or_else(|| anyhow!("failed to find function export `{}`", name))?;
-        Ok(f.typed::<Params, Results>(store)
-            .with_context(|| format!("failed to convert function `{}` to given type", name))?)
-    }
-
-    /// Looks up a module by name within this [`Instance`].
-    ///
-    /// The `store` specified must be the store that this instance lives within
-    /// and `name` is the name of the function to lookup. If the module is
-    /// found `Some` is returned otherwise `None` is returned.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `store` does not own this instance.
-    pub fn get_module(&self, mut store: impl AsContextMut, name: &str) -> Option<Module> {
-        self.exports(store.as_context_mut())
-            .root()
-            .module(name)
-            .cloned()
-    }
-
-    /// Looks up an exported resource type by name within this [`Instance`].
-    ///
-    /// The `store` specified must be the store that this instance lives within
-    /// and `name` is the name of the function to lookup. If the resource type
-    /// is found `Some` is returned otherwise `None` is returned.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `store` does not own this instance.
-    pub fn get_resource(&self, mut store: impl AsContextMut, name: &str) -> Option<ResourceType> {
-        self.exports(store.as_context_mut()).root().resource(name)
-    }
-}
-
-impl InstanceData {
-    pub fn lookup_def(&self, store: &mut StoreOpaque, def: &CoreDef) -> wasmtime_runtime::Export {
-        match def {
-            CoreDef::Export(e) => self.lookup_export(store, e),
-            CoreDef::Trampoline(idx) => {
-                wasmtime_runtime::Export::Function(wasmtime_runtime::ExportFunction {
-                    func_ref: self.state.trampoline_func_ref(*idx),
-                })
-            }
-            CoreDef::InstanceFlags(idx) => {
-                wasmtime_runtime::Export::Global(wasmtime_runtime::ExportGlobal {
-                    definition: self.state.instance_flags(*idx).as_raw(),
-                    global: Global {
-                        wasm_ty: WasmType::I32,
-                        mutability: true,
-                    },
-                })
-            }
-        }
-    }
-
-    pub fn lookup_export<T>(
-        &self,
-        store: &mut StoreOpaque,
-        item: &CoreExport<T>,
-    ) -> wasmtime_runtime::Export
-    where
-        T: Copy + Into<EntityIndex>,
-    {
-        let instance = &self.instances[item.instance];
-        let id = instance.id(store);
-        let instance = store.instance_mut(id);
-        let idx = match &item.item {
-            ExportItem::Index(idx) => (*idx).into(),
-
-            // FIXME: ideally at runtime we don't actually do any name lookups
-            // here. This will only happen when the host supplies an imported
-            // module so while the structure can't be known at compile time we
-            // do know at `InstancePre` time, for example, what all the host
-            // imports are. In theory we should be able to, as part of
-            // `InstancePre` construction, perform all name=>index mappings
-            // during that phase so the actual instantiation of an `InstancePre`
-            // skips all string lookups. This should probably only be
-            // investigated if this becomes a performance issue though.
-            ExportItem::Name(name) => instance.module().exports[name],
-        };
-        instance.get_export_by_index(idx)
-    }
-
-    #[inline]
-    pub fn instance(&self) -> &ComponentInstance {
-        &self.state
-    }
-
-    #[inline]
-    pub fn instance_ptr(&self) -> *mut ComponentInstance {
-        self.state.instance_ptr()
-    }
-
-    #[inline]
-    pub fn component_types(&self) -> &Arc<ComponentTypes> {
-        self.component.types()
-    }
-
-    #[inline]
-    pub fn ty(&self) -> InstanceType<'_> {
-        InstanceType::new(self.instance())
-    }
-
-    // NB: This method is only intended to be called during the instantiation
-    // process because the `Arc::get_mut` here is fallible and won't generally
-    // succeed once the instance has been handed to the embedder. Before that
-    // though it should be guaranteed that the single owning reference currently
-    // lives within the `ComponentInstance` that's being built.
-    fn resource_types_mut(&mut self) -> &mut ImportedResources {
-        Arc::get_mut(self.state.resource_types_mut())
-            .unwrap()
-            .downcast_mut()
-            .unwrap()
-    }
-}
-
-struct Instantiator<'a> {
-    component: &'a Component,
-    data: InstanceData,
-    core_imports: OwnedImports,
-    imports: &'a PrimaryMap<RuntimeImportIndex, RuntimeImport>,
-}
-
-pub(crate) enum RuntimeImport {
-    Func(Arc<HostFunc>),
-    Module(Module),
-    Resource {
-        ty: ResourceType,
-
-        // A strong reference to the host function that represents the
-        // destructor for this resource. At this time all resources here are
-        // host-defined resources. Note that this is itself never read because
-        // the funcref below points to it.
-        //
-        // Also note that the `Arc` here is used to support the same host
-        // function being used across multiple instances simultaneously. Or
-        // otherwise this makes `InstancePre::instantiate` possible to create
-        // separate instances all sharing the same host function.
-        _dtor: Arc<crate::func::HostFunc>,
-
-        // A raw function which is filled out (including `wasm_call`) which
-        // points to the internals of the `_dtor` field. This is read and
-        // possibly executed by wasm.
-        dtor_funcref: VMFuncRef,
-    },
-}
-
-pub type ImportedResources = PrimaryMap<ResourceIndex, ResourceType>;
-
-impl<'a> Instantiator<'a> {
-    fn new(
-        component: &'a Component,
-        store: &mut StoreOpaque,
-        imports: &'a Arc<PrimaryMap<RuntimeImportIndex, RuntimeImport>>,
-    ) -> Instantiator<'a> {
-        let env_component = component.env_component();
-        store.modules_mut().register_component(component);
-        let imported_resources: ImportedResources =
-            PrimaryMap::with_capacity(env_component.imported_resources.len());
-        Instantiator {
-            component,
-            imports,
-            core_imports: OwnedImports::empty(),
-            data: InstanceData {
-                instances: PrimaryMap::with_capacity(env_component.num_runtime_instances as usize),
-                component: component.clone(),
-                state: OwnedComponentInstance::new(
-                    component.runtime_info(),
-                    Arc::new(imported_resources),
-                    store.traitobj(),
-                ),
-                imports: imports.clone(),
-            },
-        }
-    }
-
-    fn run<T>(&mut self, store: &mut StoreContextMut<'_, T>) -> Result<()> {
-        let env_component = self.component.env_component();
-
-        // Before all initializers are processed configure all destructors for
-        // host-defined resources. No initializer will correspond to these and
-        // it's required to happen before they're needed, so execute this first.
-        for (idx, import) in env_component.imported_resources.iter() {
-            let (ty, func_ref) = match &self.imports[*import] {
-                RuntimeImport::Resource {
-                    ty, dtor_funcref, ..
-                } => (*ty, NonNull::from(dtor_funcref)),
-                _ => unreachable!(),
-            };
-            let i = self.data.resource_types_mut().push(ty);
-            assert_eq!(i, idx);
-            self.data.state.set_resource_destructor(idx, Some(func_ref));
-        }
-
-        // Next configure all `VMFuncRef`s for trampolines that this component
-        // will require. These functions won't actually get used until their
-        // associated state has been initialized through the global initializers
-        // below, but the funcrefs can all be configured here.
-        for (idx, sig) in env_component.trampolines.iter() {
-            let ptrs = self.component.trampoline_ptrs(idx);
-            let signature = self
-                .component
-                .signatures()
-                .shared_signature(*sig)
-                .expect("found unregistered signature");
-            self.data.state.set_trampoline(
-                idx,
-                ptrs.wasm_call,
-                ptrs.native_call,
-                ptrs.array_call,
-                signature,
-            );
-        }
-
-        for initializer in env_component.initializers.iter() {
-            match initializer {
-                GlobalInitializer::InstantiateModule(m) => {
-                    let module;
-                    let imports = match m {
-                        // Since upvars are statically know we know that the
-                        // `args` list is already in the right order.
-                        InstantiateModule::Static(idx, args) => {
-                            module = self.component.static_module(*idx);
-                            self.build_imports(store.0, module, args.iter())
-                        }
-
-                        // With imports, unlike upvars, we need to do runtime
-                        // lookups with strings to determine the order of the
-                        // imports since it's whatever the actual module
-                        // requires.
-                        //
-                        // FIXME: see the note in `ExportItem::Name` handling
-                        // above for how we ideally shouldn't do string lookup
-                        // here.
-                        InstantiateModule::Import(idx, args) => {
-                            module = match &self.imports[*idx] {
-                                RuntimeImport::Module(m) => m,
-                                _ => unreachable!(),
-                            };
-                            let args = module
-                                .imports()
-                                .map(|import| &args[import.module()][import.name()]);
-                            self.build_imports(store.0, module, args)
-                        }
-                    };
-
-                    // Note that the unsafety here should be ok because the
-                    // validity of the component means that type-checks have
-                    // already been performed. This means that the unsafety due
-                    // to imports having the wrong type should not happen here.
-                    //
-                    // Also note we are calling new_started_impl because we have
-                    // already checked for asyncness and are running on a fiber
-                    // if required.
-
-                    let i = unsafe {
-                        crate::Instance::new_started_impl(store, module, imports.as_ref())?
-                    };
-                    self.data.instances.push(i);
-                }
-
-                GlobalInitializer::LowerImport { import, index } => {
-                    let func = match &self.imports[*import] {
-                        RuntimeImport::Func(func) => func,
-                        _ => unreachable!(),
-                    };
-                    self.data.state.set_lowering(*index, func.lowering());
-                }
-
-                GlobalInitializer::ExtractMemory(mem) => self.extract_memory(store.0, mem),
-
-                GlobalInitializer::ExtractRealloc(realloc) => {
-                    self.extract_realloc(store.0, realloc)
-                }
-
-                GlobalInitializer::ExtractPostReturn(post_return) => {
-                    self.extract_post_return(store.0, post_return)
-                }
-
-                GlobalInitializer::Resource(r) => self.resource(store.0, r),
-            }
-        }
-        Ok(())
-    }
-
-    fn resource(&mut self, store: &mut StoreOpaque, resource: &Resource) {
-        let dtor = resource
-            .dtor
-            .as_ref()
-            .map(|dtor| self.data.lookup_def(store, dtor));
-        let dtor = dtor.map(|export| match export {
-            wasmtime_runtime::Export::Function(f) => f.func_ref,
-            _ => unreachable!(),
-        });
-        let index = self
-            .component
-            .env_component()
-            .resource_index(resource.index);
-        self.data.state.set_resource_destructor(index, dtor);
-        let ty = ResourceType::guest(store.id(), &self.data.state, resource.index);
-        let i = self.data.resource_types_mut().push(ty);
-        debug_assert_eq!(i, index);
-    }
-
-    fn extract_memory(&mut self, store: &mut StoreOpaque, memory: &ExtractMemory) {
-        let mem = match self.data.lookup_export(store, &memory.export) {
-            wasmtime_runtime::Export::Memory(m) => m,
-            _ => unreachable!(),
-        };
-        self.data
-            .state
-            .set_runtime_memory(memory.index, mem.definition);
-    }
-
-    fn extract_realloc(&mut self, store: &mut StoreOpaque, realloc: &ExtractRealloc) {
-        let func_ref = match self.data.lookup_def(store, &realloc.def) {
-            wasmtime_runtime::Export::Function(f) => f.func_ref,
-            _ => unreachable!(),
-        };
-        self.data.state.set_runtime_realloc(realloc.index, func_ref);
-    }
-
-    fn extract_post_return(&mut self, store: &mut StoreOpaque, post_return: &ExtractPostReturn) {
-        let func_ref = match self.data.lookup_def(store, &post_return.def) {
-            wasmtime_runtime::Export::Function(f) => f.func_ref,
-            _ => unreachable!(),
-        };
-        self.data
-            .state
-            .set_runtime_post_return(post_return.index, func_ref);
-    }
-
-    fn build_imports<'b>(
-        &mut self,
-        store: &mut StoreOpaque,
-        module: &Module,
-        args: impl Iterator<Item = &'b CoreDef>,
-    ) -> &OwnedImports {
-        self.core_imports.clear();
-        self.core_imports.reserve(module);
-        let mut imports = module.compiled_module().module().imports();
-
-        for arg in args {
-            // The general idea of Wasmtime is that at runtime type-checks for
-            // core wasm instantiations internally within a component are
-            // unnecessary and superfluous. Naturally though mistakes may be
-            // made, so double-check this property of wasmtime in debug mode.
-
-            if cfg!(debug_assertions) {
-                let (_, _, expected) = imports.next().unwrap();
-                self.assert_type_matches(store, module, arg, expected);
-            }
-
-            // The unsafety here should be ok since the `export` is loaded
-            // directly from an instance which should only give us valid export
-            // items.
-            let export = self.data.lookup_def(store, arg);
-            unsafe {
-                self.core_imports.push_export(&export);
-            }
-        }
-        debug_assert!(imports.next().is_none());
-
-        &self.core_imports
-    }
-
-    fn assert_type_matches(
-        &self,
-        store: &mut StoreOpaque,
-        module: &Module,
-        arg: &CoreDef,
-        expected: EntityType,
-    ) {
-        let export = self.data.lookup_def(store, arg);
-
-        // If this value is a core wasm function then the type check is inlined
-        // here. This can otherwise fail `Extern::from_wasmtime_export` because
-        // there's no guarantee that there exists a trampoline for `f` so this
-        // can't fall through to the case below
-        if let wasmtime_runtime::Export::Function(f) = &export {
-            let expected = expected.unwrap_func();
-            let actual = unsafe { f.func_ref.as_ref().type_index };
-            assert_eq!(module.signatures().shared_signature(expected), Some(actual));
-            return;
-        }
-
-        let val = unsafe { crate::Extern::from_wasmtime_export(export, store) };
-        let ty = DefinitionType::from(store, &val);
-        crate::types::matching::MatchCx {
-            engine: store.engine(),
-            signatures: module.signatures(),
-            types: module.types(),
-        }
-        .definition(&expected, &ty)
-        .expect("unexpected typecheck failure");
-    }
-}
-
-/// A "pre-instantiated" [`Instance`] which has all of its arguments already
-/// supplied and is ready to instantiate.
-///
-/// This structure represents an efficient form of instantiation where import
-/// type-checking and import lookup has all been resolved by the time that this
-/// type is created. This type is primarily created through the
-/// [`Linker::instantiate_pre`](crate::component::Linker::instantiate_pre)
-/// method.
-pub struct InstancePre<T> {
-    component: Component,
-    imports: Arc<PrimaryMap<RuntimeImportIndex, RuntimeImport>>,
-    _marker: marker::PhantomData<fn() -> T>,
-}
-
-// `InstancePre`'s clone does not require `T: Clone`
-impl<T> Clone for InstancePre<T> {
-    fn clone(&self) -> Self {
-        Self {
-            component: self.component.clone(),
-            imports: self.imports.clone(),
-            _marker: self._marker,
-        }
-    }
-}
-
-impl<T> InstancePre<T> {
-    /// This function is `unsafe` since there's no guarantee that the
-    /// `RuntimeImport` items provided are guaranteed to work with the `T` of
-    /// the store.
-    ///
-    /// Additionally there is no static guarantee that the `imports` provided
-    /// satisfy the imports of the `component` provided.
-    pub(crate) unsafe fn new_unchecked(
-        component: Component,
-        imports: PrimaryMap<RuntimeImportIndex, RuntimeImport>,
-    ) -> InstancePre<T> {
-        InstancePre {
-            component,
-            imports: Arc::new(imports),
-            _marker: marker::PhantomData,
-        }
-    }
-
-    /// Returns the underlying component that will be instantiated.
-    pub fn component(&self) -> &Component {
-        &self.component
-    }
-
-    /// Performs the instantiation process into the store specified.
-    //
-    // TODO: needs more docs
-    pub fn instantiate(&self, store: impl AsContextMut<Data = T>) -> Result<Instance> {
-        assert!(
-            !store.as_context().async_support(),
-            "must use async instantiation when async support is enabled"
-        );
-        self.instantiate_impl(store)
-    }
-    /// Performs the instantiation process into the store specified.
-    ///
-    /// Exactly like [`Self::instantiate`] except for use on async stores.
-    //
-    // TODO: needs more docs
-    #[cfg(feature = "async")]
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "async")))]
-    pub async fn instantiate_async(
-        &self,
-        mut store: impl AsContextMut<Data = T>,
-    ) -> Result<Instance>
-    where
-        T: Send,
-    {
-        let mut store = store.as_context_mut();
-        assert!(
-            store.0.async_support(),
-            "must use sync instantiation when async support is disabled"
-        );
-        store.on_fiber(|store| self.instantiate_impl(store)).await?
-    }
-
-    fn instantiate_impl(&self, mut store: impl AsContextMut<Data = T>) -> Result<Instance> {
-        let mut store = store.as_context_mut();
-        store
-            .engine()
-            .allocator()
-            .increment_component_instance_count()?;
-        let mut instantiator = Instantiator::new(&self.component, store.0, &self.imports);
-        instantiator.run(&mut store).map_err(|e| {
-            store
-                .engine()
-                .allocator()
-                .decrement_component_instance_count();
-            e
-        })?;
-        let data = Box::new(instantiator.data);
-        let instance = Instance(store.0.store_data_mut().insert(Some(data)));
-        store.0.push_component_instance(instance);
-        Ok(instance)
-    }
-}
-
-/// Description of the exports of an [`Instance`].
-///
-/// This structure is created through the [`Instance::exports`] method and is
-/// used lookup exports by name from within an instance.
-pub struct Exports<'store> {
-    store: &'store mut StoreOpaque,
-    data: Option<Box<InstanceData>>,
-    instance: Instance,
-}
-
-impl<'store> Exports<'store> {
-    fn new(store: &'store mut StoreOpaque, instance: &Instance) -> Exports<'store> {
-        // Note that the `InstanceData` is `take`n from the store here. That's
-        // to ease with the various liftimes in play here where we often need
-        // simultaneous borrows into the `store` and the `data`.
-        //
-        // To put the data back into the store the `Drop for Exports<'_>` will
-        // restore the state of the world.
-        Exports {
-            data: store[instance.0].take(),
-            store,
-            instance: *instance,
-        }
-    }
-
-    /// Returns the "root" instance of this set of exports, or the items that
-    /// are directly exported from the instance that this was created from.
-    pub fn root(&mut self) -> ExportInstance<'_, '_> {
-        let data = self.data.as_ref().unwrap();
-        ExportInstance {
-            exports: &data.component.env_component().exports,
-            instance: &self.instance,
-            data,
-            store: self.store,
-        }
-    }
-
-    /// Returns the items that the named instance exports.
-    ///
-    /// This method will lookup the exported instance with the name `name` from
-    /// this list of exports and return a descriptin of that instance's
-    /// exports.
-    pub fn instance(&mut self, name: &str) -> Option<ExportInstance<'_, '_>> {
-        self.root().into_instance(name)
-    }
-
-    // FIXME: should all the func/module/typed_func methods below be mirrored
-    // here as well? They're already mirrored on `Instance` and otherwise
-    // this is attempting to look like the `Linker` API "but in reverse"
-    // somewhat.
-}
-
-impl Drop for Exports<'_> {
-    fn drop(&mut self) {
-        // See `Exports::new` for where this data was originally extracted, and
-        // this is just restoring the state of the world.
-        self.store[self.instance.0] = self.data.take();
-    }
-}
-
-/// Description of the exports of a single instance.
-///
-/// This structure is created from [`Exports`] via the [`Exports::root`] or
-/// [`Exports::instance`] methods. This type provides access to the first layer
-/// of exports within an instance. The [`ExportInstance::instance`] method
-/// can be used to provide nested access to sub-instances.
-pub struct ExportInstance<'a, 'store> {
-    exports: &'a IndexMap<String, Export>,
-    instance: &'a Instance,
-    data: &'a InstanceData,
-    store: &'store mut StoreOpaque,
-}
-
-impl<'a, 'store> ExportInstance<'a, 'store> {
-    /// Same as [`Instance::get_func`]
-    pub fn func(&mut self, name: &str) -> Option<Func> {
-        match self.exports.get(name)? {
-            Export::LiftedFunction { ty, func, options } => Some(Func::from_lifted_func(
-                self.store,
-                self.instance,
-                self.data,
-                *ty,
-                func,
-                options,
-            )),
-            Export::ModuleStatic(_)
-            | Export::ModuleImport(_)
-            | Export::Instance(_)
-            | Export::Type(_) => None,
-        }
-    }
-
-    /// Same as [`Instance::get_typed_func`]
-    pub fn typed_func<Params, Results>(&mut self, name: &str) -> Result<TypedFunc<Params, Results>>
-    where
-        Params: ComponentNamedList + Lower,
-        Results: ComponentNamedList + Lift,
-    {
-        let func = self
-            .func(name)
-            .ok_or_else(|| anyhow!("failed to find function export `{}`", name))?;
-        Ok(func
-            ._typed::<Params, Results>(self.store, Some(self.data))
-            .with_context(|| format!("failed to convert function `{}` to given type", name))?)
-    }
-
-    /// Same as [`Instance::get_module`]
-    pub fn module(&mut self, name: &str) -> Option<&'a Module> {
-        match self.exports.get(name)? {
-            Export::ModuleStatic(idx) => Some(&self.data.component.static_module(*idx)),
-            Export::ModuleImport(idx) => Some(match &self.data.imports[*idx] {
-                RuntimeImport::Module(m) => m,
-                _ => unreachable!(),
-            }),
-            _ => None,
-        }
-    }
-
-    /// Same as [`Instance::get_resource`]
-    pub fn resource(&mut self, name: &str) -> Option<ResourceType> {
-        match self.exports.get(name)? {
-            Export::Type(TypeDef::Resource(id)) => Some(self.data.ty().resource_type(*id)),
-            Export::Type(_)
-            | Export::LiftedFunction { .. }
-            | Export::ModuleStatic(_)
-            | Export::ModuleImport(_)
-            | Export::Instance(_) => None,
-        }
-    }
-
-    /// Returns an iterator of all of the exported modules that this instance
-    /// contains.
-    //
-    // FIXME: this should probably be generalized in some form to something else
-    // that either looks like:
-    //
-    // * an iterator over all exports
-    // * an iterator for a `Component` with type information followed by a
-    //   `get_module` function here
-    //
-    // For now this is just quick-and-dirty to get wast support for iterating
-    // over exported modules to work.
-    pub fn modules(&self) -> impl Iterator<Item = (&'a str, &'a Module)> + '_ {
-        self.exports.iter().filter_map(|(name, export)| {
-            let module = match *export {
-                Export::ModuleStatic(idx) => self.data.component.static_module(idx),
-                Export::ModuleImport(idx) => match &self.data.imports[idx] {
-                    RuntimeImport::Module(m) => m,
-                    _ => unreachable!(),
-                },
-                _ => return None,
-            };
-            Some((name.as_str(), module))
-        })
-    }
-
-    fn as_mut(&mut self) -> ExportInstance<'a, '_> {
-        ExportInstance {
-            exports: self.exports,
-            instance: self.instance,
-            data: self.data,
-            store: self.store,
-        }
-    }
-
-    /// Looks up the exported instance with the `name` specified and returns
-    /// a description of its exports.
-    pub fn instance(&mut self, name: &str) -> Option<ExportInstance<'a, '_>> {
-        self.as_mut().into_instance(name)
-    }
-
-    /// Same as [`ExportInstance::instance`] but consumes self to yield a
-    /// return value with the same lifetimes.
-    pub fn into_instance(self, name: &str) -> Option<ExportInstance<'a, 'store>> {
-        match self.exports.get(name)? {
-            Export::Instance(exports) => Some(ExportInstance {
-                exports,
-                instance: self.instance,
-                data: self.data,
-                store: self.store,
-            }),
-            _ => None,
-        }
-    }
-}
diff --git a/crates/wasmtime/src/component/linker.rs b/crates/wasmtime/src/component/linker.rs
deleted file mode 100644
index 8efbbcbfe1b9..000000000000
--- a/crates/wasmtime/src/component/linker.rs
+++ /dev/null
@@ -1,496 +0,0 @@
-use crate::component::func::HostFunc;
-use crate::component::instance::RuntimeImport;
-use crate::component::matching::TypeChecker;
-use crate::component::{
-    Component, ComponentNamedList, Instance, InstancePre, Lift, Lower, ResourceType, Val,
-};
-use crate::{AsContextMut, Engine, Module, StoreContextMut};
-use anyhow::{anyhow, bail, Context, Result};
-use indexmap::IndexMap;
-use std::collections::hash_map::{Entry, HashMap};
-use std::future::Future;
-use std::marker;
-use std::ops::Deref;
-use std::pin::Pin;
-use std::sync::Arc;
-use wasmtime_environ::component::TypeDef;
-use wasmtime_environ::PrimaryMap;
-
-/// A type used to instantiate [`Component`]s.
-///
-/// This type is used to both link components together as well as supply host
-/// functionality to components. Values are defined in a [`Linker`] by their
-/// import name and then components are instantiated with a [`Linker`] using the
-/// names provided for name resolution of the component's imports.
-pub struct Linker<T> {
-    engine: Engine,
-    strings: Strings,
-    map: NameMap,
-    path: Vec<usize>,
-    allow_shadowing: bool,
-    _marker: marker::PhantomData<fn() -> T>,
-}
-
-impl<T> Clone for Linker<T> {
-    fn clone(&self) -> Linker<T> {
-        Linker {
-            engine: self.engine.clone(),
-            strings: self.strings.clone(),
-            map: self.map.clone(),
-            path: self.path.clone(),
-            allow_shadowing: self.allow_shadowing,
-            _marker: self._marker,
-        }
-    }
-}
-
-#[derive(Clone, Default)]
-pub struct Strings {
-    string2idx: HashMap<Arc<str>, usize>,
-    strings: Vec<Arc<str>>,
-}
-
-/// Structure representing an "instance" being defined within a linker.
-///
-/// Instances do not need to be actual [`Instance`]s and instead are defined by
-/// a "bag of named items", so each [`LinkerInstance`] can further define items
-/// internally.
-pub struct LinkerInstance<'a, T> {
-    engine: &'a Engine,
-    path: &'a mut Vec<usize>,
-    path_len: usize,
-    strings: &'a mut Strings,
-    map: &'a mut NameMap,
-    allow_shadowing: bool,
-    _marker: marker::PhantomData<fn() -> T>,
-}
-
-pub(crate) type NameMap = HashMap<usize, Definition>;
-
-#[derive(Clone)]
-pub(crate) enum Definition {
-    Instance(NameMap),
-    Func(Arc<HostFunc>),
-    Module(Module),
-    Resource(ResourceType, Arc<crate::func::HostFunc>),
-}
-
-impl<T> Linker<T> {
-    /// Creates a new linker for the [`Engine`] specified with no items defined
-    /// within it.
-    pub fn new(engine: &Engine) -> Linker<T> {
-        Linker {
-            engine: engine.clone(),
-            strings: Strings::default(),
-            map: NameMap::default(),
-            allow_shadowing: false,
-            path: Vec::new(),
-            _marker: marker::PhantomData,
-        }
-    }
-
-    /// Returns the [`Engine`] this is connected to.
-    pub fn engine(&self) -> &Engine {
-        &self.engine
-    }
-
-    /// Configures whether or not name-shadowing is allowed.
-    ///
-    /// By default name shadowing is not allowed and it's an error to redefine
-    /// the same name within a linker.
-    pub fn allow_shadowing(&mut self, allow: bool) -> &mut Self {
-        self.allow_shadowing = allow;
-        self
-    }
-
-    /// Returns the "root instance" of this linker, used to define names into
-    /// the root namespace.
-    pub fn root(&mut self) -> LinkerInstance<'_, T> {
-        LinkerInstance {
-            engine: &self.engine,
-            path: &mut self.path,
-            path_len: 0,
-            strings: &mut self.strings,
-            map: &mut self.map,
-            allow_shadowing: self.allow_shadowing,
-            _marker: self._marker,
-        }
-    }
-
-    /// Returns a builder for the named instance specified.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if `name` is already defined within the linker.
-    pub fn instance(&mut self, name: &str) -> Result<LinkerInstance<'_, T>> {
-        self.root().into_instance(name)
-    }
-
-    /// Performs a "pre-instantiation" to resolve the imports of the
-    /// [`Component`] specified with the items defined within this linker.
-    ///
-    /// This method will perform as much work as possible short of actually
-    /// instantiating an instance. Internally this will use the names defined
-    /// within this linker to satisfy the imports of the [`Component`] provided.
-    /// Additionally this will perform type-checks against the component's
-    /// imports against all items defined within this linker.
-    ///
-    /// Note that unlike internally in components where subtyping at the
-    /// interface-types layer is supported this is not supported here. Items
-    /// defined in this linker must match the component's imports precisely.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if this linker doesn't define a name that the
-    /// `component` imports or if a name defined doesn't match the type of the
-    /// item imported by the `component` provided.
-    pub fn instantiate_pre(&self, component: &Component) -> Result<InstancePre<T>> {
-        let mut cx = TypeChecker {
-            component: component.env_component(),
-            types: component.types(),
-            strings: &self.strings,
-            imported_resources: Default::default(),
-        };
-
-        // Walk over the component's list of import names and use that to lookup
-        // the definition within this linker that it corresponds to. When found
-        // perform a typecheck against the component's expected type.
-        let env_component = component.env_component();
-        for (_idx, (name, ty)) in env_component.import_types.iter() {
-            let import = self
-                .strings
-                .lookup(name)
-                .and_then(|name| self.map.get(&name));
-            cx.definition(ty, import)
-                .with_context(|| format!("import `{name}` has the wrong type"))?;
-        }
-
-        // Now that all imports are known to be defined and satisfied by this
-        // linker a list of "flat" import items (aka no instances) is created
-        // using the import map within the component created at
-        // component-compile-time.
-        let mut imports = PrimaryMap::with_capacity(env_component.imports.len());
-        for (idx, (import, names)) in env_component.imports.iter() {
-            let (root, _) = &env_component.import_types[*import];
-            let root = self.strings.lookup(root).unwrap();
-
-            // This is the flattening process where we go from a definition
-            // optionally through a list of exported names to get to the final
-            // item.
-            let mut cur = &self.map[&root];
-            for name in names {
-                let name = self.strings.lookup(name).unwrap();
-                cur = match cur {
-                    Definition::Instance(map) => &map[&name],
-                    _ => unreachable!(),
-                };
-            }
-            let import = match cur {
-                Definition::Module(m) => RuntimeImport::Module(m.clone()),
-                Definition::Func(f) => RuntimeImport::Func(f.clone()),
-                Definition::Resource(t, dtor) => RuntimeImport::Resource {
-                    ty: t.clone(),
-                    _dtor: dtor.clone(),
-                    dtor_funcref: component.resource_drop_func_ref(dtor),
-                },
-
-                // This is guaranteed by the compilation process that "leaf"
-                // runtime imports are never instances.
-                Definition::Instance(_) => unreachable!(),
-            };
-            let i = imports.push(import);
-            assert_eq!(i, idx);
-        }
-        Ok(unsafe { InstancePre::new_unchecked(component.clone(), imports) })
-    }
-
-    /// Instantiates the [`Component`] provided into the `store` specified.
-    ///
-    /// This function will use the items defined within this [`Linker`] to
-    /// satisfy the imports of the [`Component`] provided as necessary. For more
-    /// information about this see [`Linker::instantiate_pre`] as well.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if this [`Linker`] doesn't define an import that
-    /// `component` requires or if it is of the wrong type. Additionally this
-    /// can return an error if something goes wrong during instantiation such as
-    /// a runtime trap or a runtime limit being exceeded.
-    pub fn instantiate(
-        &self,
-        store: impl AsContextMut<Data = T>,
-        component: &Component,
-    ) -> Result<Instance> {
-        assert!(
-            !store.as_context().async_support(),
-            "must use async instantiation when async support is enabled"
-        );
-        self.instantiate_pre(component)?.instantiate(store)
-    }
-
-    /// Instantiates the [`Component`] provided into the `store` specified.
-    ///
-    /// This is exactly like [`Linker::instantiate`] except for async stores.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if this [`Linker`] doesn't define an import that
-    /// `component` requires or if it is of the wrong type. Additionally this
-    /// can return an error if something goes wrong during instantiation such as
-    /// a runtime trap or a runtime limit being exceeded.
-    #[cfg(feature = "async")]
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "async")))]
-    pub async fn instantiate_async(
-        &self,
-        store: impl AsContextMut<Data = T>,
-        component: &Component,
-    ) -> Result<Instance>
-    where
-        T: Send,
-    {
-        assert!(
-            store.as_context().async_support(),
-            "must use sync instantiation when async support is disabled"
-        );
-        self.instantiate_pre(component)?
-            .instantiate_async(store)
-            .await
-    }
-}
-
-impl<T> LinkerInstance<'_, T> {
-    fn as_mut(&mut self) -> LinkerInstance<'_, T> {
-        LinkerInstance {
-            engine: self.engine,
-            path: self.path,
-            path_len: self.path_len,
-            strings: self.strings,
-            map: self.map,
-            allow_shadowing: self.allow_shadowing,
-            _marker: self._marker,
-        }
-    }
-
-    /// Defines a new host-provided function into this [`Linker`].
-    ///
-    /// This method is used to give host functions to wasm components. The
-    /// `func` provided will be callable from linked components with the type
-    /// signature dictated by `Params` and `Return`. The `Params` is a tuple of
-    /// types that will come from wasm and `Return` is a value coming from the
-    /// host going back to wasm.
-    ///
-    /// Additionally the `func` takes a
-    /// [`StoreContextMut`](crate::StoreContextMut) as its first parameter.
-    ///
-    /// Note that `func` must be an `Fn` and must also be `Send + Sync +
-    /// 'static`. Shared state within a func is typically accessed with the `T`
-    /// type parameter from [`Store<T>`](crate::Store) which is accessible
-    /// through the leading [`StoreContextMut<'_, T>`](crate::StoreContextMut)
-    /// argument which can be provided to the `func` given here.
-    //
-    // TODO: needs more words and examples
-    pub fn func_wrap<F, Params, Return>(&mut self, name: &str, func: F) -> Result<()>
-    where
-        F: Fn(StoreContextMut<T>, Params) -> Result<Return> + Send + Sync + 'static,
-        Params: ComponentNamedList + Lift + 'static,
-        Return: ComponentNamedList + Lower + 'static,
-    {
-        let name = self.strings.intern(name);
-        self.insert(name, Definition::Func(HostFunc::from_closure(func)))
-    }
-
-    /// Defines a new host-provided async function into this [`Linker`].
-    ///
-    /// This is exactly like [`Self::func_wrap`] except it takes an async
-    /// host function.
-    #[cfg(feature = "async")]
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "async")))]
-    pub fn func_wrap_async<Params, Return, F>(&mut self, name: &str, f: F) -> Result<()>
-    where
-        F: for<'a> Fn(
-                StoreContextMut<'a, T>,
-                Params,
-            ) -> Box<dyn Future<Output = Result<Return>> + Send + 'a>
-            + Send
-            + Sync
-            + 'static,
-        Params: ComponentNamedList + Lift + 'static,
-        Return: ComponentNamedList + Lower + 'static,
-    {
-        assert!(
-            self.engine.config().async_support,
-            "cannot use `func_wrap_async` without enabling async support in the config"
-        );
-        let ff = move |mut store: StoreContextMut<'_, T>, params: Params| -> Result<Return> {
-            let async_cx = store.as_context_mut().0.async_cx().expect("async cx");
-            let mut future = Pin::from(f(store.as_context_mut(), params));
-            unsafe { async_cx.block_on(future.as_mut()) }?
-        };
-        self.func_wrap(name, ff)
-    }
-
-    /// Define a new host-provided function using dynamic types.
-    ///
-    /// `name` must refer to a function type import in `component`.  If and when
-    /// that import is invoked by the component, the specified `func` will be
-    /// called, which must return a `Val` which is an instance of the result
-    /// type of the import.
-    pub fn func_new<
-        F: Fn(StoreContextMut<'_, T>, &[Val], &mut [Val]) -> Result<()> + Send + Sync + 'static,
-    >(
-        &mut self,
-        component: &Component,
-        name: &str,
-        func: F,
-    ) -> Result<()> {
-        let mut map = &component
-            .env_component()
-            .import_types
-            .values()
-            .map(|(k, v)| (k.clone(), *v))
-            .collect::<IndexMap<_, _>>();
-
-        for name in self.path.iter().copied().take(self.path_len) {
-            let name = self.strings.strings[name].deref();
-            if let Some(ty) = map.get(name) {
-                if let TypeDef::ComponentInstance(index) = ty {
-                    map = &component.types()[*index].exports;
-                } else {
-                    bail!("import `{name}` has the wrong type (expected a component instance)");
-                }
-            } else {
-                bail!("import `{name}` not found");
-            }
-        }
-
-        if let Some(ty) = map.get(name) {
-            if let TypeDef::ComponentFunc(index) = ty {
-                let name = self.strings.intern(name);
-                return self.insert(
-                    name,
-                    Definition::Func(HostFunc::new_dynamic(func, *index, component.types())),
-                );
-            } else {
-                bail!("import `{name}` has the wrong type (expected a function)");
-            }
-        } else {
-            Err(anyhow!("import `{name}` not found"))
-        }
-    }
-
-    // TODO: define func_new_async
-
-    /// Defines a [`Module`] within this instance.
-    ///
-    /// This can be used to provide a core wasm [`Module`] as an import to a
-    /// component. The [`Module`] provided is saved within the linker for the
-    /// specified `name` in this instance.
-    pub fn module(&mut self, name: &str, module: &Module) -> Result<()> {
-        let name = self.strings.intern(name);
-        self.insert(name, Definition::Module(module.clone()))
-    }
-
-    /// Defines a new host [`ResourceType`] in this linker.
-    ///
-    /// This function is used to specify resources defined in the host. The `U`
-    /// type parameter here is the type parameter to [`Resource<U>`]. This means
-    /// that component types using this resource type will be visible in
-    /// Wasmtime as [`Resource<U>`].
-    ///
-    /// The `name` argument is the name to define the resource within this
-    /// linker.
-    ///
-    /// The `dtor` provided is a destructor that will get invoked when an owned
-    /// version of this resource is destroyed from the guest. Note that this
-    /// destructor is not called when a host-owned resource is destroyed as it's
-    /// assumed the host knows how to handle destroying its own resources.
-    ///
-    /// The `dtor` closure is provided the store state as the first argument
-    /// along with the representation of the resource that was just destroyed.
-    ///
-    /// [`Resource<U>`]: crate::component::Resource
-    ///
-    /// # Errors
-    ///
-    /// The provided `dtor` closure returns an error if something goes wrong
-    /// when a guest calls the `dtor` to drop a `Resource<T>` such as
-    /// a runtime trap or a runtime limit being exceeded.
-    pub fn resource<U: 'static>(
-        &mut self,
-        name: &str,
-        dtor: impl Fn(StoreContextMut<'_, T>, u32) -> Result<()> + Send + Sync + 'static,
-    ) -> Result<()> {
-        let name = self.strings.intern(name);
-        let dtor = Arc::new(crate::func::HostFunc::wrap(
-            &self.engine,
-            move |mut cx: crate::Caller<'_, T>, param: u32| dtor(cx.as_context_mut(), param),
-        ));
-        self.insert(name, Definition::Resource(ResourceType::host::<U>(), dtor))
-    }
-
-    /// Defines a nested instance within this instance.
-    ///
-    /// This can be used to describe arbitrarily nested levels of instances
-    /// within a linker to satisfy nested instance exports of components.
-    pub fn instance(&mut self, name: &str) -> Result<LinkerInstance<'_, T>> {
-        self.as_mut().into_instance(name)
-    }
-
-    /// Same as [`LinkerInstance::instance`] except with different lifetime
-    /// parameters.
-    pub fn into_instance(mut self, name: &str) -> Result<Self> {
-        let name = self.strings.intern(name);
-        let item = Definition::Instance(NameMap::default());
-        let slot = match self.map.entry(name) {
-            Entry::Occupied(_) if !self.allow_shadowing => {
-                bail!("import of `{}` defined twice", self.strings.strings[name])
-            }
-            Entry::Occupied(o) => {
-                let slot = o.into_mut();
-                *slot = item;
-                slot
-            }
-            Entry::Vacant(v) => v.insert(item),
-        };
-        self.map = match slot {
-            Definition::Instance(map) => map,
-            _ => unreachable!(),
-        };
-        self.path.truncate(self.path_len);
-        self.path.push(name);
-        self.path_len += 1;
-        Ok(self)
-    }
-
-    fn insert(&mut self, key: usize, item: Definition) -> Result<()> {
-        match self.map.entry(key) {
-            Entry::Occupied(_) if !self.allow_shadowing => {
-                bail!("import of `{}` defined twice", self.strings.strings[key])
-            }
-            Entry::Occupied(mut e) => {
-                e.insert(item);
-            }
-            Entry::Vacant(v) => {
-                v.insert(item);
-            }
-        }
-        Ok(())
-    }
-}
-
-impl Strings {
-    fn intern(&mut self, string: &str) -> usize {
-        if let Some(idx) = self.string2idx.get(string) {
-            return *idx;
-        }
-        let string: Arc<str> = string.into();
-        let idx = self.strings.len();
-        self.strings.push(string.clone());
-        self.string2idx.insert(string, idx);
-        idx
-    }
-
-    pub fn lookup(&self, string: &str) -> Option<usize> {
-        self.string2idx.get(string).cloned()
-    }
-}
diff --git a/crates/wasmtime/src/component/matching.rs b/crates/wasmtime/src/component/matching.rs
deleted file mode 100644
index c68a4995d4b4..000000000000
--- a/crates/wasmtime/src/component/matching.rs
+++ /dev/null
@@ -1,215 +0,0 @@
-use crate::component::func::HostFunc;
-use crate::component::linker::{Definition, NameMap, Strings};
-use crate::component::ResourceType;
-use crate::types::matching;
-use crate::Module;
-use anyhow::{anyhow, bail, Context, Result};
-use std::any::Any;
-use std::sync::Arc;
-use wasmtime_environ::component::{
-    ComponentTypes, ResourceIndex, TypeComponentInstance, TypeDef, TypeFuncIndex, TypeModule,
-    TypeResourceTableIndex,
-};
-use wasmtime_environ::PrimaryMap;
-use wasmtime_runtime::component::ComponentInstance;
-
-pub struct TypeChecker<'a> {
-    pub types: &'a Arc<ComponentTypes>,
-    pub component: &'a wasmtime_environ::component::Component,
-    pub strings: &'a Strings,
-    pub imported_resources: Arc<PrimaryMap<ResourceIndex, ResourceType>>,
-}
-
-#[derive(Copy, Clone)]
-#[doc(hidden)]
-pub struct InstanceType<'a> {
-    pub types: &'a Arc<ComponentTypes>,
-    pub resources: &'a Arc<PrimaryMap<ResourceIndex, ResourceType>>,
-}
-
-impl TypeChecker<'_> {
-    pub(crate) fn definition(
-        &mut self,
-        expected: &TypeDef,
-        actual: Option<&Definition>,
-    ) -> Result<()> {
-        match *expected {
-            TypeDef::Module(t) => match actual {
-                Some(Definition::Module(actual)) => self.module(&self.types[t], actual),
-                _ => bail!("expected module found {}", desc(actual)),
-            },
-            TypeDef::ComponentInstance(t) => match actual {
-                Some(Definition::Instance(actual)) => self.instance(&self.types[t], Some(actual)),
-                None => self.instance(&self.types[t], None),
-                _ => bail!("expected instance found {}", desc(actual)),
-            },
-            TypeDef::ComponentFunc(t) => match actual {
-                Some(Definition::Func(actual)) => self.func(t, actual),
-                _ => bail!("expected func found {}", desc(actual)),
-            },
-            TypeDef::Component(_) => bail!("expected component found {}", desc(actual)),
-            TypeDef::Interface(_) => bail!("expected type found {}", desc(actual)),
-
-            TypeDef::Resource(i) => {
-                let i = self.types[i].ty;
-                let actual = match actual {
-                    Some(Definition::Resource(actual, _dtor)) => actual,
-
-                    // If a resource is imported yet nothing was supplied then
-                    // that's only successful if the resource has itself
-                    // already been defined. If it's already defined then that
-                    // means that this is an `(eq ...)` import which is not
-                    // required to be satisfied via `Linker` definitions in the
-                    // Wasmtime API.
-                    None if self.imported_resources.get(i).is_some() => return Ok(()),
-
-                    _ => bail!("expected resource found {}", desc(actual)),
-                };
-
-                match self.imported_resources.get(i) {
-                    // If `i` hasn't been pushed onto `imported_resources` yet
-                    // then that means that it's the first time a new resource
-                    // was introduced, so record the type of this resource.  It
-                    // should always be the case that the next index assigned
-                    // is equal to `i` since types should be checked in the
-                    // same order they were assigned into the `Component` type.
-                    //
-                    // Note the `get_mut` here which is expected to always
-                    // succeed since `imported_resources` has not yet been
-                    // cloned.
-                    None => {
-                        let resources = Arc::get_mut(&mut self.imported_resources).unwrap();
-                        let id = resources.push(*actual);
-                        assert_eq!(id, i);
-                    }
-
-                    // If `i` has been defined, however, then that means that
-                    // this is an `(eq ..)` bounded type imported because it's
-                    // referring to a previously defined type.  In this
-                    // situation it's not required to provide a type import but
-                    // if it's supplied then it must be equal. In this situation
-                    // it's supplied, so test for equality.
-                    Some(expected) => {
-                        if expected != actual {
-                            bail!("mismatched resource types");
-                        }
-                    }
-                }
-                Ok(())
-            }
-
-            // not possible for valid components to import
-            TypeDef::CoreFunc(_) => unreachable!(),
-        }
-    }
-
-    fn module(&self, expected: &TypeModule, actual: &Module) -> Result<()> {
-        let actual_types = actual.types();
-        let actual = actual.env_module();
-
-        // Every export that is expected should be in the actual module we have
-        for (name, expected) in expected.exports.iter() {
-            let idx = actual
-                .exports
-                .get(name)
-                .ok_or_else(|| anyhow!("module export `{name}` not defined"))?;
-            let actual = actual.type_of(*idx);
-            matching::entity_ty(expected, self.types.module_types(), &actual, actual_types)
-                .with_context(|| format!("module export `{name}` has the wrong type"))?;
-        }
-
-        // Note the opposite order of checks here. Every import that the actual
-        // module expects should be imported by the expected module since the
-        // expected module has the set of items given to the actual module.
-        // Additionally the "matches" check is inverted here.
-        for (module, name, actual) in actual.imports() {
-            // TODO: shouldn't need a `.to_string()` here ideally
-            let expected = expected
-                .imports
-                .get(&(module.to_string(), name.to_string()))
-                .ok_or_else(|| anyhow!("module import `{module}::{name}` not defined"))?;
-            matching::entity_ty(&actual, actual_types, expected, self.types.module_types())
-                .with_context(|| format!("module import `{module}::{name}` has the wrong type"))?;
-        }
-        Ok(())
-    }
-
-    fn instance(
-        &mut self,
-        expected: &TypeComponentInstance,
-        actual: Option<&NameMap>,
-    ) -> Result<()> {
-        // Like modules, every export in the expected type must be present in
-        // the actual type. It's ok, though, to have extra exports in the actual
-        // type.
-        for (name, expected) in expected.exports.iter() {
-            // Interface types may be exported from a component in order to give them a name, but
-            // they don't have a definition in the sense that this search is interested in, so
-            // ignore them.
-            if let TypeDef::Interface(_) = expected {
-                continue;
-            }
-            let actual = self
-                .strings
-                .lookup(name)
-                .and_then(|name| actual?.get(&name));
-            self.definition(expected, actual)
-                .with_context(|| format!("instance export `{name}` has the wrong type"))?;
-        }
-        Ok(())
-    }
-
-    fn func(&self, expected: TypeFuncIndex, actual: &HostFunc) -> Result<()> {
-        let instance_type = InstanceType {
-            types: self.types,
-            resources: &self.imported_resources,
-        };
-        actual.typecheck(expected, &instance_type)
-    }
-}
-
-fn desc(def: Option<&Definition>) -> &'static str {
-    match def {
-        Some(def) => def.desc(),
-        None => "nothing",
-    }
-}
-
-impl Definition {
-    fn desc(&self) -> &'static str {
-        match self {
-            Definition::Module(_) => "module",
-            Definition::Func(_) => "func",
-            Definition::Instance(_) => "instance",
-            Definition::Resource(..) => "resource",
-        }
-    }
-}
-
-impl<'a> InstanceType<'a> {
-    pub fn new(instance: &'a ComponentInstance) -> InstanceType<'a> {
-        InstanceType {
-            types: instance.component_types(),
-            resources: downcast_arc_ref(instance.resource_types()),
-        }
-    }
-
-    pub fn resource_type(&self, index: TypeResourceTableIndex) -> ResourceType {
-        let index = self.types[index].ty;
-        self.resources[index]
-    }
-}
-
-/// Small helper method to downcast an `Arc` borrow into a borrow of a concrete
-/// type within the `Arc`.
-///
-/// Note that this is differnet than `downcast_ref` which projects out `&T`
-/// where here we want `&Arc<T>`.
-fn downcast_arc_ref<T: 'static>(arc: &Arc<dyn Any + Send + Sync>) -> &Arc<T> {
-    // First assert that the payload of the `Any` is indeed a `T`
-    let _ = arc.downcast_ref::<T>();
-
-    // Next do an unsafe pointer cast to convert the `Any` into `T` which should
-    // be safe given the above check.
-    unsafe { &*(arc as *const Arc<dyn Any + Send + Sync> as *const Arc<T>) }
-}
diff --git a/crates/wasmtime/src/component/mod.rs b/crates/wasmtime/src/component/mod.rs
deleted file mode 100644
index 73aaad8e1cfc..000000000000
--- a/crates/wasmtime/src/component/mod.rs
+++ /dev/null
@@ -1,348 +0,0 @@
-//! In-progress implementation of the WebAssembly component model
-//!
-//! This module is a work-in-progress and currently represents an incomplete and
-//! probably buggy implementation of the component model.
-
-#![cfg_attr(nightlydoc, doc(cfg(feature = "component-model")))]
-
-mod component;
-mod func;
-mod instance;
-mod linker;
-mod matching;
-mod resources;
-mod storage;
-mod store;
-pub mod types;
-mod values;
-pub use self::component::Component;
-pub use self::func::{
-    ComponentNamedList, ComponentType, Func, Lift, Lower, TypedFunc, WasmList, WasmStr,
-};
-pub use self::instance::{ExportInstance, Exports, Instance, InstancePre};
-pub use self::linker::{Linker, LinkerInstance};
-pub use self::resources::{Resource, ResourceAny};
-pub use self::types::{ResourceType, Type};
-pub use self::values::{Enum, Flags, List, OptionVal, Record, ResultVal, Tuple, Val, Variant};
-pub use wasmtime_component_macro::{flags, ComponentType, Lift, Lower};
-
-// These items are expected to be used by an eventual
-// `#[derive(ComponentType)]`, they are not part of Wasmtime's API stability
-// guarantees
-#[doc(hidden)]
-pub mod __internal {
-    pub use super::func::{
-        bad_type_info, format_flags, lower_payload, typecheck_enum, typecheck_flags,
-        typecheck_record, typecheck_variant, ComponentVariant, LiftContext, LowerContext,
-        MaybeUninitExt, Options,
-    };
-    pub use super::matching::InstanceType;
-    pub use crate::map_maybe_uninit;
-    pub use crate::store::StoreOpaque;
-    pub use anyhow;
-    #[cfg(feature = "async")]
-    pub use async_trait::async_trait;
-    pub use wasmtime_environ;
-    pub use wasmtime_environ::component::{CanonicalAbiInfo, ComponentTypes, InterfaceType};
-}
-
-pub(crate) use self::store::ComponentStoreData;
-
-/// Generate bindings for a WIT package.
-///
-/// This macro ingests a [WIT package] and will generate all the necessary
-/// bindings for instantiating and invoking a particular `world` in the
-/// package. A `world` in a WIT package is a description of imports and exports
-/// for a component. This provides a higher-level representation of working with
-/// a component than the raw [`Instance`] type which must be manually-type-check
-/// and manually have its imports provided via the [`Linker`] type.
-///
-/// The most basic usage of this macro is:
-///
-/// ```rust,ignore
-/// wasmtime::component::bindgen!("my-component");
-/// ```
-///
-/// This will parse your projects WIT package in a `wit` directory adjacent to
-/// your crate's `Cargo.toml`. All of the `*.wit` files in that directory are
-/// parsed and then the `default world` will be looked up within
-/// `my-component.wit`. This world is then used as the basis for generating
-/// bindings.
-///
-/// For example if your project contained:
-///
-/// ```text,ignore
-/// // wit/my-component.wit
-///
-/// package my:project
-///
-/// world hello-world {
-///     import name: func() -> string
-///     export greet: func()
-/// }
-/// ```
-///
-/// Then you can interact with the generated bindings like so:
-///
-/// ```rust,ignore
-/// use wasmtime::component::*;
-/// use wasmtime::{Config, Engine, Store};
-///
-/// bindgen!();
-///
-/// struct MyState {
-///     name: String,
-/// }
-///
-/// // Imports into the world, like the `name` import for this world, are satisfied
-/// // through traits.
-/// impl HelloWorldImports for MyState {
-///     // Note the `Result` return value here where `Ok` is returned back to
-///     // the component and `Err` will raise a trap.
-///     fn name(&mut self) -> wasmtime::Result<String> {
-///         Ok(self.name.clone())
-///     }
-/// }
-///
-/// fn main() -> wasmtime::Result<()> {
-///     // Configure an `Engine` and compile the `Component` that is being run for
-///     // the application.
-///     let mut config = Config::new();
-///     config.wasm_component_model(true);
-///     let engine = Engine::new(&config)?;
-///     let component = Component::from_file(&engine, "./your-component.wasm")?;
-///
-///     // Instantiation of bindings always happens through a `Linker`.
-///     // Configuration of the linker is done through a generated `add_to_linker`
-///     // method on the bindings structure.
-///     //
-///     // Note that the closure provided here is a projection from `T` in
-///     // `Store<T>` to `&mut U` where `U` implements the `HelloWorldImports`
-///     // trait. In this case the `T`, `MyState`, is stored directly in the
-///     // structure so no projection is necessary here.
-///     let mut linker = Linker::new(&engine);
-///     HelloWorld::add_to_linker(&mut linker, |state: &mut MyState| state)?;
-///
-///     // As with the core wasm API of Wasmtime instantiation occurs within a
-///     // `Store`. The bindings structure contains an `instantiate` method which
-///     // takes the store, component, and linker. This returns the `bindings`
-///     // structure which is an instance of `HelloWorld` and supports typed access
-///     // to the exports of the component.
-///     let mut store = Store::new(
-///         &engine,
-///         MyState {
-///             name: "me".to_string(),
-///         },
-///     );
-///     let (bindings, _) = HelloWorld::instantiate(&mut store, &component, &linker)?;
-///
-///     // Here our `greet` function doesn't take any parameters for the component,
-///     // but in the Wasmtime embedding API the first argument is always a `Store`.
-///     bindings.call_greet(&mut store)?;
-///     Ok(())
-/// }
-/// ```
-///
-/// The function signatures within generated traits and on generated exports
-/// match the component-model signatures as specified in the WIT `world` item.
-/// Note that WIT also has support for importing and exports interfaces within
-/// worlds, which can be bound here as well:
-///
-/// For example this WIT input
-///
-/// ```text,ignore
-/// // wit/my-component.wit
-///
-/// package my:project
-///
-/// interface host {
-///     gen-random-integer: func() -> u32
-///     sha256: func(bytes: list<u8>) -> string
-/// }
-///
-/// default world hello-world {
-///     import host
-///
-///     export demo: interface {
-///         run: func()
-///     }
-/// }
-/// ```
-///
-/// Then you can interact with the generated bindings like so:
-///
-/// ```rust,ignore
-/// use wasmtime::component::*;
-/// use wasmtime::{Config, Engine, Store};
-/// use my::project::host::Host;
-///
-/// bindgen!();
-///
-/// struct MyState {
-///     // ...
-/// }
-///
-/// // Note that the trait here is per-interface and within a submodule now.
-/// impl Host for MyState {
-///     fn gen_random_integer(&mut self) -> wasmtime::Result<u32> {
-///         Ok(rand::thread_rng().gen())
-///     }
-///
-///     fn sha256(&mut self, bytes: Vec<u8>) -> wasmtime::Result<String> {
-///         // ...
-///     }
-/// }
-///
-/// fn main() -> wasmtime::Result<()> {
-///     let mut config = Config::new();
-///     config.wasm_component_model(true);
-///     let engine = Engine::new(&config)?;
-///     let component = Component::from_file(&engine, "./your-component.wasm")?;
-///
-///     let mut linker = Linker::new(&engine);
-///     HelloWorld::add_to_linker(&mut linker, |state: &mut MyState| state)?;
-///
-///     let mut store = Store::new(
-///         &engine,
-///         MyState { /* ... */ },
-///     );
-///     let (bindings, _) = HelloWorld::instantiate(&mut store, &component, &linker)?;
-///
-///     // Note that the `demo` method returns a `&Demo` through which we can
-///     // run the methods on that interface.
-///     bindings.demo().call_run(&mut store)?;
-///     Ok(())
-/// }
-/// ```
-///
-/// The generated bindings can additionally be explored more fully with `cargo
-/// doc` to see what types and traits and such are generated.
-///
-/// # Syntax
-///
-/// This procedural macro accepts a few different syntaxes. The primary purpose
-/// of this macro is to locate a WIT package, parse it, and then extract a
-/// `world` from the parsed package. There are then codegen-specific options to
-/// the bindings themselves which can additionally be specified.
-///
-/// Basic usage of this macro looks like:
-///
-/// ```rust,ignore
-/// // Parse the `wit/` folder adjacent to this crate's `Cargo.toml` and look
-/// // for a `default world` in its documents. There must be exactly one
-/// // `default world` for this to succeed.
-/// bindgen!();
-///
-/// // Parse the `wit/` folder adjacent to this crate's `Cargo.toml` and look
-/// // for the world `foo` contained in it.
-/// bindgen!("foo");
-///
-/// // Parse the folder `other/wit/folder` adjacent to `Cargo.toml`.
-/// bindgen!(in "other/wit/folder");
-/// bindgen!("foo" in "other/wit/folder");
-///
-/// // Parse the file `foo.wit` as a single-file WIT package with no
-/// // dependencies.
-/// bindgen!("foo" in "foo.wit");
-/// ```
-///
-/// A more configured version of invoking this macro looks like:
-///
-/// ```rust,ignore
-/// bindgen!({
-///     world: "foo", // not needed if `path` has one `world`
-///
-///     // same as in `bindgen!(in "other/wit/folder")
-///     path: "other/wit/folder",
-///
-///     // Instead of `path` the WIT document can be provided inline if
-///     // desired.
-///     inline: "
-///         package my:inline
-///
-///         world foo {
-///             // ...
-///         }
-///     ",
-///
-///     // Add calls to `tracing::span!` before each import or export is called
-///     // to log arguments and return values.
-///     //
-///     // This option defaults to `false`.
-///     tracing: true,
-///
-///     // Imports will be async functions through #[async_trait] and exports
-///     // are also invoked as async functions. Requires `Config::async_support`
-///     // to be `true`.
-///     //
-///     // Note that this is only async for the host as the guest will still
-///     // appear as if it's invoking blocking functions.
-///     //
-///     // This option defaults to `false`.
-///     async: true,
-///
-///     // Alternative mode of async configuration where this still implies
-///     // async instantiation happens, for example, but more control is
-///     // provided over which imports are async and which aren't.
-///     //
-///     // Note that in this mode all exports are still async.
-///     async: {
-///         // All imports are async except for functions with these names
-///         except_imports: ["foo", "bar"],
-///
-///         // All imports are synchronous except for functions with these names
-///         //
-///         // Note that this key cannot be specified with `except_imports`,
-///         // only one or the other is accepted.
-///         only_imports: ["foo", "bar"],
-///     },
-///
-///     // This can be used to translate WIT return values of the form
-///     // `result<T, error-type>` into `Result<T, RustErrorType>` in Rust.
-///     // The `RustErrorType` structure will have an automatically generated
-///     // implementation of `From<ErrorType> for RustErrorType`. The
-///     // `RustErrorType` additionally can also represent a trap to
-///     // conveniently flatten all errors into one container.
-///     //
-///     // By default this option is not specified.
-///     trappable_error_type: {
-///         interface::ErrorType: RustErrorType,
-///     },
-///
-///     // All generated bindgen types are "owned" meaning types like `String`
-///     // are used instead of `&str`, for example. This is the default and
-///     // ensures that the same type used in both imports and exports uses the
-///     // same generated type.
-///     ownership: Owning,
-///
-///     // Alternative to `Owning` above where borrowed types attempt to be used
-///     // instead. The `duplicate_if_necessary` configures whether duplicate
-///     // Rust types will be generated for the same WIT type if necessary, for
-///     // example when a type is used both as an import and an export.
-///     ownership: Borrowing {
-///         duplicate_if_necessary: true
-///     },
-///
-///     // Restrict the code generated to what's needed for the interface
-///     // imports in the inlined WIT document fragment.
-///     interfaces: "
-///         import wasi:cli/command
-///     ",
-///
-///     // Remap imported interfaces or resources to types defined in Rust
-///     // elsewhere. Using this option will prevent any code from being
-///     // generated for interfaces mentioned here. Resources named here will
-///     // not have a type generated to represent the resource.
-///     //
-///     // Interfaces mapped with this option should be previously generated
-///     // with an invocation of this macro. Resources need to be mapped to a
-///     // Rust type name.
-///     with: {
-///         "wasi:random/random": some::other::wasi::random::random,
-///         "wasi:filesystem/types/descriptor": MyDescriptorType,
-///     },
-/// });
-/// ```
-///
-/// [WIT package]: https://github.com/WebAssembly/component-model/blob/main/design/mvp/WIT.md
-pub use wasmtime_component_macro::bindgen;
diff --git a/crates/wasmtime/src/component/resources.rs b/crates/wasmtime/src/component/resources.rs
deleted file mode 100644
index 9ed13faf3208..000000000000
--- a/crates/wasmtime/src/component/resources.rs
+++ /dev/null
@@ -1,725 +0,0 @@
-use crate::component::func::{bad_type_info, desc, LiftContext, LowerContext};
-use crate::component::matching::InstanceType;
-use crate::component::{ComponentType, Lift, Lower};
-use crate::store::{StoreId, StoreOpaque};
-use crate::{AsContextMut, StoreContextMut, Trap};
-use anyhow::{bail, Result};
-use std::any::TypeId;
-use std::fmt;
-use std::marker;
-use std::mem::MaybeUninit;
-use std::sync::atomic::{AtomicU32, Ordering::Relaxed};
-use wasmtime_environ::component::{CanonicalAbiInfo, DefinedResourceIndex, InterfaceType};
-use wasmtime_runtime::component::{ComponentInstance, InstanceFlags, ResourceTables};
-use wasmtime_runtime::{SendSyncPtr, VMFuncRef, ValRaw};
-
-/// Representation of a resource type in the component model.
-///
-/// Resources are currently always represented as 32-bit integers but they have
-/// unique types across instantiations and the host. For example instantiating
-/// the same component twice means that defined resource types in the component
-/// will all be different. Values of this type can be compared to see if
-/// resources have the same type.
-///
-/// Resource types can also be defined on the host in addition to guests. On the
-/// host resource types are tied to a `T`, an arbitrary Rust type. Two host
-/// resource types are the same if they point to the same `T`.
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct ResourceType {
-    kind: ResourceTypeKind,
-}
-
-impl ResourceType {
-    /// Creates a new host resource type corresponding to `T`.
-    ///
-    /// Note that `T` is a mostly a phantom type parameter here. It does not
-    /// need to reflect the actual storage of the resource `T`. For example this
-    /// is valid:
-    ///
-    /// ```rust
-    /// use wasmtime::component::ResourceType;
-    ///
-    /// struct Foo;
-    ///
-    /// let ty = ResourceType::host::<Foo>();
-    /// ```
-    ///
-    /// A resource type of type `ResourceType::host::<T>()` will match the type
-    /// of the value produced by `Resource::<T>::new_{own,borrow}`.
-    pub fn host<T: 'static>() -> ResourceType {
-        ResourceType {
-            kind: ResourceTypeKind::Host(TypeId::of::<T>()),
-        }
-    }
-
-    pub(crate) fn guest(
-        store: StoreId,
-        instance: &ComponentInstance,
-        id: DefinedResourceIndex,
-    ) -> ResourceType {
-        ResourceType {
-            kind: ResourceTypeKind::Guest {
-                store,
-                instance: instance as *const _ as usize,
-                id,
-            },
-        }
-    }
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-enum ResourceTypeKind {
-    Host(TypeId),
-    Guest {
-        store: StoreId,
-        // For now this is the `*mut ComponentInstance` pointer within the store
-        // that this guest corresponds to. It's used to distinguish different
-        // instantiations of the same component within the store.
-        instance: usize,
-        id: DefinedResourceIndex,
-    },
-}
-
-/// A host-defined resource in the component model.
-///
-/// This type can be thought of as roughly a newtype wrapper around `u32` for
-/// use as a resource with the component model. The main guarantee that the
-/// component model provides is that the `u32` is not forgeable by guests and
-/// there are guaranteed semantics about when a `u32` may be in use by the guest
-/// and when it's guaranteed no longer needed. This means that it is safe for
-/// embedders to consider the internal `u32` representation "trusted" and use it
-/// for things like table indices with infallible accessors that panic on
-/// out-of-bounds. This should only panic for embedder bugs, not because of any
-/// possible behavior in the guest.
-///
-/// A `Resource<T>` value dynamically represents both an `(own $t)` in the
-/// component model as well as a `(borrow $t)`. It can be inspected via
-/// [`Resource::owned`] to test whether it is an owned handle. An owned handle
-/// which is not actively borrowed can be destroyed at any time as it's
-/// guaranteed that the guest does not have access to it. A borrowed handle, on
-/// the other hand, may be accessed by the guest so it's not necessarily
-/// guaranteed to be able to be destroyed.
-///
-/// Note that the "own" and "borrow" here refer to the component model, not
-/// Rust. The semantics of Rust ownership and borrowing are slightly different
-/// than the component model's (but spiritually the same) in that more dynamic
-/// tracking is employed as part of the component model. This means that it's
-/// possible to get runtime errors when using a `Resource<T>`. For example it is
-/// an error to call [`Resource::new_borrow`] and pass that to a component
-/// function expecting `(own $t)` and this is not statically disallowed.
-///
-/// The [`Resource`] type implements both the [`Lift`] and [`Lower`] trait to be
-/// used with typed functions in the component model or as part of aggregate
-/// structures and datatypes.
-///
-/// # Destruction of a resource
-///
-/// Resources in the component model are optionally defined with a destructor,
-/// but this host resource type does not specify a destructor. It is left up to
-/// the embedder to be able to determine how best to a destroy a resource when
-/// it is owned.
-///
-/// Note, though, that while [`Resource`] itself does not specify destructors
-/// it's still possible to do so via the [`Linker::resource`] definition. When a
-/// resource type is defined for a guest component a destructor can be specified
-/// which can be used to hook into resource destruction triggered by the guest.
-///
-/// This means that there are two ways that resource destruction is handled:
-///
-/// * Host resources destroyed by the guest can hook into the
-///   [`Linker::resource`] destructor closure to handle resource destruction.
-///   This could, for example, remove table entries.
-///
-/// * Host resources owned by the host itself have no automatic means of
-///   destruction. The host can make its own determination that its own resource
-///   is not lent out to the guest and at that time choose to destroy or
-///   deallocate it.
-///
-/// # Dynamic behavior of a resource
-///
-/// A host-defined [`Resource`] does not necessarily represent a static value.
-/// Its internals may change throughout its usage to track the state associated
-/// with the resource. The internal 32-bit host-defined representation never
-/// changes, however.
-///
-/// For example if there's a component model function of the form:
-///
-/// ```wasm
-/// (func (param "a" (borrow $t)) (param "b" (own $t)))
-/// ```
-///
-/// Then that can be extracted in Rust with:
-///
-/// ```rust,ignore
-/// let func = instance.get_typed_func::<(&Resource<T>, &Resource<T>), ()>(&mut store, "name")?;
-/// ```
-///
-/// Here the exact same resource can be provided as both arguments but that is
-/// not valid to do so because the same resource cannot be actively borrowed and
-/// passed by-value as the second parameter at the same time. The internal state
-/// in `Resource<T>` will track this information and provide a dynamic runtime
-/// error in this situation.
-///
-/// Mostly it's important to be aware that there is dynamic state associated
-/// with a [`Resource<T>`] to provide errors in situations that cannot be
-/// statically ruled out.
-///
-/// # Borrows and host responsibilities
-///
-/// Borrows to resources in the component model are guaranteed to be transient
-/// such that if a borrow is passed as part of a function call then when the
-/// function returns it's guaranteed that the guest no longer has access to the
-/// resource. This guarantee, however, must be manually upheld by the host when
-/// it receives its own borrow.
-///
-/// As mentioned above the [`Resource<T>`] type can represent a borrowed value
-/// in addition to an owned value. This means a guest can provide the host with
-/// a borrow, such as an argument to an imported function:
-///
-/// ```rust,ignore
-/// linker.root().func_wrap("name", |_cx, (r,): (Resource<MyType>,)| {
-///     assert!(!r.owned());
-///     // .. here `r` is a borrowed value provided by the guest and the host
-///     // shouldn't continue to access it beyond the scope of this call
-/// })?;
-/// ```
-///
-/// In this situation the host should take care to not attempt to persist the
-/// resource beyond the scope of the call. It's the host's resource so it
-/// technically can do what it wants with it but nothing is statically
-/// preventing `r` to stay pinned to the lifetime of the closure invocation.
-/// It's considered a mistake that the host performed if `r` is persisted too
-/// long and accessed at the wrong time.
-///
-/// [`Linker::resource`]: crate::component::LinkerInstance::resource
-pub struct Resource<T> {
-    /// The host-defined 32-bit representation of this resource.
-    rep: u32,
-
-    /// Dear rust please consider `T` used even though it's not actually used.
-    _marker: marker::PhantomData<fn() -> T>,
-
-    /// Internal dynamic state tracking for this resource. This can be one of
-    /// four different states:
-    ///
-    /// * `BORROW` / `u32::MAX` - this indicates that this is a borrowed
-    ///   resource. The `rep` doesn't live in the host table and this `Resource`
-    ///   instance is transiently available. It's the host's responsibility to
-    ///   discard this resource when the borrow duration has finished.
-    ///
-    /// * `NOT_IN_TABLE` / `u32::MAX - 1` - this indicates that this is an owned
-    ///   resource not present in any store's table. This resource is not lent
-    ///   out. It can be passed as an `(own $t)` directly into a guest's table
-    ///   or it can be passed as a borrow to a guest which will insert it into
-    ///   a host store's table for dynamic borrow tracking.
-    ///
-    /// * `TAKEN` / `u32::MAX - 2` - while the `rep` is available the resource
-    ///   has been dynamically moved into a guest and cannot be moved in again.
-    ///   This is used for example to prevent the same resource from being
-    ///   passed twice to a guest.
-    ///
-    /// * All other values - any other value indicates that the value is an
-    ///   index into a store's table of host resources. It's guaranteed that the
-    ///   table entry represents a host resource and the resource may have
-    ///   borrow tracking associated with it.
-    ///
-    /// Note that this is an `AtomicU32` but it's not intended to actually be
-    /// used in conjunction with threads as generally a `Store<T>` lives on one
-    /// thread at a time. The `AtomicU32` here is used to ensure that this type
-    /// is `Send + Sync` when captured as a reference to make async programming
-    /// more ergonomic.
-    state: AtomicU32,
-}
-
-// See comments on `state` above for info about these values.
-const BORROW: u32 = u32::MAX;
-const NOT_IN_TABLE: u32 = u32::MAX - 1;
-const TAKEN: u32 = u32::MAX - 2;
-
-fn host_resource_tables(store: &mut StoreOpaque) -> ResourceTables<'_> {
-    let (calls, host_table) = store.component_calls_and_host_table();
-    ResourceTables {
-        calls,
-        host_table: Some(host_table),
-        tables: None,
-    }
-}
-
-impl<T> Resource<T>
-where
-    T: 'static,
-{
-    /// Creates a new owned resource with the `rep` specified.
-    ///
-    /// The returned value is suitable for passing to a guest as either a
-    /// `(borrow $t)` or `(own $t)`.
-    pub fn new_own(rep: u32) -> Resource<T> {
-        Resource {
-            state: AtomicU32::new(NOT_IN_TABLE),
-            rep,
-            _marker: marker::PhantomData,
-        }
-    }
-
-    /// Creates a new borrowed resource which isn't actually rooted in any
-    /// ownership.
-    ///
-    /// This can be used to pass to a guest as a borrowed resource and the
-    /// embedder will know that the `rep` won't be in use by the guest
-    /// afterwards. Exactly how the lifetime of `rep` works is up to the
-    /// embedder.
-    pub fn new_borrow(rep: u32) -> Resource<T> {
-        Resource {
-            state: AtomicU32::new(BORROW),
-            rep,
-            _marker: marker::PhantomData,
-        }
-    }
-
-    /// Returns the underlying 32-bit representation used to originally create
-    /// this resource.
-    pub fn rep(&self) -> u32 {
-        self.rep
-    }
-
-    /// Returns whether this is an owned resource or not.
-    ///
-    /// Owned resources can be safely destroyed by the embedder at any time, and
-    /// borrowed resources have an owner somewhere else on the stack so can only
-    /// be accessed, not destroyed.
-    pub fn owned(&self) -> bool {
-        match self.state.load(Relaxed) {
-            BORROW => false,
-            _ => true,
-        }
-    }
-
-    fn lower_to_index<U>(&self, cx: &mut LowerContext<'_, U>, ty: InterfaceType) -> Result<u32> {
-        match ty {
-            InterfaceType::Own(t) => {
-                let rep = match self.state.load(Relaxed) {
-                    // If this is a borrow resource then this is a dynamic
-                    // error on behalf of the embedder.
-                    BORROW => {
-                        bail!("cannot lower a `borrow` resource into an `own`")
-                    }
-
-                    // If this resource does not yet live in a table then we're
-                    // dynamically transferring ownership to wasm. Record that
-                    // it's no longer present and then pass through the
-                    // representation.
-                    NOT_IN_TABLE => {
-                        let prev = self.state.swap(TAKEN, Relaxed);
-                        assert_eq!(prev, NOT_IN_TABLE);
-                        self.rep
-                    }
-
-                    // This resource has already been moved into wasm so this is
-                    // a dynamic error on behalf of the embedder.
-                    TAKEN => bail!("host resource already consumed"),
-
-                    // If this resource lives in a host table then try to take
-                    // it out of the table, which may fail, and on success we
-                    // can move the rep into the guest table.
-                    idx => cx.host_resource_lift_own(idx)?,
-                };
-                Ok(cx.guest_resource_lower_own(t, rep))
-            }
-            InterfaceType::Borrow(t) => {
-                let rep = match self.state.load(Relaxed) {
-                    // If this is already a borrowed resource, nothing else to
-                    // do and the rep is passed through.
-                    BORROW => self.rep,
-
-                    // If this resource is already gone, that's a dynamic error
-                    // for the embedder.
-                    TAKEN => bail!("host resource already consumed"),
-
-                    // If this resource is not currently in a table then it
-                    // needs to move into a table to participate in state
-                    // related to borrow tracking. Execute the
-                    // `host_resource_lower_own` operation here and update our
-                    // state.
-                    //
-                    // Afterwards this is the same as the `idx` case below.
-                    NOT_IN_TABLE => {
-                        let idx = cx.host_resource_lower_own(self.rep);
-                        let prev = self.state.swap(idx, Relaxed);
-                        assert_eq!(prev, NOT_IN_TABLE);
-                        cx.host_resource_lift_borrow(idx)?
-                    }
-
-                    // If this resource lives in a table then it needs to come
-                    // out of the table with borrow-tracking employed.
-                    idx => cx.host_resource_lift_borrow(idx)?,
-                };
-                Ok(cx.guest_resource_lower_borrow(t, rep))
-            }
-            _ => bad_type_info(),
-        }
-    }
-
-    fn lift_from_index(cx: &mut LiftContext<'_>, ty: InterfaceType, index: u32) -> Result<Self> {
-        let (state, rep) = match ty {
-            // Ownership is being transferred from a guest to the host, so move
-            // it from the guest table into a new `Resource`. Note that this
-            // isn't immediately inserted into the host table and that's left
-            // for the future if it's necessary to take a borrow from this owned
-            // resource.
-            InterfaceType::Own(t) => {
-                debug_assert!(cx.resource_type(t) == ResourceType::host::<T>());
-                let (rep, dtor, flags) = cx.guest_resource_lift_own(t, index)?;
-                assert!(dtor.is_some());
-                assert!(flags.is_none());
-                (AtomicU32::new(NOT_IN_TABLE), rep)
-            }
-
-            // The borrow here is lifted from the guest, but note the lack of
-            // `host_resource_lower_borrow` as it's intentional. Lowering
-            // a borrow has a special case in the canonical ABI where if the
-            // receiving module is the owner of the resource then it directly
-            // receives the `rep` and no other dynamic tracking is employed.
-            // This effectively mirrors that even though the canonical ABI
-            // isn't really all that applicable in host context here.
-            InterfaceType::Borrow(t) => {
-                debug_assert!(cx.resource_type(t) == ResourceType::host::<T>());
-                let rep = cx.guest_resource_lift_borrow(t, index)?;
-                (AtomicU32::new(BORROW), rep)
-            }
-            _ => bad_type_info(),
-        };
-        Ok(Resource {
-            state,
-            rep,
-            _marker: marker::PhantomData,
-        })
-    }
-}
-
-unsafe impl<T: 'static> ComponentType for Resource<T> {
-    const ABI: CanonicalAbiInfo = CanonicalAbiInfo::SCALAR4;
-
-    type Lower = <u32 as ComponentType>::Lower;
-
-    fn typecheck(ty: &InterfaceType, types: &InstanceType<'_>) -> Result<()> {
-        let resource = match ty {
-            InterfaceType::Own(t) | InterfaceType::Borrow(t) => *t,
-            other => bail!("expected `own` or `borrow`, found `{}`", desc(other)),
-        };
-        match types.resource_type(resource).kind {
-            ResourceTypeKind::Host(id) if TypeId::of::<T>() == id => {}
-            _ => bail!("resource type mismatch"),
-        }
-
-        Ok(())
-    }
-}
-
-unsafe impl<T: 'static> Lower for Resource<T> {
-    fn lower<U>(
-        &self,
-        cx: &mut LowerContext<'_, U>,
-        ty: InterfaceType,
-        dst: &mut MaybeUninit<Self::Lower>,
-    ) -> Result<()> {
-        self.lower_to_index(cx, ty)?
-            .lower(cx, InterfaceType::U32, dst)
-    }
-
-    fn store<U>(
-        &self,
-        cx: &mut LowerContext<'_, U>,
-        ty: InterfaceType,
-        offset: usize,
-    ) -> Result<()> {
-        self.lower_to_index(cx, ty)?
-            .store(cx, InterfaceType::U32, offset)
-    }
-}
-
-unsafe impl<T: 'static> Lift for Resource<T> {
-    fn lift(cx: &mut LiftContext<'_>, ty: InterfaceType, src: &Self::Lower) -> Result<Self> {
-        let index = u32::lift(cx, InterfaceType::U32, src)?;
-        Resource::lift_from_index(cx, ty, index)
-    }
-
-    fn load(cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Self> {
-        let index = u32::load(cx, InterfaceType::U32, bytes)?;
-        Resource::lift_from_index(cx, ty, index)
-    }
-}
-
-impl<T> fmt::Debug for Resource<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let state = match self.state.load(Relaxed) {
-            BORROW => "borrow",
-            NOT_IN_TABLE => "own (not in table)",
-            TAKEN => "taken",
-            _ => "own",
-        };
-        f.debug_struct("Resource")
-            .field("rep", &self.rep)
-            .field("state", &state)
-            .finish()
-    }
-}
-
-/// Representation of a resource in the component model, either a guest-defined
-/// or a host-defined resource.
-///
-/// This type is similar to [`Resource`] except that it can be used to represent
-/// any resource, either host or guest. This type cannot be directly constructed
-/// and is only available if the guest returns it to the host (e.g. a function
-/// returning a guest-defined resource). This type also does not carry a static
-/// type parameter `T` for example and does not have as much information about
-/// its type. This means that it's possible to get runtime type-errors when
-/// using this type because it cannot statically prevent mismatching resource
-/// types.
-///
-/// Like [`Resource`] this type represents either an `own` or a `borrow`
-/// resource internally. Unlike [`Resource`], however, a [`ResourceAny`] must
-/// always be explicitly destroyed with the [`ResourceAny::resource_drop`]
-/// method. This will update internal dynamic state tracking and invoke the
-/// WebAssembly-defined destructor for a resource, if any.
-///
-/// Note that it is required to call `resource_drop` for all instances of
-/// [`ResourceAny`]: even borrows. Both borrows and own handles have state
-/// associated with them that must be discarded by the time they're done being
-/// used.
-#[derive(Debug, PartialEq, Eq, Copy, Clone)]
-pub struct ResourceAny {
-    idx: u32,
-    ty: ResourceType,
-    own_state: Option<OwnState>,
-}
-
-#[derive(Copy, Clone)]
-struct OwnState {
-    store: StoreId,
-    flags: Option<InstanceFlags>,
-    dtor: Option<SendSyncPtr<VMFuncRef>>,
-}
-
-impl ResourceAny {
-    /// Returns the corresponding type associated with this resource, either a
-    /// host-defined type or a guest-defined type.
-    ///
-    /// This can be compared against [`ResourceType::host`] for example to see
-    /// if it's a host-resource or against a type extracted with
-    /// [`Instance::get_resource`] to see if it's a guest-defined resource.
-    ///
-    /// [`Instance::get_resource`]: crate::component::Instance::get_resource
-    pub fn ty(&self) -> ResourceType {
-        self.ty
-    }
-
-    /// Returns whether this is an owned resource, and if not it's a borrowed
-    /// resource.
-    pub fn owned(&self) -> bool {
-        self.own_state.is_some()
-    }
-
-    /// Destroy this resource and release any state associated with it.
-    ///
-    /// This is required to be called (or the async version) for all instances
-    /// of [`ResourceAny`] to ensure that state associated with this resource is
-    /// properly cleaned up. For owned resources this may execute the
-    /// guest-defined destructor if applicable (or the host-defined destructor
-    /// if one was specified).
-    pub fn resource_drop(self, mut store: impl AsContextMut) -> Result<()> {
-        let mut store = store.as_context_mut();
-        assert!(
-            !store.0.async_support(),
-            "must use `resource_drop_async` when async support is enabled on the config"
-        );
-        self.resource_drop_impl(&mut store.as_context_mut())
-    }
-
-    /// Same as [`ResourceAny::resource_drop`] except for use with async stores
-    /// to execute the destructor asynchronously.
-    #[cfg(feature = "async")]
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "async")))]
-    pub async fn resource_drop_async<T>(self, mut store: impl AsContextMut<Data = T>) -> Result<()>
-    where
-        T: Send,
-    {
-        let mut store = store.as_context_mut();
-        assert!(
-            store.0.async_support(),
-            "cannot use `resource_drop_async` without enabling async support in the config"
-        );
-        store
-            .on_fiber(|store| self.resource_drop_impl(store))
-            .await?
-    }
-
-    fn resource_drop_impl<T>(self, store: &mut StoreContextMut<'_, T>) -> Result<()> {
-        // Attempt to remove `self.idx` from the host table in `store`.
-        //
-        // This could fail if the index is invalid or if this is removing an
-        // `Own` entry which is currently being borrowed.
-        let rep = host_resource_tables(store.0).resource_drop(None, self.idx)?;
-
-        let (rep, state) = match (rep, &self.own_state) {
-            (Some(rep), Some(state)) => (rep, state),
-
-            // A `borrow` was removed from the table and no further
-            // destruction, e.g. the destructor, is required so we're done.
-            (None, None) => return Ok(()),
-
-            _ => unreachable!(),
-        };
-
-        // Double-check that accessing the raw pointers on `state` are safe due
-        // to the presence of `store` above.
-        assert_eq!(
-            store.0.id(),
-            state.store,
-            "wrong store used to destroy resource"
-        );
-
-        // Implement the reentrance check required by the canonical ABI. Note
-        // that this happens whether or not a destructor is present.
-        //
-        // Note that this should be safe because the raw pointer access in
-        // `flags` is valid due to `store` being the owner of the flags and
-        // flags are never destroyed within the store.
-        if let Some(flags) = state.flags {
-            unsafe {
-                if !flags.may_enter() {
-                    bail!(Trap::CannotEnterComponent);
-                }
-            }
-        }
-
-        let dtor = match state.dtor {
-            Some(dtor) => dtor.as_non_null(),
-            None => return Ok(()),
-        };
-        let mut args = [ValRaw::u32(rep)];
-
-        // This should be safe because `dtor` has been checked to belong to the
-        // `store` provided which means it's valid and still alive. Additionally
-        // destructors have al been previously type-checked and are guaranteed
-        // to take one i32 argument and return no results, so the parameters
-        // here should be configured correctly.
-        unsafe { crate::Func::call_unchecked_raw(store, dtor, args.as_mut_ptr(), args.len()) }
-    }
-
-    fn lower_to_index<U>(&self, cx: &mut LowerContext<'_, U>, ty: InterfaceType) -> Result<u32> {
-        match ty {
-            InterfaceType::Own(t) => {
-                if cx.resource_type(t) != self.ty {
-                    bail!("mismatched resource types")
-                }
-                let rep = cx.host_resource_lift_own(self.idx)?;
-                Ok(cx.guest_resource_lower_own(t, rep))
-            }
-            InterfaceType::Borrow(t) => {
-                if cx.resource_type(t) != self.ty {
-                    bail!("mismatched resource types")
-                }
-                let rep = cx.host_resource_lift_borrow(self.idx)?;
-                Ok(cx.guest_resource_lower_borrow(t, rep))
-            }
-            _ => bad_type_info(),
-        }
-    }
-
-    fn lift_from_index(cx: &mut LiftContext<'_>, ty: InterfaceType, index: u32) -> Result<Self> {
-        match ty {
-            InterfaceType::Own(t) => {
-                let ty = cx.resource_type(t);
-                let (rep, dtor, flags) = cx.guest_resource_lift_own(t, index)?;
-                let idx = cx.host_resource_lower_own(rep);
-                Ok(ResourceAny {
-                    idx,
-                    ty,
-                    own_state: Some(OwnState {
-                        dtor: dtor.map(SendSyncPtr::new),
-                        flags,
-                        store: cx.store_id(),
-                    }),
-                })
-            }
-            InterfaceType::Borrow(t) => {
-                let ty = cx.resource_type(t);
-                let rep = cx.guest_resource_lift_borrow(t, index)?;
-                let idx = cx.host_resource_lower_borrow(rep);
-                Ok(ResourceAny {
-                    idx,
-                    ty,
-                    own_state: None,
-                })
-            }
-            _ => bad_type_info(),
-        }
-    }
-}
-
-unsafe impl ComponentType for ResourceAny {
-    const ABI: CanonicalAbiInfo = CanonicalAbiInfo::SCALAR4;
-
-    type Lower = <u32 as ComponentType>::Lower;
-
-    fn typecheck(ty: &InterfaceType, _types: &InstanceType<'_>) -> Result<()> {
-        match ty {
-            InterfaceType::Own(_) | InterfaceType::Borrow(_) => Ok(()),
-            other => bail!("expected `own` or `borrow`, found `{}`", desc(other)),
-        }
-    }
-}
-
-unsafe impl Lower for ResourceAny {
-    fn lower<T>(
-        &self,
-        cx: &mut LowerContext<'_, T>,
-        ty: InterfaceType,
-        dst: &mut MaybeUninit<Self::Lower>,
-    ) -> Result<()> {
-        self.lower_to_index(cx, ty)?
-            .lower(cx, InterfaceType::U32, dst)
-    }
-
-    fn store<T>(
-        &self,
-        cx: &mut LowerContext<'_, T>,
-        ty: InterfaceType,
-        offset: usize,
-    ) -> Result<()> {
-        self.lower_to_index(cx, ty)?
-            .store(cx, InterfaceType::U32, offset)
-    }
-}
-
-unsafe impl Lift for ResourceAny {
-    fn lift(cx: &mut LiftContext<'_>, ty: InterfaceType, src: &Self::Lower) -> Result<Self> {
-        let index = u32::lift(cx, InterfaceType::U32, src)?;
-        ResourceAny::lift_from_index(cx, ty, index)
-    }
-
-    fn load(cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Self> {
-        let index = u32::load(cx, InterfaceType::U32, bytes)?;
-        ResourceAny::lift_from_index(cx, ty, index)
-    }
-}
-
-impl fmt::Debug for OwnState {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("OwnState")
-            .field("store", &self.store)
-            .finish()
-    }
-}
-
-// This is a loose definition for `Val` primarily so it doesn't need to be
-// strictly 100% correct, and equality of resources is a bit iffy anyway, so
-// ignore equality here and only factor in the indices and other metadata in
-// `ResourceAny`.
-impl PartialEq for OwnState {
-    fn eq(&self, _other: &OwnState) -> bool {
-        true
-    }
-}
-
-impl Eq for OwnState {}
diff --git a/crates/wasmtime/src/component/store.rs b/crates/wasmtime/src/component/store.rs
deleted file mode 100644
index 9144761391c0..000000000000
--- a/crates/wasmtime/src/component/store.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-use crate::store::{StoreData, StoredData};
-
-macro_rules! component_store_data {
-    ($($field:ident => $t:ty,)*) => (
-        #[derive(Default)]
-        pub struct ComponentStoreData {
-            $($field: Vec<$t>,)*
-        }
-
-        $(
-            impl StoredData for $t {
-                #[inline]
-                fn list(data: &StoreData) -> &Vec<Self> {
-                    &data.components.$field
-                }
-                #[inline]
-                fn list_mut(data: &mut StoreData) -> &mut Vec<Self> {
-                    &mut data.components.$field
-                }
-            }
-        )*
-    )
-}
-
-component_store_data! {
-    funcs => crate::component::func::FuncData,
-    instances => Option<Box<crate::component::instance::InstanceData>>,
-}
diff --git a/crates/wasmtime/src/component/types.rs b/crates/wasmtime/src/component/types.rs
deleted file mode 100644
index f751079fa037..000000000000
--- a/crates/wasmtime/src/component/types.rs
+++ /dev/null
@@ -1,752 +0,0 @@
-//! This module defines the `Type` type, representing the dynamic form of a component interface type.
-
-use crate::component::matching::InstanceType;
-use crate::component::values::{self, Val};
-use anyhow::{anyhow, Result};
-use std::fmt;
-use std::mem;
-use std::ops::Deref;
-use std::sync::Arc;
-use wasmtime_environ::component::{
-    CanonicalAbiInfo, ComponentTypes, InterfaceType, ResourceIndex, TypeEnumIndex, TypeFlagsIndex,
-    TypeListIndex, TypeOptionIndex, TypeRecordIndex, TypeResourceTableIndex, TypeResultIndex,
-    TypeTupleIndex, TypeVariantIndex,
-};
-use wasmtime_environ::PrimaryMap;
-
-pub use crate::component::resources::ResourceType;
-
-/// An owned and `'static` handle for type information in a component.
-///
-/// The components here are:
-///
-/// * `index` - a `TypeFooIndex` defined in the `wasmtime_environ` crate. This
-///   then points into the next field of...
-///
-/// * `types` - this is an allocation originally created from compilation and is
-///   stored in a compiled `Component`. This contains all types necessary and
-///   information about recursive structures and all other type information
-///   within the component. The above `index` points into this structure.
-///
-/// * `resources` - this is used to "close the loop" and represent a concrete
-///   instance type rather than an abstract component type. Instantiating a
-///   component with different resources produces different instance types but
-///   the same underlying component type, so this field serves the purpose to
-///   distinguish instance types from one another. This is runtime state created
-///   during instantiation and threaded through here.
-#[derive(Clone)]
-struct Handle<T> {
-    index: T,
-    types: Arc<ComponentTypes>,
-    resources: Arc<PrimaryMap<ResourceIndex, ResourceType>>,
-}
-
-impl<T> Handle<T> {
-    fn new(index: T, ty: &InstanceType<'_>) -> Handle<T> {
-        Handle {
-            index,
-            types: ty.types.clone(),
-            resources: ty.resources.clone(),
-        }
-    }
-
-    fn instance(&self) -> InstanceType<'_> {
-        InstanceType {
-            types: &self.types,
-            resources: &self.resources,
-        }
-    }
-
-    fn equivalent<'a>(
-        &'a self,
-        other: &'a Self,
-        type_check: fn(&TypeChecker<'a>, T, T) -> bool,
-    ) -> bool
-    where
-        T: PartialEq + Copy,
-    {
-        (self.index == other.index
-            && Arc::ptr_eq(&self.types, &other.types)
-            && Arc::ptr_eq(&self.resources, &other.resources))
-            || type_check(
-                &TypeChecker {
-                    a_types: &self.types,
-                    b_types: &other.types,
-                    a_resource: &self.resources,
-                    b_resource: &other.resources,
-                },
-                self.index,
-                other.index,
-            )
-    }
-}
-
-impl<T: fmt::Debug> fmt::Debug for Handle<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Handle")
-            .field("index", &self.index)
-            .finish()
-    }
-}
-
-/// Type checker between two `Handle`s
-struct TypeChecker<'a> {
-    a_types: &'a ComponentTypes,
-    a_resource: &'a PrimaryMap<ResourceIndex, ResourceType>,
-    b_types: &'a ComponentTypes,
-    b_resource: &'a PrimaryMap<ResourceIndex, ResourceType>,
-}
-
-impl TypeChecker<'_> {
-    fn interface_types_equal(&self, a: InterfaceType, b: InterfaceType) -> bool {
-        match (a, b) {
-            (InterfaceType::Own(o1), InterfaceType::Own(o2)) => self.resources_equal(o1, o2),
-            (InterfaceType::Own(_), _) => false,
-            (InterfaceType::Borrow(b1), InterfaceType::Borrow(b2)) => self.resources_equal(b1, b2),
-            (InterfaceType::Borrow(_), _) => false,
-            (InterfaceType::List(l1), InterfaceType::List(l2)) => self.lists_equal(l1, l2),
-            (InterfaceType::List(_), _) => false,
-            (InterfaceType::Record(r1), InterfaceType::Record(r2)) => self.records_equal(r1, r2),
-            (InterfaceType::Record(_), _) => false,
-            (InterfaceType::Variant(v1), InterfaceType::Variant(v2)) => self.variants_equal(v1, v2),
-            (InterfaceType::Variant(_), _) => false,
-            (InterfaceType::Result(r1), InterfaceType::Result(r2)) => self.results_equal(r1, r2),
-            (InterfaceType::Result(_), _) => false,
-            (InterfaceType::Option(o1), InterfaceType::Option(o2)) => self.options_equal(o1, o2),
-            (InterfaceType::Option(_), _) => false,
-            (InterfaceType::Enum(e1), InterfaceType::Enum(e2)) => self.enums_equal(e1, e2),
-            (InterfaceType::Enum(_), _) => false,
-            (InterfaceType::Tuple(t1), InterfaceType::Tuple(t2)) => self.tuples_equal(t1, t2),
-            (InterfaceType::Tuple(_), _) => false,
-            (InterfaceType::Flags(f1), InterfaceType::Flags(f2)) => self.flags_equal(f1, f2),
-            (InterfaceType::Flags(_), _) => false,
-            (InterfaceType::Bool, InterfaceType::Bool) => true,
-            (InterfaceType::Bool, _) => false,
-            (InterfaceType::U8, InterfaceType::U8) => true,
-            (InterfaceType::U8, _) => false,
-            (InterfaceType::U16, InterfaceType::U16) => true,
-            (InterfaceType::U16, _) => false,
-            (InterfaceType::U32, InterfaceType::U32) => true,
-            (InterfaceType::U32, _) => false,
-            (InterfaceType::U64, InterfaceType::U64) => true,
-            (InterfaceType::U64, _) => false,
-            (InterfaceType::S8, InterfaceType::S8) => true,
-            (InterfaceType::S8, _) => false,
-            (InterfaceType::S16, InterfaceType::S16) => true,
-            (InterfaceType::S16, _) => false,
-            (InterfaceType::S32, InterfaceType::S32) => true,
-            (InterfaceType::S32, _) => false,
-            (InterfaceType::S64, InterfaceType::S64) => true,
-            (InterfaceType::S64, _) => false,
-            (InterfaceType::Float32, InterfaceType::Float32) => true,
-            (InterfaceType::Float32, _) => false,
-            (InterfaceType::Float64, InterfaceType::Float64) => true,
-            (InterfaceType::Float64, _) => false,
-            (InterfaceType::String, InterfaceType::String) => true,
-            (InterfaceType::String, _) => false,
-            (InterfaceType::Char, InterfaceType::Char) => true,
-            (InterfaceType::Char, _) => false,
-        }
-    }
-
-    fn lists_equal(&self, l1: TypeListIndex, l2: TypeListIndex) -> bool {
-        let a = &self.a_types[l1];
-        let b = &self.b_types[l2];
-        self.interface_types_equal(a.element, b.element)
-    }
-
-    fn resources_equal(&self, o1: TypeResourceTableIndex, o2: TypeResourceTableIndex) -> bool {
-        let a = &self.a_types[o1];
-        let b = &self.b_types[o2];
-        self.a_resource[a.ty] == self.b_resource[b.ty]
-    }
-
-    fn records_equal(&self, r1: TypeRecordIndex, r2: TypeRecordIndex) -> bool {
-        let a = &self.a_types[r1];
-        let b = &self.b_types[r2];
-        if a.fields.len() != b.fields.len() {
-            return false;
-        }
-        a.fields
-            .iter()
-            .zip(b.fields.iter())
-            .all(|(a_field, b_field)| {
-                a_field.name == b_field.name && self.interface_types_equal(a_field.ty, b_field.ty)
-            })
-    }
-
-    fn variants_equal(&self, v1: TypeVariantIndex, v2: TypeVariantIndex) -> bool {
-        let a = &self.a_types[v1];
-        let b = &self.b_types[v2];
-        if a.cases.len() != b.cases.len() {
-            return false;
-        }
-        a.cases.iter().zip(b.cases.iter()).all(|(a_case, b_case)| {
-            if a_case.name != b_case.name {
-                return false;
-            }
-            match (a_case.ty, b_case.ty) {
-                (Some(a_case_ty), Some(b_case_ty)) => {
-                    self.interface_types_equal(a_case_ty, b_case_ty)
-                }
-                (None, None) => true,
-                _ => false,
-            }
-        })
-    }
-
-    fn results_equal(&self, r1: TypeResultIndex, r2: TypeResultIndex) -> bool {
-        let a = &self.a_types[r1];
-        let b = &self.b_types[r2];
-        let oks = match (a.ok, b.ok) {
-            (Some(ok1), Some(ok2)) => self.interface_types_equal(ok1, ok2),
-            (None, None) => true,
-            _ => false,
-        };
-        if !oks {
-            return false;
-        }
-        match (a.err, b.err) {
-            (Some(err1), Some(err2)) => self.interface_types_equal(err1, err2),
-            (None, None) => true,
-            _ => false,
-        }
-    }
-
-    fn options_equal(&self, o1: TypeOptionIndex, o2: TypeOptionIndex) -> bool {
-        let a = &self.a_types[o1];
-        let b = &self.b_types[o2];
-        self.interface_types_equal(a.ty, b.ty)
-    }
-
-    fn enums_equal(&self, e1: TypeEnumIndex, e2: TypeEnumIndex) -> bool {
-        let a = &self.a_types[e1];
-        let b = &self.b_types[e2];
-        a.names == b.names
-    }
-
-    fn tuples_equal(&self, t1: TypeTupleIndex, t2: TypeTupleIndex) -> bool {
-        let a = &self.a_types[t1];
-        let b = &self.b_types[t2];
-        if a.types.len() != b.types.len() {
-            return false;
-        }
-        a.types
-            .iter()
-            .zip(b.types.iter())
-            .all(|(&a, &b)| self.interface_types_equal(a, b))
-    }
-
-    fn flags_equal(&self, f1: TypeFlagsIndex, f2: TypeFlagsIndex) -> bool {
-        let a = &self.a_types[f1];
-        let b = &self.b_types[f2];
-        a.names == b.names
-    }
-}
-
-/// A `list` interface type
-#[derive(Clone, Debug)]
-pub struct List(Handle<TypeListIndex>);
-
-impl PartialEq for List {
-    fn eq(&self, other: &Self) -> bool {
-        self.0.equivalent(&other.0, TypeChecker::lists_equal)
-    }
-}
-
-impl Eq for List {}
-
-impl List {
-    /// Instantiate this type with the specified `values`.
-    pub fn new_val(&self, values: Box<[Val]>) -> Result<Val> {
-        Ok(Val::List(values::List::new(self, values)?))
-    }
-
-    pub(crate) fn from(index: TypeListIndex, ty: &InstanceType<'_>) -> Self {
-        List(Handle::new(index, ty))
-    }
-
-    /// Retreive the element type of this `list`.
-    pub fn ty(&self) -> Type {
-        Type::from(&self.0.types[self.0.index].element, &self.0.instance())
-    }
-}
-
-/// A field declaration belonging to a `record`
-pub struct Field<'a> {
-    /// The name of the field
-    pub name: &'a str,
-    /// The type of the field
-    pub ty: Type,
-}
-
-/// A `record` interface type
-#[derive(Clone, Debug)]
-pub struct Record(Handle<TypeRecordIndex>);
-
-impl Record {
-    /// Instantiate this type with the specified `values`.
-    pub fn new_val<'a>(&self, values: impl IntoIterator<Item = (&'a str, Val)>) -> Result<Val> {
-        Ok(Val::Record(values::Record::new(self, values)?))
-    }
-
-    pub(crate) fn from(index: TypeRecordIndex, ty: &InstanceType<'_>) -> Self {
-        Record(Handle::new(index, ty))
-    }
-
-    /// Retrieve the fields of this `record` in declaration order.
-    pub fn fields(&self) -> impl ExactSizeIterator<Item = Field<'_>> {
-        self.0.types[self.0.index].fields.iter().map(|field| Field {
-            name: &field.name,
-            ty: Type::from(&field.ty, &self.0.instance()),
-        })
-    }
-}
-
-impl PartialEq for Record {
-    fn eq(&self, other: &Self) -> bool {
-        self.0.equivalent(&other.0, TypeChecker::records_equal)
-    }
-}
-
-impl Eq for Record {}
-
-/// A `tuple` interface type
-#[derive(Clone, Debug)]
-pub struct Tuple(Handle<TypeTupleIndex>);
-
-impl Tuple {
-    /// Instantiate this type ith the specified `values`.
-    pub fn new_val(&self, values: Box<[Val]>) -> Result<Val> {
-        Ok(Val::Tuple(values::Tuple::new(self, values)?))
-    }
-
-    pub(crate) fn from(index: TypeTupleIndex, ty: &InstanceType<'_>) -> Self {
-        Tuple(Handle::new(index, ty))
-    }
-
-    /// Retrieve the types of the fields of this `tuple` in declaration order.
-    pub fn types(&self) -> impl ExactSizeIterator<Item = Type> + '_ {
-        self.0.types[self.0.index]
-            .types
-            .iter()
-            .map(|ty| Type::from(ty, &self.0.instance()))
-    }
-}
-
-impl PartialEq for Tuple {
-    fn eq(&self, other: &Self) -> bool {
-        self.0.equivalent(&other.0, TypeChecker::tuples_equal)
-    }
-}
-
-impl Eq for Tuple {}
-
-/// A case declaration belonging to a `variant`
-pub struct Case<'a> {
-    /// The name of the case
-    pub name: &'a str,
-    /// The optional payload type of the case
-    pub ty: Option<Type>,
-}
-
-/// A `variant` interface type
-#[derive(Clone, Debug)]
-pub struct Variant(Handle<TypeVariantIndex>);
-
-impl Variant {
-    /// Instantiate this type with the specified case `name` and `value`.
-    pub fn new_val(&self, name: &str, value: Option<Val>) -> Result<Val> {
-        Ok(Val::Variant(values::Variant::new(self, name, value)?))
-    }
-
-    pub(crate) fn from(index: TypeVariantIndex, ty: &InstanceType<'_>) -> Self {
-        Variant(Handle::new(index, ty))
-    }
-
-    /// Retrieve the cases of this `variant` in declaration order.
-    pub fn cases(&self) -> impl ExactSizeIterator<Item = Case> {
-        self.0.types[self.0.index].cases.iter().map(|case| Case {
-            name: &case.name,
-            ty: case
-                .ty
-                .as_ref()
-                .map(|ty| Type::from(ty, &self.0.instance())),
-        })
-    }
-}
-
-impl PartialEq for Variant {
-    fn eq(&self, other: &Self) -> bool {
-        self.0.equivalent(&other.0, TypeChecker::variants_equal)
-    }
-}
-
-impl Eq for Variant {}
-
-/// An `enum` interface type
-#[derive(Clone, Debug)]
-pub struct Enum(Handle<TypeEnumIndex>);
-
-impl Enum {
-    /// Instantiate this type with the specified case `name`.
-    pub fn new_val(&self, name: &str) -> Result<Val> {
-        Ok(Val::Enum(values::Enum::new(self, name)?))
-    }
-
-    pub(crate) fn from(index: TypeEnumIndex, ty: &InstanceType<'_>) -> Self {
-        Enum(Handle::new(index, ty))
-    }
-
-    /// Retrieve the names of the cases of this `enum` in declaration order.
-    pub fn names(&self) -> impl ExactSizeIterator<Item = &str> {
-        self.0.types[self.0.index]
-            .names
-            .iter()
-            .map(|name| name.deref())
-    }
-}
-
-impl PartialEq for Enum {
-    fn eq(&self, other: &Self) -> bool {
-        self.0.equivalent(&other.0, TypeChecker::enums_equal)
-    }
-}
-
-impl Eq for Enum {}
-
-/// An `option` interface type
-#[derive(Clone, Debug)]
-pub struct OptionType(Handle<TypeOptionIndex>);
-
-impl OptionType {
-    /// Instantiate this type with the specified `value`.
-    pub fn new_val(&self, value: Option<Val>) -> Result<Val> {
-        Ok(Val::Option(values::OptionVal::new(self, value)?))
-    }
-
-    pub(crate) fn from(index: TypeOptionIndex, ty: &InstanceType<'_>) -> Self {
-        OptionType(Handle::new(index, ty))
-    }
-
-    /// Retrieve the type parameter for this `option`.
-    pub fn ty(&self) -> Type {
-        Type::from(&self.0.types[self.0.index].ty, &self.0.instance())
-    }
-}
-
-impl PartialEq for OptionType {
-    fn eq(&self, other: &Self) -> bool {
-        self.0.equivalent(&other.0, TypeChecker::options_equal)
-    }
-}
-
-impl Eq for OptionType {}
-
-/// An `expected` interface type
-#[derive(Clone, Debug)]
-pub struct ResultType(Handle<TypeResultIndex>);
-
-impl ResultType {
-    /// Instantiate this type with the specified `value`.
-    pub fn new_val(&self, value: Result<Option<Val>, Option<Val>>) -> Result<Val> {
-        Ok(Val::Result(values::ResultVal::new(self, value)?))
-    }
-
-    pub(crate) fn from(index: TypeResultIndex, ty: &InstanceType<'_>) -> Self {
-        ResultType(Handle::new(index, ty))
-    }
-
-    /// Retrieve the `ok` type parameter for this `option`.
-    pub fn ok(&self) -> Option<Type> {
-        Some(Type::from(
-            self.0.types[self.0.index].ok.as_ref()?,
-            &self.0.instance(),
-        ))
-    }
-
-    /// Retrieve the `err` type parameter for this `option`.
-    pub fn err(&self) -> Option<Type> {
-        Some(Type::from(
-            self.0.types[self.0.index].err.as_ref()?,
-            &self.0.instance(),
-        ))
-    }
-}
-
-impl PartialEq for ResultType {
-    fn eq(&self, other: &Self) -> bool {
-        self.0.equivalent(&other.0, TypeChecker::results_equal)
-    }
-}
-
-impl Eq for ResultType {}
-
-/// A `flags` interface type
-#[derive(Clone, Debug)]
-pub struct Flags(Handle<TypeFlagsIndex>);
-
-impl Flags {
-    /// Instantiate this type with the specified flag `names`.
-    pub fn new_val(&self, names: &[&str]) -> Result<Val> {
-        Ok(Val::Flags(values::Flags::new(self, names)?))
-    }
-
-    pub(crate) fn from(index: TypeFlagsIndex, ty: &InstanceType<'_>) -> Self {
-        Flags(Handle::new(index, ty))
-    }
-
-    /// Retrieve the names of the flags of this `flags` type in declaration order.
-    pub fn names(&self) -> impl ExactSizeIterator<Item = &str> {
-        self.0.types[self.0.index]
-            .names
-            .iter()
-            .map(|name| name.deref())
-    }
-
-    pub(crate) fn canonical_abi(&self) -> &CanonicalAbiInfo {
-        &self.0.types[self.0.index].abi
-    }
-}
-
-impl PartialEq for Flags {
-    fn eq(&self, other: &Self) -> bool {
-        self.0.equivalent(&other.0, TypeChecker::flags_equal)
-    }
-}
-
-impl Eq for Flags {}
-
-/// Represents a component model interface type
-#[derive(Clone, PartialEq, Eq, Debug)]
-#[allow(missing_docs)]
-pub enum Type {
-    Bool,
-    S8,
-    U8,
-    S16,
-    U16,
-    S32,
-    U32,
-    S64,
-    U64,
-    Float32,
-    Float64,
-    Char,
-    String,
-    List(List),
-    Record(Record),
-    Tuple(Tuple),
-    Variant(Variant),
-    Enum(Enum),
-    Option(OptionType),
-    Result(ResultType),
-    Flags(Flags),
-    Own(ResourceType),
-    Borrow(ResourceType),
-}
-
-impl Type {
-    /// Retrieve the inner [`List`] of a [`Type::List`].
-    ///
-    /// # Panics
-    ///
-    /// This will panic if `self` is not a [`Type::List`].
-    pub fn unwrap_list(&self) -> &List {
-        if let Type::List(handle) = self {
-            &handle
-        } else {
-            panic!("attempted to unwrap a {} as a list", self.desc())
-        }
-    }
-
-    /// Retrieve the inner [`Record`] of a [`Type::Record`].
-    ///
-    /// # Panics
-    ///
-    /// This will panic if `self` is not a [`Type::Record`].
-    pub fn unwrap_record(&self) -> &Record {
-        if let Type::Record(handle) = self {
-            &handle
-        } else {
-            panic!("attempted to unwrap a {} as a record", self.desc())
-        }
-    }
-
-    /// Retrieve the inner [`Tuple`] of a [`Type::Tuple`].
-    ///
-    /// # Panics
-    ///
-    /// This will panic if `self` is not a [`Type::Tuple`].
-    pub fn unwrap_tuple(&self) -> &Tuple {
-        if let Type::Tuple(handle) = self {
-            &handle
-        } else {
-            panic!("attempted to unwrap a {} as a tuple", self.desc())
-        }
-    }
-
-    /// Retrieve the inner [`Variant`] of a [`Type::Variant`].
-    ///
-    /// # Panics
-    ///
-    /// This will panic if `self` is not a [`Type::Variant`].
-    pub fn unwrap_variant(&self) -> &Variant {
-        if let Type::Variant(handle) = self {
-            &handle
-        } else {
-            panic!("attempted to unwrap a {} as a variant", self.desc())
-        }
-    }
-
-    /// Retrieve the inner [`Enum`] of a [`Type::Enum`].
-    ///
-    /// # Panics
-    ///
-    /// This will panic if `self` is not a [`Type::Enum`].
-    pub fn unwrap_enum(&self) -> &Enum {
-        if let Type::Enum(handle) = self {
-            &handle
-        } else {
-            panic!("attempted to unwrap a {} as a enum", self.desc())
-        }
-    }
-
-    /// Retrieve the inner [`OptionType`] of a [`Type::Option`].
-    ///
-    /// # Panics
-    ///
-    /// This will panic if `self` is not a [`Type::Option`].
-    pub fn unwrap_option(&self) -> &OptionType {
-        if let Type::Option(handle) = self {
-            &handle
-        } else {
-            panic!("attempted to unwrap a {} as a option", self.desc())
-        }
-    }
-
-    /// Retrieve the inner [`ResultType`] of a [`Type::Result`].
-    ///
-    /// # Panics
-    ///
-    /// This will panic if `self` is not a [`Type::Result`].
-    pub fn unwrap_result(&self) -> &ResultType {
-        if let Type::Result(handle) = self {
-            &handle
-        } else {
-            panic!("attempted to unwrap a {} as a result", self.desc())
-        }
-    }
-
-    /// Retrieve the inner [`Flags`] of a [`Type::Flags`].
-    ///
-    /// # Panics
-    ///
-    /// This will panic if `self` is not a [`Type::Flags`].
-    pub fn unwrap_flags(&self) -> &Flags {
-        if let Type::Flags(handle) = self {
-            &handle
-        } else {
-            panic!("attempted to unwrap a {} as a flags", self.desc())
-        }
-    }
-
-    /// Retrieve the inner [`ResourceType`] of a [`Type::Own`].
-    ///
-    /// # Panics
-    ///
-    /// This will panic if `self` is not a [`Type::Own`].
-    pub fn unwrap_own(&self) -> &ResourceType {
-        match self {
-            Type::Own(ty) => ty,
-            _ => panic!("attempted to unwrap a {} as a own", self.desc()),
-        }
-    }
-
-    /// Retrieve the inner [`ResourceType`] of a [`Type::Borrow`].
-    ///
-    /// # Panics
-    ///
-    /// This will panic if `self` is not a [`Type::Borrow`].
-    pub fn unwrap_borrow(&self) -> &ResourceType {
-        match self {
-            Type::Borrow(ty) => ty,
-            _ => panic!("attempted to unwrap a {} as a own", self.desc()),
-        }
-    }
-
-    pub(crate) fn check(&self, value: &Val) -> Result<()> {
-        let other = &value.ty();
-        if self == other {
-            Ok(())
-        } else if mem::discriminant(self) != mem::discriminant(other) {
-            Err(anyhow!(
-                "type mismatch: expected {}, got {}",
-                self.desc(),
-                other.desc()
-            ))
-        } else {
-            Err(anyhow!(
-                "type mismatch for {}, possibly due to mixing distinct composite types",
-                self.desc()
-            ))
-        }
-    }
-
-    /// Convert the specified `InterfaceType` to a `Type`.
-    pub(crate) fn from(ty: &InterfaceType, instance: &InstanceType<'_>) -> Self {
-        match ty {
-            InterfaceType::Bool => Type::Bool,
-            InterfaceType::S8 => Type::S8,
-            InterfaceType::U8 => Type::U8,
-            InterfaceType::S16 => Type::S16,
-            InterfaceType::U16 => Type::U16,
-            InterfaceType::S32 => Type::S32,
-            InterfaceType::U32 => Type::U32,
-            InterfaceType::S64 => Type::S64,
-            InterfaceType::U64 => Type::U64,
-            InterfaceType::Float32 => Type::Float32,
-            InterfaceType::Float64 => Type::Float64,
-            InterfaceType::Char => Type::Char,
-            InterfaceType::String => Type::String,
-            InterfaceType::List(index) => Type::List(List::from(*index, instance)),
-            InterfaceType::Record(index) => Type::Record(Record::from(*index, instance)),
-            InterfaceType::Tuple(index) => Type::Tuple(Tuple::from(*index, instance)),
-            InterfaceType::Variant(index) => Type::Variant(Variant::from(*index, instance)),
-            InterfaceType::Enum(index) => Type::Enum(Enum::from(*index, instance)),
-            InterfaceType::Option(index) => Type::Option(OptionType::from(*index, instance)),
-            InterfaceType::Result(index) => Type::Result(ResultType::from(*index, instance)),
-            InterfaceType::Flags(index) => Type::Flags(Flags::from(*index, instance)),
-            InterfaceType::Own(index) => Type::Own(instance.resource_type(*index)),
-            InterfaceType::Borrow(index) => Type::Borrow(instance.resource_type(*index)),
-        }
-    }
-
-    fn desc(&self) -> &'static str {
-        match self {
-            Type::Bool => "bool",
-            Type::S8 => "s8",
-            Type::U8 => "u8",
-            Type::S16 => "s16",
-            Type::U16 => "u16",
-            Type::S32 => "s32",
-            Type::U32 => "u32",
-            Type::S64 => "s64",
-            Type::U64 => "u64",
-            Type::Float32 => "float32",
-            Type::Float64 => "float64",
-            Type::Char => "char",
-            Type::String => "string",
-            Type::List(_) => "list",
-            Type::Record(_) => "record",
-            Type::Tuple(_) => "tuple",
-            Type::Variant(_) => "variant",
-            Type::Enum(_) => "enum",
-            Type::Option(_) => "option",
-            Type::Result(_) => "result",
-            Type::Flags(_) => "flags",
-            Type::Own(_) => "own",
-            Type::Borrow(_) => "borrow",
-        }
-    }
-}
diff --git a/crates/wasmtime/src/component/values.rs b/crates/wasmtime/src/component/values.rs
deleted file mode 100644
index 332a0659a875..000000000000
--- a/crates/wasmtime/src/component/values.rs
+++ /dev/null
@@ -1,1272 +0,0 @@
-use crate::component::func::{bad_type_info, Lift, LiftContext, Lower, LowerContext};
-use crate::component::types::{self, Type};
-use crate::component::ResourceAny;
-use crate::ValRaw;
-use anyhow::{anyhow, bail, Context, Error, Result};
-use std::collections::HashMap;
-use std::fmt;
-use std::iter;
-use std::mem::MaybeUninit;
-use std::ops::Deref;
-use wasmtime_component_util::{DiscriminantSize, FlagsSize};
-use wasmtime_environ::component::{
-    CanonicalAbiInfo, ComponentTypes, InterfaceType, TypeListIndex, VariantInfo,
-};
-
-/// Represents runtime list values
-#[derive(PartialEq, Eq, Clone)]
-pub struct List {
-    ty: types::List,
-    values: Box<[Val]>,
-}
-
-impl List {
-    /// Instantiate the specified type with the specified `values`.
-    pub fn new(ty: &types::List, values: Box<[Val]>) -> Result<Self> {
-        let element_type = ty.ty();
-        for (index, value) in values.iter().enumerate() {
-            element_type
-                .check(value)
-                .with_context(|| format!("type mismatch for element {index} of list"))?;
-        }
-
-        Ok(Self {
-            ty: ty.clone(),
-            values,
-        })
-    }
-
-    /// Returns the corresponding type of this list
-    pub fn ty(&self) -> &types::List {
-        &self.ty
-    }
-}
-
-impl Deref for List {
-    type Target = [Val];
-
-    fn deref(&self) -> &[Val] {
-        &self.values
-    }
-}
-
-impl fmt::Debug for List {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut f = f.debug_list();
-        for val in self.iter() {
-            f.entry(val);
-        }
-        f.finish()
-    }
-}
-
-/// Represents runtime record values
-#[derive(PartialEq, Eq, Clone)]
-pub struct Record {
-    ty: types::Record,
-    values: Box<[Val]>,
-}
-
-impl Record {
-    /// Instantiate the specified type with the specified `values`.
-    pub fn new<'a>(
-        ty: &types::Record,
-        values: impl IntoIterator<Item = (&'a str, Val)>,
-    ) -> Result<Self> {
-        let mut fields = ty.fields();
-        let expected_len = fields.len();
-        let mut iter = values.into_iter();
-        let mut values = Vec::with_capacity(expected_len);
-        loop {
-            match (fields.next(), iter.next()) {
-                (Some(field), Some((name, value))) => {
-                    if name == field.name {
-                        field
-                            .ty
-                            .check(&value)
-                            .with_context(|| format!("type mismatch for field {name} of record"))?;
-
-                        values.push(value);
-                    } else {
-                        bail!("field name mismatch: expected {}; got {name}", field.name)
-                    }
-                }
-                (None, Some((_, value))) => values.push(value),
-                _ => break,
-            }
-        }
-
-        if values.len() != expected_len {
-            bail!("expected {} value(s); got {}", expected_len, values.len());
-        }
-
-        Ok(Self {
-            ty: ty.clone(),
-            values: values.into(),
-        })
-    }
-
-    /// Returns the corresponding type of this record.
-    pub fn ty(&self) -> &types::Record {
-        &self.ty
-    }
-
-    /// Gets the value of the specified field `name` from this record.
-    pub fn fields(&self) -> impl Iterator<Item = (&str, &Val)> {
-        assert_eq!(self.values.len(), self.ty.fields().len());
-        self.ty
-            .fields()
-            .zip(self.values.iter())
-            .map(|(ty, val)| (ty.name, val))
-    }
-}
-
-impl fmt::Debug for Record {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut f = f.debug_struct("Record");
-        for (name, val) in self.fields() {
-            f.field(name, val);
-        }
-        f.finish()
-    }
-}
-
-/// Represents runtime tuple values
-#[derive(PartialEq, Eq, Clone)]
-pub struct Tuple {
-    ty: types::Tuple,
-    values: Box<[Val]>,
-}
-
-impl Tuple {
-    /// Instantiate the specified type ith the specified `values`.
-    pub fn new(ty: &types::Tuple, values: Box<[Val]>) -> Result<Self> {
-        if values.len() != ty.types().len() {
-            bail!(
-                "expected {} value(s); got {}",
-                ty.types().len(),
-                values.len()
-            );
-        }
-
-        for (index, (value, ty)) in values.iter().zip(ty.types()).enumerate() {
-            ty.check(value)
-                .with_context(|| format!("type mismatch for field {index} of tuple"))?;
-        }
-
-        Ok(Self {
-            ty: ty.clone(),
-            values,
-        })
-    }
-
-    /// Returns the type of this tuple.
-    pub fn ty(&self) -> &types::Tuple {
-        &self.ty
-    }
-
-    /// Returns the list of values that this tuple contains.
-    pub fn values(&self) -> &[Val] {
-        &self.values
-    }
-}
-
-impl fmt::Debug for Tuple {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut tuple = f.debug_tuple("");
-        for val in self.values() {
-            tuple.field(val);
-        }
-        tuple.finish()
-    }
-}
-
-/// Represents runtime variant values
-#[derive(PartialEq, Eq, Clone)]
-pub struct Variant {
-    ty: types::Variant,
-    discriminant: u32,
-    value: Option<Box<Val>>,
-}
-
-impl Variant {
-    /// Instantiate the specified type with the specified case `name` and `value`.
-    pub fn new(ty: &types::Variant, name: &str, value: Option<Val>) -> Result<Self> {
-        let (discriminant, case_type) = ty
-            .cases()
-            .enumerate()
-            .find_map(|(index, case)| {
-                if case.name == name {
-                    Some((index, case.ty))
-                } else {
-                    None
-                }
-            })
-            .ok_or_else(|| anyhow!("unknown variant case: {name}"))?;
-
-        typecheck_payload(name, case_type.as_ref(), value.as_ref())?;
-
-        Ok(Self {
-            ty: ty.clone(),
-            discriminant: u32::try_from(discriminant)?,
-            value: value.map(Box::new),
-        })
-    }
-
-    /// Returns the type of this variant.
-    pub fn ty(&self) -> &types::Variant {
-        &self.ty
-    }
-
-    /// Returns name of the discriminant of this value within the variant type.
-    pub fn discriminant(&self) -> &str {
-        self.ty
-            .cases()
-            .nth(self.discriminant as usize)
-            .unwrap()
-            .name
-    }
-
-    /// Returns the payload value for this variant.
-    pub fn payload(&self) -> Option<&Val> {
-        self.value.as_deref()
-    }
-
-    fn as_generic<'a>(
-        &'a self,
-        types: &'a ComponentTypes,
-        ty: InterfaceType,
-    ) -> GenericVariant<'a> {
-        let ty = match ty {
-            InterfaceType::Variant(i) => &types[i],
-            _ => bad_type_info(),
-        };
-        GenericVariant {
-            discriminant: self.discriminant,
-            abi: &ty.abi,
-            info: &ty.info,
-            payload: self
-                .value
-                .as_deref()
-                .zip(ty.cases[self.discriminant as usize].ty),
-        }
-    }
-}
-
-fn typecheck_payload(name: &str, case_type: Option<&Type>, value: Option<&Val>) -> Result<()> {
-    match (case_type, value) {
-        (Some(expected), Some(actual)) => expected
-            .check(&actual)
-            .with_context(|| format!("type mismatch for case {name} of variant")),
-        (None, None) => Ok(()),
-        (Some(_), None) => bail!("expected a payload for case `{name}`"),
-        (None, Some(_)) => bail!("did not expect payload for case `{name}`"),
-    }
-}
-
-impl fmt::Debug for Variant {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_tuple(self.discriminant())
-            .field(&self.payload())
-            .finish()
-    }
-}
-
-/// Represents runtime enum values
-#[derive(PartialEq, Eq, Clone)]
-pub struct Enum {
-    ty: types::Enum,
-    discriminant: u32,
-}
-
-impl Enum {
-    /// Instantiate the specified type with the specified case `name`.
-    pub fn new(ty: &types::Enum, name: &str) -> Result<Self> {
-        let discriminant = u32::try_from(
-            ty.names()
-                .position(|n| n == name)
-                .ok_or_else(|| anyhow!("unknown enum case: {name}"))?,
-        )?;
-
-        Ok(Self {
-            ty: ty.clone(),
-            discriminant,
-        })
-    }
-
-    /// Returns the type of this value.
-    pub fn ty(&self) -> &types::Enum {
-        &self.ty
-    }
-
-    /// Returns name of this enum value.
-    pub fn discriminant(&self) -> &str {
-        self.ty.names().nth(self.discriminant as usize).unwrap()
-    }
-
-    fn as_generic<'a>(
-        &'a self,
-        types: &'a ComponentTypes,
-        ty: InterfaceType,
-    ) -> GenericVariant<'a> {
-        let ty = match ty {
-            InterfaceType::Enum(i) => &types[i],
-            _ => bad_type_info(),
-        };
-        GenericVariant {
-            discriminant: self.discriminant,
-            abi: &ty.abi,
-            info: &ty.info,
-            payload: None,
-        }
-    }
-}
-
-impl fmt::Debug for Enum {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Display::fmt(&self.discriminant(), f)
-    }
-}
-
-/// Represents runtime option values
-#[derive(PartialEq, Eq, Clone)]
-pub struct OptionVal {
-    ty: types::OptionType,
-    discriminant: u32,
-    value: Option<Box<Val>>,
-}
-
-impl OptionVal {
-    /// Instantiate the specified type with the specified `value`.
-    pub fn new(ty: &types::OptionType, value: Option<Val>) -> Result<Self> {
-        let value = value
-            .map(|value| {
-                ty.ty().check(&value).context("type mismatch for option")?;
-
-                Ok::<_, Error>(value)
-            })
-            .transpose()?;
-
-        Ok(Self {
-            ty: ty.clone(),
-            discriminant: if value.is_none() { 0 } else { 1 },
-            value: value.map(Box::new),
-        })
-    }
-
-    /// Returns the type of this value.
-    pub fn ty(&self) -> &types::OptionType {
-        &self.ty
-    }
-
-    /// Returns the optional value contained within.
-    pub fn value(&self) -> Option<&Val> {
-        self.value.as_deref()
-    }
-
-    fn as_generic<'a>(
-        &'a self,
-        types: &'a ComponentTypes,
-        ty: InterfaceType,
-    ) -> GenericVariant<'a> {
-        let ty = match ty {
-            InterfaceType::Option(i) => &types[i],
-            _ => bad_type_info(),
-        };
-        GenericVariant {
-            discriminant: self.discriminant,
-            abi: &ty.abi,
-            info: &ty.info,
-            payload: self.value.as_deref().zip(Some(ty.ty)),
-        }
-    }
-}
-
-impl fmt::Debug for OptionVal {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.value().fmt(f)
-    }
-}
-
-/// Represents runtime result values
-#[derive(PartialEq, Eq, Clone)]
-pub struct ResultVal {
-    ty: types::ResultType,
-    discriminant: u32,
-    value: Option<Box<Val>>,
-}
-
-impl ResultVal {
-    /// Instantiate the specified type with the specified `value`.
-    pub fn new(ty: &types::ResultType, value: Result<Option<Val>, Option<Val>>) -> Result<Self> {
-        Ok(Self {
-            ty: ty.clone(),
-            discriminant: if value.is_ok() { 0 } else { 1 },
-            value: match value {
-                Ok(value) => {
-                    typecheck_payload("ok", ty.ok().as_ref(), value.as_ref())?;
-                    value.map(Box::new)
-                }
-                Err(value) => {
-                    typecheck_payload("err", ty.err().as_ref(), value.as_ref())?;
-                    value.map(Box::new)
-                }
-            },
-        })
-    }
-
-    /// Returns the type of this value.
-    pub fn ty(&self) -> &types::ResultType {
-        &self.ty
-    }
-
-    /// Returns the result value contained within.
-    pub fn value(&self) -> Result<Option<&Val>, Option<&Val>> {
-        if self.discriminant == 0 {
-            Ok(self.value.as_deref())
-        } else {
-            Err(self.value.as_deref())
-        }
-    }
-
-    fn as_generic<'a>(
-        &'a self,
-        types: &'a ComponentTypes,
-        ty: InterfaceType,
-    ) -> GenericVariant<'a> {
-        let ty = match ty {
-            InterfaceType::Result(i) => &types[i],
-            _ => bad_type_info(),
-        };
-        GenericVariant {
-            discriminant: self.discriminant,
-            abi: &ty.abi,
-            info: &ty.info,
-            payload: self.value.as_deref().zip(if self.discriminant == 0 {
-                ty.ok
-            } else {
-                ty.err
-            }),
-        }
-    }
-}
-
-impl fmt::Debug for ResultVal {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.value().fmt(f)
-    }
-}
-
-/// Represents runtime flag values
-#[derive(PartialEq, Eq, Clone)]
-pub struct Flags {
-    ty: types::Flags,
-    count: u32,
-    value: Box<[u32]>,
-}
-
-impl Flags {
-    /// Instantiate the specified type with the specified flag `names`.
-    pub fn new(ty: &types::Flags, names: &[&str]) -> Result<Self> {
-        let map = ty
-            .names()
-            .enumerate()
-            .map(|(index, name)| (name, index))
-            .collect::<HashMap<_, _>>();
-
-        let count = usize::from(ty.canonical_abi().flat_count.unwrap());
-        let mut values = vec![0_u32; count];
-
-        for name in names {
-            let index = map
-                .get(name)
-                .ok_or_else(|| anyhow!("unknown flag: {name}"))?;
-            values[index / 32] |= 1 << (index % 32);
-        }
-
-        Ok(Self {
-            ty: ty.clone(),
-            count: u32::try_from(map.len())?,
-            value: values.into(),
-        })
-    }
-
-    /// Returns the type of this value.
-    pub fn ty(&self) -> &types::Flags {
-        &self.ty
-    }
-
-    /// Returns an iterator over the set of names that this flags set contains.
-    pub fn flags(&self) -> impl Iterator<Item = &str> {
-        (0..self.count).filter_map(|i| {
-            let (idx, bit) = ((i / 32) as usize, i % 32);
-            if self.value[idx] & (1 << bit) != 0 {
-                Some(self.ty.names().nth(i as usize).unwrap())
-            } else {
-                None
-            }
-        })
-    }
-}
-
-impl fmt::Debug for Flags {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut set = f.debug_set();
-        for flag in self.flags() {
-            set.entry(&flag);
-        }
-        set.finish()
-    }
-}
-
-/// Represents possible runtime values which a component function can either
-/// consume or produce
-///
-/// This is a dynamic representation of possible values in the component model.
-/// Note that this is not an efficient representation but is instead intended to
-/// be a flexible and somewhat convenient representation. The most efficient
-/// representation of component model types is to use the `bindgen!` macro to
-/// generate native Rust types with specialized liftings and lowerings.
-///
-/// This type is used in conjunction with [`Func::call`] for example if the
-/// signature of a component is not statically known ahead of time.
-///
-/// # Notes on Equality
-///
-/// This type implements both the Rust `PartialEq` and `Eq` traits. This type
-/// additionally contains values which are not necessarily easily equated,
-/// however, such as floats (`Float32` and `Float64`) and resources. Equality
-/// does require that two values have the same type, and then these cases are
-/// handled as:
-///
-/// * Floats are tested if they are "semantically the same" meaning all NaN
-///   values are equal to all other NaN values. Additionally zero values must be
-///   exactly the same, so positive zero is not equal to negative zero. The
-///   primary use case at this time is fuzzing-related equality which this is
-///   sufficient for.
-///
-/// * Resources are tested if their types and indices into the host table are
-///   equal. This does not compare the underlying representation so borrows of
-///   the same guest resource are not considered equal. This additionally
-///   doesn't go further and test for equality in the guest itself (for example
-///   two different heap allocations of `Box<u32>` can be equal in normal Rust
-///   if they contain the same value, but will never be considered equal when
-///   compared as `Val::Resource`s).
-///
-/// In general if a strict guarantee about equality is required here it's
-/// recommended to "build your own" as this equality intended for fuzzing
-/// Wasmtime may not be suitable for you.
-///
-/// [`Func::call`]: crate::component::Func::call
-#[derive(Debug, Clone)]
-#[allow(missing_docs)]
-pub enum Val {
-    Bool(bool),
-    S8(i8),
-    U8(u8),
-    S16(i16),
-    U16(u16),
-    S32(i32),
-    U32(u32),
-    S64(i64),
-    U64(u64),
-    Float32(f32),
-    Float64(f64),
-    Char(char),
-    String(Box<str>),
-    List(List),
-    Record(Record),
-    Tuple(Tuple),
-    Variant(Variant),
-    Enum(Enum),
-    Option(OptionVal),
-    Result(ResultVal),
-    Flags(Flags),
-    Resource(ResourceAny),
-}
-
-impl Val {
-    /// Retrieve the [`Type`] of this value.
-    pub fn ty(&self) -> Type {
-        match self {
-            Val::Bool(_) => Type::Bool,
-            Val::S8(_) => Type::S8,
-            Val::U8(_) => Type::U8,
-            Val::S16(_) => Type::S16,
-            Val::U16(_) => Type::U16,
-            Val::S32(_) => Type::S32,
-            Val::U32(_) => Type::U32,
-            Val::S64(_) => Type::S64,
-            Val::U64(_) => Type::U64,
-            Val::Float32(_) => Type::Float32,
-            Val::Float64(_) => Type::Float64,
-            Val::Char(_) => Type::Char,
-            Val::String(_) => Type::String,
-            Val::List(List { ty, .. }) => Type::List(ty.clone()),
-            Val::Record(Record { ty, .. }) => Type::Record(ty.clone()),
-            Val::Tuple(Tuple { ty, .. }) => Type::Tuple(ty.clone()),
-            Val::Variant(Variant { ty, .. }) => Type::Variant(ty.clone()),
-            Val::Enum(Enum { ty, .. }) => Type::Enum(ty.clone()),
-            Val::Option(OptionVal { ty, .. }) => Type::Option(ty.clone()),
-            Val::Result(ResultVal { ty, .. }) => Type::Result(ty.clone()),
-            Val::Flags(Flags { ty, .. }) => Type::Flags(ty.clone()),
-            Val::Resource(r) => {
-                if r.owned() {
-                    Type::Own(r.ty())
-                } else {
-                    Type::Borrow(r.ty())
-                }
-            }
-        }
-    }
-
-    /// Deserialize a value of this type from core Wasm stack values.
-    pub(crate) fn lift(
-        cx: &mut LiftContext<'_>,
-        ty: InterfaceType,
-        src: &mut std::slice::Iter<'_, ValRaw>,
-    ) -> Result<Val> {
-        Ok(match ty {
-            InterfaceType::Bool => Val::Bool(bool::lift(cx, ty, next(src))?),
-            InterfaceType::S8 => Val::S8(i8::lift(cx, ty, next(src))?),
-            InterfaceType::U8 => Val::U8(u8::lift(cx, ty, next(src))?),
-            InterfaceType::S16 => Val::S16(i16::lift(cx, ty, next(src))?),
-            InterfaceType::U16 => Val::U16(u16::lift(cx, ty, next(src))?),
-            InterfaceType::S32 => Val::S32(i32::lift(cx, ty, next(src))?),
-            InterfaceType::U32 => Val::U32(u32::lift(cx, ty, next(src))?),
-            InterfaceType::S64 => Val::S64(i64::lift(cx, ty, next(src))?),
-            InterfaceType::U64 => Val::U64(u64::lift(cx, ty, next(src))?),
-            InterfaceType::Float32 => Val::Float32(f32::lift(cx, ty, next(src))?),
-            InterfaceType::Float64 => Val::Float64(f64::lift(cx, ty, next(src))?),
-            InterfaceType::Char => Val::Char(char::lift(cx, ty, next(src))?),
-            InterfaceType::Own(_) | InterfaceType::Borrow(_) => {
-                Val::Resource(ResourceAny::lift(cx, ty, next(src))?)
-            }
-            InterfaceType::String => {
-                Val::String(Box::<str>::lift(cx, ty, &[*next(src), *next(src)])?)
-            }
-            InterfaceType::List(i) => {
-                // FIXME: needs memory64 treatment
-                let ptr = u32::lift(cx, InterfaceType::U32, next(src))? as usize;
-                let len = u32::lift(cx, InterfaceType::U32, next(src))? as usize;
-                load_list(cx, i, ptr, len)?
-            }
-            InterfaceType::Record(i) => Val::Record(Record {
-                ty: types::Record::from(i, &cx.instance_type()),
-                values: cx.types[i]
-                    .fields
-                    .iter()
-                    .map(|field| Self::lift(cx, field.ty, src))
-                    .collect::<Result<_>>()?,
-            }),
-            InterfaceType::Tuple(i) => Val::Tuple(Tuple {
-                ty: types::Tuple::from(i, &cx.instance_type()),
-                values: cx.types[i]
-                    .types
-                    .iter()
-                    .map(|ty| Self::lift(cx, *ty, src))
-                    .collect::<Result<_>>()?,
-            }),
-            InterfaceType::Variant(i) => {
-                let (discriminant, value) = lift_variant(
-                    cx,
-                    cx.types.canonical_abi(&ty).flat_count(usize::MAX).unwrap(),
-                    cx.types[i].cases.iter().map(|case| case.ty),
-                    src,
-                )?;
-
-                Val::Variant(Variant {
-                    ty: types::Variant::from(i, &cx.instance_type()),
-                    discriminant,
-                    value,
-                })
-            }
-            InterfaceType::Enum(i) => {
-                let (discriminant, _) = lift_variant(
-                    cx,
-                    cx.types.canonical_abi(&ty).flat_count(usize::MAX).unwrap(),
-                    cx.types[i].names.iter().map(|_| None),
-                    src,
-                )?;
-
-                Val::Enum(Enum {
-                    ty: types::Enum::from(i, &cx.instance_type()),
-                    discriminant,
-                })
-            }
-            InterfaceType::Option(i) => {
-                let (discriminant, value) = lift_variant(
-                    cx,
-                    cx.types.canonical_abi(&ty).flat_count(usize::MAX).unwrap(),
-                    [None, Some(cx.types[i].ty)].into_iter(),
-                    src,
-                )?;
-
-                Val::Option(OptionVal {
-                    ty: types::OptionType::from(i, &cx.instance_type()),
-                    discriminant,
-                    value,
-                })
-            }
-            InterfaceType::Result(i) => {
-                let result_ty = &cx.types[i];
-                let (discriminant, value) = lift_variant(
-                    cx,
-                    cx.types.canonical_abi(&ty).flat_count(usize::MAX).unwrap(),
-                    [result_ty.ok, result_ty.err].into_iter(),
-                    src,
-                )?;
-
-                Val::Result(ResultVal {
-                    ty: types::ResultType::from(i, &cx.instance_type()),
-                    discriminant,
-                    value,
-                })
-            }
-            InterfaceType::Flags(i) => {
-                let count = u32::try_from(cx.types[i].names.len()).unwrap();
-                let u32_count = cx.types.canonical_abi(&ty).flat_count(usize::MAX).unwrap();
-                let value = iter::repeat_with(|| u32::lift(cx, InterfaceType::U32, next(src)))
-                    .take(u32_count)
-                    .collect::<Result<_>>()?;
-
-                Val::Flags(Flags {
-                    ty: types::Flags::from(i, &cx.instance_type()),
-                    count,
-                    value,
-                })
-            }
-        })
-    }
-
-    /// Deserialize a value of this type from the heap.
-    pub(crate) fn load(cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Val> {
-        Ok(match ty {
-            InterfaceType::Bool => Val::Bool(bool::load(cx, ty, bytes)?),
-            InterfaceType::S8 => Val::S8(i8::load(cx, ty, bytes)?),
-            InterfaceType::U8 => Val::U8(u8::load(cx, ty, bytes)?),
-            InterfaceType::S16 => Val::S16(i16::load(cx, ty, bytes)?),
-            InterfaceType::U16 => Val::U16(u16::load(cx, ty, bytes)?),
-            InterfaceType::S32 => Val::S32(i32::load(cx, ty, bytes)?),
-            InterfaceType::U32 => Val::U32(u32::load(cx, ty, bytes)?),
-            InterfaceType::S64 => Val::S64(i64::load(cx, ty, bytes)?),
-            InterfaceType::U64 => Val::U64(u64::load(cx, ty, bytes)?),
-            InterfaceType::Float32 => Val::Float32(f32::load(cx, ty, bytes)?),
-            InterfaceType::Float64 => Val::Float64(f64::load(cx, ty, bytes)?),
-            InterfaceType::Char => Val::Char(char::load(cx, ty, bytes)?),
-            InterfaceType::String => Val::String(<Box<str>>::load(cx, ty, bytes)?),
-            InterfaceType::Own(_) | InterfaceType::Borrow(_) => {
-                Val::Resource(ResourceAny::load(cx, ty, bytes)?)
-            }
-            InterfaceType::List(i) => {
-                // FIXME: needs memory64 treatment
-                let ptr = u32::from_le_bytes(bytes[..4].try_into().unwrap()) as usize;
-                let len = u32::from_le_bytes(bytes[4..].try_into().unwrap()) as usize;
-                load_list(cx, i, ptr, len)?
-            }
-
-            InterfaceType::Record(i) => Val::Record(Record {
-                ty: types::Record::from(i, &cx.instance_type()),
-                values: load_record(cx, cx.types[i].fields.iter().map(|field| field.ty), bytes)?,
-            }),
-            InterfaceType::Tuple(i) => Val::Tuple(Tuple {
-                ty: types::Tuple::from(i, &cx.instance_type()),
-                values: load_record(cx, cx.types[i].types.iter().copied(), bytes)?,
-            }),
-            InterfaceType::Variant(i) => {
-                let ty = &cx.types[i];
-                let (discriminant, value) =
-                    load_variant(cx, &ty.info, ty.cases.iter().map(|case| case.ty), bytes)?;
-
-                Val::Variant(Variant {
-                    ty: types::Variant::from(i, &cx.instance_type()),
-                    discriminant,
-                    value,
-                })
-            }
-            InterfaceType::Enum(i) => {
-                let ty = &cx.types[i];
-                let (discriminant, _) =
-                    load_variant(cx, &ty.info, ty.names.iter().map(|_| None), bytes)?;
-
-                Val::Enum(Enum {
-                    ty: types::Enum::from(i, &cx.instance_type()),
-                    discriminant,
-                })
-            }
-            InterfaceType::Option(i) => {
-                let ty = &cx.types[i];
-                let (discriminant, value) =
-                    load_variant(cx, &ty.info, [None, Some(ty.ty)].into_iter(), bytes)?;
-
-                Val::Option(OptionVal {
-                    ty: types::OptionType::from(i, &cx.instance_type()),
-                    discriminant,
-                    value,
-                })
-            }
-            InterfaceType::Result(i) => {
-                let ty = &cx.types[i];
-                let (discriminant, value) =
-                    load_variant(cx, &ty.info, [ty.ok, ty.err].into_iter(), bytes)?;
-
-                Val::Result(ResultVal {
-                    ty: types::ResultType::from(i, &cx.instance_type()),
-                    discriminant,
-                    value,
-                })
-            }
-            InterfaceType::Flags(i) => Val::Flags(Flags {
-                ty: types::Flags::from(i, &cx.instance_type()),
-                count: u32::try_from(cx.types[i].names.len())?,
-                value: match FlagsSize::from_count(cx.types[i].names.len()) {
-                    FlagsSize::Size0 => Box::new([]),
-                    FlagsSize::Size1 => {
-                        iter::once(u8::load(cx, InterfaceType::U8, bytes)?.into()).collect()
-                    }
-                    FlagsSize::Size2 => {
-                        iter::once(u16::load(cx, InterfaceType::U16, bytes)?.into()).collect()
-                    }
-                    FlagsSize::Size4Plus(n) => (0..n)
-                        .map(|index| {
-                            u32::load(
-                                cx,
-                                InterfaceType::U32,
-                                &bytes[usize::from(index) * 4..][..4],
-                            )
-                        })
-                        .collect::<Result<_>>()?,
-                },
-            }),
-        })
-    }
-
-    /// Serialize this value as core Wasm stack values.
-    pub(crate) fn lower<T>(
-        &self,
-        cx: &mut LowerContext<'_, T>,
-        ty: InterfaceType,
-        dst: &mut std::slice::IterMut<'_, MaybeUninit<ValRaw>>,
-    ) -> Result<()> {
-        match self {
-            Val::Bool(value) => value.lower(cx, ty, next_mut(dst))?,
-            Val::S8(value) => value.lower(cx, ty, next_mut(dst))?,
-            Val::U8(value) => value.lower(cx, ty, next_mut(dst))?,
-            Val::S16(value) => value.lower(cx, ty, next_mut(dst))?,
-            Val::U16(value) => value.lower(cx, ty, next_mut(dst))?,
-            Val::S32(value) => value.lower(cx, ty, next_mut(dst))?,
-            Val::U32(value) => value.lower(cx, ty, next_mut(dst))?,
-            Val::S64(value) => value.lower(cx, ty, next_mut(dst))?,
-            Val::U64(value) => value.lower(cx, ty, next_mut(dst))?,
-            Val::Float32(value) => value.lower(cx, ty, next_mut(dst))?,
-            Val::Float64(value) => value.lower(cx, ty, next_mut(dst))?,
-            Val::Char(value) => value.lower(cx, ty, next_mut(dst))?,
-            Val::Resource(value) => value.lower(cx, ty, next_mut(dst))?,
-            Val::String(value) => {
-                let my_dst = &mut MaybeUninit::<[ValRaw; 2]>::uninit();
-                value.lower(cx, ty, my_dst)?;
-                let my_dst = unsafe { my_dst.assume_init() };
-                next_mut(dst).write(my_dst[0]);
-                next_mut(dst).write(my_dst[1]);
-            }
-            Val::List(List { values, .. }) => {
-                let ty = match ty {
-                    InterfaceType::List(i) => &cx.types[i],
-                    _ => bad_type_info(),
-                };
-                let (ptr, len) = lower_list(cx, ty.element, values)?;
-                next_mut(dst).write(ValRaw::i64(ptr as i64));
-                next_mut(dst).write(ValRaw::i64(len as i64));
-            }
-            Val::Record(Record { values, .. }) => {
-                let ty = match ty {
-                    InterfaceType::Record(i) => &cx.types[i],
-                    _ => bad_type_info(),
-                };
-                for (value, field) in values.iter().zip(ty.fields.iter()) {
-                    value.lower(cx, field.ty, dst)?;
-                }
-            }
-            Val::Tuple(Tuple { values, .. }) => {
-                let ty = match ty {
-                    InterfaceType::Tuple(i) => &cx.types[i],
-                    _ => bad_type_info(),
-                };
-                for (value, ty) in values.iter().zip(ty.types.iter()) {
-                    value.lower(cx, *ty, dst)?;
-                }
-            }
-            Val::Variant(v) => v.as_generic(cx.types, ty).lower(cx, dst)?,
-            Val::Option(v) => v.as_generic(cx.types, ty).lower(cx, dst)?,
-            Val::Result(v) => v.as_generic(cx.types, ty).lower(cx, dst)?,
-            Val::Enum(Enum { discriminant, .. }) => {
-                next_mut(dst).write(ValRaw::u32(*discriminant));
-            }
-            Val::Flags(Flags { value, .. }) => {
-                for value in value.deref() {
-                    next_mut(dst).write(ValRaw::u32(*value));
-                }
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Serialize this value to the heap at the specified memory location.
-    pub(crate) fn store<T>(
-        &self,
-        cx: &mut LowerContext<'_, T>,
-        ty: InterfaceType,
-        offset: usize,
-    ) -> Result<()> {
-        debug_assert!(offset % usize::try_from(cx.types.canonical_abi(&ty).align32)? == 0);
-
-        match self {
-            Val::Bool(value) => value.store(cx, ty, offset)?,
-            Val::U8(value) => value.store(cx, ty, offset)?,
-            Val::S8(value) => value.store(cx, ty, offset)?,
-            Val::U16(value) => value.store(cx, ty, offset)?,
-            Val::S16(value) => value.store(cx, ty, offset)?,
-            Val::U32(value) => value.store(cx, ty, offset)?,
-            Val::S32(value) => value.store(cx, ty, offset)?,
-            Val::U64(value) => value.store(cx, ty, offset)?,
-            Val::S64(value) => value.store(cx, ty, offset)?,
-            Val::Float32(value) => value.store(cx, ty, offset)?,
-            Val::Float64(value) => value.store(cx, ty, offset)?,
-            Val::Char(value) => value.store(cx, ty, offset)?,
-            Val::String(value) => value.store(cx, ty, offset)?,
-            Val::Resource(value) => value.store(cx, ty, offset)?,
-            Val::List(List { values, .. }) => {
-                let ty = match ty {
-                    InterfaceType::List(i) => &cx.types[i],
-                    _ => bad_type_info(),
-                };
-                let (ptr, len) = lower_list(cx, ty.element, values)?;
-                // FIXME: needs memory64 handling
-                *cx.get(offset + 0) = (ptr as i32).to_le_bytes();
-                *cx.get(offset + 4) = (len as i32).to_le_bytes();
-            }
-            Val::Record(Record { values, .. }) => {
-                let ty = match ty {
-                    InterfaceType::Record(i) => &cx.types[i],
-                    _ => bad_type_info(),
-                };
-                let mut offset = offset;
-                for (value, field) in values.iter().zip(ty.fields.iter()) {
-                    value.store(
-                        cx,
-                        field.ty,
-                        cx.types
-                            .canonical_abi(&field.ty)
-                            .next_field32_size(&mut offset),
-                    )?;
-                }
-            }
-            Val::Tuple(Tuple { values, .. }) => {
-                let ty = match ty {
-                    InterfaceType::Tuple(i) => &cx.types[i],
-                    _ => bad_type_info(),
-                };
-                let mut offset = offset;
-                for (value, ty) in values.iter().zip(ty.types.iter()) {
-                    value.store(
-                        cx,
-                        *ty,
-                        cx.types.canonical_abi(ty).next_field32_size(&mut offset),
-                    )?;
-                }
-            }
-
-            Val::Variant(v) => v.as_generic(cx.types, ty).store(cx, offset)?,
-            Val::Enum(v) => v.as_generic(cx.types, ty).store(cx, offset)?,
-            Val::Option(v) => v.as_generic(cx.types, ty).store(cx, offset)?,
-            Val::Result(v) => v.as_generic(cx.types, ty).store(cx, offset)?,
-
-            Val::Flags(Flags { count, value, .. }) => {
-                match FlagsSize::from_count(*count as usize) {
-                    FlagsSize::Size0 => {}
-                    FlagsSize::Size1 => {
-                        u8::try_from(value[0])
-                            .unwrap()
-                            .store(cx, InterfaceType::U8, offset)?
-                    }
-                    FlagsSize::Size2 => {
-                        u16::try_from(value[0])
-                            .unwrap()
-                            .store(cx, InterfaceType::U16, offset)?
-                    }
-                    FlagsSize::Size4Plus(_) => {
-                        let mut offset = offset;
-                        for value in value.deref() {
-                            value.store(cx, InterfaceType::U32, offset)?;
-                            offset += 4;
-                        }
-                    }
-                }
-            }
-        }
-
-        Ok(())
-    }
-}
-
-impl PartialEq for Val {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            // IEEE 754 equality considers NaN inequal to NaN and negative zero
-            // equal to positive zero, however we do the opposite here, because
-            // this logic is used by testing and fuzzing, which want to know
-            // whether two values are semantically the same, rather than
-            // numerically equal.
-            (Self::Float32(l), Self::Float32(r)) => {
-                (*l != 0.0 && l == r)
-                    || (*l == 0.0 && l.to_bits() == r.to_bits())
-                    || (l.is_nan() && r.is_nan())
-            }
-            (Self::Float32(_), _) => false,
-            (Self::Float64(l), Self::Float64(r)) => {
-                (*l != 0.0 && l == r)
-                    || (*l == 0.0 && l.to_bits() == r.to_bits())
-                    || (l.is_nan() && r.is_nan())
-            }
-            (Self::Float64(_), _) => false,
-
-            (Self::Bool(l), Self::Bool(r)) => l == r,
-            (Self::Bool(_), _) => false,
-            (Self::S8(l), Self::S8(r)) => l == r,
-            (Self::S8(_), _) => false,
-            (Self::U8(l), Self::U8(r)) => l == r,
-            (Self::U8(_), _) => false,
-            (Self::S16(l), Self::S16(r)) => l == r,
-            (Self::S16(_), _) => false,
-            (Self::U16(l), Self::U16(r)) => l == r,
-            (Self::U16(_), _) => false,
-            (Self::S32(l), Self::S32(r)) => l == r,
-            (Self::S32(_), _) => false,
-            (Self::U32(l), Self::U32(r)) => l == r,
-            (Self::U32(_), _) => false,
-            (Self::S64(l), Self::S64(r)) => l == r,
-            (Self::S64(_), _) => false,
-            (Self::U64(l), Self::U64(r)) => l == r,
-            (Self::U64(_), _) => false,
-            (Self::Char(l), Self::Char(r)) => l == r,
-            (Self::Char(_), _) => false,
-            (Self::String(l), Self::String(r)) => l == r,
-            (Self::String(_), _) => false,
-            (Self::List(l), Self::List(r)) => l == r,
-            (Self::List(_), _) => false,
-            (Self::Record(l), Self::Record(r)) => l == r,
-            (Self::Record(_), _) => false,
-            (Self::Tuple(l), Self::Tuple(r)) => l == r,
-            (Self::Tuple(_), _) => false,
-            (Self::Variant(l), Self::Variant(r)) => l == r,
-            (Self::Variant(_), _) => false,
-            (Self::Enum(l), Self::Enum(r)) => l == r,
-            (Self::Enum(_), _) => false,
-            (Self::Option(l), Self::Option(r)) => l == r,
-            (Self::Option(_), _) => false,
-            (Self::Result(l), Self::Result(r)) => l == r,
-            (Self::Result(_), _) => false,
-            (Self::Flags(l), Self::Flags(r)) => l == r,
-            (Self::Flags(_), _) => false,
-            (Self::Resource(l), Self::Resource(r)) => l == r,
-            (Self::Resource(_), _) => false,
-        }
-    }
-}
-
-impl Eq for Val {}
-
-struct GenericVariant<'a> {
-    discriminant: u32,
-    payload: Option<(&'a Val, InterfaceType)>,
-    abi: &'a CanonicalAbiInfo,
-    info: &'a VariantInfo,
-}
-
-impl GenericVariant<'_> {
-    fn lower<T>(
-        &self,
-        cx: &mut LowerContext<'_, T>,
-        dst: &mut std::slice::IterMut<'_, MaybeUninit<ValRaw>>,
-    ) -> Result<()> {
-        next_mut(dst).write(ValRaw::u32(self.discriminant));
-
-        // For the remaining lowered representation of this variant that
-        // the payload didn't write we write out zeros here to ensure
-        // the entire variant is written.
-        let value_flat = match self.payload {
-            Some((value, ty)) => {
-                value.lower(cx, ty, dst)?;
-                cx.types.canonical_abi(&ty).flat_count(usize::MAX).unwrap()
-            }
-            None => 0,
-        };
-        let variant_flat = self.abi.flat_count(usize::MAX).unwrap();
-        for _ in (1 + value_flat)..variant_flat {
-            next_mut(dst).write(ValRaw::u64(0));
-        }
-        Ok(())
-    }
-
-    fn store<T>(&self, cx: &mut LowerContext<'_, T>, offset: usize) -> Result<()> {
-        match self.info.size {
-            DiscriminantSize::Size1 => {
-                u8::try_from(self.discriminant)
-                    .unwrap()
-                    .store(cx, InterfaceType::U8, offset)?
-            }
-            DiscriminantSize::Size2 => {
-                u16::try_from(self.discriminant)
-                    .unwrap()
-                    .store(cx, InterfaceType::U16, offset)?
-            }
-            DiscriminantSize::Size4 => self.discriminant.store(cx, InterfaceType::U32, offset)?,
-        }
-
-        if let Some((value, ty)) = self.payload {
-            let offset = offset + usize::try_from(self.info.payload_offset32).unwrap();
-            value.store(cx, ty, offset)?;
-        }
-
-        Ok(())
-    }
-}
-
-fn load_list(cx: &mut LiftContext<'_>, ty: TypeListIndex, ptr: usize, len: usize) -> Result<Val> {
-    let elem = cx.types[ty].element;
-    let abi = cx.types.canonical_abi(&elem);
-    let element_size = usize::try_from(abi.size32).unwrap();
-    let element_alignment = abi.align32;
-
-    match len
-        .checked_mul(element_size)
-        .and_then(|len| ptr.checked_add(len))
-    {
-        Some(n) if n <= cx.memory().len() => {}
-        _ => bail!("list pointer/length out of bounds of memory"),
-    }
-    if ptr % usize::try_from(element_alignment)? != 0 {
-        bail!("list pointer is not aligned")
-    }
-
-    Ok(Val::List(List {
-        ty: types::List::from(ty, &cx.instance_type()),
-        values: (0..len)
-            .map(|index| {
-                Val::load(
-                    cx,
-                    elem,
-                    &cx.memory()[ptr + (index * element_size)..][..element_size],
-                )
-            })
-            .collect::<Result<_>>()?,
-    }))
-}
-
-fn load_record(
-    cx: &mut LiftContext<'_>,
-    types: impl Iterator<Item = InterfaceType>,
-    bytes: &[u8],
-) -> Result<Box<[Val]>> {
-    let mut offset = 0;
-    types
-        .map(|ty| {
-            let abi = cx.types.canonical_abi(&ty);
-            let offset = abi.next_field32(&mut offset);
-            let offset = usize::try_from(offset).unwrap();
-            let size = usize::try_from(abi.size32).unwrap();
-            Val::load(cx, ty, &bytes[offset..][..size])
-        })
-        .collect()
-}
-
-fn load_variant(
-    cx: &mut LiftContext<'_>,
-    info: &VariantInfo,
-    mut types: impl ExactSizeIterator<Item = Option<InterfaceType>>,
-    bytes: &[u8],
-) -> Result<(u32, Option<Box<Val>>)> {
-    let discriminant = match info.size {
-        DiscriminantSize::Size1 => u32::from(u8::load(cx, InterfaceType::U8, &bytes[..1])?),
-        DiscriminantSize::Size2 => u32::from(u16::load(cx, InterfaceType::U16, &bytes[..2])?),
-        DiscriminantSize::Size4 => u32::load(cx, InterfaceType::U32, &bytes[..4])?,
-    };
-    let case_ty = types.nth(discriminant as usize).ok_or_else(|| {
-        anyhow!(
-            "discriminant {} out of range [0..{})",
-            discriminant,
-            types.len()
-        )
-    })?;
-    let value = match case_ty {
-        Some(case_ty) => {
-            let payload_offset = usize::try_from(info.payload_offset32).unwrap();
-            let case_abi = cx.types.canonical_abi(&case_ty);
-            let case_size = usize::try_from(case_abi.size32).unwrap();
-            Some(Box::new(Val::load(
-                cx,
-                case_ty,
-                &bytes[payload_offset..][..case_size],
-            )?))
-        }
-        None => None,
-    };
-    Ok((discriminant, value))
-}
-
-fn lift_variant(
-    cx: &mut LiftContext<'_>,
-    flatten_count: usize,
-    mut types: impl ExactSizeIterator<Item = Option<InterfaceType>>,
-    src: &mut std::slice::Iter<'_, ValRaw>,
-) -> Result<(u32, Option<Box<Val>>)> {
-    let len = types.len();
-    let discriminant = next(src).get_u32();
-    let ty = types
-        .nth(discriminant as usize)
-        .ok_or_else(|| anyhow!("discriminant {} out of range [0..{})", discriminant, len))?;
-    let (value, value_flat) = match ty {
-        Some(ty) => (
-            Some(Box::new(Val::lift(cx, ty, src)?)),
-            cx.types.canonical_abi(&ty).flat_count(usize::MAX).unwrap(),
-        ),
-        None => (None, 0),
-    };
-    for _ in (1 + value_flat)..flatten_count {
-        next(src);
-    }
-    Ok((discriminant, value))
-}
-
-/// Lower a list with the specified element type and values.
-fn lower_list<T>(
-    cx: &mut LowerContext<'_, T>,
-    element_type: InterfaceType,
-    items: &[Val],
-) -> Result<(usize, usize)> {
-    let abi = cx.types.canonical_abi(&element_type);
-    let elt_size = usize::try_from(abi.size32)?;
-    let elt_align = abi.align32;
-    let size = items
-        .len()
-        .checked_mul(elt_size)
-        .ok_or_else(|| anyhow::anyhow!("size overflow copying a list"))?;
-    let ptr = cx.realloc(0, 0, elt_align, size)?;
-    let mut element_ptr = ptr;
-    for item in items {
-        item.store(cx, element_type, element_ptr)?;
-        element_ptr += elt_size;
-    }
-    Ok((ptr, items.len()))
-}
-
-fn next<'a>(src: &mut std::slice::Iter<'a, ValRaw>) -> &'a ValRaw {
-    src.next().unwrap()
-}
-
-fn next_mut<'a>(
-    dst: &mut std::slice::IterMut<'a, MaybeUninit<ValRaw>>,
-) -> &'a mut MaybeUninit<ValRaw> {
-    dst.next().unwrap()
-}
diff --git a/crates/wasmtime/src/config.rs b/crates/wasmtime/src/config.rs
index 1fdec89379a7..4b12fe5f7e25 100644
--- a/crates/wasmtime/src/config.rs
+++ b/crates/wasmtime/src/config.rs
@@ -1,23 +1,38 @@
-use crate::memory::MemoryCreator;
-use crate::trampoline::MemoryCreatorProxy;
-use anyhow::{bail, ensure, Result};
+use crate::prelude::*;
+use alloc::sync::Arc;
+use bitflags::Flags;
+use core::fmt;
+use core::str::FromStr;
+use hashbrown::{HashMap, HashSet};
 use serde_derive::{Deserialize, Serialize};
-use std::collections::{HashMap, HashSet};
-use std::fmt;
 #[cfg(any(feature = "cache", feature = "cranelift", feature = "winch"))]
 use std::path::Path;
-use std::str::FromStr;
-use std::sync::Arc;
 use target_lexicon::Architecture;
 use wasmparser::WasmFeatures;
 #[cfg(feature = "cache")]
 use wasmtime_cache::CacheConfig;
 use wasmtime_environ::Tunables;
-use wasmtime_jit::profiling::{self, ProfilingAgent};
-use wasmtime_runtime::{mpk, InstanceAllocator, OnDemandInstanceAllocator, RuntimeMemoryCreator};
 
+#[cfg(feature = "runtime")]
+use crate::memory::MemoryCreator;
+#[cfg(feature = "runtime")]
+use crate::profiling_agent::{self, ProfilingAgent};
+#[cfg(feature = "runtime")]
+use crate::runtime::vm::{
+    GcRuntime, InstanceAllocator, OnDemandInstanceAllocator, RuntimeMemoryCreator,
+};
+#[cfg(feature = "runtime")]
+use crate::trampoline::MemoryCreatorProxy;
+
+#[cfg(feature = "async")]
+use crate::stack::{StackCreator, StackCreatorProxy};
+#[cfg(feature = "async")]
+use wasmtime_fiber::RuntimeFiberStackCreator;
+
+#[cfg(feature = "pooling-allocator")]
+pub use crate::runtime::vm::MpkEnabled;
+#[cfg(all(feature = "incremental-cache", feature = "cranelift"))]
 pub use wasmtime_environ::CacheStore;
-pub use wasmtime_runtime::MpkEnabled;
 
 /// Represents the module instance allocation strategy to use.
 #[derive(Clone)]
@@ -69,8 +84,8 @@ impl Default for ModuleVersionStrategy {
     }
 }
 
-impl std::hash::Hash for ModuleVersionStrategy {
-    fn hash<H: std::hash::Hasher>(&self, hasher: &mut H) {
+impl core::hash::Hash for ModuleVersionStrategy {
+    fn hash<H: core::hash::Hasher>(&self, hasher: &mut H) {
         match self {
             Self::WasmtimeVersion => env!("CARGO_PKG_VERSION").hash(hasher),
             Self::Custom(s) => s.hash(hasher),
@@ -92,19 +107,30 @@ pub struct Config {
     #[cfg(any(feature = "cranelift", feature = "winch"))]
     compiler_config: CompilerConfig,
     profiling_strategy: ProfilingStrategy,
+    tunables: ConfigTunables,
 
-    pub(crate) tunables: Tunables,
     #[cfg(feature = "cache")]
     pub(crate) cache_config: CacheConfig,
+    #[cfg(feature = "runtime")]
     pub(crate) mem_creator: Option<Arc<dyn RuntimeMemoryCreator>>,
     pub(crate) allocation_strategy: InstanceAllocationStrategy,
     pub(crate) max_wasm_stack: usize,
-    pub(crate) features: WasmFeatures,
+    /// Explicitly enabled features via `Config::wasm_*` methods. This is a
+    /// signal that the embedder specifically wants something turned on
+    /// regardless of the defaults that Wasmtime might otherwise have enabled.
+    ///
+    /// Note that this, and `disabled_features` below, start as the empty set of
+    /// features to only track explicit user requests.
+    pub(crate) enabled_features: WasmFeatures,
+    /// Same as `enabled_features`, but for those that are explicitly disabled.
+    pub(crate) disabled_features: WasmFeatures,
     pub(crate) wasm_backtrace: bool,
     pub(crate) wasm_backtrace_details_env_used: bool,
     pub(crate) native_unwind_info: Option<bool>,
     #[cfg(feature = "async")]
     pub(crate) async_stack_size: usize,
+    #[cfg(feature = "async")]
+    pub(crate) stack_creator: Option<Arc<dyn RuntimeFiberStackCreator>>,
     pub(crate) async_support: bool,
     pub(crate) module_version: ModuleVersionStrategy,
     pub(crate) parallel_compilation: bool,
@@ -114,17 +140,36 @@ pub struct Config {
     pub(crate) wmemcheck: bool,
     pub(crate) coredump_on_trap: bool,
     pub(crate) macos_use_mach_ports: bool,
+    pub(crate) detect_host_feature: Option<fn(&str) -> Option<bool>>,
+}
+
+#[derive(Default, Clone)]
+struct ConfigTunables {
+    static_memory_reservation: Option<u64>,
+    static_memory_offset_guard_size: Option<u64>,
+    dynamic_memory_offset_guard_size: Option<u64>,
+    dynamic_memory_growth_reserve: Option<u64>,
+    generate_native_debuginfo: Option<bool>,
+    parse_wasm_debuginfo: Option<bool>,
+    consume_fuel: Option<bool>,
+    epoch_interruption: Option<bool>,
+    static_memory_bound_is_maximum: Option<bool>,
+    guard_before_linear_memory: Option<bool>,
+    table_lazy_init: Option<bool>,
+    generate_address_map: Option<bool>,
+    debug_adapter_modules: Option<bool>,
+    relaxed_simd_deterministic: Option<bool>,
 }
 
 /// User-provided configuration for the compiler.
 #[cfg(any(feature = "cranelift", feature = "winch"))]
 #[derive(Debug, Clone)]
 struct CompilerConfig {
-    strategy: Strategy,
+    strategy: Option<Strategy>,
     target: Option<target_lexicon::Triple>,
     settings: HashMap<String, String>,
     flags: HashSet<String>,
-    #[cfg(any(feature = "cranelift", feature = "winch"))]
+    #[cfg(all(feature = "incremental-cache", feature = "cranelift"))]
     cache_store: Option<Arc<dyn CacheStore>>,
     clif_dir: Option<std::path::PathBuf>,
     wmemcheck: bool,
@@ -132,12 +177,13 @@ struct CompilerConfig {
 
 #[cfg(any(feature = "cranelift", feature = "winch"))]
 impl CompilerConfig {
-    fn new(strategy: Strategy) -> Self {
+    fn new() -> Self {
         Self {
-            strategy,
+            strategy: Strategy::Auto.not_auto(),
             target: None,
             settings: HashMap::new(),
             flags: HashSet::new(),
+            #[cfg(all(feature = "incremental-cache", feature = "cranelift"))]
             cache_store: None,
             clif_dir: None,
             wmemcheck: false,
@@ -167,7 +213,7 @@ impl CompilerConfig {
 #[cfg(any(feature = "cranelift", feature = "winch"))]
 impl Default for CompilerConfig {
     fn default() -> Self {
-        Self::new(Strategy::Auto)
+        Self::new()
     }
 }
 
@@ -176,12 +222,13 @@ impl Config {
     /// specified.
     pub fn new() -> Self {
         let mut ret = Self {
-            tunables: Tunables::default(),
+            tunables: ConfigTunables::default(),
             #[cfg(any(feature = "cranelift", feature = "winch"))]
             compiler_config: CompilerConfig::default(),
             #[cfg(feature = "cache")]
             cache_config: CacheConfig::new_cache_disabled(),
             profiling_strategy: ProfilingStrategy::None,
+            #[cfg(feature = "runtime")]
             mem_creator: None,
             allocation_strategy: InstanceAllocationStrategy::OnDemand,
             // 512k of stack -- note that this is chosen currently to not be too
@@ -196,9 +243,12 @@ impl Config {
             wasm_backtrace: true,
             wasm_backtrace_details_env_used: false,
             native_unwind_info: None,
-            features: WasmFeatures::default(),
+            enabled_features: WasmFeatures::empty(),
+            disabled_features: WasmFeatures::empty(),
             #[cfg(feature = "async")]
             async_stack_size: 2 << 20,
+            #[cfg(feature = "async")]
+            stack_creator: None,
             async_support: false,
             module_version: ModuleVersionStrategy::default(),
             parallel_compilation: !cfg!(miri),
@@ -207,7 +257,11 @@ impl Config {
             force_memory_init_memfd: false,
             wmemcheck: false,
             coredump_on_trap: false,
-            macos_use_mach_ports: true,
+            macos_use_mach_ports: !cfg!(miri),
+            #[cfg(feature = "std")]
+            detect_host_feature: Some(detect_host_feature),
+            #[cfg(not(feature = "std"))]
+            detect_host_feature: None,
         };
         #[cfg(any(feature = "cranelift", feature = "winch"))]
         {
@@ -215,16 +269,8 @@ impl Config {
             ret.cranelift_opt_level(OptLevel::Speed);
         }
 
-        ret.wasm_reference_types(true);
-        ret.wasm_multi_value(true);
-        ret.wasm_bulk_memory(true);
-        ret.wasm_simd(true);
         ret.wasm_backtrace_details(WasmBacktraceDetails::Environment);
 
-        // This is on-by-default in `wasmparser` since it's a stage 4+ proposal
-        // but it's not implemented in Wasmtime yet so disable it.
-        ret.features.tail_call = false;
-
         ret
     }
 
@@ -241,7 +287,6 @@ impl Config {
     ///
     /// This method will error if the given target triple is not supported.
     #[cfg(any(feature = "cranelift", feature = "winch"))]
-    #[cfg_attr(nightlydoc, doc(cfg(any(feature = "cranelift", feature = "winch"))))]
     pub fn target(&mut self, target: &str) -> Result<&mut Self> {
         self.compiler_config.target =
             Some(target_lexicon::Triple::from_str(target).map_err(|e| anyhow::anyhow!(e))?);
@@ -329,7 +374,7 @@ impl Config {
     ///
     /// * Alternatively you can enable the
     ///   [`Config::consume_fuel`](crate::Config::consume_fuel) method as well
-    ///   as [`crate::Store::out_of_fuel_async_yield`] When doing so this will
+    ///   as [`crate::Store::fuel_async_yield_interval`] When doing so this will
     ///   configure Wasmtime futures to yield periodically while they're
     ///   executing WebAssembly code. After consuming the specified amount of
     ///   fuel wasm futures will return `Poll::Pending` from their `poll`
@@ -352,7 +397,6 @@ impl Config {
     /// it. If Wasmtime doesn't support exactly what you'd like just yet, please
     /// feel free to open an issue!
     #[cfg(feature = "async")]
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "async")))]
     pub fn async_support(&mut self, enable: bool) -> &mut Self {
         self.async_support = enable;
         self
@@ -361,9 +405,13 @@ impl Config {
     /// Configures whether DWARF debug information will be emitted during
     /// compilation.
     ///
+    /// Note that the `debug-builtins` compile-time Cargo feature must also be
+    /// enabled for native debuggers such as GDB or LLDB to be able to debug
+    /// guest WebAssembly programs.
+    ///
     /// By default this option is `false`.
     pub fn debug_info(&mut self, enable: bool) -> &mut Self {
-        self.tunables.generate_native_debuginfo = enable;
+        self.tunables.generate_native_debuginfo = Some(enable);
         self
     }
 
@@ -405,18 +453,27 @@ impl Config {
     /// filename/line number for each wasm frame in the stack trace.
     ///
     /// By default this option is `WasmBacktraceDetails::Environment`, meaning
-    /// that wasm will read `WASMTIME_BACKTRACE_DETAILS` to indicate whether details
-    /// should be parsed.
+    /// that wasm will read `WASMTIME_BACKTRACE_DETAILS` to indicate whether
+    /// details should be parsed. Note that the `std` feature of this crate must
+    /// be active to read environment variables, otherwise this is disabled by
+    /// default.
     pub fn wasm_backtrace_details(&mut self, enable: WasmBacktraceDetails) -> &mut Self {
         self.wasm_backtrace_details_env_used = false;
         self.tunables.parse_wasm_debuginfo = match enable {
-            WasmBacktraceDetails::Enable => true,
-            WasmBacktraceDetails::Disable => false,
+            WasmBacktraceDetails::Enable => Some(true),
+            WasmBacktraceDetails::Disable => Some(false),
             WasmBacktraceDetails::Environment => {
                 self.wasm_backtrace_details_env_used = true;
-                std::env::var("WASMTIME_BACKTRACE_DETAILS")
-                    .map(|s| s == "1")
-                    .unwrap_or(false)
+                #[cfg(feature = "std")]
+                {
+                    std::env::var("WASMTIME_BACKTRACE_DETAILS")
+                        .map(|s| Some(s == "1"))
+                        .unwrap_or(Some(false))
+                }
+                #[cfg(not(feature = "std"))]
+                {
+                    Some(false)
+                }
             }
         };
         self
@@ -447,8 +504,9 @@ impl Config {
     ///
     /// This can be used to deterministically prevent infinitely-executing
     /// WebAssembly code by instrumenting generated code to consume fuel as it
-    /// executes. When fuel runs out the behavior is defined by configuration
-    /// within a [`Store`], and by default a trap is raised.
+    /// executes. When fuel runs out a trap is raised, however [`Store`] can be
+    /// configured to yield execution periodically via
+    /// [`crate::Store::fuel_async_yield_interval`].
     ///
     /// Note that a [`Store`] starts with no fuel, so if you enable this option
     /// you'll have to be sure to pour some fuel into [`Store`] before
@@ -458,7 +516,7 @@ impl Config {
     ///
     /// [`Store`]: crate::Store
     pub fn consume_fuel(&mut self, enable: bool) -> &mut Self {
-        self.tunables.consume_fuel = enable;
+        self.tunables.consume_fuel = Some(enable);
         self
     }
 
@@ -527,6 +585,24 @@ impl Config {
     /// [`Store::set_epoch_deadline`](crate::Store::set_epoch_deadline). If this
     /// deadline is not configured then wasm will immediately trap.
     ///
+    /// ## Interaction with blocking host calls
+    ///
+    /// Epochs (and fuel) do not assist in handling WebAssembly code blocked in
+    /// a call to the host. For example if the WebAssembly function calls
+    /// `wasi:io/poll/poll` to sleep epochs will not assist in waking this up or
+    /// timing it out. Epochs intentionally only affect running WebAssembly code
+    /// itself and it's left to the embedder to determine how best to wake up
+    /// indefinitely blocking code in the host.
+    ///
+    /// The typical solution for this, however, is to use
+    /// [`Config::async_support(true)`](Config::async_support) and the `async`
+    /// variant of WASI host functions. This models computation as a Rust
+    /// `Future` which means that when blocking happens the future is only
+    /// suspended and control yields back to the main event loop. This gives the
+    /// embedder the opportunity to use `tokio::time::timeout` for example on a
+    /// wasm computation and have the desired effect of cancelling a blocking
+    /// operation when a timeout expires.
+    ///
     /// ## When to use fuel vs. epochs
     ///
     /// In general, epoch-based interruption results in faster
@@ -552,7 +628,7 @@ impl Config {
     /// - [`Store::epoch_deadline_callback`](crate::Store::epoch_deadline_callback)
     /// - [`Store::epoch_deadline_async_yield_and_update`](crate::Store::epoch_deadline_async_yield_and_update)
     pub fn epoch_interruption(&mut self, enable: bool) -> &mut Self {
-        self.tunables.epoch_interruption = enable;
+        self.tunables.epoch_interruption = Some(enable);
         self
     }
 
@@ -588,7 +664,7 @@ impl Config {
     /// space consumed by a host function is counted towards this limit. The
     /// host functions are not prevented from consuming more than this limit.
     /// However, if the host function that used more than this limit and called
-    /// back into wasm, then the execution will trap immediatelly because of
+    /// back into wasm, then the execution will trap immediately because of
     /// stack overflow.
     ///
     /// When the `async` feature is enabled, this value cannot exceed the
@@ -624,12 +700,17 @@ impl Config {
     /// The `Engine::new` method will fail if the value for this option is
     /// smaller than the [`Config::max_wasm_stack`] option.
     #[cfg(feature = "async")]
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "async")))]
     pub fn async_stack_size(&mut self, size: usize) -> &mut Self {
         self.async_stack_size = size;
         self
     }
 
+    fn wasm_feature(&mut self, flag: WasmFeatures, enable: bool) -> &mut Self {
+        self.enabled_features.set(flag, enable);
+        self.disabled_features.set(flag, !enable);
+        self
+    }
+
     /// Configures whether the WebAssembly tail calls proposal will be enabled
     /// for compilation or not.
     ///
@@ -638,42 +719,59 @@ impl Config {
     /// programs to implement some recursive algorithms with *O(1)* stack space
     /// usage.
     ///
-    /// This feature is disabled by default.
+    /// This is `true` by default except when the Winch compiler is enabled.
     ///
     /// [WebAssembly tail calls proposal]: https://github.com/WebAssembly/tail-call
     pub fn wasm_tail_call(&mut self, enable: bool) -> &mut Self {
-        self.features.tail_call = enable;
-        self.tunables.tail_callable = enable;
+        self.wasm_feature(WasmFeatures::TAIL_CALL, enable);
         self
     }
 
-    /// Configures whether the WebAssembly threads proposal will be enabled for
-    /// compilation.
+    /// Configures whether the WebAssembly custom-page-sizes proposal will be
+    /// enabled for compilation or not.
     ///
-    /// The [WebAssembly threads proposal][threads] is not currently fully
-    /// standardized and is undergoing development. Additionally the support in
-    /// wasmtime itself is still being worked on. Support for this feature can
-    /// be enabled through this method for appropriate wasm modules.
+    /// The [WebAssembly custom-page-sizes proposal] allows a memory to
+    /// customize its page sizes. By default, Wasm page sizes are 64KiB
+    /// large. This proposal allows the memory to opt into smaller page sizes
+    /// instead, allowing Wasm to run in environments with less than 64KiB RAM
+    /// available, for example.
     ///
-    /// This feature gates items such as shared memories and atomic
-    /// instructions. Note that the threads feature depends on the
-    /// bulk memory feature, which is enabled by default.
+    /// Note that the page size is part of the memory's type, and because
+    /// different memories may have different types, they may also have
+    /// different page sizes.
     ///
-    /// This is `false` by default.
+    /// Currently the only valid page sizes are 64KiB (the default) and 1
+    /// byte. Future extensions may relax this constraint and allow all powers
+    /// of two.
     ///
-    /// > **Note**: Wasmtime does not implement everything for the wasm threads
-    /// > spec at this time, so bugs, panics, and possibly segfaults should be
-    /// > expected. This should not be enabled in a production setting right
-    /// > now.
+    /// Support for this proposal is disabled by default.
     ///
-    /// # Errors
+    /// [WebAssembly custom-page-sizes proposal]: https://github.com/WebAssembly/custom-page-sizes
+    pub fn wasm_custom_page_sizes(&mut self, enable: bool) -> &mut Self {
+        self.wasm_feature(WasmFeatures::CUSTOM_PAGE_SIZES, enable);
+        self
+    }
+
+    /// Configures whether the WebAssembly [threads] proposal will be enabled
+    /// for compilation.
     ///
-    /// The validation of this feature are deferred until the engine is being built,
-    /// and thus may cause `Engine::new` fail if the `bulk_memory` feature is disabled.
+    /// This feature gates items such as shared memories and atomic
+    /// instructions. Note that the threads feature depends on the bulk memory
+    /// feature, which is enabled by default. Additionally note that while the
+    /// wasm feature is called "threads" it does not actually include the
+    /// ability to spawn threads. Spawning threads is part of the [wasi-threads]
+    /// proposal which is a separately gated feature in Wasmtime.
+    ///
+    /// Embeddings of Wasmtime are able to build their own custom threading
+    /// scheme on top of the core wasm threads proposal, however.
+    ///
+    /// This is `true` by default.
     ///
     /// [threads]: https://github.com/webassembly/threads
+    /// [wasi-threads]: https://github.com/webassembly/wasi-threads
+    #[cfg(feature = "threads")]
     pub fn wasm_threads(&mut self, enable: bool) -> &mut Self {
-        self.features.threads = enable;
+        self.wasm_feature(WasmFeatures::THREADS, enable);
         self
     }
 
@@ -693,24 +791,49 @@ impl Config {
     /// and thus may cause `Engine::new` fail if the `bulk_memory` feature is disabled.
     ///
     /// [proposal]: https://github.com/webassembly/reference-types
+    #[cfg(feature = "gc")]
     pub fn wasm_reference_types(&mut self, enable: bool) -> &mut Self {
-        self.features.reference_types = enable;
+        self.wasm_feature(WasmFeatures::REFERENCE_TYPES, enable);
         self
     }
 
-    /// Configures whether the [WebAssembly function references proposal][proposal]
-    /// will be enabled for compilation.
+    /// Configures whether the [WebAssembly function references
+    /// proposal][proposal] will be enabled for compilation.
     ///
     /// This feature gates non-nullable reference types, function reference
-    /// types, call_ref, ref.func, and non-nullable reference related instructions.
+    /// types, `call_ref`, `ref.func`, and non-nullable reference related
+    /// instructions.
     ///
-    /// Note that the function references proposal depends on the reference types proposal.
+    /// Note that the function references proposal depends on the reference
+    /// types proposal.
     ///
     /// This feature is `false` by default.
     ///
     /// [proposal]: https://github.com/WebAssembly/function-references
+    #[cfg(feature = "gc")]
     pub fn wasm_function_references(&mut self, enable: bool) -> &mut Self {
-        self.features.function_references = enable;
+        self.wasm_feature(WasmFeatures::FUNCTION_REFERENCES, enable);
+        self
+    }
+
+    /// Configures whether the [WebAssembly Garbage Collection
+    /// proposal][proposal] will be enabled for compilation.
+    ///
+    /// This feature gates `struct` and `array` type definitions and references,
+    /// the `i31ref` type, and all related instructions.
+    ///
+    /// Note that the function references proposal depends on the typed function
+    /// references proposal.
+    ///
+    /// This feature is `false` by default.
+    ///
+    /// **Warning: Wasmtime's implementation of the GC proposal is still in
+    /// progress and generally not ready for primetime.**
+    ///
+    /// [proposal]: https://github.com/WebAssembly/gc
+    #[cfg(feature = "gc")]
+    pub fn wasm_gc(&mut self, enable: bool) -> &mut Self {
+        self.wasm_feature(WasmFeatures::GC, enable);
         self
     }
 
@@ -730,22 +853,20 @@ impl Config {
     /// [proposal]: https://github.com/webassembly/simd
     /// [relaxed simd proposal]: https://github.com/WebAssembly/relaxed-simd
     pub fn wasm_simd(&mut self, enable: bool) -> &mut Self {
-        self.features.simd = enable;
+        self.wasm_feature(WasmFeatures::SIMD, enable);
         self
     }
 
     /// Configures whether the WebAssembly Relaxed SIMD proposal will be
     /// enabled for compilation.
     ///
-    /// The [WebAssembly Relaxed SIMD proposal][proposal] is not, at the time of
-    /// this writing, at stage 4. The relaxed SIMD proposal adds new
-    /// instructions to WebAssembly which, for some specific inputs, are allowed
-    /// to produce different results on different hosts. More-or-less this
-    /// proposal enables exposing platform-specific semantics of SIMD
-    /// instructions in a controlled fashion to a WebAssembly program. From an
-    /// embedder's perspective this means that WebAssembly programs may execute
-    /// differently depending on whether the host is x86_64 or AArch64, for
-    /// example.
+    /// The relaxed SIMD proposal adds new instructions to WebAssembly which,
+    /// for some specific inputs, are allowed to produce different results on
+    /// different hosts. More-or-less this proposal enables exposing
+    /// platform-specific semantics of SIMD instructions in a controlled
+    /// fashion to a WebAssembly program. From an embedder's perspective this
+    /// means that WebAssembly programs may execute differently depending on
+    /// whether the host is x86_64 or AArch64, for example.
     ///
     /// By default Wasmtime lowers relaxed SIMD instructions to the fastest
     /// lowering for the platform it's running on. This means that, by default,
@@ -755,11 +876,11 @@ impl Config {
     /// deterministic behavior across all platforms, as classified by the
     /// specification, at the cost of performance.
     ///
-    /// This is `false` by default.
+    /// This is `true` by default.
     ///
     /// [proposal]: https://github.com/webassembly/relaxed-simd
     pub fn wasm_relaxed_simd(&mut self, enable: bool) -> &mut Self {
-        self.features.relaxed_simd = enable;
+        self.wasm_feature(WasmFeatures::RELAXED_SIMD, enable);
         self
     }
 
@@ -780,7 +901,7 @@ impl Config {
     ///
     /// [proposal]: https://github.com/webassembly/relaxed-simd
     pub fn relaxed_simd_deterministic(&mut self, enable: bool) -> &mut Self {
-        self.tunables.relaxed_simd_deterministic = enable;
+        self.tunables.relaxed_simd_deterministic = Some(enable);
         self
     }
 
@@ -803,7 +924,7 @@ impl Config {
     ///
     /// [proposal]: https://github.com/webassembly/bulk-memory-operations
     pub fn wasm_bulk_memory(&mut self, enable: bool) -> &mut Self {
-        self.features.bulk_memory = enable;
+        self.wasm_feature(WasmFeatures::BULK_MEMORY, enable);
         self
     }
 
@@ -817,7 +938,7 @@ impl Config {
     ///
     /// [proposal]: https://github.com/webassembly/multi-value
     pub fn wasm_multi_value(&mut self, enable: bool) -> &mut Self {
-        self.features.multi_value = enable;
+        self.wasm_feature(WasmFeatures::MULTI_VALUE, enable);
         self
     }
 
@@ -827,11 +948,11 @@ impl Config {
     /// This feature gates modules having more than one linear memory
     /// declaration or import.
     ///
-    /// This is `false` by default.
+    /// This is `true` by default.
     ///
     /// [proposal]: https://github.com/webassembly/multi-memory
     pub fn wasm_multi_memory(&mut self, enable: bool) -> &mut Self {
-        self.features.multi_memory = enable;
+        self.wasm_feature(WasmFeatures::MULTI_MEMORY, enable);
         self
     }
 
@@ -846,7 +967,18 @@ impl Config {
     ///
     /// [proposal]: https://github.com/webassembly/memory64
     pub fn wasm_memory64(&mut self, enable: bool) -> &mut Self {
-        self.features.memory64 = enable;
+        self.wasm_feature(WasmFeatures::MEMORY64, enable);
+        self
+    }
+
+    /// Configures whether the WebAssembly extended-const [proposal] will
+    /// be enabled for compilation.
+    ///
+    /// This is `true` by default.
+    ///
+    /// [proposal]: https://github.com/webassembly/extended-const
+    pub fn wasm_extended_const(&mut self, enable: bool) -> &mut Self {
+        self.wasm_feature(WasmFeatures::EXTENDED_CONST, enable);
         self
     }
 
@@ -860,7 +992,28 @@ impl Config {
     /// [proposal]: https://github.com/webassembly/component-model
     #[cfg(feature = "component-model")]
     pub fn wasm_component_model(&mut self, enable: bool) -> &mut Self {
-        self.features.component_model = enable;
+        self.wasm_feature(WasmFeatures::COMPONENT_MODEL, enable);
+        self
+    }
+
+    /// Configures whether components support more than 32 flags in each `flags`
+    /// type.
+    ///
+    /// This is part of the transition plan in
+    /// https://github.com/WebAssembly/component-model/issues/370.
+    #[cfg(feature = "component-model")]
+    pub fn wasm_component_model_more_flags(&mut self, enable: bool) -> &mut Self {
+        self.wasm_feature(WasmFeatures::COMPONENT_MODEL_MORE_FLAGS, enable);
+        self
+    }
+
+    /// Configures whether components support more than one return value for functions.
+    ///
+    /// This is part of the transition plan in
+    /// https://github.com/WebAssembly/component-model/pull/368.
+    #[cfg(feature = "component-model")]
+    pub fn wasm_component_model_multiple_returns(&mut self, enable: bool) -> &mut Self {
+        self.wasm_feature(WasmFeatures::COMPONENT_MODEL_MULTIPLE_RETURNS, enable);
         self
     }
 
@@ -872,9 +1025,8 @@ impl Config {
     ///
     /// The default value for this is `Strategy::Auto`.
     #[cfg(any(feature = "cranelift", feature = "winch"))]
-    #[cfg_attr(nightlydoc, doc(cfg(any(feature = "cranelift", feature = "winch"))))]
     pub fn strategy(&mut self, strategy: Strategy) -> &mut Self {
-        self.compiler_config.strategy = strategy;
+        self.compiler_config.strategy = strategy.not_auto();
         self
     }
 
@@ -906,7 +1058,6 @@ impl Config {
     ///
     /// The default value for this is `false`
     #[cfg(any(feature = "cranelift", feature = "winch"))]
-    #[cfg_attr(nightlydoc, doc(cfg(any(feature = "cranelift", feature = "winch"))))]
     pub fn cranelift_debug_verifier(&mut self, enable: bool) -> &mut Self {
         let val = if enable { "true" } else { "false" };
         self.compiler_config
@@ -923,7 +1074,6 @@ impl Config {
     ///
     /// The default value for this is `OptLevel::None`.
     #[cfg(any(feature = "cranelift", feature = "winch"))]
-    #[cfg_attr(nightlydoc, doc(cfg(any(feature = "cranelift", feature = "winch"))))]
     pub fn cranelift_opt_level(&mut self, level: OptLevel) -> &mut Self {
         let val = match level {
             OptLevel::None => "none",
@@ -939,13 +1089,17 @@ impl Config {
     /// Configures whether Cranelift should perform a NaN-canonicalization pass.
     ///
     /// When Cranelift is used as a code generation backend this will configure
-    /// it to replace NaNs with a single canonical value. This is useful for users
-    /// requiring entirely deterministic WebAssembly computation.
-    /// This is not required by the WebAssembly spec, so it is not enabled by default.
+    /// it to replace NaNs with a single canonical value. This is useful for
+    /// users requiring entirely deterministic WebAssembly computation.  This is
+    /// not required by the WebAssembly spec, so it is not enabled by default.
+    ///
+    /// Note that this option affects not only WebAssembly's `f32` and `f64`
+    /// types but additionally the `v128` type. This option will cause
+    /// operations using any of these types to have extra checks placed after
+    /// them to normalize NaN values as needed.
     ///
     /// The default value for this is `false`
     #[cfg(any(feature = "cranelift", feature = "winch"))]
-    #[cfg_attr(nightlydoc, doc(cfg(any(feature = "cranelift", feature = "winch"))))]
     pub fn cranelift_nan_canonicalization(&mut self, enable: bool) -> &mut Self {
         let val = if enable { "true" } else { "false" };
         self.compiler_config
@@ -954,6 +1108,28 @@ impl Config {
         self
     }
 
+    /// Controls whether proof-carrying code (PCC) is used to validate
+    /// lowering of Wasm sandbox checks.
+    ///
+    /// Proof-carrying code carries "facts" about program values from
+    /// the IR all the way to machine code, and checks those facts
+    /// against known machine-instruction semantics. This guards
+    /// against bugs in instruction lowering that might create holes
+    /// in the Wasm sandbox.
+    ///
+    /// PCC is designed to be fast: it does not require complex
+    /// solvers or logic engines to verify, but only a linear pass
+    /// over a trail of "breadcrumbs" or facts at each intermediate
+    /// value. Thus, it is appropriate to enable in production.
+    #[cfg(any(feature = "cranelift", feature = "winch"))]
+    pub fn cranelift_pcc(&mut self, enable: bool) -> &mut Self {
+        let val = if enable { "true" } else { "false" };
+        self.compiler_config
+            .settings
+            .insert("enable_pcc".to_string(), val.to_string());
+        self
+    }
+
     /// Allows setting a Cranelift boolean flag or preset. This allows
     /// fine-tuning of Cranelift settings.
     ///
@@ -971,7 +1147,6 @@ impl Config {
     /// cause `Engine::new` fail if the flag's name does not exist, or the value is not appropriate
     /// for the flag type.
     #[cfg(any(feature = "cranelift", feature = "winch"))]
-    #[cfg_attr(nightlydoc, doc(cfg(any(feature = "cranelift", feature = "winch"))))]
     pub unsafe fn cranelift_flag_enable(&mut self, flag: &str) -> &mut Self {
         self.compiler_config.flags.insert(flag.to_string());
         self
@@ -997,7 +1172,6 @@ impl Config {
     /// For example, feature `wasm_backtrace` will set `unwind_info` to `true`, but if it's
     /// manually set to false then it will fail.
     #[cfg(any(feature = "cranelift", feature = "winch"))]
-    #[cfg_attr(nightlydoc, doc(cfg(any(feature = "cranelift", feature = "winch"))))]
     pub unsafe fn cranelift_flag_set(&mut self, name: &str, value: &str) -> &mut Self {
         self.compiler_config
             .settings
@@ -1024,7 +1198,6 @@ impl Config {
     ///
     /// [docs]: https://bytecodealliance.github.io/wasmtime/cli-cache.html
     #[cfg(feature = "cache")]
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "cache")))]
     pub fn cache_config_load(&mut self, path: impl AsRef<Path>) -> Result<&mut Self> {
         self.cache_config = CacheConfig::from_file(Some(path.as_ref()))?;
         Ok(self)
@@ -1041,7 +1214,6 @@ impl Config {
     /// This method is only available when the `cache` feature of this crate is
     /// enabled.
     #[cfg(feature = "cache")]
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "cache")))]
     pub fn disable_cache(&mut self) -> &mut Self {
         self.cache_config = CacheConfig::new_cache_disabled();
         self
@@ -1069,7 +1241,6 @@ impl Config {
     ///
     /// [docs]: https://bytecodealliance.github.io/wasmtime/cli-cache.html
     #[cfg(feature = "cache")]
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "cache")))]
     pub fn cache_config_load_default(&mut self) -> Result<&mut Self> {
         self.cache_config = CacheConfig::from_file(None)?;
         Ok(self)
@@ -1079,11 +1250,22 @@ impl Config {
     ///
     /// Custom memory creators are used when creating host `Memory` objects or when
     /// creating instance linear memories for the on-demand instance allocation strategy.
+    #[cfg(feature = "runtime")]
     pub fn with_host_memory(&mut self, mem_creator: Arc<dyn MemoryCreator>) -> &mut Self {
         self.mem_creator = Some(Arc::new(MemoryCreatorProxy(mem_creator)));
         self
     }
 
+    /// Sets a custom stack creator.
+    ///
+    /// Custom memory creators are used when creating creating async instance stacks for
+    /// the on-demand instance allocation strategy.
+    #[cfg(feature = "async")]
+    pub fn with_host_stack(&mut self, stack_creator: Arc<dyn StackCreator>) -> &mut Self {
+        self.stack_creator = Some(Arc::new(StackCreatorProxy(stack_creator)));
+        self
+    }
+
     /// Sets the instance allocation strategy to use.
     ///
     /// When using the pooling instance allocation strategy, all linear memories
@@ -1189,8 +1371,7 @@ impl Config {
     /// for pooling allocation by using memory protection; see
     /// `PoolingAllocatorConfig::memory_protection_keys` for details.
     pub fn static_memory_maximum_size(&mut self, max_size: u64) -> &mut Self {
-        let max_pages = max_size / u64::from(wasmtime_environ::WASM_PAGE_SIZE);
-        self.tunables.static_memory_bound = max_pages;
+        self.tunables.static_memory_reservation = Some(max_size);
         self
     }
 
@@ -1206,7 +1387,7 @@ impl Config {
     /// For the difference between static and dynamic memories, see the
     /// [`Config::static_memory_maximum_size`].
     pub fn static_memory_forced(&mut self, force: bool) -> &mut Self {
-        self.tunables.static_memory_bound_is_maximum = force;
+        self.tunables.static_memory_bound_is_maximum = Some(force);
         self
     }
 
@@ -1261,8 +1442,7 @@ impl Config {
     /// The `Engine::new` method will return an error if this option is smaller
     /// than the value configured for [`Config::dynamic_memory_guard_size`].
     pub fn static_memory_guard_size(&mut self, guard_size: u64) -> &mut Self {
-        let guard_size = round_up_to_pages(guard_size);
-        self.tunables.static_memory_offset_guard_size = guard_size;
+        self.tunables.static_memory_offset_guard_size = Some(guard_size);
         self
     }
 
@@ -1294,8 +1474,7 @@ impl Config {
     /// The `Engine::new` method will return an error if this option is larger
     /// than the value configured for [`Config::static_memory_guard_size`].
     pub fn dynamic_memory_guard_size(&mut self, guard_size: u64) -> &mut Self {
-        let guard_size = round_up_to_pages(guard_size);
-        self.tunables.dynamic_memory_offset_guard_size = guard_size;
+        self.tunables.dynamic_memory_offset_guard_size = Some(guard_size);
         self
     }
 
@@ -1334,7 +1513,7 @@ impl Config {
     /// For 64-bit platforms this defaults to 2GB, and for 32-bit platforms this
     /// defaults to 1MB.
     pub fn dynamic_memory_reserved_for_growth(&mut self, reserved: u64) -> &mut Self {
-        self.tunables.dynamic_memory_growth_reserve = round_up_to_pages(reserved);
+        self.tunables.dynamic_memory_growth_reserve = Some(reserved);
         self
     }
 
@@ -1359,11 +1538,24 @@ impl Config {
     ///
     /// This value defaults to `true`.
     pub fn guard_before_linear_memory(&mut self, guard: bool) -> &mut Self {
-        self.tunables.guard_before_linear_memory = guard;
+        self.tunables.guard_before_linear_memory = Some(guard);
+        self
+    }
+
+    /// Indicates whether to initialize tables lazily, so that instantiation
+    /// is fast but indirect calls are a little slower. If false, tables
+    /// are initialized eagerly during instantiation from any active element
+    /// segments that apply to them.
+    ///
+    /// ## Default
+    ///
+    /// This value defaults to `true`.
+    pub fn table_lazy_init(&mut self, table_lazy_init: bool) -> &mut Self {
+        self.tunables.table_lazy_init = Some(table_lazy_init);
         self
     }
 
-    /// Configure the version information used in serialized and deserialzied [`crate::Module`]s.
+    /// Configure the version information used in serialized and deserialized [`crate::Module`]s.
     /// This effects the behavior of [`crate::Module::serialize()`], as well as
     /// [`crate::Module::deserialize()`] and related functions.
     ///
@@ -1382,7 +1574,7 @@ impl Config {
         Ok(self)
     }
 
-    /// Configure wether wasmtime should compile a module using multiple
+    /// Configure whether wasmtime should compile a module using multiple
     /// threads.
     ///
     /// Disabling this will result in a single thread being used to compile
@@ -1390,7 +1582,6 @@ impl Config {
     ///
     /// By default parallel compilation is enabled.
     #[cfg(feature = "parallel-compilation")]
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "parallel-compilation")))]
     pub fn parallel_compilation(&mut self, parallel: bool) -> &mut Self {
         self.parallel_compilation = parallel;
         self
@@ -1406,7 +1597,7 @@ impl Config {
     /// numbers if so configured as well (and the original wasm module has DWARF
     /// debugging information present).
     pub fn generate_address_map(&mut self, generate: bool) -> &mut Self {
-        self.tunables.generate_address_map = generate;
+        self.tunables.generate_address_map = Some(generate);
         self
     }
 
@@ -1421,6 +1612,15 @@ impl Config {
     /// if a module is instantiated many times this can lower the overall memory
     /// required needed to run that module.
     ///
+    /// The main disadvantage of copy-on-write initialization, however, is that
+    /// it may be possible for highly-parallel scenarios to be less scalable. If
+    /// a page is read initially by a WebAssembly module then that page will be
+    /// mapped to a read-only copy shared between all WebAssembly instances. If
+    /// the same page is then written, however, then a private copy is created
+    /// and swapped out from the read-only version. This also requires an [IPI],
+    /// however, which can be a significant bottleneck in high-parallelism
+    /// situations.
+    ///
     /// This feature is only applicable when a WebAssembly module meets specific
     /// criteria to be initialized in this fashion, such as:
     ///
@@ -1449,6 +1649,7 @@ impl Config {
     ///
     /// [`Module::deserialize_file`]: crate::Module::deserialize_file
     /// [`Module`]: crate::Module
+    /// [IPI]: https://en.wikipedia.org/wiki/Inter-processor_interrupt
     pub fn memory_init_cow(&mut self, enable: bool) -> &mut Self {
         self.memory_init_cow = enable;
         self
@@ -1483,6 +1684,7 @@ impl Config {
     /// the anyhow::Error when a trap is raised.
     ///
     /// This option is disabled by default.
+    #[cfg(feature = "coredump")]
     pub fn coredump_on_trap(&mut self, enable: bool) -> &mut Self {
         self.coredump_on_trap = enable;
         self
@@ -1538,13 +1740,162 @@ impl Config {
         self
     }
 
-    pub(crate) fn validate(&self) -> Result<()> {
-        if self.features.reference_types && !self.features.bulk_memory {
+    /// Returns the set of features that the currently selected compiler backend
+    /// does not support at all and may panic on.
+    ///
+    /// Wasmtime strives to reject unknown modules or unsupported modules with
+    /// first-class errors instead of panics. Not all compiler backends have the
+    /// same level of feature support on all platforms as well. This method
+    /// returns a set of features that the currently selected compiler
+    /// configuration is known to not support and may panic on. This acts as a
+    /// first-level filter on incoming wasm modules/configuration to fail-fast
+    /// instead of panicking later on.
+    ///
+    /// Note that if a feature is not listed here it does not mean that the
+    /// backend fully supports the proposal. Instead that means that the backend
+    /// doesn't ever panic on the proposal, but errors during compilation may
+    /// still be returned. This means that features listed here are definitely
+    /// not supported at all, but features not listed here may still be
+    /// partially supported. For example at the time of this writing the Winch
+    /// backend partially supports simd so it's not listed here. Winch doesn't
+    /// fully support simd but unimplemented instructions just return errors.
+    fn compiler_panicking_wasm_features(&self) -> WasmFeatures {
+        #[cfg(any(feature = "cranelift", feature = "winch"))]
+        match self.compiler_config.strategy {
+            None | Some(Strategy::Cranelift) => WasmFeatures::empty(),
+            Some(Strategy::Winch) => {
+                let mut unsupported = WasmFeatures::GC
+                    | WasmFeatures::FUNCTION_REFERENCES
+                    | WasmFeatures::THREADS
+                    | WasmFeatures::RELAXED_SIMD
+                    | WasmFeatures::TAIL_CALL
+                    | WasmFeatures::GC_TYPES;
+                match self.compiler_target().architecture {
+                    target_lexicon::Architecture::Aarch64(_) => {
+                        // no support for simd on aarch64
+                        unsupported |= WasmFeatures::SIMD;
+
+                        // things like multi-table are technically supported on
+                        // winch on aarch64 but this helps gate most spec tests
+                        // by default which otherwise currently cause panics.
+                        unsupported |= WasmFeatures::REFERENCE_TYPES;
+                    }
+
+                    // Winch doesn't support other non-x64 architectures at this
+                    // time either but will return an first-class error for
+                    // them.
+                    _ => {}
+                }
+                unsupported
+            }
+            Some(Strategy::Auto) => unreachable!(),
+        }
+        #[cfg(not(any(feature = "cranelift", feature = "winch")))]
+        return WasmFeatures::empty();
+    }
+
+    /// Calculates the set of features that are enabled for this `Config`.
+    ///
+    /// This method internally will start with the an empty set of features to
+    /// avoid being tied to wasmparser's defaults. Next Wasmtime's set of
+    /// default features are added to this set, some of which are conditional
+    /// depending on crate features. Finally explicitly requested features via
+    /// `wasm_*` methods on `Config` are applied. Everything is then validated
+    /// later in `Config::validate`.
+    fn features(&self) -> WasmFeatures {
+        // Wasmtime by default supports all of the wasm 2.0 version of the
+        // specification.
+        let mut features = WasmFeatures::wasm2();
+
+        // On-by-default features that wasmtime has. Note that these are all
+        // subject to the criteria at
+        // https://docs.wasmtime.dev/contributing-implementing-wasm-proposals.html
+        features |= WasmFeatures::MULTI_MEMORY;
+        features |= WasmFeatures::RELAXED_SIMD;
+        features |= WasmFeatures::TAIL_CALL;
+        features |= WasmFeatures::EXTENDED_CONST;
+
+        // Set some features to their conditionally-enabled defaults depending
+        // on crate compile-time features.
+        features.set(WasmFeatures::GC_TYPES, cfg!(feature = "gc"));
+        features.set(WasmFeatures::THREADS, cfg!(feature = "threads"));
+        features.set(
+            WasmFeatures::COMPONENT_MODEL,
+            cfg!(feature = "component-model"),
+        );
+
+        // From the default set of proposals remove any that the current
+        // compiler backend may panic on if the module contains them.
+        features = features & !self.compiler_panicking_wasm_features();
+
+        // After wasmtime's defaults are configured then factor in user requests
+        // and disable/enable features. Note that the enable/disable sets should
+        // be disjoint.
+        debug_assert!((self.enabled_features & self.disabled_features).is_empty());
+        features &= !self.disabled_features;
+        features |= self.enabled_features;
+
+        features
+    }
+
+    fn compiler_target(&self) -> target_lexicon::Triple {
+        #[cfg(any(feature = "cranelift", feature = "winch"))]
+        {
+            let host = target_lexicon::Triple::host();
+
+            self.compiler_config
+                .target
+                .as_ref()
+                .unwrap_or(&host)
+                .clone()
+        }
+        #[cfg(not(any(feature = "cranelift", feature = "winch")))]
+        {
+            target_lexicon::Triple::host()
+        }
+    }
+
+    pub(crate) fn validate(&self) -> Result<(Tunables, WasmFeatures)> {
+        let features = self.features();
+
+        // First validate that the selected compiler backend and configuration
+        // supports the set of `features` that are enabled. This will help
+        // provide more first class errors instead of panics about unsupported
+        // features and configurations.
+        let unsupported = features & self.compiler_panicking_wasm_features();
+        if !unsupported.is_empty() {
+            for flag in WasmFeatures::FLAGS.iter() {
+                if !unsupported.contains(*flag.value()) {
+                    continue;
+                }
+                bail!(
+                    "the wasm_{} feature is not supported on this compiler configuration",
+                    flag.name().to_lowercase()
+                );
+            }
+
+            panic!("should have returned an error by now")
+        }
+
+        if features.contains(WasmFeatures::REFERENCE_TYPES)
+            && !features.contains(WasmFeatures::BULK_MEMORY)
+        {
             bail!("feature 'reference_types' requires 'bulk_memory' to be enabled");
         }
-        if self.features.threads && !self.features.bulk_memory {
+        if features.contains(WasmFeatures::THREADS) && !features.contains(WasmFeatures::BULK_MEMORY)
+        {
             bail!("feature 'threads' requires 'bulk_memory' to be enabled");
         }
+        if features.contains(WasmFeatures::FUNCTION_REFERENCES)
+            && !features.contains(WasmFeatures::REFERENCE_TYPES)
+        {
+            bail!("feature 'function_references' requires 'reference_types' to be enabled");
+        }
+        if features.contains(WasmFeatures::GC)
+            && !features.contains(WasmFeatures::FUNCTION_REFERENCES)
+        {
+            bail!("feature 'gc' requires 'function_references' to be enabled");
+        }
         #[cfg(feature = "async")]
         if self.async_support && self.max_wasm_stack > self.async_stack_size {
             bail!("max_wasm_stack size cannot exceed the async_stack_size");
@@ -1552,72 +1903,139 @@ impl Config {
         if self.max_wasm_stack == 0 {
             bail!("max_wasm_stack size cannot be zero");
         }
-        if self.tunables.static_memory_offset_guard_size
-            < self.tunables.dynamic_memory_offset_guard_size
-        {
-            bail!("static memory guard size cannot be smaller than dynamic memory guard size");
-        }
         #[cfg(not(feature = "wmemcheck"))]
         if self.wmemcheck {
             bail!("wmemcheck (memory checker) was requested but is not enabled in this build");
         }
 
-        Ok(())
+        #[cfg(not(any(feature = "cranelift", feature = "winch")))]
+        let mut tunables = Tunables::default_host();
+        #[cfg(any(feature = "cranelift", feature = "winch"))]
+        let mut tunables = match &self.compiler_config.target.as_ref() {
+            Some(target) => Tunables::default_for_target(target)?,
+            None => Tunables::default_host(),
+        };
+
+        macro_rules! set_fields {
+            ($($field:ident)*) => (
+                let ConfigTunables {
+                    $($field,)*
+                } = &self.tunables;
+
+                $(
+                    if let Some(e) = $field {
+                        tunables.$field = *e;
+                    }
+                )*
+            )
+        }
+
+        set_fields! {
+            static_memory_reservation
+            static_memory_offset_guard_size
+            dynamic_memory_offset_guard_size
+            dynamic_memory_growth_reserve
+            generate_native_debuginfo
+            parse_wasm_debuginfo
+            consume_fuel
+            epoch_interruption
+            static_memory_bound_is_maximum
+            guard_before_linear_memory
+            table_lazy_init
+            generate_address_map
+            debug_adapter_modules
+            relaxed_simd_deterministic
+        }
+
+        // If we're going to compile with winch, we must use the winch calling convention.
+        #[cfg(any(feature = "cranelift", feature = "winch"))]
+        {
+            tunables.winch_callable = self.compiler_config.strategy == Some(Strategy::Winch);
+
+            if tunables.winch_callable && !tunables.table_lazy_init {
+                bail!("Winch requires the table-lazy-init configuration option");
+            }
+        }
+
+        if tunables.static_memory_offset_guard_size < tunables.dynamic_memory_offset_guard_size {
+            bail!("static memory guard size cannot be smaller than dynamic memory guard size");
+        }
+
+        Ok((tunables, features))
     }
 
-    pub(crate) fn build_allocator(&self) -> Result<Box<dyn InstanceAllocator + Send + Sync>> {
+    #[cfg(feature = "runtime")]
+    pub(crate) fn build_allocator(
+        &self,
+        tunables: &Tunables,
+    ) -> Result<Box<dyn InstanceAllocator + Send + Sync>> {
         #[cfg(feature = "async")]
         let stack_size = self.async_stack_size;
 
         #[cfg(not(feature = "async"))]
         let stack_size = 0;
 
+        let _ = tunables;
+
         match &self.allocation_strategy {
-            InstanceAllocationStrategy::OnDemand => Ok(Box::new(OnDemandInstanceAllocator::new(
-                self.mem_creator.clone(),
-                stack_size,
-            ))),
+            InstanceAllocationStrategy::OnDemand => {
+                #[allow(unused_mut)]
+                let mut allocator = Box::new(OnDemandInstanceAllocator::new(
+                    self.mem_creator.clone(),
+                    stack_size,
+                ));
+                #[cfg(feature = "async")]
+                if let Some(stack_creator) = &self.stack_creator {
+                    allocator.set_stack_creator(stack_creator.clone());
+                }
+                Ok(allocator)
+            }
             #[cfg(feature = "pooling-allocator")]
             InstanceAllocationStrategy::Pooling(config) => {
                 let mut config = config.config;
                 config.stack_size = stack_size;
-                Ok(Box::new(wasmtime_runtime::PoolingInstanceAllocator::new(
-                    &config,
-                    &self.tunables,
+                Ok(Box::new(crate::runtime::vm::PoolingInstanceAllocator::new(
+                    &config, tunables,
                 )?))
             }
         }
     }
 
+    #[cfg(feature = "runtime")]
+    pub(crate) fn build_gc_runtime(&self) -> Result<Arc<dyn GcRuntime>> {
+        Ok(Arc::new(crate::runtime::vm::default_gc_runtime()) as Arc<dyn GcRuntime>)
+    }
+
+    #[cfg(feature = "runtime")]
     pub(crate) fn build_profiler(&self) -> Result<Box<dyn ProfilingAgent>> {
         Ok(match self.profiling_strategy {
-            ProfilingStrategy::PerfMap => profiling::new_perfmap()?,
-            ProfilingStrategy::JitDump => profiling::new_jitdump()?,
-            ProfilingStrategy::VTune => profiling::new_vtune()?,
-            ProfilingStrategy::None => profiling::new_null(),
+            ProfilingStrategy::PerfMap => profiling_agent::new_perfmap()?,
+            ProfilingStrategy::JitDump => profiling_agent::new_jitdump()?,
+            ProfilingStrategy::VTune => profiling_agent::new_vtune()?,
+            ProfilingStrategy::None => profiling_agent::new_null(),
         })
     }
 
     #[cfg(any(feature = "cranelift", feature = "winch"))]
-    pub(crate) fn build_compiler(mut self) -> Result<(Self, Box<dyn wasmtime_environ::Compiler>)> {
+    pub(crate) fn build_compiler(
+        mut self,
+        tunables: &Tunables,
+        features: WasmFeatures,
+    ) -> Result<(Self, Box<dyn wasmtime_environ::Compiler>)> {
+        let target = self.compiler_config.target.clone();
+
         let mut compiler = match self.compiler_config.strategy {
             #[cfg(feature = "cranelift")]
-            Strategy::Auto => wasmtime_cranelift::builder(),
-            #[cfg(all(feature = "winch", not(feature = "cranelift")))]
-            Strategy::Auto => wasmtime_winch::builder(),
-            #[cfg(feature = "cranelift")]
-            Strategy::Cranelift => wasmtime_cranelift::builder(),
+            Some(Strategy::Cranelift) => wasmtime_cranelift::builder(target)?,
             #[cfg(not(feature = "cranelift"))]
-            Strategy::Cranelift => bail!("cranelift support not compiled in"),
+            Some(Strategy::Cranelift) => bail!("cranelift support not compiled in"),
             #[cfg(feature = "winch")]
-            Strategy::Winch => wasmtime_winch::builder(),
+            Some(Strategy::Winch) => wasmtime_winch::builder(target)?,
             #[cfg(not(feature = "winch"))]
-            Strategy::Winch => bail!("winch support not compiled in"),
-        };
+            Some(Strategy::Winch) => bail!("winch support not compiled in"),
 
-        if let Some(target) = &self.compiler_config.target {
-            compiler.target(target.clone())?;
-        }
+            None | Some(Strategy::Auto) => unreachable!(),
+        };
 
         if let Some(path) = &self.compiler_config.clif_dir {
             compiler.clif_dir(path)?;
@@ -1630,13 +2048,7 @@ impl Config {
             .settings
             .insert("probestack_strategy".into(), "inline".into());
 
-        let host = target_lexicon::Triple::host();
-        let target = self
-            .compiler_config
-            .target
-            .as_ref()
-            .unwrap_or(&host)
-            .clone();
+        let target = self.compiler_target();
 
         // On supported targets, we enable stack probing by default.
         // This is required on Windows because of the way Windows
@@ -1649,14 +2061,6 @@ impl Config {
                 .insert("enable_probestack".into());
         }
 
-        if self.features.tail_call {
-            ensure!(
-                target.architecture != Architecture::S390x,
-                "Tail calls are not supported on s390x yet: \
-                 https://github.com/bytecodealliance/wasmtime/issues/6530"
-            );
-        }
-
         if let Some(unwind_requested) = self.native_unwind_info {
             if !self
                 .compiler_config
@@ -1683,7 +2087,7 @@ impl Config {
             .insert("preserve_frame_pointers".into(), "true".into());
 
         // check for incompatible compiler options and set required values
-        if self.features.reference_types {
+        if features.contains(WasmFeatures::REFERENCE_TYPES) {
             if !self
                 .compiler_config
                 .ensure_setting_unset_or_given("enable_safepoints", "true")
@@ -1692,7 +2096,7 @@ impl Config {
             }
         }
 
-        if self.features.relaxed_simd && !self.features.simd {
+        if features.contains(WasmFeatures::RELAXED_SIMD) && !features.contains(WasmFeatures::SIMD) {
             bail!("cannot disable the simd proposal but enable the relaxed simd proposal");
         }
 
@@ -1704,11 +2108,12 @@ impl Config {
             compiler.enable(flag)?;
         }
 
+        #[cfg(feature = "incremental-cache")]
         if let Some(cache_store) = &self.compiler_config.cache_store {
             compiler.enable_incremental_compilation(cache_store.clone())?;
         }
 
-        compiler.set_tunables(self.tunables.clone())?;
+        compiler.set_tunables(tunables.clone())?;
         compiler.wmemcheck(self.compiler_config.wmemcheck);
 
         Ok((self, compiler.build()?))
@@ -1719,7 +2124,7 @@ impl Config {
     /// then are necessary.
     #[cfg(feature = "component-model")]
     pub fn debug_adapter_modules(&mut self, debug: bool) -> &mut Self {
-        self.tunables.debug_adapter_modules = debug;
+        self.tunables.debug_adapter_modules = Some(debug);
         self
     }
 
@@ -1761,14 +2166,43 @@ impl Config {
         self.macos_use_mach_ports = mach_ports;
         self
     }
-}
 
-fn round_up_to_pages(val: u64) -> u64 {
-    let page_size = wasmtime_runtime::page_size() as u64;
-    debug_assert!(page_size.is_power_of_two());
-    val.checked_add(page_size - 1)
-        .map(|val| val & !(page_size - 1))
-        .unwrap_or(u64::MAX / page_size + 1)
+    /// Configures an embedder-provided function, `detect`, which is used to
+    /// determine if an ISA-specific feature is available on the current host.
+    ///
+    /// This function is used to verify that any features enabled for a compiler
+    /// backend, such as AVX support on x86\_64, are also available on the host.
+    /// It is undefined behavior to execute an AVX instruction on a host that
+    /// doesn't support AVX instructions, for example.
+    ///
+    /// When the `std` feature is active on this crate then this function is
+    /// configured to a default implementation that uses the standard library's
+    /// feature detection. When the `std` feature is disabled then there is no
+    /// default available and this method must be called to configure a feature
+    /// probing function.
+    ///
+    /// The `detect` function provided is given a string name of an ISA feature.
+    /// The function should then return:
+    ///
+    /// * `Some(true)` - indicates that the feature was found on the host and it
+    ///   is supported.
+    /// * `Some(false)` - the feature name was recognized but it was not
+    ///   detected on the host, for example the CPU is too old.
+    /// * `None` - the feature name was not recognized and it's not known
+    ///   whether it's on the host or not.
+    ///
+    /// Feature names passed to `detect` match the same feature name used in the
+    /// Rust standard library. For example `"sse4.2"` is used on x86\_64.
+    ///
+    /// # Unsafety
+    ///
+    /// This function is `unsafe` because it is undefined behavior to execute
+    /// instructions that a host does not support. This means that the result of
+    /// `detect` must be correct for memory safe execution at runtime.
+    pub unsafe fn detect_host_feature(&mut self, detect: fn(&str) -> Option<bool>) -> &mut Self {
+        self.detect_host_feature = Some(detect);
+        self
+    }
 }
 
 impl Default for Config {
@@ -1780,40 +2214,42 @@ impl Default for Config {
 impl fmt::Debug for Config {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let mut f = f.debug_struct("Config");
-        f.field("debug_info", &self.tunables.generate_native_debuginfo)
-            .field("parse_wasm_debuginfo", &self.tunables.parse_wasm_debuginfo)
-            .field("wasm_threads", &self.features.threads)
-            .field("wasm_reference_types", &self.features.reference_types)
-            .field(
-                "wasm_function_references",
-                &self.features.function_references,
-            )
-            .field("wasm_bulk_memory", &self.features.bulk_memory)
-            .field("wasm_simd", &self.features.simd)
-            .field("wasm_relaxed_simd", &self.features.relaxed_simd)
-            .field("wasm_multi_value", &self.features.multi_value)
-            .field(
-                "static_memory_maximum_size",
-                &(u64::from(self.tunables.static_memory_bound)
-                    * u64::from(wasmtime_environ::WASM_PAGE_SIZE)),
-            )
-            .field(
-                "static_memory_guard_size",
-                &self.tunables.static_memory_offset_guard_size,
-            )
-            .field(
-                "dynamic_memory_guard_size",
-                &self.tunables.dynamic_memory_offset_guard_size,
-            )
-            .field(
-                "guard_before_linear_memory",
-                &self.tunables.guard_before_linear_memory,
-            )
-            .field("parallel_compilation", &self.parallel_compilation);
+        f.field("debug_info", &self.tunables.generate_native_debuginfo);
+
+        // Not every flag in WasmFeatures can be enabled as part of creating
+        // a Config. This impl gives a complete picture of all WasmFeatures
+        // enabled, and doesn't require maintenance by hand (which has become out
+        // of date in the past), at the cost of possible confusion for why
+        // a flag in this set doesn't have a Config setter.
+        let features = self.features();
+        for flag in WasmFeatures::FLAGS.iter() {
+            f.field(
+                &format!("wasm_{}", flag.name().to_lowercase()),
+                &features.contains(*flag.value()),
+            );
+        }
+
+        f.field("parallel_compilation", &self.parallel_compilation);
         #[cfg(any(feature = "cranelift", feature = "winch"))]
         {
             f.field("compiler_config", &self.compiler_config);
         }
+
+        if let Some(enable) = self.tunables.parse_wasm_debuginfo {
+            f.field("parse_wasm_debuginfo", &enable);
+        }
+        if let Some(size) = self.tunables.static_memory_reservation {
+            f.field("static_memory_maximum_reservation", &size);
+        }
+        if let Some(size) = self.tunables.static_memory_offset_guard_size {
+            f.field("static_memory_guard_size", &size);
+        }
+        if let Some(size) = self.tunables.dynamic_memory_offset_guard_size {
+            f.field("dynamic_memory_guard_size", &size);
+        }
+        if let Some(enable) = self.tunables.guard_before_linear_memory {
+            f.field("guard_before_linear_memory", &enable);
+        }
         f.finish()
     }
 }
@@ -1822,7 +2258,7 @@ impl fmt::Debug for Config {
 ///
 /// This is used as an argument to the [`Config::strategy`] method.
 #[non_exhaustive]
-#[derive(Clone, Debug, Copy)]
+#[derive(PartialEq, Eq, Clone, Debug, Copy)]
 pub enum Strategy {
     /// An indicator that the compilation strategy should be automatically
     /// selected.
@@ -1844,6 +2280,23 @@ pub enum Strategy {
     Winch,
 }
 
+impl Strategy {
+    fn not_auto(&self) -> Option<Strategy> {
+        match self {
+            Strategy::Auto => {
+                if cfg!(feature = "cranelift") {
+                    Some(Strategy::Cranelift)
+                } else if cfg!(feature = "winch") {
+                    Some(Strategy::Winch)
+                } else {
+                    None
+                }
+            }
+            other => Some(*other),
+        }
+    }
+}
+
 /// Possible optimization levels for the Cranelift codegen backend.
 #[non_exhaustive]
 #[derive(Copy, Clone, Debug, Serialize, Deserialize, Eq, PartialEq)]
@@ -1896,10 +2349,95 @@ pub enum WasmBacktraceDetails {
 ///
 /// This structure has a builder-style API in the same manner as [`Config`] and
 /// is configured with [`Config::allocation_strategy`].
+///
+/// Note that usage of the pooling allocator does not affect compiled
+/// WebAssembly code. Compiled `*.cwasm` files, for example, are usable both
+/// with and without the pooling allocator.
+///
+/// ## Advantages of Pooled Allocation
+///
+/// The main benefit of the pooling allocator is to make WebAssembly
+/// instantiation both faster and more scalable in terms of parallelism.
+/// Allocation is faster because virtual memory is already configured and ready
+/// to go within the pool, there's no need to [`mmap`] (for example on Unix) a
+/// new region and configure it with guard pages. By avoiding [`mmap`] this
+/// avoids whole-process virtual memory locks which can improve scalability and
+/// performance through avoiding this.
+///
+/// Additionally with pooled allocation it's possible to create "affine slots"
+/// to a particular WebAssembly module or component over time. For example if
+/// the same module is multiple times over time the pooling allocator will, by
+/// default, attempt to reuse the same slot. This mean that the slot has been
+/// pre-configured and can retain virtual memory mappings for a copy-on-write
+/// image, for example (see [`Config::memory_init_cow`] for more information.
+/// This means that in a steady state instance deallocation is a single
+/// [`madvise`] to reset linear memory to its original contents followed by a
+/// single (optional) [`mprotect`] during the next instantiation to shrink
+/// memory back to its original size. Compared to non-pooled allocation this
+/// avoids the need to [`mmap`] a new region of memory, [`munmap`] it, and
+/// [`mprotect`] regions too.
+///
+/// Another benefit of pooled allocation is that it's possible to configure
+/// things such that no virtual memory management is required at all in a steady
+/// state. For example a pooling allocator can be configured with
+/// [`Config::memory_init_cow`] disabledd, dynamic bounds checks enabled
+/// through
+/// [`Config::static_memory_maximum_size(0)`](Config::static_memory_maximum_size),
+/// and sufficient space through
+/// [`PoolingAllocationConfig::table_keep_resident`] /
+/// [`PoolingAllocationConfig::linear_memory_keep_resident`]. With all these
+/// options in place no virtual memory tricks are used at all and everything is
+/// manually managed by Wasmtime (for example resetting memory is a
+/// `memset(0)`). This is not as fast in a single-threaded scenario but can
+/// provide benefits in high-parallelism situations as no virtual memory locks
+/// or IPIs need happen.
+///
+/// ## Disadvantages of Pooled Allocation
+///
+/// Despite the above advantages to instantiation performance the pooling
+/// allocator is not enabled by default in Wasmtime. One reason is that the
+/// performance advantages are not necessarily portable, for example while the
+/// pooling allocator works on Windows it has not been tuned for performance on
+/// Windows in the same way it has on Linux.
+///
+/// Additionally the main cost of the pooling allocator is that it requires a
+/// very large reservation of virtual memory (on the order of most of the
+/// addressable virtual address space). WebAssembly 32-bit linear memories in
+/// Wasmtime are, by default 4G address space reservations with a 2G guard
+/// region both before and after the linear memory. Memories in the pooling
+/// allocator are contiguous which means that we only need a guard after linear
+/// memory because the previous linear memory's slot post-guard is our own
+/// pre-guard. This means that, by default, the pooling allocator uses 6G of
+/// virtual memory per WebAssembly linear memory slot. 6G of virtual memory is
+/// 32.5 bits of a 64-bit address. Many 64-bit systems can only actually use
+/// 48-bit addresses by default (although this can be extended on architectures
+/// nowadays too), and of those 48 bits one of them is reserved to indicate
+/// kernel-vs-userspace. This leaves 47-32.5=14.5 bits left, meaning you can
+/// only have at most 64k slots of linear memories on many systems by default.
+/// This is a relatively small number and shows how the pooling allocator can
+/// quickly exhaust all of virtual memory.
+///
+/// Another disadvantage of the pooling allocator is that it may keep memory
+/// alive when nothing is using it. A previously used slot for an instance might
+/// have paged-in memory that will not get paged out until the
+/// [`Engine`](crate::Engine) owning the pooling allocator is dropped. While
+/// suitable for some applications this behavior may not be suitable for all
+/// applications.
+///
+/// Finally the last disadvantage of the pooling allocator is that the
+/// configuration values for the maximum number of instances, memories, tables,
+/// etc, must all be fixed up-front. There's not always a clear answer as to
+/// what these values should be so not all applications may be able to work
+/// with this constraint.
+///
+/// [`madvise`]: https://man7.org/linux/man-pages/man2/madvise.2.html
+/// [`mprotect`]: https://man7.org/linux/man-pages/man2/mprotect.2.html
+/// [`mmap`]: https://man7.org/linux/man-pages/man2/mmap.2.html
+/// [`munmap`]: https://man7.org/linux/man-pages/man2/munmap.2.html
 #[cfg(feature = "pooling-allocator")]
 #[derive(Debug, Clone, Default)]
 pub struct PoolingAllocationConfig {
-    config: wasmtime_runtime::PoolingInstanceAllocatorConfig,
+    config: crate::runtime::vm::PoolingInstanceAllocatorConfig,
 }
 
 #[cfg(feature = "pooling-allocator")]
@@ -1960,6 +2498,20 @@ impl PoolingAllocationConfig {
         self
     }
 
+    /// The target number of decommits to do per batch.
+    ///
+    /// This is not precise, as we can queue up decommits at times when we
+    /// aren't prepared to immediately flush them, and so we may go over this
+    /// target size occasionally.
+    ///
+    /// A batch size of one effectively disables batching.
+    ///
+    /// Defaults to `1`.
+    pub fn decommit_batch_size(&mut self, batch_size: usize) -> &mut Self {
+        self.config.decommit_batch_size = batch_size;
+        self
+    }
+
     /// Configures whether or not stacks used for async futures are reset to
     /// zero after usage.
     ///
@@ -1980,7 +2532,6 @@ impl PoolingAllocationConfig {
     ///
     /// [`call_async`]: crate::TypedFunc::call_async
     #[cfg(feature = "async")]
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "async")))]
     pub fn async_stack_zeroing(&mut self, enable: bool) -> &mut Self {
         self.config.async_stack_zeroing = enable;
         self
@@ -1998,9 +2549,7 @@ impl PoolingAllocationConfig {
     /// Note that when using this option the memory with async stacks will
     /// never be decommitted.
     #[cfg(feature = "async")]
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "async")))]
     pub fn async_stack_keep_resident(&mut self, size: usize) -> &mut Self {
-        let size = round_up_to_pages(size as u64) as usize;
         self.config.async_stack_keep_resident = size;
         self
     }
@@ -2017,7 +2566,6 @@ impl PoolingAllocationConfig {
     /// which can, in some configurations, reduce the number of page faults
     /// taken when a slot is reused.
     pub fn linear_memory_keep_resident(&mut self, size: usize) -> &mut Self {
-        let size = round_up_to_pages(size as u64) as usize;
         self.config.linear_memory_keep_resident = size;
         self
     }
@@ -2032,7 +2580,6 @@ impl PoolingAllocationConfig {
     /// [`PoolingAllocationConfig::linear_memory_keep_resident`] except that it
     /// is applicable to tables instead.
     pub fn table_keep_resident(&mut self, size: usize) -> &mut Self {
-        let size = round_up_to_pages(size as u64) as usize;
         self.config.table_keep_resident = size;
         self
     }
@@ -2253,7 +2800,7 @@ impl PoolingAllocationConfig {
     }
 
     /// The maximum table elements for any table defined in a module (default is
-    /// `10000`).
+    /// `20000`).
     ///
     /// If a table's minimum element limit is greater than this value, the
     /// module will fail to instantiate.
@@ -2285,27 +2832,31 @@ impl PoolingAllocationConfig {
         self
     }
 
-    /// The maximum number of Wasm pages for any linear memory defined in a
-    /// module (default is `160`).
+    /// The maximum byte size that any WebAssembly linear memory may grow to.
     ///
-    /// The default of `160` means at most 10 MiB of host memory may be
-    /// committed for each instance.
+    /// This option defaults to 4 GiB meaning that for 32-bit linear memories
+    /// there is no restrictions. 64-bit linear memories will not be allowed to
+    /// grow beyond 4 GiB by default.
     ///
-    /// If a memory's minimum page limit is greater than this value, the module
-    /// will fail to instantiate.
+    /// If a memory's minimum size is greater than this value, the module will
+    /// fail to instantiate.
     ///
-    /// If a memory's maximum page limit is unbounded or greater than this
-    /// value, the maximum will be `memory_pages` for the purpose of any
-    /// `memory.grow` instruction.
+    /// If a memory's maximum size is unbounded or greater than this value, the
+    /// maximum will be `max_memory_size` for the purpose of any `memory.grow`
+    /// instruction.
     ///
     /// This value is used to control the maximum accessible space for each
-    /// linear memory of a core instance.
+    /// linear memory of a core instance. This can be thought of as a simple
+    /// mechanism like [`Store::limiter`](crate::Store::limiter) to limit memory
+    /// at runtime. This value can also affect striping/coloring behavior when
+    /// used in conjunction with
+    /// [`memory_protection_keys`](PoolingAllocationConfig::memory_protection_keys).
     ///
-    /// The reservation size of each linear memory is controlled by the
-    /// `static_memory_maximum_size` setting and this value cannot exceed the
-    /// configured static memory maximum size.
-    pub fn memory_pages(&mut self, pages: u64) -> &mut Self {
-        self.config.limits.memory_pages = pages;
+    /// The virtual memory reservation size of each linear memory is controlled
+    /// by the [`Config::static_memory_maximum_size`] setting and this method's
+    /// configuration cannot exceed [`Config::static_memory_maximum_size`].
+    pub fn max_memory_size(&mut self, bytes: usize) -> &mut Self {
+        self.config.limits.max_memory_size = bytes;
         self
     }
 
@@ -2320,6 +2871,11 @@ impl PoolingAllocationConfig {
     /// regions are accessible each time executions switches from host to guest
     /// (or vice versa).
     ///
+    /// Leveraging MPK requires configuring a smaller-than-default
+    /// [`max_memory_size`](PoolingAllocationConfig::max_memory_size) to enable
+    /// this coloring/striping behavior. For example embeddings might want to
+    /// reduce the default 4G allowance to 128M.
+    ///
     /// MPK is only available on Linux (called `pku` there) and recent x86
     /// systems; we check for MPK support at runtime by examining the `CPUID`
     /// register. This configuration setting can be in three states:
@@ -2330,25 +2886,60 @@ impl PoolingAllocationConfig {
     ///   supported
     /// - `disable`: never use MPK
     ///
-    /// By default this value is `disabled`, but may become `auto` in future releases.
+    /// By default this value is `disabled`, but may become `auto` in future
+    /// releases.
     ///
     /// __WARNING__: this configuration options is still experimental--use at
     /// your own risk! MPK uses kernel and CPU features to protect memory
     /// regions; you may observe segmentation faults if anything is
     /// misconfigured.
+    #[cfg(feature = "memory-protection-keys")]
     pub fn memory_protection_keys(&mut self, enable: MpkEnabled) -> &mut Self {
         self.config.memory_protection_keys = enable;
         self
     }
 
+    /// Sets an upper limit on how many memory protection keys (MPK) Wasmtime
+    /// will use.
+    ///
+    /// This setting is only applicable when
+    /// [`PoolingAllocationConfig::memory_protection_keys`] is set to `enable`
+    /// or `auto`. Configuring this above the HW and OS limits (typically 15)
+    /// has no effect.
+    ///
+    /// If multiple Wasmtime engines are used in the same process, note that all
+    /// engines will share the same set of allocated keys; this setting will
+    /// limit how many keys are allocated initially and thus available to all
+    /// other engines.
+    #[cfg(feature = "memory-protection-keys")]
+    pub fn max_memory_protection_keys(&mut self, max: usize) -> &mut Self {
+        self.config.max_memory_protection_keys = max;
+        self
+    }
+
     /// Check if memory protection keys (MPK) are available on the current host.
     ///
     /// This is a convenience method for determining MPK availability using the
     /// same method that [`MpkEnabled::Auto`] does. See
     /// [`PoolingAllocationConfig::memory_protection_keys`] for more
     /// information.
-    pub fn are_memory_protection_keys_available(&self) -> bool {
-        mpk::is_supported()
+    #[cfg(feature = "memory-protection-keys")]
+    pub fn are_memory_protection_keys_available() -> bool {
+        crate::runtime::vm::mpk::is_supported()
+    }
+
+    /// The maximum number of concurrent GC heaps supported (default is `1000`).
+    ///
+    /// This value has a direct impact on the amount of memory allocated by the
+    /// pooling instance allocator.
+    ///
+    /// The pooling instance allocator allocates a GC heap pool, where each
+    /// entry in the pool contains the space needed for each GC heap used by a
+    /// store.
+    #[cfg(feature = "gc")]
+    pub fn total_gc_heaps(&mut self, count: u32) -> &mut Self {
+        self.config.limits.total_gc_heaps = count;
+        self
     }
 }
 
@@ -2358,3 +2949,73 @@ pub(crate) fn probestack_supported(arch: Architecture) -> bool {
         Architecture::X86_64 | Architecture::Aarch64(_) | Architecture::Riscv64(_)
     )
 }
+
+#[cfg(feature = "std")]
+fn detect_host_feature(feature: &str) -> Option<bool> {
+    #[cfg(target_arch = "aarch64")]
+    {
+        return match feature {
+            "lse" => Some(std::arch::is_aarch64_feature_detected!("lse")),
+            "paca" => Some(std::arch::is_aarch64_feature_detected!("paca")),
+            "fp16" => Some(std::arch::is_aarch64_feature_detected!("fp16")),
+
+            _ => None,
+        };
+    }
+
+    // There is no is_s390x_feature_detected macro yet, so for now
+    // we use getauxval from the libc crate directly.
+    #[cfg(all(target_arch = "s390x", target_os = "linux"))]
+    {
+        let v = unsafe { libc::getauxval(libc::AT_HWCAP) };
+        const HWCAP_S390X_VXRS_EXT2: libc::c_ulong = 32768;
+
+        return match feature {
+            // There is no separate HWCAP bit for mie2, so assume
+            // that any machine with vxrs_ext2 also has mie2.
+            "vxrs_ext2" | "mie2" => Some((v & HWCAP_S390X_VXRS_EXT2) != 0),
+
+            _ => None,
+        };
+    }
+
+    #[cfg(target_arch = "riscv64")]
+    {
+        return match feature {
+            // due to `is_riscv64_feature_detected` is not stable.
+            // we cannot use it. For now lie and say all features are always
+            // found to keep tests working.
+            _ => Some(true),
+        };
+    }
+
+    #[cfg(target_arch = "x86_64")]
+    {
+        return match feature {
+            "sse3" => Some(std::is_x86_feature_detected!("sse3")),
+            "ssse3" => Some(std::is_x86_feature_detected!("ssse3")),
+            "sse4.1" => Some(std::is_x86_feature_detected!("sse4.1")),
+            "sse4.2" => Some(std::is_x86_feature_detected!("sse4.2")),
+            "popcnt" => Some(std::is_x86_feature_detected!("popcnt")),
+            "avx" => Some(std::is_x86_feature_detected!("avx")),
+            "avx2" => Some(std::is_x86_feature_detected!("avx2")),
+            "fma" => Some(std::is_x86_feature_detected!("fma")),
+            "bmi1" => Some(std::is_x86_feature_detected!("bmi1")),
+            "bmi2" => Some(std::is_x86_feature_detected!("bmi2")),
+            "avx512bitalg" => Some(std::is_x86_feature_detected!("avx512bitalg")),
+            "avx512dq" => Some(std::is_x86_feature_detected!("avx512dq")),
+            "avx512f" => Some(std::is_x86_feature_detected!("avx512f")),
+            "avx512vl" => Some(std::is_x86_feature_detected!("avx512vl")),
+            "avx512vbmi" => Some(std::is_x86_feature_detected!("avx512vbmi")),
+            "lzcnt" => Some(std::is_x86_feature_detected!("lzcnt")),
+
+            _ => None,
+        };
+    }
+
+    #[allow(unreachable_code)]
+    {
+        let _ = feature;
+        return None;
+    }
+}
diff --git a/crates/wasmtime/src/coredump.rs b/crates/wasmtime/src/coredump.rs
deleted file mode 100644
index 3193364eae89..000000000000
--- a/crates/wasmtime/src/coredump.rs
+++ /dev/null
@@ -1,313 +0,0 @@
-use std::{collections::HashMap, fmt};
-
-use crate::{
-    store::StoreOpaque, AsContextMut, FrameInfo, Global, Instance, Memory, Module, StoreContextMut,
-    Val, ValType, WasmBacktrace,
-};
-
-/// Representation of a core dump of a WebAssembly module
-///
-/// When the Config::coredump_on_trap option is enabled this structure is
-/// attached to the [`anyhow::Error`] returned from many Wasmtime functions that
-/// execute WebAssembly such as [`Instance::new`] or [`Func::call`]. This can be
-/// acquired with the [`anyhow::Error::downcast`] family of methods to
-/// programmatically inspect the coredump. Otherwise since it's part of the
-/// error returned this will get printed along with the rest of the error when
-/// the error is logged.
-///
-/// Note that some state, such as Wasm locals or values on the operand stack,
-/// may be optimized away by the compiler or otherwise not recovered in the
-/// coredump.
-///
-/// Capturing of wasm coredumps can be configured through the
-/// [`Config::coredump_on_trap`][crate::Config::coredump_on_trap] method.
-///
-/// For more information about errors in wasmtime see the documentation of the
-/// [`Trap`][crate::Trap] type.
-///
-/// [`Func::call`]: crate::Func::call
-/// [`Instance::new`]: crate::Instance::new
-pub struct WasmCoreDump {
-    name: String,
-    modules: Vec<Module>,
-    instances: Vec<Instance>,
-    memories: Vec<Memory>,
-    globals: Vec<Global>,
-    backtrace: WasmBacktrace,
-}
-
-impl WasmCoreDump {
-    pub(crate) fn new(store: &mut StoreOpaque, backtrace: WasmBacktrace) -> WasmCoreDump {
-        let modules: Vec<_> = store.modules().all_modules().cloned().collect();
-        let instances: Vec<Instance> = store.all_instances().collect();
-        let store_memories: Vec<Memory> = store.all_memories().collect();
-        let store_globals: Vec<Global> = store.all_globals().collect();
-
-        WasmCoreDump {
-            name: String::from("store_name"),
-            modules,
-            instances,
-            memories: store_memories,
-            globals: store_globals,
-            backtrace,
-        }
-    }
-
-    /// The stack frames for this core dump.
-    ///
-    /// Frames appear in callee to caller order, that is youngest to oldest
-    /// frames.
-    pub fn frames(&self) -> &[FrameInfo] {
-        self.backtrace.frames()
-    }
-
-    /// All modules instantiated inside the store when the core dump was
-    /// created.
-    pub fn modules(&self) -> &[Module] {
-        self.modules.as_ref()
-    }
-
-    /// All instances within the store when the core dump was created.
-    pub fn instances(&self) -> &[Instance] {
-        self.instances.as_ref()
-    }
-
-    /// All globals, instance- or host-defined, within the store when the core
-    /// dump was created.
-    pub fn globals(&self) -> &[Global] {
-        self.globals.as_ref()
-    }
-
-    /// All memories, instance- or host-defined, within the store when the core
-    /// dump was created.
-    pub fn memories(&self) -> &[Memory] {
-        self.memories.as_ref()
-    }
-
-    /// Serialize this core dump into [the standard core dump binary
-    /// format][spec].
-    ///
-    /// The `name` parameter may be a file path, URL, or arbitrary name for the
-    /// "main" Wasm service or executable that was running in this store.
-    ///
-    /// Once serialized, you can write this core dump to disk, send it over the
-    /// network, or pass it to other debugging tools that consume Wasm core
-    /// dumps.
-    ///
-    /// [spec]: https://github.com/WebAssembly/tool-conventions/blob/main/Coredump.md
-    pub fn serialize(&self, mut store: impl AsContextMut, name: &str) -> Vec<u8> {
-        let store = store.as_context_mut();
-        self._serialize(store, name)
-    }
-
-    fn _serialize<T>(&self, mut store: StoreContextMut<'_, T>, name: &str) -> Vec<u8> {
-        let mut core_dump = wasm_encoder::Module::new();
-
-        core_dump.section(&wasm_encoder::CoreDumpSection::new(name));
-
-        // A map from each memory to its index in the core dump's memories
-        // section.
-        let mut memory_to_idx = HashMap::new();
-
-        let mut data = wasm_encoder::DataSection::new();
-
-        {
-            let mut memories = wasm_encoder::MemorySection::new();
-            for mem in self.memories() {
-                let memory_idx = memories.len();
-                memory_to_idx.insert(mem.hash_key(&store.0), memory_idx);
-                let ty = mem.ty(&store);
-                memories.memory(wasm_encoder::MemoryType {
-                    minimum: mem.size(&store),
-                    maximum: ty.maximum(),
-                    memory64: ty.is_64(),
-                    shared: ty.is_shared(),
-                });
-
-                // Attach the memory data, balancing number of data segments and
-                // binary size. We don't want to attach the whole memory in one
-                // big segment, since it likely contains a bunch of large runs
-                // of zeroes. But we can't encode the data without any potential
-                // runs of zeroes (i.e. including only non-zero data in our
-                // segments) because we can run up against the implementation
-                // limits for number of segments in a Wasm module this way. So
-                // to balance these conflicting desires, we break the memory up
-                // into reasonably-sized chunks and then trim runs of zeroes
-                // from the start and end of each chunk.
-                const CHUNK_SIZE: u32 = 4096;
-                for (i, chunk) in mem
-                    .data(&store)
-                    .chunks_exact(CHUNK_SIZE as usize)
-                    .enumerate()
-                {
-                    if let Some(start) = chunk.iter().position(|byte| *byte != 0) {
-                        let end = chunk.iter().rposition(|byte| *byte != 0).unwrap() + 1;
-                        let offset = (i as u32) * CHUNK_SIZE + (start as u32);
-                        let offset = wasm_encoder::ConstExpr::i32_const(offset as i32);
-                        data.active(memory_idx, &offset, chunk[start..end].iter().copied());
-                    }
-                }
-            }
-            core_dump.section(&memories);
-        }
-
-        // A map from each global to its index in the core dump's globals
-        // section.
-        let mut global_to_idx = HashMap::new();
-
-        {
-            let mut globals = wasm_encoder::GlobalSection::new();
-            for g in self.globals() {
-                global_to_idx.insert(g.hash_key(&store.0), globals.len());
-                let ty = g.ty(&store);
-                let mutable = matches!(ty.mutability(), crate::Mutability::Var);
-                let val_type = match ty.content() {
-                    ValType::I32 => wasm_encoder::ValType::I32,
-                    ValType::I64 => wasm_encoder::ValType::I64,
-                    ValType::F32 => wasm_encoder::ValType::F32,
-                    ValType::F64 => wasm_encoder::ValType::F64,
-                    ValType::V128 => wasm_encoder::ValType::V128,
-                    ValType::FuncRef => wasm_encoder::ValType::FUNCREF,
-                    ValType::ExternRef => wasm_encoder::ValType::EXTERNREF,
-                };
-                let init = match g.get(&mut store) {
-                    Val::I32(x) => wasm_encoder::ConstExpr::i32_const(x),
-                    Val::I64(x) => wasm_encoder::ConstExpr::i64_const(x),
-                    Val::F32(x) => {
-                        wasm_encoder::ConstExpr::f32_const(unsafe { std::mem::transmute(x) })
-                    }
-                    Val::F64(x) => {
-                        wasm_encoder::ConstExpr::f64_const(unsafe { std::mem::transmute(x) })
-                    }
-                    Val::V128(x) => wasm_encoder::ConstExpr::v128_const(x.as_u128() as i128),
-                    Val::FuncRef(_) => {
-                        wasm_encoder::ConstExpr::ref_null(wasm_encoder::HeapType::Func)
-                    }
-                    Val::ExternRef(_) => {
-                        wasm_encoder::ConstExpr::ref_null(wasm_encoder::HeapType::Extern)
-                    }
-                };
-                globals.global(wasm_encoder::GlobalType { val_type, mutable }, &init);
-            }
-            core_dump.section(&globals);
-        }
-
-        core_dump.section(&data);
-        drop(data);
-
-        // A map from module id to its index within the core dump's modules
-        // section.
-        let mut module_to_index = HashMap::new();
-
-        {
-            let mut modules = wasm_encoder::CoreDumpModulesSection::new();
-            for module in self.modules() {
-                module_to_index.insert(module.id(), modules.len());
-                match module.name() {
-                    Some(name) => modules.module(name),
-                    None => modules.module(&format!("<anonymous-module-{}>", modules.len())),
-                };
-            }
-            core_dump.section(&modules);
-        }
-
-        // TODO: We can't currently recover instances from stack frames. We can
-        // recover module via the frame's PC, but if there are multiple
-        // instances of the same module, we don't know which instance the frame
-        // is associated with. Therefore, we do a best effort job: remember the
-        // last instance of each module and always choose that one. We record
-        // that information here.
-        let mut module_to_instance = HashMap::new();
-
-        {
-            let mut instances = wasm_encoder::CoreDumpInstancesSection::new();
-            for instance in self.instances() {
-                let module = instance.module(&store);
-                module_to_instance.insert(module.id(), instances.len());
-
-                let module_index = module_to_index[&module.id()];
-
-                let memories = instance
-                    .all_memories(&mut store.0)
-                    .collect::<Vec<_>>()
-                    .into_iter()
-                    .map(|(_i, memory)| memory_to_idx[&memory.hash_key(&store.0)])
-                    .collect::<Vec<_>>();
-
-                let globals = instance
-                    .all_globals(&mut store.0)
-                    .collect::<Vec<_>>()
-                    .into_iter()
-                    .map(|(_i, global)| global_to_idx[&global.hash_key(&store.0)])
-                    .collect::<Vec<_>>();
-
-                instances.instance(module_index, memories, globals);
-            }
-            core_dump.section(&instances);
-        }
-
-        {
-            let thread_name = "main";
-            let mut stack = wasm_encoder::CoreDumpStackSection::new(thread_name);
-            for frame in self.frames() {
-                // This isn't necessarily the right instance if there are
-                // multiple instances of the same module. See comment above
-                // `module_to_instance` for details.
-                let instance = module_to_instance[&frame.module().id()];
-
-                let func = frame.func_index();
-
-                let offset = frame
-                    .func_offset()
-                    .and_then(|o| u32::try_from(o).ok())
-                    .unwrap_or(0);
-
-                // We can't currently recover locals and the operand stack. We
-                // should eventually be able to do that with Winch though.
-                let locals = [];
-                let operand_stack = [];
-
-                stack.frame(instance, func, offset, locals, operand_stack);
-            }
-            core_dump.section(&stack);
-        }
-
-        core_dump.finish()
-    }
-}
-
-impl fmt::Display for WasmCoreDump {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        writeln!(f, "wasm coredump generated while executing {}:", self.name)?;
-        writeln!(f, "modules:")?;
-        for module in self.modules.iter() {
-            writeln!(f, "  {}", module.name().unwrap_or("<module>"))?;
-        }
-
-        writeln!(f, "instances:")?;
-        for instance in self.instances.iter() {
-            writeln!(f, "  {:?}", instance)?;
-        }
-
-        writeln!(f, "memories:")?;
-        for memory in self.memories.iter() {
-            writeln!(f, "  {:?}", memory)?;
-        }
-
-        writeln!(f, "globals:")?;
-        for global in self.globals.iter() {
-            writeln!(f, "  {:?}", global)?;
-        }
-
-        writeln!(f, "backtrace:")?;
-        write!(f, "{}", self.backtrace)?;
-
-        Ok(())
-    }
-}
-
-impl fmt::Debug for WasmCoreDump {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "<wasm core dump>")
-    }
-}
diff --git a/crates/wasmtime/src/engine.rs b/crates/wasmtime/src/engine.rs
index 82dd651e093d..fbd6d8aac1c3 100644
--- a/crates/wasmtime/src/engine.rs
+++ b/crates/wasmtime/src/engine.rs
@@ -1,20 +1,20 @@
-use crate::signatures::SignatureRegistry;
+use crate::prelude::*;
+#[cfg(feature = "runtime")]
+use crate::runtime::type_registry::TypeRegistry;
+#[cfg(feature = "runtime")]
+use crate::runtime::vm::GcRuntime;
+use crate::sync::OnceLock;
 use crate::Config;
-use anyhow::{Context, Result};
+use alloc::sync::Arc;
+use core::sync::atomic::{AtomicU64, Ordering};
+#[cfg(any(feature = "cranelift", feature = "winch"))]
 use object::write::{Object, StandardSegment};
 use object::SectionKind;
-use once_cell::sync::OnceCell;
-#[cfg(feature = "parallel-compilation")]
-use rayon::prelude::*;
+#[cfg(feature = "std")]
 use std::path::Path;
-use std::sync::atomic::{AtomicU64, Ordering};
-use std::sync::Arc;
-#[cfg(feature = "cache")]
-use wasmtime_cache::CacheConfig;
+use wasmparser::WasmFeatures;
 use wasmtime_environ::obj;
-use wasmtime_environ::{FlagValue, ObjectKind};
-use wasmtime_jit::{profiling::ProfilingAgent, CodeMemory};
-use wasmtime_runtime::{debug_builtins, CompiledModuleIdAllocator, InstanceAllocator, MmapVec};
+use wasmtime_environ::{FlagValue, ObjectKind, Tunables};
 
 mod serialization;
 
@@ -47,17 +47,31 @@ pub struct Engine {
 
 struct EngineInner {
     config: Config,
+    features: WasmFeatures,
+    tunables: Tunables,
     #[cfg(any(feature = "cranelift", feature = "winch"))]
     compiler: Box<dyn wasmtime_environ::Compiler>,
-    allocator: Box<dyn InstanceAllocator + Send + Sync>,
-    profiler: Box<dyn ProfilingAgent>,
-    signatures: SignatureRegistry,
+    #[cfg(feature = "runtime")]
+    allocator: Box<dyn crate::runtime::vm::InstanceAllocator + Send + Sync>,
+    #[cfg(feature = "runtime")]
+    gc_runtime: Arc<dyn GcRuntime>,
+    #[cfg(feature = "runtime")]
+    profiler: Box<dyn crate::profiling_agent::ProfilingAgent>,
+    #[cfg(feature = "runtime")]
+    signatures: TypeRegistry,
+    #[cfg(feature = "runtime")]
     epoch: AtomicU64,
-    unique_id_allocator: CompiledModuleIdAllocator,
 
-    // One-time check of whether the compiler's settings, if present, are
-    // compatible with the native host.
-    compatible_with_native_host: OnceCell<Result<(), String>>,
+    /// One-time check of whether the compiler's settings, if present, are
+    /// compatible with the native host.
+    #[cfg(any(feature = "cranelift", feature = "winch"))]
+    compatible_with_native_host: OnceLock<Result<(), String>>,
+}
+
+impl Default for Engine {
+    fn default() -> Engine {
+        Engine::new(&Config::default()).unwrap()
+    }
 }
 
 impl Engine {
@@ -74,180 +88,55 @@ impl Engine {
     /// to `true`, but explicitly disable these two compiler settings
     /// will cause errors.
     pub fn new(config: &Config) -> Result<Engine> {
-        // Ensure that wasmtime_runtime's signal handlers are configured. This
-        // is the per-program initialization required for handling traps, such
-        // as configuring signals, vectored exception handlers, etc.
-        wasmtime_runtime::init_traps(crate::module::is_wasm_trap_pc, config.macos_use_mach_ports);
-        debug_builtins::ensure_exported();
+        #[cfg(feature = "runtime")]
+        {
+            // Ensure that crate::runtime::vm's signal handlers are
+            // configured. This is the per-program initialization required for
+            // handling traps, such as configuring signals, vectored exception
+            // handlers, etc.
+            crate::runtime::vm::init_traps(config.macos_use_mach_ports);
+            #[cfg(feature = "debug-builtins")]
+            crate::runtime::vm::debug_builtins::ensure_exported();
+        }
 
-        let registry = SignatureRegistry::new();
         let config = config.clone();
-        config.validate()?;
+        let (tunables, features) = config.validate()?;
 
         #[cfg(any(feature = "cranelift", feature = "winch"))]
-        let (config, compiler) = config.build_compiler()?;
-
-        let allocator = config.build_allocator()?;
-        let profiler = config.build_profiler()?;
+        let (config, compiler) = config.build_compiler(&tunables, features)?;
 
         Ok(Engine {
             inner: Arc::new(EngineInner {
                 #[cfg(any(feature = "cranelift", feature = "winch"))]
                 compiler,
-                config,
-                allocator,
-                profiler,
-                signatures: registry,
+                #[cfg(feature = "runtime")]
+                allocator: config.build_allocator(&tunables)?,
+                #[cfg(feature = "runtime")]
+                gc_runtime: config.build_gc_runtime()?,
+                #[cfg(feature = "runtime")]
+                profiler: config.build_profiler()?,
+                #[cfg(feature = "runtime")]
+                signatures: TypeRegistry::new(),
+                #[cfg(feature = "runtime")]
                 epoch: AtomicU64::new(0),
-                unique_id_allocator: CompiledModuleIdAllocator::new(),
-                compatible_with_native_host: OnceCell::new(),
+                #[cfg(any(feature = "cranelift", feature = "winch"))]
+                compatible_with_native_host: OnceLock::new(),
+                config,
+                tunables,
+                features,
             }),
         })
     }
 
-    /// Eagerly initialize thread-local functionality shared by all [`Engine`]s.
-    ///
-    /// Wasmtime's implementation on some platforms may involve per-thread
-    /// setup that needs to happen whenever WebAssembly is invoked. This setup
-    /// can take on the order of a few hundred microseconds, whereas the
-    /// overhead of calling WebAssembly is otherwise on the order of a few
-    /// nanoseconds. This setup cost is paid once per-OS-thread. If your
-    /// application is sensitive to the latencies of WebAssembly function
-    /// calls, even those that happen first on a thread, then this function
-    /// can be used to improve the consistency of each call into WebAssembly
-    /// by explicitly frontloading the cost of the one-time setup per-thread.
-    ///
-    /// Note that this function is not required to be called in any embedding.
-    /// Wasmtime will automatically initialize thread-local-state as necessary
-    /// on calls into WebAssembly. This is provided for use cases where the
-    /// latency of WebAssembly calls are extra-important, which is not
-    /// necessarily true of all embeddings.
-    pub fn tls_eager_initialize() {
-        wasmtime_runtime::tls_eager_initialize();
-    }
-
     /// Returns the configuration settings that this engine is using.
     #[inline]
     pub fn config(&self) -> &Config {
         &self.inner.config
     }
 
-    #[cfg(any(feature = "cranelift", feature = "winch"))]
-    pub(crate) fn compiler(&self) -> &dyn wasmtime_environ::Compiler {
-        &*self.inner.compiler
-    }
-
-    pub(crate) fn allocator(&self) -> &dyn InstanceAllocator {
-        self.inner.allocator.as_ref()
-    }
-
-    pub(crate) fn profiler(&self) -> &dyn ProfilingAgent {
-        self.inner.profiler.as_ref()
-    }
-
-    #[cfg(feature = "cache")]
-    pub(crate) fn cache_config(&self) -> &CacheConfig {
-        &self.config().cache_config
-    }
-
-    /// Returns whether the engine `a` and `b` refer to the same configuration.
-    pub fn same(a: &Engine, b: &Engine) -> bool {
-        Arc::ptr_eq(&a.inner, &b.inner)
-    }
-
-    pub(crate) fn signatures(&self) -> &SignatureRegistry {
-        &self.inner.signatures
-    }
-
-    pub(crate) fn epoch_counter(&self) -> &AtomicU64 {
-        &self.inner.epoch
-    }
-
-    pub(crate) fn current_epoch(&self) -> u64 {
-        self.epoch_counter().load(Ordering::Relaxed)
-    }
-
-    /// Increments the epoch.
-    ///
-    /// When using epoch-based interruption, currently-executing Wasm
-    /// code within this engine will trap or yield "soon" when the
-    /// epoch deadline is reached or exceeded. (The configuration, and
-    /// the deadline, are set on the `Store`.) The intent of the
-    /// design is for this method to be called by the embedder at some
-    /// regular cadence, for example by a thread that wakes up at some
-    /// interval, or by a signal handler.
-    ///
-    /// See [`Config::epoch_interruption`](crate::Config::epoch_interruption)
-    /// for an introduction to epoch-based interruption and pointers
-    /// to the other relevant methods.
-    ///
-    /// ## Signal Safety
-    ///
-    /// This method is signal-safe: it does not make any syscalls, and
-    /// performs only an atomic increment to the epoch value in
-    /// memory.
-    pub fn increment_epoch(&self) {
-        self.inner.epoch.fetch_add(1, Ordering::Relaxed);
-    }
-
-    pub(crate) fn unique_id_allocator(&self) -> &CompiledModuleIdAllocator {
-        &self.inner.unique_id_allocator
-    }
-
-    /// Ahead-of-time (AOT) compiles a WebAssembly module.
-    ///
-    /// The `bytes` provided must be in one of two formats:
-    ///
-    /// * A [binary-encoded][binary] WebAssembly module. This is always supported.
-    /// * A [text-encoded][text] instance of the WebAssembly text format.
-    ///   This is only supported when the `wat` feature of this crate is enabled.
-    ///   If this is supplied then the text format will be parsed before validation.
-    ///   Note that the `wat` feature is enabled by default.
-    ///
-    /// This method may be used to compile a module for use with a different target
-    /// host. The output of this method may be used with
-    /// [`Module::deserialize`](crate::Module::deserialize) on hosts compatible
-    /// with the [`Config`] associated with this [`Engine`].
-    ///
-    /// The output of this method is safe to send to another host machine for later
-    /// execution. As the output is already a compiled module, translation and code
-    /// generation will be skipped and this will improve the performance of constructing
-    /// a [`Module`](crate::Module) from the output of this method.
-    ///
-    /// [binary]: https://webassembly.github.io/spec/core/binary/index.html
-    /// [text]: https://webassembly.github.io/spec/core/text/index.html
-    #[cfg(any(feature = "cranelift", feature = "winch"))]
-    #[cfg_attr(nightlydoc, doc(cfg(any(feature = "cranelift", feature = "winch"))))]
-    pub fn precompile_module(&self, bytes: &[u8]) -> Result<Vec<u8>> {
-        #[cfg(feature = "wat")]
-        let bytes = wat::parse_bytes(&bytes)?;
-        let (mmap, _) = crate::Module::build_artifacts(self, &bytes)?;
-        Ok(mmap.to_vec())
-    }
-
-    /// Same as [`Engine::precompile_module`] except for a
-    /// [`Component`](crate::component::Component)
-    #[cfg(any(feature = "cranelift", feature = "winch"))]
-    #[cfg_attr(nightlydoc, doc(cfg(any(feature = "cranelift", feature = "winch"))))]
-    #[cfg(feature = "component-model")]
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "component-model")))]
-    pub fn precompile_component(&self, bytes: &[u8]) -> Result<Vec<u8>> {
-        #[cfg(feature = "wat")]
-        let bytes = wat::parse_bytes(&bytes)?;
-        let (mmap, _) = crate::component::Component::build_artifacts(self, &bytes)?;
-        Ok(mmap.to_vec())
-    }
-
-    /// Returns a [`std::hash::Hash`] that can be used to check precompiled WebAssembly compatibility.
-    ///
-    /// The outputs of [`Engine::precompile_module`] and [`Engine::precompile_component`]
-    /// are compatible with a different [`Engine`] instance only if the two engines use
-    /// compatible [`Config`]s. If this Hash matches between two [`Engine`]s then binaries
-    /// from one are guaranteed to deserialize in the other.
-    #[cfg(any(feature = "cranelift", feature = "winch"))]
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "cranelift")))] // see build.rs
-    pub fn precompile_compatibility_hash(&self) -> impl std::hash::Hash + '_ {
-        crate::module::HashedEngineCompileEnv(self)
+    #[inline]
+    pub(crate) fn features(&self) -> WasmFeatures {
+        self.inner.features
     }
 
     pub(crate) fn run_maybe_parallel<
@@ -262,10 +151,13 @@ impl Engine {
     ) -> Result<Vec<B>, E> {
         if self.config().parallel_compilation {
             #[cfg(feature = "parallel-compilation")]
-            return input
-                .into_par_iter()
-                .map(|a| f(a))
-                .collect::<Result<Vec<B>, E>>();
+            {
+                use rayon::prelude::*;
+                return input
+                    .into_par_iter()
+                    .map(|a| f(a))
+                    .collect::<Result<Vec<B>, E>>();
+            }
         }
 
         // In case the parallel-compilation feature is disabled or the parallel_compilation config
@@ -276,23 +168,54 @@ impl Engine {
             .collect::<Result<Vec<B>, E>>()
     }
 
-    /// Executes `f1` and `f2` in parallel if parallel compilation is enabled at
-    /// both runtime and compile time, otherwise runs them synchronously.
-    #[allow(dead_code)] // only used for the component-model feature right now
-    pub(crate) fn join_maybe_parallel<T, U>(
-        &self,
-        f1: impl FnOnce() -> T + Send,
-        f2: impl FnOnce() -> U + Send,
-    ) -> (T, U)
-    where
-        T: Send,
-        U: Send,
-    {
-        if self.config().parallel_compilation {
-            #[cfg(feature = "parallel-compilation")]
-            return rayon::join(f1, f2);
+    /// Take a weak reference to this engine.
+    pub fn weak(&self) -> EngineWeak {
+        EngineWeak {
+            inner: Arc::downgrade(&self.inner),
         }
-        (f1(), f2())
+    }
+
+    pub(crate) fn tunables(&self) -> &Tunables {
+        &self.inner.tunables
+    }
+
+    /// Returns whether the engine `a` and `b` refer to the same configuration.
+    #[inline]
+    pub fn same(a: &Engine, b: &Engine) -> bool {
+        Arc::ptr_eq(&a.inner, &b.inner)
+    }
+
+    /// Returns whether the engine is configured to support async functions.
+    #[cfg(feature = "async")]
+    #[inline]
+    pub fn is_async(&self) -> bool {
+        self.config().async_support
+    }
+
+    /// Detects whether the bytes provided are a precompiled object produced by
+    /// Wasmtime.
+    ///
+    /// This function will inspect the header of `bytes` to determine if it
+    /// looks like a precompiled core wasm module or a precompiled component.
+    /// This does not validate the full structure or guarantee that
+    /// deserialization will succeed, instead it helps higher-levels of the
+    /// stack make a decision about what to do next when presented with the
+    /// `bytes` as an input module.
+    ///
+    /// If the `bytes` looks like a precompiled object previously produced by
+    /// [`Module::serialize`](crate::Module::serialize),
+    /// [`Component::serialize`](crate::component::Component::serialize),
+    /// [`Engine::precompile_module`], or [`Engine::precompile_component`], then
+    /// this will return `Some(...)` indicating so. Otherwise `None` is
+    /// returned.
+    pub fn detect_precompiled(&self, bytes: &[u8]) -> Option<Precompiled> {
+        serialization::detect_precompiled_bytes(bytes)
+    }
+
+    /// Like [`Engine::detect_precompiled`], but performs the detection on a file.
+    #[cfg(feature = "std")]
+    pub fn detect_precompiled_file(&self, path: impl AsRef<Path>) -> Result<Option<Precompiled>> {
+        serialization::detect_precompiled_file(path)
     }
 
     /// Returns the target triple which this engine is compiling code for
@@ -315,11 +238,18 @@ impl Engine {
     /// Note that if cranelift is disabled this trivially returns `Ok` because
     /// loaded serialized modules are checked separately.
     pub(crate) fn check_compatible_with_native_host(&self) -> Result<()> {
-        self.inner
-            .compatible_with_native_host
-            .get_or_init(|| self._check_compatible_with_native_host())
-            .clone()
-            .map_err(anyhow::Error::msg)
+        #[cfg(any(feature = "cranelift", feature = "winch"))]
+        {
+            self.inner
+                .compatible_with_native_host
+                .get_or_init(|| self._check_compatible_with_native_host())
+                .clone()
+                .map_err(anyhow::Error::msg)
+        }
+        #[cfg(not(any(feature = "cranelift", feature = "winch")))]
+        {
+            Ok(())
+        }
     }
 
     fn _check_compatible_with_native_host(&self) -> Result<(), String> {
@@ -331,8 +261,7 @@ impl Engine {
             let target = compiler.triple();
             if *target != target_lexicon::Triple::host() {
                 return Err(format!(
-                    "target '{}' specified in the configuration does not match the host",
-                    target
+                    "target '{target}' specified in the configuration does not match the host"
                 ));
             }
 
@@ -388,10 +317,11 @@ impl Engine {
             "use_colocated_libcalls" => *value == FlagValue::Bool(false),
             "use_pinned_reg_as_heap_base" => *value == FlagValue::Bool(false),
 
-            // If reference types are enabled this must be enabled, otherwise
-            // this setting can have any value.
+            // If reference types (or anything that depends on reference types,
+            // like typed function references and GC) are enabled this must be
+            // enabled, otherwise this setting can have any value.
             "enable_safepoints" => {
-                if self.config().features.reference_types {
+                if self.features().contains(WasmFeatures::REFERENCE_TYPES) {
                     *value == FlagValue::Bool(true)
                 } else {
                     return Ok(())
@@ -416,15 +346,16 @@ impl Engine {
             | "enable_jump_tables"
             | "enable_float"
             | "enable_verifier"
+            | "enable_pcc"
             | "regalloc_checker"
             | "regalloc_verbose_logs"
             | "is_pic"
             | "bb_padding_log2_minus_one"
             | "machine_code_cfg_info"
             | "tls_model" // wasmtime doesn't use tls right now
+            | "stack_switch_model" // wasmtime doesn't use stack switching right now
             | "opt_level" // opt level doesn't change semantics
             | "enable_alias_analysis" // alias analysis-based opts don't change semantics
-            | "probestack_func_adjusts_sp" // probestack above asserted disabled
             | "probestack_size_log2" // probestack above asserted disabled
             | "regalloc" // shouldn't change semantics
             | "enable_incremental_compilation_cache_checks" // shouldn't change semantics
@@ -433,14 +364,13 @@ impl Engine {
             // Everything else is unknown and needs to be added somewhere to
             // this list if encountered.
             _ => {
-                return Err(format!("unknown shared setting {:?} configured to {:?}", flag, value))
+                return Err(format!("unknown shared setting {flag:?} configured to {value:?}"))
             }
         };
 
         if !ok {
             return Err(format!(
-                "setting {:?} is configured to {:?} which is not supported",
-                flag, value,
+                "setting {flag:?} is configured to {value:?} which is not supported",
             ));
         }
         Ok(())
@@ -467,118 +397,140 @@ impl Engine {
             // need more support here.
             _ => {
                 return Err(format!(
-                    "isa-specific feature {:?} configured to unknown value {:?}",
-                    flag, value
+                    "isa-specific feature {flag:?} configured to unknown value {value:?}"
                 ))
             }
         }
 
-        #[allow(unused_assignments)]
-        let mut enabled = None;
-
-        #[cfg(target_arch = "aarch64")]
-        {
-            enabled = match flag {
-                "has_lse" => Some(std::arch::is_aarch64_feature_detected!("lse")),
-                // No effect on its own, but in order to simplify the code on a
-                // platform without pointer authentication support we fail if
-                // "has_pauth" is enabled, but "sign_return_address" is not.
-                "has_pauth" => Some(std::arch::is_aarch64_feature_detected!("paca")),
-                // No effect on its own.
-                "sign_return_address_all" => Some(true),
-                // The pointer authentication instructions act as a `NOP` when
-                // unsupported (but keep in mind "has_pauth" as well), so it is
-                // safe to enable them.
-                "sign_return_address" => Some(true),
-                // No effect on its own.
-                "sign_return_address_with_bkey" => Some(true),
-                // The `BTI` instruction acts as a `NOP` when unsupported, so it
-                // is safe to enable it.
-                "use_bti" => Some(true),
-                // fall through to the very bottom to indicate that support is
-                // not enabled to test whether this feature is enabled on the
-                // host.
-                _ => None,
-            };
-        }
+        let host_feature = match flag {
+            // aarch64 features to detect
+            "has_lse" => "lse",
+            "has_pauth" => "paca",
+            "has_fp16" => "fp16",
+
+            // aarch64 features which don't need detection
+            // No effect on its own.
+            "sign_return_address_all" => return Ok(()),
+            // The pointer authentication instructions act as a `NOP` when
+            // unsupported, so it is safe to enable them.
+            "sign_return_address" => return Ok(()),
+            // No effect on its own.
+            "sign_return_address_with_bkey" => return Ok(()),
+            // The `BTI` instruction acts as a `NOP` when unsupported, so it
+            // is safe to enable it regardless of whether the host supports it
+            // or not.
+            "use_bti" => return Ok(()),
+
+            // s390x features to detect
+            "has_vxrs_ext2" => "vxrs_ext2",
+            "has_mie2" => "mie2",
+
+            // x64 features to detect
+            "has_sse3" => "sse3",
+            "has_ssse3" => "ssse3",
+            "has_sse41" => "sse4.1",
+            "has_sse42" => "sse4.2",
+            "has_popcnt" => "popcnt",
+            "has_avx" => "avx",
+            "has_avx2" => "avx2",
+            "has_fma" => "fma",
+            "has_bmi1" => "bmi1",
+            "has_bmi2" => "bmi2",
+            "has_avx512bitalg" => "avx512bitalg",
+            "has_avx512dq" => "avx512dq",
+            "has_avx512f" => "avx512f",
+            "has_avx512vl" => "avx512vl",
+            "has_avx512vbmi" => "avx512vbmi",
+            "has_lzcnt" => "lzcnt",
 
-        // There is no is_s390x_feature_detected macro yet, so for now
-        // we use getauxval from the libc crate directly.
-        #[cfg(all(target_arch = "s390x", target_os = "linux"))]
-        {
-            let v = unsafe { libc::getauxval(libc::AT_HWCAP) };
-            const HWCAP_S390X_VXRS_EXT2: libc::c_ulong = 32768;
-
-            enabled = match flag {
-                // There is no separate HWCAP bit for mie2, so assume
-                // that any machine with vxrs_ext2 also has mie2.
-                "has_vxrs_ext2" | "has_mie2" => Some((v & HWCAP_S390X_VXRS_EXT2) != 0),
-                // fall through to the very bottom to indicate that support is
-                // not enabled to test whether this feature is enabled on the
-                // host.
-                _ => None,
-            }
-        }
-
-        #[cfg(target_arch = "riscv64")]
-        {
-            enabled = match flag {
-                // make sure `test_isa_flags_mismatch` test pass.
-                "not_a_flag" => None,
-                // due to `is_riscv64_feature_detected` is not stable.
-                // we cannot use it.
-                _ => Some(true),
+            _ => {
+                // FIXME: should enumerate risc-v features and plumb them
+                // through to the `detect_host_feature` function.
+                if cfg!(target_arch = "riscv64") && flag != "not_a_flag" {
+                    return Ok(());
+                }
+                return Err(format!(
+                    "don't know how to test for target-specific flag {flag:?} at runtime"
+                ));
             }
-        }
-
-        #[cfg(target_arch = "x86_64")]
-        {
-            enabled = match flag {
-                "has_sse3" => Some(std::is_x86_feature_detected!("sse3")),
-                "has_ssse3" => Some(std::is_x86_feature_detected!("ssse3")),
-                "has_sse41" => Some(std::is_x86_feature_detected!("sse4.1")),
-                "has_sse42" => Some(std::is_x86_feature_detected!("sse4.2")),
-                "has_popcnt" => Some(std::is_x86_feature_detected!("popcnt")),
-                "has_avx" => Some(std::is_x86_feature_detected!("avx")),
-                "has_avx2" => Some(std::is_x86_feature_detected!("avx2")),
-                "has_fma" => Some(std::is_x86_feature_detected!("fma")),
-                "has_bmi1" => Some(std::is_x86_feature_detected!("bmi1")),
-                "has_bmi2" => Some(std::is_x86_feature_detected!("bmi2")),
-                "has_avx512bitalg" => Some(std::is_x86_feature_detected!("avx512bitalg")),
-                "has_avx512dq" => Some(std::is_x86_feature_detected!("avx512dq")),
-                "has_avx512f" => Some(std::is_x86_feature_detected!("avx512f")),
-                "has_avx512vl" => Some(std::is_x86_feature_detected!("avx512vl")),
-                "has_avx512vbmi" => Some(std::is_x86_feature_detected!("avx512vbmi")),
-                "has_lzcnt" => Some(std::is_x86_feature_detected!("lzcnt")),
-
-                // fall through to the very bottom to indicate that support is
-                // not enabled to test whether this feature is enabled on the
-                // host.
-                _ => None,
-            };
-        }
+        };
 
-        match enabled {
-            Some(true) => return Ok(()),
-            Some(false) => {
+        let detect = match self.config().detect_host_feature {
+            Some(detect) => detect,
+            None => {
                 return Err(format!(
-                    "compilation setting {:?} is enabled, but not available on the host",
-                    flag
+                    "cannot determine if host feature {host_feature:?} is \
+                     available at runtime, configure a probing function with \
+                     `Config::detect_host_feature`"
                 ))
             }
-            // fall through
-            None => {}
+        };
+
+        match detect(host_feature) {
+            Some(true) => Ok(()),
+            Some(false) => Err(format!(
+                "compilation setting {flag:?} is enabled, but not \
+                 available on the host",
+            )),
+            None => Err(format!(
+                "failed to detect if target-specific flag {flag:?} is \
+                 available at runtime"
+            )),
         }
+    }
+}
 
-        Err(format!(
-            "cannot test if target-specific flag {:?} is available at runtime",
-            flag
-        ))
+#[cfg(any(feature = "cranelift", feature = "winch"))]
+impl Engine {
+    pub(crate) fn compiler(&self) -> &dyn wasmtime_environ::Compiler {
+        &*self.inner.compiler
     }
 
-    #[cfg(any(feature = "cranelift", feature = "winch"))]
+    /// Ahead-of-time (AOT) compiles a WebAssembly module.
+    ///
+    /// The `bytes` provided must be in one of two formats:
+    ///
+    /// * A [binary-encoded][binary] WebAssembly module. This is always supported.
+    /// * A [text-encoded][text] instance of the WebAssembly text format.
+    ///   This is only supported when the `wat` feature of this crate is enabled.
+    ///   If this is supplied then the text format will be parsed before validation.
+    ///   Note that the `wat` feature is enabled by default.
+    ///
+    /// This method may be used to compile a module for use with a different target
+    /// host. The output of this method may be used with
+    /// [`Module::deserialize`](crate::Module::deserialize) on hosts compatible
+    /// with the [`Config`](crate::Config) associated with this [`Engine`].
+    ///
+    /// The output of this method is safe to send to another host machine for later
+    /// execution. As the output is already a compiled module, translation and code
+    /// generation will be skipped and this will improve the performance of constructing
+    /// a [`Module`](crate::Module) from the output of this method.
+    ///
+    /// [binary]: https://webassembly.github.io/spec/core/binary/index.html
+    /// [text]: https://webassembly.github.io/spec/core/text/index.html
+    pub fn precompile_module(&self, bytes: &[u8]) -> Result<Vec<u8>> {
+        crate::CodeBuilder::new(self)
+            .wasm_binary_or_text(bytes, None)?
+            .compile_module_serialized()
+    }
+
+    /// Same as [`Engine::precompile_module`] except for a
+    /// [`Component`](crate::component::Component)
+    #[cfg(feature = "component-model")]
+    pub fn precompile_component(&self, bytes: &[u8]) -> Result<Vec<u8>> {
+        crate::CodeBuilder::new(self)
+            .wasm_binary_or_text(bytes, None)?
+            .compile_component_serialized()
+    }
+
+    /// Produces a blob of bytes by serializing the `engine`'s configuration data to
+    /// be checked, perhaps in a different process, with the `check_compatible`
+    /// method below.
+    ///
+    /// The blob of bytes is inserted into the object file specified to become part
+    /// of the final compiled artifact.
     pub(crate) fn append_compiler_info(&self, obj: &mut Object<'_>) {
-        serialization::append_compiler_info(self, obj);
+        serialization::append_compiler_info(self, obj, &serialization::Metadata::new(&self))
     }
 
     #[cfg(any(feature = "cranelift", feature = "winch"))]
@@ -595,6 +547,127 @@ impl Engine {
         };
         obj.append_section_data(section, &[contents], 1);
     }
+}
+
+/// Return value from the [`Engine::detect_precompiled`] API.
+#[derive(PartialEq, Eq, Copy, Clone, Debug)]
+pub enum Precompiled {
+    /// The input bytes look like a precompiled core wasm module.
+    Module,
+    /// The input bytes look like a precompiled wasm component.
+    Component,
+}
+
+#[cfg(feature = "runtime")]
+impl Engine {
+    /// Eagerly initialize thread-local functionality shared by all [`Engine`]s.
+    ///
+    /// Wasmtime's implementation on some platforms may involve per-thread
+    /// setup that needs to happen whenever WebAssembly is invoked. This setup
+    /// can take on the order of a few hundred microseconds, whereas the
+    /// overhead of calling WebAssembly is otherwise on the order of a few
+    /// nanoseconds. This setup cost is paid once per-OS-thread. If your
+    /// application is sensitive to the latencies of WebAssembly function
+    /// calls, even those that happen first on a thread, then this function
+    /// can be used to improve the consistency of each call into WebAssembly
+    /// by explicitly frontloading the cost of the one-time setup per-thread.
+    ///
+    /// Note that this function is not required to be called in any embedding.
+    /// Wasmtime will automatically initialize thread-local-state as necessary
+    /// on calls into WebAssembly. This is provided for use cases where the
+    /// latency of WebAssembly calls are extra-important, which is not
+    /// necessarily true of all embeddings.
+    pub fn tls_eager_initialize() {
+        crate::runtime::vm::tls_eager_initialize();
+    }
+
+    pub(crate) fn allocator(&self) -> &dyn crate::runtime::vm::InstanceAllocator {
+        self.inner.allocator.as_ref()
+    }
+
+    pub(crate) fn gc_runtime(&self) -> &Arc<dyn GcRuntime> {
+        &self.inner.gc_runtime
+    }
+
+    pub(crate) fn profiler(&self) -> &dyn crate::profiling_agent::ProfilingAgent {
+        self.inner.profiler.as_ref()
+    }
+
+    #[cfg(feature = "cache")]
+    pub(crate) fn cache_config(&self) -> &wasmtime_cache::CacheConfig {
+        &self.config().cache_config
+    }
+
+    pub(crate) fn signatures(&self) -> &TypeRegistry {
+        &self.inner.signatures
+    }
+
+    pub(crate) fn epoch_counter(&self) -> &AtomicU64 {
+        &self.inner.epoch
+    }
+
+    pub(crate) fn current_epoch(&self) -> u64 {
+        self.epoch_counter().load(Ordering::Relaxed)
+    }
+
+    /// Increments the epoch.
+    ///
+    /// When using epoch-based interruption, currently-executing Wasm
+    /// code within this engine will trap or yield "soon" when the
+    /// epoch deadline is reached or exceeded. (The configuration, and
+    /// the deadline, are set on the `Store`.) The intent of the
+    /// design is for this method to be called by the embedder at some
+    /// regular cadence, for example by a thread that wakes up at some
+    /// interval, or by a signal handler.
+    ///
+    /// See [`Config::epoch_interruption`](crate::Config::epoch_interruption)
+    /// for an introduction to epoch-based interruption and pointers
+    /// to the other relevant methods.
+    ///
+    /// When performing `increment_epoch` in a separate thread, consider using
+    /// [`Engine::weak`] to hold an [`EngineWeak`](crate::EngineWeak) and
+    /// performing [`EngineWeak::upgrade`](crate::EngineWeak::upgrade) on each
+    /// tick, so that the epoch ticking thread does not keep an [`Engine`] alive
+    /// longer than any of its consumers.
+    ///
+    /// ## Signal Safety
+    ///
+    /// This method is signal-safe: it does not make any syscalls, and
+    /// performs only an atomic increment to the epoch value in
+    /// memory.
+    pub fn increment_epoch(&self) {
+        self.inner.epoch.fetch_add(1, Ordering::Relaxed);
+    }
+
+    /// Returns a [`std::hash::Hash`] that can be used to check precompiled WebAssembly compatibility.
+    ///
+    /// The outputs of [`Engine::precompile_module`] and [`Engine::precompile_component`]
+    /// are compatible with a different [`Engine`] instance only if the two engines use
+    /// compatible [`Config`]s. If this Hash matches between two [`Engine`]s then binaries
+    /// from one are guaranteed to deserialize in the other.
+    #[cfg(any(feature = "cranelift", feature = "winch"))]
+    pub fn precompile_compatibility_hash(&self) -> impl std::hash::Hash + '_ {
+        crate::compile::HashedEngineCompileEnv(self)
+    }
+
+    /// Executes `f1` and `f2` in parallel if parallel compilation is enabled at
+    /// both runtime and compile time, otherwise runs them synchronously.
+    #[allow(dead_code)] // only used for the component-model feature right now
+    pub(crate) fn join_maybe_parallel<T, U>(
+        &self,
+        f1: impl FnOnce() -> T + Send,
+        f2: impl FnOnce() -> U + Send,
+    ) -> (T, U)
+    where
+        T: Send,
+        U: Send,
+    {
+        if self.config().parallel_compilation {
+            #[cfg(feature = "parallel-compilation")]
+            return rayon::join(f1, f2);
+        }
+        (f1(), f2())
+    }
 
     /// Loads a `CodeMemory` from the specified in-memory slice, copying it to a
     /// uniquely owned mmap.
@@ -605,186 +678,101 @@ impl Engine {
         &self,
         bytes: &[u8],
         expected: ObjectKind,
-    ) -> Result<Arc<CodeMemory>> {
-        self.load_code(MmapVec::from_slice(bytes)?, expected)
+    ) -> Result<Arc<crate::CodeMemory>> {
+        self.load_code(crate::runtime::vm::MmapVec::from_slice(bytes)?, expected)
     }
 
     /// Like `load_code_bytes`, but creates a mmap from a file on disk.
+    #[cfg(feature = "std")]
     pub(crate) fn load_code_file(
         &self,
         path: &Path,
         expected: ObjectKind,
-    ) -> Result<Arc<CodeMemory>> {
+    ) -> Result<Arc<crate::CodeMemory>> {
         self.load_code(
-            MmapVec::from_file(path).with_context(|| {
+            crate::runtime::vm::MmapVec::from_file(path).with_context(|| {
                 format!("failed to create file mapping for: {}", path.display())
             })?,
             expected,
         )
     }
 
-    pub(crate) fn load_code(&self, mmap: MmapVec, expected: ObjectKind) -> Result<Arc<CodeMemory>> {
+    pub(crate) fn load_code(
+        &self,
+        mmap: crate::runtime::vm::MmapVec,
+        expected: ObjectKind,
+    ) -> Result<Arc<crate::CodeMemory>> {
         serialization::check_compatible(self, &mmap, expected)?;
-        let mut code = CodeMemory::new(mmap)?;
+        let mut code = crate::CodeMemory::new(mmap)?;
         code.publish()?;
         Ok(Arc::new(code))
     }
 
-    /// Detects whether the bytes provided are a precompiled object produced by
-    /// Wasmtime.
+    /// Unload process-related trap/signal handlers and destroy this engine.
     ///
-    /// This function will inspect the header of `bytes` to determine if it
-    /// looks like a precompiled core wasm module or a precompiled component.
-    /// This does not validate the full structure or guarantee that
-    /// deserialization will succeed, instead it helps higher-levels of the
-    /// stack make a decision about what to do next when presented with the
-    /// `bytes` as an input module.
+    /// This method is not safe and is not widely applicable. It is not required
+    /// to be called and is intended for use cases such as unloading a dynamic
+    /// library from a process. It is difficult to invoke this method correctly
+    /// and it requires careful coordination to do so.
     ///
-    /// If the `bytes` looks like a precompiled object previously produced by
-    /// [`Module::serialize`](crate::Module::serialize),
-    /// [`Component::serialize`](crate::component::Component::serialize),
-    /// [`Engine::precompile_module`], or [`Engine::precompile_component`], then
-    /// this will return `Some(...)` indicating so. Otherwise `None` is
-    /// returned.
-    pub fn detect_precompiled(&self, bytes: &[u8]) -> Option<Precompiled> {
-        serialization::detect_precompiled_bytes(bytes)
-    }
-
-    /// Like [`Engine::detect_precompiled`], but performs the detection on a file.
-    pub fn detect_precompiled_file(&self, path: impl AsRef<Path>) -> Result<Option<Precompiled>> {
-        serialization::detect_precompiled_file(path)
-    }
-}
+    /// # Panics
+    ///
+    /// This method will panic if this `Engine` handle is not the last remaining
+    /// engine handle.
+    ///
+    /// # Aborts
+    ///
+    /// This method will abort the process on some platforms in some situations
+    /// where unloading the handler cannot be performed and an unrecoverable
+    /// state is reached. For example on Unix platforms with signal handling
+    /// the process will be aborted if the current signal handlers are not
+    /// Wasmtime's.
+    ///
+    /// # Unsafety
+    ///
+    /// This method is not generally safe to call and has a number of
+    /// preconditions that must be met to even possibly be safe. Even with these
+    /// known preconditions met there may be other unknown invariants to uphold
+    /// as well.
+    ///
+    /// * There must be no other instances of `Engine` elsewhere in the process.
+    ///   Note that this isn't just copies of this `Engine` but it's any other
+    ///   `Engine` at all. This unloads global state that is used by all
+    ///   `Engine`s so this instance must be the last.
+    ///
+    /// * On Unix platforms no other signal handlers could have been installed
+    ///   for signals that Wasmtime catches. In this situation Wasmtime won't
+    ///   know how to restore signal handlers that Wasmtime possibly overwrote
+    ///   when Wasmtime was initially loaded. If possible initialize other
+    ///   libraries first and then initialize Wasmtime last (e.g. defer creating
+    ///   an `Engine`).
+    ///
+    /// * All existing threads which have used this DLL or copy of Wasmtime may
+    ///   no longer use this copy of Wasmtime. Per-thread state is not iterated
+    ///   and destroyed. Only future threads may use future instances of this
+    ///   Wasmtime itself.
+    ///
+    /// If other crashes are seen from using this method please feel free to
+    /// file an issue to update the documentation here with more preconditions
+    /// that must be met.
+    pub unsafe fn unload_process_handlers(self) {
+        assert_eq!(Arc::weak_count(&self.inner), 0);
+        assert_eq!(Arc::strong_count(&self.inner), 1);
 
-impl Default for Engine {
-    fn default() -> Engine {
-        Engine::new(&Config::default()).unwrap()
+        crate::runtime::vm::deinit_traps();
     }
 }
 
-/// Return value from the [`Engine::detect_precompiled`] API.
-#[derive(PartialEq, Eq, Copy, Clone, Debug)]
-pub enum Precompiled {
-    /// The input bytes look like a precompiled core wasm module.
-    Module,
-    /// The input bytes look like a precompiled wasm component.
-    Component,
+/// A weak reference to an [`Engine`].
+#[derive(Clone)]
+pub struct EngineWeak {
+    inner: alloc::sync::Weak<EngineInner>,
 }
 
-#[cfg(test)]
-mod tests {
-    use std::{
-        collections::hash_map::DefaultHasher,
-        hash::{Hash, Hasher},
-    };
-
-    use crate::{Config, Engine, Module, ModuleVersionStrategy, OptLevel};
-
-    use anyhow::Result;
-    use tempfile::TempDir;
-
-    #[test]
-    #[cfg_attr(miri, ignore)]
-    fn cache_accounts_for_opt_level() -> Result<()> {
-        let td = TempDir::new()?;
-        let config_path = td.path().join("config.toml");
-        std::fs::write(
-            &config_path,
-            &format!(
-                "
-                    [cache]
-                    enabled = true
-                    directory = '{}'
-                ",
-                td.path().join("cache").display()
-            ),
-        )?;
-        let mut cfg = Config::new();
-        cfg.cranelift_opt_level(OptLevel::None)
-            .cache_config_load(&config_path)?;
-        let engine = Engine::new(&cfg)?;
-        Module::new(&engine, "(module (func))")?;
-        assert_eq!(engine.config().cache_config.cache_hits(), 0);
-        assert_eq!(engine.config().cache_config.cache_misses(), 1);
-        Module::new(&engine, "(module (func))")?;
-        assert_eq!(engine.config().cache_config.cache_hits(), 1);
-        assert_eq!(engine.config().cache_config.cache_misses(), 1);
-
-        let mut cfg = Config::new();
-        cfg.cranelift_opt_level(OptLevel::Speed)
-            .cache_config_load(&config_path)?;
-        let engine = Engine::new(&cfg)?;
-        Module::new(&engine, "(module (func))")?;
-        assert_eq!(engine.config().cache_config.cache_hits(), 0);
-        assert_eq!(engine.config().cache_config.cache_misses(), 1);
-        Module::new(&engine, "(module (func))")?;
-        assert_eq!(engine.config().cache_config.cache_hits(), 1);
-        assert_eq!(engine.config().cache_config.cache_misses(), 1);
-
-        let mut cfg = Config::new();
-        cfg.cranelift_opt_level(OptLevel::SpeedAndSize)
-            .cache_config_load(&config_path)?;
-        let engine = Engine::new(&cfg)?;
-        Module::new(&engine, "(module (func))")?;
-        assert_eq!(engine.config().cache_config.cache_hits(), 0);
-        assert_eq!(engine.config().cache_config.cache_misses(), 1);
-        Module::new(&engine, "(module (func))")?;
-        assert_eq!(engine.config().cache_config.cache_hits(), 1);
-        assert_eq!(engine.config().cache_config.cache_misses(), 1);
-
-        let mut cfg = Config::new();
-        cfg.debug_info(true).cache_config_load(&config_path)?;
-        let engine = Engine::new(&cfg)?;
-        Module::new(&engine, "(module (func))")?;
-        assert_eq!(engine.config().cache_config.cache_hits(), 0);
-        assert_eq!(engine.config().cache_config.cache_misses(), 1);
-        Module::new(&engine, "(module (func))")?;
-        assert_eq!(engine.config().cache_config.cache_hits(), 1);
-        assert_eq!(engine.config().cache_config.cache_misses(), 1);
-
-        Ok(())
-    }
-
-    #[test]
-    fn precompile_compatibility_key_accounts_for_opt_level() {
-        fn hash_for_config(cfg: &Config) -> u64 {
-            let engine = Engine::new(cfg).expect("Config should be valid");
-            let mut hasher = DefaultHasher::new();
-            engine.precompile_compatibility_hash().hash(&mut hasher);
-            hasher.finish()
-        }
-        let mut cfg = Config::new();
-        cfg.cranelift_opt_level(OptLevel::None);
-        let opt_none_hash = hash_for_config(&cfg);
-        cfg.cranelift_opt_level(OptLevel::Speed);
-        let opt_speed_hash = hash_for_config(&cfg);
-        assert_ne!(opt_none_hash, opt_speed_hash)
-    }
-
-    #[test]
-    fn precompile_compatibility_key_accounts_for_module_version_strategy() -> Result<()> {
-        fn hash_for_config(cfg: &Config) -> u64 {
-            let engine = Engine::new(cfg).expect("Config should be valid");
-            let mut hasher = DefaultHasher::new();
-            engine.precompile_compatibility_hash().hash(&mut hasher);
-            hasher.finish()
-        }
-        let mut cfg_custom_version = Config::new();
-        cfg_custom_version.module_version(ModuleVersionStrategy::Custom("1.0.1111".to_string()))?;
-        let custom_version_hash = hash_for_config(&cfg_custom_version);
-
-        let mut cfg_default_version = Config::new();
-        cfg_default_version.module_version(ModuleVersionStrategy::WasmtimeVersion)?;
-        let default_version_hash = hash_for_config(&cfg_default_version);
-
-        let mut cfg_none_version = Config::new();
-        cfg_none_version.module_version(ModuleVersionStrategy::None)?;
-        let none_version_hash = hash_for_config(&cfg_none_version);
-
-        assert_ne!(custom_version_hash, default_version_hash);
-        assert_ne!(custom_version_hash, none_version_hash);
-        assert_ne!(default_version_hash, none_version_hash);
-
-        Ok(())
+impl EngineWeak {
+    /// Upgrade this weak reference into an [`Engine`]. Returns `None` if
+    /// strong references (the [`Engine`] type itself) no longer exist.
+    pub fn upgrade(&self) -> Option<Engine> {
+        alloc::sync::Weak::upgrade(&self.inner).map(|inner| Engine { inner })
     }
 }
diff --git a/crates/wasmtime/src/engine/serialization.rs b/crates/wasmtime/src/engine/serialization.rs
index 86cc6cb8e373..9b1da2bcb68a 100644
--- a/crates/wasmtime/src/engine/serialization.rs
+++ b/crates/wasmtime/src/engine/serialization.rs
@@ -15,56 +15,25 @@
 //! 1. A version byte, currently `VERSION`.
 //! 2. A byte indicating how long the next field is.
 //! 3. A version string of the length of the previous byte value.
-//! 4. A `bincode`-encoded `Metadata` structure.
+//! 4. A `postcard`-encoded `Metadata` structure.
 //!
 //! This is hoped to help distinguish easily Wasmtime-based ELF files from
 //! other random ELF files, as well as provide better error messages for
 //! using wasmtime artifacts across versions.
 
+use crate::prelude::*;
 use crate::{Engine, ModuleVersionStrategy, Precompiled};
-use anyhow::{anyhow, bail, Context, Result};
+use core::str::FromStr;
+use object::endian::NativeEndian;
+#[cfg(any(feature = "cranelift", feature = "winch"))]
 use object::write::{Object, StandardSegment};
-use object::{File, FileFlags, Object as _, ObjectSection, SectionKind};
+use object::{read::elf::ElfFile64, FileFlags, Object as _, ObjectSection, SectionKind};
 use serde_derive::{Deserialize, Serialize};
-use std::collections::BTreeMap;
-use std::str::FromStr;
 use wasmtime_environ::obj;
 use wasmtime_environ::{FlagValue, ObjectKind, Tunables};
-use wasmtime_runtime::MmapVec;
 
 const VERSION: u8 = 0;
 
-/// Produces a blob of bytes by serializing the `engine`'s configuration data to
-/// be checked, perhaps in a different process, with the `check_compatible`
-/// method below.
-///
-/// The blob of bytes is inserted into the object file specified to become part
-/// of the final compiled artifact.
-#[cfg(any(feature = "cranelift", feature = "winch"))]
-pub fn append_compiler_info(engine: &Engine, obj: &mut Object<'_>) {
-    let section = obj.add_section(
-        obj.segment_name(StandardSegment::Data).to_vec(),
-        obj::ELF_WASM_ENGINE.as_bytes().to_vec(),
-        SectionKind::ReadOnlyData,
-    );
-    let mut data = Vec::new();
-    data.push(VERSION);
-    let version = match &engine.config().module_version {
-        ModuleVersionStrategy::WasmtimeVersion => env!("CARGO_PKG_VERSION"),
-        ModuleVersionStrategy::Custom(c) => c,
-        ModuleVersionStrategy::None => "",
-    };
-    // This precondition is checked in Config::module_version:
-    assert!(
-        version.len() < 256,
-        "package version must be less than 256 bytes"
-    );
-    data.push(version.len() as u8);
-    data.extend_from_slice(version.as_bytes());
-    bincode::serialize_into(&mut data, &Metadata::new(engine)).unwrap();
-    obj.set_section_data(section, data, 1);
-}
-
 /// Verifies that the serialized engine in `mmap` is compatible with the
 /// `engine` provided.
 ///
@@ -73,7 +42,7 @@ pub fn append_compiler_info(engine: &Engine, obj: &mut Object<'_>) {
 /// provided here, notably compatible wasm features are enabled, compatible
 /// compiler options, etc. If a mismatch is found and the compilation metadata
 /// specified is incompatible then an error is returned.
-pub fn check_compatible(engine: &Engine, mmap: &MmapVec, expected: ObjectKind) -> Result<()> {
+pub fn check_compatible(engine: &Engine, mmap: &[u8], expected: ObjectKind) -> Result<()> {
     // Parse the input `mmap` as an ELF file and see if the header matches the
     // Wasmtime-generated header. This includes a Wasmtime-specific `os_abi` and
     // the `e_flags` field should indicate whether `expected` matches or not.
@@ -87,7 +56,9 @@ pub fn check_compatible(engine: &Engine, mmap: &MmapVec, expected: ObjectKind) -
     // structured well enough to make this easy and additionally it's not really
     // a perf issue right now so doing that is left for another day's
     // refactoring.
-    let obj = File::parse(&mmap[..]).context("failed to parse precompiled artifact as an ELF")?;
+    let obj = ElfFile64::<NativeEndian>::parse(mmap)
+        .err2anyhow()
+        .context("failed to parse precompiled artifact as an ELF")?;
     let expected_e_flags = match expected {
         ObjectKind::Module => obj::EF_WASMTIME_MODULE,
         ObjectKind::Component => obj::EF_WASMTIME_COMPONENT,
@@ -104,7 +75,8 @@ pub fn check_compatible(engine: &Engine, mmap: &MmapVec, expected: ObjectKind) -
     let data = obj
         .section_by_name(obj::ELF_WASM_ENGINE)
         .ok_or_else(|| anyhow!("failed to find section `{}`", obj::ELF_WASM_ENGINE))?
-        .data()?;
+        .data()
+        .err2anyhow()?;
     let (first, data) = data
         .split_first()
         .ok_or_else(|| anyhow!("invalid engine section"))?;
@@ -123,7 +95,7 @@ pub fn check_compatible(engine: &Engine, mmap: &MmapVec, expected: ObjectKind) -
 
     match &engine.config().module_version {
         ModuleVersionStrategy::WasmtimeVersion => {
-            let version = std::str::from_utf8(version)?;
+            let version = core::str::from_utf8(version).err2anyhow()?;
             if version != env!("CARGO_PKG_VERSION") {
                 bail!(
                     "Module was compiled with incompatible Wasmtime version '{}'",
@@ -132,7 +104,7 @@ pub fn check_compatible(engine: &Engine, mmap: &MmapVec, expected: ObjectKind) -
             }
         }
         ModuleVersionStrategy::Custom(v) => {
-            let version = std::str::from_utf8(&version)?;
+            let version = core::str::from_utf8(&version).err2anyhow()?;
             if version != v {
                 bail!(
                     "Module was compiled with incompatible version '{}'",
@@ -142,11 +114,38 @@ pub fn check_compatible(engine: &Engine, mmap: &MmapVec, expected: ObjectKind) -
         }
         ModuleVersionStrategy::None => { /* ignore the version info, accept all */ }
     }
-    bincode::deserialize::<Metadata>(data)?.check_compatible(engine)
+    postcard::from_bytes::<Metadata<'_>>(data)
+        .err2anyhow()?
+        .check_compatible(engine)
+}
+
+#[cfg(any(feature = "cranelift", feature = "winch"))]
+pub fn append_compiler_info(engine: &Engine, obj: &mut Object<'_>, metadata: &Metadata<'_>) {
+    let section = obj.add_section(
+        obj.segment_name(StandardSegment::Data).to_vec(),
+        obj::ELF_WASM_ENGINE.as_bytes().to_vec(),
+        SectionKind::ReadOnlyData,
+    );
+    let mut data = Vec::new();
+    data.push(VERSION);
+    let version = match &engine.config().module_version {
+        ModuleVersionStrategy::WasmtimeVersion => env!("CARGO_PKG_VERSION"),
+        ModuleVersionStrategy::Custom(c) => c,
+        ModuleVersionStrategy::None => "",
+    };
+    // This precondition is checked in Config::module_version:
+    assert!(
+        version.len() < 256,
+        "package version must be less than 256 bytes"
+    );
+    data.push(version.len() as u8);
+    data.extend_from_slice(version.as_bytes());
+    data.extend(postcard::to_allocvec(metadata).unwrap());
+    obj.set_section_data(section, data, 1);
 }
 
 fn detect_precompiled<'data, R: object::ReadRef<'data>>(
-    obj: File<'data, R>,
+    obj: ElfFile64<'data, NativeEndian, R>,
 ) -> Option<Precompiled> {
     match obj.flags() {
         FileFlags::Elf {
@@ -164,20 +163,23 @@ fn detect_precompiled<'data, R: object::ReadRef<'data>>(
 }
 
 pub fn detect_precompiled_bytes(bytes: &[u8]) -> Option<Precompiled> {
-    detect_precompiled(File::parse(bytes).ok()?)
+    detect_precompiled(ElfFile64::parse(bytes).ok()?)
 }
 
+#[cfg(feature = "std")]
 pub fn detect_precompiled_file(path: impl AsRef<std::path::Path>) -> Result<Option<Precompiled>> {
     let read_cache = object::ReadCache::new(std::fs::File::open(path)?);
-    let obj = File::parse(&read_cache)?;
+    let obj = ElfFile64::parse(&read_cache)?;
     Ok(detect_precompiled(obj))
 }
 
 #[derive(Serialize, Deserialize)]
-struct Metadata {
+pub struct Metadata<'a> {
     target: String,
-    shared_flags: BTreeMap<String, FlagValue>,
-    isa_flags: BTreeMap<String, FlagValue>,
+    #[serde(borrow)]
+    shared_flags: Vec<(&'a str, FlagValue<'a>)>,
+    #[serde(borrow)]
+    isa_flags: Vec<(&'a str, FlagValue<'a>)>,
     tunables: Tunables,
     features: WasmFeatures,
 }
@@ -198,12 +200,17 @@ struct WasmFeatures {
     relaxed_simd: bool,
     extended_const: bool,
     function_references: bool,
+    gc: bool,
+    custom_page_sizes: bool,
+    component_model_more_flags: bool,
+    component_model_multiple_returns: bool,
+    gc_types: bool,
 }
 
-impl Metadata {
+impl Metadata<'_> {
     #[cfg(any(feature = "cranelift", feature = "winch"))]
-    fn new(engine: &Engine) -> Metadata {
-        let wasmparser::WasmFeatures {
+    pub fn new(engine: &Engine) -> Metadata<'static> {
+        let wasmparser::WasmFeaturesInflated {
             reference_types,
             multi_value,
             bulk_memory,
@@ -219,24 +226,36 @@ impl Metadata {
             memory_control,
             function_references,
             gc,
+            custom_page_sizes,
+            shared_everything_threads,
             component_model_values,
+            component_model_nested_names,
+            component_model_more_flags,
+            component_model_multiple_returns,
+            legacy_exceptions,
+            gc_types,
 
             // Always on; we don't currently have knobs for these.
             mutable_global: _,
             saturating_float_to_int: _,
             sign_extension: _,
             floats: _,
-        } = engine.config().features;
+        } = engine.features().inflate();
 
+        // These features are not implemented in Wasmtime yet. We match on them
+        // above so that once we do implement support for them, we won't
+        // silently ignore them during serialization.
         assert!(!memory_control);
-        assert!(!gc);
         assert!(!component_model_values);
+        assert!(!component_model_nested_names);
+        assert!(!shared_everything_threads);
+        assert!(!legacy_exceptions);
 
         Metadata {
             target: engine.compiler().triple().to_string(),
             shared_flags: engine.compiler().flags(),
             isa_flags: engine.compiler().isa_flags(),
-            tunables: engine.config().tunables.clone(),
+            tunables: engine.tunables().clone(),
             features: WasmFeatures {
                 reference_types,
                 multi_value,
@@ -251,6 +270,11 @@ impl Metadata {
                 relaxed_simd,
                 extended_const,
                 function_references,
+                gc,
+                custom_page_sizes,
+                component_model_more_flags,
+                component_model_multiple_returns,
+                gc_types,
             },
         }
     }
@@ -259,8 +283,8 @@ impl Metadata {
         self.check_triple(engine)?;
         self.check_shared_flags(engine)?;
         self.check_isa_flags(engine)?;
-        self.check_tunables(&engine.config().tunables)?;
-        self.check_features(&engine.config().features)?;
+        self.check_tunables(&engine.tunables())?;
+        self.check_features(&engine.features())?;
         Ok(())
     }
 
@@ -306,7 +330,7 @@ impl Metadata {
         Ok(())
     }
 
-    fn check_int<T: Eq + std::fmt::Display>(found: T, expected: T, feature: &str) -> Result<()> {
+    fn check_int<T: Eq + core::fmt::Display>(found: T, expected: T, feature: &str) -> Result<()> {
         if found == expected {
             return Ok(());
         }
@@ -334,7 +358,7 @@ impl Metadata {
 
     fn check_tunables(&mut self, other: &Tunables) -> Result<()> {
         let Tunables {
-            static_memory_bound,
+            static_memory_reservation,
             static_memory_offset_guard_size,
             dynamic_memory_offset_guard_size,
             generate_native_debuginfo,
@@ -343,8 +367,9 @@ impl Metadata {
             epoch_interruption,
             static_memory_bound_is_maximum,
             guard_before_linear_memory,
+            table_lazy_init,
             relaxed_simd_deterministic,
-            tail_callable,
+            winch_callable,
 
             // This doesn't affect compilation, it's just a runtime setting.
             dynamic_memory_growth_reserve: _,
@@ -360,9 +385,9 @@ impl Metadata {
         } = self.tunables;
 
         Self::check_int(
-            static_memory_bound,
-            other.static_memory_bound,
-            "static memory bound",
+            static_memory_reservation,
+            other.static_memory_reservation,
+            "static memory reservation",
         )?;
         Self::check_int(
             static_memory_offset_guard_size,
@@ -400,16 +425,42 @@ impl Metadata {
             other.guard_before_linear_memory,
             "guard before linear memory",
         )?;
+        Self::check_bool(table_lazy_init, other.table_lazy_init, "table lazy init")?;
         Self::check_bool(
             relaxed_simd_deterministic,
             other.relaxed_simd_deterministic,
             "relaxed simd deterministic semantics",
         )?;
-        Self::check_bool(tail_callable, other.tail_callable, "WebAssembly tail calls")?;
+        Self::check_bool(
+            winch_callable,
+            other.winch_callable,
+            "Winch calling convention",
+        )?;
 
         Ok(())
     }
 
+    fn check_cfg_bool(
+        cfg: bool,
+        cfg_str: &str,
+        found: bool,
+        expected: bool,
+        feature: &str,
+    ) -> Result<()> {
+        if cfg {
+            Self::check_bool(found, expected, feature)
+        } else {
+            assert!(!expected);
+            ensure!(
+                !found,
+                "Module was compiled with {feature} but support in the host \
+                 was disabled at compile time because the `{cfg_str}` Cargo \
+                 feature was not enabled",
+            );
+            Ok(())
+        }
+    }
+
     fn check_features(&mut self, other: &wasmparser::WasmFeatures) -> Result<()> {
         let WasmFeatures {
             reference_types,
@@ -425,60 +476,101 @@ impl Metadata {
             relaxed_simd,
             extended_const,
             function_references,
+            gc,
+            custom_page_sizes,
+            component_model_more_flags,
+            component_model_multiple_returns,
+            gc_types,
         } = self.features;
 
+        use wasmparser::WasmFeatures as F;
         Self::check_bool(
             reference_types,
-            other.reference_types,
+            other.contains(F::REFERENCE_TYPES),
             "WebAssembly reference types support",
         )?;
+        Self::check_bool(
+            function_references,
+            other.contains(F::FUNCTION_REFERENCES),
+            "WebAssembly function-references support",
+        )?;
+        Self::check_bool(
+            gc,
+            other.contains(F::GC),
+            "WebAssembly garbage collection support",
+        )?;
         Self::check_bool(
             multi_value,
-            other.multi_value,
+            other.contains(F::MULTI_VALUE),
             "WebAssembly multi-value support",
         )?;
         Self::check_bool(
             bulk_memory,
-            other.bulk_memory,
+            other.contains(F::BULK_MEMORY),
             "WebAssembly bulk memory support",
         )?;
         Self::check_bool(
             component_model,
-            other.component_model,
+            other.contains(F::COMPONENT_MODEL),
             "WebAssembly component model support",
         )?;
-        Self::check_bool(simd, other.simd, "WebAssembly SIMD support")?;
-        Self::check_bool(tail_call, other.tail_call, "WebAssembly tail calls support")?;
-        Self::check_bool(threads, other.threads, "WebAssembly threads support")?;
+        Self::check_bool(simd, other.contains(F::SIMD), "WebAssembly SIMD support")?;
+        Self::check_bool(
+            tail_call,
+            other.contains(F::TAIL_CALL),
+            "WebAssembly tail calls support",
+        )?;
+        Self::check_bool(
+            threads,
+            other.contains(F::THREADS),
+            "WebAssembly threads support",
+        )?;
         Self::check_bool(
             multi_memory,
-            other.multi_memory,
+            other.contains(F::MULTI_MEMORY),
             "WebAssembly multi-memory support",
         )?;
         Self::check_bool(
             exceptions,
-            other.exceptions,
+            other.contains(F::EXCEPTIONS),
             "WebAssembly exceptions support",
         )?;
         Self::check_bool(
             memory64,
-            other.memory64,
+            other.contains(F::MEMORY64),
             "WebAssembly 64-bit memory support",
         )?;
         Self::check_bool(
             extended_const,
-            other.extended_const,
+            other.contains(F::EXTENDED_CONST),
             "WebAssembly extended-const support",
         )?;
         Self::check_bool(
             relaxed_simd,
-            other.relaxed_simd,
+            other.contains(F::RELAXED_SIMD),
             "WebAssembly relaxed-simd support",
         )?;
         Self::check_bool(
-            function_references,
-            other.function_references,
-            "WebAssembly function-references support",
+            custom_page_sizes,
+            other.contains(F::CUSTOM_PAGE_SIZES),
+            "WebAssembly custom-page-sizes support",
+        )?;
+        Self::check_bool(
+            component_model_more_flags,
+            other.contains(F::COMPONENT_MODEL_MORE_FLAGS),
+            "WebAssembly component model support for more than 32 flags",
+        )?;
+        Self::check_bool(
+            component_model_multiple_returns,
+            other.contains(F::COMPONENT_MODEL_MULTIPLE_RETURNS),
+            "WebAssembly component model support for multiple returns",
+        )?;
+        Self::check_cfg_bool(
+            cfg!(feature = "gc"),
+            "gc",
+            gc_types,
+            other.contains(F::GC_TYPES),
+            "support for WebAssembly gc types",
         )?;
 
         Ok(())
@@ -488,7 +580,12 @@ impl Metadata {
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::Config;
+    use crate::{Config, Module, OptLevel};
+    use std::{
+        collections::hash_map::DefaultHasher,
+        hash::{Hash, Hasher},
+    };
+    use tempfile::TempDir;
 
     #[test]
     fn test_architecture_mismatch() -> Result<()> {
@@ -533,14 +630,13 @@ mod test {
         let engine = Engine::default();
         let mut metadata = Metadata::new(&engine);
 
-        metadata.shared_flags.insert(
-            "preserve_frame_pointers".to_string(),
-            FlagValue::Bool(false),
-        );
+        metadata
+            .shared_flags
+            .push(("preserve_frame_pointers", FlagValue::Bool(false)));
 
         match metadata.check_compatible(&engine) {
             Ok(_) => unreachable!(),
-            Err(e) => assert!(format!("{:?}", e).starts_with(
+            Err(e) => assert!(format!("{e:?}").starts_with(
                 "\
 compilation settings of module incompatible with native host
 
@@ -559,17 +655,20 @@ Caused by:
 
         metadata
             .isa_flags
-            .insert("not_a_flag".to_string(), FlagValue::Bool(true));
+            .push(("not_a_flag", FlagValue::Bool(true)));
 
         match metadata.check_compatible(&engine) {
             Ok(_) => unreachable!(),
-            Err(e) => assert!(format!("{:?}", e).starts_with(
-                "\
+            Err(e) => assert!(
+                format!("{e:?}").starts_with(
+                    "\
 compilation settings of module incompatible with native host
 
 Caused by:
-    cannot test if target-specific flag \"not_a_flag\" is available at runtime",
-            )),
+    don't know how to test for target-specific flag \"not_a_flag\" at runtime",
+                ),
+                "bad error {e:?}",
+            ),
         }
 
         Ok(())
@@ -629,29 +728,179 @@ Caused by:
     #[test]
     fn test_feature_mismatch() -> Result<()> {
         let mut config = Config::new();
-        config.wasm_simd(true);
+        config.wasm_threads(true);
 
         let engine = Engine::new(&config)?;
         let mut metadata = Metadata::new(&engine);
-        metadata.features.simd = false;
+        metadata.features.threads = false;
 
         match metadata.check_compatible(&engine) {
             Ok(_) => unreachable!(),
-            Err(e) => assert_eq!(e.to_string(), "Module was compiled without WebAssembly SIMD support but it is enabled for the host"),
+            Err(e) => assert_eq!(e.to_string(), "Module was compiled without WebAssembly threads support but it is enabled for the host"),
         }
 
         let mut config = Config::new();
-        config.wasm_simd(false);
+        config.wasm_threads(false);
 
         let engine = Engine::new(&config)?;
         let mut metadata = Metadata::new(&engine);
-        metadata.features.simd = true;
+        metadata.features.threads = true;
 
         match metadata.check_compatible(&engine) {
             Ok(_) => unreachable!(),
-            Err(e) => assert_eq!(e.to_string(), "Module was compiled with WebAssembly SIMD support but it is not enabled for the host"),
+            Err(e) => assert_eq!(e.to_string(), "Module was compiled with WebAssembly threads support but it is not enabled for the host"),
         }
 
         Ok(())
     }
+
+    #[test]
+    fn engine_weak_upgrades() {
+        let engine = Engine::default();
+        let weak = engine.weak();
+        weak.upgrade()
+            .expect("engine is still alive, so weak reference can upgrade");
+        drop(engine);
+        assert!(
+            weak.upgrade().is_none(),
+            "engine was dropped, so weak reference cannot upgrade"
+        );
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)]
+    fn cache_accounts_for_opt_level() -> Result<()> {
+        let td = TempDir::new()?;
+        let config_path = td.path().join("config.toml");
+        std::fs::write(
+            &config_path,
+            &format!(
+                "
+                    [cache]
+                    enabled = true
+                    directory = '{}'
+                ",
+                td.path().join("cache").display()
+            ),
+        )?;
+        let mut cfg = Config::new();
+        cfg.cranelift_opt_level(OptLevel::None)
+            .cache_config_load(&config_path)?;
+        let engine = Engine::new(&cfg)?;
+        Module::new(&engine, "(module (func))")?;
+        assert_eq!(engine.config().cache_config.cache_hits(), 0);
+        assert_eq!(engine.config().cache_config.cache_misses(), 1);
+        Module::new(&engine, "(module (func))")?;
+        assert_eq!(engine.config().cache_config.cache_hits(), 1);
+        assert_eq!(engine.config().cache_config.cache_misses(), 1);
+
+        let mut cfg = Config::new();
+        cfg.cranelift_opt_level(OptLevel::Speed)
+            .cache_config_load(&config_path)?;
+        let engine = Engine::new(&cfg)?;
+        Module::new(&engine, "(module (func))")?;
+        assert_eq!(engine.config().cache_config.cache_hits(), 0);
+        assert_eq!(engine.config().cache_config.cache_misses(), 1);
+        Module::new(&engine, "(module (func))")?;
+        assert_eq!(engine.config().cache_config.cache_hits(), 1);
+        assert_eq!(engine.config().cache_config.cache_misses(), 1);
+
+        let mut cfg = Config::new();
+        cfg.cranelift_opt_level(OptLevel::SpeedAndSize)
+            .cache_config_load(&config_path)?;
+        let engine = Engine::new(&cfg)?;
+        Module::new(&engine, "(module (func))")?;
+        assert_eq!(engine.config().cache_config.cache_hits(), 0);
+        assert_eq!(engine.config().cache_config.cache_misses(), 1);
+        Module::new(&engine, "(module (func))")?;
+        assert_eq!(engine.config().cache_config.cache_hits(), 1);
+        assert_eq!(engine.config().cache_config.cache_misses(), 1);
+
+        let mut cfg = Config::new();
+        cfg.debug_info(true).cache_config_load(&config_path)?;
+        let engine = Engine::new(&cfg)?;
+        Module::new(&engine, "(module (func))")?;
+        assert_eq!(engine.config().cache_config.cache_hits(), 0);
+        assert_eq!(engine.config().cache_config.cache_misses(), 1);
+        Module::new(&engine, "(module (func))")?;
+        assert_eq!(engine.config().cache_config.cache_hits(), 1);
+        assert_eq!(engine.config().cache_config.cache_misses(), 1);
+
+        Ok(())
+    }
+
+    #[test]
+    fn precompile_compatibility_key_accounts_for_opt_level() {
+        fn hash_for_config(cfg: &Config) -> u64 {
+            let engine = Engine::new(cfg).expect("Config should be valid");
+            let mut hasher = DefaultHasher::new();
+            engine.precompile_compatibility_hash().hash(&mut hasher);
+            hasher.finish()
+        }
+        let mut cfg = Config::new();
+        cfg.cranelift_opt_level(OptLevel::None);
+        let opt_none_hash = hash_for_config(&cfg);
+        cfg.cranelift_opt_level(OptLevel::Speed);
+        let opt_speed_hash = hash_for_config(&cfg);
+        assert_ne!(opt_none_hash, opt_speed_hash)
+    }
+
+    #[test]
+    fn precompile_compatibility_key_accounts_for_module_version_strategy() -> Result<()> {
+        fn hash_for_config(cfg: &Config) -> u64 {
+            let engine = Engine::new(cfg).expect("Config should be valid");
+            let mut hasher = DefaultHasher::new();
+            engine.precompile_compatibility_hash().hash(&mut hasher);
+            hasher.finish()
+        }
+        let mut cfg_custom_version = Config::new();
+        cfg_custom_version.module_version(ModuleVersionStrategy::Custom("1.0.1111".to_string()))?;
+        let custom_version_hash = hash_for_config(&cfg_custom_version);
+
+        let mut cfg_default_version = Config::new();
+        cfg_default_version.module_version(ModuleVersionStrategy::WasmtimeVersion)?;
+        let default_version_hash = hash_for_config(&cfg_default_version);
+
+        let mut cfg_none_version = Config::new();
+        cfg_none_version.module_version(ModuleVersionStrategy::None)?;
+        let none_version_hash = hash_for_config(&cfg_none_version);
+
+        assert_ne!(custom_version_hash, default_version_hash);
+        assert_ne!(custom_version_hash, none_version_hash);
+        assert_ne!(default_version_hash, none_version_hash);
+
+        Ok(())
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)]
+    #[cfg(feature = "component-model")]
+    fn components_are_cached() -> Result<()> {
+        use crate::component::Component;
+
+        let td = TempDir::new()?;
+        let config_path = td.path().join("config.toml");
+        std::fs::write(
+            &config_path,
+            &format!(
+                "
+                    [cache]
+                    enabled = true
+                    directory = '{}'
+                ",
+                td.path().join("cache").display()
+            ),
+        )?;
+        let mut cfg = Config::new();
+        cfg.cache_config_load(&config_path)?;
+        let engine = Engine::new(&cfg)?;
+        Component::new(&engine, "(component (core module (func)))")?;
+        assert_eq!(engine.config().cache_config.cache_hits(), 0);
+        assert_eq!(engine.config().cache_config.cache_misses(), 1);
+        Component::new(&engine, "(component (core module (func)))")?;
+        assert_eq!(engine.config().cache_config.cache_hits(), 1);
+        assert_eq!(engine.config().cache_config.cache_misses(), 1);
+
+        Ok(())
+    }
 }
diff --git a/crates/wasmtime/src/externals/global.rs b/crates/wasmtime/src/externals/global.rs
deleted file mode 100644
index fb089ba9f52b..000000000000
--- a/crates/wasmtime/src/externals/global.rs
+++ /dev/null
@@ -1,238 +0,0 @@
-use crate::store::{StoreData, StoreOpaque, Stored};
-use crate::trampoline::generate_global_export;
-use crate::{AsContext, AsContextMut, ExternRef, Func, GlobalType, Mutability, Val, ValType};
-use anyhow::{bail, Result};
-use std::mem;
-use std::ptr;
-
-/// A WebAssembly `global` value which can be read and written to.
-///
-/// A `global` in WebAssembly is sort of like a global variable within an
-/// [`Instance`](crate::Instance). The `global.get` and `global.set`
-/// instructions will modify and read global values in a wasm module. Globals
-/// can either be imported or exported from wasm modules.
-///
-/// A [`Global`] "belongs" to the store that it was originally created within
-/// (either via [`Global::new`] or via instantiating a
-/// [`Module`](crate::Module)). Operations on a [`Global`] only work with the
-/// store it belongs to, and if another store is passed in by accident then
-/// methods will panic.
-#[derive(Copy, Clone, Debug)]
-#[repr(transparent)] // here for the C API
-pub struct Global(pub(super) Stored<wasmtime_runtime::ExportGlobal>);
-
-impl Global {
-    /// Creates a new WebAssembly `global` value with the provide type `ty` and
-    /// initial value `val`.
-    ///
-    /// The `store` argument will be the owner of the [`Global`] returned. Using
-    /// the returned [`Global`] other items in the store may access this global.
-    /// For example this could be provided as an argument to
-    /// [`Instance::new`](crate::Instance::new) or
-    /// [`Linker::define`](crate::Linker::define).
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the `ty` provided does not match the type of the
-    /// value `val`, or if `val` comes from a different store than `store`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// let engine = Engine::default();
-    /// let mut store = Store::new(&engine, ());
-    ///
-    /// let ty = GlobalType::new(ValType::I32, Mutability::Const);
-    /// let i32_const = Global::new(&mut store, ty, 1i32.into())?;
-    /// let ty = GlobalType::new(ValType::F64, Mutability::Var);
-    /// let f64_mut = Global::new(&mut store, ty, 2.0f64.into())?;
-    ///
-    /// let module = Module::new(
-    ///     &engine,
-    ///     "(module
-    ///         (global (import \"\" \"i32-const\") i32)
-    ///         (global (import \"\" \"f64-mut\") (mut f64))
-    ///     )"
-    /// )?;
-    ///
-    /// let mut linker = Linker::new(&engine);
-    /// linker.define(&store, "", "i32-const", i32_const)?;
-    /// linker.define(&store, "", "f64-mut", f64_mut)?;
-    ///
-    /// let instance = linker.instantiate(&mut store, &module)?;
-    /// // ...
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn new(mut store: impl AsContextMut, ty: GlobalType, val: Val) -> Result<Global> {
-        Global::_new(store.as_context_mut().0, ty, val)
-    }
-
-    fn _new(store: &mut StoreOpaque, ty: GlobalType, val: Val) -> Result<Global> {
-        if !val.comes_from_same_store(store) {
-            bail!("cross-`Store` globals are not supported");
-        }
-        if val.ty() != *ty.content() {
-            bail!("value provided does not match the type of this global");
-        }
-        unsafe {
-            let wasmtime_export = generate_global_export(store, ty, val);
-            Ok(Global::from_wasmtime_global(wasmtime_export, store))
-        }
-    }
-
-    /// Returns the underlying type of this `global`.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `store` does not own this global.
-    pub fn ty(&self, store: impl AsContext) -> GlobalType {
-        let store = store.as_context();
-        let ty = &store[self.0].global;
-        GlobalType::from_wasmtime_global(&ty)
-    }
-
-    /// Returns the current [`Val`] of this global.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `store` does not own this global.
-    pub fn get(&self, mut store: impl AsContextMut) -> Val {
-        unsafe {
-            let store = store.as_context_mut();
-            let definition = &*store[self.0].definition;
-            match self.ty(&store).content() {
-                ValType::I32 => Val::from(*definition.as_i32()),
-                ValType::I64 => Val::from(*definition.as_i64()),
-                ValType::F32 => Val::F32(*definition.as_u32()),
-                ValType::F64 => Val::F64(*definition.as_u64()),
-                ValType::ExternRef => Val::ExternRef(
-                    definition
-                        .as_externref()
-                        .clone()
-                        .map(|inner| ExternRef { inner }),
-                ),
-                ValType::FuncRef => {
-                    Val::FuncRef(Func::from_raw(store, definition.as_func_ref().cast()))
-                }
-                ValType::V128 => Val::V128((*definition.as_u128()).into()),
-            }
-        }
-    }
-
-    /// Attempts to set the current value of this global to [`Val`].
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if this global has a different type than `Val`, if
-    /// it's not a mutable global, or if `val` comes from a different store than
-    /// the one provided.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `store` does not own this global.
-    pub fn set(&self, mut store: impl AsContextMut, val: Val) -> Result<()> {
-        let store = store.as_context_mut().0;
-        let ty = self.ty(&store);
-        if ty.mutability() != Mutability::Var {
-            bail!("immutable global cannot be set");
-        }
-        let ty = ty.content();
-        if val.ty() != *ty {
-            bail!("global of type {:?} cannot be set to {:?}", ty, val.ty());
-        }
-        if !val.comes_from_same_store(store) {
-            bail!("cross-`Store` values are not supported");
-        }
-        unsafe {
-            let definition = &mut *store[self.0].definition;
-            match val {
-                Val::I32(i) => *definition.as_i32_mut() = i,
-                Val::I64(i) => *definition.as_i64_mut() = i,
-                Val::F32(f) => *definition.as_u32_mut() = f,
-                Val::F64(f) => *definition.as_u64_mut() = f,
-                Val::FuncRef(f) => {
-                    *definition.as_func_ref_mut() =
-                        f.map_or(ptr::null_mut(), |f| f.vm_func_ref(store).as_ptr().cast());
-                }
-                Val::ExternRef(x) => {
-                    let old = mem::replace(definition.as_externref_mut(), x.map(|x| x.inner));
-                    drop(old);
-                }
-                Val::V128(i) => *definition.as_u128_mut() = i.into(),
-            }
-        }
-        Ok(())
-    }
-
-    pub(crate) unsafe fn from_wasmtime_global(
-        wasmtime_export: wasmtime_runtime::ExportGlobal,
-        store: &mut StoreOpaque,
-    ) -> Global {
-        Global(store.store_data_mut().insert(wasmtime_export))
-    }
-
-    pub(crate) fn wasmtime_ty<'a>(&self, data: &'a StoreData) -> &'a wasmtime_environ::Global {
-        &data[self.0].global
-    }
-
-    pub(crate) fn vmimport(&self, store: &StoreOpaque) -> wasmtime_runtime::VMGlobalImport {
-        wasmtime_runtime::VMGlobalImport {
-            from: store[self.0].definition,
-        }
-    }
-
-    /// Get a stable hash key for this global.
-    ///
-    /// Even if the same underlying global definition is added to the
-    /// `StoreData` multiple times and becomes multiple `wasmtime::Global`s,
-    /// this hash key will be consistent across all of these globals.
-    pub(crate) fn hash_key(&self, store: &StoreOpaque) -> impl std::hash::Hash + Eq {
-        store[self.0].definition as usize
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{Instance, Module, Store};
-
-    #[test]
-    fn hash_key_is_stable_across_duplicate_store_data_entries() -> Result<()> {
-        let mut store = Store::<()>::default();
-        let module = Module::new(
-            store.engine(),
-            r#"
-                (module
-                    (global (export "g") (mut i32) (i32.const 0))
-                )
-            "#,
-        )?;
-        let instance = Instance::new(&mut store, &module, &[])?;
-
-        // Each time we `get_global`, we call `Global::from_wasmtime` which adds
-        // a new entry to `StoreData`, so `g1` and `g2` will have different
-        // indices into `StoreData`.
-        let g1 = instance.get_global(&mut store, "g").unwrap();
-        let g2 = instance.get_global(&mut store, "g").unwrap();
-
-        // That said, they really point to the same global.
-        assert_eq!(g1.get(&mut store).unwrap_i32(), 0);
-        assert_eq!(g2.get(&mut store).unwrap_i32(), 0);
-        g1.set(&mut store, Val::I32(42))?;
-        assert_eq!(g1.get(&mut store).unwrap_i32(), 42);
-        assert_eq!(g2.get(&mut store).unwrap_i32(), 42);
-
-        // And therefore their hash keys are the same.
-        assert!(g1.hash_key(&store.as_context().0) == g2.hash_key(&store.as_context().0));
-
-        // But the hash keys are different from different globals.
-        let instance2 = Instance::new(&mut store, &module, &[])?;
-        let g3 = instance2.get_global(&mut store, "g").unwrap();
-        assert!(g1.hash_key(&store.as_context().0) != g3.hash_key(&store.as_context().0));
-
-        Ok(())
-    }
-}
diff --git a/crates/wasmtime/src/externals/table.rs b/crates/wasmtime/src/externals/table.rs
deleted file mode 100644
index cbd688207d5d..000000000000
--- a/crates/wasmtime/src/externals/table.rs
+++ /dev/null
@@ -1,403 +0,0 @@
-use crate::store::{StoreData, StoreOpaque, Stored};
-use crate::trampoline::generate_table_export;
-use crate::{AsContext, AsContextMut, ExternRef, Func, TableType, Val};
-use anyhow::{anyhow, bail, Result};
-use wasmtime_runtime::{self as runtime};
-
-/// A WebAssembly `table`, or an array of values.
-///
-/// Like [`Memory`][crate::Memory] a table is an indexed array of values, but
-/// unlike [`Memory`][crate::Memory] it's an array of WebAssembly reference type
-/// values rather than bytes. One of the most common usages of a table is a
-/// function table for wasm modules (a `funcref` table), where each element has
-/// the `ValType::FuncRef` type.
-///
-/// A [`Table`] "belongs" to the store that it was originally created within
-/// (either via [`Table::new`] or via instantiating a
-/// [`Module`](crate::Module)). Operations on a [`Table`] only work with the
-/// store it belongs to, and if another store is passed in by accident then
-/// methods will panic.
-#[derive(Copy, Clone, Debug)]
-#[repr(transparent)] // here for the C API
-pub struct Table(pub(super) Stored<wasmtime_runtime::ExportTable>);
-
-impl Table {
-    /// Creates a new [`Table`] with the given parameters.
-    ///
-    /// * `store` - the owner of the resulting [`Table`]
-    /// * `ty` - the type of this table, containing both the element type as
-    ///   well as the initial size and maximum size, if any.
-    /// * `init` - the initial value to fill all table entries with, if the
-    ///   table starts with an initial size.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if `init` does not match the element type of the table,
-    /// or if `init` does not belong to the `store` provided.
-    ///
-    /// # Panics
-    ///
-    /// This function will panic when used with a [`Store`](`crate::Store`)
-    /// which has a [`ResourceLimiterAsync`](`crate::ResourceLimiterAsync`)
-    /// (see also: [`Store::limiter_async`](`crate::Store::limiter_async`).
-    /// When using an async resource limiter, use [`Table::new_async`]
-    /// instead.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// let engine = Engine::default();
-    /// let mut store = Store::new(&engine, ());
-    ///
-    /// let ty = TableType::new(ValType::FuncRef, 2, None);
-    /// let table = Table::new(&mut store, ty, Val::FuncRef(None))?;
-    ///
-    /// let module = Module::new(
-    ///     &engine,
-    ///     "(module
-    ///         (table (import \"\" \"\") 2 funcref)
-    ///         (func $f (result i32)
-    ///             i32.const 10)
-    ///         (elem (i32.const 0) $f)
-    ///     )"
-    /// )?;
-    ///
-    /// let instance = Instance::new(&mut store, &module, &[table.into()])?;
-    /// // ...
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn new(mut store: impl AsContextMut, ty: TableType, init: Val) -> Result<Table> {
-        Table::_new(store.as_context_mut().0, ty, init)
-    }
-
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "async")))]
-    /// Async variant of [`Table::new`]. You must use this variant with
-    /// [`Store`](`crate::Store`)s which have a
-    /// [`ResourceLimiterAsync`](`crate::ResourceLimiterAsync`).
-    ///
-    /// # Panics
-    ///
-    /// This function will panic when used with a non-async
-    /// [`Store`](`crate::Store`)
-    #[cfg(feature = "async")]
-    pub async fn new_async<T>(
-        mut store: impl AsContextMut<Data = T>,
-        ty: TableType,
-        init: Val,
-    ) -> Result<Table>
-    where
-        T: Send,
-    {
-        let mut store = store.as_context_mut();
-        assert!(
-            store.0.async_support(),
-            "cannot use `new_async` without enabling async support on the config"
-        );
-        store
-            .on_fiber(|store| Table::_new(store.0, ty, init))
-            .await?
-    }
-
-    fn _new(store: &mut StoreOpaque, ty: TableType, init: Val) -> Result<Table> {
-        let wasmtime_export = generate_table_export(store, &ty)?;
-        let init = init.into_table_element(store, ty.element())?;
-        unsafe {
-            let table = Table::from_wasmtime_table(wasmtime_export, store);
-            (*table.wasmtime_table(store, std::iter::empty())).fill(0, init, ty.minimum())?;
-
-            Ok(table)
-        }
-    }
-
-    /// Returns the underlying type of this table, including its element type as
-    /// well as the maximum/minimum lower bounds.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `store` does not own this table.
-    pub fn ty(&self, store: impl AsContext) -> TableType {
-        let store = store.as_context();
-        let ty = &store[self.0].table.table;
-        TableType::from_wasmtime_table(ty)
-    }
-
-    fn wasmtime_table(
-        &self,
-        store: &mut StoreOpaque,
-        lazy_init_range: impl Iterator<Item = u32>,
-    ) -> *mut runtime::Table {
-        unsafe {
-            let export = &store[self.0];
-            wasmtime_runtime::Instance::from_vmctx(export.vmctx, |handle| {
-                let idx = handle.table_index(&*export.definition);
-                handle.get_defined_table_with_lazy_init(idx, lazy_init_range)
-            })
-        }
-    }
-
-    /// Returns the table element value at `index`.
-    ///
-    /// Returns `None` if `index` is out of bounds.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `store` does not own this table.
-    pub fn get(&self, mut store: impl AsContextMut, index: u32) -> Option<Val> {
-        let store = store.as_context_mut().0;
-        let table = self.wasmtime_table(store, std::iter::once(index));
-        unsafe {
-            match (*table).get(index)? {
-                runtime::TableElement::FuncRef(f) => {
-                    let func = Func::from_caller_checked_func_ref(store, f);
-                    Some(Val::FuncRef(func))
-                }
-                runtime::TableElement::ExternRef(None) => Some(Val::ExternRef(None)),
-                runtime::TableElement::ExternRef(Some(x)) => {
-                    Some(Val::ExternRef(Some(ExternRef { inner: x })))
-                }
-                runtime::TableElement::UninitFunc => {
-                    unreachable!("lazy init above should have converted UninitFunc")
-                }
-            }
-        }
-    }
-
-    /// Writes the `val` provided into `index` within this table.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if `index` is out of bounds, if `val` does not have
-    /// the right type to be stored in this table, or if `val` belongs to a
-    /// different store.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `store` does not own this table.
-    pub fn set(&self, mut store: impl AsContextMut, index: u32, val: Val) -> Result<()> {
-        let store = store.as_context_mut().0;
-        let ty = self.ty(&store).element().clone();
-        let val = val.into_table_element(store, ty)?;
-        let table = self.wasmtime_table(store, std::iter::empty());
-        unsafe {
-            (*table)
-                .set(index, val)
-                .map_err(|()| anyhow!("table element index out of bounds"))
-        }
-    }
-
-    /// Returns the current size of this table.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `store` does not own this table.
-    pub fn size(&self, store: impl AsContext) -> u32 {
-        self.internal_size(store.as_context().0)
-    }
-
-    pub(crate) fn internal_size(&self, store: &StoreOpaque) -> u32 {
-        unsafe { (*store[self.0].definition).current_elements }
-    }
-
-    /// Grows the size of this table by `delta` more elements, initialization
-    /// all new elements to `init`.
-    ///
-    /// Returns the previous size of this table if successful.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the table cannot be grown by `delta`, for example
-    /// if it would cause the table to exceed its maximum size. Also returns an
-    /// error if `init` is not of the right type or if `init` does not belong to
-    /// `store`.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `store` does not own this table.
-    ///
-    /// This function will panic when used with a [`Store`](`crate::Store`)
-    /// which has a [`ResourceLimiterAsync`](`crate::ResourceLimiterAsync`)
-    /// (see also: [`Store::limiter_async`](`crate::Store::limiter_async`)).
-    /// When using an async resource limiter, use [`Table::grow_async`]
-    /// instead.
-    pub fn grow(&self, mut store: impl AsContextMut, delta: u32, init: Val) -> Result<u32> {
-        let store = store.as_context_mut().0;
-        let ty = self.ty(&store).element().clone();
-        let init = init.into_table_element(store, ty)?;
-        let table = self.wasmtime_table(store, std::iter::empty());
-        unsafe {
-            match (*table).grow(delta, init, store)? {
-                Some(size) => {
-                    let vm = (*table).vmtable();
-                    *store[self.0].definition = vm;
-                    Ok(size)
-                }
-                None => bail!("failed to grow table by `{}`", delta),
-            }
-        }
-    }
-
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "async")))]
-    /// Async variant of [`Table::grow`]. Required when using a
-    /// [`ResourceLimiterAsync`](`crate::ResourceLimiterAsync`).
-    ///
-    /// # Panics
-    ///
-    /// This function will panic when used with a non-async
-    /// [`Store`](`crate::Store`).
-    #[cfg(feature = "async")]
-    pub async fn grow_async<T>(
-        &self,
-        mut store: impl AsContextMut<Data = T>,
-        delta: u32,
-        init: Val,
-    ) -> Result<u32>
-    where
-        T: Send,
-    {
-        let mut store = store.as_context_mut();
-        assert!(
-            store.0.async_support(),
-            "cannot use `grow_async` without enabling async support on the config"
-        );
-        store
-            .on_fiber(|store| self.grow(store, delta, init))
-            .await?
-    }
-
-    /// Copy `len` elements from `src_table[src_index..]` into
-    /// `dst_table[dst_index..]`.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the range is out of bounds of either the source or
-    /// destination tables.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `store` does not own either `dst_table` or `src_table`.
-    pub fn copy(
-        mut store: impl AsContextMut,
-        dst_table: &Table,
-        dst_index: u32,
-        src_table: &Table,
-        src_index: u32,
-        len: u32,
-    ) -> Result<()> {
-        let store = store.as_context_mut().0;
-        if dst_table.ty(&store).element() != src_table.ty(&store).element() {
-            bail!("tables do not have the same element type");
-        }
-
-        let dst_table = dst_table.wasmtime_table(store, std::iter::empty());
-        let src_range = src_index..(src_index.checked_add(len).unwrap_or(u32::MAX));
-        let src_table = src_table.wasmtime_table(store, src_range);
-        unsafe {
-            runtime::Table::copy(dst_table, src_table, dst_index, src_index, len)?;
-        }
-        Ok(())
-    }
-
-    /// Fill `table[dst..(dst + len)]` with the given value.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if
-    ///
-    /// * `val` is not of the same type as this table's
-    ///   element type,
-    ///
-    /// * the region to be filled is out of bounds, or
-    ///
-    /// * `val` comes from a different `Store` from this table.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `store` does not own either `dst_table` or `src_table`.
-    pub fn fill(&self, mut store: impl AsContextMut, dst: u32, val: Val, len: u32) -> Result<()> {
-        let store = store.as_context_mut().0;
-        let ty = self.ty(&store).element().clone();
-        let val = val.into_table_element(store, ty)?;
-
-        let table = self.wasmtime_table(store, std::iter::empty());
-        unsafe {
-            (*table).fill(dst, val, len)?;
-        }
-
-        Ok(())
-    }
-
-    pub(crate) unsafe fn from_wasmtime_table(
-        wasmtime_export: wasmtime_runtime::ExportTable,
-        store: &mut StoreOpaque,
-    ) -> Table {
-        Table(store.store_data_mut().insert(wasmtime_export))
-    }
-
-    pub(crate) fn wasmtime_ty<'a>(&self, data: &'a StoreData) -> &'a wasmtime_environ::Table {
-        &data[self.0].table.table
-    }
-
-    pub(crate) fn vmimport(&self, store: &StoreOpaque) -> wasmtime_runtime::VMTableImport {
-        let export = &store[self.0];
-        wasmtime_runtime::VMTableImport {
-            from: export.definition,
-            vmctx: export.vmctx,
-        }
-    }
-
-    /// Get a stable hash key for this table.
-    ///
-    /// Even if the same underlying table definition is added to the
-    /// `StoreData` multiple times and becomes multiple `wasmtime::Table`s,
-    /// this hash key will be consistent across all of these tables.
-    #[allow(dead_code)] // Not used yet, but added for consistency.
-    pub(crate) fn hash_key(&self, store: &StoreOpaque) -> impl std::hash::Hash + Eq {
-        store[self.0].definition as usize
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{Instance, Module, Store};
-
-    #[test]
-    fn hash_key_is_stable_across_duplicate_store_data_entries() -> Result<()> {
-        let mut store = Store::<()>::default();
-        let module = Module::new(
-            store.engine(),
-            r#"
-                (module
-                    (table (export "t") 1 1 externref)
-                )
-            "#,
-        )?;
-        let instance = Instance::new(&mut store, &module, &[])?;
-
-        // Each time we `get_table`, we call `Table::from_wasmtime` which adds
-        // a new entry to `StoreData`, so `t1` and `t2` will have different
-        // indices into `StoreData`.
-        let t1 = instance.get_table(&mut store, "t").unwrap();
-        let t2 = instance.get_table(&mut store, "t").unwrap();
-
-        // That said, they really point to the same table.
-        assert!(t1.get(&mut store, 0).unwrap().unwrap_externref().is_none());
-        assert!(t2.get(&mut store, 0).unwrap().unwrap_externref().is_none());
-        t1.set(&mut store, 0, Val::ExternRef(Some(ExternRef::new(42))))?;
-        assert!(t1.get(&mut store, 0).unwrap().unwrap_externref().is_some());
-        assert!(t2.get(&mut store, 0).unwrap().unwrap_externref().is_some());
-
-        // And therefore their hash keys are the same.
-        assert!(t1.hash_key(&store.as_context().0) == t2.hash_key(&store.as_context().0));
-
-        // But the hash keys are different from different tables.
-        let instance2 = Instance::new(&mut store, &module, &[])?;
-        let t3 = instance2.get_table(&mut store, "t").unwrap();
-        assert!(t1.hash_key(&store.as_context().0) != t3.hash_key(&store.as_context().0));
-
-        Ok(())
-    }
-}
diff --git a/crates/wasmtime/src/func.rs b/crates/wasmtime/src/func.rs
deleted file mode 100644
index 8e3a39d004bf..000000000000
--- a/crates/wasmtime/src/func.rs
+++ /dev/null
@@ -1,2445 +0,0 @@
-use crate::store::{StoreData, StoreOpaque, Stored};
-use crate::{
-    AsContext, AsContextMut, CallHook, Engine, Extern, FuncType, Instance, Module, StoreContext,
-    StoreContextMut, Val, ValRaw, ValType,
-};
-use anyhow::{bail, Context as _, Error, Result};
-use std::ffi::c_void;
-use std::future::Future;
-use std::mem;
-use std::panic::{self, AssertUnwindSafe};
-use std::pin::Pin;
-use std::ptr::{self, NonNull};
-use std::sync::Arc;
-use wasmtime_runtime::{
-    ExportFunction, SendSyncPtr, StoreBox, VMArrayCallHostFuncContext, VMContext, VMFuncRef,
-    VMFunctionImport, VMNativeCallHostFuncContext, VMOpaqueContext, VMSharedSignatureIndex,
-};
-
-/// A WebAssembly function which can be called.
-///
-/// This type can represent either an exported function from a WebAssembly
-/// module or a host-defined function which can be used to satisfy an import of
-/// a module. [`Func`] and can be used to both instantiate an [`Instance`] as
-/// well as be extracted from an [`Instance`].
-///
-/// [`Instance`]: crate::Instance
-///
-/// A [`Func`] "belongs" to the store that it was originally created within.
-/// Operations on a [`Func`] only work with the store it belongs to, and if
-/// another store is passed in by accident then methods will panic.
-///
-/// # `Func` and `async`
-///
-/// Functions from the perspective of WebAssembly are always synchronous. You
-/// might have an `async` function in Rust, however, which you'd like to make
-/// available from WebAssembly. Wasmtime supports asynchronously calling
-/// WebAssembly through native stack switching. You can get some more
-/// information about [asynchronous configs](crate::Config::async_support), but
-/// from the perspective of `Func` it's important to know that whether or not
-/// your [`Store`](crate::Store) is asynchronous will dictate whether you call
-/// functions through [`Func::call`] or [`Func::call_async`] (or the typed
-/// wrappers such as [`TypedFunc::call`] vs [`TypedFunc::call_async`]).
-///
-/// # To `Func::call` or to `Func::typed().call()`
-///
-/// There's a 2x2 matrix of methods to call [`Func`]. Invocations can either be
-/// asynchronous or synchronous. They can also be statically typed or not.
-/// Whether or not an invocation is asynchronous is indicated via the method
-/// being `async` and [`call_async`](Func::call_async) being the entry point.
-/// Otherwise for statically typed or not your options are:
-///
-/// * Dynamically typed - if you don't statically know the signature of the
-///   function that you're calling you'll be using [`Func::call`] or
-///   [`Func::call_async`]. These functions take a variable-length slice of
-///   "boxed" arguments in their [`Val`] representation. Additionally the
-///   results are returned as an owned slice of [`Val`]. These methods are not
-///   optimized due to the dynamic type checks that must occur, in addition to
-///   some dynamic allocations for where to put all the arguments. While this
-///   allows you to call all possible wasm function signatures, if you're
-///   looking for a speedier alternative you can also use...
-///
-/// * Statically typed - if you statically know the type signature of the wasm
-///   function you're calling, then you'll want to use the [`Func::typed`]
-///   method to acquire an instance of [`TypedFunc`]. This structure is static proof
-///   that the underlying wasm function has the ascripted type, and type
-///   validation is only done once up-front. The [`TypedFunc::call`] and
-///   [`TypedFunc::call_async`] methods are much more efficient than [`Func::call`]
-///   and [`Func::call_async`] because the type signature is statically known.
-///   This eschews runtime checks as much as possible to get into wasm as fast
-///   as possible.
-///
-/// # Examples
-///
-/// One way to get a `Func` is from an [`Instance`] after you've instantiated
-/// it:
-///
-/// ```
-/// # use wasmtime::*;
-/// # fn main() -> anyhow::Result<()> {
-/// let engine = Engine::default();
-/// let module = Module::new(&engine, r#"(module (func (export "foo")))"#)?;
-/// let mut store = Store::new(&engine, ());
-/// let instance = Instance::new(&mut store, &module, &[])?;
-/// let foo = instance.get_func(&mut store, "foo").expect("export wasn't a function");
-///
-/// // Work with `foo` as a `Func` at this point, such as calling it
-/// // dynamically...
-/// match foo.call(&mut store, &[], &mut []) {
-///     Ok(()) => { /* ... */ }
-///     Err(trap) => {
-///         panic!("execution of `foo` resulted in a wasm trap: {}", trap);
-///     }
-/// }
-/// foo.call(&mut store, &[], &mut [])?;
-///
-/// // ... or we can make a static assertion about its signature and call it.
-/// // Our first call here can fail if the signatures don't match, and then the
-/// // second call can fail if the function traps (like the `match` above).
-/// let foo = foo.typed::<(), ()>(&store)?;
-/// foo.call(&mut store, ())?;
-/// # Ok(())
-/// # }
-/// ```
-///
-/// You can also use the [`wrap` function](Func::wrap) to create a
-/// `Func`
-///
-/// ```
-/// # use wasmtime::*;
-/// # fn main() -> anyhow::Result<()> {
-/// let mut store = Store::<()>::default();
-///
-/// // Create a custom `Func` which can execute arbitrary code inside of the
-/// // closure.
-/// let add = Func::wrap(&mut store, |a: i32, b: i32| -> i32 { a + b });
-///
-/// // Next we can hook that up to a wasm module which uses it.
-/// let module = Module::new(
-///     store.engine(),
-///     r#"
-///         (module
-///             (import "" "" (func $add (param i32 i32) (result i32)))
-///             (func (export "call_add_twice") (result i32)
-///                 i32.const 1
-///                 i32.const 2
-///                 call $add
-///                 i32.const 3
-///                 i32.const 4
-///                 call $add
-///                 i32.add))
-///     "#,
-/// )?;
-/// let instance = Instance::new(&mut store, &module, &[add.into()])?;
-/// let call_add_twice = instance.get_typed_func::<(), i32>(&mut store, "call_add_twice")?;
-///
-/// assert_eq!(call_add_twice.call(&mut store, ())?, 10);
-/// # Ok(())
-/// # }
-/// ```
-///
-/// Or you could also create an entirely dynamic `Func`!
-///
-/// ```
-/// # use wasmtime::*;
-/// # fn main() -> anyhow::Result<()> {
-/// let mut store = Store::<()>::default();
-///
-/// // Here we need to define the type signature of our `Double` function and
-/// // then wrap it up in a `Func`
-/// let double_type = wasmtime::FuncType::new(
-///     [wasmtime::ValType::I32].iter().cloned(),
-///     [wasmtime::ValType::I32].iter().cloned(),
-/// );
-/// let double = Func::new(&mut store, double_type, |_, params, results| {
-///     let mut value = params[0].unwrap_i32();
-///     value *= 2;
-///     results[0] = value.into();
-///     Ok(())
-/// });
-///
-/// let module = Module::new(
-///     store.engine(),
-///     r#"
-///         (module
-///             (import "" "" (func $double (param i32) (result i32)))
-///             (func $start
-///                 i32.const 1
-///                 call $double
-///                 drop)
-///             (start $start))
-///     "#,
-/// )?;
-/// let instance = Instance::new(&mut store, &module, &[double.into()])?;
-/// // .. work with `instance` if necessary
-/// # Ok(())
-/// # }
-/// ```
-#[derive(Copy, Clone, Debug)]
-#[repr(transparent)] // here for the C API
-pub struct Func(Stored<FuncData>);
-
-pub(crate) struct FuncData {
-    kind: FuncKind,
-
-    // A pointer to the in-store `VMFuncRef` for this function, if
-    // any.
-    //
-    // When a function is passed to Wasm but doesn't have a Wasm-to-native
-    // trampoline, we have to patch it in. But that requires mutating the
-    // `VMFuncRef`, and this function could be shared across
-    // threads. So we instead copy and pin the `VMFuncRef` into
-    // `StoreOpaque::func_refs`, where we can safely patch the field without
-    // worrying about synchronization and we hold a pointer to it here so we can
-    // reuse it rather than re-copy if it is passed to Wasm again.
-    in_store_func_ref: Option<SendSyncPtr<VMFuncRef>>,
-
-    // This is somewhat expensive to load from the `Engine` and in most
-    // optimized use cases (e.g. `TypedFunc`) it's not actually needed or it's
-    // only needed rarely. To handle that this is an optionally-contained field
-    // which is lazily loaded into as part of `Func::call`.
-    //
-    // Also note that this is intentionally placed behind a pointer to keep it
-    // small as `FuncData` instances are often inserted into a `Store`.
-    ty: Option<Box<FuncType>>,
-}
-
-/// The three ways that a function can be created and referenced from within a
-/// store.
-enum FuncKind {
-    /// A function already owned by the store via some other means. This is
-    /// used, for example, when creating a `Func` from an instance's exported
-    /// function. The instance's `InstanceHandle` is already owned by the store
-    /// and we just have some pointers into that which represent how to call the
-    /// function.
-    StoreOwned { export: ExportFunction },
-
-    /// A function is shared across possibly other stores, hence the `Arc`. This
-    /// variant happens when a `Linker`-defined function is instantiated within
-    /// a `Store` (e.g. via `Linker::get` or similar APIs). The `Arc` here
-    /// indicates that there's some number of other stores holding this function
-    /// too, so dropping this may not deallocate the underlying
-    /// `InstanceHandle`.
-    SharedHost(Arc<HostFunc>),
-
-    /// A uniquely-owned host function within a `Store`. This comes about with
-    /// `Func::new` or similar APIs. The `HostFunc` internally owns the
-    /// `InstanceHandle` and that will get dropped when this `HostFunc` itself
-    /// is dropped.
-    ///
-    /// Note that this is intentionally placed behind a `Box` to minimize the
-    /// size of this enum since the most common variant for high-peformance
-    /// situations is `SharedHost` and `StoreOwned`, so this ideally isn't
-    /// larger than those two.
-    Host(Box<HostFunc>),
-
-    /// A reference to a `HostFunc`, but one that's "rooted" in the `Store`
-    /// itself.
-    ///
-    /// This variant is created when an `InstancePre<T>` is instantiated in to a
-    /// `Store<T>`. In that situation the `InstancePre<T>` already has a list of
-    /// host functions that are packaged up in an `Arc`, so the `Arc<[T]>` is
-    /// cloned once into the `Store` to avoid each individual function requiring
-    /// an `Arc::clone`.
-    ///
-    /// The lifetime management of this type is `unsafe` because
-    /// `RootedHostFunc` is a small wrapper around `NonNull<HostFunc>`. To be
-    /// safe this is required that the memory of the host function is pinned
-    /// elsewhere (e.g. the `Arc` in the `Store`).
-    RootedHost(RootedHostFunc),
-}
-
-macro_rules! for_each_function_signature {
-    ($mac:ident) => {
-        $mac!(0);
-        $mac!(1 A1);
-        $mac!(2 A1 A2);
-        $mac!(3 A1 A2 A3);
-        $mac!(4 A1 A2 A3 A4);
-        $mac!(5 A1 A2 A3 A4 A5);
-        $mac!(6 A1 A2 A3 A4 A5 A6);
-        $mac!(7 A1 A2 A3 A4 A5 A6 A7);
-        $mac!(8 A1 A2 A3 A4 A5 A6 A7 A8);
-        $mac!(9 A1 A2 A3 A4 A5 A6 A7 A8 A9);
-        $mac!(10 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10);
-        $mac!(11 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11);
-        $mac!(12 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12);
-        $mac!(13 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13);
-        $mac!(14 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14);
-        $mac!(15 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14 A15);
-        $mac!(16 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14 A15 A16);
-    };
-}
-
-mod typed;
-pub use typed::*;
-
-macro_rules! generate_wrap_async_func {
-    ($num:tt $($args:ident)*) => (paste::paste!{
-        /// Same as [`Func::wrap`], except the closure asynchronously produces
-        /// its result. For more information see the [`Func`] documentation.
-        ///
-        /// # Panics
-        ///
-        /// This function will panic if called with a non-asynchronous store.
-        #[allow(non_snake_case)]
-        #[cfg(feature = "async")]
-        #[cfg_attr(nightlydoc, doc(cfg(feature = "async")))]
-        pub fn [<wrap $num _async>]<T, $($args,)* R>(
-            store: impl AsContextMut<Data = T>,
-            func: impl for<'a> Fn(Caller<'a, T>, $($args),*) -> Box<dyn Future<Output = R> + Send + 'a> + Send + Sync + 'static,
-        ) -> Func
-        where
-            $($args: WasmTy,)*
-            R: WasmRet,
-        {
-            assert!(store.as_context().async_support(), concat!("cannot use `wrap", $num, "_async` without enabling async support on the config"));
-            Func::wrap(store, move |mut caller: Caller<'_, T>, $($args: $args),*| {
-                let async_cx = caller.store.as_context_mut().0.async_cx().expect("Attempt to start async function on dying fiber");
-                let mut future = Pin::from(func(caller, $($args),*));
-
-                match unsafe { async_cx.block_on(future.as_mut()) } {
-                    Ok(ret) => ret.into_fallible(),
-                    Err(e) => R::fallible_from_error(e),
-                }
-            })
-        }
-    })
-}
-
-impl Func {
-    /// Creates a new `Func` with the given arguments, typically to create a
-    /// host-defined function to pass as an import to a module.
-    ///
-    /// * `store` - the store in which to create this [`Func`], which will own
-    ///   the return value.
-    ///
-    /// * `ty` - the signature of this function, used to indicate what the
-    ///   inputs and outputs are.
-    ///
-    /// * `func` - the native code invoked whenever this `Func` will be called.
-    ///   This closure is provided a [`Caller`] as its first argument to learn
-    ///   information about the caller, and then it's passed a list of
-    ///   parameters as a slice along with a mutable slice of where to write
-    ///   results.
-    ///
-    /// Note that the implementation of `func` must adhere to the `ty` signature
-    /// given, error or traps may occur if it does not respect the `ty`
-    /// signature. For example if the function type declares that it returns one
-    /// i32 but the `func` closures does not write anything into the results
-    /// slice then a trap may be generated.
-    ///
-    /// Additionally note that this is quite a dynamic function since signatures
-    /// are not statically known. For a more performant and ergonomic `Func`
-    /// it's recommended to use [`Func::wrap`] if you can because with
-    /// statically known signatures Wasmtime can optimize the implementation
-    /// much more.
-    ///
-    /// For more information about `Send + Sync + 'static` requirements on the
-    /// `func`, see [`Func::wrap`](#why-send--sync--static).
-    ///
-    /// # Errors
-    ///
-    /// The host-provided function here returns a
-    /// [`Result<()>`](anyhow::Result). If the function returns `Ok(())` then
-    /// that indicates that the host function completed successfully and wrote
-    /// the result into the `&mut [Val]` argument.
-    ///
-    /// If the function returns `Err(e)`, however, then this is equivalent to
-    /// the host function triggering a trap for wasm. WebAssembly execution is
-    /// immediately halted and the original caller of [`Func::call`], for
-    /// example, will receive the error returned here (possibly with
-    /// [`WasmBacktrace`](crate::WasmBacktrace) context information attached).
-    ///
-    /// For more information about errors in Wasmtime see the [`Trap`]
-    /// documentation.
-    ///
-    /// [`Trap`]: crate::Trap
-    #[cfg(any(feature = "cranelift", feature = "winch"))]
-    #[cfg_attr(nightlydoc, doc(cfg(any(feature = "cranelift", feature = "winch"))))]
-    pub fn new<T>(
-        store: impl AsContextMut<Data = T>,
-        ty: FuncType,
-        func: impl Fn(Caller<'_, T>, &[Val], &mut [Val]) -> Result<()> + Send + Sync + 'static,
-    ) -> Self {
-        let ty_clone = ty.clone();
-        unsafe {
-            Func::new_unchecked(store, ty, move |caller, values| {
-                Func::invoke(caller, &ty_clone, values, &func)
-            })
-        }
-    }
-
-    /// Creates a new [`Func`] with the given arguments, although has fewer
-    /// runtime checks than [`Func::new`].
-    ///
-    /// This function takes a callback of a different signature than
-    /// [`Func::new`], instead receiving a raw pointer with a list of [`ValRaw`]
-    /// structures. These values have no type information associated with them
-    /// so it's up to the caller to provide a function that will correctly
-    /// interpret the list of values as those coming from the `ty` specified.
-    ///
-    /// If you're calling this from Rust it's recommended to either instead use
-    /// [`Func::new`] or [`Func::wrap`]. The [`Func::wrap`] API, in particular,
-    /// is both safer and faster than this API.
-    ///
-    /// # Errors
-    ///
-    /// See [`Func::new`] for the behavior of returning an error from the host
-    /// function provided here.
-    ///
-    /// # Unsafety
-    ///
-    /// This function is not safe because it's not known at compile time that
-    /// the `func` provided correctly interprets the argument types provided to
-    /// it, or that the results it produces will be of the correct type.
-    #[cfg(any(feature = "cranelift", feature = "winch"))]
-    #[cfg_attr(nightlydoc, doc(cfg(any(feature = "cranelift", feature = "winch"))))]
-    pub unsafe fn new_unchecked<T>(
-        mut store: impl AsContextMut<Data = T>,
-        ty: FuncType,
-        func: impl Fn(Caller<'_, T>, &mut [ValRaw]) -> Result<()> + Send + Sync + 'static,
-    ) -> Self {
-        let store = store.as_context_mut().0;
-        let host = HostFunc::new_unchecked(store.engine(), ty, func);
-        host.into_func(store)
-    }
-
-    /// Creates a new host-defined WebAssembly function which, when called,
-    /// will run the asynchronous computation defined by `func` to completion
-    /// and then return the result to WebAssembly.
-    ///
-    /// This function is the asynchronous analogue of [`Func::new`] and much of
-    /// that documentation applies to this as well. The key difference is that
-    /// `func` returns a future instead of simply a `Result`. Note that the
-    /// returned future can close over any of the arguments, but it cannot close
-    /// over the state of the closure itself. It's recommended to store any
-    /// necessary async state in the `T` of the [`Store<T>`](crate::Store) which
-    /// can be accessed through [`Caller::data`] or [`Caller::data_mut`].
-    ///
-    /// For more information on `Send + Sync + 'static`, see
-    /// [`Func::wrap`](#why-send--sync--static).
-    ///
-    /// # Panics
-    ///
-    /// This function will panic if `store` is not associated with an [async
-    /// config](crate::Config::async_support).
-    ///
-    /// # Errors
-    ///
-    /// See [`Func::new`] for the behavior of returning an error from the host
-    /// function provided here.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// // Simulate some application-specific state as well as asynchronous
-    /// // functions to query that state.
-    /// struct MyDatabase {
-    ///     // ...
-    /// }
-    ///
-    /// impl MyDatabase {
-    ///     async fn get_row_count(&self) -> u32 {
-    ///         // ...
-    /// #       100
-    ///     }
-    /// }
-    ///
-    /// let my_database = MyDatabase {
-    ///     // ...
-    /// };
-    ///
-    /// // Using `new_async` we can hook up into calling our async
-    /// // `get_row_count` function.
-    /// let engine = Engine::new(Config::new().async_support(true))?;
-    /// let mut store = Store::new(&engine, MyDatabase {
-    ///     // ...
-    /// });
-    /// let get_row_count_type = wasmtime::FuncType::new(
-    ///     None,
-    ///     Some(wasmtime::ValType::I32),
-    /// );
-    /// let get = Func::new_async(&mut store, get_row_count_type, |caller, _params, results| {
-    ///     Box::new(async move {
-    ///         let count = caller.data().get_row_count().await;
-    ///         results[0] = Val::I32(count as i32);
-    ///         Ok(())
-    ///     })
-    /// });
-    /// // ...
-    /// # Ok(())
-    /// # }
-    /// ```
-    #[cfg(all(feature = "async", feature = "cranelift"))]
-    #[cfg_attr(nightlydoc, doc(cfg(all(feature = "async", feature = "cranelift"))))]
-    pub fn new_async<T, F>(store: impl AsContextMut<Data = T>, ty: FuncType, func: F) -> Func
-    where
-        F: for<'a> Fn(
-                Caller<'a, T>,
-                &'a [Val],
-                &'a mut [Val],
-            ) -> Box<dyn Future<Output = Result<()>> + Send + 'a>
-            + Send
-            + Sync
-            + 'static,
-    {
-        assert!(
-            store.as_context().async_support(),
-            "cannot use `new_async` without enabling async support in the config"
-        );
-        Func::new(store, ty, move |mut caller, params, results| {
-            let async_cx = caller
-                .store
-                .as_context_mut()
-                .0
-                .async_cx()
-                .expect("Attempt to spawn new action on dying fiber");
-            let mut future = Pin::from(func(caller, params, results));
-            match unsafe { async_cx.block_on(future.as_mut()) } {
-                Ok(Ok(())) => Ok(()),
-                Ok(Err(trap)) | Err(trap) => Err(trap),
-            }
-        })
-    }
-
-    pub(crate) unsafe fn from_caller_checked_func_ref(
-        store: &mut StoreOpaque,
-        raw: *mut VMFuncRef,
-    ) -> Option<Func> {
-        let func_ref = NonNull::new(raw)?;
-        debug_assert!(func_ref.as_ref().type_index != VMSharedSignatureIndex::default());
-        let export = ExportFunction { func_ref };
-        Some(Func::from_wasmtime_function(export, store))
-    }
-
-    /// Creates a new `Func` from the given Rust closure.
-    ///
-    /// This function will create a new `Func` which, when called, will
-    /// execute the given Rust closure. Unlike [`Func::new`] the target
-    /// function being called is known statically so the type signature can
-    /// be inferred. Rust types will map to WebAssembly types as follows:
-    ///
-    /// | Rust Argument Type  | WebAssembly Type |
-    /// |---------------------|------------------|
-    /// | `i32`               | `i32`            |
-    /// | `u32`               | `i32`            |
-    /// | `i64`               | `i64`            |
-    /// | `u64`               | `i64`            |
-    /// | `f32`               | `f32`            |
-    /// | `f64`               | `f64`            |
-    /// | (not supported)     | `v128`           |
-    /// | `Option<Func>`      | `funcref`        |
-    /// | `Option<ExternRef>` | `externref`      |
-    ///
-    /// Any of the Rust types can be returned from the closure as well, in
-    /// addition to some extra types
-    ///
-    /// | Rust Return Type  | WebAssembly Return Type | Meaning               |
-    /// |-------------------|-------------------------|-----------------------|
-    /// | `()`              | nothing                 | no return value       |
-    /// | `T`               | `T`                     | a single return value |
-    /// | `(T1, T2, ...)`   | `T1 T2 ...`             | multiple returns      |
-    ///
-    /// Note that all return types can also be wrapped in `Result<_>` to
-    /// indicate that the host function can generate a trap as well as possibly
-    /// returning a value.
-    ///
-    /// Finally you can also optionally take [`Caller`] as the first argument of
-    /// your closure. If inserted then you're able to inspect the caller's
-    /// state, for example the [`Memory`](crate::Memory) it has exported so you
-    /// can read what pointers point to.
-    ///
-    /// Note that when using this API, the intention is to create as thin of a
-    /// layer as possible for when WebAssembly calls the function provided. With
-    /// sufficient inlining and optimization the WebAssembly will call straight
-    /// into `func` provided, with no extra fluff entailed.
-    ///
-    /// # Why `Send + Sync + 'static`?
-    ///
-    /// All host functions defined in a [`Store`](crate::Store) (including
-    /// those from [`Func::new`] and other constructors) require that the
-    /// `func` provided is `Send + Sync + 'static`. Additionally host functions
-    /// always are `Fn` as opposed to `FnMut` or `FnOnce`. This can at-a-glance
-    /// feel restrictive since the closure cannot close over as many types as
-    /// before. The reason for this, though, is to ensure that
-    /// [`Store<T>`](crate::Store) can implement both the `Send` and `Sync`
-    /// traits.
-    ///
-    /// Fear not, however, because this isn't as restrictive as it seems! Host
-    /// functions are provided a [`Caller<'_, T>`](crate::Caller) argument which
-    /// allows access to the host-defined data within the
-    /// [`Store`](crate::Store). The `T` type is not required to be any of
-    /// `Send`, `Sync`, or `'static`! This means that you can store whatever
-    /// you'd like in `T` and have it accessible by all host functions.
-    /// Additionally mutable access to `T` is allowed through
-    /// [`Caller::data_mut`].
-    ///
-    /// Most host-defined [`Func`] values provide closures that end up not
-    /// actually closing over any values. These zero-sized types will use the
-    /// context from [`Caller`] for host-defined information.
-    ///
-    /// # Errors
-    ///
-    /// The closure provided here to `wrap` can optionally return a
-    /// [`Result<T>`](anyhow::Result). Returning `Ok(t)` represents the host
-    /// function successfully completing with the `t` result. Returning
-    /// `Err(e)`, however, is equivalent to raising a custom wasm trap.
-    /// Execution of WebAssembly does not resume and the stack is unwound to the
-    /// original caller of the function where the error is returned.
-    ///
-    /// For more information about errors in Wasmtime see the [`Trap`]
-    /// documentation.
-    ///
-    /// [`Trap`]: crate::Trap
-    ///
-    /// # Examples
-    ///
-    /// First up we can see how simple wasm imports can be implemented, such
-    /// as a function that adds its two arguments and returns the result.
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// # let mut store = Store::<()>::default();
-    /// let add = Func::wrap(&mut store, |a: i32, b: i32| a + b);
-    /// let module = Module::new(
-    ///     store.engine(),
-    ///     r#"
-    ///         (module
-    ///             (import "" "" (func $add (param i32 i32) (result i32)))
-    ///             (func (export "foo") (param i32 i32) (result i32)
-    ///                 local.get 0
-    ///                 local.get 1
-    ///                 call $add))
-    ///     "#,
-    /// )?;
-    /// let instance = Instance::new(&mut store, &module, &[add.into()])?;
-    /// let foo = instance.get_typed_func::<(i32, i32), i32>(&mut store, "foo")?;
-    /// assert_eq!(foo.call(&mut store, (1, 2))?, 3);
-    /// # Ok(())
-    /// # }
-    /// ```
-    ///
-    /// We can also do the same thing, but generate a trap if the addition
-    /// overflows:
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// # let mut store = Store::<()>::default();
-    /// let add = Func::wrap(&mut store, |a: i32, b: i32| {
-    ///     match a.checked_add(b) {
-    ///         Some(i) => Ok(i),
-    ///         None => anyhow::bail!("overflow"),
-    ///     }
-    /// });
-    /// let module = Module::new(
-    ///     store.engine(),
-    ///     r#"
-    ///         (module
-    ///             (import "" "" (func $add (param i32 i32) (result i32)))
-    ///             (func (export "foo") (param i32 i32) (result i32)
-    ///                 local.get 0
-    ///                 local.get 1
-    ///                 call $add))
-    ///     "#,
-    /// )?;
-    /// let instance = Instance::new(&mut store, &module, &[add.into()])?;
-    /// let foo = instance.get_typed_func::<(i32, i32), i32>(&mut store, "foo")?;
-    /// assert_eq!(foo.call(&mut store, (1, 2))?, 3);
-    /// assert!(foo.call(&mut store, (i32::max_value(), 1)).is_err());
-    /// # Ok(())
-    /// # }
-    /// ```
-    ///
-    /// And don't forget all the wasm types are supported!
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// # let mut store = Store::<()>::default();
-    /// let debug = Func::wrap(&mut store, |a: i32, b: u32, c: f32, d: i64, e: u64, f: f64| {
-    ///
-    ///     println!("a={}", a);
-    ///     println!("b={}", b);
-    ///     println!("c={}", c);
-    ///     println!("d={}", d);
-    ///     println!("e={}", e);
-    ///     println!("f={}", f);
-    /// });
-    /// let module = Module::new(
-    ///     store.engine(),
-    ///     r#"
-    ///         (module
-    ///             (import "" "" (func $debug (param i32 i32 f32 i64 i64 f64)))
-    ///             (func (export "foo")
-    ///                 i32.const -1
-    ///                 i32.const 1
-    ///                 f32.const 2
-    ///                 i64.const -3
-    ///                 i64.const 3
-    ///                 f64.const 4
-    ///                 call $debug))
-    ///     "#,
-    /// )?;
-    /// let instance = Instance::new(&mut store, &module, &[debug.into()])?;
-    /// let foo = instance.get_typed_func::<(), ()>(&mut store, "foo")?;
-    /// foo.call(&mut store, ())?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    ///
-    /// Finally if you want to get really fancy you can also implement
-    /// imports that read/write wasm module's memory
-    ///
-    /// ```
-    /// use std::str;
-    ///
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// # let mut store = Store::default();
-    /// let log_str = Func::wrap(&mut store, |mut caller: Caller<'_, ()>, ptr: i32, len: i32| {
-    ///     let mem = match caller.get_export("memory") {
-    ///         Some(Extern::Memory(mem)) => mem,
-    ///         _ => anyhow::bail!("failed to find host memory"),
-    ///     };
-    ///     let data = mem.data(&caller)
-    ///         .get(ptr as u32 as usize..)
-    ///         .and_then(|arr| arr.get(..len as u32 as usize));
-    ///     let string = match data {
-    ///         Some(data) => match str::from_utf8(data) {
-    ///             Ok(s) => s,
-    ///             Err(_) => anyhow::bail!("invalid utf-8"),
-    ///         },
-    ///         None => anyhow::bail!("pointer/length out of bounds"),
-    ///     };
-    ///     assert_eq!(string, "Hello, world!");
-    ///     println!("{}", string);
-    ///     Ok(())
-    /// });
-    /// let module = Module::new(
-    ///     store.engine(),
-    ///     r#"
-    ///         (module
-    ///             (import "" "" (func $log_str (param i32 i32)))
-    ///             (func (export "foo")
-    ///                 i32.const 4   ;; ptr
-    ///                 i32.const 13  ;; len
-    ///                 call $log_str)
-    ///             (memory (export "memory") 1)
-    ///             (data (i32.const 4) "Hello, world!"))
-    ///     "#,
-    /// )?;
-    /// let instance = Instance::new(&mut store, &module, &[log_str.into()])?;
-    /// let foo = instance.get_typed_func::<(), ()>(&mut store, "foo")?;
-    /// foo.call(&mut store, ())?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn wrap<T, Params, Results>(
-        mut store: impl AsContextMut<Data = T>,
-        func: impl IntoFunc<T, Params, Results>,
-    ) -> Func {
-        let store = store.as_context_mut().0;
-        // part of this unsafety is about matching the `T` to a `Store<T>`,
-        // which is done through the `AsContextMut` bound above.
-        unsafe {
-            let host = HostFunc::wrap(store.engine(), func);
-            host.into_func(store)
-        }
-    }
-
-    for_each_function_signature!(generate_wrap_async_func);
-
-    /// Returns the underlying wasm type that this `Func` has.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `store` does not own this function.
-    pub fn ty(&self, store: impl AsContext) -> FuncType {
-        self.load_ty(&store.as_context().0)
-    }
-
-    /// Forcibly loads the type of this function from the `Engine`.
-    ///
-    /// Note that this is a somewhat expensive method since it requires taking a
-    /// lock as well as cloning a type.
-    fn load_ty(&self, store: &StoreOpaque) -> FuncType {
-        FuncType::from_wasm_func_type(
-            store
-                .engine()
-                .signatures()
-                .lookup_type(self.sig_index(store.store_data()))
-                .expect("signature should be registered"),
-        )
-    }
-
-    /// Gets a reference to the `FuncType` for this function.
-    ///
-    /// Note that this returns both a reference to the type of this function as
-    /// well as a reference back to the store itself. This enables using the
-    /// `StoreOpaque` while the `FuncType` is also being used (from the
-    /// perspective of the borrow-checker) because otherwise the signature would
-    /// consider `StoreOpaque` borrowed mutable while `FuncType` is in use.
-    fn ty_ref<'a>(&self, store: &'a mut StoreOpaque) -> (&'a FuncType, &'a StoreOpaque) {
-        // If we haven't loaded our type into the store yet then do so lazily at
-        // this time.
-        if store.store_data()[self.0].ty.is_none() {
-            let ty = self.load_ty(store);
-            store.store_data_mut()[self.0].ty = Some(Box::new(ty));
-        }
-
-        (store.store_data()[self.0].ty.as_ref().unwrap(), store)
-    }
-
-    pub(crate) fn sig_index(&self, data: &StoreData) -> VMSharedSignatureIndex {
-        data[self.0].sig_index()
-    }
-
-    /// Invokes this function with the `params` given and writes returned values
-    /// to `results`.
-    ///
-    /// The `params` here must match the type signature of this `Func`, or an
-    /// error will occur. Additionally `results` must have the same
-    /// length as the number of results for this function. Calling this function
-    /// will synchronously execute the WebAssembly function referenced to get
-    /// the results.
-    ///
-    /// This function will return `Ok(())` if execution completed without a trap
-    /// or error of any kind. In this situation the results will be written to
-    /// the provided `results` array.
-    ///
-    /// # Errors
-    ///
-    /// Any error which occurs throughout the execution of the function will be
-    /// returned as `Err(e)`. The [`Error`](anyhow::Error) type can be inspected
-    /// for the precise error cause such as:
-    ///
-    /// * [`Trap`] - indicates that a wasm trap happened and execution was
-    ///   halted.
-    /// * [`WasmBacktrace`] - optionally included on errors for backtrace
-    ///   information of the trap/error.
-    /// * Other string-based errors to indicate issues such as type errors with
-    ///   `params`.
-    /// * Any host-originating error originally returned from a function defined
-    ///   via [`Func::new`], for example.
-    ///
-    /// Errors typically indicate that execution of WebAssembly was halted
-    /// mid-way and did not complete after the error condition happened.
-    ///
-    /// [`Trap`]: crate::Trap
-    ///
-    /// # Panics
-    ///
-    /// This function will panic if called on a function belonging to an async
-    /// store. Asynchronous stores must always use `call_async`.
-    /// initiates a panic. Also panics if `store` does not own this function.
-    ///
-    /// [`WasmBacktrace`]: crate::WasmBacktrace
-    pub fn call(
-        &self,
-        mut store: impl AsContextMut,
-        params: &[Val],
-        results: &mut [Val],
-    ) -> Result<()> {
-        assert!(
-            !store.as_context().async_support(),
-            "must use `call_async` when async support is enabled on the config",
-        );
-        self.call_impl(&mut store.as_context_mut(), params, results)
-    }
-
-    /// Invokes this function in an "unchecked" fashion, reading parameters and
-    /// writing results to `params_and_returns`.
-    ///
-    /// This function is the same as [`Func::call`] except that the arguments
-    /// and results both use a different representation. If possible it's
-    /// recommended to use [`Func::call`] if safety isn't necessary or to use
-    /// [`Func::typed`] in conjunction with [`TypedFunc::call`] since that's
-    /// both safer and faster than this method of invoking a function.
-    ///
-    /// Note that if this function takes `externref` arguments then it will
-    /// **not** automatically GC unlike the [`Func::call`] and
-    /// [`TypedFunc::call`] functions. This means that if this function is
-    /// invoked many times with new `ExternRef` values and no other GC happens
-    /// via any other means then no values will get collected.
-    ///
-    /// # Errors
-    ///
-    /// For more information about errors see the [`Func::call`] documentation.
-    ///
-    /// # Unsafety
-    ///
-    /// This function is unsafe because the `params_and_returns` argument is not
-    /// validated at all. It must uphold invariants such as:
-    ///
-    /// * It's a valid pointer to an array
-    /// * It has enough space to store all parameters
-    /// * It has enough space to store all results (not at the same time as
-    ///   parameters)
-    /// * Parameters are initially written to the array and have the correct
-    ///   types and such.
-    /// * Reference types like `externref` and `funcref` are valid at the
-    ///   time of this call and for the `store` specified.
-    ///
-    /// These invariants are all upheld for you with [`Func::call`] and
-    /// [`TypedFunc::call`].
-    pub unsafe fn call_unchecked(
-        &self,
-        mut store: impl AsContextMut,
-        params_and_returns: *mut ValRaw,
-        params_and_returns_capacity: usize,
-    ) -> Result<()> {
-        let mut store = store.as_context_mut();
-        let data = &store.0.store_data()[self.0];
-        let func_ref = data.export().func_ref;
-        Self::call_unchecked_raw(
-            &mut store,
-            func_ref,
-            params_and_returns,
-            params_and_returns_capacity,
-        )
-    }
-
-    pub(crate) unsafe fn call_unchecked_raw<T>(
-        store: &mut StoreContextMut<'_, T>,
-        func_ref: NonNull<VMFuncRef>,
-        params_and_returns: *mut ValRaw,
-        params_and_returns_capacity: usize,
-    ) -> Result<()> {
-        invoke_wasm_and_catch_traps(store, |caller| {
-            let func_ref = func_ref.as_ref();
-            (func_ref.array_call)(
-                func_ref.vmctx,
-                caller.cast::<VMOpaqueContext>(),
-                params_and_returns,
-                params_and_returns_capacity,
-            )
-        })
-    }
-
-    /// Converts the raw representation of a `funcref` into an `Option<Func>`
-    ///
-    /// This is intended to be used in conjunction with [`Func::new_unchecked`],
-    /// [`Func::call_unchecked`], and [`ValRaw`] with its `funcref` field.
-    ///
-    /// # Unsafety
-    ///
-    /// This function is not safe because `raw` is not validated at all. The
-    /// caller must guarantee that `raw` is owned by the `store` provided and is
-    /// valid within the `store`.
-    pub unsafe fn from_raw(mut store: impl AsContextMut, raw: *mut c_void) -> Option<Func> {
-        Func::from_caller_checked_func_ref(store.as_context_mut().0, raw.cast())
-    }
-
-    /// Extracts the raw value of this `Func`, which is owned by `store`.
-    ///
-    /// This function returns a value that's suitable for writing into the
-    /// `funcref` field of the [`ValRaw`] structure.
-    ///
-    /// # Unsafety
-    ///
-    /// The returned value is only valid for as long as the store is alive and
-    /// this function is properly rooted within it. Additionally this function
-    /// should not be liberally used since it's a very low-level knob.
-    pub unsafe fn to_raw(&self, mut store: impl AsContextMut) -> *mut c_void {
-        self.vm_func_ref(store.as_context_mut().0).as_ptr().cast()
-    }
-
-    /// Invokes this function with the `params` given, returning the results
-    /// asynchronously.
-    ///
-    /// This function is the same as [`Func::call`] except that it is
-    /// asynchronous. This is only compatible with stores associated with an
-    /// [asynchronous config](crate::Config::async_support).
-    ///
-    /// It's important to note that the execution of WebAssembly will happen
-    /// synchronously in the `poll` method of the future returned from this
-    /// function. Wasmtime does not manage its own thread pool or similar to
-    /// execute WebAssembly in. Future `poll` methods are generally expected to
-    /// resolve quickly, so it's recommended that you run or poll this future
-    /// in a "blocking context".
-    ///
-    /// For more information see the documentation on [asynchronous
-    /// configs](crate::Config::async_support).
-    ///
-    /// # Errors
-    ///
-    /// For more information on errors see the [`Func::call`] documentation.
-    ///
-    /// # Panics
-    ///
-    /// Panics if this is called on a function in a synchronous store. This
-    /// only works with functions defined within an asynchronous store. Also
-    /// panics if `store` does not own this function.
-    #[cfg(feature = "async")]
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "async")))]
-    pub async fn call_async<T>(
-        &self,
-        mut store: impl AsContextMut<Data = T>,
-        params: &[Val],
-        results: &mut [Val],
-    ) -> Result<()>
-    where
-        T: Send,
-    {
-        let mut store = store.as_context_mut();
-        assert!(
-            store.0.async_support(),
-            "cannot use `call_async` without enabling async support in the config",
-        );
-        let result = store
-            .on_fiber(|store| self.call_impl(store, params, results))
-            .await??;
-        Ok(result)
-    }
-
-    fn call_impl<T>(
-        &self,
-        store: &mut StoreContextMut<'_, T>,
-        params: &[Val],
-        results: &mut [Val],
-    ) -> Result<()> {
-        // We need to perform a dynamic check that the arguments given to us
-        // match the signature of this function and are appropriate to pass to
-        // this function. This involves checking to make sure we have the right
-        // number and types of arguments as well as making sure everything is
-        // from the same `Store`.
-        let (ty, opaque) = self.ty_ref(store.0);
-        if ty.params().len() != params.len() {
-            bail!(
-                "expected {} arguments, got {}",
-                ty.params().len(),
-                params.len()
-            );
-        }
-        if ty.results().len() != results.len() {
-            bail!(
-                "expected {} results, got {}",
-                ty.results().len(),
-                results.len()
-            );
-        }
-        for (ty, arg) in ty.params().zip(params) {
-            if arg.ty() != ty {
-                bail!(
-                    "argument type mismatch: found {} but expected {}",
-                    arg.ty(),
-                    ty
-                );
-            }
-            if !arg.comes_from_same_store(opaque) {
-                bail!("cross-`Store` values are not currently supported");
-            }
-        }
-
-        let values_vec_size = params.len().max(ty.results().len());
-
-        // Whenever we pass `externref`s from host code to Wasm code, they
-        // go into the `VMExternRefActivationsTable`. But the table might be
-        // at capacity already, so check for that. If it is at capacity
-        // (unlikely) then do a GC to free up space. This is necessary
-        // because otherwise we would either keep filling up the bump chunk
-        // and making it larger and larger or we would always take the slow
-        // path when inserting references into the table.
-        if ty.as_wasm_func_type().externref_params_count()
-            > store
-                .0
-                .externref_activations_table()
-                .bump_capacity_remaining()
-        {
-            store.gc();
-        }
-
-        // Store the argument values into `values_vec`.
-        let mut values_vec = store.0.take_wasm_val_raw_storage();
-        debug_assert!(values_vec.is_empty());
-        values_vec.resize_with(values_vec_size, || ValRaw::i32(0));
-        for (arg, slot) in params.iter().cloned().zip(&mut values_vec) {
-            unsafe {
-                *slot = arg.to_raw(&mut *store);
-            }
-        }
-
-        unsafe {
-            self.call_unchecked(&mut *store, values_vec.as_mut_ptr(), values_vec_size)?;
-        }
-
-        for ((i, slot), val) in results.iter_mut().enumerate().zip(&values_vec) {
-            let ty = self.ty_ref(store.0).0.results().nth(i).unwrap();
-            *slot = unsafe { Val::from_raw(&mut *store, *val, ty) };
-        }
-        values_vec.truncate(0);
-        store.0.save_wasm_val_raw_storage(values_vec);
-        Ok(())
-    }
-
-    #[inline]
-    pub(crate) fn vm_func_ref(&self, store: &mut StoreOpaque) -> NonNull<VMFuncRef> {
-        let func_data = &mut store.store_data_mut()[self.0];
-        if let Some(in_store) = func_data.in_store_func_ref {
-            in_store.as_non_null()
-        } else {
-            let func_ref = func_data.export().func_ref;
-            unsafe {
-                if func_ref.as_ref().wasm_call.is_none() {
-                    let func_ref = store.func_refs().push(func_ref.as_ref().clone());
-                    store.store_data_mut()[self.0].in_store_func_ref =
-                        Some(SendSyncPtr::new(func_ref));
-                    store.fill_func_refs();
-                    func_ref
-                } else {
-                    func_ref
-                }
-            }
-        }
-    }
-
-    pub(crate) unsafe fn from_wasmtime_function(
-        export: ExportFunction,
-        store: &mut StoreOpaque,
-    ) -> Self {
-        Func::from_func_kind(FuncKind::StoreOwned { export }, store)
-    }
-
-    fn from_func_kind(kind: FuncKind, store: &mut StoreOpaque) -> Self {
-        Func(store.store_data_mut().insert(FuncData {
-            kind,
-            in_store_func_ref: None,
-            ty: None,
-        }))
-    }
-
-    pub(crate) fn vmimport(&self, store: &mut StoreOpaque, module: &Module) -> VMFunctionImport {
-        unsafe {
-            let f = {
-                let func_data = &mut store.store_data_mut()[self.0];
-                // If we already patched this `funcref.wasm_call` and saved a
-                // copy in the store, use the patched version. Otherwise, use
-                // the potentially un-patched version.
-                if let Some(func_ref) = func_data.in_store_func_ref {
-                    func_ref.as_non_null()
-                } else {
-                    func_data.export().func_ref
-                }
-            };
-            VMFunctionImport {
-                wasm_call: if let Some(wasm_call) = f.as_ref().wasm_call {
-                    wasm_call
-                } else {
-                    // Assert that this is a native-call function, since those
-                    // are the only ones that could be missing a `wasm_call`
-                    // trampoline.
-                    let _ = VMNativeCallHostFuncContext::from_opaque(f.as_ref().vmctx);
-
-                    let sig = self.sig_index(store.store_data());
-                    module.runtime_info().wasm_to_native_trampoline(sig).expect(
-                        "must have a wasm-to-native trampoline for this signature if the Wasm \
-                         module is importing a function of this signature",
-                    )
-                },
-                native_call: f.as_ref().native_call,
-                array_call: f.as_ref().array_call,
-                vmctx: f.as_ref().vmctx,
-            }
-        }
-    }
-
-    pub(crate) fn comes_from_same_store(&self, store: &StoreOpaque) -> bool {
-        store.store_data().contains(self.0)
-    }
-
-    fn invoke<T>(
-        mut caller: Caller<'_, T>,
-        ty: &FuncType,
-        values_vec: &mut [ValRaw],
-        func: &dyn Fn(Caller<'_, T>, &[Val], &mut [Val]) -> Result<()>,
-    ) -> Result<()> {
-        // Translate the raw JIT arguments in `values_vec` into a `Val` which
-        // we'll be passing as a slice. The storage for our slice-of-`Val` we'll
-        // be taking from the `Store`. We preserve our slice back into the
-        // `Store` after the hostcall, ideally amortizing the cost of allocating
-        // the storage across wasm->host calls.
-        //
-        // Note that we have a dynamic guarantee that `values_vec` is the
-        // appropriate length to both read all arguments from as well as store
-        // all results into.
-        let mut val_vec = caller.store.0.take_hostcall_val_storage();
-        debug_assert!(val_vec.is_empty());
-        let nparams = ty.params().len();
-        val_vec.reserve(nparams + ty.results().len());
-        for (i, ty) in ty.params().enumerate() {
-            val_vec.push(unsafe { Val::from_raw(&mut caller.store, values_vec[i], ty) })
-        }
-
-        val_vec.extend((0..ty.results().len()).map(|_| Val::null()));
-        let (params, results) = val_vec.split_at_mut(nparams);
-        func(caller.sub_caller(), params, results)?;
-
-        // See the comment in `Func::call_impl`'s `write_params` function.
-        if ty.as_wasm_func_type().externref_returns_count()
-            > caller
-                .store
-                .0
-                .externref_activations_table()
-                .bump_capacity_remaining()
-        {
-            caller.store.gc();
-        }
-
-        // Unlike our arguments we need to dynamically check that the return
-        // values produced are correct. There could be a bug in `func` that
-        // produces the wrong number, wrong types, or wrong stores of
-        // values, and we need to catch that here.
-        for (i, (ret, ty)) in results.iter().zip(ty.results()).enumerate() {
-            if ret.ty() != ty {
-                bail!("function attempted to return an incompatible value");
-            }
-            if !ret.comes_from_same_store(caller.store.0) {
-                bail!("cross-`Store` values are not currently supported");
-            }
-            unsafe {
-                values_vec[i] = ret.to_raw(&mut caller.store);
-            }
-        }
-
-        // Restore our `val_vec` back into the store so it's usable for the next
-        // hostcall to reuse our own storage.
-        val_vec.truncate(0);
-        caller.store.0.save_hostcall_val_storage(val_vec);
-        Ok(())
-    }
-
-    /// Attempts to extract a typed object from this `Func` through which the
-    /// function can be called.
-    ///
-    /// This function serves as an alternative to [`Func::call`] and
-    /// [`Func::call_async`]. This method performs a static type check (using
-    /// the `Params` and `Results` type parameters on the underlying wasm
-    /// function. If the type check passes then a `TypedFunc` object is returned,
-    /// otherwise an error is returned describing the typecheck failure.
-    ///
-    /// The purpose of this relative to [`Func::call`] is that it's much more
-    /// efficient when used to invoke WebAssembly functions. With the types
-    /// statically known far less setup/teardown is required when invoking
-    /// WebAssembly. If speed is desired then this function is recommended to be
-    /// used instead of [`Func::call`] (which is more general, hence its
-    /// slowdown).
-    ///
-    /// The `Params` type parameter is used to describe the parameters of the
-    /// WebAssembly function. This can either be a single type (like `i32`), or
-    /// a tuple of types representing the list of parameters (like `(i32, f32,
-    /// f64)`). Additionally you can use `()` to represent that the function has
-    /// no parameters.
-    ///
-    /// The `Results` type parameter is used to describe the results of the
-    /// function. This behaves the same way as `Params`, but just for the
-    /// results of the function.
-    ///
-    /// Translation between Rust types and WebAssembly types looks like:
-    ///
-    /// | WebAssembly | Rust                |
-    /// |-------------|---------------------|
-    /// | `i32`       | `i32` or `u32`      |
-    /// | `i64`       | `i64` or `u64`      |
-    /// | `f32`       | `f32`               |
-    /// | `f64`       | `f64`               |
-    /// | `externref` | `Option<ExternRef>` |
-    /// | `funcref`   | `Option<Func>`      |
-    /// | `v128`      | not supported       |
-    ///
-    /// (note that this mapping is the same as that of [`Func::wrap`]).
-    ///
-    /// Note that once the [`TypedFunc`] return value is acquired you'll use either
-    /// [`TypedFunc::call`] or [`TypedFunc::call_async`] as necessary to actually invoke
-    /// the function. This method does not invoke any WebAssembly code, it
-    /// simply performs a typecheck before returning the [`TypedFunc`] value.
-    ///
-    /// This method also has a convenience wrapper as
-    /// [`Instance::get_typed_func`](crate::Instance::get_typed_func) to
-    /// directly get a typed function value from an
-    /// [`Instance`](crate::Instance).
-    ///
-    /// # Errors
-    ///
-    /// This function will return an error if `Params` or `Results` does not
-    /// match the native type of this WebAssembly function.
-    ///
-    /// # Panics
-    ///
-    /// This method will panic if `store` does not own this function.
-    ///
-    /// # Examples
-    ///
-    /// An end-to-end example of calling a function which takes no parameters
-    /// and has no results:
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// let engine = Engine::default();
-    /// let mut store = Store::new(&engine, ());
-    /// let module = Module::new(&engine, r#"(module (func (export "foo")))"#)?;
-    /// let instance = Instance::new(&mut store, &module, &[])?;
-    /// let foo = instance.get_func(&mut store, "foo").expect("export wasn't a function");
-    ///
-    /// // Note that this call can fail due to the typecheck not passing, but
-    /// // in our case we statically know the module so we know this should
-    /// // pass.
-    /// let typed = foo.typed::<(), ()>(&store)?;
-    ///
-    /// // Note that this can fail if the wasm traps at runtime.
-    /// typed.call(&mut store, ())?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    ///
-    /// You can also pass in multiple parameters and get a result back
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn foo(add: &Func, mut store: Store<()>) -> anyhow::Result<()> {
-    /// let typed = add.typed::<(i32, i64), f32>(&store)?;
-    /// assert_eq!(typed.call(&mut store, (1, 2))?, 3.0);
-    /// # Ok(())
-    /// # }
-    /// ```
-    ///
-    /// and similarly if a function has multiple results you can bind that too
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn foo(add_with_overflow: &Func, mut store: Store<()>) -> anyhow::Result<()> {
-    /// let typed = add_with_overflow.typed::<(u32, u32), (u32, i32)>(&store)?;
-    /// let (result, overflow) = typed.call(&mut store, (u32::max_value(), 2))?;
-    /// assert_eq!(result, 1);
-    /// assert_eq!(overflow, 1);
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn typed<Params, Results>(
-        &self,
-        store: impl AsContext,
-    ) -> Result<TypedFunc<Params, Results>>
-    where
-        Params: WasmParams,
-        Results: WasmResults,
-    {
-        // Type-check that the params/results are all valid
-        let ty = self.ty(store);
-        Params::typecheck(ty.params()).context("type mismatch with parameters")?;
-        Results::typecheck(ty.results()).context("type mismatch with results")?;
-
-        // and then we can construct the typed version of this function
-        // (unsafely), which should be safe since we just did the type check above.
-        unsafe { Ok(TypedFunc::new_unchecked(*self)) }
-    }
-
-    /// Get a stable hash key for this function.
-    ///
-    /// Even if the same underlying function is added to the `StoreData`
-    /// multiple times and becomes multiple `wasmtime::Func`s, this hash key
-    /// will be consistent across all of these functions.
-    #[allow(dead_code)] // Not used yet, but added for consistency.
-    pub(crate) fn hash_key(&self, store: &mut StoreOpaque) -> impl std::hash::Hash + Eq {
-        self.vm_func_ref(store).as_ptr() as usize
-    }
-}
-
-/// Prepares for entrance into WebAssembly.
-///
-/// This function will set up context such that `closure` is allowed to call a
-/// raw trampoline or a raw WebAssembly function. This *must* be called to do
-/// things like catch traps and set up GC properly.
-///
-/// The `closure` provided receives a default "caller" `VMContext` parameter it
-/// can pass to the called wasm function, if desired.
-pub(crate) fn invoke_wasm_and_catch_traps<T>(
-    store: &mut StoreContextMut<'_, T>,
-    closure: impl FnMut(*mut VMContext),
-) -> Result<()> {
-    unsafe {
-        let exit = enter_wasm(store);
-
-        if let Err(trap) = store.0.call_hook(CallHook::CallingWasm) {
-            exit_wasm(store, exit);
-            return Err(trap);
-        }
-        let result = wasmtime_runtime::catch_traps(
-            store.0.signal_handler(),
-            store.0.engine().config().wasm_backtrace,
-            store.0.engine().config().coredump_on_trap,
-            store.0.default_caller(),
-            closure,
-        );
-        exit_wasm(store, exit);
-        store.0.call_hook(CallHook::ReturningFromWasm)?;
-        result.map_err(|t| crate::trap::from_runtime_box(store.0, t))
-    }
-}
-
-/// This function is called to register state within `Store` whenever
-/// WebAssembly is entered within the `Store`.
-///
-/// This function sets up various limits such as:
-///
-/// * The stack limit. This is what ensures that we limit the stack space
-///   allocated by WebAssembly code and it's relative to the initial stack
-///   pointer that called into wasm.
-///
-/// This function may fail if the the stack limit can't be set because an
-/// interrupt already happened.
-fn enter_wasm<T>(store: &mut StoreContextMut<'_, T>) -> Option<usize> {
-    // If this is a recursive call, e.g. our stack limit is already set, then
-    // we may be able to skip this function.
-    //
-    // For synchronous stores there's nothing else to do because all wasm calls
-    // happen synchronously and on the same stack. This means that the previous
-    // stack limit will suffice for the next recursive call.
-    //
-    // For asynchronous stores then each call happens on a separate native
-    // stack. This means that the previous stack limit is no longer relevant
-    // because we're on a separate stack.
-    if unsafe { *store.0.runtime_limits().stack_limit.get() } != usize::MAX
-        && !store.0.async_support()
-    {
-        return None;
-    }
-
-    // Ignore this stack pointer business on miri since we can't execute wasm
-    // anyway and the concept of a stack pointer on miri is a bit nebulous
-    // regardless.
-    if cfg!(miri) {
-        return None;
-    }
-
-    let stack_pointer = stack_pointer();
-
-    // Determine the stack pointer where, after which, any wasm code will
-    // immediately trap. This is checked on the entry to all wasm functions.
-    //
-    // Note that this isn't 100% precise. We are requested to give wasm
-    // `max_wasm_stack` bytes, but what we're actually doing is giving wasm
-    // probably a little less than `max_wasm_stack` because we're
-    // calculating the limit relative to this function's approximate stack
-    // pointer. Wasm will be executed on a frame beneath this one (or next
-    // to it). In any case it's expected to be at most a few hundred bytes
-    // of slop one way or another. When wasm is typically given a MB or so
-    // (a million bytes) the slop shouldn't matter too much.
-    //
-    // After we've got the stack limit then we store it into the `stack_limit`
-    // variable.
-    let wasm_stack_limit = stack_pointer - store.engine().config().max_wasm_stack;
-    let prev_stack = unsafe {
-        mem::replace(
-            &mut *store.0.runtime_limits().stack_limit.get(),
-            wasm_stack_limit,
-        )
-    };
-
-    Some(prev_stack)
-}
-
-#[inline]
-fn stack_pointer() -> usize {
-    let stack_pointer: usize;
-    cfg_if::cfg_if! {
-        if #[cfg(target_arch = "x86_64")] {
-            unsafe {
-                std::arch::asm!(
-                    "mov {}, rsp",
-                    out(reg) stack_pointer,
-                    options(nostack,nomem),
-                );
-            }
-        } else if #[cfg(target_arch = "aarch64")] {
-            unsafe {
-                std::arch::asm!(
-                    "mov {}, sp",
-                    out(reg) stack_pointer,
-                    options(nostack,nomem),
-                );
-            }
-        } else if #[cfg(target_arch = "riscv64")] {
-            unsafe {
-                std::arch::asm!(
-                    "mv {}, sp",
-                    out(reg) stack_pointer,
-                    options(nostack,nomem),
-                );
-            }
-        } else if #[cfg(target_arch = "s390x")] {
-            stack_pointer = psm::stack_pointer() as usize;
-        } else {
-            compile_error!("unsupported platform");
-        }
-    }
-    stack_pointer
-}
-
-fn exit_wasm<T>(store: &mut StoreContextMut<'_, T>, prev_stack: Option<usize>) {
-    // If we don't have a previous stack pointer to restore, then there's no
-    // cleanup we need to perform here.
-    let prev_stack = match prev_stack {
-        Some(stack) => stack,
-        None => return,
-    };
-
-    unsafe {
-        *store.0.runtime_limits().stack_limit.get() = prev_stack;
-    }
-}
-
-/// A trait implemented for types which can be returned from closures passed to
-/// [`Func::wrap`] and friends.
-///
-/// This trait should not be implemented by user types. This trait may change at
-/// any time internally. The types which implement this trait, however, are
-/// stable over time.
-///
-/// For more information see [`Func::wrap`]
-pub unsafe trait WasmRet {
-    // Same as `WasmTy::Abi`.
-    #[doc(hidden)]
-    type Abi: Copy;
-    #[doc(hidden)]
-    type Retptr: Copy;
-
-    // Same as `WasmTy::compatible_with_store`.
-    #[doc(hidden)]
-    fn compatible_with_store(&self, store: &StoreOpaque) -> bool;
-
-    // Similar to `WasmTy::into_abi_for_arg` but used when host code is
-    // returning a value into Wasm, rather than host code passing an argument to
-    // a Wasm call. Unlike `into_abi_for_arg`, implementors of this method can
-    // raise traps, which means that callers must ensure that
-    // `invoke_wasm_and_catch_traps` is on the stack, and therefore this method
-    // is unsafe.
-    #[doc(hidden)]
-    unsafe fn into_abi_for_ret(
-        self,
-        store: &mut StoreOpaque,
-        ptr: Self::Retptr,
-    ) -> Result<Self::Abi>;
-
-    #[doc(hidden)]
-    fn func_type(params: impl Iterator<Item = ValType>) -> FuncType;
-
-    #[doc(hidden)]
-    unsafe fn wrap_trampoline(ptr: *mut ValRaw, f: impl FnOnce(Self::Retptr) -> Self::Abi);
-
-    // Utilities used to convert an instance of this type to a `Result`
-    // explicitly, used when wrapping async functions which always bottom-out
-    // in a function that returns a trap because futures can be cancelled.
-    #[doc(hidden)]
-    type Fallible: WasmRet<Abi = Self::Abi, Retptr = Self::Retptr>;
-    #[doc(hidden)]
-    fn into_fallible(self) -> Self::Fallible;
-    #[doc(hidden)]
-    fn fallible_from_error(error: Error) -> Self::Fallible;
-}
-
-unsafe impl<T> WasmRet for T
-where
-    T: WasmTy,
-{
-    type Abi = <T as WasmTy>::Abi;
-    type Retptr = ();
-    type Fallible = Result<T>;
-
-    fn compatible_with_store(&self, store: &StoreOpaque) -> bool {
-        <Self as WasmTy>::compatible_with_store(self, store)
-    }
-
-    unsafe fn into_abi_for_ret(self, store: &mut StoreOpaque, _retptr: ()) -> Result<Self::Abi> {
-        Ok(<Self as WasmTy>::into_abi(self, store))
-    }
-
-    fn func_type(params: impl Iterator<Item = ValType>) -> FuncType {
-        FuncType::new(params, Some(<Self as WasmTy>::valtype()))
-    }
-
-    unsafe fn wrap_trampoline(ptr: *mut ValRaw, f: impl FnOnce(Self::Retptr) -> Self::Abi) {
-        T::abi_into_raw(f(()), ptr);
-    }
-
-    fn into_fallible(self) -> Result<T> {
-        Ok(self)
-    }
-
-    fn fallible_from_error(error: Error) -> Result<T> {
-        Err(error)
-    }
-}
-
-unsafe impl<T> WasmRet for Result<T>
-where
-    T: WasmRet,
-{
-    type Abi = <T as WasmRet>::Abi;
-    type Retptr = <T as WasmRet>::Retptr;
-    type Fallible = Self;
-
-    fn compatible_with_store(&self, store: &StoreOpaque) -> bool {
-        match self {
-            Ok(x) => <T as WasmRet>::compatible_with_store(x, store),
-            Err(_) => true,
-        }
-    }
-
-    unsafe fn into_abi_for_ret(
-        self,
-        store: &mut StoreOpaque,
-        retptr: Self::Retptr,
-    ) -> Result<Self::Abi> {
-        self.and_then(|val| val.into_abi_for_ret(store, retptr))
-    }
-
-    fn func_type(params: impl Iterator<Item = ValType>) -> FuncType {
-        T::func_type(params)
-    }
-
-    unsafe fn wrap_trampoline(ptr: *mut ValRaw, f: impl FnOnce(Self::Retptr) -> Self::Abi) {
-        T::wrap_trampoline(ptr, f)
-    }
-
-    fn into_fallible(self) -> Result<T> {
-        self
-    }
-
-    fn fallible_from_error(error: Error) -> Result<T> {
-        Err(error)
-    }
-}
-
-macro_rules! impl_wasm_host_results {
-    ($n:tt $($t:ident)*) => (
-        #[allow(non_snake_case)]
-        unsafe impl<$($t),*> WasmRet for ($($t,)*)
-        where
-            $($t: WasmTy,)*
-            ($($t::Abi,)*): HostAbi,
-        {
-            type Abi = <($($t::Abi,)*) as HostAbi>::Abi;
-            type Retptr = <($($t::Abi,)*) as HostAbi>::Retptr;
-            type Fallible = Result<Self>;
-
-            #[inline]
-            fn compatible_with_store(&self, _store: &StoreOpaque) -> bool {
-                let ($($t,)*) = self;
-                $( $t.compatible_with_store(_store) && )* true
-            }
-
-            #[inline]
-            unsafe fn into_abi_for_ret(self, _store: &mut StoreOpaque, ptr: Self::Retptr) -> Result<Self::Abi> {
-                let ($($t,)*) = self;
-                let abi = ($($t.into_abi(_store),)*);
-                Ok(<($($t::Abi,)*) as HostAbi>::into_abi(abi, ptr))
-            }
-
-            fn func_type(params: impl Iterator<Item = ValType>) -> FuncType {
-                FuncType::new(
-                    params,
-                    IntoIterator::into_iter([$($t::valtype(),)*]),
-                )
-            }
-
-            #[allow(unused_assignments)]
-            unsafe fn wrap_trampoline(mut _ptr: *mut ValRaw, f: impl FnOnce(Self::Retptr) -> Self::Abi) {
-                let ($($t,)*) = <($($t::Abi,)*) as HostAbi>::call(f);
-                $(
-                    $t::abi_into_raw($t, _ptr);
-                    _ptr = _ptr.add(1);
-                )*
-            }
-
-            #[inline]
-            fn into_fallible(self) -> Result<Self> {
-                Ok(self)
-            }
-
-            #[inline]
-            fn fallible_from_error(error: Error) -> Result<Self> {
-                Err(error)
-            }
-        }
-    )
-}
-
-for_each_function_signature!(impl_wasm_host_results);
-
-// Internal trait representing how to communicate tuples of return values across
-// an ABI boundary. This internally corresponds to the "wasmtime" ABI inside of
-// cranelift itself. Notably the first element of each tuple is returned via the
-// typical system ABI (e.g. systemv or fastcall depending on platform) and all
-// other values are returned packed via the stack.
-//
-// This trait helps to encapsulate all the details of that.
-#[doc(hidden)]
-pub trait HostAbi {
-    // A value returned from native functions which return `Self`
-    type Abi: Copy;
-    // A return pointer, added to the end of the argument list, for native
-    // functions that return `Self`. Note that a 0-sized type here should get
-    // elided at the ABI level.
-    type Retptr: Copy;
-
-    // Converts a value of `self` into its components. Stores necessary values
-    // into `ptr` and then returns whatever needs to be returned from the
-    // function.
-    unsafe fn into_abi(self, ptr: Self::Retptr) -> Self::Abi;
-
-    // Calls `f` with a suitably sized return area and requires `f` to return
-    // the raw abi value of the first element of our tuple. This will then
-    // unpack the `Retptr` and assemble it with `Self::Abi` to return an
-    // instance of the whole tuple.
-    unsafe fn call(f: impl FnOnce(Self::Retptr) -> Self::Abi) -> Self;
-}
-
-macro_rules! impl_host_abi {
-    // Base case, everything is `()`
-    (0) => {
-        impl HostAbi for () {
-            type Abi = ();
-            type Retptr = ();
-
-            #[inline]
-            unsafe fn into_abi(self, _ptr: Self::Retptr) -> Self::Abi {}
-
-            #[inline]
-            unsafe fn call(f: impl FnOnce(Self::Retptr) -> Self::Abi) -> Self {
-                f(())
-            }
-        }
-    };
-
-    // In the 1-case the retptr is not present, so it's a 0-sized value.
-    (1 $a:ident) => {
-        impl<$a: Copy> HostAbi for ($a,) {
-            type Abi = $a;
-            type Retptr = ();
-
-            unsafe fn into_abi(self, _ptr: Self::Retptr) -> Self::Abi {
-                self.0
-            }
-
-            unsafe fn call(f: impl FnOnce(Self::Retptr) -> Self::Abi) -> Self {
-                (f(()),)
-            }
-        }
-    };
-
-    // This is where the more interesting case happens. The first element of the
-    // tuple is returned via `Abi` and all other elements are returned via
-    // `Retptr`. We create a `TupleRetNN` structure to represent all of the
-    // return values here.
-    //
-    // Also note that this isn't implemented for the old backend right now due
-    // to the original author not really being sure how to implement this in the
-    // old backend.
-    ($n:tt $t:ident $($u:ident)*) => {paste::paste!{
-        #[doc(hidden)]
-        #[allow(non_snake_case)]
-        #[repr(C)]
-        pub struct [<TupleRet $n>]<$($u,)*> {
-            $($u: $u,)*
-        }
-
-        #[allow(non_snake_case, unused_assignments)]
-        impl<$t: Copy, $($u: Copy,)*> HostAbi for ($t, $($u,)*) {
-            type Abi = $t;
-            type Retptr = *mut [<TupleRet $n>]<$($u,)*>;
-
-            unsafe fn into_abi(self, ptr: Self::Retptr) -> Self::Abi {
-                let ($t, $($u,)*) = self;
-                // Store the tail of our tuple into the return pointer...
-                $((*ptr).$u = $u;)*
-                // ... and return the head raw.
-                $t
-            }
-
-            unsafe fn call(f: impl FnOnce(Self::Retptr) -> Self::Abi) -> Self {
-                // Create space to store all the return values and then invoke
-                // the function.
-                let mut space = std::mem::MaybeUninit::uninit();
-                let t = f(space.as_mut_ptr());
-                let space = space.assume_init();
-
-                // Use the return value as the head of the tuple and unpack our
-                // return area to get the rest of the tuple.
-                (t, $(space.$u,)*)
-            }
-        }
-    }};
-}
-
-for_each_function_signature!(impl_host_abi);
-
-/// Internal trait implemented for all arguments that can be passed to
-/// [`Func::wrap`] and [`Linker::func_wrap`](crate::Linker::func_wrap).
-///
-/// This trait should not be implemented by external users, it's only intended
-/// as an implementation detail of this crate.
-pub trait IntoFunc<T, Params, Results>: Send + Sync + 'static {
-    /// Convert this function into a `VM{Array,Native}CallHostFuncContext` and
-    /// internal `VMFuncRef`.
-    #[doc(hidden)]
-    fn into_func(self, engine: &Engine) -> HostContext;
-}
-
-/// A structure representing the caller's context when creating a function
-/// via [`Func::wrap`].
-///
-/// This structure can be taken as the first parameter of a closure passed to
-/// [`Func::wrap`] or other constructors, and serves two purposes:
-///
-/// * First consumers can use [`Caller<'_, T>`](crate::Caller) to get access to
-///   [`StoreContextMut<'_, T>`](crate::StoreContextMut) and/or get access to
-///   `T` itself. This means that the [`Caller`] type can serve as a proxy to
-///   the original [`Store`](crate::Store) itself and is used to satisfy
-///   [`AsContext`] and [`AsContextMut`] bounds.
-///
-/// * Second a [`Caller`] can be used as the name implies, learning about the
-///   caller's context, namely it's exported memory and exported functions. This
-///   allows functions which take pointers as arguments to easily read the
-///   memory the pointers point into, or if a function is expected to call
-///   malloc in the wasm module to reserve space for the output you can do that.
-///
-/// Host functions which want access to [`Store`](crate::Store)-level state are
-/// recommended to use this type.
-pub struct Caller<'a, T> {
-    pub(crate) store: StoreContextMut<'a, T>,
-    caller: &'a wasmtime_runtime::Instance,
-}
-
-impl<T> Caller<'_, T> {
-    unsafe fn with<R>(caller: *mut VMContext, f: impl FnOnce(Caller<'_, T>) -> R) -> R {
-        assert!(!caller.is_null());
-        wasmtime_runtime::Instance::from_vmctx(caller, |instance| {
-            let store = StoreContextMut::from_raw(instance.store());
-            f(Caller {
-                store,
-                caller: &instance,
-            })
-        })
-    }
-
-    fn sub_caller(&mut self) -> Caller<'_, T> {
-        Caller {
-            store: self.store.as_context_mut(),
-            caller: self.caller,
-        }
-    }
-
-    /// Looks up an export from the caller's module by the `name` given.
-    ///
-    /// This is a low-level function that's typically used to implement passing
-    /// of pointers or indices between core Wasm instances, where the callee
-    /// needs to consult the caller's exports to perform memory management and
-    /// resolve the references.
-    ///
-    /// For comparison, in components, the component model handles translating
-    /// arguments from one component instance to another and managing memory, so
-    /// that callees don't need to be aware of their callers, which promotes
-    /// virtualizability of APIs.
-    ///
-    /// # Return
-    ///
-    /// If an export with the `name` provided was found, then it is returned as an
-    /// `Extern`. There are a number of situations, however, where the export may not
-    /// be available:
-    ///
-    /// * The caller instance may not have an export named `name`
-    /// * There may not be a caller available, for example if `Func` was called
-    ///   directly from host code.
-    ///
-    /// It's recommended to take care when calling this API and gracefully
-    /// handling a `None` return value.
-    pub fn get_export(&mut self, name: &str) -> Option<Extern> {
-        // All instances created have a `host_state` with a pointer pointing
-        // back to themselves. If this caller doesn't have that `host_state`
-        // then it probably means it was a host-created object like `Func::new`
-        // which doesn't have any exports we want to return anyway.
-        self.caller
-            .host_state()
-            .downcast_ref::<Instance>()?
-            .get_export(&mut self.store, name)
-    }
-
-    /// Access the underlying data owned by this `Store`.
-    ///
-    /// Same as [`Store::data`](crate::Store::data)
-    pub fn data(&self) -> &T {
-        self.store.data()
-    }
-
-    /// Access the underlying data owned by this `Store`.
-    ///
-    /// Same as [`Store::data_mut`](crate::Store::data_mut)
-    pub fn data_mut(&mut self) -> &mut T {
-        self.store.data_mut()
-    }
-
-    /// Returns the underlying [`Engine`] this store is connected to.
-    pub fn engine(&self) -> &Engine {
-        self.store.engine()
-    }
-
-    /// Perform garbage collection of `ExternRef`s.
-    ///
-    /// Same as [`Store::gc`](crate::Store::gc).
-    pub fn gc(&mut self) {
-        self.store.gc()
-    }
-
-    /// Returns the fuel consumed by this store.
-    ///
-    /// For more information see [`Store::fuel_consumed`](crate::Store::fuel_consumed)
-    pub fn fuel_consumed(&self) -> Option<u64> {
-        self.store.fuel_consumed()
-    }
-
-    /// Inject more fuel into this store to be consumed when executing wasm code.
-    ///
-    /// For more information see [`Store::add_fuel`](crate::Store::add_fuel)
-    pub fn add_fuel(&mut self, fuel: u64) -> Result<()> {
-        self.store.add_fuel(fuel)
-    }
-
-    /// Synthetically consumes fuel from the store.
-    ///
-    /// For more information see [`Store::consume_fuel`](crate::Store::consume_fuel)
-    pub fn consume_fuel(&mut self, fuel: u64) -> Result<u64> {
-        self.store.consume_fuel(fuel)
-    }
-
-    /// Configures this `Store` to trap whenever fuel runs out.
-    ///
-    /// For more information see
-    /// [`Store::out_of_fuel_trap`](crate::Store::out_of_fuel_trap)
-    pub fn out_of_fuel_trap(&mut self) {
-        self.store.out_of_fuel_trap()
-    }
-
-    /// Configures this `Store` to yield while executing futures whenever fuel
-    /// runs out.
-    ///
-    /// For more information see
-    /// [`Store::out_of_fuel_async_yield`](crate::Store::out_of_fuel_async_yield)
-    pub fn out_of_fuel_async_yield(&mut self, injection_count: u64, fuel_to_inject: u64) {
-        self.store
-            .out_of_fuel_async_yield(injection_count, fuel_to_inject)
-    }
-}
-
-impl<T> AsContext for Caller<'_, T> {
-    type Data = T;
-    fn as_context(&self) -> StoreContext<'_, T> {
-        self.store.as_context()
-    }
-}
-
-impl<T> AsContextMut for Caller<'_, T> {
-    fn as_context_mut(&mut self) -> StoreContextMut<'_, T> {
-        self.store.as_context_mut()
-    }
-}
-
-macro_rules! impl_into_func {
-    ($num:tt $($args:ident)*) => {
-        // Implement for functions without a leading `&Caller` parameter,
-        // delegating to the implementation below which does have the leading
-        // `Caller` parameter.
-        #[allow(non_snake_case)]
-        impl<T, F, $($args,)* R> IntoFunc<T, ($($args,)*), R> for F
-        where
-            F: Fn($($args),*) -> R + Send + Sync + 'static,
-            $($args: WasmTy,)*
-            R: WasmRet,
-        {
-            fn into_func(self, engine: &Engine) -> HostContext {
-                let f = move |_: Caller<'_, T>, $($args:$args),*| {
-                    self($($args),*)
-                };
-
-                f.into_func(engine)
-            }
-        }
-
-        #[allow(non_snake_case)]
-        impl<T, F, $($args,)* R> IntoFunc<T, (Caller<'_, T>, $($args,)*), R> for F
-        where
-            F: Fn(Caller<'_, T>, $($args),*) -> R + Send + Sync + 'static,
-            $($args: WasmTy,)*
-            R: WasmRet,
-        {
-            fn into_func(self, engine: &Engine) -> HostContext {
-                /// This shim is a regular, non-closure function we can stuff
-                /// inside `VMFuncRef::native_call`.
-                ///
-                /// It reads the actual callee closure out of
-                /// `VMNativeCallHostFuncContext::host_state`, forwards
-                /// arguments to that function, and finally forwards the results
-                /// back out to the caller. It also handles traps and panics
-                /// along the way.
-                unsafe extern "C" fn native_call_shim<T, F, $($args,)* R>(
-                    vmctx: *mut VMOpaqueContext,
-                    caller_vmctx: *mut VMOpaqueContext,
-                    $( $args: $args::Abi, )*
-                    retptr: R::Retptr,
-                ) -> R::Abi
-                where
-                    F: Fn(Caller<'_, T>, $( $args ),*) -> R + 'static,
-                    $( $args: WasmTy, )*
-                    R: WasmRet,
-                {
-                    enum CallResult<U> {
-                        Ok(U),
-                        Trap(anyhow::Error),
-                        Panic(Box<dyn std::any::Any + Send>),
-                    }
-
-                    // Note that this `result` is intentionally scoped into a
-                    // separate block. Handling traps and panics will involve
-                    // longjmp-ing from this function which means we won't run
-                    // destructors. As a result anything requiring a destructor
-                    // should be part of this block, and the long-jmp-ing
-                    // happens after the block in handling `CallResult`.
-                    let caller_vmctx = VMContext::from_opaque(caller_vmctx);
-                    let result = Caller::with(caller_vmctx, |mut caller| {
-                        let vmctx = VMNativeCallHostFuncContext::from_opaque(vmctx);
-                        let state = (*vmctx).host_state();
-
-                        // Double-check ourselves in debug mode, but we control
-                        // the `Any` here so an unsafe downcast should also
-                        // work.
-                        debug_assert!(state.is::<F>());
-                        let func = &*(state as *const _ as *const F);
-
-                        let ret = {
-                            panic::catch_unwind(AssertUnwindSafe(|| {
-                                if let Err(trap) = caller.store.0.call_hook(CallHook::CallingHost) {
-                                    return R::fallible_from_error(trap);
-                                }
-                                $(let $args = $args::from_abi($args, caller.store.0);)*
-                                let r = func(
-                                    caller.sub_caller(),
-                                    $( $args, )*
-                                );
-                                if let Err(trap) = caller.store.0.call_hook(CallHook::ReturningFromHost) {
-                                    return R::fallible_from_error(trap);
-                                }
-                                r.into_fallible()
-                            }))
-                        };
-
-                        // Note that we need to be careful when dealing with traps
-                        // here. Traps are implemented with longjmp/setjmp meaning
-                        // that it's not unwinding and consequently no Rust
-                        // destructors are run. We need to be careful to ensure that
-                        // nothing on the stack needs a destructor when we exit
-                        // abnormally from this `match`, e.g. on `Err`, on
-                        // cross-store-issues, or if `Ok(Err)` is raised.
-                        match ret {
-                            Err(panic) => CallResult::Panic(panic),
-                            Ok(ret) => {
-                                // Because the wrapped function is not `unsafe`, we
-                                // can't assume it returned a value that is
-                                // compatible with this store.
-                                if !ret.compatible_with_store(caller.store.0) {
-                                    CallResult::Trap(anyhow::anyhow!("host function attempted to return cross-`Store` value to Wasm"))
-                                } else {
-                                    match ret.into_abi_for_ret(caller.store.0, retptr) {
-                                        Ok(val) => CallResult::Ok(val),
-                                        Err(trap) => CallResult::Trap(trap.into()),
-                                    }
-                                }
-
-                            }
-                        }
-                    });
-
-                    match result {
-                        CallResult::Ok(val) => val,
-                        CallResult::Trap(err) => crate::trap::raise(err),
-                        CallResult::Panic(panic) => wasmtime_runtime::resume_panic(panic),
-                    }
-                }
-
-                /// This trampoline allows host code to indirectly call the
-                /// wrapped function (e.g. via `Func::call` on a `funcref` that
-                /// happens to reference our wrapped function).
-                ///
-                /// It reads the arguments out of the incoming `args` array,
-                /// calls the given function pointer, and then stores the result
-                /// back into the `args` array.
-                unsafe extern "C" fn array_call_trampoline<T, F, $($args,)* R>(
-                    callee_vmctx: *mut VMOpaqueContext,
-                    caller_vmctx: *mut VMOpaqueContext,
-                    args: *mut ValRaw,
-                    _args_len: usize
-                )
-                where
-                    F: Fn(Caller<'_, T>, $( $args ),*) -> R + 'static,
-                    $($args: WasmTy,)*
-                    R: WasmRet,
-                {
-                    let mut _n = 0;
-                    $(
-                        debug_assert!(_n < _args_len);
-                        let $args = $args::abi_from_raw(args.add(_n));
-                        _n += 1;
-                    )*
-
-                    R::wrap_trampoline(args, |retptr| {
-                        native_call_shim::<T, F, $( $args, )* R>(callee_vmctx, caller_vmctx, $( $args, )* retptr)
-                    });
-                }
-
-                let ty = R::func_type(
-                    None::<ValType>.into_iter()
-                        $(.chain(Some($args::valtype())))*
-                );
-
-                let shared_signature_id = engine.signatures().register(ty.as_wasm_func_type());
-
-                let array_call = array_call_trampoline::<T, F, $($args,)* R>;
-                let native_call = NonNull::new(native_call_shim::<T, F, $($args,)* R> as *mut _).unwrap();
-
-                let ctx = unsafe {
-                    VMNativeCallHostFuncContext::new(
-                        VMFuncRef {
-                            native_call,
-                            array_call,
-                            wasm_call: None,
-                            type_index: shared_signature_id,
-                            vmctx: ptr::null_mut(),
-                        },
-                        Box::new(self),
-                    )
-                };
-
-                ctx.into()
-            }
-        }
-    }
-}
-
-for_each_function_signature!(impl_into_func);
-
-#[doc(hidden)]
-pub enum HostContext {
-    Native(StoreBox<VMNativeCallHostFuncContext>),
-    Array(StoreBox<VMArrayCallHostFuncContext>),
-}
-
-impl From<StoreBox<VMNativeCallHostFuncContext>> for HostContext {
-    fn from(ctx: StoreBox<VMNativeCallHostFuncContext>) -> Self {
-        HostContext::Native(ctx)
-    }
-}
-
-impl From<StoreBox<VMArrayCallHostFuncContext>> for HostContext {
-    fn from(ctx: StoreBox<VMArrayCallHostFuncContext>) -> Self {
-        HostContext::Array(ctx)
-    }
-}
-
-/// Representation of a host-defined function.
-///
-/// This is used for `Func::new` but also for `Linker`-defined functions. For
-/// `Func::new` this is stored within a `Store`, and for `Linker`-defined
-/// functions they wrap this up in `Arc` to enable shared ownership of this
-/// across many stores.
-///
-/// Technically this structure needs a `<T>` type parameter to connect to the
-/// `Store<T>` itself, but that's an unsafe contract of using this for now
-/// rather than part of the struct type (to avoid `Func<T>` in the API).
-pub(crate) struct HostFunc {
-    ctx: HostContext,
-
-    // Stored to unregister this function's signature with the engine when this
-    // is dropped.
-    engine: Engine,
-}
-
-impl HostFunc {
-    /// Analog of [`Func::new`]
-    #[cfg(any(feature = "cranelift", feature = "winch"))]
-    pub fn new<T>(
-        engine: &Engine,
-        ty: FuncType,
-        func: impl Fn(Caller<'_, T>, &[Val], &mut [Val]) -> Result<()> + Send + Sync + 'static,
-    ) -> Self {
-        let ty_clone = ty.clone();
-        unsafe {
-            HostFunc::new_unchecked(engine, ty, move |caller, values| {
-                Func::invoke(caller, &ty_clone, values, &func)
-            })
-        }
-    }
-
-    /// Analog of [`Func::new_unchecked`]
-    #[cfg(any(feature = "cranelift", feature = "winch"))]
-    pub unsafe fn new_unchecked<T>(
-        engine: &Engine,
-        ty: FuncType,
-        func: impl Fn(Caller<'_, T>, &mut [ValRaw]) -> Result<()> + Send + Sync + 'static,
-    ) -> Self {
-        let func = move |caller_vmctx, values: &mut [ValRaw]| {
-            Caller::<T>::with(caller_vmctx, |mut caller| {
-                caller.store.0.call_hook(CallHook::CallingHost)?;
-                let result = func(caller.sub_caller(), values)?;
-                caller.store.0.call_hook(CallHook::ReturningFromHost)?;
-                Ok(result)
-            })
-        };
-        let ctx = crate::trampoline::create_array_call_function(&ty, func, engine)
-            .expect("failed to create function");
-        HostFunc::_new(engine, ctx.into())
-    }
-
-    /// Analog of [`Func::wrap`]
-    pub fn wrap<T, Params, Results>(
-        engine: &Engine,
-        func: impl IntoFunc<T, Params, Results>,
-    ) -> Self {
-        let ctx = func.into_func(engine);
-        HostFunc::_new(engine, ctx)
-    }
-
-    /// Requires that this function's signature is already registered within
-    /// `Engine`. This happens automatically during the above two constructors.
-    fn _new(engine: &Engine, ctx: HostContext) -> Self {
-        HostFunc {
-            ctx,
-            engine: engine.clone(),
-        }
-    }
-
-    /// Inserts this `HostFunc` into a `Store`, returning the `Func` pointing to
-    /// it.
-    ///
-    /// # Unsafety
-    ///
-    /// Can only be inserted into stores with a matching `T` relative to when
-    /// this `HostFunc` was first created.
-    pub unsafe fn to_func(self: &Arc<Self>, store: &mut StoreOpaque) -> Func {
-        self.validate_store(store);
-        let me = self.clone();
-        Func::from_func_kind(FuncKind::SharedHost(me), store)
-    }
-
-    /// Inserts this `HostFunc` into a `Store`, returning the `Func` pointing to
-    /// it.
-    ///
-    /// This function is similar to, but not equivalent, to `HostFunc::to_func`.
-    /// Notably this function requires that the `Arc<Self>` pointer is otherwise
-    /// rooted within the `StoreOpaque` via another means. When in doubt use
-    /// `to_func` above as it's safer.
-    ///
-    /// # Unsafety
-    ///
-    /// Can only be inserted into stores with a matching `T` relative to when
-    /// this `HostFunc` was first created.
-    ///
-    /// Additionally the `&Arc<Self>` is not cloned in this function. Instead a
-    /// raw pointer to `Self` is stored within the `Store` for this function.
-    /// The caller must arrange for the `Arc<Self>` to be "rooted" in the store
-    /// provided via another means, probably by pushing to
-    /// `StoreOpaque::rooted_host_funcs`.
-    ///
-    /// Similarly, the caller must arrange for `rooted_func_ref` to be rooted in
-    /// the same store.
-    pub unsafe fn to_func_store_rooted(
-        self: &Arc<Self>,
-        store: &mut StoreOpaque,
-        rooted_func_ref: Option<NonNull<VMFuncRef>>,
-    ) -> Func {
-        self.validate_store(store);
-
-        if rooted_func_ref.is_some() {
-            debug_assert!(self.func_ref().wasm_call.is_none());
-            debug_assert!(matches!(self.ctx, HostContext::Native(_)));
-        }
-
-        Func::from_func_kind(
-            FuncKind::RootedHost(RootedHostFunc::new(self, rooted_func_ref)),
-            store,
-        )
-    }
-
-    /// Same as [`HostFunc::to_func`], different ownership.
-    unsafe fn into_func(self, store: &mut StoreOpaque) -> Func {
-        self.validate_store(store);
-        Func::from_func_kind(FuncKind::Host(Box::new(self)), store)
-    }
-
-    fn validate_store(&self, store: &mut StoreOpaque) {
-        // This assert is required to ensure that we can indeed safely insert
-        // `self` into the `store` provided, otherwise the type information we
-        // have listed won't be correct. This is possible to hit with the public
-        // API of Wasmtime, and should be documented in relevant functions.
-        assert!(
-            Engine::same(&self.engine, store.engine()),
-            "cannot use a store with a different engine than a linker was created with",
-        );
-    }
-
-    pub(crate) fn sig_index(&self) -> VMSharedSignatureIndex {
-        self.func_ref().type_index
-    }
-
-    pub(crate) fn func_ref(&self) -> &VMFuncRef {
-        match &self.ctx {
-            HostContext::Native(ctx) => unsafe { (*ctx.get()).func_ref() },
-            HostContext::Array(ctx) => unsafe { (*ctx.get()).func_ref() },
-        }
-    }
-
-    pub(crate) fn host_ctx(&self) -> &HostContext {
-        &self.ctx
-    }
-
-    fn export_func(&self) -> ExportFunction {
-        ExportFunction {
-            func_ref: NonNull::from(self.func_ref()),
-        }
-    }
-}
-
-impl Drop for HostFunc {
-    fn drop(&mut self) {
-        unsafe {
-            self.engine.signatures().unregister(self.sig_index());
-        }
-    }
-}
-
-impl FuncData {
-    #[inline]
-    fn export(&self) -> ExportFunction {
-        self.kind.export()
-    }
-
-    pub(crate) fn sig_index(&self) -> VMSharedSignatureIndex {
-        unsafe { self.export().func_ref.as_ref().type_index }
-    }
-}
-
-impl FuncKind {
-    #[inline]
-    fn export(&self) -> ExportFunction {
-        match self {
-            FuncKind::StoreOwned { export, .. } => *export,
-            FuncKind::SharedHost(host) => host.export_func(),
-            FuncKind::RootedHost(rooted) => ExportFunction {
-                func_ref: NonNull::from(rooted.func_ref()),
-            },
-            FuncKind::Host(host) => host.export_func(),
-        }
-    }
-}
-
-use self::rooted::*;
-
-/// An inner module is used here to force unsafe construction of
-/// `RootedHostFunc` instead of accidentally safely allowing access to its
-/// constructor.
-mod rooted {
-    use wasmtime_runtime::{SendSyncPtr, VMFuncRef};
-
-    use super::HostFunc;
-    use std::ptr::NonNull;
-    use std::sync::Arc;
-
-    /// A variant of a pointer-to-a-host-function used in `FuncKind::RootedHost`
-    /// above.
-    ///
-    /// For more documentation see `FuncKind::RootedHost`, `InstancePre`, and
-    /// `HostFunc::to_func_store_rooted`.
-    pub(crate) struct RootedHostFunc {
-        func: SendSyncPtr<HostFunc>,
-        func_ref: Option<SendSyncPtr<VMFuncRef>>,
-    }
-
-    impl RootedHostFunc {
-        /// Note that this is `unsafe` because this wrapper type allows safe
-        /// access to the pointer given at any time, including outside the
-        /// window of validity of `func`, so callers must not use the return
-        /// value past the lifetime of the provided `func`.
-        ///
-        /// Similarly, callers must ensure that the given `func_ref` is valid
-        /// for the liftime of the return value.
-        pub(crate) unsafe fn new(
-            func: &Arc<HostFunc>,
-            func_ref: Option<NonNull<VMFuncRef>>,
-        ) -> RootedHostFunc {
-            RootedHostFunc {
-                func: NonNull::from(&**func).into(),
-                func_ref: func_ref.map(|p| p.into()),
-            }
-        }
-
-        pub(crate) fn func(&self) -> &HostFunc {
-            // Safety invariants are upheld by the `RootedHostFunc::new` caller.
-            unsafe { self.func.as_ref() }
-        }
-
-        pub(crate) fn func_ref(&self) -> &VMFuncRef {
-            if let Some(f) = self.func_ref {
-                // Safety invariants are upheld by the `RootedHostFunc::new` caller.
-                unsafe { f.as_ref() }
-            } else {
-                self.func().func_ref()
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{Instance, Module, Store};
-
-    #[test]
-    fn hash_key_is_stable_across_duplicate_store_data_entries() -> Result<()> {
-        let mut store = Store::<()>::default();
-        let module = Module::new(
-            store.engine(),
-            r#"
-                (module
-                    (func (export "f")
-                        nop
-                    )
-                )
-            "#,
-        )?;
-        let instance = Instance::new(&mut store, &module, &[])?;
-
-        // Each time we `get_func`, we call `Func::from_wasmtime` which adds a
-        // new entry to `StoreData`, so `f1` and `f2` will have different
-        // indices into `StoreData`.
-        let f1 = instance.get_func(&mut store, "f").unwrap();
-        let f2 = instance.get_func(&mut store, "f").unwrap();
-
-        // But their hash keys are the same.
-        assert!(
-            f1.hash_key(&mut store.as_context_mut().0)
-                == f2.hash_key(&mut store.as_context_mut().0)
-        );
-
-        // But the hash keys are different from different funcs.
-        let instance2 = Instance::new(&mut store, &module, &[])?;
-        let f3 = instance2.get_func(&mut store, "f").unwrap();
-        assert!(
-            f1.hash_key(&mut store.as_context_mut().0)
-                != f3.hash_key(&mut store.as_context_mut().0)
-        );
-
-        Ok(())
-    }
-}
diff --git a/crates/wasmtime/src/func/typed.rs b/crates/wasmtime/src/func/typed.rs
deleted file mode 100644
index f1188faad4aa..000000000000
--- a/crates/wasmtime/src/func/typed.rs
+++ /dev/null
@@ -1,638 +0,0 @@
-use super::{invoke_wasm_and_catch_traps, HostAbi};
-use crate::store::{AutoAssertNoGc, StoreOpaque};
-use crate::{AsContextMut, ExternRef, Func, FuncType, StoreContextMut, ValRaw, ValType};
-use anyhow::{bail, Result};
-use std::marker;
-use std::mem::{self, MaybeUninit};
-use std::ptr::{self, NonNull};
-use wasmtime_runtime::{
-    VMContext, VMFuncRef, VMNativeCallFunction, VMOpaqueContext, VMSharedSignatureIndex,
-};
-
-/// A statically typed WebAssembly function.
-///
-/// Values of this type represent statically type-checked WebAssembly functions.
-/// The function within a [`TypedFunc`] is statically known to have `Params` as its
-/// parameters and `Results` as its results.
-///
-/// This structure is created via [`Func::typed`] or [`TypedFunc::new_unchecked`].
-/// For more documentation about this see those methods.
-#[repr(transparent)] // here for the C API
-pub struct TypedFunc<Params, Results> {
-    _a: marker::PhantomData<fn(Params) -> Results>,
-    func: Func,
-}
-
-impl<Params, Results> Copy for TypedFunc<Params, Results> {}
-
-impl<Params, Results> Clone for TypedFunc<Params, Results> {
-    fn clone(&self) -> TypedFunc<Params, Results> {
-        *self
-    }
-}
-
-impl<Params, Results> TypedFunc<Params, Results>
-where
-    Params: WasmParams,
-    Results: WasmResults,
-{
-    /// An unchecked version of [`Func::typed`] which does not perform a
-    /// typecheck and simply assumes that the type declared here matches the
-    /// type of this function.
-    ///
-    /// The semantics of this function are the same as [`Func::typed`] except
-    /// that no error is returned because no typechecking is done.
-    ///
-    /// # Unsafety
-    ///
-    /// This function only safe to call if `typed` would otherwise return `Ok`
-    /// for the same `Params` and `Results` specified. If `typed` would return
-    /// an error then the returned `TypedFunc` is memory unsafe to invoke.
-    pub unsafe fn new_unchecked(func: Func) -> TypedFunc<Params, Results> {
-        TypedFunc {
-            _a: marker::PhantomData,
-            func,
-        }
-    }
-
-    /// Returns the underlying [`Func`] that this is wrapping, losing the static
-    /// type information in the process.
-    pub fn func(&self) -> &Func {
-        &self.func
-    }
-
-    /// Invokes this WebAssembly function with the specified parameters.
-    ///
-    /// Returns either the results of the call, or a [`Trap`] if one happened.
-    ///
-    /// For more information, see the [`Func::typed`] and [`Func::call`]
-    /// documentation.
-    ///
-    /// # Errors
-    ///
-    /// For more information on errors see the documentation on [`Func::call`].
-    ///
-    /// # Panics
-    ///
-    /// This function will panic if it is called when the underlying [`Func`] is
-    /// connected to an asynchronous store.
-    ///
-    /// [`Trap`]: crate::Trap
-    pub fn call(&self, mut store: impl AsContextMut, params: Params) -> Result<Results> {
-        let mut store = store.as_context_mut();
-        assert!(
-            !store.0.async_support(),
-            "must use `call_async` with async stores"
-        );
-        let func = self.func.vm_func_ref(store.0);
-        unsafe { Self::call_raw(&mut store, func, params) }
-    }
-
-    /// Invokes this WebAssembly function with the specified parameters.
-    ///
-    /// Returns either the results of the call, or a [`Trap`] if one happened.
-    ///
-    /// For more information, see the [`Func::typed`] and [`Func::call_async`]
-    /// documentation.
-    ///
-    /// # Errors
-    ///
-    /// For more information on errors see the documentation on [`Func::call`].
-    ///
-    /// # Panics
-    ///
-    /// This function will panic if it is called when the underlying [`Func`] is
-    /// connected to a synchronous store.
-    ///
-    /// [`Trap`]: crate::Trap
-    #[cfg(feature = "async")]
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "async")))]
-    pub async fn call_async<T>(
-        &self,
-        mut store: impl AsContextMut<Data = T>,
-        params: Params,
-    ) -> Result<Results>
-    where
-        T: Send,
-    {
-        let mut store = store.as_context_mut();
-        assert!(
-            store.0.async_support(),
-            "must use `call` with non-async stores"
-        );
-        store
-            .on_fiber(|store| {
-                let func = self.func.vm_func_ref(store.0);
-                unsafe { Self::call_raw(store, func, params) }
-            })
-            .await?
-    }
-
-    pub(crate) unsafe fn call_raw<T>(
-        store: &mut StoreContextMut<'_, T>,
-        func: ptr::NonNull<VMFuncRef>,
-        params: Params,
-    ) -> Result<Results> {
-        // double-check that params/results match for this function's type in
-        // debug mode.
-        if cfg!(debug_assertions) {
-            Self::debug_typecheck(store.0, func.as_ref().type_index);
-        }
-
-        // See the comment in `Func::call_impl`'s `write_params` function.
-        if params.externrefs_count()
-            > store
-                .0
-                .externref_activations_table()
-                .bump_capacity_remaining()
-        {
-            store.gc();
-        }
-
-        // Validate that all runtime values flowing into this store indeed
-        // belong within this store, otherwise it would be unsafe for store
-        // values to cross each other.
-
-        let params = {
-            // GC is not safe here, since we move refs into the activations
-            // table but don't hold a strong reference onto them until we enter
-            // the Wasm frame and they get referenced from the stack maps.
-            let mut store = AutoAssertNoGc::new(&mut **store.as_context_mut().0);
-
-            match params.into_abi(&mut store) {
-                Some(abi) => abi,
-                None => {
-                    bail!("attempt to pass cross-`Store` value to Wasm as function argument")
-                }
-            }
-        };
-
-        // Try to capture only a single variable (a tuple) in the closure below.
-        // This means the size of the closure is one pointer and is much more
-        // efficient to move in memory. This closure is actually invoked on the
-        // other side of a C++ shim, so it can never be inlined enough to make
-        // the memory go away, so the size matters here for performance.
-        let mut captures = (func, MaybeUninit::uninit(), params, false);
-
-        let result = invoke_wasm_and_catch_traps(store, |caller| {
-            let (func_ref, ret, params, returned) = &mut captures;
-            let func_ref = func_ref.as_ref();
-            let result =
-                Params::invoke::<Results>(func_ref.native_call, func_ref.vmctx, caller, *params);
-            ptr::write(ret.as_mut_ptr(), result);
-            *returned = true
-        });
-        let (_, ret, _, returned) = captures;
-        debug_assert_eq!(result.is_ok(), returned);
-        result?;
-        Ok(Results::from_abi(store.0, ret.assume_init()))
-    }
-
-    /// Purely a debug-mode assertion, not actually used in release builds.
-    fn debug_typecheck(store: &StoreOpaque, func: VMSharedSignatureIndex) {
-        let ty = FuncType::from_wasm_func_type(
-            store
-                .engine()
-                .signatures()
-                .lookup_type(func)
-                .expect("signature should be registered"),
-        );
-        Params::typecheck(ty.params()).expect("params should match");
-        Results::typecheck(ty.results()).expect("results should match");
-    }
-}
-
-/// A trait implemented for types which can be arguments and results for
-/// closures passed to [`Func::wrap`] as well as parameters to [`Func::typed`].
-///
-/// This trait should not be implemented by user types. This trait may change at
-/// any time internally. The types which implement this trait, however, are
-/// stable over time.
-///
-/// For more information see [`Func::wrap`] and [`Func::typed`]
-pub unsafe trait WasmTy: Send {
-    #[doc(hidden)]
-    type Abi: Copy;
-    #[doc(hidden)]
-    #[inline]
-    fn typecheck(ty: crate::ValType) -> Result<()> {
-        if ty == Self::valtype() {
-            Ok(())
-        } else {
-            bail!("expected {} found {}", Self::valtype(), ty)
-        }
-    }
-    #[doc(hidden)]
-    fn valtype() -> ValType;
-    #[doc(hidden)]
-    fn compatible_with_store(&self, store: &StoreOpaque) -> bool;
-    #[doc(hidden)]
-    fn is_externref(&self) -> bool;
-    #[doc(hidden)]
-    unsafe fn abi_from_raw(raw: *mut ValRaw) -> Self::Abi;
-    #[doc(hidden)]
-    unsafe fn abi_into_raw(abi: Self::Abi, raw: *mut ValRaw);
-    #[doc(hidden)]
-    fn into_abi(self, store: &mut StoreOpaque) -> Self::Abi;
-    #[doc(hidden)]
-    unsafe fn from_abi(abi: Self::Abi, store: &mut StoreOpaque) -> Self;
-}
-
-macro_rules! integers {
-    ($($primitive:ident/$get_primitive:ident => $ty:ident in $raw:ident)*) => ($(
-        unsafe impl WasmTy for $primitive {
-            type Abi = $primitive;
-            #[inline]
-            fn valtype() -> ValType {
-                ValType::$ty
-            }
-            #[inline]
-            fn compatible_with_store(&self, _: &StoreOpaque) -> bool {
-                true
-            }
-            #[inline]
-            fn is_externref(&self) -> bool {
-                false
-            }
-            #[inline]
-            unsafe fn abi_from_raw(raw: *mut ValRaw) -> $primitive {
-                (*raw).$get_primitive()
-            }
-            #[inline]
-            unsafe fn abi_into_raw(abi: $primitive, raw: *mut ValRaw) {
-                *raw = ValRaw::$primitive(abi);
-            }
-            #[inline]
-            fn into_abi(self, _store: &mut StoreOpaque) -> Self::Abi {
-                self
-            }
-            #[inline]
-            unsafe fn from_abi(abi: Self::Abi, _store: &mut StoreOpaque) -> Self {
-                abi
-            }
-        }
-    )*)
-}
-
-integers! {
-    i32/get_i32 => I32 in i32
-    i64/get_i64 => I64 in i64
-    u32/get_u32 => I32 in i32
-    u64/get_u64 => I64 in i64
-}
-
-macro_rules! floats {
-    ($($float:ident/$int:ident/$get_float:ident => $ty:ident)*) => ($(
-        unsafe impl WasmTy for $float {
-            type Abi = $float;
-            #[inline]
-            fn valtype() -> ValType {
-                ValType::$ty
-            }
-            #[inline]
-            fn compatible_with_store(&self, _: &StoreOpaque) -> bool {
-                true
-            }
-            #[inline]
-            fn is_externref(&self) -> bool {
-                false
-            }
-            #[inline]
-            unsafe fn abi_from_raw(raw: *mut ValRaw) -> $float {
-                $float::from_bits((*raw).$get_float())
-            }
-            #[inline]
-            unsafe fn abi_into_raw(abi: $float, raw: *mut ValRaw) {
-                *raw = ValRaw::$float(abi.to_bits());
-            }
-            #[inline]
-            fn into_abi(self, _store: &mut StoreOpaque) -> Self::Abi {
-                self
-            }
-            #[inline]
-            unsafe fn from_abi(abi: Self::Abi, _store: &mut StoreOpaque) -> Self {
-                abi
-            }
-        }
-    )*)
-}
-
-floats! {
-    f32/u32/get_f32 => F32
-    f64/u64/get_f64 => F64
-}
-
-unsafe impl WasmTy for Option<ExternRef> {
-    type Abi = *mut u8;
-
-    #[inline]
-    fn valtype() -> ValType {
-        ValType::ExternRef
-    }
-
-    #[inline]
-    fn compatible_with_store(&self, _store: &StoreOpaque) -> bool {
-        true
-    }
-
-    #[inline]
-    fn is_externref(&self) -> bool {
-        true
-    }
-
-    #[inline]
-    unsafe fn abi_from_raw(raw: *mut ValRaw) -> *mut u8 {
-        (*raw).get_externref() as *mut u8
-    }
-
-    #[inline]
-    unsafe fn abi_into_raw(abi: *mut u8, raw: *mut ValRaw) {
-        *raw = ValRaw::externref(abi.cast());
-    }
-
-    #[inline]
-    fn into_abi(self, store: &mut StoreOpaque) -> Self::Abi {
-        if let Some(x) = self {
-            let abi = x.inner.as_raw();
-            unsafe {
-                // NB: We _must not_ trigger a GC when passing refs from host
-                // code into Wasm (e.g. returned from a host function or passed
-                // as arguments to a Wasm function). After insertion into the
-                // table, this reference is no longer rooted. If multiple
-                // references are being sent from the host into Wasm and we
-                // allowed GCs during insertion, then the following events could
-                // happen:
-                //
-                // * Reference A is inserted into the activations
-                //   table. This does not trigger a GC, but does fill the table
-                //   to capacity.
-                //
-                // * The caller's reference to A is removed. Now the only
-                //   reference to A is from the activations table.
-                //
-                // * Reference B is inserted into the activations table. Because
-                //   the table is at capacity, a GC is triggered.
-                //
-                // * A is reclaimed because the only reference keeping it alive
-                //   was the activation table's reference (it isn't inside any
-                //   Wasm frames on the stack yet, so stack scanning and stack
-                //   maps don't increment its reference count).
-                //
-                // * We transfer control to Wasm, giving it A and B. Wasm uses
-                //   A. That's a use after free.
-                //
-                // In conclusion, to prevent uses after free, we cannot GC
-                // during this insertion.
-                let mut store = AutoAssertNoGc::new(store);
-                store.insert_vmexternref_without_gc(x.inner);
-            }
-            abi
-        } else {
-            ptr::null_mut()
-        }
-    }
-
-    #[inline]
-    unsafe fn from_abi(abi: Self::Abi, _store: &mut StoreOpaque) -> Self {
-        if abi.is_null() {
-            None
-        } else {
-            Some(ExternRef {
-                inner: wasmtime_runtime::VMExternRef::clone_from_raw(abi),
-            })
-        }
-    }
-}
-
-unsafe impl WasmTy for Option<Func> {
-    type Abi = *mut wasmtime_runtime::VMFuncRef;
-
-    #[inline]
-    fn valtype() -> ValType {
-        ValType::FuncRef
-    }
-
-    #[inline]
-    fn compatible_with_store<'a>(&self, store: &StoreOpaque) -> bool {
-        if let Some(f) = self {
-            store.store_data().contains(f.0)
-        } else {
-            true
-        }
-    }
-
-    #[inline]
-    fn is_externref(&self) -> bool {
-        false
-    }
-
-    #[inline]
-    unsafe fn abi_from_raw(raw: *mut ValRaw) -> Self::Abi {
-        (*raw).get_funcref() as Self::Abi
-    }
-
-    #[inline]
-    unsafe fn abi_into_raw(abi: Self::Abi, raw: *mut ValRaw) {
-        *raw = ValRaw::funcref(abi.cast());
-    }
-
-    #[inline]
-    fn into_abi(self, store: &mut StoreOpaque) -> Self::Abi {
-        if let Some(f) = self {
-            f.vm_func_ref(store).as_ptr()
-        } else {
-            ptr::null_mut()
-        }
-    }
-
-    #[inline]
-    unsafe fn from_abi(abi: Self::Abi, store: &mut StoreOpaque) -> Self {
-        Func::from_caller_checked_func_ref(store, abi)
-    }
-}
-
-/// A trait used for [`Func::typed`] and with [`TypedFunc`] to represent the set of
-/// parameters for wasm functions.
-///
-/// This is implemented for bare types that can be passed to wasm as well as
-/// tuples of those types.
-pub unsafe trait WasmParams: Send {
-    #[doc(hidden)]
-    type Abi: Copy;
-
-    #[doc(hidden)]
-    fn typecheck(params: impl ExactSizeIterator<Item = crate::ValType>) -> Result<()>;
-
-    #[doc(hidden)]
-    fn externrefs_count(&self) -> usize;
-
-    #[doc(hidden)]
-    fn into_abi(self, store: &mut StoreOpaque) -> Option<Self::Abi>;
-
-    #[doc(hidden)]
-    unsafe fn invoke<R: WasmResults>(
-        func: NonNull<VMNativeCallFunction>,
-        vmctx1: *mut VMOpaqueContext,
-        vmctx2: *mut VMContext,
-        abi: Self::Abi,
-    ) -> R::ResultAbi;
-}
-
-// Forward an impl from `T` to `(T,)` for convenience if there's only one
-// parameter.
-unsafe impl<T> WasmParams for T
-where
-    T: WasmTy,
-{
-    type Abi = <(T,) as WasmParams>::Abi;
-
-    fn typecheck(params: impl ExactSizeIterator<Item = crate::ValType>) -> Result<()> {
-        <(T,) as WasmParams>::typecheck(params)
-    }
-
-    #[inline]
-    fn externrefs_count(&self) -> usize {
-        T::is_externref(self) as usize
-    }
-
-    #[inline]
-    fn into_abi(self, store: &mut StoreOpaque) -> Option<Self::Abi> {
-        <(T,) as WasmParams>::into_abi((self,), store)
-    }
-
-    unsafe fn invoke<R: WasmResults>(
-        func: NonNull<VMNativeCallFunction>,
-        vmctx1: *mut VMOpaqueContext,
-        vmctx2: *mut VMContext,
-        abi: Self::Abi,
-    ) -> R::ResultAbi {
-        <(T,) as WasmParams>::invoke::<R>(func, vmctx1, vmctx2, abi)
-    }
-}
-
-macro_rules! impl_wasm_params {
-    ($n:tt $($t:ident)*) => {
-        #[allow(non_snake_case)]
-        unsafe impl<$($t: WasmTy,)*> WasmParams for ($($t,)*) {
-            type Abi = ($($t::Abi,)*);
-
-            fn typecheck(mut params: impl ExactSizeIterator<Item = crate::ValType>) -> Result<()> {
-                let mut _n = 0;
-
-                $(
-                    match params.next() {
-                        Some(t) => {
-                            _n += 1;
-                            $t::typecheck(t)?
-                        },
-                        None => bail!("expected {} types, found {}", $n, params.len() + _n),
-                    }
-                )*
-
-                match params.next() {
-                    None => Ok(()),
-                    Some(_) => {
-                        _n += 1;
-                        bail!("expected {} types, found {}", $n, params.len() + _n)
-                    },
-                }
-            }
-
-            #[inline]
-            fn externrefs_count(&self) -> usize {
-                let ($(ref $t,)*) = self;
-                0 $(
-                    + $t.is_externref() as usize
-                )*
-            }
-
-
-            #[inline]
-            fn into_abi(self, _store: &mut StoreOpaque) -> Option<Self::Abi> {
-                let ($($t,)*) = self;
-                $(
-                    let $t = if $t.compatible_with_store(_store) {
-                        $t.into_abi(_store)
-                    } else {
-                        return None;
-                    };
-                )*
-                Some(($($t,)*))
-            }
-
-            unsafe fn invoke<R: WasmResults>(
-                func: NonNull<VMNativeCallFunction>,
-                vmctx1: *mut VMOpaqueContext,
-                vmctx2: *mut VMContext,
-                abi: Self::Abi,
-            ) -> R::ResultAbi {
-                let fnptr = mem::transmute::<
-                    NonNull<VMNativeCallFunction>,
-                    unsafe extern "C" fn(
-                        *mut VMOpaqueContext,
-                        *mut VMContext,
-                        $($t::Abi,)*
-                        <R::ResultAbi as HostAbi>::Retptr,
-                    ) -> <R::ResultAbi as HostAbi>::Abi,
-                    >(func);
-                let ($($t,)*) = abi;
-                // Use the `call` function to acquire a `retptr` which we'll
-                // forward to the native function. Once we have it we also
-                // convert all our arguments to abi arguments to go to the raw
-                // function.
-                //
-                // Upon returning `R::call` will convert all the returns back
-                // into `R`.
-                <R::ResultAbi as HostAbi>::call(|retptr| {
-                    fnptr(vmctx1, vmctx2, $($t,)* retptr)
-                })
-            }
-        }
-    };
-}
-
-for_each_function_signature!(impl_wasm_params);
-
-/// A trait used for [`Func::typed`] and with [`TypedFunc`] to represent the set of
-/// results for wasm functions.
-///
-/// This is currently only implemented for `()` and for bare types that can be
-/// returned. This is not yet implemented for tuples because a multi-value
-/// `TypedFunc` is not currently supported.
-pub unsafe trait WasmResults: WasmParams {
-    #[doc(hidden)]
-    type ResultAbi: HostAbi;
-    #[doc(hidden)]
-    unsafe fn from_abi(store: &mut StoreOpaque, abi: Self::ResultAbi) -> Self;
-}
-
-// Forwards from a bare type `T` to the 1-tuple type `(T,)`
-unsafe impl<T: WasmTy> WasmResults for T
-where
-    (T::Abi,): HostAbi,
-{
-    type ResultAbi = <(T,) as WasmResults>::ResultAbi;
-
-    unsafe fn from_abi(store: &mut StoreOpaque, abi: Self::ResultAbi) -> Self {
-        <(T,) as WasmResults>::from_abi(store, abi).0
-    }
-}
-
-macro_rules! impl_wasm_results {
-    ($n:tt $($t:ident)*) => {
-        #[allow(non_snake_case, unused_variables)]
-        unsafe impl<$($t: WasmTy,)*> WasmResults for ($($t,)*)
-            where ($($t::Abi,)*): HostAbi
-        {
-            type ResultAbi = ($($t::Abi,)*);
-
-            #[inline]
-            unsafe fn from_abi(store: &mut StoreOpaque, abi: Self::ResultAbi) -> Self {
-                let ($($t,)*) = abi;
-                ($($t::from_abi($t, store),)*)
-            }
-        }
-    };
-}
-
-for_each_function_signature!(impl_wasm_results);
diff --git a/crates/wasmtime/src/instance.rs b/crates/wasmtime/src/instance.rs
deleted file mode 100644
index af070727af1b..000000000000
--- a/crates/wasmtime/src/instance.rs
+++ /dev/null
@@ -1,941 +0,0 @@
-use crate::linker::{Definition, DefinitionType};
-use crate::store::{InstanceId, StoreOpaque, Stored};
-use crate::types::matching;
-use crate::{
-    AsContextMut, Engine, Export, Extern, Func, Global, Memory, Module, SharedMemory, StoreContext,
-    StoreContextMut, Table, TypedFunc,
-};
-use anyhow::{anyhow, bail, Context, Result};
-use std::mem;
-use std::ptr::NonNull;
-use std::sync::Arc;
-use wasmtime_environ::{EntityType, FuncIndex, GlobalIndex, MemoryIndex, PrimaryMap, TableIndex};
-use wasmtime_runtime::{
-    Imports, InstanceAllocationRequest, StorePtr, VMContext, VMFuncRef, VMFunctionImport,
-    VMGlobalImport, VMMemoryImport, VMNativeCallFunction, VMOpaqueContext, VMTableImport,
-};
-
-/// An instantiated WebAssembly module.
-///
-/// This type represents the instantiation of a [`Module`]. Once instantiated
-/// you can access the [`exports`](Instance::exports) which are of type
-/// [`Extern`] and provide the ability to call functions, set globals, read
-/// memory, etc. When interacting with any wasm code you'll want to make an
-/// [`Instance`] to call any code or execute anything.
-///
-/// Instances are owned by a [`Store`](crate::Store) which is passed in at
-/// creation time. It's recommended to create instances with
-/// [`Linker::instantiate`](crate::Linker::instantiate) or similar
-/// [`Linker`](crate::Linker) methods, but a more low-level constructor is also
-/// available as [`Instance::new`].
-#[derive(Copy, Clone, Debug)]
-#[repr(transparent)]
-pub struct Instance(Stored<InstanceData>);
-
-pub(crate) struct InstanceData {
-    /// The id of the instance within the store, used to find the original
-    /// `InstanceHandle`.
-    id: InstanceId,
-    /// A lazily-populated list of exports of this instance. The order of
-    /// exports here matches the order of the exports in the the original
-    /// module.
-    exports: Vec<Option<Extern>>,
-}
-
-impl InstanceData {
-    pub fn from_id(id: InstanceId) -> InstanceData {
-        InstanceData {
-            id,
-            exports: vec![],
-        }
-    }
-}
-
-impl Instance {
-    /// Creates a new [`Instance`] from the previously compiled [`Module`] and
-    /// list of `imports` specified.
-    ///
-    /// This method instantiates the `module` provided with the `imports`,
-    /// following the procedure in the [core specification][inst] to
-    /// instantiate. Instantiation can fail for a number of reasons (many
-    /// specified below), but if successful the `start` function will be
-    /// automatically run (if specified in the `module`) and then the
-    /// [`Instance`] will be returned.
-    ///
-    /// Per the WebAssembly spec, instantiation includes running the module's
-    /// start function, if it has one (not to be confused with the `_start`
-    /// function, which is not run).
-    ///
-    /// Note that this is a low-level function that just performs an
-    /// instantiation. See the [`Linker`](crate::Linker) struct for an API which
-    /// provides a convenient way to link imports and provides automatic Command
-    /// and Reactor behavior.
-    ///
-    /// ## Providing Imports
-    ///
-    /// The entries in the list of `imports` are intended to correspond 1:1
-    /// with the list of imports returned by [`Module::imports`]. Before
-    /// calling [`Instance::new`] you'll want to inspect the return value of
-    /// [`Module::imports`] and, for each import type, create an [`Extern`]
-    /// which corresponds to that type.  These [`Extern`] values are all then
-    /// collected into a list and passed to this function.
-    ///
-    /// Note that this function is intentionally relatively low level. For an
-    /// easier time passing imports by doing name-based resolution it's
-    /// recommended to instead use the [`Linker`](crate::Linker) type.
-    ///
-    /// ## Errors
-    ///
-    /// This function can fail for a number of reasons, including, but not
-    /// limited to:
-    ///
-    /// * The number of `imports` provided doesn't match the number of imports
-    ///   returned by the `module`'s [`Module::imports`] method.
-    /// * The type of any [`Extern`] doesn't match the corresponding
-    ///   [`ExternType`] entry that it maps to.
-    /// * The `start` function in the instance, if present, traps.
-    /// * Module/instance resource limits are exceeded.
-    ///
-    /// When instantiation fails it's recommended to inspect the return value to
-    /// see why it failed, or bubble it upwards. If you'd like to specifically
-    /// check for trap errors, you can use `error.downcast::<Trap>()`. For more
-    /// about error handling see the [`Trap`] documentation.
-    ///
-    /// [`Trap`]: crate::Trap
-    ///
-    /// # Panics
-    ///
-    /// This function will panic if called with a store associated with a
-    /// [`asynchronous config`](crate::Config::async_support). This function
-    /// will also panic if any [`Extern`] supplied is not owned by `store`.
-    ///
-    /// [inst]: https://webassembly.github.io/spec/core/exec/modules.html#exec-instantiation
-    /// [`ExternType`]: crate::ExternType
-    pub fn new(
-        mut store: impl AsContextMut,
-        module: &Module,
-        imports: &[Extern],
-    ) -> Result<Instance> {
-        let mut store = store.as_context_mut();
-        let imports = Instance::typecheck_externs(store.0, module, imports)?;
-        // Note that the unsafety here should be satisfied by the call to
-        // `typecheck_externs` above which satisfies the condition that all
-        // the imports are valid for this module.
-        unsafe { Instance::new_started(&mut store, module, imports.as_ref()) }
-    }
-
-    /// Same as [`Instance::new`], except for usage in [asynchronous stores].
-    ///
-    /// For more details about this function see the documentation on
-    /// [`Instance::new`]. The only difference between these two methods is that
-    /// this one will asynchronously invoke the wasm start function in case it
-    /// calls any imported function which is an asynchronous host function (e.g.
-    /// created with [`Func::new_async`](crate::Func::new_async).
-    ///
-    /// # Panics
-    ///
-    /// This function will panic if called with a store associated with a
-    /// [`synchronous config`](crate::Config::new). This is only compatible with
-    /// stores associated with an [`asynchronous
-    /// config`](crate::Config::async_support).
-    ///
-    /// This function will also panic, like [`Instance::new`], if any [`Extern`]
-    /// specified does not belong to `store`.
-    #[cfg(feature = "async")]
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "async")))]
-    pub async fn new_async<T>(
-        mut store: impl AsContextMut<Data = T>,
-        module: &Module,
-        imports: &[Extern],
-    ) -> Result<Instance>
-    where
-        T: Send,
-    {
-        let mut store = store.as_context_mut();
-        let imports = Instance::typecheck_externs(store.0, module, imports)?;
-        // See `new` for notes on this unsafety
-        unsafe { Instance::new_started_async(&mut store, module, imports.as_ref()).await }
-    }
-
-    fn typecheck_externs(
-        store: &mut StoreOpaque,
-        module: &Module,
-        imports: &[Extern],
-    ) -> Result<OwnedImports> {
-        for import in imports {
-            if !import.comes_from_same_store(store) {
-                bail!("cross-`Store` instantiation is not currently supported");
-            }
-        }
-        typecheck(module, imports, |cx, ty, item| {
-            let item = DefinitionType::from(store, item);
-            cx.definition(ty, &item)
-        })?;
-        let mut owned_imports = OwnedImports::new(module);
-        for import in imports {
-            owned_imports.push(import, store, module);
-        }
-        Ok(owned_imports)
-    }
-
-    /// Internal function to create an instance and run the start function.
-    ///
-    /// This function's unsafety is the same as `Instance::new_raw`.
-    pub(crate) unsafe fn new_started<T>(
-        store: &mut StoreContextMut<'_, T>,
-        module: &Module,
-        imports: Imports<'_>,
-    ) -> Result<Instance> {
-        assert!(
-            !store.0.async_support(),
-            "must use async instantiation when async support is enabled",
-        );
-        Self::new_started_impl(store, module, imports)
-    }
-
-    /// Internal function to create an instance and run the start function.
-    ///
-    /// ONLY CALL THIS IF YOU HAVE ALREADY CHECKED FOR ASYNCNESS AND HANDLED
-    /// THE FIBER NONSENSE
-    pub(crate) unsafe fn new_started_impl<T>(
-        store: &mut StoreContextMut<'_, T>,
-        module: &Module,
-        imports: Imports<'_>,
-    ) -> Result<Instance> {
-        let (instance, start) = Instance::new_raw(store.0, module, imports)?;
-        if let Some(start) = start {
-            instance.start_raw(store, start)?;
-        }
-        Ok(instance)
-    }
-
-    /// Internal function to create an instance and run the start function.
-    ///
-    /// This function's unsafety is the same as `Instance::new_raw`.
-    #[cfg(feature = "async")]
-    async unsafe fn new_started_async<T>(
-        store: &mut StoreContextMut<'_, T>,
-        module: &Module,
-        imports: Imports<'_>,
-    ) -> Result<Instance>
-    where
-        T: Send,
-    {
-        assert!(
-            store.0.async_support(),
-            "must use sync instantiation when async support is disabled",
-        );
-
-        store
-            .on_fiber(|store| Self::new_started_impl(store, module, imports))
-            .await?
-    }
-
-    /// Internal function to create an instance which doesn't have its `start`
-    /// function run yet.
-    ///
-    /// This is not intended to be exposed from Wasmtime, it's intended to
-    /// refactor out common code from `new_started` and `new_started_async`.
-    ///
-    /// Note that this step needs to be run on a fiber in async mode even
-    /// though it doesn't do any blocking work because an async resource
-    /// limiter may need to yield.
-    ///
-    /// # Unsafety
-    ///
-    /// This method is unsafe because it does not type-check the `imports`
-    /// provided. The `imports` provided must be suitable for the module
-    /// provided as well.
-    unsafe fn new_raw(
-        store: &mut StoreOpaque,
-        module: &Module,
-        imports: Imports<'_>,
-    ) -> Result<(Instance, Option<FuncIndex>)> {
-        if !Engine::same(store.engine(), module.engine()) {
-            bail!("cross-`Engine` instantiation is not currently supported");
-        }
-        store.bump_resource_counts(module)?;
-
-        let compiled_module = module.compiled_module();
-
-        // Register the module just before instantiation to ensure we keep the module
-        // properly referenced while in use by the store.
-        let module_id = store.modules_mut().register_module(module);
-        store.fill_func_refs();
-
-        // The first thing we do is issue an instance allocation request
-        // to the instance allocator. This, on success, will give us an
-        // instance handle.
-        //
-        // Note that the `host_state` here is a pointer back to the
-        // `Instance` we'll be returning from this function. This is a
-        // circular reference so we can't construct it before we construct
-        // this instance, so we determine what the ID is and then assert
-        // it's the same later when we do actually insert it.
-        let instance_to_be = store.store_data().next_id::<InstanceData>();
-
-        let mut instance_handle =
-            store
-                .engine()
-                .allocator()
-                .allocate_module(InstanceAllocationRequest {
-                    runtime_info: &module.runtime_info(),
-                    imports,
-                    host_state: Box::new(Instance(instance_to_be)),
-                    store: StorePtr::new(store.traitobj()),
-                    wmemcheck: store.engine().config().wmemcheck,
-                    pkey: store.get_pkey(),
-                })?;
-
-        // The instance still has lots of setup, for example
-        // data/elements/start/etc. This can all fail, but even on failure
-        // the instance may persist some state via previous successful
-        // initialization. For this reason once we have an instance handle
-        // we immediately insert it into the store to keep it alive.
-        //
-        // Note that we `clone` the instance handle just to make easier
-        // working the the borrow checker here easier. Technically the `&mut
-        // instance` has somewhat of a borrow on `store` (which
-        // conflicts with the borrow on `store.engine`) but this doesn't
-        // matter in practice since initialization isn't even running any
-        // code here anyway.
-        let id = store.add_instance(instance_handle.clone(), module_id);
-
-        // Additionally, before we start doing fallible instantiation, we
-        // do one more step which is to insert an `InstanceData`
-        // corresponding to this instance. This `InstanceData` can be used
-        // via `Caller::get_export` if our instance's state "leaks" into
-        // other instances, even if we don't return successfully from this
-        // function.
-        //
-        // We don't actually load all exports from the instance at this
-        // time, instead preferring to lazily load them as they're demanded.
-        // For module/instance exports, though, those aren't actually
-        // stored in the instance handle so we need to immediately handle
-        // those here.
-        let instance = {
-            let exports = vec![None; compiled_module.module().exports.len()];
-            let data = InstanceData { id, exports };
-            Instance::from_wasmtime(data, store)
-        };
-
-        // double-check our guess of what the new instance's ID would be
-        // was actually correct.
-        assert_eq!(instance.0, instance_to_be);
-
-        // Now that we've recorded all information we need to about this
-        // instance within a `Store` we can start performing fallible
-        // initialization. Note that we still defer the `start` function to
-        // later since that may need to run asynchronously.
-        //
-        // If this returns an error (or if the start function traps) then
-        // any other initialization which may have succeeded which placed
-        // items from this instance into other instances should be ok when
-        // those items are loaded and run we'll have all the metadata to
-        // look at them.
-        instance_handle.initialize(
-            compiled_module.module(),
-            store.engine().config().features.bulk_memory,
-        )?;
-
-        Ok((instance, compiled_module.module().start_func))
-    }
-
-    pub(crate) fn from_wasmtime(handle: InstanceData, store: &mut StoreOpaque) -> Instance {
-        Instance(store.store_data_mut().insert(handle))
-    }
-
-    fn start_raw<T>(&self, store: &mut StoreContextMut<'_, T>, start: FuncIndex) -> Result<()> {
-        let id = store.0.store_data()[self.0].id;
-        // If a start function is present, invoke it. Make sure we use all the
-        // trap-handling configuration in `store` as well.
-        let instance = store.0.instance_mut(id);
-        let f = instance.get_exported_func(start);
-        let caller_vmctx = instance.vmctx();
-        unsafe {
-            super::func::invoke_wasm_and_catch_traps(store, |_default_caller| {
-                let func = mem::transmute::<
-                    NonNull<VMNativeCallFunction>,
-                    extern "C" fn(*mut VMOpaqueContext, *mut VMContext),
-                >(f.func_ref.as_ref().native_call);
-                func(f.func_ref.as_ref().vmctx, caller_vmctx)
-            })?;
-        }
-        Ok(())
-    }
-
-    /// Get this instance's module.
-    pub fn module<'a, T: 'a>(&self, store: impl Into<StoreContext<'a, T>>) -> &'a Module {
-        self._module(store.into().0)
-    }
-
-    fn _module<'a>(&self, store: &'a StoreOpaque) -> &'a Module {
-        let InstanceData { id, .. } = store[self.0];
-        store.module_for_instance(id).unwrap()
-    }
-
-    /// Returns the list of exported items from this [`Instance`].
-    ///
-    /// # Panics
-    ///
-    /// Panics if `store` does not own this instance.
-    pub fn exports<'a, T: 'a>(
-        &'a self,
-        store: impl Into<StoreContextMut<'a, T>>,
-    ) -> impl ExactSizeIterator<Item = Export<'a>> + 'a {
-        self._exports(store.into().0)
-    }
-
-    fn _exports<'a>(
-        &'a self,
-        store: &'a mut StoreOpaque,
-    ) -> impl ExactSizeIterator<Item = Export<'a>> + 'a {
-        // If this is an `Instantiated` instance then all the `exports` may not
-        // be filled in. Fill them all in now if that's the case.
-        let InstanceData { exports, id, .. } = &store[self.0];
-        if exports.iter().any(|e| e.is_none()) {
-            let module = Arc::clone(store.instance(*id).module());
-            for name in module.exports.keys() {
-                self._get_export(store, name);
-            }
-        }
-
-        let data = &store.store_data()[self.0];
-        let module = store.instance(data.id).module();
-        module
-            .exports
-            .iter()
-            .zip(&data.exports)
-            .map(|((name, _), export)| Export::new(name, export.clone().unwrap()))
-    }
-
-    /// Looks up an exported [`Extern`] value by name.
-    ///
-    /// This method will search the module for an export named `name` and return
-    /// the value, if found.
-    ///
-    /// Returns `None` if there was no export named `name`.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `store` does not own this instance.
-    ///
-    /// # Why does `get_export` take a mutable context?
-    ///
-    /// This method requires a mutable context because an instance's exports are
-    /// lazily populated, and we cache them as they are accessed. This makes
-    /// instantiating a module faster, but also means this method requires a
-    /// mutable context.
-    pub fn get_export(&self, mut store: impl AsContextMut, name: &str) -> Option<Extern> {
-        self._get_export(store.as_context_mut().0, name)
-    }
-
-    fn _get_export(&self, store: &mut StoreOpaque, name: &str) -> Option<Extern> {
-        // Instantiated instances will lazily fill in exports, so we process
-        // all that lazy logic here.
-        let data = &store[self.0];
-
-        let instance = store.instance(data.id);
-        let (i, _, &index) = instance.module().exports.get_full(name)?;
-        if let Some(export) = &data.exports[i] {
-            return Some(export.clone());
-        }
-
-        let id = data.id;
-        let instance = store.instance_mut(id); // reborrow the &mut Instancehandle
-        let item =
-            unsafe { Extern::from_wasmtime_export(instance.get_export_by_index(index), store) };
-        let data = &mut store[self.0];
-        data.exports[i] = Some(item.clone());
-        Some(item)
-    }
-
-    /// Looks up an exported [`Func`] value by name.
-    ///
-    /// Returns `None` if there was no export named `name`, or if there was but
-    /// it wasn't a function.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `store` does not own this instance.
-    pub fn get_func(&self, store: impl AsContextMut, name: &str) -> Option<Func> {
-        self.get_export(store, name)?.into_func()
-    }
-
-    /// Looks up an exported [`Func`] value by name and with its type.
-    ///
-    /// This function is a convenience wrapper over [`Instance::get_func`] and
-    /// [`Func::typed`]. For more information see the linked documentation.
-    ///
-    /// Returns an error if `name` isn't a function export or if the export's
-    /// type did not match `Params` or `Results`
-    ///
-    /// # Panics
-    ///
-    /// Panics if `store` does not own this instance.
-    pub fn get_typed_func<Params, Results>(
-        &self,
-        mut store: impl AsContextMut,
-        name: &str,
-    ) -> Result<TypedFunc<Params, Results>>
-    where
-        Params: crate::WasmParams,
-        Results: crate::WasmResults,
-    {
-        let f = self
-            .get_export(store.as_context_mut(), name)
-            .and_then(|f| f.into_func())
-            .ok_or_else(|| anyhow!("failed to find function export `{}`", name))?;
-        Ok(f.typed::<Params, Results>(store)
-            .with_context(|| format!("failed to convert function `{}` to given type", name))?)
-    }
-
-    /// Looks up an exported [`Table`] value by name.
-    ///
-    /// Returns `None` if there was no export named `name`, or if there was but
-    /// it wasn't a table.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `store` does not own this instance.
-    pub fn get_table(&self, store: impl AsContextMut, name: &str) -> Option<Table> {
-        self.get_export(store, name)?.into_table()
-    }
-
-    /// Looks up an exported [`Memory`] value by name.
-    ///
-    /// Returns `None` if there was no export named `name`, or if there was but
-    /// it wasn't a memory.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `store` does not own this instance.
-    pub fn get_memory(&self, store: impl AsContextMut, name: &str) -> Option<Memory> {
-        self.get_export(store, name)?.into_memory()
-    }
-
-    /// Looks up an exported [`SharedMemory`] value by name.
-    ///
-    /// Returns `None` if there was no export named `name`, or if there was but
-    /// it wasn't a shared memory.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `store` does not own this instance.
-    pub fn get_shared_memory(
-        &self,
-        mut store: impl AsContextMut,
-        name: &str,
-    ) -> Option<SharedMemory> {
-        let mut store = store.as_context_mut();
-        self.get_export(&mut store, name)?.into_shared_memory()
-    }
-
-    /// Looks up an exported [`Global`] value by name.
-    ///
-    /// Returns `None` if there was no export named `name`, or if there was but
-    /// it wasn't a global.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `store` does not own this instance.
-    pub fn get_global(&self, store: impl AsContextMut, name: &str) -> Option<Global> {
-        self.get_export(store, name)?.into_global()
-    }
-
-    #[cfg(feature = "component-model")]
-    pub(crate) fn id(&self, store: &StoreOpaque) -> InstanceId {
-        store[self.0].id
-    }
-
-    /// Get all globals within this instance.
-    ///
-    /// Returns both import and defined globals.
-    ///
-    /// Returns both exported and non-exported globals.
-    ///
-    /// Gives access to the full globals space.
-    pub(crate) fn all_globals<'a>(
-        &'a self,
-        store: &'a mut StoreOpaque,
-    ) -> impl ExactSizeIterator<Item = (GlobalIndex, Global)> + 'a {
-        let data = &store[self.0];
-        let instance = store.instance_mut(data.id);
-        instance
-            .all_globals()
-            .collect::<Vec<_>>()
-            .into_iter()
-            .map(|(i, g)| (i, unsafe { Global::from_wasmtime_global(g, store) }))
-    }
-
-    /// Get all memories within this instance.
-    ///
-    /// Returns both import and defined memories.
-    ///
-    /// Returns both exported and non-exported memories.
-    ///
-    /// Gives access to the full memories space.
-    pub(crate) fn all_memories<'a>(
-        &'a self,
-        store: &'a mut StoreOpaque,
-    ) -> impl ExactSizeIterator<Item = (MemoryIndex, Memory)> + 'a {
-        let data = &store[self.0];
-        let instance = store.instance_mut(data.id);
-        instance
-            .all_memories()
-            .collect::<Vec<_>>()
-            .into_iter()
-            .map(|(i, m)| (i, unsafe { Memory::from_wasmtime_memory(m, store) }))
-    }
-}
-
-pub(crate) struct OwnedImports {
-    functions: PrimaryMap<FuncIndex, VMFunctionImport>,
-    tables: PrimaryMap<TableIndex, VMTableImport>,
-    memories: PrimaryMap<MemoryIndex, VMMemoryImport>,
-    globals: PrimaryMap<GlobalIndex, VMGlobalImport>,
-}
-
-impl OwnedImports {
-    fn new(module: &Module) -> OwnedImports {
-        let mut ret = OwnedImports::empty();
-        ret.reserve(module);
-        return ret;
-    }
-
-    pub(crate) fn empty() -> OwnedImports {
-        OwnedImports {
-            functions: PrimaryMap::new(),
-            tables: PrimaryMap::new(),
-            memories: PrimaryMap::new(),
-            globals: PrimaryMap::new(),
-        }
-    }
-
-    pub(crate) fn reserve(&mut self, module: &Module) {
-        let raw = module.compiled_module().module();
-        self.functions.reserve(raw.num_imported_funcs);
-        self.tables.reserve(raw.num_imported_tables);
-        self.memories.reserve(raw.num_imported_memories);
-        self.globals.reserve(raw.num_imported_globals);
-    }
-
-    #[cfg(feature = "component-model")]
-    pub(crate) fn clear(&mut self) {
-        self.functions.clear();
-        self.tables.clear();
-        self.memories.clear();
-        self.globals.clear();
-    }
-
-    fn push(&mut self, item: &Extern, store: &mut StoreOpaque, module: &Module) {
-        match item {
-            Extern::Func(i) => {
-                self.functions.push(i.vmimport(store, module));
-            }
-            Extern::Global(i) => {
-                self.globals.push(i.vmimport(store));
-            }
-            Extern::Table(i) => {
-                self.tables.push(i.vmimport(store));
-            }
-            Extern::Memory(i) => {
-                self.memories.push(i.vmimport(store));
-            }
-            Extern::SharedMemory(i) => {
-                self.memories.push(i.vmimport(store));
-            }
-        }
-    }
-
-    /// Note that this is unsafe as the validity of `item` is not verified and
-    /// it contains a bunch of raw pointers.
-    #[cfg(feature = "component-model")]
-    pub(crate) unsafe fn push_export(&mut self, item: &wasmtime_runtime::Export) {
-        match item {
-            wasmtime_runtime::Export::Function(f) => {
-                let f = f.func_ref.as_ref();
-                self.functions.push(VMFunctionImport {
-                    wasm_call: f.wasm_call.unwrap(),
-                    native_call: f.native_call,
-                    array_call: f.array_call,
-                    vmctx: f.vmctx,
-                });
-            }
-            wasmtime_runtime::Export::Global(g) => {
-                self.globals.push(VMGlobalImport { from: g.definition });
-            }
-            wasmtime_runtime::Export::Table(t) => {
-                self.tables.push(VMTableImport {
-                    from: t.definition,
-                    vmctx: t.vmctx,
-                });
-            }
-            wasmtime_runtime::Export::Memory(m) => {
-                self.memories.push(VMMemoryImport {
-                    from: m.definition,
-                    vmctx: m.vmctx,
-                    index: m.index,
-                });
-            }
-        }
-    }
-
-    pub(crate) fn as_ref(&self) -> Imports<'_> {
-        Imports {
-            tables: self.tables.values().as_slice(),
-            globals: self.globals.values().as_slice(),
-            memories: self.memories.values().as_slice(),
-            functions: self.functions.values().as_slice(),
-        }
-    }
-}
-
-/// An instance, pre-instantiation, that is ready to be instantiated.
-///
-/// This structure represents an instance *just before* it was instantiated,
-/// after all type-checking and imports have been resolved. The only thing left
-/// to do for this instance is to actually run the process of instantiation.
-///
-/// Note that an `InstancePre` may not be tied to any particular [`Store`] if
-/// none of the imports it closed over are tied to any particular [`Store`].
-///
-/// This structure is created through the [`Linker::instantiate_pre`] method,
-/// which also has some more information and examples.
-///
-/// [`Store`]: crate::Store
-/// [`Linker::instantiate_pre`]: crate::Linker::instantiate_pre
-pub struct InstancePre<T> {
-    module: Module,
-
-    /// The items which this `InstancePre` use to instantiate the `module`
-    /// provided, passed to `Instance::new_started` after inserting them into a
-    /// `Store`.
-    ///
-    /// Note that this is stored as an `Arc<[T]>` to quickly move a strong
-    /// reference to everything internally into a `Store<T>` without having to
-    /// clone each individual item.
-    items: Arc<[Definition]>,
-
-    /// A count of `Definition::HostFunc` entries in `items` above to
-    /// preallocate space in a `Store` up front for all entries to be inserted.
-    host_funcs: usize,
-
-    /// The `VMFuncRef`s for the functions in `items` that do not
-    /// have a `wasm_call` trampoline. We pre-allocate and pre-patch these
-    /// `VMFuncRef`s so that we don't have to do it at
-    /// instantiation time.
-    ///
-    /// This is an `Arc<[T]>` for the same reason as `items`.
-    func_refs: Arc<[VMFuncRef]>,
-
-    _marker: std::marker::PhantomData<fn() -> T>,
-}
-
-/// InstancePre's clone does not require T: Clone
-impl<T> Clone for InstancePre<T> {
-    fn clone(&self) -> Self {
-        Self {
-            module: self.module.clone(),
-            items: self.items.clone(),
-            host_funcs: self.host_funcs,
-            func_refs: self.func_refs.clone(),
-            _marker: self._marker,
-        }
-    }
-}
-
-impl<T> InstancePre<T> {
-    /// Creates a new `InstancePre` which type-checks the `items` provided and
-    /// on success is ready to instantiate a new instance.
-    ///
-    /// # Unsafety
-    ///
-    /// This method is unsafe as the `T` of the `InstancePre<T>` is not
-    /// guaranteed to be the same as the `T` within the `Store`, the caller must
-    /// verify that.
-    pub(crate) unsafe fn new(module: &Module, items: Vec<Definition>) -> Result<InstancePre<T>> {
-        typecheck(module, &items, |cx, ty, item| cx.definition(ty, &item.ty()))?;
-
-        let mut func_refs = vec![];
-        let mut host_funcs = 0;
-        for item in &items {
-            match item {
-                Definition::Extern(_, _) => {}
-                Definition::HostFunc(f) => {
-                    host_funcs += 1;
-                    if f.func_ref().wasm_call.is_none() {
-                        // `f` needs its `VMFuncRef::wasm_call`
-                        // patched with a Wasm-to-native trampoline.
-                        debug_assert!(matches!(f.host_ctx(), crate::HostContext::Native(_)));
-                        func_refs.push(VMFuncRef {
-                            wasm_call: module
-                                .runtime_info()
-                                .wasm_to_native_trampoline(f.sig_index()),
-                            ..*f.func_ref()
-                        });
-                    }
-                }
-            }
-        }
-
-        Ok(InstancePre {
-            module: module.clone(),
-            items: items.into(),
-            host_funcs,
-            func_refs: func_refs.into(),
-            _marker: std::marker::PhantomData,
-        })
-    }
-
-    /// Returns a reference to the module that this [`InstancePre`] will be
-    /// instantiating.
-    pub fn module(&self) -> &Module {
-        &self.module
-    }
-
-    /// Instantiates this instance, creating a new instance within the provided
-    /// `store`.
-    ///
-    /// This function will run the actual process of instantiation to
-    /// completion. This will use all of the previously-closed-over items as
-    /// imports to instantiate the module that this was originally created with.
-    ///
-    /// For more information about instantiation see [`Instance::new`].
-    ///
-    /// # Panics
-    ///
-    /// Panics if any import closed over by this [`InstancePre`] isn't owned by
-    /// `store`, or if `store` has async support enabled. Additionally this
-    /// function will panic if the `store` provided comes from a different
-    /// [`Engine`] than the [`InstancePre`] originally came from.
-    pub fn instantiate(&self, mut store: impl AsContextMut<Data = T>) -> Result<Instance> {
-        let mut store = store.as_context_mut();
-        let imports = pre_instantiate_raw(
-            &mut store.0,
-            &self.module,
-            &self.items,
-            self.host_funcs,
-            &self.func_refs,
-        )?;
-
-        // This unsafety should be handled by the type-checking performed by the
-        // constructor of `InstancePre` to assert that all the imports we're passing
-        // in match the module we're instantiating.
-        unsafe { Instance::new_started(&mut store, &self.module, imports.as_ref()) }
-    }
-
-    /// Creates a new instance, running the start function asynchronously
-    /// instead of inline.
-    ///
-    /// For more information about asynchronous instantiation see the
-    /// documentation on [`Instance::new_async`].
-    ///
-    /// # Panics
-    ///
-    /// Panics if any import closed over by this [`InstancePre`] isn't owned by
-    /// `store`, or if `store` does not have async support enabled.
-    #[cfg(feature = "async")]
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "async")))]
-    pub async fn instantiate_async(
-        &self,
-        mut store: impl AsContextMut<Data = T>,
-    ) -> Result<Instance>
-    where
-        T: Send,
-    {
-        let mut store = store.as_context_mut();
-        let imports = pre_instantiate_raw(
-            &mut store.0,
-            &self.module,
-            &self.items,
-            self.host_funcs,
-            &self.func_refs,
-        )?;
-
-        // This unsafety should be handled by the type-checking performed by the
-        // constructor of `InstancePre` to assert that all the imports we're passing
-        // in match the module we're instantiating.
-        unsafe { Instance::new_started_async(&mut store, &self.module, imports.as_ref()).await }
-    }
-}
-
-/// Helper function shared between
-/// `InstancePre::{instantiate,instantiate_async}`
-///
-/// This is an out-of-line function to avoid the generic on `InstancePre` and
-/// get this compiled into the `wasmtime` crate to avoid having it monomorphized
-/// elsewhere.
-fn pre_instantiate_raw(
-    store: &mut StoreOpaque,
-    module: &Module,
-    items: &Arc<[Definition]>,
-    host_funcs: usize,
-    func_refs: &Arc<[VMFuncRef]>,
-) -> Result<OwnedImports> {
-    if host_funcs > 0 {
-        // Any linker-defined function of the `Definition::HostFunc` variant
-        // will insert a function into the store automatically as part of
-        // instantiation, so reserve space here to make insertion more efficient
-        // as it won't have to realloc during the instantiation.
-        store.store_data_mut().reserve_funcs(host_funcs);
-
-        // The usage of `to_extern_store_rooted` requires that the items are
-        // rooted via another means, which happens here by cloning the list of
-        // items into the store once. This avoids cloning each individual item
-        // below.
-        store.push_rooted_funcs(items.clone());
-        store.push_instance_pre_func_refs(func_refs.clone());
-    }
-
-    let mut func_refs = func_refs.iter().map(|f| NonNull::from(f));
-    let mut imports = OwnedImports::new(module);
-    for import in items.iter() {
-        if !import.comes_from_same_store(store) {
-            bail!("cross-`Store` instantiation is not currently supported");
-        }
-        // This unsafety should be encapsulated in the constructor of
-        // `InstancePre` where the `T` of the original item should match the
-        // `T` of the store. Additionally the rooting necessary has happened
-        // above.
-        let item = match import {
-            Definition::Extern(e, _) => e.clone(),
-            Definition::HostFunc(func) => unsafe {
-                func.to_func_store_rooted(
-                    store,
-                    if func.func_ref().wasm_call.is_none() {
-                        Some(func_refs.next().unwrap())
-                    } else {
-                        None
-                    },
-                )
-                .into()
-            },
-        };
-        imports.push(&item, store, module);
-    }
-
-    Ok(imports)
-}
-
-fn typecheck<I>(
-    module: &Module,
-    imports: &[I],
-    check: impl Fn(&matching::MatchCx<'_>, &EntityType, &I) -> Result<()>,
-) -> Result<()> {
-    let env_module = module.compiled_module().module();
-    let expected = env_module.imports().count();
-    if expected != imports.len() {
-        bail!("expected {} imports, found {}", expected, imports.len());
-    }
-    let cx = matching::MatchCx {
-        signatures: module.signatures(),
-        types: module.types(),
-        engine: module.engine(),
-    };
-    for ((name, field, expected_ty), actual) in env_module.imports().zip(imports) {
-        check(&cx, &expected_ty, actual)
-            .with_context(|| format!("incompatible import type for `{name}::{field}`"))?;
-    }
-    Ok(())
-}
diff --git a/crates/wasmtime/src/lib.rs b/crates/wasmtime/src/lib.rs
index 1abfd28c0e04..9a8139fb82f4 100644
--- a/crates/wasmtime/src/lib.rs
+++ b/crates/wasmtime/src/lib.rs
@@ -1,37 +1,52 @@
-//! Wasmtime's embedding API
-//!
-//! Wasmtime is a WebAssembly engine for JIT-complied or ahead-of-time compiled
-//! WebAssembly modules. More information about the Wasmtime project as a whole
-//! can be found [in the documentation book](https://docs.wasmtime.dev) whereas
-//! this documentation mostly focuses on the API reference of the `wasmtime`
-//! crate itself.
-//!
-//! This crate contains an API used to interact with WebAssembly modules. For
-//! example you can compile modules, instantiate them, call them, etc. As an
-//! embedder of WebAssembly you can also provide WebAssembly modules
-//! functionality from the host by creating host-defined functions, memories,
-//! globals, etc, which can do things that WebAssembly cannot (such as print to
-//! the screen).
-//!
-//! The `wasmtime` crate has similar concepts to the
-//! the [JS WebAssembly
-//! API](https://developer.mozilla.org/en-US/docs/WebAssembly) as well as the
-//! [proposed C API](https://github.com/webassembly/wasm-c-api), but the Rust
-//! API is designed for efficiency, ergonomics, and expressivity in Rust. As
-//! with all other Rust code you're guaranteed that programs will be safe (not
-//! have undefined behavior or segfault) so long as you don't use `unsafe` in
-//! your own program. With `wasmtime` you can easily and conveniently embed a
-//! WebAssembly runtime with confidence that the WebAssembly is safely
-//! sandboxed.
-//!
-//! An example of using Wasmtime looks like:
+//! # Wasmtime's embedding API
+//!
+//! Wasmtime is a WebAssembly engine for JIT-compiled or ahead-of-time compiled
+//! WebAssembly modules and components. More information about the Wasmtime
+//! project as a whole can be found [in the documentation
+//! book](https://docs.wasmtime.dev) whereas this documentation mostly focuses
+//! on the API reference of the `wasmtime` crate itself.
+//!
+//! This crate contains an API used to interact with [WebAssembly modules] or
+//! [WebAssembly components]. For example you can compile WebAssembly, create
+//! instances, call functions, etc. As an embedder of WebAssembly you can also
+//! provide guests functionality from the host by creating host-defined
+//! functions, memories, globals, etc, which can do things that WebAssembly
+//! cannot (such as print to the screen).
+//!
+//! [WebAssembly modules]: https://webassembly.github.io/spec
+//! [WebAssembly components]: https://component-model.bytecodealliance.org
+//!
+//! The `wasmtime` crate is designed to be safe, efficient, and ergonomic.
+//! This enables executing WebAssembly without the embedder needing to use
+//! `unsafe` code, meaning that you're guaranteed there is no undefined behavior
+//! or segfaults in either the WebAssembly guest or the host itself.
+//!
+//! The `wasmtime` crate can roughly be thought of as being split into two
+//! halves:
+//!
+//! * One half of the crate is similar to the [JS WebAssembly
+//!   API](https://developer.mozilla.org/en-US/docs/WebAssembly) as well as the
+//!   [proposed C API](https://github.com/webassembly/wasm-c-api) and is
+//!   intended for working with [WebAssembly modules]. This API resides in the
+//!   root of the `wasmtime` crate's namespace, for example
+//!   [`wasmtime::Module`](`Module`).
+//!
+//! * The second half of the crate is for use with the [WebAssembly Component
+//!   Model]. The implementation of the component model is present in
+//!   [`wasmtime::component`](`component`) and roughly mirrors the structure for
+//!   core WebAssembly, for example [`component::Func`] mirrors [`Func`].
+//!
+//! [WebAssembly Component Model]: https://component-model.bytecodealliance.org
+//!
+//! An example of using Wasmtime to run a core WebAssembly module looks like:
 //!
 //! ```
 //! use wasmtime::*;
 //!
 //! fn main() -> wasmtime::Result<()> {
-//!     // Modules can be compiled through either the text or binary format
 //!     let engine = Engine::default();
+//!
+//!     // Modules can be compiled through either the text or binary format
 //!     let wat = r#"
 //!         (module
 //!             (import "host" "host_func" (func $host_hello (param i32)))
@@ -43,19 +58,23 @@
 //!     "#;
 //!     let module = Module::new(&engine, wat)?;
 //!
+//!     // Host functionality can be arbitrary Rust functions and is provided
+//!     // to guests through a `Linker`.
+//!     let mut linker = Linker::new(&engine);
+//!     linker.func_wrap("host", "host_func", |caller: Caller<'_, u32>, param: i32| {
+//!         println!("Got {} from WebAssembly", param);
+//!         println!("my host state is: {}", caller.data());
+//!     })?;
+//!
 //!     // All wasm objects operate within the context of a "store". Each
 //!     // `Store` has a type parameter to store host-specific data, which in
 //!     // this case we're using `4` for.
-//!     let mut store = Store::new(&engine, 4);
-//!     let host_func = Func::wrap(&mut store, |caller: Caller<'_, u32>, param: i32| {
-//!         println!("Got {} from WebAssembly", param);
-//!         println!("my host state is: {}", caller.data());
-//!     });
+//!     let mut store: Store<u32> = Store::new(&engine, 4);
 //!
 //!     // Instantiation of a module requires specifying its imports and then
 //!     // afterwards we can fetch exports by name, as well as asserting the
 //!     // type signature of the function with `get_typed_func`.
-//!     let instance = Instance::new(&mut store, &module, &[host_func.into()])?;
+//!     let instance = linker.instantiate(&mut store, &module)?;
 //!     let hello = instance.get_typed_func::<(), ()>(&mut store, "hello")?;
 //!
 //!     // And finally we can call the wasm!
@@ -70,19 +89,13 @@
 //! There are a number of core types and concepts that are important to be aware
 //! of when using the `wasmtime` crate:
 //!
-//! * [`Engine`] - a global compilation environment for WebAssembly. An
-//!   [`Engine`] is an object that can be shared concurrently across threads and
-//!   is created with a [`Config`] to tweak various settings. Compilation of any
-//!   WebAssembly requires first configuring and creating an [`Engine`].
-//!
-//! * [`Module`] - a compiled WebAssembly module. This structure represents
-//!   in-memory JIT code which is ready to execute after being instantiated.
-//!   It's often important to cache instances of a [`Module`] because creation
-//!   (compilation) can be expensive. Note that [`Module`] is safe to share
-//!   across threads, and can be created from a WebAssembly binary and an
-//!   [`Engine`] with [`Module::new`]. Caching can either happen with
-//!   [`Engine::precompile_module`] or [`Module::serialize`], feeding those
-//!   bytes back into [`Module::deserialize`].
+//! * [`Engine`] - a global compilation and runtime environment for WebAssembly.
+//!   An [`Engine`] is an object that can be shared concurrently across threads
+//!   and is created with a [`Config`] with many knobs for configuring
+//!   behavior. Compiling or executing any WebAssembly requires first
+//!   configuring and creating an [`Engine`]. All [`Module`]s and
+//!   [`Component`](component::Component)s belong to an [`Engine`], and
+//!   typically there's one [`Engine`] per process.
 //!
 //! * [`Store`] - container for all information related to WebAssembly objects
 //!   such as functions, instances, memories, etc. A [`Store<T>`][`Store`]
@@ -92,19 +105,48 @@
 //!   required for all WebAssembly operations, such as calling a wasm function.
 //!   The [`Store`] is passed in as a "context" to methods like [`Func::call`].
 //!   Dropping a [`Store`] will deallocate all memory associated with
-//!   WebAssembly objects within the [`Store`].
-//!
-//! * [`Instance`] - an instantiated WebAssembly module. An instance is where
-//!   you can actually acquire a [`Func`] from, for example, to call.
-//!
-//! * [`Func`] - a WebAssembly (or host) function. This can be acquired as the
-//!   export of an [`Instance`] to call WebAssembly functions, or it can be
-//!   created via functions like [`Func::wrap`] to wrap host-defined
-//!   functionality and give it to WebAssembly.
-//!
-//! * [`Table`], [`Global`], [`Memory`] - other WebAssembly objects which can
-//!   either be defined on the host or in wasm itself (via instances). These all
-//!   have various ways of being interacted with like [`Func`].
+//!   WebAssembly objects within the [`Store`]. A [`Store`] is cheap to create
+//!   and destroy and does not GC objects such as unused instances internally,
+//!   so it's intended to be short-lived (or no longer than the instances it
+//!   contains).
+//!
+//! * [`Linker`] (or [`component::Linker`]) - host functions are defined within
+//!   a linker to provide them a string-based name which can be looked up when
+//!   instantiating a WebAssembly module or component. Linkers are traditionally
+//!   populated at startup and then reused for all future instantiations of all
+//!   instances, assuming the set of host functions does not change over time.
+//!   Host functions are `Fn(..) + Send + Sync` and typically do not close over
+//!   mutable state. Instead it's recommended to store mutable state in the `T`
+//!   of [`Store<T>`] which is accessed through [`Caller<'_,
+//!   T>`](crate::Caller) provided to host functions.
+//!
+//! * [`Module`] (or [`Component`](component::Component)) - a compiled
+//!   WebAssembly module or component. These structures contain compiled
+//!   executable code from a WebAssembly binary which is ready to execute after
+//!   being instantiated. These are expensive to create as they require
+//!   compilation of the input WebAssembly. Modules and components are safe to
+//!   share across threads, however. Modules and components can additionally be
+//!   [serialized into a list of bytes](crate::Module::serialize) to later be
+//!   [deserialized](crate::Module::deserialize) quickly. This enables JIT-style
+//!   compilation through constructors such as [`Module::new`] and AOT-style
+//!   compilation by having the compilation process use [`Module::serialize`]
+//!   and the execution process use [`Module::deserialize`].
+//!
+//! * [`Instance`] (or [`component::Instance`]) - an instantiated WebAssembly
+//!   module or component. An instance is where you can actually acquire a
+//!   [`Func`] (or [`component::Func`]) from, for example, to call.
+//!
+//! * [`Func`] (or [`component::Func`]) - a WebAssembly function. This can be
+//!   acquired as the export of an [`Instance`] to call WebAssembly functions,
+//!   or it can be created via functions like [`Func::wrap`] to wrap
+//!   host-defined functionality and give it to WebAssembly. Functions also have
+//!   typed views as [`TypedFunc`] or [`component::TypedFunc`] for a more
+//!   efficient calling convention.
+//!
+//! * [`Table`], [`Global`], [`Memory`], [`component::Resource`] - other
+//!   WebAssembly objects which can either be defined on the host or in wasm
+//!   itself (via instances). These all have various ways of being interacted
+//!   with like [`Func`].
 //!
 //! All "store-connected" types such as [`Func`], [`Memory`], etc, require the
 //! store to be passed in as a context to each method. Methods in wasmtime
@@ -124,90 +166,6 @@
 //! [`Func`] point within the [`Store`] and require the [`Store`] to be provided
 //! to actually access the internals of the WebAssembly function, for instance.
 //!
-//! ## Linking
-//!
-//! WebAssembly modules almost always require functionality from the host to
-//! perform I/O-like tasks. They might refer to quite a few pieces of host
-//! functionality, WASI, or maybe even a number of other wasm modules. To assist
-//! with managing this a [`Linker`] type is provided to instantiate modules.
-//!
-//! A [`Linker`] performs name-based resolution of the imports of a WebAssembly
-//! module so the [`Linker::instantiate`] method does not take an `imports`
-//! argument like [`Instance::new`] does. Methods like [`Linker::define`] or
-//! [`Linker::func_wrap`] can be used to define names within a [`Linker`] to
-//! later be used for instantiation.
-//!
-//! For example we can reimplement the above example with a `Linker`:
-//!
-//! ```
-//! use wasmtime::*;
-//!
-//! fn main() -> wasmtime::Result<()> {
-//!     let engine = Engine::default();
-//!     let wat = r#"
-//!         (module
-//!             (import "host" "host_func" (func $host_hello (param i32)))
-//!
-//!             (func (export "hello")
-//!                 i32.const 3
-//!                 call $host_hello)
-//!         )
-//!     "#;
-//!     let module = Module::new(&engine, wat)?;
-//!
-//!     // Create a `Linker` and define our host function in it:
-//!     let mut linker = Linker::new(&engine);
-//!     linker.func_wrap("host", "host_func", |caller: Caller<'_, u32>, param: i32| {
-//!         println!("Got {} from WebAssembly", param);
-//!         println!("my host state is: {}", caller.data());
-//!     })?;
-//!
-//!     // Use the `linker` to instantiate the module, which will automatically
-//!     // resolve the imports of the module using name-based resolution.
-//!     let mut store = Store::new(&engine, 0);
-//!     let instance = linker.instantiate(&mut store, &module)?;
-//!     let hello = instance.get_typed_func::<(), ()>(&mut store, "hello")?;
-//!     hello.call(&mut store, ())?;
-//!
-//!     Ok(())
-//! }
-//! ```
-//!
-//! The [`Linker`] type also transparently handles Commands and Reactors
-//! as defined by WASI.
-//!
-//! ## Example Architecture
-//!
-//! To better understand how Wasmtime types interact with each other let's walk
-//! through, at a high-level, an example of how you might use WebAssembly. In
-//! our use case let's say we have a web server where we'd like to run some
-//! custom WebAssembly on each request. To ensure requests are entirely isolated
-//! from each other, though, we'll be creating a new [`Store`] for each
-//! request.
-//!
-//! When the server starts, we'll start off by creating an [`Engine`] (and maybe
-//! tweaking [`Config`] settings if necessary). This [`Engine`] will be the only
-//! engine for the lifetime of the server itself. Next, we can compile our
-//! WebAssembly. You'd create a [`Module`] through the [`Module::new`] API.
-//! This will generate JIT code and perform expensive compilation tasks
-//! up-front. Finally the last step of initialization would be to create a
-//! [`Linker`] which will later be used to instantiate modules, adding
-//! functionality like WASI to the linker too.
-//!
-//! After that setup, the server starts up as usual and is ready to receive
-//! requests. Upon receiving a request you'd then create a [`Store`] with
-//! [`Store::new`] referring to the original [`Engine`]. Using your [`Module`]
-//! and [`Linker`] from before you'd then call [`Linker::instantiate`] to
-//! instantiate our module for the request. Both of these operations are
-//! designed to be as cheap as possible.
-//!
-//! With an [`Instance`] you can then invoke various exports and interact with
-//! the WebAssembly module. Once the request is finished, the [`Store`]
-//! is dropped and everything will be deallocated. Note that if the same
-//! [`Store`] were used for every request then that would have all requests
-//! sharing resources and nothing would ever get deallocated, causing memory
-//! usage to baloon and would achive less isolation between requests.
-//!
 //! ## WASI
 //!
 //! The `wasmtime` crate does not natively provide support for WASI, but you can
@@ -218,32 +176,22 @@
 //!
 //! [`wasmtime-wasi`]: https://crates.io/crates/wasmtime-wasi
 //!
-//! ## Cross-store usage of items
-//!
-//! In `wasmtime` wasm items such as [`Global`] and [`Memory`] "belong" to a
-//! [`Store`]. The store they belong to is the one they were created with
-//! (passed in as a parameter) or instantiated with. This store is the only
-//! store that can be used to interact with wasm items after they're created.
-//!
-//! The `wasmtime` crate will panic if the [`Store`] argument passed in to these
-//! operations is incorrect. In other words it's considered a programmer error
-//! rather than a recoverable error for the wrong [`Store`] to be used when
-//! calling APIs.
-//!
 //! ## Crate Features
 //!
 //! The `wasmtime` crate comes with a number of compile-time features that can
 //! be used to customize what features it supports. Some of these features are
 //! just internal details, but some affect the public API of the `wasmtime`
-//! crate. Be sure to check the API you're using to see if any crate features
-//! are enabled.
+//! crate. Wasmtime APIs gated behind a Cargo feature should be indicated as
+//! such in the documentation.
+//!
+//! * `runtime` - Enabled by default, this feature enables executing
+//!   WebAssembly modules and components. If a compiler is not available (such
+//!   as `cranelift`) then [`Module::deserialize`] must be used, for example, to
+//!   provide an ahead-of-time compiled artifact to execute WebAssembly.
 //!
 //! * `cranelift` - Enabled by default, this features enables using Cranelift at
 //!   runtime to compile a WebAssembly module to native code. This feature is
-//!   required to process and compile new WebAssembly modules. If this feature
-//!   is disabled then the only way to create a [`Module`] is to use the
-//!   [`Module::deserialize`] function with a precompiled artifact (typically
-//!   compiled with the same version of Wasmtime, just somewhere else).
+//!   required to process and compile new WebAssembly modules and components.
 //!
 //! * `cache` - Enabled by default, this feature adds support for wasmtime to
 //!   perform internal caching of modules in a global location. This must still
@@ -251,242 +199,208 @@
 //!   [`Config::cache_config_load_default`].
 //!
 //! * `wat` - Enabled by default, this feature adds support for accepting the
-//!   text format of WebAssembly in [`Module::new`]. The text format will be
+//!   text format of WebAssembly in [`Module::new`] and
+//!   [`Component::new`](component::Component::new). The text format will be
 //!   automatically recognized and translated to binary when compiling a
 //!   module.
 //!
 //! * `parallel-compilation` - Enabled by default, this feature enables support
-//!   for compiling functions of a module in parallel with `rayon`.
+//!   for compiling functions in parallel with `rayon`.
 //!
 //! * `async` - Enabled by default, this feature enables APIs and runtime
 //!   support for defining asynchronous host functions and calling WebAssembly
-//!   asynchronously.
-//!
-//! * `jitdump` - Enabled by default, this feature compiles in support for the
-//!   jitdump runtime profiling format. The profiler can be selected with
-//!   [`Config::profiler`].
+//!   asynchronously. For more information see [`Config::async_support`].
 //!
-//! * `vtune` - Enabled by default, this feature compiles in support for VTune
-//!   profiling of JIT code.
+//! * `profiling` - Enabled by default, this feature compiles in support for
+//!   profiling guest code via a number of possible strategies. See
+//!   [`Config::profiler`] for more information.
 //!
 //! * `all-arch` - Not enabled by default. This feature compiles in support for
 //!   all architectures for both the JIT compiler and the `wasmtime compile` CLI
-//!   command.
+//!   command. This can be combined with [`Config::target`] to precompile
+//!   modules for a different platform than the host.
 //!
 //! * `pooling-allocator` - Enabled by default, this feature adds support for
-//!   the pooling allocation strategy enabled via
-//!   [`Config::allocation_strategy`]. The pooling allocator can enable more
-//!   efficient reuse of resources for high-concurrency and
-//!   high-instantiation-count scenarios.
-//!
-//! * `memory-init-cow` - Enabled by default, this feature builds in support
-//!   for, on supported platforms, initializing wasm linear memories with
-//!   copy-on-write heap mappings. This makes instantiation much faster by
-//!   `mmap`-ing the initial memory image into place instead of copying memory
-//!   into place, allowing sharing pages that end up only getting read. Note
-//!   that this is simply compile-time support and this must also be enabled at
-//!   run-time via [`Config::memory_init_cow`] (which is also enabled by
-//!   default).
-//!
-//! ## Examples
-//!
-//! In addition to the examples below be sure to check out the [online embedding
-//! documentation][rustdocs] as well as the [online list of examples][examples]
-//!
-//! [rustdocs]: https://bytecodealliance.github.io/wasmtime/lang-rust.html
-//! [examples]: https://bytecodealliance.github.io/wasmtime/examples-rust-embed.html
-//!
-//! An example of using WASI looks like:
-//!
-//! ```no_run
-//! # use wasmtime::*;
-//! use wasmtime_wasi::sync::WasiCtxBuilder;
-//!
-//! # fn main() -> wasmtime::Result<()> {
-//! // Compile our module and create a `Linker` which has WASI functions defined
-//! // within it.
-//! let engine = Engine::default();
-//! let module = Module::from_file(&engine, "foo.wasm")?;
-//! let mut linker = Linker::new(&engine);
-//! wasmtime_wasi::add_to_linker(&mut linker, |cx| cx)?;
-//!
-//! // Configure and create a `WasiCtx`, which WASI functions need access to
-//! // through the host state of the store (which in this case is the host state
-//! // of the store)
-//! let wasi_ctx = WasiCtxBuilder::new().inherit_stdio().build();
-//! let mut store = Store::new(&engine, wasi_ctx);
-//!
-//! // Instantiate our module with the imports we've created, and run it.
-//! let instance = linker.instantiate(&mut store, &module)?;
-//! // ...
-//!
-//! # Ok(())
-//! # }
-//! ```
-//!
-//! An example of reading a string from a wasm module:
-//!
-//! ```
-//! use std::str;
-//!
-//! # use wasmtime::*;
-//! # fn main() -> wasmtime::Result<()> {
-//! let mut store = Store::default();
-//! let log_str = Func::wrap(&mut store, |mut caller: Caller<'_, ()>, ptr: i32, len: i32| {
-//!     // Use our `caller` context to learn about the memory export of the
-//!     // module which called this host function.
-//!     let mem = match caller.get_export("memory") {
-//!         Some(Extern::Memory(mem)) => mem,
-//!         _ => anyhow::bail!("failed to find host memory"),
-//!     };
-//!
-//!     // Use the `ptr` and `len` values to get a subslice of the wasm-memory
-//!     // which we'll attempt to interpret as utf-8.
-//!     let data = mem.data(&caller)
-//!         .get(ptr as u32 as usize..)
-//!         .and_then(|arr| arr.get(..len as u32 as usize));
-//!     let string = match data {
-//!         Some(data) => match str::from_utf8(data) {
-//!             Ok(s) => s,
-//!             Err(_) => anyhow::bail!("invalid utf-8"),
-//!         },
-//!         None => anyhow::bail!("pointer/length out of bounds"),
-//!     };
-//!     assert_eq!(string, "Hello, world!");
-//!     println!("{}", string);
-//!     Ok(())
-//! });
-//! let module = Module::new(
-//!     store.engine(),
-//!     r#"
-//!         (module
-//!             (import "" "" (func $log_str (param i32 i32)))
-//!             (func (export "foo")
-//!                 i32.const 4   ;; ptr
-//!                 i32.const 13  ;; len
-//!                 call $log_str)
-//!             (memory (export "memory") 1)
-//!             (data (i32.const 4) "Hello, world!"))
-//!     "#,
-//! )?;
-//! let instance = Instance::new(&mut store, &module, &[log_str.into()])?;
-//! let foo = instance.get_typed_func::<(), ()>(&mut store, "foo")?;
-//! foo.call(&mut store, ())?;
-//! # Ok(())
-//! # }
-//! ```
+//!   [`PoolingAllocationConfig`] to pass to [`Config::allocation_strategy`].
+//!   The pooling allocator can enable efficient reuse of resources for
+//!   high-concurrency and high-instantiation-count scenarios.
+//!
+//! * `demangle` - Enabled by default, this will affect how backtraces are
+//!   printed and whether symbol names from WebAssembly are attempted to be
+//!   demangled. Rust and C++ demanglings are currently supported.
+//!
+//! * `coredump` - Enabled by default, this will provide support for generating
+//!   a core dump when a trap happens. This can be configured via
+//!   [`Config::coredump_on_trap`].
+//!
+//! * `addr2line` - Enabled by default, this feature configures whether traps
+//!   will attempt to parse DWARF debug information and convert WebAssembly
+//!   addresses to source filenames and line numbers.
+//!
+//! * `debug-builtins` - Enabled by default, this feature includes some built-in
+//!   debugging utilities and symbols for native debuggers such as GDB and LLDB
+//!   to attach to the process Wasmtime is used within. The intrinsics provided
+//!   will enable debugging guest code compiled to WebAssembly. This must also
+//!   be enabled via [`Config::debug_info`] as well for guests.
+//!
+//! * `component-model` - Enabled by default, this enables support for the
+//!   [`wasmtime::component`](component) API for working with components.
+//!
+//! * `gc` - Enabled by default, this enables support for a number of
+//!   WebAssembly proposals such as `reference-types`, `function-references`,
+//!   and `gc`. Note that the implementation of the `gc` proposal itself is not
+//!   yet complete at this time.
+//!
+//! * `threads` - Enabled by default, this enables compile-time support for the
+//!   WebAssembly `threads` proposal, notably shared memories.
+//!
+//! * `call-hook` - Disabled by default, this enables support for the
+//!   [`Store::call_hook`] API. This incurs a small overhead on all
+//!   entries/exits from WebAssembly and may want to be disabled by some
+//!   embedders.
+//!
+//! * `memory-protection-keys` - Disabled by default, this enables support for
+//!   the [`PoolingAllocationConfig::memory_protection_keys`] API. This feature
+//!   currently only works on x64 Linux and can enable compacting the virtual
+//!   memory allocation for linear memories in the pooling allocator. This comes
+//!   with the same overhead as the `call-hook` feature where entries/exits into
+//!   WebAssembly will have more overhead than before.
+//!
+//! More crate features can be found in the [manifest] of Wasmtime itself for
+//! seeing what can be enabled and disabled.
+//!
+//! [manifest]: https://github.com/bytecodealliance/wasmtime/blob/main/crates/wasmtime/Cargo.toml
 
 #![deny(missing_docs)]
 #![doc(test(attr(deny(warnings))))]
 #![doc(test(attr(allow(dead_code, unused_variables, unused_mut))))]
-#![cfg_attr(nightlydoc, feature(doc_cfg))]
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
 #![cfg_attr(not(feature = "default"), allow(dead_code, unused_imports))]
 // Allow broken links when the default features is disabled because most of our
 // documentation is written for the "one build" of the `main` branch which has
 // most features enabled. This will present warnings in stripped-down doc builds
 // and will prevent the doc build from failing.
-#![cfg_attr(feature = "default", deny(rustdoc::broken_intra_doc_links))]
+#![cfg_attr(feature = "default", warn(rustdoc::broken_intra_doc_links))]
+#![no_std]
 
+#[cfg(any(feature = "std", unix, windows))]
 #[macro_use]
-mod func;
+extern crate std;
+extern crate alloc;
+
+pub(crate) mod prelude {
+    pub use crate::{Error, Result};
+    pub use anyhow::{anyhow, bail, ensure, format_err, Context};
+    pub use wasmtime_environ::prelude::*;
+}
+
+/// A helper macro to safely map `MaybeUninit<T>` to `MaybeUninit<U>` where `U`
+/// is a field projection within `T`.
+///
+/// This is intended to be invoked as:
+///
+/// ```ignore
+/// struct MyType {
+///     field: u32,
+/// }
+///
+/// let initial: &mut MaybeUninit<MyType> = ...;
+/// let field: &mut MaybeUninit<u32> = map_maybe_uninit!(initial.field);
+/// ```
+///
+/// Note that array accesses are also supported:
+///
+/// ```ignore
+///
+/// let initial: &mut MaybeUninit<[u32; 2]> = ...;
+/// let element: &mut MaybeUninit<u32> = map_maybe_uninit!(initial[1]);
+/// ```
+#[doc(hidden)]
+#[macro_export]
+macro_rules! map_maybe_uninit {
+    ($maybe_uninit:ident $($field:tt)*) => ({
+        #[allow(unused_unsafe)]
+        {
+            unsafe {
+                use $crate::MaybeUninitExt;
+
+                let m: &mut core::mem::MaybeUninit<_> = $maybe_uninit;
+                // Note the usage of `addr_of_mut!` here which is an attempt to "stay
+                // safe" here where we never accidentally create `&mut T` where `T` is
+                // actually uninitialized, hopefully appeasing the Rust unsafe
+                // guidelines gods.
+                m.map(|p| core::ptr::addr_of_mut!((*p)$($field)*))
+            }
+        }
+    })
+}
+
+#[doc(hidden)]
+pub trait MaybeUninitExt<T> {
+    /// Maps `MaybeUninit<T>` to `MaybeUninit<U>` using the closure provided.
+    ///
+    /// Note that this is `unsafe` as there is no guarantee that `U` comes from
+    /// `T`.
+    unsafe fn map<U>(&mut self, f: impl FnOnce(*mut T) -> *mut U)
+        -> &mut core::mem::MaybeUninit<U>;
+}
+
+impl<T> MaybeUninitExt<T> for core::mem::MaybeUninit<T> {
+    unsafe fn map<U>(
+        &mut self,
+        f: impl FnOnce(*mut T) -> *mut U,
+    ) -> &mut core::mem::MaybeUninit<U> {
+        let new_ptr = f(self.as_mut_ptr());
+        core::mem::transmute::<*mut U, &mut core::mem::MaybeUninit<U>>(new_ptr)
+    }
+}
+
+#[cfg(feature = "runtime")]
+mod runtime;
+#[cfg(feature = "runtime")]
+pub use runtime::*;
 
 #[cfg(any(feature = "cranelift", feature = "winch"))]
-mod compiler;
+mod compile;
+#[cfg(any(feature = "cranelift", feature = "winch"))]
+pub use compile::{CodeBuilder, CodeHint};
 
-mod code;
 mod config;
-mod coredump;
 mod engine;
-mod externals;
-mod instance;
-mod limits;
-mod linker;
-mod memory;
-mod module;
-mod profiling;
-mod r#ref;
-mod resources;
-mod signatures;
-mod store;
-mod trampoline;
-mod trap;
-mod types;
-mod v128;
-mod values;
+mod profiling_agent;
 
 pub use crate::config::*;
-pub use crate::coredump::*;
 pub use crate::engine::*;
-pub use crate::externals::*;
-pub use crate::func::*;
-pub use crate::instance::{Instance, InstancePre};
-pub use crate::limits::*;
-pub use crate::linker::*;
-pub use crate::memory::*;
-pub use crate::module::Module;
-pub use crate::profiling::GuestProfiler;
-pub use crate::r#ref::ExternRef;
-pub use crate::resources::*;
-#[cfg(feature = "async")]
-pub use crate::store::CallHookHandler;
-pub use crate::store::{
-    AsContext, AsContextMut, CallHook, Store, StoreContext, StoreContextMut, UpdateDeadline,
-};
-pub use crate::trap::*;
-pub use crate::types::*;
-pub use crate::v128::V128;
-pub use crate::values::*;
+
+#[cfg(feature = "std")]
+mod sync_std;
+#[cfg(feature = "std")]
+use sync_std as sync;
+
+#[cfg_attr(feature = "std", allow(dead_code))]
+mod sync_nostd;
+#[cfg(not(feature = "std"))]
+use sync_nostd as sync;
 
 /// A convenience wrapper for `Result<T, anyhow::Error>`.
 ///
 /// This type can be used to interact with `wasmtimes`'s extensive use
 /// of `anyhow::Error` while still not directly depending on `anyhow`.
+///
 /// This type alias is identical to `anyhow::Result`.
+#[doc(no_inline)]
 pub use anyhow::{Error, Result};
 
-#[cfg(feature = "component-model")]
-pub mod component;
+fn _assert_send_and_sync<T: Send + Sync>() {}
 
-cfg_if::cfg_if! {
-    if #[cfg(all(target_os = "macos", not(feature = "posix-signals-on-macos")))] {
-        // no extensions for macOS at this time
-    } else if #[cfg(unix)] {
-        pub mod unix;
-    } else if #[cfg(windows)] {
-        pub mod windows;
-    } else {
-        // ... unknown os!
-    }
+fn _assertions_lib() {
+    _assert_send_and_sync::<Engine>();
+    _assert_send_and_sync::<Config>();
 }
 
-fn _assert_send_sync() {
-    fn _assert<T: Send + Sync>() {}
-    fn _assert_send<T: Send>(_t: T) {}
-    _assert::<Engine>();
-    _assert::<Config>();
-    _assert::<(Func, TypedFunc<(), ()>, Global, Table, Memory)>();
-    _assert::<Instance>();
-    _assert::<Module>();
-    _assert::<Store<()>>();
-    _assert::<StoreContext<'_, ()>>();
-    _assert::<StoreContextMut<'_, ()>>();
-    _assert::<Caller<'_, ()>>();
-    _assert::<Linker<()>>();
-    _assert::<Linker<*mut u8>>();
-    _assert::<ExternRef>();
-    _assert::<InstancePre<()>>();
-    _assert::<InstancePre<*mut u8>>();
-
-    #[cfg(feature = "async")]
-    fn _call_async(s: &mut Store<()>, f: Func) {
-        _assert_send(f.call_async(&mut *s, &[], &mut []))
-    }
-    #[cfg(feature = "async")]
-    fn _typed_call_async(s: &mut Store<()>, f: TypedFunc<(), ()>) {
-        _assert_send(f.call_async(&mut *s, ()))
-    }
-    #[cfg(feature = "async")]
-    fn _instantiate_async(s: &mut Store<()>, m: &Module) {
-        _assert_send(Instance::new_async(s, m, &[]))
-    }
+#[cfg(feature = "runtime")]
+#[doc(hidden)]
+pub mod _internal {
+    // Exported just for the CLI.
+    pub use crate::runtime::vm::MmapVec;
 }
diff --git a/crates/wasmtime/src/linker.rs b/crates/wasmtime/src/linker.rs
deleted file mode 100644
index 10affb2d9f23..000000000000
--- a/crates/wasmtime/src/linker.rs
+++ /dev/null
@@ -1,1479 +0,0 @@
-use crate::func::HostFunc;
-use crate::instance::InstancePre;
-use crate::store::StoreOpaque;
-use crate::{
-    AsContext, AsContextMut, Caller, Engine, Extern, ExternType, Func, FuncType, ImportType,
-    Instance, IntoFunc, Module, StoreContextMut, Val, ValRaw, ValType,
-};
-use anyhow::{bail, Context, Result};
-use log::warn;
-use std::collections::hash_map::{Entry, HashMap};
-#[cfg(feature = "async")]
-use std::future::Future;
-use std::marker;
-#[cfg(feature = "async")]
-use std::pin::Pin;
-use std::sync::Arc;
-
-/// Structure used to link wasm modules/instances together.
-///
-/// This structure is used to assist in instantiating a [`Module`]. A [`Linker`]
-/// is a way of performing name resolution to make instantiating a module easier
-/// than specifying positional imports to [`Instance::new`]. [`Linker`] is a
-/// name-based resolver where names are dynamically defined and then used to
-/// instantiate a [`Module`].
-///
-/// An important method is [`Linker::instantiate`] which takes a module to
-/// instantiate into the provided store. This method will automatically select
-/// all the right imports for the [`Module`] to be instantiated, and will
-/// otherwise return an error if an import isn't satisfied.
-///
-/// ## Name Resolution
-///
-/// As mentioned previously, `Linker` is a form of name resolver. It will be
-/// using the string-based names of imports on a module to attempt to select a
-/// matching item to hook up to it. This name resolution has two-levels of
-/// namespaces, a module level and a name level. Each item is defined within a
-/// module and then has its own name. This basically follows the wasm standard
-/// for modularization.
-///
-/// Names in a `Linker` cannot be defined twice, but allowing duplicates by
-/// shadowing the previous definition can be controlled with the
-/// [`Linker::allow_shadowing`] method.
-///
-/// ## Commands and Reactors
-///
-/// The [`Linker`] type provides conveniences for working with WASI Commands and
-/// Reactors through the [`Linker::module`] method. This will automatically
-/// handle instantiation and calling `_start` and such as appropriate
-/// depending on the inferred type of module.
-///
-/// ## Type parameter `T`
-///
-/// It's worth pointing out that the type parameter `T` on [`Linker<T>`] does
-/// not represent that `T` is stored within a [`Linker`]. Rather the `T` is used
-/// to ensure that linker-defined functions and stores instantiated into all use
-/// the same matching `T` as host state.
-///
-/// ## Multiple `Store`s
-///
-/// The [`Linker`] type is designed to be compatible, in some scenarios, with
-/// instantiation in multiple [`Store`]s. Specifically host-defined functions
-/// created in [`Linker`] with [`Linker::func_new`], [`Linker::func_wrap`], and
-/// their async versions are compatible to instantiate into any [`Store`]. This
-/// enables programs which want to instantiate lots of modules to create one
-/// [`Linker`] value at program start up and use that continuously for each
-/// [`Store`] created over the lifetime of the program.
-///
-/// Note that once [`Store`]-owned items, such as [`Global`], are defined witin
-/// a [`Linker`] then it is no longer compatible with any [`Store`]. At that
-/// point only the [`Store`] that owns the [`Global`] can be used to instantiate
-/// modules.
-///
-/// ## Multiple `Engine`s
-///
-/// The [`Linker`] type is not compatible with usage between multiple [`Engine`]
-/// values. An [`Engine`] is provided when a [`Linker`] is created and only
-/// stores and items which originate from that [`Engine`] can be used with this
-/// [`Linker`]. If more than one [`Engine`] is used with a [`Linker`] then that
-/// may cause a panic at runtime, similar to how if a [`Func`] is used with the
-/// wrong [`Store`] that can also panic at runtime.
-///
-/// [`Store`]: crate::Store
-/// [`Global`]: crate::Global
-pub struct Linker<T> {
-    engine: Engine,
-    string2idx: HashMap<Arc<str>, usize>,
-    strings: Vec<Arc<str>>,
-    map: HashMap<ImportKey, Definition>,
-    allow_shadowing: bool,
-    allow_unknown_exports: bool,
-    _marker: marker::PhantomData<fn() -> T>,
-}
-
-impl<T> Clone for Linker<T> {
-    fn clone(&self) -> Linker<T> {
-        Linker {
-            engine: self.engine.clone(),
-            string2idx: self.string2idx.clone(),
-            strings: self.strings.clone(),
-            map: self.map.clone(),
-            allow_shadowing: self.allow_shadowing,
-            allow_unknown_exports: self.allow_unknown_exports,
-            _marker: self._marker,
-        }
-    }
-}
-
-#[derive(Copy, Clone, Hash, PartialEq, Eq)]
-struct ImportKey {
-    name: usize,
-    module: usize,
-}
-
-#[derive(Clone)]
-pub(crate) enum Definition {
-    Extern(Extern, DefinitionType),
-    HostFunc(Arc<HostFunc>),
-}
-
-/// This is a sort of slimmed down `ExternType` which notably doesn't have a
-/// `FuncType`, which is an allocation, and additionally retains the current
-/// size of the table/memory.
-#[derive(Clone)]
-pub(crate) enum DefinitionType {
-    Func(wasmtime_runtime::VMSharedSignatureIndex),
-    Global(wasmtime_environ::Global),
-    // Note that tables and memories store not only the original type
-    // information but additionally the current size of the table/memory, as
-    // this is used during linking since the min size specified in the type may
-    // no longer be the current size of the table/memory.
-    Table(wasmtime_environ::Table, u32),
-    Memory(wasmtime_environ::Memory, u64),
-}
-
-macro_rules! generate_wrap_async_func {
-    ($num:tt $($args:ident)*) => (paste::paste!{
-        /// Asynchronous analog of [`Linker::func_wrap`].
-        ///
-        /// For more information also see
-        /// [`Func::wrapN_async`](crate::Func::wrap1_async).
-        #[allow(non_snake_case)]
-        #[cfg(feature = "async")]
-        #[cfg_attr(nightlydoc, doc(cfg(feature = "async")))]
-        pub fn [<func_wrap $num _async>]<$($args,)* R>(
-            &mut self,
-            module: &str,
-            name: &str,
-            func: impl for<'a> Fn(Caller<'a, T>, $($args),*) -> Box<dyn Future<Output = R> + Send + 'a> + Send + Sync + 'static,
-        ) -> Result<&mut Self>
-        where
-            $($args: crate::WasmTy,)*
-            R: crate::WasmRet,
-        {
-            assert!(
-                self.engine.config().async_support,
-                concat!(
-                    "cannot use `func_wrap",
-                    $num,
-                    "_async` without enabling async support on the config",
-                ),
-            );
-            self.func_wrap(module, name, move |mut caller: Caller<'_, T>, $($args: $args),*| {
-                let async_cx = caller.store.as_context_mut().0.async_cx().expect("Attempt to start async function on dying fiber");
-                let mut future = Pin::from(func(caller, $($args),*));
-                match unsafe { async_cx.block_on(future.as_mut()) } {
-                    Ok(ret) => ret.into_fallible(),
-                    Err(e) => R::fallible_from_error(e),
-                }
-            })
-        }
-    })
-}
-
-impl<T> Linker<T> {
-    /// Creates a new [`Linker`].
-    ///
-    /// The linker will define functions within the context of the `engine`
-    /// provided and can only instantiate modules for a [`Store`][crate::Store]
-    /// that is also defined within the same [`Engine`]. Usage of stores with
-    /// different [`Engine`]s may cause a panic when used with this [`Linker`].
-    pub fn new(engine: &Engine) -> Linker<T> {
-        Linker {
-            engine: engine.clone(),
-            map: HashMap::new(),
-            string2idx: HashMap::new(),
-            strings: Vec::new(),
-            allow_shadowing: false,
-            allow_unknown_exports: false,
-            _marker: marker::PhantomData,
-        }
-    }
-
-    /// Returns the [`Engine`] this is connected to.
-    pub fn engine(&self) -> &Engine {
-        &self.engine
-    }
-
-    /// Configures whether this [`Linker`] will shadow previous duplicate
-    /// definitions of the same signature.
-    ///
-    /// By default a [`Linker`] will disallow duplicate definitions of the same
-    /// signature. This method, however, can be used to instead allow duplicates
-    /// and have the latest definition take precedence when linking modules.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// # let engine = Engine::default();
-    /// let mut linker = Linker::<()>::new(&engine);
-    /// linker.func_wrap("", "", || {})?;
-    ///
-    /// // by default, duplicates are disallowed
-    /// assert!(linker.func_wrap("", "", || {}).is_err());
-    ///
-    /// // but shadowing can be configured to be allowed as well
-    /// linker.allow_shadowing(true);
-    /// linker.func_wrap("", "", || {})?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn allow_shadowing(&mut self, allow: bool) -> &mut Self {
-        self.allow_shadowing = allow;
-        self
-    }
-
-    /// Configures whether this [`Linker`] will allow unknown exports from
-    /// command modules.
-    ///
-    /// By default a [`Linker`] will error when unknown exports are encountered
-    /// in a command module while using [`Linker::module`].
-    ///
-    /// This method can be used to allow unknown exports from command modules.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// # let engine = Engine::default();
-    /// # let module = Module::new(&engine, "(module)")?;
-    /// # let mut store = Store::new(&engine, ());
-    /// let mut linker = Linker::new(&engine);
-    /// linker.allow_unknown_exports(true);
-    /// linker.module(&mut store, "mod", &module)?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn allow_unknown_exports(&mut self, allow: bool) -> &mut Self {
-        self.allow_unknown_exports = allow;
-        self
-    }
-
-    /// Implement any imports of the given [`Module`] with a function which traps.
-    ///
-    /// By default a [`Linker`] will error when unknown imports are encountered
-    /// in a command module while using [`Linker::module`]. Use this function
-    /// when
-    ///
-    /// This method can be used to allow unknown imports from command modules.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// # let engine = Engine::default();
-    /// # let module = Module::new(&engine, "(module (import \"unknown\" \"import\" (func)))")?;
-    /// # let mut store = Store::new(&engine, ());
-    /// let mut linker = Linker::new(&engine);
-    /// linker.define_unknown_imports_as_traps(&module)?;
-    /// linker.instantiate(&mut store, &module)?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    #[cfg(any(feature = "cranelift", feature = "winch"))]
-    #[cfg_attr(nightlydoc, doc(cfg(any(feature = "cranelift", feature = "winch"))))]
-    pub fn define_unknown_imports_as_traps(&mut self, module: &Module) -> anyhow::Result<()> {
-        for import in module.imports() {
-            if let Err(import_err) = self._get_by_import(&import) {
-                if let ExternType::Func(func_ty) = import_err.ty() {
-                    self.func_new(import.module(), import.name(), func_ty, move |_, _, _| {
-                        bail!(import_err.clone());
-                    })?;
-                }
-            }
-        }
-        Ok(())
-    }
-
-    /// Implement any function imports of the [`Module`] with a function that
-    /// ignores its arguments and returns default values.
-    ///
-    /// Default values are either zero or null, depending on the value type.
-    ///
-    /// This method can be used to allow unknown imports from command modules.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// # let engine = Engine::default();
-    /// # let module = Module::new(&engine, "(module (import \"unknown\" \"import\" (func)))")?;
-    /// # let mut store = Store::new(&engine, ());
-    /// let mut linker = Linker::new(&engine);
-    /// linker.define_unknown_imports_as_default_values(&module)?;
-    /// linker.instantiate(&mut store, &module)?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    #[cfg(any(feature = "cranelift", feature = "winch"))]
-    #[cfg_attr(nightlydoc, doc(cfg(any(feature = "cranelift", feature = "winch"))))]
-    pub fn define_unknown_imports_as_default_values(
-        &mut self,
-        module: &Module,
-    ) -> anyhow::Result<()> {
-        for import in module.imports() {
-            if let Err(import_err) = self._get_by_import(&import) {
-                if let ExternType::Func(func_ty) = import_err.ty() {
-                    let result_tys: Vec<_> = func_ty.results().collect();
-                    self.func_new(
-                        import.module(),
-                        import.name(),
-                        func_ty,
-                        move |_caller, _args, results| {
-                            for (result, ty) in results.iter_mut().zip(&result_tys) {
-                                *result = match ty {
-                                    ValType::I32 => Val::I32(0),
-                                    ValType::I64 => Val::I64(0),
-                                    ValType::F32 => Val::F32(0.0_f32.to_bits()),
-                                    ValType::F64 => Val::F64(0.0_f64.to_bits()),
-                                    ValType::V128 => Val::V128(0_u128.into()),
-                                    ValType::FuncRef => Val::FuncRef(None),
-                                    ValType::ExternRef => Val::ExternRef(None),
-                                };
-                            }
-                            Ok(())
-                        },
-                    )?;
-                }
-            }
-        }
-        Ok(())
-    }
-
-    /// Defines a new item in this [`Linker`].
-    ///
-    /// This method will add a new definition, by name, to this instance of
-    /// [`Linker`]. The `module` and `name` provided are what to name the
-    /// `item`.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the `module` and `name` already identify an item
-    /// of the same type as the `item` provided and if shadowing is disallowed.
-    /// For more information see the documentation on [`Linker`].
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// # let engine = Engine::default();
-    /// # let mut store = Store::new(&engine, ());
-    /// let mut linker = Linker::new(&engine);
-    /// let ty = GlobalType::new(ValType::I32, Mutability::Const);
-    /// let global = Global::new(&mut store, ty, Val::I32(0x1234))?;
-    /// linker.define(&store, "host", "offset", global)?;
-    ///
-    /// let wat = r#"
-    ///     (module
-    ///         (import "host" "offset" (global i32))
-    ///         (memory 1)
-    ///         (data (global.get 0) "foo")
-    ///     )
-    /// "#;
-    /// let module = Module::new(&engine, wat)?;
-    /// linker.instantiate(&mut store, &module)?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn define(
-        &mut self,
-        store: impl AsContext<Data = T>,
-        module: &str,
-        name: &str,
-        item: impl Into<Extern>,
-    ) -> Result<&mut Self> {
-        let store = store.as_context();
-        let key = self.import_key(module, Some(name));
-        self.insert(key, Definition::new(store.0, item.into()))?;
-        Ok(self)
-    }
-
-    /// Same as [`Linker::define`], except only the name of the import is
-    /// provided, not a module name as well.
-    ///
-    /// This is only relevant when working with the module linking proposal
-    /// where one-level names are allowed (in addition to two-level names).
-    /// Otherwise this method need not be used.
-    pub fn define_name(
-        &mut self,
-        store: impl AsContext<Data = T>,
-        name: &str,
-        item: impl Into<Extern>,
-    ) -> Result<&mut Self> {
-        let store = store.as_context();
-        let key = self.import_key(name, None);
-        self.insert(key, Definition::new(store.0, item.into()))?;
-        Ok(self)
-    }
-
-    /// Creates a [`Func::new`]-style function named in this linker.
-    ///
-    /// For more information see [`Linker::func_wrap`].
-    #[cfg(any(feature = "cranelift", feature = "winch"))]
-    #[cfg_attr(nightlydoc, doc(cfg(any(feature = "cranelift", feature = "winch"))))]
-    pub fn func_new(
-        &mut self,
-        module: &str,
-        name: &str,
-        ty: FuncType,
-        func: impl Fn(Caller<'_, T>, &[Val], &mut [Val]) -> Result<()> + Send + Sync + 'static,
-    ) -> Result<&mut Self> {
-        let func = HostFunc::new(&self.engine, ty, func);
-        let key = self.import_key(module, Some(name));
-        self.insert(key, Definition::HostFunc(Arc::new(func)))?;
-        Ok(self)
-    }
-
-    /// Creates a [`Func::new_unchecked`]-style function named in this linker.
-    ///
-    /// For more information see [`Linker::func_wrap`].
-    #[cfg(any(feature = "cranelift", feature = "winch"))]
-    #[cfg_attr(nightlydoc, doc(cfg(any(feature = "cranelift", feature = "winch"))))]
-    pub unsafe fn func_new_unchecked(
-        &mut self,
-        module: &str,
-        name: &str,
-        ty: FuncType,
-        func: impl Fn(Caller<'_, T>, &mut [ValRaw]) -> Result<()> + Send + Sync + 'static,
-    ) -> Result<&mut Self> {
-        let func = HostFunc::new_unchecked(&self.engine, ty, func);
-        let key = self.import_key(module, Some(name));
-        self.insert(key, Definition::HostFunc(Arc::new(func)))?;
-        Ok(self)
-    }
-
-    /// Creates a [`Func::new_async`]-style function named in this linker.
-    ///
-    /// For more information see [`Linker::func_wrap`].
-    #[cfg(all(feature = "async", feature = "cranelift"))]
-    #[cfg_attr(nightlydoc, doc(cfg(all(feature = "async", feature = "cranelift"))))]
-    pub fn func_new_async<F>(
-        &mut self,
-        module: &str,
-        name: &str,
-        ty: FuncType,
-        func: F,
-    ) -> Result<&mut Self>
-    where
-        F: for<'a> Fn(
-                Caller<'a, T>,
-                &'a [Val],
-                &'a mut [Val],
-            ) -> Box<dyn Future<Output = Result<()>> + Send + 'a>
-            + Send
-            + Sync
-            + 'static,
-    {
-        assert!(
-            self.engine.config().async_support,
-            "cannot use `func_new_async` without enabling async support in the config"
-        );
-        self.func_new(module, name, ty, move |mut caller, params, results| {
-            let async_cx = caller
-                .store
-                .as_context_mut()
-                .0
-                .async_cx()
-                .expect("Attempt to spawn new function on dying fiber");
-            let mut future = Pin::from(func(caller, params, results));
-            match unsafe { async_cx.block_on(future.as_mut()) } {
-                Ok(Ok(())) => Ok(()),
-                Ok(Err(trap)) | Err(trap) => Err(trap),
-            }
-        })
-    }
-
-    /// Define a host function within this linker.
-    ///
-    /// For information about how the host function operates, see
-    /// [`Func::wrap`]. That includes information about translating Rust types
-    /// to WebAssembly native types.
-    ///
-    /// This method creates a host-provided function in this linker under the
-    /// provided name. This method is distinct in its capability to create a
-    /// [`Store`](crate::Store)-independent function. This means that the
-    /// function defined here can be used to instantiate instances in multiple
-    /// different stores, or in other words the function can be loaded into
-    /// different stores.
-    ///
-    /// Note that the capability mentioned here applies to all other
-    /// host-function-defining-methods on [`Linker`] as well. All of them can be
-    /// used to create instances of [`Func`] within multiple stores. In a
-    /// multithreaded program, for example, this means that the host functions
-    /// could be called concurrently if different stores are executing on
-    /// different threads.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the `module` and `name` already identify an item
-    /// of the same type as the `item` provided and if shadowing is disallowed.
-    /// For more information see the documentation on [`Linker`].
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// # let engine = Engine::default();
-    /// let mut linker = Linker::new(&engine);
-    /// linker.func_wrap("host", "double", |x: i32| x * 2)?;
-    /// linker.func_wrap("host", "log_i32", |x: i32| println!("{}", x))?;
-    /// linker.func_wrap("host", "log_str", |caller: Caller<'_, ()>, ptr: i32, len: i32| {
-    ///     // ...
-    /// })?;
-    ///
-    /// let wat = r#"
-    ///     (module
-    ///         (import "host" "double" (func (param i32) (result i32)))
-    ///         (import "host" "log_i32" (func (param i32)))
-    ///         (import "host" "log_str" (func (param i32 i32)))
-    ///     )
-    /// "#;
-    /// let module = Module::new(&engine, wat)?;
-    ///
-    /// // instantiate in multiple different stores
-    /// for _ in 0..10 {
-    ///     let mut store = Store::new(&engine, ());
-    ///     linker.instantiate(&mut store, &module)?;
-    /// }
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn func_wrap<Params, Args>(
-        &mut self,
-        module: &str,
-        name: &str,
-        func: impl IntoFunc<T, Params, Args>,
-    ) -> Result<&mut Self> {
-        let func = HostFunc::wrap(&self.engine, func);
-        let key = self.import_key(module, Some(name));
-        self.insert(key, Definition::HostFunc(Arc::new(func)))?;
-        Ok(self)
-    }
-
-    for_each_function_signature!(generate_wrap_async_func);
-
-    /// Convenience wrapper to define an entire [`Instance`] in this linker.
-    ///
-    /// This function is a convenience wrapper around [`Linker::define`] which
-    /// will define all exports on `instance` into this linker. The module name
-    /// for each export is `module_name`, and the name for each export is the
-    /// name in the instance itself.
-    ///
-    /// Note that when this API is used the [`Linker`] is no longer compatible
-    /// with multi-[`Store`][crate::Store] instantiation because the items
-    /// defined within this store will belong to the `store` provided, and only
-    /// the `store` provided.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the any item is redefined twice in this linker (for
-    /// example the same `module_name` was already defined) and shadowing is
-    /// disallowed, or if `instance` comes from a different
-    /// [`Store`](crate::Store) than this [`Linker`] originally was created
-    /// with.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `instance` does not belong to `store`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// # let engine = Engine::default();
-    /// # let mut store = Store::new(&engine, ());
-    /// let mut linker = Linker::new(&engine);
-    ///
-    /// // Instantiate a small instance...
-    /// let wat = r#"(module (func (export "run") ))"#;
-    /// let module = Module::new(&engine, wat)?;
-    /// let instance = linker.instantiate(&mut store, &module)?;
-    ///
-    /// // ... and inform the linker that the name of this instance is
-    /// // `instance1`. This defines the `instance1::run` name for our next
-    /// // module to use.
-    /// linker.instance(&mut store, "instance1", instance)?;
-    ///
-    /// let wat = r#"
-    ///     (module
-    ///         (import "instance1" "run" (func $instance1_run))
-    ///         (func (export "run")
-    ///             call $instance1_run
-    ///         )
-    ///     )
-    /// "#;
-    /// let module = Module::new(&engine, wat)?;
-    /// let instance = linker.instantiate(&mut store, &module)?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn instance(
-        &mut self,
-        mut store: impl AsContextMut<Data = T>,
-        module_name: &str,
-        instance: Instance,
-    ) -> Result<&mut Self> {
-        let mut store = store.as_context_mut();
-        let exports = instance
-            .exports(&mut store)
-            .map(|e| {
-                (
-                    self.import_key(module_name, Some(e.name())),
-                    e.into_extern(),
-                )
-            })
-            .collect::<Vec<_>>();
-        for (key, export) in exports {
-            self.insert(key, Definition::new(store.0, export))?;
-        }
-        Ok(self)
-    }
-
-    /// Define automatic instantiations of a [`Module`] in this linker.
-    ///
-    /// This automatically handles [Commands and Reactors] instantiation and
-    /// initialization.
-    ///
-    /// Exported functions of a Command module may be called directly, however
-    /// instead of having a single instance which is reused for each call,
-    /// each call creates a new instance, which lives for the duration of the
-    /// call. The imports of the Command are resolved once, and reused for
-    /// each instantiation, so all dependencies need to be present at the time
-    /// when `Linker::module` is called.
-    ///
-    /// For Reactors, a single instance is created, and an initialization
-    /// function is called, and then its exports may be called.
-    ///
-    /// Ordinary modules which don't declare themselves to be either Commands
-    /// or Reactors are treated as Reactors without any initialization calls.
-    ///
-    /// [Commands and Reactors]: https://github.com/WebAssembly/WASI/blob/main/legacy/application-abi.md#current-unstable-abi
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the any item is redefined twice in this linker (for
-    /// example the same `module_name` was already defined) and shadowing is
-    /// disallowed, if `instance` comes from a different
-    /// [`Store`](crate::Store) than this [`Linker`] originally was created
-    /// with, or if a Reactor initialization function traps.
-    ///
-    /// # Panics
-    ///
-    /// Panics if any item used to instantiate the provided [`Module`] is not
-    /// owned by `store`, or if the `store` provided comes from a different
-    /// [`Engine`] than this [`Linker`].
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// # let engine = Engine::default();
-    /// # let mut store = Store::new(&engine, ());
-    /// let mut linker = Linker::new(&engine);
-    ///
-    /// // Instantiate a small instance and inform the linker that the name of
-    /// // this instance is `instance1`. This defines the `instance1::run` name
-    /// // for our next module to use.
-    /// let wat = r#"(module (func (export "run") ))"#;
-    /// let module = Module::new(&engine, wat)?;
-    /// linker.module(&mut store, "instance1", &module)?;
-    ///
-    /// let wat = r#"
-    ///     (module
-    ///         (import "instance1" "run" (func $instance1_run))
-    ///         (func (export "run")
-    ///             call $instance1_run
-    ///         )
-    ///     )
-    /// "#;
-    /// let module = Module::new(&engine, wat)?;
-    /// let instance = linker.instantiate(&mut store, &module)?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    ///
-    /// For a Command, a new instance is created for each call.
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// # let engine = Engine::default();
-    /// # let mut store = Store::new(&engine, ());
-    /// let mut linker = Linker::new(&engine);
-    ///
-    /// // Create a Command that attempts to count the number of times it is run, but is
-    /// // foiled by each call getting a new instance.
-    /// let wat = r#"
-    ///     (module
-    ///         (global $counter (mut i32) (i32.const 0))
-    ///         (func (export "_start")
-    ///             (global.set $counter (i32.add (global.get $counter) (i32.const 1)))
-    ///         )
-    ///         (func (export "read_counter") (result i32)
-    ///             (global.get $counter)
-    ///         )
-    ///     )
-    /// "#;
-    /// let module = Module::new(&engine, wat)?;
-    /// linker.module(&mut store, "commander", &module)?;
-    /// let run = linker.get_default(&mut store, "")?
-    ///     .typed::<(), ()>(&store)?
-    ///     .clone();
-    /// run.call(&mut store, ())?;
-    /// run.call(&mut store, ())?;
-    /// run.call(&mut store, ())?;
-    ///
-    /// let wat = r#"
-    ///     (module
-    ///         (import "commander" "_start" (func $commander_start))
-    ///         (import "commander" "read_counter" (func $commander_read_counter (result i32)))
-    ///         (func (export "run") (result i32)
-    ///             call $commander_start
-    ///             call $commander_start
-    ///             call $commander_start
-    ///             call $commander_read_counter
-    ///         )
-    ///     )
-    /// "#;
-    /// let module = Module::new(&engine, wat)?;
-    /// linker.module(&mut store, "", &module)?;
-    /// let run = linker.get(&mut store, "", "run").unwrap().into_func().unwrap();
-    /// let count = run.typed::<(), i32>(&store)?.call(&mut store, ())?;
-    /// assert_eq!(count, 0, "a Command should get a fresh instance on each invocation");
-    ///
-    /// # Ok(())
-    /// # }
-    /// ```
-    #[cfg(any(feature = "cranelift", feature = "winch"))]
-    #[cfg_attr(nightlydoc, doc(cfg(any(feature = "cranelift", feature = "winch"))))]
-    pub fn module(
-        &mut self,
-        mut store: impl AsContextMut<Data = T>,
-        module_name: &str,
-        module: &Module,
-    ) -> Result<&mut Self>
-    where
-        T: 'static,
-    {
-        // NB: this is intended to function the same as `Linker::module_async`,
-        // they should be kept in sync.
-
-        // This assert isn't strictly necessary since it'll bottom out in the
-        // `HostFunc::to_func` method anyway. This is placed earlier for this
-        // function though to prevent the functions created here from delaying
-        // the panic until they're called.
-        assert!(
-            Engine::same(&self.engine, store.as_context().engine()),
-            "different engines for this linker and the store provided"
-        );
-        match ModuleKind::categorize(module)? {
-            ModuleKind::Command => {
-                self.command(
-                    store,
-                    module_name,
-                    module,
-                    |store, func_ty, export_name, instance_pre| {
-                        Func::new(
-                            store,
-                            func_ty.clone(),
-                            move |mut caller, params, results| {
-                                // Create a new instance for this command execution.
-                                let instance = instance_pre.instantiate(&mut caller)?;
-
-                                // `unwrap()` everything here because we know the instance contains a
-                                // function export with the given name and signature because we're
-                                // iterating over the module it was instantiated from.
-                                instance
-                                    .get_export(&mut caller, &export_name)
-                                    .unwrap()
-                                    .into_func()
-                                    .unwrap()
-                                    .call(&mut caller, params, results)?;
-
-                                Ok(())
-                            },
-                        )
-                    },
-                )
-            }
-            ModuleKind::Reactor => {
-                let instance = self.instantiate(&mut store, &module)?;
-
-                if let Some(export) = instance.get_export(&mut store, "_initialize") {
-                    if let Extern::Func(func) = export {
-                        func.typed::<(), ()>(&store)
-                            .and_then(|f| f.call(&mut store, ()).map_err(Into::into))
-                            .context("calling the Reactor initialization function")?;
-                    }
-                }
-
-                self.instance(store, module_name, instance)
-            }
-        }
-    }
-
-    /// Define automatic instantiations of a [`Module`] in this linker.
-    ///
-    /// This is the same as [`Linker::module`], except for async `Store`s.
-    #[cfg(all(feature = "async", feature = "cranelift"))]
-    #[cfg_attr(nightlydoc, doc(cfg(all(feature = "async", feature = "cranelift"))))]
-    pub async fn module_async(
-        &mut self,
-        mut store: impl AsContextMut<Data = T>,
-        module_name: &str,
-        module: &Module,
-    ) -> Result<&mut Self>
-    where
-        T: Send + 'static,
-    {
-        // NB: this is intended to function the same as `Linker::module`, they
-        // should be kept in sync.
-        assert!(
-            Engine::same(&self.engine, store.as_context().engine()),
-            "different engines for this linker and the store provided"
-        );
-        match ModuleKind::categorize(module)? {
-            ModuleKind::Command => self.command(
-                store,
-                module_name,
-                module,
-                |store, func_ty, export_name, instance_pre| {
-                    let upvars = Arc::new((instance_pre, export_name));
-                    Func::new_async(
-                        store,
-                        func_ty.clone(),
-                        move |mut caller, params, results| {
-                            let upvars = upvars.clone();
-                            Box::new(async move {
-                                let (instance_pre, export_name) = &*upvars;
-                                let instance = instance_pre.instantiate_async(&mut caller).await?;
-
-                                instance
-                                    .get_export(&mut caller, &export_name)
-                                    .unwrap()
-                                    .into_func()
-                                    .unwrap()
-                                    .call_async(&mut caller, params, results)
-                                    .await?;
-                                Ok(())
-                            })
-                        },
-                    )
-                },
-            ),
-            ModuleKind::Reactor => {
-                let instance = self.instantiate_async(&mut store, &module).await?;
-
-                if let Some(export) = instance.get_export(&mut store, "_initialize") {
-                    if let Extern::Func(func) = export {
-                        let func = func
-                            .typed::<(), ()>(&store)
-                            .context("loading the Reactor initialization function")?;
-                        func.call_async(&mut store, ())
-                            .await
-                            .context("calling the Reactor initialization function")?;
-                    }
-                }
-
-                self.instance(store, module_name, instance)
-            }
-        }
-    }
-
-    fn command(
-        &mut self,
-        mut store: impl AsContextMut<Data = T>,
-        module_name: &str,
-        module: &Module,
-        mk_func: impl Fn(&mut StoreContextMut<T>, &FuncType, String, InstancePre<T>) -> Func,
-    ) -> Result<&mut Self>
-    where
-        T: 'static,
-    {
-        let mut store = store.as_context_mut();
-        for export in module.exports() {
-            if let Some(func_ty) = export.ty().func() {
-                let instance_pre = self.instantiate_pre(module)?;
-                let export_name = export.name().to_owned();
-                let func = mk_func(&mut store, func_ty, export_name, instance_pre);
-                let key = self.import_key(module_name, Some(export.name()));
-                self.insert(key, Definition::new(store.0, func.into()))?;
-            } else if export.name() == "memory" && export.ty().memory().is_some() {
-                // Allow an exported "memory" memory for now.
-            } else if export.name() == "__indirect_function_table" && export.ty().table().is_some()
-            {
-                // Allow an exported "__indirect_function_table" table for now.
-            } else if export.name() == "table" && export.ty().table().is_some() {
-                // Allow an exported "table" table for now.
-            } else if export.name() == "__data_end" && export.ty().global().is_some() {
-                // Allow an exported "__data_end" memory for compatibility with toolchains
-                // which use --export-dynamic, which unfortunately doesn't work the way
-                // we want it to.
-                warn!("command module exporting '__data_end' is deprecated");
-            } else if export.name() == "__heap_base" && export.ty().global().is_some() {
-                // Allow an exported "__data_end" memory for compatibility with toolchains
-                // which use --export-dynamic, which unfortunately doesn't work the way
-                // we want it to.
-                warn!("command module exporting '__heap_base' is deprecated");
-            } else if export.name() == "__dso_handle" && export.ty().global().is_some() {
-                // Allow an exported "__dso_handle" memory for compatibility with toolchains
-                // which use --export-dynamic, which unfortunately doesn't work the way
-                // we want it to.
-                warn!("command module exporting '__dso_handle' is deprecated")
-            } else if export.name() == "__rtti_base" && export.ty().global().is_some() {
-                // Allow an exported "__rtti_base" memory for compatibility with
-                // AssemblyScript.
-                warn!("command module exporting '__rtti_base' is deprecated; pass `--runtime half` to the AssemblyScript compiler");
-            } else if !self.allow_unknown_exports {
-                bail!("command export '{}' is not a function", export.name());
-            }
-        }
-
-        Ok(self)
-    }
-
-    /// Aliases one item's name as another.
-    ///
-    /// This method will alias an item with the specified `module` and `name`
-    /// under a new name of `as_module` and `as_name`.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if any shadowing violations happen while defining new
-    /// items, or if the original item wasn't defined.
-    pub fn alias(
-        &mut self,
-        module: &str,
-        name: &str,
-        as_module: &str,
-        as_name: &str,
-    ) -> Result<&mut Self> {
-        let src = self.import_key(module, Some(name));
-        let dst = self.import_key(as_module, Some(as_name));
-        match self.map.get(&src).cloned() {
-            Some(item) => self.insert(dst, item)?,
-            None => bail!("no item named `{}::{}` defined", module, name),
-        }
-        Ok(self)
-    }
-
-    /// Aliases one module's name as another.
-    ///
-    /// This method will alias all currently defined under `module` to also be
-    /// defined under the name `as_module` too.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if any shadowing violations happen while defining new
-    /// items.
-    pub fn alias_module(&mut self, module: &str, as_module: &str) -> Result<()> {
-        let module = self.intern_str(module);
-        let as_module = self.intern_str(as_module);
-        let items = self
-            .map
-            .iter()
-            .filter(|(key, _def)| key.module == module)
-            .map(|(key, def)| (key.name, def.clone()))
-            .collect::<Vec<_>>();
-        for (name, item) in items {
-            self.insert(
-                ImportKey {
-                    module: as_module,
-                    name,
-                },
-                item,
-            )?;
-        }
-        Ok(())
-    }
-
-    fn insert(&mut self, key: ImportKey, item: Definition) -> Result<()> {
-        match self.map.entry(key) {
-            Entry::Occupied(_) if !self.allow_shadowing => {
-                let module = &self.strings[key.module];
-                let desc = match self.strings.get(key.name) {
-                    Some(name) => format!("{}::{}", module, name),
-                    None => module.to_string(),
-                };
-                bail!("import of `{}` defined twice", desc)
-            }
-            Entry::Occupied(mut o) => {
-                o.insert(item);
-            }
-            Entry::Vacant(v) => {
-                v.insert(item);
-            }
-        }
-        Ok(())
-    }
-
-    fn import_key(&mut self, module: &str, name: Option<&str>) -> ImportKey {
-        ImportKey {
-            module: self.intern_str(module),
-            name: name
-                .map(|name| self.intern_str(name))
-                .unwrap_or(usize::max_value()),
-        }
-    }
-
-    fn intern_str(&mut self, string: &str) -> usize {
-        if let Some(idx) = self.string2idx.get(string) {
-            return *idx;
-        }
-        let string: Arc<str> = string.into();
-        let idx = self.strings.len();
-        self.strings.push(string.clone());
-        self.string2idx.insert(string, idx);
-        idx
-    }
-
-    /// Attempts to instantiate the `module` provided.
-    ///
-    /// This method will attempt to assemble a list of imports that correspond
-    /// to the imports required by the [`Module`] provided. This list
-    /// of imports is then passed to [`Instance::new`] to continue the
-    /// instantiation process.
-    ///
-    /// Each import of `module` will be looked up in this [`Linker`] and must
-    /// have previously been defined. If it was previously defined with an
-    /// incorrect signature or if it was not previously defined then an error
-    /// will be returned because the import can not be satisfied.
-    ///
-    /// Per the WebAssembly spec, instantiation includes running the module's
-    /// start function, if it has one (not to be confused with the `_start`
-    /// function, which is not run).
-    ///
-    /// # Errors
-    ///
-    /// This method can fail because an import may not be found, or because
-    /// instantiation itself may fail. For information on instantiation
-    /// failures see [`Instance::new`]. If an import is not found, the error
-    /// may be downcast to an [`UnknownImportError`].
-    ///
-    ///
-    /// # Panics
-    ///
-    /// Panics if any item used to instantiate `module` is not owned by
-    /// `store`. Additionally this will panic if the [`Engine`] that the `store`
-    /// belongs to is different than this [`Linker`].
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// # let engine = Engine::default();
-    /// # let mut store = Store::new(&engine, ());
-    /// let mut linker = Linker::new(&engine);
-    /// linker.func_wrap("host", "double", |x: i32| x * 2)?;
-    ///
-    /// let wat = r#"
-    ///     (module
-    ///         (import "host" "double" (func (param i32) (result i32)))
-    ///     )
-    /// "#;
-    /// let module = Module::new(&engine, wat)?;
-    /// linker.instantiate(&mut store, &module)?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn instantiate(
-        &self,
-        mut store: impl AsContextMut<Data = T>,
-        module: &Module,
-    ) -> Result<Instance> {
-        self._instantiate_pre(module, Some(store.as_context_mut().0))?
-            .instantiate(store)
-    }
-
-    /// Attempts to instantiate the `module` provided. This is the same as
-    /// [`Linker::instantiate`], except for async `Store`s.
-    #[cfg(feature = "async")]
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "async")))]
-    pub async fn instantiate_async(
-        &self,
-        mut store: impl AsContextMut<Data = T>,
-        module: &Module,
-    ) -> Result<Instance>
-    where
-        T: Send,
-    {
-        self._instantiate_pre(module, Some(store.as_context_mut().0))?
-            .instantiate_async(store)
-            .await
-    }
-
-    /// Performs all checks necessary for instantiating `module` with this
-    /// linker, except that instantiation doesn't actually finish.
-    ///
-    /// This method is used for front-loading type-checking information as well
-    /// as collecting the imports to use to instantiate a module with. The
-    /// returned [`InstancePre`] represents a ready-to-be-instantiated module,
-    /// which can also be instantiated multiple times if desired.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error which may be downcast to an [`UnknownImportError`] if
-    /// the module has any unresolvable imports.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// # let engine = Engine::default();
-    /// # let mut store = Store::new(&engine, ());
-    /// let mut linker = Linker::new(&engine);
-    /// linker.func_wrap("host", "double", |x: i32| x * 2)?;
-    ///
-    /// let wat = r#"
-    ///     (module
-    ///         (import "host" "double" (func (param i32) (result i32)))
-    ///     )
-    /// "#;
-    /// let module = Module::new(&engine, wat)?;
-    /// let instance_pre = linker.instantiate_pre(&module)?;
-    ///
-    /// // Finish instantiation after the type-checking has all completed...
-    /// let instance = instance_pre.instantiate(&mut store)?;
-    ///
-    /// // ... and we can even continue to keep instantiating if desired!
-    /// instance_pre.instantiate(&mut store)?;
-    /// instance_pre.instantiate(&mut store)?;
-    ///
-    /// // Note that functions defined in a linker with `func_wrap` and similar
-    /// // constructors are not owned by any particular `Store`, so we can also
-    /// // instantiate our `instance_pre` in other stores because no imports
-    /// // belong to the original store.
-    /// let mut new_store = Store::new(&engine, ());
-    /// instance_pre.instantiate(&mut new_store)?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn instantiate_pre(&self, module: &Module) -> Result<InstancePre<T>> {
-        self._instantiate_pre(module, None)
-    }
-
-    /// This is split out to optionally take a `store` so that when the
-    /// `.instantiate` API is used we can get fresh up-to-date type information
-    /// for memories and their current size, if necessary.
-    ///
-    /// Note that providing a `store` here is not required for correctness
-    /// per-se. If one is not provided, such as the with the `instantiate_pre`
-    /// API, then the type information used for memories and tables will reflect
-    /// their size when inserted into the linker rather than their current size.
-    /// This isn't expected to be much of a problem though since
-    /// per-store-`Linker` types are likely using `.instantiate(..)` and
-    /// per-`Engine` linkers don't have memories/tables in them.
-    fn _instantiate_pre(
-        &self,
-        module: &Module,
-        store: Option<&StoreOpaque>,
-    ) -> Result<InstancePre<T>> {
-        let mut imports = module
-            .imports()
-            .map(|import| self._get_by_import(&import))
-            .collect::<Result<Vec<_>, _>>()?;
-        if let Some(store) = store {
-            for import in imports.iter_mut() {
-                import.update_size(store);
-            }
-        }
-        unsafe { InstancePre::new(module, imports) }
-    }
-
-    /// Returns an iterator over all items defined in this `Linker`, in
-    /// arbitrary order.
-    ///
-    /// The iterator returned will yield 3-tuples where the first two elements
-    /// are the module name and item name for the external item, and the third
-    /// item is the item itself that is defined.
-    ///
-    /// Note that multiple `Extern` items may be defined for the same
-    /// module/name pair.
-    ///
-    /// # Panics
-    ///
-    /// This function will panic if the `store` provided does not come from the
-    /// same [`Engine`] that this linker was created with.
-    pub fn iter<'a: 'p, 'p>(
-        &'a self,
-        mut store: impl AsContextMut<Data = T> + 'p,
-    ) -> impl Iterator<Item = (&str, &str, Extern)> + 'p {
-        self.map.iter().map(move |(key, item)| {
-            let store = store.as_context_mut();
-            (
-                &*self.strings[key.module],
-                &*self.strings[key.name],
-                // Should be safe since `T` is connecting the linker and store
-                unsafe { item.to_extern(store.0) },
-            )
-        })
-    }
-
-    /// Looks up a previously defined value in this [`Linker`], identified by
-    /// the names provided.
-    ///
-    /// Returns `None` if this name was not previously defined in this
-    /// [`Linker`].
-    ///
-    /// # Panics
-    ///
-    /// This function will panic if the `store` provided does not come from the
-    /// same [`Engine`] that this linker was created with.
-    pub fn get(
-        &self,
-        mut store: impl AsContextMut<Data = T>,
-        module: &str,
-        name: &str,
-    ) -> Option<Extern> {
-        let store = store.as_context_mut().0;
-        // Should be safe since `T` is connecting the linker and store
-        Some(unsafe { self._get(module, name)?.to_extern(store) })
-    }
-
-    fn _get(&self, module: &str, name: &str) -> Option<&Definition> {
-        let key = ImportKey {
-            module: *self.string2idx.get(module)?,
-            name: *self.string2idx.get(name)?,
-        };
-        self.map.get(&key)
-    }
-
-    /// Looks up a value in this `Linker` which matches the `import` type
-    /// provided.
-    ///
-    /// Returns `None` if no match was found.
-    ///
-    /// # Panics
-    ///
-    /// This function will panic if the `store` provided does not come from the
-    /// same [`Engine`] that this linker was created with.
-    pub fn get_by_import(
-        &self,
-        mut store: impl AsContextMut<Data = T>,
-        import: &ImportType,
-    ) -> Option<Extern> {
-        let store = store.as_context_mut().0;
-        // Should be safe since `T` is connecting the linker and store
-        Some(unsafe { self._get_by_import(import).ok()?.to_extern(store) })
-    }
-
-    fn _get_by_import(&self, import: &ImportType) -> Result<Definition, UnknownImportError> {
-        match self._get(import.module(), import.name()) {
-            Some(item) => Ok(item.clone()),
-            None => Err(UnknownImportError::new(import)),
-        }
-    }
-
-    /// Returns the "default export" of a module.
-    ///
-    /// An export with an empty string is considered to be a "default export".
-    /// "_start" is also recognized for compatibility.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the default function found is not owned by `store`. This
-    /// function will also panic if the `store` provided does not come from the
-    /// same [`Engine`] that this linker was created with.
-    pub fn get_default(
-        &self,
-        mut store: impl AsContextMut<Data = T>,
-        module: &str,
-    ) -> Result<Func> {
-        if let Some(external) = self.get(&mut store, module, "") {
-            if let Extern::Func(func) = external {
-                return Ok(func.clone());
-            }
-            bail!("default export in '{}' is not a function", module);
-        }
-
-        // For compatibility, also recognize "_start".
-        if let Some(external) = self.get(&mut store, module, "_start") {
-            if let Extern::Func(func) = external {
-                return Ok(func.clone());
-            }
-            bail!("`_start` in '{}' is not a function", module);
-        }
-
-        // Otherwise return a no-op function.
-        Ok(Func::wrap(store, || {}))
-    }
-}
-
-impl<T> Default for Linker<T> {
-    fn default() -> Linker<T> {
-        Linker::new(&Engine::default())
-    }
-}
-
-impl Definition {
-    fn new(store: &StoreOpaque, item: Extern) -> Definition {
-        let ty = DefinitionType::from(store, &item);
-        Definition::Extern(item, ty)
-    }
-
-    pub(crate) fn ty(&self) -> DefinitionType {
-        match self {
-            Definition::Extern(_, ty) => ty.clone(),
-            Definition::HostFunc(func) => DefinitionType::Func(func.sig_index()),
-        }
-    }
-
-    /// Note the unsafety here is due to calling `HostFunc::to_func`. The
-    /// requirement here is that the `T` that was originally used to create the
-    /// `HostFunc` matches the `T` on the store.
-    pub(crate) unsafe fn to_extern(&self, store: &mut StoreOpaque) -> Extern {
-        match self {
-            Definition::Extern(e, _) => e.clone(),
-            Definition::HostFunc(func) => func.to_func(store).into(),
-        }
-    }
-
-    pub(crate) fn comes_from_same_store(&self, store: &StoreOpaque) -> bool {
-        match self {
-            Definition::Extern(e, _) => e.comes_from_same_store(store),
-            Definition::HostFunc(_func) => true,
-        }
-    }
-
-    fn update_size(&mut self, store: &StoreOpaque) {
-        match self {
-            Definition::Extern(Extern::Memory(m), DefinitionType::Memory(_, size)) => {
-                *size = m.internal_size(store);
-            }
-            Definition::Extern(Extern::SharedMemory(m), DefinitionType::Memory(_, size)) => {
-                *size = m.size();
-            }
-            Definition::Extern(Extern::Table(m), DefinitionType::Table(_, size)) => {
-                *size = m.internal_size(store);
-            }
-            _ => {}
-        }
-    }
-}
-
-impl DefinitionType {
-    pub(crate) fn from(store: &StoreOpaque, item: &Extern) -> DefinitionType {
-        let data = store.store_data();
-        match item {
-            Extern::Func(f) => DefinitionType::Func(f.sig_index(data)),
-            Extern::Table(t) => DefinitionType::Table(*t.wasmtime_ty(data), t.internal_size(store)),
-            Extern::Global(t) => DefinitionType::Global(*t.wasmtime_ty(data)),
-            Extern::Memory(t) => {
-                DefinitionType::Memory(*t.wasmtime_ty(data), t.internal_size(store))
-            }
-            Extern::SharedMemory(t) => DefinitionType::Memory(*t.ty().wasmtime_memory(), t.size()),
-        }
-    }
-
-    pub(crate) fn desc(&self) -> &'static str {
-        match self {
-            DefinitionType::Func(_) => "function",
-            DefinitionType::Table(..) => "table",
-            DefinitionType::Memory(..) => "memory",
-            DefinitionType::Global(_) => "global",
-        }
-    }
-}
-
-/// Modules can be interpreted either as Commands or Reactors.
-enum ModuleKind {
-    /// The instance is a Command, meaning an instance is created for each
-    /// exported function and lives for the duration of the function call.
-    Command,
-
-    /// The instance is a Reactor, meaning one instance is created which
-    /// may live across multiple calls.
-    Reactor,
-}
-
-impl ModuleKind {
-    /// Determine whether the given module is a Command or a Reactor.
-    fn categorize(module: &Module) -> Result<ModuleKind> {
-        let command_start = module.get_export("_start");
-        let reactor_start = module.get_export("_initialize");
-        match (command_start, reactor_start) {
-            (Some(command_start), None) => {
-                if let Some(_) = command_start.func() {
-                    Ok(ModuleKind::Command)
-                } else {
-                    bail!("`_start` must be a function")
-                }
-            }
-            (None, Some(reactor_start)) => {
-                if let Some(_) = reactor_start.func() {
-                    Ok(ModuleKind::Reactor)
-                } else {
-                    bail!("`_initialize` must be a function")
-                }
-            }
-            (None, None) => {
-                // Module declares neither of the recognized functions, so treat
-                // it as a reactor with no initialization function.
-                Ok(ModuleKind::Reactor)
-            }
-            (Some(_), Some(_)) => {
-                // Module declares itself to be both a Command and a Reactor.
-                bail!("Program cannot be both a Command and a Reactor")
-            }
-        }
-    }
-}
-
-/// Error for an unresolvable import.
-///
-/// Returned - wrapped in an [`anyhow::Error`] - by [`Linker::instantiate`] and
-/// related methods for modules with unresolvable imports.
-#[derive(Clone, Debug)]
-pub struct UnknownImportError {
-    module: String,
-    name: String,
-    ty: ExternType,
-}
-
-impl UnknownImportError {
-    fn new(import: &ImportType) -> Self {
-        Self {
-            module: import.module().to_string(),
-            name: import.name().to_string(),
-            ty: import.ty(),
-        }
-    }
-
-    /// Returns the module name that the unknown import was expected to come from.
-    pub fn module(&self) -> &str {
-        &self.module
-    }
-
-    /// Returns the field name of the module that the unknown import was expected to come from.
-    pub fn name(&self) -> &str {
-        &self.name
-    }
-
-    /// Returns the type of the unknown import.
-    pub fn ty(&self) -> ExternType {
-        self.ty.clone()
-    }
-}
-
-impl std::fmt::Display for UnknownImportError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "unknown import: `{}::{}` has not been defined",
-            self.module, self.name,
-        )
-    }
-}
-
-impl std::error::Error for UnknownImportError {}
diff --git a/crates/wasmtime/src/memory.rs b/crates/wasmtime/src/memory.rs
deleted file mode 100644
index 94cb354d4246..000000000000
--- a/crates/wasmtime/src/memory.rs
+++ /dev/null
@@ -1,996 +0,0 @@
-use crate::store::{StoreData, StoreOpaque, Stored};
-use crate::trampoline::generate_memory_export;
-use crate::Trap;
-use crate::{AsContext, AsContextMut, Engine, MemoryType, StoreContext, StoreContextMut};
-use anyhow::{bail, Result};
-use std::cell::UnsafeCell;
-use std::convert::TryFrom;
-use std::ops::Range;
-use std::slice;
-use std::time::Instant;
-use wasmtime_environ::MemoryPlan;
-use wasmtime_runtime::{RuntimeLinearMemory, VMMemoryImport};
-
-pub use wasmtime_runtime::WaitResult;
-
-/// Error for out of bounds [`Memory`] access.
-#[derive(Debug)]
-#[non_exhaustive]
-pub struct MemoryAccessError {
-    // Keep struct internals private for future extensibility.
-    _private: (),
-}
-
-impl std::fmt::Display for MemoryAccessError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "out of bounds memory access")
-    }
-}
-
-impl std::error::Error for MemoryAccessError {}
-
-/// A WebAssembly linear memory.
-///
-/// WebAssembly memories represent a contiguous array of bytes that have a size
-/// that is always a multiple of the WebAssembly page size, currently 64
-/// kilobytes.
-///
-/// WebAssembly memory is used for global data (not to be confused with wasm
-/// `global` items), statics in C/C++/Rust, shadow stack memory, etc. Accessing
-/// wasm memory is generally quite fast.
-///
-/// Memories, like other wasm items, are owned by a [`Store`](crate::Store).
-///
-/// # `Memory` and Safety
-///
-/// Linear memory is a lynchpin of safety for WebAssembly. In Wasmtime there are
-/// safe methods of interacting with a [`Memory`]:
-///
-/// * [`Memory::read`]
-/// * [`Memory::write`]
-/// * [`Memory::data`]
-/// * [`Memory::data_mut`]
-///
-/// Note that all of these consider the entire store context as borrowed for the
-/// duration of the call or the duration of the returned slice. This largely
-/// means that while the function is running you'll be unable to borrow anything
-/// else from the store. This includes getting access to the `T` on
-/// [`Store<T>`](crate::Store), but it also means that you can't recursively
-/// call into WebAssembly for instance.
-///
-/// If you'd like to dip your toes into handling [`Memory`] in a more raw
-/// fashion (e.g. by using raw pointers or raw slices), then there's a few
-/// important points to consider when doing so:
-///
-/// * Any recursive calls into WebAssembly can possibly modify any byte of the
-///   entire memory. This means that whenever wasm is called Rust can't have any
-///   long-lived borrows live across the wasm function call. Slices like `&mut
-///   [u8]` will be violated because they're not actually exclusive at that
-///   point, and slices like `&[u8]` are also violated because their contents
-///   may be mutated.
-///
-/// * WebAssembly memories can grow, and growth may change the base pointer.
-///   This means that even holding a raw pointer to memory over a wasm function
-///   call is also incorrect. Anywhere in the function call the base address of
-///   memory may change. Note that growth can also be requested from the
-///   embedding API as well.
-///
-/// As a general rule of thumb it's recommended to stick to the safe methods of
-/// [`Memory`] if you can. It's not advised to use raw pointers or `unsafe`
-/// operations because of how easy it is to accidentally get things wrong.
-///
-/// Some examples of safely interacting with memory are:
-///
-/// ```rust
-/// use wasmtime::{Memory, Store, MemoryAccessError};
-///
-/// // Memory can be read and written safely with the `Memory::read` and
-/// // `Memory::write` methods.
-/// // An error is returned if the copy did not succeed.
-/// fn safe_examples(mem: Memory, store: &mut Store<()>) -> Result<(), MemoryAccessError> {
-///     let offset = 5;
-///     mem.write(&mut *store, offset, b"hello")?;
-///     let mut buffer = [0u8; 5];
-///     mem.read(&store, offset, &mut buffer)?;
-///     assert_eq!(b"hello", &buffer);
-///
-///     // Note that while this is safe care must be taken because the indexing
-///     // here may panic if the memory isn't large enough.
-///     assert_eq!(&mem.data(&store)[offset..offset + 5], b"hello");
-///     mem.data_mut(&mut *store)[offset..offset + 5].copy_from_slice(b"bye!!");
-///
-///     Ok(())
-/// }
-/// ```
-///
-/// It's worth also, however, covering some examples of **incorrect**,
-/// **unsafe** usages of `Memory`. Do not do these things!
-///
-/// ```rust
-/// # use anyhow::Result;
-/// use wasmtime::{Memory, Store};
-///
-/// // NOTE: All code in this function is not safe to execute and may cause
-/// // segfaults/undefined behavior at runtime. Do not copy/paste these examples
-/// // into production code!
-/// unsafe fn unsafe_examples(mem: Memory, store: &mut Store<()>) -> Result<()> {
-///     // First and foremost, any borrow can be invalidated at any time via the
-///     // `Memory::grow` function. This can relocate memory which causes any
-///     // previous pointer to be possibly invalid now.
-///     let pointer: &u8 = &*mem.data_ptr(&store);
-///     mem.grow(&mut *store, 1)?; // invalidates `pointer`!
-///     // println!("{}", *pointer); // FATAL: use-after-free
-///
-///     // Note that the use-after-free also applies to slices, whether they're
-///     // slices of bytes or strings.
-///     let mem_slice = std::slice::from_raw_parts(
-///         mem.data_ptr(&store),
-///         mem.data_size(&store),
-///     );
-///     let slice: &[u8] = &mem_slice[0x100..0x102];
-///     mem.grow(&mut *store, 1)?; // invalidates `slice`!
-///     // println!("{:?}", slice); // FATAL: use-after-free
-///
-///     // The `Memory` type may be stored in other locations, so if you hand
-///     // off access to the `Store` then those locations may also call
-///     // `Memory::grow` or similar, so it's not enough to just audit code for
-///     // calls to `Memory::grow`.
-///     let pointer: &u8 = &*mem.data_ptr(&store);
-///     some_other_function(store); // may invalidate `pointer` through use of `store`
-///     // println!("{:?}", pointer); // FATAL: maybe a use-after-free
-///
-///     // An especially subtle aspect of accessing a wasm instance's memory is
-///     // that you need to be extremely careful about aliasing. Anyone at any
-///     // time can call `data_unchecked()` or `data_unchecked_mut()`, which
-///     // means you can easily have aliasing mutable references:
-///     let ref1: &u8 = &*mem.data_ptr(&store).add(0x100);
-///     let ref2: &mut u8 = &mut *mem.data_ptr(&store).add(0x100);
-///     // *ref2 = *ref1; // FATAL: violates Rust's aliasing rules
-///
-///     Ok(())
-/// }
-/// # fn some_other_function(store: &mut Store<()>) {}
-/// ```
-///
-/// Overall there's some general rules of thumb when unsafely working with
-/// `Memory` and getting raw pointers inside of it:
-///
-/// * If you never have a "long lived" pointer into memory, you're likely in the
-///   clear. Care still needs to be taken in threaded scenarios or when/where
-///   data is read, but you'll be shielded from many classes of issues.
-/// * Long-lived pointers must always respect Rust'a aliasing rules. It's ok for
-///   shared borrows to overlap with each other, but mutable borrows must
-///   overlap with nothing.
-/// * Long-lived pointers are only valid if they're not invalidated for their
-///   lifetime. This means that [`Store`](crate::Store) isn't used to reenter
-///   wasm or the memory itself is never grown or otherwise modified/aliased.
-///
-/// At this point it's worth reiterating again that unsafely working with
-/// `Memory` is pretty tricky and not recommended! It's highly recommended to
-/// use the safe methods to interact with [`Memory`] whenever possible.
-///
-/// ## `Memory` Safety and Threads
-///
-/// Currently the `wasmtime` crate does not implement the wasm threads proposal,
-/// but it is planned to do so. It may be interesting to readers to see how this
-/// affects memory safety and what was previously just discussed as well.
-///
-/// Once threads are added into the mix, all of the above rules still apply.
-/// There's an additional consideration that all reads and writes can happen
-/// concurrently, though. This effectively means that any borrow into wasm
-/// memory are virtually never safe to have.
-///
-/// Mutable pointers are fundamentally unsafe to have in a concurrent scenario
-/// in the face of arbitrary wasm code. Only if you dynamically know for sure
-/// that wasm won't access a region would it be safe to construct a mutable
-/// pointer. Additionally even shared pointers are largely unsafe because their
-/// underlying contents may change, so unless `UnsafeCell` in one form or
-/// another is used everywhere there's no safety.
-///
-/// One important point about concurrency is that while [`Memory::grow`] can
-/// happen concurrently it will never relocate the base pointer. Shared
-/// memories must always have a maximum size and they will be preallocated such
-/// that growth will never relocate the base pointer. The current size of the
-/// memory may still change over time though.
-///
-/// Overall the general rule of thumb for shared memories is that you must
-/// atomically read and write everything. Nothing can be borrowed and everything
-/// must be eagerly copied out. This means that [`Memory::data`] and
-/// [`Memory::data_mut`] won't work in the future (they'll probably return an
-/// error) for shared memories when they're implemented. When possible it's
-/// recommended to use [`Memory::read`] and [`Memory::write`] which will still
-/// be provided.
-#[derive(Copy, Clone, Debug)]
-#[repr(transparent)] // here for the C API
-pub struct Memory(Stored<wasmtime_runtime::ExportMemory>);
-
-impl Memory {
-    /// Creates a new WebAssembly memory given the configuration of `ty`.
-    ///
-    /// The `store` argument will be the owner of the returned [`Memory`]. All
-    /// WebAssembly memory is initialized to zero.
-    ///
-    /// # Panics
-    ///
-    /// This function will panic if the [`Store`](`crate::Store`) has a
-    /// [`ResourceLimiterAsync`](`crate::ResourceLimiterAsync`) (see also:
-    /// [`Store::limiter_async`](`crate::Store::limiter_async`)). When
-    /// using an async resource limiter, use [`Memory::new_async`] instead.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// let engine = Engine::default();
-    /// let mut store = Store::new(&engine, ());
-    ///
-    /// let memory_ty = MemoryType::new(1, None);
-    /// let memory = Memory::new(&mut store, memory_ty)?;
-    ///
-    /// let module = Module::new(&engine, "(module (memory (import \"\" \"\") 1))")?;
-    /// let instance = Instance::new(&mut store, &module, &[memory.into()])?;
-    /// // ...
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn new(mut store: impl AsContextMut, ty: MemoryType) -> Result<Memory> {
-        Self::_new(store.as_context_mut().0, ty)
-    }
-
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "async")))]
-    /// Async variant of [`Memory::new`]. You must use this variant with
-    /// [`Store`](`crate::Store`)s which have a
-    /// [`ResourceLimiterAsync`](`crate::ResourceLimiterAsync`).
-    ///
-    /// # Panics
-    ///
-    /// This function will panic when used with a non-async
-    /// [`Store`](`crate::Store`).
-    #[cfg(feature = "async")]
-    pub async fn new_async<T>(
-        mut store: impl AsContextMut<Data = T>,
-        ty: MemoryType,
-    ) -> Result<Memory>
-    where
-        T: Send,
-    {
-        let mut store = store.as_context_mut();
-        assert!(
-            store.0.async_support(),
-            "cannot use `new_async` without enabling async support on the config"
-        );
-        store.on_fiber(|store| Self::_new(store.0, ty)).await?
-    }
-
-    /// Helper function for attaching the memory to a "frankenstein" instance
-    fn _new(store: &mut StoreOpaque, ty: MemoryType) -> Result<Memory> {
-        unsafe {
-            let export = generate_memory_export(store, &ty, None)?;
-            Ok(Memory::from_wasmtime_memory(export, store))
-        }
-    }
-
-    /// Returns the underlying type of this memory.
-    ///
-    /// # Panics
-    ///
-    /// Panics if this memory doesn't belong to `store`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// let engine = Engine::default();
-    /// let mut store = Store::new(&engine, ());
-    /// let module = Module::new(&engine, "(module (memory (export \"mem\") 1))")?;
-    /// let instance = Instance::new(&mut store, &module, &[])?;
-    /// let memory = instance.get_memory(&mut store, "mem").unwrap();
-    /// let ty = memory.ty(&store);
-    /// assert_eq!(ty.minimum(), 1);
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn ty(&self, store: impl AsContext) -> MemoryType {
-        let store = store.as_context();
-        let ty = &store[self.0].memory.memory;
-        MemoryType::from_wasmtime_memory(&ty)
-    }
-
-    /// Safely reads memory contents at the given offset into a buffer.
-    ///
-    /// The entire buffer will be filled.
-    ///
-    /// If `offset + buffer.len()` exceed the current memory capacity, then the
-    /// buffer is left untouched and a [`MemoryAccessError`] is returned.
-    ///
-    /// # Panics
-    ///
-    /// Panics if this memory doesn't belong to `store`.
-    pub fn read(
-        &self,
-        store: impl AsContext,
-        offset: usize,
-        buffer: &mut [u8],
-    ) -> Result<(), MemoryAccessError> {
-        let store = store.as_context();
-        let slice = self
-            .data(&store)
-            .get(offset..)
-            .and_then(|s| s.get(..buffer.len()))
-            .ok_or(MemoryAccessError { _private: () })?;
-        buffer.copy_from_slice(slice);
-        Ok(())
-    }
-
-    /// Safely writes contents of a buffer to this memory at the given offset.
-    ///
-    /// If the `offset + buffer.len()` exceeds the current memory capacity, then
-    /// none of the buffer is written to memory and a [`MemoryAccessError`] is
-    /// returned.
-    ///
-    /// # Panics
-    ///
-    /// Panics if this memory doesn't belong to `store`.
-    pub fn write(
-        &self,
-        mut store: impl AsContextMut,
-        offset: usize,
-        buffer: &[u8],
-    ) -> Result<(), MemoryAccessError> {
-        let mut context = store.as_context_mut();
-        self.data_mut(&mut context)
-            .get_mut(offset..)
-            .and_then(|s| s.get_mut(..buffer.len()))
-            .ok_or(MemoryAccessError { _private: () })?
-            .copy_from_slice(buffer);
-        Ok(())
-    }
-
-    /// Returns this memory as a native Rust slice.
-    ///
-    /// Note that this method will consider the entire store context provided as
-    /// borrowed for the duration of the lifetime of the returned slice.
-    ///
-    /// # Panics
-    ///
-    /// Panics if this memory doesn't belong to `store`.
-    pub fn data<'a, T: 'a>(&self, store: impl Into<StoreContext<'a, T>>) -> &'a [u8] {
-        unsafe {
-            let store = store.into();
-            let definition = &*store[self.0].definition;
-            debug_assert!(!self.ty(store).is_shared());
-            slice::from_raw_parts(definition.base, definition.current_length())
-        }
-    }
-
-    /// Returns this memory as a native Rust mutable slice.
-    ///
-    /// Note that this method will consider the entire store context provided as
-    /// borrowed for the duration of the lifetime of the returned slice.
-    ///
-    /// # Panics
-    ///
-    /// Panics if this memory doesn't belong to `store`.
-    pub fn data_mut<'a, T: 'a>(&self, store: impl Into<StoreContextMut<'a, T>>) -> &'a mut [u8] {
-        unsafe {
-            let store = store.into();
-            let definition = &*store[self.0].definition;
-            debug_assert!(!self.ty(store).is_shared());
-            slice::from_raw_parts_mut(definition.base, definition.current_length())
-        }
-    }
-
-    /// Same as [`Memory::data_mut`], but also returns the `T` from the
-    /// [`StoreContextMut`].
-    ///
-    /// This method can be used when you want to simultaneously work with the
-    /// `T` in the store as well as the memory behind this [`Memory`]. Using
-    /// [`Memory::data_mut`] would consider the entire store borrowed, whereas
-    /// this method allows the Rust compiler to see that the borrow of this
-    /// memory and the borrow of `T` are disjoint.
-    ///
-    /// # Panics
-    ///
-    /// Panics if this memory doesn't belong to `store`.
-    pub fn data_and_store_mut<'a, T: 'a>(
-        &self,
-        store: impl Into<StoreContextMut<'a, T>>,
-    ) -> (&'a mut [u8], &'a mut T) {
-        // Note the unsafety here. Our goal is to simultaneously borrow the
-        // memory and custom data from `store`, and the store it's connected
-        // to. Rust will not let us do that, however, because we must call two
-        // separate methods (both of which borrow the whole `store`) and one of
-        // our borrows is mutable (the custom data).
-        //
-        // This operation, however, is safe because these borrows do not overlap
-        // and in the process of borrowing them mutability doesn't actually
-        // touch anything. This is akin to mutably borrowing two indices in an
-        // array, which is safe so long as the indices are separate.
-        unsafe {
-            let mut store = store.into();
-            let data = &mut *(store.data_mut() as *mut T);
-            (self.data_mut(store), data)
-        }
-    }
-
-    /// Returns the base pointer, in the host's address space, that the memory
-    /// is located at.
-    ///
-    /// For more information and examples see the documentation on the
-    /// [`Memory`] type.
-    ///
-    /// # Panics
-    ///
-    /// Panics if this memory doesn't belong to `store`.
-    pub fn data_ptr(&self, store: impl AsContext) -> *mut u8 {
-        unsafe { (*store.as_context()[self.0].definition).base }
-    }
-
-    /// Returns the byte length of this memory.
-    ///
-    /// The returned value will be a multiple of the wasm page size, 64k.
-    ///
-    /// For more information and examples see the documentation on the
-    /// [`Memory`] type.
-    ///
-    /// # Panics
-    ///
-    /// Panics if this memory doesn't belong to `store`.
-    pub fn data_size(&self, store: impl AsContext) -> usize {
-        self.internal_data_size(store.as_context().0)
-    }
-
-    pub(crate) fn internal_data_size(&self, store: &StoreOpaque) -> usize {
-        unsafe { (*store[self.0].definition).current_length() }
-    }
-
-    /// Returns the size, in WebAssembly pages, of this wasm memory.
-    ///
-    /// # Panics
-    ///
-    /// Panics if this memory doesn't belong to `store`.
-    pub fn size(&self, store: impl AsContext) -> u64 {
-        self.internal_size(store.as_context().0)
-    }
-
-    pub(crate) fn internal_size(&self, store: &StoreOpaque) -> u64 {
-        (self.internal_data_size(store) / wasmtime_environ::WASM_PAGE_SIZE as usize) as u64
-    }
-
-    /// Grows this WebAssembly memory by `delta` pages.
-    ///
-    /// This will attempt to add `delta` more pages of memory on to the end of
-    /// this `Memory` instance. If successful this may relocate the memory and
-    /// cause [`Memory::data_ptr`] to return a new value. Additionally any
-    /// unsafely constructed slices into this memory may no longer be valid.
-    ///
-    /// On success returns the number of pages this memory previously had
-    /// before the growth succeeded.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if memory could not be grown, for example if it exceeds
-    /// the maximum limits of this memory. A
-    /// [`ResourceLimiter`](crate::ResourceLimiter) is another example of
-    /// preventing a memory to grow.
-    ///
-    /// # Panics
-    ///
-    /// Panics if this memory doesn't belong to `store`.
-    ///
-    /// This function will panic if the [`Store`](`crate::Store`) has a
-    /// [`ResourceLimiterAsync`](`crate::ResourceLimiterAsync`) (see also:
-    /// [`Store::limiter_async`](`crate::Store::limiter_async`). When using an
-    /// async resource limiter, use [`Memory::grow_async`] instead.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// let engine = Engine::default();
-    /// let mut store = Store::new(&engine, ());
-    /// let module = Module::new(&engine, "(module (memory (export \"mem\") 1 2))")?;
-    /// let instance = Instance::new(&mut store, &module, &[])?;
-    /// let memory = instance.get_memory(&mut store, "mem").unwrap();
-    ///
-    /// assert_eq!(memory.size(&store), 1);
-    /// assert_eq!(memory.grow(&mut store, 1)?, 1);
-    /// assert_eq!(memory.size(&store), 2);
-    /// assert!(memory.grow(&mut store, 1).is_err());
-    /// assert_eq!(memory.size(&store), 2);
-    /// assert_eq!(memory.grow(&mut store, 0)?, 2);
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn grow(&self, mut store: impl AsContextMut, delta: u64) -> Result<u64> {
-        let store = store.as_context_mut().0;
-        let mem = self.wasmtime_memory(store);
-        unsafe {
-            match (*mem).grow(delta, Some(store))? {
-                Some(size) => {
-                    let vm = (*mem).vmmemory();
-                    *store[self.0].definition = vm;
-                    Ok(u64::try_from(size).unwrap() / u64::from(wasmtime_environ::WASM_PAGE_SIZE))
-                }
-                None => bail!("failed to grow memory by `{}`", delta),
-            }
-        }
-    }
-
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "async")))]
-    /// Async variant of [`Memory::grow`]. Required when using a
-    /// [`ResourceLimiterAsync`](`crate::ResourceLimiterAsync`).
-    ///
-    /// # Panics
-    ///
-    /// This function will panic when used with a non-async
-    /// [`Store`](`crate::Store`).
-    #[cfg(feature = "async")]
-    pub async fn grow_async<T>(
-        &self,
-        mut store: impl AsContextMut<Data = T>,
-        delta: u64,
-    ) -> Result<u64>
-    where
-        T: Send,
-    {
-        let mut store = store.as_context_mut();
-        assert!(
-            store.0.async_support(),
-            "cannot use `grow_async` without enabling async support on the config"
-        );
-        store.on_fiber(|store| self.grow(store, delta)).await?
-    }
-
-    fn wasmtime_memory(&self, store: &mut StoreOpaque) -> *mut wasmtime_runtime::Memory {
-        unsafe {
-            let export = &store[self.0];
-            wasmtime_runtime::Instance::from_vmctx(export.vmctx, |handle| {
-                handle.get_defined_memory(export.index)
-            })
-        }
-    }
-
-    pub(crate) unsafe fn from_wasmtime_memory(
-        wasmtime_export: wasmtime_runtime::ExportMemory,
-        store: &mut StoreOpaque,
-    ) -> Memory {
-        Memory(store.store_data_mut().insert(wasmtime_export))
-    }
-
-    pub(crate) fn wasmtime_ty<'a>(&self, store: &'a StoreData) -> &'a wasmtime_environ::Memory {
-        &store[self.0].memory.memory
-    }
-
-    pub(crate) fn vmimport(&self, store: &StoreOpaque) -> wasmtime_runtime::VMMemoryImport {
-        let export = &store[self.0];
-        wasmtime_runtime::VMMemoryImport {
-            from: export.definition,
-            vmctx: export.vmctx,
-            index: export.index,
-        }
-    }
-
-    pub(crate) fn comes_from_same_store(&self, store: &StoreOpaque) -> bool {
-        store.store_data().contains(self.0)
-    }
-
-    /// Get a stable hash key for this memory.
-    ///
-    /// Even if the same underlying memory definition is added to the
-    /// `StoreData` multiple times and becomes multiple `wasmtime::Memory`s,
-    /// this hash key will be consistent across all of these memories.
-    pub(crate) fn hash_key(&self, store: &StoreOpaque) -> impl std::hash::Hash + Eq {
-        store[self.0].definition as usize
-    }
-}
-
-/// A linear memory. This trait provides an interface for raw memory buffers
-/// which are used by wasmtime, e.g. inside ['Memory']. Such buffers are in
-/// principle not thread safe. By implementing this trait together with
-/// MemoryCreator, one can supply wasmtime with custom allocated host managed
-/// memory.
-///
-/// # Safety
-///
-/// The memory should be page aligned and a multiple of page size.
-/// To prevent possible silent overflows, the memory should be protected by a
-/// guard page.  Additionally the safety concerns explained in ['Memory'], for
-/// accessing the memory apply here as well.
-///
-/// Note that this is a relatively new and experimental feature and it is
-/// recommended to be familiar with wasmtime runtime code to use it.
-pub unsafe trait LinearMemory: Send + Sync + 'static {
-    /// Returns the number of allocated bytes which are accessible at this time.
-    fn byte_size(&self) -> usize;
-
-    /// Returns the maximum number of bytes the memory can grow to.
-    ///
-    /// Returns `None` if the memory is unbounded, or `Some` if memory cannot
-    /// grow beyond a specified limit.
-    fn maximum_byte_size(&self) -> Option<usize>;
-
-    /// Grows this memory to have the `new_size`, in bytes, specified.
-    ///
-    /// Returns `Err` if memory can't be grown by the specified amount
-    /// of bytes. The error may be downcastable to `std::io::Error`.
-    /// Returns `Ok` if memory was grown successfully.
-    fn grow_to(&mut self, new_size: usize) -> Result<()>;
-
-    /// Return the allocated memory as a mutable pointer to u8.
-    fn as_ptr(&self) -> *mut u8;
-
-    /// Returns the range of native addresses that WebAssembly can natively
-    /// access from this linear memory, including guard pages.
-    fn wasm_accessible(&self) -> Range<usize>;
-}
-
-/// A memory creator. Can be used to provide a memory creator
-/// to wasmtime which supplies host managed memory.
-///
-/// # Safety
-///
-/// This trait is unsafe, as the memory safety depends on proper implementation
-/// of memory management. Memories created by the MemoryCreator should always be
-/// treated as owned by wasmtime instance, and any modification of them outside
-/// of wasmtime invoked routines is unsafe and may lead to corruption.
-///
-/// Note that this is a relatively new and experimental feature and it is
-/// recommended to be familiar with wasmtime runtime code to use it.
-pub unsafe trait MemoryCreator: Send + Sync {
-    /// Create a new `LinearMemory` object from the specified parameters.
-    ///
-    /// The type of memory being created is specified by `ty` which indicates
-    /// both the minimum and maximum size, in wasm pages. The minimum and
-    /// maximum sizes, in bytes, are also specified as parameters to avoid
-    /// integer conversion if desired.
-    ///
-    /// The `reserved_size_in_bytes` value indicates the expected size of the
-    /// reservation that is to be made for this memory. If this value is `None`
-    /// than the implementation is free to allocate memory as it sees fit. If
-    /// the value is `Some`, however, then the implementation is expected to
-    /// reserve that many bytes for the memory's allocation, plus the guard
-    /// size at the end. Note that this reservation need only be a virtual
-    /// memory reservation, physical memory does not need to be allocated
-    /// immediately. In this case `grow` should never move the base pointer and
-    /// the maximum size of `ty` is guaranteed to fit within
-    /// `reserved_size_in_bytes`.
-    ///
-    /// The `guard_size_in_bytes` parameter indicates how many bytes of space,
-    /// after the memory allocation, is expected to be unmapped. JIT code will
-    /// elide bounds checks based on the `guard_size_in_bytes` provided, so for
-    /// JIT code to work correctly the memory returned will need to be properly
-    /// guarded with `guard_size_in_bytes` bytes left unmapped after the base
-    /// allocation.
-    ///
-    /// Note that the `reserved_size_in_bytes` and `guard_size_in_bytes` options
-    /// are tuned from the various [`Config`](crate::Config) methods about
-    /// memory sizes/guards. Additionally these two values are guaranteed to be
-    /// multiples of the system page size.
-    fn new_memory(
-        &self,
-        ty: MemoryType,
-        minimum: usize,
-        maximum: Option<usize>,
-        reserved_size_in_bytes: Option<usize>,
-        guard_size_in_bytes: usize,
-    ) -> Result<Box<dyn LinearMemory>, String>;
-}
-
-/// A constructor for externally-created shared memory.
-///
-/// The [threads proposal] adds the concept of "shared memory" to WebAssembly.
-/// This is much the same as a Wasm linear memory (i.e., [`Memory`]), but can be
-/// used concurrently by multiple agents. Because these agents may execute in
-/// different threads, [`SharedMemory`] must be thread-safe.
-///
-/// When the threads proposal is enabled, there are multiple ways to construct
-/// shared memory:
-///  1. for imported shared memory, e.g., `(import "env" "memory" (memory 1 1
-///     shared))`, the user must supply a [`SharedMemory`] with the
-///     externally-created memory as an import to the instance--e.g.,
-///     `shared_memory.into()`.
-///  2. for private or exported shared memory, e.g., `(export "env" "memory"
-///     (memory 1 1 shared))`, Wasmtime will create the memory internally during
-///     instantiation--access using `Instance::get_shared_memory()`.
-///
-/// [threads proposal]:
-///     https://github.com/WebAssembly/threads/blob/master/proposals/threads/Overview.md
-///
-/// # Examples
-///
-/// ```
-/// # use wasmtime::*;
-/// # fn main() -> anyhow::Result<()> {
-/// let mut config = Config::new();
-/// config.wasm_threads(true);
-/// let engine = Engine::new(&config)?;
-/// let mut store = Store::new(&engine, ());
-///
-/// let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, 2))?;
-/// let module = Module::new(&engine, r#"(module (memory (import "" "") 1 2 shared))"#)?;
-/// let instance = Instance::new(&mut store, &module, &[shared_memory.into()])?;
-/// // ...
-/// # Ok(())
-/// # }
-/// ```
-#[derive(Clone)]
-pub struct SharedMemory(wasmtime_runtime::SharedMemory, Engine);
-
-impl SharedMemory {
-    /// Construct a [`SharedMemory`] by providing both the `minimum` and
-    /// `maximum` number of 64K-sized pages. This call allocates the necessary
-    /// pages on the system.
-    pub fn new(engine: &Engine, ty: MemoryType) -> Result<Self> {
-        if !ty.is_shared() {
-            bail!("shared memory must have the `shared` flag enabled on its memory type")
-        }
-        debug_assert!(ty.maximum().is_some());
-
-        let tunables = &engine.config().tunables;
-        let plan = MemoryPlan::for_memory(ty.wasmtime_memory().clone(), tunables);
-        let memory = wasmtime_runtime::SharedMemory::new(plan)?;
-        Ok(Self(memory, engine.clone()))
-    }
-
-    /// Return the type of the shared memory.
-    pub fn ty(&self) -> MemoryType {
-        MemoryType::from_wasmtime_memory(&self.0.ty())
-    }
-
-    /// Returns the size, in WebAssembly pages, of this wasm memory.
-    pub fn size(&self) -> u64 {
-        (self.data_size() / wasmtime_environ::WASM_PAGE_SIZE as usize) as u64
-    }
-
-    /// Returns the byte length of this memory.
-    ///
-    /// The returned value will be a multiple of the wasm page size, 64k.
-    ///
-    /// For more information and examples see the documentation on the
-    /// [`Memory`] type.
-    pub fn data_size(&self) -> usize {
-        self.0.byte_size()
-    }
-
-    /// Return access to the available portion of the shared memory.
-    ///
-    /// The slice returned represents the region of accessible memory at the
-    /// time that this function was called. The contents of the returned slice
-    /// will reflect concurrent modifications happening on other threads.
-    ///
-    /// # Safety
-    ///
-    /// The returned slice is valid for the entire duration of the lifetime of
-    /// this instance of [`SharedMemory`]. The base pointer of a shared memory
-    /// does not change. This [`SharedMemory`] may grow further after this
-    /// function has been called, but the slice returned will not grow.
-    ///
-    /// Concurrent modifications may be happening to the data returned on other
-    /// threads. The `UnsafeCell<u8>` represents that safe access to the
-    /// contents of the slice is not possible through normal loads and stores.
-    ///
-    /// The memory returned must be accessed safely through the `Atomic*` types
-    /// in the [`std::sync::atomic`] module. Casting to those types must
-    /// currently be done unsafely.
-    pub fn data(&self) -> &[UnsafeCell<u8>] {
-        unsafe {
-            let definition = &*self.0.vmmemory_ptr();
-            slice::from_raw_parts(definition.base.cast(), definition.current_length())
-        }
-    }
-
-    /// Grows this WebAssembly memory by `delta` pages.
-    ///
-    /// This will attempt to add `delta` more pages of memory on to the end of
-    /// this `Memory` instance. If successful this may relocate the memory and
-    /// cause [`Memory::data_ptr`] to return a new value. Additionally any
-    /// unsafely constructed slices into this memory may no longer be valid.
-    ///
-    /// On success returns the number of pages this memory previously had
-    /// before the growth succeeded.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if memory could not be grown, for example if it exceeds
-    /// the maximum limits of this memory. A
-    /// [`ResourceLimiter`](crate::ResourceLimiter) is another example of
-    /// preventing a memory to grow.
-    pub fn grow(&self, delta: u64) -> Result<u64> {
-        match self.0.grow(delta, None)? {
-            Some((old_size, _new_size)) => {
-                // For shared memory, the `VMMemoryDefinition` is updated inside
-                // the locked region.
-                Ok(u64::try_from(old_size).unwrap() / u64::from(wasmtime_environ::WASM_PAGE_SIZE))
-            }
-            None => bail!("failed to grow memory by `{}`", delta),
-        }
-    }
-
-    /// Equivalent of the WebAssembly `memory.atomic.notify` instruction for
-    /// this shared memory.
-    ///
-    /// This method allows embedders to notify threads blocked on the specified
-    /// `addr`, an index into wasm linear memory. Threads could include
-    /// wasm threads blocked on a `memory.atomic.wait*` instruction or embedder
-    /// threads blocked on [`SharedMemory::atomic_wait32`], for example.
-    ///
-    /// The `count` argument is the number of threads to wake up.
-    ///
-    /// This function returns the number of threads awoken.
-    ///
-    /// # Errors
-    ///
-    /// This function will return an error if `addr` is not within bounds or
-    /// not aligned to a 4-byte boundary.
-    pub fn atomic_notify(&self, addr: u64, count: u32) -> Result<u32, Trap> {
-        self.0.atomic_notify(addr, count)
-    }
-
-    /// Equivalent of the WebAssembly `memory.atomic.wait32` instruction for
-    /// this shared memory.
-    ///
-    /// This method allows embedders to block the current thread until notified
-    /// via the `memory.atomic.notify` instruction or the
-    /// [`SharedMemory::atomic_notify`] method, enabling synchronization with
-    /// the wasm guest as desired.
-    ///
-    /// The `expected` argument is the expected 32-bit value to be stored at
-    /// the byte address `addr` specified. The `addr` specified is an index
-    /// into this linear memory.
-    ///
-    /// The optional `timeout` argument is the point in time after which the
-    /// calling thread is guaranteed to be woken up. Blocking will not occur
-    /// past this point.
-    ///
-    /// This function returns one of three possible values:
-    ///
-    /// * `WaitResult::Ok` - this function, loaded the value at `addr`, found
-    ///   it was equal to `expected`, and then blocked (all as one atomic
-    ///   operation). The thread was then awoken with a `memory.atomic.notify`
-    ///   instruction or the [`SharedMemory::atomic_notify`] method.
-    /// * `WaitResult::Mismatch` - the value at `addr` was loaded but was not
-    ///   equal to `expected` so the thread did not block and immediately
-    ///   returned.
-    /// * `WaitResult::TimedOut` - all the steps of `Ok` happened, except this
-    ///   thread was woken up due to a timeout.
-    ///
-    /// This function will not return due to spurious wakeups.
-    ///
-    /// # Errors
-    ///
-    /// This function will return an error if `addr` is not within bounds or
-    /// not aligned to a 4-byte boundary.
-    pub fn atomic_wait32(
-        &self,
-        addr: u64,
-        expected: u32,
-        timeout: Option<Instant>,
-    ) -> Result<WaitResult, Trap> {
-        self.0.atomic_wait32(addr, expected, timeout)
-    }
-
-    /// Equivalent of the WebAssembly `memory.atomic.wait64` instruction for
-    /// this shared memory.
-    ///
-    /// For more information see [`SharedMemory::atomic_wait32`].
-    ///
-    /// # Errors
-    ///
-    /// Returns the same error as [`SharedMemory::atomic_wait32`] except that
-    /// the specified address must be 8-byte aligned instead of 4-byte aligned.
-    pub fn atomic_wait64(
-        &self,
-        addr: u64,
-        expected: u64,
-        timeout: Option<Instant>,
-    ) -> Result<WaitResult, Trap> {
-        self.0.atomic_wait64(addr, expected, timeout)
-    }
-
-    /// Return a reference to the [`Engine`] used to configure the shared
-    /// memory.
-    pub(crate) fn engine(&self) -> &Engine {
-        &self.1
-    }
-
-    /// Construct a single-memory instance to provide a way to import
-    /// [`SharedMemory`] into other modules.
-    pub(crate) fn vmimport(&self, store: &mut StoreOpaque) -> wasmtime_runtime::VMMemoryImport {
-        let export_memory = generate_memory_export(store, &self.ty(), Some(&self.0)).unwrap();
-        VMMemoryImport {
-            from: export_memory.definition,
-            vmctx: export_memory.vmctx,
-            index: export_memory.index,
-        }
-    }
-
-    /// Create a [`SharedMemory`] from an [`ExportMemory`] definition. This
-    /// function is available to handle the case in which a Wasm module exports
-    /// shared memory and the user wants host-side access to it.
-    pub(crate) unsafe fn from_wasmtime_memory(
-        wasmtime_export: wasmtime_runtime::ExportMemory,
-        store: &mut StoreOpaque,
-    ) -> Self {
-        wasmtime_runtime::Instance::from_vmctx(wasmtime_export.vmctx, |handle| {
-            let memory = handle
-                .get_defined_memory(wasmtime_export.index)
-                .as_mut()
-                .unwrap();
-            let shared_memory = memory
-                .as_shared_memory()
-                .expect("unable to convert from a shared memory")
-                .clone();
-            Self(shared_memory, store.engine().clone())
-        })
-    }
-}
-
-impl std::fmt::Debug for SharedMemory {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("SharedMemory").finish_non_exhaustive()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::*;
-
-    // Assert that creating a memory via `Memory::new` respects the limits/tunables
-    // in `Config`.
-    #[test]
-    fn respect_tunables() {
-        let mut cfg = Config::new();
-        cfg.static_memory_maximum_size(0)
-            .dynamic_memory_guard_size(0);
-        let mut store = Store::new(&Engine::new(&cfg).unwrap(), ());
-        let ty = MemoryType::new(1, None);
-        let mem = Memory::new(&mut store, ty).unwrap();
-        let store = store.as_context();
-        assert_eq!(store[mem.0].memory.offset_guard_size, 0);
-        match &store[mem.0].memory.style {
-            wasmtime_environ::MemoryStyle::Dynamic { .. } => {}
-            other => panic!("unexpected style {:?}", other),
-        }
-    }
-
-    #[test]
-    fn hash_key_is_stable_across_duplicate_store_data_entries() -> Result<()> {
-        let mut store = Store::<()>::default();
-        let module = Module::new(
-            store.engine(),
-            r#"
-                (module
-                    (memory (export "m") 1 1)
-                )
-            "#,
-        )?;
-        let instance = Instance::new(&mut store, &module, &[])?;
-
-        // Each time we `get_memory`, we call `Memory::from_wasmtime` which adds
-        // a new entry to `StoreData`, so `g1` and `g2` will have different
-        // indices into `StoreData`.
-        let m1 = instance.get_memory(&mut store, "m").unwrap();
-        let m2 = instance.get_memory(&mut store, "m").unwrap();
-
-        // That said, they really point to the same memory.
-        assert_eq!(m1.data(&store)[0], 0);
-        assert_eq!(m2.data(&store)[0], 0);
-        m1.data_mut(&mut store)[0] = 42;
-        assert_eq!(m1.data(&mut store)[0], 42);
-        assert_eq!(m2.data(&mut store)[0], 42);
-
-        // And therefore their hash keys are the same.
-        assert!(m1.hash_key(&store.as_context().0) == m2.hash_key(&store.as_context().0));
-
-        // But the hash keys are different from different memories.
-        let instance2 = Instance::new(&mut store, &module, &[])?;
-        let m3 = instance2.get_memory(&mut store, "m").unwrap();
-        assert!(m1.hash_key(&store.as_context().0) != m3.hash_key(&store.as_context().0));
-
-        Ok(())
-    }
-}
diff --git a/crates/wasmtime/src/module.rs b/crates/wasmtime/src/module.rs
deleted file mode 100644
index 38a51fcd7ea0..000000000000
--- a/crates/wasmtime/src/module.rs
+++ /dev/null
@@ -1,1363 +0,0 @@
-use crate::{
-    code::CodeObject,
-    resources::ResourcesRequired,
-    signatures::SignatureCollection,
-    types::{ExportType, ExternType, ImportType},
-    Engine,
-};
-use anyhow::{bail, Context, Result};
-use once_cell::sync::OnceCell;
-use std::fs;
-use std::mem;
-use std::ops::Range;
-use std::path::Path;
-use std::ptr::NonNull;
-use std::sync::Arc;
-use wasmparser::{Parser, ValidPayload, Validator};
-use wasmtime_environ::{
-    DefinedFuncIndex, DefinedMemoryIndex, HostPtr, ModuleEnvironment, ModuleTypes, ObjectKind,
-    VMOffsets,
-};
-use wasmtime_jit::{CodeMemory, CompiledModule, CompiledModuleInfo};
-use wasmtime_runtime::{
-    CompiledModuleId, MemoryImage, MmapVec, ModuleMemoryImages, VMArrayCallFunction,
-    VMNativeCallFunction, VMSharedSignatureIndex, VMWasmCallFunction,
-};
-
-mod registry;
-
-pub use registry::{
-    is_wasm_trap_pc, register_code, unregister_code, ModuleRegistry, RegisteredModuleId,
-};
-
-/// A compiled WebAssembly module, ready to be instantiated.
-///
-/// A `Module` is a compiled in-memory representation of an input WebAssembly
-/// binary. A `Module` is then used to create an [`Instance`](crate::Instance)
-/// through an instantiation process. You cannot call functions or fetch
-/// globals, for example, on a `Module` because it's purely a code
-/// representation. Instead you'll need to create an
-/// [`Instance`](crate::Instance) to interact with the wasm module.
-///
-/// Creating a `Module` currently involves compiling code, meaning that it can
-/// be an expensive operation. All `Module` instances are compiled according to
-/// the configuration in [`Config`], but typically they're JIT-compiled. If
-/// you'd like to instantiate a module multiple times you can do so with
-/// compiling the original wasm module only once with a single [`Module`]
-/// instance.
-///
-/// The `Module` is thread-safe and safe to share across threads.
-///
-/// ## Modules and `Clone`
-///
-/// Using `clone` on a `Module` is a cheap operation. It will not create an
-/// entirely new module, but rather just a new reference to the existing module.
-/// In other words it's a shallow copy, not a deep copy.
-///
-/// ## Examples
-///
-/// There are a number of ways you can create a `Module`, for example pulling
-/// the bytes from a number of locations. One example is loading a module from
-/// the filesystem:
-///
-/// ```no_run
-/// # use wasmtime::*;
-/// # fn main() -> anyhow::Result<()> {
-/// let engine = Engine::default();
-/// let module = Module::from_file(&engine, "path/to/foo.wasm")?;
-/// # Ok(())
-/// # }
-/// ```
-///
-/// You can also load the wasm text format if more convenient too:
-///
-/// ```no_run
-/// # use wasmtime::*;
-/// # fn main() -> anyhow::Result<()> {
-/// let engine = Engine::default();
-/// // Now we're using the WebAssembly text extension: `.wat`!
-/// let module = Module::from_file(&engine, "path/to/foo.wat")?;
-/// # Ok(())
-/// # }
-/// ```
-///
-/// And if you've already got the bytes in-memory you can use the
-/// [`Module::new`] constructor:
-///
-/// ```no_run
-/// # use wasmtime::*;
-/// # fn main() -> anyhow::Result<()> {
-/// let engine = Engine::default();
-/// # let wasm_bytes: Vec<u8> = Vec::new();
-/// let module = Module::new(&engine, &wasm_bytes)?;
-///
-/// // It also works with the text format!
-/// let module = Module::new(&engine, "(module (func))")?;
-/// # Ok(())
-/// # }
-/// ```
-///
-/// [`Config`]: crate::Config
-#[derive(Clone)]
-pub struct Module {
-    inner: Arc<ModuleInner>,
-}
-
-struct ModuleInner {
-    engine: Engine,
-    /// The compiled artifacts for this module that will be instantiated and
-    /// executed.
-    module: CompiledModule,
-
-    /// Runtime information such as the underlying mmap, type information, etc.
-    ///
-    /// Note that this `Arc` is used to share information between compiled
-    /// modules within a component. For bare core wasm modules created with
-    /// `Module::new`, for example, this is a uniquely owned `Arc`.
-    code: Arc<CodeObject>,
-
-    /// A set of initialization images for memories, if any.
-    ///
-    /// Note that this is behind a `OnceCell` to lazily create this image. On
-    /// Linux where `memfd_create` may be used to create the backing memory
-    /// image this is a pretty expensive operation, so by deferring it this
-    /// improves memory usage for modules that are created but may not ever be
-    /// instantiated.
-    memory_images: OnceCell<Option<ModuleMemoryImages>>,
-
-    /// Flag indicating whether this module can be serialized or not.
-    serializable: bool,
-
-    /// Runtime offset information for `VMContext`.
-    offsets: VMOffsets<HostPtr>,
-}
-
-impl std::fmt::Debug for Module {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("Module")
-            .field("name", &self.name())
-            .finish_non_exhaustive()
-    }
-}
-
-impl Module {
-    /// Creates a new WebAssembly `Module` from the given in-memory `bytes`.
-    ///
-    /// The `bytes` provided must be in one of the following formats:
-    ///
-    /// * A [binary-encoded][binary] WebAssembly module. This is always supported.
-    /// * A [text-encoded][text] instance of the WebAssembly text format.
-    ///   This is only supported when the `wat` feature of this crate is enabled.
-    ///   If this is supplied then the text format will be parsed before validation.
-    ///   Note that the `wat` feature is enabled by default.
-    ///
-    /// The data for the wasm module must be loaded in-memory if it's present
-    /// elsewhere, for example on disk. This requires that the entire binary is
-    /// loaded into memory all at once, this API does not support streaming
-    /// compilation of a module.
-    ///
-    /// If the module has not been already been compiled, the WebAssembly binary will
-    /// be decoded and validated. It will also be compiled according to the
-    /// configuration of the provided `engine`.
-    ///
-    /// # Errors
-    ///
-    /// This function may fail and return an error. Errors may include
-    /// situations such as:
-    ///
-    /// * The binary provided could not be decoded because it's not a valid
-    ///   WebAssembly binary
-    /// * The WebAssembly binary may not validate (e.g. contains type errors)
-    /// * Implementation-specific limits were exceeded with a valid binary (for
-    ///   example too many locals)
-    /// * The wasm binary may use features that are not enabled in the
-    ///   configuration of `engine`
-    /// * If the `wat` feature is enabled and the input is text, then it may be
-    ///   rejected if it fails to parse.
-    ///
-    /// The error returned should contain full information about why module
-    /// creation failed if one is returned.
-    ///
-    /// [binary]: https://webassembly.github.io/spec/core/binary/index.html
-    /// [text]: https://webassembly.github.io/spec/core/text/index.html
-    ///
-    /// # Examples
-    ///
-    /// The `new` function can be invoked with a in-memory array of bytes:
-    ///
-    /// ```no_run
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// # let engine = Engine::default();
-    /// # let wasm_bytes: Vec<u8> = Vec::new();
-    /// let module = Module::new(&engine, &wasm_bytes)?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    ///
-    /// Or you can also pass in a string to be parsed as the wasm text
-    /// format:
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// # let engine = Engine::default();
-    /// let module = Module::new(&engine, "(module (func))")?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    #[cfg(any(feature = "cranelift", feature = "winch"))]
-    #[cfg_attr(nightlydoc, doc(cfg(any(feature = "cranelift", feature = "winch"))))]
-    pub fn new(engine: &Engine, bytes: impl AsRef<[u8]>) -> Result<Module> {
-        let bytes = bytes.as_ref();
-        #[cfg(feature = "wat")]
-        let bytes = wat::parse_bytes(bytes)?;
-        Self::from_binary(engine, &bytes)
-    }
-
-    /// Creates a new WebAssembly `Module` from the contents of the given
-    /// `file` on disk.
-    ///
-    /// This is a convenience function that will read the `file` provided and
-    /// pass the bytes to the [`Module::new`] function. For more information
-    /// see [`Module::new`]
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// let engine = Engine::default();
-    /// let module = Module::from_file(&engine, "./path/to/foo.wasm")?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    ///
-    /// The `.wat` text format is also supported:
-    ///
-    /// ```no_run
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// # let engine = Engine::default();
-    /// let module = Module::from_file(&engine, "./path/to/foo.wat")?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    #[cfg(any(feature = "cranelift", feature = "winch"))]
-    #[cfg_attr(nightlydoc, doc(cfg(any(feature = "cranelift", feature = "winch"))))]
-    pub fn from_file(engine: &Engine, file: impl AsRef<Path>) -> Result<Module> {
-        let file = file.as_ref();
-        match Self::new(
-            engine,
-            &fs::read(file)
-                .with_context(|| format!("failed to read input file: {}", file.display()))?,
-        ) {
-            Ok(m) => Ok(m),
-            Err(e) => {
-                cfg_if::cfg_if! {
-                    if #[cfg(feature = "wat")] {
-                        let mut e = e.downcast::<wat::Error>()?;
-                        e.set_path(file);
-                        bail!(e)
-                    } else {
-                        Err(e)
-                    }
-                }
-            }
-        }
-    }
-
-    /// Creates a new WebAssembly `Module` from the given in-memory `binary`
-    /// data.
-    ///
-    /// This is similar to [`Module::new`] except that it requires that the
-    /// `binary` input is a WebAssembly binary, the text format is not supported
-    /// by this function. It's generally recommended to use [`Module::new`], but
-    /// if it's required to not support the text format this function can be
-    /// used instead.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// # let engine = Engine::default();
-    /// let wasm = b"\0asm\x01\0\0\0";
-    /// let module = Module::from_binary(&engine, wasm)?;
-    /// # Ok(())
-    /// # }
-    /// ```
-    ///
-    /// Note that the text format is **not** accepted by this function:
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// # let engine = Engine::default();
-    /// assert!(Module::from_binary(&engine, b"(module)").is_err());
-    /// # Ok(())
-    /// # }
-    /// ```
-    #[cfg(any(feature = "cranelift", feature = "winch"))]
-    #[cfg_attr(nightlydoc, doc(cfg(any(feature = "cranelift", feature = "winch"))))]
-    pub fn from_binary(engine: &Engine, binary: &[u8]) -> Result<Module> {
-        engine
-            .check_compatible_with_native_host()
-            .context("compilation settings are not compatible with the native host")?;
-
-        cfg_if::cfg_if! {
-            if #[cfg(feature = "cache")] {
-                let state = (HashedEngineCompileEnv(engine), binary);
-                let (code, info_and_types) = wasmtime_cache::ModuleCacheEntry::new(
-                    "wasmtime",
-                    engine.cache_config(),
-                )
-                .get_data_raw(
-                    &state,
-
-                    // Cache miss, compute the actual artifacts
-                    |(engine, wasm)| -> Result<_> {
-                        let (mmap, info) = Module::build_artifacts(engine.0, wasm)?;
-                        let code = publish_mmap(mmap)?;
-                        Ok((code, info))
-                    },
-
-                    // Implementation of how to serialize artifacts
-                    |(_engine, _wasm), (code, _info_and_types)| {
-                        Some(code.mmap().to_vec())
-                    },
-
-                    // Cache hit, deserialize the provided artifacts
-                    |(engine, _wasm), serialized_bytes| {
-                        let code = engine.0.load_code_bytes(&serialized_bytes, ObjectKind::Module).ok()?;
-                        Some((code, None))
-                    },
-                )?;
-            } else {
-                let (mmap, info_and_types) = Module::build_artifacts(engine, binary)?;
-                let code = publish_mmap(mmap)?;
-            }
-        };
-
-        let info_and_types = info_and_types.map(|(info, types)| (info, types.into()));
-        return Self::from_parts(engine, code, info_and_types);
-
-        fn publish_mmap(mmap: MmapVec) -> Result<Arc<CodeMemory>> {
-            let mut code = CodeMemory::new(mmap)?;
-            code.publish()?;
-            Ok(Arc::new(code))
-        }
-    }
-
-    /// Creates a new WebAssembly `Module` from the contents of the given `file`
-    /// on disk, but with assumptions that the file is from a trusted source.
-    /// The file should be a binary- or text-format WebAssembly module, or a
-    /// precompiled artifact generated by the same version of Wasmtime.
-    ///
-    /// # Unsafety
-    ///
-    /// All of the reasons that [`deserialize`] is `unsafe` apply to this
-    /// function as well. Arbitrary data loaded from a file may trick Wasmtime
-    /// into arbitrary code execution since the contents of the file are not
-    /// validated to be a valid precompiled module.
-    ///
-    /// [`deserialize`]: Module::deserialize
-    ///
-    /// Additionally though this function is also `unsafe` because the file
-    /// referenced must remain unchanged and a valid precompiled module for the
-    /// entire lifetime of the [`Module`] returned. Any changes to the file on
-    /// disk may change future instantiations of the module to be incorrect.
-    /// This is because the file is mapped into memory and lazily loaded pages
-    /// reflect the current state of the file, not necessarily the origianl
-    /// state of the file.
-    #[cfg(any(feature = "cranelift", feature = "winch"))]
-    #[cfg_attr(nightlydoc, doc(cfg(any(feature = "cranelift", feature = "winch"))))]
-    pub unsafe fn from_trusted_file(engine: &Engine, file: impl AsRef<Path>) -> Result<Module> {
-        let mmap = MmapVec::from_file(file.as_ref())?;
-        if &mmap[0..4] == b"\x7fELF" {
-            let code = engine.load_code(mmap, ObjectKind::Module)?;
-            return Module::from_parts(engine, code, None);
-        }
-
-        Module::new(engine, &*mmap)
-    }
-
-    /// Converts an input binary-encoded WebAssembly module to compilation
-    /// artifacts and type information.
-    ///
-    /// This is where compilation actually happens of WebAssembly modules and
-    /// translation/parsing/validation of the binary input occurs. The binary
-    /// artifact represented in the `MmapVec` returned here is an in-memory ELF
-    /// file in an owned area of virtual linear memory where permissions (such
-    /// as the executable bit) can be applied.
-    ///
-    /// Additionally compilation returns an `Option` here which is always
-    /// `Some`, notably compiled metadata about the module in addition to the
-    /// type information found within.
-    #[cfg(any(feature = "cranelift", feature = "winch"))]
-    pub(crate) fn build_artifacts(
-        engine: &Engine,
-        wasm: &[u8],
-    ) -> Result<(MmapVec, Option<(CompiledModuleInfo, ModuleTypes)>)> {
-        use crate::compiler::CompileInputs;
-
-        let tunables = &engine.config().tunables;
-        let compiler = engine.compiler();
-
-        // First a `ModuleEnvironment` is created which records type information
-        // about the wasm module. This is where the WebAssembly is parsed and
-        // validated. Afterwards `types` will have all the type information for
-        // this module.
-        let mut validator =
-            wasmparser::Validator::new_with_features(engine.config().features.clone());
-        let parser = wasmparser::Parser::new(0);
-        let mut types = Default::default();
-        let mut translation = ModuleEnvironment::new(tunables, &mut validator, &mut types)
-            .translate(parser, wasm)
-            .context("failed to parse WebAssembly module")?;
-        let functions = mem::take(&mut translation.function_body_inputs);
-        let types = types.finish();
-
-        let compile_inputs = CompileInputs::for_module(&types, &translation, functions);
-        let unlinked_compile_outputs = compile_inputs.compile(engine)?;
-        let (compiled_funcs, function_indices) = unlinked_compile_outputs.pre_link();
-
-        // Emplace all compiled functions into the object file with any other
-        // sections associated with code as well.
-        let mut object = engine.compiler().object(ObjectKind::Module)?;
-        // Insert `Engine` and type-level information into the compiled
-        // artifact so if this module is deserialized later it contains all
-        // information necessary.
-        //
-        // Note that `append_compiler_info` and `append_types` here in theory
-        // can both be skipped if this module will never get serialized.
-        // They're only used during deserialization and not during runtime for
-        // the module itself. Currently there's no need for that, however, so
-        // it's left as an exercise for later.
-        engine.append_compiler_info(&mut object);
-        engine.append_bti(&mut object);
-
-        // If configured attempt to use static memory initialization which
-        // can either at runtime be implemented as a single memcpy to
-        // initialize memory or otherwise enabling virtual-memory-tricks
-        // such as mmap'ing from a file to get copy-on-write.
-        if engine.config().memory_init_cow {
-            let align = engine.compiler().page_size_align();
-            let max_always_allowed = engine.config().memory_guaranteed_dense_image_size;
-            translation.try_static_init(align, max_always_allowed);
-        }
-
-        // Attempt to convert table initializer segments to
-        // FuncTable representation where possible, to enable
-        // table lazy init.
-        translation.try_func_table_init();
-
-        let (mut object, compilation_artifacts) = function_indices.link_and_append_code(
-            object,
-            tunables,
-            compiler,
-            compiled_funcs,
-            std::iter::once(translation).collect(),
-        )?;
-
-        let info = compilation_artifacts.unwrap_as_module_info();
-        object.serialize_info(&(&info, &types));
-        let mmap = object.finish()?;
-
-        Ok((mmap, Some((info, types))))
-    }
-
-    /// Deserializes an in-memory compiled module previously created with
-    /// [`Module::serialize`] or [`Engine::precompile_module`].
-    ///
-    /// This function will deserialize the binary blobs emitted by
-    /// [`Module::serialize`] and [`Engine::precompile_module`] back into an
-    /// in-memory [`Module`] that's ready to be instantiated.
-    ///
-    /// Note that the [`Module::deserialize_file`] method is more optimized than
-    /// this function, so if the serialized module is already present in a file
-    /// it's recommended to use that method instead.
-    ///
-    /// # Unsafety
-    ///
-    /// This function is marked as `unsafe` because if fed invalid input or used
-    /// improperly this could lead to memory safety vulnerabilities. This method
-    /// should not, for example, be exposed to arbitrary user input.
-    ///
-    /// The structure of the binary blob read here is only lightly validated
-    /// internally in `wasmtime`. This is intended to be an efficient
-    /// "rehydration" for a [`Module`] which has very few runtime checks beyond
-    /// deserialization. Arbitrary input could, for example, replace valid
-    /// compiled code with any other valid compiled code, meaning that this can
-    /// trivially be used to execute arbitrary code otherwise.
-    ///
-    /// For these reasons this function is `unsafe`. This function is only
-    /// designed to receive the previous input from [`Module::serialize`] and
-    /// [`Engine::precompile_module`]. If the exact output of those functions
-    /// (unmodified) is passed to this function then calls to this function can
-    /// be considered safe. It is the caller's responsibility to provide the
-    /// guarantee that only previously-serialized bytes are being passed in
-    /// here.
-    ///
-    /// Note that this function is designed to be safe receiving output from
-    /// *any* compiled version of `wasmtime` itself. This means that it is safe
-    /// to feed output from older versions of Wasmtime into this function, in
-    /// addition to newer versions of wasmtime (from the future!). These inputs
-    /// will deterministically and safely produce an `Err`. This function only
-    /// successfully accepts inputs from the same version of `wasmtime`, but the
-    /// safety guarantee only applies to externally-defined blobs of bytes, not
-    /// those defined by any version of wasmtime. (this means that if you cache
-    /// blobs across versions of wasmtime you can be safely guaranteed that
-    /// future versions of wasmtime will reject old cache entries).
-    pub unsafe fn deserialize(engine: &Engine, bytes: impl AsRef<[u8]>) -> Result<Module> {
-        let code = engine.load_code_bytes(bytes.as_ref(), ObjectKind::Module)?;
-        Module::from_parts(engine, code, None)
-    }
-
-    /// Same as [`deserialize`], except that the contents of `path` are read to
-    /// deserialize into a [`Module`].
-    ///
-    /// This method is provided because it can be faster than [`deserialize`]
-    /// since the data doesn't need to be copied around, but rather the module
-    /// can be used directly from an mmap'd view of the file provided.
-    ///
-    /// [`deserialize`]: Module::deserialize
-    ///
-    /// # Unsafety
-    ///
-    /// All of the reasons that [`deserialize`] is `unsafe` applies to this
-    /// function as well. Arbitrary data loaded from a file may trick Wasmtime
-    /// into arbitrary code execution since the contents of the file are not
-    /// validated to be a valid precompiled module.
-    ///
-    /// Additionally though this function is also `unsafe` because the file
-    /// referenced must remain unchanged and a valid precompiled module for the
-    /// entire lifetime of the [`Module`] returned. Any changes to the file on
-    /// disk may change future instantiations of the module to be incorrect.
-    /// This is because the file is mapped into memory and lazily loaded pages
-    /// reflect the current state of the file, not necessarily the origianl
-    /// state of the file.
-    pub unsafe fn deserialize_file(engine: &Engine, path: impl AsRef<Path>) -> Result<Module> {
-        let code = engine.load_code_file(path.as_ref(), ObjectKind::Module)?;
-        Module::from_parts(engine, code, None)
-    }
-
-    /// Entrypoint for creating a `Module` for all above functions, both
-    /// of the AOT and jit-compiled cateogries.
-    ///
-    /// In all cases the compilation artifact, `code_memory`, is provided here.
-    /// The `info_and_types` argument is `None` when a module is being
-    /// deserialized from a precompiled artifact or it's `Some` if it was just
-    /// compiled and the values are already available.
-    fn from_parts(
-        engine: &Engine,
-        code_memory: Arc<CodeMemory>,
-        info_and_types: Option<(CompiledModuleInfo, ModuleTypes)>,
-    ) -> Result<Self> {
-        // Acquire this module's metadata and type information, deserializing
-        // it from the provided artifact if it wasn't otherwise provided
-        // already.
-        let (info, types) = match info_and_types {
-            Some((info, types)) => (info, types),
-            None => bincode::deserialize(code_memory.wasmtime_info())?,
-        };
-
-        // Register function type signatures into the engine for the lifetime
-        // of the `Module` that will be returned. This notably also builds up
-        // maps for trampolines to be used for this module when inserted into
-        // stores.
-        //
-        // Note that the unsafety here should be ok since the `trampolines`
-        // field should only point to valid trampoline function pointers
-        // within the text section.
-        let signatures = SignatureCollection::new_for_module(engine.signatures(), &types);
-
-        // Package up all our data into a `CodeObject` and delegate to the final
-        // step of module compilation.
-        let code = Arc::new(CodeObject::new(code_memory, signatures, types.into()));
-        Module::from_parts_raw(engine, code, info, true)
-    }
-
-    pub(crate) fn from_parts_raw(
-        engine: &Engine,
-        code: Arc<CodeObject>,
-        info: CompiledModuleInfo,
-        serializable: bool,
-    ) -> Result<Self> {
-        let module = CompiledModule::from_artifacts(
-            code.code_memory().clone(),
-            info,
-            engine.profiler(),
-            engine.unique_id_allocator(),
-        )?;
-
-        // Validate the module can be used with the current instance allocator.
-        let offsets = VMOffsets::new(HostPtr, module.module());
-        engine
-            .allocator()
-            .validate_module(module.module(), &offsets)?;
-
-        Ok(Self {
-            inner: Arc::new(ModuleInner {
-                engine: engine.clone(),
-                code,
-                memory_images: OnceCell::new(),
-                module,
-                serializable,
-                offsets,
-            }),
-        })
-    }
-
-    /// Validates `binary` input data as a WebAssembly binary given the
-    /// configuration in `engine`.
-    ///
-    /// This function will perform a speedy validation of the `binary` input
-    /// WebAssembly module (which is in [binary form][binary], the text format
-    /// is not accepted by this function) and return either `Ok` or `Err`
-    /// depending on the results of validation. The `engine` argument indicates
-    /// configuration for WebAssembly features, for example, which are used to
-    /// indicate what should be valid and what shouldn't be.
-    ///
-    /// Validation automatically happens as part of [`Module::new`].
-    ///
-    /// # Errors
-    ///
-    /// If validation fails for any reason (type check error, usage of a feature
-    /// that wasn't enabled, etc) then an error with a description of the
-    /// validation issue will be returned.
-    ///
-    /// [binary]: https://webassembly.github.io/spec/core/binary/index.html
-    pub fn validate(engine: &Engine, binary: &[u8]) -> Result<()> {
-        let mut validator = Validator::new_with_features(engine.config().features);
-
-        let mut functions = Vec::new();
-        for payload in Parser::new(0).parse_all(binary) {
-            let payload = payload?;
-            if let ValidPayload::Func(a, b) = validator.payload(&payload)? {
-                functions.push((a, b));
-            }
-            if let wasmparser::Payload::Version { encoding, .. } = &payload {
-                if let wasmparser::Encoding::Component = encoding {
-                    bail!("component passed to module validation");
-                }
-            }
-        }
-
-        engine.run_maybe_parallel(functions, |(validator, body)| {
-            // FIXME: it would be best here to use a rayon-specific parallel
-            // iterator that maintains state-per-thread to share the function
-            // validator allocations (`Default::default` here) across multiple
-            // functions.
-            validator.into_validator(Default::default()).validate(&body)
-        })?;
-        Ok(())
-    }
-
-    /// Serializes this module to a vector of bytes.
-    ///
-    /// This function is similar to the [`Engine::precompile_module`] method
-    /// where it produces an artifact of Wasmtime which is suitable to later
-    /// pass into [`Module::deserialize`]. If a module is never instantiated
-    /// then it's recommended to use [`Engine::precompile_module`] instead of
-    /// this method, but if a module is both instantiated and serialized then
-    /// this method can be useful to get the serialized version without
-    /// compiling twice.
-    #[cfg(any(feature = "cranelift", feature = "winch"))]
-    #[cfg_attr(nightlydoc, doc(cfg(any(feature = "cranelift", feature = "winch"))))]
-    pub fn serialize(&self) -> Result<Vec<u8>> {
-        // The current representation of compiled modules within a compiled
-        // component means that it cannot be serialized. The mmap returned here
-        // is the mmap for the entire component and while it contains all
-        // necessary data to deserialize this particular module it's all
-        // embedded within component-specific information.
-        //
-        // It's not the hardest thing in the world to support this but it's
-        // expected that there's not much of a use case at this time. In theory
-        // all that needs to be done is to edit the `.wasmtime.info` section
-        // to contains this module's metadata instead of the metadata for the
-        // whole component. The metadata itself is fairly trivially
-        // recreateable here it's more that there's no easy one-off API for
-        // editing the sections of an ELF object to use here.
-        //
-        // Overall for now this simply always returns an error in this
-        // situation. If you're reading this and feel that the situation should
-        // be different please feel free to open an issue.
-        if !self.inner.serializable {
-            bail!("cannot serialize a module exported from a component");
-        }
-        Ok(self.compiled_module().mmap().to_vec())
-    }
-
-    pub(crate) fn compiled_module(&self) -> &CompiledModule {
-        &self.inner.module
-    }
-
-    fn code_object(&self) -> &Arc<CodeObject> {
-        &self.inner.code
-    }
-
-    pub(crate) fn env_module(&self) -> &wasmtime_environ::Module {
-        self.compiled_module().module()
-    }
-
-    pub(crate) fn types(&self) -> &ModuleTypes {
-        self.inner.code.module_types()
-    }
-
-    pub(crate) fn signatures(&self) -> &SignatureCollection {
-        self.inner.code.signatures()
-    }
-
-    /// Returns identifier/name that this [`Module`] has. This name
-    /// is used in traps/backtrace details.
-    ///
-    /// Note that most LLVM/clang/Rust-produced modules do not have a name
-    /// associated with them, but other wasm tooling can be used to inject or
-    /// add a name.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// # let engine = Engine::default();
-    /// let module = Module::new(&engine, "(module $foo)")?;
-    /// assert_eq!(module.name(), Some("foo"));
-    ///
-    /// let module = Module::new(&engine, "(module)")?;
-    /// assert_eq!(module.name(), None);
-    ///
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn name(&self) -> Option<&str> {
-        self.compiled_module().module().name.as_deref()
-    }
-
-    /// Returns the list of imports that this [`Module`] has and must be
-    /// satisfied.
-    ///
-    /// This function returns the list of imports that the wasm module has, but
-    /// only the types of each import. The type of each import is used to
-    /// typecheck the [`Instance::new`](crate::Instance::new) method's `imports`
-    /// argument. The arguments to that function must match up 1-to-1 with the
-    /// entries in the array returned here.
-    ///
-    /// The imports returned reflect the order of the imports in the wasm module
-    /// itself, and note that no form of deduplication happens.
-    ///
-    /// # Examples
-    ///
-    /// Modules with no imports return an empty list here:
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// # let engine = Engine::default();
-    /// let module = Module::new(&engine, "(module)")?;
-    /// assert_eq!(module.imports().len(), 0);
-    /// # Ok(())
-    /// # }
-    /// ```
-    ///
-    /// and modules with imports will have a non-empty list:
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// # let engine = Engine::default();
-    /// let wat = r#"
-    ///     (module
-    ///         (import "host" "foo" (func))
-    ///     )
-    /// "#;
-    /// let module = Module::new(&engine, wat)?;
-    /// assert_eq!(module.imports().len(), 1);
-    /// let import = module.imports().next().unwrap();
-    /// assert_eq!(import.module(), "host");
-    /// assert_eq!(import.name(), "foo");
-    /// match import.ty() {
-    ///     ExternType::Func(_) => { /* ... */ }
-    ///     _ => panic!("unexpected import type!"),
-    /// }
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn imports<'module>(
-        &'module self,
-    ) -> impl ExactSizeIterator<Item = ImportType<'module>> + 'module {
-        let module = self.compiled_module().module();
-        let types = self.types();
-        module
-            .imports()
-            .map(move |(module, field, ty)| ImportType::new(module, field, ty, types))
-            .collect::<Vec<_>>()
-            .into_iter()
-    }
-
-    /// Returns the list of exports that this [`Module`] has and will be
-    /// available after instantiation.
-    ///
-    /// This function will return the type of each item that will be returned
-    /// from [`Instance::exports`](crate::Instance::exports). Each entry in this
-    /// list corresponds 1-to-1 with that list, and the entries here will
-    /// indicate the name of the export along with the type of the export.
-    ///
-    /// # Examples
-    ///
-    /// Modules might not have any exports:
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// # let engine = Engine::default();
-    /// let module = Module::new(&engine, "(module)")?;
-    /// assert!(module.exports().next().is_none());
-    /// # Ok(())
-    /// # }
-    /// ```
-    ///
-    /// When the exports are not empty, you can inspect each export:
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// # let engine = Engine::default();
-    /// let wat = r#"
-    ///     (module
-    ///         (func (export "foo"))
-    ///         (memory (export "memory") 1)
-    ///     )
-    /// "#;
-    /// let module = Module::new(&engine, wat)?;
-    /// assert_eq!(module.exports().len(), 2);
-    ///
-    /// let mut exports = module.exports();
-    /// let foo = exports.next().unwrap();
-    /// assert_eq!(foo.name(), "foo");
-    /// match foo.ty() {
-    ///     ExternType::Func(_) => { /* ... */ }
-    ///     _ => panic!("unexpected export type!"),
-    /// }
-    ///
-    /// let memory = exports.next().unwrap();
-    /// assert_eq!(memory.name(), "memory");
-    /// match memory.ty() {
-    ///     ExternType::Memory(_) => { /* ... */ }
-    ///     _ => panic!("unexpected export type!"),
-    /// }
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn exports<'module>(
-        &'module self,
-    ) -> impl ExactSizeIterator<Item = ExportType<'module>> + 'module {
-        let module = self.compiled_module().module();
-        let types = self.types();
-        module.exports.iter().map(move |(name, entity_index)| {
-            ExportType::new(name, module.type_of(*entity_index), types)
-        })
-    }
-
-    /// Looks up an export in this [`Module`] by name.
-    ///
-    /// This function will return the type of an export with the given name.
-    ///
-    /// # Examples
-    ///
-    /// There may be no export with that name:
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// # let engine = Engine::default();
-    /// let module = Module::new(&engine, "(module)")?;
-    /// assert!(module.get_export("foo").is_none());
-    /// # Ok(())
-    /// # }
-    /// ```
-    ///
-    /// When there is an export with that name, it is returned:
-    ///
-    /// ```
-    /// # use wasmtime::*;
-    /// # fn main() -> anyhow::Result<()> {
-    /// # let engine = Engine::default();
-    /// let wat = r#"
-    ///     (module
-    ///         (func (export "foo"))
-    ///         (memory (export "memory") 1)
-    ///     )
-    /// "#;
-    /// let module = Module::new(&engine, wat)?;
-    /// let foo = module.get_export("foo");
-    /// assert!(foo.is_some());
-    ///
-    /// let foo = foo.unwrap();
-    /// match foo {
-    ///     ExternType::Func(_) => { /* ... */ }
-    ///     _ => panic!("unexpected export type!"),
-    /// }
-    ///
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn get_export(&self, name: &str) -> Option<ExternType> {
-        let module = self.compiled_module().module();
-        let entity_index = module.exports.get(name)?;
-        Some(ExternType::from_wasmtime(
-            self.types(),
-            &module.type_of(*entity_index),
-        ))
-    }
-
-    /// Returns the [`Engine`] that this [`Module`] was compiled by.
-    pub fn engine(&self) -> &Engine {
-        &self.inner.engine
-    }
-
-    /// Returns a summary of the resources required to instantiate this
-    /// [`Module`].
-    ///
-    /// Potential uses of the returned information:
-    ///
-    /// * Determining whether your pooling allocator configuration supports
-    ///   instantiating this module.
-    ///
-    /// * Deciding how many of which `Module` you want to instantiate within a
-    ///   fixed amount of resources, e.g. determining whether to create 5
-    ///   instances of module X or 10 instances of module Y.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # fn main() -> wasmtime::Result<()> {
-    /// use wasmtime::{Config, Engine, Module};
-    ///
-    /// let mut config = Config::new();
-    /// config.wasm_multi_memory(true);
-    /// let engine = Engine::new(&config)?;
-    ///
-    /// let module = Module::new(&engine, r#"
-    ///     (module
-    ///         ;; Import a memory. Doesn't count towards required resources.
-    ///         (import "a" "b" (memory 10))
-    ///         ;; Define two local memories. These count towards the required
-    ///         ;; resources.
-    ///         (memory 1)
-    ///         (memory 6)
-    ///     )
-    /// "#)?;
-    ///
-    /// let resources = module.resources_required();
-    ///
-    /// // Instantiating the module will require allocating two memories, and
-    /// // the maximum initial memory size is six Wasm pages.
-    /// assert_eq!(resources.num_memories, 2);
-    /// assert_eq!(resources.max_initial_memory_size, Some(6));
-    ///
-    /// // The module doesn't need any tables.
-    /// assert_eq!(resources.num_tables, 0);
-    /// assert_eq!(resources.max_initial_table_size, None);
-    /// # Ok(()) }
-    /// ```
-    pub fn resources_required(&self) -> ResourcesRequired {
-        let em = self.env_module();
-        let num_memories = u32::try_from(em.memory_plans.len() - em.num_imported_memories).unwrap();
-        let max_initial_memory_size = em
-            .memory_plans
-            .values()
-            .skip(em.num_imported_memories)
-            .map(|plan| plan.memory.minimum)
-            .max();
-        let num_tables = u32::try_from(em.table_plans.len() - em.num_imported_tables).unwrap();
-        let max_initial_table_size = em
-            .table_plans
-            .values()
-            .skip(em.num_imported_tables)
-            .map(|plan| plan.table.minimum)
-            .max();
-        ResourcesRequired {
-            num_memories,
-            max_initial_memory_size,
-            num_tables,
-            max_initial_table_size,
-        }
-    }
-
-    /// Returns the `ModuleInner` cast as `ModuleRuntimeInfo` for use
-    /// by the runtime.
-    pub(crate) fn runtime_info(&self) -> Arc<dyn wasmtime_runtime::ModuleRuntimeInfo> {
-        // N.B.: this needs to return a clone because we cannot
-        // statically cast the &Arc<ModuleInner> to &Arc<dyn Trait...>.
-        self.inner.clone()
-    }
-
-    pub(crate) fn module_info(&self) -> &dyn wasmtime_runtime::ModuleInfo {
-        &*self.inner
-    }
-
-    /// Returns the range of bytes in memory where this module's compilation
-    /// image resides.
-    ///
-    /// The compilation image for a module contains executable code, data, debug
-    /// information, etc. This is roughly the same as the `Module::serialize`
-    /// but not the exact same.
-    ///
-    /// The range of memory reported here is exposed to allow low-level
-    /// manipulation of the memory in platform-specific manners such as using
-    /// `mlock` to force the contents to be paged in immediately or keep them
-    /// paged in after they're loaded.
-    ///
-    /// It is not safe to modify the memory in this range, nor is it safe to
-    /// modify the protections of memory in this range.
-    pub fn image_range(&self) -> Range<usize> {
-        self.compiled_module().image_range()
-    }
-
-    /// Force initialization of copy-on-write images to happen here-and-now
-    /// instead of when they're requested during first instantiation.
-    ///
-    /// When [copy-on-write memory
-    /// initialization](crate::Config::memory_init_cow) is enabled then Wasmtime
-    /// will lazily create the initialization image for a module. This method
-    /// can be used to explicitly dictate when this initialization happens.
-    ///
-    /// Note that this largely only matters on Linux when memfd is used.
-    /// Otherwise the copy-on-write image typically comes from disk and in that
-    /// situation the creation of the image is trivial as the image is always
-    /// sourced from disk. On Linux, though, when memfd is used a memfd is
-    /// created and the initialization image is written to it.
-    ///
-    /// Also note that this method is not required to be called, it's available
-    /// as a performance optimization if required but is otherwise handled
-    /// automatically.
-    pub fn initialize_copy_on_write_image(&self) -> Result<()> {
-        self.inner.memory_images()?;
-        Ok(())
-    }
-
-    /// Get the map from `.text` section offsets to Wasm binary offsets for this
-    /// module.
-    ///
-    /// Each entry is a (`.text` section offset, Wasm binary offset) pair.
-    ///
-    /// Entries are yielded in order of `.text` section offset.
-    ///
-    /// Some entries are missing a Wasm binary offset. This is for code that is
-    /// not associated with any single location in the Wasm binary, or for when
-    /// source information was optimized away.
-    ///
-    /// Not every module has an address map, since address map generation can be
-    /// turned off on `Config`.
-    ///
-    /// There is not an entry for every `.text` section offset. Every offset
-    /// after an entry's offset, but before the next entry's offset, is
-    /// considered to map to the same Wasm binary offset as the original
-    /// entry. For example, the address map will not contain the following
-    /// sequnce of entries:
-    ///
-    /// ```ignore
-    /// [
-    ///     // ...
-    ///     (10, Some(42)),
-    ///     (11, Some(42)),
-    ///     (12, Some(42)),
-    ///     (13, Some(43)),
-    ///     // ...
-    /// ]
-    /// ```
-    ///
-    /// Instead, it will drop the entries for offsets `11` and `12` since they
-    /// are the same as the entry for offset `10`:
-    ///
-    /// ```ignore
-    /// [
-    ///     // ...
-    ///     (10, Some(42)),
-    ///     (13, Some(43)),
-    ///     // ...
-    /// ]
-    /// ```
-    pub fn address_map<'a>(&'a self) -> Option<impl Iterator<Item = (usize, Option<u32>)> + 'a> {
-        Some(
-            wasmtime_environ::iterate_address_map(
-                self.code_object().code_memory().address_map_data(),
-            )?
-            .map(|(offset, file_pos)| (offset as usize, file_pos.file_offset())),
-        )
-    }
-
-    /// Get this module's code object's `.text` section, containing its compiled
-    /// executable code.
-    pub fn text(&self) -> &[u8] {
-        self.code_object().code_memory().text()
-    }
-
-    /// Get the locations of functions in this module's `.text` section.
-    ///
-    /// Each function's locartion is a (`.text` section offset, length) pair.
-    pub fn function_locations<'a>(&'a self) -> impl ExactSizeIterator<Item = (usize, usize)> + 'a {
-        self.compiled_module().finished_functions().map(|(f, _)| {
-            let loc = self.compiled_module().func_loc(f);
-            (loc.start as usize, loc.length as usize)
-        })
-    }
-
-    pub(crate) fn id(&self) -> CompiledModuleId {
-        self.inner.module.unique_id()
-    }
-}
-
-impl ModuleInner {
-    fn memory_images(&self) -> Result<Option<&ModuleMemoryImages>> {
-        let images = self
-            .memory_images
-            .get_or_try_init(|| memory_images(&self.engine, &self.module))?
-            .as_ref();
-        Ok(images)
-    }
-}
-
-impl Drop for ModuleInner {
-    fn drop(&mut self) {
-        // When a `Module` is being dropped that means that it's no longer
-        // present in any `Store` and it's additionally not longer held by any
-        // embedder. Take this opportunity to purge any lingering instantiations
-        // within a pooling instance allocator, if applicable.
-        self.engine
-            .allocator()
-            .purge_module(self.module.unique_id());
-    }
-}
-
-fn _assert_send_sync() {
-    fn _assert<T: Send + Sync>() {}
-    _assert::<Module>();
-}
-
-/// This is a helper struct used when caching to hash the state of an `Engine`
-/// used for module compilation.
-///
-/// The hash computed for this structure is used to key the global wasmtime
-/// cache and dictates whether artifacts are reused. Consequently the contents
-/// of this hash dictate when artifacts are or aren't re-used.
-#[cfg(any(feature = "cranelift", feature = "winch"))]
-pub(crate) struct HashedEngineCompileEnv<'a>(pub &'a Engine);
-
-#[cfg(any(feature = "cranelift", feature = "winch"))]
-impl std::hash::Hash for HashedEngineCompileEnv<'_> {
-    fn hash<H: std::hash::Hasher>(&self, hasher: &mut H) {
-        // Hash the compiler's state based on its target and configuration.
-        let compiler = self.0.compiler();
-        compiler.triple().hash(hasher);
-        compiler.flags().hash(hasher);
-        compiler.isa_flags().hash(hasher);
-
-        // Hash configuration state read for compilation
-        let config = self.0.config();
-        config.tunables.hash(hasher);
-        config.features.hash(hasher);
-        config.wmemcheck.hash(hasher);
-
-        // Catch accidental bugs of reusing across crate versions.
-        config.module_version.hash(hasher);
-    }
-}
-
-impl wasmtime_runtime::ModuleRuntimeInfo for ModuleInner {
-    fn module(&self) -> &Arc<wasmtime_environ::Module> {
-        self.module.module()
-    }
-
-    fn function(&self, index: DefinedFuncIndex) -> NonNull<VMWasmCallFunction> {
-        let ptr = self
-            .module
-            .finished_function(index)
-            .as_ptr()
-            .cast::<VMWasmCallFunction>()
-            .cast_mut();
-        NonNull::new(ptr).unwrap()
-    }
-
-    fn native_to_wasm_trampoline(
-        &self,
-        index: DefinedFuncIndex,
-    ) -> Option<NonNull<VMNativeCallFunction>> {
-        let ptr = self
-            .module
-            .native_to_wasm_trampoline(index)?
-            .as_ptr()
-            .cast::<VMNativeCallFunction>()
-            .cast_mut();
-        Some(NonNull::new(ptr).unwrap())
-    }
-
-    fn array_to_wasm_trampoline(&self, index: DefinedFuncIndex) -> Option<VMArrayCallFunction> {
-        let ptr = self.module.array_to_wasm_trampoline(index)?.as_ptr();
-        Some(unsafe { mem::transmute::<*const u8, VMArrayCallFunction>(ptr) })
-    }
-
-    fn wasm_to_native_trampoline(
-        &self,
-        signature: VMSharedSignatureIndex,
-    ) -> Option<NonNull<VMWasmCallFunction>> {
-        let sig = self.code.signatures().local_signature(signature)?;
-        let ptr = self
-            .module
-            .wasm_to_native_trampoline(sig)
-            .as_ptr()
-            .cast::<VMWasmCallFunction>()
-            .cast_mut();
-        Some(NonNull::new(ptr).unwrap())
-    }
-
-    fn memory_image(&self, memory: DefinedMemoryIndex) -> Result<Option<&Arc<MemoryImage>>> {
-        let images = self.memory_images()?;
-        Ok(images.and_then(|images| images.get_memory_image(memory)))
-    }
-
-    fn unique_id(&self) -> Option<CompiledModuleId> {
-        Some(self.module.unique_id())
-    }
-
-    fn wasm_data(&self) -> &[u8] {
-        self.module.code_memory().wasm_data()
-    }
-
-    fn signature_ids(&self) -> &[VMSharedSignatureIndex] {
-        self.code.signatures().as_module_map().values().as_slice()
-    }
-
-    fn offsets(&self) -> &VMOffsets<HostPtr> {
-        &self.offsets
-    }
-}
-
-impl wasmtime_runtime::ModuleInfo for ModuleInner {
-    fn lookup_stack_map(&self, pc: usize) -> Option<&wasmtime_environ::StackMap> {
-        let text_offset = pc - self.module.text().as_ptr() as usize;
-        let (index, func_offset) = self.module.func_by_text_offset(text_offset)?;
-        let info = self.module.wasm_func_info(index);
-
-        // Do a binary search to find the stack map for the given offset.
-        let index = match info
-            .stack_maps
-            .binary_search_by_key(&func_offset, |i| i.code_offset)
-        {
-            // Found it.
-            Ok(i) => i,
-
-            // No stack map associated with this PC.
-            //
-            // Because we know we are in Wasm code, and we must be at some kind
-            // of call/safepoint, then the Cranelift backend must have avoided
-            // emitting a stack map for this location because no refs were live.
-            Err(_) => return None,
-        };
-
-        Some(&info.stack_maps[index].stack_map)
-    }
-}
-
-/// A barebones implementation of ModuleRuntimeInfo that is useful for
-/// cases where a purpose-built environ::Module is used and a full
-/// CompiledModule does not exist (for example, for tests or for the
-/// default-callee instance).
-pub(crate) struct BareModuleInfo {
-    module: Arc<wasmtime_environ::Module>,
-    one_signature: Option<VMSharedSignatureIndex>,
-    offsets: VMOffsets<HostPtr>,
-}
-
-impl BareModuleInfo {
-    pub(crate) fn empty(module: Arc<wasmtime_environ::Module>) -> Self {
-        BareModuleInfo::maybe_imported_func(module, None)
-    }
-
-    pub(crate) fn maybe_imported_func(
-        module: Arc<wasmtime_environ::Module>,
-        one_signature: Option<VMSharedSignatureIndex>,
-    ) -> Self {
-        BareModuleInfo {
-            offsets: VMOffsets::new(HostPtr, &module),
-            module,
-            one_signature,
-        }
-    }
-
-    pub(crate) fn into_traitobj(self) -> Arc<dyn wasmtime_runtime::ModuleRuntimeInfo> {
-        Arc::new(self)
-    }
-}
-
-impl wasmtime_runtime::ModuleRuntimeInfo for BareModuleInfo {
-    fn module(&self) -> &Arc<wasmtime_environ::Module> {
-        &self.module
-    }
-
-    fn function(&self, _index: DefinedFuncIndex) -> NonNull<VMWasmCallFunction> {
-        unreachable!()
-    }
-
-    fn array_to_wasm_trampoline(&self, _index: DefinedFuncIndex) -> Option<VMArrayCallFunction> {
-        unreachable!()
-    }
-
-    fn native_to_wasm_trampoline(
-        &self,
-        _index: DefinedFuncIndex,
-    ) -> Option<NonNull<VMNativeCallFunction>> {
-        unreachable!()
-    }
-
-    fn wasm_to_native_trampoline(
-        &self,
-        _signature: VMSharedSignatureIndex,
-    ) -> Option<NonNull<VMWasmCallFunction>> {
-        unreachable!()
-    }
-
-    fn memory_image(&self, _memory: DefinedMemoryIndex) -> Result<Option<&Arc<MemoryImage>>> {
-        Ok(None)
-    }
-
-    fn unique_id(&self) -> Option<CompiledModuleId> {
-        None
-    }
-
-    fn wasm_data(&self) -> &[u8] {
-        &[]
-    }
-
-    fn signature_ids(&self) -> &[VMSharedSignatureIndex] {
-        match &self.one_signature {
-            Some(id) => std::slice::from_ref(id),
-            None => &[],
-        }
-    }
-
-    fn offsets(&self) -> &VMOffsets<HostPtr> {
-        &self.offsets
-    }
-}
-
-/// Helper method to construct a `ModuleMemoryImages` for an associated
-/// `CompiledModule`.
-fn memory_images(engine: &Engine, module: &CompiledModule) -> Result<Option<ModuleMemoryImages>> {
-    // If initialization via copy-on-write is explicitly disabled in
-    // configuration then this path is skipped entirely.
-    if !engine.config().memory_init_cow {
-        return Ok(None);
-    }
-
-    // ... otherwise logic is delegated to the `ModuleMemoryImages::new`
-    // constructor.
-    let mmap = if engine.config().force_memory_init_memfd {
-        None
-    } else {
-        Some(module.mmap())
-    };
-    ModuleMemoryImages::new(module.module(), module.code_memory().wasm_data(), mmap)
-}
diff --git a/crates/wasmtime/src/profiling.rs b/crates/wasmtime/src/profiling.rs
deleted file mode 100644
index 9b59e584a62a..000000000000
--- a/crates/wasmtime/src/profiling.rs
+++ /dev/null
@@ -1,212 +0,0 @@
-use crate::{AsContext, Module};
-use anyhow::Result;
-use fxprof_processed_profile::debugid::DebugId;
-use fxprof_processed_profile::{
-    CategoryHandle, CpuDelta, Frame, FrameFlags, FrameInfo, LibraryInfo, Profile,
-    ReferenceTimestamp, Symbol, SymbolTable, Timestamp,
-};
-use std::ops::Range;
-use std::sync::Arc;
-use std::time::{Duration, Instant};
-use wasmtime_jit::CompiledModule;
-use wasmtime_runtime::Backtrace;
-
-// TODO: collect more data
-// - Provide additional hooks for recording host-guest transitions, to be
-//   invoked from a Store::call_hook
-// - On non-Windows, measure thread-local CPU usage between events with
-//   rustix::time::clock_gettime(ClockId::ThreadCPUTime)
-// - Report which wasm module, and maybe instance, each frame came from
-
-/// Collects basic profiling data for a single WebAssembly guest.
-///
-/// This profiler can't provide measurements that are as accurate or detailed
-/// as a platform-specific profiler, such as `perf` on Linux. On the other
-/// hand, this profiler works on every platform that Wasmtime supports. Also,
-/// as an embedder you can use this profiler selectively on individual guest
-/// instances rather than profiling the entire process.
-///
-/// To use this, you'll need to arrange to call [`GuestProfiler::sample`] at
-/// regular intervals while the guest is on the stack. The most straightforward
-/// way to do that is to call it from a callback registered with
-/// [`Store::epoch_deadline_callback()`](crate::Store::epoch_deadline_callback).
-///
-/// # Accuracy
-///
-/// The data collection granularity is limited by the mechanism you use to
-/// interrupt guest execution and collect a profiling sample.
-///
-/// If you use epoch interruption, then samples will only be collected at
-/// function entry points and loop headers. This introduces some bias to the
-/// results. In addition, samples will only be taken at times when WebAssembly
-/// functions are running, not during host-calls.
-///
-/// It is technically possible to use fuel interruption instead. That
-/// introduces worse bias since samples occur after a certain number of
-/// WebAssembly instructions, which can take different amounts of time.
-///
-/// You may instead be able to use platform-specific methods, such as
-/// `setitimer(ITIMER_VIRTUAL, ...)` on POSIX-compliant systems, to sample on
-/// a more accurate interval. The only current requirement is that the guest
-/// you wish to profile must be on the same stack where you call `sample`,
-/// and executing within the same thread. However, the `GuestProfiler::sample`
-/// method is not currently async-signal-safe, so doing this correctly is not
-/// easy.
-///
-/// # Security
-///
-/// Profiles produced using this profiler do not include any configuration
-/// details from the host, such as virtual memory addresses, or from any
-/// WebAssembly modules that you haven't specifically allowed. So for
-/// example, these profiles should be safe to share with untrusted users
-/// who have provided untrusted code that you are running in a multi-tenancy
-/// environment.
-///
-/// However, the profile does include byte offsets into the text section of
-/// the compiled module, revealing some information about the size of the code
-/// generated for each module. For user-provided modules, the user could get
-/// the same information by compiling the module for themself using a similar
-/// version of Wasmtime on the same target architecture, but for any module
-/// where they don't already have the WebAssembly module binary available this
-/// could theoretically lead to an undesirable information disclosure. So you
-/// should only include user-provided modules in profiles.
-#[derive(Debug)]
-pub struct GuestProfiler {
-    profile: Profile,
-    modules: Vec<(Range<usize>, fxprof_processed_profile::LibraryHandle)>,
-    process: fxprof_processed_profile::ProcessHandle,
-    thread: fxprof_processed_profile::ThreadHandle,
-    start: Instant,
-}
-
-impl GuestProfiler {
-    /// Begin profiling a new guest. When this function is called, the current
-    /// wall-clock time is recorded as the start time for the guest.
-    ///
-    /// The `module_name` parameter is recorded in the profile to help identify
-    /// where the profile came from.
-    ///
-    /// The `interval` parameter should match the rate at which you intend
-    /// to call `sample`. However, this is used as a hint and not required to
-    /// exactly match the real sample rate.
-    ///
-    /// Only modules which are present in the `modules` vector will appear in
-    /// stack traces in this profile. Any stack frames which were executing
-    /// host code or functions from other modules will be omitted. See the
-    /// "Security" section of the [`GuestProfiler`] documentation for guidance
-    /// on what modules should not be included in this list.
-    pub fn new(module_name: &str, interval: Duration, modules: Vec<(String, Module)>) -> Self {
-        let zero = ReferenceTimestamp::from_millis_since_unix_epoch(0.0);
-        let mut profile = Profile::new(module_name, zero, interval.into());
-
-        let mut modules: Vec<_> = modules
-            .into_iter()
-            .filter_map(|(name, module)| {
-                let compiled = module.compiled_module();
-                let text = compiled.text().as_ptr_range();
-                let address_range = text.start as usize..text.end as usize;
-                module_symbols(name, compiled).map(|lib| (address_range, profile.add_lib(lib)))
-            })
-            .collect();
-
-        modules.sort_unstable_by_key(|(range, _)| range.start);
-
-        profile.set_reference_timestamp(std::time::SystemTime::now().into());
-        let process = profile.add_process(module_name, 0, Timestamp::from_nanos_since_reference(0));
-        let thread = profile.add_thread(process, 0, Timestamp::from_nanos_since_reference(0), true);
-        let start = Instant::now();
-        Self {
-            profile,
-            modules,
-            process,
-            thread,
-            start,
-        }
-    }
-
-    /// Add a sample to the profile. This function collects a backtrace from
-    /// any stack frames for allowed modules on the current stack. It should
-    /// typically be called from a callback registered using
-    /// [`Store::epoch_deadline_callback()`](crate::Store::epoch_deadline_callback).
-    pub fn sample(&mut self, store: impl AsContext) {
-        let now = Timestamp::from_nanos_since_reference(
-            self.start.elapsed().as_nanos().try_into().unwrap(),
-        );
-
-        let backtrace = Backtrace::new(store.as_context().0.vmruntime_limits());
-        let frames = backtrace
-            .frames()
-            // Samply needs to see the oldest frame first, but we list the newest
-            // first, so iterate in reverse.
-            .rev()
-            .filter_map(|frame| {
-                // Find the first module whose start address includes this PC.
-                let module_idx = self
-                    .modules
-                    .partition_point(|(range, _)| range.start > frame.pc());
-                if let Some((range, lib)) = self.modules.get(module_idx) {
-                    if range.contains(&frame.pc()) {
-                        return Some(FrameInfo {
-                            frame: Frame::RelativeAddressFromReturnAddress(
-                                *lib,
-                                u32::try_from(frame.pc() - range.start).unwrap(),
-                            ),
-                            category_pair: CategoryHandle::OTHER.into(),
-                            flags: FrameFlags::empty(),
-                        });
-                    }
-                }
-                None
-            });
-
-        self.profile
-            .add_sample(self.thread, now, frames, CpuDelta::ZERO, 1);
-    }
-
-    /// When the guest finishes running, call this function to write the
-    /// profile to the given `output`. The output is a JSON-formatted object in
-    /// the [Firefox "processed profile format"][fmt]. Files in this format may
-    /// be visualized at <https://profiler.firefox.com/>.
-    ///
-    /// [fmt]: https://github.com/firefox-devtools/profiler/blob/main/docs-developer/processed-profile-format.md
-    pub fn finish(mut self, output: impl std::io::Write) -> Result<()> {
-        let now = Timestamp::from_nanos_since_reference(
-            self.start.elapsed().as_nanos().try_into().unwrap(),
-        );
-        self.profile.set_thread_end_time(self.thread, now);
-        self.profile.set_process_end_time(self.process, now);
-
-        serde_json::to_writer(output, &self.profile)?;
-        Ok(())
-    }
-}
-
-fn module_symbols(name: String, compiled: &CompiledModule) -> Option<LibraryInfo> {
-    let symbols = Vec::from_iter(compiled.finished_functions().map(|(defined_idx, _)| {
-        let loc = compiled.func_loc(defined_idx);
-        let func_idx = compiled.module().func_index(defined_idx);
-        let name = match compiled.func_name(func_idx) {
-            None => format!("wasm_function_{}", defined_idx.as_u32()),
-            Some(name) => name.to_string(),
-        };
-        Symbol {
-            address: loc.start,
-            size: Some(loc.length),
-            name,
-        }
-    }));
-    if symbols.is_empty() {
-        return None;
-    }
-
-    Some(LibraryInfo {
-        name,
-        debug_name: String::new(),
-        path: String::new(),
-        debug_path: String::new(),
-        debug_id: DebugId::nil(),
-        code_id: None,
-        arch: None,
-        symbol_table: Some(Arc::new(SymbolTable::new(symbols))),
-    })
-}
diff --git a/crates/wasmtime/src/profiling_agent.rs b/crates/wasmtime/src/profiling_agent.rs
new file mode 100644
index 000000000000..50480a62450a
--- /dev/null
+++ b/crates/wasmtime/src/profiling_agent.rs
@@ -0,0 +1,104 @@
+use crate::prelude::*;
+
+cfg_if::cfg_if! {
+    if #[cfg(all(feature = "profiling", target_os = "linux"))] {
+        mod jitdump;
+        pub use jitdump::new as new_jitdump;
+    } else {
+        pub fn new_jitdump() -> Result<Box<dyn ProfilingAgent>> {
+            if cfg!(feature = "profiling") {
+                bail!("jitdump is not supported on this platform");
+            } else {
+                bail!("jitdump support disabled at compile time");
+            }
+        }
+    }
+}
+
+cfg_if::cfg_if! {
+    if #[cfg(all(unix, feature = "std"))] {
+        mod perfmap;
+        pub use perfmap::new as new_perfmap;
+    } else {
+        pub fn new_perfmap() -> Result<Box<dyn ProfilingAgent>> {
+            bail!("perfmap support not supported on this platform");
+        }
+    }
+}
+
+cfg_if::cfg_if! {
+    // Note: VTune support is disabled on windows mingw because the ittapi crate doesn't compile
+    // there; see also https://github.com/bytecodealliance/wasmtime/pull/4003 for rationale.
+    if #[cfg(all(feature = "profiling", target_arch = "x86_64", not(any(target_os = "android", all(target_os = "windows", target_env = "gnu")))))] {
+        mod vtune;
+        pub use vtune::new as new_vtune;
+    } else {
+        pub fn new_vtune() -> Result<Box<dyn ProfilingAgent>> {
+            if cfg!(feature = "profiling") {
+                bail!("VTune is not supported on this platform.");
+            } else {
+                bail!("VTune support disabled at compile time.");
+            }
+        }
+    }
+}
+
+/// Common interface for profiling tools.
+pub trait ProfilingAgent: Send + Sync + 'static {
+    fn register_function(&self, name: &str, code: &[u8]);
+
+    fn register_module(&self, code: &[u8], custom_name: &dyn Fn(usize) -> Option<String>) {
+        use object::{File, Object as _, ObjectSection, ObjectSymbol, SectionKind, SymbolKind};
+
+        let image = match File::parse(code) {
+            Ok(image) => image,
+            Err(_) => return,
+        };
+
+        let text = match image.sections().find(|s| s.kind() == SectionKind::Text) {
+            Some(section) => match section.data() {
+                Ok(data) => data,
+                Err(_) => return,
+            },
+            None => return,
+        };
+
+        for sym in image.symbols() {
+            if !sym.is_definition() {
+                continue;
+            }
+            if sym.kind() != SymbolKind::Text {
+                continue;
+            }
+            let address = sym.address();
+            let size = sym.size();
+            if size == 0 {
+                continue;
+            }
+            if let Ok(name) = sym.name() {
+                let owned;
+                let name = match custom_name(address as usize) {
+                    Some(name) => {
+                        owned = name;
+                        &owned
+                    }
+                    None => name,
+                };
+                let code = &text[address as usize..][..size as usize];
+                self.register_function(name, code)
+            }
+        }
+    }
+}
+
+pub fn new_null() -> Box<dyn ProfilingAgent> {
+    Box::new(NullProfilerAgent)
+}
+
+#[derive(Debug, Default, Clone, Copy)]
+struct NullProfilerAgent;
+
+impl ProfilingAgent for NullProfilerAgent {
+    fn register_function(&self, _name: &str, _code: &[u8]) {}
+    fn register_module(&self, _code: &[u8], _custom_name: &dyn Fn(usize) -> Option<String>) {}
+}
diff --git a/crates/jit/src/profiling/jitdump.rs b/crates/wasmtime/src/profiling_agent/jitdump.rs
similarity index 87%
rename from crates/jit/src/profiling/jitdump.rs
rename to crates/wasmtime/src/profiling_agent/jitdump.rs
index f91191761993..74b3a8975c59 100644
--- a/crates/jit/src/profiling/jitdump.rs
+++ b/crates/wasmtime/src/profiling_agent/jitdump.rs
@@ -11,15 +11,14 @@
 //!         sudo perf report -i perf.jit.data -F+period,srcline
 //! Note: For descriptive results, the WASM file being executed should contain dwarf debug data
 
-use crate::profiling::ProfilingAgent;
-use anyhow::Result;
+use crate::prelude::*;
+use crate::profiling_agent::ProfilingAgent;
+use object::elf;
 use std::process;
 use std::sync::Mutex;
 use target_lexicon::Architecture;
 use wasmtime_jit_debug::perf_jitdump::*;
 
-use object::elf;
-
 /// Interface for driving the creation of jitdump files
 struct JitDumpAgent {
     pid: u32,
@@ -28,7 +27,7 @@ struct JitDumpAgent {
 /// Process-wide JIT dump file. Perf only accepts a unique file per process, in the injection step.
 static JITDUMP_FILE: Mutex<Option<JitDumpFile>> = Mutex::new(None);
 
-/// Intialize a JitDumpAgent and write out the header.
+/// Initialize a JitDumpAgent and write out the header.
 pub fn new() -> Result<Box<dyn ProfilingAgent>> {
     let mut jitdump_file = JITDUMP_FILE.lock().unwrap();
 
@@ -51,16 +50,15 @@ pub fn new() -> Result<Box<dyn ProfilingAgent>> {
 }
 
 impl ProfilingAgent for JitDumpAgent {
-    fn register_function(&self, name: &str, addr: *const u8, size: usize) {
+    fn register_function(&self, name: &str, code: &[u8]) {
         let mut jitdump_file = JITDUMP_FILE.lock().unwrap();
         let jitdump_file = jitdump_file.as_mut().unwrap();
         let timestamp = jitdump_file.get_time_stamp();
         #[allow(trivial_numeric_casts)]
         let tid = rustix::thread::gettid().as_raw_nonzero().get() as u32;
-        if let Err(err) =
-            jitdump_file.dump_code_load_record(&name, addr, size, timestamp, self.pid, tid)
+        if let Err(err) = jitdump_file.dump_code_load_record(&name, code, timestamp, self.pid, tid)
         {
-            println!("Jitdump: write_code_load_failed_record failed: {:?}\n", err);
+            println!("Jitdump: write_code_load_failed_record failed: {err:?}\n");
         }
     }
 }
diff --git a/crates/wasmtime/src/profiling_agent/perfmap.rs b/crates/wasmtime/src/profiling_agent/perfmap.rs
new file mode 100644
index 000000000000..8ed7fc8924fe
--- /dev/null
+++ b/crates/wasmtime/src/profiling_agent/perfmap.rs
@@ -0,0 +1,48 @@
+use crate::prelude::*;
+use crate::profiling_agent::ProfilingAgent;
+use std::io::{self, BufWriter, Write};
+use std::process;
+use std::{fs::File, sync::Mutex};
+
+/// Process-wide perf map file. Perf only reads a unique file per process.
+static PERFMAP_FILE: Mutex<Option<BufWriter<File>>> = Mutex::new(None);
+
+/// Interface for driving the creation of jitdump files
+struct PerfMapAgent;
+
+/// Initialize a JitDumpAgent and write out the header.
+pub fn new() -> Result<Box<dyn ProfilingAgent>> {
+    let mut file = PERFMAP_FILE.lock().unwrap();
+    if file.is_none() {
+        let filename = format!("/tmp/perf-{}.map", process::id());
+        *file = Some(BufWriter::new(File::create(filename)?));
+    }
+    Ok(Box::new(PerfMapAgent))
+}
+
+impl PerfMapAgent {
+    fn make_line(writer: &mut dyn Write, name: &str, code: &[u8]) -> io::Result<()> {
+        // Format is documented here: https://github.com/torvalds/linux/blob/master/tools/perf/Documentation/jit-interface.txt
+        // Try our best to sanitize the name, since wasm allows for any utf8 string in there.
+        let sanitized_name = name.replace('\n', "_").replace('\r', "_");
+        write!(
+            writer,
+            "{:p} {:x} {}\n",
+            code.as_ptr(),
+            code.len(),
+            sanitized_name
+        )?;
+        writer.flush()?;
+        Ok(())
+    }
+}
+
+impl ProfilingAgent for PerfMapAgent {
+    fn register_function(&self, name: &str, code: &[u8]) {
+        let mut file = PERFMAP_FILE.lock().unwrap();
+        let file = file.as_mut().unwrap();
+        if let Err(err) = Self::make_line(file, name, code) {
+            eprintln!("Error when writing import trampoline info to the perf map file: {err}");
+        }
+    }
+}
diff --git a/crates/jit/src/profiling/vtune.rs b/crates/wasmtime/src/profiling_agent/vtune.rs
similarity index 79%
rename from crates/jit/src/profiling/vtune.rs
rename to crates/wasmtime/src/profiling_agent/vtune.rs
index ca8bd1f1c1e2..cbf7f5d7b287 100644
--- a/crates/jit/src/profiling/vtune.rs
+++ b/crates/wasmtime/src/profiling_agent/vtune.rs
@@ -12,8 +12,8 @@
 //! installed](https://www.intel.com/content/www/us/en/developer/tools/oneapi/vtune-profiler.html#standalone)
 //! for this to work.
 
-use crate::profiling::ProfilingAgent;
-use anyhow::Result;
+use crate::prelude::*;
+use crate::profiling_agent::ProfilingAgent;
 use ittapi::jit::MethodLoadBuilder;
 use std::sync::Mutex;
 
@@ -47,10 +47,10 @@ impl Drop for VTuneAgent {
 
 impl State {
     /// Notify vtune about a newly tracked code region.
-    fn notify_code(&mut self, module_name: &str, method_name: &str, addr: *const u8, len: usize) {
+    fn notify_code(&mut self, module_name: &str, method_name: &str, code: &[u8]) {
         self.vtune
             .load_method(
-                MethodLoadBuilder::new(method_name.to_owned(), addr, len)
+                MethodLoadBuilder::new(method_name.to_owned(), code.as_ptr(), code.len())
                     .class_file_name(module_name.to_owned())
                     .source_file_name("<unknown wasm filename>".to_owned()),
             )
@@ -65,16 +65,13 @@ impl State {
 }
 
 impl ProfilingAgent for VTuneAgent {
-    fn register_function(&self, name: &str, addr: *const u8, size: usize) {
-        self.state
-            .lock()
-            .unwrap()
-            .register_function(name, addr, size);
+    fn register_function(&self, name: &str, code: &[u8]) {
+        self.state.lock().unwrap().register_function(name, code);
     }
 }
 
 impl State {
-    fn register_function(&mut self, name: &str, addr: *const u8, size: usize) {
-        self.notify_code("wasmtime", name, addr, size);
+    fn register_function(&mut self, name: &str, code: &[u8]) {
+        self.notify_code("wasmtime", name, code);
     }
 }
diff --git a/crates/wasmtime/src/ref.rs b/crates/wasmtime/src/ref.rs
deleted file mode 100644
index e04cbea2a2cf..000000000000
--- a/crates/wasmtime/src/ref.rs
+++ /dev/null
@@ -1,109 +0,0 @@
-#![allow(missing_docs)]
-
-use crate::AsContextMut;
-use std::any::Any;
-use std::ffi::c_void;
-use wasmtime_runtime::VMExternRef;
-
-/// Represents an opaque reference to any data within WebAssembly.
-#[derive(Clone, Debug)]
-#[repr(transparent)]
-pub struct ExternRef {
-    pub(crate) inner: VMExternRef,
-}
-
-impl ExternRef {
-    /// Creates a new instance of `ExternRef` wrapping the given value.
-    pub fn new<T>(value: T) -> ExternRef
-    where
-        T: 'static + Any + Send + Sync,
-    {
-        let inner = VMExternRef::new(value);
-        ExternRef { inner }
-    }
-
-    /// Get the underlying data for this `ExternRef`.
-    pub fn data(&self) -> &dyn Any {
-        &*self.inner
-    }
-
-    /// Get the strong reference count for this `ExternRef`.
-    ///
-    /// Note that this loads the reference count with a `SeqCst` ordering to
-    /// synchronize with other threads.
-    pub fn strong_count(&self) -> usize {
-        self.inner.strong_count()
-    }
-
-    /// Does this `ExternRef` point to the same inner value as `other`?
-    ///
-    /// This is *only* pointer equality, and does *not* run any inner value's
-    /// `Eq` implementation.
-    pub fn ptr_eq(&self, other: &ExternRef) -> bool {
-        VMExternRef::eq(&self.inner, &other.inner)
-    }
-
-    /// Creates a new strongly-owned [`ExternRef`] from the raw value provided.
-    ///
-    /// This is intended to be used in conjunction with [`Func::new_unchecked`],
-    /// [`Func::call_unchecked`], and [`ValRaw`] with its `externref` field.
-    ///
-    /// This function assumes that `raw` is an externref value which is
-    /// currently rooted within the [`Store`].
-    ///
-    /// # Unsafety
-    ///
-    /// This function is particularly `unsafe` because `raw` not only must be a
-    /// valid externref value produced prior by `to_raw` but it must also be
-    /// correctly rooted within the store. When arguments are provided to a
-    /// callback with [`Func::new_unchecked`], for example, or returned via
-    /// [`Func::call_unchecked`], if a GC is performed within the store then
-    /// floating externref values are not rooted and will be GC'd, meaning that
-    /// this function will no longer be safe to call with the values cleaned up.
-    /// This function must be invoked *before* possible GC operations can happen
-    /// (such as calling wasm).
-    ///
-    /// When in doubt try to not use this. Instead use the safe Rust APIs of
-    /// [`TypedFunc`] and friends.
-    ///
-    /// [`Func::call_unchecked`]: crate::Func::call_unchecked
-    /// [`Func::new_unchecked`]: crate::Func::new_unchecked
-    /// [`Store`]: crate::Store
-    /// [`TypedFunc`]: crate::TypedFunc
-    /// [`ValRaw`]: crate::ValRaw
-    pub unsafe fn from_raw(raw: *mut c_void) -> Option<ExternRef> {
-        let raw = raw.cast::<u8>();
-        if raw.is_null() {
-            None
-        } else {
-            Some(ExternRef {
-                inner: VMExternRef::clone_from_raw(raw),
-            })
-        }
-    }
-
-    /// Converts this [`ExternRef`] to a raw value suitable to store within a
-    /// [`ValRaw`].
-    ///
-    /// # Unsafety
-    ///
-    /// Produces a raw value which is only safe to pass into a store if a GC
-    /// doesn't happen between when the value is produce and when it's passed
-    /// into the store.
-    ///
-    /// [`ValRaw`]: crate::ValRaw
-    pub unsafe fn to_raw(&self, mut store: impl AsContextMut) -> *mut c_void {
-        let externref_ptr = self.inner.as_raw();
-        store
-            .as_context_mut()
-            .0
-            .insert_vmexternref_without_gc(self.inner.clone());
-        externref_ptr.cast()
-    }
-}
-
-impl std::fmt::Pointer for ExternRef {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        std::fmt::Pointer::fmt(&self.inner, f)
-    }
-}
diff --git a/crates/wasmtime/src/resources.rs b/crates/wasmtime/src/resources.rs
deleted file mode 100644
index da0555b34a85..000000000000
--- a/crates/wasmtime/src/resources.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-/// A summary of the amount of resources required to instantiate a particular
-/// [`Module`][crate::Module] or [`Component`][crate::component::Component].
-///
-/// Example uses of this information:
-///
-/// * Determining whether your pooling allocator configuration supports
-///   instantiating this module.
-///
-/// * Deciding how many of which `Module` you want to instantiate within a
-///   fixed amount of resources, e.g. determining whether to create 5
-///   instances of module `X` or 10 instances of module `Y`.
-pub struct ResourcesRequired {
-    /// The number of memories that are required.
-    pub num_memories: u32,
-    /// The maximum initial size required by any memory, in units of Wasm pages.
-    pub max_initial_memory_size: Option<u64>,
-    /// The number of tables that are required.
-    pub num_tables: u32,
-    /// The maximum initial size required by any table.
-    pub max_initial_table_size: Option<u32>,
-}
-
-impl ResourcesRequired {
-    #[cfg(feature = "component-model")]
-    pub(crate) fn add(&mut self, other: &ResourcesRequired) {
-        self.num_memories += other.num_memories;
-        self.max_initial_memory_size =
-            std::cmp::max(self.max_initial_memory_size, other.max_initial_memory_size);
-        self.num_tables += other.num_tables;
-        self.max_initial_table_size =
-            std::cmp::max(self.max_initial_table_size, other.max_initial_table_size);
-    }
-}
diff --git a/crates/wasmtime/src/runtime.rs b/crates/wasmtime/src/runtime.rs
new file mode 100644
index 000000000000..0d8eaca2da2c
--- /dev/null
+++ b/crates/wasmtime/src/runtime.rs
@@ -0,0 +1,113 @@
+#[macro_use]
+pub(crate) mod func;
+
+pub(crate) mod code;
+pub(crate) mod code_memory;
+pub(crate) mod debug;
+pub(crate) mod externals;
+pub(crate) mod gc;
+pub(crate) mod instance;
+pub(crate) mod instantiate;
+pub(crate) mod limits;
+pub(crate) mod linker;
+pub(crate) mod memory;
+pub(crate) mod module;
+pub(crate) mod resources;
+pub(crate) mod store;
+pub(crate) mod trampoline;
+pub(crate) mod trap;
+pub(crate) mod type_registry;
+pub(crate) mod types;
+pub(crate) mod uninhabited;
+pub(crate) mod v128;
+pub(crate) mod values;
+pub(crate) mod vm;
+
+#[cfg(feature = "component-model")]
+pub mod component;
+
+cfg_if::cfg_if! {
+    if #[cfg(miri)] {
+        // no extensions on miri
+    } else if #[cfg(unix)] {
+        pub mod unix;
+    } else if #[cfg(windows)] {
+        pub mod windows;
+    } else {
+        // ... unknown os!
+    }
+}
+
+pub use code_memory::CodeMemory;
+pub use externals::*;
+pub use func::*;
+pub use gc::*;
+pub use instance::{Instance, InstancePre};
+pub use instantiate::CompiledModule;
+pub use limits::*;
+pub use linker::*;
+pub use memory::*;
+pub use module::{Module, ModuleExport};
+pub use resources::*;
+#[cfg(all(feature = "async", feature = "call-hook"))]
+pub use store::CallHookHandler;
+pub use store::{
+    AsContext, AsContextMut, CallHook, Store, StoreContext, StoreContextMut, UpdateDeadline,
+};
+pub use trap::*;
+pub use types::*;
+pub use v128::V128;
+pub use values::*;
+
+pub(crate) use uninhabited::*;
+
+#[cfg(feature = "pooling-allocator")]
+pub use vm::PoolConcurrencyLimitError;
+
+#[cfg(feature = "profiling")]
+mod profiling;
+#[cfg(feature = "profiling")]
+pub use profiling::GuestProfiler;
+
+#[cfg(feature = "async")]
+pub(crate) mod stack;
+#[cfg(feature = "async")]
+pub use stack::*;
+
+#[cfg(feature = "coredump")]
+mod coredump;
+#[cfg(feature = "coredump")]
+pub use coredump::*;
+
+fn _assertions_runtime() {
+    use crate::_assert_send_and_sync;
+
+    #[cfg(feature = "async")]
+    fn _assert_send<T: Send>(_t: T) {}
+
+    _assert_send_and_sync::<Caller<'_, ()>>();
+    _assert_send_and_sync::<ExternRef>();
+    _assert_send_and_sync::<(Func, TypedFunc<(), ()>, Global, Table, Memory)>();
+    _assert_send_and_sync::<Instance>();
+    _assert_send_and_sync::<InstancePre<()>>();
+    _assert_send_and_sync::<InstancePre<*mut u8>>();
+    _assert_send_and_sync::<Linker<()>>();
+    _assert_send_and_sync::<Linker<*mut u8>>();
+    _assert_send_and_sync::<Module>();
+    _assert_send_and_sync::<Store<()>>();
+    _assert_send_and_sync::<StoreContext<'_, ()>>();
+    _assert_send_and_sync::<StoreContextMut<'_, ()>>();
+
+    #[cfg(feature = "async")]
+    fn _call_async(s: &mut Store<()>, f: Func) {
+        _assert_send(f.call_async(&mut *s, &[], &mut []))
+    }
+    #[cfg(feature = "async")]
+    fn _typed_call_async(s: &mut Store<()>, f: TypedFunc<(), ()>) {
+        _assert_send(f.call_async(&mut *s, ()))
+    }
+    #[cfg(feature = "async")]
+    fn _instantiate_async(s: &mut Store<()>, m: &Module) {
+        _assert_send(Instance::new_async(s, m, &[]))
+    }
+}
diff --git a/crates/wasmtime/src/code.rs b/crates/wasmtime/src/runtime/code.rs
similarity index 85%
rename from crates/wasmtime/src/code.rs
rename to crates/wasmtime/src/runtime/code.rs
index a0d1037e705d..5030d29623fc 100644
--- a/crates/wasmtime/src/code.rs
+++ b/crates/wasmtime/src/runtime/code.rs
@@ -1,9 +1,8 @@
-use crate::signatures::SignatureCollection;
-use std::sync::Arc;
+use crate::{code_memory::CodeMemory, type_registry::TypeCollection};
+use alloc::sync::Arc;
 #[cfg(feature = "component-model")]
 use wasmtime_environ::component::ComponentTypes;
 use wasmtime_environ::ModuleTypes;
-use wasmtime_jit::CodeMemory;
 
 /// Metadata in Wasmtime about a loaded compiled artifact in memory which is
 /// ready to execute.
@@ -26,8 +25,8 @@ pub struct CodeObject {
     ///
     /// Note that this type has a significant destructor which unregisters
     /// signatures within the `Engine` it was originally tied to, and this ends
-    /// up corresponding to the liftime of a `Component` or `Module`.
-    signatures: SignatureCollection,
+    /// up corresponding to the lifetime of a `Component` or `Module`.
+    signatures: TypeCollection,
 
     /// Type information for the loaded object.
     ///
@@ -37,8 +36,8 @@ pub struct CodeObject {
 }
 
 impl CodeObject {
-    pub fn new(mmap: Arc<CodeMemory>, signatures: SignatureCollection, types: Types) -> CodeObject {
-        // The corresopnding unregister for this is below in `Drop for
+    pub fn new(mmap: Arc<CodeMemory>, signatures: TypeCollection, types: Types) -> CodeObject {
+        // The corresponding unregister for this is below in `Drop for
         // CodeObject`.
         crate::module::register_code(&mmap);
 
@@ -62,7 +61,7 @@ impl CodeObject {
         self.types.module_types()
     }
 
-    pub fn signatures(&self) -> &SignatureCollection {
+    pub fn signatures(&self) -> &TypeCollection {
         &self.signatures
     }
 }
diff --git a/crates/jit/src/code_memory.rs b/crates/wasmtime/src/runtime/code_memory.rs
similarity index 88%
rename from crates/jit/src/code_memory.rs
rename to crates/wasmtime/src/runtime/code_memory.rs
index 5b4909b48117..7a683d477f3b 100644
--- a/crates/jit/src/code_memory.rs
+++ b/crates/wasmtime/src/runtime/code_memory.rs
@@ -1,16 +1,14 @@
 //! Memory management for executable code.
 
-use crate::subslice_range;
-use crate::unwind::UnwindRegistration;
-use anyhow::{anyhow, bail, Context, Result};
-use object::read::{File, Object, ObjectSection};
+use crate::prelude::*;
+use crate::runtime::vm::{libcalls, MmapVec, UnwindRegistration};
+use core::mem::ManuallyDrop;
+use core::ops::Range;
+use object::endian::NativeEndian;
+use object::read::{elf::ElfFile64, Object, ObjectSection};
 use object::ObjectSymbol;
-use std::mem::ManuallyDrop;
-use std::ops::Range;
-use wasmtime_environ::obj;
+use wasmtime_environ::{lookup_trap_code, obj, Trap};
 use wasmtime_jit_icache_coherence as icache_coherence;
-use wasmtime_runtime::libcalls;
-use wasmtime_runtime::MmapVec;
 
 /// Management of executable memory within a `MmapVec`
 ///
@@ -59,7 +57,8 @@ impl CodeMemory {
     /// The returned `CodeMemory` manages the internal `MmapVec` and the
     /// `publish` method is used to actually make the memory executable.
     pub fn new(mmap: MmapVec) -> Result<Self> {
-        let obj = File::parse(&mmap[..])
+        let obj = ElfFile64::<NativeEndian>::parse(&mmap[..])
+            .err2anyhow()
             .with_context(|| "failed to parse internal compilation artifact")?;
 
         let mut relocations = Vec::new();
@@ -73,8 +72,8 @@ impl CodeMemory {
         let mut info_data = 0..0;
         let mut dwarf = 0..0;
         for section in obj.sections() {
-            let data = section.data()?;
-            let name = section.name()?;
+            let data = section.data().err2anyhow()?;
+            let name = section.name().err2anyhow()?;
             let range = subslice_range(data, &mmap);
 
             // Double-check that sections are all aligned properly.
@@ -105,7 +104,7 @@ impl CodeMemory {
                     for (offset, reloc) in section.relocations() {
                         assert_eq!(reloc.kind(), object::RelocationKind::Absolute);
                         assert_eq!(reloc.encoding(), object::RelocationEncoding::Generic);
-                        assert_eq!(usize::from(reloc.size()), std::mem::size_of::<usize>());
+                        assert_eq!(usize::from(reloc.size()), core::mem::size_of::<usize>() * 8);
                         assert_eq!(reloc.addend(), 0);
                         let sym = match reloc.target() {
                             object::RelocationTarget::Symbol(id) => id,
@@ -149,22 +148,26 @@ impl CodeMemory {
     }
 
     /// Returns a reference to the underlying `MmapVec` this memory owns.
+    #[inline]
     pub fn mmap(&self) -> &MmapVec {
         &self.mmap
     }
 
     /// Returns the contents of the text section of the ELF executable this
     /// represents.
+    #[inline]
     pub fn text(&self) -> &[u8] {
         &self.mmap[self.text.clone()]
     }
 
     /// Returns the contents of the `ELF_WASMTIME_DWARF` section.
+    #[inline]
     pub fn dwarf(&self) -> &[u8] {
         &self.mmap[self.dwarf.clone()]
     }
 
     /// Returns the data in the `ELF_NAME_DATA` section.
+    #[inline]
     pub fn func_name_data(&self) -> &[u8] {
         &self.mmap[self.func_name_data.clone()]
     }
@@ -174,24 +177,28 @@ impl CodeMemory {
     ///
     /// This is used for initialization of memories and all data ranges stored
     /// in a `Module` are relative to the slice returned here.
+    #[inline]
     pub fn wasm_data(&self) -> &[u8] {
         &self.mmap[self.wasm_data.clone()]
     }
 
     /// Returns the encoded address map section used to pass to
     /// `wasmtime_environ::lookup_file_pos`.
+    #[inline]
     pub fn address_map_data(&self) -> &[u8] {
         &self.mmap[self.address_map_data.clone()]
     }
 
     /// Returns the contents of the `ELF_WASMTIME_INFO` section, or an empty
     /// slice if it wasn't found.
+    #[inline]
     pub fn wasmtime_info(&self) -> &[u8] {
         &self.mmap[self.info_data.clone()]
     }
 
     /// Returns the contents of the `ELF_WASMTIME_TRAPS` section, or an empty
     /// slice if it wasn't found.
+    #[inline]
     pub fn trap_data(&self) -> &[u8] {
         &self.mmap[self.trap_data.clone()]
     }
@@ -310,4 +317,27 @@ impl CodeMemory {
         *self.unwind_registration = Some(registration);
         Ok(())
     }
+
+    /// Looks up the given offset within this module's text section and returns
+    /// the trap code associated with that instruction, if there is one.
+    pub fn lookup_trap_code(&self, text_offset: usize) -> Option<Trap> {
+        lookup_trap_code(self.trap_data(), text_offset)
+    }
+}
+
+/// Returns the range of `inner` within `outer`, such that `outer[range]` is the
+/// same as `inner`.
+///
+/// This method requires that `inner` is a sub-slice of `outer`, and if that
+/// isn't true then this method will panic.
+fn subslice_range(inner: &[u8], outer: &[u8]) -> Range<usize> {
+    if inner.len() == 0 {
+        return 0..0;
+    }
+
+    assert!(outer.as_ptr() <= inner.as_ptr());
+    assert!((&inner[inner.len() - 1] as *const _) <= (&outer[outer.len() - 1] as *const _));
+
+    let start = inner.as_ptr() as usize - outer.as_ptr() as usize;
+    start..start + inner.len()
 }
diff --git a/crates/wasmtime/src/runtime/component/bindgen_examples/_0_hello_world.rs b/crates/wasmtime/src/runtime/component/bindgen_examples/_0_hello_world.rs
new file mode 100644
index 000000000000..fcc566e89275
--- /dev/null
+++ b/crates/wasmtime/src/runtime/component/bindgen_examples/_0_hello_world.rs
@@ -0,0 +1,9 @@
+bindgen!({
+  inline: r#"
+      package my:project;
+      world hello-world {
+          import name: func() -> string;
+          export greet: func();
+      }
+  "#,
+});
diff --git a/crates/wasmtime/src/runtime/component/bindgen_examples/_1_world_imports.rs b/crates/wasmtime/src/runtime/component/bindgen_examples/_1_world_imports.rs
new file mode 100644
index 000000000000..deb8c94bdbe5
--- /dev/null
+++ b/crates/wasmtime/src/runtime/component/bindgen_examples/_1_world_imports.rs
@@ -0,0 +1,17 @@
+bindgen!({
+    inline: r#"
+        package example:imports;
+
+        world my-world {
+            /// Fetch a greeting to present.
+            import greet: func() -> string;
+
+            /// Log a message to the host.
+            import log: func(msg: string);
+
+            import my-custom-host: interface {
+                tick: func();
+            }
+        }
+    "#,
+});
diff --git a/crates/wasmtime/src/runtime/component/bindgen_examples/_2_world_exports.rs b/crates/wasmtime/src/runtime/component/bindgen_examples/_2_world_exports.rs
new file mode 100644
index 000000000000..2ee5181daa38
--- /dev/null
+++ b/crates/wasmtime/src/runtime/component/bindgen_examples/_2_world_exports.rs
@@ -0,0 +1,18 @@
+bindgen!({
+    inline: r#"
+        package my:project;
+
+        interface host {
+            gen-random-integer: func() -> u32;
+            sha256: func(bytes: list<u8>) -> string;
+        }
+
+        world hello-world {
+            import host;
+
+            export demo: interface {
+                run: func();
+            }
+        }
+    "#,
+});
diff --git a/crates/wasmtime/src/runtime/component/bindgen_examples/_3_interface_imports.rs b/crates/wasmtime/src/runtime/component/bindgen_examples/_3_interface_imports.rs
new file mode 100644
index 000000000000..de899279b63c
--- /dev/null
+++ b/crates/wasmtime/src/runtime/component/bindgen_examples/_3_interface_imports.rs
@@ -0,0 +1,20 @@
+bindgen!({
+    inline: r#"
+        package example:interface-imports;
+
+        interface logging {
+            enum level {
+                debug,
+                info,
+                warn,
+                error,
+            }
+
+            log: func(level: level, msg: string);
+        }
+
+        world with-imports {
+            import logging;
+        }
+    "#,
+});
diff --git a/crates/wasmtime/src/runtime/component/bindgen_examples/_4_imported_resources.rs b/crates/wasmtime/src/runtime/component/bindgen_examples/_4_imported_resources.rs
new file mode 100644
index 000000000000..5540c19babd4
--- /dev/null
+++ b/crates/wasmtime/src/runtime/component/bindgen_examples/_4_imported_resources.rs
@@ -0,0 +1,45 @@
+bindgen!({
+    inline: r#"
+        package example:imported-resources;
+
+        interface logging {
+            enum level {
+                debug,
+                info,
+                warn,
+                error,
+            }
+
+            resource logger {
+                constructor(max-level: level);
+
+                get-max-level: func() -> level;
+                set-max-level: func(level: level);
+
+                log: func(level: level, msg: string);
+            }
+        }
+
+        world import-some-resources {
+            import logging;
+        }
+    "#,
+
+    with: {
+        // Specify that our host resource is going to point to the `MyLogger`
+        // which is defined just below this macro.
+        "example:imported-resources/logging/logger": MyLogger,
+    },
+
+    // Interactions with `ResourceTable` can possibly trap so enable the ability
+    // to return traps from generated functions.
+    trappable_imports: true,
+});
+
+/// A sample host-defined type which contains arbitrary host-defined data.
+///
+/// In this case this is relatively simple but there's no restrictions on what
+/// this type can hold other than that it must be `'static + Send`.
+pub struct MyLogger {
+    pub max_level: example::imported_resources::logging::Level,
+}
diff --git a/crates/wasmtime/src/runtime/component/bindgen_examples/_5_all_world_export_kinds.rs b/crates/wasmtime/src/runtime/component/bindgen_examples/_5_all_world_export_kinds.rs
new file mode 100644
index 000000000000..d138f17e8675
--- /dev/null
+++ b/crates/wasmtime/src/runtime/component/bindgen_examples/_5_all_world_export_kinds.rs
@@ -0,0 +1,29 @@
+bindgen!({
+    inline: r#"
+        package example:world-exports;
+
+        world with-exports {
+            import log: func(msg: string);
+
+            export run: func();
+
+            /// An example of exporting an interface inline and naming it
+            /// directly.
+            export environment: interface {
+                get: func(var: string) -> string;
+                set: func(var: string, val: string);
+            }
+
+            /// An example of exporting an interface.
+            export units;
+        }
+
+        interface units {
+            /// Renders the number of bytes as a human readable string.
+            bytes-to-string: func(bytes: u64) -> string;
+
+            /// Renders the provided duration as a human readable string.
+            duration-to-string: func(seconds: u64, ns: u32) -> string;
+        }
+    "#,
+});
diff --git a/crates/wasmtime/src/runtime/component/bindgen_examples/_6_exported_resources.rs b/crates/wasmtime/src/runtime/component/bindgen_examples/_6_exported_resources.rs
new file mode 100644
index 000000000000..576450cc6678
--- /dev/null
+++ b/crates/wasmtime/src/runtime/component/bindgen_examples/_6_exported_resources.rs
@@ -0,0 +1,26 @@
+bindgen!({
+    inline: r#"
+        package example:exported-resources;
+
+        world export-some-resources {
+            export logging;
+        }
+
+        interface logging {
+            enum level {
+                debug,
+                info,
+                warn,
+                error,
+            }
+            resource logger {
+                constructor(max-level: level);
+
+                get-max-level: func() -> level;
+                set-max-level: func(level: level);
+
+                log: func(level: level, msg: string);
+            }
+        }
+    "#,
+});
diff --git a/crates/wasmtime/src/runtime/component/bindgen_examples/mod.rs b/crates/wasmtime/src/runtime/component/bindgen_examples/mod.rs
new file mode 100644
index 000000000000..638431c4506d
--- /dev/null
+++ b/crates/wasmtime/src/runtime/component/bindgen_examples/mod.rs
@@ -0,0 +1,488 @@
+//! Examples of output of the [`bindgen!`] macro.
+//!
+//! This module is only included in docs.rs documentation and is not present in
+//! the actual crate when compiling from crates.io. The purpose of this module
+//! is to showcase what the output of the [`bindgen!`] macro looks like and some
+//! examples of how to use it.
+//!
+//! If you're confused or lost in [`bindgen!`] feel free to [open an issue]
+//! with a description of your issue and it can hopefully lead to a new example
+//! being added here for others to use as reference.
+//!
+//! ## Including `*.wit` files in your project
+//!
+//! Note that most of the examples in this module will use the `inline` key of
+//! the [`bindgen!`] macro. This is done as it's easy to show the example and
+//! WIT all in one self-contained snippet of Rust code. Typically though a
+//! project will have a `wit` directory next to `Cargo.toml` which contains WIT
+//! files.
+//!
+//! The general layout of a `wit` directory is that:
+//!
+//! * All `*.wit` files at `wit/*.wit` are parsed and included in the same
+//!   package.
+//! * If the `wit/deps` folder is present then it can either contain:
+//!   * Subdirectories with a package-per-directory. For example
+//!     `wit/deps/wasi-http` and `wit/deps/wasi-cli`.
+//!   * WIT files that are a single-file rendering of a package, for example
+//!     `wit/deps/wasi-http.wit`
+//!   * WIT packages encoded as WebAssembly binaries for a package, for example
+//!     `wit/deps/wasi-http.wasm`
+//!
+//! This means that at this time you'll need to copy around `*.wit` files or
+//! WIT packages encoded as `*.wasm` and check them in to your project's `wit`
+//! directory. The hope is that in the future it will be easier to manage these
+//! files with registry tooling and they won't have to be copied manually.
+//! For reference documentation on the layout of the `wit` directory see
+//! [`wit_parser::Resolve::push_dir`].
+//!
+//! [`bindgen!`]: crate::component::bindgen
+//! [`wit_parser::Resolve::push_dir`]: https://docs.rs/wit-parser/latest/wit_parser/struct.Resolve.html#method.push_dir
+//! [open an issue]: https://github.com/bytecodealliance/wasmtime/issues/new
+
+#![allow(missing_docs)]
+
+// This "hack" will shadow the `bindgen` macro in general and be inherited to
+// following modules by default. This enables documenting sources as-is while
+// additionally customizing them to working within the wasmtime crate itself by
+// injecting a configuration option to change how the `wasmtime` crate is
+// referenced in the generated output.
+//
+// Note that this has an additional "hack" such that when docs.rs is documenting
+// this crate (or CI) then `include_generated_code_from_file` is unconditionally
+// turned on. This makes `[source]` links on documentation show the actual
+// generated code rather than just the `bindgen!` macro invocation, which can be
+// helpful when exploring code.
+#[cfg(docsrs)]
+macro_rules! bindgen {
+    ({$($t:tt)*}) => (crate::component::bindgen!({
+        $($t)*
+        wasmtime_crate: crate,
+        include_generated_code_from_file: true,
+    }););
+}
+#[cfg(not(docsrs))]
+macro_rules! bindgen {
+    ({$($t:tt)*}) => (crate::component::bindgen!({
+        $($t)*
+        wasmtime_crate: crate,
+    }););
+}
+
+/// A "hello world" style example.
+///
+/// This example loads a component which has access to a single host function.
+/// The exported function is called on an instantiation of the component.
+///
+/// ```rust
+/// use wasmtime::component::*;
+/// use wasmtime::{Engine, Store};
+///
+#[doc = include_str!("./_0_hello_world.rs")]
+///
+/// struct MyState {
+///     name: String,
+/// }
+///
+/// // Imports into the world, like the `name` import for this world, are
+/// // satisfied through traits.
+/// impl HelloWorldImports for MyState {
+///     fn name(&mut self) -> String {
+///         self.name.clone()
+///     }
+/// }
+///
+/// fn main() -> wasmtime::Result<()> {
+/// #   if true { return Ok(()) }
+///     // Compile the `Component` that is being run for the application.
+///     let engine = Engine::default();
+///     let component = Component::from_file(&engine, "./your-component.wasm")?;
+///
+///     // Instantiation of bindings always happens through a `Linker`.
+///     // Configuration of the linker is done through a generated `add_to_linker`
+///     // method on the bindings structure.
+///     //
+///     // Note that the closure provided here is a projection from `T` in
+///     // `Store<T>` to `&mut U` where `U` implements the `HelloWorldImports`
+///     // trait. In this case the `T`, `MyState`, is stored directly in the
+///     // structure so no projection is necessary here.
+///     let mut linker = Linker::new(&engine);
+///     HelloWorld::add_to_linker(&mut linker, |state: &mut MyState| state)?;
+///
+///     // As with the core wasm API of Wasmtime instantiation occurs within a
+///     // `Store`. The bindings structure contains an `instantiate` method which
+///     // takes the store, component, and linker. This returns the `bindings`
+///     // structure which is an instance of `HelloWorld` and supports typed access
+///     // to the exports of the component.
+///     let mut store = Store::new(
+///         &engine,
+///         MyState {
+///             name: "me".to_string(),
+///         },
+///     );
+///     let bindings = HelloWorld::instantiate(&mut store, &component, &linker)?;
+///
+///     // Here our `greet` function doesn't take any parameters for the component,
+///     // but in the Wasmtime embedding API the first argument is always a `Store`.
+///     bindings.call_greet(&mut store)?;
+///     Ok(())
+/// }
+/// ```
+pub mod _0_hello_world;
+
+/// An example of generated bindings for top-level imported functions and
+/// interfaces into a world.
+///
+/// The code used to generate this module is:
+///
+/// ```rust
+/// use wasmtime::component::*;
+/// use wasmtime::{Engine, Store};
+///
+#[doc = include_str!("./_1_world_imports.rs")]
+///
+/// struct MyState {
+///     // ...
+/// }
+///
+/// impl my_custom_host::Host for MyState {
+///     fn tick(&mut self) {
+///         todo!()
+///     }
+/// }
+///
+/// impl MyWorldImports for MyState {
+///     fn greet(&mut self) -> String {
+///         todo!()
+///     }
+///
+///     fn log(&mut self, msg: String) {
+///         println!("{msg}");
+///     }
+/// }
+///
+/// fn main() -> wasmtime::Result<()> {
+/// #   if true { return Ok(()) }
+///     let engine = Engine::default();
+///     let component = Component::from_file(&engine, "./your-component.wasm")?;
+///
+///     let mut linker = Linker::new(&engine);
+///     MyWorld::add_to_linker(&mut linker, |state: &mut MyState| state)?;
+///
+///     let mut store = Store::new(
+///         &engine,
+///         MyState { /* ... */ },
+///     );
+///     let bindings = MyWorld::instantiate(&mut store, &component, &linker)?;
+///
+///     // ... NB: this world has no exports just yet so not much can be done
+///     // with `bindings`.
+///
+///     Ok(())
+/// }
+/// ```
+pub mod _1_world_imports;
+
+/// An example of generated bindings for top-level exported functions for a
+/// world.
+///
+/// Some notable generated items here are:
+///
+/// * [`my::project::host::Host`](_2_world_exports::my::project::host::Host) -
+///   the generated trait for the `interface host` import.
+/// * [`exports::demo::Guest`](_2_world_exports::exports::demo::Guest) -
+///   the generated structured used to invoke exports on the returned instance.
+/// * [`HelloWorld`](_2_world_exports::HelloWorld) -
+///   the overall generated structure representing our `world`.
+///
+/// ```rust
+/// use wasmtime::component::*;
+/// use wasmtime::{Engine, Store};
+///
+#[doc = include_str!("./_2_world_exports.rs")]
+///
+/// struct MyState {
+///     // ...
+/// }
+///
+/// # mod rand { pub fn thread_rng() -> G { G } pub struct G; impl G { pub fn gen(&self) -> u32 { 0 } } }
+/// // Note that the trait here is per-interface and within a submodule now.
+/// impl my::project::host::Host for MyState {
+///     fn gen_random_integer(&mut self) -> u32 {
+///         rand::thread_rng().gen()
+///     }
+///
+///     fn sha256(&mut self, bytes: Vec<u8>) -> String {
+///         // ...
+/// #       panic!()
+///     }
+/// }
+///
+/// fn main() -> wasmtime::Result<()> {
+/// #   if true { return Ok(()) }
+///     let engine = Engine::default();
+///     let component = Component::from_file(&engine, "./your-component.wasm")?;
+///
+///     let mut linker = Linker::new(&engine);
+///     HelloWorld::add_to_linker(&mut linker, |state: &mut MyState| state)?;
+///
+///     let mut store = Store::new(
+///         &engine,
+///         MyState { /* ... */ },
+///     );
+///     let bindings = HelloWorld::instantiate(&mut store, &component, &linker)?;
+///
+///     // Note that the `demo` method returns a `&exports::Demo::Guest`
+///     // through which we can run the methods on that interface.
+///     bindings.demo().call_run(&mut store)?;
+///     Ok(())
+/// }
+/// ```
+pub mod _2_world_exports;
+
+/// Example of generating bindings for imported interfaces in a world.
+///
+/// Notable parts of this example are:
+///
+/// * Imported interfaces use the Rust module system to encapsulate themselves.
+///   The interface imported here is `example:interface-imports/logging` so the
+///   generated trait and types are located in
+///   [`example::interface_imports::logging`][module].
+/// * Types in the `logging` interface are generated in the `logging` module,
+///   for example [`Level`].
+/// * Generated types have implementations of [`ComponentType`], [`Lift`], and
+///   [`Lower`] derived.
+/// * The generated trait that host's must implement is always called [`Host`]
+///   and is located in the generated module.
+///
+/// [module]: _3_interface_imports::example::interface_imports::logging
+/// [`Level`]: _3_interface_imports::example::interface_imports::logging::Level
+/// [`Host`]: _3_interface_imports::example::interface_imports::logging::Host
+/// [`ComponentType`]: crate::component::ComponentType
+/// [`Lift`]: crate::component::Lift
+/// [`Lower`]: crate::component::Lower
+///
+/// ```rust
+/// use wasmtime::component::bindgen;
+/// use example::interface_imports::logging::Level;
+///
+#[doc = include_str!("./_3_interface_imports.rs")]
+///
+/// struct MyState {
+///     // ...
+/// }
+///
+/// impl example::interface_imports::logging::Host for MyState {
+///     fn log(&mut self, level: Level, msg: String) {
+///         // ...
+///     }
+/// }
+/// ```
+pub mod _3_interface_imports;
+
+/// Example of generating bindings for imported resources in a world.
+///
+/// Notable parts of this example are:
+///
+/// * Imported resources from the host are represented as traits, in this case
+///   [`HostLogger`].
+/// * The per-interface [`Host`] trait still exists but has a supertrait of
+///   [`HostLogger`].
+/// * Resources are represented as [`Resource<T>`] and it's recommended to
+///   specify a `with` key to indicate what host type you'd like to use for
+///   each resource.
+/// * A [`ResourceTable`] can be used to manage resources when working with
+///   guests.
+///
+/// [`Host`]: _4_imported_resources::example::imported_resources::logging::Host
+/// [`HostLogger`]: _4_imported_resources::example::imported_resources::logging::HostLogger
+/// [`Resource<T>`]: crate::component::Resource
+/// [`ResourceTable`]: crate::component::ResourceTable
+///
+/// ```rust
+/// use wasmtime::Result;
+/// use wasmtime::component::{bindgen, ResourceTable, Resource};
+/// use example::imported_resources::logging::{Level, Host, HostLogger};
+///
+#[doc = include_str!("./_4_imported_resources.rs")]
+///
+/// #[derive(Default)]
+/// struct MyState {
+///     // Manages the mapping of `MyLogger` structures to `Resource<MyLogger>`.
+///     table: ResourceTable,
+/// }
+///
+/// // There are no free-functions on `interface logging`, so this is an empty
+/// // impl.
+/// impl Host for MyState {}
+///
+/// // This separate `HostLogger` trait serves to act as a namespace for just
+/// // the `logger`-related resource methods.
+/// impl HostLogger for MyState {
+///     // A `constructor` in WIT maps to a `new` function in Rust.
+///     fn new(&mut self, max_level: Level) -> Result<Resource<MyLogger>> {
+///         let id = self.table.push(MyLogger { max_level })?;
+///         Ok(id)
+///     }
+///
+///     fn get_max_level(&mut self, logger: Resource<MyLogger>) -> Result<Level> {
+///         debug_assert!(!logger.owned());
+///         let logger = self.table.get(&logger)?;
+///         Ok(logger.max_level)
+///     }
+///
+///     fn set_max_level(&mut self, logger: Resource<MyLogger>, level: Level) -> Result<()> {
+///         debug_assert!(!logger.owned());
+///         let logger = self.table.get_mut(&logger)?;
+///         logger.max_level = level;
+///         Ok(())
+///     }
+///
+///     fn log(&mut self, logger: Resource<MyLogger>, level: Level, msg: String) -> Result<()> {
+///         debug_assert!(!logger.owned());
+///         let logger = self.table.get_mut(&logger)?;
+///         if (level as u32) <= (logger.max_level as u32) {
+///             println!("{msg}");
+///         }
+///         Ok(())
+///     }
+///
+///     fn drop(&mut self, logger: Resource<MyLogger>) -> Result<()> {
+///         debug_assert!(logger.owned());
+///         let _logger: MyLogger = self.table.delete(logger)?;
+///         // ... custom destruction logic here if necessary, otherwise
+///         // a `Drop for MyLogger` would also work.
+///         Ok(())
+///     }
+/// }
+///
+/// # fn main() {}
+/// ```
+pub mod _4_imported_resources;
+
+/// Example of all kinds of structures of exports from a world.
+///
+/// * Top-level functions in a `world` are exported directly on the generated
+///   structure such as [`call_run`].
+/// * All other exports are otherwise scoped with generated traits/types
+///   in a top level [`exports`] module.
+/// * Exported named interfaces are located at the root of the [`exports`]
+///   module, such as [`exports::environment`].
+/// * Interfaces are all bound with a structure called `Guest` which has typed
+///   functions for each export that can be called. For example
+///   [`exports::environment::Guest`][guest1] and
+///   [`exports::example::world_exports::units::Guest`][guest2].
+/// * Interfaces exported by their id are modeled with multiple namespacing
+///   modules, such as [`exports::example::world_exports::units`][units].
+///
+/// [`call_run`]: _5_all_world_export_kinds::WithExports::call_run
+/// [`exports`]: _5_all_world_export_kinds::exports
+/// [`exports::environment`]: _5_all_world_export_kinds::exports::environment
+/// [guest1]: _5_all_world_export_kinds::exports::environment::Guest
+/// [guest2]: _5_all_world_export_kinds::exports::example::world_exports::units::Guest
+/// [units]: _5_all_world_export_kinds::exports::example::world_exports::units
+///
+/// ```rust
+/// use wasmtime::{Result, Engine, Store};
+/// use wasmtime::component::{bindgen, Component, Linker};
+///
+#[doc = include_str!("./_5_all_world_export_kinds.rs")]
+///
+/// struct MyState;
+///
+/// impl WithExportsImports for MyState {
+///     fn log(&mut self, msg: String) {
+///         println!("{msg}");
+///     }
+/// }
+///
+/// fn main() -> Result<()> {
+/// #   if true { return Ok(()) }
+///     let engine = Engine::default();
+///     let component = Component::from_file(&engine, "./your-component.wasm")?;
+///
+///     let mut linker = Linker::new(&engine);
+///     WithExports::add_to_linker(&mut linker, |state: &mut MyState| state)?;
+///
+///     let mut store = Store::new(&engine, MyState);
+///     let bindings = WithExports::instantiate(&mut store, &component, &linker)?;
+///
+///     // top-level functions are exported directly on `WithExports` and are
+///     // all prefixed with `call_*`.
+///     bindings.call_run(&mut store)?;
+///
+///     // exported named interfaces are named directly after their export name
+///     // and the `&Guest` return value has `call_*` functions on it.
+///     bindings.environment().call_set(&mut store, "key", "value")?;
+///     let value = bindings.environment().call_get(&mut store, "key")?;
+///     assert_eq!(value, "value");
+///
+///     // exported interfaces by id are similar to export-by-name except that
+///     // the exported name is modeled after the full id, not just the name.
+///     let units = bindings.example_world_exports_units();
+///     let bytes = 1 << 30 + 1 << 20;
+///     let s = units.call_bytes_to_string(&mut store, bytes)?;
+///     println!("{bytes} = {s}");
+///
+///     let (seconds, ns) = (1 << 20, 12345);
+///     let s = units.call_duration_to_string(&mut store, seconds, ns)?;
+///     println!("{seconds}s + {ns}ns = {s}");
+///     Ok(())
+/// }
+/// ```
+pub mod _5_all_world_export_kinds;
+
+/// Example of a world which exports a resource.
+///
+/// * Guest resources are modeled as [`ResourceAny`]. Note that this type is not
+///   specialized per-resource at this time so care must be taken to not mix
+///   them up.
+/// * Resource-related methods are a projection from a [`Guest`] structure, for
+///   example to [`GuestLogger`] here.
+/// * Resource-related methods all take a [`ResourceAny`] as an argument or
+///   a return value.
+/// * The [`ResourceAny`] must be explicitly dropped.
+///
+/// [`ResourceAny`]: crate::component::ResourceAny
+/// [`Guest`]: _6_exported_resources::exports::example::exported_resources::logging::Guest
+/// [`GuestLogger`]: _6_exported_resources::exports::example::exported_resources::logging::GuestLogger
+///
+/// ```rust
+/// use wasmtime::{Result, Engine, Store};
+/// use wasmtime::component::{bindgen, Component, Linker};
+/// use self::exports::example::exported_resources::logging::Level;
+///
+#[doc = include_str!("./_6_exported_resources.rs")]
+///
+/// struct MyState;
+///
+/// fn main() -> Result<()> {
+/// #   if true { return Ok(()) }
+///     let engine = Engine::default();
+///     let component = Component::from_file(&engine, "./your-component.wasm")?;
+///
+///     let linker = Linker::new(&engine);
+///     // ... this small example has no imports so nothing is added here, but
+///     // if you had imports this is where they'd go.
+///
+///     let mut store = Store::new(&engine, MyState);
+///     let bindings = ExportSomeResources::instantiate(&mut store, &component, &linker)?;
+///     let guest = bindings.example_exported_resources_logging();
+///     let logger = guest.logger();
+///
+///     // Resource methods are all attached to `logger` and take the
+///     // `ResourceAny` parameter explicitly.
+///     let my_logger = logger.call_constructor(&mut store, Level::Warn)?;
+///     assert_eq!(logger.call_get_max_level(&mut store, my_logger)?, Level::Warn);
+///     logger.call_set_max_level(&mut store, my_logger, Level::Info)?;
+///
+///     logger.call_log(&mut store, my_logger, Level::Debug, "hello!")?;
+///
+///     // The `ResourceAny` type has no destructor but when the host is done
+///     // with it it needs to invoke the guest-level destructor.
+///     my_logger.resource_drop(&mut store)?;
+///
+///     Ok(())
+/// }
+/// ```
+pub mod _6_exported_resources;
diff --git a/crates/wasmtime/src/runtime/component/component.rs b/crates/wasmtime/src/runtime/component/component.rs
new file mode 100644
index 000000000000..e85c277e1068
--- /dev/null
+++ b/crates/wasmtime/src/runtime/component/component.rs
@@ -0,0 +1,810 @@
+use crate::component::matching::InstanceType;
+use crate::component::types;
+use crate::component::InstanceExportLookup;
+use crate::prelude::*;
+use crate::runtime::vm::component::ComponentRuntimeInfo;
+use crate::runtime::vm::{
+    CompiledModuleId, VMArrayCallFunction, VMFuncRef, VMFunctionBody, VMWasmCallFunction,
+};
+use crate::{
+    code::CodeObject, code_memory::CodeMemory, type_registry::TypeCollection, Engine, Module,
+    ResourcesRequired,
+};
+use crate::{FuncType, ValType};
+use alloc::sync::Arc;
+use core::any::Any;
+use core::mem;
+use core::ops::Range;
+use core::ptr::NonNull;
+#[cfg(feature = "std")]
+use std::path::Path;
+use wasmtime_environ::component::{
+    AllCallFunc, CompiledComponentInfo, ComponentArtifacts, ComponentTypes, Export, ExportIndex,
+    GlobalInitializer, InstantiateModule, NameMapNoIntern, StaticModuleIndex, TrampolineIndex,
+    TypeComponentIndex, TypeDef, VMComponentOffsets,
+};
+use wasmtime_environ::{FunctionLoc, HostPtr, ObjectKind, PrimaryMap};
+
+/// A compiled WebAssembly Component.
+///
+/// This structure represents a compiled component that is ready to be
+/// instantiated. This owns a region of virtual memory which contains executable
+/// code compiled from a WebAssembly binary originally. This is the analog of
+/// [`Module`](crate::Module) in the component embedding API.
+///
+/// A [`Component`] can be turned into an
+/// [`Instance`](crate::component::Instance) through a
+/// [`Linker`](crate::component::Linker). [`Component`]s are safe to share
+/// across threads. The compilation model of a component is the same as that of
+/// [a module](crate::Module) which is to say:
+///
+/// * Compilation happens synchronously during [`Component::new`].
+/// * The result of compilation can be saved into storage with
+///   [`Component::serialize`].
+/// * A previously compiled artifact can be parsed with
+///   [`Component::deserialize`].
+/// * No compilation happens at runtime for a component — everything is done
+///   by the time [`Component::new`] returns.
+///
+/// ## Components and `Clone`
+///
+/// Using `clone` on a `Component` is a cheap operation. It will not create an
+/// entirely new component, but rather just a new reference to the existing
+/// component. In other words it's a shallow copy, not a deep copy.
+///
+/// ## Examples
+///
+/// For example usage see the documentation of [`Module`](crate::Module) as
+/// [`Component`] has the same high-level API.
+#[derive(Clone)]
+pub struct Component {
+    inner: Arc<ComponentInner>,
+}
+
+struct ComponentInner {
+    /// Unique id for this component within this process.
+    ///
+    /// Note that this is repurposing ids for modules intentionally as there
+    /// shouldn't be an issue overlapping them.
+    id: CompiledModuleId,
+
+    /// The engine that this component belongs to.
+    engine: Engine,
+
+    /// Component type index
+    ty: TypeComponentIndex,
+
+    /// Core wasm modules that the component defined internally, indexed by the
+    /// compile-time-assigned `ModuleUpvarIndex`.
+    static_modules: PrimaryMap<StaticModuleIndex, Module>,
+
+    /// Code-related information such as the compiled artifact, type
+    /// information, etc.
+    ///
+    /// Note that the `Arc` here is used to share this allocation with internal
+    /// modules.
+    code: Arc<CodeObject>,
+
+    /// Metadata produced during compilation.
+    info: CompiledComponentInfo,
+
+    /// A cached handle to the `wasmtime::FuncType` for the canonical ABI's
+    /// `realloc`, to avoid the need to look up types in the registry and take
+    /// locks when calling `realloc` via `TypedFunc::call_raw`.
+    realloc_func_type: Arc<dyn Any + Send + Sync>,
+}
+
+pub(crate) struct AllCallFuncPointers {
+    pub wasm_call: NonNull<VMWasmCallFunction>,
+    pub array_call: VMArrayCallFunction,
+}
+
+impl Component {
+    /// Compiles a new WebAssembly component from the in-memory list of bytes
+    /// provided.
+    ///
+    /// The `bytes` provided can either be the binary or text format of a
+    /// [WebAssembly component]. Note that the text format requires the `wat`
+    /// feature of this crate to be enabled. This API does not support
+    /// streaming compilation.
+    ///
+    /// This function will synchronously validate the entire component,
+    /// including all core modules, and then compile all components, modules,
+    /// etc., found within the provided bytes.
+    ///
+    /// [WebAssembly component]: https://github.com/WebAssembly/component-model/blob/main/design/mvp/Binary.md
+    ///
+    /// # Errors
+    ///
+    /// This function may fail and return an error. Errors may include
+    /// situations such as:
+    ///
+    /// * The binary provided could not be decoded because it's not a valid
+    ///   WebAssembly binary
+    /// * The WebAssembly binary may not validate (e.g. contains type errors)
+    /// * Implementation-specific limits were exceeded with a valid binary (for
+    ///   example too many locals)
+    /// * The wasm binary may use features that are not enabled in the
+    ///   configuration of `engine`
+    /// * If the `wat` feature is enabled and the input is text, then it may be
+    ///   rejected if it fails to parse.
+    ///
+    /// The error returned should contain full information about why compilation
+    /// failed.
+    ///
+    /// # Examples
+    ///
+    /// The `new` function can be invoked with a in-memory array of bytes:
+    ///
+    /// ```no_run
+    /// # use wasmtime::*;
+    /// # use wasmtime::component::Component;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let engine = Engine::default();
+    /// # let wasm_bytes: Vec<u8> = Vec::new();
+    /// let component = Component::new(&engine, &wasm_bytes)?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// Or you can also pass in a string to be parsed as the wasm text
+    /// format:
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # use wasmtime::component::Component;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let engine = Engine::default();
+    /// let component = Component::new(&engine, "(component (core module))")?;
+    /// # Ok(())
+    /// # }
+    #[cfg(any(feature = "cranelift", feature = "winch"))]
+    pub fn new(engine: &Engine, bytes: impl AsRef<[u8]>) -> Result<Component> {
+        crate::CodeBuilder::new(engine)
+            .wasm_binary_or_text(bytes.as_ref(), None)?
+            .compile_component()
+    }
+
+    /// Compiles a new WebAssembly component from a wasm file on disk pointed
+    /// to by `file`.
+    ///
+    /// This is a convenience function for reading the contents of `file` on
+    /// disk and then calling [`Component::new`].
+    #[cfg(all(feature = "std", any(feature = "cranelift", feature = "winch")))]
+    pub fn from_file(engine: &Engine, file: impl AsRef<Path>) -> Result<Component> {
+        crate::CodeBuilder::new(engine)
+            .wasm_binary_or_text_file(file.as_ref())?
+            .compile_component()
+    }
+
+    /// Compiles a new WebAssembly component from the in-memory wasm image
+    /// provided.
+    ///
+    /// This function is the same as [`Component::new`] except that it does not
+    /// accept the text format of WebAssembly. Even if the `wat` feature
+    /// is enabled an error will be returned here if `binary` is the text
+    /// format.
+    ///
+    /// For more information on semantics and errors see [`Component::new`].
+    #[cfg(any(feature = "cranelift", feature = "winch"))]
+    pub fn from_binary(engine: &Engine, binary: &[u8]) -> Result<Component> {
+        crate::CodeBuilder::new(engine)
+            .wasm_binary(binary, None)?
+            .compile_component()
+    }
+
+    /// Same as [`Module::deserialize`], but for components.
+    ///
+    /// Note that the bytes referenced here must contain contents previously
+    /// produced by [`Engine::precompile_component`] or
+    /// [`Component::serialize`].
+    ///
+    /// For more information see the [`Module::deserialize`] method.
+    ///
+    /// # Unsafety
+    ///
+    /// The unsafety of this method is the same as that of the
+    /// [`Module::deserialize`] method.
+    ///
+    /// [`Module::deserialize`]: crate::Module::deserialize
+    pub unsafe fn deserialize(engine: &Engine, bytes: impl AsRef<[u8]>) -> Result<Component> {
+        let code = engine.load_code_bytes(bytes.as_ref(), ObjectKind::Component)?;
+        Component::from_parts(engine, code, None)
+    }
+
+    /// Same as [`Module::deserialize_file`], but for components.
+    ///
+    /// Note that the file referenced here must contain contents previously
+    /// produced by [`Engine::precompile_component`] or
+    /// [`Component::serialize`].
+    ///
+    /// For more information see the [`Module::deserialize_file`] method.
+    ///
+    /// # Unsafety
+    ///
+    /// The unsafety of this method is the same as that of the
+    /// [`Module::deserialize_file`] method.
+    ///
+    /// [`Module::deserialize_file`]: crate::Module::deserialize_file
+    #[cfg(feature = "std")]
+    pub unsafe fn deserialize_file(engine: &Engine, path: impl AsRef<Path>) -> Result<Component> {
+        let code = engine.load_code_file(path.as_ref(), ObjectKind::Component)?;
+        Component::from_parts(engine, code, None)
+    }
+
+    /// Returns the type of this component as a [`types::Component`].
+    ///
+    /// This method enables runtime introspection of the type of a component
+    /// before instantiation, if necessary.
+    ///
+    /// ## Component types and Resources
+    ///
+    /// An important point to note here is that the precise type of imports and
+    /// exports of a component change when it is instantiated with respect to
+    /// resources. For example a [`Component`] represents an un-instantiated
+    /// component meaning that its imported resources are represented as abstract
+    /// resource types. These abstract types are not equal to any other
+    /// component's types.
+    ///
+    /// For example:
+    ///
+    /// ```
+    /// # use wasmtime::Engine;
+    /// # use wasmtime::component::Component;
+    /// # use wasmtime::component::types::ComponentItem;
+    /// # fn main() -> wasmtime::Result<()> {
+    /// # let engine = Engine::default();
+    /// let a = Component::new(&engine, r#"
+    ///     (component (import "x" (type (sub resource))))
+    /// "#)?;
+    /// let b = Component::new(&engine, r#"
+    ///     (component (import "x" (type (sub resource))))
+    /// "#)?;
+    ///
+    /// let (_, a_ty) = a.component_type().imports(&engine).next().unwrap();
+    /// let (_, b_ty) = b.component_type().imports(&engine).next().unwrap();
+    ///
+    /// let a_ty = match a_ty {
+    ///     ComponentItem::Resource(ty) => ty,
+    ///     _ => unreachable!(),
+    /// };
+    /// let b_ty = match b_ty {
+    ///     ComponentItem::Resource(ty) => ty,
+    ///     _ => unreachable!(),
+    /// };
+    /// assert!(a_ty != b_ty);
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// Additionally, however, these abstract types are "substituted" during
+    /// instantiation meaning that a component type will appear to have changed
+    /// once it is instantiated.
+    ///
+    /// ```
+    /// # use wasmtime::{Engine, Store};
+    /// # use wasmtime::component::{Component, Linker, ResourceType};
+    /// # use wasmtime::component::types::ComponentItem;
+    /// # fn main() -> wasmtime::Result<()> {
+    /// # let engine = Engine::default();
+    /// // Here this component imports a resource and then exports it as-is
+    /// // which means that the export is equal to the import.
+    /// let a = Component::new(&engine, r#"
+    ///     (component
+    ///         (import "x" (type $x (sub resource)))
+    ///         (export "x" (type $x))
+    ///     )
+    /// "#)?;
+    ///
+    /// let (_, import) = a.component_type().imports(&engine).next().unwrap();
+    /// let (_, export) = a.component_type().exports(&engine).next().unwrap();
+    ///
+    /// let import = match import {
+    ///     ComponentItem::Resource(ty) => ty,
+    ///     _ => unreachable!(),
+    /// };
+    /// let export = match export {
+    ///     ComponentItem::Resource(ty) => ty,
+    ///     _ => unreachable!(),
+    /// };
+    /// assert_eq!(import, export);
+    ///
+    /// // However after instantiation the resource type "changes"
+    /// let mut store = Store::new(&engine, ());
+    /// let mut linker = Linker::new(&engine);
+    /// linker.root().resource("x", ResourceType::host::<()>(), |_, _| Ok(()))?;
+    /// let instance = linker.instantiate(&mut store, &a)?;
+    /// let instance_ty = instance.get_resource(&mut store, "x").unwrap();
+    ///
+    /// // Here `instance_ty` is not the same as either `import` or `export`,
+    /// // but it is equal to what we provided as an import.
+    /// assert!(instance_ty != import);
+    /// assert!(instance_ty != export);
+    /// assert!(instance_ty == ResourceType::host::<()>());
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// Finally, each instantiation of an exported resource from a component is
+    /// considered "fresh" for all instantiations meaning that different
+    /// instantiations will have different exported resource types:
+    ///
+    /// ```
+    /// # use wasmtime::{Engine, Store};
+    /// # use wasmtime::component::{Component, Linker};
+    /// # fn main() -> wasmtime::Result<()> {
+    /// # let engine = Engine::default();
+    /// let a = Component::new(&engine, r#"
+    ///     (component
+    ///         (type $x (resource (rep i32)))
+    ///         (export "x" (type $x))
+    ///     )
+    /// "#)?;
+    ///
+    /// let mut store = Store::new(&engine, ());
+    /// let linker = Linker::new(&engine);
+    /// let instance1 = linker.instantiate(&mut store, &a)?;
+    /// let instance2 = linker.instantiate(&mut store, &a)?;
+    ///
+    /// let x1 = instance1.get_resource(&mut store, "x").unwrap();
+    /// let x2 = instance2.get_resource(&mut store, "x").unwrap();
+    ///
+    /// // Despite these two resources being the same export of the same
+    /// // component they come from two different instances meaning that their
+    /// // types will be unique.
+    /// assert!(x1 != x2);
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn component_type(&self) -> types::Component {
+        self.with_uninstantiated_instance_type(|ty| types::Component::from(self.inner.ty, ty))
+    }
+
+    fn with_uninstantiated_instance_type<R>(&self, f: impl FnOnce(&InstanceType<'_>) -> R) -> R {
+        let resources = Arc::new(PrimaryMap::new());
+        f(&InstanceType {
+            types: self.types(),
+            resources: &resources,
+        })
+    }
+
+    /// Final assembly step for a component from its in-memory representation.
+    ///
+    /// If the `artifacts` are specified as `None` here then they will be
+    /// deserialized from `code_memory`.
+    pub(crate) fn from_parts(
+        engine: &Engine,
+        code_memory: Arc<CodeMemory>,
+        artifacts: Option<ComponentArtifacts>,
+    ) -> Result<Component> {
+        let ComponentArtifacts {
+            ty,
+            info,
+            types,
+            static_modules,
+        } = match artifacts {
+            Some(artifacts) => artifacts,
+            None => postcard::from_bytes(code_memory.wasmtime_info()).err2anyhow()?,
+        };
+
+        // Validate that the component can be used with the current instance
+        // allocator.
+        engine.allocator().validate_component(
+            &info.component,
+            &VMComponentOffsets::new(HostPtr, &info.component),
+            &|module_index| &static_modules[module_index].module,
+        )?;
+
+        // Create a signature registration with the `Engine` for all trampolines
+        // and core wasm types found within this component, both for the
+        // component and for all included core wasm modules.
+        let signatures = TypeCollection::new_for_module(engine, types.module_types());
+
+        // Assemble the `CodeObject` artifact which is shared by all core wasm
+        // modules as well as the final component.
+        let types = Arc::new(types);
+        let code = Arc::new(CodeObject::new(code_memory, signatures, types.into()));
+
+        // Convert all information about static core wasm modules into actual
+        // `Module` instances by converting each `CompiledModuleInfo`, the
+        // `types` type information, and the code memory to a runtime object.
+        let static_modules = static_modules
+            .into_iter()
+            .map(|(_, info)| Module::from_parts_raw(engine, code.clone(), info, false))
+            .collect::<Result<_>>()?;
+
+        let realloc_func_type = Arc::new(FuncType::new(
+            engine,
+            [ValType::I32, ValType::I32, ValType::I32, ValType::I32],
+            [ValType::I32],
+        )) as _;
+
+        Ok(Component {
+            inner: Arc::new(ComponentInner {
+                id: CompiledModuleId::new(),
+                engine: engine.clone(),
+                ty,
+                static_modules,
+                code,
+                info,
+                realloc_func_type,
+            }),
+        })
+    }
+
+    pub(crate) fn ty(&self) -> TypeComponentIndex {
+        self.inner.ty
+    }
+
+    pub(crate) fn env_component(&self) -> &wasmtime_environ::component::Component {
+        &self.inner.info.component
+    }
+
+    pub(crate) fn static_module(&self, idx: StaticModuleIndex) -> &Module {
+        &self.inner.static_modules[idx]
+    }
+
+    #[inline]
+    pub(crate) fn types(&self) -> &Arc<ComponentTypes> {
+        self.inner.component_types()
+    }
+
+    pub(crate) fn signatures(&self) -> &TypeCollection {
+        self.inner.code.signatures()
+    }
+
+    pub(crate) fn text(&self) -> &[u8] {
+        self.inner.code.code_memory().text()
+    }
+
+    pub(crate) fn trampoline_ptrs(&self, index: TrampolineIndex) -> AllCallFuncPointers {
+        let AllCallFunc {
+            wasm_call,
+            array_call,
+        } = &self.inner.info.trampolines[index];
+        AllCallFuncPointers {
+            wasm_call: self.func(wasm_call).cast(),
+            array_call: unsafe {
+                mem::transmute::<NonNull<VMFunctionBody>, VMArrayCallFunction>(
+                    self.func(array_call),
+                )
+            },
+        }
+    }
+
+    fn func(&self, loc: &FunctionLoc) -> NonNull<VMFunctionBody> {
+        let text = self.text();
+        let trampoline = &text[loc.start as usize..][..loc.length as usize];
+        NonNull::new(trampoline.as_ptr() as *mut VMFunctionBody).unwrap()
+    }
+
+    pub(crate) fn code_object(&self) -> &Arc<CodeObject> {
+        &self.inner.code
+    }
+
+    /// Same as [`Module::serialize`], except for a component.
+    ///
+    /// Note that the artifact produced here must be passed to
+    /// [`Component::deserialize`] and is not compatible for use with
+    /// [`Module`].
+    ///
+    /// [`Module::serialize`]: crate::Module::serialize
+    /// [`Module`]: crate::Module
+    pub fn serialize(&self) -> Result<Vec<u8>> {
+        Ok(self.code_object().code_memory().mmap().to_vec())
+    }
+
+    pub(crate) fn runtime_info(&self) -> Arc<dyn ComponentRuntimeInfo> {
+        self.inner.clone()
+    }
+
+    /// Creates a new `VMFuncRef` with all fields filled out for the destructor
+    /// specified.
+    ///
+    /// The `dtor`'s own `VMFuncRef` won't have `wasm_call` filled out but this
+    /// component may have `resource_drop_wasm_to_native_trampoline` filled out
+    /// if necessary in which case it's filled in here.
+    pub(crate) fn resource_drop_func_ref(&self, dtor: &crate::func::HostFunc) -> VMFuncRef {
+        // Host functions never have their `wasm_call` filled in at this time.
+        assert!(dtor.func_ref().wasm_call.is_none());
+
+        // Note that if `resource_drop_wasm_to_native_trampoline` is not present
+        // then this can't be called by the component, so it's ok to leave it
+        // blank.
+        let wasm_call = self
+            .inner
+            .info
+            .resource_drop_wasm_to_array_trampoline
+            .as_ref()
+            .map(|i| self.func(i).cast());
+        VMFuncRef {
+            wasm_call,
+            ..*dtor.func_ref()
+        }
+    }
+
+    /// Returns a summary of the resources required to instantiate this
+    /// [`Component`][crate::component::Component].
+    ///
+    /// Note that when a component imports and instantiates another component or
+    /// core module, we cannot determine ahead of time how many resources
+    /// instantiating this component will require, and therefore this method
+    /// will return `None` in these scenarios.
+    ///
+    /// Potential uses of the returned information:
+    ///
+    /// * Determining whether your pooling allocator configuration supports
+    ///   instantiating this component.
+    ///
+    /// * Deciding how many of which `Component` you want to instantiate within
+    ///   a fixed amount of resources, e.g. determining whether to create 5
+    ///   instances of component X or 10 instances of component Y.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # fn main() -> wasmtime::Result<()> {
+    /// use wasmtime::{Config, Engine, component::Component};
+    ///
+    /// let mut config = Config::new();
+    /// config.wasm_multi_memory(true);
+    /// config.wasm_component_model(true);
+    /// let engine = Engine::new(&config)?;
+    ///
+    /// let component = Component::new(&engine, &r#"
+    ///     (component
+    ///         ;; Define a core module that uses two memories.
+    ///         (core module $m
+    ///             (memory 1)
+    ///             (memory 6)
+    ///         )
+    ///
+    ///         ;; Instantiate that core module three times.
+    ///         (core instance $i1 (instantiate (module $m)))
+    ///         (core instance $i2 (instantiate (module $m)))
+    ///         (core instance $i3 (instantiate (module $m)))
+    ///     )
+    /// "#)?;
+    ///
+    /// let resources = component.resources_required()
+    ///     .expect("this component does not import any core modules or instances");
+    ///
+    /// // Instantiating the component will require allocating two memories per
+    /// // core instance, and there are three instances, so six total memories.
+    /// assert_eq!(resources.num_memories, 6);
+    /// assert_eq!(resources.max_initial_memory_size, Some(6));
+    ///
+    /// // The component doesn't need any tables.
+    /// assert_eq!(resources.num_tables, 0);
+    /// assert_eq!(resources.max_initial_table_size, None);
+    /// # Ok(()) }
+    /// ```
+    pub fn resources_required(&self) -> Option<ResourcesRequired> {
+        let mut resources = ResourcesRequired {
+            num_memories: 0,
+            max_initial_memory_size: None,
+            num_tables: 0,
+            max_initial_table_size: None,
+        };
+        for init in &self.env_component().initializers {
+            match init {
+                GlobalInitializer::InstantiateModule(inst) => match inst {
+                    InstantiateModule::Static(index, _) => {
+                        let module = self.static_module(*index);
+                        resources.add(&module.resources_required());
+                    }
+                    InstantiateModule::Import(_, _) => {
+                        // We can't statically determine the resources required
+                        // to instantiate this component.
+                        return None;
+                    }
+                },
+                GlobalInitializer::LowerImport { .. }
+                | GlobalInitializer::ExtractMemory(_)
+                | GlobalInitializer::ExtractRealloc(_)
+                | GlobalInitializer::ExtractPostReturn(_)
+                | GlobalInitializer::Resource(_) => {}
+            }
+        }
+        Some(resources)
+    }
+
+    /// Returns the range, in the host's address space, that this module's
+    /// compiled code resides at.
+    ///
+    /// For more information see
+    /// [`Module::image_range`](crate::Module::image_range).
+    pub fn image_range(&self) -> Range<*const u8> {
+        self.inner.code.code_memory().mmap().image_range()
+    }
+
+    /// Looks up a specific export of this component by `name` optionally nested
+    /// within the `instance` provided.
+    ///
+    /// This method is primarily used to acquire a [`ComponentExportIndex`]
+    /// which can be used with [`Instance`](crate::component::Instance) when
+    /// looking up exports. Export lookup with [`ComponentExportIndex`] can
+    /// skip string lookups at runtime and instead use a more efficient
+    /// index-based lookup.
+    ///
+    /// This method takes a few arguments:
+    ///
+    /// * `engine` - the engine that was used to compile this component.
+    /// * `instance` - an optional "parent instance" for the export being looked
+    ///   up. If this is `None` then the export is looked up on the root of the
+    ///   component itself, and otherwise the export is looked up on the
+    ///   `instance` specified. Note that `instance` must have come from a
+    ///   previous invocation of this method.
+    /// * `name` - the name of the export that's being looked up.
+    ///
+    /// If the export is located then two values are returned: a
+    /// [`types::ComponentItem`] which enables introspection about the type of
+    /// the export and a [`ComponentExportIndex`]. The index returned notably
+    /// implements the [`InstanceExportLookup`] trait which enables using it
+    /// with [`Instance::get_func`](crate::component::Instance::get_func) for
+    /// example.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use wasmtime::{Engine, Store};
+    /// use wasmtime::component::{Component, Linker};
+    /// use wasmtime::component::types::ComponentItem;
+    ///
+    /// # fn main() -> wasmtime::Result<()> {
+    /// let engine = Engine::default();
+    /// let component = Component::new(
+    ///     &engine,
+    ///     r#"
+    ///         (component
+    ///             (core module $m
+    ///                 (func (export "f"))
+    ///             )
+    ///             (core instance $i (instantiate $m))
+    ///             (func (export "f")
+    ///                 (canon lift (core func $i "f")))
+    ///         )
+    ///     "#,
+    /// )?;
+    ///
+    /// // Perform a lookup of the function "f" before instantiaton.
+    /// let (ty, export) = component.export_index(None, "f").unwrap();
+    /// assert!(matches!(ty, ComponentItem::ComponentFunc(_)));
+    ///
+    /// // After instantiation use `export` to lookup the function in question
+    /// // which notably does not do a string lookup at runtime.
+    /// let mut store = Store::new(&engine, ());
+    /// let instance = Linker::new(&engine).instantiate(&mut store, &component)?;
+    /// let func = instance.get_typed_func::<(), ()>(&mut store, &export)?;
+    /// // ...
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn export_index(
+        &self,
+        instance: Option<&ComponentExportIndex>,
+        name: &str,
+    ) -> Option<(types::ComponentItem, ComponentExportIndex)> {
+        let info = self.env_component();
+        let index = self.lookup_export_index(instance, name)?;
+        let ty = match info.export_items[index] {
+            Export::Instance { ty, .. } => TypeDef::ComponentInstance(ty),
+            Export::LiftedFunction { ty, .. } => TypeDef::ComponentFunc(ty),
+            Export::ModuleStatic { ty, .. } | Export::ModuleImport { ty, .. } => {
+                TypeDef::Module(ty)
+            }
+            Export::Type(ty) => ty,
+        };
+        let item = self.with_uninstantiated_instance_type(|instance| {
+            types::ComponentItem::from(&self.inner.engine, &ty, instance)
+        });
+        Some((
+            item,
+            ComponentExportIndex {
+                id: self.inner.id,
+                index,
+            },
+        ))
+    }
+
+    pub(crate) fn lookup_export_index(
+        &self,
+        instance: Option<&ComponentExportIndex>,
+        name: &str,
+    ) -> Option<ExportIndex> {
+        let info = self.env_component();
+        let exports = match instance {
+            Some(idx) => {
+                if idx.id != self.inner.id {
+                    return None;
+                }
+                match &info.export_items[idx.index] {
+                    Export::Instance { exports, .. } => exports,
+                    _ => return None,
+                }
+            }
+            None => &info.exports,
+        };
+        exports.get(name, &NameMapNoIntern).copied()
+    }
+
+    pub(crate) fn id(&self) -> CompiledModuleId {
+        self.inner.id
+    }
+
+    /// Returns the [`Engine`] that this [`Component`] was compiled by.
+    pub fn engine(&self) -> &Engine {
+        &self.inner.engine
+    }
+}
+
+/// A value which represents a known export of a component.
+///
+/// This is the return value of [`Component::export_index`] and implements the
+/// [`InstanceExportLookup`] trait to work with lookups like
+/// [`Instance::get_func`](crate::component::Instance::get_func).
+#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
+pub struct ComponentExportIndex {
+    pub(crate) id: CompiledModuleId,
+    pub(crate) index: ExportIndex,
+}
+
+impl InstanceExportLookup for ComponentExportIndex {
+    fn lookup(&self, component: &Component) -> Option<ExportIndex> {
+        if component.inner.id == self.id {
+            Some(self.index)
+        } else {
+            None
+        }
+    }
+}
+
+impl ComponentRuntimeInfo for ComponentInner {
+    fn component(&self) -> &wasmtime_environ::component::Component {
+        &self.info.component
+    }
+
+    fn component_types(&self) -> &Arc<ComponentTypes> {
+        match self.code.types() {
+            crate::code::Types::Component(types) => types,
+            // The only creator of a `Component` is itself which uses the other
+            // variant, so this shouldn't be possible.
+            crate::code::Types::Module(_) => unreachable!(),
+        }
+    }
+
+    fn realloc_func_type(&self) -> &Arc<dyn Any + Send + Sync> {
+        &self.realloc_func_type
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::component::Component;
+    use crate::{Config, Engine};
+    use wasmtime_environ::MemoryInitialization;
+
+    #[test]
+    fn cow_on_by_default() {
+        let mut config = Config::new();
+        config.wasm_component_model(true);
+        let engine = Engine::new(&config).unwrap();
+        let component = Component::new(
+            &engine,
+            r#"
+                (component
+                    (core module
+                        (memory 1)
+                        (data (i32.const 100) "abcd")
+                    )
+                )
+            "#,
+        )
+        .unwrap();
+
+        for (_, module) in component.inner.static_modules.iter() {
+            let init = &module.env_module().memory_initialization;
+            assert!(matches!(init, MemoryInitialization::Static { .. }));
+        }
+    }
+}
diff --git a/crates/wasmtime/src/runtime/component/func.rs b/crates/wasmtime/src/runtime/component/func.rs
new file mode 100644
index 000000000000..c7fda91181ea
--- /dev/null
+++ b/crates/wasmtime/src/runtime/component/func.rs
@@ -0,0 +1,688 @@
+use crate::component::instance::{Instance, InstanceData};
+use crate::component::storage::storage_as_slice;
+use crate::component::types::Type;
+use crate::component::values::Val;
+use crate::prelude::*;
+use crate::runtime::vm::component::ResourceTables;
+use crate::runtime::vm::{Export, ExportFunction};
+use crate::store::{StoreOpaque, Stored};
+use crate::{AsContext, AsContextMut, StoreContextMut, ValRaw};
+use alloc::sync::Arc;
+use core::mem::{self, MaybeUninit};
+use core::ptr::NonNull;
+use wasmtime_environ::component::{
+    CanonicalOptions, ComponentTypes, CoreDef, InterfaceType, RuntimeComponentInstanceIndex,
+    TypeFuncIndex, TypeTuple, MAX_FLAT_PARAMS, MAX_FLAT_RESULTS,
+};
+
+mod host;
+mod options;
+mod typed;
+pub use self::host::*;
+pub use self::options::*;
+pub use self::typed::*;
+
+#[repr(C)]
+union ParamsAndResults<Params: Copy, Return: Copy> {
+    params: Params,
+    ret: Return,
+}
+
+/// A WebAssembly component function which can be called.
+///
+/// This type is the dual of [`wasmtime::Func`](crate::Func) for component
+/// functions. An instance of [`Func`] represents a component function from a
+/// component [`Instance`](crate::component::Instance). Like with
+/// [`wasmtime::Func`](crate::Func) it's possible to call functions either
+/// synchronously or asynchronously and either typed or untyped.
+#[derive(Copy, Clone, Debug)]
+pub struct Func(Stored<FuncData>);
+
+#[doc(hidden)]
+pub struct FuncData {
+    export: ExportFunction,
+    ty: TypeFuncIndex,
+    types: Arc<ComponentTypes>,
+    options: Options,
+    instance: Instance,
+    component_instance: RuntimeComponentInstanceIndex,
+    post_return: Option<ExportFunction>,
+    post_return_arg: Option<ValRaw>,
+}
+
+impl Func {
+    pub(crate) fn from_lifted_func(
+        store: &mut StoreOpaque,
+        instance: &Instance,
+        data: &InstanceData,
+        ty: TypeFuncIndex,
+        func: &CoreDef,
+        options: &CanonicalOptions,
+    ) -> Func {
+        let export = match data.lookup_def(store, func) {
+            Export::Function(f) => f,
+            _ => unreachable!(),
+        };
+        let memory = options
+            .memory
+            .map(|i| NonNull::new(data.instance().runtime_memory(i)).unwrap());
+        let realloc = options.realloc.map(|i| data.instance().runtime_realloc(i));
+        let post_return = options.post_return.map(|i| {
+            let func_ref = data.instance().runtime_post_return(i);
+            ExportFunction { func_ref }
+        });
+        let component_instance = options.instance;
+        let options = unsafe { Options::new(store.id(), memory, realloc, options.string_encoding) };
+        Func(store.store_data_mut().insert(FuncData {
+            export,
+            options,
+            ty,
+            types: data.component_types().clone(),
+            instance: *instance,
+            component_instance,
+            post_return,
+            post_return_arg: None,
+        }))
+    }
+
+    /// Attempt to cast this [`Func`] to a statically typed [`TypedFunc`] with
+    /// the provided `Params` and `Return`.
+    ///
+    /// This function will perform a type-check at runtime that the [`Func`]
+    /// takes `Params` as parameters and returns `Return`. If the type-check
+    /// passes then a [`TypedFunc`] will be returned which can be used to
+    /// invoke the function in an efficient, statically-typed, and ergonomic
+    /// manner.
+    ///
+    /// The `Params` type parameter here is a tuple of the parameters to the
+    /// function. A function which takes no arguments should use `()`, a
+    /// function with one argument should use `(T,)`, etc. Note that all
+    /// `Params` must also implement the [`Lower`] trait since they're going
+    /// into wasm.
+    ///
+    /// The `Return` type parameter is the return value of this function. A
+    /// return value of `()` means that there's no return (similar to a Rust
+    /// unit return) and otherwise a type `T` can be specified. Note that the
+    /// `Return` must also implement the [`Lift`] trait since it's coming from
+    /// wasm.
+    ///
+    /// Types specified here must implement the [`ComponentType`] trait. This
+    /// trait is implemented for built-in types to Rust such as integer
+    /// primitives, floats, `Option<T>`, `Result<T, E>`, strings, `Vec<T>`, and
+    /// more. As parameters you'll be passing native Rust types.
+    ///
+    /// See the documentation for [`ComponentType`] for more information about
+    /// supported types.
+    ///
+    /// # Errors
+    ///
+    /// If the function does not actually take `Params` as its parameters or
+    /// return `Return` then an error will be returned.
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if `self` is not owned by the `store`
+    /// specified.
+    ///
+    /// # Examples
+    ///
+    /// Calling a function which takes no parameters and has no return value:
+    ///
+    /// ```
+    /// # use wasmtime::component::Func;
+    /// # use wasmtime::Store;
+    /// # fn foo(func: &Func, store: &mut Store<()>) -> anyhow::Result<()> {
+    /// let typed = func.typed::<(), ()>(&store)?;
+    /// typed.call(store, ())?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// Calling a function which takes one string parameter and returns a
+    /// string:
+    ///
+    /// ```
+    /// # use wasmtime::component::Func;
+    /// # use wasmtime::Store;
+    /// # fn foo(func: &Func, mut store: Store<()>) -> anyhow::Result<()> {
+    /// let typed = func.typed::<(&str,), (String,)>(&store)?;
+    /// let ret = typed.call(&mut store, ("Hello, ",))?.0;
+    /// println!("returned string was: {}", ret);
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// Calling a function which takes multiple parameters and returns a boolean:
+    ///
+    /// ```
+    /// # use wasmtime::component::Func;
+    /// # use wasmtime::Store;
+    /// # fn foo(func: &Func, mut store: Store<()>) -> anyhow::Result<()> {
+    /// let typed = func.typed::<(u32, Option<&str>, &[u8]), (bool,)>(&store)?;
+    /// let ok: bool = typed.call(&mut store, (1, Some("hello"), b"bytes!"))?.0;
+    /// println!("return value was: {ok}");
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn typed<Params, Return>(&self, store: impl AsContext) -> Result<TypedFunc<Params, Return>>
+    where
+        Params: ComponentNamedList + Lower,
+        Return: ComponentNamedList + Lift,
+    {
+        self._typed(store.as_context().0, None)
+    }
+
+    pub(crate) fn _typed<Params, Return>(
+        &self,
+        store: &StoreOpaque,
+        instance: Option<&InstanceData>,
+    ) -> Result<TypedFunc<Params, Return>>
+    where
+        Params: ComponentNamedList + Lower,
+        Return: ComponentNamedList + Lift,
+    {
+        self.typecheck::<Params, Return>(store, instance)?;
+        unsafe { Ok(TypedFunc::new_unchecked(*self)) }
+    }
+
+    fn typecheck<Params, Return>(
+        &self,
+        store: &StoreOpaque,
+        instance: Option<&InstanceData>,
+    ) -> Result<()>
+    where
+        Params: ComponentNamedList + Lower,
+        Return: ComponentNamedList + Lift,
+    {
+        let data = &store[self.0];
+        let cx = instance
+            .unwrap_or_else(|| &store[data.instance.0].as_ref().unwrap())
+            .ty();
+        let ty = &cx.types[data.ty];
+
+        Params::typecheck(&InterfaceType::Tuple(ty.params), &cx)
+            .context("type mismatch with parameters")?;
+        Return::typecheck(&InterfaceType::Tuple(ty.results), &cx)
+            .context("type mismatch with results")?;
+
+        Ok(())
+    }
+
+    /// Get the parameter types for this function.
+    pub fn params(&self, store: impl AsContext) -> Box<[Type]> {
+        let store = store.as_context();
+        let data = &store[self.0];
+        let instance = store[data.instance.0].as_ref().unwrap();
+        data.types[data.types[data.ty].params]
+            .types
+            .iter()
+            .map(|ty| Type::from(ty, &instance.ty()))
+            .collect()
+    }
+
+    /// Get the result types for this function.
+    pub fn results(&self, store: impl AsContext) -> Box<[Type]> {
+        let store = store.as_context();
+        let data = &store[self.0];
+        let instance = store[data.instance.0].as_ref().unwrap();
+        data.types[data.types[data.ty].results]
+            .types
+            .iter()
+            .map(|ty| Type::from(ty, &instance.ty()))
+            .collect()
+    }
+
+    /// Invokes this function with the `params` given and returns the result.
+    ///
+    /// The `params` provided must match the parameters that this function takes
+    /// in terms of their types and the number of parameters. Results will be
+    /// written to the `results` slice provided if the call completes
+    /// successfully. The initial types of the values in `results` are ignored
+    /// and values are overwritten to write the result. It's required that the
+    /// size of `results` exactly matches the number of results that this
+    /// function produces.
+    ///
+    /// Note that after a function is invoked the embedder needs to invoke
+    /// [`Func::post_return`] to execute any final cleanup required by the
+    /// guest. This function call is required to either call the function again
+    /// or to call another function.
+    ///
+    /// For more detailed information see the documentation of
+    /// [`TypedFunc::call`].
+    ///
+    /// # Errors
+    ///
+    /// Returns an error in situations including but not limited to:
+    ///
+    /// * `params` is not the right size or if the values have the wrong type
+    /// * `results` is not the right size
+    /// * A trap occurs while executing the function
+    /// * The function calls a host function which returns an error
+    ///
+    /// See [`TypedFunc::call`] for more information in addition to
+    /// [`wasmtime::Func::call`](crate::Func::call).
+    ///
+    /// # Panics
+    ///
+    /// Panics if this is called on a function in an asynchronous store. This
+    /// only works with functions defined within a synchronous store. Also
+    /// panics if `store` does not own this function.
+    pub fn call(
+        &self,
+        mut store: impl AsContextMut,
+        params: &[Val],
+        results: &mut [Val],
+    ) -> Result<()> {
+        let mut store = store.as_context_mut();
+        assert!(
+            !store.0.async_support(),
+            "must use `call_async` when async support is enabled on the config"
+        );
+        self.call_impl(&mut store.as_context_mut(), params, results)
+    }
+
+    /// Exactly like [`Self::call`] except for use on async stores.
+    ///
+    /// Note that after this [`Func::post_return_async`] will be used instead of
+    /// the synchronous version at [`Func::post_return`].
+    ///
+    /// # Panics
+    ///
+    /// Panics if this is called on a function in a synchronous store. This
+    /// only works with functions defined within an asynchronous store. Also
+    /// panics if `store` does not own this function.
+    #[cfg(feature = "async")]
+    pub async fn call_async<T>(
+        &self,
+        mut store: impl AsContextMut<Data = T>,
+        params: &[Val],
+        results: &mut [Val],
+    ) -> Result<()>
+    where
+        T: Send,
+    {
+        let mut store = store.as_context_mut();
+        assert!(
+            store.0.async_support(),
+            "cannot use `call_async` without enabling async support in the config"
+        );
+        store
+            .on_fiber(|store| self.call_impl(store, params, results))
+            .await?
+    }
+
+    fn call_impl(
+        &self,
+        mut store: impl AsContextMut,
+        params: &[Val],
+        results: &mut [Val],
+    ) -> Result<()> {
+        let store = &mut store.as_context_mut();
+
+        let param_tys = self.params(&store);
+        let result_tys = self.results(&store);
+
+        if param_tys.len() != params.len() {
+            bail!(
+                "expected {} argument(s), got {}",
+                param_tys.len(),
+                params.len()
+            );
+        }
+        if result_tys.len() != results.len() {
+            bail!(
+                "expected {} results(s), got {}",
+                result_tys.len(),
+                results.len()
+            );
+        }
+
+        self.call_raw(
+            store,
+            params,
+            |cx, params, params_ty, dst: &mut MaybeUninit<[ValRaw; MAX_FLAT_PARAMS]>| {
+                let params_ty = match params_ty {
+                    InterfaceType::Tuple(i) => &cx.types[i],
+                    _ => unreachable!(),
+                };
+                if params_ty.abi.flat_count(MAX_FLAT_PARAMS).is_some() {
+                    let dst = &mut unsafe {
+                        mem::transmute::<_, &mut [MaybeUninit<ValRaw>; MAX_FLAT_PARAMS]>(dst)
+                    }
+                    .iter_mut();
+
+                    params
+                        .iter()
+                        .zip(params_ty.types.iter())
+                        .try_for_each(|(param, ty)| param.lower(cx, *ty, dst))
+                } else {
+                    self.store_args(cx, &params_ty, params, dst)
+                }
+            },
+            |cx, results_ty, src: &[ValRaw; MAX_FLAT_RESULTS]| {
+                let results_ty = match results_ty {
+                    InterfaceType::Tuple(i) => &cx.types[i],
+                    _ => unreachable!(),
+                };
+                if results_ty.abi.flat_count(MAX_FLAT_RESULTS).is_some() {
+                    let mut flat = src.iter();
+                    for (ty, slot) in results_ty.types.iter().zip(results) {
+                        *slot = Val::lift(cx, *ty, &mut flat)?;
+                    }
+                    Ok(())
+                } else {
+                    Self::load_results(cx, results_ty, results, &mut src.iter())
+                }
+            },
+        )
+    }
+
+    /// Invokes the underlying wasm function, lowering arguments and lifting the
+    /// result.
+    ///
+    /// The `lower` function and `lift` function provided here are what actually
+    /// do the lowering and lifting. The `LowerParams` and `LowerReturn` types
+    /// are what will be allocated on the stack for this function call. They
+    /// should be appropriately sized for the lowering/lifting operation
+    /// happening.
+    fn call_raw<T, Params: ?Sized, Return, LowerParams, LowerReturn>(
+        &self,
+        store: &mut StoreContextMut<'_, T>,
+        params: &Params,
+        lower: impl FnOnce(
+            &mut LowerContext<'_, T>,
+            &Params,
+            InterfaceType,
+            &mut MaybeUninit<LowerParams>,
+        ) -> Result<()>,
+        lift: impl FnOnce(&mut LiftContext<'_>, InterfaceType, &LowerReturn) -> Result<Return>,
+    ) -> Result<Return>
+    where
+        LowerParams: Copy,
+        LowerReturn: Copy,
+    {
+        let FuncData {
+            export,
+            options,
+            instance,
+            component_instance,
+            ty,
+            ..
+        } = store.0[self.0];
+
+        let space = &mut MaybeUninit::<ParamsAndResults<LowerParams, LowerReturn>>::uninit();
+
+        // Double-check the size/alignment of `space`, just in case.
+        //
+        // Note that this alone is not enough to guarantee the validity of the
+        // `unsafe` block below, but it's definitely required. In any case LLVM
+        // should be able to trivially see through these assertions and remove
+        // them in release mode.
+        let val_size = mem::size_of::<ValRaw>();
+        let val_align = mem::align_of::<ValRaw>();
+        assert!(mem::size_of_val(space) % val_size == 0);
+        assert!(mem::size_of_val(map_maybe_uninit!(space.params)) % val_size == 0);
+        assert!(mem::size_of_val(map_maybe_uninit!(space.ret)) % val_size == 0);
+        assert!(mem::align_of_val(space) == val_align);
+        assert!(mem::align_of_val(map_maybe_uninit!(space.params)) == val_align);
+        assert!(mem::align_of_val(map_maybe_uninit!(space.ret)) == val_align);
+
+        let instance = store.0[instance.0].as_ref().unwrap();
+        let types = instance.component_types().clone();
+        let mut flags = instance.instance().instance_flags(component_instance);
+
+        unsafe {
+            // Test the "may enter" flag which is a "lock" on this instance.
+            // This is immediately set to `false` afterwards and note that
+            // there's no on-cleanup setting this flag back to true. That's an
+            // intentional design aspect where if anything goes wrong internally
+            // from this point on the instance is considered "poisoned" and can
+            // never be entered again. The only time this flag is set to `true`
+            // again is after post-return logic has completed successfully.
+            if !flags.may_enter() {
+                bail!(crate::Trap::CannotEnterComponent);
+            }
+            flags.set_may_enter(false);
+
+            debug_assert!(flags.may_leave());
+            flags.set_may_leave(false);
+            let instance_ptr = instance.instance_ptr();
+            let mut cx = LowerContext::new(store.as_context_mut(), &options, &types, instance_ptr);
+            cx.enter_call();
+            let result = lower(
+                &mut cx,
+                params,
+                InterfaceType::Tuple(types[ty].params),
+                map_maybe_uninit!(space.params),
+            );
+            flags.set_may_leave(true);
+            result?;
+
+            // This is unsafe as we are providing the guarantee that all the
+            // inputs are valid. The various pointers passed in for the function
+            // are all valid since they're coming from our store, and the
+            // `params_and_results` should have the correct layout for the core
+            // wasm function we're calling. Note that this latter point relies
+            // on the correctness of this module and `ComponentType`
+            // implementations, hence `ComponentType` being an `unsafe` trait.
+            crate::Func::call_unchecked_raw(
+                store,
+                export.func_ref,
+                space.as_mut_ptr().cast(),
+                mem::size_of_val(space) / mem::size_of::<ValRaw>(),
+            )?;
+
+            // Note that `.assume_init_ref()` here is unsafe but we're relying
+            // on the correctness of the structure of `LowerReturn` and the
+            // type-checking performed to acquire the `TypedFunc` to make this
+            // safe. It should be the case that `LowerReturn` is the exact
+            // representation of the return value when interpreted as
+            // `[ValRaw]`, and additionally they should have the correct types
+            // for the function we just called (which filled in the return
+            // values).
+            let ret = map_maybe_uninit!(space.ret).assume_init_ref();
+
+            // Lift the result into the host while managing post-return state
+            // here as well.
+            //
+            // After a successful lift the return value of the function, which
+            // is currently required to be 0 or 1 values according to the
+            // canonical ABI, is saved within the `Store`'s `FuncData`. This'll
+            // later get used in post-return.
+            flags.set_needs_post_return(true);
+            let val = lift(
+                &mut LiftContext::new(store.0, &options, &types, instance_ptr),
+                InterfaceType::Tuple(types[ty].results),
+                ret,
+            )?;
+            let ret_slice = storage_as_slice(ret);
+            let data = &mut store.0[self.0];
+            assert!(data.post_return_arg.is_none());
+            match ret_slice.len() {
+                0 => data.post_return_arg = Some(ValRaw::i32(0)),
+                1 => data.post_return_arg = Some(ret_slice[0]),
+                _ => unreachable!(),
+            }
+            return Ok(val);
+        }
+    }
+
+    /// Invokes the `post-return` canonical ABI option, if specified, after a
+    /// [`Func::call`] has finished.
+    ///
+    /// This function is a required method call after a [`Func::call`] completes
+    /// successfully. After the embedder has finished processing the return
+    /// value then this function must be invoked.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error in the case of a WebAssembly trap
+    /// happening during the execution of the `post-return` function, if
+    /// specified.
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if it's not called under the correct
+    /// conditions. This can only be called after a previous invocation of
+    /// [`Func::call`] completes successfully, and this function can only
+    /// be called for the same [`Func`] that was `call`'d.
+    ///
+    /// If this function is called when [`Func::call`] was not previously
+    /// called, then it will panic. If a different [`Func`] for the same
+    /// component instance was invoked then this function will also panic
+    /// because the `post-return` needs to happen for the other function.
+    ///
+    /// Panics if this is called on a function in an asynchronous store.
+    /// This only works with functions defined within a synchronous store.
+    #[inline]
+    pub fn post_return(&self, mut store: impl AsContextMut) -> Result<()> {
+        let store = store.as_context_mut();
+        assert!(
+            !store.0.async_support(),
+            "must use `post_return_async` when async support is enabled on the config"
+        );
+        self.post_return_impl(store)
+    }
+
+    /// Exactly like [`Self::post_return`] except for use on async stores.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this is called on a function in a synchronous store. This
+    /// only works with functions defined within an asynchronous store.
+    #[cfg(feature = "async")]
+    pub async fn post_return_async<T: Send>(
+        &self,
+        mut store: impl AsContextMut<Data = T>,
+    ) -> Result<()> {
+        let mut store = store.as_context_mut();
+        assert!(
+            store.0.async_support(),
+            "cannot use `call_async` without enabling async support in the config"
+        );
+        // Future optimization opportunity: conditionally use a fiber here since
+        // some func's post_return will not need the async context (i.e. end up
+        // calling async host functionality)
+        store.on_fiber(|store| self.post_return_impl(store)).await?
+    }
+
+    fn post_return_impl(&self, mut store: impl AsContextMut) -> Result<()> {
+        let mut store = store.as_context_mut();
+        let data = &mut store.0[self.0];
+        let instance = data.instance;
+        let post_return = data.post_return;
+        let component_instance = data.component_instance;
+        let post_return_arg = data.post_return_arg.take();
+        let instance = store.0[instance.0].as_ref().unwrap().instance_ptr();
+
+        unsafe {
+            let mut flags = (*instance).instance_flags(component_instance);
+
+            // First assert that the instance is in a "needs post return" state.
+            // This will ensure that the previous action on the instance was a
+            // function call above. This flag is only set after a component
+            // function returns so this also can't be called (as expected)
+            // during a host import for example.
+            //
+            // Note, though, that this assert is not sufficient because it just
+            // means some function on this instance needs its post-return
+            // called. We need a precise post-return for a particular function
+            // which is the second assert here (the `.expect`). That will assert
+            // that this function itself needs to have its post-return called.
+            //
+            // The theory at least is that these two asserts ensure component
+            // model semantics are upheld where the host properly calls
+            // `post_return` on the right function despite the call being a
+            // separate step in the API.
+            assert!(
+                flags.needs_post_return(),
+                "post_return can only be called after a function has previously been called",
+            );
+            let post_return_arg = post_return_arg.expect("calling post_return on wrong function");
+
+            // This is a sanity-check assert which shouldn't ever trip.
+            assert!(!flags.may_enter());
+
+            // Unset the "needs post return" flag now that post-return is being
+            // processed. This will cause future invocations of this method to
+            // panic, even if the function call below traps.
+            flags.set_needs_post_return(false);
+
+            // If the function actually had a `post-return` configured in its
+            // canonical options that's executed here.
+            //
+            // Note that if this traps (returns an error) this function
+            // intentionally leaves the instance in a "poisoned" state where it
+            // can no longer be entered because `may_enter` is `false`.
+            if let Some(func) = post_return {
+                crate::Func::call_unchecked_raw(
+                    &mut store,
+                    func.func_ref,
+                    &post_return_arg as *const ValRaw as *mut ValRaw,
+                    1,
+                )?;
+            }
+
+            // And finally if everything completed successfully then the "may
+            // enter" flag is set to `true` again here which enables further use
+            // of the component.
+            flags.set_may_enter(true);
+
+            let (calls, host_table, _) = store.0.component_resource_state();
+            ResourceTables {
+                calls,
+                host_table: Some(host_table),
+                tables: Some((*instance).component_resource_tables()),
+            }
+            .exit_call()?;
+        }
+        Ok(())
+    }
+
+    fn store_args<T>(
+        &self,
+        cx: &mut LowerContext<'_, T>,
+        params_ty: &TypeTuple,
+        args: &[Val],
+        dst: &mut MaybeUninit<[ValRaw; MAX_FLAT_PARAMS]>,
+    ) -> Result<()> {
+        let size = usize::try_from(params_ty.abi.size32).unwrap();
+        let ptr = cx.realloc(0, 0, params_ty.abi.align32, size)?;
+        let mut offset = ptr;
+        for (ty, arg) in params_ty.types.iter().zip(args) {
+            let abi = cx.types.canonical_abi(ty);
+            arg.store(cx, *ty, abi.next_field32_size(&mut offset))?;
+        }
+
+        map_maybe_uninit!(dst[0]).write(ValRaw::i64(ptr as i64));
+
+        Ok(())
+    }
+
+    fn load_results(
+        cx: &mut LiftContext<'_>,
+        results_ty: &TypeTuple,
+        results: &mut [Val],
+        src: &mut core::slice::Iter<'_, ValRaw>,
+    ) -> Result<()> {
+        // FIXME: needs to read an i64 for memory64
+        let ptr = usize::try_from(src.next().unwrap().get_u32()).err2anyhow()?;
+        if ptr % usize::try_from(results_ty.abi.align32).err2anyhow()? != 0 {
+            bail!("return pointer not aligned");
+        }
+
+        let bytes = cx
+            .memory()
+            .get(ptr..)
+            .and_then(|b| b.get(..usize::try_from(results_ty.abi.size32).unwrap()))
+            .ok_or_else(|| anyhow::anyhow!("pointer out of bounds of memory"))?;
+
+        let mut offset = 0;
+        for (ty, slot) in results_ty.types.iter().zip(results) {
+            let abi = cx.types.canonical_abi(ty);
+            let offset = abi.next_field32_size(&mut offset);
+            *slot = Val::load(cx, *ty, &bytes[offset..][..abi.size32 as usize])?;
+        }
+        Ok(())
+    }
+}
diff --git a/crates/wasmtime/src/runtime/component/func/host.rs b/crates/wasmtime/src/runtime/component/func/host.rs
new file mode 100644
index 000000000000..ed203fdcedca
--- /dev/null
+++ b/crates/wasmtime/src/runtime/component/func/host.rs
@@ -0,0 +1,439 @@
+use crate::component::func::{LiftContext, LowerContext, Options};
+use crate::component::matching::InstanceType;
+use crate::component::storage::slice_to_storage_mut;
+use crate::component::{ComponentNamedList, ComponentType, Lift, Lower, Val};
+use crate::prelude::*;
+use crate::runtime::vm::component::{
+    InstanceFlags, VMComponentContext, VMLowering, VMLoweringCallee,
+};
+use crate::runtime::vm::{VMFuncRef, VMMemoryDefinition, VMOpaqueContext};
+use crate::{AsContextMut, StoreContextMut, ValRaw};
+use alloc::sync::Arc;
+use core::any::Any;
+use core::mem::{self, MaybeUninit};
+use core::ptr::NonNull;
+use wasmtime_environ::component::{
+    CanonicalAbiInfo, InterfaceType, StringEncoding, TypeFuncIndex, MAX_FLAT_PARAMS,
+    MAX_FLAT_RESULTS,
+};
+
+pub struct HostFunc {
+    entrypoint: VMLoweringCallee,
+    typecheck: Box<dyn (Fn(TypeFuncIndex, &InstanceType<'_>) -> Result<()>) + Send + Sync>,
+    func: Box<dyn Any + Send + Sync>,
+}
+
+impl HostFunc {
+    pub(crate) fn from_closure<T, F, P, R>(func: F) -> Arc<HostFunc>
+    where
+        F: Fn(StoreContextMut<T>, P) -> Result<R> + Send + Sync + 'static,
+        P: ComponentNamedList + Lift + 'static,
+        R: ComponentNamedList + Lower + 'static,
+    {
+        let entrypoint = Self::entrypoint::<T, F, P, R>;
+        Arc::new(HostFunc {
+            entrypoint,
+            typecheck: Box::new(typecheck::<P, R>),
+            func: Box::new(func),
+        })
+    }
+
+    extern "C" fn entrypoint<T, F, P, R>(
+        cx: *mut VMOpaqueContext,
+        data: *mut u8,
+        ty: TypeFuncIndex,
+        flags: InstanceFlags,
+        memory: *mut VMMemoryDefinition,
+        realloc: *mut VMFuncRef,
+        string_encoding: StringEncoding,
+        storage: *mut MaybeUninit<ValRaw>,
+        storage_len: usize,
+    ) where
+        F: Fn(StoreContextMut<T>, P) -> Result<R>,
+        P: ComponentNamedList + Lift + 'static,
+        R: ComponentNamedList + Lower + 'static,
+    {
+        let data = data as *const F;
+        unsafe {
+            handle_result(|| {
+                call_host::<_, _, _, _>(
+                    cx,
+                    ty,
+                    flags,
+                    memory,
+                    realloc,
+                    string_encoding,
+                    core::slice::from_raw_parts_mut(storage, storage_len),
+                    |store, args| (*data)(store, args),
+                )
+            })
+        }
+    }
+
+    pub(crate) fn new_dynamic<T, F>(func: F) -> Arc<HostFunc>
+    where
+        F: Fn(StoreContextMut<'_, T>, &[Val], &mut [Val]) -> Result<()> + Send + Sync + 'static,
+    {
+        Arc::new(HostFunc {
+            entrypoint: dynamic_entrypoint::<T, F>,
+            // This function performs dynamic type checks and subsequently does
+            // not need to perform up-front type checks. Instead everything is
+            // dynamically managed at runtime.
+            typecheck: Box::new(move |_expected_index, _expected_types| Ok(())),
+            func: Box::new(func),
+        })
+    }
+
+    pub fn typecheck(&self, ty: TypeFuncIndex, types: &InstanceType<'_>) -> Result<()> {
+        (self.typecheck)(ty, types)
+    }
+
+    pub fn lowering(&self) -> VMLowering {
+        let data = &*self.func as *const (dyn Any + Send + Sync) as *mut u8;
+        VMLowering {
+            callee: self.entrypoint,
+            data,
+        }
+    }
+}
+
+fn typecheck<P, R>(ty: TypeFuncIndex, types: &InstanceType<'_>) -> Result<()>
+where
+    P: ComponentNamedList + Lift,
+    R: ComponentNamedList + Lower,
+{
+    let ty = &types.types[ty];
+    P::typecheck(&InterfaceType::Tuple(ty.params), types)
+        .context("type mismatch with parameters")?;
+    R::typecheck(&InterfaceType::Tuple(ty.results), types).context("type mismatch with results")?;
+    Ok(())
+}
+
+/// The "meat" of calling a host function from wasm.
+///
+/// This function is delegated to from implementations of
+/// `HostFunc::from_closure`. Most of the arguments from the `entrypoint` are
+/// forwarded here except for the `data` pointer which is encapsulated in the
+/// `closure` argument here.
+///
+/// This function is parameterized over:
+///
+/// * `T` - the type of store this function works with (an unsafe assertion)
+/// * `Params` - the parameters to the host function, viewed as a tuple
+/// * `Return` - the result of the host function
+/// * `F` - the `closure` to actually receive the `Params` and return the
+///   `Return`
+///
+/// It's expected that `F` will "un-tuple" the arguments to pass to a host
+/// closure.
+///
+/// This function is in general `unsafe` as the validity of all the parameters
+/// must be upheld. Generally that's done by ensuring this is only called from
+/// the select few places it's intended to be called from.
+unsafe fn call_host<T, Params, Return, F>(
+    cx: *mut VMOpaqueContext,
+    ty: TypeFuncIndex,
+    mut flags: InstanceFlags,
+    memory: *mut VMMemoryDefinition,
+    realloc: *mut VMFuncRef,
+    string_encoding: StringEncoding,
+    storage: &mut [MaybeUninit<ValRaw>],
+    closure: F,
+) -> Result<()>
+where
+    Params: Lift,
+    Return: Lower,
+    F: FnOnce(StoreContextMut<'_, T>, Params) -> Result<Return>,
+{
+    /// Representation of arguments to this function when a return pointer is in
+    /// use, namely the argument list is followed by a single value which is the
+    /// return pointer.
+    #[repr(C)]
+    struct ReturnPointer<T> {
+        args: T,
+        retptr: ValRaw,
+    }
+
+    /// Representation of arguments to this function when the return value is
+    /// returned directly, namely the arguments and return value all start from
+    /// the beginning (aka this is a `union`, not a `struct`).
+    #[repr(C)]
+    union ReturnStack<T: Copy, U: Copy> {
+        args: T,
+        ret: U,
+    }
+
+    let cx = VMComponentContext::from_opaque(cx);
+    let instance = (*cx).instance();
+    let mut cx = StoreContextMut::from_raw((*instance).store());
+
+    let options = Options::new(
+        cx.0.id(),
+        NonNull::new(memory),
+        NonNull::new(realloc),
+        string_encoding,
+    );
+
+    // Perform a dynamic check that this instance can indeed be left. Exiting
+    // the component is disallowed, for example, when the `realloc` function
+    // calls a canonical import.
+    if !flags.may_leave() {
+        bail!("cannot leave component instance");
+    }
+
+    let types = (*instance).component_types();
+    let ty = &types[ty];
+    let param_tys = InterfaceType::Tuple(ty.params);
+    let result_tys = InterfaceType::Tuple(ty.results);
+
+    // There's a 2x2 matrix of whether parameters and results are stored on the
+    // stack or on the heap. Each of the 4 branches here have a different
+    // representation of the storage of arguments/returns.
+    //
+    // Also note that while four branches are listed here only one is taken for
+    // any particular `Params` and `Return` combination. This should be
+    // trivially DCE'd by LLVM. Perhaps one day with enough const programming in
+    // Rust we can make monomorphizations of this function codegen only one
+    // branch, but today is not that day.
+    let mut storage: Storage<'_, Params, Return> = if Params::flatten_count() <= MAX_FLAT_PARAMS {
+        if Return::flatten_count() <= MAX_FLAT_RESULTS {
+            Storage::Direct(slice_to_storage_mut(storage))
+        } else {
+            Storage::ResultsIndirect(slice_to_storage_mut(storage).assume_init_ref())
+        }
+    } else {
+        if Return::flatten_count() <= MAX_FLAT_RESULTS {
+            Storage::ParamsIndirect(slice_to_storage_mut(storage))
+        } else {
+            Storage::Indirect(slice_to_storage_mut(storage).assume_init_ref())
+        }
+    };
+    let mut lift = LiftContext::new(cx.0, &options, types, instance);
+    lift.enter_call();
+    let params = storage.lift_params(&mut lift, param_tys)?;
+
+    let ret = closure(cx.as_context_mut(), params)?;
+    flags.set_may_leave(false);
+    let mut lower = LowerContext::new(cx, &options, types, instance);
+    storage.lower_results(&mut lower, result_tys, ret)?;
+    flags.set_may_leave(true);
+
+    lower.exit_call()?;
+
+    return Ok(());
+
+    enum Storage<'a, P: ComponentType, R: ComponentType> {
+        Direct(&'a mut MaybeUninit<ReturnStack<P::Lower, R::Lower>>),
+        ParamsIndirect(&'a mut MaybeUninit<ReturnStack<ValRaw, R::Lower>>),
+        ResultsIndirect(&'a ReturnPointer<P::Lower>),
+        Indirect(&'a ReturnPointer<ValRaw>),
+    }
+
+    impl<P, R> Storage<'_, P, R>
+    where
+        P: ComponentType + Lift,
+        R: ComponentType + Lower,
+    {
+        unsafe fn lift_params(&self, cx: &mut LiftContext<'_>, ty: InterfaceType) -> Result<P> {
+            match self {
+                Storage::Direct(storage) => P::lift(cx, ty, &storage.assume_init_ref().args),
+                Storage::ResultsIndirect(storage) => P::lift(cx, ty, &storage.args),
+                Storage::ParamsIndirect(storage) => {
+                    let ptr = validate_inbounds::<P>(cx.memory(), &storage.assume_init_ref().args)?;
+                    P::load(cx, ty, &cx.memory()[ptr..][..P::SIZE32])
+                }
+                Storage::Indirect(storage) => {
+                    let ptr = validate_inbounds::<P>(cx.memory(), &storage.args)?;
+                    P::load(cx, ty, &cx.memory()[ptr..][..P::SIZE32])
+                }
+            }
+        }
+
+        unsafe fn lower_results<T>(
+            &mut self,
+            cx: &mut LowerContext<'_, T>,
+            ty: InterfaceType,
+            ret: R,
+        ) -> Result<()> {
+            match self {
+                Storage::Direct(storage) => ret.lower(cx, ty, map_maybe_uninit!(storage.ret)),
+                Storage::ParamsIndirect(storage) => {
+                    ret.lower(cx, ty, map_maybe_uninit!(storage.ret))
+                }
+                Storage::ResultsIndirect(storage) => {
+                    let ptr = validate_inbounds::<R>(cx.as_slice_mut(), &storage.retptr)?;
+                    ret.store(cx, ty, ptr)
+                }
+                Storage::Indirect(storage) => {
+                    let ptr = validate_inbounds::<R>(cx.as_slice_mut(), &storage.retptr)?;
+                    ret.store(cx, ty, ptr)
+                }
+            }
+        }
+    }
+}
+
+fn validate_inbounds<T: ComponentType>(memory: &[u8], ptr: &ValRaw) -> Result<usize> {
+    // FIXME: needs memory64 support
+    let ptr = usize::try_from(ptr.get_u32()).err2anyhow()?;
+    if ptr % usize::try_from(T::ALIGN32).err2anyhow()? != 0 {
+        bail!("pointer not aligned");
+    }
+    let end = match ptr.checked_add(T::SIZE32) {
+        Some(n) => n,
+        None => bail!("pointer size overflow"),
+    };
+    if end > memory.len() {
+        bail!("pointer out of bounds")
+    }
+    Ok(ptr)
+}
+
+unsafe fn handle_result(func: impl FnOnce() -> Result<()>) {
+    match crate::runtime::vm::catch_unwind_and_longjmp(func) {
+        Ok(()) => {}
+        Err(e) => crate::trap::raise(e),
+    }
+}
+
+unsafe fn call_host_dynamic<T, F>(
+    cx: *mut VMOpaqueContext,
+    ty: TypeFuncIndex,
+    mut flags: InstanceFlags,
+    memory: *mut VMMemoryDefinition,
+    realloc: *mut VMFuncRef,
+    string_encoding: StringEncoding,
+    storage: &mut [MaybeUninit<ValRaw>],
+    closure: F,
+) -> Result<()>
+where
+    F: FnOnce(StoreContextMut<'_, T>, &[Val], &mut [Val]) -> Result<()>,
+{
+    let cx = VMComponentContext::from_opaque(cx);
+    let instance = (*cx).instance();
+    let mut store = StoreContextMut::from_raw((*instance).store());
+    let types = (*instance).component_types();
+    let options = Options::new(
+        store.0.id(),
+        NonNull::new(memory),
+        NonNull::new(realloc),
+        string_encoding,
+    );
+
+    // Perform a dynamic check that this instance can indeed be left. Exiting
+    // the component is disallowed, for example, when the `realloc` function
+    // calls a canonical import.
+    if !flags.may_leave() {
+        bail!("cannot leave component instance");
+    }
+
+    let args;
+    let ret_index;
+
+    let func_ty = &types[ty];
+    let param_tys = &types[func_ty.params];
+    let result_tys = &types[func_ty.results];
+    let mut cx = LiftContext::new(store.0, &options, types, instance);
+    cx.enter_call();
+    if let Some(param_count) = param_tys.abi.flat_count(MAX_FLAT_PARAMS) {
+        // NB: can use `MaybeUninit::slice_assume_init_ref` when that's stable
+        let mut iter =
+            mem::transmute::<&[MaybeUninit<ValRaw>], &[ValRaw]>(&storage[..param_count]).iter();
+        args = param_tys
+            .types
+            .iter()
+            .map(|ty| Val::lift(&mut cx, *ty, &mut iter))
+            .collect::<Result<Box<[_]>>>()?;
+        ret_index = param_count;
+        assert!(iter.next().is_none());
+    } else {
+        let mut offset =
+            validate_inbounds_dynamic(&param_tys.abi, cx.memory(), storage[0].assume_init_ref())?;
+        args = param_tys
+            .types
+            .iter()
+            .map(|ty| {
+                let abi = types.canonical_abi(ty);
+                let size = usize::try_from(abi.size32).unwrap();
+                let memory = &cx.memory()[abi.next_field32_size(&mut offset)..][..size];
+                Val::load(&mut cx, *ty, memory)
+            })
+            .collect::<Result<Box<[_]>>>()?;
+        ret_index = 1;
+    };
+
+    let mut result_vals = Vec::with_capacity(result_tys.types.len());
+    for _ in result_tys.types.iter() {
+        result_vals.push(Val::Bool(false));
+    }
+    closure(store.as_context_mut(), &args, &mut result_vals)?;
+    flags.set_may_leave(false);
+
+    let mut cx = LowerContext::new(store, &options, types, instance);
+    if let Some(cnt) = result_tys.abi.flat_count(MAX_FLAT_RESULTS) {
+        let mut dst = storage[..cnt].iter_mut();
+        for (val, ty) in result_vals.iter().zip(result_tys.types.iter()) {
+            val.lower(&mut cx, *ty, &mut dst)?;
+        }
+        assert!(dst.next().is_none());
+    } else {
+        let ret_ptr = storage[ret_index].assume_init_ref();
+        let mut ptr = validate_inbounds_dynamic(&result_tys.abi, cx.as_slice_mut(), ret_ptr)?;
+        for (val, ty) in result_vals.iter().zip(result_tys.types.iter()) {
+            let offset = types.canonical_abi(ty).next_field32_size(&mut ptr);
+            val.store(&mut cx, *ty, offset)?;
+        }
+    }
+
+    flags.set_may_leave(true);
+
+    cx.exit_call()?;
+
+    return Ok(());
+}
+
+fn validate_inbounds_dynamic(abi: &CanonicalAbiInfo, memory: &[u8], ptr: &ValRaw) -> Result<usize> {
+    // FIXME: needs memory64 support
+    let ptr = usize::try_from(ptr.get_u32()).err2anyhow()?;
+    if ptr % usize::try_from(abi.align32).err2anyhow()? != 0 {
+        bail!("pointer not aligned");
+    }
+    let end = match ptr.checked_add(usize::try_from(abi.size32).unwrap()) {
+        Some(n) => n,
+        None => bail!("pointer size overflow"),
+    };
+    if end > memory.len() {
+        bail!("pointer out of bounds")
+    }
+    Ok(ptr)
+}
+
+extern "C" fn dynamic_entrypoint<T, F>(
+    cx: *mut VMOpaqueContext,
+    data: *mut u8,
+    ty: TypeFuncIndex,
+    flags: InstanceFlags,
+    memory: *mut VMMemoryDefinition,
+    realloc: *mut VMFuncRef,
+    string_encoding: StringEncoding,
+    storage: *mut MaybeUninit<ValRaw>,
+    storage_len: usize,
+) where
+    F: Fn(StoreContextMut<'_, T>, &[Val], &mut [Val]) -> Result<()> + Send + Sync + 'static,
+{
+    let data = data as *const F;
+    unsafe {
+        handle_result(|| {
+            call_host_dynamic::<T, _>(
+                cx,
+                ty,
+                flags,
+                memory,
+                realloc,
+                string_encoding,
+                core::slice::from_raw_parts_mut(storage, storage_len),
+                |store, params, results| (*data)(store, params, results),
+            )
+        })
+    }
+}
diff --git a/crates/wasmtime/src/component/func/options.rs b/crates/wasmtime/src/runtime/component/func/options.rs
similarity index 77%
rename from crates/wasmtime/src/component/func/options.rs
rename to crates/wasmtime/src/runtime/component/func/options.rs
index 6cb038f4f692..83accf3dee97 100644
--- a/crates/wasmtime/src/component/func/options.rs
+++ b/crates/wasmtime/src/runtime/component/func/options.rs
@@ -1,15 +1,16 @@
 use crate::component::matching::InstanceType;
+use crate::component::resources::{HostResourceData, HostResourceIndex, HostResourceTables};
 use crate::component::ResourceType;
-use crate::store::{StoreId, StoreOpaque};
-use crate::StoreContextMut;
-use anyhow::{bail, Result};
-use std::ptr::NonNull;
-use std::sync::Arc;
-use wasmtime_environ::component::{ComponentTypes, StringEncoding, TypeResourceTableIndex};
-use wasmtime_runtime::component::{
+use crate::prelude::*;
+use crate::runtime::vm::component::{
     CallContexts, ComponentInstance, InstanceFlags, ResourceTable, ResourceTables,
 };
-use wasmtime_runtime::{VMFuncRef, VMMemoryDefinition};
+use crate::runtime::vm::{VMFuncRef, VMMemoryDefinition};
+use crate::store::{StoreId, StoreOpaque};
+use crate::{FuncType, StoreContextMut};
+use alloc::sync::Arc;
+use core::ptr::NonNull;
+use wasmtime_environ::component::{ComponentTypes, StringEncoding, TypeResourceTableIndex};
 
 /// Runtime representation of canonical ABI options in the component model.
 ///
@@ -77,6 +78,7 @@ impl Options {
     fn realloc<'a, T>(
         &self,
         store: &'a mut StoreContextMut<'_, T>,
+        realloc_ty: &FuncType,
         old: usize,
         old_size: usize,
         old_align: u32,
@@ -86,25 +88,27 @@ impl Options {
 
         let realloc = self.realloc.unwrap();
 
+        let params = (
+            u32::try_from(old).err2anyhow()?,
+            u32::try_from(old_size).err2anyhow()?,
+            old_align,
+            u32::try_from(new_size).err2anyhow()?,
+        );
+
+        type ReallocFunc = crate::TypedFunc<(u32, u32, u32, u32), u32>;
+
+        // This call doesn't take any GC refs, and therefore we shouldn't ever
+        // need to GC before entering Wasm.
+        debug_assert!(!ReallocFunc::need_gc_before_call_raw(store.0, &params));
+
         // Invoke the wasm malloc function using its raw and statically known
         // signature.
-        let result = unsafe {
-            crate::TypedFunc::<(u32, u32, u32, u32), u32>::call_raw(
-                store,
-                realloc,
-                (
-                    u32::try_from(old)?,
-                    u32::try_from(old_size)?,
-                    old_align,
-                    u32::try_from(new_size)?,
-                ),
-            )?
-        };
+        let result = unsafe { ReallocFunc::call_raw(store, realloc_ty, realloc, params)? };
 
         if result % old_align != 0 {
             bail!("realloc return: result not aligned");
         }
-        let result = usize::try_from(result)?;
+        let result = usize::try_from(result).err2anyhow()?;
 
         let memory = self.memory_mut(store.0);
 
@@ -134,7 +138,7 @@ impl Options {
         // is an optional configuration in canonical ABI options.
         unsafe {
             let memory = self.memory.unwrap().as_ref();
-            std::slice::from_raw_parts(memory.base, memory.current_length())
+            core::slice::from_raw_parts(memory.base, memory.current_length())
         }
     }
 
@@ -145,7 +149,7 @@ impl Options {
         // See comments in `memory` about the unsafety
         unsafe {
             let memory = self.memory.unwrap().as_ref();
-            std::slice::from_raw_parts_mut(memory.base, memory.current_length())
+            core::slice::from_raw_parts_mut(memory.base, memory.current_length())
         }
     }
 
@@ -242,8 +246,17 @@ impl<'a, T> LowerContext<'a, T> {
         old_align: u32,
         new_size: usize,
     ) -> Result<usize> {
+        let realloc_func_ty = Arc::clone(unsafe { (*self.instance).realloc_func_ty() });
+        let realloc_func_ty = realloc_func_ty.downcast_ref::<FuncType>().unwrap();
         self.options
-            .realloc(&mut self.store, old, old_size, old_align, new_size)
+            .realloc(
+                &mut self.store,
+                &realloc_func_ty,
+                old,
+                old_size,
+                old_align,
+                new_size,
+            )
             .map(|(_, ptr)| ptr)
     }
 
@@ -268,22 +281,28 @@ impl<'a, T> LowerContext<'a, T> {
         // For now I figure we can leave in this bounds check and if it becomes
         // an issue we can optimize further later, probably with judicious use
         // of `unsafe`.
-        (&mut self.as_slice_mut()[offset..][..N])
-            .try_into()
-            .unwrap()
+        self.as_slice_mut()[offset..].first_chunk_mut().unwrap()
     }
 
     /// Lowers an `own` resource into the guest, converting the `rep` specified
     /// into a guest-local index.
     ///
     /// The `ty` provided is which table to put this into.
-    pub fn guest_resource_lower_own(&mut self, ty: TypeResourceTableIndex, rep: u32) -> u32 {
-        self.resource_tables().resource_lower_own(Some(ty), rep)
+    pub fn guest_resource_lower_own(
+        &mut self,
+        ty: TypeResourceTableIndex,
+        rep: u32,
+    ) -> Result<u32> {
+        self.resource_tables().guest_resource_lower_own(rep, ty)
     }
 
     /// Lowers a `borrow` resource into the guest, converting the `rep` to a
     /// guest-local index in the `ty` table specified.
-    pub fn guest_resource_lower_borrow(&mut self, ty: TypeResourceTableIndex, rep: u32) -> u32 {
+    pub fn guest_resource_lower_borrow(
+        &mut self,
+        ty: TypeResourceTableIndex,
+        rep: u32,
+    ) -> Result<u32> {
         // Implement `lower_borrow`'s special case here where if a borrow is
         // inserted into a table owned by the instance which implemented the
         // original resource then no borrow tracking is employed and instead the
@@ -296,21 +315,21 @@ impl<'a, T> LowerContext<'a, T> {
         // Note that the unsafety here should be valid given the contract of
         // `LowerContext::new`.
         if unsafe { (*self.instance).resource_owned_by_own_instance(ty) } {
-            return rep;
+            return Ok(rep);
         }
-        self.resource_tables().resource_lower_borrow(Some(ty), rep)
+        self.resource_tables().guest_resource_lower_borrow(rep, ty)
     }
 
     /// Lifts a host-owned `own` resource at the `idx` specified into the
     /// representation of that resource.
-    pub fn host_resource_lift_own(&mut self, idx: u32) -> Result<u32> {
-        self.resource_tables().resource_lift_own(None, idx)
+    pub fn host_resource_lift_own(&mut self, idx: HostResourceIndex) -> Result<u32> {
+        self.resource_tables().host_resource_lift_own(idx)
     }
 
     /// Lifts a host-owned `borrow` resource at the `idx` specified into the
     /// representation of that resource.
-    pub fn host_resource_lift_borrow(&mut self, idx: u32) -> Result<u32> {
-        self.resource_tables().resource_lift_borrow(None, idx)
+    pub fn host_resource_lift_borrow(&mut self, idx: HostResourceIndex) -> Result<u32> {
+        self.resource_tables().host_resource_lift_borrow(idx)
     }
 
     /// Lowers a resource into the host-owned table, returning the index it was
@@ -318,8 +337,14 @@ impl<'a, T> LowerContext<'a, T> {
     ///
     /// Note that this is a special case for `Resource<T>`. Most of the time a
     /// host value shouldn't be lowered with a lowering context.
-    pub fn host_resource_lower_own(&mut self, rep: u32) -> u32 {
-        self.resource_tables().resource_lower_own(None, rep)
+    pub fn host_resource_lower_own(
+        &mut self,
+        rep: u32,
+        dtor: Option<NonNull<VMFuncRef>>,
+        flags: Option<InstanceFlags>,
+    ) -> Result<HostResourceIndex> {
+        self.resource_tables()
+            .host_resource_lower_own(rep, dtor, flags)
     }
 
     /// Returns the underlying resource type for the `ty` table specified.
@@ -335,26 +360,27 @@ impl<'a, T> LowerContext<'a, T> {
         InstanceType::new(unsafe { &*self.instance })
     }
 
-    fn resource_tables(&mut self) -> ResourceTables<'_> {
-        let (calls, host_table) = self.store.0.component_calls_and_host_table();
-        ResourceTables {
-            host_table: Some(host_table),
-            calls,
-            // Note that the unsafety here should be valid given the contract of
-            // `LowerContext::new`.
-            tables: Some(unsafe { (*self.instance).component_resource_tables() }),
-        }
+    fn resource_tables(&mut self) -> HostResourceTables<'_> {
+        let (calls, host_table, host_resource_data) = self.store.0.component_resource_state();
+        HostResourceTables::from_parts(
+            ResourceTables {
+                host_table: Some(host_table),
+                calls,
+                // Note that the unsafety here should be valid given the contract of
+                // `LowerContext::new`.
+                tables: Some(unsafe { (*self.instance).component_resource_tables() }),
+            },
+            host_resource_data,
+        )
     }
 
-    /// Begins a call into the component instance, starting recording of
-    /// metadata related to resource borrowing.
+    /// See [`HostResourceTables::enter_call`].
     #[inline]
     pub fn enter_call(&mut self) {
         self.resource_tables().enter_call()
     }
 
-    /// Completes a call into the component instance, validating that it's ok to
-    /// complete by ensuring the are no remaining active borrows.
+    /// See [`HostResourceTables::exit_call`].
     #[inline]
     pub fn exit_call(&mut self) -> Result<()> {
         self.resource_tables().exit_call()
@@ -379,6 +405,7 @@ pub struct LiftContext<'a> {
     instance: *mut ComponentInstance,
 
     host_table: &'a mut ResourceTable,
+    host_resource_data: &'a mut HostResourceData,
 
     calls: &'a mut CallContexts,
 }
@@ -404,8 +431,8 @@ impl<'a> LiftContext<'a> {
         // so it's hacked around a bit. This unsafe pointer cast could be fixed
         // with more methods in more places, but it doesn't seem worth doing it
         // at this time.
-        let (calls, host_table) =
-            (&mut *(store as *mut StoreOpaque)).component_calls_and_host_table();
+        let (calls, host_table, host_resource_data) =
+            (&mut *(store as *mut StoreOpaque)).component_resource_state();
         let memory = options.memory.map(|_| options.memory(store));
 
         LiftContext {
@@ -415,6 +442,7 @@ impl<'a> LiftContext<'a> {
             instance,
             calls,
             host_table,
+            host_resource_data,
         }
     }
 
@@ -450,7 +478,7 @@ impl<'a> LiftContext<'a> {
         ty: TypeResourceTableIndex,
         idx: u32,
     ) -> Result<(u32, Option<NonNull<VMFuncRef>>, Option<InstanceFlags>)> {
-        let idx = self.resource_tables().resource_lift_own(Some(ty), idx)?;
+        let idx = self.resource_tables().guest_resource_lift_own(idx, ty)?;
         // Note that the unsafety here should be valid given the contract of
         // `LiftContext::new`.
         let (dtor, flags) = unsafe { (*self.instance).dtor_and_flags(ty) };
@@ -463,19 +491,25 @@ impl<'a> LiftContext<'a> {
         ty: TypeResourceTableIndex,
         idx: u32,
     ) -> Result<u32> {
-        self.resource_tables().resource_lift_borrow(Some(ty), idx)
+        self.resource_tables().guest_resource_lift_borrow(idx, ty)
     }
 
     /// Lowers a resource into the host-owned table, returning the index it was
     /// inserted at.
-    pub fn host_resource_lower_own(&mut self, rep: u32) -> u32 {
-        self.resource_tables().resource_lower_own(None, rep)
+    pub fn host_resource_lower_own(
+        &mut self,
+        rep: u32,
+        dtor: Option<NonNull<VMFuncRef>>,
+        flags: Option<InstanceFlags>,
+    ) -> Result<HostResourceIndex> {
+        self.resource_tables()
+            .host_resource_lower_own(rep, dtor, flags)
     }
 
     /// Lowers a resource into the host-owned table, returning the index it was
     /// inserted at.
-    pub fn host_resource_lower_borrow(&mut self, rep: u32) -> u32 {
-        self.resource_tables().resource_lower_borrow(None, rep)
+    pub fn host_resource_lower_borrow(&mut self, rep: u32) -> Result<HostResourceIndex> {
+        self.resource_tables().host_resource_lower_borrow(rep)
     }
 
     /// Returns the underlying type of the resource table specified by `ty`.
@@ -491,23 +525,26 @@ impl<'a> LiftContext<'a> {
         InstanceType::new(unsafe { &*self.instance })
     }
 
-    fn resource_tables(&mut self) -> ResourceTables<'_> {
-        ResourceTables {
-            host_table: Some(self.host_table),
-            calls: self.calls,
-            // Note that the unsafety here should be valid given the contract of
-            // `LiftContext::new`.
-            tables: Some(unsafe { (*self.instance).component_resource_tables() }),
-        }
+    fn resource_tables(&mut self) -> HostResourceTables<'_> {
+        HostResourceTables::from_parts(
+            ResourceTables {
+                host_table: Some(self.host_table),
+                calls: self.calls,
+                // Note that the unsafety here should be valid given the contract of
+                // `LiftContext::new`.
+                tables: Some(unsafe { (*self.instance).component_resource_tables() }),
+            },
+            self.host_resource_data,
+        )
     }
 
-    /// Same as `LowerContext::enter_call`
+    /// See [`HostResourceTables::enter_call`].
     #[inline]
     pub fn enter_call(&mut self) {
         self.resource_tables().enter_call()
     }
 
-    /// Same as `LiftContext::enter_call`
+    /// See [`HostResourceTables::exit_call`].
     #[inline]
     pub fn exit_call(&mut self) -> Result<()> {
         self.resource_tables().exit_call()
diff --git a/crates/wasmtime/src/runtime/component/func/typed.rs b/crates/wasmtime/src/runtime/component/func/typed.rs
new file mode 100644
index 000000000000..ec1df7b3afc1
--- /dev/null
+++ b/crates/wasmtime/src/runtime/component/func/typed.rs
@@ -0,0 +1,2497 @@
+use crate::component::func::{Func, LiftContext, LowerContext, Options};
+use crate::component::matching::InstanceType;
+use crate::component::storage::{storage_as_slice, storage_as_slice_mut};
+use crate::prelude::*;
+use crate::runtime::vm::component::ComponentInstance;
+use crate::runtime::vm::SendSyncPtr;
+use crate::{AsContextMut, StoreContext, StoreContextMut, ValRaw};
+use alloc::borrow::Cow;
+use alloc::sync::Arc;
+use core::fmt;
+use core::marker;
+use core::mem::{self, MaybeUninit};
+use core::ptr::NonNull;
+use core::str;
+use wasmtime_environ::component::{
+    CanonicalAbiInfo, ComponentTypes, InterfaceType, StringEncoding, VariantInfo, MAX_FLAT_PARAMS,
+    MAX_FLAT_RESULTS,
+};
+
+/// A statically-typed version of [`Func`] which takes `Params` as input and
+/// returns `Return`.
+///
+/// This is an efficient way to invoke a WebAssembly component where if the
+/// inputs and output are statically known this can eschew the vast majority of
+/// machinery and checks when calling WebAssembly. This is the most optimized
+/// way to call a WebAssembly component.
+///
+/// Note that like [`Func`] this is a pointer within a [`Store`](crate::Store)
+/// and usage will panic if used with the wrong store.
+///
+/// This type is primarily created with the [`Func::typed`] API.
+///
+/// See [`ComponentType`] for more information about supported types.
+pub struct TypedFunc<Params, Return> {
+    func: Func,
+
+    // The definition of this field is somewhat subtle and may be surprising.
+    // Naively one might expect something like
+    //
+    //      _marker: marker::PhantomData<fn(Params) -> Return>,
+    //
+    // Since this is a function pointer after all. The problem with this
+    // definition though is that it imposes the wrong variance on `Params` from
+    // what we want. Abstractly a `fn(Params)` is able to store `Params` within
+    // it meaning you can only give it `Params` that live longer than the
+    // function pointer.
+    //
+    // With a component model function, however, we're always copying data from
+    // the host into the guest, so we are never storing pointers to `Params`
+    // into the guest outside the duration of a `call`, meaning we can actually
+    // accept values in `TypedFunc::call` which live for a shorter duration
+    // than the `Params` argument on the struct.
+    //
+    // This all means that we don't use a phantom function pointer, but instead
+    // feign phantom storage here to get the variance desired.
+    _marker: marker::PhantomData<(Params, Return)>,
+}
+
+impl<Params, Return> Copy for TypedFunc<Params, Return> {}
+
+impl<Params, Return> Clone for TypedFunc<Params, Return> {
+    fn clone(&self) -> TypedFunc<Params, Return> {
+        *self
+    }
+}
+
+impl<Params, Return> TypedFunc<Params, Return>
+where
+    Params: ComponentNamedList + Lower,
+    Return: ComponentNamedList + Lift,
+{
+    /// Creates a new [`TypedFunc`] from the provided component [`Func`],
+    /// unsafely asserting that the underlying function takes `Params` as
+    /// input and returns `Return`.
+    ///
+    /// # Unsafety
+    ///
+    /// This is an unsafe function because it does not verify that the [`Func`]
+    /// provided actually implements this signature. It's up to the caller to
+    /// have performed some other sort of check to ensure that the signature is
+    /// correct.
+    pub unsafe fn new_unchecked(func: Func) -> TypedFunc<Params, Return> {
+        TypedFunc {
+            _marker: marker::PhantomData,
+            func,
+        }
+    }
+
+    /// Returns the underlying un-typed [`Func`] that this [`TypedFunc`]
+    /// references.
+    pub fn func(&self) -> &Func {
+        &self.func
+    }
+
+    /// Calls the underlying WebAssembly component function using the provided
+    /// `params` as input.
+    ///
+    /// This method is used to enter into a component. Execution happens within
+    /// the `store` provided. The `params` are copied into WebAssembly memory
+    /// as appropriate and a core wasm function is invoked.
+    ///
+    /// # Post-return
+    ///
+    /// In the component model each function can have a "post return" specified
+    /// which allows cleaning up the arguments returned to the host. For example
+    /// if WebAssembly returns a string to the host then it might be a uniquely
+    /// allocated string which, after the host finishes processing it, needs to
+    /// be deallocated in the wasm instance's own linear memory to prevent
+    /// memory leaks in wasm itself. The `post-return` canonical abi option is
+    /// used to configured this.
+    ///
+    /// To accommodate this feature of the component model after invoking a
+    /// function via [`TypedFunc::call`] you must next invoke
+    /// [`TypedFunc::post_return`]. Note that the return value of the function
+    /// should be processed between these two function calls. The return value
+    /// continues to be usable from an embedder's perspective after
+    /// `post_return` is called, but after `post_return` is invoked it may no
+    /// longer retain the same value that the wasm module originally returned.
+    ///
+    /// Also note that [`TypedFunc::post_return`] must be invoked irrespective
+    /// of whether the canonical ABI option `post-return` was configured or not.
+    /// This means that embedders must unconditionally call
+    /// [`TypedFunc::post_return`] when a function returns. If this function
+    /// call returns an error, however, then [`TypedFunc::post_return`] is not
+    /// required.
+    ///
+    /// # Errors
+    ///
+    /// This function can return an error for a number of reasons:
+    ///
+    /// * If the wasm itself traps during execution.
+    /// * If the wasm traps while copying arguments into memory.
+    /// * If the wasm provides bad allocation pointers when copying arguments
+    ///   into memory.
+    /// * If the wasm returns a value which violates the canonical ABI.
+    /// * If this function's instances cannot be entered, for example if the
+    ///   instance is currently calling a host function.
+    /// * If a previous function call occurred and the corresponding
+    ///   `post_return` hasn't been invoked yet.
+    ///
+    /// In general there are many ways that things could go wrong when copying
+    /// types in and out of a wasm module with the canonical ABI, and certain
+    /// error conditions are specific to certain types. For example a
+    /// WebAssembly module can't return an invalid `char`. When allocating space
+    /// for this host to copy a string into the returned pointer must be
+    /// in-bounds in memory.
+    ///
+    /// If an error happens then the error should contain detailed enough
+    /// information to understand which part of the canonical ABI went wrong
+    /// and what to inspect.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this is called on a function in an asynchronous store. This
+    /// only works with functions defined within a synchronous store. Also
+    /// panics if `store` does not own this function.
+    pub fn call(&self, store: impl AsContextMut, params: Params) -> Result<Return> {
+        assert!(
+            !store.as_context().async_support(),
+            "must use `call_async` when async support is enabled on the config"
+        );
+        self.call_impl(store, params)
+    }
+
+    /// Exactly like [`Self::call`], except for use on asynchronous stores.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this is called on a function in a synchronous store. This
+    /// only works with functions defined within an asynchronous store. Also
+    /// panics if `store` does not own this function.
+    #[cfg(feature = "async")]
+    pub async fn call_async<T>(
+        &self,
+        mut store: impl AsContextMut<Data = T>,
+        params: Params,
+    ) -> Result<Return>
+    where
+        T: Send,
+        Params: Send + Sync,
+        Return: Send + Sync,
+    {
+        let mut store = store.as_context_mut();
+        assert!(
+            store.0.async_support(),
+            "cannot use `call_async` when async support is not enabled on the config"
+        );
+        store
+            .on_fiber(|store| self.call_impl(store, params))
+            .await?
+    }
+
+    fn call_impl(&self, mut store: impl AsContextMut, params: Params) -> Result<Return> {
+        let store = &mut store.as_context_mut();
+        // Note that this is in theory simpler than it might read at this time.
+        // Here we're doing a runtime dispatch on the `flatten_count` for the
+        // params/results to see whether they're inbounds. This creates 4 cases
+        // to handle. In reality this is a highly optimizable branch where LLVM
+        // will easily figure out that only one branch here is taken.
+        //
+        // Otherwise this current construction is done to ensure that the stack
+        // space reserved for the params/results is always of the appropriate
+        // size (as the params/results needed differ depending on the "flatten"
+        // count)
+        if Params::flatten_count() <= MAX_FLAT_PARAMS {
+            if Return::flatten_count() <= MAX_FLAT_RESULTS {
+                self.func.call_raw(
+                    store,
+                    &params,
+                    Self::lower_stack_args,
+                    Self::lift_stack_result,
+                )
+            } else {
+                self.func.call_raw(
+                    store,
+                    &params,
+                    Self::lower_stack_args,
+                    Self::lift_heap_result,
+                )
+            }
+        } else {
+            if Return::flatten_count() <= MAX_FLAT_RESULTS {
+                self.func.call_raw(
+                    store,
+                    &params,
+                    Self::lower_heap_args,
+                    Self::lift_stack_result,
+                )
+            } else {
+                self.func.call_raw(
+                    store,
+                    &params,
+                    Self::lower_heap_args,
+                    Self::lift_heap_result,
+                )
+            }
+        }
+    }
+
+    /// Lower parameters directly onto the stack specified by the `dst`
+    /// location.
+    ///
+    /// This is only valid to call when the "flatten count" is small enough, or
+    /// when the canonical ABI says arguments go through the stack rather than
+    /// the heap.
+    fn lower_stack_args<T>(
+        cx: &mut LowerContext<'_, T>,
+        params: &Params,
+        ty: InterfaceType,
+        dst: &mut MaybeUninit<Params::Lower>,
+    ) -> Result<()> {
+        assert!(Params::flatten_count() <= MAX_FLAT_PARAMS);
+        params.lower(cx, ty, dst)?;
+        Ok(())
+    }
+
+    /// Lower parameters onto a heap-allocated location.
+    ///
+    /// This is used when the stack space to be used for the arguments is above
+    /// the `MAX_FLAT_PARAMS` threshold. Here the wasm's `realloc` function is
+    /// invoked to allocate space and then parameters are stored at that heap
+    /// pointer location.
+    fn lower_heap_args<T>(
+        cx: &mut LowerContext<'_, T>,
+        params: &Params,
+        ty: InterfaceType,
+        dst: &mut MaybeUninit<ValRaw>,
+    ) -> Result<()> {
+        assert!(Params::flatten_count() > MAX_FLAT_PARAMS);
+
+        // Memory must exist via validation if the arguments are stored on the
+        // heap, so we can create a `MemoryMut` at this point. Afterwards
+        // `realloc` is used to allocate space for all the arguments and then
+        // they're all stored in linear memory.
+        //
+        // Note that `realloc` will bake in a check that the returned pointer is
+        // in-bounds.
+        let ptr = cx.realloc(0, 0, Params::ALIGN32, Params::SIZE32)?;
+        params.store(cx, ty, ptr)?;
+
+        // Note that the pointer here is stored as a 64-bit integer. This allows
+        // this to work with either 32 or 64-bit memories. For a 32-bit memory
+        // it'll just ignore the upper 32 zero bits, and for 64-bit memories
+        // this'll have the full 64-bits. Note that for 32-bit memories the call
+        // to `realloc` above guarantees that the `ptr` is in-bounds meaning
+        // that we will know that the zero-extended upper bits of `ptr` are
+        // guaranteed to be zero.
+        //
+        // This comment about 64-bit integers is also referred to below with
+        // "WRITEPTR64".
+        dst.write(ValRaw::i64(ptr as i64));
+
+        Ok(())
+    }
+
+    /// Lift the result of a function directly from the stack result.
+    ///
+    /// This is only used when the result fits in the maximum number of stack
+    /// slots.
+    fn lift_stack_result(
+        cx: &mut LiftContext<'_>,
+        ty: InterfaceType,
+        dst: &Return::Lower,
+    ) -> Result<Return> {
+        assert!(Return::flatten_count() <= MAX_FLAT_RESULTS);
+        Return::lift(cx, ty, dst)
+    }
+
+    /// Lift the result of a function where the result is stored indirectly on
+    /// the heap.
+    fn lift_heap_result(
+        cx: &mut LiftContext<'_>,
+        ty: InterfaceType,
+        dst: &ValRaw,
+    ) -> Result<Return> {
+        assert!(Return::flatten_count() > MAX_FLAT_RESULTS);
+        // FIXME: needs to read an i64 for memory64
+        let ptr = usize::try_from(dst.get_u32()).err2anyhow()?;
+        if ptr % usize::try_from(Return::ALIGN32).err2anyhow()? != 0 {
+            bail!("return pointer not aligned");
+        }
+
+        let bytes = cx
+            .memory()
+            .get(ptr..)
+            .and_then(|b| b.get(..Return::SIZE32))
+            .ok_or_else(|| anyhow::anyhow!("pointer out of bounds of memory"))?;
+        Return::load(cx, ty, bytes)
+    }
+
+    /// See [`Func::post_return`]
+    pub fn post_return(&self, store: impl AsContextMut) -> Result<()> {
+        self.func.post_return(store)
+    }
+
+    /// See [`Func::post_return_async`]
+    #[cfg(feature = "async")]
+    pub async fn post_return_async<T: Send>(
+        &self,
+        store: impl AsContextMut<Data = T>,
+    ) -> Result<()> {
+        self.func.post_return_async(store).await
+    }
+}
+
+/// A trait representing a static list of named types that can be passed to or
+/// returned from a [`TypedFunc`].
+///
+/// This trait is implemented for a number of tuple types and is not expected
+/// to be implemented externally. The contents of this trait are hidden as it's
+/// intended to be an implementation detail of Wasmtime. The contents of this
+/// trait are not covered by Wasmtime's stability guarantees.
+///
+/// For more information about this trait see [`Func::typed`] and
+/// [`TypedFunc`].
+//
+// Note that this is an `unsafe` trait, and the unsafety means that
+// implementations of this trait must be correct or otherwise [`TypedFunc`]
+// would not be memory safe. The main reason this is `unsafe` is the
+// `typecheck` function which must operate correctly relative to the `AsTuple`
+// interpretation of the implementor.
+pub unsafe trait ComponentNamedList: ComponentType {}
+
+/// A trait representing types which can be passed to and read from components
+/// with the canonical ABI.
+///
+/// This trait is implemented for Rust types which can be communicated to
+/// components. The [`Func::typed`] and [`TypedFunc`] Rust items are the main
+/// consumers of this trait.
+///
+/// Supported Rust types include:
+///
+/// | Component Model Type              | Rust Type                            |
+/// |-----------------------------------|--------------------------------------|
+/// | `{s,u}{8,16,32,64}`               | `{i,u}{8,16,32,64}`                  |
+/// | `f{32,64}`                        | `f{32,64}`                           |
+/// | `bool`                            | `bool`                               |
+/// | `char`                            | `char`                               |
+/// | `tuple<A, B>`                     | `(A, B)`                             |
+/// | `option<T>`                       | `Option<T>`                          |
+/// | `result`                          | `Result<(), ()>`                     |
+/// | `result<T>`                       | `Result<T, ()>`                      |
+/// | `result<_, E>`                    | `Result<(), E>`                      |
+/// | `result<T, E>`                    | `Result<T, E>`                       |
+/// | `string`                          | `String`, `&str`, or [`WasmStr`]     |
+/// | `list<T>`                         | `Vec<T>`, `&[T]`, or [`WasmList`]    |
+/// | `own<T>`, `borrow<T>`             | [`Resource<T>`] or [`ResourceAny`]   |
+/// | `record`                          | [`#[derive(ComponentType)]`][d-cm]   |
+/// | `variant`                         | [`#[derive(ComponentType)]`][d-cm]   |
+/// | `enum`                            | [`#[derive(ComponentType)]`][d-cm]   |
+/// | `flags`                           | [`flags!`][f-m]                      |
+///
+/// [`Resource<T>`]: crate::component::Resource
+/// [`ResourceAny`]: crate::component::ResourceAny
+/// [d-cm]: macro@crate::component::ComponentType
+/// [f-m]: crate::component::flags
+///
+/// Rust standard library pointers such as `&T`, `Box<T>`, `Rc<T>`, and `Arc<T>`
+/// additionally represent whatever type `T` represents in the component model.
+/// Note that types such as `record`, `variant`, `enum`, and `flags` are
+/// generated by the embedder at compile time. These macros derive
+/// implementation of this trait for custom types to map to custom types in the
+/// component model. Note that for `record`, `variant`, `enum`, and `flags`
+/// those types are often generated by the
+/// [`bindgen!`](crate::component::bindgen) macro from WIT definitions.
+///
+/// Types that implement [`ComponentType`] are used for `Params` and `Return`
+/// in [`TypedFunc`] and [`Func::typed`].
+///
+/// The contents of this trait are hidden as it's intended to be an
+/// implementation detail of Wasmtime. The contents of this trait are not
+/// covered by Wasmtime's stability guarantees.
+//
+// Note that this is an `unsafe` trait as `TypedFunc`'s safety heavily relies on
+// the correctness of the implementations of this trait. Some ways in which this
+// trait must be correct to be safe are:
+//
+// * The `Lower` associated type must be a `ValRaw` sequence. It doesn't have to
+//   literally be `[ValRaw; N]` but when laid out in memory it must be adjacent
+//   `ValRaw` values and have a multiple of the size of `ValRaw` and the same
+//   alignment.
+//
+// * The `lower` function must initialize the bits within `Lower` that are going
+//   to be read by the trampoline that's used to enter core wasm. A trampoline
+//   is passed `*mut Lower` and will read the canonical abi arguments in
+//   sequence, so all of the bits must be correctly initialized.
+//
+// * The `size` and `align` functions must be correct for this value stored in
+//   the canonical ABI. The `Cursor<T>` iteration of these bytes rely on this
+//   for correctness as they otherwise eschew bounds-checking.
+//
+// There are likely some other correctness issues which aren't documented as
+// well, this isn't intended to be an exhaustive list. It suffices to say,
+// though, that correctness bugs in this trait implementation are highly likely
+// to lead to security bugs, which again leads to the `unsafe` in the trait.
+//
+// Also note that this trait specifically is not sealed because we have a proc
+// macro that generates implementations of this trait for external types in a
+// `#[derive]`-like fashion.
+pub unsafe trait ComponentType {
+    /// Representation of the "lowered" form of this component value.
+    ///
+    /// Lowerings lower into core wasm values which are represented by `ValRaw`.
+    /// This `Lower` type must be a list of `ValRaw` as either a literal array
+    /// or a struct where every field is a `ValRaw`. This must be `Copy` (as
+    /// `ValRaw` is `Copy`) and support all byte patterns. This being correct is
+    /// one reason why the trait is unsafe.
+    #[doc(hidden)]
+    type Lower: Copy;
+
+    /// The information about this type's canonical ABI (size/align/etc).
+    #[doc(hidden)]
+    const ABI: CanonicalAbiInfo;
+
+    #[doc(hidden)]
+    const SIZE32: usize = Self::ABI.size32 as usize;
+    #[doc(hidden)]
+    const ALIGN32: u32 = Self::ABI.align32;
+
+    #[doc(hidden)]
+    const IS_RUST_UNIT_TYPE: bool = false;
+
+    /// Returns the number of core wasm abi values will be used to represent
+    /// this type in its lowered form.
+    ///
+    /// This divides the size of `Self::Lower` by the size of `ValRaw`.
+    #[doc(hidden)]
+    fn flatten_count() -> usize {
+        assert!(mem::size_of::<Self::Lower>() % mem::size_of::<ValRaw>() == 0);
+        assert!(mem::align_of::<Self::Lower>() == mem::align_of::<ValRaw>());
+        mem::size_of::<Self::Lower>() / mem::size_of::<ValRaw>()
+    }
+
+    /// Performs a type-check to see whether this component value type matches
+    /// the interface type `ty` provided.
+    #[doc(hidden)]
+    fn typecheck(ty: &InterfaceType, types: &InstanceType<'_>) -> Result<()>;
+}
+
+#[doc(hidden)]
+pub unsafe trait ComponentVariant: ComponentType {
+    const CASES: &'static [Option<CanonicalAbiInfo>];
+    const INFO: VariantInfo = VariantInfo::new_static(Self::CASES);
+    const PAYLOAD_OFFSET32: usize = Self::INFO.payload_offset32 as usize;
+}
+
+/// Host types which can be passed to WebAssembly components.
+///
+/// This trait is implemented for all types that can be passed to components
+/// either as parameters of component exports or returns of component imports.
+/// This trait represents the ability to convert from the native host
+/// representation to the canonical ABI.
+///
+/// Built-in types to Rust such as `Option<T>` implement this trait as
+/// appropriate. For a mapping of component model to Rust types see
+/// [`ComponentType`].
+///
+/// For user-defined types, for example `record` types mapped to Rust `struct`s,
+/// this crate additionally has
+/// [`#[derive(Lower)]`](macro@crate::component::Lower).
+///
+/// Note that like [`ComponentType`] the definition of this trait is intended to
+/// be an internal implementation detail of Wasmtime at this time. It's
+/// recommended to use the `#[derive(Lower)]` implementation instead.
+pub unsafe trait Lower: ComponentType {
+    /// Performs the "lower" function in the canonical ABI.
+    ///
+    /// This method will lower the current value into a component. The `lower`
+    /// function performs a "flat" lowering into the `dst` specified which is
+    /// allowed to be uninitialized entering this method but is guaranteed to be
+    /// fully initialized if the method returns `Ok(())`.
+    ///
+    /// The `cx` context provided is the context within which this lowering is
+    /// happening. This contains information such as canonical options specified
+    /// (e.g. string encodings, memories, etc), the store itself, along with
+    /// type information.
+    ///
+    /// The `ty` parameter is the destination type that is being lowered into.
+    /// For example this is the component's "view" of the type that is being
+    /// lowered. This is guaranteed to have passed a `typecheck` earlier.
+    ///
+    /// This will only be called if `typecheck` passes for `Op::Lower`.
+    #[doc(hidden)]
+    fn lower<T>(
+        &self,
+        cx: &mut LowerContext<'_, T>,
+        ty: InterfaceType,
+        dst: &mut MaybeUninit<Self::Lower>,
+    ) -> Result<()>;
+
+    /// Performs the "store" operation in the canonical ABI.
+    ///
+    /// This function will store `self` into the linear memory described by
+    /// `cx` at the `offset` provided.
+    ///
+    /// It is expected that `offset` is a valid offset in memory for
+    /// `Self::SIZE32` bytes. At this time that's not an unsafe contract as it's
+    /// always re-checked on all stores, but this is something that will need to
+    /// be improved in the future to remove extra bounds checks. For now this
+    /// function will panic if there's a bug and `offset` isn't valid within
+    /// memory.
+    ///
+    /// The `ty` type information passed here is the same as the type
+    /// information passed to `lower` above, and is the component's own view of
+    /// what the resulting type should be.
+    ///
+    /// This will only be called if `typecheck` passes for `Op::Lower`.
+    #[doc(hidden)]
+    fn store<T>(
+        &self,
+        cx: &mut LowerContext<'_, T>,
+        ty: InterfaceType,
+        offset: usize,
+    ) -> Result<()>;
+
+    /// Provided method to lower a list of `Self` into memory.
+    ///
+    /// Requires that `offset` has already been checked for alignment and
+    /// validity in terms of being in-bounds, otherwise this may panic.
+    ///
+    /// This is primarily here to get overridden for implementations of integers
+    /// which can avoid some extra fluff and use a pattern that's more easily
+    /// optimizable by LLVM.
+    #[doc(hidden)]
+    fn store_list<T>(
+        cx: &mut LowerContext<'_, T>,
+        ty: InterfaceType,
+        mut offset: usize,
+        items: &[Self],
+    ) -> Result<()>
+    where
+        Self: Sized,
+    {
+        for item in items {
+            item.store(cx, ty, offset)?;
+            offset += Self::SIZE32;
+        }
+        Ok(())
+    }
+}
+
+/// Host types which can be created from the canonical ABI.
+///
+/// This is the mirror of the [`Lower`] trait where it represents the capability
+/// of acquiring items from WebAssembly and passing them to the host.
+///
+/// Built-in types to Rust such as `Option<T>` implement this trait as
+/// appropriate. For a mapping of component model to Rust types see
+/// [`ComponentType`].
+///
+/// For user-defined types, for example `record` types mapped to Rust `struct`s,
+/// this crate additionally has
+/// [`#[derive(Lift)]`](macro@crate::component::Lift).
+///
+/// Note that like [`ComponentType`] the definition of this trait is intended to
+/// be an internal implementation detail of Wasmtime at this time. It's
+/// recommended to use the `#[derive(Lift)]` implementation instead.
+pub unsafe trait Lift: Sized + ComponentType {
+    /// Performs the "lift" operation in the canonical ABI.
+    ///
+    /// This function performs a "flat" lift operation from the `src` specified
+    /// which is a sequence of core wasm values. The lifting operation will
+    /// validate core wasm values and produce a `Self` on success.
+    ///
+    /// The `cx` provided contains contextual information such as the store
+    /// that's being loaded from, canonical options, and type information.
+    ///
+    /// The `ty` parameter is the origin component's specification for what the
+    /// type that is being lifted is. For example this is the record type or the
+    /// resource type that is being lifted.
+    ///
+    /// Note that this has a default implementation but if `typecheck` passes
+    /// for `Op::Lift` this needs to be overridden.
+    #[doc(hidden)]
+    fn lift(cx: &mut LiftContext<'_>, ty: InterfaceType, src: &Self::Lower) -> Result<Self>;
+
+    /// Performs the "load" operation in the canonical ABI.
+    ///
+    /// This will read the `bytes` provided, which are a sub-slice into the
+    /// linear memory described by `cx`. The `bytes` array provided is
+    /// guaranteed to be `Self::SIZE32` bytes large. All of memory is then also
+    /// available through `cx` for bounds-checks and such as necessary for
+    /// strings/lists.
+    ///
+    /// The `ty` argument is the type that's being loaded, as described by the
+    /// original component.
+    ///
+    /// Note that this has a default implementation but if `typecheck` passes
+    /// for `Op::Lift` this needs to be overridden.
+    #[doc(hidden)]
+    fn load(cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Self>;
+
+    /// Converts `list` into a `Vec<T>`, used in `Lift for Vec<T>`.
+    ///
+    /// This is primarily here to get overridden for implementations of integers
+    /// which can avoid some extra fluff and use a pattern that's more easily
+    /// optimizable by LLVM.
+    #[doc(hidden)]
+    fn load_list(cx: &mut LiftContext<'_>, list: &WasmList<Self>) -> Result<Vec<Self>>
+    where
+        Self: Sized,
+    {
+        (0..list.len)
+            .map(|index| list.get_from_store(cx, index).unwrap())
+            .collect()
+    }
+}
+
+// Macro to help generate "forwarding implementations" of `ComponentType` to
+// another type, used for wrappers in Rust like `&T`, `Box<T>`, etc. Note that
+// these wrappers only implement lowering because lifting native Rust types
+// cannot be done.
+macro_rules! forward_type_impls {
+    ($(($($generics:tt)*) $a:ty => $b:ty,)*) => ($(
+        unsafe impl <$($generics)*> ComponentType for $a {
+            type Lower = <$b as ComponentType>::Lower;
+
+            const ABI: CanonicalAbiInfo = <$b as ComponentType>::ABI;
+
+            #[inline]
+            fn typecheck(ty: &InterfaceType, types: &InstanceType<'_>) -> Result<()> {
+                <$b as ComponentType>::typecheck(ty, types)
+            }
+        }
+    )*)
+}
+
+forward_type_impls! {
+    (T: ComponentType + ?Sized) &'_ T => T,
+    (T: ComponentType + ?Sized) Box<T> => T,
+    (T: ComponentType + ?Sized) alloc::rc::Rc<T> => T,
+    (T: ComponentType + ?Sized) alloc::sync::Arc<T> => T,
+    () String => str,
+    (T: ComponentType) Vec<T> => [T],
+}
+
+macro_rules! forward_lowers {
+    ($(($($generics:tt)*) $a:ty => $b:ty,)*) => ($(
+        unsafe impl <$($generics)*> Lower for $a {
+            fn lower<U>(
+                &self,
+                cx: &mut LowerContext<'_, U>,
+                ty: InterfaceType,
+                dst: &mut MaybeUninit<Self::Lower>,
+            ) -> Result<()> {
+                <$b as Lower>::lower(self, cx, ty, dst)
+            }
+
+            fn store<U>(
+                &self,
+                cx: &mut LowerContext<'_, U>,
+                ty: InterfaceType,
+                offset: usize,
+            ) -> Result<()> {
+                <$b as Lower>::store(self, cx, ty, offset)
+            }
+        }
+    )*)
+}
+
+forward_lowers! {
+    (T: Lower + ?Sized) &'_ T => T,
+    (T: Lower + ?Sized) Box<T> => T,
+    (T: Lower + ?Sized) alloc::rc::Rc<T> => T,
+    (T: Lower + ?Sized) alloc::sync::Arc<T> => T,
+    () String => str,
+    (T: Lower) Vec<T> => [T],
+}
+
+macro_rules! forward_string_lifts {
+    ($($a:ty,)*) => ($(
+        unsafe impl Lift for $a {
+            #[inline]
+            fn lift(cx: &mut LiftContext<'_>, ty: InterfaceType, src: &Self::Lower) -> Result<Self> {
+                Ok(<WasmStr as Lift>::lift(cx, ty, src)?.to_str_from_memory(cx.memory())?.into())
+            }
+
+            #[inline]
+            fn load(cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Self> {
+                Ok(<WasmStr as Lift>::load(cx, ty, bytes)?.to_str_from_memory(cx.memory())?.into())
+            }
+        }
+    )*)
+}
+
+forward_string_lifts! {
+    Box<str>,
+    alloc::rc::Rc<str>,
+    alloc::sync::Arc<str>,
+    String,
+}
+
+macro_rules! forward_list_lifts {
+    ($($a:ty,)*) => ($(
+        unsafe impl <T: Lift> Lift for $a {
+            fn lift(cx: &mut LiftContext<'_>, ty: InterfaceType, src: &Self::Lower) -> Result<Self> {
+                let list = <WasmList::<T> as Lift>::lift(cx, ty, src)?;
+                Ok(T::load_list(cx, &list)?.into())
+            }
+
+            fn load(cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Self> {
+                let list = <WasmList::<T> as Lift>::load(cx, ty, bytes)?;
+                Ok(T::load_list(cx, &list)?.into())
+            }
+        }
+    )*)
+}
+
+forward_list_lifts! {
+    Box<[T]>,
+    alloc::rc::Rc<[T]>,
+    alloc::sync::Arc<[T]>,
+    Vec<T>,
+}
+
+// Macro to help generate `ComponentType` implementations for primitive types
+// such as integers, char, bool, etc.
+macro_rules! integers {
+    ($($primitive:ident = $ty:ident in $field:ident/$get:ident with abi:$abi:ident,)*) => ($(
+        unsafe impl ComponentType for $primitive {
+            type Lower = ValRaw;
+
+            const ABI: CanonicalAbiInfo = CanonicalAbiInfo::$abi;
+
+            fn typecheck(ty: &InterfaceType, _types: &InstanceType<'_>) -> Result<()> {
+                match ty {
+                    InterfaceType::$ty => Ok(()),
+                    other => bail!("expected `{}` found `{}`", desc(&InterfaceType::$ty), desc(other))
+                }
+            }
+        }
+
+        unsafe impl Lower for $primitive {
+            #[inline]
+            #[allow(trivial_numeric_casts)]
+            fn lower<T>(
+                &self,
+                _cx: &mut LowerContext<'_, T>,
+                ty: InterfaceType,
+                dst: &mut MaybeUninit<Self::Lower>,
+            ) -> Result<()> {
+                debug_assert!(matches!(ty, InterfaceType::$ty));
+                dst.write(ValRaw::$field(*self as $field));
+                Ok(())
+            }
+
+            #[inline]
+            fn store<T>(
+                &self,
+                cx: &mut LowerContext<'_, T>,
+                ty: InterfaceType,
+                offset: usize,
+            ) -> Result<()> {
+                debug_assert!(matches!(ty, InterfaceType::$ty));
+                debug_assert!(offset % Self::SIZE32 == 0);
+                *cx.get(offset) = self.to_le_bytes();
+                Ok(())
+            }
+
+            fn store_list<T>(
+                cx: &mut LowerContext<'_, T>,
+                ty: InterfaceType,
+                offset: usize,
+                items: &[Self],
+            ) -> Result<()> {
+                debug_assert!(matches!(ty, InterfaceType::$ty));
+
+                // Double-check that the CM alignment is at least the host's
+                // alignment for this type which should be true for all
+                // platforms.
+                assert!((Self::ALIGN32 as usize) >= mem::align_of::<Self>());
+
+                // Slice `cx`'s memory to the window that we'll be modifying.
+                // This should all have already been verified in terms of
+                // alignment and sizing meaning that these assertions here are
+                // not truly necessary but are instead double-checks.
+                //
+                // Note that we're casting a `[u8]` slice to `[Self]` with
+                // `align_to_mut` which is not safe in general but is safe in
+                // our specific case as all `u8` patterns are valid `Self`
+                // patterns since `Self` is an integral type.
+                let dst = &mut cx.as_slice_mut()[offset..][..items.len() * Self::SIZE32];
+                let (before, middle, end) = unsafe { dst.align_to_mut::<Self>() };
+                assert!(before.is_empty() && end.is_empty());
+                assert_eq!(middle.len(), items.len());
+
+                // And with all that out of the way perform the copying loop.
+                // This is not a `copy_from_slice` because endianness needs to
+                // be handled here, but LLVM should pretty easily transform this
+                // into a memcpy on little-endian platforms.
+                for (dst, src) in middle.iter_mut().zip(items) {
+                    *dst = src.to_le();
+                }
+                Ok(())
+            }
+        }
+
+        unsafe impl Lift for $primitive {
+            #[inline]
+            #[allow(trivial_numeric_casts)]
+            fn lift(_cx: &mut LiftContext<'_>, ty: InterfaceType, src: &Self::Lower) -> Result<Self> {
+                debug_assert!(matches!(ty, InterfaceType::$ty));
+                Ok(src.$get() as $primitive)
+            }
+
+            #[inline]
+            fn load(_cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Self> {
+                debug_assert!(matches!(ty, InterfaceType::$ty));
+                debug_assert!((bytes.as_ptr() as usize) % Self::SIZE32 == 0);
+                Ok($primitive::from_le_bytes(bytes.try_into().unwrap()))
+            }
+
+            fn load_list(cx: &mut LiftContext<'_>, list: &WasmList<Self>) -> Result<Vec<Self>> {
+                Ok(
+                    list._as_le_slice(cx.memory())
+                        .iter()
+                        .map(|i| Self::from_le(*i))
+                        .collect(),
+                )
+            }
+        }
+    )*)
+}
+
+integers! {
+    i8 = S8 in i32/get_i32 with abi:SCALAR1,
+    u8 = U8 in u32/get_u32 with abi:SCALAR1,
+    i16 = S16 in i32/get_i32 with abi:SCALAR2,
+    u16 = U16 in u32/get_u32 with abi:SCALAR2,
+    i32 = S32 in i32/get_i32 with abi:SCALAR4,
+    u32 = U32 in u32/get_u32 with abi:SCALAR4,
+    i64 = S64 in i64/get_i64 with abi:SCALAR8,
+    u64 = U64 in u64/get_u64 with abi:SCALAR8,
+}
+
+macro_rules! floats {
+    ($($float:ident/$get_float:ident = $ty:ident with abi:$abi:ident)*) => ($(const _: () = {
+        /// All floats in-and-out of the canonical abi always have their nan
+        /// payloads canonicalized. conveniently the `NAN` constant in rust has
+        /// the same representation as canonical nan, so we can use that for the
+        /// nan value.
+        #[inline]
+        fn canonicalize(float: $float) -> $float {
+            if float.is_nan() {
+                $float::NAN
+            } else {
+                float
+            }
+        }
+
+        unsafe impl ComponentType for $float {
+            type Lower = ValRaw;
+
+            const ABI: CanonicalAbiInfo = CanonicalAbiInfo::$abi;
+
+            fn typecheck(ty: &InterfaceType, _types: &InstanceType<'_>) -> Result<()> {
+                match ty {
+                    InterfaceType::$ty => Ok(()),
+                    other => bail!("expected `{}` found `{}`", desc(&InterfaceType::$ty), desc(other))
+                }
+            }
+        }
+
+        unsafe impl Lower for $float {
+            #[inline]
+            fn lower<T>(
+                &self,
+                _cx: &mut LowerContext<'_, T>,
+                ty: InterfaceType,
+                dst: &mut MaybeUninit<Self::Lower>,
+            ) -> Result<()> {
+                debug_assert!(matches!(ty, InterfaceType::$ty));
+                dst.write(ValRaw::$float(canonicalize(*self).to_bits()));
+                Ok(())
+            }
+
+            #[inline]
+            fn store<T>(
+                &self,
+                cx: &mut LowerContext<'_, T>,
+                ty: InterfaceType,
+                offset: usize,
+            ) -> Result<()> {
+                debug_assert!(matches!(ty, InterfaceType::$ty));
+                debug_assert!(offset % Self::SIZE32 == 0);
+                let ptr = cx.get(offset);
+                *ptr = canonicalize(*self).to_bits().to_le_bytes();
+                Ok(())
+            }
+        }
+
+        unsafe impl Lift for $float {
+            #[inline]
+            fn lift(_cx: &mut LiftContext<'_>, ty: InterfaceType, src: &Self::Lower) -> Result<Self> {
+                debug_assert!(matches!(ty, InterfaceType::$ty));
+                Ok(canonicalize($float::from_bits(src.$get_float())))
+            }
+
+            #[inline]
+            fn load(_cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Self> {
+                debug_assert!(matches!(ty, InterfaceType::$ty));
+                debug_assert!((bytes.as_ptr() as usize) % Self::SIZE32 == 0);
+                Ok(canonicalize($float::from_le_bytes(bytes.try_into().unwrap())))
+            }
+        }
+    };)*)
+}
+
+floats! {
+    f32/get_f32 = Float32 with abi:SCALAR4
+    f64/get_f64 = Float64 with abi:SCALAR8
+}
+
+unsafe impl ComponentType for bool {
+    type Lower = ValRaw;
+
+    const ABI: CanonicalAbiInfo = CanonicalAbiInfo::SCALAR1;
+
+    fn typecheck(ty: &InterfaceType, _types: &InstanceType<'_>) -> Result<()> {
+        match ty {
+            InterfaceType::Bool => Ok(()),
+            other => bail!("expected `bool` found `{}`", desc(other)),
+        }
+    }
+}
+
+unsafe impl Lower for bool {
+    fn lower<T>(
+        &self,
+        _cx: &mut LowerContext<'_, T>,
+        ty: InterfaceType,
+        dst: &mut MaybeUninit<Self::Lower>,
+    ) -> Result<()> {
+        debug_assert!(matches!(ty, InterfaceType::Bool));
+        dst.write(ValRaw::i32(*self as i32));
+        Ok(())
+    }
+
+    fn store<T>(
+        &self,
+        cx: &mut LowerContext<'_, T>,
+        ty: InterfaceType,
+        offset: usize,
+    ) -> Result<()> {
+        debug_assert!(matches!(ty, InterfaceType::Bool));
+        debug_assert!(offset % Self::SIZE32 == 0);
+        cx.get::<1>(offset)[0] = *self as u8;
+        Ok(())
+    }
+}
+
+unsafe impl Lift for bool {
+    #[inline]
+    fn lift(_cx: &mut LiftContext<'_>, ty: InterfaceType, src: &Self::Lower) -> Result<Self> {
+        debug_assert!(matches!(ty, InterfaceType::Bool));
+        match src.get_i32() {
+            0 => Ok(false),
+            _ => Ok(true),
+        }
+    }
+
+    #[inline]
+    fn load(_cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Self> {
+        debug_assert!(matches!(ty, InterfaceType::Bool));
+        match bytes[0] {
+            0 => Ok(false),
+            _ => Ok(true),
+        }
+    }
+}
+
+unsafe impl ComponentType for char {
+    type Lower = ValRaw;
+
+    const ABI: CanonicalAbiInfo = CanonicalAbiInfo::SCALAR4;
+
+    fn typecheck(ty: &InterfaceType, _types: &InstanceType<'_>) -> Result<()> {
+        match ty {
+            InterfaceType::Char => Ok(()),
+            other => bail!("expected `char` found `{}`", desc(other)),
+        }
+    }
+}
+
+unsafe impl Lower for char {
+    #[inline]
+    fn lower<T>(
+        &self,
+        _cx: &mut LowerContext<'_, T>,
+        ty: InterfaceType,
+        dst: &mut MaybeUninit<Self::Lower>,
+    ) -> Result<()> {
+        debug_assert!(matches!(ty, InterfaceType::Char));
+        dst.write(ValRaw::u32(u32::from(*self)));
+        Ok(())
+    }
+
+    #[inline]
+    fn store<T>(
+        &self,
+        cx: &mut LowerContext<'_, T>,
+        ty: InterfaceType,
+        offset: usize,
+    ) -> Result<()> {
+        debug_assert!(matches!(ty, InterfaceType::Char));
+        debug_assert!(offset % Self::SIZE32 == 0);
+        *cx.get::<4>(offset) = u32::from(*self).to_le_bytes();
+        Ok(())
+    }
+}
+
+unsafe impl Lift for char {
+    #[inline]
+    fn lift(_cx: &mut LiftContext<'_>, ty: InterfaceType, src: &Self::Lower) -> Result<Self> {
+        debug_assert!(matches!(ty, InterfaceType::Char));
+        Ok(char::try_from(src.get_u32()).err2anyhow()?)
+    }
+
+    #[inline]
+    fn load(_cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Self> {
+        debug_assert!(matches!(ty, InterfaceType::Char));
+        debug_assert!((bytes.as_ptr() as usize) % Self::SIZE32 == 0);
+        let bits = u32::from_le_bytes(bytes.try_into().unwrap());
+        Ok(char::try_from(bits).err2anyhow()?)
+    }
+}
+
+// TODO: these probably need different constants for memory64
+const UTF16_TAG: usize = 1 << 31;
+const MAX_STRING_BYTE_LENGTH: usize = (1 << 31) - 1;
+
+// Note that this is similar to `ComponentType for WasmStr` except it can only
+// be used for lowering, not lifting.
+unsafe impl ComponentType for str {
+    type Lower = [ValRaw; 2];
+
+    const ABI: CanonicalAbiInfo = CanonicalAbiInfo::POINTER_PAIR;
+
+    fn typecheck(ty: &InterfaceType, _types: &InstanceType<'_>) -> Result<()> {
+        match ty {
+            InterfaceType::String => Ok(()),
+            other => bail!("expected `string` found `{}`", desc(other)),
+        }
+    }
+}
+
+unsafe impl Lower for str {
+    fn lower<T>(
+        &self,
+        cx: &mut LowerContext<'_, T>,
+        ty: InterfaceType,
+        dst: &mut MaybeUninit<[ValRaw; 2]>,
+    ) -> Result<()> {
+        debug_assert!(matches!(ty, InterfaceType::String));
+        let (ptr, len) = lower_string(cx, self)?;
+        // See "WRITEPTR64" above for why this is always storing a 64-bit
+        // integer.
+        map_maybe_uninit!(dst[0]).write(ValRaw::i64(ptr as i64));
+        map_maybe_uninit!(dst[1]).write(ValRaw::i64(len as i64));
+        Ok(())
+    }
+
+    fn store<T>(
+        &self,
+        cx: &mut LowerContext<'_, T>,
+        ty: InterfaceType,
+        offset: usize,
+    ) -> Result<()> {
+        debug_assert!(matches!(ty, InterfaceType::String));
+        debug_assert!(offset % (Self::ALIGN32 as usize) == 0);
+        let (ptr, len) = lower_string(cx, self)?;
+        // FIXME: needs memory64 handling
+        *cx.get(offset + 0) = (ptr as i32).to_le_bytes();
+        *cx.get(offset + 4) = (len as i32).to_le_bytes();
+        Ok(())
+    }
+}
+
+fn lower_string<T>(cx: &mut LowerContext<'_, T>, string: &str) -> Result<(usize, usize)> {
+    // Note that in general the wasm module can't assume anything about what the
+    // host strings are encoded as. Additionally hosts are allowed to have
+    // differently-encoded strings at runtime. Finally when copying a string
+    // into wasm it's somewhat strict in the sense that the various patterns of
+    // allocation and such are already dictated for us.
+    //
+    // In general what this means is that when copying a string from the host
+    // into the destination we need to follow one of the cases of copying into
+    // WebAssembly. It doesn't particularly matter which case as long as it ends
+    // up in the right encoding. For example a destination encoding of
+    // latin1+utf16 has a number of ways to get copied into and we do something
+    // here that isn't the default "utf8 to latin1+utf16" since we have access
+    // to simd-accelerated helpers in the `encoding_rs` crate. This is ok though
+    // because we can fake that the host string was already stored in latin1
+    // format and follow that copy pattern instead.
+    match cx.options.string_encoding() {
+        // This corresponds to `store_string_copy` in the canonical ABI where
+        // the host's representation is utf-8 and the wasm module wants utf-8 so
+        // a copy is all that's needed (and the `realloc` can be precise for the
+        // initial memory allocation).
+        StringEncoding::Utf8 => {
+            if string.len() > MAX_STRING_BYTE_LENGTH {
+                bail!(
+                    "string length of {} too large to copy into wasm",
+                    string.len()
+                );
+            }
+            let ptr = cx.realloc(0, 0, 1, string.len())?;
+            cx.as_slice_mut()[ptr..][..string.len()].copy_from_slice(string.as_bytes());
+            Ok((ptr, string.len()))
+        }
+
+        // This corresponds to `store_utf8_to_utf16` in the canonical ABI. Here
+        // an over-large allocation is performed and then shrunk afterwards if
+        // necessary.
+        StringEncoding::Utf16 => {
+            let size = string.len() * 2;
+            if size > MAX_STRING_BYTE_LENGTH {
+                bail!(
+                    "string length of {} too large to copy into wasm",
+                    string.len()
+                );
+            }
+            let mut ptr = cx.realloc(0, 0, 2, size)?;
+            let mut copied = 0;
+            let bytes = &mut cx.as_slice_mut()[ptr..][..size];
+            for (u, bytes) in string.encode_utf16().zip(bytes.chunks_mut(2)) {
+                let u_bytes = u.to_le_bytes();
+                bytes[0] = u_bytes[0];
+                bytes[1] = u_bytes[1];
+                copied += 1;
+            }
+            if (copied * 2) < size {
+                ptr = cx.realloc(ptr, size, 2, copied * 2)?;
+            }
+            Ok((ptr, copied))
+        }
+
+        StringEncoding::CompactUtf16 => {
+            // This corresponds to `store_string_to_latin1_or_utf16`
+            let bytes = string.as_bytes();
+            let mut iter = string.char_indices();
+            let mut ptr = cx.realloc(0, 0, 2, bytes.len())?;
+            let mut dst = &mut cx.as_slice_mut()[ptr..][..bytes.len()];
+            let mut result = 0;
+            while let Some((i, ch)) = iter.next() {
+                // Test if this `char` fits into the latin1 encoding.
+                if let Ok(byte) = u8::try_from(u32::from(ch)) {
+                    dst[result] = byte;
+                    result += 1;
+                    continue;
+                }
+
+                // .. if utf16 is forced to be used then the allocation is
+                // bumped up to the maximum size.
+                let worst_case = bytes
+                    .len()
+                    .checked_mul(2)
+                    .ok_or_else(|| anyhow!("byte length overflow"))?;
+                if worst_case > MAX_STRING_BYTE_LENGTH {
+                    bail!("byte length too large");
+                }
+                ptr = cx.realloc(ptr, bytes.len(), 2, worst_case)?;
+                dst = &mut cx.as_slice_mut()[ptr..][..worst_case];
+
+                // Previously encoded latin1 bytes are inflated to their 16-bit
+                // size for utf16
+                for i in (0..result).rev() {
+                    dst[2 * i] = dst[i];
+                    dst[2 * i + 1] = 0;
+                }
+
+                // and then the remainder of the string is encoded.
+                for (u, bytes) in string[i..]
+                    .encode_utf16()
+                    .zip(dst[2 * result..].chunks_mut(2))
+                {
+                    let u_bytes = u.to_le_bytes();
+                    bytes[0] = u_bytes[0];
+                    bytes[1] = u_bytes[1];
+                    result += 1;
+                }
+                if worst_case > 2 * result {
+                    ptr = cx.realloc(ptr, worst_case, 2, 2 * result)?;
+                }
+                return Ok((ptr, result | UTF16_TAG));
+            }
+            if result < bytes.len() {
+                ptr = cx.realloc(ptr, bytes.len(), 2, result)?;
+            }
+            Ok((ptr, result))
+        }
+    }
+}
+
+/// Representation of a string located in linear memory in a WebAssembly
+/// instance.
+///
+/// This type can be used in place of `String` and `str` for string-taking APIs
+/// in some situations. The purpose of this type is to represent a range of
+/// validated bytes within a component but does not actually copy the bytes. The
+/// primary method, [`WasmStr::to_str`], attempts to return a reference to the
+/// string directly located in the component's memory, avoiding a copy into the
+/// host if possible.
+///
+/// The downside of this type, however, is that accessing a string requires a
+/// [`Store`](crate::Store) pointer (via [`StoreContext`]). Bindings generated
+/// by [`bindgen!`](crate::component::bindgen), for example, do not have access
+/// to [`StoreContext`] and thus can't use this type.
+///
+/// This is intended for more advanced use cases such as defining functions
+/// directly in a [`Linker`](crate::component::Linker). It's expected that in
+/// the future [`bindgen!`](crate::component::bindgen) will also have a way to
+/// use this type.
+///
+/// This type is used with [`TypedFunc`], for example, when WebAssembly returns
+/// a string. This type cannot be used to give a string to WebAssembly, instead
+/// `&str` should be used for that (since it's coming from the host).
+///
+/// Note that this type represents an in-bounds string in linear memory, but it
+/// does not represent a valid string (e.g. valid utf-8). Validation happens
+/// when [`WasmStr::to_str`] is called.
+///
+/// Also note that this type does not implement [`Lower`], it only implements
+/// [`Lift`].
+pub struct WasmStr {
+    ptr: usize,
+    len: usize,
+    options: Options,
+}
+
+impl WasmStr {
+    fn new(ptr: usize, len: usize, cx: &mut LiftContext<'_>) -> Result<WasmStr> {
+        let byte_len = match cx.options.string_encoding() {
+            StringEncoding::Utf8 => Some(len),
+            StringEncoding::Utf16 => len.checked_mul(2),
+            StringEncoding::CompactUtf16 => {
+                if len & UTF16_TAG == 0 {
+                    Some(len)
+                } else {
+                    (len ^ UTF16_TAG).checked_mul(2)
+                }
+            }
+        };
+        match byte_len.and_then(|len| ptr.checked_add(len)) {
+            Some(n) if n <= cx.memory().len() => {}
+            _ => bail!("string pointer/length out of bounds of memory"),
+        }
+        Ok(WasmStr {
+            ptr,
+            len,
+            options: *cx.options,
+        })
+    }
+
+    /// Returns the underlying string that this cursor points to.
+    ///
+    /// Note that this will internally decode the string from the wasm's
+    /// encoding to utf-8 and additionally perform validation.
+    ///
+    /// The `store` provided must be the store where this string lives to
+    /// access the correct memory.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the string wasn't encoded correctly (e.g. invalid
+    /// utf-8).
+    ///
+    /// # Panics
+    ///
+    /// Panics if this string is not owned by `store`.
+    //
+    // TODO: should add accessors for specifically utf-8 and utf-16 that perhaps
+    // in an opt-in basis don't do validation. Additionally there should be some
+    // method that returns `[u16]` after validating to avoid the utf16-to-utf8
+    // transcode.
+    pub fn to_str<'a, T: 'a>(&self, store: impl Into<StoreContext<'a, T>>) -> Result<Cow<'a, str>> {
+        let store = store.into().0;
+        let memory = self.options.memory(store);
+        self.to_str_from_memory(memory)
+    }
+
+    fn to_str_from_memory<'a>(&self, memory: &'a [u8]) -> Result<Cow<'a, str>> {
+        match self.options.string_encoding() {
+            StringEncoding::Utf8 => self.decode_utf8(memory),
+            StringEncoding::Utf16 => self.decode_utf16(memory, self.len),
+            StringEncoding::CompactUtf16 => {
+                if self.len & UTF16_TAG == 0 {
+                    self.decode_latin1(memory)
+                } else {
+                    self.decode_utf16(memory, self.len ^ UTF16_TAG)
+                }
+            }
+        }
+    }
+
+    fn decode_utf8<'a>(&self, memory: &'a [u8]) -> Result<Cow<'a, str>> {
+        // Note that bounds-checking already happen in construction of `WasmStr`
+        // so this is never expected to panic. This could theoretically be
+        // unchecked indexing if we're feeling wild enough.
+        Ok(str::from_utf8(&memory[self.ptr..][..self.len])
+            .err2anyhow()?
+            .into())
+    }
+
+    fn decode_utf16<'a>(&self, memory: &'a [u8], len: usize) -> Result<Cow<'a, str>> {
+        // See notes in `decode_utf8` for why this is panicking indexing.
+        let memory = &memory[self.ptr..][..len * 2];
+        Ok(core::char::decode_utf16(
+            memory
+                .chunks(2)
+                .map(|chunk| u16::from_le_bytes(chunk.try_into().unwrap())),
+        )
+        .collect::<Result<String, _>>()
+        .err2anyhow()?
+        .into())
+    }
+
+    fn decode_latin1<'a>(&self, memory: &'a [u8]) -> Result<Cow<'a, str>> {
+        // See notes in `decode_utf8` for why this is panicking indexing.
+        Ok(encoding_rs::mem::decode_latin1(
+            &memory[self.ptr..][..self.len],
+        ))
+    }
+}
+
+// Note that this is similar to `ComponentType for str` except it can only be
+// used for lifting, not lowering.
+unsafe impl ComponentType for WasmStr {
+    type Lower = <str as ComponentType>::Lower;
+
+    const ABI: CanonicalAbiInfo = CanonicalAbiInfo::POINTER_PAIR;
+
+    fn typecheck(ty: &InterfaceType, _types: &InstanceType<'_>) -> Result<()> {
+        match ty {
+            InterfaceType::String => Ok(()),
+            other => bail!("expected `string` found `{}`", desc(other)),
+        }
+    }
+}
+
+unsafe impl Lift for WasmStr {
+    #[inline]
+    fn lift(cx: &mut LiftContext<'_>, ty: InterfaceType, src: &Self::Lower) -> Result<Self> {
+        debug_assert!(matches!(ty, InterfaceType::String));
+        // FIXME: needs memory64 treatment
+        let ptr = src[0].get_u32();
+        let len = src[1].get_u32();
+        let (ptr, len) = (
+            usize::try_from(ptr).err2anyhow()?,
+            usize::try_from(len).err2anyhow()?,
+        );
+        WasmStr::new(ptr, len, cx)
+    }
+
+    #[inline]
+    fn load(cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Self> {
+        debug_assert!(matches!(ty, InterfaceType::String));
+        debug_assert!((bytes.as_ptr() as usize) % (Self::ALIGN32 as usize) == 0);
+        // FIXME: needs memory64 treatment
+        let ptr = u32::from_le_bytes(bytes[..4].try_into().unwrap());
+        let len = u32::from_le_bytes(bytes[4..].try_into().unwrap());
+        let (ptr, len) = (
+            usize::try_from(ptr).err2anyhow()?,
+            usize::try_from(len).err2anyhow()?,
+        );
+        WasmStr::new(ptr, len, cx)
+    }
+}
+
+unsafe impl<T> ComponentType for [T]
+where
+    T: ComponentType,
+{
+    type Lower = [ValRaw; 2];
+
+    const ABI: CanonicalAbiInfo = CanonicalAbiInfo::POINTER_PAIR;
+
+    fn typecheck(ty: &InterfaceType, types: &InstanceType<'_>) -> Result<()> {
+        match ty {
+            InterfaceType::List(t) => T::typecheck(&types.types[*t].element, types),
+            other => bail!("expected `list` found `{}`", desc(other)),
+        }
+    }
+}
+
+unsafe impl<T> Lower for [T]
+where
+    T: Lower,
+{
+    fn lower<U>(
+        &self,
+        cx: &mut LowerContext<'_, U>,
+        ty: InterfaceType,
+        dst: &mut MaybeUninit<[ValRaw; 2]>,
+    ) -> Result<()> {
+        let elem = match ty {
+            InterfaceType::List(i) => cx.types[i].element,
+            _ => bad_type_info(),
+        };
+        let (ptr, len) = lower_list(cx, elem, self)?;
+        // See "WRITEPTR64" above for why this is always storing a 64-bit
+        // integer.
+        map_maybe_uninit!(dst[0]).write(ValRaw::i64(ptr as i64));
+        map_maybe_uninit!(dst[1]).write(ValRaw::i64(len as i64));
+        Ok(())
+    }
+
+    fn store<U>(
+        &self,
+        cx: &mut LowerContext<'_, U>,
+        ty: InterfaceType,
+        offset: usize,
+    ) -> Result<()> {
+        let elem = match ty {
+            InterfaceType::List(i) => cx.types[i].element,
+            _ => bad_type_info(),
+        };
+        debug_assert!(offset % (Self::ALIGN32 as usize) == 0);
+        let (ptr, len) = lower_list(cx, elem, self)?;
+        *cx.get(offset + 0) = (ptr as i32).to_le_bytes();
+        *cx.get(offset + 4) = (len as i32).to_le_bytes();
+        Ok(())
+    }
+}
+
+// FIXME: this is not a memcpy for `T` where `T` is something like `u8`.
+//
+// Some attempts to fix this have proved not fruitful. In isolation an attempt
+// was made where:
+//
+// * `MemoryMut` stored a `*mut [u8]` as its "last view" of memory to avoid
+//   reloading the base pointer constantly. This view is reset on `realloc`.
+// * The bounds-checks in `MemoryMut::get` were removed (replaced with unsafe
+//   indexing)
+//
+// Even then though this didn't correctly vectorized for `Vec<u8>`. It's not
+// entirely clear why but it appeared that it's related to reloading the base
+// pointer to memory (I guess from `MemoryMut` itself?). Overall I'm not really
+// clear on what's happening there, but this is surely going to be a performance
+// bottleneck in the future.
+fn lower_list<T, U>(
+    cx: &mut LowerContext<'_, U>,
+    ty: InterfaceType,
+    list: &[T],
+) -> Result<(usize, usize)>
+where
+    T: Lower,
+{
+    let elem_size = T::SIZE32;
+    let size = list
+        .len()
+        .checked_mul(elem_size)
+        .ok_or_else(|| anyhow!("size overflow copying a list"))?;
+    let ptr = cx.realloc(0, 0, T::ALIGN32, size)?;
+    T::store_list(cx, ty, ptr, list)?;
+    Ok((ptr, list.len()))
+}
+
+/// Representation of a list of values that are owned by a WebAssembly instance.
+///
+/// For some more commentary about the rationale for this type see the
+/// documentation of [`WasmStr`]. In summary this type can avoid a copy when
+/// passing data to the host in some situations but is additionally more
+/// cumbersome to use by requiring a [`Store`](crate::Store) to be provided.
+///
+/// This type is used whenever a `(list T)` is returned from a [`TypedFunc`],
+/// for example. This type represents a list of values that are stored in linear
+/// memory which are waiting to be read.
+///
+/// Note that this type represents only a valid range of bytes for the list
+/// itself, it does not represent validity of the elements themselves and that's
+/// performed when they're iterated.
+///
+/// Note that this type does not implement the [`Lower`] trait, only [`Lift`].
+pub struct WasmList<T> {
+    ptr: usize,
+    len: usize,
+    options: Options,
+    elem: InterfaceType,
+    // NB: it would probably be more efficient to store a non-atomic index-style
+    // reference to something inside a `StoreOpaque`, but that's not easily
+    // available at this time, so it's left as a future exercise.
+    types: Arc<ComponentTypes>,
+    instance: SendSyncPtr<ComponentInstance>,
+    _marker: marker::PhantomData<T>,
+}
+
+impl<T: Lift> WasmList<T> {
+    fn new(
+        ptr: usize,
+        len: usize,
+        cx: &mut LiftContext<'_>,
+        elem: InterfaceType,
+    ) -> Result<WasmList<T>> {
+        match len
+            .checked_mul(T::SIZE32)
+            .and_then(|len| ptr.checked_add(len))
+        {
+            Some(n) if n <= cx.memory().len() => {}
+            _ => bail!("list pointer/length out of bounds of memory"),
+        }
+        if ptr % usize::try_from(T::ALIGN32).err2anyhow()? != 0 {
+            bail!("list pointer is not aligned")
+        }
+        Ok(WasmList {
+            ptr,
+            len,
+            options: *cx.options,
+            elem,
+            types: cx.types.clone(),
+            instance: SendSyncPtr::new(NonNull::new(cx.instance_ptr()).unwrap()),
+            _marker: marker::PhantomData,
+        })
+    }
+
+    /// Returns the item length of this vector
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.len
+    }
+
+    /// Gets the `n`th element of this list.
+    ///
+    /// Returns `None` if `index` is out of bounds. Returns `Some(Err(..))` if
+    /// the value couldn't be decoded (it was invalid). Returns `Some(Ok(..))`
+    /// if the value is valid.
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if the string did not originally come from the
+    /// `store` specified.
+    //
+    // TODO: given that interface values are intended to be consumed in one go
+    // should we even expose a random access iteration API? In theory all
+    // consumers should be validating through the iterator.
+    pub fn get(&self, mut store: impl AsContextMut, index: usize) -> Option<Result<T>> {
+        let store = store.as_context_mut().0;
+        self.options.store_id().assert_belongs_to(store.id());
+        // This should be safe because the unsafety lies in the `self.instance`
+        // pointer passed in has previously been validated by the lifting
+        // context this was originally created within and with the check above
+        // this is guaranteed to be the same store. This means that this should
+        // be carrying over the original assertion from the original creation of
+        // the lifting context that created this type.
+        let mut cx =
+            unsafe { LiftContext::new(store, &self.options, &self.types, self.instance.as_ptr()) };
+        self.get_from_store(&mut cx, index)
+    }
+
+    fn get_from_store(&self, cx: &mut LiftContext<'_>, index: usize) -> Option<Result<T>> {
+        if index >= self.len {
+            return None;
+        }
+        // Note that this is using panicking indexing and this is expected to
+        // never fail. The bounds-checking here happened during the construction
+        // of the `WasmList` itself which means these should always be in-bounds
+        // (and wasm memory can only grow). This could theoretically be
+        // unchecked indexing if we're confident enough and it's actually a perf
+        // issue one day.
+        let bytes = &cx.memory()[self.ptr + index * T::SIZE32..][..T::SIZE32];
+        Some(T::load(cx, self.elem, bytes))
+    }
+
+    /// Returns an iterator over the elements of this list.
+    ///
+    /// Each item of the list may fail to decode and is represented through the
+    /// `Result` value of the iterator.
+    pub fn iter<'a, U: 'a>(
+        &'a self,
+        store: impl Into<StoreContextMut<'a, U>>,
+    ) -> impl ExactSizeIterator<Item = Result<T>> + 'a {
+        let store = store.into().0;
+        self.options.store_id().assert_belongs_to(store.id());
+        // See comments about unsafety in the `get` method.
+        let mut cx =
+            unsafe { LiftContext::new(store, &self.options, &self.types, self.instance.as_ptr()) };
+        (0..self.len).map(move |i| self.get_from_store(&mut cx, i).unwrap())
+    }
+}
+
+macro_rules! raw_wasm_list_accessors {
+    ($($i:ident)*) => ($(
+        impl WasmList<$i> {
+            /// Get access to the raw underlying memory for this list.
+            ///
+            /// This method will return a direct slice into the original wasm
+            /// module's linear memory where the data for this slice is stored.
+            /// This allows the embedder to have efficient access to the
+            /// underlying memory if needed and avoid copies and such if
+            /// desired.
+            ///
+            /// Note that multi-byte integers are stored in little-endian format
+            /// so portable processing of this slice must be aware of the host's
+            /// byte-endianness. The `from_le` constructors in the Rust standard
+            /// library should be suitable for converting from little-endian.
+            ///
+            /// # Panics
+            ///
+            /// Panics if the `store` provided is not the one from which this
+            /// slice originated.
+            pub fn as_le_slice<'a, T: 'a>(&self, store: impl Into<StoreContext<'a, T>>) -> &'a [$i] {
+                let memory = self.options.memory(store.into().0);
+                self._as_le_slice(memory)
+            }
+
+            fn _as_le_slice<'a>(&self, all_of_memory: &'a [u8]) -> &'a [$i] {
+                // See comments in `WasmList::get` for the panicking indexing
+                let byte_size = self.len * mem::size_of::<$i>();
+                let bytes = &all_of_memory[self.ptr..][..byte_size];
+
+                // The canonical ABI requires that everything is aligned to its
+                // own size, so this should be an aligned array. Furthermore the
+                // alignment of primitive integers for hosts should be smaller
+                // than or equal to the size of the primitive itself, meaning
+                // that a wasm canonical-abi-aligned list is also aligned for
+                // the host. That should mean that the head/tail slices here are
+                // empty.
+                //
+                // Also note that the `unsafe` here is needed since the type
+                // we're aligning to isn't guaranteed to be valid, but in our
+                // case it's just integers and bytes so this should be safe.
+                unsafe {
+                    let (head, body, tail) = bytes.align_to::<$i>();
+                    assert!(head.is_empty() && tail.is_empty());
+                    body
+                }
+            }
+        }
+    )*)
+}
+
+raw_wasm_list_accessors! {
+    i8 i16 i32 i64
+    u8 u16 u32 u64
+}
+
+// Note that this is similar to `ComponentType for str` except it can only be
+// used for lifting, not lowering.
+unsafe impl<T: ComponentType> ComponentType for WasmList<T> {
+    type Lower = <[T] as ComponentType>::Lower;
+
+    const ABI: CanonicalAbiInfo = CanonicalAbiInfo::POINTER_PAIR;
+
+    fn typecheck(ty: &InterfaceType, types: &InstanceType<'_>) -> Result<()> {
+        <[T] as ComponentType>::typecheck(ty, types)
+    }
+}
+
+unsafe impl<T: Lift> Lift for WasmList<T> {
+    fn lift(cx: &mut LiftContext<'_>, ty: InterfaceType, src: &Self::Lower) -> Result<Self> {
+        let elem = match ty {
+            InterfaceType::List(i) => cx.types[i].element,
+            _ => bad_type_info(),
+        };
+        // FIXME: needs memory64 treatment
+        let ptr = src[0].get_u32();
+        let len = src[1].get_u32();
+        let (ptr, len) = (
+            usize::try_from(ptr).err2anyhow()?,
+            usize::try_from(len).err2anyhow()?,
+        );
+        WasmList::new(ptr, len, cx, elem)
+    }
+
+    fn load(cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Self> {
+        let elem = match ty {
+            InterfaceType::List(i) => cx.types[i].element,
+            _ => bad_type_info(),
+        };
+        debug_assert!((bytes.as_ptr() as usize) % (Self::ALIGN32 as usize) == 0);
+        // FIXME: needs memory64 treatment
+        let ptr = u32::from_le_bytes(bytes[..4].try_into().unwrap());
+        let len = u32::from_le_bytes(bytes[4..].try_into().unwrap());
+        let (ptr, len) = (
+            usize::try_from(ptr).err2anyhow()?,
+            usize::try_from(len).err2anyhow()?,
+        );
+        WasmList::new(ptr, len, cx, elem)
+    }
+}
+
+/// Verify that the given wasm type is a tuple with the expected fields in the right order.
+fn typecheck_tuple(
+    ty: &InterfaceType,
+    types: &InstanceType<'_>,
+    expected: &[fn(&InterfaceType, &InstanceType<'_>) -> Result<()>],
+) -> Result<()> {
+    match ty {
+        InterfaceType::Tuple(t) => {
+            let tuple = &types.types[*t];
+            if tuple.types.len() != expected.len() {
+                bail!(
+                    "expected {}-tuple, found {}-tuple",
+                    expected.len(),
+                    tuple.types.len()
+                );
+            }
+            for (ty, check) in tuple.types.iter().zip(expected) {
+                check(ty, types)?;
+            }
+            Ok(())
+        }
+        other => bail!("expected `tuple` found `{}`", desc(other)),
+    }
+}
+
+/// Verify that the given wasm type is a record with the expected fields in the right order and with the right
+/// names.
+pub fn typecheck_record(
+    ty: &InterfaceType,
+    types: &InstanceType<'_>,
+    expected: &[(&str, fn(&InterfaceType, &InstanceType<'_>) -> Result<()>)],
+) -> Result<()> {
+    match ty {
+        InterfaceType::Record(index) => {
+            let fields = &types.types[*index].fields;
+
+            if fields.len() != expected.len() {
+                bail!(
+                    "expected record of {} fields, found {} fields",
+                    expected.len(),
+                    fields.len()
+                );
+            }
+
+            for (field, &(name, check)) in fields.iter().zip(expected) {
+                check(&field.ty, types)
+                    .with_context(|| format!("type mismatch for field {name}"))?;
+
+                if field.name != name {
+                    bail!("expected record field named {}, found {}", name, field.name);
+                }
+            }
+
+            Ok(())
+        }
+        other => bail!("expected `record` found `{}`", desc(other)),
+    }
+}
+
+/// Verify that the given wasm type is a variant with the expected cases in the right order and with the right
+/// names.
+pub fn typecheck_variant(
+    ty: &InterfaceType,
+    types: &InstanceType<'_>,
+    expected: &[(
+        &str,
+        Option<fn(&InterfaceType, &InstanceType<'_>) -> Result<()>>,
+    )],
+) -> Result<()> {
+    match ty {
+        InterfaceType::Variant(index) => {
+            let cases = &types.types[*index].cases;
+
+            if cases.len() != expected.len() {
+                bail!(
+                    "expected variant of {} cases, found {} cases",
+                    expected.len(),
+                    cases.len()
+                );
+            }
+
+            for ((case_name, case_ty), &(name, check)) in cases.iter().zip(expected) {
+                if *case_name != name {
+                    bail!("expected variant case named {name}, found {case_name}");
+                }
+
+                match (check, case_ty) {
+                    (Some(check), Some(ty)) => check(ty, types)
+                        .with_context(|| format!("type mismatch for case {name}"))?,
+                    (None, None) => {}
+                    (Some(_), None) => {
+                        bail!("case `{name}` has no type but one was expected")
+                    }
+                    (None, Some(_)) => {
+                        bail!("case `{name}` has a type but none was expected")
+                    }
+                }
+            }
+
+            Ok(())
+        }
+        other => bail!("expected `variant` found `{}`", desc(other)),
+    }
+}
+
+/// Verify that the given wasm type is a enum with the expected cases in the right order and with the right
+/// names.
+pub fn typecheck_enum(
+    ty: &InterfaceType,
+    types: &InstanceType<'_>,
+    expected: &[&str],
+) -> Result<()> {
+    match ty {
+        InterfaceType::Enum(index) => {
+            let names = &types.types[*index].names;
+
+            if names.len() != expected.len() {
+                bail!(
+                    "expected enum of {} names, found {} names",
+                    expected.len(),
+                    names.len()
+                );
+            }
+
+            for (name, expected) in names.iter().zip(expected) {
+                if name != expected {
+                    bail!("expected enum case named {}, found {}", expected, name);
+                }
+            }
+
+            Ok(())
+        }
+        other => bail!("expected `enum` found `{}`", desc(other)),
+    }
+}
+
+/// Verify that the given wasm type is a flags type with the expected flags in the right order and with the right
+/// names.
+pub fn typecheck_flags(
+    ty: &InterfaceType,
+    types: &InstanceType<'_>,
+    expected: &[&str],
+) -> Result<()> {
+    match ty {
+        InterfaceType::Flags(index) => {
+            let names = &types.types[*index].names;
+
+            if names.len() != expected.len() {
+                bail!(
+                    "expected flags type with {} names, found {} names",
+                    expected.len(),
+                    names.len()
+                );
+            }
+
+            for (name, expected) in names.iter().zip(expected) {
+                if name != expected {
+                    bail!("expected flag named {}, found {}", expected, name);
+                }
+            }
+
+            Ok(())
+        }
+        other => bail!("expected `flags` found `{}`", desc(other)),
+    }
+}
+
+/// Format the specified bitflags using the specified names for debugging
+pub fn format_flags(bits: &[u32], names: &[&str], f: &mut fmt::Formatter) -> fmt::Result {
+    f.write_str("(")?;
+    let mut wrote = false;
+    for (index, name) in names.iter().enumerate() {
+        if ((bits[index / 32] >> (index % 32)) & 1) != 0 {
+            if wrote {
+                f.write_str("|")?;
+            } else {
+                wrote = true;
+            }
+
+            f.write_str(name)?;
+        }
+    }
+    f.write_str(")")
+}
+
+unsafe impl<T> ComponentType for Option<T>
+where
+    T: ComponentType,
+{
+    type Lower = TupleLower2<<u32 as ComponentType>::Lower, T::Lower>;
+
+    const ABI: CanonicalAbiInfo = CanonicalAbiInfo::variant_static(&[None, Some(T::ABI)]);
+
+    fn typecheck(ty: &InterfaceType, types: &InstanceType<'_>) -> Result<()> {
+        match ty {
+            InterfaceType::Option(t) => T::typecheck(&types.types[*t].ty, types),
+            other => bail!("expected `option` found `{}`", desc(other)),
+        }
+    }
+}
+
+unsafe impl<T> ComponentVariant for Option<T>
+where
+    T: ComponentType,
+{
+    const CASES: &'static [Option<CanonicalAbiInfo>] = &[None, Some(T::ABI)];
+}
+
+unsafe impl<T> Lower for Option<T>
+where
+    T: Lower,
+{
+    fn lower<U>(
+        &self,
+        cx: &mut LowerContext<'_, U>,
+        ty: InterfaceType,
+        dst: &mut MaybeUninit<Self::Lower>,
+    ) -> Result<()> {
+        let payload = match ty {
+            InterfaceType::Option(ty) => cx.types[ty].ty,
+            _ => bad_type_info(),
+        };
+        match self {
+            None => {
+                map_maybe_uninit!(dst.A1).write(ValRaw::i32(0));
+                // Note that this is unsafe as we're writing an arbitrary
+                // bit-pattern to an arbitrary type, but part of the unsafe
+                // contract of the `ComponentType` trait is that we can assign
+                // any bit-pattern. By writing all zeros here we're ensuring
+                // that the core wasm arguments this translates to will all be
+                // zeros (as the canonical ABI requires).
+                unsafe {
+                    map_maybe_uninit!(dst.A2).as_mut_ptr().write_bytes(0u8, 1);
+                }
+            }
+            Some(val) => {
+                map_maybe_uninit!(dst.A1).write(ValRaw::i32(1));
+                val.lower(cx, payload, map_maybe_uninit!(dst.A2))?;
+            }
+        }
+        Ok(())
+    }
+
+    fn store<U>(
+        &self,
+        cx: &mut LowerContext<'_, U>,
+        ty: InterfaceType,
+        offset: usize,
+    ) -> Result<()> {
+        debug_assert!(offset % (Self::ALIGN32 as usize) == 0);
+        let payload = match ty {
+            InterfaceType::Option(ty) => cx.types[ty].ty,
+            _ => bad_type_info(),
+        };
+        match self {
+            None => {
+                cx.get::<1>(offset)[0] = 0;
+            }
+            Some(val) => {
+                cx.get::<1>(offset)[0] = 1;
+                val.store(cx, payload, offset + (Self::INFO.payload_offset32 as usize))?;
+            }
+        }
+        Ok(())
+    }
+}
+
+unsafe impl<T> Lift for Option<T>
+where
+    T: Lift,
+{
+    fn lift(cx: &mut LiftContext<'_>, ty: InterfaceType, src: &Self::Lower) -> Result<Self> {
+        let payload = match ty {
+            InterfaceType::Option(ty) => cx.types[ty].ty,
+            _ => bad_type_info(),
+        };
+        Ok(match src.A1.get_i32() {
+            0 => None,
+            1 => Some(T::lift(cx, payload, &src.A2)?),
+            _ => bail!("invalid option discriminant"),
+        })
+    }
+
+    fn load(cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Self> {
+        debug_assert!((bytes.as_ptr() as usize) % (Self::ALIGN32 as usize) == 0);
+        let payload_ty = match ty {
+            InterfaceType::Option(ty) => cx.types[ty].ty,
+            _ => bad_type_info(),
+        };
+        let discrim = bytes[0];
+        let payload = &bytes[Self::INFO.payload_offset32 as usize..];
+        match discrim {
+            0 => Ok(None),
+            1 => Ok(Some(T::load(cx, payload_ty, payload)?)),
+            _ => bail!("invalid option discriminant"),
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+#[repr(C)]
+pub struct ResultLower<T: Copy, E: Copy> {
+    tag: ValRaw,
+    payload: ResultLowerPayload<T, E>,
+}
+
+#[derive(Clone, Copy)]
+#[repr(C)]
+union ResultLowerPayload<T: Copy, E: Copy> {
+    ok: T,
+    err: E,
+}
+
+unsafe impl<T, E> ComponentType for Result<T, E>
+where
+    T: ComponentType,
+    E: ComponentType,
+{
+    type Lower = ResultLower<T::Lower, E::Lower>;
+
+    const ABI: CanonicalAbiInfo = CanonicalAbiInfo::variant_static(&[Some(T::ABI), Some(E::ABI)]);
+
+    fn typecheck(ty: &InterfaceType, types: &InstanceType<'_>) -> Result<()> {
+        match ty {
+            InterfaceType::Result(r) => {
+                let result = &types.types[*r];
+                match &result.ok {
+                    Some(ty) => T::typecheck(ty, types)?,
+                    None if T::IS_RUST_UNIT_TYPE => {}
+                    None => bail!("expected no `ok` type"),
+                }
+                match &result.err {
+                    Some(ty) => E::typecheck(ty, types)?,
+                    None if E::IS_RUST_UNIT_TYPE => {}
+                    None => bail!("expected no `err` type"),
+                }
+                Ok(())
+            }
+            other => bail!("expected `result` found `{}`", desc(other)),
+        }
+    }
+}
+
+/// Lowers the payload of a variant into the storage for the entire payload,
+/// handling writing zeros at the end of the representation if this payload is
+/// smaller than the entire flat representation.
+///
+/// * `payload` - the flat storage space for the entire payload of the variant
+/// * `typed_payload` - projection from the payload storage space to the
+///   individual storage space for this variant.
+/// * `lower` - lowering operation used to initialize the `typed_payload` return
+///   value.
+///
+/// For more information on this se the comments in the `Lower for Result`
+/// implementation below.
+pub unsafe fn lower_payload<P, T>(
+    payload: &mut MaybeUninit<P>,
+    typed_payload: impl FnOnce(&mut MaybeUninit<P>) -> &mut MaybeUninit<T>,
+    lower: impl FnOnce(&mut MaybeUninit<T>) -> Result<()>,
+) -> Result<()> {
+    let typed = typed_payload(payload);
+    lower(typed)?;
+
+    let typed_len = storage_as_slice(typed).len();
+    let payload = storage_as_slice_mut(payload);
+    for slot in payload[typed_len..].iter_mut() {
+        *slot = ValRaw::u64(0);
+    }
+    Ok(())
+}
+
+unsafe impl<T, E> ComponentVariant for Result<T, E>
+where
+    T: ComponentType,
+    E: ComponentType,
+{
+    const CASES: &'static [Option<CanonicalAbiInfo>] = &[Some(T::ABI), Some(E::ABI)];
+}
+
+unsafe impl<T, E> Lower for Result<T, E>
+where
+    T: Lower,
+    E: Lower,
+{
+    fn lower<U>(
+        &self,
+        cx: &mut LowerContext<'_, U>,
+        ty: InterfaceType,
+        dst: &mut MaybeUninit<Self::Lower>,
+    ) -> Result<()> {
+        let (ok, err) = match ty {
+            InterfaceType::Result(ty) => {
+                let ty = &cx.types[ty];
+                (ty.ok, ty.err)
+            }
+            _ => bad_type_info(),
+        };
+
+        // This implementation of `Lower::lower`, if you're reading these from
+        // the top of this file, is the first location that the "join" logic of
+        // the component model's canonical ABI encountered. The rough problem is
+        // that let's say we have a component model type of the form:
+        //
+        //      (result u64 (error (tuple f32 u16)))
+        //
+        // The flat representation of this is actually pretty tricky. Currently
+        // it is:
+        //
+        //      i32 i64 i32
+        //
+        // The first `i32` is the discriminant for the `result`, and the payload
+        // is represented by `i64 i32`. The "ok" variant will only use the `i64`
+        // and the "err" variant will use both `i64` and `i32`.
+        //
+        // In the "ok" variant the first issue is encountered. The size of one
+        // variant may not match the size of the other variants. All variants
+        // start at the "front" but when lowering a type we need to be sure to
+        // initialize the later variants (lest we leak random host memory into
+        // the guest module). Due to how the `Lower` type is represented as a
+        // `union` of all the variants what ends up happening here is that
+        // internally within the `lower_payload` after the typed payload is
+        // lowered the remaining bits of the payload that weren't initialized
+        // are all set to zero. This will guarantee that we'll write to all the
+        // slots for each variant.
+        //
+        // The "err" variant encounters the second issue, however, which is that
+        // the flat representation for each type may differ between payloads. In
+        // the "ok" arm an `i64` is written, but the `lower` implementation for
+        // the "err" arm will write an `f32` and then an `i32`. For this
+        // implementation of `lower` to be valid the `f32` needs to get inflated
+        // to an `i64` with zero-padding in the upper bits. What may be
+        // surprising, however, is that none of this is handled in this file.
+        // This implementation looks like it's blindly deferring to `E::lower`
+        // and hoping it does the right thing.
+        //
+        // In reality, however, the correctness of variant lowering relies on
+        // two subtle details of the `ValRaw` implementation in Wasmtime:
+        //
+        // 1. First the `ValRaw` value always contains little-endian values.
+        //    This means that if a `u32` is written, a `u64` is read, and then
+        //    the `u64` has its upper bits truncated the original value will
+        //    always be retained. This is primarily here for big-endian
+        //    platforms where if it weren't little endian then the opposite
+        //    would occur and the wrong value would be read.
+        //
+        // 2. Second, and perhaps even more subtly, the `ValRaw` constructors
+        //    for 32-bit types actually always initialize 64-bits of the
+        //    `ValRaw`. In the component model flat ABI only 32 and 64-bit types
+        //    are used so 64-bits is big enough to contain everything. This
+        //    means that when a `ValRaw` is written into the destination it will
+        //    always, whether it's needed or not, be "ready" to get extended up
+        //    to 64-bits.
+        //
+        // Put together these two subtle guarantees means that all `Lower`
+        // implementations can be written "naturally" as one might naively
+        // expect. Variants will, on each arm, zero out remaining fields and all
+        // writes to the flat representation will automatically be 64-bit writes
+        // meaning that if the value is read as a 64-bit value, which isn't
+        // known at the time of the write, it'll still be correct.
+        match self {
+            Ok(e) => {
+                map_maybe_uninit!(dst.tag).write(ValRaw::i32(0));
+                unsafe {
+                    lower_payload(
+                        map_maybe_uninit!(dst.payload),
+                        |payload| map_maybe_uninit!(payload.ok),
+                        |dst| match ok {
+                            Some(ok) => e.lower(cx, ok, dst),
+                            None => Ok(()),
+                        },
+                    )
+                }
+            }
+            Err(e) => {
+                map_maybe_uninit!(dst.tag).write(ValRaw::i32(1));
+                unsafe {
+                    lower_payload(
+                        map_maybe_uninit!(dst.payload),
+                        |payload| map_maybe_uninit!(payload.err),
+                        |dst| match err {
+                            Some(err) => e.lower(cx, err, dst),
+                            None => Ok(()),
+                        },
+                    )
+                }
+            }
+        }
+    }
+
+    fn store<U>(
+        &self,
+        cx: &mut LowerContext<'_, U>,
+        ty: InterfaceType,
+        offset: usize,
+    ) -> Result<()> {
+        let (ok, err) = match ty {
+            InterfaceType::Result(ty) => {
+                let ty = &cx.types[ty];
+                (ty.ok, ty.err)
+            }
+            _ => bad_type_info(),
+        };
+        debug_assert!(offset % (Self::ALIGN32 as usize) == 0);
+        let payload_offset = Self::INFO.payload_offset32 as usize;
+        match self {
+            Ok(e) => {
+                cx.get::<1>(offset)[0] = 0;
+                if let Some(ok) = ok {
+                    e.store(cx, ok, offset + payload_offset)?;
+                }
+            }
+            Err(e) => {
+                cx.get::<1>(offset)[0] = 1;
+                if let Some(err) = err {
+                    e.store(cx, err, offset + payload_offset)?;
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+unsafe impl<T, E> Lift for Result<T, E>
+where
+    T: Lift,
+    E: Lift,
+{
+    #[inline]
+    fn lift(cx: &mut LiftContext<'_>, ty: InterfaceType, src: &Self::Lower) -> Result<Self> {
+        let (ok, err) = match ty {
+            InterfaceType::Result(ty) => {
+                let ty = &cx.types[ty];
+                (ty.ok, ty.err)
+            }
+            _ => bad_type_info(),
+        };
+        // Note that this implementation specifically isn't trying to actually
+        // reinterpret or alter the bits of `lower` depending on which variant
+        // we're lifting. This ends up all working out because the value is
+        // stored in little-endian format.
+        //
+        // When stored in little-endian format the `{T,E}::Lower`, when each
+        // individual `ValRaw` is read, means that if an i64 value, extended
+        // from an i32 value, was stored then when the i32 value is read it'll
+        // automatically ignore the upper bits.
+        //
+        // This "trick" allows us to seamlessly pass through the `Self::Lower`
+        // representation into the lifting/lowering without trying to handle
+        // "join"ed types as per the canonical ABI. It just so happens that i64
+        // bits will naturally be reinterpreted as f64. Additionally if the
+        // joined type is i64 but only the lower bits are read that's ok and we
+        // don't need to validate the upper bits.
+        //
+        // This is largely enabled by WebAssembly/component-model#35 where no
+        // validation needs to be performed for ignored bits and bytes here.
+        Ok(match src.tag.get_i32() {
+            0 => Ok(unsafe { lift_option(cx, ok, &src.payload.ok)? }),
+            1 => Err(unsafe { lift_option(cx, err, &src.payload.err)? }),
+            _ => bail!("invalid expected discriminant"),
+        })
+    }
+
+    #[inline]
+    fn load(cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Self> {
+        debug_assert!((bytes.as_ptr() as usize) % (Self::ALIGN32 as usize) == 0);
+        let discrim = bytes[0];
+        let payload = &bytes[Self::INFO.payload_offset32 as usize..];
+        let (ok, err) = match ty {
+            InterfaceType::Result(ty) => {
+                let ty = &cx.types[ty];
+                (ty.ok, ty.err)
+            }
+            _ => bad_type_info(),
+        };
+        match discrim {
+            0 => Ok(Ok(load_option(cx, ok, &payload[..T::SIZE32])?)),
+            1 => Ok(Err(load_option(cx, err, &payload[..E::SIZE32])?)),
+            _ => bail!("invalid expected discriminant"),
+        }
+    }
+}
+
+fn lift_option<T>(cx: &mut LiftContext<'_>, ty: Option<InterfaceType>, src: &T::Lower) -> Result<T>
+where
+    T: Lift,
+{
+    match ty {
+        Some(ty) => T::lift(cx, ty, src),
+        None => Ok(empty_lift()),
+    }
+}
+
+fn load_option<T>(cx: &mut LiftContext<'_>, ty: Option<InterfaceType>, bytes: &[u8]) -> Result<T>
+where
+    T: Lift,
+{
+    match ty {
+        Some(ty) => T::load(cx, ty, bytes),
+        None => Ok(empty_lift()),
+    }
+}
+
+fn empty_lift<T>() -> T
+where
+    T: Lift,
+{
+    assert!(T::IS_RUST_UNIT_TYPE);
+    assert_eq!(mem::size_of::<T>(), 0);
+    unsafe { MaybeUninit::uninit().assume_init() }
+}
+
+macro_rules! impl_component_ty_for_tuples {
+    ($n:tt $($t:ident)*) => {paste::paste!{
+        #[allow(non_snake_case)]
+        #[doc(hidden)]
+        #[derive(Clone, Copy)]
+        #[repr(C)]
+        pub struct [<TupleLower$n>]<$($t),*> {
+            $($t: $t,)*
+            _align_tuple_lower0_correctly: [ValRaw; 0],
+        }
+
+        #[allow(non_snake_case)]
+        unsafe impl<$($t,)*> ComponentType for ($($t,)*)
+            where $($t: ComponentType),*
+        {
+            type Lower = [<TupleLower$n>]<$($t::Lower),*>;
+
+            const ABI: CanonicalAbiInfo = CanonicalAbiInfo::record_static(&[
+                $($t::ABI),*
+            ]);
+
+            const IS_RUST_UNIT_TYPE: bool = {
+                let mut _is_unit = true;
+                $(
+                    let _anything_to_bind_the_macro_variable = $t::IS_RUST_UNIT_TYPE;
+                    _is_unit = false;
+                )*
+                _is_unit
+            };
+
+            fn typecheck(
+                ty: &InterfaceType,
+                types: &InstanceType<'_>,
+            ) -> Result<()> {
+                typecheck_tuple(ty, types, &[$($t::typecheck),*])
+            }
+        }
+
+        #[allow(non_snake_case)]
+        unsafe impl<$($t,)*> Lower for ($($t,)*)
+            where $($t: Lower),*
+        {
+            fn lower<U>(
+                &self,
+                cx: &mut LowerContext<'_, U>,
+                ty: InterfaceType,
+                _dst: &mut MaybeUninit<Self::Lower>,
+            ) -> Result<()> {
+                let types = match ty {
+                    InterfaceType::Tuple(t) => &cx.types[t].types,
+                    _ => bad_type_info(),
+                };
+                let ($($t,)*) = self;
+                let mut _types = types.iter();
+                $(
+                    let ty = *_types.next().unwrap_or_else(bad_type_info);
+                    $t.lower(cx, ty, map_maybe_uninit!(_dst.$t))?;
+                )*
+                Ok(())
+            }
+
+            fn store<U>(
+                &self,
+                cx: &mut LowerContext<'_, U>,
+                ty: InterfaceType,
+                mut _offset: usize,
+            ) -> Result<()> {
+                debug_assert!(_offset % (Self::ALIGN32 as usize) == 0);
+                let types = match ty {
+                    InterfaceType::Tuple(t) => &cx.types[t].types,
+                    _ => bad_type_info(),
+                };
+                let ($($t,)*) = self;
+                let mut _types = types.iter();
+                $(
+                    let ty = *_types.next().unwrap_or_else(bad_type_info);
+                    $t.store(cx, ty, $t::ABI.next_field32_size(&mut _offset))?;
+                )*
+                Ok(())
+            }
+        }
+
+        #[allow(non_snake_case)]
+        unsafe impl<$($t,)*> Lift for ($($t,)*)
+            where $($t: Lift),*
+        {
+            #[inline]
+            fn lift(cx: &mut LiftContext<'_>, ty: InterfaceType, _src: &Self::Lower) -> Result<Self> {
+                let types = match ty {
+                    InterfaceType::Tuple(t) => &cx.types[t].types,
+                    _ => bad_type_info(),
+                };
+                let mut _types = types.iter();
+                Ok(($(
+                    $t::lift(
+                        cx,
+                        *_types.next().unwrap_or_else(bad_type_info),
+                        &_src.$t,
+                    )?,
+                )*))
+            }
+
+            #[inline]
+            fn load(cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Self> {
+                debug_assert!((bytes.as_ptr() as usize) % (Self::ALIGN32 as usize) == 0);
+                let types = match ty {
+                    InterfaceType::Tuple(t) => &cx.types[t].types,
+                    _ => bad_type_info(),
+                };
+                let mut _types = types.iter();
+                let mut _offset = 0;
+                $(
+                    let ty = *_types.next().unwrap_or_else(bad_type_info);
+                    let $t = $t::load(cx, ty, &bytes[$t::ABI.next_field32_size(&mut _offset)..][..$t::SIZE32])?;
+                )*
+                Ok(($($t,)*))
+            }
+        }
+
+        #[allow(non_snake_case)]
+        unsafe impl<$($t,)*> ComponentNamedList for ($($t,)*)
+            where $($t: ComponentType),*
+        {}
+    }};
+}
+
+for_each_function_signature!(impl_component_ty_for_tuples);
+
+pub fn desc(ty: &InterfaceType) -> &'static str {
+    match ty {
+        InterfaceType::U8 => "u8",
+        InterfaceType::S8 => "s8",
+        InterfaceType::U16 => "u16",
+        InterfaceType::S16 => "s16",
+        InterfaceType::U32 => "u32",
+        InterfaceType::S32 => "s32",
+        InterfaceType::U64 => "u64",
+        InterfaceType::S64 => "s64",
+        InterfaceType::Float32 => "f32",
+        InterfaceType::Float64 => "f64",
+        InterfaceType::Bool => "bool",
+        InterfaceType::Char => "char",
+        InterfaceType::String => "string",
+        InterfaceType::List(_) => "list",
+        InterfaceType::Tuple(_) => "tuple",
+        InterfaceType::Option(_) => "option",
+        InterfaceType::Result(_) => "result",
+
+        InterfaceType::Record(_) => "record",
+        InterfaceType::Variant(_) => "variant",
+        InterfaceType::Flags(_) => "flags",
+        InterfaceType::Enum(_) => "enum",
+        InterfaceType::Own(_) => "owned resource",
+        InterfaceType::Borrow(_) => "borrowed resource",
+    }
+}
+
+#[cold]
+#[doc(hidden)]
+pub fn bad_type_info<T>() -> T {
+    // NB: should consider something like `unreachable_unchecked` here if this
+    // becomes a performance bottleneck at some point, but that also comes with
+    // a tradeoff of propagating a lot of unsafety, so it may not be worth it.
+    panic!("bad type information detected");
+}
diff --git a/crates/wasmtime/src/runtime/component/instance.rs b/crates/wasmtime/src/runtime/component/instance.rs
new file mode 100644
index 000000000000..bb7c337eb842
--- /dev/null
+++ b/crates/wasmtime/src/runtime/component/instance.rs
@@ -0,0 +1,846 @@
+use crate::component::func::HostFunc;
+use crate::component::matching::InstanceType;
+use crate::component::{
+    Component, ComponentExportIndex, ComponentNamedList, Func, Lift, Lower, ResourceType, TypedFunc,
+};
+use crate::instance::OwnedImports;
+use crate::linker::DefinitionType;
+use crate::prelude::*;
+use crate::runtime::vm::component::{ComponentInstance, OwnedComponentInstance};
+use crate::runtime::vm::{CompiledModuleId, VMFuncRef};
+use crate::store::{StoreOpaque, Stored};
+use crate::{AsContextMut, Engine, Module, StoreContextMut};
+use alloc::sync::Arc;
+use core::marker;
+use core::ptr::{self, NonNull};
+use wasmtime_environ::{component::*, EngineOrModuleTypeIndex};
+use wasmtime_environ::{EntityIndex, EntityType, Global, PrimaryMap, WasmValType};
+
+/// An instantiated component.
+///
+/// This type represents an instantiated [`Component`](super::Component).
+/// Instances have exports which can be accessed through functions such as
+/// [`Instance::get_func`] or [`Instance::get_export`]. Instances are owned by a
+/// [`Store`](crate::Store) and all methods require a handle to the store.
+///
+/// Component instances are created through
+/// [`Linker::instantiate`](super::Linker::instantiate) and its family of
+/// methods.
+///
+/// This type is similar to the core wasm version
+/// [`wasmtime::Instance`](crate::Instance) except that it represents an
+/// instantiated component instead of an instantiated module.
+#[derive(Copy, Clone)]
+pub struct Instance(pub(crate) Stored<Option<Box<InstanceData>>>);
+
+pub(crate) struct InstanceData {
+    instances: PrimaryMap<RuntimeInstanceIndex, crate::Instance>,
+
+    // NB: in the future if necessary it would be possible to avoid storing an
+    // entire `Component` here and instead storing only information such as:
+    //
+    // * Some reference to `Arc<ComponentTypes>`
+    // * Necessary references to closed-over modules which are exported from the
+    //   component itself.
+    //
+    // Otherwise the full guts of this component should only ever be used during
+    // the instantiation of this instance, meaning that after instantiation much
+    // of the component can be thrown away (theoretically).
+    component: Component,
+
+    state: OwnedComponentInstance,
+
+    /// Arguments that this instance used to be instantiated.
+    ///
+    /// Strong references are stored to these arguments since pointers are saved
+    /// into the structures such as functions within the
+    /// `OwnedComponentInstance` but it's our job to keep them alive.
+    ///
+    /// One purpose of this storage is to enable embedders to drop a `Linker`,
+    /// for example, after a component is instantiated. In that situation if the
+    /// arguments weren't held here then they might be dropped, and structures
+    /// such as `.lowering()` which point back into the original function would
+    /// become stale and use-after-free conditions when used. By preserving the
+    /// entire list here though we're guaranteed that nothing is lost for the
+    /// duration of the lifetime of this instance.
+    imports: Arc<PrimaryMap<RuntimeImportIndex, RuntimeImport>>,
+}
+
+impl Instance {
+    /// Looks up an exported function by name within this [`Instance`].
+    ///
+    /// The `store` argument provided must be the store that this instance
+    /// lives within and the `name` argument is the lookup key by which to find
+    /// the exported function. If the function is found then `Some` is returned
+    /// and otherwise `None` is returned.
+    ///
+    /// The `name` here can be a string such as `&str` or it can be a
+    /// [`ComponentExportIndex`] which is loaded prior from a [`Component`].
+    ///
+    /// # Panics
+    ///
+    /// Panics if `store` does not own this instance.
+    ///
+    /// # Examples
+    ///
+    /// Looking up a function which is exported from the root of a component:
+    ///
+    /// ```
+    /// use wasmtime::{Engine, Store};
+    /// use wasmtime::component::{Component, Linker};
+    ///
+    /// # fn main() -> wasmtime::Result<()> {
+    /// let engine = Engine::default();
+    /// let component = Component::new(
+    ///     &engine,
+    ///     r#"
+    ///         (component
+    ///             (core module $m
+    ///                 (func (export "f"))
+    ///             )
+    ///             (core instance $i (instantiate $m))
+    ///             (func (export "f")
+    ///                 (canon lift (core func $i "f")))
+    ///         )
+    ///     "#,
+    /// )?;
+    ///
+    /// // Look up the function by name
+    /// let mut store = Store::new(&engine, ());
+    /// let instance = Linker::new(&engine).instantiate(&mut store, &component)?;
+    /// let func = instance.get_func(&mut store, "f").unwrap();
+    ///
+    /// // The function can also be looked up by an index via a precomputed index.
+    /// let (_, export) = component.export_index(None, "f").unwrap();
+    /// let func = instance.get_func(&mut store, &export).unwrap();
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// Looking up a function which is exported from a nested instance:
+    ///
+    /// ```
+    /// use wasmtime::{Engine, Store};
+    /// use wasmtime::component::{Component, Linker};
+    ///
+    /// # fn main() -> wasmtime::Result<()> {
+    /// let engine = Engine::default();
+    /// let component = Component::new(
+    ///     &engine,
+    ///     r#"
+    ///         (component
+    ///             (core module $m
+    ///                 (func (export "f"))
+    ///             )
+    ///             (core instance $i (instantiate $m))
+    ///             (func $f
+    ///                 (canon lift (core func $i "f")))
+    ///
+    ///             (instance $i
+    ///                 (export "f" (func $f)))
+    ///             (export "i" (instance $i))
+    ///         )
+    ///     "#,
+    /// )?;
+    ///
+    /// // First look up the exported instance, then use that to lookup the
+    /// // exported function.
+    /// let (_, instance_index) = component.export_index(None, "i").unwrap();
+    /// let (_, func_index) = component.export_index(Some(&instance_index), "f").unwrap();
+    ///
+    /// // Then use `func_index` at runtime.
+    /// let mut store = Store::new(&engine, ());
+    /// let instance = Linker::new(&engine).instantiate(&mut store, &component)?;
+    /// let func = instance.get_func(&mut store, &func_index).unwrap();
+    ///
+    /// // Alternatively the `instance` can be used directly in conjunction with
+    /// // the `get_export` method.
+    /// let instance_index = instance.get_export(&mut store, None, "i").unwrap();
+    /// let func_index = instance.get_export(&mut store, Some(&instance_index), "f").unwrap();
+    /// let func = instance.get_func(&mut store, &func_index).unwrap();
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn get_func(
+        &self,
+        mut store: impl AsContextMut,
+        name: impl InstanceExportLookup,
+    ) -> Option<Func> {
+        let store = store.as_context_mut().0;
+        let data = store[self.0].take().unwrap();
+        let ret = name.lookup(&data.component).and_then(|index| {
+            match &data.component.env_component().export_items[index] {
+                Export::LiftedFunction { ty, func, options } => Some(Func::from_lifted_func(
+                    store, self, &data, *ty, func, options,
+                )),
+                _ => None,
+            }
+        });
+        store[self.0] = Some(data);
+        ret
+    }
+
+    /// Looks up an exported [`Func`] value by name and with its type.
+    ///
+    /// This function is a convenience wrapper over [`Instance::get_func`] and
+    /// [`Func::typed`]. For more information see the linked documentation.
+    ///
+    /// Returns an error if `name` isn't a function export or if the export's
+    /// type did not match `Params` or `Results`
+    ///
+    /// # Panics
+    ///
+    /// Panics if `store` does not own this instance.
+    pub fn get_typed_func<Params, Results>(
+        &self,
+        mut store: impl AsContextMut,
+        name: impl InstanceExportLookup,
+    ) -> Result<TypedFunc<Params, Results>>
+    where
+        Params: ComponentNamedList + Lower,
+        Results: ComponentNamedList + Lift,
+    {
+        let f = self
+            .get_func(store.as_context_mut(), name)
+            .ok_or_else(|| anyhow!("failed to find function export"))?;
+        Ok(f.typed::<Params, Results>(store)
+            .with_context(|| format!("failed to convert function to given type"))?)
+    }
+
+    /// Looks up an exported module by name within this [`Instance`].
+    ///
+    /// The `store` argument provided must be the store that this instance
+    /// lives within and the `name` argument is the lookup key by which to find
+    /// the exported module. If the module is found then `Some` is returned
+    /// and otherwise `None` is returned.
+    ///
+    /// The `name` here can be a string such as `&str` or it can be a
+    /// [`ComponentExportIndex`] which is loaded prior from a [`Component`].
+    ///
+    /// For some examples see [`Instance::get_func`] for loading values from a
+    /// component.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `store` does not own this instance.
+    pub fn get_module(
+        &self,
+        mut store: impl AsContextMut,
+        name: impl InstanceExportLookup,
+    ) -> Option<Module> {
+        let store = store.as_context_mut().0;
+        let (data, export, _) = self.lookup_export(store, name)?;
+        match export {
+            Export::ModuleStatic { index, .. } => {
+                Some(data.component.static_module(*index).clone())
+            }
+            Export::ModuleImport { import, .. } => match &data.imports[*import] {
+                RuntimeImport::Module(m) => Some(m.clone()),
+                _ => unreachable!(),
+            },
+            _ => None,
+        }
+    }
+
+    /// Looks up an exported resource type by name within this [`Instance`].
+    ///
+    /// The `store` argument provided must be the store that this instance
+    /// lives within and the `name` argument is the lookup key by which to find
+    /// the exported resource. If the resource is found then `Some` is returned
+    /// and otherwise `None` is returned.
+    ///
+    /// The `name` here can be a string such as `&str` or it can be a
+    /// [`ComponentExportIndex`] which is loaded prior from a [`Component`].
+    ///
+    /// For some examples see [`Instance::get_func`] for loading values from a
+    /// component.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `store` does not own this instance.
+    pub fn get_resource(
+        &self,
+        mut store: impl AsContextMut,
+        name: impl InstanceExportLookup,
+    ) -> Option<ResourceType> {
+        let store = store.as_context_mut().0;
+        let (data, export, _) = self.lookup_export(store, name)?;
+        match export {
+            Export::Type(TypeDef::Resource(id)) => Some(data.ty().resource_type(*id)),
+            Export::Type(_)
+            | Export::LiftedFunction { .. }
+            | Export::ModuleStatic { .. }
+            | Export::ModuleImport { .. }
+            | Export::Instance { .. } => None,
+        }
+    }
+
+    /// A methods similar to [`Component::export_index`] except for this
+    /// instance.
+    ///
+    /// This method will lookup the `name` provided within the `instance`
+    /// provided and return a [`ComponentExportIndex`] which can be used to
+    /// pass to other `get_*` functions like [`Instance::get_func`].
+    ///
+    /// # Panics
+    ///
+    /// Panics if `store` does not own this instance.
+    pub fn get_export(
+        &self,
+        mut store: impl AsContextMut,
+        instance: Option<&ComponentExportIndex>,
+        name: &str,
+    ) -> Option<ComponentExportIndex> {
+        self._get_export(store.as_context_mut().0, instance, name)
+    }
+
+    fn _get_export(
+        &self,
+        store: &StoreOpaque,
+        instance: Option<&ComponentExportIndex>,
+        name: &str,
+    ) -> Option<ComponentExportIndex> {
+        let data = store[self.0].as_ref().unwrap();
+        let index = data.component.lookup_export_index(instance, name)?;
+        Some(ComponentExportIndex {
+            id: data.component_id(),
+            index,
+        })
+    }
+
+    fn lookup_export<'a>(
+        &self,
+        store: &'a StoreOpaque,
+        name: impl InstanceExportLookup,
+    ) -> Option<(&'a InstanceData, &'a Export, ExportIndex)> {
+        let data = store[self.0].as_ref().unwrap();
+        let index = name.lookup(&data.component)?;
+        Some((
+            data,
+            &data.component.env_component().export_items[index],
+            index,
+        ))
+    }
+}
+
+/// Trait used to lookup the export of a component instance.
+///
+/// This trait is used as an implementation detail of [`Instance::get_func`]
+/// and related `get_*` methods. Notable implementors of this trait are:
+///
+/// * `str`
+/// * `String`
+/// * [`ComponentExportIndex`]
+///
+/// Note that this is intended to be a `wasmtime`-sealed trait so it shouldn't
+/// need to be implemented externally.
+pub trait InstanceExportLookup {
+    #[doc(hidden)]
+    fn lookup(&self, component: &Component) -> Option<ExportIndex>;
+}
+
+impl<T> InstanceExportLookup for &T
+where
+    T: InstanceExportLookup + ?Sized,
+{
+    fn lookup(&self, component: &Component) -> Option<ExportIndex> {
+        T::lookup(self, component)
+    }
+}
+
+impl InstanceExportLookup for str {
+    fn lookup(&self, component: &Component) -> Option<ExportIndex> {
+        component
+            .env_component()
+            .exports
+            .get(self, &NameMapNoIntern)
+            .copied()
+    }
+}
+
+impl InstanceExportLookup for String {
+    fn lookup(&self, component: &Component) -> Option<ExportIndex> {
+        str::lookup(self, component)
+    }
+}
+
+impl InstanceData {
+    pub fn lookup_def(&self, store: &mut StoreOpaque, def: &CoreDef) -> crate::runtime::vm::Export {
+        match def {
+            CoreDef::Export(e) => self.lookup_export(store, e),
+            CoreDef::Trampoline(idx) => {
+                crate::runtime::vm::Export::Function(crate::runtime::vm::ExportFunction {
+                    func_ref: self.state.trampoline_func_ref(*idx),
+                })
+            }
+            CoreDef::InstanceFlags(idx) => {
+                crate::runtime::vm::Export::Global(crate::runtime::vm::ExportGlobal {
+                    definition: self.state.instance_flags(*idx).as_raw(),
+                    vmctx: ptr::null_mut(),
+                    global: Global {
+                        wasm_ty: WasmValType::I32,
+                        mutability: true,
+                    },
+                })
+            }
+        }
+    }
+
+    pub fn lookup_export<T>(
+        &self,
+        store: &mut StoreOpaque,
+        item: &CoreExport<T>,
+    ) -> crate::runtime::vm::Export
+    where
+        T: Copy + Into<EntityIndex>,
+    {
+        let instance = &self.instances[item.instance];
+        let id = instance.id(store);
+        let instance = store.instance_mut(id);
+        let idx = match &item.item {
+            ExportItem::Index(idx) => (*idx).into(),
+
+            // FIXME: ideally at runtime we don't actually do any name lookups
+            // here. This will only happen when the host supplies an imported
+            // module so while the structure can't be known at compile time we
+            // do know at `InstancePre` time, for example, what all the host
+            // imports are. In theory we should be able to, as part of
+            // `InstancePre` construction, perform all name=>index mappings
+            // during that phase so the actual instantiation of an `InstancePre`
+            // skips all string lookups. This should probably only be
+            // investigated if this becomes a performance issue though.
+            ExportItem::Name(name) => instance.module().exports[name],
+        };
+        instance.get_export_by_index(idx)
+    }
+
+    #[inline]
+    pub fn instance(&self) -> &ComponentInstance {
+        &self.state
+    }
+
+    #[inline]
+    pub fn instance_ptr(&self) -> *mut ComponentInstance {
+        self.state.instance_ptr()
+    }
+
+    #[inline]
+    pub fn component_types(&self) -> &Arc<ComponentTypes> {
+        self.component.types()
+    }
+
+    #[inline]
+    pub fn component_id(&self) -> CompiledModuleId {
+        self.component.id()
+    }
+
+    #[inline]
+    pub fn ty(&self) -> InstanceType<'_> {
+        InstanceType::new(self.instance())
+    }
+
+    // NB: This method is only intended to be called during the instantiation
+    // process because the `Arc::get_mut` here is fallible and won't generally
+    // succeed once the instance has been handed to the embedder. Before that
+    // though it should be guaranteed that the single owning reference currently
+    // lives within the `ComponentInstance` that's being built.
+    fn resource_types_mut(&mut self) -> &mut ImportedResources {
+        Arc::get_mut(self.state.resource_types_mut())
+            .unwrap()
+            .downcast_mut()
+            .unwrap()
+    }
+}
+
+struct Instantiator<'a> {
+    component: &'a Component,
+    data: InstanceData,
+    core_imports: OwnedImports,
+    imports: &'a PrimaryMap<RuntimeImportIndex, RuntimeImport>,
+}
+
+pub(crate) enum RuntimeImport {
+    Func(Arc<HostFunc>),
+    Module(Module),
+    Resource {
+        ty: ResourceType,
+
+        // A strong reference to the host function that represents the
+        // destructor for this resource. At this time all resources here are
+        // host-defined resources. Note that this is itself never read because
+        // the funcref below points to it.
+        //
+        // Also note that the `Arc` here is used to support the same host
+        // function being used across multiple instances simultaneously. Or
+        // otherwise this makes `InstancePre::instantiate` possible to create
+        // separate instances all sharing the same host function.
+        _dtor: Arc<crate::func::HostFunc>,
+
+        // A raw function which is filled out (including `wasm_call`) which
+        // points to the internals of the `_dtor` field. This is read and
+        // possibly executed by wasm.
+        dtor_funcref: VMFuncRef,
+    },
+}
+
+pub type ImportedResources = PrimaryMap<ResourceIndex, ResourceType>;
+
+impl<'a> Instantiator<'a> {
+    fn new(
+        component: &'a Component,
+        store: &mut StoreOpaque,
+        imports: &'a Arc<PrimaryMap<RuntimeImportIndex, RuntimeImport>>,
+    ) -> Instantiator<'a> {
+        let env_component = component.env_component();
+        store.modules_mut().register_component(component);
+        let imported_resources: ImportedResources =
+            PrimaryMap::with_capacity(env_component.imported_resources.len());
+        Instantiator {
+            component,
+            imports,
+            core_imports: OwnedImports::empty(),
+            data: InstanceData {
+                instances: PrimaryMap::with_capacity(env_component.num_runtime_instances as usize),
+                component: component.clone(),
+                state: OwnedComponentInstance::new(
+                    component.runtime_info(),
+                    Arc::new(imported_resources),
+                    store.traitobj(),
+                ),
+                imports: imports.clone(),
+            },
+        }
+    }
+
+    fn run<T>(&mut self, store: &mut StoreContextMut<'_, T>) -> Result<()> {
+        let env_component = self.component.env_component();
+
+        // Before all initializers are processed configure all destructors for
+        // host-defined resources. No initializer will correspond to these and
+        // it's required to happen before they're needed, so execute this first.
+        for (idx, import) in env_component.imported_resources.iter() {
+            let (ty, func_ref) = match &self.imports[*import] {
+                RuntimeImport::Resource {
+                    ty, dtor_funcref, ..
+                } => (*ty, NonNull::from(dtor_funcref)),
+                _ => unreachable!(),
+            };
+            let i = self.data.resource_types_mut().push(ty);
+            assert_eq!(i, idx);
+            self.data.state.set_resource_destructor(idx, Some(func_ref));
+        }
+
+        // Next configure all `VMFuncRef`s for trampolines that this component
+        // will require. These functions won't actually get used until their
+        // associated state has been initialized through the global initializers
+        // below, but the funcrefs can all be configured here.
+        for (idx, sig) in env_component.trampolines.iter() {
+            let ptrs = self.component.trampoline_ptrs(idx);
+            let signature = match self.component.signatures().shared_type(*sig) {
+                Some(s) => s,
+                None => panic!("found unregistered signature: {sig:?}"),
+            };
+
+            self.data
+                .state
+                .set_trampoline(idx, ptrs.wasm_call, ptrs.array_call, signature);
+        }
+
+        for initializer in env_component.initializers.iter() {
+            match initializer {
+                GlobalInitializer::InstantiateModule(m) => {
+                    let module;
+                    let imports = match m {
+                        // Since upvars are statically know we know that the
+                        // `args` list is already in the right order.
+                        InstantiateModule::Static(idx, args) => {
+                            module = self.component.static_module(*idx);
+                            self.build_imports(store.0, module, args.iter())
+                        }
+
+                        // With imports, unlike upvars, we need to do runtime
+                        // lookups with strings to determine the order of the
+                        // imports since it's whatever the actual module
+                        // requires.
+                        //
+                        // FIXME: see the note in `ExportItem::Name` handling
+                        // above for how we ideally shouldn't do string lookup
+                        // here.
+                        InstantiateModule::Import(idx, args) => {
+                            module = match &self.imports[*idx] {
+                                RuntimeImport::Module(m) => m,
+                                _ => unreachable!(),
+                            };
+                            let args = module
+                                .imports()
+                                .map(|import| &args[import.module()][import.name()]);
+                            self.build_imports(store.0, module, args)
+                        }
+                    };
+
+                    // Note that the unsafety here should be ok because the
+                    // validity of the component means that type-checks have
+                    // already been performed. This means that the unsafety due
+                    // to imports having the wrong type should not happen here.
+                    //
+                    // Also note we are calling new_started_impl because we have
+                    // already checked for asyncness and are running on a fiber
+                    // if required.
+
+                    let i = unsafe {
+                        crate::Instance::new_started_impl(store, module, imports.as_ref())?
+                    };
+                    self.data.instances.push(i);
+                }
+
+                GlobalInitializer::LowerImport { import, index } => {
+                    let func = match &self.imports[*import] {
+                        RuntimeImport::Func(func) => func,
+                        _ => unreachable!(),
+                    };
+                    self.data.state.set_lowering(*index, func.lowering());
+                }
+
+                GlobalInitializer::ExtractMemory(mem) => self.extract_memory(store.0, mem),
+
+                GlobalInitializer::ExtractRealloc(realloc) => {
+                    self.extract_realloc(store.0, realloc)
+                }
+
+                GlobalInitializer::ExtractPostReturn(post_return) => {
+                    self.extract_post_return(store.0, post_return)
+                }
+
+                GlobalInitializer::Resource(r) => self.resource(store.0, r),
+            }
+        }
+        Ok(())
+    }
+
+    fn resource(&mut self, store: &mut StoreOpaque, resource: &Resource) {
+        let dtor = resource
+            .dtor
+            .as_ref()
+            .map(|dtor| self.data.lookup_def(store, dtor));
+        let dtor = dtor.map(|export| match export {
+            crate::runtime::vm::Export::Function(f) => f.func_ref,
+            _ => unreachable!(),
+        });
+        let index = self
+            .component
+            .env_component()
+            .resource_index(resource.index);
+        self.data.state.set_resource_destructor(index, dtor);
+        let ty = ResourceType::guest(store.id(), &self.data.state, resource.index);
+        let i = self.data.resource_types_mut().push(ty);
+        debug_assert_eq!(i, index);
+    }
+
+    fn extract_memory(&mut self, store: &mut StoreOpaque, memory: &ExtractMemory) {
+        let mem = match self.data.lookup_export(store, &memory.export) {
+            crate::runtime::vm::Export::Memory(m) => m,
+            _ => unreachable!(),
+        };
+        self.data
+            .state
+            .set_runtime_memory(memory.index, mem.definition);
+    }
+
+    fn extract_realloc(&mut self, store: &mut StoreOpaque, realloc: &ExtractRealloc) {
+        let func_ref = match self.data.lookup_def(store, &realloc.def) {
+            crate::runtime::vm::Export::Function(f) => f.func_ref,
+            _ => unreachable!(),
+        };
+        self.data.state.set_runtime_realloc(realloc.index, func_ref);
+    }
+
+    fn extract_post_return(&mut self, store: &mut StoreOpaque, post_return: &ExtractPostReturn) {
+        let func_ref = match self.data.lookup_def(store, &post_return.def) {
+            crate::runtime::vm::Export::Function(f) => f.func_ref,
+            _ => unreachable!(),
+        };
+        self.data
+            .state
+            .set_runtime_post_return(post_return.index, func_ref);
+    }
+
+    fn build_imports<'b>(
+        &mut self,
+        store: &mut StoreOpaque,
+        module: &Module,
+        args: impl Iterator<Item = &'b CoreDef>,
+    ) -> &OwnedImports {
+        self.core_imports.clear();
+        self.core_imports.reserve(module);
+        let mut imports = module.compiled_module().module().imports();
+
+        for arg in args {
+            // The general idea of Wasmtime is that at runtime type-checks for
+            // core wasm instantiations internally within a component are
+            // unnecessary and superfluous. Naturally though mistakes may be
+            // made, so double-check this property of wasmtime in debug mode.
+
+            if cfg!(debug_assertions) {
+                let (imp_module, imp_name, expected) = imports.next().unwrap();
+                self.assert_type_matches(store, module, arg, imp_module, imp_name, expected);
+            }
+
+            // The unsafety here should be ok since the `export` is loaded
+            // directly from an instance which should only give us valid export
+            // items.
+            let export = self.data.lookup_def(store, arg);
+            unsafe {
+                self.core_imports.push_export(&export);
+            }
+        }
+        debug_assert!(imports.next().is_none());
+
+        &self.core_imports
+    }
+
+    fn assert_type_matches(
+        &self,
+        store: &mut StoreOpaque,
+        module: &Module,
+        arg: &CoreDef,
+        imp_module: &str,
+        imp_name: &str,
+        expected: EntityType,
+    ) {
+        let export = self.data.lookup_def(store, arg);
+
+        // If this value is a core wasm function then the type check is inlined
+        // here. This can otherwise fail `Extern::from_wasmtime_export` because
+        // there's no guarantee that there exists a trampoline for `f` so this
+        // can't fall through to the case below
+        if let crate::runtime::vm::Export::Function(f) = &export {
+            let expected = match expected.unwrap_func() {
+                EngineOrModuleTypeIndex::Engine(e) => Some(e),
+                EngineOrModuleTypeIndex::Module(m) => module.signatures().shared_type(m),
+                EngineOrModuleTypeIndex::RecGroup(_) => unreachable!(),
+            };
+            let actual = unsafe { f.func_ref.as_ref().type_index };
+            assert_eq!(
+                expected,
+                Some(actual),
+                "type mismatch for import {imp_module:?} {imp_name:?}!!!\n\n\
+                 expected {:#?}\n\n\
+                 found {:#?}",
+                expected.and_then(|e| store.engine().signatures().borrow(e)),
+                store.engine().signatures().borrow(actual)
+            );
+            return;
+        }
+
+        let val = unsafe { crate::Extern::from_wasmtime_export(export, store) };
+        let ty = DefinitionType::from(store, &val);
+        crate::types::matching::MatchCx::new(module.engine())
+            .definition(&expected, &ty)
+            .expect("unexpected typecheck failure");
+    }
+}
+
+/// A "pre-instantiated" [`Instance`] which has all of its arguments already
+/// supplied and is ready to instantiate.
+///
+/// This structure represents an efficient form of instantiation where import
+/// type-checking and import lookup has all been resolved by the time that this
+/// type is created. This type is primarily created through the
+/// [`Linker::instantiate_pre`](crate::component::Linker::instantiate_pre)
+/// method.
+pub struct InstancePre<T> {
+    component: Component,
+    imports: Arc<PrimaryMap<RuntimeImportIndex, RuntimeImport>>,
+    _marker: marker::PhantomData<fn() -> T>,
+}
+
+// `InstancePre`'s clone does not require `T: Clone`
+impl<T> Clone for InstancePre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            component: self.component.clone(),
+            imports: self.imports.clone(),
+            _marker: self._marker,
+        }
+    }
+}
+
+impl<T> InstancePre<T> {
+    /// This function is `unsafe` since there's no guarantee that the
+    /// `RuntimeImport` items provided are guaranteed to work with the `T` of
+    /// the store.
+    ///
+    /// Additionally there is no static guarantee that the `imports` provided
+    /// satisfy the imports of the `component` provided.
+    pub(crate) unsafe fn new_unchecked(
+        component: Component,
+        imports: PrimaryMap<RuntimeImportIndex, RuntimeImport>,
+    ) -> InstancePre<T> {
+        InstancePre {
+            component,
+            imports: Arc::new(imports),
+            _marker: marker::PhantomData,
+        }
+    }
+
+    /// Returns the underlying component that will be instantiated.
+    pub fn component(&self) -> &Component {
+        &self.component
+    }
+
+    /// Returns the underlying engine.
+    pub fn engine(&self) -> &Engine {
+        self.component.engine()
+    }
+
+    /// Performs the instantiation process into the store specified.
+    //
+    // TODO: needs more docs
+    pub fn instantiate(&self, store: impl AsContextMut<Data = T>) -> Result<Instance> {
+        assert!(
+            !store.as_context().async_support(),
+            "must use async instantiation when async support is enabled"
+        );
+        self.instantiate_impl(store)
+    }
+    /// Performs the instantiation process into the store specified.
+    ///
+    /// Exactly like [`Self::instantiate`] except for use on async stores.
+    //
+    // TODO: needs more docs
+    #[cfg(feature = "async")]
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl AsContextMut<Data = T>,
+    ) -> Result<Instance>
+    where
+        T: Send,
+    {
+        let mut store = store.as_context_mut();
+        assert!(
+            store.0.async_support(),
+            "must use sync instantiation when async support is disabled"
+        );
+        store.on_fiber(|store| self.instantiate_impl(store)).await?
+    }
+
+    fn instantiate_impl(&self, mut store: impl AsContextMut<Data = T>) -> Result<Instance> {
+        let mut store = store.as_context_mut();
+        store
+            .engine()
+            .allocator()
+            .increment_component_instance_count()?;
+        let mut instantiator = Instantiator::new(&self.component, store.0, &self.imports);
+        instantiator.run(&mut store).map_err(|e| {
+            store
+                .engine()
+                .allocator()
+                .decrement_component_instance_count();
+            e
+        })?;
+        let data = Box::new(instantiator.data);
+        let instance = Instance(store.0.store_data_mut().insert(Some(data)));
+        store.0.push_component_instance(instance);
+        Ok(instance)
+    }
+}
diff --git a/crates/wasmtime/src/runtime/component/linker.rs b/crates/wasmtime/src/runtime/component/linker.rs
new file mode 100644
index 000000000000..267ad8d42985
--- /dev/null
+++ b/crates/wasmtime/src/runtime/component/linker.rs
@@ -0,0 +1,704 @@
+use crate::component::func::HostFunc;
+use crate::component::instance::RuntimeImport;
+use crate::component::matching::{InstanceType, TypeChecker};
+use crate::component::types;
+use crate::component::{
+    Component, ComponentNamedList, Instance, InstancePre, Lift, Lower, ResourceType, Val,
+};
+use crate::prelude::*;
+use crate::{AsContextMut, Engine, Module, StoreContextMut};
+use alloc::sync::Arc;
+use core::future::Future;
+use core::marker;
+use core::pin::Pin;
+use hashbrown::hash_map::HashMap;
+use wasmtime_environ::component::{NameMap, NameMapIntern};
+use wasmtime_environ::PrimaryMap;
+
+/// A type used to instantiate [`Component`]s.
+///
+/// This type is used to both link components together as well as supply host
+/// functionality to components. Values are defined in a [`Linker`] by their
+/// import name and then components are instantiated with a [`Linker`] using the
+/// names provided for name resolution of the component's imports.
+///
+/// # Names and Semver
+///
+/// Names defined in a [`Linker`] correspond to import names in the Component
+/// Model. Names in the Component Model are allowed to be semver-qualified, for
+/// example:
+///
+/// * `wasi:cli/stdout@0.2.0`
+/// * `wasi:http/types@0.2.0-rc-2023-10-25`
+/// * `my:custom/plugin@1.0.0-pre.2`
+///
+/// These version strings are taken into account when looking up names within a
+/// [`Linker`]. You're allowed to define any number of versions within a
+/// [`Linker`] still, for example you can define `a:b/c@0.2.0`, `a:b/c@0.2.1`,
+/// and `a:b/c@0.3.0` all at the same time.
+///
+/// Specifically though when names are looked up within a linker, for example
+/// during instantiation, semver-compatible names are automatically consulted.
+/// This means that if you define `a:b/c@0.2.1` in a [`Linker`] but a component
+/// imports `a:b/c@0.2.0` then that import will resolve to the `0.2.1` version.
+///
+/// This lookup behavior relies on hosts being well-behaved when using Semver,
+/// specifically that interfaces once defined are never changed. This reflects
+/// how Semver works at the Component Model layer, and it's assumed that if
+/// versions are present then hosts are respecting this.
+///
+/// Note that this behavior goes the other direction, too. If a component
+/// imports `a:b/c@0.2.1` and the host has provided `a:b/c@0.2.0` then that
+/// will also resolve correctly. This is because if an API was defined at 0.2.0
+/// and 0.2.1 then it must be the same API.
+///
+/// This behavior is intended to make it easier for hosts to upgrade WASI and
+/// for guests to upgrade WASI. So long as the actual "meat" of the
+/// functionality is defined then it should align correctly and components can
+/// be instantiated.
+pub struct Linker<T> {
+    engine: Engine,
+    strings: Strings,
+    map: NameMap<usize, Definition>,
+    path: Vec<usize>,
+    allow_shadowing: bool,
+    _marker: marker::PhantomData<fn() -> T>,
+}
+
+impl<T> Clone for Linker<T> {
+    fn clone(&self) -> Linker<T> {
+        Linker {
+            engine: self.engine.clone(),
+            strings: self.strings.clone(),
+            map: self.map.clone(),
+            path: self.path.clone(),
+            allow_shadowing: self.allow_shadowing,
+            _marker: self._marker,
+        }
+    }
+}
+
+#[derive(Clone, Default)]
+pub struct Strings {
+    string2idx: HashMap<Arc<str>, usize>,
+    strings: Vec<Arc<str>>,
+}
+
+/// Structure representing an "instance" being defined within a linker.
+///
+/// Instances do not need to be actual [`Instance`]s and instead are defined by
+/// a "bag of named items", so each [`LinkerInstance`] can further define items
+/// internally.
+pub struct LinkerInstance<'a, T> {
+    engine: &'a Engine,
+    path: &'a mut Vec<usize>,
+    path_len: usize,
+    strings: &'a mut Strings,
+    map: &'a mut NameMap<usize, Definition>,
+    allow_shadowing: bool,
+    _marker: marker::PhantomData<fn() -> T>,
+}
+
+#[derive(Clone)]
+pub(crate) enum Definition {
+    Instance(NameMap<usize, Definition>),
+    Func(Arc<HostFunc>),
+    Module(Module),
+    Resource(ResourceType, Arc<crate::func::HostFunc>),
+}
+
+impl<T> Linker<T> {
+    /// Creates a new linker for the [`Engine`] specified with no items defined
+    /// within it.
+    pub fn new(engine: &Engine) -> Linker<T> {
+        Linker {
+            engine: engine.clone(),
+            strings: Strings::default(),
+            map: NameMap::default(),
+            allow_shadowing: false,
+            path: Vec::new(),
+            _marker: marker::PhantomData,
+        }
+    }
+
+    /// Returns the [`Engine`] this is connected to.
+    pub fn engine(&self) -> &Engine {
+        &self.engine
+    }
+
+    /// Configures whether or not name-shadowing is allowed.
+    ///
+    /// By default name shadowing is not allowed and it's an error to redefine
+    /// the same name within a linker.
+    pub fn allow_shadowing(&mut self, allow: bool) -> &mut Self {
+        self.allow_shadowing = allow;
+        self
+    }
+
+    /// Returns the "root instance" of this linker, used to define names into
+    /// the root namespace.
+    pub fn root(&mut self) -> LinkerInstance<'_, T> {
+        LinkerInstance {
+            engine: &self.engine,
+            path: &mut self.path,
+            path_len: 0,
+            strings: &mut self.strings,
+            map: &mut self.map,
+            allow_shadowing: self.allow_shadowing,
+            _marker: self._marker,
+        }
+    }
+
+    /// Returns a builder for the named instance specified.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if `name` is already defined within the linker.
+    pub fn instance(&mut self, name: &str) -> Result<LinkerInstance<'_, T>> {
+        self.root().into_instance(name)
+    }
+
+    fn typecheck<'a>(&'a self, component: &'a Component) -> Result<TypeChecker<'a>> {
+        let mut cx = TypeChecker {
+            types: component.types(),
+            strings: &self.strings,
+            imported_resources: Default::default(),
+        };
+
+        // Walk over the component's list of import names and use that to lookup
+        // the definition within this linker that it corresponds to. When found
+        // perform a typecheck against the component's expected type.
+        let env_component = component.env_component();
+        for (_idx, (name, ty)) in env_component.import_types.iter() {
+            let import = self.map.get(name, &self.strings);
+            cx.definition(ty, import)
+                .with_context(|| format!("component imports {desc} `{name}`, but a matching implementation was not found in the linker", desc = ty.desc()))?;
+        }
+        Ok(cx)
+    }
+
+    /// Returns the [`types::Component`] corresponding to `component` with resource
+    /// types imported by it replaced using imports present in [`Self`].
+    pub fn substituted_component_type(&self, component: &Component) -> Result<types::Component> {
+        let cx = self.typecheck(&component)?;
+        Ok(types::Component::from(
+            component.ty(),
+            &InstanceType {
+                types: cx.types,
+                resources: &cx.imported_resources,
+            },
+        ))
+    }
+
+    /// Performs a "pre-instantiation" to resolve the imports of the
+    /// [`Component`] specified with the items defined within this linker.
+    ///
+    /// This method will perform as much work as possible short of actually
+    /// instantiating an instance. Internally this will use the names defined
+    /// within this linker to satisfy the imports of the [`Component`] provided.
+    /// Additionally this will perform type-checks against the component's
+    /// imports against all items defined within this linker.
+    ///
+    /// Note that unlike internally in components where subtyping at the
+    /// interface-types layer is supported this is not supported here. Items
+    /// defined in this linker must match the component's imports precisely.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if this linker doesn't define a name that the
+    /// `component` imports or if a name defined doesn't match the type of the
+    /// item imported by the `component` provided.
+    pub fn instantiate_pre(&self, component: &Component) -> Result<InstancePre<T>> {
+        self.typecheck(&component)?;
+
+        // Now that all imports are known to be defined and satisfied by this
+        // linker a list of "flat" import items (aka no instances) is created
+        // using the import map within the component created at
+        // component-compile-time.
+        let env_component = component.env_component();
+        let mut imports = PrimaryMap::with_capacity(env_component.imports.len());
+        for (idx, (import, names)) in env_component.imports.iter() {
+            let (root, _) = &env_component.import_types[*import];
+
+            // This is the flattening process where we go from a definition
+            // optionally through a list of exported names to get to the final
+            // item.
+            let mut cur = self.map.get(root, &self.strings).unwrap();
+            for name in names {
+                cur = match cur {
+                    Definition::Instance(map) => map.get(&name, &self.strings).unwrap(),
+                    _ => unreachable!(),
+                };
+            }
+            let import = match cur {
+                Definition::Module(m) => RuntimeImport::Module(m.clone()),
+                Definition::Func(f) => RuntimeImport::Func(f.clone()),
+                Definition::Resource(t, dtor) => RuntimeImport::Resource {
+                    ty: *t,
+                    _dtor: dtor.clone(),
+                    dtor_funcref: component.resource_drop_func_ref(dtor),
+                },
+
+                // This is guaranteed by the compilation process that "leaf"
+                // runtime imports are never instances.
+                Definition::Instance(_) => unreachable!(),
+            };
+            let i = imports.push(import);
+            assert_eq!(i, idx);
+        }
+        Ok(unsafe { InstancePre::new_unchecked(component.clone(), imports) })
+    }
+
+    /// Instantiates the [`Component`] provided into the `store` specified.
+    ///
+    /// This function will use the items defined within this [`Linker`] to
+    /// satisfy the imports of the [`Component`] provided as necessary. For more
+    /// information about this see [`Linker::instantiate_pre`] as well.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if this [`Linker`] doesn't define an import that
+    /// `component` requires or if it is of the wrong type. Additionally this
+    /// can return an error if something goes wrong during instantiation such as
+    /// a runtime trap or a runtime limit being exceeded.
+    pub fn instantiate(
+        &self,
+        store: impl AsContextMut<Data = T>,
+        component: &Component,
+    ) -> Result<Instance> {
+        assert!(
+            !store.as_context().async_support(),
+            "must use async instantiation when async support is enabled"
+        );
+        self.instantiate_pre(component)?.instantiate(store)
+    }
+
+    /// Instantiates the [`Component`] provided into the `store` specified.
+    ///
+    /// This is exactly like [`Linker::instantiate`] except for async stores.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if this [`Linker`] doesn't define an import that
+    /// `component` requires or if it is of the wrong type. Additionally this
+    /// can return an error if something goes wrong during instantiation such as
+    /// a runtime trap or a runtime limit being exceeded.
+    #[cfg(feature = "async")]
+    pub async fn instantiate_async(
+        &self,
+        store: impl AsContextMut<Data = T>,
+        component: &Component,
+    ) -> Result<Instance>
+    where
+        T: Send,
+    {
+        assert!(
+            store.as_context().async_support(),
+            "must use sync instantiation when async support is disabled"
+        );
+        self.instantiate_pre(component)?
+            .instantiate_async(store)
+            .await
+    }
+
+    /// Implement any imports of the given [`Component`] with a function which traps.
+    ///
+    /// By default a [`Linker`] will error when unknown imports are encountered when instantiating a [`Component`].
+    /// This changes this behavior from an instant error to a trap that will happen if the import is called.
+    pub fn define_unknown_imports_as_traps(&mut self, component: &Component) -> Result<()> {
+        use wasmtime_environ::component::ComponentTypes;
+        use wasmtime_environ::component::TypeDef;
+        // Recursively stub out all imports of the component with a function that traps.
+        fn stub_item<T>(
+            linker: &mut LinkerInstance<T>,
+            item_name: &str,
+            item_def: &TypeDef,
+            parent_instance: Option<&str>,
+            types: &ComponentTypes,
+        ) -> Result<()> {
+            // Skip if the item isn't an instance and has already been defined in the linker.
+            if !matches!(item_def, TypeDef::ComponentInstance(_)) && linker.get(item_name).is_some()
+            {
+                return Ok(());
+            }
+
+            match item_def {
+                TypeDef::ComponentFunc(_) => {
+                    let fully_qualified_name = parent_instance
+                        .map(|parent| format!("{parent}#{item_name}"))
+                        .unwrap_or_else(|| item_name.to_owned());
+                    linker.func_new(&item_name, move |_, _, _| {
+                        bail!("unknown import: `{fully_qualified_name}` has not been defined")
+                    })?;
+                }
+                TypeDef::ComponentInstance(i) => {
+                    let instance = &types[*i];
+                    let mut linker_instance = linker.instance(item_name)?;
+                    for (export_name, export) in instance.exports.iter() {
+                        stub_item(
+                            &mut linker_instance,
+                            export_name,
+                            export,
+                            Some(item_name),
+                            types,
+                        )?;
+                    }
+                }
+                TypeDef::Resource(_) => {
+                    let ty = crate::component::ResourceType::host::<()>();
+                    linker.resource(item_name, ty, |_, _| Ok(()))?;
+                }
+                TypeDef::Component(_) | TypeDef::Module(_) => {
+                    bail!("unable to define {} imports as traps", item_def.desc())
+                }
+                _ => {}
+            }
+            Ok(())
+        }
+
+        for (_, (import_name, import_type)) in &component.env_component().import_types {
+            stub_item(
+                &mut self.root(),
+                import_name,
+                import_type,
+                None,
+                component.types(),
+            )?;
+        }
+        Ok(())
+    }
+}
+
+impl<T> LinkerInstance<'_, T> {
+    fn as_mut(&mut self) -> LinkerInstance<'_, T> {
+        LinkerInstance {
+            engine: self.engine,
+            path: self.path,
+            path_len: self.path_len,
+            strings: self.strings,
+            map: self.map,
+            allow_shadowing: self.allow_shadowing,
+            _marker: self._marker,
+        }
+    }
+
+    /// Defines a new host-provided function into this [`Linker`].
+    ///
+    /// This method is used to give host functions to wasm components. The
+    /// `func` provided will be callable from linked components with the type
+    /// signature dictated by `Params` and `Return`. The `Params` is a tuple of
+    /// types that will come from wasm and `Return` is a value coming from the
+    /// host going back to wasm.
+    ///
+    /// Additionally the `func` takes a
+    /// [`StoreContextMut`](crate::StoreContextMut) as its first parameter.
+    ///
+    /// Note that `func` must be an `Fn` and must also be `Send + Sync +
+    /// 'static`. Shared state within a func is typically accessed with the `T`
+    /// type parameter from [`Store<T>`](crate::Store) which is accessible
+    /// through the leading [`StoreContextMut<'_, T>`](crate::StoreContextMut)
+    /// argument which can be provided to the `func` given here.
+    //
+    // TODO: needs more words and examples
+    pub fn func_wrap<F, Params, Return>(&mut self, name: &str, func: F) -> Result<()>
+    where
+        F: Fn(StoreContextMut<T>, Params) -> Result<Return> + Send + Sync + 'static,
+        Params: ComponentNamedList + Lift + 'static,
+        Return: ComponentNamedList + Lower + 'static,
+    {
+        self.insert(name, Definition::Func(HostFunc::from_closure(func)))?;
+        Ok(())
+    }
+
+    /// Defines a new host-provided async function into this [`Linker`].
+    ///
+    /// This is exactly like [`Self::func_wrap`] except it takes an async
+    /// host function.
+    #[cfg(feature = "async")]
+    pub fn func_wrap_async<Params, Return, F>(&mut self, name: &str, f: F) -> Result<()>
+    where
+        F: for<'a> Fn(
+                StoreContextMut<'a, T>,
+                Params,
+            ) -> Box<dyn Future<Output = Result<Return>> + Send + 'a>
+            + Send
+            + Sync
+            + 'static,
+        Params: ComponentNamedList + Lift + 'static,
+        Return: ComponentNamedList + Lower + 'static,
+    {
+        assert!(
+            self.engine.config().async_support,
+            "cannot use `func_wrap_async` without enabling async support in the config"
+        );
+        let ff = move |mut store: StoreContextMut<'_, T>, params: Params| -> Result<Return> {
+            let async_cx = store.as_context_mut().0.async_cx().expect("async cx");
+            let mut future = Pin::from(f(store.as_context_mut(), params));
+            unsafe { async_cx.block_on(future.as_mut()) }?
+        };
+        self.func_wrap(name, ff)
+    }
+
+    /// Define a new host-provided function using dynamically typed values.
+    ///
+    /// The `name` provided is the name of the function to define and the
+    /// `func` provided is the host-defined closure to invoke when this
+    /// function is called.
+    ///
+    /// This function is the "dynamic" version of defining a host function as
+    /// compared to [`LinkerInstance::func_wrap`]. With
+    /// [`LinkerInstance::func_wrap`] a function's type is statically known but
+    /// with this method the `func` argument's type isn't known ahead of time.
+    /// That means that `func` can be by imported component so long as it's
+    /// imported as a matching name.
+    ///
+    /// Type information will be available at execution time, however. For
+    /// example when `func` is invoked the second argument, a `&[Val]` list,
+    /// contains [`Val`] entries that say what type they are. Additionally the
+    /// third argument, `&mut [Val]`, is the expected number of results. Note
+    /// that the expected types of the results cannot be learned during the
+    /// execution of `func`. Learning that would require runtime introspection
+    /// of a component.
+    ///
+    /// Return values, stored in the third argument of `&mut [Val]`, are
+    /// type-checked at runtime to ensure that they have the appropriate type.
+    /// A trap will be raised if they do not have the right type.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use wasmtime::{Store, Engine};
+    /// use wasmtime::component::{Component, Linker, Val};
+    ///
+    /// # fn main() -> wasmtime::Result<()> {
+    /// let engine = Engine::default();
+    /// let component = Component::new(
+    ///     &engine,
+    ///     r#"
+    ///         (component
+    ///             (import "thunk" (func $thunk))
+    ///             (import "is-even" (func $is-even (param "x" u32) (result bool)))
+    ///
+    ///             (core module $m
+    ///                 (import "" "thunk" (func $thunk))
+    ///                 (import "" "is-even" (func $is-even (param i32) (result i32)))
+    ///
+    ///                 (func (export "run")
+    ///                     call $thunk
+    ///
+    ///                     (call $is-even (i32.const 1))
+    ///                     if unreachable end
+    ///
+    ///                     (call $is-even (i32.const 2))
+    ///                     i32.eqz
+    ///                     if unreachable end
+    ///                 )
+    ///             )
+    ///             (core func $thunk (canon lower (func $thunk)))
+    ///             (core func $is-even (canon lower (func $is-even)))
+    ///             (core instance $i (instantiate $m
+    ///                 (with "" (instance
+    ///                     (export "thunk" (func $thunk))
+    ///                     (export "is-even" (func $is-even))
+    ///                 ))
+    ///             ))
+    ///
+    ///             (func (export "run") (canon lift (core func $i "run")))
+    ///         )
+    ///     "#,
+    /// )?;
+    ///
+    /// let mut linker = Linker::<()>::new(&engine);
+    ///
+    /// // Sample function that takes no arguments.
+    /// linker.root().func_new("thunk", |_store, params, results| {
+    ///     assert!(params.is_empty());
+    ///     assert!(results.is_empty());
+    ///     println!("Look ma, host hands!");
+    ///     Ok(())
+    /// })?;
+    ///
+    /// // This function takes one argument and returns one result.
+    /// linker.root().func_new("is-even", |_store, params, results| {
+    ///     assert_eq!(params.len(), 1);
+    ///     let param = match params[0] {
+    ///         Val::U32(n) => n,
+    ///         _ => panic!("unexpected type"),
+    ///     };
+    ///
+    ///     assert_eq!(results.len(), 1);
+    ///     results[0] = Val::Bool(param % 2 == 0);
+    ///     Ok(())
+    /// })?;
+    ///
+    /// let mut store = Store::new(&engine, ());
+    /// let instance = linker.instantiate(&mut store, &component)?;
+    /// let run = instance.get_typed_func::<(), ()>(&mut store, "run")?;
+    /// run.call(&mut store, ())?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn func_new(
+        &mut self,
+        name: &str,
+        func: impl Fn(StoreContextMut<'_, T>, &[Val], &mut [Val]) -> Result<()> + Send + Sync + 'static,
+    ) -> Result<()> {
+        self.insert(name, Definition::Func(HostFunc::new_dynamic(func)))?;
+        Ok(())
+    }
+
+    /// Define a new host-provided async function using dynamic types.
+    ///
+    /// This is exactly like [`Self::func_new`] except it takes an async
+    /// host function.
+    #[cfg(feature = "async")]
+    pub fn func_new_async<F>(&mut self, name: &str, f: F) -> Result<()>
+    where
+        F: for<'a> Fn(
+                StoreContextMut<'a, T>,
+                &'a [Val],
+                &'a mut [Val],
+            ) -> Box<dyn Future<Output = Result<()>> + Send + 'a>
+            + Send
+            + Sync
+            + 'static,
+    {
+        assert!(
+            self.engine.config().async_support,
+            "cannot use `func_new_async` without enabling async support in the config"
+        );
+        let ff = move |mut store: StoreContextMut<'_, T>, params: &[Val], results: &mut [Val]| {
+            let async_cx = store.as_context_mut().0.async_cx().expect("async cx");
+            let mut future = Pin::from(f(store.as_context_mut(), params, results));
+            unsafe { async_cx.block_on(future.as_mut()) }?
+        };
+        self.func_new(name, ff)
+    }
+
+    /// Defines a [`Module`] within this instance.
+    ///
+    /// This can be used to provide a core wasm [`Module`] as an import to a
+    /// component. The [`Module`] provided is saved within the linker for the
+    /// specified `name` in this instance.
+    pub fn module(&mut self, name: &str, module: &Module) -> Result<()> {
+        self.insert(name, Definition::Module(module.clone()))?;
+        Ok(())
+    }
+
+    /// Defines a new resource of a given [`ResourceType`] in this linker.
+    ///
+    /// This function is used to specify resources defined in the host.
+    ///
+    /// The `name` argument is the name to define the resource within this
+    /// linker.
+    ///
+    /// The `dtor` provided is a destructor that will get invoked when an owned
+    /// version of this resource is destroyed from the guest. Note that this
+    /// destructor is not called when a host-owned resource is destroyed as it's
+    /// assumed the host knows how to handle destroying its own resources.
+    ///
+    /// The `dtor` closure is provided the store state as the first argument
+    /// along with the representation of the resource that was just destroyed.
+    ///
+    /// [`Resource<U>`]: crate::component::Resource
+    ///
+    /// # Errors
+    ///
+    /// The provided `dtor` closure returns an error if something goes wrong
+    /// when a guest calls the `dtor` to drop a `Resource<T>` such as
+    /// a runtime trap or a runtime limit being exceeded.
+    pub fn resource(
+        &mut self,
+        name: &str,
+        ty: ResourceType,
+        dtor: impl Fn(StoreContextMut<'_, T>, u32) -> Result<()> + Send + Sync + 'static,
+    ) -> Result<()> {
+        let dtor = Arc::new(crate::func::HostFunc::wrap_inner(
+            &self.engine,
+            move |mut cx: crate::Caller<'_, T>, (param,): (u32,)| dtor(cx.as_context_mut(), param),
+        ));
+        self.insert(name, Definition::Resource(ty, dtor))?;
+        Ok(())
+    }
+
+    /// Identical to [`Self::resource`], except that it takes an async destructor.
+    #[cfg(feature = "async")]
+    pub fn resource_async<F>(&mut self, name: &str, ty: ResourceType, dtor: F) -> Result<()>
+    where
+        F: for<'a> Fn(
+                StoreContextMut<'a, T>,
+                u32,
+            ) -> Box<dyn Future<Output = Result<()>> + Send + 'a>
+            + Send
+            + Sync
+            + 'static,
+    {
+        assert!(
+            self.engine.config().async_support,
+            "cannot use `resource_async` without enabling async support in the config"
+        );
+        let dtor = Arc::new(crate::func::HostFunc::wrap_inner(
+            &self.engine,
+            move |mut cx: crate::Caller<'_, T>, (param,): (u32,)| {
+                let async_cx = cx.as_context_mut().0.async_cx().expect("async cx");
+                let mut future = Pin::from(dtor(cx.as_context_mut(), param));
+                match unsafe { async_cx.block_on(future.as_mut()) } {
+                    Ok(Ok(())) => Ok(()),
+                    Ok(Err(trap)) | Err(trap) => Err(trap),
+                }
+            },
+        ));
+        self.insert(name, Definition::Resource(ty, dtor))?;
+        Ok(())
+    }
+
+    /// Defines a nested instance within this instance.
+    ///
+    /// This can be used to describe arbitrarily nested levels of instances
+    /// within a linker to satisfy nested instance exports of components.
+    pub fn instance(&mut self, name: &str) -> Result<LinkerInstance<'_, T>> {
+        self.as_mut().into_instance(name)
+    }
+
+    /// Same as [`LinkerInstance::instance`] except with different lifetime
+    /// parameters.
+    pub fn into_instance(mut self, name: &str) -> Result<Self> {
+        let name = self.insert(name, Definition::Instance(NameMap::default()))?;
+        self.map = match self.map.raw_get_mut(&name) {
+            Some(Definition::Instance(map)) => map,
+            _ => unreachable!(),
+        };
+        self.path.truncate(self.path_len);
+        self.path.push(name);
+        self.path_len += 1;
+        Ok(self)
+    }
+
+    fn insert(&mut self, name: &str, item: Definition) -> Result<usize> {
+        self.map
+            .insert(name, self.strings, self.allow_shadowing, item)
+    }
+
+    fn get(&self, name: &str) -> Option<&Definition> {
+        self.map.get(name, self.strings)
+    }
+}
+
+impl NameMapIntern for Strings {
+    type Key = usize;
+
+    fn intern(&mut self, string: &str) -> usize {
+        if let Some(idx) = self.string2idx.get(string) {
+            return *idx;
+        }
+        let string: Arc<str> = string.into();
+        let idx = self.strings.len();
+        self.strings.push(string.clone());
+        self.string2idx.insert(string, idx);
+        idx
+    }
+
+    fn lookup(&self, string: &str) -> Option<usize> {
+        self.string2idx.get(string).cloned()
+    }
+}
diff --git a/crates/wasmtime/src/runtime/component/matching.rs b/crates/wasmtime/src/runtime/component/matching.rs
new file mode 100644
index 000000000000..4222daa6dc62
--- /dev/null
+++ b/crates/wasmtime/src/runtime/component/matching.rs
@@ -0,0 +1,216 @@
+use crate::component::func::HostFunc;
+use crate::component::linker::{Definition, Strings};
+use crate::component::ResourceType;
+use crate::prelude::*;
+use crate::runtime::vm::component::ComponentInstance;
+use crate::types::matching;
+use crate::Module;
+use alloc::sync::Arc;
+use core::any::Any;
+use wasmtime_environ::component::{
+    ComponentTypes, NameMap, ResourceIndex, TypeComponentInstance, TypeDef, TypeFuncIndex,
+    TypeModule, TypeResourceTableIndex,
+};
+use wasmtime_environ::PrimaryMap;
+
+pub struct TypeChecker<'a> {
+    pub types: &'a Arc<ComponentTypes>,
+    pub strings: &'a Strings,
+    pub imported_resources: Arc<PrimaryMap<ResourceIndex, ResourceType>>,
+}
+
+#[derive(Copy, Clone)]
+#[doc(hidden)]
+pub struct InstanceType<'a> {
+    pub types: &'a Arc<ComponentTypes>,
+    pub resources: &'a Arc<PrimaryMap<ResourceIndex, ResourceType>>,
+}
+
+impl TypeChecker<'_> {
+    pub(crate) fn definition(
+        &mut self,
+        expected: &TypeDef,
+        actual: Option<&Definition>,
+    ) -> Result<()> {
+        match *expected {
+            TypeDef::Module(t) => match actual {
+                Some(Definition::Module(actual)) => self.module(&self.types[t], actual),
+                Some(actual) => bail!("expected module found {}", actual.desc()),
+                None => bail!("module implementation is missing"),
+            },
+            TypeDef::ComponentInstance(t) => match actual {
+                Some(Definition::Instance(actual)) => self.instance(&self.types[t], Some(actual)),
+                None => self.instance(&self.types[t], None),
+                Some(actual) => bail!("expected instance found {}", actual.desc()),
+            },
+            TypeDef::ComponentFunc(t) => match actual {
+                Some(Definition::Func(actual)) => self.func(t, actual),
+                Some(actual) => bail!("expected function found {}", actual.desc()),
+                None => bail!("function implementation is missing"),
+            },
+            TypeDef::Component(_) => match actual {
+                Some(actual) => bail!("expected component found {}", actual.desc()),
+                None => bail!("component implementation is missing"),
+            },
+            TypeDef::Interface(_) => match actual {
+                Some(actual) => bail!("expected type found {}", actual.desc()),
+                None => bail!("type implementation is missing"),
+            },
+
+            TypeDef::Resource(i) => {
+                let i = self.types[i].ty;
+                let actual = match actual {
+                    Some(Definition::Resource(actual, _dtor)) => actual,
+
+                    // If a resource is imported yet nothing was supplied then
+                    // that's only successful if the resource has itself
+                    // already been defined. If it's already defined then that
+                    // means that this is an `(eq ...)` import which is not
+                    // required to be satisfied via `Linker` definitions in the
+                    // Wasmtime API.
+                    None if self.imported_resources.get(i).is_some() => return Ok(()),
+
+                    Some(actual) => bail!("expected resource found {}", actual.desc()),
+                    None => bail!("resource implementation is missing"),
+                };
+
+                match self.imported_resources.get(i) {
+                    // If `i` hasn't been pushed onto `imported_resources` yet
+                    // then that means that it's the first time a new resource
+                    // was introduced, so record the type of this resource.  It
+                    // should always be the case that the next index assigned
+                    // is equal to `i` since types should be checked in the
+                    // same order they were assigned into the `Component` type.
+                    //
+                    // Note the `get_mut` here which is expected to always
+                    // succeed since `imported_resources` has not yet been
+                    // cloned.
+                    None => {
+                        let resources = Arc::get_mut(&mut self.imported_resources).unwrap();
+                        let id = resources.push(*actual);
+                        assert_eq!(id, i);
+                    }
+
+                    // If `i` has been defined, however, then that means that
+                    // this is an `(eq ..)` bounded type imported because it's
+                    // referring to a previously defined type.  In this
+                    // situation it's not required to provide a type import but
+                    // if it's supplied then it must be equal. In this situation
+                    // it's supplied, so test for equality.
+                    Some(expected) => {
+                        if expected != actual {
+                            bail!("mismatched resource types");
+                        }
+                    }
+                }
+                Ok(())
+            }
+
+            // not possible for valid components to import
+            TypeDef::CoreFunc(_) => unreachable!(),
+        }
+    }
+
+    fn module(&self, expected: &TypeModule, actual: &Module) -> Result<()> {
+        let actual_types = actual.types();
+        let actual = actual.env_module();
+
+        // Every export that is expected should be in the actual module we have
+        for (name, expected) in expected.exports.iter() {
+            let idx = actual
+                .exports
+                .get(name)
+                .ok_or_else(|| anyhow!("module export `{name}` not defined"))?;
+            let actual = actual.type_of(*idx);
+            matching::entity_ty(expected, self.types.module_types(), &actual, actual_types)
+                .with_context(|| format!("module export `{name}` has the wrong type"))?;
+        }
+
+        // Note the opposite order of checks here. Every import that the actual
+        // module expects should be imported by the expected module since the
+        // expected module has the set of items given to the actual module.
+        // Additionally the "matches" check is inverted here.
+        for (module, name, actual) in actual.imports() {
+            // TODO: shouldn't need a `.to_string()` here ideally
+            let expected = expected
+                .imports
+                .get(&(module.to_string(), name.to_string()))
+                .ok_or_else(|| anyhow!("module import `{module}::{name}` not defined"))?;
+            matching::entity_ty(&actual, actual_types, expected, self.types.module_types())
+                .with_context(|| format!("module import `{module}::{name}` has the wrong type"))?;
+        }
+        Ok(())
+    }
+
+    fn instance(
+        &mut self,
+        expected: &TypeComponentInstance,
+        actual: Option<&NameMap<usize, Definition>>,
+    ) -> Result<()> {
+        // Like modules, every export in the expected type must be present in
+        // the actual type. It's ok, though, to have extra exports in the actual
+        // type.
+        for (name, expected) in expected.exports.iter() {
+            // Interface types may be exported from a component in order to give them a name, but
+            // they don't have a definition in the sense that this search is interested in, so
+            // ignore them.
+            if let TypeDef::Interface(_) = expected {
+                continue;
+            }
+            let actual = actual.and_then(|map| map.get(name, self.strings));
+            self.definition(expected, actual)
+                .with_context(|| format!("instance export `{name}` has the wrong type"))?;
+        }
+        Ok(())
+    }
+
+    fn func(&self, expected: TypeFuncIndex, actual: &HostFunc) -> Result<()> {
+        let instance_type = InstanceType {
+            types: self.types,
+            resources: &self.imported_resources,
+        };
+        actual.typecheck(expected, &instance_type)
+    }
+}
+
+impl Definition {
+    fn desc(&self) -> &'static str {
+        match self {
+            Definition::Module(_) => "module",
+            Definition::Func(_) => "func",
+            Definition::Instance(_) => "instance",
+            Definition::Resource(..) => "resource",
+        }
+    }
+}
+
+impl<'a> InstanceType<'a> {
+    pub fn new(instance: &'a ComponentInstance) -> InstanceType<'a> {
+        InstanceType {
+            types: instance.component_types(),
+            resources: downcast_arc_ref(instance.resource_types()),
+        }
+    }
+
+    pub fn resource_type(&self, index: TypeResourceTableIndex) -> ResourceType {
+        let index = self.types[index].ty;
+        self.resources
+            .get(index)
+            .copied()
+            .unwrap_or_else(|| ResourceType::uninstantiated(&self.types, index))
+    }
+}
+
+/// Small helper method to downcast an `Arc` borrow into a borrow of a concrete
+/// type within the `Arc`.
+///
+/// Note that this is different than `downcast_ref` which projects out `&T`
+/// where here we want `&Arc<T>`.
+fn downcast_arc_ref<T: 'static>(arc: &Arc<dyn Any + Send + Sync>) -> &Arc<T> {
+    // First assert that the payload of the `Any` is indeed a `T`
+    let _ = arc.downcast_ref::<T>();
+
+    // Next do an unsafe pointer cast to convert the `Any` into `T` which should
+    // be safe given the above check.
+    unsafe { &*(arc as *const Arc<dyn Any + Send + Sync> as *const Arc<T>) }
+}
diff --git a/crates/wasmtime/src/runtime/component/mod.rs b/crates/wasmtime/src/runtime/component/mod.rs
new file mode 100644
index 000000000000..93f85932021b
--- /dev/null
+++ b/crates/wasmtime/src/runtime/component/mod.rs
@@ -0,0 +1,665 @@
+//! # Embedding API for the Component Model
+//!
+//! This module contains the embedding API for the [Component Model] in
+//! Wasmtime. This module requires the `component-model` feature to be enabled,
+//! which is enabled by default. The embedding API here is mirrored after the
+//! core wasm embedding API at the crate root and is intended to have the same
+//! look-and-feel while handling concepts of the component model.
+//!
+//! [Component Model]: https://component-model.bytecodealliance.org
+//!
+//! The component model is a broad topic which can't be explained here fully, so
+//! it's recommended to read over individual items' documentation to see more
+//! about the capabilities of the embedding API. At a high-level, however,
+//! perhaps the most interesting items in this module are:
+//!
+//! * [`Component`] - a compiled component ready to be instantiated. Similar to
+//!   a [`Module`](crate::Module) for core wasm.
+//!
+//! * [`Linker`] - a component-style location for defining host functions. This
+//!   is not the same as [`wasmtime::Linker`](crate::Linker) for core wasm
+//!   modules.
+//!
+//! * [`bindgen!`] - a macro to generate Rust bindings for a [WIT] [world]. This
+//!   maps all WIT types into Rust automatically and generates traits for
+//!   embedders to implement.
+//!
+//! [WIT]: https://component-model.bytecodealliance.org/design/wit.html
+//! [world]: https://component-model.bytecodealliance.org/design/worlds.html
+//!
+//! Embedders of the component model will typically start by defining their API
+//! in [WIT]. This describes what will be available to guests and what needs to
+//! be provided to the embedder by the guest. This [`world`][world] that was
+//! created is then fed into [`bindgen!`] to generate types and traits for the
+//! embedder to use. The embedder then implements these traits, adds
+//! functionality via the generated `add_to_linker` method (see [`bindgen!`] for
+//! more info), and then instantiates/executes a component.
+//!
+//! It's recommended to read over the [documentation for the Component
+//! Model][Component Model] to get an overview about how to build components
+//! from various languages.
+//!
+//! ## Example Usage
+//!
+//! Imagine you have the following WIT package definition in a file called world.wit
+//! along with a component (my_component.wasm) that targets `my-world`:
+//!
+//! ```text,ignore
+//! package component:my-package;
+//!
+//! world my-world {
+//!     import name: func() -> string;
+//!     export greet: func() -> string;
+//! }
+//! ```
+//!
+//! You can instantiate and call the component like so:
+//!
+//! ```
+//! fn main() -> wasmtime::Result<()> {
+//!     #   if true { return Ok(()) }
+//!     // Instantiate the engine and store
+//!     let engine = wasmtime::Engine::default();
+//!     let mut store = wasmtime::Store::new(&engine, ());
+//!
+//!     // Load the component from disk
+//!     let bytes = std::fs::read("my_component.wasm")?;
+//!     let component = wasmtime::component::Component::new(&engine, bytes)?;
+//!
+//!     // Configure the linker
+//!     let mut linker = wasmtime::component::Linker::new(&engine);
+//!     // The component expects one import `name` that
+//!     // takes no params and returns a string
+//!     linker
+//!         .root()
+//!         .func_wrap("name", |_store, _params: ()| {
+//!             Ok((String::from("Alice"),))
+//!         })?;
+//!
+//!     // Instantiate the component
+//!     let instance = linker.instantiate(&mut store, &component)?;
+//!
+//!     // Call the `greet` function
+//!     let func = instance.get_func(&mut store, "greet").expect("greet export not found");
+//!     let mut result = [wasmtime::component::Val::String("".into())];
+//!     func.call(&mut store, &[], &mut result)?;
+//!
+//!     // This should print out `Greeting: [String("Hello, Alice!")]`
+//!     println!("Greeting: {:?}", result);
+//!
+//!     Ok(())
+//! }
+//! ```
+//!
+//! Manually configuring the linker and calling untyped component exports is
+//! a bit tedious and error prone. The [`bindgen!`] macro can be used to
+//! generate bindings eliminating much of this boilerplate.
+//!
+//! See the docs for [`bindgen!`] for more information on how to use it.
+
+// rustdoc appears to lie about a warning above, so squelch it for now.
+#![allow(rustdoc::redundant_explicit_links)]
+
+mod component;
+mod func;
+mod instance;
+mod linker;
+mod matching;
+mod resource_table;
+mod resources;
+mod storage;
+mod store;
+pub mod types;
+mod values;
+pub use self::component::{Component, ComponentExportIndex};
+pub use self::func::{
+    ComponentNamedList, ComponentType, Func, Lift, Lower, TypedFunc, WasmList, WasmStr,
+};
+pub use self::instance::{Instance, InstanceExportLookup, InstancePre};
+pub use self::linker::{Linker, LinkerInstance};
+pub use self::resource_table::{ResourceTable, ResourceTableError};
+pub use self::resources::{Resource, ResourceAny};
+pub use self::types::{ResourceType, Type};
+pub use self::values::Val;
+
+pub(crate) use self::resources::HostResourceData;
+
+// These items are expected to be used by an eventual
+// `#[derive(ComponentType)]`, they are not part of Wasmtime's API stability
+// guarantees
+#[doc(hidden)]
+pub mod __internal {
+    pub use super::func::{
+        bad_type_info, format_flags, lower_payload, typecheck_enum, typecheck_flags,
+        typecheck_record, typecheck_variant, ComponentVariant, LiftContext, LowerContext, Options,
+    };
+    pub use super::matching::InstanceType;
+    pub use crate::map_maybe_uninit;
+    pub use crate::store::StoreOpaque;
+    pub use crate::MaybeUninitExt;
+    pub use alloc::boxed::Box;
+    pub use alloc::string::String;
+    pub use alloc::vec::Vec;
+    pub use anyhow;
+    #[cfg(feature = "async")]
+    pub use async_trait::async_trait;
+    pub use core::mem::transmute;
+    pub use wasmtime_environ;
+    pub use wasmtime_environ::component::{CanonicalAbiInfo, ComponentTypes, InterfaceType};
+}
+
+pub(crate) use self::store::ComponentStoreData;
+
+/// Generate bindings for a [WIT world].
+///
+/// [WIT world]: https://component-model.bytecodealliance.org/design/worlds.html
+/// [WIT package]: https://component-model.bytecodealliance.org/design/packages.html
+///
+/// This macro ingests a [WIT world] and will generate all the necessary
+/// bindings for instantiating components that ascribe to the `world`. This
+/// provides a higher-level representation of working with a component than the
+/// raw [`Instance`] type which must be manually-type-checked and manually have
+/// its imports provided via the [`Linker`] type.
+///
+/// # Examples
+///
+/// Examples for this macro can be found in the [`bindgen_examples`] module
+/// documentation. That module has a submodule-per-example which includes the
+/// source code, with WIT, used to generate the structures along with the
+/// generated code itself in documentation.
+///
+/// # Debugging and Exploring
+///
+/// If you need to debug the output of `bindgen!` you can try using the
+/// `WASMTIME_DEBUG_BINDGEN=1` environment variable. This will write the
+/// generated code to a file on disk so rustc can produce better error messages
+/// against the actual generated source instead of the macro invocation itself.
+/// This additionally can enable opening up the generated code in an editor and
+/// exploring it (through an error message).
+///
+/// The generated bindings can additionally be explored with `cargo doc` to see
+/// what's generated. It's also recommended to browse the [`bindgen_examples`]
+/// for example generated structures and example generated code.
+///
+/// # Syntax
+///
+/// This procedural macro accepts a few different syntaxes. The primary purpose
+/// of this macro is to locate a WIT package, parse it, and then extract a
+/// `world` from the parsed package. There are then codegen-specific options to
+/// the bindings themselves which can additionally be specified.
+///
+/// Usage of this macro looks like:
+///
+/// ```rust
+/// # macro_rules! bindgen { ($($t:tt)*) => () }
+/// // Parse the `wit/` folder adjacent to this crate's `Cargo.toml` and look
+/// // for a single `world` in it. There must be exactly one for this to
+/// // succeed.
+/// bindgen!();
+///
+/// // Parse the `wit/` folder adjacent to this crate's `Cargo.toml` and look
+/// // for the world `foo` contained in it.
+/// bindgen!("foo");
+///
+/// // Parse the folder `other/wit/folder` adjacent to `Cargo.toml`.
+/// bindgen!(in "other/wit/folder");
+/// bindgen!("foo" in "other/wit/folder");
+///
+/// // Parse the file `foo.wit` as a single-file WIT package with no
+/// // dependencies.
+/// bindgen!("foo" in "foo.wit");
+///
+/// // Specify a suite of options to the bindings generation, documented below
+/// bindgen!({
+///     world: "foo",
+///     path: "other/path/to/wit",
+///     // ...
+/// });
+/// ```
+///
+/// # Options Reference
+///
+/// This is an example listing of all options that this macro supports along
+/// with documentation for each option and example syntax for each option.
+///
+/// ```rust
+/// # macro_rules! bindgen { ($($t:tt)*) => () }
+/// bindgen!({
+///     world: "foo", // not needed if `path` has one `world`
+///
+///     // same as in `bindgen!(in "other/wit/folder")
+///     path: "other/wit/folder",
+///
+///     // Instead of `path` the WIT document can be provided inline if
+///     // desired.
+///     inline: "
+///         package my:inline;
+///
+///         world foo {
+///             // ...
+///         }
+///     ",
+///
+///     // Add calls to `tracing::span!` before each import or export is called
+///     // to log arguments and return values.
+///     //
+///     // This option defaults to `false`.
+///     tracing: true,
+///
+///     // Imports will be async functions through #[async_trait] and exports
+///     // are also invoked as async functions. Requires `Config::async_support`
+///     // to be `true`.
+///     //
+///     // Note that this is only async for the host as the guest will still
+///     // appear as if it's invoking blocking functions.
+///     //
+///     // This option defaults to `false`.
+///     async: true,
+///
+///     // Alternative mode of async configuration where this still implies
+///     // async instantiation happens, for example, but more control is
+///     // provided over which imports are async and which aren't.
+///     //
+///     // Note that in this mode all exports are still async.
+///     async: {
+///         // All imports are async except for functions with these names
+///         except_imports: ["foo", "bar"],
+///
+///         // All imports are synchronous except for functions with these names
+///         //
+///         // Note that this key cannot be specified with `except_imports`,
+///         // only one or the other is accepted.
+///         only_imports: ["foo", "bar"],
+///     },
+///
+///     // This option is used to indicate whether imports can trap.
+///     //
+///     // Imports that may trap have their return types wrapped in
+///     // `wasmtime::Result<T>` where the `Err` variant indicates that a
+///     // trap will be raised in the guest.
+///     //
+///     // By default imports cannot trap and the return value is the return
+///     // value from the WIT bindings itself. This value can be set to `true`
+///     // to indicate that any import can trap. This value can also be set to
+///     // an array-of-strings to indicate that only a set list of imports
+///     // can trap.
+///     trappable_imports: false,             // no imports can trap (default)
+///     // trappable_imports: true,           // all imports can trap
+///     // trappable_imports: ["foo", "bar"], // only these can trap
+///
+///     // This can be used to translate WIT return values of the form
+///     // `result<T, error-type>` into `Result<T, RustErrorType>` in Rust.
+///     // Users must define `RustErrorType` and the `Host` trait for the
+///     // interface which defines `error-type` will have a method
+///     // called `convert_error_type` which converts `RustErrorType`
+///     // into `wasmtime::Result<ErrorType>`. This conversion can either
+///     // return the raw WIT error (`ErrorType` here) or a trap.
+///     //
+///     // By default this option is not specified. This option only takes
+///     // effect when `trappable_imports` is set for some imports.
+///     trappable_error_type: {
+///         "wasi:io/streams/stream-error" => RustErrorType,
+///     },
+///
+///     // All generated bindgen types are "owned" meaning types like `String`
+///     // are used instead of `&str`, for example. This is the default and
+///     // ensures that the same type used in both imports and exports uses the
+///     // same generated type.
+///     ownership: Owning,
+///
+///     // Alternative to `Owning` above where borrowed types attempt to be used
+///     // instead. The `duplicate_if_necessary` configures whether duplicate
+///     // Rust types will be generated for the same WIT type if necessary, for
+///     // example when a type is used both as an import and an export.
+///     ownership: Borrowing {
+///         duplicate_if_necessary: true
+///     },
+///
+///     // Restrict the code generated to what's needed for the interface
+///     // imports in the inlined WIT document fragment.
+///     interfaces: "
+///         import wasi:cli/command;
+///     ",
+///
+///     // Remap imported interfaces or resources to types defined in Rust
+///     // elsewhere. Using this option will prevent any code from being
+///     // generated for interfaces mentioned here. Resources named here will
+///     // not have a type generated to represent the resource.
+///     //
+///     // Interfaces mapped with this option should be previously generated
+///     // with an invocation of this macro. Resources need to be mapped to a
+///     // Rust type name.
+///     with: {
+///         // This can be used to indicate that entire interfaces have
+///         // bindings generated elsewhere with a path pointing to the
+///         // bindinges-generated module.
+///         "wasi:random/random": wasmtime_wasi::bindings::random::random,
+///
+///         // Similarly entire packages can also be specified.
+///         "wasi:cli": wasmtime_wasi::bindings::cli,
+///
+///         // Or, if applicable, entire namespaces can additionally be mapped.
+///         "wasi": wasmtime_wasi::bindings,
+///
+///         // Versions are supported if multiple versions are in play:
+///         "wasi:http/types@0.2.0": wasmtime_wasi_http::bindings::http::types,
+///         "wasi:http@0.2.0": wasmtime_wasi_http::bindings::http,
+///
+///         // The `with` key can also be used to specify the `T` used in
+///         // import bindings of `Resource<T>`. This can be done to configure
+///         // which typed resource shows up in generated bindings and can be
+///         // useful when working with the typed methods of `ResourceTable`.
+///         "wasi:filesystem/types/descriptor": MyDescriptorType,
+///     },
+///
+///     // Additional derive attributes to include on generated types (structs or enums).
+///     //
+///     // These are deduplicated and attached in a deterministic order.
+///     additional_derives: [
+///         Hash,
+///         serde::Deserialize,
+///         serde::Serialize,
+///     ],
+///
+///     // A list of WIT "features" to enable when parsing the WIT document that
+///     // this bindgen macro matches. WIT features are all disabled by default
+///     // and must be opted-in-to if source level features are used.
+///     //
+///     // This option defaults to an empty array.
+///     features: ["foo", "bar", "baz"],
+///
+///     // An niche configuration option to require that the `T` in `Store<T>`
+///     // is always `Send` in the generated bindings. Typically not needed
+///     // but if synchronous bindings depend on asynchronous bindings using
+///     // the `with` key then this may be required.
+///     require_store_data_send: false,
+///
+///     // If the `wasmtime` crate is depended on at a nonstandard location
+///     // or is renamed then this is the path to the root of the `wasmtime`
+///     // crate. Much of the generated code needs to refer to `wasmtime` so
+///     // this should be used if the `wasmtime` name is not wasmtime itself.
+///     //
+///     // By default this is `wasmtime`.
+///     wasmtime_crate: path::to::wasmtime,
+///
+///     // This is an in-source alternative to using `WASMTIME_DEBUG_BINDGEN`.
+///     //
+///     // Note that if this option is specified then the compiler will always
+///     // recompile your bindings. Cargo records the start time of when rustc
+///     // is spawned by this will write a file during compilation. To Cargo
+///     // that looks like a file was modified after `rustc` was spawned,
+///     // so Cargo will always think your project is "dirty" and thus always
+///     // recompile it. Recompiling will then overwrite the file again,
+///     // starting the cycle anew. This is only recommended for debugging.
+///     //
+///     // This option defaults to false.
+///     include_generated_code_from_file: false,
+/// });
+/// ```
+pub use wasmtime_component_macro::bindgen;
+
+/// Derive macro to generate implementations of the [`ComponentType`] trait.
+///
+/// This derive macro can be applied to `struct` and `enum` definitions and is
+/// used to bind either a `record`, `enum`, or `variant` in the component model.
+///
+/// Note you might be looking for [`bindgen!`] rather than this macro as that
+/// will generate the entire type for you rather than just a trait
+/// implementation.
+///
+/// This macro supports a `#[component]` attribute which is used to customize
+/// how the type is bound to the component model. A top-level `#[component]`
+/// attribute is required to specify either `record`, `enum`, or `variant`.
+///
+/// ## Records
+///
+/// `record`s in the component model correspond to `struct`s in Rust. An example
+/// is:
+///
+/// ```rust
+/// use wasmtime::component::ComponentType;
+///
+/// #[derive(ComponentType)]
+/// #[component(record)]
+/// struct Color {
+///     r: u8,
+///     g: u8,
+///     b: u8,
+/// }
+/// ```
+///
+/// which corresponds to the WIT type:
+///
+/// ```wit
+/// record color {
+///     r: u8,
+///     g: u8,
+///     b: u8,
+/// }
+/// ```
+///
+/// Note that the name `Color` here does not need to match the name in WIT.
+/// That's purely used as a name in Rust of what to refer to. The field names
+/// must match that in WIT, however. Field names can be customized with the
+/// `#[component]` attribute though.
+///
+/// ```rust
+/// use wasmtime::component::ComponentType;
+///
+/// #[derive(ComponentType)]
+/// #[component(record)]
+/// struct VerboseColor {
+///     #[component(name = "r")]
+///     red: u8,
+///     #[component(name = "g")]
+///     green: u8,
+///     #[component(name = "b")]
+///     blue: u8,
+/// }
+/// ```
+///
+/// Also note that field ordering is significant at this time and must match
+/// WIT.
+///
+/// ## Variants
+///
+/// `variant`s in the component model correspond to a subset of shapes of a Rust
+/// `enum`. Variants in the component model have a single optional payload type
+/// which means that not all Rust `enum`s correspond to component model
+/// `variant`s. An example variant is:
+///
+/// ```rust
+/// use wasmtime::component::ComponentType;
+///
+/// #[derive(ComponentType)]
+/// #[component(variant)]
+/// enum Filter {
+///     #[component(name = "none")]
+///     None,
+///     #[component(name = "all")]
+///     All,
+///     #[component(name = "some")]
+///     Some(Vec<String>),
+/// }
+/// ```
+///
+/// which corresponds to the WIT type:
+///
+/// ```wit
+/// variant filter {
+///     none,
+///     all,
+///     some(list<string>),
+/// }
+/// ```
+///
+/// The `variant` style of derive allows an optional payload on Rust `enum`
+/// variants but it must be a single unnamed field. Variants of the form `Foo(T,
+/// U)` or `Foo { name: T }` are not supported at this time.
+///
+/// Note that the order of variants in Rust must match the order of variants in
+/// WIT. Additionally it's likely that `#[component(name = "...")]` is required
+/// on all Rust `enum` variants because the name currently defaults to the Rust
+/// name which is typically UpperCamelCase whereas WIT uses kebab-case.
+///
+/// ## Enums
+///
+/// `enum`s in the component model correspond to C-like `enum`s in Rust. Note
+/// that a component model `enum` does not allow any payloads so the Rust `enum`
+/// must additionally have no payloads.
+///
+/// ```rust
+/// use wasmtime::component::ComponentType;
+///
+/// #[derive(ComponentType)]
+/// #[component(enum)]
+/// #[repr(u8)]
+/// enum Setting {
+///     #[component(name = "yes")]
+///     Yes,
+///     #[component(name = "no")]
+///     No,
+///     #[component(name = "auto")]
+///     Auto,
+/// }
+/// ```
+///
+/// which corresponds to the WIT type:
+///
+/// ```wit
+/// enum setting {
+///     yes,
+///     no,
+///     auto,
+/// }
+/// ```
+///
+/// Note that the order of variants in Rust must match the order of variants in
+/// WIT. Additionally it's likely that `#[component(name = "...")]` is required
+/// on all Rust `enum` variants because the name currently defaults to the Rust
+/// name which is typically UpperCamelCase whereas WIT uses kebab-case.
+pub use wasmtime_component_macro::ComponentType;
+
+/// A derive macro for generating implementations of the [`Lift`] trait.
+///
+/// This macro will likely be applied in conjunction with the
+/// [`#[derive(ComponentType)]`](macro@ComponentType) macro along the lines
+/// of `#[derive(ComponentType, Lift)]`. This trait enables reading values from
+/// WebAssembly.
+///
+/// Note you might be looking for [`bindgen!`] rather than this macro as that
+/// will generate the entire type for you rather than just a trait
+/// implementation.
+///
+/// At this time this derive macro has no configuration.
+///
+/// ## Examples
+///
+/// ```rust
+/// use wasmtime::component::{ComponentType, Lift};
+///
+/// #[derive(ComponentType, Lift)]
+/// #[component(record)]
+/// struct Color {
+///     r: u8,
+///     g: u8,
+///     b: u8,
+/// }
+/// ```
+pub use wasmtime_component_macro::Lift;
+
+/// A derive macro for generating implementations of the [`Lower`] trait.
+///
+/// This macro will likely be applied in conjunction with the
+/// [`#[derive(ComponentType)]`](macro@ComponentType) macro along the lines
+/// of `#[derive(ComponentType, Lower)]`. This trait enables passing values to
+/// WebAssembly.
+///
+/// Note you might be looking for [`bindgen!`] rather than this macro as that
+/// will generate the entire type for you rather than just a trait
+/// implementation.
+///
+/// At this time this derive macro has no configuration.
+///
+/// ## Examples
+///
+/// ```rust
+/// use wasmtime::component::{ComponentType, Lower};
+///
+/// #[derive(ComponentType, Lower)]
+/// #[component(record)]
+/// struct Color {
+///     r: u8,
+///     g: u8,
+///     b: u8,
+/// }
+/// ```
+pub use wasmtime_component_macro::Lower;
+
+/// A macro to generate a Rust type corresponding to WIT `flags`
+///
+/// This macro generates a type that implements the [`ComponentType`], [`Lift`],
+/// and [`Lower`] traits. The generated Rust type corresponds to the `flags`
+/// type in WIT.
+///
+/// Example usage of this looks like:
+///
+/// ```rust
+/// use wasmtime::component::flags;
+///
+/// flags! {
+///     Permissions {
+///         #[component(name = "read")]
+///         const READ;
+///         #[component(name = "write")]
+///         const WRITE;
+///         #[component(name = "execute")]
+///         const EXECUTE;
+///     }
+/// }
+///
+/// fn validate_permissions(permissions: &mut Permissions) {
+///     if permissions.contains(Permissions::EXECUTE | Permissions::WRITE) {
+///         panic!("cannot enable both writable and executable at the same time");
+///     }
+///
+///     if permissions.contains(Permissions::READ) {
+///         panic!("permissions must at least contain read");
+///     }
+/// }
+/// ```
+///
+/// which corresponds to the WIT type:
+///
+/// ```wit
+/// flags permissions {
+///     read,
+///     write,
+///     execute,
+/// }
+/// ```
+///
+/// This generates a structure which is similar to/inspired by the [`bitflags`
+/// crate](https://crates.io/crates/bitflags). The `Permissions` structure
+/// generated implements the [`PartialEq`], [`Eq`], [`Debug`], [`BitOr`],
+/// [`BitOrAssign`], [`BitAnd`], [`BitAndAssign`], [`BitXor`], [`BitXorAssign`],
+/// and [`Not`] traits - in addition to the Wasmtime-specific component ones
+/// [`ComponentType`], [`Lift`], and [`Lower`].
+///
+/// [`BitOr`]: std::ops::BitOr
+/// [`BitOrAssign`]: std::ops::BitOrAssign
+/// [`BitAnd`]: std::ops::BitAnd
+/// [`BitAndAssign`]: std::ops::BitAndAssign
+/// [`BitXor`]: std::ops::BitXor
+/// [`BitXorAssign`]: std::ops::BitXorAssign
+/// [`Not`]: std::ops::Not
+pub use wasmtime_component_macro::flags;
+
+#[cfg(any(docsrs, test, doctest))]
+pub mod bindgen_examples;
+
+// NB: needed for the links in the docs above to work in all `cargo doc`
+// configurations and avoid errors.
+#[cfg(not(any(docsrs, test, doctest)))]
+#[doc(hidden)]
+pub mod bindgen_examples {}
diff --git a/crates/wasmtime/src/runtime/component/resource_table.rs b/crates/wasmtime/src/runtime/component/resource_table.rs
new file mode 100644
index 000000000000..22a72fb3fee2
--- /dev/null
+++ b/crates/wasmtime/src/runtime/component/resource_table.rs
@@ -0,0 +1,355 @@
+use super::Resource;
+use crate::prelude::*;
+use alloc::collections::BTreeSet;
+use core::any::Any;
+use core::fmt;
+
+#[derive(Debug)]
+/// Errors returned by operations on `ResourceTable`
+pub enum ResourceTableError {
+    /// ResourceTable has no free keys
+    Full,
+    /// Resource not present in table
+    NotPresent,
+    /// Resource present in table, but with a different type
+    WrongType,
+    /// Resource cannot be deleted because child resources exist in the table. Consult wit docs for
+    /// the particular resource to see which methods may return child resources.
+    HasChildren,
+}
+
+impl fmt::Display for ResourceTableError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Full => write!(f, "resource table has no free keys"),
+            Self::NotPresent => write!(f, "resource not present"),
+            Self::WrongType => write!(f, "resource is of another type"),
+            Self::HasChildren => write!(f, "resource has children"),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for ResourceTableError {}
+
+/// The `ResourceTable` type maps a `Resource<T>` to its `T`.
+#[derive(Debug)]
+pub struct ResourceTable {
+    entries: Vec<Entry>,
+    free_head: Option<usize>,
+}
+
+#[derive(Debug)]
+enum Entry {
+    Free { next: Option<usize> },
+    Occupied { entry: TableEntry },
+}
+
+impl Entry {
+    pub fn occupied(&self) -> Option<&TableEntry> {
+        match self {
+            Self::Occupied { entry } => Some(entry),
+            Self::Free { .. } => None,
+        }
+    }
+
+    pub fn occupied_mut(&mut self) -> Option<&mut TableEntry> {
+        match self {
+            Self::Occupied { entry } => Some(entry),
+            Self::Free { .. } => None,
+        }
+    }
+}
+
+/// This structure tracks parent and child relationships for a given table entry.
+///
+/// Parents and children are referred to by table index. We maintain the
+/// following invariants to prevent orphans and cycles:
+/// * parent can only be assigned on creating the entry.
+/// * parent, if some, must exist when creating the entry.
+/// * whenever a child is created, its index is added to children.
+/// * whenever a child is deleted, its index is removed from children.
+/// * an entry with children may not be deleted.
+#[derive(Debug)]
+struct TableEntry {
+    /// The entry in the table, as a boxed dynamically-typed object
+    entry: Box<dyn Any + Send>,
+    /// The index of the parent of this entry, if it has one.
+    parent: Option<u32>,
+    /// The indices of any children of this entry.
+    children: BTreeSet<u32>,
+}
+
+impl TableEntry {
+    fn new(entry: Box<dyn Any + Send>, parent: Option<u32>) -> Self {
+        Self {
+            entry,
+            parent,
+            children: BTreeSet::new(),
+        }
+    }
+    fn add_child(&mut self, child: u32) {
+        debug_assert!(!self.children.contains(&child));
+        self.children.insert(child);
+    }
+    fn remove_child(&mut self, child: u32) {
+        let was_removed = self.children.remove(&child);
+        debug_assert!(was_removed);
+    }
+}
+
+impl ResourceTable {
+    /// Create an empty table
+    pub fn new() -> Self {
+        ResourceTable {
+            entries: Vec::new(),
+            free_head: None,
+        }
+    }
+
+    /// Create an empty table with at least the specified capacity.
+    pub fn with_capacity(capacity: usize) -> Self {
+        ResourceTable {
+            entries: Vec::with_capacity(capacity),
+            free_head: None,
+        }
+    }
+
+    /// Inserts a new value `T` into this table, returning a corresponding
+    /// `Resource<T>` which can be used to refer to it after it was inserted.
+    pub fn push<T>(&mut self, entry: T) -> Result<Resource<T>, ResourceTableError>
+    where
+        T: Send + 'static,
+    {
+        let idx = self.push_(TableEntry::new(Box::new(entry), None))?;
+        Ok(Resource::new_own(idx))
+    }
+
+    /// Pop an index off of the free list, if it's not empty.
+    fn pop_free_list(&mut self) -> Option<usize> {
+        if let Some(ix) = self.free_head {
+            // Advance free_head to the next entry if one is available.
+            match &self.entries[ix] {
+                Entry::Free { next } => self.free_head = *next,
+                Entry::Occupied { .. } => unreachable!(),
+            }
+            Some(ix)
+        } else {
+            None
+        }
+    }
+
+    /// Free an entry in the table, returning its [`TableEntry`]. Add the index to the free list.
+    fn free_entry(&mut self, ix: usize) -> TableEntry {
+        let entry = match core::mem::replace(
+            &mut self.entries[ix],
+            Entry::Free {
+                next: self.free_head,
+            },
+        ) {
+            Entry::Occupied { entry } => entry,
+            Entry::Free { .. } => unreachable!(),
+        };
+
+        self.free_head = Some(ix);
+
+        entry
+    }
+
+    /// Push a new entry into the table, returning its handle. This will prefer to use free entries
+    /// if they exist, falling back on pushing new entries onto the end of the table.
+    fn push_(&mut self, e: TableEntry) -> Result<u32, ResourceTableError> {
+        if let Some(free) = self.pop_free_list() {
+            self.entries[free] = Entry::Occupied { entry: e };
+            Ok(free as u32)
+        } else {
+            let ix = self
+                .entries
+                .len()
+                .try_into()
+                .map_err(|_| ResourceTableError::Full)?;
+            self.entries.push(Entry::Occupied { entry: e });
+            Ok(ix)
+        }
+    }
+
+    fn occupied(&self, key: u32) -> Result<&TableEntry, ResourceTableError> {
+        self.entries
+            .get(key as usize)
+            .and_then(Entry::occupied)
+            .ok_or(ResourceTableError::NotPresent)
+    }
+
+    fn occupied_mut(&mut self, key: u32) -> Result<&mut TableEntry, ResourceTableError> {
+        self.entries
+            .get_mut(key as usize)
+            .and_then(Entry::occupied_mut)
+            .ok_or(ResourceTableError::NotPresent)
+    }
+
+    /// Insert a resource at the next available index, and track that it has a
+    /// parent resource.
+    ///
+    /// The parent must exist to create a child. All children resources must
+    /// be destroyed before a parent can be destroyed - otherwise
+    /// [`ResourceTable::delete`] will fail with
+    /// [`ResourceTableError::HasChildren`].
+    ///
+    /// Parent-child relationships are tracked inside the table to ensure that
+    /// a parent resource is not deleted while it has live children. This
+    /// allows child resources to hold "references" to a parent by table
+    /// index, to avoid needing e.g. an `Arc<Mutex<parent>>` and the associated
+    /// locking overhead and design issues, such as child existence extending
+    /// lifetime of parent referent even after parent resource is destroyed,
+    /// possibility for deadlocks.
+    ///
+    /// Parent-child relationships may not be modified once created. There
+    /// is no way to observe these relationships through the [`ResourceTable`]
+    /// methods except for erroring on deletion, or the [`std::fmt::Debug`]
+    /// impl.
+    pub fn push_child<T, U>(
+        &mut self,
+        entry: T,
+        parent: &Resource<U>,
+    ) -> Result<Resource<T>, ResourceTableError>
+    where
+        T: Send + 'static,
+        U: 'static,
+    {
+        let parent = parent.rep();
+        self.occupied(parent)?;
+        let child = self.push_(TableEntry::new(Box::new(entry), Some(parent)))?;
+        self.occupied_mut(parent)?.add_child(child);
+        Ok(Resource::new_own(child))
+    }
+
+    /// Get an immutable reference to a resource of a given type at a given
+    /// index.
+    ///
+    /// Multiple shared references can be borrowed at any given time.
+    pub fn get<T: Any + Sized>(&self, key: &Resource<T>) -> Result<&T, ResourceTableError> {
+        self.get_(key.rep())?
+            .downcast_ref()
+            .ok_or(ResourceTableError::WrongType)
+    }
+
+    fn get_(&self, key: u32) -> Result<&dyn Any, ResourceTableError> {
+        let r = self.occupied(key)?;
+        Ok(&*r.entry)
+    }
+
+    /// Get an mutable reference to a resource of a given type at a given
+    /// index.
+    pub fn get_mut<T: Any + Sized>(
+        &mut self,
+        key: &Resource<T>,
+    ) -> Result<&mut T, ResourceTableError> {
+        self.get_any_mut(key.rep())?
+            .downcast_mut()
+            .ok_or(ResourceTableError::WrongType)
+    }
+
+    /// Returns the raw `Any` at the `key` index provided.
+    pub fn get_any_mut(&mut self, key: u32) -> Result<&mut dyn Any, ResourceTableError> {
+        let r = self.occupied_mut(key)?;
+        Ok(&mut *r.entry)
+    }
+
+    /// Same as `delete`, but typed
+    pub fn delete<T>(&mut self, resource: Resource<T>) -> Result<T, ResourceTableError>
+    where
+        T: Any,
+    {
+        debug_assert!(resource.owned());
+        let entry = self.delete_entry(resource.rep())?;
+        match entry.entry.downcast() {
+            Ok(t) => Ok(*t),
+            Err(_e) => Err(ResourceTableError::WrongType),
+        }
+    }
+
+    fn delete_entry(&mut self, key: u32) -> Result<TableEntry, ResourceTableError> {
+        if !self.occupied(key)?.children.is_empty() {
+            return Err(ResourceTableError::HasChildren);
+        }
+        let e = self.free_entry(key as usize);
+        if let Some(parent) = e.parent {
+            // Remove deleted resource from parent's child list.
+            // Parent must still be present because it can't be deleted while still having
+            // children:
+            self.occupied_mut(parent)
+                .expect("missing parent")
+                .remove_child(key);
+        }
+        Ok(e)
+    }
+
+    /// Zip the values of the map with mutable references to table entries corresponding to each
+    /// key. As the keys in the `HashMap` are unique, this iterator can give mutable references
+    /// with the same lifetime as the mutable reference to the [ResourceTable].
+    #[cfg(feature = "std")]
+    pub fn iter_entries<'a, T>(
+        &'a mut self,
+        map: std::collections::HashMap<u32, T>,
+    ) -> impl Iterator<Item = (Result<&'a mut dyn Any, ResourceTableError>, T)> {
+        map.into_iter().map(move |(k, v)| {
+            let item = self
+                .occupied_mut(k)
+                .map(|e| Box::as_mut(&mut e.entry))
+                // Safety: extending the lifetime of the mutable reference.
+                .map(|item| unsafe { &mut *(item as *mut dyn Any) });
+            (item, v)
+        })
+    }
+
+    /// Iterate over all children belonging to the provided parent
+    pub fn iter_children<T>(
+        &self,
+        parent: &Resource<T>,
+    ) -> Result<impl Iterator<Item = &(dyn Any + Send)>, ResourceTableError>
+    where
+        T: 'static,
+    {
+        let parent_entry = self.occupied(parent.rep())?;
+        Ok(parent_entry.children.iter().map(|child_index| {
+            let child = self.occupied(*child_index).expect("missing child");
+            child.entry.as_ref()
+        }))
+    }
+}
+
+impl Default for ResourceTable {
+    fn default() -> Self {
+        ResourceTable::new()
+    }
+}
+
+#[test]
+pub fn test_free_list() {
+    let mut table = ResourceTable::new();
+
+    let x = table.push(()).unwrap();
+    assert_eq!(x.rep(), 0);
+
+    let y = table.push(()).unwrap();
+    assert_eq!(y.rep(), 1);
+
+    // Deleting x should put it on the free list, so the next entry should have the same rep.
+    table.delete(x).unwrap();
+    let x = table.push(()).unwrap();
+    assert_eq!(x.rep(), 0);
+
+    // Deleting x and then y should yield indices 1 and then 0 for new entries.
+    table.delete(x).unwrap();
+    table.delete(y).unwrap();
+
+    let y = table.push(()).unwrap();
+    assert_eq!(y.rep(), 1);
+
+    let x = table.push(()).unwrap();
+    assert_eq!(x.rep(), 0);
+
+    // As the free list is empty, this entry will have a new id.
+    let x = table.push(()).unwrap();
+    assert_eq!(x.rep(), 2);
+}
diff --git a/crates/wasmtime/src/runtime/component/resources.rs b/crates/wasmtime/src/runtime/component/resources.rs
new file mode 100644
index 000000000000..678b0f8f78e8
--- /dev/null
+++ b/crates/wasmtime/src/runtime/component/resources.rs
@@ -0,0 +1,1132 @@
+use crate::component::func::{bad_type_info, desc, LiftContext, LowerContext};
+use crate::component::matching::InstanceType;
+use crate::component::{ComponentType, Lift, Lower};
+use crate::prelude::*;
+use crate::runtime::vm::component::{ComponentInstance, InstanceFlags, ResourceTables};
+use crate::runtime::vm::{SendSyncPtr, VMFuncRef, ValRaw};
+use crate::store::{StoreId, StoreOpaque};
+use crate::{AsContextMut, StoreContextMut, Trap};
+use core::any::TypeId;
+use core::fmt;
+use core::marker;
+use core::mem::MaybeUninit;
+use core::ptr::NonNull;
+use core::sync::atomic::{AtomicU64, Ordering::Relaxed};
+use wasmtime_environ::component::{
+    CanonicalAbiInfo, ComponentTypes, DefinedResourceIndex, InterfaceType, ResourceIndex,
+    TypeResourceTableIndex,
+};
+
+/// Representation of a resource type in the component model.
+///
+/// Resources are currently always represented as 32-bit integers but they have
+/// unique types across instantiations and the host. For example instantiating
+/// the same component twice means that defined resource types in the component
+/// will all be different. Values of this type can be compared to see if
+/// resources have the same type.
+///
+/// Resource types can also be defined on the host in addition to guests. On the
+/// host resource types are tied to a `T`, an arbitrary Rust type. Two host
+/// resource types are the same if they point to the same `T`.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct ResourceType {
+    kind: ResourceTypeKind,
+}
+
+impl ResourceType {
+    /// Creates a new host resource type corresponding to `T`.
+    ///
+    /// Note that `T` is a mostly a phantom type parameter here. It does not
+    /// need to reflect the actual storage of the resource `T`. For example this
+    /// is valid:
+    ///
+    /// ```rust
+    /// use wasmtime::component::ResourceType;
+    ///
+    /// struct Foo;
+    ///
+    /// let ty = ResourceType::host::<Foo>();
+    /// ```
+    ///
+    /// A resource type of type `ResourceType::host::<T>()` will match the type
+    /// of the value produced by `Resource::<T>::new_{own,borrow}`.
+    pub fn host<T: 'static>() -> ResourceType {
+        ResourceType {
+            kind: ResourceTypeKind::Host(TypeId::of::<T>()),
+        }
+    }
+
+    pub(crate) fn guest(
+        store: StoreId,
+        instance: &ComponentInstance,
+        id: DefinedResourceIndex,
+    ) -> ResourceType {
+        ResourceType {
+            kind: ResourceTypeKind::Guest {
+                store,
+                instance: instance as *const _ as usize,
+                id,
+            },
+        }
+    }
+
+    pub(crate) fn uninstantiated(types: &ComponentTypes, index: ResourceIndex) -> ResourceType {
+        ResourceType {
+            kind: ResourceTypeKind::Uninstantiated {
+                component: types as *const _ as usize,
+                index,
+            },
+        }
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+enum ResourceTypeKind {
+    Host(TypeId),
+    Guest {
+        store: StoreId,
+        // For now this is the `*mut ComponentInstance` pointer within the store
+        // that this guest corresponds to. It's used to distinguish different
+        // instantiations of the same component within the store.
+        instance: usize,
+        id: DefinedResourceIndex,
+    },
+    Uninstantiated {
+        // Like `instance` in `Guest` above this is a pointer and is used to
+        // distinguish between two components. Technically susceptible to ABA
+        // issues but the consequence is a nonexistent resource would be equal
+        // to a new resource so there's not really any issue with that.
+        component: usize,
+        index: ResourceIndex,
+    },
+}
+
+/// A host-defined resource in the component model.
+///
+/// This type can be thought of as roughly a newtype wrapper around `u32` for
+/// use as a resource with the component model. The main guarantee that the
+/// component model provides is that the `u32` is not forgeable by guests and
+/// there are guaranteed semantics about when a `u32` may be in use by the guest
+/// and when it's guaranteed no longer needed. This means that it is safe for
+/// embedders to consider the internal `u32` representation "trusted" and use it
+/// for things like table indices with infallible accessors that panic on
+/// out-of-bounds. This should only panic for embedder bugs, not because of any
+/// possible behavior in the guest.
+///
+/// A `Resource<T>` value dynamically represents both an `(own $t)` in the
+/// component model as well as a `(borrow $t)`. It can be inspected via
+/// [`Resource::owned`] to test whether it is an owned handle. An owned handle
+/// which is not actively borrowed can be destroyed at any time as it's
+/// guaranteed that the guest does not have access to it. A borrowed handle, on
+/// the other hand, may be accessed by the guest so it's not necessarily
+/// guaranteed to be able to be destroyed.
+///
+/// Note that the "own" and "borrow" here refer to the component model, not
+/// Rust. The semantics of Rust ownership and borrowing are slightly different
+/// than the component model's (but spiritually the same) in that more dynamic
+/// tracking is employed as part of the component model. This means that it's
+/// possible to get runtime errors when using a `Resource<T>`. For example it is
+/// an error to call [`Resource::new_borrow`] and pass that to a component
+/// function expecting `(own $t)` and this is not statically disallowed.
+///
+/// The [`Resource`] type implements both the [`Lift`] and [`Lower`] trait to be
+/// used with typed functions in the component model or as part of aggregate
+/// structures and datatypes.
+///
+/// # Destruction of a resource
+///
+/// Resources in the component model are optionally defined with a destructor,
+/// but this host resource type does not specify a destructor. It is left up to
+/// the embedder to be able to determine how best to a destroy a resource when
+/// it is owned.
+///
+/// Note, though, that while [`Resource`] itself does not specify destructors
+/// it's still possible to do so via the [`Linker::resource`] definition. When a
+/// resource type is defined for a guest component a destructor can be specified
+/// which can be used to hook into resource destruction triggered by the guest.
+///
+/// This means that there are two ways that resource destruction is handled:
+///
+/// * Host resources destroyed by the guest can hook into the
+///   [`Linker::resource`] destructor closure to handle resource destruction.
+///   This could, for example, remove table entries.
+///
+/// * Host resources owned by the host itself have no automatic means of
+///   destruction. The host can make its own determination that its own resource
+///   is not lent out to the guest and at that time choose to destroy or
+///   deallocate it.
+///
+/// # Dynamic behavior of a resource
+///
+/// A host-defined [`Resource`] does not necessarily represent a static value.
+/// Its internals may change throughout its usage to track the state associated
+/// with the resource. The internal 32-bit host-defined representation never
+/// changes, however.
+///
+/// For example if there's a component model function of the form:
+///
+/// ```wasm
+/// (func (param "a" (borrow $t)) (param "b" (own $t)))
+/// ```
+///
+/// Then that can be extracted in Rust with:
+///
+/// ```rust,ignore
+/// let func = instance.get_typed_func::<(&Resource<T>, &Resource<T>), ()>(&mut store, "name")?;
+/// ```
+///
+/// Here the exact same resource can be provided as both arguments but that is
+/// not valid to do so because the same resource cannot be actively borrowed and
+/// passed by-value as the second parameter at the same time. The internal state
+/// in `Resource<T>` will track this information and provide a dynamic runtime
+/// error in this situation.
+///
+/// Mostly it's important to be aware that there is dynamic state associated
+/// with a [`Resource<T>`] to provide errors in situations that cannot be
+/// statically ruled out.
+///
+/// # Borrows and host responsibilities
+///
+/// Borrows to resources in the component model are guaranteed to be transient
+/// such that if a borrow is passed as part of a function call then when the
+/// function returns it's guaranteed that the guest no longer has access to the
+/// resource. This guarantee, however, must be manually upheld by the host when
+/// it receives its own borrow.
+///
+/// As mentioned above the [`Resource<T>`] type can represent a borrowed value
+/// in addition to an owned value. This means a guest can provide the host with
+/// a borrow, such as an argument to an imported function:
+///
+/// ```rust,ignore
+/// linker.root().func_wrap("name", |_cx, (r,): (Resource<MyType>,)| {
+///     assert!(!r.owned());
+///     // .. here `r` is a borrowed value provided by the guest and the host
+///     // shouldn't continue to access it beyond the scope of this call
+/// })?;
+/// ```
+///
+/// In this situation the host should take care to not attempt to persist the
+/// resource beyond the scope of the call. It's the host's resource so it
+/// technically can do what it wants with it but nothing is statically
+/// preventing `r` to stay pinned to the lifetime of the closure invocation.
+/// It's considered a mistake that the host performed if `r` is persisted too
+/// long and accessed at the wrong time.
+///
+/// [`Linker::resource`]: crate::component::LinkerInstance::resource
+pub struct Resource<T> {
+    /// The host-defined 32-bit representation of this resource.
+    rep: u32,
+
+    /// Dear rust please consider `T` used even though it's not actually used.
+    _marker: marker::PhantomData<fn() -> T>,
+
+    state: AtomicResourceState,
+}
+
+/// Internal dynamic state tracking for this resource. This can be one of
+/// four different states:
+///
+/// * `BORROW` / `u64::MAX` - this indicates that this is a borrowed
+///   resource. The `rep` doesn't live in the host table and this `Resource`
+///   instance is transiently available. It's the host's responsibility to
+///   discard this resource when the borrow duration has finished.
+///
+/// * `NOT_IN_TABLE` / `u64::MAX - 1` - this indicates that this is an owned
+///   resource not present in any store's table. This resource is not lent
+///   out. It can be passed as an `(own $t)` directly into a guest's table
+///   or it can be passed as a borrow to a guest which will insert it into
+///   a host store's table for dynamic borrow tracking.
+///
+/// * `TAKEN` / `u64::MAX - 2` - while the `rep` is available the resource
+///   has been dynamically moved into a guest and cannot be moved in again.
+///   This is used for example to prevent the same resource from being
+///   passed twice to a guest.
+///
+/// * All other values - any other value indicates that the value is an
+///   index into a store's table of host resources. It's guaranteed that the
+///   table entry represents a host resource and the resource may have
+///   borrow tracking associated with it. The low 32-bits of the value are
+///   the table index and the upper 32-bits are the generation.
+///
+/// Note that this is an `AtomicU64` but it's not intended to actually be
+/// used in conjunction with threads as generally a `Store<T>` lives on one
+/// thread at a time. The `AtomicU64` here is used to ensure that this type
+/// is `Send + Sync` when captured as a reference to make async programming
+/// more ergonomic.
+struct AtomicResourceState(AtomicU64);
+
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+enum ResourceState {
+    Borrow,
+    NotInTable,
+    Taken,
+    Index(HostResourceIndex),
+}
+
+impl AtomicResourceState {
+    const BORROW: Self = Self(AtomicU64::new(ResourceState::BORROW));
+    const NOT_IN_TABLE: Self = Self(AtomicU64::new(ResourceState::NOT_IN_TABLE));
+
+    fn get(&self) -> ResourceState {
+        ResourceState::decode(self.0.load(Relaxed))
+    }
+
+    fn swap(&self, state: ResourceState) -> ResourceState {
+        ResourceState::decode(self.0.swap(state.encode(), Relaxed))
+    }
+}
+
+impl ResourceState {
+    // See comments on `state` above for info about these values.
+    const BORROW: u64 = u64::MAX;
+    const NOT_IN_TABLE: u64 = u64::MAX - 1;
+    const TAKEN: u64 = u64::MAX - 2;
+
+    fn decode(bits: u64) -> ResourceState {
+        match bits {
+            Self::BORROW => Self::Borrow,
+            Self::NOT_IN_TABLE => Self::NotInTable,
+            Self::TAKEN => Self::Taken,
+            other => Self::Index(HostResourceIndex(other)),
+        }
+    }
+
+    fn encode(&self) -> u64 {
+        match self {
+            Self::Borrow => Self::BORROW,
+            Self::NotInTable => Self::NOT_IN_TABLE,
+            Self::Taken => Self::TAKEN,
+            Self::Index(index) => index.0,
+        }
+    }
+}
+
+/// Metadata tracking the state of resources within a `Store`.
+///
+/// This is a borrowed structure created from a `Store` piecemeal from below.
+/// The `ResourceTables` type holds most of the raw information and this
+/// structure tacks on a reference to `HostResourceData` to track generation
+/// numbers of host indices.
+pub struct HostResourceTables<'a> {
+    tables: ResourceTables<'a>,
+    host_resource_data: &'a mut HostResourceData,
+}
+
+/// Metadata for host-owned resources owned within a `Store`.
+///
+/// This metadata is used to prevent the ABA problem with indices handed out as
+/// part of `Resource` and `ResourceAny`. Those structures are `Copy` meaning
+/// that it's easy to reuse them, possibly accidentally. To prevent issues in
+/// the host Wasmtime attaches both an index (within `ResourceTables`) as well
+/// as a 32-bit generation counter onto each `HostResourceIndex` which the host
+/// actually holds in `Resource` and `ResourceAny`.
+///
+/// This structure holds a list which is a parallel list to the "list of reps"
+/// that's stored within `ResourceTables` elsewhere in the `Store`. This
+/// parallel list holds the last known generation of each element in the table.
+/// The generation is then compared on access to make sure it's the same.
+///
+/// Whenever a slot in the table is allocated the `cur_generation` field is
+/// pushed at the corresponding index of `generation_of_table_slot`. Whenever
+/// a field is accessed the current value of `generation_of_table_slot` is
+/// checked against the generation of the index. Whenever a slot is deallocated
+/// the generation is incremented. Put together this means that any access of a
+/// deallocated slot should deterministically provide an error.
+#[derive(Default)]
+pub struct HostResourceData {
+    cur_generation: u32,
+    table_slot_metadata: Vec<TableSlot>,
+}
+
+#[derive(Copy, Clone)]
+struct TableSlot {
+    generation: u32,
+    flags: Option<InstanceFlags>,
+    dtor: Option<SendSyncPtr<VMFuncRef>>,
+}
+
+/// Host representation of an index into a table slot.
+///
+/// This is morally (u32, u32) but is encoded as a 64-bit integer. The low
+/// 32-bits are the table index and the upper 32-bits are the generation
+/// counter.
+#[derive(PartialEq, Eq, Debug, Copy, Clone)]
+#[repr(transparent)]
+pub struct HostResourceIndex(u64);
+
+impl HostResourceIndex {
+    fn new(idx: u32, gen: u32) -> HostResourceIndex {
+        HostResourceIndex(u64::from(idx) | (u64::from(gen) << 32))
+    }
+
+    fn index(&self) -> u32 {
+        u32::try_from(self.0 & 0xffffffff).unwrap()
+    }
+
+    fn gen(&self) -> u32 {
+        u32::try_from(self.0 >> 32).unwrap()
+    }
+}
+
+impl<'a> HostResourceTables<'a> {
+    pub fn new_host(store: &'a mut StoreOpaque) -> HostResourceTables<'_> {
+        let (calls, host_table, host_resource_data) = store.component_resource_state();
+        HostResourceTables::from_parts(
+            ResourceTables {
+                host_table: Some(host_table),
+                calls,
+                tables: None,
+            },
+            host_resource_data,
+        )
+    }
+
+    pub fn from_parts(
+        tables: ResourceTables<'a>,
+        host_resource_data: &'a mut HostResourceData,
+    ) -> Self {
+        HostResourceTables {
+            tables,
+            host_resource_data,
+        }
+    }
+
+    /// Lifts an `own` resource that resides in the host's tables at the `idx`
+    /// specified into its `rep`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if `idx` doesn't point to a valid owned resource, or
+    /// if `idx` can't be lifted as an `own` (e.g. it has active borrows).
+    pub fn host_resource_lift_own(&mut self, idx: HostResourceIndex) -> Result<u32> {
+        let (idx, _) = self.validate_host_index(idx, true)?;
+        self.tables.resource_lift_own(None, idx)
+    }
+
+    /// See [`HostResourceTables::host_resource_lift_own`].
+    pub fn host_resource_lift_borrow(&mut self, idx: HostResourceIndex) -> Result<u32> {
+        let (idx, _) = self.validate_host_index(idx, false)?;
+        self.tables.resource_lift_borrow(None, idx)
+    }
+
+    /// Lowers an `own` resource to be owned by the host.
+    ///
+    /// This returns a new index into the host's set of resource tables which
+    /// will point to the `rep` specified. The returned index is suitable for
+    /// conversion into either [`Resource`] or [`ResourceAny`].
+    ///
+    /// The `dtor` and instance `flags` are specified as well to know what
+    /// destructor to run when this resource is destroyed.
+    pub fn host_resource_lower_own(
+        &mut self,
+        rep: u32,
+        dtor: Option<NonNull<VMFuncRef>>,
+        flags: Option<InstanceFlags>,
+    ) -> Result<HostResourceIndex> {
+        let idx = self.tables.resource_lower_own(None, rep)?;
+        Ok(self.new_host_index(idx, dtor, flags))
+    }
+
+    /// See [`HostResourceTables::host_resource_lower_own`].
+    pub fn host_resource_lower_borrow(&mut self, rep: u32) -> Result<HostResourceIndex> {
+        let idx = self.tables.resource_lower_borrow(None, rep)?;
+        Ok(self.new_host_index(idx, None, None))
+    }
+
+    /// Validates that `idx` is still valid for the host tables, notably
+    /// ensuring that the generation listed in `idx` is the same as the
+    /// last recorded generation of the slot itself.
+    ///
+    /// The `is_removal` option indicates whether or not this table access will
+    /// end up removing the element from the host table. In such a situation the
+    /// current generation number is incremented.
+    fn validate_host_index(
+        &mut self,
+        idx: HostResourceIndex,
+        is_removal: bool,
+    ) -> Result<(u32, Option<TableSlot>)> {
+        let actual = usize::try_from(idx.index())
+            .ok()
+            .and_then(|i| self.host_resource_data.table_slot_metadata.get(i).copied());
+
+        // If `idx` is out-of-bounds then skip returning an error. In such a
+        // situation the operation that this is guarding will return a more
+        // precise error, such as a lift operation.
+        if let Some(actual) = actual {
+            if actual.generation != idx.gen() {
+                bail!("host-owned resource is being used with the wrong type");
+            }
+        }
+
+        // Bump the current generation of this is a removal to ensure any
+        // future item placed in this slot can't be pointed to by the `idx`
+        // provided above.
+        if is_removal {
+            self.host_resource_data.cur_generation += 1;
+        }
+
+        Ok((idx.index(), actual))
+    }
+
+    /// Creates a new `HostResourceIndex` which will point to the raw table
+    /// slot provided by `idx`.
+    ///
+    /// This will register metadata necessary to track the current generation
+    /// in the returned `HostResourceIndex` as well.
+    fn new_host_index(
+        &mut self,
+        idx: u32,
+        dtor: Option<NonNull<VMFuncRef>>,
+        flags: Option<InstanceFlags>,
+    ) -> HostResourceIndex {
+        let list = &mut self.host_resource_data.table_slot_metadata;
+        let info = TableSlot {
+            generation: self.host_resource_data.cur_generation,
+            flags,
+            dtor: dtor.map(SendSyncPtr::new),
+        };
+        match list.get_mut(idx as usize) {
+            Some(slot) => *slot = info,
+            None => {
+                // Resource handles start at 1, not zero, so push two elements
+                // for the first resource handle.
+                if list.is_empty() {
+                    assert_eq!(idx, 1);
+                    list.push(TableSlot {
+                        generation: 0,
+                        flags: None,
+                        dtor: None,
+                    });
+                }
+                assert_eq!(idx as usize, list.len());
+                list.push(info);
+            }
+        }
+
+        HostResourceIndex::new(idx, info.generation)
+    }
+
+    /// Drops a host-owned resource from host tables.
+    ///
+    /// This method will attempt to interpret `idx` as pointing to either a
+    /// `borrow` or `own` resource with the `expected` type specified. This
+    /// method will then return the underlying `rep` if it points to an `own`
+    /// resource which can then be further processed for destruction.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if `idx` doesn't point to a valid resource, points to
+    /// an `own` with active borrows, or if it doesn't have the type `expected`
+    /// in the host tables.
+    fn host_resource_drop(&mut self, idx: HostResourceIndex) -> Result<Option<(u32, TableSlot)>> {
+        let (idx, slot) = self.validate_host_index(idx, true)?;
+        match self.tables.resource_drop(None, idx)? {
+            Some(rep) => Ok(Some((rep, slot.unwrap()))),
+            None => Ok(None),
+        }
+    }
+
+    /// Lowers an `own` resource into the guest, converting the `rep` specified
+    /// into a guest-local index.
+    ///
+    /// The `ty` provided is which table to put this into.
+    pub fn guest_resource_lower_own(
+        &mut self,
+        rep: u32,
+        ty: TypeResourceTableIndex,
+    ) -> Result<u32> {
+        self.tables.resource_lower_own(Some(ty), rep)
+    }
+
+    /// Lowers a `borrow` resource into the guest, converting the `rep`
+    /// specified into a guest-local index.
+    ///
+    /// The `ty` provided is which table to put this into.
+    ///
+    /// Note that this cannot be used in isolation because lowering a borrow
+    /// into a guest has a special case where `rep` is returned directly if `ty`
+    /// belongs to the component being lowered into. That property must be
+    /// handled by the caller of this function.
+    pub fn guest_resource_lower_borrow(
+        &mut self,
+        rep: u32,
+        ty: TypeResourceTableIndex,
+    ) -> Result<u32> {
+        self.tables.resource_lower_borrow(Some(ty), rep)
+    }
+
+    /// Lifts an `own` resource from the `idx` specified from the table `ty`.
+    ///
+    /// This will lookup the appropriate table in the guest and return the `rep`
+    /// corresponding to `idx` if it's valid.
+    pub fn guest_resource_lift_own(&mut self, idx: u32, ty: TypeResourceTableIndex) -> Result<u32> {
+        self.tables.resource_lift_own(Some(ty), idx)
+    }
+
+    /// Lifts a `borrow` resource from the `idx` specified from the table `ty`.
+    ///
+    /// This will lookup the appropriate table in the guest and return the `rep`
+    /// corresponding to `idx` if it's valid.
+    pub fn guest_resource_lift_borrow(
+        &mut self,
+        idx: u32,
+        ty: TypeResourceTableIndex,
+    ) -> Result<u32> {
+        self.tables.resource_lift_borrow(Some(ty), idx)
+    }
+
+    /// Begins a call into the component instance, starting recording of
+    /// metadata related to resource borrowing.
+    #[inline]
+    pub fn enter_call(&mut self) {
+        self.tables.enter_call()
+    }
+
+    /// Completes a call into the component instance, validating that it's ok to
+    /// complete by ensuring the are no remaining active borrows.
+    #[inline]
+    pub fn exit_call(&mut self) -> Result<()> {
+        self.tables.exit_call()
+    }
+}
+
+impl<T> Resource<T>
+where
+    T: 'static,
+{
+    /// Creates a new owned resource with the `rep` specified.
+    ///
+    /// The returned value is suitable for passing to a guest as either a
+    /// `(borrow $t)` or `(own $t)`.
+    pub fn new_own(rep: u32) -> Resource<T> {
+        Resource {
+            state: AtomicResourceState::NOT_IN_TABLE,
+            rep,
+            _marker: marker::PhantomData,
+        }
+    }
+
+    /// Creates a new borrowed resource which isn't actually rooted in any
+    /// ownership.
+    ///
+    /// This can be used to pass to a guest as a borrowed resource and the
+    /// embedder will know that the `rep` won't be in use by the guest
+    /// afterwards. Exactly how the lifetime of `rep` works is up to the
+    /// embedder.
+    pub fn new_borrow(rep: u32) -> Resource<T> {
+        Resource {
+            state: AtomicResourceState::BORROW,
+            rep,
+            _marker: marker::PhantomData,
+        }
+    }
+
+    /// Returns the underlying 32-bit representation used to originally create
+    /// this resource.
+    pub fn rep(&self) -> u32 {
+        self.rep
+    }
+
+    /// Returns whether this is an owned resource or not.
+    ///
+    /// Owned resources can be safely destroyed by the embedder at any time, and
+    /// borrowed resources have an owner somewhere else on the stack so can only
+    /// be accessed, not destroyed.
+    pub fn owned(&self) -> bool {
+        match self.state.get() {
+            ResourceState::Borrow => false,
+            ResourceState::Taken | ResourceState::NotInTable | ResourceState::Index(_) => true,
+        }
+    }
+
+    fn lower_to_index<U>(&self, cx: &mut LowerContext<'_, U>, ty: InterfaceType) -> Result<u32> {
+        match ty {
+            InterfaceType::Own(t) => {
+                let rep = match self.state.get() {
+                    // If this is a borrow resource then this is a dynamic
+                    // error on behalf of the embedder.
+                    ResourceState::Borrow => {
+                        bail!("cannot lower a `borrow` resource into an `own`")
+                    }
+
+                    // If this resource does not yet live in a table then we're
+                    // dynamically transferring ownership to wasm. Record that
+                    // it's no longer present and then pass through the
+                    // representation.
+                    ResourceState::NotInTable => {
+                        let prev = self.state.swap(ResourceState::Taken);
+                        assert_eq!(prev, ResourceState::NotInTable);
+                        self.rep
+                    }
+
+                    // This resource has already been moved into wasm so this is
+                    // a dynamic error on behalf of the embedder.
+                    ResourceState::Taken => bail!("host resource already consumed"),
+
+                    // If this resource lives in a host table then try to take
+                    // it out of the table, which may fail, and on success we
+                    // can move the rep into the guest table.
+                    ResourceState::Index(idx) => cx.host_resource_lift_own(idx)?,
+                };
+                cx.guest_resource_lower_own(t, rep)
+            }
+            InterfaceType::Borrow(t) => {
+                let rep = match self.state.get() {
+                    // If this is already a borrowed resource, nothing else to
+                    // do and the rep is passed through.
+                    ResourceState::Borrow => self.rep,
+
+                    // If this resource is already gone, that's a dynamic error
+                    // for the embedder.
+                    ResourceState::Taken => bail!("host resource already consumed"),
+
+                    // If this resource is not currently in a table then it
+                    // needs to move into a table to participate in state
+                    // related to borrow tracking. Execute the
+                    // `host_resource_lower_own` operation here and update our
+                    // state.
+                    //
+                    // Afterwards this is the same as the `idx` case below.
+                    //
+                    // Note that flags/dtor are passed as `None` here since
+                    // `Resource<T>` doesn't offer destruction support.
+                    ResourceState::NotInTable => {
+                        let idx = cx.host_resource_lower_own(self.rep, None, None)?;
+                        let prev = self.state.swap(ResourceState::Index(idx));
+                        assert_eq!(prev, ResourceState::NotInTable);
+                        cx.host_resource_lift_borrow(idx)?
+                    }
+
+                    // If this resource lives in a table then it needs to come
+                    // out of the table with borrow-tracking employed.
+                    ResourceState::Index(idx) => cx.host_resource_lift_borrow(idx)?,
+                };
+                cx.guest_resource_lower_borrow(t, rep)
+            }
+            _ => bad_type_info(),
+        }
+    }
+
+    fn lift_from_index(cx: &mut LiftContext<'_>, ty: InterfaceType, index: u32) -> Result<Self> {
+        let (state, rep) = match ty {
+            // Ownership is being transferred from a guest to the host, so move
+            // it from the guest table into a new `Resource`. Note that this
+            // isn't immediately inserted into the host table and that's left
+            // for the future if it's necessary to take a borrow from this owned
+            // resource.
+            InterfaceType::Own(t) => {
+                debug_assert!(cx.resource_type(t) == ResourceType::host::<T>());
+                let (rep, dtor, flags) = cx.guest_resource_lift_own(t, index)?;
+                assert!(dtor.is_some());
+                assert!(flags.is_none());
+                (AtomicResourceState::NOT_IN_TABLE, rep)
+            }
+
+            // The borrow here is lifted from the guest, but note the lack of
+            // `host_resource_lower_borrow` as it's intentional. Lowering
+            // a borrow has a special case in the canonical ABI where if the
+            // receiving module is the owner of the resource then it directly
+            // receives the `rep` and no other dynamic tracking is employed.
+            // This effectively mirrors that even though the canonical ABI
+            // isn't really all that applicable in host context here.
+            InterfaceType::Borrow(t) => {
+                debug_assert!(cx.resource_type(t) == ResourceType::host::<T>());
+                let rep = cx.guest_resource_lift_borrow(t, index)?;
+                (AtomicResourceState::BORROW, rep)
+            }
+            _ => bad_type_info(),
+        };
+        Ok(Resource {
+            state,
+            rep,
+            _marker: marker::PhantomData,
+        })
+    }
+
+    /// Attempts to convert a [`ResourceAny`] into [`Resource`].
+    ///
+    /// This method will check that `resource` has type
+    /// `ResourceType::host::<T>()` and then convert it into a typed version of
+    /// the resource.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error if `resource` does not have type
+    /// `ResourceType::host::<T>()`. This function may also return an error if
+    /// `resource` is no longer valid, for example it was previously converted.
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if `resource` does not belong to the `store`
+    /// specified.
+    pub fn try_from_resource_any(
+        resource: ResourceAny,
+        mut store: impl AsContextMut,
+    ) -> Result<Self> {
+        let store = store.as_context_mut();
+        let mut tables = HostResourceTables::new_host(store.0);
+        let ResourceAny { idx, ty, owned } = resource;
+        ensure!(ty == ResourceType::host::<T>(), "resource type mismatch");
+        let (state, rep) = if owned {
+            let rep = tables.host_resource_lift_own(idx)?;
+            (AtomicResourceState::NOT_IN_TABLE, rep)
+        } else {
+            // For borrowed handles, first acquire the `rep` via lifting the
+            // borrow. Afterwards though remove any dynamic state associated
+            // with this borrow. `Resource<T>` doesn't participate in dynamic
+            // state tracking and it's assumed embedders know what they're
+            // doing, so the drop call will clear out that a borrow is active
+            //
+            // Note that the result of `drop` should always be `None` as it's a
+            // borrowed handle, so assert so.
+            let rep = tables.host_resource_lift_borrow(idx)?;
+            let res = tables.host_resource_drop(idx)?;
+            assert!(res.is_none());
+            (AtomicResourceState::BORROW, rep)
+        };
+        Ok(Resource {
+            state,
+            rep,
+            _marker: marker::PhantomData,
+        })
+    }
+
+    /// See [`ResourceAny::try_from_resource`]
+    pub fn try_into_resource_any(self, store: impl AsContextMut) -> Result<ResourceAny> {
+        ResourceAny::try_from_resource(self, store)
+    }
+}
+
+unsafe impl<T: 'static> ComponentType for Resource<T> {
+    const ABI: CanonicalAbiInfo = CanonicalAbiInfo::SCALAR4;
+
+    type Lower = <u32 as ComponentType>::Lower;
+
+    fn typecheck(ty: &InterfaceType, types: &InstanceType<'_>) -> Result<()> {
+        let resource = match ty {
+            InterfaceType::Own(t) | InterfaceType::Borrow(t) => *t,
+            other => bail!("expected `own` or `borrow`, found `{}`", desc(other)),
+        };
+        match types.resource_type(resource).kind {
+            ResourceTypeKind::Host(id) if TypeId::of::<T>() == id => {}
+            _ => bail!("resource type mismatch"),
+        }
+
+        Ok(())
+    }
+}
+
+unsafe impl<T: 'static> Lower for Resource<T> {
+    fn lower<U>(
+        &self,
+        cx: &mut LowerContext<'_, U>,
+        ty: InterfaceType,
+        dst: &mut MaybeUninit<Self::Lower>,
+    ) -> Result<()> {
+        self.lower_to_index(cx, ty)?
+            .lower(cx, InterfaceType::U32, dst)
+    }
+
+    fn store<U>(
+        &self,
+        cx: &mut LowerContext<'_, U>,
+        ty: InterfaceType,
+        offset: usize,
+    ) -> Result<()> {
+        self.lower_to_index(cx, ty)?
+            .store(cx, InterfaceType::U32, offset)
+    }
+}
+
+unsafe impl<T: 'static> Lift for Resource<T> {
+    fn lift(cx: &mut LiftContext<'_>, ty: InterfaceType, src: &Self::Lower) -> Result<Self> {
+        let index = u32::lift(cx, InterfaceType::U32, src)?;
+        Resource::lift_from_index(cx, ty, index)
+    }
+
+    fn load(cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Self> {
+        let index = u32::load(cx, InterfaceType::U32, bytes)?;
+        Resource::lift_from_index(cx, ty, index)
+    }
+}
+
+impl<T> fmt::Debug for Resource<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let state = match self.state.get() {
+            ResourceState::Borrow => "borrow",
+            ResourceState::NotInTable => "own (not in table)",
+            ResourceState::Taken => "taken",
+            ResourceState::Index(_) => "own",
+        };
+        f.debug_struct("Resource")
+            .field("rep", &self.rep)
+            .field("state", &state)
+            .finish()
+    }
+}
+
+/// Representation of a resource in the component model, either a guest-defined
+/// or a host-defined resource.
+///
+/// This type is similar to [`Resource`] except that it can be used to represent
+/// any resource, either host or guest. This type cannot be directly constructed
+/// and is only available if the guest returns it to the host (e.g. a function
+/// returning a guest-defined resource) or by a conversion from [`Resource`] via
+/// [`ResourceAny::try_from_resource`].
+/// This type also does not carry a static type parameter `T` for example and
+/// does not have as much information about its type.
+/// This means that it's possible to get runtime type-errors when
+/// using this type because it cannot statically prevent mismatching resource
+/// types.
+///
+/// Like [`Resource`] this type represents either an `own` or a `borrow`
+/// resource internally. Unlike [`Resource`], however, a [`ResourceAny`] must
+/// always be explicitly destroyed with the [`ResourceAny::resource_drop`]
+/// method. This will update internal dynamic state tracking and invoke the
+/// WebAssembly-defined destructor for a resource, if any.
+///
+/// Note that it is required to call `resource_drop` for all instances of
+/// [`ResourceAny`]: even borrows. Both borrows and own handles have state
+/// associated with them that must be discarded by the time they're done being
+/// used.
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
+pub struct ResourceAny {
+    idx: HostResourceIndex,
+    ty: ResourceType,
+    owned: bool,
+}
+
+impl ResourceAny {
+    /// Attempts to convert an imported [`Resource`] into [`ResourceAny`].
+    ///
+    /// * `resource` is the resource to convert.
+    /// * `store` is the store to place the returned resource into.
+    ///
+    /// The returned `ResourceAny` will not have a destructor attached to it
+    /// meaning that if `resource_drop` is called then it will not invoked a
+    /// host-defined destructor. This is similar to how `Resource<T>` does not
+    /// have a destructor associated with it.
+    ///
+    /// # Errors
+    ///
+    /// This method will return an error if `resource` has already been "taken"
+    /// and has ownership transferred elsewhere which can happen in situations
+    /// such as when it's already lowered into a component.
+    pub fn try_from_resource<T: 'static>(
+        resource: Resource<T>,
+        mut store: impl AsContextMut,
+    ) -> Result<Self> {
+        let Resource { rep, state, .. } = resource;
+        let store = store.as_context_mut();
+
+        let mut tables = HostResourceTables::new_host(store.0);
+        let (idx, owned) = match state.get() {
+            ResourceState::Borrow => (tables.host_resource_lower_borrow(rep)?, false),
+            ResourceState::NotInTable => {
+                let idx = tables.host_resource_lower_own(rep, None, None)?;
+                (idx, true)
+            }
+            ResourceState::Taken => bail!("host resource already consumed"),
+            ResourceState::Index(idx) => (idx, true),
+        };
+        Ok(Self {
+            idx,
+            ty: ResourceType::host::<T>(),
+            owned,
+        })
+    }
+
+    /// See [`Resource::try_from_resource_any`]
+    pub fn try_into_resource<T: 'static>(self, store: impl AsContextMut) -> Result<Resource<T>> {
+        Resource::try_from_resource_any(self, store)
+    }
+
+    /// Returns the corresponding type associated with this resource, either a
+    /// host-defined type or a guest-defined type.
+    ///
+    /// This can be compared against [`ResourceType::host`] for example to see
+    /// if it's a host-resource or against a type extracted with
+    /// [`Instance::get_resource`] to see if it's a guest-defined resource.
+    ///
+    /// [`Instance::get_resource`]: crate::component::Instance::get_resource
+    pub fn ty(&self) -> ResourceType {
+        self.ty
+    }
+
+    /// Returns whether this is an owned resource, and if not it's a borrowed
+    /// resource.
+    pub fn owned(&self) -> bool {
+        self.owned
+    }
+
+    /// Destroy this resource and release any state associated with it.
+    ///
+    /// This is required to be called (or the async version) for all instances
+    /// of [`ResourceAny`] to ensure that state associated with this resource is
+    /// properly cleaned up. For owned resources this may execute the
+    /// guest-defined destructor if applicable (or the host-defined destructor
+    /// if one was specified).
+    pub fn resource_drop(self, mut store: impl AsContextMut) -> Result<()> {
+        let mut store = store.as_context_mut();
+        assert!(
+            !store.0.async_support(),
+            "must use `resource_drop_async` when async support is enabled on the config"
+        );
+        self.resource_drop_impl(&mut store.as_context_mut())
+    }
+
+    /// Same as [`ResourceAny::resource_drop`] except for use with async stores
+    /// to execute the destructor asynchronously.
+    #[cfg(feature = "async")]
+    pub async fn resource_drop_async<T>(self, mut store: impl AsContextMut<Data = T>) -> Result<()>
+    where
+        T: Send,
+    {
+        let mut store = store.as_context_mut();
+        assert!(
+            store.0.async_support(),
+            "cannot use `resource_drop_async` without enabling async support in the config"
+        );
+        store
+            .on_fiber(|store| self.resource_drop_impl(store))
+            .await?
+    }
+
+    fn resource_drop_impl<T>(self, store: &mut StoreContextMut<'_, T>) -> Result<()> {
+        // Attempt to remove `self.idx` from the host table in `store`.
+        //
+        // This could fail if the index is invalid or if this is removing an
+        // `Own` entry which is currently being borrowed.
+        let pair = HostResourceTables::new_host(store.0).host_resource_drop(self.idx)?;
+
+        let (rep, slot) = match (pair, self.owned) {
+            (Some(pair), true) => pair,
+
+            // A `borrow` was removed from the table and no further
+            // destruction, e.g. the destructor, is required so we're done.
+            (None, false) => return Ok(()),
+
+            _ => unreachable!(),
+        };
+
+        // Implement the reentrance check required by the canonical ABI. Note
+        // that this happens whether or not a destructor is present.
+        //
+        // Note that this should be safe because the raw pointer access in
+        // `flags` is valid due to `store` being the owner of the flags and
+        // flags are never destroyed within the store.
+        if let Some(flags) = slot.flags {
+            unsafe {
+                if !flags.may_enter() {
+                    bail!(Trap::CannotEnterComponent);
+                }
+            }
+        }
+
+        let dtor = match slot.dtor {
+            Some(dtor) => dtor.as_non_null(),
+            None => return Ok(()),
+        };
+        let mut args = [ValRaw::u32(rep)];
+
+        // This should be safe because `dtor` has been checked to belong to the
+        // `store` provided which means it's valid and still alive. Additionally
+        // destructors have al been previously type-checked and are guaranteed
+        // to take one i32 argument and return no results, so the parameters
+        // here should be configured correctly.
+        unsafe { crate::Func::call_unchecked_raw(store, dtor, args.as_mut_ptr(), args.len()) }
+    }
+
+    fn lower_to_index<U>(&self, cx: &mut LowerContext<'_, U>, ty: InterfaceType) -> Result<u32> {
+        match ty {
+            InterfaceType::Own(t) => {
+                if cx.resource_type(t) != self.ty {
+                    bail!("mismatched resource types");
+                }
+                let rep = cx.host_resource_lift_own(self.idx)?;
+                cx.guest_resource_lower_own(t, rep)
+            }
+            InterfaceType::Borrow(t) => {
+                if cx.resource_type(t) != self.ty {
+                    bail!("mismatched resource types");
+                }
+                let rep = cx.host_resource_lift_borrow(self.idx)?;
+                cx.guest_resource_lower_borrow(t, rep)
+            }
+            _ => bad_type_info(),
+        }
+    }
+
+    fn lift_from_index(cx: &mut LiftContext<'_>, ty: InterfaceType, index: u32) -> Result<Self> {
+        match ty {
+            InterfaceType::Own(t) => {
+                let ty = cx.resource_type(t);
+                let (rep, dtor, flags) = cx.guest_resource_lift_own(t, index)?;
+                let idx = cx.host_resource_lower_own(rep, dtor, flags)?;
+                Ok(ResourceAny {
+                    idx,
+                    ty,
+                    owned: true,
+                })
+            }
+            InterfaceType::Borrow(t) => {
+                let ty = cx.resource_type(t);
+                let rep = cx.guest_resource_lift_borrow(t, index)?;
+                let idx = cx.host_resource_lower_borrow(rep)?;
+                Ok(ResourceAny {
+                    idx,
+                    ty,
+                    owned: false,
+                })
+            }
+            _ => bad_type_info(),
+        }
+    }
+}
+
+unsafe impl ComponentType for ResourceAny {
+    const ABI: CanonicalAbiInfo = CanonicalAbiInfo::SCALAR4;
+
+    type Lower = <u32 as ComponentType>::Lower;
+
+    fn typecheck(ty: &InterfaceType, _types: &InstanceType<'_>) -> Result<()> {
+        match ty {
+            InterfaceType::Own(_) | InterfaceType::Borrow(_) => Ok(()),
+            other => bail!("expected `own` or `borrow`, found `{}`", desc(other)),
+        }
+    }
+}
+
+unsafe impl Lower for ResourceAny {
+    fn lower<T>(
+        &self,
+        cx: &mut LowerContext<'_, T>,
+        ty: InterfaceType,
+        dst: &mut MaybeUninit<Self::Lower>,
+    ) -> Result<()> {
+        self.lower_to_index(cx, ty)?
+            .lower(cx, InterfaceType::U32, dst)
+    }
+
+    fn store<T>(
+        &self,
+        cx: &mut LowerContext<'_, T>,
+        ty: InterfaceType,
+        offset: usize,
+    ) -> Result<()> {
+        self.lower_to_index(cx, ty)?
+            .store(cx, InterfaceType::U32, offset)
+    }
+}
+
+unsafe impl Lift for ResourceAny {
+    fn lift(cx: &mut LiftContext<'_>, ty: InterfaceType, src: &Self::Lower) -> Result<Self> {
+        let index = u32::lift(cx, InterfaceType::U32, src)?;
+        ResourceAny::lift_from_index(cx, ty, index)
+    }
+
+    fn load(cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Self> {
+        let index = u32::load(cx, InterfaceType::U32, bytes)?;
+        ResourceAny::lift_from_index(cx, ty, index)
+    }
+}
diff --git a/crates/wasmtime/src/component/storage.rs b/crates/wasmtime/src/runtime/component/storage.rs
similarity index 96%
rename from crates/wasmtime/src/component/storage.rs
rename to crates/wasmtime/src/runtime/component/storage.rs
index f66980cd6643..01537b42984d 100644
--- a/crates/wasmtime/src/component/storage.rs
+++ b/crates/wasmtime/src/runtime/component/storage.rs
@@ -1,6 +1,6 @@
 use crate::ValRaw;
-use std::mem::{self, MaybeUninit};
-use std::slice;
+use core::mem::{self, MaybeUninit};
+use core::slice;
 
 fn assert_raw_slice_compat<T>() {
     assert!(mem::size_of::<T>() % mem::size_of::<ValRaw>() == 0);
diff --git a/crates/wasmtime/src/runtime/component/store.rs b/crates/wasmtime/src/runtime/component/store.rs
new file mode 100644
index 000000000000..d2422043ebd0
--- /dev/null
+++ b/crates/wasmtime/src/runtime/component/store.rs
@@ -0,0 +1,29 @@
+use crate::prelude::*;
+use crate::store::{StoreData, StoredData};
+
+macro_rules! component_store_data {
+    ($($field:ident => $t:ty,)*) => (
+        #[derive(Default)]
+        pub struct ComponentStoreData {
+            $($field: Vec<$t>,)*
+        }
+
+        $(
+            impl StoredData for $t {
+                #[inline]
+                fn list(data: &StoreData) -> &Vec<Self> {
+                    &data.components.$field
+                }
+                #[inline]
+                fn list_mut(data: &mut StoreData) -> &mut Vec<Self> {
+                    &mut data.components.$field
+                }
+            }
+        )*
+    )
+}
+
+component_store_data! {
+    funcs => crate::component::func::FuncData,
+    instances => Option<Box<crate::component::instance::InstanceData>>,
+}
diff --git a/crates/wasmtime/src/runtime/component/types.rs b/crates/wasmtime/src/runtime/component/types.rs
new file mode 100644
index 000000000000..06824897eb05
--- /dev/null
+++ b/crates/wasmtime/src/runtime/component/types.rs
@@ -0,0 +1,897 @@
+//! This module defines the `Type` type, representing the dynamic form of a component interface type.
+
+use crate::component::matching::InstanceType;
+use crate::{Engine, ExternType, FuncType};
+use alloc::sync::Arc;
+use core::fmt;
+use core::ops::Deref;
+use wasmtime_environ::component::{
+    ComponentTypes, InterfaceType, ResourceIndex, TypeComponentIndex, TypeComponentInstanceIndex,
+    TypeDef, TypeEnumIndex, TypeFlagsIndex, TypeFuncIndex, TypeListIndex, TypeModuleIndex,
+    TypeOptionIndex, TypeRecordIndex, TypeResourceTableIndex, TypeResultIndex, TypeTupleIndex,
+    TypeVariantIndex,
+};
+use wasmtime_environ::PrimaryMap;
+
+pub use crate::component::resources::ResourceType;
+
+/// An owned and `'static` handle for type information in a component.
+///
+/// The components here are:
+///
+/// * `index` - a `TypeFooIndex` defined in the `wasmtime_environ` crate. This
+///   then points into the next field of...
+///
+/// * `types` - this is an allocation originally created from compilation and is
+///   stored in a compiled `Component`. This contains all types necessary and
+///   information about recursive structures and all other type information
+///   within the component. The above `index` points into this structure.
+///
+/// * `resources` - this is used to "close the loop" and represent a concrete
+///   instance type rather than an abstract component type. Instantiating a
+///   component with different resources produces different instance types but
+///   the same underlying component type, so this field serves the purpose to
+///   distinguish instance types from one another. This is runtime state created
+///   during instantiation and threaded through here.
+#[derive(Clone)]
+struct Handle<T> {
+    index: T,
+    types: Arc<ComponentTypes>,
+    resources: Arc<PrimaryMap<ResourceIndex, ResourceType>>,
+}
+
+impl<T> Handle<T> {
+    fn new(index: T, ty: &InstanceType<'_>) -> Handle<T> {
+        Handle {
+            index,
+            types: ty.types.clone(),
+            resources: ty.resources.clone(),
+        }
+    }
+
+    fn instance(&self) -> InstanceType<'_> {
+        InstanceType {
+            types: &self.types,
+            resources: &self.resources,
+        }
+    }
+
+    fn equivalent<'a>(
+        &'a self,
+        other: &'a Self,
+        type_check: fn(&TypeChecker<'a>, T, T) -> bool,
+    ) -> bool
+    where
+        T: PartialEq + Copy,
+    {
+        (self.index == other.index
+            && Arc::ptr_eq(&self.types, &other.types)
+            && Arc::ptr_eq(&self.resources, &other.resources))
+            || type_check(
+                &TypeChecker {
+                    a_types: &self.types,
+                    b_types: &other.types,
+                    a_resource: &self.resources,
+                    b_resource: &other.resources,
+                },
+                self.index,
+                other.index,
+            )
+    }
+}
+
+impl<T: fmt::Debug> fmt::Debug for Handle<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Handle")
+            .field("index", &self.index)
+            .finish()
+    }
+}
+
+/// Type checker between two `Handle`s
+struct TypeChecker<'a> {
+    a_types: &'a ComponentTypes,
+    a_resource: &'a PrimaryMap<ResourceIndex, ResourceType>,
+    b_types: &'a ComponentTypes,
+    b_resource: &'a PrimaryMap<ResourceIndex, ResourceType>,
+}
+
+impl TypeChecker<'_> {
+    fn interface_types_equal(&self, a: InterfaceType, b: InterfaceType) -> bool {
+        match (a, b) {
+            (InterfaceType::Own(o1), InterfaceType::Own(o2)) => self.resources_equal(o1, o2),
+            (InterfaceType::Own(_), _) => false,
+            (InterfaceType::Borrow(b1), InterfaceType::Borrow(b2)) => self.resources_equal(b1, b2),
+            (InterfaceType::Borrow(_), _) => false,
+            (InterfaceType::List(l1), InterfaceType::List(l2)) => self.lists_equal(l1, l2),
+            (InterfaceType::List(_), _) => false,
+            (InterfaceType::Record(r1), InterfaceType::Record(r2)) => self.records_equal(r1, r2),
+            (InterfaceType::Record(_), _) => false,
+            (InterfaceType::Variant(v1), InterfaceType::Variant(v2)) => self.variants_equal(v1, v2),
+            (InterfaceType::Variant(_), _) => false,
+            (InterfaceType::Result(r1), InterfaceType::Result(r2)) => self.results_equal(r1, r2),
+            (InterfaceType::Result(_), _) => false,
+            (InterfaceType::Option(o1), InterfaceType::Option(o2)) => self.options_equal(o1, o2),
+            (InterfaceType::Option(_), _) => false,
+            (InterfaceType::Enum(e1), InterfaceType::Enum(e2)) => self.enums_equal(e1, e2),
+            (InterfaceType::Enum(_), _) => false,
+            (InterfaceType::Tuple(t1), InterfaceType::Tuple(t2)) => self.tuples_equal(t1, t2),
+            (InterfaceType::Tuple(_), _) => false,
+            (InterfaceType::Flags(f1), InterfaceType::Flags(f2)) => self.flags_equal(f1, f2),
+            (InterfaceType::Flags(_), _) => false,
+            (InterfaceType::Bool, InterfaceType::Bool) => true,
+            (InterfaceType::Bool, _) => false,
+            (InterfaceType::U8, InterfaceType::U8) => true,
+            (InterfaceType::U8, _) => false,
+            (InterfaceType::U16, InterfaceType::U16) => true,
+            (InterfaceType::U16, _) => false,
+            (InterfaceType::U32, InterfaceType::U32) => true,
+            (InterfaceType::U32, _) => false,
+            (InterfaceType::U64, InterfaceType::U64) => true,
+            (InterfaceType::U64, _) => false,
+            (InterfaceType::S8, InterfaceType::S8) => true,
+            (InterfaceType::S8, _) => false,
+            (InterfaceType::S16, InterfaceType::S16) => true,
+            (InterfaceType::S16, _) => false,
+            (InterfaceType::S32, InterfaceType::S32) => true,
+            (InterfaceType::S32, _) => false,
+            (InterfaceType::S64, InterfaceType::S64) => true,
+            (InterfaceType::S64, _) => false,
+            (InterfaceType::Float32, InterfaceType::Float32) => true,
+            (InterfaceType::Float32, _) => false,
+            (InterfaceType::Float64, InterfaceType::Float64) => true,
+            (InterfaceType::Float64, _) => false,
+            (InterfaceType::String, InterfaceType::String) => true,
+            (InterfaceType::String, _) => false,
+            (InterfaceType::Char, InterfaceType::Char) => true,
+            (InterfaceType::Char, _) => false,
+        }
+    }
+
+    fn lists_equal(&self, l1: TypeListIndex, l2: TypeListIndex) -> bool {
+        let a = &self.a_types[l1];
+        let b = &self.b_types[l2];
+        self.interface_types_equal(a.element, b.element)
+    }
+
+    fn resources_equal(&self, o1: TypeResourceTableIndex, o2: TypeResourceTableIndex) -> bool {
+        let a = &self.a_types[o1];
+        let b = &self.b_types[o2];
+        self.a_resource[a.ty] == self.b_resource[b.ty]
+    }
+
+    fn records_equal(&self, r1: TypeRecordIndex, r2: TypeRecordIndex) -> bool {
+        let a = &self.a_types[r1];
+        let b = &self.b_types[r2];
+        if a.fields.len() != b.fields.len() {
+            return false;
+        }
+        a.fields
+            .iter()
+            .zip(b.fields.iter())
+            .all(|(a_field, b_field)| {
+                a_field.name == b_field.name && self.interface_types_equal(a_field.ty, b_field.ty)
+            })
+    }
+
+    fn variants_equal(&self, v1: TypeVariantIndex, v2: TypeVariantIndex) -> bool {
+        let a = &self.a_types[v1];
+        let b = &self.b_types[v2];
+        if a.cases.len() != b.cases.len() {
+            return false;
+        }
+        a.cases
+            .iter()
+            .zip(b.cases.iter())
+            .all(|((a_name, a_ty), (b_name, b_ty))| {
+                if a_name != b_name {
+                    return false;
+                }
+                match (a_ty, b_ty) {
+                    (Some(a_case_ty), Some(b_case_ty)) => {
+                        self.interface_types_equal(*a_case_ty, *b_case_ty)
+                    }
+                    (None, None) => true,
+                    _ => false,
+                }
+            })
+    }
+
+    fn results_equal(&self, r1: TypeResultIndex, r2: TypeResultIndex) -> bool {
+        let a = &self.a_types[r1];
+        let b = &self.b_types[r2];
+        let oks = match (a.ok, b.ok) {
+            (Some(ok1), Some(ok2)) => self.interface_types_equal(ok1, ok2),
+            (None, None) => true,
+            _ => false,
+        };
+        if !oks {
+            return false;
+        }
+        match (a.err, b.err) {
+            (Some(err1), Some(err2)) => self.interface_types_equal(err1, err2),
+            (None, None) => true,
+            _ => false,
+        }
+    }
+
+    fn options_equal(&self, o1: TypeOptionIndex, o2: TypeOptionIndex) -> bool {
+        let a = &self.a_types[o1];
+        let b = &self.b_types[o2];
+        self.interface_types_equal(a.ty, b.ty)
+    }
+
+    fn enums_equal(&self, e1: TypeEnumIndex, e2: TypeEnumIndex) -> bool {
+        let a = &self.a_types[e1];
+        let b = &self.b_types[e2];
+        a.names == b.names
+    }
+
+    fn tuples_equal(&self, t1: TypeTupleIndex, t2: TypeTupleIndex) -> bool {
+        let a = &self.a_types[t1];
+        let b = &self.b_types[t2];
+        if a.types.len() != b.types.len() {
+            return false;
+        }
+        a.types
+            .iter()
+            .zip(b.types.iter())
+            .all(|(&a, &b)| self.interface_types_equal(a, b))
+    }
+
+    fn flags_equal(&self, f1: TypeFlagsIndex, f2: TypeFlagsIndex) -> bool {
+        let a = &self.a_types[f1];
+        let b = &self.b_types[f2];
+        a.names == b.names
+    }
+}
+
+/// A `list` interface type
+#[derive(Clone, Debug)]
+pub struct List(Handle<TypeListIndex>);
+
+impl PartialEq for List {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.equivalent(&other.0, TypeChecker::lists_equal)
+    }
+}
+
+impl Eq for List {}
+
+impl List {
+    pub(crate) fn from(index: TypeListIndex, ty: &InstanceType<'_>) -> Self {
+        List(Handle::new(index, ty))
+    }
+
+    /// Retrieve the element type of this `list`.
+    pub fn ty(&self) -> Type {
+        Type::from(&self.0.types[self.0.index].element, &self.0.instance())
+    }
+}
+
+/// A field declaration belonging to a `record`
+#[derive(Debug)]
+pub struct Field<'a> {
+    /// The name of the field
+    pub name: &'a str,
+    /// The type of the field
+    pub ty: Type,
+}
+
+/// A `record` interface type
+#[derive(Clone, Debug)]
+pub struct Record(Handle<TypeRecordIndex>);
+
+impl Record {
+    pub(crate) fn from(index: TypeRecordIndex, ty: &InstanceType<'_>) -> Self {
+        Record(Handle::new(index, ty))
+    }
+
+    /// Retrieve the fields of this `record` in declaration order.
+    pub fn fields(&self) -> impl ExactSizeIterator<Item = Field<'_>> {
+        self.0.types[self.0.index].fields.iter().map(|field| Field {
+            name: &field.name,
+            ty: Type::from(&field.ty, &self.0.instance()),
+        })
+    }
+}
+
+impl PartialEq for Record {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.equivalent(&other.0, TypeChecker::records_equal)
+    }
+}
+
+impl Eq for Record {}
+
+/// A `tuple` interface type
+#[derive(Clone, Debug)]
+pub struct Tuple(Handle<TypeTupleIndex>);
+
+impl Tuple {
+    pub(crate) fn from(index: TypeTupleIndex, ty: &InstanceType<'_>) -> Self {
+        Tuple(Handle::new(index, ty))
+    }
+
+    /// Retrieve the types of the fields of this `tuple` in declaration order.
+    pub fn types(&self) -> impl ExactSizeIterator<Item = Type> + '_ {
+        self.0.types[self.0.index]
+            .types
+            .iter()
+            .map(|ty| Type::from(ty, &self.0.instance()))
+    }
+}
+
+impl PartialEq for Tuple {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.equivalent(&other.0, TypeChecker::tuples_equal)
+    }
+}
+
+impl Eq for Tuple {}
+
+/// A case declaration belonging to a `variant`
+pub struct Case<'a> {
+    /// The name of the case
+    pub name: &'a str,
+    /// The optional payload type of the case
+    pub ty: Option<Type>,
+}
+
+/// A `variant` interface type
+#[derive(Clone, Debug)]
+pub struct Variant(Handle<TypeVariantIndex>);
+
+impl Variant {
+    pub(crate) fn from(index: TypeVariantIndex, ty: &InstanceType<'_>) -> Self {
+        Variant(Handle::new(index, ty))
+    }
+
+    /// Retrieve the cases of this `variant` in declaration order.
+    pub fn cases(&self) -> impl ExactSizeIterator<Item = Case> {
+        self.0.types[self.0.index]
+            .cases
+            .iter()
+            .map(|(name, ty)| Case {
+                name: name,
+                ty: ty.as_ref().map(|ty| Type::from(ty, &self.0.instance())),
+            })
+    }
+}
+
+impl PartialEq for Variant {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.equivalent(&other.0, TypeChecker::variants_equal)
+    }
+}
+
+impl Eq for Variant {}
+
+/// An `enum` interface type
+#[derive(Clone, Debug)]
+pub struct Enum(Handle<TypeEnumIndex>);
+
+impl Enum {
+    pub(crate) fn from(index: TypeEnumIndex, ty: &InstanceType<'_>) -> Self {
+        Enum(Handle::new(index, ty))
+    }
+
+    /// Retrieve the names of the cases of this `enum` in declaration order.
+    pub fn names(&self) -> impl ExactSizeIterator<Item = &str> {
+        self.0.types[self.0.index]
+            .names
+            .iter()
+            .map(|name| name.deref())
+    }
+}
+
+impl PartialEq for Enum {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.equivalent(&other.0, TypeChecker::enums_equal)
+    }
+}
+
+impl Eq for Enum {}
+
+/// An `option` interface type
+#[derive(Clone, Debug)]
+pub struct OptionType(Handle<TypeOptionIndex>);
+
+impl OptionType {
+    pub(crate) fn from(index: TypeOptionIndex, ty: &InstanceType<'_>) -> Self {
+        OptionType(Handle::new(index, ty))
+    }
+
+    /// Retrieve the type parameter for this `option`.
+    pub fn ty(&self) -> Type {
+        Type::from(&self.0.types[self.0.index].ty, &self.0.instance())
+    }
+}
+
+impl PartialEq for OptionType {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.equivalent(&other.0, TypeChecker::options_equal)
+    }
+}
+
+impl Eq for OptionType {}
+
+/// An `expected` interface type
+#[derive(Clone, Debug)]
+pub struct ResultType(Handle<TypeResultIndex>);
+
+impl ResultType {
+    pub(crate) fn from(index: TypeResultIndex, ty: &InstanceType<'_>) -> Self {
+        ResultType(Handle::new(index, ty))
+    }
+
+    /// Retrieve the `ok` type parameter for this `result`.
+    pub fn ok(&self) -> Option<Type> {
+        Some(Type::from(
+            self.0.types[self.0.index].ok.as_ref()?,
+            &self.0.instance(),
+        ))
+    }
+
+    /// Retrieve the `err` type parameter for this `result`.
+    pub fn err(&self) -> Option<Type> {
+        Some(Type::from(
+            self.0.types[self.0.index].err.as_ref()?,
+            &self.0.instance(),
+        ))
+    }
+}
+
+impl PartialEq for ResultType {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.equivalent(&other.0, TypeChecker::results_equal)
+    }
+}
+
+impl Eq for ResultType {}
+
+/// A `flags` interface type
+#[derive(Clone, Debug)]
+pub struct Flags(Handle<TypeFlagsIndex>);
+
+impl Flags {
+    pub(crate) fn from(index: TypeFlagsIndex, ty: &InstanceType<'_>) -> Self {
+        Flags(Handle::new(index, ty))
+    }
+
+    /// Retrieve the names of the flags of this `flags` type in declaration order.
+    pub fn names(&self) -> impl ExactSizeIterator<Item = &str> {
+        self.0.types[self.0.index]
+            .names
+            .iter()
+            .map(|name| name.deref())
+    }
+}
+
+impl PartialEq for Flags {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.equivalent(&other.0, TypeChecker::flags_equal)
+    }
+}
+
+impl Eq for Flags {}
+
+/// Represents a component model interface type
+#[derive(Clone, PartialEq, Eq, Debug)]
+#[allow(missing_docs)]
+pub enum Type {
+    Bool,
+    S8,
+    U8,
+    S16,
+    U16,
+    S32,
+    U32,
+    S64,
+    U64,
+    Float32,
+    Float64,
+    Char,
+    String,
+    List(List),
+    Record(Record),
+    Tuple(Tuple),
+    Variant(Variant),
+    Enum(Enum),
+    Option(OptionType),
+    Result(ResultType),
+    Flags(Flags),
+    Own(ResourceType),
+    Borrow(ResourceType),
+}
+
+impl Type {
+    /// Retrieve the inner [`List`] of a [`Type::List`].
+    ///
+    /// # Panics
+    ///
+    /// This will panic if `self` is not a [`Type::List`].
+    pub fn unwrap_list(&self) -> &List {
+        if let Type::List(handle) = self {
+            &handle
+        } else {
+            panic!("attempted to unwrap a {} as a list", self.desc())
+        }
+    }
+
+    /// Retrieve the inner [`Record`] of a [`Type::Record`].
+    ///
+    /// # Panics
+    ///
+    /// This will panic if `self` is not a [`Type::Record`].
+    pub fn unwrap_record(&self) -> &Record {
+        if let Type::Record(handle) = self {
+            &handle
+        } else {
+            panic!("attempted to unwrap a {} as a record", self.desc())
+        }
+    }
+
+    /// Retrieve the inner [`Tuple`] of a [`Type::Tuple`].
+    ///
+    /// # Panics
+    ///
+    /// This will panic if `self` is not a [`Type::Tuple`].
+    pub fn unwrap_tuple(&self) -> &Tuple {
+        if let Type::Tuple(handle) = self {
+            &handle
+        } else {
+            panic!("attempted to unwrap a {} as a tuple", self.desc())
+        }
+    }
+
+    /// Retrieve the inner [`Variant`] of a [`Type::Variant`].
+    ///
+    /// # Panics
+    ///
+    /// This will panic if `self` is not a [`Type::Variant`].
+    pub fn unwrap_variant(&self) -> &Variant {
+        if let Type::Variant(handle) = self {
+            &handle
+        } else {
+            panic!("attempted to unwrap a {} as a variant", self.desc())
+        }
+    }
+
+    /// Retrieve the inner [`Enum`] of a [`Type::Enum`].
+    ///
+    /// # Panics
+    ///
+    /// This will panic if `self` is not a [`Type::Enum`].
+    pub fn unwrap_enum(&self) -> &Enum {
+        if let Type::Enum(handle) = self {
+            &handle
+        } else {
+            panic!("attempted to unwrap a {} as a enum", self.desc())
+        }
+    }
+
+    /// Retrieve the inner [`OptionType`] of a [`Type::Option`].
+    ///
+    /// # Panics
+    ///
+    /// This will panic if `self` is not a [`Type::Option`].
+    pub fn unwrap_option(&self) -> &OptionType {
+        if let Type::Option(handle) = self {
+            &handle
+        } else {
+            panic!("attempted to unwrap a {} as a option", self.desc())
+        }
+    }
+
+    /// Retrieve the inner [`ResultType`] of a [`Type::Result`].
+    ///
+    /// # Panics
+    ///
+    /// This will panic if `self` is not a [`Type::Result`].
+    pub fn unwrap_result(&self) -> &ResultType {
+        if let Type::Result(handle) = self {
+            &handle
+        } else {
+            panic!("attempted to unwrap a {} as a result", self.desc())
+        }
+    }
+
+    /// Retrieve the inner [`Flags`] of a [`Type::Flags`].
+    ///
+    /// # Panics
+    ///
+    /// This will panic if `self` is not a [`Type::Flags`].
+    pub fn unwrap_flags(&self) -> &Flags {
+        if let Type::Flags(handle) = self {
+            &handle
+        } else {
+            panic!("attempted to unwrap a {} as a flags", self.desc())
+        }
+    }
+
+    /// Retrieve the inner [`ResourceType`] of a [`Type::Own`].
+    ///
+    /// # Panics
+    ///
+    /// This will panic if `self` is not a [`Type::Own`].
+    pub fn unwrap_own(&self) -> &ResourceType {
+        match self {
+            Type::Own(ty) => ty,
+            _ => panic!("attempted to unwrap a {} as a own", self.desc()),
+        }
+    }
+
+    /// Retrieve the inner [`ResourceType`] of a [`Type::Borrow`].
+    ///
+    /// # Panics
+    ///
+    /// This will panic if `self` is not a [`Type::Borrow`].
+    pub fn unwrap_borrow(&self) -> &ResourceType {
+        match self {
+            Type::Borrow(ty) => ty,
+            _ => panic!("attempted to unwrap a {} as a own", self.desc()),
+        }
+    }
+
+    /// Convert the specified `InterfaceType` to a `Type`.
+    pub(crate) fn from(ty: &InterfaceType, instance: &InstanceType<'_>) -> Self {
+        match ty {
+            InterfaceType::Bool => Type::Bool,
+            InterfaceType::S8 => Type::S8,
+            InterfaceType::U8 => Type::U8,
+            InterfaceType::S16 => Type::S16,
+            InterfaceType::U16 => Type::U16,
+            InterfaceType::S32 => Type::S32,
+            InterfaceType::U32 => Type::U32,
+            InterfaceType::S64 => Type::S64,
+            InterfaceType::U64 => Type::U64,
+            InterfaceType::Float32 => Type::Float32,
+            InterfaceType::Float64 => Type::Float64,
+            InterfaceType::Char => Type::Char,
+            InterfaceType::String => Type::String,
+            InterfaceType::List(index) => Type::List(List::from(*index, instance)),
+            InterfaceType::Record(index) => Type::Record(Record::from(*index, instance)),
+            InterfaceType::Tuple(index) => Type::Tuple(Tuple::from(*index, instance)),
+            InterfaceType::Variant(index) => Type::Variant(Variant::from(*index, instance)),
+            InterfaceType::Enum(index) => Type::Enum(Enum::from(*index, instance)),
+            InterfaceType::Option(index) => Type::Option(OptionType::from(*index, instance)),
+            InterfaceType::Result(index) => Type::Result(ResultType::from(*index, instance)),
+            InterfaceType::Flags(index) => Type::Flags(Flags::from(*index, instance)),
+            InterfaceType::Own(index) => Type::Own(instance.resource_type(*index)),
+            InterfaceType::Borrow(index) => Type::Borrow(instance.resource_type(*index)),
+        }
+    }
+
+    fn desc(&self) -> &'static str {
+        match self {
+            Type::Bool => "bool",
+            Type::S8 => "s8",
+            Type::U8 => "u8",
+            Type::S16 => "s16",
+            Type::U16 => "u16",
+            Type::S32 => "s32",
+            Type::U32 => "u32",
+            Type::S64 => "s64",
+            Type::U64 => "u64",
+            Type::Float32 => "float32",
+            Type::Float64 => "float64",
+            Type::Char => "char",
+            Type::String => "string",
+            Type::List(_) => "list",
+            Type::Record(_) => "record",
+            Type::Tuple(_) => "tuple",
+            Type::Variant(_) => "variant",
+            Type::Enum(_) => "enum",
+            Type::Option(_) => "option",
+            Type::Result(_) => "result",
+            Type::Flags(_) => "flags",
+            Type::Own(_) => "own",
+            Type::Borrow(_) => "borrow",
+        }
+    }
+}
+
+/// Component function type
+#[derive(Clone, Debug)]
+pub struct ComponentFunc(Handle<TypeFuncIndex>);
+
+impl ComponentFunc {
+    pub(crate) fn from(index: TypeFuncIndex, ty: &InstanceType<'_>) -> Self {
+        Self(Handle::new(index, ty))
+    }
+
+    /// Iterates over types of function parameters
+    pub fn params(&self) -> impl ExactSizeIterator<Item = Type> + '_ {
+        let params = self.0.types[self.0.index].params;
+        self.0.types[params]
+            .types
+            .iter()
+            .map(|ty| Type::from(ty, &self.0.instance()))
+    }
+
+    /// Iterates over types of function results
+    pub fn results(&self) -> impl ExactSizeIterator<Item = Type> + '_ {
+        let results = self.0.types[self.0.index].results;
+        self.0.types[results]
+            .types
+            .iter()
+            .map(|ty| Type::from(ty, &self.0.instance()))
+    }
+}
+
+/// Core module type
+#[derive(Clone, Debug)]
+pub struct Module(Handle<TypeModuleIndex>);
+
+impl Module {
+    pub(crate) fn from(index: TypeModuleIndex, ty: &InstanceType<'_>) -> Self {
+        Self(Handle::new(index, ty))
+    }
+
+    /// Iterates over imports of the module
+    pub fn imports<'a>(
+        &'a self,
+        engine: &'a Engine,
+    ) -> impl ExactSizeIterator<Item = ((&str, &str), ExternType)> + 'a {
+        self.0.types[self.0.index]
+            .imports
+            .iter()
+            .map(|((namespace, name), ty)| {
+                (
+                    (namespace.as_str(), name.as_str()),
+                    ExternType::from_wasmtime(engine, self.0.types.module_types(), ty),
+                )
+            })
+    }
+
+    /// Iterates over exports of the module
+    pub fn exports<'a>(
+        &'a self,
+        engine: &'a Engine,
+    ) -> impl ExactSizeIterator<Item = (&str, ExternType)> + 'a {
+        self.0.types[self.0.index].exports.iter().map(|(name, ty)| {
+            (
+                name.as_str(),
+                ExternType::from_wasmtime(engine, self.0.types.module_types(), ty),
+            )
+        })
+    }
+}
+
+/// Component type
+#[derive(Clone, Debug)]
+pub struct Component(Handle<TypeComponentIndex>);
+
+impl Component {
+    pub(crate) fn from(index: TypeComponentIndex, ty: &InstanceType<'_>) -> Self {
+        Self(Handle::new(index, ty))
+    }
+
+    /// Returns import associated with `name`, if such exists in the component
+    pub fn get_import(&self, engine: &Engine, name: &str) -> Option<ComponentItem> {
+        self.0.types[self.0.index]
+            .imports
+            .get(name)
+            .map(|ty| ComponentItem::from(engine, ty, &self.0.instance()))
+    }
+
+    /// Iterates over imports of the component
+    pub fn imports<'a>(
+        &'a self,
+        engine: &'a Engine,
+    ) -> impl ExactSizeIterator<Item = (&str, ComponentItem)> + 'a {
+        self.0.types[self.0.index].imports.iter().map(|(name, ty)| {
+            (
+                name.as_str(),
+                ComponentItem::from(engine, ty, &self.0.instance()),
+            )
+        })
+    }
+
+    /// Returns export associated with `name`, if such exists in the component
+    pub fn get_export(&self, engine: &Engine, name: &str) -> Option<ComponentItem> {
+        self.0.types[self.0.index]
+            .exports
+            .get(name)
+            .map(|ty| ComponentItem::from(engine, ty, &self.0.instance()))
+    }
+
+    /// Iterates over exports of the component
+    pub fn exports<'a>(
+        &'a self,
+        engine: &'a Engine,
+    ) -> impl ExactSizeIterator<Item = (&str, ComponentItem)> + 'a {
+        self.0.types[self.0.index].exports.iter().map(|(name, ty)| {
+            (
+                name.as_str(),
+                ComponentItem::from(engine, ty, &self.0.instance()),
+            )
+        })
+    }
+}
+
+/// Component instance type
+#[derive(Clone, Debug)]
+pub struct ComponentInstance(Handle<TypeComponentInstanceIndex>);
+
+impl ComponentInstance {
+    pub(crate) fn from(index: TypeComponentInstanceIndex, ty: &InstanceType<'_>) -> Self {
+        Self(Handle::new(index, ty))
+    }
+
+    /// Returns export associated with `name`, if such exists in the component instance
+    pub fn get_export(&self, engine: &Engine, name: &str) -> Option<ComponentItem> {
+        self.0.types[self.0.index]
+            .exports
+            .get(name)
+            .map(|ty| ComponentItem::from(engine, ty, &self.0.instance()))
+    }
+
+    /// Iterates over exports of the component instance
+    pub fn exports<'a>(
+        &'a self,
+        engine: &'a Engine,
+    ) -> impl ExactSizeIterator<Item = (&str, ComponentItem)> {
+        self.0.types[self.0.index].exports.iter().map(|(name, ty)| {
+            (
+                name.as_str(),
+                ComponentItem::from(engine, ty, &self.0.instance()),
+            )
+        })
+    }
+}
+
+/// Type of an item contained within the component
+#[derive(Clone, Debug)]
+pub enum ComponentItem {
+    /// Component function item
+    ComponentFunc(ComponentFunc),
+    /// Core function item
+    CoreFunc(FuncType),
+    /// Core module item
+    Module(Module),
+    /// Component item
+    Component(Component),
+    /// Component instance item
+    ComponentInstance(ComponentInstance),
+    /// Interface type item
+    Type(Type),
+    /// Resource item
+    Resource(ResourceType),
+}
+
+impl ComponentItem {
+    pub(crate) fn from(engine: &Engine, def: &TypeDef, ty: &InstanceType<'_>) -> Self {
+        match def {
+            TypeDef::Component(idx) => Self::Component(Component::from(*idx, ty)),
+            TypeDef::ComponentInstance(idx) => {
+                Self::ComponentInstance(ComponentInstance::from(*idx, ty))
+            }
+            TypeDef::ComponentFunc(idx) => Self::ComponentFunc(ComponentFunc::from(*idx, ty)),
+            TypeDef::Interface(iface_ty) => Self::Type(Type::from(iface_ty, ty)),
+            TypeDef::Module(idx) => Self::Module(Module::from(*idx, ty)),
+            TypeDef::CoreFunc(idx) => {
+                let subty = &ty.types[*idx];
+                Self::CoreFunc(FuncType::from_wasm_func_type(
+                    engine,
+                    subty.is_final,
+                    subty.supertype,
+                    subty.unwrap_func().clone(),
+                ))
+            }
+            TypeDef::Resource(idx) => {
+                let resource_index = ty.types[*idx].ty;
+                let ty = match ty.resources.get(resource_index) {
+                    // This resource type was substituted by a linker for
+                    // example so it's replaced here.
+                    Some(ty) => *ty,
+
+                    // This resource type was not substituted.
+                    None => ResourceType::uninstantiated(&ty.types, resource_index),
+                };
+                Self::Resource(ty)
+            }
+        }
+    }
+}
diff --git a/crates/wasmtime/src/runtime/component/values.rs b/crates/wasmtime/src/runtime/component/values.rs
new file mode 100644
index 000000000000..0221ea50f847
--- /dev/null
+++ b/crates/wasmtime/src/runtime/component/values.rs
@@ -0,0 +1,979 @@
+use crate::component::func::{desc, Lift, LiftContext, Lower, LowerContext};
+use crate::component::ResourceAny;
+use crate::prelude::*;
+use crate::ValRaw;
+use core::mem::MaybeUninit;
+use core::slice::{Iter, IterMut};
+use wasmtime_component_util::{DiscriminantSize, FlagsSize};
+use wasmtime_environ::component::{
+    CanonicalAbiInfo, InterfaceType, TypeEnum, TypeFlags, TypeListIndex, TypeOption, TypeResult,
+    TypeVariant, VariantInfo,
+};
+
+/// Represents possible runtime values which a component function can either
+/// consume or produce
+///
+/// This is a dynamic representation of possible values in the component model.
+/// Note that this is not an efficient representation but is instead intended to
+/// be a flexible and somewhat convenient representation. The most efficient
+/// representation of component model types is to use the `bindgen!` macro to
+/// generate native Rust types with specialized liftings and lowerings.
+///
+/// This type is used in conjunction with [`Func::call`] for example if the
+/// signature of a component is not statically known ahead of time.
+///
+/// # Equality and `Val`
+///
+/// This type implements both the Rust `PartialEq` and `Eq` traits. This type
+/// additionally contains values which are not necessarily easily equated,
+/// however, such as floats (`Float32` and `Float64`) and resources. Equality
+/// does require that two values have the same type, and then these cases are
+/// handled as:
+///
+/// * Floats are tested if they are "semantically the same" meaning all NaN
+///   values are equal to all other NaN values. Additionally zero values must be
+///   exactly the same, so positive zero is not equal to negative zero. The
+///   primary use case at this time is fuzzing-related equality which this is
+///   sufficient for.
+///
+/// * Resources are tested if their types and indices into the host table are
+///   equal. This does not compare the underlying representation so borrows of
+///   the same guest resource are not considered equal. This additionally
+///   doesn't go further and test for equality in the guest itself (for example
+///   two different heap allocations of `Box<u32>` can be equal in normal Rust
+///   if they contain the same value, but will never be considered equal when
+///   compared as `Val::Resource`s).
+///
+/// In general if a strict guarantee about equality is required here it's
+/// recommended to "build your own" as this equality intended for fuzzing
+/// Wasmtime may not be suitable for you.
+///
+/// # Component model types and `Val`
+///
+/// The `Val` type here does not contain enough information to say what the
+/// component model type of a `Val` is. This is instead more of an AST of sorts.
+/// For example the `Val::Enum` only carries information about a single
+/// discriminant, not the entire enumeration or what it's a discriminant of.
+///
+/// This means that when a `Val` is passed to Wasmtime, for example as a
+/// function parameter when calling a function or as a return value from an
+/// host-defined imported function, then it must pass a type-check. Instances of
+/// `Val` are type-checked against what's required by the component itself.
+///
+/// [`Func::call`]: crate::component::Func::call
+#[derive(Debug, Clone)]
+#[allow(missing_docs)]
+pub enum Val {
+    Bool(bool),
+    S8(i8),
+    U8(u8),
+    S16(i16),
+    U16(u16),
+    S32(i32),
+    U32(u32),
+    S64(i64),
+    U64(u64),
+    Float32(f32),
+    Float64(f64),
+    Char(char),
+    String(String),
+    List(Vec<Val>),
+    Record(Vec<(String, Val)>),
+    Tuple(Vec<Val>),
+    Variant(String, Option<Box<Val>>),
+    Enum(String),
+    Option(Option<Box<Val>>),
+    Result(Result<Option<Box<Val>>, Option<Box<Val>>>),
+    Flags(Vec<String>),
+    Resource(ResourceAny),
+}
+
+impl Val {
+    /// Deserialize a value of this type from core Wasm stack values.
+    pub(crate) fn lift(
+        cx: &mut LiftContext<'_>,
+        ty: InterfaceType,
+        src: &mut Iter<'_, ValRaw>,
+    ) -> Result<Val> {
+        Ok(match ty {
+            InterfaceType::Bool => Val::Bool(bool::lift(cx, ty, next(src))?),
+            InterfaceType::S8 => Val::S8(i8::lift(cx, ty, next(src))?),
+            InterfaceType::U8 => Val::U8(u8::lift(cx, ty, next(src))?),
+            InterfaceType::S16 => Val::S16(i16::lift(cx, ty, next(src))?),
+            InterfaceType::U16 => Val::U16(u16::lift(cx, ty, next(src))?),
+            InterfaceType::S32 => Val::S32(i32::lift(cx, ty, next(src))?),
+            InterfaceType::U32 => Val::U32(u32::lift(cx, ty, next(src))?),
+            InterfaceType::S64 => Val::S64(i64::lift(cx, ty, next(src))?),
+            InterfaceType::U64 => Val::U64(u64::lift(cx, ty, next(src))?),
+            InterfaceType::Float32 => Val::Float32(f32::lift(cx, ty, next(src))?),
+            InterfaceType::Float64 => Val::Float64(f64::lift(cx, ty, next(src))?),
+            InterfaceType::Char => Val::Char(char::lift(cx, ty, next(src))?),
+            InterfaceType::Own(_) | InterfaceType::Borrow(_) => {
+                Val::Resource(ResourceAny::lift(cx, ty, next(src))?)
+            }
+            InterfaceType::String => Val::String(<_>::lift(cx, ty, &[*next(src), *next(src)])?),
+            InterfaceType::List(i) => {
+                // FIXME: needs memory64 treatment
+                let ptr = u32::lift(cx, InterfaceType::U32, next(src))? as usize;
+                let len = u32::lift(cx, InterfaceType::U32, next(src))? as usize;
+                load_list(cx, i, ptr, len)?
+            }
+            InterfaceType::Record(i) => Val::Record(
+                cx.types[i]
+                    .fields
+                    .iter()
+                    .map(|field| {
+                        let val = Self::lift(cx, field.ty, src)?;
+                        Ok((field.name.to_string(), val))
+                    })
+                    .collect::<Result<_>>()?,
+            ),
+            InterfaceType::Tuple(i) => Val::Tuple(
+                cx.types[i]
+                    .types
+                    .iter()
+                    .map(|ty| Self::lift(cx, *ty, src))
+                    .collect::<Result<_>>()?,
+            ),
+            InterfaceType::Variant(i) => {
+                let vty = &cx.types[i];
+                let (discriminant, value) = lift_variant(
+                    cx,
+                    cx.types.canonical_abi(&ty).flat_count(usize::MAX).unwrap(),
+                    vty.cases.values().copied(),
+                    src,
+                )?;
+
+                let (k, _) = vty.cases.get_index(discriminant as usize).unwrap();
+                Val::Variant(k.clone(), value)
+            }
+            InterfaceType::Enum(i) => {
+                let ety = &cx.types[i];
+                let (discriminant, _) = lift_variant(
+                    cx,
+                    cx.types.canonical_abi(&ty).flat_count(usize::MAX).unwrap(),
+                    ety.names.iter().map(|_| None),
+                    src,
+                )?;
+
+                Val::Enum(ety.names[discriminant as usize].clone())
+            }
+            InterfaceType::Option(i) => {
+                let (_discriminant, value) = lift_variant(
+                    cx,
+                    cx.types.canonical_abi(&ty).flat_count(usize::MAX).unwrap(),
+                    [None, Some(cx.types[i].ty)].into_iter(),
+                    src,
+                )?;
+
+                Val::Option(value)
+            }
+            InterfaceType::Result(i) => {
+                let result_ty = &cx.types[i];
+                let (discriminant, value) = lift_variant(
+                    cx,
+                    cx.types.canonical_abi(&ty).flat_count(usize::MAX).unwrap(),
+                    [result_ty.ok, result_ty.err].into_iter(),
+                    src,
+                )?;
+
+                Val::Result(if discriminant == 0 {
+                    Ok(value)
+                } else {
+                    Err(value)
+                })
+            }
+            InterfaceType::Flags(i) => {
+                let u32_count = cx.types.canonical_abi(&ty).flat_count(usize::MAX).unwrap();
+                let ty = &cx.types[i];
+                let mut flags = Vec::new();
+                for i in 0..u32_count {
+                    push_flags(
+                        ty,
+                        &mut flags,
+                        (i as u32) * 32,
+                        u32::lift(cx, InterfaceType::U32, next(src))?,
+                    );
+                }
+
+                Val::Flags(flags.into())
+            }
+        })
+    }
+
+    /// Deserialize a value of this type from the heap.
+    pub(crate) fn load(cx: &mut LiftContext<'_>, ty: InterfaceType, bytes: &[u8]) -> Result<Val> {
+        Ok(match ty {
+            InterfaceType::Bool => Val::Bool(bool::load(cx, ty, bytes)?),
+            InterfaceType::S8 => Val::S8(i8::load(cx, ty, bytes)?),
+            InterfaceType::U8 => Val::U8(u8::load(cx, ty, bytes)?),
+            InterfaceType::S16 => Val::S16(i16::load(cx, ty, bytes)?),
+            InterfaceType::U16 => Val::U16(u16::load(cx, ty, bytes)?),
+            InterfaceType::S32 => Val::S32(i32::load(cx, ty, bytes)?),
+            InterfaceType::U32 => Val::U32(u32::load(cx, ty, bytes)?),
+            InterfaceType::S64 => Val::S64(i64::load(cx, ty, bytes)?),
+            InterfaceType::U64 => Val::U64(u64::load(cx, ty, bytes)?),
+            InterfaceType::Float32 => Val::Float32(f32::load(cx, ty, bytes)?),
+            InterfaceType::Float64 => Val::Float64(f64::load(cx, ty, bytes)?),
+            InterfaceType::Char => Val::Char(char::load(cx, ty, bytes)?),
+            InterfaceType::String => Val::String(<_>::load(cx, ty, bytes)?),
+            InterfaceType::Own(_) | InterfaceType::Borrow(_) => {
+                Val::Resource(ResourceAny::load(cx, ty, bytes)?)
+            }
+            InterfaceType::List(i) => {
+                // FIXME: needs memory64 treatment
+                let ptr = u32::from_le_bytes(bytes[..4].try_into().unwrap()) as usize;
+                let len = u32::from_le_bytes(bytes[4..].try_into().unwrap()) as usize;
+                load_list(cx, i, ptr, len)?
+            }
+
+            InterfaceType::Record(i) => {
+                let mut offset = 0;
+                let fields = cx.types[i].fields.iter();
+                Val::Record(
+                    fields
+                        .map(|field| -> Result<(String, Val)> {
+                            let abi = cx.types.canonical_abi(&field.ty);
+                            let offset = abi.next_field32(&mut offset);
+                            let offset = usize::try_from(offset).unwrap();
+                            let size = usize::try_from(abi.size32).unwrap();
+                            Ok((
+                                field.name.to_string(),
+                                Val::load(cx, field.ty, &bytes[offset..][..size])?,
+                            ))
+                        })
+                        .collect::<Result<_>>()?,
+                )
+            }
+            InterfaceType::Tuple(i) => {
+                let types = cx.types[i].types.iter().copied();
+                let mut offset = 0;
+                Val::Tuple(
+                    types
+                        .map(|ty| {
+                            let abi = cx.types.canonical_abi(&ty);
+                            let offset = abi.next_field32(&mut offset);
+                            let offset = usize::try_from(offset).unwrap();
+                            let size = usize::try_from(abi.size32).unwrap();
+                            Val::load(cx, ty, &bytes[offset..][..size])
+                        })
+                        .collect::<Result<_>>()?,
+                )
+            }
+            InterfaceType::Variant(i) => {
+                let ty = &cx.types[i];
+                let (discriminant, value) =
+                    load_variant(cx, &ty.info, ty.cases.values().copied(), bytes)?;
+
+                let (k, _) = ty.cases.get_index(discriminant as usize).unwrap();
+                Val::Variant(k.clone(), value)
+            }
+            InterfaceType::Enum(i) => {
+                let ty = &cx.types[i];
+                let (discriminant, _) =
+                    load_variant(cx, &ty.info, ty.names.iter().map(|_| None), bytes)?;
+
+                Val::Enum(ty.names[discriminant as usize].clone())
+            }
+            InterfaceType::Option(i) => {
+                let ty = &cx.types[i];
+                let (_discriminant, value) =
+                    load_variant(cx, &ty.info, [None, Some(ty.ty)].into_iter(), bytes)?;
+
+                Val::Option(value)
+            }
+            InterfaceType::Result(i) => {
+                let ty = &cx.types[i];
+                let (discriminant, value) =
+                    load_variant(cx, &ty.info, [ty.ok, ty.err].into_iter(), bytes)?;
+
+                Val::Result(if discriminant == 0 {
+                    Ok(value)
+                } else {
+                    Err(value)
+                })
+            }
+            InterfaceType::Flags(i) => {
+                let ty = &cx.types[i];
+                let mut flags = Vec::new();
+                match FlagsSize::from_count(ty.names.len()) {
+                    FlagsSize::Size0 => {}
+                    FlagsSize::Size1 => {
+                        let bits = u8::load(cx, InterfaceType::U8, bytes)?;
+                        push_flags(ty, &mut flags, 0, u32::from(bits));
+                    }
+                    FlagsSize::Size2 => {
+                        let bits = u16::load(cx, InterfaceType::U16, bytes)?;
+                        push_flags(ty, &mut flags, 0, u32::from(bits));
+                    }
+                    FlagsSize::Size4Plus(n) => {
+                        for i in 0..n {
+                            let bits = u32::load(
+                                cx,
+                                InterfaceType::U32,
+                                &bytes[usize::from(i) * 4..][..4],
+                            )?;
+                            push_flags(ty, &mut flags, u32::from(i) * 32, bits);
+                        }
+                    }
+                }
+                Val::Flags(flags.into())
+            }
+        })
+    }
+
+    /// Serialize this value as core Wasm stack values.
+    pub(crate) fn lower<T>(
+        &self,
+        cx: &mut LowerContext<'_, T>,
+        ty: InterfaceType,
+        dst: &mut IterMut<'_, MaybeUninit<ValRaw>>,
+    ) -> Result<()> {
+        match (ty, self) {
+            (InterfaceType::Bool, Val::Bool(value)) => value.lower(cx, ty, next_mut(dst)),
+            (InterfaceType::Bool, _) => unexpected(ty, self),
+            (InterfaceType::S8, Val::S8(value)) => value.lower(cx, ty, next_mut(dst)),
+            (InterfaceType::S8, _) => unexpected(ty, self),
+            (InterfaceType::U8, Val::U8(value)) => value.lower(cx, ty, next_mut(dst)),
+            (InterfaceType::U8, _) => unexpected(ty, self),
+            (InterfaceType::S16, Val::S16(value)) => value.lower(cx, ty, next_mut(dst)),
+            (InterfaceType::S16, _) => unexpected(ty, self),
+            (InterfaceType::U16, Val::U16(value)) => value.lower(cx, ty, next_mut(dst)),
+            (InterfaceType::U16, _) => unexpected(ty, self),
+            (InterfaceType::S32, Val::S32(value)) => value.lower(cx, ty, next_mut(dst)),
+            (InterfaceType::S32, _) => unexpected(ty, self),
+            (InterfaceType::U32, Val::U32(value)) => value.lower(cx, ty, next_mut(dst)),
+            (InterfaceType::U32, _) => unexpected(ty, self),
+            (InterfaceType::S64, Val::S64(value)) => value.lower(cx, ty, next_mut(dst)),
+            (InterfaceType::S64, _) => unexpected(ty, self),
+            (InterfaceType::U64, Val::U64(value)) => value.lower(cx, ty, next_mut(dst)),
+            (InterfaceType::U64, _) => unexpected(ty, self),
+            (InterfaceType::Float32, Val::Float32(value)) => value.lower(cx, ty, next_mut(dst)),
+            (InterfaceType::Float32, _) => unexpected(ty, self),
+            (InterfaceType::Float64, Val::Float64(value)) => value.lower(cx, ty, next_mut(dst)),
+            (InterfaceType::Float64, _) => unexpected(ty, self),
+            (InterfaceType::Char, Val::Char(value)) => value.lower(cx, ty, next_mut(dst)),
+            (InterfaceType::Char, _) => unexpected(ty, self),
+            // NB: `lower` on `ResourceAny` does its own type-checking, so skip
+            // looking at it here.
+            (InterfaceType::Borrow(_) | InterfaceType::Own(_), Val::Resource(value)) => {
+                value.lower(cx, ty, next_mut(dst))
+            }
+            (InterfaceType::Borrow(_) | InterfaceType::Own(_), _) => unexpected(ty, self),
+            (InterfaceType::String, Val::String(value)) => {
+                let my_dst = &mut MaybeUninit::<[ValRaw; 2]>::uninit();
+                value.lower(cx, ty, my_dst)?;
+                let my_dst = unsafe { my_dst.assume_init() };
+                next_mut(dst).write(my_dst[0]);
+                next_mut(dst).write(my_dst[1]);
+                Ok(())
+            }
+            (InterfaceType::String, _) => unexpected(ty, self),
+            (InterfaceType::List(ty), Val::List(values)) => {
+                let ty = &cx.types[ty];
+                let (ptr, len) = lower_list(cx, ty.element, values)?;
+                next_mut(dst).write(ValRaw::i64(ptr as i64));
+                next_mut(dst).write(ValRaw::i64(len as i64));
+                Ok(())
+            }
+            (InterfaceType::List(_), _) => unexpected(ty, self),
+            (InterfaceType::Record(ty), Val::Record(values)) => {
+                let ty = &cx.types[ty];
+                if ty.fields.len() != values.len() {
+                    bail!("expected {} fields, got {}", ty.fields.len(), values.len());
+                }
+                for ((name, value), field) in values.iter().zip(ty.fields.iter()) {
+                    if *name != field.name {
+                        bail!("expected field `{}`, got `{name}`", field.name);
+                    }
+                    value.lower(cx, field.ty, dst)?;
+                }
+                Ok(())
+            }
+            (InterfaceType::Record(_), _) => unexpected(ty, self),
+            (InterfaceType::Tuple(ty), Val::Tuple(values)) => {
+                let ty = &cx.types[ty];
+                if ty.types.len() != values.len() {
+                    bail!("expected {} types, got {}", ty.types.len(), values.len());
+                }
+                for (value, ty) in values.iter().zip(ty.types.iter()) {
+                    value.lower(cx, *ty, dst)?;
+                }
+                Ok(())
+            }
+            (InterfaceType::Tuple(_), _) => unexpected(ty, self),
+            (InterfaceType::Variant(ty), Val::Variant(n, v)) => {
+                GenericVariant::variant(&cx.types[ty], n, v)?.lower(cx, dst)
+            }
+            (InterfaceType::Variant(_), _) => unexpected(ty, self),
+            (InterfaceType::Option(ty), Val::Option(v)) => {
+                GenericVariant::option(&cx.types[ty], v).lower(cx, dst)
+            }
+            (InterfaceType::Option(_), _) => unexpected(ty, self),
+            (InterfaceType::Result(ty), Val::Result(v)) => {
+                GenericVariant::result(&cx.types[ty], v)?.lower(cx, dst)
+            }
+            (InterfaceType::Result(_), _) => unexpected(ty, self),
+            (InterfaceType::Enum(ty), Val::Enum(discriminant)) => {
+                let discriminant = get_enum_discriminant(&cx.types[ty], discriminant)?;
+                next_mut(dst).write(ValRaw::u32(discriminant));
+                Ok(())
+            }
+            (InterfaceType::Enum(_), _) => unexpected(ty, self),
+            (InterfaceType::Flags(ty), Val::Flags(value)) => {
+                let ty = &cx.types[ty];
+                let storage = flags_to_storage(ty, value)?;
+                for value in storage {
+                    next_mut(dst).write(ValRaw::u32(value));
+                }
+                Ok(())
+            }
+            (InterfaceType::Flags(_), _) => unexpected(ty, self),
+        }
+    }
+
+    /// Serialize this value to the heap at the specified memory location.
+    pub(crate) fn store<T>(
+        &self,
+        cx: &mut LowerContext<'_, T>,
+        ty: InterfaceType,
+        offset: usize,
+    ) -> Result<()> {
+        debug_assert!(
+            offset % usize::try_from(cx.types.canonical_abi(&ty).align32).err2anyhow()? == 0
+        );
+
+        match (ty, self) {
+            (InterfaceType::Bool, Val::Bool(value)) => value.store(cx, ty, offset),
+            (InterfaceType::Bool, _) => unexpected(ty, self),
+            (InterfaceType::U8, Val::U8(value)) => value.store(cx, ty, offset),
+            (InterfaceType::U8, _) => unexpected(ty, self),
+            (InterfaceType::S8, Val::S8(value)) => value.store(cx, ty, offset),
+            (InterfaceType::S8, _) => unexpected(ty, self),
+            (InterfaceType::U16, Val::U16(value)) => value.store(cx, ty, offset),
+            (InterfaceType::U16, _) => unexpected(ty, self),
+            (InterfaceType::S16, Val::S16(value)) => value.store(cx, ty, offset),
+            (InterfaceType::S16, _) => unexpected(ty, self),
+            (InterfaceType::U32, Val::U32(value)) => value.store(cx, ty, offset),
+            (InterfaceType::U32, _) => unexpected(ty, self),
+            (InterfaceType::S32, Val::S32(value)) => value.store(cx, ty, offset),
+            (InterfaceType::S32, _) => unexpected(ty, self),
+            (InterfaceType::U64, Val::U64(value)) => value.store(cx, ty, offset),
+            (InterfaceType::U64, _) => unexpected(ty, self),
+            (InterfaceType::S64, Val::S64(value)) => value.store(cx, ty, offset),
+            (InterfaceType::S64, _) => unexpected(ty, self),
+            (InterfaceType::Float32, Val::Float32(value)) => value.store(cx, ty, offset),
+            (InterfaceType::Float32, _) => unexpected(ty, self),
+            (InterfaceType::Float64, Val::Float64(value)) => value.store(cx, ty, offset),
+            (InterfaceType::Float64, _) => unexpected(ty, self),
+            (InterfaceType::Char, Val::Char(value)) => value.store(cx, ty, offset),
+            (InterfaceType::Char, _) => unexpected(ty, self),
+            (InterfaceType::String, Val::String(value)) => value.store(cx, ty, offset),
+            (InterfaceType::String, _) => unexpected(ty, self),
+
+            // NB: resources do type-checking when they lower.
+            (InterfaceType::Borrow(_) | InterfaceType::Own(_), Val::Resource(value)) => {
+                value.store(cx, ty, offset)
+            }
+            (InterfaceType::Borrow(_) | InterfaceType::Own(_), _) => unexpected(ty, self),
+            (InterfaceType::List(ty), Val::List(values)) => {
+                let ty = &cx.types[ty];
+                let (ptr, len) = lower_list(cx, ty.element, values)?;
+                // FIXME: needs memory64 handling
+                *cx.get(offset + 0) = (ptr as i32).to_le_bytes();
+                *cx.get(offset + 4) = (len as i32).to_le_bytes();
+                Ok(())
+            }
+            (InterfaceType::List(_), _) => unexpected(ty, self),
+            (InterfaceType::Record(ty), Val::Record(values)) => {
+                let ty = &cx.types[ty];
+                if ty.fields.len() != values.len() {
+                    bail!("expected {} fields, got {}", ty.fields.len(), values.len());
+                }
+                let mut offset = offset;
+                for ((name, value), field) in values.iter().zip(ty.fields.iter()) {
+                    if *name != field.name {
+                        bail!("expected field `{}`, got `{name}`", field.name);
+                    }
+                    value.store(
+                        cx,
+                        field.ty,
+                        cx.types
+                            .canonical_abi(&field.ty)
+                            .next_field32_size(&mut offset),
+                    )?;
+                }
+                Ok(())
+            }
+            (InterfaceType::Record(_), _) => unexpected(ty, self),
+            (InterfaceType::Tuple(ty), Val::Tuple(values)) => {
+                let ty = &cx.types[ty];
+                if ty.types.len() != values.len() {
+                    bail!("expected {} types, got {}", ty.types.len(), values.len());
+                }
+                let mut offset = offset;
+                for (value, ty) in values.iter().zip(ty.types.iter()) {
+                    value.store(
+                        cx,
+                        *ty,
+                        cx.types.canonical_abi(ty).next_field32_size(&mut offset),
+                    )?;
+                }
+                Ok(())
+            }
+            (InterfaceType::Tuple(_), _) => unexpected(ty, self),
+
+            (InterfaceType::Variant(ty), Val::Variant(n, v)) => {
+                GenericVariant::variant(&cx.types[ty], n, v)?.store(cx, offset)
+            }
+            (InterfaceType::Variant(_), _) => unexpected(ty, self),
+            (InterfaceType::Enum(ty), Val::Enum(v)) => {
+                GenericVariant::enum_(&cx.types[ty], v)?.store(cx, offset)
+            }
+            (InterfaceType::Enum(_), _) => unexpected(ty, self),
+            (InterfaceType::Option(ty), Val::Option(v)) => {
+                GenericVariant::option(&cx.types[ty], v).store(cx, offset)
+            }
+            (InterfaceType::Option(_), _) => unexpected(ty, self),
+            (InterfaceType::Result(ty), Val::Result(v)) => {
+                GenericVariant::result(&cx.types[ty], v)?.store(cx, offset)
+            }
+            (InterfaceType::Result(_), _) => unexpected(ty, self),
+
+            (InterfaceType::Flags(ty), Val::Flags(flags)) => {
+                let ty = &cx.types[ty];
+                let storage = flags_to_storage(ty, flags)?;
+                match FlagsSize::from_count(ty.names.len()) {
+                    FlagsSize::Size0 => {}
+                    FlagsSize::Size1 => {
+                        u8::try_from(storage[0])
+                            .unwrap()
+                            .store(cx, InterfaceType::U8, offset)?
+                    }
+                    FlagsSize::Size2 => {
+                        u16::try_from(storage[0])
+                            .unwrap()
+                            .store(cx, InterfaceType::U16, offset)?
+                    }
+                    FlagsSize::Size4Plus(_) => {
+                        let mut offset = offset;
+                        for value in storage {
+                            value.store(cx, InterfaceType::U32, offset)?;
+                            offset += 4;
+                        }
+                    }
+                }
+                Ok(())
+            }
+            (InterfaceType::Flags(_), _) => unexpected(ty, self),
+        }
+    }
+
+    fn desc(&self) -> &'static str {
+        match self {
+            Val::Bool(_) => "bool",
+            Val::U8(_) => "u8",
+            Val::S8(_) => "s8",
+            Val::U16(_) => "u16",
+            Val::S16(_) => "s16",
+            Val::U32(_) => "u32",
+            Val::S32(_) => "s32",
+            Val::U64(_) => "u64",
+            Val::S64(_) => "s64",
+            Val::Float32(_) => "f32",
+            Val::Float64(_) => "f64",
+            Val::Char(_) => "char",
+            Val::List(_) => "list",
+            Val::String(_) => "string",
+            Val::Record(_) => "record",
+            Val::Enum(_) => "enum",
+            Val::Variant(..) => "variant",
+            Val::Tuple(_) => "tuple",
+            Val::Option(_) => "option",
+            Val::Result(_) => "result",
+            Val::Resource(_) => "resource",
+            Val::Flags(_) => "flags",
+        }
+    }
+}
+
+impl PartialEq for Val {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            // IEEE 754 equality considers NaN inequal to NaN and negative zero
+            // equal to positive zero, however we do the opposite here, because
+            // this logic is used by testing and fuzzing, which want to know
+            // whether two values are semantically the same, rather than
+            // numerically equal.
+            (Self::Float32(l), Self::Float32(r)) => {
+                (*l != 0.0 && l == r)
+                    || (*l == 0.0 && l.to_bits() == r.to_bits())
+                    || (l.is_nan() && r.is_nan())
+            }
+            (Self::Float32(_), _) => false,
+            (Self::Float64(l), Self::Float64(r)) => {
+                (*l != 0.0 && l == r)
+                    || (*l == 0.0 && l.to_bits() == r.to_bits())
+                    || (l.is_nan() && r.is_nan())
+            }
+            (Self::Float64(_), _) => false,
+
+            (Self::Bool(l), Self::Bool(r)) => l == r,
+            (Self::Bool(_), _) => false,
+            (Self::S8(l), Self::S8(r)) => l == r,
+            (Self::S8(_), _) => false,
+            (Self::U8(l), Self::U8(r)) => l == r,
+            (Self::U8(_), _) => false,
+            (Self::S16(l), Self::S16(r)) => l == r,
+            (Self::S16(_), _) => false,
+            (Self::U16(l), Self::U16(r)) => l == r,
+            (Self::U16(_), _) => false,
+            (Self::S32(l), Self::S32(r)) => l == r,
+            (Self::S32(_), _) => false,
+            (Self::U32(l), Self::U32(r)) => l == r,
+            (Self::U32(_), _) => false,
+            (Self::S64(l), Self::S64(r)) => l == r,
+            (Self::S64(_), _) => false,
+            (Self::U64(l), Self::U64(r)) => l == r,
+            (Self::U64(_), _) => false,
+            (Self::Char(l), Self::Char(r)) => l == r,
+            (Self::Char(_), _) => false,
+            (Self::String(l), Self::String(r)) => l == r,
+            (Self::String(_), _) => false,
+            (Self::List(l), Self::List(r)) => l == r,
+            (Self::List(_), _) => false,
+            (Self::Record(l), Self::Record(r)) => l == r,
+            (Self::Record(_), _) => false,
+            (Self::Tuple(l), Self::Tuple(r)) => l == r,
+            (Self::Tuple(_), _) => false,
+            (Self::Variant(ln, lv), Self::Variant(rn, rv)) => ln == rn && lv == rv,
+            (Self::Variant(..), _) => false,
+            (Self::Enum(l), Self::Enum(r)) => l == r,
+            (Self::Enum(_), _) => false,
+            (Self::Option(l), Self::Option(r)) => l == r,
+            (Self::Option(_), _) => false,
+            (Self::Result(l), Self::Result(r)) => l == r,
+            (Self::Result(_), _) => false,
+            (Self::Flags(l), Self::Flags(r)) => l == r,
+            (Self::Flags(_), _) => false,
+            (Self::Resource(l), Self::Resource(r)) => l == r,
+            (Self::Resource(_), _) => false,
+        }
+    }
+}
+
+impl Eq for Val {}
+
+struct GenericVariant<'a> {
+    discriminant: u32,
+    payload: Option<(&'a Val, InterfaceType)>,
+    abi: &'a CanonicalAbiInfo,
+    info: &'a VariantInfo,
+}
+
+impl GenericVariant<'_> {
+    fn result<'a>(
+        ty: &'a TypeResult,
+        r: &'a Result<Option<Box<Val>>, Option<Box<Val>>>,
+    ) -> Result<GenericVariant<'a>> {
+        let (discriminant, payload) = match r {
+            Ok(val) => {
+                let payload = match (val, ty.ok) {
+                    (Some(val), Some(ty)) => Some((&**val, ty)),
+                    (None, None) => None,
+                    (Some(_), None) => {
+                        bail!("payload provided to `ok` but not expected");
+                    }
+                    (None, Some(_)) => {
+                        bail!("payload expected to `ok` but not provided");
+                    }
+                };
+                (0, payload)
+            }
+            Err(val) => {
+                let payload = match (val, ty.err) {
+                    (Some(val), Some(ty)) => Some((&**val, ty)),
+                    (None, None) => None,
+                    (Some(_), None) => {
+                        bail!("payload provided to `err` but not expected");
+                    }
+                    (None, Some(_)) => {
+                        bail!("payload expected to `err` but not provided");
+                    }
+                };
+                (1, payload)
+            }
+        };
+        Ok(GenericVariant {
+            discriminant,
+            payload,
+            abi: &ty.abi,
+            info: &ty.info,
+        })
+    }
+
+    fn option<'a>(ty: &'a TypeOption, r: &'a Option<Box<Val>>) -> GenericVariant<'a> {
+        let (discriminant, payload) = match r {
+            None => (0, None),
+            Some(val) => (1, Some((&**val, ty.ty))),
+        };
+        GenericVariant {
+            discriminant,
+            payload,
+            abi: &ty.abi,
+            info: &ty.info,
+        }
+    }
+
+    fn enum_<'a>(ty: &'a TypeEnum, discriminant: &str) -> Result<GenericVariant<'a>> {
+        let discriminant = get_enum_discriminant(ty, discriminant)?;
+
+        Ok(GenericVariant {
+            discriminant,
+            payload: None,
+            abi: &ty.abi,
+            info: &ty.info,
+        })
+    }
+
+    fn variant<'a>(
+        ty: &'a TypeVariant,
+        discriminant_name: &str,
+        payload: &'a Option<Box<Val>>,
+    ) -> Result<GenericVariant<'a>> {
+        let (discriminant, payload_ty) = get_variant_discriminant(ty, discriminant_name)?;
+
+        let payload = match (payload, payload_ty) {
+            (Some(val), Some(ty)) => Some((&**val, *ty)),
+            (None, None) => None,
+            (Some(_), None) => bail!("did not expect a payload for case `{discriminant_name}`"),
+            (None, Some(_)) => bail!("expected a payload for case `{discriminant_name}`"),
+        };
+
+        Ok(GenericVariant {
+            discriminant,
+            payload,
+            abi: &ty.abi,
+            info: &ty.info,
+        })
+    }
+
+    fn lower<T>(
+        &self,
+        cx: &mut LowerContext<'_, T>,
+        dst: &mut IterMut<'_, MaybeUninit<ValRaw>>,
+    ) -> Result<()> {
+        next_mut(dst).write(ValRaw::u32(self.discriminant));
+
+        // For the remaining lowered representation of this variant that
+        // the payload didn't write we write out zeros here to ensure
+        // the entire variant is written.
+        let value_flat = match self.payload {
+            Some((value, ty)) => {
+                value.lower(cx, ty, dst)?;
+                cx.types.canonical_abi(&ty).flat_count(usize::MAX).unwrap()
+            }
+            None => 0,
+        };
+        let variant_flat = self.abi.flat_count(usize::MAX).unwrap();
+        for _ in (1 + value_flat)..variant_flat {
+            next_mut(dst).write(ValRaw::u64(0));
+        }
+        Ok(())
+    }
+
+    fn store<T>(&self, cx: &mut LowerContext<'_, T>, offset: usize) -> Result<()> {
+        match self.info.size {
+            DiscriminantSize::Size1 => {
+                u8::try_from(self.discriminant)
+                    .unwrap()
+                    .store(cx, InterfaceType::U8, offset)?
+            }
+            DiscriminantSize::Size2 => {
+                u16::try_from(self.discriminant)
+                    .unwrap()
+                    .store(cx, InterfaceType::U16, offset)?
+            }
+            DiscriminantSize::Size4 => self.discriminant.store(cx, InterfaceType::U32, offset)?,
+        }
+
+        if let Some((value, ty)) = self.payload {
+            let offset = offset + usize::try_from(self.info.payload_offset32).unwrap();
+            value.store(cx, ty, offset)?;
+        }
+
+        Ok(())
+    }
+}
+
+fn load_list(cx: &mut LiftContext<'_>, ty: TypeListIndex, ptr: usize, len: usize) -> Result<Val> {
+    let elem = cx.types[ty].element;
+    let abi = cx.types.canonical_abi(&elem);
+    let element_size = usize::try_from(abi.size32).unwrap();
+    let element_alignment = abi.align32;
+
+    match len
+        .checked_mul(element_size)
+        .and_then(|len| ptr.checked_add(len))
+    {
+        Some(n) if n <= cx.memory().len() => {}
+        _ => bail!("list pointer/length out of bounds of memory"),
+    }
+    if ptr % usize::try_from(element_alignment).err2anyhow()? != 0 {
+        bail!("list pointer is not aligned")
+    }
+
+    Ok(Val::List(
+        (0..len)
+            .map(|index| {
+                Val::load(
+                    cx,
+                    elem,
+                    &cx.memory()[ptr + (index * element_size)..][..element_size],
+                )
+            })
+            .collect::<Result<_>>()?,
+    ))
+}
+
+fn load_variant(
+    cx: &mut LiftContext<'_>,
+    info: &VariantInfo,
+    mut types: impl ExactSizeIterator<Item = Option<InterfaceType>>,
+    bytes: &[u8],
+) -> Result<(u32, Option<Box<Val>>)> {
+    let discriminant = match info.size {
+        DiscriminantSize::Size1 => u32::from(u8::load(cx, InterfaceType::U8, &bytes[..1])?),
+        DiscriminantSize::Size2 => u32::from(u16::load(cx, InterfaceType::U16, &bytes[..2])?),
+        DiscriminantSize::Size4 => u32::load(cx, InterfaceType::U32, &bytes[..4])?,
+    };
+    let case_ty = types.nth(discriminant as usize).ok_or_else(|| {
+        anyhow!(
+            "discriminant {} out of range [0..{})",
+            discriminant,
+            types.len()
+        )
+    })?;
+    let value = match case_ty {
+        Some(case_ty) => {
+            let payload_offset = usize::try_from(info.payload_offset32).unwrap();
+            let case_abi = cx.types.canonical_abi(&case_ty);
+            let case_size = usize::try_from(case_abi.size32).unwrap();
+            Some(Box::new(Val::load(
+                cx,
+                case_ty,
+                &bytes[payload_offset..][..case_size],
+            )?))
+        }
+        None => None,
+    };
+    Ok((discriminant, value))
+}
+
+fn lift_variant(
+    cx: &mut LiftContext<'_>,
+    flatten_count: usize,
+    mut types: impl ExactSizeIterator<Item = Option<InterfaceType>>,
+    src: &mut Iter<'_, ValRaw>,
+) -> Result<(u32, Option<Box<Val>>)> {
+    let len = types.len();
+    let discriminant = next(src).get_u32();
+    let ty = types
+        .nth(discriminant as usize)
+        .ok_or_else(|| anyhow!("discriminant {} out of range [0..{})", discriminant, len))?;
+    let (value, value_flat) = match ty {
+        Some(ty) => (
+            Some(Box::new(Val::lift(cx, ty, src)?)),
+            cx.types.canonical_abi(&ty).flat_count(usize::MAX).unwrap(),
+        ),
+        None => (None, 0),
+    };
+    for _ in (1 + value_flat)..flatten_count {
+        next(src);
+    }
+    Ok((discriminant, value))
+}
+
+/// Lower a list with the specified element type and values.
+fn lower_list<T>(
+    cx: &mut LowerContext<'_, T>,
+    element_type: InterfaceType,
+    items: &[Val],
+) -> Result<(usize, usize)> {
+    let abi = cx.types.canonical_abi(&element_type);
+    let elt_size = usize::try_from(abi.size32).err2anyhow()?;
+    let elt_align = abi.align32;
+    let size = items
+        .len()
+        .checked_mul(elt_size)
+        .ok_or_else(|| anyhow::anyhow!("size overflow copying a list"))?;
+    let ptr = cx.realloc(0, 0, elt_align, size)?;
+    let mut element_ptr = ptr;
+    for item in items {
+        item.store(cx, element_type, element_ptr)?;
+        element_ptr += elt_size;
+    }
+    Ok((ptr, items.len()))
+}
+
+fn push_flags(ty: &TypeFlags, flags: &mut Vec<String>, mut offset: u32, mut bits: u32) {
+    while bits > 0 {
+        if bits & 1 != 0 {
+            flags.push(ty.names[offset as usize].clone());
+        }
+        bits >>= 1;
+        offset += 1;
+    }
+}
+
+fn flags_to_storage(ty: &TypeFlags, flags: &[String]) -> Result<Vec<u32>> {
+    let mut storage = match FlagsSize::from_count(ty.names.len()) {
+        FlagsSize::Size0 => Vec::new(),
+        FlagsSize::Size1 | FlagsSize::Size2 => vec![0],
+        FlagsSize::Size4Plus(n) => vec![0; n.into()],
+    };
+
+    for flag in flags {
+        let bit = ty
+            .names
+            .get_index_of(flag)
+            .ok_or_else(|| anyhow::anyhow!("unknown flag: `{flag}`"))?;
+        storage[bit / 32] |= 1 << (bit % 32);
+    }
+    Ok(storage)
+}
+
+fn get_enum_discriminant(ty: &TypeEnum, n: &str) -> Result<u32> {
+    ty.names
+        .get_index_of(n)
+        .ok_or_else(|| anyhow::anyhow!("enum variant name `{n}` is not valid"))
+        .map(|i| i as u32)
+}
+
+fn get_variant_discriminant<'a>(
+    ty: &'a TypeVariant,
+    name: &str,
+) -> Result<(u32, &'a Option<InterfaceType>)> {
+    let (i, _, ty) = ty
+        .cases
+        .get_full(name)
+        .ok_or_else(|| anyhow::anyhow!("unknown variant case: `{name}`"))?;
+    Ok((i as u32, ty))
+}
+
+fn next<'a>(src: &mut Iter<'a, ValRaw>) -> &'a ValRaw {
+    src.next().unwrap()
+}
+
+fn next_mut<'a>(dst: &mut IterMut<'a, MaybeUninit<ValRaw>>) -> &'a mut MaybeUninit<ValRaw> {
+    dst.next().unwrap()
+}
+
+#[cold]
+fn unexpected<T>(ty: InterfaceType, val: &Val) -> Result<T> {
+    bail!(
+        "type mismatch: expected {}, found {}",
+        desc(&ty),
+        val.desc()
+    )
+}
diff --git a/crates/wasmtime/src/runtime/coredump.rs b/crates/wasmtime/src/runtime/coredump.rs
new file mode 100644
index 000000000000..0d20a2067aad
--- /dev/null
+++ b/crates/wasmtime/src/runtime/coredump.rs
@@ -0,0 +1,339 @@
+use crate::prelude::*;
+use crate::{
+    store::StoreOpaque, AsContextMut, FrameInfo, Global, HeapType, Instance, Memory, Module,
+    StoreContextMut, Val, ValType, WasmBacktrace,
+};
+use std::{collections::HashMap, fmt};
+
+/// Representation of a core dump of a WebAssembly module
+///
+/// When the Config::coredump_on_trap option is enabled this structure is
+/// attached to the [`anyhow::Error`] returned from many Wasmtime functions that
+/// execute WebAssembly such as [`Instance::new`] or [`Func::call`]. This can be
+/// acquired with the [`anyhow::Error::downcast`] family of methods to
+/// programmatically inspect the coredump. Otherwise since it's part of the
+/// error returned this will get printed along with the rest of the error when
+/// the error is logged.
+///
+/// Note that some state, such as Wasm locals or values on the operand stack,
+/// may be optimized away by the compiler or otherwise not recovered in the
+/// coredump.
+///
+/// Capturing of wasm coredumps can be configured through the
+/// [`Config::coredump_on_trap`][crate::Config::coredump_on_trap] method.
+///
+/// For more information about errors in wasmtime see the documentation of the
+/// [`Trap`][crate::Trap] type.
+///
+/// [`Func::call`]: crate::Func::call
+/// [`Instance::new`]: crate::Instance::new
+pub struct WasmCoreDump {
+    name: String,
+    modules: Vec<Module>,
+    instances: Vec<Instance>,
+    memories: Vec<Memory>,
+    globals: Vec<Global>,
+    backtrace: WasmBacktrace,
+}
+
+impl WasmCoreDump {
+    pub(crate) fn new(store: &mut StoreOpaque, backtrace: WasmBacktrace) -> WasmCoreDump {
+        let modules: Vec<_> = store.modules().all_modules().cloned().collect();
+        let instances: Vec<Instance> = store.all_instances().collect();
+        let store_memories: Vec<Memory> = store.all_memories().collect();
+
+        let mut store_globals: Vec<Global> = vec![];
+        store.for_each_global(|_store, global| store_globals.push(global));
+
+        WasmCoreDump {
+            name: String::from("store_name"),
+            modules,
+            instances,
+            memories: store_memories,
+            globals: store_globals,
+            backtrace,
+        }
+    }
+
+    /// The stack frames for this core dump.
+    ///
+    /// Frames appear in callee to caller order, that is youngest to oldest
+    /// frames.
+    pub fn frames(&self) -> &[FrameInfo] {
+        self.backtrace.frames()
+    }
+
+    /// All modules instantiated inside the store when the core dump was
+    /// created.
+    pub fn modules(&self) -> &[Module] {
+        self.modules.as_ref()
+    }
+
+    /// All instances within the store when the core dump was created.
+    pub fn instances(&self) -> &[Instance] {
+        self.instances.as_ref()
+    }
+
+    /// All globals, instance- or host-defined, within the store when the core
+    /// dump was created.
+    pub fn globals(&self) -> &[Global] {
+        self.globals.as_ref()
+    }
+
+    /// All memories, instance- or host-defined, within the store when the core
+    /// dump was created.
+    pub fn memories(&self) -> &[Memory] {
+        self.memories.as_ref()
+    }
+
+    /// Serialize this core dump into [the standard core dump binary
+    /// format][spec].
+    ///
+    /// The `name` parameter may be a file path, URL, or arbitrary name for the
+    /// "main" Wasm service or executable that was running in this store.
+    ///
+    /// Once serialized, you can write this core dump to disk, send it over the
+    /// network, or pass it to other debugging tools that consume Wasm core
+    /// dumps.
+    ///
+    /// [spec]: https://github.com/WebAssembly/tool-conventions/blob/main/Coredump.md
+    pub fn serialize(&self, mut store: impl AsContextMut, name: &str) -> Vec<u8> {
+        let store = store.as_context_mut();
+        self._serialize(store, name)
+    }
+
+    fn _serialize<T>(&self, mut store: StoreContextMut<'_, T>, name: &str) -> Vec<u8> {
+        let mut core_dump = wasm_encoder::Module::new();
+
+        core_dump.section(&wasm_encoder::CoreDumpSection::new(name));
+
+        // A map from each memory to its index in the core dump's memories
+        // section.
+        let mut memory_to_idx = HashMap::new();
+
+        let mut data = wasm_encoder::DataSection::new();
+
+        {
+            let mut memories = wasm_encoder::MemorySection::new();
+            for mem in self.memories() {
+                let memory_idx = memories.len();
+                memory_to_idx.insert(mem.hash_key(&store.0), memory_idx);
+                let ty = mem.ty(&store);
+                memories.memory(wasm_encoder::MemoryType {
+                    minimum: mem.size(&store),
+                    maximum: ty.maximum(),
+                    memory64: ty.is_64(),
+                    shared: ty.is_shared(),
+                    page_size_log2: None,
+                });
+
+                // Attach the memory data, balancing number of data segments and
+                // binary size. We don't want to attach the whole memory in one
+                // big segment, since it likely contains a bunch of large runs
+                // of zeroes. But we can't encode the data without any potential
+                // runs of zeroes (i.e. including only non-zero data in our
+                // segments) because we can run up against the implementation
+                // limits for number of segments in a Wasm module this way. So
+                // to balance these conflicting desires, we break the memory up
+                // into reasonably-sized chunks and then trim runs of zeroes
+                // from the start and end of each chunk.
+                const CHUNK_SIZE: u32 = 4096;
+                for (i, chunk) in mem
+                    .data(&store)
+                    .chunks_exact(CHUNK_SIZE as usize)
+                    .enumerate()
+                {
+                    if let Some(start) = chunk.iter().position(|byte| *byte != 0) {
+                        let end = chunk.iter().rposition(|byte| *byte != 0).unwrap() + 1;
+                        let offset = (i as u32) * CHUNK_SIZE + (start as u32);
+                        let offset = wasm_encoder::ConstExpr::i32_const(offset as i32);
+                        data.active(memory_idx, &offset, chunk[start..end].iter().copied());
+                    }
+                }
+            }
+            core_dump.section(&memories);
+        }
+
+        // A map from each global to its index in the core dump's globals
+        // section.
+        let mut global_to_idx = HashMap::new();
+
+        {
+            let mut globals = wasm_encoder::GlobalSection::new();
+            for g in self.globals() {
+                global_to_idx.insert(g.hash_key(&store.0), globals.len());
+                let ty = g.ty(&store);
+                let mutable = matches!(ty.mutability(), crate::Mutability::Var);
+                let val_type = match ty.content() {
+                    ValType::I32 => wasm_encoder::ValType::I32,
+                    ValType::I64 => wasm_encoder::ValType::I64,
+                    ValType::F32 => wasm_encoder::ValType::F32,
+                    ValType::F64 => wasm_encoder::ValType::F64,
+                    ValType::V128 => wasm_encoder::ValType::V128,
+
+                    // We encode all references as null in the core dump, so
+                    // choose the common super type of all the actual function
+                    // reference types. This lets us avoid needing to figure out
+                    // what a concrete type reference's index is in the local
+                    // core dump index space.
+                    ValType::Ref(r) => match r.heap_type().top() {
+                        HeapType::Extern => wasm_encoder::ValType::EXTERNREF,
+
+                        HeapType::Func => wasm_encoder::ValType::FUNCREF,
+
+                        HeapType::Any => wasm_encoder::ValType::Ref(wasm_encoder::RefType::ANYREF),
+
+                        ty => unreachable!("not a top type: {ty:?}"),
+                    },
+                };
+                let init = match g.get(&mut store) {
+                    Val::I32(x) => wasm_encoder::ConstExpr::i32_const(x),
+                    Val::I64(x) => wasm_encoder::ConstExpr::i64_const(x),
+                    Val::F32(x) => {
+                        wasm_encoder::ConstExpr::f32_const(unsafe { std::mem::transmute(x) })
+                    }
+                    Val::F64(x) => {
+                        wasm_encoder::ConstExpr::f64_const(unsafe { std::mem::transmute(x) })
+                    }
+                    Val::V128(x) => wasm_encoder::ConstExpr::v128_const(x.as_u128() as i128),
+                    Val::FuncRef(_) => {
+                        wasm_encoder::ConstExpr::ref_null(wasm_encoder::HeapType::FUNC)
+                    }
+                    Val::ExternRef(_) => {
+                        wasm_encoder::ConstExpr::ref_null(wasm_encoder::HeapType::EXTERN)
+                    }
+                    Val::AnyRef(_) => {
+                        wasm_encoder::ConstExpr::ref_null(wasm_encoder::HeapType::ANY)
+                    }
+                };
+                globals.global(
+                    wasm_encoder::GlobalType {
+                        val_type,
+                        mutable,
+                        shared: false,
+                    },
+                    &init,
+                );
+            }
+            core_dump.section(&globals);
+        }
+
+        core_dump.section(&data);
+        drop(data);
+
+        // A map from module id to its index within the core dump's modules
+        // section.
+        let mut module_to_index = HashMap::new();
+
+        {
+            let mut modules = wasm_encoder::CoreDumpModulesSection::new();
+            for module in self.modules() {
+                module_to_index.insert(module.id(), modules.len());
+                match module.name() {
+                    Some(name) => modules.module(name),
+                    None => modules.module(&format!("<anonymous-module-{}>", modules.len())),
+                };
+            }
+            core_dump.section(&modules);
+        }
+
+        // TODO: We can't currently recover instances from stack frames. We can
+        // recover module via the frame's PC, but if there are multiple
+        // instances of the same module, we don't know which instance the frame
+        // is associated with. Therefore, we do a best effort job: remember the
+        // last instance of each module and always choose that one. We record
+        // that information here.
+        let mut module_to_instance = HashMap::new();
+
+        {
+            let mut instances = wasm_encoder::CoreDumpInstancesSection::new();
+            for instance in self.instances() {
+                let module = instance.module(&store);
+                module_to_instance.insert(module.id(), instances.len());
+
+                let module_index = module_to_index[&module.id()];
+
+                let memories = instance
+                    .all_memories(&mut store.0)
+                    .collect::<Vec<_>>()
+                    .into_iter()
+                    .map(|(_i, memory)| memory_to_idx[&memory.hash_key(&store.0)])
+                    .collect::<Vec<_>>();
+
+                let globals = instance
+                    .all_globals(&mut store.0)
+                    .collect::<Vec<_>>()
+                    .into_iter()
+                    .map(|(_i, global)| global_to_idx[&global.hash_key(&store.0)])
+                    .collect::<Vec<_>>();
+
+                instances.instance(module_index, memories, globals);
+            }
+            core_dump.section(&instances);
+        }
+
+        {
+            let thread_name = "main";
+            let mut stack = wasm_encoder::CoreDumpStackSection::new(thread_name);
+            for frame in self.frames() {
+                // This isn't necessarily the right instance if there are
+                // multiple instances of the same module. See comment above
+                // `module_to_instance` for details.
+                let instance = module_to_instance[&frame.module().id()];
+
+                let func = frame.func_index();
+
+                let offset = frame
+                    .func_offset()
+                    .and_then(|o| u32::try_from(o).ok())
+                    .unwrap_or(0);
+
+                // We can't currently recover locals and the operand stack. We
+                // should eventually be able to do that with Winch though.
+                let locals = [];
+                let operand_stack = [];
+
+                stack.frame(instance, func, offset, locals, operand_stack);
+            }
+            core_dump.section(&stack);
+        }
+
+        core_dump.finish()
+    }
+}
+
+impl fmt::Display for WasmCoreDump {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        writeln!(f, "wasm coredump generated while executing {}:", self.name)?;
+        writeln!(f, "modules:")?;
+        for module in self.modules.iter() {
+            writeln!(f, "  {}", module.name().unwrap_or("<module>"))?;
+        }
+
+        writeln!(f, "instances:")?;
+        for instance in self.instances.iter() {
+            writeln!(f, "  {instance:?}")?;
+        }
+
+        writeln!(f, "memories:")?;
+        for memory in self.memories.iter() {
+            writeln!(f, "  {memory:?}")?;
+        }
+
+        writeln!(f, "globals:")?;
+        for global in self.globals.iter() {
+            writeln!(f, "  {global:?}")?;
+        }
+
+        writeln!(f, "backtrace:")?;
+        write!(f, "{}", self.backtrace)?;
+
+        Ok(())
+    }
+}
+
+impl fmt::Debug for WasmCoreDump {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "<wasm core dump>")
+    }
+}
diff --git a/crates/wasmtime/src/runtime/debug.rs b/crates/wasmtime/src/runtime/debug.rs
new file mode 100644
index 000000000000..b3a5d94ddb64
--- /dev/null
+++ b/crates/wasmtime/src/runtime/debug.rs
@@ -0,0 +1,165 @@
+use crate::prelude::*;
+use core::mem::size_of;
+use object::elf::*;
+use object::endian::{BigEndian, Endian, Endianness, LittleEndian};
+use object::read::elf::{FileHeader, SectionHeader};
+use object::{
+    File, NativeEndian as NE, Object, ObjectSection, ObjectSymbol, RelocationEncoding,
+    RelocationKind, RelocationTarget, U64Bytes,
+};
+
+pub(crate) fn create_gdbjit_image(
+    mut bytes: Vec<u8>,
+    code_region: (*const u8, usize),
+) -> Result<Vec<u8>, Error> {
+    let e = ensure_supported_elf_format(&bytes)?;
+
+    // patch relocs
+    relocate_dwarf_sections(&mut bytes, code_region)?;
+
+    // elf is still missing details...
+    match e {
+        Endianness::Little => {
+            convert_object_elf_to_loadable_file::<LittleEndian>(&mut bytes, code_region)
+        }
+        Endianness::Big => {
+            convert_object_elf_to_loadable_file::<BigEndian>(&mut bytes, code_region)
+        }
+    }
+
+    Ok(bytes)
+}
+
+fn relocate_dwarf_sections(bytes: &mut [u8], code_region: (*const u8, usize)) -> Result<(), Error> {
+    let mut relocations = Vec::new();
+    let obj = File::parse(&bytes[..]).err2anyhow()?;
+    for section in obj.sections() {
+        let section_start = match section.file_range() {
+            Some((start, _)) => start,
+            None => continue,
+        };
+        for (off, r) in section.relocations() {
+            if r.kind() != RelocationKind::Absolute
+                || r.encoding() != RelocationEncoding::Generic
+                || r.size() != 64
+            {
+                continue;
+            }
+
+            let sym = match r.target() {
+                RelocationTarget::Symbol(index) => match obj.symbol_by_index(index) {
+                    Ok(sym) => sym,
+                    Err(_) => continue,
+                },
+                _ => continue,
+            };
+            relocations.push((
+                section_start + off,
+                (code_region.0 as u64)
+                    .wrapping_add(sym.address())
+                    .wrapping_add(r.addend() as u64),
+            ));
+        }
+    }
+
+    for (offset, value) in relocations {
+        let (loc, _) = object::from_bytes_mut::<U64Bytes<NE>>(&mut bytes[offset as usize..])
+            .map_err(|()| anyhow!("invalid dwarf relocations"))?;
+        loc.set(NE, value);
+    }
+    Ok(())
+}
+
+fn ensure_supported_elf_format(bytes: &[u8]) -> Result<Endianness, Error> {
+    use object::elf::*;
+    use object::read::elf::*;
+
+    let kind = match object::FileKind::parse(bytes) {
+        Ok(file) => file,
+        Err(err) => {
+            bail!("Failed to parse file: {}", err);
+        }
+    };
+    let header = match kind {
+        object::FileKind::Elf64 => match object::elf::FileHeader64::<Endianness>::parse(bytes) {
+            Ok(header) => header,
+            Err(err) => {
+                bail!("Unsupported ELF file: {}", err);
+            }
+        },
+        _ => {
+            bail!("only 64-bit ELF files currently supported")
+        }
+    };
+    let e = header.endian().unwrap();
+
+    match header.e_machine.get(e) {
+        EM_AARCH64 => (),
+        EM_X86_64 => (),
+        EM_S390 => (),
+        EM_RISCV => (),
+        machine => {
+            bail!("Unsupported ELF target machine: {:x}", machine);
+        }
+    }
+    ensure!(
+        header.e_phoff.get(e) == 0 && header.e_phnum.get(e) == 0,
+        "program header table is empty"
+    );
+    let e_shentsize = header.e_shentsize.get(e);
+    let req_shentsize = match e {
+        Endianness::Little => size_of::<SectionHeader64<LittleEndian>>(),
+        Endianness::Big => size_of::<SectionHeader64<BigEndian>>(),
+    };
+    ensure!(e_shentsize as usize == req_shentsize, "size of sh");
+    Ok(e)
+}
+
+fn convert_object_elf_to_loadable_file<E: Endian>(
+    bytes: &mut Vec<u8>,
+    code_region: (*const u8, usize),
+) {
+    let e = E::default();
+
+    let header = FileHeader64::<E>::parse(&bytes[..]).unwrap();
+    let sections = header.sections(e, &bytes[..]).unwrap();
+    let text_range = match sections.section_by_name(e, b".text") {
+        Some((i, text)) => {
+            let range = text.file_range(e);
+            let off = header.e_shoff.get(e) as usize + i.0 * header.e_shentsize.get(e) as usize;
+
+            let section: &mut SectionHeader64<E> =
+                object::from_bytes_mut(&mut bytes[off..]).unwrap().0;
+            // Patch vaddr, and save file location and its size.
+            section.sh_addr.set(e, code_region.0 as u64);
+            range
+        }
+        None => None,
+    };
+
+    // LLDB wants segment with virtual address set, placing them at the end of ELF.
+    let ph_off = bytes.len();
+    let e_phentsize = size_of::<ProgramHeader64<E>>();
+    let e_phnum = 1;
+    bytes.resize(ph_off + e_phentsize * e_phnum, 0);
+    if let Some((sh_offset, sh_size)) = text_range {
+        let (v_offset, size) = code_region;
+        let program: &mut ProgramHeader64<E> =
+            object::from_bytes_mut(&mut bytes[ph_off..]).unwrap().0;
+        program.p_type.set(e, PT_LOAD);
+        program.p_offset.set(e, sh_offset);
+        program.p_vaddr.set(e, v_offset as u64);
+        program.p_paddr.set(e, v_offset as u64);
+        program.p_filesz.set(e, sh_size);
+        program.p_memsz.set(e, size as u64);
+    } else {
+        unreachable!();
+    }
+
+    // It is somewhat loadable ELF file at this moment.
+    let header: &mut FileHeader64<E> = object::from_bytes_mut(bytes).unwrap().0;
+    header.e_type.set(e, ET_DYN);
+    header.e_phoff.set(e, ph_off as u64);
+    header.e_phentsize.set(e, e_phentsize as u16);
+    header.e_phnum.set(e, e_phnum as u16);
+}
diff --git a/crates/wasmtime/src/externals.rs b/crates/wasmtime/src/runtime/externals.rs
similarity index 96%
rename from crates/wasmtime/src/externals.rs
rename to crates/wasmtime/src/runtime/externals.rs
index c627f38e2040..d457a13a568b 100644
--- a/crates/wasmtime/src/externals.rs
+++ b/crates/wasmtime/src/runtime/externals.rs
@@ -104,24 +104,24 @@ impl Extern {
     }
 
     pub(crate) unsafe fn from_wasmtime_export(
-        wasmtime_export: wasmtime_runtime::Export,
+        wasmtime_export: crate::runtime::vm::Export,
         store: &mut StoreOpaque,
     ) -> Extern {
         match wasmtime_export {
-            wasmtime_runtime::Export::Function(f) => {
+            crate::runtime::vm::Export::Function(f) => {
                 Extern::Func(Func::from_wasmtime_function(f, store))
             }
-            wasmtime_runtime::Export::Memory(m) => {
+            crate::runtime::vm::Export::Memory(m) => {
                 if m.memory.memory.shared {
                     Extern::SharedMemory(SharedMemory::from_wasmtime_memory(m, store))
                 } else {
                     Extern::Memory(Memory::from_wasmtime_memory(m, store))
                 }
             }
-            wasmtime_runtime::Export::Global(g) => {
+            crate::runtime::vm::Export::Global(g) => {
                 Extern::Global(Global::from_wasmtime_global(g, store))
             }
-            wasmtime_runtime::Export::Table(t) => {
+            crate::runtime::vm::Export::Table(t) => {
                 Extern::Table(Table::from_wasmtime_table(t, store))
             }
         }
diff --git a/crates/wasmtime/src/runtime/externals/global.rs b/crates/wasmtime/src/runtime/externals/global.rs
new file mode 100644
index 000000000000..bc6916bc01a3
--- /dev/null
+++ b/crates/wasmtime/src/runtime/externals/global.rs
@@ -0,0 +1,312 @@
+use crate::prelude::*;
+use crate::runtime::vm::{GcRootsList, SendSyncPtr};
+use crate::{
+    store::{AutoAssertNoGc, StoreData, StoreOpaque, Stored},
+    trampoline::generate_global_export,
+    AnyRef, AsContext, AsContextMut, ExternRef, Func, GlobalType, HeapType, Mutability, Ref,
+    RootedGcRefImpl, Val, ValType,
+};
+use core::ptr;
+use core::ptr::NonNull;
+use wasmtime_environ::TypeTrace;
+
+/// A WebAssembly `global` value which can be read and written to.
+///
+/// A `global` in WebAssembly is sort of like a global variable within an
+/// [`Instance`](crate::Instance). The `global.get` and `global.set`
+/// instructions will modify and read global values in a wasm module. Globals
+/// can either be imported or exported from wasm modules.
+///
+/// A [`Global`] "belongs" to the store that it was originally created within
+/// (either via [`Global::new`] or via instantiating a
+/// [`Module`](crate::Module)). Operations on a [`Global`] only work with the
+/// store it belongs to, and if another store is passed in by accident then
+/// methods will panic.
+#[derive(Copy, Clone, Debug)]
+#[repr(transparent)] // here for the C API
+pub struct Global(pub(super) Stored<crate::runtime::vm::ExportGlobal>);
+
+impl Global {
+    /// Creates a new WebAssembly `global` value with the provide type `ty` and
+    /// initial value `val`.
+    ///
+    /// The `store` argument will be the owner of the [`Global`] returned. Using
+    /// the returned [`Global`] other items in the store may access this global.
+    /// For example this could be provided as an argument to
+    /// [`Instance::new`](crate::Instance::new) or
+    /// [`Linker::define`](crate::Linker::define).
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the `ty` provided does not match the type of the
+    /// value `val`, or if `val` comes from a different store than `store`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// let engine = Engine::default();
+    /// let mut store = Store::new(&engine, ());
+    ///
+    /// let ty = GlobalType::new(ValType::I32, Mutability::Const);
+    /// let i32_const = Global::new(&mut store, ty, 1i32.into())?;
+    /// let ty = GlobalType::new(ValType::F64, Mutability::Var);
+    /// let f64_mut = Global::new(&mut store, ty, 2.0f64.into())?;
+    ///
+    /// let module = Module::new(
+    ///     &engine,
+    ///     "(module
+    ///         (global (import \"\" \"i32-const\") i32)
+    ///         (global (import \"\" \"f64-mut\") (mut f64))
+    ///     )"
+    /// )?;
+    ///
+    /// let mut linker = Linker::new(&engine);
+    /// linker.define(&store, "", "i32-const", i32_const)?;
+    /// linker.define(&store, "", "f64-mut", f64_mut)?;
+    ///
+    /// let instance = linker.instantiate(&mut store, &module)?;
+    /// // ...
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn new(mut store: impl AsContextMut, ty: GlobalType, val: Val) -> Result<Global> {
+        Global::_new(store.as_context_mut().0, ty, val)
+    }
+
+    fn _new(store: &mut StoreOpaque, ty: GlobalType, val: Val) -> Result<Global> {
+        val.ensure_matches_ty(store, ty.content()).context(
+            "type mismatch: initial value provided does not match the type of this global",
+        )?;
+        unsafe {
+            let wasmtime_export = generate_global_export(store, ty, val)?;
+            Ok(Global::from_wasmtime_global(wasmtime_export, store))
+        }
+    }
+
+    /// Returns the underlying type of this `global`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `store` does not own this global.
+    pub fn ty(&self, store: impl AsContext) -> GlobalType {
+        self._ty(store.as_context().0)
+    }
+
+    pub(crate) fn _ty(&self, store: &StoreOpaque) -> GlobalType {
+        let ty = &store[self.0].global;
+        GlobalType::from_wasmtime_global(store.engine(), &ty)
+    }
+
+    /// Returns the current [`Val`] of this global.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `store` does not own this global.
+    pub fn get(&self, mut store: impl AsContextMut) -> Val {
+        unsafe {
+            let store = store.as_context_mut();
+            let mut store = AutoAssertNoGc::new(store.0);
+            let definition = &*store[self.0].definition;
+            match self._ty(&store).content() {
+                ValType::I32 => Val::from(*definition.as_i32()),
+                ValType::I64 => Val::from(*definition.as_i64()),
+                ValType::F32 => Val::F32(*definition.as_u32()),
+                ValType::F64 => Val::F64(*definition.as_u64()),
+                ValType::V128 => Val::V128((*definition.as_u128()).into()),
+                ValType::Ref(ref_ty) => {
+                    let reference: Ref = match ref_ty.heap_type() {
+                        HeapType::Func | HeapType::ConcreteFunc(_) => {
+                            Func::_from_raw(&mut store, definition.as_func_ref().cast()).into()
+                        }
+
+                        HeapType::NoFunc => Ref::Func(None),
+
+                        HeapType::Extern => Ref::Extern(
+                            definition
+                                .as_gc_ref()
+                                .map(|r| {
+                                    let r = store.unwrap_gc_store_mut().clone_gc_ref(r);
+                                    ExternRef::from_cloned_gc_ref(&mut store, r)
+                                })
+                                .into(),
+                        ),
+
+                        HeapType::NoExtern => Ref::Extern(None),
+
+                        HeapType::Any
+                        | HeapType::Eq
+                        | HeapType::I31
+                        | HeapType::Struct
+                        | HeapType::ConcreteStruct(_)
+                        | HeapType::Array
+                        | HeapType::ConcreteArray(_) => definition
+                            .as_gc_ref()
+                            .map(|r| {
+                                let r = store.unwrap_gc_store_mut().clone_gc_ref(r);
+                                AnyRef::from_cloned_gc_ref(&mut store, r)
+                            })
+                            .into(),
+
+                        HeapType::None => Ref::Any(None),
+                    };
+                    debug_assert!(
+                        ref_ty.is_nullable() || !reference.is_null(),
+                        "if the type is non-nullable, we better have a non-null reference"
+                    );
+                    reference.into()
+                }
+            }
+        }
+    }
+
+    /// Attempts to set the current value of this global to [`Val`].
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if this global has a different type than `Val`, if
+    /// it's not a mutable global, or if `val` comes from a different store than
+    /// the one provided.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `store` does not own this global.
+    pub fn set(&self, mut store: impl AsContextMut, val: Val) -> Result<()> {
+        let mut store = AutoAssertNoGc::new(store.as_context_mut().0);
+        let global_ty = self._ty(&store);
+        if global_ty.mutability() != Mutability::Var {
+            bail!("immutable global cannot be set");
+        }
+        val.ensure_matches_ty(&store, global_ty.content())
+            .context("type mismatch: attempt to set global to value of wrong type")?;
+        unsafe {
+            let definition = &mut *store[self.0].definition;
+            match val {
+                Val::I32(i) => *definition.as_i32_mut() = i,
+                Val::I64(i) => *definition.as_i64_mut() = i,
+                Val::F32(f) => *definition.as_u32_mut() = f,
+                Val::F64(f) => *definition.as_u64_mut() = f,
+                Val::V128(i) => *definition.as_u128_mut() = i.into(),
+                Val::FuncRef(f) => {
+                    *definition.as_func_ref_mut() = f.map_or(ptr::null_mut(), |f| {
+                        f.vm_func_ref(&mut store).as_ptr().cast()
+                    });
+                }
+                Val::ExternRef(e) => {
+                    let new = match e {
+                        None => None,
+                        #[cfg_attr(not(feature = "gc"), allow(unreachable_patterns))]
+                        Some(e) => Some(e.try_gc_ref(&mut store)?.unchecked_copy()),
+                    };
+                    let new = new.as_ref();
+                    definition.write_gc_ref(store.unwrap_gc_store_mut(), new);
+                }
+                Val::AnyRef(a) => {
+                    let new = match a {
+                        None => None,
+                        #[cfg_attr(not(feature = "gc"), allow(unreachable_patterns))]
+                        Some(a) => Some(a.try_gc_ref(&mut store)?.unchecked_copy()),
+                    };
+                    let new = new.as_ref();
+                    definition.write_gc_ref(store.unwrap_gc_store_mut(), new);
+                }
+            }
+        }
+        Ok(())
+    }
+
+    pub(crate) fn trace_root(&self, store: &mut StoreOpaque, gc_roots_list: &mut GcRootsList) {
+        if let Some(ref_ty) = self._ty(store).content().as_ref() {
+            if !ref_ty.is_vmgcref_type_and_points_to_object() {
+                return;
+            }
+
+            if let Some(gc_ref) = unsafe { (*store[self.0].definition).as_gc_ref() } {
+                let gc_ref = NonNull::from(gc_ref);
+                let gc_ref = SendSyncPtr::new(gc_ref);
+                unsafe {
+                    gc_roots_list.add_root(gc_ref, "Wasm global");
+                }
+            }
+        }
+    }
+
+    pub(crate) unsafe fn from_wasmtime_global(
+        mut wasmtime_export: crate::runtime::vm::ExportGlobal,
+        store: &mut StoreOpaque,
+    ) -> Global {
+        wasmtime_export
+            .global
+            .wasm_ty
+            .canonicalize_for_runtime_usage(&mut |module_index| {
+                crate::runtime::vm::Instance::from_vmctx(wasmtime_export.vmctx, |instance| {
+                    instance.engine_type_index(module_index)
+                })
+            });
+
+        Global(store.store_data_mut().insert(wasmtime_export))
+    }
+
+    pub(crate) fn wasmtime_ty<'a>(&self, data: &'a StoreData) -> &'a wasmtime_environ::Global {
+        &data[self.0].global
+    }
+
+    pub(crate) fn vmimport(&self, store: &StoreOpaque) -> crate::runtime::vm::VMGlobalImport {
+        crate::runtime::vm::VMGlobalImport {
+            from: store[self.0].definition,
+        }
+    }
+
+    /// Get a stable hash key for this global.
+    ///
+    /// Even if the same underlying global definition is added to the
+    /// `StoreData` multiple times and becomes multiple `wasmtime::Global`s,
+    /// this hash key will be consistent across all of these globals.
+    pub(crate) fn hash_key(&self, store: &StoreOpaque) -> impl core::hash::Hash + Eq {
+        store[self.0].definition as usize
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{Instance, Module, Store};
+
+    #[test]
+    fn hash_key_is_stable_across_duplicate_store_data_entries() -> Result<()> {
+        let mut store = Store::<()>::default();
+        let module = Module::new(
+            store.engine(),
+            r#"
+                (module
+                    (global (export "g") (mut i32) (i32.const 0))
+                )
+            "#,
+        )?;
+        let instance = Instance::new(&mut store, &module, &[])?;
+
+        // Each time we `get_global`, we call `Global::from_wasmtime` which adds
+        // a new entry to `StoreData`, so `g1` and `g2` will have different
+        // indices into `StoreData`.
+        let g1 = instance.get_global(&mut store, "g").unwrap();
+        let g2 = instance.get_global(&mut store, "g").unwrap();
+
+        // That said, they really point to the same global.
+        assert_eq!(g1.get(&mut store).unwrap_i32(), 0);
+        assert_eq!(g2.get(&mut store).unwrap_i32(), 0);
+        g1.set(&mut store, Val::I32(42))?;
+        assert_eq!(g1.get(&mut store).unwrap_i32(), 42);
+        assert_eq!(g2.get(&mut store).unwrap_i32(), 42);
+
+        // And therefore their hash keys are the same.
+        assert!(g1.hash_key(&store.as_context().0) == g2.hash_key(&store.as_context().0));
+
+        // But the hash keys are different from different globals.
+        let instance2 = Instance::new(&mut store, &module, &[])?;
+        let g3 = instance2.get_global(&mut store, "g").unwrap();
+        assert!(g1.hash_key(&store.as_context().0) != g3.hash_key(&store.as_context().0));
+
+        Ok(())
+    }
+}
diff --git a/crates/wasmtime/src/runtime/externals/table.rs b/crates/wasmtime/src/runtime/externals/table.rs
new file mode 100644
index 000000000000..bea26c42a674
--- /dev/null
+++ b/crates/wasmtime/src/runtime/externals/table.rs
@@ -0,0 +1,480 @@
+use crate::prelude::*;
+use crate::runtime::vm::{self as runtime};
+use crate::store::{AutoAssertNoGc, StoreData, StoreOpaque, Stored};
+use crate::trampoline::generate_table_export;
+use crate::{AnyRef, AsContext, AsContextMut, ExternRef, Func, HeapType, Ref, TableType};
+use core::iter;
+use core::ptr::NonNull;
+use runtime::{GcRootsList, SendSyncPtr};
+use wasmtime_environ::TypeTrace;
+
+/// A WebAssembly `table`, or an array of values.
+///
+/// Like [`Memory`][crate::Memory] a table is an indexed array of values, but
+/// unlike [`Memory`][crate::Memory] it's an array of WebAssembly reference type
+/// values rather than bytes. One of the most common usages of a table is a
+/// function table for wasm modules (a `funcref` table), where each element has
+/// the `ValType::FuncRef` type.
+///
+/// A [`Table`] "belongs" to the store that it was originally created within
+/// (either via [`Table::new`] or via instantiating a
+/// [`Module`](crate::Module)). Operations on a [`Table`] only work with the
+/// store it belongs to, and if another store is passed in by accident then
+/// methods will panic.
+#[derive(Copy, Clone, Debug)]
+#[repr(transparent)] // here for the C API
+pub struct Table(pub(super) Stored<crate::runtime::vm::ExportTable>);
+
+impl Table {
+    /// Creates a new [`Table`] with the given parameters.
+    ///
+    /// * `store` - the owner of the resulting [`Table`]
+    /// * `ty` - the type of this table, containing both the element type as
+    ///   well as the initial size and maximum size, if any.
+    /// * `init` - the initial value to fill all table entries with, if the
+    ///   table starts with an initial size.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if `init` does not match the element type of the table,
+    /// or if `init` does not belong to the `store` provided.
+    ///
+    /// # Panics
+    ///
+    /// This function will panic when used with a [`Store`](`crate::Store`)
+    /// which has a [`ResourceLimiterAsync`](`crate::ResourceLimiterAsync`)
+    /// (see also: [`Store::limiter_async`](`crate::Store::limiter_async`).
+    /// When using an async resource limiter, use [`Table::new_async`]
+    /// instead.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// let engine = Engine::default();
+    /// let mut store = Store::new(&engine, ());
+    ///
+    /// let ty = TableType::new(RefType::FUNCREF, 2, None);
+    /// let table = Table::new(&mut store, ty, Ref::Func(None))?;
+    ///
+    /// let module = Module::new(
+    ///     &engine,
+    ///     "(module
+    ///         (table (import \"\" \"\") 2 funcref)
+    ///         (func $f (result i32)
+    ///             i32.const 10)
+    ///         (elem (i32.const 0) $f)
+    ///     )"
+    /// )?;
+    ///
+    /// let instance = Instance::new(&mut store, &module, &[table.into()])?;
+    /// // ...
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn new(mut store: impl AsContextMut, ty: TableType, init: Ref) -> Result<Table> {
+        Table::_new(store.as_context_mut().0, ty, init)
+    }
+
+    /// Async variant of [`Table::new`]. You must use this variant with
+    /// [`Store`](`crate::Store`)s which have a
+    /// [`ResourceLimiterAsync`](`crate::ResourceLimiterAsync`).
+    ///
+    /// # Panics
+    ///
+    /// This function will panic when used with a non-async
+    /// [`Store`](`crate::Store`)
+    #[cfg(feature = "async")]
+    pub async fn new_async<T>(
+        mut store: impl AsContextMut<Data = T>,
+        ty: TableType,
+        init: Ref,
+    ) -> Result<Table>
+    where
+        T: Send,
+    {
+        let mut store = store.as_context_mut();
+        assert!(
+            store.0.async_support(),
+            "cannot use `new_async` without enabling async support on the config"
+        );
+        store
+            .on_fiber(|store| Table::_new(store.0, ty, init))
+            .await?
+    }
+
+    fn _new(store: &mut StoreOpaque, ty: TableType, init: Ref) -> Result<Table> {
+        let wasmtime_export = generate_table_export(store, &ty)?;
+        let init = init.into_table_element(store, ty.element())?;
+        unsafe {
+            let table = Table::from_wasmtime_table(wasmtime_export, store);
+            let wasmtime_table = table.wasmtime_table(store, iter::empty());
+            (*wasmtime_table)
+                .fill(store.gc_store_mut()?, 0, init, ty.minimum())
+                .err2anyhow()?;
+            Ok(table)
+        }
+    }
+
+    /// Returns the underlying type of this table, including its element type as
+    /// well as the maximum/minimum lower bounds.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `store` does not own this table.
+    pub fn ty(&self, store: impl AsContext) -> TableType {
+        self._ty(store.as_context().0)
+    }
+
+    fn _ty(&self, store: &StoreOpaque) -> TableType {
+        let ty = &store[self.0].table.table;
+        TableType::from_wasmtime_table(store.engine(), ty)
+    }
+
+    fn wasmtime_table(
+        &self,
+        store: &mut StoreOpaque,
+        lazy_init_range: impl Iterator<Item = u32>,
+    ) -> *mut runtime::Table {
+        unsafe {
+            let export = &store[self.0];
+            crate::runtime::vm::Instance::from_vmctx(export.vmctx, |handle| {
+                let idx = handle.table_index(&*export.definition);
+                handle.get_defined_table_with_lazy_init(idx, lazy_init_range)
+            })
+        }
+    }
+
+    /// Returns the table element value at `index`.
+    ///
+    /// Returns `None` if `index` is out of bounds.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `store` does not own this table.
+    pub fn get(&self, mut store: impl AsContextMut, index: u32) -> Option<Ref> {
+        let mut store = AutoAssertNoGc::new(store.as_context_mut().0);
+        let table = self.wasmtime_table(&mut store, iter::once(index));
+        unsafe {
+            match (*table).get(store.unwrap_gc_store_mut(), index)? {
+                runtime::TableElement::FuncRef(f) => {
+                    let func = Func::from_vm_func_ref(&mut store, f);
+                    Some(func.into())
+                }
+
+                runtime::TableElement::UninitFunc => {
+                    unreachable!("lazy init above should have converted UninitFunc")
+                }
+
+                runtime::TableElement::GcRef(None) => {
+                    Some(Ref::null(self._ty(&store).element().heap_type()))
+                }
+
+                #[cfg_attr(not(feature = "gc"), allow(unreachable_code, unused_variables))]
+                runtime::TableElement::GcRef(Some(x)) => {
+                    match self._ty(&store).element().heap_type().top() {
+                        HeapType::Any => {
+                            let x = AnyRef::from_cloned_gc_ref(&mut store, x);
+                            Some(x.into())
+                        }
+                        HeapType::Extern => {
+                            let x = ExternRef::from_cloned_gc_ref(&mut store, x);
+                            Some(x.into())
+                        }
+                        HeapType::Func => {
+                            unreachable!("never have TableElement::GcRef for func tables")
+                        }
+                        ty => unreachable!("not a top type: {ty:?}"),
+                    }
+                }
+            }
+        }
+    }
+
+    /// Writes the `val` provided into `index` within this table.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if `index` is out of bounds, if `val` does not have
+    /// the right type to be stored in this table, or if `val` belongs to a
+    /// different store.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `store` does not own this table.
+    pub fn set(&self, mut store: impl AsContextMut, index: u32, val: Ref) -> Result<()> {
+        let store = store.as_context_mut().0;
+        let ty = self.ty(&store);
+        let val = val.into_table_element(store, ty.element())?;
+        let table = self.wasmtime_table(store, iter::empty());
+        unsafe {
+            (*table)
+                .set(index, val)
+                .map_err(|()| anyhow!("table element index out of bounds"))
+        }
+    }
+
+    /// Returns the current size of this table.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `store` does not own this table.
+    pub fn size(&self, store: impl AsContext) -> u32 {
+        self.internal_size(store.as_context().0)
+    }
+
+    pub(crate) fn internal_size(&self, store: &StoreOpaque) -> u32 {
+        unsafe { (*store[self.0].definition).current_elements }
+    }
+
+    /// Grows the size of this table by `delta` more elements, initialization
+    /// all new elements to `init`.
+    ///
+    /// Returns the previous size of this table if successful.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the table cannot be grown by `delta`, for example
+    /// if it would cause the table to exceed its maximum size. Also returns an
+    /// error if `init` is not of the right type or if `init` does not belong to
+    /// `store`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `store` does not own this table.
+    ///
+    /// This function will panic when used with a [`Store`](`crate::Store`)
+    /// which has a [`ResourceLimiterAsync`](`crate::ResourceLimiterAsync`)
+    /// (see also: [`Store::limiter_async`](`crate::Store::limiter_async`)).
+    /// When using an async resource limiter, use [`Table::grow_async`]
+    /// instead.
+    pub fn grow(&self, mut store: impl AsContextMut, delta: u32, init: Ref) -> Result<u32> {
+        let store = store.as_context_mut().0;
+        let ty = self.ty(&store);
+        let init = init.into_table_element(store, ty.element())?;
+        let table = self.wasmtime_table(store, iter::empty());
+        unsafe {
+            match (*table).grow(delta, init, store)? {
+                Some(size) => {
+                    let vm = (*table).vmtable();
+                    *store[self.0].definition = vm;
+                    Ok(size)
+                }
+                None => bail!("failed to grow table by `{}`", delta),
+            }
+        }
+    }
+
+    /// Async variant of [`Table::grow`]. Required when using a
+    /// [`ResourceLimiterAsync`](`crate::ResourceLimiterAsync`).
+    ///
+    /// # Panics
+    ///
+    /// This function will panic when used with a non-async
+    /// [`Store`](`crate::Store`).
+    #[cfg(feature = "async")]
+    pub async fn grow_async<T>(
+        &self,
+        mut store: impl AsContextMut<Data = T>,
+        delta: u32,
+        init: Ref,
+    ) -> Result<u32>
+    where
+        T: Send,
+    {
+        let mut store = store.as_context_mut();
+        assert!(
+            store.0.async_support(),
+            "cannot use `grow_async` without enabling async support on the config"
+        );
+        store
+            .on_fiber(|store| self.grow(store, delta, init))
+            .await?
+    }
+
+    /// Copy `len` elements from `src_table[src_index..]` into
+    /// `dst_table[dst_index..]`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the range is out of bounds of either the source or
+    /// destination tables, or if the source table's element type does not match
+    /// the destination table's element type.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `store` does not own either `dst_table` or `src_table`.
+    pub fn copy(
+        mut store: impl AsContextMut,
+        dst_table: &Table,
+        dst_index: u32,
+        src_table: &Table,
+        src_index: u32,
+        len: u32,
+    ) -> Result<()> {
+        let store = store.as_context_mut().0;
+
+        let dst_ty = dst_table.ty(&store);
+        let src_ty = src_table.ty(&store);
+        src_ty
+            .element()
+            .ensure_matches(store.engine(), dst_ty.element())
+            .context(
+                "type mismatch: source table's element type does not match \
+                 destination table's element type",
+            )?;
+
+        let dst_table = dst_table.wasmtime_table(store, iter::empty());
+        let src_range = src_index..(src_index.checked_add(len).unwrap_or(u32::MAX));
+        let src_table = src_table.wasmtime_table(store, src_range);
+        unsafe {
+            runtime::Table::copy(
+                store.gc_store_mut()?,
+                dst_table,
+                src_table,
+                dst_index,
+                src_index,
+                len,
+            )
+            .err2anyhow()?;
+        }
+        Ok(())
+    }
+
+    /// Fill `table[dst..(dst + len)]` with the given value.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if
+    ///
+    /// * `val` is not of the same type as this table's
+    ///   element type,
+    ///
+    /// * the region to be filled is out of bounds, or
+    ///
+    /// * `val` comes from a different `Store` from this table.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `store` does not own either `dst_table` or `src_table`.
+    pub fn fill(&self, mut store: impl AsContextMut, dst: u32, val: Ref, len: u32) -> Result<()> {
+        let store = store.as_context_mut().0;
+        let ty = self.ty(&store);
+        let val = val.into_table_element(store, ty.element())?;
+
+        let table = self.wasmtime_table(store, iter::empty());
+        unsafe {
+            (*table)
+                .fill(store.gc_store_mut()?, dst, val, len)
+                .err2anyhow()?;
+        }
+
+        Ok(())
+    }
+
+    pub(crate) fn trace_roots(&self, store: &mut StoreOpaque, gc_roots_list: &mut GcRootsList) {
+        if !self
+            ._ty(store)
+            .element()
+            .is_vmgcref_type_and_points_to_object()
+        {
+            return;
+        }
+
+        let table = self.wasmtime_table(store, iter::empty());
+        for gc_ref in unsafe { (*table).gc_refs_mut() } {
+            if let Some(gc_ref) = gc_ref {
+                let gc_ref = NonNull::from(gc_ref);
+                let gc_ref = SendSyncPtr::new(gc_ref);
+                unsafe {
+                    gc_roots_list.add_root(gc_ref, "Wasm table element");
+                }
+            }
+        }
+    }
+
+    pub(crate) unsafe fn from_wasmtime_table(
+        mut wasmtime_export: crate::runtime::vm::ExportTable,
+        store: &mut StoreOpaque,
+    ) -> Table {
+        // Ensure that the table's type is engine-level canonicalized.
+        wasmtime_export
+            .table
+            .table
+            .wasm_ty
+            .canonicalize_for_runtime_usage(&mut |module_index| {
+                crate::runtime::vm::Instance::from_vmctx(wasmtime_export.vmctx, |instance| {
+                    instance.engine_type_index(module_index)
+                })
+            });
+
+        Table(store.store_data_mut().insert(wasmtime_export))
+    }
+
+    pub(crate) fn wasmtime_ty<'a>(&self, data: &'a StoreData) -> &'a wasmtime_environ::Table {
+        &data[self.0].table.table
+    }
+
+    pub(crate) fn vmimport(&self, store: &StoreOpaque) -> crate::runtime::vm::VMTableImport {
+        let export = &store[self.0];
+        crate::runtime::vm::VMTableImport {
+            from: export.definition,
+            vmctx: export.vmctx,
+        }
+    }
+
+    /// Get a stable hash key for this table.
+    ///
+    /// Even if the same underlying table definition is added to the
+    /// `StoreData` multiple times and becomes multiple `wasmtime::Table`s,
+    /// this hash key will be consistent across all of these tables.
+    #[allow(dead_code)] // Not used yet, but added for consistency.
+    pub(crate) fn hash_key(&self, store: &StoreOpaque) -> impl core::hash::Hash + Eq {
+        store[self.0].definition as usize
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{Instance, Module, Store};
+
+    #[test]
+    fn hash_key_is_stable_across_duplicate_store_data_entries() -> Result<()> {
+        let mut store = Store::<()>::default();
+        let module = Module::new(
+            store.engine(),
+            r#"
+                (module
+                    (table (export "t") 1 1 externref)
+                )
+            "#,
+        )?;
+        let instance = Instance::new(&mut store, &module, &[])?;
+
+        // Each time we `get_table`, we call `Table::from_wasmtime` which adds
+        // a new entry to `StoreData`, so `t1` and `t2` will have different
+        // indices into `StoreData`.
+        let t1 = instance.get_table(&mut store, "t").unwrap();
+        let t2 = instance.get_table(&mut store, "t").unwrap();
+
+        // That said, they really point to the same table.
+        assert!(t1.get(&mut store, 0).unwrap().unwrap_extern().is_none());
+        assert!(t2.get(&mut store, 0).unwrap().unwrap_extern().is_none());
+        let e = ExternRef::new(&mut store, 42)?;
+        t1.set(&mut store, 0, e.into())?;
+        assert!(t1.get(&mut store, 0).unwrap().unwrap_extern().is_some());
+        assert!(t2.get(&mut store, 0).unwrap().unwrap_extern().is_some());
+
+        // And therefore their hash keys are the same.
+        assert!(t1.hash_key(&store.as_context().0) == t2.hash_key(&store.as_context().0));
+
+        // But the hash keys are different from different tables.
+        let instance2 = Instance::new(&mut store, &module, &[])?;
+        let t3 = instance2.get_table(&mut store, "t").unwrap();
+        assert!(t1.hash_key(&store.as_context().0) != t3.hash_key(&store.as_context().0));
+
+        Ok(())
+    }
+}
diff --git a/crates/wasmtime/src/runtime/func.rs b/crates/wasmtime/src/runtime/func.rs
new file mode 100644
index 000000000000..e5c0092a19ee
--- /dev/null
+++ b/crates/wasmtime/src/runtime/func.rs
@@ -0,0 +1,2607 @@
+use crate::prelude::*;
+use crate::runtime::vm::{
+    ExportFunction, SendSyncPtr, StoreBox, VMArrayCallHostFuncContext, VMContext, VMFuncRef,
+    VMFunctionImport, VMOpaqueContext,
+};
+use crate::runtime::Uninhabited;
+use crate::store::{AutoAssertNoGc, StoreData, StoreOpaque, Stored};
+use crate::type_registry::RegisteredType;
+use crate::{
+    AsContext, AsContextMut, CallHook, Engine, Extern, FuncType, Instance, Module, Ref,
+    StoreContext, StoreContextMut, Val, ValRaw, ValType,
+};
+use alloc::sync::Arc;
+use core::ffi::c_void;
+use core::future::Future;
+use core::mem::{self, MaybeUninit};
+use core::num::NonZeroUsize;
+use core::pin::Pin;
+use core::ptr::{self, NonNull};
+use wasmtime_environ::VMSharedTypeIndex;
+
+/// A reference to the abstract `nofunc` heap value.
+///
+/// The are no instances of `(ref nofunc)`: it is an uninhabited type.
+///
+/// There is precisely one instance of `(ref null nofunc)`, aka `nullfuncref`:
+/// the null reference.
+///
+/// This `NoFunc` Rust type's sole purpose is for use with [`Func::wrap`]- and
+/// [`Func::typed`]-style APIs for statically typing a function as taking or
+/// returning a `(ref null nofunc)` (aka `Option<NoFunc>`) which is always
+/// `None`.
+///
+/// # Example
+///
+/// ```
+/// # use wasmtime::*;
+/// # fn _foo() -> Result<()> {
+/// let mut config = Config::new();
+/// config.wasm_function_references(true);
+/// let engine = Engine::new(&config)?;
+///
+/// let module = Module::new(
+///     &engine,
+///     r#"
+///         (module
+///             (func (export "f") (param (ref null nofunc))
+///                 ;; If the reference is null, return.
+///                 local.get 0
+///                 ref.is_null nofunc
+///                 br_if 0
+///
+///                 ;; If the reference was not null (which is impossible)
+///                 ;; then raise a trap.
+///                 unreachable
+///             )
+///         )
+///     "#,
+/// )?;
+///
+/// let mut store = Store::new(&engine, ());
+/// let instance = Instance::new(&mut store, &module, &[])?;
+/// let f = instance.get_func(&mut store, "f").unwrap();
+///
+/// // We can cast a `(ref null nofunc)`-taking function into a typed function that
+/// // takes an `Option<NoFunc>` via the `Func::typed` method.
+/// let f = f.typed::<Option<NoFunc>, ()>(&store)?;
+///
+/// // We can call the typed function, passing the null `nofunc` reference.
+/// let result = f.call(&mut store, NoFunc::null());
+///
+/// // The function should not have trapped, because the reference we gave it was
+/// // null (as it had to be, since `NoFunc` is uninhabited).
+/// assert!(result.is_ok());
+/// # Ok(())
+/// # }
+/// ```
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub struct NoFunc {
+    _inner: Uninhabited,
+}
+
+impl NoFunc {
+    /// Get the null `(ref null nofunc)` (aka `nullfuncref`) reference.
+    #[inline]
+    pub fn null() -> Option<NoFunc> {
+        None
+    }
+
+    /// Get the null `(ref null nofunc)` (aka `nullfuncref`) reference as a
+    /// [`Ref`].
+    #[inline]
+    pub fn null_ref() -> Ref {
+        Ref::Func(None)
+    }
+
+    /// Get the null `(ref null nofunc)` (aka `nullfuncref`) reference as a
+    /// [`Val`].
+    #[inline]
+    pub fn null_val() -> Val {
+        Val::FuncRef(None)
+    }
+}
+
+/// A WebAssembly function which can be called.
+///
+/// This type typically represents an exported function from a WebAssembly
+/// module instance. In this case a [`Func`] belongs to an [`Instance`] and is
+/// loaded from there. A [`Func`] may also represent a host function as well in
+/// some cases, too.
+///
+/// Functions can be called in a few different ways, either synchronous or async
+/// and either typed or untyped (more on this below). Note that host functions
+/// are normally inserted directly into a [`Linker`](crate::Linker) rather than
+/// using this directly, but both options are available.
+///
+/// # `Func` and `async`
+///
+/// Functions from the perspective of WebAssembly are always synchronous. You
+/// might have an `async` function in Rust, however, which you'd like to make
+/// available from WebAssembly. Wasmtime supports asynchronously calling
+/// WebAssembly through native stack switching. You can get some more
+/// information about [asynchronous configs](crate::Config::async_support), but
+/// from the perspective of `Func` it's important to know that whether or not
+/// your [`Store`](crate::Store) is asynchronous will dictate whether you call
+/// functions through [`Func::call`] or [`Func::call_async`] (or the typed
+/// wrappers such as [`TypedFunc::call`] vs [`TypedFunc::call_async`]).
+///
+/// # To `Func::call` or to `Func::typed().call()`
+///
+/// There's a 2x2 matrix of methods to call [`Func`]. Invocations can either be
+/// asynchronous or synchronous. They can also be statically typed or not.
+/// Whether or not an invocation is asynchronous is indicated via the method
+/// being `async` and [`call_async`](Func::call_async) being the entry point.
+/// Otherwise for statically typed or not your options are:
+///
+/// * Dynamically typed - if you don't statically know the signature of the
+///   function that you're calling you'll be using [`Func::call`] or
+///   [`Func::call_async`]. These functions take a variable-length slice of
+///   "boxed" arguments in their [`Val`] representation. Additionally the
+///   results are returned as an owned slice of [`Val`]. These methods are not
+///   optimized due to the dynamic type checks that must occur, in addition to
+///   some dynamic allocations for where to put all the arguments. While this
+///   allows you to call all possible wasm function signatures, if you're
+///   looking for a speedier alternative you can also use...
+///
+/// * Statically typed - if you statically know the type signature of the wasm
+///   function you're calling, then you'll want to use the [`Func::typed`]
+///   method to acquire an instance of [`TypedFunc`]. This structure is static proof
+///   that the underlying wasm function has the ascripted type, and type
+///   validation is only done once up-front. The [`TypedFunc::call`] and
+///   [`TypedFunc::call_async`] methods are much more efficient than [`Func::call`]
+///   and [`Func::call_async`] because the type signature is statically known.
+///   This eschews runtime checks as much as possible to get into wasm as fast
+///   as possible.
+///
+/// # Examples
+///
+/// One way to get a `Func` is from an [`Instance`] after you've instantiated
+/// it:
+///
+/// ```
+/// # use wasmtime::*;
+/// # fn main() -> anyhow::Result<()> {
+/// let engine = Engine::default();
+/// let module = Module::new(&engine, r#"(module (func (export "foo")))"#)?;
+/// let mut store = Store::new(&engine, ());
+/// let instance = Instance::new(&mut store, &module, &[])?;
+/// let foo = instance.get_func(&mut store, "foo").expect("export wasn't a function");
+///
+/// // Work with `foo` as a `Func` at this point, such as calling it
+/// // dynamically...
+/// match foo.call(&mut store, &[], &mut []) {
+///     Ok(()) => { /* ... */ }
+///     Err(trap) => {
+///         panic!("execution of `foo` resulted in a wasm trap: {}", trap);
+///     }
+/// }
+/// foo.call(&mut store, &[], &mut [])?;
+///
+/// // ... or we can make a static assertion about its signature and call it.
+/// // Our first call here can fail if the signatures don't match, and then the
+/// // second call can fail if the function traps (like the `match` above).
+/// let foo = foo.typed::<(), ()>(&store)?;
+/// foo.call(&mut store, ())?;
+/// # Ok(())
+/// # }
+/// ```
+///
+/// You can also use the [`wrap` function](Func::wrap) to create a
+/// `Func`
+///
+/// ```
+/// # use wasmtime::*;
+/// # fn main() -> anyhow::Result<()> {
+/// let mut store = Store::<()>::default();
+///
+/// // Create a custom `Func` which can execute arbitrary code inside of the
+/// // closure.
+/// let add = Func::wrap(&mut store, |a: i32, b: i32| -> i32 { a + b });
+///
+/// // Next we can hook that up to a wasm module which uses it.
+/// let module = Module::new(
+///     store.engine(),
+///     r#"
+///         (module
+///             (import "" "" (func $add (param i32 i32) (result i32)))
+///             (func (export "call_add_twice") (result i32)
+///                 i32.const 1
+///                 i32.const 2
+///                 call $add
+///                 i32.const 3
+///                 i32.const 4
+///                 call $add
+///                 i32.add))
+///     "#,
+/// )?;
+/// let instance = Instance::new(&mut store, &module, &[add.into()])?;
+/// let call_add_twice = instance.get_typed_func::<(), i32>(&mut store, "call_add_twice")?;
+///
+/// assert_eq!(call_add_twice.call(&mut store, ())?, 10);
+/// # Ok(())
+/// # }
+/// ```
+///
+/// Or you could also create an entirely dynamic `Func`!
+///
+/// ```
+/// # use wasmtime::*;
+/// # fn main() -> anyhow::Result<()> {
+/// let mut store = Store::<()>::default();
+///
+/// // Here we need to define the type signature of our `Double` function and
+/// // then wrap it up in a `Func`
+/// let double_type = wasmtime::FuncType::new(
+///     store.engine(),
+///     [wasmtime::ValType::I32].iter().cloned(),
+///     [wasmtime::ValType::I32].iter().cloned(),
+/// );
+/// let double = Func::new(&mut store, double_type, |_, params, results| {
+///     let mut value = params[0].unwrap_i32();
+///     value *= 2;
+///     results[0] = value.into();
+///     Ok(())
+/// });
+///
+/// let module = Module::new(
+///     store.engine(),
+///     r#"
+///         (module
+///             (import "" "" (func $double (param i32) (result i32)))
+///             (func $start
+///                 i32.const 1
+///                 call $double
+///                 drop)
+///             (start $start))
+///     "#,
+/// )?;
+/// let instance = Instance::new(&mut store, &module, &[double.into()])?;
+/// // .. work with `instance` if necessary
+/// # Ok(())
+/// # }
+/// ```
+#[derive(Copy, Clone, Debug)]
+#[repr(transparent)] // here for the C API
+pub struct Func(Stored<FuncData>);
+
+pub(crate) struct FuncData {
+    kind: FuncKind,
+
+    // A pointer to the in-store `VMFuncRef` for this function, if
+    // any.
+    //
+    // When a function is passed to Wasm but doesn't have a Wasm-to-native
+    // trampoline, we have to patch it in. But that requires mutating the
+    // `VMFuncRef`, and this function could be shared across
+    // threads. So we instead copy and pin the `VMFuncRef` into
+    // `StoreOpaque::func_refs`, where we can safely patch the field without
+    // worrying about synchronization and we hold a pointer to it here so we can
+    // reuse it rather than re-copy if it is passed to Wasm again.
+    in_store_func_ref: Option<SendSyncPtr<VMFuncRef>>,
+
+    // This is somewhat expensive to load from the `Engine` and in most
+    // optimized use cases (e.g. `TypedFunc`) it's not actually needed or it's
+    // only needed rarely. To handle that this is an optionally-contained field
+    // which is lazily loaded into as part of `Func::call`.
+    //
+    // Also note that this is intentionally placed behind a pointer to keep it
+    // small as `FuncData` instances are often inserted into a `Store`.
+    ty: Option<Box<FuncType>>,
+}
+
+/// The three ways that a function can be created and referenced from within a
+/// store.
+enum FuncKind {
+    /// A function already owned by the store via some other means. This is
+    /// used, for example, when creating a `Func` from an instance's exported
+    /// function. The instance's `InstanceHandle` is already owned by the store
+    /// and we just have some pointers into that which represent how to call the
+    /// function.
+    StoreOwned { export: ExportFunction },
+
+    /// A function is shared across possibly other stores, hence the `Arc`. This
+    /// variant happens when a `Linker`-defined function is instantiated within
+    /// a `Store` (e.g. via `Linker::get` or similar APIs). The `Arc` here
+    /// indicates that there's some number of other stores holding this function
+    /// too, so dropping this may not deallocate the underlying
+    /// `InstanceHandle`.
+    SharedHost(Arc<HostFunc>),
+
+    /// A uniquely-owned host function within a `Store`. This comes about with
+    /// `Func::new` or similar APIs. The `HostFunc` internally owns the
+    /// `InstanceHandle` and that will get dropped when this `HostFunc` itself
+    /// is dropped.
+    ///
+    /// Note that this is intentionally placed behind a `Box` to minimize the
+    /// size of this enum since the most common variant for high-performance
+    /// situations is `SharedHost` and `StoreOwned`, so this ideally isn't
+    /// larger than those two.
+    Host(Box<HostFunc>),
+
+    /// A reference to a `HostFunc`, but one that's "rooted" in the `Store`
+    /// itself.
+    ///
+    /// This variant is created when an `InstancePre<T>` is instantiated in to a
+    /// `Store<T>`. In that situation the `InstancePre<T>` already has a list of
+    /// host functions that are packaged up in an `Arc`, so the `Arc<[T]>` is
+    /// cloned once into the `Store` to avoid each individual function requiring
+    /// an `Arc::clone`.
+    ///
+    /// The lifetime management of this type is `unsafe` because
+    /// `RootedHostFunc` is a small wrapper around `NonNull<HostFunc>`. To be
+    /// safe this is required that the memory of the host function is pinned
+    /// elsewhere (e.g. the `Arc` in the `Store`).
+    RootedHost(RootedHostFunc),
+}
+
+macro_rules! for_each_function_signature {
+    ($mac:ident) => {
+        $mac!(0);
+        $mac!(1 A1);
+        $mac!(2 A1 A2);
+        $mac!(3 A1 A2 A3);
+        $mac!(4 A1 A2 A3 A4);
+        $mac!(5 A1 A2 A3 A4 A5);
+        $mac!(6 A1 A2 A3 A4 A5 A6);
+        $mac!(7 A1 A2 A3 A4 A5 A6 A7);
+        $mac!(8 A1 A2 A3 A4 A5 A6 A7 A8);
+        $mac!(9 A1 A2 A3 A4 A5 A6 A7 A8 A9);
+        $mac!(10 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10);
+        $mac!(11 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11);
+        $mac!(12 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12);
+        $mac!(13 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13);
+        $mac!(14 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14);
+        $mac!(15 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14 A15);
+        $mac!(16 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14 A15 A16);
+        $mac!(17 A1 A2 A3 A4 A5 A6 A7 A8 A9 A10 A11 A12 A13 A14 A15 A16 A17);
+    };
+}
+
+mod typed;
+pub use typed::*;
+
+impl Func {
+    /// Creates a new `Func` with the given arguments, typically to create a
+    /// host-defined function to pass as an import to a module.
+    ///
+    /// * `store` - the store in which to create this [`Func`], which will own
+    ///   the return value.
+    ///
+    /// * `ty` - the signature of this function, used to indicate what the
+    ///   inputs and outputs are.
+    ///
+    /// * `func` - the native code invoked whenever this `Func` will be called.
+    ///   This closure is provided a [`Caller`] as its first argument to learn
+    ///   information about the caller, and then it's passed a list of
+    ///   parameters as a slice along with a mutable slice of where to write
+    ///   results.
+    ///
+    /// Note that the implementation of `func` must adhere to the `ty` signature
+    /// given, error or traps may occur if it does not respect the `ty`
+    /// signature. For example if the function type declares that it returns one
+    /// i32 but the `func` closures does not write anything into the results
+    /// slice then a trap may be generated.
+    ///
+    /// Additionally note that this is quite a dynamic function since signatures
+    /// are not statically known. For a more performant and ergonomic `Func`
+    /// it's recommended to use [`Func::wrap`] if you can because with
+    /// statically known signatures Wasmtime can optimize the implementation
+    /// much more.
+    ///
+    /// For more information about `Send + Sync + 'static` requirements on the
+    /// `func`, see [`Func::wrap`](#why-send--sync--static).
+    ///
+    /// # Errors
+    ///
+    /// The host-provided function here returns a
+    /// [`Result<()>`](anyhow::Result). If the function returns `Ok(())` then
+    /// that indicates that the host function completed successfully and wrote
+    /// the result into the `&mut [Val]` argument.
+    ///
+    /// If the function returns `Err(e)`, however, then this is equivalent to
+    /// the host function triggering a trap for wasm. WebAssembly execution is
+    /// immediately halted and the original caller of [`Func::call`], for
+    /// example, will receive the error returned here (possibly with
+    /// [`WasmBacktrace`](crate::WasmBacktrace) context information attached).
+    ///
+    /// For more information about errors in Wasmtime see the [`Trap`]
+    /// documentation.
+    ///
+    /// [`Trap`]: crate::Trap
+    ///
+    /// # Panics
+    ///
+    /// Panics if the given function type is not associated with this store's
+    /// engine.
+    pub fn new<T>(
+        store: impl AsContextMut<Data = T>,
+        ty: FuncType,
+        func: impl Fn(Caller<'_, T>, &[Val], &mut [Val]) -> Result<()> + Send + Sync + 'static,
+    ) -> Self {
+        assert!(ty.comes_from_same_engine(store.as_context().engine()));
+        let ty_clone = ty.clone();
+        unsafe {
+            Func::new_unchecked(store, ty, move |caller, values| {
+                Func::invoke_host_func_for_wasm(caller, &ty_clone, values, &func)
+            })
+        }
+    }
+
+    /// Creates a new [`Func`] with the given arguments, although has fewer
+    /// runtime checks than [`Func::new`].
+    ///
+    /// This function takes a callback of a different signature than
+    /// [`Func::new`], instead receiving a raw pointer with a list of [`ValRaw`]
+    /// structures. These values have no type information associated with them
+    /// so it's up to the caller to provide a function that will correctly
+    /// interpret the list of values as those coming from the `ty` specified.
+    ///
+    /// If you're calling this from Rust it's recommended to either instead use
+    /// [`Func::new`] or [`Func::wrap`]. The [`Func::wrap`] API, in particular,
+    /// is both safer and faster than this API.
+    ///
+    /// # Errors
+    ///
+    /// See [`Func::new`] for the behavior of returning an error from the host
+    /// function provided here.
+    ///
+    /// # Unsafety
+    ///
+    /// This function is not safe because it's not known at compile time that
+    /// the `func` provided correctly interprets the argument types provided to
+    /// it, or that the results it produces will be of the correct type.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the given function type is not associated with this store's
+    /// engine.
+    pub unsafe fn new_unchecked<T>(
+        mut store: impl AsContextMut<Data = T>,
+        ty: FuncType,
+        func: impl Fn(Caller<'_, T>, &mut [ValRaw]) -> Result<()> + Send + Sync + 'static,
+    ) -> Self {
+        assert!(ty.comes_from_same_engine(store.as_context().engine()));
+        let store = store.as_context_mut().0;
+        let host = HostFunc::new_unchecked(store.engine(), ty, func);
+        host.into_func(store)
+    }
+
+    /// Creates a new host-defined WebAssembly function which, when called,
+    /// will run the asynchronous computation defined by `func` to completion
+    /// and then return the result to WebAssembly.
+    ///
+    /// This function is the asynchronous analogue of [`Func::new`] and much of
+    /// that documentation applies to this as well. The key difference is that
+    /// `func` returns a future instead of simply a `Result`. Note that the
+    /// returned future can close over any of the arguments, but it cannot close
+    /// over the state of the closure itself. It's recommended to store any
+    /// necessary async state in the `T` of the [`Store<T>`](crate::Store) which
+    /// can be accessed through [`Caller::data`] or [`Caller::data_mut`].
+    ///
+    /// For more information on `Send + Sync + 'static`, see
+    /// [`Func::wrap`](#why-send--sync--static).
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if `store` is not associated with an [async
+    /// config](crate::Config::async_support).
+    ///
+    /// Panics if the given function type is not associated with this store's
+    /// engine.
+    ///
+    /// # Errors
+    ///
+    /// See [`Func::new`] for the behavior of returning an error from the host
+    /// function provided here.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// // Simulate some application-specific state as well as asynchronous
+    /// // functions to query that state.
+    /// struct MyDatabase {
+    ///     // ...
+    /// }
+    ///
+    /// impl MyDatabase {
+    ///     async fn get_row_count(&self) -> u32 {
+    ///         // ...
+    /// #       100
+    ///     }
+    /// }
+    ///
+    /// let my_database = MyDatabase {
+    ///     // ...
+    /// };
+    ///
+    /// // Using `new_async` we can hook up into calling our async
+    /// // `get_row_count` function.
+    /// let engine = Engine::new(Config::new().async_support(true))?;
+    /// let mut store = Store::new(&engine, MyDatabase {
+    ///     // ...
+    /// });
+    /// let get_row_count_type = wasmtime::FuncType::new(
+    ///     &engine,
+    ///     None,
+    ///     Some(wasmtime::ValType::I32),
+    /// );
+    /// let get = Func::new_async(&mut store, get_row_count_type, |caller, _params, results| {
+    ///     Box::new(async move {
+    ///         let count = caller.data().get_row_count().await;
+    ///         results[0] = Val::I32(count as i32);
+    ///         Ok(())
+    ///     })
+    /// });
+    /// // ...
+    /// # Ok(())
+    /// # }
+    /// ```
+    #[cfg(all(feature = "async", feature = "cranelift"))]
+    pub fn new_async<T, F>(store: impl AsContextMut<Data = T>, ty: FuncType, func: F) -> Func
+    where
+        F: for<'a> Fn(
+                Caller<'a, T>,
+                &'a [Val],
+                &'a mut [Val],
+            ) -> Box<dyn Future<Output = Result<()>> + Send + 'a>
+            + Send
+            + Sync
+            + 'static,
+    {
+        assert!(
+            store.as_context().async_support(),
+            "cannot use `new_async` without enabling async support in the config"
+        );
+        assert!(ty.comes_from_same_engine(store.as_context().engine()));
+        Func::new(store, ty, move |mut caller, params, results| {
+            let async_cx = caller
+                .store
+                .as_context_mut()
+                .0
+                .async_cx()
+                .expect("Attempt to spawn new action on dying fiber");
+            let mut future = Pin::from(func(caller, params, results));
+            match unsafe { async_cx.block_on(future.as_mut()) } {
+                Ok(Ok(())) => Ok(()),
+                Ok(Err(trap)) | Err(trap) => Err(trap),
+            }
+        })
+    }
+
+    pub(crate) unsafe fn from_vm_func_ref(
+        store: &mut StoreOpaque,
+        raw: *mut VMFuncRef,
+    ) -> Option<Func> {
+        let func_ref = NonNull::new(raw)?;
+        debug_assert!(func_ref.as_ref().type_index != VMSharedTypeIndex::default());
+        let export = ExportFunction { func_ref };
+        Some(Func::from_wasmtime_function(export, store))
+    }
+
+    /// Creates a new `Func` from the given Rust closure.
+    ///
+    /// This function will create a new `Func` which, when called, will
+    /// execute the given Rust closure. Unlike [`Func::new`] the target
+    /// function being called is known statically so the type signature can
+    /// be inferred. Rust types will map to WebAssembly types as follows:
+    ///
+    /// | Rust Argument Type                | WebAssembly Type                          |
+    /// |-----------------------------------|-------------------------------------------|
+    /// | `i32`                             | `i32`                                     |
+    /// | `u32`                             | `i32`                                     |
+    /// | `i64`                             | `i64`                                     |
+    /// | `u64`                             | `i64`                                     |
+    /// | `f32`                             | `f32`                                     |
+    /// | `f64`                             | `f64`                                     |
+    /// | `V128` on x86-64 and aarch64 only | `v128`                                    |
+    /// | `Option<Func>`                    | `funcref` aka `(ref null func)`           |
+    /// | `Func`                            | `(ref func)`                              |
+    /// | `Option<Nofunc>`                  | `nullfuncref` aka `(ref null nofunc)`     |
+    /// | `NoFunc`                          | `(ref nofunc)`                            |
+    /// | `Option<ExternRef>`               | `externref` aka `(ref null extern)`       |
+    /// | `ExternRef`                       | `(ref extern)`                            |
+    /// | `Option<NoExtern>`                | `nullexternref` aka `(ref null noextern)` |
+    /// | `NoExtern`                        | `(ref noextern)`                          |
+    /// | `Option<AnyRef>`                  | `anyref` aka `(ref null any)`             |
+    /// | `AnyRef`                          | `(ref any)`                               |
+    /// | `Option<I31>`                     | `i31ref` aka `(ref null i31)`             |
+    /// | `I31`                             | `(ref i31)`                               |
+    /// | `Option<StructRef>`               | `(ref null struct)`                       |
+    /// | `StructRef`                       | `(ref struct)`                            |
+    /// | `Option<ArrayRef>`                | `(ref null array)`                        |
+    /// | `ArrayRef`                        | `(ref array)`                             |
+    ///
+    /// Any of the Rust types can be returned from the closure as well, in
+    /// addition to some extra types
+    ///
+    /// | Rust Return Type  | WebAssembly Return Type | Meaning               |
+    /// |-------------------|-------------------------|-----------------------|
+    /// | `()`              | nothing                 | no return value       |
+    /// | `T`               | `T`                     | a single return value |
+    /// | `(T1, T2, ...)`   | `T1 T2 ...`             | multiple returns      |
+    ///
+    /// Note that all return types can also be wrapped in `Result<_>` to
+    /// indicate that the host function can generate a trap as well as possibly
+    /// returning a value.
+    ///
+    /// Finally you can also optionally take [`Caller`] as the first argument of
+    /// your closure. If inserted then you're able to inspect the caller's
+    /// state, for example the [`Memory`](crate::Memory) it has exported so you
+    /// can read what pointers point to.
+    ///
+    /// Note that when using this API, the intention is to create as thin of a
+    /// layer as possible for when WebAssembly calls the function provided. With
+    /// sufficient inlining and optimization the WebAssembly will call straight
+    /// into `func` provided, with no extra fluff entailed.
+    ///
+    /// # Why `Send + Sync + 'static`?
+    ///
+    /// All host functions defined in a [`Store`](crate::Store) (including
+    /// those from [`Func::new`] and other constructors) require that the
+    /// `func` provided is `Send + Sync + 'static`. Additionally host functions
+    /// always are `Fn` as opposed to `FnMut` or `FnOnce`. This can at-a-glance
+    /// feel restrictive since the closure cannot close over as many types as
+    /// before. The reason for this, though, is to ensure that
+    /// [`Store<T>`](crate::Store) can implement both the `Send` and `Sync`
+    /// traits.
+    ///
+    /// Fear not, however, because this isn't as restrictive as it seems! Host
+    /// functions are provided a [`Caller<'_, T>`](crate::Caller) argument which
+    /// allows access to the host-defined data within the
+    /// [`Store`](crate::Store). The `T` type is not required to be any of
+    /// `Send`, `Sync`, or `'static`! This means that you can store whatever
+    /// you'd like in `T` and have it accessible by all host functions.
+    /// Additionally mutable access to `T` is allowed through
+    /// [`Caller::data_mut`].
+    ///
+    /// Most host-defined [`Func`] values provide closures that end up not
+    /// actually closing over any values. These zero-sized types will use the
+    /// context from [`Caller`] for host-defined information.
+    ///
+    /// # Errors
+    ///
+    /// The closure provided here to `wrap` can optionally return a
+    /// [`Result<T>`](anyhow::Result). Returning `Ok(t)` represents the host
+    /// function successfully completing with the `t` result. Returning
+    /// `Err(e)`, however, is equivalent to raising a custom wasm trap.
+    /// Execution of WebAssembly does not resume and the stack is unwound to the
+    /// original caller of the function where the error is returned.
+    ///
+    /// For more information about errors in Wasmtime see the [`Trap`]
+    /// documentation.
+    ///
+    /// [`Trap`]: crate::Trap
+    ///
+    /// # Examples
+    ///
+    /// First up we can see how simple wasm imports can be implemented, such
+    /// as a function that adds its two arguments and returns the result.
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let mut store = Store::<()>::default();
+    /// let add = Func::wrap(&mut store, |a: i32, b: i32| a + b);
+    /// let module = Module::new(
+    ///     store.engine(),
+    ///     r#"
+    ///         (module
+    ///             (import "" "" (func $add (param i32 i32) (result i32)))
+    ///             (func (export "foo") (param i32 i32) (result i32)
+    ///                 local.get 0
+    ///                 local.get 1
+    ///                 call $add))
+    ///     "#,
+    /// )?;
+    /// let instance = Instance::new(&mut store, &module, &[add.into()])?;
+    /// let foo = instance.get_typed_func::<(i32, i32), i32>(&mut store, "foo")?;
+    /// assert_eq!(foo.call(&mut store, (1, 2))?, 3);
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// We can also do the same thing, but generate a trap if the addition
+    /// overflows:
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let mut store = Store::<()>::default();
+    /// let add = Func::wrap(&mut store, |a: i32, b: i32| {
+    ///     match a.checked_add(b) {
+    ///         Some(i) => Ok(i),
+    ///         None => anyhow::bail!("overflow"),
+    ///     }
+    /// });
+    /// let module = Module::new(
+    ///     store.engine(),
+    ///     r#"
+    ///         (module
+    ///             (import "" "" (func $add (param i32 i32) (result i32)))
+    ///             (func (export "foo") (param i32 i32) (result i32)
+    ///                 local.get 0
+    ///                 local.get 1
+    ///                 call $add))
+    ///     "#,
+    /// )?;
+    /// let instance = Instance::new(&mut store, &module, &[add.into()])?;
+    /// let foo = instance.get_typed_func::<(i32, i32), i32>(&mut store, "foo")?;
+    /// assert_eq!(foo.call(&mut store, (1, 2))?, 3);
+    /// assert!(foo.call(&mut store, (i32::max_value(), 1)).is_err());
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// And don't forget all the wasm types are supported!
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let mut store = Store::<()>::default();
+    /// let debug = Func::wrap(&mut store, |a: i32, b: u32, c: f32, d: i64, e: u64, f: f64| {
+    ///
+    ///     println!("a={}", a);
+    ///     println!("b={}", b);
+    ///     println!("c={}", c);
+    ///     println!("d={}", d);
+    ///     println!("e={}", e);
+    ///     println!("f={}", f);
+    /// });
+    /// let module = Module::new(
+    ///     store.engine(),
+    ///     r#"
+    ///         (module
+    ///             (import "" "" (func $debug (param i32 i32 f32 i64 i64 f64)))
+    ///             (func (export "foo")
+    ///                 i32.const -1
+    ///                 i32.const 1
+    ///                 f32.const 2
+    ///                 i64.const -3
+    ///                 i64.const 3
+    ///                 f64.const 4
+    ///                 call $debug))
+    ///     "#,
+    /// )?;
+    /// let instance = Instance::new(&mut store, &module, &[debug.into()])?;
+    /// let foo = instance.get_typed_func::<(), ()>(&mut store, "foo")?;
+    /// foo.call(&mut store, ())?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// Finally if you want to get really fancy you can also implement
+    /// imports that read/write wasm module's memory
+    ///
+    /// ```
+    /// use std::str;
+    ///
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let mut store = Store::default();
+    /// let log_str = Func::wrap(&mut store, |mut caller: Caller<'_, ()>, ptr: i32, len: i32| {
+    ///     let mem = match caller.get_export("memory") {
+    ///         Some(Extern::Memory(mem)) => mem,
+    ///         _ => anyhow::bail!("failed to find host memory"),
+    ///     };
+    ///     let data = mem.data(&caller)
+    ///         .get(ptr as u32 as usize..)
+    ///         .and_then(|arr| arr.get(..len as u32 as usize));
+    ///     let string = match data {
+    ///         Some(data) => match str::from_utf8(data) {
+    ///             Ok(s) => s,
+    ///             Err(_) => anyhow::bail!("invalid utf-8"),
+    ///         },
+    ///         None => anyhow::bail!("pointer/length out of bounds"),
+    ///     };
+    ///     assert_eq!(string, "Hello, world!");
+    ///     println!("{}", string);
+    ///     Ok(())
+    /// });
+    /// let module = Module::new(
+    ///     store.engine(),
+    ///     r#"
+    ///         (module
+    ///             (import "" "" (func $log_str (param i32 i32)))
+    ///             (func (export "foo")
+    ///                 i32.const 4   ;; ptr
+    ///                 i32.const 13  ;; len
+    ///                 call $log_str)
+    ///             (memory (export "memory") 1)
+    ///             (data (i32.const 4) "Hello, world!"))
+    ///     "#,
+    /// )?;
+    /// let instance = Instance::new(&mut store, &module, &[log_str.into()])?;
+    /// let foo = instance.get_typed_func::<(), ()>(&mut store, "foo")?;
+    /// foo.call(&mut store, ())?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn wrap<T, Params, Results>(
+        mut store: impl AsContextMut<Data = T>,
+        func: impl IntoFunc<T, Params, Results>,
+    ) -> Func {
+        let store = store.as_context_mut().0;
+        // part of this unsafety is about matching the `T` to a `Store<T>`,
+        // which is done through the `AsContextMut` bound above.
+        unsafe {
+            let host = HostFunc::wrap(store.engine(), func);
+            host.into_func(store)
+        }
+    }
+
+    fn wrap_inner<F, T, Params, Results>(mut store: impl AsContextMut<Data = T>, func: F) -> Func
+    where
+        F: Fn(Caller<'_, T>, Params) -> Results + Send + Sync + 'static,
+        Params: WasmTyList,
+        Results: WasmRet,
+    {
+        let store = store.as_context_mut().0;
+        // part of this unsafety is about matching the `T` to a `Store<T>`,
+        // which is done through the `AsContextMut` bound above.
+        unsafe {
+            let host = HostFunc::wrap_inner(store.engine(), func);
+            host.into_func(store)
+        }
+    }
+
+    /// Same as [`Func::wrap`], except the closure asynchronously produces the
+    /// result and the arguments are passed within a tuple. For more information
+    /// see the [`Func`] documentation.
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if called with a non-asynchronous store.
+    #[cfg(feature = "async")]
+    pub fn wrap_async<T, F, P, R>(store: impl AsContextMut<Data = T>, func: F) -> Func
+    where
+        F: for<'a> Fn(Caller<'a, T>, P) -> Box<dyn Future<Output = R> + Send + 'a>
+            + Send
+            + Sync
+            + 'static,
+        P: WasmTyList,
+        R: WasmRet,
+    {
+        assert!(
+            store.as_context().async_support(),
+            concat!("cannot use `wrap_async` without enabling async support on the config")
+        );
+        Func::wrap_inner(store, move |mut caller: Caller<'_, T>, args| {
+            let async_cx = caller
+                .store
+                .as_context_mut()
+                .0
+                .async_cx()
+                .expect("Attempt to start async function on dying fiber");
+            let mut future = Pin::from(func(caller, args));
+
+            match unsafe { async_cx.block_on(future.as_mut()) } {
+                Ok(ret) => ret.into_fallible(),
+                Err(e) => R::fallible_from_error(e),
+            }
+        })
+    }
+
+    /// Returns the underlying wasm type that this `Func` has.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `store` does not own this function.
+    pub fn ty(&self, store: impl AsContext) -> FuncType {
+        self.load_ty(&store.as_context().0)
+    }
+
+    /// Forcibly loads the type of this function from the `Engine`.
+    ///
+    /// Note that this is a somewhat expensive method since it requires taking a
+    /// lock as well as cloning a type.
+    pub(crate) fn load_ty(&self, store: &StoreOpaque) -> FuncType {
+        assert!(self.comes_from_same_store(store));
+        FuncType::from_shared_type_index(store.engine(), self.type_index(store.store_data()))
+    }
+
+    /// Does this function match the given type?
+    ///
+    /// That is, is this function's type a subtype of the given type?
+    ///
+    /// # Panics
+    ///
+    /// Panics if this function is not associated with the given store or if the
+    /// function type is not associated with the store's engine.
+    pub fn matches_ty(&self, store: impl AsContext, func_ty: &FuncType) -> bool {
+        self._matches_ty(store.as_context().0, func_ty)
+    }
+
+    pub(crate) fn _matches_ty(&self, store: &StoreOpaque, func_ty: &FuncType) -> bool {
+        let actual_ty = self.load_ty(store);
+        actual_ty.matches(func_ty)
+    }
+
+    pub(crate) fn ensure_matches_ty(&self, store: &StoreOpaque, func_ty: &FuncType) -> Result<()> {
+        if !self.comes_from_same_store(store) {
+            bail!("function used with wrong store");
+        }
+        if self._matches_ty(store, func_ty) {
+            Ok(())
+        } else {
+            let actual_ty = self.load_ty(store);
+            bail!("type mismatch: expected {func_ty}, found {actual_ty}")
+        }
+    }
+
+    /// Gets a reference to the `FuncType` for this function.
+    ///
+    /// Note that this returns both a reference to the type of this function as
+    /// well as a reference back to the store itself. This enables using the
+    /// `StoreOpaque` while the `FuncType` is also being used (from the
+    /// perspective of the borrow-checker) because otherwise the signature would
+    /// consider `StoreOpaque` borrowed mutable while `FuncType` is in use.
+    fn ty_ref<'a>(&self, store: &'a mut StoreOpaque) -> (&'a FuncType, &'a StoreOpaque) {
+        // If we haven't loaded our type into the store yet then do so lazily at
+        // this time.
+        if store.store_data()[self.0].ty.is_none() {
+            let ty = self.load_ty(store);
+            store.store_data_mut()[self.0].ty = Some(Box::new(ty));
+        }
+
+        (store.store_data()[self.0].ty.as_ref().unwrap(), store)
+    }
+
+    pub(crate) fn type_index(&self, data: &StoreData) -> VMSharedTypeIndex {
+        data[self.0].sig_index()
+    }
+
+    /// Invokes this function with the `params` given and writes returned values
+    /// to `results`.
+    ///
+    /// The `params` here must match the type signature of this `Func`, or an
+    /// error will occur. Additionally `results` must have the same
+    /// length as the number of results for this function. Calling this function
+    /// will synchronously execute the WebAssembly function referenced to get
+    /// the results.
+    ///
+    /// This function will return `Ok(())` if execution completed without a trap
+    /// or error of any kind. In this situation the results will be written to
+    /// the provided `results` array.
+    ///
+    /// # Errors
+    ///
+    /// Any error which occurs throughout the execution of the function will be
+    /// returned as `Err(e)`. The [`Error`](anyhow::Error) type can be inspected
+    /// for the precise error cause such as:
+    ///
+    /// * [`Trap`] - indicates that a wasm trap happened and execution was
+    ///   halted.
+    /// * [`WasmBacktrace`] - optionally included on errors for backtrace
+    ///   information of the trap/error.
+    /// * Other string-based errors to indicate issues such as type errors with
+    ///   `params`.
+    /// * Any host-originating error originally returned from a function defined
+    ///   via [`Func::new`], for example.
+    ///
+    /// Errors typically indicate that execution of WebAssembly was halted
+    /// mid-way and did not complete after the error condition happened.
+    ///
+    /// [`Trap`]: crate::Trap
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if called on a function belonging to an async
+    /// store. Asynchronous stores must always use `call_async`. Also panics if
+    /// `store` does not own this function.
+    ///
+    /// [`WasmBacktrace`]: crate::WasmBacktrace
+    pub fn call(
+        &self,
+        mut store: impl AsContextMut,
+        params: &[Val],
+        results: &mut [Val],
+    ) -> Result<()> {
+        assert!(
+            !store.as_context().async_support(),
+            "must use `call_async` when async support is enabled on the config",
+        );
+        let mut store = store.as_context_mut();
+        let need_gc = self.call_impl_check_args(&mut store, params, results)?;
+        if need_gc {
+            store.0.gc();
+        }
+        unsafe { self.call_impl_do_call(&mut store, params, results) }
+    }
+
+    /// Invokes this function in an "unchecked" fashion, reading parameters and
+    /// writing results to `params_and_returns`.
+    ///
+    /// This function is the same as [`Func::call`] except that the arguments
+    /// and results both use a different representation. If possible it's
+    /// recommended to use [`Func::call`] if safety isn't necessary or to use
+    /// [`Func::typed`] in conjunction with [`TypedFunc::call`] since that's
+    /// both safer and faster than this method of invoking a function.
+    ///
+    /// Note that if this function takes `externref` arguments then it will
+    /// **not** automatically GC unlike the [`Func::call`] and
+    /// [`TypedFunc::call`] functions. This means that if this function is
+    /// invoked many times with new `ExternRef` values and no other GC happens
+    /// via any other means then no values will get collected.
+    ///
+    /// # Errors
+    ///
+    /// For more information about errors see the [`Func::call`] documentation.
+    ///
+    /// # Unsafety
+    ///
+    /// This function is unsafe because the `params_and_returns` argument is not
+    /// validated at all. It must uphold invariants such as:
+    ///
+    /// * It's a valid pointer to an array
+    /// * It has enough space to store all parameters
+    /// * It has enough space to store all results (not at the same time as
+    ///   parameters)
+    /// * Parameters are initially written to the array and have the correct
+    ///   types and such.
+    /// * Reference types like `externref` and `funcref` are valid at the
+    ///   time of this call and for the `store` specified.
+    ///
+    /// These invariants are all upheld for you with [`Func::call`] and
+    /// [`TypedFunc::call`].
+    pub unsafe fn call_unchecked(
+        &self,
+        mut store: impl AsContextMut,
+        params_and_returns: *mut ValRaw,
+        params_and_returns_capacity: usize,
+    ) -> Result<()> {
+        let mut store = store.as_context_mut();
+        let data = &store.0.store_data()[self.0];
+        let func_ref = data.export().func_ref;
+        Self::call_unchecked_raw(
+            &mut store,
+            func_ref,
+            params_and_returns,
+            params_and_returns_capacity,
+        )
+    }
+
+    pub(crate) unsafe fn call_unchecked_raw<T>(
+        store: &mut StoreContextMut<'_, T>,
+        func_ref: NonNull<VMFuncRef>,
+        params_and_returns: *mut ValRaw,
+        params_and_returns_capacity: usize,
+    ) -> Result<()> {
+        invoke_wasm_and_catch_traps(store, |caller| {
+            let func_ref = func_ref.as_ref();
+            (func_ref.array_call)(
+                func_ref.vmctx,
+                caller.cast::<VMOpaqueContext>(),
+                params_and_returns,
+                params_and_returns_capacity,
+            )
+        })
+    }
+
+    /// Converts the raw representation of a `funcref` into an `Option<Func>`
+    ///
+    /// This is intended to be used in conjunction with [`Func::new_unchecked`],
+    /// [`Func::call_unchecked`], and [`ValRaw`] with its `funcref` field.
+    ///
+    /// # Unsafety
+    ///
+    /// This function is not safe because `raw` is not validated at all. The
+    /// caller must guarantee that `raw` is owned by the `store` provided and is
+    /// valid within the `store`.
+    pub unsafe fn from_raw(mut store: impl AsContextMut, raw: *mut c_void) -> Option<Func> {
+        Self::_from_raw(store.as_context_mut().0, raw)
+    }
+
+    pub(crate) unsafe fn _from_raw(store: &mut StoreOpaque, raw: *mut c_void) -> Option<Func> {
+        Func::from_vm_func_ref(store, raw.cast())
+    }
+
+    /// Extracts the raw value of this `Func`, which is owned by `store`.
+    ///
+    /// This function returns a value that's suitable for writing into the
+    /// `funcref` field of the [`ValRaw`] structure.
+    ///
+    /// # Unsafety
+    ///
+    /// The returned value is only valid for as long as the store is alive and
+    /// this function is properly rooted within it. Additionally this function
+    /// should not be liberally used since it's a very low-level knob.
+    pub unsafe fn to_raw(&self, mut store: impl AsContextMut) -> *mut c_void {
+        self.vm_func_ref(store.as_context_mut().0).as_ptr().cast()
+    }
+
+    /// Invokes this function with the `params` given, returning the results
+    /// asynchronously.
+    ///
+    /// This function is the same as [`Func::call`] except that it is
+    /// asynchronous. This is only compatible with stores associated with an
+    /// [asynchronous config](crate::Config::async_support).
+    ///
+    /// It's important to note that the execution of WebAssembly will happen
+    /// synchronously in the `poll` method of the future returned from this
+    /// function. Wasmtime does not manage its own thread pool or similar to
+    /// execute WebAssembly in. Future `poll` methods are generally expected to
+    /// resolve quickly, so it's recommended that you run or poll this future
+    /// in a "blocking context".
+    ///
+    /// For more information see the documentation on [asynchronous
+    /// configs](crate::Config::async_support).
+    ///
+    /// # Errors
+    ///
+    /// For more information on errors see the [`Func::call`] documentation.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this is called on a function in a synchronous store. This
+    /// only works with functions defined within an asynchronous store. Also
+    /// panics if `store` does not own this function.
+    #[cfg(feature = "async")]
+    pub async fn call_async<T>(
+        &self,
+        mut store: impl AsContextMut<Data = T>,
+        params: &[Val],
+        results: &mut [Val],
+    ) -> Result<()>
+    where
+        T: Send,
+    {
+        let mut store = store.as_context_mut();
+        assert!(
+            store.0.async_support(),
+            "cannot use `call_async` without enabling async support in the config",
+        );
+        let need_gc = self.call_impl_check_args(&mut store, params, results)?;
+        if need_gc {
+            store.0.gc_async().await;
+        }
+        let result = store
+            .on_fiber(|store| unsafe { self.call_impl_do_call(store, params, results) })
+            .await??;
+        Ok(result)
+    }
+
+    /// Perform dynamic checks that the arguments given to us match
+    /// the signature of this function and are appropriate to pass to this
+    /// function.
+    ///
+    /// This involves checking to make sure we have the right number and types
+    /// of arguments as well as making sure everything is from the same `Store`.
+    ///
+    /// This must be called just before `call_impl_do_call`.
+    ///
+    /// Returns whether we need to GC before calling `call_impl_do_call`.
+    fn call_impl_check_args<T>(
+        &self,
+        store: &mut StoreContextMut<'_, T>,
+        params: &[Val],
+        results: &mut [Val],
+    ) -> Result<bool> {
+        let (ty, opaque) = self.ty_ref(store.0);
+        if ty.params().len() != params.len() {
+            bail!(
+                "expected {} arguments, got {}",
+                ty.params().len(),
+                params.len()
+            );
+        }
+        if ty.results().len() != results.len() {
+            bail!(
+                "expected {} results, got {}",
+                ty.results().len(),
+                results.len()
+            );
+        }
+        for (ty, arg) in ty.params().zip(params) {
+            arg.ensure_matches_ty(opaque, &ty)
+                .context("argument type mismatch")?;
+            if !arg.comes_from_same_store(opaque) {
+                bail!("cross-`Store` values are not currently supported");
+            }
+        }
+
+        #[cfg(feature = "gc")]
+        {
+            // Check whether we need to GC before calling into Wasm.
+            //
+            // For example, with the DRC collector, whenever we pass GC refs
+            // from host code to Wasm code, they go into the
+            // `VMGcRefActivationsTable`. But the table might be at capacity
+            // already. If it is at capacity (unlikely) then we need to do a GC
+            // to free up space.
+            let num_gc_refs = ty.as_wasm_func_type().non_i31_gc_ref_params_count();
+            if let Some(num_gc_refs) = NonZeroUsize::new(num_gc_refs) {
+                return Ok(opaque
+                    .gc_store()?
+                    .gc_heap
+                    .need_gc_before_entering_wasm(num_gc_refs));
+            }
+        }
+
+        Ok(false)
+    }
+
+    /// Do the actual call into Wasm.
+    ///
+    /// # Safety
+    ///
+    /// You must have type checked the arguments by calling
+    /// `call_impl_check_args` immediately before calling this function. It is
+    /// only safe to call this function if that one did not return an error.
+    unsafe fn call_impl_do_call<T>(
+        &self,
+        store: &mut StoreContextMut<'_, T>,
+        params: &[Val],
+        results: &mut [Val],
+    ) -> Result<()> {
+        // Store the argument values into `values_vec`.
+        let (ty, _) = self.ty_ref(store.0);
+        let values_vec_size = params.len().max(ty.results().len());
+        let mut values_vec = store.0.take_wasm_val_raw_storage();
+        debug_assert!(values_vec.is_empty());
+        values_vec.resize_with(values_vec_size, || ValRaw::v128(0));
+        for (arg, slot) in params.iter().cloned().zip(&mut values_vec) {
+            unsafe {
+                *slot = arg.to_raw(&mut *store)?;
+            }
+        }
+
+        unsafe {
+            self.call_unchecked(&mut *store, values_vec.as_mut_ptr(), values_vec_size)?;
+        }
+
+        for ((i, slot), val) in results.iter_mut().enumerate().zip(&values_vec) {
+            let ty = self.ty_ref(store.0).0.results().nth(i).unwrap();
+            *slot = unsafe { Val::from_raw(&mut *store, *val, ty) };
+        }
+        values_vec.truncate(0);
+        store.0.save_wasm_val_raw_storage(values_vec);
+        Ok(())
+    }
+
+    #[inline]
+    pub(crate) fn vm_func_ref(&self, store: &mut StoreOpaque) -> NonNull<VMFuncRef> {
+        let func_data = &mut store.store_data_mut()[self.0];
+        let func_ref = func_data.export().func_ref;
+        if unsafe { func_ref.as_ref().wasm_call.is_some() } {
+            return func_ref;
+        }
+
+        if let Some(in_store) = func_data.in_store_func_ref {
+            in_store.as_non_null()
+        } else {
+            unsafe {
+                // Move this uncommon/slow path out of line.
+                self.copy_func_ref_into_store_and_fill(store, func_ref)
+            }
+        }
+    }
+
+    unsafe fn copy_func_ref_into_store_and_fill(
+        &self,
+        store: &mut StoreOpaque,
+        func_ref: NonNull<VMFuncRef>,
+    ) -> NonNull<VMFuncRef> {
+        let func_ref = store.func_refs().push(func_ref.as_ref().clone());
+        store.store_data_mut()[self.0].in_store_func_ref = Some(SendSyncPtr::new(func_ref));
+        store.fill_func_refs();
+        func_ref
+    }
+
+    pub(crate) unsafe fn from_wasmtime_function(
+        export: ExportFunction,
+        store: &mut StoreOpaque,
+    ) -> Self {
+        Func::from_func_kind(FuncKind::StoreOwned { export }, store)
+    }
+
+    fn from_func_kind(kind: FuncKind, store: &mut StoreOpaque) -> Self {
+        Func(store.store_data_mut().insert(FuncData {
+            kind,
+            in_store_func_ref: None,
+            ty: None,
+        }))
+    }
+
+    pub(crate) fn vmimport(&self, store: &mut StoreOpaque, module: &Module) -> VMFunctionImport {
+        unsafe {
+            let f = {
+                let func_data = &mut store.store_data_mut()[self.0];
+                // If we already patched this `funcref.wasm_call` and saved a
+                // copy in the store, use the patched version. Otherwise, use
+                // the potentially un-patched version.
+                if let Some(func_ref) = func_data.in_store_func_ref {
+                    func_ref.as_non_null()
+                } else {
+                    func_data.export().func_ref
+                }
+            };
+            VMFunctionImport {
+                wasm_call: if let Some(wasm_call) = f.as_ref().wasm_call {
+                    wasm_call
+                } else {
+                    // Assert that this is a array-call function, since those
+                    // are the only ones that could be missing a `wasm_call`
+                    // trampoline.
+                    let _ = VMArrayCallHostFuncContext::from_opaque(f.as_ref().vmctx);
+
+                    let sig = self.type_index(store.store_data());
+                    module.wasm_to_array_trampoline(sig).expect(
+                        "if the wasm is importing a function of a given type, it must have the \
+                         type's trampoline",
+                    )
+                },
+                array_call: f.as_ref().array_call,
+                vmctx: f.as_ref().vmctx,
+            }
+        }
+    }
+
+    pub(crate) fn comes_from_same_store(&self, store: &StoreOpaque) -> bool {
+        store.store_data().contains(self.0)
+    }
+
+    fn invoke_host_func_for_wasm<T>(
+        mut caller: Caller<'_, T>,
+        ty: &FuncType,
+        values_vec: &mut [ValRaw],
+        func: &dyn Fn(Caller<'_, T>, &[Val], &mut [Val]) -> Result<()>,
+    ) -> Result<()> {
+        // Translate the raw JIT arguments in `values_vec` into a `Val` which
+        // we'll be passing as a slice. The storage for our slice-of-`Val` we'll
+        // be taking from the `Store`. We preserve our slice back into the
+        // `Store` after the hostcall, ideally amortizing the cost of allocating
+        // the storage across wasm->host calls.
+        //
+        // Note that we have a dynamic guarantee that `values_vec` is the
+        // appropriate length to both read all arguments from as well as store
+        // all results into.
+        let mut val_vec = caller.store.0.take_hostcall_val_storage();
+        debug_assert!(val_vec.is_empty());
+        let nparams = ty.params().len();
+        val_vec.reserve(nparams + ty.results().len());
+        for (i, ty) in ty.params().enumerate() {
+            val_vec.push(unsafe { Val::from_raw(&mut caller.store, values_vec[i], ty) })
+        }
+
+        val_vec.extend((0..ty.results().len()).map(|_| Val::null_func_ref()));
+        let (params, results) = val_vec.split_at_mut(nparams);
+        func(caller.sub_caller(), params, results)?;
+
+        // Unlike our arguments we need to dynamically check that the return
+        // values produced are correct. There could be a bug in `func` that
+        // produces the wrong number, wrong types, or wrong stores of
+        // values, and we need to catch that here.
+        for (i, (ret, ty)) in results.iter().zip(ty.results()).enumerate() {
+            ret.ensure_matches_ty(caller.store.0, &ty)
+                .context("function attempted to return an incompatible value")?;
+            unsafe {
+                values_vec[i] = ret.to_raw(&mut caller.store)?;
+            }
+        }
+
+        // Restore our `val_vec` back into the store so it's usable for the next
+        // hostcall to reuse our own storage.
+        val_vec.truncate(0);
+        caller.store.0.save_hostcall_val_storage(val_vec);
+        Ok(())
+    }
+
+    /// Attempts to extract a typed object from this `Func` through which the
+    /// function can be called.
+    ///
+    /// This function serves as an alternative to [`Func::call`] and
+    /// [`Func::call_async`]. This method performs a static type check (using
+    /// the `Params` and `Results` type parameters on the underlying wasm
+    /// function. If the type check passes then a `TypedFunc` object is returned,
+    /// otherwise an error is returned describing the typecheck failure.
+    ///
+    /// The purpose of this relative to [`Func::call`] is that it's much more
+    /// efficient when used to invoke WebAssembly functions. With the types
+    /// statically known far less setup/teardown is required when invoking
+    /// WebAssembly. If speed is desired then this function is recommended to be
+    /// used instead of [`Func::call`] (which is more general, hence its
+    /// slowdown).
+    ///
+    /// The `Params` type parameter is used to describe the parameters of the
+    /// WebAssembly function. This can either be a single type (like `i32`), or
+    /// a tuple of types representing the list of parameters (like `(i32, f32,
+    /// f64)`). Additionally you can use `()` to represent that the function has
+    /// no parameters.
+    ///
+    /// The `Results` type parameter is used to describe the results of the
+    /// function. This behaves the same way as `Params`, but just for the
+    /// results of the function.
+    ///
+    /// # Translating Between WebAssembly and Rust Types
+    ///
+    /// Translation between Rust types and WebAssembly types looks like:
+    ///
+    /// | WebAssembly                               | Rust                                  |
+    /// |-------------------------------------------|---------------------------------------|
+    /// | `i32`                                     | `i32` or `u32`                        |
+    /// | `i64`                                     | `i64` or `u64`                        |
+    /// | `f32`                                     | `f32`                                 |
+    /// | `f64`                                     | `f64`                                 |
+    /// | `externref` aka `(ref null extern)`       | `Option<ExternRef>`                   |
+    /// | `(ref extern)`                            | `ExternRef`                           |
+    /// | `(ref noextern)`                          | `NoExtern`                            |
+    /// | `nullexternref` aka `(ref null noextern)` | `Option<NoExtern>`                    |
+    /// | `anyref` aka `(ref null any)`             | `Option<AnyRef>`                      |
+    /// | `(ref any)`                               | `AnyRef`                              |
+    /// | `i31ref` aka `(ref null i31)`             | `Option<I31>`                         |
+    /// | `(ref i31)`                               | `I31`                                 |
+    /// | `structref` aka `(ref null struct)`       | `Option<Struct>`                      |
+    /// | `(ref struct)`                            | `Struct`                              |
+    /// | `arrayref` aka `(ref null array)`         | `Option<Array>`                       |
+    /// | `(ref array)`                             | `Array`                               |
+    /// | `funcref` aka `(ref null func)`           | `Option<Func>`                        |
+    /// | `(ref func)`                              | `Func`                                |
+    /// | `(ref null <func type index>)`            | `Option<Func>`                        |
+    /// | `(ref <func type index>)`                 | `Func`                                |
+    /// | `nullfuncref` aka `(ref null nofunc)`     | `Option<NoFunc>`                      |
+    /// | `(ref nofunc)`                            | `NoFunc`                              |
+    /// | `v128`                                    | `V128` on `x86-64` and `aarch64` only |
+    ///
+    /// (Note that this mapping is the same as that of [`Func::wrap`]).
+    ///
+    /// Note that once the [`TypedFunc`] return value is acquired you'll use either
+    /// [`TypedFunc::call`] or [`TypedFunc::call_async`] as necessary to actually invoke
+    /// the function. This method does not invoke any WebAssembly code, it
+    /// simply performs a typecheck before returning the [`TypedFunc`] value.
+    ///
+    /// This method also has a convenience wrapper as
+    /// [`Instance::get_typed_func`](crate::Instance::get_typed_func) to
+    /// directly get a typed function value from an
+    /// [`Instance`](crate::Instance).
+    ///
+    /// ## Subtyping
+    ///
+    /// For result types, you can always use a supertype of the WebAssembly
+    /// function's actual declared result type. For example, if the WebAssembly
+    /// function was declared with type `(func (result nullfuncref))` you could
+    /// successfully call `f.typed::<(), Option<Func>>()` because `Option<Func>`
+    /// corresponds to `funcref`, which is a supertype of `nullfuncref`.
+    ///
+    /// For parameter types, you can always use a subtype of the WebAssembly
+    /// function's actual declared parameter type. For example, if the
+    /// WebAssembly function was declared with type `(func (param (ref null
+    /// func)))` you could successfully call `f.typed::<Func, ()>()` because
+    /// `Func` corresponds to `(ref func)`, which is a subtype of `(ref null
+    /// func)`.
+    ///
+    /// Additionally, for functions which take a reference to a concrete type as
+    /// a parameter, you can also use the concrete type's supertype. Consider a
+    /// WebAssembly function that takes a reference to a function with a
+    /// concrete type: `(ref null <func type index>)`. In this scenario, there
+    /// is no static `wasmtime::Foo` Rust type that corresponds to that
+    /// particular Wasm-defined concrete reference type because Wasm modules are
+    /// loaded dynamically at runtime. You *could* do `f.typed::<Option<NoFunc>,
+    /// ()>()`, and while that is correctly typed and valid, it is often overly
+    /// restrictive. The only value you could call the resulting typed function
+    /// with is the null function reference, but we'd like to call it with
+    /// non-null function references that happen to be of the correct
+    /// type. Therefore, `f.typed<Option<Func>, ()>()` is also allowed in this
+    /// case, even though `Option<Func>` represents `(ref null func)` which is
+    /// the supertype, not subtype, of `(ref null <func type index>)`. This does
+    /// imply some minimal dynamic type checks in this case, but it is supported
+    /// for better ergonomics, to enable passing non-null references into the
+    /// function.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error if `Params` or `Results` does not
+    /// match the native type of this WebAssembly function.
+    ///
+    /// # Panics
+    ///
+    /// This method will panic if `store` does not own this function.
+    ///
+    /// # Examples
+    ///
+    /// An end-to-end example of calling a function which takes no parameters
+    /// and has no results:
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// let engine = Engine::default();
+    /// let mut store = Store::new(&engine, ());
+    /// let module = Module::new(&engine, r#"(module (func (export "foo")))"#)?;
+    /// let instance = Instance::new(&mut store, &module, &[])?;
+    /// let foo = instance.get_func(&mut store, "foo").expect("export wasn't a function");
+    ///
+    /// // Note that this call can fail due to the typecheck not passing, but
+    /// // in our case we statically know the module so we know this should
+    /// // pass.
+    /// let typed = foo.typed::<(), ()>(&store)?;
+    ///
+    /// // Note that this can fail if the wasm traps at runtime.
+    /// typed.call(&mut store, ())?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// You can also pass in multiple parameters and get a result back
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn foo(add: &Func, mut store: Store<()>) -> anyhow::Result<()> {
+    /// let typed = add.typed::<(i32, i64), f32>(&store)?;
+    /// assert_eq!(typed.call(&mut store, (1, 2))?, 3.0);
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// and similarly if a function has multiple results you can bind that too
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn foo(add_with_overflow: &Func, mut store: Store<()>) -> anyhow::Result<()> {
+    /// let typed = add_with_overflow.typed::<(u32, u32), (u32, i32)>(&store)?;
+    /// let (result, overflow) = typed.call(&mut store, (u32::max_value(), 2))?;
+    /// assert_eq!(result, 1);
+    /// assert_eq!(overflow, 1);
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn typed<Params, Results>(
+        &self,
+        store: impl AsContext,
+    ) -> Result<TypedFunc<Params, Results>>
+    where
+        Params: WasmParams,
+        Results: WasmResults,
+    {
+        // Type-check that the params/results are all valid
+        let store = store.as_context().0;
+        let ty = self.load_ty(store);
+        Params::typecheck(store.engine(), ty.params(), TypeCheckPosition::Param)
+            .context("type mismatch with parameters")?;
+        Results::typecheck(store.engine(), ty.results(), TypeCheckPosition::Result)
+            .context("type mismatch with results")?;
+
+        // and then we can construct the typed version of this function
+        // (unsafely), which should be safe since we just did the type check above.
+        unsafe { Ok(TypedFunc::_new_unchecked(store, *self)) }
+    }
+
+    /// Get a stable hash key for this function.
+    ///
+    /// Even if the same underlying function is added to the `StoreData`
+    /// multiple times and becomes multiple `wasmtime::Func`s, this hash key
+    /// will be consistent across all of these functions.
+    #[allow(dead_code)] // Not used yet, but added for consistency.
+    pub(crate) fn hash_key(&self, store: &mut StoreOpaque) -> impl core::hash::Hash + Eq {
+        self.vm_func_ref(store).as_ptr() as usize
+    }
+}
+
+/// Prepares for entrance into WebAssembly.
+///
+/// This function will set up context such that `closure` is allowed to call a
+/// raw trampoline or a raw WebAssembly function. This *must* be called to do
+/// things like catch traps and set up GC properly.
+///
+/// The `closure` provided receives a default "caller" `VMContext` parameter it
+/// can pass to the called wasm function, if desired.
+pub(crate) fn invoke_wasm_and_catch_traps<T>(
+    store: &mut StoreContextMut<'_, T>,
+    closure: impl FnMut(*mut VMContext),
+) -> Result<()> {
+    unsafe {
+        let exit = enter_wasm(store);
+
+        if let Err(trap) = store.0.call_hook(CallHook::CallingWasm) {
+            exit_wasm(store, exit);
+            return Err(trap);
+        }
+        let result = crate::runtime::vm::catch_traps(
+            store.0.signal_handler(),
+            store.0.engine().config().wasm_backtrace,
+            store.0.engine().config().coredump_on_trap,
+            store.0.default_caller(),
+            closure,
+        );
+        exit_wasm(store, exit);
+        store.0.call_hook(CallHook::ReturningFromWasm)?;
+        result.map_err(|t| crate::trap::from_runtime_box(store.0, t))
+    }
+}
+
+/// This function is called to register state within `Store` whenever
+/// WebAssembly is entered within the `Store`.
+///
+/// This function sets up various limits such as:
+///
+/// * The stack limit. This is what ensures that we limit the stack space
+///   allocated by WebAssembly code and it's relative to the initial stack
+///   pointer that called into wasm.
+///
+/// This function may fail if the stack limit can't be set because an
+/// interrupt already happened.
+fn enter_wasm<T>(store: &mut StoreContextMut<'_, T>) -> Option<usize> {
+    // If this is a recursive call, e.g. our stack limit is already set, then
+    // we may be able to skip this function.
+    //
+    // For synchronous stores there's nothing else to do because all wasm calls
+    // happen synchronously and on the same stack. This means that the previous
+    // stack limit will suffice for the next recursive call.
+    //
+    // For asynchronous stores then each call happens on a separate native
+    // stack. This means that the previous stack limit is no longer relevant
+    // because we're on a separate stack.
+    if unsafe { *store.0.runtime_limits().stack_limit.get() } != usize::MAX
+        && !store.0.async_support()
+    {
+        return None;
+    }
+
+    // Ignore this stack pointer business on miri since we can't execute wasm
+    // anyway and the concept of a stack pointer on miri is a bit nebulous
+    // regardless.
+    if cfg!(miri) {
+        return None;
+    }
+
+    let stack_pointer = crate::runtime::vm::get_stack_pointer();
+
+    // Determine the stack pointer where, after which, any wasm code will
+    // immediately trap. This is checked on the entry to all wasm functions.
+    //
+    // Note that this isn't 100% precise. We are requested to give wasm
+    // `max_wasm_stack` bytes, but what we're actually doing is giving wasm
+    // probably a little less than `max_wasm_stack` because we're
+    // calculating the limit relative to this function's approximate stack
+    // pointer. Wasm will be executed on a frame beneath this one (or next
+    // to it). In any case it's expected to be at most a few hundred bytes
+    // of slop one way or another. When wasm is typically given a MB or so
+    // (a million bytes) the slop shouldn't matter too much.
+    //
+    // After we've got the stack limit then we store it into the `stack_limit`
+    // variable.
+    let wasm_stack_limit = stack_pointer - store.engine().config().max_wasm_stack;
+    let prev_stack = unsafe {
+        mem::replace(
+            &mut *store.0.runtime_limits().stack_limit.get(),
+            wasm_stack_limit,
+        )
+    };
+
+    Some(prev_stack)
+}
+
+fn exit_wasm<T>(store: &mut StoreContextMut<'_, T>, prev_stack: Option<usize>) {
+    // If we don't have a previous stack pointer to restore, then there's no
+    // cleanup we need to perform here.
+    let prev_stack = match prev_stack {
+        Some(stack) => stack,
+        None => return,
+    };
+
+    unsafe {
+        *store.0.runtime_limits().stack_limit.get() = prev_stack;
+    }
+}
+
+/// A trait implemented for types which can be returned from closures passed to
+/// [`Func::wrap`] and friends.
+///
+/// This trait should not be implemented by user types. This trait may change at
+/// any time internally. The types which implement this trait, however, are
+/// stable over time.
+///
+/// For more information see [`Func::wrap`]
+pub unsafe trait WasmRet {
+    // Same as `WasmTy::compatible_with_store`.
+    #[doc(hidden)]
+    fn compatible_with_store(&self, store: &StoreOpaque) -> bool;
+
+    /// Stores this return value into the `ptr` specified using the rooted
+    /// `store`.
+    ///
+    /// Traps are communicated through the `Result<_>` return value.
+    ///
+    /// # Unsafety
+    ///
+    /// This method is unsafe as `ptr` must have the correct length to store
+    /// this result. This property is only checked in debug mode, not in release
+    /// mode.
+    #[doc(hidden)]
+    unsafe fn store(
+        self,
+        store: &mut AutoAssertNoGc<'_>,
+        ptr: &mut [MaybeUninit<ValRaw>],
+    ) -> Result<()>;
+
+    #[doc(hidden)]
+    fn func_type(engine: &Engine, params: impl Iterator<Item = ValType>) -> FuncType;
+    #[doc(hidden)]
+    fn may_gc() -> bool;
+
+    // Utilities used to convert an instance of this type to a `Result`
+    // explicitly, used when wrapping async functions which always bottom-out
+    // in a function that returns a trap because futures can be cancelled.
+    #[doc(hidden)]
+    type Fallible: WasmRet;
+    #[doc(hidden)]
+    fn into_fallible(self) -> Self::Fallible;
+    #[doc(hidden)]
+    fn fallible_from_error(error: Error) -> Self::Fallible;
+}
+
+unsafe impl<T> WasmRet for T
+where
+    T: WasmTy,
+{
+    type Fallible = Result<T>;
+
+    fn compatible_with_store(&self, store: &StoreOpaque) -> bool {
+        <Self as WasmTy>::compatible_with_store(self, store)
+    }
+
+    unsafe fn store(
+        self,
+        store: &mut AutoAssertNoGc<'_>,
+        ptr: &mut [MaybeUninit<ValRaw>],
+    ) -> Result<()> {
+        debug_assert!(ptr.len() > 0);
+        <Self as WasmTy>::store(self, store, ptr.get_unchecked_mut(0))
+    }
+
+    fn may_gc() -> bool {
+        T::may_gc()
+    }
+
+    fn func_type(engine: &Engine, params: impl Iterator<Item = ValType>) -> FuncType {
+        FuncType::new(engine, params, Some(<Self as WasmTy>::valtype()))
+    }
+
+    fn into_fallible(self) -> Result<T> {
+        Ok(self)
+    }
+
+    fn fallible_from_error(error: Error) -> Result<T> {
+        Err(error)
+    }
+}
+
+unsafe impl<T> WasmRet for Result<T>
+where
+    T: WasmRet,
+{
+    type Fallible = Self;
+
+    fn compatible_with_store(&self, store: &StoreOpaque) -> bool {
+        match self {
+            Ok(x) => <T as WasmRet>::compatible_with_store(x, store),
+            Err(_) => true,
+        }
+    }
+
+    unsafe fn store(
+        self,
+        store: &mut AutoAssertNoGc<'_>,
+        ptr: &mut [MaybeUninit<ValRaw>],
+    ) -> Result<()> {
+        self.and_then(|val| val.store(store, ptr))
+    }
+
+    fn may_gc() -> bool {
+        T::may_gc()
+    }
+
+    fn func_type(engine: &Engine, params: impl Iterator<Item = ValType>) -> FuncType {
+        T::func_type(engine, params)
+    }
+
+    fn into_fallible(self) -> Result<T> {
+        self
+    }
+
+    fn fallible_from_error(error: Error) -> Result<T> {
+        Err(error)
+    }
+}
+
+macro_rules! impl_wasm_host_results {
+    ($n:tt $($t:ident)*) => (
+        #[allow(non_snake_case)]
+        unsafe impl<$($t),*> WasmRet for ($($t,)*)
+        where
+            $($t: WasmTy,)*
+        {
+            type Fallible = Result<Self>;
+
+            #[inline]
+            fn compatible_with_store(&self, _store: &StoreOpaque) -> bool {
+                let ($($t,)*) = self;
+                $( $t.compatible_with_store(_store) && )* true
+            }
+
+            #[inline]
+            unsafe fn store(
+                self,
+                _store: &mut AutoAssertNoGc<'_>,
+                _ptr: &mut [MaybeUninit<ValRaw>],
+            ) -> Result<()> {
+                let ($($t,)*) = self;
+                let mut _cur = 0;
+                $(
+                    debug_assert!(_cur < _ptr.len());
+                    let val = _ptr.get_unchecked_mut(_cur);
+                    _cur += 1;
+                    WasmTy::store($t, _store, val)?;
+                )*
+                Ok(())
+            }
+
+            #[doc(hidden)]
+            fn may_gc() -> bool {
+                $( $t::may_gc() || )* false
+            }
+
+            fn func_type(engine: &Engine, params: impl Iterator<Item = ValType>) -> FuncType {
+                FuncType::new(
+                    engine,
+                    params,
+                    IntoIterator::into_iter([$($t::valtype(),)*]),
+                )
+            }
+
+            #[inline]
+            fn into_fallible(self) -> Result<Self> {
+                Ok(self)
+            }
+
+            #[inline]
+            fn fallible_from_error(error: Error) -> Result<Self> {
+                Err(error)
+            }
+        }
+    )
+}
+
+for_each_function_signature!(impl_wasm_host_results);
+
+/// Internal trait implemented for all arguments that can be passed to
+/// [`Func::wrap`] and [`Linker::func_wrap`](crate::Linker::func_wrap).
+///
+/// This trait should not be implemented by external users, it's only intended
+/// as an implementation detail of this crate.
+pub trait IntoFunc<T, Params, Results>: Send + Sync + 'static {
+    /// Convert this function into a `VM{Array,Native}CallHostFuncContext` and
+    /// internal `VMFuncRef`.
+    #[doc(hidden)]
+    fn into_func(self, engine: &Engine) -> HostContext;
+}
+
+macro_rules! impl_into_func {
+    ($num:tt $arg:ident) => {
+        // Implement for functions without a leading `&Caller` parameter,
+        // delegating to the implementation below which does have the leading
+        // `Caller` parameter.
+        #[allow(non_snake_case)]
+        impl<T, F, $arg, R> IntoFunc<T, $arg, R> for F
+        where
+            F: Fn($arg) -> R + Send + Sync + 'static,
+            $arg: WasmTy,
+            R: WasmRet,
+        {
+            fn into_func(self, engine: &Engine) -> HostContext {
+                let f = move |_: Caller<'_, T>, $arg: $arg| {
+                    self($arg)
+                };
+
+                f.into_func(engine)
+            }
+        }
+
+        #[allow(non_snake_case)]
+        impl<T, F, $arg, R> IntoFunc<T, (Caller<'_, T>, $arg), R> for F
+        where
+            F: Fn(Caller<'_, T>, $arg) -> R + Send + Sync + 'static,
+            $arg: WasmTy,
+            R: WasmRet,
+        {
+            fn into_func(self, engine: &Engine) -> HostContext {
+                HostContext::from_closure(engine, move |caller: Caller<'_, T>, ($arg,)| {
+                    self(caller, $arg)
+                })
+            }
+        }
+    };
+    ($num:tt $($args:ident)*) => {
+        // Implement for functions without a leading `&Caller` parameter,
+        // delegating to the implementation below which does have the leading
+        // `Caller` parameter.
+        #[allow(non_snake_case)]
+        impl<T, F, $($args,)* R> IntoFunc<T, ($($args,)*), R> for F
+        where
+            F: Fn($($args),*) -> R + Send + Sync + 'static,
+            $($args: WasmTy,)*
+            R: WasmRet,
+        {
+            fn into_func(self, engine: &Engine) -> HostContext {
+                let f = move |_: Caller<'_, T>, $($args:$args),*| {
+                    self($($args),*)
+                };
+
+                f.into_func(engine)
+            }
+        }
+
+        #[allow(non_snake_case)]
+        impl<T, F, $($args,)* R> IntoFunc<T, (Caller<'_, T>, $($args,)*), R> for F
+        where
+            F: Fn(Caller<'_, T>, $($args),*) -> R + Send + Sync + 'static,
+            $($args: WasmTy,)*
+            R: WasmRet,
+        {
+            fn into_func(self, engine: &Engine) -> HostContext {
+                HostContext::from_closure(engine, move |caller: Caller<'_, T>, ( $( $args ),* )| {
+                    self(caller, $( $args ),* )
+                })
+            }
+        }
+    }
+}
+
+for_each_function_signature!(impl_into_func);
+
+/// Trait implemented for various tuples made up of types which implement
+/// [`WasmTy`] that can be passed to [`Func::wrap_inner`] and
+/// [`HostContext::from_closure`].
+pub unsafe trait WasmTyList {
+    /// Get the value type that each Type in the list represents.
+    fn valtypes() -> impl Iterator<Item = ValType>;
+
+    // Load a version of `Self` from the `values` provided.
+    //
+    // # Safety
+    //
+    // This function is unsafe as it's up to the caller to ensure that `values` are
+    // valid for this given type.
+    #[doc(hidden)]
+    unsafe fn load(store: &mut AutoAssertNoGc<'_>, values: &mut [MaybeUninit<ValRaw>]) -> Self;
+
+    #[doc(hidden)]
+    fn may_gc() -> bool;
+}
+
+macro_rules! impl_wasm_ty_list {
+    ($num:tt $($args:ident)*) => (paste::paste!{
+        #[allow(non_snake_case)]
+        unsafe impl<$($args),*> WasmTyList for ($($args,)*)
+        where
+            $($args: WasmTy,)*
+        {
+            fn valtypes() -> impl Iterator<Item = ValType> {
+                IntoIterator::into_iter([$($args::valtype(),)*])
+            }
+
+            unsafe fn load(_store: &mut AutoAssertNoGc<'_>, _values: &mut [MaybeUninit<ValRaw>]) -> Self {
+                let mut _cur = 0;
+                ($({
+                    debug_assert!(_cur < _values.len());
+                    let ptr = _values.get_unchecked(_cur).assume_init_ref();
+                    _cur += 1;
+                    $args::load(_store, ptr)
+                },)*)
+            }
+
+            fn may_gc() -> bool {
+                $( $args::may_gc() || )* false
+            }
+        }
+    });
+}
+
+for_each_function_signature!(impl_wasm_ty_list);
+
+/// A structure representing the caller's context when creating a function
+/// via [`Func::wrap`].
+///
+/// This structure can be taken as the first parameter of a closure passed to
+/// [`Func::wrap`] or other constructors, and serves two purposes:
+///
+/// * First consumers can use [`Caller<'_, T>`](crate::Caller) to get access to
+///   [`StoreContextMut<'_, T>`](crate::StoreContextMut) and/or get access to
+///   `T` itself. This means that the [`Caller`] type can serve as a proxy to
+///   the original [`Store`](crate::Store) itself and is used to satisfy
+///   [`AsContext`] and [`AsContextMut`] bounds.
+///
+/// * Second a [`Caller`] can be used as the name implies, learning about the
+///   caller's context, namely it's exported memory and exported functions. This
+///   allows functions which take pointers as arguments to easily read the
+///   memory the pointers point into, or if a function is expected to call
+///   malloc in the wasm module to reserve space for the output you can do that.
+///
+/// Host functions which want access to [`Store`](crate::Store)-level state are
+/// recommended to use this type.
+pub struct Caller<'a, T> {
+    pub(crate) store: StoreContextMut<'a, T>,
+    caller: &'a crate::runtime::vm::Instance,
+}
+
+impl<T> Caller<'_, T> {
+    unsafe fn with<F, R>(caller: *mut VMContext, f: F) -> R
+    where
+        // The closure must be valid for any `Caller` it is given; it doesn't
+        // get to choose the `Caller`'s lifetime.
+        F: for<'a> FnOnce(Caller<'a, T>) -> R,
+        // And the return value must not borrow from the caller/store.
+        R: 'static,
+    {
+        debug_assert!(!caller.is_null());
+        crate::runtime::vm::Instance::from_vmctx(caller, |instance| {
+            let store = StoreContextMut::from_raw(instance.store());
+            let gc_lifo_scope = store.0.gc_roots().enter_lifo_scope();
+
+            let ret = f(Caller {
+                store,
+                caller: &instance,
+            });
+
+            // Safe to recreate a mutable borrow of the store because `ret`
+            // cannot be borrowing from the store.
+            let store = StoreContextMut::<T>::from_raw(instance.store());
+            store.0.exit_gc_lifo_scope(gc_lifo_scope);
+
+            ret
+        })
+    }
+
+    fn sub_caller(&mut self) -> Caller<'_, T> {
+        Caller {
+            store: self.store.as_context_mut(),
+            caller: self.caller,
+        }
+    }
+
+    /// Looks up an export from the caller's module by the `name` given.
+    ///
+    /// This is a low-level function that's typically used to implement passing
+    /// of pointers or indices between core Wasm instances, where the callee
+    /// needs to consult the caller's exports to perform memory management and
+    /// resolve the references.
+    ///
+    /// For comparison, in components, the component model handles translating
+    /// arguments from one component instance to another and managing memory, so
+    /// that callees don't need to be aware of their callers, which promotes
+    /// virtualizability of APIs.
+    ///
+    /// # Return
+    ///
+    /// If an export with the `name` provided was found, then it is returned as an
+    /// `Extern`. There are a number of situations, however, where the export may not
+    /// be available:
+    ///
+    /// * The caller instance may not have an export named `name`
+    /// * There may not be a caller available, for example if `Func` was called
+    ///   directly from host code.
+    ///
+    /// It's recommended to take care when calling this API and gracefully
+    /// handling a `None` return value.
+    pub fn get_export(&mut self, name: &str) -> Option<Extern> {
+        // All instances created have a `host_state` with a pointer pointing
+        // back to themselves. If this caller doesn't have that `host_state`
+        // then it probably means it was a host-created object like `Func::new`
+        // which doesn't have any exports we want to return anyway.
+        self.caller
+            .host_state()
+            .downcast_ref::<Instance>()?
+            .get_export(&mut self.store, name)
+    }
+
+    /// Access the underlying data owned by this `Store`.
+    ///
+    /// Same as [`Store::data`](crate::Store::data)
+    pub fn data(&self) -> &T {
+        self.store.data()
+    }
+
+    /// Access the underlying data owned by this `Store`.
+    ///
+    /// Same as [`Store::data_mut`](crate::Store::data_mut)
+    pub fn data_mut(&mut self) -> &mut T {
+        self.store.data_mut()
+    }
+
+    /// Returns the underlying [`Engine`] this store is connected to.
+    pub fn engine(&self) -> &Engine {
+        self.store.engine()
+    }
+
+    /// Perform garbage collection.
+    ///
+    /// Same as [`Store::gc`](crate::Store::gc).
+    #[cfg(feature = "gc")]
+    pub fn gc(&mut self) {
+        self.store.gc()
+    }
+
+    /// Perform garbage collection asynchronously.
+    ///
+    /// Same as [`Store::gc_async`](crate::Store::gc_async).
+    #[cfg(all(feature = "async", feature = "gc"))]
+    pub async fn gc_async(&mut self)
+    where
+        T: Send,
+    {
+        self.store.gc_async().await;
+    }
+
+    /// Returns the remaining fuel in the store.
+    ///
+    /// For more information see [`Store::get_fuel`](crate::Store::get_fuel)
+    pub fn get_fuel(&self) -> Result<u64> {
+        self.store.get_fuel()
+    }
+
+    /// Set the amount of fuel in this store to be consumed when executing wasm code.
+    ///
+    /// For more information see [`Store::set_fuel`](crate::Store::set_fuel)
+    pub fn set_fuel(&mut self, fuel: u64) -> Result<()> {
+        self.store.set_fuel(fuel)
+    }
+
+    /// Configures this `Store` to yield while executing futures every N units of fuel.
+    ///
+    /// For more information see
+    /// [`Store::fuel_async_yield_interval`](crate::Store::fuel_async_yield_interval)
+    pub fn fuel_async_yield_interval(&mut self, interval: Option<u64>) -> Result<()> {
+        self.store.fuel_async_yield_interval(interval)
+    }
+}
+
+impl<T> AsContext for Caller<'_, T> {
+    type Data = T;
+    fn as_context(&self) -> StoreContext<'_, T> {
+        self.store.as_context()
+    }
+}
+
+impl<T> AsContextMut for Caller<'_, T> {
+    fn as_context_mut(&mut self) -> StoreContextMut<'_, T> {
+        self.store.as_context_mut()
+    }
+}
+
+// State stored inside a `VMArrayCallHostFuncContext`.
+struct HostFuncState<F> {
+    // The actual host function.
+    func: F,
+
+    // NB: We have to keep our `VMSharedTypeIndex` registered in the engine for
+    // as long as this function exists.
+    #[allow(dead_code)]
+    ty: RegisteredType,
+}
+
+#[doc(hidden)]
+pub enum HostContext {
+    Array(StoreBox<VMArrayCallHostFuncContext>),
+}
+
+impl From<StoreBox<VMArrayCallHostFuncContext>> for HostContext {
+    fn from(ctx: StoreBox<VMArrayCallHostFuncContext>) -> Self {
+        HostContext::Array(ctx)
+    }
+}
+
+impl HostContext {
+    fn from_closure<F, T, P, R>(engine: &Engine, func: F) -> Self
+    where
+        F: Fn(Caller<'_, T>, P) -> R + Send + Sync + 'static,
+        P: WasmTyList,
+        R: WasmRet,
+    {
+        let ty = R::func_type(engine, None::<ValType>.into_iter().chain(P::valtypes()));
+        let type_index = ty.type_index();
+
+        let array_call = Self::array_call_trampoline::<T, F, P, R>;
+
+        let ctx = unsafe {
+            VMArrayCallHostFuncContext::new(
+                VMFuncRef {
+                    array_call,
+                    wasm_call: None,
+                    type_index,
+                    vmctx: ptr::null_mut(),
+                },
+                Box::new(HostFuncState {
+                    func,
+                    ty: ty.into_registered_type(),
+                }),
+            )
+        };
+
+        ctx.into()
+    }
+
+    unsafe extern "C" fn array_call_trampoline<T, F, P, R>(
+        callee_vmctx: *mut VMOpaqueContext,
+        caller_vmctx: *mut VMOpaqueContext,
+        args: *mut ValRaw,
+        args_len: usize,
+    ) where
+        F: Fn(Caller<'_, T>, P) -> R + 'static,
+        P: WasmTyList,
+        R: WasmRet,
+    {
+        // Note that this function is intentionally scoped into a
+        // separate closure. Handling traps and panics will involve
+        // longjmp-ing from this function which means we won't run
+        // destructors. As a result anything requiring a destructor
+        // should be part of this closure, and the long-jmp-ing
+        // happens after the closure in handling the result.
+        let run = move |mut caller: Caller<'_, T>| {
+            let args =
+                core::slice::from_raw_parts_mut(args.cast::<MaybeUninit<ValRaw>>(), args_len);
+            let vmctx = VMArrayCallHostFuncContext::from_opaque(callee_vmctx);
+            let state = (*vmctx).host_state();
+
+            // Double-check ourselves in debug mode, but we control
+            // the `Any` here so an unsafe downcast should also
+            // work.
+            debug_assert!(state.is::<HostFuncState<F>>());
+            let state = &*(state as *const _ as *const HostFuncState<F>);
+            let func = &state.func;
+
+            let ret = 'ret: {
+                if let Err(trap) = caller.store.0.call_hook(CallHook::CallingHost) {
+                    break 'ret R::fallible_from_error(trap);
+                }
+
+                let mut store = if P::may_gc() {
+                    AutoAssertNoGc::new(caller.store.0)
+                } else {
+                    unsafe { AutoAssertNoGc::disabled(caller.store.0) }
+                };
+                let params = P::load(&mut store, args);
+                let _ = &mut store;
+                drop(store);
+
+                let r = func(caller.sub_caller(), params);
+                if let Err(trap) = caller.store.0.call_hook(CallHook::ReturningFromHost) {
+                    break 'ret R::fallible_from_error(trap);
+                }
+                r.into_fallible()
+            };
+
+            if !ret.compatible_with_store(caller.store.0) {
+                bail!("host function attempted to return cross-`Store` value to Wasm")
+            } else {
+                let mut store = if R::may_gc() {
+                    AutoAssertNoGc::new(caller.store.0)
+                } else {
+                    unsafe { AutoAssertNoGc::disabled(caller.store.0) }
+                };
+                let ret = ret.store(&mut store, args)?;
+                Ok(ret)
+            }
+        };
+
+        // With nothing else on the stack move `run` into this
+        // closure and then run it as part of `Caller::with`.
+        let result = crate::runtime::vm::catch_unwind_and_longjmp(move || {
+            let caller_vmctx = VMContext::from_opaque(caller_vmctx);
+            Caller::with(caller_vmctx, run)
+        });
+
+        match result {
+            Ok(val) => val,
+            Err(err) => crate::trap::raise(err),
+        }
+    }
+}
+
+/// Representation of a host-defined function.
+///
+/// This is used for `Func::new` but also for `Linker`-defined functions. For
+/// `Func::new` this is stored within a `Store`, and for `Linker`-defined
+/// functions they wrap this up in `Arc` to enable shared ownership of this
+/// across many stores.
+///
+/// Technically this structure needs a `<T>` type parameter to connect to the
+/// `Store<T>` itself, but that's an unsafe contract of using this for now
+/// rather than part of the struct type (to avoid `Func<T>` in the API).
+pub(crate) struct HostFunc {
+    ctx: HostContext,
+
+    // Stored to unregister this function's signature with the engine when this
+    // is dropped.
+    engine: Engine,
+}
+
+impl HostFunc {
+    /// Analog of [`Func::new`]
+    ///
+    /// # Panics
+    ///
+    /// Panics if the given function type is not associated with the given
+    /// engine.
+    pub fn new<T>(
+        engine: &Engine,
+        ty: FuncType,
+        func: impl Fn(Caller<'_, T>, &[Val], &mut [Val]) -> Result<()> + Send + Sync + 'static,
+    ) -> Self {
+        assert!(ty.comes_from_same_engine(engine));
+        let ty_clone = ty.clone();
+        unsafe {
+            HostFunc::new_unchecked(engine, ty, move |caller, values| {
+                Func::invoke_host_func_for_wasm(caller, &ty_clone, values, &func)
+            })
+        }
+    }
+
+    /// Analog of [`Func::new_unchecked`]
+    ///
+    /// # Panics
+    ///
+    /// Panics if the given function type is not associated with the given
+    /// engine.
+    pub unsafe fn new_unchecked<T>(
+        engine: &Engine,
+        ty: FuncType,
+        func: impl Fn(Caller<'_, T>, &mut [ValRaw]) -> Result<()> + Send + Sync + 'static,
+    ) -> Self {
+        assert!(ty.comes_from_same_engine(engine));
+        let func = move |caller_vmctx, values: &mut [ValRaw]| {
+            Caller::<T>::with(caller_vmctx, |mut caller| {
+                caller.store.0.call_hook(CallHook::CallingHost)?;
+                let result = func(caller.sub_caller(), values)?;
+                caller.store.0.call_hook(CallHook::ReturningFromHost)?;
+                Ok(result)
+            })
+        };
+        let ctx = crate::trampoline::create_array_call_function(&ty, func)
+            .expect("failed to create function");
+        HostFunc::_new(engine, ctx.into())
+    }
+
+    /// Analog of [`Func::wrap_inner`]
+    pub fn wrap_inner<F, T, Params, Results>(engine: &Engine, func: F) -> Self
+    where
+        F: Fn(Caller<'_, T>, Params) -> Results + Send + Sync + 'static,
+        Params: WasmTyList,
+        Results: WasmRet,
+    {
+        let ctx = HostContext::from_closure(engine, func);
+        HostFunc::_new(engine, ctx)
+    }
+
+    /// Analog of [`Func::wrap`]
+    pub fn wrap<T, Params, Results>(
+        engine: &Engine,
+        func: impl IntoFunc<T, Params, Results>,
+    ) -> Self {
+        let ctx = func.into_func(engine);
+        HostFunc::_new(engine, ctx)
+    }
+
+    /// Requires that this function's signature is already registered within
+    /// `Engine`. This happens automatically during the above two constructors.
+    fn _new(engine: &Engine, ctx: HostContext) -> Self {
+        HostFunc {
+            ctx,
+            engine: engine.clone(),
+        }
+    }
+
+    /// Inserts this `HostFunc` into a `Store`, returning the `Func` pointing to
+    /// it.
+    ///
+    /// # Unsafety
+    ///
+    /// Can only be inserted into stores with a matching `T` relative to when
+    /// this `HostFunc` was first created.
+    pub unsafe fn to_func(self: &Arc<Self>, store: &mut StoreOpaque) -> Func {
+        self.validate_store(store);
+        let me = self.clone();
+        Func::from_func_kind(FuncKind::SharedHost(me), store)
+    }
+
+    /// Inserts this `HostFunc` into a `Store`, returning the `Func` pointing to
+    /// it.
+    ///
+    /// This function is similar to, but not equivalent, to `HostFunc::to_func`.
+    /// Notably this function requires that the `Arc<Self>` pointer is otherwise
+    /// rooted within the `StoreOpaque` via another means. When in doubt use
+    /// `to_func` above as it's safer.
+    ///
+    /// # Unsafety
+    ///
+    /// Can only be inserted into stores with a matching `T` relative to when
+    /// this `HostFunc` was first created.
+    ///
+    /// Additionally the `&Arc<Self>` is not cloned in this function. Instead a
+    /// raw pointer to `Self` is stored within the `Store` for this function.
+    /// The caller must arrange for the `Arc<Self>` to be "rooted" in the store
+    /// provided via another means, probably by pushing to
+    /// `StoreOpaque::rooted_host_funcs`.
+    ///
+    /// Similarly, the caller must arrange for `rooted_func_ref` to be rooted in
+    /// the same store.
+    pub unsafe fn to_func_store_rooted(
+        self: &Arc<Self>,
+        store: &mut StoreOpaque,
+        rooted_func_ref: Option<NonNull<VMFuncRef>>,
+    ) -> Func {
+        self.validate_store(store);
+
+        if rooted_func_ref.is_some() {
+            debug_assert!(self.func_ref().wasm_call.is_none());
+            debug_assert!(matches!(self.ctx, HostContext::Array(_)));
+        }
+
+        Func::from_func_kind(
+            FuncKind::RootedHost(RootedHostFunc::new(self, rooted_func_ref)),
+            store,
+        )
+    }
+
+    /// Same as [`HostFunc::to_func`], different ownership.
+    unsafe fn into_func(self, store: &mut StoreOpaque) -> Func {
+        self.validate_store(store);
+        Func::from_func_kind(FuncKind::Host(Box::new(self)), store)
+    }
+
+    fn validate_store(&self, store: &mut StoreOpaque) {
+        // This assert is required to ensure that we can indeed safely insert
+        // `self` into the `store` provided, otherwise the type information we
+        // have listed won't be correct. This is possible to hit with the public
+        // API of Wasmtime, and should be documented in relevant functions.
+        assert!(
+            Engine::same(&self.engine, store.engine()),
+            "cannot use a store with a different engine than a linker was created with",
+        );
+    }
+
+    pub(crate) fn sig_index(&self) -> VMSharedTypeIndex {
+        self.func_ref().type_index
+    }
+
+    pub(crate) fn func_ref(&self) -> &VMFuncRef {
+        match &self.ctx {
+            HostContext::Array(ctx) => unsafe { (*ctx.get()).func_ref() },
+        }
+    }
+
+    pub(crate) fn host_ctx(&self) -> &HostContext {
+        &self.ctx
+    }
+
+    fn export_func(&self) -> ExportFunction {
+        ExportFunction {
+            func_ref: NonNull::from(self.func_ref()),
+        }
+    }
+}
+
+impl FuncData {
+    #[inline]
+    fn export(&self) -> ExportFunction {
+        self.kind.export()
+    }
+
+    pub(crate) fn sig_index(&self) -> VMSharedTypeIndex {
+        unsafe { self.export().func_ref.as_ref().type_index }
+    }
+}
+
+impl FuncKind {
+    #[inline]
+    fn export(&self) -> ExportFunction {
+        match self {
+            FuncKind::StoreOwned { export, .. } => *export,
+            FuncKind::SharedHost(host) => host.export_func(),
+            FuncKind::RootedHost(rooted) => ExportFunction {
+                func_ref: NonNull::from(rooted.func_ref()),
+            },
+            FuncKind::Host(host) => host.export_func(),
+        }
+    }
+}
+
+use self::rooted::*;
+
+/// An inner module is used here to force unsafe construction of
+/// `RootedHostFunc` instead of accidentally safely allowing access to its
+/// constructor.
+mod rooted {
+    use super::HostFunc;
+    use crate::runtime::vm::{SendSyncPtr, VMFuncRef};
+    use alloc::sync::Arc;
+    use core::ptr::NonNull;
+
+    /// A variant of a pointer-to-a-host-function used in `FuncKind::RootedHost`
+    /// above.
+    ///
+    /// For more documentation see `FuncKind::RootedHost`, `InstancePre`, and
+    /// `HostFunc::to_func_store_rooted`.
+    pub(crate) struct RootedHostFunc {
+        func: SendSyncPtr<HostFunc>,
+        func_ref: Option<SendSyncPtr<VMFuncRef>>,
+    }
+
+    impl RootedHostFunc {
+        /// Note that this is `unsafe` because this wrapper type allows safe
+        /// access to the pointer given at any time, including outside the
+        /// window of validity of `func`, so callers must not use the return
+        /// value past the lifetime of the provided `func`.
+        ///
+        /// Similarly, callers must ensure that the given `func_ref` is valid
+        /// for the lifetime of the return value.
+        pub(crate) unsafe fn new(
+            func: &Arc<HostFunc>,
+            func_ref: Option<NonNull<VMFuncRef>>,
+        ) -> RootedHostFunc {
+            RootedHostFunc {
+                func: NonNull::from(&**func).into(),
+                func_ref: func_ref.map(|p| p.into()),
+            }
+        }
+
+        pub(crate) fn func(&self) -> &HostFunc {
+            // Safety invariants are upheld by the `RootedHostFunc::new` caller.
+            unsafe { self.func.as_ref() }
+        }
+
+        pub(crate) fn func_ref(&self) -> &VMFuncRef {
+            if let Some(f) = self.func_ref {
+                // Safety invariants are upheld by the `RootedHostFunc::new` caller.
+                unsafe { f.as_ref() }
+            } else {
+                self.func().func_ref()
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::Store;
+
+    #[test]
+    fn hash_key_is_stable_across_duplicate_store_data_entries() -> Result<()> {
+        let mut store = Store::<()>::default();
+        let module = Module::new(
+            store.engine(),
+            r#"
+                (module
+                    (func (export "f")
+                        nop
+                    )
+                )
+            "#,
+        )?;
+        let instance = Instance::new(&mut store, &module, &[])?;
+
+        // Each time we `get_func`, we call `Func::from_wasmtime` which adds a
+        // new entry to `StoreData`, so `f1` and `f2` will have different
+        // indices into `StoreData`.
+        let f1 = instance.get_func(&mut store, "f").unwrap();
+        let f2 = instance.get_func(&mut store, "f").unwrap();
+
+        // But their hash keys are the same.
+        assert!(
+            f1.hash_key(&mut store.as_context_mut().0)
+                == f2.hash_key(&mut store.as_context_mut().0)
+        );
+
+        // But the hash keys are different from different funcs.
+        let instance2 = Instance::new(&mut store, &module, &[])?;
+        let f3 = instance2.get_func(&mut store, "f").unwrap();
+        assert!(
+            f1.hash_key(&mut store.as_context_mut().0)
+                != f3.hash_key(&mut store.as_context_mut().0)
+        );
+
+        Ok(())
+    }
+}
diff --git a/crates/wasmtime/src/runtime/func/typed.rs b/crates/wasmtime/src/runtime/func/typed.rs
new file mode 100644
index 000000000000..f021909ae7bc
--- /dev/null
+++ b/crates/wasmtime/src/runtime/func/typed.rs
@@ -0,0 +1,788 @@
+use super::invoke_wasm_and_catch_traps;
+use crate::prelude::*;
+use crate::runtime::vm::{VMFuncRef, VMOpaqueContext};
+use crate::store::{AutoAssertNoGc, StoreOpaque};
+use crate::{
+    AsContext, AsContextMut, Engine, Func, FuncType, HeapType, NoFunc, RefType, StoreContextMut,
+    ValRaw, ValType,
+};
+use core::ffi::c_void;
+use core::marker;
+use core::mem::{self, MaybeUninit};
+use core::num::NonZeroUsize;
+use core::ptr::{self};
+use wasmtime_environ::VMSharedTypeIndex;
+
+/// A statically typed WebAssembly function.
+///
+/// Values of this type represent statically type-checked WebAssembly functions.
+/// The function within a [`TypedFunc`] is statically known to have `Params` as its
+/// parameters and `Results` as its results.
+///
+/// This structure is created via [`Func::typed`] or [`TypedFunc::new_unchecked`].
+/// For more documentation about this see those methods.
+pub struct TypedFunc<Params, Results> {
+    _a: marker::PhantomData<fn(Params) -> Results>,
+    ty: FuncType,
+    func: Func,
+}
+
+impl<Params, Results> Clone for TypedFunc<Params, Results> {
+    fn clone(&self) -> TypedFunc<Params, Results> {
+        Self {
+            _a: marker::PhantomData,
+            ty: self.ty.clone(),
+            func: self.func,
+        }
+    }
+}
+
+impl<Params, Results> TypedFunc<Params, Results>
+where
+    Params: WasmParams,
+    Results: WasmResults,
+{
+    /// An unchecked version of [`Func::typed`] which does not perform a
+    /// typecheck and simply assumes that the type declared here matches the
+    /// type of this function.
+    ///
+    /// The semantics of this function are the same as [`Func::typed`] except
+    /// that no error is returned because no typechecking is done.
+    ///
+    /// # Unsafety
+    ///
+    /// This function only safe to call if `typed` would otherwise return `Ok`
+    /// for the same `Params` and `Results` specified. If `typed` would return
+    /// an error then the returned `TypedFunc` is memory unsafe to invoke.
+    pub unsafe fn new_unchecked(store: impl AsContext, func: Func) -> TypedFunc<Params, Results> {
+        let store = store.as_context().0;
+        Self::_new_unchecked(store, func)
+    }
+
+    pub(crate) unsafe fn _new_unchecked(
+        store: &StoreOpaque,
+        func: Func,
+    ) -> TypedFunc<Params, Results> {
+        let ty = func.load_ty(store);
+        TypedFunc {
+            _a: marker::PhantomData,
+            ty,
+            func,
+        }
+    }
+
+    /// Returns the underlying [`Func`] that this is wrapping, losing the static
+    /// type information in the process.
+    pub fn func(&self) -> &Func {
+        &self.func
+    }
+
+    /// Invokes this WebAssembly function with the specified parameters.
+    ///
+    /// Returns either the results of the call, or a [`Trap`] if one happened.
+    ///
+    /// For more information, see the [`Func::typed`] and [`Func::call`]
+    /// documentation.
+    ///
+    /// # Errors
+    ///
+    /// For more information on errors see the documentation on [`Func::call`].
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if it is called when the underlying [`Func`] is
+    /// connected to an asynchronous store.
+    ///
+    /// [`Trap`]: crate::Trap
+    pub fn call(&self, mut store: impl AsContextMut, params: Params) -> Result<Results> {
+        let mut store = store.as_context_mut();
+        assert!(
+            !store.0.async_support(),
+            "must use `call_async` with async stores"
+        );
+        if Self::need_gc_before_call_raw(store.0, &params) {
+            store.0.gc();
+        }
+        let func = self.func.vm_func_ref(store.0);
+        unsafe { Self::call_raw(&mut store, &self.ty, func, params) }
+    }
+
+    /// Invokes this WebAssembly function with the specified parameters.
+    ///
+    /// Returns either the results of the call, or a [`Trap`] if one happened.
+    ///
+    /// For more information, see the [`Func::typed`] and [`Func::call_async`]
+    /// documentation.
+    ///
+    /// # Errors
+    ///
+    /// For more information on errors see the documentation on [`Func::call`].
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if it is called when the underlying [`Func`] is
+    /// connected to a synchronous store.
+    ///
+    /// [`Trap`]: crate::Trap
+    #[cfg(feature = "async")]
+    pub async fn call_async<T>(
+        &self,
+        mut store: impl AsContextMut<Data = T>,
+        params: Params,
+    ) -> Result<Results>
+    where
+        T: Send,
+    {
+        let mut store = store.as_context_mut();
+        assert!(
+            store.0.async_support(),
+            "must use `call` with non-async stores"
+        );
+        if Self::need_gc_before_call_raw(store.0, &params) {
+            store.0.gc_async().await;
+        }
+        store
+            .on_fiber(|store| {
+                let func = self.func.vm_func_ref(store.0);
+                unsafe { Self::call_raw(store, &self.ty, func, params) }
+            })
+            .await?
+    }
+
+    #[inline]
+    pub(crate) fn need_gc_before_call_raw(_store: &StoreOpaque, _params: &Params) -> bool {
+        #[cfg(feature = "gc")]
+        {
+            // See the comment in `Func::call_impl_check_args`.
+            let num_gc_refs = _params.vmgcref_pointing_to_object_count();
+            if let Some(num_gc_refs) = NonZeroUsize::new(num_gc_refs) {
+                return _store
+                    .unwrap_gc_store()
+                    .gc_heap
+                    .need_gc_before_entering_wasm(num_gc_refs);
+            }
+        }
+
+        false
+    }
+
+    /// Do a raw call of a typed function.
+    ///
+    /// # Safety
+    ///
+    /// `func` must be of the given type.
+    ///
+    /// If `Self::need_gc_before_call_raw`, then the caller must have done a GC
+    /// just before calling this method.
+    pub(crate) unsafe fn call_raw<T>(
+        store: &mut StoreContextMut<'_, T>,
+        ty: &FuncType,
+        func: ptr::NonNull<VMFuncRef>,
+        params: Params,
+    ) -> Result<Results> {
+        // double-check that params/results match for this function's type in
+        // debug mode.
+        if cfg!(debug_assertions) {
+            Self::debug_typecheck(store.0, func.as_ref().type_index);
+        }
+
+        // Validate that all runtime values flowing into this store indeed
+        // belong within this store, otherwise it would be unsafe for store
+        // values to cross each other.
+
+        union Storage<T: Copy, U: Copy> {
+            params: MaybeUninit<T>,
+            results: U,
+        }
+
+        let mut storage = Storage::<Params::ValRawStorage, Results::ValRawStorage> {
+            params: MaybeUninit::uninit(),
+        };
+
+        {
+            let mut store = AutoAssertNoGc::new(store.0);
+            params.store(&mut store, ty, &mut storage.params)?;
+        }
+
+        // Try to capture only a single variable (a tuple) in the closure below.
+        // This means the size of the closure is one pointer and is much more
+        // efficient to move in memory. This closure is actually invoked on the
+        // other side of a C++ shim, so it can never be inlined enough to make
+        // the memory go away, so the size matters here for performance.
+        let mut captures = (func, storage);
+
+        let result = invoke_wasm_and_catch_traps(store, |caller| {
+            let (func_ref, storage) = &mut captures;
+            let func_ref = func_ref.as_ref();
+            (func_ref.array_call)(
+                func_ref.vmctx,
+                VMOpaqueContext::from_vmcontext(caller),
+                (storage as *mut Storage<_, _>) as *mut ValRaw,
+                mem::size_of_val::<Storage<_, _>>(storage) / mem::size_of::<ValRaw>(),
+            );
+        });
+
+        let (_, storage) = captures;
+        result?;
+
+        let mut store = AutoAssertNoGc::new(store.0);
+        Ok(Results::load(&mut store, &storage.results))
+    }
+
+    /// Purely a debug-mode assertion, not actually used in release builds.
+    fn debug_typecheck(store: &StoreOpaque, func: VMSharedTypeIndex) {
+        let ty = FuncType::from_shared_type_index(store.engine(), func);
+        Params::typecheck(store.engine(), ty.params(), TypeCheckPosition::Param)
+            .expect("params should match");
+        Results::typecheck(store.engine(), ty.results(), TypeCheckPosition::Result)
+            .expect("results should match");
+    }
+}
+
+#[doc(hidden)]
+#[derive(Copy, Clone)]
+pub enum TypeCheckPosition {
+    Param,
+    Result,
+}
+
+/// A trait implemented for types which can be arguments and results for
+/// closures passed to [`Func::wrap`] as well as parameters to [`Func::typed`].
+///
+/// This trait should not be implemented by user types. This trait may change at
+/// any time internally. The types which implement this trait, however, are
+/// stable over time.
+///
+/// For more information see [`Func::wrap`] and [`Func::typed`]
+pub unsafe trait WasmTy: Send {
+    // Do a "static" (aka at time of `func.typed::<P, R>()`) ahead-of-time type
+    // check for this type at the given position. You probably don't need to
+    // override this trait method.
+    #[doc(hidden)]
+    #[inline]
+    fn typecheck(engine: &Engine, actual: ValType, position: TypeCheckPosition) -> Result<()> {
+        let expected = Self::valtype();
+        debug_assert!(expected.comes_from_same_engine(engine));
+        debug_assert!(actual.comes_from_same_engine(engine));
+        match position {
+            // The caller is expecting to receive a `T` and the callee is
+            // actually returning a `U`, so ensure that `U <: T`.
+            TypeCheckPosition::Result => actual.ensure_matches(engine, &expected),
+            // The caller is expecting to pass a `T` and the callee is expecting
+            // to receive a `U`, so ensure that `T <: U`.
+            TypeCheckPosition::Param => match (expected.as_ref(), actual.as_ref()) {
+                // ... except that this technically-correct check would overly
+                // restrict the usefulness of our typed function APIs for the
+                // specific case of concrete reference types. Let's work through
+                // an example.
+                //
+                // Consider functions that take a `(ref param $some_func_type)`
+                // parameter:
+                //
+                // * We cannot have a static `wasmtime::SomeFuncTypeRef` type
+                //   that implements `WasmTy` specifically for `(ref null
+                //   $some_func_type)` because Wasm modules, and their types,
+                //   are loaded dynamically at runtime.
+                //
+                // * Therefore the embedder's only option for `T <: (ref null
+                //   $some_func_type)` is `T = (ref null nofunc)` aka
+                //   `Option<wasmtime::NoFunc>`.
+                //
+                // * But that static type means they can *only* pass in the null
+                //   function reference as an argument to the typed function.
+                //   This is way too restrictive! For ergonomics, we want them
+                //   to be able to pass in a `wasmtime::Func` whose type is
+                //   `$some_func_type`!
+                //
+                // To lift this constraint and enable better ergonomics for
+                // embedders, we allow `top(T) <: top(U)` -- i.e. they are part
+                // of the same type hierarchy and a dynamic cast could possibly
+                // succeed -- for the specific case of concrete heap type
+                // parameters, and fall back to dynamic type checks on the
+                // arguments passed to each invocation, as necessary.
+                (Some(expected_ref), Some(actual_ref)) if actual_ref.heap_type().is_concrete() => {
+                    expected_ref
+                        .heap_type()
+                        .top()
+                        .ensure_matches(engine, &actual_ref.heap_type().top())
+                }
+                _ => expected.ensure_matches(engine, &actual),
+            },
+        }
+    }
+
+    // The value type that this Type represents.
+    #[doc(hidden)]
+    fn valtype() -> ValType;
+
+    #[doc(hidden)]
+    fn may_gc() -> bool {
+        match Self::valtype() {
+            ValType::Ref(_) => true,
+            ValType::I32 | ValType::I64 | ValType::F32 | ValType::F64 | ValType::V128 => false,
+        }
+    }
+
+    // Dynamic checks that this value is being used with the correct store
+    // context.
+    #[doc(hidden)]
+    fn compatible_with_store(&self, store: &StoreOpaque) -> bool;
+
+    // Dynamic checks that `self <: actual` for concrete type arguments. See the
+    // comment above in `WasmTy::typecheck`.
+    //
+    // Only ever called for concrete reference type arguments, so any type which
+    // is not in a type hierarchy with concrete reference types can implement
+    // this with `unreachable!()`.
+    #[doc(hidden)]
+    fn dynamic_concrete_type_check(
+        &self,
+        store: &StoreOpaque,
+        nullable: bool,
+        actual: &HeapType,
+    ) -> Result<()>;
+
+    // Is this a GC-managed reference that actually points to a GC object? That
+    // is, `self` is *not* an `i31`, null reference, or uninhabited type.
+    //
+    // Note that it is okay if this returns false positives (i.e. `true` for
+    // `Rooted<AnyRef>` without actually looking up the rooted `anyref` in the
+    // store and reflecting on it to determine whether it is actually an
+    // `i31`). However, it is not okay if this returns false negatives.
+    #[doc(hidden)]
+    #[inline]
+    fn is_vmgcref_and_points_to_object(&self) -> bool {
+        Self::valtype().is_vmgcref_type_and_points_to_object()
+    }
+
+    // Store `self` into `ptr`.
+    //
+    // NB: We _must not_ trigger a GC when passing refs from host code into Wasm
+    // (e.g. returned from a host function or passed as arguments to a Wasm
+    // function). After insertion into the activations table, the reference is
+    // no longer rooted. If multiple references are being sent from the host
+    // into Wasm and we allowed GCs during insertion, then the following events
+    // could happen:
+    //
+    // * Reference A is inserted into the activations table. This does not
+    //   trigger a GC, but does fill the table to capacity.
+    //
+    // * The caller's reference to A is removed. Now the only reference to A is
+    //   from the activations table.
+    //
+    // * Reference B is inserted into the activations table. Because the table
+    //   is at capacity, a GC is triggered.
+    //
+    // * A is reclaimed because the only reference keeping it alive was the
+    //   activation table's reference (it isn't inside any Wasm frames on the
+    //   stack yet, so stack scanning and stack maps don't increment its
+    //   reference count).
+    //
+    // * We transfer control to Wasm, giving it A and B. Wasm uses A. That's a
+    //   use-after-free bug.
+    //
+    // In conclusion, to prevent uses-after-free bugs, we cannot GC while
+    // converting types into their raw ABI forms.
+    #[doc(hidden)]
+    fn store(self, store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()>;
+
+    // Load a version of `Self` from the `ptr` provided.
+    //
+    // # Safety
+    //
+    // This function is unsafe as it's up to the caller to ensure that `ptr` is
+    // valid for this given type.
+    #[doc(hidden)]
+    unsafe fn load(store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self;
+}
+
+macro_rules! integers {
+    ($($primitive:ident/$get_primitive:ident => $ty:ident)*) => ($(
+        unsafe impl WasmTy for $primitive {
+            #[inline]
+            fn valtype() -> ValType {
+                ValType::$ty
+            }
+            #[inline]
+            fn compatible_with_store(&self, _: &StoreOpaque) -> bool {
+                true
+            }
+            #[inline]
+            fn dynamic_concrete_type_check(&self, _: &StoreOpaque, _: bool, _: &HeapType) -> Result<()> {
+                unreachable!()
+            }
+            #[inline]
+            fn store(self, _store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
+                ptr.write(ValRaw::$primitive(self));
+                Ok(())
+            }
+            #[inline]
+            unsafe fn load(_store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self {
+                ptr.$get_primitive()
+            }
+        }
+    )*)
+}
+
+integers! {
+    i32/get_i32 => I32
+    i64/get_i64 => I64
+    u32/get_u32 => I32
+    u64/get_u64 => I64
+}
+
+macro_rules! floats {
+    ($($float:ident/$int:ident/$get_float:ident => $ty:ident)*) => ($(
+        unsafe impl WasmTy for $float {
+            #[inline]
+            fn valtype() -> ValType {
+                ValType::$ty
+            }
+            #[inline]
+            fn compatible_with_store(&self, _: &StoreOpaque) -> bool {
+                true
+            }
+            #[inline]
+            fn dynamic_concrete_type_check(&self, _: &StoreOpaque, _: bool, _: &HeapType) -> Result<()> {
+                unreachable!()
+            }
+            #[inline]
+            fn store(self, _store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
+                ptr.write(ValRaw::$float(self.to_bits()));
+                Ok(())
+            }
+            #[inline]
+            unsafe fn load(_store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self {
+                $float::from_bits(ptr.$get_float())
+            }
+        }
+    )*)
+}
+
+floats! {
+    f32/u32/get_f32 => F32
+    f64/u64/get_f64 => F64
+}
+
+unsafe impl WasmTy for NoFunc {
+    #[inline]
+    fn valtype() -> ValType {
+        ValType::Ref(RefType::new(false, HeapType::NoFunc))
+    }
+
+    #[inline]
+    fn compatible_with_store(&self, _store: &StoreOpaque) -> bool {
+        match self._inner {}
+    }
+
+    #[inline]
+    fn dynamic_concrete_type_check(&self, _: &StoreOpaque, _: bool, _: &HeapType) -> Result<()> {
+        match self._inner {}
+    }
+
+    #[inline]
+    fn is_vmgcref_and_points_to_object(&self) -> bool {
+        match self._inner {}
+    }
+
+    #[inline]
+    fn store(self, _store: &mut AutoAssertNoGc<'_>, _ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
+        match self._inner {}
+    }
+
+    #[inline]
+    unsafe fn load(_store: &mut AutoAssertNoGc<'_>, _ptr: &ValRaw) -> Self {
+        unreachable!("NoFunc is uninhabited")
+    }
+}
+
+unsafe impl WasmTy for Option<NoFunc> {
+    #[inline]
+    fn valtype() -> ValType {
+        ValType::Ref(RefType::new(true, HeapType::NoFunc))
+    }
+
+    #[inline]
+    fn compatible_with_store(&self, _store: &StoreOpaque) -> bool {
+        true
+    }
+
+    #[inline]
+    fn dynamic_concrete_type_check(
+        &self,
+        _: &StoreOpaque,
+        nullable: bool,
+        ty: &HeapType,
+    ) -> Result<()> {
+        if nullable {
+            // `(ref null nofunc) <: (ref null $f)` for all function types `$f`.
+            Ok(())
+        } else {
+            bail!("argument type mismatch: expected non-nullable (ref {ty}), found null reference")
+        }
+    }
+
+    #[inline]
+    fn store(self, _store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
+        ptr.write(ValRaw::funcref(ptr::null_mut()));
+        Ok(())
+    }
+
+    #[inline]
+    unsafe fn load(_store: &mut AutoAssertNoGc<'_>, _ptr: &ValRaw) -> Self {
+        None
+    }
+}
+
+unsafe impl WasmTy for Func {
+    #[inline]
+    fn valtype() -> ValType {
+        ValType::Ref(RefType::new(false, HeapType::Func))
+    }
+
+    #[inline]
+    fn compatible_with_store(&self, store: &StoreOpaque) -> bool {
+        store.store_data().contains(self.0)
+    }
+
+    #[inline]
+    fn dynamic_concrete_type_check(
+        &self,
+        store: &StoreOpaque,
+        _nullable: bool,
+        expected: &HeapType,
+    ) -> Result<()> {
+        let expected = expected.unwrap_concrete_func();
+        self.ensure_matches_ty(store, expected)
+            .context("argument type mismatch for reference to concrete type")
+    }
+
+    #[inline]
+    fn store(self, store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
+        let abi = self.vm_func_ref(store);
+        ptr.write(ValRaw::funcref(abi.cast::<c_void>().as_ptr()));
+        Ok(())
+    }
+
+    #[inline]
+    unsafe fn load(store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self {
+        let p = ptr.get_funcref();
+        debug_assert!(!p.is_null());
+        Func::from_vm_func_ref(store, p.cast()).unwrap()
+    }
+}
+
+unsafe impl WasmTy for Option<Func> {
+    #[inline]
+    fn valtype() -> ValType {
+        ValType::FUNCREF
+    }
+
+    #[inline]
+    fn compatible_with_store(&self, store: &StoreOpaque) -> bool {
+        if let Some(f) = self {
+            store.store_data().contains(f.0)
+        } else {
+            true
+        }
+    }
+
+    fn dynamic_concrete_type_check(
+        &self,
+        store: &StoreOpaque,
+        nullable: bool,
+        expected: &HeapType,
+    ) -> Result<()> {
+        if let Some(f) = self {
+            let expected = expected.unwrap_concrete_func();
+            f.ensure_matches_ty(store, expected)
+                .context("argument type mismatch for reference to concrete type")
+        } else if nullable {
+            Ok(())
+        } else {
+            bail!("argument type mismatch: expected non-nullable (ref {expected}), found null reference")
+        }
+    }
+
+    #[inline]
+    fn store(self, store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
+        let raw = if let Some(f) = self {
+            f.vm_func_ref(store).as_ptr()
+        } else {
+            ptr::null_mut()
+        };
+        ptr.write(ValRaw::funcref(raw.cast::<c_void>()));
+        Ok(())
+    }
+
+    #[inline]
+    unsafe fn load(store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self {
+        Func::from_vm_func_ref(store, ptr.get_funcref().cast())
+    }
+}
+
+/// A trait used for [`Func::typed`] and with [`TypedFunc`] to represent the set of
+/// parameters for wasm functions.
+///
+/// This is implemented for bare types that can be passed to wasm as well as
+/// tuples of those types.
+pub unsafe trait WasmParams: Send {
+    #[doc(hidden)]
+    type ValRawStorage: Copy;
+
+    #[doc(hidden)]
+    fn typecheck(
+        engine: &Engine,
+        params: impl ExactSizeIterator<Item = crate::ValType>,
+        position: TypeCheckPosition,
+    ) -> Result<()>;
+
+    #[doc(hidden)]
+    fn vmgcref_pointing_to_object_count(&self) -> usize;
+
+    #[doc(hidden)]
+    fn store(
+        self,
+        store: &mut AutoAssertNoGc<'_>,
+        func_ty: &FuncType,
+        dst: &mut MaybeUninit<Self::ValRawStorage>,
+    ) -> Result<()>;
+}
+
+// Forward an impl from `T` to `(T,)` for convenience if there's only one
+// parameter.
+unsafe impl<T> WasmParams for T
+where
+    T: WasmTy,
+{
+    type ValRawStorage = <(T,) as WasmParams>::ValRawStorage;
+
+    fn typecheck(
+        engine: &Engine,
+        params: impl ExactSizeIterator<Item = crate::ValType>,
+        position: TypeCheckPosition,
+    ) -> Result<()> {
+        <(T,) as WasmParams>::typecheck(engine, params, position)
+    }
+
+    #[inline]
+    fn vmgcref_pointing_to_object_count(&self) -> usize {
+        T::is_vmgcref_and_points_to_object(self) as usize
+    }
+
+    #[inline]
+    fn store(
+        self,
+        store: &mut AutoAssertNoGc<'_>,
+        func_ty: &FuncType,
+        dst: &mut MaybeUninit<Self::ValRawStorage>,
+    ) -> Result<()> {
+        <(T,) as WasmParams>::store((self,), store, func_ty, dst)
+    }
+}
+
+macro_rules! impl_wasm_params {
+    ($n:tt $($t:ident)*) => {
+        #[allow(non_snake_case)]
+        unsafe impl<$($t: WasmTy,)*> WasmParams for ($($t,)*) {
+            type ValRawStorage = [ValRaw; $n];
+
+            fn typecheck(
+                _engine: &Engine,
+                mut params: impl ExactSizeIterator<Item = crate::ValType>,
+                _position: TypeCheckPosition,
+            ) -> Result<()> {
+                let mut _n = 0;
+
+                $(
+                    match params.next() {
+                        Some(t) => {
+                            _n += 1;
+                            $t::typecheck(_engine, t, _position)?
+                        },
+                        None => bail!("expected {} types, found {}", $n, params.len() + _n),
+                    }
+                )*
+
+                match params.next() {
+                    None => Ok(()),
+                    Some(_) => {
+                        _n += 1;
+                        bail!("expected {} types, found {}", $n, params.len() + _n)
+                    },
+                }
+            }
+
+            #[inline]
+            fn vmgcref_pointing_to_object_count(&self) -> usize {
+                let ($(ref $t,)*) = self;
+                0 $(
+                    + $t.is_vmgcref_and_points_to_object() as usize
+                )*
+            }
+
+
+            #[inline]
+            fn store(
+                self,
+                _store: &mut AutoAssertNoGc<'_>,
+                _func_ty: &FuncType,
+                _ptr: &mut MaybeUninit<Self::ValRawStorage>,
+            ) -> Result<()> {
+                let ($($t,)*) = self;
+
+                let mut _i = 0;
+                $(
+                    if !$t.compatible_with_store(_store) {
+                        bail!("attempt to pass cross-`Store` value to Wasm as function argument");
+                    }
+
+                    if $t::valtype().is_ref() {
+                        let param_ty = _func_ty.param(_i).unwrap();
+                        let ref_ty = param_ty.unwrap_ref();
+                        let heap_ty = ref_ty.heap_type();
+                        if heap_ty.is_concrete() {
+                            $t.dynamic_concrete_type_check(_store, ref_ty.is_nullable(), heap_ty)?;
+                        }
+                    }
+
+                    let dst = map_maybe_uninit!(_ptr[_i]);
+                    $t.store(_store, dst)?;
+
+                    _i += 1;
+                )*
+                Ok(())
+            }
+        }
+    };
+}
+
+for_each_function_signature!(impl_wasm_params);
+
+/// A trait used for [`Func::typed`] and with [`TypedFunc`] to represent the set of
+/// results for wasm functions.
+pub unsafe trait WasmResults: WasmParams {
+    #[doc(hidden)]
+    unsafe fn load(store: &mut AutoAssertNoGc<'_>, abi: &Self::ValRawStorage) -> Self;
+}
+
+// Forwards from a bare type `T` to the 1-tuple type `(T,)`
+unsafe impl<T: WasmTy> WasmResults for T {
+    unsafe fn load(store: &mut AutoAssertNoGc<'_>, abi: &Self::ValRawStorage) -> Self {
+        <(T,) as WasmResults>::load(store, abi).0
+    }
+}
+
+macro_rules! impl_wasm_results {
+    ($n:tt $($t:ident)*) => {
+        #[allow(non_snake_case, unused_variables)]
+        unsafe impl<$($t: WasmTy,)*> WasmResults for ($($t,)*) {
+            unsafe fn load(store: &mut AutoAssertNoGc<'_>, abi: &Self::ValRawStorage) -> Self {
+                let [$($t,)*] = abi;
+                ($($t::load(store, $t),)*)
+            }
+        }
+    };
+}
+
+for_each_function_signature!(impl_wasm_results);
diff --git a/crates/wasmtime/src/runtime/gc.rs b/crates/wasmtime/src/runtime/gc.rs
new file mode 100644
index 000000000000..f6697b1057a0
--- /dev/null
+++ b/crates/wasmtime/src/runtime/gc.rs
@@ -0,0 +1,92 @@
+#[cfg(feature = "gc")]
+mod enabled;
+#[cfg(feature = "gc")]
+pub use enabled::*;
+
+#[cfg(not(feature = "gc"))]
+mod disabled;
+#[cfg(not(feature = "gc"))]
+pub use disabled::*;
+
+mod noextern;
+pub use noextern::NoExtern;
+
+use core::fmt;
+use core::ops::Deref;
+
+/// A common trait implemented by all garbage-collected reference types.
+///
+/// This is a sealed trait, and may not be implemented for any types outside of
+/// the `wasmtime` crate.
+pub trait GcRef: GcRefImpl {}
+
+impl<T> GcRef for T where T: GcRefImpl {}
+
+/// A trait implemented for GC references that are guaranteed to be rooted:
+///
+/// * [`Rooted<T>`][crate::Rooted]
+/// * [`ManuallyRooted<T>`][crate::ManuallyRooted]
+///
+/// You can use this to abstract over the different kinds of rooted GC
+/// references. Note that `Deref<Target = T>` is a supertrait for
+/// `RootedGcRef<T>`, so all rooted GC references deref to their underlying `T`,
+/// allowing you to call its methods.
+///
+/// This is a sealed trait, and may not be implemented for any types outside of
+/// the `wasmtime` crate.
+pub trait RootedGcRef<T>: RootedGcRefImpl<T> + Deref<Target = T>
+where
+    T: GcRef,
+{
+}
+
+impl<T, U> RootedGcRef<T> for U
+where
+    T: GcRef,
+    U: RootedGcRefImpl<T> + Deref<Target = T>,
+{
+}
+
+/// An error returned when attempting to allocate a GC-managed object, but the
+/// GC heap is out of memory.
+///
+/// This error wraps an inner `T` value -- which is the host value, if any, that
+/// was passed to [`ExternRef::new`][crate::ExternRef::new] -- and you can
+/// recover this value via the
+/// [`into_inner`][crate::GcHeapOutOfMemory::into_inner] method. This lets you
+/// try to allocate the `externref` again, after performing a GC to hopefully
+/// free up space in the heap, or otherwise do whatever you want with the inner
+/// value.
+///
+/// For errors that occur when attempting to allocate non-`externref` objects
+/// when the GC heap is at capacity, the `T` type parameter is just the unit
+/// type `()`.
+pub struct GcHeapOutOfMemory<T> {
+    inner: T,
+}
+
+impl<T> fmt::Debug for GcHeapOutOfMemory<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, f)
+    }
+}
+
+impl<T> fmt::Display for GcHeapOutOfMemory<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "GC heap out of memory")
+    }
+}
+
+#[cfg(feature = "std")]
+impl<T> std::error::Error for GcHeapOutOfMemory<T> {}
+
+impl<T> GcHeapOutOfMemory<T> {
+    pub(crate) fn new(inner: T) -> Self {
+        Self { inner }
+    }
+
+    /// Recover this error's inner host value.
+    pub fn into_inner(self) -> T {
+        self.inner
+    }
+}
diff --git a/crates/wasmtime/src/runtime/gc/disabled.rs b/crates/wasmtime/src/runtime/gc/disabled.rs
new file mode 100644
index 000000000000..9b785043e0b9
--- /dev/null
+++ b/crates/wasmtime/src/runtime/gc/disabled.rs
@@ -0,0 +1,23 @@
+//! The dummy implementation of garbage-collection, for when the `gc` Cargo
+//! feature is disabled.
+//!
+//! We provide dummy/uninhabited types so that downstream users (and the rest of
+//! Wasmtime) need to do fewer `#[cfg(...)]`s for when GC is enabled versus
+//! disabled at compile time. While we implement dummy methods for these types'
+//! public methods, we do not, however, create dummy constructors constructors.
+
+#![allow(missing_docs, unreachable_code)]
+
+mod anyref;
+mod arrayref;
+mod externref;
+mod i31;
+mod rooting;
+mod structref;
+
+pub use anyref::*;
+pub use arrayref::*;
+pub use externref::*;
+pub use i31::*;
+pub use rooting::*;
+pub use structref::*;
diff --git a/crates/wasmtime/src/runtime/gc/disabled/anyref.rs b/crates/wasmtime/src/runtime/gc/disabled/anyref.rs
new file mode 100644
index 000000000000..ee62ec4aef45
--- /dev/null
+++ b/crates/wasmtime/src/runtime/gc/disabled/anyref.rs
@@ -0,0 +1,126 @@
+use crate::runtime::vm::VMGcRef;
+use crate::{
+    store::{AutoAssertNoGc, StoreOpaque},
+    ArrayRef, AsContext, AsContextMut, GcRefImpl, HeapType, ManuallyRooted, Result, Rooted,
+    StructRef, I31,
+};
+
+/// Support for `anyref` disabled at compile time because the `gc` cargo feature
+/// was not enabled.
+pub enum AnyRef {}
+
+impl From<Rooted<StructRef>> for Rooted<AnyRef> {
+    #[inline]
+    fn from(s: Rooted<StructRef>) -> Self {
+        match s.inner {}
+    }
+}
+
+impl From<ManuallyRooted<StructRef>> for ManuallyRooted<AnyRef> {
+    #[inline]
+    fn from(s: ManuallyRooted<StructRef>) -> Self {
+        match s.inner {}
+    }
+}
+
+impl From<Rooted<ArrayRef>> for Rooted<AnyRef> {
+    #[inline]
+    fn from(s: Rooted<ArrayRef>) -> Self {
+        match s.inner {}
+    }
+}
+
+impl From<ManuallyRooted<ArrayRef>> for ManuallyRooted<AnyRef> {
+    #[inline]
+    fn from(s: ManuallyRooted<ArrayRef>) -> Self {
+        match s.inner {}
+    }
+}
+
+impl GcRefImpl for AnyRef {}
+
+impl AnyRef {
+    pub(crate) fn from_cloned_gc_ref(
+        _store: &mut AutoAssertNoGc<'_>,
+        _gc_ref: VMGcRef,
+    ) -> Rooted<Self> {
+        unreachable!()
+    }
+
+    pub unsafe fn from_raw(_store: impl AsContextMut, raw: u32) -> Option<Rooted<Self>> {
+        assert_eq!(raw, 0);
+        None
+    }
+
+    pub unsafe fn to_raw(&self, _store: impl AsContextMut) -> Result<u32> {
+        match *self {}
+    }
+
+    pub fn ty(&self, _store: impl AsContext) -> Result<HeapType> {
+        match *self {}
+    }
+
+    pub(crate) fn _ty(&self, _store: &StoreOpaque) -> Result<HeapType> {
+        match *self {}
+    }
+
+    pub fn matches_ty(&self, _store: impl AsContext, _ty: &HeapType) -> Result<bool> {
+        match *self {}
+    }
+
+    pub fn is_i31(&self, _store: impl AsContext) -> Result<bool> {
+        match *self {}
+    }
+
+    pub(crate) fn _is_i31(&self, _store: &StoreOpaque) -> Result<bool> {
+        match *self {}
+    }
+
+    pub fn as_i31(&self, _store: impl AsContext) -> Result<Option<I31>> {
+        match *self {}
+    }
+
+    pub fn unwrap_i31(&self, _store: impl AsContext) -> Result<I31> {
+        match *self {}
+    }
+
+    pub fn is_struct(&self, _store: impl AsContext) -> Result<bool> {
+        match *self {}
+    }
+
+    pub(crate) fn _is_struct(&self, _store: &StoreOpaque) -> Result<bool> {
+        match *self {}
+    }
+
+    pub fn as_struct(&self, _store: impl AsContext) -> Result<Option<StructRef>> {
+        match *self {}
+    }
+
+    pub(crate) fn _as_struct(&self, _store: &StoreOpaque) -> Result<Option<StructRef>> {
+        match *self {}
+    }
+
+    pub fn unwrap_struct(&self, _store: impl AsContext) -> Result<StructRef> {
+        match *self {}
+    }
+
+    pub fn is_array(&self, _store: impl AsContext) -> Result<bool> {
+        match *self {}
+    }
+
+    pub(crate) fn _is_array(&self, _store: &StoreOpaque) -> Result<bool> {
+        match *self {}
+    }
+
+    pub fn as_array(&self, _store: impl AsContext) -> Result<Option<ArrayRef>> {
+        match *self {}
+    }
+
+    pub(crate) fn _as_array(&self, _store: &StoreOpaque) -> Result<Option<ArrayRef>> {
+        match *self {}
+    }
+
+    pub fn unwrap_array(&self, _store: impl AsContext) -> Result<ArrayRef> {
+        match *self {}
+    }
+}
diff --git a/crates/wasmtime/src/runtime/gc/disabled/arrayref.rs b/crates/wasmtime/src/runtime/gc/disabled/arrayref.rs
new file mode 100644
index 000000000000..38ec2da9c0c8
--- /dev/null
+++ b/crates/wasmtime/src/runtime/gc/disabled/arrayref.rs
@@ -0,0 +1,56 @@
+use crate::runtime::vm::VMGcRef;
+use crate::{
+    store::{AutoAssertNoGc, StoreContextMut, StoreOpaque},
+    ArrayType, AsContext, AsContextMut, GcRefImpl, Result, Rooted, Val, I31,
+};
+
+/// Support for `ArrayRefPre` disabled at compile time because the `gc` cargo
+/// feature was not enabled.
+pub enum ArrayRefPre {}
+
+/// Support for `arrayref` disabled at compile time because the `gc` cargo feature
+/// was not enabled.
+pub enum ArrayRef {}
+
+impl GcRefImpl for ArrayRef {}
+
+impl ArrayRef {
+    pub(crate) fn from_cloned_gc_ref(
+        _store: &mut AutoAssertNoGc<'_>,
+        _gc_ref: VMGcRef,
+    ) -> Rooted<Self> {
+        unreachable!()
+    }
+
+    pub fn ty(&self, _store: impl AsContext) -> Result<ArrayType> {
+        match *self {}
+    }
+
+    pub fn matches_ty(&self, _store: impl AsContext, _ty: &ArrayType) -> Result<bool> {
+        match *self {}
+    }
+
+    pub(crate) fn _matches_ty(&self, _store: &StoreOpaque, _ty: &ArrayType) -> Result<bool> {
+        match *self {}
+    }
+
+    pub fn len(&self, _store: impl AsContext) -> Result<u32> {
+        match *self {}
+    }
+
+    pub fn elems<'a, T: 'a>(
+        &self,
+        _store: impl Into<StoreContextMut<'a, T>>,
+    ) -> Result<impl ExactSizeIterator<Item = Val> + 'a> {
+        match *self {}
+        Ok([].into_iter())
+    }
+
+    pub fn get(&self, _store: impl AsContextMut, _index: usize) -> Result<Val> {
+        match *self {}
+    }
+
+    pub fn set(&self, _store: impl AsContextMut, _index: usize, _value: Val) -> Result<()> {
+        match *self {}
+    }
+}
diff --git a/crates/wasmtime/src/runtime/gc/disabled/externref.rs b/crates/wasmtime/src/runtime/gc/disabled/externref.rs
new file mode 100644
index 000000000000..a89babaf57d1
--- /dev/null
+++ b/crates/wasmtime/src/runtime/gc/disabled/externref.rs
@@ -0,0 +1,49 @@
+use crate::runtime::vm::VMGcRef;
+use crate::{
+    store::AutoAssertNoGc, AsContextMut, GcRefImpl, Result, Rooted, StoreContext, StoreContextMut,
+};
+use core::any::Any;
+
+/// Support for `externref` disabled at compile time because the `gc` cargo
+/// feature was not enabled.
+pub enum ExternRef {}
+
+impl GcRefImpl for ExternRef {}
+
+impl ExternRef {
+    pub(crate) fn from_cloned_gc_ref(
+        _store: &mut AutoAssertNoGc<'_>,
+        _gc_ref: VMGcRef,
+    ) -> Rooted<Self> {
+        unreachable!()
+    }
+
+    pub fn data<'a, T>(
+        &self,
+        _store: impl Into<StoreContext<'a, T>>,
+    ) -> Result<&'a (dyn Any + Send + Sync)>
+    where
+        T: 'a,
+    {
+        match *self {}
+    }
+
+    pub fn data_mut<'a, T>(
+        &self,
+        _store: impl Into<StoreContextMut<'a, T>>,
+    ) -> Result<&'a mut (dyn Any + Send + Sync)>
+    where
+        T: 'a,
+    {
+        match *self {}
+    }
+
+    pub unsafe fn from_raw(_store: impl AsContextMut, raw: u32) -> Option<Rooted<Self>> {
+        assert_eq!(raw, 0);
+        None
+    }
+
+    pub unsafe fn to_raw(&self, _store: impl AsContextMut) -> Result<u32> {
+        match *self {}
+    }
+}
diff --git a/crates/wasmtime/src/runtime/gc/disabled/i31.rs b/crates/wasmtime/src/runtime/gc/disabled/i31.rs
new file mode 100644
index 000000000000..f38a2a1ca568
--- /dev/null
+++ b/crates/wasmtime/src/runtime/gc/disabled/i31.rs
@@ -0,0 +1,13 @@
+/// Support for `i31ref` disabled at compile time because the `gc` cargo feature
+/// was not enabled.
+pub enum I31 {}
+
+impl I31 {
+    pub fn get_u32(&self) -> u32 {
+        match *self {}
+    }
+
+    pub fn get_i32(&self) -> i32 {
+        match *self {}
+    }
+}
diff --git a/crates/wasmtime/src/runtime/gc/disabled/rooting.rs b/crates/wasmtime/src/runtime/gc/disabled/rooting.rs
new file mode 100644
index 000000000000..c00d93bbca9b
--- /dev/null
+++ b/crates/wasmtime/src/runtime/gc/disabled/rooting.rs
@@ -0,0 +1,229 @@
+use crate::prelude::*;
+use crate::runtime::vm::{GcStore, VMExternRef, VMGcRef};
+use crate::{
+    runtime::Uninhabited,
+    store::{AutoAssertNoGc, StoreOpaque},
+    AsContext, AsContextMut, GcRef, Result, RootedGcRef,
+};
+use core::any::Any;
+use core::ffi::c_void;
+use core::fmt::{self, Debug};
+use core::hash::{Hash, Hasher};
+use core::marker;
+use core::ops::Deref;
+
+mod sealed {
+    use super::*;
+    pub trait GcRefImpl {}
+    pub trait RootedGcRefImpl<T: GcRef> {
+        fn assert_unreachable<U>(&self) -> U;
+
+        fn get_gc_ref<'a>(&self, _store: &'a StoreOpaque) -> Option<&'a VMGcRef> {
+            self.assert_unreachable()
+        }
+
+        fn try_gc_ref<'a>(&self, _store: &'a StoreOpaque) -> Result<&'a VMGcRef> {
+            self.assert_unreachable()
+        }
+
+        fn clone_gc_ref(&self, _store: &mut AutoAssertNoGc<'_>) -> Option<VMGcRef> {
+            self.assert_unreachable()
+        }
+
+        fn try_clone_gc_ref(&self, _store: &mut AutoAssertNoGc<'_>) -> Result<VMGcRef> {
+            self.assert_unreachable()
+        }
+    }
+}
+pub(crate) use sealed::*;
+
+#[derive(Debug, Default)]
+pub(crate) struct RootSet {}
+
+impl RootSet {
+    pub(crate) fn enter_lifo_scope(&self) -> usize {
+        usize::MAX
+    }
+
+    pub(crate) fn exit_lifo_scope(&mut self, _gc_store: Option<&mut GcStore>, _scope: usize) {}
+
+    pub(crate) fn with_lifo_scope<T>(
+        store: &mut StoreOpaque,
+        f: impl FnOnce(&mut StoreOpaque) -> T,
+    ) -> T {
+        f(store)
+    }
+}
+
+/// This type is disabled because the `gc` cargo feature was not enabled at
+/// compile time.
+pub struct Rooted<T: GcRef> {
+    pub(crate) inner: Uninhabited,
+    _phantom: marker::PhantomData<T>,
+}
+
+impl<T: GcRef> Clone for Rooted<T> {
+    fn clone(&self) -> Self {
+        match self.inner {}
+    }
+}
+
+impl<T: GcRef> Copy for Rooted<T> {}
+
+impl<T: GcRef> Debug for Rooted<T> {
+    fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self.inner {}
+    }
+}
+
+impl<T: GcRef> PartialEq for Rooted<T> {
+    fn eq(&self, _other: &Self) -> bool {
+        match self.inner {}
+    }
+}
+
+impl<T: GcRef> Eq for Rooted<T> {}
+
+impl<T: GcRef> Hash for Rooted<T> {
+    fn hash<H: Hasher>(&self, _state: &mut H) {
+        match self.inner {}
+    }
+}
+
+impl<T: GcRef> RootedGcRefImpl<T> for Rooted<T> {
+    fn assert_unreachable<U>(&self) -> U {
+        match self.inner {}
+    }
+}
+
+impl<T: GcRef> Deref for Rooted<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        match self.inner {}
+    }
+}
+
+impl<T: GcRef> Rooted<T> {
+    pub(crate) fn comes_from_same_store(&self, _store: &StoreOpaque) -> bool {
+        match self.inner {}
+    }
+
+    pub fn to_manually_rooted(&self, _store: impl AsContextMut) -> Result<ManuallyRooted<T>> {
+        match self.inner {}
+    }
+
+    pub fn rooted_eq(a: Self, _b: Self) -> bool {
+        match a.inner {}
+    }
+
+    pub fn ref_eq(
+        _store: impl AsContext,
+        a: &impl RootedGcRef<T>,
+        _b: &impl RootedGcRef<T>,
+    ) -> Result<bool> {
+        a.assert_unreachable()
+    }
+
+    pub(crate) fn unchecked_cast<U: GcRef>(self) -> Rooted<U> {
+        match self.inner {}
+    }
+}
+
+/// This type has been disabled because the `gc` cargo feature was not enabled
+/// at compile time.
+pub struct RootScope<C>
+where
+    C: AsContextMut,
+{
+    inner: Uninhabited,
+    _phantom: marker::PhantomData<C>,
+}
+
+impl<C> RootScope<C>
+where
+    C: AsContextMut,
+{
+    pub fn reserve(&mut self, _additional: usize) {
+        match self.inner {}
+    }
+}
+
+impl<T> AsContext for RootScope<T>
+where
+    T: AsContextMut,
+{
+    type Data = T::Data;
+
+    fn as_context(&self) -> crate::StoreContext<'_, Self::Data> {
+        match self.inner {}
+    }
+}
+
+impl<T> AsContextMut for RootScope<T>
+where
+    T: AsContextMut,
+{
+    fn as_context_mut(&mut self) -> crate::StoreContextMut<'_, Self::Data> {
+        match self.inner {}
+    }
+}
+
+/// This type has been disabled because the `gc` cargo feature was not enabled
+/// at compile time.
+pub struct ManuallyRooted<T>
+where
+    T: GcRef,
+{
+    pub(crate) inner: Uninhabited,
+    _phantom: marker::PhantomData<T>,
+}
+
+impl<T: GcRef> Debug for ManuallyRooted<T> {
+    fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self.inner {}
+    }
+}
+
+impl<T: GcRef> Deref for ManuallyRooted<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        match self.inner {}
+    }
+}
+
+impl<T> ManuallyRooted<T>
+where
+    T: GcRef,
+{
+    pub(crate) fn comes_from_same_store(&self, _store: &StoreOpaque) -> bool {
+        match self.inner {}
+    }
+
+    pub fn clone(&self, _store: impl AsContextMut) -> Self {
+        match self.inner {}
+    }
+
+    pub fn unroot(self, _store: impl AsContextMut) {
+        match self.inner {}
+    }
+
+    pub fn to_rooted(&self, _context: impl AsContextMut) -> Rooted<T> {
+        match self.inner {}
+    }
+
+    pub fn into_rooted(self, _context: impl AsContextMut) -> Rooted<T> {
+        match self.inner {}
+    }
+
+    pub(crate) fn unchecked_cast<U: GcRef>(self) -> ManuallyRooted<U> {
+        match self.inner {}
+    }
+}
+
+impl<T: GcRef> RootedGcRefImpl<T> for ManuallyRooted<T> {
+    fn assert_unreachable<U>(&self) -> U {
+        match self.inner {}
+    }
+}
diff --git a/crates/wasmtime/src/runtime/gc/disabled/structref.rs b/crates/wasmtime/src/runtime/gc/disabled/structref.rs
new file mode 100644
index 000000000000..ba7d2099c64f
--- /dev/null
+++ b/crates/wasmtime/src/runtime/gc/disabled/structref.rs
@@ -0,0 +1,52 @@
+use crate::runtime::vm::VMGcRef;
+use crate::{
+    store::{AutoAssertNoGc, StoreContextMut, StoreOpaque},
+    AsContext, AsContextMut, GcRefImpl, Result, Rooted, StructType, Val, I31,
+};
+
+/// Support for `StructRefPre` disabled at compile time because the `gc` cargo
+/// feature was not enabled.
+pub enum StructRefPre {}
+
+/// Support for `structref` disabled at compile time because the `gc` cargo feature
+/// was not enabled.
+pub enum StructRef {}
+
+impl GcRefImpl for StructRef {}
+
+impl StructRef {
+    pub(crate) fn from_cloned_gc_ref(
+        _store: &mut AutoAssertNoGc<'_>,
+        _gc_ref: VMGcRef,
+    ) -> Rooted<Self> {
+        unreachable!()
+    }
+
+    pub fn ty(&self, _store: impl AsContext) -> Result<StructType> {
+        match *self {}
+    }
+
+    pub fn matches_ty(&self, _store: impl AsContext, _ty: &StructType) -> Result<bool> {
+        match *self {}
+    }
+
+    pub(crate) fn _matches_ty(&self, _store: &StoreOpaque, _ty: &StructType) -> Result<bool> {
+        match *self {}
+    }
+
+    pub fn fields<'a, T: 'a>(
+        &self,
+        _store: impl Into<StoreContextMut<'a, T>>,
+    ) -> Result<impl ExactSizeIterator<Item = Val> + 'a> {
+        match *self {}
+        Ok([].into_iter())
+    }
+
+    pub fn field(&self, _store: impl AsContextMut, _index: usize) -> Result<Val> {
+        match *self {}
+    }
+
+    pub fn set_field(&self, _store: impl AsContextMut, _index: usize, _value: Val) -> Result<()> {
+        match *self {}
+    }
+}
diff --git a/crates/wasmtime/src/runtime/gc/enabled.rs b/crates/wasmtime/src/runtime/gc/enabled.rs
new file mode 100644
index 000000000000..7e1f70ddb48c
--- /dev/null
+++ b/crates/wasmtime/src/runtime/gc/enabled.rs
@@ -0,0 +1,16 @@
+//! The actual implementation of garbage collection, for when the `gc` Cargo
+//! feature is enabled.
+
+mod anyref;
+mod arrayref;
+mod externref;
+mod i31;
+mod rooting;
+mod structref;
+
+pub use anyref::*;
+pub use arrayref::*;
+pub use externref::*;
+pub use i31::*;
+pub use rooting::*;
+pub use structref::*;
diff --git a/crates/wasmtime/src/runtime/gc/enabled/anyref.rs b/crates/wasmtime/src/runtime/gc/enabled/anyref.rs
new file mode 100644
index 000000000000..ffd54b87b27e
--- /dev/null
+++ b/crates/wasmtime/src/runtime/gc/enabled/anyref.rs
@@ -0,0 +1,662 @@
+//! Implementation of `anyref` in Wasmtime.
+
+use crate::prelude::*;
+use crate::runtime::vm::VMGcRef;
+use crate::{
+    store::{AutoAssertNoGc, StoreOpaque},
+    ArrayRef, ArrayType, AsContext, AsContextMut, GcRefImpl, GcRootIndex, HeapType, ManuallyRooted,
+    RefType, Result, Rooted, StructRef, StructType, ValRaw, ValType, WasmTy, I31,
+};
+use core::mem;
+use core::mem::MaybeUninit;
+use wasmtime_environ::VMGcKind;
+
+/// An `anyref` GC reference.
+///
+/// The `AnyRef` type represents WebAssembly `anyref` values. These can be
+/// references to `struct`s and `array`s or inline/unboxed 31-bit
+/// integers. Unlike `externref`, Wasm guests can directly allocate `anyref`s.
+///
+/// Like all WebAssembly references, these are opaque and unforgable to Wasm:
+/// they cannot be faked and Wasm cannot, for example, cast the integer
+/// `0x12345678` into a reference, pretend it is a valid `anyref`, and trick the
+/// host into dereferencing it and segfaulting or worse.
+///
+/// Note that you can also use `Rooted<AnyRef>` and `ManuallyRooted<AnyRef>` as
+/// a type parameter with [`Func::typed`][crate::Func::typed]- and
+/// [`Func::wrap`][crate::Func::wrap]-style APIs.
+///
+/// # Example
+///
+/// ```
+/// # use wasmtime::*;
+/// # fn _foo() -> Result<()> {
+/// let mut config = Config::new();
+/// config.wasm_gc(true);
+///
+/// let engine = Engine::new(&config)?;
+///
+/// // Define a module which does stuff with `anyref`s.
+/// let module = Module::new(&engine, r#"
+///     (module
+///         (func (export "increment-if-i31") (param (ref null any)) (result (ref null any))
+///             block
+///                 ;; Try to cast the arg to an `i31`, otherwise branch out
+///                 ;; of this `block`.
+///                 local.get 0
+///                 br_on_cast_fail (ref null any) (ref i31) 0
+///                 ;; Get the `i31`'s inner value and add one to it.
+///                 i31.get_u
+///                 i32.const 1
+///                 i32.add
+///                 ;; Wrap the incremented value back into an `i31` reference and
+///                 ;; return it.
+///                 ref.i31
+///                 return
+///             end
+///
+///             ;; If the `anyref` we were given is not an `i31`, just return it
+///             ;; as-is.
+///             local.get 0
+///         )
+///     )
+/// "#)?;
+///
+/// // Instantiate the module.
+/// let mut store = Store::new(&engine, ());
+/// let instance = Instance::new(&mut store, &module, &[])?;
+///
+/// // Extract the function.
+/// let increment_if_i31 = instance
+///     .get_typed_func::<Option<Rooted<AnyRef>>, Option<Rooted<AnyRef>>>(
+///         &mut store,
+///         "increment-if-i31",
+///     )?;
+///
+/// {
+///     // Create a new scope for the `Rooted` arguments and returns.
+///     let mut scope = RootScope::new(&mut store);
+///
+///     // Call the function with an `i31`.
+///     let arg = AnyRef::from_i31(&mut scope, I31::wrapping_u32(419));
+///     let result = increment_if_i31.call(&mut scope, Some(arg))?;
+///     assert_eq!(result.unwrap().as_i31(&scope)?, Some(I31::wrapping_u32(420)));
+///
+///     // Call the function with something that isn't an `i31`.
+///     let result = increment_if_i31.call(&mut scope, None)?;
+///     assert!(result.is_none());
+/// }
+/// # Ok(())
+/// # }
+/// ```
+#[derive(Debug)]
+#[repr(transparent)]
+pub struct AnyRef {
+    pub(super) inner: GcRootIndex,
+}
+
+impl From<Rooted<StructRef>> for Rooted<AnyRef> {
+    #[inline]
+    fn from(s: Rooted<StructRef>) -> Self {
+        s.to_anyref()
+    }
+}
+
+impl From<ManuallyRooted<StructRef>> for ManuallyRooted<AnyRef> {
+    #[inline]
+    fn from(s: ManuallyRooted<StructRef>) -> Self {
+        s.to_anyref()
+    }
+}
+
+impl From<Rooted<ArrayRef>> for Rooted<AnyRef> {
+    #[inline]
+    fn from(s: Rooted<ArrayRef>) -> Self {
+        s.to_anyref()
+    }
+}
+
+impl From<ManuallyRooted<ArrayRef>> for ManuallyRooted<AnyRef> {
+    #[inline]
+    fn from(s: ManuallyRooted<ArrayRef>) -> Self {
+        s.to_anyref()
+    }
+}
+
+unsafe impl GcRefImpl for AnyRef {
+    #[allow(private_interfaces)]
+    fn transmute_ref(index: &GcRootIndex) -> &Self {
+        // Safety: `AnyRef` is a newtype of a `GcRootIndex`.
+        let me: &Self = unsafe { mem::transmute(index) };
+
+        // Assert we really are just a newtype of a `GcRootIndex`.
+        assert!(matches!(
+            me,
+            Self {
+                inner: GcRootIndex { .. },
+            }
+        ));
+
+        me
+    }
+}
+
+impl AnyRef {
+    /// Construct an `anyref` from an `i31`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn _foo() -> Result<()> {
+    /// let mut store = Store::<()>::default();
+    ///
+    /// // Create an `i31`.
+    /// let i31 = I31::wrapping_u32(999);
+    ///
+    /// // Convert it into an `anyref`.
+    /// let anyref = AnyRef::from_i31(&mut store, i31);
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn from_i31(mut store: impl AsContextMut, value: I31) -> Rooted<Self> {
+        let mut store = AutoAssertNoGc::new(store.as_context_mut().0);
+        Self::_from_i31(&mut store, value)
+    }
+
+    pub(crate) fn _from_i31(store: &mut AutoAssertNoGc<'_>, value: I31) -> Rooted<Self> {
+        let gc_ref = VMGcRef::from_i31(value.runtime_i31());
+        Rooted::new(store, gc_ref)
+    }
+
+    /// Creates a new strongly-owned [`AnyRef`] from the raw value provided.
+    ///
+    /// This is intended to be used in conjunction with [`Func::new_unchecked`],
+    /// [`Func::call_unchecked`], and [`ValRaw`] with its `anyref` field.
+    ///
+    /// This function assumes that `raw` is an `anyref` value which is currently
+    /// rooted within the [`Store`].
+    ///
+    /// # Unsafety
+    ///
+    /// This function is particularly `unsafe` because `raw` not only must be a
+    /// valid `anyref` value produced prior by [`AnyRef::to_raw`] but it must
+    /// also be correctly rooted within the store. When arguments are provided
+    /// to a callback with [`Func::new_unchecked`], for example, or returned via
+    /// [`Func::call_unchecked`], if a GC is performed within the store then
+    /// floating `anyref` values are not rooted and will be GC'd, meaning that
+    /// this function will no longer be safe to call with the values cleaned up.
+    /// This function must be invoked *before* possible GC operations can happen
+    /// (such as calling Wasm).
+    ///
+    /// When in doubt try to not use this. Instead use the safe Rust APIs of
+    /// [`TypedFunc`] and friends.
+    ///
+    /// [`Func::call_unchecked`]: crate::Func::call_unchecked
+    /// [`Func::new_unchecked`]: crate::Func::new_unchecked
+    /// [`Store`]: crate::Store
+    /// [`TypedFunc`]: crate::TypedFunc
+    /// [`ValRaw`]: crate::ValRaw
+    pub unsafe fn from_raw(mut store: impl AsContextMut, raw: u32) -> Option<Rooted<Self>> {
+        let mut store = AutoAssertNoGc::new(store.as_context_mut().0);
+        Self::_from_raw(&mut store, raw)
+    }
+
+    // (Not actually memory unsafe since we have indexed GC heaps.)
+    pub(crate) fn _from_raw(store: &mut AutoAssertNoGc, raw: u32) -> Option<Rooted<Self>> {
+        let gc_ref = VMGcRef::from_raw_u32(raw)?;
+        Some(Self::from_cloned_gc_ref(store, gc_ref))
+    }
+
+    /// Create a new `Rooted<AnyRef>` from the given GC reference.
+    ///
+    /// `gc_ref` should point to a valid `anyref` and should belong to the
+    /// store's GC heap. Failure to uphold these invariants is memory safe but
+    /// will lead to general incorrectness such as panics or wrong results.
+    pub(crate) fn from_cloned_gc_ref(
+        store: &mut AutoAssertNoGc<'_>,
+        gc_ref: VMGcRef,
+    ) -> Rooted<Self> {
+        debug_assert!(
+            gc_ref.is_i31()
+                || store
+                    .unwrap_gc_store()
+                    .header(&gc_ref)
+                    .kind()
+                    .matches(VMGcKind::AnyRef)
+        );
+        Rooted::new(store, gc_ref)
+    }
+
+    #[inline]
+    pub(crate) fn comes_from_same_store(&self, store: &StoreOpaque) -> bool {
+        self.inner.comes_from_same_store(store)
+    }
+
+    /// Converts this [`AnyRef`] to a raw value suitable to store within a
+    /// [`ValRaw`].
+    ///
+    /// Returns an error if this `anyref` has been unrooted.
+    ///
+    /// # Unsafety
+    ///
+    /// Produces a raw value which is only safe to pass into a store if a GC
+    /// doesn't happen between when the value is produce and when it's passed
+    /// into the store.
+    ///
+    /// [`ValRaw`]: crate::ValRaw
+    pub unsafe fn to_raw(&self, mut store: impl AsContextMut) -> Result<u32> {
+        let mut store = AutoAssertNoGc::new(store.as_context_mut().0);
+        let gc_ref = self.inner.try_clone_gc_ref(&mut store)?;
+        let raw = gc_ref.as_raw_u32();
+        store.gc_store_mut()?.expose_gc_ref_to_wasm(gc_ref);
+        Ok(raw)
+    }
+
+    /// Get the type of this reference.
+    ///
+    /// # Errors
+    ///
+    /// Return an error if this reference has been unrooted.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this reference is associated with a different store.
+    pub fn ty(&self, store: impl AsContext) -> Result<HeapType> {
+        self._ty(store.as_context().0)
+    }
+
+    pub(crate) fn _ty(&self, store: &StoreOpaque) -> Result<HeapType> {
+        let gc_ref = self.inner.try_gc_ref(store)?;
+        if gc_ref.is_i31() {
+            return Ok(HeapType::I31);
+        }
+
+        let header = store.gc_store()?.header(gc_ref);
+
+        if header.kind().matches(VMGcKind::StructRef) {
+            return Ok(HeapType::ConcreteStruct(
+                StructType::from_shared_type_index(store.engine(), header.ty().unwrap()),
+            ));
+        }
+
+        if header.kind().matches(VMGcKind::ArrayRef) {
+            return Ok(HeapType::ConcreteArray(ArrayType::from_shared_type_index(
+                store.engine(),
+                header.ty().unwrap(),
+            )));
+        }
+
+        unreachable!("no other kinds of `anyref`s")
+    }
+
+    /// Does this `anyref` match the given type?
+    ///
+    /// That is, is this object's type a subtype of the given type?
+    ///
+    /// # Errors
+    ///
+    /// Return an error if this reference has been unrooted.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this reference is associated with a different store.
+    pub fn matches_ty(&self, store: impl AsContext, ty: &HeapType) -> Result<bool> {
+        self._matches_ty(store.as_context().0, ty)
+    }
+
+    pub(crate) fn _matches_ty(&self, store: &StoreOpaque, ty: &HeapType) -> Result<bool> {
+        assert!(self.comes_from_same_store(store));
+        Ok(self._ty(store)?.matches(ty))
+    }
+
+    pub(crate) fn ensure_matches_ty(&self, store: &StoreOpaque, ty: &HeapType) -> Result<()> {
+        if !self.comes_from_same_store(store) {
+            bail!("function used with wrong store");
+        }
+        if self._matches_ty(store, ty)? {
+            Ok(())
+        } else {
+            let actual_ty = self._ty(store)?;
+            bail!("type mismatch: expected `(ref {ty})`, found `(ref {actual_ty})`")
+        }
+    }
+
+    /// Is this `anyref` an `i31`?
+    ///
+    /// # Errors
+    ///
+    /// Return an error if this reference has been unrooted.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this reference is associated with a different store.
+    pub fn is_i31(&self, store: impl AsContext) -> Result<bool> {
+        self._is_i31(store.as_context().0)
+    }
+
+    pub(crate) fn _is_i31(&self, store: &StoreOpaque) -> Result<bool> {
+        assert!(self.comes_from_same_store(store));
+        let gc_ref = self.inner.try_gc_ref(store)?;
+        Ok(gc_ref.is_i31())
+    }
+
+    /// Downcast this `anyref` to an `i31`.
+    ///
+    /// If this `anyref` is an `i31`, then `Some(_)` is returned.
+    ///
+    /// If this `anyref` is not an `i31`, then `None` is returned.
+    ///
+    /// # Errors
+    ///
+    /// Return an error if this reference has been unrooted.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this reference is associated with a different store.
+    pub fn as_i31(&self, store: impl AsContext) -> Result<Option<I31>> {
+        self._as_i31(store.as_context().0)
+    }
+
+    pub(crate) fn _as_i31(&self, store: &StoreOpaque) -> Result<Option<I31>> {
+        assert!(self.comes_from_same_store(store));
+        let gc_ref = self.inner.try_gc_ref(store)?;
+        Ok(gc_ref.as_i31().map(Into::into))
+    }
+
+    /// Downcast this `anyref` to an `i31`, panicking if this `anyref` is not an
+    /// `i31`.
+    ///
+    /// # Errors
+    ///
+    /// Return an error if this reference has been unrooted.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this reference is associated with a different store, or if
+    /// this `anyref` is not an `i31`.
+    pub fn unwrap_i31(&self, store: impl AsContext) -> Result<I31> {
+        Ok(self.as_i31(store)?.expect("AnyRef::unwrap_i31 on non-i31"))
+    }
+
+    /// Is this `anyref` a `structref`?
+    ///
+    /// # Errors
+    ///
+    /// Return an error if this reference has been unrooted.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this reference is associated with a different store.
+    pub fn is_struct(&self, store: impl AsContext) -> Result<bool> {
+        self._is_struct(store.as_context().0)
+    }
+
+    pub(crate) fn _is_struct(&self, store: &StoreOpaque) -> Result<bool> {
+        let gc_ref = self.inner.try_gc_ref(store)?;
+        Ok(!gc_ref.is_i31() && store.gc_store()?.kind(gc_ref).matches(VMGcKind::StructRef))
+    }
+
+    /// Downcast this `anyref` to a `structref`.
+    ///
+    /// If this `anyref` is a `structref`, then `Some(_)` is returned.
+    ///
+    /// If this `anyref` is not a `structref`, then `None` is returned.
+    ///
+    /// # Errors
+    ///
+    /// Return an error if this reference has been unrooted.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this reference is associated with a different store.
+    pub fn as_struct(&self, store: impl AsContext) -> Result<Option<Rooted<StructRef>>> {
+        self._as_struct(store.as_context().0)
+    }
+
+    pub(crate) fn _as_struct(&self, store: &StoreOpaque) -> Result<Option<Rooted<StructRef>>> {
+        if self._is_struct(store)? {
+            Ok(Some(Rooted::from_gc_root_index(self.inner)))
+        } else {
+            Ok(None)
+        }
+    }
+
+    /// Downcast this `anyref` to a `structref`, panicking if this `anyref` is
+    /// not a `structref`.
+    ///
+    /// # Errors
+    ///
+    /// Return an error if this reference has been unrooted.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this reference is associated with a different store, or if
+    /// this `anyref` is not a `struct`.
+    pub fn unwrap_struct(&self, store: impl AsContext) -> Result<Rooted<StructRef>> {
+        self._unwrap_struct(store.as_context().0)
+    }
+
+    pub(crate) fn _unwrap_struct(&self, store: &StoreOpaque) -> Result<Rooted<StructRef>> {
+        Ok(self
+            ._as_struct(store)?
+            .expect("AnyRef::unwrap_struct on non-structref"))
+    }
+
+    /// Is this `anyref` an `arrayref`?
+    ///
+    /// # Errors
+    ///
+    /// Return an error if this reference has been unrooted.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this reference is associated with a different store.
+    pub fn is_array(&self, store: impl AsContext) -> Result<bool> {
+        self._is_array(store.as_context().0)
+    }
+
+    pub(crate) fn _is_array(&self, store: &StoreOpaque) -> Result<bool> {
+        let gc_ref = self.inner.try_gc_ref(store)?;
+        Ok(!gc_ref.is_i31() && store.gc_store()?.kind(gc_ref).matches(VMGcKind::ArrayRef))
+    }
+
+    /// Downcast this `anyref` to an `arrayref`.
+    ///
+    /// If this `anyref` is an `arrayref`, then `Some(_)` is returned.
+    ///
+    /// If this `anyref` is not an `arrayref`, then `None` is returned.
+    ///
+    /// # Errors
+    ///
+    /// Return an error if this reference has been unrooted.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this reference is associated with a different store.
+    pub fn as_array(&self, store: impl AsContext) -> Result<Option<Rooted<ArrayRef>>> {
+        self._as_array(store.as_context().0)
+    }
+
+    pub(crate) fn _as_array(&self, store: &StoreOpaque) -> Result<Option<Rooted<ArrayRef>>> {
+        if self._is_array(store)? {
+            Ok(Some(Rooted::from_gc_root_index(self.inner)))
+        } else {
+            Ok(None)
+        }
+    }
+
+    /// Downcast this `anyref` to an `arrayref`, panicking if this `anyref` is
+    /// not an `arrayref`.
+    ///
+    /// # Errors
+    ///
+    /// Return an error if this reference has been unrooted.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this reference is associated with a different store, or if
+    /// this `anyref` is not an `array`.
+    pub fn unwrap_array(&self, store: impl AsContext) -> Result<Rooted<ArrayRef>> {
+        self._unwrap_array(store.as_context().0)
+    }
+
+    pub(crate) fn _unwrap_array(&self, store: &StoreOpaque) -> Result<Rooted<ArrayRef>> {
+        Ok(self
+            ._as_array(store)?
+            .expect("AnyRef::unwrap_array on non-arrayref"))
+    }
+}
+
+unsafe impl WasmTy for Rooted<AnyRef> {
+    #[inline]
+    fn valtype() -> ValType {
+        ValType::Ref(RefType::new(false, HeapType::Any))
+    }
+
+    #[inline]
+    fn compatible_with_store(&self, store: &StoreOpaque) -> bool {
+        self.comes_from_same_store(store)
+    }
+
+    #[inline]
+    fn dynamic_concrete_type_check(
+        &self,
+        store: &StoreOpaque,
+        _nullable: bool,
+        ty: &HeapType,
+    ) -> Result<()> {
+        self.ensure_matches_ty(store, ty)
+    }
+
+    fn store(self, store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
+        self.wasm_ty_store(store, ptr, ValRaw::anyref)
+    }
+
+    unsafe fn load(store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self {
+        Self::wasm_ty_load(store, ptr.get_anyref(), AnyRef::from_cloned_gc_ref)
+    }
+}
+
+unsafe impl WasmTy for Option<Rooted<AnyRef>> {
+    #[inline]
+    fn valtype() -> ValType {
+        ValType::ANYREF
+    }
+
+    #[inline]
+    fn compatible_with_store(&self, store: &StoreOpaque) -> bool {
+        self.map_or(true, |x| x.comes_from_same_store(store))
+    }
+
+    #[inline]
+    fn dynamic_concrete_type_check(
+        &self,
+        store: &StoreOpaque,
+        nullable: bool,
+        ty: &HeapType,
+    ) -> Result<()> {
+        match self {
+            Some(a) => a.ensure_matches_ty(store, ty),
+            None => {
+                ensure!(
+                    nullable,
+                    "expected a non-null reference, but found a null reference"
+                );
+                Ok(())
+            }
+        }
+    }
+
+    #[inline]
+    fn is_vmgcref_and_points_to_object(&self) -> bool {
+        self.is_some()
+    }
+
+    fn store(self, store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
+        <Rooted<AnyRef>>::wasm_ty_option_store(self, store, ptr, ValRaw::anyref)
+    }
+
+    unsafe fn load(store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self {
+        <Rooted<AnyRef>>::wasm_ty_option_load(store, ptr.get_anyref(), AnyRef::from_cloned_gc_ref)
+    }
+}
+
+unsafe impl WasmTy for ManuallyRooted<AnyRef> {
+    #[inline]
+    fn valtype() -> ValType {
+        ValType::Ref(RefType::new(false, HeapType::Any))
+    }
+
+    #[inline]
+    fn compatible_with_store(&self, store: &StoreOpaque) -> bool {
+        self.comes_from_same_store(store)
+    }
+
+    #[inline]
+    fn dynamic_concrete_type_check(
+        &self,
+        store: &StoreOpaque,
+        _nullable: bool,
+        ty: &HeapType,
+    ) -> Result<()> {
+        self.ensure_matches_ty(store, ty)
+    }
+
+    fn store(self, store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
+        self.wasm_ty_store(store, ptr, ValRaw::anyref)
+    }
+
+    unsafe fn load(store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self {
+        Self::wasm_ty_load(store, ptr.get_anyref(), AnyRef::from_cloned_gc_ref)
+    }
+}
+
+unsafe impl WasmTy for Option<ManuallyRooted<AnyRef>> {
+    #[inline]
+    fn valtype() -> ValType {
+        ValType::ANYREF
+    }
+
+    #[inline]
+    fn compatible_with_store(&self, store: &StoreOpaque) -> bool {
+        self.as_ref()
+            .map_or(true, |x| x.comes_from_same_store(store))
+    }
+
+    #[inline]
+    fn dynamic_concrete_type_check(
+        &self,
+        store: &StoreOpaque,
+        nullable: bool,
+        ty: &HeapType,
+    ) -> Result<()> {
+        match self {
+            Some(a) => a.ensure_matches_ty(store, ty),
+            None => {
+                ensure!(
+                    nullable,
+                    "expected a non-null reference, but found a null reference"
+                );
+                Ok(())
+            }
+        }
+    }
+
+    #[inline]
+    fn is_vmgcref_and_points_to_object(&self) -> bool {
+        self.is_some()
+    }
+
+    fn store(self, store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
+        <ManuallyRooted<AnyRef>>::wasm_ty_option_store(self, store, ptr, ValRaw::anyref)
+    }
+
+    unsafe fn load(store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self {
+        <ManuallyRooted<AnyRef>>::wasm_ty_option_load(
+            store,
+            ptr.get_anyref(),
+            AnyRef::from_cloned_gc_ref,
+        )
+    }
+}
diff --git a/crates/wasmtime/src/runtime/gc/enabled/arrayref.rs b/crates/wasmtime/src/runtime/gc/enabled/arrayref.rs
new file mode 100644
index 000000000000..dae784bace86
--- /dev/null
+++ b/crates/wasmtime/src/runtime/gc/enabled/arrayref.rs
@@ -0,0 +1,879 @@
+//! Working with GC `array` objects.
+
+use crate::runtime::vm::VMGcRef;
+use crate::store::StoreId;
+use crate::vm::{GcArrayLayout, GcLayout, VMArrayRef, VMGcHeader};
+use crate::{
+    prelude::*,
+    store::{AutoAssertNoGc, StoreContextMut, StoreOpaque},
+    ArrayType, AsContext, AsContextMut, GcHeapOutOfMemory, GcRefImpl, GcRootIndex, HeapType,
+    ManuallyRooted, RefType, Rooted, Val, ValRaw, ValType, WasmTy,
+};
+use crate::{AnyRef, FieldType};
+use core::mem::{self, MaybeUninit};
+use wasmtime_environ::{VMGcKind, VMSharedTypeIndex};
+
+/// An allocator for a particular Wasm GC array type.
+///
+/// Every `ArrayRefPre` is associated with a particular [`Store`][crate::Store]
+/// and a particular [`ArrayType`][crate::ArrayType].
+///
+/// Reusing an allocator across many allocations amortizes some per-type runtime
+/// overheads inside Wasmtime. An `ArrayRefPre` is to `ArrayRef`s as an
+/// `InstancePre` is to `Instance`s.
+///
+/// # Example
+///
+/// ```
+/// use wasmtime::*;
+///
+/// # fn foo() -> Result<()> {
+/// let mut config = Config::new();
+/// config.wasm_function_references(true);
+/// config.wasm_gc(true);
+///
+/// let engine = Engine::new(&config)?;
+/// let mut store = Store::new(&engine, ());
+///
+/// // Define an array type.
+/// let array_ty = ArrayType::new(
+///    store.engine(),
+///    FieldType::new(Mutability::Var, ValType::I32.into()),
+/// );
+///
+/// // Create an allocator for the array type.
+/// let allocator = ArrayRefPre::new(&mut store, array_ty);
+///
+/// {
+///     let mut scope = RootScope::new(&mut store);
+///
+///     // Allocate a bunch of instances of our array type using the same
+///     // allocator! This is faster than creating a new allocator for each
+///     // instance we want to allocate.
+///     for i in 0..10 {
+///         let len = 42;
+///         let elem = Val::I32(36);
+///         ArrayRef::new(&mut scope, &allocator, &elem, len)?;
+///     }
+/// }
+/// # Ok(())
+/// # }
+/// # foo().unwrap();
+/// ```
+pub struct ArrayRefPre {
+    store_id: StoreId,
+    ty: ArrayType,
+}
+
+impl ArrayRefPre {
+    /// Create a new `ArrayRefPre` that is associated with the given store
+    /// and type.
+    pub fn new(mut store: impl AsContextMut, ty: ArrayType) -> Self {
+        Self::_new(store.as_context_mut().0, ty)
+    }
+
+    pub(crate) fn _new(store: &mut StoreOpaque, ty: ArrayType) -> Self {
+        store.insert_gc_host_alloc_type(ty.registered_type().clone());
+        let store_id = store.id();
+        ArrayRefPre { store_id, ty }
+    }
+
+    pub(crate) fn layout(&self) -> &GcArrayLayout {
+        self.ty
+            .registered_type()
+            .layout()
+            .expect("array types have a layout")
+            .unwrap_array()
+    }
+
+    pub(crate) fn type_index(&self) -> VMSharedTypeIndex {
+        self.ty.registered_type().index()
+    }
+}
+
+/// A reference to a GC-managed `array` instance.
+///
+/// WebAssembly `array`s are a sequence of elements of some homogeneous
+/// type. The elements length is determined at allocation time — two instances
+/// of the same array type may have different lengths — but, once allocated, an
+/// array's length can never be resized. An array's elements are mutable or
+/// constant, depending on the array's type. This determines whether any array
+/// element can be assigned a new value or not. Each element is either an
+/// unpacked [`Val`][crate::Val] or a packed 8-/16-bit integer. Array elements
+/// are dynamically accessed via indexing; out-of-bounds accesses result in
+/// traps.
+///
+/// Like all WebAssembly references, these are opaque and unforgeable to Wasm:
+/// they cannot be faked and Wasm cannot, for example, cast the integer
+/// `0x12345678` into a reference, pretend it is a valid `arrayref`, and trick
+/// the host into dereferencing it and segfaulting or worse.
+///
+/// Note that you can also use `Rooted<ArrayRef>` and `ManuallyRooted<ArrayRef>`
+/// as a type parameter with [`Func::typed`][crate::Func::typed]- and
+/// [`Func::wrap`][crate::Func::wrap]-style APIs.
+///
+/// # Example
+///
+/// ```
+/// use wasmtime::*;
+///
+/// # fn foo() -> Result<()> {
+/// let mut config = Config::new();
+/// config.wasm_function_references(true);
+/// config.wasm_gc(true);
+///
+/// let engine = Engine::new(&config)?;
+/// let mut store = Store::new(&engine, ());
+///
+/// // Define the type for an array of `i32`s.
+/// let array_ty = ArrayType::new(
+///    store.engine(),
+///    FieldType::new(Mutability::Var, ValType::I32.into()),
+/// );
+///
+/// // Create an allocator for the array type.
+/// let allocator = ArrayRefPre::new(&mut store, array_ty);
+///
+/// {
+///     let mut scope = RootScope::new(&mut store);
+///
+///     // Allocate an instance of the array type.
+///     let len = 36;
+///     let elem = Val::I32(42);
+///     let my_array = match ArrayRef::new(&mut scope, &allocator, &elem, len) {
+///         Ok(s) => s,
+///
+///         // If the heap is out of memory, then do a GC to free up some space
+///         // and try again.
+///         Err(e) if e.is::<GcHeapOutOfMemory<()>>() => {
+///             // Do a GC! Note: in an async context, you'd want to do
+///             // `scope.as_context_mut().gc_async().await`.
+///             scope.as_context_mut().gc();
+///
+///             // Try again. If the GC heap is still out of memory, then we
+///             // weren't able to free up resources for this allocation, so
+///             // propagate the error.
+///             ArrayRef::new(&mut scope, &allocator, &elem, len)?
+///         }
+///
+///         // Propagate any other kind of error.
+///         Err(e) => return Err(e),
+///     };
+///
+///     // That instance's elements should have the initial value.
+///     for i in 0..len {
+///         let val = my_array.get(&mut scope, i)?.unwrap_i32();
+///         assert_eq!(val, 42);
+///     }
+///
+///     // We can set an element to a new value because the type was defined with
+///     // mutable elements (as opposed to const).
+///     my_array.set(&mut scope, 3, Val::I32(1234))?;
+///     let new_val = my_array.get(&mut scope, 3)?.unwrap_i32();
+///     assert_eq!(new_val, 1234);
+/// }
+/// # Ok(())
+/// # }
+/// # foo().unwrap();
+/// ```
+#[derive(Debug)]
+#[repr(transparent)]
+pub struct ArrayRef {
+    pub(super) inner: GcRootIndex,
+}
+
+unsafe impl GcRefImpl for ArrayRef {
+    #[allow(private_interfaces)]
+    fn transmute_ref(index: &GcRootIndex) -> &Self {
+        // Safety: `ArrayRef` is a newtype of a `GcRootIndex`.
+        let me: &Self = unsafe { mem::transmute(index) };
+
+        // Assert we really are just a newtype of a `GcRootIndex`.
+        assert!(matches!(
+            me,
+            Self {
+                inner: GcRootIndex { .. },
+            }
+        ));
+
+        me
+    }
+}
+
+impl Rooted<ArrayRef> {
+    /// Upcast this `arrayref` into an `anyref`.
+    #[inline]
+    pub fn to_anyref(self) -> Rooted<AnyRef> {
+        self.unchecked_cast()
+    }
+}
+
+impl ManuallyRooted<ArrayRef> {
+    /// Upcast this `arrayref` into an `anyref`.
+    #[inline]
+    pub fn to_anyref(self) -> ManuallyRooted<AnyRef> {
+        self.unchecked_cast()
+    }
+}
+
+impl ArrayRef {
+    /// Allocate a new `array` of the given length, with every element
+    /// initialized to `elem`.
+    ///
+    /// For example, `ArrayRef::new(ctx, pre, &Val::I64(9), 3)` allocates the
+    /// array `[9, 9, 9]`.
+    ///
+    /// This is similar to the `array.new` instruction.
+    ///
+    /// # Errors
+    ///
+    /// If the given `elem` value's type does not match the `allocator`'s array
+    /// type's element type, an error is returned.
+    ///
+    /// If the allocation cannot be satisfied because the GC heap is currently
+    /// out of memory, but performing a garbage collection might free up space
+    /// such that retrying the allocation afterwards might succeed, then a
+    /// [`GcHeapOutOfMemory<()>`][crate::GcHeapOutOfMemory] error is returned.
+    ///
+    /// # Panics
+    ///
+    /// Panics if either the allocator or the `elem` value is not associated
+    /// with the given store.
+    pub fn new(
+        mut store: impl AsContextMut,
+        allocator: &ArrayRefPre,
+        elem: &Val,
+        len: u32,
+    ) -> Result<Rooted<ArrayRef>> {
+        Self::_new(store.as_context_mut().0, allocator, elem, len)
+    }
+
+    pub(crate) fn _new(
+        store: &mut StoreOpaque,
+        allocator: &ArrayRefPre,
+        elem: &Val,
+        len: u32,
+    ) -> Result<Rooted<ArrayRef>> {
+        assert_eq!(
+            store.id(),
+            allocator.store_id,
+            "attempted to use a `ArrayRefPre` with the wrong store"
+        );
+
+        // Type check the initial element value against the element type.
+        elem.ensure_matches_ty(store, allocator.ty.element_type().unpack())
+            .context("element type mismatch")?;
+
+        return Self::_new_unchecked(store, allocator, RepeatN(elem, len));
+
+        // NB: Can't use `iter::repeat(elem).take(len)` above because that
+        // doesn't implement `ExactSizeIterator`.
+        struct RepeatN<'a>(&'a Val, u32);
+
+        impl<'a> Iterator for RepeatN<'a> {
+            type Item = &'a Val;
+
+            fn next(&mut self) -> Option<Self::Item> {
+                if self.1 == 0 {
+                    None
+                } else {
+                    self.1 -= 1;
+                    Some(self.0)
+                }
+            }
+
+            fn size_hint(&self) -> (usize, Option<usize>) {
+                let len = self.len();
+                (len, Some(len))
+            }
+        }
+
+        impl ExactSizeIterator for RepeatN<'_> {
+            fn len(&self) -> usize {
+                usize::try_from(self.1).unwrap()
+            }
+        }
+    }
+
+    /// Allocate a new array of the given elements, without checking that the
+    /// elements' types match the array's element type.
+    fn _new_unchecked<'a>(
+        store: &mut StoreOpaque,
+        allocator: &ArrayRefPre,
+        elems: impl ExactSizeIterator<Item = &'a Val>,
+    ) -> Result<Rooted<ArrayRef>> {
+        let len = u32::try_from(elems.len()).unwrap();
+
+        // Allocate the array and write each field value into the appropriate
+        // offset.
+        let arrayref = store
+            .gc_store_mut()?
+            .alloc_uninit_array(allocator.type_index(), len, allocator.layout())
+            .err2anyhow()
+            .context("unrecoverable error when allocating new `arrayref`")?
+            .ok_or_else(|| GcHeapOutOfMemory::new(()))
+            .err2anyhow()?;
+
+        // From this point on, if we get any errors, then the array is not
+        // fully initialized, so we need to eagerly deallocate it before the
+        // next GC where the collector might try to interpret one of the
+        // uninitialized fields as a GC reference.
+        let mut store = AutoAssertNoGc::new(store);
+        match (|| {
+            let elem_ty = allocator.ty.element_type();
+            for (i, elem) in elems.enumerate() {
+                let i = u32::try_from(i).unwrap();
+                debug_assert!(i < len);
+                arrayref.initialize_elem(&mut store, allocator.layout(), &elem_ty, i, *elem)?;
+            }
+            Ok(())
+        })() {
+            Ok(()) => Ok(Rooted::new(&mut store, arrayref.into())),
+            Err(e) => {
+                store.gc_store_mut()?.dealloc_uninit_array(arrayref);
+                Err(e)
+            }
+        }
+    }
+
+    /// Allocate a new `array` containing the given elements.
+    ///
+    /// For example, `ArrayRef::new_fixed(ctx, pre, &[Val::I64(4), Val::I64(5),
+    /// Val::I64(6)])` allocates the array `[4, 5, 6]`.
+    ///
+    /// This is similar to the `array.new_fixed` instruction.
+    ///
+    /// # Errors
+    ///
+    /// If any of the `elems` values' type does not match the `allocator`'s
+    /// array type's element type, an error is returned.
+    ///
+    /// If the allocation cannot be satisfied because the GC heap is currently
+    /// out of memory, but performing a garbage collection might free up space
+    /// such that retrying the allocation afterwards might succeed, then a
+    /// [`GcHeapOutOfMemory<()>`][crate::GcHeapOutOfMemory] error is returned.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the allocator or any of the `elems` values are not associated
+    /// with the given store.
+    pub fn new_fixed(
+        mut store: impl AsContextMut,
+        allocator: &ArrayRefPre,
+        elems: &[Val],
+    ) -> Result<Rooted<ArrayRef>> {
+        Self::_new_fixed(store.as_context_mut().0, allocator, elems)
+    }
+
+    pub(crate) fn _new_fixed(
+        store: &mut StoreOpaque,
+        allocator: &ArrayRefPre,
+        elems: &[Val],
+    ) -> Result<Rooted<ArrayRef>> {
+        assert_eq!(
+            store.id(),
+            allocator.store_id,
+            "attempted to use a `ArrayRefPre` with the wrong store"
+        );
+
+        // Type check the elements against the element type.
+        for elem in elems {
+            elem.ensure_matches_ty(store, allocator.ty.element_type().unpack())
+                .context("element type mismatch")?;
+        }
+
+        return Self::_new_unchecked(store, allocator, elems.iter());
+    }
+
+    #[inline]
+    pub(crate) fn comes_from_same_store(&self, store: &StoreOpaque) -> bool {
+        self.inner.comes_from_same_store(store)
+    }
+
+    /// Get this `arrayref`'s type.
+    ///
+    /// # Errors
+    ///
+    /// Return an error if this reference has been unrooted.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this reference is associated with a different store.
+    pub fn ty(&self, store: impl AsContext) -> Result<ArrayType> {
+        self._ty(store.as_context().0)
+    }
+
+    pub(crate) fn _ty(&self, store: &StoreOpaque) -> Result<ArrayType> {
+        assert!(self.comes_from_same_store(store));
+        let index = self.type_index(store)?;
+        Ok(ArrayType::from_shared_type_index(store.engine(), index))
+    }
+
+    /// Does this `arrayref` match the given type?
+    ///
+    /// That is, is this array's type a subtype of the given type?
+    ///
+    /// # Errors
+    ///
+    /// Return an error if this reference has been unrooted.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this reference is associated with a different store or if the
+    /// type is not associated with the store's engine.
+    pub fn matches_ty(&self, store: impl AsContext, ty: &ArrayType) -> Result<bool> {
+        self._matches_ty(store.as_context().0, ty)
+    }
+
+    pub(crate) fn _matches_ty(&self, store: &StoreOpaque, ty: &ArrayType) -> Result<bool> {
+        assert!(self.comes_from_same_store(store));
+        Ok(self._ty(store)?.matches(ty))
+    }
+
+    pub(crate) fn ensure_matches_ty(&self, store: &StoreOpaque, ty: &ArrayType) -> Result<()> {
+        if !self.comes_from_same_store(store) {
+            bail!("function used with wrong store");
+        }
+        if self._matches_ty(store, ty)? {
+            Ok(())
+        } else {
+            let actual_ty = self._ty(store)?;
+            bail!("type mismatch: expected `(ref {ty})`, found `(ref {actual_ty})`")
+        }
+    }
+
+    /// Get the length of this array.
+    ///
+    /// # Errors
+    ///
+    /// Return an error if this reference has been unrooted.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this reference is associated with a different store.
+    pub fn len(&self, store: impl AsContext) -> Result<u32> {
+        self._len(store.as_context().0)
+    }
+
+    pub(crate) fn _len(&self, store: &StoreOpaque) -> Result<u32> {
+        assert!(self.comes_from_same_store(store));
+        let gc_ref = self.inner.try_gc_ref(store)?;
+        debug_assert!({
+            let header = store.gc_store()?.header(gc_ref);
+            header.kind().matches(VMGcKind::ArrayRef)
+        });
+        let arrayref = gc_ref.as_arrayref_unchecked();
+        Ok(arrayref.len(store))
+    }
+
+    /// Get the values of this array's elements.
+    ///
+    /// Note that `i8` and `i16` field values are zero-extended into
+    /// `Val::I32(_)`s.
+    ///
+    /// # Errors
+    ///
+    /// Return an error if this reference has been unrooted.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this reference is associated with a different store.
+    pub fn elems<'a, T: 'a>(
+        &'a self,
+        store: impl Into<StoreContextMut<'a, T>>,
+    ) -> Result<impl ExactSizeIterator<Item = Val> + 'a> {
+        self._elems(store.into().0)
+    }
+
+    pub(crate) fn _elems<'a>(
+        &'a self,
+        store: &'a mut StoreOpaque,
+    ) -> Result<impl ExactSizeIterator<Item = Val> + 'a> {
+        assert!(self.comes_from_same_store(store));
+        let store = AutoAssertNoGc::new(store);
+
+        let gc_ref = self.inner.try_gc_ref(&store)?;
+        let header = store.gc_store()?.header(gc_ref);
+        debug_assert!(header.kind().matches(VMGcKind::ArrayRef));
+
+        let len = self._len(&store)?;
+
+        return Ok(Elems {
+            arrayref: self,
+            store,
+            index: 0,
+            len,
+        });
+
+        struct Elems<'a, 'b> {
+            arrayref: &'a ArrayRef,
+            store: AutoAssertNoGc<'b>,
+            index: u32,
+            len: u32,
+        }
+
+        impl Iterator for Elems<'_, '_> {
+            type Item = Val;
+
+            #[inline]
+            fn next(&mut self) -> Option<Self::Item> {
+                let i = self.index;
+                debug_assert!(i <= self.len);
+                if i >= self.len {
+                    return None;
+                }
+                self.index += 1;
+                Some(self.arrayref._get(&mut self.store, i).unwrap())
+            }
+
+            #[inline]
+            fn size_hint(&self) -> (usize, Option<usize>) {
+                let len = self.len - self.index;
+                let len = usize::try_from(len).unwrap();
+                (len, Some(len))
+            }
+        }
+
+        impl ExactSizeIterator for Elems<'_, '_> {
+            #[inline]
+            fn len(&self) -> usize {
+                let len = self.len - self.index;
+                usize::try_from(len).unwrap()
+            }
+        }
+    }
+
+    fn header<'a>(&self, store: &'a AutoAssertNoGc<'_>) -> Result<&'a VMGcHeader> {
+        assert!(self.comes_from_same_store(&store));
+        let gc_ref = self.inner.try_gc_ref(store)?;
+        Ok(store.gc_store()?.header(gc_ref))
+    }
+
+    fn arrayref<'a>(&self, store: &'a AutoAssertNoGc<'_>) -> Result<&'a VMArrayRef> {
+        assert!(self.comes_from_same_store(&store));
+        let gc_ref = self.inner.try_gc_ref(store)?;
+        debug_assert!(self.header(store)?.kind().matches(VMGcKind::ArrayRef));
+        Ok(gc_ref.as_arrayref_unchecked())
+    }
+
+    fn layout(&self, store: &AutoAssertNoGc<'_>) -> Result<GcArrayLayout> {
+        assert!(self.comes_from_same_store(&store));
+        let type_index = self.type_index(store)?;
+        let layout = store
+            .engine()
+            .signatures()
+            .layout(type_index)
+            .expect("array types should have GC layouts");
+        match layout {
+            GcLayout::Array(a) => Ok(a),
+            GcLayout::Struct(_) => unreachable!(),
+        }
+    }
+
+    fn field_ty(&self, store: &StoreOpaque) -> Result<FieldType> {
+        let ty = self._ty(store)?;
+        Ok(ty.field_type())
+    }
+
+    /// Get this array's `index`th element.
+    ///
+    /// Note that `i8` and `i16` field values are zero-extended into
+    /// `Val::I32(_)`s.
+    ///
+    /// # Errors
+    ///
+    /// Returns an `Err(_)` if the index is out of bounds or this reference has
+    /// been unrooted.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this reference is associated with a different store.
+    pub fn get(&self, mut store: impl AsContextMut, index: u32) -> Result<Val> {
+        let mut store = AutoAssertNoGc::new(store.as_context_mut().0);
+        self._get(&mut store, index)
+    }
+
+    pub(crate) fn _get(&self, store: &mut AutoAssertNoGc<'_>, index: u32) -> Result<Val> {
+        assert!(
+            self.comes_from_same_store(store),
+            "attempted to use an array with the wrong store",
+        );
+        let arrayref = self.arrayref(store)?.unchecked_copy();
+        let field_ty = self.field_ty(store)?;
+        let layout = self.layout(store)?;
+        let len = arrayref.len(store);
+        ensure!(
+            index < len,
+            "index out of bounds: the length is {len} but the index is {index}"
+        );
+        Ok(arrayref.read_elem(store, &layout, field_ty.element_type(), index))
+    }
+
+    /// Set this array's `index`th element.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error in the following scenarios:
+    ///
+    /// * When given a value of the wrong type, such as trying to write an `f32`
+    ///   value into an array of `i64` elements.
+    ///
+    /// * When the array elements are not mutable.
+    ///
+    /// * When `index` is not within the range `0..self.len(ctx)`.
+    ///
+    /// * When `value` is a GC reference that has since been unrooted.
+    ///
+    /// # Panics
+    ///
+    /// Panics if either this reference or the given `value` is associated with
+    /// a different store.
+    pub fn set(&self, mut store: impl AsContextMut, index: u32, value: Val) -> Result<()> {
+        self._set(store.as_context_mut().0, index, value)
+    }
+
+    pub(crate) fn _set(&self, store: &mut StoreOpaque, index: u32, value: Val) -> Result<()> {
+        assert!(
+            self.comes_from_same_store(store),
+            "attempted to use an array with the wrong store",
+        );
+        assert!(
+            value.comes_from_same_store(store),
+            "attempted to use a value with the wrong store",
+        );
+
+        let mut store = AutoAssertNoGc::new(store);
+
+        let field_ty = self.field_ty(&store)?;
+        ensure!(
+            field_ty.mutability().is_var(),
+            "cannot set element {index}: array elements are not mutable"
+        );
+
+        value
+            .ensure_matches_ty(&store, &field_ty.element_type().unpack())
+            .with_context(|| format!("cannot set element {index}: type mismatch"))?;
+
+        let layout = self.layout(&store)?;
+        let arrayref = self.arrayref(&store)?.unchecked_copy();
+
+        let len = arrayref.len(&store);
+        ensure!(
+            index < len,
+            "index out of bounds: the length is {len} but the index is {index}"
+        );
+
+        arrayref.write_elem(&mut store, &layout, field_ty.element_type(), index, value)
+    }
+
+    pub(crate) fn type_index(&self, store: &StoreOpaque) -> Result<VMSharedTypeIndex> {
+        let gc_ref = self.inner.try_gc_ref(store)?;
+        let header = store.gc_store()?.header(gc_ref);
+        debug_assert!(header.kind().matches(VMGcKind::ArrayRef));
+        Ok(header.ty().expect("arrayrefs should have concrete types"))
+    }
+
+    /// Create a new `Rooted<ArrayRef>` from the given GC reference.
+    ///
+    /// `gc_ref` should point to a valid `arrayref` and should belong to the
+    /// store's GC heap. Failure to uphold these invariants is memory safe but
+    /// will lead to general incorrectness such as panics or wrong results.
+    pub(crate) fn from_cloned_gc_ref(
+        store: &mut AutoAssertNoGc<'_>,
+        gc_ref: VMGcRef,
+    ) -> Rooted<Self> {
+        debug_assert!(!gc_ref.is_i31());
+        Rooted::new(store, gc_ref)
+    }
+}
+
+unsafe impl WasmTy for Rooted<ArrayRef> {
+    #[inline]
+    fn valtype() -> ValType {
+        ValType::Ref(RefType::new(false, HeapType::Array))
+    }
+
+    #[inline]
+    fn compatible_with_store(&self, store: &StoreOpaque) -> bool {
+        self.comes_from_same_store(store)
+    }
+
+    #[inline]
+    fn dynamic_concrete_type_check(
+        &self,
+        store: &StoreOpaque,
+        _nullable: bool,
+        ty: &HeapType,
+    ) -> Result<()> {
+        match ty {
+            HeapType::Any | HeapType::Eq | HeapType::Array => Ok(()),
+            HeapType::ConcreteArray(ty) => self.ensure_matches_ty(store, ty),
+
+            HeapType::Extern
+            | HeapType::NoExtern
+            | HeapType::Func
+            | HeapType::ConcreteFunc(_)
+            | HeapType::NoFunc
+            | HeapType::I31
+            | HeapType::Struct
+            | HeapType::ConcreteStruct(_)
+            | HeapType::None => bail!(
+                "type mismatch: expected `(ref {ty})`, got `(ref {})`",
+                self._ty(store)?,
+            ),
+        }
+    }
+
+    fn store(self, store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
+        self.wasm_ty_store(store, ptr, ValRaw::anyref)
+    }
+
+    unsafe fn load(store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self {
+        Self::wasm_ty_load(store, ptr.get_anyref(), ArrayRef::from_cloned_gc_ref)
+    }
+}
+
+unsafe impl WasmTy for Option<Rooted<ArrayRef>> {
+    #[inline]
+    fn valtype() -> ValType {
+        ValType::ARRAYREF
+    }
+
+    #[inline]
+    fn compatible_with_store(&self, store: &StoreOpaque) -> bool {
+        self.map_or(true, |x| x.comes_from_same_store(store))
+    }
+
+    #[inline]
+    fn dynamic_concrete_type_check(
+        &self,
+        store: &StoreOpaque,
+        nullable: bool,
+        ty: &HeapType,
+    ) -> Result<()> {
+        match self {
+            Some(s) => Rooted::<ArrayRef>::dynamic_concrete_type_check(s, store, nullable, ty),
+            None => {
+                ensure!(
+                    nullable,
+                    "expected a non-null reference, but found a null reference"
+                );
+                Ok(())
+            }
+        }
+    }
+
+    #[inline]
+    fn is_vmgcref_and_points_to_object(&self) -> bool {
+        self.is_some()
+    }
+
+    fn store(self, store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
+        <Rooted<ArrayRef>>::wasm_ty_option_store(self, store, ptr, ValRaw::anyref)
+    }
+
+    unsafe fn load(store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self {
+        <Rooted<ArrayRef>>::wasm_ty_option_load(
+            store,
+            ptr.get_anyref(),
+            ArrayRef::from_cloned_gc_ref,
+        )
+    }
+}
+
+unsafe impl WasmTy for ManuallyRooted<ArrayRef> {
+    #[inline]
+    fn valtype() -> ValType {
+        ValType::Ref(RefType::new(false, HeapType::Array))
+    }
+
+    #[inline]
+    fn compatible_with_store(&self, store: &StoreOpaque) -> bool {
+        self.comes_from_same_store(store)
+    }
+
+    #[inline]
+    fn dynamic_concrete_type_check(
+        &self,
+        store: &StoreOpaque,
+        _: bool,
+        ty: &HeapType,
+    ) -> Result<()> {
+        match ty {
+            HeapType::Any | HeapType::Eq | HeapType::Array => Ok(()),
+            HeapType::ConcreteArray(ty) => self.ensure_matches_ty(store, ty),
+
+            HeapType::Extern
+            | HeapType::NoExtern
+            | HeapType::Func
+            | HeapType::ConcreteFunc(_)
+            | HeapType::NoFunc
+            | HeapType::I31
+            | HeapType::Struct
+            | HeapType::ConcreteStruct(_)
+            | HeapType::None => bail!(
+                "type mismatch: expected `(ref {ty})`, got `(ref {})`",
+                self._ty(store)?,
+            ),
+        }
+    }
+
+    fn store(self, store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
+        self.wasm_ty_store(store, ptr, ValRaw::anyref)
+    }
+
+    unsafe fn load(store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self {
+        Self::wasm_ty_load(store, ptr.get_anyref(), ArrayRef::from_cloned_gc_ref)
+    }
+}
+
+unsafe impl WasmTy for Option<ManuallyRooted<ArrayRef>> {
+    #[inline]
+    fn valtype() -> ValType {
+        ValType::ARRAYREF
+    }
+
+    #[inline]
+    fn compatible_with_store(&self, store: &StoreOpaque) -> bool {
+        self.as_ref()
+            .map_or(true, |x| x.comes_from_same_store(store))
+    }
+
+    #[inline]
+    fn dynamic_concrete_type_check(
+        &self,
+        store: &StoreOpaque,
+        nullable: bool,
+        ty: &HeapType,
+    ) -> Result<()> {
+        match self {
+            Some(s) => {
+                ManuallyRooted::<ArrayRef>::dynamic_concrete_type_check(s, store, nullable, ty)
+            }
+            None => {
+                ensure!(
+                    nullable,
+                    "expected a non-null reference, but found a null reference"
+                );
+                Ok(())
+            }
+        }
+    }
+
+    #[inline]
+    fn is_vmgcref_and_points_to_object(&self) -> bool {
+        self.is_some()
+    }
+
+    fn store(self, store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
+        <ManuallyRooted<ArrayRef>>::wasm_ty_option_store(self, store, ptr, ValRaw::anyref)
+    }
+
+    unsafe fn load(store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self {
+        <ManuallyRooted<ArrayRef>>::wasm_ty_option_load(
+            store,
+            ptr.get_anyref(),
+            ArrayRef::from_cloned_gc_ref,
+        )
+    }
+}
diff --git a/crates/wasmtime/src/runtime/gc/enabled/externref.rs b/crates/wasmtime/src/runtime/gc/enabled/externref.rs
new file mode 100644
index 000000000000..1cbdeac0a9c2
--- /dev/null
+++ b/crates/wasmtime/src/runtime/gc/enabled/externref.rs
@@ -0,0 +1,557 @@
+//! Implementation of `externref` in Wasmtime.
+
+use crate::prelude::*;
+use crate::runtime::vm::VMGcRef;
+use crate::{
+    store::{AutoAssertNoGc, StoreOpaque},
+    AsContextMut, GcHeapOutOfMemory, GcRefImpl, GcRootIndex, HeapType, ManuallyRooted, RefType,
+    Result, Rooted, StoreContext, StoreContextMut, ValRaw, ValType, WasmTy,
+};
+use core::any::Any;
+use core::mem;
+use core::mem::MaybeUninit;
+
+/// An opaque, GC-managed reference to some host data that can be passed to
+/// WebAssembly.
+///
+/// The `ExternRef` type represents WebAssembly `externref` values. Wasm can't
+/// do anything with the `externref`s other than put them in tables, globals,
+/// and locals or pass them to other functions (such as imported functions from
+/// the host). Unlike `anyref`s, Wasm guests cannot directly allocate new
+/// `externref`s; only the host can.
+///
+/// You can use `ExternRef` to give access to host objects and control the
+/// operations that Wasm can perform on them via what functions you allow Wasm
+/// to import.
+///
+/// Like all WebAssembly references, these are opaque and unforgeable to Wasm:
+/// they cannot be faked and Wasm cannot, for example, cast the integer
+/// `0x12345678` into a reference, pretend it is a valid `externref`, and trick
+/// the host into dereferencing it and segfaulting or worse.
+///
+/// Note that you can also use `Rooted<ExternRef>` and
+/// `ManuallyRooted<ExternRef>` as a type parameter with
+/// [`Func::typed`][crate::Func::typed]- and
+/// [`Func::wrap`][crate::Func::wrap]-style APIs.
+///
+/// # Example
+///
+/// ```
+/// # use wasmtime::*;
+/// # use std::borrow::Cow;
+/// # fn _foo() -> Result<()> {
+/// let engine = Engine::default();
+/// let mut store = Store::new(&engine, ());
+///
+/// // Define some APIs for working with host strings from Wasm via `externref`.
+/// let mut linker = Linker::new(&engine);
+/// linker.func_wrap(
+///     "host-string",
+///     "new",
+///     |caller: Caller<'_, ()>| -> Result<Rooted<ExternRef>> {
+///         ExternRef::new(caller, Cow::from(""))
+///     },
+/// )?;
+/// linker.func_wrap(
+///     "host-string",
+///     "concat",
+///     |mut caller: Caller<'_, ()>, a: Rooted<ExternRef>, b: Rooted<ExternRef>| -> Result<Rooted<ExternRef>> {
+///         let mut s = a
+///             .data(&caller)?
+///             .downcast_ref::<Cow<str>>()
+///             .ok_or_else(|| Error::msg("externref was not a string"))?
+///             .clone()
+///             .into_owned();
+///         let b = b
+///             .data(&caller)?
+///             .downcast_ref::<Cow<str>>()
+///             .ok_or_else(|| Error::msg("externref was not a string"))?;
+///         s.push_str(&b);
+///         ExternRef::new(&mut caller, s)
+///     },
+/// )?;
+///
+/// // Here is a Wasm module that uses those APIs.
+/// let module = Module::new(
+///     &engine,
+///     r#"
+///         (module
+///             (import "host-string" "concat" (func $concat (param externref externref)
+///                                                          (result externref)))
+///             (func (export "run") (param externref externref) (result externref)
+///                 local.get 0
+///                 local.get 1
+///                 call $concat
+///             )
+///         )
+///     "#,
+/// )?;
+///
+/// // Create a couple `externref`s wrapping `Cow<str>`s.
+/// let hello = ExternRef::new(&mut store, Cow::from("Hello, "))?;
+/// let world = ExternRef::new(&mut store, Cow::from("World!"))?;
+///
+/// // Instantiate the module and pass the `externref`s into it.
+/// let instance = linker.instantiate(&mut store, &module)?;
+/// let result = instance
+///     .get_typed_func::<(Rooted<ExternRef>, Rooted<ExternRef>), Rooted<ExternRef>>(&mut store, "run")?
+///     .call(&mut store, (hello, world))?;
+///
+/// // The module should have concatenated the strings together!
+/// assert_eq!(
+///     result.data(&store)?.downcast_ref::<Cow<str>>().unwrap(),
+///     "Hello, World!"
+/// );
+/// # Ok(())
+/// # }
+/// ```
+#[derive(Debug, Clone)]
+#[repr(transparent)]
+pub struct ExternRef {
+    pub(crate) inner: GcRootIndex,
+}
+
+unsafe impl GcRefImpl for ExternRef {
+    #[allow(private_interfaces)]
+    fn transmute_ref(index: &GcRootIndex) -> &Self {
+        // Safety: `ExternRef` is a newtype of a `GcRootIndex`.
+        let me: &Self = unsafe { mem::transmute(index) };
+
+        // Assert we really are just a newtype of a `GcRootIndex`.
+        assert!(matches!(
+            me,
+            Self {
+                inner: GcRootIndex { .. },
+            }
+        ));
+
+        me
+    }
+}
+
+impl ExternRef {
+    /// Creates a new instance of `ExternRef` wrapping the given value.
+    ///
+    /// The resulting value is automatically unrooted when the given `context`'s
+    /// scope is exited. See [`Rooted<T>`][crate::Rooted]'s documentation for
+    /// more details.
+    ///
+    /// This method will *not* automatically trigger a GC to free up space in
+    /// the GC heap; instead it will return an error. This gives you more
+    /// precise control over when collections happen and allows you to choose
+    /// between performing synchronous and asynchronous collections.
+    ///
+    /// # Errors
+    ///
+    /// If the allocation cannot be satisfied because the GC heap is currently
+    /// out of memory, but performing a garbage collection might free up space
+    /// such that retrying the allocation afterwards might succeed, then a
+    /// `GcHeapOutOfMemory<T>` error is returned.
+    ///
+    /// The `GcHeapOutOfMemory<T>` error contains the host value that the
+    /// `externref` would have wrapped. You can extract that value from this
+    /// error and reuse it when attempting to allocate an `externref` again
+    /// after GC or otherwise do with it whatever you see fit.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn _foo() -> Result<()> {
+    /// let mut store = Store::<()>::default();
+    ///
+    /// {
+    ///     let mut scope = RootScope::new(&mut store);
+    ///
+    ///     // Create an `externref` wrapping a `str`.
+    ///     let externref = match ExternRef::new(&mut scope, "hello!") {
+    ///         Ok(x) => x,
+    ///         // If the heap is out of memory, then do a GC and try again.
+    ///         Err(e) if e.is::<GcHeapOutOfMemory<&'static str>>() => {
+    ///             // Do a GC! Note: in an async context, you'd want to do
+    ///             // `scope.as_context_mut().gc_async().await`.
+    ///             scope.as_context_mut().gc();
+    ///
+    ///             // Extract the original host value from the error.
+    ///             let host_value = e
+    ///                 .downcast::<GcHeapOutOfMemory<&'static str>>()
+    ///                 .unwrap()
+    ///                 .into_inner();
+    ///
+    ///             // Try to allocate the `externref` again, now that the GC
+    ///             // has hopefully freed up some space.
+    ///             ExternRef::new(&mut scope, host_value)?
+    ///         }
+    ///         Err(e) => return Err(e),
+    ///     };
+    ///
+    ///     // Use the `externref`, pass it to Wasm, etc...
+    /// }
+    ///
+    /// // The `externref` is automatically unrooted when we exit the scope.
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn new<T>(mut context: impl AsContextMut, value: T) -> Result<Rooted<ExternRef>>
+    where
+        T: 'static + Any + Send + Sync,
+    {
+        let ctx = context.as_context_mut().0;
+
+        let value: Box<dyn Any + Send + Sync> = Box::new(value);
+        let gc_ref = ctx
+            .gc_store_mut()?
+            .alloc_externref(value)
+            .err2anyhow()
+            .context("unrecoverable error when allocating new `externref`")?
+            .map_err(|x| GcHeapOutOfMemory::<T>::new(*x.downcast().unwrap()))
+            .err2anyhow()
+            .context("failed to allocate `externref`")?;
+
+        let mut ctx = AutoAssertNoGc::new(ctx);
+        Ok(Self::from_cloned_gc_ref(&mut ctx, gc_ref.into()))
+    }
+
+    /// Creates a new, manually-rooted instance of `ExternRef` wrapping the
+    /// given value.
+    ///
+    /// The resulting value must be manually unrooted, or else it will leak for
+    /// the entire duration of the store's lifetime. See
+    /// [`ManuallyRooted<T>`][crate::ManuallyRooted]'s documentation for more
+    /// details.
+    ///
+    /// # Errors
+    ///
+    /// This function returns the same errors in the same scenarios as
+    /// [`ExternRef::new`][crate::ExternRef::new].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn _foo() -> Result<()> {
+    /// let mut store = Store::<()>::default();
+    ///
+    /// // Create a manually-rooted `externref` wrapping a `str`.
+    /// let externref = ExternRef::new_manually_rooted(&mut store, "hello!")?;
+    ///
+    /// // Use `externref` a bunch, pass it to Wasm, etc...
+    ///
+    /// // Don't forget to explicitly unroot the `externref` when you're done
+    /// // using it!
+    /// externref.unroot(&mut store);
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn new_manually_rooted<T>(
+        mut store: impl AsContextMut,
+        value: T,
+    ) -> Result<ManuallyRooted<ExternRef>>
+    where
+        T: 'static + Any + Send + Sync,
+    {
+        let ctx = store.as_context_mut().0;
+
+        let value: Box<dyn Any + Send + Sync> = Box::new(value);
+        let gc_ref = ctx
+            .gc_store_mut()?
+            .alloc_externref(value)
+            .err2anyhow()
+            .context("unrecoverable error when allocating new `externref`")?
+            .map_err(|x| GcHeapOutOfMemory::<T>::new(*x.downcast().unwrap()))
+            .err2anyhow()
+            .context("failed to allocate `externref`")?;
+
+        let mut ctx = AutoAssertNoGc::new(ctx);
+        Ok(ManuallyRooted::new(&mut ctx, gc_ref.into()))
+    }
+
+    /// Create a new `Rooted<ExternRef>` from the given GC reference.
+    ///
+    /// Does not invoke the `GcRuntime`'s clone hook; callers should ensure it
+    /// has been called.
+    ///
+    /// `gc_ref` should be a GC reference pointing to an instance of `externref`
+    /// that is in this store's GC heap. Failure to uphold this invariant is
+    /// memory safe but will result in general incorrectness such as panics and
+    /// wrong results.
+    pub(crate) fn from_cloned_gc_ref(
+        store: &mut AutoAssertNoGc<'_>,
+        gc_ref: VMGcRef,
+    ) -> Rooted<Self> {
+        assert!(
+            gc_ref.is_extern_ref(&*store.unwrap_gc_store().gc_heap),
+            "GC reference {gc_ref:#p} is not an externref"
+        );
+        Rooted::new(store, gc_ref)
+    }
+
+    /// Get a shared borrow of the underlying data for this `ExternRef`.
+    ///
+    /// Returns an error if this `externref` GC reference has been unrooted (eg
+    /// if you attempt to use a `Rooted<ExternRef>` after exiting the scope it
+    /// was rooted within). See the documentation for
+    /// [`Rooted<T>`][crate::Rooted] for more details.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn _foo() -> Result<()> {
+    /// let mut store = Store::<()>::default();
+    ///
+    /// let externref = ExternRef::new(&mut store, "hello")?;
+    ///
+    /// // Access the `externref`'s host data.
+    /// let data = externref.data(&store)?;
+    /// // Dowcast it to a `&str`.
+    /// let data = data.downcast_ref::<&str>().ok_or_else(|| Error::msg("not a str"))?;
+    /// // We should have got the data we created the `externref` with!
+    /// assert_eq!(*data, "hello");
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn data<'a, T>(
+        &self,
+        store: impl Into<StoreContext<'a, T>>,
+    ) -> Result<&'a (dyn Any + Send + Sync)>
+    where
+        T: 'a,
+    {
+        let store = store.into().0;
+        let gc_ref = self.inner.try_gc_ref(&store)?;
+        let externref = gc_ref.as_externref_unchecked();
+        Ok(store.gc_store()?.externref_host_data(externref))
+    }
+
+    /// Get an exclusive borrow of the underlying data for this `ExternRef`.
+    ///
+    /// Returns an error if this `externref` GC reference has been unrooted (eg
+    /// if you attempt to use a `Rooted<ExternRef>` after exiting the scope it
+    /// was rooted within). See the documentation for
+    /// [`Rooted<T>`][crate::Rooted] for more details.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn _foo() -> Result<()> {
+    /// let mut store = Store::<()>::default();
+    ///
+    /// let externref = ExternRef::new::<usize>(&mut store, 0)?;
+    ///
+    /// // Access the `externref`'s host data.
+    /// let data = externref.data_mut(&mut store)?;
+    /// // Dowcast it to a `usize`.
+    /// let data = data.downcast_mut::<usize>().ok_or_else(|| Error::msg("not a usize"))?;
+    /// // We initialized to zero.
+    /// assert_eq!(*data, 0);
+    /// // And we can mutate the value!
+    /// *data += 10;
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn data_mut<'a, T>(
+        &self,
+        store: impl Into<StoreContextMut<'a, T>>,
+    ) -> Result<&'a mut (dyn Any + Send + Sync)>
+    where
+        T: 'a,
+    {
+        let store = store.into().0;
+        // NB: need to do an unchecked copy to release the borrow on the store
+        // so that we can get the store's GC store. But importantly we cannot
+        // trigger a GC while we are working with `gc_ref` here.
+        let gc_ref = self.inner.try_gc_ref(store)?.unchecked_copy();
+        let externref = gc_ref.as_externref_unchecked();
+        Ok(store.gc_store_mut()?.externref_host_data_mut(externref))
+    }
+
+    /// Creates a new strongly-owned [`ExternRef`] from the raw value provided.
+    ///
+    /// This is intended to be used in conjunction with [`Func::new_unchecked`],
+    /// [`Func::call_unchecked`], and [`ValRaw`] with its `externref` field.
+    ///
+    /// This function assumes that `raw` is an externref value which is
+    /// currently rooted within the [`Store`].
+    ///
+    /// # Unsafety
+    ///
+    /// This function is particularly `unsafe` because `raw` not only must be a
+    /// valid externref value produced prior by `to_raw` but it must also be
+    /// correctly rooted within the store. When arguments are provided to a
+    /// callback with [`Func::new_unchecked`], for example, or returned via
+    /// [`Func::call_unchecked`], if a GC is performed within the store then
+    /// floating externref values are not rooted and will be GC'd, meaning that
+    /// this function will no longer be safe to call with the values cleaned up.
+    /// This function must be invoked *before* possible GC operations can happen
+    /// (such as calling wasm).
+    ///
+    /// When in doubt try to not use this. Instead use the safe Rust APIs of
+    /// [`TypedFunc`] and friends.
+    ///
+    /// [`Func::call_unchecked`]: crate::Func::call_unchecked
+    /// [`Func::new_unchecked`]: crate::Func::new_unchecked
+    /// [`Store`]: crate::Store
+    /// [`TypedFunc`]: crate::TypedFunc
+    /// [`ValRaw`]: crate::ValRaw
+    pub unsafe fn from_raw(mut store: impl AsContextMut, raw: u32) -> Option<Rooted<ExternRef>> {
+        let mut store = AutoAssertNoGc::new(store.as_context_mut().0);
+        Self::_from_raw(&mut store, raw)
+    }
+
+    // (Not actually memory unsafe since we have indexed GC heaps.)
+    pub(crate) fn _from_raw(store: &mut AutoAssertNoGc, raw: u32) -> Option<Rooted<ExternRef>> {
+        let gc_ref = VMGcRef::from_raw_u32(raw)?;
+        let gc_ref = store.unwrap_gc_store_mut().clone_gc_ref(&gc_ref);
+        Some(Self::from_cloned_gc_ref(store, gc_ref))
+    }
+
+    /// Converts this [`ExternRef`] to a raw value suitable to store within a
+    /// [`ValRaw`].
+    ///
+    /// Returns an error if this `externref` has been unrooted.
+    ///
+    /// # Unsafety
+    ///
+    /// Produces a raw value which is only safe to pass into a store if a GC
+    /// doesn't happen between when the value is produce and when it's passed
+    /// into the store.
+    ///
+    /// [`ValRaw`]: crate::ValRaw
+    pub unsafe fn to_raw(&self, mut store: impl AsContextMut) -> Result<u32> {
+        let mut store = AutoAssertNoGc::new(store.as_context_mut().0);
+        self._to_raw(&mut store)
+    }
+
+    pub(crate) fn _to_raw(&self, store: &mut AutoAssertNoGc) -> Result<u32> {
+        let gc_ref = self.inner.try_clone_gc_ref(store)?;
+        let raw = gc_ref.as_raw_u32();
+        store.unwrap_gc_store_mut().expose_gc_ref_to_wasm(gc_ref);
+        Ok(raw)
+    }
+}
+
+unsafe impl WasmTy for Rooted<ExternRef> {
+    #[inline]
+    fn valtype() -> ValType {
+        ValType::Ref(RefType::new(false, HeapType::Extern))
+    }
+
+    #[inline]
+    fn compatible_with_store(&self, store: &StoreOpaque) -> bool {
+        self.comes_from_same_store(store)
+    }
+
+    #[inline]
+    fn dynamic_concrete_type_check(&self, _: &StoreOpaque, _: bool, _: &HeapType) -> Result<()> {
+        unreachable!()
+    }
+
+    fn store(self, store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
+        self.wasm_ty_store(store, ptr, ValRaw::externref)
+    }
+
+    unsafe fn load(store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self {
+        Self::wasm_ty_load(store, ptr.get_externref(), ExternRef::from_cloned_gc_ref)
+    }
+}
+
+unsafe impl WasmTy for Option<Rooted<ExternRef>> {
+    #[inline]
+    fn valtype() -> ValType {
+        ValType::EXTERNREF
+    }
+
+    #[inline]
+    fn compatible_with_store(&self, store: &StoreOpaque) -> bool {
+        self.map_or(true, |x| x.comes_from_same_store(store))
+    }
+
+    #[inline]
+    fn dynamic_concrete_type_check(&self, _: &StoreOpaque, _: bool, _: &HeapType) -> Result<()> {
+        unreachable!()
+    }
+
+    #[inline]
+    fn is_vmgcref_and_points_to_object(&self) -> bool {
+        self.is_some()
+    }
+
+    fn store(self, store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
+        <Rooted<ExternRef>>::wasm_ty_option_store(self, store, ptr, ValRaw::externref)
+    }
+
+    unsafe fn load(store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self {
+        <Rooted<ExternRef>>::wasm_ty_option_load(
+            store,
+            ptr.get_externref(),
+            ExternRef::from_cloned_gc_ref,
+        )
+    }
+}
+
+unsafe impl WasmTy for ManuallyRooted<ExternRef> {
+    #[inline]
+    fn valtype() -> ValType {
+        ValType::Ref(RefType::new(false, HeapType::Extern))
+    }
+
+    #[inline]
+    fn compatible_with_store(&self, store: &StoreOpaque) -> bool {
+        self.comes_from_same_store(store)
+    }
+
+    #[inline]
+    fn dynamic_concrete_type_check(&self, _: &StoreOpaque, _: bool, _: &HeapType) -> Result<()> {
+        unreachable!()
+    }
+
+    #[inline]
+    fn is_vmgcref_and_points_to_object(&self) -> bool {
+        true
+    }
+
+    fn store(self, store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
+        self.wasm_ty_store(store, ptr, ValRaw::externref)
+    }
+
+    unsafe fn load(store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self {
+        Self::wasm_ty_load(store, ptr.get_externref(), ExternRef::from_cloned_gc_ref)
+    }
+}
+
+unsafe impl WasmTy for Option<ManuallyRooted<ExternRef>> {
+    #[inline]
+    fn valtype() -> ValType {
+        ValType::EXTERNREF
+    }
+
+    #[inline]
+    fn compatible_with_store(&self, store: &StoreOpaque) -> bool {
+        self.as_ref()
+            .map_or(true, |x| x.comes_from_same_store(store))
+    }
+
+    #[inline]
+    fn dynamic_concrete_type_check(&self, _: &StoreOpaque, _: bool, _: &HeapType) -> Result<()> {
+        unreachable!()
+    }
+
+    #[inline]
+    fn is_vmgcref_and_points_to_object(&self) -> bool {
+        self.is_some()
+    }
+
+    fn store(self, store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
+        <ManuallyRooted<ExternRef>>::wasm_ty_option_store(self, store, ptr, ValRaw::externref)
+    }
+
+    unsafe fn load(store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self {
+        <ManuallyRooted<ExternRef>>::wasm_ty_option_load(
+            store,
+            ptr.get_externref(),
+            ExternRef::from_cloned_gc_ref,
+        )
+    }
+}
diff --git a/crates/wasmtime/src/runtime/gc/enabled/i31.rs b/crates/wasmtime/src/runtime/gc/enabled/i31.rs
new file mode 100644
index 000000000000..6b739513dc07
--- /dev/null
+++ b/crates/wasmtime/src/runtime/gc/enabled/i31.rs
@@ -0,0 +1,291 @@
+//! Unboxed 31-bit integers.
+//!
+//! Note that ideally, we would just re-export `wasmtime_runtime::I31` here, but
+//! in order to get doc comments with example code that shows the use of `I31`
+//! with typed functions and such, we need to wrap it in a newtype.
+
+use crate::runtime::vm::{VMGcRef, ValRaw};
+use crate::{
+    store::{AutoAssertNoGc, StoreOpaque},
+    HeapType, RefType, Result, ValType, WasmTy,
+};
+use core::fmt;
+use core::mem::MaybeUninit;
+
+/// A 31-bit integer.
+///
+/// Represents WebAssembly's `(ref i31)` and `(ref null i31)` (aka `i31ref`)
+/// references.
+///
+/// You can convert this into any of the `(ref i31)` supertypes such as `(ref
+/// eq)` or `(ref any)`, and their nullable equivalents. After conversion, the
+/// resulting reference does not actually point at a GC object in the heap,
+/// instead it is a 31-bit integer that is stored unboxed/inline in the
+/// reference itself.
+///
+/// # Example
+///
+/// ```
+/// # use wasmtime::*;
+/// # fn _foo() -> Result<()> {
+/// // Enable the Wasm GC proposal for Wasm to use i31 references.
+/// let mut config = Config::new();
+/// config.wasm_gc(true);
+///
+/// let engine = Engine::new(&config)?;
+/// let mut store = Store::new(&engine, ());
+///
+/// // A Wasm module that exports a function that increments an i31.
+/// let module = Module::new(&engine, r#"
+///     (module
+///         (func (export "inc_i31") (param (ref i31)) (result (ref i31))
+///             local.get 0
+///             i31.get_u
+///             i32.const 1
+///             i32.add
+///             ref.i31
+///         )
+/// "#)?;
+///
+/// // Instantiate the module.
+/// let instance = Instance::new(&mut store, &module, &[])?;
+///
+/// // Get the exported `inc_i31` function.
+/// let inc_i31 = instance.get_func(&mut store, "inc_i31").unwrap();
+///
+/// // Call the function using the untyped functions API, meaning we need to
+/// // pack our `I31` argument into an `AnyRef` that is packed into a `Val`, and
+/// // then we need to do the opposite unpacking to extract the result.
+/// let i31 = I31::wrapping_u32(0x1234);
+/// let anyref = AnyRef::from_i31(&mut store, i31);
+/// let val = Val::AnyRef(Some(anyref));
+/// let mut results = [Val::null_any_ref()];
+/// inc_i31.call(&mut store, &[val], &mut results)?;
+/// let nullable_anyref = results[0].unwrap_anyref();
+/// let anyref = nullable_anyref.unwrap();
+/// let i31 = anyref.unwrap_i31(&store)?;
+/// assert_eq!(i31.get_u32(), 0x1235);
+///
+/// // Alternatively, we can use the typed function API to make this all a lot
+/// // more ergonomic.
+/// let inc_i31 = inc_i31.typed::<I31, I31>(&mut store)?;
+/// let i31 = I31::wrapping_u32(0x5678);
+/// let result = inc_i31.call(&mut store, i31)?;
+/// assert_eq!(result.get_u32(), 0x5679);
+/// # Ok(())
+/// # }
+/// ```
+#[derive(Clone, Copy, Default, PartialEq, Eq, Hash)]
+pub struct I31(crate::runtime::vm::I31);
+
+impl fmt::Debug for I31 {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("I31")
+            .field("as_u32", &self.get_u32())
+            .field("as_i32", &self.get_i32())
+            .finish()
+    }
+}
+
+impl From<crate::runtime::vm::I31> for I31 {
+    #[inline]
+    fn from(value: crate::runtime::vm::I31) -> Self {
+        Self(value)
+    }
+}
+
+impl From<I31> for crate::runtime::vm::I31 {
+    #[inline]
+    fn from(value: I31) -> Self {
+        value.0
+    }
+}
+
+impl I31 {
+    /// Get this `wasmtime::I31`'s internal `crate::runtime::vm::I31`.
+    pub(crate) fn runtime_i31(self) -> crate::runtime::vm::I31 {
+        self.0
+    }
+
+    /// Construct a new `I31` from the given unsigned value.
+    ///
+    /// Returns `None` if the value does not fit in the bottom 31 bits.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// // This value does not fit into 31 bits.
+    /// assert!(I31::new_u32(0x8000_0000).is_none());
+    ///
+    /// // This value does fit into 31 bits.
+    /// let x = I31::new_u32(5).unwrap();
+    /// assert_eq!(x.get_u32(), 5);
+    /// ```
+    #[inline]
+    pub fn new_u32(value: u32) -> Option<Self> {
+        crate::runtime::vm::I31::new_u32(value).map(Self)
+    }
+
+    /// Construct a new `I31` from the given signed value.
+    ///
+    /// Returns `None` if the value does not fit in the bottom 31 bits.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// // This value does not fit into 31 bits.
+    /// assert!(I31::new_i32(-2147483648).is_none());
+    ///
+    /// // This value does fit into 31 bits.
+    /// let x = I31::new_i32(-5).unwrap();
+    /// assert_eq!(x.get_i32(), -5);
+    /// ```
+    #[inline]
+    pub fn new_i32(value: i32) -> Option<Self> {
+        crate::runtime::vm::I31::new_i32(value).map(Self)
+    }
+
+    /// Construct a new `I31` from the given unsigned value.
+    ///
+    /// If the value doesn't fit in the bottom 31 bits, it is wrapped such that
+    /// the wrapped value does.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// // Values that fit in 31 bits are preserved.
+    /// let x = I31::wrapping_u32(5);
+    /// assert_eq!(x.get_u32(), 5);
+    ///
+    /// // Values that do not fit in 31 bits are wrapped to 31 bits.
+    /// let y = I31::wrapping_u32(0xffff_ffff);
+    /// assert_eq!(y.get_u32(), 0x7fff_ffff);
+    /// ```
+    #[inline]
+    pub fn wrapping_u32(value: u32) -> Self {
+        Self(crate::runtime::vm::I31::wrapping_u32(value))
+    }
+
+    /// Construct a new `I31` from the given signed value.
+    ///
+    /// If the value doesn't fit in the bottom 31 bits, it is wrapped such that
+    /// the wrapped value does.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// // Values that fit in 31 bits are preserved.
+    /// let x = I31::wrapping_i32(-5);
+    /// assert_eq!(x.get_i32(), -5);
+    ///
+    /// // Values that do not fit in 31 bits are wrapped to 31 bits.
+    /// let y = I31::wrapping_i32(-1073741825); // 0xbfffffff
+    /// assert_eq!(y.get_i32(), 1073741823);    // 0x3fffffff
+    /// ```
+    #[inline]
+    pub fn wrapping_i32(value: i32) -> Self {
+        Self(crate::runtime::vm::I31::wrapping_i32(value))
+    }
+
+    /// Get this `I31`'s value as an unsigned integer.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// let x = I31::new_i32(-1).unwrap();
+    /// assert_eq!(x.get_u32(), 0x7fff_ffff);
+    /// ```
+    #[inline]
+    pub fn get_u32(&self) -> u32 {
+        self.0.get_u32()
+    }
+
+    /// Get this `I31`'s value as a signed integer.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// let x = I31::new_u32(0x7fff_ffff).unwrap();
+    /// assert_eq!(x.get_i32(), -1);
+    /// ```
+    #[inline]
+    pub fn get_i32(&self) -> i32 {
+        self.0.get_i32()
+    }
+}
+
+unsafe impl WasmTy for I31 {
+    #[inline]
+    fn valtype() -> ValType {
+        ValType::Ref(RefType::new(false, HeapType::I31))
+    }
+
+    #[inline]
+    fn compatible_with_store(&self, _store: &StoreOpaque) -> bool {
+        true
+    }
+
+    fn dynamic_concrete_type_check(
+        &self,
+        _store: &StoreOpaque,
+        _nullable: bool,
+        _actual: &HeapType,
+    ) -> Result<()> {
+        unreachable!()
+    }
+
+    fn store(self, _store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
+        let gc_ref = VMGcRef::from_i31(self.into()).as_raw_u32();
+        ptr.write(ValRaw::anyref(gc_ref));
+        Ok(())
+    }
+
+    unsafe fn load(_store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self {
+        let raw = ptr.get_anyref();
+        let gc_ref = VMGcRef::from_raw_u32(raw).expect("non-null");
+        gc_ref.unwrap_i31().into()
+    }
+}
+
+unsafe impl WasmTy for Option<I31> {
+    #[inline]
+    fn valtype() -> ValType {
+        ValType::Ref(RefType::new(true, HeapType::I31))
+    }
+
+    #[inline]
+    fn compatible_with_store(&self, _store: &StoreOpaque) -> bool {
+        true
+    }
+
+    fn dynamic_concrete_type_check(
+        &self,
+        _store: &StoreOpaque,
+        _nullable: bool,
+        _actual: &HeapType,
+    ) -> Result<()> {
+        unreachable!()
+    }
+
+    fn store(self, store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
+        match self {
+            Some(i) => i.store(store, ptr),
+            None => {
+                ptr.write(ValRaw::anyref(0));
+                Ok(())
+            }
+        }
+    }
+
+    unsafe fn load(_store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self {
+        let raw = ptr.get_anyref();
+        let gc_ref = VMGcRef::from_raw_u32(raw)?;
+        Some(I31(gc_ref.unwrap_i31()))
+    }
+}
diff --git a/crates/wasmtime/src/runtime/gc/enabled/rooting.rs b/crates/wasmtime/src/runtime/gc/enabled/rooting.rs
new file mode 100644
index 000000000000..bcdee415973f
--- /dev/null
+++ b/crates/wasmtime/src/runtime/gc/enabled/rooting.rs
@@ -0,0 +1,1755 @@
+//! Garbage collection rooting APIs.
+//!
+//! Rooting prevents GC objects from being collected while they are actively
+//! being used.
+//!
+//! ## Goals
+//!
+//! We have a few sometimes-conflicting goals with our GC rooting APIs:
+//!
+//! 1. Safety: It should never be possible to get a use-after-free bug because
+//!    the user misused the rooting APIs, the collector "mistakenly" determined
+//!    an object was unreachable and collected it, and then the user tried to
+//!    access the object. This is our highest priority.
+//!
+//! 2. Moving GC: Our rooting APIs should moving collectors (such as
+//!    generational and compacting collectors) where an object might get
+//!    relocated after a collection and we need to update the GC root's pointer
+//!    to the moved object. This means we either need cooperation and internal
+//!    mutability from individual GC roots as well as the ability to enumerate
+//!    all GC roots on the native Rust stack, or we need a level of indirection.
+//!
+//! 3. Performance: Our rooting APIs should generally be as low-overhead as
+//!    possible. They definitely shouldn't require synchronization and locking
+//!    to create, access, and drop GC roots.
+//!
+//! 4. Ergonomics: Our rooting APIs should be, if not a pleasure, then at least
+//!    not a burden for users. Additionally, the API's types should be `Sync`
+//!    and `Send` so that they work well with async Rust.
+//!
+//! For example, goals (3) and (4) are in conflict when we think about how to
+//! support (2). Ideally, for ergonomics, a root would automatically unroot
+//! itself when dropped. But in the general case that requires holding a
+//! reference to the store's root set, and that root set needs to be held
+//! simultaneously by all GC roots, and they each need to mutate the set to
+//! unroot themselves. That implies `Rc<RefCell<...>>` or `Arc<Mutex<...>>`! The
+//! former makes the store and GC root types not `Send` and not `Sync`. The
+//! latter imposes synchronization and locking overhead. So we instead make GC
+//! roots indirect and require passing in a store context explicitly to unroot
+//! in the general case. This trades worse ergonomics for better performance and
+//! support for moving GC.
+//!
+//! ## Two Flavors of Rooting API
+//!
+//! Okay, with that out of the way, this module provides two flavors of rooting
+//! API. One for the common, scoped lifetime case, and another for the rare case
+//! where we really need a GC root with an arbitrary, non-LIFO/non-scoped
+//! lifetime:
+//!
+//! 1. `RootScope` and `Rooted<T>`: These are used for temporarily rooting GC
+//!    objects for the duration of a scope. The internal implementation takes
+//!    advantage of the LIFO property inherent in scopes, making creating and
+//!    dropping `Rooted<T>`s and `RootScope`s super fast and roughly equivalent
+//!    to bump allocation.
+//!
+//!    This type is vaguely similar to V8's [`HandleScope`].
+//!
+//!    [`HandleScope`]: https://v8.github.io/api/head/classv8_1_1HandleScope.html
+//!
+//!    Note that `Rooted<T>` can't be statically tied to its context scope via a
+//!    lifetime parameter, unfortunately, as that would allow the creation of
+//!    only one `Rooted<T>` at a time, since the `Rooted<T>` would take a borrow
+//!    of the whole context.
+//!
+//!    This supports the common use case for rooting and provides good
+//!    ergonomics.
+//!
+//! 2. `ManuallyRooted<T>`: This is the fully general rooting API used for
+//!    holding onto non-LIFO GC roots with arbitrary lifetimes. However, users
+//!    must manually unroot them. Failure to manually unroot a
+//!    `ManuallyRooted<T>` before it is dropped will result in the GC object
+//!    (and everything it transitively references) leaking for the duration of
+//!    the `Store`'s lifetime.
+//!
+//!    This type is roughly similar to SpiderMonkey's [`PersistentRooted<T>`],
+//!    although they avoid the manual-unrooting with internal mutation and
+//!    shared references. (Our constraints mean we can't do those things, as
+//!    mentioned explained above.)
+//!
+//!    [`PersistentRooted<T>`]: http://devdoc.net/web/developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey/JSAPI_reference/JS::PersistentRooted.html
+//!
+//! At the end of the day, both `Rooted<T>` and `ManuallyRooted<T>` are just
+//! tagged indices into the store's `RootSet`. This indirection allows working
+//! with Rust's borrowing discipline (we use `&mut Store` to represent mutable
+//! access to the GC heap) while still allowing rooted references to be moved
+//! around without tying up the whole store in borrows. Additionally, and
+//! crucially, this indirection allows us to update the *actual* GC pointers in
+//! the `RootSet` and support moving GCs (again, as mentioned above).
+//!
+//! ## Unrooted References
+//!
+//! We generally don't expose *unrooted* GC references in the Wasmtime API at
+//! this time -- and I expect it will be a very long time before we do, but in
+//! the limit we may want to let users define their own GC-managed types that
+//! participate in GC tracing and all that -- so we don't have to worry about
+//! failure to root an object causing use-after-free bugs or failing to update a
+//! GC root pointer after a moving GC as long as users stick to our safe rooting
+//! APIs. (The one exception is `ValRaw`, which does hold raw GC references. But
+//! with `ValRaw` all bets are off and safety is 100% up to the user.)
+//!
+//! We do, however, have to worry about these things internally. So first of
+//! all, try to avoid ever working with unrooted GC references if you
+//! can. However, if you really must, consider also using an `AutoAssertNoGc`
+//! across the block of code that is manipulating raw GC references.
+
+use crate::runtime::vm::{GcRootsList, GcStore, VMGcRef};
+use crate::{prelude::*, ValRaw};
+use crate::{
+    store::{AutoAssertNoGc, StoreId, StoreOpaque},
+    AsContext, AsContextMut, GcRef, Result, RootedGcRef,
+};
+use core::any;
+use core::marker;
+use core::mem::{self, MaybeUninit};
+use core::num::NonZeroU64;
+use core::{
+    fmt::{self, Debug},
+    hash::{Hash, Hasher},
+    ops::{Deref, DerefMut},
+};
+use wasmtime_slab::{Id as SlabId, Slab};
+
+mod sealed {
+    use super::*;
+
+    /// Sealed, `wasmtime`-internal trait for GC references.
+    ///
+    /// # Safety
+    ///
+    /// All types implementing this trait must:
+    ///
+    /// * Be a newtype of a `GcRootIndex`
+    ///
+    /// * Not implement `Copy` or `Clone`
+    ///
+    /// * Only have `&self` methods.
+    pub unsafe trait GcRefImpl: Sized {
+        /// Transmute a `&GcRootIndex` into an `&Self`.
+        fn transmute_ref(index: &GcRootIndex) -> &Self;
+    }
+
+    /// Sealed, `wasmtime`-internal trait for the common methods on rooted GC
+    /// references.
+    pub trait RootedGcRefImpl<T: GcRef> {
+        /// Get this rooted GC reference's raw `VMGcRef` out of the store's GC
+        /// root set.
+        ///
+        /// Returns `None` for objects that have since been unrooted (eg because
+        /// its associated `RootedScope` was dropped).
+        ///
+        /// Panics if this root is not associated with the given store.
+        fn get_gc_ref<'a>(&self, store: &'a StoreOpaque) -> Option<&'a VMGcRef>;
+
+        /// Same as `get_gc_ref` but returns an error instead of `None` for
+        /// objects that have been unrooted.
+        fn try_gc_ref<'a>(&self, store: &'a StoreOpaque) -> Result<&'a VMGcRef> {
+            self.get_gc_ref(store).ok_or_else(|| {
+                anyhow!("attempted to use a garbage-collected object that has been unrooted")
+            })
+        }
+
+        /// Get a clone of this rooted GC reference's raw `VMGcRef` out of the
+        /// store's GC root set.
+        ///
+        /// Returns `None` for objects that have since been unrooted (eg because
+        /// its associated `RootedScope` was dropped).
+        ///
+        /// Panics if this root is not associated with the given store.
+        fn clone_gc_ref(&self, store: &mut AutoAssertNoGc<'_>) -> Option<VMGcRef> {
+            let gc_ref = self.get_gc_ref(store)?.unchecked_copy();
+            Some(store.unwrap_gc_store_mut().clone_gc_ref(&gc_ref))
+        }
+
+        /// Same as `clone_gc_ref` but returns an error instead of `None` for
+        /// objects that have been unrooted.
+        fn try_clone_gc_ref(&self, store: &mut AutoAssertNoGc<'_>) -> Result<VMGcRef> {
+            let gc_ref = self.try_gc_ref(store)?.unchecked_copy();
+            Ok(store.gc_store_mut()?.clone_gc_ref(&gc_ref))
+        }
+    }
+}
+pub(crate) use sealed::*;
+
+/// The index of a GC root inside a particular store's GC root set.
+///
+/// Can be either a LIFO- or manually-rooted object, depending on the
+/// `PackedIndex`.
+///
+/// Every `T` such that `T: GcRef` must be a newtype over this `GcRootIndex`.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+// Just `pub` to avoid `warn(private_interfaces)` in public APIs, which we can't
+// `allow(...)` on our MSRV yet.
+#[doc(hidden)]
+#[repr(C)] // NB: if this layout changes be sure to change the C API as well
+pub struct GcRootIndex {
+    store_id: StoreId,
+    generation: u32,
+    index: PackedIndex,
+}
+
+const _: () = {
+    // NB: these match the C API which should also be updated if this changes
+    assert!(mem::size_of::<GcRootIndex>() == 16);
+    assert!(mem::align_of::<GcRootIndex>() == mem::align_of::<u64>());
+};
+
+impl GcRootIndex {
+    #[inline]
+    pub(crate) fn comes_from_same_store(&self, store: &StoreOpaque) -> bool {
+        self.store_id == store.id()
+    }
+
+    /// Same as `RootedGcRefImpl::get_gc_ref` but not associated with any
+    /// particular `T: GcRef`.
+    ///
+    /// We must avoid triggering a GC while holding onto the resulting raw
+    /// `VMGcRef` to avoid use-after-free bugs and similar. The `'a` lifetime
+    /// threaded from the `store` to the result will normally prevent GCs
+    /// statically, at compile time, since performing a GC requires a mutable
+    /// borrow of the store. However, if you call `VMGcRef::unchecked_copy` on
+    /// the resulting GC reference, then all bets are off and this invariant is
+    /// up to you to manually uphold. Failure to uphold this invariant is memory
+    /// safe but will lead to general incorrectness such as panics and wrong
+    /// results.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `self` is not associated with the given store.
+    pub(crate) fn get_gc_ref<'a>(&self, store: &'a StoreOpaque) -> Option<&'a VMGcRef> {
+        assert!(
+            self.comes_from_same_store(store),
+            "object used with wrong store"
+        );
+        if let Some(index) = self.index.as_lifo() {
+            let entry = store.gc_roots().lifo_roots.get(index)?;
+            if entry.generation == self.generation {
+                Some(&entry.gc_ref)
+            } else {
+                None
+            }
+        } else if let Some(id) = self.index.as_manual() {
+            let gc_ref = store.gc_roots().manually_rooted.get(id);
+            debug_assert!(gc_ref.is_some());
+            gc_ref
+        } else {
+            unreachable!()
+        }
+    }
+
+    /// Same as `get_gc_ref` but returns an error instead of `None` if
+    /// the GC reference has been unrooted.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `self` is not associated with the given store.
+    pub(crate) fn try_gc_ref<'a>(&self, store: &'a StoreOpaque) -> Result<&'a VMGcRef> {
+        self.get_gc_ref(store).ok_or_else(|| {
+            anyhow!("attempted to use a garbage-collected object that has been unrooted")
+        })
+    }
+
+    /// Same as `RootedGcRefImpl::clone_gc_ref` but not associated with any
+    /// particular `T: GcRef`.
+    pub(crate) fn try_clone_gc_ref(&self, store: &mut AutoAssertNoGc<'_>) -> Result<VMGcRef> {
+        let gc_ref = self.try_gc_ref(store)?.unchecked_copy();
+        Ok(store.gc_store_mut()?.clone_gc_ref(&gc_ref))
+    }
+}
+
+/// This is a bit-packed version of
+///
+/// ```ignore
+/// enema {
+///     Lifo(usize),
+///     Manual(SlabId),
+/// }
+/// ```
+///
+/// where the high bit is the discriminant and the lower 31 bits are the
+/// payload.
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+struct PackedIndex(u32);
+
+impl Debug for PackedIndex {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if let Some(index) = self.as_lifo() {
+            f.debug_tuple("PackedIndex::Lifo").field(&index).finish()
+        } else if let Some(id) = self.as_manual() {
+            f.debug_tuple("PackedIndex::Manual").field(&id).finish()
+        } else {
+            unreachable!()
+        }
+    }
+}
+
+impl PackedIndex {
+    const DISCRIMINANT_MASK: u32 = 0b1 << 31;
+    const LIFO_DISCRIMINANT: u32 = 0b0 << 31;
+    const MANUAL_DISCRIMINANT: u32 = 0b1 << 31;
+    const PAYLOAD_MASK: u32 = !Self::DISCRIMINANT_MASK;
+
+    fn new_lifo(index: usize) -> PackedIndex {
+        let index32 = u32::try_from(index).unwrap();
+        assert_eq!(index32 & Self::DISCRIMINANT_MASK, 0);
+        let packed = PackedIndex(Self::LIFO_DISCRIMINANT | index32);
+        debug_assert!(packed.is_lifo());
+        debug_assert_eq!(packed.as_lifo(), Some(index));
+        debug_assert!(!packed.is_manual());
+        debug_assert!(packed.as_manual().is_none());
+        packed
+    }
+
+    fn new_manual(id: SlabId) -> PackedIndex {
+        let raw = id.into_raw();
+        assert_eq!(raw & Self::DISCRIMINANT_MASK, 0);
+        let packed = PackedIndex(Self::MANUAL_DISCRIMINANT | raw);
+        debug_assert!(packed.is_manual());
+        debug_assert_eq!(packed.as_manual(), Some(id));
+        debug_assert!(!packed.is_lifo());
+        debug_assert!(packed.as_lifo().is_none());
+        packed
+    }
+
+    fn discriminant(&self) -> u32 {
+        self.0 & Self::DISCRIMINANT_MASK
+    }
+
+    fn is_lifo(&self) -> bool {
+        self.discriminant() == Self::LIFO_DISCRIMINANT
+    }
+
+    fn is_manual(&self) -> bool {
+        self.discriminant() == Self::MANUAL_DISCRIMINANT
+    }
+
+    fn payload(&self) -> u32 {
+        self.0 & Self::PAYLOAD_MASK
+    }
+
+    fn as_lifo(&self) -> Option<usize> {
+        if self.is_lifo() {
+            Some(usize::try_from(self.payload()).unwrap())
+        } else {
+            None
+        }
+    }
+
+    fn as_manual(&self) -> Option<SlabId> {
+        if self.is_manual() {
+            Some(SlabId::from_raw(self.payload()))
+        } else {
+            None
+        }
+    }
+}
+
+/// The set of all embedder-API GC roots in a single store/heap.
+#[derive(Debug, Default)]
+pub(crate) struct RootSet {
+    /// GC roots with arbitrary lifetime that are manually rooted and unrooted,
+    /// for use with `ManuallyRooted<T>`.
+    manually_rooted: Slab<VMGcRef>,
+
+    /// Strictly LIFO-ordered GC roots, for use with `RootScope` and
+    /// `Rooted<T>`.
+    lifo_roots: Vec<LifoRoot>,
+
+    /// Generation counter for entries to prevent ABA bugs with `RootScope` and
+    /// `Rooted<T>`.
+    lifo_generation: u32,
+}
+
+#[derive(Debug)]
+struct LifoRoot {
+    generation: u32,
+    gc_ref: VMGcRef,
+}
+
+impl RootSet {
+    pub(crate) fn trace_roots(&mut self, gc_roots_list: &mut GcRootsList) {
+        log::trace!("Begin trace user LIFO roots");
+        for root in &mut self.lifo_roots {
+            unsafe {
+                gc_roots_list.add_root((&mut root.gc_ref).into(), "user LIFO root");
+            }
+        }
+        log::trace!("End trace user LIFO roots");
+
+        log::trace!("Begin trace user manual roots");
+        for (_id, root) in self.manually_rooted.iter_mut() {
+            unsafe {
+                gc_roots_list.add_root(root.into(), "user manual root");
+            }
+        }
+        log::trace!("End trace user manual roots");
+    }
+
+    /// Enter a LIFO rooting scope.
+    ///
+    /// Returns an integer that should be passed unmodified to `exit_lifo_scope`
+    /// when the scope is finished.
+    ///
+    /// Calls to `{enter,exit}_lifo_scope` must happen in a strict LIFO order.
+    #[inline]
+    pub(crate) fn enter_lifo_scope(&self) -> usize {
+        self.lifo_roots.len()
+    }
+
+    /// Exit a LIFO rooting scope.
+    ///
+    /// The `scope` argument must be the result of the corresponding
+    /// `enter_lifo_scope` call.
+    ///
+    /// Calls to `{enter,exit}_lifo_scope` must happen in a strict LIFO order.
+    #[inline]
+    pub(crate) fn exit_lifo_scope(&mut self, gc_store: Option<&mut GcStore>, scope: usize) {
+        debug_assert!(self.lifo_roots.len() >= scope);
+
+        // If we actually have roots to unroot, call an out-of-line slow path.
+        if self.lifo_roots.len() > scope {
+            self.exit_lifo_scope_slow(gc_store, scope);
+        }
+    }
+
+    #[inline(never)]
+    #[cold]
+    fn exit_lifo_scope_slow(&mut self, mut gc_store: Option<&mut GcStore>, scope: usize) {
+        self.lifo_generation += 1;
+
+        // TODO: In the case where we have a tracing GC that doesn't need to
+        // drop barriers, this should really be:
+        //
+        //     self.lifo_roots.truncate(scope);
+
+        let mut lifo_roots = mem::take(&mut self.lifo_roots);
+        for root in lifo_roots.drain(scope..) {
+            // Only drop the GC reference if we actually have a GC store. How
+            // can we have a GC reference but not a GC store? If we've only
+            // create `i31refs`, we never force a GC store's allocation. This is
+            // fine because `i31ref`s never need drop barriers.
+            if let Some(gc_store) = &mut gc_store {
+                gc_store.drop_gc_ref(root.gc_ref);
+            }
+        }
+        self.lifo_roots = lifo_roots;
+    }
+
+    pub(crate) fn with_lifo_scope<S, T>(store: &mut S, f: impl FnOnce(&mut S) -> T) -> T
+    where
+        S: DerefMut<Target = StoreOpaque>,
+    {
+        let scope = store.gc_roots().enter_lifo_scope();
+        let ret = f(store);
+        store.exit_gc_lifo_scope(scope);
+        ret
+    }
+
+    pub(crate) fn push_lifo_root(&mut self, store_id: StoreId, gc_ref: VMGcRef) -> GcRootIndex {
+        let generation = self.lifo_generation;
+        let index = self.lifo_roots.len();
+        let index = PackedIndex::new_lifo(index);
+        self.lifo_roots.push(LifoRoot { generation, gc_ref });
+        GcRootIndex {
+            store_id,
+            generation,
+            index,
+        }
+    }
+}
+
+/// A scoped, rooted reference to a garbage-collected `T`.
+///
+/// A `Rooted<T>` is a strong handle to a garbage-collected `T`, preventing its
+/// referent (and anything else transitively referenced) from being collected by
+/// the GC during the scope within which this `Rooted<T>` was created.
+///
+/// When the context exits this `Rooted<T>`'s scope, the underlying GC object is
+/// automatically unrooted and any further attempts to use access the underlying
+/// object will return errors or otherwise fail.
+///
+/// `Rooted<T>` dereferences to its underlying `T`, allowing you to call `T`'s
+/// methods.
+///
+/// # Example
+///
+/// ```
+/// # use wasmtime::*;
+/// # fn _foo() -> Result<()> {
+/// let mut store = Store::<()>::default();
+///
+/// // Allocating a GC object returns a `Rooted<T>`.
+/// let hello: Rooted<ExternRef> = ExternRef::new(&mut store, "hello")?;
+///
+/// // Because `Rooted<T>` derefs to `T`, we can call `T` methods on a
+/// // `Rooted<T>`. For example, we can call the `ExternRef::data` method when we
+/// // have a `Rooted<ExternRef>`.
+/// let data = hello
+///     .data(&store)?
+///     .downcast_ref::<&str>()
+///     .ok_or_else(|| Error::msg("not a str"))?;
+/// assert_eq!(*data, "hello");
+///
+/// // A `Rooted<T>` roots its underlying GC object for the duration of the
+/// // scope of the store/caller/context that was passed to the method that created
+/// // it. If we only want to keep a GC reference rooted and alive temporarily, we
+/// // can introduce new scopes with `RootScope`.
+/// {
+///     let mut scope = RootScope::new(&mut store);
+///
+///     // This `Rooted<T>` is automatically unrooted after `scope` is dropped,
+///     // allowing the collector to reclaim its GC object in the next GC.
+///     let scoped_ref = ExternRef::new(&mut scope, "goodbye");
+/// }
+///
+/// let module = Module::new(store.engine(), r#"
+///     (module
+///         (global (export "global") (mut externref) (ref.null extern))
+///         (table (export "table") 10 externref)
+///         (func (export "func") (param externref) (result externref)
+///             local.get 0
+///         )
+///     )
+/// "#)?;
+/// let instance = Instance::new(&mut store, &module, &[])?;
+///
+/// // GC references returned from calls into Wasm also return (optional, if the
+/// // Wasm type is nullable) `Rooted<T>`s.
+/// let result: Option<Rooted<_>> = instance
+///     .get_typed_func::<Option<Rooted<ExternRef>>, Option<Rooted<ExternRef>>>(&mut store, "func")?
+///     .call(&mut store, Some(hello))?;
+///
+/// // Similarly, getting a GC reference from a Wasm instance's exported global
+/// // or table yields a `Rooted<T>`.
+///
+/// let global = instance
+///     .get_global(&mut store, "global")
+///     .ok_or_else(|| Error::msg("missing `global` export"))?;
+/// let global_val = global.get(&mut store);
+/// let global_ref: Option<&Rooted<_>> = global_val
+///     .externref()
+///     .ok_or_else(|| Error::msg("not an externref"))?;
+///
+/// let table = instance.get_table(&mut store, "table").unwrap();
+/// let table_elem = table
+///     .get(&mut store, 3)
+///     .ok_or_else(|| Error::msg("table out of bounds"))?;
+/// let table_elem_ref: Option<&Rooted<_>> = table_elem
+///     .as_extern()
+///     .ok_or_else(|| Error::msg("not an externref"))?;
+/// # Ok(())
+/// # }
+/// ```
+///
+/// # Differences Between `Rooted<T>` and `ManuallyRooted<T>`
+///
+/// While `Rooted<T>` is automatically unrooted when its scope is exited, this
+/// means that `Rooted<T>` is only valid for strictly last-in-first-out (LIFO,
+/// aka stack order) lifetimes. This is in contrast to
+/// [`ManuallyRooted<T>`][crate::ManuallyRooted], which supports rooting GC
+/// objects for arbitrary lifetimes, but requires manual unrooting.
+///
+/// | Type                                         | Supported Lifetimes         | Unrooting |
+/// |----------------------------------------------|-----------------------------|-----------|
+/// | [`Rooted<T>`][crate::Rooted]                 | Strictly LIFO / stack order | Automatic |
+/// | [`ManuallyRooted<T>`][crate::ManuallyRooted] | Arbitrary                   | Manual    |
+///
+/// `Rooted<T>` should suffice for most use cases, and provides better
+/// ergonomics, but `ManuallyRooted<T>` exists as a fully-general escape hatch.
+///
+/// # Scopes
+///
+/// Wasmtime automatically creates two kinds of scopes:
+///
+/// 1. A [`Store`][crate::Store] is the outermost rooting scope. Creating a
+///    `Root<T>` directly inside a `Store` permanently roots the underlying
+///    object, similar to dropping a
+///    [`ManuallyRooted<T>`][crate::ManuallyRooted] without unrooting it.
+///
+/// 2. A [`Caller`][crate::Caller] provides a rooting scope for the duration of
+///    a call from Wasm into a host function. Any objects rooted in a `Caller`
+///    will be unrooted after the host function returns. Note that there can be
+///    nested `Caller` scopes in the case where Wasm calls a host function,
+///    creating the first `Caller` and its rooting scope , and then the host
+///    function calls a Wasm function which then calls another host function,
+///    creating a second `Caller` and a second rooting scope. This nesting can
+///    be arbitrarily deep.
+///
+/// Additionally, if you would like to define finer-grained rooting scopes,
+/// Wasmtime provides the [`RootScope`][crate::RootScope] type.
+///
+/// Scopes are always nested in a last-in-first-out (LIFO) order. An outer scope
+/// is never exited (and the `Rooted<T>`s defined within it are never
+/// automatically unrooted) while an inner scope is still active. All inner
+/// scopes are exited before their outer scopes.
+///
+/// The following diagram illustrates various rooting scopes over time, how they
+/// nest, and when their `Rooted<T>`s are automatically unrooted:
+///
+/// ```text
+/// ----- new Store
+///   |
+///   |
+///   | let a: Rooted<T> = ...;
+///   |
+///   |
+///   | ----- call into Wasm
+///   |   |
+///   |   |
+///   |   | ----- Wasm calls host function F
+///   |   |   |
+///   |   |   |
+///   |   |   | let b: Rooted<T> = ...;
+///   |   |   |
+///   |   |   |
+///   |   |   | ----- F calls into Wasm
+///   |   |   |   |
+///   |   |   |   |
+///   |   |   |   | ----- Wasm call host function G
+///   |   |   |   |   |
+///   |   |   |   |   |
+///   |   |   |   |   | let c: Rooted<T> = ...;
+///   |   |   |   |   |
+///   |   |   |   |   |
+///   |   |   |   | ----- return to Wasm from host function G (unroots `c`)
+///   |   |   |   |
+///   |   |   |   |
+///   |   |   | ----- Wasm returns to F
+///   |   |   |
+///   |   |   |
+///   |   | ----- return from host function F (unroots `b`)
+///   |   |
+///   |   |
+///   | ----- return from Wasm
+///   |
+///   |
+///   | ----- let scope1 = RootScope::new(...);
+///   |   |
+///   |   |
+///   |   | let d: Rooted<T> = ...;
+///   |   |
+///   |   |
+///   |   | ----- let scope2 = RootScope::new(...);
+///   |   |   |
+///   |   |   |
+///   |   |   | let e: Rooted<T> = ...;
+///   |   |   |
+///   |   |   |
+///   |   | ----- drop `scope2` (unroots `e`)
+///   |   |
+///   |   |
+///   | ----- drop `scope1` (unroots `d`)
+///   |
+///   |
+/// ----- drop Store (unroots `a`)
+/// ```
+///
+/// A `Rooted<T>` can be used successfully as long as it is still rooted so, in
+/// the above diagram, `d` is valid inside `scope2` because `scope2` is wholly
+/// contained within the scope `d` was rooted within (`scope1`).
+///
+/// See also the documentation for [`RootScope`][crate::RootScope].
+#[repr(transparent)]
+pub struct Rooted<T: GcRef> {
+    inner: GcRootIndex,
+    _phantom: marker::PhantomData<T>,
+}
+
+impl<T: GcRef> Clone for Rooted<T> {
+    fn clone(&self) -> Self {
+        Rooted {
+            inner: self.inner,
+            _phantom: marker::PhantomData,
+        }
+    }
+}
+
+impl<T: GcRef> Copy for Rooted<T> {}
+
+impl<T: GcRef> Debug for Rooted<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let name = format!("Rooted<{}>", any::type_name::<T>());
+        f.debug_struct(&name).field("inner", &self.inner).finish()
+    }
+}
+
+impl<T: GcRef> RootedGcRefImpl<T> for Rooted<T> {
+    fn get_gc_ref<'a>(&self, store: &'a StoreOpaque) -> Option<&'a VMGcRef> {
+        assert!(
+            self.comes_from_same_store(store),
+            "object used with wrong store"
+        );
+        let index = self.inner.index.as_lifo().unwrap();
+        let entry = store.gc_roots().lifo_roots.get(index)?;
+        if entry.generation == self.inner.generation {
+            Some(&entry.gc_ref)
+        } else {
+            None
+        }
+    }
+}
+
+impl<T: GcRef> Deref for Rooted<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        T::transmute_ref(&self.inner)
+    }
+}
+
+impl<T: GcRef> Rooted<T> {
+    /// Push the given `VMGcRef` onto our LIFO root set.
+    ///
+    /// `gc_ref` should belong to `store`'s heap; failure to uphold this is
+    /// memory safe but will result in general failures down the line such as
+    /// panics or incorrect results.
+    ///
+    /// `gc_ref` should be a GC reference pointing to an instance of the GC type
+    /// that `T` represents. Failure to uphold this invariant is memory safe but
+    /// will result in general incorrectness such as panics and wrong results.
+    pub(crate) fn new(store: &mut AutoAssertNoGc<'_>, gc_ref: VMGcRef) -> Rooted<T> {
+        let id = store.id();
+        let roots = store.gc_roots_mut();
+        let inner = roots.push_lifo_root(id, gc_ref);
+        Rooted {
+            inner,
+            _phantom: marker::PhantomData,
+        }
+    }
+
+    /// Create a new `Rooted<T>` from a `GcRootIndex`.
+    ///
+    /// Note that `Rooted::from_gc_root_index(my_rooted.index)` is not
+    /// necessarily an identity function, as it allows changing the `T` type
+    /// parameter.
+    ///
+    /// The given index should be a LIFO index of a GC reference pointing to an
+    /// instance of the GC type that `T` represents. Failure to uphold this
+    /// invariant is memory safe but will result in general incorrectness such
+    /// as panics and wrong results.
+    pub(crate) fn from_gc_root_index(inner: GcRootIndex) -> Rooted<T> {
+        debug_assert!(inner.index.is_lifo());
+        Rooted {
+            inner,
+            _phantom: marker::PhantomData,
+        }
+    }
+
+    #[inline]
+    pub(crate) fn comes_from_same_store(&self, store: &StoreOpaque) -> bool {
+        debug_assert!(self.inner.index.is_lifo());
+        self.inner.comes_from_same_store(store)
+    }
+
+    /// Create a [`ManuallyRooted<T>`][crate::ManuallyRooted] holding onto the
+    /// same GC object as `self`.
+    ///
+    /// Returns `None` if `self` is used outside of its scope and has therefore
+    /// been unrooted.
+    ///
+    /// This does not unroot `self`, and `self` remains valid until its
+    /// associated scope is exited.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this object is not associate with the given store.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn _foo() -> Result<()> {
+    /// let mut store = Store::<()>::default();
+    ///
+    /// let y: ManuallyRooted<_> = {
+    ///     // Create a nested rooting scope.
+    ///     let mut scope = RootScope::new(&mut store);
+    ///
+    ///     // `x` is only rooted within this nested scope.
+    ///     let x: Rooted<_> = ExternRef::new(&mut scope, "hello!")?;
+    ///
+    ///     // Extend `x`'s rooting past its scope's lifetime by converting it
+    ///     // to a `ManuallyRooted`.
+    ///     x.to_manually_rooted(&mut scope)?
+    /// };
+    ///
+    /// // Now we can still access the reference outside the scope it was
+    /// // originally defined within.
+    /// let data = y.data(&store)?;
+    /// let data = data.downcast_ref::<&str>().unwrap();
+    /// assert_eq!(*data, "hello!");
+    ///
+    /// // But we have to manually unroot `y`.
+    /// y.unroot(&mut store);
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn to_manually_rooted(&self, mut store: impl AsContextMut) -> Result<ManuallyRooted<T>> {
+        self._to_manually_rooted(store.as_context_mut().0)
+    }
+
+    pub(crate) fn _to_manually_rooted(&self, store: &mut StoreOpaque) -> Result<ManuallyRooted<T>> {
+        let mut store = AutoAssertNoGc::new(store);
+        let gc_ref = self.try_clone_gc_ref(&mut store)?;
+        Ok(ManuallyRooted::new(&mut store, gc_ref))
+    }
+
+    /// Are these two `Rooted<T>`s the same GC root?
+    ///
+    /// Note that this function can return `false` even when `a` and `b` are
+    /// rooting the same underlying GC object, but the object was rooted
+    /// multiple times (for example in different scopes). Use
+    /// [`Rooted::ref_eq`][crate::Rooted::ref_eq] to test whether these are
+    /// references to the same underlying GC object or not.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn foo() -> Result<()> {
+    /// let mut store = Store::<()>::default();
+    ///
+    /// let a = ExternRef::new(&mut store, "hello")?;
+    /// let b = a;
+    ///
+    /// // `a` and `b` are the same GC root.
+    /// assert!(Rooted::rooted_eq(a, b));
+    ///
+    /// {
+    ///     let mut scope = RootScope::new(&mut store);
+    ///
+    ///     // `c` is a different GC root, in a different scope, even though it
+    ///     // is rooting the same object.
+    ///     let c = a.to_manually_rooted(&mut scope)?.into_rooted(&mut scope);
+    ///     assert!(!Rooted::rooted_eq(a, c));
+    /// }
+    ///
+    /// let x = ExternRef::new(&mut store, "goodbye")?;
+    ///
+    /// // `a` and `x` are different GC roots, rooting different objects.
+    /// assert!(!Rooted::rooted_eq(a, x));
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn rooted_eq(a: Self, b: Self) -> bool {
+        a.inner == b.inner
+    }
+
+    /// Are these two GC roots referencing the same underlying GC object?
+    ///
+    /// This function will return `true` even when `a` and `b` are different GC
+    /// roots (for example because they were rooted in different scopes) if they
+    /// are rooting the same underlying GC object. To only test whether they are
+    /// the same GC root, and not whether they are rooting the same GC object,
+    /// use [`Rooted::rooted_eq`][crate::Rooted::rooted_eq].
+    ///
+    /// Returns an error if either `a` or `b` has been unrooted, for example
+    /// because the scope it was rooted within has been exited.
+    ///
+    /// Because this method takes any `impl RootedGcRef<T>` arguments, it can be
+    /// used to compare, for example, a `Rooted<T>` and a `ManuallyRooted<T>`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if either `a` or `b` is not associated with the given `store`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn foo() -> Result<()> {
+    /// let mut store = Store::<()>::default();
+    ///
+    /// let a = ExternRef::new(&mut store, "hello")?;
+    /// let b = a;
+    ///
+    /// // `a` and `b` are rooting the same object.
+    /// assert!(Rooted::ref_eq(&store, &a, &b)?);
+    ///
+    /// {
+    ///     let mut scope = RootScope::new(&mut store);
+    ///
+    ///     // `c` is a different GC root, in a different scope, but still
+    ///     // rooting the same object.
+    ///     let c = a.to_manually_rooted(&mut scope)?.into_rooted(&mut scope);
+    ///     assert!(!Rooted::ref_eq(&scope, &a, &c)?);
+    /// }
+    ///
+    /// let x = ExternRef::new(&mut store, "goodbye")?;
+    ///
+    /// // `a` and `x` are rooting different objects.
+    /// assert!(!Rooted::ref_eq(&store, &a, &x)?);
+    ///
+    /// // You can also compare `Rooted<T>`s and `ManuallyRooted<T>`s with this
+    /// // function.
+    /// let d = a.to_manually_rooted(&mut store)?;
+    /// assert!(Rooted::ref_eq(&store, &a, &d)?);
+    ///
+    /// d.unroot(&mut store);
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn ref_eq(
+        store: impl AsContext,
+        a: &impl RootedGcRef<T>,
+        b: &impl RootedGcRef<T>,
+    ) -> Result<bool> {
+        let store = store.as_context().0;
+        let a = a.try_gc_ref(store)?;
+        let b = b.try_gc_ref(store)?;
+        Ok(a == b)
+    }
+
+    /// Hash this root.
+    ///
+    /// Note that, similar to `Rooted::rooted_eq`, this only operates on the
+    /// root and *not* the underlying GC reference. That means that two
+    /// different rootings of the same object will hash to different values
+    /// (modulo hash collisions). If this is undesirable, use the
+    /// [`ref_hash`][crate::Rooted::ref_hash] method instead.
+    pub fn rooted_hash<H>(&self, state: &mut H)
+    where
+        H: Hasher,
+    {
+        self.inner.hash(state);
+    }
+
+    /// Hash the underlying rooted object reference.
+    ///
+    /// Note that, similar to `Rooted::ref_eq`, and operates on the underlying
+    /// rooted GC object reference, not the root. That means that two
+    /// *different* rootings of the same object will hash to the *same*
+    /// value. If this is undesirable, use the
+    /// [`rooted_hash`][crate::Rooted::rooted_hash] method instead.
+    pub fn ref_hash<H>(&self, store: impl AsContext, state: &mut H) -> Result<()>
+    where
+        H: Hasher,
+    {
+        let gc_ref = self.try_gc_ref(store.as_context().0)?;
+        gc_ref.hash(state);
+        Ok(())
+    }
+
+    /// Cast `self` to a `Rooted<U>`.
+    ///
+    /// It is the caller's responsibility to ensure that `self` is actually a
+    /// `U`. Failure to uphold this invariant will be memory safe but will
+    /// result in general incorrectness such as panics and wrong results.
+    pub(crate) fn unchecked_cast<U: GcRef>(self) -> Rooted<U> {
+        Rooted::from_gc_root_index(self.inner)
+    }
+
+    /// Common implementation of the `WasmTy::store` trait method for all
+    /// `Rooted<T>`s.
+    pub(super) fn wasm_ty_store(
+        self,
+        store: &mut AutoAssertNoGc<'_>,
+        ptr: &mut MaybeUninit<ValRaw>,
+        val_raw: impl Fn(u32) -> ValRaw,
+    ) -> Result<()> {
+        let gc_ref = self.inner.try_clone_gc_ref(store)?;
+        let raw = gc_ref.as_raw_u32();
+        debug_assert_ne!(raw, 0);
+        store.gc_store_mut()?.expose_gc_ref_to_wasm(gc_ref);
+        ptr.write(val_raw(raw));
+        Ok(())
+    }
+
+    /// Common implementation of the `WasmTy::load` trait method for all
+    /// `Rooted<T>`s.
+    pub(super) fn wasm_ty_load(
+        store: &mut AutoAssertNoGc<'_>,
+        raw_gc_ref: u32,
+        from_cloned_gc_ref: impl Fn(&mut AutoAssertNoGc<'_>, VMGcRef) -> Self,
+    ) -> Self {
+        debug_assert_ne!(raw_gc_ref, 0);
+        let gc_ref = VMGcRef::from_raw_u32(raw_gc_ref).expect("non-null");
+        let gc_ref = store.unwrap_gc_store_mut().clone_gc_ref(&gc_ref);
+        from_cloned_gc_ref(store, gc_ref)
+    }
+
+    /// Common implementation of the `WasmTy::store` trait method for all
+    /// `Option<Rooted<T>>`s.
+    pub(super) fn wasm_ty_option_store(
+        me: Option<Self>,
+        store: &mut AutoAssertNoGc<'_>,
+        ptr: &mut MaybeUninit<ValRaw>,
+        val_raw: impl Fn(u32) -> ValRaw,
+    ) -> Result<()> {
+        match me {
+            Some(me) => me.wasm_ty_store(store, ptr, val_raw),
+            None => {
+                ptr.write(val_raw(0));
+                Ok(())
+            }
+        }
+    }
+
+    /// Common implementation of the `WasmTy::load` trait method for all
+    /// `Option<Rooted<T>>`s.
+    pub(super) fn wasm_ty_option_load(
+        store: &mut AutoAssertNoGc<'_>,
+        raw_gc_ref: u32,
+        from_cloned_gc_ref: impl Fn(&mut AutoAssertNoGc<'_>, VMGcRef) -> Self,
+    ) -> Option<Self> {
+        let gc_ref = VMGcRef::from_raw_u32(raw_gc_ref)?;
+        let gc_ref = store.unwrap_gc_store_mut().clone_gc_ref(&gc_ref);
+        Some(from_cloned_gc_ref(store, gc_ref))
+    }
+}
+
+/// Nested rooting scopes.
+///
+/// `RootScope` allows the creation or nested rooting scopes for use with
+/// [`Rooted<T>`][crate::Rooted]. This allows for fine-grained control over how
+/// long a set of [`Rooted<T>`][crate::Rooted]s are strongly held alive, giving
+/// gives you the tools necessary to avoid holding onto GC objects longer than
+/// necessary. `Rooted<T>`s created within a `RootScope` are automatically
+/// unrooted when the `RootScope` is dropped. For more details on
+/// [`Rooted<T>`][crate::Rooted] lifetimes and their interaction with rooting
+/// scopes, see [`Rooted<T>`][crate::Rooted]'s documentation.
+///
+/// A `RootScope<C>` wraps a `C: AsContextMut` (that is, anything that
+/// represents exclusive access to a [`Store`][crate::Store]) and in turn
+/// implements [`AsContext`][crate::AsContext] and
+/// [`AsContextMut`][crate::AsContextMut] in terms of its underlying
+/// `C`. Therefore, `RootScope<C>` can be used anywhere you would use the
+/// underlying `C`, for example in the [`Global::get`][crate::Global::get]
+/// method. Any `Rooted<T>`s created by a method that a `RootScope<C>` was
+/// passed as context to are tied to the `RootScope<C>`'s scope and
+/// automatically unrooted when the scope is dropped.
+///
+/// # Example
+///
+/// ```
+/// # use wasmtime::*;
+/// # fn _foo() -> Result<()> {
+/// let mut store = Store::<()>::default();
+///
+/// let a: Rooted<_>;
+/// let b: Rooted<_>;
+/// let c: Rooted<_>;
+///
+/// // Root `a` in the store's scope. It will be rooted for the duration of the
+/// // store's lifetime.
+/// a = ExternRef::new(&mut store, 42)?;
+///
+/// // `a` is rooted, so we can access its data successfully.
+/// assert!(a.data(&store).is_ok());
+///
+/// {
+///     let mut scope1 = RootScope::new(&mut store);
+///
+///     // Root `b` in `scope1`.
+///     b = ExternRef::new(&mut scope1, 36)?;
+///
+///     // Both `a` and `b` are rooted.
+///     assert!(a.data(&scope1).is_ok());
+///     assert!(b.data(&scope1).is_ok());
+///
+///     {
+///         let mut scope2 = RootScope::new(&mut scope1);
+///
+///         // Root `c` in `scope2`.
+///         c = ExternRef::new(&mut scope2, 36)?;
+///
+///         // All of `a`, `b`, and `c` are rooted.
+///         assert!(a.data(&scope2).is_ok());
+///         assert!(b.data(&scope2).is_ok());
+///         assert!(c.data(&scope2).is_ok());
+///
+///         // Drop `scope2`.
+///     }
+///
+///     // Now `a` and `b` are still rooted, but `c` was unrooted when we dropped
+///     // `scope2`.
+///     assert!(a.data(&scope1).is_ok());
+///     assert!(b.data(&scope1).is_ok());
+///     assert!(c.data(&scope1).is_err());
+///
+///     // Drop `scope1`.
+/// }
+///
+/// // And now only `a` is still rooted. Both `b` and `c` were unrooted when we
+/// // dropped their respective rooting scopes.
+/// assert!(a.data(&store).is_ok());
+/// assert!(b.data(&store).is_err());
+/// assert!(c.data(&store).is_err());
+/// # Ok(())
+/// # }
+/// ```
+pub struct RootScope<C>
+where
+    C: AsContextMut,
+{
+    store: C,
+    scope: usize,
+}
+
+impl<C> Drop for RootScope<C>
+where
+    C: AsContextMut,
+{
+    fn drop(&mut self) {
+        self.store.as_context_mut().0.exit_gc_lifo_scope(self.scope);
+    }
+}
+
+impl<C> RootScope<C>
+where
+    C: AsContextMut,
+{
+    // NB: we MUST NOT expose a method like
+    //
+    //     pub fn store(&mut self) -> &mut Store { ... }
+    //
+    // because callers could do treacherous things like
+    //
+    //     let scope1 = RootScope::new(&mut store1);
+    //     let scope2 = RootScope::new(&mut store2);
+    //     std::mem::swap(scope1.store(), scope2.store());
+    //
+    // and then we would start truncate the store's GC root set's LIFO roots to
+    // the wrong lengths.
+    //
+    // Instead, we just implement `AsContext[Mut]` for `RootScope`.
+
+    /// Construct a new scope for rooting GC objects.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// let mut store = Store::<()>::default();
+    ///
+    /// {
+    ///     let mut scope = RootScope::new(&mut store);
+    ///
+    ///     // Temporarily root GC objects in this nested rooting scope...
+    /// }
+    /// ```
+    pub fn new(store: C) -> Self {
+        let scope = store.as_context().0.gc_roots().enter_lifo_scope();
+        RootScope { store, scope }
+    }
+
+    fn gc_roots(&mut self) -> &mut RootSet {
+        self.store.as_context_mut().0.gc_roots_mut()
+    }
+
+    fn lifo_roots(&mut self) -> &mut Vec<LifoRoot> {
+        &mut self.gc_roots().lifo_roots
+    }
+
+    /// Reserve enough capacity for `additional` GC roots in this scope.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// let mut store = Store::<()>::default();
+    ///
+    /// {
+    ///     let mut scope = RootScope::new(&mut store);
+    ///
+    ///     // Ensure we have enough storage pre-allocated to root five GC
+    ///     // references inside this scope without any underlying reallocation.
+    ///     scope.reserve(5);
+    ///
+    ///     // ...
+    /// }
+    /// ```
+    pub fn reserve(&mut self, additional: usize) {
+        self.lifo_roots().reserve(additional);
+    }
+}
+
+impl<T> AsContext for RootScope<T>
+where
+    T: AsContextMut,
+{
+    type Data = T::Data;
+
+    fn as_context(&self) -> crate::StoreContext<'_, Self::Data> {
+        self.store.as_context()
+    }
+}
+
+impl<T> AsContextMut for RootScope<T>
+where
+    T: AsContextMut,
+{
+    fn as_context_mut(&mut self) -> crate::StoreContextMut<'_, Self::Data> {
+        self.store.as_context_mut()
+    }
+}
+
+/// A rooted reference to a garbage-collected `T` with arbitrary lifetime.
+///
+/// A `ManuallyRooted<T>` is a strong handle to a garbage-collected `T`,
+/// preventing its referent (and anything else transitively referenced) from
+/// being collected by the GC until [`unroot`][crate::ManuallyRooted::unroot] is
+/// explicitly called.
+///
+/// The primary way to create a `ManuallyRooted<T>` is to promote a temporary
+/// `Rooted<T>` into a `ManuallyRooted<T>` via its
+/// [`to_manually_rooted`][crate::Rooted::to_manually_rooted] method.
+///
+/// `ManuallyRooted<T>` dereferences to its underlying `T`, allowing you to call
+/// `T`'s methods.
+///
+/// # Example
+///
+/// ```
+/// # use wasmtime::*;
+/// # fn _foo() -> Result<()> {
+/// let mut store = Store::<Option<ManuallyRooted<ExternRef>>>::default();
+///
+/// // Create our `ManuallyRooted` in a nested scope to avoid rooting it for
+/// // the duration of the store's lifetime.
+/// let x = {
+///     let mut scope = RootScope::new(&mut store);
+///     let x = ExternRef::new(&mut scope, 1234)?;
+///     x.to_manually_rooted(&mut scope)?
+/// };
+///
+/// // Place `x` into our store.
+/// *store.data_mut() = Some(x);
+///
+/// // Do a bunch stuff that may or may not access, replace, or take `x`...
+///
+/// // At any time, in any arbitrary scope, we can remove `x` from the store
+/// // and unroot it:
+/// if let Some(x) = store.data_mut().take() {
+///     x.unroot(&mut store);
+/// }
+/// # Ok(())
+/// # }
+/// ```
+///
+/// # Differences Between `ManuallyRooted<T>` and `Rooted<T>`
+///
+/// While `ManuallyRooted<T>` can have arbitrary lifetimes, it requires manual
+/// unrooting. This is in contrast to [`Rooted<T>`][crate::Rooted] which is
+/// restricted to strictly last-in-first-out (LIFO, aka stack order) lifetimes,
+/// but comes with automatic unrooting.
+///
+/// | Type                                         | Supported Lifetimes         | Unrooting |
+/// |----------------------------------------------|-----------------------------|-----------|
+/// | [`Rooted<T>`][crate::Rooted]                 | Strictly LIFO / stack order | Automatic |
+/// | [`ManuallyRooted<T>`][crate::ManuallyRooted] | Arbitrary                   | Manual    |
+///
+/// `Rooted<T>` should suffice for most use cases, and provides better
+/// ergonomics, but `ManuallyRooted<T>` exists as a fully-general escape hatch.
+///
+/// # Manual Unrooting
+///
+/// Failure to explicitly call [`unroot`][crate::ManuallyRooted::unroot] (or
+/// another method that consumes `self` and unroots the reference, such as
+/// [`into_rooted`][crate::ManuallyRooted::into_rooted]) will leak the
+/// underlying GC object, preventing it from being garbage collected until its
+/// owning [`Store`][crate::Store] is dropped. That means all of the following
+/// will result in permanently rooting the underlying GC object:
+///
+/// * Implicitly dropping a `ManuallyRooted<T>`:
+///
+///   ```no_run
+///   # use wasmtime::*;
+///   # let get_manually_rooted = || -> ManuallyRooted<ExternRef> { todo!() };
+///   {
+///       let perma_root: ManuallyRooted<_> = get_manually_rooted();
+///
+///       // `perma_root` is implicitly dropped at the end of its scope,
+///       // permanently rooting/leaking its referent.
+///   }
+///   ```
+///
+/// * Explicitly dropping a `ManuallyRooted<T>`: `drop(my_manually_rooted)`.
+///
+/// * Forgetting a `ManuallyRooted<T>`: `std::mem::forget(my_manually_rooted)`.
+///
+/// * Inserting a `ManuallyRooted<T>` into a `std::sync::Arc` or `std::rc::Rc`
+///   cycle.
+///
+/// * Etc...
+///
+/// Wasmtime does *not* assert that a `ManuallyRooted<T>` is unrooted on `Drop`,
+/// or otherwise raise a panic, log a warning, or etc... on failure to manually
+/// unroot. Sometimes leaking is intentional and desirable, particularly when
+/// dealing with short-lived [`Store`][crate::Store]s where unrooting would just
+/// be busy work since the whole store is about to be dropped.
+#[repr(transparent)] // NB: the C API relies on this
+pub struct ManuallyRooted<T>
+where
+    T: GcRef,
+{
+    inner: GcRootIndex,
+    _phantom: marker::PhantomData<T>,
+}
+
+const _: () = {
+    use crate::{AnyRef, ExternRef};
+
+    // NB: these match the C API which should also be updated if this changes
+    assert!(mem::size_of::<ManuallyRooted<AnyRef>>() == 16);
+    assert!(mem::align_of::<ManuallyRooted<AnyRef>>() == mem::align_of::<u64>());
+    assert!(mem::size_of::<ManuallyRooted<ExternRef>>() == 16);
+    assert!(mem::align_of::<ManuallyRooted<ExternRef>>() == mem::align_of::<u64>());
+};
+
+impl<T: GcRef> Debug for ManuallyRooted<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let name = format!("ManuallyRooted<{}>", any::type_name::<T>());
+        f.debug_struct(&name).field("inner", &self.inner).finish()
+    }
+}
+
+impl<T: GcRef> Deref for ManuallyRooted<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        T::transmute_ref(&self.inner)
+    }
+}
+
+impl<T> ManuallyRooted<T>
+where
+    T: GcRef,
+{
+    /// Construct a new manually-rooted GC root.
+    ///
+    /// `gc_ref` should belong to `store`'s heap; failure to uphold this is
+    /// memory safe but will result in general failures down the line such as
+    /// panics or incorrect results.
+    ///
+    /// `gc_ref` should be a GC reference pointing to an instance of the GC type
+    /// that `T` represents. Failure to uphold this invariant is memory safe but
+    /// will result in general incorrectness such as panics and wrong results.
+    pub(crate) fn new(store: &mut AutoAssertNoGc<'_>, gc_ref: VMGcRef) -> Self {
+        let id = store.gc_roots_mut().manually_rooted.alloc(gc_ref);
+        ManuallyRooted {
+            inner: GcRootIndex {
+                store_id: store.id(),
+                generation: 0,
+                index: PackedIndex::new_manual(id),
+            },
+            _phantom: marker::PhantomData,
+        }
+    }
+
+    #[inline]
+    pub(crate) fn comes_from_same_store(&self, store: &StoreOpaque) -> bool {
+        debug_assert!(self.inner.index.is_manual());
+        self.inner.comes_from_same_store(store)
+    }
+
+    /// Clone this `ManuallyRooted`.
+    ///
+    /// Does not consume or unroot `self`: both `self` and the new
+    /// `ManuallyRooted` return value will need to be manually unrooted.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `self` is not associated with the given `store`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn _foo() -> Result<()> {
+    /// let mut store = Store::<Vec<ManuallyRooted<ExternRef>>>::default();
+    ///
+    /// // Create our `ManuallyRooted` in a nested scope to avoid rooting it for
+    /// // the duration of the store's lifetime.
+    /// let x = {
+    ///     let mut scope = RootScope::new(&mut store);
+    ///     let x = ExternRef::new(&mut scope, 1234)?;
+    ///     x.to_manually_rooted(&mut scope)?
+    /// };
+    ///
+    /// // Push five clones of `x` into our store.
+    /// for _ in 0..5 {
+    ///     let x_clone = x.clone(&mut store);
+    ///     store.data_mut().push(x_clone);
+    /// }
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn clone(&self, mut store: impl AsContextMut) -> Self {
+        self._clone(store.as_context_mut().0)
+    }
+
+    pub(crate) fn _clone(&self, store: &mut StoreOpaque) -> Self {
+        let mut store = AutoAssertNoGc::new(store);
+        let gc_ref = self
+            .clone_gc_ref(&mut store)
+            .expect("ManuallyRooted always has a gc ref");
+        Self::new(&mut store, gc_ref)
+    }
+
+    /// Unroot this GC object.
+    ///
+    /// Failure to call this method will result in the GC object, and anything
+    /// it transitively references, being kept alive (aka "leaking") for the
+    /// entirety of the store's lifetime.
+    ///
+    /// See the type-level docs for example usage.
+    pub fn unroot(self, mut store: impl AsContextMut) {
+        self._unroot(store.as_context_mut().0)
+    }
+
+    pub(crate) fn _unroot(self, store: &mut StoreOpaque) {
+        assert!(
+            self.comes_from_same_store(store),
+            "object used with wrong store"
+        );
+
+        let mut store = AutoAssertNoGc::new(store);
+        let id = self.inner.index.as_manual().unwrap();
+        let roots = store.gc_roots_mut();
+        let gc_ref = roots.manually_rooted.dealloc(id);
+        store.unwrap_gc_store_mut().drop_gc_ref(gc_ref);
+    }
+
+    /// Clone this `ManuallyRooted<T>` into a `Rooted<T>`.
+    ///
+    /// This operation does not consume or unroot this `ManuallyRooted<T>`.
+    ///
+    /// The underlying GC object is re-rooted in the given context's scope. The
+    /// resulting `Rooted<T>` is only valid during the given context's
+    /// scope. See the [`Rooted<T>`][crate::Rooted] documentation for more
+    /// details on rooting scopes.
+    ///
+    /// This operation does not consume or unroot this `ManuallyRooted<T>`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this object is not associated with the given context's store.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn _foo() -> Result<()> {
+    /// let mut store = Store::<()>::default();
+    ///
+    /// let root1: Rooted<_>;
+    ///
+    /// let manual = {
+    ///     let mut scope = RootScope::new(&mut store);
+    ///     root1 = ExternRef::new(&mut scope, 1234)?;
+    ///     root1.to_manually_rooted(&mut scope)?
+    /// };
+    ///
+    /// // `root1` is no longer accessible because it was unrooted when `scope`
+    /// // was dropped.
+    /// assert!(root1.data(&store).is_err());
+    ///
+    /// // But we can re-root `manual` into this scope.
+    /// let root2 = manual.to_rooted(&mut store);
+    /// assert!(root2.data(&store).is_ok());
+    ///
+    /// // And we also still have access to `manual` and we still have to
+    /// // manually unroot it.
+    /// assert!(manual.data(&store).is_ok());
+    /// manual.unroot(&mut store);
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn to_rooted(&self, mut context: impl AsContextMut) -> Rooted<T> {
+        self._to_rooted(context.as_context_mut().0)
+    }
+
+    pub(crate) fn _to_rooted(&self, store: &mut StoreOpaque) -> Rooted<T> {
+        assert!(
+            self.comes_from_same_store(store),
+            "object used with wrong store"
+        );
+        let mut store = AutoAssertNoGc::new(store);
+        let gc_ref = self.clone_gc_ref(&mut store).unwrap();
+        Rooted::new(&mut store, gc_ref)
+    }
+
+    /// Convert this `ManuallyRooted<T>` into a `Rooted<T>`.
+    ///
+    /// The underlying GC object is re-rooted in the given context's scope. The
+    /// resulting `Rooted<T>` is only valid during the given context's
+    /// scope. See the [`Rooted<T>`][crate::Rooted] documentation for more
+    /// details on rooting scopes.
+    ///
+    /// This operation consumes and unroots this `ManuallyRooted<T>`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this object is not associate with the given context's store.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn _foo() -> Result<()> {
+    /// let mut store = Store::<()>::default();
+    ///
+    /// let root1: Rooted<_>;
+    ///
+    /// let manual = {
+    ///     let mut scope = RootScope::new(&mut store);
+    ///     root1 = ExternRef::new(&mut scope, 1234)?;
+    ///     root1.to_manually_rooted(&mut scope)?
+    /// };
+    ///
+    /// // `root1` is no longer accessible because it was unrooted when `scope`
+    /// // was dropped.
+    /// assert!(root1.data(&store).is_err());
+    ///
+    /// // But we can re-root `manual` into this scope.
+    /// let root2 = manual.into_rooted(&mut store);
+    /// assert!(root2.data(&store).is_ok());
+    ///
+    /// // `manual` was consumed by the `into_rooted` call, and we no longer
+    /// // have access to it, nor need to manually unroot it.
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn into_rooted(self, mut context: impl AsContextMut) -> Rooted<T> {
+        self._into_rooted(context.as_context_mut().0)
+    }
+
+    pub(crate) fn _into_rooted(self, store: &mut StoreOpaque) -> Rooted<T> {
+        assert!(
+            self.comes_from_same_store(store),
+            "object used with wrong store"
+        );
+        let rooted = self._to_rooted(store);
+        self._unroot(store);
+        rooted
+    }
+
+    /// Are these two GC roots referencing the same underlying GC object?
+    ///
+    /// This function will return `true` even when `a` and `b` are different GC
+    /// roots (for example because they were rooted in different scopes) if they
+    /// are rooting the same underlying GC object.
+    ///
+    /// Because this method takes any `impl RootedGcRef<T>` arguments, it can be
+    /// used to compare, for example, a `Rooted<T>` and a `ManuallyRooted<T>`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if either `a` or `b` is not associated with the given `store`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn foo() -> Result<()> {
+    /// let mut store = Store::<()>::default();
+    ///
+    /// let a = ExternRef::new_manually_rooted(&mut store, "hello")?;
+    /// let b = a.clone(&mut store);
+    ///
+    /// // `a` and `b` are rooting the same object.
+    /// assert!(ManuallyRooted::ref_eq(&store, &a, &b)?);
+    ///
+    /// {
+    ///     let mut scope = RootScope::new(&mut store);
+    ///
+    ///     // `c` is a different GC root, is in a different scope, and is a
+    ///     // `Rooted<T>` instead of a `ManuallyRooted<T>`, but is still rooting
+    ///     // the same object.
+    ///     let c = a.to_rooted(&mut scope);
+    ///     assert!(ManuallyRooted::ref_eq(&scope, &a, &c)?);
+    /// }
+    ///
+    /// let x = ExternRef::new_manually_rooted(&mut store, "goodbye")?;
+    ///
+    /// // `a` and `x` are rooting different objects.
+    /// assert!(!ManuallyRooted::ref_eq(&store, &a, &x)?);
+    ///
+    /// a.unroot(&mut store);
+    /// b.unroot(&mut store);
+    /// x.unroot(&mut store);
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn ref_eq(
+        store: impl AsContext,
+        a: &impl RootedGcRef<T>,
+        b: &impl RootedGcRef<T>,
+    ) -> Result<bool> {
+        Rooted::ref_eq(store, a, b)
+    }
+
+    /// Hash this root.
+    ///
+    /// Note that, similar to `Rooted::rooted_eq`, this only operates on the
+    /// root and *not* the underlying GC reference. That means that two
+    /// different rootings of the same object will hash to different values
+    /// (modulo hash collisions). If this is undesirable, use the
+    /// [`ref_hash`][crate::ManuallyRooted::ref_hash] method instead.
+    pub fn rooted_hash<H>(&self, state: &mut H)
+    where
+        H: Hasher,
+    {
+        self.inner.hash(state);
+    }
+
+    /// Hash the underlying rooted object reference.
+    ///
+    /// Note that, similar to `Rooted::ref_eq`, and operates on the underlying
+    /// rooted GC object reference, not the root. That means that two
+    /// *different* rootings of the same object will hash to the *same*
+    /// value. If this is undesirable, use the
+    /// [`rooted_hash`][crate::Rooted::rooted_hash] method instead.
+    pub fn ref_hash<H>(&self, store: impl AsContext, state: &mut H)
+    where
+        H: Hasher,
+    {
+        let gc_ref = self
+            .get_gc_ref(store.as_context().0)
+            .expect("ManuallyRooted's get_gc_ref is infallible");
+        gc_ref.hash(state);
+    }
+
+    #[doc(hidden)]
+    pub fn into_parts_for_c_api(self) -> (NonZeroU64, u32, u32) {
+        (
+            self.inner.store_id.as_raw(),
+            self.inner.generation,
+            self.inner.index.0,
+        )
+    }
+
+    #[doc(hidden)]
+    pub unsafe fn from_raw_parts_for_c_api(a: NonZeroU64, b: u32, c: u32) -> ManuallyRooted<T> {
+        ManuallyRooted {
+            inner: GcRootIndex {
+                store_id: StoreId::from_raw(a),
+                generation: b,
+                index: PackedIndex(c),
+            },
+            _phantom: marker::PhantomData,
+        }
+    }
+
+    /// Cast `self` to a `ManuallyRooted<U>`.
+    ///
+    /// It is the caller's responsibility to ensure that `self` is actually a
+    /// `U`. Failure to uphold this invariant will be memory safe but will
+    /// result in general incorrectness such as panics and wrong results.
+    pub(crate) fn unchecked_cast<U: GcRef>(self) -> ManuallyRooted<U> {
+        let u = ManuallyRooted {
+            inner: self.inner,
+            _phantom: core::marker::PhantomData,
+        };
+        core::mem::forget(self);
+        u
+    }
+
+    /// Common implementation of the `WasmTy::store` trait method for all
+    /// `ManuallyRooted<T>`s.
+    pub(super) fn wasm_ty_store(
+        self,
+        store: &mut AutoAssertNoGc<'_>,
+        ptr: &mut MaybeUninit<ValRaw>,
+        val_raw: impl Fn(u32) -> ValRaw,
+    ) -> Result<()> {
+        let gc_ref = self.try_clone_gc_ref(store)?;
+        let raw = gc_ref.as_raw_u32();
+        debug_assert_ne!(raw, 0);
+        store.gc_store_mut()?.expose_gc_ref_to_wasm(gc_ref);
+        ptr.write(val_raw(raw));
+        Ok(())
+    }
+
+    /// Common implementation of the `WasmTy::load` trait method for all
+    /// `ManuallyRooted<T>`s.
+    pub(super) fn wasm_ty_load(
+        store: &mut AutoAssertNoGc<'_>,
+        raw_gc_ref: u32,
+        from_cloned_gc_ref: impl Fn(&mut AutoAssertNoGc<'_>, VMGcRef) -> Rooted<T>,
+    ) -> Self {
+        debug_assert_ne!(raw_gc_ref, 0);
+        let gc_ref = VMGcRef::from_raw_u32(raw_gc_ref).expect("non-null");
+        let gc_ref = store.unwrap_gc_store_mut().clone_gc_ref(&gc_ref);
+        RootSet::with_lifo_scope(store, |store| {
+            let rooted = from_cloned_gc_ref(store, gc_ref);
+            rooted
+                ._to_manually_rooted(store)
+                .expect("rooted is in scope")
+        })
+    }
+
+    /// Common implementation of the `WasmTy::store` trait method for all
+    /// `Option<ManuallyRooted<T>>`s.
+    pub(super) fn wasm_ty_option_store(
+        me: Option<Self>,
+        store: &mut AutoAssertNoGc<'_>,
+        ptr: &mut MaybeUninit<ValRaw>,
+        val_raw: impl Fn(u32) -> ValRaw,
+    ) -> Result<()> {
+        match me {
+            Some(me) => me.wasm_ty_store(store, ptr, val_raw),
+            None => {
+                ptr.write(val_raw(0));
+                Ok(())
+            }
+        }
+    }
+
+    /// Common implementation of the `WasmTy::load` trait method for all
+    /// `Option<ManuallyRooted<T>>`s.
+    pub(super) fn wasm_ty_option_load(
+        store: &mut AutoAssertNoGc<'_>,
+        raw_gc_ref: u32,
+        from_cloned_gc_ref: impl Fn(&mut AutoAssertNoGc<'_>, VMGcRef) -> Rooted<T>,
+    ) -> Option<Self> {
+        let gc_ref = VMGcRef::from_raw_u32(raw_gc_ref)?;
+        let gc_ref = store.unwrap_gc_store_mut().clone_gc_ref(&gc_ref);
+        RootSet::with_lifo_scope(store, |store| {
+            let rooted = from_cloned_gc_ref(store, gc_ref);
+            Some(
+                rooted
+                    ._to_manually_rooted(store)
+                    .expect("rooted is in scope"),
+            )
+        })
+    }
+}
+
+impl<T: GcRef> RootedGcRefImpl<T> for ManuallyRooted<T> {
+    fn get_gc_ref<'a>(&self, store: &'a StoreOpaque) -> Option<&'a VMGcRef> {
+        assert!(
+            self.comes_from_same_store(store),
+            "object used with wrong store"
+        );
+
+        let id = self.inner.index.as_manual().unwrap();
+        store.gc_roots().manually_rooted.get(id)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::ExternRef;
+
+    use super::*;
+
+    #[test]
+    fn sizes() {
+        // Try to keep tabs on the size of these things. Don't want them growing
+        // unintentionally.
+        assert_eq!(std::mem::size_of::<Rooted<ExternRef>>(), 16);
+        assert_eq!(std::mem::size_of::<ManuallyRooted<ExternRef>>(), 16);
+    }
+}
diff --git a/crates/wasmtime/src/runtime/gc/enabled/structref.rs b/crates/wasmtime/src/runtime/gc/enabled/structref.rs
new file mode 100644
index 000000000000..48849e405751
--- /dev/null
+++ b/crates/wasmtime/src/runtime/gc/enabled/structref.rs
@@ -0,0 +1,746 @@
+//! Working with GC `struct` objects.
+
+use crate::runtime::vm::VMGcRef;
+use crate::store::StoreId;
+use crate::vm::{GcLayout, GcStructLayout, VMGcHeader, VMStructRef};
+use crate::{
+    prelude::*,
+    store::{AutoAssertNoGc, StoreContextMut, StoreOpaque},
+    AsContext, AsContextMut, GcHeapOutOfMemory, GcRefImpl, GcRootIndex, HeapType, ManuallyRooted,
+    RefType, Rooted, StructType, Val, ValRaw, ValType, WasmTy,
+};
+use crate::{AnyRef, FieldType};
+use core::mem::{self, MaybeUninit};
+use wasmtime_environ::{VMGcKind, VMSharedTypeIndex};
+
+/// An allocator for a particular Wasm GC struct type.
+///
+/// Every `StructRefPre` is associated with a particular
+/// [`Store`][crate::Store] and a particular [StructType][crate::StructType].
+///
+/// Reusing an allocator across many allocations amortizes some per-type runtime
+/// overheads inside Wasmtime. A `StructRefPre` is to `StructRef`s as an
+/// `InstancePre` is to `Instance`s.
+///
+/// # Example
+///
+/// ```
+/// use wasmtime::*;
+///
+/// # fn foo() -> Result<()> {
+/// let mut config = Config::new();
+/// config.wasm_function_references(true);
+/// config.wasm_gc(true);
+///
+/// let engine = Engine::new(&config)?;
+/// let mut store = Store::new(&engine, ());
+///
+/// // Define a struct type.
+/// let struct_ty = StructType::new(
+///    store.engine(),
+///    [FieldType::new(Mutability::Var, StorageType::I8)],
+/// )?;
+///
+/// // Create an allocator for the struct type.
+/// let allocator = StructRefPre::new(&mut store, struct_ty);
+///
+/// {
+///     let mut scope = RootScope::new(&mut store);
+///
+///     // Allocate a bunch of instances of our struct type using the same
+///     // allocator! This is faster than creating a new allocator for each
+///     // instance we want to allocate.
+///     for i in 0..10 {
+///         StructRef::new(&mut scope, &allocator, &[Val::I32(i)])?;
+///     }
+/// }
+/// # Ok(())
+/// # }
+/// # foo().unwrap();
+/// ```
+pub struct StructRefPre {
+    store_id: StoreId,
+    ty: StructType,
+}
+
+impl StructRefPre {
+    /// Create a new `StructRefPre` that is associated with the given store
+    /// and type.
+    pub fn new(mut store: impl AsContextMut, ty: StructType) -> Self {
+        Self::_new(store.as_context_mut().0, ty)
+    }
+
+    pub(crate) fn _new(store: &mut StoreOpaque, ty: StructType) -> Self {
+        store.insert_gc_host_alloc_type(ty.registered_type().clone());
+        let store_id = store.id();
+
+        StructRefPre { store_id, ty }
+    }
+
+    pub(crate) fn layout(&self) -> &GcStructLayout {
+        self.ty
+            .registered_type()
+            .layout()
+            .expect("struct types have a layout")
+            .unwrap_struct()
+    }
+
+    pub(crate) fn type_index(&self) -> VMSharedTypeIndex {
+        self.ty.registered_type().index()
+    }
+}
+
+/// A reference to a GC-managed `struct` instance.
+///
+/// WebAssembly `struct`s are static, fixed-length, ordered sequences of
+/// fields. Fields are named by index, not by identifier; in this way, they are
+/// similar to Rust's tuples. Each field is mutable or constant and stores
+/// unpacked [`Val`][crate::Val]s or packed 8-/16-bit integers.
+///
+/// Like all WebAssembly references, these are opaque and unforgeable to Wasm:
+/// they cannot be faked and Wasm cannot, for example, cast the integer
+/// `0x12345678` into a reference, pretend it is a valid `structref`, and trick
+/// the host into dereferencing it and segfaulting or worse.
+///
+/// Note that you can also use `Rooted<StructRef>` and
+/// `ManuallyRooted<StructRef>` as a type parameter with
+/// [`Func::typed`][crate::Func::typed]- and
+/// [`Func::wrap`][crate::Func::wrap]-style APIs.
+///
+/// # Example
+///
+/// ```
+/// use wasmtime::*;
+///
+/// # fn foo() -> Result<()> {
+/// let mut config = Config::new();
+/// config.wasm_function_references(true);
+/// config.wasm_gc(true);
+///
+/// let engine = Engine::new(&config)?;
+/// let mut store = Store::new(&engine, ());
+///
+/// // Define a struct type.
+/// let struct_ty = StructType::new(
+///    store.engine(),
+///    [FieldType::new(Mutability::Var, StorageType::I8)],
+/// )?;
+///
+/// // Create an allocator for the struct type.
+/// let allocator = StructRefPre::new(&mut store, struct_ty);
+///
+/// {
+///     let mut scope = RootScope::new(&mut store);
+///
+///     // Allocate an instance of the struct type.
+///     let my_struct = match StructRef::new(&mut scope, &allocator, &[Val::I32(42)]) {
+///         Ok(s) => s,
+///         // If the heap is out of memory, then do a GC and try again.
+///         Err(e) if e.is::<GcHeapOutOfMemory<()>>() => {
+///             // Do a GC! Note: in an async context, you'd want to do
+///             // `scope.as_context_mut().gc_async().await`.
+///             scope.as_context_mut().gc();
+///
+///             StructRef::new(&mut scope, &allocator, &[Val::I32(42)])?
+///         }
+///         Err(e) => return Err(e),
+///     };
+///
+///     // That instance's field should have the expected value.
+///     let val = my_struct.field(&mut scope, 0)?.unwrap_i32();
+///     assert_eq!(val, 42);
+///
+///     // And we can update the field's value because it is a mutable field.
+///     my_struct.set_field(&mut scope, 0, Val::I32(36))?;
+///     let new_val = my_struct.field(&mut scope, 0)?.unwrap_i32();
+///     assert_eq!(new_val, 36);
+/// }
+/// # Ok(())
+/// # }
+/// # foo().unwrap();
+/// ```
+#[derive(Debug)]
+#[repr(transparent)]
+pub struct StructRef {
+    pub(super) inner: GcRootIndex,
+}
+
+unsafe impl GcRefImpl for StructRef {
+    #[allow(private_interfaces)]
+    fn transmute_ref(index: &GcRootIndex) -> &Self {
+        // Safety: `StructRef` is a newtype of a `GcRootIndex`.
+        let me: &Self = unsafe { mem::transmute(index) };
+
+        // Assert we really are just a newtype of a `GcRootIndex`.
+        assert!(matches!(
+            me,
+            Self {
+                inner: GcRootIndex { .. },
+            }
+        ));
+
+        me
+    }
+}
+
+impl Rooted<StructRef> {
+    /// Upcast this `structref` into an `anyref`.
+    #[inline]
+    pub fn to_anyref(self) -> Rooted<AnyRef> {
+        self.unchecked_cast()
+    }
+}
+
+impl ManuallyRooted<StructRef> {
+    /// Upcast this `structref` into an `anyref`.
+    #[inline]
+    pub fn to_anyref(self) -> ManuallyRooted<AnyRef> {
+        self.unchecked_cast()
+    }
+}
+
+impl StructRef {
+    /// Allocate a new `struct` and get a reference to it.
+    ///
+    /// # Errors
+    ///
+    /// If the given `fields` values' types do not match the field types of the
+    /// `allocator`'s struct type, an error is returned.
+    ///
+    /// If the allocation cannot be satisfied because the GC heap is currently
+    /// out of memory, but performing a garbage collection might free up space
+    /// such that retrying the allocation afterwards might succeed, then a
+    /// [`GcHeapOutOfMemory<()>`][crate::GcHeapOutOfMemory] error is returned.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the allocator, or any of the field values, is not associated
+    /// with the given store.
+    pub fn new(
+        mut store: impl AsContextMut,
+        allocator: &StructRefPre,
+        fields: &[Val],
+    ) -> Result<Rooted<StructRef>> {
+        Self::_new(store.as_context_mut().0, allocator, fields)
+    }
+
+    pub(crate) fn _new(
+        store: &mut StoreOpaque,
+        allocator: &StructRefPre,
+        fields: &[Val],
+    ) -> Result<Rooted<StructRef>> {
+        assert_eq!(
+            store.id(),
+            allocator.store_id,
+            "attempted to use a `StructRefPre` with the wrong store"
+        );
+
+        // Type check the given values against the field types.
+        let expected_len = allocator.ty.fields().len();
+        let actual_len = fields.len();
+        ensure!(
+            actual_len == expected_len,
+            "expected {expected_len} fields, got {actual_len}"
+        );
+        for (ty, val) in allocator.ty.fields().zip(fields) {
+            assert!(
+                val.comes_from_same_store(store),
+                "field value comes from the wrong store",
+            );
+            let ty = ty.element_type().unpack();
+            val.ensure_matches_ty(store, ty)
+                .context("field type mismatch")?;
+        }
+
+        // Allocate the struct and write each field value into the appropriate
+        // offset.
+        let structref = store
+            .gc_store_mut()?
+            .alloc_uninit_struct(allocator.type_index(), &allocator.layout())
+            .err2anyhow()
+            .context("unrecoverable error when allocating new `structref`")?
+            .ok_or_else(|| GcHeapOutOfMemory::new(()))
+            .err2anyhow()?;
+
+        // From this point on, if we get any errors, then the struct is not
+        // fully initialized, so we need to eagerly deallocate it before the
+        // next GC where the collector might try to interpret one of the
+        // uninitialized fields as a GC reference.
+        let mut store = AutoAssertNoGc::new(store);
+        match (|| {
+            for (index, (ty, val)) in allocator.ty.fields().zip(fields).enumerate() {
+                structref.initialize_field(
+                    &mut store,
+                    allocator.layout(),
+                    ty.element_type(),
+                    index,
+                    *val,
+                )?;
+            }
+            Ok(())
+        })() {
+            Ok(()) => Ok(Rooted::new(&mut store, structref.into())),
+            Err(e) => {
+                store.gc_store_mut()?.dealloc_uninit_struct(structref);
+                Err(e)
+            }
+        }
+    }
+
+    #[inline]
+    pub(crate) fn comes_from_same_store(&self, store: &StoreOpaque) -> bool {
+        self.inner.comes_from_same_store(store)
+    }
+
+    /// Get this `structref`'s type.
+    ///
+    /// # Errors
+    ///
+    /// Return an error if this reference has been unrooted.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this reference is associated with a different store.
+    pub fn ty(&self, store: impl AsContext) -> Result<StructType> {
+        self._ty(store.as_context().0)
+    }
+
+    pub(crate) fn _ty(&self, store: &StoreOpaque) -> Result<StructType> {
+        assert!(self.comes_from_same_store(store));
+        let index = self.type_index(store)?;
+        Ok(StructType::from_shared_type_index(store.engine(), index))
+    }
+
+    /// Does this `structref` match the given type?
+    ///
+    /// That is, is this struct's type a subtype of the given type?
+    ///
+    /// # Errors
+    ///
+    /// Return an error if this reference has been unrooted.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this reference is associated with a different store or if the
+    /// type is not associated with the store's engine.
+    pub fn matches_ty(&self, store: impl AsContext, ty: &StructType) -> Result<bool> {
+        self._matches_ty(store.as_context().0, ty)
+    }
+
+    pub(crate) fn _matches_ty(&self, store: &StoreOpaque, ty: &StructType) -> Result<bool> {
+        assert!(self.comes_from_same_store(store));
+        Ok(self._ty(store)?.matches(ty))
+    }
+
+    pub(crate) fn ensure_matches_ty(&self, store: &StoreOpaque, ty: &StructType) -> Result<()> {
+        if !self.comes_from_same_store(store) {
+            bail!("function used with wrong store");
+        }
+        if self._matches_ty(store, ty)? {
+            Ok(())
+        } else {
+            let actual_ty = self._ty(store)?;
+            bail!("type mismatch: expected `(ref {ty})`, found `(ref {actual_ty})`")
+        }
+    }
+
+    /// Get the values of this struct's fields.
+    ///
+    /// Note that `i8` and `i16` field values are zero-extended into
+    /// `Val::I32(_)`s.
+    ///
+    /// # Errors
+    ///
+    /// Return an error if this reference has been unrooted.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this reference is associated with a different store.
+    pub fn fields<'a, T: 'a>(
+        &'a self,
+        store: impl Into<StoreContextMut<'a, T>>,
+    ) -> Result<impl ExactSizeIterator<Item = Val> + 'a> {
+        self._fields(store.into().0)
+    }
+
+    pub(crate) fn _fields<'a>(
+        &'a self,
+        store: &'a mut StoreOpaque,
+    ) -> Result<impl ExactSizeIterator<Item = Val> + 'a> {
+        assert!(self.comes_from_same_store(store));
+        let store = AutoAssertNoGc::new(store);
+
+        let gc_ref = self.inner.try_gc_ref(&store)?;
+        let header = store.gc_store()?.header(gc_ref);
+        debug_assert!(header.kind().matches(VMGcKind::StructRef));
+
+        let index = header.ty().expect("structrefs should have concrete types");
+        let ty = StructType::from_shared_type_index(store.engine(), index);
+        let len = ty.fields().len();
+
+        return Ok(Fields {
+            structref: self,
+            store,
+            index: 0,
+            len,
+        });
+
+        struct Fields<'a, 'b> {
+            structref: &'a StructRef,
+            store: AutoAssertNoGc<'b>,
+            index: usize,
+            len: usize,
+        }
+
+        impl Iterator for Fields<'_, '_> {
+            type Item = Val;
+
+            #[inline]
+            fn next(&mut self) -> Option<Self::Item> {
+                let i = self.index;
+                debug_assert!(i <= self.len);
+                if i >= self.len {
+                    return None;
+                }
+                self.index += 1;
+                Some(self.structref._field(&mut self.store, i).unwrap())
+            }
+
+            #[inline]
+            fn size_hint(&self) -> (usize, Option<usize>) {
+                let len = self.len - self.index;
+                (len, Some(len))
+            }
+        }
+
+        impl ExactSizeIterator for Fields<'_, '_> {
+            #[inline]
+            fn len(&self) -> usize {
+                self.len - self.index
+            }
+        }
+    }
+
+    fn header<'a>(&self, store: &'a AutoAssertNoGc<'_>) -> Result<&'a VMGcHeader> {
+        assert!(self.comes_from_same_store(&store));
+        let gc_ref = self.inner.try_gc_ref(store)?;
+        Ok(store.gc_store()?.header(gc_ref))
+    }
+
+    fn structref<'a>(&self, store: &'a AutoAssertNoGc<'_>) -> Result<&'a VMStructRef> {
+        assert!(self.comes_from_same_store(&store));
+        let gc_ref = self.inner.try_gc_ref(store)?;
+        debug_assert!(self.header(store)?.kind().matches(VMGcKind::StructRef));
+        Ok(gc_ref.as_structref_unchecked())
+    }
+
+    fn layout(&self, store: &AutoAssertNoGc<'_>) -> Result<GcStructLayout> {
+        assert!(self.comes_from_same_store(&store));
+        let type_index = self.type_index(store)?;
+        let layout = store
+            .engine()
+            .signatures()
+            .layout(type_index)
+            .expect("struct types should have GC layouts");
+        match layout {
+            GcLayout::Struct(s) => Ok(s),
+            GcLayout::Array(_) => unreachable!(),
+        }
+    }
+
+    fn field_ty(&self, store: &StoreOpaque, field: usize) -> Result<FieldType> {
+        let ty = self._ty(store)?;
+        match ty.field(field) {
+            Some(f) => Ok(f),
+            None => {
+                let len = ty.fields().len();
+                bail!("cannot access field {field}: struct only has {len} fields")
+            }
+        }
+    }
+
+    /// Get this struct's `index`th field.
+    ///
+    /// Note that `i8` and `i16` field values are zero-extended into
+    /// `Val::I32(_)`s.
+    ///
+    /// # Errors
+    ///
+    /// Returns an `Err(_)` if the index is out of bounds or this reference has
+    /// been unrooted.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this reference is associated with a different store.
+    pub fn field(&self, mut store: impl AsContextMut, index: usize) -> Result<Val> {
+        let mut store = AutoAssertNoGc::new(store.as_context_mut().0);
+        self._field(&mut store, index)
+    }
+
+    pub(crate) fn _field(&self, store: &mut AutoAssertNoGc<'_>, index: usize) -> Result<Val> {
+        assert!(self.comes_from_same_store(store));
+        let structref = self.structref(store)?.unchecked_copy();
+        let field_ty = self.field_ty(store, index)?;
+        let layout = self.layout(store)?;
+        Ok(structref.read_field(store, &layout, field_ty.element_type(), index))
+    }
+
+    /// Set this struct's `index`th field.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error in the following scenarios:
+    ///
+    /// * When given a value of the wrong type, such as trying to set an `f32`
+    ///   field to an `i64` value.
+    ///
+    /// * When the field is not mutable.
+    ///
+    /// * When this struct does not have an `index`th field, i.e. `index` is out
+    ///   of bounds.
+    ///
+    /// * When `value` is a GC reference that has since been unrooted.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this reference is associated with a different store.
+    pub fn set_field(&self, mut store: impl AsContextMut, index: usize, value: Val) -> Result<()> {
+        self._set_field(store.as_context_mut().0, index, value)
+    }
+
+    pub(crate) fn _set_field(
+        &self,
+        store: &mut StoreOpaque,
+        index: usize,
+        value: Val,
+    ) -> Result<()> {
+        assert!(self.comes_from_same_store(store));
+        let mut store = AutoAssertNoGc::new(store);
+
+        let field_ty = self.field_ty(&store, index)?;
+        ensure!(
+            field_ty.mutability().is_var(),
+            "cannot set field {index}: field is not mutable"
+        );
+
+        value
+            .ensure_matches_ty(&store, &field_ty.element_type().unpack())
+            .with_context(|| format!("cannot set field {index}: type mismatch"))?;
+
+        let layout = self.layout(&store)?;
+        let structref = self.structref(&store)?.unchecked_copy();
+
+        structref.write_field(&mut store, &layout, field_ty.element_type(), index, value)
+    }
+
+    pub(crate) fn type_index(&self, store: &StoreOpaque) -> Result<VMSharedTypeIndex> {
+        let gc_ref = self.inner.try_gc_ref(store)?;
+        let header = store.gc_store()?.header(gc_ref);
+        debug_assert!(header.kind().matches(VMGcKind::StructRef));
+        Ok(header.ty().expect("structrefs should have concrete types"))
+    }
+
+    /// Create a new `Rooted<StructRef>` from the given GC reference.
+    ///
+    /// `gc_ref` should point to a valid `structref` and should belong to the
+    /// store's GC heap. Failure to uphold these invariants is memory safe but
+    /// will lead to general incorrectness such as panics or wrong results.
+    pub(crate) fn from_cloned_gc_ref(
+        store: &mut AutoAssertNoGc<'_>,
+        gc_ref: VMGcRef,
+    ) -> Rooted<Self> {
+        debug_assert!(!gc_ref.is_i31());
+        Rooted::new(store, gc_ref)
+    }
+}
+
+unsafe impl WasmTy for Rooted<StructRef> {
+    #[inline]
+    fn valtype() -> ValType {
+        ValType::Ref(RefType::new(false, HeapType::Struct))
+    }
+
+    #[inline]
+    fn compatible_with_store(&self, store: &StoreOpaque) -> bool {
+        self.comes_from_same_store(store)
+    }
+
+    #[inline]
+    fn dynamic_concrete_type_check(
+        &self,
+        store: &StoreOpaque,
+        _nullable: bool,
+        ty: &HeapType,
+    ) -> Result<()> {
+        match ty {
+            HeapType::Any | HeapType::Eq | HeapType::Struct => Ok(()),
+            HeapType::ConcreteStruct(ty) => self.ensure_matches_ty(store, ty),
+
+            HeapType::Extern
+            | HeapType::NoExtern
+            | HeapType::Func
+            | HeapType::ConcreteFunc(_)
+            | HeapType::NoFunc
+            | HeapType::I31
+            | HeapType::Array
+            | HeapType::ConcreteArray(_)
+            | HeapType::None => bail!(
+                "type mismatch: expected `(ref {ty})`, got `(ref {})`",
+                self._ty(store)?,
+            ),
+        }
+    }
+
+    fn store(self, store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
+        self.wasm_ty_store(store, ptr, ValRaw::anyref)
+    }
+
+    unsafe fn load(store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self {
+        Self::wasm_ty_load(store, ptr.get_anyref(), StructRef::from_cloned_gc_ref)
+    }
+}
+
+unsafe impl WasmTy for Option<Rooted<StructRef>> {
+    #[inline]
+    fn valtype() -> ValType {
+        ValType::STRUCTREF
+    }
+
+    #[inline]
+    fn compatible_with_store(&self, store: &StoreOpaque) -> bool {
+        self.map_or(true, |x| x.comes_from_same_store(store))
+    }
+
+    #[inline]
+    fn dynamic_concrete_type_check(
+        &self,
+        store: &StoreOpaque,
+        nullable: bool,
+        ty: &HeapType,
+    ) -> Result<()> {
+        match self {
+            Some(s) => Rooted::<StructRef>::dynamic_concrete_type_check(s, store, nullable, ty),
+            None => {
+                ensure!(
+                    nullable,
+                    "expected a non-null reference, but found a null reference"
+                );
+                Ok(())
+            }
+        }
+    }
+
+    #[inline]
+    fn is_vmgcref_and_points_to_object(&self) -> bool {
+        self.is_some()
+    }
+
+    fn store(self, store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
+        <Rooted<StructRef>>::wasm_ty_option_store(self, store, ptr, ValRaw::anyref)
+    }
+
+    unsafe fn load(store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self {
+        <Rooted<StructRef>>::wasm_ty_option_load(
+            store,
+            ptr.get_anyref(),
+            StructRef::from_cloned_gc_ref,
+        )
+    }
+}
+
+unsafe impl WasmTy for ManuallyRooted<StructRef> {
+    #[inline]
+    fn valtype() -> ValType {
+        ValType::Ref(RefType::new(false, HeapType::Struct))
+    }
+
+    #[inline]
+    fn compatible_with_store(&self, store: &StoreOpaque) -> bool {
+        self.comes_from_same_store(store)
+    }
+
+    #[inline]
+    fn dynamic_concrete_type_check(
+        &self,
+        store: &StoreOpaque,
+        _: bool,
+        ty: &HeapType,
+    ) -> Result<()> {
+        match ty {
+            HeapType::Any | HeapType::Eq | HeapType::Struct => Ok(()),
+            HeapType::ConcreteStruct(ty) => self.ensure_matches_ty(store, ty),
+
+            HeapType::Extern
+            | HeapType::NoExtern
+            | HeapType::Func
+            | HeapType::ConcreteFunc(_)
+            | HeapType::NoFunc
+            | HeapType::I31
+            | HeapType::Array
+            | HeapType::ConcreteArray(_)
+            | HeapType::None => bail!(
+                "type mismatch: expected `(ref {ty})`, got `(ref {})`",
+                self._ty(store)?,
+            ),
+        }
+    }
+
+    fn store(self, store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
+        self.wasm_ty_store(store, ptr, ValRaw::anyref)
+    }
+
+    unsafe fn load(store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self {
+        Self::wasm_ty_load(store, ptr.get_anyref(), StructRef::from_cloned_gc_ref)
+    }
+}
+
+unsafe impl WasmTy for Option<ManuallyRooted<StructRef>> {
+    #[inline]
+    fn valtype() -> ValType {
+        ValType::STRUCTREF
+    }
+
+    #[inline]
+    fn compatible_with_store(&self, store: &StoreOpaque) -> bool {
+        self.as_ref()
+            .map_or(true, |x| x.comes_from_same_store(store))
+    }
+
+    #[inline]
+    fn dynamic_concrete_type_check(
+        &self,
+        store: &StoreOpaque,
+        nullable: bool,
+        ty: &HeapType,
+    ) -> Result<()> {
+        match self {
+            Some(s) => {
+                ManuallyRooted::<StructRef>::dynamic_concrete_type_check(s, store, nullable, ty)
+            }
+            None => {
+                ensure!(
+                    nullable,
+                    "expected a non-null reference, but found a null reference"
+                );
+                Ok(())
+            }
+        }
+    }
+
+    #[inline]
+    fn is_vmgcref_and_points_to_object(&self) -> bool {
+        self.is_some()
+    }
+
+    fn store(self, store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
+        <ManuallyRooted<StructRef>>::wasm_ty_option_store(self, store, ptr, ValRaw::anyref)
+    }
+
+    unsafe fn load(store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self {
+        <ManuallyRooted<StructRef>>::wasm_ty_option_load(
+            store,
+            ptr.get_anyref(),
+            StructRef::from_cloned_gc_ref,
+        )
+    }
+}
diff --git a/crates/wasmtime/src/runtime/gc/noextern.rs b/crates/wasmtime/src/runtime/gc/noextern.rs
new file mode 100644
index 000000000000..9cbe765262af
--- /dev/null
+++ b/crates/wasmtime/src/runtime/gc/noextern.rs
@@ -0,0 +1,154 @@
+use crate::{
+    store::{AutoAssertNoGc, StoreOpaque},
+    HeapType, Ref, RefType, Result, Uninhabited, Val, ValRaw, ValType, WasmTy,
+};
+use core::mem::MaybeUninit;
+
+/// A reference to the abstract `noextern` heap value.
+///
+/// The are no instances of `(ref noextern)`: it is an uninhabited type.
+///
+/// There is precisely one instance of `(ref null noextern)`, aka `nullexternref`:
+/// the null reference.
+///
+/// This `NoExtern` Rust type's sole purpose is for use with
+/// [`Func::wrap`][crate::Func::wrap]- and
+/// [`Func::typed`][crate::Func::typed]-style APIs for statically typing a
+/// function as taking or returning a `(ref null noextern)` (aka
+/// `Option<NoExtern>`) which is always `None`.
+///
+/// # Example
+///
+/// ```
+/// # use wasmtime::*;
+/// # fn _foo() -> Result<()> {
+/// let mut config = Config::new();
+/// config.wasm_function_references(true);
+/// config.wasm_gc(true);
+/// let engine = Engine::new(&config)?;
+///
+/// let module = Module::new(
+///     &engine,
+///     r#"
+///         (module
+///             (func (export "f") (param (ref null noextern))
+///                 ;; If the reference is null, return.
+///                 local.get 0
+///                 ref.is_null noextern
+///                 br_if 0
+///
+///                 ;; If the reference was not null (which is impossible)
+///                 ;; then raise a trap.
+///                 unreachable
+///             )
+///         )
+///     "#,
+/// )?;
+///
+/// let mut store = Store::new(&engine, ());
+/// let instance = Instance::new(&mut store, &module, &[])?;
+/// let f = instance.get_func(&mut store, "f").unwrap();
+///
+/// // We can cast a `(ref null noextern)`-taking function into a typed function that
+/// // takes an `Option<NoExtern>` via the `Func::typed` method.
+/// let f = f.typed::<Option<NoExtern>, ()>(&store)?;
+///
+/// // We can call the typed function, passing the null `noextern` reference.
+/// let result = f.call(&mut store, NoExtern::null());
+///
+/// // The function should not have trapped, because the reference we gave it was
+/// // null (as it had to be, since `NoExtern` is uninhabited).
+/// assert!(result.is_ok());
+/// # Ok(())
+/// # }
+/// ```
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub struct NoExtern {
+    _inner: Uninhabited,
+}
+
+impl NoExtern {
+    /// Get the null `(ref null noextern)` (aka `nullexternref`) reference.
+    #[inline]
+    pub fn null() -> Option<Self> {
+        None
+    }
+
+    /// Get the null `(ref null noextern)` (aka `nullexternref`) reference as a
+    /// [`Ref`].
+    #[inline]
+    pub fn null_ref() -> Ref {
+        Ref::Extern(None)
+    }
+
+    /// Get the null `(ref null noextern)` (aka `nullexternref`) reference as a
+    /// [`Val`].
+    #[inline]
+    pub fn null_val() -> Val {
+        Val::ExternRef(None)
+    }
+}
+
+unsafe impl WasmTy for NoExtern {
+    #[inline]
+    fn valtype() -> ValType {
+        ValType::Ref(RefType::new(false, HeapType::NoExtern))
+    }
+
+    #[inline]
+    fn compatible_with_store(&self, _store: &StoreOpaque) -> bool {
+        match self._inner {}
+    }
+
+    #[inline]
+    fn dynamic_concrete_type_check(&self, _: &StoreOpaque, _: bool, _: &HeapType) -> Result<()> {
+        match self._inner {}
+    }
+
+    #[inline]
+    fn is_vmgcref_and_points_to_object(&self) -> bool {
+        match self._inner {}
+    }
+
+    fn store(self, _store: &mut AutoAssertNoGc<'_>, _ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
+        match self._inner {}
+    }
+
+    unsafe fn load(_store: &mut AutoAssertNoGc<'_>, _ptr: &ValRaw) -> Self {
+        unreachable!("NoExtern is uninhabited")
+    }
+}
+
+unsafe impl WasmTy for Option<NoExtern> {
+    #[inline]
+    fn valtype() -> ValType {
+        ValType::Ref(RefType::new(true, HeapType::NoExtern))
+    }
+
+    #[inline]
+    fn compatible_with_store(&self, _store: &StoreOpaque) -> bool {
+        true
+    }
+
+    #[inline]
+    fn dynamic_concrete_type_check(
+        &self,
+        _store: &StoreOpaque,
+        _nullable: bool,
+        _ty: &HeapType,
+    ) -> Result<()> {
+        unreachable!()
+    }
+
+    #[inline]
+    fn store(self, _store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
+        ptr.write(ValRaw::externref(0));
+        Ok(())
+    }
+
+    #[inline]
+    unsafe fn load(_store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self {
+        debug_assert_eq!(ptr.get_externref(), 0);
+        None
+    }
+}
diff --git a/crates/wasmtime/src/runtime/instance.rs b/crates/wasmtime/src/runtime/instance.rs
new file mode 100644
index 000000000000..06c3e66ffa36
--- /dev/null
+++ b/crates/wasmtime/src/runtime/instance.rs
@@ -0,0 +1,989 @@
+use crate::linker::{Definition, DefinitionType};
+use crate::prelude::*;
+use crate::runtime::vm::{
+    Imports, InstanceAllocationRequest, ModuleRuntimeInfo, StorePtr, VMFuncRef, VMFunctionImport,
+    VMGlobalImport, VMMemoryImport, VMOpaqueContext, VMTableImport,
+};
+use crate::store::{InstanceId, StoreOpaque, Stored};
+use crate::types::matching;
+use crate::{
+    AsContextMut, Engine, Export, Extern, Func, Global, Memory, Module, ModuleExport, SharedMemory,
+    StoreContext, StoreContextMut, Table, TypedFunc,
+};
+use alloc::sync::Arc;
+use core::ptr::NonNull;
+use wasmparser::WasmFeatures;
+use wasmtime_environ::{
+    EntityIndex, EntityType, FuncIndex, GlobalIndex, MemoryIndex, PrimaryMap, TableIndex, TypeTrace,
+};
+
+/// An instantiated WebAssembly module.
+///
+/// This type represents the instantiation of a [`Module`]. Once instantiated
+/// you can access the [`exports`](Instance::exports) which are of type
+/// [`Extern`] and provide the ability to call functions, set globals, read
+/// memory, etc. When interacting with any wasm code you'll want to make an
+/// [`Instance`] to call any code or execute anything.
+///
+/// Instances are owned by a [`Store`](crate::Store) which is passed in at
+/// creation time. It's recommended to create instances with
+/// [`Linker::instantiate`](crate::Linker::instantiate) or similar
+/// [`Linker`](crate::Linker) methods, but a more low-level constructor is also
+/// available as [`Instance::new`].
+#[derive(Copy, Clone, Debug)]
+#[repr(transparent)]
+pub struct Instance(Stored<InstanceData>);
+
+pub(crate) struct InstanceData {
+    /// The id of the instance within the store, used to find the original
+    /// `InstanceHandle`.
+    id: InstanceId,
+    /// A lazily-populated list of exports of this instance. The order of
+    /// exports here matches the order of the exports in the original
+    /// module.
+    exports: Vec<Option<Extern>>,
+}
+
+impl InstanceData {
+    pub fn from_id(id: InstanceId) -> InstanceData {
+        InstanceData {
+            id,
+            exports: vec![],
+        }
+    }
+}
+
+impl Instance {
+    /// Creates a new [`Instance`] from the previously compiled [`Module`] and
+    /// list of `imports` specified.
+    ///
+    /// This method instantiates the `module` provided with the `imports`,
+    /// following the procedure in the [core specification][inst] to
+    /// instantiate. Instantiation can fail for a number of reasons (many
+    /// specified below), but if successful the `start` function will be
+    /// automatically run (if specified in the `module`) and then the
+    /// [`Instance`] will be returned.
+    ///
+    /// Per the WebAssembly spec, instantiation includes running the module's
+    /// start function, if it has one (not to be confused with the `_start`
+    /// function, which is not run).
+    ///
+    /// Note that this is a low-level function that just performs an
+    /// instantiation. See the [`Linker`](crate::Linker) struct for an API which
+    /// provides a convenient way to link imports and provides automatic Command
+    /// and Reactor behavior.
+    ///
+    /// ## Providing Imports
+    ///
+    /// The entries in the list of `imports` are intended to correspond 1:1
+    /// with the list of imports returned by [`Module::imports`]. Before
+    /// calling [`Instance::new`] you'll want to inspect the return value of
+    /// [`Module::imports`] and, for each import type, create an [`Extern`]
+    /// which corresponds to that type.  These [`Extern`] values are all then
+    /// collected into a list and passed to this function.
+    ///
+    /// Note that this function is intentionally relatively low level. For an
+    /// easier time passing imports by doing name-based resolution it's
+    /// recommended to instead use the [`Linker`](crate::Linker) type.
+    ///
+    /// ## Errors
+    ///
+    /// This function can fail for a number of reasons, including, but not
+    /// limited to:
+    ///
+    /// * The number of `imports` provided doesn't match the number of imports
+    ///   returned by the `module`'s [`Module::imports`] method.
+    /// * The type of any [`Extern`] doesn't match the corresponding
+    ///   [`ExternType`] entry that it maps to.
+    /// * The `start` function in the instance, if present, traps.
+    /// * Module/instance resource limits are exceeded.
+    ///
+    /// When instantiation fails it's recommended to inspect the return value to
+    /// see why it failed, or bubble it upwards. If you'd like to specifically
+    /// check for trap errors, you can use `error.downcast::<Trap>()`. For more
+    /// about error handling see the [`Trap`] documentation.
+    ///
+    /// [`Trap`]: crate::Trap
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if called with a store associated with a
+    /// [`asynchronous config`](crate::Config::async_support). This function
+    /// will also panic if any [`Extern`] supplied is not owned by `store`.
+    ///
+    /// [inst]: https://webassembly.github.io/spec/core/exec/modules.html#exec-instantiation
+    /// [`ExternType`]: crate::ExternType
+    pub fn new(
+        mut store: impl AsContextMut,
+        module: &Module,
+        imports: &[Extern],
+    ) -> Result<Instance> {
+        let mut store = store.as_context_mut();
+        let imports = Instance::typecheck_externs(store.0, module, imports)?;
+        // Note that the unsafety here should be satisfied by the call to
+        // `typecheck_externs` above which satisfies the condition that all
+        // the imports are valid for this module.
+        unsafe { Instance::new_started(&mut store, module, imports.as_ref()) }
+    }
+
+    /// Same as [`Instance::new`], except for usage in [asynchronous stores].
+    ///
+    /// For more details about this function see the documentation on
+    /// [`Instance::new`]. The only difference between these two methods is that
+    /// this one will asynchronously invoke the wasm start function in case it
+    /// calls any imported function which is an asynchronous host function (e.g.
+    /// created with [`Func::new_async`](crate::Func::new_async).
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if called with a store associated with a
+    /// [`synchronous config`](crate::Config::new). This is only compatible with
+    /// stores associated with an [`asynchronous
+    /// config`](crate::Config::async_support).
+    ///
+    /// This function will also panic, like [`Instance::new`], if any [`Extern`]
+    /// specified does not belong to `store`.
+    #[cfg(feature = "async")]
+    pub async fn new_async<T>(
+        mut store: impl AsContextMut<Data = T>,
+        module: &Module,
+        imports: &[Extern],
+    ) -> Result<Instance>
+    where
+        T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let imports = Instance::typecheck_externs(store.0, module, imports)?;
+        // See `new` for notes on this unsafety
+        unsafe { Instance::new_started_async(&mut store, module, imports.as_ref()).await }
+    }
+
+    fn typecheck_externs(
+        store: &mut StoreOpaque,
+        module: &Module,
+        imports: &[Extern],
+    ) -> Result<OwnedImports> {
+        for import in imports {
+            if !import.comes_from_same_store(store) {
+                bail!("cross-`Store` instantiation is not currently supported");
+            }
+        }
+        typecheck(module, imports, |cx, ty, item| {
+            let item = DefinitionType::from(store, item);
+            cx.definition(ty, &item)
+        })?;
+        let mut owned_imports = OwnedImports::new(module);
+        for import in imports {
+            owned_imports.push(import, store, module);
+        }
+        Ok(owned_imports)
+    }
+
+    /// Internal function to create an instance and run the start function.
+    ///
+    /// This function's unsafety is the same as `Instance::new_raw`.
+    pub(crate) unsafe fn new_started<T>(
+        store: &mut StoreContextMut<'_, T>,
+        module: &Module,
+        imports: Imports<'_>,
+    ) -> Result<Instance> {
+        assert!(
+            !store.0.async_support(),
+            "must use async instantiation when async support is enabled",
+        );
+        Self::new_started_impl(store, module, imports)
+    }
+
+    /// Internal function to create an instance and run the start function.
+    ///
+    /// ONLY CALL THIS IF YOU HAVE ALREADY CHECKED FOR ASYNCNESS AND HANDLED
+    /// THE FIBER NONSENSE
+    pub(crate) unsafe fn new_started_impl<T>(
+        store: &mut StoreContextMut<'_, T>,
+        module: &Module,
+        imports: Imports<'_>,
+    ) -> Result<Instance> {
+        let (instance, start) = Instance::new_raw(store.0, module, imports)?;
+        if let Some(start) = start {
+            instance.start_raw(store, start)?;
+        }
+        Ok(instance)
+    }
+
+    /// Internal function to create an instance and run the start function.
+    ///
+    /// This function's unsafety is the same as `Instance::new_raw`.
+    #[cfg(feature = "async")]
+    async unsafe fn new_started_async<T>(
+        store: &mut StoreContextMut<'_, T>,
+        module: &Module,
+        imports: Imports<'_>,
+    ) -> Result<Instance>
+    where
+        T: Send,
+    {
+        assert!(
+            store.0.async_support(),
+            "must use sync instantiation when async support is disabled",
+        );
+
+        store
+            .on_fiber(|store| Self::new_started_impl(store, module, imports))
+            .await?
+    }
+
+    /// Internal function to create an instance which doesn't have its `start`
+    /// function run yet.
+    ///
+    /// This is not intended to be exposed from Wasmtime, it's intended to
+    /// refactor out common code from `new_started` and `new_started_async`.
+    ///
+    /// Note that this step needs to be run on a fiber in async mode even
+    /// though it doesn't do any blocking work because an async resource
+    /// limiter may need to yield.
+    ///
+    /// # Unsafety
+    ///
+    /// This method is unsafe because it does not type-check the `imports`
+    /// provided. The `imports` provided must be suitable for the module
+    /// provided as well.
+    unsafe fn new_raw(
+        store: &mut StoreOpaque,
+        module: &Module,
+        imports: Imports<'_>,
+    ) -> Result<(Instance, Option<FuncIndex>)> {
+        if !Engine::same(store.engine(), module.engine()) {
+            bail!("cross-`Engine` instantiation is not currently supported");
+        }
+        store.bump_resource_counts(module)?;
+
+        // Allocate the GC heap, if necessary.
+        let _ = store.gc_store_mut()?;
+
+        let compiled_module = module.compiled_module();
+
+        // Register the module just before instantiation to ensure we keep the module
+        // properly referenced while in use by the store.
+        let module_id = store.modules_mut().register_module(module);
+        store.fill_func_refs();
+
+        // The first thing we do is issue an instance allocation request
+        // to the instance allocator. This, on success, will give us an
+        // instance handle.
+        //
+        // Note that the `host_state` here is a pointer back to the
+        // `Instance` we'll be returning from this function. This is a
+        // circular reference so we can't construct it before we construct
+        // this instance, so we determine what the ID is and then assert
+        // it's the same later when we do actually insert it.
+        let instance_to_be = store.store_data().next_id::<InstanceData>();
+
+        let mut instance_handle =
+            store
+                .engine()
+                .allocator()
+                .allocate_module(InstanceAllocationRequest {
+                    runtime_info: &ModuleRuntimeInfo::Module(module.clone()),
+                    imports,
+                    host_state: Box::new(Instance(instance_to_be)),
+                    store: StorePtr::new(store.traitobj()),
+                    wmemcheck: store.engine().config().wmemcheck,
+                    pkey: store.get_pkey(),
+                })?;
+
+        // The instance still has lots of setup, for example
+        // data/elements/start/etc. This can all fail, but even on failure
+        // the instance may persist some state via previous successful
+        // initialization. For this reason once we have an instance handle
+        // we immediately insert it into the store to keep it alive.
+        //
+        // Note that we `clone` the instance handle just to make easier
+        // working the borrow checker here easier. Technically the `&mut
+        // instance` has somewhat of a borrow on `store` (which
+        // conflicts with the borrow on `store.engine`) but this doesn't
+        // matter in practice since initialization isn't even running any
+        // code here anyway.
+        let id = store.add_instance(instance_handle.clone(), module_id);
+
+        // Additionally, before we start doing fallible instantiation, we
+        // do one more step which is to insert an `InstanceData`
+        // corresponding to this instance. This `InstanceData` can be used
+        // via `Caller::get_export` if our instance's state "leaks" into
+        // other instances, even if we don't return successfully from this
+        // function.
+        //
+        // We don't actually load all exports from the instance at this
+        // time, instead preferring to lazily load them as they're demanded.
+        // For module/instance exports, though, those aren't actually
+        // stored in the instance handle so we need to immediately handle
+        // those here.
+        let instance = {
+            let exports = vec![None; compiled_module.module().exports.len()];
+            let data = InstanceData { id, exports };
+            Instance::from_wasmtime(data, store)
+        };
+
+        // double-check our guess of what the new instance's ID would be
+        // was actually correct.
+        assert_eq!(instance.0, instance_to_be);
+
+        // Now that we've recorded all information we need to about this
+        // instance within a `Store` we can start performing fallible
+        // initialization. Note that we still defer the `start` function to
+        // later since that may need to run asynchronously.
+        //
+        // If this returns an error (or if the start function traps) then
+        // any other initialization which may have succeeded which placed
+        // items from this instance into other instances should be ok when
+        // those items are loaded and run we'll have all the metadata to
+        // look at them.
+        instance_handle.initialize(
+            compiled_module.module(),
+            store
+                .engine()
+                .features()
+                .contains(WasmFeatures::BULK_MEMORY),
+        )?;
+
+        Ok((instance, compiled_module.module().start_func))
+    }
+
+    pub(crate) fn from_wasmtime(handle: InstanceData, store: &mut StoreOpaque) -> Instance {
+        Instance(store.store_data_mut().insert(handle))
+    }
+
+    fn start_raw<T>(&self, store: &mut StoreContextMut<'_, T>, start: FuncIndex) -> Result<()> {
+        let id = store.0.store_data()[self.0].id;
+        // If a start function is present, invoke it. Make sure we use all the
+        // trap-handling configuration in `store` as well.
+        let instance = store.0.instance_mut(id);
+        let f = instance.get_exported_func(start);
+        let caller_vmctx = instance.vmctx();
+        unsafe {
+            super::func::invoke_wasm_and_catch_traps(store, |_default_caller| {
+                let func = f.func_ref.as_ref().array_call;
+                func(
+                    f.func_ref.as_ref().vmctx,
+                    VMOpaqueContext::from_vmcontext(caller_vmctx),
+                    [].as_mut_ptr(),
+                    0,
+                )
+            })?;
+        }
+        Ok(())
+    }
+
+    /// Get this instance's module.
+    pub fn module<'a, T: 'a>(&self, store: impl Into<StoreContext<'a, T>>) -> &'a Module {
+        self._module(store.into().0)
+    }
+
+    fn _module<'a>(&self, store: &'a StoreOpaque) -> &'a Module {
+        let InstanceData { id, .. } = store[self.0];
+        store.module_for_instance(id).unwrap()
+    }
+
+    /// Returns the list of exported items from this [`Instance`].
+    ///
+    /// # Panics
+    ///
+    /// Panics if `store` does not own this instance.
+    pub fn exports<'a, T: 'a>(
+        &'a self,
+        store: impl Into<StoreContextMut<'a, T>>,
+    ) -> impl ExactSizeIterator<Item = Export<'a>> + 'a {
+        self._exports(store.into().0)
+    }
+
+    fn _exports<'a>(
+        &'a self,
+        store: &'a mut StoreOpaque,
+    ) -> impl ExactSizeIterator<Item = Export<'a>> + 'a {
+        // If this is an `Instantiated` instance then all the `exports` may not
+        // be filled in. Fill them all in now if that's the case.
+        let InstanceData { exports, id, .. } = &store[self.0];
+        if exports.iter().any(|e| e.is_none()) {
+            let module = Arc::clone(store.instance(*id).module());
+            let data = &store[self.0];
+            let id = data.id;
+
+            for name in module.exports.keys() {
+                let instance = store.instance(id);
+                if let Some((export_name_index, _, &entity)) =
+                    instance.module().exports.get_full(name)
+                {
+                    self._get_export(store, entity, export_name_index);
+                }
+            }
+        }
+
+        let data = &store.store_data()[self.0];
+        let module = store.instance(data.id).module();
+        module
+            .exports
+            .iter()
+            .zip(&data.exports)
+            .map(|((name, _), export)| Export::new(name, export.clone().unwrap()))
+    }
+
+    /// Looks up an exported [`Extern`] value by name.
+    ///
+    /// This method will search the module for an export named `name` and return
+    /// the value, if found.
+    ///
+    /// Returns `None` if there was no export named `name`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `store` does not own this instance.
+    ///
+    /// # Why does `get_export` take a mutable context?
+    ///
+    /// This method requires a mutable context because an instance's exports are
+    /// lazily populated, and we cache them as they are accessed. This makes
+    /// instantiating a module faster, but also means this method requires a
+    /// mutable context.
+    pub fn get_export(&self, mut store: impl AsContextMut, name: &str) -> Option<Extern> {
+        let store = store.as_context_mut().0;
+        let data = &store[self.0];
+        let instance = store.instance(data.id);
+        let (export_name_index, _, &entity) = instance.module().exports.get_full(name)?;
+        self._get_export(store, entity, export_name_index)
+    }
+
+    /// Looks up an exported [`Extern`] value by a [`ModuleExport`] value.
+    ///
+    /// This is similar to [`Instance::get_export`] but uses a [`ModuleExport`] value to avoid
+    /// string lookups where possible. [`ModuleExport`]s can be obtained by calling
+    /// [`Module::get_export_index`] on the [`Module`] that this instance was instantiated with.
+    ///
+    /// This method will search the module for an export with a matching entity index and return
+    /// the value, if found.
+    ///
+    /// Returns `None` if there was no export with a matching entity index.
+    /// # Panics
+    ///
+    /// Panics if `store` does not own this instance.
+    pub fn get_module_export(
+        &self,
+        mut store: impl AsContextMut,
+        export: &ModuleExport,
+    ) -> Option<Extern> {
+        let store = store.as_context_mut().0;
+
+        // Verify the `ModuleExport` matches the module used in this instance.
+        if self._module(store).id() != export.module {
+            return None;
+        }
+
+        self._get_export(store, export.entity, export.export_name_index)
+    }
+
+    fn _get_export(
+        &self,
+        store: &mut StoreOpaque,
+        entity: EntityIndex,
+        export_name_index: usize,
+    ) -> Option<Extern> {
+        // Instantiated instances will lazily fill in exports, so we process
+        // all that lazy logic here.
+        let data = &store[self.0];
+
+        if let Some(export) = &data.exports[export_name_index] {
+            return Some(export.clone());
+        }
+
+        let instance = store.instance_mut(data.id); // Reborrow the &mut InstanceHandle
+        let item =
+            unsafe { Extern::from_wasmtime_export(instance.get_export_by_index(entity), store) };
+        let data = &mut store[self.0];
+        data.exports[export_name_index] = Some(item.clone());
+        Some(item)
+    }
+
+    /// Looks up an exported [`Func`] value by name.
+    ///
+    /// Returns `None` if there was no export named `name`, or if there was but
+    /// it wasn't a function.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `store` does not own this instance.
+    pub fn get_func(&self, store: impl AsContextMut, name: &str) -> Option<Func> {
+        self.get_export(store, name)?.into_func()
+    }
+
+    /// Looks up an exported [`Func`] value by name and with its type.
+    ///
+    /// This function is a convenience wrapper over [`Instance::get_func`] and
+    /// [`Func::typed`]. For more information see the linked documentation.
+    ///
+    /// Returns an error if `name` isn't a function export or if the export's
+    /// type did not match `Params` or `Results`
+    ///
+    /// # Panics
+    ///
+    /// Panics if `store` does not own this instance.
+    pub fn get_typed_func<Params, Results>(
+        &self,
+        mut store: impl AsContextMut,
+        name: &str,
+    ) -> Result<TypedFunc<Params, Results>>
+    where
+        Params: crate::WasmParams,
+        Results: crate::WasmResults,
+    {
+        let f = self
+            .get_export(store.as_context_mut(), name)
+            .and_then(|f| f.into_func())
+            .ok_or_else(|| anyhow!("failed to find function export `{}`", name))?;
+        Ok(f.typed::<Params, Results>(store)
+            .with_context(|| format!("failed to convert function `{name}` to given type"))?)
+    }
+
+    /// Looks up an exported [`Table`] value by name.
+    ///
+    /// Returns `None` if there was no export named `name`, or if there was but
+    /// it wasn't a table.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `store` does not own this instance.
+    pub fn get_table(&self, store: impl AsContextMut, name: &str) -> Option<Table> {
+        self.get_export(store, name)?.into_table()
+    }
+
+    /// Looks up an exported [`Memory`] value by name.
+    ///
+    /// Returns `None` if there was no export named `name`, or if there was but
+    /// it wasn't a memory.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `store` does not own this instance.
+    pub fn get_memory(&self, store: impl AsContextMut, name: &str) -> Option<Memory> {
+        self.get_export(store, name)?.into_memory()
+    }
+
+    /// Looks up an exported [`SharedMemory`] value by name.
+    ///
+    /// Returns `None` if there was no export named `name`, or if there was but
+    /// it wasn't a shared memory.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `store` does not own this instance.
+    pub fn get_shared_memory(
+        &self,
+        mut store: impl AsContextMut,
+        name: &str,
+    ) -> Option<SharedMemory> {
+        let mut store = store.as_context_mut();
+        self.get_export(&mut store, name)?.into_shared_memory()
+    }
+
+    /// Looks up an exported [`Global`] value by name.
+    ///
+    /// Returns `None` if there was no export named `name`, or if there was but
+    /// it wasn't a global.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `store` does not own this instance.
+    pub fn get_global(&self, store: impl AsContextMut, name: &str) -> Option<Global> {
+        self.get_export(store, name)?.into_global()
+    }
+
+    #[cfg(feature = "component-model")]
+    pub(crate) fn id(&self, store: &StoreOpaque) -> InstanceId {
+        store[self.0].id
+    }
+
+    /// Get all globals within this instance.
+    ///
+    /// Returns both import and defined globals.
+    ///
+    /// Returns both exported and non-exported globals.
+    ///
+    /// Gives access to the full globals space.
+    pub(crate) fn all_globals<'a>(
+        &'a self,
+        store: &'a mut StoreOpaque,
+    ) -> impl ExactSizeIterator<Item = (GlobalIndex, Global)> + 'a {
+        let data = &store[self.0];
+        let instance = store.instance_mut(data.id);
+        instance
+            .all_globals()
+            .collect::<Vec<_>>()
+            .into_iter()
+            .map(|(i, g)| (i, unsafe { Global::from_wasmtime_global(g, store) }))
+    }
+
+    /// Get all memories within this instance.
+    ///
+    /// Returns both import and defined memories.
+    ///
+    /// Returns both exported and non-exported memories.
+    ///
+    /// Gives access to the full memories space.
+    pub(crate) fn all_memories<'a>(
+        &'a self,
+        store: &'a mut StoreOpaque,
+    ) -> impl ExactSizeIterator<Item = (MemoryIndex, Memory)> + 'a {
+        let data = &store[self.0];
+        let instance = store.instance_mut(data.id);
+        instance
+            .all_memories()
+            .collect::<Vec<_>>()
+            .into_iter()
+            .map(|(i, m)| (i, unsafe { Memory::from_wasmtime_memory(m, store) }))
+    }
+}
+
+pub(crate) struct OwnedImports {
+    functions: PrimaryMap<FuncIndex, VMFunctionImport>,
+    tables: PrimaryMap<TableIndex, VMTableImport>,
+    memories: PrimaryMap<MemoryIndex, VMMemoryImport>,
+    globals: PrimaryMap<GlobalIndex, VMGlobalImport>,
+}
+
+impl OwnedImports {
+    fn new(module: &Module) -> OwnedImports {
+        let mut ret = OwnedImports::empty();
+        ret.reserve(module);
+        return ret;
+    }
+
+    pub(crate) fn empty() -> OwnedImports {
+        OwnedImports {
+            functions: PrimaryMap::new(),
+            tables: PrimaryMap::new(),
+            memories: PrimaryMap::new(),
+            globals: PrimaryMap::new(),
+        }
+    }
+
+    pub(crate) fn reserve(&mut self, module: &Module) {
+        let raw = module.compiled_module().module();
+        self.functions.reserve(raw.num_imported_funcs);
+        self.tables.reserve(raw.num_imported_tables);
+        self.memories.reserve(raw.num_imported_memories);
+        self.globals.reserve(raw.num_imported_globals);
+    }
+
+    #[cfg(feature = "component-model")]
+    pub(crate) fn clear(&mut self) {
+        self.functions.clear();
+        self.tables.clear();
+        self.memories.clear();
+        self.globals.clear();
+    }
+
+    fn push(&mut self, item: &Extern, store: &mut StoreOpaque, module: &Module) {
+        match item {
+            Extern::Func(i) => {
+                self.functions.push(i.vmimport(store, module));
+            }
+            Extern::Global(i) => {
+                self.globals.push(i.vmimport(store));
+            }
+            Extern::Table(i) => {
+                self.tables.push(i.vmimport(store));
+            }
+            Extern::Memory(i) => {
+                self.memories.push(i.vmimport(store));
+            }
+            Extern::SharedMemory(i) => {
+                self.memories.push(i.vmimport(store));
+            }
+        }
+    }
+
+    /// Note that this is unsafe as the validity of `item` is not verified and
+    /// it contains a bunch of raw pointers.
+    #[cfg(feature = "component-model")]
+    pub(crate) unsafe fn push_export(&mut self, item: &crate::runtime::vm::Export) {
+        match item {
+            crate::runtime::vm::Export::Function(f) => {
+                let f = f.func_ref.as_ref();
+                self.functions.push(VMFunctionImport {
+                    wasm_call: f.wasm_call.unwrap(),
+                    array_call: f.array_call,
+                    vmctx: f.vmctx,
+                });
+            }
+            crate::runtime::vm::Export::Global(g) => {
+                self.globals.push(VMGlobalImport { from: g.definition });
+            }
+            crate::runtime::vm::Export::Table(t) => {
+                self.tables.push(VMTableImport {
+                    from: t.definition,
+                    vmctx: t.vmctx,
+                });
+            }
+            crate::runtime::vm::Export::Memory(m) => {
+                self.memories.push(VMMemoryImport {
+                    from: m.definition,
+                    vmctx: m.vmctx,
+                    index: m.index,
+                });
+            }
+        }
+    }
+
+    pub(crate) fn as_ref(&self) -> Imports<'_> {
+        Imports {
+            tables: self.tables.values().as_slice(),
+            globals: self.globals.values().as_slice(),
+            memories: self.memories.values().as_slice(),
+            functions: self.functions.values().as_slice(),
+        }
+    }
+}
+
+/// An instance, pre-instantiation, that is ready to be instantiated.
+///
+/// This structure represents an instance *just before* it was instantiated,
+/// after all type-checking and imports have been resolved. The only thing left
+/// to do for this instance is to actually run the process of instantiation.
+///
+/// Note that an `InstancePre` may not be tied to any particular [`Store`] if
+/// none of the imports it closed over are tied to any particular [`Store`].
+///
+/// This structure is created through the [`Linker::instantiate_pre`] method,
+/// which also has some more information and examples.
+///
+/// [`Store`]: crate::Store
+/// [`Linker::instantiate_pre`]: crate::Linker::instantiate_pre
+pub struct InstancePre<T> {
+    module: Module,
+
+    /// The items which this `InstancePre` use to instantiate the `module`
+    /// provided, passed to `Instance::new_started` after inserting them into a
+    /// `Store`.
+    ///
+    /// Note that this is stored as an `Arc<[T]>` to quickly move a strong
+    /// reference to everything internally into a `Store<T>` without having to
+    /// clone each individual item.
+    items: Arc<[Definition]>,
+
+    /// A count of `Definition::HostFunc` entries in `items` above to
+    /// preallocate space in a `Store` up front for all entries to be inserted.
+    host_funcs: usize,
+
+    /// The `VMFuncRef`s for the functions in `items` that do not
+    /// have a `wasm_call` trampoline. We pre-allocate and pre-patch these
+    /// `VMFuncRef`s so that we don't have to do it at
+    /// instantiation time.
+    ///
+    /// This is an `Arc<[T]>` for the same reason as `items`.
+    func_refs: Arc<[VMFuncRef]>,
+
+    _marker: core::marker::PhantomData<fn() -> T>,
+}
+
+/// InstancePre's clone does not require T: Clone
+impl<T> Clone for InstancePre<T> {
+    fn clone(&self) -> Self {
+        Self {
+            module: self.module.clone(),
+            items: self.items.clone(),
+            host_funcs: self.host_funcs,
+            func_refs: self.func_refs.clone(),
+            _marker: self._marker,
+        }
+    }
+}
+
+impl<T> InstancePre<T> {
+    /// Creates a new `InstancePre` which type-checks the `items` provided and
+    /// on success is ready to instantiate a new instance.
+    ///
+    /// # Unsafety
+    ///
+    /// This method is unsafe as the `T` of the `InstancePre<T>` is not
+    /// guaranteed to be the same as the `T` within the `Store`, the caller must
+    /// verify that.
+    pub(crate) unsafe fn new(module: &Module, items: Vec<Definition>) -> Result<InstancePre<T>> {
+        typecheck(module, &items, |cx, ty, item| cx.definition(ty, &item.ty()))?;
+
+        let mut func_refs = vec![];
+        let mut host_funcs = 0;
+        for item in &items {
+            match item {
+                Definition::Extern(_, _) => {}
+                Definition::HostFunc(f) => {
+                    host_funcs += 1;
+                    if f.func_ref().wasm_call.is_none() {
+                        // `f` needs its `VMFuncRef::wasm_call` patched with a
+                        // Wasm-to-native trampoline.
+                        debug_assert!(matches!(f.host_ctx(), crate::HostContext::Array(_)));
+                        func_refs.push(VMFuncRef {
+                            wasm_call: module.wasm_to_array_trampoline(f.sig_index()),
+                            ..*f.func_ref()
+                        });
+                    }
+                }
+            }
+        }
+
+        Ok(InstancePre {
+            module: module.clone(),
+            items: items.into(),
+            host_funcs,
+            func_refs: func_refs.into(),
+            _marker: core::marker::PhantomData,
+        })
+    }
+
+    /// Returns a reference to the module that this [`InstancePre`] will be
+    /// instantiating.
+    pub fn module(&self) -> &Module {
+        &self.module
+    }
+
+    /// Instantiates this instance, creating a new instance within the provided
+    /// `store`.
+    ///
+    /// This function will run the actual process of instantiation to
+    /// completion. This will use all of the previously-closed-over items as
+    /// imports to instantiate the module that this was originally created with.
+    ///
+    /// For more information about instantiation see [`Instance::new`].
+    ///
+    /// # Panics
+    ///
+    /// Panics if any import closed over by this [`InstancePre`] isn't owned by
+    /// `store`, or if `store` has async support enabled. Additionally this
+    /// function will panic if the `store` provided comes from a different
+    /// [`Engine`] than the [`InstancePre`] originally came from.
+    pub fn instantiate(&self, mut store: impl AsContextMut<Data = T>) -> Result<Instance> {
+        let mut store = store.as_context_mut();
+        let imports = pre_instantiate_raw(
+            &mut store.0,
+            &self.module,
+            &self.items,
+            self.host_funcs,
+            &self.func_refs,
+        )?;
+
+        // This unsafety should be handled by the type-checking performed by the
+        // constructor of `InstancePre` to assert that all the imports we're passing
+        // in match the module we're instantiating.
+        unsafe { Instance::new_started(&mut store, &self.module, imports.as_ref()) }
+    }
+
+    /// Creates a new instance, running the start function asynchronously
+    /// instead of inline.
+    ///
+    /// For more information about asynchronous instantiation see the
+    /// documentation on [`Instance::new_async`].
+    ///
+    /// # Panics
+    ///
+    /// Panics if any import closed over by this [`InstancePre`] isn't owned by
+    /// `store`, or if `store` does not have async support enabled.
+    #[cfg(feature = "async")]
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl AsContextMut<Data = T>,
+    ) -> Result<Instance>
+    where
+        T: Send,
+    {
+        let mut store = store.as_context_mut();
+        let imports = pre_instantiate_raw(
+            &mut store.0,
+            &self.module,
+            &self.items,
+            self.host_funcs,
+            &self.func_refs,
+        )?;
+
+        // This unsafety should be handled by the type-checking performed by the
+        // constructor of `InstancePre` to assert that all the imports we're passing
+        // in match the module we're instantiating.
+        unsafe { Instance::new_started_async(&mut store, &self.module, imports.as_ref()).await }
+    }
+}
+
+/// Helper function shared between
+/// `InstancePre::{instantiate,instantiate_async}`
+///
+/// This is an out-of-line function to avoid the generic on `InstancePre` and
+/// get this compiled into the `wasmtime` crate to avoid having it monomorphized
+/// elsewhere.
+fn pre_instantiate_raw(
+    store: &mut StoreOpaque,
+    module: &Module,
+    items: &Arc<[Definition]>,
+    host_funcs: usize,
+    func_refs: &Arc<[VMFuncRef]>,
+) -> Result<OwnedImports> {
+    if host_funcs > 0 {
+        // Any linker-defined function of the `Definition::HostFunc` variant
+        // will insert a function into the store automatically as part of
+        // instantiation, so reserve space here to make insertion more efficient
+        // as it won't have to realloc during the instantiation.
+        store.store_data_mut().reserve_funcs(host_funcs);
+
+        // The usage of `to_extern_store_rooted` requires that the items are
+        // rooted via another means, which happens here by cloning the list of
+        // items into the store once. This avoids cloning each individual item
+        // below.
+        store.push_rooted_funcs(items.clone());
+        store.push_instance_pre_func_refs(func_refs.clone());
+    }
+
+    let mut func_refs = func_refs.iter().map(|f| NonNull::from(f));
+    let mut imports = OwnedImports::new(module);
+    for import in items.iter() {
+        if !import.comes_from_same_store(store) {
+            bail!("cross-`Store` instantiation is not currently supported");
+        }
+        // This unsafety should be encapsulated in the constructor of
+        // `InstancePre` where the `T` of the original item should match the
+        // `T` of the store. Additionally the rooting necessary has happened
+        // above.
+        let item = match import {
+            Definition::Extern(e, _) => e.clone(),
+            Definition::HostFunc(func) => unsafe {
+                func.to_func_store_rooted(
+                    store,
+                    if func.func_ref().wasm_call.is_none() {
+                        Some(func_refs.next().unwrap())
+                    } else {
+                        None
+                    },
+                )
+                .into()
+            },
+        };
+        imports.push(&item, store, module);
+    }
+
+    Ok(imports)
+}
+
+fn typecheck<I>(
+    module: &Module,
+    import_args: &[I],
+    check: impl Fn(&matching::MatchCx<'_>, &EntityType, &I) -> Result<()>,
+) -> Result<()> {
+    let env_module = module.compiled_module().module();
+    let expected_len = env_module.imports().count();
+    let actual_len = import_args.len();
+    if expected_len != actual_len {
+        bail!("expected {expected_len} imports, found {actual_len}");
+    }
+    let cx = matching::MatchCx::new(module.engine());
+    for ((name, field, mut expected_ty), actual) in env_module.imports().zip(import_args) {
+        expected_ty.canonicalize_for_runtime_usage(&mut |module_index| {
+            module.signatures().shared_type(module_index).unwrap()
+        });
+
+        check(&cx, &expected_ty, actual)
+            .with_context(|| format!("incompatible import type for `{name}::{field}`"))?;
+    }
+    Ok(())
+}
diff --git a/crates/wasmtime/src/runtime/instantiate.rs b/crates/wasmtime/src/runtime/instantiate.rs
new file mode 100644
index 000000000000..a8abc8147c50
--- /dev/null
+++ b/crates/wasmtime/src/runtime/instantiate.rs
@@ -0,0 +1,332 @@
+//! Define the `instantiate` function, which takes a byte array containing an
+//! encoded wasm module and returns a live wasm instance. Also, define
+//! `CompiledModule` to allow compiling and instantiating to be done as separate
+//! steps.
+
+use crate::prelude::*;
+use crate::runtime::vm::{CompiledModuleId, MmapVec};
+use crate::{code_memory::CodeMemory, profiling_agent::ProfilingAgent};
+use alloc::sync::Arc;
+use core::str;
+use wasmtime_environ::{
+    CompiledFunctionInfo, CompiledModuleInfo, DefinedFuncIndex, FuncIndex, FunctionLoc,
+    FunctionName, Metadata, Module, ModuleInternedTypeIndex, PrimaryMap, StackMapInformation,
+    WasmFunctionInfo,
+};
+
+/// A compiled wasm module, ready to be instantiated.
+pub struct CompiledModule {
+    module: Arc<Module>,
+    funcs: PrimaryMap<DefinedFuncIndex, CompiledFunctionInfo>,
+    wasm_to_array_trampolines: Vec<(ModuleInternedTypeIndex, FunctionLoc)>,
+    meta: Metadata,
+    code_memory: Arc<CodeMemory>,
+    #[cfg(feature = "debug-builtins")]
+    dbg_jit_registration: Option<crate::runtime::vm::GdbJitImageRegistration>,
+    /// A unique ID used to register this module with the engine.
+    unique_id: CompiledModuleId,
+    func_names: Vec<FunctionName>,
+}
+
+impl CompiledModule {
+    /// Creates `CompiledModule` directly from a precompiled artifact.
+    ///
+    /// The `code_memory` argument is expected to be the result of a previous
+    /// call to `ObjectBuilder::finish` above. This is an ELF image, at this
+    /// time, which contains all necessary information to create a
+    /// `CompiledModule` from a compilation.
+    ///
+    /// This method also takes `info`, an optionally-provided deserialization
+    /// of the artifacts' compilation metadata section. If this information is
+    /// not provided then the information will be
+    /// deserialized from the image of the compilation artifacts. Otherwise it
+    /// will be assumed to be what would otherwise happen if the section were
+    /// to be deserialized.
+    ///
+    /// The `profiler` argument here is used to inform JIT profiling runtimes
+    /// about new code that is loaded.
+    pub fn from_artifacts(
+        code_memory: Arc<CodeMemory>,
+        info: CompiledModuleInfo,
+        profiler: &dyn ProfilingAgent,
+    ) -> Result<Self> {
+        let mut ret = Self {
+            module: Arc::new(info.module),
+            funcs: info.funcs,
+            wasm_to_array_trampolines: info.wasm_to_array_trampolines,
+            #[cfg(feature = "debug-builtins")]
+            dbg_jit_registration: None,
+            code_memory,
+            meta: info.meta,
+            unique_id: CompiledModuleId::new(),
+            func_names: info.func_names,
+        };
+        ret.register_debug_and_profiling(profiler)?;
+
+        Ok(ret)
+    }
+
+    fn register_debug_and_profiling(&mut self, profiler: &dyn ProfilingAgent) -> Result<()> {
+        #[cfg(feature = "debug-builtins")]
+        if self.meta.native_debug_info_present {
+            let text = self.text();
+            let bytes = crate::debug::create_gdbjit_image(
+                self.mmap().to_vec(),
+                (text.as_ptr(), text.len()),
+            )
+            .context("failed to create jit image for gdb")?;
+            let reg = crate::runtime::vm::GdbJitImageRegistration::register(bytes);
+            self.dbg_jit_registration = Some(reg);
+        }
+        profiler.register_module(&self.code_memory.mmap()[..], &|addr| {
+            let (idx, _) = self.func_by_text_offset(addr)?;
+            let idx = self.module.func_index(idx);
+            let name = self.func_name(idx)?;
+            let mut demangled = String::new();
+            wasmtime_environ::demangle_function_name(&mut demangled, name).unwrap();
+            Some(demangled)
+        });
+        Ok(())
+    }
+
+    /// Get this module's unique ID. It is unique with respect to a
+    /// single allocator (which is ordinarily held on a Wasm engine).
+    pub fn unique_id(&self) -> CompiledModuleId {
+        self.unique_id
+    }
+
+    /// Returns the underlying memory which contains the compiled module's
+    /// image.
+    pub fn mmap(&self) -> &MmapVec {
+        self.code_memory.mmap()
+    }
+
+    /// Returns the underlying owned mmap of this compiled image.
+    pub fn code_memory(&self) -> &Arc<CodeMemory> {
+        &self.code_memory
+    }
+
+    /// Returns the text section of the ELF image for this compiled module.
+    ///
+    /// This memory should have the read/execute permissions.
+    #[inline]
+    pub fn text(&self) -> &[u8] {
+        self.code_memory.text()
+    }
+
+    /// Return a reference-counting pointer to a module.
+    pub fn module(&self) -> &Arc<Module> {
+        &self.module
+    }
+
+    /// Looks up the `name` section name for the function index `idx`, if one
+    /// was specified in the original wasm module.
+    pub fn func_name(&self, idx: FuncIndex) -> Option<&str> {
+        // Find entry for `idx`, if present.
+        let i = self.func_names.binary_search_by_key(&idx, |n| n.idx).ok()?;
+        let name = &self.func_names[i];
+
+        // Here we `unwrap` the `from_utf8` but this can theoretically be a
+        // `from_utf8_unchecked` if we really wanted since this section is
+        // guaranteed to only have valid utf-8 data. Until it's a problem it's
+        // probably best to double-check this though.
+        let data = self.code_memory().func_name_data();
+        Some(str::from_utf8(&data[name.offset as usize..][..name.len as usize]).unwrap())
+    }
+
+    /// Return a reference to a mutable module (if possible).
+    pub fn module_mut(&mut self) -> Option<&mut Module> {
+        Arc::get_mut(&mut self.module)
+    }
+
+    /// Returns an iterator over all functions defined within this module with
+    /// their index and their body in memory.
+    #[inline]
+    pub fn finished_functions(
+        &self,
+    ) -> impl ExactSizeIterator<Item = (DefinedFuncIndex, &[u8])> + '_ {
+        self.funcs
+            .iter()
+            .map(move |(i, _)| (i, self.finished_function(i)))
+    }
+
+    /// Returns the body of the function that `index` points to.
+    #[inline]
+    pub fn finished_function(&self, index: DefinedFuncIndex) -> &[u8] {
+        let loc = self.funcs[index].wasm_func_loc;
+        &self.text()[loc.start as usize..][..loc.length as usize]
+    }
+
+    /// Get the array-to-Wasm trampoline for the function `index` points to.
+    ///
+    /// If the function `index` points to does not escape, then `None` is
+    /// returned.
+    ///
+    /// These trampolines are used for array callers (e.g. `Func::new`)
+    /// calling Wasm callees.
+    pub fn array_to_wasm_trampoline(&self, index: DefinedFuncIndex) -> Option<&[u8]> {
+        let loc = self.funcs[index].array_to_wasm_trampoline?;
+        Some(&self.text()[loc.start as usize..][..loc.length as usize])
+    }
+
+    /// Get the Wasm-to-array trampoline for the given signature.
+    ///
+    /// These trampolines are used for filling in
+    /// `VMFuncRef::wasm_call` for `Func::wrap`-style host funcrefs
+    /// that don't have access to a compiler when created.
+    pub fn wasm_to_array_trampoline(&self, signature: ModuleInternedTypeIndex) -> &[u8] {
+        let idx = match self
+            .wasm_to_array_trampolines
+            .binary_search_by_key(&signature, |entry| entry.0)
+        {
+            Ok(idx) => idx,
+            Err(_) => panic!("missing trampoline for {signature:?}"),
+        };
+
+        let (_, loc) = self.wasm_to_array_trampolines[idx];
+        &self.text()[loc.start as usize..][..loc.length as usize]
+    }
+
+    /// Returns the stack map information for all functions defined in this
+    /// module.
+    ///
+    /// The iterator returned iterates over the span of the compiled function in
+    /// memory with the stack maps associated with those bytes.
+    pub fn stack_maps(&self) -> impl Iterator<Item = (&[u8], &[StackMapInformation])> {
+        self.finished_functions().map(|(_, f)| f).zip(
+            self.funcs
+                .values()
+                .map(|f| &f.wasm_func_info.stack_maps[..]),
+        )
+    }
+
+    /// Lookups a defined function by a program counter value.
+    ///
+    /// Returns the defined function index and the relative address of
+    /// `text_offset` within the function itself.
+    pub fn func_by_text_offset(&self, text_offset: usize) -> Option<(DefinedFuncIndex, u32)> {
+        let text_offset = u32::try_from(text_offset).unwrap();
+
+        let index = match self.funcs.binary_search_values_by_key(&text_offset, |e| {
+            debug_assert!(e.wasm_func_loc.length > 0);
+            // Return the inclusive "end" of the function
+            e.wasm_func_loc.start + e.wasm_func_loc.length - 1
+        }) {
+            Ok(k) => {
+                // Exact match, pc is at the end of this function
+                k
+            }
+            Err(k) => {
+                // Not an exact match, k is where `pc` would be "inserted"
+                // Since we key based on the end, function `k` might contain `pc`,
+                // so we'll validate on the range check below
+                k
+            }
+        };
+
+        let CompiledFunctionInfo { wasm_func_loc, .. } = self.funcs.get(index)?;
+        let start = wasm_func_loc.start;
+        let end = wasm_func_loc.start + wasm_func_loc.length;
+
+        if text_offset < start || end < text_offset {
+            return None;
+        }
+
+        Some((index, text_offset - wasm_func_loc.start))
+    }
+
+    /// Gets the function location information for a given function index.
+    pub fn func_loc(&self, index: DefinedFuncIndex) -> &FunctionLoc {
+        &self
+            .funcs
+            .get(index)
+            .expect("defined function should be present")
+            .wasm_func_loc
+    }
+
+    /// Gets the function information for a given function index.
+    pub fn wasm_func_info(&self, index: DefinedFuncIndex) -> &WasmFunctionInfo {
+        &self
+            .funcs
+            .get(index)
+            .expect("defined function should be present")
+            .wasm_func_info
+    }
+
+    /// Creates a new symbolication context which can be used to further
+    /// symbolicate stack traces.
+    ///
+    /// Basically this makes a thing which parses debuginfo and can tell you
+    /// what filename and line number a wasm pc comes from.
+    #[cfg(feature = "addr2line")]
+    pub fn symbolize_context(&self) -> Result<Option<SymbolizeContext<'_>>> {
+        use gimli::EndianSlice;
+        if !self.meta.has_wasm_debuginfo {
+            return Ok(None);
+        }
+        let dwarf = gimli::Dwarf::load(|id| -> Result<_> {
+            // Lookup the `id` in the `dwarf` array prepared for this module
+            // during module serialization where it's sorted by the `id` key. If
+            // found this is a range within the general module's concatenated
+            // dwarf section which is extracted here, otherwise it's just an
+            // empty list to represent that it's not present.
+            let data = self
+                .meta
+                .dwarf
+                .binary_search_by_key(&(id as u8), |(id, _)| *id)
+                .map(|i| {
+                    let (_, range) = &self.meta.dwarf[i];
+                    &self.code_memory().dwarf()[range.start as usize..range.end as usize]
+                })
+                .unwrap_or(&[]);
+            Ok(EndianSlice::new(data, gimli::LittleEndian))
+        })?;
+        let cx = addr2line::Context::from_dwarf(dwarf)
+            .context("failed to create addr2line dwarf mapping context")?;
+        Ok(Some(SymbolizeContext {
+            inner: cx,
+            code_section_offset: self.meta.code_section_offset,
+        }))
+    }
+
+    /// Returns whether the original wasm module had unparsed debug information
+    /// based on the tunables configuration.
+    pub fn has_unparsed_debuginfo(&self) -> bool {
+        self.meta.has_unparsed_debuginfo
+    }
+
+    /// Indicates whether this module came with n address map such that lookups
+    /// via `wasmtime_environ::lookup_file_pos` will succeed.
+    ///
+    /// If this function returns `false` then `lookup_file_pos` will always
+    /// return `None`.
+    pub fn has_address_map(&self) -> bool {
+        !self.code_memory.address_map_data().is_empty()
+    }
+}
+
+#[cfg(feature = "addr2line")]
+type Addr2LineContext<'a> = addr2line::Context<gimli::EndianSlice<'a, gimli::LittleEndian>>;
+
+/// A context which contains dwarf debug information to translate program
+/// counters back to filenames and line numbers.
+#[cfg(feature = "addr2line")]
+pub struct SymbolizeContext<'a> {
+    inner: Addr2LineContext<'a>,
+    code_section_offset: u64,
+}
+
+#[cfg(feature = "addr2line")]
+impl<'a> SymbolizeContext<'a> {
+    /// Returns access to the [`addr2line::Context`] which can be used to query
+    /// frame information with.
+    pub fn addr2line(&self) -> &Addr2LineContext<'a> {
+        &self.inner
+    }
+
+    /// Returns the offset of the code section in the original wasm file, used
+    /// to calculate lookup values into the DWARF.
+    pub fn code_section_offset(&self) -> u64 {
+        self.code_section_offset
+    }
+}
diff --git a/crates/wasmtime/src/limits.rs b/crates/wasmtime/src/runtime/limits.rs
similarity index 99%
rename from crates/wasmtime/src/limits.rs
rename to crates/wasmtime/src/runtime/limits.rs
index 5d0f934a5b32..76faf312cd21 100644
--- a/crates/wasmtime/src/limits.rs
+++ b/crates/wasmtime/src/runtime/limits.rs
@@ -1,4 +1,4 @@
-use anyhow::{bail, Result};
+use crate::prelude::*;
 
 /// Value returned by [`ResourceLimiter::instances`] default method
 pub const DEFAULT_INSTANCE_LIMIT: usize = 10000;
diff --git a/crates/wasmtime/src/runtime/linker.rs b/crates/wasmtime/src/runtime/linker.rs
new file mode 100644
index 000000000000..c0a8517a704b
--- /dev/null
+++ b/crates/wasmtime/src/runtime/linker.rs
@@ -0,0 +1,1498 @@
+use crate::func::HostFunc;
+use crate::instance::InstancePre;
+use crate::store::StoreOpaque;
+use crate::{prelude::*, IntoFunc};
+use crate::{
+    AsContext, AsContextMut, Caller, Engine, Extern, ExternType, Func, FuncType, ImportType,
+    Instance, Module, StoreContextMut, Val, ValRaw, ValType, WasmTyList,
+};
+use alloc::sync::Arc;
+use core::fmt;
+#[cfg(feature = "async")]
+use core::future::Future;
+use core::marker;
+#[cfg(feature = "async")]
+use core::pin::Pin;
+use hashbrown::hash_map::{Entry, HashMap};
+use log::warn;
+
+/// Structure used to link wasm modules/instances together.
+///
+/// This structure is used to assist in instantiating a [`Module`]. A [`Linker`]
+/// is a way of performing name resolution to make instantiating a module easier
+/// than specifying positional imports to [`Instance::new`]. [`Linker`] is a
+/// name-based resolver where names are dynamically defined and then used to
+/// instantiate a [`Module`].
+///
+/// An important method is [`Linker::instantiate`] which takes a module to
+/// instantiate into the provided store. This method will automatically select
+/// all the right imports for the [`Module`] to be instantiated, and will
+/// otherwise return an error if an import isn't satisfied.
+///
+/// ## Name Resolution
+///
+/// As mentioned previously, `Linker` is a form of name resolver. It will be
+/// using the string-based names of imports on a module to attempt to select a
+/// matching item to hook up to it. This name resolution has two-levels of
+/// namespaces, a module level and a name level. Each item is defined within a
+/// module and then has its own name. This basically follows the wasm standard
+/// for modularization.
+///
+/// Names in a `Linker` cannot be defined twice, but allowing duplicates by
+/// shadowing the previous definition can be controlled with the
+/// [`Linker::allow_shadowing`] method.
+///
+/// ## Commands and Reactors
+///
+/// The [`Linker`] type provides conveniences for working with WASI Commands and
+/// Reactors through the [`Linker::module`] method. This will automatically
+/// handle instantiation and calling `_start` and such as appropriate
+/// depending on the inferred type of module.
+///
+/// ## Type parameter `T`
+///
+/// It's worth pointing out that the type parameter `T` on [`Linker<T>`] does
+/// not represent that `T` is stored within a [`Linker`]. Rather the `T` is used
+/// to ensure that linker-defined functions and stores instantiated into all use
+/// the same matching `T` as host state.
+///
+/// ## Multiple `Store`s
+///
+/// The [`Linker`] type is designed to be compatible, in some scenarios, with
+/// instantiation in multiple [`Store`]s. Specifically host-defined functions
+/// created in [`Linker`] with [`Linker::func_new`], [`Linker::func_wrap`], and
+/// their async versions are compatible to instantiate into any [`Store`]. This
+/// enables programs which want to instantiate lots of modules to create one
+/// [`Linker`] value at program start up and use that continuously for each
+/// [`Store`] created over the lifetime of the program.
+///
+/// Note that once [`Store`]-owned items, such as [`Global`], are defined within
+/// a [`Linker`] then it is no longer compatible with any [`Store`]. At that
+/// point only the [`Store`] that owns the [`Global`] can be used to instantiate
+/// modules.
+///
+/// ## Multiple `Engine`s
+///
+/// The [`Linker`] type is not compatible with usage between multiple [`Engine`]
+/// values. An [`Engine`] is provided when a [`Linker`] is created and only
+/// stores and items which originate from that [`Engine`] can be used with this
+/// [`Linker`]. If more than one [`Engine`] is used with a [`Linker`] then that
+/// may cause a panic at runtime, similar to how if a [`Func`] is used with the
+/// wrong [`Store`] that can also panic at runtime.
+///
+/// [`Store`]: crate::Store
+/// [`Global`]: crate::Global
+pub struct Linker<T> {
+    engine: Engine,
+    string2idx: HashMap<Arc<str>, usize>,
+    strings: Vec<Arc<str>>,
+    map: HashMap<ImportKey, Definition>,
+    allow_shadowing: bool,
+    allow_unknown_exports: bool,
+    _marker: marker::PhantomData<fn() -> T>,
+}
+
+impl<T> Clone for Linker<T> {
+    fn clone(&self) -> Linker<T> {
+        Linker {
+            engine: self.engine.clone(),
+            string2idx: self.string2idx.clone(),
+            strings: self.strings.clone(),
+            map: self.map.clone(),
+            allow_shadowing: self.allow_shadowing,
+            allow_unknown_exports: self.allow_unknown_exports,
+            _marker: self._marker,
+        }
+    }
+}
+
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
+struct ImportKey {
+    name: usize,
+    module: usize,
+}
+
+#[derive(Clone)]
+pub(crate) enum Definition {
+    Extern(Extern, DefinitionType),
+    HostFunc(Arc<HostFunc>),
+}
+
+/// This is a sort of slimmed down `ExternType` which notably doesn't have a
+/// `FuncType`, which is an allocation, and additionally retains the current
+/// size of the table/memory.
+#[derive(Clone, Debug)]
+pub(crate) enum DefinitionType {
+    Func(wasmtime_environ::VMSharedTypeIndex),
+    Global(wasmtime_environ::Global),
+    // Note that tables and memories store not only the original type
+    // information but additionally the current size of the table/memory, as
+    // this is used during linking since the min size specified in the type may
+    // no longer be the current size of the table/memory.
+    Table(wasmtime_environ::Table, u32),
+    Memory(wasmtime_environ::Memory, u64),
+}
+
+impl<T> Linker<T> {
+    /// Creates a new [`Linker`].
+    ///
+    /// The linker will define functions within the context of the `engine`
+    /// provided and can only instantiate modules for a [`Store`][crate::Store]
+    /// that is also defined within the same [`Engine`]. Usage of stores with
+    /// different [`Engine`]s may cause a panic when used with this [`Linker`].
+    pub fn new(engine: &Engine) -> Linker<T> {
+        Linker {
+            engine: engine.clone(),
+            map: HashMap::new(),
+            string2idx: HashMap::new(),
+            strings: Vec::new(),
+            allow_shadowing: false,
+            allow_unknown_exports: false,
+            _marker: marker::PhantomData,
+        }
+    }
+
+    /// Returns the [`Engine`] this is connected to.
+    pub fn engine(&self) -> &Engine {
+        &self.engine
+    }
+
+    /// Configures whether this [`Linker`] will shadow previous duplicate
+    /// definitions of the same signature.
+    ///
+    /// By default a [`Linker`] will disallow duplicate definitions of the same
+    /// signature. This method, however, can be used to instead allow duplicates
+    /// and have the latest definition take precedence when linking modules.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let engine = Engine::default();
+    /// let mut linker = Linker::<()>::new(&engine);
+    /// linker.func_wrap("", "", || {})?;
+    ///
+    /// // by default, duplicates are disallowed
+    /// assert!(linker.func_wrap("", "", || {}).is_err());
+    ///
+    /// // but shadowing can be configured to be allowed as well
+    /// linker.allow_shadowing(true);
+    /// linker.func_wrap("", "", || {})?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn allow_shadowing(&mut self, allow: bool) -> &mut Self {
+        self.allow_shadowing = allow;
+        self
+    }
+
+    /// Configures whether this [`Linker`] will allow unknown exports from
+    /// command modules.
+    ///
+    /// By default a [`Linker`] will error when unknown exports are encountered
+    /// in a command module while using [`Linker::module`].
+    ///
+    /// This method can be used to allow unknown exports from command modules.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let engine = Engine::default();
+    /// # let module = Module::new(&engine, "(module)")?;
+    /// # let mut store = Store::new(&engine, ());
+    /// let mut linker = Linker::new(&engine);
+    /// linker.allow_unknown_exports(true);
+    /// linker.module(&mut store, "mod", &module)?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn allow_unknown_exports(&mut self, allow: bool) -> &mut Self {
+        self.allow_unknown_exports = allow;
+        self
+    }
+
+    /// Implement any imports of the given [`Module`] with a function which traps.
+    ///
+    /// By default a [`Linker`] will error when unknown imports are encountered
+    /// in a command module while using [`Linker::module`].
+    ///
+    /// This method can be used to allow unknown imports from command modules.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let engine = Engine::default();
+    /// # let module = Module::new(&engine, "(module (import \"unknown\" \"import\" (func)))")?;
+    /// # let mut store = Store::new(&engine, ());
+    /// let mut linker = Linker::new(&engine);
+    /// linker.define_unknown_imports_as_traps(&module)?;
+    /// linker.instantiate(&mut store, &module)?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn define_unknown_imports_as_traps(&mut self, module: &Module) -> anyhow::Result<()> {
+        for import in module.imports() {
+            if let Err(import_err) = self._get_by_import(&import) {
+                if let ExternType::Func(func_ty) = import_err.ty() {
+                    self.func_new(import.module(), import.name(), func_ty, move |_, _, _| {
+                        bail!(import_err.clone());
+                    })?;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// Implement any function imports of the [`Module`] with a function that
+    /// ignores its arguments and returns default values.
+    ///
+    /// Default values are either zero or null, depending on the value type.
+    ///
+    /// This method can be used to allow unknown imports from command modules.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let engine = Engine::default();
+    /// # let module = Module::new(&engine, "(module (import \"unknown\" \"import\" (func)))")?;
+    /// # let mut store = Store::new(&engine, ());
+    /// let mut linker = Linker::new(&engine);
+    /// linker.define_unknown_imports_as_default_values(&module)?;
+    /// linker.instantiate(&mut store, &module)?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn define_unknown_imports_as_default_values(
+        &mut self,
+        module: &Module,
+    ) -> anyhow::Result<()> {
+        for import in module.imports() {
+            if let Err(import_err) = self._get_by_import(&import) {
+                if let ExternType::Func(func_ty) = import_err.ty() {
+                    let result_tys: Vec<_> = func_ty.results().collect();
+
+                    for ty in &result_tys {
+                        if ty.as_ref().map_or(false, |r| !r.is_nullable()) {
+                            bail!("no default value exists for type `{ty}`")
+                        }
+                    }
+
+                    self.func_new(
+                        import.module(),
+                        import.name(),
+                        func_ty,
+                        move |_caller, _args, results| {
+                            for (result, ty) in results.iter_mut().zip(&result_tys) {
+                                *result = match ty {
+                                    ValType::I32 => Val::I32(0),
+                                    ValType::I64 => Val::I64(0),
+                                    ValType::F32 => Val::F32(0.0_f32.to_bits()),
+                                    ValType::F64 => Val::F64(0.0_f64.to_bits()),
+                                    ValType::V128 => Val::V128(0_u128.into()),
+                                    ValType::Ref(r) => {
+                                        debug_assert!(r.is_nullable());
+                                        Val::null_ref(r.heap_type())
+                                    }
+                                };
+                            }
+                            Ok(())
+                        },
+                    )?;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    /// Defines a new item in this [`Linker`].
+    ///
+    /// This method will add a new definition, by name, to this instance of
+    /// [`Linker`]. The `module` and `name` provided are what to name the
+    /// `item`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the `module` and `name` already identify an item
+    /// of the same type as the `item` provided and if shadowing is disallowed.
+    /// For more information see the documentation on [`Linker`].
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let engine = Engine::default();
+    /// # let mut store = Store::new(&engine, ());
+    /// let mut linker = Linker::new(&engine);
+    /// let ty = GlobalType::new(ValType::I32, Mutability::Const);
+    /// let global = Global::new(&mut store, ty, Val::I32(0x1234))?;
+    /// linker.define(&store, "host", "offset", global)?;
+    ///
+    /// let wat = r#"
+    ///     (module
+    ///         (import "host" "offset" (global i32))
+    ///         (memory 1)
+    ///         (data (global.get 0) "foo")
+    ///     )
+    /// "#;
+    /// let module = Module::new(&engine, wat)?;
+    /// linker.instantiate(&mut store, &module)?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn define(
+        &mut self,
+        store: impl AsContext<Data = T>,
+        module: &str,
+        name: &str,
+        item: impl Into<Extern>,
+    ) -> Result<&mut Self> {
+        let store = store.as_context();
+        let key = self.import_key(module, Some(name));
+        self.insert(key, Definition::new(store.0, item.into()))?;
+        Ok(self)
+    }
+
+    /// Same as [`Linker::define`], except only the name of the import is
+    /// provided, not a module name as well.
+    ///
+    /// This is only relevant when working with the module linking proposal
+    /// where one-level names are allowed (in addition to two-level names).
+    /// Otherwise this method need not be used.
+    pub fn define_name(
+        &mut self,
+        store: impl AsContext<Data = T>,
+        name: &str,
+        item: impl Into<Extern>,
+    ) -> Result<&mut Self> {
+        let store = store.as_context();
+        let key = self.import_key(name, None);
+        self.insert(key, Definition::new(store.0, item.into()))?;
+        Ok(self)
+    }
+
+    /// Creates a [`Func::new`]-style function named in this linker.
+    ///
+    /// For more information see [`Linker::func_wrap`].
+    ///
+    /// # Panics
+    ///
+    /// Panics if the given function type is not associated with the same engine
+    /// as this linker.
+    pub fn func_new(
+        &mut self,
+        module: &str,
+        name: &str,
+        ty: FuncType,
+        func: impl Fn(Caller<'_, T>, &[Val], &mut [Val]) -> Result<()> + Send + Sync + 'static,
+    ) -> Result<&mut Self> {
+        assert!(ty.comes_from_same_engine(self.engine()));
+        let func = HostFunc::new(&self.engine, ty, func);
+        let key = self.import_key(module, Some(name));
+        self.insert(key, Definition::HostFunc(Arc::new(func)))?;
+        Ok(self)
+    }
+
+    /// Creates a [`Func::new_unchecked`]-style function named in this linker.
+    ///
+    /// For more information see [`Linker::func_wrap`].
+    ///
+    /// # Panics
+    ///
+    /// Panics if the given function type is not associated with the same engine
+    /// as this linker.
+    pub unsafe fn func_new_unchecked(
+        &mut self,
+        module: &str,
+        name: &str,
+        ty: FuncType,
+        func: impl Fn(Caller<'_, T>, &mut [ValRaw]) -> Result<()> + Send + Sync + 'static,
+    ) -> Result<&mut Self> {
+        assert!(ty.comes_from_same_engine(self.engine()));
+        let func = HostFunc::new_unchecked(&self.engine, ty, func);
+        let key = self.import_key(module, Some(name));
+        self.insert(key, Definition::HostFunc(Arc::new(func)))?;
+        Ok(self)
+    }
+
+    /// Creates a [`Func::new_async`]-style function named in this linker.
+    ///
+    /// For more information see [`Linker::func_wrap`].
+    ///
+    /// # Panics
+    ///
+    /// This method panics in the following situations:
+    ///
+    /// * This linker is not associated with an [async
+    ///   config](crate::Config::async_support).
+    ///
+    /// * If the given function type is not associated with the same engine as
+    ///   this linker.
+    #[cfg(all(feature = "async", feature = "cranelift"))]
+    pub fn func_new_async<F>(
+        &mut self,
+        module: &str,
+        name: &str,
+        ty: FuncType,
+        func: F,
+    ) -> Result<&mut Self>
+    where
+        F: for<'a> Fn(
+                Caller<'a, T>,
+                &'a [Val],
+                &'a mut [Val],
+            ) -> Box<dyn Future<Output = Result<()>> + Send + 'a>
+            + Send
+            + Sync
+            + 'static,
+    {
+        assert!(
+            self.engine.config().async_support,
+            "cannot use `func_new_async` without enabling async support in the config"
+        );
+        assert!(ty.comes_from_same_engine(self.engine()));
+        self.func_new(module, name, ty, move |mut caller, params, results| {
+            let async_cx = caller
+                .store
+                .as_context_mut()
+                .0
+                .async_cx()
+                .expect("Attempt to spawn new function on dying fiber");
+            let mut future = Pin::from(func(caller, params, results));
+            match unsafe { async_cx.block_on(future.as_mut()) } {
+                Ok(Ok(())) => Ok(()),
+                Ok(Err(trap)) | Err(trap) => Err(trap),
+            }
+        })
+    }
+
+    /// Define a host function within this linker.
+    ///
+    /// For information about how the host function operates, see
+    /// [`Func::wrap`]. That includes information about translating Rust types
+    /// to WebAssembly native types.
+    ///
+    /// This method creates a host-provided function in this linker under the
+    /// provided name. This method is distinct in its capability to create a
+    /// [`Store`](crate::Store)-independent function. This means that the
+    /// function defined here can be used to instantiate instances in multiple
+    /// different stores, or in other words the function can be loaded into
+    /// different stores.
+    ///
+    /// Note that the capability mentioned here applies to all other
+    /// host-function-defining-methods on [`Linker`] as well. All of them can be
+    /// used to create instances of [`Func`] within multiple stores. In a
+    /// multithreaded program, for example, this means that the host functions
+    /// could be called concurrently if different stores are executing on
+    /// different threads.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the `module` and `name` already identify an item
+    /// of the same type as the `item` provided and if shadowing is disallowed.
+    /// For more information see the documentation on [`Linker`].
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let engine = Engine::default();
+    /// let mut linker = Linker::new(&engine);
+    /// linker.func_wrap("host", "double", |x: i32| x * 2)?;
+    /// linker.func_wrap("host", "log_i32", |x: i32| println!("{}", x))?;
+    /// linker.func_wrap("host", "log_str", |caller: Caller<'_, ()>, ptr: i32, len: i32| {
+    ///     // ...
+    /// })?;
+    ///
+    /// let wat = r#"
+    ///     (module
+    ///         (import "host" "double" (func (param i32) (result i32)))
+    ///         (import "host" "log_i32" (func (param i32)))
+    ///         (import "host" "log_str" (func (param i32 i32)))
+    ///     )
+    /// "#;
+    /// let module = Module::new(&engine, wat)?;
+    ///
+    /// // instantiate in multiple different stores
+    /// for _ in 0..10 {
+    ///     let mut store = Store::new(&engine, ());
+    ///     linker.instantiate(&mut store, &module)?;
+    /// }
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn func_wrap<Params, Args>(
+        &mut self,
+        module: &str,
+        name: &str,
+        func: impl IntoFunc<T, Params, Args>,
+    ) -> Result<&mut Self> {
+        let func = HostFunc::wrap(&self.engine, func);
+        let key = self.import_key(module, Some(name));
+        self.insert(key, Definition::HostFunc(Arc::new(func)))?;
+        Ok(self)
+    }
+
+    /// Asynchronous analog of [`Linker::func_wrap`].
+    #[cfg(feature = "async")]
+    pub fn func_wrap_async<F, Params: WasmTyList, Args: crate::WasmRet>(
+        &mut self,
+        module: &str,
+        name: &str,
+        func: F,
+    ) -> Result<&mut Self>
+    where
+        F: for<'a> Fn(Caller<'a, T>, Params) -> Box<dyn Future<Output = Args> + Send + 'a>
+            + Send
+            + Sync
+            + 'static,
+    {
+        assert!(
+            self.engine.config().async_support,
+            "cannot use `func_wrap_async` without enabling async support on the config",
+        );
+        let func = HostFunc::wrap_inner(
+            &self.engine,
+            move |mut caller: Caller<'_, T>, args: Params| {
+                let async_cx = caller
+                    .store
+                    .as_context_mut()
+                    .0
+                    .async_cx()
+                    .expect("Attempt to start async function on dying fiber");
+                let mut future = Pin::from(func(caller, args));
+                match unsafe { async_cx.block_on(future.as_mut()) } {
+                    Ok(ret) => ret.into_fallible(),
+                    Err(e) => Args::fallible_from_error(e),
+                }
+            },
+        );
+        let key = self.import_key(module, Some(name));
+        self.insert(key, Definition::HostFunc(Arc::new(func)))?;
+        Ok(self)
+    }
+
+    /// Convenience wrapper to define an entire [`Instance`] in this linker.
+    ///
+    /// This function is a convenience wrapper around [`Linker::define`] which
+    /// will define all exports on `instance` into this linker. The module name
+    /// for each export is `module_name`, and the name for each export is the
+    /// name in the instance itself.
+    ///
+    /// Note that when this API is used the [`Linker`] is no longer compatible
+    /// with multi-[`Store`][crate::Store] instantiation because the items
+    /// defined within this store will belong to the `store` provided, and only
+    /// the `store` provided.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the any item is redefined twice in this linker (for
+    /// example the same `module_name` was already defined) and shadowing is
+    /// disallowed, or if `instance` comes from a different
+    /// [`Store`](crate::Store) than this [`Linker`] originally was created
+    /// with.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `instance` does not belong to `store`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let engine = Engine::default();
+    /// # let mut store = Store::new(&engine, ());
+    /// let mut linker = Linker::new(&engine);
+    ///
+    /// // Instantiate a small instance...
+    /// let wat = r#"(module (func (export "run") ))"#;
+    /// let module = Module::new(&engine, wat)?;
+    /// let instance = linker.instantiate(&mut store, &module)?;
+    ///
+    /// // ... and inform the linker that the name of this instance is
+    /// // `instance1`. This defines the `instance1::run` name for our next
+    /// // module to use.
+    /// linker.instance(&mut store, "instance1", instance)?;
+    ///
+    /// let wat = r#"
+    ///     (module
+    ///         (import "instance1" "run" (func $instance1_run))
+    ///         (func (export "run")
+    ///             call $instance1_run
+    ///         )
+    ///     )
+    /// "#;
+    /// let module = Module::new(&engine, wat)?;
+    /// let instance = linker.instantiate(&mut store, &module)?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn instance(
+        &mut self,
+        mut store: impl AsContextMut<Data = T>,
+        module_name: &str,
+        instance: Instance,
+    ) -> Result<&mut Self> {
+        let mut store = store.as_context_mut();
+        let exports = instance
+            .exports(&mut store)
+            .map(|e| {
+                (
+                    self.import_key(module_name, Some(e.name())),
+                    e.into_extern(),
+                )
+            })
+            .collect::<Vec<_>>();
+        for (key, export) in exports {
+            self.insert(key, Definition::new(store.0, export))?;
+        }
+        Ok(self)
+    }
+
+    /// Define automatic instantiations of a [`Module`] in this linker.
+    ///
+    /// This automatically handles [Commands and Reactors] instantiation and
+    /// initialization.
+    ///
+    /// Exported functions of a Command module may be called directly, however
+    /// instead of having a single instance which is reused for each call,
+    /// each call creates a new instance, which lives for the duration of the
+    /// call. The imports of the Command are resolved once, and reused for
+    /// each instantiation, so all dependencies need to be present at the time
+    /// when `Linker::module` is called.
+    ///
+    /// For Reactors, a single instance is created, and an initialization
+    /// function is called, and then its exports may be called.
+    ///
+    /// Ordinary modules which don't declare themselves to be either Commands
+    /// or Reactors are treated as Reactors without any initialization calls.
+    ///
+    /// [Commands and Reactors]: https://github.com/WebAssembly/WASI/blob/main/legacy/application-abi.md#current-unstable-abi
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the any item is redefined twice in this linker (for
+    /// example the same `module_name` was already defined) and shadowing is
+    /// disallowed, if `instance` comes from a different
+    /// [`Store`](crate::Store) than this [`Linker`] originally was created
+    /// with, or if a Reactor initialization function traps.
+    ///
+    /// # Panics
+    ///
+    /// Panics if any item used to instantiate the provided [`Module`] is not
+    /// owned by `store`, or if the `store` provided comes from a different
+    /// [`Engine`] than this [`Linker`].
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let engine = Engine::default();
+    /// # let mut store = Store::new(&engine, ());
+    /// let mut linker = Linker::new(&engine);
+    ///
+    /// // Instantiate a small instance and inform the linker that the name of
+    /// // this instance is `instance1`. This defines the `instance1::run` name
+    /// // for our next module to use.
+    /// let wat = r#"(module (func (export "run") ))"#;
+    /// let module = Module::new(&engine, wat)?;
+    /// linker.module(&mut store, "instance1", &module)?;
+    ///
+    /// let wat = r#"
+    ///     (module
+    ///         (import "instance1" "run" (func $instance1_run))
+    ///         (func (export "run")
+    ///             call $instance1_run
+    ///         )
+    ///     )
+    /// "#;
+    /// let module = Module::new(&engine, wat)?;
+    /// let instance = linker.instantiate(&mut store, &module)?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// For a Command, a new instance is created for each call.
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let engine = Engine::default();
+    /// # let mut store = Store::new(&engine, ());
+    /// let mut linker = Linker::new(&engine);
+    ///
+    /// // Create a Command that attempts to count the number of times it is run, but is
+    /// // foiled by each call getting a new instance.
+    /// let wat = r#"
+    ///     (module
+    ///         (global $counter (mut i32) (i32.const 0))
+    ///         (func (export "_start")
+    ///             (global.set $counter (i32.add (global.get $counter) (i32.const 1)))
+    ///         )
+    ///         (func (export "read_counter") (result i32)
+    ///             (global.get $counter)
+    ///         )
+    ///     )
+    /// "#;
+    /// let module = Module::new(&engine, wat)?;
+    /// linker.module(&mut store, "commander", &module)?;
+    /// let run = linker.get_default(&mut store, "")?
+    ///     .typed::<(), ()>(&store)?
+    ///     .clone();
+    /// run.call(&mut store, ())?;
+    /// run.call(&mut store, ())?;
+    /// run.call(&mut store, ())?;
+    ///
+    /// let wat = r#"
+    ///     (module
+    ///         (import "commander" "_start" (func $commander_start))
+    ///         (import "commander" "read_counter" (func $commander_read_counter (result i32)))
+    ///         (func (export "run") (result i32)
+    ///             call $commander_start
+    ///             call $commander_start
+    ///             call $commander_start
+    ///             call $commander_read_counter
+    ///         )
+    ///     )
+    /// "#;
+    /// let module = Module::new(&engine, wat)?;
+    /// linker.module(&mut store, "", &module)?;
+    /// let run = linker.get(&mut store, "", "run").unwrap().into_func().unwrap();
+    /// let count = run.typed::<(), i32>(&store)?.call(&mut store, ())?;
+    /// assert_eq!(count, 0, "a Command should get a fresh instance on each invocation");
+    ///
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn module(
+        &mut self,
+        mut store: impl AsContextMut<Data = T>,
+        module_name: &str,
+        module: &Module,
+    ) -> Result<&mut Self>
+    where
+        T: 'static,
+    {
+        // NB: this is intended to function the same as `Linker::module_async`,
+        // they should be kept in sync.
+
+        // This assert isn't strictly necessary since it'll bottom out in the
+        // `HostFunc::to_func` method anyway. This is placed earlier for this
+        // function though to prevent the functions created here from delaying
+        // the panic until they're called.
+        assert!(
+            Engine::same(&self.engine, store.as_context().engine()),
+            "different engines for this linker and the store provided"
+        );
+        match ModuleKind::categorize(module)? {
+            ModuleKind::Command => {
+                self.command(
+                    store,
+                    module_name,
+                    module,
+                    |store, func_ty, export_name, instance_pre| {
+                        Func::new(
+                            store,
+                            func_ty.clone(),
+                            move |mut caller, params, results| {
+                                // Create a new instance for this command execution.
+                                let instance = instance_pre.instantiate(&mut caller)?;
+
+                                // `unwrap()` everything here because we know the instance contains a
+                                // function export with the given name and signature because we're
+                                // iterating over the module it was instantiated from.
+                                instance
+                                    .get_export(&mut caller, &export_name)
+                                    .unwrap()
+                                    .into_func()
+                                    .unwrap()
+                                    .call(&mut caller, params, results)?;
+
+                                Ok(())
+                            },
+                        )
+                    },
+                )
+            }
+            ModuleKind::Reactor => {
+                let instance = self.instantiate(&mut store, &module)?;
+
+                if let Some(export) = instance.get_export(&mut store, "_initialize") {
+                    if let Extern::Func(func) = export {
+                        func.typed::<(), ()>(&store)
+                            .and_then(|f| f.call(&mut store, ()).map_err(Into::into))
+                            .context("calling the Reactor initialization function")?;
+                    }
+                }
+
+                self.instance(store, module_name, instance)
+            }
+        }
+    }
+
+    /// Define automatic instantiations of a [`Module`] in this linker.
+    ///
+    /// This is the same as [`Linker::module`], except for async `Store`s.
+    #[cfg(all(feature = "async", feature = "cranelift"))]
+    pub async fn module_async(
+        &mut self,
+        mut store: impl AsContextMut<Data = T>,
+        module_name: &str,
+        module: &Module,
+    ) -> Result<&mut Self>
+    where
+        T: Send + 'static,
+    {
+        // NB: this is intended to function the same as `Linker::module`, they
+        // should be kept in sync.
+        assert!(
+            Engine::same(&self.engine, store.as_context().engine()),
+            "different engines for this linker and the store provided"
+        );
+        match ModuleKind::categorize(module)? {
+            ModuleKind::Command => self.command(
+                store,
+                module_name,
+                module,
+                |store, func_ty, export_name, instance_pre| {
+                    let upvars = Arc::new((instance_pre, export_name));
+                    Func::new_async(
+                        store,
+                        func_ty.clone(),
+                        move |mut caller, params, results| {
+                            let upvars = upvars.clone();
+                            Box::new(async move {
+                                let (instance_pre, export_name) = &*upvars;
+                                let instance = instance_pre.instantiate_async(&mut caller).await?;
+
+                                instance
+                                    .get_export(&mut caller, &export_name)
+                                    .unwrap()
+                                    .into_func()
+                                    .unwrap()
+                                    .call_async(&mut caller, params, results)
+                                    .await?;
+                                Ok(())
+                            })
+                        },
+                    )
+                },
+            ),
+            ModuleKind::Reactor => {
+                let instance = self.instantiate_async(&mut store, &module).await?;
+
+                if let Some(export) = instance.get_export(&mut store, "_initialize") {
+                    if let Extern::Func(func) = export {
+                        let func = func
+                            .typed::<(), ()>(&store)
+                            .context("loading the Reactor initialization function")?;
+                        func.call_async(&mut store, ())
+                            .await
+                            .context("calling the Reactor initialization function")?;
+                    }
+                }
+
+                self.instance(store, module_name, instance)
+            }
+        }
+    }
+
+    fn command(
+        &mut self,
+        mut store: impl AsContextMut<Data = T>,
+        module_name: &str,
+        module: &Module,
+        mk_func: impl Fn(&mut StoreContextMut<T>, &FuncType, String, InstancePre<T>) -> Func,
+    ) -> Result<&mut Self>
+    where
+        T: 'static,
+    {
+        let mut store = store.as_context_mut();
+        for export in module.exports() {
+            if let Some(func_ty) = export.ty().func() {
+                let instance_pre = self.instantiate_pre(module)?;
+                let export_name = export.name().to_owned();
+                let func = mk_func(&mut store, func_ty, export_name, instance_pre);
+                let key = self.import_key(module_name, Some(export.name()));
+                self.insert(key, Definition::new(store.0, func.into()))?;
+            } else if export.name() == "memory" && export.ty().memory().is_some() {
+                // Allow an exported "memory" memory for now.
+            } else if export.name() == "__indirect_function_table" && export.ty().table().is_some()
+            {
+                // Allow an exported "__indirect_function_table" table for now.
+            } else if export.name() == "table" && export.ty().table().is_some() {
+                // Allow an exported "table" table for now.
+            } else if export.name() == "__data_end" && export.ty().global().is_some() {
+                // Allow an exported "__data_end" memory for compatibility with toolchains
+                // which use --export-dynamic, which unfortunately doesn't work the way
+                // we want it to.
+                warn!("command module exporting '__data_end' is deprecated");
+            } else if export.name() == "__heap_base" && export.ty().global().is_some() {
+                // Allow an exported "__data_end" memory for compatibility with toolchains
+                // which use --export-dynamic, which unfortunately doesn't work the way
+                // we want it to.
+                warn!("command module exporting '__heap_base' is deprecated");
+            } else if export.name() == "__dso_handle" && export.ty().global().is_some() {
+                // Allow an exported "__dso_handle" memory for compatibility with toolchains
+                // which use --export-dynamic, which unfortunately doesn't work the way
+                // we want it to.
+                warn!("command module exporting '__dso_handle' is deprecated")
+            } else if export.name() == "__rtti_base" && export.ty().global().is_some() {
+                // Allow an exported "__rtti_base" memory for compatibility with
+                // AssemblyScript.
+                warn!("command module exporting '__rtti_base' is deprecated; pass `--runtime half` to the AssemblyScript compiler");
+            } else if !self.allow_unknown_exports {
+                bail!("command export '{}' is not a function", export.name());
+            }
+        }
+
+        Ok(self)
+    }
+
+    /// Aliases one item's name as another.
+    ///
+    /// This method will alias an item with the specified `module` and `name`
+    /// under a new name of `as_module` and `as_name`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if any shadowing violations happen while defining new
+    /// items, or if the original item wasn't defined.
+    pub fn alias(
+        &mut self,
+        module: &str,
+        name: &str,
+        as_module: &str,
+        as_name: &str,
+    ) -> Result<&mut Self> {
+        let src = self.import_key(module, Some(name));
+        let dst = self.import_key(as_module, Some(as_name));
+        match self.map.get(&src).cloned() {
+            Some(item) => self.insert(dst, item)?,
+            None => bail!("no item named `{}::{}` defined", module, name),
+        }
+        Ok(self)
+    }
+
+    /// Aliases one module's name as another.
+    ///
+    /// This method will alias all currently defined under `module` to also be
+    /// defined under the name `as_module` too.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if any shadowing violations happen while defining new
+    /// items.
+    pub fn alias_module(&mut self, module: &str, as_module: &str) -> Result<()> {
+        let module = self.intern_str(module);
+        let as_module = self.intern_str(as_module);
+        let items = self
+            .map
+            .iter()
+            .filter(|(key, _def)| key.module == module)
+            .map(|(key, def)| (key.name, def.clone()))
+            .collect::<Vec<_>>();
+        for (name, item) in items {
+            self.insert(
+                ImportKey {
+                    module: as_module,
+                    name,
+                },
+                item,
+            )?;
+        }
+        Ok(())
+    }
+
+    fn insert(&mut self, key: ImportKey, item: Definition) -> Result<()> {
+        match self.map.entry(key) {
+            Entry::Occupied(_) if !self.allow_shadowing => {
+                let module = &self.strings[key.module];
+                let desc = match self.strings.get(key.name) {
+                    Some(name) => format!("{module}::{name}"),
+                    None => module.to_string(),
+                };
+                bail!("import of `{}` defined twice", desc)
+            }
+            Entry::Occupied(mut o) => {
+                o.insert(item);
+            }
+            Entry::Vacant(v) => {
+                v.insert(item);
+            }
+        }
+        Ok(())
+    }
+
+    fn import_key(&mut self, module: &str, name: Option<&str>) -> ImportKey {
+        ImportKey {
+            module: self.intern_str(module),
+            name: name
+                .map(|name| self.intern_str(name))
+                .unwrap_or(usize::max_value()),
+        }
+    }
+
+    fn intern_str(&mut self, string: &str) -> usize {
+        if let Some(idx) = self.string2idx.get(string) {
+            return *idx;
+        }
+        let string: Arc<str> = string.into();
+        let idx = self.strings.len();
+        self.strings.push(string.clone());
+        self.string2idx.insert(string, idx);
+        idx
+    }
+
+    /// Attempts to instantiate the `module` provided.
+    ///
+    /// This method will attempt to assemble a list of imports that correspond
+    /// to the imports required by the [`Module`] provided. This list
+    /// of imports is then passed to [`Instance::new`] to continue the
+    /// instantiation process.
+    ///
+    /// Each import of `module` will be looked up in this [`Linker`] and must
+    /// have previously been defined. If it was previously defined with an
+    /// incorrect signature or if it was not previously defined then an error
+    /// will be returned because the import can not be satisfied.
+    ///
+    /// Per the WebAssembly spec, instantiation includes running the module's
+    /// start function, if it has one (not to be confused with the `_start`
+    /// function, which is not run).
+    ///
+    /// # Errors
+    ///
+    /// This method can fail because an import may not be found, or because
+    /// instantiation itself may fail. For information on instantiation
+    /// failures see [`Instance::new`]. If an import is not found, the error
+    /// may be downcast to an [`UnknownImportError`].
+    ///
+    ///
+    /// # Panics
+    ///
+    /// Panics if any item used to instantiate `module` is not owned by
+    /// `store`. Additionally this will panic if the [`Engine`] that the `store`
+    /// belongs to is different than this [`Linker`].
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let engine = Engine::default();
+    /// # let mut store = Store::new(&engine, ());
+    /// let mut linker = Linker::new(&engine);
+    /// linker.func_wrap("host", "double", |x: i32| x * 2)?;
+    ///
+    /// let wat = r#"
+    ///     (module
+    ///         (import "host" "double" (func (param i32) (result i32)))
+    ///     )
+    /// "#;
+    /// let module = Module::new(&engine, wat)?;
+    /// linker.instantiate(&mut store, &module)?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn instantiate(
+        &self,
+        mut store: impl AsContextMut<Data = T>,
+        module: &Module,
+    ) -> Result<Instance> {
+        self._instantiate_pre(module, Some(store.as_context_mut().0))?
+            .instantiate(store)
+    }
+
+    /// Attempts to instantiate the `module` provided. This is the same as
+    /// [`Linker::instantiate`], except for async `Store`s.
+    #[cfg(feature = "async")]
+    pub async fn instantiate_async(
+        &self,
+        mut store: impl AsContextMut<Data = T>,
+        module: &Module,
+    ) -> Result<Instance>
+    where
+        T: Send,
+    {
+        self._instantiate_pre(module, Some(store.as_context_mut().0))?
+            .instantiate_async(store)
+            .await
+    }
+
+    /// Performs all checks necessary for instantiating `module` with this
+    /// linker, except that instantiation doesn't actually finish.
+    ///
+    /// This method is used for front-loading type-checking information as well
+    /// as collecting the imports to use to instantiate a module with. The
+    /// returned [`InstancePre`] represents a ready-to-be-instantiated module,
+    /// which can also be instantiated multiple times if desired.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error which may be downcast to an [`UnknownImportError`] if
+    /// the module has any unresolvable imports.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let engine = Engine::default();
+    /// # let mut store = Store::new(&engine, ());
+    /// let mut linker = Linker::new(&engine);
+    /// linker.func_wrap("host", "double", |x: i32| x * 2)?;
+    ///
+    /// let wat = r#"
+    ///     (module
+    ///         (import "host" "double" (func (param i32) (result i32)))
+    ///     )
+    /// "#;
+    /// let module = Module::new(&engine, wat)?;
+    /// let instance_pre = linker.instantiate_pre(&module)?;
+    ///
+    /// // Finish instantiation after the type-checking has all completed...
+    /// let instance = instance_pre.instantiate(&mut store)?;
+    ///
+    /// // ... and we can even continue to keep instantiating if desired!
+    /// instance_pre.instantiate(&mut store)?;
+    /// instance_pre.instantiate(&mut store)?;
+    ///
+    /// // Note that functions defined in a linker with `func_wrap` and similar
+    /// // constructors are not owned by any particular `Store`, so we can also
+    /// // instantiate our `instance_pre` in other stores because no imports
+    /// // belong to the original store.
+    /// let mut new_store = Store::new(&engine, ());
+    /// instance_pre.instantiate(&mut new_store)?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn instantiate_pre(&self, module: &Module) -> Result<InstancePre<T>> {
+        self._instantiate_pre(module, None)
+    }
+
+    /// This is split out to optionally take a `store` so that when the
+    /// `.instantiate` API is used we can get fresh up-to-date type information
+    /// for memories and their current size, if necessary.
+    ///
+    /// Note that providing a `store` here is not required for correctness
+    /// per-se. If one is not provided, such as the with the `instantiate_pre`
+    /// API, then the type information used for memories and tables will reflect
+    /// their size when inserted into the linker rather than their current size.
+    /// This isn't expected to be much of a problem though since
+    /// per-store-`Linker` types are likely using `.instantiate(..)` and
+    /// per-`Engine` linkers don't have memories/tables in them.
+    fn _instantiate_pre(
+        &self,
+        module: &Module,
+        store: Option<&StoreOpaque>,
+    ) -> Result<InstancePre<T>> {
+        let mut imports = module
+            .imports()
+            .map(|import| self._get_by_import(&import))
+            .collect::<Result<Vec<_>, _>>()
+            .err2anyhow()?;
+        if let Some(store) = store {
+            for import in imports.iter_mut() {
+                import.update_size(store);
+            }
+        }
+        unsafe { InstancePre::new(module, imports) }
+    }
+
+    /// Returns an iterator over all items defined in this `Linker`, in
+    /// arbitrary order.
+    ///
+    /// The iterator returned will yield 3-tuples where the first two elements
+    /// are the module name and item name for the external item, and the third
+    /// item is the item itself that is defined.
+    ///
+    /// Note that multiple `Extern` items may be defined for the same
+    /// module/name pair.
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if the `store` provided does not come from the
+    /// same [`Engine`] that this linker was created with.
+    pub fn iter<'a: 'p, 'p>(
+        &'a self,
+        mut store: impl AsContextMut<Data = T> + 'p,
+    ) -> impl Iterator<Item = (&str, &str, Extern)> + 'p {
+        self.map.iter().map(move |(key, item)| {
+            let store = store.as_context_mut();
+            (
+                &*self.strings[key.module],
+                &*self.strings[key.name],
+                // Should be safe since `T` is connecting the linker and store
+                unsafe { item.to_extern(store.0) },
+            )
+        })
+    }
+
+    /// Looks up a previously defined value in this [`Linker`], identified by
+    /// the names provided.
+    ///
+    /// Returns `None` if this name was not previously defined in this
+    /// [`Linker`].
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if the `store` provided does not come from the
+    /// same [`Engine`] that this linker was created with.
+    pub fn get(
+        &self,
+        mut store: impl AsContextMut<Data = T>,
+        module: &str,
+        name: &str,
+    ) -> Option<Extern> {
+        let store = store.as_context_mut().0;
+        // Should be safe since `T` is connecting the linker and store
+        Some(unsafe { self._get(module, name)?.to_extern(store) })
+    }
+
+    fn _get(&self, module: &str, name: &str) -> Option<&Definition> {
+        let key = ImportKey {
+            module: *self.string2idx.get(module)?,
+            name: *self.string2idx.get(name)?,
+        };
+        self.map.get(&key)
+    }
+
+    /// Looks up a value in this `Linker` which matches the `import` type
+    /// provided.
+    ///
+    /// Returns `None` if no match was found.
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if the `store` provided does not come from the
+    /// same [`Engine`] that this linker was created with.
+    pub fn get_by_import(
+        &self,
+        mut store: impl AsContextMut<Data = T>,
+        import: &ImportType,
+    ) -> Option<Extern> {
+        let store = store.as_context_mut().0;
+        // Should be safe since `T` is connecting the linker and store
+        Some(unsafe { self._get_by_import(import).ok()?.to_extern(store) })
+    }
+
+    fn _get_by_import(&self, import: &ImportType) -> Result<Definition, UnknownImportError> {
+        match self._get(import.module(), import.name()) {
+            Some(item) => Ok(item.clone()),
+            None => Err(UnknownImportError::new(import)),
+        }
+    }
+
+    /// Returns the "default export" of a module.
+    ///
+    /// An export with an empty string is considered to be a "default export".
+    /// "_start" is also recognized for compatibility.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the default function found is not owned by `store`. This
+    /// function will also panic if the `store` provided does not come from the
+    /// same [`Engine`] that this linker was created with.
+    pub fn get_default(
+        &self,
+        mut store: impl AsContextMut<Data = T>,
+        module: &str,
+    ) -> Result<Func> {
+        if let Some(external) = self.get(&mut store, module, "") {
+            if let Extern::Func(func) = external {
+                return Ok(func);
+            }
+            bail!("default export in '{}' is not a function", module);
+        }
+
+        // For compatibility, also recognize "_start".
+        if let Some(external) = self.get(&mut store, module, "_start") {
+            if let Extern::Func(func) = external {
+                return Ok(func);
+            }
+            bail!("`_start` in '{}' is not a function", module);
+        }
+
+        // Otherwise return a no-op function.
+        Ok(Func::wrap(store, || {}))
+    }
+}
+
+impl<T> Default for Linker<T> {
+    fn default() -> Linker<T> {
+        Linker::new(&Engine::default())
+    }
+}
+
+impl Definition {
+    fn new(store: &StoreOpaque, item: Extern) -> Definition {
+        let ty = DefinitionType::from(store, &item);
+        Definition::Extern(item, ty)
+    }
+
+    pub(crate) fn ty(&self) -> DefinitionType {
+        match self {
+            Definition::Extern(_, ty) => ty.clone(),
+            Definition::HostFunc(func) => DefinitionType::Func(func.sig_index()),
+        }
+    }
+
+    /// Note the unsafety here is due to calling `HostFunc::to_func`. The
+    /// requirement here is that the `T` that was originally used to create the
+    /// `HostFunc` matches the `T` on the store.
+    pub(crate) unsafe fn to_extern(&self, store: &mut StoreOpaque) -> Extern {
+        match self {
+            Definition::Extern(e, _) => e.clone(),
+            Definition::HostFunc(func) => func.to_func(store).into(),
+        }
+    }
+
+    pub(crate) fn comes_from_same_store(&self, store: &StoreOpaque) -> bool {
+        match self {
+            Definition::Extern(e, _) => e.comes_from_same_store(store),
+            Definition::HostFunc(_func) => true,
+        }
+    }
+
+    fn update_size(&mut self, store: &StoreOpaque) {
+        match self {
+            Definition::Extern(Extern::Memory(m), DefinitionType::Memory(_, size)) => {
+                *size = m.internal_size(store);
+            }
+            Definition::Extern(Extern::SharedMemory(m), DefinitionType::Memory(_, size)) => {
+                *size = m.size();
+            }
+            Definition::Extern(Extern::Table(m), DefinitionType::Table(_, size)) => {
+                *size = m.internal_size(store);
+            }
+            _ => {}
+        }
+    }
+}
+
+impl DefinitionType {
+    pub(crate) fn from(store: &StoreOpaque, item: &Extern) -> DefinitionType {
+        let data = store.store_data();
+        match item {
+            Extern::Func(f) => DefinitionType::Func(f.type_index(data)),
+            Extern::Table(t) => DefinitionType::Table(*t.wasmtime_ty(data), t.internal_size(store)),
+            Extern::Global(t) => DefinitionType::Global(*t.wasmtime_ty(data)),
+            Extern::Memory(t) => {
+                DefinitionType::Memory(*t.wasmtime_ty(data), t.internal_size(store))
+            }
+            Extern::SharedMemory(t) => DefinitionType::Memory(*t.ty().wasmtime_memory(), t.size()),
+        }
+    }
+
+    pub(crate) fn desc(&self) -> &'static str {
+        match self {
+            DefinitionType::Func(_) => "function",
+            DefinitionType::Table(..) => "table",
+            DefinitionType::Memory(..) => "memory",
+            DefinitionType::Global(_) => "global",
+        }
+    }
+}
+
+/// Modules can be interpreted either as Commands or Reactors.
+enum ModuleKind {
+    /// The instance is a Command, meaning an instance is created for each
+    /// exported function and lives for the duration of the function call.
+    Command,
+
+    /// The instance is a Reactor, meaning one instance is created which
+    /// may live across multiple calls.
+    Reactor,
+}
+
+impl ModuleKind {
+    /// Determine whether the given module is a Command or a Reactor.
+    fn categorize(module: &Module) -> Result<ModuleKind> {
+        let command_start = module.get_export("_start");
+        let reactor_start = module.get_export("_initialize");
+        match (command_start, reactor_start) {
+            (Some(command_start), None) => {
+                if let Some(_) = command_start.func() {
+                    Ok(ModuleKind::Command)
+                } else {
+                    bail!("`_start` must be a function")
+                }
+            }
+            (None, Some(reactor_start)) => {
+                if let Some(_) = reactor_start.func() {
+                    Ok(ModuleKind::Reactor)
+                } else {
+                    bail!("`_initialize` must be a function")
+                }
+            }
+            (None, None) => {
+                // Module declares neither of the recognized functions, so treat
+                // it as a reactor with no initialization function.
+                Ok(ModuleKind::Reactor)
+            }
+            (Some(_), Some(_)) => {
+                // Module declares itself to be both a Command and a Reactor.
+                bail!("Program cannot be both a Command and a Reactor")
+            }
+        }
+    }
+}
+
+/// Error for an unresolvable import.
+///
+/// Returned - wrapped in an [`anyhow::Error`] - by [`Linker::instantiate`] and
+/// related methods for modules with unresolvable imports.
+#[derive(Clone, Debug)]
+pub struct UnknownImportError {
+    module: String,
+    name: String,
+    ty: ExternType,
+}
+
+impl UnknownImportError {
+    fn new(import: &ImportType) -> Self {
+        Self {
+            module: import.module().to_string(),
+            name: import.name().to_string(),
+            ty: import.ty(),
+        }
+    }
+
+    /// Returns the module name that the unknown import was expected to come from.
+    pub fn module(&self) -> &str {
+        &self.module
+    }
+
+    /// Returns the field name of the module that the unknown import was expected to come from.
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
+    /// Returns the type of the unknown import.
+    pub fn ty(&self) -> ExternType {
+        self.ty.clone()
+    }
+}
+
+impl fmt::Display for UnknownImportError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "unknown import: `{}::{}` has not been defined",
+            self.module, self.name,
+        )
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for UnknownImportError {}
diff --git a/crates/wasmtime/src/runtime/memory.rs b/crates/wasmtime/src/runtime/memory.rs
new file mode 100644
index 000000000000..2614c2ed0f55
--- /dev/null
+++ b/crates/wasmtime/src/runtime/memory.rs
@@ -0,0 +1,1101 @@
+use crate::prelude::*;
+use crate::runtime::vm::{RuntimeLinearMemory, VMMemoryImport};
+use crate::store::{StoreData, StoreOpaque, Stored};
+use crate::trampoline::generate_memory_export;
+use crate::Trap;
+use crate::{AsContext, AsContextMut, Engine, MemoryType, StoreContext, StoreContextMut};
+use core::cell::UnsafeCell;
+use core::fmt;
+use core::ops::Range;
+use core::slice;
+use core::time::Duration;
+use wasmtime_environ::MemoryPlan;
+
+pub use crate::runtime::vm::WaitResult;
+
+/// Error for out of bounds [`Memory`] access.
+#[derive(Debug)]
+#[non_exhaustive]
+pub struct MemoryAccessError {
+    // Keep struct internals private for future extensibility.
+    _private: (),
+}
+
+impl fmt::Display for MemoryAccessError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "out of bounds memory access")
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for MemoryAccessError {}
+
+/// A WebAssembly linear memory.
+///
+/// WebAssembly memories represent a contiguous array of bytes that have a size
+/// that is always a multiple of the WebAssembly page size, currently 64
+/// kilobytes.
+///
+/// WebAssembly memory is used for global data (not to be confused with wasm
+/// `global` items), statics in C/C++/Rust, shadow stack memory, etc. Accessing
+/// wasm memory is generally quite fast.
+///
+/// Memories, like other wasm items, are owned by a [`Store`](crate::Store).
+///
+/// # `Memory` and Safety
+///
+/// Linear memory is a lynchpin of safety for WebAssembly. In Wasmtime there are
+/// safe methods of interacting with a [`Memory`]:
+///
+/// * [`Memory::read`]
+/// * [`Memory::write`]
+/// * [`Memory::data`]
+/// * [`Memory::data_mut`]
+///
+/// Note that all of these consider the entire store context as borrowed for the
+/// duration of the call or the duration of the returned slice. This largely
+/// means that while the function is running you'll be unable to borrow anything
+/// else from the store. This includes getting access to the `T` on
+/// [`Store<T>`](crate::Store), but it also means that you can't recursively
+/// call into WebAssembly for instance.
+///
+/// If you'd like to dip your toes into handling [`Memory`] in a more raw
+/// fashion (e.g. by using raw pointers or raw slices), then there's a few
+/// important points to consider when doing so:
+///
+/// * Any recursive calls into WebAssembly can possibly modify any byte of the
+///   entire memory. This means that whenever wasm is called Rust can't have any
+///   long-lived borrows live across the wasm function call. Slices like `&mut
+///   [u8]` will be violated because they're not actually exclusive at that
+///   point, and slices like `&[u8]` are also violated because their contents
+///   may be mutated.
+///
+/// * WebAssembly memories can grow, and growth may change the base pointer.
+///   This means that even holding a raw pointer to memory over a wasm function
+///   call is also incorrect. Anywhere in the function call the base address of
+///   memory may change. Note that growth can also be requested from the
+///   embedding API as well.
+///
+/// As a general rule of thumb it's recommended to stick to the safe methods of
+/// [`Memory`] if you can. It's not advised to use raw pointers or `unsafe`
+/// operations because of how easy it is to accidentally get things wrong.
+///
+/// Some examples of safely interacting with memory are:
+///
+/// ```rust
+/// use wasmtime::{Memory, Store, MemoryAccessError};
+///
+/// // Memory can be read and written safely with the `Memory::read` and
+/// // `Memory::write` methods.
+/// // An error is returned if the copy did not succeed.
+/// fn safe_examples(mem: Memory, store: &mut Store<()>) -> Result<(), MemoryAccessError> {
+///     let offset = 5;
+///     mem.write(&mut *store, offset, b"hello")?;
+///     let mut buffer = [0u8; 5];
+///     mem.read(&store, offset, &mut buffer)?;
+///     assert_eq!(b"hello", &buffer);
+///
+///     // Note that while this is safe care must be taken because the indexing
+///     // here may panic if the memory isn't large enough.
+///     assert_eq!(&mem.data(&store)[offset..offset + 5], b"hello");
+///     mem.data_mut(&mut *store)[offset..offset + 5].copy_from_slice(b"bye!!");
+///
+///     Ok(())
+/// }
+/// ```
+///
+/// It's worth also, however, covering some examples of **incorrect**,
+/// **unsafe** usages of `Memory`. Do not do these things!
+///
+/// ```rust
+/// # use anyhow::Result;
+/// use wasmtime::{Memory, Store};
+///
+/// // NOTE: All code in this function is not safe to execute and may cause
+/// // segfaults/undefined behavior at runtime. Do not copy/paste these examples
+/// // into production code!
+/// unsafe fn unsafe_examples(mem: Memory, store: &mut Store<()>) -> Result<()> {
+///     // First and foremost, any borrow can be invalidated at any time via the
+///     // `Memory::grow` function. This can relocate memory which causes any
+///     // previous pointer to be possibly invalid now.
+///     let pointer: &u8 = &*mem.data_ptr(&store);
+///     mem.grow(&mut *store, 1)?; // invalidates `pointer`!
+///     // println!("{}", *pointer); // FATAL: use-after-free
+///
+///     // Note that the use-after-free also applies to slices, whether they're
+///     // slices of bytes or strings.
+///     let mem_slice = std::slice::from_raw_parts(
+///         mem.data_ptr(&store),
+///         mem.data_size(&store),
+///     );
+///     let slice: &[u8] = &mem_slice[0x100..0x102];
+///     mem.grow(&mut *store, 1)?; // invalidates `slice`!
+///     // println!("{:?}", slice); // FATAL: use-after-free
+///
+///     // The `Memory` type may be stored in other locations, so if you hand
+///     // off access to the `Store` then those locations may also call
+///     // `Memory::grow` or similar, so it's not enough to just audit code for
+///     // calls to `Memory::grow`.
+///     let pointer: &u8 = &*mem.data_ptr(&store);
+///     some_other_function(store); // may invalidate `pointer` through use of `store`
+///     // println!("{:?}", pointer); // FATAL: maybe a use-after-free
+///
+///     // An especially subtle aspect of accessing a wasm instance's memory is
+///     // that you need to be extremely careful about aliasing. Anyone at any
+///     // time can call `data_unchecked()` or `data_unchecked_mut()`, which
+///     // means you can easily have aliasing mutable references:
+///     let ref1: &u8 = &*mem.data_ptr(&store).add(0x100);
+///     let ref2: &mut u8 = &mut *mem.data_ptr(&store).add(0x100);
+///     // *ref2 = *ref1; // FATAL: violates Rust's aliasing rules
+///
+///     Ok(())
+/// }
+/// # fn some_other_function(store: &mut Store<()>) {}
+/// ```
+///
+/// Overall there's some general rules of thumb when unsafely working with
+/// `Memory` and getting raw pointers inside of it:
+///
+/// * If you never have a "long lived" pointer into memory, you're likely in the
+///   clear. Care still needs to be taken in threaded scenarios or when/where
+///   data is read, but you'll be shielded from many classes of issues.
+/// * Long-lived pointers must always respect Rust'a aliasing rules. It's ok for
+///   shared borrows to overlap with each other, but mutable borrows must
+///   overlap with nothing.
+/// * Long-lived pointers are only valid if they're not invalidated for their
+///   lifetime. This means that [`Store`](crate::Store) isn't used to reenter
+///   wasm or the memory itself is never grown or otherwise modified/aliased.
+///
+/// At this point it's worth reiterating again that unsafely working with
+/// `Memory` is pretty tricky and not recommended! It's highly recommended to
+/// use the safe methods to interact with [`Memory`] whenever possible.
+///
+/// ## `Memory` Safety and Threads
+///
+/// Currently the `wasmtime` crate does not implement the wasm threads proposal,
+/// but it is planned to do so. It may be interesting to readers to see how this
+/// affects memory safety and what was previously just discussed as well.
+///
+/// Once threads are added into the mix, all of the above rules still apply.
+/// There's an additional consideration that all reads and writes can happen
+/// concurrently, though. This effectively means that any borrow into wasm
+/// memory are virtually never safe to have.
+///
+/// Mutable pointers are fundamentally unsafe to have in a concurrent scenario
+/// in the face of arbitrary wasm code. Only if you dynamically know for sure
+/// that wasm won't access a region would it be safe to construct a mutable
+/// pointer. Additionally even shared pointers are largely unsafe because their
+/// underlying contents may change, so unless `UnsafeCell` in one form or
+/// another is used everywhere there's no safety.
+///
+/// One important point about concurrency is that while [`Memory::grow`] can
+/// happen concurrently it will never relocate the base pointer. Shared
+/// memories must always have a maximum size and they will be preallocated such
+/// that growth will never relocate the base pointer. The current size of the
+/// memory may still change over time though.
+///
+/// Overall the general rule of thumb for shared memories is that you must
+/// atomically read and write everything. Nothing can be borrowed and everything
+/// must be eagerly copied out. This means that [`Memory::data`] and
+/// [`Memory::data_mut`] won't work in the future (they'll probably return an
+/// error) for shared memories when they're implemented. When possible it's
+/// recommended to use [`Memory::read`] and [`Memory::write`] which will still
+/// be provided.
+#[derive(Copy, Clone, Debug)]
+#[repr(transparent)] // here for the C API
+pub struct Memory(Stored<crate::runtime::vm::ExportMemory>);
+
+impl Memory {
+    /// Creates a new WebAssembly memory given the configuration of `ty`.
+    ///
+    /// The `store` argument will be the owner of the returned [`Memory`]. All
+    /// WebAssembly memory is initialized to zero.
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if the [`Store`](`crate::Store`) has a
+    /// [`ResourceLimiterAsync`](`crate::ResourceLimiterAsync`) (see also:
+    /// [`Store::limiter_async`](`crate::Store::limiter_async`)). When
+    /// using an async resource limiter, use [`Memory::new_async`] instead.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// let engine = Engine::default();
+    /// let mut store = Store::new(&engine, ());
+    ///
+    /// let memory_ty = MemoryType::new(1, None);
+    /// let memory = Memory::new(&mut store, memory_ty)?;
+    ///
+    /// let module = Module::new(&engine, "(module (memory (import \"\" \"\") 1))")?;
+    /// let instance = Instance::new(&mut store, &module, &[memory.into()])?;
+    /// // ...
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn new(mut store: impl AsContextMut, ty: MemoryType) -> Result<Memory> {
+        Self::_new(store.as_context_mut().0, ty)
+    }
+
+    /// Async variant of [`Memory::new`]. You must use this variant with
+    /// [`Store`](`crate::Store`)s which have a
+    /// [`ResourceLimiterAsync`](`crate::ResourceLimiterAsync`).
+    ///
+    /// # Panics
+    ///
+    /// This function will panic when used with a non-async
+    /// [`Store`](`crate::Store`).
+    #[cfg(feature = "async")]
+    pub async fn new_async<T>(
+        mut store: impl AsContextMut<Data = T>,
+        ty: MemoryType,
+    ) -> Result<Memory>
+    where
+        T: Send,
+    {
+        let mut store = store.as_context_mut();
+        assert!(
+            store.0.async_support(),
+            "cannot use `new_async` without enabling async support on the config"
+        );
+        store.on_fiber(|store| Self::_new(store.0, ty)).await?
+    }
+
+    /// Helper function for attaching the memory to a "frankenstein" instance
+    fn _new(store: &mut StoreOpaque, ty: MemoryType) -> Result<Memory> {
+        unsafe {
+            let export = generate_memory_export(store, &ty, None)?;
+            Ok(Memory::from_wasmtime_memory(export, store))
+        }
+    }
+
+    /// Returns the underlying type of this memory.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this memory doesn't belong to `store`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// let engine = Engine::default();
+    /// let mut store = Store::new(&engine, ());
+    /// let module = Module::new(&engine, "(module (memory (export \"mem\") 1))")?;
+    /// let instance = Instance::new(&mut store, &module, &[])?;
+    /// let memory = instance.get_memory(&mut store, "mem").unwrap();
+    /// let ty = memory.ty(&store);
+    /// assert_eq!(ty.minimum(), 1);
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn ty(&self, store: impl AsContext) -> MemoryType {
+        let store = store.as_context();
+        let ty = &store[self.0].memory.memory;
+        MemoryType::from_wasmtime_memory(&ty)
+    }
+
+    /// Safely reads memory contents at the given offset into a buffer.
+    ///
+    /// The entire buffer will be filled.
+    ///
+    /// If `offset + buffer.len()` exceed the current memory capacity, then the
+    /// buffer is left untouched and a [`MemoryAccessError`] is returned.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this memory doesn't belong to `store`.
+    pub fn read(
+        &self,
+        store: impl AsContext,
+        offset: usize,
+        buffer: &mut [u8],
+    ) -> Result<(), MemoryAccessError> {
+        let store = store.as_context();
+        let slice = self
+            .data(&store)
+            .get(offset..)
+            .and_then(|s| s.get(..buffer.len()))
+            .ok_or(MemoryAccessError { _private: () })?;
+        buffer.copy_from_slice(slice);
+        Ok(())
+    }
+
+    /// Safely writes contents of a buffer to this memory at the given offset.
+    ///
+    /// If the `offset + buffer.len()` exceeds the current memory capacity, then
+    /// none of the buffer is written to memory and a [`MemoryAccessError`] is
+    /// returned.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this memory doesn't belong to `store`.
+    pub fn write(
+        &self,
+        mut store: impl AsContextMut,
+        offset: usize,
+        buffer: &[u8],
+    ) -> Result<(), MemoryAccessError> {
+        let mut context = store.as_context_mut();
+        self.data_mut(&mut context)
+            .get_mut(offset..)
+            .and_then(|s| s.get_mut(..buffer.len()))
+            .ok_or(MemoryAccessError { _private: () })?
+            .copy_from_slice(buffer);
+        Ok(())
+    }
+
+    /// Returns this memory as a native Rust slice.
+    ///
+    /// Note that this method will consider the entire store context provided as
+    /// borrowed for the duration of the lifetime of the returned slice.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this memory doesn't belong to `store`.
+    pub fn data<'a, T: 'a>(&self, store: impl Into<StoreContext<'a, T>>) -> &'a [u8] {
+        unsafe {
+            let store = store.into();
+            let definition = &*store[self.0].definition;
+            debug_assert!(!self.ty(store).is_shared());
+            slice::from_raw_parts(definition.base, definition.current_length())
+        }
+    }
+
+    /// Returns this memory as a native Rust mutable slice.
+    ///
+    /// Note that this method will consider the entire store context provided as
+    /// borrowed for the duration of the lifetime of the returned slice.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this memory doesn't belong to `store`.
+    pub fn data_mut<'a, T: 'a>(&self, store: impl Into<StoreContextMut<'a, T>>) -> &'a mut [u8] {
+        unsafe {
+            let store = store.into();
+            let definition = &*store[self.0].definition;
+            debug_assert!(!self.ty(store).is_shared());
+            slice::from_raw_parts_mut(definition.base, definition.current_length())
+        }
+    }
+
+    /// Same as [`Memory::data_mut`], but also returns the `T` from the
+    /// [`StoreContextMut`].
+    ///
+    /// This method can be used when you want to simultaneously work with the
+    /// `T` in the store as well as the memory behind this [`Memory`]. Using
+    /// [`Memory::data_mut`] would consider the entire store borrowed, whereas
+    /// this method allows the Rust compiler to see that the borrow of this
+    /// memory and the borrow of `T` are disjoint.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this memory doesn't belong to `store`.
+    pub fn data_and_store_mut<'a, T: 'a>(
+        &self,
+        store: impl Into<StoreContextMut<'a, T>>,
+    ) -> (&'a mut [u8], &'a mut T) {
+        // Note the unsafety here. Our goal is to simultaneously borrow the
+        // memory and custom data from `store`, and the store it's connected
+        // to. Rust will not let us do that, however, because we must call two
+        // separate methods (both of which borrow the whole `store`) and one of
+        // our borrows is mutable (the custom data).
+        //
+        // This operation, however, is safe because these borrows do not overlap
+        // and in the process of borrowing them mutability doesn't actually
+        // touch anything. This is akin to mutably borrowing two indices in an
+        // array, which is safe so long as the indices are separate.
+        unsafe {
+            let mut store = store.into();
+            let data = &mut *(store.data_mut() as *mut T);
+            (self.data_mut(store), data)
+        }
+    }
+
+    /// Returns the base pointer, in the host's address space, that the memory
+    /// is located at.
+    ///
+    /// For more information and examples see the documentation on the
+    /// [`Memory`] type.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this memory doesn't belong to `store`.
+    pub fn data_ptr(&self, store: impl AsContext) -> *mut u8 {
+        unsafe { (*store.as_context()[self.0].definition).base }
+    }
+
+    /// Returns the byte length of this memory.
+    ///
+    /// WebAssembly memories are made up of a whole number of pages, so the byte
+    /// size returned will always be a multiple of this memory's page size. Note
+    /// that different Wasm memories may have different page sizes. You can get
+    /// a memory's page size via the [`Memory::page_size`] method.
+    ///
+    /// By default the page size is 64KiB (aka `0x10000`, `2**16`, `1<<16`, or
+    /// `65536`) but [the custom-page-sizes proposal] allows a memory to opt
+    /// into a page size of `1`. Future extensions might allow any power of two
+    /// as a page size.
+    ///
+    /// [the custom-page-sizes proposal]: https://github.com/WebAssembly/custom-page-sizes
+    ///
+    /// For more information and examples see the documentation on the
+    /// [`Memory`] type.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this memory doesn't belong to `store`.
+    pub fn data_size(&self, store: impl AsContext) -> usize {
+        self.internal_data_size(store.as_context().0)
+    }
+
+    pub(crate) fn internal_data_size(&self, store: &StoreOpaque) -> usize {
+        unsafe { (*store[self.0].definition).current_length() }
+    }
+
+    /// Returns the size, in units of pages, of this Wasm memory.
+    ///
+    /// WebAssembly memories are made up of a whole number of pages, so the byte
+    /// size returned will always be a multiple of this memory's page size. Note
+    /// that different Wasm memories may have different page sizes. You can get
+    /// a memory's page size via the [`Memory::page_size`] method.
+    ///
+    /// By default the page size is 64KiB (aka `0x10000`, `2**16`, `1<<16`, or
+    /// `65536`) but [the custom-page-sizes proposal] allows a memory to opt
+    /// into a page size of `1`. Future extensions might allow any power of two
+    /// as a page size.
+    ///
+    /// [the custom-page-sizes proposal]: https://github.com/WebAssembly/custom-page-sizes
+    ///
+    /// # Panics
+    ///
+    /// Panics if this memory doesn't belong to `store`.
+    pub fn size(&self, store: impl AsContext) -> u64 {
+        self.internal_size(store.as_context().0)
+    }
+
+    pub(crate) fn internal_size(&self, store: &StoreOpaque) -> u64 {
+        let byte_size = self.internal_data_size(store);
+        let page_size = usize::try_from(self._page_size(store)).unwrap();
+        u64::try_from(byte_size / page_size).unwrap()
+    }
+
+    /// Returns the size of a page, in bytes, for this memory.
+    ///
+    /// WebAssembly memories are made up of a whole number of pages, so the byte
+    /// size (as returned by [`Memory::data_size`]) will always be a multiple of
+    /// their page size. Different Wasm memories may have different page sizes.
+    ///
+    /// By default this is 64KiB (aka `0x10000`, `2**16`, `1<<16`, or `65536`)
+    /// but [the custom-page-sizes proposal] allows opting into a page size of
+    /// `1`. Future extensions might allow any power of two as a page size.
+    ///
+    /// [the custom-page-sizes proposal]: https://github.com/WebAssembly/custom-page-sizes
+    pub fn page_size(&self, store: impl AsContext) -> u64 {
+        self._page_size(store.as_context().0)
+    }
+
+    pub(crate) fn _page_size(&self, store: &StoreOpaque) -> u64 {
+        store[self.0].memory.memory.page_size()
+    }
+
+    /// Returns the log2 of this memory's page size, in bytes.
+    ///
+    /// WebAssembly memories are made up of a whole number of pages, so the byte
+    /// size (as returned by [`Memory::data_size`]) will always be a multiple of
+    /// their page size. Different Wasm memories may have different page sizes.
+    ///
+    /// By default the page size is 64KiB (aka `0x10000`, `2**16`, `1<<16`, or
+    /// `65536`) but [the custom-page-sizes proposal] allows opting into a page
+    /// size of `1`. Future extensions might allow any power of two as a page
+    /// size.
+    ///
+    /// [the custom-page-sizes proposal]: https://github.com/WebAssembly/custom-page-sizes
+    pub fn page_size_log2(&self, store: impl AsContext) -> u8 {
+        self._page_size_log2(store.as_context().0)
+    }
+
+    pub(crate) fn _page_size_log2(&self, store: &StoreOpaque) -> u8 {
+        store[self.0].memory.memory.page_size_log2
+    }
+
+    /// Grows this WebAssembly memory by `delta` pages.
+    ///
+    /// This will attempt to add `delta` more pages of memory on to the end of
+    /// this `Memory` instance. If successful this may relocate the memory and
+    /// cause [`Memory::data_ptr`] to return a new value. Additionally any
+    /// unsafely constructed slices into this memory may no longer be valid.
+    ///
+    /// On success returns the number of pages this memory previously had
+    /// before the growth succeeded.
+    ///
+    /// Note that, by default, a WebAssembly memory's page size is 64KiB (aka
+    /// 65536 or 2<sup>16</sup>). The [custom-page-sizes proposal] allows Wasm
+    /// memories to opt into a page size of one byte (and this may be further
+    /// relaxed to any power of two in a future extension).
+    ///
+    /// [custom-page-sizes proposal]: https://github.com/WebAssembly/custom-page-sizes
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if memory could not be grown, for example if it exceeds
+    /// the maximum limits of this memory. A
+    /// [`ResourceLimiter`](crate::ResourceLimiter) is another example of
+    /// preventing a memory to grow.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this memory doesn't belong to `store`.
+    ///
+    /// This function will panic if the [`Store`](`crate::Store`) has a
+    /// [`ResourceLimiterAsync`](`crate::ResourceLimiterAsync`) (see also:
+    /// [`Store::limiter_async`](`crate::Store::limiter_async`). When using an
+    /// async resource limiter, use [`Memory::grow_async`] instead.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// let engine = Engine::default();
+    /// let mut store = Store::new(&engine, ());
+    /// let module = Module::new(&engine, "(module (memory (export \"mem\") 1 2))")?;
+    /// let instance = Instance::new(&mut store, &module, &[])?;
+    /// let memory = instance.get_memory(&mut store, "mem").unwrap();
+    ///
+    /// assert_eq!(memory.size(&store), 1);
+    /// assert_eq!(memory.grow(&mut store, 1)?, 1);
+    /// assert_eq!(memory.size(&store), 2);
+    /// assert!(memory.grow(&mut store, 1).is_err());
+    /// assert_eq!(memory.size(&store), 2);
+    /// assert_eq!(memory.grow(&mut store, 0)?, 2);
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn grow(&self, mut store: impl AsContextMut, delta: u64) -> Result<u64> {
+        let store = store.as_context_mut().0;
+        let mem = self.wasmtime_memory(store);
+        unsafe {
+            match (*mem).grow(delta, Some(store))? {
+                Some(size) => {
+                    let vm = (*mem).vmmemory();
+                    *store[self.0].definition = vm;
+                    let page_size = (*mem).page_size();
+                    Ok(u64::try_from(size).unwrap() / page_size)
+                }
+                None => bail!("failed to grow memory by `{}`", delta),
+            }
+        }
+    }
+
+    /// Async variant of [`Memory::grow`]. Required when using a
+    /// [`ResourceLimiterAsync`](`crate::ResourceLimiterAsync`).
+    ///
+    /// # Panics
+    ///
+    /// This function will panic when used with a non-async
+    /// [`Store`](`crate::Store`).
+    #[cfg(feature = "async")]
+    pub async fn grow_async<T>(
+        &self,
+        mut store: impl AsContextMut<Data = T>,
+        delta: u64,
+    ) -> Result<u64>
+    where
+        T: Send,
+    {
+        let mut store = store.as_context_mut();
+        assert!(
+            store.0.async_support(),
+            "cannot use `grow_async` without enabling async support on the config"
+        );
+        store.on_fiber(|store| self.grow(store, delta)).await?
+    }
+
+    fn wasmtime_memory(&self, store: &mut StoreOpaque) -> *mut crate::runtime::vm::Memory {
+        unsafe {
+            let export = &store[self.0];
+            crate::runtime::vm::Instance::from_vmctx(export.vmctx, |handle| {
+                handle.get_defined_memory(export.index)
+            })
+        }
+    }
+
+    pub(crate) unsafe fn from_wasmtime_memory(
+        wasmtime_export: crate::runtime::vm::ExportMemory,
+        store: &mut StoreOpaque,
+    ) -> Memory {
+        Memory(store.store_data_mut().insert(wasmtime_export))
+    }
+
+    pub(crate) fn wasmtime_ty<'a>(&self, store: &'a StoreData) -> &'a wasmtime_environ::Memory {
+        &store[self.0].memory.memory
+    }
+
+    pub(crate) fn vmimport(&self, store: &StoreOpaque) -> crate::runtime::vm::VMMemoryImport {
+        let export = &store[self.0];
+        crate::runtime::vm::VMMemoryImport {
+            from: export.definition,
+            vmctx: export.vmctx,
+            index: export.index,
+        }
+    }
+
+    pub(crate) fn comes_from_same_store(&self, store: &StoreOpaque) -> bool {
+        store.store_data().contains(self.0)
+    }
+
+    /// Get a stable hash key for this memory.
+    ///
+    /// Even if the same underlying memory definition is added to the
+    /// `StoreData` multiple times and becomes multiple `wasmtime::Memory`s,
+    /// this hash key will be consistent across all of these memories.
+    pub(crate) fn hash_key(&self, store: &StoreOpaque) -> impl core::hash::Hash + Eq {
+        store[self.0].definition as usize
+    }
+}
+
+/// A linear memory. This trait provides an interface for raw memory buffers
+/// which are used by wasmtime, e.g. inside ['Memory']. Such buffers are in
+/// principle not thread safe. By implementing this trait together with
+/// MemoryCreator, one can supply wasmtime with custom allocated host managed
+/// memory.
+///
+/// # Safety
+///
+/// The memory should be page aligned and a multiple of page size.
+/// To prevent possible silent overflows, the memory should be protected by a
+/// guard page.  Additionally the safety concerns explained in ['Memory'], for
+/// accessing the memory apply here as well.
+///
+/// Note that this is a relatively new and experimental feature and it is
+/// recommended to be familiar with wasmtime runtime code to use it.
+pub unsafe trait LinearMemory: Send + Sync + 'static {
+    /// Returns the number of allocated bytes which are accessible at this time.
+    fn byte_size(&self) -> usize;
+
+    /// Returns the maximum number of bytes the memory can grow to.
+    ///
+    /// Returns `None` if the memory is unbounded, or `Some` if memory cannot
+    /// grow beyond a specified limit.
+    fn maximum_byte_size(&self) -> Option<usize>;
+
+    /// Grows this memory to have the `new_size`, in bytes, specified.
+    ///
+    /// Returns `Err` if memory can't be grown by the specified amount
+    /// of bytes. The error may be downcastable to `std::io::Error`.
+    /// Returns `Ok` if memory was grown successfully.
+    fn grow_to(&mut self, new_size: usize) -> Result<()>;
+
+    /// Return the allocated memory as a mutable pointer to u8.
+    fn as_ptr(&self) -> *mut u8;
+
+    /// Returns the range of native addresses that WebAssembly can natively
+    /// access from this linear memory, including guard pages.
+    fn wasm_accessible(&self) -> Range<usize>;
+}
+
+/// A memory creator. Can be used to provide a memory creator
+/// to wasmtime which supplies host managed memory.
+///
+/// # Safety
+///
+/// This trait is unsafe, as the memory safety depends on proper implementation
+/// of memory management. Memories created by the MemoryCreator should always be
+/// treated as owned by wasmtime instance, and any modification of them outside
+/// of wasmtime invoked routines is unsafe and may lead to corruption.
+///
+/// Note that this is a relatively new and experimental feature and it is
+/// recommended to be familiar with wasmtime runtime code to use it.
+pub unsafe trait MemoryCreator: Send + Sync {
+    /// Create a new `LinearMemory` object from the specified parameters.
+    ///
+    /// The type of memory being created is specified by `ty` which indicates
+    /// both the minimum and maximum size, in wasm pages. The minimum and
+    /// maximum sizes, in bytes, are also specified as parameters to avoid
+    /// integer conversion if desired.
+    ///
+    /// The `reserved_size_in_bytes` value indicates the expected size of the
+    /// reservation that is to be made for this memory. If this value is `None`
+    /// than the implementation is free to allocate memory as it sees fit. If
+    /// the value is `Some`, however, then the implementation is expected to
+    /// reserve that many bytes for the memory's allocation, plus the guard
+    /// size at the end. Note that this reservation need only be a virtual
+    /// memory reservation, physical memory does not need to be allocated
+    /// immediately. In this case `grow` should never move the base pointer and
+    /// the maximum size of `ty` is guaranteed to fit within
+    /// `reserved_size_in_bytes`.
+    ///
+    /// The `guard_size_in_bytes` parameter indicates how many bytes of space,
+    /// after the memory allocation, is expected to be unmapped. JIT code will
+    /// elide bounds checks based on the `guard_size_in_bytes` provided, so for
+    /// JIT code to work correctly the memory returned will need to be properly
+    /// guarded with `guard_size_in_bytes` bytes left unmapped after the base
+    /// allocation.
+    ///
+    /// Note that the `reserved_size_in_bytes` and `guard_size_in_bytes` options
+    /// are tuned from the various [`Config`](crate::Config) methods about
+    /// memory sizes/guards. Additionally these two values are guaranteed to be
+    /// multiples of the system page size.
+    ///
+    /// Memory created from this method should be zero filled.
+    fn new_memory(
+        &self,
+        ty: MemoryType,
+        minimum: usize,
+        maximum: Option<usize>,
+        reserved_size_in_bytes: Option<usize>,
+        guard_size_in_bytes: usize,
+    ) -> Result<Box<dyn LinearMemory>, String>;
+}
+
+/// A constructor for externally-created shared memory.
+///
+/// The [threads proposal] adds the concept of "shared memory" to WebAssembly.
+/// This is much the same as a Wasm linear memory (i.e., [`Memory`]), but can be
+/// used concurrently by multiple agents. Because these agents may execute in
+/// different threads, [`SharedMemory`] must be thread-safe.
+///
+/// When the threads proposal is enabled, there are multiple ways to construct
+/// shared memory:
+///  1. for imported shared memory, e.g., `(import "env" "memory" (memory 1 1
+///     shared))`, the user must supply a [`SharedMemory`] with the
+///     externally-created memory as an import to the instance--e.g.,
+///     `shared_memory.into()`.
+///  2. for private or exported shared memory, e.g., `(export "env" "memory"
+///     (memory 1 1 shared))`, Wasmtime will create the memory internally during
+///     instantiation--access using `Instance::get_shared_memory()`.
+///
+/// [threads proposal]:
+///     https://github.com/WebAssembly/threads/blob/master/proposals/threads/Overview.md
+///
+/// # Examples
+///
+/// ```
+/// # use wasmtime::*;
+/// # fn main() -> anyhow::Result<()> {
+/// let mut config = Config::new();
+/// config.wasm_threads(true);
+/// let engine = Engine::new(&config)?;
+/// let mut store = Store::new(&engine, ());
+///
+/// let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, 2))?;
+/// let module = Module::new(&engine, r#"(module (memory (import "" "") 1 2 shared))"#)?;
+/// let instance = Instance::new(&mut store, &module, &[shared_memory.into()])?;
+/// // ...
+/// # Ok(())
+/// # }
+/// ```
+#[derive(Clone)]
+pub struct SharedMemory {
+    vm: crate::runtime::vm::SharedMemory,
+    engine: Engine,
+    page_size_log2: u8,
+}
+
+impl SharedMemory {
+    /// Construct a [`SharedMemory`] by providing both the `minimum` and
+    /// `maximum` number of 64K-sized pages. This call allocates the necessary
+    /// pages on the system.
+    #[cfg(feature = "threads")]
+    pub fn new(engine: &Engine, ty: MemoryType) -> Result<Self> {
+        if !ty.is_shared() {
+            bail!("shared memory must have the `shared` flag enabled on its memory type")
+        }
+        debug_assert!(ty.maximum().is_some());
+
+        let tunables = engine.tunables();
+        let plan = MemoryPlan::for_memory(*ty.wasmtime_memory(), tunables);
+        let page_size_log2 = plan.memory.page_size_log2;
+        let memory = crate::runtime::vm::SharedMemory::new(plan)?;
+
+        Ok(Self {
+            vm: memory,
+            engine: engine.clone(),
+            page_size_log2,
+        })
+    }
+
+    /// Return the type of the shared memory.
+    pub fn ty(&self) -> MemoryType {
+        MemoryType::from_wasmtime_memory(&self.vm.ty())
+    }
+
+    /// Returns the size, in WebAssembly pages, of this wasm memory.
+    pub fn size(&self) -> u64 {
+        let byte_size = u64::try_from(self.data_size()).unwrap();
+        let page_size = u64::from(self.page_size());
+        byte_size / page_size
+    }
+
+    /// Returns the size of a page, in bytes, for this memory.
+    ///
+    /// By default this is 64KiB (aka `0x10000`, `2**16`, `1<<16`, or `65536`)
+    /// but [the custom-page-sizes proposal] allows opting into a page size of
+    /// `1`. Future extensions might allow any power of two as a page size.
+    ///
+    /// [the custom-page-sizes proposal]: https://github.com/WebAssembly/custom-page-sizes
+    pub fn page_size(&self) -> u32 {
+        debug_assert!(self.page_size_log2 == 0 || self.page_size_log2 == 16);
+        1 << self.page_size_log2
+    }
+
+    /// Returns the byte length of this memory.
+    ///
+    /// The returned value will be a multiple of the wasm page size, 64k.
+    ///
+    /// For more information and examples see the documentation on the
+    /// [`Memory`] type.
+    pub fn data_size(&self) -> usize {
+        self.vm.byte_size()
+    }
+
+    /// Return access to the available portion of the shared memory.
+    ///
+    /// The slice returned represents the region of accessible memory at the
+    /// time that this function was called. The contents of the returned slice
+    /// will reflect concurrent modifications happening on other threads.
+    ///
+    /// # Safety
+    ///
+    /// The returned slice is valid for the entire duration of the lifetime of
+    /// this instance of [`SharedMemory`]. The base pointer of a shared memory
+    /// does not change. This [`SharedMemory`] may grow further after this
+    /// function has been called, but the slice returned will not grow.
+    ///
+    /// Concurrent modifications may be happening to the data returned on other
+    /// threads. The `UnsafeCell<u8>` represents that safe access to the
+    /// contents of the slice is not possible through normal loads and stores.
+    ///
+    /// The memory returned must be accessed safely through the `Atomic*` types
+    /// in the [`std::sync::atomic`] module. Casting to those types must
+    /// currently be done unsafely.
+    pub fn data(&self) -> &[UnsafeCell<u8>] {
+        unsafe {
+            let definition = &*self.vm.vmmemory_ptr();
+            slice::from_raw_parts(definition.base.cast(), definition.current_length())
+        }
+    }
+
+    /// Grows this WebAssembly memory by `delta` pages.
+    ///
+    /// This will attempt to add `delta` more pages of memory on to the end of
+    /// this `Memory` instance. If successful this may relocate the memory and
+    /// cause [`Memory::data_ptr`] to return a new value. Additionally any
+    /// unsafely constructed slices into this memory may no longer be valid.
+    ///
+    /// On success returns the number of pages this memory previously had
+    /// before the growth succeeded.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if memory could not be grown, for example if it exceeds
+    /// the maximum limits of this memory. A
+    /// [`ResourceLimiter`](crate::ResourceLimiter) is another example of
+    /// preventing a memory to grow.
+    pub fn grow(&self, delta: u64) -> Result<u64> {
+        match self.vm.grow(delta, None)? {
+            Some((old_size, _new_size)) => {
+                // For shared memory, the `VMMemoryDefinition` is updated inside
+                // the locked region.
+                Ok(u64::try_from(old_size).unwrap() / u64::from(self.page_size()))
+            }
+            None => bail!("failed to grow memory by `{}`", delta),
+        }
+    }
+
+    /// Equivalent of the WebAssembly `memory.atomic.notify` instruction for
+    /// this shared memory.
+    ///
+    /// This method allows embedders to notify threads blocked on the specified
+    /// `addr`, an index into wasm linear memory. Threads could include
+    /// wasm threads blocked on a `memory.atomic.wait*` instruction or embedder
+    /// threads blocked on [`SharedMemory::atomic_wait32`], for example.
+    ///
+    /// The `count` argument is the number of threads to wake up.
+    ///
+    /// This function returns the number of threads awoken.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error if `addr` is not within bounds or
+    /// not aligned to a 4-byte boundary.
+    pub fn atomic_notify(&self, addr: u64, count: u32) -> Result<u32, Trap> {
+        self.vm.atomic_notify(addr, count)
+    }
+
+    /// Equivalent of the WebAssembly `memory.atomic.wait32` instruction for
+    /// this shared memory.
+    ///
+    /// This method allows embedders to block the current thread until notified
+    /// via the `memory.atomic.notify` instruction or the
+    /// [`SharedMemory::atomic_notify`] method, enabling synchronization with
+    /// the wasm guest as desired.
+    ///
+    /// The `expected` argument is the expected 32-bit value to be stored at
+    /// the byte address `addr` specified. The `addr` specified is an index
+    /// into this linear memory.
+    ///
+    /// The optional `timeout` argument is the maximum amount of time to block
+    /// the current thread. If not specified the thread may sleep indefinitely.
+    ///
+    /// This function returns one of three possible values:
+    ///
+    /// * `WaitResult::Ok` - this function, loaded the value at `addr`, found
+    ///   it was equal to `expected`, and then blocked (all as one atomic
+    ///   operation). The thread was then awoken with a `memory.atomic.notify`
+    ///   instruction or the [`SharedMemory::atomic_notify`] method.
+    /// * `WaitResult::Mismatch` - the value at `addr` was loaded but was not
+    ///   equal to `expected` so the thread did not block and immediately
+    ///   returned.
+    /// * `WaitResult::TimedOut` - all the steps of `Ok` happened, except this
+    ///   thread was woken up due to a timeout.
+    ///
+    /// This function will not return due to spurious wakeups.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error if `addr` is not within bounds or
+    /// not aligned to a 4-byte boundary.
+    pub fn atomic_wait32(
+        &self,
+        addr: u64,
+        expected: u32,
+        timeout: Option<Duration>,
+    ) -> Result<WaitResult, Trap> {
+        self.vm.atomic_wait32(addr, expected, timeout)
+    }
+
+    /// Equivalent of the WebAssembly `memory.atomic.wait64` instruction for
+    /// this shared memory.
+    ///
+    /// For more information see [`SharedMemory::atomic_wait32`].
+    ///
+    /// # Errors
+    ///
+    /// Returns the same error as [`SharedMemory::atomic_wait32`] except that
+    /// the specified address must be 8-byte aligned instead of 4-byte aligned.
+    pub fn atomic_wait64(
+        &self,
+        addr: u64,
+        expected: u64,
+        timeout: Option<Duration>,
+    ) -> Result<WaitResult, Trap> {
+        self.vm.atomic_wait64(addr, expected, timeout)
+    }
+
+    /// Return a reference to the [`Engine`] used to configure the shared
+    /// memory.
+    pub(crate) fn engine(&self) -> &Engine {
+        &self.engine
+    }
+
+    /// Construct a single-memory instance to provide a way to import
+    /// [`SharedMemory`] into other modules.
+    pub(crate) fn vmimport(&self, store: &mut StoreOpaque) -> crate::runtime::vm::VMMemoryImport {
+        let export_memory = generate_memory_export(store, &self.ty(), Some(&self.vm)).unwrap();
+        VMMemoryImport {
+            from: export_memory.definition,
+            vmctx: export_memory.vmctx,
+            index: export_memory.index,
+        }
+    }
+
+    /// Create a [`SharedMemory`] from an [`ExportMemory`] definition. This
+    /// function is available to handle the case in which a Wasm module exports
+    /// shared memory and the user wants host-side access to it.
+    pub(crate) unsafe fn from_wasmtime_memory(
+        wasmtime_export: crate::runtime::vm::ExportMemory,
+        store: &mut StoreOpaque,
+    ) -> Self {
+        #[cfg_attr(not(feature = "threads"), allow(unused_variables, unreachable_code))]
+        crate::runtime::vm::Instance::from_vmctx(wasmtime_export.vmctx, |handle| {
+            let memory_index = handle.module().memory_index(wasmtime_export.index);
+            let page_size = handle.memory_page_size(memory_index);
+            debug_assert!(page_size.is_power_of_two());
+            let page_size_log2 = u8::try_from(page_size.ilog2()).unwrap();
+
+            let memory = handle
+                .get_defined_memory(wasmtime_export.index)
+                .as_mut()
+                .unwrap();
+            match memory.as_shared_memory() {
+                Some(mem) => Self {
+                    vm: mem.clone(),
+                    engine: store.engine().clone(),
+                    page_size_log2,
+                },
+                None => panic!("unable to convert from a shared memory"),
+            }
+        })
+    }
+}
+
+impl fmt::Debug for SharedMemory {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("SharedMemory").finish_non_exhaustive()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::*;
+
+    // Assert that creating a memory via `Memory::new` respects the limits/tunables
+    // in `Config`.
+    #[test]
+    fn respect_tunables() {
+        let mut cfg = Config::new();
+        cfg.static_memory_maximum_size(0)
+            .dynamic_memory_guard_size(0);
+        let mut store = Store::new(&Engine::new(&cfg).unwrap(), ());
+        let ty = MemoryType::new(1, None);
+        let mem = Memory::new(&mut store, ty).unwrap();
+        let store = store.as_context();
+        assert_eq!(store[mem.0].memory.offset_guard_size, 0);
+        match &store[mem.0].memory.style {
+            wasmtime_environ::MemoryStyle::Dynamic { .. } => {}
+            other => panic!("unexpected style {other:?}"),
+        }
+    }
+
+    #[test]
+    fn hash_key_is_stable_across_duplicate_store_data_entries() -> Result<()> {
+        let mut store = Store::<()>::default();
+        let module = Module::new(
+            store.engine(),
+            r#"
+                (module
+                    (memory (export "m") 1 1)
+                )
+            "#,
+        )?;
+        let instance = Instance::new(&mut store, &module, &[])?;
+
+        // Each time we `get_memory`, we call `Memory::from_wasmtime` which adds
+        // a new entry to `StoreData`, so `g1` and `g2` will have different
+        // indices into `StoreData`.
+        let m1 = instance.get_memory(&mut store, "m").unwrap();
+        let m2 = instance.get_memory(&mut store, "m").unwrap();
+
+        // That said, they really point to the same memory.
+        assert_eq!(m1.data(&store)[0], 0);
+        assert_eq!(m2.data(&store)[0], 0);
+        m1.data_mut(&mut store)[0] = 42;
+        assert_eq!(m1.data(&mut store)[0], 42);
+        assert_eq!(m2.data(&mut store)[0], 42);
+
+        // And therefore their hash keys are the same.
+        assert!(m1.hash_key(&store.as_context().0) == m2.hash_key(&store.as_context().0));
+
+        // But the hash keys are different from different memories.
+        let instance2 = Instance::new(&mut store, &module, &[])?;
+        let m3 = instance2.get_memory(&mut store, "m").unwrap();
+        assert!(m1.hash_key(&store.as_context().0) != m3.hash_key(&store.as_context().0));
+
+        Ok(())
+    }
+}
diff --git a/crates/wasmtime/src/runtime/module.rs b/crates/wasmtime/src/runtime/module.rs
new file mode 100644
index 000000000000..2b277e254f00
--- /dev/null
+++ b/crates/wasmtime/src/runtime/module.rs
@@ -0,0 +1,1178 @@
+use crate::prelude::*;
+use crate::runtime::vm::{CompiledModuleId, MmapVec, ModuleMemoryImages, VMWasmCallFunction};
+use crate::sync::OnceLock;
+use crate::{
+    code::CodeObject,
+    code_memory::CodeMemory,
+    instantiate::CompiledModule,
+    resources::ResourcesRequired,
+    type_registry::TypeCollection,
+    types::{ExportType, ExternType, ImportType},
+    Engine,
+};
+use alloc::sync::Arc;
+use core::fmt;
+use core::ops::Range;
+use core::ptr::NonNull;
+#[cfg(feature = "std")]
+use std::path::Path;
+use wasmparser::{Parser, ValidPayload, Validator};
+use wasmtime_environ::{
+    CompiledModuleInfo, EntityIndex, HostPtr, ModuleTypes, ObjectKind, TypeTrace, VMOffsets,
+    VMSharedTypeIndex,
+};
+mod registry;
+
+pub use registry::{
+    lookup_code, register_code, unregister_code, ModuleRegistry, RegisteredModuleId,
+};
+
+/// A compiled WebAssembly module, ready to be instantiated.
+///
+/// A `Module` is a compiled in-memory representation of an input WebAssembly
+/// binary. A `Module` is then used to create an [`Instance`](crate::Instance)
+/// through an instantiation process. You cannot call functions or fetch
+/// globals, for example, on a `Module` because it's purely a code
+/// representation. Instead you'll need to create an
+/// [`Instance`](crate::Instance) to interact with the wasm module.
+///
+/// A `Module` can be created by compiling WebAssembly code through APIs such as
+/// [`Module::new`]. This would be a JIT-style use case where code is compiled
+/// just before it's used. Alternatively a `Module` can be compiled in one
+/// process and [`Module::serialize`] can be used to save it to storage. A later
+/// call to [`Module::deserialize`] will quickly load the module to execute and
+/// does not need to compile any code, representing a more AOT-style use case.
+///
+/// Currently a `Module` does not implement any form of tiering or dynamic
+/// optimization of compiled code. Creation of a `Module` via [`Module::new`] or
+/// related APIs will perform the entire compilation step synchronously. When
+/// finished no further compilation will happen at runtime or later during
+/// execution of WebAssembly instances for example.
+///
+/// Compilation of WebAssembly by default goes through Cranelift and is
+/// recommended to be done once-per-module. The same WebAssembly binary need not
+/// be compiled multiple times and can instead used an embedder-cached result of
+/// the first call.
+///
+/// `Module` is thread-safe and safe to share across threads.
+///
+/// ## Modules and `Clone`
+///
+/// Using `clone` on a `Module` is a cheap operation. It will not create an
+/// entirely new module, but rather just a new reference to the existing module.
+/// In other words it's a shallow copy, not a deep copy.
+///
+/// ## Examples
+///
+/// There are a number of ways you can create a `Module`, for example pulling
+/// the bytes from a number of locations. One example is loading a module from
+/// the filesystem:
+///
+/// ```no_run
+/// # use wasmtime::*;
+/// # fn main() -> anyhow::Result<()> {
+/// let engine = Engine::default();
+/// let module = Module::from_file(&engine, "path/to/foo.wasm")?;
+/// # Ok(())
+/// # }
+/// ```
+///
+/// You can also load the wasm text format if more convenient too:
+///
+/// ```no_run
+/// # use wasmtime::*;
+/// # fn main() -> anyhow::Result<()> {
+/// let engine = Engine::default();
+/// // Now we're using the WebAssembly text extension: `.wat`!
+/// let module = Module::from_file(&engine, "path/to/foo.wat")?;
+/// # Ok(())
+/// # }
+/// ```
+///
+/// And if you've already got the bytes in-memory you can use the
+/// [`Module::new`] constructor:
+///
+/// ```no_run
+/// # use wasmtime::*;
+/// # fn main() -> anyhow::Result<()> {
+/// let engine = Engine::default();
+/// # let wasm_bytes: Vec<u8> = Vec::new();
+/// let module = Module::new(&engine, &wasm_bytes)?;
+///
+/// // It also works with the text format!
+/// let module = Module::new(&engine, "(module (func))")?;
+/// # Ok(())
+/// # }
+/// ```
+///
+/// Serializing and deserializing a module looks like:
+///
+/// ```no_run
+/// # use wasmtime::*;
+/// # fn main() -> anyhow::Result<()> {
+/// let engine = Engine::default();
+/// # let wasm_bytes: Vec<u8> = Vec::new();
+/// let module = Module::new(&engine, &wasm_bytes)?;
+/// let module_bytes = module.serialize()?;
+///
+/// // ... can save `module_bytes` to disk or other storage ...
+///
+/// // recreate the module from the serialized bytes. For the `unsafe` bits
+/// // see the documentation of `deserialize`.
+/// let module = unsafe { Module::deserialize(&engine, &module_bytes)? };
+/// # Ok(())
+/// # }
+/// ```
+///
+/// [`Config`]: crate::Config
+#[derive(Clone)]
+pub struct Module {
+    inner: Arc<ModuleInner>,
+}
+
+struct ModuleInner {
+    engine: Engine,
+    /// The compiled artifacts for this module that will be instantiated and
+    /// executed.
+    module: CompiledModule,
+
+    /// Runtime information such as the underlying mmap, type information, etc.
+    ///
+    /// Note that this `Arc` is used to share information between compiled
+    /// modules within a component. For bare core wasm modules created with
+    /// `Module::new`, for example, this is a uniquely owned `Arc`.
+    code: Arc<CodeObject>,
+
+    /// A set of initialization images for memories, if any.
+    ///
+    /// Note that this is behind a `OnceCell` to lazily create this image. On
+    /// Linux where `memfd_create` may be used to create the backing memory
+    /// image this is a pretty expensive operation, so by deferring it this
+    /// improves memory usage for modules that are created but may not ever be
+    /// instantiated.
+    memory_images: OnceLock<Option<ModuleMemoryImages>>,
+
+    /// Flag indicating whether this module can be serialized or not.
+    serializable: bool,
+
+    /// Runtime offset information for `VMContext`.
+    offsets: VMOffsets<HostPtr>,
+}
+
+impl fmt::Debug for Module {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Module")
+            .field("name", &self.name())
+            .finish_non_exhaustive()
+    }
+}
+
+impl fmt::Debug for ModuleInner {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ModuleInner")
+            .field("name", &self.module.module().name.as_ref())
+            .finish_non_exhaustive()
+    }
+}
+
+impl Module {
+    /// Creates a new WebAssembly `Module` from the given in-memory `bytes`.
+    ///
+    /// The `bytes` provided must be in one of the following formats:
+    ///
+    /// * A [binary-encoded][binary] WebAssembly module. This is always supported.
+    /// * A [text-encoded][text] instance of the WebAssembly text format.
+    ///   This is only supported when the `wat` feature of this crate is enabled.
+    ///   If this is supplied then the text format will be parsed before validation.
+    ///   Note that the `wat` feature is enabled by default.
+    ///
+    /// The data for the wasm module must be loaded in-memory if it's present
+    /// elsewhere, for example on disk. This requires that the entire binary is
+    /// loaded into memory all at once, this API does not support streaming
+    /// compilation of a module.
+    ///
+    /// The WebAssembly binary will be decoded and validated. It will also be
+    /// compiled according to the configuration of the provided `engine`.
+    ///
+    /// # Errors
+    ///
+    /// This function may fail and return an error. Errors may include
+    /// situations such as:
+    ///
+    /// * The binary provided could not be decoded because it's not a valid
+    ///   WebAssembly binary
+    /// * The WebAssembly binary may not validate (e.g. contains type errors)
+    /// * Implementation-specific limits were exceeded with a valid binary (for
+    ///   example too many locals)
+    /// * The wasm binary may use features that are not enabled in the
+    ///   configuration of `engine`
+    /// * If the `wat` feature is enabled and the input is text, then it may be
+    ///   rejected if it fails to parse.
+    ///
+    /// The error returned should contain full information about why module
+    /// creation failed if one is returned.
+    ///
+    /// [binary]: https://webassembly.github.io/spec/core/binary/index.html
+    /// [text]: https://webassembly.github.io/spec/core/text/index.html
+    ///
+    /// # Examples
+    ///
+    /// The `new` function can be invoked with a in-memory array of bytes:
+    ///
+    /// ```no_run
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let engine = Engine::default();
+    /// # let wasm_bytes: Vec<u8> = Vec::new();
+    /// let module = Module::new(&engine, &wasm_bytes)?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// Or you can also pass in a string to be parsed as the wasm text
+    /// format:
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let engine = Engine::default();
+    /// let module = Module::new(&engine, "(module (func))")?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    #[cfg(any(feature = "cranelift", feature = "winch"))]
+    pub fn new(engine: &Engine, bytes: impl AsRef<[u8]>) -> Result<Module> {
+        crate::CodeBuilder::new(engine)
+            .wasm_binary_or_text(bytes.as_ref(), None)?
+            .compile_module()
+    }
+
+    /// Creates a new WebAssembly `Module` from the contents of the given
+    /// `file` on disk.
+    ///
+    /// This is a convenience function that will read the `file` provided and
+    /// pass the bytes to the [`Module::new`] function. For more information
+    /// see [`Module::new`]
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// let engine = Engine::default();
+    /// let module = Module::from_file(&engine, "./path/to/foo.wasm")?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// The `.wat` text format is also supported:
+    ///
+    /// ```no_run
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let engine = Engine::default();
+    /// let module = Module::from_file(&engine, "./path/to/foo.wat")?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    #[cfg(all(feature = "std", any(feature = "cranelift", feature = "winch")))]
+    pub fn from_file(engine: &Engine, file: impl AsRef<Path>) -> Result<Module> {
+        crate::CodeBuilder::new(engine)
+            .wasm_binary_or_text_file(file.as_ref())?
+            .compile_module()
+    }
+
+    /// Creates a new WebAssembly `Module` from the given in-memory `binary`
+    /// data.
+    ///
+    /// This is similar to [`Module::new`] except that it requires that the
+    /// `binary` input is a WebAssembly binary, the text format is not supported
+    /// by this function. It's generally recommended to use [`Module::new`], but
+    /// if it's required to not support the text format this function can be
+    /// used instead.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let engine = Engine::default();
+    /// let wasm = b"\0asm\x01\0\0\0";
+    /// let module = Module::from_binary(&engine, wasm)?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// Note that the text format is **not** accepted by this function:
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let engine = Engine::default();
+    /// assert!(Module::from_binary(&engine, b"(module)").is_err());
+    /// # Ok(())
+    /// # }
+    /// ```
+    #[cfg(any(feature = "cranelift", feature = "winch"))]
+    pub fn from_binary(engine: &Engine, binary: &[u8]) -> Result<Module> {
+        crate::CodeBuilder::new(engine)
+            .wasm_binary(binary, None)?
+            .compile_module()
+    }
+
+    /// Creates a new WebAssembly `Module` from the contents of the given `file`
+    /// on disk, but with assumptions that the file is from a trusted source.
+    /// The file should be a binary- or text-format WebAssembly module, or a
+    /// precompiled artifact generated by the same version of Wasmtime.
+    ///
+    /// # Unsafety
+    ///
+    /// All of the reasons that [`deserialize`] is `unsafe` apply to this
+    /// function as well. Arbitrary data loaded from a file may trick Wasmtime
+    /// into arbitrary code execution since the contents of the file are not
+    /// validated to be a valid precompiled module.
+    ///
+    /// [`deserialize`]: Module::deserialize
+    ///
+    /// Additionally though this function is also `unsafe` because the file
+    /// referenced must remain unchanged and a valid precompiled module for the
+    /// entire lifetime of the [`Module`] returned. Any changes to the file on
+    /// disk may change future instantiations of the module to be incorrect.
+    /// This is because the file is mapped into memory and lazily loaded pages
+    /// reflect the current state of the file, not necessarily the original
+    /// state of the file.
+    #[cfg(all(feature = "std", any(feature = "cranelift", feature = "winch")))]
+    pub unsafe fn from_trusted_file(engine: &Engine, file: impl AsRef<Path>) -> Result<Module> {
+        let mmap = MmapVec::from_file(file.as_ref())?;
+        if &mmap[0..4] == b"\x7fELF" {
+            let code = engine.load_code(mmap, ObjectKind::Module)?;
+            return Module::from_parts(engine, code, None);
+        }
+
+        crate::CodeBuilder::new(engine)
+            .wasm_binary_or_text(&mmap[..], Some(file.as_ref()))?
+            .compile_module()
+    }
+
+    /// Deserializes an in-memory compiled module previously created with
+    /// [`Module::serialize`] or [`Engine::precompile_module`].
+    ///
+    /// This function will deserialize the binary blobs emitted by
+    /// [`Module::serialize`] and [`Engine::precompile_module`] back into an
+    /// in-memory [`Module`] that's ready to be instantiated.
+    ///
+    /// Note that the [`Module::deserialize_file`] method is more optimized than
+    /// this function, so if the serialized module is already present in a file
+    /// it's recommended to use that method instead.
+    ///
+    /// # Unsafety
+    ///
+    /// This function is marked as `unsafe` because if fed invalid input or used
+    /// improperly this could lead to memory safety vulnerabilities. This method
+    /// should not, for example, be exposed to arbitrary user input.
+    ///
+    /// The structure of the binary blob read here is only lightly validated
+    /// internally in `wasmtime`. This is intended to be an efficient
+    /// "rehydration" for a [`Module`] which has very few runtime checks beyond
+    /// deserialization. Arbitrary input could, for example, replace valid
+    /// compiled code with any other valid compiled code, meaning that this can
+    /// trivially be used to execute arbitrary code otherwise.
+    ///
+    /// For these reasons this function is `unsafe`. This function is only
+    /// designed to receive the previous input from [`Module::serialize`] and
+    /// [`Engine::precompile_module`]. If the exact output of those functions
+    /// (unmodified) is passed to this function then calls to this function can
+    /// be considered safe. It is the caller's responsibility to provide the
+    /// guarantee that only previously-serialized bytes are being passed in
+    /// here.
+    ///
+    /// Note that this function is designed to be safe receiving output from
+    /// *any* compiled version of `wasmtime` itself. This means that it is safe
+    /// to feed output from older versions of Wasmtime into this function, in
+    /// addition to newer versions of wasmtime (from the future!). These inputs
+    /// will deterministically and safely produce an `Err`. This function only
+    /// successfully accepts inputs from the same version of `wasmtime`, but the
+    /// safety guarantee only applies to externally-defined blobs of bytes, not
+    /// those defined by any version of wasmtime. (this means that if you cache
+    /// blobs across versions of wasmtime you can be safely guaranteed that
+    /// future versions of wasmtime will reject old cache entries).
+    pub unsafe fn deserialize(engine: &Engine, bytes: impl AsRef<[u8]>) -> Result<Module> {
+        let code = engine.load_code_bytes(bytes.as_ref(), ObjectKind::Module)?;
+        Module::from_parts(engine, code, None)
+    }
+
+    /// Same as [`deserialize`], except that the contents of `path` are read to
+    /// deserialize into a [`Module`].
+    ///
+    /// This method is provided because it can be faster than [`deserialize`]
+    /// since the data doesn't need to be copied around, but rather the module
+    /// can be used directly from an mmap'd view of the file provided.
+    ///
+    /// [`deserialize`]: Module::deserialize
+    ///
+    /// # Unsafety
+    ///
+    /// All of the reasons that [`deserialize`] is `unsafe` applies to this
+    /// function as well. Arbitrary data loaded from a file may trick Wasmtime
+    /// into arbitrary code execution since the contents of the file are not
+    /// validated to be a valid precompiled module.
+    ///
+    /// Additionally though this function is also `unsafe` because the file
+    /// referenced must remain unchanged and a valid precompiled module for the
+    /// entire lifetime of the [`Module`] returned. Any changes to the file on
+    /// disk may change future instantiations of the module to be incorrect.
+    /// This is because the file is mapped into memory and lazily loaded pages
+    /// reflect the current state of the file, not necessarily the original
+    /// state of the file.
+    #[cfg(feature = "std")]
+    pub unsafe fn deserialize_file(engine: &Engine, path: impl AsRef<Path>) -> Result<Module> {
+        let code = engine.load_code_file(path.as_ref(), ObjectKind::Module)?;
+        Module::from_parts(engine, code, None)
+    }
+
+    /// Entrypoint for creating a `Module` for all above functions, both
+    /// of the AOT and jit-compiled categories.
+    ///
+    /// In all cases the compilation artifact, `code_memory`, is provided here.
+    /// The `info_and_types` argument is `None` when a module is being
+    /// deserialized from a precompiled artifact or it's `Some` if it was just
+    /// compiled and the values are already available.
+    pub(crate) fn from_parts(
+        engine: &Engine,
+        code_memory: Arc<CodeMemory>,
+        info_and_types: Option<(CompiledModuleInfo, ModuleTypes)>,
+    ) -> Result<Self> {
+        // Acquire this module's metadata and type information, deserializing
+        // it from the provided artifact if it wasn't otherwise provided
+        // already.
+        let (info, types) = match info_and_types {
+            Some((info, types)) => (info, types),
+            None => postcard::from_bytes(code_memory.wasmtime_info()).err2anyhow()?,
+        };
+
+        // Register function type signatures into the engine for the lifetime
+        // of the `Module` that will be returned. This notably also builds up
+        // maps for trampolines to be used for this module when inserted into
+        // stores.
+        //
+        // Note that the unsafety here should be ok since the `trampolines`
+        // field should only point to valid trampoline function pointers
+        // within the text section.
+        let signatures = TypeCollection::new_for_module(engine, &types);
+
+        // Package up all our data into a `CodeObject` and delegate to the final
+        // step of module compilation.
+        let code = Arc::new(CodeObject::new(code_memory, signatures, types.into()));
+        Module::from_parts_raw(engine, code, info, true)
+    }
+
+    pub(crate) fn from_parts_raw(
+        engine: &Engine,
+        code: Arc<CodeObject>,
+        info: CompiledModuleInfo,
+        serializable: bool,
+    ) -> Result<Self> {
+        let module =
+            CompiledModule::from_artifacts(code.code_memory().clone(), info, engine.profiler())?;
+
+        // Validate the module can be used with the current instance allocator.
+        let offsets = VMOffsets::new(HostPtr, module.module());
+        engine
+            .allocator()
+            .validate_module(module.module(), &offsets)?;
+
+        Ok(Self {
+            inner: Arc::new(ModuleInner {
+                engine: engine.clone(),
+                code,
+                memory_images: OnceLock::new(),
+                module,
+                serializable,
+                offsets,
+            }),
+        })
+    }
+
+    /// Validates `binary` input data as a WebAssembly binary given the
+    /// configuration in `engine`.
+    ///
+    /// This function will perform a speedy validation of the `binary` input
+    /// WebAssembly module (which is in [binary form][binary], the text format
+    /// is not accepted by this function) and return either `Ok` or `Err`
+    /// depending on the results of validation. The `engine` argument indicates
+    /// configuration for WebAssembly features, for example, which are used to
+    /// indicate what should be valid and what shouldn't be.
+    ///
+    /// Validation automatically happens as part of [`Module::new`].
+    ///
+    /// # Errors
+    ///
+    /// If validation fails for any reason (type check error, usage of a feature
+    /// that wasn't enabled, etc) then an error with a description of the
+    /// validation issue will be returned.
+    ///
+    /// [binary]: https://webassembly.github.io/spec/core/binary/index.html
+    pub fn validate(engine: &Engine, binary: &[u8]) -> Result<()> {
+        let mut validator = Validator::new_with_features(engine.features());
+
+        let mut functions = Vec::new();
+        for payload in Parser::new(0).parse_all(binary) {
+            let payload = payload.err2anyhow()?;
+            if let ValidPayload::Func(a, b) = validator.payload(&payload).err2anyhow()? {
+                functions.push((a, b));
+            }
+            if let wasmparser::Payload::Version { encoding, .. } = &payload {
+                if let wasmparser::Encoding::Component = encoding {
+                    bail!("component passed to module validation");
+                }
+            }
+        }
+
+        engine
+            .run_maybe_parallel(functions, |(validator, body)| {
+                // FIXME: it would be best here to use a rayon-specific parallel
+                // iterator that maintains state-per-thread to share the function
+                // validator allocations (`Default::default` here) across multiple
+                // functions.
+                validator.into_validator(Default::default()).validate(&body)
+            })
+            .err2anyhow()?;
+        Ok(())
+    }
+
+    /// Serializes this module to a vector of bytes.
+    ///
+    /// This function is similar to the [`Engine::precompile_module`] method
+    /// where it produces an artifact of Wasmtime which is suitable to later
+    /// pass into [`Module::deserialize`]. If a module is never instantiated
+    /// then it's recommended to use [`Engine::precompile_module`] instead of
+    /// this method, but if a module is both instantiated and serialized then
+    /// this method can be useful to get the serialized version without
+    /// compiling twice.
+    #[cfg(any(feature = "cranelift", feature = "winch"))]
+    pub fn serialize(&self) -> Result<Vec<u8>> {
+        // The current representation of compiled modules within a compiled
+        // component means that it cannot be serialized. The mmap returned here
+        // is the mmap for the entire component and while it contains all
+        // necessary data to deserialize this particular module it's all
+        // embedded within component-specific information.
+        //
+        // It's not the hardest thing in the world to support this but it's
+        // expected that there's not much of a use case at this time. In theory
+        // all that needs to be done is to edit the `.wasmtime.info` section
+        // to contains this module's metadata instead of the metadata for the
+        // whole component. The metadata itself is fairly trivially
+        // recreateable here it's more that there's no easy one-off API for
+        // editing the sections of an ELF object to use here.
+        //
+        // Overall for now this simply always returns an error in this
+        // situation. If you're reading this and feel that the situation should
+        // be different please feel free to open an issue.
+        if !self.inner.serializable {
+            bail!("cannot serialize a module exported from a component");
+        }
+        Ok(self.compiled_module().mmap().to_vec())
+    }
+
+    pub(crate) fn compiled_module(&self) -> &CompiledModule {
+        &self.inner.module
+    }
+
+    pub(crate) fn code_object(&self) -> &Arc<CodeObject> {
+        &self.inner.code
+    }
+
+    pub(crate) fn env_module(&self) -> &Arc<wasmtime_environ::Module> {
+        self.compiled_module().module()
+    }
+
+    pub(crate) fn types(&self) -> &ModuleTypes {
+        self.inner.code.module_types()
+    }
+
+    pub(crate) fn signatures(&self) -> &TypeCollection {
+        self.inner.code.signatures()
+    }
+
+    /// Returns identifier/name that this [`Module`] has. This name
+    /// is used in traps/backtrace details.
+    ///
+    /// Note that most LLVM/clang/Rust-produced modules do not have a name
+    /// associated with them, but other wasm tooling can be used to inject or
+    /// add a name.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let engine = Engine::default();
+    /// let module = Module::new(&engine, "(module $foo)")?;
+    /// assert_eq!(module.name(), Some("foo"));
+    ///
+    /// let module = Module::new(&engine, "(module)")?;
+    /// assert_eq!(module.name(), None);
+    ///
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn name(&self) -> Option<&str> {
+        self.compiled_module().module().name.as_deref()
+    }
+
+    /// Returns the list of imports that this [`Module`] has and must be
+    /// satisfied.
+    ///
+    /// This function returns the list of imports that the wasm module has, but
+    /// only the types of each import. The type of each import is used to
+    /// typecheck the [`Instance::new`](crate::Instance::new) method's `imports`
+    /// argument. The arguments to that function must match up 1-to-1 with the
+    /// entries in the array returned here.
+    ///
+    /// The imports returned reflect the order of the imports in the wasm module
+    /// itself, and note that no form of deduplication happens.
+    ///
+    /// # Examples
+    ///
+    /// Modules with no imports return an empty list here:
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let engine = Engine::default();
+    /// let module = Module::new(&engine, "(module)")?;
+    /// assert_eq!(module.imports().len(), 0);
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// and modules with imports will have a non-empty list:
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let engine = Engine::default();
+    /// let wat = r#"
+    ///     (module
+    ///         (import "host" "foo" (func))
+    ///     )
+    /// "#;
+    /// let module = Module::new(&engine, wat)?;
+    /// assert_eq!(module.imports().len(), 1);
+    /// let import = module.imports().next().unwrap();
+    /// assert_eq!(import.module(), "host");
+    /// assert_eq!(import.name(), "foo");
+    /// match import.ty() {
+    ///     ExternType::Func(_) => { /* ... */ }
+    ///     _ => panic!("unexpected import type!"),
+    /// }
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn imports<'module>(
+        &'module self,
+    ) -> impl ExactSizeIterator<Item = ImportType<'module>> + 'module {
+        let module = self.compiled_module().module();
+        let types = self.types();
+        let engine = self.engine();
+        module
+            .imports()
+            .map(move |(imp_mod, imp_field, mut ty)| {
+                ty.canonicalize_for_runtime_usage(&mut |i| {
+                    self.signatures().shared_type(i).unwrap()
+                });
+                ImportType::new(imp_mod, imp_field, ty, types, engine)
+            })
+            .collect::<Vec<_>>()
+            .into_iter()
+    }
+
+    /// Returns the list of exports that this [`Module`] has and will be
+    /// available after instantiation.
+    ///
+    /// This function will return the type of each item that will be returned
+    /// from [`Instance::exports`](crate::Instance::exports). Each entry in this
+    /// list corresponds 1-to-1 with that list, and the entries here will
+    /// indicate the name of the export along with the type of the export.
+    ///
+    /// # Examples
+    ///
+    /// Modules might not have any exports:
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let engine = Engine::default();
+    /// let module = Module::new(&engine, "(module)")?;
+    /// assert!(module.exports().next().is_none());
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// When the exports are not empty, you can inspect each export:
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let engine = Engine::default();
+    /// let wat = r#"
+    ///     (module
+    ///         (func (export "foo"))
+    ///         (memory (export "memory") 1)
+    ///     )
+    /// "#;
+    /// let module = Module::new(&engine, wat)?;
+    /// assert_eq!(module.exports().len(), 2);
+    ///
+    /// let mut exports = module.exports();
+    /// let foo = exports.next().unwrap();
+    /// assert_eq!(foo.name(), "foo");
+    /// match foo.ty() {
+    ///     ExternType::Func(_) => { /* ... */ }
+    ///     _ => panic!("unexpected export type!"),
+    /// }
+    ///
+    /// let memory = exports.next().unwrap();
+    /// assert_eq!(memory.name(), "memory");
+    /// match memory.ty() {
+    ///     ExternType::Memory(_) => { /* ... */ }
+    ///     _ => panic!("unexpected export type!"),
+    /// }
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn exports<'module>(
+        &'module self,
+    ) -> impl ExactSizeIterator<Item = ExportType<'module>> + 'module {
+        let module = self.compiled_module().module();
+        let types = self.types();
+        let engine = self.engine();
+        module.exports.iter().map(move |(name, entity_index)| {
+            ExportType::new(name, module.type_of(*entity_index), types, engine)
+        })
+    }
+
+    /// Looks up an export in this [`Module`] by name.
+    ///
+    /// This function will return the type of an export with the given name.
+    ///
+    /// # Examples
+    ///
+    /// There may be no export with that name:
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let engine = Engine::default();
+    /// let module = Module::new(&engine, "(module)")?;
+    /// assert!(module.get_export("foo").is_none());
+    /// # Ok(())
+    /// # }
+    /// ```
+    ///
+    /// When there is an export with that name, it is returned:
+    ///
+    /// ```
+    /// # use wasmtime::*;
+    /// # fn main() -> anyhow::Result<()> {
+    /// # let engine = Engine::default();
+    /// let wat = r#"
+    ///     (module
+    ///         (func (export "foo"))
+    ///         (memory (export "memory") 1)
+    ///     )
+    /// "#;
+    /// let module = Module::new(&engine, wat)?;
+    /// let foo = module.get_export("foo");
+    /// assert!(foo.is_some());
+    ///
+    /// let foo = foo.unwrap();
+    /// match foo {
+    ///     ExternType::Func(_) => { /* ... */ }
+    ///     _ => panic!("unexpected export type!"),
+    /// }
+    ///
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn get_export(&self, name: &str) -> Option<ExternType> {
+        let module = self.compiled_module().module();
+        let entity_index = module.exports.get(name)?;
+        Some(ExternType::from_wasmtime(
+            self.engine(),
+            self.types(),
+            &module.type_of(*entity_index),
+        ))
+    }
+
+    /// Looks up an export in this [`Module`] by name to get its index.
+    ///
+    /// This function will return the index of an export with the given name. This can be useful
+    /// to avoid the cost of looking up the export by name multiple times. Instead the
+    /// [`ModuleExport`] can be stored and used to look up the export on the
+    /// [`Instance`](crate::Instance) later.
+    pub fn get_export_index(&self, name: &str) -> Option<ModuleExport> {
+        let compiled_module = self.compiled_module();
+        let module = compiled_module.module();
+        module
+            .exports
+            .get_full(name)
+            .map(|(export_name_index, _, &entity)| ModuleExport {
+                module: self.id(),
+                entity,
+                export_name_index,
+            })
+    }
+
+    /// Returns the [`Engine`] that this [`Module`] was compiled by.
+    pub fn engine(&self) -> &Engine {
+        &self.inner.engine
+    }
+
+    /// Returns a summary of the resources required to instantiate this
+    /// [`Module`].
+    ///
+    /// Potential uses of the returned information:
+    ///
+    /// * Determining whether your pooling allocator configuration supports
+    ///   instantiating this module.
+    ///
+    /// * Deciding how many of which `Module` you want to instantiate within a
+    ///   fixed amount of resources, e.g. determining whether to create 5
+    ///   instances of module X or 10 instances of module Y.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # fn main() -> wasmtime::Result<()> {
+    /// use wasmtime::{Config, Engine, Module};
+    ///
+    /// let mut config = Config::new();
+    /// config.wasm_multi_memory(true);
+    /// let engine = Engine::new(&config)?;
+    ///
+    /// let module = Module::new(&engine, r#"
+    ///     (module
+    ///         ;; Import a memory. Doesn't count towards required resources.
+    ///         (import "a" "b" (memory 10))
+    ///         ;; Define two local memories. These count towards the required
+    ///         ;; resources.
+    ///         (memory 1)
+    ///         (memory 6)
+    ///     )
+    /// "#)?;
+    ///
+    /// let resources = module.resources_required();
+    ///
+    /// // Instantiating the module will require allocating two memories, and
+    /// // the maximum initial memory size is six Wasm pages.
+    /// assert_eq!(resources.num_memories, 2);
+    /// assert_eq!(resources.max_initial_memory_size, Some(6));
+    ///
+    /// // The module doesn't need any tables.
+    /// assert_eq!(resources.num_tables, 0);
+    /// assert_eq!(resources.max_initial_table_size, None);
+    /// # Ok(()) }
+    /// ```
+    pub fn resources_required(&self) -> ResourcesRequired {
+        let em = self.env_module();
+        let num_memories = u32::try_from(em.memory_plans.len() - em.num_imported_memories).unwrap();
+        let max_initial_memory_size = em
+            .memory_plans
+            .values()
+            .skip(em.num_imported_memories)
+            .map(|plan| plan.memory.minimum)
+            .max();
+        let num_tables = u32::try_from(em.table_plans.len() - em.num_imported_tables).unwrap();
+        let max_initial_table_size = em
+            .table_plans
+            .values()
+            .skip(em.num_imported_tables)
+            .map(|plan| plan.table.minimum)
+            .max();
+        ResourcesRequired {
+            num_memories,
+            max_initial_memory_size,
+            num_tables,
+            max_initial_table_size,
+        }
+    }
+
+    pub(crate) fn module_info(&self) -> &dyn crate::runtime::vm::ModuleInfo {
+        &*self.inner
+    }
+
+    /// Returns the range of bytes in memory where this module's compilation
+    /// image resides.
+    ///
+    /// The compilation image for a module contains executable code, data, debug
+    /// information, etc. This is roughly the same as the `Module::serialize`
+    /// but not the exact same.
+    ///
+    /// The range of memory reported here is exposed to allow low-level
+    /// manipulation of the memory in platform-specific manners such as using
+    /// `mlock` to force the contents to be paged in immediately or keep them
+    /// paged in after they're loaded.
+    ///
+    /// It is not safe to modify the memory in this range, nor is it safe to
+    /// modify the protections of memory in this range.
+    pub fn image_range(&self) -> Range<*const u8> {
+        self.compiled_module().mmap().image_range()
+    }
+
+    /// Force initialization of copy-on-write images to happen here-and-now
+    /// instead of when they're requested during first instantiation.
+    ///
+    /// When [copy-on-write memory
+    /// initialization](crate::Config::memory_init_cow) is enabled then Wasmtime
+    /// will lazily create the initialization image for a module. This method
+    /// can be used to explicitly dictate when this initialization happens.
+    ///
+    /// Note that this largely only matters on Linux when memfd is used.
+    /// Otherwise the copy-on-write image typically comes from disk and in that
+    /// situation the creation of the image is trivial as the image is always
+    /// sourced from disk. On Linux, though, when memfd is used a memfd is
+    /// created and the initialization image is written to it.
+    ///
+    /// Also note that this method is not required to be called, it's available
+    /// as a performance optimization if required but is otherwise handled
+    /// automatically.
+    pub fn initialize_copy_on_write_image(&self) -> Result<()> {
+        self.memory_images()?;
+        Ok(())
+    }
+
+    /// Get the map from `.text` section offsets to Wasm binary offsets for this
+    /// module.
+    ///
+    /// Each entry is a (`.text` section offset, Wasm binary offset) pair.
+    ///
+    /// Entries are yielded in order of `.text` section offset.
+    ///
+    /// Some entries are missing a Wasm binary offset. This is for code that is
+    /// not associated with any single location in the Wasm binary, or for when
+    /// source information was optimized away.
+    ///
+    /// Not every module has an address map, since address map generation can be
+    /// turned off on `Config`.
+    ///
+    /// There is not an entry for every `.text` section offset. Every offset
+    /// after an entry's offset, but before the next entry's offset, is
+    /// considered to map to the same Wasm binary offset as the original
+    /// entry. For example, the address map will not contain the following
+    /// sequence of entries:
+    ///
+    /// ```ignore
+    /// [
+    ///     // ...
+    ///     (10, Some(42)),
+    ///     (11, Some(42)),
+    ///     (12, Some(42)),
+    ///     (13, Some(43)),
+    ///     // ...
+    /// ]
+    /// ```
+    ///
+    /// Instead, it will drop the entries for offsets `11` and `12` since they
+    /// are the same as the entry for offset `10`:
+    ///
+    /// ```ignore
+    /// [
+    ///     // ...
+    ///     (10, Some(42)),
+    ///     (13, Some(43)),
+    ///     // ...
+    /// ]
+    /// ```
+    pub fn address_map<'a>(&'a self) -> Option<impl Iterator<Item = (usize, Option<u32>)> + 'a> {
+        Some(
+            wasmtime_environ::iterate_address_map(
+                self.code_object().code_memory().address_map_data(),
+            )?
+            .map(|(offset, file_pos)| (offset as usize, file_pos.file_offset())),
+        )
+    }
+
+    /// Get this module's code object's `.text` section, containing its compiled
+    /// executable code.
+    pub fn text(&self) -> &[u8] {
+        self.code_object().code_memory().text()
+    }
+
+    /// Get information about functions in this module's `.text` section: their
+    /// index, name, and offset+length.
+    ///
+    /// Results are yielded in a ModuleFunction struct.
+    pub fn functions<'a>(&'a self) -> impl ExactSizeIterator<Item = ModuleFunction> + 'a {
+        let module = self.compiled_module();
+        module.finished_functions().map(|(idx, _)| {
+            let loc = module.func_loc(idx);
+            let idx = module.module().func_index(idx);
+            ModuleFunction {
+                index: idx,
+                name: module.func_name(idx).map(|n| n.to_string()),
+                offset: loc.start as usize,
+                len: loc.length as usize,
+            }
+        })
+    }
+
+    pub(crate) fn id(&self) -> CompiledModuleId {
+        self.inner.module.unique_id()
+    }
+
+    pub(crate) fn offsets(&self) -> &VMOffsets<HostPtr> {
+        &self.inner.offsets
+    }
+
+    /// Return the address, in memory, of the trampoline that allows Wasm to
+    /// call a array function of the given signature.
+    pub(crate) fn wasm_to_array_trampoline(
+        &self,
+        signature: VMSharedTypeIndex,
+    ) -> Option<NonNull<VMWasmCallFunction>> {
+        log::trace!("Looking up trampoline for {signature:?}");
+        let trampoline_shared_ty = self.inner.engine.signatures().trampoline_type(signature);
+        let trampoline_module_ty = self
+            .inner
+            .code
+            .signatures()
+            .trampoline_type(trampoline_shared_ty)?;
+        debug_assert!(self
+            .inner
+            .engine
+            .signatures()
+            .borrow(
+                self.inner
+                    .code
+                    .signatures()
+                    .shared_type(trampoline_module_ty)
+                    .unwrap()
+            )
+            .unwrap()
+            .unwrap_func()
+            .is_trampoline_type());
+
+        let ptr = self
+            .compiled_module()
+            .wasm_to_array_trampoline(trampoline_module_ty)
+            .as_ptr()
+            .cast::<VMWasmCallFunction>()
+            .cast_mut();
+        Some(NonNull::new(ptr).unwrap())
+    }
+
+    pub(crate) fn memory_images(&self) -> Result<Option<&ModuleMemoryImages>> {
+        let images = self
+            .inner
+            .memory_images
+            .get_or_try_init(|| memory_images(&self.inner.engine, &self.inner.module))?
+            .as_ref();
+        Ok(images)
+    }
+}
+
+/// Describes a function for a given module.
+pub struct ModuleFunction {
+    pub index: wasmtime_environ::FuncIndex,
+    pub name: Option<String>,
+    pub offset: usize,
+    pub len: usize,
+}
+
+impl Drop for ModuleInner {
+    fn drop(&mut self) {
+        // When a `Module` is being dropped that means that it's no longer
+        // present in any `Store` and it's additionally not longer held by any
+        // embedder. Take this opportunity to purge any lingering instantiations
+        // within a pooling instance allocator, if applicable.
+        self.engine
+            .allocator()
+            .purge_module(self.module.unique_id());
+    }
+}
+
+/// Describes the location of an export in a module.
+#[derive(Copy, Clone)]
+pub struct ModuleExport {
+    /// The module that this export is defined in.
+    pub(crate) module: CompiledModuleId,
+    /// A raw index into the wasm module.
+    pub(crate) entity: EntityIndex,
+    /// The index of the export name.
+    pub(crate) export_name_index: usize,
+}
+
+fn _assert_send_sync() {
+    fn _assert<T: Send + Sync>() {}
+    _assert::<Module>();
+}
+
+impl crate::runtime::vm::ModuleInfo for ModuleInner {
+    fn lookup_stack_map(&self, pc: usize) -> Option<&wasmtime_environ::StackMap> {
+        let text_offset = pc - self.module.text().as_ptr() as usize;
+        let (index, func_offset) = self.module.func_by_text_offset(text_offset)?;
+        let info = self.module.wasm_func_info(index);
+
+        // Do a binary search to find the stack map for the given offset.
+        let index = match info
+            .stack_maps
+            .binary_search_by_key(&func_offset, |i| i.code_offset)
+        {
+            // Found it.
+            Ok(i) => i,
+
+            // No stack map associated with this PC.
+            //
+            // Because we know we are in Wasm code, and we must be at some kind
+            // of call/safepoint, then the Cranelift backend must have avoided
+            // emitting a stack map for this location because no refs were live.
+            Err(_) => return None,
+        };
+
+        Some(&info.stack_maps[index].stack_map)
+    }
+}
+
+/// Helper method to construct a `ModuleMemoryImages` for an associated
+/// `CompiledModule`.
+fn memory_images(engine: &Engine, module: &CompiledModule) -> Result<Option<ModuleMemoryImages>> {
+    // If initialization via copy-on-write is explicitly disabled in
+    // configuration then this path is skipped entirely.
+    if !engine.config().memory_init_cow {
+        return Ok(None);
+    }
+
+    // ... otherwise logic is delegated to the `ModuleMemoryImages::new`
+    // constructor.
+    let mmap = if engine.config().force_memory_init_memfd {
+        None
+    } else {
+        Some(module.mmap())
+    };
+    ModuleMemoryImages::new(module.module(), module.code_memory().wasm_data(), mmap)
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{Engine, Module};
+    use wasmtime_environ::MemoryInitialization;
+
+    #[test]
+    fn cow_on_by_default() {
+        let engine = Engine::default();
+        let module = Module::new(
+            &engine,
+            r#"
+                (module
+                    (memory 1)
+                    (data (i32.const 100) "abcd")
+                )
+            "#,
+        )
+        .unwrap();
+
+        let init = &module.env_module().memory_initialization;
+        assert!(matches!(init, MemoryInitialization::Static { .. }));
+    }
+}
diff --git a/crates/wasmtime/src/module/registry.rs b/crates/wasmtime/src/runtime/module/registry.rs
similarity index 87%
rename from crates/wasmtime/src/module/registry.rs
rename to crates/wasmtime/src/runtime/module/registry.rs
index 65de4bf22536..8c7293e662be 100644
--- a/crates/wasmtime/src/module/registry.rs
+++ b/crates/wasmtime/src/runtime/module/registry.rs
@@ -3,16 +3,14 @@
 use crate::code::CodeObject;
 #[cfg(feature = "component-model")]
 use crate::component::Component;
-use crate::{FrameInfo, Module, Trap};
-use once_cell::sync::Lazy;
-use std::collections::btree_map::Entry;
-use std::{
-    collections::BTreeMap,
-    ptr::NonNull,
-    sync::{Arc, RwLock},
-};
-use wasmtime_jit::CodeMemory;
-use wasmtime_runtime::{ModuleInfo, VMSharedSignatureIndex, VMWasmCallFunction};
+use crate::prelude::*;
+use crate::runtime::vm::VMWasmCallFunction;
+use crate::sync::{OnceLock, RwLock};
+use crate::{code_memory::CodeMemory, FrameInfo, Module};
+use alloc::collections::btree_map::{BTreeMap, Entry};
+use alloc::sync::Arc;
+use core::ptr::NonNull;
+use wasmtime_environ::VMSharedTypeIndex;
 
 /// Used for registering modules with a store.
 ///
@@ -35,9 +33,9 @@ pub struct ModuleRegistry {
 }
 
 struct LoadedCode {
-    /// Representation of loaded code which could be either a component or a
-    /// module.
-    code: Arc<CodeObject>,
+    /// Kept alive here in the store to have a strong reference to keep the
+    /// relevant code mapped while the store is alive.
+    _code: Arc<CodeObject>,
 
     /// Modules found within `self.code`, keyed by start address here of the
     /// address of the first function in the module.
@@ -68,7 +66,7 @@ impl ModuleRegistry {
     }
 
     /// Fetches information about a registered module given a program counter value.
-    pub fn lookup_module_info(&self, pc: usize) -> Option<&dyn ModuleInfo> {
+    pub fn lookup_module_info(&self, pc: usize) -> Option<&dyn crate::runtime::vm::ModuleInfo> {
         let (module, _) = self.module_and_offset(pc)?;
         Some(module.module_info())
     }
@@ -154,7 +152,7 @@ impl ModuleRegistry {
         }
 
         let mut item = LoadedCode {
-            code: code.clone(),
+            _code: code.clone(),
             modules: Default::default(),
         };
         if let Some(module) = module {
@@ -165,12 +163,6 @@ impl ModuleRegistry {
         id
     }
 
-    /// Fetches trap information about a program counter in a backtrace.
-    pub fn lookup_trap_code(&self, pc: usize) -> Option<Trap> {
-        let (code, offset) = self.code(pc)?;
-        wasmtime_environ::lookup_trap_code(code.code.code_memory().trap_data(), offset)
-    }
-
     /// Fetches frame information about a program counter in a backtrace.
     ///
     /// Returns an object if this `pc` is known to some previously registered
@@ -185,9 +177,9 @@ impl ModuleRegistry {
         Some((info, module))
     }
 
-    pub fn wasm_to_native_trampoline(
+    pub fn wasm_to_array_trampoline(
         &self,
-        sig: VMSharedSignatureIndex,
+        sig: VMSharedTypeIndex,
     ) -> Option<NonNull<VMWasmCallFunction>> {
         // TODO: We are doing a linear search over each module. This is fine for
         // now because we typically have very few modules per store (almost
@@ -198,7 +190,7 @@ impl ModuleRegistry {
         // See also the comment in `ModuleInner::wasm_to_native_trampoline`.
         for (_, code) in self.loaded_code.values() {
             for module in code.modules.values() {
-                if let Some(trampoline) = module.runtime_info().wasm_to_native_trampoline(sig) {
+                if let Some(trampoline) = module.wasm_to_array_trampoline(sig) {
                     return Some(trampoline);
                 }
             }
@@ -255,27 +247,20 @@ impl LoadedCode {
 // it is also automatically registered with the singleton global module
 // registry. When a `ModuleRegistry` is destroyed then all of its entries
 // are removed from the global registry.
-static GLOBAL_CODE: Lazy<RwLock<GlobalRegistry>> = Lazy::new(Default::default);
+fn global_code() -> &'static RwLock<GlobalRegistry> {
+    static GLOBAL_CODE: OnceLock<RwLock<GlobalRegistry>> = OnceLock::new();
+    GLOBAL_CODE.get_or_init(Default::default)
+}
 
 type GlobalRegistry = BTreeMap<usize, (usize, Arc<CodeMemory>)>;
 
-/// Returns whether the `pc`, according to globally registered information,
-/// is a wasm trap or not.
-pub fn is_wasm_trap_pc(pc: usize) -> bool {
-    let (code, text_offset) = {
-        let all_modules = GLOBAL_CODE.read().unwrap();
-
-        let (end, (start, module)) = match all_modules.range(pc..).next() {
-            Some(info) => info,
-            None => return false,
-        };
-        if pc < *start || *end < pc {
-            return false;
-        }
-        (module.clone(), pc - *start)
-    };
-
-    wasmtime_environ::lookup_trap_code(code.trap_data(), text_offset).is_some()
+/// Find which registered region of code contains the given program counter, and
+/// what offset that PC is within that module's code.
+pub fn lookup_code(pc: usize) -> Option<(Arc<CodeMemory>, usize)> {
+    let all_modules = global_code().read();
+    let (_end, (start, module)) = all_modules.range(pc..).next()?;
+    let text_offset = pc.checked_sub(*start)?;
+    Some((module.clone(), text_offset))
 }
 
 /// Registers a new region of code.
@@ -293,10 +278,7 @@ pub fn register_code(code: &Arc<CodeMemory>) {
     }
     let start = text.as_ptr() as usize;
     let end = start + text.len() - 1;
-    let prev = GLOBAL_CODE
-        .write()
-        .unwrap()
-        .insert(end, (start, code.clone()));
+    let prev = global_code().write().insert(end, (start, code.clone()));
     assert!(prev.is_none());
 }
 
@@ -309,7 +291,7 @@ pub fn unregister_code(code: &Arc<CodeMemory>) {
         return;
     }
     let end = (text.as_ptr() as usize) + text.len() - 1;
-    let code = GLOBAL_CODE.write().unwrap().remove(&end);
+    let code = global_code().write().remove(&end);
     assert!(code.is_some());
 }
 
diff --git a/crates/wasmtime/src/runtime/profiling.rs b/crates/wasmtime/src/runtime/profiling.rs
new file mode 100644
index 000000000000..fded2a481779
--- /dev/null
+++ b/crates/wasmtime/src/runtime/profiling.rs
@@ -0,0 +1,280 @@
+use crate::instantiate::CompiledModule;
+use crate::prelude::*;
+use crate::runtime::vm::Backtrace;
+use crate::{AsContext, CallHook, Module};
+use fxprof_processed_profile::debugid::DebugId;
+use fxprof_processed_profile::{
+    CategoryHandle, Frame, FrameFlags, FrameInfo, LibraryInfo, MarkerLocation, MarkerSchema,
+    MarkerTiming, Profile, ProfilerMarker, ReferenceTimestamp, Symbol, SymbolTable, Timestamp,
+};
+use std::ops::Range;
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+use wasmtime_environ::demangle_function_name_or_index;
+
+// TODO: collect more data
+// - On non-Windows, measure thread-local CPU usage between events with
+//   rustix::time::clock_gettime(ClockId::ThreadCPUTime)
+// - Report which wasm module, and maybe instance, each frame came from
+
+/// Collects basic profiling data for a single WebAssembly guest.
+///
+/// This profiler can't provide measurements that are as accurate or detailed
+/// as a platform-specific profiler, such as `perf` on Linux. On the other
+/// hand, this profiler works on every platform that Wasmtime supports. Also,
+/// as an embedder you can use this profiler selectively on individual guest
+/// instances rather than profiling the entire process.
+///
+/// To use this, you'll need to arrange to call [`GuestProfiler::sample`] at
+/// regular intervals while the guest is on the stack. The most straightforward
+/// way to do that is to call it from a callback registered with
+/// [`Store::epoch_deadline_callback()`](crate::Store::epoch_deadline_callback).
+///
+/// # Accuracy
+///
+/// The data collection granularity is limited by the mechanism you use to
+/// interrupt guest execution and collect a profiling sample.
+///
+/// If you use epoch interruption, then samples will only be collected at
+/// function entry points and loop headers. This introduces some bias to the
+/// results. In addition, samples will only be taken at times when WebAssembly
+/// functions are running, not during host-calls.
+///
+/// It is technically possible to use fuel interruption instead. That
+/// introduces worse bias since samples occur after a certain number of
+/// WebAssembly instructions, which can take different amounts of time.
+///
+/// You may instead be able to use platform-specific methods, such as
+/// `setitimer(ITIMER_VIRTUAL, ...)` on POSIX-compliant systems, to sample on
+/// a more accurate interval. The only current requirement is that the guest
+/// you wish to profile must be on the same stack where you call `sample`,
+/// and executing within the same thread. However, the `GuestProfiler::sample`
+/// method is not currently async-signal-safe, so doing this correctly is not
+/// easy.
+///
+/// # Security
+///
+/// Profiles produced using this profiler do not include any configuration
+/// details from the host, such as virtual memory addresses, or from any
+/// WebAssembly modules that you haven't specifically allowed. So for
+/// example, these profiles should be safe to share with untrusted users
+/// who have provided untrusted code that you are running in a multi-tenancy
+/// environment.
+///
+/// However, the profile does include byte offsets into the text section of
+/// the compiled module, revealing some information about the size of the code
+/// generated for each module. For user-provided modules, the user could get
+/// the same information by compiling the module for themself using a similar
+/// version of Wasmtime on the same target architecture, but for any module
+/// where they don't already have the WebAssembly module binary available this
+/// could theoretically lead to an undesirable information disclosure. So you
+/// should only include user-provided modules in profiles.
+#[derive(Debug)]
+pub struct GuestProfiler {
+    profile: Profile,
+    modules: Modules,
+    process: fxprof_processed_profile::ProcessHandle,
+    thread: fxprof_processed_profile::ThreadHandle,
+    start: Instant,
+}
+
+type Modules = Vec<(Range<usize>, fxprof_processed_profile::LibraryHandle)>;
+
+impl GuestProfiler {
+    /// Begin profiling a new guest. When this function is called, the current
+    /// wall-clock time is recorded as the start time for the guest.
+    ///
+    /// The `module_name` parameter is recorded in the profile to help identify
+    /// where the profile came from.
+    ///
+    /// The `interval` parameter should match the rate at which you intend
+    /// to call `sample`. However, this is used as a hint and not required to
+    /// exactly match the real sample rate.
+    ///
+    /// Only modules which are present in the `modules` vector will appear in
+    /// stack traces in this profile. Any stack frames which were executing
+    /// host code or functions from other modules will be omitted. See the
+    /// "Security" section of the [`GuestProfiler`] documentation for guidance
+    /// on what modules should not be included in this list.
+    pub fn new(module_name: &str, interval: Duration, modules: Vec<(String, Module)>) -> Self {
+        let zero = ReferenceTimestamp::from_millis_since_unix_epoch(0.0);
+        let mut profile = Profile::new(module_name, zero, interval.into());
+
+        let mut modules: Vec<_> = modules
+            .into_iter()
+            .filter_map(|(name, module)| {
+                let compiled = module.compiled_module();
+                let text = compiled.text().as_ptr_range();
+                let address_range = text.start as usize..text.end as usize;
+                module_symbols(name, compiled).map(|lib| (address_range, profile.add_lib(lib)))
+            })
+            .collect();
+
+        modules.sort_unstable_by_key(|(range, _)| range.start);
+
+        profile.set_reference_timestamp(std::time::SystemTime::now().into());
+        let process = profile.add_process(module_name, 0, Timestamp::from_nanos_since_reference(0));
+        let thread = profile.add_thread(process, 0, Timestamp::from_nanos_since_reference(0), true);
+        let start = Instant::now();
+        Self {
+            profile,
+            modules,
+            process,
+            thread,
+            start,
+        }
+    }
+
+    /// Add a sample to the profile. This function collects a backtrace from
+    /// any stack frames for allowed modules on the current stack. It should
+    /// typically be called from a callback registered using
+    /// [`Store::epoch_deadline_callback()`](crate::Store::epoch_deadline_callback).
+    ///
+    /// The `delta` parameter is the amount of CPU time that was used by this
+    /// guest since the previous sample. It is allowed to pass `Duration::ZERO`
+    /// here if recording CPU usage information is not needed.
+    pub fn sample(&mut self, store: impl AsContext, delta: Duration) {
+        let now = Timestamp::from_nanos_since_reference(
+            self.start.elapsed().as_nanos().try_into().unwrap(),
+        );
+        let backtrace = Backtrace::new(store.as_context().0.vmruntime_limits());
+        let frames = lookup_frames(&self.modules, &backtrace);
+        self.profile
+            .add_sample(self.thread, now, frames, delta.into(), 1);
+    }
+
+    /// Add a marker for transitions between guest and host to the profile.
+    /// This function should typically be called from a callback registered
+    /// using [`Store::call_hook()`](crate::Store::call_hook), and the `kind`
+    /// parameter should be the value of the same type passed into that hook.
+    pub fn call_hook(&mut self, store: impl AsContext, kind: CallHook) {
+        let now = Timestamp::from_nanos_since_reference(
+            self.start.elapsed().as_nanos().try_into().unwrap(),
+        );
+        match kind {
+            CallHook::CallingWasm | CallHook::ReturningFromWasm => {}
+            CallHook::CallingHost => {
+                let backtrace = Backtrace::new(store.as_context().0.vmruntime_limits());
+                let frames = lookup_frames(&self.modules, &backtrace);
+                self.profile.add_marker_with_stack(
+                    self.thread,
+                    "hostcall",
+                    CallMarker,
+                    MarkerTiming::IntervalStart(now),
+                    frames,
+                );
+            }
+            CallHook::ReturningFromHost => {
+                self.profile.add_marker(
+                    self.thread,
+                    "hostcall",
+                    CallMarker,
+                    MarkerTiming::IntervalEnd(now),
+                );
+            }
+        }
+    }
+
+    /// When the guest finishes running, call this function to write the
+    /// profile to the given `output`. The output is a JSON-formatted object in
+    /// the [Firefox "processed profile format"][fmt]. Files in this format may
+    /// be visualized at <https://profiler.firefox.com/>.
+    ///
+    /// [fmt]: https://github.com/firefox-devtools/profiler/blob/main/docs-developer/processed-profile-format.md
+    pub fn finish(mut self, output: impl std::io::Write) -> Result<()> {
+        let now = Timestamp::from_nanos_since_reference(
+            self.start.elapsed().as_nanos().try_into().unwrap(),
+        );
+        self.profile.set_thread_end_time(self.thread, now);
+        self.profile.set_process_end_time(self.process, now);
+
+        serde_json::to_writer(output, &self.profile)?;
+        Ok(())
+    }
+}
+
+fn module_symbols(name: String, compiled: &CompiledModule) -> Option<LibraryInfo> {
+    let symbols = Vec::from_iter(compiled.finished_functions().map(|(defined_idx, _)| {
+        let loc = compiled.func_loc(defined_idx);
+        let func_idx = compiled.module().func_index(defined_idx);
+        let mut name = String::new();
+        demangle_function_name_or_index(
+            &mut name,
+            compiled.func_name(func_idx),
+            defined_idx.as_u32() as usize,
+        )
+        .unwrap();
+        Symbol {
+            address: loc.start,
+            size: Some(loc.length),
+            name,
+        }
+    }));
+    if symbols.is_empty() {
+        return None;
+    }
+
+    Some(LibraryInfo {
+        name,
+        debug_name: String::new(),
+        path: String::new(),
+        debug_path: String::new(),
+        debug_id: DebugId::nil(),
+        code_id: None,
+        arch: None,
+        symbol_table: Some(Arc::new(SymbolTable::new(symbols))),
+    })
+}
+
+fn lookup_frames<'a>(
+    modules: &'a Modules,
+    backtrace: &'a Backtrace,
+) -> impl Iterator<Item = FrameInfo> + 'a {
+    backtrace
+        .frames()
+        // Samply needs to see the oldest frame first, but we list the newest
+        // first, so iterate in reverse.
+        .rev()
+        .filter_map(|frame| {
+            // Find the first module whose start address includes this PC.
+            let module_idx = modules.partition_point(|(range, _)| range.start > frame.pc());
+            if let Some((range, lib)) = modules.get(module_idx) {
+                if range.contains(&frame.pc()) {
+                    return Some(FrameInfo {
+                        frame: Frame::RelativeAddressFromReturnAddress(
+                            *lib,
+                            u32::try_from(frame.pc() - range.start).unwrap(),
+                        ),
+                        category_pair: CategoryHandle::OTHER.into(),
+                        flags: FrameFlags::empty(),
+                    });
+                }
+            }
+            None
+        })
+}
+
+struct CallMarker;
+
+impl ProfilerMarker for CallMarker {
+    const MARKER_TYPE_NAME: &'static str = "hostcall";
+
+    fn schema() -> MarkerSchema {
+        MarkerSchema {
+            type_name: Self::MARKER_TYPE_NAME,
+            locations: vec![
+                MarkerLocation::MarkerChart,
+                MarkerLocation::MarkerTable,
+                MarkerLocation::TimelineOverview,
+            ],
+            chart_label: None,
+            tooltip_label: None,
+            table_label: None,
+            fields: vec![],
+        }
+    }
+
+    fn json_marker_data(&self) -> serde_json::Value {
+        serde_json::json!({ "type": Self::MARKER_TYPE_NAME })
+    }
+}
diff --git a/crates/wasmtime/src/runtime/resources.rs b/crates/wasmtime/src/runtime/resources.rs
new file mode 100644
index 000000000000..540f7b37b299
--- /dev/null
+++ b/crates/wasmtime/src/runtime/resources.rs
@@ -0,0 +1,33 @@
+/// A summary of the amount of resources required to instantiate a particular
+/// [`Module`][crate::Module] or [`Component`][crate::component::Component].
+///
+/// Example uses of this information:
+///
+/// * Determining whether your pooling allocator configuration supports
+///   instantiating this module.
+///
+/// * Deciding how many of which `Module` you want to instantiate within a
+///   fixed amount of resources, e.g. determining whether to create 5
+///   instances of module `X` or 10 instances of module `Y`.
+pub struct ResourcesRequired {
+    /// The number of memories that are required.
+    pub num_memories: u32,
+    /// The maximum initial size required by any memory, in units of Wasm pages.
+    pub max_initial_memory_size: Option<u64>,
+    /// The number of tables that are required.
+    pub num_tables: u32,
+    /// The maximum initial size required by any table.
+    pub max_initial_table_size: Option<u32>,
+}
+
+impl ResourcesRequired {
+    #[cfg(feature = "component-model")]
+    pub(crate) fn add(&mut self, other: &ResourcesRequired) {
+        self.num_memories += other.num_memories;
+        self.max_initial_memory_size =
+            core::cmp::max(self.max_initial_memory_size, other.max_initial_memory_size);
+        self.num_tables += other.num_tables;
+        self.max_initial_table_size =
+            core::cmp::max(self.max_initial_table_size, other.max_initial_table_size);
+    }
+}
diff --git a/crates/wasmtime/src/signatures.rs b/crates/wasmtime/src/runtime/signatures.rs
similarity index 99%
rename from crates/wasmtime/src/signatures.rs
rename to crates/wasmtime/src/runtime/signatures.rs
index 6ce6b0150423..11374a7ab568 100644
--- a/crates/wasmtime/src/signatures.rs
+++ b/crates/wasmtime/src/runtime/signatures.rs
@@ -1,13 +1,13 @@
 //! Implement a registry of function signatures, for fast indirect call
 //! signature checking.
 
+use crate::runtime::vm::VMSharedSignatureIndex;
 use std::{
     collections::{hash_map::Entry, HashMap},
     sync::RwLock,
 };
 use std::{convert::TryFrom, sync::Arc};
 use wasmtime_environ::{ModuleTypes, PrimaryMap, SignatureIndex, WasmFuncType};
-use wasmtime_runtime::VMSharedSignatureIndex;
 
 /// Represents a collection of shared signatures.
 ///
diff --git a/crates/wasmtime/src/runtime/stack.rs b/crates/wasmtime/src/runtime/stack.rs
new file mode 100644
index 000000000000..703c03691379
--- /dev/null
+++ b/crates/wasmtime/src/runtime/stack.rs
@@ -0,0 +1,72 @@
+use crate::prelude::*;
+use std::{ops::Range, sync::Arc};
+use wasmtime_fiber::{RuntimeFiberStack, RuntimeFiberStackCreator};
+
+/// A stack creator. Can be used to provide a stack creator to wasmtime
+/// which supplies stacks for async support.
+///
+/// # Safety
+///
+/// This trait is unsafe, as memory safety depends on a proper implementation
+/// of memory management. Stacks created by the StackCreator should always be
+/// treated as owned by an wasmtime instance, and any modification of them
+/// outside of wasmtime invoked routines is unsafe and may lead to corruption.
+///
+/// Note that this is a relatively new and experimental feature and it is
+/// recommended to be familiar with wasmtime runtime code to use it.
+pub unsafe trait StackCreator: Send + Sync {
+    /// Create a new `StackMemory` object with the specified size.
+    ///
+    /// The `size` parameter is the expected size of the stack without any guard pages.
+    ///
+    /// Note there should be at least one guard page of protected memory at the bottom
+    /// of the stack to catch potential stack overflow scenarios. Additionally, stacks should be
+    /// page aligned and zero filled.
+    fn new_stack(&self, size: usize) -> Result<Box<dyn StackMemory>, Error>;
+}
+
+#[derive(Clone)]
+pub(crate) struct StackCreatorProxy(pub Arc<dyn StackCreator>);
+
+unsafe impl RuntimeFiberStackCreator for StackCreatorProxy {
+    fn new_stack(&self, size: usize) -> Result<Box<dyn RuntimeFiberStack>, Error> {
+        let stack = self.0.new_stack(size)?;
+        Ok(Box::new(FiberStackProxy(stack)) as Box<dyn RuntimeFiberStack>)
+    }
+}
+
+/// A stack memory. This trait provides an interface for raw memory buffers
+/// which are used by wasmtime inside of stacks which wasmtime executes
+/// WebAssembly in for async support. By implementing this trait together
+/// with StackCreator, one can supply wasmtime with custom allocated host
+/// managed stacks.
+///
+/// # Safety
+///
+/// The memory should be page aligned and a multiple of page size.
+/// To prevent possible silent overflows, the memory should be protected by a
+/// guard page. Additionally the safety concerns explained in ['Memory'], for
+/// accessing the memory apply here as well.
+///
+/// Note that this is a relatively new and experimental feature and it is
+/// recommended to be familiar with wasmtime runtime code to use it.
+pub unsafe trait StackMemory: Send + Sync {
+    /// The top of the allocated stack.
+    ///
+    /// This address should be page aligned.
+    fn top(&self) -> *mut u8;
+    /// The range of where this stack resides in memory, excluding guard pages.
+    fn range(&self) -> Range<usize>;
+}
+
+pub(crate) struct FiberStackProxy(pub Box<dyn StackMemory>);
+
+unsafe impl RuntimeFiberStack for FiberStackProxy {
+    fn top(&self) -> *mut u8 {
+        self.0.top()
+    }
+
+    fn range(&self) -> Range<usize> {
+        self.0.range()
+    }
+}
diff --git a/crates/wasmtime/src/runtime/store.rs b/crates/wasmtime/src/runtime/store.rs
new file mode 100644
index 000000000000..9d4e1215b2e9
--- /dev/null
+++ b/crates/wasmtime/src/runtime/store.rs
@@ -0,0 +1,2877 @@
+//! Wasmtime's "store" type
+//!
+//! This module, and its submodules, contain the `Store` type and various types
+//! used to interact with it. At first glance this is a pretty confusing module
+//! where you need to know the difference between:
+//!
+//! * `Store<T>`
+//! * `StoreContext<T>`
+//! * `StoreContextMut<T>`
+//! * `AsContext`
+//! * `AsContextMut`
+//! * `StoreInner<T>`
+//! * `StoreOpaque`
+//! * `StoreData`
+//!
+//! There's... quite a lot going on here, and it's easy to be confused. This
+//! comment is ideally going to serve the purpose of clarifying what all these
+//! types are for and why they're motivated.
+//!
+//! First it's important to know what's "internal" and what's "external". Almost
+//! everything above is defined as `pub`, but only some of the items are
+//! reexported to the outside world to be usable from this crate. Otherwise all
+//! items are `pub` within this `store` module, and the `store` module is
+//! private to the `wasmtime` crate. Notably `Store<T>`, `StoreContext<T>`,
+//! `StoreContextMut<T>`, `AsContext`, and `AsContextMut` are all public
+//! interfaces to the `wasmtime` crate. You can think of these as:
+//!
+//! * `Store<T>` - an owned reference to a store, the "root of everything"
+//! * `StoreContext<T>` - basically `&StoreInner<T>`
+//! * `StoreContextMut<T>` - more-or-less `&mut StoreInner<T>` with caveats.
+//!   Explained later.
+//! * `AsContext` - similar to `AsRef`, but produces `StoreContext<T>`
+//! * `AsContextMut` - similar to `AsMut`, but produces `StoreContextMut<T>`
+//!
+//! Next comes the internal structure of the `Store<T>` itself. This looks like:
+//!
+//! * `Store<T>` - this type is just a pointer large. It's primarily just
+//!   intended to be consumed by the outside world. Note that the "just a
+//!   pointer large" is a load-bearing implementation detail in Wasmtime. This
+//!   enables it to store a pointer to its own trait object which doesn't need
+//!   to change over time.
+//!
+//! * `StoreInner<T>` - the first layer of the contents of a `Store<T>`, what's
+//!   stored inside the `Box`. This is the general Rust pattern when one struct
+//!   is a layer over another. The surprising part, though, is that this is
+//!   further subdivided. This structure only contains things which actually
+//!   need `T` itself. The downside of this structure is that it's always
+//!   generic and means that code is monomorphized into consumer crates. We
+//!   strive to have things be as monomorphic as possible in `wasmtime` so this
+//!   type is not heavily used.
+//!
+//! * `StoreOpaque` - this is the primary contents of the `StoreInner<T>` type.
+//!   Stored inline in the outer type the "opaque" here means that it's a
+//!   "store" but it doesn't have access to the `T`. This is the primary
+//!   "internal" reference that Wasmtime uses since `T` is rarely needed by the
+//!   internals of Wasmtime.
+//!
+//! * `StoreData` - this is a final helper struct stored within `StoreOpaque`.
+//!   All references of Wasm items into a `Store` are actually indices into a
+//!   table in this structure, and the `StoreData` being separate makes it a bit
+//!   easier to manage/define/work with. There's no real fundamental reason this
+//!   is split out, although sometimes it's useful to have separate borrows into
+//!   these tables than the `StoreOpaque`.
+//!
+//! A major caveat with these representations is that the internal `&mut
+//! StoreInner<T>` is never handed out publicly to consumers of this crate, only
+//! through a wrapper of `StoreContextMut<'_, T>`. The reason for this is that
+//! we want to provide mutable, but not destructive, access to the contents of a
+//! `Store`. For example if a `StoreInner<T>` were replaced with some other
+//! `StoreInner<T>` then that would drop live instances, possibly those
+//! currently executing beneath the current stack frame. This would not be a
+//! safe operation.
+//!
+//! This means, though, that the `wasmtime` crate, which liberally uses `&mut
+//! StoreOpaque` internally, has to be careful to never actually destroy the
+//! contents of `StoreOpaque`. This is an invariant that we, as the authors of
+//! `wasmtime`, must uphold for the public interface to be safe.
+
+use crate::instance::InstanceData;
+use crate::linker::Definition;
+use crate::module::RegisteredModuleId;
+use crate::prelude::*;
+use crate::runtime::vm::mpk::{self, ProtectionKey, ProtectionMask};
+use crate::runtime::vm::{
+    Backtrace, ExportGlobal, GcHeapAllocationIndex, GcRootsList, GcStore,
+    InstanceAllocationRequest, InstanceAllocator, InstanceHandle, ModuleRuntimeInfo,
+    OnDemandInstanceAllocator, SignalHandler, StoreBox, StorePtr, VMContext, VMFuncRef, VMGcRef,
+    VMRuntimeLimits, WasmFault,
+};
+use crate::trampoline::VMHostGlobalContext;
+use crate::type_registry::RegisteredType;
+use crate::RootSet;
+use crate::{module::ModuleRegistry, Engine, Module, Trap, Val, ValRaw};
+use crate::{Global, Instance, Memory, RootScope, Table, Uninhabited};
+use alloc::sync::Arc;
+use core::cell::UnsafeCell;
+use core::fmt;
+use core::future::Future;
+use core::marker;
+use core::mem::{self, ManuallyDrop};
+use core::num::NonZeroU64;
+use core::ops::{Deref, DerefMut};
+use core::pin::Pin;
+use core::ptr;
+use core::sync::atomic::AtomicU64;
+use core::task::{Context, Poll};
+
+mod context;
+pub use self::context::*;
+mod data;
+pub use self::data::*;
+mod func_refs;
+use func_refs::FuncRefs;
+
+/// A [`Store`] is a collection of WebAssembly instances and host-defined state.
+///
+/// All WebAssembly instances and items will be attached to and refer to a
+/// [`Store`]. For example instances, functions, globals, and tables are all
+/// attached to a [`Store`]. Instances are created by instantiating a
+/// [`Module`](crate::Module) within a [`Store`].
+///
+/// A [`Store`] is intended to be a short-lived object in a program. No form
+/// of GC is implemented at this time so once an instance is created within a
+/// [`Store`] it will not be deallocated until the [`Store`] itself is dropped.
+/// This makes [`Store`] unsuitable for creating an unbounded number of
+/// instances in it because [`Store`] will never release this memory. It's
+/// recommended to have a [`Store`] correspond roughly to the lifetime of a
+/// "main instance" that an embedding is interested in executing.
+///
+/// ## Type parameter `T`
+///
+/// Each [`Store`] has a type parameter `T` associated with it. This `T`
+/// represents state defined by the host. This state will be accessible through
+/// the [`Caller`](crate::Caller) type that host-defined functions get access
+/// to. This `T` is suitable for storing `Store`-specific information which
+/// imported functions may want access to.
+///
+/// The data `T` can be accessed through methods like [`Store::data`] and
+/// [`Store::data_mut`].
+///
+/// ## Stores, contexts, oh my
+///
+/// Most methods in Wasmtime take something of the form
+/// [`AsContext`](crate::AsContext) or [`AsContextMut`](crate::AsContextMut) as
+/// the first argument. These two traits allow ergonomically passing in the
+/// context you currently have to any method. The primary two sources of
+/// contexts are:
+///
+/// * `Store<T>`
+/// * `Caller<'_, T>`
+///
+/// corresponding to what you create and what you have access to in a host
+/// function. You can also explicitly acquire a [`StoreContext`] or
+/// [`StoreContextMut`] and pass that around as well.
+///
+/// Note that all methods on [`Store`] are mirrored onto [`StoreContext`],
+/// [`StoreContextMut`], and [`Caller`](crate::Caller). This way no matter what
+/// form of context you have you can call various methods, create objects, etc.
+///
+/// ## Stores and `Default`
+///
+/// You can create a store with default configuration settings using
+/// `Store::default()`. This will create a brand new [`Engine`] with default
+/// configuration (see [`Config`](crate::Config) for more information).
+///
+/// ## Cross-store usage of items
+///
+/// In `wasmtime` wasm items such as [`Global`] and [`Memory`] "belong" to a
+/// [`Store`]. The store they belong to is the one they were created with
+/// (passed in as a parameter) or instantiated with. This store is the only
+/// store that can be used to interact with wasm items after they're created.
+///
+/// The `wasmtime` crate will panic if the [`Store`] argument passed in to these
+/// operations is incorrect. In other words it's considered a programmer error
+/// rather than a recoverable error for the wrong [`Store`] to be used when
+/// calling APIs.
+pub struct Store<T> {
+    // for comments about `ManuallyDrop`, see `Store::into_data`
+    inner: ManuallyDrop<Box<StoreInner<T>>>,
+}
+
+#[derive(Copy, Clone, Debug)]
+/// Passed to the argument of [`Store::call_hook`] to indicate a state transition in
+/// the WebAssembly VM.
+pub enum CallHook {
+    /// Indicates the VM is calling a WebAssembly function, from the host.
+    CallingWasm,
+    /// Indicates the VM is returning from a WebAssembly function, to the host.
+    ReturningFromWasm,
+    /// Indicates the VM is calling a host function, from WebAssembly.
+    CallingHost,
+    /// Indicates the VM is returning from a host function, to WebAssembly.
+    ReturningFromHost,
+}
+
+impl CallHook {
+    /// Indicates the VM is entering host code (exiting WebAssembly code)
+    pub fn entering_host(&self) -> bool {
+        match self {
+            CallHook::ReturningFromWasm | CallHook::CallingHost => true,
+            _ => false,
+        }
+    }
+    /// Indicates the VM is exiting host code (entering WebAssembly code)
+    pub fn exiting_host(&self) -> bool {
+        match self {
+            CallHook::ReturningFromHost | CallHook::CallingWasm => true,
+            _ => false,
+        }
+    }
+}
+
+/// Internal contents of a `Store<T>` that live on the heap.
+///
+/// The members of this struct are those that need to be generic over `T`, the
+/// store's internal type storage. Otherwise all things that don't rely on `T`
+/// should go into `StoreOpaque`.
+pub struct StoreInner<T> {
+    /// Generic metadata about the store that doesn't need access to `T`.
+    inner: StoreOpaque,
+
+    limiter: Option<ResourceLimiterInner<T>>,
+    call_hook: Option<CallHookInner<T>>,
+    epoch_deadline_behavior:
+        Option<Box<dyn FnMut(StoreContextMut<T>) -> Result<UpdateDeadline> + Send + Sync>>,
+    // for comments about `ManuallyDrop`, see `Store::into_data`
+    data: ManuallyDrop<T>,
+}
+
+enum ResourceLimiterInner<T> {
+    Sync(Box<dyn FnMut(&mut T) -> &mut (dyn crate::ResourceLimiter) + Send + Sync>),
+    #[cfg(feature = "async")]
+    Async(Box<dyn FnMut(&mut T) -> &mut (dyn crate::ResourceLimiterAsync) + Send + Sync>),
+}
+
+/// An object that can take callbacks when the runtime enters or exits hostcalls.
+#[cfg(all(feature = "async", feature = "call-hook"))]
+#[async_trait::async_trait]
+pub trait CallHookHandler<T>: Send {
+    /// A callback to run when wasmtime is about to enter a host call, or when about to
+    /// exit the hostcall.
+    async fn handle_call_event(&self, t: StoreContextMut<'_, T>, ch: CallHook) -> Result<()>;
+}
+
+enum CallHookInner<T> {
+    #[cfg(feature = "call-hook")]
+    Sync(Box<dyn FnMut(StoreContextMut<'_, T>, CallHook) -> Result<()> + Send + Sync>),
+    #[cfg(all(feature = "async", feature = "call-hook"))]
+    Async(Box<dyn CallHookHandler<T> + Send + Sync>),
+    #[allow(dead_code)]
+    ForceTypeParameterToBeUsed {
+        uninhabited: Uninhabited,
+        _marker: marker::PhantomData<T>,
+    },
+}
+
+/// What to do after returning from a callback when the engine epoch reaches
+/// the deadline for a Store during execution of a function using that store.
+pub enum UpdateDeadline {
+    /// Extend the deadline by the specified number of ticks.
+    Continue(u64),
+    /// Extend the deadline by the specified number of ticks after yielding to
+    /// the async executor loop. This can only be used with an async [`Store`]
+    /// configured via [`Config::async_support`](crate::Config::async_support).
+    #[cfg(feature = "async")]
+    Yield(u64),
+}
+
+// Forward methods on `StoreOpaque` to also being on `StoreInner<T>`
+impl<T> Deref for StoreInner<T> {
+    type Target = StoreOpaque;
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+impl<T> DerefMut for StoreInner<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+
+/// Monomorphic storage for a `Store<T>`.
+///
+/// This structure contains the bulk of the metadata about a `Store`. This is
+/// used internally in Wasmtime when dependence on the `T` of `Store<T>` isn't
+/// necessary, allowing code to be monomorphic and compiled into the `wasmtime`
+/// crate itself.
+pub struct StoreOpaque {
+    // This `StoreOpaque` structure has references to itself. These aren't
+    // immediately evident, however, so we need to tell the compiler that it
+    // contains self-references. This notably suppresses `noalias` annotations
+    // when this shows up in compiled code because types of this structure do
+    // indeed alias itself. An example of this is `default_callee` holds a
+    // `*mut dyn Store` to the address of this `StoreOpaque` itself, indeed
+    // aliasing!
+    //
+    // It's somewhat unclear to me at this time if this is 100% sufficient to
+    // get all the right codegen in all the right places. For example does
+    // `Store` need to internally contain a `Pin<Box<StoreInner<T>>>`? Do the
+    // contexts need to contain `Pin<&mut StoreInner<T>>`? I'm not familiar
+    // enough with `Pin` to understand if it's appropriate here (we do, for
+    // example want to allow movement in and out of `data: T`, just not movement
+    // of most of the other members). It's also not clear if using `Pin` in a
+    // few places buys us much other than a bunch of `unsafe` that we already
+    // sort of hand-wave away.
+    //
+    // In any case this seems like a good mid-ground for now where we're at
+    // least telling the compiler something about all the aliasing happening
+    // within a `Store`.
+    _marker: marker::PhantomPinned,
+
+    engine: Engine,
+    runtime_limits: VMRuntimeLimits,
+    instances: Vec<StoreInstance>,
+    #[cfg(feature = "component-model")]
+    num_component_instances: usize,
+    signal_handler: Option<Box<SignalHandler<'static>>>,
+    modules: ModuleRegistry,
+    func_refs: FuncRefs,
+    host_globals: Vec<StoreBox<VMHostGlobalContext>>,
+
+    // GC-related fields.
+    gc_store: Option<GcStore>,
+    gc_roots: RootSet,
+    gc_roots_list: GcRootsList,
+    // Types for which the embedder has created an allocator for.
+    gc_host_alloc_types: hashbrown::HashSet<RegisteredType>,
+
+    // Numbers of resources instantiated in this store, and their limits
+    instance_count: usize,
+    instance_limit: usize,
+    memory_count: usize,
+    memory_limit: usize,
+    table_count: usize,
+    table_limit: usize,
+    #[cfg(feature = "async")]
+    async_state: AsyncState,
+    // If fuel_yield_interval is enabled, then we store the remaining fuel (that isn't in
+    // runtime_limits) here. The total amount of fuel is the runtime limits and reserve added
+    // together. Then when we run out of gas, we inject the yield amount from the reserve
+    // until the reserve is empty.
+    fuel_reserve: u64,
+    fuel_yield_interval: Option<NonZeroU64>,
+    /// Indexed data within this `Store`, used to store information about
+    /// globals, functions, memories, etc.
+    ///
+    /// Note that this is `ManuallyDrop` because it needs to be dropped before
+    /// `rooted_host_funcs` below. This structure contains pointers which are
+    /// otherwise kept alive by the `Arc` references in `rooted_host_funcs`.
+    store_data: ManuallyDrop<StoreData>,
+    default_caller: InstanceHandle,
+
+    /// Used to optimzed wasm->host calls when the host function is defined with
+    /// `Func::new` to avoid allocating a new vector each time a function is
+    /// called.
+    hostcall_val_storage: Vec<Val>,
+    /// Same as `hostcall_val_storage`, but for the direction of the host
+    /// calling wasm.
+    wasm_val_raw_storage: Vec<ValRaw>,
+
+    /// A list of lists of definitions which have been used to instantiate
+    /// within this `Store`.
+    ///
+    /// Note that not all instantiations end up pushing to this list. At the
+    /// time of this writing only the `InstancePre<T>` type will push to this
+    /// list. Pushes to this list are typically accompanied with
+    /// `HostFunc::to_func_store_rooted` to clone an `Arc` here once which
+    /// preserves a strong reference to the `Arc` for each `HostFunc` stored
+    /// within the list of `Definition`s.
+    ///
+    /// Note that this is `ManuallyDrop` as it must be dropped after
+    /// `store_data` above, where the function pointers are stored.
+    rooted_host_funcs: ManuallyDrop<Vec<Arc<[Definition]>>>,
+
+    /// Keep track of what protection key is being used during allocation so
+    /// that the right memory pages can be enabled when entering WebAssembly
+    /// guest code.
+    pkey: Option<ProtectionKey>,
+
+    /// Runtime state for components used in the handling of resources, borrow,
+    /// and calls. These also interact with the `ResourceAny` type and its
+    /// internal representation.
+    #[cfg(feature = "component-model")]
+    component_host_table: crate::runtime::vm::component::ResourceTable,
+    #[cfg(feature = "component-model")]
+    component_calls: crate::runtime::vm::component::CallContexts,
+    #[cfg(feature = "component-model")]
+    host_resource_data: crate::component::HostResourceData,
+}
+
+#[cfg(feature = "async")]
+struct AsyncState {
+    current_suspend: UnsafeCell<*mut wasmtime_fiber::Suspend<Result<()>, (), Result<()>>>,
+    current_poll_cx: UnsafeCell<*mut Context<'static>>,
+}
+
+// Lots of pesky unsafe cells and pointers in this structure. This means we need
+// to declare explicitly that we use this in a threadsafe fashion.
+#[cfg(feature = "async")]
+unsafe impl Send for AsyncState {}
+#[cfg(feature = "async")]
+unsafe impl Sync for AsyncState {}
+
+/// An RAII type to automatically mark a region of code as unsafe for GC.
+#[doc(hidden)]
+pub struct AutoAssertNoGc<'a> {
+    store: &'a mut StoreOpaque,
+    entered: bool,
+}
+
+impl<'a> AutoAssertNoGc<'a> {
+    #[inline]
+    pub fn new(store: &'a mut StoreOpaque) -> Self {
+        let entered = if !cfg!(feature = "gc") {
+            false
+        } else if let Some(gc_store) = store.gc_store.as_mut() {
+            gc_store.gc_heap.enter_no_gc_scope();
+            true
+        } else {
+            false
+        };
+
+        AutoAssertNoGc { store, entered }
+    }
+
+    /// Creates an `AutoAssertNoGc` value which is forcibly "not entered" and
+    /// disables checks for no GC happening for the duration of this value.
+    ///
+    /// This is used when it is statically otherwise known that a GC doesn't
+    /// happen for the various types involved.
+    ///
+    /// # Unsafety
+    ///
+    /// This method is `unsafe` as it does not provide the same safety
+    /// guarantees as `AutoAssertNoGc::new`. It must be guaranteed by the
+    /// caller that a GC doesn't happen.
+    #[inline]
+    pub unsafe fn disabled(store: &'a mut StoreOpaque) -> Self {
+        if cfg!(debug_assertions) {
+            AutoAssertNoGc::new(store)
+        } else {
+            AutoAssertNoGc {
+                store,
+                entered: false,
+            }
+        }
+    }
+}
+
+impl core::ops::Deref for AutoAssertNoGc<'_> {
+    type Target = StoreOpaque;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &*self.store
+    }
+}
+
+impl core::ops::DerefMut for AutoAssertNoGc<'_> {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut *self.store
+    }
+}
+
+impl Drop for AutoAssertNoGc<'_> {
+    #[inline]
+    fn drop(&mut self) {
+        if self.entered {
+            self.store.unwrap_gc_store_mut().gc_heap.exit_no_gc_scope();
+        }
+    }
+}
+
+/// Used to associate instances with the store.
+///
+/// This is needed to track if the instance was allocated explicitly with the on-demand
+/// instance allocator.
+struct StoreInstance {
+    handle: InstanceHandle,
+    kind: StoreInstanceKind,
+}
+
+enum StoreInstanceKind {
+    /// An actual, non-dummy instance.
+    Real {
+        /// The id of this instance's module inside our owning store's
+        /// `ModuleRegistry`.
+        module_id: RegisteredModuleId,
+    },
+
+    /// This is a dummy instance that is just an implementation detail for
+    /// something else. For example, host-created memories internally create a
+    /// dummy instance.
+    ///
+    /// Regardless of the configured instance allocator for the engine, dummy
+    /// instances always use the on-demand allocator to deallocate the instance.
+    Dummy,
+}
+
+impl<T> Store<T> {
+    /// Creates a new [`Store`] to be associated with the given [`Engine`] and
+    /// `data` provided.
+    ///
+    /// The created [`Store`] will place no additional limits on the size of
+    /// linear memories or tables at runtime. Linear memories and tables will
+    /// be allowed to grow to any upper limit specified in their definitions.
+    /// The store will limit the number of instances, linear memories, and
+    /// tables created to 10,000. This can be overridden with the
+    /// [`Store::limiter`] configuration method.
+    pub fn new(engine: &Engine, data: T) -> Self {
+        let pkey = engine.allocator().next_available_pkey();
+
+        let mut inner = Box::new(StoreInner {
+            inner: StoreOpaque {
+                _marker: marker::PhantomPinned,
+                engine: engine.clone(),
+                runtime_limits: Default::default(),
+                instances: Vec::new(),
+                #[cfg(feature = "component-model")]
+                num_component_instances: 0,
+                signal_handler: None,
+                gc_store: None,
+                gc_roots: RootSet::default(),
+                gc_roots_list: GcRootsList::default(),
+                gc_host_alloc_types: hashbrown::HashSet::default(),
+                modules: ModuleRegistry::default(),
+                func_refs: FuncRefs::default(),
+                host_globals: Vec::new(),
+                instance_count: 0,
+                instance_limit: crate::DEFAULT_INSTANCE_LIMIT,
+                memory_count: 0,
+                memory_limit: crate::DEFAULT_MEMORY_LIMIT,
+                table_count: 0,
+                table_limit: crate::DEFAULT_TABLE_LIMIT,
+                #[cfg(feature = "async")]
+                async_state: AsyncState {
+                    current_suspend: UnsafeCell::new(ptr::null_mut()),
+                    current_poll_cx: UnsafeCell::new(ptr::null_mut()),
+                },
+                fuel_reserve: 0,
+                fuel_yield_interval: None,
+                store_data: ManuallyDrop::new(StoreData::new()),
+                default_caller: InstanceHandle::null(),
+                hostcall_val_storage: Vec::new(),
+                wasm_val_raw_storage: Vec::new(),
+                rooted_host_funcs: ManuallyDrop::new(Vec::new()),
+                pkey,
+                #[cfg(feature = "component-model")]
+                component_host_table: Default::default(),
+                #[cfg(feature = "component-model")]
+                component_calls: Default::default(),
+                #[cfg(feature = "component-model")]
+                host_resource_data: Default::default(),
+            },
+            limiter: None,
+            call_hook: None,
+            epoch_deadline_behavior: None,
+            data: ManuallyDrop::new(data),
+        });
+
+        // Wasmtime uses the callee argument to host functions to learn about
+        // the original pointer to the `Store` itself, allowing it to
+        // reconstruct a `StoreContextMut<T>`. When we initially call a `Func`,
+        // however, there's no "callee" to provide. To fix this we allocate a
+        // single "default callee" for the entire `Store`. This is then used as
+        // part of `Func::call` to guarantee that the `callee: *mut VMContext`
+        // is never null.
+        inner.default_caller = {
+            let module = Arc::new(wasmtime_environ::Module::default());
+            let shim = ModuleRuntimeInfo::bare(module);
+            let allocator = OnDemandInstanceAllocator::default();
+            allocator
+                .validate_module(shim.module(), shim.offsets())
+                .unwrap();
+            let mut instance = unsafe {
+                allocator
+                    .allocate_module(InstanceAllocationRequest {
+                        host_state: Box::new(()),
+                        imports: Default::default(),
+                        store: StorePtr::empty(),
+                        runtime_info: &shim,
+                        wmemcheck: engine.config().wmemcheck,
+                        pkey: None,
+                    })
+                    .expect("failed to allocate default callee")
+            };
+
+            // Note the erasure of the lifetime here into `'static`, so in
+            // general usage of this trait object must be strictly bounded to
+            // the `Store` itself, and is a variant that we have to maintain
+            // throughout Wasmtime.
+            unsafe {
+                let traitobj = mem::transmute::<
+                    *mut (dyn crate::runtime::vm::Store + '_),
+                    *mut (dyn crate::runtime::vm::Store + 'static),
+                >(&mut *inner);
+                instance.set_store(traitobj);
+            }
+            instance
+        };
+
+        Self {
+            inner: ManuallyDrop::new(inner),
+        }
+    }
+
+    /// Access the underlying data owned by this `Store`.
+    #[inline]
+    pub fn data(&self) -> &T {
+        self.inner.data()
+    }
+
+    /// Access the underlying data owned by this `Store`.
+    #[inline]
+    pub fn data_mut(&mut self) -> &mut T {
+        self.inner.data_mut()
+    }
+
+    /// Consumes this [`Store`], destroying it, and returns the underlying data.
+    pub fn into_data(mut self) -> T {
+        // This is an unsafe operation because we want to avoid having a runtime
+        // check or boolean for whether the data is actually contained within a
+        // `Store`. The data itself is stored as `ManuallyDrop` since we're
+        // manually managing the memory here, and there's also a `ManuallyDrop`
+        // around the `Box<StoreInner<T>>`. The way this works though is a bit
+        // tricky, so here's how things get dropped appropriately:
+        //
+        // * When a `Store<T>` is normally dropped, the custom destructor for
+        //   `Store<T>` will drop `T`, then the `self.inner` field. The
+        //   rustc-glue destructor runs for `Box<StoreInner<T>>` which drops
+        //   `StoreInner<T>`. This cleans up all internal fields and doesn't
+        //   touch `T` because it's wrapped in `ManuallyDrop`.
+        //
+        // * When calling this method we skip the top-level destructor for
+        //   `Store<T>` with `mem::forget`. This skips both the destructor for
+        //   `T` and the destructor for `StoreInner<T>`. We do, however, run the
+        //   destructor for `Box<StoreInner<T>>` which, like above, will skip
+        //   the destructor for `T` since it's `ManuallyDrop`.
+        //
+        // In both cases all the other fields of `StoreInner<T>` should all get
+        // dropped, and the manual management of destructors is basically
+        // between this method and `Drop for Store<T>`. Note that this also
+        // means that `Drop for StoreInner<T>` cannot access `self.data`, so
+        // there is a comment indicating this as well.
+        unsafe {
+            let mut inner = ManuallyDrop::take(&mut self.inner);
+            core::mem::forget(self);
+            ManuallyDrop::take(&mut inner.data)
+        }
+    }
+
+    /// Configures the [`ResourceLimiter`] used to limit resource creation
+    /// within this [`Store`].
+    ///
+    /// Whenever resources such as linear memory, tables, or instances are
+    /// allocated the `limiter` specified here is invoked with the store's data
+    /// `T` and the returned [`ResourceLimiter`] is used to limit the operation
+    /// being allocated. The returned [`ResourceLimiter`] is intended to live
+    /// within the `T` itself, for example by storing a
+    /// [`StoreLimits`](crate::StoreLimits).
+    ///
+    /// Note that this limiter is only used to limit the creation/growth of
+    /// resources in the future, this does not retroactively attempt to apply
+    /// limits to the [`Store`].
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use wasmtime::*;
+    ///
+    /// struct MyApplicationState {
+    ///     my_state: u32,
+    ///     limits: StoreLimits,
+    /// }
+    ///
+    /// let engine = Engine::default();
+    /// let my_state = MyApplicationState {
+    ///     my_state: 42,
+    ///     limits: StoreLimitsBuilder::new()
+    ///         .memory_size(1 << 20 /* 1 MB */)
+    ///         .instances(2)
+    ///         .build(),
+    /// };
+    /// let mut store = Store::new(&engine, my_state);
+    /// store.limiter(|state| &mut state.limits);
+    ///
+    /// // Creation of smaller memories is allowed
+    /// Memory::new(&mut store, MemoryType::new(1, None)).unwrap();
+    ///
+    /// // Creation of a larger memory, however, will exceed the 1MB limit we've
+    /// // configured
+    /// assert!(Memory::new(&mut store, MemoryType::new(1000, None)).is_err());
+    ///
+    /// // The number of instances in this store is limited to 2, so the third
+    /// // instance here should fail.
+    /// let module = Module::new(&engine, "(module)").unwrap();
+    /// assert!(Instance::new(&mut store, &module, &[]).is_ok());
+    /// assert!(Instance::new(&mut store, &module, &[]).is_ok());
+    /// assert!(Instance::new(&mut store, &module, &[]).is_err());
+    /// ```
+    ///
+    /// [`ResourceLimiter`]: crate::ResourceLimiter
+    pub fn limiter(
+        &mut self,
+        mut limiter: impl FnMut(&mut T) -> &mut (dyn crate::ResourceLimiter) + Send + Sync + 'static,
+    ) {
+        // Apply the limits on instances, tables, and memory given by the limiter:
+        let inner = &mut self.inner;
+        let (instance_limit, table_limit, memory_limit) = {
+            let l = limiter(&mut inner.data);
+            (l.instances(), l.tables(), l.memories())
+        };
+        let innermost = &mut inner.inner;
+        innermost.instance_limit = instance_limit;
+        innermost.table_limit = table_limit;
+        innermost.memory_limit = memory_limit;
+
+        // Save the limiter accessor function:
+        inner.limiter = Some(ResourceLimiterInner::Sync(Box::new(limiter)));
+    }
+
+    /// Configures the [`ResourceLimiterAsync`](crate::ResourceLimiterAsync)
+    /// used to limit resource creation within this [`Store`].
+    ///
+    /// This method is an asynchronous variant of the [`Store::limiter`] method
+    /// where the embedder can block the wasm request for more resources with
+    /// host `async` execution of futures.
+    ///
+    /// By using a [`ResourceLimiterAsync`](`crate::ResourceLimiterAsync`)
+    /// with a [`Store`], you can no longer use
+    /// [`Memory::new`](`crate::Memory::new`),
+    /// [`Memory::grow`](`crate::Memory::grow`),
+    /// [`Table::new`](`crate::Table::new`), and
+    /// [`Table::grow`](`crate::Table::grow`). Instead, you must use their
+    /// `async` variants: [`Memory::new_async`](`crate::Memory::new_async`),
+    /// [`Memory::grow_async`](`crate::Memory::grow_async`),
+    /// [`Table::new_async`](`crate::Table::new_async`), and
+    /// [`Table::grow_async`](`crate::Table::grow_async`).
+    ///
+    /// Note that this limiter is only used to limit the creation/growth of
+    /// resources in the future, this does not retroactively attempt to apply
+    /// limits to the [`Store`]. Additionally this must be used with an async
+    /// [`Store`] configured via
+    /// [`Config::async_support`](crate::Config::async_support).
+    #[cfg(feature = "async")]
+    pub fn limiter_async(
+        &mut self,
+        mut limiter: impl FnMut(&mut T) -> &mut (dyn crate::ResourceLimiterAsync)
+            + Send
+            + Sync
+            + 'static,
+    ) {
+        debug_assert!(self.inner.async_support());
+        // Apply the limits on instances, tables, and memory given by the limiter:
+        let inner = &mut self.inner;
+        let (instance_limit, table_limit, memory_limit) = {
+            let l = limiter(&mut inner.data);
+            (l.instances(), l.tables(), l.memories())
+        };
+        let innermost = &mut inner.inner;
+        innermost.instance_limit = instance_limit;
+        innermost.table_limit = table_limit;
+        innermost.memory_limit = memory_limit;
+
+        // Save the limiter accessor function:
+        inner.limiter = Some(ResourceLimiterInner::Async(Box::new(limiter)));
+    }
+
+    /// Configures an async function that runs on calls and returns between
+    /// WebAssembly and host code. For the non-async equivalent of this method,
+    /// see [`Store::call_hook`].
+    ///
+    /// The function is passed a [`CallHook`] argument, which indicates which
+    /// state transition the VM is making.
+    ///
+    /// This function's future may return a [`Trap`]. If a trap is returned
+    /// when an import was called, it is immediately raised as-if the host
+    /// import had returned the trap. If a trap is returned after wasm returns
+    /// to the host then the wasm function's result is ignored and this trap is
+    /// returned instead.
+    ///
+    /// After this function returns a trap, it may be called for subsequent
+    /// returns to host or wasm code as the trap propagates to the root call.
+    #[cfg(all(feature = "async", feature = "call-hook"))]
+    pub fn call_hook_async(&mut self, hook: impl CallHookHandler<T> + Send + Sync + 'static) {
+        self.inner.call_hook = Some(CallHookInner::Async(Box::new(hook)));
+    }
+
+    /// Configure a function that runs on calls and returns between WebAssembly
+    /// and host code.
+    ///
+    /// The function is passed a [`CallHook`] argument, which indicates which
+    /// state transition the VM is making.
+    ///
+    /// This function may return a [`Trap`]. If a trap is returned when an
+    /// import was called, it is immediately raised as-if the host import had
+    /// returned the trap. If a trap is returned after wasm returns to the host
+    /// then the wasm function's result is ignored and this trap is returned
+    /// instead.
+    ///
+    /// After this function returns a trap, it may be called for subsequent returns
+    /// to host or wasm code as the trap propagates to the root call.
+    #[cfg(feature = "call-hook")]
+    pub fn call_hook(
+        &mut self,
+        hook: impl FnMut(StoreContextMut<'_, T>, CallHook) -> Result<()> + Send + Sync + 'static,
+    ) {
+        self.inner.call_hook = Some(CallHookInner::Sync(Box::new(hook)));
+    }
+
+    /// Returns the [`Engine`] that this store is associated with.
+    pub fn engine(&self) -> &Engine {
+        self.inner.engine()
+    }
+
+    /// Perform garbage collection.
+    ///
+    /// Note that it is not required to actively call this function. GC will
+    /// automatically happen according to various internal heuristics. This is
+    /// provided if fine-grained control over the GC is desired.
+    ///
+    /// This method is only available when the `gc` Cargo feature is enabled.
+    #[cfg(feature = "gc")]
+    pub fn gc(&mut self) {
+        self.inner.gc()
+    }
+
+    /// Perform garbage collection asynchronously.
+    ///
+    /// Note that it is not required to actively call this function. GC will
+    /// automatically happen according to various internal heuristics. This is
+    /// provided if fine-grained control over the GC is desired.
+    ///
+    /// This method is only available when the `gc` Cargo feature is enabled.
+    #[cfg(all(feature = "async", feature = "gc"))]
+    pub async fn gc_async(&mut self)
+    where
+        T: Send,
+    {
+        self.inner.gc_async().await;
+    }
+
+    /// Returns the amount fuel in this [`Store`]. When fuel is enabled, it must
+    /// be configured via [`Store::set_fuel`].
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error if fuel consumption is not enabled
+    /// via [`Config::consume_fuel`](crate::Config::consume_fuel).
+    pub fn get_fuel(&self) -> Result<u64> {
+        self.inner.get_fuel()
+    }
+
+    /// Set the fuel to this [`Store`] for wasm to consume while executing.
+    ///
+    /// For this method to work fuel consumption must be enabled via
+    /// [`Config::consume_fuel`](crate::Config::consume_fuel). By default a
+    /// [`Store`] starts with 0 fuel for wasm to execute with (meaning it will
+    /// immediately trap). This function must be called for the store to have
+    /// some fuel to allow WebAssembly to execute.
+    ///
+    /// Most WebAssembly instructions consume 1 unit of fuel. Some
+    /// instructions, such as `nop`, `drop`, `block`, and `loop`, consume 0
+    /// units, as any execution cost associated with them involves other
+    /// instructions which do consume fuel.
+    ///
+    /// Note that when fuel is entirely consumed it will cause wasm to trap.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error if fuel consumption is not enabled via
+    /// [`Config::consume_fuel`](crate::Config::consume_fuel).
+    pub fn set_fuel(&mut self, fuel: u64) -> Result<()> {
+        self.inner.set_fuel(fuel)
+    }
+
+    /// Configures a [`Store`] to yield execution of async WebAssembly code
+    /// periodically.
+    ///
+    /// When a [`Store`] is configured to consume fuel with
+    /// [`Config::consume_fuel`](crate::Config::consume_fuel) this method will
+    /// configure WebAssembly to be suspended and control will be yielded back to the
+    /// caller every `interval` units of fuel consumed. This is only suitable with use of
+    /// a store associated with an [async config](crate::Config::async_support) because
+    /// only then are futures used and yields are possible.
+    ///
+    /// The purpose of this behavior is to ensure that futures which represent
+    /// execution of WebAssembly do not execute too long inside their
+    /// `Future::poll` method. This allows for some form of cooperative
+    /// multitasking where WebAssembly will voluntarily yield control
+    /// periodically (based on fuel consumption) back to the running thread.
+    ///
+    /// Note that futures returned by this crate will automatically flag
+    /// themselves to get re-polled if a yield happens. This means that
+    /// WebAssembly will continue to execute, just after giving the host an
+    /// opportunity to do something else.
+    ///
+    /// The `interval` parameter indicates how much fuel should be
+    /// consumed between yields of an async future. When fuel runs out wasm will trap.
+    ///
+    /// # Error
+    ///
+    /// This method will error if it is not called on a store associated with an [async
+    /// config](crate::Config::async_support).
+    pub fn fuel_async_yield_interval(&mut self, interval: Option<u64>) -> Result<()> {
+        self.inner.fuel_async_yield_interval(interval)
+    }
+
+    /// Sets the epoch deadline to a certain number of ticks in the future.
+    ///
+    /// When the Wasm guest code is compiled with epoch-interruption
+    /// instrumentation
+    /// ([`Config::epoch_interruption()`](crate::Config::epoch_interruption)),
+    /// and when the `Engine`'s epoch is incremented
+    /// ([`Engine::increment_epoch()`](crate::Engine::increment_epoch))
+    /// past a deadline, execution can be configured to either trap or
+    /// yield and then continue.
+    ///
+    /// This deadline is always set relative to the current epoch:
+    /// `ticks_beyond_current` ticks in the future. The deadline can
+    /// be set explicitly via this method, or refilled automatically
+    /// on a yield if configured via
+    /// [`epoch_deadline_async_yield_and_update()`](Store::epoch_deadline_async_yield_and_update). After
+    /// this method is invoked, the deadline is reached when
+    /// [`Engine::increment_epoch()`] has been invoked at least
+    /// `ticks_beyond_current` times.
+    ///
+    /// By default a store will trap immediately with an epoch deadline of 0
+    /// (which has always "elapsed"). This method is required to be configured
+    /// for stores with epochs enabled to some future epoch deadline.
+    ///
+    /// See documentation on
+    /// [`Config::epoch_interruption()`](crate::Config::epoch_interruption)
+    /// for an introduction to epoch-based interruption.
+    pub fn set_epoch_deadline(&mut self, ticks_beyond_current: u64) {
+        self.inner.set_epoch_deadline(ticks_beyond_current);
+    }
+
+    /// Configures epoch-deadline expiration to trap.
+    ///
+    /// When epoch-interruption-instrumented code is executed on this
+    /// store and the epoch deadline is reached before completion,
+    /// with the store configured in this way, execution will
+    /// terminate with a trap as soon as an epoch check in the
+    /// instrumented code is reached.
+    ///
+    /// This behavior is the default if the store is not otherwise
+    /// configured via
+    /// [`epoch_deadline_trap()`](Store::epoch_deadline_trap),
+    /// [`epoch_deadline_callback()`](Store::epoch_deadline_callback) or
+    /// [`epoch_deadline_async_yield_and_update()`](Store::epoch_deadline_async_yield_and_update).
+    ///
+    /// This setting is intended to allow for coarse-grained
+    /// interruption, but not a deterministic deadline of a fixed,
+    /// finite interval. For deterministic interruption, see the
+    /// "fuel" mechanism instead.
+    ///
+    /// Note that when this is used it's required to call
+    /// [`Store::set_epoch_deadline`] or otherwise wasm will always immediately
+    /// trap.
+    ///
+    /// See documentation on
+    /// [`Config::epoch_interruption()`](crate::Config::epoch_interruption)
+    /// for an introduction to epoch-based interruption.
+    pub fn epoch_deadline_trap(&mut self) {
+        self.inner.epoch_deadline_trap();
+    }
+
+    /// Configures epoch-deadline expiration to invoke a custom callback
+    /// function.
+    ///
+    /// When epoch-interruption-instrumented code is executed on this
+    /// store and the epoch deadline is reached before completion, the
+    /// provided callback function is invoked.
+    ///
+    /// This callback should either return an [`UpdateDeadline`], or
+    /// return an error, which will terminate execution with a trap.
+    ///
+    /// The [`UpdateDeadline`] is a positive number of ticks to
+    /// add to the epoch deadline, as well as indicating what
+    /// to do after the callback returns. If the [`Store`] is
+    /// configured with async support, then the callback may return
+    /// [`UpdateDeadline::Yield`] to yield to the async executor before
+    /// updating the epoch deadline. Alternatively, the callback may
+    /// return [`UpdateDeadline::Continue`] to update the epoch deadline
+    /// immediately.
+    ///
+    /// This setting is intended to allow for coarse-grained
+    /// interruption, but not a deterministic deadline of a fixed,
+    /// finite interval. For deterministic interruption, see the
+    /// "fuel" mechanism instead.
+    ///
+    /// See documentation on
+    /// [`Config::epoch_interruption()`](crate::Config::epoch_interruption)
+    /// for an introduction to epoch-based interruption.
+    pub fn epoch_deadline_callback(
+        &mut self,
+        callback: impl FnMut(StoreContextMut<T>) -> Result<UpdateDeadline> + Send + Sync + 'static,
+    ) {
+        self.inner.epoch_deadline_callback(Box::new(callback));
+    }
+
+    /// Configures epoch-deadline expiration to yield to the async
+    /// caller and the update the deadline.
+    ///
+    /// When epoch-interruption-instrumented code is executed on this
+    /// store and the epoch deadline is reached before completion,
+    /// with the store configured in this way, execution will yield
+    /// (the future will return `Pending` but re-awake itself for
+    /// later execution) and, upon resuming, the store will be
+    /// configured with an epoch deadline equal to the current epoch
+    /// plus `delta` ticks.
+    ///
+    /// This setting is intended to allow for cooperative timeslicing
+    /// of multiple CPU-bound Wasm guests in different stores, all
+    /// executing under the control of an async executor. To drive
+    /// this, stores should be configured to "yield and update"
+    /// automatically with this function, and some external driver (a
+    /// thread that wakes up periodically, or a timer
+    /// signal/interrupt) should call
+    /// [`Engine::increment_epoch()`](crate::Engine::increment_epoch).
+    ///
+    /// See documentation on
+    /// [`Config::epoch_interruption()`](crate::Config::epoch_interruption)
+    /// for an introduction to epoch-based interruption.
+    #[cfg(feature = "async")]
+    pub fn epoch_deadline_async_yield_and_update(&mut self, delta: u64) {
+        self.inner.epoch_deadline_async_yield_and_update(delta);
+    }
+}
+
+impl<'a, T> StoreContext<'a, T> {
+    pub(crate) fn async_support(&self) -> bool {
+        self.0.async_support()
+    }
+
+    /// Returns the underlying [`Engine`] this store is connected to.
+    pub fn engine(&self) -> &Engine {
+        self.0.engine()
+    }
+
+    /// Access the underlying data owned by this `Store`.
+    ///
+    /// Same as [`Store::data`].
+    pub fn data(&self) -> &'a T {
+        self.0.data()
+    }
+
+    /// Returns the remaining fuel in this store.
+    ///
+    /// For more information see [`Store::get_fuel`].
+    pub fn get_fuel(&self) -> Result<u64> {
+        self.0.get_fuel()
+    }
+}
+
+impl<'a, T> StoreContextMut<'a, T> {
+    /// Access the underlying data owned by this `Store`.
+    ///
+    /// Same as [`Store::data`].
+    pub fn data(&self) -> &T {
+        self.0.data()
+    }
+
+    /// Access the underlying data owned by this `Store`.
+    ///
+    /// Same as [`Store::data_mut`].
+    pub fn data_mut(&mut self) -> &mut T {
+        self.0.data_mut()
+    }
+
+    /// Returns the underlying [`Engine`] this store is connected to.
+    pub fn engine(&self) -> &Engine {
+        self.0.engine()
+    }
+
+    /// Perform garbage collection of `ExternRef`s.
+    ///
+    /// Same as [`Store::gc`].
+    ///
+    /// This method is only available when the `gc` Cargo feature is enabled.
+    #[cfg(feature = "gc")]
+    pub fn gc(&mut self) {
+        self.0.gc()
+    }
+
+    /// Perform garbage collection of `ExternRef`s.
+    ///
+    /// Same as [`Store::gc`].
+    ///
+    /// This method is only available when the `gc` Cargo feature is enabled.
+    #[cfg(all(feature = "async", feature = "gc"))]
+    pub async fn gc_async(&mut self)
+    where
+        T: Send,
+    {
+        self.0.gc_async().await;
+    }
+
+    /// Returns remaining fuel in this store.
+    ///
+    /// For more information see [`Store::get_fuel`]
+    pub fn get_fuel(&self) -> Result<u64> {
+        self.0.get_fuel()
+    }
+
+    /// Set the amount of fuel in this store.
+    ///
+    /// For more information see [`Store::set_fuel`]
+    pub fn set_fuel(&mut self, fuel: u64) -> Result<()> {
+        self.0.set_fuel(fuel)
+    }
+
+    /// Configures this `Store` to periodically yield while executing futures.
+    ///
+    /// For more information see [`Store::fuel_async_yield_interval`]
+    pub fn fuel_async_yield_interval(&mut self, interval: Option<u64>) -> Result<()> {
+        self.0.fuel_async_yield_interval(interval)
+    }
+
+    /// Sets the epoch deadline to a certain number of ticks in the future.
+    ///
+    /// For more information see [`Store::set_epoch_deadline`].
+    pub fn set_epoch_deadline(&mut self, ticks_beyond_current: u64) {
+        self.0.set_epoch_deadline(ticks_beyond_current);
+    }
+
+    /// Configures epoch-deadline expiration to trap.
+    ///
+    /// For more information see [`Store::epoch_deadline_trap`].
+    pub fn epoch_deadline_trap(&mut self) {
+        self.0.epoch_deadline_trap();
+    }
+
+    /// Configures epoch-deadline expiration to yield to the async
+    /// caller and the update the deadline.
+    ///
+    /// For more information see
+    /// [`Store::epoch_deadline_async_yield_and_update`].
+    #[cfg(feature = "async")]
+    pub fn epoch_deadline_async_yield_and_update(&mut self, delta: u64) {
+        self.0.epoch_deadline_async_yield_and_update(delta);
+    }
+}
+
+impl<T> StoreInner<T> {
+    #[inline]
+    fn data(&self) -> &T {
+        &self.data
+    }
+
+    #[inline]
+    fn data_mut(&mut self) -> &mut T {
+        &mut self.data
+    }
+
+    #[inline]
+    pub fn call_hook(&mut self, s: CallHook) -> Result<()> {
+        if self.inner.pkey.is_none() && self.call_hook.is_none() {
+            Ok(())
+        } else {
+            self.call_hook_slow_path(s)
+        }
+    }
+
+    fn call_hook_slow_path(&mut self, s: CallHook) -> Result<()> {
+        if let Some(pkey) = &self.inner.pkey {
+            let allocator = self.engine().allocator();
+            match s {
+                CallHook::CallingWasm | CallHook::ReturningFromHost => {
+                    allocator.restrict_to_pkey(*pkey)
+                }
+                CallHook::ReturningFromWasm | CallHook::CallingHost => allocator.allow_all_pkeys(),
+            }
+        }
+
+        // Temporarily take the configured behavior to avoid mutably borrowing
+        // multiple times.
+        #[cfg_attr(not(feature = "call-hook"), allow(unreachable_patterns))]
+        if let Some(mut call_hook) = self.call_hook.take() {
+            let result = self.invoke_call_hook(&mut call_hook, s);
+            self.call_hook = Some(call_hook);
+            return result;
+        }
+
+        Ok(())
+    }
+
+    fn invoke_call_hook(&mut self, call_hook: &mut CallHookInner<T>, s: CallHook) -> Result<()> {
+        match call_hook {
+            #[cfg(feature = "call-hook")]
+            CallHookInner::Sync(hook) => hook((&mut *self).as_context_mut(), s),
+
+            #[cfg(all(feature = "async", feature = "call-hook"))]
+            CallHookInner::Async(handler) => unsafe {
+                self.inner
+                    .async_cx()
+                    .ok_or_else(|| anyhow!("couldn't grab async_cx for call hook"))?
+                    .block_on(
+                        handler
+                            .handle_call_event((&mut *self).as_context_mut(), s)
+                            .as_mut(),
+                    )?
+            },
+
+            CallHookInner::ForceTypeParameterToBeUsed { uninhabited, .. } => {
+                let _ = s;
+                match *uninhabited {}
+            }
+        }
+    }
+}
+
+fn get_fuel(injected_fuel: i64, fuel_reserve: u64) -> u64 {
+    fuel_reserve.saturating_add_signed(-injected_fuel)
+}
+
+// Add remaining fuel from the reserve into the active fuel if there is any left.
+fn refuel(
+    injected_fuel: &mut i64,
+    fuel_reserve: &mut u64,
+    yield_interval: Option<NonZeroU64>,
+) -> bool {
+    let fuel = get_fuel(*injected_fuel, *fuel_reserve);
+    if fuel > 0 {
+        set_fuel(injected_fuel, fuel_reserve, yield_interval, fuel);
+        true
+    } else {
+        false
+    }
+}
+
+fn set_fuel(
+    injected_fuel: &mut i64,
+    fuel_reserve: &mut u64,
+    yield_interval: Option<NonZeroU64>,
+    new_fuel_amount: u64,
+) {
+    let interval = yield_interval.unwrap_or(NonZeroU64::MAX).get();
+    // If we're yielding periodically we only store the "active" amount of fuel into consumed_ptr
+    // for the VM to use.
+    let injected = core::cmp::min(interval, new_fuel_amount);
+    // Fuel in the VM is stored as an i64, so we have to cap the amount of fuel we inject into the
+    // VM at once to be i64 range.
+    let injected = core::cmp::min(injected, i64::MAX as u64);
+    // Add whatever is left over after injection to the reserve for later use.
+    *fuel_reserve = new_fuel_amount - injected;
+    // Within the VM we increment to count fuel, so inject a negative amount. The VM will halt when
+    // this counter is positive.
+    *injected_fuel = -(injected as i64);
+}
+
+#[doc(hidden)]
+impl StoreOpaque {
+    pub fn id(&self) -> StoreId {
+        self.store_data.id()
+    }
+
+    pub fn bump_resource_counts(&mut self, module: &Module) -> Result<()> {
+        fn bump(slot: &mut usize, max: usize, amt: usize, desc: &str) -> Result<()> {
+            let new = slot.saturating_add(amt);
+            if new > max {
+                bail!(
+                    "resource limit exceeded: {} count too high at {}",
+                    desc,
+                    new
+                );
+            }
+            *slot = new;
+            Ok(())
+        }
+
+        let module = module.env_module();
+        let memories = module.memory_plans.len() - module.num_imported_memories;
+        let tables = module.table_plans.len() - module.num_imported_tables;
+
+        bump(&mut self.instance_count, self.instance_limit, 1, "instance")?;
+        bump(
+            &mut self.memory_count,
+            self.memory_limit,
+            memories,
+            "memory",
+        )?;
+        bump(&mut self.table_count, self.table_limit, tables, "table")?;
+
+        Ok(())
+    }
+
+    #[inline]
+    pub fn async_support(&self) -> bool {
+        cfg!(feature = "async") && self.engine().config().async_support
+    }
+
+    #[inline]
+    pub fn engine(&self) -> &Engine {
+        &self.engine
+    }
+
+    #[inline]
+    pub fn store_data(&self) -> &StoreData {
+        &self.store_data
+    }
+
+    #[inline]
+    pub fn store_data_mut(&mut self) -> &mut StoreData {
+        &mut self.store_data
+    }
+
+    #[inline]
+    pub(crate) fn modules(&self) -> &ModuleRegistry {
+        &self.modules
+    }
+
+    #[inline]
+    pub(crate) fn modules_mut(&mut self) -> &mut ModuleRegistry {
+        &mut self.modules
+    }
+
+    pub(crate) fn func_refs(&mut self) -> &mut FuncRefs {
+        &mut self.func_refs
+    }
+
+    pub(crate) fn fill_func_refs(&mut self) {
+        self.func_refs.fill(&mut self.modules);
+    }
+
+    pub(crate) fn push_instance_pre_func_refs(&mut self, func_refs: Arc<[VMFuncRef]>) {
+        self.func_refs.push_instance_pre_func_refs(func_refs);
+    }
+
+    pub(crate) fn host_globals(&mut self) -> &mut Vec<StoreBox<VMHostGlobalContext>> {
+        &mut self.host_globals
+    }
+
+    pub fn module_for_instance(&self, instance: InstanceId) -> Option<&'_ Module> {
+        match self.instances[instance.0].kind {
+            StoreInstanceKind::Dummy => None,
+            StoreInstanceKind::Real { module_id } => {
+                let module = self
+                    .modules()
+                    .lookup_module_by_id(module_id)
+                    .expect("should always have a registered module for real instances");
+                Some(module)
+            }
+        }
+    }
+
+    pub unsafe fn add_instance(
+        &mut self,
+        handle: InstanceHandle,
+        module_id: RegisteredModuleId,
+    ) -> InstanceId {
+        self.instances.push(StoreInstance {
+            handle: handle.clone(),
+            kind: StoreInstanceKind::Real { module_id },
+        });
+        InstanceId(self.instances.len() - 1)
+    }
+
+    /// Add a dummy instance that to the store.
+    ///
+    /// These are instances that are just implementation details of something
+    /// else (e.g. host-created memories that are not actually defined in any
+    /// Wasm module) and therefore shouldn't show up in things like core dumps.
+    pub unsafe fn add_dummy_instance(&mut self, handle: InstanceHandle) -> InstanceId {
+        self.instances.push(StoreInstance {
+            handle: handle.clone(),
+            kind: StoreInstanceKind::Dummy,
+        });
+        InstanceId(self.instances.len() - 1)
+    }
+
+    pub fn instance(&self, id: InstanceId) -> &InstanceHandle {
+        &self.instances[id.0].handle
+    }
+
+    pub fn instance_mut(&mut self, id: InstanceId) -> &mut InstanceHandle {
+        &mut self.instances[id.0].handle
+    }
+
+    /// Get all instances (ignoring dummy instances) within this store.
+    pub fn all_instances<'a>(&'a mut self) -> impl ExactSizeIterator<Item = Instance> + 'a {
+        let instances = self
+            .instances
+            .iter()
+            .enumerate()
+            .filter_map(|(idx, inst)| {
+                let id = InstanceId::from_index(idx);
+                if let StoreInstanceKind::Dummy = inst.kind {
+                    None
+                } else {
+                    Some(InstanceData::from_id(id))
+                }
+            })
+            .collect::<Vec<_>>();
+        instances
+            .into_iter()
+            .map(|i| Instance::from_wasmtime(i, self))
+    }
+
+    /// Get all memories (host- or Wasm-defined) within this store.
+    pub fn all_memories<'a>(&'a mut self) -> impl Iterator<Item = Memory> + 'a {
+        // NB: Host-created memories have dummy instances. Therefore, we can get
+        // all memories in the store by iterating over all instances (including
+        // dummy instances) and getting each of their defined memories.
+        let mems = self
+            .instances
+            .iter_mut()
+            .flat_map(|instance| instance.handle.defined_memories())
+            .collect::<Vec<_>>();
+        mems.into_iter()
+            .map(|memory| unsafe { Memory::from_wasmtime_memory(memory, self) })
+    }
+
+    /// Iterate over all tables (host- or Wasm-defined) within this store.
+    pub fn for_each_table(&mut self, mut f: impl FnMut(&mut Self, Table)) {
+        // NB: Host-created tables have dummy instances. Therefore, we can get
+        // all memories in the store by iterating over all instances (including
+        // dummy instances) and getting each of their defined memories.
+
+        struct TempTakeInstances<'a> {
+            instances: Vec<StoreInstance>,
+            store: &'a mut StoreOpaque,
+        }
+
+        impl<'a> TempTakeInstances<'a> {
+            fn new(store: &'a mut StoreOpaque) -> Self {
+                let instances = mem::take(&mut store.instances);
+                Self { instances, store }
+            }
+        }
+
+        impl Drop for TempTakeInstances<'_> {
+            fn drop(&mut self) {
+                assert!(self.store.instances.is_empty());
+                self.store.instances = mem::take(&mut self.instances);
+            }
+        }
+
+        let mut temp = TempTakeInstances::new(self);
+        for instance in temp.instances.iter_mut() {
+            for table in instance.handle.defined_tables() {
+                let table = unsafe { Table::from_wasmtime_table(table, temp.store) };
+                f(temp.store, table);
+            }
+        }
+    }
+
+    /// Iterate over all globals (host- or Wasm-defined) within this store.
+    pub fn for_each_global(&mut self, mut f: impl FnMut(&mut Self, Global)) {
+        struct TempTakeHostGlobalsAndInstances<'a> {
+            host_globals: Vec<StoreBox<VMHostGlobalContext>>,
+            instances: Vec<StoreInstance>,
+            store: &'a mut StoreOpaque,
+        }
+
+        impl<'a> TempTakeHostGlobalsAndInstances<'a> {
+            fn new(store: &'a mut StoreOpaque) -> Self {
+                let host_globals = mem::take(&mut store.host_globals);
+                let instances = mem::take(&mut store.instances);
+                Self {
+                    host_globals,
+                    instances,
+                    store,
+                }
+            }
+        }
+
+        impl Drop for TempTakeHostGlobalsAndInstances<'_> {
+            fn drop(&mut self) {
+                assert!(self.store.host_globals.is_empty());
+                self.store.host_globals = mem::take(&mut self.host_globals);
+                assert!(self.store.instances.is_empty());
+                self.store.instances = mem::take(&mut self.instances);
+            }
+        }
+
+        let mut temp = TempTakeHostGlobalsAndInstances::new(self);
+        unsafe {
+            // First enumerate all the host-created globals.
+            for global in temp.host_globals.iter() {
+                let export = ExportGlobal {
+                    definition: &mut (*global.get()).global as *mut _,
+                    vmctx: core::ptr::null_mut(),
+                    global: (*global.get()).ty.to_wasm_type(),
+                };
+                let global = Global::from_wasmtime_global(export, temp.store);
+                f(temp.store, global);
+            }
+
+            // Then enumerate all instances' defined globals.
+            for instance in temp.instances.iter_mut() {
+                for (_, export) in instance.handle.defined_globals() {
+                    let global = Global::from_wasmtime_global(export, temp.store);
+                    f(temp.store, global);
+                }
+            }
+        }
+    }
+
+    #[cfg_attr(not(target_os = "linux"), allow(dead_code))] // not used on all platforms
+    pub fn set_signal_handler(&mut self, handler: Option<Box<SignalHandler<'static>>>) {
+        self.signal_handler = handler;
+    }
+
+    #[inline]
+    pub fn runtime_limits(&self) -> &VMRuntimeLimits {
+        &self.runtime_limits
+    }
+
+    #[inline(never)]
+    pub(crate) fn allocate_gc_heap(&mut self) -> Result<()> {
+        assert!(self.gc_store.is_none());
+        let gc_store = allocate_gc_store(self.engine())?;
+        self.gc_store = Some(gc_store);
+        return Ok(());
+
+        #[cfg(feature = "gc")]
+        fn allocate_gc_store(engine: &Engine) -> Result<GcStore> {
+            let (index, heap) = if engine.features().gc_types() {
+                engine
+                    .allocator()
+                    .allocate_gc_heap(&**engine.gc_runtime())?
+            } else {
+                (
+                    GcHeapAllocationIndex::default(),
+                    crate::runtime::vm::disabled_gc_heap(),
+                )
+            };
+            Ok(GcStore::new(index, heap))
+        }
+
+        #[cfg(not(feature = "gc"))]
+        fn allocate_gc_store(_engine: &Engine) -> Result<GcStore> {
+            Ok(GcStore::new(
+                GcHeapAllocationIndex::default(),
+                crate::runtime::vm::disabled_gc_heap(),
+            ))
+        }
+    }
+
+    #[inline]
+    #[cfg(feature = "gc")]
+    pub(crate) fn gc_store(&self) -> Result<&GcStore> {
+        match &self.gc_store {
+            Some(gc_store) => Ok(gc_store),
+            None => bail!("GC heap not initialized yet"),
+        }
+    }
+
+    #[inline]
+    pub(crate) fn gc_store_mut(&mut self) -> Result<&mut GcStore> {
+        if self.gc_store.is_none() {
+            self.allocate_gc_heap()?;
+        }
+        Ok(self.unwrap_gc_store_mut())
+    }
+
+    #[inline]
+    #[cfg(feature = "gc")]
+    pub(crate) fn unwrap_gc_store(&self) -> &GcStore {
+        self.gc_store
+            .as_ref()
+            .expect("attempted to access the store's GC heap before it has been allocated")
+    }
+
+    #[inline]
+    pub(crate) fn unwrap_gc_store_mut(&mut self) -> &mut GcStore {
+        self.gc_store
+            .as_mut()
+            .expect("attempted to access the store's GC heap before it has been allocated")
+    }
+
+    #[inline]
+    pub(crate) fn gc_roots(&self) -> &RootSet {
+        &self.gc_roots
+    }
+
+    #[inline]
+    pub(crate) fn gc_roots_mut(&mut self) -> &mut RootSet {
+        &mut self.gc_roots
+    }
+
+    #[inline]
+    pub(crate) fn exit_gc_lifo_scope(&mut self, scope: usize) {
+        self.gc_roots.exit_lifo_scope(self.gc_store.as_mut(), scope);
+    }
+
+    #[cfg(feature = "gc")]
+    pub fn gc(&mut self) {
+        // If the GC heap hasn't been initialized, there is nothing to collect.
+        if self.gc_store.is_none() {
+            return;
+        }
+
+        // Take the GC roots out of `self` so we can borrow it mutably but still
+        // call mutable methods on `self`.
+        let mut roots = core::mem::take(&mut self.gc_roots_list);
+
+        self.trace_roots(&mut roots);
+        self.unwrap_gc_store_mut().gc(unsafe { roots.iter() });
+
+        // Restore the GC roots for the next GC.
+        roots.clear();
+        self.gc_roots_list = roots;
+    }
+
+    #[inline]
+    #[cfg(not(feature = "gc"))]
+    pub fn gc(&mut self) {
+        // Nothing to collect.
+        //
+        // Note that this is *not* a public method, this is just defined for the
+        // crate-internal `StoreOpaque` type. This is a convenience so that we
+        // don't have to `cfg` every call site.
+    }
+
+    #[cfg(feature = "gc")]
+    fn trace_roots(&mut self, gc_roots_list: &mut GcRootsList) {
+        log::trace!("Begin trace GC roots");
+
+        // We shouldn't have any leftover, stale GC roots.
+        assert!(gc_roots_list.is_empty());
+
+        self.trace_wasm_stack_roots(gc_roots_list);
+        self.trace_vmctx_roots(gc_roots_list);
+        self.trace_user_roots(gc_roots_list);
+
+        log::trace!("End trace GC roots")
+    }
+
+    #[cfg(all(feature = "async", feature = "gc"))]
+    pub async fn gc_async(&mut self) {
+        assert!(
+            self.async_support(),
+            "cannot use `gc_async` without enabling async support in the config",
+        );
+
+        // If the GC heap hasn't been initialized, there is nothing to collect.
+        if self.gc_store.is_none() {
+            return;
+        }
+
+        // Take the GC roots out of `self` so we can borrow it mutably but still
+        // call mutable methods on `self`.
+        let mut roots = std::mem::take(&mut self.gc_roots_list);
+
+        self.trace_roots_async(&mut roots).await;
+        self.unwrap_gc_store_mut()
+            .gc_async(unsafe { roots.iter() })
+            .await;
+
+        // Restore the GC roots for the next GC.
+        roots.clear();
+        self.gc_roots_list = roots;
+    }
+
+    #[inline]
+    #[cfg(all(feature = "async", not(feature = "gc")))]
+    pub async fn gc_async(&mut self) {
+        // Nothing to collect.
+        //
+        // Note that this is *not* a public method, this is just defined for the
+        // crate-internal `StoreOpaque` type. This is a convenience so that we
+        // don't have to `cfg` every call site.
+    }
+
+    #[cfg(all(feature = "async", feature = "gc"))]
+    async fn trace_roots_async(&mut self, gc_roots_list: &mut GcRootsList) {
+        use crate::runtime::vm::Yield;
+
+        log::trace!("Begin trace GC roots");
+
+        // We shouldn't have any leftover, stale GC roots.
+        assert!(gc_roots_list.is_empty());
+
+        self.trace_wasm_stack_roots(gc_roots_list);
+        Yield::new().await;
+        self.trace_vmctx_roots(gc_roots_list);
+        Yield::new().await;
+        self.trace_user_roots(gc_roots_list);
+
+        log::trace!("End trace GC roots")
+    }
+
+    #[cfg(feature = "gc")]
+    fn trace_wasm_stack_roots(&mut self, gc_roots_list: &mut GcRootsList) {
+        use core::ptr::NonNull;
+
+        use crate::runtime::vm::{ModuleInfoLookup, SendSyncPtr};
+
+        log::trace!("Begin trace GC roots :: Wasm stack");
+
+        Backtrace::trace(self.vmruntime_limits().cast_const(), |frame| {
+            let pc = frame.pc();
+            debug_assert!(pc != 0, "we should always get a valid PC for Wasm frames");
+
+            let fp = frame.fp() as *mut usize;
+            debug_assert!(
+                !fp.is_null(),
+                "we should always get a valid frame pointer for Wasm frames"
+            );
+
+            let module_info = self
+                .modules()
+                .lookup(pc)
+                .expect("should have module info for Wasm frame");
+
+            let stack_map = match module_info.lookup_stack_map(pc) {
+                Some(sm) => sm,
+                None => {
+                    log::trace!("No stack map for this Wasm frame");
+                    return core::ops::ControlFlow::Continue(());
+                }
+            };
+            log::trace!(
+                "We have a stack map that maps {} bytes in this Wasm frame",
+                stack_map.frame_size()
+            );
+
+            let sp = unsafe { stack_map.sp(fp) };
+            for stack_slot in unsafe { stack_map.live_gc_refs(sp) } {
+                let raw: u32 = unsafe { core::ptr::read(stack_slot) };
+                log::trace!("Stack slot @ {stack_slot:p} = {raw:#x}");
+
+                let gc_ref = VMGcRef::from_raw_u32(raw);
+                if gc_ref.is_some() {
+                    unsafe {
+                        gc_roots_list.add_wasm_stack_root(SendSyncPtr::new(
+                            NonNull::new(stack_slot).unwrap(),
+                        ));
+                    }
+                }
+            }
+
+            core::ops::ControlFlow::Continue(())
+        });
+
+        log::trace!("End trace GC roots :: Wasm stack");
+    }
+
+    #[cfg(feature = "gc")]
+    fn trace_vmctx_roots(&mut self, gc_roots_list: &mut GcRootsList) {
+        log::trace!("Begin trace GC roots :: vmctx");
+        self.for_each_global(|store, global| global.trace_root(store, gc_roots_list));
+        self.for_each_table(|store, table| table.trace_roots(store, gc_roots_list));
+        log::trace!("End trace GC roots :: vmctx");
+    }
+
+    #[cfg(feature = "gc")]
+    fn trace_user_roots(&mut self, gc_roots_list: &mut GcRootsList) {
+        log::trace!("Begin trace GC roots :: user");
+        self.gc_roots.trace_roots(gc_roots_list);
+        log::trace!("End trace GC roots :: user");
+    }
+
+    /// Insert a host-allocated GC type into this store.
+    ///
+    /// This makes it suitable for the embedder to allocate instances of this
+    /// type in this store, and we don't have to worry about the type being
+    /// reclaimed (since it is possible that none of the Wasm modules in this
+    /// store are holding it alive).
+    pub(crate) fn insert_gc_host_alloc_type(&mut self, ty: RegisteredType) {
+        self.gc_host_alloc_types.insert(ty);
+    }
+
+    /// Yields the async context, assuming that we are executing on a fiber and
+    /// that fiber is not in the process of dying. This function will return
+    /// None in the latter case (the fiber is dying), and panic if
+    /// `async_support()` is false.
+    #[cfg(feature = "async")]
+    #[inline]
+    pub fn async_cx(&self) -> Option<AsyncCx> {
+        assert!(self.async_support());
+
+        let poll_cx_box_ptr = self.async_state.current_poll_cx.get();
+        if poll_cx_box_ptr.is_null() {
+            return None;
+        }
+
+        let poll_cx_inner_ptr = unsafe { *poll_cx_box_ptr };
+        if poll_cx_inner_ptr.is_null() {
+            return None;
+        }
+
+        Some(AsyncCx {
+            current_suspend: self.async_state.current_suspend.get(),
+            current_poll_cx: poll_cx_box_ptr,
+            track_pkey_context_switch: self.pkey.is_some(),
+        })
+    }
+
+    pub fn get_fuel(&self) -> Result<u64> {
+        anyhow::ensure!(
+            self.engine().tunables().consume_fuel,
+            "fuel is not configured in this store"
+        );
+        let injected_fuel = unsafe { *self.runtime_limits.fuel_consumed.get() };
+        Ok(get_fuel(injected_fuel, self.fuel_reserve))
+    }
+
+    fn refuel(&mut self) -> bool {
+        let injected_fuel = unsafe { &mut *self.runtime_limits.fuel_consumed.get() };
+        refuel(
+            injected_fuel,
+            &mut self.fuel_reserve,
+            self.fuel_yield_interval,
+        )
+    }
+
+    pub fn set_fuel(&mut self, fuel: u64) -> Result<()> {
+        anyhow::ensure!(
+            self.engine().tunables().consume_fuel,
+            "fuel is not configured in this store"
+        );
+        let injected_fuel = unsafe { &mut *self.runtime_limits.fuel_consumed.get() };
+        set_fuel(
+            injected_fuel,
+            &mut self.fuel_reserve,
+            self.fuel_yield_interval,
+            fuel,
+        );
+        Ok(())
+    }
+
+    pub fn fuel_async_yield_interval(&mut self, interval: Option<u64>) -> Result<()> {
+        anyhow::ensure!(
+            self.engine().tunables().consume_fuel,
+            "fuel is not configured in this store"
+        );
+        anyhow::ensure!(
+            self.engine().config().async_support,
+            "async support is not configured in this store"
+        );
+        anyhow::ensure!(
+            interval != Some(0),
+            "fuel_async_yield_interval must not be 0"
+        );
+        self.fuel_yield_interval = interval.and_then(|i| NonZeroU64::new(i));
+        // Reset the fuel active + reserve states by resetting the amount.
+        self.set_fuel(self.get_fuel()?)
+    }
+
+    /// Yields execution to the caller on out-of-gas or epoch interruption.
+    ///
+    /// This only works on async futures and stores, and assumes that we're
+    /// executing on a fiber. This will yield execution back to the caller once.
+    #[cfg(feature = "async")]
+    fn async_yield_impl(&mut self) -> Result<()> {
+        use crate::runtime::vm::Yield;
+
+        let mut future = Yield::new();
+
+        // When control returns, we have a `Result<()>` passed
+        // in from the host fiber. If this finished successfully then
+        // we were resumed normally via a `poll`, so keep going.  If
+        // the future was dropped while we were yielded, then we need
+        // to clean up this fiber. Do so by raising a trap which will
+        // abort all wasm and get caught on the other side to clean
+        // things up.
+        unsafe {
+            self.async_cx()
+                .expect("attempted to pull async context during shutdown")
+                .block_on(Pin::new_unchecked(&mut future))
+        }
+    }
+
+    #[inline]
+    pub fn signal_handler(&self) -> Option<*const SignalHandler<'static>> {
+        let handler = self.signal_handler.as_ref()?;
+        Some(&**handler as *const _)
+    }
+
+    #[inline]
+    pub fn vmruntime_limits(&self) -> *mut VMRuntimeLimits {
+        &self.runtime_limits as *const VMRuntimeLimits as *mut VMRuntimeLimits
+    }
+
+    #[inline]
+    pub fn default_caller(&self) -> *mut VMContext {
+        self.default_caller.vmctx()
+    }
+
+    pub fn traitobj(&self) -> *mut dyn crate::runtime::vm::Store {
+        self.default_caller.store()
+    }
+
+    /// Takes the cached `Vec<Val>` stored internally across hostcalls to get
+    /// used as part of calling the host in a `Func::new` method invocation.
+    #[inline]
+    pub fn take_hostcall_val_storage(&mut self) -> Vec<Val> {
+        mem::take(&mut self.hostcall_val_storage)
+    }
+
+    /// Restores the vector previously taken by `take_hostcall_val_storage`
+    /// above back into the store, allowing it to be used in the future for the
+    /// next wasm->host call.
+    #[inline]
+    pub fn save_hostcall_val_storage(&mut self, storage: Vec<Val>) {
+        if storage.capacity() > self.hostcall_val_storage.capacity() {
+            self.hostcall_val_storage = storage;
+        }
+    }
+
+    /// Same as `take_hostcall_val_storage`, but for the direction of the host
+    /// calling wasm.
+    #[inline]
+    pub fn take_wasm_val_raw_storage(&mut self) -> Vec<ValRaw> {
+        mem::take(&mut self.wasm_val_raw_storage)
+    }
+
+    /// Same as `save_hostcall_val_storage`, but for the direction of the host
+    /// calling wasm.
+    #[inline]
+    pub fn save_wasm_val_raw_storage(&mut self, storage: Vec<ValRaw>) {
+        if storage.capacity() > self.wasm_val_raw_storage.capacity() {
+            self.wasm_val_raw_storage = storage;
+        }
+    }
+
+    pub(crate) fn push_rooted_funcs(&mut self, funcs: Arc<[Definition]>) {
+        self.rooted_host_funcs.push(funcs);
+    }
+
+    /// Translates a WebAssembly fault at the native `pc` and native `addr` to a
+    /// WebAssembly-relative fault.
+    ///
+    /// This function may abort the process if `addr` is not found to actually
+    /// reside in any linear memory. In such a situation it means that the
+    /// segfault was erroneously caught by Wasmtime and is possibly indicative
+    /// of a code generator bug.
+    ///
+    /// This function returns `None` for dynamically-bounds-checked-memories
+    /// with spectre mitigations enabled since the hardware fault address is
+    /// always zero in these situations which means that the trapping context
+    /// doesn't have enough information to report the fault address.
+    pub(crate) fn wasm_fault(&self, pc: usize, addr: usize) -> Option<WasmFault> {
+        // There are a few instances where a "close to zero" pointer is loaded
+        // and we expect that to happen:
+        //
+        // * Explicitly bounds-checked memories with spectre-guards enabled will
+        //   cause out-of-bounds accesses to get routed to address 0, so allow
+        //   wasm instructions to fault on the null address.
+        // * `call_indirect` when invoking a null function pointer may load data
+        //   from the a `VMFuncRef` whose address is null, meaning any field of
+        //   `VMFuncRef` could be the address of the fault.
+        //
+        // In these situations where the address is so small it won't be in any
+        // instance, so skip the checks below.
+        if addr <= mem::size_of::<VMFuncRef>() {
+            const _: () = {
+                // static-assert that `VMFuncRef` isn't too big to ensure that
+                // it lives solely within the first page as we currently only
+                // have the guarantee that the first page of memory is unmapped,
+                // no more.
+                assert!(mem::size_of::<VMFuncRef>() <= 512);
+            };
+            return None;
+        }
+
+        // Search all known instances in this store for this address. Note that
+        // this is probably not the speediest way to do this. Traps, however,
+        // are generally not expected to be super fast and additionally stores
+        // probably don't have all that many instances or memories.
+        //
+        // If this loop becomes hot in the future, however, it should be
+        // possible to precompute maps about linear memories in a store and have
+        // a quicker lookup.
+        let mut fault = None;
+        for instance in self.instances.iter() {
+            if let Some(f) = instance.handle.wasm_fault(addr) {
+                assert!(fault.is_none());
+                fault = Some(f);
+            }
+        }
+        if fault.is_some() {
+            return fault;
+        }
+
+        cfg_if::cfg_if! {
+            if #[cfg(any(feature = "std", unix, windows))] {
+                // With the standard library a rich error can be printed here
+                // to stderr and the native abort path is used.
+                eprintln!(
+                    "\
+Wasmtime caught a segfault for a wasm program because the faulting instruction
+is allowed to segfault due to how linear memories are implemented. The address
+that was accessed, however, is not known to any linear memory in use within this
+Store. This may be indicative of a critical bug in Wasmtime's code generation
+because all addresses which are known to be reachable from wasm won't reach this
+message.
+
+    pc:      0x{pc:x}
+    address: 0x{addr:x}
+
+This is a possible security issue because WebAssembly has accessed something it
+shouldn't have been able to. Other accesses may have succeeded and this one just
+happened to be caught. The process will now be aborted to prevent this damage
+from going any further and to alert what's going on. If this is a security
+issue please reach out to the Wasmtime team via its security policy
+at https://bytecodealliance.org/security.
+"
+                );
+                std::process::abort();
+            } else if #[cfg(panic = "abort")] {
+                // Without the standard library but with `panic=abort` then
+                // it's safe to panic as that's known to halt execution. For
+                // now avoid the above error message as well since without
+                // `std` it's probably best to be a bit more size-conscious.
+                let _ = pc;
+                panic!("invalid fault");
+            } else {
+                // Without `std` and with `panic = "unwind"` there's no way to
+                // abort the process portably, so flag a compile time error.
+                //
+                // NB: if this becomes a problem in the future one option would
+                // be to extend the `capi.rs` module for no_std platforms, but
+                // it remains yet to be seen at this time if this is hit much.
+                compile_error!("either `std` or `panic=abort` must be enabled");
+                None
+            }
+        }
+    }
+
+    /// Retrieve the store's protection key.
+    #[inline]
+    pub(crate) fn get_pkey(&self) -> Option<ProtectionKey> {
+        self.pkey
+    }
+
+    #[inline]
+    #[cfg(feature = "component-model")]
+    pub(crate) fn component_resource_state(
+        &mut self,
+    ) -> (
+        &mut crate::runtime::vm::component::CallContexts,
+        &mut crate::runtime::vm::component::ResourceTable,
+        &mut crate::component::HostResourceData,
+    ) {
+        (
+            &mut self.component_calls,
+            &mut self.component_host_table,
+            &mut self.host_resource_data,
+        )
+    }
+
+    #[cfg(feature = "component-model")]
+    pub(crate) fn push_component_instance(&mut self, instance: crate::component::Instance) {
+        // We don't actually need the instance itself right now, but it seems
+        // like something we will almost certainly eventually want to keep
+        // around, so force callers to provide it.
+        let _ = instance;
+
+        self.num_component_instances += 1;
+    }
+}
+
+impl<T> StoreContextMut<'_, T> {
+    /// Executes a synchronous computation `func` asynchronously on a new fiber.
+    ///
+    /// This function will convert the synchronous `func` into an asynchronous
+    /// future. This is done by running `func` in a fiber on a separate native
+    /// stack which can be suspended and resumed from.
+    ///
+    /// Most of the nitty-gritty here is how we juggle the various contexts
+    /// necessary to suspend the fiber later on and poll sub-futures. It's hoped
+    /// that the various comments are illuminating as to what's going on here.
+    #[cfg(feature = "async")]
+    pub(crate) async fn on_fiber<R>(
+        &mut self,
+        func: impl FnOnce(&mut StoreContextMut<'_, T>) -> R + Send,
+    ) -> Result<R>
+    where
+        T: Send,
+    {
+        let config = self.engine().config();
+        debug_assert!(self.0.async_support());
+        debug_assert!(config.async_stack_size > 0);
+
+        let mut slot = None;
+        let future = {
+            let current_poll_cx = self.0.async_state.current_poll_cx.get();
+            let current_suspend = self.0.async_state.current_suspend.get();
+            let stack = self.engine().allocator().allocate_fiber_stack()?;
+
+            let engine = self.engine().clone();
+            let slot = &mut slot;
+            let fiber = wasmtime_fiber::Fiber::new(stack, move |keep_going, suspend| {
+                // First check and see if we were interrupted/dropped, and only
+                // continue if we haven't been.
+                keep_going?;
+
+                // Configure our store's suspension context for the rest of the
+                // execution of this fiber. Note that a raw pointer is stored here
+                // which is only valid for the duration of this closure.
+                // Consequently we at least replace it with the previous value when
+                // we're done. This reset is also required for correctness because
+                // otherwise our value will overwrite another active fiber's value.
+                // There should be a test that segfaults in `async_functions.rs` if
+                // this `Replace` is removed.
+                unsafe {
+                    let _reset = Reset(current_suspend, *current_suspend);
+                    *current_suspend = suspend;
+
+                    *slot = Some(func(self));
+                    Ok(())
+                }
+            })?;
+
+            // Once we have the fiber representing our synchronous computation, we
+            // wrap that in a custom future implementation which does the
+            // translation from the future protocol to our fiber API.
+            FiberFuture {
+                fiber: Some(fiber),
+                current_poll_cx,
+                engine,
+                state: Some(crate::runtime::vm::AsyncWasmCallState::new()),
+            }
+        };
+        future.await?;
+
+        return Ok(slot.unwrap());
+
+        struct FiberFuture<'a> {
+            fiber: Option<wasmtime_fiber::Fiber<'a, Result<()>, (), Result<()>>>,
+            current_poll_cx: *mut *mut Context<'static>,
+            engine: Engine,
+            // See comments in `FiberFuture::resume` for this
+            state: Option<crate::runtime::vm::AsyncWasmCallState>,
+        }
+
+        // This is surely the most dangerous `unsafe impl Send` in the entire
+        // crate. There are two members in `FiberFuture` which cause it to not
+        // be `Send`. One is `current_poll_cx` and is entirely uninteresting.
+        // This is just used to manage `Context` pointers across `await` points
+        // in the future, and requires raw pointers to get it to happen easily.
+        // Nothing too weird about the `Send`-ness, values aren't actually
+        // crossing threads.
+        //
+        // The really interesting piece is `fiber`. Now the "fiber" here is
+        // actual honest-to-god Rust code which we're moving around. What we're
+        // doing is the equivalent of moving our thread's stack to another OS
+        // thread. Turns out we, in general, have no idea what's on the stack
+        // and would generally have no way to verify that this is actually safe
+        // to do!
+        //
+        // Thankfully, though, Wasmtime has the power. Without being glib it's
+        // actually worth examining what's on the stack. It's unfortunately not
+        // super-local to this function itself. Our closure to `Fiber::new` runs
+        // `func`, which is given to us from the outside. Thankfully, though, we
+        // have tight control over this. Usage of `on_fiber` is typically done
+        // *just* before entering WebAssembly itself, so we'll have a few stack
+        // frames of Rust code (all in Wasmtime itself) before we enter wasm.
+        //
+        // Once we've entered wasm, well then we have a whole bunch of wasm
+        // frames on the stack. We've got this nifty thing called Cranelift,
+        // though, which allows us to also have complete control over everything
+        // on the stack!
+        //
+        // Finally, when wasm switches back to the fiber's starting pointer
+        // (this future we're returning) then it means wasm has reentered Rust.
+        // Suspension can only happen via the `block_on` function of an
+        // `AsyncCx`. This, conveniently, also happens entirely in Wasmtime
+        // controlled code!
+        //
+        // There's an extremely important point that should be called out here.
+        // User-provided futures **are not on the stack** during suspension
+        // points. This is extremely crucial because we in general cannot reason
+        // about Send/Sync for stack-local variables since rustc doesn't analyze
+        // them at all. With our construction, though, we are guaranteed that
+        // Wasmtime owns all stack frames between the stack of a fiber and when
+        // the fiber suspends (and it could move across threads). At this time
+        // the only user-provided piece of data on the stack is the future
+        // itself given to us. Lo-and-behold as you might notice the future is
+        // required to be `Send`!
+        //
+        // What this all boils down to is that we, as the authors of Wasmtime,
+        // need to be extremely careful that on the async fiber stack we only
+        // store Send things. For example we can't start using `Rc` willy nilly
+        // by accident and leave a copy in TLS somewhere. (similarly we have to
+        // be ready for TLS to change while we're executing wasm code between
+        // suspension points).
+        //
+        // While somewhat onerous it shouldn't be too too hard (the TLS bit is
+        // the hardest bit so far). This does mean, though, that no user should
+        // ever have to worry about the `Send`-ness of Wasmtime. If rustc says
+        // it's ok, then it's ok.
+        //
+        // With all that in mind we unsafely assert here that wasmtime is
+        // correct. We declare the fiber as only containing Send data on its
+        // stack, despite not knowing for sure at compile time that this is
+        // correct. That's what `unsafe` in Rust is all about, though, right?
+        unsafe impl Send for FiberFuture<'_> {}
+
+        impl FiberFuture<'_> {
+            fn fiber(&self) -> &wasmtime_fiber::Fiber<'_, Result<()>, (), Result<()>> {
+                self.fiber.as_ref().unwrap()
+            }
+
+            /// This is a helper function to call `resume` on the underlying
+            /// fiber while correctly managing Wasmtime's thread-local data.
+            ///
+            /// Wasmtime's implementation of traps leverages thread-local data
+            /// to get access to metadata during a signal. This thread-local
+            /// data is a linked list of "activations" where the nodes of the
+            /// linked list are stored on the stack. It would be invalid as a
+            /// result to suspend a computation with the head of the linked list
+            /// on this stack then move the stack to another thread and resume
+            /// it. That means that a different thread would point to our stack
+            /// and our thread doesn't point to our stack at all!
+            ///
+            /// Basically management of TLS is required here one way or another.
+            /// The strategy currently settled on is to manage the list of
+            /// activations created by this fiber as a unit. When a fiber
+            /// resumes the linked list is prepended to the current thread's
+            /// list. When the fiber is suspended then the fiber's list of
+            /// activations are all removed en-masse and saved within the fiber.
+            fn resume(&mut self, val: Result<()>) -> Result<Result<()>, ()> {
+                unsafe {
+                    let prev = self.state.take().unwrap().push();
+                    let restore = Restore {
+                        fiber: self,
+                        state: Some(prev),
+                    };
+                    return restore.fiber.fiber().resume(val);
+                }
+
+                struct Restore<'a, 'b> {
+                    fiber: &'a mut FiberFuture<'b>,
+                    state: Option<crate::runtime::vm::PreviousAsyncWasmCallState>,
+                }
+
+                impl Drop for Restore<'_, '_> {
+                    fn drop(&mut self) {
+                        unsafe {
+                            self.fiber.state = Some(self.state.take().unwrap().restore());
+                        }
+                    }
+                }
+            }
+        }
+
+        impl Future for FiberFuture<'_> {
+            type Output = Result<()>;
+
+            fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+                // We need to carry over this `cx` into our fiber's runtime
+                // for when it tries to poll sub-futures that are created. Doing
+                // this must be done unsafely, however, since `cx` is only alive
+                // for this one singular function call. Here we do a `transmute`
+                // to extend the lifetime of `Context` so it can be stored in
+                // our `Store`, and then we replace the current polling context
+                // with this one.
+                //
+                // Note that the replace is done for weird situations where
+                // futures might be switching contexts and there's multiple
+                // wasmtime futures in a chain of futures.
+                //
+                // On exit from this function, though, we reset the polling
+                // context back to what it was to signify that `Store` no longer
+                // has access to this pointer.
+                unsafe {
+                    let _reset = Reset(self.current_poll_cx, *self.current_poll_cx);
+                    *self.current_poll_cx =
+                        core::mem::transmute::<&mut Context<'_>, *mut Context<'static>>(cx);
+
+                    // After that's set up we resume execution of the fiber, which
+                    // may also start the fiber for the first time. This either
+                    // returns `Ok` saying the fiber finished (yay!) or it
+                    // returns `Err` with the payload passed to `suspend`, which
+                    // in our case is `()`.
+                    match self.resume(Ok(())) {
+                        Ok(result) => Poll::Ready(result),
+
+                        // If `Err` is returned that means the fiber polled a
+                        // future but it said "Pending", so we propagate that
+                        // here.
+                        //
+                        // An additional safety check is performed when leaving
+                        // this function to help bolster the guarantees of
+                        // `unsafe impl Send` above. Notably this future may get
+                        // re-polled on a different thread. Wasmtime's
+                        // thread-local state points to the stack, however,
+                        // meaning that it would be incorrect to leave a pointer
+                        // in TLS when this function returns. This function
+                        // performs a runtime assert to verify that this is the
+                        // case, notably that the one TLS pointer Wasmtime uses
+                        // is not pointing anywhere within the stack. If it is
+                        // then that's a bug indicating that TLS management in
+                        // Wasmtime is incorrect.
+                        Err(()) => {
+                            if let Some(range) = self.fiber().stack().range() {
+                                crate::runtime::vm::AsyncWasmCallState::assert_current_state_not_in_range(range);
+                            }
+                            Poll::Pending
+                        }
+                    }
+                }
+            }
+        }
+
+        // Dropping futures is pretty special in that it means the future has
+        // been requested to be cancelled. Here we run the risk of dropping an
+        // in-progress fiber, and if we were to do nothing then the fiber would
+        // leak all its owned stack resources.
+        //
+        // To handle this we implement `Drop` here and, if the fiber isn't done,
+        // resume execution of the fiber saying "hey please stop you're
+        // interrupted". Our `Trap` created here (which has the stack trace
+        // of whomever dropped us) will then get propagated in whatever called
+        // `block_on`, and the idea is that the trap propagates all the way back
+        // up to the original fiber start, finishing execution.
+        //
+        // We don't actually care about the fiber's return value here (no one's
+        // around to look at it), we just assert the fiber finished to
+        // completion.
+        impl Drop for FiberFuture<'_> {
+            fn drop(&mut self) {
+                if !self.fiber().done() {
+                    let result = self.resume(Err(anyhow!("future dropped")));
+                    // This resumption with an error should always complete the
+                    // fiber. While it's technically possible for host code to catch
+                    // the trap and re-resume, we'd ideally like to signal that to
+                    // callers that they shouldn't be doing that.
+                    debug_assert!(result.is_ok());
+                }
+
+                self.state.take().unwrap().assert_null();
+
+                unsafe {
+                    self.engine
+                        .allocator()
+                        .deallocate_fiber_stack(self.fiber.take().unwrap().into_stack());
+                }
+            }
+        }
+    }
+}
+
+#[cfg(feature = "async")]
+pub struct AsyncCx {
+    current_suspend: *mut *mut wasmtime_fiber::Suspend<Result<()>, (), Result<()>>,
+    current_poll_cx: *mut *mut Context<'static>,
+    track_pkey_context_switch: bool,
+}
+
+#[cfg(feature = "async")]
+impl AsyncCx {
+    /// Blocks on the asynchronous computation represented by `future` and
+    /// produces the result here, in-line.
+    ///
+    /// This function is designed to only work when it's currently executing on
+    /// a native fiber. This fiber provides the ability for us to handle the
+    /// future's `Pending` state as "jump back to whomever called the fiber in
+    /// an asynchronous fashion and propagate `Pending`". This tight coupling
+    /// with `on_fiber` below is what powers the asynchronicity of calling wasm.
+    /// Note that the asynchronous part only applies to host functions, wasm
+    /// itself never really does anything asynchronous at this time.
+    ///
+    /// This function takes a `future` and will (appear to) synchronously wait
+    /// on the result. While this function is executing it will fiber switch
+    /// to-and-from the original frame calling `on_fiber` which should be a
+    /// guarantee due to how async stores are configured.
+    ///
+    /// The return value here is either the output of the future `T`, or a trap
+    /// which represents that the asynchronous computation was cancelled. It is
+    /// not recommended to catch the trap and try to keep executing wasm, so
+    /// we've tried to liberally document this.
+    pub unsafe fn block_on<U>(
+        &self,
+        mut future: Pin<&mut (dyn Future<Output = U> + Send)>,
+    ) -> Result<U> {
+        // Take our current `Suspend` context which was configured as soon as
+        // our fiber started. Note that we must load it at the front here and
+        // save it on our stack frame. While we're polling the future other
+        // fibers may be started for recursive computations, and the current
+        // suspend context is only preserved at the edges of the fiber, not
+        // during the fiber itself.
+        //
+        // For a little bit of extra safety we also replace the current value
+        // with null to try to catch any accidental bugs on our part early.
+        // This is all pretty unsafe so we're trying to be careful...
+        //
+        // Note that there should be a segfaulting test  in `async_functions.rs`
+        // if this `Reset` is removed.
+        let suspend = *self.current_suspend;
+        let _reset = Reset(self.current_suspend, suspend);
+        *self.current_suspend = ptr::null_mut();
+        assert!(!suspend.is_null());
+
+        loop {
+            let future_result = {
+                let poll_cx = *self.current_poll_cx;
+                let _reset = Reset(self.current_poll_cx, poll_cx);
+                *self.current_poll_cx = ptr::null_mut();
+                assert!(!poll_cx.is_null());
+                future.as_mut().poll(&mut *poll_cx)
+            };
+
+            match future_result {
+                Poll::Ready(t) => break Ok(t),
+                Poll::Pending => {}
+            }
+
+            // In order to prevent this fiber's MPK state from being munged by
+            // other fibers while it is suspended, we save and restore it once
+            // once execution resumes. Note that when MPK is not supported,
+            // these are noops.
+            let previous_mask = if self.track_pkey_context_switch {
+                let previous_mask = mpk::current_mask();
+                mpk::allow(ProtectionMask::all());
+                previous_mask
+            } else {
+                ProtectionMask::all()
+            };
+            (*suspend).suspend(())?;
+            if self.track_pkey_context_switch {
+                mpk::allow(previous_mask);
+            }
+        }
+    }
+}
+
+unsafe impl<T> crate::runtime::vm::Store for StoreInner<T> {
+    fn vmruntime_limits(&self) -> *mut VMRuntimeLimits {
+        <StoreOpaque>::vmruntime_limits(self)
+    }
+
+    fn epoch_ptr(&self) -> *const AtomicU64 {
+        self.engine.epoch_counter() as *const _
+    }
+
+    fn maybe_gc_store(&mut self) -> Option<&mut GcStore> {
+        self.gc_store.as_mut()
+    }
+
+    fn memory_growing(
+        &mut self,
+        current: usize,
+        desired: usize,
+        maximum: Option<usize>,
+    ) -> Result<bool, anyhow::Error> {
+        match self.limiter {
+            Some(ResourceLimiterInner::Sync(ref mut limiter)) => {
+                limiter(&mut self.data).memory_growing(current, desired, maximum)
+            }
+            #[cfg(feature = "async")]
+            Some(ResourceLimiterInner::Async(ref mut limiter)) => unsafe {
+                self.inner
+                    .async_cx()
+                    .expect("ResourceLimiterAsync requires async Store")
+                    .block_on(
+                        limiter(&mut self.data)
+                            .memory_growing(current, desired, maximum)
+                            .as_mut(),
+                    )?
+            },
+            None => Ok(true),
+        }
+    }
+
+    fn memory_grow_failed(&mut self, error: anyhow::Error) -> Result<()> {
+        match self.limiter {
+            Some(ResourceLimiterInner::Sync(ref mut limiter)) => {
+                limiter(&mut self.data).memory_grow_failed(error)
+            }
+            #[cfg(feature = "async")]
+            Some(ResourceLimiterInner::Async(ref mut limiter)) => {
+                limiter(&mut self.data).memory_grow_failed(error)
+            }
+            None => {
+                log::debug!("ignoring memory growth failure error: {error:?}");
+                Ok(())
+            }
+        }
+    }
+
+    fn table_growing(
+        &mut self,
+        current: u32,
+        desired: u32,
+        maximum: Option<u32>,
+    ) -> Result<bool, anyhow::Error> {
+        // Need to borrow async_cx before the mut borrow of the limiter.
+        // self.async_cx() panicks when used with a non-async store, so
+        // wrap this in an option.
+        #[cfg(feature = "async")]
+        let async_cx = if self.async_support()
+            && matches!(self.limiter, Some(ResourceLimiterInner::Async(_)))
+        {
+            Some(self.async_cx().unwrap())
+        } else {
+            None
+        };
+
+        match self.limiter {
+            Some(ResourceLimiterInner::Sync(ref mut limiter)) => {
+                limiter(&mut self.data).table_growing(current, desired, maximum)
+            }
+            #[cfg(feature = "async")]
+            Some(ResourceLimiterInner::Async(ref mut limiter)) => unsafe {
+                async_cx
+                    .expect("ResourceLimiterAsync requires async Store")
+                    .block_on(
+                        limiter(&mut self.data)
+                            .table_growing(current, desired, maximum)
+                            .as_mut(),
+                    )?
+            },
+            None => Ok(true),
+        }
+    }
+
+    fn table_grow_failed(&mut self, error: anyhow::Error) -> Result<()> {
+        match self.limiter {
+            Some(ResourceLimiterInner::Sync(ref mut limiter)) => {
+                limiter(&mut self.data).table_grow_failed(error)
+            }
+            #[cfg(feature = "async")]
+            Some(ResourceLimiterInner::Async(ref mut limiter)) => {
+                limiter(&mut self.data).table_grow_failed(error)
+            }
+            None => {
+                log::debug!("ignoring table growth failure: {error:?}");
+                Ok(())
+            }
+        }
+    }
+
+    fn out_of_gas(&mut self) -> Result<()> {
+        if !self.refuel() {
+            return Err(Trap::OutOfFuel).err2anyhow();
+        }
+        #[cfg(feature = "async")]
+        if self.fuel_yield_interval.is_some() {
+            self.async_yield_impl()?;
+        }
+        Ok(())
+    }
+
+    fn new_epoch(&mut self) -> Result<u64, anyhow::Error> {
+        // Temporarily take the configured behavior to avoid mutably borrowing
+        // multiple times.
+        let mut behavior = self.epoch_deadline_behavior.take();
+        let delta_result = match &mut behavior {
+            None => Err(Trap::Interrupt).err2anyhow(),
+            Some(callback) => callback((&mut *self).as_context_mut()).and_then(|update| {
+                let delta = match update {
+                    UpdateDeadline::Continue(delta) => delta,
+
+                    #[cfg(feature = "async")]
+                    UpdateDeadline::Yield(delta) => {
+                        assert!(
+                            self.async_support(),
+                            "cannot use `UpdateDeadline::Yield` without enabling async support in the config"
+                        );
+                        // Do the async yield. May return a trap if future was
+                        // canceled while we're yielded.
+                        self.async_yield_impl()?;
+                        delta
+                    }
+                };
+
+                // Set a new deadline and return the new epoch deadline so
+                // the Wasm code doesn't have to reload it.
+                self.set_epoch_deadline(delta);
+                Ok(self.get_epoch_deadline())
+            })
+        };
+
+        // Put back the original behavior which was replaced by `take`.
+        self.epoch_deadline_behavior = behavior;
+        delta_result
+    }
+
+    #[cfg(feature = "gc")]
+    fn gc(&mut self, root: Option<VMGcRef>) -> Result<Option<VMGcRef>> {
+        let mut scope = RootScope::new(self);
+        let store = scope.as_context_mut().0;
+        let store_id = store.id();
+        let root = root.map(|r| store.gc_roots_mut().push_lifo_root(store_id, r));
+
+        if store.async_support() {
+            #[cfg(feature = "async")]
+            unsafe {
+                let async_cx = store.async_cx();
+                let mut future = store.gc_async();
+                async_cx
+                    .expect("attempted to pull async context during shutdown")
+                    .block_on(Pin::new_unchecked(&mut future))?;
+            }
+        } else {
+            (**store).gc();
+        }
+
+        let root = match root {
+            None => None,
+            Some(r) => {
+                let r = r
+                    .get_gc_ref(store)
+                    .expect("still in scope")
+                    .unchecked_copy();
+                Some(store.gc_store_mut()?.clone_gc_ref(&r))
+            }
+        };
+
+        Ok(root)
+    }
+
+    #[cfg(not(feature = "gc"))]
+    fn gc(&mut self, root: Option<VMGcRef>) -> Result<Option<VMGcRef>> {
+        Ok(root)
+    }
+
+    #[cfg(feature = "component-model")]
+    fn component_calls(&mut self) -> &mut crate::runtime::vm::component::CallContexts {
+        &mut self.component_calls
+    }
+}
+
+impl<T> StoreInner<T> {
+    pub(crate) fn set_epoch_deadline(&mut self, delta: u64) {
+        // Set a new deadline based on the "epoch deadline delta".
+        //
+        // Safety: this is safe because the epoch deadline in the
+        // `VMRuntimeLimits` is accessed only here and by Wasm guest code
+        // running in this store, and we have a `&mut self` here.
+        //
+        // Also, note that when this update is performed while Wasm is
+        // on the stack, the Wasm will reload the new value once we
+        // return into it.
+        let epoch_deadline = unsafe { (*self.vmruntime_limits()).epoch_deadline.get_mut() };
+        *epoch_deadline = self.engine().current_epoch() + delta;
+    }
+
+    fn epoch_deadline_trap(&mut self) {
+        self.epoch_deadline_behavior = None;
+    }
+
+    fn epoch_deadline_callback(
+        &mut self,
+        callback: Box<dyn FnMut(StoreContextMut<T>) -> Result<UpdateDeadline> + Send + Sync>,
+    ) {
+        self.epoch_deadline_behavior = Some(callback);
+    }
+
+    fn epoch_deadline_async_yield_and_update(&mut self, delta: u64) {
+        assert!(
+            self.async_support(),
+            "cannot use `epoch_deadline_async_yield_and_update` without enabling async support in the config"
+        );
+        #[cfg(feature = "async")]
+        {
+            self.epoch_deadline_behavior =
+                Some(Box::new(move |_store| Ok(UpdateDeadline::Yield(delta))));
+        }
+        let _ = delta; // suppress warning in non-async build
+    }
+
+    fn get_epoch_deadline(&self) -> u64 {
+        // Safety: this is safe because, as above, it is only invoked
+        // from within `new_epoch` which is called from guest Wasm
+        // code, which will have an exclusive borrow on the Store.
+        let epoch_deadline = unsafe { (*self.vmruntime_limits()).epoch_deadline.get_mut() };
+        *epoch_deadline
+    }
+}
+
+impl<T: Default> Default for Store<T> {
+    fn default() -> Store<T> {
+        Store::new(&Engine::default(), T::default())
+    }
+}
+
+impl<T: fmt::Debug> fmt::Debug for Store<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let inner = &**self.inner as *const StoreInner<T>;
+        f.debug_struct("Store")
+            .field("inner", &inner)
+            .field("data", &self.inner.data)
+            .finish()
+    }
+}
+
+impl<T> Drop for Store<T> {
+    fn drop(&mut self) {
+        // for documentation on this `unsafe`, see `into_data`.
+        unsafe {
+            ManuallyDrop::drop(&mut self.inner.data);
+            ManuallyDrop::drop(&mut self.inner);
+        }
+    }
+}
+
+impl Drop for StoreOpaque {
+    fn drop(&mut self) {
+        // NB it's important that this destructor does not access `self.data`.
+        // That is deallocated by `Drop for Store<T>` above.
+
+        unsafe {
+            let allocator = self.engine.allocator();
+            let ondemand = OnDemandInstanceAllocator::default();
+            for instance in self.instances.iter_mut() {
+                if let StoreInstanceKind::Dummy = instance.kind {
+                    ondemand.deallocate_module(&mut instance.handle);
+                } else {
+                    allocator.deallocate_module(&mut instance.handle);
+                }
+            }
+            ondemand.deallocate_module(&mut self.default_caller);
+
+            #[cfg(feature = "gc")]
+            if let Some(gc_store) = self.gc_store.take() {
+                if self.engine.features().gc_types() {
+                    allocator.deallocate_gc_heap(gc_store.allocation_index, gc_store.gc_heap);
+                } else {
+                    // If GC types are not enabled, we are just dealing with a
+                    // dummy GC heap.
+                    debug_assert_eq!(gc_store.allocation_index, GcHeapAllocationIndex::default());
+                    debug_assert!(gc_store.gc_heap.as_any().is::<crate::vm::DisabledGcHeap>());
+                }
+            }
+
+            #[cfg(feature = "component-model")]
+            {
+                for _ in 0..self.num_component_instances {
+                    allocator.decrement_component_instance_count();
+                }
+            }
+
+            // See documentation for these fields on `StoreOpaque` for why they
+            // must be dropped in this order.
+            ManuallyDrop::drop(&mut self.store_data);
+            ManuallyDrop::drop(&mut self.rooted_host_funcs);
+        }
+    }
+}
+
+impl crate::runtime::vm::ModuleInfoLookup for ModuleRegistry {
+    fn lookup(&self, pc: usize) -> Option<&dyn crate::runtime::vm::ModuleInfo> {
+        self.lookup_module_info(pc)
+    }
+}
+
+struct Reset<T: Copy>(*mut T, T);
+
+impl<T: Copy> Drop for Reset<T> {
+    fn drop(&mut self) {
+        unsafe {
+            *self.0 = self.1;
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{get_fuel, refuel, set_fuel};
+    use std::num::NonZeroU64;
+
+    struct FuelTank {
+        pub consumed_fuel: i64,
+        pub reserve_fuel: u64,
+        pub yield_interval: Option<NonZeroU64>,
+    }
+
+    impl FuelTank {
+        fn new() -> Self {
+            FuelTank {
+                consumed_fuel: 0,
+                reserve_fuel: 0,
+                yield_interval: None,
+            }
+        }
+        fn get_fuel(&self) -> u64 {
+            get_fuel(self.consumed_fuel, self.reserve_fuel)
+        }
+        fn refuel(&mut self) -> bool {
+            refuel(
+                &mut self.consumed_fuel,
+                &mut self.reserve_fuel,
+                self.yield_interval,
+            )
+        }
+        fn set_fuel(&mut self, fuel: u64) {
+            set_fuel(
+                &mut self.consumed_fuel,
+                &mut self.reserve_fuel,
+                self.yield_interval,
+                fuel,
+            );
+        }
+    }
+
+    #[test]
+    fn smoke() {
+        let mut tank = FuelTank::new();
+        tank.set_fuel(10);
+        assert_eq!(tank.consumed_fuel, -10);
+        assert_eq!(tank.reserve_fuel, 0);
+
+        tank.yield_interval = NonZeroU64::new(10);
+        tank.set_fuel(25);
+        assert_eq!(tank.consumed_fuel, -10);
+        assert_eq!(tank.reserve_fuel, 15);
+    }
+
+    #[test]
+    fn does_not_lose_precision() {
+        let mut tank = FuelTank::new();
+        tank.set_fuel(u64::MAX);
+        assert_eq!(tank.get_fuel(), u64::MAX);
+
+        tank.set_fuel(i64::MAX as u64);
+        assert_eq!(tank.get_fuel(), i64::MAX as u64);
+
+        tank.set_fuel(i64::MAX as u64 + 1);
+        assert_eq!(tank.get_fuel(), i64::MAX as u64 + 1);
+    }
+
+    #[test]
+    fn yielding_does_not_lose_precision() {
+        let mut tank = FuelTank::new();
+
+        tank.yield_interval = NonZeroU64::new(10);
+        tank.set_fuel(u64::MAX);
+        assert_eq!(tank.get_fuel(), u64::MAX);
+        assert_eq!(tank.consumed_fuel, -10);
+        assert_eq!(tank.reserve_fuel, u64::MAX - 10);
+
+        tank.yield_interval = NonZeroU64::new(u64::MAX);
+        tank.set_fuel(u64::MAX);
+        assert_eq!(tank.get_fuel(), u64::MAX);
+        assert_eq!(tank.consumed_fuel, -i64::MAX);
+        assert_eq!(tank.reserve_fuel, u64::MAX - (i64::MAX as u64));
+
+        tank.yield_interval = NonZeroU64::new((i64::MAX as u64) + 1);
+        tank.set_fuel(u64::MAX);
+        assert_eq!(tank.get_fuel(), u64::MAX);
+        assert_eq!(tank.consumed_fuel, -i64::MAX);
+        assert_eq!(tank.reserve_fuel, u64::MAX - (i64::MAX as u64));
+    }
+
+    #[test]
+    fn refueling() {
+        // It's possible to fuel to have consumed over the limit as some instructions can consume
+        // multiple units of fuel at once. Refueling should be strict in it's consumption and not
+        // add more fuel than there is.
+        let mut tank = FuelTank::new();
+
+        tank.yield_interval = NonZeroU64::new(10);
+        tank.reserve_fuel = 42;
+        tank.consumed_fuel = 4;
+        assert!(tank.refuel());
+        assert_eq!(tank.reserve_fuel, 28);
+        assert_eq!(tank.consumed_fuel, -10);
+
+        tank.yield_interval = NonZeroU64::new(1);
+        tank.reserve_fuel = 8;
+        tank.consumed_fuel = 4;
+        assert_eq!(tank.get_fuel(), 4);
+        assert!(tank.refuel());
+        assert_eq!(tank.reserve_fuel, 3);
+        assert_eq!(tank.consumed_fuel, -1);
+        assert_eq!(tank.get_fuel(), 4);
+
+        tank.yield_interval = NonZeroU64::new(10);
+        tank.reserve_fuel = 3;
+        tank.consumed_fuel = 4;
+        assert_eq!(tank.get_fuel(), 0);
+        assert!(!tank.refuel());
+        assert_eq!(tank.reserve_fuel, 3);
+        assert_eq!(tank.consumed_fuel, 4);
+        assert_eq!(tank.get_fuel(), 0);
+    }
+}
diff --git a/crates/wasmtime/src/store/context.rs b/crates/wasmtime/src/runtime/store/context.rs
similarity index 99%
rename from crates/wasmtime/src/store/context.rs
rename to crates/wasmtime/src/runtime/store/context.rs
index 2e65c0c3344a..98211da5591e 100644
--- a/crates/wasmtime/src/store/context.rs
+++ b/crates/wasmtime/src/runtime/store/context.rs
@@ -32,7 +32,7 @@ impl<'a, T> StoreContextMut<'a, T> {
     /// Unfortunately there's not a ton of debug asserts we can add here, so we
     /// rely on testing to largely help show that this is correctly used.
     pub(crate) unsafe fn from_raw(
-        store: *mut dyn wasmtime_runtime::Store,
+        store: *mut dyn crate::runtime::vm::Store,
     ) -> StoreContextMut<'a, T> {
         StoreContextMut(&mut *(store as *mut StoreInner<T>))
     }
diff --git a/crates/wasmtime/src/runtime/store/data.rs b/crates/wasmtime/src/runtime/store/data.rs
new file mode 100644
index 000000000000..4a119bcd80db
--- /dev/null
+++ b/crates/wasmtime/src/runtime/store/data.rs
@@ -0,0 +1,301 @@
+use crate::prelude::*;
+use crate::store::StoreOpaque;
+use crate::{StoreContext, StoreContextMut};
+use core::fmt;
+use core::marker;
+use core::num::NonZeroU64;
+use core::ops::{Index, IndexMut};
+use core::sync::atomic::{AtomicU64, Ordering::Relaxed};
+
+// This is defined here, in a private submodule, so we can explicitly reexport
+// it only as `pub(crate)`. This avoids a ton of
+// crate-private-type-in-public-interface errors that aren't really too
+// interesting to deal with.
+#[derive(Copy, Clone)]
+pub struct InstanceId(pub(super) usize);
+
+impl InstanceId {
+    pub fn from_index(idx: usize) -> InstanceId {
+        InstanceId(idx)
+    }
+}
+
+pub struct StoreData {
+    id: StoreId,
+    funcs: Vec<crate::func::FuncData>,
+    tables: Vec<crate::runtime::vm::ExportTable>,
+    globals: Vec<crate::runtime::vm::ExportGlobal>,
+    instances: Vec<crate::instance::InstanceData>,
+    memories: Vec<crate::runtime::vm::ExportMemory>,
+    #[cfg(feature = "component-model")]
+    pub(crate) components: crate::component::ComponentStoreData,
+}
+
+pub trait StoredData: Sized {
+    fn list(data: &StoreData) -> &Vec<Self>;
+    fn list_mut(data: &mut StoreData) -> &mut Vec<Self>;
+}
+
+macro_rules! impl_store_data {
+    ($($field:ident => $t:ty,)*) => ($(
+        impl StoredData for $t {
+            #[inline]
+            fn list(data: &StoreData) -> &Vec<Self> { &data.$field }
+            #[inline]
+            fn list_mut(data: &mut StoreData) -> &mut Vec<Self> { &mut data.$field }
+        }
+    )*)
+}
+
+impl_store_data! {
+    funcs => crate::func::FuncData,
+    tables => crate::runtime::vm::ExportTable,
+    globals => crate::runtime::vm::ExportGlobal,
+    instances => crate::instance::InstanceData,
+    memories => crate::runtime::vm::ExportMemory,
+}
+
+impl StoreData {
+    pub fn new() -> StoreData {
+        StoreData {
+            id: StoreId::allocate(),
+            funcs: Vec::new(),
+            tables: Vec::new(),
+            globals: Vec::new(),
+            instances: Vec::new(),
+            memories: Vec::new(),
+            #[cfg(feature = "component-model")]
+            components: Default::default(),
+        }
+    }
+
+    pub fn id(&self) -> StoreId {
+        self.id
+    }
+
+    pub fn insert<T>(&mut self, data: T) -> Stored<T>
+    where
+        T: StoredData,
+    {
+        let list = T::list_mut(self);
+        let index = list.len();
+        list.push(data);
+        Stored::new(self.id, index)
+    }
+
+    pub fn next_id<T>(&self) -> Stored<T>
+    where
+        T: StoredData,
+    {
+        Stored::new(self.id, T::list(self).len())
+    }
+
+    pub fn contains<T>(&self, id: Stored<T>) -> bool
+    where
+        T: StoredData,
+    {
+        if id.store_id != self.id {
+            return false;
+        }
+        // This should be true as an invariant of our API, but double-check with
+        // debug assertions enabled.
+        debug_assert!(id.index() < T::list(self).len());
+        true
+    }
+
+    pub fn iter<T>(&self) -> impl ExactSizeIterator<Item = Stored<T>>
+    where
+        T: StoredData,
+    {
+        let id = self.id;
+        (0..T::list(self).len()).map(move |i| Stored::new(id, i))
+    }
+
+    pub(crate) fn reserve_funcs(&mut self, count: usize) {
+        self.funcs.reserve(count);
+    }
+}
+
+impl<T> Index<Stored<T>> for StoreData
+where
+    T: StoredData,
+{
+    type Output = T;
+
+    #[inline]
+    fn index(&self, index: Stored<T>) -> &Self::Output {
+        index.assert_belongs_to(self.id);
+        // Note that if this is ever a performance bottleneck it should be safe
+        // to use unchecked indexing here because presence of a `Stored<T>` is
+        // proof of an item having been inserted into a store and lists in
+        // stores are never shrunk. After the store check above the actual index
+        // should always be valid.
+        &T::list(self)[index.index()]
+    }
+}
+
+impl<T> IndexMut<Stored<T>> for StoreData
+where
+    T: StoredData,
+{
+    #[inline]
+    fn index_mut(&mut self, index: Stored<T>) -> &mut Self::Output {
+        index.assert_belongs_to(self.id);
+        // Note that this could be unchecked indexing, see the note in `Index`
+        // above.
+        &mut T::list_mut(self)[index.index()]
+    }
+}
+
+// forward StoreContext => StoreData
+impl<I, T> Index<I> for StoreContext<'_, T>
+where
+    StoreData: Index<I>,
+{
+    type Output = <StoreData as Index<I>>::Output;
+
+    #[inline]
+    fn index(&self, index: I) -> &Self::Output {
+        self.0.store_data.index(index)
+    }
+}
+
+// forward StoreContextMut => StoreData
+impl<I, T> Index<I> for StoreContextMut<'_, T>
+where
+    StoreData: Index<I>,
+{
+    type Output = <StoreData as Index<I>>::Output;
+
+    #[inline]
+    fn index(&self, index: I) -> &Self::Output {
+        self.0.store_data.index(index)
+    }
+}
+
+// forward StoreOpaque => StoreData
+impl<I> Index<I> for StoreOpaque
+where
+    StoreData: Index<I>,
+{
+    type Output = <StoreData as Index<I>>::Output;
+
+    #[inline]
+    fn index(&self, index: I) -> &Self::Output {
+        self.store_data().index(index)
+    }
+}
+impl<I> IndexMut<I> for StoreOpaque
+where
+    StoreData: IndexMut<I>,
+{
+    #[inline]
+    fn index_mut(&mut self, index: I) -> &mut Self::Output {
+        self.store_data_mut().index_mut(index)
+    }
+}
+
+/// A unique identifier to get attached to a store.
+///
+/// This identifier is embedded into the `Stored<T>` structure and is used to
+/// identify the original store that items come from. For example a `Memory` is
+/// owned by a `Store` and will embed a `StoreId` internally to say which store
+/// it came from. Comparisons with this value are how panics are generated for
+/// mismatching the item that a store belongs to.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[repr(transparent)] // NB: relied on in the C API
+pub struct StoreId(NonZeroU64);
+
+impl StoreId {
+    /// Allocates a new unique identifier for a store that has never before been
+    /// used in this process.
+    pub fn allocate() -> StoreId {
+        static NEXT_ID: AtomicU64 = AtomicU64::new(0);
+
+        // Only allow 2^63 stores at which point we start panicking to prevent
+        // overflow.
+        //
+        // If a store is created once per microsecond then this will last the
+        // current process for 584,540 years before overflowing.
+        //
+        // Also note the usage of `Relaxed` ordering here which should be ok
+        // since we're only looking for atomicity on this counter and this
+        // otherwise isn't used to synchronize memory stored anywhere else.
+        let id = NEXT_ID.fetch_add(1, Relaxed);
+        if id & (1 << 63) != 0 {
+            NEXT_ID.store(1 << 63, Relaxed);
+            panic!("store id allocator overflow");
+        }
+
+        StoreId(NonZeroU64::new(id + 1).unwrap())
+    }
+
+    #[inline]
+    pub fn assert_belongs_to(&self, store: StoreId) {
+        if *self == store {
+            return;
+        }
+        store_id_mismatch();
+    }
+
+    /// Raw accessor for the C API.
+    pub fn as_raw(&self) -> NonZeroU64 {
+        self.0
+    }
+
+    /// Raw constructor for the C API.
+    pub fn from_raw(id: NonZeroU64) -> StoreId {
+        StoreId(id)
+    }
+}
+
+#[repr(C)] // used by reference in the C API, also in `wasmtime_func_t`.
+pub struct Stored<T> {
+    store_id: StoreId,
+    index: usize,
+    _marker: marker::PhantomData<fn() -> T>,
+}
+
+impl<T> Stored<T> {
+    fn new(store_id: StoreId, index: usize) -> Stored<T> {
+        Stored {
+            store_id,
+            index,
+            _marker: marker::PhantomData,
+        }
+    }
+
+    #[inline]
+    pub fn assert_belongs_to(&self, store: StoreId) {
+        self.store_id.assert_belongs_to(store)
+    }
+
+    fn index(&self) -> usize {
+        self.index
+    }
+}
+
+#[cold]
+fn store_id_mismatch() {
+    panic!("object used with the wrong store");
+}
+
+impl<T> PartialEq for Stored<T> {
+    fn eq(&self, other: &Stored<T>) -> bool {
+        self.store_id == other.store_id && self.index == other.index
+    }
+}
+
+impl<T> Copy for Stored<T> {}
+
+impl<T> Clone for Stored<T> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<T> fmt::Debug for Stored<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "store={}, index={}", self.store_id.0, self.index())
+    }
+}
diff --git a/crates/wasmtime/src/store/func_refs.rs b/crates/wasmtime/src/runtime/store/func_refs.rs
similarity index 79%
rename from crates/wasmtime/src/store/func_refs.rs
rename to crates/wasmtime/src/runtime/store/func_refs.rs
index b84849cdc29e..9b195e42af7b 100644
--- a/crates/wasmtime/src/store/func_refs.rs
+++ b/crates/wasmtime/src/runtime/store/func_refs.rs
@@ -1,6 +1,11 @@
+//! Lifetime management of `VMFuncRef`s inside of stores, and filling in their
+//! trampolines.
+
 use crate::module::ModuleRegistry;
-use std::{ptr::NonNull, sync::Arc};
-use wasmtime_runtime::{SendSyncPtr, VMFuncRef, VMNativeCallHostFuncContext};
+use crate::prelude::*;
+use crate::runtime::vm::{SendSyncPtr, VMArrayCallHostFuncContext, VMFuncRef};
+use alloc::sync::Arc;
+use core::ptr::NonNull;
 
 /// An arena of `VMFuncRef`s.
 ///
@@ -50,9 +55,9 @@ impl FuncRefs {
     /// `FuncRefs` and only while the store holding this `FuncRefs` exists.
     pub unsafe fn push(&mut self, func_ref: VMFuncRef) -> NonNull<VMFuncRef> {
         debug_assert!(func_ref.wasm_call.is_none());
-        // Debug assert that the vmctx is a `VMNativeCallHostFuncContext` as
+        // Debug assert that the vmctx is a `VMArrayCallHostFuncContext` as
         // that is the only kind that can have holes.
-        let _ = unsafe { VMNativeCallHostFuncContext::from_opaque(func_ref.vmctx) };
+        let _ = unsafe { VMArrayCallHostFuncContext::from_opaque(func_ref.vmctx) };
 
         let func_ref = self.bump.alloc(func_ref);
         let unpatched = SendSyncPtr::from(func_ref);
@@ -68,11 +73,11 @@ impl FuncRefs {
                 let func_ref = f.as_mut();
                 debug_assert!(func_ref.wasm_call.is_none());
 
-                // Debug assert that the vmctx is a `VMNativeCallHostFuncContext` as
+                // Debug assert that the vmctx is a `VMArrayCallHostFuncContext` as
                 // that is the only kind that can have holes.
-                let _ = VMNativeCallHostFuncContext::from_opaque(func_ref.vmctx);
+                let _ = VMArrayCallHostFuncContext::from_opaque(func_ref.vmctx);
 
-                func_ref.wasm_call = modules.wasm_to_native_trampoline(func_ref.type_index);
+                func_ref.wasm_call = modules.wasm_to_array_trampoline(func_ref.type_index);
                 func_ref.wasm_call.is_none()
             }
         });
diff --git a/crates/wasmtime/src/runtime/trampoline.rs b/crates/wasmtime/src/runtime/trampoline.rs
new file mode 100644
index 000000000000..a060ea306127
--- /dev/null
+++ b/crates/wasmtime/src/runtime/trampoline.rs
@@ -0,0 +1,75 @@
+//! Utility module to create trampolines in/out WebAssembly module.
+
+mod func;
+mod global;
+mod memory;
+mod table;
+
+pub use self::func::*;
+pub use self::global::*;
+pub(crate) use memory::MemoryCreatorProxy;
+
+use self::memory::create_memory;
+use self::table::create_table;
+use crate::prelude::*;
+use crate::runtime::vm::{
+    Imports, InstanceAllocationRequest, InstanceAllocator, ModuleRuntimeInfo,
+    OnDemandInstanceAllocator, SharedMemory, StorePtr, VMFunctionImport,
+};
+use crate::store::{InstanceId, StoreOpaque};
+use crate::{MemoryType, TableType};
+use alloc::sync::Arc;
+use core::any::Any;
+use wasmtime_environ::{MemoryIndex, Module, TableIndex, VMSharedTypeIndex};
+
+fn create_handle(
+    module: Module,
+    store: &mut StoreOpaque,
+    host_state: Box<dyn Any + Send + Sync>,
+    func_imports: &[VMFunctionImport],
+    one_signature: Option<VMSharedTypeIndex>,
+) -> Result<InstanceId> {
+    let mut imports = Imports::default();
+    imports.functions = func_imports;
+
+    unsafe {
+        let config = store.engine().config();
+        // Use the on-demand allocator when creating handles associated with host objects
+        // The configured instance allocator should only be used when creating module instances
+        // as we don't want host objects to count towards instance limits.
+        let module = Arc::new(module);
+        let runtime_info = &ModuleRuntimeInfo::bare_maybe_imported_func(module, one_signature);
+        let allocator = OnDemandInstanceAllocator::new(config.mem_creator.clone(), 0);
+        let handle = allocator.allocate_module(InstanceAllocationRequest {
+            imports,
+            host_state,
+            store: StorePtr::new(store.traitobj()),
+            runtime_info,
+            wmemcheck: false,
+            pkey: None,
+        })?;
+
+        Ok(store.add_dummy_instance(handle))
+    }
+}
+
+pub fn generate_memory_export(
+    store: &mut StoreOpaque,
+    m: &MemoryType,
+    preallocation: Option<&SharedMemory>,
+) -> Result<crate::runtime::vm::ExportMemory> {
+    let instance = create_memory(store, m, preallocation)?;
+    Ok(store
+        .instance_mut(instance)
+        .get_exported_memory(MemoryIndex::from_u32(0)))
+}
+
+pub fn generate_table_export(
+    store: &mut StoreOpaque,
+    t: &TableType,
+) -> Result<crate::runtime::vm::ExportTable> {
+    let instance = create_table(store, t)?;
+    Ok(store
+        .instance_mut(instance)
+        .get_exported_table(TableIndex::from_u32(0)))
+}
diff --git a/crates/wasmtime/src/runtime/trampoline/func.rs b/crates/wasmtime/src/runtime/trampoline/func.rs
new file mode 100644
index 000000000000..7ecf43b854c5
--- /dev/null
+++ b/crates/wasmtime/src/runtime/trampoline/func.rs
@@ -0,0 +1,93 @@
+//! Support for a calling of an imported function.
+
+use crate::prelude::*;
+use crate::runtime::vm::{
+    StoreBox, VMArrayCallHostFuncContext, VMContext, VMFuncRef, VMOpaqueContext,
+};
+use crate::type_registry::RegisteredType;
+use crate::{FuncType, ValRaw};
+use core::ptr;
+
+struct TrampolineState<F> {
+    func: F,
+
+    // Need to keep our `VMSharedTypeIndex` registered in the engine.
+    #[allow(dead_code)]
+    sig: RegisteredType,
+}
+
+/// Shim to call a host-defined function that uses the array calling convention.
+///
+/// Together with `VMArrayCallHostFuncContext`, this implements the transition
+/// from a raw, non-closure function pointer to a Rust closure that associates
+/// data and function together.
+///
+/// Also shepherds panics and traps across Wasm.
+unsafe extern "C" fn array_call_shim<F>(
+    vmctx: *mut VMOpaqueContext,
+    caller_vmctx: *mut VMOpaqueContext,
+    values_vec: *mut ValRaw,
+    values_vec_len: usize,
+) where
+    F: Fn(*mut VMContext, &mut [ValRaw]) -> Result<()> + 'static,
+{
+    // Here we are careful to use `catch_unwind` to ensure Rust panics don't
+    // unwind past us. The primary reason for this is that Rust considers it UB
+    // to unwind past an `extern "C"` function. Here we are in an `extern "C"`
+    // function and the cross into wasm was through an `extern "C"` function at
+    // the base of the stack as well. We'll need to wait for assorted RFCs and
+    // language features to enable this to be done in a sound and stable fashion
+    // before avoiding catching the panic here.
+    //
+    // Also note that there are intentionally no local variables on this stack
+    // frame. The reason for that is that some of the "raise" functions we have
+    // below will trigger a longjmp, which won't run local destructors if we
+    // have any. To prevent leaks we avoid having any local destructors by
+    // avoiding local variables.
+    let result = crate::runtime::vm::catch_unwind_and_longjmp(|| {
+        let vmctx = VMArrayCallHostFuncContext::from_opaque(vmctx);
+        // Double-check ourselves in debug mode, but we control
+        // the `Any` here so an unsafe downcast should also
+        // work.
+        let state = (*vmctx).host_state();
+        debug_assert!(state.is::<TrampolineState<F>>());
+        let state = &*(state as *const _ as *const TrampolineState<F>);
+        let values_vec = core::slice::from_raw_parts_mut(values_vec, values_vec_len);
+        (state.func)(VMContext::from_opaque(caller_vmctx), values_vec)
+    });
+
+    match result {
+        Ok(()) => {}
+
+        // If a trap was raised (an error returned from the imported function)
+        // then we smuggle the trap through `Box<dyn Error>` through to the
+        // call-site, which gets unwrapped in `Trap::from_runtime` later on as we
+        // convert from the internal `Trap` type to our own `Trap` type in this
+        // crate.
+        Err(trap) => crate::trap::raise(trap.into()),
+    }
+}
+
+pub fn create_array_call_function<F>(
+    ft: &FuncType,
+    func: F,
+) -> Result<StoreBox<VMArrayCallHostFuncContext>>
+where
+    F: Fn(*mut VMContext, &mut [ValRaw]) -> Result<()> + Send + Sync + 'static,
+{
+    let array_call = array_call_shim::<F>;
+
+    let sig = ft.clone().into_registered_type();
+
+    unsafe {
+        Ok(VMArrayCallHostFuncContext::new(
+            VMFuncRef {
+                array_call,
+                wasm_call: None,
+                type_index: sig.index(),
+                vmctx: ptr::null_mut(),
+            },
+            Box::new(TrampolineState { func, sig }),
+        ))
+    }
+}
diff --git a/crates/wasmtime/src/runtime/trampoline/global.rs b/crates/wasmtime/src/runtime/trampoline/global.rs
new file mode 100644
index 000000000000..80578f8c518d
--- /dev/null
+++ b/crates/wasmtime/src/runtime/trampoline/global.rs
@@ -0,0 +1,70 @@
+use crate::runtime::vm::{StoreBox, VMGlobalDefinition};
+use crate::store::{AutoAssertNoGc, StoreOpaque};
+use crate::{GlobalType, Mutability, Result, RootedGcRefImpl, Val};
+use core::ptr;
+
+#[repr(C)]
+pub struct VMHostGlobalContext {
+    pub(crate) ty: GlobalType,
+    pub(crate) global: VMGlobalDefinition,
+}
+
+pub fn generate_global_export(
+    store: &mut StoreOpaque,
+    ty: GlobalType,
+    val: Val,
+) -> Result<crate::runtime::vm::ExportGlobal> {
+    let global = wasmtime_environ::Global {
+        wasm_ty: ty.content().to_wasm_type(),
+        mutability: match ty.mutability() {
+            Mutability::Const => false,
+            Mutability::Var => true,
+        },
+    };
+    let ctx = StoreBox::new(VMHostGlobalContext {
+        ty,
+        global: VMGlobalDefinition::new(),
+    });
+
+    let mut store = AutoAssertNoGc::new(store);
+    let definition = unsafe {
+        let global = &mut (*ctx.get()).global;
+        match val {
+            Val::I32(x) => *global.as_i32_mut() = x,
+            Val::I64(x) => *global.as_i64_mut() = x,
+            Val::F32(x) => *global.as_f32_bits_mut() = x,
+            Val::F64(x) => *global.as_f64_bits_mut() = x,
+            Val::V128(x) => *global.as_u128_mut() = x.into(),
+            Val::FuncRef(f) => {
+                *global.as_func_ref_mut() =
+                    f.map_or(ptr::null_mut(), |f| f.vm_func_ref(&mut store).as_ptr());
+            }
+            Val::ExternRef(x) => {
+                let new = match x {
+                    None => None,
+                    #[cfg_attr(not(feature = "gc"), allow(unreachable_patterns))]
+                    Some(x) => Some(x.try_gc_ref(&mut store)?.unchecked_copy()),
+                };
+                let new = new.as_ref();
+                global.write_gc_ref(store.gc_store_mut()?, new);
+            }
+            Val::AnyRef(a) => {
+                let new = match a {
+                    None => None,
+                    #[cfg_attr(not(feature = "gc"), allow(unreachable_patterns))]
+                    Some(a) => Some(a.try_gc_ref(&mut store)?.unchecked_copy()),
+                };
+                let new = new.as_ref();
+                global.write_gc_ref(store.gc_store_mut()?, new);
+            }
+        }
+        global
+    };
+
+    store.host_globals().push(ctx);
+    Ok(crate::runtime::vm::ExportGlobal {
+        definition,
+        vmctx: ptr::null_mut(),
+        global,
+    })
+}
diff --git a/crates/wasmtime/src/runtime/trampoline/memory.rs b/crates/wasmtime/src/runtime/trampoline/memory.rs
new file mode 100644
index 000000000000..ca35719326ae
--- /dev/null
+++ b/crates/wasmtime/src/runtime/trampoline/memory.rs
@@ -0,0 +1,295 @@
+use crate::memory::{LinearMemory, MemoryCreator};
+use crate::prelude::*;
+use crate::runtime::vm::mpk::ProtectionKey;
+use crate::runtime::vm::{
+    CompiledModuleId, GcHeapAllocationIndex, Imports, InstanceAllocationRequest, InstanceAllocator,
+    InstanceAllocatorImpl, Memory, MemoryAllocationIndex, MemoryImage, ModuleRuntimeInfo,
+    OnDemandInstanceAllocator, RuntimeLinearMemory, RuntimeMemoryCreator, SharedMemory, StorePtr,
+    Table, TableAllocationIndex, VMMemoryDefinition,
+};
+use crate::store::{InstanceId, StoreOpaque};
+use crate::MemoryType;
+use alloc::sync::Arc;
+use core::ops::Range;
+use wasmtime_environ::{
+    DefinedMemoryIndex, DefinedTableIndex, EntityIndex, HostPtr, MemoryPlan, MemoryStyle, Module,
+    VMOffsets,
+};
+
+#[cfg(feature = "component-model")]
+use wasmtime_environ::{
+    component::{Component, VMComponentOffsets},
+    StaticModuleIndex,
+};
+
+/// Create a "frankenstein" instance with a single memory.
+///
+/// This separate instance is necessary because Wasm objects in Wasmtime must be
+/// attached to instances (versus the store, e.g.) and some objects exist
+/// outside: a host-provided memory import, shared memory.
+pub fn create_memory(
+    store: &mut StoreOpaque,
+    memory_ty: &MemoryType,
+    preallocation: Option<&SharedMemory>,
+) -> Result<InstanceId> {
+    let mut module = Module::new();
+
+    // Create a memory plan for the memory, though it will never be used for
+    // constructing a memory with an allocator: instead the memories are either
+    // preallocated (i.e., shared memory) or allocated manually below.
+    let plan = wasmtime_environ::MemoryPlan::for_memory(
+        *memory_ty.wasmtime_memory(),
+        store.engine().tunables(),
+    );
+    let memory_id = module.memory_plans.push(plan.clone());
+
+    // Since we have only associated a single memory with the "frankenstein"
+    // instance, it will be exported at index 0.
+    debug_assert_eq!(memory_id.as_u32(), 0);
+    module
+        .exports
+        .insert(String::new(), EntityIndex::Memory(memory_id));
+
+    // We create an instance in the on-demand allocator when creating handles
+    // associated with external objects. The configured instance allocator
+    // should only be used when creating module instances as we don't want host
+    // objects to count towards instance limits.
+    let runtime_info = &ModuleRuntimeInfo::bare_maybe_imported_func(Arc::new(module), None);
+    let host_state = Box::new(());
+    let imports = Imports::default();
+    let request = InstanceAllocationRequest {
+        imports,
+        host_state,
+        store: StorePtr::new(store.traitobj()),
+        runtime_info,
+        wmemcheck: false,
+        pkey: None,
+    };
+
+    unsafe {
+        let handle = SingleMemoryInstance {
+            preallocation,
+            ondemand: OnDemandInstanceAllocator::default(),
+        }
+        .allocate_module(request)?;
+        let instance_id = store.add_dummy_instance(handle.clone());
+        Ok(instance_id)
+    }
+}
+
+struct LinearMemoryProxy {
+    mem: Box<dyn LinearMemory>,
+    page_size_log2: u8,
+}
+
+impl RuntimeLinearMemory for LinearMemoryProxy {
+    fn page_size_log2(&self) -> u8 {
+        self.page_size_log2
+    }
+
+    fn byte_size(&self) -> usize {
+        self.mem.byte_size()
+    }
+
+    fn maximum_byte_size(&self) -> Option<usize> {
+        self.mem.maximum_byte_size()
+    }
+
+    fn grow_to(&mut self, new_size: usize) -> Result<()> {
+        self.mem.grow_to(new_size)
+    }
+
+    fn vmmemory(&mut self) -> VMMemoryDefinition {
+        VMMemoryDefinition {
+            base: self.mem.as_ptr(),
+            current_length: self.mem.byte_size().into(),
+        }
+    }
+
+    fn needs_init(&self) -> bool {
+        true
+    }
+
+    fn as_any_mut(&mut self) -> &mut dyn core::any::Any {
+        self
+    }
+
+    fn wasm_accessible(&self) -> Range<usize> {
+        self.mem.wasm_accessible()
+    }
+}
+
+#[derive(Clone)]
+pub(crate) struct MemoryCreatorProxy(pub Arc<dyn MemoryCreator>);
+
+impl RuntimeMemoryCreator for MemoryCreatorProxy {
+    fn new_memory(
+        &self,
+        plan: &MemoryPlan,
+        minimum: usize,
+        maximum: Option<usize>,
+        _: Option<&Arc<MemoryImage>>,
+    ) -> Result<Box<dyn RuntimeLinearMemory>> {
+        let ty = MemoryType::from_wasmtime_memory(&plan.memory);
+        let reserved_size_in_bytes = match plan.style {
+            MemoryStyle::Static { byte_reservation } => {
+                Some(usize::try_from(byte_reservation).unwrap())
+            }
+            MemoryStyle::Dynamic { .. } => None,
+        };
+        self.0
+            .new_memory(
+                ty,
+                minimum,
+                maximum,
+                reserved_size_in_bytes,
+                usize::try_from(plan.offset_guard_size).unwrap(),
+            )
+            .map(|mem| {
+                Box::new(LinearMemoryProxy {
+                    mem,
+                    page_size_log2: plan.memory.page_size_log2,
+                }) as Box<dyn RuntimeLinearMemory>
+            })
+            .map_err(|e| anyhow!(e))
+    }
+}
+
+struct SingleMemoryInstance<'a> {
+    preallocation: Option<&'a SharedMemory>,
+    ondemand: OnDemandInstanceAllocator,
+}
+
+unsafe impl InstanceAllocatorImpl for SingleMemoryInstance<'_> {
+    #[cfg(feature = "component-model")]
+    fn validate_component_impl<'a>(
+        &self,
+        _component: &Component,
+        _offsets: &VMComponentOffsets<HostPtr>,
+        _get_module: &'a dyn Fn(StaticModuleIndex) -> &'a Module,
+    ) -> Result<()> {
+        unreachable!("`SingleMemoryInstance` allocator never used with components")
+    }
+
+    fn validate_module_impl(&self, module: &Module, offsets: &VMOffsets<HostPtr>) -> Result<()> {
+        anyhow::ensure!(
+            module.memory_plans.len() == 1,
+            "`SingleMemoryInstance` allocator can only be used for modules with a single memory"
+        );
+        self.ondemand.validate_module_impl(module, offsets)?;
+        Ok(())
+    }
+
+    fn increment_component_instance_count(&self) -> Result<()> {
+        self.ondemand.increment_component_instance_count()
+    }
+
+    fn decrement_component_instance_count(&self) {
+        self.ondemand.decrement_component_instance_count();
+    }
+
+    fn increment_core_instance_count(&self) -> Result<()> {
+        self.ondemand.increment_core_instance_count()
+    }
+
+    fn decrement_core_instance_count(&self) {
+        self.ondemand.decrement_core_instance_count();
+    }
+
+    unsafe fn allocate_memory(
+        &self,
+        request: &mut InstanceAllocationRequest,
+        memory_plan: &MemoryPlan,
+        memory_index: DefinedMemoryIndex,
+    ) -> Result<(MemoryAllocationIndex, Memory)> {
+        #[cfg(debug_assertions)]
+        {
+            let module = request.runtime_info.module();
+            let offsets = request.runtime_info.offsets();
+            self.validate_module_impl(module, offsets)
+                .expect("should have already validated the module before allocating memory");
+        }
+
+        match self.preallocation {
+            Some(shared_memory) => Ok((
+                MemoryAllocationIndex::default(),
+                shared_memory.clone().as_memory(),
+            )),
+            None => self
+                .ondemand
+                .allocate_memory(request, memory_plan, memory_index),
+        }
+    }
+
+    unsafe fn deallocate_memory(
+        &self,
+        memory_index: DefinedMemoryIndex,
+        allocation_index: MemoryAllocationIndex,
+        memory: Memory,
+    ) {
+        self.ondemand
+            .deallocate_memory(memory_index, allocation_index, memory)
+    }
+
+    unsafe fn allocate_table(
+        &self,
+        req: &mut InstanceAllocationRequest,
+        table_plan: &wasmtime_environ::TablePlan,
+        table_index: DefinedTableIndex,
+    ) -> Result<(TableAllocationIndex, Table)> {
+        self.ondemand.allocate_table(req, table_plan, table_index)
+    }
+
+    unsafe fn deallocate_table(
+        &self,
+        table_index: DefinedTableIndex,
+        allocation_index: TableAllocationIndex,
+        table: Table,
+    ) {
+        self.ondemand
+            .deallocate_table(table_index, allocation_index, table)
+    }
+
+    #[cfg(feature = "async")]
+    fn allocate_fiber_stack(&self) -> Result<wasmtime_fiber::FiberStack> {
+        unreachable!()
+    }
+
+    #[cfg(feature = "async")]
+    unsafe fn deallocate_fiber_stack(&self, _stack: wasmtime_fiber::FiberStack) {
+        unreachable!()
+    }
+
+    fn purge_module(&self, _: CompiledModuleId) {
+        unreachable!()
+    }
+
+    fn next_available_pkey(&self) -> Option<ProtectionKey> {
+        unreachable!()
+    }
+
+    fn restrict_to_pkey(&self, _: ProtectionKey) {
+        unreachable!()
+    }
+
+    fn allow_all_pkeys(&self) {
+        unreachable!()
+    }
+
+    #[cfg(feature = "gc")]
+    fn allocate_gc_heap(
+        &self,
+        _gc_runtime: &dyn crate::runtime::vm::GcRuntime,
+    ) -> Result<(GcHeapAllocationIndex, Box<dyn crate::runtime::vm::GcHeap>)> {
+        unreachable!()
+    }
+
+    #[cfg(feature = "gc")]
+    fn deallocate_gc_heap(
+        &self,
+        _allocation_index: GcHeapAllocationIndex,
+        _gc_heap: Box<dyn crate::runtime::vm::GcHeap>,
+    ) {
+        unreachable!()
+    }
+}
diff --git a/crates/wasmtime/src/runtime/trampoline/table.rs b/crates/wasmtime/src/runtime/trampoline/table.rs
new file mode 100644
index 000000000000..d96d6a2950bf
--- /dev/null
+++ b/crates/wasmtime/src/runtime/trampoline/table.rs
@@ -0,0 +1,28 @@
+use crate::prelude::*;
+use crate::store::{InstanceId, StoreOpaque};
+use crate::trampoline::create_handle;
+use crate::TableType;
+use wasmtime_environ::{EntityIndex, Module, TypeTrace};
+
+pub fn create_table(store: &mut StoreOpaque, table: &TableType) -> Result<InstanceId> {
+    let mut module = Module::new();
+
+    let wasmtime_table = *table.wasmtime_table();
+    let tunables = store.engine().tunables();
+
+    debug_assert!(
+        wasmtime_table.wasm_ty.is_canonicalized_for_runtime_usage(),
+        "should be canonicalized for runtime usage: {:?}",
+        wasmtime_table.wasm_ty
+    );
+
+    let table_plan = wasmtime_environ::TablePlan::for_table(wasmtime_table, tunables);
+    let table_id = module.table_plans.push(table_plan);
+
+    // TODO: can this `exports.insert` get removed?
+    module
+        .exports
+        .insert(String::new(), EntityIndex::Table(table_id));
+
+    create_handle(module, store, Box::new(()), &[], None)
+}
diff --git a/crates/wasmtime/src/trap.rs b/crates/wasmtime/src/runtime/trap.rs
similarity index 90%
rename from crates/wasmtime/src/trap.rs
rename to crates/wasmtime/src/runtime/trap.rs
index 3f8b2b0f7c49..7f159a7e18c0 100644
--- a/crates/wasmtime/src/trap.rs
+++ b/crates/wasmtime/src/runtime/trap.rs
@@ -1,10 +1,12 @@
-use crate::coredump::WasmCoreDump;
+#[cfg(feature = "coredump")]
+use super::coredump::WasmCoreDump;
+use crate::prelude::*;
 use crate::store::StoreOpaque;
 use crate::{AsContext, Module};
-use anyhow::Error;
-use std::fmt;
-use wasmtime_environ::{EntityRef, FilePos};
-use wasmtime_jit::{demangle_function_name, demangle_function_name_or_index};
+use core::fmt;
+use wasmtime_environ::{
+    demangle_function_name, demangle_function_name_or_index, EntityRef, FilePos,
+};
 
 /// Representation of a WebAssembly trap and what caused it to occur.
 ///
@@ -17,11 +19,12 @@ use wasmtime_jit::{demangle_function_name, demangle_function_name_or_index};
 ///
 /// # Errors in Wasmtime
 ///
-/// Error-handling in Wasmtime is primarily done through the [`anyhow`] crate
-/// where most results are a [`Result<T>`](anyhow::Result) which is an alias for
-/// [`Result<T, anyhow::Error>`](std::result::Result). Errors in Wasmtime are
-/// represented with [`anyhow::Error`] which acts as a container for any type of
-/// error in addition to optional context for this error. The "base" error or
+/// Error-handling in Wasmtime is primarily done through the
+/// [`anyhow`][mod@anyhow] crate where most results are a
+/// [`Result<T>`](anyhow::Result) which is an alias for [`Result<T,
+/// anyhow::Error>`](std::result::Result). Errors in Wasmtime are represented
+/// with [`anyhow::Error`] which acts as a container for any type of error in
+/// addition to optional context for this error. The "base" error or
 /// [`anyhow::Error::root_cause`] is a [`Trap`] whenever WebAssembly hits a
 /// trap, or otherwise it's whatever the host created the error with when
 /// returning an error for a host call.
@@ -38,7 +41,6 @@ use wasmtime_jit::{demangle_function_name, demangle_function_name_or_index};
 ///
 /// ```
 /// # use wasmtime::*;
-/// # use anyhow::Result;
 /// # fn main() -> Result<()> {
 /// let engine = Engine::default();
 /// let module = Module::new(
@@ -69,18 +71,18 @@ use wasmtime_jit::{demangle_function_name, demangle_function_name_or_index};
 pub use wasmtime_environ::Trap;
 
 // Same safety requirements and caveats as
-// `wasmtime_runtime::raise_user_trap`.
+// `crate::runtime::vm::raise_user_trap`.
 pub(crate) unsafe fn raise(error: anyhow::Error) -> ! {
     let needs_backtrace = error.downcast_ref::<WasmBacktrace>().is_none();
-    wasmtime_runtime::raise_user_trap(error, needs_backtrace)
+    crate::runtime::vm::raise_user_trap(error, needs_backtrace)
 }
 
 #[cold] // traps are exceptional, this helps move handling off the main path
 pub(crate) fn from_runtime_box(
     store: &mut StoreOpaque,
-    runtime_trap: Box<wasmtime_runtime::Trap>,
+    runtime_trap: Box<crate::runtime::vm::Trap>,
 ) -> Error {
-    let wasmtime_runtime::Trap {
+    let crate::runtime::vm::Trap {
         reason,
         backtrace,
         coredumpstack,
@@ -99,7 +101,7 @@ pub(crate) fn from_runtime_box(
         // provide useful information to debug with for the embedder/caller,
         // otherwise the information about what the wasm was doing when the
         // error was generated would be lost.
-        wasmtime_runtime::TrapReason::User {
+        crate::runtime::vm::TrapReason::User {
             error,
             needs_backtrace,
         } => {
@@ -108,12 +110,12 @@ pub(crate) fn from_runtime_box(
             );
             (error, None)
         }
-        wasmtime_runtime::TrapReason::Jit { pc, faulting_addr } => {
-            let code = store
-                .modules()
-                .lookup_trap_code(pc)
-                .unwrap_or(Trap::StackOverflow);
-            let mut err: Error = code.into();
+        crate::runtime::vm::TrapReason::Jit {
+            pc,
+            faulting_addr,
+            trap,
+        } => {
+            let mut err: Error = trap.into_anyhow();
 
             // If a fault address was present, for example with segfaults,
             // then simultaneously assert that it's within a known linear memory
@@ -124,7 +126,7 @@ pub(crate) fn from_runtime_box(
             }
             (err, Some(pc))
         }
-        wasmtime_runtime::TrapReason::Wasm(trap_code) => (trap_code.into(), None),
+        crate::runtime::vm::TrapReason::Wasm(trap_code) => (trap_code.into_anyhow(), None),
     };
 
     if let Some(bt) = backtrace {
@@ -134,11 +136,14 @@ pub(crate) fn from_runtime_box(
         }
     }
 
+    let _ = &coredumpstack;
+    #[cfg(feature = "coredump")]
     if let Some(coredump) = coredumpstack {
         let bt = WasmBacktrace::from_captured(store, coredump.bt, pc);
         let cd = WasmCoreDump::new(store, bt);
         error = error.context(cd);
     }
+
     error
 }
 
@@ -165,7 +170,6 @@ pub(crate) fn from_runtime_box(
 ///
 /// ```
 /// # use wasmtime::*;
-/// # use anyhow::Result;
 /// # fn main() -> Result<()> {
 /// let engine = Engine::default();
 /// let module = Module::new(
@@ -198,7 +202,7 @@ pub struct WasmBacktrace {
     // This is currently only present for the `Debug` implementation for extra
     // context.
     #[allow(dead_code)]
-    runtime_trace: wasmtime_runtime::Backtrace,
+    runtime_trace: crate::runtime::vm::Backtrace,
 }
 
 impl WasmBacktrace {
@@ -225,7 +229,6 @@ impl WasmBacktrace {
     ///
     /// ```
     /// # use wasmtime::*;
-    /// # use anyhow::Result;
     /// # fn main() -> Result<()> {
     /// let engine = Engine::default();
     /// let module = Module::new(
@@ -258,7 +261,7 @@ impl WasmBacktrace {
             WasmBacktrace {
                 wasm_trace: Vec::new(),
                 hint_wasm_backtrace_details_env: false,
-                runtime_trace: wasmtime_runtime::Backtrace::empty(),
+                runtime_trace: crate::runtime::vm::Backtrace::empty(),
             }
         }
     }
@@ -273,14 +276,14 @@ impl WasmBacktrace {
         let store = store.as_context();
         Self::from_captured(
             store.0,
-            wasmtime_runtime::Backtrace::new(store.0.runtime_limits()),
+            crate::runtime::vm::Backtrace::new(store.0.runtime_limits()),
             None,
         )
     }
 
     fn from_captured(
         store: &StoreOpaque,
-        runtime_trace: wasmtime_runtime::Backtrace,
+        runtime_trace: crate::runtime::vm::Backtrace,
         trap_pc: Option<usize>,
     ) -> Self {
         let mut wasm_trace = Vec::<FrameInfo>::with_capacity(runtime_trace.frames().len());
@@ -308,7 +311,7 @@ impl WasmBacktrace {
             };
 
             // NB: The PC we are looking up _must_ be a Wasm PC since
-            // `wasmtime_runtime::Backtrace` only contains Wasm frames.
+            // `crate::runtime::vm::Backtrace` only contains Wasm frames.
             //
             // However, consider the case where we have multiple, nested calls
             // across stores (with host code in between, by necessity, since
@@ -324,13 +327,13 @@ impl WasmBacktrace {
             //     | Wasm in store B |  V
             //     +-----------------+
             //
-            // In this scenario, the `wasmtime_runtime::Backtrace` will contain
-            // two frames: Wasm in store B followed by Wasm in store A. But
-            // `store.modules()` will only have the module information for
-            // modules instantiated within this store. Therefore, we use `if let
-            // Some(..)` instead of the `unwrap` you might otherwise expect and
-            // we ignore frames from modules that were not registered in this
-            // store's module registry.
+            // In this scenario, the `crate::runtime::vm::Backtrace` will
+            // contain two frames: Wasm in store B followed by Wasm in store
+            // A. But `store.modules()` will only have the module information
+            // for modules instantiated within this store. Therefore, we use `if
+            // let Some(..)` instead of the `unwrap` you might otherwise expect
+            // and we ignore frames from modules that were not registered in
+            // this store's module registry.
             if let Some((info, module)) = store.modules().lookup_frame_info(pc_to_lookup) {
                 wasm_trace.push(info);
 
@@ -374,17 +377,17 @@ impl fmt::Display for WasmBacktrace {
                 needs_newline = true;
             }
             let name = frame.module().name().unwrap_or("<unknown>");
-            write!(f, "  {:>3}: ", i)?;
+            write!(f, "  {i:>3}: ")?;
 
             if let Some(offset) = frame.module_offset() {
-                write!(f, "{:#6x} - ", offset)?;
+                write!(f, "{offset:#6x} - ")?;
             }
 
             let write_raw_func_name = |f: &mut fmt::Formatter<'_>| {
                 demangle_function_name_or_index(f, frame.func_name(), frame.func_index() as usize)
             };
             if frame.symbols().is_empty() {
-                write!(f, "{}!", name)?;
+                write!(f, "{name}!")?;
                 write_raw_func_name(f)?;
             } else {
                 for (i, symbol) in frame.symbols().iter().enumerate() {
@@ -400,11 +403,11 @@ impl fmt::Display for WasmBacktrace {
                     }
                     if let Some(file) = symbol.file() {
                         writeln!(f, "")?;
-                        write!(f, "                    at {}", file)?;
+                        write!(f, "                    at {file}")?;
                         if let Some(line) = symbol.line() {
-                            write!(f, ":{}", line)?;
+                            write!(f, ":{line}")?;
                             if let Some(col) = symbol.column() {
-                                write!(f, ":{}", col)?;
+                                write!(f, ":{col}")?;
                             }
                         }
                     }
@@ -460,8 +463,7 @@ impl FrameInfo {
         // compilation settings then it's expected that `instr` is `None`.
         debug_assert!(
             instr.is_some() || !compiled_module.has_address_map(),
-            "failed to find instruction for {:#x}",
-            text_offset
+            "failed to find instruction for {text_offset:#x}"
         );
 
         // Use our wasm-relative pc to symbolize this frame. If there's a
@@ -474,6 +476,8 @@ impl FrameInfo {
         // custom section contents.
         let mut symbols = Vec::new();
 
+        let _ = &mut symbols;
+        #[cfg(feature = "addr2line")]
         if let Some(s) = &compiled_module.symbolize_context().ok().and_then(|c| c) {
             if let Some(offset) = instr.and_then(|i| i.file_offset()) {
                 let to_lookup = u64::from(offset) - s.code_section_offset();
diff --git a/crates/wasmtime/src/runtime/type_registry.rs b/crates/wasmtime/src/runtime/type_registry.rs
new file mode 100644
index 000000000000..1a4b63eedf5b
--- /dev/null
+++ b/crates/wasmtime/src/runtime/type_registry.rs
@@ -0,0 +1,1099 @@
+//! Implement a registry of types: function, struct, and array definitions.
+//!
+//! Helps implement fast indirect call signature checking, reference type
+//! downcasting, and etc...
+
+use crate::prelude::*;
+use crate::sync::RwLock;
+use crate::vm::{GcLayout, GcRuntime};
+use crate::Engine;
+use alloc::borrow::Cow;
+use alloc::sync::Arc;
+use core::iter;
+use core::{
+    borrow::Borrow,
+    fmt::{self, Debug},
+    hash::{Hash, Hasher},
+    ops::Range,
+    sync::atomic::{
+        AtomicUsize,
+        Ordering::{AcqRel, Acquire},
+    },
+};
+use hashbrown::HashSet;
+use wasmtime_environ::{
+    iter_entity_range, packed_option::PackedOption, EngineOrModuleTypeIndex,
+    ModuleInternedTypeIndex, ModuleTypes, PrimaryMap, SecondaryMap, TypeTrace, VMSharedTypeIndex,
+    WasmRecGroup, WasmSubType,
+};
+use wasmtime_slab::{Id as SlabId, Slab};
+
+// ### Notes on the Lifetime Management of Types
+//
+// All defined types from all Wasm modules loaded into Wasmtime are interned
+// into their engine's `TypeRegistry`.
+//
+// With Wasm MVP, managing type lifetimes within the registry was easy: we only
+// cared about canonicalizing types so that `call_indirect` was fast and we
+// didn't waste memory on many copies of the same function type definition.
+// Function types could only take and return simple scalars (i32/f64/etc...) and
+// there were no type-to-type references. We could simply deduplicate function
+// types and reference count their entries in the registry.
+//
+// The typed function references and GC proposals change everything. The former
+// introduced function types that take a reference to a function of another
+// specific type. This is a type-to-type reference. The latter introduces struct
+// and array types that can have references to other struct, array, and function
+// types, as well as recursion groups that allow cyclic references between
+// types. Now type canonicalization additionally enables fast type checks and
+// downcasts *across* modules: so that two modules which define the same struct
+// type, for example, can pass instances of that struct type to each other, and
+// we can quickly check that those instances are in fact of the expected types.
+//
+// But how do we manage the lifetimes of types that can reference other types as
+// Wasm modules are dynamically loaded and unloaded from the engine? These
+// modules can define subsets of the same types and there can be cyclic type
+// references. Dynamic lifetimes, sharing, and cycles is a classic combination
+// of constraints that push a design towards a tracing garbage collector (or,
+// equivalently, a reference-counting collector with a cycle collector).
+//
+// However, we can rely on the following properties:
+//
+// 1. The unit of type canonicalization is a whole recursion group.
+//
+// 2. Type-to-type reference cycles may only happen within a recursion group and
+//    therefore type-to-type references across recursion groups are acyclic.
+//
+// Therefore, our type registry makes the following design decisions:
+//
+// * We manage the lifetime of whole recursion groups, not individual
+//   types. That is, every type in the recursion group stays alive as long as
+//   any type in the recursion group is kept alive. This is effectively mandated
+//   by property (1) and the hash consing it implies.
+//
+// * We still use naive reference counting to manage the lifetimes of recursion
+//   groups. A type-to-type reference that crosses the boundary from recursion
+//   group A to recursion group B will increment B's reference count when A is
+//   first registered and decrement B's reference count when A is removed from
+//   the registry. Because of property (2) we don't need to worry about cycles,
+//   which are the classic weakness of reference counting.
+
+/// Represents a collection of shared types.
+///
+/// This is used to register shared types with a shared type registry.
+///
+/// The collection will unregister any contained types with the registry
+/// when dropped.
+pub struct TypeCollection {
+    engine: Engine,
+    rec_groups: Vec<RecGroupEntry>,
+    types: PrimaryMap<ModuleInternedTypeIndex, VMSharedTypeIndex>,
+    trampolines: SecondaryMap<VMSharedTypeIndex, PackedOption<ModuleInternedTypeIndex>>,
+}
+
+impl Debug for TypeCollection {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let TypeCollection {
+            engine: _,
+            rec_groups,
+            types,
+            trampolines,
+        } = self;
+        f.debug_struct("TypeCollection")
+            .field("rec_groups", rec_groups)
+            .field("types", types)
+            .field("trampolines", trampolines)
+            .finish_non_exhaustive()
+    }
+}
+
+impl TypeCollection {
+    /// Creates a type collection for a module given the module's types.
+    pub fn new_for_module(engine: &Engine, module_types: &ModuleTypes) -> Self {
+        let engine = engine.clone();
+        let registry = engine.signatures();
+        let gc_runtime = engine.gc_runtime();
+        let (rec_groups, types) = registry
+            .0
+            .write()
+            .register_module_types(&**gc_runtime, module_types);
+
+        let mut trampolines = SecondaryMap::with_capacity(types.len());
+        for (module_ty, trampoline) in module_types.trampoline_types() {
+            let shared_ty = types[module_ty];
+            let trampoline_ty = registry.trampoline_type(shared_ty);
+            trampolines[trampoline_ty] = Some(trampoline).into();
+        }
+
+        Self {
+            engine,
+            rec_groups,
+            types,
+            trampolines,
+        }
+    }
+
+    /// Treats the type collection as a map from a module type index to
+    /// registered shared type indexes.
+    ///
+    /// This is used for looking up module shared type indexes during module
+    /// instantiation.
+    pub fn as_module_map(&self) -> &PrimaryMap<ModuleInternedTypeIndex, VMSharedTypeIndex> {
+        &self.types
+    }
+
+    /// Gets the shared type index given a module type index.
+    #[inline]
+    pub fn shared_type(&self, index: ModuleInternedTypeIndex) -> Option<VMSharedTypeIndex> {
+        self.types.get(index).copied()
+    }
+
+    /// Get the module-level type index of the trampoline type for the given
+    /// engine-level function type, if any.
+    ///
+    /// This allows callers to look up the pre-compiled wasm-to-native
+    /// trampoline in this type collection's associated module.
+    ///
+    /// See the docs for `WasmFuncType::trampoline_type` for details on
+    /// trampoline types.
+    #[inline]
+    pub fn trampoline_type(&self, ty: VMSharedTypeIndex) -> Option<ModuleInternedTypeIndex> {
+        let trampoline_ty = self.trampolines[ty].expand();
+        log::trace!("TypeCollection::trampoline_type({ty:?}) -> {trampoline_ty:?}");
+        trampoline_ty
+    }
+}
+
+impl Drop for TypeCollection {
+    fn drop(&mut self) {
+        if !self.rec_groups.is_empty() {
+            self.engine
+                .signatures()
+                .0
+                .write()
+                .unregister_type_collection(self);
+        }
+    }
+}
+
+#[inline]
+fn shared_type_index_to_slab_id(index: VMSharedTypeIndex) -> SlabId {
+    SlabId::from_raw(index.bits())
+}
+
+#[inline]
+fn slab_id_to_shared_type_index(id: SlabId) -> VMSharedTypeIndex {
+    VMSharedTypeIndex::new(id.into_raw())
+}
+
+/// A Wasm type that has been registered in the engine's `TypeRegistry`.
+///
+/// Prevents its associated type from being unregistered while it is alive.
+///
+/// Automatically unregisters the type on drop. (Unless other `RegisteredTypes`
+/// are keeping the type registered).
+///
+/// Dereferences to its underlying `WasmSubType`.
+pub struct RegisteredType {
+    engine: Engine,
+    entry: RecGroupEntry,
+    ty: Arc<WasmSubType>,
+    index: VMSharedTypeIndex,
+    layout: Option<GcLayout>,
+}
+
+impl Debug for RegisteredType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let RegisteredType {
+            engine: _,
+            entry: _,
+            ty,
+            index,
+            layout,
+        } = self;
+        f.debug_struct("RegisteredType")
+            .field("index", index)
+            .field("ty", ty)
+            .field("layout", layout)
+            .finish_non_exhaustive()
+    }
+}
+
+impl Clone for RegisteredType {
+    fn clone(&self) -> Self {
+        self.entry.incref("cloning RegisteredType");
+        RegisteredType {
+            engine: self.engine.clone(),
+            entry: self.entry.clone(),
+            ty: self.ty.clone(),
+            index: self.index,
+            layout: self.layout.clone(),
+        }
+    }
+}
+
+impl Drop for RegisteredType {
+    fn drop(&mut self) {
+        if self.entry.decref("dropping RegisteredType") {
+            self.engine
+                .signatures()
+                .0
+                .write()
+                .unregister_entry(self.entry.clone());
+        }
+    }
+}
+
+impl core::ops::Deref for RegisteredType {
+    type Target = WasmSubType;
+
+    fn deref(&self) -> &Self::Target {
+        &self.ty
+    }
+}
+
+impl PartialEq for RegisteredType {
+    fn eq(&self, other: &Self) -> bool {
+        let eq = Arc::ptr_eq(&self.entry.0, &other.entry.0);
+
+        if cfg!(debug_assertions) {
+            if eq {
+                assert!(Engine::same(&self.engine, &other.engine));
+                assert_eq!(self.ty, other.ty);
+            } else {
+                assert!(self.ty != other.ty || !Engine::same(&self.engine, &other.engine));
+            }
+        }
+
+        eq
+    }
+}
+
+impl Eq for RegisteredType {}
+
+impl Hash for RegisteredType {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        let ptr = Arc::as_ptr(&self.entry.0);
+        ptr.hash(state);
+    }
+}
+
+impl RegisteredType {
+    /// Constructs a new `RegisteredType`, registering the given type with the
+    /// engine's `TypeRegistry`.
+    pub fn new(engine: &Engine, ty: WasmSubType) -> RegisteredType {
+        let (entry, index, ty, layout) = {
+            log::trace!("RegisteredType::new({ty:?})");
+
+            let gc_runtime = engine.gc_runtime();
+            let mut inner = engine.signatures().0.write();
+
+            // It shouldn't be possible for users to construct non-canonical
+            // types via the embedding API, and the only other types they can
+            // get are already-canonicalized types from modules, so we shouldn't
+            // ever get non-canonical types here. Furthermore, this is only
+            // called internally to Wasmtime, so we shouldn't ever have an
+            // engine mismatch; those should be caught earlier.
+            inner.assert_canonicalized_for_runtime_usage_in_this_registry(&ty);
+
+            let entry = inner.register_singleton_rec_group(&**gc_runtime, ty);
+
+            let index = entry.0.shared_type_indices[0];
+            let id = shared_type_index_to_slab_id(index);
+            let ty = inner.types[id].clone();
+            let layout = inner.type_to_gc_layout.get(index).and_then(|l| l.clone());
+
+            (entry, index, ty, layout)
+        };
+
+        RegisteredType::from_parts(engine.clone(), entry, index, ty, layout)
+    }
+
+    /// Create an owning handle to the given index's associated type.
+    ///
+    /// This will prevent the associated type from being unregistered as long as
+    /// the returned `RegisteredType` is kept alive.
+    ///
+    /// Returns `None` if `index` is not registered in the given engine's
+    /// registry.
+    pub fn root(engine: &Engine, index: VMSharedTypeIndex) -> Option<RegisteredType> {
+        let (entry, ty, layout) = {
+            let id = shared_type_index_to_slab_id(index);
+            let inner = engine.signatures().0.read();
+
+            let ty = inner.types.get(id)?.clone();
+            let entry = inner.type_to_rec_group[index].clone().unwrap();
+            let layout = inner.type_to_gc_layout.get(index).and_then(|l| l.clone());
+
+            // NB: make sure to incref while the lock is held to prevent:
+            //
+            // * This thread: read locks registry, gets entry E, unlocks registry
+            // * Other thread: drops `RegisteredType` for entry E, decref
+            //   reaches zero, write locks registry, unregisters entry
+            // * This thread: increfs entry, but it isn't in the registry anymore
+            entry.incref("RegisteredType::root");
+
+            (entry, ty, layout)
+        };
+
+        Some(RegisteredType::from_parts(
+            engine.clone(),
+            entry,
+            index,
+            ty,
+            layout,
+        ))
+    }
+
+    /// Construct a new `RegisteredType`.
+    ///
+    /// It is the caller's responsibility to ensure that the entry's reference
+    /// count has already been incremented.
+    fn from_parts(
+        engine: Engine,
+        entry: RecGroupEntry,
+        index: VMSharedTypeIndex,
+        ty: Arc<WasmSubType>,
+        layout: Option<GcLayout>,
+    ) -> Self {
+        debug_assert!(entry.0.registrations.load(Acquire) != 0);
+        RegisteredType {
+            engine,
+            entry,
+            ty,
+            index,
+            layout,
+        }
+    }
+
+    /// Get the engine whose registry this type is registered within.
+    pub fn engine(&self) -> &Engine {
+        &self.engine
+    }
+
+    /// Get this registered type's index.
+    pub fn index(&self) -> VMSharedTypeIndex {
+        self.index
+    }
+
+    /// Get this registered type's GC layout, if any.
+    ///
+    /// Only struct and array types have GC layouts; function types do not have
+    /// layouts.
+    pub fn layout(&self) -> Option<&GcLayout> {
+        self.layout.as_ref()
+    }
+}
+
+/// An entry in the type registry.
+///
+/// Implements `Borrow`, `Eq`, and `Hash` by forwarding to the underlying Wasm
+/// rec group, so that this can be a hash consing key. (We can't use
+/// `Arc<RecGroupEntryInner>` directly for this purpose because `Arc<T>` doesn't
+/// implement `Borrow<U>` when `T: Borrow<U>`).
+#[derive(Clone)]
+struct RecGroupEntry(Arc<RecGroupEntryInner>);
+
+impl Debug for RecGroupEntry {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        struct Ptr<'a, P>(&'a P);
+        impl<P: fmt::Pointer> Debug for Ptr<'_, P> {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                write!(f, "{:#p}", *self.0)
+            }
+        }
+
+        f.debug_struct("RecGroupEntry")
+            .field("ptr", &Ptr(&self.0))
+            .field("shared_type_indices", &self.0.shared_type_indices)
+            .field("hash_consing_key", &self.0.hash_consing_key)
+            .field("registrations", &self.0.registrations.load(Acquire))
+            .finish()
+    }
+}
+
+struct RecGroupEntryInner {
+    /// The Wasm rec group, canonicalized for hash consing.
+    hash_consing_key: WasmRecGroup,
+    shared_type_indices: Box<[VMSharedTypeIndex]>,
+    registrations: AtomicUsize,
+}
+
+impl PartialEq for RecGroupEntry {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.hash_consing_key == other.0.hash_consing_key
+    }
+}
+
+impl Eq for RecGroupEntry {}
+
+impl Hash for RecGroupEntry {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.0.hash_consing_key.hash(state);
+    }
+}
+
+impl Borrow<WasmRecGroup> for RecGroupEntry {
+    fn borrow(&self) -> &WasmRecGroup {
+        &self.0.hash_consing_key
+    }
+}
+
+impl RecGroupEntry {
+    /// Increment the registration count.
+    fn incref(&self, why: &str) {
+        let old_count = self.0.registrations.fetch_add(1, AcqRel);
+        log::trace!(
+            "increment registration count for {self:?} (registrations -> {}): {why}",
+            old_count + 1
+        );
+    }
+
+    /// Decrement the registration count and return `true` if the registration
+    /// count reached zero and this entry should be removed from the registry.
+    #[must_use = "caller must remove entry from registry if `decref` returns `true`"]
+    fn decref(&self, why: &str) -> bool {
+        let old_count = self.0.registrations.fetch_sub(1, AcqRel);
+        debug_assert_ne!(old_count, 0);
+        log::trace!(
+            "decrement registration count for {self:?} (registrations -> {}): {why}",
+            old_count - 1
+        );
+        old_count == 1
+    }
+}
+
+#[derive(Debug, Default)]
+struct TypeRegistryInner {
+    // A hash map from a canonicalized-for-hash-consing rec group to its
+    // `VMSharedTypeIndex`es.
+    //
+    // There is an entry in this map for every rec group we have already
+    // registered. Before registering new rec groups, we first check this map to
+    // see if we've already registered an identical rec group that we should
+    // reuse instead.
+    hash_consing_map: HashSet<RecGroupEntry>,
+
+    // A map from `VMSharedTypeIndex::bits()` to the type index's associated
+    // Wasm type.
+    //
+    // These types are always canonicalized for runtime usage.
+    types: Slab<Arc<WasmSubType>>,
+
+    // A map that lets you walk backwards from a `VMSharedTypeIndex` to its
+    // `RecGroupEntry`.
+    type_to_rec_group: SecondaryMap<VMSharedTypeIndex, Option<RecGroupEntry>>,
+
+    // A map from a registered type to its complete list of supertypes.
+    //
+    // The supertypes are ordered from super- to subtype, i.e. the immediate
+    // parent supertype is the last element and the least-upper-bound of all
+    // supertypes is the first element.
+    //
+    // Types without any supertypes are omitted from this map. This means that
+    // we never allocate any backing storage for this map when Wasm GC is not in
+    // use.
+    type_to_supertypes: SecondaryMap<VMSharedTypeIndex, Option<Box<[VMSharedTypeIndex]>>>,
+
+    // A map from each registered function type to its trampoline type.
+    //
+    // Note that when a function type is its own trampoline type, then we omit
+    // the entry in this map as a memory optimization. This means that if only
+    // core Wasm function types are ever used, then we will never allocate any
+    // backing storage for this map. As a nice bonus, this also avoids cycles (a
+    // function type referencing itself) that our naive reference counting
+    // doesn't play well with.
+    type_to_trampoline: SecondaryMap<VMSharedTypeIndex, PackedOption<VMSharedTypeIndex>>,
+
+    // A map from each registered GC type to its layout.
+    //
+    // Function types do not have an entry in this map. Similar to the
+    // `type_to_{supertypes,trampoline}` maps, we completely omit the `None`
+    // entries for these types as a memory optimization.
+    type_to_gc_layout: SecondaryMap<VMSharedTypeIndex, Option<GcLayout>>,
+
+    // An explicit stack of entries that we are in the middle of dropping. Used
+    // to avoid recursion when dropping a type that is holding the last
+    // reference to another type, etc...
+    drop_stack: Vec<RecGroupEntry>,
+}
+
+impl TypeRegistryInner {
+    fn register_module_types(
+        &mut self,
+        gc_runtime: &dyn GcRuntime,
+        types: &ModuleTypes,
+    ) -> (
+        Vec<RecGroupEntry>,
+        PrimaryMap<ModuleInternedTypeIndex, VMSharedTypeIndex>,
+    ) {
+        log::trace!("Start registering module types");
+
+        let mut entries = Vec::with_capacity(types.rec_groups().len());
+        let mut map = PrimaryMap::<ModuleInternedTypeIndex, VMSharedTypeIndex>::with_capacity(
+            types.wasm_types().len(),
+        );
+
+        for (_rec_group_index, module_group) in types.rec_groups() {
+            let entry = self.register_rec_group(
+                gc_runtime,
+                &map,
+                module_group.clone(),
+                iter_entity_range(module_group.clone()).map(|ty| types[ty].clone()),
+            );
+
+            for (module_ty, engine_ty) in
+                iter_entity_range(module_group).zip(entry.0.shared_type_indices.iter())
+            {
+                let module_ty2 = map.push(*engine_ty);
+                assert_eq!(module_ty, module_ty2);
+            }
+
+            entries.push(entry);
+        }
+
+        log::trace!("End registering module types");
+
+        (entries, map)
+    }
+
+    /// Register a rec group in this registry.
+    ///
+    /// The rec group may be either module-level canonical (i.e. straight from
+    /// `wasmparser`) or engine-level canonicalized for runtime usage in this
+    /// registry. It may *not* be engine-level canonicalized for hash consing or
+    /// engine-level canonicalized for a different type registry instance.
+    ///
+    /// If this rec group is determined to be a duplicate of an
+    /// already-registered rec group, the existing rec group is reused.
+    ///
+    /// Parameters:
+    ///
+    /// * `map`: A map that we use to canonicalize inter-group type references
+    ///   from module-canonical to engine-canonical indices. This must contain
+    ///   entries for each inter-group type reference that this rec group
+    ///   contains.
+    ///
+    /// * `range`: The range of (module-level) types defined by this rec
+    ///   group. This is used to determine which type references inside this rec
+    ///   group are inter- vs intra-group.
+    ///
+    /// * `types`: The types defined within this rec group. Must have the same
+    ///   length as `range`.
+    ///
+    /// The returned entry will have already had its reference count incremented
+    /// on behalf of callers.
+    fn register_rec_group(
+        &mut self,
+        gc_runtime: &dyn GcRuntime,
+        map: &PrimaryMap<ModuleInternedTypeIndex, VMSharedTypeIndex>,
+        range: Range<ModuleInternedTypeIndex>,
+        types: impl ExactSizeIterator<Item = WasmSubType>,
+    ) -> RecGroupEntry {
+        debug_assert_eq!(iter_entity_range(range.clone()).len(), types.len());
+
+        let mut non_canon_types = Vec::with_capacity(types.len());
+        let hash_consing_key = WasmRecGroup {
+            types: types
+                .zip(iter_entity_range(range.clone()))
+                .map(|(mut ty, module_index)| {
+                    non_canon_types.push((module_index, ty.clone()));
+                    ty.canonicalize_for_hash_consing(range.clone(), &mut |idx| {
+                        debug_assert!(idx < range.clone().start);
+                        map[idx]
+                    });
+                    ty
+                })
+                .collect::<Box<[_]>>(),
+        };
+
+        // If we've already registered this rec group before, reuse it.
+        if let Some(entry) = self.hash_consing_map.get(&hash_consing_key) {
+            entry.incref(
+                "hash consed to already-registered type in `TypeRegistryInner::register_rec_group`",
+            );
+            return entry.clone();
+        }
+
+        // Inter-group edges: increment the referenced group's ref
+        // count, because these other rec groups shouldn't be dropped
+        // while this rec group is still alive.
+        hash_consing_key
+            .trace_engine_indices::<_, ()>(&mut |index| {
+                let entry = &self.type_to_rec_group[index].as_ref().unwrap();
+                entry.incref(
+                    "new cross-group type reference to existing type in `register_rec_group`",
+                );
+                Ok(())
+            })
+            .unwrap();
+
+        // Register the individual types.
+        //
+        // Note that we can't update the reverse type-to-rec-group map until
+        // after we've constructed the `RecGroupEntry`, since that map needs to
+        // the fully-constructed entry for its values.
+        let module_rec_group_start = range.start;
+        let engine_rec_group_start = u32::try_from(self.types.len()).unwrap();
+        let shared_type_indices: Box<[_]> = non_canon_types
+            .into_iter()
+            .map(|(module_index, mut ty)| {
+                ty.canonicalize_for_runtime_usage(&mut |idx| {
+                    if idx < module_rec_group_start {
+                        map[idx]
+                    } else {
+                        let rec_group_offset = idx.as_u32() - module_rec_group_start.as_u32();
+                        VMSharedTypeIndex::from_u32(engine_rec_group_start + rec_group_offset)
+                    }
+                });
+                self.insert_one_type_from_rec_group(gc_runtime, module_index, ty)
+            })
+            .collect();
+
+        let entry = RecGroupEntry(Arc::new(RecGroupEntryInner {
+            hash_consing_key,
+            shared_type_indices,
+            registrations: AtomicUsize::new(1),
+        }));
+        log::trace!("create new entry {entry:?} (registrations -> 1)");
+
+        let is_new_entry = self.hash_consing_map.insert(entry.clone());
+        debug_assert!(is_new_entry);
+
+        // Now that we've constructed the entry, we can update the reverse
+        // type-to-rec-group map.
+        for ty in entry.0.shared_type_indices.iter().copied() {
+            debug_assert!(self.type_to_rec_group[ty].is_none());
+            self.type_to_rec_group[ty] = Some(entry.clone());
+        }
+
+        // Finally, make sure to register the trampoline type for each function
+        // type in the rec group.
+        for shared_type_index in entry.0.shared_type_indices.iter().copied() {
+            let slab_id = shared_type_index_to_slab_id(shared_type_index);
+            if let Some(f) = self.types[slab_id].as_func() {
+                match f.trampoline_type() {
+                    Cow::Borrowed(_) => {
+                        // The function type is its own trampoline type. Leave
+                        // its entry in `type_to_trampoline` empty to signal
+                        // this.
+                    }
+                    Cow::Owned(trampoline) => {
+                        // This will recursively call into rec group
+                        // registration, but at most once since trampoline
+                        // function types are their own trampoline type.
+                        let trampoline_entry = self.register_singleton_rec_group(
+                            gc_runtime,
+                            WasmSubType {
+                                is_final: true,
+                                supertype: None,
+                                composite_type: wasmtime_environ::WasmCompositeType::Func(
+                                    trampoline,
+                                ),
+                            },
+                        );
+                        let trampoline_index = trampoline_entry.0.shared_type_indices[0];
+                        log::trace!(
+                            "Registering trampoline {trampoline_index:?} for function type {shared_type_index:?}"
+                        );
+                        debug_assert_ne!(shared_type_index, trampoline_index);
+                        self.type_to_trampoline[shared_type_index] = Some(trampoline_index).into();
+                    }
+                }
+            }
+        }
+
+        entry
+    }
+
+    /// Is the given type canonicalized for runtime usage this registry?
+    fn assert_canonicalized_for_runtime_usage_in_this_registry(&self, ty: &WasmSubType) {
+        ty.trace::<_, ()>(&mut |index| match index {
+            EngineOrModuleTypeIndex::RecGroup(_) | EngineOrModuleTypeIndex::Module(_) => {
+                panic!("not canonicalized for runtime usage: {ty:?}")
+            }
+            EngineOrModuleTypeIndex::Engine(idx) => {
+                let id = shared_type_index_to_slab_id(idx);
+                assert!(
+                    self.types.contains(id),
+                    "canonicalized in a different engine? {ty:?}"
+                );
+                Ok(())
+            }
+        })
+        .unwrap();
+    }
+
+    /// Insert a new type as part of registering a new rec group.
+    ///
+    /// The type must be canonicalized for runtime usage in this registry and
+    /// its rec group must be a new one that we are currently registering, not
+    /// an already-registered rec group.
+    fn insert_one_type_from_rec_group(
+        &mut self,
+        gc_runtime: &dyn GcRuntime,
+        module_index: ModuleInternedTypeIndex,
+        ty: WasmSubType,
+    ) -> VMSharedTypeIndex {
+        // Despite being canonicalized for runtime usage, this type may still
+        // have forward references to other types in the rec group we haven't
+        // yet registered. Therefore, we can't use our usual
+        // `assert_canonicalized_for_runtime_usage_in_this_registry` helper here
+        // as that will see the forward references and think they must be
+        // references to types in other registries.
+        assert!(
+            ty.is_canonicalized_for_runtime_usage(),
+            "type is not canonicalized for runtime usage: {ty:?}"
+        );
+
+        let gc_layout = match &ty.composite_type {
+            wasmtime_environ::WasmCompositeType::Func(_) => None,
+            wasmtime_environ::WasmCompositeType::Array(a) => {
+                Some(gc_runtime.array_layout(a).into())
+            }
+            wasmtime_environ::WasmCompositeType::Struct(s) => {
+                Some(gc_runtime.struct_layout(s).into())
+            }
+        };
+
+        // Add the type to our slab.
+        let id = self.types.alloc(Arc::new(ty));
+        let engine_index = slab_id_to_shared_type_index(id);
+        log::trace!(
+            "registered type {module_index:?} as {engine_index:?} = {:?}",
+            &self.types[id]
+        );
+
+        // Create the supertypes list for this type.
+        if let Some(supertype) = self.types[id].supertype {
+            let supertype = supertype.unwrap_engine_type_index();
+            let supers_supertypes = self.supertypes(supertype);
+            let mut supertypes = Vec::with_capacity(supers_supertypes.len() + 1);
+            supertypes.extend(
+                supers_supertypes
+                    .iter()
+                    .copied()
+                    .chain(iter::once(supertype)),
+            );
+            self.type_to_supertypes[engine_index] = Some(supertypes.into_boxed_slice());
+        }
+
+        // Only write the type-to-gc-layout entry if we have a GC layout, so
+        // that the map can avoid any heap allocation for backing storage in the
+        // case where Wasm GC is disabled.
+        if let Some(layout) = gc_layout {
+            self.type_to_gc_layout[engine_index] = Some(layout);
+        }
+
+        engine_index
+    }
+
+    /// Get the supertypes list for the given type.
+    ///
+    /// The supertypes are listed in super-to-sub order. `ty` itself is not
+    /// included in the list.
+    fn supertypes(&self, ty: VMSharedTypeIndex) -> &[VMSharedTypeIndex] {
+        self.type_to_supertypes
+            .get(ty)
+            .and_then(|s| s.as_deref())
+            .unwrap_or(&[])
+    }
+
+    /// Register a rec group consisting of a single type.
+    ///
+    /// The type must already be canonicalized for runtime usage in this
+    /// registry.
+    ///
+    /// The returned entry will have already had its reference count incremented
+    /// on behalf of callers.
+    fn register_singleton_rec_group(
+        &mut self,
+        gc_runtime: &dyn GcRuntime,
+        ty: WasmSubType,
+    ) -> RecGroupEntry {
+        self.assert_canonicalized_for_runtime_usage_in_this_registry(&ty);
+
+        // This type doesn't have any module-level type references, since it is
+        // already canonicalized for runtime usage in this registry, so an empty
+        // map suffices.
+        let map = PrimaryMap::default();
+
+        // This must have `range.len() == 1`, even though we know this type
+        // doesn't have any intra-group type references, to satisfy
+        // `register_rec_group`'s preconditions.
+        let range = ModuleInternedTypeIndex::from_bits(u32::MAX - 1)
+            ..ModuleInternedTypeIndex::from_bits(u32::MAX);
+
+        self.register_rec_group(gc_runtime, &map, range, iter::once(ty))
+    }
+
+    /// Unregister all of a type collection's rec groups.
+    fn unregister_type_collection(&mut self, collection: &TypeCollection) {
+        for entry in &collection.rec_groups {
+            if entry.decref("TypeRegistryInner::unregister_type_collection") {
+                self.unregister_entry(entry.clone());
+            }
+        }
+    }
+
+    /// Remove a zero-refcount entry from the registry.
+    ///
+    /// This does *not* decrement the entry's registration count, it should
+    /// instead be invoked only after a previous decrement operation observed
+    /// zero remaining registrations.
+    fn unregister_entry(&mut self, entry: RecGroupEntry) {
+        debug_assert!(self.drop_stack.is_empty());
+        self.drop_stack.push(entry);
+
+        while let Some(entry) = self.drop_stack.pop() {
+            log::trace!("Start unregistering {entry:?}");
+
+            // We need to double check whether the entry is still at zero
+            // registrations: Between the time that we observed a zero and
+            // acquired the lock to call this function, another thread could
+            // have registered the type and found the 0-registrations entry in
+            // `self.map` and incremented its count.
+            //
+            // We don't need to worry about any concurrent increments during
+            // this function's invocation after we check for zero because we
+            // have exclusive access to `&mut self` and therefore no one can
+            // create a new reference to this entry and bring it back to life.
+            let registrations = entry.0.registrations.load(Acquire);
+            if registrations != 0 {
+                log::trace!(
+                    "{entry:?} was concurrently resurrected and no longer has \
+                     zero registrations (registrations -> {registrations})",
+                );
+                continue;
+            }
+
+            // Decrement any other types that this type was shallowly
+            // (i.e. non-transitively) referencing and keeping alive. If this
+            // was the last thing keeping them registered, its okay to
+            // unregister them as well now.
+            debug_assert!(entry.0.hash_consing_key.is_canonicalized_for_hash_consing());
+            entry
+                .0
+                .hash_consing_key
+                .trace_engine_indices::<_, ()>(&mut |other_index| {
+                    let other_entry = self.type_to_rec_group[other_index].as_ref().unwrap();
+                    if other_entry.decref(
+                        "referenced by dropped entry in \
+                         `TypeCollection::unregister_entry`",
+                    ) {
+                        self.drop_stack.push(other_entry.clone());
+                    }
+                    Ok(())
+                })
+                .unwrap();
+
+            // Remove the entry from the hash-consing map. If we register a
+            // duplicate definition of this rec group again in the future, it
+            // will be as if it is the first time it has ever been registered,
+            // and it will be inserted into the hash-consing map again at that
+            // time.
+            self.hash_consing_map.remove(&entry);
+
+            // Similarly, remove the rec group's types from the registry, as
+            // well as their entries from the reverse type-to-rec-group
+            // map. Additionally, stop holding a strong reference from each
+            // function type in the rec group to that function type's trampoline
+            // type.
+            for ty in entry.0.shared_type_indices.iter().copied() {
+                log::trace!("removing {ty:?} from registry");
+
+                let removed_entry = self.type_to_rec_group[ty].take();
+                debug_assert_eq!(removed_entry.unwrap(), entry);
+
+                // Remove the associated trampoline type, if any.
+                if let Some(trampoline_ty) =
+                    self.type_to_trampoline.get(ty).and_then(|x| x.expand())
+                {
+                    self.type_to_trampoline[ty] = None.into();
+                    let trampoline_entry = self.type_to_rec_group[trampoline_ty].as_ref().unwrap();
+                    if trampoline_entry
+                        .decref("removing reference from a function type to its trampoline type")
+                    {
+                        self.drop_stack.push(trampoline_entry.clone());
+                    }
+                }
+
+                // Remove the type's supertypes list, if any. Take care to guard
+                // this assignment so that we don't accidentally force the
+                // secondary map to allocate even when we never actually use
+                // Wasm GC.
+                if self.type_to_supertypes.get(ty).is_some() {
+                    self.type_to_supertypes[ty] = None;
+                }
+
+                // Same as above, but for the type's GC layout.
+                if self.type_to_gc_layout.get(ty).is_some() {
+                    self.type_to_gc_layout[ty] = None;
+                }
+
+                let id = shared_type_index_to_slab_id(ty);
+                self.types.dealloc(id);
+            }
+
+            log::trace!("End unregistering {entry:?}");
+        }
+    }
+}
+
+// `TypeRegistryInner` implements `Drop` in debug builds to assert that
+// all types have been unregistered for the registry.
+#[cfg(debug_assertions)]
+impl Drop for TypeRegistryInner {
+    fn drop(&mut self) {
+        log::trace!("Dropping type registry: {self:#?}");
+        let TypeRegistryInner {
+            hash_consing_map,
+            types,
+            type_to_rec_group,
+            type_to_supertypes,
+            type_to_trampoline,
+            type_to_gc_layout,
+            drop_stack,
+        } = self;
+        assert!(
+            hash_consing_map.is_empty(),
+            "type registry not empty: hash consing map is not empty: {hash_consing_map:#?}"
+        );
+        assert!(
+            types.is_empty(),
+            "type registry not empty: types slab is not empty: {types:#?}"
+        );
+        assert!(
+            type_to_rec_group.is_empty() || type_to_rec_group.values().all(|x| x.is_none()),
+            "type registry not empty: type-to-rec-group map is not empty: {type_to_rec_group:#?}"
+        );
+        assert!(
+            type_to_supertypes.is_empty() || type_to_supertypes.values().all(|x| x.is_none()),
+            "type registry not empty: type-to-supertypes map is not empty: {type_to_supertypes:#?}"
+        );
+        assert!(
+            type_to_trampoline.is_empty() || type_to_trampoline.values().all(|x| x.is_none()),
+            "type registry not empty: type-to-trampoline map is not empty: {type_to_trampoline:#?}"
+        );
+        assert!(
+            type_to_gc_layout.is_empty() || type_to_gc_layout.values().all(|x| x.is_none()),
+            "type registry not empty: type-to-gc-layout map is not empty: {type_to_gc_layout:#?}"
+        );
+        assert!(
+            drop_stack.is_empty(),
+            "type registry not empty: drop stack is not empty: {drop_stack:#?}"
+        );
+    }
+}
+
+/// Implements a shared type registry.
+///
+/// WebAssembly requires that the caller and callee types in an indirect
+/// call must match. To implement this efficiently, keep a registry of all
+/// types, shared by all instances, so that call sites can just do an
+/// index comparison.
+#[derive(Debug)]
+pub struct TypeRegistry(RwLock<TypeRegistryInner>);
+
+impl TypeRegistry {
+    /// Creates a new shared type registry.
+    pub fn new() -> Self {
+        Self(RwLock::new(TypeRegistryInner::default()))
+    }
+
+    /// Looks up a function type from a shared type index.
+    ///
+    /// This does *NOT* prevent the type from being unregistered while you are
+    /// still using the resulting value! Use the `RegisteredType::root`
+    /// constructor if you need to ensure that property and you don't have some
+    /// other mechanism already keeping the type registered.
+    pub fn borrow(&self, index: VMSharedTypeIndex) -> Option<Arc<WasmSubType>> {
+        let id = shared_type_index_to_slab_id(index);
+        let inner = self.0.read();
+        inner.types.get(id).cloned()
+    }
+
+    /// Get the GC layout for the given index's type.
+    ///
+    /// Returns `None` for types that do not have GC layouts (i.e. function
+    /// types).
+    pub fn layout(&self, index: VMSharedTypeIndex) -> Option<GcLayout> {
+        let inner = self.0.read();
+        inner.type_to_gc_layout.get(index).and_then(|l| l.clone())
+    }
+
+    /// Get the trampoline type for the given function type index.
+    ///
+    /// Panics for non-function type indices.
+    pub fn trampoline_type(&self, index: VMSharedTypeIndex) -> VMSharedTypeIndex {
+        let slab_id = shared_type_index_to_slab_id(index);
+        let inner = self.0.read();
+
+        let ty = &inner.types[slab_id];
+        debug_assert!(
+            ty.is_func(),
+            "cannot get the trampoline type of a non-function type: {index:?} = {ty:?}"
+        );
+
+        let trampoline_ty = match inner.type_to_trampoline.get(index).and_then(|x| x.expand()) {
+            Some(ty) => ty,
+            None => {
+                // The function type is its own trampoline type.
+                index
+            }
+        };
+        log::trace!("TypeRegistry::trampoline_type({index:?}) -> {trampoline_ty:?}");
+        trampoline_ty
+    }
+
+    /// Is type `sub` a subtype of `sup`?
+    pub fn is_subtype(&self, sub: VMSharedTypeIndex, sup: VMSharedTypeIndex) -> bool {
+        if sub == sup {
+            return true;
+        }
+
+        // Do the O(1) subtype checking trick:
+        //
+        // In a type system with single inheritance, the subtyping relationships
+        // between all types form a set of trees. The root of each tree is a
+        // type that has no supertype; each node's immediate children are the
+        // types that directly subtype that node.
+        //
+        // For example, consider these types:
+        //
+        //     class Base {}
+        //     class A subtypes Base {}
+        //     class B subtypes Base {}
+        //     class C subtypes A {}
+        //     class D subtypes A {}
+        //     class E subtypes C {}
+        //
+        // These types produce the following tree:
+        //
+        //                Base
+        //               /    \
+        //              A      B
+        //             / \
+        //            C   D
+        //           /
+        //          E
+        //
+        // Note the following properties:
+        //
+        // 1. If `sub` is a subtype of `sup` (either directly or transitively)
+        //    then `sup` *must* be on the path from `sub` up to the root of
+        //    `sub`'s tree.
+        //
+        // 2. Additionally, `sup` *must* be the `i`th node down from the root in
+        //    that path, where `i` is the length of the path from `sup` to its
+        //    tree's root.
+        //
+        // Therefore, if we have the path to the root for each type (we do) then
+        // we can simply check if `sup` is at index `supertypes(sup).len()`
+        // within `supertypes(sub)`.
+        let inner = self.0.read();
+        let sub_supertypes = inner.supertypes(sub);
+        let sup_supertypes = inner.supertypes(sup);
+        sub_supertypes.get(sup_supertypes.len()) == Some(&sup)
+    }
+}
diff --git a/crates/wasmtime/src/runtime/types.rs b/crates/wasmtime/src/runtime/types.rs
new file mode 100644
index 000000000000..ecf1865a21a3
--- /dev/null
+++ b/crates/wasmtime/src/runtime/types.rs
@@ -0,0 +1,2932 @@
+use crate::prelude::*;
+use core::fmt::{self, Display, Write};
+use wasmtime_environ::{
+    EngineOrModuleTypeIndex, EntityType, Global, Memory, ModuleTypes, Table, TypeTrace,
+    VMSharedTypeIndex, WasmArrayType, WasmCompositeType, WasmFieldType, WasmFuncType, WasmHeapType,
+    WasmRefType, WasmStorageType, WasmStructType, WasmSubType, WasmValType,
+};
+
+use crate::{type_registry::RegisteredType, Engine};
+
+pub(crate) mod matching;
+
+// Type Representations
+
+// Type attributes
+
+/// Indicator of whether a global value, struct's field, or array type's
+/// elements are mutable or not.
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
+pub enum Mutability {
+    /// The global value, struct field, or array elements are constant and the
+    /// value does not change.
+    Const,
+    /// The value of the global, struct field, or array elements can change over
+    /// time.
+    Var,
+}
+
+impl Mutability {
+    /// Is this constant?
+    #[inline]
+    pub fn is_const(&self) -> bool {
+        *self == Self::Const
+    }
+
+    /// Is this variable?
+    #[inline]
+    pub fn is_var(&self) -> bool {
+        *self == Self::Var
+    }
+}
+
+/// Indicator of whether a type is final or not.
+///
+/// Final types may not be the supertype of other types.
+#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
+pub enum Finality {
+    /// The associated type is final.
+    Final,
+    /// The associated type is not final.
+    NonFinal,
+}
+
+impl Finality {
+    /// Is this final?
+    #[inline]
+    pub fn is_final(&self) -> bool {
+        *self == Self::Final
+    }
+
+    /// Is this non-final?
+    #[inline]
+    pub fn is_non_final(&self) -> bool {
+        *self == Self::NonFinal
+    }
+}
+
+// Value Types
+
+/// A list of all possible value types in WebAssembly.
+///
+/// # Subtyping and Equality
+///
+/// `ValType` does not implement `Eq`, because reference types have a subtyping
+/// relationship, and so 99.99% of the time you actually want to check whether
+/// one type matches (i.e. is a subtype of) another type. You can use the
+/// [`ValType::matches`] and [`Val::matches_ty`][crate::Val::matches_ty] methods
+/// to perform these types of checks. If, however, you are in that 0.01%
+/// scenario where you need to check precise equality between types, you can use
+/// the [`ValType::eq`] method.
+#[derive(Clone, Hash)]
+pub enum ValType {
+    // NB: the ordering of variants here is intended to match the ordering in
+    // `wasmtime_types::WasmType` to help improve codegen when converting.
+    //
+    /// Signed 32 bit integer.
+    I32,
+    /// Signed 64 bit integer.
+    I64,
+    /// Floating point 32 bit integer.
+    F32,
+    /// Floating point 64 bit integer.
+    F64,
+    /// A 128 bit number.
+    V128,
+    /// An opaque reference to some type on the heap.
+    Ref(RefType),
+}
+
+impl fmt::Debug for ValType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, f)
+    }
+}
+
+impl Display for ValType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            ValType::I32 => write!(f, "i32"),
+            ValType::I64 => write!(f, "i64"),
+            ValType::F32 => write!(f, "f32"),
+            ValType::F64 => write!(f, "f64"),
+            ValType::V128 => write!(f, "v128"),
+            ValType::Ref(r) => Display::fmt(r, f),
+        }
+    }
+}
+
+impl From<RefType> for ValType {
+    #[inline]
+    fn from(r: RefType) -> Self {
+        ValType::Ref(r)
+    }
+}
+
+impl ValType {
+    /// The `externref` type, aka `(ref null extern)`.
+    pub const EXTERNREF: Self = ValType::Ref(RefType::EXTERNREF);
+
+    /// The `nullexternref` type, aka `(ref null noextern)`.
+    pub const NULLEXTERNREF: Self = ValType::Ref(RefType::NULLEXTERNREF);
+
+    /// The `funcref` type, aka `(ref null func)`.
+    pub const FUNCREF: Self = ValType::Ref(RefType::FUNCREF);
+
+    /// The `nullfuncref` type, aka `(ref null nofunc)`.
+    pub const NULLFUNCREF: Self = ValType::Ref(RefType::NULLFUNCREF);
+
+    /// The `anyref` type, aka `(ref null any)`.
+    pub const ANYREF: Self = ValType::Ref(RefType::ANYREF);
+
+    /// The `i31ref` type, aka `(ref null i31)`.
+    pub const I31REF: Self = ValType::Ref(RefType::I31REF);
+
+    /// The `arrayref` type, aka `(ref null array)`.
+    pub const ARRAYREF: Self = ValType::Ref(RefType::ARRAYREF);
+
+    /// The `structref` type, aka `(ref null struct)`.
+    pub const STRUCTREF: Self = ValType::Ref(RefType::STRUCTREF);
+
+    /// The `nullref` type, aka `(ref null none)`.
+    pub const NULLREF: Self = ValType::Ref(RefType::NULLREF);
+
+    /// Returns true if `ValType` matches any of the numeric types. (e.g. `I32`,
+    /// `I64`, `F32`, `F64`).
+    #[inline]
+    pub fn is_num(&self) -> bool {
+        match self {
+            ValType::I32 | ValType::I64 | ValType::F32 | ValType::F64 => true,
+            _ => false,
+        }
+    }
+
+    /// Is this the `i32` type?
+    #[inline]
+    pub fn is_i32(&self) -> bool {
+        matches!(self, ValType::I32)
+    }
+
+    /// Is this the `i64` type?
+    #[inline]
+    pub fn is_i64(&self) -> bool {
+        matches!(self, ValType::I64)
+    }
+
+    /// Is this the `f32` type?
+    #[inline]
+    pub fn is_f32(&self) -> bool {
+        matches!(self, ValType::F32)
+    }
+
+    /// Is this the `f64` type?
+    #[inline]
+    pub fn is_f64(&self) -> bool {
+        matches!(self, ValType::F64)
+    }
+
+    /// Is this the `v128` type?
+    #[inline]
+    pub fn is_v128(&self) -> bool {
+        matches!(self, ValType::V128)
+    }
+
+    /// Returns true if `ValType` is any kind of reference type.
+    #[inline]
+    pub fn is_ref(&self) -> bool {
+        matches!(self, ValType::Ref(_))
+    }
+
+    /// Is this the `funcref` (aka `(ref null func)`) type?
+    #[inline]
+    pub fn is_funcref(&self) -> bool {
+        matches!(
+            self,
+            ValType::Ref(RefType {
+                is_nullable: true,
+                heap_type: HeapType::Func
+            })
+        )
+    }
+
+    /// Is this the `externref` (aka `(ref null extern)`) type?
+    #[inline]
+    pub fn is_externref(&self) -> bool {
+        matches!(
+            self,
+            ValType::Ref(RefType {
+                is_nullable: true,
+                heap_type: HeapType::Extern
+            })
+        )
+    }
+
+    /// Is this the `anyref` (aka `(ref null any)`) type?
+    #[inline]
+    pub fn is_anyref(&self) -> bool {
+        matches!(
+            self,
+            ValType::Ref(RefType {
+                is_nullable: true,
+                heap_type: HeapType::Any
+            })
+        )
+    }
+
+    /// Get the underlying reference type, if this value type is a reference
+    /// type.
+    #[inline]
+    pub fn as_ref(&self) -> Option<&RefType> {
+        match self {
+            ValType::Ref(r) => Some(r),
+            _ => None,
+        }
+    }
+
+    /// Get the underlying reference type, panicking if this value type is not a
+    /// reference type.
+    #[inline]
+    pub fn unwrap_ref(&self) -> &RefType {
+        self.as_ref()
+            .expect("ValType::unwrap_ref on a non-reference type")
+    }
+
+    /// Does this value type match the other type?
+    ///
+    /// That is, is this value type a subtype of the other?
+    ///
+    /// # Panics
+    ///
+    /// Panics if either type is associated with a different engine from the
+    /// other.
+    pub fn matches(&self, other: &ValType) -> bool {
+        match (self, other) {
+            (Self::I32, Self::I32) => true,
+            (Self::I64, Self::I64) => true,
+            (Self::F32, Self::F32) => true,
+            (Self::F64, Self::F64) => true,
+            (Self::V128, Self::V128) => true,
+            (Self::Ref(a), Self::Ref(b)) => a.matches(b),
+            (Self::I32, _)
+            | (Self::I64, _)
+            | (Self::F32, _)
+            | (Self::F64, _)
+            | (Self::V128, _)
+            | (Self::Ref(_), _) => false,
+        }
+    }
+
+    /// Is value type `a` precisely equal to value type `b`?
+    ///
+    /// Returns `false` even if `a` is a subtype of `b` or vice versa, if they
+    /// are not exactly the same value type.
+    ///
+    /// # Panics
+    ///
+    /// Panics if either type is associated with a different engine.
+    pub fn eq(a: &Self, b: &Self) -> bool {
+        a.matches(b) && b.matches(a)
+    }
+
+    /// Is this a `VMGcRef` type that is not i31 and is not an uninhabited
+    /// bottom type?
+    #[inline]
+    pub(crate) fn is_vmgcref_type_and_points_to_object(&self) -> bool {
+        match self {
+            ValType::Ref(r) => r.is_vmgcref_type_and_points_to_object(),
+            ValType::I32 | ValType::I64 | ValType::F32 | ValType::F64 | ValType::V128 => false,
+        }
+    }
+
+    pub(crate) fn ensure_matches(&self, engine: &Engine, other: &ValType) -> Result<()> {
+        if !self.comes_from_same_engine(engine) || !other.comes_from_same_engine(engine) {
+            bail!("type used with wrong engine");
+        }
+        if self.matches(other) {
+            Ok(())
+        } else {
+            bail!("type mismatch: expected {other}, found {self}")
+        }
+    }
+
+    pub(crate) fn comes_from_same_engine(&self, engine: &Engine) -> bool {
+        match self {
+            Self::I32 | Self::I64 | Self::F32 | Self::F64 | Self::V128 => true,
+            Self::Ref(r) => r.comes_from_same_engine(engine),
+        }
+    }
+
+    pub(crate) fn to_wasm_type(&self) -> WasmValType {
+        match self {
+            Self::I32 => WasmValType::I32,
+            Self::I64 => WasmValType::I64,
+            Self::F32 => WasmValType::F32,
+            Self::F64 => WasmValType::F64,
+            Self::V128 => WasmValType::V128,
+            Self::Ref(r) => WasmValType::Ref(r.to_wasm_type()),
+        }
+    }
+
+    #[inline]
+    pub(crate) fn from_wasm_type(engine: &Engine, ty: &WasmValType) -> Self {
+        match ty {
+            WasmValType::I32 => Self::I32,
+            WasmValType::I64 => Self::I64,
+            WasmValType::F32 => Self::F32,
+            WasmValType::F64 => Self::F64,
+            WasmValType::V128 => Self::V128,
+            WasmValType::Ref(r) => Self::Ref(RefType::from_wasm_type(engine, r)),
+        }
+    }
+
+    /// What is the size (in bytes) of this type's values when they are stored
+    /// inside the GC heap?
+    pub(crate) fn byte_size_in_gc_heap(&self) -> u32 {
+        match self {
+            ValType::I32 => 4,
+            ValType::I64 => 8,
+            ValType::F32 => 4,
+            ValType::F64 => 8,
+            ValType::V128 => 16,
+            ValType::Ref(r) => r.byte_size_in_gc_heap(),
+        }
+    }
+}
+
+/// Opaque references to data in the Wasm heap or to host data.
+///
+/// # Subtyping and Equality
+///
+/// `RefType` does not implement `Eq`, because reference types have a subtyping
+/// relationship, and so 99.99% of the time you actually want to check whether
+/// one type matches (i.e. is a subtype of) another type. You can use the
+/// [`RefType::matches`] and [`Ref::matches_ty`][crate::Ref::matches_ty] methods
+/// to perform these types of checks. If, however, you are in that 0.01%
+/// scenario where you need to check precise equality between types, you can use
+/// the [`RefType::eq`] method.
+#[derive(Clone, Hash)]
+pub struct RefType {
+    is_nullable: bool,
+    heap_type: HeapType,
+}
+
+impl fmt::Debug for RefType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        Display::fmt(self, f)
+    }
+}
+
+impl fmt::Display for RefType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "(ref ")?;
+        if self.is_nullable() {
+            write!(f, "null ")?;
+        }
+        write!(f, "{})", self.heap_type())
+    }
+}
+
+impl RefType {
+    /// The `externref` type, aka `(ref null extern)`.
+    pub const EXTERNREF: Self = RefType {
+        is_nullable: true,
+        heap_type: HeapType::Extern,
+    };
+
+    /// The `nullexternref` type, aka `(ref null noextern)`.
+    pub const NULLEXTERNREF: Self = RefType {
+        is_nullable: true,
+        heap_type: HeapType::NoExtern,
+    };
+
+    /// The `funcref` type, aka `(ref null func)`.
+    pub const FUNCREF: Self = RefType {
+        is_nullable: true,
+        heap_type: HeapType::Func,
+    };
+
+    /// The `nullfuncref` type, aka `(ref null nofunc)`.
+    pub const NULLFUNCREF: Self = RefType {
+        is_nullable: true,
+        heap_type: HeapType::NoFunc,
+    };
+
+    /// The `anyref` type, aka `(ref null any)`.
+    pub const ANYREF: Self = RefType {
+        is_nullable: true,
+        heap_type: HeapType::Any,
+    };
+
+    /// The `i31ref` type, aka `(ref null i31)`.
+    pub const I31REF: Self = RefType {
+        is_nullable: true,
+        heap_type: HeapType::I31,
+    };
+
+    /// The `arrayref` type, aka `(ref null array)`.
+    pub const ARRAYREF: Self = RefType {
+        is_nullable: true,
+        heap_type: HeapType::Array,
+    };
+
+    /// The `structref` type, aka `(ref null struct)`.
+    pub const STRUCTREF: Self = RefType {
+        is_nullable: true,
+        heap_type: HeapType::Struct,
+    };
+
+    /// The `nullref` type, aka `(ref null none)`.
+    pub const NULLREF: Self = RefType {
+        is_nullable: true,
+        heap_type: HeapType::None,
+    };
+
+    /// Construct a new reference type.
+    pub fn new(is_nullable: bool, heap_type: HeapType) -> RefType {
+        RefType {
+            is_nullable,
+            heap_type,
+        }
+    }
+
+    /// Can this type of reference be null?
+    pub fn is_nullable(&self) -> bool {
+        self.is_nullable
+    }
+
+    /// The heap type that this is a reference to.
+    #[inline]
+    pub fn heap_type(&self) -> &HeapType {
+        &self.heap_type
+    }
+
+    /// Does this reference type match the other?
+    ///
+    /// That is, is this reference type a subtype of the other?
+    ///
+    /// # Panics
+    ///
+    /// Panics if either type is associated with a different engine from the
+    /// other.
+    pub fn matches(&self, other: &RefType) -> bool {
+        if self.is_nullable() && !other.is_nullable() {
+            return false;
+        }
+        self.heap_type().matches(other.heap_type())
+    }
+
+    /// Is reference type `a` precisely equal to reference type `b`?
+    ///
+    /// Returns `false` even if `a` is a subtype of `b` or vice versa, if they
+    /// are not exactly the same reference type.
+    ///
+    /// # Panics
+    ///
+    /// Panics if either type is associated with a different engine.
+    pub fn eq(a: &RefType, b: &RefType) -> bool {
+        a.matches(b) && b.matches(a)
+    }
+
+    pub(crate) fn ensure_matches(&self, engine: &Engine, other: &RefType) -> Result<()> {
+        if !self.comes_from_same_engine(engine) || !other.comes_from_same_engine(engine) {
+            bail!("type used with wrong engine");
+        }
+        if self.matches(other) {
+            Ok(())
+        } else {
+            bail!("type mismatch: expected {other}, found {self}")
+        }
+    }
+
+    pub(crate) fn comes_from_same_engine(&self, engine: &Engine) -> bool {
+        self.heap_type().comes_from_same_engine(engine)
+    }
+
+    pub(crate) fn to_wasm_type(&self) -> WasmRefType {
+        WasmRefType {
+            nullable: self.is_nullable(),
+            heap_type: self.heap_type().to_wasm_type(),
+        }
+    }
+
+    pub(crate) fn from_wasm_type(engine: &Engine, ty: &WasmRefType) -> RefType {
+        RefType {
+            is_nullable: ty.nullable,
+            heap_type: HeapType::from_wasm_type(engine, &ty.heap_type),
+        }
+    }
+
+    pub(crate) fn is_vmgcref_type_and_points_to_object(&self) -> bool {
+        self.heap_type().is_vmgcref_type_and_points_to_object()
+    }
+
+    /// What is the size (in bytes) of this type's values when they are stored
+    /// inside the GC heap?
+    pub(crate) fn byte_size_in_gc_heap(&self) -> u32 {
+        match &self.heap_type {
+            HeapType::Extern | HeapType::NoExtern => 4,
+
+            HeapType::Func | HeapType::ConcreteFunc(_) | HeapType::NoFunc => {
+                todo!("funcrefs in the gc heap aren't supported yet")
+            }
+            HeapType::Any
+            | HeapType::Eq
+            | HeapType::I31
+            | HeapType::Array
+            | HeapType::ConcreteArray(_)
+            | HeapType::Struct
+            | HeapType::ConcreteStruct(_)
+            | HeapType::None => 4,
+        }
+    }
+}
+
+/// The heap types that can Wasm can have references to.
+///
+/// # Subtyping Hierarchy
+///
+/// Wasm has three different heap type hierarchies:
+///
+/// 1. Function types
+/// 2. External types
+/// 3. Internal types
+///
+/// Each hierarchy has a top type (the common supertype of which everything else
+/// in its hierarchy is a subtype of) and a bottom type (the common subtype of
+/// which everything else in its hierarchy is supertype of).
+///
+/// ## Function Types Hierarchy
+///
+/// The top of the function types hierarchy is `func`; the bottom is
+/// `nofunc`. In between are all the concrete function types.
+///
+/// ```text
+///                          func
+///                       /  /  \  \
+///      ,----------------  /    \  -------------------------.
+///     /                  /      \                           \
+///    |              ,----        -----------.                |
+///    |              |                       |                |
+///    |              |                       |                |
+/// (func)    (func (param i32))    (func (param i32 i32))    ...
+///    |              |                       |                |
+///    |              |                       |                |
+///    |              `---.        ,----------'                |
+///     \                  \      /                           /
+///      `---------------.  \    /  ,------------------------'
+///                       \  \  /  /
+///                         nofunc
+/// ```
+///
+/// Additionally, some concrete function types are sub- or supertypes of other
+/// concrete function types, if that was declared in their definition. For
+/// simplicity, this isn't depicted in the diagram above.
+///
+/// ## External
+///
+/// The top of the external types hierarchy is `extern`; the bottom is
+/// `noextern`. There are no concrete types in this hierarchy.
+///
+/// ```text
+///  extern
+///    |
+/// noextern
+/// ```
+///
+/// ## Internal
+///
+/// The top of the internal types hierarchy is `any`; the bottom is `none`. The
+/// `eq` type is the common supertype of all types that can be compared for
+/// equality. The `struct` and `array` types are the common supertypes of all
+/// concrete struct and array types respectively. The `i31` type represents
+/// unboxed 31-bit integers.
+///
+/// ```text
+///                                   any
+///                                  / | \
+///    ,----------------------------'  |  `--------------------------.
+///   /                                |                              \
+///  |                        .--------'                               |
+///  |                        |                                        |
+///  |                      struct                                   array
+///  |                     /  |   \                                 /  |   \
+/// i31             ,-----'   |    '-----.                   ,-----'   |    `-----.
+///  |             /          |           \                 /          |           \
+///  |            |           |            |               |           |            |
+///  |        (struct)    (struct i32)    ...        (array i32)    (array i64)    ...
+///  |            |           |            |               |           |            |
+///  |             \          |           /                 \          |           /
+///   \             `-----.   |    ,-----'                   `-----.   |    ,-----'
+///    \                   \  |   /                                 \  |   /
+///     \                   \ |  /                                   \ |  /
+///      \                   \| /                                     \| /
+///       \                   |/                                       |/
+///        \                  |                                        |
+///         \                 |                                       /
+///          \                '--------.                             /
+///           \                        |                            /
+///            `--------------------.  |   ,-----------------------'
+///                                  \ |  /
+///                                   none
+/// ```
+///
+/// Additionally, concrete struct and array types can be subtypes of other
+/// concrete struct and array types respectively, if that was declared in their
+/// definitions. Once again, this is omitted from the above diagram for
+/// simplicity.
+///
+/// # Subtyping and Equality
+///
+/// `HeapType` does not implement `Eq`, because heap types have a subtyping
+/// relationship, and so 99.99% of the time you actually want to check whether
+/// one type matches (i.e. is a subtype of) another type. You can use the
+/// [`HeapType::matches`] method to perform these types of checks. If, however,
+/// you are in that 0.01% scenario where you need to check precise equality
+/// between types, you can use the [`HeapType::eq`] method.
+#[derive(Debug, Clone, Hash)]
+pub enum HeapType {
+    /// The abstract `extern` heap type represents external host data.
+    ///
+    /// This is the top type for the external type hierarchy, and therefore is
+    /// the common supertype of all external reference types.
+    Extern,
+
+    /// The abstract `noextern` heap type represents the null external
+    /// reference.
+    ///
+    /// This is the bottom type for the external type hierarchy, and therefore
+    /// is the common subtype of all external reference types.
+    NoExtern,
+
+    /// The abstract `func` heap type represents a reference to any kind of
+    /// function.
+    ///
+    /// This is the top type for the function references type hierarchy, and is
+    /// therefore a supertype of every function reference.
+    Func,
+
+    /// A reference to a function of a specific, concrete type.
+    ///
+    /// These are subtypes of `func` and supertypes of `nofunc`.
+    ConcreteFunc(FuncType),
+
+    /// The abstract `nofunc` heap type represents the null function reference.
+    ///
+    /// This is the bottom type for the function references type hierarchy, and
+    /// therefore `nofunc` is a subtype of all function reference types.
+    NoFunc,
+
+    /// The abstract `any` heap type represents all internal Wasm data.
+    ///
+    /// This is the top type of the internal type hierarchy, and is therefore a
+    /// supertype of all internal types (such as `eq`, `i31`, `struct`s, and
+    /// `array`s).
+    Any,
+
+    /// The abstract `eq` heap type represenets all internal Wasm references
+    /// that can be compared for equality.
+    ///
+    /// This is a subtype of `any` and a supertype of `i31`, `array`, `struct`,
+    /// and `none` heap types.
+    Eq,
+
+    /// The `i31` heap type represents unboxed 31-bit integers.
+    ///
+    /// This is a subtype of `any` and `eq`, and a supertype of `none`.
+    I31,
+
+    /// The abstract `array` heap type represents a reference to any kind of
+    /// array.
+    ///
+    /// This is a subtype of `any` and `eq`, and a supertype of all concrete
+    /// array types, as well as a supertype of the abstract `none` heap type.
+    Array,
+
+    /// A reference to an array of a specific, concrete type.
+    ///
+    /// These are subtypes of the `array` heap type (therefore also a subtype of
+    /// `any` and `eq`) and supertypes of the `none` heap type.
+    ConcreteArray(ArrayType),
+
+    /// The abstract `struct` heap type represents a reference to any kind of
+    /// struct.
+    ///
+    /// This is a subtype of `any` and `eq`, and a supertype of all concrete
+    /// struct types, as well as a supertype of the abstract `none` heap type.
+    Struct,
+
+    /// A reference to an struct of a specific, concrete type.
+    ///
+    /// These are subtypes of the `struct` heap type (therefore also a subtype
+    /// of `any` and `eq`) and supertypes of the `none` heap type.
+    ConcreteStruct(StructType),
+
+    /// The abstract `none` heap type represents the null internal reference.
+    ///
+    /// This is the bottom type for the internal type hierarchy, and therefore
+    /// `none` is a subtype of internal types.
+    None,
+}
+
+impl Display for HeapType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            HeapType::Extern => write!(f, "extern"),
+            HeapType::NoExtern => write!(f, "noextern"),
+            HeapType::Func => write!(f, "func"),
+            HeapType::NoFunc => write!(f, "nofunc"),
+            HeapType::Any => write!(f, "any"),
+            HeapType::Eq => write!(f, "eq"),
+            HeapType::I31 => write!(f, "i31"),
+            HeapType::Array => write!(f, "array"),
+            HeapType::Struct => write!(f, "struct"),
+            HeapType::None => write!(f, "none"),
+            HeapType::ConcreteFunc(ty) => write!(f, "(concrete func {:?})", ty.type_index()),
+            HeapType::ConcreteArray(ty) => write!(f, "(concrete array {:?})", ty.type_index()),
+            HeapType::ConcreteStruct(ty) => write!(f, "(concrete struct {:?})", ty.type_index()),
+        }
+    }
+}
+
+impl From<FuncType> for HeapType {
+    #[inline]
+    fn from(f: FuncType) -> Self {
+        HeapType::ConcreteFunc(f)
+    }
+}
+
+impl From<ArrayType> for HeapType {
+    #[inline]
+    fn from(a: ArrayType) -> Self {
+        HeapType::ConcreteArray(a)
+    }
+}
+
+impl From<StructType> for HeapType {
+    #[inline]
+    fn from(s: StructType) -> Self {
+        HeapType::ConcreteStruct(s)
+    }
+}
+
+impl HeapType {
+    /// Is this the abstract `extern` heap type?
+    pub fn is_extern(&self) -> bool {
+        matches!(self, HeapType::Extern)
+    }
+
+    /// Is this the abstract `func` heap type?
+    pub fn is_func(&self) -> bool {
+        matches!(self, HeapType::Func)
+    }
+
+    /// Is this the abstract `nofunc` heap type?
+    pub fn is_no_func(&self) -> bool {
+        matches!(self, HeapType::NoFunc)
+    }
+
+    /// Is this the abstract `any` heap type?
+    pub fn is_any(&self) -> bool {
+        matches!(self, HeapType::Any)
+    }
+
+    /// Is this the abstract `i31` heap type?
+    pub fn is_i31(&self) -> bool {
+        matches!(self, HeapType::I31)
+    }
+
+    /// Is this the abstract `none` heap type?
+    pub fn is_none(&self) -> bool {
+        matches!(self, HeapType::None)
+    }
+
+    /// Is this an abstract type?
+    ///
+    /// Types that are not abstract are concrete, user-defined types.
+    pub fn is_abstract(&self) -> bool {
+        !self.is_concrete()
+    }
+
+    /// Is this a concrete, user-defined heap type?
+    ///
+    /// Types that are not concrete, user-defined types are abstract types.
+    #[inline]
+    pub fn is_concrete(&self) -> bool {
+        matches!(
+            self,
+            HeapType::ConcreteFunc(_) | HeapType::ConcreteArray(_) | HeapType::ConcreteStruct(_)
+        )
+    }
+
+    /// Is this a concrete, user-defined function type?
+    pub fn is_concrete_func(&self) -> bool {
+        matches!(self, HeapType::ConcreteFunc(_))
+    }
+
+    /// Get the underlying concrete, user-defined function type, if any.
+    ///
+    /// Returns `None` if this is not a concrete function type.
+    pub fn as_concrete_func(&self) -> Option<&FuncType> {
+        match self {
+            HeapType::ConcreteFunc(f) => Some(f),
+            _ => None,
+        }
+    }
+
+    /// Get the underlying concrete, user-defined type, panicking if this is not
+    /// a concrete function type.
+    pub fn unwrap_concrete_func(&self) -> &FuncType {
+        self.as_concrete_func().unwrap()
+    }
+
+    /// Is this a concrete, user-defined array type?
+    pub fn is_concrete_array(&self) -> bool {
+        matches!(self, HeapType::ConcreteArray(_))
+    }
+
+    /// Get the underlying concrete, user-defined array type, if any.
+    ///
+    /// Returns `None` for if this is not a concrete array type.
+    pub fn as_concrete_array(&self) -> Option<&ArrayType> {
+        match self {
+            HeapType::ConcreteArray(f) => Some(f),
+            _ => None,
+        }
+    }
+
+    /// Get the underlying concrete, user-defined type, panicking if this is not
+    /// a concrete array type.
+    pub fn unwrap_concrete_array(&self) -> &ArrayType {
+        self.as_concrete_array().unwrap()
+    }
+
+    /// Is this a concrete, user-defined struct type?
+    pub fn is_concrete_struct(&self) -> bool {
+        matches!(self, HeapType::ConcreteStruct(_))
+    }
+
+    /// Get the underlying concrete, user-defined struct type, if any.
+    ///
+    /// Returns `None` for if this is not a concrete struct type.
+    pub fn as_concrete_struct(&self) -> Option<&StructType> {
+        match self {
+            HeapType::ConcreteStruct(f) => Some(f),
+            _ => None,
+        }
+    }
+
+    /// Get the underlying concrete, user-defined type, panicking if this is not
+    /// a concrete struct type.
+    pub fn unwrap_concrete_struct(&self) -> &StructType {
+        self.as_concrete_struct().unwrap()
+    }
+
+    /// Get the top type of this heap type's type hierarchy.
+    ///
+    /// The returned heap type is a supertype of all types in this heap type's
+    /// type hierarchy.
+    #[inline]
+    pub fn top(&self) -> HeapType {
+        match self {
+            HeapType::Func | HeapType::ConcreteFunc(_) | HeapType::NoFunc => HeapType::Func,
+
+            HeapType::Extern | HeapType::NoExtern => HeapType::Extern,
+
+            HeapType::Any
+            | HeapType::Eq
+            | HeapType::I31
+            | HeapType::Array
+            | HeapType::ConcreteArray(_)
+            | HeapType::Struct
+            | HeapType::ConcreteStruct(_)
+            | HeapType::None => HeapType::Any,
+        }
+    }
+
+    /// Is this the top type within its type hierarchy?
+    #[inline]
+    pub fn is_top(&self) -> bool {
+        match self {
+            HeapType::Any | HeapType::Extern | HeapType::Func => true,
+            _ => false,
+        }
+    }
+
+    /// Get the bottom type of this heap type's type hierarchy.
+    ///
+    /// The returned heap type is a subtype of all types in this heap type's
+    /// type hierarchy.
+    #[inline]
+    pub fn bottom(&self) -> HeapType {
+        match self {
+            HeapType::Extern | HeapType::NoExtern => HeapType::NoExtern,
+
+            HeapType::Func | HeapType::ConcreteFunc(_) | HeapType::NoFunc => HeapType::NoFunc,
+
+            HeapType::Any
+            | HeapType::Eq
+            | HeapType::I31
+            | HeapType::Array
+            | HeapType::ConcreteArray(_)
+            | HeapType::Struct
+            | HeapType::ConcreteStruct(_)
+            | HeapType::None => HeapType::None,
+        }
+    }
+
+    /// Is this the bottom type within its type hierarchy?
+    #[inline]
+    pub fn is_bottom(&self) -> bool {
+        match self {
+            HeapType::None | HeapType::NoExtern | HeapType::NoFunc => true,
+            _ => false,
+        }
+    }
+
+    /// Does this heap type match the other heap type?
+    ///
+    /// That is, is this heap type a subtype of the other?
+    ///
+    /// # Panics
+    ///
+    /// Panics if either type is associated with a different engine from the
+    /// other.
+    pub fn matches(&self, other: &HeapType) -> bool {
+        match (self, other) {
+            (HeapType::Extern, HeapType::Extern) => true,
+            (HeapType::Extern, _) => false,
+
+            (HeapType::NoExtern, HeapType::NoExtern | HeapType::Extern) => true,
+            (HeapType::NoExtern, _) => false,
+
+            (HeapType::NoFunc, HeapType::NoFunc | HeapType::ConcreteFunc(_) | HeapType::Func) => {
+                true
+            }
+            (HeapType::NoFunc, _) => false,
+
+            (HeapType::ConcreteFunc(_), HeapType::Func) => true,
+            (HeapType::ConcreteFunc(a), HeapType::ConcreteFunc(b)) => {
+                assert!(a.comes_from_same_engine(b.engine()));
+                a.engine()
+                    .signatures()
+                    .is_subtype(a.type_index(), b.type_index())
+            }
+            (HeapType::ConcreteFunc(_), _) => false,
+
+            (HeapType::Func, HeapType::Func) => true,
+            (HeapType::Func, _) => false,
+
+            (
+                HeapType::None,
+                HeapType::None
+                | HeapType::ConcreteArray(_)
+                | HeapType::Array
+                | HeapType::ConcreteStruct(_)
+                | HeapType::Struct
+                | HeapType::I31
+                | HeapType::Eq
+                | HeapType::Any,
+            ) => true,
+            (HeapType::None, _) => false,
+
+            (HeapType::ConcreteArray(_), HeapType::Array | HeapType::Eq | HeapType::Any) => true,
+            (HeapType::ConcreteArray(a), HeapType::ConcreteArray(b)) => {
+                assert!(a.comes_from_same_engine(b.engine()));
+                a.engine()
+                    .signatures()
+                    .is_subtype(a.type_index(), b.type_index())
+            }
+            (HeapType::ConcreteArray(_), _) => false,
+
+            (HeapType::Array, HeapType::Array | HeapType::Eq | HeapType::Any) => true,
+            (HeapType::Array, _) => false,
+
+            (HeapType::ConcreteStruct(_), HeapType::Struct | HeapType::Eq | HeapType::Any) => true,
+            (HeapType::ConcreteStruct(a), HeapType::ConcreteStruct(b)) => {
+                assert!(a.comes_from_same_engine(b.engine()));
+                a.engine()
+                    .signatures()
+                    .is_subtype(a.type_index(), b.type_index())
+            }
+            (HeapType::ConcreteStruct(_), _) => false,
+
+            (HeapType::Struct, HeapType::Struct | HeapType::Eq | HeapType::Any) => true,
+            (HeapType::Struct, _) => false,
+
+            (HeapType::I31, HeapType::I31 | HeapType::Eq | HeapType::Any) => true,
+            (HeapType::I31, _) => false,
+
+            (HeapType::Eq, HeapType::Eq | HeapType::Any) => true,
+            (HeapType::Eq, _) => false,
+
+            (HeapType::Any, HeapType::Any) => true,
+            (HeapType::Any, _) => false,
+        }
+    }
+
+    /// Is heap type `a` precisely equal to heap type `b`?
+    ///
+    /// Returns `false` even if `a` is a subtype of `b` or vice versa, if they
+    /// are not exactly the same heap type.
+    ///
+    /// # Panics
+    ///
+    /// Panics if either type is associated with a different engine from the
+    /// other.
+    pub fn eq(a: &HeapType, b: &HeapType) -> bool {
+        a.matches(b) && b.matches(a)
+    }
+
+    pub(crate) fn ensure_matches(&self, engine: &Engine, other: &HeapType) -> Result<()> {
+        if !self.comes_from_same_engine(engine) || !other.comes_from_same_engine(engine) {
+            bail!("type used with wrong engine");
+        }
+        if self.matches(other) {
+            Ok(())
+        } else {
+            bail!("type mismatch: expected {other}, found {self}");
+        }
+    }
+
+    pub(crate) fn comes_from_same_engine(&self, engine: &Engine) -> bool {
+        match self {
+            HeapType::Extern
+            | HeapType::NoExtern
+            | HeapType::Func
+            | HeapType::NoFunc
+            | HeapType::Any
+            | HeapType::Eq
+            | HeapType::I31
+            | HeapType::Array
+            | HeapType::Struct
+            | HeapType::None => true,
+            HeapType::ConcreteFunc(ty) => ty.comes_from_same_engine(engine),
+            HeapType::ConcreteArray(ty) => ty.comes_from_same_engine(engine),
+            HeapType::ConcreteStruct(ty) => ty.comes_from_same_engine(engine),
+        }
+    }
+
+    pub(crate) fn to_wasm_type(&self) -> WasmHeapType {
+        match self {
+            HeapType::Extern => WasmHeapType::Extern,
+            HeapType::NoExtern => WasmHeapType::NoExtern,
+            HeapType::Func => WasmHeapType::Func,
+            HeapType::NoFunc => WasmHeapType::NoFunc,
+            HeapType::Any => WasmHeapType::Any,
+            HeapType::Eq => WasmHeapType::Eq,
+            HeapType::I31 => WasmHeapType::I31,
+            HeapType::Array => WasmHeapType::Array,
+            HeapType::Struct => WasmHeapType::Struct,
+            HeapType::None => WasmHeapType::None,
+            HeapType::ConcreteFunc(f) => {
+                WasmHeapType::ConcreteFunc(EngineOrModuleTypeIndex::Engine(f.type_index()))
+            }
+            HeapType::ConcreteArray(a) => {
+                WasmHeapType::ConcreteArray(EngineOrModuleTypeIndex::Engine(a.type_index()))
+            }
+            HeapType::ConcreteStruct(a) => {
+                WasmHeapType::ConcreteStruct(EngineOrModuleTypeIndex::Engine(a.type_index()))
+            }
+        }
+    }
+
+    pub(crate) fn from_wasm_type(engine: &Engine, ty: &WasmHeapType) -> HeapType {
+        match ty {
+            WasmHeapType::Extern => HeapType::Extern,
+            WasmHeapType::NoExtern => HeapType::NoExtern,
+            WasmHeapType::Func => HeapType::Func,
+            WasmHeapType::NoFunc => HeapType::NoFunc,
+            WasmHeapType::Any => HeapType::Any,
+            WasmHeapType::Eq => HeapType::Eq,
+            WasmHeapType::I31 => HeapType::I31,
+            WasmHeapType::Array => HeapType::Array,
+            WasmHeapType::Struct => HeapType::Struct,
+            WasmHeapType::None => HeapType::None,
+            WasmHeapType::ConcreteFunc(EngineOrModuleTypeIndex::Engine(idx)) => {
+                HeapType::ConcreteFunc(FuncType::from_shared_type_index(engine, *idx))
+            }
+            WasmHeapType::ConcreteArray(EngineOrModuleTypeIndex::Engine(idx)) => {
+                HeapType::ConcreteArray(ArrayType::from_shared_type_index(engine, *idx))
+            }
+            WasmHeapType::ConcreteStruct(EngineOrModuleTypeIndex::Engine(idx)) => {
+                HeapType::ConcreteStruct(StructType::from_shared_type_index(engine, *idx))
+            }
+
+            WasmHeapType::ConcreteFunc(EngineOrModuleTypeIndex::Module(_))
+            | WasmHeapType::ConcreteFunc(EngineOrModuleTypeIndex::RecGroup(_))
+            | WasmHeapType::ConcreteArray(EngineOrModuleTypeIndex::Module(_))
+            | WasmHeapType::ConcreteArray(EngineOrModuleTypeIndex::RecGroup(_))
+            | WasmHeapType::ConcreteStruct(EngineOrModuleTypeIndex::Module(_))
+            | WasmHeapType::ConcreteStruct(EngineOrModuleTypeIndex::RecGroup(_)) => {
+                panic!("HeapType::from_wasm_type on non-canonicalized-for-runtime-usage heap type")
+            }
+        }
+    }
+
+    pub(crate) fn as_registered_type(&self) -> Option<&RegisteredType> {
+        match self {
+            HeapType::ConcreteFunc(f) => Some(&f.registered_type),
+            HeapType::ConcreteArray(a) => Some(&a.registered_type),
+            HeapType::ConcreteStruct(a) => Some(&a.registered_type),
+
+            HeapType::Extern
+            | HeapType::NoExtern
+            | HeapType::Func
+            | HeapType::NoFunc
+            | HeapType::Any
+            | HeapType::Eq
+            | HeapType::I31
+            | HeapType::Array
+            | HeapType::Struct
+            | HeapType::None => None,
+        }
+    }
+
+    #[inline]
+    pub(crate) fn is_vmgcref_type(&self) -> bool {
+        match self.top() {
+            Self::Any | Self::Extern => true,
+            Self::Func => false,
+            ty => unreachable!("not a top type: {ty:?}"),
+        }
+    }
+
+    /// Is this a `VMGcRef` type that is not i31 and is not an uninhabited
+    /// bottom type?
+    #[inline]
+    pub(crate) fn is_vmgcref_type_and_points_to_object(&self) -> bool {
+        self.is_vmgcref_type()
+            && !matches!(
+                self,
+                HeapType::I31 | HeapType::NoExtern | HeapType::NoFunc | HeapType::None
+            )
+    }
+}
+
+// External Types
+
+/// A list of all possible types which can be externally referenced from a
+/// WebAssembly module.
+///
+/// This list can be found in [`ImportType`] or [`ExportType`], so these types
+/// can either be imported or exported.
+#[derive(Debug, Clone)]
+pub enum ExternType {
+    /// This external type is the type of a WebAssembly function.
+    Func(FuncType),
+    /// This external type is the type of a WebAssembly global.
+    Global(GlobalType),
+    /// This external type is the type of a WebAssembly table.
+    Table(TableType),
+    /// This external type is the type of a WebAssembly memory.
+    Memory(MemoryType),
+}
+
+macro_rules! extern_type_accessors {
+    ($(($variant:ident($ty:ty) $get:ident $unwrap:ident))*) => ($(
+        /// Attempt to return the underlying type of this external type,
+        /// returning `None` if it is a different type.
+        pub fn $get(&self) -> Option<&$ty> {
+            if let ExternType::$variant(e) = self {
+                Some(e)
+            } else {
+                None
+            }
+        }
+
+        /// Returns the underlying descriptor of this [`ExternType`], panicking
+        /// if it is a different type.
+        ///
+        /// # Panics
+        ///
+        /// Panics if `self` is not of the right type.
+        pub fn $unwrap(&self) -> &$ty {
+            self.$get().expect(concat!("expected ", stringify!($ty)))
+        }
+    )*)
+}
+
+impl ExternType {
+    extern_type_accessors! {
+        (Func(FuncType) func unwrap_func)
+        (Global(GlobalType) global unwrap_global)
+        (Table(TableType) table unwrap_table)
+        (Memory(MemoryType) memory unwrap_memory)
+    }
+
+    pub(crate) fn from_wasmtime(
+        engine: &Engine,
+        types: &ModuleTypes,
+        ty: &EntityType,
+    ) -> ExternType {
+        match ty {
+            EntityType::Function(idx) => match idx {
+                EngineOrModuleTypeIndex::Engine(e) => {
+                    FuncType::from_shared_type_index(engine, *e).into()
+                }
+                EngineOrModuleTypeIndex::Module(m) => {
+                    let subty = &types[*m];
+                    FuncType::from_wasm_func_type(
+                        engine,
+                        subty.is_final,
+                        subty.supertype,
+                        subty.unwrap_func().clone(),
+                    )
+                    .into()
+                }
+                EngineOrModuleTypeIndex::RecGroup(_) => unreachable!(),
+            },
+            EntityType::Global(ty) => GlobalType::from_wasmtime_global(engine, ty).into(),
+            EntityType::Memory(ty) => MemoryType::from_wasmtime_memory(ty).into(),
+            EntityType::Table(ty) => TableType::from_wasmtime_table(engine, ty).into(),
+            EntityType::Tag(_) => unimplemented!("wasm tag support"),
+        }
+    }
+}
+
+impl From<FuncType> for ExternType {
+    fn from(ty: FuncType) -> ExternType {
+        ExternType::Func(ty)
+    }
+}
+
+impl From<GlobalType> for ExternType {
+    fn from(ty: GlobalType) -> ExternType {
+        ExternType::Global(ty)
+    }
+}
+
+impl From<MemoryType> for ExternType {
+    fn from(ty: MemoryType) -> ExternType {
+        ExternType::Memory(ty)
+    }
+}
+
+impl From<TableType> for ExternType {
+    fn from(ty: TableType) -> ExternType {
+        ExternType::Table(ty)
+    }
+}
+
+/// The storage type of a `struct` field or `array` element.
+///
+/// This is either a packed 8- or -16 bit integer, or else it is some unpacked
+/// Wasm value type.
+#[derive(Clone, Hash)]
+pub enum StorageType {
+    /// `i8`, an 8-bit integer.
+    I8,
+    /// `i16`, a 16-bit integer.
+    I16,
+    /// A value type.
+    ValType(ValType),
+}
+
+impl fmt::Display for StorageType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            StorageType::I8 => write!(f, "i8"),
+            StorageType::I16 => write!(f, "i16"),
+            StorageType::ValType(ty) => fmt::Display::fmt(ty, f),
+        }
+    }
+}
+
+impl From<ValType> for StorageType {
+    #[inline]
+    fn from(v: ValType) -> Self {
+        StorageType::ValType(v)
+    }
+}
+
+impl StorageType {
+    /// Is this an `i8`?
+    #[inline]
+    pub fn is_i8(&self) -> bool {
+        matches!(self, Self::I8)
+    }
+
+    /// Is this an `i16`?
+    #[inline]
+    pub fn is_i16(&self) -> bool {
+        matches!(self, Self::I16)
+    }
+
+    /// Is this a Wasm value type?
+    #[inline]
+    pub fn is_val_type(&self) -> bool {
+        matches!(self, Self::I16)
+    }
+
+    /// Get this storage type's underlying value type, if any.
+    ///
+    /// Returns `None` if this storage type is not a value type.
+    #[inline]
+    pub fn as_val_type(&self) -> Option<&ValType> {
+        match self {
+            Self::ValType(v) => Some(v),
+            _ => None,
+        }
+    }
+
+    /// Get this storage type's underlying value type, panicking if it is not a
+    /// value type.
+    pub fn unwrap_val_type(&self) -> &ValType {
+        self.as_val_type().unwrap()
+    }
+
+    /// Unpack this (possibly packed) storage type into a full `ValType`.
+    ///
+    /// If this is a `StorageType::ValType`, then the inner `ValType` is
+    /// returned as-is.
+    ///
+    /// If this is a packed `StorageType::I8` or `StorageType::I16, then a
+    /// `ValType::I32` is returned.
+    pub fn unpack(&self) -> &ValType {
+        match self {
+            StorageType::I8 | StorageType::I16 => &ValType::I32,
+            StorageType::ValType(ty) => ty,
+        }
+    }
+
+    /// Does this field type match the other field type?
+    ///
+    /// That is, is this field type a subtype of the other field type?
+    ///
+    /// # Panics
+    ///
+    /// Panics if either type is associated with a different engine from the
+    /// other.
+    pub fn matches(&self, other: &Self) -> bool {
+        match (self, other) {
+            (StorageType::I8, StorageType::I8) => true,
+            (StorageType::I8, _) => false,
+            (StorageType::I16, StorageType::I16) => true,
+            (StorageType::I16, _) => false,
+            (StorageType::ValType(a), StorageType::ValType(b)) => a.matches(b),
+            (StorageType::ValType(_), _) => false,
+        }
+    }
+
+    /// Is field type `a` precisely equal to field type `b`?
+    ///
+    /// Returns `false` even if `a` is a subtype of `b` or vice versa, if they
+    /// are not exactly the same field type.
+    ///
+    /// # Panics
+    ///
+    /// Panics if either type is associated with a different engine from the
+    /// other.
+    pub fn eq(a: &Self, b: &Self) -> bool {
+        a.matches(b) && b.matches(a)
+    }
+
+    /// What is the size (in bytes) of this type's values when they are stored
+    /// inside the GC heap?
+    pub(crate) fn byte_size_in_gc_heap(&self) -> u32 {
+        match self {
+            StorageType::I8 => 1,
+            StorageType::I16 => 2,
+            StorageType::ValType(ty) => ty.byte_size_in_gc_heap(),
+        }
+    }
+
+    pub(crate) fn comes_from_same_engine(&self, engine: &Engine) -> bool {
+        match self {
+            StorageType::I8 | StorageType::I16 => true,
+            StorageType::ValType(v) => v.comes_from_same_engine(engine),
+        }
+    }
+
+    pub(crate) fn from_wasm_storage_type(engine: &Engine, ty: &WasmStorageType) -> Self {
+        match ty {
+            WasmStorageType::I8 => Self::I8,
+            WasmStorageType::I16 => Self::I16,
+            WasmStorageType::Val(v) => ValType::from_wasm_type(engine, &v).into(),
+        }
+    }
+
+    pub(crate) fn to_wasm_storage_type(&self) -> WasmStorageType {
+        match self {
+            Self::I8 => WasmStorageType::I8,
+            Self::I16 => WasmStorageType::I16,
+            Self::ValType(v) => WasmStorageType::Val(v.to_wasm_type()),
+        }
+    }
+}
+
+/// The type of a `struct` field or an `array`'s elements.
+///
+/// This is a pair of both the field's storage type and its mutability
+/// (i.e. whether the field can be updated or not).
+#[derive(Clone, Hash)]
+pub struct FieldType {
+    mutability: Mutability,
+    element_type: StorageType,
+}
+
+impl fmt::Display for FieldType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.mutability.is_var() {
+            write!(f, "(mut {})", self.element_type)
+        } else {
+            fmt::Display::fmt(&self.element_type, f)
+        }
+    }
+}
+
+impl FieldType {
+    /// Construct a new field type from the given parts.
+    #[inline]
+    pub fn new(mutability: Mutability, element_type: StorageType) -> Self {
+        Self {
+            mutability,
+            element_type,
+        }
+    }
+
+    /// Get whether or not this field type is mutable.
+    #[inline]
+    pub fn mutability(&self) -> Mutability {
+        self.mutability
+    }
+
+    /// Get this field type's storage type.
+    #[inline]
+    pub fn element_type(&self) -> &StorageType {
+        &self.element_type
+    }
+
+    /// Does this field type match the other field type?
+    ///
+    /// That is, is this field type a subtype of the other field type?
+    ///
+    /// # Panics
+    ///
+    /// Panics if either type is associated with a different engine from the
+    /// other.
+    pub fn matches(&self, other: &Self) -> bool {
+        (other.mutability == Mutability::Var || self.mutability == Mutability::Const)
+            && self.element_type.matches(&other.element_type)
+    }
+
+    /// Is field type `a` precisely equal to field type `b`?
+    ///
+    /// Returns `false` even if `a` is a subtype of `b` or vice versa, if they
+    /// are not exactly the same field type.
+    ///
+    /// # Panics
+    ///
+    /// Panics if either type is associated with a different engine from the
+    /// other.
+    pub fn eq(a: &Self, b: &Self) -> bool {
+        a.matches(b) && b.matches(a)
+    }
+
+    pub(crate) fn comes_from_same_engine(&self, engine: &Engine) -> bool {
+        self.element_type.comes_from_same_engine(engine)
+    }
+
+    pub(crate) fn from_wasm_field_type(engine: &Engine, ty: &WasmFieldType) -> Self {
+        Self {
+            mutability: if ty.mutable {
+                Mutability::Var
+            } else {
+                Mutability::Const
+            },
+            element_type: StorageType::from_wasm_storage_type(engine, &ty.element_type),
+        }
+    }
+
+    pub(crate) fn to_wasm_field_type(&self) -> WasmFieldType {
+        WasmFieldType {
+            element_type: self.element_type.to_wasm_storage_type(),
+            mutable: matches!(self.mutability, Mutability::Var),
+        }
+    }
+}
+
+/// The type of a WebAssembly struct.
+///
+/// WebAssembly structs are a static, fixed-length, ordered sequence of
+/// fields. Fields are named by index, not an identifier. Each field is mutable
+/// or constant and stores unpacked [`Val`][crate::Val]s or packed 8-/16-bit
+/// integers.
+///
+/// # Subtyping and Equality
+///
+/// `StructType` does not implement `Eq`, because reference types have a
+/// subtyping relationship, and so 99.99% of the time you actually want to check
+/// whether one type matches (i.e. is a subtype of) another type. You can use
+/// the [`StructType::matches`] method to perform these types of checks. If,
+/// however, you are in that 0.01% scenario where you need to check precise
+/// equality between types, you can use the [`StructType::eq`] method.
+//
+// TODO: Once we have struct values, update above docs with a reference to the
+// future `Struct::matches_ty` method
+#[derive(Debug, Clone, Hash)]
+pub struct StructType {
+    registered_type: RegisteredType,
+}
+
+impl fmt::Display for StructType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "(struct")?;
+        for field in self.fields() {
+            write!(f, " (field {field})")?;
+        }
+        write!(f, ")")?;
+        Ok(())
+    }
+}
+
+impl StructType {
+    /// Construct a new `StructType` with the given field types.
+    ///
+    /// This `StructType` will be final and without a supertype.
+    ///
+    /// The result will be associated with the given engine, and attempts to use
+    /// it with other engines will panic (for example, checking whether it is a
+    /// subtype of another struct type that is associated with a different
+    /// engine).
+    ///
+    /// Returns an error if the number of fields exceeds the implementation
+    /// limit.
+    ///
+    /// # Panics
+    ///
+    /// Panics if any given field type is not associated with the given engine.
+    pub fn new(engine: &Engine, fields: impl IntoIterator<Item = FieldType>) -> Result<Self> {
+        Self::with_finality_and_supertype(engine, Finality::Final, None, fields)
+    }
+
+    /// Construct a new `StructType` with the given finality, supertype, and
+    /// fields.
+    ///
+    /// The result will be associated with the given engine, and attempts to use
+    /// it with other engines will panic (for example, checking whether it is a
+    /// subtype of another struct type that is associated with a different
+    /// engine).
+    ///
+    /// Returns an error if the number of fields exceeds the implementation
+    /// limit, if the supertype is final, or if this type does not match the
+    /// supertype.
+    ///
+    /// # Panics
+    ///
+    /// Panics if any given field type is not associated with the given engine.
+    pub fn with_finality_and_supertype(
+        engine: &Engine,
+        finality: Finality,
+        supertype: Option<&Self>,
+        fields: impl IntoIterator<Item = FieldType>,
+    ) -> Result<Self> {
+        let fields = fields.into_iter();
+
+        let mut wasmtime_fields = Vec::with_capacity({
+            let size_hint = fields.size_hint();
+            let cap = size_hint.1.unwrap_or(size_hint.0);
+            // Only reserve space if we have a supertype, as that is the only time
+            // that this vec is used.
+            supertype.is_some() as usize * cap
+        });
+
+        // Same as in `FuncType::new`: we must prevent any `RegisteredType`s
+        // from being reclaimed while constructing this struct type.
+        let mut registrations = smallvec::SmallVec::<[_; 4]>::new();
+
+        let fields = fields
+            .map(|ty: FieldType| {
+                assert!(ty.comes_from_same_engine(engine));
+
+                if supertype.is_some() {
+                    wasmtime_fields.push(ty.clone());
+                }
+
+                if let Some(r) = ty.element_type.as_val_type().and_then(|v| v.as_ref()) {
+                    if let Some(r) = r.heap_type().as_registered_type() {
+                        registrations.push(r.clone());
+                    }
+                }
+
+                ty.to_wasm_field_type()
+            })
+            .collect();
+
+        if let Some(supertype) = supertype {
+            ensure!(
+                supertype.finality().is_non_final(),
+                "cannot create a subtype of a final supertype"
+            );
+            ensure!(
+                Self::fields_match(wasmtime_fields.into_iter(), supertype.fields()),
+                "struct fields must match their supertype's fields"
+            );
+        }
+
+        Self::from_wasm_struct_type(
+            engine,
+            finality.is_final(),
+            supertype.map(|ty| ty.type_index().into()),
+            WasmStructType { fields },
+        )
+    }
+
+    /// Get the engine that this struct type is associated with.
+    pub fn engine(&self) -> &Engine {
+        self.registered_type.engine()
+    }
+
+    /// Get the finality of this struct type.
+    pub fn finality(&self) -> Finality {
+        match self.registered_type.is_final {
+            true => Finality::Final,
+            false => Finality::NonFinal,
+        }
+    }
+
+    /// Get the supertype of this struct type, if any.
+    pub fn supertype(&self) -> Option<Self> {
+        self.registered_type
+            .supertype
+            .map(|ty| Self::from_shared_type_index(self.engine(), ty.unwrap_engine_type_index()))
+    }
+
+    /// Get the `i`th field type.
+    ///
+    /// Returns `None` if `i` is out of bounds.
+    pub fn field(&self, i: usize) -> Option<FieldType> {
+        let engine = self.engine();
+        self.as_wasm_struct_type()
+            .fields
+            .get(i)
+            .map(|ty| FieldType::from_wasm_field_type(engine, ty))
+    }
+
+    /// Returns the list of field types for this function.
+    #[inline]
+    pub fn fields(&self) -> impl ExactSizeIterator<Item = FieldType> + '_ {
+        let engine = self.engine();
+        self.as_wasm_struct_type()
+            .fields
+            .iter()
+            .map(|ty| FieldType::from_wasm_field_type(engine, ty))
+    }
+
+    /// Does this struct type match the other struct type?
+    ///
+    /// That is, is this function type a subtype of the other struct type?
+    ///
+    /// # Panics
+    ///
+    /// Panics if either type is associated with a different engine from the
+    /// other.
+    pub fn matches(&self, other: &StructType) -> bool {
+        assert!(self.comes_from_same_engine(other.engine()));
+
+        // Avoid matching on structure for subtyping checks when we have
+        // precisely the same type.
+        if self.type_index() == other.type_index() {
+            return true;
+        }
+
+        Self::fields_match(self.fields(), other.fields())
+    }
+
+    fn fields_match(
+        a: impl ExactSizeIterator<Item = FieldType>,
+        b: impl ExactSizeIterator<Item = FieldType>,
+    ) -> bool {
+        a.len() >= b.len() && a.zip(b).all(|(a, b)| a.matches(&b))
+    }
+
+    /// Is struct type `a` precisely equal to struct type `b`?
+    ///
+    /// Returns `false` even if `a` is a subtype of `b` or vice versa, if they
+    /// are not exactly the same struct type.
+    ///
+    /// # Panics
+    ///
+    /// Panics if either type is associated with a different engine from the
+    /// other.
+    pub fn eq(a: &StructType, b: &StructType) -> bool {
+        assert!(a.comes_from_same_engine(b.engine()));
+        a.type_index() == b.type_index()
+    }
+
+    pub(crate) fn comes_from_same_engine(&self, engine: &Engine) -> bool {
+        Engine::same(self.registered_type().engine(), engine)
+    }
+
+    pub(crate) fn type_index(&self) -> VMSharedTypeIndex {
+        self.registered_type().index()
+    }
+
+    pub(crate) fn as_wasm_struct_type(&self) -> &WasmStructType {
+        self.registered_type().unwrap_struct()
+    }
+
+    pub(crate) fn registered_type(&self) -> &RegisteredType {
+        &self.registered_type
+    }
+
+    /// Construct a `StructType` from a `WasmStructType`.
+    ///
+    /// This method should only be used when something has already registered --
+    /// and is *keeping registered* -- any other concrete Wasm types referenced
+    /// by the given `WasmStructType`.
+    ///
+    /// For example, this method may be called to convert an struct type from
+    /// within a Wasm module's `ModuleTypes` since the Wasm module itself is
+    /// holding a strong reference to all of its types, including any `(ref null
+    /// <index>)` types used as the element type for this struct type.
+    pub(crate) fn from_wasm_struct_type(
+        engine: &Engine,
+        is_final: bool,
+        supertype: Option<EngineOrModuleTypeIndex>,
+        ty: WasmStructType,
+    ) -> Result<StructType> {
+        const MAX_FIELDS: usize = 10_000;
+        let fields_len = ty.fields.len();
+        ensure!(
+            fields_len <= MAX_FIELDS,
+            "attempted to define a struct type with {fields_len} fields, but \
+             that is more than the maximum supported number of fields \
+             ({MAX_FIELDS})",
+        );
+
+        let ty = RegisteredType::new(
+            engine,
+            WasmSubType {
+                is_final,
+                supertype,
+                composite_type: WasmCompositeType::Struct(ty),
+            },
+        );
+        Ok(Self {
+            registered_type: ty,
+        })
+    }
+
+    pub(crate) fn from_shared_type_index(engine: &Engine, index: VMSharedTypeIndex) -> StructType {
+        let ty = RegisteredType::root(engine, index).expect(
+            "VMSharedTypeIndex is not registered in the Engine! Wrong \
+             engine? Didn't root the index somewhere?",
+        );
+        Self::from_registered_type(ty)
+    }
+
+    pub(crate) fn from_registered_type(registered_type: RegisteredType) -> Self {
+        debug_assert!(registered_type.is_struct());
+        Self { registered_type }
+    }
+}
+
+/// The type of a WebAssembly array.
+///
+/// WebAssembly arrays are dynamically-sized, but not resizable. They contain
+/// either unpacked [`Val`][crate::Val]s or packed 8-/16-bit integers.
+///
+/// # Subtyping and Equality
+///
+/// `ArrayType` does not implement `Eq`, because reference types have a
+/// subtyping relationship, and so 99.99% of the time you actually want to check
+/// whether one type matches (i.e. is a subtype of) another type. You can use
+/// the [`ArrayType::matches`] method to perform these types of checks. If,
+/// however, you are in that 0.01% scenario where you need to check precise
+/// equality between types, you can use the [`ArrayType::eq`] method.
+//
+// TODO: Once we have array values, update above docs with a reference to the
+// future `Array::matches_ty` method
+#[derive(Debug, Clone, Hash)]
+pub struct ArrayType {
+    registered_type: RegisteredType,
+}
+
+impl fmt::Display for ArrayType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let field_ty = self.field_type();
+        write!(f, "(array (field {field_ty}))")?;
+        Ok(())
+    }
+}
+
+impl ArrayType {
+    /// Construct a new `ArrayType` with the given field type's mutability and
+    /// storage type.
+    ///
+    /// The new `ArrayType` will be final and without a supertype.
+    ///
+    /// The result will be associated with the given engine, and attempts to use
+    /// it with other engines will panic (for example, checking whether it is a
+    /// subtype of another array type that is associated with a different
+    /// engine).
+    ///
+    /// # Panics
+    ///
+    /// Panics if the given field type is not associated with the given engine.
+    pub fn new(engine: &Engine, field_type: FieldType) -> Self {
+        Self::with_finality_and_supertype(engine, Finality::Final, None, field_type)
+            .expect("cannot fail without a supertype")
+    }
+
+    /// Construct a new `StructType` with the given finality, supertype, and
+    /// fields.
+    ///
+    /// The result will be associated with the given engine, and attempts to use
+    /// it with other engines will panic (for example, checking whether it is a
+    /// subtype of another struct type that is associated with a different
+    /// engine).
+    ///
+    /// Returns an error if the supertype is final, or if this type does not
+    /// match the supertype.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the given field type is not associated with the given engine.
+    pub fn with_finality_and_supertype(
+        engine: &Engine,
+        finality: Finality,
+        supertype: Option<&Self>,
+        field_type: FieldType,
+    ) -> Result<Self> {
+        if let Some(supertype) = supertype {
+            assert!(supertype.comes_from_same_engine(engine));
+            ensure!(
+                supertype.finality().is_non_final(),
+                "cannot create a subtype of a final supertype"
+            );
+            ensure!(
+                field_type.matches(&supertype.field_type()),
+                "array field type must match its supertype's field type"
+            );
+        }
+
+        // Same as in `FuncType::new`: we must prevent any `RegisteredType` in
+        // `field_type` from being reclaimed while constructing this array type.
+        let _registration = field_type
+            .element_type
+            .as_val_type()
+            .and_then(|v| v.as_ref())
+            .and_then(|r| r.heap_type().as_registered_type());
+
+        assert!(field_type.comes_from_same_engine(engine));
+        let wasm_ty = WasmArrayType(field_type.to_wasm_field_type());
+
+        Ok(Self::from_wasm_array_type(
+            engine,
+            finality.is_final(),
+            supertype.map(|ty| ty.type_index().into()),
+            wasm_ty,
+        ))
+    }
+
+    /// Get the engine that this array type is associated with.
+    pub fn engine(&self) -> &Engine {
+        self.registered_type.engine()
+    }
+
+    /// Get the finality of this array type.
+    pub fn finality(&self) -> Finality {
+        match self.registered_type.is_final {
+            true => Finality::Final,
+            false => Finality::NonFinal,
+        }
+    }
+
+    /// Get the supertype of this array type, if any.
+    pub fn supertype(&self) -> Option<Self> {
+        self.registered_type
+            .supertype
+            .map(|ty| Self::from_shared_type_index(self.engine(), ty.unwrap_engine_type_index()))
+    }
+
+    /// Get this array's underlying field type.
+    ///
+    /// The field type contains information about both this array type's
+    /// mutability and the storage type used for its elements.
+    pub fn field_type(&self) -> FieldType {
+        FieldType::from_wasm_field_type(self.engine(), &self.as_wasm_array_type().0)
+    }
+
+    /// Get this array type's mutability and whether its instances' elements can
+    /// be updated or not.
+    ///
+    /// This is a convenience method providing a short-hand for
+    /// `my_array_type.field_type().mutability()`.
+    pub fn mutability(&self) -> Mutability {
+        if self.as_wasm_array_type().0.mutable {
+            Mutability::Var
+        } else {
+            Mutability::Const
+        }
+    }
+
+    /// Get the storage type used for this array type's elements.
+    ///
+    /// This is a convenience method providing a short-hand for
+    /// `my_array_type.field_type().element_type()`.
+    pub fn element_type(&self) -> StorageType {
+        StorageType::from_wasm_storage_type(
+            self.engine(),
+            &self.registered_type.unwrap_array().0.element_type,
+        )
+    }
+
+    /// Does this array type match the other array type?
+    ///
+    /// That is, is this function type a subtype of the other array type?
+    ///
+    /// # Panics
+    ///
+    /// Panics if either type is associated with a different engine from the
+    /// other.
+    pub fn matches(&self, other: &ArrayType) -> bool {
+        assert!(self.comes_from_same_engine(other.engine()));
+
+        // Avoid matching on structure for subtyping checks when we have
+        // precisely the same type.
+        if self.type_index() == other.type_index() {
+            return true;
+        }
+
+        self.field_type().matches(&other.field_type())
+    }
+
+    /// Is array type `a` precisely equal to array type `b`?
+    ///
+    /// Returns `false` even if `a` is a subtype of `b` or vice versa, if they
+    /// are not exactly the same array type.
+    ///
+    /// # Panics
+    ///
+    /// Panics if either type is associated with a different engine from the
+    /// other.
+    pub fn eq(a: &ArrayType, b: &ArrayType) -> bool {
+        assert!(a.comes_from_same_engine(b.engine()));
+        a.type_index() == b.type_index()
+    }
+
+    pub(crate) fn comes_from_same_engine(&self, engine: &Engine) -> bool {
+        Engine::same(self.registered_type.engine(), engine)
+    }
+
+    pub(crate) fn registered_type(&self) -> &RegisteredType {
+        &self.registered_type
+    }
+
+    pub(crate) fn type_index(&self) -> VMSharedTypeIndex {
+        self.registered_type.index()
+    }
+
+    pub(crate) fn as_wasm_array_type(&self) -> &WasmArrayType {
+        self.registered_type.unwrap_array()
+    }
+
+    /// Construct a `ArrayType` from a `WasmArrayType`.
+    ///
+    /// This method should only be used when something has already registered --
+    /// and is *keeping registered* -- any other concrete Wasm types referenced
+    /// by the given `WasmArrayType`.
+    ///
+    /// For example, this method may be called to convert an array type from
+    /// within a Wasm module's `ModuleTypes` since the Wasm module itself is
+    /// holding a strong reference to all of its types, including any `(ref null
+    /// <index>)` types used as the element type for this array type.
+    pub(crate) fn from_wasm_array_type(
+        engine: &Engine,
+        is_final: bool,
+        supertype: Option<EngineOrModuleTypeIndex>,
+        ty: WasmArrayType,
+    ) -> ArrayType {
+        let ty = RegisteredType::new(
+            engine,
+            WasmSubType {
+                is_final,
+                supertype,
+                composite_type: WasmCompositeType::Array(ty),
+            },
+        );
+        Self {
+            registered_type: ty,
+        }
+    }
+
+    pub(crate) fn from_shared_type_index(engine: &Engine, index: VMSharedTypeIndex) -> ArrayType {
+        let ty = RegisteredType::root(engine, index).expect(
+            "VMSharedTypeIndex is not registered in the Engine! Wrong \
+             engine? Didn't root the index somewhere?",
+        );
+        Self::from_registered_type(ty)
+    }
+
+    pub(crate) fn from_registered_type(registered_type: RegisteredType) -> Self {
+        debug_assert!(registered_type.is_array());
+        Self { registered_type }
+    }
+}
+
+/// The type of a WebAssembly function.
+///
+/// WebAssembly functions can have 0 or more parameters and results.
+///
+/// # Subtyping and Equality
+///
+/// `FuncType` does not implement `Eq`, because reference types have a subtyping
+/// relationship, and so 99.99% of the time you actually want to check whether
+/// one type matches (i.e. is a subtype of) another type. You can use the
+/// [`FuncType::matches`] and [`Func::matches_ty`][crate::Func::matches_ty]
+/// methods to perform these types of checks. If, however, you are in that 0.01%
+/// scenario where you need to check precise equality between types, you can use
+/// the [`FuncType::eq`] method.
+#[derive(Debug, Clone, Hash)]
+pub struct FuncType {
+    registered_type: RegisteredType,
+}
+
+impl Display for FuncType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "(type (func")?;
+        if self.params().len() > 0 {
+            write!(f, " (param")?;
+            for p in self.params() {
+                write!(f, " {p}")?;
+            }
+            write!(f, ")")?;
+        }
+        if self.results().len() > 0 {
+            write!(f, " (result")?;
+            for r in self.results() {
+                write!(f, " {r}")?;
+            }
+            write!(f, ")")?;
+        }
+        write!(f, "))")
+    }
+}
+
+impl FuncType {
+    /// Creates a new function type from the given parameters and results.
+    ///
+    /// The function type returned will represent a function which takes
+    /// `params` as arguments and returns `results` when it is finished.
+    ///
+    /// The resulting function type will be final and without a supertype.
+    ///
+    /// # Panics
+    ///
+    /// Panics if any parameter or value type is not associated with the given
+    /// engine.
+    pub fn new(
+        engine: &Engine,
+        params: impl IntoIterator<Item = ValType>,
+        results: impl IntoIterator<Item = ValType>,
+    ) -> FuncType {
+        Self::with_finality_and_supertype(engine, Finality::Final, None, params, results)
+            .expect("cannot fail without a supertype")
+    }
+
+    /// Create a new function type with the given finality, supertype, parameter
+    /// types, and result types.
+    ///
+    /// Returns an error if the supertype is final, or if this function type
+    /// does not match the supertype.
+    ///
+    /// # Panics
+    ///
+    /// Panics if any parameter or value type is not associated with the given
+    /// engine.
+    pub fn with_finality_and_supertype(
+        engine: &Engine,
+        finality: Finality,
+        supertype: Option<&Self>,
+        params: impl IntoIterator<Item = ValType>,
+        results: impl IntoIterator<Item = ValType>,
+    ) -> Result<Self> {
+        let params = params.into_iter();
+        let results = results.into_iter();
+
+        let mut wasmtime_params = Vec::with_capacity({
+            let size_hint = params.size_hint();
+            let cap = size_hint.1.unwrap_or(size_hint.0);
+            // Only reserve space if we have a supertype, as that is the only time
+            // that this vec is used.
+            supertype.is_some() as usize * cap
+        });
+
+        let mut wasmtime_results = Vec::with_capacity({
+            let size_hint = results.size_hint();
+            let cap = size_hint.1.unwrap_or(size_hint.0);
+            // Same as above.
+            supertype.is_some() as usize * cap
+        });
+
+        // Keep any of our parameters' and results' `RegisteredType`s alive
+        // across `Self::from_wasm_func_type`. If one of our given `ValType`s is
+        // the only thing keeping a type in the registry, we don't want to
+        // unregister it when we convert the `ValType` into a `WasmValType` just
+        // before we register our new `WasmFuncType` that will reference it.
+        let mut registrations = smallvec::SmallVec::<[_; 4]>::new();
+
+        let mut to_wasm_type = |ty: ValType, vec: &mut Vec<_>| {
+            assert!(ty.comes_from_same_engine(engine));
+
+            if supertype.is_some() {
+                vec.push(ty.clone());
+            }
+
+            if let Some(r) = ty.as_ref() {
+                if let Some(r) = r.heap_type().as_registered_type() {
+                    registrations.push(r.clone());
+                }
+            }
+
+            ty.to_wasm_type()
+        };
+
+        let wasm_func_ty = WasmFuncType::new(
+            params
+                .map(|p| to_wasm_type(p, &mut wasmtime_params))
+                .collect(),
+            results
+                .map(|r| to_wasm_type(r, &mut wasmtime_results))
+                .collect(),
+        );
+
+        if let Some(supertype) = supertype {
+            assert!(supertype.comes_from_same_engine(engine));
+            ensure!(
+                supertype.finality().is_non_final(),
+                "cannot create a subtype of a final supertype"
+            );
+            ensure!(
+                Self::matches_impl(
+                    wasmtime_params.iter().cloned(),
+                    supertype.params(),
+                    wasmtime_results.iter().cloned(),
+                    supertype.results()
+                ),
+                "function type must match its supertype: found (func{params}{results}), expected \
+                 {supertype}",
+                params = if wasmtime_params.is_empty() {
+                    String::new()
+                } else {
+                    let mut s = format!(" (params");
+                    for p in &wasmtime_params {
+                        write!(&mut s, " {p}").unwrap();
+                    }
+                    s.push(')');
+                    s
+                },
+                results = if wasmtime_results.is_empty() {
+                    String::new()
+                } else {
+                    let mut s = format!(" (results");
+                    for r in &wasmtime_results {
+                        write!(&mut s, " {r}").unwrap();
+                    }
+                    s.push(')');
+                    s
+                },
+            );
+        }
+
+        Ok(Self::from_wasm_func_type(
+            engine,
+            finality.is_final(),
+            supertype.map(|ty| ty.type_index().into()),
+            wasm_func_ty,
+        ))
+    }
+
+    /// Get the engine that this function type is associated with.
+    pub fn engine(&self) -> &Engine {
+        self.registered_type.engine()
+    }
+
+    /// Get the finality of this function type.
+    pub fn finality(&self) -> Finality {
+        match self.registered_type.is_final {
+            true => Finality::Final,
+            false => Finality::NonFinal,
+        }
+    }
+
+    /// Get the supertype of this function type, if any.
+    pub fn supertype(&self) -> Option<Self> {
+        self.registered_type
+            .supertype
+            .map(|ty| Self::from_shared_type_index(self.engine(), ty.unwrap_engine_type_index()))
+    }
+
+    /// Get the `i`th parameter type.
+    ///
+    /// Returns `None` if `i` is out of bounds.
+    pub fn param(&self, i: usize) -> Option<ValType> {
+        let engine = self.engine();
+        self.registered_type
+            .unwrap_func()
+            .params()
+            .get(i)
+            .map(|ty| ValType::from_wasm_type(engine, ty))
+    }
+
+    /// Returns the list of parameter types for this function.
+    #[inline]
+    pub fn params(&self) -> impl ExactSizeIterator<Item = ValType> + '_ {
+        let engine = self.engine();
+        self.registered_type
+            .unwrap_func()
+            .params()
+            .iter()
+            .map(|ty| ValType::from_wasm_type(engine, ty))
+    }
+
+    /// Get the `i`th result type.
+    ///
+    /// Returns `None` if `i` is out of bounds.
+    pub fn result(&self, i: usize) -> Option<ValType> {
+        let engine = self.engine();
+        self.registered_type
+            .unwrap_func()
+            .returns()
+            .get(i)
+            .map(|ty| ValType::from_wasm_type(engine, ty))
+    }
+
+    /// Returns the list of result types for this function.
+    #[inline]
+    pub fn results(&self) -> impl ExactSizeIterator<Item = ValType> + '_ {
+        let engine = self.engine();
+        self.registered_type
+            .unwrap_func()
+            .returns()
+            .iter()
+            .map(|ty| ValType::from_wasm_type(engine, ty))
+    }
+
+    /// Does this function type match the other function type?
+    ///
+    /// That is, is this function type a subtype of the other function type?
+    ///
+    /// # Panics
+    ///
+    /// Panics if either type is associated with a different engine from the
+    /// other.
+    pub fn matches(&self, other: &FuncType) -> bool {
+        assert!(self.comes_from_same_engine(other.engine()));
+
+        // Avoid matching on structure for subtyping checks when we have
+        // precisely the same type.
+        if self.type_index() == other.type_index() {
+            return true;
+        }
+
+        Self::matches_impl(
+            self.params(),
+            other.params(),
+            self.results(),
+            other.results(),
+        )
+    }
+
+    fn matches_impl(
+        a_params: impl ExactSizeIterator<Item = ValType>,
+        b_params: impl ExactSizeIterator<Item = ValType>,
+        a_results: impl ExactSizeIterator<Item = ValType>,
+        b_results: impl ExactSizeIterator<Item = ValType>,
+    ) -> bool {
+        a_params.len() == b_params.len()
+            && a_results.len() == b_results.len()
+            // Params are contravariant and results are covariant. For more
+            // details and a refresher on variance, read
+            // https://github.com/bytecodealliance/wasm-tools/blob/f1d89a4/crates/wasmparser/src/readers/core/types/matches.rs#L137-L174
+            && a_params
+                .zip(b_params)
+                .all(|(a, b)| b.matches(&a))
+            && a_results
+                .zip(b_results)
+                .all(|(a, b)| a.matches(&b))
+    }
+
+    /// Is function type `a` precisely equal to function type `b`?
+    ///
+    /// Returns `false` even if `a` is a subtype of `b` or vice versa, if they
+    /// are not exactly the same function type.
+    ///
+    /// # Panics
+    ///
+    /// Panics if either type is associated with a different engine from the
+    /// other.
+    pub fn eq(a: &FuncType, b: &FuncType) -> bool {
+        assert!(a.comes_from_same_engine(b.engine()));
+        a.type_index() == b.type_index()
+    }
+
+    pub(crate) fn comes_from_same_engine(&self, engine: &Engine) -> bool {
+        Engine::same(self.registered_type.engine(), engine)
+    }
+
+    pub(crate) fn type_index(&self) -> VMSharedTypeIndex {
+        self.registered_type.index()
+    }
+
+    pub(crate) fn as_wasm_func_type(&self) -> &WasmFuncType {
+        self.registered_type.unwrap_func()
+    }
+
+    pub(crate) fn into_registered_type(self) -> RegisteredType {
+        self.registered_type
+    }
+
+    /// Construct a `FuncType` from a `WasmFuncType`.
+    ///
+    /// This method should only be used when something has already registered --
+    /// and is *keeping registered* -- any other concrete Wasm types referenced
+    /// by the given `WasmFuncType`.
+    ///
+    /// For example, this method may be called to convert a function type from
+    /// within a Wasm module's `ModuleTypes` since the Wasm module itself is
+    /// holding a strong reference to all of its types, including any `(ref null
+    /// <index>)` types used in the function's parameters and results.
+    pub(crate) fn from_wasm_func_type(
+        engine: &Engine,
+        is_final: bool,
+        supertype: Option<EngineOrModuleTypeIndex>,
+        ty: WasmFuncType,
+    ) -> FuncType {
+        let ty = RegisteredType::new(
+            engine,
+            WasmSubType {
+                is_final,
+                supertype,
+                composite_type: WasmCompositeType::Func(ty),
+            },
+        );
+        Self {
+            registered_type: ty,
+        }
+    }
+
+    pub(crate) fn from_shared_type_index(engine: &Engine, index: VMSharedTypeIndex) -> FuncType {
+        let ty = RegisteredType::root(engine, index).expect(
+            "VMSharedTypeIndex is not registered in the Engine! Wrong \
+             engine? Didn't root the index somewhere?",
+        );
+        Self::from_registered_type(ty)
+    }
+
+    pub(crate) fn from_registered_type(registered_type: RegisteredType) -> Self {
+        debug_assert!(registered_type.is_func());
+        Self { registered_type }
+    }
+}
+
+// Global Types
+
+/// A WebAssembly global descriptor.
+///
+/// This type describes an instance of a global in a WebAssembly module. Globals
+/// are local to an [`Instance`](crate::Instance) and are either immutable or
+/// mutable.
+#[derive(Debug, Clone, Hash)]
+pub struct GlobalType {
+    content: ValType,
+    mutability: Mutability,
+}
+
+impl GlobalType {
+    /// Creates a new global descriptor of the specified `content` type and
+    /// whether or not it's mutable.
+    pub fn new(content: ValType, mutability: Mutability) -> GlobalType {
+        GlobalType {
+            content,
+            mutability,
+        }
+    }
+
+    /// Returns the value type of this global descriptor.
+    pub fn content(&self) -> &ValType {
+        &self.content
+    }
+
+    /// Returns whether or not this global is mutable.
+    pub fn mutability(&self) -> Mutability {
+        self.mutability
+    }
+
+    pub(crate) fn to_wasm_type(&self) -> Global {
+        let wasm_ty = self.content().to_wasm_type();
+        let mutability = matches!(self.mutability(), Mutability::Var);
+        Global {
+            wasm_ty,
+            mutability,
+        }
+    }
+
+    /// Returns `None` if the wasmtime global has a type that we can't
+    /// represent, but that should only very rarely happen and indicate a bug.
+    pub(crate) fn from_wasmtime_global(engine: &Engine, global: &Global) -> GlobalType {
+        let ty = ValType::from_wasm_type(engine, &global.wasm_ty);
+        let mutability = if global.mutability {
+            Mutability::Var
+        } else {
+            Mutability::Const
+        };
+        GlobalType::new(ty, mutability)
+    }
+}
+
+// Table Types
+
+/// A descriptor for a table in a WebAssembly module.
+///
+/// Tables are contiguous chunks of a specific element, typically a `funcref` or
+/// an `externref`. The most common use for tables is a function table through
+/// which `call_indirect` can invoke other functions.
+#[derive(Debug, Clone, Hash)]
+pub struct TableType {
+    // Keep a `wasmtime::RefType` so that `TableType::element` doesn't need to
+    // take an `&Engine`.
+    element: RefType,
+    ty: Table,
+}
+
+impl TableType {
+    /// Creates a new table descriptor which will contain the specified
+    /// `element` and have the `limits` applied to its length.
+    pub fn new(element: RefType, min: u32, max: Option<u32>) -> TableType {
+        let wasm_ty = element.to_wasm_type();
+
+        debug_assert!(
+            wasm_ty.is_canonicalized_for_runtime_usage(),
+            "should be canonicalized for runtime usage: {wasm_ty:?}"
+        );
+
+        TableType {
+            element,
+            ty: Table {
+                wasm_ty,
+                minimum: min,
+                maximum: max,
+            },
+        }
+    }
+
+    /// Returns the element value type of this table.
+    pub fn element(&self) -> &RefType {
+        &self.element
+    }
+
+    /// Returns minimum number of elements this table must have
+    pub fn minimum(&self) -> u32 {
+        self.ty.minimum
+    }
+
+    /// Returns the optionally-specified maximum number of elements this table
+    /// can have.
+    ///
+    /// If this returns `None` then the table is not limited in size.
+    pub fn maximum(&self) -> Option<u32> {
+        self.ty.maximum
+    }
+
+    pub(crate) fn from_wasmtime_table(engine: &Engine, table: &Table) -> TableType {
+        let element = RefType::from_wasm_type(engine, &table.wasm_ty);
+        TableType {
+            element,
+            ty: *table,
+        }
+    }
+
+    pub(crate) fn wasmtime_table(&self) -> &Table {
+        &self.ty
+    }
+}
+
+// Memory Types
+
+/// A builder for [`MemoryType`][crate::MemoryType]s.
+///
+/// A new builder can be constructed via its `Default` implementation.
+///
+/// When you're done configuring, get the underlying
+/// [`MemoryType`][crate::MemoryType] by calling the
+/// [`build`][crate::MemoryTypeBuilder::build] method.
+///
+/// # Example
+///
+/// ```
+/// # fn foo() -> wasmtime::Result<()> {
+/// use wasmtime::MemoryTypeBuilder;
+///
+/// let memory_type = MemoryTypeBuilder::default()
+///     // Set the minimum size, in pages.
+///     .min(4096)
+///     // Set the maximum size, in pages.
+///     .max(Some(4096))
+///     // Set the page size to 1 byte (aka 2**0).
+///     .page_size_log2(0)
+///     // Get the underlying memory type.
+///     .build()?;
+/// #   Ok(())
+/// # }
+/// ```
+pub struct MemoryTypeBuilder {
+    ty: Memory,
+}
+
+impl Default for MemoryTypeBuilder {
+    fn default() -> Self {
+        MemoryTypeBuilder {
+            ty: Memory {
+                minimum: 0,
+                maximum: None,
+                shared: false,
+                memory64: false,
+                page_size_log2: Memory::DEFAULT_PAGE_SIZE_LOG2,
+            },
+        }
+    }
+}
+
+impl MemoryTypeBuilder {
+    fn validate(&self) -> Result<()> {
+        if self.ty.maximum.map_or(false, |max| max < self.ty.minimum) {
+            bail!("maximum page size cannot be smaller than the minimum page size");
+        }
+
+        match self.ty.page_size_log2 {
+            0 | Memory::DEFAULT_PAGE_SIZE_LOG2 => {}
+            x => bail!(
+                "page size must be 2**16 or 2**0, but was given 2**{x}; note \
+                 that future Wasm extensions might allow any power of two page \
+                 size, but only 2**16 and 2**0 are currently valid",
+            ),
+        }
+
+        if self.ty.shared && self.ty.maximum.is_none() {
+            bail!("shared memories must have a maximum size");
+        }
+
+        let absolute_max = self.ty.max_size_based_on_index_type();
+        let min = self
+            .ty
+            .minimum_byte_size()
+            .err2anyhow()
+            .context("memory's minimum byte size must fit in a u64")?;
+        if min > absolute_max {
+            bail!("minimum size is too large for this memory type's index type");
+        }
+        if self
+            .ty
+            .maximum_byte_size()
+            .map_or(false, |max| max > absolute_max)
+        {
+            bail!("maximum size is too large for this memory type's index type");
+        }
+
+        Ok(())
+    }
+
+    /// Set the minimum size, in units of pages, for the memory type being
+    /// built.
+    ///
+    /// The default minimum is `0`.
+    pub fn min(&mut self, minimum: u64) -> &mut Self {
+        self.ty.minimum = minimum;
+        self
+    }
+
+    /// Set the maximum size, in units of pages, for the memory type being
+    /// built.
+    ///
+    /// The default maximum is `None`.
+    pub fn max(&mut self, maximum: Option<u64>) -> &mut Self {
+        self.ty.maximum = maximum;
+        self
+    }
+
+    /// Set whether this is a 64-bit memory or not.
+    ///
+    /// If a memory is not a 64-bit memory, then it is a 32-bit memory.
+    ///
+    /// The default is `false`, aka 32-bit memories.
+    ///
+    /// Note that 64-bit memories are part of [the memory64
+    /// proposal](https://github.com/WebAssembly/memory64) for WebAssembly which
+    /// is not fully standardized yet.
+    pub fn memory64(&mut self, memory64: bool) -> &mut Self {
+        self.ty.memory64 = memory64;
+        self
+    }
+
+    /// Set the sharedness for the memory type being built.
+    ///
+    /// The default is `false`, aka unshared.
+    ///
+    /// Note that shared memories are part of [the threads
+    /// proposal](https://github.com/WebAssembly/threads) for WebAssembly which
+    /// is not fully standardized yet.
+    pub fn shared(&mut self, shared: bool) -> &mut Self {
+        self.ty.shared = shared;
+        self
+    }
+
+    /// Set the log base 2 of the page size, in bytes, for the memory type being
+    /// built.
+    ///
+    /// The default value is `16`, which results in the default Wasm page size
+    /// of 64KiB (aka 2<sup>16</sup> or 65536).
+    ///
+    /// Other than `16`, the only valid value is `0`, which results in a page
+    /// size of one byte (aka 2<sup>0</sup>). Single-byte page sizes can be used
+    /// to get fine-grained control over a Wasm memory's resource consumption
+    /// and run Wasm in embedded environments with less than 64KiB of RAM, for
+    /// example.
+    ///
+    /// Future extensions to the core WebAssembly language might relax these
+    /// constraints and introduce more valid page sizes, such as any power of
+    /// two between 1 and 65536 inclusive.
+    ///
+    /// Note that non-default page sizes are part of [the custom-page-sizes
+    /// proposal](https://github.com/WebAssembly/custom-page-sizes) for
+    /// WebAssembly which is not fully standardized yet.
+    pub fn page_size_log2(&mut self, page_size_log2: u8) -> &mut Self {
+        self.ty.page_size_log2 = page_size_log2;
+        self
+    }
+
+    /// Get the underlying memory type that this builder has been building.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the configured memory type is invalid, for example
+    /// if the maximum size is smaller than the minimum size.
+    pub fn build(&self) -> Result<MemoryType> {
+        self.validate()?;
+        Ok(MemoryType { ty: self.ty })
+    }
+}
+
+/// A descriptor for a WebAssembly memory type.
+///
+/// Memories are described in units of pages (64KB) and represent contiguous
+/// chunks of addressable memory.
+#[derive(Debug, Clone, Hash, Eq, PartialEq)]
+pub struct MemoryType {
+    ty: Memory,
+}
+
+impl MemoryType {
+    /// Creates a new descriptor for a 32-bit WebAssembly memory given the
+    /// specified limits of the memory.
+    ///
+    /// The `minimum` and `maximum` values here are specified in units of
+    /// WebAssembly pages, which are 64KiB by default. Use
+    /// [`MemoryTypeBuilder`][crate::MemoryTypeBuilder] if you want a
+    /// non-default page size.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the minimum is greater than the maximum or if the minimum or
+    /// maximum number of pages can result in a byte size that is not
+    /// addressable with a 32-bit integer.
+    pub fn new(minimum: u32, maximum: Option<u32>) -> MemoryType {
+        MemoryTypeBuilder::default()
+            .min(minimum.into())
+            .max(maximum.map(Into::into))
+            .build()
+            .unwrap()
+    }
+
+    /// Creates a new descriptor for a 64-bit WebAssembly memory given the
+    /// specified limits of the memory.
+    ///
+    /// The `minimum` and `maximum` values here are specified in units of
+    /// WebAssembly pages, which are 64KiB by default. Use
+    /// [`MemoryTypeBuilder`][crate::MemoryTypeBuilder] if you want a
+    /// non-default page size.
+    ///
+    /// Note that 64-bit memories are part of [the memory64
+    /// proposal](https://github.com/WebAssembly/memory64) for WebAssembly which
+    /// is not fully standardized yet.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the minimum is greater than the maximum or if the minimum or
+    /// maximum number of pages can result in a byte size that is not
+    /// addressable with a 64-bit integer.
+    pub fn new64(minimum: u64, maximum: Option<u64>) -> MemoryType {
+        MemoryTypeBuilder::default()
+            .memory64(true)
+            .min(minimum)
+            .max(maximum)
+            .build()
+            .unwrap()
+    }
+
+    /// Creates a new descriptor for shared WebAssembly memory given the
+    /// specified limits of the memory.
+    ///
+    /// The `minimum` and `maximum` values here are specified in units of
+    /// WebAssembly pages, which are 64KiB by default. Use
+    /// [`MemoryTypeBuilder`][crate::MemoryTypeBuilder] if you want a
+    /// non-default page size.
+    ///
+    /// Note that shared memories are part of [the threads
+    /// proposal](https://github.com/WebAssembly/threads) for WebAssembly which
+    /// is not fully standardized yet.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the minimum is greater than the maximum or if the minimum or
+    /// maximum number of pages can result in a byte size that is not
+    /// addressable with a 32-bit integer.
+    pub fn shared(minimum: u32, maximum: u32) -> MemoryType {
+        MemoryTypeBuilder::default()
+            .shared(true)
+            .min(minimum.into())
+            .max(Some(maximum.into()))
+            .build()
+            .unwrap()
+    }
+
+    /// Returns whether this is a 64-bit memory or not.
+    ///
+    /// Note that 64-bit memories are part of the memory64 proposal for
+    /// WebAssembly which is not standardized yet.
+    pub fn is_64(&self) -> bool {
+        self.ty.memory64
+    }
+
+    /// Returns whether this is a shared memory or not.
+    ///
+    /// Note that shared memories are part of the threads proposal for
+    /// WebAssembly which is not standardized yet.
+    pub fn is_shared(&self) -> bool {
+        self.ty.shared
+    }
+
+    /// Returns minimum number of WebAssembly pages this memory must have.
+    ///
+    /// Note that the return value, while a `u64`, will always fit into a `u32`
+    /// for 32-bit memories.
+    pub fn minimum(&self) -> u64 {
+        self.ty.minimum
+    }
+
+    /// Returns the optionally-specified maximum number of pages this memory
+    /// can have.
+    ///
+    /// If this returns `None` then the memory is not limited in size.
+    ///
+    /// Note that the return value, while a `u64`, will always fit into a `u32`
+    /// for 32-bit memories.
+    pub fn maximum(&self) -> Option<u64> {
+        self.ty.maximum
+    }
+
+    /// This memory's page size, in bytes.
+    pub fn page_size(&self) -> u64 {
+        self.ty.page_size()
+    }
+
+    /// The log2 of this memory's page size, in bytes.
+    pub fn page_size_log2(&self) -> u8 {
+        self.ty.page_size_log2
+    }
+
+    pub(crate) fn from_wasmtime_memory(memory: &Memory) -> MemoryType {
+        MemoryType { ty: *memory }
+    }
+
+    pub(crate) fn wasmtime_memory(&self) -> &Memory {
+        &self.ty
+    }
+}
+
+// Import Types
+
+/// A descriptor for an imported value into a wasm module.
+///
+/// This type is primarily accessed from the
+/// [`Module::imports`](crate::Module::imports) API. Each [`ImportType`]
+/// describes an import into the wasm module with the module/name that it's
+/// imported from as well as the type of item that's being imported.
+#[derive(Clone)]
+pub struct ImportType<'module> {
+    /// The module of the import.
+    module: &'module str,
+
+    /// The field of the import.
+    name: &'module str,
+
+    /// The type of the import.
+    ty: EntityType,
+    types: &'module ModuleTypes,
+    engine: &'module Engine,
+}
+
+impl<'module> ImportType<'module> {
+    /// Creates a new import descriptor which comes from `module` and `name` and
+    /// is of type `ty`.
+    pub(crate) fn new(
+        module: &'module str,
+        name: &'module str,
+        ty: EntityType,
+        types: &'module ModuleTypes,
+        engine: &'module Engine,
+    ) -> ImportType<'module> {
+        assert!(ty.is_canonicalized_for_runtime_usage());
+        ImportType {
+            module,
+            name,
+            ty,
+            types,
+            engine,
+        }
+    }
+
+    /// Returns the module name that this import is expected to come from.
+    pub fn module(&self) -> &'module str {
+        self.module
+    }
+
+    /// Returns the field name of the module that this import is expected to
+    /// come from.
+    pub fn name(&self) -> &'module str {
+        self.name
+    }
+
+    /// Returns the expected type of this import.
+    pub fn ty(&self) -> ExternType {
+        ExternType::from_wasmtime(self.engine, self.types, &self.ty)
+    }
+}
+
+impl<'module> fmt::Debug for ImportType<'module> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ImportType")
+            .field("module", &self.module())
+            .field("name", &self.name())
+            .field("ty", &self.ty())
+            .finish()
+    }
+}
+
+// Export Types
+
+/// A descriptor for an exported WebAssembly value.
+///
+/// This type is primarily accessed from the
+/// [`Module::exports`](crate::Module::exports) accessor and describes what
+/// names are exported from a wasm module and the type of the item that is
+/// exported.
+#[derive(Clone)]
+pub struct ExportType<'module> {
+    /// The name of the export.
+    name: &'module str,
+
+    /// The type of the export.
+    ty: EntityType,
+    types: &'module ModuleTypes,
+    engine: &'module Engine,
+}
+
+impl<'module> ExportType<'module> {
+    /// Creates a new export which is exported with the given `name` and has the
+    /// given `ty`.
+    pub(crate) fn new(
+        name: &'module str,
+        ty: EntityType,
+        types: &'module ModuleTypes,
+        engine: &'module Engine,
+    ) -> ExportType<'module> {
+        ExportType {
+            name,
+            ty,
+            types,
+            engine,
+        }
+    }
+
+    /// Returns the name by which this export is known.
+    pub fn name(&self) -> &'module str {
+        self.name
+    }
+
+    /// Returns the type of this export.
+    pub fn ty(&self) -> ExternType {
+        ExternType::from_wasmtime(self.engine, self.types, &self.ty)
+    }
+}
+
+impl<'module> fmt::Debug for ExportType<'module> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("ExportType")
+            .field("name", &self.name().to_owned())
+            .field("ty", &self.ty())
+            .finish()
+    }
+}
diff --git a/crates/wasmtime/src/runtime/types/matching.rs b/crates/wasmtime/src/runtime/types/matching.rs
new file mode 100644
index 000000000000..3d675dc67c7c
--- /dev/null
+++ b/crates/wasmtime/src/runtime/types/matching.rs
@@ -0,0 +1,390 @@
+use crate::type_registry::RegisteredType;
+use crate::{linker::DefinitionType, Engine, FuncType};
+use crate::{prelude::*, ArrayType, StructType};
+use wasmtime_environ::{
+    EntityType, Global, Memory, ModuleTypes, Table, TypeTrace, VMSharedTypeIndex, WasmHeapType,
+    WasmRefType, WasmSubType, WasmValType,
+};
+
+pub struct MatchCx<'a> {
+    engine: &'a Engine,
+}
+
+impl MatchCx<'_> {
+    /// Construct a new matching context for the given module.
+    pub fn new(engine: &Engine) -> MatchCx<'_> {
+        MatchCx { engine }
+    }
+
+    fn type_reference(&self, expected: VMSharedTypeIndex, actual: VMSharedTypeIndex) -> Result<()> {
+        // Avoid matching on structure for subtyping checks when we have
+        // precisely the same type.
+        let matches = expected == actual || {
+            let expected = RegisteredType::root(self.engine, expected).unwrap();
+            let actual = RegisteredType::root(self.engine, actual).unwrap();
+            if expected.is_array() && actual.is_array() {
+                let expected = ArrayType::from_registered_type(expected);
+                let actual = ArrayType::from_registered_type(actual);
+                actual.matches(&expected)
+            } else if expected.is_func() && actual.is_func() {
+                let expected = FuncType::from_registered_type(expected);
+                let actual = FuncType::from_registered_type(actual);
+                actual.matches(&expected)
+            } else if expected.is_struct() && actual.is_struct() {
+                let expected = StructType::from_registered_type(expected);
+                let actual = StructType::from_registered_type(actual);
+                actual.matches(&expected)
+            } else {
+                false
+            }
+        };
+        if matches {
+            return Ok(());
+        }
+        let msg = "types incompatible";
+        let expected = match self.engine.signatures().borrow(expected) {
+            Some(ty) => ty,
+            None => panic!("{expected:?} is not registered"),
+        };
+        let actual = match self.engine.signatures().borrow(actual) {
+            Some(ty) => ty,
+            None => panic!("{actual:?} is not registered"),
+        };
+
+        Err(concrete_type_mismatch(msg, &expected, &actual))
+    }
+
+    /// Validates that the `expected` type matches the type of `actual`
+    pub(crate) fn definition(&self, expected: &EntityType, actual: &DefinitionType) -> Result<()> {
+        match expected {
+            EntityType::Global(expected) => match actual {
+                DefinitionType::Global(actual) => global_ty(expected, actual),
+                _ => bail!("expected global, but found {}", actual.desc()),
+            },
+            EntityType::Table(expected) => match actual {
+                DefinitionType::Table(actual, cur_size) => {
+                    table_ty(expected, actual, Some(*cur_size))
+                }
+                _ => bail!("expected table, but found {}", actual.desc()),
+            },
+            EntityType::Memory(expected) => match actual {
+                DefinitionType::Memory(actual, cur_size) => {
+                    memory_ty(expected, actual, Some(*cur_size))
+                }
+                _ => bail!("expected memory, but found {}", actual.desc()),
+            },
+            EntityType::Function(expected) => match actual {
+                DefinitionType::Func(actual) => {
+                    self.type_reference(expected.unwrap_engine_type_index(), *actual)
+                }
+                _ => bail!("expected func, but found {}", actual.desc()),
+            },
+            EntityType::Tag(_) => unimplemented!(),
+        }
+    }
+}
+
+#[cfg_attr(not(feature = "component-model"), allow(dead_code))]
+pub fn entity_ty(
+    expected: &EntityType,
+    expected_types: &ModuleTypes,
+    actual: &EntityType,
+    actual_types: &ModuleTypes,
+) -> Result<()> {
+    match expected {
+        EntityType::Memory(expected) => match actual {
+            EntityType::Memory(actual) => memory_ty(expected, actual, None),
+            _ => bail!("expected memory found {}", entity_desc(actual)),
+        },
+        EntityType::Global(expected) => match actual {
+            EntityType::Global(actual) => global_ty(expected, actual),
+            _ => bail!("expected global found {}", entity_desc(actual)),
+        },
+        EntityType::Table(expected) => match actual {
+            EntityType::Table(actual) => table_ty(expected, actual, None),
+            _ => bail!("expected table found {}", entity_desc(actual)),
+        },
+        EntityType::Function(expected) => match actual {
+            EntityType::Function(actual) => {
+                let expected = &expected_types[expected.unwrap_module_type_index()];
+                let actual = &actual_types[actual.unwrap_module_type_index()];
+                if expected == actual {
+                    Ok(())
+                } else {
+                    Err(concrete_type_mismatch(
+                        "function types incompatible",
+                        expected,
+                        actual,
+                    ))
+                }
+            }
+            _ => bail!("expected func found {}", entity_desc(actual)),
+        },
+        EntityType::Tag(_) => unimplemented!(),
+    }
+}
+
+fn concrete_type_mismatch(
+    msg: &str,
+    expected: &WasmSubType,
+    actual: &WasmSubType,
+) -> anyhow::Error {
+    anyhow!("{msg}: expected type `{expected}`, found type `{actual}`")
+}
+
+fn global_ty(expected: &Global, actual: &Global) -> Result<()> {
+    // Subtyping is only sound on immutable global
+    // references. Therefore if either type is mutable we perform a
+    // strict equality check on the types.
+    if expected.mutability || actual.mutability {
+        equal_ty(expected.wasm_ty, actual.wasm_ty, "global")?;
+    } else {
+        match_ty(expected.wasm_ty, actual.wasm_ty, "global")?;
+    }
+    match_bool(
+        expected.mutability,
+        actual.mutability,
+        "global",
+        "mutable",
+        "immutable",
+    )?;
+    Ok(())
+}
+
+fn table_ty(expected: &Table, actual: &Table, actual_runtime_size: Option<u32>) -> Result<()> {
+    equal_ty(
+        WasmValType::Ref(expected.wasm_ty),
+        WasmValType::Ref(actual.wasm_ty),
+        "table",
+    )?;
+    match_limits(
+        expected.minimum.into(),
+        expected.maximum.map(|i| i.into()),
+        actual_runtime_size.unwrap_or(actual.minimum).into(),
+        actual.maximum.map(|i| i.into()),
+        "table",
+    )?;
+    Ok(())
+}
+
+fn memory_ty(expected: &Memory, actual: &Memory, actual_runtime_size: Option<u64>) -> Result<()> {
+    match_bool(
+        expected.shared,
+        actual.shared,
+        "memory",
+        "shared",
+        "non-shared",
+    )?;
+    match_bool(
+        expected.memory64,
+        actual.memory64,
+        "memory",
+        "64-bit",
+        "32-bit",
+    )?;
+    match_limits(
+        expected.minimum,
+        expected.maximum,
+        actual_runtime_size.unwrap_or(actual.minimum),
+        actual.maximum,
+        "memory",
+    )?;
+    if expected.page_size_log2 != actual.page_size_log2 {
+        bail!(
+            "memory types incompatible: expected a memory with a page size of \
+             {}, but received a memory with a page size of {}",
+            expected.page_size(),
+            actual.page_size(),
+        )
+    }
+    Ok(())
+}
+
+fn match_heap(expected: WasmHeapType, actual: WasmHeapType, desc: &str) -> Result<()> {
+    use WasmHeapType as H;
+    let result = match (actual, expected) {
+        // TODO: Wasm GC introduces subtyping between function types, so it will
+        // no longer suffice to check whether canonicalized type IDs are equal.
+        (H::ConcreteArray(actual), H::ConcreteArray(expected)) => actual == expected,
+        (H::ConcreteFunc(actual), H::ConcreteFunc(expected)) => actual == expected,
+        (H::ConcreteStruct(actual), H::ConcreteStruct(expected)) => actual == expected,
+
+        (H::NoFunc, H::NoFunc) => true,
+        (_, H::NoFunc) => false,
+
+        (H::NoFunc, H::ConcreteFunc(_)) => true,
+        (_, H::ConcreteFunc(_)) => false,
+
+        (H::NoFunc | H::ConcreteFunc(_) | H::Func, H::Func) => true,
+        (_, H::Func) => false,
+
+        (H::Extern | H::NoExtern, H::Extern) => true,
+        (_, H::Extern) => false,
+
+        (H::NoExtern, H::NoExtern) => true,
+        (_, H::NoExtern) => false,
+
+        (
+            H::Any
+            | H::Eq
+            | H::I31
+            | H::Array
+            | H::ConcreteArray(_)
+            | H::Struct
+            | H::ConcreteStruct(_)
+            | H::None,
+            H::Any,
+        ) => true,
+        (_, H::Any) => false,
+
+        (
+            H::Eq
+            | H::I31
+            | H::Array
+            | H::ConcreteArray(_)
+            | H::Struct
+            | H::ConcreteStruct(_)
+            | H::None,
+            H::Eq,
+        ) => true,
+        (_, H::Eq) => false,
+
+        (H::I31 | H::None, H::I31) => true,
+        (_, H::I31) => false,
+
+        (H::Array | H::ConcreteArray(_) | H::None, H::Array) => true,
+        (_, H::Array) => false,
+
+        (H::None, H::ConcreteArray(_)) => true,
+        (_, H::ConcreteArray(_)) => false,
+
+        (H::Struct | H::ConcreteStruct(_) | H::None, H::Struct) => true,
+        (_, H::Struct) => false,
+
+        (H::None, H::ConcreteStruct(_)) => true,
+        (_, H::ConcreteStruct(_)) => false,
+
+        (H::None, H::None) => true,
+        (_, H::None) => false,
+    };
+    if result {
+        Ok(())
+    } else {
+        bail!(
+            "{desc} types incompatible: expected {desc} of type `{expected}`, \
+             found {desc} of type `{actual}`",
+        )
+    }
+}
+
+fn match_ref(expected: WasmRefType, actual: WasmRefType, desc: &str) -> Result<()> {
+    if actual.nullable == expected.nullable || expected.nullable {
+        return match_heap(expected.heap_type, actual.heap_type, desc);
+    }
+    bail!(
+        "{desc} types incompatible: expected {desc} of type `{expected}`, \
+         found {desc} of type `{actual}`",
+    )
+}
+
+// Checks whether actual is a subtype of expected, i.e. `actual <: expected`
+// (note the parameters are given the other way around in code).
+fn match_ty(expected: WasmValType, actual: WasmValType, desc: &str) -> Result<()> {
+    // Assert that both our types are engine-level canonicalized. We can't
+    // compare types otherwise.
+    debug_assert!(
+        expected.is_canonicalized_for_runtime_usage(),
+        "expected type should be canonicalized for runtime usage: {expected:?}"
+    );
+    debug_assert!(
+        actual.is_canonicalized_for_runtime_usage(),
+        "actual type should be canonicalized for runtime usage: {actual:?}"
+    );
+
+    match (actual, expected) {
+        (WasmValType::Ref(actual), WasmValType::Ref(expected)) => match_ref(expected, actual, desc),
+        (actual, expected) => equal_ty(expected, actual, desc),
+    }
+}
+
+fn equal_ty(expected: WasmValType, actual: WasmValType, desc: &str) -> Result<()> {
+    // Assert that both our types are engine-level canonicalized. We can't
+    // compare types otherwise.
+    debug_assert!(
+        expected.is_canonicalized_for_runtime_usage(),
+        "expected type should be canonicalized for runtime usage: {expected:?}"
+    );
+    debug_assert!(
+        actual.is_canonicalized_for_runtime_usage(),
+        "actual type should be canonicalized for runtime usage: {actual:?}"
+    );
+
+    if expected == actual {
+        return Ok(());
+    }
+    bail!(
+        "{desc} types incompatible: expected {desc} of type `{expected}`, \
+         found {desc} of type `{actual}`",
+    )
+}
+
+fn match_bool(
+    expected: bool,
+    actual: bool,
+    desc: &str,
+    if_true: &str,
+    if_false: &str,
+) -> Result<()> {
+    if expected == actual {
+        return Ok(());
+    }
+    let expected = if expected { if_true } else { if_false };
+    let actual = if actual { if_true } else { if_false };
+    bail!(
+        "{desc} types incompatible: expected {expected} {desc}, \
+         found {actual} {desc}",
+    )
+}
+
+fn match_limits(
+    expected_min: u64,
+    expected_max: Option<u64>,
+    actual_min: u64,
+    actual_max: Option<u64>,
+    desc: &str,
+) -> Result<()> {
+    if expected_min <= actual_min
+        && match expected_max {
+            Some(expected) => match actual_max {
+                Some(actual) => expected >= actual,
+                None => false,
+            },
+            None => true,
+        }
+    {
+        return Ok(());
+    }
+    let limits = |min: u64, max: Option<u64>| {
+        format!(
+            "min: {}, max: {}",
+            min,
+            max.map(|s| s.to_string()).unwrap_or(String::from("none"))
+        )
+    };
+    bail!(
+        "{} types incompatible: expected {0} limits ({}) doesn't match provided {0} limits ({})",
+        desc,
+        limits(expected_min, expected_max),
+        limits(actual_min, actual_max)
+    )
+}
+
+fn entity_desc(ty: &EntityType) -> &'static str {
+    match ty {
+        EntityType::Global(_) => "global",
+        EntityType::Table(_) => "table",
+        EntityType::Memory(_) => "memory",
+        EntityType::Function(_) => "func",
+        EntityType::Tag(_) => "tag",
+    }
+}
diff --git a/crates/wasmtime/src/runtime/uninhabited.rs b/crates/wasmtime/src/runtime/uninhabited.rs
new file mode 100644
index 000000000000..6b368c35ceba
--- /dev/null
+++ b/crates/wasmtime/src/runtime/uninhabited.rs
@@ -0,0 +1,5 @@
+/// An uninhabited type.
+///
+/// Useful for modeling Wasm's bottom types or `cfg`'d off features.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub(crate) enum Uninhabited {}
diff --git a/crates/wasmtime/src/runtime/unix.rs b/crates/wasmtime/src/runtime/unix.rs
new file mode 100644
index 000000000000..6442502b4a94
--- /dev/null
+++ b/crates/wasmtime/src/runtime/unix.rs
@@ -0,0 +1,40 @@
+//! Unix-specific extension for the `wasmtime` crate.
+//!
+//! This module is only available on Unix targets, for example Linux. Note that
+//! this module is notably not available on macOS or Windows.  Note that the
+//! import path for this module is `wasmtime::unix::...`, which is intended to
+//! emphasize that it is platform-specific.
+//!
+//! The traits contained in this module are intended to extend various types
+//! throughout the `wasmtime` crate with extra functionality that's only
+//! available on Unix.
+
+use crate::prelude::*;
+use crate::{AsContextMut, Store};
+
+/// Extensions for the [`Store`] type only available on Unix.
+pub trait StoreExt {
+    // TODO: needs more docs?
+    /// The signal handler must be
+    /// [async-signal-safe](http://man7.org/linux/man-pages/man7/signal-safety.7.html).
+    unsafe fn set_signal_handler<H>(&mut self, handler: H)
+    where
+        H: 'static
+            + Fn(libc::c_int, *const libc::siginfo_t, *const libc::c_void) -> bool
+            + Send
+            + Sync;
+}
+
+impl<T> StoreExt for Store<T> {
+    unsafe fn set_signal_handler<H>(&mut self, handler: H)
+    where
+        H: 'static
+            + Fn(libc::c_int, *const libc::siginfo_t, *const libc::c_void) -> bool
+            + Send
+            + Sync,
+    {
+        self.as_context_mut()
+            .0
+            .set_signal_handler(Some(Box::new(handler)));
+    }
+}
diff --git a/crates/wasmtime/src/runtime/v128.rs b/crates/wasmtime/src/runtime/v128.rs
new file mode 100644
index 000000000000..0eb2acafdea7
--- /dev/null
+++ b/crates/wasmtime/src/runtime/v128.rs
@@ -0,0 +1,115 @@
+#![cfg_attr(
+    not(any(target_arch = "x86_64", target_arch = "aarch64")),
+    allow(unused_imports)
+)]
+
+use crate::store::{AutoAssertNoGc, StoreOpaque};
+use crate::{Result, ValRaw, ValType, WasmTy};
+use core::cmp::Ordering;
+use core::mem::MaybeUninit;
+use core::{fmt, mem};
+
+/// Representation of a 128-bit vector type, `v128`, for WebAssembly.
+///
+/// This type corresponds to the `v128` type in WebAssembly and can be used with
+/// the [`TypedFunc`] API for example. This is additionally
+/// the payload of [`Val::V128`](crate::Val).
+///
+/// # Platform specifics
+///
+/// This type can currently only be used on x86_64 and AArch64 with the
+/// [`TypedFunc`] API. Rust does not have stable support on other platforms for
+/// this type so invoking functions with `v128` parameters requires the
+/// [`Func::call`](crate::Func::call) API (or perhaps
+/// [`Func::call_unchecked`](crate::Func::call_unchecked).
+///
+/// [`TypedFunc`]: crate::TypedFunc
+#[derive(Copy, Clone)]
+#[repr(transparent)]
+pub struct V128(
+    // NB: represent this internally with a `u8` array so that `V128` does not
+    // have 16-byte alignment and force `Val`'s discriminant to be 16-bytes
+    // larger. These bytes are always in native-endian order.
+    [u8; mem::size_of::<u128>()],
+);
+
+impl V128 {
+    /// Returns the representation of this `v128` as a 128-bit integer in Rust.
+    pub fn as_u128(&self) -> u128 {
+        u128::from_ne_bytes(self.0)
+    }
+}
+
+/// Primary constructor of a `V128` type.
+impl From<u128> for V128 {
+    fn from(val: u128) -> V128 {
+        Self(val.to_ne_bytes())
+    }
+}
+
+impl From<V128> for u128 {
+    fn from(val: V128) -> u128 {
+        val.as_u128()
+    }
+}
+
+impl fmt::Debug for V128 {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.as_u128().fmt(f)
+    }
+}
+
+impl PartialEq for V128 {
+    fn eq(&self, other: &V128) -> bool {
+        self.as_u128() == other.as_u128()
+    }
+}
+
+impl Eq for V128 {}
+
+impl PartialOrd for V128 {
+    fn partial_cmp(&self, other: &V128) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for V128 {
+    fn cmp(&self, other: &V128) -> Ordering {
+        self.as_u128().cmp(&other.as_u128())
+    }
+}
+
+// Note that this trait is conditionally implemented which is intentional. See
+// the documentation above in the `cfg_if!` for why this is conditional.
+#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
+unsafe impl WasmTy for V128 {
+    #[inline]
+    fn valtype() -> ValType {
+        ValType::V128
+    }
+
+    #[inline]
+    fn compatible_with_store(&self, _: &StoreOpaque) -> bool {
+        true
+    }
+
+    fn dynamic_concrete_type_check(
+        &self,
+        _: &StoreOpaque,
+        _: bool,
+        _: &crate::HeapType,
+    ) -> anyhow::Result<()> {
+        unreachable!()
+    }
+
+    #[inline]
+    fn store(self, _store: &mut AutoAssertNoGc<'_>, ptr: &mut MaybeUninit<ValRaw>) -> Result<()> {
+        ptr.write(ValRaw::v128(self.as_u128()));
+        Ok(())
+    }
+
+    #[inline]
+    unsafe fn load(_store: &mut AutoAssertNoGc<'_>, ptr: &ValRaw) -> Self {
+        V128::from(ptr.get_v128())
+    }
+}
diff --git a/crates/wasmtime/src/runtime/values.rs b/crates/wasmtime/src/runtime/values.rs
new file mode 100644
index 000000000000..b537ce1cbd0b
--- /dev/null
+++ b/crates/wasmtime/src/runtime/values.rs
@@ -0,0 +1,1050 @@
+use crate::runtime::vm::TableElement;
+use crate::store::{AutoAssertNoGc, StoreOpaque};
+use crate::{
+    prelude::*, AnyRef, ArrayRef, AsContext, AsContextMut, ExternRef, Func, HeapType, RefType,
+    Rooted, RootedGcRefImpl, StructRef, ValType, V128,
+};
+use core::ptr;
+
+pub use crate::runtime::vm::ValRaw;
+
+/// Possible runtime values that a WebAssembly module can either consume or
+/// produce.
+///
+/// Note that we inline the `enum Ref { ... }` variants into `enum Val { ... }`
+/// here as a size optimization.
+#[derive(Debug, Clone, Copy)]
+pub enum Val {
+    // NB: the ordering here is intended to match the ordering in
+    // `ValType` to improve codegen when learning the type of a value.
+    //
+    /// A 32-bit integer.
+    I32(i32),
+
+    /// A 64-bit integer.
+    I64(i64),
+
+    /// A 32-bit float.
+    ///
+    /// Note that the raw bits of the float are stored here, and you can use
+    /// `f32::from_bits` to create an `f32` value.
+    F32(u32),
+
+    /// A 64-bit float.
+    ///
+    /// Note that the raw bits of the float are stored here, and you can use
+    /// `f64::from_bits` to create an `f64` value.
+    F64(u64),
+
+    /// A 128-bit number.
+    V128(V128),
+
+    /// A function reference.
+    FuncRef(Option<Func>),
+
+    /// An external reference.
+    ExternRef(Option<Rooted<ExternRef>>),
+
+    /// An internal reference.
+    AnyRef(Option<Rooted<AnyRef>>),
+}
+
+macro_rules! accessors {
+    ($bind:ident $(($variant:ident($ty:ty) $get:ident $unwrap:ident $cvt:expr))*) => ($(
+        /// Attempt to access the underlying value of this `Val`, returning
+        /// `None` if it is not the correct type.
+        #[inline]
+        pub fn $get(&self) -> Option<$ty> {
+            if let Val::$variant($bind) = self {
+                Some($cvt)
+            } else {
+                None
+            }
+        }
+
+        /// Returns the underlying value of this `Val`, panicking if it's the
+        /// wrong type.
+        ///
+        /// # Panics
+        ///
+        /// Panics if `self` is not of the right type.
+        #[inline]
+        pub fn $unwrap(&self) -> $ty {
+            self.$get().expect(concat!("expected ", stringify!($ty)))
+        }
+    )*)
+}
+
+impl Val {
+    /// Returns the null reference for the given heap type.
+    #[inline]
+    pub fn null_ref(heap_type: &HeapType) -> Val {
+        Ref::null(&heap_type).into()
+    }
+
+    /// Returns the null function reference value.
+    ///
+    /// The return value has type `(ref null nofunc)` aka `nullfuncref` and is a
+    /// subtype of all function references.
+    #[inline]
+    pub const fn null_func_ref() -> Val {
+        Val::FuncRef(None)
+    }
+
+    /// Returns the null function reference value.
+    ///
+    /// The return value has type `(ref null extern)` aka `nullexternref` and is
+    /// a subtype of all external references.
+    #[inline]
+    pub const fn null_extern_ref() -> Val {
+        Val::ExternRef(None)
+    }
+
+    /// Returns the null function reference value.
+    ///
+    /// The return value has type `(ref null any)` aka `nullref` and is a
+    /// subtype of all internal references.
+    #[inline]
+    pub const fn null_any_ref() -> Val {
+        Val::AnyRef(None)
+    }
+
+    /// Returns the corresponding [`ValType`] for this `Val`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if this value is a GC reference that has since been
+    /// unrooted.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this value is associated with a different store.
+    #[inline]
+    pub fn ty(&self, store: impl AsContext) -> Result<ValType> {
+        self.load_ty(&store.as_context().0)
+    }
+
+    #[inline]
+    pub(crate) fn load_ty(&self, store: &StoreOpaque) -> Result<ValType> {
+        Ok(match self {
+            Val::I32(_) => ValType::I32,
+            Val::I64(_) => ValType::I64,
+            Val::F32(_) => ValType::F32,
+            Val::F64(_) => ValType::F64,
+            Val::V128(_) => ValType::V128,
+            Val::ExternRef(Some(_)) => ValType::EXTERNREF,
+            Val::ExternRef(None) => ValType::NULLFUNCREF,
+            Val::FuncRef(None) => ValType::NULLFUNCREF,
+            Val::FuncRef(Some(f)) => ValType::Ref(RefType::new(
+                false,
+                HeapType::ConcreteFunc(f.load_ty(store)),
+            )),
+            Val::AnyRef(None) => ValType::NULLREF,
+            Val::AnyRef(Some(a)) => ValType::Ref(RefType::new(false, a._ty(store)?)),
+        })
+    }
+
+    /// Does this value match the given type?
+    ///
+    /// Returns an error is an underlying `Rooted` has been unrooted.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this value is not associated with the given store.
+    pub fn matches_ty(&self, store: impl AsContext, ty: &ValType) -> Result<bool> {
+        self._matches_ty(&store.as_context().0, ty)
+    }
+
+    pub(crate) fn _matches_ty(&self, store: &StoreOpaque, ty: &ValType) -> Result<bool> {
+        assert!(self.comes_from_same_store(store));
+        assert!(ty.comes_from_same_engine(store.engine()));
+        Ok(match (self, ty) {
+            (Val::I32(_), ValType::I32)
+            | (Val::I64(_), ValType::I64)
+            | (Val::F32(_), ValType::F32)
+            | (Val::F64(_), ValType::F64)
+            | (Val::V128(_), ValType::V128) => true,
+
+            (Val::FuncRef(f), ValType::Ref(ref_ty)) => Ref::from(*f)._matches_ty(store, ref_ty)?,
+            (Val::ExternRef(e), ValType::Ref(ref_ty)) => {
+                Ref::from(*e)._matches_ty(store, ref_ty)?
+            }
+            (Val::AnyRef(a), ValType::Ref(ref_ty)) => Ref::from(*a)._matches_ty(store, ref_ty)?,
+
+            (Val::I32(_), _)
+            | (Val::I64(_), _)
+            | (Val::F32(_), _)
+            | (Val::F64(_), _)
+            | (Val::V128(_), _)
+            | (Val::FuncRef(_), _)
+            | (Val::ExternRef(_), _)
+            | (Val::AnyRef(_), _) => false,
+        })
+    }
+
+    pub(crate) fn ensure_matches_ty(&self, store: &StoreOpaque, ty: &ValType) -> Result<()> {
+        if !self.comes_from_same_store(store) {
+            bail!("value used with wrong store")
+        }
+        if !ty.comes_from_same_engine(store.engine()) {
+            bail!("type used with wrong engine")
+        }
+        if self._matches_ty(store, ty)? {
+            Ok(())
+        } else {
+            let actual_ty = self.load_ty(store)?;
+            bail!("type mismatch: expected {ty}, found {actual_ty}")
+        }
+    }
+
+    /// Convenience method to convert this [`Val`] into a [`ValRaw`].
+    ///
+    /// Returns an error if this value is a GC reference and the GC reference
+    /// has been unrooted.
+    ///
+    /// # Unsafety
+    ///
+    /// This method is unsafe for the reasons that [`ExternRef::to_raw`] and
+    /// [`Func::to_raw`] are unsafe.
+    pub unsafe fn to_raw(&self, store: impl AsContextMut) -> Result<ValRaw> {
+        match self {
+            Val::I32(i) => Ok(ValRaw::i32(*i)),
+            Val::I64(i) => Ok(ValRaw::i64(*i)),
+            Val::F32(u) => Ok(ValRaw::f32(*u)),
+            Val::F64(u) => Ok(ValRaw::f64(*u)),
+            Val::V128(b) => Ok(ValRaw::v128(b.as_u128())),
+            Val::ExternRef(e) => Ok(ValRaw::externref(match e {
+                None => 0,
+                Some(e) => e.to_raw(store)?,
+            })),
+            Val::AnyRef(e) => Ok(ValRaw::anyref(match e {
+                None => 0,
+                Some(e) => e.to_raw(store)?,
+            })),
+            Val::FuncRef(f) => Ok(ValRaw::funcref(match f {
+                Some(f) => f.to_raw(store),
+                None => ptr::null_mut(),
+            })),
+        }
+    }
+
+    /// Convenience method to convert a [`ValRaw`] into a [`Val`].
+    ///
+    /// # Unsafety
+    ///
+    /// This method is unsafe for the reasons that [`ExternRef::from_raw`] and
+    /// [`Func::from_raw`] are unsafe. Additionally there's no guarantee
+    /// otherwise that `raw` should have the type `ty` specified.
+    pub unsafe fn from_raw(store: impl AsContextMut, raw: ValRaw, ty: ValType) -> Val {
+        match ty {
+            ValType::I32 => Val::I32(raw.get_i32()),
+            ValType::I64 => Val::I64(raw.get_i64()),
+            ValType::F32 => Val::F32(raw.get_f32()),
+            ValType::F64 => Val::F64(raw.get_f64()),
+            ValType::V128 => Val::V128(raw.get_v128().into()),
+            ValType::Ref(ref_ty) => {
+                let ref_ = match ref_ty.heap_type() {
+                    HeapType::Func | HeapType::ConcreteFunc(_) => {
+                        Func::from_raw(store, raw.get_funcref()).into()
+                    }
+
+                    HeapType::NoFunc => Ref::Func(None),
+
+                    HeapType::Extern => ExternRef::from_raw(store, raw.get_externref()).into(),
+
+                    HeapType::NoExtern => Ref::Extern(None),
+
+                    HeapType::Any
+                    | HeapType::Eq
+                    | HeapType::I31
+                    | HeapType::Array
+                    | HeapType::ConcreteArray(_)
+                    | HeapType::Struct
+                    | HeapType::ConcreteStruct(_) => {
+                        AnyRef::from_raw(store, raw.get_anyref()).into()
+                    }
+
+                    HeapType::None => Ref::Any(None),
+                };
+                assert!(
+                    ref_ty.is_nullable() || !ref_.is_null(),
+                    "if the type is not nullable, we shouldn't get null; got \
+                     type = {ref_ty}, ref = {ref_:?}"
+                );
+                ref_.into()
+            }
+        }
+    }
+
+    accessors! {
+        e
+        (I32(i32) i32 unwrap_i32 *e)
+        (I64(i64) i64 unwrap_i64 *e)
+        (F32(f32) f32 unwrap_f32 f32::from_bits(*e))
+        (F64(f64) f64 unwrap_f64 f64::from_bits(*e))
+        (FuncRef(Option<&Func>) func_ref unwrap_func_ref e.as_ref())
+        (ExternRef(Option<&Rooted<ExternRef>>) extern_ref unwrap_extern_ref e.as_ref())
+        (AnyRef(Option<&Rooted<AnyRef>>) any_ref unwrap_any_ref e.as_ref())
+        (V128(V128) v128 unwrap_v128 *e)
+    }
+
+    /// Get this value's underlying reference, if any.
+    #[inline]
+    pub fn ref_(self) -> Option<Ref> {
+        match self {
+            Val::FuncRef(f) => Some(Ref::Func(f)),
+            Val::ExternRef(e) => Some(Ref::Extern(e)),
+            Val::AnyRef(a) => Some(Ref::Any(a)),
+            Val::I32(_) | Val::I64(_) | Val::F32(_) | Val::F64(_) | Val::V128(_) => None,
+        }
+    }
+
+    /// Attempt to access the underlying `externref` value of this `Val`.
+    ///
+    /// If this is not an `externref`, then `None` is returned.
+    ///
+    /// If this is a null `externref`, then `Some(None)` is returned.
+    ///
+    /// If this is a non-null `externref`, then `Some(Some(..))` is returned.
+    #[inline]
+    pub fn externref(&self) -> Option<Option<&Rooted<ExternRef>>> {
+        match self {
+            Val::ExternRef(None) => Some(None),
+            Val::ExternRef(Some(e)) => Some(Some(e)),
+            _ => None,
+        }
+    }
+
+    /// Returns the underlying `externref` value of this `Val`, panicking if it's the
+    /// wrong type.
+    ///
+    /// If this is a null `externref`, then `None` is returned.
+    ///
+    /// If this is a non-null `externref`, then `Some(..)` is returned.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `self` is not a (nullable) `externref`.
+    #[inline]
+    pub fn unwrap_externref(&self) -> Option<&Rooted<ExternRef>> {
+        self.externref().expect("expected externref")
+    }
+
+    /// Attempt to access the underlying `anyref` value of this `Val`.
+    ///
+    /// If this is not an `anyref`, then `None` is returned.
+    ///
+    /// If this is a null `anyref`, then `Some(None)` is returned.
+    ///
+    /// If this is a non-null `anyref`, then `Some(Some(..))` is returned.
+    #[inline]
+    pub fn anyref(&self) -> Option<Option<&Rooted<AnyRef>>> {
+        match self {
+            Val::AnyRef(None) => Some(None),
+            Val::AnyRef(Some(e)) => Some(Some(e)),
+            _ => None,
+        }
+    }
+
+    /// Returns the underlying `anyref` value of this `Val`, panicking if it's the
+    /// wrong type.
+    ///
+    /// If this is a null `anyref`, then `None` is returned.
+    ///
+    /// If this is a non-null `anyref`, then `Some(..)` is returned.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `self` is not a (nullable) `anyref`.
+    #[inline]
+    pub fn unwrap_anyref(&self) -> Option<&Rooted<AnyRef>> {
+        self.anyref().expect("expected anyref")
+    }
+
+    /// Attempt to access the underlying `funcref` value of this `Val`.
+    ///
+    /// If this is not an `funcref`, then `None` is returned.
+    ///
+    /// If this is a null `funcref`, then `Some(None)` is returned.
+    ///
+    /// If this is a non-null `funcref`, then `Some(Some(..))` is returned.
+    #[inline]
+    pub fn funcref(&self) -> Option<Option<&Func>> {
+        match self {
+            Val::FuncRef(None) => Some(None),
+            Val::FuncRef(Some(f)) => Some(Some(f)),
+            _ => None,
+        }
+    }
+
+    /// Returns the underlying `funcref` value of this `Val`, panicking if it's the
+    /// wrong type.
+    ///
+    /// If this is a null `funcref`, then `None` is returned.
+    ///
+    /// If this is a non-null `funcref`, then `Some(..)` is returned.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `self` is not a (nullable) `funcref`.
+    #[inline]
+    pub fn unwrap_funcref(&self) -> Option<&Func> {
+        self.funcref().expect("expected funcref")
+    }
+
+    #[inline]
+    pub(crate) fn comes_from_same_store(&self, store: &StoreOpaque) -> bool {
+        match self {
+            Val::FuncRef(Some(f)) => f.comes_from_same_store(store),
+            Val::FuncRef(None) => true,
+
+            Val::ExternRef(Some(x)) => x.comes_from_same_store(store),
+            Val::ExternRef(None) => true,
+
+            Val::AnyRef(Some(a)) => a.comes_from_same_store(store),
+            Val::AnyRef(None) => true,
+
+            // Integers, floats, and vectors have no association with any
+            // particular store, so they're always considered as "yes I came
+            // from that store",
+            Val::I32(_) | Val::I64(_) | Val::F32(_) | Val::F64(_) | Val::V128(_) => true,
+        }
+    }
+}
+
+impl From<i32> for Val {
+    #[inline]
+    fn from(val: i32) -> Val {
+        Val::I32(val)
+    }
+}
+
+impl From<i64> for Val {
+    #[inline]
+    fn from(val: i64) -> Val {
+        Val::I64(val)
+    }
+}
+
+impl From<f32> for Val {
+    #[inline]
+    fn from(val: f32) -> Val {
+        Val::F32(val.to_bits())
+    }
+}
+
+impl From<f64> for Val {
+    #[inline]
+    fn from(val: f64) -> Val {
+        Val::F64(val.to_bits())
+    }
+}
+
+impl From<Ref> for Val {
+    #[inline]
+    fn from(val: Ref) -> Val {
+        match val {
+            Ref::Extern(e) => Val::ExternRef(e),
+            Ref::Func(f) => Val::FuncRef(f),
+            Ref::Any(a) => Val::AnyRef(a),
+        }
+    }
+}
+
+impl From<Rooted<ExternRef>> for Val {
+    #[inline]
+    fn from(val: Rooted<ExternRef>) -> Val {
+        Val::ExternRef(Some(val))
+    }
+}
+
+impl From<Option<Rooted<ExternRef>>> for Val {
+    #[inline]
+    fn from(val: Option<Rooted<ExternRef>>) -> Val {
+        Val::ExternRef(val)
+    }
+}
+
+impl From<Rooted<AnyRef>> for Val {
+    #[inline]
+    fn from(val: Rooted<AnyRef>) -> Val {
+        Val::AnyRef(Some(val))
+    }
+}
+
+impl From<Option<Rooted<AnyRef>>> for Val {
+    #[inline]
+    fn from(val: Option<Rooted<AnyRef>>) -> Val {
+        Val::AnyRef(val)
+    }
+}
+
+impl From<Rooted<StructRef>> for Val {
+    #[inline]
+    fn from(val: Rooted<StructRef>) -> Val {
+        Val::AnyRef(Some(val.into()))
+    }
+}
+
+impl From<Option<Rooted<StructRef>>> for Val {
+    #[inline]
+    fn from(val: Option<Rooted<StructRef>>) -> Val {
+        Val::AnyRef(val.map(Into::into))
+    }
+}
+
+impl From<Rooted<ArrayRef>> for Val {
+    #[inline]
+    fn from(val: Rooted<ArrayRef>) -> Val {
+        Val::AnyRef(Some(val.into()))
+    }
+}
+
+impl From<Option<Rooted<ArrayRef>>> for Val {
+    #[inline]
+    fn from(val: Option<Rooted<ArrayRef>>) -> Val {
+        Val::AnyRef(val.map(Into::into))
+    }
+}
+
+impl From<Func> for Val {
+    #[inline]
+    fn from(val: Func) -> Val {
+        Val::FuncRef(Some(val))
+    }
+}
+
+impl From<Option<Func>> for Val {
+    #[inline]
+    fn from(val: Option<Func>) -> Val {
+        Val::FuncRef(val)
+    }
+}
+
+impl From<u128> for Val {
+    #[inline]
+    fn from(val: u128) -> Val {
+        Val::V128(val.into())
+    }
+}
+
+impl From<V128> for Val {
+    #[inline]
+    fn from(val: V128) -> Val {
+        Val::V128(val)
+    }
+}
+
+/// A reference.
+///
+/// References come in three broad flavors:
+///
+/// 1. Function references. These are references to a function that can be
+///    invoked.
+///
+/// 2. External references. These are references to data that is external
+///    and opaque to the Wasm guest, provided by the host.
+///
+/// 3. Internal references. These are references to allocations inside the
+///    Wasm's heap, such as structs and arrays. These are part of the GC
+///    proposal, and not yet implemented in Wasmtime.
+///
+/// At the Wasm level, there are nullable and non-nullable variants of each type
+/// of reference. Both variants are represented with `Ref` at the Wasmtime API
+/// level. For example, values of both `(ref extern)` and `(ref null extern)`
+/// types will be represented as `Ref::Extern(Option<ExternRef>)` in the
+/// Wasmtime API. Nullable references are represented as `Option<Ref>` where
+/// null references are represented as `None`. Wasm can construct null
+/// references via the `ref.null <heap-type>` instruction.
+///
+/// References are non-forgable: Wasm cannot create invalid references, for
+/// example, by claiming that the integer `0xbad1bad2` is actually a reference.
+#[derive(Debug, Clone)]
+pub enum Ref {
+    // NB: We have a variant for each of the type hierarchies defined in Wasm,
+    // and push the `Option` that provides nullability into each variant. This
+    // allows us to get the most-precise type of any reference value, whether it
+    // is null or not, without any additional metadata.
+    //
+    // Consider if we instead had the nullability inside `Val::Ref` and each of
+    // the `Ref` variants did not have an `Option`:
+    //
+    //     enum Val {
+    //         Ref(Option<Ref>),
+    //         // Etc...
+    //     }
+    //     enum Ref {
+    //         Func(Func),
+    //         External(ExternRef),
+    //         // Etc...
+    //     }
+    //
+    // In this scenario, what type would we return from `Val::ty` for
+    // `Val::Ref(None)`? Because Wasm has multiple separate type hierarchies,
+    // there is no single common bottom type for all the different kinds of
+    // references. So in this scenario, `Val::Ref(None)` doesn't have enough
+    // information to reconstruct the value's type. That's a problem for us
+    // because we need to get a value's type at various times all over the code
+    // base.
+    //
+    /// A first-class reference to a WebAssembly function.
+    ///
+    /// The host, or the Wasm guest, can invoke this function.
+    ///
+    /// The host can create function references via [`Func::new`] or
+    /// [`Func::wrap`].
+    ///
+    /// The Wasm guest can create non-null function references via the
+    /// `ref.func` instruction, or null references via the `ref.null func`
+    /// instruction.
+    Func(Option<Func>),
+
+    /// A reference to an value outside of the Wasm heap.
+    ///
+    /// These references are opaque to the Wasm itself. Wasm can't create
+    /// non-null external references, nor do anything with them accept pass them
+    /// around as function arguments and returns and place them into globals and
+    /// tables.
+    ///
+    /// Wasm can create null external references via the `ref.null extern`
+    /// instruction.
+    Extern(Option<Rooted<ExternRef>>),
+
+    /// An internal reference.
+    ///
+    /// The `AnyRef` type represents WebAssembly `anyref` values. These can be
+    /// references to `struct`s and `array`s or inline/unboxed 31-bit
+    /// integers.
+    ///
+    /// Unlike `externref`, Wasm guests can directly allocate `anyref`s, and
+    /// does not need to rely on the host to do that.
+    Any(Option<Rooted<AnyRef>>),
+}
+
+impl From<Func> for Ref {
+    #[inline]
+    fn from(f: Func) -> Ref {
+        Ref::Func(Some(f))
+    }
+}
+
+impl From<Option<Func>> for Ref {
+    #[inline]
+    fn from(f: Option<Func>) -> Ref {
+        Ref::Func(f)
+    }
+}
+
+impl From<Rooted<ExternRef>> for Ref {
+    #[inline]
+    fn from(e: Rooted<ExternRef>) -> Ref {
+        Ref::Extern(Some(e))
+    }
+}
+
+impl From<Option<Rooted<ExternRef>>> for Ref {
+    #[inline]
+    fn from(e: Option<Rooted<ExternRef>>) -> Ref {
+        Ref::Extern(e)
+    }
+}
+
+impl From<Rooted<AnyRef>> for Ref {
+    #[inline]
+    fn from(e: Rooted<AnyRef>) -> Ref {
+        Ref::Any(Some(e))
+    }
+}
+
+impl From<Option<Rooted<AnyRef>>> for Ref {
+    #[inline]
+    fn from(e: Option<Rooted<AnyRef>>) -> Ref {
+        Ref::Any(e)
+    }
+}
+
+impl From<Rooted<StructRef>> for Ref {
+    #[inline]
+    fn from(e: Rooted<StructRef>) -> Ref {
+        Ref::Any(Some(e.into()))
+    }
+}
+
+impl From<Option<Rooted<StructRef>>> for Ref {
+    #[inline]
+    fn from(e: Option<Rooted<StructRef>>) -> Ref {
+        Ref::Any(e.map(Into::into))
+    }
+}
+
+impl From<Rooted<ArrayRef>> for Ref {
+    #[inline]
+    fn from(e: Rooted<ArrayRef>) -> Ref {
+        Ref::Any(Some(e.into()))
+    }
+}
+
+impl From<Option<Rooted<ArrayRef>>> for Ref {
+    #[inline]
+    fn from(e: Option<Rooted<ArrayRef>>) -> Ref {
+        Ref::Any(e.map(Into::into))
+    }
+}
+
+impl Ref {
+    /// Create a null reference to the given heap type.
+    #[inline]
+    pub fn null(heap_type: &HeapType) -> Self {
+        match heap_type.top() {
+            HeapType::Any => Ref::Any(None),
+            HeapType::Extern => Ref::Extern(None),
+            HeapType::Func => Ref::Func(None),
+            ty => unreachable!("not a heap type: {ty:?}"),
+        }
+    }
+
+    /// Is this a null reference?
+    #[inline]
+    pub fn is_null(&self) -> bool {
+        match self {
+            Ref::Any(None) | Ref::Extern(None) | Ref::Func(None) => true,
+            Ref::Any(Some(_)) | Ref::Extern(Some(_)) | Ref::Func(Some(_)) => false,
+        }
+    }
+
+    /// Is this a non-null reference?
+    #[inline]
+    pub fn is_non_null(&self) -> bool {
+        !self.is_null()
+    }
+
+    /// Is this an `extern` reference?
+    #[inline]
+    pub fn is_extern(&self) -> bool {
+        matches!(self, Ref::Extern(_))
+    }
+
+    /// Get the underlying `extern` reference, if any.
+    ///
+    /// Returns `None` if this `Ref` is not an `extern` reference, eg it is a
+    /// `func` reference.
+    ///
+    /// Returns `Some(None)` if this `Ref` is a null `extern` reference.
+    ///
+    /// Returns `Some(Some(_))` if this `Ref` is a non-null `extern` reference.
+    #[inline]
+    pub fn as_extern(&self) -> Option<Option<&Rooted<ExternRef>>> {
+        match self {
+            Ref::Extern(e) => Some(e.as_ref()),
+            _ => None,
+        }
+    }
+
+    /// Get the underlying `extern` reference, panicking if this is a different
+    /// kind of reference.
+    ///
+    /// Returns `None` if this `Ref` is a null `extern` reference.
+    ///
+    /// Returns `Some(_)` if this `Ref` is a non-null `extern` reference.
+    #[inline]
+    pub fn unwrap_extern(&self) -> Option<&Rooted<ExternRef>> {
+        self.as_extern()
+            .expect("Ref::unwrap_extern on non-extern reference")
+    }
+
+    /// Is this an `any` reference?
+    #[inline]
+    pub fn is_any(&self) -> bool {
+        matches!(self, Ref::Any(_))
+    }
+
+    /// Get the underlying `any` reference, if any.
+    ///
+    /// Returns `None` if this `Ref` is not an `any` reference, eg it is a
+    /// `func` reference.
+    ///
+    /// Returns `Some(None)` if this `Ref` is a null `any` reference.
+    ///
+    /// Returns `Some(Some(_))` if this `Ref` is a non-null `any` reference.
+    #[inline]
+    pub fn as_any(&self) -> Option<Option<&Rooted<AnyRef>>> {
+        match self {
+            Ref::Any(e) => Some(e.as_ref()),
+            _ => None,
+        }
+    }
+
+    /// Get the underlying `any` reference, panicking if this is a different
+    /// kind of reference.
+    ///
+    /// Returns `None` if this `Ref` is a null `any` reference.
+    ///
+    /// Returns `Some(_)` if this `Ref` is a non-null `any` reference.
+    #[inline]
+    pub fn unwrap_any(&self) -> Option<&Rooted<AnyRef>> {
+        self.as_any().expect("Ref::unwrap_any on non-any reference")
+    }
+
+    /// Is this a `func` reference?
+    #[inline]
+    pub fn is_func(&self) -> bool {
+        matches!(self, Ref::Func(_))
+    }
+
+    /// Get the underlying `func` reference, if any.
+    ///
+    /// Returns `None` if this `Ref` is not an `func` reference, eg it is an
+    /// `extern` reference.
+    ///
+    /// Returns `Some(None)` if this `Ref` is a null `func` reference.
+    ///
+    /// Returns `Some(Some(_))` if this `Ref` is a non-null `func` reference.
+    #[inline]
+    pub fn as_func(&self) -> Option<Option<&Func>> {
+        match self {
+            Ref::Func(f) => Some(f.as_ref()),
+            _ => None,
+        }
+    }
+
+    /// Get the underlying `func` reference, panicking if this is a different
+    /// kind of reference.
+    ///
+    /// Returns `None` if this `Ref` is a null `func` reference.
+    ///
+    /// Returns `Some(_)` if this `Ref` is a non-null `func` reference.
+    #[inline]
+    pub fn unwrap_func(&self) -> Option<&Func> {
+        self.as_func()
+            .expect("Ref::unwrap_func on non-func reference")
+    }
+
+    /// Get the type of this reference.
+    ///
+    /// # Errors
+    ///
+    /// Return an error if this reference has been unrooted.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this reference is associated with a different store.
+    pub fn ty(&self, store: impl AsContext) -> Result<RefType> {
+        self.load_ty(&store.as_context().0)
+    }
+
+    pub(crate) fn load_ty(&self, store: &StoreOpaque) -> Result<RefType> {
+        assert!(self.comes_from_same_store(store));
+        Ok(RefType::new(
+            self.is_null(),
+            // NB: We choose the most-specific heap type we can here and let
+            // subtyping do its thing if callers are matching against a
+            // `HeapType::Func`.
+            match self {
+                Ref::Extern(None) => HeapType::NoExtern,
+                Ref::Extern(Some(_)) => HeapType::Extern,
+
+                Ref::Func(None) => HeapType::NoFunc,
+                Ref::Func(Some(f)) => HeapType::ConcreteFunc(f.load_ty(store)),
+
+                Ref::Any(None) => HeapType::None,
+                Ref::Any(Some(a)) => a._ty(store)?,
+            },
+        ))
+    }
+
+    /// Does this reference value match the given type?
+    ///
+    /// Returns an error if the underlying `Rooted` has been unrooted.
+    ///
+    /// # Panics
+    ///
+    /// Panics if this reference is not associated with the given store.
+    pub fn matches_ty(&self, store: impl AsContext, ty: &RefType) -> Result<bool> {
+        self._matches_ty(&store.as_context().0, ty)
+    }
+
+    pub(crate) fn _matches_ty(&self, store: &StoreOpaque, ty: &RefType) -> Result<bool> {
+        assert!(self.comes_from_same_store(store));
+        assert!(ty.comes_from_same_engine(store.engine()));
+        if self.is_null() && !ty.is_nullable() {
+            return Ok(false);
+        }
+        Ok(match (self, ty.heap_type()) {
+            (Ref::Extern(_), HeapType::Extern) => true,
+            (Ref::Extern(_), _) => false,
+
+            (Ref::Func(_), HeapType::Func) => true,
+            (Ref::Func(None), HeapType::NoFunc | HeapType::ConcreteFunc(_)) => true,
+            (Ref::Func(Some(f)), HeapType::ConcreteFunc(func_ty)) => f._matches_ty(store, func_ty),
+            (Ref::Func(_), _) => false,
+
+            (Ref::Any(_), HeapType::Any) => true,
+            (Ref::Any(Some(a)), HeapType::I31) => a._is_i31(store)?,
+            (Ref::Any(Some(a)), HeapType::Struct) => a._is_struct(store)?,
+            (Ref::Any(Some(a)), HeapType::ConcreteStruct(_ty)) => match a._as_struct(store)? {
+                None => false,
+                #[cfg_attr(not(feature = "gc"), allow(unreachable_patterns))]
+                Some(s) => s._matches_ty(store, _ty)?,
+            },
+            (Ref::Any(Some(_)), HeapType::Eq) => todo!("eqref"),
+            (Ref::Any(Some(a)), HeapType::Array) => a._is_array(store)?,
+            (Ref::Any(Some(a)), HeapType::ConcreteArray(_ty)) => match a._as_array(store)? {
+                None => false,
+                #[cfg_attr(not(feature = "gc"), allow(unreachable_patterns))]
+                Some(a) => a._matches_ty(store, _ty)?,
+            },
+            (
+                Ref::Any(None),
+                HeapType::None
+                | HeapType::I31
+                | HeapType::ConcreteStruct(_)
+                | HeapType::Struct
+                | HeapType::ConcreteArray(_)
+                | HeapType::Array,
+            ) => true,
+            (Ref::Any(_), _) => false,
+        })
+    }
+
+    pub(crate) fn ensure_matches_ty(&self, store: &StoreOpaque, ty: &RefType) -> Result<()> {
+        if !self.comes_from_same_store(store) {
+            bail!("reference used with wrong store")
+        }
+        if !ty.comes_from_same_engine(store.engine()) {
+            bail!("type used with wrong engine")
+        }
+        if self._matches_ty(store, ty)? {
+            Ok(())
+        } else {
+            let actual_ty = self.load_ty(store)?;
+            bail!("type mismatch: expected {ty}, found {actual_ty}")
+        }
+    }
+
+    pub(crate) fn comes_from_same_store(&self, store: &StoreOpaque) -> bool {
+        match self {
+            Ref::Func(Some(f)) => f.comes_from_same_store(store),
+            Ref::Func(None) => true,
+            Ref::Extern(Some(x)) => x.comes_from_same_store(store),
+            Ref::Extern(None) => true,
+            Ref::Any(Some(a)) => a.comes_from_same_store(store),
+            Ref::Any(None) => true,
+        }
+    }
+
+    pub(crate) fn into_table_element(
+        self,
+        store: &mut StoreOpaque,
+        ty: &RefType,
+    ) -> Result<TableElement> {
+        let mut store = AutoAssertNoGc::new(store);
+        self.ensure_matches_ty(&store, &ty)
+            .context("type mismatch: value does not match table element type")?;
+
+        match (self, ty.heap_type().top()) {
+            (Ref::Func(None), HeapType::Func) => {
+                assert!(ty.is_nullable());
+                Ok(TableElement::FuncRef(ptr::null_mut()))
+            }
+            (Ref::Func(Some(f)), HeapType::Func) => {
+                debug_assert!(
+                    f.comes_from_same_store(&store),
+                    "checked in `ensure_matches_ty`"
+                );
+                Ok(TableElement::FuncRef(f.vm_func_ref(&mut store).as_ptr()))
+            }
+
+            (Ref::Extern(e), HeapType::Extern) => match e {
+                None => {
+                    assert!(ty.is_nullable());
+                    Ok(TableElement::GcRef(None))
+                }
+                #[cfg_attr(not(feature = "gc"), allow(unreachable_patterns))]
+                Some(e) => {
+                    let gc_ref = e.try_clone_gc_ref(&mut store)?;
+                    Ok(TableElement::GcRef(Some(gc_ref)))
+                }
+            },
+
+            (Ref::Any(a), HeapType::Any) => match a {
+                None => {
+                    assert!(ty.is_nullable());
+                    Ok(TableElement::GcRef(None))
+                }
+                #[cfg_attr(not(feature = "gc"), allow(unreachable_patterns))]
+                Some(a) => {
+                    let gc_ref = a.try_clone_gc_ref(&mut store)?;
+                    Ok(TableElement::GcRef(Some(gc_ref)))
+                }
+            },
+
+            _ => unreachable!("checked that the value matches the type above"),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::*;
+
+    #[test]
+    fn size_of_val() {
+        // Try to keep tabs on the size of `Val` and make sure we don't grow its
+        // size.
+        assert_eq!(
+            std::mem::size_of::<Val>(),
+            if cfg!(any(
+                target_arch = "x86_64",
+                target_arch = "aarch64",
+                target_arch = "riscv64",
+                target_arch = "s390x"
+            )) {
+                24
+            } else {
+                panic!("unsupported architecture")
+            }
+        );
+    }
+
+    #[test]
+    fn size_of_ref() {
+        // Try to keep tabs on the size of `Ref` and make sure we don't grow its
+        // size.
+        assert_eq!(std::mem::size_of::<Ref>(), 24);
+    }
+
+    #[test]
+    #[should_panic]
+    fn val_matches_ty_wrong_engine() {
+        let e1 = Engine::default();
+        let e2 = Engine::default();
+
+        let t1 = FuncType::new(&e1, None, None);
+        let t2 = FuncType::new(&e2, None, None);
+
+        let mut s1 = Store::new(&e1, ());
+        let f = Func::new(&mut s1, t1.clone(), |_caller, _args, _results| Ok(()));
+
+        // Should panic.
+        let _ = Val::FuncRef(Some(f)).matches_ty(
+            &s1,
+            &ValType::Ref(RefType::new(true, HeapType::ConcreteFunc(t2))),
+        );
+    }
+
+    #[test]
+    #[should_panic]
+    fn ref_matches_ty_wrong_engine() {
+        let e1 = Engine::default();
+        let e2 = Engine::default();
+
+        let t1 = FuncType::new(&e1, None, None);
+        let t2 = FuncType::new(&e2, None, None);
+
+        let mut s1 = Store::new(&e1, ());
+        let f = Func::new(&mut s1, t1.clone(), |_caller, _args, _results| Ok(()));
+
+        // Should panic.
+        let _ = Ref::Func(Some(f)).matches_ty(&s1, &RefType::new(true, HeapType::ConcreteFunc(t2)));
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm.rs b/crates/wasmtime/src/runtime/vm.rs
new file mode 100644
index 000000000000..21a274f7cdb6
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm.rs
@@ -0,0 +1,403 @@
+//! Runtime library support for Wasmtime.
+
+#![deny(missing_docs)]
+#![warn(clippy::cast_sign_loss)]
+
+use crate::prelude::*;
+use alloc::sync::Arc;
+use core::fmt;
+use core::mem;
+use core::ptr::NonNull;
+use core::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
+use wasmtime_environ::{
+    DefinedFuncIndex, DefinedMemoryIndex, HostPtr, ModuleInternedTypeIndex, VMOffsets,
+    VMSharedTypeIndex,
+};
+
+mod arch;
+mod async_yield;
+#[cfg(feature = "component-model")]
+pub mod component;
+mod const_expr;
+mod export;
+mod gc;
+mod imports;
+mod instance;
+mod memory;
+mod mmap;
+mod mmap_vec;
+mod send_sync_ptr;
+mod store_box;
+mod sys;
+mod table;
+mod traphandlers;
+mod vmcontext;
+
+mod threads;
+pub use self::threads::*;
+
+#[cfg(feature = "debug-builtins")]
+pub mod debug_builtins;
+pub mod libcalls;
+pub mod mpk;
+
+#[cfg(feature = "debug-builtins")]
+pub use wasmtime_jit_debug::gdb_jit_int::GdbJitImageRegistration;
+
+pub use crate::runtime::vm::arch::get_stack_pointer;
+pub use crate::runtime::vm::async_yield::*;
+pub use crate::runtime::vm::export::*;
+pub use crate::runtime::vm::gc::*;
+pub use crate::runtime::vm::imports::Imports;
+pub use crate::runtime::vm::instance::{
+    GcHeapAllocationIndex, Instance, InstanceAllocationRequest, InstanceAllocator,
+    InstanceAllocatorImpl, InstanceHandle, MemoryAllocationIndex, OnDemandInstanceAllocator,
+    StorePtr, TableAllocationIndex,
+};
+#[cfg(feature = "pooling-allocator")]
+pub use crate::runtime::vm::instance::{
+    InstanceLimits, PoolConcurrencyLimitError, PoolingInstanceAllocator,
+    PoolingInstanceAllocatorConfig,
+};
+pub use crate::runtime::vm::memory::{Memory, RuntimeLinearMemory, RuntimeMemoryCreator};
+pub use crate::runtime::vm::mmap::Mmap;
+pub use crate::runtime::vm::mmap_vec::MmapVec;
+pub use crate::runtime::vm::mpk::MpkEnabled;
+pub use crate::runtime::vm::store_box::*;
+pub use crate::runtime::vm::sys::unwind::UnwindRegistration;
+pub use crate::runtime::vm::table::{Table, TableElement};
+pub use crate::runtime::vm::traphandlers::*;
+pub use crate::runtime::vm::vmcontext::{
+    VMArrayCallFunction, VMArrayCallHostFuncContext, VMContext, VMFuncRef, VMFunctionBody,
+    VMFunctionImport, VMGlobalDefinition, VMGlobalImport, VMMemoryDefinition, VMMemoryImport,
+    VMOpaqueContext, VMRuntimeLimits, VMTableImport, VMWasmCallFunction, ValRaw,
+};
+pub use send_sync_ptr::SendSyncPtr;
+
+mod module_id;
+pub use module_id::CompiledModuleId;
+
+mod cow;
+pub use crate::runtime::vm::cow::{MemoryImage, MemoryImageSlot, ModuleMemoryImages};
+
+/// Dynamic runtime functionality needed by this crate throughout the execution
+/// of a wasm instance.
+///
+/// This trait is used to store a raw pointer trait object within each
+/// `VMContext`. This raw pointer trait object points back to the
+/// `wasmtime::Store` internally but is type-erased so this `wasmtime-runtime`
+/// crate doesn't need the entire `wasmtime` crate to build.
+///
+/// Note that this is an extra-unsafe trait because no heed is paid to the
+/// lifetime of this store or the Send/Sync-ness of this store. All of that must
+/// be respected by embedders (e.g. the `wasmtime::Store` structure). The theory
+/// is that `wasmtime::Store` handles all this correctly.
+pub unsafe trait Store {
+    /// Returns the raw pointer in memory where this store's shared
+    /// `VMRuntimeLimits` structure is located.
+    ///
+    /// Used to configure `VMContext` initialization and store the right pointer
+    /// in the `VMContext`.
+    fn vmruntime_limits(&self) -> *mut VMRuntimeLimits;
+
+    /// Returns a pointer to the global epoch counter.
+    ///
+    /// Used to configure the `VMContext` on initialization.
+    fn epoch_ptr(&self) -> *const AtomicU64;
+
+    /// Get this store's GC heap.
+    fn gc_store(&mut self) -> &mut GcStore {
+        self.maybe_gc_store()
+            .expect("attempt to access the GC store before it has been allocated")
+    }
+
+    /// Get this store's GC heap, if it has been allocated.
+    fn maybe_gc_store(&mut self) -> Option<&mut GcStore>;
+
+    /// Callback invoked to allow the store's resource limiter to reject a
+    /// memory grow operation.
+    fn memory_growing(
+        &mut self,
+        current: usize,
+        desired: usize,
+        maximum: Option<usize>,
+    ) -> Result<bool, Error>;
+
+    /// Callback invoked to notify the store's resource limiter that a memory
+    /// grow operation has failed.
+    ///
+    /// Note that this is not invoked if `memory_growing` returns an error.
+    fn memory_grow_failed(&mut self, error: Error) -> Result<()>;
+
+    /// Callback invoked to allow the store's resource limiter to reject a
+    /// table grow operation.
+    fn table_growing(
+        &mut self,
+        current: u32,
+        desired: u32,
+        maximum: Option<u32>,
+    ) -> Result<bool, Error>;
+
+    /// Callback invoked to notify the store's resource limiter that a table
+    /// grow operation has failed.
+    ///
+    /// Note that this is not invoked if `table_growing` returns an error.
+    fn table_grow_failed(&mut self, error: Error) -> Result<()>;
+
+    /// Callback invoked whenever fuel runs out by a wasm instance. If an error
+    /// is returned that's raised as a trap. Otherwise wasm execution will
+    /// continue as normal.
+    fn out_of_gas(&mut self) -> Result<(), Error>;
+
+    /// Callback invoked whenever an instance observes a new epoch
+    /// number. Cannot fail; cooperative epoch-based yielding is
+    /// completely semantically transparent. Returns the new deadline.
+    fn new_epoch(&mut self) -> Result<u64, Error>;
+
+    /// Callback invoked whenever an instance needs to trigger a GC.
+    ///
+    /// Optionally given a GC reference that is rooted for the collection, and
+    /// then whose updated GC reference is returned.
+    ///
+    /// Cooperative, async-yielding (if configured) is completely transparent.
+    ///
+    /// If the async GC was cancelled, returns an error. This should be raised
+    /// as a trap to clean up Wasm execution.
+    fn gc(&mut self, root: Option<VMGcRef>) -> Result<Option<VMGcRef>>;
+
+    /// Metadata required for resources for the component model.
+    #[cfg(feature = "component-model")]
+    fn component_calls(&mut self) -> &mut component::CallContexts;
+}
+
+/// Functionality required by this crate for a particular module. This
+/// is chiefly needed for lazy initialization of various bits of
+/// instance state.
+///
+/// When an instance is created, it holds an `Arc<dyn ModuleRuntimeInfo>`
+/// so that it can get to signatures, metadata on functions, memory and
+/// funcref-table images, etc. All of these things are ordinarily known
+/// by the higher-level layers of Wasmtime. Specifically, the main
+/// implementation of this trait is provided by
+/// `wasmtime::module::ModuleInner`.  Since the runtime crate sits at
+/// the bottom of the dependence DAG though, we don't know or care about
+/// that; we just need some implementor of this trait for each
+/// allocation request.
+#[derive(Clone)]
+pub enum ModuleRuntimeInfo {
+    Module(crate::Module),
+    Bare(Box<BareModuleInfo>),
+}
+
+/// A barebones implementation of ModuleRuntimeInfo that is useful for
+/// cases where a purpose-built environ::Module is used and a full
+/// CompiledModule does not exist (for example, for tests or for the
+/// default-callee instance).
+#[derive(Clone)]
+pub struct BareModuleInfo {
+    module: Arc<wasmtime_environ::Module>,
+    one_signature: Option<VMSharedTypeIndex>,
+    offsets: VMOffsets<HostPtr>,
+}
+
+impl ModuleRuntimeInfo {
+    pub(crate) fn bare(module: Arc<wasmtime_environ::Module>) -> Self {
+        ModuleRuntimeInfo::bare_maybe_imported_func(module, None)
+    }
+
+    pub(crate) fn bare_maybe_imported_func(
+        module: Arc<wasmtime_environ::Module>,
+        one_signature: Option<VMSharedTypeIndex>,
+    ) -> Self {
+        ModuleRuntimeInfo::Bare(Box::new(BareModuleInfo {
+            offsets: VMOffsets::new(HostPtr, &module),
+            module,
+            one_signature,
+        }))
+    }
+
+    /// The underlying Module.
+    pub(crate) fn module(&self) -> &Arc<wasmtime_environ::Module> {
+        match self {
+            ModuleRuntimeInfo::Module(m) => m.env_module(),
+            ModuleRuntimeInfo::Bare(b) => &b.module,
+        }
+    }
+
+    /// Translate a module-level interned type index into an engine-level
+    /// interned type index.
+    fn engine_type_index(&self, module_index: ModuleInternedTypeIndex) -> VMSharedTypeIndex {
+        match self {
+            ModuleRuntimeInfo::Module(m) => m
+                .code_object()
+                .signatures()
+                .shared_type(module_index)
+                .expect("bad module-level interned type index"),
+            ModuleRuntimeInfo::Bare(_) => unreachable!(),
+        }
+    }
+
+    /// Returns the address, in memory, that the function `index` resides at.
+    fn function(&self, index: DefinedFuncIndex) -> NonNull<VMWasmCallFunction> {
+        let module = match self {
+            ModuleRuntimeInfo::Module(m) => m,
+            ModuleRuntimeInfo::Bare(_) => unreachable!(),
+        };
+        let ptr = module
+            .compiled_module()
+            .finished_function(index)
+            .as_ptr()
+            .cast::<VMWasmCallFunction>()
+            .cast_mut();
+        NonNull::new(ptr).unwrap()
+    }
+
+    /// Returns the address, in memory, of the trampoline that allows the given
+    /// defined Wasm function to be called by the array calling convention.
+    ///
+    /// Returns `None` for Wasm functions which do not escape, and therefore are
+    /// not callable from outside the Wasm module itself.
+    fn array_to_wasm_trampoline(&self, index: DefinedFuncIndex) -> Option<VMArrayCallFunction> {
+        let m = match self {
+            ModuleRuntimeInfo::Module(m) => m,
+            ModuleRuntimeInfo::Bare(_) => unreachable!(),
+        };
+        let ptr = m
+            .compiled_module()
+            .array_to_wasm_trampoline(index)?
+            .as_ptr();
+        Some(unsafe { mem::transmute::<*const u8, VMArrayCallFunction>(ptr) })
+    }
+
+    /// Returns the `MemoryImage` structure used for copy-on-write
+    /// initialization of the memory, if it's applicable.
+    fn memory_image(
+        &self,
+        memory: DefinedMemoryIndex,
+    ) -> anyhow::Result<Option<&Arc<MemoryImage>>> {
+        match self {
+            ModuleRuntimeInfo::Module(m) => {
+                let images = m.memory_images()?;
+                Ok(images.and_then(|images| images.get_memory_image(memory)))
+            }
+            ModuleRuntimeInfo::Bare(_) => Ok(None),
+        }
+    }
+
+    /// A unique ID for this particular module. This can be used to
+    /// allow for fastpaths to optimize a "re-instantiate the same
+    /// module again" case.
+    fn unique_id(&self) -> Option<CompiledModuleId> {
+        match self {
+            ModuleRuntimeInfo::Module(m) => Some(m.id()),
+            ModuleRuntimeInfo::Bare(_) => None,
+        }
+    }
+
+    /// A slice pointing to all data that is referenced by this instance.
+    fn wasm_data(&self) -> &[u8] {
+        match self {
+            ModuleRuntimeInfo::Module(m) => m.compiled_module().code_memory().wasm_data(),
+            ModuleRuntimeInfo::Bare(_) => &[],
+        }
+    }
+
+    /// Returns an array, indexed by `ModuleInternedTypeIndex` of all
+    /// `VMSharedSignatureIndex` entries corresponding to the `SignatureIndex`.
+    fn type_ids(&self) -> &[VMSharedTypeIndex] {
+        match self {
+            ModuleRuntimeInfo::Module(m) => m
+                .code_object()
+                .signatures()
+                .as_module_map()
+                .values()
+                .as_slice(),
+            ModuleRuntimeInfo::Bare(b) => match &b.one_signature {
+                Some(s) => core::slice::from_ref(s),
+                None => &[],
+            },
+        }
+    }
+
+    /// Offset information for the current host.
+    pub(crate) fn offsets(&self) -> &VMOffsets<HostPtr> {
+        match self {
+            ModuleRuntimeInfo::Module(m) => m.offsets(),
+            ModuleRuntimeInfo::Bare(b) => &b.offsets,
+        }
+    }
+}
+
+/// Returns the host OS page size, in bytes.
+pub fn host_page_size() -> usize {
+    static PAGE_SIZE: AtomicUsize = AtomicUsize::new(0);
+
+    return match PAGE_SIZE.load(Ordering::Relaxed) {
+        0 => {
+            let size = sys::vm::get_page_size();
+            assert!(size != 0);
+            PAGE_SIZE.store(size, Ordering::Relaxed);
+            size
+        }
+        n => n,
+    };
+}
+
+/// Is `bytes` a multiple of the host page size?
+pub fn usize_is_multiple_of_host_page_size(bytes: usize) -> bool {
+    bytes % host_page_size() == 0
+}
+
+/// Round the given byte size up to a multiple of the host OS page size.
+///
+/// Returns an error if rounding up overflows.
+pub fn round_u64_up_to_host_pages(bytes: u64) -> Result<u64> {
+    let page_size = u64::try_from(crate::runtime::vm::host_page_size()).err2anyhow()?;
+    debug_assert!(page_size.is_power_of_two());
+    bytes
+        .checked_add(page_size - 1)
+        .ok_or_else(|| anyhow!(
+            "{bytes} is too large to be rounded up to a multiple of the host page size of {page_size}"
+        ))
+        .map(|val| val & !(page_size - 1))
+}
+
+/// Same as `round_u64_up_to_host_pages` but for `usize`s.
+pub fn round_usize_up_to_host_pages(bytes: usize) -> Result<usize> {
+    let bytes = u64::try_from(bytes).err2anyhow()?;
+    let rounded = round_u64_up_to_host_pages(bytes)?;
+    Ok(usize::try_from(rounded).err2anyhow()?)
+}
+
+/// Result of `Memory::atomic_wait32` and `Memory::atomic_wait64`
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub enum WaitResult {
+    /// Indicates that a `wait` completed by being awoken by a different thread.
+    /// This means the thread went to sleep and didn't time out.
+    Ok = 0,
+    /// Indicates that `wait` did not complete and instead returned due to the
+    /// value in memory not matching the expected value.
+    Mismatch = 1,
+    /// Indicates that `wait` completed with a timeout, meaning that the
+    /// original value matched as expected but nothing ever called `notify`.
+    TimedOut = 2,
+}
+
+/// Description about a fault that occurred in WebAssembly.
+#[derive(Debug)]
+pub struct WasmFault {
+    /// The size of memory, in bytes, at the time of the fault.
+    pub memory_size: usize,
+    /// The WebAssembly address at which the fault occurred.
+    pub wasm_address: u64,
+}
+
+impl fmt::Display for WasmFault {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "memory fault at wasm address 0x{:x} in linear memory of size 0x{:x}",
+            self.wasm_address, self.memory_size,
+        )
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/arch/aarch64.rs b/crates/wasmtime/src/runtime/vm/arch/aarch64.rs
new file mode 100644
index 000000000000..5c7ae5084deb
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/arch/aarch64.rs
@@ -0,0 +1,71 @@
+//! Arm64-specific definitions of architecture-specific functions in Wasmtime.
+
+#[inline]
+#[allow(missing_docs)]
+pub fn get_stack_pointer() -> usize {
+    let stack_pointer: usize;
+    unsafe {
+        core::arch::asm!(
+            "mov {}, sp",
+            out(reg) stack_pointer,
+            options(nostack,nomem),
+        );
+    }
+    stack_pointer
+}
+
+// The aarch64 calling conventions save the return PC one i64 above the FP and
+// the previous FP is pointed to by the current FP:
+//
+// > Each frame shall link to the frame of its caller by means of a frame record
+// > of two 64-bit values on the stack [...] The frame record for the innermost
+// > frame [...] shall be pointed to by the frame pointer register (FP). The
+// > lowest addressed double-word shall point to the previous frame record and the
+// > highest addressed double-word shall contain the value passed in LR on entry
+// > to the current function.
+//
+// - AAPCS64 section 6.2.3 The Frame Pointer[0]
+pub unsafe fn get_next_older_pc_from_fp(fp: usize) -> usize {
+    let mut pc = *(fp as *mut usize).offset(1);
+
+    // The return address might be signed, so we need to strip the highest bits
+    // (where the authentication code might be located) in order to obtain a
+    // valid address. We use the `XPACLRI` instruction, which is executed as a
+    // no-op by processors that do not support pointer authentication, so that
+    // the implementation is backward-compatible and there is no duplication.
+    // However, this instruction requires the LR register for both its input and
+    // output.
+    core::arch::asm!(
+        "mov lr, {pc}",
+        "xpaclri",
+        "mov {pc}, lr",
+        pc = inout(reg) pc,
+        out("lr") _,
+        options(nomem, nostack, preserves_flags, pure),
+    );
+
+    pc
+}
+
+// And the current frame pointer points to the next older frame pointer.
+pub const NEXT_OLDER_FP_FROM_FP_OFFSET: usize = 0;
+
+pub fn reached_entry_sp(fp: usize, entry_sp: usize) -> bool {
+    fp >= entry_sp
+}
+
+pub fn assert_entry_sp_is_aligned(sp: usize) {
+    assert_eq!(sp % 16, 0, "stack should always be aligned to 16");
+}
+
+pub fn assert_fp_is_aligned(_fp: usize) {
+    // From AAPCS64, section 6.2.3 The Frame Pointer[0]:
+    //
+    // > The location of the frame record within a stack frame is not specified.
+    //
+    // So this presumably means that the FP can have any alignment, as its
+    // location is not specified and nothing further is said about constraining
+    // alignment.
+    //
+    // [0]: https://github.com/ARM-software/abi-aa/blob/2022Q1/aapcs64/aapcs64.rst#the-frame-pointer
+}
diff --git a/crates/wasmtime/src/runtime/vm/arch/mod.rs b/crates/wasmtime/src/runtime/vm/arch/mod.rs
new file mode 100644
index 000000000000..ea4b5e4f1f5a
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/arch/mod.rs
@@ -0,0 +1,53 @@
+//! Architecture-specific support required by Wasmtime.
+//!
+//! This crate houses any architecture-specific tidbits required when running
+//! Wasmtime. Each architecture has its own file in the `arch` folder which is
+//! referenced here.
+//!
+//! All architectures have the same interface when exposed to the rest of the
+//! crate.
+
+cfg_if::cfg_if! {
+    if #[cfg(target_arch = "x86_64")] {
+        mod x86_64;
+        use x86_64 as imp;
+    } else if #[cfg(target_arch = "aarch64")] {
+        mod aarch64;
+        use aarch64 as imp;
+    } else if #[cfg(target_arch = "s390x")] {
+        mod s390x;
+        use s390x as imp;
+    } else if #[cfg(target_arch = "riscv64")] {
+        mod riscv64;
+        use riscv64 as imp;
+    } else {
+        mod unsupported;
+        use unsupported as imp;
+    }
+}
+
+// Functions defined in this module but all the implementations delegate to each
+// `imp` module. This exists to assert that each module internally provides the
+// same set of functionality with the same types for all architectures.
+
+pub fn get_stack_pointer() -> usize {
+    imp::get_stack_pointer()
+}
+
+pub unsafe fn get_next_older_pc_from_fp(fp: usize) -> usize {
+    imp::get_next_older_pc_from_fp(fp)
+}
+
+pub const NEXT_OLDER_FP_FROM_FP_OFFSET: usize = imp::NEXT_OLDER_FP_FROM_FP_OFFSET;
+
+pub fn reached_entry_sp(fp: usize, entry_sp: usize) -> bool {
+    imp::reached_entry_sp(fp, entry_sp)
+}
+
+pub fn assert_entry_sp_is_aligned(sp: usize) {
+    imp::assert_entry_sp_is_aligned(sp)
+}
+
+pub fn assert_fp_is_aligned(fp: usize) {
+    imp::assert_fp_is_aligned(fp)
+}
diff --git a/crates/wasmtime/src/runtime/vm/arch/riscv64.rs b/crates/wasmtime/src/runtime/vm/arch/riscv64.rs
new file mode 100644
index 000000000000..8875b35592cd
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/arch/riscv64.rs
@@ -0,0 +1,34 @@
+//! Riscv64-specific definitions of architecture-specific functions in Wasmtime.
+
+#[inline]
+#[allow(missing_docs)]
+pub fn get_stack_pointer() -> usize {
+    let stack_pointer: usize;
+    unsafe {
+        core::arch::asm!(
+            "mv {}, sp",
+            out(reg) stack_pointer,
+            options(nostack,nomem),
+        );
+    }
+    stack_pointer
+}
+
+pub unsafe fn get_next_older_pc_from_fp(fp: usize) -> usize {
+    *(fp as *mut usize).offset(1)
+}
+
+// And the current frame pointer points to the next older frame pointer.
+pub const NEXT_OLDER_FP_FROM_FP_OFFSET: usize = 0;
+
+pub fn reached_entry_sp(fp: usize, entry_sp: usize) -> bool {
+    fp >= entry_sp
+}
+
+pub fn assert_entry_sp_is_aligned(sp: usize) {
+    assert_eq!(sp % 16, 0, "stack should always be aligned to 16");
+}
+
+pub fn assert_fp_is_aligned(fp: usize) {
+    assert_eq!(fp % 16, 0, "stack should always be aligned to 16");
+}
diff --git a/crates/runtime/src/trampolines/s390x.S b/crates/wasmtime/src/runtime/vm/arch/s390x.S
similarity index 93%
rename from crates/runtime/src/trampolines/s390x.S
rename to crates/wasmtime/src/runtime/vm/arch/s390x.S
index 3cf80d9d6e4b..bf335ad67508 100644
--- a/crates/runtime/src/trampolines/s390x.S
+++ b/crates/wasmtime/src/runtime/vm/arch/s390x.S
@@ -51,10 +51,10 @@ LIBCALL_TRAMPOLINE(memory_init, impl_memory_init)
 LIBCALL_TRAMPOLINE(ref_func, impl_ref_func)
 LIBCALL_TRAMPOLINE(data_drop, impl_data_drop)
 LIBCALL_TRAMPOLINE(table_get_lazy_init_func_ref, impl_table_get_lazy_init_func_ref)
-LIBCALL_TRAMPOLINE(drop_externref, impl_drop_externref)
-LIBCALL_TRAMPOLINE(activations_table_insert_with_gc, impl_activations_table_insert_with_gc)
-LIBCALL_TRAMPOLINE(externref_global_get, impl_externref_global_get)
-LIBCALL_TRAMPOLINE(externref_global_set, impl_externref_global_set)
+LIBCALL_TRAMPOLINE(drop_gc_ref, impl_drop_gc_ref)
+LIBCALL_TRAMPOLINE(gc, gc)
+LIBCALL_TRAMPOLINE(gc_ref_global_get, impl_gc_ref_global_get)
+LIBCALL_TRAMPOLINE(gc_ref_global_set, impl_gc_ref_global_set)
 LIBCALL_TRAMPOLINE(memory_atomic_notify, impl_memory_atomic_notify)
 LIBCALL_TRAMPOLINE(memory_atomic_wait32, impl_memory_atomic_wait32)
 LIBCALL_TRAMPOLINE(memory_atomic_wait64, impl_memory_atomic_wait64)
diff --git a/crates/wasmtime/src/runtime/vm/arch/s390x.rs b/crates/wasmtime/src/runtime/vm/arch/s390x.rs
new file mode 100644
index 000000000000..e2f53ecb4797
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/arch/s390x.rs
@@ -0,0 +1,30 @@
+//! s390x-specific definitions of architecture-specific functions in Wasmtime.
+
+#[inline]
+#[allow(missing_docs)]
+pub fn get_stack_pointer() -> usize {
+    psm::stack_pointer() as usize
+}
+
+pub unsafe fn get_next_older_pc_from_fp(fp: usize) -> usize {
+    // The next older PC can be found in register %r14 at function entry, which
+    // was saved into slot 14 of the register save area pointed to by "FP" (the
+    // backchain pointer).
+    *(fp as *mut usize).offset(14)
+}
+
+// The next older "FP" (backchain pointer) was saved in the slot pointed to
+// by the current "FP".
+pub const NEXT_OLDER_FP_FROM_FP_OFFSET: usize = 0;
+
+pub fn reached_entry_sp(fp: usize, entry_sp: usize) -> bool {
+    fp > entry_sp
+}
+
+pub fn assert_entry_sp_is_aligned(sp: usize) {
+    assert_eq!(sp % 8, 0, "stack should always be aligned to 8");
+}
+
+pub fn assert_fp_is_aligned(fp: usize) {
+    assert_eq!(fp % 8, 0, "stack should always be aligned to 8");
+}
diff --git a/crates/wasmtime/src/runtime/vm/arch/unsupported.rs b/crates/wasmtime/src/runtime/vm/arch/unsupported.rs
new file mode 100644
index 000000000000..d4073fbaecb6
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/arch/unsupported.rs
@@ -0,0 +1,44 @@
+compile_error!("Wasmtime's runtime is being compiled for an architecture that it does not support");
+
+cfg_if::cfg_if! {
+    if #[cfg(target_arch = "x86")] {
+    compile_error!("\
+the tracking issue for i686 support is https://github.com/bytecodealliance/wasmtime/issues/1980 \
+");
+    } else if #[cfg(target_arch = "arm")] {
+    compile_error!("\
+the tracking issue for arm support is https://github.com/bytecodealliance/wasmtime/issues/1173 \
+");
+    } else if #[cfg(target_arch = "riscv32")] {
+    compile_error!("\
+the tracking issue for riscv32 support is https://github.com/bytecodealliance/wasmtime/issues/8768 \
+");
+    } else {
+    compile_error!("\
+if you'd like feel free to file an issue for platform support at
+https://github.com/bytecodealliance/wasmtime/issues/new
+");
+    }
+}
+
+pub fn get_stack_pointer() -> usize {
+    panic!()
+}
+
+pub unsafe fn get_next_older_pc_from_fp(_fp: usize) -> usize {
+    panic!()
+}
+
+pub const NEXT_OLDER_FP_FROM_FP_OFFSET: usize = 0;
+
+pub fn reached_entry_sp(_fp: usize, _entry_sp: usize) -> bool {
+    panic!()
+}
+
+pub fn assert_entry_sp_is_aligned(_sp: usize) {
+    panic!()
+}
+
+pub fn assert_fp_is_aligned(_fp: usize) {
+    panic!()
+}
diff --git a/crates/wasmtime/src/runtime/vm/arch/x86_64.rs b/crates/wasmtime/src/runtime/vm/arch/x86_64.rs
new file mode 100644
index 000000000000..cd47c4a4b0b2
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/arch/x86_64.rs
@@ -0,0 +1,36 @@
+//! x86_64-specific definitions of architecture-specific functions in Wasmtime.
+
+#[inline]
+#[allow(missing_docs)]
+pub fn get_stack_pointer() -> usize {
+    let stack_pointer: usize;
+    unsafe {
+        core::arch::asm!(
+            "mov {}, rsp",
+            out(reg) stack_pointer,
+            options(nostack,nomem),
+        );
+    }
+    stack_pointer
+}
+
+pub unsafe fn get_next_older_pc_from_fp(fp: usize) -> usize {
+    // The calling convention always pushes the return pointer (aka the PC of
+    // the next older frame) just before this frame.
+    *(fp as *mut usize).offset(1)
+}
+
+// And the current frame pointer points to the next older frame pointer.
+pub const NEXT_OLDER_FP_FROM_FP_OFFSET: usize = 0;
+
+pub fn reached_entry_sp(fp: usize, entry_sp: usize) -> bool {
+    fp >= entry_sp
+}
+
+pub fn assert_entry_sp_is_aligned(sp: usize) {
+    assert_eq!(sp % 16, 0, "stack should always be aligned to 16");
+}
+
+pub fn assert_fp_is_aligned(fp: usize) {
+    assert_eq!(fp % 16, 0, "stack should always be aligned to 16");
+}
diff --git a/crates/wasmtime/src/runtime/vm/async_yield.rs b/crates/wasmtime/src/runtime/vm/async_yield.rs
new file mode 100644
index 000000000000..4b53f990492b
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/async_yield.rs
@@ -0,0 +1,35 @@
+use core::{
+    future::Future,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+/// A small future that yields once and then returns.
+#[derive(Default)]
+pub struct Yield {
+    yielded: bool,
+}
+
+impl Yield {
+    /// Create a new `Yield`.
+    pub fn new() -> Self {
+        Self::default()
+    }
+}
+
+impl Future for Yield {
+    type Output = ();
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
+        if self.yielded {
+            Poll::Ready(())
+        } else {
+            // Flag ourselves as yielded to return next time, and also
+            // flag the waker that we're already ready to get
+            // re-enqueued for another poll.
+            self.yielded = true;
+            cx.waker().wake_by_ref();
+            Poll::Pending
+        }
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/component.rs b/crates/wasmtime/src/runtime/vm/component.rs
new file mode 100644
index 000000000000..a9847355c49b
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/component.rs
@@ -0,0 +1,857 @@
+//! Runtime support for the component model in Wasmtime
+//!
+//! Currently this runtime support includes a `VMComponentContext` which is
+//! similar in purpose to `VMContext`. The context is read from
+//! cranelift-generated trampolines when entering the host from a wasm module.
+//! Eventually it's intended that module-to-module calls, which would be
+//! cranelift-compiled adapters, will use this `VMComponentContext` as well.
+
+use crate::prelude::*;
+use crate::runtime::vm::{
+    SendSyncPtr, Store, VMArrayCallFunction, VMFuncRef, VMGlobalDefinition, VMMemoryDefinition,
+    VMOpaqueContext, VMWasmCallFunction, ValRaw,
+};
+use alloc::alloc::Layout;
+use alloc::sync::Arc;
+use core::any::Any;
+use core::marker;
+use core::mem;
+use core::mem::offset_of;
+use core::ops::Deref;
+use core::ptr::{self, NonNull};
+use sptr::Strict;
+use wasmtime_environ::component::*;
+use wasmtime_environ::{HostPtr, PrimaryMap, VMSharedTypeIndex};
+
+const INVALID_PTR: usize = 0xdead_dead_beef_beef_u64 as usize;
+
+mod libcalls;
+mod resources;
+
+pub use self::resources::{CallContexts, ResourceTable, ResourceTables};
+
+/// Runtime representation of a component instance and all state necessary for
+/// the instance itself.
+///
+/// This type never exists by-value, but rather it's always behind a pointer.
+/// The size of the allocation for `ComponentInstance` includes the trailing
+/// `VMComponentContext` which is variably sized based on the `offsets`
+/// contained within.
+#[repr(C)]
+pub struct ComponentInstance {
+    /// Size and offset information for the trailing `VMComponentContext`.
+    offsets: VMComponentOffsets<HostPtr>,
+
+    /// For more information about this see the documentation on
+    /// `Instance::vmctx_self_reference`.
+    vmctx_self_reference: SendSyncPtr<VMComponentContext>,
+
+    /// Runtime type information about this component.
+    runtime_info: Arc<dyn ComponentRuntimeInfo>,
+
+    /// State of resources for all `TypeResourceTableIndex` values for this
+    /// component.
+    ///
+    /// This is paired with other information to create a `ResourceTables` which
+    /// is how this field is manipulated.
+    component_resource_tables: PrimaryMap<TypeResourceTableIndex, ResourceTable>,
+
+    /// Storage for the type information about resources within this component
+    /// instance.
+    ///
+    /// This is actually `Arc<PrimaryMap<ResourceIndex, ResourceType>>` but that
+    /// can't be in this crate because `ResourceType` isn't here. Not using `dyn
+    /// Any` is left as an exercise for a future refactoring.
+    resource_types: Arc<dyn Any + Send + Sync>,
+
+    /// A zero-sized field which represents the end of the struct for the actual
+    /// `VMComponentContext` to be allocated behind.
+    vmctx: VMComponentContext,
+}
+
+/// Type signature for host-defined trampolines that are called from
+/// WebAssembly.
+///
+/// This function signature is invoked from a cranelift-compiled trampoline that
+/// adapts from the core wasm System-V ABI into the ABI provided here:
+///
+/// * `vmctx` - this is the first argument to the wasm import, and should always
+///   end up being a `VMComponentContext`.
+/// * `data` - this is the data pointer associated with the `VMLowering` for
+///   which this function pointer was registered.
+/// * `ty` - the type index, relative to the tables in `vmctx`, that is the
+///   type of the function being called.
+/// * `flags` - the component flags for may_enter/leave corresponding to the
+///   component instance that the lowering happened within.
+/// * `opt_memory` - this nullable pointer represents the memory configuration
+///   option for the canonical ABI options.
+/// * `opt_realloc` - this nullable pointer represents the realloc configuration
+///   option for the canonical ABI options.
+/// * `string_encoding` - this is the configured string encoding for the
+///   canonical ABI this lowering corresponds to.
+/// * `args_and_results` - pointer to stack-allocated space in the caller where
+///   all the arguments are stored as well as where the results will be written
+///   to. The size and initialized bytes of this depends on the core wasm type
+///   signature that this callee corresponds to.
+/// * `nargs_and_results` - the size, in units of `ValRaw`, of
+///   `args_and_results`.
+//
+// FIXME: 9 arguments is probably too many. The `data` through `string-encoding`
+// parameters should probably get packaged up into the `VMComponentContext`.
+// Needs benchmarking one way or another though to figure out what the best
+// balance is here.
+pub type VMLoweringCallee = extern "C" fn(
+    vmctx: *mut VMOpaqueContext,
+    data: *mut u8,
+    ty: TypeFuncIndex,
+    flags: InstanceFlags,
+    opt_memory: *mut VMMemoryDefinition,
+    opt_realloc: *mut VMFuncRef,
+    string_encoding: StringEncoding,
+    args_and_results: *mut mem::MaybeUninit<ValRaw>,
+    nargs_and_results: usize,
+);
+
+/// Structure describing a lowered host function stored within a
+/// `VMComponentContext` per-lowering.
+#[derive(Copy, Clone)]
+#[repr(C)]
+pub struct VMLowering {
+    /// The host function pointer that is invoked when this lowering is
+    /// invoked.
+    pub callee: VMLoweringCallee,
+    /// The host data pointer (think void* pointer) to get passed to `callee`.
+    pub data: *mut u8,
+}
+
+/// This is a marker type to represent the underlying allocation of a
+/// `VMComponentContext`.
+///
+/// This type is similar to `VMContext` for core wasm and is allocated once per
+/// component instance in Wasmtime. While the static size of this type is 0 the
+/// actual runtime size is variable depending on the shape of the component that
+/// this corresponds to. This structure always trails a `ComponentInstance`
+/// allocation and the allocation/liftetime of this allocation is managed by
+/// `ComponentInstance`.
+#[repr(C)]
+// Set an appropriate alignment for this structure where the most-aligned value
+// internally right now `VMGlobalDefinition` which has an alignment of 16 bytes.
+#[repr(align(16))]
+pub struct VMComponentContext {
+    /// For more information about this see the equivalent field in `VMContext`
+    _marker: marker::PhantomPinned,
+}
+
+impl ComponentInstance {
+    /// Converts the `vmctx` provided into a `ComponentInstance` and runs the
+    /// provided closure with that instance.
+    ///
+    /// # Unsafety
+    ///
+    /// This is `unsafe` because `vmctx` cannot be guaranteed to be a valid
+    /// pointer and it cannot be proven statically that it's safe to get a
+    /// mutable reference at this time to the instance from `vmctx`.
+    pub unsafe fn from_vmctx<R>(
+        vmctx: *mut VMComponentContext,
+        f: impl FnOnce(&mut ComponentInstance) -> R,
+    ) -> R {
+        let ptr = vmctx
+            .byte_sub(mem::size_of::<ComponentInstance>())
+            .cast::<ComponentInstance>();
+        f(&mut *ptr)
+    }
+
+    /// Returns the layout corresponding to what would be an allocation of a
+    /// `ComponentInstance` for the `offsets` provided.
+    ///
+    /// The returned layout has space for both the `ComponentInstance` and the
+    /// trailing `VMComponentContext`.
+    fn alloc_layout(offsets: &VMComponentOffsets<HostPtr>) -> Layout {
+        let size = mem::size_of::<Self>()
+            .checked_add(usize::try_from(offsets.size_of_vmctx()).unwrap())
+            .unwrap();
+        let align = mem::align_of::<Self>();
+        Layout::from_size_align(size, align).unwrap()
+    }
+
+    /// Initializes an uninitialized pointer to a `ComponentInstance` in
+    /// addition to its trailing `VMComponentContext`.
+    ///
+    /// The `ptr` provided must be valid for `alloc_size` bytes and will be
+    /// entirely overwritten by this function call. The `offsets` correspond to
+    /// the shape of the component being instantiated and `store` is a pointer
+    /// back to the Wasmtime store for host functions to have access to.
+    unsafe fn new_at(
+        ptr: NonNull<ComponentInstance>,
+        alloc_size: usize,
+        offsets: VMComponentOffsets<HostPtr>,
+        runtime_info: Arc<dyn ComponentRuntimeInfo>,
+        resource_types: Arc<dyn Any + Send + Sync>,
+        store: *mut dyn Store,
+    ) {
+        assert!(alloc_size >= Self::alloc_layout(&offsets).size());
+
+        let num_tables = runtime_info.component().num_resource_tables;
+        let mut component_resource_tables = PrimaryMap::with_capacity(num_tables);
+        for _ in 0..num_tables {
+            component_resource_tables.push(ResourceTable::default());
+        }
+
+        ptr::write(
+            ptr.as_ptr(),
+            ComponentInstance {
+                offsets,
+                vmctx_self_reference: SendSyncPtr::new(
+                    NonNull::new(
+                        ptr.as_ptr()
+                            .byte_add(mem::size_of::<ComponentInstance>())
+                            .cast(),
+                    )
+                    .unwrap(),
+                ),
+                component_resource_tables,
+                runtime_info,
+                resource_types,
+                vmctx: VMComponentContext {
+                    _marker: marker::PhantomPinned,
+                },
+            },
+        );
+
+        (*ptr.as_ptr()).initialize_vmctx(store);
+    }
+
+    fn vmctx(&self) -> *mut VMComponentContext {
+        let addr = core::ptr::addr_of!(self.vmctx);
+        Strict::with_addr(self.vmctx_self_reference.as_ptr(), Strict::addr(addr))
+    }
+
+    unsafe fn vmctx_plus_offset<T>(&self, offset: u32) -> *const T {
+        self.vmctx()
+            .byte_add(usize::try_from(offset).unwrap())
+            .cast()
+    }
+
+    unsafe fn vmctx_plus_offset_mut<T>(&mut self, offset: u32) -> *mut T {
+        self.vmctx()
+            .byte_add(usize::try_from(offset).unwrap())
+            .cast()
+    }
+
+    /// Returns a pointer to the "may leave" flag for this instance specified
+    /// for canonical lowering and lifting operations.
+    #[inline]
+    pub fn instance_flags(&self, instance: RuntimeComponentInstanceIndex) -> InstanceFlags {
+        unsafe {
+            let ptr = self
+                .vmctx_plus_offset::<VMGlobalDefinition>(self.offsets.instance_flags(instance))
+                .cast_mut();
+            InstanceFlags(SendSyncPtr::new(NonNull::new(ptr).unwrap()))
+        }
+    }
+
+    /// Returns the store that this component was created with.
+    pub fn store(&self) -> *mut dyn Store {
+        unsafe {
+            let ret = *self.vmctx_plus_offset::<*mut dyn Store>(self.offsets.store());
+            assert!(!ret.is_null());
+            ret
+        }
+    }
+
+    /// Returns the runtime memory definition corresponding to the index of the
+    /// memory provided.
+    ///
+    /// This can only be called after `idx` has been initialized at runtime
+    /// during the instantiation process of a component.
+    pub fn runtime_memory(&self, idx: RuntimeMemoryIndex) -> *mut VMMemoryDefinition {
+        unsafe {
+            let ret = *self.vmctx_plus_offset(self.offsets.runtime_memory(idx));
+            debug_assert!(ret as usize != INVALID_PTR);
+            ret
+        }
+    }
+
+    /// Returns the realloc pointer corresponding to the index provided.
+    ///
+    /// This can only be called after `idx` has been initialized at runtime
+    /// during the instantiation process of a component.
+    pub fn runtime_realloc(&self, idx: RuntimeReallocIndex) -> NonNull<VMFuncRef> {
+        unsafe {
+            let ret = *self.vmctx_plus_offset::<NonNull<_>>(self.offsets.runtime_realloc(idx));
+            debug_assert!(ret.as_ptr() as usize != INVALID_PTR);
+            ret
+        }
+    }
+
+    /// Returns the post-return pointer corresponding to the index provided.
+    ///
+    /// This can only be called after `idx` has been initialized at runtime
+    /// during the instantiation process of a component.
+    pub fn runtime_post_return(&self, idx: RuntimePostReturnIndex) -> NonNull<VMFuncRef> {
+        unsafe {
+            let ret = *self.vmctx_plus_offset::<NonNull<_>>(self.offsets.runtime_post_return(idx));
+            debug_assert!(ret.as_ptr() as usize != INVALID_PTR);
+            ret
+        }
+    }
+
+    /// Returns the host information for the lowered function at the index
+    /// specified.
+    ///
+    /// This can only be called after `idx` has been initialized at runtime
+    /// during the instantiation process of a component.
+    pub fn lowering(&self, idx: LoweredIndex) -> VMLowering {
+        unsafe {
+            let ret = *self.vmctx_plus_offset::<VMLowering>(self.offsets.lowering(idx));
+            debug_assert!(ret.callee as usize != INVALID_PTR);
+            debug_assert!(ret.data as usize != INVALID_PTR);
+            ret
+        }
+    }
+
+    /// Returns the core wasm `funcref` corresponding to the trampoline
+    /// specified.
+    ///
+    /// The returned function is suitable to pass directly to a wasm module
+    /// instantiation and the function contains cranelift-compiled trampolines.
+    ///
+    /// This can only be called after `idx` has been initialized at runtime
+    /// during the instantiation process of a component.
+    pub fn trampoline_func_ref(&self, idx: TrampolineIndex) -> NonNull<VMFuncRef> {
+        unsafe {
+            let offset = self.offsets.trampoline_func_ref(idx);
+            let ret = self.vmctx_plus_offset::<VMFuncRef>(offset);
+            debug_assert!(
+                mem::transmute::<Option<NonNull<VMWasmCallFunction>>, usize>((*ret).wasm_call)
+                    != INVALID_PTR
+            );
+            debug_assert!((*ret).vmctx as usize != INVALID_PTR);
+            NonNull::new(ret.cast_mut()).unwrap()
+        }
+    }
+
+    /// Stores the runtime memory pointer at the index specified.
+    ///
+    /// This is intended to be called during the instantiation process of a
+    /// component once a memory is available, which may not be until part-way
+    /// through component instantiation.
+    ///
+    /// Note that it should be a property of the component model that the `ptr`
+    /// here is never needed prior to it being configured here in the instance.
+    pub fn set_runtime_memory(&mut self, idx: RuntimeMemoryIndex, ptr: *mut VMMemoryDefinition) {
+        unsafe {
+            debug_assert!(!ptr.is_null());
+            let storage = self.vmctx_plus_offset_mut(self.offsets.runtime_memory(idx));
+            debug_assert!(*storage as usize == INVALID_PTR);
+            *storage = ptr;
+        }
+    }
+
+    /// Same as `set_runtime_memory` but for realloc function pointers.
+    pub fn set_runtime_realloc(&mut self, idx: RuntimeReallocIndex, ptr: NonNull<VMFuncRef>) {
+        unsafe {
+            let storage = self.vmctx_plus_offset_mut(self.offsets.runtime_realloc(idx));
+            debug_assert!(*storage as usize == INVALID_PTR);
+            *storage = ptr.as_ptr();
+        }
+    }
+
+    /// Same as `set_runtime_memory` but for post-return function pointers.
+    pub fn set_runtime_post_return(
+        &mut self,
+        idx: RuntimePostReturnIndex,
+        ptr: NonNull<VMFuncRef>,
+    ) {
+        unsafe {
+            let storage = self.vmctx_plus_offset_mut(self.offsets.runtime_post_return(idx));
+            debug_assert!(*storage as usize == INVALID_PTR);
+            *storage = ptr.as_ptr();
+        }
+    }
+
+    /// Configures host runtime lowering information associated with imported f
+    /// functions for the `idx` specified.
+    pub fn set_lowering(&mut self, idx: LoweredIndex, lowering: VMLowering) {
+        unsafe {
+            debug_assert!(
+                *self.vmctx_plus_offset::<usize>(self.offsets.lowering_callee(idx)) == INVALID_PTR
+            );
+            debug_assert!(
+                *self.vmctx_plus_offset::<usize>(self.offsets.lowering_data(idx)) == INVALID_PTR
+            );
+            *self.vmctx_plus_offset_mut(self.offsets.lowering(idx)) = lowering;
+        }
+    }
+
+    /// Same as `set_lowering` but for the resource.drop functions.
+    pub fn set_trampoline(
+        &mut self,
+        idx: TrampolineIndex,
+        wasm_call: NonNull<VMWasmCallFunction>,
+        array_call: VMArrayCallFunction,
+        type_index: VMSharedTypeIndex,
+    ) {
+        unsafe {
+            let offset = self.offsets.trampoline_func_ref(idx);
+            debug_assert!(*self.vmctx_plus_offset::<usize>(offset) == INVALID_PTR);
+            let vmctx = VMOpaqueContext::from_vmcomponent(self.vmctx());
+            *self.vmctx_plus_offset_mut(offset) = VMFuncRef {
+                wasm_call: Some(wasm_call),
+                array_call,
+                type_index,
+                vmctx,
+            };
+        }
+    }
+
+    /// Configures the destructor for a resource at the `idx` specified.
+    ///
+    /// This is required to be called for each resource as it's defined within a
+    /// component during the instantiation process.
+    pub fn set_resource_destructor(
+        &mut self,
+        idx: ResourceIndex,
+        dtor: Option<NonNull<VMFuncRef>>,
+    ) {
+        unsafe {
+            let offset = self.offsets.resource_destructor(idx);
+            debug_assert!(*self.vmctx_plus_offset::<usize>(offset) == INVALID_PTR);
+            *self.vmctx_plus_offset_mut(offset) = dtor;
+        }
+    }
+
+    /// Returns the destructor, if any, for `idx`.
+    ///
+    /// This is only valid to call after `set_resource_destructor`, or typically
+    /// after instantiation.
+    pub fn resource_destructor(&self, idx: ResourceIndex) -> Option<NonNull<VMFuncRef>> {
+        unsafe {
+            let offset = self.offsets.resource_destructor(idx);
+            debug_assert!(*self.vmctx_plus_offset::<usize>(offset) != INVALID_PTR);
+            *self.vmctx_plus_offset(offset)
+        }
+    }
+
+    unsafe fn initialize_vmctx(&mut self, store: *mut dyn Store) {
+        *self.vmctx_plus_offset_mut(self.offsets.magic()) = VMCOMPONENT_MAGIC;
+        *self.vmctx_plus_offset_mut(self.offsets.libcalls()) = &libcalls::VMComponentLibcalls::INIT;
+        *self.vmctx_plus_offset_mut(self.offsets.store()) = store;
+        *self.vmctx_plus_offset_mut(self.offsets.limits()) = (*store).vmruntime_limits();
+
+        for i in 0..self.offsets.num_runtime_component_instances {
+            let i = RuntimeComponentInstanceIndex::from_u32(i);
+            let mut def = VMGlobalDefinition::new();
+            *def.as_i32_mut() = FLAG_MAY_ENTER | FLAG_MAY_LEAVE;
+            *self.instance_flags(i).as_raw() = def;
+        }
+
+        // In debug mode set non-null bad values to all "pointer looking" bits
+        // and pices related to lowering and such. This'll help detect any
+        // erroneous usage and enable debug assertions above as well to prevent
+        // loading these before they're configured or setting them twice.
+        if cfg!(debug_assertions) {
+            for i in 0..self.offsets.num_lowerings {
+                let i = LoweredIndex::from_u32(i);
+                let offset = self.offsets.lowering_callee(i);
+                *self.vmctx_plus_offset_mut(offset) = INVALID_PTR;
+                let offset = self.offsets.lowering_data(i);
+                *self.vmctx_plus_offset_mut(offset) = INVALID_PTR;
+            }
+            for i in 0..self.offsets.num_trampolines {
+                let i = TrampolineIndex::from_u32(i);
+                let offset = self.offsets.trampoline_func_ref(i);
+                *self.vmctx_plus_offset_mut(offset) = INVALID_PTR;
+            }
+            for i in 0..self.offsets.num_runtime_memories {
+                let i = RuntimeMemoryIndex::from_u32(i);
+                let offset = self.offsets.runtime_memory(i);
+                *self.vmctx_plus_offset_mut(offset) = INVALID_PTR;
+            }
+            for i in 0..self.offsets.num_runtime_reallocs {
+                let i = RuntimeReallocIndex::from_u32(i);
+                let offset = self.offsets.runtime_realloc(i);
+                *self.vmctx_plus_offset_mut(offset) = INVALID_PTR;
+            }
+            for i in 0..self.offsets.num_runtime_post_returns {
+                let i = RuntimePostReturnIndex::from_u32(i);
+                let offset = self.offsets.runtime_post_return(i);
+                *self.vmctx_plus_offset_mut(offset) = INVALID_PTR;
+            }
+            for i in 0..self.offsets.num_resources {
+                let i = ResourceIndex::from_u32(i);
+                let offset = self.offsets.resource_destructor(i);
+                *self.vmctx_plus_offset_mut(offset) = INVALID_PTR;
+            }
+        }
+    }
+
+    /// Returns a reference to the component type information for this instance.
+    pub fn component(&self) -> &Component {
+        self.runtime_info.component()
+    }
+
+    /// Returns the type information that this instance is instantiated with.
+    pub fn component_types(&self) -> &Arc<ComponentTypes> {
+        self.runtime_info.component_types()
+    }
+
+    /// Get the canonical ABI's `realloc` function's runtime type.
+    pub fn realloc_func_ty(&self) -> &Arc<dyn Any + Send + Sync> {
+        self.runtime_info.realloc_func_type()
+    }
+
+    /// Returns a reference to the resource type information as a `dyn Any`.
+    ///
+    /// Wasmtime is the one which then downcasts this to the appropriate type.
+    pub fn resource_types(&self) -> &Arc<dyn Any + Send + Sync> {
+        &self.resource_types
+    }
+
+    /// Returns whether the resource that `ty` points to is owned by the
+    /// instance that `ty` correspond to.
+    ///
+    /// This is used when lowering borrows to skip table management and instead
+    /// thread through the underlying representation directly.
+    pub fn resource_owned_by_own_instance(&self, ty: TypeResourceTableIndex) -> bool {
+        let resource = &self.component_types()[ty];
+        let component = self.component();
+        let idx = match component.defined_resource_index(resource.ty) {
+            Some(idx) => idx,
+            None => return false,
+        };
+        resource.instance == component.defined_resource_instances[idx]
+    }
+
+    /// Implementation of the `resource.new` intrinsic for `i32`
+    /// representations.
+    pub fn resource_new32(&mut self, resource: TypeResourceTableIndex, rep: u32) -> Result<u32> {
+        self.resource_tables().resource_new(Some(resource), rep)
+    }
+
+    /// Implementation of the `resource.rep` intrinsic for `i32`
+    /// representations.
+    pub fn resource_rep32(&mut self, resource: TypeResourceTableIndex, idx: u32) -> Result<u32> {
+        self.resource_tables().resource_rep(Some(resource), idx)
+    }
+
+    /// Implementation of the `resource.drop` intrinsic.
+    pub fn resource_drop(
+        &mut self,
+        resource: TypeResourceTableIndex,
+        idx: u32,
+    ) -> Result<Option<u32>> {
+        self.resource_tables().resource_drop(Some(resource), idx)
+    }
+
+    /// NB: this is intended to be a private method. This does not have
+    /// `host_table` information at this time meaning it's only suitable for
+    /// working with resources specified to this component which is currently
+    /// all that this is used for.
+    ///
+    /// If necessary though it's possible to enhance the `Store` trait to thread
+    /// through the relevant information and get `host_table` to be `Some` here.
+    fn resource_tables(&mut self) -> ResourceTables<'_> {
+        ResourceTables {
+            host_table: None,
+            calls: unsafe { (&mut *self.store()).component_calls() },
+            tables: Some(&mut self.component_resource_tables),
+        }
+    }
+
+    /// Returns the runtime state of resources associated with this component.
+    #[inline]
+    pub fn component_resource_tables(
+        &mut self,
+    ) -> &mut PrimaryMap<TypeResourceTableIndex, ResourceTable> {
+        &mut self.component_resource_tables
+    }
+
+    /// Returns the destructor and instance flags for the specified resource
+    /// table type.
+    ///
+    /// This will lookup the origin definition of the `ty` table and return the
+    /// destructor/flags for that.
+    pub fn dtor_and_flags(
+        &self,
+        ty: TypeResourceTableIndex,
+    ) -> (Option<NonNull<VMFuncRef>>, Option<InstanceFlags>) {
+        let resource = self.component_types()[ty].ty;
+        let dtor = self.resource_destructor(resource);
+        let component = self.component();
+        let flags = component.defined_resource_index(resource).map(|i| {
+            let instance = component.defined_resource_instances[i];
+            self.instance_flags(instance)
+        });
+        (dtor, flags)
+    }
+
+    pub(crate) fn resource_transfer_own(
+        &mut self,
+        idx: u32,
+        src: TypeResourceTableIndex,
+        dst: TypeResourceTableIndex,
+    ) -> Result<u32> {
+        let mut tables = self.resource_tables();
+        let rep = tables.resource_lift_own(Some(src), idx)?;
+        tables.resource_lower_own(Some(dst), rep)
+    }
+
+    pub(crate) fn resource_transfer_borrow(
+        &mut self,
+        idx: u32,
+        src: TypeResourceTableIndex,
+        dst: TypeResourceTableIndex,
+    ) -> Result<u32> {
+        let dst_owns_resource = self.resource_owned_by_own_instance(dst);
+        let mut tables = self.resource_tables();
+        let rep = tables.resource_lift_borrow(Some(src), idx)?;
+        // Implement `lower_borrow`'s special case here where if a borrow's
+        // resource type is owned by `dst` then the destination receives the
+        // representation directly rather than a handle to the representation.
+        //
+        // This can perhaps become a different libcall in the future to avoid
+        // this check at runtime since we know at compile time whether the
+        // destination type owns the resource, but that's left as a future
+        // refactoring if truly necessary.
+        if dst_owns_resource {
+            return Ok(rep);
+        }
+        tables.resource_lower_borrow(Some(dst), rep)
+    }
+
+    pub(crate) fn resource_enter_call(&mut self) {
+        self.resource_tables().enter_call()
+    }
+
+    pub(crate) fn resource_exit_call(&mut self) -> Result<()> {
+        self.resource_tables().exit_call()
+    }
+}
+
+impl VMComponentContext {
+    /// Moves the `self` pointer backwards to the `ComponentInstance` pointer
+    /// that this `VMComponentContext` trails.
+    pub fn instance(&self) -> *mut ComponentInstance {
+        unsafe {
+            (self as *const Self as *mut u8)
+                .offset(-(offset_of!(ComponentInstance, vmctx) as isize))
+                as *mut ComponentInstance
+        }
+    }
+}
+
+/// An owned version of `ComponentInstance` which is akin to
+/// `Box<ComponentInstance>`.
+///
+/// This type can be dereferenced to `ComponentInstance` to access the
+/// underlying methods.
+pub struct OwnedComponentInstance {
+    ptr: SendSyncPtr<ComponentInstance>,
+}
+
+impl OwnedComponentInstance {
+    /// Allocates a new `ComponentInstance + VMComponentContext` pair on the
+    /// heap with `malloc` and configures it for the `component` specified.
+    pub fn new(
+        runtime_info: Arc<dyn ComponentRuntimeInfo>,
+        resource_types: Arc<dyn Any + Send + Sync>,
+        store: *mut dyn Store,
+    ) -> OwnedComponentInstance {
+        let component = runtime_info.component();
+        let offsets = VMComponentOffsets::new(HostPtr, component);
+        let layout = ComponentInstance::alloc_layout(&offsets);
+        unsafe {
+            // Technically it is not required to `alloc_zeroed` here. The
+            // primary reason for doing this is because a component context
+            // start is a "partly initialized" state where pointers and such are
+            // configured as the instantiation process continues. The component
+            // model should guarantee that we never access uninitialized memory
+            // in the context, but to help protect against possible bugs a
+            // zeroed allocation is done here to try to contain
+            // use-before-initialized issues.
+            let ptr = alloc::alloc::alloc_zeroed(layout) as *mut ComponentInstance;
+            let ptr = NonNull::new(ptr).unwrap();
+
+            ComponentInstance::new_at(
+                ptr,
+                layout.size(),
+                offsets,
+                runtime_info,
+                resource_types,
+                store,
+            );
+
+            let ptr = SendSyncPtr::new(ptr);
+            OwnedComponentInstance { ptr }
+        }
+    }
+
+    // Note that this is technically unsafe due to the fact that it enables
+    // `mem::swap`-ing two component instances which would get all the offsets
+    // mixed up and cause issues. This is scoped to just this module though as a
+    // convenience to forward to `&mut` methods on `ComponentInstance`.
+    unsafe fn instance_mut(&mut self) -> &mut ComponentInstance {
+        &mut *self.ptr.as_ptr()
+    }
+
+    /// Returns the underlying component instance's raw pointer.
+    pub fn instance_ptr(&self) -> *mut ComponentInstance {
+        self.ptr.as_ptr()
+    }
+
+    /// See `ComponentInstance::set_runtime_memory`
+    pub fn set_runtime_memory(&mut self, idx: RuntimeMemoryIndex, ptr: *mut VMMemoryDefinition) {
+        unsafe { self.instance_mut().set_runtime_memory(idx, ptr) }
+    }
+
+    /// See `ComponentInstance::set_runtime_realloc`
+    pub fn set_runtime_realloc(&mut self, idx: RuntimeReallocIndex, ptr: NonNull<VMFuncRef>) {
+        unsafe { self.instance_mut().set_runtime_realloc(idx, ptr) }
+    }
+
+    /// See `ComponentInstance::set_runtime_post_return`
+    pub fn set_runtime_post_return(
+        &mut self,
+        idx: RuntimePostReturnIndex,
+        ptr: NonNull<VMFuncRef>,
+    ) {
+        unsafe { self.instance_mut().set_runtime_post_return(idx, ptr) }
+    }
+
+    /// See `ComponentInstance::set_lowering`
+    pub fn set_lowering(&mut self, idx: LoweredIndex, lowering: VMLowering) {
+        unsafe { self.instance_mut().set_lowering(idx, lowering) }
+    }
+
+    /// See `ComponentInstance::set_resource_drop`
+    pub fn set_trampoline(
+        &mut self,
+        idx: TrampolineIndex,
+        wasm_call: NonNull<VMWasmCallFunction>,
+        array_call: VMArrayCallFunction,
+        type_index: VMSharedTypeIndex,
+    ) {
+        unsafe {
+            self.instance_mut()
+                .set_trampoline(idx, wasm_call, array_call, type_index)
+        }
+    }
+
+    /// See `ComponentInstance::set_resource_destructor`
+    pub fn set_resource_destructor(
+        &mut self,
+        idx: ResourceIndex,
+        dtor: Option<NonNull<VMFuncRef>>,
+    ) {
+        unsafe { self.instance_mut().set_resource_destructor(idx, dtor) }
+    }
+
+    /// See `ComponentInstance::resource_types`
+    pub fn resource_types_mut(&mut self) -> &mut Arc<dyn Any + Send + Sync> {
+        unsafe { &mut (*self.ptr.as_ptr()).resource_types }
+    }
+}
+
+impl Deref for OwnedComponentInstance {
+    type Target = ComponentInstance;
+    fn deref(&self) -> &ComponentInstance {
+        unsafe { &*self.ptr.as_ptr() }
+    }
+}
+
+impl Drop for OwnedComponentInstance {
+    fn drop(&mut self) {
+        let layout = ComponentInstance::alloc_layout(&self.offsets);
+        unsafe {
+            ptr::drop_in_place(self.ptr.as_ptr());
+            alloc::alloc::dealloc(self.ptr.as_ptr().cast(), layout);
+        }
+    }
+}
+
+impl VMComponentContext {
+    /// Helper function to cast between context types using a debug assertion to
+    /// protect against some mistakes.
+    #[inline]
+    pub unsafe fn from_opaque(opaque: *mut VMOpaqueContext) -> *mut VMComponentContext {
+        // See comments in `VMContext::from_opaque` for this debug assert
+        debug_assert_eq!((*opaque).magic, VMCOMPONENT_MAGIC);
+        opaque.cast()
+    }
+}
+
+impl VMOpaqueContext {
+    /// Helper function to clearly indicate the cast desired
+    #[inline]
+    pub fn from_vmcomponent(ptr: *mut VMComponentContext) -> *mut VMOpaqueContext {
+        ptr.cast()
+    }
+}
+
+#[allow(missing_docs)]
+#[repr(transparent)]
+#[derive(Copy, Clone)]
+pub struct InstanceFlags(SendSyncPtr<VMGlobalDefinition>);
+
+#[allow(missing_docs)]
+impl InstanceFlags {
+    #[inline]
+    pub unsafe fn may_leave(&self) -> bool {
+        *(*self.as_raw()).as_i32() & FLAG_MAY_LEAVE != 0
+    }
+
+    #[inline]
+    pub unsafe fn set_may_leave(&mut self, val: bool) {
+        if val {
+            *(*self.as_raw()).as_i32_mut() |= FLAG_MAY_LEAVE;
+        } else {
+            *(*self.as_raw()).as_i32_mut() &= !FLAG_MAY_LEAVE;
+        }
+    }
+
+    #[inline]
+    pub unsafe fn may_enter(&self) -> bool {
+        *(*self.as_raw()).as_i32() & FLAG_MAY_ENTER != 0
+    }
+
+    #[inline]
+    pub unsafe fn set_may_enter(&mut self, val: bool) {
+        if val {
+            *(*self.as_raw()).as_i32_mut() |= FLAG_MAY_ENTER;
+        } else {
+            *(*self.as_raw()).as_i32_mut() &= !FLAG_MAY_ENTER;
+        }
+    }
+
+    #[inline]
+    pub unsafe fn needs_post_return(&self) -> bool {
+        *(*self.as_raw()).as_i32() & FLAG_NEEDS_POST_RETURN != 0
+    }
+
+    #[inline]
+    pub unsafe fn set_needs_post_return(&mut self, val: bool) {
+        if val {
+            *(*self.as_raw()).as_i32_mut() |= FLAG_NEEDS_POST_RETURN;
+        } else {
+            *(*self.as_raw()).as_i32_mut() &= !FLAG_NEEDS_POST_RETURN;
+        }
+    }
+
+    #[inline]
+    pub fn as_raw(&self) -> *mut VMGlobalDefinition {
+        self.0.as_ptr()
+    }
+}
+
+/// Runtime information about a component stored locally for reflection.
+pub trait ComponentRuntimeInfo: Send + Sync + 'static {
+    /// Returns the type information about the compiled component.
+    fn component(&self) -> &Component;
+
+    /// Returns a handle to the tables of type information for this component.
+    fn component_types(&self) -> &Arc<ComponentTypes>;
+
+    /// Get the `wasmtime::FuncType` for the canonical ABI's `realloc` function.
+    fn realloc_func_type(&self) -> &Arc<dyn Any + Send + Sync>;
+}
diff --git a/crates/wasmtime/src/runtime/vm/component/libcalls.rs b/crates/wasmtime/src/runtime/vm/component/libcalls.rs
new file mode 100644
index 000000000000..34d2a0c1813e
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/component/libcalls.rs
@@ -0,0 +1,571 @@
+//! Implementation of string transcoding required by the component model.
+
+use crate::prelude::*;
+use crate::runtime::vm::component::{ComponentInstance, VMComponentContext};
+use core::cell::Cell;
+use core::slice;
+use wasmtime_environ::component::TypeResourceTableIndex;
+
+const UTF16_TAG: usize = 1 << 31;
+
+#[repr(C)] // this is read by Cranelift code so it's layout must be as-written
+pub struct VMComponentLibcalls {
+    builtins: VMComponentBuiltins,
+    transcoders: VMBuiltinTranscodeArray,
+}
+
+impl VMComponentLibcalls {
+    pub const INIT: VMComponentLibcalls = VMComponentLibcalls {
+        builtins: VMComponentBuiltins::INIT,
+        transcoders: VMBuiltinTranscodeArray::INIT,
+    };
+}
+
+macro_rules! signature {
+    (@ty size) => (usize);
+    (@ty size_pair) => (usize);
+    (@ty ptr_u8) => (*mut u8);
+    (@ty ptr_u16) => (*mut u16);
+    (@ty ptr_size) => (*mut usize);
+    (@ty u32) => (u32);
+    (@ty u64) => (u64);
+    (@ty vmctx) => (*mut VMComponentContext);
+
+    (@retptr size_pair) => (*mut usize);
+    (@retptr $other:ident) => (());
+}
+
+/// Defines a `VMComponentBuiltins` structure which contains any builtins such
+/// as resource-related intrinsics.
+macro_rules! define_builtins {
+    (
+        $(
+            $( #[$attr:meta] )*
+            $name:ident( $( $pname:ident: $param:ident ),* ) $( -> $result:ident )?;
+        )*
+    ) => {
+        /// An array that stores addresses of builtin functions. We translate code
+        /// to use indirect calls. This way, we don't have to patch the code.
+        #[repr(C)]
+        struct VMComponentBuiltins {
+            $(
+                $name: unsafe extern "C" fn(
+                    $(signature!(@ty $param),)*
+                ) $( -> signature!(@ty $result))?,
+            )*
+        }
+
+        impl VMComponentBuiltins {
+            const INIT: VMComponentBuiltins = VMComponentBuiltins {
+                $($name: trampolines::$name,)*
+            };
+        }
+    };
+}
+
+wasmtime_environ::foreach_builtin_component_function!(define_builtins);
+
+/// Macro to define the `VMBuiltinTranscodeArray` type which contains all of the
+/// function pointers to the actual transcoder functions. This structure is read
+/// by Cranelift-generated code, hence the `repr(C)`.
+///
+/// Note that this references the `trampolines` module rather than the functions
+/// below as the `trampolines` module has the raw ABI.
+///
+/// This is modeled after the similar macros and usages in `libcalls.rs` and
+/// `vmcontext.rs`
+macro_rules! define_transcoders {
+    (
+        $(
+            $( #[$attr:meta] )*
+            $name:ident( $( $pname:ident: $param:ident ),* ) $( -> $result:ident )?;
+        )*
+    ) => {
+        /// An array that stores addresses of builtin functions. We translate code
+        /// to use indirect calls. This way, we don't have to patch the code.
+        #[repr(C)]
+        struct VMBuiltinTranscodeArray {
+            $(
+                $name: unsafe extern "C" fn(
+                    $(signature!(@ty $param),)*
+                ) $( -> signature!(@ty $result))?,
+            )*
+        }
+
+        impl VMBuiltinTranscodeArray {
+            const INIT: VMBuiltinTranscodeArray = VMBuiltinTranscodeArray {
+                $($name: trampolines::$name,)*
+            };
+        }
+    };
+}
+
+wasmtime_environ::foreach_transcoder!(define_transcoders);
+
+/// Submodule with macro-generated constants which are the actual libcall
+/// transcoders that are invoked by Cranelift. These functions have a specific
+/// ABI defined by the macro itself and will defer to the actual bodies of each
+/// implementation following this submodule.
+#[allow(improper_ctypes_definitions)]
+mod trampolines {
+    use super::VMComponentContext;
+
+    macro_rules! shims {
+        (
+            $(
+                $( #[$attr:meta] )*
+                $name:ident( $( $pname:ident: $param:ident ),* ) $( -> $result:ident )?;
+            )*
+        ) => (
+            $(
+                pub unsafe extern "C" fn $name(
+                    $($pname : signature!(@ty $param),)*
+                ) $( -> signature!(@ty $result))? {
+                    $(shims!(@validate_param $pname $param);)*
+
+                    // Always catch panics to avoid trying to unwind from Rust
+                    // into Cranelift-generated code which would lead to a Bad
+                    // Time.
+                    //
+                    // Additionally assume that every function below returns a
+                    // `Result` where errors turn into traps.
+                    let result = crate::runtime::vm::traphandlers::catch_unwind_and_longjmp(|| {
+                        shims!(@invoke $name() $($pname)*)
+                    });
+                    match result {
+                        Ok(ret) => shims!(@convert_ret ret $($pname: $param)*),
+                        Err(err) => crate::runtime::vm::traphandlers::raise_trap(
+                            crate::runtime::vm::traphandlers::TrapReason::User {
+                                error: err,
+                                needs_backtrace: true,
+                            },
+                        ),
+                    }
+                }
+            )*
+        );
+
+        // Helper macro to convert a 2-tuple automatically when the last
+        // parameter is a `ptr_size` argument.
+        (@convert_ret $ret:ident) => ($ret);
+        (@convert_ret $ret:ident $retptr:ident: ptr_size) => ({
+            let (a, b) = $ret;
+            *$retptr = b;
+            a
+        });
+        (@convert_ret $ret:ident $name:ident: $ty:ident $($rest:tt)*) => (
+            shims!(@convert_ret $ret $($rest)*)
+        );
+
+        (@validate_param $arg:ident ptr_u16) => ({
+            // This should already be guaranteed by the canonical ABI and our
+            // adapter modules, but double-check here to be extra-sure. If this
+            // is a perf concern it can become a `debug_assert!`.
+            assert!(($arg as usize) % 2 == 0, "unaligned 16-bit pointer");
+        });
+        (@validate_param $arg:ident $ty:ident) => ();
+
+        // Helper macro to invoke `$m` with all of the tokens passed except for
+        // any argument named `ret2`
+        (@invoke $m:ident ($($args:tt)*)) => (super::$m($($args)*));
+
+        // ignore `ret2`-named arguments
+        (@invoke $m:ident ($($args:tt)*) ret2 $($rest:tt)*) => (
+            shims!(@invoke $m ($($args)*) $($rest)*)
+        );
+
+        // move all other arguments into the `$args` list
+        (@invoke $m:ident ($($args:tt)*) $param:ident $($rest:tt)*) => (
+            shims!(@invoke $m ($($args)* $param,) $($rest)*)
+        );
+    }
+
+    wasmtime_environ::foreach_builtin_component_function!(shims);
+    wasmtime_environ::foreach_transcoder!(shims);
+}
+
+/// This property should already be guaranteed by construction in the component
+/// model but assert it here to be extra sure. Nothing below is sound if regions
+/// can overlap.
+fn assert_no_overlap<T, U>(a: &[T], b: &[U]) {
+    let a_start = a.as_ptr() as usize;
+    let a_end = a_start + (a.len() * core::mem::size_of::<T>());
+    let b_start = b.as_ptr() as usize;
+    let b_end = b_start + (b.len() * core::mem::size_of::<U>());
+
+    if a_start < b_start {
+        assert!(a_end < b_start);
+    } else {
+        assert!(b_end < a_start);
+    }
+}
+
+/// Converts a utf8 string to a utf8 string.
+///
+/// The length provided is length of both the source and the destination
+/// buffers. No value is returned other than whether an invalid string was
+/// found.
+unsafe fn utf8_to_utf8(src: *mut u8, len: usize, dst: *mut u8) -> Result<()> {
+    let src = slice::from_raw_parts(src, len);
+    let dst = slice::from_raw_parts_mut(dst, len);
+    assert_no_overlap(src, dst);
+    log::trace!("utf8-to-utf8 {len}");
+    let src = core::str::from_utf8(src).map_err(|_| anyhow!("invalid utf8 encoding"))?;
+    dst.copy_from_slice(src.as_bytes());
+    Ok(())
+}
+
+/// Converts a utf16 string to a utf16 string.
+///
+/// The length provided is length of both the source and the destination
+/// buffers. No value is returned other than whether an invalid string was
+/// found.
+unsafe fn utf16_to_utf16(src: *mut u16, len: usize, dst: *mut u16) -> Result<()> {
+    let src = slice::from_raw_parts(src, len);
+    let dst = slice::from_raw_parts_mut(dst, len);
+    assert_no_overlap(src, dst);
+    log::trace!("utf16-to-utf16 {len}");
+    run_utf16_to_utf16(src, dst)?;
+    Ok(())
+}
+
+/// Transcodes utf16 to itself, returning whether all code points were inside of
+/// the latin1 space.
+fn run_utf16_to_utf16(src: &[u16], mut dst: &mut [u16]) -> Result<bool> {
+    let mut all_latin1 = true;
+    for ch in core::char::decode_utf16(src.iter().map(|i| u16::from_le(*i))) {
+        let ch = ch.map_err(|_| anyhow!("invalid utf16 encoding"))?;
+        all_latin1 = all_latin1 && u8::try_from(u32::from(ch)).is_ok();
+        let result = ch.encode_utf16(dst);
+        let size = result.len();
+        for item in result {
+            *item = item.to_le();
+        }
+        dst = &mut dst[size..];
+    }
+    Ok(all_latin1)
+}
+
+/// Converts a latin1 string to a latin1 string.
+///
+/// Given that all byte sequences are valid latin1 strings this is simply a
+/// memory copy.
+unsafe fn latin1_to_latin1(src: *mut u8, len: usize, dst: *mut u8) -> Result<()> {
+    let src = slice::from_raw_parts(src, len);
+    let dst = slice::from_raw_parts_mut(dst, len);
+    assert_no_overlap(src, dst);
+    log::trace!("latin1-to-latin1 {len}");
+    dst.copy_from_slice(src);
+    Ok(())
+}
+
+/// Converts a latin1 string to a utf16 string.
+///
+/// This simply inflates the latin1 characters to the u16 code points. The
+/// length provided is the same length of the source and destination buffers.
+unsafe fn latin1_to_utf16(src: *mut u8, len: usize, dst: *mut u16) -> Result<()> {
+    let src = slice::from_raw_parts(src, len);
+    let dst = slice::from_raw_parts_mut(dst, len);
+    assert_no_overlap(src, dst);
+    for (src, dst) in src.iter().zip(dst) {
+        *dst = u16::from(*src).to_le();
+    }
+    log::trace!("latin1-to-utf16 {len}");
+    Ok(())
+}
+
+/// Converts utf8 to utf16.
+///
+/// The length provided is the same unit length of both buffers, and the
+/// returned value from this function is how many u16 units were written.
+unsafe fn utf8_to_utf16(src: *mut u8, len: usize, dst: *mut u16) -> Result<usize> {
+    let src = slice::from_raw_parts(src, len);
+    let dst = slice::from_raw_parts_mut(dst, len);
+    assert_no_overlap(src, dst);
+
+    let result = run_utf8_to_utf16(src, dst)?;
+    log::trace!("utf8-to-utf16 {len} => {result}");
+    Ok(result)
+}
+
+fn run_utf8_to_utf16(src: &[u8], dst: &mut [u16]) -> Result<usize> {
+    let src = core::str::from_utf8(src).map_err(|_| anyhow!("invalid utf8 encoding"))?;
+    let mut amt = 0;
+    for (i, dst) in src.encode_utf16().zip(dst) {
+        *dst = i.to_le();
+        amt += 1;
+    }
+    Ok(amt)
+}
+
+/// Converts utf16 to utf8.
+///
+/// Each buffer is specified independently here and the returned value is a pair
+/// of the number of code units read and code units written. This might perform
+/// a partial transcode if the destination buffer is not large enough to hold
+/// the entire contents.
+unsafe fn utf16_to_utf8(
+    src: *mut u16,
+    src_len: usize,
+    dst: *mut u8,
+    dst_len: usize,
+) -> Result<(usize, usize)> {
+    let src = slice::from_raw_parts(src, src_len);
+    let mut dst = slice::from_raw_parts_mut(dst, dst_len);
+    assert_no_overlap(src, dst);
+
+    // This iterator will convert to native endianness and additionally count
+    // how many items have been read from the iterator so far. This
+    // count is used to return how many of the source code units were read.
+    let src_iter_read = Cell::new(0);
+    let src_iter = src.iter().map(|i| {
+        src_iter_read.set(src_iter_read.get() + 1);
+        u16::from_le(*i)
+    });
+
+    let mut src_read = 0;
+    let mut dst_written = 0;
+
+    for ch in core::char::decode_utf16(src_iter) {
+        let ch = ch.map_err(|_| anyhow!("invalid utf16 encoding"))?;
+
+        // If the destination doesn't have enough space for this character
+        // then the loop is ended and this function will be called later with a
+        // larger destination buffer.
+        if dst.len() < 4 && dst.len() < ch.len_utf8() {
+            break;
+        }
+
+        // Record that characters were read and then convert the `char` to
+        // utf-8, advancing the destination buffer.
+        src_read = src_iter_read.get();
+        let len = ch.encode_utf8(dst).len();
+        dst_written += len;
+        dst = &mut dst[len..];
+    }
+
+    log::trace!("utf16-to-utf8 {src_len}/{dst_len} => {src_read}/{dst_written}");
+    Ok((src_read, dst_written))
+}
+
+/// Converts latin1 to utf8.
+///
+/// Receives the independent size of both buffers and returns the number of code
+/// units read and code units written (both bytes in this case).
+///
+/// This may perform a partial encoding if the destination is not large enough.
+unsafe fn latin1_to_utf8(
+    src: *mut u8,
+    src_len: usize,
+    dst: *mut u8,
+    dst_len: usize,
+) -> Result<(usize, usize)> {
+    let src = slice::from_raw_parts(src, src_len);
+    let dst = slice::from_raw_parts_mut(dst, dst_len);
+    assert_no_overlap(src, dst);
+    let (read, written) = encoding_rs::mem::convert_latin1_to_utf8_partial(src, dst);
+    log::trace!("latin1-to-utf8 {src_len}/{dst_len} => ({read}, {written})");
+    Ok((read, written))
+}
+
+/// Converts utf16 to "latin1+utf16", probably using a utf16 encoding.
+///
+/// The length specified is the length of both the source and destination
+/// buffers. If the source string has any characters that don't fit in the
+/// latin1 code space (0xff and below) then a utf16-tagged length will be
+/// returned. Otherwise the string is "deflated" from a utf16 string to a latin1
+/// string and the latin1 length is returned.
+unsafe fn utf16_to_compact_probably_utf16(
+    src: *mut u16,
+    len: usize,
+    dst: *mut u16,
+) -> Result<usize> {
+    let src = slice::from_raw_parts(src, len);
+    let dst = slice::from_raw_parts_mut(dst, len);
+    assert_no_overlap(src, dst);
+    let all_latin1 = run_utf16_to_utf16(src, dst)?;
+    if all_latin1 {
+        let (left, dst, right) = dst.align_to_mut::<u8>();
+        assert!(left.is_empty());
+        assert!(right.is_empty());
+        for i in 0..len {
+            dst[i] = dst[2 * i];
+        }
+        log::trace!("utf16-to-compact-probably-utf16 {len} => latin1 {len}");
+        Ok(len)
+    } else {
+        log::trace!("utf16-to-compact-probably-utf16 {len} => utf16 {len}");
+        Ok(len | UTF16_TAG)
+    }
+}
+
+/// Converts a utf8 string to latin1.
+///
+/// The length specified is the same length of both the input and the output
+/// buffers.
+///
+/// Returns the number of code units read from the source and the number of code
+/// units written to the destination.
+///
+/// Note that this may not convert the entire source into the destination if the
+/// original utf8 string has usvs not representable in latin1.
+unsafe fn utf8_to_latin1(src: *mut u8, len: usize, dst: *mut u8) -> Result<(usize, usize)> {
+    let src = slice::from_raw_parts(src, len);
+    let dst = slice::from_raw_parts_mut(dst, len);
+    assert_no_overlap(src, dst);
+    let read = encoding_rs::mem::utf8_latin1_up_to(src);
+    let written = encoding_rs::mem::convert_utf8_to_latin1_lossy(&src[..read], dst);
+    log::trace!("utf8-to-latin1 {len} => ({read}, {written})");
+    Ok((read, written))
+}
+
+/// Converts a utf16 string to latin1
+///
+/// This is the same as `utf8_to_latin1` in terms of parameters/results.
+unsafe fn utf16_to_latin1(src: *mut u16, len: usize, dst: *mut u8) -> Result<(usize, usize)> {
+    let src = slice::from_raw_parts(src, len);
+    let dst = slice::from_raw_parts_mut(dst, len);
+    assert_no_overlap(src, dst);
+
+    let mut size = 0;
+    for (src, dst) in src.iter().zip(dst) {
+        let src = u16::from_le(*src);
+        match u8::try_from(src) {
+            Ok(src) => *dst = src,
+            Err(_) => break,
+        }
+        size += 1;
+    }
+    log::trace!("utf16-to-latin1 {len} => {size}");
+    Ok((size, size))
+}
+
+/// Converts a utf8 string to a utf16 string which has been partially converted
+/// as latin1 prior.
+///
+/// The original string has already been partially transcoded with
+/// `utf8_to_latin1` and that was determined to not be able to transcode the
+/// entire string. The substring of the source that couldn't be encoded into
+/// latin1 is passed here via `src` and `src_len`.
+///
+/// The destination buffer is specified by `dst` and `dst_len`. The first
+/// `latin1_bytes_so_far` bytes (not code units) of the `dst` buffer have
+/// already been filled in with latin1 characters and need to be inflated
+/// in-place to their utf16 equivalents.
+///
+/// After the initial latin1 code units have been inflated the entirety of `src`
+/// is then transcoded into the remaining space within `dst`.
+unsafe fn utf8_to_compact_utf16(
+    src: *mut u8,
+    src_len: usize,
+    dst: *mut u16,
+    dst_len: usize,
+    latin1_bytes_so_far: usize,
+) -> Result<usize> {
+    let src = slice::from_raw_parts(src, src_len);
+    let dst = slice::from_raw_parts_mut(dst, dst_len);
+    assert_no_overlap(src, dst);
+
+    let dst = inflate_latin1_bytes(dst, latin1_bytes_so_far);
+    let result = run_utf8_to_utf16(src, dst)?;
+    log::trace!("utf8-to-compact-utf16 {src_len}/{dst_len}/{latin1_bytes_so_far} => {result}");
+    Ok(result + latin1_bytes_so_far)
+}
+
+/// Same as `utf8_to_compact_utf16` but for utf16 source strings.
+unsafe fn utf16_to_compact_utf16(
+    src: *mut u16,
+    src_len: usize,
+    dst: *mut u16,
+    dst_len: usize,
+    latin1_bytes_so_far: usize,
+) -> Result<usize> {
+    let src = slice::from_raw_parts(src, src_len);
+    let dst = slice::from_raw_parts_mut(dst, dst_len);
+    assert_no_overlap(src, dst);
+
+    let dst = inflate_latin1_bytes(dst, latin1_bytes_so_far);
+    run_utf16_to_utf16(src, dst)?;
+    let result = src.len();
+    log::trace!("utf16-to-compact-utf16 {src_len}/{dst_len}/{latin1_bytes_so_far} => {result}");
+    Ok(result + latin1_bytes_so_far)
+}
+
+/// Inflates the `latin1_bytes_so_far` number of bytes written to the beginning
+/// of `dst` into u16 codepoints.
+///
+/// Returns the remaining space in the destination that can be transcoded into,
+/// slicing off the prefix of the string that was inflated from the latin1
+/// bytes.
+fn inflate_latin1_bytes(dst: &mut [u16], latin1_bytes_so_far: usize) -> &mut [u16] {
+    // Note that `latin1_bytes_so_far` is a byte measure while `dst` is a region
+    // of u16 units. This `split_at_mut` uses the byte index as an index into
+    // the u16 unit because each of the latin1 bytes will become a whole code
+    // unit in the destination which is 2 bytes large.
+    let (to_inflate, rest) = dst.split_at_mut(latin1_bytes_so_far);
+
+    // Use a byte-oriented view to inflate the original latin1 bytes.
+    let (left, mid, right) = unsafe { to_inflate.align_to_mut::<u8>() };
+    assert!(left.is_empty());
+    assert!(right.is_empty());
+    for i in (0..latin1_bytes_so_far).rev() {
+        mid[2 * i] = mid[i];
+        mid[2 * i + 1] = 0;
+    }
+
+    return rest;
+}
+
+unsafe fn resource_new32(vmctx: *mut VMComponentContext, resource: u32, rep: u32) -> Result<u32> {
+    let resource = TypeResourceTableIndex::from_u32(resource);
+    ComponentInstance::from_vmctx(vmctx, |instance| instance.resource_new32(resource, rep))
+}
+
+unsafe fn resource_rep32(vmctx: *mut VMComponentContext, resource: u32, idx: u32) -> Result<u32> {
+    let resource = TypeResourceTableIndex::from_u32(resource);
+    ComponentInstance::from_vmctx(vmctx, |instance| instance.resource_rep32(resource, idx))
+}
+
+unsafe fn resource_drop(vmctx: *mut VMComponentContext, resource: u32, idx: u32) -> Result<u64> {
+    let resource = TypeResourceTableIndex::from_u32(resource);
+    ComponentInstance::from_vmctx(vmctx, |instance| {
+        Ok(match instance.resource_drop(resource, idx)? {
+            Some(rep) => (u64::from(rep) << 1) | 1,
+            None => 0,
+        })
+    })
+}
+
+unsafe fn resource_transfer_own(
+    vmctx: *mut VMComponentContext,
+    src_idx: u32,
+    src_table: u32,
+    dst_table: u32,
+) -> Result<u32> {
+    let src_table = TypeResourceTableIndex::from_u32(src_table);
+    let dst_table = TypeResourceTableIndex::from_u32(dst_table);
+    ComponentInstance::from_vmctx(vmctx, |instance| {
+        instance.resource_transfer_own(src_idx, src_table, dst_table)
+    })
+}
+
+unsafe fn resource_transfer_borrow(
+    vmctx: *mut VMComponentContext,
+    src_idx: u32,
+    src_table: u32,
+    dst_table: u32,
+) -> Result<u32> {
+    let src_table = TypeResourceTableIndex::from_u32(src_table);
+    let dst_table = TypeResourceTableIndex::from_u32(dst_table);
+    ComponentInstance::from_vmctx(vmctx, |instance| {
+        instance.resource_transfer_borrow(src_idx, src_table, dst_table)
+    })
+}
+
+unsafe fn resource_enter_call(vmctx: *mut VMComponentContext) -> Result<()> {
+    ComponentInstance::from_vmctx(vmctx, |instance| Ok(instance.resource_enter_call()))
+}
+
+unsafe fn resource_exit_call(vmctx: *mut VMComponentContext) -> Result<()> {
+    ComponentInstance::from_vmctx(vmctx, |instance| instance.resource_exit_call())
+}
diff --git a/crates/wasmtime/src/runtime/vm/component/resources.rs b/crates/wasmtime/src/runtime/vm/component/resources.rs
new file mode 100644
index 000000000000..8ea8b7f15f87
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/component/resources.rs
@@ -0,0 +1,351 @@
+//! Implementation of the canonical-ABI related intrinsics for resources in the
+//! component model.
+//!
+//! This module contains all the relevant gory details of the
+//! component model related to lifting and lowering resources. For example
+//! intrinsics like `resource.new` will bottom out in calling this file, and
+//! this is where resource tables are actually defined and modified.
+//!
+//! The main types in this file are:
+//!
+//! * `ResourceTables` - the "here's everything" context which is required to
+//!   perform canonical ABI operations.
+//!
+//! * `ResourceTable` - an individual instance of a table of resources,
+//!   basically "just a slab" though.
+//!
+//! * `CallContexts` - store-local information about active calls and borrows
+//!   and runtime state tracking that to ensure that everything is handled
+//!   correctly.
+//!
+//! Individual operations are exposed through methods on `ResourceTables` for
+//! lifting/lowering/etc. This does mean though that some other fiddly bits
+//! about ABI details can be found in lifting/lowering throughout Wasmtime,
+//! namely in the `Resource<T>` and `ResourceAny` types.
+
+use crate::prelude::*;
+use core::mem;
+use wasmtime_environ::component::TypeResourceTableIndex;
+use wasmtime_environ::PrimaryMap;
+
+/// The maximum handle value is specified in
+/// <https://github.com/WebAssembly/component-model/blob/main/design/mvp/CanonicalABI.md>
+/// currently and keeps the upper bit free for use in the component.
+const MAX_RESOURCE_HANDLE: u32 = 1 << 30;
+
+/// Contextual state necessary to perform resource-related operations.
+///
+/// This state a bit odd since it has a few optional bits, but the idea is that
+/// whenever this is constructed the bits required to perform operations are
+/// always `Some`. For example:
+///
+/// * During lifting and lowering both `tables` and `host_table` are `Some`.
+/// * During wasm's own intrinsics only `tables` is `Some`.
+/// * During embedder-invoked resource destruction calls only `host_table` is
+///   `Some`.
+///
+/// This is all packaged up into one state though to make it easier to operate
+/// on and to centralize handling of the state related to resources due to how
+/// critical it is for correctness.
+pub struct ResourceTables<'a> {
+    /// Runtime state for all resources defined in a component.
+    ///
+    /// This is required whenever a `TypeResourceTableIndex` is provided as it's
+    /// the lookup where that happens. Not present during embedder-originating
+    /// operations though such as `ResourceAny::resource_drop` which won't
+    /// consult this table as it's only operating over the host table.
+    pub tables: Option<&'a mut PrimaryMap<TypeResourceTableIndex, ResourceTable>>,
+
+    /// Runtime state for resources currently owned by the host.
+    ///
+    /// This is the single table used by the host stored within `Store<T>`. Host
+    /// resources will point into this and effectively have the same semantics
+    /// as-if they're in-component resources. The major distinction though is
+    /// that this is a heterogeneous table instead of only containing a single
+    /// type.
+    pub host_table: Option<&'a mut ResourceTable>,
+
+    /// Scope information about calls actively in use to track information such
+    /// as borrow counts.
+    pub calls: &'a mut CallContexts,
+}
+
+/// An individual slab of resources used for a single table within a component.
+/// Not much fancier than a general slab data structure.
+#[derive(Default)]
+pub struct ResourceTable {
+    /// Next slot to allocate, or `self.slots.len()` if they're all full.
+    next: u32,
+    /// Runtime state of all slots.
+    slots: Vec<Slot>,
+}
+
+enum Slot {
+    /// This slot is free and points to the next free slot, forming a linked
+    /// list of free slots.
+    Free { next: u32 },
+
+    /// This slot contains an owned resource with the listed representation.
+    ///
+    /// The `lend_count` tracks how many times this has been lent out as a
+    /// `borrow` and if nonzero this can't be removed.
+    Own { rep: u32, lend_count: u32 },
+
+    /// This slot contains a `borrow` resource that's connected to the `scope`
+    /// provided. The `rep` is listed and dropping this borrow will decrement
+    /// the borrow count of the `scope`.
+    Borrow { rep: u32, scope: usize },
+}
+
+/// State related to borrows and calls within a component.
+///
+/// This is created once per `Store` and updated and modified throughout the
+/// lifetime of the store. This primarily tracks borrow counts and what slots
+/// should be updated when calls go out of scope.
+#[derive(Default)]
+pub struct CallContexts {
+    scopes: Vec<CallContext>,
+}
+
+#[derive(Default)]
+struct CallContext {
+    lenders: Vec<Lender>,
+    borrow_count: u32,
+}
+
+#[derive(Copy, Clone)]
+struct Lender {
+    ty: Option<TypeResourceTableIndex>,
+    idx: u32,
+}
+
+impl ResourceTables<'_> {
+    fn table(&mut self, ty: Option<TypeResourceTableIndex>) -> &mut ResourceTable {
+        match ty {
+            None => self.host_table.as_mut().unwrap(),
+            Some(idx) => &mut self.tables.as_mut().unwrap()[idx],
+        }
+    }
+
+    /// Implementation of the `resource.new` canonical intrinsic.
+    ///
+    /// Note that this is the same as `resource_lower_own`.
+    pub fn resource_new(&mut self, ty: Option<TypeResourceTableIndex>, rep: u32) -> Result<u32> {
+        self.table(ty).insert(Slot::Own { rep, lend_count: 0 })
+    }
+
+    /// Implementation of the `resource.rep` canonical intrinsic.
+    ///
+    /// This one's one of the simpler ones: "just get the rep please"
+    pub fn resource_rep(&mut self, ty: Option<TypeResourceTableIndex>, idx: u32) -> Result<u32> {
+        self.table(ty).rep(idx)
+    }
+
+    /// Implementation of the `resource.drop` canonical intrinsic minus the
+    /// actual invocation of the destructor.
+    ///
+    /// This will drop the handle at the `idx` specified, removing it from the
+    /// specified table. This operation can fail if:
+    ///
+    /// * The index is invalid.
+    /// * The index points to an `own` resource which has active borrows.
+    ///
+    /// Otherwise this will return `Some(rep)` if the destructor for `rep` needs
+    /// to run. If `None` is returned then that means a `borrow` handle was
+    /// removed and no destructor is necessary.
+    pub fn resource_drop(
+        &mut self,
+        ty: Option<TypeResourceTableIndex>,
+        idx: u32,
+    ) -> Result<Option<u32>> {
+        match self.table(ty).remove(idx)? {
+            Slot::Own { rep, lend_count: 0 } => Ok(Some(rep)),
+            Slot::Own { .. } => bail!("cannot remove owned resource while borrowed"),
+            Slot::Borrow { scope, .. } => {
+                self.calls.scopes[scope].borrow_count -= 1;
+                Ok(None)
+            }
+            Slot::Free { .. } => unreachable!(),
+        }
+    }
+
+    /// Inserts a new "own" handle into the specified table.
+    ///
+    /// This will insert the specified representation into the specified type
+    /// table.
+    ///
+    /// Note that this operation is infallible, and additionally that this is
+    /// the same as `resource_new` implementation-wise.
+    ///
+    /// This is an implementation of the canonical ABI `lower_own` function.
+    pub fn resource_lower_own(
+        &mut self,
+        ty: Option<TypeResourceTableIndex>,
+        rep: u32,
+    ) -> Result<u32> {
+        self.table(ty).insert(Slot::Own { rep, lend_count: 0 })
+    }
+
+    /// Attempts to remove an "own" handle from the specified table and its
+    /// index.
+    ///
+    /// This operation will fail if `idx` is invalid, if it's a `borrow` handle,
+    /// or if the own handle has currently been "lent" as a borrow.
+    ///
+    /// This is an implementation of the canonical ABI `lift_own` function.
+    pub fn resource_lift_own(
+        &mut self,
+        ty: Option<TypeResourceTableIndex>,
+        idx: u32,
+    ) -> Result<u32> {
+        match self.table(ty).remove(idx)? {
+            Slot::Own { rep, lend_count: 0 } => Ok(rep),
+            Slot::Own { .. } => bail!("cannot remove owned resource while borrowed"),
+            Slot::Borrow { .. } => bail!("cannot lift own resource from a borrow"),
+            Slot::Free { .. } => unreachable!(),
+        }
+    }
+
+    /// Extracts the underlying resource representation by lifting a "borrow"
+    /// from the tables.
+    ///
+    /// This primarily employs dynamic tracking when a borrow is created from an
+    /// "own" handle to ensure that the "own" handle isn't dropped while the
+    /// borrow is active and additionally that when the current call scope
+    /// returns the lend operation is undone.
+    ///
+    /// This is an implementation of the canonical ABI `lift_borrow` function.
+    pub fn resource_lift_borrow(
+        &mut self,
+        ty: Option<TypeResourceTableIndex>,
+        idx: u32,
+    ) -> Result<u32> {
+        match self.table(ty).get_mut(idx)? {
+            Slot::Own { rep, lend_count } => {
+                // The decrement to this count happens in `exit_call`.
+                *lend_count = lend_count.checked_add(1).unwrap();
+                let rep = *rep;
+                let scope = self.calls.scopes.last_mut().unwrap();
+                scope.lenders.push(Lender { ty, idx });
+                Ok(rep)
+            }
+            Slot::Borrow { rep, .. } => Ok(*rep),
+            Slot::Free { .. } => unreachable!(),
+        }
+    }
+
+    /// Records a new `borrow` resource with the given representation within the
+    /// current call scope.
+    ///
+    /// This requires that a call scope is active. Additionally the number of
+    /// active borrows in the latest scope will be increased and must be
+    /// decreased through a future use of `resource_drop` before the current
+    /// call scope exits.
+    ///
+    /// This some of the implementation of the canonical ABI `lower_borrow`
+    /// function. The other half of this implementation is located on
+    /// `VMComponentContext` which handles the special case of avoiding borrow
+    /// tracking entirely.
+    pub fn resource_lower_borrow(
+        &mut self,
+        ty: Option<TypeResourceTableIndex>,
+        rep: u32,
+    ) -> Result<u32> {
+        let scope = self.calls.scopes.len() - 1;
+        let borrow_count = &mut self.calls.scopes.last_mut().unwrap().borrow_count;
+        *borrow_count = borrow_count.checked_add(1).unwrap();
+        self.table(ty).insert(Slot::Borrow { rep, scope })
+    }
+
+    /// Enters a new calling context, starting a fresh count of borrows and
+    /// such.
+    #[inline]
+    pub fn enter_call(&mut self) {
+        self.calls.scopes.push(CallContext::default());
+    }
+
+    /// Exits the previously pushed calling context.
+    ///
+    /// This requires all information to be available within this
+    /// `ResourceTables` and is only called during lowering/lifting operations
+    /// at this time.
+    #[inline]
+    pub fn exit_call(&mut self) -> Result<()> {
+        let cx = self.calls.scopes.pop().unwrap();
+        if cx.borrow_count > 0 {
+            bail!("borrow handles still remain at the end of the call")
+        }
+        for lender in cx.lenders.iter() {
+            // Note the panics here which should never get triggered in theory
+            // due to the dynamic tracking of borrows and such employed for
+            // resources.
+            match self.table(lender.ty).get_mut(lender.idx).unwrap() {
+                Slot::Own { lend_count, .. } => {
+                    *lend_count -= 1;
+                }
+                _ => unreachable!(),
+            }
+        }
+        Ok(())
+    }
+}
+
+impl ResourceTable {
+    fn insert(&mut self, new: Slot) -> Result<u32> {
+        let next = self.next as usize;
+        if next == self.slots.len() {
+            self.slots.push(Slot::Free {
+                next: self.next.checked_add(1).unwrap(),
+            });
+        }
+        let ret = self.next;
+        self.next = match mem::replace(&mut self.slots[next], new) {
+            Slot::Free { next } => next,
+            _ => unreachable!(),
+        };
+
+        // The component model reserves index 0 as never allocatable so add one
+        // to the table index to start the numbering at 1 instead. Also note
+        // that the component model places an upper-limit per-table on the
+        // maximum allowed index.
+        let ret = ret + 1;
+        if ret >= MAX_RESOURCE_HANDLE {
+            bail!("cannot allocate another handle: index overflow");
+        }
+        Ok(ret)
+    }
+
+    fn handle_index_to_table_index(&self, idx: u32) -> Option<usize> {
+        // NB: `idx` is decremented by one to account for the `+1` above during
+        // allocation.
+        let idx = idx.checked_sub(1)?;
+        usize::try_from(idx).ok()
+    }
+
+    fn rep(&self, idx: u32) -> Result<u32> {
+        let slot = self
+            .handle_index_to_table_index(idx)
+            .and_then(|i| self.slots.get(i));
+        match slot {
+            None | Some(Slot::Free { .. }) => bail!("unknown handle index {idx}"),
+            Some(Slot::Own { rep, .. } | Slot::Borrow { rep, .. }) => Ok(*rep),
+        }
+    }
+
+    fn get_mut(&mut self, idx: u32) -> Result<&mut Slot> {
+        let slot = self
+            .handle_index_to_table_index(idx)
+            .and_then(|i| self.slots.get_mut(i));
+        match slot {
+            None | Some(Slot::Free { .. }) => bail!("unknown handle index {idx}"),
+            Some(other) => Ok(other),
+        }
+    }
+
+    fn remove(&mut self, idx: u32) -> Result<Slot> {
+        let to_fill = Slot::Free { next: self.next };
+        let ret = mem::replace(self.get_mut(idx)?, to_fill);
+        self.next = idx - 1;
+        Ok(ret)
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/const_expr.rs b/crates/wasmtime/src/runtime/vm/const_expr.rs
new file mode 100644
index 000000000000..198673b93051
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/const_expr.rs
@@ -0,0 +1,132 @@
+//! Evaluating const expressions.
+
+use crate::prelude::*;
+use crate::runtime::vm::{Instance, VMGcRef, ValRaw, I31};
+use smallvec::SmallVec;
+use wasmtime_environ::{ConstExpr, FuncIndex, GlobalIndex, Module};
+
+/// An interpreter for const expressions.
+///
+/// This can be reused across many const expression evaluations to reuse
+/// allocated resources, if any.
+#[derive(Default)]
+pub struct ConstExprEvaluator {
+    stack: SmallVec<[ValRaw; 2]>,
+}
+
+/// The context within which a particular const expression is evaluated.
+pub struct ConstEvalContext<'a, 'b> {
+    instance: &'a mut Instance,
+    module: &'b Module,
+}
+
+impl<'a, 'b> ConstEvalContext<'a, 'b> {
+    /// Create a new context.
+    pub fn new(instance: &'a mut Instance, module: &'b Module) -> Self {
+        Self { instance, module }
+    }
+
+    fn global_get(&mut self, index: GlobalIndex) -> Result<ValRaw> {
+        unsafe {
+            let gc_store = (*self.instance.store()).gc_store();
+            let global = self
+                .instance
+                .defined_or_imported_global_ptr(index)
+                .as_ref()
+                .unwrap();
+            Ok(global.to_val_raw(gc_store, self.module.globals[index].wasm_ty))
+        }
+    }
+
+    fn ref_func(&mut self, index: FuncIndex) -> Result<ValRaw> {
+        Ok(ValRaw::funcref(
+            self.instance.get_func_ref(index).unwrap().cast(),
+        ))
+    }
+}
+
+impl ConstExprEvaluator {
+    /// Evaluate the given const expression in the given context.
+    ///
+    /// # Unsafety
+    ///
+    /// The given const expression must be valid within the given context,
+    /// e.g. the const expression must be well-typed and the context must return
+    /// global values of the expected types. This evaluator operates directly on
+    /// untyped `ValRaw`s and does not and cannot check that its operands are of
+    /// the correct type.
+    pub unsafe fn eval(
+        &mut self,
+        context: &mut ConstEvalContext<'_, '_>,
+        expr: &ConstExpr,
+    ) -> Result<ValRaw> {
+        self.stack.clear();
+
+        for op in expr.ops() {
+            match op {
+                wasmtime_environ::ConstOp::I32Const(i) => self.stack.push(ValRaw::i32(*i)),
+                wasmtime_environ::ConstOp::I64Const(i) => self.stack.push(ValRaw::i64(*i)),
+                wasmtime_environ::ConstOp::F32Const(f) => self.stack.push(ValRaw::f32(*f)),
+                wasmtime_environ::ConstOp::F64Const(f) => self.stack.push(ValRaw::f64(*f)),
+                wasmtime_environ::ConstOp::V128Const(v) => self.stack.push(ValRaw::v128(*v)),
+                wasmtime_environ::ConstOp::GlobalGet(g) => self.stack.push(context.global_get(*g)?),
+                wasmtime_environ::ConstOp::RefNull => self.stack.push(ValRaw::null()),
+                wasmtime_environ::ConstOp::RefFunc(f) => self.stack.push(context.ref_func(*f)?),
+                wasmtime_environ::ConstOp::RefI31 => {
+                    let i = self.pop()?.get_i32();
+                    let i31 = I31::wrapping_i32(i);
+                    let raw = VMGcRef::from_i31(i31).as_raw_u32();
+                    self.stack.push(ValRaw::anyref(raw));
+                }
+                wasmtime_environ::ConstOp::I32Add => {
+                    let b = self.pop()?.get_i32();
+                    let a = self.pop()?.get_i32();
+                    self.stack.push(ValRaw::i32(a.wrapping_add(b)));
+                }
+                wasmtime_environ::ConstOp::I32Sub => {
+                    let b = self.pop()?.get_i32();
+                    let a = self.pop()?.get_i32();
+                    self.stack.push(ValRaw::i32(a.wrapping_sub(b)));
+                }
+                wasmtime_environ::ConstOp::I32Mul => {
+                    let b = self.pop()?.get_i32();
+                    let a = self.pop()?.get_i32();
+                    self.stack.push(ValRaw::i32(a.wrapping_mul(b)));
+                }
+                wasmtime_environ::ConstOp::I64Add => {
+                    let b = self.pop()?.get_i64();
+                    let a = self.pop()?.get_i64();
+                    self.stack.push(ValRaw::i64(a.wrapping_add(b)));
+                }
+                wasmtime_environ::ConstOp::I64Sub => {
+                    let b = self.pop()?.get_i64();
+                    let a = self.pop()?.get_i64();
+                    self.stack.push(ValRaw::i64(a.wrapping_sub(b)));
+                }
+                wasmtime_environ::ConstOp::I64Mul => {
+                    let b = self.pop()?.get_i64();
+                    let a = self.pop()?.get_i64();
+                    self.stack.push(ValRaw::i64(a.wrapping_mul(b)));
+                }
+            }
+        }
+
+        if self.stack.len() == 1 {
+            Ok(self.stack[0])
+        } else {
+            bail!(
+                "const expr evaluation error: expected 1 resulting value, found {}",
+                self.stack.len()
+            )
+        }
+    }
+
+    fn pop(&mut self) -> Result<ValRaw> {
+        self.stack.pop().ok_or_else(|| {
+            anyhow!(
+                "const expr evaluation error: attempted to pop from an empty \
+                 evaluation stack"
+            )
+        })
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/cow.rs b/crates/wasmtime/src/runtime/vm/cow.rs
new file mode 100644
index 000000000000..ded449f8e340
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/cow.rs
@@ -0,0 +1,992 @@
+//! Copy-on-write initialization support: creation of backing images for
+//! modules, and logic to support mapping these backing images into memory.
+
+// `MemoryImageSource` is an empty enum on some platforms which triggers some
+// warnings
+#![cfg_attr(any(not(unix), miri), allow(unreachable_patterns))]
+
+use crate::prelude::*;
+use crate::runtime::vm::sys::vm::{self, MemoryImageSource};
+use crate::runtime::vm::{MmapVec, SendSyncPtr};
+use alloc::sync::Arc;
+use core::ffi::c_void;
+use core::ops::Range;
+use core::ptr::{self, NonNull};
+use wasmtime_environ::{
+    DefinedMemoryIndex, MemoryInitialization, MemoryPlan, MemoryStyle, Module, PrimaryMap,
+};
+
+use super::sys::DecommitBehavior;
+
+/// Backing images for memories in a module.
+///
+/// This is meant to be built once, when a module is first loaded/constructed,
+/// and then used many times for instantiation.
+pub struct ModuleMemoryImages {
+    memories: PrimaryMap<DefinedMemoryIndex, Option<Arc<MemoryImage>>>,
+}
+
+impl ModuleMemoryImages {
+    /// Get the MemoryImage for a given memory.
+    pub fn get_memory_image(&self, defined_index: DefinedMemoryIndex) -> Option<&Arc<MemoryImage>> {
+        self.memories[defined_index].as_ref()
+    }
+}
+
+/// One backing image for one memory.
+#[derive(Debug, PartialEq)]
+pub struct MemoryImage {
+    /// The platform-specific source of this image.
+    ///
+    /// This might be a mapped `*.cwasm` file or on Unix it could also be a
+    /// `Memfd` as an anonymous file in memory on Linux. In either case this is
+    /// used as the backing-source for the CoW image.
+    source: MemoryImageSource,
+
+    /// Length of image, in bytes.
+    ///
+    /// Note that initial memory size may be larger; leading and trailing zeroes
+    /// are truncated (handled by backing fd).
+    ///
+    /// Must be a multiple of the system page size.
+    len: usize,
+
+    /// Image starts this many bytes into `source`.
+    ///
+    /// This is 0 for anonymous-backed memfd files and is the offset of the
+    /// data section in a `*.cwasm` file for `*.cwasm`-backed images.
+    ///
+    /// Must be a multiple of the system page size.
+    source_offset: u64,
+
+    /// Image starts this many bytes into heap space.
+    ///
+    /// Must be a multiple of the system page size.
+    linear_memory_offset: usize,
+}
+
+impl MemoryImage {
+    fn new(
+        page_size: u32,
+        offset: u64,
+        data: &[u8],
+        mmap: Option<&MmapVec>,
+    ) -> Result<Option<MemoryImage>> {
+        // Sanity-check that various parameters are page-aligned.
+        let len = data.len();
+        assert_eq!(offset % u64::from(page_size), 0);
+        assert_eq!((len as u32) % page_size, 0);
+        let linear_memory_offset = match usize::try_from(offset) {
+            Ok(offset) => offset,
+            Err(_) => return Ok(None),
+        };
+
+        // If a backing `mmap` is present then `data` should be a sub-slice of
+        // the `mmap`. The sanity-checks here double-check that. Additionally
+        // compilation should have ensured that the `data` section is
+        // page-aligned within `mmap`, so that's also all double-checked here.
+        //
+        // Finally if the `mmap` itself comes from a backing file on disk, such
+        // as a `*.cwasm` file, then that's a valid source of data for the
+        // memory image so we simply return referencing that.
+        //
+        // Note that this path is platform-agnostic in the sense of all
+        // platforms we support support memory mapping copy-on-write data from
+        // files, but for now this is still a Linux-specific region of Wasmtime.
+        // Some work will be needed to get this file compiling for macOS and
+        // Windows.
+        if let Some(mmap) = mmap {
+            let start = mmap.as_ptr() as usize;
+            let end = start + mmap.len();
+            let data_start = data.as_ptr() as usize;
+            let data_end = data_start + data.len();
+            assert!(start <= data_start && data_end <= end);
+            assert_eq!((start as u32) % page_size, 0);
+            assert_eq!((data_start as u32) % page_size, 0);
+            assert_eq!((data_end as u32) % page_size, 0);
+            assert_eq!((mmap.original_offset() as u32) % page_size, 0);
+
+            #[cfg(feature = "std")]
+            if let Some(file) = mmap.original_file() {
+                if let Some(source) = MemoryImageSource::from_file(file) {
+                    return Ok(Some(MemoryImage {
+                        source,
+                        source_offset: u64::try_from(mmap.original_offset() + (data_start - start))
+                            .unwrap(),
+                        linear_memory_offset,
+                        len,
+                    }));
+                }
+            }
+        }
+
+        // If `mmap` doesn't come from a file then platform-specific mechanisms
+        // may be used to place the data in a form that's amenable to an mmap.
+        if let Some(source) = MemoryImageSource::from_data(data).err2anyhow()? {
+            return Ok(Some(MemoryImage {
+                source,
+                source_offset: 0,
+                linear_memory_offset,
+                len,
+            }));
+        }
+
+        Ok(None)
+    }
+
+    unsafe fn map_at(&self, base: *mut u8) -> Result<()> {
+        self.source
+            .map_at(
+                base.add(self.linear_memory_offset),
+                self.len,
+                self.source_offset,
+            )
+            .err2anyhow()?;
+        Ok(())
+    }
+
+    unsafe fn remap_as_zeros_at(&self, base: *mut u8) -> Result<()> {
+        self.source
+            .remap_as_zeros_at(base.add(self.linear_memory_offset), self.len)
+            .err2anyhow()?;
+        Ok(())
+    }
+}
+
+impl ModuleMemoryImages {
+    /// Create a new `ModuleMemoryImages` for the given module. This can be
+    /// passed in as part of a `InstanceAllocationRequest` to speed up
+    /// instantiation and execution by using copy-on-write-backed memories.
+    pub fn new(
+        module: &Module,
+        wasm_data: &[u8],
+        mmap: Option<&MmapVec>,
+    ) -> Result<Option<ModuleMemoryImages>> {
+        let map = match &module.memory_initialization {
+            MemoryInitialization::Static { map } => map,
+            _ => return Ok(None),
+        };
+        let mut memories = PrimaryMap::with_capacity(map.len());
+        let page_size = crate::runtime::vm::host_page_size() as u32;
+        for (memory_index, init) in map {
+            // mmap-based-initialization only works for defined memories with a
+            // known starting point of all zeros, so bail out if the mmeory is
+            // imported.
+            let defined_memory = match module.defined_memory_index(memory_index) {
+                Some(idx) => idx,
+                None => return Ok(None),
+            };
+
+            // If there's no initialization for this memory known then we don't
+            // need an image for the memory so push `None` and move on.
+            let init = match init {
+                Some(init) => init,
+                None => {
+                    memories.push(None);
+                    continue;
+                }
+            };
+
+            // Get the image for this wasm module  as a subslice of `wasm_data`,
+            // and then use that to try to create the `MemoryImage`. If this
+            // creation files then we fail creating `ModuleMemoryImages` since this
+            // memory couldn't be represented.
+            let data = &wasm_data[init.data.start as usize..init.data.end as usize];
+            if module.memory_plans[memory_index]
+                .memory
+                .minimum_byte_size()
+                .map_or(false, |mem_initial_len| {
+                    init.offset + u64::try_from(data.len()).unwrap() > mem_initial_len
+                })
+            {
+                // The image is rounded up to multiples of the host OS page
+                // size. But if Wasm is using a custom page size, the Wasm page
+                // size might be smaller than the host OS page size, and that
+                // rounding might have made the image larger than the Wasm
+                // memory's initial length. This is *probably* okay, since the
+                // rounding would have just introduced new runs of zeroes in the
+                // image, but out of an abundance of caution we don't generate
+                // CoW images in this scenario.
+                return Ok(None);
+            }
+            let image = match MemoryImage::new(page_size, init.offset, data, mmap)? {
+                Some(image) => image,
+                None => return Ok(None),
+            };
+
+            let idx = memories.push(Some(Arc::new(image)));
+            assert_eq!(idx, defined_memory);
+        }
+
+        Ok(Some(ModuleMemoryImages { memories }))
+    }
+}
+
+/// Slot management of a copy-on-write image which can be reused for the pooling
+/// allocator.
+///
+/// This data structure manages a slot of linear memory, primarily in the
+/// pooling allocator, which optionally has a contiguous memory image in the
+/// middle of it. Pictorially this data structure manages a virtual memory
+/// region that looks like:
+///
+/// ```text
+///   +--------------------+-------------------+--------------+--------------+
+///   |   anonymous        |      optional     |   anonymous  |    PROT_NONE |
+///   |     zero           |       memory      |     zero     |     memory   |
+///   |    memory          |       image       |    memory    |              |
+///   +--------------------+-------------------+--------------+--------------+
+///   |                     <------+---------->
+///   |<-----+------------>         \
+///   |      \                   image.len
+///   |       \
+///   |  image.linear_memory_offset
+///   |
+///   \
+///  self.base is this virtual address
+///
+///    <------------------+------------------------------------------------>
+///                        \
+///                      static_size
+///
+///    <------------------+---------------------------------->
+///                        \
+///                      accessible
+/// ```
+///
+/// When a `MemoryImageSlot` is created it's told what the `static_size` and
+/// `accessible` limits are. Initially there is assumed to be no image in linear
+/// memory.
+///
+/// When `MemoryImageSlot::instantiate` is called then the method will perform
+/// a "synchronization" to take the image from its prior state to the new state
+/// for the image specified. The first instantiation for example will mmap the
+/// heap image into place. Upon reuse of a slot nothing happens except possibly
+/// shrinking `self.accessible`. When a new image is used then the old image is
+/// mapped to anonymous zero memory and then the new image is mapped in place.
+///
+/// A `MemoryImageSlot` is either `dirty` or it isn't. When a `MemoryImageSlot`
+/// is dirty then it is assumed that any memory beneath `self.accessible` could
+/// have any value. Instantiation cannot happen into a `dirty` slot, however, so
+/// the `MemoryImageSlot::clear_and_remain_ready` returns this memory back to
+/// its original state to mark `dirty = false`. This is done by resetting all
+/// anonymous memory back to zero and the image itself back to its initial
+/// contents.
+///
+/// On Linux this is achieved with the `madvise(MADV_DONTNEED)` syscall. This
+/// syscall will release the physical pages back to the OS but retain the
+/// original mappings, effectively resetting everything back to its initial
+/// state. Non-linux platforms will replace all memory below `self.accessible`
+/// with a fresh zero'd mmap, meaning that reuse is effectively not supported.
+#[derive(Debug)]
+pub struct MemoryImageSlot {
+    /// The base address in virtual memory of the actual heap memory.
+    ///
+    /// Bytes at this address are what is seen by the Wasm guest code.
+    base: SendSyncPtr<u8>,
+
+    /// The maximum static memory size which `self.accessible` can grow to.
+    static_size: usize,
+
+    /// An optional image that is currently being used in this linear memory.
+    ///
+    /// This can be `None` in which case memory is originally all zeros. When
+    /// `Some` the image describes where it's located within the image.
+    image: Option<Arc<MemoryImage>>,
+
+    /// The size of the heap that is readable and writable.
+    ///
+    /// Note that this may extend beyond the actual linear memory heap size in
+    /// the case of dynamic memories in use. Memory accesses to memory below
+    /// `self.accessible` may still page fault as pages are lazily brought in
+    /// but the faults will always be resolved by the kernel.
+    accessible: usize,
+
+    /// Whether this slot may have "dirty" pages (pages written by an
+    /// instantiation). Set by `instantiate()` and cleared by
+    /// `clear_and_remain_ready()`, and used in assertions to ensure
+    /// those methods are called properly.
+    ///
+    /// Invariant: if !dirty, then this memory slot contains a clean
+    /// CoW mapping of `image`, if `Some(..)`, and anonymous-zero
+    /// memory beyond the image up to `static_size`. The addresses
+    /// from offset 0 to `self.accessible` are R+W and set to zero or the
+    /// initial image content, as appropriate. Everything between
+    /// `self.accessible` and `self.static_size` is inaccessible.
+    dirty: bool,
+
+    /// Whether this MemoryImageSlot is responsible for mapping anonymous
+    /// memory (to hold the reservation while overwriting mappings
+    /// specific to this slot) in place when it is dropped. Default
+    /// on, unless the caller knows what they are doing.
+    clear_on_drop: bool,
+}
+
+impl MemoryImageSlot {
+    /// Create a new MemoryImageSlot. Assumes that there is an anonymous
+    /// mmap backing in the given range to start.
+    ///
+    /// The `accessible` parameter describes how much of linear memory is
+    /// already mapped as R/W with all zero-bytes. The `static_size` value is
+    /// the maximum size of this image which `accessible` cannot grow beyond,
+    /// and all memory from `accessible` from `static_size` should be mapped as
+    /// `PROT_NONE` backed by zero-bytes.
+    pub(crate) fn create(base_addr: *mut c_void, accessible: usize, static_size: usize) -> Self {
+        MemoryImageSlot {
+            base: NonNull::new(base_addr.cast()).unwrap().into(),
+            static_size,
+            accessible,
+            image: None,
+            dirty: false,
+            clear_on_drop: true,
+        }
+    }
+
+    #[cfg(feature = "pooling-allocator")]
+    pub(crate) fn dummy() -> MemoryImageSlot {
+        MemoryImageSlot {
+            // This pointer isn't ever actually used so its value doesn't
+            // matter but we need to satisfy `NonNull` requirement so create a
+            // `dangling` pointer as a sentinel that should cause problems if
+            // it's actually used.
+            base: NonNull::dangling().into(),
+            static_size: 0,
+            image: None,
+            accessible: 0,
+            dirty: false,
+            clear_on_drop: false,
+        }
+    }
+
+    /// Inform the MemoryImageSlot that it should *not* clear the underlying
+    /// address space when dropped. This should be used only when the
+    /// caller will clear or reuse the address space in some other
+    /// way.
+    pub(crate) fn no_clear_on_drop(&mut self) {
+        self.clear_on_drop = false;
+    }
+
+    pub(crate) fn set_heap_limit(&mut self, size_bytes: usize) -> Result<()> {
+        assert!(size_bytes <= self.static_size);
+
+        // If the heap limit already addresses accessible bytes then no syscalls
+        // are necessary since the data is already mapped into the process and
+        // waiting to go.
+        //
+        // This is used for "dynamic" memories where memory is not always
+        // decommitted during recycling (but it's still always reset).
+        if size_bytes <= self.accessible {
+            return Ok(());
+        }
+
+        // Otherwise use `mprotect` to make the new pages read/write.
+        self.set_protection(self.accessible..size_bytes, true)?;
+        self.accessible = size_bytes;
+
+        Ok(())
+    }
+
+    /// Prepares this slot for the instantiation of a new instance with the
+    /// provided linear memory image.
+    ///
+    /// The `initial_size_bytes` parameter indicates the required initial size
+    /// of the heap for the instance. The `maybe_image` is an optional initial
+    /// image for linear memory to contains. The `style` is the way compiled
+    /// code will be accessing this memory.
+    ///
+    /// The purpose of this method is to take a previously pristine slot
+    /// (`!self.dirty`) and transform its prior state into state necessary for
+    /// the given parameters. This could include, for example:
+    ///
+    /// * More memory may be made read/write if `initial_size_bytes` is larger
+    ///   than `self.accessible`.
+    /// * For `MemoryStyle::Static` linear memory may be made `PROT_NONE` if
+    ///   `self.accessible` is larger than `initial_size_bytes`.
+    /// * If no image was previously in place or if the wrong image was
+    ///   previously in place then `mmap` may be used to setup the initial
+    ///   image.
+    pub(crate) fn instantiate(
+        &mut self,
+        initial_size_bytes: usize,
+        maybe_image: Option<&Arc<MemoryImage>>,
+        plan: &MemoryPlan,
+    ) -> Result<()> {
+        assert!(!self.dirty);
+        assert!(initial_size_bytes <= self.static_size);
+
+        // First order of business is to blow away the previous linear memory
+        // image if it doesn't match the image specified here. If one is
+        // detected then it's reset with anonymous memory which means that all
+        // of memory up to `self.accessible` will now be read/write and zero.
+        //
+        // Note that this intentionally a "small mmap" which only covers the
+        // extent of the prior initialization image in order to preserve
+        // resident memory that might come before or after the image.
+        if self.image.as_ref() != maybe_image {
+            self.remove_image()?;
+        }
+
+        // The next order of business is to ensure that `self.accessible` is
+        // appropriate. First up is to grow the read/write portion of memory if
+        // it's not large enough to accommodate `initial_size_bytes`.
+        if self.accessible < initial_size_bytes {
+            self.set_protection(self.accessible..initial_size_bytes, true)?;
+            self.accessible = initial_size_bytes;
+        }
+
+        // If (1) the accessible region is not in its initial state, and (2) the
+        // memory relies on virtual memory at all (i.e. has offset guard pages
+        // and/or is static), then we need to reset memory protections. Put
+        // another way, the only time it is safe to not reset protections is
+        // when we are using dynamic memory without any guard pages.
+        if initial_size_bytes < self.accessible
+            && (plan.offset_guard_size > 0 || matches!(plan.style, MemoryStyle::Static { .. }))
+        {
+            self.set_protection(initial_size_bytes..self.accessible, false)?;
+            self.accessible = initial_size_bytes;
+        }
+
+        // Now that memory is sized appropriately the final operation is to
+        // place the new image into linear memory. Note that this operation is
+        // skipped if `self.image` matches `maybe_image`.
+        assert!(initial_size_bytes <= self.accessible);
+        if self.image.as_ref() != maybe_image {
+            if let Some(image) = maybe_image.as_ref() {
+                assert!(
+                    image.linear_memory_offset.checked_add(image.len).unwrap()
+                        <= initial_size_bytes
+                );
+                if image.len > 0 {
+                    unsafe {
+                        image.map_at(self.base.as_ptr())?;
+                    }
+                }
+            }
+            self.image = maybe_image.cloned();
+        }
+
+        // Flag ourselves as `dirty` which means that the next operation on this
+        // slot is required to be `clear_and_remain_ready`.
+        self.dirty = true;
+
+        Ok(())
+    }
+
+    pub(crate) fn remove_image(&mut self) -> Result<()> {
+        if let Some(image) = &self.image {
+            unsafe {
+                image.remap_as_zeros_at(self.base.as_ptr())?;
+            }
+            self.image = None;
+        }
+        Ok(())
+    }
+
+    /// Resets this linear memory slot back to a "pristine state".
+    ///
+    /// This will reset the memory back to its original contents on Linux or
+    /// reset the contents back to zero on other platforms. The `keep_resident`
+    /// argument is the maximum amount of memory to keep resident in this
+    /// process's memory on Linux. Up to that much memory will be `memset` to
+    /// zero where the rest of it will be reset or released with `madvise`.
+    #[allow(dead_code)] // ignore warnings as this is only used in some cfgs
+    pub(crate) fn clear_and_remain_ready(
+        &mut self,
+        keep_resident: usize,
+        decommit: impl FnMut(*mut u8, usize),
+    ) -> Result<()> {
+        assert!(self.dirty);
+
+        unsafe {
+            self.reset_all_memory_contents(keep_resident, decommit)?;
+        }
+
+        self.dirty = false;
+        Ok(())
+    }
+
+    #[allow(dead_code)] // ignore warnings as this is only used in some cfgs
+    unsafe fn reset_all_memory_contents(
+        &mut self,
+        keep_resident: usize,
+        decommit: impl FnMut(*mut u8, usize),
+    ) -> Result<()> {
+        match vm::decommit_behavior() {
+            DecommitBehavior::Zero => {
+                // If we're not on Linux then there's no generic platform way to
+                // reset memory back to its original state, so instead reset memory
+                // back to entirely zeros with an anonymous backing.
+                //
+                // Additionally the previous image, if any, is dropped here
+                // since it's no longer applicable to this mapping.
+                self.reset_with_anon_memory()
+            }
+            DecommitBehavior::RestoreOriginalMapping => {
+                self.reset_with_original_mapping(keep_resident, decommit);
+                Ok(())
+            }
+        }
+    }
+
+    #[allow(dead_code)] // ignore warnings as this is only used in some cfgs
+    unsafe fn reset_with_original_mapping(
+        &mut self,
+        keep_resident: usize,
+        mut decommit: impl FnMut(*mut u8, usize),
+    ) {
+        match &self.image {
+            Some(image) => {
+                assert!(self.accessible >= image.linear_memory_offset + image.len);
+                if image.linear_memory_offset < keep_resident {
+                    // If the image starts below the `keep_resident` then
+                    // memory looks something like this:
+                    //
+                    //               up to `keep_resident` bytes
+                    //                          |
+                    //          +--------------------------+  remaining_memset
+                    //          |                          | /
+                    //  <-------------->                <------->
+                    //
+                    //                              image_end
+                    // 0        linear_memory_offset   |             accessible
+                    // |                |              |                  |
+                    // +----------------+--------------+---------+--------+
+                    // |  dirty memory  |    image     |   dirty memory   |
+                    // +----------------+--------------+---------+--------+
+                    //
+                    //  <------+-------> <-----+----->  <---+---> <--+--->
+                    //         |               |            |        |
+                    //         |               |            |        |
+                    //   memset (1)            /            |   madvise (4)
+                    //                  mmadvise (2)       /
+                    //                                    /
+                    //                              memset (3)
+                    //
+                    //
+                    // In this situation there are two disjoint regions that are
+                    // `memset` manually to zero. Note that `memset (3)` may be
+                    // zero bytes large. Furthermore `madvise (4)` may also be
+                    // zero bytes large.
+
+                    let image_end = image.linear_memory_offset + image.len;
+                    let mem_after_image = self.accessible - image_end;
+                    let remaining_memset =
+                        (keep_resident - image.linear_memory_offset).min(mem_after_image);
+
+                    // This is memset (1)
+                    ptr::write_bytes(self.base.as_ptr(), 0u8, image.linear_memory_offset);
+
+                    // This is madvise (2)
+                    self.restore_original_mapping(
+                        image.linear_memory_offset,
+                        image.len,
+                        &mut decommit,
+                    );
+
+                    // This is memset (3)
+                    ptr::write_bytes(self.base.as_ptr().add(image_end), 0u8, remaining_memset);
+
+                    // This is madvise (4)
+                    self.restore_original_mapping(
+                        image_end + remaining_memset,
+                        mem_after_image - remaining_memset,
+                        &mut decommit,
+                    );
+                } else {
+                    // If the image starts after the `keep_resident` threshold
+                    // then we memset the start of linear memory and then use
+                    // madvise below for the rest of it, including the image.
+                    //
+                    // 0             keep_resident                   accessible
+                    // |                |                                 |
+                    // +----------------+---+----------+------------------+
+                    // |  dirty memory      |  image   |   dirty memory   |
+                    // +----------------+---+----------+------------------+
+                    //
+                    //  <------+-------> <-------------+----------------->
+                    //         |                       |
+                    //         |                       |
+                    //   memset (1)                 madvise (2)
+                    //
+                    // Here only a single memset is necessary since the image
+                    // started after the threshold which we're keeping resident.
+                    // Note that the memset may be zero bytes here.
+
+                    // This is memset (1)
+                    ptr::write_bytes(self.base.as_ptr(), 0u8, keep_resident);
+
+                    // This is madvise (2)
+                    self.restore_original_mapping(
+                        keep_resident,
+                        self.accessible - keep_resident,
+                        decommit,
+                    );
+                }
+            }
+
+            // If there's no memory image for this slot then memset the first
+            // bytes in the memory back to zero while using `madvise` to purge
+            // the rest.
+            None => {
+                let size_to_memset = keep_resident.min(self.accessible);
+                ptr::write_bytes(self.base.as_ptr(), 0u8, size_to_memset);
+                self.restore_original_mapping(
+                    size_to_memset,
+                    self.accessible - size_to_memset,
+                    decommit,
+                );
+            }
+        }
+    }
+
+    #[allow(dead_code)] // ignore warnings as this is only used in some cfgs
+    unsafe fn restore_original_mapping(
+        &self,
+        base: usize,
+        len: usize,
+        mut decommit: impl FnMut(*mut u8, usize),
+    ) {
+        assert!(base + len <= self.accessible);
+        if len == 0 {
+            return;
+        }
+
+        assert_eq!(
+            vm::decommit_behavior(),
+            DecommitBehavior::RestoreOriginalMapping
+        );
+        decommit(self.base.as_ptr().add(base), len);
+    }
+
+    fn set_protection(&self, range: Range<usize>, readwrite: bool) -> Result<()> {
+        assert!(range.start <= range.end);
+        assert!(range.end <= self.static_size);
+        if range.len() == 0 {
+            return Ok(());
+        }
+
+        unsafe {
+            let start = self.base.as_ptr().add(range.start);
+            if readwrite {
+                vm::expose_existing_mapping(start, range.len()).err2anyhow()?;
+            } else {
+                vm::hide_existing_mapping(start, range.len()).err2anyhow()?;
+            }
+        }
+
+        Ok(())
+    }
+
+    pub(crate) fn has_image(&self) -> bool {
+        self.image.is_some()
+    }
+
+    #[allow(dead_code)] // ignore warnings as this is only used in some cfgs
+    pub(crate) fn is_dirty(&self) -> bool {
+        self.dirty
+    }
+
+    /// Map anonymous zeroed memory across the whole slot,
+    /// inaccessible. Used both during instantiate and during drop.
+    fn reset_with_anon_memory(&mut self) -> Result<()> {
+        if self.static_size == 0 {
+            assert!(self.image.is_none());
+            assert_eq!(self.accessible, 0);
+            return Ok(());
+        }
+
+        unsafe {
+            vm::erase_existing_mapping(self.base.as_ptr(), self.static_size).err2anyhow()?;
+        }
+
+        self.image = None;
+        self.accessible = 0;
+
+        Ok(())
+    }
+}
+
+impl Drop for MemoryImageSlot {
+    fn drop(&mut self) {
+        // The MemoryImageSlot may be dropped if there is an error during
+        // instantiation: for example, if a memory-growth limiter
+        // disallows a guest from having a memory of a certain size,
+        // after we've already initialized the MemoryImageSlot.
+        //
+        // We need to return this region of the large pool mmap to a
+        // safe state (with no module-specific mappings). The
+        // MemoryImageSlot will not be returned to the MemoryPool, so a new
+        // MemoryImageSlot will be created and overwrite the mappings anyway
+        // on the slot's next use; but for safety and to avoid
+        // resource leaks it's better not to have stale mappings to a
+        // possibly-otherwise-dead module's image.
+        //
+        // To "wipe the slate clean", let's do a mmap of anonymous
+        // memory over the whole region, with PROT_NONE. Note that we
+        // *can't* simply munmap, because that leaves a hole in the
+        // middle of the pooling allocator's big memory area that some
+        // other random mmap may swoop in and take, to be trampled
+        // over by the next MemoryImageSlot later.
+        //
+        // Since we're in drop(), we can't sanely return an error if
+        // this mmap fails. Instead though the result is unwrapped here to
+        // trigger a panic if something goes wrong. Otherwise if this
+        // reset-the-mapping fails then on reuse it might be possible, depending
+        // on precisely where errors happened, that stale memory could get
+        // leaked through.
+        //
+        // The exception to all of this is if the `clear_on_drop` flag
+        // (which is set by default) is false. If so, the owner of
+        // this MemoryImageSlot has indicated that it will clean up in some
+        // other way.
+        if self.clear_on_drop {
+            self.reset_with_anon_memory().unwrap();
+        }
+    }
+}
+
+#[cfg(all(test, target_os = "linux", not(miri)))]
+mod test {
+    use super::*;
+    use crate::runtime::vm::host_page_size;
+    use crate::runtime::vm::mmap::Mmap;
+    use crate::runtime::vm::sys::vm::decommit_pages;
+    use std::sync::Arc;
+    use wasmtime_environ::Memory;
+
+    fn create_memfd_with_data(offset: usize, data: &[u8]) -> Result<MemoryImage> {
+        // Offset must be page-aligned.
+        let page_size = host_page_size();
+        assert_eq!(offset & (page_size - 1), 0);
+
+        // The image length is rounded up to the nearest page size
+        let image_len = (data.len() + page_size - 1) & !(page_size - 1);
+
+        Ok(MemoryImage {
+            source: MemoryImageSource::from_data(data)?.unwrap(),
+            len: image_len,
+            source_offset: 0,
+            linear_memory_offset: offset,
+        })
+    }
+
+    fn dummy_memory_plan(style: MemoryStyle) -> MemoryPlan {
+        MemoryPlan {
+            style,
+            memory: Memory {
+                minimum: 0,
+                maximum: None,
+                shared: false,
+                memory64: false,
+                page_size_log2: Memory::DEFAULT_PAGE_SIZE_LOG2,
+            },
+            pre_guard_size: 0,
+            offset_guard_size: 0,
+        }
+    }
+
+    #[test]
+    fn instantiate_no_image() {
+        let plan = dummy_memory_plan(MemoryStyle::Static {
+            byte_reservation: 4 << 30,
+        });
+        // 4 MiB mmap'd area, not accessible
+        let mut mmap = Mmap::accessible_reserved(0, 4 << 20).unwrap();
+        // Create a MemoryImageSlot on top of it
+        let mut memfd = MemoryImageSlot::create(mmap.as_mut_ptr() as *mut _, 0, 4 << 20);
+        memfd.no_clear_on_drop();
+        assert!(!memfd.is_dirty());
+        // instantiate with 64 KiB initial size
+        memfd.instantiate(64 << 10, None, &plan).unwrap();
+        assert!(memfd.is_dirty());
+        // We should be able to access this 64 KiB (try both ends) and
+        // it should consist of zeroes.
+        let slice = unsafe { mmap.slice_mut(0..65536) };
+        assert_eq!(0, slice[0]);
+        assert_eq!(0, slice[65535]);
+        slice[1024] = 42;
+        assert_eq!(42, slice[1024]);
+        // grow the heap
+        memfd.set_heap_limit(128 << 10).unwrap();
+        let slice = unsafe { mmap.slice(0..1 << 20) };
+        assert_eq!(42, slice[1024]);
+        assert_eq!(0, slice[131071]);
+        // instantiate again; we should see zeroes, even as the
+        // reuse-anon-mmap-opt kicks in
+        memfd
+            .clear_and_remain_ready(0, |ptr, len| unsafe { decommit_pages(ptr, len).unwrap() })
+            .unwrap();
+        assert!(!memfd.is_dirty());
+        memfd.instantiate(64 << 10, None, &plan).unwrap();
+        let slice = unsafe { mmap.slice(0..65536) };
+        assert_eq!(0, slice[1024]);
+    }
+
+    #[test]
+    fn instantiate_image() {
+        let page_size = host_page_size();
+        let plan = dummy_memory_plan(MemoryStyle::Static {
+            byte_reservation: 4 << 30,
+        });
+        // 4 MiB mmap'd area, not accessible
+        let mut mmap = Mmap::accessible_reserved(0, 4 << 20).unwrap();
+        // Create a MemoryImageSlot on top of it
+        let mut memfd = MemoryImageSlot::create(mmap.as_mut_ptr() as *mut _, 0, 4 << 20);
+        memfd.no_clear_on_drop();
+        // Create an image with some data.
+        let image = Arc::new(create_memfd_with_data(page_size, &[1, 2, 3, 4]).unwrap());
+        // Instantiate with this image
+        memfd.instantiate(64 << 10, Some(&image), &plan).unwrap();
+        assert!(memfd.has_image());
+        let slice = unsafe { mmap.slice_mut(0..65536) };
+        assert_eq!(&[1, 2, 3, 4], &slice[page_size..][..4]);
+        slice[page_size] = 5;
+        // Clear and re-instantiate same image
+        memfd
+            .clear_and_remain_ready(0, |ptr, len| unsafe { decommit_pages(ptr, len).unwrap() })
+            .unwrap();
+        memfd.instantiate(64 << 10, Some(&image), &plan).unwrap();
+        let slice = unsafe { mmap.slice_mut(0..65536) };
+        // Should not see mutation from above
+        assert_eq!(&[1, 2, 3, 4], &slice[page_size..][..4]);
+        // Clear and re-instantiate no image
+        memfd
+            .clear_and_remain_ready(0, |ptr, len| unsafe { decommit_pages(ptr, len).unwrap() })
+            .unwrap();
+        memfd.instantiate(64 << 10, None, &plan).unwrap();
+        assert!(!memfd.has_image());
+        let slice = unsafe { mmap.slice_mut(0..65536) };
+        assert_eq!(&[0, 0, 0, 0], &slice[page_size..][..4]);
+        // Clear and re-instantiate image again
+        memfd
+            .clear_and_remain_ready(0, |ptr, len| unsafe { decommit_pages(ptr, len).unwrap() })
+            .unwrap();
+        memfd.instantiate(64 << 10, Some(&image), &plan).unwrap();
+        let slice = unsafe { mmap.slice_mut(0..65536) };
+        assert_eq!(&[1, 2, 3, 4], &slice[page_size..][..4]);
+        // Create another image with different data.
+        let image2 = Arc::new(create_memfd_with_data(page_size, &[10, 11, 12, 13]).unwrap());
+        memfd
+            .clear_and_remain_ready(0, |ptr, len| unsafe { decommit_pages(ptr, len).unwrap() })
+            .unwrap();
+        memfd.instantiate(128 << 10, Some(&image2), &plan).unwrap();
+        let slice = unsafe { mmap.slice_mut(0..65536) };
+        assert_eq!(&[10, 11, 12, 13], &slice[page_size..][..4]);
+        // Instantiate the original image again; we should notice it's
+        // a different image and not reuse the mappings.
+        memfd
+            .clear_and_remain_ready(0, |ptr, len| unsafe { decommit_pages(ptr, len).unwrap() })
+            .unwrap();
+        memfd.instantiate(64 << 10, Some(&image), &plan).unwrap();
+        let slice = unsafe { mmap.slice_mut(0..65536) };
+        assert_eq!(&[1, 2, 3, 4], &slice[page_size..][..4]);
+    }
+
+    #[test]
+    #[cfg(target_os = "linux")]
+    fn memset_instead_of_madvise() {
+        let page_size = host_page_size();
+        let plan = dummy_memory_plan(MemoryStyle::Static {
+            byte_reservation: 100 << 16,
+        });
+        let mut mmap = Mmap::accessible_reserved(0, 4 << 20).unwrap();
+        let mut memfd = MemoryImageSlot::create(mmap.as_mut_ptr() as *mut _, 0, 4 << 20);
+        memfd.no_clear_on_drop();
+
+        // Test basics with the image
+        for image_off in [0, page_size, page_size * 2] {
+            let image = Arc::new(create_memfd_with_data(image_off, &[1, 2, 3, 4]).unwrap());
+            for amt_to_memset in [0, page_size, page_size * 10, 1 << 20, 10 << 20] {
+                memfd.instantiate(64 << 10, Some(&image), &plan).unwrap();
+                assert!(memfd.has_image());
+                let slice = unsafe { mmap.slice_mut(0..64 << 10) };
+                if image_off > 0 {
+                    assert_eq!(slice[image_off - 1], 0);
+                }
+                assert_eq!(slice[image_off + 5], 0);
+                assert_eq!(&[1, 2, 3, 4], &slice[image_off..][..4]);
+                slice[image_off] = 5;
+                assert_eq!(&[5, 2, 3, 4], &slice[image_off..][..4]);
+                memfd
+                    .clear_and_remain_ready(amt_to_memset, |ptr, len| unsafe {
+                        decommit_pages(ptr, len).unwrap()
+                    })
+                    .unwrap();
+            }
+        }
+
+        // Test without an image
+        for amt_to_memset in [0, page_size, page_size * 10, 1 << 20, 10 << 20] {
+            memfd.instantiate(64 << 10, None, &plan).unwrap();
+            let mem = unsafe { mmap.slice_mut(0..64 << 10) };
+            for chunk in mem.chunks_mut(1024) {
+                assert_eq!(chunk[0], 0);
+                chunk[0] = 5;
+            }
+            memfd
+                .clear_and_remain_ready(amt_to_memset, |ptr, len| unsafe {
+                    decommit_pages(ptr, len).unwrap()
+                })
+                .unwrap();
+        }
+    }
+
+    #[test]
+    #[cfg(target_os = "linux")]
+    fn dynamic() {
+        let page_size = host_page_size();
+        let plan = dummy_memory_plan(MemoryStyle::Dynamic { reserve: 200 });
+
+        let mut mmap = Mmap::accessible_reserved(0, 4 << 20).unwrap();
+        let mut memfd = MemoryImageSlot::create(mmap.as_mut_ptr() as *mut _, 0, 4 << 20);
+        memfd.no_clear_on_drop();
+        let image = Arc::new(create_memfd_with_data(page_size, &[1, 2, 3, 4]).unwrap());
+        let initial = 64 << 10;
+
+        // Instantiate the image and test that memory remains accessible after
+        // it's cleared.
+        memfd.instantiate(initial, Some(&image), &plan).unwrap();
+        assert!(memfd.has_image());
+        let slice = unsafe { mmap.slice_mut(0..(64 << 10) + page_size) };
+        assert_eq!(&[1, 2, 3, 4], &slice[page_size..][..4]);
+        slice[page_size] = 5;
+        assert_eq!(&[5, 2, 3, 4], &slice[page_size..][..4]);
+        memfd
+            .clear_and_remain_ready(0, |ptr, len| unsafe { decommit_pages(ptr, len).unwrap() })
+            .unwrap();
+        assert_eq!(&[1, 2, 3, 4], &slice[page_size..][..4]);
+
+        // Re-instantiate make sure it preserves memory. Grow a bit and set data
+        // beyond the initial size.
+        memfd.instantiate(initial, Some(&image), &plan).unwrap();
+        assert_eq!(&[1, 2, 3, 4], &slice[page_size..][..4]);
+        memfd.set_heap_limit(initial * 2).unwrap();
+        assert_eq!(&[0, 0], &slice[initial..initial + 2]);
+        slice[initial] = 100;
+        assert_eq!(&[100, 0], &slice[initial..initial + 2]);
+        memfd
+            .clear_and_remain_ready(0, |ptr, len| unsafe { decommit_pages(ptr, len).unwrap() })
+            .unwrap();
+
+        // Test that memory is still accessible, but it's been reset
+        assert_eq!(&[0, 0], &slice[initial..initial + 2]);
+
+        // Instantiate again, and again memory beyond the initial size should
+        // still be accessible. Grow into it again and make sure it works.
+        memfd.instantiate(initial, Some(&image), &plan).unwrap();
+        assert_eq!(&[0, 0], &slice[initial..initial + 2]);
+        memfd.set_heap_limit(initial * 2).unwrap();
+        assert_eq!(&[0, 0], &slice[initial..initial + 2]);
+        slice[initial] = 100;
+        assert_eq!(&[100, 0], &slice[initial..initial + 2]);
+        memfd
+            .clear_and_remain_ready(0, |ptr, len| unsafe { decommit_pages(ptr, len).unwrap() })
+            .unwrap();
+
+        // Reset the image to none and double-check everything is back to zero
+        memfd.instantiate(64 << 10, None, &plan).unwrap();
+        assert!(!memfd.has_image());
+        assert_eq!(&[0, 0, 0, 0], &slice[page_size..][..4]);
+        assert_eq!(&[0, 0], &slice[initial..initial + 2]);
+    }
+}
diff --git a/crates/runtime/src/debug_builtins.rs b/crates/wasmtime/src/runtime/vm/debug_builtins.rs
similarity index 95%
rename from crates/runtime/src/debug_builtins.rs
rename to crates/wasmtime/src/runtime/vm/debug_builtins.rs
index 82ac1cf37609..beef757aee91 100644
--- a/crates/runtime/src/debug_builtins.rs
+++ b/crates/wasmtime/src/runtime/vm/debug_builtins.rs
@@ -1,7 +1,7 @@
 #![doc(hidden)]
 
-use crate::instance::Instance;
-use crate::vmcontext::VMContext;
+use crate::runtime::vm::instance::Instance;
+use crate::runtime::vm::vmcontext::VMContext;
 use wasmtime_environ::{EntityRef, MemoryIndex};
 use wasmtime_versioned_export_macros::versioned_export;
 
diff --git a/crates/runtime/src/export.rs b/crates/wasmtime/src/runtime/vm/export.rs
similarity index 84%
rename from crates/runtime/src/export.rs
rename to crates/wasmtime/src/runtime/vm/export.rs
index 93ed6ebe9e78..aebe55b49ca4 100644
--- a/crates/runtime/src/export.rs
+++ b/crates/wasmtime/src/runtime/vm/export.rs
@@ -1,7 +1,7 @@
-use crate::vmcontext::{
+use crate::runtime::vm::vmcontext::{
     VMContext, VMFuncRef, VMGlobalDefinition, VMMemoryDefinition, VMTableDefinition,
 };
-use std::ptr::NonNull;
+use core::ptr::NonNull;
 use wasmtime_environ::{DefinedMemoryIndex, Global, MemoryPlan, TablePlan};
 
 /// The value of an export passed from one instance to another.
@@ -29,9 +29,9 @@ pub struct ExportFunction {
     pub func_ref: NonNull<VMFuncRef>,
 }
 
-// It's part of the contract of using `ExportFunction` that synchronization
-// properties are upheld, so declare that despite the raw pointers inside this
-// is send/sync.
+// As part of the contract for using `ExportFunction`, synchronization
+// properties must be upheld. Therefore, despite containing raw pointers,
+// it is declared as Send/Sync.
 unsafe impl Send for ExportFunction {}
 unsafe impl Sync for ExportFunction {}
 
@@ -48,7 +48,7 @@ pub struct ExportTable {
     pub definition: *mut VMTableDefinition,
     /// Pointer to the containing `VMContext`.
     pub vmctx: *mut VMContext,
-    /// The table declaration, used for compatibilty checking.
+    /// The table declaration, used for compatibility checking.
     pub table: TablePlan,
 }
 
@@ -90,7 +90,10 @@ impl From<ExportMemory> for Export {
 pub struct ExportGlobal {
     /// The address of the global storage.
     pub definition: *mut VMGlobalDefinition,
-    /// The global declaration, used for compatibilty checking.
+    /// Pointer to the containing `VMContext`. May be null for host-created
+    /// globals.
+    pub vmctx: *mut VMContext,
+    /// The global declaration, used for compatibility checking.
     pub global: Global,
 }
 
diff --git a/crates/wasmtime/src/runtime/vm/gc.rs b/crates/wasmtime/src/runtime/vm/gc.rs
new file mode 100644
index 000000000000..beafb0c71951
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/gc.rs
@@ -0,0 +1,339 @@
+#[cfg(feature = "gc")]
+mod enabled;
+#[cfg(feature = "gc")]
+pub use enabled::*;
+
+#[cfg(not(feature = "gc"))]
+mod disabled;
+#[cfg(not(feature = "gc"))]
+pub use disabled::*;
+
+mod gc_ref;
+mod gc_runtime;
+mod host_data;
+mod i31;
+
+pub use gc_ref::*;
+pub use gc_runtime::*;
+pub use host_data::*;
+pub use i31::*;
+
+use crate::prelude::*;
+use crate::runtime::vm::GcHeapAllocationIndex;
+use core::ptr;
+use core::{any::Any, num::NonZeroUsize};
+use wasmtime_environ::{StackMap, VMGcKind, VMSharedTypeIndex};
+
+/// Used by the runtime to lookup information about a module given a
+/// program counter value.
+pub trait ModuleInfoLookup {
+    /// Lookup the module information from a program counter value.
+    fn lookup(&self, pc: usize) -> Option<&dyn ModuleInfo>;
+}
+
+/// Used by the runtime to query module information.
+pub trait ModuleInfo {
+    /// Lookup the stack map at a program counter value.
+    fn lookup_stack_map(&self, pc: usize) -> Option<&StackMap>;
+}
+
+/// GC-related data that is one-to-one with a `wasmtime::Store`.
+///
+/// Contains everything we need to do collections, invoke barriers, etc...
+///
+/// In general, exposes a very similar interface to `GcHeap`, but fills in some
+/// of the context arguments for callers (such as the `ExternRefHostDataTable`)
+/// since they are all stored together inside `GcStore`.
+pub struct GcStore {
+    /// This GC heap's allocation index (primarily used for integrating with the
+    /// pooling allocator).
+    pub allocation_index: GcHeapAllocationIndex,
+
+    /// The actual GC heap.
+    pub gc_heap: Box<dyn GcHeap>,
+
+    /// The `externref` host data table for this GC heap.
+    pub host_data_table: ExternRefHostDataTable,
+}
+
+impl GcStore {
+    /// Create a new `GcStore`.
+    pub fn new(allocation_index: GcHeapAllocationIndex, gc_heap: Box<dyn GcHeap>) -> Self {
+        let host_data_table = ExternRefHostDataTable::default();
+        Self {
+            allocation_index,
+            gc_heap,
+            host_data_table,
+        }
+    }
+
+    /// Perform garbage collection within this heap.
+    pub fn gc(&mut self, roots: GcRootsIter<'_>) {
+        let mut collection = self.gc_heap.gc(roots, &mut self.host_data_table);
+        collection.collect();
+    }
+
+    /// Asynchronously perform garbage collection within this heap.
+    #[cfg(feature = "async")]
+    pub async fn gc_async(&mut self, roots: GcRootsIter<'_>) {
+        let collection = self.gc_heap.gc(roots, &mut self.host_data_table);
+        collect_async(collection).await;
+    }
+
+    /// Get the kind of the given GC reference.
+    pub fn kind(&self, gc_ref: &VMGcRef) -> VMGcKind {
+        debug_assert!(!gc_ref.is_i31());
+        self.header(gc_ref).kind()
+    }
+
+    /// Get the header of the given GC reference.
+    pub fn header(&self, gc_ref: &VMGcRef) -> &VMGcHeader {
+        debug_assert!(!gc_ref.is_i31());
+        self.gc_heap.header(gc_ref)
+    }
+
+    /// Clone a GC reference, calling GC write barriers as necessary.
+    pub fn clone_gc_ref(&mut self, gc_ref: &VMGcRef) -> VMGcRef {
+        if gc_ref.is_i31() {
+            gc_ref.unchecked_copy()
+        } else {
+            self.gc_heap.clone_gc_ref(gc_ref)
+        }
+    }
+
+    /// Write the `source` GC reference into the `destination` slot, performing
+    /// write barriers as necessary.
+    pub fn write_gc_ref(&mut self, destination: &mut Option<VMGcRef>, source: Option<&VMGcRef>) {
+        // If neither the source nor destination actually point to a GC object
+        // (that is, they are both either null or `i31ref`s) then we can skip
+        // the GC barrier.
+        if destination.as_ref().map_or(true, |d| d.is_i31())
+            && source.as_ref().map_or(true, |s| s.is_i31())
+        {
+            *destination = source.map(|s| s.unchecked_copy());
+            return;
+        }
+
+        self.gc_heap
+            .write_gc_ref(&mut self.host_data_table, destination, source);
+    }
+
+    /// Drop the given GC reference, performing drop barriers as necessary.
+    pub fn drop_gc_ref(&mut self, gc_ref: VMGcRef) {
+        if !gc_ref.is_i31() {
+            self.gc_heap.drop_gc_ref(&mut self.host_data_table, gc_ref);
+        }
+    }
+
+    /// Hook to call whenever a GC reference is about to be exposed to Wasm.
+    pub fn expose_gc_ref_to_wasm(&mut self, gc_ref: VMGcRef) {
+        if !gc_ref.is_i31() {
+            log::trace!("exposing GC ref to Wasm: {gc_ref:p}");
+            self.gc_heap.expose_gc_ref_to_wasm(gc_ref);
+        }
+    }
+
+    /// Allocate a new `externref`.
+    ///
+    /// Returns:
+    ///
+    /// * `Ok(Ok(_))`: Successfully allocated the `externref`.
+    ///
+    /// * `Ok(Err(value))`: Failed to allocate the `externref`, but doing a GC
+    ///   and then trying again may succeed. Returns the given `value` as the
+    ///   error payload.
+    ///
+    /// * `Err(_)`: Unrecoverable allocation failure.
+    pub fn alloc_externref(
+        &mut self,
+        value: Box<dyn Any + Send + Sync>,
+    ) -> Result<Result<VMExternRef, Box<dyn Any + Send + Sync>>> {
+        let host_data_id = self.host_data_table.alloc(value);
+        match self.gc_heap.alloc_externref(host_data_id)? {
+            #[cfg_attr(not(feature = "gc"), allow(unreachable_patterns))]
+            Some(x) => Ok(Ok(x)),
+            None => Ok(Err(self.host_data_table.dealloc(host_data_id))),
+        }
+    }
+
+    /// Get a shared borrow of the given `externref`'s host data.
+    ///
+    /// Passing invalid `VMExternRef`s (eg garbage values or `externref`s
+    /// associated with a different heap is memory safe but will lead to general
+    /// incorrectness such as panics and wrong results.
+    pub fn externref_host_data(&self, externref: &VMExternRef) -> &(dyn Any + Send + Sync) {
+        let host_data_id = self.gc_heap.externref_host_data(externref);
+        self.host_data_table.get(host_data_id)
+    }
+
+    /// Get a mutable borrow of the given `externref`'s host data.
+    ///
+    /// Passing invalid `VMExternRef`s (eg garbage values or `externref`s
+    /// associated with a different heap is memory safe but will lead to general
+    /// incorrectness such as panics and wrong results.
+    pub fn externref_host_data_mut(
+        &mut self,
+        externref: &VMExternRef,
+    ) -> &mut (dyn Any + Send + Sync) {
+        let host_data_id = self.gc_heap.externref_host_data(externref);
+        self.host_data_table.get_mut(host_data_id)
+    }
+
+    /// Allocate an uninitialized struct with the given type index and layout.
+    ///
+    /// This does NOT check that the index is currently allocated in the types
+    /// registry or that the layout matches the index's type. Failure to uphold
+    /// those invariants is memory safe, but will lead to general incorrectness
+    /// such as panics and wrong results.
+    pub fn alloc_uninit_struct(
+        &mut self,
+        ty: VMSharedTypeIndex,
+        layout: &GcStructLayout,
+    ) -> Result<Option<VMStructRef>> {
+        self.gc_heap.alloc_uninit_struct(ty, layout)
+    }
+
+    /// Deallocate an uninitialized struct.
+    pub fn dealloc_uninit_struct(&mut self, structref: VMStructRef) {
+        self.gc_heap.dealloc_uninit_struct(structref);
+    }
+
+    /// Get the data for the given object reference.
+    ///
+    /// Panics when the structref and its size is out of the GC heap bounds.
+    pub fn gc_object_data(&mut self, gc_ref: &VMGcRef) -> VMGcObjectDataMut<'_> {
+        self.gc_heap.gc_object_data(gc_ref)
+    }
+
+    /// Allocate an uninitialized array with the given type index.
+    ///
+    /// This does NOT check that the index is currently allocated in the types
+    /// registry or that the layout matches the index's type. Failure to uphold
+    /// those invariants is memory safe, but will lead to general incorrectness
+    /// such as panics and wrong results.
+    pub fn alloc_uninit_array(
+        &mut self,
+        ty: VMSharedTypeIndex,
+        len: u32,
+        layout: &GcArrayLayout,
+    ) -> Result<Option<VMArrayRef>> {
+        self.gc_heap.alloc_uninit_array(ty, len, layout)
+    }
+
+    /// Deallocate an uninitialized array.
+    pub fn dealloc_uninit_array(&mut self, arrayref: VMArrayRef) {
+        self.gc_heap.dealloc_uninit_array(arrayref);
+    }
+
+    /// Get the length of the given array.
+    pub fn array_len(&self, arrayref: &VMArrayRef) -> u32 {
+        self.gc_heap.array_len(arrayref)
+    }
+}
+
+/// Get a no-op GC heap for when GC is disabled (either statically at compile
+/// time or dynamically due to it being turned off in the `wasmtime::Config`).
+pub fn disabled_gc_heap() -> Box<dyn GcHeap> {
+    return Box::new(DisabledGcHeap);
+}
+
+pub(crate) struct DisabledGcHeap;
+
+unsafe impl GcHeap for DisabledGcHeap {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+    fn as_any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+    fn enter_no_gc_scope(&mut self) {}
+    fn exit_no_gc_scope(&mut self) {}
+    fn header(&self, _gc_ref: &VMGcRef) -> &VMGcHeader {
+        unreachable!()
+    }
+    fn clone_gc_ref(&mut self, _gc_ref: &VMGcRef) -> VMGcRef {
+        unreachable!()
+    }
+    fn write_gc_ref(
+        &mut self,
+        _host_data_table: &mut ExternRefHostDataTable,
+        _destination: &mut Option<VMGcRef>,
+        _source: Option<&VMGcRef>,
+    ) {
+        unreachable!()
+    }
+    fn expose_gc_ref_to_wasm(&mut self, _gc_ref: VMGcRef) {
+        unreachable!()
+    }
+    fn need_gc_before_entering_wasm(&self, _num_gc_refs: NonZeroUsize) -> bool {
+        unreachable!()
+    }
+    fn alloc_externref(&mut self, _host_data: ExternRefHostDataId) -> Result<Option<VMExternRef>> {
+        bail!(
+            "GC support disabled either in the `Config` or at compile time \
+                 because the `gc` cargo feature was not enabled"
+        )
+    }
+    fn externref_host_data(&self, _externref: &VMExternRef) -> ExternRefHostDataId {
+        unreachable!()
+    }
+    fn alloc_uninit_struct(
+        &mut self,
+        _ty: wasmtime_environ::VMSharedTypeIndex,
+        _layout: &GcStructLayout,
+    ) -> Result<Option<VMStructRef>> {
+        bail!(
+            "GC support disabled either in the `Config` or at compile time \
+                 because the `gc` cargo feature was not enabled"
+        )
+    }
+    fn dealloc_uninit_struct(&mut self, _structref: VMStructRef) {
+        unreachable!()
+    }
+    fn gc_object_data(&mut self, _gc_ref: &VMGcRef) -> VMGcObjectDataMut<'_> {
+        unreachable!()
+    }
+    fn alloc_uninit_array(
+        &mut self,
+        _ty: VMSharedTypeIndex,
+        _len: u32,
+        _layout: &GcArrayLayout,
+    ) -> Result<Option<VMArrayRef>> {
+        bail!(
+            "GC support disabled either in the `Config` or at compile time \
+                 because the `gc` cargo feature was not enabled"
+        )
+    }
+    fn dealloc_uninit_array(&mut self, _structref: VMArrayRef) {
+        unreachable!()
+    }
+    fn array_len(&self, _arrayref: &VMArrayRef) -> u32 {
+        unreachable!()
+    }
+    fn gc<'a>(
+        &'a mut self,
+        _roots: GcRootsIter<'a>,
+        _host_data_table: &'a mut ExternRefHostDataTable,
+    ) -> Box<dyn GarbageCollection<'a> + 'a> {
+        return Box::new(NoGc);
+
+        struct NoGc;
+
+        impl<'a> GarbageCollection<'a> for NoGc {
+            fn collect_increment(&mut self) -> GcProgress {
+                GcProgress::Complete
+            }
+        }
+    }
+    unsafe fn vmctx_gc_heap_base(&self) -> *mut u8 {
+        ptr::null_mut()
+    }
+    unsafe fn vmctx_gc_heap_bound(&self) -> usize {
+        0
+    }
+    unsafe fn vmctx_gc_heap_data(&self) -> *mut u8 {
+        ptr::null_mut()
+    }
+    #[cfg(feature = "pooling-allocator")]
+    fn reset(&mut self) {}
+}
diff --git a/crates/wasmtime/src/runtime/vm/gc/disabled.rs b/crates/wasmtime/src/runtime/vm/gc/disabled.rs
new file mode 100644
index 000000000000..24aa269ffbae
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/gc/disabled.rs
@@ -0,0 +1,41 @@
+//! Dummy GC types for when the `gc` cargo feature is disabled.
+//!
+//! To reduce `#[cfg(...)]`s, this provides all the same methods as the real
+//! `VMExternRef` except for constructors.
+
+#![allow(missing_docs)]
+
+use crate::prelude::*;
+use crate::runtime::vm::{GcArrayLayout, GcHeap, GcRuntime, GcStructLayout};
+use wasmtime_environ::{WasmArrayType, WasmStructType};
+
+pub fn default_gc_runtime() -> impl GcRuntime {
+    DisabledCollector
+}
+
+struct DisabledCollector;
+
+unsafe impl GcRuntime for DisabledCollector {
+    fn new_gc_heap(&self) -> Result<Box<dyn GcHeap>> {
+        unreachable!()
+    }
+
+    fn array_layout(&self, _ty: &WasmArrayType) -> GcArrayLayout {
+        unreachable!()
+    }
+
+    fn struct_layout(&self, _ty: &WasmStructType) -> GcStructLayout {
+        unreachable!()
+    }
+}
+
+pub enum VMExternRef {}
+
+pub enum VMStructRef {}
+
+pub enum VMArrayRef {}
+
+pub struct VMGcObjectDataMut<'a> {
+    inner: VMStructRef,
+    _phantom: core::marker::PhantomData<&'a mut ()>,
+}
diff --git a/crates/wasmtime/src/runtime/vm/gc/enabled.rs b/crates/wasmtime/src/runtime/vm/gc/enabled.rs
new file mode 100644
index 000000000000..ca8ab8859a87
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/gc/enabled.rs
@@ -0,0 +1,29 @@
+//! Implementation of garbage collection and GC types in Wasmtime.
+
+mod arrayref;
+mod data;
+mod drc;
+mod externref;
+mod free_list;
+mod structref;
+
+pub use arrayref::*;
+pub use data::*;
+pub use drc::*;
+pub use externref::*;
+pub use structref::*;
+
+use crate::runtime::vm::GcRuntime;
+
+/// Get the default GC runtime.
+pub fn default_gc_runtime() -> impl GcRuntime {
+    DrcCollector
+}
+
+/// The default GC heap capacity: 512KiB.
+#[cfg(not(miri))]
+const DEFAULT_GC_HEAP_CAPACITY: usize = 1 << 19;
+
+/// The default GC heap capacity for miri: 64KiB.
+#[cfg(miri)]
+const DEFAULT_GC_HEAP_CAPACITY: usize = 1 << 16;
diff --git a/crates/wasmtime/src/runtime/vm/gc/enabled/arrayref.rs b/crates/wasmtime/src/runtime/vm/gc/enabled/arrayref.rs
new file mode 100644
index 000000000000..d6d192226e00
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/gc/enabled/arrayref.rs
@@ -0,0 +1,342 @@
+use crate::{
+    prelude::*,
+    runtime::vm::{GcHeap, GcStore, VMGcRef},
+    store::{AutoAssertNoGc, StoreOpaque},
+    vm::GcArrayLayout,
+    AnyRef, ExternRef, HeapType, RootedGcRefImpl, StorageType, Val, ValType,
+};
+use core::fmt;
+use wasmtime_environ::VMGcKind;
+
+/// A `VMGcRef` that we know points to a `array`.
+///
+/// Create a `VMArrayRef` via `VMGcRef::into_arrayref` and
+/// `VMGcRef::as_arrayref`, or their untyped equivalents
+/// `VMGcRef::into_arrayref_unchecked` and `VMGcRef::as_arrayref_unchecked`.
+///
+/// Note: This is not a `TypedGcRef<_>` because each collector can have a
+/// different concrete representation of `arrayref` that they allocate inside
+/// their heaps.
+#[derive(Debug, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct VMArrayRef(VMGcRef);
+
+impl fmt::Pointer for VMArrayRef {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Pointer::fmt(&self.0, f)
+    }
+}
+
+impl From<VMArrayRef> for VMGcRef {
+    #[inline]
+    fn from(x: VMArrayRef) -> Self {
+        x.0
+    }
+}
+
+impl VMGcRef {
+    /// Is this `VMGcRef` pointing to a `array`?
+    pub fn is_arrayref(&self, gc_heap: &(impl GcHeap + ?Sized)) -> bool {
+        if self.is_i31() {
+            return false;
+        }
+
+        let header = gc_heap.header(&self);
+        header.kind().matches(VMGcKind::ArrayRef)
+    }
+
+    /// Create a new `VMArrayRef` from the given `gc_ref`.
+    ///
+    /// If this is not a GC reference to an `arrayref`, `Err(self)` is
+    /// returned.
+    pub fn into_arrayref(self, gc_heap: &impl GcHeap) -> Result<VMArrayRef, VMGcRef> {
+        if self.is_arrayref(gc_heap) {
+            Ok(self.into_arrayref_unchecked())
+        } else {
+            Err(self)
+        }
+    }
+
+    /// Create a new `VMArrayRef` from `self` without actually checking that
+    /// `self` is an `arrayref`.
+    ///
+    /// This method does not check that `self` is actually an `arrayref`, but
+    /// it should be. Failure to uphold this invariant is memory safe but will
+    /// result in general incorrectness down the line such as panics or wrong
+    /// results.
+    #[inline]
+    pub fn into_arrayref_unchecked(self) -> VMArrayRef {
+        debug_assert!(!self.is_i31());
+        VMArrayRef(self)
+    }
+
+    /// Get this GC reference as an `arrayref` reference, if it actually is an
+    /// `arrayref` reference.
+    pub fn as_arrayref(&self, gc_heap: &(impl GcHeap + ?Sized)) -> Option<&VMArrayRef> {
+        if self.is_arrayref(gc_heap) {
+            Some(self.as_arrayref_unchecked())
+        } else {
+            None
+        }
+    }
+
+    /// Get this GC reference as an `arrayref` reference without checking if it
+    /// actually is an `arrayref` reference.
+    ///
+    /// Calling this method on a non-`arrayref` reference is memory safe, but
+    /// will lead to general incorrectness like panics and wrong results.
+    pub fn as_arrayref_unchecked(&self) -> &VMArrayRef {
+        debug_assert!(!self.is_i31());
+        let ptr = self as *const VMGcRef;
+        let ret = unsafe { &*ptr.cast() };
+        assert!(matches!(ret, VMArrayRef(VMGcRef { .. })));
+        ret
+    }
+}
+
+impl VMArrayRef {
+    /// Get the underlying `VMGcRef`.
+    pub fn as_gc_ref(&self) -> &VMGcRef {
+        &self.0
+    }
+
+    /// Clone this `VMArrayRef`, running any GC barriers as necessary.
+    pub fn clone(&self, gc_store: &mut GcStore) -> Self {
+        Self(gc_store.clone_gc_ref(&self.0))
+    }
+
+    /// Explicitly drop this `arrayref`, running GC drop barriers as necessary.
+    pub fn drop(self, gc_store: &mut GcStore) {
+        gc_store.drop_gc_ref(self.0);
+    }
+
+    /// Copy this `VMArrayRef` without running the GC's clone barriers.
+    ///
+    /// Prefer calling `clone(&mut GcStore)` instead! This is mostly an internal
+    /// escape hatch for collector implementations.
+    ///
+    /// Failure to run GC barriers when they would otherwise be necessary can
+    /// lead to leaks, panics, and wrong results. It cannot lead to memory
+    /// unsafety, however.
+    pub fn unchecked_copy(&self) -> Self {
+        Self(self.0.unchecked_copy())
+    }
+
+    /// Get the length of this array.
+    pub fn len(&self, store: &StoreOpaque) -> u32 {
+        store.unwrap_gc_store().array_len(self)
+    }
+
+    /// Read an element of the given `StorageType` into a `Val`.
+    ///
+    /// `i8` and `i16` fields are zero-extended into `Val::I32(_)`s.
+    ///
+    /// Does not check that this array's elements are actually of type
+    /// `ty`. That is the caller's responsibility. Failure to do so is memory
+    /// safe, but will lead to general incorrectness such as panics and wrong
+    /// results.
+    ///
+    /// Panics on out-of-bounds accesses.
+    pub fn read_elem(
+        &self,
+        store: &mut AutoAssertNoGc,
+        layout: &GcArrayLayout,
+        ty: &StorageType,
+        index: u32,
+    ) -> Val {
+        let offset = layout.elems_offset + index * ty.byte_size_in_gc_heap();
+        let data = store.unwrap_gc_store_mut().gc_object_data(self.as_gc_ref());
+        match ty {
+            StorageType::I8 => Val::I32(data.read_u8(offset).into()),
+            StorageType::I16 => Val::I32(data.read_u16(offset).into()),
+            StorageType::ValType(ValType::I32) => Val::I32(data.read_i32(offset)),
+            StorageType::ValType(ValType::I64) => Val::I64(data.read_i64(offset)),
+            StorageType::ValType(ValType::F32) => Val::F32(data.read_u32(offset)),
+            StorageType::ValType(ValType::F64) => Val::F64(data.read_u64(offset)),
+            StorageType::ValType(ValType::V128) => Val::V128(data.read_v128(offset)),
+            StorageType::ValType(ValType::Ref(r)) => match r.heap_type().top() {
+                HeapType::Extern => {
+                    let raw = data.read_u32(offset);
+                    Val::ExternRef(ExternRef::_from_raw(store, raw))
+                }
+                HeapType::Any => {
+                    let raw = data.read_u32(offset);
+                    Val::AnyRef(AnyRef::_from_raw(store, raw))
+                }
+                HeapType::Func => todo!("funcrefs inside gc objects not yet implemented"),
+                otherwise => unreachable!("not a top type: {otherwise:?}"),
+            },
+        }
+    }
+
+    /// Write the given value into this array at the given offset.
+    ///
+    /// Returns an error if `val` is a GC reference that has since been
+    /// unrooted.
+    ///
+    /// Does not check that `val` matches `ty`, nor that the field is actually
+    /// of type `ty`. Checking those things is the caller's responsibility.
+    /// Failure to do so is memory safe, but will lead to general incorrectness
+    /// such as panics and wrong results.
+    ///
+    /// Panics on out-of-bounds accesses.
+    pub fn write_elem(
+        &self,
+        store: &mut AutoAssertNoGc,
+        layout: &GcArrayLayout,
+        ty: &StorageType,
+        index: u32,
+        val: Val,
+    ) -> Result<()> {
+        debug_assert!(val._matches_ty(&store, &ty.unpack())?);
+
+        let offset = layout.elem_offset(index, ty.byte_size_in_gc_heap());
+        let mut data = store.unwrap_gc_store_mut().gc_object_data(self.as_gc_ref());
+        match val {
+            Val::I32(i) if ty.is_i8() => data.write_i8(offset, i as i8),
+            Val::I32(i) if ty.is_i16() => data.write_i16(offset, i as i16),
+            Val::I32(i) => data.write_i32(offset, i),
+            Val::I64(i) => data.write_i64(offset, i),
+            Val::F32(f) => data.write_u32(offset, f),
+            Val::F64(f) => data.write_u64(offset, f),
+            Val::V128(v) => data.write_v128(offset, v),
+
+            // For GC-managed references, we need to take care to run the
+            // appropriate barriers, even when we are writing null references
+            // into the array.
+            //
+            // POD-read the old value into a local copy, run the GC write
+            // barrier on that local copy, and then POD-write the updated
+            // value back into the array. This avoids transmuting the inner
+            // data, which would probably be fine, but this approach is
+            // Obviously Correct and should get us by for now. If LLVM isn't
+            // able to elide some of these unnecessary copies, and this
+            // method is ever hot enough, we can always come back and clean
+            // it up in the future.
+            Val::ExternRef(e) => {
+                let raw = data.read_u32(offset);
+                let mut gc_ref = VMGcRef::from_raw_u32(raw);
+                let e = match e {
+                    Some(e) => Some(e.try_gc_ref(store)?.unchecked_copy()),
+                    None => None,
+                };
+                store.gc_store_mut()?.write_gc_ref(&mut gc_ref, e.as_ref());
+                let mut data = store.gc_store_mut()?.gc_object_data(self.as_gc_ref());
+                data.write_u32(offset, gc_ref.map_or(0, |r| r.as_raw_u32()));
+            }
+            Val::AnyRef(a) => {
+                let raw = data.read_u32(offset);
+                let mut gc_ref = VMGcRef::from_raw_u32(raw);
+                let a = match a {
+                    Some(a) => Some(a.try_gc_ref(store)?.unchecked_copy()),
+                    None => None,
+                };
+                store.gc_store_mut()?.write_gc_ref(&mut gc_ref, a.as_ref());
+                let mut data = store.gc_store_mut()?.gc_object_data(self.as_gc_ref());
+                data.write_u32(offset, gc_ref.map_or(0, |r| r.as_raw_u32()));
+            }
+
+            Val::FuncRef(_) => todo!("funcrefs inside gc objects not yet implemented"),
+        }
+        Ok(())
+    }
+
+    /// Initialize an element in this arrayref that is currently uninitialized.
+    ///
+    /// The difference between this method and `write_elem` is that GC barriers
+    /// are handled differently. When overwriting an initialized element (aka
+    /// `write_elem`) we need to call the full write GC write barrier, which
+    /// logically drops the old GC reference and clones the new GC
+    /// reference. When we are initializing an element for the first time, there
+    /// is no old GC reference that is being overwritten and which we need to
+    /// drop, so we only need to clone the new GC reference.
+    ///
+    /// Calling this method on a arrayref that has already had the associated
+    /// element initialized will result in GC bugs. These are memory safe but
+    /// will lead to generally incorrect behavior such as panics, leaks, and
+    /// incorrect results.
+    ///
+    /// Does not check that `val` matches `ty`, nor that the field is actually
+    /// of type `ty`. Checking those things is the caller's responsibility.
+    /// Failure to do so is memory safe, but will lead to general incorrectness
+    /// such as panics and wrong results.
+    ///
+    /// Returns an error if `val` is a GC reference that has since been
+    /// unrooted.
+    ///
+    /// Panics on out-of-bounds accesses.
+    pub fn initialize_elem(
+        &self,
+        store: &mut AutoAssertNoGc,
+        layout: &GcArrayLayout,
+        ty: &StorageType,
+        index: u32,
+        val: Val,
+    ) -> Result<()> {
+        debug_assert!(val._matches_ty(&store, &ty.unpack())?);
+        let offset = layout.elem_offset(index, ty.byte_size_in_gc_heap());
+        match val {
+            Val::I32(i) if ty.is_i8() => store
+                .gc_store_mut()?
+                .gc_object_data(self.as_gc_ref())
+                .write_i8(offset, i as i8),
+            Val::I32(i) if ty.is_i16() => store
+                .gc_store_mut()?
+                .gc_object_data(self.as_gc_ref())
+                .write_i16(offset, i as i16),
+            Val::I32(i) => store
+                .gc_store_mut()?
+                .gc_object_data(self.as_gc_ref())
+                .write_i32(offset, i),
+            Val::I64(i) => store
+                .gc_store_mut()?
+                .gc_object_data(self.as_gc_ref())
+                .write_i64(offset, i),
+            Val::F32(f) => store
+                .gc_store_mut()?
+                .gc_object_data(self.as_gc_ref())
+                .write_u32(offset, f),
+            Val::F64(f) => store
+                .gc_store_mut()?
+                .gc_object_data(self.as_gc_ref())
+                .write_u64(offset, f),
+            Val::V128(v) => store
+                .gc_store_mut()?
+                .gc_object_data(self.as_gc_ref())
+                .write_v128(offset, v),
+
+            // NB: We don't need to do a write barrier when initializing a
+            // field, because there is nothing being overwritten. Therefore, we
+            // just the clone barrier.
+            Val::ExternRef(x) => {
+                let x = match x {
+                    None => 0,
+                    Some(x) => x.try_clone_gc_ref(store)?.as_raw_u32(),
+                };
+                store
+                    .gc_store_mut()?
+                    .gc_object_data(self.as_gc_ref())
+                    .write_u32(offset, x);
+            }
+            Val::AnyRef(x) => {
+                let x = match x {
+                    None => 0,
+                    Some(x) => x.try_clone_gc_ref(store)?.as_raw_u32(),
+                };
+                store
+                    .gc_store_mut()?
+                    .gc_object_data(self.as_gc_ref())
+                    .write_u32(offset, x);
+            }
+
+            Val::FuncRef(_) => {
+                // TODO: we can't trust the GC heap, which means we can't read
+                // native VMFuncRef pointers out of it and trust them. That
+                // means we need to do the same side table kind of thing we do
+                // with `externref` host data here. This isn't implemented yet.
+                todo!("funcrefs in GC objects")
+            }
+        }
+        Ok(())
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/gc/enabled/data.rs b/crates/wasmtime/src/runtime/vm/gc/enabled/data.rs
new file mode 100644
index 000000000000..c806fbb4f814
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/gc/enabled/data.rs
@@ -0,0 +1,149 @@
+//! Unchecked methods for working with the data inside GC objects.
+
+use crate::V128;
+use core::mem;
+
+/// A plain-old-data type that can be stored in a `ValType` or a `StorageType`.
+///
+/// Safety: implementations must be POD and all bit patterns must be valid.
+pub trait PodValType<const SIZE: usize>: Copy {
+    /// Read an instance of `Self` from the given little-endian bytes.
+    fn read_le(le_bytes: &[u8; SIZE]) -> Self;
+
+    /// Write `self` into the given memory location, as little-endian bytes.
+    fn write_le(&self, into: &mut [u8; SIZE]);
+}
+
+macro_rules! impl_pod_val_type {
+    ( $( $t:ty , )* ) => {
+        $(
+            impl PodValType<{mem::size_of::<$t>()}> for $t {
+                fn read_le(le_bytes: &[u8; mem::size_of::<$t>()]) -> Self {
+                    <$t>::from_le_bytes(*le_bytes)
+                }
+                fn write_le(&self, into: &mut [u8; mem::size_of::<$t>()]) {
+                    *into = self.to_le_bytes();
+                }
+            }
+        )*
+    };
+}
+
+impl_pod_val_type! {
+    u8,
+    u16,
+    u32,
+    u64,
+    i8,
+    i16,
+    i32,
+    i64,
+}
+
+impl PodValType<{ mem::size_of::<V128>() }> for V128 {
+    fn read_le(le_bytes: &[u8; mem::size_of::<V128>()]) -> Self {
+        u128::from_le_bytes(*le_bytes).into()
+    }
+    fn write_le(&self, into: &mut [u8; mem::size_of::<V128>()]) {
+        *into = self.as_u128().to_le_bytes();
+    }
+}
+
+/// The backing storage for a GC-managed object.
+///
+/// Methods on this type do not, generally, check against things like type
+/// mismatches or that the given offset to read from even falls on a field
+/// boundary. Omitting these checks is memory safe, due to our untrusted,
+/// indexed GC heaps. Providing incorrect offsets will result in general
+/// incorrectness, such as wrong answers or even panics, however.
+///
+/// Finally, these methods *will* panic on out-of-bounds accesses, either out of
+/// the GC heap's bounds or out of this object's bounds. The former is necessary
+/// for preserving the memory safety of indexed GC heaps in the face of (for
+/// example) collector bugs, but the latter is just a defensive technique to
+/// catch bugs early and prevent action at a distance as much as possible.
+pub struct VMGcObjectDataMut<'a> {
+    data: &'a mut [u8],
+}
+
+macro_rules! impl_pod_methods {
+    ( $( $t:ty, $read:ident, $write:ident; )* ) => {
+        $(
+            /// Read a `
+            #[doc = stringify!($t)]
+            /// ` field this object.
+            ///
+            /// Panics on out-of-bounds accesses.
+            #[inline]
+            pub fn $read(&self, offset: u32) -> $t {
+                self.read_pod::<{ mem::size_of::<$t>() }, $t>(offset)
+            }
+
+            /// Write a `
+            #[doc = stringify!($t)]
+            /// ` into this object.
+            ///
+            /// Panics on out-of-bounds accesses.
+            #[inline]
+            pub fn $write(&mut self, offset: u32, val: $t) {
+                self.write_pod::<{ mem::size_of::<$t>() }, $t>(offset, val);
+            }
+        )*
+    };
+}
+
+impl<'a> VMGcObjectDataMut<'a> {
+    /// Construct a `VMStructDataMut` from the given slice of bytes.
+    #[inline]
+    pub fn new(data: &'a mut [u8]) -> Self {
+        Self { data }
+    }
+
+    /// Read a POD field out of this object.
+    ///
+    /// Panics on out-of-bounds accesses.
+    ///
+    /// Don't generally use this method, use `read_u8`, `read_i64`,
+    /// etc... instead.
+    #[inline]
+    fn read_pod<const N: usize, T>(&self, offset: u32) -> T
+    where
+        T: PodValType<N>,
+    {
+        assert_eq!(N, mem::size_of::<T>());
+        let offset = usize::try_from(offset).unwrap();
+        let end = offset.checked_add(N).unwrap();
+        let bytes = self.data.get(offset..end).expect("out of bounds field");
+        T::read_le(bytes.try_into().unwrap())
+    }
+
+    /// Read a POD field out of this object.
+    ///
+    /// Panics on out-of-bounds accesses.
+    ///
+    /// Don't generally use this method, use `write_u8`, `write_i64`,
+    /// etc... instead.
+    #[inline]
+    fn write_pod<const N: usize, T>(&mut self, offset: u32, val: T)
+    where
+        T: PodValType<N>,
+    {
+        assert_eq!(N, mem::size_of::<T>());
+        let offset = usize::try_from(offset).unwrap();
+        let end = offset.checked_add(N).unwrap();
+        let into = self.data.get_mut(offset..end).expect("out of bounds field");
+        val.write_le(into.try_into().unwrap());
+    }
+
+    impl_pod_methods! {
+        u8, read_u8, write_u8;
+        u16, read_u16, write_u16;
+        u32, read_u32, write_u32;
+        u64, read_u64, write_u64;
+        i8, read_i8, write_i8;
+        i16, read_i16, write_i16;
+        i32, read_i32, write_i32;
+        i64, read_i64, write_i64;
+        V128, read_v128, write_v128;
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/gc/enabled/drc.rs b/crates/wasmtime/src/runtime/vm/gc/enabled/drc.rs
new file mode 100644
index 000000000000..abc1a799bf4f
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/gc/enabled/drc.rs
@@ -0,0 +1,1163 @@
+//! The deferred reference-counting (DRC) collector.
+//!
+//! Warning: this ref-counting collector does not have a tracing cycle
+//! collector, and therefore cannot collect cycles between GC objects!
+//!
+//! For host VM code, we use plain reference counting, where cloning increments
+//! the reference count, and dropping decrements it. We can avoid many of the
+//! on-stack increment/decrement operations that typically plague the
+//! performance of reference counting via Rust's ownership and borrowing system.
+//! Moving a `VMGcRef` avoids mutating its reference count, and borrowing it
+//! either avoids the reference count increment or delays it until if/when the
+//! `VMGcRef` is cloned.
+//!
+//! When passing a `VMGcRef` into compiled Wasm code, we don't want to do
+//! reference count mutations for every compiled `local.{get,set}`, nor for
+//! every function call. Therefore, we use a variation of **deferred reference
+//! counting**, where we only mutate reference counts when storing `VMGcRef`s
+//! somewhere that outlives the Wasm activation: into a global or
+//! table. Simultaneously, we over-approximate the set of `VMGcRef`s that are
+//! inside Wasm function activations. Periodically, we walk the stack at GC safe
+//! points, and use stack map information to precisely identify the set of
+//! `VMGcRef`s inside Wasm activations. Then we take the difference between this
+//! precise set and our over-approximation, and decrement the reference count
+//! for each of the `VMGcRef`s that are in our over-approximation but not in the
+//! precise set. Finally, the over-approximation is replaced with the precise
+//! set.
+//!
+//! The `VMGcRefActivationsTable` implements the over-approximized set of
+//! `VMGcRef`s referenced by Wasm activations. Calling a Wasm function and
+//! passing it a `VMGcRef` moves the `VMGcRef` into the table, and the compiled
+//! Wasm function logically "borrows" the `VMGcRef` from the table. Similarly,
+//! `global.get` and `table.get` operations clone the gotten `VMGcRef` into the
+//! `VMGcRefActivationsTable` and then "borrow" the reference out of the table.
+//!
+//! When a `VMGcRef` is returned to host code from a Wasm function, the host
+//! increments the reference count (because the reference is logically
+//! "borrowed" from the `VMGcRefActivationsTable` and the reference count from
+//! the table will be dropped at the next GC).
+//!
+//! For more general information on deferred reference counting, see *An
+//! Examination of Deferred Reference Counting and Cycle Detection* by Quinane:
+//! <https://openresearch-repository.anu.edu.au/bitstream/1885/42030/2/hon-thesis.pdf>
+
+use super::free_list::FreeList;
+use super::{VMArrayRef, VMGcObjectDataMut, VMStructRef};
+use crate::prelude::*;
+use crate::runtime::vm::{
+    ExternRefHostDataId, ExternRefHostDataTable, GarbageCollection, GcArrayLayout, GcHeap,
+    GcHeapObject, GcProgress, GcRootsIter, GcRuntime, GcStructLayout, Mmap, TypedGcRef,
+    VMExternRef, VMGcHeader, VMGcRef,
+};
+use core::ops::{Deref, DerefMut};
+use core::{
+    alloc::Layout,
+    any::Any,
+    cell::UnsafeCell,
+    mem,
+    num::NonZeroUsize,
+    ptr::{self, NonNull},
+};
+use hashbrown::HashSet;
+use wasmtime_environ::{VMGcKind, VMSharedTypeIndex, WasmStorageType, WasmValType};
+
+/// The deferred reference-counting (DRC) collector.
+///
+/// This reference-counting collector does not have a cycle collector, and so it
+/// will not be able to reclaim garbage cycles.
+///
+/// This is not a moving collector; it doesn't have a nursery or do any
+/// compaction.
+pub struct DrcCollector;
+
+/// Align `offset` up to `bytes`, updating `max_align` if `align` is the
+/// new maximum alignment, and returning the aligned offset.
+fn align_up(offset: &mut u32, max_align: &mut u32, align: u32) -> u32 {
+    debug_assert!(max_align.is_power_of_two());
+    debug_assert!(align.is_power_of_two());
+    *offset = offset.checked_add(align - 1).unwrap() & !(align - 1);
+    *max_align = core::cmp::max(*max_align, align);
+    *offset
+}
+
+/// Define a new field of size and alignment `bytes`, updating the object's
+/// total `size` and `align` as necessary. The offset of the new field is
+/// returned.
+fn field(size: &mut u32, align: &mut u32, bytes: u32) -> u32 {
+    let offset = align_up(size, align, bytes);
+    *size += bytes;
+    offset
+}
+
+fn size_of_wasm_ty(ty: &WasmStorageType) -> u32 {
+    match ty {
+        WasmStorageType::I8 => 1,
+        WasmStorageType::I16 => 2,
+        WasmStorageType::Val(ty) => match ty {
+            WasmValType::I32 | WasmValType::F32 | WasmValType::Ref(_) => 4,
+            WasmValType::I64 | WasmValType::F64 => 8,
+            WasmValType::V128 => 16,
+        },
+    }
+}
+
+unsafe impl GcRuntime for DrcCollector {
+    fn new_gc_heap(&self) -> Result<Box<dyn GcHeap>> {
+        let heap = DrcHeap::new()?;
+        Ok(Box::new(heap) as _)
+    }
+
+    fn array_layout(&self, ty: &wasmtime_environ::WasmArrayType) -> GcArrayLayout {
+        let mut size = VMDrcHeader::HEADER_SIZE;
+        let mut align = VMDrcHeader::HEADER_ALIGN;
+        let length_field_offset = field(&mut size, &mut align, 4);
+        debug_assert_eq!(
+            length_field_offset,
+            u32::try_from(core::mem::offset_of!(VMDrcArrayHeader, length)).unwrap(),
+        );
+        let elem_size = size_of_wasm_ty(&ty.0.element_type);
+        let elems_offset = align_up(&mut size, &mut align, elem_size);
+        GcArrayLayout {
+            size,
+            align,
+            length_field_offset,
+            elems_offset,
+            elem_size,
+        }
+    }
+
+    fn struct_layout(&self, ty: &wasmtime_environ::WasmStructType) -> GcStructLayout {
+        // Process each field, aligning it to its natural alignment.
+        //
+        // We don't try and do any fancy field reordering to minimize padding
+        // (yet?) because (a) the toolchain probably already did that and (b)
+        // we're just doing the simple thing first. We can come back and improve
+        // things here if we find that (a) isn't actually holding true in
+        // practice.
+        let mut size = VMDrcHeader::HEADER_SIZE;
+        let mut align = VMDrcHeader::HEADER_ALIGN;
+        let fields = ty
+            .fields
+            .iter()
+            .map(|f| {
+                let field_size = size_of_wasm_ty(&f.element_type);
+                field(&mut size, &mut align, field_size)
+            })
+            .collect();
+
+        // Ensure that the final size is a multiple of the alignment, for
+        // simplicity.
+        align_up(&mut size, &mut 16, align);
+
+        GcStructLayout {
+            size,
+            align,
+            fields,
+        }
+    }
+}
+
+/// A deferred reference-counting (DRC) heap.
+struct DrcHeap {
+    no_gc_count: u64,
+    // NB: this box shouldn't be strictly necessary, but it makes upholding the
+    // safety invariants of the `vmctx_gc_heap_data` more obviously correct.
+    activations_table: Box<VMGcRefActivationsTable>,
+    heap: Mmap,
+    free_list: FreeList,
+}
+
+impl DrcHeap {
+    /// Construct a new, default DRC heap.
+    fn new() -> Result<Self> {
+        Self::with_capacity(super::DEFAULT_GC_HEAP_CAPACITY)
+    }
+
+    /// Create a new DRC heap with the given capacity.
+    fn with_capacity(capacity: usize) -> Result<Self> {
+        let heap = Mmap::with_at_least(capacity)?;
+        let free_list = FreeList::new(heap.len());
+        Ok(Self {
+            no_gc_count: 0,
+            activations_table: Box::new(VMGcRefActivationsTable::default()),
+            heap,
+            free_list,
+        })
+    }
+
+    fn heap_slice(&self) -> &[UnsafeCell<u8>] {
+        let ptr = self.heap.as_ptr().cast::<UnsafeCell<u8>>();
+        let len = self.heap.len();
+        unsafe { core::slice::from_raw_parts(ptr, len) }
+    }
+
+    fn heap_slice_mut(&mut self) -> &mut [u8] {
+        let ptr = self.heap.as_mut_ptr();
+        let len = self.heap.len();
+        unsafe { core::slice::from_raw_parts_mut(ptr, len) }
+    }
+
+    /// Allocate a blank GC object.
+    ///
+    /// The given layout must include the `VMDrcHeader`.
+    ///
+    /// The resulting GC reference has its header initialized, but everything
+    /// else uninitialized.
+    fn alloc(&mut self, mut header: VMGcHeader, layout: Layout) -> Result<Option<VMGcRef>> {
+        let gc_ref = match self.free_list.alloc(layout)? {
+            None => return Ok(None),
+            Some(index) => VMGcRef::from_heap_index(index).unwrap(),
+        };
+
+        debug_assert_eq!(header.reserved_u26(), 0);
+        header.set_reserved_u26(u32::try_from(layout.size()).unwrap());
+
+        *self.index_mut(drc_ref(&gc_ref)) = VMDrcHeader {
+            header,
+            ref_count: UnsafeCell::new(1),
+        };
+        log::trace!("increment {gc_ref:#p} ref count -> 1");
+        Ok(Some(gc_ref))
+    }
+
+    fn dealloc(&mut self, gc_ref: VMGcRef) {
+        let drc_ref = drc_ref(&gc_ref);
+        let size = self.index(drc_ref).object_size();
+        let layout = FreeList::layout(size);
+        self.free_list
+            .dealloc(gc_ref.as_heap_index().unwrap(), layout);
+    }
+
+    /// Index into this heap and get a shared reference to the `T` that `gc_ref`
+    /// points to.
+    ///
+    /// # Panics
+    ///
+    /// Panics on out of bounds or if the `gc_ref` is an `i31ref`.
+    fn index<T>(&self, gc_ref: &TypedGcRef<T>) -> &T
+    where
+        T: GcHeapObject,
+    {
+        assert!(!mem::needs_drop::<T>());
+        let gc_ref = gc_ref.as_untyped();
+        let start = gc_ref.as_heap_index().unwrap().get();
+        let start = usize::try_from(start).unwrap();
+        let len = mem::size_of::<T>();
+        let slice = &self.heap_slice()[start..][..len];
+        unsafe { &*(slice.as_ptr().cast::<T>()) }
+    }
+
+    /// Index into this heap and get an exclusive reference to the `T` that
+    /// `gc_ref` points to.
+    ///
+    /// # Panics
+    ///
+    /// Panics on out of bounds or if the `gc_ref` is an `i31ref`.
+    fn index_mut<T>(&mut self, gc_ref: &TypedGcRef<T>) -> &mut T
+    where
+        T: GcHeapObject,
+    {
+        assert!(!mem::needs_drop::<T>());
+        let gc_ref = gc_ref.as_untyped();
+        let start = gc_ref.as_heap_index().unwrap().get();
+        let start = usize::try_from(start).unwrap();
+        let len = mem::size_of::<T>();
+        let slice = &mut self.heap_slice_mut()[start..][..len];
+        unsafe { &mut *(slice.as_mut_ptr().cast::<T>()) }
+    }
+
+    /// Increment the ref count for the associated object.
+    fn inc_ref(&mut self, gc_ref: &VMGcRef) {
+        if gc_ref.is_i31() {
+            return;
+        }
+
+        let drc_ref = drc_ref(gc_ref);
+        let header = self.index_mut(&drc_ref);
+        debug_assert_ne!(
+            *header.ref_count.get_mut(),
+            0,
+            "{:#p} is supposedly live; should have nonzero ref count",
+            *gc_ref
+        );
+        *header.ref_count.get_mut() += 1;
+        log::trace!(
+            "increment {:#p} ref count -> {}",
+            *gc_ref,
+            header.ref_count.get_mut()
+        );
+    }
+
+    /// Decrement the ref count for the associated object.
+    ///
+    /// Returns `true` if the ref count reached zero and the object should be
+    /// deallocated.
+    fn dec_ref(&mut self, gc_ref: &VMGcRef) -> bool {
+        if gc_ref.is_i31() {
+            return false;
+        }
+
+        let drc_ref = drc_ref(gc_ref);
+        let header = self.index_mut(drc_ref);
+        debug_assert_ne!(
+            *header.ref_count.get_mut(),
+            0,
+            "{:#p} is supposedly live; should have nonzero ref count",
+            *gc_ref
+        );
+        *header.ref_count.get_mut() -= 1;
+        log::trace!(
+            "decrement {:#p} ref count -> {}",
+            *gc_ref,
+            header.ref_count.get_mut()
+        );
+        *header.ref_count.get_mut() == 0
+    }
+
+    /// Decrement the ref count for the associated object.
+    ///
+    /// If the ref count reached zero, then deallocate the object and remove its
+    /// associated entry from the `host_data_table` if necessary.
+    fn dec_ref_and_maybe_dealloc(
+        &mut self,
+        host_data_table: &mut ExternRefHostDataTable,
+        gc_ref: &VMGcRef,
+    ) {
+        if self.dec_ref(gc_ref) {
+            // If this was an `externref`, remove its associated entry from
+            // the host data table.
+            if let Some(externref) = gc_ref.as_typed::<VMDrcExternRef>(self) {
+                let host_data_id = self.index(externref).host_data;
+                host_data_table.dealloc(host_data_id);
+            }
+
+            // TODO: `dec_ref_and_maybe_dealloc` each `VMGcRef` inside this
+            // object.
+
+            // Deallocate this GC object.
+            self.dealloc(gc_ref.unchecked_copy());
+        }
+    }
+
+    fn trace(&mut self, roots: &mut GcRootsIter<'_>) {
+        debug_assert!({
+            // This set is only non-empty during collection. It is built up when
+            // tracing roots, and then drained back into the activations table's
+            // bump-allocated space at the end. Therefore, it should always be
+            // empty upon beginning tracing, which is the start of collection.
+            self.activations_table.precise_stack_roots.is_empty()
+        });
+
+        // The `activations_table_set` is used for `debug_assert!`s checking that
+        // every reference we read out from the stack via stack maps is actually in
+        // the table. If that weren't true, than either we forgot to insert a
+        // reference in the table when passing it into Wasm (a bug) or we are
+        // reading invalid references from the stack (another bug).
+        let mut activations_table_set: DebugOnly<HashSet<_>> = Default::default();
+        if cfg!(debug_assertions) {
+            self.activations_table.elements(|elem| {
+                activations_table_set.insert(elem.unchecked_copy());
+            });
+        }
+
+        for root in roots {
+            if !root.is_on_wasm_stack() {
+                // We only trace on-Wasm-stack GC roots. These are the
+                // GC references that we do deferred ref counting for
+                // and that get inserted into our activations
+                // table. Other GC roots are managed purely with naive
+                // ref counting.
+                continue;
+            }
+
+            let gc_ref = root.get();
+            debug_assert!(
+                gc_ref.is_i31() || activations_table_set.contains(&gc_ref),
+                "every on-stack gc_ref inside a Wasm frame should \
+                 have an entry in the VMGcRefActivationsTable; \
+                 {gc_ref:#p} is not in the table",
+            );
+            if gc_ref.is_i31() {
+                continue;
+            }
+
+            debug_assert_ne!(
+                *self.index_mut(drc_ref(&gc_ref)).ref_count.get_mut(),
+                0,
+                "{gc_ref:#p} is on the Wasm stack and therefore should be held \
+                 by the activations table; should have nonzero ref count",
+            );
+
+            log::trace!("Found GC reference on the stack: {:#p}", gc_ref);
+            let is_new = self
+                .activations_table
+                .precise_stack_roots
+                .insert(gc_ref.unchecked_copy());
+            if is_new {
+                self.inc_ref(&gc_ref);
+            }
+        }
+    }
+
+    fn iter_bump_chunk(&mut self) -> impl Iterator<Item = VMGcRef> + '_ {
+        let num_filled = self.activations_table.num_filled_in_bump_chunk();
+        self.activations_table
+            .alloc
+            .chunk
+            .iter_mut()
+            .take(num_filled)
+            .map(|slot| {
+                let raw = *slot.get_mut();
+                VMGcRef::from_raw_u32(raw).expect("non-null")
+            })
+    }
+
+    #[inline(never)]
+    #[cold]
+    fn log_gc_ref_set(prefix: &str, items: impl Iterator<Item = VMGcRef>) {
+        assert!(log::log_enabled!(log::Level::Trace));
+        let mut set = "{".to_string();
+        let mut any = false;
+        for gc_ref in items {
+            any = true;
+            set += &format!("\n  {gc_ref:#p},");
+        }
+        if any {
+            set.push('\n');
+        }
+        set.push('}');
+        log::trace!("{prefix}: {set}");
+    }
+
+    fn drain_bump_chunk(&mut self, mut f: impl FnMut(&mut Self, VMGcRef)) {
+        let num_filled = self.activations_table.num_filled_in_bump_chunk();
+
+        // Temporarily take the allocation out of `self` to avoid conflicting
+        // borrows.
+        let mut alloc = mem::take(&mut self.activations_table.alloc);
+        for slot in alloc.chunk.iter_mut().take(num_filled) {
+            let raw = mem::take(slot.get_mut());
+            let gc_ref = VMGcRef::from_raw_u32(raw).expect("non-null");
+            f(self, gc_ref);
+            *slot.get_mut() = 0;
+        }
+
+        debug_assert!(
+            alloc.chunk.iter_mut().all(|slot| *slot.get_mut() == 0),
+            "after sweeping the bump chunk, all slots should be empty",
+        );
+
+        debug_assert!(self.activations_table.alloc.chunk.is_empty());
+        self.activations_table.alloc = alloc;
+    }
+
+    /// Sweep the bump allocation table after we've discovered our precise stack
+    /// roots.
+    fn sweep(&mut self, host_data_table: &mut ExternRefHostDataTable) {
+        if log::log_enabled!(log::Level::Trace) {
+            Self::log_gc_ref_set("bump chunk before sweeping", self.iter_bump_chunk());
+        }
+
+        // Sweep our bump chunk.
+        log::trace!("Begin sweeping bump chunk");
+        self.drain_bump_chunk(|heap, gc_ref| {
+            heap.dec_ref_and_maybe_dealloc(host_data_table, &gc_ref);
+        });
+        log::trace!("Done sweeping bump chunk");
+
+        if self.activations_table.alloc.chunk.is_empty() {
+            // If this is the first collection, then the bump chunk is empty
+            // since we lazily allocate it. Force that lazy allocation now so we
+            // have fast bump-allocation in the future.
+            self.activations_table.alloc.force_allocation();
+        } else {
+            // Reset our `next` finger to the start of the bump allocation chunk.
+            self.activations_table.alloc.reset();
+        }
+
+        if log::log_enabled!(log::Level::Trace) {
+            Self::log_gc_ref_set(
+                "hash set before sweeping",
+                self.activations_table
+                    .over_approximated_stack_roots
+                    .iter()
+                    .map(|r| r.unchecked_copy()),
+            );
+        }
+
+        // The current `precise_stack_roots` becomes our new over-appoximated
+        // set for the next GC cycle.
+        mem::swap(
+            &mut self.activations_table.precise_stack_roots,
+            &mut self.activations_table.over_approximated_stack_roots,
+        );
+
+        // And finally, the new `precise_stack_roots` should be cleared and
+        // remain empty until the next GC cycle.
+        //
+        // Note that this may run arbitrary code as we run gc_ref
+        // destructors. Because of our `&mut` borrow above on this table,
+        // though, we're guaranteed that nothing will touch this table.
+        log::trace!("Begin sweeping hash set");
+        let mut precise_stack_roots = mem::take(&mut self.activations_table.precise_stack_roots);
+        for gc_ref in precise_stack_roots.drain() {
+            self.dec_ref_and_maybe_dealloc(host_data_table, &gc_ref);
+        }
+        log::trace!("Done sweeping hash set");
+
+        // Make sure to replace the `precise_stack_roots` so that we reuse any
+        // allocated capacity.
+        self.activations_table.precise_stack_roots = precise_stack_roots;
+
+        if log::log_enabled!(log::Level::Trace) {
+            Self::log_gc_ref_set(
+                "hash set after sweeping",
+                self.activations_table
+                    .over_approximated_stack_roots
+                    .iter()
+                    .map(|r| r.unchecked_copy()),
+            );
+        }
+    }
+}
+
+/// Convert the given GC reference as a typed GC reference pointing to a
+/// `VMDrcHeader`.
+fn drc_ref(gc_ref: &VMGcRef) -> &TypedGcRef<VMDrcHeader> {
+    debug_assert!(!gc_ref.is_i31());
+    gc_ref.as_typed_unchecked()
+}
+
+/// Convert a generic `externref` to a typed reference to our concrete
+/// `externref` type.
+fn externref_to_drc(externref: &VMExternRef) -> &TypedGcRef<VMDrcExternRef> {
+    let gc_ref = externref.as_gc_ref();
+    debug_assert!(!gc_ref.is_i31());
+    gc_ref.as_typed_unchecked()
+}
+
+/// The common header for all objects in the DRC collector.
+///
+/// This adds a ref count on top collector-agnostic `VMGcHeader`.
+///
+/// This is accessed by JIT code.
+#[repr(C)]
+struct VMDrcHeader {
+    header: VMGcHeader,
+    ref_count: UnsafeCell<u64>,
+}
+
+// Although this contains an `UnsafeCell`, that is just for allowing the field
+// to be written to by JIT code, and it is only read/modified when we have
+// access to an appropriate borrow of the heap.
+unsafe impl Send for VMDrcHeader {}
+unsafe impl Sync for VMDrcHeader {}
+
+unsafe impl GcHeapObject for VMDrcHeader {
+    #[inline]
+    fn is(_header: &VMGcHeader) -> bool {
+        // All DRC objects have a DRC header.
+        true
+    }
+}
+
+const _: () = {
+    assert!((VMDrcHeader::HEADER_SIZE as usize) == core::mem::size_of::<VMDrcHeader>());
+    assert!((VMDrcHeader::HEADER_ALIGN as usize) == core::mem::align_of::<VMDrcHeader>());
+};
+
+impl VMDrcHeader {
+    /// The size of `VMDrcHeader` on *all* architectures.
+    const HEADER_SIZE: u32 = VMGcHeader::HEADER_SIZE + 8;
+
+    /// The alignment of `VMDrcHeader` on *all* architectures.
+    const HEADER_ALIGN: u32 = 8;
+
+    /// The size of this header's object.
+    ///
+    /// This is stored in the inner `VMGcHeader`'s reserved bits.
+    fn object_size(&self) -> usize {
+        let size = self.header.reserved_u26();
+        usize::try_from(size).unwrap()
+    }
+}
+
+/// The common header for all arrays in the DRC collector.
+#[repr(C)]
+struct VMDrcArrayHeader {
+    header: VMDrcHeader,
+    length: u32,
+}
+
+unsafe impl GcHeapObject for VMDrcArrayHeader {
+    #[inline]
+    fn is(header: &VMGcHeader) -> bool {
+        header.kind() == VMGcKind::ArrayRef
+    }
+}
+
+/// The representation of an `externref` in the DRC collector.
+#[repr(C)]
+struct VMDrcExternRef {
+    header: VMDrcHeader,
+    host_data: ExternRefHostDataId,
+}
+
+unsafe impl GcHeapObject for VMDrcExternRef {
+    #[inline]
+    fn is(header: &VMGcHeader) -> bool {
+        header.kind() == VMGcKind::ExternRef
+    }
+}
+
+unsafe impl GcHeap for DrcHeap {
+    fn as_any(&self) -> &dyn Any {
+        self as _
+    }
+
+    fn as_any_mut(&mut self) -> &mut dyn Any {
+        self as _
+    }
+
+    fn enter_no_gc_scope(&mut self) {
+        self.no_gc_count += 1;
+    }
+
+    fn exit_no_gc_scope(&mut self) {
+        self.no_gc_count -= 1;
+    }
+
+    fn header(&self, gc_ref: &VMGcRef) -> &VMGcHeader {
+        self.index(gc_ref.as_typed_unchecked())
+    }
+
+    fn clone_gc_ref(&mut self, gc_ref: &VMGcRef) -> VMGcRef {
+        self.inc_ref(gc_ref);
+        gc_ref.unchecked_copy()
+    }
+
+    fn write_gc_ref(
+        &mut self,
+        host_data_table: &mut ExternRefHostDataTable,
+        destination: &mut Option<VMGcRef>,
+        source: Option<&VMGcRef>,
+    ) {
+        // Increment the ref count of the object being written into the slot.
+        if let Some(src) = source {
+            self.inc_ref(src);
+        }
+
+        // Decrement the ref count of the value being overwritten and, if
+        // necessary, deallocate the GC object.
+        if let Some(dest) = destination {
+            self.dec_ref_and_maybe_dealloc(host_data_table, dest);
+        }
+
+        // Do the actual write.
+        *destination = source.map(|s| s.unchecked_copy());
+    }
+
+    fn expose_gc_ref_to_wasm(&mut self, gc_ref: VMGcRef) {
+        // self.inc_ref(&gc_ref);
+        self.activations_table.insert_without_gc(gc_ref);
+    }
+
+    fn need_gc_before_entering_wasm(&self, num_gc_refs: NonZeroUsize) -> bool {
+        num_gc_refs.get() > self.activations_table.bump_capacity_remaining()
+    }
+
+    fn alloc_externref(&mut self, host_data: ExternRefHostDataId) -> Result<Option<VMExternRef>> {
+        let gc_ref = match self.alloc(VMGcHeader::externref(), Layout::new::<VMDrcExternRef>())? {
+            None => return Ok(None),
+            Some(gc_ref) => gc_ref,
+        };
+        self.index_mut::<VMDrcExternRef>(gc_ref.as_typed_unchecked())
+            .host_data = host_data;
+        Ok(Some(gc_ref.into_externref_unchecked()))
+    }
+
+    fn externref_host_data(&self, externref: &VMExternRef) -> ExternRefHostDataId {
+        let typed_ref = externref_to_drc(externref);
+        self.index(typed_ref).host_data
+    }
+
+    fn alloc_uninit_struct(
+        &mut self,
+        ty: VMSharedTypeIndex,
+        layout: &GcStructLayout,
+    ) -> Result<Option<VMStructRef>> {
+        let layout = Layout::from_size_align(
+            usize::try_from(layout.size).unwrap(),
+            usize::try_from(layout.align).unwrap(),
+        )
+        .unwrap();
+        let gc_ref = match self.alloc(
+            VMGcHeader::from_kind_and_index(VMGcKind::StructRef, ty),
+            layout,
+        )? {
+            None => return Ok(None),
+            Some(gc_ref) => gc_ref,
+        };
+        Ok(Some(gc_ref.into_structref_unchecked()))
+    }
+
+    fn dealloc_uninit_struct(&mut self, structref: VMStructRef) {
+        self.dealloc(structref.into());
+    }
+
+    fn gc_object_data(&mut self, gc_ref: &VMGcRef) -> VMGcObjectDataMut<'_> {
+        let start = gc_ref.as_heap_index().unwrap().get();
+        let start = usize::try_from(start).unwrap();
+        let size = self
+            .index::<VMDrcHeader>(gc_ref.as_typed_unchecked())
+            .object_size();
+        let end = start + size;
+        let data = &mut self.heap_slice_mut()[start..end];
+        VMGcObjectDataMut::new(data)
+    }
+
+    fn alloc_uninit_array(
+        &mut self,
+        ty: VMSharedTypeIndex,
+        length: u32,
+        layout: &GcArrayLayout,
+    ) -> Result<Option<VMArrayRef>> {
+        let size = usize::try_from(layout.size_for_len(length)).unwrap();
+        let align = usize::try_from(layout.align).unwrap();
+        let layout = Layout::from_size_align(size, align).unwrap();
+        let gc_ref = match self.alloc(
+            VMGcHeader::from_kind_and_index(VMGcKind::ArrayRef, ty),
+            layout,
+        )? {
+            None => return Ok(None),
+            Some(gc_ref) => gc_ref,
+        };
+        self.index_mut::<VMDrcArrayHeader>(gc_ref.as_typed_unchecked())
+            .length = length;
+        Ok(Some(gc_ref.into_arrayref_unchecked()))
+    }
+
+    fn dealloc_uninit_array(&mut self, arrayref: VMArrayRef) {
+        self.dealloc(arrayref.into())
+    }
+
+    fn array_len(&self, arrayref: &VMArrayRef) -> u32 {
+        debug_assert!(arrayref.as_gc_ref().is_typed::<VMDrcArrayHeader>(self));
+        self.index::<VMDrcArrayHeader>(arrayref.as_gc_ref().as_typed_unchecked())
+            .length
+    }
+
+    fn gc<'a>(
+        &'a mut self,
+        roots: GcRootsIter<'a>,
+        host_data_table: &'a mut ExternRefHostDataTable,
+    ) -> Box<dyn GarbageCollection<'a> + 'a> {
+        assert_eq!(self.no_gc_count, 0, "Cannot GC inside a no-GC scope!");
+        Box::new(DrcCollection {
+            roots,
+            host_data_table,
+            heap: self,
+            phase: DrcCollectionPhase::Trace,
+        })
+    }
+
+    unsafe fn vmctx_gc_heap_base(&self) -> *mut u8 {
+        self.heap.as_ptr().cast_mut()
+    }
+
+    unsafe fn vmctx_gc_heap_bound(&self) -> usize {
+        self.heap.len()
+    }
+
+    unsafe fn vmctx_gc_heap_data(&self) -> *mut u8 {
+        let ptr = &*self.activations_table as *const VMGcRefActivationsTable;
+        ptr.cast_mut().cast::<u8>()
+    }
+
+    #[cfg(feature = "pooling-allocator")]
+    fn reset(&mut self) {
+        let DrcHeap {
+            no_gc_count,
+            activations_table,
+            free_list,
+            heap: _,
+        } = self;
+
+        *no_gc_count = 0;
+        free_list.reset();
+        activations_table.reset();
+    }
+}
+
+struct DrcCollection<'a> {
+    roots: GcRootsIter<'a>,
+    host_data_table: &'a mut ExternRefHostDataTable,
+    heap: &'a mut DrcHeap,
+    phase: DrcCollectionPhase,
+}
+
+enum DrcCollectionPhase {
+    Trace,
+    Sweep,
+    Done,
+}
+
+impl<'a> GarbageCollection<'a> for DrcCollection<'a> {
+    fn collect_increment(&mut self) -> GcProgress {
+        match self.phase {
+            DrcCollectionPhase::Trace => {
+                log::trace!("Begin DRC trace");
+                self.heap.trace(&mut self.roots);
+                log::trace!("End DRC trace");
+                self.phase = DrcCollectionPhase::Sweep;
+                GcProgress::Continue
+            }
+            DrcCollectionPhase::Sweep => {
+                log::trace!("Begin DRC sweep");
+                self.heap.sweep(self.host_data_table);
+                log::trace!("End DRC sweep");
+                self.phase = DrcCollectionPhase::Done;
+                GcProgress::Complete
+            }
+            DrcCollectionPhase::Done => GcProgress::Complete,
+        }
+    }
+}
+
+/// The type of `VMGcRefActivationsTable`'s bump region's elements.
+///
+/// These are written to by Wasm.
+type TableElem = UnsafeCell<u32>;
+
+/// A table that over-approximizes the set of `VMGcRef`s that any Wasm
+/// activation on this thread is currently using.
+///
+/// Under the covers, this is a simple bump allocator that allows duplicate
+/// entries. Deduplication happens at GC time.
+//
+// `alloc` must be the first member, it's accessed from JIT code.
+#[repr(C)]
+struct VMGcRefActivationsTable {
+    /// Structures used to perform fast bump allocation of storage of externref
+    /// values.
+    ///
+    /// This is the only member of this structure accessed from JIT code.
+    alloc: VMGcRefTableAlloc,
+
+    /// When unioned with `chunk`, this is an over-approximation of the GC roots
+    /// on the stack, inside Wasm frames.
+    ///
+    /// This is used by slow-path insertion, and when a GC cycle finishes, is
+    /// re-initialized to the just-discovered precise set of stack roots (which
+    /// immediately becomes an over-approximation again as soon as Wasm runs and
+    /// potentially drops references).
+    over_approximated_stack_roots: HashSet<VMGcRef>,
+
+    /// The precise set of on-stack, inside-Wasm GC roots that we discover via
+    /// walking the stack and interpreting stack maps.
+    ///
+    /// This is *only* used inside the `gc` function, and is empty otherwise. It
+    /// is just part of this struct so that we can reuse the allocation, rather
+    /// than create a new hash set every GC.
+    precise_stack_roots: HashSet<VMGcRef>,
+}
+
+/// The chunk of memory that we bump-allocate into for the fast path of
+/// inserting into the `VMGcRefActivationsTable`.
+///
+/// This is accessed from compiled Wasm code.
+#[repr(C)]
+struct VMGcRefTableAlloc {
+    /// Bump-allocation finger within the `chunk`.
+    ///
+    /// NB: this is an `UnsafeCell` because it is written to by compiled Wasm
+    /// code.
+    next: UnsafeCell<NonNull<TableElem>>,
+
+    /// Pointer to just after the `chunk`.
+    ///
+    /// This is *not* within the current chunk and therefore is not a valid
+    /// place to insert a reference!
+    end: NonNull<TableElem>,
+
+    /// Bump allocation chunk that stores fast-path insertions.
+    ///
+    /// This is not accessed from JIT code.
+    chunk: Box<[TableElem]>,
+}
+
+impl Default for VMGcRefTableAlloc {
+    fn default() -> Self {
+        // Start with an empty chunk, just in case this activations table isn't
+        // ever used. This means that there's no space in the bump-allocation
+        // area which will force any path trying to use this to the slow GC
+        // path. The first time this happens, though, the slow GC path will
+        // allocate a new chunk for actual fast-bumping.
+        let mut chunk: Box<[TableElem]> = Box::new([]);
+        let next = chunk.as_mut_ptr();
+        let end = unsafe { next.add(chunk.len()) };
+        VMGcRefTableAlloc {
+            next: UnsafeCell::new(NonNull::new(next).unwrap()),
+            end: NonNull::new(end).unwrap(),
+            chunk,
+        }
+    }
+}
+
+impl VMGcRefTableAlloc {
+    /// Create a new, empty bump region.
+    const CHUNK_SIZE: usize = 4096 / mem::size_of::<TableElem>();
+
+    /// Force the lazy allocation of this bump region.
+    fn force_allocation(&mut self) {
+        assert!(self.chunk.is_empty());
+        self.chunk = (0..Self::CHUNK_SIZE).map(|_| UnsafeCell::new(0)).collect();
+        self.reset();
+    }
+
+    /// Reset this bump region, retaining any underlying allocation, but moving
+    /// the bump pointer and limit to their default positions.
+    fn reset(&mut self) {
+        self.next = UnsafeCell::new(NonNull::new(self.chunk.as_mut_ptr()).unwrap());
+        self.end = NonNull::new(unsafe { self.chunk.as_mut_ptr().add(self.chunk.len()) }).unwrap();
+    }
+}
+
+// This gets around the usage of `UnsafeCell` throughout the internals of this
+// allocator, but the storage should all be Send/Sync and synchronization isn't
+// necessary since operations require `&mut self`.
+unsafe impl Send for VMGcRefTableAlloc {}
+unsafe impl Sync for VMGcRefTableAlloc {}
+
+fn _assert_send_sync() {
+    fn _assert<T: Send + Sync>() {}
+    _assert::<VMGcRefActivationsTable>();
+}
+
+impl Default for VMGcRefActivationsTable {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl VMGcRefActivationsTable {
+    /// Create a new `VMGcRefActivationsTable`.
+    fn new() -> Self {
+        VMGcRefActivationsTable {
+            alloc: VMGcRefTableAlloc::default(),
+            over_approximated_stack_roots: HashSet::new(),
+            precise_stack_roots: HashSet::new(),
+        }
+    }
+
+    #[cfg(feature = "pooling-allocator")]
+    fn reset(&mut self) {
+        let VMGcRefActivationsTable {
+            alloc,
+            over_approximated_stack_roots,
+            precise_stack_roots,
+        } = self;
+
+        alloc.reset();
+        over_approximated_stack_roots.clear();
+        precise_stack_roots.clear();
+    }
+
+    /// Get the available capacity in the bump allocation chunk.
+    #[inline]
+    fn bump_capacity_remaining(&self) -> usize {
+        let end = self.alloc.end.as_ptr() as usize;
+        let next = unsafe { *self.alloc.next.get() };
+        end - next.as_ptr() as usize
+    }
+
+    /// Try and insert a `VMGcRef` into this table.
+    ///
+    /// This is a fast path that only succeeds when the bump chunk has the
+    /// capacity for the requested insertion.
+    ///
+    /// If the insertion fails, then the `VMGcRef` is given back. Callers
+    /// may attempt a GC to free up space and try again, or may call
+    /// `insert_slow_path` to infallibly insert the reference (potentially
+    /// allocating additional space in the table to hold it).
+    #[inline]
+    fn try_insert(&mut self, gc_ref: VMGcRef) -> Result<(), VMGcRef> {
+        unsafe {
+            let next = *self.alloc.next.get();
+            if next == self.alloc.end {
+                return Err(gc_ref);
+            }
+
+            debug_assert_eq!(
+                (*next.as_ref().get()),
+                0,
+                "slots >= the `next` bump finger are always `None`"
+            );
+            ptr::write(next.as_ptr(), UnsafeCell::new(gc_ref.as_raw_u32()));
+
+            let next = NonNull::new_unchecked(next.as_ptr().add(1));
+            debug_assert!(next <= self.alloc.end);
+            *self.alloc.next.get() = next;
+
+            Ok(())
+        }
+    }
+
+    /// Insert a reference into the table, without ever performing GC.
+    #[inline]
+    fn insert_without_gc(&mut self, gc_ref: VMGcRef) {
+        if let Err(gc_ref) = self.try_insert(gc_ref) {
+            self.insert_slow_without_gc(gc_ref);
+        }
+    }
+
+    #[inline(never)]
+    fn insert_slow_without_gc(&mut self, gc_ref: VMGcRef) {
+        self.over_approximated_stack_roots.insert(gc_ref);
+    }
+
+    fn num_filled_in_bump_chunk(&self) -> usize {
+        let next = unsafe { *self.alloc.next.get() };
+        let bytes_unused = (self.alloc.end.as_ptr() as usize) - (next.as_ptr() as usize);
+        let slots_unused = bytes_unused / mem::size_of::<TableElem>();
+        self.alloc.chunk.len().saturating_sub(slots_unused)
+    }
+
+    fn elements(&self, mut f: impl FnMut(&VMGcRef)) {
+        for elem in self.over_approximated_stack_roots.iter() {
+            f(elem);
+        }
+
+        // The bump chunk is not all the way full, so we only iterate over its
+        // filled-in slots.
+        let num_filled = self.num_filled_in_bump_chunk();
+        for slot in self.alloc.chunk.iter().take(num_filled) {
+            if let Some(elem) = VMGcRef::from_raw_u32(unsafe { *slot.get() }) {
+                f(&elem);
+            }
+        }
+    }
+}
+
+#[derive(Debug, Default)]
+struct DebugOnly<T> {
+    inner: T,
+}
+
+impl<T> Deref for DebugOnly<T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        if cfg!(debug_assertions) {
+            &self.inner
+        } else {
+            panic!(
+                "only deref `DebugOnly` when `cfg(debug_assertions)` or \
+                 inside a `debug_assert!(..)`"
+            )
+        }
+    }
+}
+
+impl<T> DerefMut for DebugOnly<T> {
+    fn deref_mut(&mut self) -> &mut T {
+        if cfg!(debug_assertions) {
+            &mut self.inner
+        } else {
+            panic!(
+                "only deref `DebugOnly` when `cfg(debug_assertions)` or \
+                 inside a `debug_assert!(..)`"
+            )
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn ref_count_is_at_correct_offset() {
+        let extern_data = VMDrcHeader {
+            header: VMGcHeader::externref(),
+            ref_count: UnsafeCell::new(0),
+        };
+
+        let extern_data_ptr = &extern_data as *const _;
+        let ref_count_ptr = &extern_data.ref_count as *const _;
+
+        let actual_offset = (ref_count_ptr as usize) - (extern_data_ptr as usize);
+
+        let offsets = wasmtime_environ::VMOffsets::from(wasmtime_environ::VMOffsetsFields {
+            ptr: 8,
+            num_imported_functions: 0,
+            num_imported_tables: 0,
+            num_imported_memories: 0,
+            num_imported_globals: 0,
+            num_defined_tables: 0,
+            num_defined_memories: 0,
+            num_owned_memories: 0,
+            num_defined_globals: 0,
+            num_escaped_funcs: 0,
+        });
+
+        assert_eq!(
+            offsets.vm_drc_header_ref_count(),
+            u32::try_from(actual_offset).unwrap(),
+        );
+    }
+
+    #[test]
+    fn table_next_is_at_correct_offset() {
+        let table = VMGcRefActivationsTable::new();
+
+        let table_ptr = &table as *const _;
+        let next_ptr = &table.alloc.next as *const _;
+
+        let actual_offset = (next_ptr as usize) - (table_ptr as usize);
+
+        let offsets = wasmtime_environ::VMOffsets::from(wasmtime_environ::VMOffsetsFields {
+            ptr: 8,
+            num_imported_functions: 0,
+            num_imported_tables: 0,
+            num_imported_memories: 0,
+            num_imported_globals: 0,
+            num_defined_tables: 0,
+            num_defined_memories: 0,
+            num_owned_memories: 0,
+            num_defined_globals: 0,
+            num_escaped_funcs: 0,
+        });
+        assert_eq!(
+            offsets.vm_gc_ref_activation_table_next() as usize,
+            actual_offset
+        );
+    }
+
+    #[test]
+    fn table_end_is_at_correct_offset() {
+        let table = VMGcRefActivationsTable::new();
+
+        let table_ptr = &table as *const _;
+        let end_ptr = &table.alloc.end as *const _;
+
+        let actual_offset = (end_ptr as usize) - (table_ptr as usize);
+
+        let offsets = wasmtime_environ::VMOffsets::from(wasmtime_environ::VMOffsetsFields {
+            ptr: 8,
+            num_imported_functions: 0,
+            num_imported_tables: 0,
+            num_imported_memories: 0,
+            num_imported_globals: 0,
+            num_defined_tables: 0,
+            num_defined_memories: 0,
+            num_owned_memories: 0,
+            num_defined_globals: 0,
+            num_escaped_funcs: 0,
+        });
+        assert_eq!(
+            offsets.vm_gc_ref_activation_table_end() as usize,
+            actual_offset
+        );
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/gc/enabled/externref.rs b/crates/wasmtime/src/runtime/vm/gc/enabled/externref.rs
new file mode 100644
index 000000000000..1c4622077830
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/gc/enabled/externref.rs
@@ -0,0 +1,116 @@
+use crate::runtime::vm::{GcHeap, GcStore, VMGcRef};
+use core::fmt;
+use wasmtime_environ::VMGcKind;
+
+/// A `VMGcRef` that we know points to an `externref`.
+///
+/// Create a `VMExternRef` via `VMGcRef::into_externref` and
+/// `VMGcRef::as_externref`, or their untyped equivalents
+/// `VMGcRef::into_externref_unchecked` and `VMGcRef::as_externref_unchecked`.
+///
+/// Note: This is not a `TypedGcRef<_>` because each collector can have a
+/// different concrete representation of `externref` that they allocate inside
+/// their heaps.
+#[derive(Debug, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct VMExternRef(VMGcRef);
+
+impl fmt::Pointer for VMExternRef {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Pointer::fmt(&self.0, f)
+    }
+}
+
+impl From<VMExternRef> for VMGcRef {
+    #[inline]
+    fn from(x: VMExternRef) -> Self {
+        x.0
+    }
+}
+
+impl VMGcRef {
+    /// Create a new `VMExternRef` from the given `gc_ref`.
+    ///
+    /// If this is not GC reference to an `externref`, `Err(self)` is returned.
+    pub fn into_externref(self, gc_heap: &impl GcHeap) -> Result<VMExternRef, VMGcRef> {
+        if self.is_i31() {
+            return Err(self);
+        }
+        if gc_heap.header(&self).kind() == VMGcKind::ExternRef {
+            Ok(VMExternRef(self))
+        } else {
+            Err(self)
+        }
+    }
+
+    /// Create a new `VMExternRef` from `self` without actually checking that
+    /// `self` is an `externref`.
+    ///
+    /// This method does not check that `self` is actually an `externref`, but
+    /// it should be. Failure to uphold this invariant is memory safe but will
+    /// result in general incorrectness down the line such as panics or wrong
+    /// results.
+    #[inline]
+    pub fn into_externref_unchecked(self) -> VMExternRef {
+        debug_assert!(!self.is_i31());
+        VMExternRef(self)
+    }
+
+    /// Get this GC reference as an `externref` reference, if it actually is an
+    /// `externref` reference.
+    pub fn as_externref(&self, gc_heap: &impl GcHeap) -> Option<&VMExternRef> {
+        if self.is_i31() {
+            return None;
+        }
+        if gc_heap.header(&self).kind() == VMGcKind::ExternRef {
+            let ptr = self as *const VMGcRef;
+            let ret = unsafe { &*ptr.cast() };
+            assert!(matches!(ret, VMExternRef(VMGcRef { .. })));
+            Some(ret)
+        } else {
+            None
+        }
+    }
+
+    /// Get this GC reference as an `externref` reference without checking if it
+    /// actually is an `externref` reference.
+    ///
+    /// Calling this method on a non-`externref` reference is memory safe, but
+    /// will lead to general incorrectness like panics and wrong results.
+    pub fn as_externref_unchecked(&self) -> &VMExternRef {
+        debug_assert!(!self.is_i31());
+        let ptr = self as *const VMGcRef;
+        let ret = unsafe { &*ptr.cast() };
+        assert!(matches!(ret, VMExternRef(VMGcRef { .. })));
+        ret
+    }
+}
+
+impl VMExternRef {
+    /// Get the underlying `VMGcRef`.
+    pub fn as_gc_ref(&self) -> &VMGcRef {
+        &self.0
+    }
+
+    /// Clone this `VMExternRef`, running any GC barriers as necessary.
+    pub fn clone(&self, gc_store: &mut GcStore) -> Self {
+        Self(gc_store.clone_gc_ref(&self.0))
+    }
+
+    /// Explicitly drop this `externref`, running GC drop barriers as necessary.
+    pub fn drop(self, gc_store: &mut GcStore) {
+        gc_store.drop_gc_ref(self.0);
+    }
+
+    /// Copy this `VMExternRef` without running the GC's clone barriers.
+    ///
+    /// Prefer calling `clone(&mut GcStore)` instead! This is mostly an internal
+    /// escape hatch for collector implementations.
+    ///
+    /// Failure to run GC barriers when they would otherwise be necessary can
+    /// lead to leaks, panics, and wrong results. It cannot lead to memory
+    /// unsafety, however.
+    pub fn unchecked_copy(&self) -> Self {
+        Self(self.0.unchecked_copy())
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/gc/enabled/free_list.rs b/crates/wasmtime/src/runtime/vm/gc/enabled/free_list.rs
new file mode 100644
index 000000000000..8e62253896ba
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/gc/enabled/free_list.rs
@@ -0,0 +1,776 @@
+use crate::prelude::*;
+use alloc::collections::BTreeMap;
+use core::cmp;
+use core::{alloc::Layout, num::NonZeroU32, ops::Bound};
+
+/// A very simple first-fit free list for use by our garbage collectors.
+pub(crate) struct FreeList {
+    /// The total capacity of the contiguous range of memory we are managing.
+    capacity: usize,
+    /// Our free blocks, as a map from index to length of the free block at that
+    /// index.
+    free_block_index_to_len: BTreeMap<u32, u32>,
+}
+
+/// Our minimum and maximum supported alignment. Every allocation is aligned to
+/// this.
+const ALIGN_USIZE: usize = 8;
+const ALIGN_U32: u32 = ALIGN_USIZE as u32;
+
+/// Our minimum allocation size.
+const MIN_BLOCK_SIZE: u32 = 24;
+
+impl FreeList {
+    /// Create a new `Layout` from the given `size` with an alignment that is
+    /// compatible with this free list.
+    pub fn layout(size: usize) -> Layout {
+        Layout::from_size_align(size, ALIGN_USIZE).unwrap()
+    }
+
+    /// Create a new `FreeList` for a contiguous region of memory of the given
+    /// size.
+    pub fn new(capacity: usize) -> Self {
+        let mut free_list = FreeList {
+            capacity,
+            free_block_index_to_len: BTreeMap::new(),
+        };
+        free_list.reset();
+        free_list
+    }
+
+    fn max_size(&self) -> usize {
+        let cap = cmp::min(self.capacity, usize::try_from(u32::MAX).unwrap());
+        round_usize_down_to_pow2(cap.saturating_sub(ALIGN_USIZE), ALIGN_USIZE)
+    }
+
+    /// Check the given layout for compatibility with this free list and return
+    /// the actual block size we will use for this layout.
+    fn check_layout(&self, layout: Layout) -> Result<u32> {
+        ensure!(
+            layout.align() <= ALIGN_USIZE,
+            "requested allocation's alignment of {} is greater than max supported alignment of {ALIGN_USIZE}",
+            layout.align(),
+        );
+
+        ensure!(
+            layout.size() <= self.max_size(),
+            "requested allocation's size of {} is greater than the max supported size of {}",
+            layout.size(),
+            self.max_size(),
+        );
+
+        let alloc_size = u32::try_from(layout.size())
+            .err2anyhow()
+            .context("requested allocation's size does not fit in a u32")?;
+        alloc_size
+            .checked_next_multiple_of(ALIGN_U32)
+            .ok_or_else(|| {
+                anyhow!(
+                    "failed to round allocation size of {alloc_size} up to next \
+                     multiple of {ALIGN_USIZE}"
+                )
+            })
+    }
+
+    /// Find the first free block that can hold an allocation of the given size
+    /// and remove it from the free list.
+    fn first_fit(&mut self, alloc_size: u32) -> Option<(u32, u32)> {
+        debug_assert_eq!(alloc_size % ALIGN_U32, 0);
+
+        let (&block_index, &block_len) = self
+            .free_block_index_to_len
+            .iter()
+            .find(|(_idx, len)| **len >= alloc_size)?;
+
+        debug_assert_eq!(block_index % ALIGN_U32, 0);
+        debug_assert_eq!(block_len % ALIGN_U32, 0);
+
+        let entry = self.free_block_index_to_len.remove(&block_index);
+        debug_assert!(entry.is_some());
+
+        Some((block_index, block_len))
+    }
+
+    /// If the given allocated block is large enough such that we can split it
+    /// and still have enough space left for future allocations, then split it.
+    ///
+    /// Returns the new length of the allocated block.
+    fn maybe_split(&mut self, alloc_size: u32, block_index: u32, block_len: u32) -> u32 {
+        debug_assert_eq!(alloc_size % ALIGN_U32, 0);
+        debug_assert_eq!(block_index % ALIGN_U32, 0);
+        debug_assert_eq!(block_len % ALIGN_U32, 0);
+
+        if block_len - alloc_size < MIN_BLOCK_SIZE {
+            // The block is not large enough to split.
+            return block_len;
+        }
+
+        // The block is large enough to split. Split the block at exactly the
+        // requested allocation size and put the tail back in the free list.
+        let new_block_len = alloc_size;
+        let split_start = block_index + alloc_size;
+        let split_len = block_len - alloc_size;
+
+        debug_assert_eq!(new_block_len % ALIGN_U32, 0);
+        debug_assert_eq!(split_start % ALIGN_U32, 0);
+        debug_assert_eq!(split_len % ALIGN_U32, 0);
+
+        self.free_block_index_to_len.insert(split_start, split_len);
+
+        new_block_len
+    }
+
+    /// Allocate space for an object of the given layout.
+    ///
+    /// Returns:
+    ///
+    /// * `Ok(Some(_))`: Allocation succeeded.
+    ///
+    /// * `Ok(None)`: Can't currently fulfill the allocation request, but might
+    ///   be able to if some stuff was reallocated.
+    ///
+    /// * `Err(_)`:
+    pub fn alloc(&mut self, layout: Layout) -> Result<Option<NonZeroU32>> {
+        let alloc_size = self.check_layout(layout)?;
+        debug_assert_eq!(alloc_size % ALIGN_U32, 0);
+
+        let (block_index, block_len) = match self.first_fit(alloc_size) {
+            None => return Ok(None),
+            Some(tup) => tup,
+        };
+        debug_assert_ne!(block_index, 0);
+        debug_assert_eq!(block_index % ALIGN_U32, 0);
+        debug_assert!(block_len >= alloc_size);
+        debug_assert_eq!(block_len % ALIGN_U32, 0);
+
+        let block_len = self.maybe_split(alloc_size, block_index, block_len);
+        debug_assert!(block_len >= alloc_size);
+        debug_assert_eq!(block_len % ALIGN_U32, 0);
+
+        // After we've mutated the free list, double check its integrity.
+        #[cfg(debug_assertions)]
+        self.check_integrity();
+
+        Ok(Some(unsafe { NonZeroU32::new_unchecked(block_index) }))
+    }
+
+    /// Deallocate an object with the given layout.
+    pub fn dealloc(&mut self, index: NonZeroU32, layout: Layout) {
+        let index = index.get();
+        debug_assert_eq!(index % ALIGN_U32, 0);
+
+        let alloc_size = self.check_layout(layout).unwrap();
+        debug_assert_eq!(alloc_size % ALIGN_U32, 0);
+
+        let prev_block = self
+            .free_block_index_to_len
+            .range((Bound::Unbounded, Bound::Excluded(index)))
+            .next_back()
+            .map(|(idx, len)| (*idx, *len));
+
+        let next_block = self
+            .free_block_index_to_len
+            .range((Bound::Excluded(index), Bound::Unbounded))
+            .next()
+            .map(|(idx, len)| (*idx, *len));
+
+        // Try and merge this block with its previous and next blocks in the
+        // free list, if any and if they are contiguous.
+        match (prev_block, next_block) {
+            // The prev, this, and next blocks are all contiguous: merge this
+            // and next into prev.
+            (Some((prev_index, prev_len)), Some((next_index, next_len)))
+                if blocks_are_contiguous(prev_index, prev_len, index)
+                    && blocks_are_contiguous(index, alloc_size, next_index) =>
+            {
+                self.free_block_index_to_len.remove(&next_index);
+                let merged_block_len = next_index + next_len - prev_index;
+                debug_assert_eq!(merged_block_len % ALIGN_U32, 0);
+                *self.free_block_index_to_len.get_mut(&prev_index).unwrap() = merged_block_len;
+            }
+
+            // The prev and this blocks are contiguous: merge this into prev.
+            (Some((prev_index, prev_len)), _)
+                if blocks_are_contiguous(prev_index, prev_len, index) =>
+            {
+                let merged_block_len = index + alloc_size - prev_index;
+                debug_assert_eq!(merged_block_len % ALIGN_U32, 0);
+                *self.free_block_index_to_len.get_mut(&prev_index).unwrap() = merged_block_len;
+            }
+
+            // The this and next blocks are contiguous: merge next into this.
+            (_, Some((next_index, next_len)))
+                if blocks_are_contiguous(index, alloc_size, next_index) =>
+            {
+                self.free_block_index_to_len.remove(&next_index);
+                let merged_block_len = next_index + next_len - index;
+                debug_assert_eq!(merged_block_len % ALIGN_U32, 0);
+                self.free_block_index_to_len.insert(index, merged_block_len);
+            }
+
+            // None of the blocks are contiguous: insert this block into the
+            // free list.
+            (_, _) => {
+                self.free_block_index_to_len.insert(index, alloc_size);
+            }
+        }
+
+        // After we've added to/mutated the free list, double check its
+        // integrity.
+        #[cfg(debug_assertions)]
+        self.check_integrity();
+    }
+
+    /// Assert that the free list is valid:
+    ///
+    /// 1. All blocks are within `ALIGN..self.capacity`
+    ///
+    /// 2. No blocks are overlapping.
+    ///
+    /// 3. All blocks are aligned to `ALIGN`
+    ///
+    /// 4. All block sizes are a multiple of `ALIGN`
+    #[cfg(debug_assertions)]
+    fn check_integrity(&self) {
+        let mut prev_end = None;
+        for (&index, &len) in self.free_block_index_to_len.iter() {
+            // (1)
+            let end = index + len;
+            assert!(usize::try_from(end).unwrap() <= self.capacity);
+
+            // (2)
+            if let Some(prev_end) = prev_end {
+                // We could assert `prev_end <= index`, and that would be
+                // correct, but it would also mean that we missed an opportunity
+                // to merge the previous block and this current block
+                // together. We don't want to allow that kind of fragmentation,
+                // so do the stricter `prev_end < index` assert here.
+                assert!(prev_end < index);
+            }
+
+            // (3)
+            assert_eq!(index % ALIGN_U32, 0);
+
+            // (4)
+            assert_eq!(len % ALIGN_U32, 0);
+
+            prev_end = Some(end);
+        }
+    }
+
+    /// Reset this free list, making the whole range available for allocation.
+    pub fn reset(&mut self) {
+        let end = u32::try_from(self.capacity).unwrap_or_else(|_| {
+            assert!(self.capacity > usize::try_from(u32::MAX).unwrap());
+            u32::MAX
+        });
+
+        // Don't start at `0`. Reserve that for "null pointers" and this way we
+        // can use `NonZeroU32` as out pointer type, giving us some more
+        // bitpacking opportunities.
+        let start = ALIGN_U32;
+
+        let len = round_u32_down_to_pow2(end.saturating_sub(start), ALIGN_U32);
+
+        let entire_range = if len >= MIN_BLOCK_SIZE {
+            Some((start, len))
+        } else {
+            None
+        };
+
+        self.free_block_index_to_len.clear();
+        self.free_block_index_to_len.extend(entire_range);
+    }
+}
+
+#[inline]
+fn blocks_are_contiguous(prev_index: u32, prev_len: u32, next_index: u32) -> bool {
+    // NB: We might have decided *not* to split the prev block if it was larger
+    // than the requested allocation size but not large enough such that if we
+    // split it, the remainder could fulfill future allocations. In such cases,
+    // the size of the `Layout` given to us upon deallocation (aka `prev_len`)
+    // is smaller than the actual size of the block we allocated.
+    let end_of_prev = prev_index + prev_len;
+    debug_assert!(next_index >= end_of_prev);
+    let delta_to_next = next_index - end_of_prev;
+    delta_to_next < MIN_BLOCK_SIZE
+}
+
+#[inline]
+fn round_u32_down_to_pow2(value: u32, divisor: u32) -> u32 {
+    debug_assert!(divisor > 0);
+    debug_assert!(divisor.is_power_of_two());
+    value & !(divisor - 1)
+}
+
+#[inline]
+fn round_usize_down_to_pow2(value: usize, divisor: usize) -> usize {
+    debug_assert!(divisor > 0);
+    debug_assert!(divisor.is_power_of_two());
+    value & !(divisor - 1)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use proptest::prelude::*;
+    use std::{collections::HashMap, num::NonZeroUsize};
+
+    fn free_list_block_len_and_size(free_list: &FreeList) -> (usize, Option<usize>) {
+        let len = free_list.free_block_index_to_len.len();
+        let size = free_list
+            .free_block_index_to_len
+            .values()
+            .next()
+            .map(|s| usize::try_from(*s).unwrap());
+        (len, size)
+    }
+
+    proptest! {
+        /// This property test ensures that `FreeList` doesn't suffer from
+        /// permanent fragmentation. That is, it can always merge neighboring
+        /// free blocks together into a single, larger free block that can be
+        /// used to satisfy larger allocations than either of those smaller
+        /// blocks could have. In the limit, once we've freed all blocks, that
+        /// means we should end up with a single block that represents the whole
+        /// range of memory that the `FreeList` is portioning out (just like
+        /// what we started with when we initially created the `FreeList`).
+        #[test]
+        #[cfg_attr(miri, ignore)]
+        fn check_no_fragmentation((capacity, ops) in ops()) {
+            // Map from allocation id to ptr.
+            let mut live = HashMap::new();
+
+            // Set of deferred deallocations, where the strategy told us to
+            // deallocate an id before it was allocated. These simply get
+            // deallocated en-mass at the end.
+            let mut deferred = vec![];
+
+            // The free list we are testing.
+            let mut free_list = FreeList::new(capacity.get());
+
+            let (initial_len, initial_size) = free_list_block_len_and_size(&free_list);
+            assert!(initial_len == 0 || initial_len == 1);
+            assert!(initial_size.unwrap_or(0) <= capacity.get());
+            assert_eq!(initial_size.unwrap_or(0), free_list.max_size());
+
+            // Run through the generated ops and perform each operation.
+            for (id, op) in ops {
+                match op {
+                    Op::Alloc(layout) => {
+                        if let Ok(Some(ptr)) = free_list.alloc(layout) {
+                            live.insert(id, ptr);
+                        }
+                    }
+                    Op::Dealloc(layout) => {
+                        if let Some(ptr) = live.remove(&id) {
+                            free_list.dealloc(ptr, layout);
+                        } else {
+                            deferred.push((id, layout));
+                        }
+                    }
+                }
+            }
+
+            // Now that we've completed all allocations, perform the deferred
+            // deallocations.
+            for (id, layout) in deferred {
+                // NB: not all IDs necessarily got successful allocations, so
+                // there might not be a live pointer for this ID, even after
+                // we've already performed all the allocation operations.
+                if let Some(ptr) = live.remove(&id) {
+                    free_list.dealloc(ptr, layout);
+                }
+            }
+
+            // Now we can assert various properties that should hold after we
+            // have deallocated everything that was allocated.
+            //
+            // First, assert we did in fact deallocate everything.
+            assert!(live.is_empty());
+
+            let (final_len, final_size) = free_list_block_len_and_size(&free_list);
+
+            // The free list should have a single chunk again (or no chunks if
+            // the capacity was too small).
+            assert_eq!(final_len, initial_len);
+
+            // And the size of that chunk should be the same as the initial size.
+            assert_eq!(final_size, initial_size);
+        }
+    }
+
+    #[derive(Clone, Debug)]
+    enum Op {
+        Alloc(Layout),
+        Dealloc(Layout),
+    }
+
+    /// Map an arbitrary `x` to a power of 2 that is less than or equal to
+    /// `max`, but with as little bias as possible (e.g. rounding `min(x, max)`
+    /// to the nearest power of 2 is unacceptable because it would majorly bias
+    /// the distribution towards `max` when `max` is much smaller than
+    /// `usize::MAX`).
+    fn clamp_to_pow2_in_range(x: usize, max: usize) -> usize {
+        let log_x = max.ilog2() as usize;
+        if log_x == 0 {
+            return 1;
+        }
+        let divisor = usize::MAX / log_x;
+        let y = 1_usize << (x / divisor);
+        assert!(y.is_power_of_two(), "{y} is not a power of two");
+        assert!(y <= max, "{y} is larger than {max}");
+        y
+    }
+
+    /// Helper to turn a pair of arbitrary `usize`s into a valid `Layout` of
+    /// reasonable size for use with quickchecks.
+    fn arbitrary_layout(max_size: NonZeroUsize, size: usize, align: usize) -> Layout {
+        // The maximum size cannot be larger than `isize::MAX` because `Layout`
+        // imposes that constraint on its size.
+        let max_size = std::cmp::min(max_size.get(), usize::try_from(isize::MAX).unwrap());
+
+        // Ensure that the alignment is a power of 2 that is less than or equal
+        // to the maximum alignment that `FreeList` supports.
+        let align = clamp_to_pow2_in_range(align, super::ALIGN_USIZE);
+
+        // Ensure that `size` is less than or equal to `max_size`.
+        let size = size % (max_size + 1);
+
+        // Ensure that `size` is a multiple of `align`.
+        //
+        // NB: We round `size` *down* to the previous multiple of `align` to
+        // preserve `size <= max_size`.
+        let size = round_usize_down_to_pow2(size, align);
+        assert!(size <= max_size);
+
+        // Double check that we satisfied all of `Layout::from_size_align`'s
+        // success requirements.
+        assert_ne!(align, 0);
+        assert!(align.is_power_of_two());
+        assert_eq!(size % align, 0);
+        assert!(size <= usize::try_from(isize::MAX).unwrap());
+
+        Layout::from_size_align(size, align).unwrap()
+    }
+
+    /// Proptest strategy to generate a free list capacity and a series of
+    /// allocation operations to perform in a free list of that capacity.
+    fn ops() -> impl Strategy<Value = (NonZeroUsize, Vec<(usize, Op)>)> {
+        any::<usize>().prop_flat_map(|capacity| {
+            let capacity =
+                NonZeroUsize::new(capacity).unwrap_or_else(|| NonZeroUsize::new(1 << 31).unwrap());
+
+            (
+                Just(capacity),
+                (any::<usize>(), any::<usize>(), any::<usize>())
+                    .prop_flat_map(move |(id, size, align)| {
+                        let layout = arbitrary_layout(capacity, size, align);
+                        vec![
+                            Just((id, Op::Alloc(layout))),
+                            Just((id, Op::Dealloc(layout))),
+                        ]
+                    })
+                    .prop_shuffle(),
+            )
+        })
+    }
+
+    #[test]
+    fn allocate_no_split() {
+        // Create a free list with the capacity to allocate two blocks of size
+        // `MIN_BLOCK_SIZE`.
+        let mut free_list =
+            FreeList::new(ALIGN_USIZE + usize::try_from(MIN_BLOCK_SIZE).unwrap() * 2);
+
+        assert_eq!(free_list.free_block_index_to_len.len(), 1);
+        assert_eq!(
+            free_list.max_size(),
+            usize::try_from(MIN_BLOCK_SIZE).unwrap() * 2
+        );
+
+        // Allocate a block such that the remainder is not worth splitting.
+        free_list
+            .alloc(
+                Layout::from_size_align(
+                    usize::try_from(MIN_BLOCK_SIZE).unwrap() + ALIGN_USIZE,
+                    ALIGN_USIZE,
+                )
+                .unwrap(),
+            )
+            .expect("allocation within 'static' free list limits")
+            .expect("have free space available for allocation");
+
+        // Should not have split the block.
+        assert_eq!(free_list.free_block_index_to_len.len(), 0);
+    }
+
+    #[test]
+    fn allocate_and_split() {
+        // Create a free list with the capacity to allocate three blocks of size
+        // `MIN_BLOCK_SIZE`.
+        let mut free_list =
+            FreeList::new(ALIGN_USIZE + usize::try_from(MIN_BLOCK_SIZE).unwrap() * 3);
+
+        assert_eq!(free_list.free_block_index_to_len.len(), 1);
+        assert_eq!(
+            free_list.max_size(),
+            usize::try_from(MIN_BLOCK_SIZE).unwrap() * 3
+        );
+
+        // Allocate a block such that the remainder is not worth splitting.
+        free_list
+            .alloc(
+                Layout::from_size_align(
+                    usize::try_from(MIN_BLOCK_SIZE).unwrap() + ALIGN_USIZE,
+                    ALIGN_USIZE,
+                )
+                .unwrap(),
+            )
+            .expect("allocation within 'static' free list limits")
+            .expect("have free space available for allocation");
+
+        // Should have split the block.
+        assert_eq!(free_list.free_block_index_to_len.len(), 1);
+    }
+
+    #[test]
+    fn dealloc_merge_prev_and_next() {
+        let layout =
+            Layout::from_size_align(usize::try_from(MIN_BLOCK_SIZE).unwrap(), ALIGN_USIZE).unwrap();
+
+        let mut free_list =
+            FreeList::new(ALIGN_USIZE + usize::try_from(MIN_BLOCK_SIZE).unwrap() * 100);
+        assert_eq!(
+            free_list.free_block_index_to_len.len(),
+            1,
+            "initially one big free block"
+        );
+
+        let a = free_list
+            .alloc(layout)
+            .expect("allocation within 'static' free list limits")
+            .expect("have free space available for allocation");
+        assert_eq!(
+            free_list.free_block_index_to_len.len(),
+            1,
+            "should have split the block to allocate `a`"
+        );
+
+        let b = free_list
+            .alloc(layout)
+            .expect("allocation within 'static' free list limits")
+            .expect("have free space available for allocation");
+        assert_eq!(
+            free_list.free_block_index_to_len.len(),
+            1,
+            "should have split the block to allocate `b`"
+        );
+
+        free_list.dealloc(a, layout);
+        assert_eq!(
+            free_list.free_block_index_to_len.len(),
+            2,
+            "should have two non-contiguous free blocks after deallocating `a`"
+        );
+
+        free_list.dealloc(b, layout);
+        assert_eq!(
+            free_list.free_block_index_to_len.len(),
+            1,
+            "should have merged `a` and `b` blocks with the rest to form a \
+             single, contiguous free block after deallocating `b`"
+        );
+    }
+
+    #[test]
+    fn dealloc_merge_with_prev_and_not_next() {
+        let layout =
+            Layout::from_size_align(usize::try_from(MIN_BLOCK_SIZE).unwrap(), ALIGN_USIZE).unwrap();
+
+        let mut free_list =
+            FreeList::new(ALIGN_USIZE + usize::try_from(MIN_BLOCK_SIZE).unwrap() * 100);
+        assert_eq!(
+            free_list.free_block_index_to_len.len(),
+            1,
+            "initially one big free block"
+        );
+
+        let a = free_list
+            .alloc(layout)
+            .expect("allocation within 'static' free list limits")
+            .expect("have free space available for allocation");
+        let b = free_list
+            .alloc(layout)
+            .expect("allocation within 'static' free list limits")
+            .expect("have free space available for allocation");
+        let c = free_list
+            .alloc(layout)
+            .expect("allocation within 'static' free list limits")
+            .expect("have free space available for allocation");
+        assert_eq!(
+            free_list.free_block_index_to_len.len(),
+            1,
+            "should have split the block to allocate `a`, `b`, and `c`"
+        );
+
+        free_list.dealloc(a, layout);
+        assert_eq!(
+            free_list.free_block_index_to_len.len(),
+            2,
+            "should have two non-contiguous free blocks after deallocating `a`"
+        );
+
+        free_list.dealloc(b, layout);
+        assert_eq!(
+            free_list.free_block_index_to_len.len(),
+            2,
+            "should have merged `a` and `b` blocks, but not merged with the \
+             rest of the free space"
+        );
+
+        let _ = c;
+    }
+
+    #[test]
+    fn dealloc_merge_with_next_and_not_prev() {
+        let layout =
+            Layout::from_size_align(usize::try_from(MIN_BLOCK_SIZE).unwrap(), ALIGN_USIZE).unwrap();
+
+        let mut free_list =
+            FreeList::new(ALIGN_USIZE + usize::try_from(MIN_BLOCK_SIZE).unwrap() * 100);
+        assert_eq!(
+            free_list.free_block_index_to_len.len(),
+            1,
+            "initially one big free block"
+        );
+
+        let a = free_list
+            .alloc(layout)
+            .expect("allocation within 'static' free list limits")
+            .expect("have free space available for allocation");
+        let b = free_list
+            .alloc(layout)
+            .expect("allocation within 'static' free list limits")
+            .expect("have free space available for allocation");
+        let c = free_list
+            .alloc(layout)
+            .expect("allocation within 'static' free list limits")
+            .expect("have free space available for allocation");
+        assert_eq!(
+            free_list.free_block_index_to_len.len(),
+            1,
+            "should have split the block to allocate `a`, `b`, and `c`"
+        );
+
+        free_list.dealloc(a, layout);
+        assert_eq!(
+            free_list.free_block_index_to_len.len(),
+            2,
+            "should have two non-contiguous free blocks after deallocating `a`"
+        );
+
+        free_list.dealloc(c, layout);
+        assert_eq!(
+            free_list.free_block_index_to_len.len(),
+            2,
+            "should have merged `c` block with rest of the free space, but not \
+             with `a` block"
+        );
+
+        let _ = b;
+    }
+
+    #[test]
+    fn dealloc_no_merge() {
+        let layout =
+            Layout::from_size_align(usize::try_from(MIN_BLOCK_SIZE).unwrap(), ALIGN_USIZE).unwrap();
+
+        let mut free_list =
+            FreeList::new(ALIGN_USIZE + usize::try_from(MIN_BLOCK_SIZE).unwrap() * 100);
+        assert_eq!(
+            free_list.free_block_index_to_len.len(),
+            1,
+            "initially one big free block"
+        );
+
+        let a = free_list
+            .alloc(layout)
+            .expect("allocation within 'static' free list limits")
+            .expect("have free space available for allocation");
+        let b = free_list
+            .alloc(layout)
+            .expect("allocation within 'static' free list limits")
+            .expect("have free space available for allocation");
+        let c = free_list
+            .alloc(layout)
+            .expect("allocation within 'static' free list limits")
+            .expect("have free space available for allocation");
+        let d = free_list
+            .alloc(layout)
+            .expect("allocation within 'static' free list limits")
+            .expect("have free space available for allocation");
+        assert_eq!(
+            free_list.free_block_index_to_len.len(),
+            1,
+            "should have split the block to allocate `a`, `b`, `c`, and `d`"
+        );
+
+        free_list.dealloc(a, layout);
+        assert_eq!(
+            free_list.free_block_index_to_len.len(),
+            2,
+            "should have two non-contiguous free blocks after deallocating `a`"
+        );
+
+        free_list.dealloc(c, layout);
+        assert_eq!(
+            free_list.free_block_index_to_len.len(),
+            3,
+            "should not have merged `c` block `a` block or rest of the free \
+             space"
+        );
+
+        let _ = (b, d);
+    }
+
+    #[test]
+    fn alloc_size_too_large() {
+        // Free list with room for 10 min-sized blocks.
+        let mut free_list =
+            FreeList::new(ALIGN_USIZE + usize::try_from(MIN_BLOCK_SIZE).unwrap() * 10);
+        assert_eq!(
+            free_list.max_size(),
+            usize::try_from(MIN_BLOCK_SIZE).unwrap() * 10
+        );
+
+        // Attempt to allocate something that is 20 times the size of our
+        // min-sized block.
+        assert!(free_list
+            .alloc(
+                Layout::from_size_align(usize::try_from(MIN_BLOCK_SIZE).unwrap() * 20, ALIGN_USIZE)
+                    .unwrap(),
+            )
+            .is_err());
+    }
+
+    #[test]
+    fn alloc_align_too_large() {
+        // Free list with room for 10 min-sized blocks.
+        let mut free_list =
+            FreeList::new(ALIGN_USIZE + usize::try_from(MIN_BLOCK_SIZE).unwrap() * 10);
+        assert_eq!(
+            free_list.max_size(),
+            usize::try_from(MIN_BLOCK_SIZE).unwrap() * 10
+        );
+
+        // Attempt to allocate something that requires larger alignment than
+        // `FreeList` supports.
+        assert!(free_list
+            .alloc(
+                Layout::from_size_align(usize::try_from(MIN_BLOCK_SIZE).unwrap(), ALIGN_USIZE * 2)
+                    .unwrap(),
+            )
+            .is_err());
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/gc/enabled/structref.rs b/crates/wasmtime/src/runtime/vm/gc/enabled/structref.rs
new file mode 100644
index 000000000000..d0bd18d43b28
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/gc/enabled/structref.rs
@@ -0,0 +1,336 @@
+use crate::{
+    prelude::*,
+    runtime::vm::{GcHeap, GcStore, VMGcRef},
+    store::AutoAssertNoGc,
+    vm::GcStructLayout,
+    AnyRef, ExternRef, HeapType, RootedGcRefImpl, StorageType, Val, ValType,
+};
+use core::fmt;
+use wasmtime_environ::VMGcKind;
+
+/// A `VMGcRef` that we know points to a `struct`.
+///
+/// Create a `VMStructRef` via `VMGcRef::into_structref` and
+/// `VMGcRef::as_structref`, or their untyped equivalents
+/// `VMGcRef::into_structref_unchecked` and `VMGcRef::as_structref_unchecked`.
+///
+/// Note: This is not a `TypedGcRef<_>` because each collector can have a
+/// different concrete representation of `structref` that they allocate inside
+/// their heaps.
+#[derive(Debug, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct VMStructRef(VMGcRef);
+
+impl fmt::Pointer for VMStructRef {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Pointer::fmt(&self.0, f)
+    }
+}
+
+impl From<VMStructRef> for VMGcRef {
+    #[inline]
+    fn from(x: VMStructRef) -> Self {
+        x.0
+    }
+}
+
+impl VMGcRef {
+    /// Is this `VMGcRef` pointing to a `struct`?
+    pub fn is_structref(&self, gc_heap: &(impl GcHeap + ?Sized)) -> bool {
+        if self.is_i31() {
+            return false;
+        }
+
+        let header = gc_heap.header(&self);
+        header.kind().matches(VMGcKind::StructRef)
+    }
+
+    /// Create a new `VMStructRef` from the given `gc_ref`.
+    ///
+    /// If this is not a GC reference to an `structref`, `Err(self)` is
+    /// returned.
+    pub fn into_structref(self, gc_heap: &impl GcHeap) -> Result<VMStructRef, VMGcRef> {
+        if self.is_structref(gc_heap) {
+            Ok(self.into_structref_unchecked())
+        } else {
+            Err(self)
+        }
+    }
+
+    /// Create a new `VMStructRef` from `self` without actually checking that
+    /// `self` is an `structref`.
+    ///
+    /// This method does not check that `self` is actually an `structref`, but
+    /// it should be. Failure to uphold this invariant is memory safe but will
+    /// result in general incorrectness down the line such as panics or wrong
+    /// results.
+    #[inline]
+    pub fn into_structref_unchecked(self) -> VMStructRef {
+        debug_assert!(!self.is_i31());
+        VMStructRef(self)
+    }
+
+    /// Get this GC reference as an `structref` reference, if it actually is an
+    /// `structref` reference.
+    pub fn as_structref(&self, gc_heap: &(impl GcHeap + ?Sized)) -> Option<&VMStructRef> {
+        if self.is_structref(gc_heap) {
+            Some(self.as_structref_unchecked())
+        } else {
+            None
+        }
+    }
+
+    /// Get this GC reference as an `structref` reference without checking if it
+    /// actually is an `structref` reference.
+    ///
+    /// Calling this method on a non-`structref` reference is memory safe, but
+    /// will lead to general incorrectness like panics and wrong results.
+    pub fn as_structref_unchecked(&self) -> &VMStructRef {
+        debug_assert!(!self.is_i31());
+        let ptr = self as *const VMGcRef;
+        let ret = unsafe { &*ptr.cast() };
+        assert!(matches!(ret, VMStructRef(VMGcRef { .. })));
+        ret
+    }
+}
+
+impl VMStructRef {
+    /// Get the underlying `VMGcRef`.
+    pub fn as_gc_ref(&self) -> &VMGcRef {
+        &self.0
+    }
+
+    /// Clone this `VMStructRef`, running any GC barriers as necessary.
+    pub fn clone(&self, gc_store: &mut GcStore) -> Self {
+        Self(gc_store.clone_gc_ref(&self.0))
+    }
+
+    /// Explicitly drop this `structref`, running GC drop barriers as necessary.
+    pub fn drop(self, gc_store: &mut GcStore) {
+        gc_store.drop_gc_ref(self.0);
+    }
+
+    /// Copy this `VMStructRef` without running the GC's clone barriers.
+    ///
+    /// Prefer calling `clone(&mut GcStore)` instead! This is mostly an internal
+    /// escape hatch for collector implementations.
+    ///
+    /// Failure to run GC barriers when they would otherwise be necessary can
+    /// lead to leaks, panics, and wrong results. It cannot lead to memory
+    /// unsafety, however.
+    pub fn unchecked_copy(&self) -> Self {
+        Self(self.0.unchecked_copy())
+    }
+
+    /// Read a field of the given `StorageType` into a `Val`.
+    ///
+    /// `i8` and `i16` fields are zero-extended into `Val::I32(_)`s.
+    ///
+    /// Does not check that the field is actually of type `ty`. That is the
+    /// caller's responsibility. Failure to do so is memory safe, but will lead
+    /// to general incorrectness such as panics and wrong results.
+    ///
+    /// Panics on out-of-bounds accesses.
+    pub fn read_field(
+        &self,
+        store: &mut AutoAssertNoGc,
+        layout: &GcStructLayout,
+        ty: &StorageType,
+        field: usize,
+    ) -> Val {
+        let offset = layout.fields[field];
+        let data = store.unwrap_gc_store_mut().gc_object_data(self.as_gc_ref());
+        match ty {
+            StorageType::I8 => Val::I32(data.read_u8(offset).into()),
+            StorageType::I16 => Val::I32(data.read_u16(offset).into()),
+            StorageType::ValType(ValType::I32) => Val::I32(data.read_i32(offset)),
+            StorageType::ValType(ValType::I64) => Val::I64(data.read_i64(offset)),
+            StorageType::ValType(ValType::F32) => Val::F32(data.read_u32(offset)),
+            StorageType::ValType(ValType::F64) => Val::F64(data.read_u64(offset)),
+            StorageType::ValType(ValType::V128) => Val::V128(data.read_v128(offset)),
+            StorageType::ValType(ValType::Ref(r)) => match r.heap_type().top() {
+                HeapType::Extern => {
+                    let raw = data.read_u32(offset);
+                    Val::ExternRef(ExternRef::_from_raw(store, raw))
+                }
+                HeapType::Any => {
+                    let raw = data.read_u32(offset);
+                    Val::AnyRef(AnyRef::_from_raw(store, raw))
+                }
+                HeapType::Func => todo!("funcrefs inside gc objects not yet implemented"),
+                otherwise => unreachable!("not a top type: {otherwise:?}"),
+            },
+        }
+    }
+
+    /// Write the given value into this struct at the given offset.
+    ///
+    /// Returns an error if `val` is a GC reference that has since been
+    /// unrooted.
+    ///
+    /// Does not check that `val` matches `ty`, nor that the field is actually
+    /// of type `ty`. Checking those things is the caller's responsibility.
+    /// Failure to do so is memory safe, but will lead to general incorrectness
+    /// such as panics and wrong results.
+    ///
+    /// Panics on out-of-bounds accesses.
+    pub fn write_field(
+        &self,
+        store: &mut AutoAssertNoGc,
+        layout: &GcStructLayout,
+        ty: &StorageType,
+        field: usize,
+        val: Val,
+    ) -> Result<()> {
+        debug_assert!(val._matches_ty(&store, &ty.unpack())?);
+
+        let offset = layout.fields[field];
+        let mut data = store.gc_store_mut()?.gc_object_data(self.as_gc_ref());
+        match val {
+            Val::I32(i) if ty.is_i8() => data.write_i8(offset, i as i8),
+            Val::I32(i) if ty.is_i16() => data.write_i16(offset, i as i16),
+            Val::I32(i) => data.write_i32(offset, i),
+            Val::I64(i) => data.write_i64(offset, i),
+            Val::F32(f) => data.write_u32(offset, f),
+            Val::F64(f) => data.write_u64(offset, f),
+            Val::V128(v) => data.write_v128(offset, v),
+
+            // For GC-managed references, we need to take care to run the
+            // appropriate barriers, even when we are writing null references
+            // into the struct.
+            //
+            // POD-read the old value into a local copy, run the GC write
+            // barrier on that local copy, and then POD-write the updated
+            // value back into the struct. This avoids transmuting the inner
+            // data, which would probably be fine, but this approach is
+            // Obviously Correct and should get us by for now. If LLVM isn't
+            // able to elide some of these unnecessary copies, and this
+            // method is ever hot enough, we can always come back and clean
+            // it up in the future.
+            Val::ExternRef(e) => {
+                let raw = data.read_u32(offset);
+                let mut gc_ref = VMGcRef::from_raw_u32(raw);
+                let e = match e {
+                    Some(e) => Some(e.try_gc_ref(store)?.unchecked_copy()),
+                    None => None,
+                };
+                store.gc_store_mut()?.write_gc_ref(&mut gc_ref, e.as_ref());
+                let mut data = store.gc_store_mut()?.gc_object_data(self.as_gc_ref());
+                data.write_u32(offset, gc_ref.map_or(0, |r| r.as_raw_u32()));
+            }
+            Val::AnyRef(a) => {
+                let raw = data.read_u32(offset);
+                let mut gc_ref = VMGcRef::from_raw_u32(raw);
+                let a = match a {
+                    Some(a) => Some(a.try_gc_ref(store)?.unchecked_copy()),
+                    None => None,
+                };
+                store.gc_store_mut()?.write_gc_ref(&mut gc_ref, a.as_ref());
+                let mut data = store.gc_store_mut()?.gc_object_data(self.as_gc_ref());
+                data.write_u32(offset, gc_ref.map_or(0, |r| r.as_raw_u32()));
+            }
+
+            Val::FuncRef(_) => todo!("funcrefs inside gc objects not yet implemented"),
+        }
+        Ok(())
+    }
+
+    /// Initialize a field in this structref that is currently uninitialized.
+    ///
+    /// The difference between this method and `write_field` is that GC barriers
+    /// are handled differently. When overwriting an initialized field (aka
+    /// `write_field`) we need to call the full write GC write barrier, which
+    /// logically drops the old GC reference and clones the new GC
+    /// reference. When we are initializing a field for the first time, there is
+    /// no old GC reference that is being overwritten and which we need to drop,
+    /// so we only need to clone the new GC reference.
+    ///
+    /// Calling this method on a structref that has already had the associated
+    /// field initialized will result in GC bugs. These are memory safe but will
+    /// lead to generally incorrect behavior such as panics, leaks, and
+    /// incorrect results.
+    ///
+    /// Does not check that `val` matches `ty`, nor that the field is actually
+    /// of type `ty`. Checking those things is the caller's responsibility.
+    /// Failure to do so is memory safe, but will lead to general incorrectness
+    /// such as panics and wrong results.
+    ///
+    /// Returns an error if `val` is a GC reference that has since been
+    /// unrooted.
+    ///
+    /// Panics on out-of-bounds accesses.
+    pub fn initialize_field(
+        &self,
+        store: &mut AutoAssertNoGc,
+        layout: &GcStructLayout,
+        ty: &StorageType,
+        field: usize,
+        val: Val,
+    ) -> Result<()> {
+        debug_assert!(val._matches_ty(&store, &ty.unpack())?);
+        let offset = layout.fields[field];
+        match val {
+            Val::I32(i) if ty.is_i8() => store
+                .gc_store_mut()?
+                .gc_object_data(self.as_gc_ref())
+                .write_i8(offset, i as i8),
+            Val::I32(i) if ty.is_i16() => store
+                .gc_store_mut()?
+                .gc_object_data(self.as_gc_ref())
+                .write_i16(offset, i as i16),
+            Val::I32(i) => store
+                .gc_store_mut()?
+                .gc_object_data(self.as_gc_ref())
+                .write_i32(offset, i),
+            Val::I64(i) => store
+                .gc_store_mut()?
+                .gc_object_data(self.as_gc_ref())
+                .write_i64(offset, i),
+            Val::F32(f) => store
+                .gc_store_mut()?
+                .gc_object_data(self.as_gc_ref())
+                .write_u32(offset, f),
+            Val::F64(f) => store
+                .gc_store_mut()?
+                .gc_object_data(self.as_gc_ref())
+                .write_u64(offset, f),
+            Val::V128(v) => store
+                .gc_store_mut()?
+                .gc_object_data(self.as_gc_ref())
+                .write_v128(offset, v),
+
+            // NB: We don't need to do a write barrier when initializing a
+            // field, because there is nothing being overwritten. Therefore, we
+            // just the clone barrier.
+            Val::ExternRef(x) => {
+                let x = match x {
+                    None => 0,
+                    Some(x) => x.try_clone_gc_ref(store)?.as_raw_u32(),
+                };
+                store
+                    .gc_store_mut()?
+                    .gc_object_data(self.as_gc_ref())
+                    .write_u32(offset, x);
+            }
+            Val::AnyRef(x) => {
+                let x = match x {
+                    None => 0,
+                    Some(x) => x.try_clone_gc_ref(store)?.as_raw_u32(),
+                };
+                store
+                    .gc_store_mut()?
+                    .gc_object_data(self.as_gc_ref())
+                    .write_u32(offset, x);
+            }
+
+            Val::FuncRef(_) => {
+                // TODO: we can't trust the GC heap, which means we can't read
+                // native VMFuncRef pointers out of it and trust them. That
+                // means we need to do the same side table kind of thing we do
+                // with `externref` host data here. This isn't implemented yet.
+                todo!("funcrefs in GC objects")
+            }
+        }
+        Ok(())
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/gc/gc_ref.rs b/crates/wasmtime/src/runtime/vm/gc/gc_ref.rs
new file mode 100644
index 000000000000..a916e3888786
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/gc/gc_ref.rs
@@ -0,0 +1,479 @@
+use crate::prelude::*;
+use crate::runtime::vm::{GcHeap, GcStore, I31};
+use core::fmt;
+use core::marker;
+use core::num::NonZeroU32;
+use wasmtime_environ::packed_option::ReservedValue;
+use wasmtime_environ::{VMGcKind, VMSharedTypeIndex};
+
+/// The common header for all objects allocated in a GC heap.
+///
+/// This header is shared across all collectors, although particular collectors
+/// may always add their own trailing fields to this header for all of their own
+/// GC objects.
+///
+/// This is a bit-packed structure that logically has the following fields:
+///
+/// ```ignore
+/// struct VMGcHeader {
+///     // Highest 2 bits.
+///     kind: VMGcKind,
+///
+///     // 30 bits available for the `GcRuntime` to make use of however it sees fit.
+///     reserved: u30,
+///
+///     // The `VMSharedTypeIndex` for this GC object, if it isn't an
+///     // `externref` (or an `externref` re-wrapped as an `anyref`). `None` is
+///     // represented with `VMSharedTypeIndex::reserved_value()`.
+///     ty: Option<VMSharedTypeIndex>,
+/// }
+/// ```
+#[repr(align(8))]
+pub struct VMGcHeader(u64);
+
+unsafe impl GcHeapObject for VMGcHeader {
+    #[inline]
+    fn is(_: &VMGcHeader) -> bool {
+        true
+    }
+}
+
+const _: () = {
+    assert!((VMGcHeader::HEADER_SIZE as usize) == core::mem::size_of::<VMGcHeader>());
+    assert!((VMGcHeader::HEADER_ALIGN as usize) == core::mem::align_of::<VMGcHeader>());
+};
+
+impl VMGcHeader {
+    /// The size of this type on all architectures.
+    pub const HEADER_SIZE: u32 = 8;
+
+    /// The alignment of this type on all architectures.
+    pub const HEADER_ALIGN: u32 = 8;
+
+    /// Create the header for an `externref`.
+    pub fn externref() -> Self {
+        Self::from_kind_and_index(VMGcKind::ExternRef, VMSharedTypeIndex::reserved_value())
+    }
+
+    /// Create the header for the given kind and type index.
+    pub fn from_kind_and_index(kind: VMGcKind, index: VMSharedTypeIndex) -> Self {
+        let upper = kind as u32;
+        let upper = u64::from(upper) << 32;
+        let lower = u64::from(index.bits());
+        Self(upper | lower)
+    }
+
+    /// Get the kind of GC object that this is.
+    pub fn kind(&self) -> VMGcKind {
+        let upper = u32::try_from(self.0 >> 32).unwrap();
+        VMGcKind::from_high_bits_of_u32(upper)
+    }
+
+    /// Get the reserved 26 bits in this header.
+    ///
+    /// These are bits are reserved for `GcRuntime` implementations to make use
+    /// of however they see fit.
+    pub fn reserved_u26(&self) -> u32 {
+        let upper = u32::try_from(self.0 >> 32).unwrap();
+        upper & VMGcKind::UNUSED_MASK
+    }
+
+    /// Set the 26-bit reserved value.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the given `value` has any of the upper 6 bits set.
+    pub fn set_reserved_u26(&mut self, value: u32) {
+        assert_eq!(
+            value & VMGcKind::MASK,
+            0,
+            "VMGcHeader::set_reserved_u26 with value using more than 26 bits"
+        );
+        self.0 |= u64::from(value) << 32;
+    }
+
+    /// Set the 26-bit reserved value.
+    ///
+    /// # Safety
+    ///
+    /// The given `value` must only use the lower 26 bits; its upper 6 bits must
+    /// be unset.
+    pub unsafe fn unchecked_set_reserved_u26(&mut self, value: u32) {
+        debug_assert_eq!(value & VMGcKind::MASK, 0);
+        self.0 |= u64::from(value) << 32;
+    }
+
+    /// Get this object's specific concrete type.
+    pub fn ty(&self) -> Option<VMSharedTypeIndex> {
+        let lower_mask = u64::from(u32::MAX);
+        let lower = u32::try_from(self.0 & lower_mask).unwrap();
+        if lower == u32::MAX {
+            None
+        } else {
+            Some(VMSharedTypeIndex::new(lower))
+        }
+    }
+}
+
+#[cfg(test)]
+mod vm_gc_header_tests {
+    use super::*;
+    use std::mem;
+
+    #[test]
+    fn size_align() {
+        assert_eq!(mem::size_of::<VMGcHeader>(), 8);
+        assert_eq!(mem::align_of::<VMGcHeader>(), 8);
+    }
+}
+
+/// A raw, unrooted GC reference.
+///
+/// A `VMGcRef` is either:
+///
+/// * A reference to some kind of object on the GC heap, but we don't know
+///   exactly which kind without further reflection. Furthermore, this is not
+///   actually a pointer, but a compact index into a Wasm GC heap.
+///
+/// * An `i31ref`: it doesn't actually reference an object in the GC heap, but
+///   is instead an inline, unboxed 31-bit integer.
+///
+/// ## `VMGcRef` and GC Barriers
+///
+/// Depending on the garbage collector in use, cloning, writing, and dropping a
+/// `VMGcRef` may require invoking GC barriers (little snippets of code provided
+/// by the collector to ensure it is correctly tracking all GC references).
+///
+/// Therefore, to encourage correct usage of GC barriers, this type does *NOT*
+/// implement `Clone` or `Copy`. Use `GcStore::clone_gc_ref`,
+/// `GcStore::write_gc_ref`, and `GcStore::drop_gc_ref` to clone, write, and
+/// drop `VMGcRef`s respectively.
+///
+/// As an escape hatch, if you really need to copy a `VMGcRef` without invoking
+/// GC barriers and you understand why that will not lead to GC bugs in this
+/// particular case, you can use the `unchecked_copy` method.
+#[derive(Debug, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct VMGcRef(NonZeroU32);
+
+impl<T> From<TypedGcRef<T>> for VMGcRef {
+    #[inline]
+    fn from(value: TypedGcRef<T>) -> Self {
+        value.gc_ref
+    }
+}
+
+impl fmt::LowerHex for VMGcRef {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl fmt::UpperHex for VMGcRef {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl fmt::Pointer for VMGcRef {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{self:#x}")
+    }
+}
+
+impl VMGcRef {
+    /// If this bit is set on a GC reference, then the GC reference is actually an
+    /// unboxed `i31`.
+    ///
+    /// Must be kept in sync with `wasmtime_cranelift::I31_REF_DISCRIMINANT`.
+    pub const I31_REF_DISCRIMINANT: u32 = 1;
+
+    /// Create a new `VMGcRef` from the given raw u32 value.
+    ///
+    /// Does not discriminate between indices into a GC heap and `i31ref`s.
+    ///
+    /// Returns `None` for zero values.
+    ///
+    /// The given index should point to a valid GC-managed object within this
+    /// reference's associated heap. Failure to uphold this will be memory safe,
+    /// but will lead to general failures such as panics or incorrect results.
+    pub fn from_raw_u32(raw: u32) -> Option<Self> {
+        Some(Self::from_raw_non_zero_u32(NonZeroU32::new(raw)?))
+    }
+
+    /// Create a new `VMGcRef` from the given index into a GC heap.
+    ///
+    /// The given index should point to a valid GC-managed object within this
+    /// reference's associated heap. Failure to uphold this will be memory safe,
+    /// but will lead to general failures such as panics or incorrect results.
+    ///
+    /// Returns `None` when the index is not 2-byte aligned and therefore
+    /// conflicts with the `i31ref` discriminant.
+    pub fn from_heap_index(index: NonZeroU32) -> Option<Self> {
+        if (index.get() & Self::I31_REF_DISCRIMINANT) == 0 {
+            Some(Self::from_raw_non_zero_u32(index))
+        } else {
+            None
+        }
+    }
+
+    /// Create a new `VMGcRef` from the given raw value.
+    ///
+    /// Does not discriminate between indices into a GC heap and `i31ref`s.
+    pub fn from_raw_non_zero_u32(raw: NonZeroU32) -> Self {
+        VMGcRef(raw)
+    }
+
+    /// Construct a new `VMGcRef` from an unboxed 31-bit integer.
+    #[inline]
+    pub fn from_i31(val: I31) -> Self {
+        let val = (val.get_u32() << 1) | Self::I31_REF_DISCRIMINANT;
+        debug_assert_ne!(val, 0);
+        let non_zero = unsafe { NonZeroU32::new_unchecked(val) };
+        VMGcRef::from_raw_non_zero_u32(non_zero)
+    }
+
+    /// Copy this `VMGcRef` without running the GC's clone barriers.
+    ///
+    /// Prefer calling `clone(&mut GcStore)` instead! This is mostly an internal
+    /// escape hatch for collector implementations.
+    ///
+    /// Failure to run GC barriers when they would otherwise be necessary can
+    /// lead to leaks, panics, and wrong results. It cannot lead to memory
+    /// unsafety, however.
+    pub fn unchecked_copy(&self) -> Self {
+        VMGcRef(self.0)
+    }
+
+    /// Get this GC reference as a u32 index into its GC heap.
+    ///
+    /// Returns `None` for `i31ref`s.
+    pub fn as_heap_index(&self) -> Option<NonZeroU32> {
+        if self.is_i31() {
+            None
+        } else {
+            Some(self.0)
+        }
+    }
+
+    /// Get this GC reference as a raw u32 value, regardless whether it is
+    /// actually a reference to a GC object or is an `i31ref`.
+    pub fn as_raw_u32(&self) -> u32 {
+        self.0.get()
+    }
+
+    /// Creates a typed GC reference from `self`, checking that `self` actually
+    /// is a `T`.
+    ///
+    /// If this is not a GC reference to a `T`, then `Err(self)` is returned.
+    pub fn into_typed<T>(self, gc_heap: &impl GcHeap) -> Result<TypedGcRef<T>, Self>
+    where
+        T: GcHeapObject,
+    {
+        if self.is_i31() {
+            return Err(self);
+        }
+        if T::is(gc_heap.header(&self)) {
+            Ok(TypedGcRef {
+                gc_ref: self,
+                _phantom: marker::PhantomData,
+            })
+        } else {
+            Err(self)
+        }
+    }
+
+    /// Creates a typed GC reference without actually checking that `self` is a
+    /// `T`.
+    ///
+    /// `self` should point to a `T` object. Failure to uphold this invariant is
+    /// memory safe, but will lead to general incorrectness such as panics or
+    /// wrong results.
+    pub fn into_typed_unchecked<T>(self) -> TypedGcRef<T>
+    where
+        T: GcHeapObject,
+    {
+        debug_assert!(!self.is_i31());
+        TypedGcRef {
+            gc_ref: self,
+            _phantom: marker::PhantomData,
+        }
+    }
+
+    /// Is this GC reference pointing to a `T`?
+    pub fn is_typed<T>(&self, gc_heap: &impl GcHeap) -> bool
+    where
+        T: GcHeapObject,
+    {
+        if self.is_i31() {
+            return false;
+        }
+        T::is(gc_heap.header(&self))
+    }
+
+    /// Borrow `self` as a typed GC reference, checking that `self` actually is
+    /// a `T`.
+    pub fn as_typed<T>(&self, gc_heap: &impl GcHeap) -> Option<&TypedGcRef<T>>
+    where
+        T: GcHeapObject,
+    {
+        if self.is_i31() {
+            return None;
+        }
+        if T::is(gc_heap.header(&self)) {
+            let ptr = self as *const VMGcRef;
+            let ret = unsafe { &*ptr.cast() };
+            assert!(matches!(
+                ret,
+                TypedGcRef {
+                    gc_ref: VMGcRef(_),
+                    _phantom
+                }
+            ));
+            Some(ret)
+        } else {
+            None
+        }
+    }
+
+    /// Creates a typed GC reference without actually checking that `self` is a
+    /// `T`.
+    ///
+    /// `self` should point to a `T` object. Failure to uphold this invariant is
+    /// memory safe, but will lead to general incorrectness such as panics or
+    /// wrong results.
+    pub fn as_typed_unchecked<T>(&self) -> &TypedGcRef<T>
+    where
+        T: GcHeapObject,
+    {
+        debug_assert!(!self.is_i31());
+        let ptr = self as *const VMGcRef;
+        let ret = unsafe { &*ptr.cast() };
+        assert!(matches!(
+            ret,
+            TypedGcRef {
+                gc_ref: VMGcRef(_),
+                _phantom
+            }
+        ));
+        ret
+    }
+
+    /// Get a reference to the GC header that this GC reference is pointing to.
+    ///
+    /// Returns `None` when this is an `i31ref` and doesn't actually point to a
+    /// GC header.
+    pub fn gc_header<'a>(&self, gc_heap: &'a (impl GcHeap + ?Sized)) -> Option<&'a VMGcHeader> {
+        if self.is_i31() {
+            None
+        } else {
+            Some(gc_heap.header(self))
+        }
+    }
+
+    /// Is this `VMGcRef` actually an unboxed 31-bit integer, and not actually a
+    /// GC reference?
+    #[inline]
+    pub fn is_i31(&self) -> bool {
+        let val = self.0.get();
+        (val & Self::I31_REF_DISCRIMINANT) != 0
+    }
+
+    /// Get the underlying `i31`, if any.
+    #[inline]
+    pub fn as_i31(&self) -> Option<I31> {
+        if self.is_i31() {
+            let val = self.0.get();
+            Some(I31::wrapping_u32(val >> 1))
+        } else {
+            None
+        }
+    }
+
+    /// Get the underlying `i31`, panicking if this is not an `i31`.
+    #[inline]
+    pub fn unwrap_i31(&self) -> I31 {
+        self.as_i31().unwrap()
+    }
+
+    /// Is this `VMGcRef` a `VMExternRef`?
+    #[inline]
+    pub fn is_extern_ref(&self, gc_heap: &(impl GcHeap + ?Sized)) -> bool {
+        self.gc_header(gc_heap)
+            .map_or(false, |h| h.kind().matches(VMGcKind::ExternRef))
+    }
+}
+
+/// A trait implemented by all objects allocated inside a GC heap.
+///
+/// # Safety
+///
+/// All implementations must:
+///
+/// * Be `repr(C)` or `repr(transparent)`
+///
+/// * Begin with a `VMGcHeader` as their first field
+///
+/// * Not have `Drop` implementations (aka, `std::mem::needs_drop::<Self>()`
+///   should return `false`).
+///
+/// * Be memory safe to transmute to from an arbitrary byte sequence (that is,
+///   it is okay if some bit patterns are invalid with regards to correctness,
+///   so long as these invalid bit patterns cannot lead to memory unsafety).
+pub unsafe trait GcHeapObject: Send + Sync {
+    /// Check whether the GC object with the given header is an instance of
+    /// `Self`.
+    fn is(header: &VMGcHeader) -> bool;
+}
+
+/// A GC reference to a heap object of concrete type `T`.
+///
+/// Create typed GC refs via `VMGcRef::into_typed` and `VMGcRef::as_typed`, as
+/// well as via their unchecked equivalents `VMGcRef::into_typed_unchecked` and
+/// `VMGcRef::as_typed_unchecked`.
+#[derive(Debug, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct TypedGcRef<T> {
+    gc_ref: VMGcRef,
+    _phantom: marker::PhantomData<*mut T>,
+}
+
+impl<T> TypedGcRef<T>
+where
+    T: GcHeapObject,
+{
+    /// Clone this `VMGcRef`, running any GC barriers as necessary.
+    pub fn clone(&self, gc_store: &mut GcStore) -> Self {
+        Self {
+            gc_ref: gc_store.clone_gc_ref(&self.gc_ref),
+            _phantom: marker::PhantomData,
+        }
+    }
+
+    /// Explicitly drop this GC reference, running any GC barriers as necessary.
+    pub fn drop(self, gc_store: &mut GcStore) {
+        gc_store.drop_gc_ref(self.gc_ref);
+    }
+
+    /// Copy this GC reference without running the GC's clone barriers.
+    ///
+    /// Prefer calling `clone(&mut GcStore)` instead! This is mostly an internal
+    /// escape hatch for collector implementations.
+    ///
+    /// Failure to run GC barriers when they would otherwise be necessary can
+    /// lead to leaks, panics, and wrong results. It cannot lead to memory
+    /// unsafety, however.
+    pub fn unchecked_copy(&self) -> Self {
+        Self {
+            gc_ref: self.gc_ref.unchecked_copy(),
+            _phantom: marker::PhantomData,
+        }
+    }
+}
+
+impl<T> TypedGcRef<T> {
+    /// Get the untyped version of this GC reference.
+    pub fn as_untyped(&self) -> &VMGcRef {
+        &self.gc_ref
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/gc/gc_runtime.rs b/crates/wasmtime/src/runtime/vm/gc/gc_runtime.rs
new file mode 100644
index 000000000000..d36e64ecd740
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/gc/gc_runtime.rs
@@ -0,0 +1,718 @@
+//! Traits for abstracting over our different garbage collectors.
+
+use crate::prelude::*;
+use crate::runtime::vm::{
+    ExternRefHostDataId, ExternRefHostDataTable, SendSyncPtr, VMArrayRef, VMExternRef, VMGcHeader,
+    VMGcRef, VMStructRef,
+};
+use core::marker;
+use core::ptr;
+use core::{any::Any, num::NonZeroUsize};
+use wasmtime_environ::{VMSharedTypeIndex, WasmArrayType, WasmStructType};
+
+use super::VMGcObjectDataMut;
+
+/// Trait for integrating a garbage collector with the runtime.
+///
+/// This trait is responsible for:
+///
+/// * GC barriers used by runtime code (as opposed to compiled Wasm code)
+///
+/// * Creating and managing GC heaps for individual stores
+///
+/// * Running garbage collection
+///
+/// # Safety
+///
+/// The collector, its GC heaps, and GC barriers when taken together as a whole
+/// must be safe. Additionally, they must work with the GC barriers emitted into
+/// compiled Wasm code via the collector's corresponding `GcCompiler`
+/// implementation. That is, if callers only call safe methods on this trait
+/// (while pairing it with its associated `GcCompiler`, `GcHeap`, and etc...)
+/// and uphold all the documented safety invariants of this trait's unsafe
+/// methods, then it must be impossible for callers to violate memory
+/// safety. Implementations of this trait may not add new safety invariants, not
+/// already documented in this trait's interface, that callers need to uphold.
+pub unsafe trait GcRuntime: 'static + Send + Sync {
+    /// Construct a new GC heap.
+    fn new_gc_heap(&self) -> Result<Box<dyn GcHeap>>;
+
+    /// Get this collector's layout for the given array type.
+    fn array_layout(&self, ty: &WasmArrayType) -> GcArrayLayout;
+
+    /// Get this collector's layout for the given struct type.
+    fn struct_layout(&self, ty: &WasmStructType) -> GcStructLayout;
+}
+
+/// A heap that manages garbage-collected objects.
+///
+/// Each `wasmtime::Store` is associated with a single `GcHeap`, and a `GcHeap`
+/// is only ever used with one store at a time, but `GcHeap`s may be reused with
+/// new stores after its original store is dropped. The `reset` method will be
+/// called in between each such reuse. (This reuse allows for better integration
+/// with the pooling allocator).
+///
+/// If a `GcHeap` mapped any memory, its `Drop` implementation should unmap that
+/// memory.
+///
+/// # Safety
+///
+/// The trait methods below are all safe: implementations of this trait must
+/// ensure that these methods cannot be misused to create memory unsafety. The
+/// expectation is that -- given that `VMGcRef` is a newtype over an index --
+/// implementations perform similar tricks as Wasm linear memory
+/// implementations. The heap should internally be a contiguous region of memory
+/// and `VMGcRef` indices into the heap must be bounds checked (explicitly or
+/// implicitly via virtual memory tricks).
+///
+/// Furthermore, if heap corruption occurs because (for example) a `VMGcRef`
+/// from a different heap is used with this heap, then that corruption must be
+/// limited to within this heap. Every heap is a mini sandbox. It follows that
+/// native pointers should never be written into or read out from the GC heap,
+/// since that could spread corruption from inside the GC heap out to the native
+/// host heap. The host data for an `externref`, therefore, is stored in a side
+/// table (`ExternRefHostDataTable`) and never inside the heap. Only an id
+/// referencing a slot in that table should ever be written into the GC heap.
+///
+/// These constraints give us great amounts of safety compared to working with
+/// raw pointers. The worst that could happen is corruption local to heap and a
+/// panic, or perhaps reading stale heap data from a previous Wasm instance. A
+/// corrupt `GcHeap` can *never* result in the native host's corruption.
+///
+/// The downside is that we are introducing `heap_base + index` computations and
+/// bounds checking to access GC memory, adding performance overhead. This is
+/// deemed to be a worthy trade off. Furthermore, it isn't even a clear cut
+/// performance degradation since this allows us to use 32-bit "pointers",
+/// giving us more compact data representations and the improved cache
+/// utilization that implies.
+pub unsafe trait GcHeap: 'static + Send + Sync {
+    ////////////////////////////////////////////////////////////////////////////
+    // `Any` methods
+
+    /// Get this heap as an `&Any`.
+    fn as_any(&self) -> &dyn Any;
+
+    /// Get this heap as an `&mut Any`.
+    fn as_any_mut(&mut self) -> &mut dyn Any;
+
+    ////////////////////////////////////////////////////////////////////////////
+    // No-GC Scope Methods
+
+    /// Enter a no-GC scope.
+    ///
+    /// Calling the `gc` method when we are inside a no-GC scope should panic.
+    ///
+    /// We can enter multiple, nested no-GC scopes and this method should
+    /// account for that.
+    fn enter_no_gc_scope(&mut self);
+
+    /// Exit a no-GC scope.
+    ///
+    /// Dual to `enter_no_gc_scope`.
+    fn exit_no_gc_scope(&mut self);
+
+    ////////////////////////////////////////////////////////////////////////////
+    // GC Object Header Methods
+
+    /// Get a shared borrow of the `VMGcHeader` that this GC reference is
+    /// pointing to.
+    fn header(&self, gc_ref: &VMGcRef) -> &VMGcHeader;
+
+    ////////////////////////////////////////////////////////////////////////////
+    // GC Barriers
+
+    /// Read barrier called every time the runtime clones a GC reference.
+    ///
+    /// Callers should pass a valid `VMGcRef` that belongs to the given
+    /// heap. Failure to do so is memory safe, but may result in general
+    /// failures such as panics or incorrect results.
+    fn clone_gc_ref(&mut self, gc_ref: &VMGcRef) -> VMGcRef;
+
+    /// Write barrier called whenever the runtime is nulling out a GC reference.
+    ///
+    /// Default implemented in terms of the `write_gc_ref` barrier.
+    ///
+    /// If an `externref` is reclaimed, then its associated entry in the
+    /// `host_data_table` should be removed.
+    ///
+    /// Callers should pass a valid `VMGcRef` that belongs to the given
+    /// heap. Failure to do so is memory safe, but may result in general
+    /// failures such as panics or incorrect results.
+    ///
+    /// The given `gc_ref` should not be used again.
+    fn drop_gc_ref(&mut self, host_data_table: &mut ExternRefHostDataTable, gc_ref: VMGcRef) {
+        let mut dest = Some(gc_ref);
+        self.write_gc_ref(host_data_table, &mut dest, None);
+    }
+
+    /// Write barrier called every time the runtime overwrites a GC reference.
+    ///
+    /// The `source` is a borrowed GC reference, and should not have been cloned
+    /// already for this write operation. This allows implementations to fuse
+    /// the `source`'s read barrier into this write barrier.
+    ///
+    /// If an `externref` is reclaimed, then its associated entry in the
+    /// `host_data_table` should be removed.
+    ///
+    /// Callers should pass a valid `VMGcRef` that belongs to the given heap for
+    /// both the `source` and `destination`. Failure to do so is memory safe,
+    /// but may result in general failures such as panics or incorrect results.
+    fn write_gc_ref(
+        &mut self,
+        host_data_table: &mut ExternRefHostDataTable,
+        destination: &mut Option<VMGcRef>,
+        source: Option<&VMGcRef>,
+    );
+
+    /// Read barrier called whenever a GC reference is passed from the runtime
+    /// to Wasm: an argument to a host-to-Wasm call, or a return from a
+    /// Wasm-to-host call.
+    ///
+    /// Callers should pass a valid `VMGcRef` that belongs to the given
+    /// heap. Failure to do so is memory safe, but may result in general
+    /// failures such as panics or incorrect results.
+    fn expose_gc_ref_to_wasm(&mut self, gc_ref: VMGcRef);
+
+    /// Predicate invoked before calling into or returning to Wasm to determine
+    /// whether we should GC first.
+    ///
+    /// `num_gc_refs` is the number of non-`i31ref` GC references that will be
+    /// passed into Wasm.
+    fn need_gc_before_entering_wasm(&self, num_gc_refs: NonZeroUsize) -> bool;
+
+    ////////////////////////////////////////////////////////////////////////////
+    // `externref` Methods
+
+    /// Allocate a `VMExternRef` with space for host data described by the given
+    /// layout.
+    ///
+    /// Return values:
+    ///
+    /// * `Ok(Some(_))`: The allocation was successful.
+    ///
+    /// * `Ok(None)`: There is currently no available space for this
+    ///   allocation. The caller should call `self.gc()`, run the GC to
+    ///   completion so the collector can reclaim space, and then try allocating
+    ///   again.
+    ///
+    /// * `Err(_)`: The collector cannot satisfy this allocation request, and
+    ///   would not be able to even after the caller were to trigger a
+    ///   collection. This could be because, for example, the requested
+    ///   allocation is larger than this collector's implementation limit for
+    ///   object size.
+    fn alloc_externref(&mut self, host_data: ExternRefHostDataId) -> Result<Option<VMExternRef>>;
+
+    /// Get the host data ID associated with the given `externref`.
+    ///
+    /// Callers should pass a valid `externref` that belongs to the given
+    /// heap. Failure to do so is memory safe, but may result in general
+    /// failures such as panics or incorrect results.
+    fn externref_host_data(&self, externref: &VMExternRef) -> ExternRefHostDataId;
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Struct and Array methods
+
+    /// Allocate a GC-managed struct of the given type and layout.
+    ///
+    /// The struct's fields are left uninitialized. It is the caller's
+    /// responsibility to initialize them before exposing the struct to Wasm or
+    /// triggering a GC.
+    ///
+    /// The `ty` and `layout` must match.
+    ///
+    /// Failure to do either of the above is memory safe, but may result in
+    /// general failures such as panics or incorrect results.
+    ///
+    /// Return values:
+    ///
+    /// * `Ok(Some(_))`: The allocation was successful.
+    ///
+    /// * `Ok(None)`: There is currently no available space for this
+    ///   allocation. The caller should call `self.gc()`, run the GC to
+    ///   completion so the collector can reclaim space, and then try allocating
+    ///   again.
+    ///
+    /// * `Err(_)`: The collector cannot satisfy this allocation request, and
+    ///   would not be able to even after the caller were to trigger a
+    ///   collection. This could be because, for example, the requested
+    ///   allocation is larger than this collector's implementation limit for
+    ///   object size.
+    fn alloc_uninit_struct(
+        &mut self,
+        ty: VMSharedTypeIndex,
+        layout: &GcStructLayout,
+    ) -> Result<Option<VMStructRef>>;
+
+    /// Deallocate an uninitialized, GC-managed struct.
+    ///
+    /// This is useful for if initialization of the struct's fields fails, so
+    /// that the struct's allocation can be eagerly reclaimed, and so that the
+    /// collector doesn't attempt to treat any of the uninitialized fields as
+    /// valid GC references, or something like that.
+    fn dealloc_uninit_struct(&mut self, structref: VMStructRef);
+
+    /// Get a mutable borrow of the the given object's data.
+    ///
+    /// Panics on out-of-bounds accesses.
+    fn gc_object_data(&mut self, gc_ref: &VMGcRef) -> VMGcObjectDataMut<'_>;
+
+    /// Allocate a GC-managed array of the given type and length.
+    ///
+    /// The array's elements are left uninitialized. It is the caller's
+    /// responsibility to initialize them before exposing the array to Wasm or
+    /// triggering a GC. Failure to do this is memory safe, but may result in
+    /// general failures such as panics or incorrect results.
+    ///
+    /// Return values:
+    ///
+    /// * `Ok(Some(_))`: The allocation was successful.
+    ///
+    /// * `Ok(None)`: There is currently no available space for this
+    ///   allocation. The caller should call `self.gc()`, run the GC to
+    ///   completion so the collector can reclaim space, and then try allocating
+    ///   again.
+    ///
+    /// * `Err(_)`: The collector cannot satisfy this allocation request, and
+    ///   would not be able to even after the caller were to trigger a
+    ///   collection. This could be because, for example, the requested
+    ///   allocation is larger than this collector's implementation limit for
+    ///   object size.
+    fn alloc_uninit_array(
+        &mut self,
+        ty: VMSharedTypeIndex,
+        len: u32,
+        layout: &GcArrayLayout,
+    ) -> Result<Option<VMArrayRef>>;
+
+    /// Deallocate an uninitialized, GC-managed array.
+    ///
+    /// This is useful for if initialization of the array's fields fails, so
+    /// that the array's allocation can be eagerly reclaimed, and so that the
+    /// collector doesn't attempt to treat any of the uninitialized fields as
+    /// valid GC references, or something like that.
+    fn dealloc_uninit_array(&mut self, arrayref: VMArrayRef);
+
+    /// Get the length of the given array.
+    ///
+    /// Panics on out-of-bounds accesses.
+    ///
+    /// The given `arrayref` should be valid and of the given size. Failure to
+    /// do so is memory safe, but may result in general failures such as panics
+    /// or incorrect results.
+    fn array_len(&self, arrayref: &VMArrayRef) -> u32;
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Garbage Collection Methods
+
+    /// Start a new garbage collection process.
+    ///
+    /// The given `roots` are GC roots and should not be collected (nor anything
+    /// transitively reachable from them).
+    ///
+    /// Upon reclaiming an `externref`, its associated entry in the
+    /// `host_data_table` is removed.
+    ///
+    /// Callers should pass valid GC roots that belongs to this heap, and the
+    /// host data table associated with this heap's `externref`s. Failure to do
+    /// so is memory safe, but may result in general failures such as panics or
+    /// incorrect results.
+    ///
+    /// This method should panic if we are in a no-GC scope.
+    fn gc<'a>(
+        &'a mut self,
+        roots: GcRootsIter<'a>,
+        host_data_table: &'a mut ExternRefHostDataTable,
+    ) -> Box<dyn GarbageCollection<'a> + 'a>;
+
+    ////////////////////////////////////////////////////////////////////////////
+    // JIT-Code Interaction Methods
+
+    /// Get the GC heap's base pointer.
+    ///
+    /// # Safety
+    ///
+    /// The memory region
+    ///
+    /// ```ignore
+    /// self.vmctx_gc_heap_base..self.vmctx_gc_heap_base + self.vmctx_gc_heap_bound
+    /// ```
+    ///
+    /// must be the GC heap region, and must remain valid for JIT code as long
+    /// as `self` is not dropped.
+    unsafe fn vmctx_gc_heap_base(&self) -> *mut u8;
+
+    /// Get the GC heap's bound.
+    ///
+    /// # Safety
+    ///
+    /// The memory region
+    ///
+    /// ```ignore
+    /// self.vmctx_gc_heap_base..self.vmctx_gc_heap_base + self.vmctx_gc_heap_bound
+    /// ```
+    ///
+    /// must be the GC heap region, and must remain valid for JIT code as long
+    /// as `self` is not dropped.
+    unsafe fn vmctx_gc_heap_bound(&self) -> usize;
+
+    /// Get the pointer that will be stored in the `VMContext::gc_heap_data`
+    /// field and be accessible from JIT code via collaboration with the
+    /// corresponding `GcCompiler` trait.
+    ///
+    /// # Safety
+    ///
+    /// The returned pointer, if any, must remain valid as long as `self` is not
+    /// dropped.
+    unsafe fn vmctx_gc_heap_data(&self) -> *mut u8;
+
+    ////////////////////////////////////////////////////////////////////////////
+    // Recycling GC Heap Methods
+
+    /// Reset this heap.
+    ///
+    /// Calling this method unassociates this heap with the store that it has
+    /// been associated with, making it available to be associated with a new
+    /// heap.
+    ///
+    /// This should refill free lists, reset bump pointers, and etc... as if
+    /// nothing were allocated in this heap (because nothing is allocated in
+    /// this heap anymore).
+    ///
+    /// This should retain any allocated memory from the global allocator and
+    /// any virtual memory mappings.
+    ///
+    /// This method is only used with the pooling allocator.
+    #[cfg(feature = "pooling-allocator")]
+    fn reset(&mut self);
+}
+
+/// The layout of a GC-managed object.
+#[derive(Clone, Debug)]
+pub enum GcLayout {
+    /// The layout of a GC-managed array object.
+    #[allow(dead_code)] // Not used yet, but added for completeness.
+    Array(GcArrayLayout),
+
+    /// The layout of a GC-managed struct object.
+    Struct(GcStructLayout),
+}
+
+impl From<GcArrayLayout> for GcLayout {
+    fn from(layout: GcArrayLayout) -> Self {
+        Self::Array(layout)
+    }
+}
+
+impl From<GcStructLayout> for GcLayout {
+    fn from(layout: GcStructLayout) -> Self {
+        Self::Struct(layout)
+    }
+}
+
+impl GcLayout {
+    /// Get the underlying `GcStructLayout`, or panic.
+    #[track_caller]
+    pub fn unwrap_struct(&self) -> &GcStructLayout {
+        match self {
+            Self::Struct(s) => s,
+            _ => panic!("GcLayout::unwrap_struct on non-struct GC layout"),
+        }
+    }
+
+    /// Get the underlying `GcArrayLayout`, or panic.
+    #[track_caller]
+    pub fn unwrap_array(&self) -> &GcArrayLayout {
+        match self {
+            Self::Array(a) => a,
+            _ => panic!("GcLayout::unwrap_array on non-array GC layout"),
+        }
+    }
+}
+
+/// The layout of a GC-managed array.
+///
+/// This layout is only valid for use with the GC runtime that created it. It is
+/// not valid to use one GC runtime's layout with another GC runtime, doing so
+/// is memory safe but will lead to general incorrectness like panics and wrong
+/// results.
+///
+/// All offsets are from the start of the object; that is, the size of the GC
+/// header (for example) is included in the offset.
+///
+/// All arrays are composed of the generic `VMGcHeader`, followed by
+/// collector-specific fields, followed by the contiguous array elements
+/// themselves. The array elements must be aligned to the element type's natural
+/// alignment.
+#[derive(Clone, Debug)]
+#[allow(dead_code)] // Not used yet, but added for completeness.
+pub struct GcArrayLayout {
+    /// The size of this array object, ignoring its elements.
+    pub size: u32,
+
+    /// The alignment of this array.
+    pub align: u32,
+
+    /// The offset of the array's length.
+    pub length_field_offset: u32,
+
+    /// The offset from where this array's contiguous elements begin.
+    pub elems_offset: u32,
+
+    /// The size and natural alignment of each element in this array.
+    pub elem_size: u32,
+}
+
+impl GcArrayLayout {
+    /// Get the total size of this array for a given length of elements.
+    pub fn size_for_len(&self, len: u32) -> u32 {
+        self.size + len * self.elem_size
+    }
+
+    /// Get the offset of the `i`th element in an array with this layout.
+    #[inline]
+    pub fn elem_offset(&self, i: u32, elem_size: u32) -> u32 {
+        self.elems_offset + i * elem_size
+    }
+}
+
+/// The layout for a GC-managed struct type.
+///
+/// This layout is only valid for use with the GC runtime that created it. It is
+/// not valid to use one GC runtime's layout with another GC runtime, doing so
+/// is memory safe but will lead to general incorrectness like panics and wrong
+/// results.
+///
+/// All offsets are from the start of the object; that is, the size of the GC
+/// header (for example) is included in the offset.
+#[derive(Clone, Debug)]
+pub struct GcStructLayout {
+    /// The size of this struct.
+    pub size: u32,
+
+    /// The alignment of this struct.
+    pub align: u32,
+
+    /// The fields of this struct. The `i`th entry is the `i`th struct field's
+    /// offset in the struct.
+    pub fields: Vec<u32>,
+}
+
+/// A list of GC roots.
+///
+/// This is effectively a builder for a `GcRootsIter` that will be given to a GC
+/// heap when it is time to perform garbage collection.
+#[derive(Default)]
+pub struct GcRootsList(Vec<RawGcRoot>);
+
+// Ideally these `*mut`s would be `&mut`s and we wouldn't need as much of this
+// machinery around `GcRootsList`, `RawGcRoot`, `GcRoot`, and `GcRootIter` but
+// if we try that then we run into two different kinds of lifetime issues:
+//
+// 1. When collecting the various roots from a `&mut StoreOpaque`, we borrow
+//    from `self` to push new GC roots onto the roots list. But then we want to
+//    call helper methods like `self.for_each_global(...)`, but we can't because
+//    there are active borrows of `self` preventing it.
+//
+// 2. We want to reuse the roots list and its backing storage across GCs, rather
+//    than reallocate on every GC. But the only place for the roots list to live
+//    such that it is easily reusable across GCs is in the store itself. But the
+//    contents of the roots list (when it is non-empty, during GCs) borrow from
+//    the store, which creates self-references.
+#[derive(Clone, Copy, Debug)]
+enum RawGcRoot {
+    Stack(SendSyncPtr<u32>),
+    NonStack(SendSyncPtr<VMGcRef>),
+}
+
+impl GcRootsList {
+    /// Add a GC root that is inside a Wasm stack frame to this list.
+    #[inline]
+    pub unsafe fn add_wasm_stack_root(&mut self, ptr_to_root: SendSyncPtr<u32>) {
+        log::trace!(
+            "Adding Wasm stack root: {:#p} -> {:#p}",
+            ptr_to_root,
+            VMGcRef::from_raw_u32(*ptr_to_root.as_ref()).unwrap()
+        );
+        debug_assert!(VMGcRef::from_raw_u32(*ptr_to_root.as_ref()).is_some());
+        self.0.push(RawGcRoot::Stack(ptr_to_root));
+    }
+
+    /// Add a GC root to this list.
+    #[inline]
+    pub unsafe fn add_root(&mut self, ptr_to_root: SendSyncPtr<VMGcRef>, why: &str) {
+        log::trace!(
+            "Adding non-stack root: {why}: {:#p}",
+            ptr_to_root.as_ref().unchecked_copy()
+        );
+        self.0.push(RawGcRoot::NonStack(ptr_to_root))
+    }
+
+    /// Get an iterator over all roots in this list.
+    ///
+    /// # Safety
+    ///
+    /// Callers must ensure that all the pointers to GC roots that have been
+    /// added to this list are valid for the duration of the `'a` lifetime.
+    #[inline]
+    pub unsafe fn iter<'a>(&'a mut self) -> GcRootsIter<'a> {
+        GcRootsIter {
+            list: self,
+            index: 0,
+        }
+    }
+
+    /// Is this list empty?
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
+    /// Clear this GC roots list.
+    #[inline]
+    pub fn clear(&mut self) {
+        self.0.clear();
+    }
+}
+
+/// An iterator over all the roots in a `GcRootsList`.
+pub struct GcRootsIter<'a> {
+    list: &'a mut GcRootsList,
+    index: usize,
+}
+
+impl<'a> Iterator for GcRootsIter<'a> {
+    type Item = GcRoot<'a>;
+
+    #[inline]
+    fn next(&mut self) -> Option<Self::Item> {
+        let root = GcRoot {
+            raw: self.list.0.get(self.index).copied()?,
+            _phantom: marker::PhantomData,
+        };
+        self.index += 1;
+        Some(root)
+    }
+}
+
+/// A GC root.
+///
+/// This is, effectively, a mutable reference to a `VMGcRef`.
+///
+/// Collector implementations should update the `VMGcRef` if they move the
+/// `VMGcRef`'s referent during the course of a GC.
+#[derive(Debug)]
+pub struct GcRoot<'a> {
+    raw: RawGcRoot,
+    _phantom: marker::PhantomData<&'a mut VMGcRef>,
+}
+
+impl GcRoot<'_> {
+    /// Is this root from inside a Wasm stack frame?
+    #[inline]
+    pub fn is_on_wasm_stack(&self) -> bool {
+        matches!(self.raw, RawGcRoot::Stack(_))
+    }
+
+    /// Get this GC root.
+    ///
+    /// Does NOT run GC barriers.
+    #[inline]
+    pub fn get(&self) -> VMGcRef {
+        match self.raw {
+            RawGcRoot::NonStack(ptr) => unsafe { ptr::read(ptr.as_ptr()) },
+            RawGcRoot::Stack(ptr) => unsafe {
+                let raw: u32 = ptr::read(ptr.as_ptr());
+                VMGcRef::from_raw_u32(raw).expect("non-null")
+            },
+        }
+    }
+
+    /// Set this GC root.
+    ///
+    /// Does NOT run GC barriers.
+    ///
+    /// Collector implementations should use this method to update GC root
+    /// pointers after the collector moves the GC object that the root is
+    /// referencing.
+    pub fn set(&mut self, new_ref: VMGcRef) {
+        match self.raw {
+            RawGcRoot::NonStack(ptr) => unsafe {
+                ptr::write(ptr.as_ptr(), new_ref);
+            },
+            RawGcRoot::Stack(ptr) => unsafe {
+                ptr::write(ptr.as_ptr(), new_ref.as_raw_u32());
+            },
+        }
+    }
+}
+
+/// A garbage collection process.
+///
+/// Implementations define the `collect_increment` method, and then consumers
+/// can either use
+///
+/// * `GarbageCollection::collect` for synchronous code, or
+///
+/// * `collect_async(Box<dyn GarbageCollection>)` for async code.
+///
+/// When using fuel and/or epochs, consumers can also use `collect_increment`
+/// directly and choose to abandon further execution in this GC's heap's whole
+/// store if the GC is taking too long to complete.
+pub trait GarbageCollection<'a>: Send + Sync {
+    /// Perform an incremental slice of this garbage collection process.
+    ///
+    /// Upon completion of the slice, a `GcProgress` is returned which informs
+    /// the caller whether to continue driving this GC process forward and
+    /// executing more slices (`GcProgress::Continue`) or whether the GC process
+    /// has finished (`GcProgress::Complete`).
+    ///
+    /// The mutator does *not* run in between increments. This method exists
+    /// solely to allow cooperative yielding
+    fn collect_increment(&mut self) -> GcProgress;
+
+    /// Run this GC process to completion.
+    ///
+    /// Keeps calling `collect_increment` in a loop until the GC process is
+    /// complete.
+    fn collect(&mut self) {
+        loop {
+            match self.collect_increment() {
+                GcProgress::Continue => continue,
+                GcProgress::Complete => return,
+            }
+        }
+    }
+}
+
+/// The result of doing an incremental amount of GC.
+pub enum GcProgress {
+    /// There is still more work to do.
+    Continue,
+    /// The GC is complete.
+    Complete,
+}
+
+/// Asynchronously run the given garbage collection process to completion,
+/// cooperatively yielding back to the event loop after each increment of work.
+#[cfg(feature = "async")]
+pub async fn collect_async<'a>(mut collection: Box<dyn GarbageCollection<'a> + 'a>) {
+    loop {
+        match collection.collect_increment() {
+            GcProgress::Continue => crate::runtime::vm::Yield::new().await,
+            GcProgress::Complete => return,
+        }
+    }
+}
+
+#[cfg(all(test, feature = "async"))]
+mod collect_async_tests {
+    use super::*;
+
+    #[test]
+    fn is_send_and_sync() {
+        fn _assert_send_sync<T: Send + Sync>(_: T) {}
+
+        fn _foo<'a>(collection: Box<dyn GarbageCollection<'a>>) {
+            _assert_send_sync(collect_async(collection));
+        }
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/gc/host_data.rs b/crates/wasmtime/src/runtime/vm/gc/host_data.rs
new file mode 100644
index 000000000000..4d7044c48886
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/gc/host_data.rs
@@ -0,0 +1,82 @@
+//! Implementation of the side table for `externref` host data.
+//!
+//! The actual host data is kept in a side table, rather than inside the GC
+//! heap, because we do not trust any data coming from the GC heap. If we
+//! constructed `&dyn Any`s from GC heap data and called any function loaded
+//! from the `dyn Any`'s vtable, then any bug in our collector could lead to
+//! corrupted vtables, which could lead to security vulnerabilities and sandbox
+//! escapes.
+//!
+//! Much better to store host data IDs inside the GC heap, and then do checked
+//! accesses into the host data table from those untrusted IDs. At worst, we can
+//! return the wrong (but still valid) host data object or panic. This is way
+//! less catastrophic than doing an indirect call to an attacker-controlled
+//! function pointer.
+
+use crate::prelude::*;
+use core::any::Any;
+use wasmtime_slab::{Id, Slab};
+
+/// Side table for each `externref`'s host data value.
+#[derive(Default)]
+pub struct ExternRefHostDataTable {
+    slab: Slab<Box<dyn Any + Send + Sync>>,
+}
+
+/// ID into the `externref` host data table.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct ExternRefHostDataId(Id);
+
+fn deref_box<T: ?Sized>(b: &Box<T>) -> &T {
+    &**b
+}
+
+fn deref_box_mut<T: ?Sized>(b: &mut Box<T>) -> &mut T {
+    &mut **b
+}
+
+impl ExternRefHostDataTable {
+    /// Allocate a new `externref` host data value.
+    pub fn alloc(&mut self, value: Box<dyn Any + Send + Sync>) -> ExternRefHostDataId {
+        let id = self.slab.alloc(value);
+        let id = ExternRefHostDataId(id);
+        log::trace!("allocated new externref host data: {id:?}");
+        id
+    }
+
+    /// Deallocate an `externref` host data value.
+    pub fn dealloc(&mut self, id: ExternRefHostDataId) -> Box<dyn Any + Send + Sync> {
+        log::trace!("deallocated externref host data: {id:?}");
+        self.slab.dealloc(id.0)
+    }
+
+    /// Get a shared borrow of the host data associated with the given ID.
+    pub fn get(&self, id: ExternRefHostDataId) -> &(dyn Any + Send + Sync) {
+        let data: &Box<dyn Any + Send + Sync> = self.slab.get(id.0).unwrap();
+        deref_box(data)
+    }
+
+    /// Get a mutable borrow of the host data associated with the given ID.
+    pub fn get_mut(&mut self, id: ExternRefHostDataId) -> &mut (dyn Any + Send + Sync) {
+        let data: &mut Box<dyn Any + Send + Sync> = self.slab.get_mut(id.0).unwrap();
+        deref_box_mut(data)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn correct_dyn_object() {
+        let mut table = ExternRefHostDataTable::default();
+
+        let x = 42_u32;
+        let id = table.alloc(Box::new(x));
+        assert!(table.get(id).is::<u32>());
+        assert_eq!(*table.get(id).downcast_ref::<u32>().unwrap(), 42);
+        assert!(table.get_mut(id).is::<u32>());
+        assert_eq!(*table.get_mut(id).downcast_ref::<u32>().unwrap(), 42);
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/gc/i31.rs b/crates/wasmtime/src/runtime/vm/gc/i31.rs
new file mode 100644
index 000000000000..e79ece0c3f93
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/gc/i31.rs
@@ -0,0 +1,87 @@
+//! Implementation of unboxed 31-bit integers.
+
+use super::VMGcRef;
+use core::fmt;
+
+/// A 31-bit integer for use with `i31ref`.
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+pub struct I31(pub(super) u32);
+
+impl Default for I31 {
+    #[inline]
+    fn default() -> Self {
+        Self::wrapping_u32(0)
+    }
+}
+
+impl fmt::Debug for I31 {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("I31")
+            .field("as_u32", &self.get_u32())
+            .field("as_i32", &self.get_i32())
+            .finish()
+    }
+}
+
+impl I31 {
+    const DISCRIMINANT: u32 = VMGcRef::I31_REF_DISCRIMINANT;
+
+    /// Construct a new `I31` from the given unsigned value.
+    ///
+    /// Returns `None` if the value does not fit in the bottom 31 bits.
+    #[inline]
+    pub fn new_u32(value: u32) -> Option<Self> {
+        if ((value << 1) >> 1) == value {
+            let i31 = Self::wrapping_u32(value);
+            debug_assert_eq!(i31.get_u32(), value);
+            Some(i31)
+        } else {
+            None
+        }
+    }
+
+    /// Construct a new `I31` from the given signed value.
+    ///
+    /// Returns `None` if the value does not fit in the bottom 31 bits.
+    #[inline]
+    pub fn new_i32(value: i32) -> Option<Self> {
+        if ((value << 1) >> 1) == value {
+            let i31 = Self::wrapping_i32(value);
+            debug_assert_eq!(i31.get_i32(), value);
+            Some(i31)
+        } else {
+            None
+        }
+    }
+
+    /// Construct a new `I31` from the given unsigned value.
+    ///
+    /// If the value doesn't fit in the bottom 31 bits, it is wrapped such that
+    /// the wrapped value does.
+    #[inline]
+    pub fn wrapping_u32(value: u32) -> Self {
+        Self((value << 1) | Self::DISCRIMINANT)
+    }
+
+    /// Construct a new `I31` from the given signed value.
+    ///
+    /// If the value doesn't fit in the bottom 31 bits, it is wrapped such that
+    /// the wrapped value does.
+    #[inline]
+    #[allow(clippy::cast_sign_loss)]
+    pub fn wrapping_i32(value: i32) -> Self {
+        Self::wrapping_u32(value as u32)
+    }
+
+    /// Get this `I31`'s value as an unsigned integer.
+    #[inline]
+    pub fn get_u32(&self) -> u32 {
+        self.0 >> 1
+    }
+
+    /// Get this `I31`'s value as ansigned integer.
+    #[inline]
+    pub fn get_i32(&self) -> i32 {
+        (self.0 as i32) >> 1
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/helpers.c b/crates/wasmtime/src/runtime/vm/helpers.c
new file mode 100644
index 000000000000..08fcfeb75018
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/helpers.c
@@ -0,0 +1,113 @@
+#include <setjmp.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#if (defined(__GNUC__) && !defined(__clang__))
+#define WASMTIME_GCC 1
+#endif
+
+#ifdef CFG_TARGET_OS_windows
+
+// Windows is required to use normal `setjmp` and `longjmp`.
+#define platform_setjmp(buf) setjmp(buf)
+#define platform_longjmp(buf, arg) longjmp(buf, arg)
+typedef jmp_buf platform_jmp_buf;
+
+#elif defined(WASMTIME_GCC) || defined(__x86_64__)
+
+// clang-format off
+
+// GCC and Clang on x86_64 provide `__builtin_setjmp`/`__builtin_longjmp`, which
+// differ from plain `setjmp` and `longjmp` in that they're implemented by
+// the compiler inline rather than in libc, and the compiler can avoid saving
+// and restoring most of the registers. See the [GCC docs] and [clang docs]
+// for more information.
+//
+// Per the caveat in the GCC docs, this assumes that the host compiler (which
+// may be compiling for a generic architecture family) knows about all the
+// register state that Cranelift (which may be specializing for the hardware at
+// runtime) is assuming is callee-saved.
+//
+// [GCC docs]: https://gcc.gnu.org/onlinedocs/gcc/Nonlocal-Gotos.html
+// [clang docs]: https://llvm.org/docs/ExceptionHandling.html#llvm-eh-sjlj-setjmp
+
+// clang-format on
+#define platform_setjmp(buf) __builtin_setjmp(buf)
+#define platform_longjmp(buf, arg) __builtin_longjmp(buf, arg)
+typedef void *platform_jmp_buf[5]; // this is the documented size; see the docs
+                                   // links for details.
+
+#else
+
+// All other platforms/compilers funnel in here.
+//
+// Note that `sigsetjmp` and `siglongjmp` are used here where possible to
+// explicitly pass a 0 argument to `sigsetjmp` that we don't need to preserve
+// the process signal mask. This should make this call a bit faster b/c it
+// doesn't need to touch the kernel signal handling routines.
+#define platform_setjmp(buf) sigsetjmp(buf, 0)
+#define platform_longjmp(buf, arg) siglongjmp(buf, arg)
+typedef sigjmp_buf platform_jmp_buf;
+
+#endif
+
+#define CONCAT2(a, b) a##b
+#define CONCAT(a, b) CONCAT2(a, b)
+#define VERSIONED_SYMBOL(a) CONCAT(a, VERSIONED_SUFFIX)
+
+int VERSIONED_SYMBOL(wasmtime_setjmp)(void **buf_storage,
+                                      void (*body)(void *, void *),
+                                      void *payload, void *callee) {
+  platform_jmp_buf buf;
+  if (platform_setjmp(buf) != 0) {
+    return 0;
+  }
+  *buf_storage = &buf;
+  body(payload, callee);
+  return 1;
+}
+
+void VERSIONED_SYMBOL(wasmtime_longjmp)(void *JmpBuf) {
+  platform_jmp_buf *buf = (platform_jmp_buf *)JmpBuf;
+  platform_longjmp(*buf, 1);
+}
+
+#ifdef CFG_TARGET_OS_windows
+// export required for external access.
+__declspec(dllexport)
+#else
+// Note the `weak` linkage here, though, which is intended to let other code
+// override this symbol if it's defined elsewhere, since this definition doesn't
+// matter.
+// Just in case cross-language LTO is enabled we set the `noinline` attribute
+// and also try to have some sort of side effect in this function with a dummy
+// `asm` statement.
+__attribute__((weak, noinline))
+#endif
+    void __jit_debug_register_code() {
+#ifndef CFG_TARGET_OS_windows
+  __asm__("");
+#endif
+}
+
+struct JITDescriptor {
+  uint32_t version_;
+  uint32_t action_flag_;
+  void *relevant_entry_;
+  void *first_entry_;
+};
+
+#ifdef CFG_TARGET_OS_windows
+// export required for external access.
+__declspec(dllexport)
+#else
+// Note the `weak` linkage here which is the same purpose as above. We want to
+// let other runtimes be able to override this since our own definition isn't
+// important.
+__attribute__((weak))
+#endif
+    struct JITDescriptor __jit_debug_descriptor = {1, 0, NULL, NULL};
+
+struct JITDescriptor *VERSIONED_SYMBOL(wasmtime_jit_debug_descriptor)() {
+  return &__jit_debug_descriptor;
+}
diff --git a/crates/runtime/src/imports.rs b/crates/wasmtime/src/runtime/vm/imports.rs
similarity index 89%
rename from crates/runtime/src/imports.rs
rename to crates/wasmtime/src/runtime/vm/imports.rs
index fe6031293e4e..a1b47e17d9f4 100644
--- a/crates/runtime/src/imports.rs
+++ b/crates/wasmtime/src/runtime/vm/imports.rs
@@ -1,4 +1,6 @@
-use crate::vmcontext::{VMFunctionImport, VMGlobalImport, VMMemoryImport, VMTableImport};
+use crate::runtime::vm::vmcontext::{
+    VMFunctionImport, VMGlobalImport, VMMemoryImport, VMTableImport,
+};
 
 /// Resolved import pointers.
 ///
diff --git a/crates/wasmtime/src/runtime/vm/instance.rs b/crates/wasmtime/src/runtime/vm/instance.rs
new file mode 100644
index 000000000000..fe3fbe6a2430
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/instance.rs
@@ -0,0 +1,1518 @@
+//! An `Instance` contains all the runtime state used by execution of a
+//! wasm module (except its callstack and register state). An
+//! `InstanceHandle` is a reference-counting handle for an `Instance`.
+
+use crate::prelude::*;
+use crate::runtime::vm::const_expr::{ConstEvalContext, ConstExprEvaluator};
+use crate::runtime::vm::export::Export;
+use crate::runtime::vm::memory::{Memory, RuntimeMemoryCreator};
+use crate::runtime::vm::table::{Table, TableElement, TableElementType};
+use crate::runtime::vm::vmcontext::{
+    VMBuiltinFunctionsArray, VMContext, VMFuncRef, VMFunctionImport, VMGlobalDefinition,
+    VMGlobalImport, VMMemoryDefinition, VMMemoryImport, VMOpaqueContext, VMRuntimeLimits,
+    VMTableDefinition, VMTableImport,
+};
+use crate::runtime::vm::{
+    ExportFunction, ExportGlobal, ExportMemory, ExportTable, GcStore, Imports, ModuleRuntimeInfo,
+    SendSyncPtr, Store, VMFunctionBody, VMGcRef, WasmFault,
+};
+use alloc::sync::Arc;
+use core::alloc::Layout;
+use core::any::Any;
+use core::ops::Range;
+use core::ptr::NonNull;
+use core::sync::atomic::AtomicU64;
+use core::{mem, ptr};
+use sptr::Strict;
+use wasmtime_environ::{
+    packed_option::ReservedValue, DataIndex, DefinedGlobalIndex, DefinedMemoryIndex,
+    DefinedTableIndex, ElemIndex, EntityIndex, EntityRef, EntitySet, FuncIndex, GlobalIndex,
+    HostPtr, MemoryIndex, MemoryPlan, Module, ModuleInternedTypeIndex, PrimaryMap, PtrSize,
+    TableIndex, TableInitialValue, TableSegmentElements, Trap, VMOffsets, VMSharedTypeIndex,
+    WasmHeapTopType, VMCONTEXT_MAGIC,
+};
+#[cfg(feature = "wmemcheck")]
+use wasmtime_wmemcheck::Wmemcheck;
+
+mod allocator;
+
+pub use allocator::*;
+
+/// A type that roughly corresponds to a WebAssembly instance, but is also used
+/// for host-defined objects.
+///
+/// This structure is is never allocated directly but is instead managed through
+/// an `InstanceHandle`. This structure ends with a `VMContext` which has a
+/// dynamic size corresponding to the `module` configured within. Memory
+/// management of this structure is always externalized.
+///
+/// Instances here can correspond to actual instantiated modules, but it's also
+/// used ubiquitously for host-defined objects. For example creating a
+/// host-defined memory will have a `module` that looks like it exports a single
+/// memory (and similar for other constructs).
+///
+/// This `Instance` type is used as a ubiquitous representation for WebAssembly
+/// values, whether or not they were created on the host or through a module.
+#[repr(C)] // ensure that the vmctx field is last.
+pub struct Instance {
+    /// The runtime info (corresponding to the "compiled module"
+    /// abstraction in higher layers) that is retained and needed for
+    /// lazy initialization. This provides access to the underlying
+    /// Wasm module entities, the compiled JIT code, metadata about
+    /// functions, lazy initialization state, etc.
+    runtime_info: ModuleRuntimeInfo,
+
+    /// WebAssembly linear memory data.
+    ///
+    /// This is where all runtime information about defined linear memories in
+    /// this module lives.
+    ///
+    /// The `MemoryAllocationIndex` was given from our `InstanceAllocator` and
+    /// must be given back to the instance allocator when deallocating each
+    /// memory.
+    memories: PrimaryMap<DefinedMemoryIndex, (MemoryAllocationIndex, Memory)>,
+
+    /// WebAssembly table data.
+    ///
+    /// Like memories, this is only for defined tables in the module and
+    /// contains all of their runtime state.
+    ///
+    /// The `TableAllocationIndex` was given from our `InstanceAllocator` and
+    /// must be given back to the instance allocator when deallocating each
+    /// table.
+    tables: PrimaryMap<DefinedTableIndex, (TableAllocationIndex, Table)>,
+
+    /// Stores the dropped passive element segments in this instantiation by index.
+    /// If the index is present in the set, the segment has been dropped.
+    dropped_elements: EntitySet<ElemIndex>,
+
+    /// Stores the dropped passive data segments in this instantiation by index.
+    /// If the index is present in the set, the segment has been dropped.
+    dropped_data: EntitySet<DataIndex>,
+
+    /// Hosts can store arbitrary per-instance information here.
+    ///
+    /// Most of the time from Wasmtime this is `Box::new(())`, a noop
+    /// allocation, but some host-defined objects will store their state here.
+    host_state: Box<dyn Any + Send + Sync>,
+
+    /// A pointer to the `vmctx` field at the end of the `Instance`.
+    ///
+    /// If you're looking at this a reasonable question would be "why do we need
+    /// a pointer to ourselves?" because after all the pointer's value is
+    /// trivially derivable from any `&Instance` pointer. The rationale for this
+    /// field's existence is subtle, but it's required for correctness. The
+    /// short version is "this makes miri happy".
+    ///
+    /// The long version of why this field exists is that the rules that MIRI
+    /// uses to ensure pointers are used correctly have various conditions on
+    /// them depend on how pointers are used. More specifically if `*mut T` is
+    /// derived from `&mut T`, then that invalidates all prior pointers drived
+    /// from the `&mut T`. This means that while we liberally want to re-acquire
+    /// a `*mut VMContext` throughout the implementation of `Instance` the
+    /// trivial way, a function `fn vmctx(&mut Instance) -> *mut VMContext`
+    /// would effectively invalidate all prior `*mut VMContext` pointers
+    /// acquired. The purpose of this field is to serve as a sort of
+    /// source-of-truth for where `*mut VMContext` pointers come from.
+    ///
+    /// This field is initialized when the `Instance` is created with the
+    /// original allocation's pointer. That means that the provenance of this
+    /// pointer contains the entire allocation (both instance and `VMContext`).
+    /// This provenance bit is then "carried through" where `fn vmctx` will base
+    /// all returned pointers on this pointer itself. This provides the means of
+    /// never invalidating this pointer throughout MIRI and additionally being
+    /// able to still temporarily have `&mut Instance` methods and such.
+    ///
+    /// It's important to note, though, that this is not here purely for MIRI.
+    /// The careful construction of the `fn vmctx` method has ramifications on
+    /// the LLVM IR generated, for example. A historical CVE on Wasmtime,
+    /// GHSA-ch89-5g45-qwc7, was caused due to relying on undefined behavior. By
+    /// deriving VMContext pointers from this pointer it specifically hints to
+    /// LLVM that trickery is afoot and it properly informs `noalias` and such
+    /// annotations and analysis. More-or-less this pointer is actually loaded
+    /// in LLVM IR which helps defeat otherwise present aliasing optimizations,
+    /// which we want, since writes to this should basically never be optimized
+    /// out.
+    ///
+    /// As a final note it's worth pointing out that the machine code generated
+    /// for accessing `fn vmctx` is still as one would expect. This member isn't
+    /// actually ever loaded at runtime (or at least shouldn't be). Perhaps in
+    /// the future if the memory consumption of this field is a problem we could
+    /// shrink it slightly, but for now one extra pointer per wasm instance
+    /// seems not too bad.
+    vmctx_self_reference: SendSyncPtr<VMContext>,
+
+    // TODO: add support for multiple memories; `wmemcheck_state` corresponds to
+    // memory 0.
+    #[cfg(feature = "wmemcheck")]
+    pub(crate) wmemcheck_state: Option<Wmemcheck>,
+
+    /// Additional context used by compiled wasm code. This field is last, and
+    /// represents a dynamically-sized array that extends beyond the nominal
+    /// end of the struct (similar to a flexible array member).
+    vmctx: VMContext,
+}
+
+impl Instance {
+    /// Create an instance at the given memory address.
+    ///
+    /// It is assumed the memory was properly aligned and the
+    /// allocation was `alloc_size` in bytes.
+    unsafe fn new(
+        req: InstanceAllocationRequest,
+        memories: PrimaryMap<DefinedMemoryIndex, (MemoryAllocationIndex, Memory)>,
+        tables: PrimaryMap<DefinedTableIndex, (TableAllocationIndex, Table)>,
+        memory_plans: &PrimaryMap<MemoryIndex, MemoryPlan>,
+    ) -> InstanceHandle {
+        // The allocation must be *at least* the size required of `Instance`.
+        let layout = Self::alloc_layout(req.runtime_info.offsets());
+        let ptr = alloc::alloc::alloc(layout);
+        if ptr.is_null() {
+            alloc::alloc::handle_alloc_error(layout);
+        }
+        let ptr = ptr.cast::<Instance>();
+
+        let module = req.runtime_info.module();
+        let dropped_elements = EntitySet::with_capacity(module.passive_elements.len());
+        let dropped_data = EntitySet::with_capacity(module.passive_data_map.len());
+
+        #[cfg(not(feature = "wmemcheck"))]
+        let _ = memory_plans;
+
+        ptr::write(
+            ptr,
+            Instance {
+                runtime_info: req.runtime_info.clone(),
+                memories,
+                tables,
+                dropped_elements,
+                dropped_data,
+                host_state: req.host_state,
+                vmctx_self_reference: SendSyncPtr::new(NonNull::new(ptr.add(1).cast()).unwrap()),
+                vmctx: VMContext {
+                    _marker: core::marker::PhantomPinned,
+                },
+                #[cfg(feature = "wmemcheck")]
+                wmemcheck_state: {
+                    if req.wmemcheck {
+                        let size = memory_plans
+                            .iter()
+                            .next()
+                            .map(|plan| plan.1.memory.minimum)
+                            .unwrap_or(0)
+                            * 64
+                            * 1024;
+                        Some(Wmemcheck::new(size as usize))
+                    } else {
+                        None
+                    }
+                },
+            },
+        );
+
+        (*ptr).initialize_vmctx(module, req.runtime_info.offsets(), req.store, req.imports);
+        InstanceHandle {
+            instance: Some(SendSyncPtr::new(NonNull::new(ptr).unwrap())),
+        }
+    }
+
+    /// Converts the provided `*mut VMContext` to an `Instance` pointer and runs
+    /// the provided closure with the instance.
+    ///
+    /// This method will move the `vmctx` pointer backwards to point to the
+    /// original `Instance` that precedes it. The closure is provided a
+    /// temporary version of the `Instance` pointer with a constrained lifetime
+    /// to the closure to ensure it doesn't accidentally escape.
+    ///
+    /// # Unsafety
+    ///
+    /// Callers must validate that the `vmctx` pointer is a valid allocation
+    /// and that it's valid to acquire `&mut Instance` at this time. For example
+    /// this can't be called twice on the same `VMContext` to get two active
+    /// pointers to the same `Instance`.
+    #[inline]
+    pub unsafe fn from_vmctx<R>(vmctx: *mut VMContext, f: impl FnOnce(&mut Instance) -> R) -> R {
+        debug_assert!(!vmctx.is_null());
+        let ptr = vmctx
+            .byte_sub(mem::size_of::<Instance>())
+            .cast::<Instance>();
+        f(&mut *ptr)
+    }
+
+    /// Helper function to access various locations offset from our `*mut
+    /// VMContext` object.
+    ///
+    /// # Safety
+    ///
+    /// This method is unsafe because the `offset` must be within bounds of the
+    /// `VMContext` object trailing this instance.
+    unsafe fn vmctx_plus_offset<T>(&self, offset: impl Into<u32>) -> *const T {
+        self.vmctx()
+            .byte_add(usize::try_from(offset.into()).unwrap())
+            .cast()
+    }
+
+    /// Dual of `vmctx_plus_offset`, but for mutability.
+    unsafe fn vmctx_plus_offset_mut<T>(&mut self, offset: impl Into<u32>) -> *mut T {
+        self.vmctx()
+            .byte_add(usize::try_from(offset.into()).unwrap())
+            .cast()
+    }
+
+    pub(crate) fn module(&self) -> &Arc<Module> {
+        self.runtime_info.module()
+    }
+
+    /// Translate a module-level interned type index into an engine-level
+    /// interned type index.
+    pub fn engine_type_index(&self, module_index: ModuleInternedTypeIndex) -> VMSharedTypeIndex {
+        self.runtime_info.engine_type_index(module_index)
+    }
+
+    #[inline]
+    fn offsets(&self) -> &VMOffsets<HostPtr> {
+        self.runtime_info.offsets()
+    }
+
+    /// Return the indexed `VMFunctionImport`.
+    fn imported_function(&self, index: FuncIndex) -> &VMFunctionImport {
+        unsafe { &*self.vmctx_plus_offset(self.offsets().vmctx_vmfunction_import(index)) }
+    }
+
+    /// Return the index `VMTableImport`.
+    fn imported_table(&self, index: TableIndex) -> &VMTableImport {
+        unsafe { &*self.vmctx_plus_offset(self.offsets().vmctx_vmtable_import(index)) }
+    }
+
+    /// Return the indexed `VMMemoryImport`.
+    fn imported_memory(&self, index: MemoryIndex) -> &VMMemoryImport {
+        unsafe { &*self.vmctx_plus_offset(self.offsets().vmctx_vmmemory_import(index)) }
+    }
+
+    /// Return the indexed `VMGlobalImport`.
+    fn imported_global(&self, index: GlobalIndex) -> &VMGlobalImport {
+        unsafe { &*self.vmctx_plus_offset(self.offsets().vmctx_vmglobal_import(index)) }
+    }
+
+    /// Return the indexed `VMTableDefinition`.
+    #[allow(dead_code)]
+    fn table(&mut self, index: DefinedTableIndex) -> VMTableDefinition {
+        unsafe { *self.table_ptr(index) }
+    }
+
+    /// Updates the value for a defined table to `VMTableDefinition`.
+    fn set_table(&mut self, index: DefinedTableIndex, table: VMTableDefinition) {
+        unsafe {
+            *self.table_ptr(index) = table;
+        }
+    }
+
+    /// Return the indexed `VMTableDefinition`.
+    fn table_ptr(&mut self, index: DefinedTableIndex) -> *mut VMTableDefinition {
+        unsafe { self.vmctx_plus_offset_mut(self.offsets().vmctx_vmtable_definition(index)) }
+    }
+
+    /// Get a locally defined or imported memory.
+    pub(crate) fn get_memory(&self, index: MemoryIndex) -> VMMemoryDefinition {
+        if let Some(defined_index) = self.module().defined_memory_index(index) {
+            self.memory(defined_index)
+        } else {
+            let import = self.imported_memory(index);
+            unsafe { VMMemoryDefinition::load(import.from) }
+        }
+    }
+
+    /// Get a locally defined or imported memory.
+    #[cfg(feature = "threads")]
+    pub(crate) fn get_runtime_memory(&mut self, index: MemoryIndex) -> &mut Memory {
+        if let Some(defined_index) = self.module().defined_memory_index(index) {
+            unsafe { &mut *self.get_defined_memory(defined_index) }
+        } else {
+            let import = self.imported_memory(index);
+            unsafe {
+                let ptr =
+                    Instance::from_vmctx(import.vmctx, |i| i.get_defined_memory(import.index));
+                &mut *ptr
+            }
+        }
+    }
+
+    /// Return the indexed `VMMemoryDefinition`.
+    fn memory(&self, index: DefinedMemoryIndex) -> VMMemoryDefinition {
+        unsafe { VMMemoryDefinition::load(self.memory_ptr(index)) }
+    }
+
+    /// Set the indexed memory to `VMMemoryDefinition`.
+    fn set_memory(&self, index: DefinedMemoryIndex, mem: VMMemoryDefinition) {
+        unsafe {
+            *self.memory_ptr(index) = mem;
+        }
+    }
+
+    /// Return the indexed `VMMemoryDefinition`.
+    fn memory_ptr(&self, index: DefinedMemoryIndex) -> *mut VMMemoryDefinition {
+        unsafe { *self.vmctx_plus_offset(self.offsets().vmctx_vmmemory_pointer(index)) }
+    }
+
+    /// Return the indexed `VMGlobalDefinition`.
+    fn global_ptr(&mut self, index: DefinedGlobalIndex) -> *mut VMGlobalDefinition {
+        unsafe { self.vmctx_plus_offset_mut(self.offsets().vmctx_vmglobal_definition(index)) }
+    }
+
+    /// Get a raw pointer to the global at the given index regardless whether it
+    /// is defined locally or imported from another module.
+    ///
+    /// Panics if the index is out of bound or is the reserved value.
+    pub(crate) fn defined_or_imported_global_ptr(
+        &mut self,
+        index: GlobalIndex,
+    ) -> *mut VMGlobalDefinition {
+        if let Some(index) = self.module().defined_global_index(index) {
+            self.global_ptr(index)
+        } else {
+            self.imported_global(index).from
+        }
+    }
+
+    /// Get all globals within this instance.
+    ///
+    /// Returns both import and defined globals.
+    ///
+    /// Returns both exported and non-exported globals.
+    ///
+    /// Gives access to the full globals space.
+    pub fn all_globals<'a>(
+        &'a mut self,
+    ) -> impl ExactSizeIterator<Item = (GlobalIndex, ExportGlobal)> + 'a {
+        let module = self.module().clone();
+        module.globals.keys().map(move |idx| {
+            (
+                idx,
+                ExportGlobal {
+                    definition: self.defined_or_imported_global_ptr(idx),
+                    vmctx: self.vmctx(),
+                    global: self.module().globals[idx],
+                },
+            )
+        })
+    }
+
+    /// Get the globals defined in this instance (not imported).
+    pub fn defined_globals<'a>(
+        &'a mut self,
+    ) -> impl ExactSizeIterator<Item = (DefinedGlobalIndex, ExportGlobal)> + 'a {
+        let module = self.module().clone();
+        module
+            .globals
+            .keys()
+            .skip(module.num_imported_globals)
+            .map(move |global_idx| {
+                let def_idx = module.defined_global_index(global_idx).unwrap();
+                let global = ExportGlobal {
+                    definition: self.global_ptr(def_idx),
+                    vmctx: self.vmctx(),
+                    global: self.module().globals[global_idx],
+                };
+                (def_idx, global)
+            })
+    }
+
+    /// Return a pointer to the interrupts structure
+    #[inline]
+    pub fn runtime_limits(&mut self) -> *mut *const VMRuntimeLimits {
+        unsafe { self.vmctx_plus_offset_mut(self.offsets().ptr.vmctx_runtime_limits()) }
+    }
+
+    /// Return a pointer to the global epoch counter used by this instance.
+    pub fn epoch_ptr(&mut self) -> *mut *const AtomicU64 {
+        unsafe { self.vmctx_plus_offset_mut(self.offsets().ptr.vmctx_epoch_ptr()) }
+    }
+
+    /// Return a pointer to the GC heap base pointer.
+    pub fn gc_heap_base(&mut self) -> *mut *mut u8 {
+        unsafe { self.vmctx_plus_offset_mut(self.offsets().ptr.vmctx_gc_heap_base()) }
+    }
+
+    /// Return a pointer to the GC heap bound.
+    pub fn gc_heap_bound(&mut self) -> *mut usize {
+        unsafe { self.vmctx_plus_offset_mut(self.offsets().ptr.vmctx_gc_heap_bound()) }
+    }
+
+    /// Return a pointer to the collector-specific heap data.
+    pub fn gc_heap_data(&mut self) -> *mut *mut u8 {
+        unsafe { self.vmctx_plus_offset_mut(self.offsets().ptr.vmctx_gc_heap_data()) }
+    }
+
+    /// Gets a pointer to this instance's `Store` which was originally
+    /// configured on creation.
+    ///
+    /// # Panics
+    ///
+    /// This will panic if the originally configured store was `None`. That can
+    /// happen for host functions so host functions can't be queried what their
+    /// original `Store` was since it's just retained as null (since host
+    /// functions are shared amongst threads and don't all share the same
+    /// store).
+    #[inline]
+    pub fn store(&self) -> *mut dyn Store {
+        let ptr =
+            unsafe { *self.vmctx_plus_offset::<*mut dyn Store>(self.offsets().ptr.vmctx_store()) };
+        debug_assert!(!ptr.is_null());
+        ptr
+    }
+
+    pub(crate) unsafe fn set_store(&mut self, store: Option<*mut dyn Store>) {
+        if let Some(store) = store {
+            *self.vmctx_plus_offset_mut(self.offsets().ptr.vmctx_store()) = store;
+            *self.runtime_limits() = (*store).vmruntime_limits();
+            *self.epoch_ptr() = (*store).epoch_ptr();
+            self.set_gc_heap((*store).maybe_gc_store());
+        } else {
+            assert_eq!(
+                mem::size_of::<*mut dyn Store>(),
+                mem::size_of::<[*mut (); 2]>()
+            );
+            *self.vmctx_plus_offset_mut::<[*mut (); 2]>(self.offsets().ptr.vmctx_store()) =
+                [ptr::null_mut(), ptr::null_mut()];
+            *self.runtime_limits() = ptr::null_mut();
+            *self.epoch_ptr() = ptr::null_mut();
+            self.set_gc_heap(None);
+        }
+    }
+
+    unsafe fn set_gc_heap(&mut self, gc_store: Option<&mut GcStore>) {
+        if let Some(gc_store) = gc_store {
+            *self.gc_heap_base() = gc_store.gc_heap.vmctx_gc_heap_base();
+            *self.gc_heap_bound() = gc_store.gc_heap.vmctx_gc_heap_bound();
+            *self.gc_heap_data() = gc_store.gc_heap.vmctx_gc_heap_data();
+        } else {
+            *self.gc_heap_base() = ptr::null_mut();
+            *self.gc_heap_bound() = 0;
+            *self.gc_heap_data() = ptr::null_mut();
+        }
+    }
+
+    pub(crate) unsafe fn set_callee(&mut self, callee: Option<NonNull<VMFunctionBody>>) {
+        *self.vmctx_plus_offset_mut(self.offsets().ptr.vmctx_callee()) =
+            callee.map_or(ptr::null_mut(), |c| c.as_ptr());
+    }
+
+    /// Return a reference to the vmctx used by compiled wasm code.
+    #[inline]
+    pub fn vmctx(&self) -> *mut VMContext {
+        // The definition of this method is subtle but intentional. The goal
+        // here is that effectively this should return `&mut self.vmctx`, but
+        // it's not quite so simple. Some more documentation is available on the
+        // `vmctx_self_reference` field, but the general idea is that we're
+        // creating a pointer to return with proper provenance. Provenance is
+        // still in the works in Rust at the time of this writing but the load
+        // of the `self.vmctx_self_reference` field is important here as it
+        // affects how LLVM thinks about aliasing with respect to the returned
+        // pointer.
+        //
+        // The intention of this method is to codegen to machine code as `&mut
+        // self.vmctx`, however. While it doesn't show up like this in LLVM IR
+        // (there's an actual load of the field) it does look like that by the
+        // time the backend runs. (that's magic to me, the backend removing
+        // loads...)
+        //
+        // As a final minor note, strict provenance APIs are not stable on Rust
+        // today so the `sptr` crate is used. This crate provides the extension
+        // trait `Strict` but the method names conflict with the nightly methods
+        // so a different syntax is used to invoke methods here.
+        let addr = ptr::addr_of!(self.vmctx);
+        Strict::with_addr(self.vmctx_self_reference.as_ptr(), Strict::addr(addr))
+    }
+
+    fn get_exported_func(&mut self, index: FuncIndex) -> ExportFunction {
+        let func_ref = self.get_func_ref(index).unwrap();
+        let func_ref = NonNull::new(func_ref as *const VMFuncRef as *mut _).unwrap();
+        ExportFunction { func_ref }
+    }
+
+    fn get_exported_table(&mut self, index: TableIndex) -> ExportTable {
+        let (definition, vmctx) = if let Some(def_index) = self.module().defined_table_index(index)
+        {
+            (self.table_ptr(def_index), self.vmctx())
+        } else {
+            let import = self.imported_table(index);
+            (import.from, import.vmctx)
+        };
+        ExportTable {
+            definition,
+            vmctx,
+            table: self.module().table_plans[index].clone(),
+        }
+    }
+
+    fn get_exported_memory(&mut self, index: MemoryIndex) -> ExportMemory {
+        let (definition, vmctx, def_index) =
+            if let Some(def_index) = self.module().defined_memory_index(index) {
+                (self.memory_ptr(def_index), self.vmctx(), def_index)
+            } else {
+                let import = self.imported_memory(index);
+                (import.from, import.vmctx, import.index)
+            };
+        ExportMemory {
+            definition,
+            vmctx,
+            memory: self.module().memory_plans[index].clone(),
+            index: def_index,
+        }
+    }
+
+    fn get_exported_global(&mut self, index: GlobalIndex) -> ExportGlobal {
+        ExportGlobal {
+            definition: if let Some(def_index) = self.module().defined_global_index(index) {
+                self.global_ptr(def_index)
+            } else {
+                self.imported_global(index).from
+            },
+            vmctx: self.vmctx(),
+            global: self.module().globals[index],
+        }
+    }
+
+    /// Return an iterator over the exports of this instance.
+    ///
+    /// 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) -> wasmparser::collections::index_map::Iter<String, EntityIndex> {
+        self.module().exports.iter()
+    }
+
+    /// Return a reference to the custom state attached to this instance.
+    #[inline]
+    pub fn host_state(&self) -> &dyn Any {
+        &*self.host_state
+    }
+
+    /// Return the table index for the given `VMTableDefinition`.
+    pub unsafe fn table_index(&mut self, table: &VMTableDefinition) -> DefinedTableIndex {
+        let index = DefinedTableIndex::new(
+            usize::try_from(
+                (table as *const VMTableDefinition)
+                    .offset_from(self.table_ptr(DefinedTableIndex::new(0))),
+            )
+            .unwrap(),
+        );
+        assert!(index.index() < self.tables.len());
+        index
+    }
+
+    /// Get the given memory's page size, in bytes.
+    pub(crate) fn memory_page_size(&self, index: MemoryIndex) -> usize {
+        usize::try_from(self.module().memory_plans[index].memory.page_size()).unwrap()
+    }
+
+    /// Grow memory by the specified amount of pages.
+    ///
+    /// Returns `None` if memory can't be grown by the specified amount
+    /// of pages. Returns `Some` with the old size in bytes if growth was
+    /// successful.
+    pub(crate) fn memory_grow(
+        &mut self,
+        index: MemoryIndex,
+        delta: u64,
+    ) -> Result<Option<usize>, Error> {
+        match self.module().defined_memory_index(index) {
+            Some(idx) => self.defined_memory_grow(idx, delta),
+            None => {
+                let import = self.imported_memory(index);
+                unsafe {
+                    Instance::from_vmctx(import.vmctx, |i| {
+                        i.defined_memory_grow(import.index, delta)
+                    })
+                }
+            }
+        }
+    }
+
+    fn defined_memory_grow(
+        &mut self,
+        idx: DefinedMemoryIndex,
+        delta: u64,
+    ) -> Result<Option<usize>, Error> {
+        let store = unsafe { &mut *self.store() };
+        let memory = &mut self.memories[idx].1;
+
+        let result = unsafe { memory.grow(delta, Some(store)) };
+
+        // Update the state used by a non-shared Wasm memory in case the base
+        // pointer and/or the length changed.
+        if memory.as_shared_memory().is_none() {
+            let vmmemory = memory.vmmemory();
+            self.set_memory(idx, vmmemory);
+        }
+
+        result
+    }
+
+    pub(crate) fn table_element_type(&mut self, table_index: TableIndex) -> TableElementType {
+        unsafe { (*self.get_table(table_index)).element_type() }
+    }
+
+    /// Grow table by the specified amount of elements, filling them with
+    /// `init_value`.
+    ///
+    /// Returns `None` if table can't be grown by the specified amount of
+    /// elements, or if `init_value` is the wrong type of table element.
+    pub(crate) fn table_grow(
+        &mut self,
+        table_index: TableIndex,
+        delta: u32,
+        init_value: TableElement,
+    ) -> Result<Option<u32>, Error> {
+        self.with_defined_table_index_and_instance(table_index, |i, instance| {
+            instance.defined_table_grow(i, delta, init_value)
+        })
+    }
+
+    fn defined_table_grow(
+        &mut self,
+        table_index: DefinedTableIndex,
+        delta: u32,
+        init_value: TableElement,
+    ) -> Result<Option<u32>, Error> {
+        let store = unsafe { &mut *self.store() };
+        let table = &mut self
+            .tables
+            .get_mut(table_index)
+            .unwrap_or_else(|| panic!("no table for index {}", table_index.index()))
+            .1;
+
+        let result = unsafe { table.grow(delta, init_value, store) };
+
+        // Keep the `VMContext` pointers used by compiled Wasm code up to
+        // date.
+        let element = self.tables[table_index].1.vmtable();
+        self.set_table(table_index, element);
+
+        result
+    }
+
+    fn alloc_layout(offsets: &VMOffsets<HostPtr>) -> Layout {
+        let size = mem::size_of::<Self>()
+            .checked_add(usize::try_from(offsets.size_of_vmctx()).unwrap())
+            .unwrap();
+        let align = mem::align_of::<Self>();
+        Layout::from_size_align(size, align).unwrap()
+    }
+
+    /// Construct a new VMFuncRef for the given function
+    /// (imported or defined in this module) and store into the given
+    /// location. Used during lazy initialization.
+    ///
+    /// Note that our current lazy-init scheme actually calls this every
+    /// time the funcref pointer is fetched; this turns out to be better
+    /// than tracking state related to whether it's been initialized
+    /// before, because resetting that state on (re)instantiation is
+    /// very expensive if there are many funcrefs.
+    fn construct_func_ref(
+        &mut self,
+        index: FuncIndex,
+        sig: ModuleInternedTypeIndex,
+        into: *mut VMFuncRef,
+    ) {
+        let type_index = unsafe {
+            let base: *const VMSharedTypeIndex =
+                *self.vmctx_plus_offset_mut(self.offsets().ptr.vmctx_type_ids_array());
+            *base.add(sig.index())
+        };
+
+        let func_ref = if let Some(def_index) = self.module().defined_func_index(index) {
+            VMFuncRef {
+                array_call: self
+                    .runtime_info
+                    .array_to_wasm_trampoline(def_index)
+                    .expect("should have array-to-Wasm trampoline for escaping function"),
+                wasm_call: Some(self.runtime_info.function(def_index)),
+                vmctx: VMOpaqueContext::from_vmcontext(self.vmctx()),
+                type_index,
+            }
+        } else {
+            let import = self.imported_function(index);
+            VMFuncRef {
+                array_call: import.array_call,
+                wasm_call: Some(import.wasm_call),
+                vmctx: import.vmctx,
+                type_index,
+            }
+        };
+
+        // Safety: we have a `&mut self`, so we have exclusive access
+        // to this Instance.
+        unsafe {
+            ptr::write(into, func_ref);
+        }
+    }
+
+    /// Get a `&VMFuncRef` for the given `FuncIndex`.
+    ///
+    /// Returns `None` if the index is the reserved index value.
+    ///
+    /// The returned reference is a stable reference that won't be moved and can
+    /// be passed into JIT code.
+    pub(crate) fn get_func_ref(&mut self, index: FuncIndex) -> Option<*mut VMFuncRef> {
+        if index == FuncIndex::reserved_value() {
+            return None;
+        }
+
+        // Safety: we have a `&mut self`, so we have exclusive access
+        // to this Instance.
+        unsafe {
+            // For now, we eagerly initialize an funcref struct in-place
+            // whenever asked for a reference to it. This is mostly
+            // fine, because in practice each funcref is unlikely to be
+            // requested more than a few times: once-ish for funcref
+            // tables used for call_indirect (the usual compilation
+            // strategy places each function in the table at most once),
+            // and once or a few times when fetching exports via API.
+            // Note that for any case driven by table accesses, the lazy
+            // table init behaves like a higher-level cache layer that
+            // protects this initialization from happening multiple
+            // times, via that particular table at least.
+            //
+            // When `ref.func` becomes more commonly used or if we
+            // otherwise see a use-case where this becomes a hotpath,
+            // we can reconsider by using some state to track
+            // "uninitialized" explicitly, for example by zeroing the
+            // funcrefs (perhaps together with other
+            // zeroed-at-instantiate-time state) or using a separate
+            // is-initialized bitmap.
+            //
+            // We arrived at this design because zeroing memory is
+            // expensive, so it's better for instantiation performance
+            // if we don't have to track "is-initialized" state at
+            // all!
+            let func = &self.module().functions[index];
+            let sig = func.signature;
+            let func_ref: *mut VMFuncRef = self
+                .vmctx_plus_offset_mut::<VMFuncRef>(self.offsets().vmctx_func_ref(func.func_ref));
+            self.construct_func_ref(index, sig, func_ref);
+
+            Some(func_ref)
+        }
+    }
+
+    /// The `table.init` operation: initializes a portion of a table with a
+    /// passive element.
+    ///
+    /// # Errors
+    ///
+    /// Returns a `Trap` error when the range within the table is out of bounds
+    /// or the range within the passive element is out of bounds.
+    pub(crate) fn table_init(
+        &mut self,
+        table_index: TableIndex,
+        elem_index: ElemIndex,
+        dst: u32,
+        src: u32,
+        len: u32,
+    ) -> Result<(), Trap> {
+        // TODO: this `clone()` shouldn't be necessary but is used for now to
+        // inform `rustc` that the lifetime of the elements here are
+        // disconnected from the lifetime of `self`.
+        let module = self.module().clone();
+
+        // NB: fall back to an expressions-based list of elements which doesn't
+        // have static type information (as opposed to `Functions`) since we
+        // don't know just yet what type the table has. The type will be be
+        // inferred in the next step within `table_init_segment`.
+        let empty = TableSegmentElements::Expressions(Box::new([]));
+
+        let elements = match module.passive_elements_map.get(&elem_index) {
+            Some(index) if !self.dropped_elements.contains(elem_index) => {
+                &module.passive_elements[*index]
+            }
+            _ => &empty,
+        };
+        let mut const_evaluator = ConstExprEvaluator::default();
+        self.table_init_segment(&mut const_evaluator, table_index, elements, dst, src, len)
+    }
+
+    pub(crate) fn table_init_segment(
+        &mut self,
+        const_evaluator: &mut ConstExprEvaluator,
+        table_index: TableIndex,
+        elements: &TableSegmentElements,
+        dst: u32,
+        src: u32,
+        len: u32,
+    ) -> Result<(), Trap> {
+        // https://webassembly.github.io/bulk-memory-operations/core/exec/instructions.html#exec-table-init
+
+        let table = unsafe { &mut *self.get_table(table_index) };
+        let src = usize::try_from(src).map_err(|_| Trap::TableOutOfBounds)?;
+        let len = usize::try_from(len).map_err(|_| Trap::TableOutOfBounds)?;
+        let module = self.module().clone();
+
+        match elements {
+            TableSegmentElements::Functions(funcs) => {
+                let elements = funcs
+                    .get(src..)
+                    .and_then(|s| s.get(..len))
+                    .ok_or(Trap::TableOutOfBounds)?;
+                table.init_func(
+                    dst,
+                    elements
+                        .iter()
+                        .map(|idx| self.get_func_ref(*idx).unwrap_or(ptr::null_mut())),
+                )?;
+            }
+            TableSegmentElements::Expressions(exprs) => {
+                let exprs = exprs
+                    .get(src..)
+                    .and_then(|s| s.get(..len))
+                    .ok_or(Trap::TableOutOfBounds)?;
+                let mut context = ConstEvalContext::new(self, &module);
+                match module.table_plans[table_index]
+                    .table
+                    .wasm_ty
+                    .heap_type
+                    .top()
+                {
+                    WasmHeapTopType::Extern => table.init_gc_refs(
+                        dst,
+                        exprs.iter().map(|expr| unsafe {
+                            let raw = const_evaluator
+                                .eval(&mut context, expr)
+                                .expect("const expr should be valid");
+                            VMGcRef::from_raw_u32(raw.get_externref())
+                        }),
+                    )?,
+                    WasmHeapTopType::Any => table.init_gc_refs(
+                        dst,
+                        exprs.iter().map(|expr| unsafe {
+                            let raw = const_evaluator
+                                .eval(&mut context, expr)
+                                .expect("const expr should be valid");
+                            VMGcRef::from_raw_u32(raw.get_anyref())
+                        }),
+                    )?,
+                    WasmHeapTopType::Func => table.init_func(
+                        dst,
+                        exprs.iter().map(|expr| unsafe {
+                            const_evaluator
+                                .eval(&mut context, expr)
+                                .expect("const expr should be valid")
+                                .get_funcref()
+                                .cast()
+                        }),
+                    )?,
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Drop an element.
+    pub(crate) fn elem_drop(&mut self, elem_index: ElemIndex) {
+        // https://webassembly.github.io/reference-types/core/exec/instructions.html#exec-elem-drop
+
+        self.dropped_elements.insert(elem_index);
+
+        // Note that we don't check that we actually removed a segment because
+        // dropping a non-passive segment is a no-op (not a trap).
+    }
+
+    /// Get a locally-defined memory.
+    pub fn get_defined_memory(&mut self, index: DefinedMemoryIndex) -> *mut Memory {
+        ptr::addr_of_mut!(self.memories[index].1)
+    }
+
+    /// Do a `memory.copy`
+    ///
+    /// # Errors
+    ///
+    /// Returns a `Trap` error when the source or destination ranges are out of
+    /// bounds.
+    pub(crate) fn memory_copy(
+        &mut self,
+        dst_index: MemoryIndex,
+        dst: u64,
+        src_index: MemoryIndex,
+        src: u64,
+        len: u64,
+    ) -> Result<(), Trap> {
+        // https://webassembly.github.io/reference-types/core/exec/instructions.html#exec-memory-copy
+
+        let src_mem = self.get_memory(src_index);
+        let dst_mem = self.get_memory(dst_index);
+
+        let src = self.validate_inbounds(src_mem.current_length(), src, len)?;
+        let dst = self.validate_inbounds(dst_mem.current_length(), dst, len)?;
+
+        // Bounds and casts are checked above, by this point we know that
+        // everything is safe.
+        unsafe {
+            let dst = dst_mem.base.add(dst);
+            let src = src_mem.base.add(src);
+            // FIXME audit whether this is safe in the presence of shared memory
+            // (https://github.com/bytecodealliance/wasmtime/issues/4203).
+            ptr::copy(src, dst, len as usize);
+        }
+
+        Ok(())
+    }
+
+    fn validate_inbounds(&self, max: usize, ptr: u64, len: u64) -> Result<usize, Trap> {
+        let oob = || Trap::MemoryOutOfBounds;
+        let end = ptr
+            .checked_add(len)
+            .and_then(|i| usize::try_from(i).ok())
+            .ok_or_else(oob)?;
+        if end > max {
+            Err(oob())
+        } else {
+            Ok(ptr as usize)
+        }
+    }
+
+    /// Perform the `memory.fill` operation on a locally defined memory.
+    ///
+    /// # Errors
+    ///
+    /// Returns a `Trap` error if the memory range is out of bounds.
+    pub(crate) fn memory_fill(
+        &mut self,
+        memory_index: MemoryIndex,
+        dst: u64,
+        val: u8,
+        len: u64,
+    ) -> Result<(), Trap> {
+        let memory = self.get_memory(memory_index);
+        let dst = self.validate_inbounds(memory.current_length(), dst, len)?;
+
+        // Bounds and casts are checked above, by this point we know that
+        // everything is safe.
+        unsafe {
+            let dst = memory.base.add(dst);
+            // FIXME audit whether this is safe in the presence of shared memory
+            // (https://github.com/bytecodealliance/wasmtime/issues/4203).
+            ptr::write_bytes(dst, val, len as usize);
+        }
+
+        Ok(())
+    }
+
+    /// Performs the `memory.init` operation.
+    ///
+    /// # Errors
+    ///
+    /// Returns a `Trap` error if the destination range is out of this module's
+    /// memory's bounds or if the source range is outside the data segment's
+    /// bounds.
+    pub(crate) fn memory_init(
+        &mut self,
+        memory_index: MemoryIndex,
+        data_index: DataIndex,
+        dst: u64,
+        src: u32,
+        len: u32,
+    ) -> Result<(), Trap> {
+        let range = match self.module().passive_data_map.get(&data_index).cloned() {
+            Some(range) if !self.dropped_data.contains(data_index) => range,
+            _ => 0..0,
+        };
+        self.memory_init_segment(memory_index, range, dst, src, len)
+    }
+
+    pub(crate) fn wasm_data(&self, range: Range<u32>) -> &[u8] {
+        &self.runtime_info.wasm_data()[range.start as usize..range.end as usize]
+    }
+
+    pub(crate) fn memory_init_segment(
+        &mut self,
+        memory_index: MemoryIndex,
+        range: Range<u32>,
+        dst: u64,
+        src: u32,
+        len: u32,
+    ) -> Result<(), Trap> {
+        // https://webassembly.github.io/bulk-memory-operations/core/exec/instructions.html#exec-memory-init
+
+        let memory = self.get_memory(memory_index);
+        let data = self.wasm_data(range);
+        let dst = self.validate_inbounds(memory.current_length(), dst, len.into())?;
+        let src = self.validate_inbounds(data.len(), src.into(), len.into())?;
+        let len = len as usize;
+
+        unsafe {
+            let src_start = data.as_ptr().add(src);
+            let dst_start = memory.base.add(dst);
+            // FIXME audit whether this is safe in the presence of shared memory
+            // (https://github.com/bytecodealliance/wasmtime/issues/4203).
+            ptr::copy_nonoverlapping(src_start, dst_start, len);
+        }
+
+        Ok(())
+    }
+
+    /// Drop the given data segment, truncating its length to zero.
+    pub(crate) fn data_drop(&mut self, data_index: DataIndex) {
+        self.dropped_data.insert(data_index);
+
+        // Note that we don't check that we actually removed a segment because
+        // dropping a non-passive segment is a no-op (not a trap).
+    }
+
+    /// Get a table by index regardless of whether it is locally-defined
+    /// or an imported, foreign table. Ensure that the given range of
+    /// elements in the table is lazily initialized.  We define this
+    /// operation all-in-one for safety, to ensure the lazy-init
+    /// happens.
+    ///
+    /// Takes an `Iterator` for the index-range to lazy-initialize,
+    /// for flexibility. This can be a range, single item, or empty
+    /// sequence, for example. The iterator should return indices in
+    /// increasing order, so that the break-at-out-of-bounds behavior
+    /// works correctly.
+    pub(crate) fn get_table_with_lazy_init(
+        &mut self,
+        table_index: TableIndex,
+        range: impl Iterator<Item = u32>,
+    ) -> *mut Table {
+        self.with_defined_table_index_and_instance(table_index, |idx, instance| {
+            instance.get_defined_table_with_lazy_init(idx, range)
+        })
+    }
+
+    /// Gets the raw runtime table data structure owned by this instance
+    /// given the provided `idx`.
+    ///
+    /// The `range` specified is eagerly initialized for funcref tables.
+    pub fn get_defined_table_with_lazy_init(
+        &mut self,
+        idx: DefinedTableIndex,
+        range: impl Iterator<Item = u32>,
+    ) -> *mut Table {
+        let elt_ty = self.tables[idx].1.element_type();
+
+        if elt_ty == TableElementType::Func {
+            for i in range {
+                let gc_store = unsafe { (*self.store()).gc_store() };
+                let value = match self.tables[idx].1.get(gc_store, i) {
+                    Some(value) => value,
+                    None => {
+                        // Out-of-bounds; caller will handle by likely
+                        // throwing a trap. No work to do to lazy-init
+                        // beyond the end.
+                        break;
+                    }
+                };
+
+                if !value.is_uninit() {
+                    continue;
+                }
+
+                // The table element `i` is uninitialized and is now being
+                // initialized. This must imply that a `precompiled` list of
+                // function indices is available for this table. The precompiled
+                // list is extracted and then it is consulted with `i` to
+                // determine the function that is going to be initialized. Note
+                // that `i` may be outside the limits of the static
+                // initialization so it's a fallible `get` instead of an index.
+                let module = self.module();
+                let precomputed = match &module.table_initialization.initial_values[idx] {
+                    TableInitialValue::Null { precomputed } => precomputed,
+                    TableInitialValue::Expr(_) => unreachable!(),
+                };
+                let func_index = precomputed.get(i as usize).cloned();
+                let func_ref = func_index
+                    .and_then(|func_index| self.get_func_ref(func_index))
+                    .unwrap_or(ptr::null_mut());
+                self.tables[idx]
+                    .1
+                    .set(i, TableElement::FuncRef(func_ref))
+                    .expect("Table type should match and index should be in-bounds");
+            }
+        }
+
+        ptr::addr_of_mut!(self.tables[idx].1)
+    }
+
+    /// Get a table by index regardless of whether it is locally-defined or an
+    /// imported, foreign table.
+    pub(crate) fn get_table(&mut self, table_index: TableIndex) -> *mut Table {
+        self.with_defined_table_index_and_instance(table_index, |idx, instance| {
+            ptr::addr_of_mut!(instance.tables[idx].1)
+        })
+    }
+
+    /// Get a locally-defined table.
+    pub(crate) fn get_defined_table(&mut self, index: DefinedTableIndex) -> *mut Table {
+        ptr::addr_of_mut!(self.tables[index].1)
+    }
+
+    pub(crate) fn with_defined_table_index_and_instance<R>(
+        &mut self,
+        index: TableIndex,
+        f: impl FnOnce(DefinedTableIndex, &mut Instance) -> R,
+    ) -> R {
+        if let Some(defined_table_index) = self.module().defined_table_index(index) {
+            f(defined_table_index, self)
+        } else {
+            let import = self.imported_table(index);
+            unsafe {
+                Instance::from_vmctx(import.vmctx, |foreign_instance| {
+                    let foreign_table_def = import.from;
+                    let foreign_table_index = foreign_instance.table_index(&*foreign_table_def);
+                    f(foreign_table_index, foreign_instance)
+                })
+            }
+        }
+    }
+
+    /// Initialize the VMContext data associated with this Instance.
+    ///
+    /// The `VMContext` memory is assumed to be uninitialized; any field
+    /// that we need in a certain state will be explicitly written by this
+    /// function.
+    unsafe fn initialize_vmctx(
+        &mut self,
+        module: &Module,
+        offsets: &VMOffsets<HostPtr>,
+        store: StorePtr,
+        imports: Imports,
+    ) {
+        assert!(ptr::eq(module, self.module().as_ref()));
+
+        *self.vmctx_plus_offset_mut(offsets.ptr.vmctx_magic()) = VMCONTEXT_MAGIC;
+        self.set_callee(None);
+        self.set_store(store.as_raw());
+
+        // Initialize shared types
+        let types = self.runtime_info.type_ids();
+        *self.vmctx_plus_offset_mut(offsets.ptr.vmctx_type_ids_array()) = types.as_ptr();
+
+        // Initialize the built-in functions
+        *self.vmctx_plus_offset_mut(offsets.ptr.vmctx_builtin_functions()) =
+            &VMBuiltinFunctionsArray::INIT;
+
+        // Initialize the imports
+        debug_assert_eq!(imports.functions.len(), module.num_imported_funcs);
+        ptr::copy_nonoverlapping(
+            imports.functions.as_ptr(),
+            self.vmctx_plus_offset_mut(offsets.vmctx_imported_functions_begin()),
+            imports.functions.len(),
+        );
+        debug_assert_eq!(imports.tables.len(), module.num_imported_tables);
+        ptr::copy_nonoverlapping(
+            imports.tables.as_ptr(),
+            self.vmctx_plus_offset_mut(offsets.vmctx_imported_tables_begin()),
+            imports.tables.len(),
+        );
+        debug_assert_eq!(imports.memories.len(), module.num_imported_memories);
+        ptr::copy_nonoverlapping(
+            imports.memories.as_ptr(),
+            self.vmctx_plus_offset_mut(offsets.vmctx_imported_memories_begin()),
+            imports.memories.len(),
+        );
+        debug_assert_eq!(imports.globals.len(), module.num_imported_globals);
+        ptr::copy_nonoverlapping(
+            imports.globals.as_ptr(),
+            self.vmctx_plus_offset_mut(offsets.vmctx_imported_globals_begin()),
+            imports.globals.len(),
+        );
+
+        // N.B.: there is no need to initialize the funcrefs array because we
+        // eagerly construct each element in it whenever asked for a reference
+        // to that element. In other words, there is no state needed to track
+        // the lazy-init, so we don't need to initialize any state now.
+
+        // Initialize the defined tables
+        let mut ptr = self.vmctx_plus_offset_mut(offsets.vmctx_tables_begin());
+        for i in 0..module.table_plans.len() - module.num_imported_tables {
+            ptr::write(ptr, self.tables[DefinedTableIndex::new(i)].1.vmtable());
+            ptr = ptr.add(1);
+        }
+
+        // Initialize the defined memories. This fills in both the
+        // `defined_memories` table and the `owned_memories` table at the same
+        // time. Entries in `defined_memories` hold a pointer to a definition
+        // (all memories) whereas the `owned_memories` hold the actual
+        // definitions of memories owned (not shared) in the module.
+        let mut ptr = self.vmctx_plus_offset_mut(offsets.vmctx_memories_begin());
+        let mut owned_ptr = self.vmctx_plus_offset_mut(offsets.vmctx_owned_memories_begin());
+        for i in 0..module.memory_plans.len() - module.num_imported_memories {
+            let defined_memory_index = DefinedMemoryIndex::new(i);
+            let memory_index = module.memory_index(defined_memory_index);
+            if module.memory_plans[memory_index].memory.shared {
+                let def_ptr = self.memories[defined_memory_index]
+                    .1
+                    .as_shared_memory()
+                    .unwrap()
+                    .vmmemory_ptr();
+                ptr::write(ptr, def_ptr.cast_mut());
+            } else {
+                ptr::write(owned_ptr, self.memories[defined_memory_index].1.vmmemory());
+                ptr::write(ptr, owned_ptr);
+                owned_ptr = owned_ptr.add(1);
+            }
+            ptr = ptr.add(1);
+        }
+
+        // Initialize the defined globals
+        let mut const_evaluator = ConstExprEvaluator::default();
+        self.initialize_vmctx_globals(&mut const_evaluator, module);
+    }
+
+    unsafe fn initialize_vmctx_globals(
+        &mut self,
+        const_evaluator: &mut ConstExprEvaluator,
+        module: &Module,
+    ) {
+        for (index, init) in module.global_initializers.iter() {
+            let mut context = ConstEvalContext::new(self, module);
+            let raw = const_evaluator
+                .eval(&mut context, init)
+                .expect("should be a valid const expr");
+
+            let to = self.global_ptr(index);
+            let wasm_ty = module.globals[module.global_index(index)].wasm_ty;
+
+            #[cfg(feature = "wmemcheck")]
+            if index.index() == 0 && wasm_ty == wasmtime_environ::WasmValType::I32 {
+                if let Some(wmemcheck) = &mut self.wmemcheck_state {
+                    let size = usize::try_from(raw.get_i32()).unwrap();
+                    wmemcheck.set_stack_size(size);
+                }
+            }
+
+            ptr::write(to, VMGlobalDefinition::from_val_raw(wasm_ty, raw));
+        }
+    }
+
+    fn wasm_fault(&self, addr: usize) -> Option<WasmFault> {
+        let mut fault = None;
+        for (_, (_, memory)) in self.memories.iter() {
+            let accessible = memory.wasm_accessible();
+            if accessible.start <= addr && addr < accessible.end {
+                // All linear memories should be disjoint so assert that no
+                // prior fault has been found.
+                assert!(fault.is_none());
+                fault = Some(WasmFault {
+                    memory_size: memory.byte_size(),
+                    wasm_address: u64::try_from(addr - accessible.start).unwrap(),
+                });
+            }
+        }
+        fault
+    }
+}
+
+/// A handle holding an `Instance` of a WebAssembly module.
+#[derive(Debug)]
+pub struct InstanceHandle {
+    instance: Option<SendSyncPtr<Instance>>,
+}
+
+impl InstanceHandle {
+    /// Creates an "empty" instance handle which internally has a null pointer
+    /// to an instance.
+    pub fn null() -> InstanceHandle {
+        InstanceHandle { instance: None }
+    }
+
+    /// Return a raw pointer to the vmctx used by compiled wasm code.
+    #[inline]
+    pub fn vmctx(&self) -> *mut VMContext {
+        self.instance().vmctx()
+    }
+
+    /// Return a reference to a module.
+    pub fn module(&self) -> &Arc<Module> {
+        self.instance().module()
+    }
+
+    /// Lookup a function by index.
+    pub fn get_exported_func(&mut self, export: FuncIndex) -> ExportFunction {
+        self.instance_mut().get_exported_func(export)
+    }
+
+    /// Lookup a global by index.
+    pub fn get_exported_global(&mut self, export: GlobalIndex) -> ExportGlobal {
+        self.instance_mut().get_exported_global(export)
+    }
+
+    /// Lookup a memory by index.
+    pub fn get_exported_memory(&mut self, export: MemoryIndex) -> ExportMemory {
+        self.instance_mut().get_exported_memory(export)
+    }
+
+    /// Lookup a table by index.
+    pub fn get_exported_table(&mut self, export: TableIndex) -> ExportTable {
+        self.instance_mut().get_exported_table(export)
+    }
+
+    /// Lookup an item with the given index.
+    pub fn get_export_by_index(&mut self, export: EntityIndex) -> Export {
+        match export {
+            EntityIndex::Function(i) => Export::Function(self.get_exported_func(i)),
+            EntityIndex::Global(i) => Export::Global(self.get_exported_global(i)),
+            EntityIndex::Table(i) => Export::Table(self.get_exported_table(i)),
+            EntityIndex::Memory(i) => Export::Memory(self.get_exported_memory(i)),
+        }
+    }
+
+    /// Return an iterator over the exports of this instance.
+    ///
+    /// 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) -> wasmparser::collections::index_map::Iter<String, EntityIndex> {
+        self.instance().exports()
+    }
+
+    /// Return a reference to the custom state attached to this instance.
+    pub fn host_state(&self) -> &dyn Any {
+        self.instance().host_state()
+    }
+
+    /// Get a table defined locally within this module.
+    pub fn get_defined_table(&mut self, index: DefinedTableIndex) -> *mut Table {
+        self.instance_mut().get_defined_table(index)
+    }
+
+    /// Get a table defined locally within this module, lazily
+    /// initializing the given range first.
+    pub fn get_defined_table_with_lazy_init(
+        &mut self,
+        index: DefinedTableIndex,
+        range: impl Iterator<Item = u32>,
+    ) -> *mut Table {
+        let index = self.instance().module().table_index(index);
+        self.instance_mut().get_table_with_lazy_init(index, range)
+    }
+
+    /// Get all tables within this instance.
+    ///
+    /// Returns both import and defined tables.
+    ///
+    /// Returns both exported and non-exported tables.
+    ///
+    /// Gives access to the full tables space.
+    pub fn all_tables<'a>(
+        &'a mut self,
+    ) -> impl ExactSizeIterator<Item = (TableIndex, ExportTable)> + 'a {
+        let indices = (0..self.module().table_plans.len())
+            .map(|i| TableIndex::new(i))
+            .collect::<Vec<_>>();
+        indices.into_iter().map(|i| (i, self.get_exported_table(i)))
+    }
+
+    /// Return the tables defined in this instance (not imported).
+    pub fn defined_tables<'a>(&'a mut self) -> impl ExactSizeIterator<Item = ExportTable> + 'a {
+        let num_imported = self.module().num_imported_tables;
+        self.all_tables()
+            .skip(num_imported)
+            .map(|(_i, table)| table)
+    }
+
+    /// Get all memories within this instance.
+    ///
+    /// Returns both import and defined memories.
+    ///
+    /// Returns both exported and non-exported memories.
+    ///
+    /// Gives access to the full memories space.
+    pub fn all_memories<'a>(
+        &'a mut self,
+    ) -> impl ExactSizeIterator<Item = (MemoryIndex, ExportMemory)> + 'a {
+        let indices = (0..self.module().memory_plans.len())
+            .map(|i| MemoryIndex::new(i))
+            .collect::<Vec<_>>();
+        indices
+            .into_iter()
+            .map(|i| (i, self.get_exported_memory(i)))
+    }
+
+    /// Return the memories defined in this instance (not imported).
+    pub fn defined_memories<'a>(&'a mut self) -> impl ExactSizeIterator<Item = ExportMemory> + 'a {
+        let num_imported = self.module().num_imported_memories;
+        self.all_memories()
+            .skip(num_imported)
+            .map(|(_i, memory)| memory)
+    }
+
+    /// Get all globals within this instance.
+    ///
+    /// Returns both import and defined globals.
+    ///
+    /// Returns both exported and non-exported globals.
+    ///
+    /// Gives access to the full globals space.
+    pub fn all_globals<'a>(
+        &'a mut self,
+    ) -> impl ExactSizeIterator<Item = (GlobalIndex, ExportGlobal)> + 'a {
+        self.instance_mut().all_globals()
+    }
+
+    /// Get the globals defined in this instance (not imported).
+    pub fn defined_globals<'a>(
+        &'a mut self,
+    ) -> impl ExactSizeIterator<Item = (DefinedGlobalIndex, ExportGlobal)> + 'a {
+        self.instance_mut().defined_globals()
+    }
+
+    /// Return a reference to the contained `Instance`.
+    #[inline]
+    pub(crate) fn instance(&self) -> &Instance {
+        unsafe { &*self.instance.unwrap().as_ptr() }
+    }
+
+    pub(crate) fn instance_mut(&mut self) -> &mut Instance {
+        unsafe { &mut *self.instance.unwrap().as_ptr() }
+    }
+
+    /// Returns the `Store` pointer that was stored on creation
+    #[inline]
+    pub fn store(&self) -> *mut dyn Store {
+        self.instance().store()
+    }
+
+    /// Configure the `*mut dyn Store` internal pointer after-the-fact.
+    ///
+    /// This is provided for the original `Store` itself to configure the first
+    /// self-pointer after the original `Box` has been initialized.
+    pub unsafe fn set_store(&mut self, store: *mut dyn Store) {
+        self.instance_mut().set_store(Some(store));
+    }
+
+    /// Returns a clone of this instance.
+    ///
+    /// This is unsafe because the returned handle here is just a cheap clone
+    /// of the internals, there's no lifetime tracking around its validity.
+    /// You'll need to ensure that the returned handles all go out of scope at
+    /// the same time.
+    #[inline]
+    pub unsafe fn clone(&self) -> InstanceHandle {
+        InstanceHandle {
+            instance: self.instance,
+        }
+    }
+
+    /// Performs post-initialization of an instance after its handle has been
+    /// created and registered with a store.
+    ///
+    /// Failure of this function means that the instance still must persist
+    /// within the store since failure may indicate partial failure, or some
+    /// state could be referenced by other instances.
+    pub fn initialize(&mut self, module: &Module, is_bulk_memory: bool) -> Result<()> {
+        allocator::initialize_instance(self.instance_mut(), module, is_bulk_memory)
+    }
+
+    /// Attempts to convert from the host `addr` specified to a WebAssembly
+    /// based address recorded in `WasmFault`.
+    ///
+    /// This method will check all linear memories that this instance contains
+    /// to see if any of them contain `addr`. If one does then `Some` is
+    /// returned with metadata about the wasm fault. Otherwise `None` is
+    /// returned and `addr` doesn't belong to this instance.
+    pub fn wasm_fault(&self, addr: usize) -> Option<WasmFault> {
+        self.instance().wasm_fault(addr)
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/instance/allocator.rs b/crates/wasmtime/src/runtime/vm/instance/allocator.rs
new file mode 100644
index 000000000000..61cb6fe4c1f4
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/instance/allocator.rs
@@ -0,0 +1,808 @@
+use crate::prelude::*;
+use crate::runtime::vm::const_expr::{ConstEvalContext, ConstExprEvaluator};
+use crate::runtime::vm::imports::Imports;
+use crate::runtime::vm::instance::{Instance, InstanceHandle};
+use crate::runtime::vm::memory::Memory;
+use crate::runtime::vm::mpk::ProtectionKey;
+use crate::runtime::vm::table::Table;
+use crate::runtime::vm::{CompiledModuleId, ModuleRuntimeInfo, Store, VMFuncRef, VMGcRef};
+use core::{any::Any, mem, ptr};
+use wasmtime_environ::{
+    DefinedMemoryIndex, DefinedTableIndex, HostPtr, InitMemory, MemoryInitialization,
+    MemoryInitializer, MemoryPlan, Module, PrimaryMap, SizeOverflow, TableInitialValue, TablePlan,
+    Trap, VMOffsets, WasmHeapTopType,
+};
+
+#[cfg(feature = "gc")]
+use crate::runtime::vm::{GcHeap, GcRuntime};
+
+#[cfg(feature = "component-model")]
+use wasmtime_environ::{
+    component::{Component, VMComponentOffsets},
+    StaticModuleIndex,
+};
+
+mod on_demand;
+pub use self::on_demand::OnDemandInstanceAllocator;
+
+#[cfg(feature = "pooling-allocator")]
+mod pooling;
+#[cfg(feature = "pooling-allocator")]
+pub use self::pooling::{
+    InstanceLimits, PoolConcurrencyLimitError, PoolingInstanceAllocator,
+    PoolingInstanceAllocatorConfig,
+};
+
+/// Represents a request for a new runtime instance.
+pub struct InstanceAllocationRequest<'a> {
+    /// The info related to the compiled version of this module,
+    /// needed for instantiation: function metadata, JIT code
+    /// addresses, precomputed images for lazy memory and table
+    /// initialization, and the like. This Arc is cloned and held for
+    /// the lifetime of the instance.
+    pub runtime_info: &'a ModuleRuntimeInfo,
+
+    /// The imports to use for the instantiation.
+    pub imports: Imports<'a>,
+
+    /// The host state to associate with the instance.
+    pub host_state: Box<dyn Any + Send + Sync>,
+
+    /// A pointer to the "store" for this instance to be allocated. The store
+    /// correlates with the `Store` in wasmtime itself, and lots of contextual
+    /// information about the execution of wasm can be learned through the
+    /// store.
+    ///
+    /// Note that this is a raw pointer and has a static lifetime, both of which
+    /// are a bit of a lie. This is done purely so a store can learn about
+    /// itself when it gets called as a host function, and additionally so this
+    /// runtime can access internals as necessary (such as the
+    /// VMExternRefActivationsTable or the resource limiter methods).
+    ///
+    /// Note that this ends up being a self-pointer to the instance when stored.
+    /// The reason is that the instance itself is then stored within the store.
+    /// We use a number of `PhantomPinned` declarations to indicate this to the
+    /// compiler. More info on this in `wasmtime/src/store.rs`
+    pub store: StorePtr,
+
+    /// Indicates '--wmemcheck' flag.
+    #[cfg_attr(not(feature = "wmemcheck"), allow(dead_code))]
+    pub wmemcheck: bool,
+
+    /// Request that the instance's memories be protected by a specific
+    /// protection key.
+    pub pkey: Option<ProtectionKey>,
+}
+
+/// A pointer to a Store. This Option<*mut dyn Store> is wrapped in a struct
+/// so that the function to create a &mut dyn Store is a method on a member of
+/// InstanceAllocationRequest, rather than on a &mut InstanceAllocationRequest
+/// itself, because several use-sites require a split mut borrow on the
+/// InstanceAllocationRequest.
+pub struct StorePtr(Option<*mut dyn Store>);
+
+impl StorePtr {
+    /// A pointer to no Store.
+    pub fn empty() -> Self {
+        Self(None)
+    }
+
+    /// A pointer to a Store.
+    pub fn new(ptr: *mut dyn Store) -> Self {
+        Self(Some(ptr))
+    }
+
+    /// The raw contents of this struct
+    pub fn as_raw(&self) -> Option<*mut dyn Store> {
+        self.0
+    }
+
+    /// Use the StorePtr as a mut ref to the Store.
+    ///
+    /// Safety: must not be used outside the original lifetime of the borrow.
+    pub(crate) unsafe fn get(&mut self) -> Option<&mut dyn Store> {
+        match self.0 {
+            Some(ptr) => Some(&mut *ptr),
+            None => None,
+        }
+    }
+}
+
+/// The index of a memory allocation within an `InstanceAllocator`.
+#[derive(Clone, Copy, Debug, Eq, PartialEq, PartialOrd, Ord)]
+pub struct MemoryAllocationIndex(u32);
+
+impl Default for MemoryAllocationIndex {
+    fn default() -> Self {
+        // A default `MemoryAllocationIndex` that can be used with
+        // `InstanceAllocator`s that don't actually need indices.
+        MemoryAllocationIndex(u32::MAX)
+    }
+}
+
+impl MemoryAllocationIndex {
+    /// Get the underlying index of this `MemoryAllocationIndex`.
+    pub fn index(&self) -> usize {
+        self.0 as usize
+    }
+}
+
+/// The index of a table allocation within an `InstanceAllocator`.
+#[derive(Clone, Copy, Debug, Eq, PartialEq, PartialOrd, Ord)]
+pub struct TableAllocationIndex(u32);
+
+impl Default for TableAllocationIndex {
+    fn default() -> Self {
+        // A default `TableAllocationIndex` that can be used with
+        // `InstanceAllocator`s that don't actually need indices.
+        TableAllocationIndex(u32::MAX)
+    }
+}
+
+impl TableAllocationIndex {
+    /// Get the underlying index of this `TableAllocationIndex`.
+    pub fn index(&self) -> usize {
+        self.0 as usize
+    }
+}
+
+/// The index of a table allocation within an `InstanceAllocator`.
+#[derive(Clone, Copy, Debug, Eq, PartialEq, PartialOrd, Ord)]
+pub struct GcHeapAllocationIndex(u32);
+
+impl Default for GcHeapAllocationIndex {
+    fn default() -> Self {
+        // A default `GcHeapAllocationIndex` that can be used with
+        // `InstanceAllocator`s that don't actually need indices.
+        GcHeapAllocationIndex(u32::MAX)
+    }
+}
+
+impl GcHeapAllocationIndex {
+    /// Get the underlying index of this `GcHeapAllocationIndex`.
+    pub fn index(&self) -> usize {
+        self.0 as usize
+    }
+}
+
+/// Trait that represents the hooks needed to implement an instance allocator.
+///
+/// Implement this trait when implementing new instance allocators, but don't
+/// use this trait when you need an instance allocator. Instead use the
+/// `InstanceAllocator` trait for that, which has additional helper methods and
+/// a blanket implementation for all types that implement this trait.
+///
+/// # Safety
+///
+/// This trait is unsafe as it requires knowledge of Wasmtime's runtime
+/// internals to implement correctly.
+pub unsafe trait InstanceAllocatorImpl {
+    /// Validate whether a component (including all of its contained core
+    /// modules) is allocatable by this instance allocator.
+    #[cfg(feature = "component-model")]
+    fn validate_component_impl<'a>(
+        &self,
+        component: &Component,
+        offsets: &VMComponentOffsets<HostPtr>,
+        get_module: &'a dyn Fn(StaticModuleIndex) -> &'a Module,
+    ) -> Result<()>;
+
+    /// Validate whether a module is allocatable by this instance allocator.
+    fn validate_module_impl(&self, module: &Module, offsets: &VMOffsets<HostPtr>) -> Result<()>;
+
+    /// Increment the count of concurrent component instances that are currently
+    /// allocated, if applicable.
+    ///
+    /// Not all instance allocators will have limits for the maximum number of
+    /// concurrent component instances that can be live at the same time, and
+    /// these allocators may implement this method with a no-op.
+    //
+    // Note: It would be nice to have an associated type that on construction
+    // does the increment and on drop does the decrement but there are two
+    // problems with this:
+    //
+    // 1. This trait's implementations are always used as trait objects, and
+    //    associated types are not object safe.
+    //
+    // 2. We would want a parameterized `Drop` implementation so that we could
+    //    pass in the `InstanceAllocatorImpl` on drop, but this doesn't exist in
+    //    Rust. Therefore, we would be forced to add reference counting and
+    //    stuff like that to keep a handle on the instance allocator from this
+    //    theoretical type. That's a bummer.
+    fn increment_component_instance_count(&self) -> Result<()>;
+
+    /// The dual of `increment_component_instance_count`.
+    fn decrement_component_instance_count(&self);
+
+    /// Increment the count of concurrent core module instances that are
+    /// currently allocated, if applicable.
+    ///
+    /// Not all instance allocators will have limits for the maximum number of
+    /// concurrent core module instances that can be live at the same time, and
+    /// these allocators may implement this method with a no-op.
+    fn increment_core_instance_count(&self) -> Result<()>;
+
+    /// The dual of `increment_core_instance_count`.
+    fn decrement_core_instance_count(&self);
+
+    /// Allocate a memory for an instance.
+    ///
+    /// # Unsafety
+    ///
+    /// The memory and its associated module must have already been validated by
+    /// `Self::validate_module` and passed that validation.
+    unsafe fn allocate_memory(
+        &self,
+        request: &mut InstanceAllocationRequest,
+        memory_plan: &MemoryPlan,
+        memory_index: DefinedMemoryIndex,
+    ) -> Result<(MemoryAllocationIndex, Memory)>;
+
+    /// Deallocate an instance's previously allocated memory.
+    ///
+    /// # Unsafety
+    ///
+    /// The memory must have previously been allocated by
+    /// `Self::allocate_memory`, be at the given index, and must currently be
+    /// allocated. It must never be used again.
+    unsafe fn deallocate_memory(
+        &self,
+        memory_index: DefinedMemoryIndex,
+        allocation_index: MemoryAllocationIndex,
+        memory: Memory,
+    );
+
+    /// Allocate a table for an instance.
+    ///
+    /// # Unsafety
+    ///
+    /// The table and its associated module must have already been validated by
+    /// `Self::validate_module` and passed that validation.
+    unsafe fn allocate_table(
+        &self,
+        req: &mut InstanceAllocationRequest,
+        table_plan: &TablePlan,
+        table_index: DefinedTableIndex,
+    ) -> Result<(TableAllocationIndex, Table)>;
+
+    /// Deallocate an instance's previously allocated table.
+    ///
+    /// # Unsafety
+    ///
+    /// The table must have previously been allocated by `Self::allocate_table`,
+    /// be at the given index, and must currently be allocated. It must never be
+    /// used again.
+    unsafe fn deallocate_table(
+        &self,
+        table_index: DefinedTableIndex,
+        allocation_index: TableAllocationIndex,
+        table: Table,
+    );
+
+    /// Allocates a fiber stack for calling async functions on.
+    #[cfg(feature = "async")]
+    fn allocate_fiber_stack(&self) -> Result<wasmtime_fiber::FiberStack>;
+
+    /// Deallocates a fiber stack that was previously allocated with
+    /// `allocate_fiber_stack`.
+    ///
+    /// # Safety
+    ///
+    /// The provided stack is required to have been allocated with
+    /// `allocate_fiber_stack`.
+    #[cfg(feature = "async")]
+    unsafe fn deallocate_fiber_stack(&self, stack: wasmtime_fiber::FiberStack);
+
+    /// Allocate a GC heap for allocating Wasm GC objects within.
+    #[cfg(feature = "gc")]
+    fn allocate_gc_heap(
+        &self,
+        gc_runtime: &dyn GcRuntime,
+    ) -> Result<(GcHeapAllocationIndex, Box<dyn GcHeap>)>;
+
+    /// Deallocate a GC heap that was previously allocated with
+    /// `allocate_gc_heap`.
+    #[cfg(feature = "gc")]
+    fn deallocate_gc_heap(&self, allocation_index: GcHeapAllocationIndex, gc_heap: Box<dyn GcHeap>);
+
+    /// Purges all lingering resources related to `module` from within this
+    /// allocator.
+    ///
+    /// Primarily present for the pooling allocator to remove mappings of
+    /// this module from slots in linear memory.
+    fn purge_module(&self, module: CompiledModuleId);
+
+    /// Use the next available protection key.
+    ///
+    /// The pooling allocator can use memory protection keys (MPK) for
+    /// compressing the guard regions protecting against OOB. Each
+    /// pool-allocated store needs its own key.
+    fn next_available_pkey(&self) -> Option<ProtectionKey>;
+
+    /// Restrict access to memory regions protected by `pkey`.
+    ///
+    /// This is useful for the pooling allocator, which can use memory
+    /// protection keys (MPK). Note: this may still allow access to other
+    /// protection keys, such as the default kernel key; see implementations of
+    /// this.
+    fn restrict_to_pkey(&self, pkey: ProtectionKey);
+
+    /// Allow access to memory regions protected by any protection key.
+    fn allow_all_pkeys(&self);
+}
+
+/// A thing that can allocate instances.
+///
+/// Don't implement this trait directly, instead implement
+/// `InstanceAllocatorImpl` and you'll get this trait for free via a blanket
+/// impl.
+pub trait InstanceAllocator: InstanceAllocatorImpl {
+    /// Validate whether a component (including all of its contained core
+    /// modules) is allocatable with this instance allocator.
+    #[cfg(feature = "component-model")]
+    fn validate_component<'a>(
+        &self,
+        component: &Component,
+        offsets: &VMComponentOffsets<HostPtr>,
+        get_module: &'a dyn Fn(StaticModuleIndex) -> &'a Module,
+    ) -> Result<()> {
+        InstanceAllocatorImpl::validate_component_impl(self, component, offsets, get_module)
+    }
+
+    /// Validate whether a core module is allocatable with this instance
+    /// allocator.
+    fn validate_module(&self, module: &Module, offsets: &VMOffsets<HostPtr>) -> Result<()> {
+        InstanceAllocatorImpl::validate_module_impl(self, module, offsets)
+    }
+
+    /// Allocates a fresh `InstanceHandle` for the `req` given.
+    ///
+    /// This will allocate memories and tables internally from this allocator
+    /// and weave that altogether into a final and complete `InstanceHandle`
+    /// ready to be registered with a store.
+    ///
+    /// Note that the returned instance must still have `.initialize(..)` called
+    /// on it to complete the instantiation process.
+    ///
+    /// # Unsafety
+    ///
+    /// The request's associated module, memories, tables, and vmctx must have
+    /// already have been validated by `Self::validate_module`.
+    unsafe fn allocate_module(
+        &self,
+        mut request: InstanceAllocationRequest,
+    ) -> Result<InstanceHandle> {
+        let module = request.runtime_info.module();
+
+        #[cfg(debug_assertions)]
+        InstanceAllocatorImpl::validate_module_impl(self, module, request.runtime_info.offsets())
+            .expect("module should have already been validated before allocation");
+
+        self.increment_core_instance_count()?;
+
+        let num_defined_memories = module.memory_plans.len() - module.num_imported_memories;
+        let mut memories = PrimaryMap::with_capacity(num_defined_memories);
+
+        let num_defined_tables = module.table_plans.len() - module.num_imported_tables;
+        let mut tables = PrimaryMap::with_capacity(num_defined_tables);
+
+        match (|| {
+            self.allocate_memories(&mut request, &mut memories)?;
+            self.allocate_tables(&mut request, &mut tables)?;
+            Ok(())
+        })() {
+            Ok(_) => Ok(Instance::new(
+                request,
+                memories,
+                tables,
+                &module.memory_plans,
+            )),
+            Err(e) => {
+                self.deallocate_memories(&mut memories);
+                self.deallocate_tables(&mut tables);
+                self.decrement_core_instance_count();
+                Err(e)
+            }
+        }
+    }
+
+    /// Deallocates the provided instance.
+    ///
+    /// This will null-out the pointer within `handle` and otherwise reclaim
+    /// resources such as tables, memories, and the instance memory itself.
+    ///
+    /// # Unsafety
+    ///
+    /// The instance must have previously been allocated by `Self::allocate`.
+    unsafe fn deallocate_module(&self, handle: &mut InstanceHandle) {
+        self.deallocate_memories(&mut handle.instance_mut().memories);
+        self.deallocate_tables(&mut handle.instance_mut().tables);
+
+        let layout = Instance::alloc_layout(handle.instance().offsets());
+        let ptr = handle.instance.take().unwrap();
+        ptr::drop_in_place(ptr.as_ptr());
+        alloc::alloc::dealloc(ptr.as_ptr().cast(), layout);
+
+        self.decrement_core_instance_count();
+    }
+
+    /// Allocate the memories for the given instance allocation request, pushing
+    /// them into `memories`.
+    ///
+    /// # Unsafety
+    ///
+    /// The request's associated module and memories must have previously been
+    /// validated by `Self::validate_module`.
+    unsafe fn allocate_memories(
+        &self,
+        request: &mut InstanceAllocationRequest,
+        memories: &mut PrimaryMap<DefinedMemoryIndex, (MemoryAllocationIndex, Memory)>,
+    ) -> Result<()> {
+        let module = request.runtime_info.module();
+
+        #[cfg(debug_assertions)]
+        InstanceAllocatorImpl::validate_module_impl(self, module, request.runtime_info.offsets())
+            .expect("module should have already been validated before allocation");
+
+        for (memory_index, memory_plan) in module
+            .memory_plans
+            .iter()
+            .skip(module.num_imported_memories)
+        {
+            let memory_index = module
+                .defined_memory_index(memory_index)
+                .expect("should be a defined memory since we skipped imported ones");
+
+            memories.push(self.allocate_memory(request, memory_plan, memory_index)?);
+        }
+
+        Ok(())
+    }
+
+    /// Deallocate all the memories in the given primary map.
+    ///
+    /// # Unsafety
+    ///
+    /// The memories must have previously been allocated by
+    /// `Self::allocate_memories`.
+    unsafe fn deallocate_memories(
+        &self,
+        memories: &mut PrimaryMap<DefinedMemoryIndex, (MemoryAllocationIndex, Memory)>,
+    ) {
+        for (memory_index, (allocation_index, memory)) in mem::take(memories) {
+            // Because deallocating memory is infallible, we don't need to worry
+            // about leaking subsequent memories if the first memory failed to
+            // deallocate. If deallocating memory ever becomes fallible, we will
+            // need to be careful here!
+            self.deallocate_memory(memory_index, allocation_index, memory);
+        }
+    }
+
+    /// Allocate tables for the given instance allocation request, pushing them
+    /// into `tables`.
+    ///
+    /// # Unsafety
+    ///
+    /// The request's associated module and tables must have previously been
+    /// validated by `Self::validate_module`.
+    unsafe fn allocate_tables(
+        &self,
+        request: &mut InstanceAllocationRequest,
+        tables: &mut PrimaryMap<DefinedTableIndex, (TableAllocationIndex, Table)>,
+    ) -> Result<()> {
+        let module = request.runtime_info.module();
+
+        #[cfg(debug_assertions)]
+        InstanceAllocatorImpl::validate_module_impl(self, module, request.runtime_info.offsets())
+            .expect("module should have already been validated before allocation");
+
+        for (index, plan) in module.table_plans.iter().skip(module.num_imported_tables) {
+            let def_index = module
+                .defined_table_index(index)
+                .expect("should be a defined table since we skipped imported ones");
+
+            tables.push(self.allocate_table(request, plan, def_index)?);
+        }
+
+        Ok(())
+    }
+
+    /// Deallocate all the tables in the given primary map.
+    ///
+    /// # Unsafety
+    ///
+    /// The tables must have previously been allocated by
+    /// `Self::allocate_tables`.
+    unsafe fn deallocate_tables(
+        &self,
+        tables: &mut PrimaryMap<DefinedTableIndex, (TableAllocationIndex, Table)>,
+    ) {
+        for (table_index, (allocation_index, table)) in mem::take(tables) {
+            self.deallocate_table(table_index, allocation_index, table);
+        }
+    }
+}
+
+// Every `InstanceAllocatorImpl` is an `InstanceAllocator` when used
+// correctly. Also, no one is allowed to override this trait's methods, they
+// must use the defaults. This blanket impl provides both of those things.
+impl<T: InstanceAllocatorImpl> InstanceAllocator for T {}
+
+fn check_table_init_bounds(instance: &mut Instance, module: &Module) -> Result<()> {
+    let mut const_evaluator = ConstExprEvaluator::default();
+
+    for segment in module.table_initialization.segments.iter() {
+        let table = unsafe { &*instance.get_table(segment.table_index) };
+        let mut context = ConstEvalContext::new(instance, module);
+        let start = unsafe {
+            const_evaluator
+                .eval(&mut context, &segment.offset)
+                .expect("const expression should be valid")
+        };
+        let start = usize::try_from(start.get_u32()).unwrap();
+        let end = start.checked_add(usize::try_from(segment.elements.len()).unwrap());
+
+        match end {
+            Some(end) if end <= table.size() as usize => {
+                // Initializer is in bounds
+            }
+            _ => {
+                bail!("table out of bounds: elements segment does not fit")
+            }
+        }
+    }
+
+    Ok(())
+}
+
+fn initialize_tables(instance: &mut Instance, module: &Module) -> Result<()> {
+    let mut const_evaluator = ConstExprEvaluator::default();
+
+    for (table, init) in module.table_initialization.initial_values.iter() {
+        match init {
+            // Tables are always initially null-initialized at this time
+            TableInitialValue::Null { precomputed: _ } => {}
+
+            TableInitialValue::Expr(expr) => {
+                let mut context = ConstEvalContext::new(instance, module);
+                let raw = unsafe {
+                    const_evaluator
+                        .eval(&mut context, expr)
+                        .expect("const expression should be valid")
+                };
+                let idx = module.table_index(table);
+                let table = unsafe { instance.get_defined_table(table).as_mut().unwrap() };
+                match module.table_plans[idx].table.wasm_ty.heap_type.top() {
+                    WasmHeapTopType::Extern => {
+                        let gc_ref = VMGcRef::from_raw_u32(raw.get_externref());
+                        let gc_store = unsafe { (*instance.store()).gc_store() };
+                        let items = (0..table.size())
+                            .map(|_| gc_ref.as_ref().map(|r| gc_store.clone_gc_ref(r)));
+                        table.init_gc_refs(0, items).err2anyhow()?;
+                    }
+
+                    WasmHeapTopType::Any => {
+                        let gc_ref = VMGcRef::from_raw_u32(raw.get_anyref());
+                        let gc_store = unsafe { (*instance.store()).gc_store() };
+                        let items = (0..table.size())
+                            .map(|_| gc_ref.as_ref().map(|r| gc_store.clone_gc_ref(r)));
+                        table.init_gc_refs(0, items).err2anyhow()?;
+                    }
+
+                    WasmHeapTopType::Func => {
+                        let funcref = raw.get_funcref().cast::<VMFuncRef>();
+                        let items = (0..table.size()).map(|_| funcref);
+                        table.init_func(0, items).err2anyhow()?;
+                    }
+                }
+            }
+        }
+    }
+
+    // Note: if the module's table initializer state is in
+    // FuncTable mode, we will lazily initialize tables based on
+    // any statically-precomputed image of FuncIndexes, but there
+    // may still be "leftover segments" that could not be
+    // incorporated. So we have a unified handler here that
+    // iterates over all segments (Segments mode) or leftover
+    // segments (FuncTable mode) to initialize.
+    for segment in module.table_initialization.segments.iter() {
+        let mut context = ConstEvalContext::new(instance, module);
+        let start = unsafe {
+            const_evaluator
+                .eval(&mut context, &segment.offset)
+                .expect("const expression should be valid")
+        };
+        instance
+            .table_init_segment(
+                &mut const_evaluator,
+                segment.table_index,
+                &segment.elements,
+                start.get_u32(),
+                0,
+                segment.elements.len(),
+            )
+            .err2anyhow()?;
+    }
+
+    Ok(())
+}
+
+fn get_memory_init_start(
+    init: &MemoryInitializer,
+    instance: &mut Instance,
+    module: &Module,
+) -> Result<u64> {
+    let mem64 = instance.module().memory_plans[init.memory_index]
+        .memory
+        .memory64;
+    let mut context = ConstEvalContext::new(instance, module);
+    let mut const_evaluator = ConstExprEvaluator::default();
+    unsafe { const_evaluator.eval(&mut context, &init.offset) }.map(|v| {
+        if mem64 {
+            v.get_u64()
+        } else {
+            v.get_u32().into()
+        }
+    })
+}
+
+fn check_memory_init_bounds(
+    instance: &mut Instance,
+    module: &Module,
+    initializers: &[MemoryInitializer],
+) -> Result<()> {
+    for init in initializers {
+        let memory = instance.get_memory(init.memory_index);
+        let start = get_memory_init_start(init, instance, module)?;
+        let end = usize::try_from(start)
+            .ok()
+            .and_then(|start| start.checked_add(init.data.len()));
+
+        match end {
+            Some(end) if end <= memory.current_length() => {
+                // Initializer is in bounds
+            }
+            _ => {
+                bail!("memory out of bounds: data segment does not fit")
+            }
+        }
+    }
+
+    Ok(())
+}
+
+fn initialize_memories(instance: &mut Instance, module: &Module) -> Result<()> {
+    // Delegates to the `init_memory` method which is sort of a duplicate of
+    // `instance.memory_init_segment` but is used at compile-time in other
+    // contexts so is shared here to have only one method of memory
+    // initialization.
+    //
+    // This call to `init_memory` notably implements all the bells and whistles
+    // so errors only happen if an out-of-bounds segment is found, in which case
+    // a trap is returned.
+
+    struct InitMemoryAtInstantiation<'a> {
+        instance: &'a mut Instance,
+        module: &'a Module,
+        const_evaluator: ConstExprEvaluator,
+    }
+
+    impl InitMemory for InitMemoryAtInstantiation<'_> {
+        fn memory_size_in_bytes(
+            &mut self,
+            memory: wasmtime_environ::MemoryIndex,
+        ) -> Result<u64, SizeOverflow> {
+            let len = self.instance.get_memory(memory).current_length();
+            let len = u64::try_from(len).unwrap();
+            Ok(len)
+        }
+
+        fn eval_offset(
+            &mut self,
+            memory: wasmtime_environ::MemoryIndex,
+            expr: &wasmtime_environ::ConstExpr,
+        ) -> Option<u64> {
+            let mem64 = self.instance.module().memory_plans[memory].memory.memory64;
+            let mut context = ConstEvalContext::new(self.instance, self.module);
+            let val = unsafe { self.const_evaluator.eval(&mut context, expr) }
+                .expect("const expression should be valid");
+            Some(if mem64 {
+                val.get_u64()
+            } else {
+                val.get_u32().into()
+            })
+        }
+
+        fn write(
+            &mut self,
+            memory_index: wasmtime_environ::MemoryIndex,
+            init: &wasmtime_environ::StaticMemoryInitializer,
+        ) -> bool {
+            // If this initializer applies to a defined memory but that memory
+            // doesn't need initialization, due to something like copy-on-write
+            // pre-initializing it via mmap magic, then this initializer can be
+            // skipped entirely.
+            if let Some(memory_index) = self.module.defined_memory_index(memory_index) {
+                if !self.instance.memories[memory_index].1.needs_init() {
+                    return true;
+                }
+            }
+            let memory = self.instance.get_memory(memory_index);
+
+            unsafe {
+                let src = self.instance.wasm_data(init.data.clone());
+                let offset = usize::try_from(init.offset).unwrap();
+                let dst = memory.base.add(offset);
+
+                assert!(offset + src.len() <= memory.current_length());
+
+                // FIXME audit whether this is safe in the presence of shared
+                // memory
+                // (https://github.com/bytecodealliance/wasmtime/issues/4203).
+                ptr::copy_nonoverlapping(src.as_ptr(), dst, src.len())
+            }
+            true
+        }
+    }
+
+    let ok = module
+        .memory_initialization
+        .init_memory(&mut InitMemoryAtInstantiation {
+            instance,
+            module,
+            const_evaluator: ConstExprEvaluator::default(),
+        });
+    if !ok {
+        return Err(Trap::MemoryOutOfBounds).err2anyhow();
+    }
+
+    Ok(())
+}
+
+fn check_init_bounds(instance: &mut Instance, module: &Module) -> Result<()> {
+    check_table_init_bounds(instance, module)?;
+
+    match &module.memory_initialization {
+        MemoryInitialization::Segmented(initializers) => {
+            check_memory_init_bounds(instance, module, initializers)?;
+        }
+        // Statically validated already to have everything in-bounds.
+        MemoryInitialization::Static { .. } => {}
+    }
+
+    Ok(())
+}
+
+pub(super) fn initialize_instance(
+    instance: &mut Instance,
+    module: &Module,
+    is_bulk_memory: bool,
+) -> Result<()> {
+    // If bulk memory is not enabled, bounds check the data and element segments before
+    // making any changes. With bulk memory enabled, initializers are processed
+    // in-order and side effects are observed up to the point of an out-of-bounds
+    // initializer, so the early checking is not desired.
+    if !is_bulk_memory {
+        check_init_bounds(instance, module)?;
+    }
+
+    // Initialize the tables
+    initialize_tables(instance, module)?;
+
+    // Initialize the memories
+    initialize_memories(instance, &module)?;
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn allocator_traits_are_object_safe() {
+        fn _instance_allocator(_: &dyn InstanceAllocatorImpl) {}
+        fn _instance_allocator_ext(_: &dyn InstanceAllocator) {}
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/instance/allocator/on_demand.rs b/crates/wasmtime/src/runtime/vm/instance/allocator/on_demand.rs
new file mode 100644
index 000000000000..1f2dcb292a05
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/instance/allocator/on_demand.rs
@@ -0,0 +1,219 @@
+use super::{
+    InstanceAllocationRequest, InstanceAllocatorImpl, MemoryAllocationIndex, TableAllocationIndex,
+};
+use crate::prelude::*;
+use crate::runtime::vm::instance::RuntimeMemoryCreator;
+use crate::runtime::vm::memory::{DefaultMemoryCreator, Memory};
+use crate::runtime::vm::mpk::ProtectionKey;
+use crate::runtime::vm::table::Table;
+use crate::runtime::vm::CompiledModuleId;
+use alloc::sync::Arc;
+use wasmtime_environ::{
+    DefinedMemoryIndex, DefinedTableIndex, HostPtr, MemoryPlan, Module, TablePlan, VMOffsets,
+};
+
+#[cfg(feature = "gc")]
+use crate::runtime::vm::{GcHeap, GcHeapAllocationIndex, GcRuntime};
+
+#[cfg(feature = "async")]
+use wasmtime_fiber::RuntimeFiberStackCreator;
+
+#[cfg(feature = "component-model")]
+use wasmtime_environ::{
+    component::{Component, VMComponentOffsets},
+    StaticModuleIndex,
+};
+
+/// Represents the on-demand instance allocator.
+#[derive(Clone)]
+pub struct OnDemandInstanceAllocator {
+    mem_creator: Option<Arc<dyn RuntimeMemoryCreator>>,
+    #[cfg(feature = "async")]
+    stack_creator: Option<Arc<dyn RuntimeFiberStackCreator>>,
+    #[cfg(feature = "async")]
+    stack_size: usize,
+}
+
+impl OnDemandInstanceAllocator {
+    /// Creates a new on-demand instance allocator.
+    pub fn new(mem_creator: Option<Arc<dyn RuntimeMemoryCreator>>, stack_size: usize) -> Self {
+        let _ = stack_size; // suppress warnings when async feature is disabled.
+        Self {
+            mem_creator,
+            #[cfg(feature = "async")]
+            stack_creator: None,
+            #[cfg(feature = "async")]
+            stack_size,
+        }
+    }
+
+    /// Set the stack creator.
+    #[cfg(feature = "async")]
+    pub fn set_stack_creator(&mut self, stack_creator: Arc<dyn RuntimeFiberStackCreator>) {
+        self.stack_creator = Some(stack_creator);
+    }
+}
+
+impl Default for OnDemandInstanceAllocator {
+    fn default() -> Self {
+        Self {
+            mem_creator: None,
+            #[cfg(feature = "async")]
+            stack_creator: None,
+            #[cfg(feature = "async")]
+            stack_size: 0,
+        }
+    }
+}
+
+unsafe impl InstanceAllocatorImpl for OnDemandInstanceAllocator {
+    #[cfg(feature = "component-model")]
+    fn validate_component_impl<'a>(
+        &self,
+        _component: &Component,
+        _offsets: &VMComponentOffsets<HostPtr>,
+        _get_module: &'a dyn Fn(StaticModuleIndex) -> &'a Module,
+    ) -> Result<()> {
+        Ok(())
+    }
+
+    fn validate_module_impl(&self, _module: &Module, _offsets: &VMOffsets<HostPtr>) -> Result<()> {
+        Ok(())
+    }
+
+    fn increment_component_instance_count(&self) -> Result<()> {
+        Ok(())
+    }
+
+    fn decrement_component_instance_count(&self) {}
+
+    fn increment_core_instance_count(&self) -> Result<()> {
+        Ok(())
+    }
+
+    fn decrement_core_instance_count(&self) {}
+
+    unsafe fn allocate_memory(
+        &self,
+        request: &mut InstanceAllocationRequest,
+        memory_plan: &MemoryPlan,
+        memory_index: DefinedMemoryIndex,
+    ) -> Result<(MemoryAllocationIndex, Memory)> {
+        let creator = self
+            .mem_creator
+            .as_deref()
+            .unwrap_or_else(|| &DefaultMemoryCreator);
+        let image = request.runtime_info.memory_image(memory_index)?;
+        let allocation_index = MemoryAllocationIndex::default();
+        let memory = Memory::new_dynamic(
+            memory_plan,
+            creator,
+            request
+                .store
+                .get()
+                .expect("if module has memory plans, store is not empty"),
+            image,
+        )?;
+        Ok((allocation_index, memory))
+    }
+
+    unsafe fn deallocate_memory(
+        &self,
+        _memory_index: DefinedMemoryIndex,
+        allocation_index: MemoryAllocationIndex,
+        _memory: Memory,
+    ) {
+        debug_assert_eq!(allocation_index, MemoryAllocationIndex::default());
+        // Normal destructors do all the necessary clean up.
+    }
+
+    unsafe fn allocate_table(
+        &self,
+        request: &mut InstanceAllocationRequest,
+        table_plan: &TablePlan,
+        _table_index: DefinedTableIndex,
+    ) -> Result<(TableAllocationIndex, Table)> {
+        let allocation_index = TableAllocationIndex::default();
+        let table = Table::new_dynamic(
+            table_plan,
+            request
+                .store
+                .get()
+                .expect("if module has table plans, store is not empty"),
+        )?;
+        Ok((allocation_index, table))
+    }
+
+    unsafe fn deallocate_table(
+        &self,
+        _table_index: DefinedTableIndex,
+        allocation_index: TableAllocationIndex,
+        _table: Table,
+    ) {
+        debug_assert_eq!(allocation_index, TableAllocationIndex::default());
+        // Normal destructors do all the necessary clean up.
+    }
+
+    #[cfg(feature = "async")]
+    fn allocate_fiber_stack(&self) -> Result<wasmtime_fiber::FiberStack> {
+        if self.stack_size == 0 {
+            anyhow::bail!("fiber stacks are not supported by the allocator")
+        }
+        let stack = match &self.stack_creator {
+            Some(stack_creator) => {
+                let stack = stack_creator.new_stack(self.stack_size)?;
+                wasmtime_fiber::FiberStack::from_custom(stack)
+            }
+            None => wasmtime_fiber::FiberStack::new(self.stack_size),
+        }?;
+        Ok(stack)
+    }
+
+    #[cfg(feature = "async")]
+    unsafe fn deallocate_fiber_stack(&self, stack: wasmtime_fiber::FiberStack) {
+        // The on-demand allocator has no further bookkeeping for fiber stacks
+        // beyond dropping them.
+        let _ = stack;
+    }
+
+    fn purge_module(&self, _: CompiledModuleId) {}
+
+    fn next_available_pkey(&self) -> Option<ProtectionKey> {
+        // The on-demand allocator cannot use protection keys--it requires
+        // back-to-back allocation of memory slots that this allocator cannot
+        // guarantee.
+        None
+    }
+
+    fn restrict_to_pkey(&self, _: ProtectionKey) {
+        // The on-demand allocator cannot use protection keys; an on-demand
+        // allocator will never hand out protection keys to the stores its
+        // engine creates.
+        unreachable!()
+    }
+
+    fn allow_all_pkeys(&self) {
+        // The on-demand allocator cannot use protection keys; an on-demand
+        // allocator will never hand out protection keys to the stores its
+        // engine creates.
+        unreachable!()
+    }
+
+    #[cfg(feature = "gc")]
+    fn allocate_gc_heap(
+        &self,
+        gc_runtime: &dyn GcRuntime,
+    ) -> Result<(GcHeapAllocationIndex, Box<dyn GcHeap>)> {
+        Ok((GcHeapAllocationIndex::default(), gc_runtime.new_gc_heap()?))
+    }
+
+    #[cfg(feature = "gc")]
+    fn deallocate_gc_heap(
+        &self,
+        allocation_index: GcHeapAllocationIndex,
+        gc_heap: Box<dyn crate::runtime::vm::GcHeap>,
+    ) {
+        debug_assert_eq!(allocation_index, GcHeapAllocationIndex::default());
+        drop(gc_heap);
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/instance/allocator/pooling.rs b/crates/wasmtime/src/runtime/vm/instance/allocator/pooling.rs
new file mode 100644
index 000000000000..14c5e94ab302
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/instance/allocator/pooling.rs
@@ -0,0 +1,796 @@
+//! Implements the pooling instance allocator.
+//!
+//! The pooling instance allocator maps memory in advance and allocates
+//! instances, memories, tables, and stacks from a pool of available resources.
+//! Using the pooling instance allocator can speed up module instantiation when
+//! modules can be constrained based on configurable limits
+//! ([`InstanceLimits`]). Each new instance is stored in a "slot"; as instances
+//! are allocated and freed, these slots are either filled or emptied:
+//!
+//! ```text
+//! ┌──────┬──────┬──────┬──────┬──────┐
+//! │Slot 0│Slot 1│Slot 2│Slot 3│......│
+//! └──────┴──────┴──────┴──────┴──────┘
+//! ```
+//!
+//! Each slot has a "slot ID"--an index into the pool. Slot IDs are handed out
+//! by the [`index_allocator`] module. Note that each kind of pool-allocated
+//! item is stored in its own separate pool: [`memory_pool`], [`table_pool`],
+//! [`stack_pool`]. See those modules for more details.
+
+mod decommit_queue;
+mod index_allocator;
+mod memory_pool;
+mod table_pool;
+
+#[cfg(feature = "gc")]
+mod gc_heap_pool;
+
+#[cfg(all(feature = "async"))]
+mod generic_stack_pool;
+#[cfg(all(feature = "async", unix, not(miri)))]
+mod unix_stack_pool;
+
+#[cfg(all(feature = "async"))]
+cfg_if::cfg_if! {
+    if #[cfg(all(unix, not(miri), not(asan)))] {
+        use unix_stack_pool as stack_pool;
+    } else {
+        use generic_stack_pool as stack_pool;
+    }
+}
+
+use self::decommit_queue::DecommitQueue;
+use self::memory_pool::MemoryPool;
+use self::table_pool::TablePool;
+use super::{
+    InstanceAllocationRequest, InstanceAllocatorImpl, MemoryAllocationIndex, TableAllocationIndex,
+};
+use crate::prelude::*;
+use crate::runtime::vm::{
+    instance::Instance,
+    mpk::{self, MpkEnabled, ProtectionKey, ProtectionMask},
+    CompiledModuleId, Memory, Table,
+};
+use std::borrow::Cow;
+use std::fmt::Display;
+use std::sync::{Mutex, MutexGuard};
+use std::{
+    mem,
+    sync::atomic::{AtomicU64, Ordering},
+};
+use wasmtime_environ::{
+    DefinedMemoryIndex, DefinedTableIndex, HostPtr, MemoryPlan, Module, TablePlan, Tunables,
+    VMOffsets,
+};
+
+#[cfg(feature = "gc")]
+use super::GcHeapAllocationIndex;
+#[cfg(feature = "gc")]
+use crate::runtime::vm::{GcHeap, GcRuntime};
+#[cfg(feature = "gc")]
+use gc_heap_pool::GcHeapPool;
+
+#[cfg(feature = "async")]
+use stack_pool::StackPool;
+
+#[cfg(feature = "component-model")]
+use wasmtime_environ::{
+    component::{Component, VMComponentOffsets},
+    StaticModuleIndex,
+};
+
+fn round_up_to_pow2(n: usize, to: usize) -> usize {
+    debug_assert!(to > 0);
+    debug_assert!(to.is_power_of_two());
+    (n + to - 1) & !(to - 1)
+}
+
+/// Instance-related limit configuration for pooling.
+///
+/// More docs on this can be found at `wasmtime::PoolingAllocationConfig`.
+#[derive(Debug, Copy, Clone)]
+pub struct InstanceLimits {
+    /// The maximum number of component instances that may be allocated
+    /// concurrently.
+    pub total_component_instances: u32,
+
+    /// The maximum size of a component's `VMComponentContext`, not including
+    /// any of its inner core modules' `VMContext` sizes.
+    pub component_instance_size: usize,
+
+    /// The maximum number of core module instances that may be allocated
+    /// concurrently.
+    pub total_core_instances: u32,
+
+    /// The maximum number of core module instances that a single component may
+    /// transitively contain.
+    pub max_core_instances_per_component: u32,
+
+    /// The maximum number of Wasm linear memories that a component may
+    /// transitively contain.
+    pub max_memories_per_component: u32,
+
+    /// The maximum number of tables that a component may transitively contain.
+    pub max_tables_per_component: u32,
+
+    /// The total number of linear memories in the pool, across all instances.
+    pub total_memories: u32,
+
+    /// The total number of tables in the pool, across all instances.
+    pub total_tables: u32,
+
+    /// The total number of async stacks in the pool, across all instances.
+    #[cfg(feature = "async")]
+    pub total_stacks: u32,
+
+    /// Maximum size of a core instance's `VMContext`.
+    pub core_instance_size: usize,
+
+    /// Maximum number of tables per instance.
+    pub max_tables_per_module: u32,
+
+    /// Maximum number of table elements per table.
+    pub table_elements: u32,
+
+    /// Maximum number of linear memories per instance.
+    pub max_memories_per_module: u32,
+
+    /// Maximum byte size of a linear memory, must be smaller than
+    /// `static_memory_reservation` in `Tunables`.
+    pub max_memory_size: usize,
+
+    /// The total number of GC heaps in the pool, across all instances.
+    #[cfg(feature = "gc")]
+    pub total_gc_heaps: u32,
+}
+
+impl Default for InstanceLimits {
+    fn default() -> Self {
+        // See doc comments for `wasmtime::PoolingAllocationConfig` for these
+        // default values
+        Self {
+            total_component_instances: 1000,
+            component_instance_size: 1 << 20, // 1 MiB
+            total_core_instances: 1000,
+            max_core_instances_per_component: 20,
+            max_memories_per_component: 20,
+            max_tables_per_component: 20,
+            total_memories: 1000,
+            total_tables: 1000,
+            #[cfg(feature = "async")]
+            total_stacks: 1000,
+            core_instance_size: 1 << 20, // 1 MiB
+            max_tables_per_module: 1,
+            // NB: in #8504 it was seen that a C# module in debug module can
+            // have 10k+ elements.
+            table_elements: 20_000,
+            max_memories_per_module: 1,
+            #[cfg(target_pointer_width = "64")]
+            max_memory_size: 1 << 32, // 4G,
+            #[cfg(target_pointer_width = "32")]
+            max_memory_size: usize::MAX,
+            #[cfg(feature = "gc")]
+            total_gc_heaps: 1000,
+        }
+    }
+}
+
+/// Configuration options for the pooling instance allocator supplied at
+/// construction.
+#[derive(Copy, Clone, Debug)]
+pub struct PoolingInstanceAllocatorConfig {
+    /// See `PoolingAllocatorConfig::max_unused_warm_slots` in `wasmtime`
+    pub max_unused_warm_slots: u32,
+    /// The target number of decommits to do per batch. This is not precise, as
+    /// we can queue up decommits at times when we aren't prepared to
+    /// immediately flush them, and so we may go over this target size
+    /// occasionally.
+    pub decommit_batch_size: usize,
+    /// The size, in bytes, of async stacks to allocate (not including the guard
+    /// page).
+    pub stack_size: usize,
+    /// The limits to apply to instances allocated within this allocator.
+    pub limits: InstanceLimits,
+    /// Whether or not async stacks are zeroed after use.
+    pub async_stack_zeroing: bool,
+    /// If async stack zeroing is enabled and the host platform is Linux this is
+    /// how much memory to zero out with `memset`.
+    ///
+    /// The rest of memory will be zeroed out with `madvise`.
+    pub async_stack_keep_resident: usize,
+    /// How much linear memory, in bytes, to keep resident after resetting for
+    /// use with the next instance. This much memory will be `memset` to zero
+    /// when a linear memory is deallocated.
+    ///
+    /// Memory exceeding this amount in the wasm linear memory will be released
+    /// with `madvise` back to the kernel.
+    ///
+    /// Only applicable on Linux.
+    pub linear_memory_keep_resident: usize,
+    /// Same as `linear_memory_keep_resident` but for tables.
+    pub table_keep_resident: usize,
+    /// Whether to enable memory protection keys.
+    pub memory_protection_keys: MpkEnabled,
+    /// How many memory protection keys to allocate.
+    pub max_memory_protection_keys: usize,
+}
+
+impl Default for PoolingInstanceAllocatorConfig {
+    fn default() -> PoolingInstanceAllocatorConfig {
+        PoolingInstanceAllocatorConfig {
+            max_unused_warm_slots: 100,
+            decommit_batch_size: 1,
+            stack_size: 2 << 20,
+            limits: InstanceLimits::default(),
+            async_stack_zeroing: false,
+            async_stack_keep_resident: 0,
+            linear_memory_keep_resident: 0,
+            table_keep_resident: 0,
+            memory_protection_keys: MpkEnabled::Disable,
+            max_memory_protection_keys: 16,
+        }
+    }
+}
+
+/// An error returned when the pooling allocator cannot allocate a table,
+/// memory, etc... because the maximum number of concurrent allocations for that
+/// entity has been reached.
+#[derive(Debug)]
+pub struct PoolConcurrencyLimitError {
+    limit: usize,
+    kind: Cow<'static, str>,
+}
+
+impl std::error::Error for PoolConcurrencyLimitError {}
+
+impl Display for PoolConcurrencyLimitError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let limit = self.limit;
+        let kind = &self.kind;
+        write!(f, "maximum concurrent limit of {limit} for {kind} reached")
+    }
+}
+
+impl PoolConcurrencyLimitError {
+    fn new(limit: usize, kind: impl Into<Cow<'static, str>>) -> Self {
+        Self {
+            limit,
+            kind: kind.into(),
+        }
+    }
+}
+
+/// Implements the pooling instance allocator.
+///
+/// This allocator internally maintains pools of instances, memories, tables,
+/// and stacks.
+///
+/// Note: the resource pools are manually dropped so that the fault handler
+/// terminates correctly.
+#[derive(Debug)]
+pub struct PoolingInstanceAllocator {
+    decommit_batch_size: usize,
+    limits: InstanceLimits,
+
+    // The number of live core module and component instances at any given
+    // time. Note that this can temporarily go over the configured limit. This
+    // doesn't mean we have actually overshot, but that we attempted to allocate
+    // a new instance and incremented the counter, we've seen (or are about to
+    // see) that the counter is beyond the configured threshold, and are going
+    // to decrement the counter and return an error but haven't done so yet. See
+    // the increment trait methods for more details.
+    live_core_instances: AtomicU64,
+    live_component_instances: AtomicU64,
+
+    decommit_queue: Mutex<DecommitQueue>,
+    memories: MemoryPool,
+    tables: TablePool,
+
+    #[cfg(feature = "gc")]
+    gc_heaps: GcHeapPool,
+
+    #[cfg(feature = "async")]
+    stacks: StackPool,
+}
+
+#[cfg(debug_assertions)]
+impl Drop for PoolingInstanceAllocator {
+    fn drop(&mut self) {
+        // NB: when cfg(not(debug_assertions)) it is okay that we don't flush
+        // the queue, as the sub-pools will unmap those ranges anyways, so
+        // there's no point in decommitting them. But we do need to flush the
+        // queue when debug assertions are enabled to make sure that all
+        // entities get returned to their associated sub-pools and we can
+        // differentiate between a leaking slot and an enqueued-for-decommit
+        // slot.
+        let queue = self.decommit_queue.lock().unwrap();
+        self.flush_decommit_queue(queue);
+
+        debug_assert_eq!(self.live_component_instances.load(Ordering::Acquire), 0);
+        debug_assert_eq!(self.live_core_instances.load(Ordering::Acquire), 0);
+
+        debug_assert!(self.memories.is_empty());
+        debug_assert!(self.tables.is_empty());
+
+        #[cfg(feature = "gc")]
+        debug_assert!(self.gc_heaps.is_empty());
+
+        #[cfg(feature = "async")]
+        debug_assert!(self.stacks.is_empty());
+    }
+}
+
+impl PoolingInstanceAllocator {
+    /// Creates a new pooling instance allocator with the given strategy and limits.
+    pub fn new(config: &PoolingInstanceAllocatorConfig, tunables: &Tunables) -> Result<Self> {
+        Ok(Self {
+            decommit_batch_size: config.decommit_batch_size,
+            limits: config.limits,
+            live_component_instances: AtomicU64::new(0),
+            live_core_instances: AtomicU64::new(0),
+            decommit_queue: Mutex::new(DecommitQueue::default()),
+            memories: MemoryPool::new(config, tunables)?,
+            tables: TablePool::new(config)?,
+            #[cfg(feature = "gc")]
+            gc_heaps: GcHeapPool::new(config)?,
+            #[cfg(feature = "async")]
+            stacks: StackPool::new(config)?,
+        })
+    }
+
+    fn core_instance_size(&self) -> usize {
+        round_up_to_pow2(self.limits.core_instance_size, mem::align_of::<Instance>())
+    }
+
+    fn validate_table_plans(&self, module: &Module) -> Result<()> {
+        self.tables.validate(module)
+    }
+
+    fn validate_memory_plans(&self, module: &Module) -> Result<()> {
+        self.memories.validate(module)
+    }
+
+    fn validate_core_instance_size(&self, offsets: &VMOffsets<HostPtr>) -> Result<()> {
+        let layout = Instance::alloc_layout(offsets);
+        if layout.size() <= self.core_instance_size() {
+            return Ok(());
+        }
+
+        // If this `module` exceeds the allocation size allotted to it then an
+        // error will be reported here. The error of "required N bytes but
+        // cannot allocate that" is pretty opaque, however, because it's not
+        // clear what the breakdown of the N bytes are and what to optimize
+        // next. To help provide a better error message here some fancy-ish
+        // logic is done here to report the breakdown of the byte request into
+        // the largest portions and where it's coming from.
+        let mut message = format!(
+            "instance allocation for this module \
+             requires {} bytes which exceeds the configured maximum \
+             of {} bytes; breakdown of allocation requirement:\n\n",
+            layout.size(),
+            self.core_instance_size(),
+        );
+
+        let mut remaining = layout.size();
+        let mut push = |name: &str, bytes: usize| {
+            assert!(remaining >= bytes);
+            remaining -= bytes;
+
+            // If the `name` region is more than 5% of the allocation request
+            // then report it here, otherwise ignore it. We have less than 20
+            // fields so we're guaranteed that something should be reported, and
+            // otherwise it's not particularly interesting to learn about 5
+            // different fields that are all 8 or 0 bytes. Only try to report
+            // the "major" sources of bytes here.
+            if bytes > layout.size() / 20 {
+                message.push_str(&format!(
+                    " * {:.02}% - {} bytes - {}\n",
+                    ((bytes as f32) / (layout.size() as f32)) * 100.0,
+                    bytes,
+                    name,
+                ));
+            }
+        };
+
+        // The `Instance` itself requires some size allocated to it.
+        push("instance state management", mem::size_of::<Instance>());
+
+        // Afterwards the `VMContext`'s regions are why we're requesting bytes,
+        // so ask it for descriptions on each region's byte size.
+        for (desc, size) in offsets.region_sizes() {
+            push(desc, size as usize);
+        }
+
+        // double-check we accounted for all the bytes
+        assert_eq!(remaining, 0);
+
+        bail!("{}", message)
+    }
+
+    #[cfg(feature = "component-model")]
+    fn validate_component_instance_size(
+        &self,
+        offsets: &VMComponentOffsets<HostPtr>,
+    ) -> Result<()> {
+        if usize::try_from(offsets.size_of_vmctx()).unwrap() <= self.limits.component_instance_size
+        {
+            return Ok(());
+        }
+
+        // TODO: Add context with detailed accounting of what makes up all the
+        // `VMComponentContext`'s space like we do for module instances.
+        bail!(
+            "instance allocation for this component requires {} bytes of `VMComponentContext` \
+             space which exceeds the configured maximum of {} bytes",
+            offsets.size_of_vmctx(),
+            self.limits.component_instance_size
+        )
+    }
+
+    fn flush_decommit_queue(&self, mut locked_queue: MutexGuard<'_, DecommitQueue>) -> bool {
+        // Take the queue out of the mutex and drop the lock, to minimize
+        // contention.
+        let queue = mem::take(&mut *locked_queue);
+        drop(locked_queue);
+        queue.flush(self)
+    }
+
+    /// Execute `f` and if it returns `Err(PoolConcurrencyLimitError)`, then try
+    /// flushing the decommit queue. If flushing the queue freed up slots, then
+    /// try running `f` again.
+    fn with_flush_and_retry<T>(&self, mut f: impl FnMut() -> Result<T>) -> Result<T> {
+        f().or_else(|e| {
+            if e.is::<PoolConcurrencyLimitError>() {
+                let queue = self.decommit_queue.lock().unwrap();
+                if self.flush_decommit_queue(queue) {
+                    return f();
+                }
+            }
+
+            Err(e)
+        })
+    }
+
+    fn merge_or_flush(&self, mut local_queue: DecommitQueue) {
+        match local_queue.raw_len() {
+            // If we didn't enqueue any regions for decommit, then we must have
+            // either memset the whole entity or eagerly remapped it to zero
+            // because we don't have linux's `madvise(DONTNEED)` semantics. In
+            // either case, the entity slot is ready for reuse immediately.
+            0 => {
+                local_queue.flush(self);
+            }
+
+            // We enqueued at least our batch size of regions for decommit, so
+            // flush the local queue immediately. Don't bother inspecting (or
+            // locking!) the shared queue.
+            n if n >= self.decommit_batch_size => {
+                local_queue.flush(self);
+            }
+
+            // If we enqueued some regions for decommit, but did not reach our
+            // batch size, so we don't want to flush it yet, then merge the
+            // local queue into the shared queue.
+            n => {
+                debug_assert!(n < self.decommit_batch_size);
+                let mut shared_queue = self.decommit_queue.lock().unwrap();
+                shared_queue.append(&mut local_queue);
+                // And if the shared queue now has at least as many regions
+                // enqueued for decommit as our batch size, then we can flush
+                // it.
+                if shared_queue.raw_len() >= self.decommit_batch_size {
+                    self.flush_decommit_queue(shared_queue);
+                }
+            }
+        }
+    }
+}
+
+unsafe impl InstanceAllocatorImpl for PoolingInstanceAllocator {
+    #[cfg(feature = "component-model")]
+    fn validate_component_impl<'a>(
+        &self,
+        component: &Component,
+        offsets: &VMComponentOffsets<HostPtr>,
+        get_module: &'a dyn Fn(StaticModuleIndex) -> &'a Module,
+    ) -> Result<()> {
+        self.validate_component_instance_size(offsets)?;
+
+        let mut num_core_instances = 0;
+        let mut num_memories = 0;
+        let mut num_tables = 0;
+        for init in &component.initializers {
+            use wasmtime_environ::component::GlobalInitializer::*;
+            use wasmtime_environ::component::InstantiateModule;
+            match init {
+                InstantiateModule(InstantiateModule::Import(_, _)) => {
+                    num_core_instances += 1;
+                    // Can't statically account for the total vmctx size, number
+                    // of memories, and number of tables in this component.
+                }
+                InstantiateModule(InstantiateModule::Static(static_module_index, _)) => {
+                    let module = get_module(*static_module_index);
+                    let offsets = VMOffsets::new(HostPtr, &module);
+                    self.validate_module_impl(module, &offsets)?;
+                    num_core_instances += 1;
+                    num_memories += module.memory_plans.len() - module.num_imported_memories;
+                    num_tables += module.table_plans.len() - module.num_imported_tables;
+                }
+                LowerImport { .. }
+                | ExtractMemory(_)
+                | ExtractRealloc(_)
+                | ExtractPostReturn(_)
+                | Resource(_) => {}
+            }
+        }
+
+        if num_core_instances
+            > usize::try_from(self.limits.max_core_instances_per_component).unwrap()
+        {
+            bail!(
+                "The component transitively contains {num_core_instances} core module instances, \
+                 which exceeds the configured maximum of {}",
+                self.limits.max_core_instances_per_component
+            );
+        }
+
+        if num_memories > usize::try_from(self.limits.max_memories_per_component).unwrap() {
+            bail!(
+                "The component transitively contains {num_memories} Wasm linear memories, which \
+                 exceeds the configured maximum of {}",
+                self.limits.max_memories_per_component
+            );
+        }
+
+        if num_tables > usize::try_from(self.limits.max_tables_per_component).unwrap() {
+            bail!(
+                "The component transitively contains {num_tables} tables, which exceeds the \
+                 configured maximum of {}",
+                self.limits.max_tables_per_component
+            );
+        }
+
+        Ok(())
+    }
+
+    fn validate_module_impl(&self, module: &Module, offsets: &VMOffsets<HostPtr>) -> Result<()> {
+        self.validate_memory_plans(module)?;
+        self.validate_table_plans(module)?;
+        self.validate_core_instance_size(offsets)?;
+        Ok(())
+    }
+
+    fn increment_component_instance_count(&self) -> Result<()> {
+        let old_count = self.live_component_instances.fetch_add(1, Ordering::AcqRel);
+        if old_count >= u64::from(self.limits.total_component_instances) {
+            self.decrement_component_instance_count();
+            return Err(PoolConcurrencyLimitError::new(
+                usize::try_from(self.limits.total_component_instances).unwrap(),
+                "component instances",
+            )
+            .into());
+        }
+        Ok(())
+    }
+
+    fn decrement_component_instance_count(&self) {
+        self.live_component_instances.fetch_sub(1, Ordering::AcqRel);
+    }
+
+    fn increment_core_instance_count(&self) -> Result<()> {
+        let old_count = self.live_core_instances.fetch_add(1, Ordering::AcqRel);
+        if old_count >= u64::from(self.limits.total_core_instances) {
+            self.decrement_core_instance_count();
+            return Err(PoolConcurrencyLimitError::new(
+                usize::try_from(self.limits.total_core_instances).unwrap(),
+                "core instances",
+            )
+            .into());
+        }
+        Ok(())
+    }
+
+    fn decrement_core_instance_count(&self) {
+        self.live_core_instances.fetch_sub(1, Ordering::AcqRel);
+    }
+
+    unsafe fn allocate_memory(
+        &self,
+        request: &mut InstanceAllocationRequest,
+        memory_plan: &MemoryPlan,
+        memory_index: DefinedMemoryIndex,
+    ) -> Result<(MemoryAllocationIndex, Memory)> {
+        self.with_flush_and_retry(|| self.memories.allocate(request, memory_plan, memory_index))
+    }
+
+    unsafe fn deallocate_memory(
+        &self,
+        _memory_index: DefinedMemoryIndex,
+        allocation_index: MemoryAllocationIndex,
+        memory: Memory,
+    ) {
+        // Reset the image slot. If there is any error clearing the
+        // image, just drop it here, and let the drop handler for the
+        // slot unmap in a way that retains the address space
+        // reservation.
+        let mut image = memory.unwrap_static_image();
+        let mut queue = DecommitQueue::default();
+        image
+            .clear_and_remain_ready(self.memories.keep_resident, |ptr, len| {
+                queue.push_raw(ptr, len);
+            })
+            .expect("failed to reset memory image");
+        queue.push_memory(allocation_index, image);
+        self.merge_or_flush(queue);
+    }
+
+    unsafe fn allocate_table(
+        &self,
+        request: &mut InstanceAllocationRequest,
+        table_plan: &TablePlan,
+        _table_index: DefinedTableIndex,
+    ) -> Result<(super::TableAllocationIndex, Table)> {
+        self.with_flush_and_retry(|| self.tables.allocate(request, table_plan))
+    }
+
+    unsafe fn deallocate_table(
+        &self,
+        _table_index: DefinedTableIndex,
+        allocation_index: TableAllocationIndex,
+        mut table: Table,
+    ) {
+        let mut queue = DecommitQueue::default();
+        self.tables
+            .reset_table_pages_to_zero(allocation_index, &mut table, |ptr, len| {
+                queue.push_raw(ptr, len);
+            });
+        queue.push_table(allocation_index, table);
+        self.merge_or_flush(queue);
+    }
+
+    #[cfg(feature = "async")]
+    fn allocate_fiber_stack(&self) -> Result<wasmtime_fiber::FiberStack> {
+        self.with_flush_and_retry(|| self.stacks.allocate())
+    }
+
+    #[cfg(feature = "async")]
+    unsafe fn deallocate_fiber_stack(&self, mut stack: wasmtime_fiber::FiberStack) {
+        let mut queue = DecommitQueue::default();
+        self.stacks
+            .zero_stack(&mut stack, |ptr, len| queue.push_raw(ptr, len));
+        queue.push_stack(stack);
+        self.merge_or_flush(queue);
+    }
+
+    fn purge_module(&self, module: CompiledModuleId) {
+        self.memories.purge_module(module);
+    }
+
+    fn next_available_pkey(&self) -> Option<ProtectionKey> {
+        self.memories.next_available_pkey()
+    }
+
+    fn restrict_to_pkey(&self, pkey: ProtectionKey) {
+        mpk::allow(ProtectionMask::zero().or(pkey));
+    }
+
+    fn allow_all_pkeys(&self) {
+        mpk::allow(ProtectionMask::all());
+    }
+
+    #[cfg(feature = "gc")]
+    fn allocate_gc_heap(
+        &self,
+        gc_runtime: &dyn GcRuntime,
+    ) -> Result<(GcHeapAllocationIndex, Box<dyn GcHeap>)> {
+        self.gc_heaps.allocate(gc_runtime)
+    }
+
+    #[cfg(feature = "gc")]
+    fn deallocate_gc_heap(
+        &self,
+        allocation_index: GcHeapAllocationIndex,
+        gc_heap: Box<dyn GcHeap>,
+    ) {
+        self.gc_heaps.deallocate(allocation_index, gc_heap);
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_pooling_allocator_with_memory_pages_exceeded() {
+        let config = PoolingInstanceAllocatorConfig {
+            limits: InstanceLimits {
+                total_memories: 1,
+                max_memory_size: 0x100010000,
+                ..Default::default()
+            },
+            ..PoolingInstanceAllocatorConfig::default()
+        };
+        assert_eq!(
+            PoolingInstanceAllocator::new(
+                &config,
+                &Tunables {
+                    static_memory_reservation: 0x10000,
+                    ..Tunables::default_host()
+                },
+            )
+            .map_err(|e| e.to_string())
+            .expect_err("expected a failure constructing instance allocator"),
+            "maximum memory size of 0x100010000 bytes exceeds the configured \
+             static memory reservation of 0x10000 bytes"
+        );
+    }
+
+    #[cfg(all(unix, target_pointer_width = "64", feature = "async", not(miri)))]
+    #[test]
+    fn test_stack_zeroed() -> Result<()> {
+        let config = PoolingInstanceAllocatorConfig {
+            max_unused_warm_slots: 0,
+            limits: InstanceLimits {
+                total_stacks: 1,
+                total_memories: 0,
+                total_tables: 0,
+                ..Default::default()
+            },
+            stack_size: 128,
+            async_stack_zeroing: true,
+            ..PoolingInstanceAllocatorConfig::default()
+        };
+        let allocator = PoolingInstanceAllocator::new(&config, &Tunables::default_host())?;
+
+        unsafe {
+            for _ in 0..255 {
+                let stack = allocator.allocate_fiber_stack()?;
+
+                // The stack pointer is at the top, so decrement it first
+                let addr = stack.top().unwrap().sub(1);
+
+                assert_eq!(*addr, 0);
+                *addr = 1;
+
+                allocator.deallocate_fiber_stack(stack);
+            }
+        }
+
+        Ok(())
+    }
+
+    #[cfg(all(unix, target_pointer_width = "64", feature = "async", not(miri)))]
+    #[test]
+    fn test_stack_unzeroed() -> Result<()> {
+        let config = PoolingInstanceAllocatorConfig {
+            max_unused_warm_slots: 0,
+            limits: InstanceLimits {
+                total_stacks: 1,
+                total_memories: 0,
+                total_tables: 0,
+                ..Default::default()
+            },
+            stack_size: 128,
+            async_stack_zeroing: false,
+            ..PoolingInstanceAllocatorConfig::default()
+        };
+        let allocator = PoolingInstanceAllocator::new(&config, &Tunables::default_host())?;
+
+        unsafe {
+            for i in 0..255 {
+                let stack = allocator.allocate_fiber_stack()?;
+
+                // The stack pointer is at the top, so decrement it first
+                let addr = stack.top().unwrap().sub(1);
+
+                assert_eq!(*addr, i);
+                *addr = i + 1;
+
+                allocator.deallocate_fiber_stack(stack);
+            }
+        }
+
+        Ok(())
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/instance/allocator/pooling/decommit_queue.rs b/crates/wasmtime/src/runtime/vm/instance/allocator/pooling/decommit_queue.rs
new file mode 100644
index 000000000000..8844086111c2
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/instance/allocator/pooling/decommit_queue.rs
@@ -0,0 +1,199 @@
+//! A queue for batching decommits together.
+//!
+//! We don't immediately decommit a Wasm table/memory/stack/etc... eagerly, but
+//! instead batch them up to be decommitted together. This module implements
+//! that queuing and batching.
+//!
+//! Even when batching is "disabled" we still use this queue. Batching is
+//! disabled by specifying a batch size of one, in which case, this queue will
+//! immediately get flushed every time we push onto it.
+
+use super::PoolingInstanceAllocator;
+use crate::vm::{MemoryAllocationIndex, MemoryImageSlot, Table, TableAllocationIndex};
+use smallvec::SmallVec;
+
+#[cfg(feature = "async")]
+use wasmtime_fiber::FiberStack;
+
+#[cfg(unix)]
+#[allow(non_camel_case_types)]
+type iovec = libc::iovec;
+
+#[cfg(not(unix))]
+#[allow(non_camel_case_types)]
+struct iovec {
+    iov_base: *mut libc::c_void,
+    iov_len: libc::size_t,
+}
+
+#[repr(transparent)]
+struct IoVec(iovec);
+
+unsafe impl Send for IoVec {}
+unsafe impl Sync for IoVec {}
+
+impl std::fmt::Debug for IoVec {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("IoVec")
+            .field("base", &self.0.iov_base)
+            .field("len", &self.0.iov_len)
+            .finish()
+    }
+}
+
+#[cfg(feature = "async")]
+struct SendSyncStack(FiberStack);
+#[cfg(feature = "async")]
+unsafe impl Send for SendSyncStack {}
+#[cfg(feature = "async")]
+unsafe impl Sync for SendSyncStack {}
+
+#[derive(Default)]
+pub struct DecommitQueue {
+    raw: SmallVec<[IoVec; 2]>,
+    memories: SmallVec<[(MemoryAllocationIndex, MemoryImageSlot); 1]>,
+    tables: SmallVec<[(TableAllocationIndex, Table); 1]>,
+    #[cfg(feature = "async")]
+    stacks: SmallVec<[SendSyncStack; 1]>,
+    //
+    // TODO: GC heaps are not well-integrated with the pooling allocator
+    // yet. Once we better integrate them, we should start (optionally) zeroing
+    // them, and batching that up here.
+    //
+    // #[cfg(feature = "gc")]
+    // pub gc_heaps: SmallVec<[(GcHeapAllocationIndex, Box<dyn GcHeap>); 1]>,
+}
+
+impl std::fmt::Debug for DecommitQueue {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("DecommitQueue")
+            .field("raw", &self.raw)
+            .finish_non_exhaustive()
+    }
+}
+
+impl DecommitQueue {
+    /// Append another queue to this queue.
+    pub fn append(
+        &mut self,
+        Self {
+            raw,
+            memories,
+            tables,
+            #[cfg(feature = "async")]
+            stacks,
+        }: &mut Self,
+    ) {
+        self.raw.append(raw);
+        self.memories.append(memories);
+        self.tables.append(tables);
+        #[cfg(feature = "async")]
+        self.stacks.append(stacks);
+    }
+
+    /// How many raw memory regions are enqueued for decommit?
+    pub fn raw_len(&self) -> usize {
+        self.raw.len()
+    }
+
+    /// Enqueue a region of memory for decommit.
+    ///
+    /// It is the caller's responsibility to push the associated data via
+    /// `self.push_{memory,table,stack}` as appropriate.
+    ///
+    /// # Safety
+    ///
+    /// The enqueued memory regions must be safe to decommit when `flush` is
+    /// called (no other references, not in use, won't be otherwise unmapped,
+    /// etc...).
+    pub unsafe fn push_raw(&mut self, ptr: *mut u8, len: usize) {
+        self.raw.push(IoVec(iovec {
+            iov_base: ptr.cast(),
+            iov_len: len,
+        }));
+    }
+
+    /// Push a memory into the queue.
+    ///
+    /// # Safety
+    ///
+    /// This memory should not be in use, and its decommit regions must have
+    /// already been enqueued via `self.enqueue_raw`.
+    pub unsafe fn push_memory(
+        &mut self,
+        allocation_index: MemoryAllocationIndex,
+        image: MemoryImageSlot,
+    ) {
+        self.memories.push((allocation_index, image));
+    }
+
+    /// Push a table into the queue.
+    ///
+    /// # Safety
+    ///
+    /// This table should not be in use, and its decommit regions must have
+    /// already been enqueued via `self.enqueue_raw`.
+    pub unsafe fn push_table(&mut self, allocation_index: TableAllocationIndex, table: Table) {
+        self.tables.push((allocation_index, table));
+    }
+
+    /// Push a stack into the queue.
+    ///
+    /// # Safety
+    ///
+    /// This stack should not be in use, and its decommit regions must have
+    /// already been enqueued via `self.enqueue_raw`.
+    #[cfg(feature = "async")]
+    pub unsafe fn push_stack(&mut self, stack: FiberStack) {
+        self.stacks.push(SendSyncStack(stack));
+    }
+
+    fn decommit_all_raw(&mut self) {
+        for iovec in self.raw.drain(..) {
+            unsafe {
+                crate::vm::sys::vm::decommit_pages(iovec.0.iov_base.cast(), iovec.0.iov_len)
+                    .unwrap_or_else(|e| {
+                        panic!(
+                            "failed to decommit ptr={:#p}, len={:#x}: {e}",
+                            iovec.0.iov_base, iovec.0.iov_len
+                        )
+                    });
+            }
+        }
+    }
+
+    /// Flush this queue, decommitting all enqueued regions in batch.
+    ///
+    /// Returns `true` if we did any decommits and returned their entities to
+    /// the associated free lists; `false` if the queue was empty.
+    pub fn flush(mut self, pool: &PoolingInstanceAllocator) -> bool {
+        // First, do the raw decommit syscall(s).
+        self.decommit_all_raw();
+
+        // Second, restore the various entities to their associated pools' free
+        // lists. This is safe, and they are ready for reuse, now that their
+        // memory regions have been decommitted.
+        let mut deallocated_any = false;
+        for (allocation_index, image) in self.memories {
+            deallocated_any = true;
+            unsafe {
+                pool.memories.deallocate(allocation_index, image);
+            }
+        }
+        for (allocation_index, table) in self.tables {
+            deallocated_any = true;
+            unsafe {
+                pool.tables.deallocate(allocation_index, table);
+            }
+        }
+        #[cfg(feature = "async")]
+        for stack in self.stacks {
+            deallocated_any = true;
+            unsafe {
+                pool.stacks.deallocate(stack.0);
+            }
+        }
+
+        deallocated_any
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/instance/allocator/pooling/gc_heap_pool.rs b/crates/wasmtime/src/runtime/vm/instance/allocator/pooling/gc_heap_pool.rs
new file mode 100644
index 000000000000..8d471384bbc8
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/instance/allocator/pooling/gc_heap_pool.rs
@@ -0,0 +1,95 @@
+use super::index_allocator::{SimpleIndexAllocator, SlotId};
+use super::GcHeapAllocationIndex;
+use crate::prelude::*;
+use crate::runtime::vm::{GcHeap, GcRuntime, PoolingInstanceAllocatorConfig, Result};
+use std::sync::Mutex;
+
+/// A pool of reusable GC heaps.
+pub struct GcHeapPool {
+    max_gc_heaps: usize,
+    index_allocator: SimpleIndexAllocator,
+    heaps: Mutex<Vec<Option<Box<dyn GcHeap>>>>,
+}
+
+impl std::fmt::Debug for GcHeapPool {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("GcHeapPool")
+            .field("max_gc_heaps", &self.max_gc_heaps)
+            .field("index_allocator", &self.index_allocator)
+            .field("heaps", &"..")
+            .finish()
+    }
+}
+
+impl GcHeapPool {
+    /// Create a new `GcHeapPool` with the given configuration.
+    pub fn new(config: &PoolingInstanceAllocatorConfig) -> Result<Self> {
+        let index_allocator = SimpleIndexAllocator::new(config.limits.total_gc_heaps);
+        let max_gc_heaps = usize::try_from(config.limits.total_gc_heaps).unwrap();
+
+        // Each individual GC heap in the pool is lazily allocated. See the
+        // `allocate` method.
+        let heaps = Mutex::new((0..max_gc_heaps).map(|_| None).collect());
+
+        Ok(Self {
+            max_gc_heaps,
+            index_allocator,
+            heaps,
+        })
+    }
+
+    /// Are there zero slots in use right now?
+    #[allow(unused)] // some cfgs don't use this
+    pub fn is_empty(&self) -> bool {
+        self.index_allocator.is_empty()
+    }
+
+    /// Allocate a single table for the given instance allocation request.
+    pub fn allocate(
+        &self,
+        gc_runtime: &dyn GcRuntime,
+    ) -> Result<(GcHeapAllocationIndex, Box<dyn GcHeap>)> {
+        let allocation_index = self
+            .index_allocator
+            .alloc()
+            .map(|slot| GcHeapAllocationIndex(slot.0))
+            .ok_or_else(|| {
+                anyhow!(
+                    "maximum concurrent GC heap limit of {} reached",
+                    self.max_gc_heaps
+                )
+            })?;
+        debug_assert_ne!(allocation_index, GcHeapAllocationIndex::default());
+
+        let heap = match {
+            let mut heaps = self.heaps.lock().unwrap();
+            heaps[allocation_index.index()].take()
+        } {
+            // If we already have a heap at this slot, reuse it.
+            Some(heap) => heap,
+            // Otherwise, we haven't forced this slot's lazily allocated heap
+            // yet. So do that now.
+            None => gc_runtime.new_gc_heap()?,
+        };
+
+        Ok((allocation_index, heap))
+    }
+
+    /// Deallocate a previously-allocated GC heap.
+    pub fn deallocate(&self, allocation_index: GcHeapAllocationIndex, mut heap: Box<dyn GcHeap>) {
+        debug_assert_ne!(allocation_index, GcHeapAllocationIndex::default());
+        heap.reset();
+
+        // NB: Replace the heap before freeing the index. If we did it in the
+        // opposite order, a concurrent allocation request could reallocate the
+        // index before we have replaced the heap.
+
+        {
+            let mut heaps = self.heaps.lock().unwrap();
+            let old_entry = std::mem::replace(&mut heaps[allocation_index.index()], Some(heap));
+            debug_assert!(old_entry.is_none());
+        }
+
+        self.index_allocator.free(SlotId(allocation_index.0));
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/instance/allocator/pooling/generic_stack_pool.rs b/crates/wasmtime/src/runtime/vm/instance/allocator/pooling/generic_stack_pool.rs
new file mode 100644
index 000000000000..0c2a4f1ecf5e
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/instance/allocator/pooling/generic_stack_pool.rs
@@ -0,0 +1,78 @@
+#![cfg_attr(not(asan), allow(dead_code))]
+
+use crate::prelude::*;
+use crate::{runtime::vm::PoolingInstanceAllocatorConfig, PoolConcurrencyLimitError};
+use std::sync::atomic::{AtomicU64, Ordering};
+
+/// A generic implementation of a stack pool.
+///
+/// This implementation technically doesn't actually pool anything at this time.
+/// Originally this was the implementation for non-Unix (e.g. Windows and
+/// MIRI), but nowadays this is also used for fuzzing. For more documentation
+/// for why this is used on fuzzing see the `asan` module in the
+/// `wasmtime-fiber` crate.
+///
+/// Currently the only purpose of `StackPool` is to limit the total number of
+/// concurrent stacks while otherwise leveraging `wasmtime_fiber::FiberStack`
+/// natively.
+#[derive(Debug)]
+pub struct StackPool {
+    stack_size: usize,
+    live_stacks: AtomicU64,
+    stack_limit: u64,
+}
+
+impl StackPool {
+    pub fn new(config: &PoolingInstanceAllocatorConfig) -> Result<Self> {
+        Ok(StackPool {
+            stack_size: config.stack_size,
+            live_stacks: AtomicU64::new(0),
+            stack_limit: config.limits.total_stacks.into(),
+        })
+    }
+
+    #[allow(unused)] // some cfgs don't use this
+    pub fn is_empty(&self) -> bool {
+        self.live_stacks.load(Ordering::Acquire) == 0
+    }
+
+    pub fn allocate(&self) -> Result<wasmtime_fiber::FiberStack> {
+        if self.stack_size == 0 {
+            bail!("fiber stack allocation not supported")
+        }
+
+        let old_count = self.live_stacks.fetch_add(1, Ordering::AcqRel);
+        if old_count >= self.stack_limit {
+            self.live_stacks.fetch_sub(1, Ordering::AcqRel);
+            return Err(PoolConcurrencyLimitError::new(
+                usize::try_from(self.stack_limit).unwrap(),
+                "fibers",
+            )
+            .into());
+        }
+
+        match wasmtime_fiber::FiberStack::new(self.stack_size) {
+            Ok(stack) => Ok(stack),
+            Err(e) => {
+                self.live_stacks.fetch_sub(1, Ordering::AcqRel);
+                Err(anyhow::Error::from(e))
+            }
+        }
+    }
+
+    pub unsafe fn zero_stack(
+        &self,
+        _stack: &mut wasmtime_fiber::FiberStack,
+        _decommit: impl FnMut(*mut u8, usize),
+    ) {
+        // No need to actually zero the stack, since the stack won't ever be
+        // reused on non-unix systems.
+    }
+
+    /// Safety: see the unix implementation.
+    pub unsafe fn deallocate(&self, stack: wasmtime_fiber::FiberStack) {
+        self.live_stacks.fetch_sub(1, Ordering::AcqRel);
+        // A no-op as we don't actually own the fiber stack on Windows.
+        let _ = stack;
+    }
+}
diff --git a/crates/runtime/src/instance/allocator/pooling/index_allocator.rs b/crates/wasmtime/src/runtime/vm/instance/allocator/pooling/index_allocator.rs
similarity index 95%
rename from crates/runtime/src/instance/allocator/pooling/index_allocator.rs
rename to crates/wasmtime/src/runtime/vm/instance/allocator/pooling/index_allocator.rs
index 7d35f8e3f757..0127bff01fe9 100644
--- a/crates/runtime/src/instance/allocator/pooling/index_allocator.rs
+++ b/crates/wasmtime/src/runtime/vm/instance/allocator/pooling/index_allocator.rs
@@ -1,6 +1,7 @@
 //! Index/slot allocator policies for the pooling allocator.
 
-use crate::CompiledModuleId;
+use crate::prelude::*;
+use crate::runtime::vm::CompiledModuleId;
 use std::collections::hash_map::{Entry, HashMap};
 use std::mem;
 use std::sync::Mutex;
@@ -30,6 +31,7 @@ impl SimpleIndexAllocator {
         SimpleIndexAllocator(ModuleAffinityIndexAllocator::new(capacity, 0))
     }
 
+    #[allow(unused)] // some cfgs don't use this
     pub fn is_empty(&self) -> bool {
         self.0.is_empty()
     }
@@ -174,6 +176,7 @@ impl ModuleAffinityIndexAllocator {
     }
 
     /// Are zero slots in use right now?
+    #[allow(unused)] // some cfgs don't use this
     pub fn is_empty(&self) -> bool {
         let inner = self.0.lock().unwrap();
         !inner
@@ -482,7 +485,6 @@ impl List {
 #[cfg(test)]
 mod test {
     use super::*;
-    use crate::CompiledModuleIdAllocator;
     use wasmtime_environ::EntityRef;
 
     #[test]
@@ -500,9 +502,8 @@ mod test {
 
     #[test]
     fn test_affinity_allocation_strategy() {
-        let id_alloc = CompiledModuleIdAllocator::new();
-        let id1 = MemoryInModule(id_alloc.alloc(), DefinedMemoryIndex::new(0));
-        let id2 = MemoryInModule(id_alloc.alloc(), DefinedMemoryIndex::new(0));
+        let id1 = MemoryInModule(CompiledModuleId::new(), DefinedMemoryIndex::new(0));
+        let id2 = MemoryInModule(CompiledModuleId::new(), DefinedMemoryIndex::new(0));
         let state = ModuleAffinityIndexAllocator::new(100, 100);
 
         let index1 = state.alloc(Some(id1)).unwrap();
@@ -557,8 +558,7 @@ mod test {
 
     #[test]
     fn clear_affine() {
-        let id_alloc = CompiledModuleIdAllocator::new();
-        let id = id_alloc.alloc();
+        let id = CompiledModuleId::new();
         let memory_index = DefinedMemoryIndex::new(0);
 
         for max_unused_warm_slots in [0, 1, 2] {
@@ -586,11 +586,11 @@ mod test {
         use rand::Rng;
         let mut rng = rand::thread_rng();
 
-        let id_alloc = CompiledModuleIdAllocator::new();
-        let ids =
-            std::iter::repeat_with(|| MemoryInModule(id_alloc.alloc(), DefinedMemoryIndex::new(0)))
-                .take(10)
-                .collect::<Vec<_>>();
+        let ids = std::iter::repeat_with(|| {
+            MemoryInModule(CompiledModuleId::new(), DefinedMemoryIndex::new(0))
+        })
+        .take(10)
+        .collect::<Vec<_>>();
         let state = ModuleAffinityIndexAllocator::new(1000, 1000);
         let mut allocated: Vec<SlotId> = vec![];
         let mut last_id = vec![None; 1000];
@@ -624,17 +624,15 @@ mod test {
         // affinity is occurring.
         assert!(
             hits > (amt / 5),
-            "expected at least 20000 (20%) ID-reuses but got {}",
-            hits
+            "expected at least 20000 (20%) ID-reuses but got {hits}"
         );
     }
 
     #[test]
     fn test_affinity_threshold() {
-        let id_alloc = CompiledModuleIdAllocator::new();
-        let id1 = MemoryInModule(id_alloc.alloc(), DefinedMemoryIndex::new(0));
-        let id2 = MemoryInModule(id_alloc.alloc(), DefinedMemoryIndex::new(0));
-        let id3 = MemoryInModule(id_alloc.alloc(), DefinedMemoryIndex::new(0));
+        let id1 = MemoryInModule(CompiledModuleId::new(), DefinedMemoryIndex::new(0));
+        let id2 = MemoryInModule(CompiledModuleId::new(), DefinedMemoryIndex::new(0));
+        let id3 = MemoryInModule(CompiledModuleId::new(), DefinedMemoryIndex::new(0));
         let state = ModuleAffinityIndexAllocator::new(10, 2);
 
         // Set some slot affinities
@@ -670,7 +668,7 @@ mod test {
         // LRU is 1, so that should be picked
         assert_eq!(
             state.alloc(Some(MemoryInModule(
-                id_alloc.alloc(),
+                CompiledModuleId::new(),
                 DefinedMemoryIndex::new(0)
             ))),
             Some(SlotId(1))
@@ -679,7 +677,7 @@ mod test {
         // Pick another LRU entry, this time 2
         assert_eq!(
             state.alloc(Some(MemoryInModule(
-                id_alloc.alloc(),
+                CompiledModuleId::new(),
                 DefinedMemoryIndex::new(0)
             ))),
             Some(SlotId(2))
@@ -688,7 +686,7 @@ mod test {
         // This should preserve slot `0` and pick up something new
         assert_eq!(
             state.alloc(Some(MemoryInModule(
-                id_alloc.alloc(),
+                CompiledModuleId::new(),
                 DefinedMemoryIndex::new(0)
             ))),
             Some(SlotId(3))
diff --git a/crates/runtime/src/instance/allocator/pooling/memory_pool.rs b/crates/wasmtime/src/runtime/vm/instance/allocator/pooling/memory_pool.rs
similarity index 75%
rename from crates/runtime/src/instance/allocator/pooling/memory_pool.rs
rename to crates/wasmtime/src/runtime/vm/instance/allocator/pooling/memory_pool.rs
index 47455a0e3558..2e5dd793b94b 100644
--- a/crates/runtime/src/instance/allocator/pooling/memory_pool.rs
+++ b/crates/wasmtime/src/runtime/vm/instance/allocator/pooling/memory_pool.rs
@@ -1,11 +1,9 @@
 //! Implements a memory pool using a single allocated memory slab.
 //!
-//! The pooling instance allocator maps memory in advance and allocates
-//! instances, memories, tables, and stacks from a pool of available resources.
-//! Using the pooling instance allocator can speed up module instantiation when
-//! modules can be constrained based on configurable limits
-//! ([`InstanceLimits`]). Each new instance is stored in a "slot"; as instances
-//! are allocated and freed, these slots are either filled or emptied:
+//! The pooling instance allocator maps one large slab of memory in advance and
+//! allocates WebAssembly memories from this slab--a [`MemoryPool`]. Each
+//! WebAssembly memory is allocated in its own slot (see uses of `index` and
+//! [`SlotId`] in this module):
 //!
 //! ```text
 //! ┌──────┬──────┬──────┬──────┬──────┐
@@ -13,17 +11,12 @@
 //! └──────┴──────┴──────┴──────┴──────┘
 //! ```
 //!
-//! Note that these slots are a useful abstraction but not exactly how this is
-//! mapped to memory in fact. Each new instance _does_ get associated with a
-//! slot number (see uses of `index` and [`SlotId`] in this module) but the
-//! parts of the instances are stored in separate pools: memories in the
-//! [`MemoryPool`], tables in the [`TablePool`], etc. What ties these various
-//! parts together is the slot number generated by an [`IndexAllocator`] .
-//!
-//! The [`MemoryPool`] protects Wasmtime from out-of-bounds memory accesses by
-//! inserting inaccessible guard regions between memory slots. The
-//! [`MemoryPool`] documentation has a more in-depth chart but one can think of
-//! memories being laid out like the following:
+//! Diving deeper, we note that a [`MemoryPool`] protects Wasmtime from
+//! out-of-bounds memory accesses by inserting inaccessible guard regions
+//! between memory slots. These guard regions are configured to raise a signal
+//! if they are accessed--a WebAssembly out-of-bounds (OOB) memory access. The
+//! [`MemoryPool`] documentation has a more detailed chart but one can think of
+//! memory slots being laid out like the following:
 //!
 //! ```text
 //! ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
@@ -31,22 +24,21 @@
 //! └─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘
 //! ```
 //!
-//! To complicate matters, each instance can have multiple memories, multiple
-//! tables, etc. You might think these would be stored consecutively in their
-//! respective pools (for instance `n`, table 0 is at table pool slot `n + 0`
-//! and table 1 is at `n + 1`), but for memories this is not the case. With
-//! protection keys enabled, memories do not need interleaved guard regions
-//! because the protection key will signal a fault if the wrong memory is
-//! accessed. Instead, the pooling allocator "stripes" the memories with
-//! different protection keys.
+//! But we can be more efficient about guard regions: with memory protection
+//! keys (MPK) enabled, the interleaved guard regions can be smaller. If we
+//! surround a memory with memories from other instances and each instance is
+//! protected by different protection keys, the guard region can be smaller AND
+//! the pool will still raise a signal on an OOB access. This complicates how we
+//! lay out memory slots: we must store memories from the same instance in the
+//! same "stripe". Each stripe is protected by a different protection key.
 //!
 //! This concept, dubbed [ColorGuard] in the original paper, relies on careful
-//! calculation of the memory sizes to prevent any "overlapping access": there
-//! are limited protection keys available (15) so the next memory using the same
-//! key must be at least as far away as the guard region we would insert
-//! otherwise. This ends up looking like the following, where a store for
-//! instance 0 (`I0`) "stripes" two memories (`M0` and `M1`) with the same
-//! protection key 1 and far enough apart to signal an OOB access:
+//! calculation of the memory sizes to prevent any "overlapping access" (see
+//! [`calculate`]): there are limited protection keys available (15) so the next
+//! memory using the same key must be at least as far away as the guard region
+//! we would insert otherwise. This ends up looking like the following, where a
+//! store for instance 0 (`I0`) "stripes" two memories (`M0` and `M1`) with the
+//! same protection key 1 and far enough apart to signal an OOB access:
 //!
 //! ```text
 //! ┌─────┬─────┬─────┬─────┬────────────────┬─────┬─────┬─────┐
@@ -62,18 +54,16 @@ use super::{
     index_allocator::{MemoryInModule, ModuleAffinityIndexAllocator, SlotId},
     MemoryAllocationIndex,
 };
-use crate::mpk::{self, ProtectionKey, ProtectionMask};
-use crate::{
+use crate::runtime::vm::mpk::{self, ProtectionKey, ProtectionMask};
+use crate::runtime::vm::{
     CompiledModuleId, InstanceAllocationRequest, InstanceLimits, Memory, MemoryImageSlot, Mmap,
     MpkEnabled, PoolingInstanceAllocatorConfig,
 };
-use anyhow::{anyhow, bail, Context, Result};
-use libc::c_void;
+use crate::{prelude::*, vm::round_usize_up_to_host_pages};
+use std::ffi::c_void;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Mutex;
-use wasmtime_environ::{
-    DefinedMemoryIndex, MemoryPlan, MemoryStyle, Module, Tunables, WASM_PAGE_SIZE,
-};
+use wasmtime_environ::{DefinedMemoryIndex, MemoryPlan, MemoryStyle, Module, Tunables};
 
 /// A set of allocator slots.
 ///
@@ -92,21 +82,21 @@ struct Stripe {
 
 /// Represents a pool of WebAssembly linear memories.
 ///
-/// A linear memory is divided into accessible pages and guard pages.
-///
-/// A diagram for this struct's fields is:
+/// A linear memory is divided into accessible pages and guard pages. A memory
+/// pool contains linear memories: each memory occupies a slot in an
+/// allocated slab (i.e., `mapping`):
 ///
 /// ```text
 ///          layout.max_memory_bytes                 layout.slot_bytes
 ///                    |                                   |
-///              <-----+---->                  <-----------+----------->
-/// +-----------+------------+-----------+     +--------+---+-----------+-----------+
-/// | PROT_NONE |            | PROT_NONE | ... |            | PROT_NONE | PROT_NONE |
-/// +-----------+------------+-----------+     +--------+---+-----------+-----------+
-/// |           |<------------------+----------------------------------> <----+---->
-/// \           |                    \                                        |
-///  mapping    |            `layout.num_slots` memories         layout.post_slab_guard_size
-///            /
+///              ◄─────┴────►                  ◄───────────┴──────────►
+/// ┌───────────┬────────────┬───────────┐     ┌───────────┬───────────┬───────────┐
+/// | PROT_NONE |            | PROT_NONE | ... |           | PROT_NONE | PROT_NONE |
+/// └───────────┴────────────┴───────────┘     └───────────┴───────────┴───────────┘
+/// |           |◄──────────────────┬─────────────────────────────────► ◄────┬────►
+/// |           |                   |                                        |
+/// mapping     |            `layout.num_slots` memories         layout.post_slab_guard_size
+///             |
 ///   layout.pre_slab_guard_size
 /// ```
 #[derive(Debug)]
@@ -116,54 +106,60 @@ pub struct MemoryPool {
     /// will contain one stripe per available key; otherwise, a single stripe
     /// with an empty key.
     stripes: Vec<Stripe>,
-    // If using a copy-on-write allocation scheme, the slot management. We
-    // dynamically transfer ownership of a slot to a Memory when in
-    // use.
+
+    /// If using a copy-on-write allocation scheme, the slot management. We
+    /// dynamically transfer ownership of a slot to a Memory when in use.
     image_slots: Vec<Mutex<Option<MemoryImageSlot>>>,
+
     /// A description of the various memory sizes used in allocating the
     /// `mapping` slab.
     layout: SlabLayout,
-    // The maximum number of memories that a single core module instance may
-    // use.
-    //
-    // NB: this is needed for validation but does not affect the pool's size.
+
+    /// The maximum number of memories that a single core module instance may
+    /// use.
+    ///
+    /// NB: this is needed for validation but does not affect the pool's size.
     memories_per_instance: usize,
-    // How much linear memory, in bytes, to keep resident after resetting for
-    // use with the next instance. This much memory will be `memset` to zero
-    // when a linear memory is deallocated.
-    //
-    // Memory exceeding this amount in the wasm linear memory will be released
-    // with `madvise` back to the kernel.
-    //
-    // Only applicable on Linux.
-    keep_resident: usize,
-    // Keep track of protection keys handed out to initialized stores; this
-    // allows us to round-robin the assignment of stores to stripes.
+
+    /// How much linear memory, in bytes, to keep resident after resetting for
+    /// use with the next instance. This much memory will be `memset` to zero
+    /// when a linear memory is deallocated.
+    ///
+    /// Memory exceeding this amount in the wasm linear memory will be released
+    /// with `madvise` back to the kernel.
+    ///
+    /// Only applicable on Linux.
+    pub(super) keep_resident: usize,
+
+    /// Keep track of protection keys handed out to initialized stores; this
+    /// allows us to round-robin the assignment of stores to stripes.
     next_available_pkey: AtomicUsize,
 }
 
 impl MemoryPool {
     /// Create a new `MemoryPool`.
     pub fn new(config: &PoolingInstanceAllocatorConfig, tunables: &Tunables) -> Result<Self> {
-        // The maximum module memory page count cannot exceed 65536 pages
-        if config.limits.memory_pages > 0x10000 {
+        if u64::try_from(config.limits.max_memory_size).unwrap()
+            > tunables.static_memory_reservation
+        {
             bail!(
-                "module memory page limit of {} exceeds the maximum of 65536",
-                config.limits.memory_pages
+                "maximum memory size of {:#x} bytes exceeds the configured \
+                 static memory reservation of {:#x} bytes",
+                config.limits.max_memory_size,
+                tunables.static_memory_reservation
             );
         }
-
         let pkeys = match config.memory_protection_keys {
             MpkEnabled::Auto => {
                 if mpk::is_supported() {
-                    mpk::keys()
+                    mpk::keys(config.max_memory_protection_keys)
                 } else {
                     &[]
                 }
             }
             MpkEnabled::Enable => {
                 if mpk::is_supported() {
-                    mpk::keys()
+                    mpk::keys(config.max_memory_protection_keys)
                 } else {
                     bail!("mpk is disabled on this system")
                 }
@@ -189,7 +185,10 @@ impl MemoryPool {
         // region to start--`PROT_NONE`.
         let constraints = SlabConstraints::new(&config.limits, tunables, pkeys.len())?;
         let layout = calculate(&constraints)?;
-        log::debug!("creating memory pool: {constraints:?} -> {layout:?}");
+        log::debug!(
+            "creating memory pool: {constraints:?} -> {layout:?} (total: {})",
+            layout.total_slab_bytes()?
+        );
         let mut mapping = Mmap::accessible_reserved(0, layout.total_slab_bytes()?)
             .context("failed to create memory pool mapping")?;
 
@@ -239,7 +238,7 @@ impl MemoryPool {
             image_slots,
             layout,
             memories_per_instance: usize::try_from(config.limits.max_memories_per_module).unwrap(),
-            keep_resident: config.linear_memory_keep_resident,
+            keep_resident: round_usize_up_to_host_pages(config.linear_memory_keep_resident)?,
             next_available_pkey: AtomicUsize::new(0),
         };
 
@@ -253,7 +252,7 @@ impl MemoryPool {
             self.stripes.len() < 2 || self.stripes[index].pkey.is_some(),
             "if we are using stripes, we cannot have an empty protection key"
         );
-        self.stripes[index].pkey.clone()
+        self.stripes[index].pkey
     }
 
     /// Validate whether this memory pool supports the given module.
@@ -267,29 +266,36 @@ impl MemoryPool {
             );
         }
 
-        let max_memory_pages = self.layout.max_memory_bytes / WASM_PAGE_SIZE as usize;
         for (i, plan) in module
             .memory_plans
             .iter()
             .skip(module.num_imported_memories)
         {
             match plan.style {
-                MemoryStyle::Static { bound } => {
-                    if u64::try_from(self.layout.pages_to_next_stripe_slot()).unwrap() < bound {
+                MemoryStyle::Static { byte_reservation } => {
+                    if u64::try_from(self.layout.bytes_to_next_stripe_slot()).unwrap()
+                        < byte_reservation
+                    {
                         bail!(
                             "memory size allocated per-memory is too small to \
-                             satisfy static bound of {bound:#x} pages"
+                             satisfy static bound of {byte_reservation:#x} bytes"
                         );
                     }
                 }
                 MemoryStyle::Dynamic { .. } => {}
             }
-            if plan.memory.minimum > u64::try_from(max_memory_pages).unwrap() {
+            let min = plan.memory.minimum_byte_size().with_context(|| {
+                format!(
+                    "memory index {} has a minimum byte size that cannot be represented in a u64",
+                    i.as_u32()
+                )
+            })?;
+            if min > u64::try_from(self.layout.max_memory_bytes).unwrap() {
                 bail!(
-                    "memory index {} has a minimum page size of {} which exceeds the limit of {}",
+                    "memory index {} has a minimum byte size of {} which exceeds the limit of {} bytes",
                     i.as_u32(),
-                    plan.memory.minimum,
-                    max_memory_pages,
+                    min,
+                    self.layout.max_memory_bytes,
                 );
             }
         }
@@ -297,6 +303,7 @@ impl MemoryPool {
     }
 
     /// Are zero slots in use right now?
+    #[allow(unused)] // some cfgs don't use this
     pub fn is_empty(&self) -> bool {
         self.stripes.iter().all(|s| s.allocator.is_empty())
     }
@@ -325,10 +332,9 @@ impl MemoryPool {
             )
             .map(|slot| StripedAllocationIndex(u32::try_from(slot.index()).unwrap()))
             .ok_or_else(|| {
-                anyhow!(
-                    "maximum concurrent memory limit of {} reached for stripe {}",
+                super::PoolConcurrencyLimitError::new(
                     self.stripes[stripe_index].allocator.len(),
-                    stripe_index
+                    format!("memory stripe {stripe_index}"),
                 )
             })?;
         let allocation_index =
@@ -340,9 +346,11 @@ impl MemoryPool {
             // should be returned as an error through `validate_memory_plans`
             // but double-check here to be sure.
             match memory_plan.style {
-                MemoryStyle::Static { bound } => {
-                    let bound = bound * u64::from(WASM_PAGE_SIZE);
-                    assert!(bound <= u64::try_from(self.layout.slot_bytes).unwrap());
+                MemoryStyle::Static { byte_reservation } => {
+                    assert!(
+                        byte_reservation
+                            <= u64::try_from(self.layout.bytes_to_next_stripe_slot()).unwrap()
+                    );
                 }
                 MemoryStyle::Dynamic { .. } => {}
             }
@@ -352,7 +360,10 @@ impl MemoryPool {
 
             let mut slot = self.take_memory_image_slot(allocation_index);
             let image = request.runtime_info.memory_image(memory_index)?;
-            let initial_size = memory_plan.memory.minimum * WASM_PAGE_SIZE as u64;
+            let initial_size = memory_plan
+                .memory
+                .minimum_byte_size()
+                .expect("min size checked in validation");
 
             // If instantiation fails, we can propagate the error
             // upward and drop the slot. This will cause the Drop
@@ -374,7 +385,7 @@ impl MemoryPool {
                 base_ptr,
                 base_capacity,
                 slot,
-                self.layout.slot_bytes,
+                self.layout.bytes_to_next_stripe_slot(),
                 unsafe { &mut *request.store.get().unwrap() },
             )
         })() {
@@ -395,16 +406,15 @@ impl MemoryPool {
     /// The memory must have been previously allocated from this pool and
     /// assigned the given index, must currently be in an allocated state, and
     /// must never be used again.
-    pub unsafe fn deallocate(&self, allocation_index: MemoryAllocationIndex, memory: Memory) {
-        let mut image = memory.unwrap_static_image();
-
-        // Reset the image slot. If there is any error clearing the
-        // image, just drop it here, and let the drop handler for the
-        // slot unmap in a way that retains the address space
-        // reservation.
-        if image.clear_and_remain_ready(self.keep_resident).is_ok() {
-            self.return_memory_image_slot(allocation_index, image);
-        }
+    ///
+    /// The caller must have already called `clear_and_remain_ready` on the
+    /// memory's image and flushed any enqueued decommits for this memory.
+    pub unsafe fn deallocate(
+        &self,
+        allocation_index: MemoryAllocationIndex,
+        image: MemoryImageSlot,
+    ) {
+        self.return_memory_image_slot(allocation_index, image);
 
         let (stripe_index, striped_allocation_index) =
             StripedAllocationIndex::from_unstriped_slot_index(allocation_index, self.stripes.len());
@@ -550,35 +560,38 @@ impl SlabConstraints {
         tunables: &Tunables,
         num_pkeys_available: usize,
     ) -> Result<Self> {
-        // The maximum size a memory can grow to in this pool.
-        let max_memory_bytes = limits.memory_pages * u64::from(WASM_PAGE_SIZE);
-
-        // `static_memory_bound` is the configured number of Wasm pages for a
+        // `static_memory_reservation` is the configured number of bytes for a
         // static memory slot (see `Config::static_memory_maximum_size`); even
         // if the memory never grows to this size (e.g., it has a lower memory
         // maximum), codegen will assume that this unused memory is mapped
-        // `PROT_NONE`. Typically `static_memory_bound` is 4G which helps elide
-        // most bounds checks. `MemoryPool` must respect this bound, though not
-        // explicitly: if we can achieve the same effect via MPK-protected
-        // stripes, the slot size can be lower than the `static_memory_bound`.
-        let expected_slot_bytes = tunables.static_memory_bound * u64::from(WASM_PAGE_SIZE);
+        // `PROT_NONE`. Typically `static_memory_bound` is 4GiB which helps
+        // elide most bounds checks. `MemoryPool` must respect this bound,
+        // though not explicitly: if we can achieve the same effect via
+        // MPK-protected stripes, the slot size can be lower than the
+        // `static_memory_bound`.
+        let expected_slot_bytes: usize = tunables
+            .static_memory_reservation
+            .try_into()
+            .context("static memory bound is too large")?;
+        let expected_slot_bytes = round_usize_up_to_host_pages(expected_slot_bytes)?;
+
+        let guard_bytes: usize = tunables
+            .static_memory_offset_guard_size
+            .try_into()
+            .context("guard region is too large")?;
+        let guard_bytes = round_usize_up_to_host_pages(guard_bytes)?;
+
+        let num_slots = limits
+            .total_memories
+            .try_into()
+            .context("too many memories")?;
 
         let constraints = SlabConstraints {
-            max_memory_bytes: max_memory_bytes
-                .try_into()
-                .context("max memory is too large")?,
-            num_slots: limits
-                .total_memories
-                .try_into()
-                .context("too many memories")?,
-            expected_slot_bytes: expected_slot_bytes
-                .try_into()
-                .context("static memory bound is too large")?,
+            max_memory_bytes: limits.max_memory_size,
+            num_slots,
+            expected_slot_bytes,
             num_pkeys_available,
-            guard_bytes: tunables
-                .static_memory_offset_guard_size
-                .try_into()
-                .context("guard region is too large")?,
+            guard_bytes,
             guard_before_slots: tunables.guard_before_linear_memory,
         };
         Ok(constraints)
@@ -594,17 +607,16 @@ struct SlabLayout {
     /// guard region after the memory to catch OOB access. On these guard
     /// regions, note that:
     /// - users can configure how aggressively (or not) to elide bounds checks
-    ///   via `Config::static_memory_guard_size`
+    ///   via `Config::static_memory_guard_size` (see also:
+    ///   `memory_and_guard_size`)
     /// - memory protection keys can compress the size of the guard region by
     ///   placing slots from a different key (i.e., a stripe) in the guard
     ///   region; this means the slot itself can be smaller and we can allocate
     ///   more of them.
     slot_bytes: usize,
-    // The maximum size that can become accessible, in bytes, for each linear
-    // memory. Guaranteed to be a whole number of wasm pages.
+    /// The maximum size that can become accessible, in bytes, for each linear
+    /// memory. Guaranteed to be a whole number of Wasm pages.
     max_memory_bytes: usize,
-    /// The total number of bytes to allocate for the memory pool slab.
-    // total_slab_bytes: usize,
     /// If necessary, the number of bytes to reserve as a guard region at the
     /// beginning of the slab.
     pre_slab_guard_bytes: usize,
@@ -631,7 +643,7 @@ impl SlabLayout {
             .ok_or_else(|| anyhow!("total size of memory reservation exceeds addressable memory"))
     }
 
-    /// Returns the number of Wasm pages from the beginning of one slot to the
+    /// Returns the number of Wasm bytes from the beginning of one slot to the
     /// next slot in the same stripe--this is the striped equivalent of
     /// `static_memory_bound`. Recall that between slots of the same stripe we
     /// will see a slot from every other stripe.
@@ -640,13 +652,13 @@ impl SlabLayout {
     /// from the beginning of slot 1 to slot 4, which are of the same stripe:
     ///
     /// ```text
+    ///  ◄────────────────────►
     /// ┌────────┬──────┬──────┬────────┬───┐
     /// │*slot 1*│slot 2│slot 3│*slot 4*│...|
     /// └────────┴──────┴──────┴────────┴───┘
     /// ```
-    fn pages_to_next_stripe_slot(&self) -> usize {
-        let slot_pages = self.slot_bytes / WASM_PAGE_SIZE as usize;
-        slot_pages * self.num_stripes
+    fn bytes_to_next_stripe_slot(&self) -> usize {
+        self.slot_bytes * self.num_stripes
     }
 }
 
@@ -670,21 +682,20 @@ fn calculate(constraints: &SlabConstraints) -> Result<SlabLayout> {
     // To calculate the slot size, we start with the default configured size and
     // attempt to chip away at this via MPK protection. Note here how we begin
     // to define a slot as "all of the memory and guard region."
-    let slot_bytes = expected_slot_bytes
+    let faulting_region_bytes = expected_slot_bytes
         .max(max_memory_bytes)
-        .checked_add(guard_bytes)
-        .unwrap_or(usize::MAX);
+        .saturating_add(guard_bytes);
 
     let (num_stripes, slot_bytes) = if guard_bytes == 0 || max_memory_bytes == 0 || num_slots == 0 {
         // In the uncommon case where the memory/guard regions are empty or we don't need any slots , we
         // will not need any stripes: we just lay out the slots back-to-back
         // using a single stripe.
-        (1, slot_bytes)
+        (1, faulting_region_bytes)
     } else if num_pkeys_available < 2 {
         // If we do not have enough protection keys to stripe the memory, we do
         // the same. We can't elide any of the guard bytes because we aren't
         // overlapping guard regions with other stripes...
-        (1, slot_bytes)
+        (1, faulting_region_bytes)
     } else {
         // ...but if we can create at least two stripes, we can use another
         // stripe (i.e., a different pkey) as this slot's guard region--this
@@ -701,39 +712,38 @@ fn calculate(constraints: &SlabConstraints) -> Result<SlabLayout> {
         // pool is configured with only three slots (`num_memory_slots =
         // 3`), we will run into failures if we attempt to set up more than
         // three stripes.
-        let needed_num_stripes =
-            slot_bytes / max_memory_bytes + usize::from(slot_bytes % max_memory_bytes != 0) + 1;
+        let needed_num_stripes = faulting_region_bytes / max_memory_bytes
+            + usize::from(faulting_region_bytes % max_memory_bytes != 0);
+        assert!(needed_num_stripes > 0);
         let num_stripes = num_pkeys_available.min(needed_num_stripes).min(num_slots);
 
-        // Next, we try to reduce the slot size by "overlapping" the
-        // stripes: we can make slot `n` smaller since we know that slot
-        // `n+1` and following are in different stripes and will look just
-        // like `PROT_NONE` memory.
-        let next_slots_overlapping_bytes = max_memory_bytes
-            .checked_mul(num_stripes - 1)
-            .unwrap_or(usize::MAX);
-        let needed_slot_bytes = slot_bytes
-            .checked_sub(next_slots_overlapping_bytes)
-            .unwrap_or(0)
+        // Next, we try to reduce the slot size by "overlapping" the stripes: we
+        // can make slot `n` smaller since we know that slot `n+1` and following
+        // are in different stripes and will look just like `PROT_NONE` memory.
+        // Recall that codegen expects a guarantee that at least
+        // `faulting_region_bytes` will catch OOB accesses via segfaults.
+        let needed_slot_bytes = faulting_region_bytes
+            .checked_div(num_stripes)
+            .unwrap_or(faulting_region_bytes)
             .max(max_memory_bytes);
+        assert!(needed_slot_bytes >= max_memory_bytes);
+
         (num_stripes, needed_slot_bytes)
     };
 
     // The page-aligned slot size; equivalent to `memory_and_guard_size`.
-    let page_alignment = crate::page_size() - 1;
+    let page_alignment = crate::runtime::vm::host_page_size() - 1;
     let slot_bytes = slot_bytes
         .checked_add(page_alignment)
         .and_then(|slot_bytes| Some(slot_bytes & !page_alignment))
         .ok_or_else(|| anyhow!("slot size is too large"))?;
 
     // We may need another guard region (like `pre_slab_guard_bytes`) at the end
-    // of our slab. We could be conservative and just create it as large as
-    // `guard_bytes`, but because we know that the last slot already has
-    // `guard_bytes` factored in to its guard region, we can reduce the final
-    // guard region by that much.
-    let post_slab_guard_bytes = guard_bytes
-        .checked_sub(slot_bytes - max_memory_bytes)
-        .unwrap_or(0);
+    // of our slab to maintain our `faulting_region_bytes` guarantee. We could
+    // be conservative and just create it as large as `faulting_region_bytes`,
+    // but because we know that the last slot's `slot_bytes` make up the first
+    // part of that region, we reduce the final guard region by that much.
+    let post_slab_guard_bytes = faulting_region_bytes.saturating_sub(slot_bytes);
 
     // Check that we haven't exceeded the slab we can calculate given the limits
     // of `usize`.
@@ -754,9 +764,9 @@ fn calculate(constraints: &SlabConstraints) -> Result<SlabLayout> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{InstanceLimits, PoolingInstanceAllocator};
     use proptest::prelude::*;
-    use wasmtime_environ::WASM_PAGE_SIZE;
+
+    const WASM_PAGE_SIZE: u32 = wasmtime_environ::Memory::DEFAULT_PAGE_SIZE;
 
     #[cfg(target_pointer_width = "64")]
     #[test]
@@ -768,15 +778,15 @@ mod tests {
                     max_tables_per_module: 0,
                     max_memories_per_module: 3,
                     table_elements: 0,
-                    memory_pages: 1,
+                    max_memory_size: WASM_PAGE_SIZE as usize,
                     ..Default::default()
                 },
                 ..Default::default()
             },
             &Tunables {
-                static_memory_bound: 1,
+                static_memory_reservation: WASM_PAGE_SIZE as u64,
                 static_memory_offset_guard_size: 0,
-                ..Tunables::default()
+                ..Tunables::default_host()
             },
         )?;
 
@@ -795,28 +805,6 @@ mod tests {
         Ok(())
     }
 
-    #[test]
-    fn test_pooling_allocator_with_reservation_size_exceeded() {
-        let config = PoolingInstanceAllocatorConfig {
-            limits: InstanceLimits {
-                total_memories: 1,
-                memory_pages: 2,
-                ..Default::default()
-            },
-            ..PoolingInstanceAllocatorConfig::default()
-        };
-        let pool = PoolingInstanceAllocator::new(
-            &config,
-            &Tunables {
-                static_memory_bound: 1,
-                static_memory_offset_guard_size: 0,
-                ..Tunables::default()
-            },
-        )
-        .unwrap();
-        assert_eq!(pool.memories.layout.max_memory_bytes, 2 * 65536);
-    }
-
     #[test]
     #[cfg_attr(miri, ignore)]
     fn test_pooling_allocator_striping() {
@@ -830,7 +818,7 @@ mod tests {
             memory_protection_keys: MpkEnabled::Enable,
             ..PoolingInstanceAllocatorConfig::default()
         };
-        let pool = MemoryPool::new(&config, &Tunables::default()).unwrap();
+        let pool = MemoryPool::new(&config, &Tunables::default_host()).unwrap();
         assert!(pool.stripes.len() >= 2);
 
         let max_memory_slots = config.limits.total_memories;
@@ -841,7 +829,10 @@ mod tests {
             .iter()
             .map(|s| s.allocator.num_empty_slots())
             .sum();
-        assert_eq!(max_memory_slots, available_memory_slots.try_into().unwrap());
+        assert_eq!(
+            max_memory_slots,
+            u32::try_from(available_memory_slots).unwrap()
+        );
     }
 
     #[test]
@@ -978,13 +969,14 @@ mod tests {
 
         // Check that the memory-striping will not allow OOB access.
         // - we may have reduced the slot size from `expected_slot_bytes` to
-        //   `slot_bytes` assuming MPK striping; we check that the expectation
-        //   still holds
+        //   `slot_bytes` assuming MPK striping; we check that our guaranteed
+        //   "faulting region" is respected
         // - the last slot won't have MPK striping after it; we check that the
         //   `post_slab_guard_bytes` accounts for this
         assert!(
-            s.slot_bytes * s.num_stripes >= c.expected_slot_bytes + c.guard_bytes,
-            "slot may allow OOB access: {c:?} => {s:?}"
+            s.bytes_to_next_stripe_slot()
+                >= c.expected_slot_bytes.max(c.max_memory_bytes) + c.guard_bytes,
+            "faulting region not large enough: {c:?} => {s:?}"
         );
         assert!(
             s.slot_bytes + s.post_slab_guard_bytes >= c.expected_slot_bytes,
@@ -993,6 +985,6 @@ mod tests {
     }
 
     fn is_aligned(bytes: usize) -> bool {
-        bytes % crate::page_size() == 0
+        bytes % crate::runtime::vm::host_page_size() == 0
     }
 }
diff --git a/crates/wasmtime/src/runtime/vm/instance/allocator/pooling/table_pool.rs b/crates/wasmtime/src/runtime/vm/instance/allocator/pooling/table_pool.rs
new file mode 100644
index 000000000000..c67d43214b63
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/instance/allocator/pooling/table_pool.rs
@@ -0,0 +1,245 @@
+use super::{
+    index_allocator::{SimpleIndexAllocator, SlotId},
+    round_up_to_pow2, TableAllocationIndex,
+};
+use crate::prelude::*;
+use crate::runtime::vm::{
+    InstanceAllocationRequest, Mmap, PoolingInstanceAllocatorConfig, SendSyncPtr, Table,
+};
+use crate::{runtime::vm::sys::vm::commit_pages, vm::round_usize_up_to_host_pages};
+use std::mem;
+use std::ptr::NonNull;
+use wasmtime_environ::{Module, TablePlan};
+
+/// Represents a pool of WebAssembly tables.
+///
+/// Each instance index into the pool returns an iterator over the base addresses
+/// of the instance's tables.
+#[derive(Debug)]
+pub struct TablePool {
+    index_allocator: SimpleIndexAllocator,
+    mapping: Mmap,
+    table_size: usize,
+    max_total_tables: usize,
+    tables_per_instance: usize,
+    page_size: usize,
+    keep_resident: usize,
+    table_elements: usize,
+}
+
+impl TablePool {
+    /// Create a new `TablePool`.
+    pub fn new(config: &PoolingInstanceAllocatorConfig) -> Result<Self> {
+        let page_size = crate::runtime::vm::host_page_size();
+
+        let table_size = round_up_to_pow2(
+            mem::size_of::<*mut u8>()
+                .checked_mul(config.limits.table_elements as usize)
+                .ok_or_else(|| anyhow!("table size exceeds addressable memory"))?,
+            page_size,
+        );
+
+        let max_total_tables = usize::try_from(config.limits.total_tables).unwrap();
+        let tables_per_instance = usize::try_from(config.limits.max_tables_per_module).unwrap();
+
+        let allocation_size = table_size
+            .checked_mul(max_total_tables)
+            .ok_or_else(|| anyhow!("total size of tables exceeds addressable memory"))?;
+
+        let mapping = Mmap::accessible_reserved(allocation_size, allocation_size)
+            .context("failed to create table pool mapping")?;
+
+        Ok(Self {
+            index_allocator: SimpleIndexAllocator::new(config.limits.total_tables),
+            mapping,
+            table_size,
+            max_total_tables,
+            tables_per_instance,
+            page_size,
+            keep_resident: round_usize_up_to_host_pages(config.table_keep_resident)?,
+            table_elements: usize::try_from(config.limits.table_elements).unwrap(),
+        })
+    }
+
+    /// Validate whether this module's tables are allocatable by this pool.
+    pub fn validate(&self, module: &Module) -> Result<()> {
+        let tables = module.table_plans.len() - module.num_imported_tables;
+
+        if tables > usize::try_from(self.tables_per_instance).unwrap() {
+            bail!(
+                "defined tables count of {} exceeds the per-instance limit of {}",
+                tables,
+                self.tables_per_instance,
+            );
+        }
+
+        if tables > self.max_total_tables {
+            bail!(
+                "defined tables count of {} exceeds the total tables limit of {}",
+                tables,
+                self.max_total_tables,
+            );
+        }
+
+        for (i, plan) in module.table_plans.iter().skip(module.num_imported_tables) {
+            if plan.table.minimum > u32::try_from(self.table_elements).unwrap() {
+                bail!(
+                    "table index {} has a minimum element size of {} which exceeds the limit of {}",
+                    i.as_u32(),
+                    plan.table.minimum,
+                    self.table_elements,
+                );
+            }
+        }
+        Ok(())
+    }
+
+    /// Are there zero slots in use right now?
+    #[allow(unused)] // some cfgs don't use this
+    pub fn is_empty(&self) -> bool {
+        self.index_allocator.is_empty()
+    }
+
+    /// Get the base pointer of the given table allocation.
+    fn get(&self, table_index: TableAllocationIndex) -> *mut u8 {
+        assert!(table_index.index() < self.max_total_tables);
+
+        unsafe {
+            self.mapping
+                .as_ptr()
+                .add(table_index.index() * self.table_size)
+                .cast_mut()
+        }
+    }
+
+    /// Allocate a single table for the given instance allocation request.
+    pub fn allocate(
+        &self,
+        request: &mut InstanceAllocationRequest,
+        table_plan: &TablePlan,
+    ) -> Result<(TableAllocationIndex, Table)> {
+        let allocation_index = self
+            .index_allocator
+            .alloc()
+            .map(|slot| TableAllocationIndex(slot.0))
+            .ok_or_else(|| {
+                super::PoolConcurrencyLimitError::new(self.max_total_tables, "tables")
+            })?;
+
+        match (|| {
+            let base = self.get(allocation_index);
+
+            unsafe {
+                commit_pages(
+                    base as *mut u8,
+                    self.table_elements * mem::size_of::<*mut u8>(),
+                )?;
+            }
+
+            let ptr = NonNull::new(std::ptr::slice_from_raw_parts_mut(
+                base.cast(),
+                self.table_elements * mem::size_of::<*mut u8>(),
+            ))
+            .unwrap();
+            unsafe {
+                Table::new_static(
+                    table_plan,
+                    SendSyncPtr::new(ptr),
+                    &mut *request.store.get().unwrap(),
+                )
+            }
+        })() {
+            Ok(table) => Ok((allocation_index, table)),
+            Err(e) => {
+                self.index_allocator.free(SlotId(allocation_index.0));
+                Err(e)
+            }
+        }
+    }
+
+    /// Deallocate a previously-allocated table.
+    ///
+    /// # Safety
+    ///
+    /// The table must have been previously-allocated by this pool and assigned
+    /// the given allocation index, it must currently be allocated, and it must
+    /// never be used again.
+    ///
+    /// The caller must have already called `reset_table_pages_to_zero` on the
+    /// memory and flushed any enqueued decommits for this table's memory.
+    pub unsafe fn deallocate(&self, allocation_index: TableAllocationIndex, table: Table) {
+        assert!(table.is_static());
+        drop(table);
+        self.index_allocator.free(SlotId(allocation_index.0));
+    }
+
+    /// Reset the given table's memory to zero.
+    ///
+    /// Invokes the given `decommit` function for each region of memory that
+    /// needs to be decommitted. It is the caller's responsibility to actually
+    /// perform that decommit before this table is reused.
+    ///
+    /// # Safety
+    ///
+    /// This table must not be in active use, and ready for returning to the
+    /// table pool once it is zeroed and decommitted.
+    pub unsafe fn reset_table_pages_to_zero(
+        &self,
+        allocation_index: TableAllocationIndex,
+        table: &mut Table,
+        mut decommit: impl FnMut(*mut u8, usize),
+    ) {
+        assert!(table.is_static());
+        let base = self.get(allocation_index);
+
+        let size = round_up_to_pow2(
+            table.size() as usize * mem::size_of::<*mut u8>(),
+            self.page_size,
+        );
+
+        // `memset` the first `keep_resident` bytes.
+        let size_to_memset = size.min(self.keep_resident);
+        std::ptr::write_bytes(base, 0, size_to_memset);
+
+        // And decommit the rest of it.
+        decommit(base.add(size_to_memset), size - size_to_memset)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::runtime::vm::InstanceLimits;
+
+    #[cfg(target_pointer_width = "64")]
+    #[test]
+    fn test_table_pool() -> Result<()> {
+        let pool = TablePool::new(&PoolingInstanceAllocatorConfig {
+            limits: InstanceLimits {
+                total_tables: 7,
+                table_elements: 100,
+                max_memory_size: 0,
+                max_memories_per_module: 0,
+                ..Default::default()
+            },
+            ..Default::default()
+        })?;
+
+        let host_page_size = crate::runtime::vm::host_page_size();
+
+        assert_eq!(pool.table_size, host_page_size);
+        assert_eq!(pool.max_total_tables, 7);
+        assert_eq!(pool.page_size, host_page_size);
+        assert_eq!(pool.table_elements, 100);
+
+        let base = pool.mapping.as_ptr() as usize;
+
+        for i in 0..7 {
+            let index = TableAllocationIndex(i);
+            let ptr = pool.get(index);
+            assert_eq!(ptr as usize - base, i as usize * pool.table_size);
+        }
+
+        Ok(())
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/instance/allocator/pooling/unix_stack_pool.rs b/crates/wasmtime/src/runtime/vm/instance/allocator/pooling/unix_stack_pool.rs
new file mode 100644
index 000000000000..2bfe64612216
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/instance/allocator/pooling/unix_stack_pool.rs
@@ -0,0 +1,279 @@
+#![cfg_attr(asan, allow(dead_code))]
+
+use super::{
+    index_allocator::{SimpleIndexAllocator, SlotId},
+    round_up_to_pow2,
+};
+use crate::prelude::*;
+use crate::runtime::vm::sys::vm::commit_pages;
+use crate::runtime::vm::{round_usize_up_to_host_pages, Mmap, PoolingInstanceAllocatorConfig};
+
+/// Represents a pool of execution stacks (used for the async fiber implementation).
+///
+/// Each index into the pool represents a single execution stack. The maximum number of
+/// stacks is the same as the maximum number of instances.
+///
+/// As stacks grow downwards, each stack starts (lowest address) with a guard page
+/// that can be used to detect stack overflow.
+///
+/// The top of the stack (starting stack pointer) is returned when a stack is allocated
+/// from the pool.
+#[derive(Debug)]
+pub struct StackPool {
+    mapping: Mmap,
+    stack_size: usize,
+    max_stacks: usize,
+    page_size: usize,
+    index_allocator: SimpleIndexAllocator,
+    async_stack_zeroing: bool,
+    async_stack_keep_resident: usize,
+}
+
+impl StackPool {
+    pub fn new(config: &PoolingInstanceAllocatorConfig) -> Result<Self> {
+        use rustix::mm::{mprotect, MprotectFlags};
+
+        let page_size = crate::runtime::vm::host_page_size();
+
+        // Add a page to the stack size for the guard page when using fiber stacks
+        let stack_size = if config.stack_size == 0 {
+            0
+        } else {
+            round_up_to_pow2(config.stack_size, page_size)
+                .checked_add(page_size)
+                .ok_or_else(|| anyhow!("stack size exceeds addressable memory"))?
+        };
+
+        let max_stacks = usize::try_from(config.limits.total_stacks).unwrap();
+
+        let allocation_size = stack_size
+            .checked_mul(max_stacks)
+            .ok_or_else(|| anyhow!("total size of execution stacks exceeds addressable memory"))?;
+
+        let mapping = Mmap::accessible_reserved(allocation_size, allocation_size)
+            .context("failed to create stack pool mapping")?;
+
+        // Set up the stack guard pages.
+        if allocation_size > 0 {
+            unsafe {
+                for i in 0..max_stacks {
+                    // Make the stack guard page inaccessible.
+                    let bottom_of_stack = mapping.as_ptr().add(i * stack_size).cast_mut();
+                    mprotect(bottom_of_stack.cast(), page_size, MprotectFlags::empty())
+                        .context("failed to protect stack guard page")?;
+                }
+            }
+        }
+
+        Ok(Self {
+            mapping,
+            stack_size,
+            max_stacks,
+            page_size,
+            async_stack_zeroing: config.async_stack_zeroing,
+            async_stack_keep_resident: round_usize_up_to_host_pages(
+                config.async_stack_keep_resident,
+            )?,
+            index_allocator: SimpleIndexAllocator::new(config.limits.total_stacks),
+        })
+    }
+
+    /// Are there zero slots in use right now?
+    #[allow(unused)] // some cfgs don't use this
+    pub fn is_empty(&self) -> bool {
+        self.index_allocator.is_empty()
+    }
+
+    /// Allocate a new fiber.
+    pub fn allocate(&self) -> Result<wasmtime_fiber::FiberStack> {
+        if self.stack_size == 0 {
+            bail!("pooling allocator not configured to enable fiber stack allocation");
+        }
+
+        let index = self
+            .index_allocator
+            .alloc()
+            .ok_or_else(|| super::PoolConcurrencyLimitError::new(self.max_stacks, "fibers"))?
+            .index();
+
+        assert!(index < self.max_stacks);
+
+        unsafe {
+            // Remove the guard page from the size
+            let size_without_guard = self.stack_size - self.page_size;
+
+            let bottom_of_stack = self
+                .mapping
+                .as_ptr()
+                .add((index * self.stack_size) + self.page_size)
+                .cast_mut();
+
+            commit_pages(bottom_of_stack, size_without_guard)?;
+
+            let stack =
+                wasmtime_fiber::FiberStack::from_raw_parts(bottom_of_stack, size_without_guard)?;
+            Ok(stack)
+        }
+    }
+
+    /// Zero the given stack, if we are configured to do so.
+    ///
+    /// This will call the given `decommit` function for each region of memory
+    /// that should be decommitted. It is the caller's responsibility to ensure
+    /// that those decommits happen before this stack is reused.
+    ///
+    /// # Safety
+    ///
+    /// The stack must no longer be in use, and ready for returning to the pool
+    /// after it is zeroed and decommitted.
+    pub unsafe fn zero_stack(
+        &self,
+        stack: &mut wasmtime_fiber::FiberStack,
+        mut decommit: impl FnMut(*mut u8, usize),
+    ) {
+        assert!(stack.is_from_raw_parts());
+
+        if !self.async_stack_zeroing {
+            return;
+        }
+
+        let top = stack
+            .top()
+            .expect("fiber stack not allocated from the pool") as usize;
+
+        let base = self.mapping.as_ptr() as usize;
+        let len = self.mapping.len();
+        assert!(
+            top > base && top <= (base + len),
+            "fiber stack top pointer not in range"
+        );
+
+        // Remove the guard page from the size
+        let stack_size = self.stack_size - self.page_size;
+        let bottom_of_stack = top - stack_size;
+        let start_of_stack = bottom_of_stack - self.page_size;
+        assert!(start_of_stack >= base && start_of_stack < (base + len));
+        assert!((start_of_stack - base) % self.stack_size == 0);
+
+        // Manually zero the top of the stack to keep the pages resident in
+        // memory and avoid future page faults. Use the system to deallocate
+        // pages past this. This hopefully strikes a reasonable balance between:
+        //
+        // * memset for the whole range is probably expensive
+        // * madvise for the whole range incurs expensive future page faults
+        // * most threads probably don't use most of the stack anyway
+        let size_to_memset = stack_size.min(self.async_stack_keep_resident);
+        std::ptr::write_bytes(
+            (bottom_of_stack + stack_size - size_to_memset) as *mut u8,
+            0,
+            size_to_memset,
+        );
+
+        // Use the system to reset remaining stack pages to zero.
+        decommit(bottom_of_stack as _, stack_size - size_to_memset);
+    }
+
+    /// Deallocate a previously-allocated fiber.
+    ///
+    /// # Safety
+    ///
+    /// The fiber must have been allocated by this pool, must be in an allocated
+    /// state, and must never be used again.
+    ///
+    /// The caller must have already called `zero_stack` on the fiber stack and
+    /// flushed any enqueued decommits for this stack's memory.
+    pub unsafe fn deallocate(&self, stack: wasmtime_fiber::FiberStack) {
+        assert!(stack.is_from_raw_parts());
+
+        let top = stack
+            .top()
+            .expect("fiber stack not allocated from the pool") as usize;
+
+        let base = self.mapping.as_ptr() as usize;
+        let len = self.mapping.len();
+        assert!(
+            top > base && top <= (base + len),
+            "fiber stack top pointer not in range"
+        );
+
+        // Remove the guard page from the size
+        let stack_size = self.stack_size - self.page_size;
+        let bottom_of_stack = top - stack_size;
+        let start_of_stack = bottom_of_stack - self.page_size;
+        assert!(start_of_stack >= base && start_of_stack < (base + len));
+        assert!((start_of_stack - base) % self.stack_size == 0);
+
+        let index = (start_of_stack - base) / self.stack_size;
+        assert!(index < self.max_stacks);
+
+        self.index_allocator.free(SlotId(index as u32));
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::runtime::vm::InstanceLimits;
+
+    #[cfg(all(unix, target_pointer_width = "64", feature = "async", not(miri)))]
+    #[test]
+    fn test_stack_pool() -> Result<()> {
+        let config = PoolingInstanceAllocatorConfig {
+            limits: InstanceLimits {
+                total_stacks: 10,
+                ..Default::default()
+            },
+            stack_size: 1,
+            async_stack_zeroing: true,
+            ..PoolingInstanceAllocatorConfig::default()
+        };
+        let pool = StackPool::new(&config)?;
+
+        let native_page_size = crate::runtime::vm::host_page_size();
+        assert_eq!(pool.stack_size, 2 * native_page_size);
+        assert_eq!(pool.max_stacks, 10);
+        assert_eq!(pool.page_size, native_page_size);
+
+        assert_eq!(pool.index_allocator.testing_freelist(), []);
+
+        let base = pool.mapping.as_ptr() as usize;
+
+        let mut stacks = Vec::new();
+        for i in 0..10 {
+            let stack = pool.allocate().expect("allocation should succeed");
+            assert_eq!(
+                ((stack.top().unwrap() as usize - base) / pool.stack_size) - 1,
+                i
+            );
+            stacks.push(stack);
+        }
+
+        assert_eq!(pool.index_allocator.testing_freelist(), []);
+
+        assert!(pool.allocate().is_err(), "allocation should fail");
+
+        for stack in stacks {
+            unsafe {
+                pool.deallocate(stack);
+            }
+        }
+
+        assert_eq!(
+            pool.index_allocator.testing_freelist(),
+            [
+                SlotId(0),
+                SlotId(1),
+                SlotId(2),
+                SlotId(3),
+                SlotId(4),
+                SlotId(5),
+                SlotId(6),
+                SlotId(7),
+                SlotId(8),
+                SlotId(9)
+            ],
+        );
+
+        Ok(())
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/libcalls.rs b/crates/wasmtime/src/runtime/vm/libcalls.rs
new file mode 100644
index 000000000000..207048809099
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/libcalls.rs
@@ -0,0 +1,850 @@
+//! Runtime library calls.
+//!
+//! Note that Wasm compilers may sometimes perform these inline rather than
+//! calling them, particularly when CPUs have special instructions which compute
+//! them directly.
+//!
+//! These functions are called by compiled Wasm code, and therefore must take
+//! certain care about some things:
+//!
+//! * They must only contain basic, raw i32/i64/f32/f64/pointer parameters that
+//!   are safe to pass across the system ABI.
+//!
+//! * If any nested function propagates an `Err(trap)` out to the library
+//!   function frame, we need to raise it. This involves some nasty and quite
+//!   unsafe code under the covers! Notably, after raising the trap, drops
+//!   **will not** be run for local variables! This can lead to things like
+//!   leaking `InstanceHandle`s which leads to never deallocating JIT code,
+//!   instances, and modules if we are not careful!
+//!
+//! * The libcall must be entered via a Wasm-to-libcall trampoline that saves
+//!   the last Wasm FP and PC for stack walking purposes. (For more details, see
+//!   `crates/wasmtime/src/runtime/vm/backtrace.rs`.)
+//!
+//! To make it easier to correctly handle all these things, **all** libcalls
+//! must be defined via the `libcall!` helper macro! See its doc comments below
+//! for an example, or just look at the rest of the file.
+//!
+//! ## Dealing with `externref`s
+//!
+//! When receiving a raw `*mut u8` that is actually a `VMExternRef` reference,
+//! convert it into a proper `VMExternRef` with `VMExternRef::clone_from_raw` as
+//! soon as apossible. Any GC before raw pointer is converted into a reference
+//! can potentially collect the referenced object, which could lead to use after
+//! free.
+//!
+//! Avoid this by eagerly converting into a proper `VMExternRef`! (Unfortunately
+//! there is no macro to help us automatically get this correct, so stay
+//! vigilant!)
+//!
+//! ```ignore
+//! pub unsafe extern "C" my_libcall_takes_ref(raw_extern_ref: *mut u8) {
+//!     // Before `clone_from_raw`, `raw_extern_ref` is potentially unrooted,
+//!     // and doing GC here could lead to use after free!
+//!
+//!     let my_extern_ref = if raw_extern_ref.is_null() {
+//!         None
+//!     } else {
+//!         Some(VMExternRef::clone_from_raw(raw_extern_ref))
+//!     };
+//!
+//!     // Now that we did `clone_from_raw`, it is safe to do a GC (or do
+//!     // anything else that might transitively GC, like call back into
+//!     // Wasm!)
+//! }
+//! ```
+
+use crate::prelude::*;
+use crate::runtime::vm::table::{Table, TableElementType};
+use crate::runtime::vm::vmcontext::VMFuncRef;
+use crate::runtime::vm::{Instance, TrapReason, VMGcRef};
+#[cfg(feature = "threads")]
+use core::time::Duration;
+use wasmtime_environ::{DataIndex, ElemIndex, FuncIndex, MemoryIndex, TableIndex, Trap, Unsigned};
+#[cfg(feature = "wmemcheck")]
+use wasmtime_wmemcheck::AccessError::{
+    DoubleMalloc, InvalidFree, InvalidRead, InvalidWrite, OutOfBounds,
+};
+
+/// Raw functions which are actually called from compiled code.
+///
+/// Invocation of a builtin currently looks like:
+///
+/// * A wasm function calls a cranelift-compiled trampoline that's generated
+///   once-per-builtin.
+/// * The cranelift-compiled trampoline performs any necessary actions to exit
+///   wasm, such as dealing with fp/pc/etc.
+/// * The cranelift-compiled trampoline loads a function pointer from an array
+///   stored in `VMContext` That function pointer is defined in this module.
+/// * This module runs, handling things like `catch_unwind` and `Result` and
+///   such.
+/// * This module delegates to the outer module (this file) which has the actual
+///   implementation.
+pub mod raw {
+    // Allow these things because of the macro and how we can't differentiate
+    // between doc comments and `cfg`s.
+    #![allow(unused_doc_comments, unused_attributes)]
+
+    use crate::runtime::vm::{Instance, TrapReason, VMContext};
+
+    macro_rules! libcall {
+        (
+            $(
+                $( #[cfg($attr:meta)] )?
+                $name:ident( vmctx: vmctx $(, $pname:ident: $param:ident )* ) $( -> $result:ident )?;
+            )*
+        ) => {
+            $(
+                // This is the direct entrypoint from the compiled module which
+                // still has the raw signature.
+                //
+                // This will delegate to the outer module to the actual
+                // implementation and automatically perform `catch_unwind` along
+                // with conversion of the return value in the face of traps.
+                #[allow(unused_variables, missing_docs)]
+                pub unsafe extern "C" fn $name(
+                    vmctx: *mut VMContext,
+                    $( $pname : libcall!(@ty $param), )*
+                ) $( -> libcall!(@ty $result))? {
+                    $(#[cfg($attr)])?
+                    {
+                        let ret = crate::runtime::vm::traphandlers::catch_unwind_and_longjmp(|| {
+                            Instance::from_vmctx(vmctx, |instance| {
+                                {
+                                    super::$name(instance, $($pname),*)
+                                }
+                            })
+                        });
+                        LibcallResult::convert(ret)
+                    }
+                    $(
+                        #[cfg(not($attr))]
+                        unreachable!();
+                    )?
+                }
+
+                // This works around a `rustc` bug where compiling with LTO
+                // will sometimes strip out some of these symbols resulting
+                // in a linking failure.
+                #[allow(non_upper_case_globals)]
+                const _: () = {
+                    #[used]
+                    static I_AM_USED: unsafe extern "C" fn(
+                        *mut VMContext,
+                        $( $pname : libcall!(@ty $param), )*
+                    ) $( -> libcall!(@ty $result))? = $name;
+                };
+            )*
+        };
+
+        (@ty i32) => (u32);
+        (@ty i64) => (u64);
+        (@ty reference) => (u32);
+        (@ty pointer) => (*mut u8);
+        (@ty vmctx) => (*mut VMContext);
+    }
+
+    wasmtime_environ::foreach_builtin_function!(libcall);
+
+    // Helper trait to convert results of libcalls below into the ABI of what
+    // the libcall expects.
+    //
+    // This basically entirely exists for the `Result` implementation which
+    // "unwraps" via a throwing of a trap.
+    trait LibcallResult {
+        type Abi;
+        unsafe fn convert(self) -> Self::Abi;
+    }
+
+    impl LibcallResult for () {
+        type Abi = ();
+        unsafe fn convert(self) {}
+    }
+
+    impl<T, E> LibcallResult for Result<T, E>
+    where
+        E: Into<TrapReason>,
+    {
+        type Abi = T;
+        unsafe fn convert(self) -> T {
+            match self {
+                Ok(t) => t,
+                Err(e) => crate::runtime::vm::traphandlers::raise_trap(e.into()),
+            }
+        }
+    }
+
+    impl LibcallResult for *mut u8 {
+        type Abi = *mut u8;
+        unsafe fn convert(self) -> *mut u8 {
+            self
+        }
+    }
+}
+
+fn memory32_grow(
+    instance: &mut Instance,
+    delta: u64,
+    memory_index: u32,
+) -> Result<*mut u8, TrapReason> {
+    let memory_index = MemoryIndex::from_u32(memory_index);
+    let result =
+        match instance
+            .memory_grow(memory_index, delta)
+            .map_err(|error| TrapReason::User {
+                error,
+                needs_backtrace: true,
+            })? {
+            Some(size_in_bytes) => size_in_bytes / instance.memory_page_size(memory_index),
+            None => usize::max_value(),
+        };
+    Ok(result as *mut _)
+}
+
+/// Implementation of `table.grow` for `funcref` tables.
+unsafe fn table_grow_func_ref(
+    instance: &mut Instance,
+    table_index: u32,
+    delta: u32,
+    init_value: *mut u8,
+) -> Result<u32> {
+    let table_index = TableIndex::from_u32(table_index);
+
+    let element = match instance.table_element_type(table_index) {
+        TableElementType::Func => (init_value as *mut VMFuncRef).into(),
+        TableElementType::GcRef => unreachable!(),
+    };
+
+    Ok(match instance.table_grow(table_index, delta, element)? {
+        Some(r) => r,
+        None => (-1_i32).unsigned(),
+    })
+}
+
+/// Implementation of `table.grow` for GC-reference tables.
+#[cfg(feature = "gc")]
+unsafe fn table_grow_gc_ref(
+    instance: &mut Instance,
+    table_index: u32,
+    delta: u32,
+    init_value: u32,
+) -> Result<u32> {
+    let table_index = TableIndex::from_u32(table_index);
+
+    let element = match instance.table_element_type(table_index) {
+        TableElementType::Func => unreachable!(),
+        TableElementType::GcRef => VMGcRef::from_raw_u32(init_value)
+            .map(|r| (*instance.store()).gc_store().clone_gc_ref(&r))
+            .into(),
+    };
+
+    Ok(match instance.table_grow(table_index, delta, element)? {
+        Some(r) => r,
+        None => (-1_i32).unsigned(),
+    })
+}
+
+/// Implementation of `table.fill` for `funcref`s.
+unsafe fn table_fill_func_ref(
+    instance: &mut Instance,
+    table_index: u32,
+    dst: u32,
+    val: *mut u8,
+    len: u32,
+) -> Result<(), Trap> {
+    let table_index = TableIndex::from_u32(table_index);
+    let table = &mut *instance.get_table(table_index);
+    match table.element_type() {
+        TableElementType::Func => {
+            let val = val.cast::<VMFuncRef>();
+            table.fill((*instance.store()).gc_store(), dst, val.into(), len)
+        }
+        TableElementType::GcRef => unreachable!(),
+    }
+}
+
+#[cfg(feature = "gc")]
+unsafe fn table_fill_gc_ref(
+    instance: &mut Instance,
+    table_index: u32,
+    dst: u32,
+    val: u32,
+    len: u32,
+) -> Result<(), Trap> {
+    let table_index = TableIndex::from_u32(table_index);
+    let table = &mut *instance.get_table(table_index);
+    match table.element_type() {
+        TableElementType::Func => unreachable!(),
+        TableElementType::GcRef => {
+            let gc_store = (*instance.store()).gc_store();
+            let gc_ref = VMGcRef::from_raw_u32(val);
+            let gc_ref = gc_ref.map(|r| gc_store.clone_gc_ref(&r));
+            table.fill(gc_store, dst, gc_ref.into(), len)
+        }
+    }
+}
+
+// Implementation of `table.copy`.
+unsafe fn table_copy(
+    instance: &mut Instance,
+    dst_table_index: u32,
+    src_table_index: u32,
+    dst: u32,
+    src: u32,
+    len: u32,
+) -> Result<(), Trap> {
+    let dst_table_index = TableIndex::from_u32(dst_table_index);
+    let src_table_index = TableIndex::from_u32(src_table_index);
+    let dst_table = instance.get_table(dst_table_index);
+    // Lazy-initialize the whole range in the source table first.
+    let src_range = src..(src.checked_add(len).unwrap_or(u32::MAX));
+    let src_table = instance.get_table_with_lazy_init(src_table_index, src_range);
+    let gc_store = (*instance.store()).gc_store();
+    Table::copy(gc_store, dst_table, src_table, dst, src, len)
+}
+
+// Implementation of `table.init`.
+fn table_init(
+    instance: &mut Instance,
+    table_index: u32,
+    elem_index: u32,
+    dst: u32,
+    src: u32,
+    len: u32,
+) -> Result<(), Trap> {
+    let table_index = TableIndex::from_u32(table_index);
+    let elem_index = ElemIndex::from_u32(elem_index);
+    instance.table_init(table_index, elem_index, dst, src, len)
+}
+
+// Implementation of `elem.drop`.
+fn elem_drop(instance: &mut Instance, elem_index: u32) {
+    let elem_index = ElemIndex::from_u32(elem_index);
+    instance.elem_drop(elem_index)
+}
+
+// Implementation of `memory.copy`.
+fn memory_copy(
+    instance: &mut Instance,
+    dst_index: u32,
+    dst: u64,
+    src_index: u32,
+    src: u64,
+    len: u64,
+) -> Result<(), Trap> {
+    let src_index = MemoryIndex::from_u32(src_index);
+    let dst_index = MemoryIndex::from_u32(dst_index);
+    instance.memory_copy(dst_index, dst, src_index, src, len)
+}
+
+// Implementation of `memory.fill` for locally defined memories.
+fn memory_fill(
+    instance: &mut Instance,
+    memory_index: u32,
+    dst: u64,
+    val: u32,
+    len: u64,
+) -> Result<(), Trap> {
+    let memory_index = MemoryIndex::from_u32(memory_index);
+    instance.memory_fill(memory_index, dst, val as u8, len)
+}
+
+// Implementation of `memory.init`.
+fn memory_init(
+    instance: &mut Instance,
+    memory_index: u32,
+    data_index: u32,
+    dst: u64,
+    src: u32,
+    len: u32,
+) -> Result<(), Trap> {
+    let memory_index = MemoryIndex::from_u32(memory_index);
+    let data_index = DataIndex::from_u32(data_index);
+    instance.memory_init(memory_index, data_index, dst, src, len)
+}
+
+// Implementation of `ref.func`.
+fn ref_func(instance: &mut Instance, func_index: u32) -> *mut u8 {
+    instance
+        .get_func_ref(FuncIndex::from_u32(func_index))
+        .expect("ref_func: funcref should always be available for given func index")
+        .cast()
+}
+
+// Implementation of `data.drop`.
+fn data_drop(instance: &mut Instance, data_index: u32) {
+    let data_index = DataIndex::from_u32(data_index);
+    instance.data_drop(data_index)
+}
+
+// Returns a table entry after lazily initializing it.
+unsafe fn table_get_lazy_init_func_ref(
+    instance: &mut Instance,
+    table_index: u32,
+    index: u32,
+) -> *mut u8 {
+    let table_index = TableIndex::from_u32(table_index);
+    let table = instance.get_table_with_lazy_init(table_index, core::iter::once(index));
+    let gc_store = (*instance.store()).gc_store();
+    let elem = (*table)
+        .get(gc_store, index)
+        .expect("table access already bounds-checked");
+
+    elem.into_func_ref_asserting_initialized().cast()
+}
+
+/// Drop a GC reference.
+#[cfg(feature = "gc")]
+unsafe fn drop_gc_ref(instance: &mut Instance, gc_ref: u32) {
+    log::trace!("libcalls::drop_gc_ref({gc_ref:#x})");
+    let gc_ref = VMGcRef::from_raw_u32(gc_ref).expect("non-null VMGcRef");
+    (*instance.store()).gc_store().drop_gc_ref(gc_ref);
+}
+
+/// Do a GC, keeping `gc_ref` rooted and returning the updated `gc_ref`
+/// reference.
+#[cfg(feature = "gc")]
+unsafe fn gc(instance: &mut Instance, gc_ref: u32) -> Result<u32> {
+    let gc_ref = VMGcRef::from_raw_u32(gc_ref);
+    let gc_ref = gc_ref.map(|r| (*instance.store()).gc_store().clone_gc_ref(&r));
+
+    if let Some(gc_ref) = &gc_ref {
+        // It is possible that we are GC'ing because the DRC's activation
+        // table's bump region is full, and we failed to insert `gc_ref` into
+        // the bump region. But it is an invariant for DRC collection that all
+        // GC references on the stack are in the DRC's activations table at the
+        // time of a GC. So make sure to "expose" this GC reference to Wasm (aka
+        // insert it into the DRC's activation table) before we do the actual
+        // GC.
+        let gc_store = (*instance.store()).gc_store();
+        let gc_ref = gc_store.clone_gc_ref(gc_ref);
+        gc_store.expose_gc_ref_to_wasm(gc_ref);
+    }
+
+    match (*instance.store()).gc(gc_ref)? {
+        None => Ok(0),
+        Some(r) => {
+            let raw = r.as_raw_u32();
+            (*instance.store()).gc_store().expose_gc_ref_to_wasm(r);
+            Ok(raw)
+        }
+    }
+}
+
+/// Perform a Wasm `global.get` for GC reference globals.
+#[cfg(feature = "gc")]
+unsafe fn gc_ref_global_get(instance: &mut Instance, index: u32) -> Result<u32> {
+    use core::num::NonZeroUsize;
+
+    let index = wasmtime_environ::GlobalIndex::from_u32(index);
+    let global = instance.defined_or_imported_global_ptr(index);
+    let gc_store = (*instance.store()).gc_store();
+
+    if gc_store
+        .gc_heap
+        .need_gc_before_entering_wasm(NonZeroUsize::new(1).unwrap())
+    {
+        (*instance.store()).gc(None)?;
+    }
+
+    match (*global).as_gc_ref() {
+        None => Ok(0),
+        Some(gc_ref) => {
+            let gc_ref = gc_store.clone_gc_ref(gc_ref);
+            let ret = gc_ref.as_raw_u32();
+            gc_store.expose_gc_ref_to_wasm(gc_ref);
+            Ok(ret)
+        }
+    }
+}
+
+/// Perform a Wasm `global.set` for GC reference globals.
+#[cfg(feature = "gc")]
+unsafe fn gc_ref_global_set(instance: &mut Instance, index: u32, gc_ref: u32) {
+    let index = wasmtime_environ::GlobalIndex::from_u32(index);
+    let global = instance.defined_or_imported_global_ptr(index);
+    let gc_ref = VMGcRef::from_raw_u32(gc_ref);
+    let gc_store = (*instance.store()).gc_store();
+    (*global).write_gc_ref(gc_store, gc_ref.as_ref());
+}
+
+// Implementation of `memory.atomic.notify` for locally defined memories.
+#[cfg(feature = "threads")]
+fn memory_atomic_notify(
+    instance: &mut Instance,
+    memory_index: u32,
+    addr_index: u64,
+    count: u32,
+) -> Result<u32, Trap> {
+    let memory = MemoryIndex::from_u32(memory_index);
+    instance
+        .get_runtime_memory(memory)
+        .atomic_notify(addr_index, count)
+}
+
+// Implementation of `memory.atomic.wait32` for locally defined memories.
+#[cfg(feature = "threads")]
+fn memory_atomic_wait32(
+    instance: &mut Instance,
+    memory_index: u32,
+    addr_index: u64,
+    expected: u32,
+    timeout: u64,
+) -> Result<u32, Trap> {
+    let timeout = (timeout as i64 >= 0).then(|| Duration::from_nanos(timeout));
+    let memory = MemoryIndex::from_u32(memory_index);
+    Ok(instance
+        .get_runtime_memory(memory)
+        .atomic_wait32(addr_index, expected, timeout)? as u32)
+}
+
+// Implementation of `memory.atomic.wait64` for locally defined memories.
+#[cfg(feature = "threads")]
+fn memory_atomic_wait64(
+    instance: &mut Instance,
+    memory_index: u32,
+    addr_index: u64,
+    expected: u64,
+    timeout: u64,
+) -> Result<u32, Trap> {
+    let timeout = (timeout as i64 >= 0).then(|| Duration::from_nanos(timeout));
+    let memory = MemoryIndex::from_u32(memory_index);
+    Ok(instance
+        .get_runtime_memory(memory)
+        .atomic_wait64(addr_index, expected, timeout)? as u32)
+}
+
+// Hook for when an instance runs out of fuel.
+unsafe fn out_of_gas(instance: &mut Instance) -> Result<()> {
+    (*instance.store()).out_of_gas()
+}
+
+// Hook for when an instance observes that the epoch has changed.
+unsafe fn new_epoch(instance: &mut Instance) -> Result<u64> {
+    (*instance.store()).new_epoch()
+}
+
+// Hook for validating malloc using wmemcheck_state.
+#[cfg(feature = "wmemcheck")]
+unsafe fn check_malloc(instance: &mut Instance, addr: u32, len: u32) -> Result<u32> {
+    if let Some(wmemcheck_state) = &mut instance.wmemcheck_state {
+        let result = wmemcheck_state.malloc(addr as usize, len as usize);
+        wmemcheck_state.memcheck_on();
+        match result {
+            Ok(()) => {
+                return Ok(0);
+            }
+            Err(DoubleMalloc { addr, len }) => {
+                bail!("Double malloc at addr {:#x} of size {}", addr, len)
+            }
+            Err(OutOfBounds { addr, len }) => {
+                bail!("Malloc out of bounds at addr {:#x} of size {}", addr, len);
+            }
+            _ => {
+                panic!("unreachable")
+            }
+        }
+    }
+    Ok(0)
+}
+
+// Hook for validating free using wmemcheck_state.
+#[cfg(feature = "wmemcheck")]
+unsafe fn check_free(instance: &mut Instance, addr: u32) -> Result<u32> {
+    if let Some(wmemcheck_state) = &mut instance.wmemcheck_state {
+        let result = wmemcheck_state.free(addr as usize);
+        wmemcheck_state.memcheck_on();
+        match result {
+            Ok(()) => {
+                return Ok(0);
+            }
+            Err(InvalidFree { addr }) => {
+                bail!("Invalid free at addr {:#x}", addr)
+            }
+            _ => {
+                panic!("unreachable")
+            }
+        }
+    }
+    Ok(0)
+}
+
+// Hook for validating load using wmemcheck_state.
+#[cfg(feature = "wmemcheck")]
+fn check_load(instance: &mut Instance, num_bytes: u32, addr: u32, offset: u32) -> Result<u32> {
+    if let Some(wmemcheck_state) = &mut instance.wmemcheck_state {
+        let result = wmemcheck_state.read(addr as usize + offset as usize, num_bytes as usize);
+        match result {
+            Ok(()) => {
+                return Ok(0);
+            }
+            Err(InvalidRead { addr, len }) => {
+                bail!("Invalid load at addr {:#x} of size {}", addr, len);
+            }
+            Err(OutOfBounds { addr, len }) => {
+                bail!("Load out of bounds at addr {:#x} of size {}", addr, len);
+            }
+            _ => {
+                panic!("unreachable")
+            }
+        }
+    }
+    Ok(0)
+}
+
+// Hook for validating store using wmemcheck_state.
+#[cfg(feature = "wmemcheck")]
+fn check_store(instance: &mut Instance, num_bytes: u32, addr: u32, offset: u32) -> Result<u32> {
+    if let Some(wmemcheck_state) = &mut instance.wmemcheck_state {
+        let result = wmemcheck_state.write(addr as usize + offset as usize, num_bytes as usize);
+        match result {
+            Ok(()) => {
+                return Ok(0);
+            }
+            Err(InvalidWrite { addr, len }) => {
+                bail!("Invalid store at addr {:#x} of size {}", addr, len)
+            }
+            Err(OutOfBounds { addr, len }) => {
+                bail!("Store out of bounds at addr {:#x} of size {}", addr, len)
+            }
+            _ => {
+                panic!("unreachable")
+            }
+        }
+    }
+    Ok(0)
+}
+
+// Hook for turning wmemcheck load/store validation off when entering a malloc function.
+#[cfg(feature = "wmemcheck")]
+fn malloc_start(instance: &mut Instance) {
+    if let Some(wmemcheck_state) = &mut instance.wmemcheck_state {
+        wmemcheck_state.memcheck_off();
+    }
+}
+
+// Hook for turning wmemcheck load/store validation off when entering a free function.
+#[cfg(feature = "wmemcheck")]
+fn free_start(instance: &mut Instance) {
+    if let Some(wmemcheck_state) = &mut instance.wmemcheck_state {
+        wmemcheck_state.memcheck_off();
+    }
+}
+
+// Hook for tracking wasm stack updates using wmemcheck_state.
+#[cfg(feature = "wmemcheck")]
+fn update_stack_pointer(_instance: &mut Instance, _value: u32) {
+    // TODO: stack-tracing has yet to be finalized. All memory below
+    // the address of the top of the stack is marked as valid for
+    // loads and stores.
+    // if let Some(wmemcheck_state) = &mut instance.wmemcheck_state {
+    //     instance.wmemcheck_state.update_stack_pointer(value as usize);
+    // }
+}
+
+// Hook updating wmemcheck_state memory state vector every time memory.grow is called.
+#[cfg(feature = "wmemcheck")]
+fn update_mem_size(instance: &mut Instance, num_pages: u32) {
+    if let Some(wmemcheck_state) = &mut instance.wmemcheck_state {
+        const KIB: usize = 1024;
+        let num_bytes = num_pages as usize * 64 * KIB;
+        wmemcheck_state.update_mem_size(num_bytes);
+    }
+}
+
+/// This module contains functions which are used for resolving relocations at
+/// runtime if necessary.
+///
+/// These functions are not used by default and currently the only platform
+/// they're used for is on x86_64 when SIMD is disabled and then SSE features
+/// are further disabled. In these configurations Cranelift isn't allowed to use
+/// native CPU instructions so it falls back to libcalls and we rely on the Rust
+/// standard library generally for implementing these.
+#[allow(missing_docs)]
+pub mod relocs {
+    macro_rules! float_function {
+        (std: $std:path, core: $core:path,) => {{
+            #[cfg(feature = "std")]
+            let func = $std;
+            #[cfg(not(feature = "std"))]
+            let func = $core;
+            func
+        }};
+    }
+    pub extern "C" fn floorf32(f: f32) -> f32 {
+        let func = float_function! {
+            std: f32::floor,
+            core: libm::floorf,
+        };
+        func(f)
+    }
+
+    pub extern "C" fn floorf64(f: f64) -> f64 {
+        let func = float_function! {
+            std: f64::floor,
+            core: libm::floor,
+        };
+        func(f)
+    }
+
+    pub extern "C" fn ceilf32(f: f32) -> f32 {
+        let func = float_function! {
+            std: f32::ceil,
+            core: libm::ceilf,
+        };
+        func(f)
+    }
+
+    pub extern "C" fn ceilf64(f: f64) -> f64 {
+        let func = float_function! {
+            std: f64::ceil,
+            core: libm::ceil,
+        };
+        func(f)
+    }
+
+    pub extern "C" fn truncf32(f: f32) -> f32 {
+        let func = float_function! {
+            std: f32::trunc,
+            core: libm::truncf,
+        };
+        func(f)
+    }
+
+    pub extern "C" fn truncf64(f: f64) -> f64 {
+        let func = float_function! {
+            std: f64::trunc,
+            core: libm::trunc,
+        };
+        func(f)
+    }
+
+    const TOINT_32: f32 = 1.0 / f32::EPSILON;
+    const TOINT_64: f64 = 1.0 / f64::EPSILON;
+
+    // NB: replace with `round_ties_even` from libstd when it's stable as
+    // tracked by rust-lang/rust#96710
+    pub extern "C" fn nearestf32(x: f32) -> f32 {
+        // Rust doesn't have a nearest function; there's nearbyint, but it's not
+        // stabilized, so do it manually.
+        // Nearest is either ceil or floor depending on which is nearest or even.
+        // This approach exploited round half to even default mode.
+        let i = x.to_bits();
+        let e = i >> 23 & 0xff;
+        if e >= 0x7f_u32 + 23 {
+            // Check for NaNs.
+            if e == 0xff {
+                // Read the 23-bits significand.
+                if i & 0x7fffff != 0 {
+                    // Ensure it's arithmetic by setting the significand's most
+                    // significant bit to 1; it also works for canonical NaNs.
+                    return f32::from_bits(i | (1 << 22));
+                }
+            }
+            x
+        } else {
+            let abs = float_function! {
+                std: f32::abs,
+                core: libm::fabsf,
+            };
+            let copysign = float_function! {
+                std: f32::copysign,
+                core: libm::copysignf,
+            };
+
+            copysign(abs(x) + TOINT_32 - TOINT_32, x)
+        }
+    }
+
+    pub extern "C" fn nearestf64(x: f64) -> f64 {
+        let i = x.to_bits();
+        let e = i >> 52 & 0x7ff;
+        if e >= 0x3ff_u64 + 52 {
+            // Check for NaNs.
+            if e == 0x7ff {
+                // Read the 52-bits significand.
+                if i & 0xfffffffffffff != 0 {
+                    // Ensure it's arithmetic by setting the significand's most
+                    // significant bit to 1; it also works for canonical NaNs.
+                    return f64::from_bits(i | (1 << 51));
+                }
+            }
+            x
+        } else {
+            let abs = float_function! {
+                std: f64::abs,
+                core: libm::fabs,
+            };
+            let copysign = float_function! {
+                std: f64::copysign,
+                core: libm::copysign,
+            };
+
+            copysign(abs(x) + TOINT_64 - TOINT_64, x)
+        }
+    }
+
+    pub extern "C" fn fmaf32(a: f32, b: f32, c: f32) -> f32 {
+        let func = float_function! {
+            std: f32::mul_add,
+            core: libm::fmaf,
+        };
+        func(a, b, c)
+    }
+
+    pub extern "C" fn fmaf64(a: f64, b: f64, c: f64) -> f64 {
+        let func = float_function! {
+            std: f64::mul_add,
+            core: libm::fma,
+        };
+        func(a, b, c)
+    }
+
+    // This intrinsic is only used on x86_64 platforms as an implementation of
+    // the `pshufb` instruction when SSSE3 is not available.
+    #[cfg(target_arch = "x86_64")]
+    use core::arch::x86_64::__m128i;
+    #[cfg(target_arch = "x86_64")]
+    #[allow(improper_ctypes_definitions)]
+    pub extern "C" fn x86_pshufb(a: __m128i, b: __m128i) -> __m128i {
+        union U {
+            reg: __m128i,
+            mem: [u8; 16],
+        }
+
+        unsafe {
+            let a = U { reg: a }.mem;
+            let b = U { reg: b }.mem;
+
+            let select = |arr: &[u8; 16], byte: u8| {
+                if byte & 0x80 != 0 {
+                    0x00
+                } else {
+                    arr[(byte & 0xf) as usize]
+                }
+            };
+
+            U {
+                mem: [
+                    select(&a, b[0]),
+                    select(&a, b[1]),
+                    select(&a, b[2]),
+                    select(&a, b[3]),
+                    select(&a, b[4]),
+                    select(&a, b[5]),
+                    select(&a, b[6]),
+                    select(&a, b[7]),
+                    select(&a, b[8]),
+                    select(&a, b[9]),
+                    select(&a, b[10]),
+                    select(&a, b[11]),
+                    select(&a, b[12]),
+                    select(&a, b[13]),
+                    select(&a, b[14]),
+                    select(&a, b[15]),
+                ],
+            }
+            .reg
+        }
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/memory.rs b/crates/wasmtime/src/runtime/vm/memory.rs
new file mode 100644
index 000000000000..d36ea1dc6eed
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/memory.rs
@@ -0,0 +1,815 @@
+//! Memory management for linear memories.
+//!
+//! `RuntimeLinearMemory` is to WebAssembly linear memories what `Table` is to WebAssembly tables.
+
+use crate::prelude::*;
+use crate::runtime::vm::mmap::Mmap;
+use crate::runtime::vm::vmcontext::VMMemoryDefinition;
+use crate::runtime::vm::{
+    round_usize_up_to_host_pages, usize_is_multiple_of_host_page_size, MemoryImage,
+    MemoryImageSlot, SendSyncPtr, SharedMemory, Store, WaitResult,
+};
+use alloc::sync::Arc;
+use core::ops::Range;
+use core::ptr::NonNull;
+use core::time::Duration;
+use wasmtime_environ::{MemoryPlan, MemoryStyle, Trap};
+
+/// A memory allocator
+pub trait RuntimeMemoryCreator: Send + Sync {
+    /// Create new RuntimeLinearMemory
+    fn new_memory(
+        &self,
+        plan: &MemoryPlan,
+        minimum: usize,
+        maximum: Option<usize>,
+        // Optionally, a memory image for CoW backing.
+        memory_image: Option<&Arc<MemoryImage>>,
+    ) -> Result<Box<dyn RuntimeLinearMemory>>;
+}
+
+/// A default memory allocator used by Wasmtime
+pub struct DefaultMemoryCreator;
+
+impl RuntimeMemoryCreator for DefaultMemoryCreator {
+    /// Create new MmapMemory
+    fn new_memory(
+        &self,
+        plan: &MemoryPlan,
+        minimum: usize,
+        maximum: Option<usize>,
+        memory_image: Option<&Arc<MemoryImage>>,
+    ) -> Result<Box<dyn RuntimeLinearMemory>> {
+        Ok(Box::new(MmapMemory::new(
+            plan,
+            minimum,
+            maximum,
+            memory_image,
+        )?))
+    }
+}
+
+/// A linear memory's backing storage.
+///
+/// This does not a full Wasm linear memory, as it may
+pub trait RuntimeLinearMemory: Send + Sync {
+    /// Returns the log2 of this memory's page size, in bytes.
+    fn page_size_log2(&self) -> u8;
+
+    /// Returns this memory's page size, in bytes.
+    fn page_size(&self) -> u64 {
+        let log2 = self.page_size_log2();
+        debug_assert!(log2 == 16 || log2 == 0);
+        1 << self.page_size_log2()
+    }
+
+    /// Returns the number of allocated bytes.
+    fn byte_size(&self) -> usize;
+
+    /// Returns the maximum number of bytes the memory can grow to.
+    /// Returns `None` if the memory is unbounded.
+    fn maximum_byte_size(&self) -> Option<usize>;
+
+    /// Grows a memory by `delta_pages`.
+    ///
+    /// This performs the necessary checks on the growth before delegating to
+    /// the underlying `grow_to` implementation. A default implementation of
+    /// this memory is provided here since this is assumed to be the same for
+    /// most kinds of memory; one exception is shared memory, which must perform
+    /// all the steps of the default implementation *plus* the required locking.
+    ///
+    /// The `store` is used only for error reporting.
+    fn grow(
+        &mut self,
+        delta_pages: u64,
+        mut store: Option<&mut dyn Store>,
+    ) -> Result<Option<(usize, usize)>, Error> {
+        let old_byte_size = self.byte_size();
+
+        // Wasm spec: when growing by 0 pages, always return the current size.
+        if delta_pages == 0 {
+            return Ok(Some((old_byte_size, old_byte_size)));
+        }
+
+        let page_size = usize::try_from(self.page_size()).unwrap();
+
+        // The largest wasm-page-aligned region of memory is possible to
+        // represent in a `usize`. This will be impossible for the system to
+        // actually allocate.
+        let absolute_max = 0usize.wrapping_sub(page_size);
+
+        // Calculate the byte size of the new allocation. Let it overflow up to
+        // `usize::MAX`, then clamp it down to `absolute_max`.
+        let new_byte_size = usize::try_from(delta_pages)
+            .unwrap_or(usize::MAX)
+            .saturating_mul(page_size)
+            .saturating_add(old_byte_size)
+            .min(absolute_max);
+
+        let maximum = self.maximum_byte_size();
+
+        // Store limiter gets first chance to reject memory_growing.
+        if let Some(store) = &mut store {
+            if !store.memory_growing(old_byte_size, new_byte_size, maximum)? {
+                return Ok(None);
+            }
+        }
+
+        // Never exceed maximum, even if limiter permitted it.
+        if let Some(max) = maximum {
+            if new_byte_size > max {
+                if let Some(store) = store {
+                    // FIXME: shared memories may not have an associated store
+                    // to report the growth failure to but the error should not
+                    // be dropped
+                    // (https://github.com/bytecodealliance/wasmtime/issues/4240).
+                    store.memory_grow_failed(format_err!("Memory maximum size exceeded"))?;
+                }
+                return Ok(None);
+            }
+        }
+
+        match self.grow_to(new_byte_size) {
+            Ok(_) => Ok(Some((old_byte_size, new_byte_size))),
+            Err(e) => {
+                // FIXME: shared memories may not have an associated store to
+                // report the growth failure to but the error should not be
+                // dropped
+                // (https://github.com/bytecodealliance/wasmtime/issues/4240).
+                if let Some(store) = store {
+                    store.memory_grow_failed(e)?;
+                }
+                Ok(None)
+            }
+        }
+    }
+
+    /// Grow memory to the specified amount of bytes.
+    ///
+    /// Returns an error if memory can't be grown by the specified amount
+    /// of bytes.
+    fn grow_to(&mut self, size: usize) -> Result<()>;
+
+    /// Return a `VMMemoryDefinition` for exposing the memory to compiled wasm
+    /// code.
+    fn vmmemory(&mut self) -> VMMemoryDefinition;
+
+    /// Does this memory need initialization? It may not if it already
+    /// has initial contents courtesy of the `MemoryImage` passed to
+    /// `RuntimeMemoryCreator::new_memory()`.
+    fn needs_init(&self) -> bool;
+
+    /// Used for optional dynamic downcasting.
+    fn as_any_mut(&mut self) -> &mut dyn core::any::Any;
+
+    /// Returns the range of addresses that may be reached by WebAssembly.
+    ///
+    /// This starts at the base of linear memory and ends at the end of the
+    /// guard pages, if any.
+    fn wasm_accessible(&self) -> Range<usize>;
+}
+
+/// A linear memory instance.
+#[derive(Debug)]
+pub struct MmapMemory {
+    // The underlying allocation.
+    mmap: Mmap,
+
+    // The current length of this Wasm memory, in bytes.
+    //
+    // This region starts at `pre_guard_size` offset from the base of `mmap`. It
+    // is always accessible, which means that if the Wasm page size is smaller
+    // than the host page size, there may be some trailing region in the `mmap`
+    // that is accessible but should not be accessed. (We rely on explicit
+    // bounds checks in the compiled code to protect this region.)
+    len: usize,
+
+    // The optional maximum accessible size, in bytes, for this linear memory.
+    //
+    // Note that this maximum does not factor in guard pages, so this isn't the
+    // maximum size of the linear address space reservation for this memory.
+    //
+    // This is *not* always a multiple of the host page size, and
+    // `self.accessible()` may go past `self.maximum` when Wasm is using a small
+    // custom page size due to `self.accessible()`'s rounding up to the host
+    // page size.
+    maximum: Option<usize>,
+
+    // The log2 of this Wasm memory's page size, in bytes.
+    page_size_log2: u8,
+
+    // The amount of extra bytes to reserve whenever memory grows. This is
+    // specified so that the cost of repeated growth is amortized.
+    extra_to_reserve_on_growth: usize,
+
+    // Size in bytes of extra guard pages before the start and after the end to
+    // optimize loads and stores with constant offsets.
+    pre_guard_size: usize,
+    offset_guard_size: usize,
+
+    // An optional CoW mapping that provides the initial content of this
+    // MmapMemory, if mapped.
+    memory_image: Option<MemoryImageSlot>,
+}
+
+impl MmapMemory {
+    /// Create a new linear memory instance with specified minimum and maximum
+    /// number of wasm pages.
+    pub fn new(
+        plan: &MemoryPlan,
+        minimum: usize,
+        mut maximum: Option<usize>,
+        memory_image: Option<&Arc<MemoryImage>>,
+    ) -> Result<Self> {
+        // It's a programmer error for these two configuration values to exceed
+        // the host available address space, so panic if such a configuration is
+        // found (mostly an issue for hypothetical 32-bit hosts).
+        let offset_guard_bytes = usize::try_from(plan.offset_guard_size).unwrap();
+        let pre_guard_bytes = usize::try_from(plan.pre_guard_size).unwrap();
+
+        // Ensure that our guard regions are multiples of the host page size.
+        let offset_guard_bytes = round_usize_up_to_host_pages(offset_guard_bytes)?;
+        let pre_guard_bytes = round_usize_up_to_host_pages(pre_guard_bytes)?;
+
+        let (alloc_bytes, extra_to_reserve_on_growth) = match plan.style {
+            // Dynamic memories start with the minimum size plus the `reserve`
+            // amount specified to grow into.
+            MemoryStyle::Dynamic { reserve } => (
+                round_usize_up_to_host_pages(minimum)?,
+                round_usize_up_to_host_pages(usize::try_from(reserve).unwrap())?,
+            ),
+
+            // Static memories will never move in memory and consequently get
+            // their entire allocation up-front with no extra room to grow into.
+            // Note that the `maximum` is adjusted here to whatever the smaller
+            // of the two is, the `maximum` given or the `bound` specified for
+            // this memory.
+            MemoryStyle::Static { byte_reservation } => {
+                assert!(byte_reservation >= plan.memory.minimum_byte_size().unwrap());
+                let bound_bytes = usize::try_from(byte_reservation).unwrap();
+                let bound_bytes = round_usize_up_to_host_pages(bound_bytes)?;
+                maximum = Some(bound_bytes.min(maximum.unwrap_or(usize::MAX)));
+                (bound_bytes, 0)
+            }
+        };
+        assert!(usize_is_multiple_of_host_page_size(alloc_bytes));
+
+        let request_bytes = pre_guard_bytes
+            .checked_add(alloc_bytes)
+            .and_then(|i| i.checked_add(extra_to_reserve_on_growth))
+            .and_then(|i| i.checked_add(offset_guard_bytes))
+            .ok_or_else(|| format_err!("cannot allocate {} with guard regions", minimum))?;
+        assert!(usize_is_multiple_of_host_page_size(request_bytes));
+
+        let mut mmap = Mmap::accessible_reserved(0, request_bytes)?;
+
+        if minimum > 0 {
+            let accessible = round_usize_up_to_host_pages(minimum)?;
+            mmap.make_accessible(pre_guard_bytes, accessible)?;
+        }
+
+        // If a memory image was specified, try to create the MemoryImageSlot on
+        // top of our mmap.
+        let memory_image = match memory_image {
+            Some(image) => {
+                let base = unsafe { mmap.as_mut_ptr().add(pre_guard_bytes) };
+                let mut slot = MemoryImageSlot::create(
+                    base.cast(),
+                    minimum,
+                    alloc_bytes + extra_to_reserve_on_growth,
+                );
+                slot.instantiate(minimum, Some(image), &plan)?;
+                // On drop, we will unmap our mmap'd range that this slot was
+                // mapped on top of, so there is no need for the slot to wipe
+                // it with an anonymous mapping first.
+                slot.no_clear_on_drop();
+                Some(slot)
+            }
+            None => None,
+        };
+
+        Ok(Self {
+            mmap,
+            len: minimum,
+            maximum,
+            page_size_log2: plan.memory.page_size_log2,
+            pre_guard_size: pre_guard_bytes,
+            offset_guard_size: offset_guard_bytes,
+            extra_to_reserve_on_growth,
+            memory_image,
+        })
+    }
+
+    /// Get the length of the accessible portion of the underlying `mmap`. This
+    /// is the same region as `self.len` but rounded up to a multiple of the
+    /// host page size.
+    fn accessible(&self) -> usize {
+        let accessible =
+            round_usize_up_to_host_pages(self.len).expect("accessible region always fits in usize");
+        debug_assert!(accessible <= self.mmap.len() - self.offset_guard_size - self.pre_guard_size);
+        accessible
+    }
+}
+
+impl RuntimeLinearMemory for MmapMemory {
+    fn page_size_log2(&self) -> u8 {
+        self.page_size_log2
+    }
+
+    fn byte_size(&self) -> usize {
+        self.len
+    }
+
+    fn maximum_byte_size(&self) -> Option<usize> {
+        self.maximum
+    }
+
+    fn grow_to(&mut self, new_size: usize) -> Result<()> {
+        assert!(usize_is_multiple_of_host_page_size(self.offset_guard_size));
+        assert!(usize_is_multiple_of_host_page_size(self.pre_guard_size));
+        assert!(usize_is_multiple_of_host_page_size(self.mmap.len()));
+
+        let new_accessible = round_usize_up_to_host_pages(new_size)?;
+        if new_accessible > self.mmap.len() - self.offset_guard_size - self.pre_guard_size {
+            // If the new size of this heap exceeds the current size of the
+            // allocation we have, then this must be a dynamic heap. Use
+            // `new_size` to calculate a new size of an allocation, allocate it,
+            // and then copy over the memory from before.
+            let request_bytes = self
+                .pre_guard_size
+                .checked_add(new_accessible)
+                .and_then(|s| s.checked_add(self.extra_to_reserve_on_growth))
+                .and_then(|s| s.checked_add(self.offset_guard_size))
+                .ok_or_else(|| format_err!("overflow calculating size of memory allocation"))?;
+            assert!(usize_is_multiple_of_host_page_size(request_bytes));
+
+            let mut new_mmap = Mmap::accessible_reserved(0, request_bytes)?;
+            new_mmap.make_accessible(self.pre_guard_size, new_accessible)?;
+
+            // This method has an exclusive reference to `self.mmap` and just
+            // created `new_mmap` so it should be safe to acquire references
+            // into both of them and copy between them.
+            unsafe {
+                let range = self.pre_guard_size..self.pre_guard_size + self.len;
+                let src = self.mmap.slice(range.clone());
+                let dst = new_mmap.slice_mut(range);
+                dst.copy_from_slice(src);
+            }
+
+            // Now drop the MemoryImageSlot, if any. We've lost the CoW
+            // advantages by explicitly copying all data, but we have
+            // preserved all of its content; so we no longer need the
+            // mapping. We need to do this before we (implicitly) drop the
+            // `mmap` field by overwriting it below.
+            drop(self.memory_image.take());
+
+            self.mmap = new_mmap;
+        } else if let Some(image) = self.memory_image.as_mut() {
+            // MemoryImageSlot has its own growth mechanisms; defer to its
+            // implementation.
+            image.set_heap_limit(new_size)?;
+        } else {
+            // If the new size of this heap fits within the existing allocation
+            // then all we need to do is to make the new pages accessible. This
+            // can happen either for "static" heaps which always hit this case,
+            // or "dynamic" heaps which have some space reserved after the
+            // initial allocation to grow into before the heap is moved in
+            // memory.
+            assert!(new_size > self.len);
+            assert!(self.maximum.map_or(true, |max| new_size <= max));
+            assert!(new_size <= self.mmap.len() - self.offset_guard_size - self.pre_guard_size);
+
+            let new_accessible = round_usize_up_to_host_pages(new_size)?;
+            assert!(
+                new_accessible <= self.mmap.len() - self.offset_guard_size - self.pre_guard_size,
+            );
+
+            // If the Wasm memory's page size is smaller than the host's page
+            // size, then we might not need to actually change permissions,
+            // since we are forced to round our accessible range up to the
+            // host's page size.
+            if new_accessible > self.accessible() {
+                self.mmap.make_accessible(
+                    self.pre_guard_size + self.accessible(),
+                    new_accessible - self.accessible(),
+                )?;
+            }
+        }
+
+        self.len = new_size;
+
+        Ok(())
+    }
+
+    fn vmmemory(&mut self) -> VMMemoryDefinition {
+        VMMemoryDefinition {
+            base: unsafe { self.mmap.as_mut_ptr().add(self.pre_guard_size) },
+            current_length: self.len.into(),
+        }
+    }
+
+    fn needs_init(&self) -> bool {
+        // If we're using a CoW mapping, then no initialization
+        // is needed.
+        self.memory_image.is_none()
+    }
+
+    fn as_any_mut(&mut self) -> &mut dyn core::any::Any {
+        self
+    }
+
+    fn wasm_accessible(&self) -> Range<usize> {
+        let base = self.mmap.as_ptr() as usize + self.pre_guard_size;
+        let end = base + (self.mmap.len() - self.pre_guard_size);
+        base..end
+    }
+}
+
+/// A "static" memory where the lifetime of the backing memory is managed
+/// elsewhere. Currently used with the pooling allocator.
+struct StaticMemory {
+    /// The base pointer of this static memory, wrapped up in a send/sync
+    /// wrapper.
+    base: SendSyncPtr<u8>,
+
+    /// The byte capacity of the `base` pointer.
+    capacity: usize,
+
+    /// The current size, in bytes, of this memory.
+    size: usize,
+
+    /// The log2 of this memory's page size.
+    page_size_log2: u8,
+
+    /// The size, in bytes, of the virtual address allocation starting at `base`
+    /// and going to the end of the guard pages at the end of the linear memory.
+    memory_and_guard_size: usize,
+
+    /// The image management, if any, for this memory. Owned here and
+    /// returned to the pooling allocator when termination occurs.
+    memory_image: MemoryImageSlot,
+}
+
+impl StaticMemory {
+    fn new(
+        base_ptr: *mut u8,
+        base_capacity: usize,
+        initial_size: usize,
+        maximum_size: Option<usize>,
+        page_size_log2: u8,
+        memory_image: MemoryImageSlot,
+        memory_and_guard_size: usize,
+    ) -> Result<Self> {
+        if base_capacity < initial_size {
+            bail!(
+                "initial memory size of {} exceeds the pooling allocator's \
+                 configured maximum memory size of {} bytes",
+                initial_size,
+                base_capacity,
+            );
+        }
+
+        // Only use the part of the slice that is necessary.
+        let base_capacity = match maximum_size {
+            Some(max) if max < base_capacity => max,
+            _ => base_capacity,
+        };
+
+        Ok(Self {
+            base: SendSyncPtr::new(NonNull::new(base_ptr).unwrap()),
+            capacity: base_capacity,
+            size: initial_size,
+            page_size_log2,
+            memory_image,
+            memory_and_guard_size,
+        })
+    }
+}
+
+impl RuntimeLinearMemory for StaticMemory {
+    fn page_size_log2(&self) -> u8 {
+        self.page_size_log2
+    }
+
+    fn byte_size(&self) -> usize {
+        self.size
+    }
+
+    fn maximum_byte_size(&self) -> Option<usize> {
+        Some(self.capacity)
+    }
+
+    fn grow_to(&mut self, new_byte_size: usize) -> Result<()> {
+        // Never exceed the static memory size; this check should have been made
+        // prior to arriving here.
+        assert!(new_byte_size <= self.capacity);
+
+        self.memory_image.set_heap_limit(new_byte_size)?;
+
+        // Update our accounting of the available size.
+        self.size = new_byte_size;
+        Ok(())
+    }
+
+    fn vmmemory(&mut self) -> VMMemoryDefinition {
+        VMMemoryDefinition {
+            base: self.base.as_ptr(),
+            current_length: self.size.into(),
+        }
+    }
+
+    fn needs_init(&self) -> bool {
+        !self.memory_image.has_image()
+    }
+
+    fn as_any_mut(&mut self) -> &mut dyn core::any::Any {
+        self
+    }
+
+    fn wasm_accessible(&self) -> Range<usize> {
+        let base = self.base.as_ptr() as usize;
+        let end = base + self.memory_and_guard_size;
+        base..end
+    }
+}
+
+/// Representation of a runtime wasm linear memory.
+pub struct Memory(pub(crate) Box<dyn RuntimeLinearMemory>);
+
+impl Memory {
+    /// Create a new dynamic (movable) memory instance for the specified plan.
+    pub fn new_dynamic(
+        plan: &MemoryPlan,
+        creator: &dyn RuntimeMemoryCreator,
+        store: &mut dyn Store,
+        memory_image: Option<&Arc<MemoryImage>>,
+    ) -> Result<Self> {
+        let (minimum, maximum) = Self::limit_new(plan, Some(store))?;
+        let allocation = creator.new_memory(plan, minimum, maximum, memory_image)?;
+        let allocation = if plan.memory.shared {
+            Box::new(SharedMemory::wrap(plan, allocation, plan.memory)?)
+        } else {
+            allocation
+        };
+        Ok(Memory(allocation))
+    }
+
+    /// Create a new static (immovable) memory instance for the specified plan.
+    pub fn new_static(
+        plan: &MemoryPlan,
+        base_ptr: *mut u8,
+        base_capacity: usize,
+        memory_image: MemoryImageSlot,
+        memory_and_guard_size: usize,
+        store: &mut dyn Store,
+    ) -> Result<Self> {
+        let (minimum, maximum) = Self::limit_new(plan, Some(store))?;
+        let pooled_memory = StaticMemory::new(
+            base_ptr,
+            base_capacity,
+            minimum,
+            maximum,
+            plan.memory.page_size_log2,
+            memory_image,
+            memory_and_guard_size,
+        )?;
+        let allocation = Box::new(pooled_memory);
+        let allocation: Box<dyn RuntimeLinearMemory> = if plan.memory.shared {
+            // FIXME: since the pooling allocator owns the memory allocation
+            // (which is torn down with the instance), the current shared memory
+            // implementation will cause problems; see
+            // https://github.com/bytecodealliance/wasmtime/issues/4244.
+            todo!("using shared memory with the pooling allocator is a work in progress");
+        } else {
+            allocation
+        };
+        Ok(Memory(allocation))
+    }
+
+    /// Calls the `store`'s limiter to optionally prevent a memory from being allocated.
+    ///
+    /// Returns a tuple of the minimum size, optional maximum size, and log(page
+    /// size) of the memory, all in bytes.
+    pub(crate) fn limit_new(
+        plan: &MemoryPlan,
+        store: Option<&mut dyn Store>,
+    ) -> Result<(usize, Option<usize>)> {
+        let page_size = usize::try_from(plan.memory.page_size()).unwrap();
+
+        // This is the absolute possible maximum that the module can try to
+        // allocate, which is our entire address space minus a wasm page. That
+        // shouldn't ever actually work in terms of an allocation because
+        // presumably the kernel wants *something* for itself, but this is used
+        // to pass to the `store`'s limiter for a requested size
+        // to approximate the scale of the request that the wasm module is
+        // making. This is necessary because the limiter works on `usize` bytes
+        // whereas we're working with possibly-overflowing `u64` calculations
+        // here. To actually faithfully represent the byte requests of modules
+        // we'd have to represent things as `u128`, but that's kinda
+        // overkill for this purpose.
+        let absolute_max = 0usize.wrapping_sub(page_size);
+
+        // Sanity-check what should already be true from wasm module validation.
+        if let Ok(size) = plan.memory.minimum_byte_size() {
+            assert!(size <= u64::try_from(absolute_max).unwrap());
+        }
+        if let Ok(max) = plan.memory.maximum_byte_size() {
+            assert!(max <= u64::try_from(absolute_max).unwrap());
+        }
+
+        // If the minimum memory size overflows the size of our own address
+        // space, then we can't satisfy this request, but defer the error to
+        // later so the `store` can be informed that an effective oom is
+        // happening.
+        let minimum = plan
+            .memory
+            .minimum_byte_size()
+            .ok()
+            .and_then(|m| usize::try_from(m).ok());
+
+        // The plan stores the maximum size in units of wasm pages, but we
+        // use units of bytes. Unlike for the `minimum` size we silently clamp
+        // the effective maximum size to the limits of what we can track. If the
+        // maximum size exceeds `usize` or `u64` then there's no need to further
+        // keep track of it as some sort of runtime limit will kick in long
+        // before we reach the statically declared maximum size.
+        let maximum = plan
+            .memory
+            .maximum_byte_size()
+            .ok()
+            .and_then(|m| usize::try_from(m).ok());
+
+        // Inform the store's limiter what's about to happen. This will let the
+        // limiter reject anything if necessary, and this also guarantees that
+        // we should call the limiter for all requested memories, even if our
+        // `minimum` calculation overflowed. This means that the `minimum` we're
+        // informing the limiter is lossy and may not be 100% accurate, but for
+        // now the expected uses of limiter means that's ok.
+        if let Some(store) = store {
+            // We ignore the store limits for shared memories since they are
+            // technically not created within a store (though, trickily, they
+            // may be associated with one in order to get a `vmctx`).
+            if !plan.memory.shared {
+                if !store.memory_growing(0, minimum.unwrap_or(absolute_max), maximum)? {
+                    bail!(
+                        "memory minimum size of {} pages exceeds memory limits",
+                        plan.memory.minimum
+                    );
+                }
+            }
+        }
+
+        // At this point we need to actually handle overflows, so bail out with
+        // an error if we made it this far.
+        let minimum = minimum.ok_or_else(|| {
+            format_err!(
+                "memory minimum size of {} pages exceeds memory limits",
+                plan.memory.minimum
+            )
+        })?;
+
+        Ok((minimum, maximum))
+    }
+
+    /// Returns this memory's page size, in bytes.
+    pub fn page_size(&self) -> u64 {
+        self.0.page_size()
+    }
+
+    /// Returns the number of allocated wasm pages.
+    pub fn byte_size(&self) -> usize {
+        self.0.byte_size()
+    }
+
+    /// Returns whether or not this memory needs initialization. It
+    /// may not if it already has initial content thanks to a CoW
+    /// mechanism.
+    pub(crate) fn needs_init(&self) -> bool {
+        self.0.needs_init()
+    }
+
+    /// Grow memory by the specified amount of wasm pages.
+    ///
+    /// Returns `None` if memory can't be grown by the specified amount
+    /// of wasm pages. Returns `Some` with the old size of memory, in bytes, on
+    /// successful growth.
+    ///
+    /// # Safety
+    ///
+    /// Resizing the memory can reallocate the memory buffer for dynamic memories.
+    /// An instance's `VMContext` may have pointers to the memory's base and will
+    /// need to be fixed up after growing the memory.
+    ///
+    /// Generally, prefer using `InstanceHandle::memory_grow`, which encapsulates
+    /// this unsafety.
+    ///
+    /// Ensure that the provided Store is not used to get access any Memory
+    /// which lives inside it.
+    pub unsafe fn grow(
+        &mut self,
+        delta_pages: u64,
+        store: Option<&mut dyn Store>,
+    ) -> Result<Option<usize>, Error> {
+        self.0
+            .grow(delta_pages, store)
+            .map(|opt| opt.map(|(old, _new)| old))
+    }
+
+    /// Return a `VMMemoryDefinition` for exposing the memory to compiled wasm code.
+    pub fn vmmemory(&mut self) -> VMMemoryDefinition {
+        self.0.vmmemory()
+    }
+
+    /// Consume the memory, returning its [`MemoryImageSlot`] if any is present.
+    /// The image should only be present for a subset of memories created with
+    /// [`Memory::new_static()`].
+    #[cfg(feature = "pooling-allocator")]
+    pub fn unwrap_static_image(mut self) -> MemoryImageSlot {
+        let mem = self.0.as_any_mut().downcast_mut::<StaticMemory>().unwrap();
+        core::mem::replace(&mut mem.memory_image, MemoryImageSlot::dummy())
+    }
+
+    /// If the [Memory] is a [SharedMemory], unwrap it and return a clone to
+    /// that shared memory.
+    pub fn as_shared_memory(&mut self) -> Option<&mut SharedMemory> {
+        let as_any = self.0.as_any_mut();
+        if let Some(m) = as_any.downcast_mut::<SharedMemory>() {
+            Some(m)
+        } else {
+            None
+        }
+    }
+
+    /// Implementation of `memory.atomic.notify` for all memories.
+    pub fn atomic_notify(&mut self, addr: u64, count: u32) -> Result<u32, Trap> {
+        match self.0.as_any_mut().downcast_mut::<SharedMemory>() {
+            Some(m) => m.atomic_notify(addr, count),
+            None => {
+                validate_atomic_addr(&self.vmmemory(), addr, 4, 4)?;
+                Ok(0)
+            }
+        }
+    }
+
+    /// Implementation of `memory.atomic.wait32` for all memories.
+    pub fn atomic_wait32(
+        &mut self,
+        addr: u64,
+        expected: u32,
+        timeout: Option<Duration>,
+    ) -> Result<WaitResult, Trap> {
+        match self.0.as_any_mut().downcast_mut::<SharedMemory>() {
+            Some(m) => m.atomic_wait32(addr, expected, timeout),
+            None => {
+                validate_atomic_addr(&self.vmmemory(), addr, 4, 4)?;
+                Err(Trap::AtomicWaitNonSharedMemory)
+            }
+        }
+    }
+
+    /// Implementation of `memory.atomic.wait64` for all memories.
+    pub fn atomic_wait64(
+        &mut self,
+        addr: u64,
+        expected: u64,
+        timeout: Option<Duration>,
+    ) -> Result<WaitResult, Trap> {
+        match self.0.as_any_mut().downcast_mut::<SharedMemory>() {
+            Some(m) => m.atomic_wait64(addr, expected, timeout),
+            None => {
+                validate_atomic_addr(&self.vmmemory(), addr, 8, 8)?;
+                Err(Trap::AtomicWaitNonSharedMemory)
+            }
+        }
+    }
+
+    /// Returns the range of bytes that WebAssembly should be able to address in
+    /// this linear memory. Note that this includes guard pages which wasm can
+    /// hit.
+    pub fn wasm_accessible(&self) -> Range<usize> {
+        self.0.wasm_accessible()
+    }
+}
+
+/// In the configurations where bounds checks were elided in JIT code (because
+/// we are using static memories with virtual memory guard pages) this manual
+/// check is here so we don't segfault from Rust. For other configurations,
+/// these checks are required anyways.
+pub fn validate_atomic_addr(
+    def: &VMMemoryDefinition,
+    addr: u64,
+    access_size: u64,
+    access_alignment: u64,
+) -> Result<*mut u8, Trap> {
+    debug_assert!(access_alignment.is_power_of_two());
+    if !(addr % access_alignment == 0) {
+        return Err(Trap::HeapMisaligned);
+    }
+
+    let length = u64::try_from(def.current_length()).unwrap();
+    if !(addr.saturating_add(access_size) < length) {
+        return Err(Trap::MemoryOutOfBounds);
+    }
+
+    Ok(def.base.wrapping_add(addr as usize))
+}
diff --git a/crates/wasmtime/src/runtime/vm/mmap.rs b/crates/wasmtime/src/runtime/vm/mmap.rs
new file mode 100644
index 000000000000..2d955d5ebddc
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/mmap.rs
@@ -0,0 +1,217 @@
+//! Low-level abstraction for allocating and managing zero-filled pages
+//! of memory.
+
+use crate::runtime::vm::sys::mmap;
+use crate::{prelude::*, vm::usize_is_multiple_of_host_page_size};
+use core::ops::Range;
+#[cfg(feature = "std")]
+use std::{fs::File, path::Path, sync::Arc};
+
+/// A simple struct consisting of a page-aligned pointer to page-aligned
+/// and initially-zeroed memory and a length.
+#[derive(Debug)]
+pub struct Mmap {
+    sys: mmap::Mmap,
+    #[cfg(feature = "std")]
+    file: Option<Arc<File>>,
+}
+
+impl Mmap {
+    /// Create a new `Mmap` pointing to at least `size` bytes of page-aligned
+    /// accessible memory.
+    pub fn with_at_least(size: usize) -> Result<Self> {
+        let rounded_size = crate::runtime::vm::round_usize_up_to_host_pages(size)?;
+        Self::accessible_reserved(rounded_size, rounded_size)
+    }
+
+    /// Creates a new `Mmap` by opening the file located at `path` and mapping
+    /// it into memory.
+    ///
+    /// The memory is mapped in read-only mode for the entire file. If portions
+    /// of the file need to be modified then the `region` crate can be use to
+    /// alter permissions of each page.
+    ///
+    /// The memory mapping and the length of the file within the mapping are
+    /// returned.
+    #[cfg(feature = "std")]
+    pub fn from_file(path: &Path) -> Result<Self> {
+        let (sys, file) = mmap::Mmap::from_file(path)?;
+        Ok(Mmap {
+            sys,
+            file: Some(Arc::new(file)),
+        })
+    }
+
+    /// Create a new `Mmap` pointing to `accessible_size` bytes of page-aligned
+    /// accessible memory, within a reserved mapping of `mapping_size` bytes.
+    /// `accessible_size` and `mapping_size` must be native page-size multiples.
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if `accessible_size` is greater than
+    /// `mapping_size` or if either of them are not page-aligned.
+    pub fn accessible_reserved(accessible_size: usize, mapping_size: usize) -> Result<Self> {
+        assert!(accessible_size <= mapping_size);
+        assert!(usize_is_multiple_of_host_page_size(mapping_size));
+        assert!(usize_is_multiple_of_host_page_size(accessible_size));
+
+        if mapping_size == 0 {
+            Ok(Mmap {
+                sys: mmap::Mmap::new_empty(),
+                #[cfg(feature = "std")]
+                file: None,
+            })
+        } else if accessible_size == mapping_size {
+            Ok(Mmap {
+                sys: mmap::Mmap::new(mapping_size)
+                    .context(format!("mmap failed to allocate {mapping_size:#x} bytes"))?,
+                #[cfg(feature = "std")]
+                file: None,
+            })
+        } else {
+            let mut result = Mmap {
+                sys: mmap::Mmap::reserve(mapping_size)
+                    .context(format!("mmap failed to reserve {mapping_size:#x} bytes"))?,
+                #[cfg(feature = "std")]
+                file: None,
+            };
+            if accessible_size > 0 {
+                result.make_accessible(0, accessible_size).context(format!(
+                    "mmap failed to allocate {accessible_size:#x} bytes"
+                ))?;
+            }
+            Ok(result)
+        }
+    }
+
+    /// Make the memory starting at `start` and extending for `len` bytes
+    /// accessible. `start` and `len` must be native page-size multiples and
+    /// describe a range within `self`'s reserved memory.
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if `start` or `len` is not page aligned or if
+    /// either are outside the bounds of this mapping.
+    pub fn make_accessible(&mut self, start: usize, len: usize) -> Result<()> {
+        let page_size = crate::runtime::vm::host_page_size();
+        assert_eq!(start & (page_size - 1), 0);
+        assert_eq!(len & (page_size - 1), 0);
+        assert!(len <= self.len());
+        assert!(start <= self.len() - len);
+
+        self.sys.make_accessible(start, len)
+    }
+
+    /// Return the allocated memory as a slice of u8.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that the range of bytes is accessible to the
+    /// program and additionally has previously been initialized.
+    ///
+    /// # Panics
+    ///
+    /// Panics of the `range` provided is outside of the limits of this mmap.
+    #[inline]
+    pub unsafe fn slice(&self, range: Range<usize>) -> &[u8] {
+        assert!(range.start <= range.end);
+        assert!(range.end <= self.len());
+        core::slice::from_raw_parts(self.as_ptr().add(range.start), range.end - range.start)
+    }
+
+    /// Return the allocated memory as a mutable slice of u8.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that the range of bytes is accessible to the
+    /// program and additionally has previously been initialized.
+    ///
+    /// # Panics
+    ///
+    /// Panics of the `range` provided is outside of the limits of this mmap.
+    pub unsafe fn slice_mut(&mut self, range: Range<usize>) -> &mut [u8] {
+        assert!(range.start <= range.end);
+        assert!(range.end <= self.len());
+        core::slice::from_raw_parts_mut(self.as_mut_ptr().add(range.start), range.end - range.start)
+    }
+
+    /// Return the allocated memory as a pointer to u8.
+    #[inline]
+    pub fn as_ptr(&self) -> *const u8 {
+        self.sys.as_ptr()
+    }
+
+    /// Return the allocated memory as a mutable pointer to u8.
+    #[inline]
+    pub fn as_mut_ptr(&mut self) -> *mut u8 {
+        self.sys.as_mut_ptr()
+    }
+
+    /// Return the length of the allocated memory.
+    ///
+    /// This is the byte length of this entire mapping which includes both
+    /// addressable and non-addressable memory.
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.sys.len()
+    }
+
+    /// Return whether any memory has been allocated or reserved.
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Makes the specified `range` within this `Mmap` to be read/execute.
+    ///
+    /// # Unsafety
+    ///
+    /// This method is unsafe as it's generally not valid to simply make memory
+    /// executable, so it's up to the caller to ensure that everything is in
+    /// order and this doesn't overlap with other memory that should only be
+    /// read or only read/write.
+    ///
+    /// # Panics
+    ///
+    /// Panics of `range` is out-of-bounds or not page-aligned.
+    pub unsafe fn make_executable(
+        &self,
+        range: Range<usize>,
+        enable_branch_protection: bool,
+    ) -> Result<()> {
+        assert!(range.start <= self.len());
+        assert!(range.end <= self.len());
+        assert!(range.start <= range.end);
+        assert!(
+            range.start % crate::runtime::vm::host_page_size() == 0,
+            "changing of protections isn't page-aligned",
+        );
+        self.sys
+            .make_executable(range, enable_branch_protection)
+            .context("failed to make memory executable")
+    }
+
+    /// Makes the specified `range` within this `Mmap` to be readonly.
+    pub unsafe fn make_readonly(&self, range: Range<usize>) -> Result<()> {
+        assert!(range.start <= self.len());
+        assert!(range.end <= self.len());
+        assert!(range.start <= range.end);
+        assert!(
+            range.start % crate::runtime::vm::host_page_size() == 0,
+            "changing of protections isn't page-aligned",
+        );
+        self.sys
+            .make_readonly(range)
+            .context("failed to make memory readonly")
+    }
+
+    /// Returns the underlying file that this mmap is mapping, if present.
+    #[cfg(feature = "std")]
+    pub fn original_file(&self) -> Option<&Arc<File>> {
+        self.file.as_ref()
+    }
+}
+
+fn _assert() {
+    fn _assert_send_sync<T: Send + Sync>() {}
+    _assert_send_sync::<Mmap>();
+}
diff --git a/crates/wasmtime/src/runtime/vm/mmap_vec.rs b/crates/wasmtime/src/runtime/vm/mmap_vec.rs
new file mode 100644
index 000000000000..6c67eadc1aaf
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/mmap_vec.rs
@@ -0,0 +1,159 @@
+use crate::prelude::*;
+use crate::runtime::vm::Mmap;
+use alloc::sync::Arc;
+use core::ops::{Deref, DerefMut, Range};
+#[cfg(feature = "std")]
+use std::{fs::File, path::Path};
+
+/// A type akin to `Vec<u8>`, but backed by `mmap` and able to be split.
+///
+/// This type is a non-growable owned list of bytes. It can be segmented into
+/// disjoint separately owned views akin to the `split_at` method on slices in
+/// Rust. An `MmapVec` is backed by an OS-level memory allocation and is not
+/// suitable for lots of small allocation (since it works at the page
+/// granularity).
+///
+/// An `MmapVec` is an owned value which means that owners have the ability to
+/// get exclusive access to the underlying bytes, enabling mutation.
+pub struct MmapVec {
+    mmap: Arc<Mmap>,
+    range: Range<usize>,
+}
+
+impl MmapVec {
+    /// Consumes an existing `mmap` and wraps it up into an `MmapVec`.
+    ///
+    /// The returned `MmapVec` will have the `size` specified, which can be
+    /// smaller than the region mapped by the `Mmap`. The returned `MmapVec`
+    /// will only have at most `size` bytes accessible.
+    pub fn new(mmap: Mmap, size: usize) -> MmapVec {
+        assert!(size <= mmap.len());
+        MmapVec {
+            mmap: Arc::new(mmap),
+            range: 0..size,
+        }
+    }
+
+    /// Creates a new zero-initialized `MmapVec` with the given `size`.
+    ///
+    /// This commit will return a new `MmapVec` suitably sized to hold `size`
+    /// bytes. All bytes will be initialized to zero since this is a fresh OS
+    /// page allocation.
+    pub fn with_capacity(size: usize) -> Result<MmapVec> {
+        Ok(MmapVec::new(Mmap::with_at_least(size)?, size))
+    }
+
+    /// Creates a new `MmapVec` from the contents of an existing `slice`.
+    ///
+    /// A new `MmapVec` is allocated to hold the contents of `slice` and then
+    /// `slice` is copied into the new mmap. It's recommended to avoid this
+    /// method if possible to avoid the need to copy data around.
+    pub fn from_slice(slice: &[u8]) -> Result<MmapVec> {
+        let mut result = MmapVec::with_capacity(slice.len())?;
+        result.copy_from_slice(slice);
+        Ok(result)
+    }
+
+    /// Creates a new `MmapVec` which is the `path` specified mmap'd into
+    /// memory.
+    ///
+    /// This function will attempt to open the file located at `path` and will
+    /// then use that file to learn about its size and map the full contents
+    /// into memory. This will return an error if the file doesn't exist or if
+    /// it's too large to be fully mapped into memory.
+    #[cfg(feature = "std")]
+    pub fn from_file(path: &Path) -> Result<MmapVec> {
+        let mmap = Mmap::from_file(path)
+            .with_context(|| format!("failed to create mmap for file: {}", path.display()))?;
+        let len = mmap.len();
+        Ok(MmapVec::new(mmap, len))
+    }
+
+    /// Makes the specified `range` within this `mmap` to be read/execute.
+    pub unsafe fn make_executable(
+        &self,
+        range: Range<usize>,
+        enable_branch_protection: bool,
+    ) -> Result<()> {
+        assert!(range.start <= range.end);
+        assert!(range.end <= self.range.len());
+        self.mmap.make_executable(
+            range.start + self.range.start..range.end + self.range.start,
+            enable_branch_protection,
+        )
+    }
+
+    /// Makes the specified `range` within this `mmap` to be read-only.
+    pub unsafe fn make_readonly(&self, range: Range<usize>) -> Result<()> {
+        assert!(range.start <= range.end);
+        assert!(range.end <= self.range.len());
+        self.mmap
+            .make_readonly(range.start + self.range.start..range.end + self.range.start)
+    }
+
+    /// Returns the underlying file that this mmap is mapping, if present.
+    #[cfg(feature = "std")]
+    pub fn original_file(&self) -> Option<&Arc<File>> {
+        self.mmap.original_file()
+    }
+
+    /// Returns the offset within the original mmap that this `MmapVec` is
+    /// created from.
+    pub fn original_offset(&self) -> usize {
+        self.range.start
+    }
+
+    /// Returns the bounds, in host memory, of where this mmap
+    /// image resides.
+    pub fn image_range(&self) -> Range<*const u8> {
+        let base = self.as_ptr();
+        let len = self.len();
+        base..base.wrapping_add(len)
+    }
+}
+
+impl Deref for MmapVec {
+    type Target = [u8];
+
+    #[inline]
+    fn deref(&self) -> &[u8] {
+        // SAFETY: this mmap owns its own range of the underlying mmap so it
+        // should be all good-to-read.
+        unsafe { self.mmap.slice(self.range.clone()) }
+    }
+}
+
+impl DerefMut for MmapVec {
+    fn deref_mut(&mut self) -> &mut [u8] {
+        // SAFETY: The underlying mmap is protected behind an `Arc` which means
+        // there there can be many references to it. We are guaranteed, though,
+        // that each reference to the underlying `mmap` has a disjoint `range`
+        // listed that it can access. This means that despite having shared
+        // access to the mmap itself we have exclusive ownership of the bytes
+        // specified in `self.range`. This should allow us to safely hand out
+        // mutable access to these bytes if so desired.
+        unsafe {
+            let slice =
+                core::slice::from_raw_parts_mut(self.mmap.as_ptr().cast_mut(), self.mmap.len());
+            &mut slice[self.range.clone()]
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::MmapVec;
+
+    #[test]
+    fn smoke() {
+        let mut mmap = MmapVec::with_capacity(10).unwrap();
+        assert_eq!(mmap.len(), 10);
+        assert_eq!(&mmap[..], &[0; 10]);
+
+        mmap[0] = 1;
+        mmap[2] = 3;
+        assert!(mmap.get(10).is_none());
+        assert_eq!(mmap[0], 1);
+        assert_eq!(mmap[2], 3);
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/module_id.rs b/crates/wasmtime/src/runtime/vm/module_id.rs
new file mode 100644
index 000000000000..be5bc513ecae
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/module_id.rs
@@ -0,0 +1,19 @@
+//! Unique IDs for modules in the runtime.
+
+use core::num::NonZeroU64;
+
+/// A unique identifier (within an engine or similar) for a compiled
+/// module.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct CompiledModuleId(NonZeroU64);
+
+impl CompiledModuleId {
+    /// Allocates a new ID which will be unique within this process.
+    pub fn new() -> Self {
+        // As an implementation detail this is implemented on the same
+        // allocator as stores. It's ok if there are "holes" in the store id
+        // space as it's not required to be compact, it's just used for
+        // uniqueness.
+        CompiledModuleId(crate::store::StoreId::allocate().as_raw())
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/mpk/disabled.rs b/crates/wasmtime/src/runtime/vm/mpk/disabled.rs
new file mode 100644
index 000000000000..52370215fbf1
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/mpk/disabled.rs
@@ -0,0 +1,43 @@
+//! Noop implementations of MPK primitives for environments that do not support
+//! the feature.
+
+#![allow(missing_docs)]
+
+use crate::prelude::*;
+
+pub fn is_supported() -> bool {
+    false
+}
+pub fn keys(_: usize) -> &'static [ProtectionKey] {
+    &[]
+}
+pub fn allow(_: ProtectionMask) {}
+
+pub fn current_mask() -> ProtectionMask {
+    ProtectionMask
+}
+
+#[derive(Clone, Copy, Debug)]
+pub enum ProtectionKey {}
+impl ProtectionKey {
+    pub fn protect(&self, _: &mut [u8]) -> Result<()> {
+        match *self {}
+    }
+    pub fn as_stripe(&self) -> usize {
+        match *self {}
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct ProtectionMask;
+impl ProtectionMask {
+    pub fn all() -> Self {
+        Self
+    }
+    pub fn zero() -> Self {
+        Self
+    }
+    pub fn or(self, _: ProtectionKey) -> Self {
+        Self
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/mpk/enabled.rs b/crates/wasmtime/src/runtime/vm/mpk/enabled.rs
new file mode 100644
index 000000000000..21fc058b69fc
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/mpk/enabled.rs
@@ -0,0 +1,213 @@
+//!
+
+use super::{pkru, sys};
+use crate::prelude::*;
+use std::sync::OnceLock;
+
+/// Check if the MPK feature is supported.
+pub fn is_supported() -> bool {
+    cfg!(target_os = "linux") && cfg!(target_arch = "x86_64") && pkru::has_cpuid_bit_set()
+}
+
+/// Allocate up to `max` protection keys.
+///
+/// This asks the kernel for all available keys up to `max` in a thread-safe way
+/// (we can expect 1-15; 0 is kernel-reserved). This avoids interference when
+/// multiple threads try to allocate keys at the same time (e.g., during
+/// testing). It also ensures that a single copy of the keys is reserved for the
+/// lifetime of the process. Because of this, `max` is only a hint to
+/// allocation: it only is effective on the first invocation of this function.
+///
+/// TODO: this is not the best-possible design. This creates global state that
+/// would prevent any other code in the process from using protection keys; the
+/// `KEYS` are never deallocated from the system with `pkey_dealloc`.
+pub fn keys(max: usize) -> &'static [ProtectionKey] {
+    let keys = KEYS.get_or_init(|| {
+        let mut allocated = vec![];
+        if is_supported() {
+            while allocated.len() < max {
+                if let Ok(key_id) = sys::pkey_alloc(0, 0) {
+                    debug_assert!(key_id < 16);
+                    // UNSAFETY: here we unsafely assume that the
+                    // system-allocated pkey will exist forever.
+                    allocated.push(ProtectionKey {
+                        id: key_id,
+                        stripe: allocated.len().try_into().unwrap(),
+                    });
+                } else {
+                    break;
+                }
+            }
+        }
+        allocated
+    });
+    &keys[..keys.len().min(max)]
+}
+static KEYS: OnceLock<Vec<ProtectionKey>> = OnceLock::new();
+
+/// Only allow access to pages marked by the keys set in `mask`.
+///
+/// Any accesses to pages marked by another key will result in a `SIGSEGV`
+/// fault.
+pub fn allow(mask: ProtectionMask) {
+    let previous = if log::log_enabled!(log::Level::Trace) {
+        pkru::read()
+    } else {
+        0
+    };
+    pkru::write(mask.0);
+    log::trace!("PKRU change: {:#034b} => {:#034b}", previous, pkru::read());
+}
+
+/// Retrieve the current protection mask.
+pub fn current_mask() -> ProtectionMask {
+    ProtectionMask(pkru::read())
+}
+
+/// An MPK protection key.
+///
+/// The expected usage is:
+/// - receive system-allocated keys from [`keys`]
+/// - mark some regions of memory as accessible with [`ProtectionKey::protect`]
+/// - [`allow`] or disallow access to the memory regions using a
+///   [`ProtectionMask`]; any accesses to unmarked pages result in a fault
+/// - drop the key
+#[derive(Clone, Copy, Debug)]
+pub struct ProtectionKey {
+    id: u32,
+    stripe: u32,
+}
+
+impl ProtectionKey {
+    /// Mark a page as protected by this [`ProtectionKey`].
+    ///
+    /// This "colors" the pages of `region` via a kernel `pkey_mprotect` call to
+    /// only allow reads and writes when this [`ProtectionKey`] is activated
+    /// (see [`allow`]).
+    ///
+    /// # Errors
+    ///
+    /// This will fail if the region is not page aligned or for some unknown
+    /// kernel reason.
+    pub fn protect(&self, region: &mut [u8]) -> Result<()> {
+        let addr = region.as_mut_ptr() as usize;
+        let len = region.len();
+        let prot = sys::PROT_NONE;
+        sys::pkey_mprotect(addr, len, prot, self.id).with_context(|| {
+            format!(
+                "failed to mark region with pkey (addr = {addr:#x}, len = {len}, prot = {prot:#b})"
+            )
+        })
+    }
+
+    /// Convert the [`ProtectionKey`] to its 0-based index; this is useful for
+    /// determining which allocation "stripe" a key belongs to.
+    ///
+    /// This function assumes that the kernel has allocated key 0 for itself.
+    pub fn as_stripe(&self) -> usize {
+        self.stripe as usize
+    }
+}
+
+/// A bit field indicating which protection keys should be allowed and disabled.
+///
+/// The internal representation makes it easy to use [`ProtectionMask`] directly
+/// with the PKRU register. When bits `n` and `n+1` are set, it means the
+/// protection key is *not* allowed (see the PKRU write and access disabled
+/// bits).
+pub struct ProtectionMask(u32);
+impl ProtectionMask {
+    /// Allow access from all protection keys.
+    #[inline]
+    pub fn all() -> Self {
+        Self(pkru::ALLOW_ACCESS)
+    }
+
+    /// Only allow access to memory protected with protection key 0; note that
+    /// this does not mean "none" but rather allows access from the default
+    /// kernel protection key.
+    #[inline]
+    pub fn zero() -> Self {
+        Self(pkru::DISABLE_ACCESS ^ 0b11)
+    }
+
+    /// Include `pkey` as another allowed protection key in the mask.
+    #[inline]
+    pub fn or(self, pkey: ProtectionKey) -> Self {
+        let mask = pkru::DISABLE_ACCESS ^ 0b11 << (pkey.id * 2);
+        Self(self.0 & mask)
+    }
+}
+
+/// Helper macro for skipping tests on systems that do not have MPK enabled
+/// (e.g., older architecture, disabled by kernel, etc.)
+#[cfg(test)]
+macro_rules! skip_if_mpk_unavailable {
+    () => {
+        if !crate::runtime::vm::mpk::is_supported() {
+            println!("> mpk is not supported: ignoring test");
+            return;
+        }
+    };
+}
+/// Necessary for inter-module access.
+#[cfg(test)]
+pub(crate) use skip_if_mpk_unavailable;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn check_is_supported() {
+        println!("is pku supported = {}", is_supported());
+        if std::env::var("WASMTIME_TEST_FORCE_MPK").is_ok() {
+            assert!(is_supported());
+        }
+    }
+
+    #[test]
+    fn check_initialized_keys() {
+        if is_supported() {
+            assert!(!keys(15).is_empty())
+        }
+    }
+
+    #[test]
+    fn check_invalid_mark() {
+        skip_if_mpk_unavailable!();
+        let pkey = keys(15)[0];
+        let unaligned_region = unsafe {
+            let addr = 1 as *mut u8; // this is not page-aligned!
+            let len = 1;
+            std::slice::from_raw_parts_mut(addr, len)
+        };
+        let result = pkey.protect(unaligned_region);
+        assert!(result.is_err());
+        assert_eq!(
+            result.unwrap_err().to_string(),
+            "failed to mark region with pkey (addr = 0x1, len = 1, prot = 0b0)"
+        );
+    }
+
+    #[test]
+    fn check_masking() {
+        skip_if_mpk_unavailable!();
+        let original = pkru::read();
+
+        allow(ProtectionMask::all());
+        assert_eq!(0, pkru::read());
+
+        allow(ProtectionMask::all().or(ProtectionKey { id: 5, stripe: 0 }));
+        assert_eq!(0, pkru::read());
+
+        allow(ProtectionMask::zero());
+        assert_eq!(0b11111111_11111111_11111111_11111100, pkru::read());
+
+        allow(ProtectionMask::zero().or(ProtectionKey { id: 5, stripe: 0 }));
+        assert_eq!(0b11111111_11111111_11110011_11111100, pkru::read());
+
+        // Reset the PKRU state to what we originally observed.
+        pkru::write(original);
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/mpk/mod.rs b/crates/wasmtime/src/runtime/vm/mpk/mod.rs
new file mode 100644
index 000000000000..844c35b4378e
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/mpk/mod.rs
@@ -0,0 +1,59 @@
+//! Memory Protection Keys (MPK) implementation for use in striped memory
+//! allocation.
+//!
+//! MPK is an x86 feature available on relatively recent versions of Intel and
+//! AMD CPUs. In Linux, this feature is named `pku` (protection keys userspace)
+//! and consists of three new system calls: `pkey_alloc`, `pkey_free`, and
+//! `pkey_mprotect` (see the [Linux documentation]). This crate provides an
+//! abstraction, [`ProtectionKey`], that the [pooling allocator] applies to
+//! contiguous memory allocations, allowing it to avoid guard pages in some
+//! cases and more efficiently use memory. This technique was first presented in
+//! a 2022 paper: [Segue and ColorGuard: Optimizing SFI Performance and
+//! Scalability on Modern x86][colorguard].
+//!
+//! [pooling allocator]: crate::runtime::vm::PoolingInstanceAllocator
+//! [Linux documentation]:
+//!     https://www.kernel.org/doc/html/latest/core-api/protection-keys.html
+//! [colorguard]: https://plas2022.github.io/files/pdf/SegueColorGuard.pdf
+//!
+//! On x86_64 Linux systems, this module implements the various parts necessary
+//! to use MPK in Wasmtime:
+//! - [`is_supported`] indicates whether the feature is available at runtime
+//! - [`ProtectionKey`] provides access to the kernel-allocated protection keys
+//!   (see [`keys`])
+//! - [`allow`] sets the CPU state to prevent access to regions outside the
+//!   [`ProtectionMask`]
+//! - the `sys` module bridges the gap to Linux's `pkey_*` system calls
+//! - the `pkru` module controls the x86 `PKRU` register (and other CPU state)
+//!
+//! On any other kind of machine, this module exposes noop implementations of
+//! the public interface.
+
+cfg_if::cfg_if! {
+    if #[cfg(all(
+        target_arch = "x86_64",
+        target_os = "linux",
+        feature = "memory-protection-keys",
+        not(miri),
+    ))] {
+        mod enabled;
+        mod pkru;
+        mod sys;
+        pub use enabled::{allow, current_mask, is_supported, keys, ProtectionKey, ProtectionMask};
+    } else {
+        mod disabled;
+        pub use disabled::{allow, current_mask, is_supported, keys, ProtectionKey, ProtectionMask};
+    }
+}
+
+/// Describe the tri-state configuration of memory protection keys (MPK).
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
+pub enum MpkEnabled {
+    /// Use MPK if supported by the current system; fall back to guard regions
+    /// otherwise.
+    Auto,
+    /// Use MPK or fail if not supported.
+    Enable,
+    /// Do not use MPK.
+    Disable,
+}
diff --git a/crates/wasmtime/src/runtime/vm/mpk/pkru.rs b/crates/wasmtime/src/runtime/vm/mpk/pkru.rs
new file mode 100644
index 000000000000..43751d9cd8ee
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/mpk/pkru.rs
@@ -0,0 +1,104 @@
+//! Control access to the x86 `PKRU` register.
+//!
+//! As documented in the Intel Software Development Manual, vol 3a, section 2.7,
+//! the 32 bits of the `PKRU` register laid out as follows (note the
+//! little-endianness):
+//!
+//! ```text
+//! ┌───┬───┬───┬───┬───┬───┐
+//! │...│AD2│WD1│AD1│WD0│AD0│
+//! └───┴───┴───┴───┴───┴───┘
+//! ```
+//!
+//! - `ADn = 1` means "access disable key `n`"--no reads or writes allowed to
+//!   pages marked with key `n`.
+//! - `WDn = 1` means "write disable key `n`"--only reads are prevented to pages
+//!   marked with key `n`
+//! - it is unclear what it means to have both `ADn` and `WDn` set
+//!
+//! Note that this only handles the user-mode `PKRU` register; there is an
+//! equivalent supervisor-mode MSR, `IA32_PKRS`.
+
+use core::arch::asm;
+
+/// This `PKRU` register mask allows access to any pages marked with any
+/// key--in other words, reading and writing is permitted to all pages.
+pub const ALLOW_ACCESS: u32 = 0;
+
+/// This `PKRU` register mask disables access to any page marked with any
+/// key--in other words, no reading or writing to all pages.
+pub const DISABLE_ACCESS: u32 = 0b11111111_11111111_11111111_11111111;
+
+/// Read the value of the `PKRU` register.
+#[inline]
+pub fn read() -> u32 {
+    // ECX must be 0 to prevent a general protection exception (#GP).
+    let ecx: u32 = 0;
+    let pkru: u32;
+    unsafe {
+        asm!("rdpkru", in("ecx") ecx, out("eax") pkru, out("edx") _,
+            options(nomem, nostack, preserves_flags));
+    }
+    return pkru;
+}
+
+/// Write a value to the `PKRU` register.
+#[inline]
+pub fn write(pkru: u32) {
+    // Both ECX and EDX must be 0 to prevent a general protection exception
+    // (#GP).
+    let ecx: u32 = 0;
+    let edx: u32 = 0;
+    unsafe {
+        asm!("wrpkru", in("eax") pkru, in("ecx") ecx, in("edx") edx,
+            options(nomem, nostack, preserves_flags));
+    }
+}
+
+/// Check the `ECX.PKU` flag (bit 3, zero-based) of the `07h` `CPUID` leaf; see
+/// the Intel Software Development Manual, vol 3a, section 2.7. This flag is
+/// only set on Intel CPUs, so this function also checks the `CPUID` vendor
+/// string.
+pub fn has_cpuid_bit_set() -> bool {
+    let result = unsafe { core::arch::x86_64::__cpuid(0x07) };
+    is_intel_cpu() && (result.ecx & 0b1000) != 0
+}
+
+/// Check the `CPUID` vendor string for `GenuineIntel`; see the Intel Software
+/// Development Manual, vol 2a, `CPUID` description.
+pub fn is_intel_cpu() -> bool {
+    // To read the CPU vendor string, we pass 0 in EAX and read 12 ASCII bytes
+    // from EBX, EDX, and ECX (in that order).
+    let result = unsafe { core::arch::x86_64::__cpuid(0) };
+    // Then we check if the vendor string matches "GenuineIntel".
+    result.ebx == u32::from_le_bytes(*b"Genu")
+        && result.edx == u32::from_le_bytes(*b"ineI")
+        && result.ecx == u32::from_le_bytes(*b"ntel")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::runtime::vm::mpk::enabled::skip_if_mpk_unavailable;
+
+    #[test]
+    #[ignore = "cannot be run with other tests that munge the PKRU register"]
+    fn check_read() {
+        skip_if_mpk_unavailable!();
+        assert_eq!(read(), DISABLE_ACCESS ^ 1);
+        // By default, the Linux kernel only allows a process to access key 0,
+        // the default kernel key.
+    }
+
+    #[test]
+    fn check_roundtrip() {
+        skip_if_mpk_unavailable!();
+        let pkru = read();
+        // Allow access to pages marked with any key.
+        write(ALLOW_ACCESS);
+        assert_eq!(read(), ALLOW_ACCESS);
+        // Restore the original value.
+        write(pkru);
+        assert_eq!(read(), pkru);
+    }
+}
diff --git a/crates/runtime/src/mpk/sys.rs b/crates/wasmtime/src/runtime/vm/mpk/sys.rs
similarity index 89%
rename from crates/runtime/src/mpk/sys.rs
rename to crates/wasmtime/src/runtime/vm/mpk/sys.rs
index fe68decce8c2..002163c47ff8 100644
--- a/crates/runtime/src/mpk/sys.rs
+++ b/crates/wasmtime/src/runtime/vm/mpk/sys.rs
@@ -9,17 +9,14 @@
 //! [`pkey_mprotect`]: https://man7.org/linux/man-pages/man2/pkey_mprotect.2.html
 //! [`pkeys`]: https://man7.org/linux/man-pages/man7/pkeys.7.html
 
-use crate::page_size;
-use anyhow::Result;
+use crate::prelude::*;
+use crate::runtime::vm::host_page_size;
 use std::io::Error;
 
-/// Protection mask allowing reads of pkey-protected memory (see `prot` in
-/// [`pkey_mprotect`]).
-pub const PROT_READ: u32 = libc::PROT_READ as u32; // == 0b0001.
-
-/// Protection mask allowing writes of pkey-protected memory (see `prot` in
-/// [`pkey_mprotect`]).
-pub const PROT_WRITE: u32 = libc::PROT_WRITE as u32; // == 0b0010;
+/// Protection mask disallowing reads and writes of pkey-protected memory (see
+/// `prot` in [`pkey_mprotect`]); in Wasmtime we expect all MPK-protected memory
+/// to start as `PROT_NONE`.
+pub const PROT_NONE: u32 = libc::PROT_NONE as u32; // == 0b0000;
 
 /// Allocate a new protection key in the Linux kernel ([docs]); returns the
 /// key ID.
@@ -59,7 +56,7 @@ pub fn pkey_free(key: u32) -> Result<()> {
 ///
 /// [docs]: https://man7.org/linux/man-pages/man2/pkey_mprotect.2.html
 pub fn pkey_mprotect(addr: usize, len: usize, prot: u32, key: u32) -> Result<()> {
-    let page_size = page_size();
+    let page_size = host_page_size();
     if addr % page_size != 0 {
         log::warn!(
             "memory must be page-aligned for MPK (addr = {addr:#x}, page size = {page_size}"
diff --git a/crates/wasmtime/src/runtime/vm/send_sync_ptr.rs b/crates/wasmtime/src/runtime/vm/send_sync_ptr.rs
new file mode 100644
index 000000000000..f2bb45a7a4f8
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/send_sync_ptr.rs
@@ -0,0 +1,106 @@
+use core::fmt;
+use core::hash::{Hash, Hasher};
+use core::ptr::{self, NonNull};
+
+/// A helper type in Wasmtime to store a raw pointer to `T` while automatically
+/// inferring the `Send` and `Sync` traits for the container based on the
+/// properties of `T`.
+#[repr(transparent)]
+pub struct SendSyncPtr<T: ?Sized>(NonNull<T>);
+
+unsafe impl<T: Send + ?Sized> Send for SendSyncPtr<T> {}
+unsafe impl<T: Sync + ?Sized> Sync for SendSyncPtr<T> {}
+
+impl<T: ?Sized> SendSyncPtr<T> {
+    /// Creates a new pointer wrapping the non-nullable pointer provided.
+    #[inline]
+    pub fn new(ptr: NonNull<T>) -> SendSyncPtr<T> {
+        SendSyncPtr(ptr)
+    }
+
+    /// Returns the underlying raw pointer.
+    #[inline]
+    pub fn as_ptr(&self) -> *mut T {
+        self.0.as_ptr()
+    }
+
+    /// Unsafely assert that this is a pointer to valid contents and it's also
+    /// valid to get a shared reference to it at this time.
+    #[inline]
+    pub unsafe fn as_ref<'a>(&self) -> &'a T {
+        self.0.as_ref()
+    }
+
+    /// Unsafely assert that this is a pointer to valid contents and it's also
+    /// valid to get a mutable reference to it at this time.
+    #[inline]
+    pub unsafe fn as_mut<'a>(&mut self) -> &'a mut T {
+        self.0.as_mut()
+    }
+
+    /// Returns the underlying `NonNull<T>` wrapper.
+    #[inline]
+    pub fn as_non_null(&self) -> NonNull<T> {
+        self.0
+    }
+
+    /// Cast this to a pointer to a `U`.
+    #[inline]
+    pub fn cast<U>(&self) -> SendSyncPtr<U> {
+        SendSyncPtr(self.0.cast::<U>())
+    }
+}
+
+impl<T> SendSyncPtr<[T]> {
+    /// Returns the slice's length component of the pointer.
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+}
+
+impl<T: ?Sized, U> From<U> for SendSyncPtr<T>
+where
+    U: Into<NonNull<T>>,
+{
+    #[inline]
+    fn from(ptr: U) -> SendSyncPtr<T> {
+        SendSyncPtr::new(ptr.into())
+    }
+}
+
+impl<T: ?Sized> fmt::Debug for SendSyncPtr<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.as_ptr().fmt(f)
+    }
+}
+
+impl<T: ?Sized> fmt::Pointer for SendSyncPtr<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.as_ptr().fmt(f)
+    }
+}
+
+impl<T: ?Sized> Clone for SendSyncPtr<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<T: ?Sized> Copy for SendSyncPtr<T> {}
+
+impl<T: ?Sized> PartialEq for SendSyncPtr<T> {
+    #[inline]
+    fn eq(&self, other: &SendSyncPtr<T>) -> bool {
+        ptr::eq(self.0.as_ptr(), other.0.as_ptr())
+    }
+}
+
+impl<T: ?Sized> Eq for SendSyncPtr<T> {}
+
+impl<T: ?Sized> Hash for SendSyncPtr<T> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.as_ptr().hash(state);
+    }
+}
diff --git a/crates/runtime/src/store_box.rs b/crates/wasmtime/src/runtime/vm/store_box.rs
similarity index 97%
rename from crates/runtime/src/store_box.rs
rename to crates/wasmtime/src/runtime/vm/store_box.rs
index 00929e540a65..21ac0cdfa14e 100644
--- a/crates/runtime/src/store_box.rs
+++ b/crates/wasmtime/src/runtime/vm/store_box.rs
@@ -1,3 +1,5 @@
+use crate::prelude::*;
+
 /// A `Box<T>` lookalike for memory that's stored in a `Store<T>`
 ///
 /// This is intended to be quite similar to a `Box<T>` except without the
diff --git a/crates/wasmtime/src/runtime/vm/sys/custom/capi.rs b/crates/wasmtime/src/runtime/vm/sys/custom/capi.rs
new file mode 100644
index 000000000000..b63280fa5a51
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/sys/custom/capi.rs
@@ -0,0 +1,200 @@
+#![allow(non_camel_case_types)]
+
+// Flags to either `wasmtime_mmap_{new,remap}` or `wasmtime_mprotect`.
+
+/// Indicates that the memory region should be readable.
+pub const WASMTIME_PROT_READ: u32 = 1 << 0;
+/// Indicates that the memory region should be writable.
+pub const WASMTIME_PROT_WRITE: u32 = 1 << 1;
+/// Indicates that the memory region should be executable.
+pub const WASMTIME_PROT_EXEC: u32 = 1 << 2;
+
+pub use WASMTIME_PROT_EXEC as PROT_EXEC;
+pub use WASMTIME_PROT_READ as PROT_READ;
+pub use WASMTIME_PROT_WRITE as PROT_WRITE;
+
+/// Handler function for traps in Wasmtime passed to `wasmtime_init_traps`.
+///
+/// This function is invoked whenever a trap is caught by the system. For
+/// example this would be invoked during a signal handler on Linux. This
+/// function is passed a number of parameters indicating information about the
+/// trap:
+///
+/// * `ip` - the instruction pointer at the time of the trap.
+/// * `fp` - the frame pointer register's value at the time of the trap.
+/// * `has_faulting_addr` - whether this trap is associated with an access
+///   violation (e.g. a segfault) meaning memory was accessed when it shouldn't
+///   be. If this is `true` then the next parameter is filled in.
+/// * `faulting_addr` - if `has_faulting_addr` is true then this is the address
+///   that was attempted to be accessed. Otherwise this value is not used.
+///
+/// If this function returns then the trap was not handled by Wasmtime. This
+/// means that it's left up to the embedder how to deal with the trap/signal
+/// depending on its default behavior. This could mean forwarding to a
+/// non-Wasmtime handler, aborting the process, logging then crashing, etc. The
+/// meaning of a trap that's not handled by Wasmtime depends on the context in
+/// which the trap was generated.
+///
+/// When this function does not return it's because `wasmtime_longjmp` is
+/// used to handle a Wasm-based trap.
+pub type wasmtime_trap_handler_t =
+    extern "C" fn(ip: usize, fp: usize, has_faulting_addr: bool, faulting_addr: usize);
+
+/// Abstract pointer type used in the `wasmtime_memory_image_*` APIs which
+/// is defined by the embedder.
+pub enum wasmtime_memory_image {}
+
+extern "C" {
+    /// Creates a new virtual memory mapping of the `size` specified with
+    /// protection bits specified in `prot_flags`.
+    ///
+    /// Memory can be lazily committed.
+    ///
+    /// Stores the base pointer of the new mapping in `ret` on success.
+    ///
+    /// Returns 0 on success and an error code on failure.
+    ///
+    /// Similar to `mmap(0, size, prot_flags, MAP_PRIVATE, 0, -1)` on Linux.
+    pub fn wasmtime_mmap_new(size: usize, prot_flags: u32, ret: &mut *mut u8) -> i32;
+
+    /// Remaps the virtual memory starting at `addr` going for `size` bytes to
+    /// the protections specified with a new blank mapping.
+    ///
+    /// This will unmap any prior mappings and decommit them. New mappings for
+    /// anonymous memory are used to replace these mappings and the new area
+    /// should have the protection specified by `prot_flags`.
+    ///
+    /// Returns 0 on success and an error code on failure.
+    ///
+    /// Similar to `mmap(addr, size, prot_flags, MAP_PRIVATE | MAP_FIXED, 0, -1)` on Linux.
+    pub fn wasmtime_mmap_remap(addr: *mut u8, size: usize, prot_flags: u32) -> i32;
+
+    /// Unmaps memory at the specified `ptr` for `size` bytes.
+    ///
+    /// The memory should be discarded and decommitted and should generate a
+    /// segfault if accessed after this function call.
+    ///
+    /// Returns 0 on success and an error code on failure.
+    ///
+    /// Similar to `munmap` on Linux.
+    pub fn wasmtime_munmap(ptr: *mut u8, size: usize) -> i32;
+
+    /// Configures the protections associated with a region of virtual memory
+    /// starting at `ptr` and going to `size`.
+    ///
+    /// Returns 0 on success and an error code on failure.
+    ///
+    /// Similar to `mprotect` on Linux.
+    pub fn wasmtime_mprotect(ptr: *mut u8, size: usize, prot_flags: u32) -> i32;
+
+    /// Returns the page size, in bytes, of the current system.
+    pub fn wasmtime_page_size() -> usize;
+
+    /// Used to setup a frame on the stack to longjmp back to in the future.
+    ///
+    /// This function is used for handling traps in WebAssembly and is paried
+    /// with `wasmtime_longjmp`.
+    ///
+    /// * `jmp_buf` - this argument is filled in with a pointer which if used
+    ///   will be passed to `wasmtime_longjmp` later on by the runtime.
+    /// * `callback` - this callback should be invoked after `jmp_buf` is
+    ///   configured.
+    /// * `payload` and `callee` - the two arguments to pass to `callback`.
+    ///
+    /// Returns 0 if `wasmtime_longjmp` was used to return to this function.
+    /// Returns 1 if `wasmtime_longjmp` was not called and `callback` returned.
+    pub fn wasmtime_setjmp(
+        jmp_buf: *mut *const u8,
+        callback: extern "C" fn(*mut u8, *mut u8),
+        payload: *mut u8,
+        callee: *mut u8,
+    ) -> i32;
+
+    /// Paired with `wasmtime_setjmp` this is used to jump back to the `setjmp`
+    /// point.
+    ///
+    /// The argument here was originally passed to `wasmtime_setjmp` through its
+    /// out-param.
+    ///
+    /// This function cannot return.
+    ///
+    /// This function may be invoked from the `wasmtime_trap_handler_t`
+    /// configured by `wasmtime_init_traps`.
+    pub fn wasmtime_longjmp(jmp_buf: *const u8) -> !;
+
+    /// Initializes trap-handling logic for this platform.
+    ///
+    /// Wasmtime's implementation of WebAssembly relies on the ability to catch
+    /// signals/traps/etc. For example divide-by-zero may raise a machine
+    /// exception. Out-of-bounds memory accesses may also raise a machine
+    /// exception. This function is used to initialize trap handling.
+    ///
+    /// The `handler` provided is a function pointer to invoke whenever a trap
+    /// is encountered. The `handler` is invoked whenever a trap is caught by
+    /// the system.
+    ///
+    /// Returns 0 on success and an error code on failure.
+    pub fn wasmtime_init_traps(handler: wasmtime_trap_handler_t) -> i32;
+
+    /// Attempts to create a new in-memory image of the `ptr`/`len` combo which
+    /// can be mapped to virtual addresses in the future.
+    ///
+    /// On success the returned `wasmtime_memory_image` pointer is stored into `ret`.
+    /// This value stored can be `NULL` to indicate that an image cannot be
+    /// created but no failure occurred. The structure otherwise will later be
+    /// deallocated with `wasmtime_memory_image_free` and
+    /// `wasmtime_memory_image_map_at` will be used to map the image into new
+    /// regions of the address space.
+    ///
+    /// The `ptr` and `len` arguments are only valid for this function call, if
+    /// the image needs to refer to them in the future then it must make a copy.
+    ///
+    /// Both `ptr` and `len` are guaranteed to be page-aligned.
+    ///
+    /// Returns 0 on success and an error code on failure. Note that storing
+    /// `NULL` into `ret` is not considered a failure, and failure is used to
+    /// indicate that something fatal has happened and Wasmtime will propagate
+    /// the error upwards.
+    pub fn wasmtime_memory_image_new(
+        ptr: *const u8,
+        len: usize,
+        ret: &mut *mut wasmtime_memory_image,
+    ) -> i32;
+
+    /// Maps the `image` provided to the virtual address at `addr` and `len`.
+    ///
+    /// This semantically should make it such that `addr` and `len` looks the
+    /// same as the contents of what the memory image was first created with.
+    /// The mappings of `addr` should be private and changes do not reflect back
+    /// to `wasmtime_memory_image`.
+    ///
+    /// In effect this is to create a copy-on-write mapping at `addr`/`len`
+    /// pointing back to the memory used by the image originally.
+    ///
+    /// Note that the memory region will be unmapped with `wasmtime_munmap` in
+    /// the future.
+    ///
+    /// Aborts the process on failure.
+    pub fn wasmtime_memory_image_map_at(
+        image: *mut wasmtime_memory_image,
+        addr: *mut u8,
+        len: usize,
+    ) -> i32;
+
+    /// Deallocates the provided `wasmtime_memory_image`.
+    ///
+    /// Note that mappings created from this image are not guaranteed to be
+    /// deallocated and/or unmapped before this is called.
+    pub fn wasmtime_memory_image_free(image: *mut wasmtime_memory_image);
+
+    /// Wasmtime requires a single pointer's space of TLS to be used at runtime,
+    /// and this function returns the current value of the TLS variable.
+    ///
+    /// This value should default to `NULL`.
+    pub fn wasmtime_tls_get() -> *mut u8;
+
+    /// Sets the current TLS value for Wasmtime to the provided value.
+    ///
+    /// This value should be returned when later calling `wasmtime_tls_get`.
+    pub fn wasmtime_tls_set(ptr: *mut u8);
+}
diff --git a/crates/wasmtime/src/runtime/vm/sys/custom/mmap.rs b/crates/wasmtime/src/runtime/vm/sys/custom/mmap.rs
new file mode 100644
index 000000000000..171cf010aee6
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/sys/custom/mmap.rs
@@ -0,0 +1,112 @@
+use super::cvt;
+use crate::prelude::*;
+use crate::runtime::vm::sys::capi;
+use crate::runtime::vm::SendSyncPtr;
+use core::ops::Range;
+use core::ptr::{self, NonNull};
+#[cfg(feature = "std")]
+use std::{fs::File, path::Path};
+
+#[derive(Debug)]
+pub struct Mmap {
+    memory: SendSyncPtr<[u8]>,
+}
+
+impl Mmap {
+    pub fn new_empty() -> Mmap {
+        Mmap {
+            memory: SendSyncPtr::from(&mut [][..]),
+        }
+    }
+
+    pub fn new(size: usize) -> Result<Self> {
+        let mut ptr = ptr::null_mut();
+        cvt(unsafe {
+            capi::wasmtime_mmap_new(size, capi::PROT_READ | capi::PROT_WRITE, &mut ptr)
+        })?;
+        let memory = ptr::slice_from_raw_parts_mut(ptr.cast(), size);
+        let memory = SendSyncPtr::new(NonNull::new(memory).unwrap());
+        Ok(Mmap { memory })
+    }
+
+    pub fn reserve(size: usize) -> Result<Self> {
+        let mut ptr = ptr::null_mut();
+        cvt(unsafe { capi::wasmtime_mmap_new(size, 0, &mut ptr) })?;
+        let memory = ptr::slice_from_raw_parts_mut(ptr.cast(), size);
+        let memory = SendSyncPtr::new(NonNull::new(memory).unwrap());
+        Ok(Mmap { memory })
+    }
+
+    #[cfg(feature = "std")]
+    pub fn from_file(_path: &Path) -> Result<(Self, File)> {
+        anyhow::bail!("not supported on this platform");
+    }
+
+    pub fn make_accessible(&mut self, start: usize, len: usize) -> Result<()> {
+        let ptr = self.memory.as_ptr();
+        unsafe {
+            cvt(capi::wasmtime_mprotect(
+                ptr.byte_add(start).cast(),
+                len,
+                capi::PROT_READ | capi::PROT_WRITE,
+            ))?;
+        }
+
+        Ok(())
+    }
+
+    #[inline]
+    pub fn as_ptr(&self) -> *const u8 {
+        self.memory.as_ptr() as *const u8
+    }
+
+    #[inline]
+    pub fn as_mut_ptr(&mut self) -> *mut u8 {
+        self.memory.as_ptr().cast()
+    }
+
+    #[inline]
+    pub fn len(&self) -> usize {
+        unsafe { (*self.memory.as_ptr()).len() }
+    }
+
+    pub unsafe fn make_executable(
+        &self,
+        range: Range<usize>,
+        enable_branch_protection: bool,
+    ) -> Result<()> {
+        let base = self.memory.as_ptr().byte_add(range.start).cast();
+        let len = range.end - range.start;
+
+        // not mapped into the C API at this time.
+        let _ = enable_branch_protection;
+
+        cvt(capi::wasmtime_mprotect(
+            base,
+            len,
+            capi::PROT_READ | capi::PROT_EXEC,
+        ))?;
+        Ok(())
+    }
+
+    pub unsafe fn make_readonly(&self, range: Range<usize>) -> Result<()> {
+        let base = self.memory.as_ptr().byte_add(range.start).cast();
+        let len = range.end - range.start;
+
+        cvt(capi::wasmtime_mprotect(base, len, capi::PROT_READ))?;
+        Ok(())
+    }
+}
+
+impl Drop for Mmap {
+    fn drop(&mut self) {
+        unsafe {
+            let ptr = self.memory.as_ptr().cast();
+            let len = (*self.memory.as_ptr()).len();
+            if len == 0 {
+                return;
+            }
+            cvt(capi::wasmtime_munmap(ptr, len)).unwrap();
+        }
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/sys/custom/mod.rs b/crates/wasmtime/src/runtime/vm/sys/custom/mod.rs
new file mode 100644
index 000000000000..271479165ca2
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/sys/custom/mod.rs
@@ -0,0 +1,34 @@
+//! Custom platform support in Wasmtime.
+//!
+//! This module contains an implementation of defining Wasmtime's platform
+//! support in terms of a minimal C API. This API can be found in the `capi`
+//! module and all other functionality here is implemented in terms of that
+//! module.
+//!
+//! For more information about this see `./examples/min-platform` as well as
+//! `./docs/examples-minimal.md`.
+
+use crate::prelude::*;
+
+pub mod capi;
+pub mod mmap;
+pub mod traphandlers;
+pub mod unwind;
+pub mod vm;
+
+fn cvt(rc: i32) -> Result<()> {
+    match rc {
+        0 => Ok(()),
+        code => bail!("os error {code}"),
+    }
+}
+
+#[inline]
+pub fn tls_get() -> *mut u8 {
+    unsafe { capi::wasmtime_tls_get() }
+}
+
+#[inline]
+pub fn tls_set(ptr: *mut u8) {
+    unsafe { capi::wasmtime_tls_set(ptr) }
+}
diff --git a/crates/wasmtime/src/runtime/vm/sys/custom/traphandlers.rs b/crates/wasmtime/src/runtime/vm/sys/custom/traphandlers.rs
new file mode 100644
index 000000000000..72f65bf0e65d
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/sys/custom/traphandlers.rs
@@ -0,0 +1,57 @@
+use crate::runtime::vm::traphandlers::{tls, TrapRegisters, TrapTest};
+use crate::runtime::vm::VMContext;
+use core::mem;
+
+pub use crate::runtime::vm::sys::capi::{self, wasmtime_longjmp};
+
+#[allow(missing_docs)]
+pub type SignalHandler<'a> = dyn Fn() + Send + Sync + 'a;
+
+pub unsafe fn wasmtime_setjmp(
+    jmp_buf: *mut *const u8,
+    callback: extern "C" fn(*mut u8, *mut VMContext),
+    payload: *mut u8,
+    callee: *mut VMContext,
+) -> i32 {
+    let callback = mem::transmute::<
+        extern "C" fn(*mut u8, *mut VMContext),
+        extern "C" fn(*mut u8, *mut u8),
+    >(callback);
+    capi::wasmtime_setjmp(jmp_buf, callback, payload, callee.cast())
+}
+
+pub struct TrapHandler;
+
+impl TrapHandler {
+    pub unsafe fn new(_macos_use_mach_ports: bool) -> TrapHandler {
+        capi::wasmtime_init_traps(handle_trap);
+        TrapHandler
+    }
+
+    pub fn validate_config(&self, _macos_use_mach_ports: bool) {}
+}
+
+extern "C" fn handle_trap(pc: usize, fp: usize, has_faulting_addr: bool, faulting_addr: usize) {
+    tls::with(|info| {
+        let info = match info {
+            Some(info) => info,
+            None => return,
+        };
+        let faulting_addr = if has_faulting_addr {
+            Some(faulting_addr)
+        } else {
+            None
+        };
+        let regs = TrapRegisters { pc, fp };
+        let test = info.test_if_trap(regs, faulting_addr, |_handler| {
+            panic!("custom signal handlers are not supported on this platform");
+        });
+        match test {
+            TrapTest::NotWasm => {}
+            TrapTest::HandledByEmbedder => unreachable!(),
+            TrapTest::Trap { jmp_buf } => unsafe { wasmtime_longjmp(jmp_buf) },
+        }
+    })
+}
+
+pub fn lazy_per_thread_init() {}
diff --git a/crates/wasmtime/src/runtime/vm/sys/custom/unwind.rs b/crates/wasmtime/src/runtime/vm/sys/custom/unwind.rs
new file mode 100644
index 000000000000..0387893b7bce
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/sys/custom/unwind.rs
@@ -0,0 +1,17 @@
+#![allow(missing_docs)]
+
+use crate::prelude::*;
+
+pub struct UnwindRegistration {}
+
+impl UnwindRegistration {
+    pub const SECTION_NAME: &'static str = ".eh_frame";
+
+    pub unsafe fn new(
+        _base_address: *const u8,
+        _unwind_info: *const u8,
+        _unwind_len: usize,
+    ) -> Result<UnwindRegistration> {
+        Ok(UnwindRegistration {})
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/sys/custom/vm.rs b/crates/wasmtime/src/runtime/vm/sys/custom/vm.rs
new file mode 100644
index 000000000000..e7f79e41c701
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/sys/custom/vm.rs
@@ -0,0 +1,105 @@
+use super::cvt;
+use crate::prelude::*;
+use crate::runtime::vm::sys::capi;
+use crate::runtime::vm::SendSyncPtr;
+use crate::vm::sys::DecommitBehavior;
+use core::ptr::{self, NonNull};
+#[cfg(feature = "std")]
+use std::{fs::File, sync::Arc};
+
+pub unsafe fn expose_existing_mapping(ptr: *mut u8, len: usize) -> Result<()> {
+    cvt(capi::wasmtime_mprotect(
+        ptr.cast(),
+        len,
+        capi::PROT_READ | capi::PROT_WRITE,
+    ))
+}
+
+pub unsafe fn hide_existing_mapping(ptr: *mut u8, len: usize) -> Result<()> {
+    cvt(capi::wasmtime_mprotect(ptr.cast(), len, 0))
+}
+
+pub unsafe fn erase_existing_mapping(ptr: *mut u8, len: usize) -> Result<()> {
+    cvt(capi::wasmtime_mmap_remap(ptr.cast(), len, 0))
+}
+
+#[cfg(feature = "pooling-allocator")]
+pub unsafe fn commit_pages(_addr: *mut u8, _len: usize) -> Result<()> {
+    // Pages are always READ | WRITE so there's nothing that needs to be
+    // done here.
+    Ok(())
+}
+
+pub unsafe fn decommit_pages(addr: *mut u8, len: usize) -> Result<()> {
+    if len == 0 {
+        return Ok(());
+    }
+
+    cvt(capi::wasmtime_mmap_remap(
+        addr,
+        len,
+        capi::PROT_READ | capi::PROT_WRITE,
+    ))
+}
+
+pub fn get_page_size() -> usize {
+    unsafe { capi::wasmtime_page_size() }
+}
+
+pub fn decommit_behavior() -> DecommitBehavior {
+    DecommitBehavior::Zero
+}
+
+#[derive(PartialEq, Debug)]
+pub struct MemoryImageSource {
+    data: SendSyncPtr<capi::wasmtime_memory_image>,
+}
+
+impl MemoryImageSource {
+    #[cfg(feature = "std")]
+    pub fn from_file(_file: &Arc<File>) -> Option<MemoryImageSource> {
+        None
+    }
+
+    pub fn from_data(data: &[u8]) -> Result<Option<MemoryImageSource>> {
+        unsafe {
+            let mut ptr = ptr::null_mut();
+            cvt(capi::wasmtime_memory_image_new(
+                data.as_ptr(),
+                data.len(),
+                &mut ptr,
+            ))?;
+            match NonNull::new(ptr) {
+                Some(ptr) => Ok(Some(MemoryImageSource {
+                    data: SendSyncPtr::new(ptr),
+                })),
+                None => Ok(None),
+            }
+        }
+    }
+
+    pub unsafe fn map_at(&self, base: *mut u8, len: usize, offset: u64) -> Result<()> {
+        assert_eq!(offset, 0);
+        cvt(capi::wasmtime_memory_image_map_at(
+            self.data.as_ptr(),
+            base,
+            len,
+        ))
+    }
+
+    pub unsafe fn remap_as_zeros_at(&self, base: *mut u8, len: usize) -> Result<()> {
+        cvt(capi::wasmtime_mmap_remap(
+            base.cast(),
+            len,
+            capi::PROT_READ | capi::PROT_WRITE,
+        ))
+    }
+}
+
+impl Drop for MemoryImageSource {
+    fn drop(&mut self) {
+        unsafe {
+            capi::wasmtime_memory_image_free(self.data.as_ptr());
+        }
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/sys/miri/mmap.rs b/crates/wasmtime/src/runtime/vm/sys/miri/mmap.rs
new file mode 100644
index 000000000000..de2a6aa3f76c
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/sys/miri/mmap.rs
@@ -0,0 +1,98 @@
+//! A "dummy" implementation of mmaps for miri where "we do the best we can"
+//!
+//! Namely this uses `alloc` to allocate memory for the "mmap" specifically to
+//! create page-aligned allocations. This allocation doesn't handle operations
+//! like becoming executable or becoming readonly or being created from files,
+//! but it's enough to get various tests running relying on memories and such.
+
+use crate::prelude::*;
+use crate::runtime::vm::SendSyncPtr;
+use std::alloc::{self, Layout};
+use std::fs::File;
+use std::ops::Range;
+use std::path::Path;
+use std::ptr::NonNull;
+
+#[derive(Debug)]
+pub struct Mmap {
+    memory: SendSyncPtr<[u8]>,
+}
+
+impl Mmap {
+    pub fn new_empty() -> Mmap {
+        Mmap {
+            memory: SendSyncPtr::from(&mut [][..]),
+        }
+    }
+
+    pub fn new(size: usize) -> Result<Self> {
+        let mut ret = Mmap::reserve(size)?;
+        ret.make_accessible(0, size)?;
+        Ok(ret)
+    }
+
+    pub fn reserve(size: usize) -> Result<Self> {
+        if size > 1 << 32 {
+            bail!("failed to allocate memory");
+        }
+        let layout = Layout::from_size_align(size, crate::runtime::vm::host_page_size()).unwrap();
+        let ptr = unsafe { alloc::alloc(layout) };
+        if ptr.is_null() {
+            bail!("failed to allocate memory");
+        }
+
+        let memory = std::ptr::slice_from_raw_parts_mut(ptr.cast(), size);
+        let memory = SendSyncPtr::new(NonNull::new(memory).unwrap());
+        Ok(Mmap { memory })
+    }
+
+    pub fn from_file(_path: &Path) -> Result<(Self, File)> {
+        bail!("not supported on miri");
+    }
+
+    pub fn make_accessible(&mut self, start: usize, len: usize) -> Result<()> {
+        // The memory is technically always accessible but this marks it as
+        // initialized for miri-level checking.
+        unsafe {
+            std::ptr::write_bytes(self.as_mut_ptr().add(start), 0u8, len);
+        }
+        Ok(())
+    }
+
+    pub fn as_ptr(&self) -> *const u8 {
+        self.memory.as_ptr() as *const u8
+    }
+
+    pub fn as_mut_ptr(&mut self) -> *mut u8 {
+        self.memory.as_ptr().cast()
+    }
+
+    pub fn len(&self) -> usize {
+        unsafe { (*self.memory.as_ptr()).len() }
+    }
+
+    pub unsafe fn make_executable(
+        &self,
+        _range: Range<usize>,
+        _enable_branch_protection: bool,
+    ) -> Result<()> {
+        Ok(())
+    }
+
+    pub unsafe fn make_readonly(&self, _range: Range<usize>) -> Result<()> {
+        Ok(())
+    }
+}
+
+impl Drop for Mmap {
+    fn drop(&mut self) {
+        if self.len() == 0 {
+            return;
+        }
+        unsafe {
+            let layout =
+                Layout::from_size_align(self.len(), crate::runtime::vm::host_page_size()).unwrap();
+            alloc::dealloc(self.as_mut_ptr(), layout);
+        }
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/sys/miri/mod.rs b/crates/wasmtime/src/runtime/vm/sys/miri/mod.rs
new file mode 100644
index 000000000000..cf953c365a30
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/sys/miri/mod.rs
@@ -0,0 +1,24 @@
+//! "Dummy" implementations of some system primitives for MIRI emulation.
+//!
+//! Note that at this time this is just enough to run some tests in MIRI but
+//! notably WebAssembly tests are not executed at this time (MIRI can't execute
+//! Cranelift-generated code).
+
+use std::cell::Cell;
+
+pub mod mmap;
+pub mod traphandlers;
+pub mod unwind;
+pub mod vm;
+
+std::thread_local!(static TLS: Cell<*mut u8> = const { Cell::new(std::ptr::null_mut()) });
+
+#[inline]
+pub fn tls_get() -> *mut u8 {
+    TLS.with(|p| p.get())
+}
+
+#[inline]
+pub fn tls_set(ptr: *mut u8) {
+    TLS.with(|p| p.set(ptr));
+}
diff --git a/crates/wasmtime/src/runtime/vm/sys/miri/traphandlers.rs b/crates/wasmtime/src/runtime/vm/sys/miri/traphandlers.rs
new file mode 100644
index 000000000000..0059e4b0654c
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/sys/miri/traphandlers.rs
@@ -0,0 +1,48 @@
+// For MIRI, there's no way to implement longjmp/setjmp. The only possible way
+// to implement this is with panic/catch_panic, but the entrypoint into Rust
+// from wasm is defined as `extern "C"` which isn't allowed to panic. That
+// means that panicking here triggers UB which gets routed to `libc::abort()`.
+//
+// This maens that on MIRI all tests which trap are configured to be skipped at
+// this time.
+//
+// Note that no actual JIT code runs in MIRI so this is purely here for
+// host-to-host calls.
+
+use crate::runtime::vm::VMContext;
+
+pub fn wasmtime_setjmp(
+    _jmp_buf: *mut *const u8,
+    callback: extern "C" fn(*mut u8, *mut VMContext),
+    payload: *mut u8,
+    callee: *mut VMContext,
+) -> i32 {
+    callback(payload, callee);
+    1
+}
+
+pub fn wasmtime_longjmp(_jmp_buf: *const u8) -> ! {
+    unsafe {
+        libc::abort();
+    }
+}
+
+#[allow(missing_docs)]
+pub type SignalHandler<'a> = dyn Fn() + Send + Sync + 'a;
+
+pub struct TrapHandler;
+
+impl TrapHandler {
+    pub unsafe fn new(_macos_use_mach_ports: bool) -> TrapHandler {
+        TrapHandler
+    }
+
+    pub fn validate_config(&self, _macos_use_mach_ports: bool) {}
+}
+
+pub fn lazy_per_thread_init() {}
+
+#[cfg(target_os = "macos")]
+pub fn using_mach_ports() -> bool {
+    false
+}
diff --git a/crates/wasmtime/src/runtime/vm/sys/miri/unwind.rs b/crates/wasmtime/src/runtime/vm/sys/miri/unwind.rs
new file mode 100644
index 000000000000..0387893b7bce
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/sys/miri/unwind.rs
@@ -0,0 +1,17 @@
+#![allow(missing_docs)]
+
+use crate::prelude::*;
+
+pub struct UnwindRegistration {}
+
+impl UnwindRegistration {
+    pub const SECTION_NAME: &'static str = ".eh_frame";
+
+    pub unsafe fn new(
+        _base_address: *const u8,
+        _unwind_info: *const u8,
+        _unwind_len: usize,
+    ) -> Result<UnwindRegistration> {
+        Ok(UnwindRegistration {})
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/sys/miri/vm.rs b/crates/wasmtime/src/runtime/vm/sys/miri/vm.rs
new file mode 100644
index 000000000000..321e8cf2f1c3
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/sys/miri/vm.rs
@@ -0,0 +1,59 @@
+use crate::vm::sys::DecommitBehavior;
+use std::fs::File;
+use std::io;
+use std::sync::Arc;
+
+pub unsafe fn expose_existing_mapping(ptr: *mut u8, len: usize) -> io::Result<()> {
+    std::ptr::write_bytes(ptr, 0u8, len);
+    Ok(())
+}
+
+pub unsafe fn hide_existing_mapping(ptr: *mut u8, len: usize) -> io::Result<()> {
+    std::ptr::write_bytes(ptr, 0, len);
+    Ok(())
+}
+
+pub unsafe fn erase_existing_mapping(ptr: *mut u8, len: usize) -> io::Result<()> {
+    std::ptr::write_bytes(ptr, 0, len);
+    Ok(())
+}
+
+#[cfg(feature = "pooling-allocator")]
+pub unsafe fn commit_pages(ptr: *mut u8, len: usize) -> io::Result<()> {
+    std::ptr::write_bytes(ptr, 0, len);
+    Ok(())
+}
+
+pub unsafe fn decommit_pages(ptr: *mut u8, len: usize) -> io::Result<()> {
+    std::ptr::write_bytes(ptr, 0, len);
+    Ok(())
+}
+
+pub fn get_page_size() -> usize {
+    4096
+}
+
+pub fn decommit_behavior() -> DecommitBehavior {
+    DecommitBehavior::Zero
+}
+
+#[derive(PartialEq, Debug)]
+pub enum MemoryImageSource {}
+
+impl MemoryImageSource {
+    pub fn from_file(_file: &Arc<File>) -> Option<MemoryImageSource> {
+        None
+    }
+
+    pub fn from_data(_data: &[u8]) -> io::Result<Option<MemoryImageSource>> {
+        Ok(None)
+    }
+
+    pub unsafe fn map_at(&self, _base: *mut u8, _len: usize, _offset: u64) -> io::Result<()> {
+        match *self {}
+    }
+
+    pub unsafe fn remap_as_zeros_at(&self, _base: *mut u8, _len: usize) -> io::Result<()> {
+        match *self {}
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/sys/mod.rs b/crates/wasmtime/src/runtime/vm/sys/mod.rs
new file mode 100644
index 000000000000..e25ebe305593
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/sys/mod.rs
@@ -0,0 +1,36 @@
+//! OS-related abstractions required by Wasmtime.
+//!
+//! This module is intended to house all logic that's specific to either Unix
+//! or Windows, for example. The goal of this module is to be the "single
+//! module" to edit if Wasmtime is ported to a new platform. Ideally all that's
+//! needed is an extra block below and a new platform should be good to go after
+//! filling out the implementation.
+
+#![allow(clippy::cast_sign_loss)] // platforms too fiddly to worry about this
+
+/// What happens to a mapping after it is decommitted?
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum DecommitBehavior {
+    /// The mapping is zeroed.
+    Zero,
+    /// The original mapping is restored. If it was zero, then it is zero again;
+    /// if it was a CoW mapping, then the original CoW mapping is restored;
+    /// etc...
+    RestoreOriginalMapping,
+}
+
+cfg_if::cfg_if! {
+    if #[cfg(miri)] {
+        mod miri;
+        pub use miri::*;
+    } else if #[cfg(windows)] {
+        mod windows;
+        pub use windows::*;
+    } else if #[cfg(unix)] {
+        mod unix;
+        pub use unix::*;
+    } else {
+        mod custom;
+        pub use custom::*;
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/sys/unix/machports.rs b/crates/wasmtime/src/runtime/vm/sys/unix/machports.rs
new file mode 100644
index 000000000000..63872692b3e7
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/sys/unix/machports.rs
@@ -0,0 +1,440 @@
+//! macOS-specific handling of handling exceptions
+//!
+//! Unlike other Unix platforms macOS here uses mach ports to handle exceptions
+//! instead of signals. While macOS platforms could use signals (and
+//! historically they did!) this is incompatible when Wasmtime is linked into a
+//! project that is otherwise using mach ports for catching exceptions. This
+//! came up #2456 notably when a project like Breakpad is integrated to blanket
+//! catch exceptions and report them.
+//!
+//! Mach ports are somewhat obscure and not really heavily used in a ton of
+//! places. Needless to say the original author of this file worked with mach
+//! ports for the first time when writing this file. As such the exact specifics
+//! here may not be super well documented. This file is 100% lifted from
+//! SpiderMonkey and then adapted for Wasmtime's purposes. Credit for almost
+//! all of this file goes to SpiderMonkey for figuring out all the fiddly bits.
+//! See also
+//! <https://searchfox.org/mozilla-central/source/js/src/wasm/WasmSignalHandlers.cpp>
+//! for the original code.
+//!
+//! The high-level overview is that when using mach ports a thread is blocked
+//! when it generates an exception and then a message can be read from the
+//! port. This means that, unlike signals, threads can't fix their own traps.
+//! Instead a helper thread is spun up to service exception messages. This is
+//! also in conflict with Wasmtime's exception handling currently which is to
+//! use a thread-local to store information about how to unwind. Additionally
+//! this requires that the check of whether a pc is a wasm trap or not is a
+//! global check rather than a per-thread check. This necessitates the existence
+//! of `GlobalModuleRegistry` in the `wasmtime` crate.
+//!
+//! Otherwise this file heavily uses the `mach` Rust crate for type and
+//! function declarations. Many bits and pieces are copied or translated from
+//! the SpiderMonkey implementation and it should pass all the tests!
+
+#![allow(non_snake_case, clippy::cast_sign_loss)]
+
+use crate::runtime::module::lookup_code;
+use crate::runtime::vm::sys::traphandlers::wasmtime_longjmp;
+use crate::runtime::vm::traphandlers::{tls, TrapRegisters};
+use mach2::exc::*;
+use mach2::exception_types::*;
+use mach2::kern_return::*;
+use mach2::mach_init::*;
+use mach2::mach_port::*;
+use mach2::message::*;
+use mach2::ndr::*;
+use mach2::port::*;
+use mach2::thread_act::*;
+use mach2::thread_status::*;
+use mach2::traps::*;
+use std::mem;
+use std::ptr::addr_of_mut;
+use std::thread;
+use wasmtime_environ::Trap;
+
+/// Process-global port that we use to route thread-level exceptions to.
+static mut WASMTIME_PORT: mach_port_name_t = MACH_PORT_NULL;
+
+static mut CHILD_OF_FORKED_PROCESS: bool = false;
+
+pub struct TrapHandler {
+    thread: Option<thread::JoinHandle<()>>,
+}
+
+impl TrapHandler {
+    pub unsafe fn new() -> TrapHandler {
+        // Mach ports do not currently work across forks, so configure Wasmtime to
+        // panic in `lazy_per_thread_init` if the child attempts to invoke
+        // WebAssembly.
+        unsafe extern "C" fn child() {
+            CHILD_OF_FORKED_PROCESS = true;
+        }
+        let rc = libc::pthread_atfork(None, None, Some(child));
+        assert_eq!(rc, 0, "failed to configure `pthread_atfork` handler");
+
+        // Allocate our WASMTIME_PORT and make sure that it can be sent to so we
+        // can receive exceptions.
+        let me = mach_task_self();
+        let kret = mach_port_allocate(me, MACH_PORT_RIGHT_RECEIVE, addr_of_mut!(WASMTIME_PORT));
+        assert_eq!(kret, KERN_SUCCESS, "failed to allocate port");
+        let kret =
+            mach_port_insert_right(me, WASMTIME_PORT, WASMTIME_PORT, MACH_MSG_TYPE_MAKE_SEND);
+        assert_eq!(kret, KERN_SUCCESS, "failed to insert right");
+
+        // Spin up our handler thread which will solely exist to service exceptions
+        // generated by other threads. Note that this is a background thread that
+        // we're not very interested in so it's detached here.
+        let thread = thread::spawn(|| handler_thread());
+
+        TrapHandler {
+            thread: Some(thread),
+        }
+    }
+}
+
+impl Drop for TrapHandler {
+    fn drop(&mut self) {
+        unsafe {
+            let kret = mach_port_destroy(mach_task_self(), WASMTIME_PORT);
+            assert_eq!(kret, KERN_SUCCESS, "failed to destroy port");
+            self.thread.take().unwrap().join().unwrap();
+        }
+    }
+}
+
+// Note that this is copied from Gecko at
+//
+// https://searchfox.org/mozilla-central/rev/ed93119be4818da1509bbcb7b28e245853eeedd5/js/src/wasm/WasmSignalHandlers.cpp#583-601
+//
+// which distinctly diverges from the actual version of this in the header
+// files provided by macOS, notably in the `code` field which uses `i64`
+// instead of `i32`.
+//
+// Also note the `packed(4)` here which forcibly decreases alignment to 4 to
+// additionally match what mach expects (apparently, I wish I had a better
+// reference for this).
+#[repr(C, packed(4))]
+#[allow(dead_code)]
+#[derive(Copy, Clone, Debug)]
+struct __Request__exception_raise_t {
+    Head: mach_msg_header_t,
+    /* start of the kernel processed data */
+    msgh_body: mach_msg_body_t,
+    thread: mach_msg_port_descriptor_t,
+    task: mach_msg_port_descriptor_t,
+    /* end of the kernel processed data */
+    NDR: NDR_record_t,
+    exception: exception_type_t,
+    codeCnt: mach_msg_type_number_t,
+
+    // Note that this is a divergence from the C headers which use
+    // `integer_t` here for this field which is a `c_int`. That isn't
+    // actually reflecting reality apparently though because if `c_int` is
+    // used here then the structure is too small to receive a message.
+    code: [i64; 2],
+}
+
+// This is largely just copied from SpiderMonkey.
+#[repr(C)]
+#[allow(dead_code)]
+#[derive(Debug)]
+struct ExceptionRequest {
+    body: __Request__exception_raise_t,
+    trailer: mach_msg_trailer_t,
+}
+
+unsafe fn handler_thread() {
+    // Taken from mach_exc in /usr/include/mach/mach_exc.defs.
+    const EXCEPTION_MSG_ID: mach_msg_id_t = 2405;
+
+    loop {
+        // Block this thread reading a message from our port. This will block
+        // until some thread throws an exception. Note that messages are all
+        // expected to be exceptions here.
+        let mut request: ExceptionRequest = mem::zeroed();
+        let kret = mach_msg(
+            &mut request.body.Head,
+            MACH_RCV_MSG | MACH_RCV_INTERRUPT,
+            0,
+            mem::size_of_val(&request) as u32,
+            WASMTIME_PORT,
+            MACH_MSG_TIMEOUT_NONE,
+            MACH_PORT_NULL,
+        );
+        if kret == MACH_RCV_PORT_CHANGED {
+            // this port has been closed;
+            break;
+        }
+        if kret != KERN_SUCCESS {
+            eprintln!("mach_msg failed with {kret} ({kret:x})");
+            libc::abort();
+        }
+        if request.body.Head.msgh_id != EXCEPTION_MSG_ID {
+            eprintln!("unexpected msg header id {}", request.body.Head.msgh_id);
+            libc::abort();
+        }
+
+        // Attempt to handle the exception below which will process the state
+        // of the request.
+        //
+        // We unconditionally need to send a message back on our port after
+        // this exception is received, and our reply code here dictates whether
+        // the thread crashes or whether we continue execution of the thread.
+        let reply_code = if handle_exception(&mut request) {
+            KERN_SUCCESS
+        } else {
+            KERN_FAILURE
+        };
+
+        // This magic incantation to send a reply back to the kernel was
+        // derived from the exc_server generated by
+        // 'mig -v /usr/include/mach/mach_exc.defs'.
+        let mut reply: __Reply__exception_raise_t = mem::zeroed();
+        reply.Head.msgh_bits =
+            MACH_MSGH_BITS(request.body.Head.msgh_bits & MACH_MSGH_BITS_REMOTE_MASK, 0);
+        reply.Head.msgh_size = mem::size_of_val(&reply) as u32;
+        reply.Head.msgh_remote_port = request.body.Head.msgh_remote_port;
+        reply.Head.msgh_local_port = MACH_PORT_NULL;
+        reply.Head.msgh_id = request.body.Head.msgh_id + 100;
+        reply.NDR = NDR_record;
+        reply.RetCode = reply_code;
+        mach_msg(
+            &mut reply.Head,
+            MACH_SEND_MSG,
+            mem::size_of_val(&reply) as u32,
+            0,
+            MACH_PORT_NULL,
+            MACH_MSG_TIMEOUT_NONE,
+            MACH_PORT_NULL,
+        );
+    }
+}
+
+unsafe fn handle_exception(request: &mut ExceptionRequest) -> bool {
+    // First make sure that this exception is one that we actually expect to
+    // get raised by wasm code. All other exceptions we safely ignore.
+    match request.body.exception as u32 {
+        EXC_BAD_ACCESS | EXC_BAD_INSTRUCTION | EXC_ARITHMETIC => {}
+        _ => return false,
+    }
+
+    // For `EXC_BAD_ACCESS` the faulting address is listed as the "subcode" in
+    // the second `code` field. If we're ever interested in it the first code
+    // field has a `kern_return_t` describing the kind of failure (e.g. SIGSEGV
+    // vs SIGBUS), but we're not interested in that right now.
+    let faulting_addr = if request.body.exception as u32 == EXC_BAD_ACCESS {
+        Some(request.body.code[1] as usize)
+    } else {
+        None
+    };
+
+    // Depending on the current architecture various bits and pieces of this
+    // will change. This is expected to get filled out for other macos
+    // platforms as necessary.
+    //
+    // The variables this needs to define are:
+    //
+    // * `ThreadState` - a structure read via `thread_get_state` to learn about
+    //   the register state of the thread that trapped.
+    // * `thread_state_flavor` - used to read `ThreadState`
+    // * `get_pc` - a function from `&ThreadState` to a pointer to read the
+    //   current program counter, used to test if it's an address we're
+    //   catching wasm traps for.
+    // * `resume` - a function used to modify `ThreadState` to resume in the
+    //   target thread in the `unwind` function below, passing the two
+    //   parameters as the first two arguments.
+    // * `thread_state` - a fresh instance of `ThreadState` to read into
+    // * `thread_state_count` - the size to pass to `mach_msg`.
+    cfg_if::cfg_if! {
+        if #[cfg(target_arch = "x86_64")] {
+            use mach2::structs::x86_thread_state64_t;
+            use mach2::thread_status::x86_THREAD_STATE64;
+
+            type ThreadState = x86_thread_state64_t;
+
+            let thread_state_flavor = x86_THREAD_STATE64;
+
+            let get_pc_and_fp = |state: &ThreadState| (
+                state.__rip as *const u8,
+                state.__rbp as usize,
+            );
+
+            let resume = |state: &mut ThreadState, pc: usize, fp: usize, fault1: usize, fault2: usize, trap: Trap| {
+                // The x86_64 ABI requires a 16-byte stack alignment for
+                // functions, so typically we'll be 16-byte aligned. In this
+                // case we simulate a `call` instruction by decrementing the
+                // stack pointer and pushing the "return" address which in this
+                // case is the faulting address. This should help the native
+                // unwinder figure out how to find the precisely trapping
+                // function.
+                //
+                // Note, however, that if the stack is not 16-byte aligned then
+                // we don't do anything. Currently this only arises due to
+                // `ud2` in the prologue of functions when performing the
+                // initial stack check. In the old backend 0 stack manipulation
+                // happens until after the stack check passes, so if the stack
+                // check fails (hence we're running in this handler) then the
+                // stack is not 16-byte aligned due to the previous return
+                // address pushed by `call`. In this scenario we just blow away
+                // the stack frame by overwriting %rip. This technically loses
+                // the precise frame that was interrupted, but that's probably
+                // not the end of the world anyway.
+                if state.__rsp % 16 == 0 {
+                    state.__rsp -= 8;
+                    *(state.__rsp as *mut u64) = state.__rip;
+                }
+                state.__rip = unwind as u64;
+                state.__rdi = pc as u64;
+                state.__rsi = fp as u64;
+                state.__rdx = fault1 as u64;
+                state.__rcx = fault2 as u64;
+                state.__r8 = trap as u64;
+            };
+            let mut thread_state = ThreadState::new();
+        } else if #[cfg(target_arch = "aarch64")] {
+            type ThreadState = mach2::structs::arm_thread_state64_t;
+
+            let thread_state_flavor = ARM_THREAD_STATE64;
+
+            let get_pc_and_fp = |state: &ThreadState| (
+                state.__pc as *const u8,
+                state.__fp as usize,
+            );
+
+            let resume = |state: &mut ThreadState, pc: usize, fp: usize, fault1: usize, fault2: usize, trap: Trap| {
+                // Clobber LR with the faulting PC, so unwinding resumes at the
+                // faulting instruction. The previous value of LR has been saved
+                // by the callee (in Cranelift generated code), so no need to
+                // stash it.
+                state.__lr = pc as u64;
+
+                // Fill in the argument to unwind here, and set PC to it, so
+                // it looks like a call to unwind.
+                state.__x[0] = pc as u64;
+                state.__x[1] = fp as u64;
+                state.__x[2] = fault1 as u64;
+                state.__x[3] = fault2 as u64;
+                state.__x[4] = trap as u64;
+                state.__pc = unwind as u64;
+            };
+            let mut thread_state = mem::zeroed::<ThreadState>();
+        } else {
+            compile_error!("unsupported target architecture");
+        }
+    }
+
+    // First up read our origin thread's state into the area defined above.
+    let origin_thread = request.body.thread.name;
+    let mut thread_state_count = ThreadState::count();
+    let kret = thread_get_state(
+        origin_thread,
+        thread_state_flavor,
+        &mut thread_state as *mut ThreadState as *mut u32,
+        &mut thread_state_count,
+    );
+    if kret != KERN_SUCCESS {
+        return false;
+    }
+
+    // Use our global map to determine if this program counter is indeed a wasm
+    // trap, loading the `jmp_buf` to unwind to if it is.
+    //
+    // Note that this is where things are pretty tricky. We're accessing
+    // non-`Send` state (`CallThreadState`) from the exception handling thread.
+    // While typically invalid we are guaranteed that the original thread is
+    // stopped while we're accessing it here so this should be safe.
+    //
+    // Note also that we access the `state` outside the lock of `MAP`. This
+    // again is safe because if `state` is `Some` then we're guaranteed the
+    // thread is stopped and won't be removing or invalidating its state.
+    // Finally our indirection with a pointer means that we can read the
+    // pointer value and if `MAP` changes happen after we read our entry that's
+    // ok since they won't invalidate our entry.
+    let (pc, fp) = get_pc_and_fp(&thread_state);
+    let Some((code, text_offset)) = lookup_code(pc as usize) else {
+        return false;
+    };
+
+    let Some(trap) = code.lookup_trap_code(text_offset) else {
+        return false;
+    };
+
+    // We have determined that this is a wasm trap and we need to actually
+    // force the thread itself to trap. The thread's register state is
+    // configured to resume in the `unwind` function below, we update the
+    // thread's register state, and then we're off to the races.
+    let (fault1, fault2) = match faulting_addr {
+        None => (0, 0),
+        Some(addr) => (1, addr),
+    };
+    resume(&mut thread_state, pc as usize, fp, fault1, fault2, trap);
+    let kret = thread_set_state(
+        origin_thread,
+        thread_state_flavor,
+        &mut thread_state as *mut ThreadState as *mut u32,
+        thread_state_count,
+    );
+    kret == KERN_SUCCESS
+}
+
+/// This is a "landing pad" which is never called directly but is directly
+/// resumed into from wasm-trapped threads.
+///
+/// This is a small shim which primarily serves the purpose of simply capturing
+/// a native backtrace once we've switched back to the thread itself. After
+/// the backtrace is captured we can do the usual `longjmp` back to the source
+/// of the wasm code.
+unsafe extern "C" fn unwind(pc: usize, fp: usize, fault1: usize, fault2: usize, trap: u8) -> ! {
+    let jmp_buf = tls::with(|state| {
+        let state = state.unwrap();
+        let regs = TrapRegisters { pc, fp };
+        let faulting_addr = match fault1 {
+            0 => None,
+            _ => Some(fault2),
+        };
+        let trap = Trap::from_u8(trap).unwrap();
+        state.set_jit_trap(regs, faulting_addr, trap);
+        state.take_jmp_buf()
+    });
+    debug_assert!(!jmp_buf.is_null());
+    wasmtime_longjmp(jmp_buf);
+}
+
+/// Exceptions on macOS can be delivered to either thread-level or task-level
+/// exception ports. In wasmtime we choose to send the exceptions to
+/// thread-level ports. This means that we need to, for each thread that can
+/// generate an exception, register our thread's exception port as
+/// `WASMTIME_PORT` above.
+///
+/// Note that this choice is done because at the current time if we were to
+/// implement a task-level (process-wide) port we'd have to figure out how to
+/// forward exceptions that we're not interested to the previously registered
+/// port. At this time the author isn't sure how to even do that. SpiderMonkey
+/// calls this forwarding "dark magic" as well, and since SpiderMonkey chooses
+/// thread-level ports then I hope that's good enough for wasmtime.
+///
+/// Also note that this choice of thread-level ports should be fine in that
+/// unhandled thread-level exceptions get automatically forwarded to the
+/// task-level port which is where we'd expected things like breakpad/crashpad
+/// exception handlers to get registered.
+#[cold]
+pub fn lazy_per_thread_init() {
+    unsafe {
+        assert!(
+            !CHILD_OF_FORKED_PROCESS,
+            "cannot use Wasmtime in a forked process when mach ports are \
+             configured, see `Config::macos_use_mach_ports`"
+        );
+        assert!(WASMTIME_PORT != MACH_PORT_NULL);
+        let this_thread = mach_thread_self();
+        let kret = thread_set_exception_ports(
+            this_thread,
+            EXC_MASK_BAD_ACCESS | EXC_MASK_BAD_INSTRUCTION | EXC_MASK_ARITHMETIC,
+            WASMTIME_PORT,
+            (EXCEPTION_DEFAULT | MACH_EXCEPTION_CODES) as exception_behavior_t,
+            THREAD_STATE_NONE,
+        );
+        mach_port_deallocate(mach_task_self(), this_thread);
+        assert_eq!(kret, KERN_SUCCESS, "failed to set thread exception port");
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/sys/unix/macos_traphandlers.rs b/crates/wasmtime/src/runtime/vm/sys/unix/macos_traphandlers.rs
new file mode 100644
index 000000000000..862b3eb44dd7
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/sys/unix/macos_traphandlers.rs
@@ -0,0 +1,39 @@
+/// Whether or not macOS is using mach ports.
+#[cfg(target_os = "macos")]
+static mut USE_MACH_PORTS: bool = false;
+
+pub use super::signals::{wasmtime_longjmp, wasmtime_setjmp, SignalHandler};
+
+pub enum TrapHandler {
+    Signals(super::signals::TrapHandler),
+    #[allow(dead_code)] // used for its drop
+    MachPorts(super::machports::TrapHandler),
+}
+
+impl TrapHandler {
+    pub unsafe fn new(macos_use_mach_ports: bool) -> TrapHandler {
+        USE_MACH_PORTS = macos_use_mach_ports;
+        if macos_use_mach_ports {
+            TrapHandler::MachPorts(super::machports::TrapHandler::new())
+        } else {
+            TrapHandler::Signals(super::signals::TrapHandler::new(false))
+        }
+    }
+
+    pub fn validate_config(&self, macos_use_mach_ports: bool) {
+        match self {
+            TrapHandler::Signals(t) => t.validate_config(macos_use_mach_ports),
+            TrapHandler::MachPorts(_) => assert!(macos_use_mach_ports),
+        }
+    }
+}
+
+pub fn lazy_per_thread_init() {
+    unsafe {
+        if USE_MACH_PORTS {
+            super::machports::lazy_per_thread_init();
+        } else {
+            super::signals::lazy_per_thread_init();
+        }
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/sys/unix/mmap.rs b/crates/wasmtime/src/runtime/vm/sys/unix/mmap.rs
new file mode 100644
index 000000000000..4c29a9ae1ca0
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/sys/unix/mmap.rs
@@ -0,0 +1,159 @@
+use crate::prelude::*;
+use crate::runtime::vm::SendSyncPtr;
+use rustix::mm::{mprotect, MprotectFlags};
+use std::ops::Range;
+use std::ptr::{self, NonNull};
+#[cfg(feature = "std")]
+use std::{fs::File, path::Path};
+
+#[derive(Debug)]
+pub struct Mmap {
+    memory: SendSyncPtr<[u8]>,
+}
+
+impl Mmap {
+    pub fn new_empty() -> Mmap {
+        Mmap {
+            memory: SendSyncPtr::from(&mut [][..]),
+        }
+    }
+
+    pub fn new(size: usize) -> Result<Self> {
+        let ptr = unsafe {
+            rustix::mm::mmap_anonymous(
+                ptr::null_mut(),
+                size,
+                rustix::mm::ProtFlags::READ | rustix::mm::ProtFlags::WRITE,
+                rustix::mm::MapFlags::PRIVATE,
+            )
+            .err2anyhow()?
+        };
+        let memory = std::ptr::slice_from_raw_parts_mut(ptr.cast(), size);
+        let memory = SendSyncPtr::new(NonNull::new(memory).unwrap());
+        Ok(Mmap { memory })
+    }
+
+    pub fn reserve(size: usize) -> Result<Self> {
+        let ptr = unsafe {
+            rustix::mm::mmap_anonymous(
+                ptr::null_mut(),
+                size,
+                rustix::mm::ProtFlags::empty(),
+                rustix::mm::MapFlags::PRIVATE,
+            )
+            .err2anyhow()?
+        };
+
+        let memory = std::ptr::slice_from_raw_parts_mut(ptr.cast(), size);
+        let memory = SendSyncPtr::new(NonNull::new(memory).unwrap());
+        Ok(Mmap { memory })
+    }
+
+    #[cfg(feature = "std")]
+    pub fn from_file(path: &Path) -> Result<(Self, File)> {
+        let file = File::open(path)
+            .err2anyhow()
+            .context("failed to open file")?;
+        let len = file
+            .metadata()
+            .err2anyhow()
+            .context("failed to get file metadata")?
+            .len();
+        let len = usize::try_from(len).map_err(|_| anyhow::anyhow!("file too large to map"))?;
+        let ptr = unsafe {
+            rustix::mm::mmap(
+                ptr::null_mut(),
+                len,
+                rustix::mm::ProtFlags::READ | rustix::mm::ProtFlags::WRITE,
+                rustix::mm::MapFlags::PRIVATE,
+                &file,
+                0,
+            )
+            .err2anyhow()
+            .context(format!("mmap failed to allocate {len:#x} bytes"))?
+        };
+        let memory = std::ptr::slice_from_raw_parts_mut(ptr.cast(), len);
+        let memory = SendSyncPtr::new(NonNull::new(memory).unwrap());
+
+        Ok((Mmap { memory }, file))
+    }
+
+    pub fn make_accessible(&mut self, start: usize, len: usize) -> Result<()> {
+        let ptr = self.memory.as_ptr();
+        unsafe {
+            mprotect(
+                ptr.byte_add(start).cast(),
+                len,
+                MprotectFlags::READ | MprotectFlags::WRITE,
+            )
+            .err2anyhow()?;
+        }
+
+        Ok(())
+    }
+
+    #[inline]
+    pub fn as_ptr(&self) -> *const u8 {
+        self.memory.as_ptr() as *const u8
+    }
+
+    #[inline]
+    pub fn as_mut_ptr(&mut self) -> *mut u8 {
+        self.memory.as_ptr().cast()
+    }
+
+    #[inline]
+    pub fn len(&self) -> usize {
+        unsafe { (*self.memory.as_ptr()).len() }
+    }
+
+    pub unsafe fn make_executable(
+        &self,
+        range: Range<usize>,
+        enable_branch_protection: bool,
+    ) -> Result<()> {
+        let base = self.memory.as_ptr().byte_add(range.start).cast();
+        let len = range.end - range.start;
+
+        let flags = MprotectFlags::READ | MprotectFlags::EXEC;
+        let flags = if enable_branch_protection {
+            #[cfg(all(target_arch = "aarch64", target_os = "linux"))]
+            if std::arch::is_aarch64_feature_detected!("bti") {
+                MprotectFlags::from_bits_retain(flags.bits() | /* PROT_BTI */ 0x10)
+            } else {
+                flags
+            }
+
+            #[cfg(not(all(target_arch = "aarch64", target_os = "linux")))]
+            flags
+        } else {
+            flags
+        };
+
+        mprotect(base, len, flags).err2anyhow()?;
+
+        Ok(())
+    }
+
+    pub unsafe fn make_readonly(&self, range: Range<usize>) -> Result<()> {
+        let base = self.memory.as_ptr().byte_add(range.start).cast();
+        let len = range.end - range.start;
+
+        mprotect(base, len, MprotectFlags::READ).err2anyhow()?;
+
+        Ok(())
+    }
+}
+
+impl Drop for Mmap {
+    fn drop(&mut self) {
+        unsafe {
+            let ptr = self.memory.as_ptr().cast();
+            let len = (*self.memory.as_ptr()).len();
+            if len == 0 {
+                return;
+            }
+            rustix::mm::munmap(ptr, len).expect("munmap failed");
+        }
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/sys/unix/mod.rs b/crates/wasmtime/src/runtime/vm/sys/unix/mod.rs
new file mode 100644
index 000000000000..92bcbc9149a0
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/sys/unix/mod.rs
@@ -0,0 +1,35 @@
+//! Implementation of Wasmtime's system primitives for Unix-like operating
+//! systems.
+//!
+//! This module handles Linux and macOS for example.
+
+use core::cell::Cell;
+
+pub mod mmap;
+pub mod unwind;
+pub mod vm;
+
+pub mod signals;
+
+cfg_if::cfg_if! {
+    if #[cfg(target_os = "macos")] {
+        pub mod machports;
+
+        pub mod macos_traphandlers;
+        pub use macos_traphandlers as traphandlers;
+    } else {
+        pub use signals as traphandlers;
+    }
+}
+
+std::thread_local!(static TLS: Cell<*mut u8> = const { Cell::new(std::ptr::null_mut()) });
+
+#[inline]
+pub fn tls_get() -> *mut u8 {
+    TLS.with(|p| p.get())
+}
+
+#[inline]
+pub fn tls_set(ptr: *mut u8) {
+    TLS.with(|p| p.set(ptr));
+}
diff --git a/crates/wasmtime/src/runtime/vm/sys/unix/signals.rs b/crates/wasmtime/src/runtime/vm/sys/unix/signals.rs
new file mode 100644
index 000000000000..5b8d2b44543b
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/sys/unix/signals.rs
@@ -0,0 +1,465 @@
+//! Trap handling on Unix based on POSIX signals.
+
+use crate::runtime::vm::traphandlers::{tls, TrapRegisters, TrapTest};
+use crate::runtime::vm::VMContext;
+use std::cell::RefCell;
+use std::io;
+use std::mem::{self, MaybeUninit};
+use std::ptr::{self, null_mut};
+
+#[link(name = "wasmtime-helpers")]
+extern "C" {
+    #[wasmtime_versioned_export_macros::versioned_link]
+    #[allow(improper_ctypes)]
+    pub fn wasmtime_setjmp(
+        jmp_buf: *mut *const u8,
+        callback: extern "C" fn(*mut u8, *mut VMContext),
+        payload: *mut u8,
+        callee: *mut VMContext,
+    ) -> i32;
+
+    #[wasmtime_versioned_export_macros::versioned_link]
+    pub fn wasmtime_longjmp(jmp_buf: *const u8) -> !;
+}
+
+/// Function which may handle custom signals while processing traps.
+pub type SignalHandler<'a> =
+    dyn Fn(libc::c_int, *const libc::siginfo_t, *const libc::c_void) -> bool + Send + Sync + 'a;
+
+static mut PREV_SIGSEGV: MaybeUninit<libc::sigaction> = MaybeUninit::uninit();
+static mut PREV_SIGBUS: MaybeUninit<libc::sigaction> = MaybeUninit::uninit();
+static mut PREV_SIGILL: MaybeUninit<libc::sigaction> = MaybeUninit::uninit();
+static mut PREV_SIGFPE: MaybeUninit<libc::sigaction> = MaybeUninit::uninit();
+
+pub struct TrapHandler;
+
+impl TrapHandler {
+    /// Installs all trap handlers.
+    ///
+    /// # Unsafety
+    ///
+    /// This function is unsafe because it's not safe to call concurrently and
+    /// it's not safe to call if the trap handlers have already been initialized
+    /// for this process.
+    pub unsafe fn new(macos_use_mach_ports: bool) -> TrapHandler {
+        // Either mach ports shouldn't be in use or we shouldn't be on macOS,
+        // otherwise the `machports.rs` module should be used instead.
+        assert!(!macos_use_mach_ports || !cfg!(target_os = "macos"));
+
+        foreach_handler(|slot, signal| {
+            let mut handler: libc::sigaction = mem::zeroed();
+            // The flags here are relatively careful, and they are...
+            //
+            // SA_SIGINFO gives us access to information like the program
+            // counter from where the fault happened.
+            //
+            // SA_ONSTACK allows us to handle signals on an alternate stack,
+            // so that the handler can run in response to running out of
+            // stack space on the main stack. Rust installs an alternate
+            // stack with sigaltstack, so we rely on that.
+            //
+            // SA_NODEFER allows us to reenter the signal handler if we
+            // 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;
+            libc::sigemptyset(&mut handler.sa_mask);
+            if libc::sigaction(signal, &handler, slot) != 0 {
+                panic!(
+                    "unable to install signal handler: {}",
+                    io::Error::last_os_error(),
+                );
+            }
+        });
+
+        TrapHandler
+    }
+
+    pub fn validate_config(&self, macos_use_mach_ports: bool) {
+        assert!(!macos_use_mach_ports || !cfg!(target_os = "macos"));
+    }
+}
+
+unsafe fn foreach_handler(mut f: impl FnMut(*mut libc::sigaction, i32)) {
+    // Allow handling OOB with signals on all architectures
+    f(PREV_SIGSEGV.as_mut_ptr(), libc::SIGSEGV);
+
+    // Handle `unreachable` instructions which execute `ud2` right now
+    f(PREV_SIGILL.as_mut_ptr(), libc::SIGILL);
+
+    // x86 and s390x use SIGFPE to report division by zero
+    if cfg!(target_arch = "x86_64") || cfg!(target_arch = "s390x") {
+        f(PREV_SIGFPE.as_mut_ptr(), libc::SIGFPE);
+    }
+
+    // Sometimes we need to handle SIGBUS too:
+    // - On Darwin, guard page accesses are raised as SIGBUS.
+    if cfg!(target_os = "macos") || cfg!(target_os = "freebsd") {
+        f(PREV_SIGBUS.as_mut_ptr(), libc::SIGBUS);
+    }
+
+    // TODO(#1980): x86-32, if we support it, will also need a SIGFPE handler.
+    // TODO(#1173): ARM32, if we support it, will also need a SIGBUS handler.
+}
+
+impl Drop for TrapHandler {
+    fn drop(&mut self) {
+        unsafe {
+            foreach_handler(|slot, signal| {
+                let mut prev: libc::sigaction = mem::zeroed();
+
+                // Restore the previous handler that this signal had.
+                if libc::sigaction(signal, slot, &mut prev) != 0 {
+                    eprintln!(
+                        "unable to reinstall signal handler: {}",
+                        io::Error::last_os_error(),
+                    );
+                    libc::abort();
+                }
+
+                // If our trap handler wasn't currently listed for this process
+                // then that's a problem because we have just corrupted the
+                // signal handler state and don't know how to remove ourselves
+                // from the signal handling state. Inform the user of this and
+                // abort the process.
+                if prev.sa_sigaction != trap_handler as usize {
+                    eprintln!(
+                        "
+Wasmtime's signal handler was not the last signal handler to be installed
+in the process so it's not certain how to unload signal handlers. In this
+situation the Engine::unload_process_handlers API is not applicable and requires
+perhaps initializing libraries in a different order. The process will be aborted
+now.
+"
+                    );
+                    libc::abort();
+                }
+            });
+        }
+    }
+}
+
+unsafe extern "C" fn trap_handler(
+    signum: libc::c_int,
+    siginfo: *mut libc::siginfo_t,
+    context: *mut libc::c_void,
+) {
+    let previous = match signum {
+        libc::SIGSEGV => PREV_SIGSEGV.as_ptr(),
+        libc::SIGBUS => PREV_SIGBUS.as_ptr(),
+        libc::SIGFPE => PREV_SIGFPE.as_ptr(),
+        libc::SIGILL => PREV_SIGILL.as_ptr(),
+        _ => panic!("unknown signal: {signum}"),
+    };
+    let handled = tls::with(|info| {
+        // If no wasm code is executing, we don't handle this as a wasm
+        // trap.
+        let info = match info {
+            Some(info) => info,
+            None => return false,
+        };
+
+        // If we hit an exception while handling a previous trap, that's
+        // quite bad, so bail out and let the system handle this
+        // recursive segfault.
+        //
+        // Otherwise flag ourselves as handling a trap, do the trap
+        // handling, and reset our trap handling flag. Then we figure
+        // out what to do based on the result of the trap handling.
+        let faulting_addr = match signum {
+            libc::SIGSEGV | libc::SIGBUS => Some((*siginfo).si_addr() as usize),
+            _ => None,
+        };
+        let regs = get_trap_registers(context, signum);
+        let test = info.test_if_trap(regs, faulting_addr, |handler| {
+            handler(signum, siginfo, context)
+        });
+
+        // Figure out what to do based on the result of this handling of
+        // the trap. Note that our sentinel value of 1 means that the
+        // exception was handled by a custom exception handler, so we
+        // keep executing.
+        let jmp_buf = match test {
+            TrapTest::NotWasm => return false,
+            TrapTest::HandledByEmbedder => return true,
+            TrapTest::Trap { jmp_buf } => jmp_buf,
+        };
+        // On macOS this is a bit special, unfortunately. If we were to
+        // `siglongjmp` out of the signal handler that notably does
+        // *not* reset the sigaltstack state of our signal handler. This
+        // seems to trick the kernel into thinking that the sigaltstack
+        // is still in use upon delivery of the next signal, meaning
+        // that the sigaltstack is not ever used again if we immediately
+        // call `wasmtime_longjmp` here.
+        //
+        // Note that if we use `longjmp` instead of `siglongjmp` then
+        // the problem is fixed. The problem with that, however, is that
+        // `setjmp` is much slower than `sigsetjmp` due to the
+        // preservation of the process's signal mask. The reason
+        // `longjmp` appears to work is that it seems to call a function
+        // (according to published macOS sources) called
+        // `_sigunaltstack` which updates the kernel to say the
+        // sigaltstack is no longer in use. We ideally want to call that
+        // here but I don't think there's a stable way for us to call
+        // that.
+        //
+        // Given all that, on macOS only, we do the next best thing. We
+        // return from the signal handler after updating the register
+        // context. This will cause control to return to our shim
+        // function defined here which will perform the
+        // `wasmtime_longjmp` (`siglongjmp`) for us. The reason this
+        // works is that by returning from the signal handler we'll
+        // trigger all the normal machinery for "the signal handler is
+        // done running" which will clear the sigaltstack flag and allow
+        // reusing it for the next signal. Then upon resuming in our custom
+        // code we blow away the stack anyway with a longjmp.
+        if cfg!(target_os = "macos") {
+            unsafe extern "C" fn wasmtime_longjmp_shim(jmp_buf: *const u8) {
+                wasmtime_longjmp(jmp_buf)
+            }
+            set_pc(context, wasmtime_longjmp_shim as usize, jmp_buf as usize);
+            return true;
+        }
+        wasmtime_longjmp(jmp_buf)
+    });
+
+    if handled {
+        return;
+    }
+
+    // This signal is not for any compiled wasm code we expect, so we
+    // need to forward the signal to the next handler. If there is no
+    // next handler (SIG_IGN or SIG_DFL), then it's time to crash. To do
+    // this, we set the signal back to its original disposition and
+    // return. This will cause the faulting op to be re-executed which
+    // will crash in the normal way. If there is a next handler, call
+    // it. It will either crash synchronously, fix up the instruction
+    // so that execution can continue and return, or trigger a crash by
+    // returning the signal to it's original disposition and returning.
+    let previous = *previous;
+    if previous.sa_flags & libc::SA_SIGINFO != 0 {
+        mem::transmute::<usize, extern "C" fn(libc::c_int, *mut libc::siginfo_t, *mut libc::c_void)>(
+            previous.sa_sigaction,
+        )(signum, siginfo, context)
+    } else if previous.sa_sigaction == libc::SIG_DFL || previous.sa_sigaction == libc::SIG_IGN {
+        libc::sigaction(signum, &previous as *const _, ptr::null_mut());
+    } else {
+        mem::transmute::<usize, extern "C" fn(libc::c_int)>(previous.sa_sigaction)(signum)
+    }
+}
+
+unsafe fn get_trap_registers(cx: *mut libc::c_void, _signum: libc::c_int) -> TrapRegisters {
+    cfg_if::cfg_if! {
+        if #[cfg(all(any(target_os = "linux", target_os = "android"), target_arch = "x86_64"))] {
+            let cx = &*(cx as *const libc::ucontext_t);
+            TrapRegisters {
+                pc: cx.uc_mcontext.gregs[libc::REG_RIP as usize] as usize,
+                fp: cx.uc_mcontext.gregs[libc::REG_RBP as usize] as usize,
+            }
+        } else if #[cfg(all(any(target_os = "linux", target_os = "android"), target_arch = "aarch64"))] {
+            let cx = &*(cx as *const libc::ucontext_t);
+            TrapRegisters {
+                pc: cx.uc_mcontext.pc as usize,
+                fp: cx.uc_mcontext.regs[29] as usize,
+            }
+        } else if #[cfg(all(target_os = "linux", target_arch = "s390x"))] {
+            // On s390x, SIGILL and SIGFPE are delivered with the PSW address
+            // pointing *after* the faulting instruction, while SIGSEGV and
+            // SIGBUS are delivered with the PSW address pointing *to* the
+            // faulting instruction.  To handle this, the code generator registers
+            // any trap that results in one of "late" signals on the last byte
+            // of the instruction, and any trap that results in one of the "early"
+            // signals on the first byte of the instruction (as usual).  This
+            // means we simply need to decrement the reported PSW address by
+            // one in the case of a "late" signal here to ensure we always
+            // correctly find the associated trap handler.
+            let trap_offset = match _signum {
+                libc::SIGILL | libc::SIGFPE => 1,
+                _ => 0,
+            };
+            let cx = &*(cx as *const libc::ucontext_t);
+            TrapRegisters {
+                pc: (cx.uc_mcontext.psw.addr - trap_offset) as usize,
+                fp: *(cx.uc_mcontext.gregs[15] as *const usize),
+            }
+        } else if #[cfg(all(target_os = "macos", target_arch = "x86_64"))] {
+            let cx = &*(cx as *const libc::ucontext_t);
+            TrapRegisters {
+                pc: (*cx.uc_mcontext).__ss.__rip as usize,
+                fp: (*cx.uc_mcontext).__ss.__rbp as usize,
+            }
+        } else if #[cfg(all(target_os = "macos", target_arch = "aarch64"))] {
+            let cx = &*(cx as *const libc::ucontext_t);
+            TrapRegisters {
+                pc: (*cx.uc_mcontext).__ss.__pc as usize,
+                fp: (*cx.uc_mcontext).__ss.__fp as usize,
+            }
+        } else if #[cfg(all(target_os = "freebsd", target_arch = "x86_64"))] {
+            let cx = &*(cx as *const libc::ucontext_t);
+            TrapRegisters {
+                pc: cx.uc_mcontext.mc_rip as usize,
+                fp: cx.uc_mcontext.mc_rbp as usize,
+            }
+        } else if #[cfg(all(target_os = "linux", target_arch = "riscv64"))] {
+            let cx = &*(cx as *const libc::ucontext_t);
+            TrapRegisters {
+                pc: cx.uc_mcontext.__gregs[libc::REG_PC] as usize,
+                fp: cx.uc_mcontext.__gregs[libc::REG_S0] as usize,
+            }
+        } else if #[cfg(all(target_os = "freebsd", target_arch = "aarch64"))] {
+            let cx = &*(cx as *const libc::mcontext_t);
+            TrapRegisters {
+                pc: cx.mc_gpregs.gp_elr as usize,
+                fp: cx.mc_gpregs.gp_x[29] as usize,
+            }
+        } else if #[cfg(all(target_os = "openbsd", target_arch = "x86_64"))] {
+            let cx = &*(cx as *const libc::ucontext_t);
+            TrapRegisters {
+                pc: cx.sc_rip as usize,
+                fp: cx.sc_rbp as usize,
+            }
+        }
+        else {
+            compile_error!("unsupported platform");
+            panic!();
+        }
+    }
+}
+
+// This is only used on macOS targets for calling an unwinding shim
+// function to ensure that we return from the signal handler.
+//
+// See more comments above where this is called for what it's doing.
+unsafe fn set_pc(cx: *mut libc::c_void, pc: usize, arg1: usize) {
+    cfg_if::cfg_if! {
+        if #[cfg(not(target_os = "macos"))] {
+            let _ = (cx, pc, arg1);
+            unreachable!(); // not used on these platforms
+        } else if #[cfg(target_arch = "x86_64")] {
+            let cx = &mut *(cx as *mut libc::ucontext_t);
+            (*cx.uc_mcontext).__ss.__rip = pc as u64;
+            (*cx.uc_mcontext).__ss.__rdi = arg1 as u64;
+            // We're simulating a "pseudo-call" so we need to ensure
+            // stack alignment is properly respected, notably that on a
+            // `call` instruction the stack is 8/16-byte aligned, then
+            // the function adjusts itself to be 16-byte aligned.
+            //
+            // Most of the time the stack pointer is 16-byte aligned at
+            // the time of the trap but for more robust-ness with JIT
+            // code where it may ud2 in a prologue check before the
+            // stack is aligned we double-check here.
+            if (*cx.uc_mcontext).__ss.__rsp % 16 == 0 {
+                (*cx.uc_mcontext).__ss.__rsp -= 8;
+            }
+        } else if #[cfg(target_arch = "aarch64")] {
+            let cx = &mut *(cx as *mut libc::ucontext_t);
+            (*cx.uc_mcontext).__ss.__pc = pc as u64;
+            (*cx.uc_mcontext).__ss.__x[0] = arg1 as u64;
+        } else {
+            compile_error!("unsupported macos target architecture");
+        }
+    }
+}
+
+/// A function for registering a custom alternate signal stack (sigaltstack).
+///
+/// Rust's libstd installs an alternate stack with size `SIGSTKSZ`, which is not
+/// always large enough for our signal handling code. Override it by creating
+/// and registering our own alternate stack that is large enough and has a guard
+/// page.
+#[cold]
+pub fn lazy_per_thread_init() {
+    // This thread local is purely used to register a `Stack` to get deallocated
+    // when the thread exists. Otherwise this function is only ever called at
+    // most once per-thread.
+    std::thread_local! {
+        static STACK: RefCell<Option<Stack>> = const { RefCell::new(None) };
+    }
+
+    /// The size of the sigaltstack (not including the guard, which will be
+    /// added). Make this large enough to run our signal handlers.
+    ///
+    /// The main current requirement of the signal handler in terms of stack
+    /// space is that `malloc`/`realloc` are called to create a `Backtrace` of
+    /// wasm frames.
+    ///
+    /// Historically this was 16k. Turns out jemalloc requires more than 16k of
+    /// stack space in debug mode, so this was bumped to 64k.
+    const MIN_STACK_SIZE: usize = 64 * 4096;
+
+    struct Stack {
+        mmap_ptr: *mut libc::c_void,
+        mmap_size: usize,
+    }
+
+    return STACK.with(|s| {
+        *s.borrow_mut() = unsafe { allocate_sigaltstack() };
+    });
+
+    unsafe fn allocate_sigaltstack() -> Option<Stack> {
+        // 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: {}",
+            io::Error::last_os_error()
+        );
+        if old_stack.ss_flags & libc::SS_DISABLE == 0 && old_stack.ss_size >= MIN_STACK_SIZE {
+            return None;
+        }
+
+        // ... but failing that we need to allocate our own, so do all that
+        // here.
+        let page_size = crate::runtime::vm::host_page_size();
+        let guard_size = page_size;
+        let alloc_size = guard_size + MIN_STACK_SIZE;
+
+        let ptr = rustix::mm::mmap_anonymous(
+            null_mut(),
+            alloc_size,
+            rustix::mm::ProtFlags::empty(),
+            rustix::mm::MapFlags::PRIVATE,
+        )
+        .expect("failed to allocate memory for sigaltstack");
+
+        // Prepare the stack with readable/writable memory and then register it
+        // with `sigaltstack`.
+        let stack_ptr = (ptr as usize + guard_size) as *mut std::ffi::c_void;
+        rustix::mm::mprotect(
+            stack_ptr,
+            MIN_STACK_SIZE,
+            rustix::mm::MprotectFlags::READ | rustix::mm::MprotectFlags::WRITE,
+        )
+        .expect("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: {}",
+            io::Error::last_os_error()
+        );
+
+        Some(Stack {
+            mmap_ptr: ptr,
+            mmap_size: alloc_size,
+        })
+    }
+
+    impl Drop for Stack {
+        fn drop(&mut self) {
+            unsafe {
+                // Deallocate the stack memory.
+                let r = rustix::mm::munmap(self.mmap_ptr, self.mmap_size);
+                debug_assert!(r.is_ok(), "munmap failed during thread shutdown");
+            }
+        }
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/sys/unix/unwind.rs b/crates/wasmtime/src/runtime/vm/sys/unix/unwind.rs
new file mode 100644
index 000000000000..7ab9a73607db
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/sys/unix/unwind.rs
@@ -0,0 +1,149 @@
+//! Module for System V ABI unwind registry.
+
+use crate::prelude::*;
+use crate::runtime::vm::SendSyncPtr;
+use core::ptr::{self, NonNull};
+use core::sync::atomic::{AtomicUsize, Ordering::Relaxed};
+
+/// Represents a registration of function unwind information for System V ABI.
+pub struct UnwindRegistration {
+    registrations: Vec<SendSyncPtr<u8>>,
+}
+
+extern "C" {
+    // libunwind import
+    fn __register_frame(fde: *const u8);
+    fn __deregister_frame(fde: *const u8);
+}
+
+/// There are two primary unwinders on Unix platforms: libunwind and libgcc.
+///
+/// Unfortunately their interface to `__register_frame` is different. The
+/// libunwind library takes a pointer to an individual FDE while libgcc takes a
+/// null-terminated list of FDEs. This means we need to know what unwinder
+/// is being used at runtime.
+///
+/// This detection is done currently by looking for a libunwind-specific symbol.
+/// This specific symbol was somewhat recommended by LLVM's
+/// "RTDyldMemoryManager.cpp" file which says:
+///
+/// > We use the presence of __unw_add_dynamic_fde to detect libunwind.
+///
+/// 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.
+fn using_libunwind() -> bool {
+    static USING_LIBUNWIND: AtomicUsize = AtomicUsize::new(LIBUNWIND_UNKNOWN);
+
+    const LIBUNWIND_UNKNOWN: usize = 0;
+    const LIBUNWIND_YES: usize = 1;
+    const LIBUNWIND_NO: usize = 2;
+
+    // On macOS the libgcc interface is never used so libunwind is always used.
+    if cfg!(target_os = "macos") {
+        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
+    // figure out what we're using and branch based on that.
+    //
+    // Note that the result of `libc::dlsym` is cached to only look this up
+    // once.
+    match USING_LIBUNWIND.load(Relaxed) {
+        LIBUNWIND_YES => true,
+        LIBUNWIND_NO => false,
+        LIBUNWIND_UNKNOWN => {
+            let looks_like_libunwind = unsafe {
+                !libc::dlsym(ptr::null_mut(), c"__unw_add_dynamic_fde".as_ptr()).is_null()
+            };
+            USING_LIBUNWIND.store(
+                if looks_like_libunwind {
+                    LIBUNWIND_YES
+                } else {
+                    LIBUNWIND_NO
+                },
+                Relaxed,
+            );
+            looks_like_libunwind
+        }
+        _ => unreachable!(),
+    }
+}
+
+impl UnwindRegistration {
+    #[allow(missing_docs)]
+    pub const SECTION_NAME: &'static str = ".eh_frame";
+
+    /// Registers precompiled unwinding information with the system.
+    ///
+    /// The `_base_address` field is ignored here (only used on other
+    /// platforms), but the `unwind_info` and `unwind_len` parameters should
+    /// describe an in-memory representation of a `.eh_frame` section. This is
+    /// typically arranged for by the `wasmtime-obj` crate.
+    pub unsafe fn new(
+        _base_address: *const u8,
+        unwind_info: *const u8,
+        unwind_len: usize,
+    ) -> Result<UnwindRegistration> {
+        debug_assert_eq!(
+            unwind_info as usize % crate::runtime::vm::host_page_size(),
+            0,
+            "The unwind info must always be aligned to a page"
+        );
+
+        let mut registrations = Vec::new();
+        if using_libunwind() {
+            // For libunwind, `__register_frame` takes a pointer to a single
+            // FDE. Note that we subtract 4 from the length of unwind info since
+            // wasmtime-encode .eh_frame sections always have a trailing 32-bit
+            // zero for the platforms above.
+            let start = unwind_info;
+            let end = start.add(unwind_len - 4);
+            let mut current = start;
+
+            // Walk all of the entries in the frame table and register them
+            while current < end {
+                let len = current.cast::<u32>().read_unaligned() as usize;
+
+                // Skip over the CIE
+                if current != start {
+                    __register_frame(current);
+                    let cur = NonNull::new(current.cast_mut()).unwrap();
+                    registrations.push(SendSyncPtr::new(cur));
+                }
+
+                // Move to the next table entry (+4 because the length itself is
+                // not inclusive)
+                current = current.add(len + 4);
+            }
+        } else {
+            // On gnu (libgcc), `__register_frame` will walk the FDEs until an
+            // entry of length 0
+            __register_frame(unwind_info);
+            let info = NonNull::new(unwind_info.cast_mut()).unwrap();
+            registrations.push(SendSyncPtr::new(info));
+        }
+
+        Ok(UnwindRegistration { registrations })
+    }
+}
+
+impl Drop for UnwindRegistration {
+    fn drop(&mut self) {
+        unsafe {
+            // libgcc stores the frame entries as a linked list in decreasing
+            // sort order based on the PC value of the registered entry.
+            //
+            // As we store the registrations in increasing order, it would be
+            // O(N^2) to deregister in that order.
+            //
+            // To ensure that we just pop off the first element in the list upon
+            // every deregistration, walk our list of registrations backwards.
+            for fde in self.registrations.iter().rev() {
+                __deregister_frame(fde.as_ptr());
+            }
+        }
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/sys/unix/vm.rs b/crates/wasmtime/src/runtime/vm/sys/unix/vm.rs
new file mode 100644
index 000000000000..6552746c7cff
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/sys/unix/vm.rs
@@ -0,0 +1,190 @@
+use crate::runtime::vm::sys::DecommitBehavior;
+use rustix::fd::AsRawFd;
+use rustix::mm::{mmap, mmap_anonymous, mprotect, MapFlags, MprotectFlags, ProtFlags};
+use std::fs::File;
+use std::io;
+#[cfg(feature = "std")]
+use std::sync::Arc;
+
+pub unsafe fn expose_existing_mapping(ptr: *mut u8, len: usize) -> io::Result<()> {
+    mprotect(ptr.cast(), len, MprotectFlags::READ | MprotectFlags::WRITE)?;
+    Ok(())
+}
+
+pub unsafe fn hide_existing_mapping(ptr: *mut u8, len: usize) -> io::Result<()> {
+    mprotect(ptr.cast(), len, MprotectFlags::empty())?;
+    Ok(())
+}
+
+pub unsafe fn erase_existing_mapping(ptr: *mut u8, len: usize) -> io::Result<()> {
+    let ret = mmap_anonymous(
+        ptr.cast(),
+        len,
+        ProtFlags::empty(),
+        MapFlags::PRIVATE | MapFlags::FIXED,
+    )?;
+    assert_eq!(ptr, ret.cast());
+    Ok(())
+}
+
+#[cfg(feature = "pooling-allocator")]
+pub unsafe fn commit_pages(_addr: *mut u8, _len: usize) -> io::Result<()> {
+    // Pages are always READ | WRITE so there's nothing that needs to be done
+    // here.
+    Ok(())
+}
+
+pub unsafe fn decommit_pages(addr: *mut u8, len: usize) -> io::Result<()> {
+    if len == 0 {
+        return Ok(());
+    }
+
+    unsafe {
+        cfg_if::cfg_if! {
+            if #[cfg(target_os = "linux")] {
+                use rustix::mm::{madvise, Advice};
+
+                // On Linux, this is enough to cause the kernel to initialize
+                // the pages to 0 on next access
+                madvise(addr as _, len, Advice::LinuxDontNeed)?;
+            } else {
+                // By creating a new mapping at the same location, this will
+                // discard the mapping for the pages in the given range.
+                // The new mapping will be to the CoW zero page, so this
+                // effectively zeroes the pages.
+                mmap_anonymous(
+                    addr as _,
+                    len,
+                    ProtFlags::READ | ProtFlags::WRITE,
+                    MapFlags::PRIVATE | MapFlags::FIXED,
+                )?;
+            }
+        }
+    }
+
+    Ok(())
+}
+
+pub fn get_page_size() -> usize {
+    unsafe { libc::sysconf(libc::_SC_PAGESIZE).try_into().unwrap() }
+}
+
+pub fn decommit_behavior() -> DecommitBehavior {
+    if cfg!(target_os = "linux") {
+        DecommitBehavior::RestoreOriginalMapping
+    } else {
+        DecommitBehavior::Zero
+    }
+}
+
+#[derive(Debug)]
+pub enum MemoryImageSource {
+    #[cfg(feature = "std")]
+    Mmap(Arc<File>),
+    #[cfg(target_os = "linux")]
+    Memfd(memfd::Memfd),
+}
+
+impl MemoryImageSource {
+    #[cfg(feature = "std")]
+    pub fn from_file(file: &Arc<File>) -> Option<MemoryImageSource> {
+        Some(MemoryImageSource::Mmap(file.clone()))
+    }
+
+    #[cfg(not(target_os = "linux"))]
+    pub fn from_data(_data: &[u8]) -> io::Result<Option<MemoryImageSource>> {
+        Ok(None)
+    }
+
+    #[cfg(target_os = "linux")]
+    pub fn from_data(data: &[u8]) -> anyhow::Result<Option<MemoryImageSource>> {
+        // On Linux `memfd_create` is used to create an anonymous
+        // in-memory file to represent the heap image. This anonymous
+        // file is then used as the basis for further mmaps.
+
+        use crate::prelude::*;
+        use std::io::{ErrorKind, Write};
+
+        // Create the memfd. It needs a name, but the documentation for
+        // `memfd_create()` says that names can be duplicated with no issues.
+        let memfd = match memfd::MemfdOptions::new()
+            .allow_sealing(true)
+            .create("wasm-memory-image")
+        {
+            Ok(memfd) => memfd,
+            // If this kernel is old enough to not support memfd then attempt to
+            // gracefully handle that and fall back to skipping the memfd
+            // optimization.
+            Err(memfd::Error::Create(err)) if err.kind() == ErrorKind::Unsupported => {
+                return Ok(None)
+            }
+            Err(e) => return Err(e.into_anyhow()),
+        };
+        memfd.as_file().write_all(data).err2anyhow()?;
+
+        // Seal the memfd's data and length.
+        //
+        // This is a defense-in-depth security mitigation. The
+        // memfd will serve as the starting point for the heap of
+        // every instance of this module. If anything were to
+        // write to this, it could affect every execution. The
+        // memfd object itself is owned by the machinery here and
+        // not exposed elsewhere, but it is still an ambient open
+        // file descriptor at the syscall level, so some other
+        // vulnerability that allowed writes to arbitrary fds
+        // could modify it. Or we could have some issue with the
+        // way that we map it into each instance. To be
+        // extra-super-sure that it never changes, and because
+        // this costs very little, we use the kernel's "seal" API
+        // to make the memfd image permanently read-only.
+        memfd
+            .add_seals(&[
+                memfd::FileSeal::SealGrow,
+                memfd::FileSeal::SealShrink,
+                memfd::FileSeal::SealWrite,
+                memfd::FileSeal::SealSeal,
+            ])
+            .err2anyhow()?;
+
+        Ok(Some(MemoryImageSource::Memfd(memfd)))
+    }
+
+    fn as_file(&self) -> &File {
+        match *self {
+            #[cfg(feature = "std")]
+            MemoryImageSource::Mmap(ref file) => file,
+            #[cfg(target_os = "linux")]
+            MemoryImageSource::Memfd(ref memfd) => memfd.as_file(),
+        }
+    }
+
+    pub unsafe fn map_at(&self, base: *mut u8, len: usize, offset: u64) -> io::Result<()> {
+        let ptr = mmap(
+            base.cast(),
+            len,
+            ProtFlags::READ | ProtFlags::WRITE,
+            MapFlags::PRIVATE | MapFlags::FIXED,
+            self.as_file(),
+            offset,
+        )?;
+        assert_eq!(base, ptr.cast());
+        Ok(())
+    }
+
+    pub unsafe fn remap_as_zeros_at(&self, base: *mut u8, len: usize) -> io::Result<()> {
+        let ptr = mmap_anonymous(
+            base.cast(),
+            len,
+            ProtFlags::READ | ProtFlags::WRITE,
+            MapFlags::PRIVATE | MapFlags::FIXED,
+        )?;
+        assert_eq!(base, ptr.cast());
+        Ok(())
+    }
+}
+
+impl PartialEq for MemoryImageSource {
+    fn eq(&self, other: &MemoryImageSource) -> bool {
+        self.as_file().as_raw_fd() == other.as_file().as_raw_fd()
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/sys/windows/mmap.rs b/crates/wasmtime/src/runtime/vm/sys/windows/mmap.rs
new file mode 100644
index 000000000000..d4d62061eb22
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/sys/windows/mmap.rs
@@ -0,0 +1,220 @@
+use crate::prelude::*;
+use crate::runtime::vm::SendSyncPtr;
+use std::fs::{File, OpenOptions};
+use std::io;
+use std::ops::Range;
+use std::os::windows::prelude::*;
+use std::path::Path;
+use std::ptr::{self, NonNull};
+use windows_sys::Win32::Foundation::*;
+use windows_sys::Win32::Storage::FileSystem::*;
+use windows_sys::Win32::System::Memory::*;
+
+#[derive(Debug)]
+pub struct Mmap {
+    memory: SendSyncPtr<[u8]>,
+    is_file: bool,
+}
+
+impl Mmap {
+    pub fn new_empty() -> Mmap {
+        Mmap {
+            memory: SendSyncPtr::from(&mut [][..]),
+            is_file: false,
+        }
+    }
+
+    pub fn new(size: usize) -> Result<Self> {
+        let ptr = unsafe {
+            VirtualAlloc(
+                ptr::null_mut(),
+                size,
+                MEM_RESERVE | MEM_COMMIT,
+                PAGE_READWRITE,
+            )
+        };
+        if ptr.is_null() {
+            bail!(io::Error::last_os_error())
+        }
+
+        let memory = std::ptr::slice_from_raw_parts_mut(ptr.cast(), size);
+        let memory = SendSyncPtr::new(NonNull::new(memory).unwrap());
+        Ok(Self {
+            memory,
+            is_file: false,
+        })
+    }
+
+    pub fn reserve(size: usize) -> Result<Self> {
+        let ptr = unsafe { VirtualAlloc(ptr::null_mut(), size, MEM_RESERVE, PAGE_NOACCESS) };
+        if ptr.is_null() {
+            bail!(io::Error::last_os_error())
+        }
+        let memory = std::ptr::slice_from_raw_parts_mut(ptr.cast(), size);
+        let memory = SendSyncPtr::new(NonNull::new(memory).unwrap());
+        Ok(Self {
+            memory,
+            is_file: false,
+        })
+    }
+
+    pub fn from_file(path: &Path) -> Result<(Self, File)> {
+        unsafe {
+            // Open the file with read/execute access and only share for
+            // read. This will enable us to perform the proper mmap below
+            // while also disallowing other processes modifying the file
+            // and having those modifications show up in our address space.
+            let file = OpenOptions::new()
+                .read(true)
+                .access_mode(FILE_GENERIC_READ | FILE_GENERIC_EXECUTE)
+                .share_mode(FILE_SHARE_READ)
+                .open(path)
+                .err2anyhow()
+                .context("failed to open file")?;
+
+            let len = file
+                .metadata()
+                .err2anyhow()
+                .context("failed to get file metadata")?
+                .len();
+            let len = usize::try_from(len).map_err(|_| anyhow!("file too large to map"))?;
+
+            // Create a file mapping that allows PAGE_EXECUTE_WRITECOPY.
+            // This enables up-to these permissions but we won't leave all
+            // of these permissions active at all times. Execution is
+            // necessary for the generated code from Cranelift and the
+            // WRITECOPY part is needed for possibly resolving relocations,
+            // but otherwise writes don't happen.
+            let mapping = CreateFileMappingW(
+                file.as_raw_handle() as isize,
+                ptr::null_mut(),
+                PAGE_EXECUTE_WRITECOPY,
+                0,
+                0,
+                ptr::null(),
+            );
+            if mapping == 0 {
+                return Err(io::Error::last_os_error().into_anyhow())
+                    .context("failed to create file mapping");
+            }
+
+            // Create a view for the entire file using all our requisite
+            // permissions so that we can change the virtual permissions
+            // later on.
+            let ptr = MapViewOfFile(
+                mapping,
+                FILE_MAP_READ | FILE_MAP_EXECUTE | FILE_MAP_COPY,
+                0,
+                0,
+                len,
+            )
+            .Value;
+            let err = io::Error::last_os_error();
+            CloseHandle(mapping);
+            if ptr.is_null() {
+                return Err(err.into_anyhow())
+                    .context(format!("failed to create map view of {:#x} bytes", len));
+            }
+
+            let memory = std::ptr::slice_from_raw_parts_mut(ptr.cast(), len);
+            let memory = SendSyncPtr::new(NonNull::new(memory).unwrap());
+            let mut ret = Self {
+                memory,
+                is_file: true,
+            };
+
+            // Protect the entire file as PAGE_WRITECOPY to start (i.e.
+            // remove the execute bit)
+            let mut old = 0;
+            if VirtualProtect(ret.as_mut_ptr().cast(), ret.len(), PAGE_WRITECOPY, &mut old) == 0 {
+                return Err(io::Error::last_os_error().into_anyhow())
+                    .context("failed change pages to `PAGE_READONLY`");
+            }
+
+            Ok((ret, file))
+        }
+    }
+
+    pub fn make_accessible(&mut self, start: usize, len: usize) -> Result<()> {
+        if unsafe {
+            VirtualAlloc(
+                self.as_ptr().add(start) as _,
+                len,
+                MEM_COMMIT,
+                PAGE_READWRITE,
+            )
+        }
+        .is_null()
+        {
+            bail!(io::Error::last_os_error())
+        }
+
+        Ok(())
+    }
+
+    #[inline]
+    pub fn as_ptr(&self) -> *const u8 {
+        self.memory.as_ptr() as *const u8
+    }
+
+    #[inline]
+    pub fn as_mut_ptr(&mut self) -> *mut u8 {
+        self.memory.as_ptr().cast()
+    }
+
+    #[inline]
+    pub fn len(&self) -> usize {
+        unsafe { (*self.memory.as_ptr()).len() }
+    }
+
+    pub unsafe fn make_executable(
+        &self,
+        range: Range<usize>,
+        enable_branch_protection: bool,
+    ) -> Result<()> {
+        let flags = if enable_branch_protection {
+            // TODO: We use this check to avoid an unused variable warning,
+            // but some of the CFG-related flags might be applicable
+            PAGE_EXECUTE_READ
+        } else {
+            PAGE_EXECUTE_READ
+        };
+        let mut old = 0;
+        let base = self.as_ptr().add(range.start);
+        let result = VirtualProtect(base as _, range.end - range.start, flags, &mut old);
+        if result == 0 {
+            bail!(io::Error::last_os_error());
+        }
+        Ok(())
+    }
+
+    pub unsafe fn make_readonly(&self, range: Range<usize>) -> Result<()> {
+        let mut old = 0;
+        let base = self.as_ptr().add(range.start);
+        let result = VirtualProtect(base as _, range.end - range.start, PAGE_READONLY, &mut old);
+        if result == 0 {
+            bail!(io::Error::last_os_error());
+        }
+        Ok(())
+    }
+}
+
+impl Drop for Mmap {
+    fn drop(&mut self) {
+        if self.len() == 0 {
+            return;
+        }
+
+        if self.is_file {
+            let r = unsafe {
+                UnmapViewOfFile(MEMORY_MAPPED_VIEW_ADDRESS {
+                    Value: self.as_mut_ptr().cast(),
+                })
+            };
+            assert_ne!(r, 0);
+        } else {
+            let r = unsafe { VirtualFree(self.as_mut_ptr().cast(), 0, MEM_RELEASE) };
+            assert_ne!(r, 0);
+        }
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/sys/windows/mod.rs b/crates/wasmtime/src/runtime/vm/sys/windows/mod.rs
new file mode 100644
index 000000000000..0ecc7295c99b
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/sys/windows/mod.rs
@@ -0,0 +1,20 @@
+//! Implementation of Wasmtime's system primitives for Windows.
+
+use std::cell::Cell;
+
+pub mod mmap;
+pub mod traphandlers;
+pub mod unwind;
+pub mod vm;
+
+std::thread_local!(static TLS: Cell<*mut u8> = const { Cell::new(std::ptr::null_mut()) });
+
+#[inline]
+pub fn tls_get() -> *mut u8 {
+    TLS.with(|p| p.get())
+}
+
+#[inline]
+pub fn tls_set(ptr: *mut u8) {
+    TLS.with(|p| p.set(ptr));
+}
diff --git a/crates/wasmtime/src/runtime/vm/sys/windows/traphandlers.rs b/crates/wasmtime/src/runtime/vm/sys/windows/traphandlers.rs
new file mode 100644
index 000000000000..69e1cb90fcb7
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/sys/windows/traphandlers.rs
@@ -0,0 +1,135 @@
+use crate::runtime::vm::traphandlers::{tls, TrapRegisters, TrapTest};
+use crate::runtime::vm::VMContext;
+use std::ffi::c_void;
+use std::io;
+use windows_sys::Win32::Foundation::*;
+use windows_sys::Win32::System::Diagnostics::Debug::*;
+use windows_sys::Win32::System::Kernel::*;
+
+#[link(name = "wasmtime-helpers")]
+extern "C" {
+    #[wasmtime_versioned_export_macros::versioned_link]
+    #[allow(improper_ctypes)]
+    pub fn wasmtime_setjmp(
+        jmp_buf: *mut *const u8,
+        callback: extern "C" fn(*mut u8, *mut VMContext),
+        payload: *mut u8,
+        callee: *mut VMContext,
+    ) -> i32;
+
+    #[wasmtime_versioned_export_macros::versioned_link]
+    pub fn wasmtime_longjmp(jmp_buf: *const u8) -> !;
+}
+
+/// Function which may handle custom signals while processing traps.
+pub type SignalHandler<'a> = dyn Fn(*mut EXCEPTION_POINTERS) -> bool + Send + Sync + 'a;
+
+pub struct TrapHandler {
+    handle: *mut c_void,
+}
+
+unsafe impl Send for TrapHandler {}
+unsafe impl Sync for TrapHandler {}
+
+impl TrapHandler {
+    pub unsafe fn new(_macos_use_mach_ports: bool) -> TrapHandler {
+        // 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 handle = AddVectoredExceptionHandler(1, Some(exception_handler));
+        if handle.is_null() {
+            panic!(
+                "failed to add exception handler: {}",
+                io::Error::last_os_error()
+            );
+        }
+        TrapHandler { handle }
+    }
+
+    pub fn validate_config(&self, _macos_use_mach_ports: bool) {}
+}
+
+impl Drop for TrapHandler {
+    fn drop(&mut self) {
+        unsafe {
+            let rc = RemoveVectoredExceptionHandler(self.handle);
+            if rc == 0 {
+                eprintln!(
+                    "failed to remove exception handler: {}",
+                    io::Error::last_os_error()
+                );
+                libc::abort();
+            }
+        }
+    }
+}
+
+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_INT_DIVIDE_BY_ZERO
+        && record.ExceptionCode != EXCEPTION_INT_OVERFLOW
+    {
+        return ExceptionContinueSearch;
+    }
+
+    // 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 ExceptionContinueSearch;
+    // }
+
+    // This is basically the same as the unix version above, only with a
+    // few parameters tweaked here and there.
+    tls::with(|info| {
+        let info = match info {
+            Some(info) => info,
+            None => return ExceptionContinueSearch,
+        };
+        let context = &*(*exception_info).ContextRecord;
+        cfg_if::cfg_if! {
+            if #[cfg(target_arch = "x86_64")] {
+                let regs = TrapRegisters {
+                    pc: context.Rip as usize,
+                    fp: context.Rbp as usize,
+                };
+            } else if #[cfg(target_arch = "aarch64")] {
+                let regs = TrapRegisters {
+                    pc: context.Pc as usize,
+                    fp: context.Anonymous.Anonymous.Fp as usize,
+                };
+            } else {
+                compile_error!("unsupported platform");
+            }
+        }
+        // For access violations the first element in `ExceptionInformation` is
+        // an indicator as to whether the fault was a read/write. The second
+        // element is the address of the inaccessible data causing this
+        // violation.
+        let faulting_addr = if record.ExceptionCode == EXCEPTION_ACCESS_VIOLATION {
+            assert!(record.NumberParameters >= 2);
+            Some(record.ExceptionInformation[1])
+        } else {
+            None
+        };
+        match info.test_if_trap(regs, faulting_addr, |handler| handler(exception_info)) {
+            TrapTest::NotWasm => ExceptionContinueSearch,
+            TrapTest::HandledByEmbedder => ExceptionContinueExecution,
+            TrapTest::Trap { jmp_buf } => wasmtime_longjmp(jmp_buf),
+        }
+    })
+}
+
+pub fn lazy_per_thread_init() {
+    // Unused on Windows
+}
diff --git a/crates/wasmtime/src/runtime/vm/sys/windows/unwind.rs b/crates/wasmtime/src/runtime/vm/sys/windows/unwind.rs
new file mode 100644
index 000000000000..eb559302bcd9
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/sys/windows/unwind.rs
@@ -0,0 +1,46 @@
+//! Module for Windows x64 ABI unwind registry.
+
+use crate::prelude::*;
+use std::mem;
+use windows_sys::Win32::System::Diagnostics::Debug::*;
+
+/// Represents a registry of function unwind information for Windows x64 ABI.
+pub struct UnwindRegistration {
+    functions: usize,
+}
+
+impl UnwindRegistration {
+    #[allow(missing_docs)]
+    pub const SECTION_NAME: &'static str = ".pdata";
+
+    #[allow(missing_docs)]
+    pub unsafe fn new(
+        base_address: *const u8,
+        unwind_info: *const u8,
+        unwind_len: usize,
+    ) -> Result<UnwindRegistration> {
+        assert!(unwind_info as usize % 4 == 0);
+        let unit_len = mem::size_of::<IMAGE_RUNTIME_FUNCTION_ENTRY>();
+        assert!(unwind_len % unit_len == 0);
+        if RtlAddFunctionTable(
+            unwind_info as *mut _,
+            (unwind_len / unit_len) as u32,
+            base_address as _,
+        ) == 0
+        {
+            bail!("failed to register function table");
+        }
+
+        Ok(UnwindRegistration {
+            functions: unwind_info as usize,
+        })
+    }
+}
+
+impl Drop for UnwindRegistration {
+    fn drop(&mut self) {
+        unsafe {
+            RtlDeleteFunctionTable(self.functions as _);
+        }
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/sys/windows/vm.rs b/crates/wasmtime/src/runtime/vm/sys/windows/vm.rs
new file mode 100644
index 000000000000..c4a3dd9f0634
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/sys/windows/vm.rs
@@ -0,0 +1,75 @@
+use crate::vm::sys::DecommitBehavior;
+use std::fs::File;
+use std::io;
+use std::mem::MaybeUninit;
+use std::sync::Arc;
+use windows_sys::Win32::System::Memory::*;
+use windows_sys::Win32::System::SystemInformation::*;
+
+pub unsafe fn expose_existing_mapping(ptr: *mut u8, len: usize) -> io::Result<()> {
+    if len == 0 {
+        return Ok(());
+    }
+    if VirtualAlloc(ptr.cast(), len, MEM_COMMIT, PAGE_READWRITE).is_null() {
+        Err(std::io::Error::last_os_error())
+    } else {
+        Ok(())
+    }
+}
+
+pub unsafe fn hide_existing_mapping(ptr: *mut u8, len: usize) -> io::Result<()> {
+    erase_existing_mapping(ptr, len)
+}
+
+pub unsafe fn erase_existing_mapping(ptr: *mut u8, len: usize) -> io::Result<()> {
+    if len == 0 {
+        return Ok(());
+    }
+    if VirtualFree(ptr.cast(), len, MEM_DECOMMIT) == 0 {
+        Err(std::io::Error::last_os_error())
+    } else {
+        Ok(())
+    }
+}
+
+#[cfg(feature = "pooling-allocator")]
+pub unsafe fn commit_pages(addr: *mut u8, len: usize) -> io::Result<()> {
+    expose_existing_mapping(addr, len)
+}
+
+pub unsafe fn decommit_pages(addr: *mut u8, len: usize) -> io::Result<()> {
+    erase_existing_mapping(addr, len)
+}
+
+pub fn get_page_size() -> usize {
+    unsafe {
+        let mut info = MaybeUninit::uninit();
+        GetSystemInfo(info.as_mut_ptr());
+        info.assume_init_ref().dwPageSize as usize
+    }
+}
+
+pub fn decommit_behavior() -> DecommitBehavior {
+    DecommitBehavior::Zero
+}
+
+#[derive(PartialEq, Debug)]
+pub enum MemoryImageSource {}
+
+impl MemoryImageSource {
+    pub fn from_file(_file: &Arc<File>) -> Option<MemoryImageSource> {
+        None
+    }
+
+    pub fn from_data(_data: &[u8]) -> io::Result<Option<MemoryImageSource>> {
+        Ok(None)
+    }
+
+    pub unsafe fn map_at(&self, _base: *mut u8, _len: usize, _offset: u64) -> io::Result<()> {
+        match *self {}
+    }
+
+    pub unsafe fn remap_as_zeros_at(&self, _base: *mut u8, _len: usize) -> io::Result<()> {
+        match *self {}
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/table.rs b/crates/wasmtime/src/runtime/vm/table.rs
new file mode 100644
index 000000000000..0e3b566326f7
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/table.rs
@@ -0,0 +1,898 @@
+//! Memory management for tables.
+//!
+//! `Table` is to WebAssembly tables what `LinearMemory` is to WebAssembly linear memories.
+
+#![cfg_attr(feature = "gc", allow(irrefutable_let_patterns))]
+
+use crate::prelude::*;
+use crate::runtime::vm::vmcontext::{VMFuncRef, VMTableDefinition};
+use crate::runtime::vm::{GcStore, SendSyncPtr, Store, VMGcRef};
+use core::cmp;
+use core::ops::Range;
+use core::ptr::{self, NonNull};
+use core::slice;
+use sptr::Strict;
+use wasmtime_environ::{
+    TablePlan, TableStyle, Trap, WasmHeapTopType, WasmRefType, FUNCREF_INIT_BIT, FUNCREF_MASK,
+};
+
+/// An element going into or coming out of a table.
+///
+/// Table elements are stored as pointers and are default-initialized with
+/// `ptr::null_mut`.
+pub enum TableElement {
+    /// A `funcref`.
+    FuncRef(*mut VMFuncRef),
+
+    /// A GC reference.
+    GcRef(Option<VMGcRef>),
+
+    /// An uninitialized funcref value. This should never be exposed
+    /// beyond the `wasmtime` crate boundary; the upper-level code
+    /// (which has access to the info needed for lazy initialization)
+    /// will replace it when fetched.
+    UninitFunc,
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub enum TableElementType {
+    Func,
+    GcRef,
+}
+
+impl TableElementType {
+    fn matches(&self, val: &TableElement) -> bool {
+        match (val, self) {
+            (TableElement::FuncRef(_), TableElementType::Func) => true,
+            (TableElement::GcRef(_), TableElementType::GcRef) => true,
+            _ => false,
+        }
+    }
+}
+
+// The usage of `*mut VMFuncRef` is safe w.r.t. thread safety, this just relies
+// on thread-safety of `VMGcRef` itself.
+unsafe impl Send for TableElement where VMGcRef: Send {}
+unsafe impl Sync for TableElement where VMGcRef: Sync {}
+
+impl TableElement {
+    /// Consumes a table element into a pointer/reference, as it
+    /// exists outside the table itself. This strips off any tag bits
+    /// or other information that only lives inside the table.
+    ///
+    /// Can only be done to an initialized table element; lazy init
+    /// must occur first. (In other words, lazy values do not survive
+    /// beyond the table, as every table read path initializes them.)
+    ///
+    /// # Safety
+    ///
+    /// The same warnings as for `into_table_values()` apply.
+    pub(crate) unsafe fn into_func_ref_asserting_initialized(self) -> *mut VMFuncRef {
+        match self {
+            Self::FuncRef(e) => e,
+            Self::UninitFunc => panic!("Uninitialized table element value outside of table slot"),
+            Self::GcRef(_) => panic!("GC reference is not a function reference"),
+        }
+    }
+
+    /// Indicates whether this value is the "uninitialized element"
+    /// value.
+    pub(crate) fn is_uninit(&self) -> bool {
+        match self {
+            Self::UninitFunc => true,
+            _ => false,
+        }
+    }
+}
+
+impl From<*mut VMFuncRef> for TableElement {
+    fn from(f: *mut VMFuncRef) -> TableElement {
+        TableElement::FuncRef(f)
+    }
+}
+
+impl From<Option<VMGcRef>> for TableElement {
+    fn from(x: Option<VMGcRef>) -> TableElement {
+        TableElement::GcRef(x)
+    }
+}
+
+impl From<VMGcRef> for TableElement {
+    fn from(x: VMGcRef) -> TableElement {
+        TableElement::GcRef(Some(x))
+    }
+}
+
+#[derive(Copy, Clone)]
+#[repr(transparent)]
+struct TaggedFuncRef(*mut VMFuncRef);
+
+impl TaggedFuncRef {
+    const UNINIT: TaggedFuncRef = TaggedFuncRef(ptr::null_mut());
+
+    /// Converts the given `ptr`, a valid funcref pointer, into a tagged pointer
+    /// by adding in the `FUNCREF_INIT_BIT`.
+    fn from(ptr: *mut VMFuncRef, lazy_init: bool) -> Self {
+        if lazy_init {
+            let masked = Strict::map_addr(ptr, |a| a | FUNCREF_INIT_BIT);
+            TaggedFuncRef(masked)
+        } else {
+            TaggedFuncRef(ptr)
+        }
+    }
+
+    /// Converts a tagged pointer into a `TableElement`, returning `UninitFunc`
+    /// for null (not a tagged value) or `FuncRef` for otherwise tagged values.
+    fn into_table_element(self, lazy_init: bool) -> TableElement {
+        let ptr = self.0;
+        if lazy_init && ptr.is_null() {
+            TableElement::UninitFunc
+        } else {
+            // Masking off the tag bit is harmless whether the table uses lazy
+            // init or not.
+            let unmasked = Strict::map_addr(ptr, |a| a & FUNCREF_MASK);
+            TableElement::FuncRef(unmasked)
+        }
+    }
+}
+
+pub type FuncTableElem = Option<SendSyncPtr<VMFuncRef>>;
+
+pub enum StaticTable {
+    Func(StaticFuncTable),
+    GcRef(StaticGcRefTable),
+}
+
+impl From<StaticFuncTable> for StaticTable {
+    fn from(value: StaticFuncTable) -> Self {
+        Self::Func(value)
+    }
+}
+
+impl From<StaticGcRefTable> for StaticTable {
+    fn from(value: StaticGcRefTable) -> Self {
+        Self::GcRef(value)
+    }
+}
+
+pub struct StaticFuncTable {
+    /// Where data for this table is stored. The length of this list is the
+    /// maximum size of the table.
+    data: SendSyncPtr<[FuncTableElem]>,
+    /// The current size of the table.
+    size: u32,
+    /// Whether elements of this table are initialized lazily.
+    lazy_init: bool,
+}
+
+pub struct StaticGcRefTable {
+    /// Where data for this table is stored. The length of this list is the
+    /// maximum size of the table.
+    data: SendSyncPtr<[Option<VMGcRef>]>,
+    /// The current size of the table.
+    size: u32,
+}
+
+pub enum DynamicTable {
+    Func(DynamicFuncTable),
+    GcRef(DynamicGcRefTable),
+}
+
+impl From<DynamicFuncTable> for DynamicTable {
+    fn from(value: DynamicFuncTable) -> Self {
+        Self::Func(value)
+    }
+}
+
+impl From<DynamicGcRefTable> for DynamicTable {
+    fn from(value: DynamicGcRefTable) -> Self {
+        Self::GcRef(value)
+    }
+}
+
+pub struct DynamicFuncTable {
+    /// Dynamically managed storage space for this table. The length of this
+    /// vector is the current size of the table.
+    elements: Vec<FuncTableElem>,
+    /// Maximum size that `elements` can grow to.
+    maximum: Option<u32>,
+    /// Whether elements of this table are initialized lazily.
+    lazy_init: bool,
+}
+
+pub struct DynamicGcRefTable {
+    /// Dynamically managed storage space for this table. The length of this
+    /// vector is the current size of the table.
+    elements: Vec<Option<VMGcRef>>,
+    /// Maximum size that `elements` can grow to.
+    maximum: Option<u32>,
+}
+
+/// Represents an instance's table.
+pub enum Table {
+    /// A "static" table where storage space is managed externally, currently
+    /// used with the pooling allocator.
+    Static(StaticTable),
+    /// A "dynamic" table where table storage space is dynamically allocated via
+    /// `malloc` (aka Rust's `Vec`).
+    Dynamic(DynamicTable),
+}
+
+impl From<StaticTable> for Table {
+    fn from(value: StaticTable) -> Self {
+        Self::Static(value)
+    }
+}
+
+impl From<StaticFuncTable> for Table {
+    fn from(value: StaticFuncTable) -> Self {
+        let t: StaticTable = value.into();
+        t.into()
+    }
+}
+
+impl From<StaticGcRefTable> for Table {
+    fn from(value: StaticGcRefTable) -> Self {
+        let t: StaticTable = value.into();
+        t.into()
+    }
+}
+
+impl From<DynamicTable> for Table {
+    fn from(value: DynamicTable) -> Self {
+        Self::Dynamic(value)
+    }
+}
+
+impl From<DynamicFuncTable> for Table {
+    fn from(value: DynamicFuncTable) -> Self {
+        let t: DynamicTable = value.into();
+        t.into()
+    }
+}
+
+impl From<DynamicGcRefTable> for Table {
+    fn from(value: DynamicGcRefTable) -> Self {
+        let t: DynamicTable = value.into();
+        t.into()
+    }
+}
+
+fn wasm_to_table_type(ty: WasmRefType) -> TableElementType {
+    match ty.heap_type.top() {
+        WasmHeapTopType::Func => TableElementType::Func,
+        WasmHeapTopType::Any | WasmHeapTopType::Extern => TableElementType::GcRef,
+    }
+}
+
+impl Table {
+    /// Create a new dynamic (movable) table instance for the specified table plan.
+    pub fn new_dynamic(plan: &TablePlan, store: &mut dyn Store) -> Result<Self> {
+        Self::limit_new(plan, store)?;
+        let TableStyle::CallerChecksSignature { lazy_init } = plan.style;
+        match wasm_to_table_type(plan.table.wasm_ty) {
+            TableElementType::Func => Ok(Self::from(DynamicFuncTable {
+                elements: vec![None; usize::try_from(plan.table.minimum).unwrap()],
+                maximum: plan.table.maximum,
+                lazy_init,
+            })),
+            TableElementType::GcRef => Ok(Self::from(DynamicGcRefTable {
+                elements: (0..usize::try_from(plan.table.minimum).unwrap())
+                    .map(|_| None)
+                    .collect(),
+                maximum: plan.table.maximum,
+            })),
+        }
+    }
+
+    /// Create a new static (immovable) table instance for the specified table plan.
+    pub unsafe fn new_static(
+        plan: &TablePlan,
+        data: SendSyncPtr<[u8]>,
+        store: &mut dyn Store,
+    ) -> Result<Self> {
+        Self::limit_new(plan, store)?;
+
+        let size = plan.table.minimum;
+        let max = plan
+            .table
+            .maximum
+            .map_or(usize::MAX, |x| usize::try_from(x).unwrap());
+
+        match wasm_to_table_type(plan.table.wasm_ty) {
+            TableElementType::Func => {
+                let len = {
+                    let data = data.as_non_null().as_ref();
+                    let (before, data, after) = data.align_to::<FuncTableElem>();
+                    assert!(before.is_empty());
+                    assert!(after.is_empty());
+                    data.len()
+                };
+                ensure!(
+                    usize::try_from(plan.table.minimum).unwrap() <= len,
+                    "initial table size of {} exceeds the pooling allocator's \
+                     configured maximum table size of {len} elements",
+                    plan.table.minimum,
+                );
+                let data = SendSyncPtr::new(NonNull::slice_from_raw_parts(
+                    data.as_non_null().cast::<FuncTableElem>(),
+                    cmp::min(len, max),
+                ));
+                let TableStyle::CallerChecksSignature { lazy_init } = plan.style;
+                Ok(Self::from(StaticFuncTable {
+                    data,
+                    size,
+                    lazy_init,
+                }))
+            }
+            TableElementType::GcRef => {
+                let len = {
+                    let data = data.as_non_null().as_ref();
+                    let (before, data, after) = data.align_to::<Option<VMGcRef>>();
+                    assert!(before.is_empty());
+                    assert!(after.is_empty());
+                    data.len()
+                };
+                ensure!(
+                    usize::try_from(plan.table.minimum).unwrap() <= len,
+                    "initial table size of {} exceeds the pooling allocator's \
+                     configured maximum table size of {len} elements",
+                    plan.table.minimum,
+                );
+                let data = SendSyncPtr::new(NonNull::slice_from_raw_parts(
+                    data.as_non_null().cast::<Option<VMGcRef>>(),
+                    cmp::min(len, max),
+                ));
+                Ok(Self::from(StaticGcRefTable { data, size }))
+            }
+        }
+    }
+
+    fn limit_new(plan: &TablePlan, store: &mut dyn Store) -> Result<()> {
+        if !store.table_growing(0, plan.table.minimum, plan.table.maximum)? {
+            bail!(
+                "table minimum size of {} elements exceeds table limits",
+                plan.table.minimum
+            );
+        }
+        Ok(())
+    }
+
+    /// Returns the type of the elements in this table.
+    pub fn element_type(&self) -> TableElementType {
+        match self {
+            Table::Static(StaticTable::Func(_)) | Table::Dynamic(DynamicTable::Func(_)) => {
+                TableElementType::Func
+            }
+            Table::Static(StaticTable::GcRef(_)) | Table::Dynamic(DynamicTable::GcRef(_)) => {
+                TableElementType::GcRef
+            }
+        }
+    }
+
+    /// Returns whether or not the underlying storage of the table is "static".
+    #[cfg(feature = "pooling-allocator")]
+    pub(crate) fn is_static(&self) -> bool {
+        matches!(self, Table::Static(_))
+    }
+
+    /// Returns the number of allocated elements.
+    pub fn size(&self) -> u32 {
+        match self {
+            Table::Static(StaticTable::Func(StaticFuncTable { size, .. })) => *size,
+            Table::Static(StaticTable::GcRef(StaticGcRefTable { size, .. })) => *size,
+            Table::Dynamic(DynamicTable::Func(DynamicFuncTable { elements, .. })) => {
+                elements.len().try_into().unwrap()
+            }
+            Table::Dynamic(DynamicTable::GcRef(DynamicGcRefTable { elements, .. })) => {
+                elements.len().try_into().unwrap()
+            }
+        }
+    }
+
+    /// Returns the maximum number of elements at runtime.
+    ///
+    /// Returns `None` if the table is unbounded.
+    ///
+    /// The runtime maximum may not be equal to the maximum from the table's Wasm type
+    /// when it is being constrained by an instance allocator.
+    pub fn maximum(&self) -> Option<u32> {
+        match self {
+            Table::Static(StaticTable::Func(StaticFuncTable { data, .. })) => {
+                Some(u32::try_from(data.len()).unwrap())
+            }
+            Table::Static(StaticTable::GcRef(StaticGcRefTable { data, .. })) => {
+                Some(u32::try_from(data.len()).unwrap())
+            }
+            Table::Dynamic(DynamicTable::Func(DynamicFuncTable { maximum, .. })) => *maximum,
+            Table::Dynamic(DynamicTable::GcRef(DynamicGcRefTable { maximum, .. })) => *maximum,
+        }
+    }
+
+    /// Initializes the contents of this table to the specified function
+    ///
+    /// # Panics
+    ///
+    /// Panics if the table is not a function table.
+    pub fn init_func(
+        &mut self,
+        dst: u32,
+        items: impl ExactSizeIterator<Item = *mut VMFuncRef>,
+    ) -> Result<(), Trap> {
+        let dst = usize::try_from(dst).map_err(|_| Trap::TableOutOfBounds)?;
+
+        let (funcrefs, lazy_init) = self.funcrefs_mut();
+        let elements = funcrefs
+            .get_mut(dst..)
+            .and_then(|s| s.get_mut(..items.len()))
+            .ok_or(Trap::TableOutOfBounds)?;
+
+        for (item, slot) in items.zip(elements) {
+            *slot = TaggedFuncRef::from(item, lazy_init);
+        }
+        Ok(())
+    }
+
+    /// Fill `table[dst..]` with values from `items`
+    ///
+    /// Returns a trap error on out-of-bounds accesses.
+    pub fn init_gc_refs(
+        &mut self,
+        dst: u32,
+        items: impl ExactSizeIterator<Item = Option<VMGcRef>>,
+    ) -> Result<(), Trap> {
+        let dst = usize::try_from(dst).map_err(|_| Trap::TableOutOfBounds)?;
+
+        let elements = self
+            .gc_refs_mut()
+            .get_mut(dst..)
+            .and_then(|s| s.get_mut(..items.len()))
+            .ok_or(Trap::TableOutOfBounds)?;
+
+        for (item, slot) in items.zip(elements) {
+            *slot = item;
+        }
+        Ok(())
+    }
+
+    /// Fill `table[dst..dst + len]` with `val`.
+    ///
+    /// Returns a trap error on out-of-bounds accesses.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `val` does not have a type that matches this table.
+    pub fn fill(
+        &mut self,
+        gc_store: &mut GcStore,
+        dst: u32,
+        val: TableElement,
+        len: u32,
+    ) -> Result<(), Trap> {
+        let start = dst as usize;
+        let end = start
+            .checked_add(len as usize)
+            .ok_or_else(|| Trap::TableOutOfBounds)?;
+
+        if end > self.size() as usize {
+            return Err(Trap::TableOutOfBounds);
+        }
+
+        match val {
+            TableElement::FuncRef(f) => {
+                let (funcrefs, lazy_init) = self.funcrefs_mut();
+                funcrefs[start..end].fill(TaggedFuncRef::from(f, lazy_init));
+            }
+            TableElement::GcRef(r) => {
+                // Clone the init GC reference into each table slot.
+                for slot in &mut self.gc_refs_mut()[start..end] {
+                    gc_store.write_gc_ref(slot, r.as_ref());
+                }
+
+                // Drop the init GC reference, since we aren't holding onto this
+                // reference anymore, only the clones in the table.
+                if let Some(r) = r {
+                    gc_store.drop_gc_ref(r);
+                }
+            }
+            TableElement::UninitFunc => {
+                let (funcrefs, _lazy_init) = self.funcrefs_mut();
+                funcrefs[start..end].fill(TaggedFuncRef::UNINIT);
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Grow table by the specified amount of elements.
+    ///
+    /// Returns the previous size of the table if growth is successful.
+    ///
+    /// Returns `None` if table can't be grown by the specified amount of
+    /// elements, or if the `init_value` is the wrong kind of table element.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `init_value` does not have a type that matches this table.
+    ///
+    /// # Unsafety
+    ///
+    /// Resizing the table can reallocate its internal elements buffer. This
+    /// table's instance's `VMContext` has raw pointers to the elements buffer
+    /// that are used by Wasm, and they need to be fixed up before we call into
+    /// Wasm again. Failure to do so will result in use-after-free inside Wasm.
+    ///
+    /// Generally, prefer using `InstanceHandle::table_grow`, which encapsulates
+    /// this unsafety.
+    pub unsafe fn grow(
+        &mut self,
+        delta: u32,
+        init_value: TableElement,
+        store: &mut dyn Store,
+    ) -> Result<Option<u32>, Error> {
+        let old_size = self.size();
+
+        // Don't try to resize the table if its size isn't changing, just return
+        // success.
+        if delta == 0 {
+            return Ok(Some(old_size));
+        }
+
+        let new_size = match old_size.checked_add(delta) {
+            Some(s) => s,
+            None => {
+                store.table_grow_failed(format_err!("overflow calculating new table size"))?;
+                return Ok(None);
+            }
+        };
+
+        if !store.table_growing(old_size, new_size, self.maximum())? {
+            return Ok(None);
+        }
+
+        // The WebAssembly spec requires failing a `table.grow` request if
+        // it exceeds the declared limits of the table. We may have set lower
+        // limits in the instance allocator as well.
+        if let Some(max) = self.maximum() {
+            if new_size > max {
+                store.table_grow_failed(format_err!("Table maximum size exceeded"))?;
+                return Ok(None);
+            }
+        }
+
+        debug_assert!(self.type_matches(&init_value));
+
+        // First resize the storage and then fill with the init value
+        match self {
+            Table::Static(StaticTable::Func(StaticFuncTable { data, size, .. })) => {
+                unsafe {
+                    debug_assert!(data.as_ref()[*size as usize..new_size as usize]
+                        .iter()
+                        .all(|x| x.is_none()));
+                }
+                *size = new_size;
+            }
+            Table::Static(StaticTable::GcRef(StaticGcRefTable { data, size })) => {
+                unsafe {
+                    debug_assert!(data.as_ref()[*size as usize..new_size as usize]
+                        .iter()
+                        .all(|x| x.is_none()));
+                }
+                *size = new_size;
+            }
+
+            // These calls to `resize` could move the base address of
+            // `elements`. If this table's limits declare it to be fixed-size,
+            // then during AOT compilation we may have promised Cranelift that
+            // the table base address won't change, so it is allowed to optimize
+            // loading the base address. However, in that case the above checks
+            // that delta is non-zero and the new size doesn't exceed the
+            // maximum mean we can't get here.
+            Table::Dynamic(DynamicTable::Func(DynamicFuncTable { elements, .. })) => {
+                elements.resize(usize::try_from(new_size).unwrap(), None);
+            }
+            Table::Dynamic(DynamicTable::GcRef(DynamicGcRefTable { elements, .. })) => {
+                elements.resize_with(usize::try_from(new_size).unwrap(), || None);
+            }
+        }
+
+        self.fill(store.gc_store(), old_size, init_value, delta)
+            .expect("table should not be out of bounds");
+
+        Ok(Some(old_size))
+    }
+
+    /// Get reference to the specified element.
+    ///
+    /// Returns `None` if the index is out of bounds.
+    pub fn get(&self, gc_store: &mut GcStore, index: u32) -> Option<TableElement> {
+        let index = usize::try_from(index).ok()?;
+        match self.element_type() {
+            TableElementType::Func => {
+                let (funcrefs, lazy_init) = self.funcrefs();
+                funcrefs
+                    .get(index)
+                    .copied()
+                    .map(|e| e.into_table_element(lazy_init))
+            }
+            TableElementType::GcRef => self.gc_refs().get(index).map(|r| {
+                let r = r.as_ref().map(|r| gc_store.clone_gc_ref(r));
+                TableElement::GcRef(r)
+            }),
+        }
+    }
+
+    /// Set reference to the specified element.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if `index` is out of bounds or if this table type does
+    /// not match the element type.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `elem` is not of the right type for this table.
+    pub fn set(&mut self, index: u32, elem: TableElement) -> Result<(), ()> {
+        let index = usize::try_from(index).map_err(|_| ())?;
+        match elem {
+            TableElement::FuncRef(f) => {
+                let (funcrefs, lazy_init) = self.funcrefs_mut();
+                *funcrefs.get_mut(index).ok_or(())? = TaggedFuncRef::from(f, lazy_init);
+            }
+            TableElement::UninitFunc => {
+                let (funcrefs, _lazy_init) = self.funcrefs_mut();
+                *funcrefs.get_mut(index).ok_or(())? = TaggedFuncRef::UNINIT;
+            }
+            TableElement::GcRef(e) => {
+                *self.gc_refs_mut().get_mut(index).ok_or(())? = e;
+            }
+        }
+        Ok(())
+    }
+
+    /// Copy `len` elements from `src_table[src_index..]` into `dst_table[dst_index..]`.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the range is out of bounds of either the source or
+    /// destination tables.
+    pub unsafe fn copy(
+        gc_store: &mut GcStore,
+        dst_table: *mut Self,
+        src_table: *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 > (*src_table).size())
+            || dst_index
+                .checked_add(len)
+                .map_or(true, |m| m > (*dst_table).size())
+        {
+            return Err(Trap::TableOutOfBounds);
+        }
+
+        debug_assert!(
+            (*dst_table).element_type() == (*src_table).element_type(),
+            "table element type mismatch"
+        );
+
+        let src_range = src_index as usize..src_index as usize + len as usize;
+        let dst_range = dst_index as usize..dst_index as usize + len as usize;
+
+        // Check if the tables are the same as we cannot mutably borrow and also borrow the same `RefCell`
+        if ptr::eq(dst_table, src_table) {
+            (*dst_table).copy_elements_within(gc_store, dst_range, src_range);
+        } else {
+            Self::copy_elements(gc_store, &mut *dst_table, &*src_table, dst_range, src_range);
+        }
+
+        Ok(())
+    }
+
+    /// Return a `VMTableDefinition` for exposing the table to compiled wasm code.
+    pub fn vmtable(&mut self) -> VMTableDefinition {
+        match self {
+            Table::Static(StaticTable::Func(StaticFuncTable { data, size, .. })) => {
+                VMTableDefinition {
+                    base: data.as_ptr().cast(),
+                    current_elements: *size,
+                }
+            }
+            Table::Static(StaticTable::GcRef(StaticGcRefTable { data, size })) => {
+                VMTableDefinition {
+                    base: data.as_ptr().cast(),
+                    current_elements: *size,
+                }
+            }
+            Table::Dynamic(DynamicTable::Func(DynamicFuncTable { elements, .. })) => {
+                VMTableDefinition {
+                    base: elements.as_mut_ptr().cast(),
+                    current_elements: elements.len().try_into().unwrap(),
+                }
+            }
+            Table::Dynamic(DynamicTable::GcRef(DynamicGcRefTable { elements, .. })) => {
+                VMTableDefinition {
+                    base: elements.as_mut_ptr().cast(),
+                    current_elements: elements.len().try_into().unwrap(),
+                }
+            }
+        }
+    }
+
+    fn type_matches(&self, val: &TableElement) -> bool {
+        self.element_type().matches(val)
+    }
+
+    fn funcrefs(&self) -> (&[TaggedFuncRef], bool) {
+        assert_eq!(self.element_type(), TableElementType::Func);
+        match self {
+            Self::Dynamic(DynamicTable::Func(DynamicFuncTable {
+                elements,
+                lazy_init,
+                ..
+            })) => (
+                unsafe { slice::from_raw_parts(elements.as_ptr().cast(), elements.len()) },
+                *lazy_init,
+            ),
+            Self::Static(StaticTable::Func(StaticFuncTable {
+                data,
+                size,
+                lazy_init,
+            })) => (
+                unsafe {
+                    slice::from_raw_parts(data.as_ptr().cast(), usize::try_from(*size).unwrap())
+                },
+                *lazy_init,
+            ),
+            _ => unreachable!(),
+        }
+    }
+
+    fn funcrefs_mut(&mut self) -> (&mut [TaggedFuncRef], bool) {
+        assert_eq!(self.element_type(), TableElementType::Func);
+        match self {
+            Self::Dynamic(DynamicTable::Func(DynamicFuncTable {
+                elements,
+                lazy_init,
+                ..
+            })) => (
+                unsafe { slice::from_raw_parts_mut(elements.as_mut_ptr().cast(), elements.len()) },
+                *lazy_init,
+            ),
+            Self::Static(StaticTable::Func(StaticFuncTable {
+                data,
+                size,
+                lazy_init,
+            })) => (
+                unsafe {
+                    slice::from_raw_parts_mut(data.as_ptr().cast(), usize::try_from(*size).unwrap())
+                },
+                *lazy_init,
+            ),
+            _ => unreachable!(),
+        }
+    }
+
+    fn gc_refs(&self) -> &[Option<VMGcRef>] {
+        assert_eq!(self.element_type(), TableElementType::GcRef);
+        match self {
+            Self::Dynamic(DynamicTable::GcRef(DynamicGcRefTable { elements, .. })) => elements,
+            Self::Static(StaticTable::GcRef(StaticGcRefTable { data, size })) => unsafe {
+                &data.as_non_null().as_ref()[..usize::try_from(*size).unwrap()]
+            },
+            _ => unreachable!(),
+        }
+    }
+
+    /// Get this table's GC references as a slice.
+    ///
+    /// Panics if this is not a table of GC references.
+    pub fn gc_refs_mut(&mut self) -> &mut [Option<VMGcRef>] {
+        assert_eq!(self.element_type(), TableElementType::GcRef);
+        match self {
+            Self::Dynamic(DynamicTable::GcRef(DynamicGcRefTable { elements, .. })) => elements,
+            Self::Static(StaticTable::GcRef(StaticGcRefTable { data, size })) => unsafe {
+                &mut data.as_non_null().as_mut()[..usize::try_from(*size).unwrap()]
+            },
+            _ => unreachable!(),
+        }
+    }
+
+    fn copy_elements(
+        gc_store: &mut GcStore,
+        dst_table: &mut Self,
+        src_table: &Self,
+        dst_range: Range<usize>,
+        src_range: Range<usize>,
+    ) {
+        // This can only be used when copying between different tables
+        debug_assert!(!ptr::eq(dst_table, src_table));
+
+        let ty = dst_table.element_type();
+
+        match ty {
+            TableElementType::Func => {
+                // `funcref` are `Copy`, so just do a mempcy
+                let (dst_funcrefs, _lazy_init) = dst_table.funcrefs_mut();
+                let (src_funcrefs, _lazy_init) = src_table.funcrefs();
+                dst_funcrefs[dst_range].copy_from_slice(&src_funcrefs[src_range]);
+            }
+            TableElementType::GcRef => {
+                assert_eq!(
+                    dst_range.end - dst_range.start,
+                    src_range.end - src_range.start
+                );
+                assert!(dst_range.end <= dst_table.gc_refs().len());
+                assert!(src_range.end <= src_table.gc_refs().len());
+                for (dst, src) in dst_range.zip(src_range) {
+                    gc_store.write_gc_ref(
+                        &mut dst_table.gc_refs_mut()[dst],
+                        src_table.gc_refs()[src].as_ref(),
+                    );
+                }
+            }
+        }
+    }
+
+    fn copy_elements_within(
+        &mut self,
+        gc_store: &mut GcStore,
+        dst_range: Range<usize>,
+        src_range: Range<usize>,
+    ) {
+        assert_eq!(
+            dst_range.end - dst_range.start,
+            src_range.end - src_range.start
+        );
+
+        // This is a no-op.
+        if src_range.start == dst_range.start {
+            return;
+        }
+
+        let ty = self.element_type();
+        match ty {
+            TableElementType::Func => {
+                // `funcref` are `Copy`, so just do a memmove
+                let (funcrefs, _lazy_init) = self.funcrefs_mut();
+                funcrefs.copy_within(src_range, dst_range.start);
+            }
+            TableElementType::GcRef => {
+                // We need to clone each `externref` while handling overlapping
+                // ranges
+                let elements = self.gc_refs_mut();
+                if dst_range.start < src_range.start {
+                    for (d, s) in dst_range.zip(src_range) {
+                        let (ds, ss) = elements.split_at_mut(s);
+                        let dst = &mut ds[d];
+                        let src = ss[0].as_ref();
+                        gc_store.write_gc_ref(dst, src);
+                    }
+                } else {
+                    for (s, d) in src_range.rev().zip(dst_range.rev()) {
+                        let (ss, ds) = elements.split_at_mut(d);
+                        let dst = &mut ds[0];
+                        let src = ss[s].as_ref();
+                        gc_store.write_gc_ref(dst, src);
+                    }
+                }
+            }
+        }
+    }
+}
+
+// The default table representation is an empty funcref table that cannot grow.
+impl Default for Table {
+    fn default() -> Self {
+        Self::from(StaticFuncTable {
+            data: SendSyncPtr::new(NonNull::from(&mut [])),
+            size: 0,
+            lazy_init: false,
+        })
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/threads/mod.rs b/crates/wasmtime/src/runtime/vm/threads/mod.rs
new file mode 100644
index 000000000000..dad96f471870
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/threads/mod.rs
@@ -0,0 +1,12 @@
+#[cfg(feature = "threads")]
+mod parking_spot;
+
+#[cfg(feature = "threads")]
+mod shared_memory;
+#[cfg(feature = "threads")]
+pub use shared_memory::SharedMemory;
+
+#[cfg(not(feature = "threads"))]
+mod shared_memory_disabled;
+#[cfg(not(feature = "threads"))]
+pub use shared_memory_disabled::SharedMemory;
diff --git a/crates/wasmtime/src/runtime/vm/threads/parking_spot.rs b/crates/wasmtime/src/runtime/vm/threads/parking_spot.rs
new file mode 100644
index 000000000000..0de3260fc8f7
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/threads/parking_spot.rs
@@ -0,0 +1,623 @@
+//! Implements thread wait and notify primitives with `std::sync` primitives.
+//!
+//! This is a simplified version of the `parking_lot_core` crate.
+//!
+//! There are two main operations that can be performed:
+//!
+//! - *Parking* refers to suspending the thread while simultaneously enqueuing it
+//!   on a queue keyed by some address.
+//! - *Unparking* refers to dequeuing a thread from a queue keyed by some address
+//!   and resuming it.
+
+#![deny(missing_docs)]
+
+use crate::prelude::*;
+use crate::runtime::vm::{SendSyncPtr, WaitResult};
+use std::collections::BTreeMap;
+use std::ptr::NonNull;
+use std::sync::atomic::{AtomicU32, AtomicU64, Ordering::SeqCst};
+use std::sync::Mutex;
+use std::thread::{self, Thread};
+use std::time::{Duration, Instant};
+
+#[derive(Default, Debug)]
+struct Spot {
+    head: Option<SendSyncPtr<WaiterInner>>,
+    tail: Option<SendSyncPtr<WaiterInner>>,
+}
+
+/// The thread global `ParkingSpot`.
+#[derive(Default, Debug)]
+pub struct ParkingSpot {
+    inner: Mutex<BTreeMap<u64, Spot>>,
+}
+
+#[derive(Default)]
+pub struct Waiter {
+    inner: Option<Box<WaiterInner>>,
+}
+
+struct WaiterInner {
+    // NB: this field may be read concurrently, but is only written under the
+    // lock of a `ParkingSpot`.
+    thread: Thread,
+
+    // NB: these fields are only modified/read under the lock of a
+    // `ParkingSpot`.
+    notified: bool,
+    next: Option<SendSyncPtr<WaiterInner>>,
+    prev: Option<SendSyncPtr<WaiterInner>>,
+}
+
+impl ParkingSpot {
+    /// Atomically validates if `atomic == expected` and, if so, blocks the
+    /// current thread.
+    ///
+    /// This method will first check to see if `atomic == expected` using a
+    /// `SeqCst` load ordering. If the values are not equal then the method
+    /// immediately returns with `WaitResult::Mismatch`. Otherwise the thread
+    /// will be blocked and can only be woken up with `notify` on the same
+    /// address. Note that the check-and-block operation is atomic with respect
+    /// to `notify`.
+    ///
+    /// The optional `deadline` specified can indicate a point in time after
+    /// which this thread will be unblocked. If this thread is not notified and
+    /// `deadline` is reached then `WaitResult::TimedOut` is returned. If
+    /// `deadline` is `None` then this thread will block forever waiting for
+    /// `notify`.
+    ///
+    /// The `waiter` argument is metadata used by this structure to block
+    /// the current thread.
+    ///
+    /// This method will not spuriously wake up one blocked.
+    pub fn wait32(
+        &self,
+        atomic: &AtomicU32,
+        expected: u32,
+        deadline: impl Into<Option<Instant>>,
+        waiter: &mut Waiter,
+    ) -> WaitResult {
+        self.wait(
+            atomic.as_ptr() as u64,
+            || atomic.load(SeqCst) == expected,
+            deadline.into(),
+            waiter,
+        )
+    }
+
+    /// Same as `wait32`, but for 64-bit values.
+    pub fn wait64(
+        &self,
+        atomic: &AtomicU64,
+        expected: u64,
+        deadline: impl Into<Option<Instant>>,
+        waiter: &mut Waiter,
+    ) -> WaitResult {
+        self.wait(
+            atomic.as_ptr() as u64,
+            || atomic.load(SeqCst) == expected,
+            deadline.into(),
+            waiter,
+        )
+    }
+
+    fn wait(
+        &self,
+        key: u64,
+        validate: impl FnOnce() -> bool,
+        deadline: Option<Instant>,
+        waiter: &mut Waiter,
+    ) -> WaitResult {
+        let mut inner = self
+            .inner
+            .lock()
+            .expect("failed to lock inner parking table");
+
+        // This is the "atomic" part of the `validate` check which ensure that
+        // the memory location still indicates that we're allowed to block.
+        if !validate() {
+            return WaitResult::Mismatch;
+        }
+
+        // Lazily initialize the `waiter` node if it hasn't been already, and
+        // additionally ensure it's not accidentally in some other queue.
+        let waiter = waiter.inner.get_or_insert_with(|| {
+            Box::new(WaiterInner {
+                next: None,
+                prev: None,
+                notified: false,
+                thread: thread::current(),
+            })
+        });
+        assert!(waiter.next.is_none());
+        assert!(waiter.prev.is_none());
+
+        // Clear the `notified` flag if it was previously notified and
+        // configure the thread to wakeup as our own.
+        waiter.notified = false;
+        waiter.thread = thread::current();
+
+        let ptr = SendSyncPtr::new(NonNull::from(&mut **waiter));
+        let spot = inner.entry(key).or_insert_with(Spot::default);
+        unsafe {
+            // Enqueue our `waiter` in the internal queue for this spot.
+            spot.push(ptr);
+
+            // Wait for a notification to arrive. This is done through
+            // `std::thread::park_timeout` by dropping the lock that is held.
+            // This loop is somewhat similar to a condition variable.
+            //
+            // If no timeout was given then the maximum duration is effectively
+            // infinite (500 billion years), otherwise the timeout is
+            // calculated relative to the `deadline` specified.
+            //
+            // To handle spurious wakeups if the thread wakes up but a
+            // notification wasn't received then the thread goes back to sleep.
+            let timed_out = loop {
+                let timeout = match deadline {
+                    Some(deadline) => {
+                        let now = Instant::now();
+                        if deadline <= now {
+                            break true;
+                        } else {
+                            deadline - now
+                        }
+                    }
+                    None => Duration::MAX,
+                };
+
+                drop(inner);
+                thread::park_timeout(timeout);
+                inner = self.inner.lock().unwrap();
+
+                if ptr.as_ref().notified {
+                    break false;
+                }
+            };
+
+            if timed_out {
+                // If this thread timed out then it is still present in the
+                // waiter queue, so remove it.
+                inner.get_mut(&key).unwrap().remove(ptr);
+                WaitResult::TimedOut
+            } else {
+                // If this node was notified then we should not be in a queue
+                // at this point.
+                assert!(ptr.as_ref().next.is_none());
+                assert!(ptr.as_ref().prev.is_none());
+                WaitResult::Ok
+            }
+        }
+    }
+
+    /// Notify at most `n` threads that are blocked on the given address.
+    ///
+    /// Returns the number of threads that were actually unparked.
+    pub fn notify<T>(&self, addr: &T, n: u32) -> u32 {
+        if n == 0 {
+            return 0;
+        }
+        let mut unparked = 0;
+
+        // It's known here that `n > 0` so dequeue items until `unparked`
+        // equals `n` or the queue runs out. Each thread dequeued is signaled
+        // that it's been notified and then woken up.
+        self.with_lot(addr, |spot| unsafe {
+            while let Some(mut head) = spot.pop() {
+                let head = head.as_mut();
+                assert!(head.next.is_none());
+                head.notified = true;
+                head.thread.unpark();
+                unparked += 1;
+                if unparked == n {
+                    break;
+                }
+            }
+        });
+
+        unparked
+    }
+
+    fn with_lot<T, F: FnMut(&mut Spot)>(&self, addr: &T, mut f: F) {
+        let key = addr as *const _ as u64;
+        let mut inner = self
+            .inner
+            .lock()
+            .expect("failed to lock inner parking table");
+        if let Some(spot) = inner.get_mut(&key) {
+            f(spot);
+        }
+    }
+}
+
+impl Waiter {
+    pub const fn new() -> Waiter {
+        Waiter { inner: None }
+    }
+}
+
+impl Spot {
+    /// Adds `waiter` to the queue at the end.
+    ///
+    /// # Unsafety
+    ///
+    /// This method is `unsafe` as it can only be invoked under the parking
+    /// spot's mutex. Additionally `waiter` must be a valid pointer not already
+    /// in any other queue and additionally only exclusively used by this queue
+    /// now.
+    unsafe fn push(&mut self, mut waiter: SendSyncPtr<WaiterInner>) {
+        assert!(waiter.as_ref().next.is_none());
+        assert!(waiter.as_ref().prev.is_none());
+
+        waiter.as_mut().prev = self.tail;
+        match self.tail {
+            Some(mut tail) => tail.as_mut().next = Some(waiter),
+            None => self.head = Some(waiter),
+        }
+        self.tail = Some(waiter);
+    }
+
+    /// Removes `waiter` from the queue.
+    ///
+    /// # Unsafety
+    ///
+    /// This method is `unsafe` as it can only be invoked under the parking
+    /// spot's mutex. Additionally `waiter` must be a valid pointer in this
+    /// queue.
+    unsafe fn remove(&mut self, mut waiter: SendSyncPtr<WaiterInner>) {
+        let w = waiter.as_mut();
+        match w.prev {
+            Some(mut prev) => prev.as_mut().next = w.next,
+            None => self.head = w.next,
+        }
+        match w.next {
+            Some(mut next) => next.as_mut().prev = w.prev,
+            None => self.tail = w.prev,
+        }
+        w.prev = None;
+        w.next = None;
+    }
+
+    /// Pops the head of the queue from this linked list to wake up a waiter.
+    ///
+    /// # Unsafety
+    ///
+    /// This method is `unsafe` as it can only be invoked under the parking
+    /// spot's mutex.
+    unsafe fn pop(&mut self) -> Option<SendSyncPtr<WaiterInner>> {
+        let ret = self.head?;
+        self.remove(ret);
+        Some(ret)
+    }
+
+    #[cfg(test)]
+    fn num_parked(&self) -> u32 {
+        let mut ret = 0;
+        let mut cur = self.head;
+        while let Some(next) = cur {
+            ret += 1;
+            cur = unsafe { next.as_ref().next };
+        }
+        ret
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{ParkingSpot, Waiter};
+    use crate::prelude::*;
+    use std::sync::atomic::{AtomicU64, Ordering};
+    use std::thread;
+    use std::time::{Duration, Instant};
+
+    #[test]
+    fn atomic_wait_notify() {
+        let parking_spot = ParkingSpot::default();
+        let atomic = AtomicU64::new(0);
+
+        let wait_until_value = |val: u64, waiter: &mut Waiter| loop {
+            let cur = atomic.load(Ordering::SeqCst);
+            if cur == val {
+                break;
+            } else {
+                parking_spot.wait64(&atomic, cur, None, waiter);
+            }
+        };
+
+        thread::scope(|s| {
+            let thread1 = s.spawn(|| {
+                let mut waiter = Waiter::default();
+                atomic.store(1, Ordering::SeqCst);
+                parking_spot.notify(&atomic, u32::MAX);
+                parking_spot.wait64(&atomic, 1, None, &mut waiter);
+            });
+
+            let thread2 = s.spawn(|| {
+                let mut waiter = Waiter::default();
+                wait_until_value(1, &mut waiter);
+                atomic.store(2, Ordering::SeqCst);
+                parking_spot.notify(&atomic, u32::MAX);
+                parking_spot.wait64(&atomic, 2, None, &mut waiter);
+            });
+
+            let thread3 = s.spawn(|| {
+                let mut waiter = Waiter::default();
+                wait_until_value(2, &mut waiter);
+                atomic.store(3, Ordering::SeqCst);
+                parking_spot.notify(&atomic, u32::MAX);
+                parking_spot.wait64(&atomic, 3, None, &mut waiter);
+            });
+
+            let mut waiter = Waiter::default();
+            wait_until_value(3, &mut waiter);
+            atomic.store(4, Ordering::SeqCst);
+            parking_spot.notify(&atomic, u32::MAX);
+
+            thread1.join().unwrap();
+            thread2.join().unwrap();
+            thread3.join().unwrap();
+        });
+    }
+
+    mod parking_lot {
+        // This is a modified version of the parking_lot_core tests,
+        // which are licensed under the MIT and Apache 2.0 licenses.
+        use super::*;
+        use std::sync::atomic::AtomicU32;
+        use std::sync::Arc;
+
+        macro_rules! test {
+            ( $( $name:ident(
+                repeats: $repeats:expr,
+                latches: $latches:expr,
+                delay: $delay:expr,
+                threads: $threads:expr,
+                single_unparks: $single_unparks:expr);
+            )* ) => {
+                $(
+                #[test]
+                #[cfg_attr(miri, ignore)]
+                fn $name() {
+                    if std::env::var("WASMTIME_TEST_NO_HOG_MEMORY").is_ok() {
+                        return;
+                    }
+                    let delay = Duration::from_micros($delay);
+                    for _ in 0..$repeats {
+                        run_parking_test($latches, delay, $threads, $single_unparks);
+                    }
+                })*
+            };
+        }
+
+        test! {
+            unpark_all_one_fast(
+                repeats: 10000, latches: 1, delay: 0, threads: 1, single_unparks: 0
+            );
+            unpark_all_hundred_fast(
+                repeats: 100, latches: 1, delay: 0, threads: 100, single_unparks: 0
+            );
+            unpark_one_one_fast(
+                repeats: 1000, latches: 1, delay: 0, threads: 1, single_unparks: 1
+            );
+            unpark_one_hundred_fast(
+                repeats: 20, latches: 1, delay: 0, threads: 100, single_unparks: 100
+            );
+            unpark_one_fifty_then_fifty_all_fast(
+                repeats: 50, latches: 1, delay: 0, threads: 100, single_unparks: 50
+            );
+            unpark_all_one(
+                repeats: 100, latches: 1, delay: 10000, threads: 1, single_unparks: 0
+            );
+            unpark_all_hundred(
+                repeats: 100, latches: 1, delay: 10000, threads: 100, single_unparks: 0
+            );
+            unpark_one_one(
+                repeats: 10, latches: 1, delay: 10000, threads: 1, single_unparks: 1
+            );
+            unpark_one_fifty(
+                repeats: 1, latches: 1, delay: 10000, threads: 50, single_unparks: 50
+            );
+            unpark_one_fifty_then_fifty_all(
+                repeats: 2, latches: 1, delay: 10000, threads: 100, single_unparks: 50
+            );
+            hundred_unpark_all_one_fast(
+                repeats: 100, latches: 100, delay: 0, threads: 1, single_unparks: 0
+            );
+            hundred_unpark_all_one(
+                repeats: 1, latches: 100, delay: 10000, threads: 1, single_unparks: 0
+            );
+        }
+
+        fn run_parking_test(
+            num_latches: usize,
+            delay: Duration,
+            num_threads: u32,
+            num_single_unparks: u32,
+        ) {
+            let spot = ParkingSpot::default();
+
+            thread::scope(|s| {
+                let mut tests = Vec::with_capacity(num_latches);
+
+                for _ in 0..num_latches {
+                    let test = Arc::new(SingleLatchTest::new(num_threads, &spot));
+                    let mut threads = Vec::with_capacity(num_threads as _);
+                    for _ in 0..num_threads {
+                        let test = test.clone();
+                        threads.push(s.spawn(move || test.run()));
+                    }
+                    tests.push((test, threads));
+                }
+
+                for unpark_index in 0..num_single_unparks {
+                    thread::sleep(delay);
+                    for (test, _) in &tests {
+                        test.unpark_one(unpark_index);
+                    }
+                }
+
+                for (test, threads) in tests {
+                    test.finish(num_single_unparks);
+                    for thread in threads {
+                        thread.join().expect("Test thread panic");
+                    }
+                }
+            });
+        }
+
+        struct SingleLatchTest<'a> {
+            semaphore: AtomicU32,
+            num_awake: AtomicU32,
+            /// Total number of threads participating in this test.
+            num_threads: u32,
+            spot: &'a ParkingSpot,
+        }
+
+        impl<'a> SingleLatchTest<'a> {
+            pub fn new(num_threads: u32, spot: &'a ParkingSpot) -> Self {
+                Self {
+                    // This implements a fair (FIFO) semaphore, and it starts out unavailable.
+                    semaphore: AtomicU32::new(0),
+                    num_awake: AtomicU32::new(0),
+                    num_threads,
+                    spot,
+                }
+            }
+
+            pub fn run(&self) {
+                // Get one slot from the semaphore
+                self.down();
+
+                self.num_awake.fetch_add(1, Ordering::SeqCst);
+            }
+
+            pub fn unpark_one(&self, _single_unpark_index: u32) {
+                let num_awake_before_up = self.num_awake.load(Ordering::SeqCst);
+
+                self.up();
+
+                // Wait for a parked thread to wake up and update num_awake + last_awoken.
+                while self.num_awake.load(Ordering::SeqCst) != num_awake_before_up + 1 {
+                    thread::yield_now();
+                }
+            }
+
+            pub fn finish(&self, num_single_unparks: u32) {
+                // The amount of threads not unparked via unpark_one
+                let mut num_threads_left =
+                    self.num_threads.checked_sub(num_single_unparks).unwrap();
+
+                // Wake remaining threads up with unpark_all. Has to be in a loop, because there might
+                // still be threads that has not yet parked.
+                while num_threads_left > 0 {
+                    let mut num_waiting_on_address = 0;
+                    self.spot.with_lot(&self.semaphore, |thread_data| {
+                        num_waiting_on_address = thread_data.num_parked();
+                    });
+                    assert!(num_waiting_on_address <= num_threads_left);
+
+                    let num_awake_before_unpark = self.num_awake.load(Ordering::SeqCst);
+
+                    let num_unparked = self.spot.notify(&self.semaphore, u32::MAX);
+                    assert!(num_unparked >= num_waiting_on_address);
+                    assert!(num_unparked <= num_threads_left);
+
+                    // Wait for all unparked threads to wake up and update num_awake + last_awoken.
+                    while self.num_awake.load(Ordering::SeqCst)
+                        != num_awake_before_unpark + num_unparked
+                    {
+                        thread::yield_now();
+                    }
+
+                    num_threads_left = num_threads_left.checked_sub(num_unparked).unwrap();
+                }
+                // By now, all threads should have been woken up
+                assert_eq!(self.num_awake.load(Ordering::SeqCst), self.num_threads);
+
+                // Make sure no thread is parked on our semaphore address
+                let mut num_waiting_on_address = 0;
+                self.spot.with_lot(&self.semaphore, |thread_data| {
+                    num_waiting_on_address = thread_data.num_parked();
+                });
+                assert_eq!(num_waiting_on_address, 0);
+            }
+
+            pub fn down(&self) {
+                let mut old_semaphore_value = self.semaphore.fetch_sub(1, Ordering::SeqCst);
+
+                if (old_semaphore_value as i32) > 0 {
+                    // We acquired the semaphore. Done.
+                    return;
+                }
+
+                // Force this thread to go to sleep.
+                let mut waiter = Waiter::new();
+                loop {
+                    match self
+                        .spot
+                        .wait32(&self.semaphore, old_semaphore_value, None, &mut waiter)
+                    {
+                        crate::runtime::vm::WaitResult::Mismatch => {}
+                        _ => break,
+                    }
+                    old_semaphore_value = self.semaphore.load(Ordering::SeqCst);
+                }
+            }
+
+            pub fn up(&self) {
+                let old_semaphore_value = self.semaphore.fetch_add(1, Ordering::SeqCst) as i32;
+
+                // Check if anyone was waiting on the semaphore. If they were, then pass ownership to them.
+                if old_semaphore_value < 0 {
+                    // We need to continue until we have actually unparked someone. It might be that
+                    // the thread we want to pass ownership to has decremented the semaphore counter,
+                    // but not yet parked.
+                    loop {
+                        match self.spot.notify(&self.semaphore, 1) {
+                            1 => break,
+                            0 => (),
+                            i => panic!("Should not wake up {i} threads"),
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn wait_with_timeout() {
+        let parking_spot = ParkingSpot::default();
+        let atomic = AtomicU64::new(0);
+
+        thread::scope(|s| {
+            const N: u64 = 5;
+            const M: u64 = if cfg!(miri) { 10 } else { 1000 };
+
+            let thread = s.spawn(|| {
+                let mut waiter = Waiter::new();
+                loop {
+                    let cur = atomic.load(Ordering::SeqCst);
+                    if cur == N * M {
+                        break;
+                    }
+                    let timeout = Instant::now() + Duration::from_millis(1);
+                    parking_spot.wait64(&atomic, cur, Some(timeout), &mut waiter);
+                }
+            });
+
+            let mut threads = vec![thread];
+            for _ in 0..N {
+                threads.push(s.spawn(|| {
+                    for _ in 0..M {
+                        atomic.fetch_add(1, Ordering::SeqCst);
+                        parking_spot.notify(&atomic, 1);
+                    }
+                }));
+            }
+
+            for thread in threads {
+                thread.join().unwrap();
+            }
+        });
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/threads/shared_memory.rs b/crates/wasmtime/src/runtime/vm/threads/shared_memory.rs
new file mode 100644
index 000000000000..b62ce1f54855
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/threads/shared_memory.rs
@@ -0,0 +1,235 @@
+use crate::prelude::*;
+use crate::runtime::vm::memory::{validate_atomic_addr, MmapMemory};
+use crate::runtime::vm::threads::parking_spot::{ParkingSpot, Waiter};
+use crate::runtime::vm::vmcontext::VMMemoryDefinition;
+use crate::runtime::vm::{Memory, RuntimeLinearMemory, Store, WaitResult};
+use std::cell::RefCell;
+use std::ops::Range;
+use std::sync::atomic::{AtomicU32, AtomicU64, Ordering};
+use std::sync::{Arc, RwLock};
+use std::time::{Duration, Instant};
+use wasmtime_environ::{MemoryPlan, MemoryStyle, Trap};
+
+/// For shared memory (and only for shared memory), this lock-version restricts
+/// access when growing the memory or checking its size. This is to conform with
+/// the [thread proposal]: "When `IsSharedArrayBuffer(...)` is true, the return
+/// value should be the result of an atomic read-modify-write of the new size to
+/// the internal `length` slot."
+///
+/// [thread proposal]:
+///     https://github.com/WebAssembly/threads/blob/master/proposals/threads/Overview.md#webassemblymemoryprototypegrow
+#[derive(Clone)]
+pub struct SharedMemory(Arc<SharedMemoryInner>);
+
+struct SharedMemoryInner {
+    memory: RwLock<Box<dyn RuntimeLinearMemory>>,
+    spot: ParkingSpot,
+    ty: wasmtime_environ::Memory,
+    def: LongTermVMMemoryDefinition,
+}
+
+impl SharedMemory {
+    /// Construct a new [`SharedMemory`].
+    pub fn new(plan: MemoryPlan) -> Result<Self> {
+        let (minimum_bytes, maximum_bytes) = Memory::limit_new(&plan, None)?;
+        let mmap_memory = MmapMemory::new(&plan, minimum_bytes, maximum_bytes, None)?;
+        Self::wrap(&plan, Box::new(mmap_memory), plan.memory)
+    }
+
+    /// Wrap an existing [Memory] with the locking provided by a [SharedMemory].
+    pub fn wrap(
+        plan: &MemoryPlan,
+        mut memory: Box<dyn RuntimeLinearMemory>,
+        ty: wasmtime_environ::Memory,
+    ) -> Result<Self> {
+        if !ty.shared {
+            bail!("shared memory must have a `shared` memory type");
+        }
+        if !matches!(plan.style, MemoryStyle::Static { .. }) {
+            bail!("shared memory can only be built from a static memory allocation")
+        }
+        assert!(
+            memory.as_any_mut().type_id() != std::any::TypeId::of::<SharedMemory>(),
+            "cannot re-wrap a shared memory"
+        );
+        Ok(Self(Arc::new(SharedMemoryInner {
+            ty,
+            spot: ParkingSpot::default(),
+            def: LongTermVMMemoryDefinition(memory.vmmemory()),
+            memory: RwLock::new(memory),
+        })))
+    }
+
+    /// Return the memory type for this [`SharedMemory`].
+    pub fn ty(&self) -> wasmtime_environ::Memory {
+        self.0.ty
+    }
+
+    /// Convert this shared memory into a [`Memory`].
+    pub fn as_memory(self) -> Memory {
+        Memory(Box::new(self))
+    }
+
+    /// Return a pointer to the shared memory's [VMMemoryDefinition].
+    pub fn vmmemory_ptr(&self) -> *const VMMemoryDefinition {
+        &self.0.def.0
+    }
+
+    /// Same as `RuntimeLinearMemory::grow`, except with `&self`.
+    pub fn grow(
+        &self,
+        delta_pages: u64,
+        store: Option<&mut dyn Store>,
+    ) -> Result<Option<(usize, usize)>, Error> {
+        let mut memory = self.0.memory.write().unwrap();
+        let result = memory.grow(delta_pages, store)?;
+        if let Some((_old_size_in_bytes, new_size_in_bytes)) = result {
+            // Store the new size to the `VMMemoryDefinition` for JIT-generated
+            // code (and runtime functions) to access. No other code can be
+            // growing this memory due to the write lock, but code in other
+            // threads could have access to this shared memory and we want them
+            // to see the most consistent version of the `current_length`; a
+            // weaker consistency is possible if we accept them seeing an older,
+            // smaller memory size (assumption: memory only grows) but presently
+            // we are aiming for accuracy.
+            //
+            // Note that it could be possible to access a memory address that is
+            // now-valid due to changes to the page flags in `grow` above but
+            // beyond the `memory.size` that we are about to assign to. In these
+            // and similar cases, discussion in the thread proposal concluded
+            // that: "multiple accesses in one thread racing with another
+            // thread's `memory.grow` that are in-bounds only after the grow
+            // commits may independently succeed or trap" (see
+            // https://github.com/WebAssembly/threads/issues/26#issuecomment-433930711).
+            // In other words, some non-determinism is acceptable when using
+            // `memory.size` on work being done by `memory.grow`.
+            self.0
+                .def
+                .0
+                .current_length
+                .store(new_size_in_bytes, Ordering::SeqCst);
+        }
+        Ok(result)
+    }
+
+    /// Implementation of `memory.atomic.notify` for this shared memory.
+    pub fn atomic_notify(&self, addr_index: u64, count: u32) -> Result<u32, Trap> {
+        let ptr = validate_atomic_addr(&self.0.def.0, addr_index, 4, 4)?;
+        log::trace!("memory.atomic.notify(addr={addr_index:#x}, count={count})");
+        let ptr = unsafe { &*ptr };
+        Ok(self.0.spot.notify(ptr, count))
+    }
+
+    /// Implementation of `memory.atomic.wait32` for this shared memory.
+    pub fn atomic_wait32(
+        &self,
+        addr_index: u64,
+        expected: u32,
+        timeout: Option<Duration>,
+    ) -> Result<WaitResult, Trap> {
+        let addr = validate_atomic_addr(&self.0.def.0, addr_index, 4, 4)?;
+        log::trace!(
+            "memory.atomic.wait32(addr={addr_index:#x}, expected={expected}, timeout={timeout:?})"
+        );
+
+        // SAFETY: `addr_index` was validated by `validate_atomic_addr` above.
+        assert!(std::mem::size_of::<AtomicU32>() == 4);
+        assert!(std::mem::align_of::<AtomicU32>() <= 4);
+        let atomic = unsafe { AtomicU32::from_ptr(addr.cast()) };
+        let deadline = timeout.map(|d| Instant::now() + d);
+
+        WAITER.with(|waiter| {
+            let mut waiter = waiter.borrow_mut();
+            Ok(self.0.spot.wait32(atomic, expected, deadline, &mut waiter))
+        })
+    }
+
+    /// Implementation of `memory.atomic.wait64` for this shared memory.
+    pub fn atomic_wait64(
+        &self,
+        addr_index: u64,
+        expected: u64,
+        timeout: Option<Duration>,
+    ) -> Result<WaitResult, Trap> {
+        let addr = validate_atomic_addr(&self.0.def.0, addr_index, 8, 8)?;
+        log::trace!(
+            "memory.atomic.wait64(addr={addr_index:#x}, expected={expected}, timeout={timeout:?})"
+        );
+
+        // SAFETY: `addr_index` was validated by `validate_atomic_addr` above.
+        assert!(std::mem::size_of::<AtomicU64>() == 8);
+        assert!(std::mem::align_of::<AtomicU64>() <= 8);
+        let atomic = unsafe { AtomicU64::from_ptr(addr.cast()) };
+        let deadline = timeout.map(|d| Instant::now() + d);
+
+        WAITER.with(|waiter| {
+            let mut waiter = waiter.borrow_mut();
+            Ok(self.0.spot.wait64(atomic, expected, deadline, &mut waiter))
+        })
+    }
+}
+
+thread_local! {
+    /// Structure used in conjunction with `ParkingSpot` to block the current
+    /// thread if necessary. Note that this is lazily initialized.
+    static WAITER: RefCell<Waiter> = const { RefCell::new(Waiter::new()) };
+}
+
+/// Shared memory needs some representation of a `VMMemoryDefinition` for
+/// JIT-generated code to access. This structure owns the base pointer and
+/// length to the actual memory and we share this definition across threads by:
+/// - never changing the base pointer; according to the specification, shared
+///   memory must be created with a known maximum size so it can be allocated
+///   once and never moved
+/// - carefully changing the length, using atomic accesses in both the runtime
+///   and JIT-generated code.
+struct LongTermVMMemoryDefinition(VMMemoryDefinition);
+unsafe impl Send for LongTermVMMemoryDefinition {}
+unsafe impl Sync for LongTermVMMemoryDefinition {}
+
+/// Proxy all calls through the [`RwLock`].
+impl RuntimeLinearMemory for SharedMemory {
+    fn page_size_log2(&self) -> u8 {
+        self.0.memory.read().unwrap().page_size_log2()
+    }
+
+    fn byte_size(&self) -> usize {
+        self.0.memory.read().unwrap().byte_size()
+    }
+
+    fn maximum_byte_size(&self) -> Option<usize> {
+        self.0.memory.read().unwrap().maximum_byte_size()
+    }
+
+    fn grow(
+        &mut self,
+        delta_pages: u64,
+        store: Option<&mut dyn Store>,
+    ) -> Result<Option<(usize, usize)>, Error> {
+        SharedMemory::grow(self, delta_pages, store)
+    }
+
+    fn grow_to(&mut self, size: usize) -> Result<()> {
+        self.0.memory.write().unwrap().grow_to(size)
+    }
+
+    fn vmmemory(&mut self) -> VMMemoryDefinition {
+        // `vmmemory()` is used for writing the `VMMemoryDefinition` of a memory
+        // into its `VMContext`; this should never be possible for a shared
+        // memory because the only `VMMemoryDefinition` for it should be stored
+        // in its own `def` field.
+        unreachable!()
+    }
+
+    fn needs_init(&self) -> bool {
+        self.0.memory.read().unwrap().needs_init()
+    }
+
+    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
+        self
+    }
+
+    fn wasm_accessible(&self) -> Range<usize> {
+        self.0.memory.read().unwrap().wasm_accessible()
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/threads/shared_memory_disabled.rs b/crates/wasmtime/src/runtime/vm/threads/shared_memory_disabled.rs
new file mode 100644
index 000000000000..4927918ce299
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/threads/shared_memory_disabled.rs
@@ -0,0 +1,104 @@
+#![allow(missing_docs)]
+
+use crate::prelude::*;
+use crate::runtime::vm::{RuntimeLinearMemory, Store, VMMemoryDefinition, WaitResult};
+use core::ops::Range;
+use core::time::Duration;
+use wasmtime_environ::{MemoryPlan, Trap};
+
+#[derive(Clone)]
+pub enum SharedMemory {}
+
+impl SharedMemory {
+    pub fn wrap(
+        _plan: &MemoryPlan,
+        _memory: Box<dyn RuntimeLinearMemory>,
+        _ty: wasmtime_environ::Memory,
+    ) -> Result<Self> {
+        bail!("support for shared memories was disabled at compile time");
+    }
+
+    pub fn ty(&self) -> wasmtime_environ::Memory {
+        match *self {}
+    }
+
+    pub fn as_memory(self) -> crate::runtime::vm::Memory {
+        match self {}
+    }
+
+    pub fn vmmemory_ptr(&self) -> *const VMMemoryDefinition {
+        match *self {}
+    }
+
+    pub fn grow(
+        &self,
+        _delta_pages: u64,
+        _store: Option<&mut dyn Store>,
+    ) -> Result<Option<(usize, usize)>> {
+        match *self {}
+    }
+
+    pub fn atomic_notify(&self, _addr_index: u64, _count: u32) -> Result<u32, Trap> {
+        match *self {}
+    }
+
+    pub fn atomic_wait32(
+        &self,
+        _addr_index: u64,
+        _expected: u32,
+        _timeout: Option<Duration>,
+    ) -> Result<WaitResult, Trap> {
+        match *self {}
+    }
+
+    pub fn atomic_wait64(
+        &self,
+        _addr_index: u64,
+        _expected: u64,
+        _timeout: Option<Duration>,
+    ) -> Result<WaitResult, Trap> {
+        match *self {}
+    }
+}
+
+impl RuntimeLinearMemory for SharedMemory {
+    fn page_size_log2(&self) -> u8 {
+        match *self {}
+    }
+
+    fn byte_size(&self) -> usize {
+        match *self {}
+    }
+
+    fn maximum_byte_size(&self) -> Option<usize> {
+        match *self {}
+    }
+
+    fn grow(
+        &mut self,
+        _delta_pages: u64,
+        _store: Option<&mut dyn Store>,
+    ) -> Result<Option<(usize, usize)>> {
+        match *self {}
+    }
+
+    fn grow_to(&mut self, _size: usize) -> Result<()> {
+        match *self {}
+    }
+
+    fn vmmemory(&mut self) -> VMMemoryDefinition {
+        match *self {}
+    }
+
+    fn needs_init(&self) -> bool {
+        match *self {}
+    }
+
+    fn as_any_mut(&mut self) -> &mut dyn core::any::Any {
+        match *self {}
+    }
+
+    fn wasm_accessible(&self) -> Range<usize> {
+        match *self {}
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/traphandlers.rs b/crates/wasmtime/src/runtime/vm/traphandlers.rs
new file mode 100644
index 000000000000..bfd45a680482
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/traphandlers.rs
@@ -0,0 +1,787 @@
+//! WebAssembly trap handling, which is built on top of the lower-level
+//! signalhandling mechanisms.
+
+mod backtrace;
+
+#[cfg(feature = "coredump")]
+#[path = "traphandlers/coredump_enabled.rs"]
+mod coredump;
+#[cfg(not(feature = "coredump"))]
+#[path = "traphandlers/coredump_disabled.rs"]
+mod coredump;
+
+use crate::prelude::*;
+use crate::runtime::module::lookup_code;
+use crate::runtime::vm::sys::traphandlers;
+use crate::runtime::vm::{Instance, VMContext, VMRuntimeLimits};
+use crate::sync::RwLock;
+use core::cell::{Cell, UnsafeCell};
+use core::mem::MaybeUninit;
+use core::ptr;
+
+pub use self::backtrace::Backtrace;
+pub use self::coredump::CoreDumpStack;
+pub use self::tls::{tls_eager_initialize, AsyncWasmCallState, PreviousAsyncWasmCallState};
+
+pub use traphandlers::SignalHandler;
+
+/// Platform-specific trap-handler state.
+///
+/// This state is protected by a lock to synchronize access to it. Right now
+/// it's a `RwLock` but it could be a `Mutex`, and `RwLock` is just chosen for
+/// convenience as it's what's implemented in no_std. The performance here
+/// should not be of consequence.
+///
+/// This is initialized to `None` and then set as part of `init_traps`.
+static TRAP_HANDLER: RwLock<Option<traphandlers::TrapHandler>> = RwLock::new(None);
+
+/// This function is required to be called before any WebAssembly is entered.
+/// This will configure global state such as signal handlers to prepare the
+/// process to receive wasm traps.
+///
+/// # Panics
+///
+/// This function will panic on macOS if it is called twice or more times with
+/// different values of `macos_use_mach_ports`.
+///
+/// This function will also panic if the `std` feature is disabled and it's
+/// called concurrently.
+pub fn init_traps(macos_use_mach_ports: bool) {
+    let mut lock = TRAP_HANDLER.write();
+    match lock.as_mut() {
+        Some(state) => state.validate_config(macos_use_mach_ports),
+        None => *lock = Some(unsafe { traphandlers::TrapHandler::new(macos_use_mach_ports) }),
+    }
+}
+
+/// De-initializes platform-specific state for trap handling.
+///
+/// # Panics
+///
+/// This function will also panic if the `std` feature is disabled and it's
+/// called concurrently.
+///
+/// # Aborts
+///
+/// This may abort the process on some platforms where trap handling state
+/// cannot be unloaded.
+///
+/// # Unsafety
+///
+/// This is not safe to be called unless all wasm code is unloaded. This is not
+/// safe to be called on some platforms, like Unix, when other libraries
+/// installed their own signal handlers after `init_traps` was called.
+///
+/// There's more reasons for unsafety here than those articulated above,
+/// generally this can only be called "if you know what you're doing".
+pub unsafe fn deinit_traps() {
+    let mut lock = TRAP_HANDLER.write();
+    let _ = lock.take();
+}
+
+fn lazy_per_thread_init() {
+    traphandlers::lazy_per_thread_init();
+}
+
+/// Raises a trap immediately.
+///
+/// This function performs as-if a wasm trap was just executed. This trap
+/// payload is then returned from `catch_traps` below.
+///
+/// # Safety
+///
+/// Only safe to call when wasm code is on the stack, aka `catch_traps` must
+/// have been previously called. Additionally no Rust destructors can be on the
+/// stack. They will be skipped and not executed.
+pub unsafe fn raise_trap(reason: TrapReason) -> ! {
+    tls::with(|info| info.unwrap().unwind_with(UnwindReason::Trap(reason)))
+}
+
+/// Raises a user-defined trap immediately.
+///
+/// This function performs as-if a wasm trap was just executed, only the trap
+/// has a dynamic payload associated with it which is user-provided. This trap
+/// payload is then returned from `catch_traps` below.
+///
+/// # Safety
+///
+/// Only safe to call when wasm code is on the stack, aka `catch_traps` must
+/// have been previously called. Additionally no Rust destructors can be on the
+/// stack. They will be skipped and not executed.
+pub unsafe fn raise_user_trap(error: Error, needs_backtrace: bool) -> ! {
+    raise_trap(TrapReason::User {
+        error,
+        needs_backtrace,
+    })
+}
+
+/// Invokes the closure `f` and returns the result.
+///
+/// If `f` panics and this crate is compiled with `panic=unwind` this will
+/// catch the panic and capture it to "throw" with `longjmp` to be caught by
+/// the nearest `setjmp`. The panic will then be resumed from where it is
+/// caught.
+///
+/// # Safety
+///
+/// Only safe to call when wasm code is on the stack, aka `catch_traps` must
+/// have been previously called. Additionally no Rust destructors can be on the
+/// stack. They will be skipped and not executed in the case that `f` panics.
+pub unsafe fn catch_unwind_and_longjmp<R>(f: impl FnOnce() -> R) -> R {
+    // With `panic=unwind` use `std::panic::catch_unwind` to catch possible
+    // panics to rethrow.
+    #[cfg(all(feature = "std", panic = "unwind"))]
+    {
+        match std::panic::catch_unwind(std::panic::AssertUnwindSafe(f)) {
+            Ok(ret) => ret,
+            Err(err) => tls::with(|info| info.unwrap().unwind_with(UnwindReason::Panic(err))),
+        }
+    }
+
+    // With `panic=abort` there's no use in using `std::panic::catch_unwind`
+    // since it won't actually catch anything. Note that
+    // `std::panic::catch_unwind` will technically optimize to this but having
+    // this branch avoids using the `std::panic` module entirely.
+    #[cfg(not(all(feature = "std", panic = "unwind")))]
+    {
+        f()
+    }
+}
+
+/// Stores trace message with backtrace.
+#[derive(Debug)]
+pub struct Trap {
+    /// Original reason from where this trap originated.
+    pub reason: TrapReason,
+    /// Wasm backtrace of the trap, if any.
+    pub backtrace: Option<Backtrace>,
+    /// The Wasm Coredump, if any.
+    pub coredumpstack: Option<CoreDumpStack>,
+}
+
+/// Enumeration of different methods of raising a trap.
+#[derive(Debug)]
+pub enum TrapReason {
+    /// A user-raised trap through `raise_user_trap`.
+    User {
+        /// The actual user trap error.
+        error: Error,
+        /// Whether we need to capture a backtrace for this error or not.
+        needs_backtrace: bool,
+    },
+
+    /// A trap raised from Cranelift-generated code.
+    Jit {
+        /// The program counter where this trap originated.
+        ///
+        /// This is later used with side tables from compilation to translate
+        /// the trapping address to a trap code.
+        pc: usize,
+
+        /// If the trap was a memory-related trap such as SIGSEGV then this
+        /// field will contain the address of the inaccessible data.
+        ///
+        /// Note that wasm loads/stores are not guaranteed to fill in this
+        /// information. Dynamically-bounds-checked memories, for example, will
+        /// not access an invalid address but may instead load from NULL or may
+        /// explicitly jump to a `ud2` instruction. This is only available for
+        /// fault-based traps which are one of the main ways, but not the only
+        /// way, to run wasm.
+        faulting_addr: Option<usize>,
+
+        /// The trap code associated with this trap.
+        trap: wasmtime_environ::Trap,
+    },
+
+    /// A trap raised from a wasm libcall
+    Wasm(wasmtime_environ::Trap),
+}
+
+impl TrapReason {
+    /// Create a new `TrapReason::User` that does not have a backtrace yet.
+    pub fn user_without_backtrace(error: Error) -> Self {
+        TrapReason::User {
+            error,
+            needs_backtrace: true,
+        }
+    }
+}
+
+impl From<Error> for TrapReason {
+    fn from(err: Error) -> Self {
+        TrapReason::user_without_backtrace(err)
+    }
+}
+
+impl From<wasmtime_environ::Trap> for TrapReason {
+    fn from(code: wasmtime_environ::Trap) -> Self {
+        TrapReason::Wasm(code)
+    }
+}
+
+pub(crate) struct TrapRegisters {
+    pub pc: usize,
+    pub fp: usize,
+}
+
+/// Return value from `test_if_trap`.
+pub(crate) enum TrapTest {
+    /// Not a wasm trap, need to delegate to whatever process handler is next.
+    NotWasm,
+    /// This trap was handled by the embedder via custom embedding APIs.
+    HandledByEmbedder,
+    /// This is a wasm trap, it needs to be handled.
+    #[cfg_attr(miri, allow(dead_code))]
+    Trap {
+        /// How to longjmp back to the original wasm frame.
+        jmp_buf: *const u8,
+    },
+}
+
+/// Catches any wasm traps that happen within the execution of `closure`,
+/// returning them as a `Result`.
+///
+/// Highly unsafe since `closure` won't have any dtors run.
+pub unsafe fn catch_traps<F>(
+    signal_handler: Option<*const SignalHandler<'static>>,
+    capture_backtrace: bool,
+    capture_coredump: bool,
+    caller: *mut VMContext,
+    mut closure: F,
+) -> Result<(), Box<Trap>>
+where
+    F: FnMut(*mut VMContext),
+{
+    let limits = Instance::from_vmctx(caller, |i| i.runtime_limits());
+
+    let result = CallThreadState::new(signal_handler, capture_backtrace, capture_coredump, *limits)
+        .with(|cx| {
+            traphandlers::wasmtime_setjmp(
+                cx.jmp_buf.as_ptr(),
+                call_closure::<F>,
+                &mut closure as *mut F as *mut u8,
+                caller,
+            )
+        });
+
+    return match result {
+        Ok(x) => Ok(x),
+        Err((UnwindReason::Trap(reason), backtrace, coredumpstack)) => Err(Box::new(Trap {
+            reason,
+            backtrace,
+            coredumpstack,
+        })),
+        #[cfg(all(feature = "std", panic = "unwind"))]
+        Err((UnwindReason::Panic(panic), _, _)) => std::panic::resume_unwind(panic),
+    };
+
+    extern "C" fn call_closure<F>(payload: *mut u8, caller: *mut VMContext)
+    where
+        F: FnMut(*mut VMContext),
+    {
+        unsafe { (*(payload as *mut F))(caller) }
+    }
+}
+
+// Module to hide visibility of the `CallThreadState::prev` field and force
+// usage of its accessor methods.
+mod call_thread_state {
+    use super::*;
+
+    /// Temporary state stored on the stack which is registered in the `tls` module
+    /// below for calls into wasm.
+    pub struct CallThreadState {
+        pub(super) unwind:
+            UnsafeCell<MaybeUninit<(UnwindReason, Option<Backtrace>, Option<CoreDumpStack>)>>,
+        pub(super) jmp_buf: Cell<*const u8>,
+        pub(super) signal_handler: Option<*const SignalHandler<'static>>,
+        pub(super) capture_backtrace: bool,
+        #[cfg(feature = "coredump")]
+        pub(super) capture_coredump: bool,
+
+        pub(crate) limits: *const VMRuntimeLimits,
+
+        pub(super) prev: Cell<tls::Ptr>,
+
+        // The values of `VMRuntimeLimits::last_wasm_{exit_{pc,fp},entry_sp}`
+        // for the *previous* `CallThreadState` for this same store/limits. Our
+        // *current* last wasm PC/FP/SP are saved in `self.limits`. We save a
+        // copy of the old registers here because the `VMRuntimeLimits`
+        // typically doesn't change across nested calls into Wasm (i.e. they are
+        // typically calls back into the same store and `self.limits ==
+        // self.prev.limits`) and we must to maintain the list of
+        // contiguous-Wasm-frames stack regions for backtracing purposes.
+        old_last_wasm_exit_fp: Cell<usize>,
+        old_last_wasm_exit_pc: Cell<usize>,
+        old_last_wasm_entry_sp: Cell<usize>,
+    }
+
+    impl Drop for CallThreadState {
+        fn drop(&mut self) {
+            unsafe {
+                *(*self.limits).last_wasm_exit_fp.get() = self.old_last_wasm_exit_fp.get();
+                *(*self.limits).last_wasm_exit_pc.get() = self.old_last_wasm_exit_pc.get();
+                *(*self.limits).last_wasm_entry_sp.get() = self.old_last_wasm_entry_sp.get();
+            }
+        }
+    }
+
+    impl CallThreadState {
+        #[inline]
+        pub(super) fn new(
+            signal_handler: Option<*const SignalHandler<'static>>,
+            capture_backtrace: bool,
+            capture_coredump: bool,
+            limits: *const VMRuntimeLimits,
+        ) -> CallThreadState {
+            let _ = capture_coredump;
+
+            CallThreadState {
+                unwind: UnsafeCell::new(MaybeUninit::uninit()),
+                jmp_buf: Cell::new(ptr::null()),
+                signal_handler,
+                capture_backtrace,
+                #[cfg(feature = "coredump")]
+                capture_coredump,
+                limits,
+                prev: Cell::new(ptr::null()),
+                old_last_wasm_exit_fp: Cell::new(unsafe { *(*limits).last_wasm_exit_fp.get() }),
+                old_last_wasm_exit_pc: Cell::new(unsafe { *(*limits).last_wasm_exit_pc.get() }),
+                old_last_wasm_entry_sp: Cell::new(unsafe { *(*limits).last_wasm_entry_sp.get() }),
+            }
+        }
+
+        /// Get the saved FP upon exit from Wasm for the previous `CallThreadState`.
+        pub fn old_last_wasm_exit_fp(&self) -> usize {
+            self.old_last_wasm_exit_fp.get()
+        }
+
+        /// Get the saved PC upon exit from Wasm for the previous `CallThreadState`.
+        pub fn old_last_wasm_exit_pc(&self) -> usize {
+            self.old_last_wasm_exit_pc.get()
+        }
+
+        /// Get the saved SP upon entry into Wasm for the previous `CallThreadState`.
+        pub fn old_last_wasm_entry_sp(&self) -> usize {
+            self.old_last_wasm_entry_sp.get()
+        }
+
+        /// Get the previous `CallThreadState`.
+        pub fn prev(&self) -> tls::Ptr {
+            self.prev.get()
+        }
+
+        #[inline]
+        pub(crate) unsafe fn push(&self) {
+            assert!(self.prev.get().is_null());
+            self.prev.set(tls::raw::replace(self));
+        }
+
+        #[inline]
+        pub(crate) unsafe fn pop(&self) {
+            let prev = self.prev.replace(ptr::null());
+            let head = tls::raw::replace(prev);
+            assert!(core::ptr::eq(head, self));
+        }
+    }
+}
+pub use call_thread_state::*;
+
+enum UnwindReason {
+    #[cfg(all(feature = "std", panic = "unwind"))]
+    Panic(Box<dyn std::any::Any + Send>),
+    Trap(TrapReason),
+}
+
+impl CallThreadState {
+    #[inline]
+    fn with(
+        mut self,
+        closure: impl FnOnce(&CallThreadState) -> i32,
+    ) -> Result<(), (UnwindReason, Option<Backtrace>, Option<CoreDumpStack>)> {
+        let ret = tls::set(&mut self, |me| closure(me));
+        if ret != 0 {
+            Ok(())
+        } else {
+            Err(unsafe { self.read_unwind() })
+        }
+    }
+
+    #[cold]
+    unsafe fn read_unwind(&self) -> (UnwindReason, Option<Backtrace>, Option<CoreDumpStack>) {
+        (*self.unwind.get()).as_ptr().read()
+    }
+
+    fn unwind_with(&self, reason: UnwindReason) -> ! {
+        let (backtrace, coredump) = match reason {
+            // Panics don't need backtraces. There is nowhere to attach the
+            // hypothetical backtrace to and it doesn't really make sense to try
+            // in the first place since this is a Rust problem rather than a
+            // Wasm problem.
+            #[cfg(all(feature = "std", panic = "unwind"))]
+            UnwindReason::Panic(_) => (None, None),
+            // And if we are just propagating an existing trap that already has
+            // a backtrace attached to it, then there is no need to capture a
+            // new backtrace either.
+            UnwindReason::Trap(TrapReason::User {
+                needs_backtrace: false,
+                ..
+            }) => (None, None),
+            UnwindReason::Trap(_) => (
+                self.capture_backtrace(self.limits, None),
+                self.capture_coredump(self.limits, None),
+            ),
+        };
+        unsafe {
+            (*self.unwind.get())
+                .as_mut_ptr()
+                .write((reason, backtrace, coredump));
+            traphandlers::wasmtime_longjmp(self.jmp_buf.get());
+        }
+    }
+
+    /// Trap handler using our thread-local state.
+    ///
+    /// * `pc` - the program counter the trap happened at
+    /// * `call_handler` - a closure used to invoke the platform-specific
+    ///   signal handler for each instance, if available.
+    ///
+    /// Attempts to handle the trap if it's a wasm trap. Returns a few
+    /// different things:
+    ///
+    /// * null - the trap didn't look like a wasm trap and should continue as a
+    ///   trap
+    /// * 1 as a pointer - the trap was handled by a custom trap handler on an
+    ///   instance, and the trap handler should quickly return.
+    /// * a different pointer - a jmp_buf buffer to longjmp to, meaning that
+    ///   the wasm trap was successfully handled.
+    #[cfg_attr(miri, allow(dead_code))] // miri doesn't handle traps yet
+    pub(crate) fn test_if_trap(
+        &self,
+        regs: TrapRegisters,
+        faulting_addr: Option<usize>,
+        call_handler: impl Fn(&SignalHandler) -> bool,
+    ) -> TrapTest {
+        // If we haven't even started to handle traps yet, bail out.
+        if self.jmp_buf.get().is_null() {
+            return TrapTest::NotWasm;
+        }
+
+        // First up see if any instance registered has a custom trap handler,
+        // in which case run them all. If anything handles the trap then we
+        // return that the trap was handled.
+        if let Some(handler) = self.signal_handler {
+            if unsafe { call_handler(&*handler) } {
+                return TrapTest::HandledByEmbedder;
+            }
+        }
+
+        // If this fault wasn't in wasm code, then it's not our problem
+        let Some((code, text_offset)) = lookup_code(regs.pc) else {
+            return TrapTest::NotWasm;
+        };
+
+        let Some(trap) = code.lookup_trap_code(text_offset) else {
+            return TrapTest::NotWasm;
+        };
+
+        self.set_jit_trap(regs, faulting_addr, trap);
+
+        // If all that passed then this is indeed a wasm trap, so return the
+        // `jmp_buf` passed to `wasmtime_longjmp` to resume.
+        TrapTest::Trap {
+            jmp_buf: self.take_jmp_buf(),
+        }
+    }
+
+    pub(crate) fn take_jmp_buf(&self) -> *const u8 {
+        self.jmp_buf.replace(ptr::null())
+    }
+
+    #[cfg_attr(miri, allow(dead_code))] // miri doesn't handle traps yet
+    pub(crate) fn set_jit_trap(
+        &self,
+        TrapRegisters { pc, fp, .. }: TrapRegisters,
+        faulting_addr: Option<usize>,
+        trap: wasmtime_environ::Trap,
+    ) {
+        let backtrace = self.capture_backtrace(self.limits, Some((pc, fp)));
+        let coredump = self.capture_coredump(self.limits, Some((pc, fp)));
+        unsafe {
+            (*self.unwind.get()).as_mut_ptr().write((
+                UnwindReason::Trap(TrapReason::Jit {
+                    pc,
+                    faulting_addr,
+                    trap,
+                }),
+                backtrace,
+                coredump,
+            ));
+        }
+    }
+
+    fn capture_backtrace(
+        &self,
+        limits: *const VMRuntimeLimits,
+        trap_pc_and_fp: Option<(usize, usize)>,
+    ) -> Option<Backtrace> {
+        if !self.capture_backtrace {
+            return None;
+        }
+
+        Some(unsafe { Backtrace::new_with_trap_state(limits, self, trap_pc_and_fp) })
+    }
+
+    pub(crate) fn iter<'a>(&'a self) -> impl Iterator<Item = &Self> + 'a {
+        let mut state = Some(self);
+        core::iter::from_fn(move || {
+            let this = state?;
+            state = unsafe { this.prev().as_ref() };
+            Some(this)
+        })
+    }
+}
+
+// A private inner module for managing the TLS state that we require across
+// calls in wasm. The WebAssembly code is called from C++ and then a trap may
+// happen which requires us to read some contextual state to figure out what to
+// do with the trap. This `tls` module is used to persist that information from
+// the caller to the trap site.
+pub(crate) mod tls {
+    use super::CallThreadState;
+    use core::mem;
+    use core::ops::Range;
+
+    pub use raw::Ptr;
+
+    // An even *more* inner module for dealing with TLS. This actually has the
+    // thread local variable and has functions to access the variable.
+    //
+    // Note that this is specially done to fully encapsulate that the accessors
+    // for tls may or may not be inlined. Wasmtime's async support employs stack
+    // switching which can resume execution on different OS threads. This means
+    // that borrows of our TLS pointer must never live across accesses because
+    // otherwise the access may be split across two threads and cause unsafety.
+    //
+    // This also means that extra care is taken by the runtime to save/restore
+    // these TLS values when the runtime may have crossed threads.
+    //
+    // Note, though, that if async support is disabled at compile time then
+    // these functions are free to be inlined.
+    pub(super) mod raw {
+        use super::CallThreadState;
+        use sptr::Strict;
+
+        pub type Ptr = *const CallThreadState;
+
+        const _: () = {
+            assert!(core::mem::align_of::<CallThreadState>() > 1);
+        };
+
+        fn tls_get() -> (Ptr, bool) {
+            let mut initialized = false;
+            let p = Strict::map_addr(crate::runtime::vm::sys::tls_get(), |a| {
+                initialized = (a & 1) != 0;
+                a & !1
+            });
+            (p.cast(), initialized)
+        }
+
+        fn tls_set(ptr: Ptr, initialized: bool) {
+            let encoded = Strict::map_addr(ptr, |a| a | usize::from(initialized));
+            crate::runtime::vm::sys::tls_set(encoded.cast_mut().cast::<u8>());
+        }
+
+        #[cfg_attr(feature = "async", inline(never))] // see module docs
+        #[cfg_attr(not(feature = "async"), inline)]
+        pub fn replace(val: Ptr) -> Ptr {
+            // When a new value is configured that means that we may be
+            // entering WebAssembly so check to see if this thread has
+            // performed per-thread initialization for traps.
+            let (prev, initialized) = tls_get();
+            if !initialized {
+                super::super::lazy_per_thread_init();
+            }
+            tls_set(val, true);
+            prev
+        }
+
+        /// Eagerly initialize thread-local runtime functionality. This will be performed
+        /// lazily by the runtime if users do not perform it eagerly.
+        #[cfg_attr(feature = "async", inline(never))] // see module docs
+        #[cfg_attr(not(feature = "async"), inline)]
+        pub fn initialize() {
+            let (state, initialized) = tls_get();
+            if initialized {
+                return;
+            }
+            super::super::lazy_per_thread_init();
+            tls_set(state, true);
+        }
+
+        #[cfg_attr(feature = "async", inline(never))] // see module docs
+        #[cfg_attr(not(feature = "async"), inline)]
+        pub fn get() -> Ptr {
+            tls_get().0
+        }
+    }
+
+    pub use raw::initialize as tls_eager_initialize;
+
+    /// Opaque state used to persist the state of the `CallThreadState`
+    /// activations associated with a fiber stack that's used as part of an
+    /// async wasm call.
+    pub struct AsyncWasmCallState {
+        // The head of a linked list of activations that are currently present
+        // on an async call's fiber stack. This pointer points to the oldest
+        // activation frame where the `prev` links internally link to younger
+        // activation frames.
+        //
+        // When pushed onto a thread this linked list is traversed to get pushed
+        // onto the current thread at the time.
+        state: raw::Ptr,
+    }
+
+    impl AsyncWasmCallState {
+        /// Creates new state that initially starts as null.
+        pub fn new() -> AsyncWasmCallState {
+            AsyncWasmCallState {
+                state: core::ptr::null_mut(),
+            }
+        }
+
+        /// Pushes the saved state of this wasm's call onto the current thread's
+        /// state.
+        ///
+        /// This will iterate over the linked list of states stored within
+        /// `self` and push them sequentially onto the current thread's
+        /// activation list.
+        ///
+        /// The returned `PreviousAsyncWasmCallState` captures the state of this
+        /// thread just before this operation, and it must have its `restore`
+        /// method called to restore the state when the async wasm is suspended
+        /// from.
+        ///
+        /// # Unsafety
+        ///
+        /// Must be carefully coordinated with
+        /// `PreviousAsyncWasmCallState::restore` and fiber switches to ensure
+        /// that this doesn't push stale data and the data is popped
+        /// appropriately.
+        pub unsafe fn push(self) -> PreviousAsyncWasmCallState {
+            // Our `state` pointer is a linked list of oldest-to-youngest so by
+            // pushing in order of the list we restore the youngest-to-oldest
+            // list as stored in the state of this current thread.
+            let ret = PreviousAsyncWasmCallState { state: raw::get() };
+            let mut ptr = self.state;
+            while let Some(state) = ptr.as_ref() {
+                ptr = state.prev.replace(core::ptr::null_mut());
+                state.push();
+            }
+            ret
+        }
+
+        /// Performs a runtime check that this state is indeed null.
+        pub fn assert_null(&self) {
+            assert!(self.state.is_null());
+        }
+
+        /// Asserts that the current CallThreadState pointer, if present, is not
+        /// in the `range` specified.
+        ///
+        /// This is used when exiting a future in Wasmtime to assert that the
+        /// current CallThreadState pointer does not point within the stack
+        /// we're leaving (e.g.  allocated for a fiber).
+        pub fn assert_current_state_not_in_range(range: Range<usize>) {
+            let p = raw::get() as usize;
+            assert!(p < range.start || range.end < p);
+        }
+    }
+
+    /// Opaque state used to help control TLS state across stack switches for
+    /// async support.
+    pub struct PreviousAsyncWasmCallState {
+        // The head of a linked list, similar to the TLS state. Note though that
+        // this list is stored in reverse order to assist with `push` and `pop`
+        // below.
+        //
+        // After a `push` call this stores the previous head for the current
+        // thread so we know when to stop popping during a `pop`.
+        state: raw::Ptr,
+    }
+
+    impl PreviousAsyncWasmCallState {
+        /// Pops a fiber's linked list of activations and stores them in
+        /// `AsyncWasmCallState`.
+        ///
+        /// This will pop the top activation of this current thread continuously
+        /// until it reaches whatever the current activation was when `push` was
+        /// originally called.
+        ///
+        /// # Unsafety
+        ///
+        /// Must be paired with a `push` and only performed at a time when a
+        /// fiber is being suspended.
+        pub unsafe fn restore(self) -> AsyncWasmCallState {
+            let thread_head = self.state;
+            mem::forget(self);
+            let mut ret = AsyncWasmCallState::new();
+            loop {
+                // If the current TLS state is as we originally found it, then
+                // this loop is finished.
+                let ptr = raw::get();
+                if ptr == thread_head {
+                    break ret;
+                }
+
+                // Pop this activation from the current thread's TLS state, and
+                // then afterwards push it onto our own linked list within this
+                // `AsyncWasmCallState`. Note that the linked list in `AsyncWasmCallState` is stored
+                // in reverse order so a subsequent `push` later on pushes
+                // everything in the right order.
+                (*ptr).pop();
+                if let Some(state) = ret.state.as_ref() {
+                    (*ptr).prev.set(state);
+                }
+                ret.state = ptr;
+            }
+        }
+    }
+
+    impl Drop for PreviousAsyncWasmCallState {
+        fn drop(&mut self) {
+            panic!("must be consumed with `restore`");
+        }
+    }
+
+    /// Configures thread local state such that for the duration of the
+    /// execution of `closure` any call to `with` will yield `state`, unless
+    /// this is recursively called again.
+    #[inline]
+    pub fn set<R>(state: &mut CallThreadState, closure: impl FnOnce(&CallThreadState) -> R) -> R {
+        struct Reset<'a> {
+            state: &'a CallThreadState,
+        }
+
+        impl Drop for Reset<'_> {
+            #[inline]
+            fn drop(&mut self) {
+                unsafe {
+                    self.state.pop();
+                }
+            }
+        }
+
+        unsafe {
+            state.push();
+            let reset = Reset { state };
+            closure(reset.state)
+        }
+    }
+
+    /// Returns the last pointer configured with `set` above, if any.
+    pub fn with<R>(closure: impl FnOnce(Option<&CallThreadState>) -> R) -> R {
+        let p = raw::get();
+        unsafe { closure(if p.is_null() { None } else { Some(&*p) }) }
+    }
+}
diff --git a/crates/runtime/src/traphandlers/backtrace.rs b/crates/wasmtime/src/runtime/vm/traphandlers/backtrace.rs
similarity index 88%
rename from crates/runtime/src/traphandlers/backtrace.rs
rename to crates/wasmtime/src/runtime/vm/traphandlers/backtrace.rs
index 0b61fb425f5d..cf589aaf3813 100644
--- a/crates/runtime/src/traphandlers/backtrace.rs
+++ b/crates/wasmtime/src/runtime/vm/traphandlers/backtrace.rs
@@ -10,9 +10,10 @@
 //! To perform (1) we maintain the entry stack pointer (SP) and exit frame
 //! pointer (FP) and program counter (PC) each time we call into Wasm and Wasm
 //! calls into the host via trampolines (see
-//! `crates/runtime/src/trampolines`). The most recent entry is stored in
-//! `VMRuntimeLimits` and older entries are saved in `CallThreadState`. This
-//! lets us identify ranges of contiguous Wasm frames on the stack.
+//! `crates/wasmtime/src/runtime/vm/trampolines`). The most recent entry is
+//! stored in `VMRuntimeLimits` and older entries are saved in
+//! `CallThreadState`. This lets us identify ranges of contiguous Wasm frames on
+//! the stack.
 //!
 //! To solve (2) and walk the Wasm frames within a region of contiguous Wasm
 //! frames on the stack, we configure Cranelift's `preserve_frame_pointers =
@@ -20,38 +21,13 @@
 //! exit FP and stopping once we reach the entry SP (meaning that the next older
 //! frame is a host frame).
 
-use crate::{
+use crate::prelude::*;
+use crate::runtime::vm::arch;
+use crate::runtime::vm::{
     traphandlers::{tls, CallThreadState},
     VMRuntimeLimits,
 };
-use cfg_if::cfg_if;
-use std::ops::ControlFlow;
-
-// Architecture-specific bits for stack walking. Each of these modules should
-// define and export the following functions:
-//
-// * `unsafe fn get_next_older_pc_from_fp(fp: usize) -> usize`
-// * `unsafe fn get_next_older_fp_from_fp(fp: usize) -> usize`
-// * `fn reached_entry_sp(fp: usize, first_wasm_sp: usize) -> bool`
-// * `fn assert_entry_sp_is_aligned(sp: usize)`
-// * `fn assert_fp_is_aligned(fp: usize)`
-cfg_if! {
-    if #[cfg(target_arch = "x86_64")] {
-        mod x86_64;
-        use x86_64 as arch;
-    } else if #[cfg(target_arch = "aarch64")] {
-        mod aarch64;
-        use aarch64 as arch;
-    } else if #[cfg(target_arch = "s390x")] {
-        mod s390x;
-        use s390x as arch;
-    } else if #[cfg(target_arch = "riscv64")] {
-        mod riscv64;
-        use riscv64 as arch;
-    } else {
-        compile_error!("unsupported architecture");
-    }
-}
+use core::ops::ControlFlow;
 
 /// A WebAssembly stack trace.
 #[derive(Debug)]
@@ -134,7 +110,7 @@ impl Backtrace {
             // trampoline did not get a chance to save the last Wasm PC and FP,
             // and we need to use the plumbed-through values instead.
             Some((pc, fp)) => {
-                assert!(std::ptr::eq(limits, state.limits));
+                assert!(core::ptr::eq(limits, state.limits));
                 (pc, fp)
             }
             // Either there is no Wasm currently on the stack, or we exited Wasm
@@ -146,7 +122,7 @@ impl Backtrace {
             }
         };
 
-        let activations = std::iter::once((
+        let activations = core::iter::once((
             last_wasm_exit_pc,
             last_wasm_exit_fp,
             *(*limits).last_wasm_entry_sp.get(),
@@ -154,7 +130,7 @@ impl Backtrace {
         .chain(
             state
                 .iter()
-                .filter(|state| std::ptr::eq(limits, state.limits))
+                .filter(|state| core::ptr::eq(limits, state.limits))
                 .map(|state| {
                     (
                         state.old_last_wasm_exit_pc(),
diff --git a/crates/wasmtime/src/runtime/vm/traphandlers/coredump_disabled.rs b/crates/wasmtime/src/runtime/vm/traphandlers/coredump_disabled.rs
new file mode 100644
index 000000000000..d4dc86a1d9bc
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/traphandlers/coredump_disabled.rs
@@ -0,0 +1,16 @@
+use crate::runtime::vm::traphandlers::CallThreadState;
+use crate::runtime::vm::VMRuntimeLimits;
+
+/// A WebAssembly Coredump
+#[derive(Debug)]
+pub enum CoreDumpStack {}
+
+impl CallThreadState {
+    pub(super) fn capture_coredump(
+        &self,
+        _limits: *const VMRuntimeLimits,
+        _trap_pc_and_fp: Option<(usize, usize)>,
+    ) -> Option<CoreDumpStack> {
+        None
+    }
+}
diff --git a/crates/wasmtime/src/runtime/vm/traphandlers/coredump_enabled.rs b/crates/wasmtime/src/runtime/vm/traphandlers/coredump_enabled.rs
new file mode 100644
index 000000000000..6d269af67f1c
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/traphandlers/coredump_enabled.rs
@@ -0,0 +1,42 @@
+use super::CallThreadState;
+use crate::prelude::*;
+use crate::runtime::vm::{Backtrace, VMRuntimeLimits};
+use wasm_encoder::CoreDumpValue;
+
+/// A WebAssembly Coredump
+#[derive(Debug)]
+pub struct CoreDumpStack {
+    /// The backtrace containing the stack frames for the CoreDump
+    pub bt: Backtrace,
+
+    /// The locals for each frame in the backtrace.
+    ///
+    /// This is not currently implemented.
+    #[allow(dead_code)]
+    pub locals: Vec<Vec<CoreDumpValue>>,
+
+    /// The operands for each stack frame
+    ///
+    /// This is not currently implemented.
+    #[allow(dead_code)]
+    pub operand_stack: Vec<Vec<CoreDumpValue>>,
+}
+
+impl CallThreadState {
+    pub(super) fn capture_coredump(
+        &self,
+        limits: *const VMRuntimeLimits,
+        trap_pc_and_fp: Option<(usize, usize)>,
+    ) -> Option<CoreDumpStack> {
+        if !self.capture_coredump {
+            return None;
+        }
+        let bt = unsafe { Backtrace::new_with_trap_state(limits, self, trap_pc_and_fp) };
+
+        Some(CoreDumpStack {
+            bt,
+            locals: vec![],
+            operand_stack: vec![],
+        })
+    }
+}
diff --git a/crates/runtime/src/vmcontext.rs b/crates/wasmtime/src/runtime/vm/vmcontext.rs
similarity index 78%
rename from crates/runtime/src/vmcontext.rs
rename to crates/wasmtime/src/runtime/vm/vmcontext.rs
index a46e59c3fde2..77c2aa91d9c3 100644
--- a/crates/runtime/src/vmcontext.rs
+++ b/crates/wasmtime/src/runtime/vm/vmcontext.rs
@@ -3,16 +3,20 @@
 
 mod vm_host_func_context;
 
-use crate::externref::VMExternRef;
+pub use self::vm_host_func_context::VMArrayCallHostFuncContext;
+use crate::runtime::vm::{GcStore, VMGcRef};
+use core::cell::UnsafeCell;
+use core::ffi::c_void;
+use core::fmt;
+use core::marker;
+use core::mem;
+use core::ptr::{self, NonNull};
+use core::sync::atomic::{AtomicUsize, Ordering};
 use sptr::Strict;
-use std::cell::UnsafeCell;
-use std::ffi::c_void;
-use std::marker;
-use std::ptr::NonNull;
-use std::sync::atomic::{AtomicUsize, Ordering};
-use std::u32;
-pub use vm_host_func_context::{VMArrayCallHostFuncContext, VMNativeCallHostFuncContext};
-use wasmtime_environ::{DefinedMemoryIndex, VMCONTEXT_MAGIC};
+use wasmtime_environ::{
+    BuiltinFunctionIndex, DefinedMemoryIndex, Unsigned, VMSharedTypeIndex, WasmHeapTopType,
+    WasmValType, VMCONTEXT_MAGIC,
+};
 
 /// A function pointer that exposes the array calling convention.
 ///
@@ -34,18 +38,6 @@ use wasmtime_environ::{DefinedMemoryIndex, VMCONTEXT_MAGIC};
 pub type VMArrayCallFunction =
     unsafe extern "C" fn(*mut VMOpaqueContext, *mut VMOpaqueContext, *mut ValRaw, usize);
 
-/// A function pointer that exposes the native calling convention.
-///
-/// Different Wasm function types end up mapping to different Rust function
-/// types, so this isn't simply a type alias the way that `VMArrayCallFunction`
-/// is.
-///
-/// This is the default calling convention for the target (e.g. System-V or
-/// fast-call) except multiple return values are handled by returning the first
-/// return value in a register and everything else through a return-pointer.
-#[repr(transparent)]
-pub struct VMNativeCallFunction(VMFunctionBody);
-
 /// A function pointer that exposes the Wasm calling convention.
 ///
 /// In practice, different Wasm function types end up mapping to different Rust
@@ -64,9 +56,6 @@ pub struct VMFunctionImport {
     /// Function pointer to use when calling this imported function from Wasm.
     pub wasm_call: NonNull<VMWasmCallFunction>,
 
-    /// Function pointer to use when calling this imported function from native code.
-    pub native_call: NonNull<VMNativeCallFunction>,
-
     /// Function pointer to use when calling this imported function with the
     /// "array" calling convention that `Func::new` et al use.
     pub array_call: VMArrayCallFunction,
@@ -88,7 +77,7 @@ unsafe impl Sync for VMFunctionImport {}
 #[cfg(test)]
 mod test_vmfunction_import {
     use super::VMFunctionImport;
-    use memoffset::offset_of;
+    use core::mem::offset_of;
     use std::mem::size_of;
     use wasmtime_environ::{Module, VMOffsets};
 
@@ -104,10 +93,6 @@ mod test_vmfunction_import {
             offset_of!(VMFunctionImport, wasm_call),
             usize::from(offsets.vmfunction_import_wasm_call())
         );
-        assert_eq!(
-            offset_of!(VMFunctionImport, native_call),
-            usize::from(offsets.vmfunction_import_native_call())
-        );
         assert_eq!(
             offset_of!(VMFunctionImport, array_call),
             usize::from(offsets.vmfunction_import_array_call())
@@ -157,7 +142,7 @@ unsafe impl Sync for VMTableImport {}
 #[cfg(test)]
 mod test_vmtable_import {
     use super::VMTableImport;
-    use memoffset::offset_of;
+    use core::mem::offset_of;
     use std::mem::size_of;
     use wasmtime_environ::{Module, VMOffsets};
 
@@ -203,7 +188,7 @@ unsafe impl Sync for VMMemoryImport {}
 #[cfg(test)]
 mod test_vmmemory_import {
     use super::VMMemoryImport;
-    use memoffset::offset_of;
+    use core::mem::offset_of;
     use std::mem::size_of;
     use wasmtime_environ::{Module, VMOffsets};
 
@@ -247,7 +232,7 @@ unsafe impl Sync for VMGlobalImport {}
 #[cfg(test)]
 mod test_vmglobal_import {
     use super::VMGlobalImport;
-    use memoffset::offset_of;
+    use core::mem::offset_of;
     use std::mem::size_of;
     use wasmtime_environ::{Module, VMOffsets};
 
@@ -284,13 +269,14 @@ pub struct VMMemoryDefinition {
 }
 
 impl VMMemoryDefinition {
-    /// Return the current length of the [`VMMemoryDefinition`] by performing a
-    /// relaxed load; do not use this function for situations in which a precise
-    /// length is needed. Owned memories (i.e., non-shared) will always return a
-    /// precise result (since no concurrent modification is possible) but shared
-    /// memories may see an imprecise value--a `current_length` potentially
-    /// smaller than what some other thread observes. Since Wasm memory only
-    /// grows, this under-estimation may be acceptable in certain cases.
+    /// Return the current length (in bytes) of the [`VMMemoryDefinition`] by
+    /// performing a relaxed load; do not use this function for situations in
+    /// which a precise length is needed. Owned memories (i.e., non-shared) will
+    /// always return a precise result (since no concurrent modification is
+    /// possible) but shared memories may see an imprecise value--a
+    /// `current_length` potentially smaller than what some other thread
+    /// observes. Since Wasm memory only grows, this under-estimation may be
+    /// acceptable in certain cases.
     pub fn current_length(&self) -> usize {
         self.current_length.load(Ordering::Relaxed)
     }
@@ -309,7 +295,7 @@ impl VMMemoryDefinition {
 #[cfg(test)]
 mod test_vmmemory_definition {
     use super::VMMemoryDefinition;
-    use memoffset::offset_of;
+    use core::mem::offset_of;
     use std::mem::size_of;
     use wasmtime_environ::{Module, PtrSize, VMOffsets};
 
@@ -353,7 +339,7 @@ pub struct VMTableDefinition {
 #[cfg(test)]
 mod test_vmtable_definition {
     use super::VMTableDefinition;
-    use memoffset::offset_of;
+    use core::mem::offset_of;
     use std::mem::size_of;
     use wasmtime_environ::{Module, VMOffsets};
 
@@ -390,7 +376,6 @@ pub struct VMGlobalDefinition {
 #[cfg(test)]
 mod test_vmglobal_definition {
     use super::VMGlobalDefinition;
-    use crate::externref::VMExternRef;
     use std::mem::{align_of, size_of};
     use wasmtime_environ::{Module, PtrSize, VMOffsets};
 
@@ -421,8 +406,9 @@ mod test_vmglobal_definition {
     }
 
     #[test]
-    fn check_vmglobal_can_contain_externref() {
-        assert!(size_of::<VMExternRef>() <= size_of::<VMGlobalDefinition>());
+    #[cfg(feature = "gc")]
+    fn check_vmglobal_can_contain_gc_ref() {
+        assert!(size_of::<crate::runtime::vm::VMGcRef>() <= size_of::<VMGlobalDefinition>());
     }
 }
 
@@ -432,6 +418,56 @@ impl VMGlobalDefinition {
         Self { storage: [0; 16] }
     }
 
+    /// Create a `VMGlobalDefinition` from a `ValRaw`.
+    ///
+    /// # Unsafety
+    ///
+    /// This raw value's type must match the given `WasmValType`.
+    pub unsafe fn from_val_raw(wasm_ty: WasmValType, raw: ValRaw) -> Self {
+        let mut global = Self::new();
+        match wasm_ty {
+            WasmValType::I32 => *global.as_i32_mut() = raw.get_i32(),
+            WasmValType::I64 => *global.as_i64_mut() = raw.get_i64(),
+            WasmValType::F32 => *global.as_f32_bits_mut() = raw.get_f32(),
+            WasmValType::F64 => *global.as_f64_bits_mut() = raw.get_f64(),
+            WasmValType::V128 => *global.as_u128_mut() = raw.get_v128(),
+            WasmValType::Ref(r) => match r.heap_type.top() {
+                WasmHeapTopType::Extern => {
+                    global.init_gc_ref(VMGcRef::from_raw_u32(raw.get_externref()))
+                }
+                WasmHeapTopType::Any => global.init_gc_ref(VMGcRef::from_raw_u32(raw.get_anyref())),
+                WasmHeapTopType::Func => *global.as_func_ref_mut() = raw.get_funcref().cast(),
+            },
+        }
+        global
+    }
+
+    /// Get this global's value as a `ValRaw`.
+    ///
+    /// # Unsafety
+    ///
+    /// This global's value's type must match the given `WasmValType`.
+    pub unsafe fn to_val_raw(&self, gc_store: &mut GcStore, wasm_ty: WasmValType) -> ValRaw {
+        match wasm_ty {
+            WasmValType::I32 => ValRaw::i32(*self.as_i32()),
+            WasmValType::I64 => ValRaw::i64(*self.as_i64()),
+            WasmValType::F32 => ValRaw::f32(*self.as_f32_bits()),
+            WasmValType::F64 => ValRaw::f64(*self.as_f64_bits()),
+            WasmValType::V128 => ValRaw::v128(*self.as_u128()),
+            WasmValType::Ref(r) => match r.heap_type.top() {
+                WasmHeapTopType::Extern => ValRaw::externref(
+                    self.as_gc_ref()
+                        .map_or(0, |r| gc_store.clone_gc_ref(r).as_raw_u32()),
+                ),
+                WasmHeapTopType::Any => ValRaw::anyref(
+                    self.as_gc_ref()
+                        .map_or(0, |r| gc_store.clone_gc_ref(r).as_raw_u32()),
+                ),
+                WasmHeapTopType::Func => ValRaw::funcref(self.as_func_ref().cast()),
+            },
+        }
+    }
+
     /// Return a reference to the value as an i32.
     pub unsafe fn as_i32(&self) -> &i32 {
         &*(self.storage.as_ref().as_ptr().cast::<i32>())
@@ -532,18 +568,29 @@ impl VMGlobalDefinition {
         &mut *(self.storage.as_mut().as_mut_ptr().cast::<[u8; 16]>())
     }
 
-    /// Return a reference to the value as an externref.
-    pub unsafe fn as_externref(&self) -> &Option<VMExternRef> {
-        &*(self.storage.as_ref().as_ptr().cast::<Option<VMExternRef>>())
+    /// Return a reference to the global value as a borrowed GC reference.
+    pub unsafe fn as_gc_ref(&self) -> Option<&VMGcRef> {
+        let raw_ptr = self.storage.as_ref().as_ptr().cast::<Option<VMGcRef>>();
+        let ret = (*raw_ptr).as_ref();
+        assert!(cfg!(feature = "gc") || ret.is_none());
+        ret
+    }
+
+    /// Initialize a global to the given GC reference.
+    pub unsafe fn init_gc_ref(&mut self, gc_ref: Option<VMGcRef>) {
+        assert!(cfg!(feature = "gc") || gc_ref.is_none());
+        let raw_ptr = self.storage.as_mut().as_mut_ptr().cast::<Option<VMGcRef>>();
+        ptr::write(raw_ptr, gc_ref);
     }
 
-    /// Return a mutable reference to the value as an externref.
-    pub unsafe fn as_externref_mut(&mut self) -> &mut Option<VMExternRef> {
-        &mut *(self
-            .storage
-            .as_mut()
-            .as_mut_ptr()
-            .cast::<Option<VMExternRef>>())
+    /// Write a GC reference into this global value.
+    pub unsafe fn write_gc_ref(&mut self, gc_store: &mut GcStore, gc_ref: Option<&VMGcRef>) {
+        assert!(cfg!(feature = "gc") || gc_ref.is_none());
+
+        let dest = &mut *(self.storage.as_mut().as_mut_ptr().cast::<Option<VMGcRef>>());
+        assert!(cfg!(feature = "gc") || dest.is_none());
+
+        gc_store.write_gc_ref(dest, gc_ref)
     }
 
     /// Return a reference to the value as a `VMFuncRef`.
@@ -557,61 +604,30 @@ impl VMGlobalDefinition {
     }
 }
 
-/// An index into the shared signature registry, usable for checking signatures
-/// at indirect calls.
-#[repr(C)]
-#[derive(Debug, Eq, PartialEq, Clone, Copy, Hash)]
-pub struct VMSharedSignatureIndex(u32);
-
 #[cfg(test)]
-mod test_vmshared_signature_index {
-    use super::VMSharedSignatureIndex;
+mod test_vmshared_type_index {
+    use super::VMSharedTypeIndex;
     use std::mem::size_of;
     use wasmtime_environ::{Module, VMOffsets};
 
     #[test]
-    fn check_vmshared_signature_index() {
+    fn check_vmshared_type_index() {
         let module = Module::new();
         let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module);
         assert_eq!(
-            size_of::<VMSharedSignatureIndex>(),
-            usize::from(offsets.size_of_vmshared_signature_index())
+            size_of::<VMSharedTypeIndex>(),
+            usize::from(offsets.size_of_vmshared_type_index())
         );
     }
 }
 
-impl VMSharedSignatureIndex {
-    /// Create a new `VMSharedSignatureIndex`.
-    #[inline]
-    pub fn new(value: u32) -> Self {
-        Self(value)
-    }
-
-    /// Returns the underlying bits of the index.
-    #[inline]
-    pub fn bits(&self) -> u32 {
-        self.0
-    }
-}
-
-impl Default for VMSharedSignatureIndex {
-    #[inline]
-    fn default() -> Self {
-        Self::new(u32::MAX)
-    }
-}
-
 /// The VM caller-checked "funcref" record, for caller-side signature checking.
 ///
-/// It consists of function pointer(s), a signature id to be checked by the
+/// It consists of function pointer(s), a type id to be checked by the
 /// caller, and the vmctx closure associated with this function.
 #[derive(Debug, Clone)]
 #[repr(C)]
 pub struct VMFuncRef {
-    /// Function pointer for this funcref if being called via the native calling
-    /// convention.
-    pub native_call: NonNull<VMNativeCallFunction>,
-
     /// Function pointer for this funcref if being called via the "array"
     /// calling convention that `Func::new` et al use.
     pub array_call: VMArrayCallFunction,
@@ -625,7 +641,7 @@ pub struct VMFuncRef {
     /// Wasm-to-native trampoline for the function. In this case, we leave
     /// `wasm_call` empty until the function is passed as an import to Wasm (or
     /// otherwise exposed to Wasm via tables/globals). At this point, we look up
-    /// a Wasm-to-native trampoline for the function in the the Wasm's compiled
+    /// a Wasm-to-native trampoline for the function in the Wasm's compiled
     /// module and use that fill in `VMFunctionImport::wasm_call`. **However**
     /// there is no guarantee that the Wasm module has a trampoline for this
     /// function's signature. The Wasm module only has trampolines for its
@@ -636,8 +652,8 @@ pub struct VMFuncRef {
     /// the vast vast vast majority of the time.
     pub wasm_call: Option<NonNull<VMWasmCallFunction>>,
 
-    /// Function signature id.
-    pub type_index: VMSharedSignatureIndex,
+    /// Function signature's type id.
+    pub type_index: VMSharedTypeIndex,
 
     /// The VM state associated with this function.
     ///
@@ -655,7 +671,7 @@ unsafe impl Sync for VMFuncRef {}
 #[cfg(test)]
 mod test_vm_func_ref {
     use super::VMFuncRef;
-    use memoffset::offset_of;
+    use core::mem::offset_of;
     use std::mem::size_of;
     use wasmtime_environ::{Module, PtrSize, VMOffsets};
 
@@ -667,10 +683,6 @@ mod test_vm_func_ref {
             size_of::<VMFuncRef>(),
             usize::from(offsets.ptr.size_of_vm_func_ref())
         );
-        assert_eq!(
-            offset_of!(VMFuncRef, native_call),
-            usize::from(offsets.ptr.vm_func_ref_native_call())
-        );
         assert_eq!(
             offset_of!(VMFuncRef, array_call),
             usize::from(offsets.ptr.vm_func_ref_array_call())
@@ -709,56 +721,31 @@ macro_rules! define_builtin_array {
         }
 
         impl VMBuiltinFunctionsArray {
+            #[allow(unused_doc_comments)]
             pub const INIT: VMBuiltinFunctionsArray = VMBuiltinFunctionsArray {
-                $($name: crate::libcalls::trampolines::$name,)*
+                $(
+                    $name: crate::runtime::vm::libcalls::raw::$name,
+                )*
             };
         }
     };
 
     (@ty i32) => (u32);
     (@ty i64) => (u64);
-    (@ty reference) => (*mut u8);
+    (@ty reference) => (u32);
     (@ty pointer) => (*mut u8);
     (@ty vmctx) => (*mut VMContext);
 }
 
 wasmtime_environ::foreach_builtin_function!(define_builtin_array);
 
-/// The storage for a WebAssembly invocation argument
-///
-/// TODO: These could be packed more densely, rather than using the same size for every type.
-#[derive(Debug, Copy, Clone)]
-#[repr(C, align(16))]
-pub struct VMInvokeArgument([u8; 16]);
-
-#[cfg(test)]
-mod test_vm_invoke_argument {
-    use super::VMInvokeArgument;
-    use std::mem::{align_of, size_of};
-    use wasmtime_environ::{Module, PtrSize, VMOffsets};
-
-    #[test]
-    fn check_vm_invoke_argument_alignment() {
-        assert_eq!(align_of::<VMInvokeArgument>(), 16);
-    }
-
-    #[test]
-    fn check_vmglobal_definition_offsets() {
-        let module = Module::new();
-        let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module);
-        assert_eq!(
-            size_of::<VMInvokeArgument>(),
-            usize::from(offsets.ptr.size_of_vmglobal_definition())
-        );
-    }
-}
-
-impl VMInvokeArgument {
-    /// Create a new invocation argument filled with zeroes
-    pub fn new() -> Self {
-        Self([0; 16])
-    }
-}
+const _: () = {
+    assert!(
+        mem::size_of::<VMBuiltinFunctionsArray>()
+            == mem::size_of::<usize>()
+                * (BuiltinFunctionIndex::builtin_functions_total_number() as usize)
+    )
+};
 
 /// Structure used to control interrupting wasm code.
 #[derive(Debug)]
@@ -816,7 +803,7 @@ pub struct VMRuntimeLimits {
     /// to the host.
     ///
     /// When a host function is wrapped into a `wasmtime::Func`, and is then
-    /// called from the host, then this member has the sentinal value of `-1 as
+    /// called from the host, then this member has the sentinel value of `-1 as
     /// usize`, meaning that this contiguous sequence of Wasm frames is the
     /// empty sequence, and it is not safe to dereference the
     /// `last_wasm_exit_fp`.
@@ -849,20 +836,10 @@ impl Default for VMRuntimeLimits {
 #[cfg(test)]
 mod test_vmruntime_limits {
     use super::VMRuntimeLimits;
-    use memoffset::offset_of;
+    use core::mem::offset_of;
     use std::mem::size_of;
     use wasmtime_environ::{Module, PtrSize, VMOffsets};
 
-    #[test]
-    fn vmctx_runtime_limits_offset() {
-        let module = Module::new();
-        let offsets = VMOffsets::new(size_of::<*mut u8>() as u8, &module);
-        assert_eq!(
-            offsets.vmctx_runtime_limits(),
-            offsets.ptr.vmcontext_runtime_limits().into()
-        );
-    }
-
     #[test]
     fn field_offsets() {
         let module = Module::new();
@@ -994,15 +971,16 @@ pub union ValRaw {
 
     /// A WebAssembly `v128` value.
     ///
-    /// The payload here is a Rust `u128` which has the same number of bits but
-    /// note that `v128` in WebAssembly is often considered a vector type such
-    /// as `i32x4` or `f64x2`. This means that the actual interpretation of the
-    /// underlying bits is left up to the instructions which consume this value.
+    /// The payload here is a Rust `[u8; 16]` which has the same number of bits
+    /// but note that `v128` in WebAssembly is often considered a vector type
+    /// such as `i32x4` or `f64x2`. This means that the actual interpretation
+    /// of the underlying bits is left up to the instructions which consume
+    /// this value.
     ///
     /// This value is always stored in a little-endian format.
-    v128: u128,
+    v128: [u8; 16],
 
-    /// A WebAssembly `funcref` value.
+    /// A WebAssembly `funcref` value (or one of its subtypes).
     ///
     /// The payload here is a pointer which is runtime-defined. This is one of
     /// the main points of unsafety about the `ValRaw` type as the validity of
@@ -1012,23 +990,82 @@ pub union ValRaw {
     /// This value is always stored in a little-endian format.
     funcref: *mut c_void,
 
-    /// A WebAssembly `externref` value.
+    /// A WebAssembly `externref` value (or one of its subtypes).
     ///
-    /// The payload here is a pointer which is runtime-defined. This is one of
-    /// the main points of unsafety about the `ValRaw` type as the validity of
-    /// the pointer here is not easily verified and must be preserved by
-    /// carefully calling the correct functions throughout the runtime.
+    /// The payload here is a compressed pointer value which is
+    /// runtime-defined. This is one of the main points of unsafety about the
+    /// `ValRaw` type as the validity of the pointer here is not easily verified
+    /// and must be preserved by carefully calling the correct functions
+    /// throughout the runtime.
+    ///
+    /// This value is always stored in a little-endian format.
+    externref: u32,
+
+    /// A WebAssembly `anyref` value (or one of its subtypes).
+    ///
+    /// The payload here is a compressed pointer value which is
+    /// runtime-defined. This is one of the main points of unsafety about the
+    /// `ValRaw` type as the validity of the pointer here is not easily verified
+    /// and must be preserved by carefully calling the correct functions
+    /// throughout the runtime.
     ///
     /// This value is always stored in a little-endian format.
-    externref: *mut c_void,
+    anyref: u32,
 }
 
+// The `ValRaw` type is matched as `wasmtime_val_raw_t` in the C API so these
+// are some simple assertions about the shape of the type which are additionally
+// matched in C.
+const _: () = {
+    assert!(mem::size_of::<ValRaw>() == 16);
+    assert!(mem::align_of::<ValRaw>() == mem::align_of::<u64>());
+};
+
 // This type is just a bag-of-bits so it's up to the caller to figure out how
 // to safely deal with threading concerns and safely access interior bits.
 unsafe impl Send for ValRaw {}
 unsafe impl Sync for ValRaw {}
 
+impl fmt::Debug for ValRaw {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        struct Hex<T>(T);
+        impl<T: fmt::LowerHex> fmt::Debug for Hex<T> {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                let bytes = mem::size_of::<T>();
+                let hex_digits_per_byte = 2;
+                let hex_digits = bytes * hex_digits_per_byte;
+                write!(f, "0x{:0width$x}", self.0, width = hex_digits)
+            }
+        }
+
+        unsafe {
+            f.debug_struct("ValRaw")
+                .field("i32", &Hex(self.i32))
+                .field("i64", &Hex(self.i64))
+                .field("f32", &Hex(self.f32))
+                .field("f64", &Hex(self.f64))
+                .field("v128", &Hex(u128::from_le_bytes(self.v128)))
+                .field("funcref", &self.funcref)
+                .field("externref", &Hex(self.externref))
+                .field("anyref", &Hex(self.anyref))
+                .finish()
+        }
+    }
+}
+
 impl ValRaw {
+    /// Create a null reference that is compatible with any of
+    /// `{any,extern,func}ref`.
+    pub fn null() -> ValRaw {
+        unsafe {
+            let raw = mem::MaybeUninit::<Self>::zeroed().assume_init();
+            debug_assert_eq!(raw.get_anyref(), 0);
+            debug_assert_eq!(raw.get_externref(), 0);
+            debug_assert_eq!(raw.get_funcref(), ptr::null_mut());
+            raw
+        }
+    }
+
     /// Creates a WebAssembly `i32` value
     #[inline]
     pub fn i32(i: i32) -> ValRaw {
@@ -1038,7 +1075,7 @@ impl ValRaw {
         // `wasmtime` crate. Otherwise though all `ValRaw` constructors are
         // otherwise constrained to guarantee that the initial 64-bits are
         // always initialized.
-        ValRaw::u64((i as u32).into())
+        ValRaw::u64(i.unsigned().into())
     }
 
     /// Creates a WebAssembly `i64` value
@@ -1078,7 +1115,9 @@ impl ValRaw {
     /// Creates a WebAssembly `v128` value
     #[inline]
     pub fn v128(i: u128) -> ValRaw {
-        ValRaw { v128: i.to_le() }
+        ValRaw {
+            v128: i.to_le_bytes(),
+        }
     }
 
     /// Creates a WebAssembly `funcref` value
@@ -1091,12 +1130,20 @@ impl ValRaw {
 
     /// Creates a WebAssembly `externref` value
     #[inline]
-    pub fn externref(i: *mut c_void) -> ValRaw {
+    pub fn externref(e: u32) -> ValRaw {
+        assert!(cfg!(feature = "gc") || e == 0);
         ValRaw {
-            externref: Strict::map_addr(i, |i| i.to_le()),
+            externref: e.to_le(),
         }
     }
 
+    /// Creates a WebAssembly `anyref` value
+    #[inline]
+    pub fn anyref(r: u32) -> ValRaw {
+        assert!(cfg!(feature = "gc") || r == 0);
+        ValRaw { anyref: r.to_le() }
+    }
+
     /// Gets the WebAssembly `i32` value
     #[inline]
     pub fn get_i32(&self) -> i32 {
@@ -1112,13 +1159,13 @@ impl ValRaw {
     /// Gets the WebAssembly `i32` value
     #[inline]
     pub fn get_u32(&self) -> u32 {
-        self.get_i32() as u32
+        self.get_i32().unsigned()
     }
 
     /// Gets the WebAssembly `i64` value
     #[inline]
     pub fn get_u64(&self) -> u64 {
-        self.get_i64() as u64
+        self.get_i64().unsigned()
     }
 
     /// Gets the WebAssembly `f32` value
@@ -1136,7 +1183,7 @@ impl ValRaw {
     /// Gets the WebAssembly `v128` value
     #[inline]
     pub fn get_v128(&self) -> u128 {
-        unsafe { u128::from_le(self.v128) }
+        unsafe { u128::from_le_bytes(self.v128) }
     }
 
     /// Gets the WebAssembly `funcref` value
@@ -1147,8 +1194,18 @@ impl ValRaw {
 
     /// Gets the WebAssembly `externref` value
     #[inline]
-    pub fn get_externref(&self) -> *mut c_void {
-        unsafe { Strict::map_addr(self.externref, |i| usize::from_le(i)) }
+    pub fn get_externref(&self) -> u32 {
+        let externref = u32::from_le(unsafe { self.externref });
+        assert!(cfg!(feature = "gc") || externref == 0);
+        externref
+    }
+
+    /// Gets the WebAssembly `anyref` value
+    #[inline]
+    pub fn get_anyref(&self) -> u32 {
+        let anyref = u32::from_le(unsafe { self.anyref });
+        assert!(cfg!(feature = "gc") || anyref == 0);
+        anyref
     }
 }
 
@@ -1186,12 +1243,4 @@ impl VMOpaqueContext {
     ) -> *mut VMOpaqueContext {
         ptr.cast()
     }
-
-    /// Helper function to clearly indicate that casts are desired.
-    #[inline]
-    pub fn from_vm_native_call_host_func_context(
-        ptr: *mut VMNativeCallHostFuncContext,
-    ) -> *mut VMOpaqueContext {
-        ptr.cast()
-    }
 }
diff --git a/crates/wasmtime/src/runtime/vm/vmcontext/vm_host_func_context.rs b/crates/wasmtime/src/runtime/vm/vmcontext/vm_host_func_context.rs
new file mode 100644
index 000000000000..8e525596a823
--- /dev/null
+++ b/crates/wasmtime/src/runtime/vm/vmcontext/vm_host_func_context.rs
@@ -0,0 +1,79 @@
+//! Definition of `VM*Context` variant for host functions.
+//!
+//! Keep in sync with `wasmtime_environ::VMHostFuncOffsets`.
+
+use super::VMOpaqueContext;
+use crate::prelude::*;
+use crate::runtime::vm::{StoreBox, VMFuncRef};
+use core::any::Any;
+use wasmtime_environ::VM_ARRAY_CALL_HOST_FUNC_MAGIC;
+
+/// The `VM*Context` for array-call host functions.
+///
+/// Its `magic` field must always be
+/// `wasmtime_environ::VM_ARRAY_CALL_HOST_FUNC_MAGIC`, and this is how you can
+/// determine whether a `VM*Context` is a `VMArrayCallHostFuncContext` versus a
+/// different kind of context.
+#[repr(C)]
+pub struct VMArrayCallHostFuncContext {
+    magic: u32,
+    // _padding: u32, // (on 64-bit systems)
+    pub(crate) func_ref: VMFuncRef,
+    host_state: Box<dyn Any + Send + Sync>,
+}
+
+impl VMArrayCallHostFuncContext {
+    /// Create the context for the given host function.
+    ///
+    /// # Safety
+    ///
+    /// The `host_func` must be a pointer to a host (not Wasm) function and it
+    /// must be `Send` and `Sync`.
+    pub unsafe fn new(
+        func_ref: VMFuncRef,
+        host_state: Box<dyn Any + Send + Sync>,
+    ) -> StoreBox<VMArrayCallHostFuncContext> {
+        debug_assert!(func_ref.vmctx.is_null());
+        let ctx = StoreBox::new(VMArrayCallHostFuncContext {
+            magic: wasmtime_environ::VM_ARRAY_CALL_HOST_FUNC_MAGIC,
+            func_ref,
+            host_state,
+        });
+        let vmctx = VMOpaqueContext::from_vm_array_call_host_func_context(ctx.get());
+        unsafe {
+            (*ctx.get()).func_ref.vmctx = vmctx;
+        }
+        ctx
+    }
+
+    /// Get the host state for this host function context.
+    #[inline]
+    pub fn host_state(&self) -> &(dyn Any + Send + Sync) {
+        &*self.host_state
+    }
+
+    /// Get this context's `VMFuncRef`.
+    #[inline]
+    pub fn func_ref(&self) -> &VMFuncRef {
+        &self.func_ref
+    }
+
+    /// Helper function to cast between context types using a debug assertion to
+    /// protect against some mistakes.
+    #[inline]
+    pub unsafe fn from_opaque(opaque: *mut VMOpaqueContext) -> *mut VMArrayCallHostFuncContext {
+        // See comments in `VMContext::from_opaque` for this debug assert
+        debug_assert_eq!((*opaque).magic, VM_ARRAY_CALL_HOST_FUNC_MAGIC);
+        opaque.cast()
+    }
+}
+
+#[test]
+fn vmarray_call_host_func_context_offsets() {
+    use core::mem::offset_of;
+    use wasmtime_environ::{HostPtr, PtrSize};
+    assert_eq!(
+        usize::from(HostPtr.vmarray_call_host_func_context_func_ref()),
+        offset_of!(VMArrayCallHostFuncContext, func_ref)
+    );
+}
diff --git a/crates/wasmtime/src/runtime/windows.rs b/crates/wasmtime/src/runtime/windows.rs
new file mode 100644
index 000000000000..46022b53803a
--- /dev/null
+++ b/crates/wasmtime/src/runtime/windows.rs
@@ -0,0 +1,35 @@
+//! windows-specific extension for the `wasmtime` crate.
+//!
+//! This module is only available on Windows targets.
+//! It is not available on Linux or macOS, for example. Note that the import path for
+//! this module is `wasmtime::windows::...`, which is intended to emphasize that it
+//! is platform-specific.
+//!
+//! The traits contained in this module are intended to extend various types
+//! throughout the `wasmtime` crate with extra functionality that's only
+//! available on Windows.
+
+use crate::prelude::*;
+use crate::{AsContextMut, Store};
+use windows_sys::Win32::System::Diagnostics::Debug::EXCEPTION_POINTERS;
+
+/// Extensions for the [`Store`] type only available on Windows.
+pub trait StoreExt {
+    /// Configures a custom signal handler to execute.
+    ///
+    /// TODO: needs more documentation.
+    unsafe fn set_signal_handler<H>(&mut self, handler: H)
+    where
+        H: 'static + Fn(*mut EXCEPTION_POINTERS) -> bool + Send + Sync;
+}
+
+impl<T> StoreExt for Store<T> {
+    unsafe fn set_signal_handler<H>(&mut self, handler: H)
+    where
+        H: 'static + Fn(*mut EXCEPTION_POINTERS) -> bool + Send + Sync,
+    {
+        self.as_context_mut()
+            .0
+            .set_signal_handler(Some(Box::new(handler)));
+    }
+}
diff --git a/crates/wasmtime/src/store.rs b/crates/wasmtime/src/store.rs
deleted file mode 100644
index 48436c04f639..000000000000
--- a/crates/wasmtime/src/store.rs
+++ /dev/null
@@ -1,2360 +0,0 @@
-//! Wasmtime's "store" type
-//!
-//! This module, and its submodules, contain the `Store` type and various types
-//! used to interact with it. At first glance this is a pretty confusing module
-//! where you need to know the difference between:
-//!
-//! * `Store<T>`
-//! * `StoreContext<T>`
-//! * `StoreContextMut<T>`
-//! * `AsContext`
-//! * `AsContextMut`
-//! * `StoreInner<T>`
-//! * `StoreOpaque`
-//! * `StoreData`
-//!
-//! There's... quite a lot going on here, and it's easy to be confused. This
-//! comment is ideally going to serve the purpose of clarifying what all these
-//! types are for and why they're motivated.
-//!
-//! First it's important to know what's "internal" and what's "external". Almost
-//! everything above is defined as `pub`, but only some of the items are
-//! reexported to the outside world to be usable from this crate. Otherwise all
-//! items are `pub` within this `store` module, and the `store` module is
-//! private to the `wasmtime` crate. Notably `Store<T>`, `StoreContext<T>`,
-//! `StoreContextMut<T>`, `AsContext`, and `AsContextMut` are all public
-//! interfaces to the `wasmtime` crate. You can think of these as:
-//!
-//! * `Store<T>` - an owned reference to a store, the "root of everything"
-//! * `StoreContext<T>` - basically `&StoreInner<T>`
-//! * `StoreContextMut<T>` - more-or-less `&mut StoreInner<T>` with caveats.
-//!   Explained later.
-//! * `AsContext` - similar to `AsRef`, but produces `StoreContext<T>`
-//! * `AsContextMut` - similar to `AsMut`, but produces `StoreContextMut<T>`
-//!
-//! Next comes the internal structure of the `Store<T>` itself. This looks like:
-//!
-//! * `Store<T>` - this type is just a pointer large. It's primarily just
-//!   intended to be consumed by the outside world. Note that the "just a
-//!   pointer large" is a load-bearing implementation detail in Wasmtime. This
-//!   enables it to store a pointer to its own trait object which doesn't need
-//!   to change over time.
-//!
-//! * `StoreInner<T>` - the first layer of the contents of a `Store<T>`, what's
-//!   stored inside the `Box`. This is the general Rust pattern when one struct
-//!   is a layer over another. The surprising part, though, is that this is
-//!   further subdivided. This structure only contains things which actually
-//!   need `T` itself. The downside of this structure is that it's always
-//!   generic and means that code is monomorphized into consumer crates. We
-//!   strive to have things be as monomorphic as possible in `wasmtime` so this
-//!   type is not heavily used.
-//!
-//! * `StoreOpaque` - this is the primary contents of the `StoreInner<T>` type.
-//!   Stored inline in the outer type the "opaque" here means that it's a
-//!   "store" but it doesn't have access to the `T`. This is the primary
-//!   "internal" reference that Wasmtime uses since `T` is rarely needed by the
-//!   internals of Wasmtime.
-//!
-//! * `StoreData` - this is a final helper struct stored within `StoreOpaque`.
-//!   All references of Wasm items into a `Store` are actually indices into a
-//!   table in this structure, and the `StoreData` being separate makes it a bit
-//!   easier to manage/define/work with. There's no real fundamental reason this
-//!   is split out, although sometimes it's useful to have separate borrows into
-//!   these tables than the `StoreOpaque`.
-//!
-//! A major caveat with these representations is that the internal `&mut
-//! StoreInner<T>` is never handed out publicly to consumers of this crate, only
-//! through a wrapper of `StoreContextMut<'_, T>`. The reason for this is that
-//! we want to provide mutable, but not destructive, access to the contents of a
-//! `Store`. For example if a `StoreInner<T>` were replaced with some other
-//! `StoreInner<T>` then that would drop live instances, possibly those
-//! currently executing beneath the current stack frame. This would not be a
-//! safe operation.
-//!
-//! This means, though, that the `wasmtime` crate, which liberally uses `&mut
-//! StoreOpaque` internally, has to be careful to never actually destroy the
-//! contents of `StoreOpaque`. This is an invariant that we, as the authors of
-//! `wasmtime`, must uphold for the public interface to be safe.
-
-use crate::instance::InstanceData;
-use crate::linker::Definition;
-use crate::module::{BareModuleInfo, RegisteredModuleId};
-use crate::trampoline::VMHostGlobalContext;
-use crate::{module::ModuleRegistry, Engine, Module, Trap, Val, ValRaw};
-use crate::{Global, Instance, Memory};
-use anyhow::{anyhow, bail, Result};
-use std::cell::UnsafeCell;
-use std::convert::TryFrom;
-use std::fmt;
-use std::future::Future;
-use std::marker;
-use std::mem::{self, ManuallyDrop};
-use std::ops::{Deref, DerefMut};
-use std::pin::Pin;
-use std::ptr;
-use std::sync::atomic::AtomicU64;
-use std::sync::Arc;
-use std::task::{Context, Poll};
-use wasmtime_runtime::{
-    mpk::ProtectionKey, ExportGlobal, InstanceAllocationRequest, InstanceAllocator, InstanceHandle,
-    ModuleInfo, OnDemandInstanceAllocator, SignalHandler, StoreBox, StorePtr, VMContext,
-    VMExternRef, VMExternRefActivationsTable, VMFuncRef, VMRuntimeLimits, WasmFault,
-};
-
-mod context;
-pub use self::context::*;
-mod data;
-pub use self::data::*;
-mod func_refs;
-use func_refs::FuncRefs;
-
-/// A [`Store`] is a collection of WebAssembly instances and host-defined state.
-///
-/// All WebAssembly instances and items will be attached to and refer to a
-/// [`Store`]. For example instances, functions, globals, and tables are all
-/// attached to a [`Store`]. Instances are created by instantiating a
-/// [`Module`](crate::Module) within a [`Store`].
-///
-/// A [`Store`] is intended to be a short-lived object in a program. No form
-/// of GC is implemented at this time so once an instance is created within a
-/// [`Store`] it will not be deallocated until the [`Store`] itself is dropped.
-/// This makes [`Store`] unsuitable for creating an unbounded number of
-/// instances in it because [`Store`] will never release this memory. It's
-/// recommended to have a [`Store`] correspond roughly to the lifetime of a "main
-/// instance" that an embedding is interested in executing.
-///
-/// ## Type parameter `T`
-///
-/// Each [`Store`] has a type parameter `T` associated with it. This `T`
-/// represents state defined by the host. This state will be accessible through
-/// the [`Caller`](crate::Caller) type that host-defined functions get access
-/// to. This `T` is suitable for storing `Store`-specific information which
-/// imported functions may want access to.
-///
-/// The data `T` can be accessed through methods like [`Store::data`] and
-/// [`Store::data_mut`].
-///
-/// ## Stores, contexts, oh my
-///
-/// Most methods in Wasmtime take something of the form
-/// [`AsContext`](crate::AsContext) or [`AsContextMut`](crate::AsContextMut) as
-/// the first argument. These two traits allow ergonomically passing in the
-/// context you currently have to any method. The primary two sources of
-/// contexts are:
-///
-/// * `Store<T>`
-/// * `Caller<'_, T>`
-///
-/// corresponding to what you create and what you have access to in a host
-/// function. You can also explicitly acquire a [`StoreContext`] or
-/// [`StoreContextMut`] and pass that around as well.
-///
-/// Note that all methods on [`Store`] are mirrored onto [`StoreContext`],
-/// [`StoreContextMut`], and [`Caller`](crate::Caller). This way no matter what
-/// form of context you have you can call various methods, create objects, etc.
-///
-/// ## Stores and `Default`
-///
-/// You can create a store with default configuration settings using
-/// `Store::default()`. This will create a brand new [`Engine`] with default
-/// configuration (see [`Config`](crate::Config) for more information).
-pub struct Store<T> {
-    // for comments about `ManuallyDrop`, see `Store::into_data`
-    inner: ManuallyDrop<Box<StoreInner<T>>>,
-}
-
-#[derive(Copy, Clone, Debug)]
-/// Passed to the argument of [`Store::call_hook`] to indicate a state transition in
-/// the WebAssembly VM.
-pub enum CallHook {
-    /// Indicates the VM is calling a WebAssembly function, from the host.
-    CallingWasm,
-    /// Indicates the VM is returning from a WebAssembly function, to the host.
-    ReturningFromWasm,
-    /// Indicates the VM is calling a host function, from WebAssembly.
-    CallingHost,
-    /// Indicates the VM is returning from a host function, to WebAssembly.
-    ReturningFromHost,
-}
-
-impl CallHook {
-    /// Indicates the VM is entering host code (exiting WebAssembly code)
-    pub fn entering_host(&self) -> bool {
-        match self {
-            CallHook::ReturningFromWasm | CallHook::CallingHost => true,
-            _ => false,
-        }
-    }
-    /// Indicates the VM is exiting host code (entering WebAssembly code)
-    pub fn exiting_host(&self) -> bool {
-        match self {
-            CallHook::ReturningFromHost | CallHook::CallingWasm => true,
-            _ => false,
-        }
-    }
-}
-
-/// Internal contents of a `Store<T>` that live on the heap.
-///
-/// The members of this struct are those that need to be generic over `T`, the
-/// store's internal type storage. Otherwise all things that don't rely on `T`
-/// should go into `StoreOpaque`.
-pub struct StoreInner<T> {
-    /// Generic metadata about the store that doesn't need access to `T`.
-    inner: StoreOpaque,
-
-    limiter: Option<ResourceLimiterInner<T>>,
-    call_hook: Option<CallHookInner<T>>,
-    epoch_deadline_behavior:
-        Option<Box<dyn FnMut(StoreContextMut<T>) -> Result<UpdateDeadline> + Send + Sync>>,
-    // for comments about `ManuallyDrop`, see `Store::into_data`
-    data: ManuallyDrop<T>,
-}
-
-enum ResourceLimiterInner<T> {
-    Sync(Box<dyn FnMut(&mut T) -> &mut (dyn crate::ResourceLimiter) + Send + Sync>),
-    #[cfg(feature = "async")]
-    Async(Box<dyn FnMut(&mut T) -> &mut (dyn crate::ResourceLimiterAsync) + Send + Sync>),
-}
-
-/// An object that can take callbacks when the runtime enters or exits hostcalls.
-#[cfg(feature = "async")]
-#[async_trait::async_trait]
-pub trait CallHookHandler<T>: Send {
-    /// A callback to run when wasmtime is about to enter a host call, or when about to
-    /// exit the hostcall.
-    async fn handle_call_event(&self, t: &mut T, ch: CallHook) -> Result<()>;
-}
-
-enum CallHookInner<T> {
-    Sync(Box<dyn FnMut(&mut T, CallHook) -> Result<()> + Send + Sync>),
-    #[cfg(feature = "async")]
-    Async(Box<dyn CallHookHandler<T> + Send + Sync>),
-}
-
-/// What to do after returning from a callback when the engine epoch reaches
-/// the deadline for a Store during execution of a function using that store.
-pub enum UpdateDeadline {
-    /// Extend the deadline by the specified number of ticks.
-    Continue(u64),
-    /// Extend the deadline by the specified number of ticks after yielding to
-    /// the async executor loop. This can only be used with an async [`Store`]
-    /// configured via [`Config::async_support`](crate::Config::async_support).
-    #[cfg(feature = "async")]
-    Yield(u64),
-}
-
-// Forward methods on `StoreOpaque` to also being on `StoreInner<T>`
-impl<T> Deref for StoreInner<T> {
-    type Target = StoreOpaque;
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-
-impl<T> DerefMut for StoreInner<T> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.inner
-    }
-}
-
-/// Monomorphic storage for a `Store<T>`.
-///
-/// This structure contains the bulk of the metadata about a `Store`. This is
-/// used internally in Wasmtime when dependence on the `T` of `Store<T>` isn't
-/// necessary, allowing code to be monomorphic and compiled into the `wasmtime`
-/// crate itself.
-pub struct StoreOpaque {
-    // This `StoreOpaque` structure has references to itself. These aren't
-    // immediately evident, however, so we need to tell the compiler that it
-    // contains self-references. This notably suppresses `noalias` annotations
-    // when this shows up in compiled code because types of this structure do
-    // indeed alias itself. An example of this is `default_callee` holds a
-    // `*mut dyn Store` to the address of this `StoreOpaque` itself, indeed
-    // aliasing!
-    //
-    // It's somewhat unclear to me at this time if this is 100% sufficient to
-    // get all the right codegen in all the right places. For example does
-    // `Store` need to internally contain a `Pin<Box<StoreInner<T>>>`? Do the
-    // contexts need to contain `Pin<&mut StoreInner<T>>`? I'm not familiar
-    // enough with `Pin` to understand if it's appropriate here (we do, for
-    // example want to allow movement in and out of `data: T`, just not movement
-    // of most of the other members). It's also not clear if using `Pin` in a
-    // few places buys us much other than a bunch of `unsafe` that we already
-    // sort of hand-wave away.
-    //
-    // In any case this seems like a good mid-ground for now where we're at
-    // least telling the compiler something about all the aliasing happening
-    // within a `Store`.
-    _marker: marker::PhantomPinned,
-
-    engine: Engine,
-    runtime_limits: VMRuntimeLimits,
-    instances: Vec<StoreInstance>,
-    #[cfg(feature = "component-model")]
-    num_component_instances: usize,
-    signal_handler: Option<Box<SignalHandler<'static>>>,
-    externref_activations_table: VMExternRefActivationsTable,
-    modules: ModuleRegistry,
-    func_refs: FuncRefs,
-    host_globals: Vec<StoreBox<VMHostGlobalContext>>,
-
-    // Numbers of resources instantiated in this store, and their limits
-    instance_count: usize,
-    instance_limit: usize,
-    memory_count: usize,
-    memory_limit: usize,
-    table_count: usize,
-    table_limit: usize,
-    /// An adjustment to add to the fuel consumed value in `runtime_limits` above
-    /// to get the true amount of fuel consumed.
-    fuel_adj: i64,
-    #[cfg(feature = "async")]
-    async_state: AsyncState,
-    out_of_gas_behavior: OutOfGas,
-    /// Indexed data within this `Store`, used to store information about
-    /// globals, functions, memories, etc.
-    ///
-    /// Note that this is `ManuallyDrop` because it needs to be dropped before
-    /// `rooted_host_funcs` below. This structure contains pointers which are
-    /// otherwise kept alive by the `Arc` references in `rooted_host_funcs`.
-    store_data: ManuallyDrop<StoreData>,
-    default_caller: InstanceHandle,
-
-    /// Used to optimzed wasm->host calls when the host function is defined with
-    /// `Func::new` to avoid allocating a new vector each time a function is
-    /// called.
-    hostcall_val_storage: Vec<Val>,
-    /// Same as `hostcall_val_storage`, but for the direction of the host
-    /// calling wasm.
-    wasm_val_raw_storage: Vec<ValRaw>,
-
-    /// A list of lists of definitions which have been used to instantiate
-    /// within this `Store`.
-    ///
-    /// Note that not all instantiations end up pushing to this list. At the
-    /// time of this writing only the `InstancePre<T>` type will push to this
-    /// list. Pushes to this list are typically accompanied with
-    /// `HostFunc::to_func_store_rooted` to clone an `Arc` here once which
-    /// preserves a strong reference to the `Arc` for each `HostFunc` stored
-    /// within the list of `Definition`s.
-    ///
-    /// Note that this is `ManuallyDrop` as it must be dropped after
-    /// `store_data` above, where the function pointers are stored.
-    rooted_host_funcs: ManuallyDrop<Vec<Arc<[Definition]>>>,
-
-    /// Keep track of what protection key is being used during allocation so
-    /// that the right memory pages can be enabled when entering WebAssembly
-    /// guest code.
-    pkey: Option<ProtectionKey>,
-
-    /// Runtime state for components used in the handling of resources, borrow,
-    /// and calls. These also interact with the `ResourceAny` type and its
-    /// internal representation.
-    #[cfg(feature = "component-model")]
-    component_host_table: wasmtime_runtime::component::ResourceTable,
-    #[cfg(feature = "component-model")]
-    component_calls: wasmtime_runtime::component::CallContexts,
-}
-
-#[cfg(feature = "async")]
-struct AsyncState {
-    current_suspend: UnsafeCell<*const wasmtime_fiber::Suspend<Result<()>, (), Result<()>>>,
-    current_poll_cx: UnsafeCell<*mut Context<'static>>,
-}
-
-// Lots of pesky unsafe cells and pointers in this structure. This means we need
-// to declare explicitly that we use this in a threadsafe fashion.
-#[cfg(feature = "async")]
-unsafe impl Send for AsyncState {}
-#[cfg(feature = "async")]
-unsafe impl Sync for AsyncState {}
-
-/// An RAII type to automatically mark a region of code as unsafe for GC.
-pub(crate) struct AutoAssertNoGc<T>
-where
-    T: std::ops::DerefMut<Target = StoreOpaque>,
-{
-    #[cfg(debug_assertions)]
-    prev_okay: bool,
-    store: T,
-}
-
-impl<T> AutoAssertNoGc<T>
-where
-    T: std::ops::DerefMut<Target = StoreOpaque>,
-{
-    pub fn new(mut store: T) -> Self {
-        let _ = &mut store;
-        #[cfg(debug_assertions)]
-        {
-            let prev_okay = store.externref_activations_table.set_gc_okay(false);
-            return AutoAssertNoGc { store, prev_okay };
-        }
-        #[cfg(not(debug_assertions))]
-        {
-            return AutoAssertNoGc { store };
-        }
-    }
-}
-
-impl<T> std::ops::Deref for AutoAssertNoGc<T>
-where
-    T: std::ops::DerefMut<Target = StoreOpaque>,
-{
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        &self.store
-    }
-}
-
-impl<T> std::ops::DerefMut for AutoAssertNoGc<T>
-where
-    T: std::ops::DerefMut<Target = StoreOpaque>,
-{
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.store
-    }
-}
-
-impl<T> Drop for AutoAssertNoGc<T>
-where
-    T: std::ops::DerefMut<Target = StoreOpaque>,
-{
-    fn drop(&mut self) {
-        #[cfg(debug_assertions)]
-        {
-            self.store
-                .externref_activations_table
-                .set_gc_okay(self.prev_okay);
-        }
-    }
-}
-
-/// Used to associate instances with the store.
-///
-/// This is needed to track if the instance was allocated explicitly with the on-demand
-/// instance allocator.
-struct StoreInstance {
-    handle: InstanceHandle,
-    kind: StoreInstanceKind,
-}
-
-enum StoreInstanceKind {
-    /// An actual, non-dummy instance.
-    Real {
-        /// The id of this instance's module inside our owning store's
-        /// `ModuleRegistry`.
-        module_id: RegisteredModuleId,
-    },
-
-    /// This is a dummy instance that is just an implementation detail for
-    /// something else. For example, host-created memories internally create a
-    /// dummy instance.
-    ///
-    /// Regardless of the configured instance allocator for the engine, dummy
-    /// instances always use the on-demand allocator to deallocate the instance.
-    Dummy,
-}
-
-#[derive(Copy, Clone)]
-enum OutOfGas {
-    Trap,
-    InjectFuel {
-        injection_count: u64,
-        fuel_to_inject: u64,
-    },
-}
-
-impl<T> Store<T> {
-    /// Creates a new [`Store`] to be associated with the given [`Engine`] and
-    /// `data` provided.
-    ///
-    /// The created [`Store`] will place no additional limits on the size of
-    /// linear memories or tables at runtime. Linear memories and tables will
-    /// be allowed to grow to any upper limit specified in their definitions.
-    /// The store will limit the number of instances, linear memories, and
-    /// tables created to 10,000. This can be overridden with the
-    /// [`Store::limiter`] configuration method.
-    pub fn new(engine: &Engine, data: T) -> Self {
-        let pkey = engine.allocator().next_available_pkey();
-        let mut inner = Box::new(StoreInner {
-            inner: StoreOpaque {
-                _marker: marker::PhantomPinned,
-                engine: engine.clone(),
-                runtime_limits: Default::default(),
-                instances: Vec::new(),
-                #[cfg(feature = "component-model")]
-                num_component_instances: 0,
-                signal_handler: None,
-                externref_activations_table: VMExternRefActivationsTable::new(),
-                modules: ModuleRegistry::default(),
-                func_refs: FuncRefs::default(),
-                host_globals: Vec::new(),
-                instance_count: 0,
-                instance_limit: crate::DEFAULT_INSTANCE_LIMIT,
-                memory_count: 0,
-                memory_limit: crate::DEFAULT_MEMORY_LIMIT,
-                table_count: 0,
-                table_limit: crate::DEFAULT_TABLE_LIMIT,
-                fuel_adj: 0,
-                #[cfg(feature = "async")]
-                async_state: AsyncState {
-                    current_suspend: UnsafeCell::new(ptr::null()),
-                    current_poll_cx: UnsafeCell::new(ptr::null_mut()),
-                },
-                out_of_gas_behavior: OutOfGas::Trap,
-                store_data: ManuallyDrop::new(StoreData::new()),
-                default_caller: InstanceHandle::null(),
-                hostcall_val_storage: Vec::new(),
-                wasm_val_raw_storage: Vec::new(),
-                rooted_host_funcs: ManuallyDrop::new(Vec::new()),
-                pkey,
-                #[cfg(feature = "component-model")]
-                component_host_table: Default::default(),
-                #[cfg(feature = "component-model")]
-                component_calls: Default::default(),
-            },
-            limiter: None,
-            call_hook: None,
-            epoch_deadline_behavior: None,
-            data: ManuallyDrop::new(data),
-        });
-
-        // Wasmtime uses the callee argument to host functions to learn about
-        // the original pointer to the `Store` itself, allowing it to
-        // reconstruct a `StoreContextMut<T>`. When we initially call a `Func`,
-        // however, there's no "callee" to provide. To fix this we allocate a
-        // single "default callee" for the entire `Store`. This is then used as
-        // part of `Func::call` to guarantee that the `callee: *mut VMContext`
-        // is never null.
-        inner.default_caller = {
-            let module = Arc::new(wasmtime_environ::Module::default());
-            let shim = BareModuleInfo::empty(module).into_traitobj();
-            let allocator = OnDemandInstanceAllocator::default();
-            allocator
-                .validate_module(shim.module(), shim.offsets())
-                .unwrap();
-            let mut instance = unsafe {
-                allocator
-                    .allocate_module(InstanceAllocationRequest {
-                        host_state: Box::new(()),
-                        imports: Default::default(),
-                        store: StorePtr::empty(),
-                        runtime_info: &shim,
-                        wmemcheck: engine.config().wmemcheck,
-                        pkey: None,
-                    })
-                    .expect("failed to allocate default callee")
-            };
-
-            // Note the erasure of the lifetime here into `'static`, so in
-            // general usage of this trait object must be strictly bounded to
-            // the `Store` itself, and is a variant that we have to maintain
-            // throughout Wasmtime.
-            unsafe {
-                let traitobj = std::mem::transmute::<
-                    *mut (dyn wasmtime_runtime::Store + '_),
-                    *mut (dyn wasmtime_runtime::Store + 'static),
-                >(&mut *inner);
-                instance.set_store(traitobj);
-            }
-            instance
-        };
-
-        Self {
-            inner: ManuallyDrop::new(inner),
-        }
-    }
-
-    /// Access the underlying data owned by this `Store`.
-    #[inline]
-    pub fn data(&self) -> &T {
-        self.inner.data()
-    }
-
-    /// Access the underlying data owned by this `Store`.
-    #[inline]
-    pub fn data_mut(&mut self) -> &mut T {
-        self.inner.data_mut()
-    }
-
-    /// Consumes this [`Store`], destroying it, and returns the underlying data.
-    pub fn into_data(mut self) -> T {
-        // This is an unsafe operation because we want to avoid having a runtime
-        // check or boolean for whether the data is actually contained within a
-        // `Store`. The data itself is stored as `ManuallyDrop` since we're
-        // manually managing the memory here, and there's also a `ManuallyDrop`
-        // around the `Box<StoreInner<T>>`. The way this works though is a bit
-        // tricky, so here's how things get dropped appropriately:
-        //
-        // * When a `Store<T>` is normally dropped, the custom destructor for
-        //   `Store<T>` will drop `T`, then the `self.inner` field. The
-        //   rustc-glue destructor runs for `Box<StoreInner<T>>` which drops
-        //   `StoreInner<T>`. This cleans up all internal fields and doesn't
-        //   touch `T` because it's wrapped in `ManuallyDrop`.
-        //
-        // * When calling this method we skip the top-level destructor for
-        //   `Store<T>` with `mem::forget`. This skips both the destructor for
-        //   `T` and the destructor for `StoreInner<T>`. We do, however, run the
-        //   destructor for `Box<StoreInner<T>>` which, like above, will skip
-        //   the destructor for `T` since it's `ManuallyDrop`.
-        //
-        // In both cases all the other fields of `StoreInner<T>` should all get
-        // dropped, and the manual management of destructors is basically
-        // between this method and `Drop for Store<T>`. Note that this also
-        // means that `Drop for StoreInner<T>` cannot access `self.data`, so
-        // there is a comment indicating this as well.
-        unsafe {
-            let mut inner = ManuallyDrop::take(&mut self.inner);
-            std::mem::forget(self);
-            ManuallyDrop::take(&mut inner.data)
-        }
-    }
-
-    /// Configures the [`ResourceLimiter`] used to limit resource creation
-    /// within this [`Store`].
-    ///
-    /// Whenever resources such as linear memory, tables, or instances are
-    /// allocated the `limiter` specified here is invoked with the store's data
-    /// `T` and the returned [`ResourceLimiter`] is used to limit the operation
-    /// being allocated. The returned [`ResourceLimiter`] is intended to live
-    /// within the `T` itself, for example by storing a
-    /// [`StoreLimits`](crate::StoreLimits).
-    ///
-    /// Note that this limiter is only used to limit the creation/growth of
-    /// resources in the future, this does not retroactively attempt to apply
-    /// limits to the [`Store`].
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use wasmtime::*;
-    ///
-    /// struct MyApplicationState {
-    ///     my_state: u32,
-    ///     limits: StoreLimits,
-    /// }
-    ///
-    /// let engine = Engine::default();
-    /// let my_state = MyApplicationState {
-    ///     my_state: 42,
-    ///     limits: StoreLimitsBuilder::new()
-    ///         .memory_size(1 << 20 /* 1 MB */)
-    ///         .instances(2)
-    ///         .build(),
-    /// };
-    /// let mut store = Store::new(&engine, my_state);
-    /// store.limiter(|state| &mut state.limits);
-    ///
-    /// // Creation of smaller memories is allowed
-    /// Memory::new(&mut store, MemoryType::new(1, None)).unwrap();
-    ///
-    /// // Creation of a larger memory, however, will exceed the 1MB limit we've
-    /// // configured
-    /// assert!(Memory::new(&mut store, MemoryType::new(1000, None)).is_err());
-    ///
-    /// // The number of instances in this store is limited to 2, so the third
-    /// // instance here should fail.
-    /// let module = Module::new(&engine, "(module)").unwrap();
-    /// assert!(Instance::new(&mut store, &module, &[]).is_ok());
-    /// assert!(Instance::new(&mut store, &module, &[]).is_ok());
-    /// assert!(Instance::new(&mut store, &module, &[]).is_err());
-    /// ```
-    ///
-    /// [`ResourceLimiter`]: crate::ResourceLimiter
-    pub fn limiter(
-        &mut self,
-        mut limiter: impl FnMut(&mut T) -> &mut (dyn crate::ResourceLimiter) + Send + Sync + 'static,
-    ) {
-        // Apply the limits on instances, tables, and memory given by the limiter:
-        let inner = &mut self.inner;
-        let (instance_limit, table_limit, memory_limit) = {
-            let l = limiter(&mut inner.data);
-            (l.instances(), l.tables(), l.memories())
-        };
-        let innermost = &mut inner.inner;
-        innermost.instance_limit = instance_limit;
-        innermost.table_limit = table_limit;
-        innermost.memory_limit = memory_limit;
-
-        // Save the limiter accessor function:
-        inner.limiter = Some(ResourceLimiterInner::Sync(Box::new(limiter)));
-    }
-
-    /// Configures the [`ResourceLimiterAsync`](crate::ResourceLimiterAsync)
-    /// used to limit resource creation within this [`Store`].
-    ///
-    /// This method is an asynchronous variant of the [`Store::limiter`] method
-    /// where the embedder can block the wasm request for more resources with
-    /// host `async` execution of futures.
-    ///
-    /// By using a [`ResourceLimiterAsync`](`crate::ResourceLimiterAsync`)
-    /// with a [`Store`], you can no longer use
-    /// [`Memory::new`](`crate::Memory::new`),
-    /// [`Memory::grow`](`crate::Memory::grow`),
-    /// [`Table::new`](`crate::Table::new`), and
-    /// [`Table::grow`](`crate::Table::grow`). Instead, you must use their
-    /// `async` variants: [`Memory::new_async`](`crate::Memory::new_async`),
-    /// [`Memory::grow_async`](`crate::Memory::grow_async`),
-    /// [`Table::new_async`](`crate::Table::new_async`), and
-    /// [`Table::grow_async`](`crate::Table::grow_async`).
-    ///
-    /// Note that this limiter is only used to limit the creation/growth of
-    /// resources in the future, this does not retroactively attempt to apply
-    /// limits to the [`Store`]. Additionally this must be used with an async
-    /// [`Store`] configured via
-    /// [`Config::async_support`](crate::Config::async_support).
-    #[cfg(feature = "async")]
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "async")))]
-    pub fn limiter_async(
-        &mut self,
-        mut limiter: impl FnMut(&mut T) -> &mut (dyn crate::ResourceLimiterAsync)
-            + Send
-            + Sync
-            + 'static,
-    ) {
-        debug_assert!(self.inner.async_support());
-        // Apply the limits on instances, tables, and memory given by the limiter:
-        let inner = &mut self.inner;
-        let (instance_limit, table_limit, memory_limit) = {
-            let l = limiter(&mut inner.data);
-            (l.instances(), l.tables(), l.memories())
-        };
-        let innermost = &mut inner.inner;
-        innermost.instance_limit = instance_limit;
-        innermost.table_limit = table_limit;
-        innermost.memory_limit = memory_limit;
-
-        // Save the limiter accessor function:
-        inner.limiter = Some(ResourceLimiterInner::Async(Box::new(limiter)));
-    }
-
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "async")))]
-    /// Configures an async function that runs on calls and returns between
-    /// WebAssembly and host code. For the non-async equivalent of this method,
-    /// see [`Store::call_hook`].
-    ///
-    /// The function is passed a [`CallHook`] argument, which indicates which
-    /// state transition the VM is making.
-    ///
-    /// This function's future may return a [`Trap`]. If a trap is returned
-    /// when an import was called, it is immediately raised as-if the host
-    /// import had returned the trap. If a trap is returned after wasm returns
-    /// to the host then the wasm function's result is ignored and this trap is
-    /// returned instead.
-    ///
-    /// After this function returns a trap, it may be called for subsequent
-    /// returns to host or wasm code as the trap propagates to the root call.
-    #[cfg(feature = "async")]
-    pub fn call_hook_async(&mut self, hook: impl CallHookHandler<T> + Send + Sync + 'static) {
-        self.inner.call_hook = Some(CallHookInner::Async(Box::new(hook)));
-    }
-
-    /// Configure a function that runs on calls and returns between WebAssembly
-    /// and host code.
-    ///
-    /// The function is passed a [`CallHook`] argument, which indicates which
-    /// state transition the VM is making.
-    ///
-    /// This function may return a [`Trap`]. If a trap is returned when an
-    /// import was called, it is immediately raised as-if the host import had
-    /// returned the trap. If a trap is returned after wasm returns to the host
-    /// then the wasm function's result is ignored and this trap is returned
-    /// instead.
-    ///
-    /// After this function returns a trap, it may be called for subsequent returns
-    /// to host or wasm code as the trap propagates to the root call.
-    pub fn call_hook(
-        &mut self,
-        hook: impl FnMut(&mut T, CallHook) -> Result<()> + Send + Sync + 'static,
-    ) {
-        self.inner.call_hook = Some(CallHookInner::Sync(Box::new(hook)));
-    }
-
-    /// Returns the [`Engine`] that this store is associated with.
-    pub fn engine(&self) -> &Engine {
-        self.inner.engine()
-    }
-
-    /// Perform garbage collection of `ExternRef`s.
-    ///
-    /// Note that it is not required to actively call this function. GC will
-    /// automatically happen when internal buffers fill up. This is provided if
-    /// fine-grained control over the GC is desired.
-    pub fn gc(&mut self) {
-        self.inner.gc()
-    }
-
-    /// Returns the amount of fuel consumed by this store's execution so far.
-    ///
-    /// If fuel consumption is not enabled via
-    /// [`Config::consume_fuel`](crate::Config::consume_fuel) then this
-    /// function will return `None`. Also note that fuel, if enabled, must be
-    /// originally configured via [`Store::add_fuel`].
-    pub fn fuel_consumed(&self) -> Option<u64> {
-        self.inner.fuel_consumed()
-    }
-
-    /// Returns remaining fuel in this [`Store`].
-    ///
-    /// If fuel consumption is not enabled via
-    /// [`Config::consume_fuel`](crate::Config::consume_fuel) then this
-    /// function will return `None`. Also note that fuel, if enabled, must be
-    /// originally configured via [`Store::add_fuel`].
-    pub fn fuel_remaining(&mut self) -> Option<u64> {
-        self.inner.fuel_remaining()
-    }
-
-    /// Adds fuel to this [`Store`] for wasm to consume while executing.
-    ///
-    /// For this method to work fuel consumption must be enabled via
-    /// [`Config::consume_fuel`](crate::Config::consume_fuel). By default a
-    /// [`Store`] starts with 0 fuel for wasm to execute with (meaning it will
-    /// immediately trap). This function must be called for the store to have
-    /// some fuel to allow WebAssembly to execute.
-    ///
-    /// Most WebAssembly instructions consume 1 unit of fuel. Some
-    /// instructions, such as `nop`, `drop`, `block`, and `loop`, consume 0
-    /// units, as any execution cost associated with them involves other
-    /// instructions which do consume fuel.
-    ///
-    /// Note that at this time when fuel is entirely consumed it will cause
-    /// wasm to trap. More usages of fuel are planned for the future.
-    ///
-    /// # Errors
-    ///
-    /// This function will return an error if fuel consumption is not enabled via
-    /// [`Config::consume_fuel`](crate::Config::consume_fuel).
-    pub fn add_fuel(&mut self, fuel: u64) -> Result<()> {
-        self.inner.add_fuel(fuel)
-    }
-
-    /// Synthetically consumes fuel from this [`Store`].
-    ///
-    /// For this method to work fuel consumption must be enabled via
-    /// [`Config::consume_fuel`](crate::Config::consume_fuel).
-    ///
-    /// WebAssembly execution will automatically consume fuel but if so desired
-    /// the embedder can also consume fuel manually to account for relative
-    /// costs of host functions, for example.
-    ///
-    /// This function will attempt to consume `fuel` units of fuel from within
-    /// this store. If the remaining amount of fuel allows this then `Ok(N)` is
-    /// returned where `N` is the amount of remaining fuel. Otherwise an error
-    /// is returned and no fuel is consumed.
-    ///
-    /// # Errors
-    ///
-    /// This function will return an error either if fuel consumption is not
-    /// enabled via [`Config::consume_fuel`](crate::Config::consume_fuel) or if
-    /// `fuel` exceeds the amount of remaining fuel within this store.
-    pub fn consume_fuel(&mut self, fuel: u64) -> Result<u64> {
-        self.inner.consume_fuel(fuel)
-    }
-
-    /// Configures a [`Store`] to generate a [`Trap`] whenever it runs out of
-    /// fuel.
-    ///
-    /// When a [`Store`] is configured to consume fuel with
-    /// [`Config::consume_fuel`](crate::Config::consume_fuel) this method will
-    /// configure what happens when fuel runs out. Specifically a WebAssembly
-    /// trap will be raised and the current execution of WebAssembly will be
-    /// aborted.
-    ///
-    /// This is the default behavior for running out of fuel.
-    pub fn out_of_fuel_trap(&mut self) {
-        self.inner.out_of_fuel_trap()
-    }
-
-    /// Configures a [`Store`] to yield execution of async WebAssembly code
-    /// periodically.
-    ///
-    /// When a [`Store`] is configured to consume fuel with
-    /// [`Config::consume_fuel`](crate::Config::consume_fuel) this method will
-    /// configure what happens when fuel runs out. Specifically executing
-    /// WebAssembly will be suspended and control will be yielded back to the
-    /// caller. This is only suitable with use of a store associated with an [async
-    /// config](crate::Config::async_support) because only then are futures used and yields
-    /// are possible.
-    ///
-    /// The purpose of this behavior is to ensure that futures which represent
-    /// execution of WebAssembly do not execute too long inside their
-    /// `Future::poll` method. This allows for some form of cooperative
-    /// multitasking where WebAssembly will voluntarily yield control
-    /// periodically (based on fuel consumption) back to the running thread.
-    ///
-    /// Note that futures returned by this crate will automatically flag
-    /// themselves to get re-polled if a yield happens. This means that
-    /// WebAssembly will continue to execute, just after giving the host an
-    /// opportunity to do something else.
-    ///
-    /// The `fuel_to_inject` parameter indicates how much fuel should be
-    /// automatically re-injected after fuel runs out. This is how much fuel
-    /// will be consumed between yields of an async future.
-    ///
-    /// The `injection_count` parameter indicates how many times this fuel will
-    /// be injected. Multiplying the two parameters is the total amount of fuel
-    /// this store is allowed before wasm traps.
-    ///
-    /// # Panics
-    ///
-    /// This method will panic if it is not called on a store associated with an [async
-    /// config](crate::Config::async_support).
-    pub fn out_of_fuel_async_yield(&mut self, injection_count: u64, fuel_to_inject: u64) {
-        self.inner
-            .out_of_fuel_async_yield(injection_count, fuel_to_inject)
-    }
-
-    /// Sets the epoch deadline to a certain number of ticks in the future.
-    ///
-    /// When the Wasm guest code is compiled with epoch-interruption
-    /// instrumentation
-    /// ([`Config::epoch_interruption()`](crate::Config::epoch_interruption)),
-    /// and when the `Engine`'s epoch is incremented
-    /// ([`Engine::increment_epoch()`](crate::Engine::increment_epoch))
-    /// past a deadline, execution can be configured to either trap or
-    /// yield and then continue.
-    ///
-    /// This deadline is always set relative to the current epoch:
-    /// `delta_beyond_current` ticks in the future. The deadline can
-    /// be set explicitly via this method, or refilled automatically
-    /// on a yield if configured via
-    /// [`epoch_deadline_async_yield_and_update()`](Store::epoch_deadline_async_yield_and_update). After
-    /// this method is invoked, the deadline is reached when
-    /// [`Engine::increment_epoch()`] has been invoked at least
-    /// `ticks_beyond_current` times.
-    ///
-    /// By default a store will trap immediately with an epoch deadline of 0
-    /// (which has always "elapsed"). This method is required to be configured
-    /// for stores with epochs enabled to some future epoch deadline.
-    ///
-    /// See documentation on
-    /// [`Config::epoch_interruption()`](crate::Config::epoch_interruption)
-    /// for an introduction to epoch-based interruption.
-    pub fn set_epoch_deadline(&mut self, ticks_beyond_current: u64) {
-        self.inner.set_epoch_deadline(ticks_beyond_current);
-    }
-
-    /// Configures epoch-deadline expiration to trap.
-    ///
-    /// When epoch-interruption-instrumented code is executed on this
-    /// store and the epoch deadline is reached before completion,
-    /// with the store configured in this way, execution will
-    /// terminate with a trap as soon as an epoch check in the
-    /// instrumented code is reached.
-    ///
-    /// This behavior is the default if the store is not otherwise
-    /// configured via
-    /// [`epoch_deadline_trap()`](Store::epoch_deadline_trap),
-    /// [`epoch_deadline_callback()`](Store::epoch_deadline_callback) or
-    /// [`epoch_deadline_async_yield_and_update()`](Store::epoch_deadline_async_yield_and_update).
-    ///
-    /// This setting is intended to allow for coarse-grained
-    /// interruption, but not a deterministic deadline of a fixed,
-    /// finite interval. For deterministic interruption, see the
-    /// "fuel" mechanism instead.
-    ///
-    /// Note that when this is used it's required to call
-    /// [`Store::set_epoch_deadline`] or otherwise wasm will always immediately
-    /// trap.
-    ///
-    /// See documentation on
-    /// [`Config::epoch_interruption()`](crate::Config::epoch_interruption)
-    /// for an introduction to epoch-based interruption.
-    pub fn epoch_deadline_trap(&mut self) {
-        self.inner.epoch_deadline_trap();
-    }
-
-    /// Configures epoch-deadline expiration to invoke a custom callback
-    /// function.
-    ///
-    /// When epoch-interruption-instrumented code is executed on this
-    /// store and the epoch deadline is reached before completion, the
-    /// provided callback function is invoked.
-    ///
-    /// This callback should either return an [`UpdateDeadline`], or
-    /// return an error, which will terminate execution with a trap.
-    ///
-    /// The [`UpdateDeadline`] is a positive number of ticks to
-    /// add to the epoch deadline, as well as indicating what
-    /// to do after the callback returns. If the [`Store`] is
-    /// configured with async support, then the callback may return
-    /// [`UpdateDeadline::Yield`] to yield to the async executor before
-    /// updating the epoch deadline. Alternatively, the callback may
-    /// return [`UpdateDeadline::Continue`] to update the epoch deadline
-    /// immediately.
-    ///
-    /// This setting is intended to allow for coarse-grained
-    /// interruption, but not a deterministic deadline of a fixed,
-    /// finite interval. For deterministic interruption, see the
-    /// "fuel" mechanism instead.
-    ///
-    /// See documentation on
-    /// [`Config::epoch_interruption()`](crate::Config::epoch_interruption)
-    /// for an introduction to epoch-based interruption.
-    pub fn epoch_deadline_callback(
-        &mut self,
-        callback: impl FnMut(StoreContextMut<T>) -> Result<UpdateDeadline> + Send + Sync + 'static,
-    ) {
-        self.inner.epoch_deadline_callback(Box::new(callback));
-    }
-
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "async")))]
-    /// Configures epoch-deadline expiration to yield to the async
-    /// caller and the update the deadline.
-    ///
-    /// When epoch-interruption-instrumented code is executed on this
-    /// store and the epoch deadline is reached before completion,
-    /// with the store configured in this way, execution will yield
-    /// (the future will return `Pending` but re-awake itself for
-    /// later execution) and, upon resuming, the store will be
-    /// configured with an epoch deadline equal to the current epoch
-    /// plus `delta` ticks.
-    ///
-    /// This setting is intended to allow for cooperative timeslicing
-    /// of multiple CPU-bound Wasm guests in different stores, all
-    /// executing under the control of an async executor. To drive
-    /// this, stores should be configured to "yield and update"
-    /// automatically with this function, and some external driver (a
-    /// thread that wakes up periodically, or a timer
-    /// signal/interrupt) should call
-    /// [`Engine::increment_epoch()`](crate::Engine::increment_epoch).
-    ///
-    /// See documentation on
-    /// [`Config::epoch_interruption()`](crate::Config::epoch_interruption)
-    /// for an introduction to epoch-based interruption.
-    #[cfg(feature = "async")]
-    pub fn epoch_deadline_async_yield_and_update(&mut self, delta: u64) {
-        self.inner.epoch_deadline_async_yield_and_update(delta);
-    }
-}
-
-impl<'a, T> StoreContext<'a, T> {
-    pub(crate) fn async_support(&self) -> bool {
-        self.0.async_support()
-    }
-
-    /// Returns the underlying [`Engine`] this store is connected to.
-    pub fn engine(&self) -> &Engine {
-        self.0.engine()
-    }
-
-    /// Access the underlying data owned by this `Store`.
-    ///
-    /// Same as [`Store::data`].
-    pub fn data(&self) -> &'a T {
-        self.0.data()
-    }
-
-    /// Returns the fuel consumed by this store.
-    ///
-    /// For more information see [`Store::fuel_consumed`].
-    pub fn fuel_consumed(&self) -> Option<u64> {
-        self.0.fuel_consumed()
-    }
-
-    /// Returns remaining fuel in this store.
-    ///
-    /// For more information see [`Store::fuel_remaining`]
-    pub fn fuel_remaining(&mut self) -> Option<u64> {
-        self.0.fuel_remaining()
-    }
-}
-
-impl<'a, T> StoreContextMut<'a, T> {
-    /// Access the underlying data owned by this `Store`.
-    ///
-    /// Same as [`Store::data`].
-    pub fn data(&self) -> &T {
-        self.0.data()
-    }
-
-    /// Access the underlying data owned by this `Store`.
-    ///
-    /// Same as [`Store::data_mut`].
-    pub fn data_mut(&mut self) -> &mut T {
-        self.0.data_mut()
-    }
-
-    /// Returns the underlying [`Engine`] this store is connected to.
-    pub fn engine(&self) -> &Engine {
-        self.0.engine()
-    }
-
-    /// Perform garbage collection of `ExternRef`s.
-    ///
-    /// Same as [`Store::gc`].
-    pub fn gc(&mut self) {
-        self.0.gc()
-    }
-
-    /// Returns the fuel consumed by this store.
-    ///
-    /// For more information see [`Store::fuel_consumed`].
-    pub fn fuel_consumed(&self) -> Option<u64> {
-        self.0.fuel_consumed()
-    }
-
-    /// Returns remaining fuel in this store.
-    ///
-    /// For more information see [`Store::fuel_remaining`]
-    pub fn fuel_remaining(&self) -> Option<u64> {
-        self.0.fuel_remaining()
-    }
-
-    /// Inject more fuel into this store to be consumed when executing wasm code.
-    ///
-    /// For more information see [`Store::add_fuel`]
-    pub fn add_fuel(&mut self, fuel: u64) -> Result<()> {
-        self.0.add_fuel(fuel)
-    }
-
-    /// Synthetically consume fuel from this store.
-    ///
-    /// For more information see [`Store::consume_fuel`]
-    pub fn consume_fuel(&mut self, fuel: u64) -> Result<u64> {
-        self.0.consume_fuel(fuel)
-    }
-
-    /// Configures this `Store` to trap whenever fuel runs out.
-    ///
-    /// For more information see [`Store::out_of_fuel_trap`]
-    pub fn out_of_fuel_trap(&mut self) {
-        self.0.out_of_fuel_trap()
-    }
-
-    /// Configures this `Store` to yield while executing futures whenever fuel
-    /// runs out.
-    ///
-    /// For more information see [`Store::out_of_fuel_async_yield`]
-    pub fn out_of_fuel_async_yield(&mut self, injection_count: u64, fuel_to_inject: u64) {
-        self.0
-            .out_of_fuel_async_yield(injection_count, fuel_to_inject)
-    }
-
-    /// Sets the epoch deadline to a certain number of ticks in the future.
-    ///
-    /// For more information see [`Store::set_epoch_deadline`].
-    pub fn set_epoch_deadline(&mut self, ticks_beyond_current: u64) {
-        self.0.set_epoch_deadline(ticks_beyond_current);
-    }
-
-    /// Configures epoch-deadline expiration to trap.
-    ///
-    /// For more information see [`Store::epoch_deadline_trap`].
-    pub fn epoch_deadline_trap(&mut self) {
-        self.0.epoch_deadline_trap();
-    }
-
-    #[cfg_attr(nightlydoc, doc(cfg(feature = "async")))]
-    /// Configures epoch-deadline expiration to yield to the async
-    /// caller and the update the deadline.
-    ///
-    /// For more information see
-    /// [`Store::epoch_deadline_async_yield_and_update`].
-    #[cfg(feature = "async")]
-    pub fn epoch_deadline_async_yield_and_update(&mut self, delta: u64) {
-        self.0.epoch_deadline_async_yield_and_update(delta);
-    }
-}
-
-impl<T> StoreInner<T> {
-    #[inline]
-    fn data(&self) -> &T {
-        &self.data
-    }
-
-    #[inline]
-    fn data_mut(&mut self) -> &mut T {
-        &mut self.data
-    }
-
-    pub fn call_hook(&mut self, s: CallHook) -> Result<()> {
-        if let Some(pkey) = &self.inner.pkey {
-            let allocator = self.engine().allocator();
-            match s {
-                CallHook::CallingWasm | CallHook::ReturningFromHost => {
-                    allocator.restrict_to_pkey(*pkey)
-                }
-                CallHook::ReturningFromWasm | CallHook::CallingHost => allocator.allow_all_pkeys(),
-            }
-        }
-
-        match &mut self.call_hook {
-            Some(CallHookInner::Sync(hook)) => hook(&mut self.data, s),
-
-            #[cfg(feature = "async")]
-            Some(CallHookInner::Async(handler)) => unsafe {
-                Ok(self
-                    .inner
-                    .async_cx()
-                    .ok_or_else(|| anyhow!("couldn't grab async_cx for call hook"))?
-                    .block_on(handler.handle_call_event(&mut self.data, s).as_mut())??)
-            },
-
-            None => Ok(()),
-        }
-    }
-}
-
-#[doc(hidden)]
-impl StoreOpaque {
-    pub fn id(&self) -> StoreId {
-        self.store_data.id()
-    }
-
-    pub fn bump_resource_counts(&mut self, module: &Module) -> Result<()> {
-        fn bump(slot: &mut usize, max: usize, amt: usize, desc: &str) -> Result<()> {
-            let new = slot.saturating_add(amt);
-            if new > max {
-                bail!(
-                    "resource limit exceeded: {} count too high at {}",
-                    desc,
-                    new
-                );
-            }
-            *slot = new;
-            Ok(())
-        }
-
-        let module = module.env_module();
-        let memories = module.memory_plans.len() - module.num_imported_memories;
-        let tables = module.table_plans.len() - module.num_imported_tables;
-
-        bump(&mut self.instance_count, self.instance_limit, 1, "instance")?;
-        bump(
-            &mut self.memory_count,
-            self.memory_limit,
-            memories,
-            "memory",
-        )?;
-        bump(&mut self.table_count, self.table_limit, tables, "table")?;
-
-        Ok(())
-    }
-
-    #[inline]
-    pub fn async_support(&self) -> bool {
-        cfg!(feature = "async") && self.engine().config().async_support
-    }
-
-    #[inline]
-    pub fn engine(&self) -> &Engine {
-        &self.engine
-    }
-
-    #[inline]
-    pub fn store_data(&self) -> &StoreData {
-        &self.store_data
-    }
-
-    #[inline]
-    pub fn store_data_mut(&mut self) -> &mut StoreData {
-        &mut self.store_data
-    }
-
-    #[inline]
-    pub(crate) fn modules(&self) -> &ModuleRegistry {
-        &self.modules
-    }
-
-    #[inline]
-    pub(crate) fn modules_mut(&mut self) -> &mut ModuleRegistry {
-        &mut self.modules
-    }
-
-    pub(crate) fn func_refs(&mut self) -> &mut FuncRefs {
-        &mut self.func_refs
-    }
-
-    pub(crate) fn fill_func_refs(&mut self) {
-        self.func_refs.fill(&mut self.modules);
-    }
-
-    pub(crate) fn push_instance_pre_func_refs(&mut self, func_refs: Arc<[VMFuncRef]>) {
-        self.func_refs.push_instance_pre_func_refs(func_refs);
-    }
-
-    pub(crate) fn host_globals(&mut self) -> &mut Vec<StoreBox<VMHostGlobalContext>> {
-        &mut self.host_globals
-    }
-
-    pub fn module_for_instance(&self, instance: InstanceId) -> Option<&'_ Module> {
-        match self.instances[instance.0].kind {
-            StoreInstanceKind::Dummy => None,
-            StoreInstanceKind::Real { module_id } => {
-                let module = self
-                    .modules()
-                    .lookup_module_by_id(module_id)
-                    .expect("should always have a registered module for real instances");
-                Some(module)
-            }
-        }
-    }
-
-    pub unsafe fn add_instance(
-        &mut self,
-        handle: InstanceHandle,
-        module_id: RegisteredModuleId,
-    ) -> InstanceId {
-        self.instances.push(StoreInstance {
-            handle: handle.clone(),
-            kind: StoreInstanceKind::Real { module_id },
-        });
-        InstanceId(self.instances.len() - 1)
-    }
-
-    /// Add a dummy instance that to the store.
-    ///
-    /// These are instances that are just implementation details of something
-    /// else (e.g. host-created memories that are not actually defined in any
-    /// Wasm module) and therefore shouldn't show up in things like core dumps.
-    pub unsafe fn add_dummy_instance(&mut self, handle: InstanceHandle) -> InstanceId {
-        self.instances.push(StoreInstance {
-            handle: handle.clone(),
-            kind: StoreInstanceKind::Dummy,
-        });
-        InstanceId(self.instances.len() - 1)
-    }
-
-    pub fn instance(&self, id: InstanceId) -> &InstanceHandle {
-        &self.instances[id.0].handle
-    }
-
-    pub fn instance_mut(&mut self, id: InstanceId) -> &mut InstanceHandle {
-        &mut self.instances[id.0].handle
-    }
-
-    /// Get all instances (ignoring dummy instances) within this store.
-    pub fn all_instances<'a>(&'a mut self) -> impl ExactSizeIterator<Item = Instance> + 'a {
-        let instances = self
-            .instances
-            .iter()
-            .enumerate()
-            .filter_map(|(idx, inst)| {
-                let id = InstanceId::from_index(idx);
-                if let StoreInstanceKind::Dummy = inst.kind {
-                    None
-                } else {
-                    Some(InstanceData::from_id(id))
-                }
-            })
-            .collect::<Vec<_>>();
-        instances
-            .into_iter()
-            .map(|i| Instance::from_wasmtime(i, self))
-    }
-
-    /// Get all memories (host- or Wasm-defined) within this store.
-    pub fn all_memories<'a>(&'a mut self) -> impl Iterator<Item = Memory> + 'a {
-        // NB: Host-created memories have dummy instances. Therefore, we can get
-        // all memories in the store by iterating over all instances (including
-        // dummy instances) and getting each of their defined memories.
-        let mems = self
-            .instances
-            .iter_mut()
-            .flat_map(|instance| instance.handle.defined_memories())
-            .collect::<Vec<_>>();
-        mems.into_iter()
-            .map(|memory| unsafe { Memory::from_wasmtime_memory(memory, self) })
-    }
-
-    /// Iterate over all globals (host- or Wasm-defined) within this store.
-    pub fn all_globals<'a>(&'a mut self) -> impl Iterator<Item = Global> + 'a {
-        unsafe {
-            // First gather all the host-created globals.
-            let mut globals = self
-                .host_globals()
-                .iter()
-                .map(|global| ExportGlobal {
-                    definition: &mut (*global.get()).global as *mut _,
-                    global: (*global.get()).ty.to_wasm_type(),
-                })
-                .collect::<Vec<_>>();
-
-            // Then iterate over all instances and yield each of their defined
-            // globals.
-            globals.extend(
-                self.instances.iter_mut().flat_map(|instance| {
-                    instance.handle.defined_globals().map(|(_i, global)| global)
-                }),
-            );
-
-            globals
-                .into_iter()
-                .map(|g| Global::from_wasmtime_global(g, self))
-        }
-    }
-
-    #[cfg_attr(not(target_os = "linux"), allow(dead_code))] // not used on all platforms
-    pub fn set_signal_handler(&mut self, handler: Option<Box<SignalHandler<'static>>>) {
-        self.signal_handler = handler;
-    }
-
-    #[inline]
-    pub fn runtime_limits(&self) -> &VMRuntimeLimits {
-        &self.runtime_limits
-    }
-
-    #[inline]
-    pub fn externref_activations_table(&mut self) -> &mut VMExternRefActivationsTable {
-        &mut self.externref_activations_table
-    }
-
-    pub fn gc(&mut self) {
-        // For this crate's API, we ensure that `set_stack_canary` invariants
-        // are upheld for all host-->Wasm calls.
-        unsafe {
-            wasmtime_runtime::gc(
-                self.runtime_limits(),
-                &self.modules,
-                &mut self.externref_activations_table,
-            )
-        }
-    }
-
-    /// Yields the async context, assuming that we are executing on a fiber and
-    /// that fiber is not in the process of dying. This function will return
-    /// None in the latter case (the fiber is dying), and panic if
-    /// `async_support()` is false.
-    #[cfg(feature = "async")]
-    #[inline]
-    pub fn async_cx(&self) -> Option<AsyncCx> {
-        debug_assert!(self.async_support());
-
-        let poll_cx_box_ptr = self.async_state.current_poll_cx.get();
-        if poll_cx_box_ptr.is_null() {
-            return None;
-        }
-
-        let poll_cx_inner_ptr = unsafe { *poll_cx_box_ptr };
-        if poll_cx_inner_ptr.is_null() {
-            return None;
-        }
-
-        Some(AsyncCx {
-            current_suspend: self.async_state.current_suspend.get(),
-            current_poll_cx: poll_cx_box_ptr,
-        })
-    }
-
-    pub fn fuel_consumed(&self) -> Option<u64> {
-        if !self.engine.config().tunables.consume_fuel {
-            return None;
-        }
-        let consumed = unsafe { *self.runtime_limits.fuel_consumed.get() };
-        Some(u64::try_from(self.fuel_adj + consumed).unwrap())
-    }
-
-    fn fuel_remaining(&self) -> Option<u64> {
-        if !self.engine.config().tunables.consume_fuel {
-            return None;
-        }
-        let consumed = unsafe { *self.runtime_limits.fuel_consumed.get() };
-        Some(u64::try_from(-consumed).unwrap())
-    }
-
-    fn out_of_fuel_trap(&mut self) {
-        self.out_of_gas_behavior = OutOfGas::Trap;
-    }
-
-    fn out_of_fuel_async_yield(&mut self, injection_count: u64, fuel_to_inject: u64) {
-        assert!(
-            self.async_support(),
-            "cannot use `out_of_fuel_async_yield` without enabling async support in the config"
-        );
-        self.out_of_gas_behavior = OutOfGas::InjectFuel {
-            injection_count,
-            fuel_to_inject,
-        };
-    }
-
-    /// Yields execution to the caller on out-of-gas or epoch interruption.
-    ///
-    /// This only works on async futures and stores, and assumes that we're
-    /// executing on a fiber. This will yield execution back to the caller once.
-    #[cfg(feature = "async")]
-    fn async_yield_impl(&mut self) -> Result<()> {
-        // Small future that yields once and then returns ()
-        #[derive(Default)]
-        struct Yield {
-            yielded: bool,
-        }
-
-        impl Future for Yield {
-            type Output = ();
-
-            fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
-                if self.yielded {
-                    Poll::Ready(())
-                } else {
-                    // Flag ourselves as yielded to return next time, and also
-                    // flag the waker that we're already ready to get
-                    // re-enqueued for another poll.
-                    self.yielded = true;
-                    cx.waker().wake_by_ref();
-                    Poll::Pending
-                }
-            }
-        }
-
-        let mut future = Yield::default();
-
-        // When control returns, we have a `Result<()>` passed
-        // in from the host fiber. If this finished successfully then
-        // we were resumed normally via a `poll`, so keep going.  If
-        // the future was dropped while we were yielded, then we need
-        // to clean up this fiber. Do so by raising a trap which will
-        // abort all wasm and get caught on the other side to clean
-        // things up.
-        unsafe {
-            self.async_cx()
-                .expect("attempted to pull async context during shutdown")
-                .block_on(Pin::new_unchecked(&mut future))
-        }
-    }
-
-    fn add_fuel(&mut self, fuel: u64) -> Result<()> {
-        anyhow::ensure!(
-            self.engine().config().tunables.consume_fuel,
-            "fuel is not configured in this store"
-        );
-
-        // Fuel is stored as an i64, so we need to cast it. If the provided fuel
-        // value overflows that just assume that i64::max will suffice. Wasm
-        // execution isn't fast enough to burn through i64::max fuel in any
-        // reasonable amount of time anyway.
-        let fuel = i64::try_from(fuel).unwrap_or(i64::max_value());
-        let adj = self.fuel_adj;
-        let consumed_ptr = unsafe { &mut *self.runtime_limits.fuel_consumed.get() };
-
-        match (consumed_ptr.checked_sub(fuel), adj.checked_add(fuel)) {
-            // If we succesfully did arithmetic without overflowing then we can
-            // just update our fields.
-            (Some(consumed), Some(adj)) => {
-                self.fuel_adj = adj;
-                *consumed_ptr = consumed;
-            }
-
-            // Otherwise something overflowed. Make sure that we preserve the
-            // amount of fuel that's already consumed, but otherwise assume that
-            // we were given infinite fuel.
-            _ => {
-                self.fuel_adj = i64::max_value();
-                *consumed_ptr = (*consumed_ptr + adj) - i64::max_value();
-            }
-        }
-
-        Ok(())
-    }
-
-    fn consume_fuel(&mut self, fuel: u64) -> Result<u64> {
-        let consumed_ptr = unsafe { &mut *self.runtime_limits.fuel_consumed.get() };
-        match i64::try_from(fuel)
-            .ok()
-            .and_then(|fuel| consumed_ptr.checked_add(fuel))
-        {
-            Some(consumed) if consumed <= 0 => {
-                *consumed_ptr = consumed;
-                Ok(u64::try_from(-consumed).unwrap())
-            }
-            _ => bail!("not enough fuel remaining in store"),
-        }
-    }
-
-    #[inline]
-    pub fn signal_handler(&self) -> Option<*const SignalHandler<'static>> {
-        let handler = self.signal_handler.as_ref()?;
-        Some(&**handler as *const _)
-    }
-
-    #[inline]
-    pub fn vmruntime_limits(&self) -> *mut VMRuntimeLimits {
-        &self.runtime_limits as *const VMRuntimeLimits as *mut VMRuntimeLimits
-    }
-
-    pub unsafe fn insert_vmexternref_without_gc(&mut self, r: VMExternRef) {
-        self.externref_activations_table.insert_without_gc(r);
-    }
-
-    #[inline]
-    pub fn default_caller(&self) -> *mut VMContext {
-        self.default_caller.vmctx()
-    }
-
-    pub fn traitobj(&self) -> *mut dyn wasmtime_runtime::Store {
-        self.default_caller.store()
-    }
-
-    /// Takes the cached `Vec<Val>` stored internally across hostcalls to get
-    /// used as part of calling the host in a `Func::new` method invocation.
-    #[inline]
-    pub fn take_hostcall_val_storage(&mut self) -> Vec<Val> {
-        mem::take(&mut self.hostcall_val_storage)
-    }
-
-    /// Restores the vector previously taken by `take_hostcall_val_storage`
-    /// above back into the store, allowing it to be used in the future for the
-    /// next wasm->host call.
-    #[inline]
-    pub fn save_hostcall_val_storage(&mut self, storage: Vec<Val>) {
-        if storage.capacity() > self.hostcall_val_storage.capacity() {
-            self.hostcall_val_storage = storage;
-        }
-    }
-
-    /// Same as `take_hostcall_val_storage`, but for the direction of the host
-    /// calling wasm.
-    #[inline]
-    pub fn take_wasm_val_raw_storage(&mut self) -> Vec<ValRaw> {
-        mem::take(&mut self.wasm_val_raw_storage)
-    }
-
-    /// Same as `save_hostcall_val_storage`, but for the direction of the host
-    /// calling wasm.
-    #[inline]
-    pub fn save_wasm_val_raw_storage(&mut self, storage: Vec<ValRaw>) {
-        if storage.capacity() > self.wasm_val_raw_storage.capacity() {
-            self.wasm_val_raw_storage = storage;
-        }
-    }
-
-    pub(crate) fn push_rooted_funcs(&mut self, funcs: Arc<[Definition]>) {
-        self.rooted_host_funcs.push(funcs);
-    }
-
-    /// Translates a WebAssembly fault at the native `pc` and native `addr` to a
-    /// WebAssembly-relative fault.
-    ///
-    /// This function may abort the process if `addr` is not found to actually
-    /// reside in any linear memory. In such a situation it means that the
-    /// segfault was erroneously caught by Wasmtime and is possibly indicative
-    /// of a code generator bug.
-    ///
-    /// This function returns `None` for dynamically-bounds-checked-memories
-    /// with spectre mitigations enabled since the hardware fault address is
-    /// always zero in these situations which means that the trapping context
-    /// doesn't have enough information to report the fault address.
-    pub(crate) fn wasm_fault(&self, pc: usize, addr: usize) -> Option<WasmFault> {
-        // Explicitly bounds-checked memories with spectre-guards enabled will
-        // cause out-of-bounds accesses to get routed to address 0, so allow
-        // wasm instructions to fault on the null address.
-        if addr == 0 {
-            return None;
-        }
-
-        // Search all known instances in this store for this address. Note that
-        // this is probably not the speediest way to do this. Traps, however,
-        // are generally not expected to be super fast and additionally stores
-        // probably don't have all that many instances or memories.
-        //
-        // If this loop becomes hot in the future, however, it should be
-        // possible to precompute maps about linear memories in a store and have
-        // a quicker lookup.
-        let mut fault = None;
-        for instance in self.instances.iter() {
-            if let Some(f) = instance.handle.wasm_fault(addr) {
-                assert!(fault.is_none());
-                fault = Some(f);
-            }
-        }
-        if fault.is_some() {
-            return fault;
-        }
-
-        eprintln!(
-            "\
-Wasmtime caught a segfault for a wasm program because the faulting instruction
-is allowed to segfault due to how linear memories are implemented. The address
-that was accessed, however, is not known to any linear memory in use within this
-Store. This may be indicative of a critical bug in Wasmtime's code generation
-because all addresses which are known to be reachable from wasm won't reach this
-message.
-
-    pc:      0x{pc:x}
-    address: 0x{addr:x}
-
-This is a possible security issue because WebAssembly has accessed something it
-shouldn't have been able to. Other accesses may have succeeded and this one just
-happened to be caught. The process will now be aborted to prevent this damage
-from going any further and to alert what's going on. If this is a security
-issue please reach out to the Wasmtime team via its security policy
-at https://bytecodealliance.org/security.
-"
-        );
-        std::process::abort();
-    }
-
-    /// Retrieve the store's protection key.
-    #[inline]
-    pub(crate) fn get_pkey(&self) -> Option<ProtectionKey> {
-        self.pkey.clone()
-    }
-
-    #[inline]
-    #[cfg(feature = "component-model")]
-    pub(crate) fn component_calls_and_host_table(
-        &mut self,
-    ) -> (
-        &mut wasmtime_runtime::component::CallContexts,
-        &mut wasmtime_runtime::component::ResourceTable,
-    ) {
-        (&mut self.component_calls, &mut self.component_host_table)
-    }
-
-    #[cfg(feature = "component-model")]
-    pub(crate) fn push_component_instance(&mut self, instance: crate::component::Instance) {
-        // We don't actually need the instance itself right now, but it seems
-        // like something we will almost certainly eventually want to keep
-        // around, so force callers to provide it.
-        let _ = instance;
-
-        self.num_component_instances += 1;
-    }
-}
-
-impl<T> StoreContextMut<'_, T> {
-    /// Executes a synchronous computation `func` asynchronously on a new fiber.
-    ///
-    /// This function will convert the synchronous `func` into an asynchronous
-    /// future. This is done by running `func` in a fiber on a separate native
-    /// stack which can be suspended and resumed from.
-    ///
-    /// Most of the nitty-gritty here is how we juggle the various contexts
-    /// necessary to suspend the fiber later on and poll sub-futures. It's hoped
-    /// that the various comments are illuminating as to what's going on here.
-    #[cfg(feature = "async")]
-    pub(crate) async fn on_fiber<R>(
-        &mut self,
-        func: impl FnOnce(&mut StoreContextMut<'_, T>) -> R + Send,
-    ) -> Result<R>
-    where
-        T: Send,
-    {
-        let config = self.engine().config();
-        debug_assert!(self.0.async_support());
-        debug_assert!(config.async_stack_size > 0);
-
-        let mut slot = None;
-        let future = {
-            let current_poll_cx = self.0.async_state.current_poll_cx.get();
-            let current_suspend = self.0.async_state.current_suspend.get();
-            let stack = self.engine().allocator().allocate_fiber_stack()?;
-
-            let engine = self.engine().clone();
-            let slot = &mut slot;
-            let fiber = wasmtime_fiber::Fiber::new(stack, move |keep_going, suspend| {
-                // First check and see if we were interrupted/dropped, and only
-                // continue if we haven't been.
-                keep_going?;
-
-                // Configure our store's suspension context for the rest of the
-                // execution of this fiber. Note that a raw pointer is stored here
-                // which is only valid for the duration of this closure.
-                // Consequently we at least replace it with the previous value when
-                // we're done. This reset is also required for correctness because
-                // otherwise our value will overwrite another active fiber's value.
-                // There should be a test that segfaults in `async_functions.rs` if
-                // this `Replace` is removed.
-                unsafe {
-                    let _reset = Reset(current_suspend, *current_suspend);
-                    *current_suspend = suspend;
-
-                    *slot = Some(func(self));
-                    Ok(())
-                }
-            })?;
-
-            // Once we have the fiber representing our synchronous computation, we
-            // wrap that in a custom future implementation which does the
-            // translation from the future protocol to our fiber API.
-            FiberFuture {
-                fiber,
-                current_poll_cx,
-                engine,
-                state: Some(wasmtime_runtime::AsyncWasmCallState::new()),
-            }
-        };
-        future.await?;
-
-        return Ok(slot.unwrap());
-
-        struct FiberFuture<'a> {
-            fiber: wasmtime_fiber::Fiber<'a, Result<()>, (), Result<()>>,
-            current_poll_cx: *mut *mut Context<'static>,
-            engine: Engine,
-            // See comments in `FiberFuture::resume` for this
-            state: Option<wasmtime_runtime::AsyncWasmCallState>,
-        }
-
-        // This is surely the most dangerous `unsafe impl Send` in the entire
-        // crate. There are two members in `FiberFuture` which cause it to not
-        // be `Send`. One is `current_poll_cx` and is entirely uninteresting.
-        // This is just used to manage `Context` pointers across `await` points
-        // in the future, and requires raw pointers to get it to happen easily.
-        // Nothing too weird about the `Send`-ness, values aren't actually
-        // crossing threads.
-        //
-        // The really interesting piece is `fiber`. Now the "fiber" here is
-        // actual honest-to-god Rust code which we're moving around. What we're
-        // doing is the equivalent of moving our thread's stack to another OS
-        // thread. Turns out we, in general, have no idea what's on the stack
-        // and would generally have no way to verify that this is actually safe
-        // to do!
-        //
-        // Thankfully, though, Wasmtime has the power. Without being glib it's
-        // actually worth examining what's on the stack. It's unfortunately not
-        // super-local to this function itself. Our closure to `Fiber::new` runs
-        // `func`, which is given to us from the outside. Thankfully, though, we
-        // have tight control over this. Usage of `on_fiber` is typically done
-        // *just* before entering WebAssembly itself, so we'll have a few stack
-        // frames of Rust code (all in Wasmtime itself) before we enter wasm.
-        //
-        // Once we've entered wasm, well then we have a whole bunch of wasm
-        // frames on the stack. We've got this nifty thing called Cranelift,
-        // though, which allows us to also have complete control over everything
-        // on the stack!
-        //
-        // Finally, when wasm switches back to the fiber's starting pointer
-        // (this future we're returning) then it means wasm has reentered Rust.
-        // Suspension can only happen via the `block_on` function of an
-        // `AsyncCx`. This, conveniently, also happens entirely in Wasmtime
-        // controlled code!
-        //
-        // There's an extremely important point that should be called out here.
-        // User-provided futures **are not on the stack** during suspension
-        // points. This is extremely crucial because we in general cannot reason
-        // about Send/Sync for stack-local variables since rustc doesn't analyze
-        // them at all. With our construction, though, we are guaranteed that
-        // Wasmtime owns all stack frames between the stack of a fiber and when
-        // the fiber suspends (and it could move across threads). At this time
-        // the only user-provided piece of data on the stack is the future
-        // itself given to us. Lo-and-behold as you might notice the future is
-        // required to be `Send`!
-        //
-        // What this all boils down to is that we, as the authors of Wasmtime,
-        // need to be extremely careful that on the async fiber stack we only
-        // store Send things. For example we can't start using `Rc` willy nilly
-        // by accident and leave a copy in TLS somewhere. (similarly we have to
-        // be ready for TLS to change while we're executing wasm code between
-        // suspension points).
-        //
-        // While somewhat onerous it shouldn't be too too hard (the TLS bit is
-        // the hardest bit so far). This does mean, though, that no user should
-        // ever have to worry about the `Send`-ness of Wasmtime. If rustc says
-        // it's ok, then it's ok.
-        //
-        // With all that in mind we unsafely assert here that wasmtime is
-        // correct. We declare the fiber as only containing Send data on its
-        // stack, despite not knowing for sure at compile time that this is
-        // correct. That's what `unsafe` in Rust is all about, though, right?
-        unsafe impl Send for FiberFuture<'_> {}
-
-        impl FiberFuture<'_> {
-            /// This is a helper function to call `resume` on the underlying
-            /// fiber while correctly managing Wasmtime's thread-local data.
-            ///
-            /// Wasmtime's implementation of traps leverages thread-local data
-            /// to get access to metadata during a signal. This thread-local
-            /// data is a linked list of "activations" where the nodes of the
-            /// linked list are stored on the stack. It would be invalid as a
-            /// result to suspend a computation with the head of the linked list
-            /// on this stack then move the stack to another thread and resume
-            /// it. That means that a different thread would point to our stack
-            /// and our thread doesn't point to our stack at all!
-            ///
-            /// Basically management of TLS is required here one way or another.
-            /// The strategy currently settled on is to manage the list of
-            /// activations created by this fiber as a unit. When a fiber
-            /// resumes the linked list is prepended to the current thread's
-            /// list. When the fiber is suspended then the fiber's list of
-            /// activations are all removed en-masse and saved within the fiber.
-            fn resume(&mut self, val: Result<()>) -> Result<Result<()>, ()> {
-                unsafe {
-                    let prev = self.state.take().unwrap().push();
-                    let restore = Restore {
-                        fiber: self,
-                        state: Some(prev),
-                    };
-                    return restore.fiber.fiber.resume(val);
-                }
-
-                struct Restore<'a, 'b> {
-                    fiber: &'a mut FiberFuture<'b>,
-                    state: Option<wasmtime_runtime::PreviousAsyncWasmCallState>,
-                }
-
-                impl Drop for Restore<'_, '_> {
-                    fn drop(&mut self) {
-                        unsafe {
-                            self.fiber.state = Some(self.state.take().unwrap().restore());
-                        }
-                    }
-                }
-            }
-        }
-
-        impl Future for FiberFuture<'_> {
-            type Output = Result<()>;
-
-            fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
-                // We need to carry over this `cx` into our fiber's runtime
-                // for when it tries to poll sub-futures that are created. Doing
-                // this must be done unsafely, however, since `cx` is only alive
-                // for this one singular function call. Here we do a `transmute`
-                // to extend the lifetime of `Context` so it can be stored in
-                // our `Store`, and then we replace the current polling context
-                // with this one.
-                //
-                // Note that the replace is done for weird situations where
-                // futures might be switching contexts and there's multiple
-                // wasmtime futures in a chain of futures.
-                //
-                // On exit from this function, though, we reset the polling
-                // context back to what it was to signify that `Store` no longer
-                // has access to this pointer.
-                unsafe {
-                    let _reset = Reset(self.current_poll_cx, *self.current_poll_cx);
-                    *self.current_poll_cx =
-                        std::mem::transmute::<&mut Context<'_>, *mut Context<'static>>(cx);
-
-                    // After that's set up we resume execution of the fiber, which
-                    // may also start the fiber for the first time. This either
-                    // returns `Ok` saying the fiber finished (yay!) or it
-                    // returns `Err` with the payload passed to `suspend`, which
-                    // in our case is `()`.
-                    match self.resume(Ok(())) {
-                        Ok(result) => Poll::Ready(result),
-
-                        // If `Err` is returned that means the fiber polled a
-                        // future but it said "Pending", so we propagate that
-                        // here.
-                        //
-                        // An additional safety check is performed when leaving
-                        // this function to help bolster the guarantees of
-                        // `unsafe impl Send` above. Notably this future may get
-                        // re-polled on a different thread. Wasmtime's
-                        // thread-local state points to the stack, however,
-                        // meaning that it would be incorrect to leave a pointer
-                        // in TLS when this function returns. This function
-                        // performs a runtime assert to verify that this is the
-                        // case, notably that the one TLS pointer Wasmtime uses
-                        // is not pointing anywhere within the stack. If it is
-                        // then that's a bug indicating that TLS management in
-                        // Wasmtime is incorrect.
-                        Err(()) => {
-                            if let Some(range) = self.fiber.stack().range() {
-                                wasmtime_runtime::AsyncWasmCallState::assert_current_state_not_in_range(range);
-                            }
-                            Poll::Pending
-                        }
-                    }
-                }
-            }
-        }
-
-        // Dropping futures is pretty special in that it means the future has
-        // been requested to be cancelled. Here we run the risk of dropping an
-        // in-progress fiber, and if we were to do nothing then the fiber would
-        // leak all its owned stack resources.
-        //
-        // To handle this we implement `Drop` here and, if the fiber isn't done,
-        // resume execution of the fiber saying "hey please stop you're
-        // interrupted". Our `Trap` created here (which has the stack trace
-        // of whomever dropped us) will then get propagated in whatever called
-        // `block_on`, and the idea is that the trap propagates all the way back
-        // up to the original fiber start, finishing execution.
-        //
-        // We don't actually care about the fiber's return value here (no one's
-        // around to look at it), we just assert the fiber finished to
-        // completion.
-        impl Drop for FiberFuture<'_> {
-            fn drop(&mut self) {
-                if !self.fiber.done() {
-                    let result = self.resume(Err(anyhow!("future dropped")));
-                    // This resumption with an error should always complete the
-                    // fiber. While it's technically possible for host code to catch
-                    // the trap and re-resume, we'd ideally like to signal that to
-                    // callers that they shouldn't be doing that.
-                    debug_assert!(result.is_ok());
-                }
-
-                self.state.take().unwrap().assert_null();
-
-                unsafe {
-                    self.engine
-                        .allocator()
-                        .deallocate_fiber_stack(self.fiber.stack());
-                }
-            }
-        }
-    }
-}
-
-#[cfg(feature = "async")]
-pub struct AsyncCx {
-    current_suspend: *mut *const wasmtime_fiber::Suspend<Result<()>, (), Result<()>>,
-    current_poll_cx: *mut *mut Context<'static>,
-}
-
-#[cfg(feature = "async")]
-impl AsyncCx {
-    /// Blocks on the asynchronous computation represented by `future` and
-    /// produces the result here, in-line.
-    ///
-    /// This function is designed to only work when it's currently executing on
-    /// a native fiber. This fiber provides the ability for us to handle the
-    /// future's `Pending` state as "jump back to whomever called the fiber in
-    /// an asynchronous fashion and propagate `Pending`". This tight coupling
-    /// with `on_fiber` below is what powers the asynchronicity of calling wasm.
-    /// Note that the asynchronous part only applies to host functions, wasm
-    /// itself never really does anything asynchronous at this time.
-    ///
-    /// This function takes a `future` and will (appear to) synchronously wait
-    /// on the result. While this function is executing it will fiber switch
-    /// to-and-from the original frame calling `on_fiber` which should be a
-    /// guarantee due to how async stores are configured.
-    ///
-    /// The return value here is either the output of the future `T`, or a trap
-    /// which represents that the asynchronous computation was cancelled. It is
-    /// not recommended to catch the trap and try to keep executing wasm, so
-    /// we've tried to liberally document this.
-    pub unsafe fn block_on<U>(
-        &self,
-        mut future: Pin<&mut (dyn Future<Output = U> + Send)>,
-    ) -> Result<U> {
-        // Take our current `Suspend` context which was configured as soon as
-        // our fiber started. Note that we must load it at the front here and
-        // save it on our stack frame. While we're polling the future other
-        // fibers may be started for recursive computations, and the current
-        // suspend context is only preserved at the edges of the fiber, not
-        // during the fiber itself.
-        //
-        // For a little bit of extra safety we also replace the current value
-        // with null to try to catch any accidental bugs on our part early.
-        // This is all pretty unsafe so we're trying to be careful...
-        //
-        // Note that there should be a segfaulting test  in `async_functions.rs`
-        // if this `Reset` is removed.
-        let suspend = *self.current_suspend;
-        let _reset = Reset(self.current_suspend, suspend);
-        *self.current_suspend = ptr::null();
-        assert!(!suspend.is_null());
-
-        loop {
-            let future_result = {
-                let poll_cx = *self.current_poll_cx;
-                let _reset = Reset(self.current_poll_cx, poll_cx);
-                *self.current_poll_cx = ptr::null_mut();
-                assert!(!poll_cx.is_null());
-                future.as_mut().poll(&mut *poll_cx)
-            };
-
-            match future_result {
-                Poll::Ready(t) => break Ok(t),
-                Poll::Pending => {}
-            }
-
-            (*suspend).suspend(())?;
-        }
-    }
-}
-
-unsafe impl<T> wasmtime_runtime::Store for StoreInner<T> {
-    fn vmruntime_limits(&self) -> *mut VMRuntimeLimits {
-        <StoreOpaque>::vmruntime_limits(self)
-    }
-
-    fn epoch_ptr(&self) -> *const AtomicU64 {
-        self.engine.epoch_counter() as *const _
-    }
-
-    fn externref_activations_table(
-        &mut self,
-    ) -> (
-        &mut VMExternRefActivationsTable,
-        &dyn wasmtime_runtime::ModuleInfoLookup,
-    ) {
-        let inner = &mut self.inner;
-        (&mut inner.externref_activations_table, &inner.modules)
-    }
-
-    fn memory_growing(
-        &mut self,
-        current: usize,
-        desired: usize,
-        maximum: Option<usize>,
-    ) -> Result<bool, anyhow::Error> {
-        match self.limiter {
-            Some(ResourceLimiterInner::Sync(ref mut limiter)) => {
-                limiter(&mut self.data).memory_growing(current, desired, maximum)
-            }
-            #[cfg(feature = "async")]
-            Some(ResourceLimiterInner::Async(ref mut limiter)) => unsafe {
-                self.inner
-                    .async_cx()
-                    .expect("ResourceLimiterAsync requires async Store")
-                    .block_on(
-                        limiter(&mut self.data)
-                            .memory_growing(current, desired, maximum)
-                            .as_mut(),
-                    )?
-            },
-            None => Ok(true),
-        }
-    }
-
-    fn memory_grow_failed(&mut self, error: anyhow::Error) -> Result<()> {
-        match self.limiter {
-            Some(ResourceLimiterInner::Sync(ref mut limiter)) => {
-                limiter(&mut self.data).memory_grow_failed(error)
-            }
-            #[cfg(feature = "async")]
-            Some(ResourceLimiterInner::Async(ref mut limiter)) => {
-                limiter(&mut self.data).memory_grow_failed(error)
-            }
-            None => {
-                log::debug!("ignoring memory growth failure error: {error:?}");
-                Ok(())
-            }
-        }
-    }
-
-    fn table_growing(
-        &mut self,
-        current: u32,
-        desired: u32,
-        maximum: Option<u32>,
-    ) -> Result<bool, anyhow::Error> {
-        // Need to borrow async_cx before the mut borrow of the limiter.
-        // self.async_cx() panicks when used with a non-async store, so
-        // wrap this in an option.
-        #[cfg(feature = "async")]
-        let async_cx = if self.async_support() {
-            Some(self.async_cx().unwrap())
-        } else {
-            None
-        };
-
-        match self.limiter {
-            Some(ResourceLimiterInner::Sync(ref mut limiter)) => {
-                limiter(&mut self.data).table_growing(current, desired, maximum)
-            }
-            #[cfg(feature = "async")]
-            Some(ResourceLimiterInner::Async(ref mut limiter)) => unsafe {
-                async_cx
-                    .expect("ResourceLimiterAsync requires async Store")
-                    .block_on(
-                        limiter(&mut self.data)
-                            .table_growing(current, desired, maximum)
-                            .as_mut(),
-                    )?
-            },
-            None => Ok(true),
-        }
-    }
-
-    fn table_grow_failed(&mut self, error: anyhow::Error) -> Result<()> {
-        match self.limiter {
-            Some(ResourceLimiterInner::Sync(ref mut limiter)) => {
-                limiter(&mut self.data).table_grow_failed(error)
-            }
-            #[cfg(feature = "async")]
-            Some(ResourceLimiterInner::Async(ref mut limiter)) => {
-                limiter(&mut self.data).table_grow_failed(error)
-            }
-            None => {
-                log::debug!("ignoring table growth failure: {error:?}");
-                Ok(())
-            }
-        }
-    }
-
-    fn out_of_gas(&mut self) -> Result<(), anyhow::Error> {
-        return match &mut self.out_of_gas_behavior {
-            OutOfGas::Trap => Err(Trap::OutOfFuel.into()),
-            #[cfg(feature = "async")]
-            OutOfGas::InjectFuel {
-                injection_count,
-                fuel_to_inject,
-            } => {
-                if *injection_count == 0 {
-                    return Err(Trap::OutOfFuel.into());
-                }
-                *injection_count -= 1;
-                let fuel = *fuel_to_inject;
-                self.async_yield_impl()?;
-                if fuel > 0 {
-                    self.add_fuel(fuel).unwrap();
-                }
-                Ok(())
-            }
-            #[cfg(not(feature = "async"))]
-            OutOfGas::InjectFuel { .. } => unreachable!(),
-        };
-    }
-
-    fn new_epoch(&mut self) -> Result<u64, anyhow::Error> {
-        // Temporarily take the configured behavior to avoid mutably borrowing
-        // multiple times.
-        let mut behavior = self.epoch_deadline_behavior.take();
-        let delta_result = match &mut behavior {
-            None => Err(Trap::Interrupt.into()),
-            Some(callback) => callback((&mut *self).as_context_mut()).and_then(|update| {
-                let delta = match update {
-                    UpdateDeadline::Continue(delta) => delta,
-
-                    #[cfg(feature = "async")]
-                    UpdateDeadline::Yield(delta) => {
-                        assert!(
-                            self.async_support(),
-                            "cannot use `UpdateDeadline::Yield` without enabling async support in the config"
-                        );
-                        // Do the async yield. May return a trap if future was
-                        // canceled while we're yielded.
-                        self.async_yield_impl()?;
-                        delta
-                    }
-                };
-
-                // Set a new deadline and return the new epoch deadline so
-                // the Wasm code doesn't have to reload it.
-                self.set_epoch_deadline(delta);
-                Ok(self.get_epoch_deadline())
-            })
-        };
-
-        // Put back the original behavior which was replaced by `take`.
-        self.epoch_deadline_behavior = behavior;
-        delta_result
-    }
-
-    #[cfg(feature = "component-model")]
-    fn component_calls(&mut self) -> &mut wasmtime_runtime::component::CallContexts {
-        &mut self.component_calls
-    }
-}
-
-impl<T> StoreInner<T> {
-    pub(crate) fn set_epoch_deadline(&mut self, delta: u64) {
-        // Set a new deadline based on the "epoch deadline delta".
-        //
-        // Safety: this is safe because the epoch deadline in the
-        // `VMRuntimeLimits` is accessed only here and by Wasm guest code
-        // running in this store, and we have a `&mut self` here.
-        //
-        // Also, note that when this update is performed while Wasm is
-        // on the stack, the Wasm will reload the new value once we
-        // return into it.
-        let epoch_deadline = unsafe { (*self.vmruntime_limits()).epoch_deadline.get_mut() };
-        *epoch_deadline = self.engine().current_epoch() + delta;
-    }
-
-    fn epoch_deadline_trap(&mut self) {
-        self.epoch_deadline_behavior = None;
-    }
-
-    fn epoch_deadline_callback(
-        &mut self,
-        callback: Box<dyn FnMut(StoreContextMut<T>) -> Result<UpdateDeadline> + Send + Sync>,
-    ) {
-        self.epoch_deadline_behavior = Some(callback);
-    }
-
-    fn epoch_deadline_async_yield_and_update(&mut self, delta: u64) {
-        assert!(
-            self.async_support(),
-            "cannot use `epoch_deadline_async_yield_and_update` without enabling async support in the config"
-        );
-        #[cfg(feature = "async")]
-        {
-            self.epoch_deadline_behavior =
-                Some(Box::new(move |_store| Ok(UpdateDeadline::Yield(delta))));
-        }
-        let _ = delta; // suppress warning in non-async build
-    }
-
-    fn get_epoch_deadline(&self) -> u64 {
-        // Safety: this is safe because, as above, it is only invoked
-        // from within `new_epoch` which is called from guest Wasm
-        // code, which will have an exclusive borrow on the Store.
-        let epoch_deadline = unsafe { (*self.vmruntime_limits()).epoch_deadline.get_mut() };
-        *epoch_deadline
-    }
-}
-
-impl<T: Default> Default for Store<T> {
-    fn default() -> Store<T> {
-        Store::new(&Engine::default(), T::default())
-    }
-}
-
-impl<T: fmt::Debug> fmt::Debug for Store<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let inner = &**self.inner as *const StoreInner<T>;
-        f.debug_struct("Store")
-            .field("inner", &inner)
-            .field("data", &self.inner.data)
-            .finish()
-    }
-}
-
-impl<T> Drop for Store<T> {
-    fn drop(&mut self) {
-        // for documentation on this `unsafe`, see `into_data`.
-        unsafe {
-            ManuallyDrop::drop(&mut self.inner.data);
-            ManuallyDrop::drop(&mut self.inner);
-        }
-    }
-}
-
-impl Drop for StoreOpaque {
-    fn drop(&mut self) {
-        // NB it's important that this destructor does not access `self.data`.
-        // That is deallocated by `Drop for Store<T>` above.
-
-        unsafe {
-            let allocator = self.engine.allocator();
-            let ondemand = OnDemandInstanceAllocator::default();
-            for instance in self.instances.iter_mut() {
-                if let StoreInstanceKind::Dummy = instance.kind {
-                    ondemand.deallocate_module(&mut instance.handle);
-                } else {
-                    allocator.deallocate_module(&mut instance.handle);
-                }
-            }
-            ondemand.deallocate_module(&mut self.default_caller);
-
-            #[cfg(feature = "component-model")]
-            {
-                for _ in 0..self.num_component_instances {
-                    allocator.decrement_component_instance_count();
-                }
-            }
-
-            // See documentation for these fields on `StoreOpaque` for why they
-            // must be dropped in this order.
-            ManuallyDrop::drop(&mut self.store_data);
-            ManuallyDrop::drop(&mut self.rooted_host_funcs);
-        }
-    }
-}
-
-impl wasmtime_runtime::ModuleInfoLookup for ModuleRegistry {
-    fn lookup(&self, pc: usize) -> Option<&dyn ModuleInfo> {
-        self.lookup_module_info(pc)
-    }
-}
-
-struct Reset<T: Copy>(*mut T, T);
-
-impl<T: Copy> Drop for Reset<T> {
-    fn drop(&mut self) {
-        unsafe {
-            *self.0 = self.1;
-        }
-    }
-}
diff --git a/crates/wasmtime/src/store/data.rs b/crates/wasmtime/src/store/data.rs
deleted file mode 100644
index 390374985f90..000000000000
--- a/crates/wasmtime/src/store/data.rs
+++ /dev/null
@@ -1,289 +0,0 @@
-use crate::store::StoreOpaque;
-use crate::{StoreContext, StoreContextMut};
-use std::fmt;
-use std::marker;
-use std::num::NonZeroU64;
-use std::ops::{Index, IndexMut};
-use std::sync::atomic::{AtomicU64, Ordering::Relaxed};
-
-// This is defined here, in a private submodule, so we can explicitly reexport
-// it only as `pub(crate)`. This avoids a ton of
-// crate-private-type-in-public-interface errors that aren't really too
-// interesting to deal with.
-#[derive(Copy, Clone)]
-pub struct InstanceId(pub(super) usize);
-
-impl InstanceId {
-    pub fn from_index(idx: usize) -> InstanceId {
-        InstanceId(idx)
-    }
-}
-
-pub struct StoreData {
-    id: StoreId,
-    funcs: Vec<crate::func::FuncData>,
-    tables: Vec<wasmtime_runtime::ExportTable>,
-    globals: Vec<wasmtime_runtime::ExportGlobal>,
-    instances: Vec<crate::instance::InstanceData>,
-    memories: Vec<wasmtime_runtime::ExportMemory>,
-    #[cfg(feature = "component-model")]
-    pub(crate) components: crate::component::ComponentStoreData,
-}
-
-pub trait StoredData: Sized {
-    fn list(data: &StoreData) -> &Vec<Self>;
-    fn list_mut(data: &mut StoreData) -> &mut Vec<Self>;
-}
-
-macro_rules! impl_store_data {
-    ($($field:ident => $t:ty,)*) => ($(
-        impl StoredData for $t {
-            #[inline]
-            fn list(data: &StoreData) -> &Vec<Self> { &data.$field }
-            #[inline]
-            fn list_mut(data: &mut StoreData) -> &mut Vec<Self> { &mut data.$field }
-        }
-    )*)
-}
-
-impl_store_data! {
-    funcs => crate::func::FuncData,
-    tables => wasmtime_runtime::ExportTable,
-    globals => wasmtime_runtime::ExportGlobal,
-    instances => crate::instance::InstanceData,
-    memories => wasmtime_runtime::ExportMemory,
-}
-
-impl StoreData {
-    pub fn new() -> StoreData {
-        StoreData {
-            id: StoreId::allocate(),
-            funcs: Vec::new(),
-            tables: Vec::new(),
-            globals: Vec::new(),
-            instances: Vec::new(),
-            memories: Vec::new(),
-            #[cfg(feature = "component-model")]
-            components: Default::default(),
-        }
-    }
-
-    pub fn id(&self) -> StoreId {
-        self.id
-    }
-
-    pub fn insert<T>(&mut self, data: T) -> Stored<T>
-    where
-        T: StoredData,
-    {
-        let list = T::list_mut(self);
-        let index = list.len();
-        list.push(data);
-        Stored::new(self.id, index)
-    }
-
-    pub fn next_id<T>(&self) -> Stored<T>
-    where
-        T: StoredData,
-    {
-        Stored::new(self.id, T::list(self).len())
-    }
-
-    pub fn contains<T>(&self, id: Stored<T>) -> bool
-    where
-        T: StoredData,
-    {
-        if id.store_id != self.id {
-            return false;
-        }
-        // This should be true as an invariant of our API, but double-check with
-        // debug assertions enabled.
-        debug_assert!(id.index() < T::list(self).len());
-        true
-    }
-
-    pub fn iter<T>(&self) -> impl ExactSizeIterator<Item = Stored<T>>
-    where
-        T: StoredData,
-    {
-        let id = self.id;
-        (0..T::list(self).len()).map(move |i| Stored::new(id, i))
-    }
-
-    pub(crate) fn reserve_funcs(&mut self, count: usize) {
-        self.funcs.reserve(count);
-    }
-}
-
-impl<T> Index<Stored<T>> for StoreData
-where
-    T: StoredData,
-{
-    type Output = T;
-
-    #[inline]
-    fn index(&self, index: Stored<T>) -> &Self::Output {
-        index.assert_belongs_to(self.id);
-        // Note that if this is ever a performance bottleneck it should be safe
-        // to use unchecked indexing here because presence of a `Stored<T>` is
-        // proof of an item having been inserted into a store and lists in
-        // stores are never shrunk. After the store check above the actual index
-        // should always be valid.
-        &T::list(self)[index.index()]
-    }
-}
-
-impl<T> IndexMut<Stored<T>> for StoreData
-where
-    T: StoredData,
-{
-    #[inline]
-    fn index_mut(&mut self, index: Stored<T>) -> &mut Self::Output {
-        index.assert_belongs_to(self.id);
-        // Note that this could be unchecked indexing, see the note in `Index`
-        // above.
-        &mut T::list_mut(self)[index.index()]
-    }
-}
-
-// forward StoreContext => StoreData
-impl<I, T> Index<I> for StoreContext<'_, T>
-where
-    StoreData: Index<I>,
-{
-    type Output = <StoreData as Index<I>>::Output;
-
-    #[inline]
-    fn index(&self, index: I) -> &Self::Output {
-        self.0.store_data.index(index)
-    }
-}
-
-// forward StoreContextMut => StoreData
-impl<I, T> Index<I> for StoreContextMut<'_, T>
-where
-    StoreData: Index<I>,
-{
-    type Output = <StoreData as Index<I>>::Output;
-
-    #[inline]
-    fn index(&self, index: I) -> &Self::Output {
-        self.0.store_data.index(index)
-    }
-}
-
-// forward StoreOpaque => StoreData
-impl<I> Index<I> for StoreOpaque
-where
-    StoreData: Index<I>,
-{
-    type Output = <StoreData as Index<I>>::Output;
-
-    #[inline]
-    fn index(&self, index: I) -> &Self::Output {
-        self.store_data().index(index)
-    }
-}
-impl<I> IndexMut<I> for StoreOpaque
-where
-    StoreData: IndexMut<I>,
-{
-    #[inline]
-    fn index_mut(&mut self, index: I) -> &mut Self::Output {
-        self.store_data_mut().index_mut(index)
-    }
-}
-
-/// A unique identifier to get attached to a store.
-///
-/// This identifier is embedded into the `Stored<T>` structure and is used to
-/// identify the original store that items come from. For example a `Memory` is
-/// owned by a `Store` and will embed a `StoreId` internally to say which store
-/// it came from. Comparisons with this value are how panics are generated for
-/// mismatching the item that a store belongs to.
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub struct StoreId(NonZeroU64);
-
-impl StoreId {
-    /// Allocates a new unique identifier for a store that has never before been
-    /// used in this process.
-    fn allocate() -> StoreId {
-        static NEXT_ID: AtomicU64 = AtomicU64::new(0);
-
-        // Only allow 2^63 stores at which point we start panicking to prevent
-        // overflow.
-        //
-        // If a store is created once per microsecond then this will last the
-        // current process for 584,540 years before overflowing.
-        //
-        // Also note the usage of `Relaxed` ordering here which should be ok
-        // since we're only looking for atomicity on this counter and this
-        // otherwise isn't used to synchronize memory stored anywhere else.
-        let id = NEXT_ID.fetch_add(1, Relaxed);
-        if id & (1 << 63) != 0 {
-            NEXT_ID.store(1 << 63, Relaxed);
-            panic!("store id allocator overflow");
-        }
-
-        StoreId(NonZeroU64::new(id + 1).unwrap())
-    }
-
-    #[inline]
-    pub fn assert_belongs_to(&self, store: StoreId) {
-        if *self == store {
-            return;
-        }
-        store_id_mismatch();
-    }
-}
-
-#[repr(C)] // used by reference in the C API
-pub struct Stored<T> {
-    store_id: StoreId,
-    index: usize,
-    _marker: marker::PhantomData<fn() -> T>,
-}
-
-impl<T> Stored<T> {
-    fn new(store_id: StoreId, index: usize) -> Stored<T> {
-        Stored {
-            store_id,
-            index,
-            _marker: marker::PhantomData,
-        }
-    }
-
-    #[inline]
-    pub fn assert_belongs_to(&self, store: StoreId) {
-        self.store_id.assert_belongs_to(store)
-    }
-
-    fn index(&self) -> usize {
-        self.index
-    }
-}
-
-#[cold]
-fn store_id_mismatch() {
-    panic!("object used with the wrong store");
-}
-
-impl<T> PartialEq for Stored<T> {
-    fn eq(&self, other: &Stored<T>) -> bool {
-        self.store_id == other.store_id && self.index == other.index
-    }
-}
-
-impl<T> Copy for Stored<T> {}
-
-impl<T> Clone for Stored<T> {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-
-impl<T> fmt::Debug for Stored<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "store={}, index={}", self.store_id.0, self.index())
-    }
-}
diff --git a/crates/wasmtime/src/sync_nostd.rs b/crates/wasmtime/src/sync_nostd.rs
new file mode 100644
index 000000000000..cfc7fe27dfb8
--- /dev/null
+++ b/crates/wasmtime/src/sync_nostd.rs
@@ -0,0 +1,255 @@
+//! Synchronization primitives for Wasmtime for `no_std`.
+//!
+//! These primitives are intended for use in `no_std` contexts are are not as
+//! full-featured as the `std` brethren. Namely these panic and/or return an
+//! error on contention. This serves to continue to be correct in the face of
+//! actual multiple threads, but if a system actually has multiple threads then
+//! something will need to change in the Wasmtime crate to enable the external
+//! system to perform necessary synchronization.
+//!
+//! In the future if these primitives are not suitable we can switch to putting
+//! relevant functions in the `capi.rs` module where we basically require
+//! embedders to implement them instead of doing it ourselves here. It's unclear
+//! if this will be necessary, so this is the chosen starting point.
+//!
+//! See a brief overview of this module in `sync_std.rs` as well.
+
+use core::cell::UnsafeCell;
+use core::mem::MaybeUninit;
+use core::ops::{Deref, DerefMut};
+use core::sync::atomic::{AtomicU32, AtomicU8, Ordering};
+
+pub struct OnceLock<T> {
+    val: UnsafeCell<MaybeUninit<T>>,
+    state: AtomicU8,
+}
+
+unsafe impl<T: Send> Send for OnceLock<T> {}
+unsafe impl<T: Sync> Sync for OnceLock<T> {}
+
+const UNINITIALIZED: u8 = 0;
+const INITIALIZING: u8 = 1;
+const INITIALIZED: u8 = 2;
+
+impl<T> OnceLock<T> {
+    pub const fn new() -> OnceLock<T> {
+        OnceLock {
+            state: AtomicU8::new(UNINITIALIZED),
+            val: UnsafeCell::new(MaybeUninit::uninit()),
+        }
+    }
+
+    pub fn get_or_init(&self, f: impl FnOnce() -> T) -> &T {
+        if let Some(ret) = self.get() {
+            return ret;
+        }
+        self.try_init::<()>(|| Ok(f())).unwrap()
+    }
+
+    pub fn get_or_try_init<E>(&self, f: impl FnOnce() -> Result<T, E>) -> Result<&T, E> {
+        if let Some(ret) = self.get() {
+            return Ok(ret);
+        }
+        self.try_init(f)
+    }
+
+    fn get(&self) -> Option<&T> {
+        if self.state.load(Ordering::Acquire) == INITIALIZED {
+            Some(unsafe { (*self.val.get()).assume_init_ref() })
+        } else {
+            None
+        }
+    }
+
+    #[cold]
+    fn try_init<E>(&self, f: impl FnOnce() -> Result<T, E>) -> Result<&T, E> {
+        match self.state.compare_exchange(
+            UNINITIALIZED,
+            INITIALIZING,
+            Ordering::Acquire,
+            Ordering::Acquire,
+        ) {
+            Ok(UNINITIALIZED) => match f() {
+                Ok(val) => {
+                    let ret = unsafe { &*(*self.val.get()).write(val) };
+                    let prev = self.state.swap(INITIALIZED, Ordering::Release);
+                    assert_eq!(prev, INITIALIZING);
+                    Ok(ret)
+                }
+                Err(e) => match self.state.swap(UNINITIALIZED, Ordering::Release) {
+                    INITIALIZING => Err(e),
+                    _ => unreachable!(),
+                },
+            },
+            Err(INITIALIZING) => panic!("concurrent initialization only allowed with `std`"),
+            Err(INITIALIZED) => Ok(self.get().unwrap()),
+            _ => unreachable!(),
+        }
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct RwLock<T> {
+    val: UnsafeCell<T>,
+    state: AtomicU32,
+}
+
+unsafe impl<T: Send> Send for RwLock<T> {}
+unsafe impl<T: Send + Sync> Sync for RwLock<T> {}
+
+impl<T> RwLock<T> {
+    pub const fn new(val: T) -> RwLock<T> {
+        RwLock {
+            val: UnsafeCell::new(val),
+            state: AtomicU32::new(0),
+        }
+    }
+
+    pub fn read(&self) -> impl Deref<Target = T> + '_ {
+        const READER_LIMIT: u32 = u32::MAX / 2;
+        match self
+            .state
+            .fetch_update(Ordering::Acquire, Ordering::Acquire, |x| match x {
+                u32::MAX => None,
+                n => {
+                    let next = n + 1;
+                    if next < READER_LIMIT {
+                        Some(next)
+                    } else {
+                        None
+                    }
+                }
+            }) {
+            Ok(_) => RwLockReadGuard { lock: self },
+            Err(_) => panic!(
+                "concurrent read request while locked for writing, must use `std` to avoid panic"
+            ),
+        }
+    }
+
+    pub fn write(&self) -> impl DerefMut<Target = T> + '_ {
+        match self
+            .state
+            .compare_exchange(0, u32::MAX, Ordering::Acquire, Ordering::Relaxed)
+        {
+            Ok(0) => RwLockWriteGuard { lock: self },
+            _ => panic!("concurrent write request, must use `std` to avoid panicking"),
+        }
+    }
+}
+
+struct RwLockReadGuard<'a, T> {
+    lock: &'a RwLock<T>,
+}
+
+impl<T> Deref for RwLockReadGuard<'_, T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        unsafe { &*self.lock.val.get() }
+    }
+}
+
+impl<T> Drop for RwLockReadGuard<'_, T> {
+    fn drop(&mut self) {
+        self.lock.state.fetch_sub(1, Ordering::Release);
+    }
+}
+
+struct RwLockWriteGuard<'a, T> {
+    lock: &'a RwLock<T>,
+}
+
+impl<T> Deref for RwLockWriteGuard<'_, T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        unsafe { &*self.lock.val.get() }
+    }
+}
+
+impl<T> DerefMut for RwLockWriteGuard<'_, T> {
+    fn deref_mut(&mut self) -> &mut T {
+        unsafe { &mut *self.lock.val.get() }
+    }
+}
+
+impl<T> Drop for RwLockWriteGuard<'_, T> {
+    fn drop(&mut self) {
+        match self.lock.state.swap(0, Ordering::Release) {
+            u32::MAX => {}
+            _ => unreachable!(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn smoke_once_lock() {
+        let lock = OnceLock::new();
+        assert!(lock.get().is_none());
+        assert_eq!(*lock.get_or_init(|| 1), 1);
+        assert_eq!(*lock.get_or_init(|| 2), 1);
+        assert_eq!(*lock.get_or_init(|| 3), 1);
+        assert_eq!(lock.get_or_try_init::<()>(|| Ok(3)), Ok(&1));
+
+        let lock = OnceLock::new();
+        assert_eq!(lock.get_or_try_init::<()>(|| Ok(3)), Ok(&3));
+        assert_eq!(*lock.get_or_init(|| 1), 3);
+
+        let lock = OnceLock::new();
+        assert_eq!(lock.get_or_try_init(|| Err(())), Err(()));
+        assert_eq!(*lock.get_or_init(|| 1), 1);
+    }
+
+    #[test]
+    fn smoke_rwlock() {
+        let lock = RwLock::new(1);
+        assert_eq!(*lock.read(), 1);
+
+        let a = lock.read();
+        let b = lock.read();
+        assert_eq!(*a, 1);
+        assert_eq!(*b, 1);
+        drop((a, b));
+
+        assert_eq!(*lock.write(), 1);
+
+        *lock.write() = 4;
+        assert_eq!(*lock.read(), 4);
+        assert_eq!(*lock.write(), 4);
+
+        let a = lock.read();
+        let b = lock.read();
+        assert_eq!(*a, 4);
+        assert_eq!(*b, 4);
+        drop((a, b));
+    }
+
+    #[test]
+    #[should_panic(expected = "concurrent write request")]
+    fn rwlock_panic_read_then_write() {
+        let lock = RwLock::new(1);
+        let _a = lock.read();
+        let _b = lock.write();
+    }
+
+    #[test]
+    #[should_panic(expected = "concurrent read request")]
+    fn rwlock_panic_write_then_read() {
+        let lock = RwLock::new(1);
+        let _a = lock.write();
+        let _b = lock.read();
+    }
+
+    #[test]
+    #[should_panic(expected = "concurrent write request")]
+    fn rwlock_panic_write_then_write() {
+        let lock = RwLock::new(1);
+        let _a = lock.write();
+        let _b = lock.write();
+    }
+}
diff --git a/crates/wasmtime/src/sync_std.rs b/crates/wasmtime/src/sync_std.rs
new file mode 100644
index 000000000000..73da271fd5cb
--- /dev/null
+++ b/crates/wasmtime/src/sync_std.rs
@@ -0,0 +1,52 @@
+//! Synchronization primitives for Wasmtime.
+//!
+//! This is a small set of primitives split between std and no_std with "dummy"
+//! implementation on no_std. The no_std implementations live in
+//! `sync_nostd.rs`.
+
+use once_cell::sync::OnceCell;
+use std::ops::{Deref, DerefMut};
+
+/// This type is intended to mirror, and one day be implemented by, the
+/// `std::sync::OnceLock` type. At this time
+/// `std::sync::OnceLock::get_or_try_init` is not stable so for now this is
+/// implemented with the `once_cell` crate instead.
+pub struct OnceLock<T>(OnceCell<T>);
+
+impl<T> OnceLock<T> {
+    #[inline]
+    pub const fn new() -> OnceLock<T> {
+        OnceLock(OnceCell::new())
+    }
+
+    #[inline]
+    pub fn get_or_init(&self, f: impl FnOnce() -> T) -> &T {
+        self.0.get_or_init(f)
+    }
+
+    #[inline]
+    pub fn get_or_try_init<E>(&self, f: impl FnOnce() -> Result<T, E>) -> Result<&T, E> {
+        self.0.get_or_try_init(f)
+    }
+}
+
+/// Small wrapper around `std::sync::RwLock` which undoes poisoning.
+#[derive(Debug, Default)]
+pub struct RwLock<T>(std::sync::RwLock<T>);
+
+impl<T> RwLock<T> {
+    #[inline]
+    pub const fn new(val: T) -> RwLock<T> {
+        RwLock(std::sync::RwLock::new(val))
+    }
+
+    #[inline]
+    pub fn read(&self) -> impl Deref<Target = T> + '_ {
+        self.0.read().unwrap()
+    }
+
+    #[inline]
+    pub fn write(&self) -> impl DerefMut<Target = T> + '_ {
+        self.0.write().unwrap()
+    }
+}
diff --git a/crates/wasmtime/src/trampoline.rs b/crates/wasmtime/src/trampoline.rs
deleted file mode 100644
index 7f2499fb3ef2..000000000000
--- a/crates/wasmtime/src/trampoline.rs
+++ /dev/null
@@ -1,77 +0,0 @@
-//! Utility module to create trampolines in/out WebAssembly module.
-
-mod func;
-mod global;
-mod memory;
-mod table;
-
-pub use self::func::*;
-pub use self::global::*;
-pub(crate) use memory::MemoryCreatorProxy;
-
-use self::memory::create_memory;
-use self::table::create_table;
-use crate::module::BareModuleInfo;
-use crate::store::{InstanceId, StoreOpaque};
-use crate::{MemoryType, TableType};
-use anyhow::Result;
-use std::any::Any;
-use std::sync::Arc;
-use wasmtime_environ::{MemoryIndex, Module, TableIndex};
-use wasmtime_runtime::{
-    Imports, InstanceAllocationRequest, InstanceAllocator, OnDemandInstanceAllocator, SharedMemory,
-    StorePtr, VMFunctionImport, VMSharedSignatureIndex,
-};
-
-fn create_handle(
-    module: Module,
-    store: &mut StoreOpaque,
-    host_state: Box<dyn Any + Send + Sync>,
-    func_imports: &[VMFunctionImport],
-    one_signature: Option<VMSharedSignatureIndex>,
-) -> Result<InstanceId> {
-    let mut imports = Imports::default();
-    imports.functions = func_imports;
-
-    unsafe {
-        let config = store.engine().config();
-        // Use the on-demand allocator when creating handles associated with host objects
-        // The configured instance allocator should only be used when creating module instances
-        // as we don't want host objects to count towards instance limits.
-        let module = Arc::new(module);
-        let runtime_info =
-            &BareModuleInfo::maybe_imported_func(module, one_signature).into_traitobj();
-        let handle = OnDemandInstanceAllocator::new(config.mem_creator.clone(), 0)
-            .allocate_module(InstanceAllocationRequest {
-                imports,
-                host_state,
-                store: StorePtr::new(store.traitobj()),
-                runtime_info,
-                wmemcheck: false,
-                pkey: None,
-            })?;
-
-        Ok(store.add_dummy_instance(handle))
-    }
-}
-
-pub fn generate_memory_export(
-    store: &mut StoreOpaque,
-    m: &MemoryType,
-    preallocation: Option<&SharedMemory>,
-) -> Result<wasmtime_runtime::ExportMemory> {
-    let instance = create_memory(store, m, preallocation)?;
-    Ok(store
-        .instance_mut(instance)
-        .get_exported_memory(MemoryIndex::from_u32(0)))
-}
-
-pub fn generate_table_export(
-    store: &mut StoreOpaque,
-    t: &TableType,
-) -> Result<wasmtime_runtime::ExportTable> {
-    let instance = create_table(store, t)?;
-    Ok(store
-        .instance_mut(instance)
-        .get_exported_table(TableIndex::from_u32(0)))
-}
diff --git a/crates/wasmtime/src/trampoline/func.rs b/crates/wasmtime/src/trampoline/func.rs
deleted file mode 100644
index 716e709a140e..000000000000
--- a/crates/wasmtime/src/trampoline/func.rs
+++ /dev/null
@@ -1,133 +0,0 @@
-//! Support for a calling of an imported function.
-
-use crate::{Engine, FuncType, ValRaw};
-use anyhow::Result;
-use std::panic::{self, AssertUnwindSafe};
-use std::ptr::NonNull;
-use wasmtime_jit::CodeMemory;
-use wasmtime_runtime::{
-    StoreBox, VMArrayCallHostFuncContext, VMContext, VMFuncRef, VMOpaqueContext,
-};
-
-struct TrampolineState<F> {
-    func: F,
-    #[allow(dead_code)]
-    code_memory: CodeMemory,
-}
-
-/// Shim to call a host-defined function that uses the array calling convention.
-///
-/// Together with `VMArrayCallHostFuncContext`, this implements the transition
-/// from a raw, non-closure function pointer to a Rust closure that associates
-/// data and function together.
-///
-/// Also shepherds panics and traps across Wasm.
-unsafe extern "C" fn array_call_shim<F>(
-    vmctx: *mut VMOpaqueContext,
-    caller_vmctx: *mut VMOpaqueContext,
-    values_vec: *mut ValRaw,
-    values_vec_len: usize,
-) where
-    F: Fn(*mut VMContext, &mut [ValRaw]) -> Result<()> + 'static,
-{
-    // Here we are careful to use `catch_unwind` to ensure Rust panics don't
-    // unwind past us. The primary reason for this is that Rust considers it UB
-    // to unwind past an `extern "C"` function. Here we are in an `extern "C"`
-    // function and the cross into wasm was through an `extern "C"` function at
-    // the base of the stack as well. We'll need to wait for assorted RFCs and
-    // language features to enable this to be done in a sound and stable fashion
-    // before avoiding catching the panic here.
-    //
-    // Also note that there are intentionally no local variables on this stack
-    // frame. The reason for that is that some of the "raise" functions we have
-    // below will trigger a longjmp, which won't run local destructors if we
-    // have any. To prevent leaks we avoid having any local destructors by
-    // avoiding local variables.
-    let result = panic::catch_unwind(AssertUnwindSafe(|| {
-        let vmctx = VMArrayCallHostFuncContext::from_opaque(vmctx);
-        // Double-check ourselves in debug mode, but we control
-        // the `Any` here so an unsafe downcast should also
-        // work.
-        let state = (*vmctx).host_state();
-        debug_assert!(state.is::<TrampolineState<F>>());
-        let state = &*(state as *const _ as *const TrampolineState<F>);
-        let values_vec = std::slice::from_raw_parts_mut(values_vec, values_vec_len);
-        (state.func)(VMContext::from_opaque(caller_vmctx), values_vec)
-    }));
-
-    match result {
-        Ok(Ok(())) => {}
-
-        // If a trap was raised (an error returned from the imported function)
-        // then we smuggle the trap through `Box<dyn Error>` through to the
-        // call-site, which gets unwrapped in `Trap::from_runtime` later on as we
-        // convert from the internal `Trap` type to our own `Trap` type in this
-        // crate.
-        Ok(Err(trap)) => crate::trap::raise(trap.into()),
-
-        // And finally if the imported function panicked, then we trigger the
-        // form of unwinding that's safe to jump over wasm code on all
-        // platforms.
-        Err(panic) => wasmtime_runtime::resume_panic(panic),
-    }
-}
-
-#[cfg(any(feature = "cranelift", feature = "winch"))]
-pub fn create_array_call_function<F>(
-    ft: &FuncType,
-    func: F,
-    engine: &Engine,
-) -> Result<StoreBox<VMArrayCallHostFuncContext>>
-where
-    F: Fn(*mut VMContext, &mut [ValRaw]) -> Result<()> + Send + Sync + 'static,
-{
-    use std::ptr;
-
-    let mut obj = engine
-        .compiler()
-        .object(wasmtime_environ::ObjectKind::Module)?;
-    let (wasm_call_range, native_call_range) = engine
-        .compiler()
-        .emit_trampolines_for_array_call_host_func(
-            ft.as_wasm_func_type(),
-            array_call_shim::<F> as usize,
-            &mut obj,
-        )?;
-    engine.append_bti(&mut obj);
-    let obj = wasmtime_jit::ObjectBuilder::new(obj, &engine.config().tunables).finish()?;
-
-    // Copy the results of JIT compilation into executable memory, and this will
-    // also take care of unwind table registration.
-    let mut code_memory = CodeMemory::new(obj)?;
-    code_memory.publish()?;
-
-    engine.profiler().register_module(&code_memory, &|_| None);
-
-    // Extract the host/wasm trampolines from the results of compilation since
-    // we know their start/length.
-
-    let text = code_memory.text();
-
-    let array_call = array_call_shim::<F>;
-
-    let wasm_call = text[wasm_call_range.start as usize..].as_ptr() as *mut _;
-    let wasm_call = Some(NonNull::new(wasm_call).unwrap());
-
-    let native_call = text[native_call_range.start as usize..].as_ptr() as *mut _;
-    let native_call = NonNull::new(native_call).unwrap();
-
-    let sig = engine.signatures().register(ft.as_wasm_func_type());
-
-    unsafe {
-        Ok(VMArrayCallHostFuncContext::new(
-            VMFuncRef {
-                array_call,
-                wasm_call,
-                native_call,
-                type_index: sig,
-                vmctx: ptr::null_mut(),
-            },
-            Box::new(TrampolineState { func, code_memory }),
-        ))
-    }
-}
diff --git a/crates/wasmtime/src/trampoline/global.rs b/crates/wasmtime/src/trampoline/global.rs
deleted file mode 100644
index 50a77811d1e4..000000000000
--- a/crates/wasmtime/src/trampoline/global.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-use crate::store::StoreOpaque;
-use crate::{GlobalType, Mutability, Val};
-use std::ptr;
-use wasmtime_runtime::{StoreBox, VMGlobalDefinition};
-
-#[repr(C)]
-pub struct VMHostGlobalContext {
-    pub(crate) ty: GlobalType,
-    pub(crate) global: VMGlobalDefinition,
-}
-
-impl Drop for VMHostGlobalContext {
-    fn drop(&mut self) {
-        match self.ty.content() {
-            crate::ValType::I32
-            | crate::ValType::I64
-            | crate::ValType::F32
-            | crate::ValType::F64
-            | crate::ValType::V128
-            | crate::ValType::FuncRef => {
-                // Nothing to drop.
-            }
-            crate::ValType::ExternRef => unsafe {
-                ptr::drop_in_place(self.global.as_externref_mut())
-            },
-        }
-    }
-}
-
-pub fn generate_global_export(
-    store: &mut StoreOpaque,
-    ty: GlobalType,
-    val: Val,
-) -> wasmtime_runtime::ExportGlobal {
-    let global = wasmtime_environ::Global {
-        wasm_ty: ty.content().to_wasm_type(),
-        mutability: match ty.mutability() {
-            Mutability::Const => false,
-            Mutability::Var => true,
-        },
-    };
-    let ctx = StoreBox::new(VMHostGlobalContext {
-        ty,
-        global: VMGlobalDefinition::new(),
-    });
-
-    let definition = unsafe {
-        let global = &mut (*ctx.get()).global;
-        match val {
-            Val::I32(x) => *global.as_i32_mut() = x,
-            Val::I64(x) => *global.as_i64_mut() = x,
-            Val::F32(x) => *global.as_f32_bits_mut() = x,
-            Val::F64(x) => *global.as_f64_bits_mut() = x,
-            Val::V128(x) => *global.as_u128_mut() = x.into(),
-            Val::FuncRef(f) => {
-                *global.as_func_ref_mut() =
-                    f.map_or(ptr::null_mut(), |f| f.vm_func_ref(store).as_ptr())
-            }
-            Val::ExternRef(x) => *global.as_externref_mut() = x.map(|x| x.inner),
-        }
-        global
-    };
-
-    store.host_globals().push(ctx);
-    wasmtime_runtime::ExportGlobal { definition, global }
-}
diff --git a/crates/wasmtime/src/trampoline/memory.rs b/crates/wasmtime/src/trampoline/memory.rs
deleted file mode 100644
index 72c7eb891f81..000000000000
--- a/crates/wasmtime/src/trampoline/memory.rs
+++ /dev/null
@@ -1,269 +0,0 @@
-use crate::memory::{LinearMemory, MemoryCreator};
-use crate::module::BareModuleInfo;
-use crate::store::{InstanceId, StoreOpaque};
-use crate::MemoryType;
-use anyhow::{anyhow, Result};
-use std::convert::TryFrom;
-use std::ops::Range;
-use std::sync::Arc;
-use wasmtime_environ::{
-    DefinedMemoryIndex, DefinedTableIndex, EntityIndex, HostPtr, MemoryPlan, MemoryStyle, Module,
-    VMOffsets, WASM_PAGE_SIZE,
-};
-use wasmtime_runtime::mpk::ProtectionKey;
-use wasmtime_runtime::{
-    CompiledModuleId, Imports, InstanceAllocationRequest, InstanceAllocator, InstanceAllocatorImpl,
-    Memory, MemoryAllocationIndex, MemoryImage, OnDemandInstanceAllocator, RuntimeLinearMemory,
-    RuntimeMemoryCreator, SharedMemory, StorePtr, Table, TableAllocationIndex, VMMemoryDefinition,
-};
-
-#[cfg(feature = "component-model")]
-use wasmtime_environ::{
-    component::{Component, VMComponentOffsets},
-    StaticModuleIndex,
-};
-
-/// Create a "frankenstein" instance with a single memory.
-///
-/// This separate instance is necessary because Wasm objects in Wasmtime must be
-/// attached to instances (versus the store, e.g.) and some objects exist
-/// outside: a host-provided memory import, shared memory.
-pub fn create_memory(
-    store: &mut StoreOpaque,
-    memory_ty: &MemoryType,
-    preallocation: Option<&SharedMemory>,
-) -> Result<InstanceId> {
-    let mut module = Module::new();
-
-    // Create a memory plan for the memory, though it will never be used for
-    // constructing a memory with an allocator: instead the memories are either
-    // preallocated (i.e., shared memory) or allocated manually below.
-    let plan = wasmtime_environ::MemoryPlan::for_memory(
-        memory_ty.wasmtime_memory().clone(),
-        &store.engine().config().tunables,
-    );
-    let memory_id = module.memory_plans.push(plan.clone());
-
-    // Since we have only associated a single memory with the "frankenstein"
-    // instance, it will be exported at index 0.
-    debug_assert_eq!(memory_id.as_u32(), 0);
-    module
-        .exports
-        .insert(String::new(), EntityIndex::Memory(memory_id));
-
-    // We create an instance in the on-demand allocator when creating handles
-    // associated with external objects. The configured instance allocator
-    // should only be used when creating module instances as we don't want host
-    // objects to count towards instance limits.
-    let runtime_info = &BareModuleInfo::maybe_imported_func(Arc::new(module), None).into_traitobj();
-    let host_state = Box::new(());
-    let imports = Imports::default();
-    let request = InstanceAllocationRequest {
-        imports,
-        host_state,
-        store: StorePtr::new(store.traitobj()),
-        runtime_info,
-        wmemcheck: false,
-        pkey: None,
-    };
-
-    unsafe {
-        let handle = SingleMemoryInstance {
-            preallocation,
-            ondemand: OnDemandInstanceAllocator::default(),
-        }
-        .allocate_module(request)?;
-        let instance_id = store.add_dummy_instance(handle.clone());
-        Ok(instance_id)
-    }
-}
-
-struct LinearMemoryProxy {
-    mem: Box<dyn LinearMemory>,
-}
-
-impl RuntimeLinearMemory for LinearMemoryProxy {
-    fn byte_size(&self) -> usize {
-        self.mem.byte_size()
-    }
-
-    fn maximum_byte_size(&self) -> Option<usize> {
-        self.mem.maximum_byte_size()
-    }
-
-    fn grow_to(&mut self, new_size: usize) -> Result<()> {
-        self.mem.grow_to(new_size)
-    }
-
-    fn vmmemory(&mut self) -> VMMemoryDefinition {
-        VMMemoryDefinition {
-            base: self.mem.as_ptr(),
-            current_length: self.mem.byte_size().into(),
-        }
-    }
-
-    fn needs_init(&self) -> bool {
-        true
-    }
-
-    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
-        self
-    }
-
-    fn wasm_accessible(&self) -> Range<usize> {
-        self.mem.wasm_accessible()
-    }
-}
-
-#[derive(Clone)]
-pub(crate) struct MemoryCreatorProxy(pub Arc<dyn MemoryCreator>);
-
-impl RuntimeMemoryCreator for MemoryCreatorProxy {
-    fn new_memory(
-        &self,
-        plan: &MemoryPlan,
-        minimum: usize,
-        maximum: Option<usize>,
-        _: Option<&Arc<MemoryImage>>,
-    ) -> Result<Box<dyn RuntimeLinearMemory>> {
-        let ty = MemoryType::from_wasmtime_memory(&plan.memory);
-        let reserved_size_in_bytes = match plan.style {
-            MemoryStyle::Static { bound } => {
-                Some(usize::try_from(bound * (WASM_PAGE_SIZE as u64)).unwrap())
-            }
-            MemoryStyle::Dynamic { .. } => None,
-        };
-        self.0
-            .new_memory(
-                ty,
-                minimum,
-                maximum,
-                reserved_size_in_bytes,
-                usize::try_from(plan.offset_guard_size).unwrap(),
-            )
-            .map(|mem| Box::new(LinearMemoryProxy { mem }) as Box<dyn RuntimeLinearMemory>)
-            .map_err(|e| anyhow!(e))
-    }
-}
-
-struct SingleMemoryInstance<'a> {
-    preallocation: Option<&'a SharedMemory>,
-    ondemand: OnDemandInstanceAllocator,
-}
-
-unsafe impl InstanceAllocatorImpl for SingleMemoryInstance<'_> {
-    #[cfg(feature = "component-model")]
-    fn validate_component_impl<'a>(
-        &self,
-        _component: &Component,
-        _offsets: &VMComponentOffsets<HostPtr>,
-        _get_module: &'a dyn Fn(StaticModuleIndex) -> &'a Module,
-    ) -> Result<()> {
-        unreachable!("`SingleMemoryInstance` allocator never used with components")
-    }
-
-    fn validate_module_impl(&self, module: &Module, offsets: &VMOffsets<HostPtr>) -> Result<()> {
-        anyhow::ensure!(
-            module.memory_plans.len() == 1,
-            "`SingleMemoryInstance` allocator can only be used for modules with a single memory"
-        );
-        self.ondemand.validate_module_impl(module, offsets)?;
-        Ok(())
-    }
-
-    fn increment_component_instance_count(&self) -> Result<()> {
-        self.ondemand.increment_component_instance_count()
-    }
-
-    fn decrement_component_instance_count(&self) {
-        self.ondemand.decrement_component_instance_count();
-    }
-
-    fn increment_core_instance_count(&self) -> Result<()> {
-        self.ondemand.increment_core_instance_count()
-    }
-
-    fn decrement_core_instance_count(&self) {
-        self.ondemand.decrement_core_instance_count();
-    }
-
-    unsafe fn allocate_memory(
-        &self,
-        request: &mut InstanceAllocationRequest,
-        memory_plan: &MemoryPlan,
-        memory_index: DefinedMemoryIndex,
-    ) -> Result<(MemoryAllocationIndex, Memory)> {
-        #[cfg(debug_assertions)]
-        {
-            let module = request.runtime_info.module();
-            let offsets = request.runtime_info.offsets();
-            self.validate_module_impl(module, offsets)
-                .expect("should have already validated the module before allocating memory");
-        }
-
-        match self.preallocation {
-            Some(shared_memory) => Ok((
-                MemoryAllocationIndex::default(),
-                shared_memory.clone().as_memory(),
-            )),
-            None => self
-                .ondemand
-                .allocate_memory(request, memory_plan, memory_index),
-        }
-    }
-
-    unsafe fn deallocate_memory(
-        &self,
-        memory_index: DefinedMemoryIndex,
-        allocation_index: MemoryAllocationIndex,
-        memory: Memory,
-    ) {
-        self.ondemand
-            .deallocate_memory(memory_index, allocation_index, memory)
-    }
-
-    unsafe fn allocate_table(
-        &self,
-        req: &mut InstanceAllocationRequest,
-        table_plan: &wasmtime_environ::TablePlan,
-        table_index: DefinedTableIndex,
-    ) -> Result<(TableAllocationIndex, Table)> {
-        self.ondemand.allocate_table(req, table_plan, table_index)
-    }
-
-    unsafe fn deallocate_table(
-        &self,
-        table_index: DefinedTableIndex,
-        allocation_index: TableAllocationIndex,
-        table: Table,
-    ) {
-        self.ondemand
-            .deallocate_table(table_index, allocation_index, table)
-    }
-
-    #[cfg(feature = "async")]
-    fn allocate_fiber_stack(&self) -> Result<wasmtime_fiber::FiberStack> {
-        unreachable!()
-    }
-
-    #[cfg(feature = "async")]
-    unsafe fn deallocate_fiber_stack(&self, _stack: &wasmtime_fiber::FiberStack) {
-        unreachable!()
-    }
-
-    fn purge_module(&self, _: CompiledModuleId) {
-        unreachable!()
-    }
-
-    fn next_available_pkey(&self) -> Option<ProtectionKey> {
-        unreachable!()
-    }
-
-    fn restrict_to_pkey(&self, _: ProtectionKey) {
-        unreachable!()
-    }
-
-    fn allow_all_pkeys(&self) {
-        unreachable!()
-    }
-}
diff --git a/crates/wasmtime/src/trampoline/table.rs b/crates/wasmtime/src/trampoline/table.rs
deleted file mode 100644
index f351a26096f1..000000000000
--- a/crates/wasmtime/src/trampoline/table.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-use crate::store::{InstanceId, StoreOpaque};
-use crate::trampoline::create_handle;
-use crate::TableType;
-use anyhow::Result;
-use wasmtime_environ::{EntityIndex, Module};
-
-pub fn create_table(store: &mut StoreOpaque, table: &TableType) -> Result<InstanceId> {
-    let mut module = Module::new();
-    let table_plan = wasmtime_environ::TablePlan::for_table(
-        table.wasmtime_table().clone(),
-        &store.engine().config().tunables,
-    );
-    let table_id = module.table_plans.push(table_plan);
-    // TODO: can this `exports.insert` get removed?
-    module
-        .exports
-        .insert(String::new(), EntityIndex::Table(table_id));
-
-    create_handle(module, store, Box::new(()), &[], None)
-}
diff --git a/crates/wasmtime/src/types.rs b/crates/wasmtime/src/types.rs
deleted file mode 100644
index 98b3ca73a67b..000000000000
--- a/crates/wasmtime/src/types.rs
+++ /dev/null
@@ -1,581 +0,0 @@
-use std::fmt;
-use wasmtime_environ::{
-    EntityType, Global, Memory, ModuleTypes, Table, WasmFuncType, WasmRefType, WasmType,
-};
-
-pub(crate) mod matching;
-
-// Type Representations
-
-// Type attributes
-
-/// Indicator of whether a global is mutable or not
-#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq)]
-pub enum Mutability {
-    /// The global is constant and its value does not change
-    Const,
-    /// The value of the global can change over time
-    Var,
-}
-
-// Value Types
-
-/// A list of all possible value types in WebAssembly.
-#[derive(Debug, Clone, Hash, Eq, PartialEq)]
-pub enum ValType {
-    // NB: the ordering here is intended to match the ordering in
-    // `wasmtime_types::WasmType` to help improve codegen when converting.
-    /// Signed 32 bit integer.
-    I32,
-    /// Signed 64 bit integer.
-    I64,
-    /// Floating point 32 bit integer.
-    F32,
-    /// Floating point 64 bit integer.
-    F64,
-    /// A 128 bit number.
-    V128,
-    /// A reference to a Wasm function.
-    FuncRef,
-    /// A reference to opaque data in the Wasm instance.
-    ExternRef,
-}
-
-impl fmt::Display for ValType {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            ValType::I32 => write!(f, "i32"),
-            ValType::I64 => write!(f, "i64"),
-            ValType::F32 => write!(f, "f32"),
-            ValType::F64 => write!(f, "f64"),
-            ValType::V128 => write!(f, "v128"),
-            ValType::ExternRef => write!(f, "externref"),
-            ValType::FuncRef => write!(f, "funcref"),
-        }
-    }
-}
-
-impl ValType {
-    /// Returns true if `ValType` matches any of the numeric types. (e.g. `I32`,
-    /// `I64`, `F32`, `F64`).
-    pub fn is_num(&self) -> bool {
-        match self {
-            ValType::I32 | ValType::I64 | ValType::F32 | ValType::F64 => true,
-            _ => false,
-        }
-    }
-
-    /// Returns true if `ValType` matches either of the reference types.
-    pub fn is_ref(&self) -> bool {
-        match self {
-            ValType::ExternRef | ValType::FuncRef => true,
-            _ => false,
-        }
-    }
-
-    pub(crate) fn to_wasm_type(&self) -> WasmType {
-        match self {
-            Self::I32 => WasmType::I32,
-            Self::I64 => WasmType::I64,
-            Self::F32 => WasmType::F32,
-            Self::F64 => WasmType::F64,
-            Self::V128 => WasmType::V128,
-            Self::FuncRef => WasmType::Ref(WasmRefType::FUNCREF),
-            Self::ExternRef => WasmType::Ref(WasmRefType::EXTERNREF),
-        }
-    }
-
-    pub(crate) fn from_wasm_type(ty: &WasmType) -> Self {
-        match ty {
-            WasmType::I32 => Self::I32,
-            WasmType::I64 => Self::I64,
-            WasmType::F32 => Self::F32,
-            WasmType::F64 => Self::F64,
-            WasmType::V128 => Self::V128,
-            WasmType::Ref(WasmRefType::FUNCREF) => Self::FuncRef,
-            WasmType::Ref(WasmRefType::EXTERNREF) => Self::ExternRef,
-            // FIXME: exposing the full function-references (and beyond)
-            // proposals will require redesigning the embedder API for `ValType`
-            // and types in Wasmtime. That is a large undertaking which is
-            // deferred for later. The intention for now is that
-            // function-references types can't show up in the "public API" of a
-            // core wasm module but it can use everything internally still.
-            WasmType::Ref(_) => {
-                unimplemented!("typed function references are not exposed in the public API yet")
-            }
-        }
-    }
-}
-
-// External Types
-
-/// A list of all possible types which can be externally referenced from a
-/// WebAssembly module.
-///
-/// This list can be found in [`ImportType`] or [`ExportType`], so these types
-/// can either be imported or exported.
-#[derive(Debug, Clone)]
-pub enum ExternType {
-    /// This external type is the type of a WebAssembly function.
-    Func(FuncType),
-    /// This external type is the type of a WebAssembly global.
-    Global(GlobalType),
-    /// This external type is the type of a WebAssembly table.
-    Table(TableType),
-    /// This external type is the type of a WebAssembly memory.
-    Memory(MemoryType),
-}
-
-macro_rules! accessors {
-    ($(($variant:ident($ty:ty) $get:ident $unwrap:ident))*) => ($(
-        /// Attempt to return the underlying type of this external type,
-        /// returning `None` if it is a different type.
-        pub fn $get(&self) -> Option<&$ty> {
-            if let ExternType::$variant(e) = self {
-                Some(e)
-            } else {
-                None
-            }
-        }
-
-        /// Returns the underlying descriptor of this [`ExternType`], panicking
-        /// if it is a different type.
-        ///
-        /// # Panics
-        ///
-        /// Panics if `self` is not of the right type.
-        pub fn $unwrap(&self) -> &$ty {
-            self.$get().expect(concat!("expected ", stringify!($ty)))
-        }
-    )*)
-}
-
-impl ExternType {
-    accessors! {
-        (Func(FuncType) func unwrap_func)
-        (Global(GlobalType) global unwrap_global)
-        (Table(TableType) table unwrap_table)
-        (Memory(MemoryType) memory unwrap_memory)
-    }
-
-    pub(crate) fn from_wasmtime(types: &ModuleTypes, ty: &EntityType) -> ExternType {
-        match ty {
-            EntityType::Function(idx) => FuncType::from_wasm_func_type(types[*idx].clone()).into(),
-            EntityType::Global(ty) => GlobalType::from_wasmtime_global(ty).into(),
-            EntityType::Memory(ty) => MemoryType::from_wasmtime_memory(ty).into(),
-            EntityType::Table(ty) => TableType::from_wasmtime_table(ty).into(),
-            EntityType::Tag(_) => unimplemented!("wasm tag support"),
-        }
-    }
-}
-
-impl From<FuncType> for ExternType {
-    fn from(ty: FuncType) -> ExternType {
-        ExternType::Func(ty)
-    }
-}
-
-impl From<GlobalType> for ExternType {
-    fn from(ty: GlobalType) -> ExternType {
-        ExternType::Global(ty)
-    }
-}
-
-impl From<MemoryType> for ExternType {
-    fn from(ty: MemoryType) -> ExternType {
-        ExternType::Memory(ty)
-    }
-}
-
-impl From<TableType> for ExternType {
-    fn from(ty: TableType) -> ExternType {
-        ExternType::Table(ty)
-    }
-}
-
-/// A descriptor for a function in a WebAssembly module.
-///
-/// WebAssembly functions can have 0 or more parameters and results.
-#[derive(Debug, Clone, Hash, Eq, PartialEq)]
-pub struct FuncType {
-    sig: WasmFuncType,
-}
-
-impl FuncType {
-    /// Creates a new function descriptor from the given parameters and results.
-    ///
-    /// The function descriptor returned will represent a function which takes
-    /// `params` as arguments and returns `results` when it is finished.
-    pub fn new(
-        params: impl IntoIterator<Item = ValType>,
-        results: impl IntoIterator<Item = ValType>,
-    ) -> FuncType {
-        FuncType {
-            sig: WasmFuncType::new(
-                params.into_iter().map(|t| t.to_wasm_type()).collect(),
-                results.into_iter().map(|t| t.to_wasm_type()).collect(),
-            ),
-        }
-    }
-
-    /// Returns the list of parameter types for this function.
-    #[inline]
-    pub fn params(&self) -> impl ExactSizeIterator<Item = ValType> + '_ {
-        self.sig.params().iter().map(ValType::from_wasm_type)
-    }
-
-    /// Returns the list of result types for this function.
-    #[inline]
-    pub fn results(&self) -> impl ExactSizeIterator<Item = ValType> + '_ {
-        self.sig.returns().iter().map(ValType::from_wasm_type)
-    }
-
-    pub(crate) fn as_wasm_func_type(&self) -> &WasmFuncType {
-        &self.sig
-    }
-
-    pub(crate) fn from_wasm_func_type(sig: WasmFuncType) -> FuncType {
-        Self { sig }
-    }
-}
-
-// Global Types
-
-/// A WebAssembly global descriptor.
-///
-/// This type describes an instance of a global in a WebAssembly module. Globals
-/// are local to an [`Instance`](crate::Instance) and are either immutable or
-/// mutable.
-#[derive(Debug, Clone, Hash, Eq, PartialEq)]
-pub struct GlobalType {
-    content: ValType,
-    mutability: Mutability,
-}
-
-impl GlobalType {
-    /// Creates a new global descriptor of the specified `content` type and
-    /// whether or not it's mutable.
-    pub fn new(content: ValType, mutability: Mutability) -> GlobalType {
-        GlobalType {
-            content,
-            mutability,
-        }
-    }
-
-    /// Returns the value type of this global descriptor.
-    pub fn content(&self) -> &ValType {
-        &self.content
-    }
-
-    /// Returns whether or not this global is mutable.
-    pub fn mutability(&self) -> Mutability {
-        self.mutability
-    }
-
-    pub(crate) fn to_wasm_type(&self) -> Global {
-        let wasm_ty = self.content().to_wasm_type();
-        let mutability = matches!(self.mutability(), Mutability::Var);
-        Global {
-            wasm_ty,
-            mutability,
-        }
-    }
-
-    /// Returns `None` if the wasmtime global has a type that we can't
-    /// represent, but that should only very rarely happen and indicate a bug.
-    pub(crate) fn from_wasmtime_global(global: &Global) -> GlobalType {
-        let ty = ValType::from_wasm_type(&global.wasm_ty);
-        let mutability = if global.mutability {
-            Mutability::Var
-        } else {
-            Mutability::Const
-        };
-        GlobalType::new(ty, mutability)
-    }
-}
-
-// Table Types
-
-/// A descriptor for a table in a WebAssembly module.
-///
-/// Tables are contiguous chunks of a specific element, typically a `funcref` or
-/// an `externref`. The most common use for tables is a function table through
-/// which `call_indirect` can invoke other functions.
-#[derive(Debug, Clone, Hash, Eq, PartialEq)]
-pub struct TableType {
-    ty: Table,
-}
-
-impl TableType {
-    /// Creates a new table descriptor which will contain the specified
-    /// `element` and have the `limits` applied to its length.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the `element` type provided is not a reference type.
-    pub fn new(element: ValType, min: u32, max: Option<u32>) -> TableType {
-        TableType {
-            ty: Table {
-                // FIXME: the `ValType` API should be redesigned and the
-                // argument to this constructor should be `RefType`.
-                wasm_ty: match element {
-                    ValType::FuncRef => WasmRefType::FUNCREF,
-                    ValType::ExternRef => WasmRefType::EXTERNREF,
-                    _ => panic!("Attempt to convert non-reference type to a reference type"),
-                },
-                minimum: min,
-                maximum: max,
-            },
-        }
-    }
-
-    /// Returns the element value type of this table.
-    pub fn element(&self) -> ValType {
-        ValType::from_wasm_type(&WasmType::Ref(self.ty.wasm_ty))
-    }
-
-    /// Returns minimum number of elements this table must have
-    pub fn minimum(&self) -> u32 {
-        self.ty.minimum
-    }
-
-    /// Returns the optionally-specified maximum number of elements this table
-    /// can have.
-    ///
-    /// If this returns `None` then the table is not limited in size.
-    pub fn maximum(&self) -> Option<u32> {
-        self.ty.maximum
-    }
-
-    pub(crate) fn from_wasmtime_table(table: &Table) -> TableType {
-        TableType { ty: table.clone() }
-    }
-
-    pub(crate) fn wasmtime_table(&self) -> &Table {
-        &self.ty
-    }
-}
-
-// Memory Types
-
-/// A descriptor for a WebAssembly memory type.
-///
-/// Memories are described in units of pages (64KB) and represent contiguous
-/// chunks of addressable memory.
-#[derive(Debug, Clone, Hash, Eq, PartialEq)]
-pub struct MemoryType {
-    ty: Memory,
-}
-
-impl MemoryType {
-    /// Creates a new descriptor for a 32-bit WebAssembly memory given the
-    /// specified limits of the memory.
-    ///
-    /// The `minimum` and `maximum`  values here are specified in units of
-    /// WebAssembly pages, which are 64k.
-    pub fn new(minimum: u32, maximum: Option<u32>) -> MemoryType {
-        MemoryType {
-            ty: Memory {
-                memory64: false,
-                shared: false,
-                minimum: minimum.into(),
-                maximum: maximum.map(|i| i.into()),
-            },
-        }
-    }
-
-    /// Creates a new descriptor for a 64-bit WebAssembly memory given the
-    /// specified limits of the memory.
-    ///
-    /// The `minimum` and `maximum`  values here are specified in units of
-    /// WebAssembly pages, which are 64k.
-    ///
-    /// Note that 64-bit memories are part of the memory64 proposal for
-    /// WebAssembly which is not standardized yet.
-    pub fn new64(minimum: u64, maximum: Option<u64>) -> MemoryType {
-        MemoryType {
-            ty: Memory {
-                memory64: true,
-                shared: false,
-                minimum,
-                maximum,
-            },
-        }
-    }
-
-    /// Creates a new descriptor for shared WebAssembly memory given the
-    /// specified limits of the memory.
-    ///
-    /// The `minimum` and `maximum`  values here are specified in units of
-    /// WebAssembly pages, which are 64k.
-    ///
-    /// Note that shared memories are part of the threads proposal for
-    /// WebAssembly which is not standardized yet.
-    pub fn shared(minimum: u32, maximum: u32) -> MemoryType {
-        MemoryType {
-            ty: Memory {
-                memory64: false,
-                shared: true,
-                minimum: minimum.into(),
-                maximum: Some(maximum.into()),
-            },
-        }
-    }
-
-    /// Returns whether this is a 64-bit memory or not.
-    ///
-    /// Note that 64-bit memories are part of the memory64 proposal for
-    /// WebAssembly which is not standardized yet.
-    pub fn is_64(&self) -> bool {
-        self.ty.memory64
-    }
-
-    /// Returns whether this is a shared memory or not.
-    ///
-    /// Note that shared memories are part of the threads proposal for
-    /// WebAssembly which is not standardized yet.
-    pub fn is_shared(&self) -> bool {
-        self.ty.shared
-    }
-
-    /// Returns minimum number of WebAssembly pages this memory must have.
-    ///
-    /// Note that the return value, while a `u64`, will always fit into a `u32`
-    /// for 32-bit memories.
-    pub fn minimum(&self) -> u64 {
-        self.ty.minimum
-    }
-
-    /// Returns the optionally-specified maximum number of pages this memory
-    /// can have.
-    ///
-    /// If this returns `None` then the memory is not limited in size.
-    ///
-    /// Note that the return value, while a `u64`, will always fit into a `u32`
-    /// for 32-bit memories.
-    pub fn maximum(&self) -> Option<u64> {
-        self.ty.maximum
-    }
-
-    pub(crate) fn from_wasmtime_memory(memory: &Memory) -> MemoryType {
-        MemoryType { ty: memory.clone() }
-    }
-
-    pub(crate) fn wasmtime_memory(&self) -> &Memory {
-        &self.ty
-    }
-}
-
-// Import Types
-
-/// A descriptor for an imported value into a wasm module.
-///
-/// This type is primarily accessed from the
-/// [`Module::imports`](crate::Module::imports) API. Each [`ImportType`]
-/// describes an import into the wasm module with the module/name that it's
-/// imported from as well as the type of item that's being imported.
-#[derive(Clone)]
-pub struct ImportType<'module> {
-    /// The module of the import.
-    module: &'module str,
-
-    /// The field of the import.
-    name: &'module str,
-
-    /// The type of the import.
-    ty: EntityType,
-    types: &'module ModuleTypes,
-}
-
-impl<'module> ImportType<'module> {
-    /// Creates a new import descriptor which comes from `module` and `name` and
-    /// is of type `ty`.
-    pub(crate) fn new(
-        module: &'module str,
-        name: &'module str,
-        ty: EntityType,
-        types: &'module ModuleTypes,
-    ) -> ImportType<'module> {
-        ImportType {
-            module,
-            name,
-            ty,
-            types,
-        }
-    }
-
-    /// Returns the module name that this import is expected to come from.
-    pub fn module(&self) -> &'module str {
-        self.module
-    }
-
-    /// Returns the field name of the module that this import is expected to
-    /// come from.
-    pub fn name(&self) -> &'module str {
-        self.name
-    }
-
-    /// Returns the expected type of this import.
-    pub fn ty(&self) -> ExternType {
-        ExternType::from_wasmtime(self.types, &self.ty)
-    }
-}
-
-impl<'module> fmt::Debug for ImportType<'module> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("ImportType")
-            .field("module", &self.module())
-            .field("name", &self.name())
-            .field("ty", &self.ty())
-            .finish()
-    }
-}
-
-// Export Types
-
-/// A descriptor for an exported WebAssembly value.
-///
-/// This type is primarily accessed from the
-/// [`Module::exports`](crate::Module::exports) accessor and describes what
-/// names are exported from a wasm module and the type of the item that is
-/// exported.
-#[derive(Clone)]
-pub struct ExportType<'module> {
-    /// The name of the export.
-    name: &'module str,
-
-    /// The type of the export.
-    ty: EntityType,
-    types: &'module ModuleTypes,
-}
-
-impl<'module> ExportType<'module> {
-    /// Creates a new export which is exported with the given `name` and has the
-    /// given `ty`.
-    pub(crate) fn new(
-        name: &'module str,
-        ty: EntityType,
-        types: &'module ModuleTypes,
-    ) -> ExportType<'module> {
-        ExportType { name, ty, types }
-    }
-
-    /// Returns the name by which this export is known.
-    pub fn name(&self) -> &'module str {
-        self.name
-    }
-
-    /// Returns the type of this export.
-    pub fn ty(&self) -> ExternType {
-        ExternType::from_wasmtime(self.types, &self.ty)
-    }
-}
-
-impl<'module> fmt::Debug for ExportType<'module> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("ExportType")
-            .field("name", &self.name().to_owned())
-            .field("ty", &self.ty())
-            .finish()
-    }
-}
diff --git a/crates/wasmtime/src/types/matching.rs b/crates/wasmtime/src/types/matching.rs
deleted file mode 100644
index f0e24e1fe1b6..000000000000
--- a/crates/wasmtime/src/types/matching.rs
+++ /dev/null
@@ -1,312 +0,0 @@
-use crate::linker::DefinitionType;
-use crate::{signatures::SignatureCollection, Engine};
-use anyhow::{anyhow, bail, Result};
-use wasmtime_environ::{
-    EntityType, Global, Memory, ModuleTypes, SignatureIndex, Table, WasmFuncType, WasmHeapType,
-    WasmRefType, WasmType,
-};
-use wasmtime_runtime::VMSharedSignatureIndex;
-
-pub struct MatchCx<'a> {
-    pub signatures: &'a SignatureCollection,
-    pub types: &'a ModuleTypes,
-    pub engine: &'a Engine,
-}
-
-impl MatchCx<'_> {
-    pub fn vmshared_signature_index(
-        &self,
-        expected: SignatureIndex,
-        actual: VMSharedSignatureIndex,
-    ) -> Result<()> {
-        let matches = match self.signatures.shared_signature(expected) {
-            Some(idx) => actual == idx,
-            // If our expected signature isn't registered, then there's no way
-            // that `actual` can match it.
-            None => false,
-        };
-        if matches {
-            return Ok(());
-        }
-        let msg = "function types incompatible";
-        let expected = &self.types[expected];
-        let actual = match self.engine.signatures().lookup_type(actual) {
-            Some(ty) => ty,
-            None => {
-                debug_assert!(false, "all signatures should be registered");
-                bail!("{}", msg);
-            }
-        };
-
-        Err(func_ty_mismatch(msg, expected, &actual))
-    }
-
-    /// Validates that the `expected` type matches the type of `actual`
-    pub(crate) fn definition(&self, expected: &EntityType, actual: &DefinitionType) -> Result<()> {
-        match expected {
-            EntityType::Global(expected) => match actual {
-                DefinitionType::Global(actual) => global_ty(expected, actual),
-                _ => bail!("expected global, but found {}", actual.desc()),
-            },
-            EntityType::Table(expected) => match actual {
-                DefinitionType::Table(actual, cur_size) => {
-                    table_ty(expected, actual, Some(*cur_size))
-                }
-                _ => bail!("expected table, but found {}", actual.desc()),
-            },
-            EntityType::Memory(expected) => match actual {
-                DefinitionType::Memory(actual, cur_size) => {
-                    memory_ty(expected, actual, Some(*cur_size))
-                }
-                _ => bail!("expected memory, but found {}", actual.desc()),
-            },
-            EntityType::Function(expected) => match actual {
-                DefinitionType::Func(actual) => self.vmshared_signature_index(*expected, *actual),
-                _ => bail!("expected func, but found {}", actual.desc()),
-            },
-            EntityType::Tag(_) => unimplemented!(),
-        }
-    }
-}
-
-#[cfg_attr(not(feature = "component-model"), allow(dead_code))]
-pub fn entity_ty(
-    expected: &EntityType,
-    expected_types: &ModuleTypes,
-    actual: &EntityType,
-    actual_types: &ModuleTypes,
-) -> Result<()> {
-    match expected {
-        EntityType::Memory(expected) => match actual {
-            EntityType::Memory(actual) => memory_ty(expected, actual, None),
-            _ => bail!("expected memory found {}", entity_desc(actual)),
-        },
-        EntityType::Global(expected) => match actual {
-            EntityType::Global(actual) => global_ty(expected, actual),
-            _ => bail!("expected global found {}", entity_desc(actual)),
-        },
-        EntityType::Table(expected) => match actual {
-            EntityType::Table(actual) => table_ty(expected, actual, None),
-            _ => bail!("expected table found {}", entity_desc(actual)),
-        },
-        EntityType::Function(expected) => match actual {
-            EntityType::Function(actual) => {
-                let expected = &expected_types[*expected];
-                let actual = &actual_types[*actual];
-                if expected == actual {
-                    Ok(())
-                } else {
-                    Err(func_ty_mismatch(
-                        "function types incompaible",
-                        expected,
-                        actual,
-                    ))
-                }
-            }
-            _ => bail!("expected func found {}", entity_desc(actual)),
-        },
-        EntityType::Tag(_) => unimplemented!(),
-    }
-}
-
-fn func_ty_mismatch(msg: &str, expected: &WasmFuncType, actual: &WasmFuncType) -> anyhow::Error {
-    let render = |ty: &WasmFuncType| {
-        let params = ty
-            .params()
-            .iter()
-            .map(|s| s.to_string())
-            .collect::<Vec<_>>()
-            .join(", ");
-        let returns = ty
-            .returns()
-            .iter()
-            .map(|s| s.to_string())
-            .collect::<Vec<_>>()
-            .join(", ");
-        format!("`({}) -> ({})`", params, returns)
-    };
-    anyhow!(
-        "{msg}: expected func of type {}, found func of type {}",
-        render(expected),
-        render(actual)
-    )
-}
-
-fn global_ty(expected: &Global, actual: &Global) -> Result<()> {
-    // Subtyping is only sound on immutable global
-    // references. Therefore if either type is mutable we perform a
-    // strict equality check on the types.
-    if expected.mutability || actual.mutability {
-        equal_ty(expected.wasm_ty, actual.wasm_ty, "global")?;
-    } else {
-        match_ty(expected.wasm_ty, actual.wasm_ty, "global")?;
-    }
-    match_bool(
-        expected.mutability,
-        actual.mutability,
-        "global",
-        "mutable",
-        "immutable",
-    )?;
-    Ok(())
-}
-
-fn table_ty(expected: &Table, actual: &Table, actual_runtime_size: Option<u32>) -> Result<()> {
-    equal_ty(
-        WasmType::Ref(expected.wasm_ty),
-        WasmType::Ref(actual.wasm_ty),
-        "table",
-    )?;
-    match_limits(
-        expected.minimum.into(),
-        expected.maximum.map(|i| i.into()),
-        actual_runtime_size.unwrap_or(actual.minimum).into(),
-        actual.maximum.map(|i| i.into()),
-        "table",
-    )?;
-    Ok(())
-}
-
-fn memory_ty(expected: &Memory, actual: &Memory, actual_runtime_size: Option<u64>) -> Result<()> {
-    match_bool(
-        expected.shared,
-        actual.shared,
-        "memory",
-        "shared",
-        "non-shared",
-    )?;
-    match_bool(
-        expected.memory64,
-        actual.memory64,
-        "memory",
-        "64-bit",
-        "32-bit",
-    )?;
-    match_limits(
-        expected.minimum,
-        expected.maximum,
-        actual_runtime_size.unwrap_or(actual.minimum),
-        actual.maximum,
-        "memory",
-    )?;
-    Ok(())
-}
-
-fn match_heap(expected: WasmHeapType, actual: WasmHeapType, desc: &str) -> Result<()> {
-    let result = match (actual, expected) {
-        (WasmHeapType::TypedFunc(actual), WasmHeapType::TypedFunc(expected)) => {
-            // TODO(dhil): we need either canonicalised types or a context here.
-            actual == expected
-        }
-        (WasmHeapType::TypedFunc(_), WasmHeapType::Func)
-        | (WasmHeapType::Func, WasmHeapType::Func)
-        | (WasmHeapType::Extern, WasmHeapType::Extern) => true,
-        (WasmHeapType::Func, _) | (WasmHeapType::Extern, _) | (WasmHeapType::TypedFunc(_), _) => {
-            false
-        }
-    };
-    if result {
-        Ok(())
-    } else {
-        bail!(
-            "{} types incompatible: expected {0} of type `{}`, found {0} of type `{}`",
-            desc,
-            expected,
-            actual,
-        )
-    }
-}
-
-fn match_ref(expected: WasmRefType, actual: WasmRefType, desc: &str) -> Result<()> {
-    if actual.nullable == expected.nullable || expected.nullable {
-        return match_heap(expected.heap_type, actual.heap_type, desc);
-    }
-    bail!(
-        "{} types incompatible: expected {0} of type `{}`, found {0} of type `{}`",
-        desc,
-        expected,
-        actual,
-    )
-}
-
-// Checks whether actual is a subtype of expected, i.e. `actual <: expected`
-// (note the parameters are given the other way around in code).
-fn match_ty(expected: WasmType, actual: WasmType, desc: &str) -> Result<()> {
-    match (actual, expected) {
-        (WasmType::Ref(actual), WasmType::Ref(expected)) => match_ref(expected, actual, desc),
-        (actual, expected) => equal_ty(expected, actual, desc),
-    }
-}
-
-fn equal_ty(expected: WasmType, actual: WasmType, desc: &str) -> Result<()> {
-    if expected == actual {
-        return Ok(());
-    }
-    bail!(
-        "{} types incompatible: expected {0} of type `{}`, found {0} of type `{}`",
-        desc,
-        expected,
-        actual,
-    )
-}
-
-fn match_bool(
-    expected: bool,
-    actual: bool,
-    desc: &str,
-    if_true: &str,
-    if_false: &str,
-) -> Result<()> {
-    if expected == actual {
-        return Ok(());
-    }
-    bail!(
-        "{} types incompatible: expected {} {0}, found {} {0}",
-        desc,
-        if expected { if_true } else { if_false },
-        if actual { if_true } else { if_false },
-    )
-}
-
-fn match_limits(
-    expected_min: u64,
-    expected_max: Option<u64>,
-    actual_min: u64,
-    actual_max: Option<u64>,
-    desc: &str,
-) -> Result<()> {
-    if expected_min <= actual_min
-        && match expected_max {
-            Some(expected) => match actual_max {
-                Some(actual) => expected >= actual,
-                None => false,
-            },
-            None => true,
-        }
-    {
-        return Ok(());
-    }
-    let limits = |min: u64, max: Option<u64>| {
-        format!(
-            "min: {}, max: {}",
-            min,
-            max.map(|s| s.to_string()).unwrap_or(String::from("none"))
-        )
-    };
-    bail!(
-        "{} types incompatible: expected {0} limits ({}) doesn't match provided {0} limits ({})",
-        desc,
-        limits(expected_min, expected_max),
-        limits(actual_min, actual_max)
-    )
-}
-
-fn entity_desc(ty: &EntityType) -> &'static str {
-    match ty {
-        EntityType::Global(_) => "global",
-        EntityType::Table(_) => "table",
-        EntityType::Memory(_) => "memory",
-        EntityType::Function(_) => "func",
-        EntityType::Tag(_) => "tag",
-    }
-}
diff --git a/crates/wasmtime/src/unix.rs b/crates/wasmtime/src/unix.rs
deleted file mode 100644
index f52895bea3ff..000000000000
--- a/crates/wasmtime/src/unix.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-//! Unix-specific extension for the `wasmtime` crate.
-//!
-//! This module is only available on Unix targets, for example Linux. Note that
-//! this module is notably not available on macOS or Windows.  Note that the
-//! import path for this module is `wasmtime::unix::...`, which is intended to
-//! emphasize that it is platform-specific.
-//!
-//! The traits contained in this module are intended to extend various types
-//! throughout the `wasmtime` crate with extra functionality that's only
-//! available on Unix.
-
-use crate::{AsContextMut, Store};
-
-/// Extensions for the [`Store`] type only available on Unix.
-pub trait StoreExt {
-    // TODO: needs more docs?
-    /// The signal handler must be
-    /// [async-signal-safe](http://man7.org/linux/man-pages/man7/signal-safety.7.html).
-    unsafe fn set_signal_handler<H>(&mut self, handler: H)
-    where
-        H: 'static
-            + Fn(libc::c_int, *const libc::siginfo_t, *const libc::c_void) -> bool
-            + Send
-            + Sync;
-}
-
-impl<T> StoreExt for Store<T> {
-    unsafe fn set_signal_handler<H>(&mut self, handler: H)
-    where
-        H: 'static
-            + Fn(libc::c_int, *const libc::siginfo_t, *const libc::c_void) -> bool
-            + Send
-            + Sync,
-    {
-        self.as_context_mut()
-            .0
-            .set_signal_handler(Some(Box::new(handler)));
-    }
-}
diff --git a/crates/wasmtime/src/v128.rs b/crates/wasmtime/src/v128.rs
deleted file mode 100644
index 25b48b1e368c..000000000000
--- a/crates/wasmtime/src/v128.rs
+++ /dev/null
@@ -1,151 +0,0 @@
-#![cfg_attr(
-    not(any(target_arch = "x86_64", target_arch = "aarch64")),
-    allow(unused_imports)
-)]
-
-use crate::store::StoreOpaque;
-use crate::{ValRaw, ValType, WasmTy};
-use std::cmp::Ordering;
-use std::fmt;
-
-/// Representation of a 128-bit vector type, `v128`, for WebAssembly.
-///
-/// This type corresponds to the `v128` type in WebAssembly and can be used with
-/// the [`TypedFunc`] API for example. This is additionally
-/// the payload of [`Val::V128`](crate::Val).
-///
-/// # Platform specifics
-///
-/// This type can currently only be used on x86_64 and AArch64 with the
-/// [`TypedFunc`] API. Rust does not have stable support on other platforms for
-/// this type so invoking functions with `v128` parameters requires the
-/// [`Func::call`](crate::Func::call) API (or perhaps
-/// [`Func::call_unchecked`](crate::Func::call_unchecked).
-///
-/// [`TypedFunc`]: crate::TypedFunc
-#[derive(Copy, Clone)]
-#[repr(transparent)]
-pub struct V128(Abi);
-
-// NB: this is why this type is only suitable with `TypedFunc` on some platforms
-// and no other. See the documentation for each platform for why each ABI is
-// chosen.
-cfg_if::cfg_if! {
-    if #[cfg(target_arch = "x86_64")] {
-        // x86 vectors are represented with XMM registers which are represented
-        // with the `__m128i` type. This type is considered a vector type for
-        // ABI purposes which is implemented by Cranelift.
-        type Abi = std::arch::x86_64::__m128i;
-    } else if #[cfg(target_arch = "aarch64")] {
-        // AArch64 uses vector registered which here is used with a vector type.
-        // Note that the specific type shouldn't matter too much but the choice
-        // of using a vector is the significant part.
-        type Abi = std::arch::aarch64::uint8x16_t;
-    } else if #[cfg(target_arch = "riscv64")] {
-        // RISC-V currently always passes all vector arguments indirectly in the
-        // ABI. Currently Rust has no stable means of representing this meaning
-        // that a 128-bit representation is chosen here but it can't be passed
-        // directly to WebAssembly, for example, and must instead be passed
-        // through an array-call trampoline.
-        type Abi = u128;
-    } else if #[cfg(target_arch = "s390x")] {
-        // Currently Rust has no stable means of representing vector registers
-        // so like RISC-V at this time this uses a bland 128-bit representation.
-        type Abi = u128;
-    } else {
-        compile_error!("unsupported platform");
-    }
-}
-
-union Reinterpret {
-    abi: Abi,
-    u128: u128,
-}
-
-impl V128 {
-    /// Returns the representation of this `v128` as a 128-bit integer in Rust.
-    pub fn as_u128(&self) -> u128 {
-        unsafe { Reinterpret { abi: self.0 }.u128 }
-    }
-}
-
-/// Primary constructor of a `V128` type.
-impl From<u128> for V128 {
-    fn from(val: u128) -> V128 {
-        unsafe { V128(Reinterpret { u128: val }.abi) }
-    }
-}
-
-impl From<V128> for u128 {
-    fn from(val: V128) -> u128 {
-        val.as_u128()
-    }
-}
-
-impl fmt::Debug for V128 {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.as_u128().fmt(f)
-    }
-}
-
-impl PartialEq for V128 {
-    fn eq(&self, other: &V128) -> bool {
-        self.as_u128() == other.as_u128()
-    }
-}
-
-impl Eq for V128 {}
-
-impl PartialOrd for V128 {
-    fn partial_cmp(&self, other: &V128) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Ord for V128 {
-    fn cmp(&self, other: &V128) -> Ordering {
-        self.as_u128().cmp(&other.as_u128())
-    }
-}
-
-// Note that this trait is conditionally implemented which is intentional. See
-// the documentation above in the `cfg_if!` for why this is conditional.
-#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
-unsafe impl WasmTy for V128 {
-    type Abi = Abi;
-
-    #[inline]
-    fn valtype() -> ValType {
-        ValType::V128
-    }
-
-    #[inline]
-    fn compatible_with_store(&self, _: &StoreOpaque) -> bool {
-        true
-    }
-
-    #[inline]
-    fn is_externref(&self) -> bool {
-        false
-    }
-
-    #[inline]
-    unsafe fn abi_from_raw(raw: *mut ValRaw) -> Self::Abi {
-        V128::from((*raw).get_v128()).0
-    }
-
-    #[inline]
-    unsafe fn abi_into_raw(abi: Self::Abi, raw: *mut ValRaw) {
-        *raw = ValRaw::v128(V128(abi).as_u128());
-    }
-
-    #[inline]
-    fn into_abi(self, _store: &mut StoreOpaque) -> Self::Abi {
-        self.0
-    }
-
-    #[inline]
-    unsafe fn from_abi(abi: Self::Abi, _store: &mut StoreOpaque) -> Self {
-        V128(abi)
-    }
-}
diff --git a/crates/wasmtime/src/values.rs b/crates/wasmtime/src/values.rs
deleted file mode 100644
index d5605e962dda..000000000000
--- a/crates/wasmtime/src/values.rs
+++ /dev/null
@@ -1,295 +0,0 @@
-use crate::r#ref::ExternRef;
-use crate::store::StoreOpaque;
-use crate::{AsContextMut, Func, ValType, V128};
-use anyhow::{bail, Result};
-use std::ptr;
-use wasmtime_runtime::TableElement;
-
-pub use wasmtime_runtime::ValRaw;
-
-/// Possible runtime values that a WebAssembly module can either consume or
-/// produce.
-#[derive(Debug, Clone)]
-pub enum Val {
-    // NB: the ordering here is intended to match the ordering in
-    // `ValType` to improve codegen when learning the type of a value.
-    /// A 32-bit integer
-    I32(i32),
-
-    /// A 64-bit integer
-    I64(i64),
-
-    /// A 32-bit float.
-    ///
-    /// Note that the raw bits of the float are stored here, and you can use
-    /// `f32::from_bits` to create an `f32` value.
-    F32(u32),
-
-    /// A 64-bit float.
-    ///
-    /// Note that the raw bits of the float are stored here, and you can use
-    /// `f64::from_bits` to create an `f64` value.
-    F64(u64),
-
-    /// A 128-bit number
-    V128(V128),
-
-    /// A first-class reference to a WebAssembly function.
-    ///
-    /// `FuncRef(None)` is the null function reference, created by `ref.null
-    /// func` in Wasm.
-    FuncRef(Option<Func>),
-
-    /// An `externref` value which can hold opaque data to the Wasm instance
-    /// itself.
-    ///
-    /// `ExternRef(None)` is the null external reference, created by `ref.null
-    /// extern` in Wasm.
-    ExternRef(Option<ExternRef>),
-}
-
-macro_rules! accessors {
-    ($bind:ident $(($variant:ident($ty:ty) $get:ident $unwrap:ident $cvt:expr))*) => ($(
-        /// Attempt to access the underlying value of this `Val`, returning
-        /// `None` if it is not the correct type.
-        #[inline]
-        pub fn $get(&self) -> Option<$ty> {
-            if let Val::$variant($bind) = self {
-                Some($cvt)
-            } else {
-                None
-            }
-        }
-
-        /// Returns the underlying value of this `Val`, panicking if it's the
-        /// wrong type.
-        ///
-        /// # Panics
-        ///
-        /// Panics if `self` is not of the right type.
-        #[inline]
-        pub fn $unwrap(&self) -> $ty {
-            self.$get().expect(concat!("expected ", stringify!($ty)))
-        }
-    )*)
-}
-
-impl Val {
-    /// Returns a null `externref` value.
-    #[inline]
-    pub fn null() -> Val {
-        Val::ExternRef(None)
-    }
-
-    /// Returns the corresponding [`ValType`] for this `Val`.
-    #[inline]
-    pub fn ty(&self) -> ValType {
-        match self {
-            Val::I32(_) => ValType::I32,
-            Val::I64(_) => ValType::I64,
-            Val::F32(_) => ValType::F32,
-            Val::F64(_) => ValType::F64,
-            Val::ExternRef(_) => ValType::ExternRef,
-            Val::FuncRef(_) => ValType::FuncRef,
-            Val::V128(_) => ValType::V128,
-        }
-    }
-
-    /// Convenience method to convert this [`Val`] into a [`ValRaw`].
-    ///
-    /// # Unsafety
-    ///
-    /// This method is unsafe for the reasons that [`ExternRef::to_raw`] and
-    /// [`Func::to_raw`] are unsafe.
-    pub unsafe fn to_raw(&self, store: impl AsContextMut) -> ValRaw {
-        match self {
-            Val::I32(i) => ValRaw::i32(*i),
-            Val::I64(i) => ValRaw::i64(*i),
-            Val::F32(u) => ValRaw::f32(*u),
-            Val::F64(u) => ValRaw::f64(*u),
-            Val::V128(b) => ValRaw::v128(b.as_u128()),
-            Val::ExternRef(e) => {
-                let externref = match e {
-                    Some(e) => e.to_raw(store),
-                    None => ptr::null_mut(),
-                };
-                ValRaw::externref(externref)
-            }
-            Val::FuncRef(f) => {
-                let funcref = match f {
-                    Some(f) => f.to_raw(store),
-                    None => ptr::null_mut(),
-                };
-                ValRaw::funcref(funcref)
-            }
-        }
-    }
-
-    /// Convenience method to convert a [`ValRaw`] into a [`Val`].
-    ///
-    /// # Unsafety
-    ///
-    /// This method is unsafe for the reasons that [`ExternRef::from_raw`] and
-    /// [`Func::from_raw`] are unsafe. Additionaly there's no guarantee
-    /// otherwise that `raw` should have the type `ty` specified.
-    pub unsafe fn from_raw(store: impl AsContextMut, raw: ValRaw, ty: ValType) -> Val {
-        match ty {
-            ValType::I32 => Val::I32(raw.get_i32()),
-            ValType::I64 => Val::I64(raw.get_i64()),
-            ValType::F32 => Val::F32(raw.get_f32()),
-            ValType::F64 => Val::F64(raw.get_f64()),
-            ValType::V128 => Val::V128(raw.get_v128().into()),
-            ValType::ExternRef => Val::ExternRef(ExternRef::from_raw(raw.get_externref())),
-            ValType::FuncRef => Val::FuncRef(Func::from_raw(store, raw.get_funcref())),
-        }
-    }
-
-    accessors! {
-        e
-        (I32(i32) i32 unwrap_i32 *e)
-        (I64(i64) i64 unwrap_i64 *e)
-        (F32(f32) f32 unwrap_f32 f32::from_bits(*e))
-        (F64(f64) f64 unwrap_f64 f64::from_bits(*e))
-        (FuncRef(Option<&Func>) funcref unwrap_funcref e.as_ref())
-        (V128(V128) v128 unwrap_v128 *e)
-    }
-
-    /// Attempt to access the underlying `externref` value of this `Val`.
-    ///
-    /// If this is not an `externref`, then `None` is returned.
-    ///
-    /// If this is a null `externref`, then `Some(None)` is returned.
-    ///
-    /// If this is a non-null `externref`, then `Some(Some(..))` is returned.
-    #[inline]
-    pub fn externref(&self) -> Option<Option<ExternRef>> {
-        match self {
-            Val::ExternRef(e) => Some(e.clone()),
-            _ => None,
-        }
-    }
-
-    /// Returns the underlying `externref` value of this `Val`, panicking if it's the
-    /// wrong type.
-    ///
-    /// If this is a null `externref`, then `None` is returned.
-    ///
-    /// If this is a non-null `externref`, then `Some(..)` is returned.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `self` is not a (nullable) `externref`.
-    #[inline]
-    pub fn unwrap_externref(&self) -> Option<ExternRef> {
-        self.externref().expect("expected externref")
-    }
-
-    pub(crate) fn into_table_element(
-        self,
-        store: &mut StoreOpaque,
-        ty: ValType,
-    ) -> Result<TableElement> {
-        match (self, ty) {
-            (Val::FuncRef(Some(f)), ValType::FuncRef) => {
-                if !f.comes_from_same_store(store) {
-                    bail!("cross-`Store` values are not supported in tables");
-                }
-                Ok(TableElement::FuncRef(f.vm_func_ref(store).as_ptr()))
-            }
-            (Val::FuncRef(None), ValType::FuncRef) => Ok(TableElement::FuncRef(ptr::null_mut())),
-            (Val::ExternRef(Some(x)), ValType::ExternRef) => {
-                Ok(TableElement::ExternRef(Some(x.inner)))
-            }
-            (Val::ExternRef(None), ValType::ExternRef) => Ok(TableElement::ExternRef(None)),
-            _ => bail!("value does not match table element type"),
-        }
-    }
-
-    #[inline]
-    pub(crate) fn comes_from_same_store(&self, store: &StoreOpaque) -> bool {
-        match self {
-            Val::FuncRef(Some(f)) => f.comes_from_same_store(store),
-            Val::FuncRef(None) => true,
-
-            // Integers, floats, vectors, and `externref`s have no association
-            // with any particular store, so they're always considered as "yes I
-            // came from that store",
-            Val::I32(_)
-            | Val::I64(_)
-            | Val::F32(_)
-            | Val::F64(_)
-            | Val::V128(_)
-            | Val::ExternRef(_) => true,
-        }
-    }
-}
-
-impl From<i32> for Val {
-    #[inline]
-    fn from(val: i32) -> Val {
-        Val::I32(val)
-    }
-}
-
-impl From<i64> for Val {
-    #[inline]
-    fn from(val: i64) -> Val {
-        Val::I64(val)
-    }
-}
-
-impl From<f32> for Val {
-    #[inline]
-    fn from(val: f32) -> Val {
-        Val::F32(val.to_bits())
-    }
-}
-
-impl From<f64> for Val {
-    #[inline]
-    fn from(val: f64) -> Val {
-        Val::F64(val.to_bits())
-    }
-}
-
-impl From<ExternRef> for Val {
-    #[inline]
-    fn from(val: ExternRef) -> Val {
-        Val::ExternRef(Some(val))
-    }
-}
-
-impl From<Option<ExternRef>> for Val {
-    #[inline]
-    fn from(val: Option<ExternRef>) -> Val {
-        Val::ExternRef(val)
-    }
-}
-
-impl From<Option<Func>> for Val {
-    #[inline]
-    fn from(val: Option<Func>) -> Val {
-        Val::FuncRef(val)
-    }
-}
-
-impl From<Func> for Val {
-    #[inline]
-    fn from(val: Func) -> Val {
-        Val::FuncRef(Some(val))
-    }
-}
-
-impl From<u128> for Val {
-    #[inline]
-    fn from(val: u128) -> Val {
-        Val::V128(val.into())
-    }
-}
-
-impl From<V128> for Val {
-    #[inline]
-    fn from(val: V128) -> Val {
-        Val::V128(val)
-    }
-}
diff --git a/crates/wasmtime/src/windows.rs b/crates/wasmtime/src/windows.rs
deleted file mode 100644
index e746d3a813ab..000000000000
--- a/crates/wasmtime/src/windows.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-//! windows-specific extension for the `wasmtime` crate.
-//!
-//! This module is only available on Windows targets.
-//! It is not available on Linux or macOS, for example. Note that the import path for
-//! this module is `wasmtime::windows::...`, which is intended to emphasize that it
-//! is platform-specific.
-//!
-//! The traits contained in this module are intended to extend various types
-//! throughout the `wasmtime` crate with extra functionality that's only
-//! available on Windows.
-
-use crate::{AsContextMut, Store};
-use windows_sys::Win32::System::Diagnostics::Debug::EXCEPTION_POINTERS;
-
-/// Extensions for the [`Store`] type only available on Windows.
-pub trait StoreExt {
-    /// Configures a custom signal handler to execute.
-    ///
-    /// TODO: needs more documentation.
-    unsafe fn set_signal_handler<H>(&mut self, handler: H)
-    where
-        H: 'static + Fn(*mut EXCEPTION_POINTERS) -> bool + Send + Sync;
-}
-
-impl<T> StoreExt for Store<T> {
-    unsafe fn set_signal_handler<H>(&mut self, handler: H)
-    where
-        H: 'static + Fn(*mut EXCEPTION_POINTERS) -> bool + Send + Sync,
-    {
-        self.as_context_mut()
-            .0
-            .set_signal_handler(Some(Box::new(handler)));
-    }
-}
diff --git a/crates/wast/Cargo.toml b/crates/wast/Cargo.toml
index 24b690427cc6..599cfae1cdd1 100644
--- a/crates/wast/Cargo.toml
+++ b/crates/wast/Cargo.toml
@@ -8,10 +8,14 @@ categories = ["wasm"]
 keywords = ["webassembly", "wasm"]
 repository = "https://github.com/bytecodealliance/wasmtime"
 edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
 
 [dependencies]
 anyhow = { workspace = true }
-wasmtime = { workspace = true, features = ['cranelift'] }
+wasmtime = { workspace = true, features = ['cranelift', 'wat', 'runtime', 'gc'] }
 wast = { workspace = true }
 log = { workspace = true }
 
diff --git a/crates/wast/src/component.rs b/crates/wast/src/component.rs
index 2ce11c8651d1..8a7f19dc08d0 100644
--- a/crates/wast/src/component.rs
+++ b/crates/wast/src/component.rs
@@ -1,13 +1,13 @@
 use crate::core;
-use anyhow::{anyhow, bail, Context, Result};
-use std::collections::{BTreeSet, HashMap};
+use anyhow::{bail, Context, Result};
+use std::collections::BTreeSet;
 use std::fmt::Debug;
 use wast::component::WastVal;
 use wast::core::NanPattern;
 
 pub use wasmtime::component::*;
 
-pub fn val(v: &WastVal<'_>, ty: &Type) -> Result<Val> {
+pub fn val(v: &WastVal<'_>) -> Result<Val> {
     Ok(match v {
         WastVal::Bool(b) => Val::Bool(*b),
         WastVal::U8(b) => Val::U8(*b),
@@ -18,108 +18,48 @@ pub fn val(v: &WastVal<'_>, ty: &Type) -> Result<Val> {
         WastVal::S32(b) => Val::S32(*b),
         WastVal::U64(b) => Val::U64(*b),
         WastVal::S64(b) => Val::S64(*b),
-        WastVal::Float32(b) => Val::Float32(f32::from_bits(b.bits)),
-        WastVal::Float64(b) => Val::Float64(f64::from_bits(b.bits)),
+        WastVal::F32(b) => Val::Float32(f32::from_bits(b.bits)),
+        WastVal::F64(b) => Val::Float64(f64::from_bits(b.bits)),
         WastVal::Char(b) => Val::Char(*b),
         WastVal::String(s) => Val::String(s.to_string().into()),
-        WastVal::List(vals) => match ty {
-            Type::List(t) => {
-                let element = t.ty();
-                let vals = vals
-                    .iter()
-                    .map(|v| val(v, &element))
-                    .collect::<Result<Vec<_>>>()?;
-                t.new_val(vals.into())?
-            }
-            _ => bail!("expected a list value"),
-        },
-        WastVal::Record(fields) => match ty {
-            Type::Record(t) => {
-                let mut fields_by_name = HashMap::new();
-                for (name, val) in fields {
-                    let prev = fields_by_name.insert(*name, val);
-                    if prev.is_some() {
-                        bail!("field `{name}` specified twice");
-                    }
-                }
-                let mut values = Vec::new();
-                for field in t.fields() {
-                    let name = field.name;
-                    let v = fields_by_name
-                        .remove(name)
-                        .ok_or_else(|| anyhow!("field `{name}` not specified"))?;
-                    values.push((name, val(v, &field.ty)?));
-                }
-                if let Some((field, _)) = fields_by_name.iter().next() {
-                    bail!("extra field `{field}` specified");
-                }
-                t.new_val(values)?
-            }
-            _ => bail!("expected a record value"),
-        },
-        WastVal::Tuple(vals) => match ty {
-            Type::Tuple(t) => {
-                if vals.len() != t.types().len() {
-                    bail!("expected {} values got {}", t.types().len(), vals.len());
-                }
-                t.new_val(
-                    vals.iter()
-                        .zip(t.types())
-                        .map(|(v, ty)| val(v, &ty))
-                        .collect::<Result<Vec<_>>>()?
-                        .into(),
-                )?
-            }
-            _ => bail!("expected a tuple value"),
-        },
-        WastVal::Enum(name) => match ty {
-            Type::Enum(t) => t.new_val(name)?,
-            _ => bail!("expected an enum value"),
-        },
-        WastVal::Variant(name, payload) => match ty {
-            Type::Variant(t) => {
-                let case = match t.cases().find(|c| c.name == *name) {
-                    Some(case) => case,
-                    None => bail!("no case named `{}", name),
-                };
-                let payload = payload_val(case.name, payload.as_deref(), case.ty.as_ref())?;
-                t.new_val(name, payload)?
-            }
-            _ => bail!("expected a variant value"),
-        },
-        WastVal::Option(v) => match ty {
-            Type::Option(t) => {
-                let v = match v {
-                    Some(v) => Some(val(v, &t.ty())?),
-                    None => None,
-                };
-                t.new_val(v)?
-            }
-            _ => bail!("expected an option value"),
-        },
-        WastVal::Result(v) => match ty {
-            Type::Result(t) => {
-                let v = match v {
-                    Ok(v) => Ok(payload_val("ok", v.as_deref(), t.ok().as_ref())?),
-                    Err(v) => Err(payload_val("err", v.as_deref(), t.err().as_ref())?),
-                };
-                t.new_val(v)?
+        WastVal::List(vals) => {
+            let vals = vals.iter().map(|v| val(v)).collect::<Result<Vec<_>>>()?;
+            Val::List(vals.into())
+        }
+        WastVal::Record(vals) => {
+            let mut fields = Vec::new();
+            for (name, v) in vals {
+                fields.push((name.to_string(), val(v)?));
             }
-            _ => bail!("expected an expected value"),
-        },
-        WastVal::Flags(v) => match ty {
-            Type::Flags(t) => t.new_val(v)?,
-            _ => bail!("expected a flags value"),
-        },
+            Val::Record(fields.into())
+        }
+        WastVal::Tuple(vals) => Val::Tuple(
+            vals.iter()
+                .map(|v| val(v))
+                .collect::<Result<Vec<_>>>()?
+                .into(),
+        ),
+        WastVal::Enum(name) => Val::Enum(name.to_string()),
+        WastVal::Variant(name, payload) => {
+            let payload = payload_val(payload.as_deref())?;
+            Val::Variant(name.to_string(), payload)
+        }
+        WastVal::Option(v) => Val::Option(match v {
+            Some(v) => Some(Box::new(val(v)?)),
+            None => None,
+        }),
+        WastVal::Result(v) => Val::Result(match v {
+            Ok(v) => Ok(payload_val(v.as_deref())?),
+            Err(v) => Err(payload_val(v.as_deref())?),
+        }),
+        WastVal::Flags(v) => Val::Flags(v.iter().map(|s| s.to_string()).collect()),
     })
 }
 
-fn payload_val(name: &str, v: Option<&WastVal<'_>>, ty: Option<&Type>) -> Result<Option<Val>> {
-    match (v, ty) {
-        (Some(v), Some(ty)) => Ok(Some(val(v, ty)?)),
-        (None, None) => Ok(None),
-        (Some(_), None) => bail!("expected payload for case `{name}`"),
-        (None, Some(_)) => bail!("unexpected payload for case `{name}`"),
+fn payload_val(v: Option<&WastVal<'_>>) -> Result<Option<Box<Val>>> {
+    match v {
+        Some(v) => Ok(Some(Box::new(val(v)?))),
+        None => Ok(None),
     }
 }
 
@@ -161,11 +101,11 @@ pub fn match_val(expected: &WastVal<'_>, actual: &Val) -> Result<()> {
             Val::S64(a) => core::match_int(a, e),
             _ => mismatch(expected, actual),
         },
-        WastVal::Float32(e) => match actual {
+        WastVal::F32(e) => match actual {
             Val::Float32(a) => core::match_f32(a.to_bits(), &NanPattern::Value(*e)),
             _ => mismatch(expected, actual),
         },
-        WastVal::Float64(e) => match actual {
+        WastVal::F64(e) => match actual {
             Val::Float64(a) => core::match_f64(a.to_bits(), &NanPattern::Value(*e)),
             _ => mismatch(expected, actual),
         },
@@ -192,22 +132,15 @@ pub fn match_val(expected: &WastVal<'_>, actual: &Val) -> Result<()> {
         },
         WastVal::Record(e) => match actual {
             Val::Record(a) => {
-                let mut fields_by_name = HashMap::new();
-                for (name, val) in e {
-                    let prev = fields_by_name.insert(*name, val);
-                    if prev.is_some() {
-                        bail!("field `{name}` specified twice");
-                    }
-                }
-                for (name, actual) in a.fields() {
-                    let expected = fields_by_name
-                        .remove(name)
-                        .ok_or_else(|| anyhow!("field `{name}` not specified"))?;
-                    match_val(expected, actual)
-                        .with_context(|| format!("failed to match field `{name}`"))?;
+                if e.len() != e.len() {
+                    bail!("mismatched number of record fields");
                 }
-                if let Some((field, _)) = fields_by_name.iter().next() {
-                    bail!("extra field `{field}` specified");
+                for ((e_name, e_val), (a_name, a_val)) in e.iter().zip(a.iter()) {
+                    if e_name != a_name {
+                        bail!("expected field `{e_name}` got `{a_name}`");
+                    }
+                    match_val(e_val, a_val)
+                        .with_context(|| format!("failed to match field `{e_name}`"))?;
                 }
                 Ok(())
             }
@@ -215,14 +148,10 @@ pub fn match_val(expected: &WastVal<'_>, actual: &Val) -> Result<()> {
         },
         WastVal::Tuple(e) => match actual {
             Val::Tuple(a) => {
-                if e.len() != a.values().len() {
-                    bail!(
-                        "expected {}-tuple, found {}-tuple",
-                        e.len(),
-                        a.values().len()
-                    );
+                if e.len() != a.len() {
+                    bail!("expected {}-tuple, found {}-tuple", e.len(), a.len());
                 }
-                for (i, (expected, actual)) in e.iter().zip(a.values()).enumerate() {
+                for (i, (expected, actual)) in e.iter().zip(a.iter()).enumerate() {
                     match_val(expected, actual)
                         .with_context(|| format!("failed to match tuple element {i}"))?;
                 }
@@ -231,18 +160,18 @@ pub fn match_val(expected: &WastVal<'_>, actual: &Val) -> Result<()> {
             _ => mismatch(expected, actual),
         },
         WastVal::Variant(name, e) => match actual {
-            Val::Variant(a) => {
-                if a.discriminant() != *name {
-                    bail!("expected discriminant `{name}` got `{}`", a.discriminant());
+            Val::Variant(discr, payload) => {
+                if *discr != *name {
+                    bail!("expected discriminant `{name}` got `{discr}`");
                 }
-                match_payload_val(name, e.as_deref(), a.payload())
+                match_payload_val(name, e.as_deref(), payload.as_deref())
             }
             _ => mismatch(expected, actual),
         },
         WastVal::Enum(name) => match actual {
             Val::Enum(a) => {
-                if a.discriminant() != *name {
-                    bail!("expected discriminant `{name}` got `{}`", a.discriminant());
+                if *a != *name {
+                    bail!("expected discriminant `{name}` got `{a}`");
                 } else {
                     Ok(())
                 }
@@ -250,7 +179,7 @@ pub fn match_val(expected: &WastVal<'_>, actual: &Val) -> Result<()> {
             _ => mismatch(expected, actual),
         },
         WastVal::Option(e) => match actual {
-            Val::Option(a) => match (e, a.value()) {
+            Val::Option(a) => match (e, a) {
                 (None, None) => Ok(()),
                 (Some(expected), Some(actual)) => match_val(expected, actual),
                 (None, Some(_)) => bail!("expected `none`, found `some`"),
@@ -259,18 +188,18 @@ pub fn match_val(expected: &WastVal<'_>, actual: &Val) -> Result<()> {
             _ => mismatch(expected, actual),
         },
         WastVal::Result(e) => match actual {
-            Val::Result(a) => match (e, a.value()) {
+            Val::Result(a) => match (e, a) {
                 (Ok(_), Err(_)) => bail!("expected `ok`, found `err`"),
                 (Err(_), Ok(_)) => bail!("expected `err`, found `ok`"),
-                (Err(e), Err(a)) => match_payload_val("err", e.as_deref(), a),
-                (Ok(e), Ok(a)) => match_payload_val("ok", e.as_deref(), a),
+                (Err(e), Err(a)) => match_payload_val("err", e.as_deref(), a.as_deref()),
+                (Ok(e), Ok(a)) => match_payload_val("ok", e.as_deref(), a.as_deref()),
             },
             _ => mismatch(expected, actual),
         },
         WastVal::Flags(e) => match actual {
             Val::Flags(a) => {
                 let expected = e.iter().copied().collect::<BTreeSet<_>>();
-                let actual = a.flags().collect::<BTreeSet<_>>();
+                let actual = a.iter().map(|s| s.as_str()).collect::<BTreeSet<_>>();
                 match_debug(&actual, &expected)
             }
             _ => mismatch(expected, actual),
@@ -319,8 +248,8 @@ fn mismatch(expected: &WastVal<'_>, actual: &Val) -> Result<()> {
         WastVal::S32(..) => "s32",
         WastVal::U64(..) => "u64",
         WastVal::S64(..) => "s64",
-        WastVal::Float32(..) => "float32",
-        WastVal::Float64(..) => "float64",
+        WastVal::F32(..) => "f32",
+        WastVal::F64(..) => "f64",
         WastVal::Char(..) => "char",
         WastVal::String(..) => "string",
         WastVal::List(..) => "list",
@@ -342,8 +271,8 @@ fn mismatch(expected: &WastVal<'_>, actual: &Val) -> Result<()> {
         Val::S32(..) => "s32",
         Val::U64(..) => "u64",
         Val::S64(..) => "s64",
-        Val::Float32(..) => "float32",
-        Val::Float64(..) => "float64",
+        Val::Float32(..) => "f32",
+        Val::Float64(..) => "f64",
         Val::Char(..) => "char",
         Val::String(..) => "string",
         Val::List(..) => "list",
diff --git a/crates/wast/src/core.rs b/crates/wast/src/core.rs
index de01b1023c9e..ea6fd75a4e7a 100644
--- a/crates/wast/src/core.rs
+++ b/crates/wast/src/core.rs
@@ -1,11 +1,11 @@
 use anyhow::{bail, Context, Result};
 use std::fmt::{Display, LowerHex};
-use wasmtime::{ExternRef, Val};
-use wast::core::{HeapType, NanPattern, V128Pattern, WastArgCore, WastRetCore};
-use wast::token::{Float32, Float64};
+use wasmtime::{ExternRef, Store, Val};
+use wast::core::{AbstractHeapType, HeapType, NanPattern, V128Pattern, WastArgCore, WastRetCore};
+use wast::token::{F32, F64};
 
 /// Translate from a `script::Value` to a `RuntimeValue`.
-pub fn val(v: &WastArgCore<'_>) -> Result<Val> {
+pub fn val<T>(store: &mut Store<T>, v: &WastArgCore<'_>) -> Result<Val> {
     use wast::core::WastArgCore::*;
 
     Ok(match v {
@@ -14,9 +14,15 @@ pub fn val(v: &WastArgCore<'_>) -> Result<Val> {
         F32(x) => Val::F32(x.bits),
         F64(x) => Val::F64(x.bits),
         V128(x) => Val::V128(u128::from_le_bytes(x.to_le_bytes()).into()),
-        RefNull(HeapType::Extern) => Val::ExternRef(None),
-        RefNull(HeapType::Func) => Val::FuncRef(None),
-        RefExtern(x) => Val::ExternRef(Some(ExternRef::new(*x))),
+        RefNull(HeapType::Abstract {
+            ty: AbstractHeapType::Extern,
+            shared: false,
+        }) => Val::ExternRef(None),
+        RefNull(HeapType::Abstract {
+            ty: AbstractHeapType::Func,
+            shared: false,
+        }) => Val::FuncRef(None),
+        RefExtern(x) => Val::ExternRef(Some(ExternRef::new(store, *x)?)),
         other => bail!("couldn't convert {:?} to a runtime value", other),
     })
 }
@@ -37,41 +43,59 @@ fn extract_lane_as_i64(bytes: u128, lane: usize) -> i64 {
     (bytes >> (lane * 64)) as i64
 }
 
-pub fn match_val(actual: &Val, expected: &WastRetCore) -> Result<()> {
+pub fn match_val<T>(store: &Store<T>, actual: &Val, expected: &WastRetCore) -> Result<()> {
     match (actual, expected) {
         (_, WastRetCore::Either(expected)) => {
             for expected in expected {
-                if match_val(actual, expected).is_ok() {
+                if match_val(store, actual, expected).is_ok() {
                     return Ok(());
                 }
             }
-            match_val(actual, &expected[0])
+            match_val(store, actual, &expected[0])
         }
+
         (Val::I32(a), WastRetCore::I32(b)) => match_int(a, b),
         (Val::I64(a), WastRetCore::I64(b)) => match_int(a, b),
+
         // Note that these float comparisons are comparing bits, not float
         // values, so we're testing for bit-for-bit equivalence
         (Val::F32(a), WastRetCore::F32(b)) => match_f32(*a, b),
         (Val::F64(a), WastRetCore::F64(b)) => match_f64(*a, b),
         (Val::V128(a), WastRetCore::V128(b)) => match_v128(a.as_u128(), b),
-        (Val::ExternRef(x), WastRetCore::RefNull(Some(HeapType::Extern))) => {
-            if let Some(x) = x {
-                let x = x
-                    .data()
-                    .downcast_ref::<u32>()
-                    .expect("only u32 externrefs created in wast test suites");
-                bail!("expected null externref, found {}", x);
-            } else {
-                Ok(())
-            }
-        }
-        (Val::ExternRef(_), WastRetCore::RefExtern(None)) => Ok(()),
+
+        // Null references.
+        (
+            Val::FuncRef(None) | Val::ExternRef(None) | Val::AnyRef(None),
+            WastRetCore::RefNull(_),
+        )
+        | (Val::ExternRef(None), WastRetCore::RefExtern(None)) => Ok(()),
+
+        // Null and non-null mismatches.
         (Val::ExternRef(None), WastRetCore::RefExtern(Some(_))) => {
-            bail!("expected non-null externref, found null")
+            bail!("expected non-null reference, found null")
         }
+        (
+            Val::ExternRef(Some(x)),
+            WastRetCore::RefNull(Some(HeapType::Abstract {
+                ty: AbstractHeapType::Extern,
+                shared: false,
+            })),
+        ) => {
+            let x = x
+                .data(store)?
+                .downcast_ref::<u32>()
+                .expect("only u32 externrefs created in wast test suites");
+            bail!("expected null externref, found non-null externref of {x}");
+        }
+        (Val::ExternRef(Some(_)) | Val::FuncRef(Some(_)), WastRetCore::RefNull(_)) => {
+            bail!("expected null, found non-null reference: {actual:?}")
+        }
+
+        // Non-null references.
+        (Val::FuncRef(Some(_)), WastRetCore::RefFunc(_)) => Ok(()),
         (Val::ExternRef(Some(x)), WastRetCore::RefExtern(Some(y))) => {
             let x = x
-                .data()
+                .data(store)?
                 .downcast_ref::<u32>()
                 .expect("only u32 externrefs created in wast test suites");
             if x == y {
@@ -80,19 +104,15 @@ pub fn match_val(actual: &Val, expected: &WastRetCore) -> Result<()> {
                 bail!("expected {} found {}", y, x);
             }
         }
-        (Val::FuncRef(actual), WastRetCore::RefNull(expected)) => match (actual, expected) {
-            (None, None) => Ok(()),
-            (None, Some(HeapType::Func)) => Ok(()),
-            (None, Some(_)) => bail!("expected null non-funcref, found null funcref"),
-            (Some(_), _) => bail!("expected null funcref, found non-null"),
-        },
-        (Val::FuncRef(x), WastRetCore::RefFunc(_)) => {
-            if x.is_none() {
-                bail!("expected non-null funcref, found null");
-            } else {
+
+        (Val::AnyRef(Some(x)), WastRetCore::RefI31) => {
+            if x.is_i31(store)? {
                 Ok(())
+            } else {
+                bail!("expected a `(ref i31)`, found {x:?}");
             }
         }
+
         _ => bail!(
             "don't know how to compare {:?} and {:?} yet",
             actual,
@@ -117,7 +137,7 @@ where
     }
 }
 
-pub fn match_f32(actual: u32, expected: &NanPattern<Float32>) -> Result<()> {
+pub fn match_f32(actual: u32, expected: &NanPattern<F32>) -> Result<()> {
     match expected {
         // Check if an f32 (as u32 bits to avoid possible quieting when moving values in registers, e.g.
         // https://developer.arm.com/documentation/ddi0344/i/neon-and-vfp-programmers-model/modes-of-operation/default-nan-mode?lang=en)
@@ -182,7 +202,7 @@ pub fn match_f32(actual: u32, expected: &NanPattern<Float32>) -> Result<()> {
     }
 }
 
-pub fn match_f64(actual: u64, expected: &NanPattern<Float64>) -> Result<()> {
+pub fn match_f64(actual: u64, expected: &NanPattern<F64>) -> Result<()> {
     match expected {
         // Check if an f64 (as u64 bits to avoid possible quieting when moving values in registers, e.g.
         // https://developer.arm.com/documentation/ddi0344/i/neon-and-vfp-programmers-model/modes-of-operation/default-nan-mode?lang=en)
@@ -345,14 +365,14 @@ fn match_v128(actual: u128, expected: &V128Pattern) -> Result<()> {
         V128Pattern::F32x4(expected) => {
             for (i, expected) in expected.iter().enumerate() {
                 let a = extract_lane_as_i32(actual, i) as u32;
-                match_f32(a, expected).with_context(|| format!("difference in lane {}", i))?;
+                match_f32(a, expected).with_context(|| format!("difference in lane {i}"))?;
             }
             Ok(())
         }
         V128Pattern::F64x2(expected) => {
             for (i, expected) in expected.iter().enumerate() {
                 let a = extract_lane_as_i64(actual, i) as u64;
-                match_f64(a, expected).with_context(|| format!("difference in lane {}", i))?;
+                match_f64(a, expected).with_context(|| format!("difference in lane {i}"))?;
             }
             Ok(())
         }
diff --git a/crates/wast/src/lib.rs b/crates/wast/src/lib.rs
index 96c076ca2602..d8749e6e1ec8 100644
--- a/crates/wast/src/lib.rs
+++ b/crates/wast/src/lib.rs
@@ -1,8 +1,6 @@
 //! Implementation of the WAST text format for wasmtime.
 
-#![deny(missing_docs, trivial_numeric_casts, unused_extern_crates)]
-#![warn(unused_import_braces)]
-#![deny(unstable_features)]
+#![deny(missing_docs)]
 
 #[cfg(feature = "component-model")]
 mod component;
@@ -10,7 +8,7 @@ mod core;
 mod spectest;
 mod wast;
 
-pub use crate::spectest::link_spectest;
+pub use crate::spectest::{link_spectest, SpectestConfig};
 pub use crate::wast::WastContext;
 
 /// Version number of this crate.
diff --git a/crates/wast/src/spectest.rs b/crates/wast/src/spectest.rs
index 17d49b7c294d..f69213af978a 100644
--- a/crates/wast/src/spectest.rs
+++ b/crates/wast/src/spectest.rs
@@ -1,25 +1,53 @@
-use anyhow::Result;
 use wasmtime::*;
 
+/// Configuration of how spectest primitives work.
+pub struct SpectestConfig {
+    /// Whether or not to have a `shared_memory` definition.
+    pub use_shared_memory: bool,
+    /// Whether or not spectest functions that print things actually print things.
+    pub suppress_prints: bool,
+}
+
 /// Return an instance implementing the "spectest" interface used in the
 /// spec testsuite.
 pub fn link_spectest<T>(
     linker: &mut Linker<T>,
     store: &mut Store<T>,
-    use_shared_memory: bool,
+    config: &SpectestConfig,
 ) -> Result<()> {
+    let suppress = config.suppress_prints;
     linker.func_wrap("spectest", "print", || {})?;
-    linker.func_wrap("spectest", "print_i32", |val: i32| println!("{}: i32", val))?;
-    linker.func_wrap("spectest", "print_i64", |val: i64| println!("{}: i64", val))?;
-    linker.func_wrap("spectest", "print_f32", |val: f32| println!("{}: f32", val))?;
-    linker.func_wrap("spectest", "print_f64", |val: f64| println!("{}: f64", val))?;
-    linker.func_wrap("spectest", "print_i32_f32", |i: i32, f: f32| {
-        println!("{}: i32", i);
-        println!("{}: f32", f);
+    linker.func_wrap("spectest", "print_i32", move |val: i32| {
+        if !suppress {
+            println!("{val}: i32")
+        }
+    })?;
+    linker.func_wrap("spectest", "print_i64", move |val: i64| {
+        if !suppress {
+            println!("{val}: i64")
+        }
+    })?;
+    linker.func_wrap("spectest", "print_f32", move |val: f32| {
+        if !suppress {
+            println!("{val}: f32")
+        }
+    })?;
+    linker.func_wrap("spectest", "print_f64", move |val: f64| {
+        if !suppress {
+            println!("{val}: f64")
+        }
+    })?;
+    linker.func_wrap("spectest", "print_i32_f32", move |i: i32, f: f32| {
+        if !suppress {
+            println!("{i}: i32");
+            println!("{f}: f32");
+        }
     })?;
-    linker.func_wrap("spectest", "print_f64_f64", |f1: f64, f2: f64| {
-        println!("{}: f64", f1);
-        println!("{}: f64", f2);
+    linker.func_wrap("spectest", "print_f64_f64", move |f1: f64, f2: f64| {
+        if !suppress {
+            println!("{f1}: f64");
+            println!("{f2}: f64");
+        }
     })?;
 
     let ty = GlobalType::new(ValType::I32, Mutability::Const);
@@ -31,22 +59,22 @@ pub fn link_spectest<T>(
     linker.define(&mut *store, "spectest", "global_i64", g)?;
 
     let ty = GlobalType::new(ValType::F32, Mutability::Const);
-    let g = Global::new(&mut *store, ty, Val::F32(0x4426_8000))?;
+    let g = Global::new(&mut *store, ty, Val::F32(0x4426_a666))?;
     linker.define(&mut *store, "spectest", "global_f32", g)?;
 
     let ty = GlobalType::new(ValType::F64, Mutability::Const);
-    let g = Global::new(&mut *store, ty, Val::F64(0x4084_d000_0000_0000))?;
+    let g = Global::new(&mut *store, ty, Val::F64(0x4084_d4cc_cccc_cccd))?;
     linker.define(&mut *store, "spectest", "global_f64", g)?;
 
-    let ty = TableType::new(ValType::FuncRef, 10, Some(20));
-    let table = Table::new(&mut *store, ty, Val::FuncRef(None))?;
+    let ty = TableType::new(RefType::FUNCREF, 10, Some(20));
+    let table = Table::new(&mut *store, ty, Ref::Func(None))?;
     linker.define(&mut *store, "spectest", "table", table)?;
 
     let ty = MemoryType::new(1, Some(2));
     let memory = Memory::new(&mut *store, ty)?;
     linker.define(&mut *store, "spectest", "memory", memory)?;
 
-    if use_shared_memory {
+    if config.use_shared_memory {
         let ty = MemoryType::shared(1, 1);
         let memory = Memory::new(&mut *store, ty)?;
         linker.define(&mut *store, "spectest", "shared_memory", memory)?;
@@ -59,7 +87,7 @@ pub fn link_spectest<T>(
 pub fn link_component_spectest<T>(linker: &mut component::Linker<T>) -> Result<()> {
     use std::sync::atomic::{AtomicU32, Ordering::SeqCst};
     use std::sync::Arc;
-    use wasmtime::component::Resource;
+    use wasmtime::component::{Resource, ResourceType};
 
     let engine = linker.engine().clone();
     linker
@@ -92,7 +120,7 @@ pub fn link_component_spectest<T>(linker: &mut component::Linker<T>) -> Result<(
 
     let state = Arc::new(ResourceState::default());
 
-    i.resource::<Resource1>("resource1", {
+    i.resource("resource1", ResourceType::host::<Resource1>(), {
         let state = state.clone();
         move |_, rep| {
             state.drops.fetch_add(1, SeqCst);
@@ -101,13 +129,21 @@ pub fn link_component_spectest<T>(linker: &mut component::Linker<T>) -> Result<(
             Ok(())
         }
     })?;
-    i.resource::<Resource2>("resource2", |_, _| Ok(()))?;
+    i.resource(
+        "resource2",
+        ResourceType::host::<Resource2>(),
+        |_, _| Ok(()),
+    )?;
     // Currently the embedder API requires redefining the resource destructor
     // here despite this being the same type as before, and fixing that is left
     // for a future refactoring.
-    i.resource::<Resource1>("resource1-again", |_, _| {
-        panic!("shouldn't be destroyed");
-    })?;
+    i.resource(
+        "resource1-again",
+        ResourceType::host::<Resource1>(),
+        |_, _| {
+            panic!("shouldn't be destroyed");
+        },
+    )?;
 
     i.func_wrap("[constructor]resource1", |_cx, (rep,): (u32,)| {
         Ok((Resource::<Resource1>::new_own(rep),))
diff --git a/crates/wast/src/wast.rs b/crates/wast/src/wast.rs
index 32d4cc2d02ee..d8b39b66794f 100644
--- a/crates/wast/src/wast.rs
+++ b/crates/wast/src/wast.rs
@@ -2,9 +2,11 @@
 use crate::component;
 use crate::core;
 use crate::spectest::*;
-use anyhow::{anyhow, bail, Context as _, Error, Result};
+use anyhow::{anyhow, bail, Context as _};
+use std::collections::HashMap;
 use std::path::Path;
 use std::str;
+use std::thread;
 use wasmtime::*;
 use wast::lexer::Lexer;
 use wast::parser::{self, ParseBuffer};
@@ -62,7 +64,10 @@ enum Export {
     Component(component::Func),
 }
 
-impl<T> WastContext<T> {
+impl<T> WastContext<T>
+where
+    T: Clone + Send + 'static,
+{
     /// Construct a new instance of `WastContext`.
     pub fn new(store: Store<T>) -> Self {
         // Spec tests will redefine the same module/name sometimes, so we need
@@ -120,20 +125,26 @@ impl<T> WastContext<T> {
     }
 
     #[cfg(feature = "component-model")]
-    fn instantiate_component(&mut self, module: &[u8]) -> Result<Outcome<component::Instance>> {
+    fn instantiate_component(
+        &mut self,
+        component: &[u8],
+    ) -> Result<Outcome<(component::Component, component::Instance)>> {
         let engine = self.store.engine();
-        let module = component::Component::new(engine, module)?;
+        let component = component::Component::new(engine, component)?;
         Ok(
-            match self.component_linker.instantiate(&mut self.store, &module) {
-                Ok(i) => Outcome::Ok(i),
+            match self
+                .component_linker
+                .instantiate(&mut self.store, &component)
+            {
+                Ok(i) => Outcome::Ok((component, i)),
                 Err(e) => Outcome::Trap(e),
             },
         )
     }
 
     /// Register "spectest" which is used by the spec testsuite.
-    pub fn register_spectest(&mut self, use_shared_memory: bool) -> Result<()> {
-        link_spectest(&mut self.core_linker, &mut self.store, use_shared_memory)?;
+    pub fn register_spectest(&mut self, config: &SpectestConfig) -> Result<()> {
+        link_spectest(&mut self.core_linker, &mut self.store, config)?;
         #[cfg(feature = "component-model")]
         link_component_spectest(&mut self.component_linker)?;
         Ok(())
@@ -154,7 +165,7 @@ impl<T> WastContext<T> {
                 #[cfg(not(feature = "component-model"))]
                 Wat::Component(_) => bail!("component-model support not enabled"),
             }),
-            WastExecute::Get { module, global } => self.get(module.map(|s| s.name()), global),
+            WastExecute::Get { module, global, .. } => self.get(module.map(|s| s.name()), global),
         }
     }
 
@@ -168,12 +179,12 @@ impl<T> WastContext<T> {
                     .args
                     .iter()
                     .map(|v| match v {
-                        WastArg::Core(v) => core::val(v),
+                        WastArg::Core(v) => core::val(&mut self.store, v),
                         WastArg::Component(_) => bail!("expected component function, found core"),
                     })
                     .collect::<Result<Vec<_>>>()?;
 
-                let mut results = vec![Val::null(); func.ty(&self.store).results().len()];
+                let mut results = vec![Val::null_func_ref(); func.ty(&self.store).results().len()];
                 Ok(match func.call(&mut self.store, &values, &mut results) {
                     Ok(()) => Outcome::Ok(Results::Core(results.into())),
                     Err(e) => Outcome::Trap(e),
@@ -181,16 +192,11 @@ impl<T> WastContext<T> {
             }
             #[cfg(feature = "component-model")]
             Export::Component(func) => {
-                let params = func.params(&self.store);
-                if exec.args.len() != params.len() {
-                    bail!("mismatched number of parameters")
-                }
                 let values = exec
                     .args
                     .iter()
-                    .zip(params.iter())
-                    .map(|(v, t)| match v {
-                        WastArg::Component(v) => component::val(v, t),
+                    .map(|v| match v {
+                        WastArg::Component(v) => component::val(v),
                         WastArg::Core(_) => bail!("expected core function, found component"),
                     })
                     .collect::<Result<Vec<_>>>()?;
@@ -230,19 +236,28 @@ impl<T> WastContext<T> {
         } else {
             #[cfg(feature = "component-model")]
             {
-                let instance = match self.instantiate_component(&bytes)? {
+                let (component, instance) = match self.instantiate_component(&bytes)? {
                     Outcome::Ok(i) => i,
                     Outcome::Trap(e) => return Err(e).context("instantiation failed"),
                 };
                 if let Some(name) = name {
-                    // TODO: should ideally reflect more than just modules into
-                    // the linker's namespace but that's not easily supported
-                    // today for host functions due to the inability to take a
-                    // function from one instance and put it into the linker
-                    // (must go through the host right now).
+                    let ty = component.component_type();
                     let mut linker = self.component_linker.instance(name.name())?;
-                    for (name, module) in instance.exports(&mut self.store).root().modules() {
-                        linker.module(name, module)?;
+                    let engine = self.store.engine().clone();
+                    for (name, item) in ty.exports(&engine) {
+                        match item {
+                            component::types::ComponentItem::Module(_) => {
+                                let module = instance.get_module(&mut self.store, name).unwrap();
+                                linker.module(name, &module)?;
+                            }
+                            // TODO: should ideally reflect more than just
+                            // modules into the linker's namespace but that's
+                            // not easily supported today for host functions due
+                            // to the inability to take a function from one
+                            // instance and put it into the linker (must go
+                            // through the host right now).
+                            _ => {}
+                        }
                     }
                 }
                 self.current = Some(InstanceKind::Component(instance));
@@ -304,7 +319,8 @@ impl<T> WastContext<T> {
                             bail!("expected component value found core value")
                         }
                     };
-                    core::match_val(v, e).with_context(|| format!("result {} didn't match", i))?;
+                    core::match_val(&self.store, v, e)
+                        .with_context(|| format!("result {i} didn't match"))?;
                 }
             }
             #[cfg(feature = "component-model")]
@@ -320,7 +336,7 @@ impl<T> WastContext<T> {
                         WastRet::Component(val) => val,
                     };
                     component::match_val(e, v)
-                        .with_context(|| format!("result {} didn't match", i))?;
+                        .with_context(|| format!("result {i} didn't match"))?;
                 }
             }
         }
@@ -361,26 +377,54 @@ impl<T> WastContext<T> {
         let buf = ParseBuffer::new_with_lexer(lexer).map_err(adjust_wast)?;
         let ast = parser::parse::<Wast>(&buf).map_err(adjust_wast)?;
 
-        for directive in ast.directives {
-            let sp = directive.span();
-            if log::log_enabled!(log::Level::Debug) {
-                let (line, col) = sp.linecol_in(wast);
-                log::debug!("running directive on {}:{}:{}", filename, line + 1, col);
-            }
-            self.run_directive(directive)
-                .map_err(|e| match e.downcast() {
-                    Ok(err) => adjust_wast(err).into(),
-                    Err(e) => e,
-                })
-                .with_context(|| {
+        self.run_directives(ast.directives, filename, wast)
+    }
+
+    fn run_directives(
+        &mut self,
+        directives: Vec<WastDirective<'_>>,
+        filename: &str,
+        wast: &str,
+    ) -> Result<()> {
+        let adjust_wast = |mut err: wast::Error| {
+            err.set_path(filename.as_ref());
+            err.set_text(wast);
+            err
+        };
+
+        thread::scope(|scope| {
+            let mut threads = HashMap::new();
+            for directive in directives {
+                let sp = directive.span();
+                if log::log_enabled!(log::Level::Debug) {
                     let (line, col) = sp.linecol_in(wast);
-                    format!("failed directive on {}:{}:{}", filename, line + 1, col)
-                })?;
-        }
-        Ok(())
+                    log::debug!("running directive on {}:{}:{}", filename, line + 1, col);
+                }
+                self.run_directive(directive, filename, wast, &scope, &mut threads)
+                    .map_err(|e| match e.downcast() {
+                        Ok(err) => adjust_wast(err).into(),
+                        Err(e) => e,
+                    })
+                    .with_context(|| {
+                        let (line, col) = sp.linecol_in(wast);
+                        format!("failed directive on {}:{}:{}", filename, line + 1, col)
+                    })?;
+            }
+            Ok(())
+        })
     }
 
-    fn run_directive(&mut self, directive: WastDirective) -> Result<()> {
+    fn run_directive<'a>(
+        &mut self,
+        directive: WastDirective<'a>,
+        filename: &'a str,
+        wast: &'a str,
+        scope: &'a thread::Scope<'a, '_>,
+        threads: &mut HashMap<&'a str, thread::ScopedJoinHandle<'a, Result<()>>>,
+    ) -> Result<()>
+    where
+        T: 'a,
+    {
         use wast::WastDirective::*;
 
         match directive {
@@ -428,7 +472,7 @@ impl<T> WastContext<T> {
                     Ok(()) => bail!("expected module to fail to build"),
                     Err(e) => e,
                 };
-                let error_message = format!("{:?}", err);
+                let error_message = format!("{err:?}");
                 if !is_matching_assert_invalid_error_message(&message, &error_message) {
                     bail!(
                         "assert_invalid: expected \"{}\", got \"{}\"",
@@ -455,7 +499,7 @@ impl<T> WastContext<T> {
                     Ok(()) => bail!("expected module to fail to link"),
                     Err(e) => e,
                 };
-                let error_message = format!("{:?}", err);
+                let error_message = format!("{err:?}");
                 if !error_message.contains(&message) {
                     bail!(
                         "assert_unlinkable: expected {}, got {}",
@@ -465,6 +509,40 @@ impl<T> WastContext<T> {
                 }
             }
             AssertException { .. } => bail!("unimplemented assert_exception"),
+
+            Thread(thread) => {
+                let mut core_linker = Linker::new(self.store.engine());
+                if let Some(id) = thread.shared_module {
+                    let items = self
+                        .core_linker
+                        .iter(&mut self.store)
+                        .filter(|(module, _, _)| *module == id.name())
+                        .collect::<Vec<_>>();
+                    for (module, name, item) in items {
+                        core_linker.define(&mut self.store, module, name, item)?;
+                    }
+                }
+                let mut child_cx = WastContext {
+                    current: None,
+                    core_linker,
+                    #[cfg(feature = "component-model")]
+                    component_linker: component::Linker::new(self.store.engine()),
+                    store: Store::new(self.store.engine(), self.store.data().clone()),
+                };
+                let name = thread.name.name();
+                let child =
+                    scope.spawn(move || child_cx.run_directives(thread.directives, filename, wast));
+                threads.insert(name, child);
+            }
+
+            Wait { thread, .. } => {
+                let name = thread.name();
+                threads
+                    .remove(name)
+                    .ok_or_else(|| anyhow!("no thread named `{name}`"))?
+                    .join()
+                    .unwrap()?;
+            }
         }
 
         Ok(())
diff --git a/crates/wiggle/Cargo.toml b/crates/wiggle/Cargo.toml
index 479fac45531b..ae526252fd4f 100644
--- a/crates/wiggle/Cargo.toml
+++ b/crates/wiggle/Cargo.toml
@@ -3,6 +3,7 @@ name = "wiggle"
 version.workspace = true
 authors = ["Pat Hickey <phickey@fastly.com>", "Jakub Konka <kubkonk@jakubkonka.com>", "Alex Crichton <alex@alexcrichton.com>"]
 edition.workspace = true
+rust-version.workspace = true
 license = "Apache-2.0 WITH LLVM-exception"
 description = "Runtime components of wiggle code generator"
 categories = ["wasm"]
@@ -10,20 +11,24 @@ keywords = ["webassembly", "wasm"]
 repository = "https://github.com/bytecodealliance/wasmtime"
 include = ["src/**/*", "README.md", "LICENSE"]
 
+[lints]
+workspace = true
+
 [dependencies]
 thiserror = { workspace = true }
-witx = { path = "../wasi-common/WASI/tools/witx", version = "0.9.1", optional = true }
+witx = { version = "0.9.1", optional = true }
 wiggle-macro = { workspace = true }
 tracing = { workspace = true }
 bitflags = { workspace = true }
 async-trait = { workspace = true }
-wasmtime = { workspace = true }
+wasmtime = { workspace = true, optional = true }
 anyhow = { workspace = true }
 
 [dev-dependencies]
 wiggle-test = { path = "test-helpers" }
 proptest = "1.0.0"
 tokio = { version = "1", features = ["rt-multi-thread","time", "macros"] }
+wasmtime = { workspace = true }
 
 [[test]]
 name = "atoms_async"
@@ -59,7 +64,10 @@ wiggle_metadata = ['witx', "wiggle-macro/wiggle_metadata"]
 # the logs out of wiggle-generated libraries.
 tracing_log = [ "tracing/log" ]
 
+# This feature enables integration with wasmtime.
+wasmtime = ["dep:wasmtime"]
+
 # Support for async in the wasmtime crates.
 wasmtime_async = [ "wasmtime/async" ]
 
-default = ["wiggle_metadata", "wasmtime_async" ]
+default = ["wiggle_metadata", "wasmtime", "wasmtime_async" ]
diff --git a/crates/wiggle/generate/Cargo.toml b/crates/wiggle/generate/Cargo.toml
index 98684a627847..83444c410f1b 100644
--- a/crates/wiggle/generate/Cargo.toml
+++ b/crates/wiggle/generate/Cargo.toml
@@ -4,6 +4,7 @@ version.workspace = true
 authors = ["Pat Hickey <phickey@fastly.com>", "Jakub Konka <kubkon@jakubkonka.com>", "Alex Crichton <alex@alexcrichton.com>"]
 license = "Apache-2.0 WITH LLVM-exception"
 edition.workspace = true
+rust-version.workspace = true
 description = "Library crate for wiggle code generator."
 categories = ["wasm"]
 keywords = ["webassembly", "wasm"]
@@ -11,10 +12,11 @@ repository = "https://github.com/bytecodealliance/wasmtime"
 readme = "README.md"
 include = ["src/**/*", "README.md", "LICENSE"]
 
-[lib]
+[lints]
+workspace = true
 
 [dependencies]
-witx = { version = "0.9.1", path = "../../wasi-common/WASI/tools/witx" }
+witx = "0.9.1"
 quote = "1.0"
 proc-macro2 = "1.0"
 heck = { workspace = true }
diff --git a/crates/wiggle/generate/src/codegen_settings.rs b/crates/wiggle/generate/src/codegen_settings.rs
index b6fdf62f227b..4b0e4d6bce5a 100644
--- a/crates/wiggle/generate/src/codegen_settings.rs
+++ b/crates/wiggle/generate/src/codegen_settings.rs
@@ -62,7 +62,7 @@ impl ErrorTransform {
                 },
                 ErrorConfField::User(field) => if let Some(abi_type) = doc.typename(&Id::new(ident.to_string())) {
                     if let Some(ident) = field.rich_error.get_ident() {
-                        if let Some(prior_def) = richtype_identifiers.insert(ident.clone(), field.err_loc.clone())
+                        if let Some(prior_def) = richtype_identifiers.insert(ident.clone(), field.err_loc)
                          {
                             return Err(anyhow!(
                                     "duplicate rich type identifier of {:?} not allowed. prior definition at {:?}",
diff --git a/crates/wiggle/generate/src/config.rs b/crates/wiggle/generate/src/config.rs
index a007d5448ee1..cfb1bccea146 100644
--- a/crates/wiggle/generate/src/config.rs
+++ b/crates/wiggle/generate/src/config.rs
@@ -1,6 +1,6 @@
 use {
     proc_macro2::{Span, TokenStream},
-    std::{collections::HashMap, iter::FromIterator, path::PathBuf},
+    std::{collections::HashMap, path::PathBuf},
     syn::{
         braced, bracketed,
         parse::{Parse, ParseStream},
diff --git a/crates/wiggle/generate/src/funcs.rs b/crates/wiggle/generate/src/funcs.rs
index 0bf41f7ca7ad..7b6528208ce7 100644
--- a/crates/wiggle/generate/src/funcs.rs
+++ b/crates/wiggle/generate/src/funcs.rs
@@ -35,7 +35,7 @@ fn _define_func(
 
     let (wasm_params, wasm_results) = func.wasm_signature();
     let param_names = (0..wasm_params.len())
-        .map(|i| Ident::new(&format!("arg{}", i), Span::call_site()))
+        .map(|i| Ident::new(&format!("arg{i}"), Span::call_site()))
         .collect::<Vec<_>>();
     let abi_params = wasm_params.iter().zip(&param_names).map(|(arg, name)| {
         let wasm = names::wasm_type(*arg);
@@ -78,9 +78,9 @@ fn _define_func(
         );
     );
     let ctx_type = if settings.mutable {
-        quote!(&'a mut)
+        quote!(&mut)
     } else {
-        quote!(&'a)
+        quote!(&)
     };
     if settings.get_async(&module, &func).is_sync() {
         let traced_body = if settings.tracing.enabled_for(&mod_name, &func_name) {
@@ -96,9 +96,9 @@ fn _define_func(
         (
             quote!(
                 #[allow(unreachable_code)] // deals with warnings in noreturn functions
-                pub fn #ident<'a>(
+                pub fn #ident(
                     ctx: #ctx_type (impl #(#bounds)+*),
-                    memory: &dyn wiggle::GuestMemory,
+                    memory: &mut wiggle::GuestMemory<'_>,
                     #(#abi_params),*
                 ) -> wiggle::anyhow::Result<#abi_ret> {
                     use std::convert::TryFrom as _;
@@ -114,23 +114,21 @@ fn _define_func(
                 #mk_span
                 async move {
                     #body
-                }.instrument(_span)
+                }.instrument(_span).await
             )
         } else {
             quote!(
-                async move {
-                    #body
-                }
+                #body
             )
         };
         (
             quote!(
                 #[allow(unreachable_code)] // deals with warnings in noreturn functions
-                pub fn #ident<'a>(
+                pub async fn #ident(
                     ctx: #ctx_type (impl #(#bounds)+*),
-                    memory: &'a dyn wiggle::GuestMemory,
+                    memory: &mut wiggle::GuestMemory<'_>,
                     #(#abi_params),*
-                ) -> impl std::future::Future<Output = wiggle::anyhow::Result<#abi_ret>> + 'a {
+                ) -> wiggle::anyhow::Result<#abi_ret> {
                     use std::convert::TryFrom as _;
                     #traced_body
                 }
@@ -210,7 +208,7 @@ impl witx::Bindgen for Rust<'_> {
 
         let mut try_from = |ty: TokenStream| {
             let val = operands.pop().unwrap();
-            let wrap_err = wrap_err(&format!("convert {}", ty));
+            let wrap_err = wrap_err(&format!("convert {ty}"));
             results.push(quote!(#ty::try_from(#val).map_err(#wrap_err)?));
         };
 
@@ -224,7 +222,7 @@ impl witx::Bindgen for Rust<'_> {
                 let val = operands.pop().unwrap();
                 let pointee_type = names::type_ref(ty, anon_lifetime());
                 results.push(quote! {
-                    wiggle::GuestPtr::<#pointee_type>::new(memory, #val as u32)
+                    wiggle::GuestPtr::<#pointee_type>::new(#val as u32)
                 });
             }
 
@@ -239,7 +237,7 @@ impl witx::Bindgen for Rust<'_> {
                     }
                 };
                 results.push(quote! {
-                    wiggle::GuestPtr::<#ty>::new(memory, (#ptr as u32, #len as u32));
+                    wiggle::GuestPtr::<#ty>::new((#ptr as u32, #len as u32));
                 })
             }
 
@@ -284,11 +282,11 @@ impl witx::Bindgen for Rust<'_> {
                 let ident = names::func(&func.name);
                 if self.settings.get_async(&self.module, &func).is_sync() {
                     self.src.extend(quote! {
-                        let ret = #trait_name::#ident(ctx, #(#args),*);
+                        let ret = #trait_name::#ident(ctx, memory, #(#args),*);
                     })
                 } else {
                     self.src.extend(quote! {
-                        let ret = #trait_name::#ident(ctx, #(#args),*).await;
+                        let ret = #trait_name::#ident(ctx, memory, #(#args),*).await;
                     })
                 };
                 if self
@@ -355,7 +353,7 @@ impl witx::Bindgen for Rust<'_> {
 
             Instruction::TupleLower { amt } => {
                 let names = (0..*amt)
-                    .map(|i| Ident::new(&format!("t{}", i), Span::call_site()))
+                    .map(|i| Ident::new(&format!("t{i}"), Span::call_site()))
                     .collect::<Vec<_>>();
                 let val = operands.pop().unwrap();
                 self.src.extend(quote!( let (#(#names,)*) = #val;));
@@ -368,9 +366,11 @@ impl witx::Bindgen for Rust<'_> {
                 let wrap_err = wrap_err(&format!("write {}", ty.name.as_str()));
                 let pointee_type = names::type_(&ty.name);
                 self.src.extend(quote! {
-                    wiggle::GuestPtr::<#pointee_type>::new(memory, #ptr as u32)
-                        .write(#val)
-                        .map_err(#wrap_err)?;
+                    memory.write(
+                        wiggle::GuestPtr::<#pointee_type>::new(#ptr as u32),
+                        #val,
+                    )
+                    .map_err(#wrap_err)?;
                 });
             }
 
@@ -379,8 +379,7 @@ impl witx::Bindgen for Rust<'_> {
                 let wrap_err = wrap_err(&format!("read {}", ty.name.as_str()));
                 let pointee_type = names::type_(&ty.name);
                 results.push(quote! {
-                    wiggle::GuestPtr::<#pointee_type>::new(memory, #ptr as u32)
-                        .read()
+                    memory.read(wiggle::GuestPtr::<#pointee_type>::new(#ptr as u32))
                         .map_err(#wrap_err)?
                 });
             }
@@ -429,7 +428,7 @@ impl witx::Bindgen for Rust<'_> {
             // There's a number of other instructions we could implement but
             // they're not exercised by WASI at this time. As necessary we can
             // add code to implement them.
-            other => panic!("no implementation for {:?}", other),
+            other => panic!("no implementation for {other:?}"),
         }
     }
 }
diff --git a/crates/wiggle/generate/src/lib.rs b/crates/wiggle/generate/src/lib.rs
index 77bbe6b005c9..8e1ccdf625e2 100644
--- a/crates/wiggle/generate/src/lib.rs
+++ b/crates/wiggle/generate/src/lib.rs
@@ -88,7 +88,7 @@ pub fn generate(doc: &witx::Document, settings: &CodegenSettings) -> TokenStream
 }
 
 pub fn generate_metadata(doc: &witx::Document) -> TokenStream {
-    let doc_text = &format!("{}", doc);
+    let doc_text = &format!("{doc}");
     quote! {
         pub mod metadata {
             pub const DOC_TEXT: &str = #doc_text;
diff --git a/crates/wiggle/generate/src/module_trait.rs b/crates/wiggle/generate/src/module_trait.rs
index 7a7b52fb0c30..fb57919c4b4e 100644
--- a/crates/wiggle/generate/src/module_trait.rs
+++ b/crates/wiggle/generate/src/module_trait.rs
@@ -2,13 +2,11 @@ use proc_macro2::TokenStream;
 use quote::quote;
 
 use crate::codegen_settings::{CodegenSettings, ErrorType};
-use crate::lifetimes::{anon_lifetime, LifetimeExt};
 use crate::names;
 use witx::Module;
 
 pub fn passed_by_reference(ty: &witx::Type) -> bool {
     match ty {
-        witx::Type::Pointer(_) | witx::Type::ConstPointer(_) | witx::Type::List(_) => true,
         witx::Type::Record(r) => r.bitflags_repr().is_none(),
         witx::Type::Variant(v) => !v.is_enum(),
         _ => false,
@@ -18,23 +16,10 @@ pub fn passed_by_reference(ty: &witx::Type) -> bool {
 pub fn define_module_trait(m: &Module, settings: &CodegenSettings) -> TokenStream {
     let traitname = names::trait_name(&m.name);
     let traitmethods = m.funcs().map(|f| {
-        // Check if we're returning an entity anotated with a lifetime,
-        // in which case, we'll need to annotate the function itself, and
-        // hence will need an explicit lifetime (rather than anonymous)
-        let (lifetime, is_anonymous) = if f
-            .params
-            .iter()
-            .chain(&f.results)
-            .any(|ret| ret.tref.needs_lifetime())
-        {
-            (quote!('a), false)
-        } else {
-            (anon_lifetime(), true)
-        };
         let funcname = names::func(&f.name);
         let args = f.params.iter().map(|arg| {
             let arg_name = names::func_param(&arg.name);
-            let arg_typename = names::type_ref(&arg.tref, lifetime.clone());
+            let arg_typename = names::type_ref(&arg.tref, quote!());
             let arg_type = if passed_by_reference(&*arg.tref.type_()) {
                 quote!(&#arg_typename)
             } else {
@@ -56,7 +41,7 @@ pub fn define_module_trait(m: &Module, settings: &CodegenSettings) -> TokenStrea
                 };
 
                 let ok = match ok {
-                    Some(ty) => names::type_ref(ty, lifetime.clone()),
+                    Some(ty) => names::type_ref(ty, quote!()),
                     None => quote!(()),
                 };
                 let err = match err {
@@ -66,7 +51,7 @@ pub fn define_module_trait(m: &Module, settings: &CodegenSettings) -> TokenStrea
                             quote!(super::#tn)
                         }
                         Some(ErrorType::Generated(g)) => g.typename(),
-                        None => names::type_ref(ty, lifetime.clone()),
+                        None => names::type_ref(ty, quote!()),
                     },
                     None => quote!(()),
                 };
@@ -86,11 +71,13 @@ pub fn define_module_trait(m: &Module, settings: &CodegenSettings) -> TokenStrea
         } else {
             quote!(&self)
         };
-        if is_anonymous {
-            quote!(#asyncness fn #funcname(#self_, #(#args),*) -> #result; )
-        } else {
-            quote!(#asyncness fn #funcname<#lifetime>(#self_, #(#args),*) -> #result;)
-        }
+        quote!(
+            #asyncness fn #funcname(
+                #self_,
+                mem: &mut wiggle::GuestMemory<'_>,
+                #(#args),*
+            ) -> #result;
+        )
     });
 
     quote! {
diff --git a/crates/wiggle/generate/src/names.rs b/crates/wiggle/generate/src/names.rs
index a32a35be5740..f1748e729f26 100644
--- a/crates/wiggle/generate/src/names.rs
+++ b/crates/wiggle/generate/src/names.rs
@@ -4,7 +4,7 @@ use proc_macro2::{Ident, TokenStream};
 use quote::{format_ident, quote};
 use witx::{BuiltinType, Id, Type, TypeRef, WasmType};
 
-use crate::{lifetimes::LifetimeExt, UserErrorType};
+use crate::UserErrorType;
 
 pub fn type_(id: &Id) -> Ident {
     escape_id(id, NamingConvention::CamelCase)
@@ -39,25 +39,21 @@ pub fn type_ref(tref: &TypeRef, lifetime: TokenStream) -> TokenStream {
     match tref {
         TypeRef::Name(nt) => {
             let ident = type_(&nt.name);
-            if nt.tref.needs_lifetime() {
-                quote!(#ident<#lifetime>)
-            } else {
-                quote!(#ident)
-            }
+            quote!(#ident)
         }
         TypeRef::Value(ty) => match &**ty {
             Type::Builtin(builtin) => builtin_type(*builtin),
             Type::Pointer(pointee) | Type::ConstPointer(pointee) => {
                 let pointee_type = type_ref(&pointee, lifetime.clone());
-                quote!(wiggle::GuestPtr<#lifetime, #pointee_type>)
+                quote!(wiggle::GuestPtr<#pointee_type>)
             }
             Type::List(pointee) => match &**pointee.type_() {
                 Type::Builtin(BuiltinType::Char) => {
-                    quote!(wiggle::GuestPtr<#lifetime, str>)
+                    quote!(wiggle::GuestPtr<str>)
                 }
                 _ => {
                     let pointee_type = type_ref(&pointee, lifetime.clone());
-                    quote!(wiggle::GuestPtr<#lifetime, [#pointee_type]>)
+                    quote!(wiggle::GuestPtr<[#pointee_type]>)
                 }
             },
             Type::Variant(v) => match v.as_expected() {
@@ -174,7 +170,7 @@ fn snake_typename(tref: &TypeRef) -> String {
         TypeRef::Name(nt) => nt.name.as_str().to_snake_case(),
         TypeRef::Value(ty) => match &**ty {
             Type::Builtin(b) => builtin_name(&b).to_owned(),
-            _ => panic!("unexpected anonymous type: {:?}", ty),
+            _ => panic!("unexpected anonymous type: {ty:?}"),
         },
     }
 }
diff --git a/crates/wiggle/generate/src/types/flags.rs b/crates/wiggle/generate/src/types/flags.rs
index 5c117a845a65..8687d95a4a02 100644
--- a/crates/wiggle/generate/src/types/flags.rs
+++ b/crates/wiggle/generate/src/types/flags.rs
@@ -65,7 +65,7 @@ pub(super) fn define_flags(
             }
         }
 
-        impl<'a> wiggle::GuestType<'a> for #ident {
+        impl wiggle::GuestType for #ident {
             #[inline]
             fn guest_size() -> u32 {
                 #repr::guest_size()
@@ -76,16 +76,16 @@ pub(super) fn define_flags(
                 #repr::guest_align()
             }
 
-            fn read(location: &wiggle::GuestPtr<#ident>) -> Result<#ident, wiggle::GuestError> {
+            fn read(mem: &wiggle::GuestMemory, location: wiggle::GuestPtr<#ident>) -> Result<#ident, wiggle::GuestError> {
                 use std::convert::TryFrom;
-                let reprval = #repr::read(&location.cast())?;
+                let reprval = #repr::read(mem, location.cast())?;
                 let value = #ident::try_from(reprval)?;
                 Ok(value)
             }
 
-            fn write(location: &wiggle::GuestPtr<'_, #ident>, val: Self) -> Result<(), wiggle::GuestError> {
+            fn write(mem: &mut wiggle::GuestMemory, location: wiggle::GuestPtr<#ident>, val: Self) -> Result<(), wiggle::GuestError> {
                 let val: #repr = #repr::from(val);
-                #repr::write(&location.cast(), val)
+                #repr::write(mem, location.cast(), val)
             }
         }
     }
diff --git a/crates/wiggle/generate/src/types/handle.rs b/crates/wiggle/generate/src/types/handle.rs
index d277ffec39d6..34540f295b4c 100644
--- a/crates/wiggle/generate/src/types/handle.rs
+++ b/crates/wiggle/generate/src/types/handle.rs
@@ -7,7 +7,7 @@ use witx::Layout;
 pub(super) fn define_handle(name: &witx::Id, h: &witx::HandleDatatype) -> TokenStream {
     let ident = names::type_(name);
     let size = h.mem_size_align().size as u32;
-    let align = h.mem_size_align().align as usize;
+    let align = h.mem_size_align().align;
     quote! {
         #[repr(transparent)]
         #[derive(Copy, Clone, Debug, ::std::hash::Hash, Eq, PartialEq)]
@@ -53,7 +53,7 @@ pub(super) fn define_handle(name: &witx::Id, h: &witx::HandleDatatype) -> TokenS
             }
         }
 
-        impl<'a> wiggle::GuestType<'a> for #ident {
+        impl wiggle::GuestType for #ident {
             #[inline]
             fn guest_size() -> u32 {
                 #size
@@ -65,13 +65,13 @@ pub(super) fn define_handle(name: &witx::Id, h: &witx::HandleDatatype) -> TokenS
             }
 
             #[inline]
-            fn read(location: &wiggle::GuestPtr<'a, #ident>) -> Result<#ident, wiggle::GuestError> {
-                Ok(#ident(u32::read(&location.cast())?))
+            fn read(mem: &wiggle::GuestMemory, location: wiggle::GuestPtr<#ident>) -> Result<#ident, wiggle::GuestError> {
+                Ok(#ident(u32::read(mem, location.cast())?))
             }
 
             #[inline]
-            fn write(location: &wiggle::GuestPtr<'_, Self>, val: Self) -> Result<(), wiggle::GuestError> {
-                u32::write(&location.cast(), val.0)
+            fn write(mem: &mut wiggle::GuestMemory, location: wiggle::GuestPtr<Self>, val: Self) -> Result<(), wiggle::GuestError> {
+                u32::write(mem, location.cast(), val.0)
             }
         }
     }
diff --git a/crates/wiggle/generate/src/types/mod.rs b/crates/wiggle/generate/src/types/mod.rs
index 2820db9fbd29..556c14ca21a3 100644
--- a/crates/wiggle/generate/src/types/mod.rs
+++ b/crates/wiggle/generate/src/types/mod.rs
@@ -70,8 +70,8 @@ fn define_witx_pointer(
 
 fn define_witx_list(name: &witx::Id, arr_raw: &witx::TypeRef) -> TokenStream {
     let ident = names::type_(name);
-    let pointee_type = names::type_ref(arr_raw, quote!('a));
-    quote!(pub type #ident<'a> = wiggle::GuestPtr<'a, [#pointee_type]>;)
+    let pointee_type = names::type_ref(arr_raw, quote!());
+    quote!(pub type #ident = wiggle::GuestPtr<[#pointee_type]>;)
 }
 
 pub fn int_repr_tokens(int_repr: witx::IntRepr) -> TokenStream {
diff --git a/crates/wiggle/generate/src/types/record.rs b/crates/wiggle/generate/src/types/record.rs
index 167f317caa6b..2b71d568fc91 100644
--- a/crates/wiggle/generate/src/types/record.rs
+++ b/crates/wiggle/generate/src/types/record.rs
@@ -8,7 +8,7 @@ use witx::Layout;
 pub(super) fn define_struct(name: &witx::Id, s: &witx::RecordDatatype) -> TokenStream {
     let ident = names::type_(name);
     let size = s.mem_size_align().size as u32;
-    let align = s.mem_size_align().align as usize;
+    let align = s.mem_size_align().align;
 
     let member_names = s.members.iter().map(|m| names::struct_member(&m.name));
     let member_decls = s.members.iter().map(|m| {
@@ -16,17 +16,13 @@ pub(super) fn define_struct(name: &witx::Id, s: &witx::RecordDatatype) -> TokenS
         let type_ = match &m.tref {
             witx::TypeRef::Name(nt) => {
                 let tt = names::type_(&nt.name);
-                if m.tref.needs_lifetime() {
-                    quote!(#tt<'a>)
-                } else {
-                    quote!(#tt)
-                }
+                quote!(#tt)
             }
             witx::TypeRef::Value(ty) => match &**ty {
                 witx::Type::Builtin(builtin) => names::builtin_type(*builtin),
                 witx::Type::Pointer(pointee) | witx::Type::ConstPointer(pointee) => {
                     let pointee_type = names::type_ref(&pointee, quote!('a));
-                    quote!(wiggle::GuestPtr<'a, #pointee_type>)
+                    quote!(wiggle::GuestPtr<#pointee_type>)
                 }
                 _ => unimplemented!("other anonymous struct members: {:?}", m.tref),
             },
@@ -53,20 +49,20 @@ pub(super) fn define_struct(name: &witx::Id, s: &witx::RecordDatatype) -> TokenS
             witx::TypeRef::Name(nt) => {
                 let type_ = names::type_(&nt.name);
                 quote! {
-                    let #name = <#type_ as wiggle::GuestType>::read(&#location)?;
+                    let #name = <#type_ as wiggle::GuestType>::read(mem, #location)?;
                 }
             }
             witx::TypeRef::Value(ty) => match &**ty {
                 witx::Type::Builtin(builtin) => {
                     let type_ = names::builtin_type(*builtin);
                     quote! {
-                        let #name = <#type_ as wiggle::GuestType>::read(&#location)?;
+                        let #name = <#type_ as wiggle::GuestType>::read(mem, #location)?;
                     }
                 }
                 witx::Type::Pointer(pointee) | witx::Type::ConstPointer(pointee) => {
                     let pointee_type = names::type_ref(&pointee, anon_lifetime());
                     quote! {
-                        let #name = <wiggle::GuestPtr::<#pointee_type> as wiggle::GuestType>::read(&#location)?;
+                        let #name = <wiggle::GuestPtr::<#pointee_type> as wiggle::GuestType>::read(mem, #location)?;
                     }
                 }
                 _ => unimplemented!("other anonymous struct members: {:?}", ty),
@@ -79,7 +75,8 @@ pub(super) fn define_struct(name: &witx::Id, s: &witx::RecordDatatype) -> TokenS
         let offset = ml.offset as u32;
         quote! {
             wiggle::GuestType::write(
-                &location.cast::<u8>().add(#offset)?.cast(),
+                mem,
+                location.cast::<u8>().add(#offset)?.cast(),
                 val.#name,
             )?;
         }
@@ -93,15 +90,15 @@ pub(super) fn define_struct(name: &witx::Id, s: &witx::RecordDatatype) -> TokenS
 
     quote! {
         #[derive(Clone, Debug #extra_derive)]
-        pub struct #ident #struct_lifetime {
+        pub struct #ident {
             #(#member_decls),*
         }
 
-        impl #struct_lifetime #ident #struct_lifetime {
+        impl #struct_lifetime #ident {
             #(#member_offsets)*
         }
 
-        impl<'a> wiggle::GuestType<'a> for #ident #struct_lifetime {
+        impl wiggle::GuestType for #ident {
             #[inline]
             fn guest_size() -> u32 {
                 #size
@@ -112,12 +109,12 @@ pub(super) fn define_struct(name: &witx::Id, s: &witx::RecordDatatype) -> TokenS
                 #align
             }
 
-            fn read(location: &wiggle::GuestPtr<'a, Self>) -> Result<Self, wiggle::GuestError> {
+            fn read(mem: &wiggle::GuestMemory, location: wiggle::GuestPtr<Self>) -> Result<Self, wiggle::GuestError> {
                 #(#member_reads)*
                 Ok(#ident { #(#member_names),* })
             }
 
-            fn write(location: &wiggle::GuestPtr<'_, Self>, val: Self) -> Result<(), wiggle::GuestError> {
+            fn write(mem: &mut wiggle::GuestMemory, location: wiggle::GuestPtr<Self>, val: Self) -> Result<(), wiggle::GuestError> {
                 #(#member_writes)*
                 Ok(())
             }
diff --git a/crates/wiggle/generate/src/types/variant.rs b/crates/wiggle/generate/src/types/variant.rs
index 5fc5943696d1..0585660c563c 100644
--- a/crates/wiggle/generate/src/types/variant.rs
+++ b/crates/wiggle/generate/src/types/variant.rs
@@ -1,4 +1,3 @@
-use crate::lifetimes::LifetimeExt;
 use crate::names;
 
 use proc_macro2::{Literal, TokenStream};
@@ -12,7 +11,7 @@ pub(super) fn define_variant(
 ) -> TokenStream {
     let ident = names::type_(name);
     let size = v.mem_size_align().size as u32;
-    let align = v.mem_size_align().align as usize;
+    let align = v.mem_size_align().align;
     let contents_offset = v.payload_offset() as u32;
 
     let lifetime = quote!('a);
@@ -36,7 +35,7 @@ pub(super) fn define_variant(
             quote! {
                 #i => {
                     let variant_ptr = location.cast::<u8>().add(#contents_offset)?;
-                    let variant_val = <#varianttype as wiggle::GuestType>::read(&variant_ptr.cast())?;
+                    let variant_val = <#varianttype as wiggle::GuestType>::read(mem, variant_ptr.cast())?;
                     Ok(#ident::#variantname(variant_val))
                 }
             }
@@ -48,7 +47,7 @@ pub(super) fn define_variant(
     let write_variant = v.cases.iter().enumerate().map(|(i, c)| {
         let variantname = names::enum_variant(&c.name);
         let write_tag = quote! {
-            location.cast().write(#i as #tag_ty)?;
+            mem.write(location.cast(), #i as #tag_ty)?;
         };
         if let Some(tref) = &c.tref {
             let varianttype = names::type_ref(tref, lifetime.clone());
@@ -56,7 +55,7 @@ pub(super) fn define_variant(
                 #ident::#variantname(contents) => {
                     #write_tag
                     let variant_ptr = location.cast::<u8>().add(#contents_offset)?;
-                    <#varianttype as wiggle::GuestType>::write(&variant_ptr.cast(), contents)?;
+                    <#varianttype as wiggle::GuestType>::write(mem, variant_ptr.cast(), contents)?;
                 }
             }
         } else {
@@ -121,11 +120,7 @@ pub(super) fn define_variant(
         quote!()
     };
 
-    let (enum_lifetime, extra_derive) = if v.needs_lifetime() {
-        (quote!(<'a>), quote!())
-    } else {
-        (quote!(), quote!(, PartialEq #extra_derive))
-    };
+    let extra_derive = quote!(, PartialEq #extra_derive);
 
     let error_impls = if derive_std_error {
         quote! {
@@ -142,7 +137,7 @@ pub(super) fn define_variant(
 
     quote! {
         #[derive(Clone, Debug #extra_derive)]
-        pub enum #ident #enum_lifetime {
+        pub enum #ident {
             #(#variants),*
         }
         #error_impls
@@ -150,7 +145,7 @@ pub(super) fn define_variant(
         #enum_try_from
         #enum_from
 
-        impl<'a> wiggle::GuestType<'a> for #ident #enum_lifetime {
+        impl wiggle::GuestType for #ident {
             #[inline]
             fn guest_size() -> u32 {
                 #size
@@ -161,10 +156,10 @@ pub(super) fn define_variant(
                 #align
             }
 
-            fn read(location: &wiggle::GuestPtr<'a, Self>)
+            fn read(mem: &wiggle::GuestMemory, location: wiggle::GuestPtr<Self>)
                 -> Result<Self, wiggle::GuestError>
             {
-                let tag = location.cast::<#tag_ty>().read()?;
+                let tag = mem.read(location.cast::<#tag_ty>())?;
                 match tag {
                     #(#read_variant)*
                     _ => Err(wiggle::GuestError::InvalidEnumValue(stringify!(#ident))),
@@ -172,7 +167,7 @@ pub(super) fn define_variant(
 
             }
 
-            fn write(location: &wiggle::GuestPtr<'_, Self>, val: Self)
+            fn write(mem:  &mut wiggle::GuestMemory, location: wiggle::GuestPtr<Self>, val: Self)
                 -> Result<(), wiggle::GuestError>
             {
                 match val {
diff --git a/crates/wiggle/generate/src/wasmtime.rs b/crates/wiggle/generate/src/wasmtime.rs
index 0db270e27306..cb488f992792 100644
--- a/crates/wiggle/generate/src/wasmtime.rs
+++ b/crates/wiggle/generate/src/wasmtime.rs
@@ -81,15 +81,17 @@ fn generate_func(
     let (params, results) = func.wasm_signature();
 
     let arg_names = (0..params.len())
-        .map(|i| Ident::new(&format!("arg{}", i), Span::call_site()))
+        .map(|i| Ident::new(&format!("arg{i}"), Span::call_site()))
         .collect::<Vec<_>>();
-    let arg_decls = params
+    let arg_tys = params
         .iter()
-        .enumerate()
-        .map(|(i, ty)| {
-            let name = &arg_names[i];
-            let wasm = names::wasm_type(*ty);
-            quote! { #name: #wasm }
+        .map(|ty| names::wasm_type(*ty))
+        .collect::<Vec<_>>();
+    let arg_decls = arg_names
+        .iter()
+        .zip(arg_tys.iter())
+        .map(|(name, ty)| {
+            quote! { #name: #ty }
         })
         .collect::<Vec<_>>();
 
@@ -113,29 +115,29 @@ fn generate_func(
 
     let body = quote! {
         let export = caller.get_export("memory");
-        let (mem, ctx) = match &export {
+        let (mut mem, ctx) = match &export {
             Some(wiggle::wasmtime_crate::Extern::Memory(m)) => {
                 let (mem, ctx) = m.data_and_store_mut(&mut caller);
                 let ctx = get_cx(ctx);
-                (wiggle::wasmtime::WasmtimeGuestMemory::new(mem), ctx)
+                (wiggle::GuestMemory::Unshared(mem), ctx)
             }
             Some(wiggle::wasmtime_crate::Extern::SharedMemory(m)) => {
                 let ctx = get_cx(caller.data_mut());
-                (wiggle::wasmtime::WasmtimeGuestMemory::shared(m.data()), ctx)
+                (wiggle::GuestMemory::Shared(m.data()), ctx)
             }
             _ => wiggle::anyhow::bail!("missing required memory export"),
         };
-        Ok(<#ret_ty>::from(#abi_func(ctx, &mem #(, #arg_names)*) #await_ ?))
+        Ok(<#ret_ty>::from(#abi_func(ctx, &mut mem #(, #arg_names)*) #await_ ?))
     };
 
     match asyncness {
         Asyncness::Async => {
-            let wrapper = format_ident!("func_wrap{}_async", params.len());
+            let arg_decls = quote! { ( #(#arg_names,)* ) : ( #(#arg_tys,)* ) };
             quote! {
-                linker.#wrapper(
+                linker.func_wrap_async(
                     #module_str,
                     #field_str,
-                    move |mut caller: wiggle::wasmtime_crate::Caller<'_, T> #(, #arg_decls)*| {
+                    move |mut caller: wiggle::wasmtime_crate::Caller<'_, T>, #arg_decls| {
                         Box::new(async move { #body })
                     },
                 )?;
diff --git a/crates/wiggle/macro/Cargo.toml b/crates/wiggle/macro/Cargo.toml
index 927bdec080ad..6d10be2efa44 100644
--- a/crates/wiggle/macro/Cargo.toml
+++ b/crates/wiggle/macro/Cargo.toml
@@ -3,12 +3,15 @@ name = "wiggle-macro"
 version.workspace = true
 authors = ["Pat Hickey <phickey@fastly.com>", "Jakub Konka <kubkon@jakubkonka.com>", "Alex Crichton <alex@alexcrichton.com>"]
 edition.workspace = true
+rust-version.workspace = true
 license = "Apache-2.0 WITH LLVM-exception"
 description = "Wiggle code generator"
 categories = ["wasm"]
 keywords = ["webassembly", "wasm"]
 repository = "https://github.com/bytecodealliance/wasmtime"
-include = ["src/**/*", "LICENSE"]
+
+[lints]
+workspace = true
 
 [lib]
 proc-macro = true
diff --git a/crates/wiggle/macro/build.rs b/crates/wiggle/macro/build.rs
new file mode 100644
index 000000000000..be0ad5bc97cb
--- /dev/null
+++ b/crates/wiggle/macro/build.rs
@@ -0,0 +1,5 @@
+fn main() {
+    println!("cargo:rerun-if-changed=build.rs");
+    let out_dir = std::env::var("OUT_DIR").unwrap();
+    println!("cargo:rustc-env=DEBUG_OUTPUT_DIR={out_dir}");
+}
diff --git a/crates/wiggle/macro/src/lib.rs b/crates/wiggle/macro/src/lib.rs
index 81304fcccf9b..aa3732a5b4e6 100644
--- a/crates/wiggle/macro/src/lib.rs
+++ b/crates/wiggle/macro/src/lib.rs
@@ -1,5 +1,3 @@
-extern crate proc_macro;
-
 use proc_macro::TokenStream;
 use quote::quote;
 use syn::parse_macro_input;
@@ -27,8 +25,8 @@ use syn::parse_macro_input;
 ///       and return `Result<($return_types),$error_type>`
 ///
 ///     * When the `wiggle` crate is built with the `wasmtime_integration`
-///     feature, each module contains an `add_to_linker` function to add it to
-///     a `wasmtime::Linker`.
+///       feature, each module contains an `add_to_linker` function to add it to
+///       a `wasmtime::Linker`.
 ///
 /// Arguments are provided using Rust struct value syntax.
 ///
@@ -96,7 +94,7 @@ use syn::parse_macro_input;
 /// /// is an asynchronous method. Therefore, we use the `async_trait` proc macro
 /// /// to define this trait, so that `double_int_return_float` can be an `async fn`.
 /// /// `wiggle::async_trait` is defined as `#[async_trait::async_trait(?Send)]` -
-/// /// in wiggle, async methods do not have the Send constaint.
+/// /// in wiggle, async methods do not have the Send constraint.
 /// impl example::Example for YourCtxType {
 ///     /// The arrays module has two methods, shown here.
 ///     /// Note that the `GuestPtr` type comes from `wiggle`,
@@ -168,7 +166,30 @@ pub fn from_witx(args: TokenStream) -> TokenStream {
         quote!()
     };
 
-    TokenStream::from(quote! { #code #metadata })
+    let mut ret = quote! { #code #metadata };
+
+    if std::env::var("WIGGLE_DEBUG_BINDGEN").is_ok() {
+        use std::path::Path;
+        use std::sync::atomic::{AtomicUsize, Ordering::Relaxed};
+        static INVOCATION: AtomicUsize = AtomicUsize::new(0);
+        let root = Path::new(env!("DEBUG_OUTPUT_DIR"));
+        let n = INVOCATION.fetch_add(1, Relaxed);
+        let path = root.join(format!("wiggle{n}.rs"));
+
+        std::fs::write(&path, ret.to_string()).unwrap();
+
+        // optimistically format the code but don't require success
+        drop(
+            std::process::Command::new("rustfmt")
+                .arg(&path)
+                .arg("--edition=2021")
+                .output(),
+        );
+
+        let path = path.to_str().unwrap();
+        ret = quote!(include!(#path););
+    }
+    TokenStream::from(ret)
 }
 
 #[proc_macro_attribute]
diff --git a/crates/wiggle/src/borrow.rs b/crates/wiggle/src/borrow.rs
deleted file mode 100644
index d0a85288e9ad..000000000000
--- a/crates/wiggle/src/borrow.rs
+++ /dev/null
@@ -1,259 +0,0 @@
-use crate::{BorrowHandle, GuestError, Region};
-use std::collections::HashMap;
-use std::sync::Mutex;
-
-pub struct BorrowChecker {
-    /// Unfortunately, since the terminology of std::cell and the problem domain of borrow checking
-    /// overlap, the method calls on this member will be confusing.
-    ///
-    /// Also, unfortunately, for now this uses a `Mutex`. The reason for that is
-    /// that this is shared as `&BorrowChecker` in a bunch of `GuestPtr` values.
-    /// Through this sharing we still want each `GuestPtr` to be `Send` and the
-    /// "naive" way to make `&T` `Send` with interior mutability is to use a
-    /// `Mutex`. Fixing this will likely require rethinking `GuestPtr` one way
-    /// or another. That needs to happen for other reasons as well (for example
-    /// to allow for wasm calls to happen while `GuestPtr` values are active),
-    /// so it's hoped that in a later rethinking of `GuestPtr` we can revisit
-    /// this and remove this `Mutex`.
-    bc: Mutex<InnerBorrowChecker>,
-}
-
-impl BorrowChecker {
-    /// A `BorrowChecker` manages run-time validation of borrows from a
-    /// `GuestMemory`. It keeps track of regions of guest memory which are
-    /// possible to alias with Rust references (via the `GuestSlice` and
-    /// `GuestStr` structs, which implement `std::ops::Deref` and
-    /// `std::ops::DerefMut`. It also enforces that `GuestPtr::read`
-    /// does not access memory with an outstanding mutable borrow, and
-    /// `GuestPtr::write` does not access memory with an outstanding
-    /// shared or mutable borrow.
-    pub fn new() -> Self {
-        BorrowChecker {
-            bc: Mutex::new(InnerBorrowChecker::new()),
-        }
-    }
-    /// Indicates whether any outstanding shared or mutable borrows are known
-    /// to the `BorrowChecker`. This function must be `false` in order for it
-    /// to be safe to recursively call into a WebAssembly module, or to
-    /// manipulate the WebAssembly memory by any other means.
-    pub fn has_outstanding_borrows(&self) -> bool {
-        self.bc.lock().unwrap().has_outstanding_borrows()
-    }
-    pub fn shared_borrow(&self, r: Region) -> Result<BorrowHandle, GuestError> {
-        self.bc.lock().unwrap().shared_borrow(r)
-    }
-    pub fn mut_borrow(&self, r: Region) -> Result<BorrowHandle, GuestError> {
-        self.bc.lock().unwrap().mut_borrow(r)
-    }
-    pub fn shared_unborrow(&self, h: BorrowHandle) {
-        self.bc.lock().unwrap().shared_unborrow(h)
-    }
-    pub fn mut_unborrow(&self, h: BorrowHandle) {
-        self.bc.lock().unwrap().mut_unborrow(h)
-    }
-    pub fn is_shared_borrowed(&self, r: Region) -> bool {
-        self.bc.lock().unwrap().is_shared_borrowed(r)
-    }
-    pub fn is_mut_borrowed(&self, r: Region) -> bool {
-        self.bc.lock().unwrap().is_mut_borrowed(r)
-    }
-}
-
-#[derive(Debug)]
-/// This is a pretty naive way to account for borrows. This datastructure
-/// could be made a lot more efficient with some effort.
-struct InnerBorrowChecker {
-    /// Maps from handle to region borrowed. A HashMap is probably not ideal
-    /// for this but it works. It would be more efficient if we could
-    /// check `is_borrowed` without an O(n) iteration, by organizing borrows
-    /// by an ordering of Region.
-    shared_borrows: HashMap<BorrowHandle, Region>,
-    mut_borrows: HashMap<BorrowHandle, Region>,
-    /// Handle to give out for the next borrow. This is the bare minimum of
-    /// bookkeeping of free handles, and in a pathological case we could run
-    /// out, hence [`GuestError::BorrowCheckerOutOfHandles`]
-    next_handle: BorrowHandle,
-}
-
-impl InnerBorrowChecker {
-    fn new() -> Self {
-        InnerBorrowChecker {
-            shared_borrows: HashMap::new(),
-            mut_borrows: HashMap::new(),
-            next_handle: BorrowHandle(0),
-        }
-    }
-
-    fn has_outstanding_borrows(&self) -> bool {
-        !(self.shared_borrows.is_empty() && self.mut_borrows.is_empty())
-    }
-
-    fn is_shared_borrowed(&self, r: Region) -> bool {
-        self.shared_borrows.values().any(|b| b.overlaps(r))
-    }
-    fn is_mut_borrowed(&self, r: Region) -> bool {
-        self.mut_borrows.values().any(|b| b.overlaps(r))
-    }
-
-    fn new_handle(&mut self) -> Result<BorrowHandle, GuestError> {
-        // Reset handles to 0 if all handles have been returned.
-        if self.shared_borrows.is_empty() && self.mut_borrows.is_empty() {
-            self.next_handle = BorrowHandle(0);
-        }
-        let h = self.next_handle;
-        // Get the next handle. Since we don't recycle handles until all of
-        // them have been returned, there is a pathological case where a user
-        // may make a Very Large (usize::MAX) number of valid borrows and
-        // unborrows while always keeping at least one borrow outstanding, and
-        // we will run out of borrow handles.
-        self.next_handle = BorrowHandle(
-            h.0.checked_add(1)
-                .ok_or_else(|| GuestError::BorrowCheckerOutOfHandles)?,
-        );
-        Ok(h)
-    }
-
-    fn shared_borrow(&mut self, r: Region) -> Result<BorrowHandle, GuestError> {
-        if self.is_mut_borrowed(r) {
-            return Err(GuestError::PtrBorrowed(r));
-        }
-        let h = self.new_handle()?;
-        self.shared_borrows.insert(h, r);
-        Ok(h)
-    }
-
-    fn mut_borrow(&mut self, r: Region) -> Result<BorrowHandle, GuestError> {
-        if self.is_shared_borrowed(r) || self.is_mut_borrowed(r) {
-            return Err(GuestError::PtrBorrowed(r));
-        }
-        let h = self.new_handle()?;
-        self.mut_borrows.insert(h, r);
-        Ok(h)
-    }
-
-    fn shared_unborrow(&mut self, h: BorrowHandle) {
-        let removed = self.shared_borrows.remove(&h);
-        debug_assert!(removed.is_some(), "double-freed shared borrow");
-    }
-
-    fn mut_unborrow(&mut self, h: BorrowHandle) {
-        let removed = self.mut_borrows.remove(&h);
-        debug_assert!(removed.is_some(), "double-freed mut borrow");
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    #[test]
-    fn nonoverlapping() {
-        let mut bs = InnerBorrowChecker::new();
-        let r1 = Region::new(0, 10);
-        let r2 = Region::new(10, 10);
-        assert!(!r1.overlaps(r2));
-        bs.mut_borrow(r1).expect("can borrow r1");
-        bs.mut_borrow(r2).expect("can borrow r2");
-
-        let mut bs = InnerBorrowChecker::new();
-        let r1 = Region::new(10, 10);
-        let r2 = Region::new(0, 10);
-        assert!(!r1.overlaps(r2));
-        bs.mut_borrow(r1).expect("can borrow r1");
-        bs.mut_borrow(r2).expect("can borrow r2");
-    }
-
-    #[test]
-    fn overlapping() {
-        let mut bs = InnerBorrowChecker::new();
-        let r1 = Region::new(0, 10);
-        let r2 = Region::new(9, 10);
-        assert!(r1.overlaps(r2));
-        bs.shared_borrow(r1).expect("can borrow r1");
-        assert!(bs.mut_borrow(r2).is_err(), "cant mut borrow r2");
-        bs.shared_borrow(r2).expect("can shared borrow r2");
-
-        let mut bs = InnerBorrowChecker::new();
-        let r1 = Region::new(0, 10);
-        let r2 = Region::new(2, 5);
-        assert!(r1.overlaps(r2));
-        bs.shared_borrow(r1).expect("can borrow r1");
-        assert!(bs.mut_borrow(r2).is_err(), "cant borrow r2");
-        bs.shared_borrow(r2).expect("can shared borrow r2");
-
-        let mut bs = InnerBorrowChecker::new();
-        let r1 = Region::new(9, 10);
-        let r2 = Region::new(0, 10);
-        assert!(r1.overlaps(r2));
-        bs.shared_borrow(r1).expect("can borrow r1");
-        assert!(bs.mut_borrow(r2).is_err(), "cant borrow r2");
-        bs.shared_borrow(r2).expect("can shared borrow r2");
-
-        let mut bs = InnerBorrowChecker::new();
-        let r1 = Region::new(2, 5);
-        let r2 = Region::new(0, 10);
-        assert!(r1.overlaps(r2));
-        bs.shared_borrow(r1).expect("can borrow r1");
-        assert!(bs.mut_borrow(r2).is_err(), "cant borrow r2");
-        bs.shared_borrow(r2).expect("can shared borrow r2");
-
-        let mut bs = InnerBorrowChecker::new();
-        let r1 = Region::new(2, 5);
-        let r2 = Region::new(10, 5);
-        let r3 = Region::new(15, 5);
-        let r4 = Region::new(0, 10);
-        assert!(r1.overlaps(r4));
-        bs.shared_borrow(r1).expect("can borrow r1");
-        bs.shared_borrow(r2).expect("can borrow r2");
-        bs.shared_borrow(r3).expect("can borrow r3");
-        assert!(bs.mut_borrow(r4).is_err(), "cant mut borrow r4");
-        bs.shared_borrow(r4).expect("can shared borrow r4");
-    }
-
-    #[test]
-    fn unborrowing() {
-        let mut bs = InnerBorrowChecker::new();
-        let r1 = Region::new(0, 10);
-        let r2 = Region::new(10, 10);
-        assert!(!r1.overlaps(r2));
-        assert_eq!(bs.has_outstanding_borrows(), false, "start with no borrows");
-        let h1 = bs.mut_borrow(r1).expect("can borrow r1");
-        assert_eq!(bs.has_outstanding_borrows(), true, "h1 is outstanding");
-        let h2 = bs.mut_borrow(r2).expect("can borrow r2");
-
-        assert!(bs.mut_borrow(r2).is_err(), "can't borrow r2 twice");
-        bs.mut_unborrow(h2);
-        assert_eq!(
-            bs.has_outstanding_borrows(),
-            true,
-            "h1 is still outstanding"
-        );
-        bs.mut_unborrow(h1);
-        assert_eq!(bs.has_outstanding_borrows(), false, "no remaining borrows");
-
-        let _h3 = bs
-            .mut_borrow(r2)
-            .expect("can borrow r2 again now that its been unborrowed");
-
-        // Lets try again with shared:
-
-        let mut bs = InnerBorrowChecker::new();
-        let r1 = Region::new(0, 10);
-        let r2 = Region::new(10, 10);
-        assert!(!r1.overlaps(r2));
-        assert_eq!(bs.has_outstanding_borrows(), false, "start with no borrows");
-        let h1 = bs.shared_borrow(r1).expect("can borrow r1");
-        assert_eq!(bs.has_outstanding_borrows(), true, "h1 is outstanding");
-        let h2 = bs.shared_borrow(r2).expect("can borrow r2");
-        let h3 = bs.shared_borrow(r2).expect("can shared borrow r2 twice");
-
-        bs.shared_unborrow(h2);
-        assert_eq!(
-            bs.has_outstanding_borrows(),
-            true,
-            "h1, h3 still outstanding"
-        );
-        bs.shared_unborrow(h1);
-        bs.shared_unborrow(h3);
-        assert_eq!(bs.has_outstanding_borrows(), false, "no remaining borrows");
-    }
-}
diff --git a/crates/wiggle/src/guest_type.rs b/crates/wiggle/src/guest_type.rs
index 4464347cbf33..45bf01ec800c 100644
--- a/crates/wiggle/src/guest_type.rs
+++ b/crates/wiggle/src/guest_type.rs
@@ -1,4 +1,5 @@
-use crate::{GuestError, GuestPtr};
+use crate::{GuestError, GuestMemory, GuestPtr};
+use std::cell::UnsafeCell;
 use std::mem;
 use std::sync::atomic::{
     AtomicI16, AtomicI32, AtomicI64, AtomicI8, AtomicU16, AtomicU32, AtomicU64, AtomicU8, Ordering,
@@ -7,9 +8,9 @@ use std::sync::atomic::{
 /// A trait for types which are used to report errors. Each type used in the
 /// first result position of an interface function is used, by convention, to
 /// indicate whether the function was successful and subsequent results are valid,
-/// or whether an error occured. This trait allows wiggle to return the correct
+/// or whether an error occurred. This trait allows wiggle to return the correct
 /// value when the interface function's idiomatic Rust method returns
-/// Ok(<rest of return values>).
+/// `Ok(<rest of return values>)`.
 pub trait GuestErrorType {
     fn success() -> Self;
 }
@@ -21,7 +22,7 @@ pub trait GuestErrorType {
 /// abstraction allows the guest representation of a type to be different from
 /// the host representation of a type, if necessary. It also allows for
 /// validation when reading/writing.
-pub trait GuestType<'a>: Sized {
+pub trait GuestType: Sized {
     /// Returns the size, in bytes, of this type in the guest memory.
     fn guest_size() -> u32;
 
@@ -37,14 +38,14 @@ pub trait GuestType<'a>: Sized {
     /// Typically if you're implementing this by hand you'll want to delegate to
     /// other safe implementations of this trait (e.g. for primitive types like
     /// `u32`) rather than writing lots of raw code yourself.
-    fn read(ptr: &GuestPtr<'a, Self>) -> Result<Self, GuestError>;
+    fn read(mem: &GuestMemory, ptr: GuestPtr<Self>) -> Result<Self, GuestError>;
 
     /// Writes a value to `ptr` after verifying that `ptr` is indeed valid to
     /// store `val`.
     ///
     /// Similar to `read`, you'll probably want to implement this in terms of
     /// other primitives.
-    fn write(ptr: &GuestPtr<'_, Self>, val: Self) -> Result<(), GuestError>;
+    fn write(mem: &mut GuestMemory, ptr: GuestPtr<Self>, val: Self) -> Result<(), GuestError>;
 }
 
 /// A trait for `GuestType`s that have the same representation in guest memory
@@ -56,43 +57,35 @@ pub trait GuestType<'a>: Sized {
 /// representation on the host matches the guest and all bit patterns are
 /// valid. This trait should only ever be implemented by
 /// wiggle_generate-produced code.
-pub unsafe trait GuestTypeTransparent<'a>: GuestType<'a> {}
+pub unsafe trait GuestTypeTransparent: GuestType {}
 
 macro_rules! integer_primitives {
     ($([$ty:ident, $ty_atomic:ident],)*) => ($(
-        impl<'a> GuestType<'a> for $ty {
+        impl GuestType for $ty {
             #[inline]
             fn guest_size() -> u32 { mem::size_of::<Self>() as u32 }
             #[inline]
             fn guest_align() -> usize { mem::align_of::<Self>() }
 
             #[inline]
-            fn read(ptr: &GuestPtr<'a, Self>) -> Result<Self, GuestError> {
+            fn read(mem: &GuestMemory, ptr: GuestPtr<Self>) -> Result<Self, GuestError> {
                 // Use `validate_size_align` to validate offset and alignment
                 // internally. The `host_ptr` type will be `&UnsafeCell<Self>`
                 // indicating that the memory is valid, and next safety checks
                 // are required to access it.
                 let offset = ptr.offset();
-                let (host_ptr, region) = super::validate_size_align::<Self>(ptr.mem(), offset, 1)?;
-                let host_ptr = &host_ptr[0];
-
-                // If this memory is mutable borrowed then it cannot be read
-                // here, so skip this operation.
-                //
-                // Note that shared memories don't allow borrows and other
-                // shared borrows are ok to overlap with this.
-                if ptr.mem().is_mut_borrowed(region) {
-                    return Err(GuestError::PtrBorrowed(region));
-                }
+                let host_ptr = mem.validate_size_align::<Self>(offset, 1)?;
 
                 // If the accessed memory is shared, we need to load the bytes
                 // with the correct memory consistency. We could check if the
                 // memory is shared each time, but we expect little performance
                 // difference between an additional branch and a relaxed memory
                 // access and thus always do the relaxed access here.
-                let atomic_value_ref: &$ty_atomic =
-                    unsafe { &*(host_ptr.get().cast::<$ty_atomic>()) };
-                let val = atomic_value_ref.load(Ordering::Relaxed);
+                let host_ptr: &$ty_atomic = unsafe {
+                    let host_ptr: &UnsafeCell<Self> = &host_ptr[0];
+                    &*((host_ptr as *const UnsafeCell<Self>).cast::<$ty_atomic>())
+                };
+                let val = host_ptr.load(Ordering::Relaxed);
 
                 // And as a final operation convert from the little-endian wasm
                 // value to a native-endian value for the host.
@@ -100,15 +93,12 @@ macro_rules! integer_primitives {
             }
 
             #[inline]
-            fn write(ptr: &GuestPtr<'_, Self>, val: Self) -> Result<(), GuestError> {
+            fn write(mem: &mut GuestMemory, ptr: GuestPtr<Self>, val: Self) -> Result<(), GuestError> {
                 // See `read` above for various checks here.
                 let val = val.to_le();
                 let offset = ptr.offset();
-                let (host_ptr, region) = super::validate_size_align::<Self>(ptr.mem(), offset, 1)?;
+                let host_ptr = mem.validate_size_align::<Self>(offset, 1)?;
                 let host_ptr = &host_ptr[0];
-                if ptr.mem().is_shared_borrowed(region) || ptr.mem().is_mut_borrowed(region) {
-                    return Err(GuestError::PtrBorrowed(region));
-                }
                 let atomic_value_ref: &$ty_atomic =
                     unsafe { &*(host_ptr.get().cast::<$ty_atomic>()) };
                 atomic_value_ref.store(val, Ordering::Relaxed);
@@ -116,60 +106,31 @@ macro_rules! integer_primitives {
             }
         }
 
-        unsafe impl<'a> GuestTypeTransparent<'a> for $ty {}
+        unsafe impl GuestTypeTransparent for $ty {}
 
     )*)
 }
 
 macro_rules! float_primitives {
     ($([$ty:ident, $ty_unsigned:ident, $ty_atomic:ident],)*) => ($(
-        impl<'a> GuestType<'a> for $ty {
+        impl GuestType for $ty {
             #[inline]
             fn guest_size() -> u32 { mem::size_of::<Self>() as u32 }
             #[inline]
             fn guest_align() -> usize { mem::align_of::<Self>() }
 
             #[inline]
-            fn read(ptr: &GuestPtr<'a, Self>) -> Result<Self, GuestError> {
-                // For more commentary see `read` for integers
-                let offset = ptr.offset();
-                let (host_ptr, region) = super::validate_size_align::<$ty_unsigned>(
-                    ptr.mem(),
-                    offset,
-                    1,
-                )?;
-                let host_ptr = &host_ptr[0];
-                if ptr.mem().is_mut_borrowed(region) {
-                    return Err(GuestError::PtrBorrowed(region));
-                }
-                let atomic_value_ref: &$ty_atomic =
-                    unsafe { &*(host_ptr.get().cast::<$ty_atomic>()) };
-                let value = $ty_unsigned::from_le(atomic_value_ref.load(Ordering::Relaxed));
-                Ok($ty::from_bits(value))
+            fn read(mem: &GuestMemory, ptr: GuestPtr<Self>) -> Result<Self, GuestError> {
+                <$ty_unsigned as GuestType>::read(mem, ptr.cast()).map($ty::from_bits)
             }
 
             #[inline]
-            fn write(ptr: &GuestPtr<'_, Self>, val: Self) -> Result<(), GuestError> {
-                // For more commentary see `read`/`write` for integers.
-                let offset = ptr.offset();
-                let (host_ptr, region) = super::validate_size_align::<$ty_unsigned>(
-                    ptr.mem(),
-                    offset,
-                    1,
-                )?;
-                let host_ptr = &host_ptr[0];
-                if ptr.mem().is_shared_borrowed(region) || ptr.mem().is_mut_borrowed(region) {
-                    return Err(GuestError::PtrBorrowed(region));
-                }
-                let atomic_value_ref: &$ty_atomic =
-                    unsafe { &*(host_ptr.get().cast::<$ty_atomic>()) };
-                let le_value = $ty_unsigned::to_le(val.to_bits());
-                atomic_value_ref.store(le_value, Ordering::Relaxed);
-                Ok(())
+            fn write(mem:&mut GuestMemory, ptr: GuestPtr<Self>, val: Self) -> Result<(), GuestError> {
+                <$ty_unsigned as GuestType>::write(mem, ptr.cast(), val.to_bits())
             }
         }
 
-        unsafe impl<'a> GuestTypeTransparent<'a> for $ty {}
+        unsafe impl GuestTypeTransparent for $ty {}
 
     )*)
 }
@@ -186,7 +147,7 @@ float_primitives! {
 }
 
 // Support pointers-to-pointers where pointers are always 32-bits in wasm land
-impl<'a, T> GuestType<'a> for GuestPtr<'a, T> {
+impl<T> GuestType for GuestPtr<T> {
     #[inline]
     fn guest_size() -> u32 {
         u32::guest_size()
@@ -197,20 +158,20 @@ impl<'a, T> GuestType<'a> for GuestPtr<'a, T> {
         u32::guest_align()
     }
 
-    fn read(ptr: &GuestPtr<'a, Self>) -> Result<Self, GuestError> {
-        let offset = ptr.cast::<u32>().read()?;
-        Ok(GuestPtr::new(ptr.mem(), offset))
+    fn read(mem: &GuestMemory, ptr: GuestPtr<Self>) -> Result<Self, GuestError> {
+        let offset = u32::read(mem, ptr.cast())?;
+        Ok(GuestPtr::new(offset))
     }
 
-    fn write(ptr: &GuestPtr<'_, Self>, val: Self) -> Result<(), GuestError> {
-        ptr.cast::<u32>().write(val.offset())
+    fn write(mem: &mut GuestMemory, ptr: GuestPtr<Self>, val: Self) -> Result<(), GuestError> {
+        u32::write(mem, ptr.cast(), val.offset())
     }
 }
 
 // Support pointers-to-arrays where pointers are always 32-bits in wasm land
-impl<'a, T> GuestType<'a> for GuestPtr<'a, [T]>
+impl<T> GuestType for GuestPtr<[T]>
 where
-    T: GuestType<'a>,
+    T: GuestType,
 {
     #[inline]
     fn guest_size() -> u32 {
@@ -222,16 +183,18 @@ where
         u32::guest_align()
     }
 
-    fn read(ptr: &GuestPtr<'a, Self>) -> Result<Self, GuestError> {
-        let offset = ptr.cast::<u32>().read()?;
-        let len = ptr.cast::<u32>().add(1)?.read()?;
-        Ok(GuestPtr::new(ptr.mem(), offset).as_array(len))
+    fn read(mem: &GuestMemory, ptr: GuestPtr<Self>) -> Result<Self, GuestError> {
+        let ptr = ptr.cast::<u32>();
+        let offset = u32::read(mem, ptr)?;
+        let len = u32::read(mem, ptr.add(1)?)?;
+        Ok(GuestPtr::new(offset).as_array(len))
     }
 
-    fn write(ptr: &GuestPtr<'_, Self>, val: Self) -> Result<(), GuestError> {
-        let (offs, len) = val.offset();
-        let len_ptr = ptr.cast::<u32>().add(1)?;
-        ptr.cast::<u32>().write(offs)?;
-        len_ptr.write(len)
+    fn write(mem: &mut GuestMemory, ptr: GuestPtr<Self>, val: Self) -> Result<(), GuestError> {
+        let (offset, len) = val.offset();
+        let ptr = ptr.cast::<u32>();
+        u32::write(mem, ptr, offset)?;
+        u32::write(mem, ptr.add(1)?, len)?;
+        Ok(())
     }
 }
diff --git a/crates/wiggle/src/lib.rs b/crates/wiggle/src/lib.rs
index 7bad7f20ee07..a7f4bed304cc 100644
--- a/crates/wiggle/src/lib.rs
+++ b/crates/wiggle/src/lib.rs
@@ -1,10 +1,10 @@
 use anyhow::{bail, Result};
+use std::borrow::Cow;
 use std::cell::UnsafeCell;
 use std::fmt;
 use std::mem;
-use std::slice;
+use std::ops::Range;
 use std::str;
-use std::sync::Arc;
 
 pub use wiggle_macro::{async_trait, from_witx};
 
@@ -16,12 +16,11 @@ pub use bitflags;
 #[cfg(feature = "wiggle_metadata")]
 pub use witx;
 
-pub mod borrow;
 mod error;
 mod guest_type;
 mod region;
 
-pub extern crate tracing;
+pub use tracing;
 
 pub use error::GuestError;
 pub use guest_type::{GuestErrorType, GuestType, GuestTypeTransparent};
@@ -31,318 +30,309 @@ pub mod async_trait_crate {
     pub use async_trait::*;
 }
 
-pub mod wasmtime;
+#[cfg(feature = "wasmtime")]
 pub mod wasmtime_crate {
     pub use wasmtime::*;
 }
 
-/// A trait which abstracts how to get at the region of host memory that
-/// contains guest memory.
+/// Representation of guest memory for `wiggle`-generated trait methods.
 ///
-/// All `GuestPtr` types will contain a handle to this trait, signifying where
-/// the pointer is actually pointing into. This type will need to be implemented
-/// for the host's memory storage object.
+/// Guest memory is represented as an array of bytes. Memories are either
+/// "unshared" or "shared". Unshared means that the host has exclusive access to
+/// the entire array of memory. This allows safe borrows into wasm linear
+/// memory. Shared memories can be modified at any time and are represented as
+/// an array of `UnsafeCell<u8>`.
 ///
-/// # Safety
-///
-/// Safety around this type is tricky, and the trait is `unsafe` since there are
-/// a few contracts you need to uphold to implement this type correctly and have
-/// everything else in this crate work out safely.
-///
-/// The most important method of this trait is the `base` method. This returns,
-/// in host memory, a pointer and a length. The pointer should point to valid
-/// memory for the guest to read/write for the length contiguous bytes
-/// afterwards.
-///
-/// The region returned by `base` must not only be valid, however, but it must
-/// be valid for "a period of time before the guest is reentered". This isn't
-/// exactly well defined but the general idea is that `GuestMemory` is allowed
-/// to change under our feet to accommodate instructions like `memory.grow` or
-/// other guest modifications. Memory, however, cannot be changed if the guest
-/// is not reentered or if no explicitly action is taken to modify the guest
-/// memory.
-///
-/// This provides the guarantee that host pointers based on the return value of
-/// `base` have a dynamic period for which they are valid. This time duration
-/// must be "somehow nonzero in length" to allow users of `GuestMemory` and
-/// `GuestPtr` to safely read and write interior data.
-///
-/// This type also provides methods for run-time borrow checking of references
-/// into the memory. The safety of this mechanism depends on there being exactly
-/// one associated tracking of borrows for a given WebAssembly memory. There
-/// must be no other reads or writes of WebAssembly the memory by either Rust or
-/// WebAssembly code while there are any outstanding borrows, as given by
-/// `GuestMemory::has_outstanding_borrows()`.
-///
-/// # Using References
-///
-/// The [`GuestPtr::as_slice`] or [`GuestPtr::as_str`] will return smart
-/// pointers [`GuestSlice`] and [`GuestStr`]. These types, which implement
-/// [`std::ops::Deref`] and [`std::ops::DerefMut`], provide mutable references
-/// into the memory region given by a `GuestMemory`.
-///
-/// These smart pointers are dynamically borrow-checked by the borrow checker
-/// methods on this trait. While a `GuestSlice` or a `GuestStr` are live, the
-/// [`GuestMemory::has_outstanding_borrows()`] method will always return `true`.
-/// If you need to re-enter the guest or otherwise read or write to the contents
-/// of a WebAssembly memory, all `GuestSlice`s and `GuestStr`s for the memory
-/// must be dropped, at which point `GuestMemory::has_outstanding_borrows()`
-/// will return `false`.
-pub unsafe trait GuestMemory: Send + Sync {
-    /// Returns the base allocation of this guest memory, located in host
-    /// memory.
+/// This is generated by the `wiggle` bindings macros.
+pub enum GuestMemory<'a> {
+    Unshared(&'a mut [u8]),
+    Shared(&'a [UnsafeCell<u8>]),
+}
+
+// manual impls are needed because of the `UnsafeCell` in the `Shared` branch
+// but this otherwise upholds send/sync invariants.
+unsafe impl Send for GuestMemory<'_> {}
+unsafe impl Sync for GuestMemory<'_> {}
+
+impl<'a> GuestMemory<'a> {
+    /// Read a value from the provided pointer.
+    ///
+    /// This method will delegate to `T`'s implementation of `read` which will
+    /// read a value from the `ptr` provided.
     ///
-    /// A pointer/length pair are returned to signify where the guest memory
-    /// lives in the host, and how many contiguous bytes the memory is valid for
-    /// after the returned pointer.
+    /// # Errors
     ///
-    /// Note that there are safety guarantees about this method that
-    /// implementations must uphold, and for more details see the
-    /// [`GuestMemory`] documentation.
-    fn base(&self) -> &[UnsafeCell<u8>];
+    /// An error is returned if `ptr` is out of bounds, misaligned, or otherwise
+    /// not valid to read from.
+    pub fn read<T>(&self, ptr: GuestPtr<T>) -> Result<T, GuestError>
+    where
+        T: GuestType,
+    {
+        T::read(self, ptr)
+    }
 
-    /// Convenience method for creating a `GuestPtr` at a particular offset.
+    /// Writes the `val` provided to the `ptr` provided.
     ///
-    /// Note that `T` can be almost any type, and typically `offset` is a `u32`.
-    /// The exception is slices and strings, in which case `offset` is a `(u32,
-    /// u32)` of `(offset, length)`.
-    fn ptr<'a, T>(&'a self, offset: T::Pointer) -> GuestPtr<'a, T>
+    /// This commit will write a `val` into a guest's linear memory. This will
+    /// delegate to `T`'s implementation of `write`.
+    ///
+    /// # Errors
+    ///
+    /// An error is returned if `ptr` is out of bounds, misaligned, or otherwise
+    /// not valid to read from.
+    pub fn write<T>(&mut self, ptr: GuestPtr<T>, val: T) -> Result<(), GuestError>
     where
-        Self: Sized,
-        T: ?Sized + Pointee,
+        T: GuestType,
     {
-        GuestPtr::new(self, offset)
+        T::write(self, ptr, val)
     }
 
-    /// Indicates whether any outstanding borrows are known to the
-    /// `GuestMemory`. This function must be `false` in order for it to be
-    /// safe to recursively call into a WebAssembly module, or to manipulate
-    /// the WebAssembly memory by any other means.
-    fn has_outstanding_borrows(&self) -> bool;
-    /// Check if a region of linear memory is exclusively borrowed. This is called during any
-    /// `GuestPtr::read` or `GuestPtr::write` operation to ensure that wiggle is not reading or
-    /// writing a region of memory which Rust believes it has exclusive access to.
-    fn is_mut_borrowed(&self, r: Region) -> bool;
-    /// Check if a region of linear memory has any shared borrows.
-    fn is_shared_borrowed(&self, r: Region) -> bool;
-    /// Exclusively borrow a region of linear memory. This is used when constructing a
-    /// `GuestSliceMut` or `GuestStrMut`. Those types will give Rust `&mut` access
-    /// to the region of linear memory, therefore, the `GuestMemory` impl must
-    /// guarantee that at most one `BorrowHandle` is issued to a given region,
-    /// `GuestMemory::has_outstanding_borrows` is true for the duration of the
-    /// borrow, and that `GuestMemory::is_mut_borrowed` of any overlapping region
-    /// is false for the duration of the borrow.
-    fn mut_borrow(&self, r: Region) -> Result<BorrowHandle, GuestError>;
-    /// Shared borrow a region of linear memory. This is used when constructing a
-    /// `GuestSlice` or `GuestStr`. Those types will give Rust `&` (shared reference) access
-    /// to the region of linear memory.
-    fn shared_borrow(&self, r: Region) -> Result<BorrowHandle, GuestError>;
-    /// Unborrow a previously borrowed mutable region. As long as `GuestSliceMut` and
-    /// `GuestStrMut` are implemented correctly, a mut `BorrowHandle` should only be
-    /// unborrowed once.
-    fn mut_unborrow(&self, h: BorrowHandle);
-    /// Unborrow a previously borrowed shared region. As long as `GuestSlice` and
-    /// `GuestStr` are implemented correctly, a shared `BorrowHandle` should only be
-    /// unborrowed once.
-    fn shared_unborrow(&self, h: BorrowHandle);
+    /// Acquires a slice or owned copy of the memory pointed to by `ptr`.
+    ///
+    /// This method will attempt to borrow `ptr` directly from linear memory. If
+    /// memory is shared and cannot be borrowed directly then an owned copy is
+    /// returned instead.
+    ///
+    /// # Errors
+    ///
+    /// An error is returned if `ptr` is out of bounds, misaligned, or otherwise
+    /// not valid to read from.
+    pub fn as_cow(&self, ptr: GuestPtr<[u8]>) -> Result<Cow<'_, [u8]>, GuestError> {
+        match self {
+            GuestMemory::Unshared(_) => match self.as_slice(ptr)? {
+                Some(slice) => Ok(Cow::Borrowed(slice)),
+                None => unreachable!(),
+            },
+            GuestMemory::Shared(_) => Ok(Cow::Owned(self.to_vec(ptr)?)),
+        }
+    }
 
-    /// Check if the underlying memory is shared across multiple threads; e.g.,
-    /// with a WebAssembly shared memory.
-    fn is_shared_memory(&self) -> bool {
-        false
+    /// Same as [`GuestMemory::as_cow`] but for strings.
+    ///
+    /// # Errors
+    ///
+    /// An error is returned if `ptr` is out of bounds, misaligned, or otherwise
+    /// not valid to read from.
+    pub fn as_cow_str(&self, ptr: GuestPtr<str>) -> Result<Cow<'_, str>, GuestError> {
+        match self.as_cow(ptr.cast::<[u8]>())? {
+            Cow::Owned(bytes) => Ok(Cow::Owned(
+                String::from_utf8(bytes).map_err(|e| e.utf8_error())?,
+            )),
+            Cow::Borrowed(bytes) => Ok(Cow::Borrowed(std::str::from_utf8(bytes)?)),
+        }
     }
-}
 
-/// Validates a guest-relative pointer given various attributes, and returns
-/// the corresponding host pointer.
-///
-/// * `mem` - this is the guest memory being accessed.
-/// * `offset` - this is the guest-relative pointer, an offset from the
-///   base.
-/// * `len` - this is the number of length, in units of `T`, to return
-///   in the resulting slice.
-///
-/// If the parameters are valid then this function will return a slice into
-/// `mem` for units of `T`, assuming everything is in-bounds and properly
-/// aligned. Additionally the byte-based `Region` is returned, used for borrows
-/// later on.
-fn validate_size_align<'a, T: GuestTypeTransparent<'a>>(
-    mem: &'a dyn GuestMemory,
-    offset: u32,
-    len: u32,
-) -> Result<(&[UnsafeCell<T>], Region), GuestError> {
-    let base = mem.base();
-    let byte_len = len
-        .checked_mul(T::guest_size())
-        .ok_or(GuestError::PtrOverflow)?;
-    let region = Region {
-        start: offset,
-        len: byte_len,
-    };
-    let offset = usize::try_from(offset)?;
-    let byte_len = usize::try_from(byte_len)?;
+    /// Attempts to borrow a raw guest slice of memory pointed to by `ptr`.
+    ///
+    /// This method will attempt to return a raw pointer into guest memory. This
+    /// can only be done for `Unshared` memories. A `Shared` memory will return
+    /// `Ok(None)` here.
+    ///
+    /// # Errors
+    ///
+    /// An error is returned if `ptr` is out of bounds, misaligned, or otherwise
+    /// not valid to read from.
+    pub fn as_slice(&self, ptr: GuestPtr<[u8]>) -> Result<Option<&[u8]>, GuestError> {
+        let range = self.validate_range::<u8>(ptr.pointer.0, ptr.pointer.1)?;
+        match self {
+            GuestMemory::Unshared(slice) => Ok(Some(&slice[range])),
+            GuestMemory::Shared(_) => Ok(None),
+        }
+    }
 
-    // Slice the input region to the byte range that we're interested in.
-    let bytes = base
-        .get(offset..)
-        .and_then(|s| s.get(..byte_len))
-        .ok_or(GuestError::PtrOutOfBounds(region))?;
+    /// Same as [`GuestMemory::as_slice`] but for strings.
+    pub fn as_str(&self, ptr: GuestPtr<str>) -> Result<Option<&str>, GuestError> {
+        match self.as_slice(ptr.cast())? {
+            Some(bytes) => Ok(Some(std::str::from_utf8(bytes)?)),
+            None => Ok(None),
+        }
+    }
 
-    // ... and then align it to `T`, failing if either the head or tail slices
-    // are nonzero in length. This `unsafe` here is from the standard library
-    // and should be ok since the input slice is `UnsafeCell<u8>` and the output
-    // slice is `UnsafeCell<T>`, meaning the only guarantee of the output is
-    // that it's valid addressable memory, still unsafe to actually access.
-    assert!(mem::align_of::<T>() <= T::guest_align());
-    let (start, mid, end) = unsafe { bytes.align_to() };
-    if start.len() > 0 || end.len() > 0 {
-        return Err(GuestError::PtrNotAligned(region, T::guest_align() as u32));
+    /// Attempts return `ptr` as a raw slice of mutable bytes in wasm linear
+    /// memory.
+    ///
+    /// Like [`GuestMemory::as_slice`] this only works for `Unshared` memories
+    /// and will not work for `Shared` memories.
+    pub fn as_slice_mut(&mut self, ptr: GuestPtr<[u8]>) -> Result<Option<&mut [u8]>, GuestError> {
+        let range = self.validate_range::<u8>(ptr.pointer.0, ptr.pointer.1)?;
+        match self {
+            GuestMemory::Unshared(slice) => Ok(Some(&mut slice[range])),
+            GuestMemory::Shared(_) => Ok(None),
+        }
     }
-    Ok((mid, region))
-}
 
-/// A handle to a borrow on linear memory. It is produced by `{mut, shared}_borrow` and
-/// consumed by `{mut, shared}_unborrow`. Only the `GuestMemory` impl should ever construct
-/// a `BorrowHandle` or inspect its contents.
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub struct BorrowHandle(pub usize);
+    /// Copies the data in the guest region into a [`Vec`].
+    ///
+    /// This is useful when one cannot use [`GuestMemory::as_slice`], e.g., when
+    /// pointing to a region of WebAssembly shared memory.
+    pub fn to_vec<T>(&self, ptr: GuestPtr<[T]>) -> Result<Vec<T>, GuestError>
+    where
+        T: GuestTypeTransparent + Copy,
+    {
+        let guest = self.validate_size_align::<T>(ptr.pointer.0, ptr.pointer.1)?;
+        let mut host = Vec::with_capacity(guest.len());
 
-// Forwarding trait implementations to the original type
-unsafe impl<'a, T: ?Sized + GuestMemory> GuestMemory for &'a T {
-    fn base(&self) -> &[UnsafeCell<u8>] {
-        T::base(self)
-    }
-    fn has_outstanding_borrows(&self) -> bool {
-        T::has_outstanding_borrows(self)
-    }
-    fn is_mut_borrowed(&self, r: Region) -> bool {
-        T::is_mut_borrowed(self, r)
-    }
-    fn is_shared_borrowed(&self, r: Region) -> bool {
-        T::is_shared_borrowed(self, r)
-    }
-    fn mut_borrow(&self, r: Region) -> Result<BorrowHandle, GuestError> {
-        T::mut_borrow(self, r)
-    }
-    fn shared_borrow(&self, r: Region) -> Result<BorrowHandle, GuestError> {
-        T::shared_borrow(self, r)
-    }
-    fn mut_unborrow(&self, h: BorrowHandle) {
-        T::mut_unborrow(self, h)
-    }
-    fn shared_unborrow(&self, h: BorrowHandle) {
-        T::shared_unborrow(self, h)
+        // SAFETY: The `guest_slice` variable is already a valid pointer into
+        // the guest's memory, and it may or may not be a pointer into shared
+        // memory. We can't naively use `.to_vec(..)` which could introduce data
+        // races but all that needs to happen is to copy data into our local
+        // `vec` as all the data is `Copy` and transparent anyway. For this
+        // purpose the `ptr::copy` function should be sufficient for copying
+        // over all the data.
+        //
+        // TODO: audit that this use of `std::ptr::copy` is safe with shared
+        // memory (https://github.com/bytecodealliance/wasmtime/issues/4203)
+        unsafe {
+            std::ptr::copy(guest.as_ptr().cast(), host.as_mut_ptr(), guest.len());
+            host.set_len(guest.len());
+        }
+        Ok(host)
     }
-}
 
-unsafe impl<'a, T: ?Sized + GuestMemory> GuestMemory for &'a mut T {
-    fn base(&self) -> &[UnsafeCell<u8>] {
-        T::base(self)
-    }
-    fn has_outstanding_borrows(&self) -> bool {
-        T::has_outstanding_borrows(self)
-    }
-    fn is_mut_borrowed(&self, r: Region) -> bool {
-        T::is_mut_borrowed(self, r)
-    }
-    fn is_shared_borrowed(&self, r: Region) -> bool {
-        T::is_shared_borrowed(self, r)
-    }
-    fn mut_borrow(&self, r: Region) -> Result<BorrowHandle, GuestError> {
-        T::mut_borrow(self, r)
-    }
-    fn shared_borrow(&self, r: Region) -> Result<BorrowHandle, GuestError> {
-        T::shared_borrow(self, r)
-    }
-    fn mut_unborrow(&self, h: BorrowHandle) {
-        T::mut_unborrow(self, h)
-    }
-    fn shared_unborrow(&self, h: BorrowHandle) {
-        T::shared_unborrow(self, h)
-    }
-}
+    /// Copies the data pointed to by `slice` into this guest region.
+    ///
+    /// This method is a *safe* method to copy data from the host to the guest.
+    /// This requires that `self` and `slice` have the same length. The pointee
+    /// type `T` requires the [`GuestTypeTransparent`] trait which is an
+    /// assertion that the representation on the host and on the guest is the
+    /// same.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if this guest pointer is out of bounds or if the length
+    /// of this guest pointer is not equal to the length of the slice provided.
+    pub fn copy_from_slice<T>(&mut self, slice: &[T], ptr: GuestPtr<[T]>) -> Result<(), GuestError>
+    where
+        T: GuestTypeTransparent + Copy,
+    {
+        if usize::try_from(ptr.len())? != slice.len() {
+            return Err(GuestError::SliceLengthsDiffer);
+        }
+        if slice.is_empty() {
+            return Ok(());
+        }
 
-unsafe impl<T: ?Sized + GuestMemory> GuestMemory for Box<T> {
-    fn base(&self) -> &[UnsafeCell<u8>] {
-        T::base(self)
-    }
-    fn has_outstanding_borrows(&self) -> bool {
-        T::has_outstanding_borrows(self)
-    }
-    fn is_mut_borrowed(&self, r: Region) -> bool {
-        T::is_mut_borrowed(self, r)
-    }
-    fn is_shared_borrowed(&self, r: Region) -> bool {
-        T::is_shared_borrowed(self, r)
-    }
-    fn mut_borrow(&self, r: Region) -> Result<BorrowHandle, GuestError> {
-        T::mut_borrow(self, r)
-    }
-    fn shared_borrow(&self, r: Region) -> Result<BorrowHandle, GuestError> {
-        T::shared_borrow(self, r)
-    }
-    fn mut_unborrow(&self, h: BorrowHandle) {
-        T::mut_unborrow(self, h)
-    }
-    fn shared_unborrow(&self, h: BorrowHandle) {
-        T::shared_unborrow(self, h)
-    }
-}
+        let guest = self.validate_size_align::<T>(ptr.pointer.0, ptr.pointer.1)?;
 
-unsafe impl<T: ?Sized + GuestMemory> GuestMemory for Arc<T> {
-    fn base(&self) -> &[UnsafeCell<u8>] {
-        T::base(self)
-    }
-    fn has_outstanding_borrows(&self) -> bool {
-        T::has_outstanding_borrows(self)
-    }
-    fn is_mut_borrowed(&self, r: Region) -> bool {
-        T::is_mut_borrowed(self, r)
-    }
-    fn is_shared_borrowed(&self, r: Region) -> bool {
-        T::is_shared_borrowed(self, r)
-    }
-    fn mut_borrow(&self, r: Region) -> Result<BorrowHandle, GuestError> {
-        T::mut_borrow(self, r)
+        // SAFETY: in the shared memory case, we copy and accept that
+        // the guest data may be concurrently modified. TODO: audit that
+        // this use of `std::ptr::copy` is safe with shared memory
+        // (https://github.com/bytecodealliance/wasmtime/issues/4203)
+        //
+        // Also note that the validity of `guest_slice` has already been
+        // determined by the `as_unsafe_slice_mut` call above.
+        assert_eq!(guest.len(), slice.len());
+        unsafe {
+            let guest: &[UnsafeCell<T>] = guest;
+            let guest: *const UnsafeCell<T> = guest.as_ptr();
+            let guest = guest.cast_mut().cast::<T>();
+            std::ptr::copy(slice.as_ptr(), guest, slice.len());
+        }
+        Ok(())
     }
-    fn shared_borrow(&self, r: Region) -> Result<BorrowHandle, GuestError> {
-        T::shared_borrow(self, r)
+
+    /// Validates a guest-relative pointer given various attributes, and returns
+    /// the corresponding host pointer.
+    ///
+    /// * `mem` - this is the guest memory being accessed.
+    /// * `offset` - this is the guest-relative pointer, an offset from the
+    ///   base.
+    /// * `len` - this is the number of length, in units of `T`, to return
+    ///   in the resulting slice.
+    ///
+    /// If the parameters are valid then this function will return a slice into
+    /// `mem` for units of `T`, assuming everything is in-bounds and properly
+    /// aligned. Additionally the byte-based `Region` is returned, used for borrows
+    /// later on.
+    fn validate_size_align<T>(&self, offset: u32, len: u32) -> Result<&[UnsafeCell<T>], GuestError>
+    where
+        T: GuestTypeTransparent,
+    {
+        let range = self.validate_range::<T>(offset, len)?;
+        let cells = match self {
+            GuestMemory::Unshared(s) => {
+                let s: &[u8] = s;
+                unsafe { &*(s as *const [u8] as *const [UnsafeCell<u8>]) }
+            }
+            GuestMemory::Shared(s) => s,
+        };
+        let memory = &cells[range.clone()];
+
+        // ... and then align it to `T`, failing if either the head or tail slices
+        // are nonzero in length. This `unsafe` here is from the standard library
+        // and should be ok since the input slice is `UnsafeCell<u8>` and the output
+        // slice is `UnsafeCell<T>`, meaning the only guarantee of the output is
+        // that it's valid addressable memory, still unsafe to actually access.
+        assert!(mem::align_of::<T>() <= T::guest_align());
+        let (start, mid, end) = unsafe { memory.align_to() };
+        if start.len() > 0 || end.len() > 0 {
+            let region = Region {
+                start: range.start as u32,
+                len: range.len() as u32,
+            };
+            return Err(GuestError::PtrNotAligned(region, T::guest_align() as u32));
+        }
+        Ok(mid)
     }
-    fn mut_unborrow(&self, h: BorrowHandle) {
-        T::mut_unborrow(self, h)
+
+    fn validate_range<T>(&self, offset: u32, len: u32) -> Result<Range<usize>, GuestError>
+    where
+        T: GuestTypeTransparent,
+    {
+        let byte_len = len
+            .checked_mul(T::guest_size())
+            .ok_or(GuestError::PtrOverflow)?;
+        let region = Region {
+            start: offset,
+            len: byte_len,
+        };
+        let offset = usize::try_from(offset)?;
+        let byte_len = usize::try_from(byte_len)?;
+
+        let range = offset..offset + byte_len;
+        let oob = match self {
+            GuestMemory::Unshared(b) => b.get(range.clone()).is_none(),
+            GuestMemory::Shared(b) => b.get(range.clone()).is_none(),
+        };
+        if oob {
+            Err(GuestError::PtrOutOfBounds(region))
+        } else {
+            Ok(range)
+        }
     }
-    fn shared_unborrow(&self, h: BorrowHandle) {
-        T::shared_unborrow(self, h)
+
+    /// Returns whether this is a shared memory or not.
+    pub fn is_shared_memory(&self) -> bool {
+        match self {
+            GuestMemory::Shared(_) => true,
+            GuestMemory::Unshared(_) => false,
+        }
     }
 }
 
-/// A *guest* pointer into host memory.
+/// A *guest* pointer.
 ///
 /// This type represents a pointer from the guest that points into host memory.
-/// Internally a `GuestPtr` contains a handle to its original [`GuestMemory`] as
-/// well as the offset into the memory that the pointer is pointing at.
+/// Internally a `GuestPtr` the offset into the memory that the pointer is
+/// pointing at. At this time this is always a 32-bit offset so this is not
+/// suitable for bindings where wasm has 64-bit addresses.
 ///
 /// Presence of a [`GuestPtr`] does not imply any form of validity. Pointers can
 /// be out-of-bounds, misaligned, etc. It is safe to construct a `GuestPtr` with
 /// any offset at any time. Consider a `GuestPtr<T>` roughly equivalent to `*mut
-/// T`, although there are a few more safety guarantees around this type.
+/// T`.
 ///
 /// ## Slices and Strings
 ///
 /// Note that the type parameter does not need to implement the `Sized` trait,
 /// so you can implement types such as this:
 ///
-/// * `GuestPtr<'_, str>` - a pointer to a guest string. Has the methods
-///   [`GuestPtr::as_str_mut`], which gives a dynamically borrow-checked
-///   `GuestStrMut<'_>`, which `DerefMut`s to a `&mut str`, and
-///   [`GuestPtr::as_str`], which is the shareable version of same.
-/// * `GuestPtr<'_, [T]>` - a pointer to a guest array. Has methods
-///   [`GuestPtr::as_slice_mut`], which gives a dynamically borrow-checked
-///   `GuestSliceMut<'_, T>`, which `DerefMut`s to a `&mut [T]` and
-///   [`GuestPtr::as_slice`], which is the shareable version of same.
+/// * `GuestPtr<str>` - a pointer to a guest string.
+/// * `GuestPtr<[T]>` - a pointer to a guest array.
 ///
-/// Unsized types such as this may have extra methods and won't have methods
-/// like [`GuestPtr::read`] or [`GuestPtr::write`].
+/// Note that generated bindings won't use these types so you'll have to
+/// otherwise construct the types with `.cast()` or `.as_array()`. Unsized types
+/// track both the pointer and length in guest memory.
 ///
 /// ## Type parameter and pointee
 ///
@@ -362,23 +352,23 @@ unsafe impl<T: ?Sized + GuestMemory> GuestMemory for Arc<T> {
 /// similar) and then the bytes loaded are validated to fit within the
 /// definition of `MyEnum` before `MyEnum` is returned.
 ///
-/// For more information see the [`GuestPtr::read`] and [`GuestPtr::write`]
-/// methods. In general though be extremely careful about writing `unsafe` code
-/// when working with a `GuestPtr` if you're not using one of the
-/// already-attached helper methods.
-pub struct GuestPtr<'a, T: ?Sized + Pointee> {
-    mem: &'a (dyn GuestMemory + 'a),
+/// For more information see the [`GuestMemory::read`] and
+/// [`GuestMemory::write`] methods. In general though be extremely careful about
+/// writing `unsafe` code when working with a `GuestPtr` if you're not using one
+/// of the already-attached helper methods.
+#[repr(transparent)]
+pub struct GuestPtr<T: ?Sized + Pointee> {
     pointer: T::Pointer,
 }
 
-impl<'a, T: ?Sized + Pointee> GuestPtr<'a, T> {
+impl<T: ?Sized + Pointee> GuestPtr<T> {
     /// Creates a new `GuestPtr` from the given `mem` and `pointer` values.
     ///
     /// Note that for sized types like `u32`, `GuestPtr<T>`, etc, the `pointer`
     /// value is a `u32` offset into guest memory. For slices and strings,
     /// `pointer` is a `(u32, u32)` offset/length pair.
-    pub fn new(mem: &'a (dyn GuestMemory + 'a), pointer: T::Pointer) -> GuestPtr<'a, T> {
-        GuestPtr { mem, pointer }
+    pub fn new(pointer: T::Pointer) -> GuestPtr<T> {
+        GuestPtr { pointer }
     }
 
     /// Returns the offset of this pointer in guest memory.
@@ -389,69 +379,17 @@ impl<'a, T: ?Sized + Pointee> GuestPtr<'a, T> {
         self.pointer
     }
 
-    /// Returns the guest memory that this pointer is coming from.
-    pub fn mem(&self) -> &'a (dyn GuestMemory + 'a) {
-        self.mem
-    }
-
     /// Casts this `GuestPtr` type to a different type.
     ///
     /// This is a safe method which is useful for simply reinterpreting the type
     /// parameter on this `GuestPtr`. Note that this is a safe method, where
     /// again there's no guarantees about alignment, validity, in-bounds-ness,
     /// etc of the returned pointer.
-    pub fn cast<U>(&self) -> GuestPtr<'a, U>
-    where
-        T: Pointee<Pointer = u32>,
-    {
-        GuestPtr::new(self.mem, self.pointer)
-    }
-
-    /// Safely read a value from this pointer.
-    ///
-    /// This is a fun method, and is one of the lynchpins of this
-    /// implementation. The highlight here is that this is a *safe* operation,
-    /// not an unsafe one like `*mut T`. This works for a few reasons:
-    ///
-    /// * The `unsafe` contract of the `GuestMemory` trait means that there's
-    ///   always at least some backing memory for this `GuestPtr<T>`.
-    ///
-    /// * This does not use Rust-intrinsics to read the type `T`, but rather it
-    ///   delegates to `T`'s implementation of [`GuestType`] to actually read
-    ///   the underlying data. This again is a safe method, so any unsafety, if
-    ///   any, must be internally documented.
-    ///
-    /// * Eventually what typically happens it that this bottoms out in the read
-    ///   implementations for primitives types (like `i32`) which can safely be
-    ///   read at any time, and then it's up to the runtime to determine what to
-    ///   do with the bytes it read in a safe manner.
-    ///
-    /// Naturally lots of things can still go wrong, such as out-of-bounds
-    /// checks, alignment checks, validity checks (e.g. for enums), etc. All of
-    /// these check failures, however, are returned as a [`GuestError`] in the
-    /// `Result` here, and `Ok` is only returned if all the checks passed.
-    pub fn read(&self) -> Result<T, GuestError>
+    pub fn cast<U>(&self) -> GuestPtr<U>
     where
-        T: GuestType<'a>,
+        U: Pointee<Pointer = T::Pointer> + ?Sized,
     {
-        T::read(self)
-    }
-
-    /// Safely write a value to this pointer.
-    ///
-    /// This method, like [`GuestPtr::read`], is pretty crucial for the safe
-    /// operation of this crate. All the same reasons apply though for why this
-    /// method is safe, even eventually bottoming out in primitives like writing
-    /// an `i32` which is safe to write bit patterns into memory at any time due
-    /// to the guarantees of [`GuestMemory`].
-    ///
-    /// Like `read`, `write` can fail due to any manner of pointer checks, but
-    /// any failure is returned as a [`GuestError`].
-    pub fn write(&self, val: T) -> Result<(), GuestError>
-    where
-        T: GuestType<'a>,
-    {
-        T::write(self, val)
+        GuestPtr::new(self.pointer)
     }
 
     /// Performs pointer arithmetic on this pointer, moving the pointer forward
@@ -460,9 +398,9 @@ impl<'a, T: ?Sized + Pointee> GuestPtr<'a, T> {
     /// This will either return the resulting pointer or `Err` if the pointer
     /// arithmetic calculation would overflow around the end of the address
     /// space.
-    pub fn add(&self, amt: u32) -> Result<GuestPtr<'a, T>, GuestError>
+    pub fn add(&self, amt: u32) -> Result<GuestPtr<T>, GuestError>
     where
-        T: GuestType<'a> + Pointee<Pointer = u32>,
+        T: GuestType + Pointee<Pointer = u32>,
     {
         let offset = amt
             .checked_mul(T::guest_size())
@@ -471,25 +409,20 @@ impl<'a, T: ?Sized + Pointee> GuestPtr<'a, T> {
             Some(o) => o,
             None => return Err(GuestError::PtrOverflow),
         };
-        Ok(GuestPtr::new(self.mem, offset))
+        Ok(GuestPtr::new(offset))
     }
 
     /// Returns a `GuestPtr` for an array of `T`s using this pointer as the
     /// base.
-    pub fn as_array(&self, elems: u32) -> GuestPtr<'a, [T]>
+    pub fn as_array(&self, elems: u32) -> GuestPtr<[T]>
     where
-        T: GuestType<'a> + Pointee<Pointer = u32>,
+        T: GuestType + Pointee<Pointer = u32>,
     {
-        GuestPtr::new(self.mem, (self.pointer, elems))
-    }
-
-    /// Check if this pointer references WebAssembly shared memory.
-    pub fn is_shared_memory(&self) -> bool {
-        self.mem.is_shared_memory()
+        GuestPtr::new((self.pointer, elems))
     }
 }
 
-impl<'a, T> GuestPtr<'a, [T]> {
+impl<T> GuestPtr<[T]> {
     /// For slices, specifically returns the relative pointer to the base of the
     /// array.
     ///
@@ -507,157 +440,23 @@ impl<'a, T> GuestPtr<'a, [T]> {
     ///
     /// Each item is a `Result` indicating whether it overflowed past the end of
     /// the address space or not.
-    pub fn iter<'b>(
-        &'b self,
-    ) -> impl ExactSizeIterator<Item = Result<GuestPtr<'a, T>, GuestError>> + 'b
+    pub fn iter(&self) -> impl ExactSizeIterator<Item = Result<GuestPtr<T>, GuestError>> + '_
     where
-        T: GuestType<'a>,
+        T: GuestType,
     {
         let base = self.as_ptr();
         (0..self.len()).map(move |i| base.add(i))
     }
 
-    /// Attempts to create a [`GuestCow<'_, T>`] from this pointer, performing
-    /// bounds checks and type validation. Whereas [`GuestPtr::as_slice`] will
-    /// fail with `None` if attempting to access Wasm shared memory, this call
-    /// will succeed: if used on shared memory, this function will copy the
-    /// slice into [`GuestCow::Copied`]. If the memory is non-shared, this
-    /// returns a [`GuestCow::Borrowed`] (a thin wrapper over [`GuestSlice<'_,
-    /// T>]`).
-    pub fn as_cow(&self) -> Result<GuestCow<'a, T>, GuestError>
-    where
-        T: GuestTypeTransparent<'a> + Copy + 'a,
-    {
-        match self.as_unsafe_slice_mut()?.shared_borrow() {
-            UnsafeBorrowResult::Ok(slice) => Ok(GuestCow::Borrowed(slice)),
-            UnsafeBorrowResult::Shared(_) => Ok(GuestCow::Copied(self.to_vec()?)),
-            UnsafeBorrowResult::Err(e) => Err(e),
-        }
-    }
-
-    /// Attempts to create a [`GuestSlice<'_, T>`] from this pointer, performing
-    /// bounds checks and type validation. The `GuestSlice` is a smart pointer
-    /// that can be used as a `&[T]` via the `Deref` trait. The region of memory
-    /// backing the slice will be marked as shareably borrowed by the
-    /// [`GuestMemory`] until the `GuestSlice` is dropped. Multiple shareable
-    /// borrows of the same memory are permitted, but only one mutable borrow.
-    ///
-    /// This function will return a `GuestSlice` into host memory if all checks
-    /// succeed (valid utf-8, valid pointers, memory is not borrowed, etc.). If
-    /// any checks fail then `GuestError` will be returned.
-    ///
-    /// Additionally, because it is `unsafe` to have a `GuestSlice` of shared
-    /// memory, this function will return `None` in this case (see
-    /// [`GuestPtr::as_cow`]).
-    pub fn as_slice(&self) -> Result<Option<GuestSlice<'a, T>>, GuestError>
-    where
-        T: GuestTypeTransparent<'a>,
-    {
-        match self.as_unsafe_slice_mut()?.shared_borrow() {
-            UnsafeBorrowResult::Ok(slice) => Ok(Some(slice)),
-            UnsafeBorrowResult::Shared(_) => Ok(None),
-            UnsafeBorrowResult::Err(e) => Err(e),
-        }
-    }
-
-    /// Attempts to create a [`GuestSliceMut<'_, T>`] from this pointer,
-    /// performing bounds checks and type validation. The `GuestSliceMut` is a
-    /// smart pointer that can be used as a `&[T]` or a `&mut [T]` via the
-    /// `Deref` and `DerefMut` traits. The region of memory backing the slice
-    /// will be marked as borrowed by the [`GuestMemory`] until the `GuestSlice`
-    /// is dropped.
-    ///
-    /// This function will return a `GuestSliceMut` into host memory if all
-    /// checks succeed (valid utf-8, valid pointers, memory is not borrowed,
-    /// etc). If any checks fail then `GuestError` will be returned.
-    ///
-    /// Additionally, because it is `unsafe` to have a `GuestSliceMut` of shared
-    /// memory, this function will return `None` in this case.
-    pub fn as_slice_mut(&self) -> Result<Option<GuestSliceMut<'a, T>>, GuestError>
-    where
-        T: GuestTypeTransparent<'a>,
-    {
-        self.as_unsafe_slice_mut()?.as_slice_mut()
-    }
-
-    /// Similar to `as_slice_mut`, this function will attempt to create a smart
-    /// pointer to the WebAssembly linear memory. All validation and Wiggle
-    /// borrow checking is the same, but unlike `as_slice_mut`, the returned
-    /// `&mut` slice can point to WebAssembly shared memory. Though the Wiggle
-    /// borrow checker can guarantee no other Wiggle calls will access this
-    /// slice, it cannot guarantee that another thread is not modifying the
-    /// `&mut` slice in some other way. Thus, access to that slice is marked
-    /// `unsafe`.
-    pub fn as_unsafe_slice_mut(&self) -> Result<UnsafeGuestSlice<'a, T>, GuestError>
-    where
-        T: GuestTypeTransparent<'a>,
-    {
-        let (ptr, region) = validate_size_align(self.mem, self.pointer.0, self.pointer.1)?;
-
-        Ok(UnsafeGuestSlice {
-            ptr,
-            region,
-            mem: self.mem,
-        })
-    }
-
-    /// Copies the data in the guest region into a [`Vec`].
-    ///
-    /// This is useful when one cannot use [`GuestPtr::as_slice`], e.g., when
-    /// pointing to a region of WebAssembly shared memory.
-    pub fn to_vec(&self) -> Result<Vec<T>, GuestError>
-    where
-        T: GuestTypeTransparent<'a> + Copy + 'a,
-    {
-        let guest_slice = self.as_unsafe_slice_mut()?;
-        let len = guest_slice.ptr.len();
-        let mut vec = Vec::with_capacity(len);
-
-        // SAFETY: The `guest_slice` variable is already a valid pointer into
-        // the guest's memory, and it may or may not be a pointer into shared
-        // memory. We can't naively use `.to_vec(..)` which could introduce data
-        // races but all that needs to happen is to copy data into our local
-        // `vec` as all the data is `Copy` and transparent anyway. For this
-        // purpose the `ptr::copy` function should be sufficient for copying
-        // over all the data.
-        //
-        // TODO: audit that this use of `std::ptr::copy` is safe with shared
-        // memory (https://github.com/bytecodealliance/wasmtime/issues/4203)
-        unsafe {
-            std::ptr::copy(guest_slice.ptr.as_ptr().cast::<T>(), vec.as_mut_ptr(), len);
-            vec.set_len(len);
-        }
-        Ok(vec)
-    }
-
-    /// Copies the data pointed to by `slice` into this guest region.
-    ///
-    /// This method is a *safe* method to copy data from the host to the guest.
-    /// This requires that `self` and `slice` have the same length. The pointee
-    /// type `T` requires the [`GuestTypeTransparent`] trait which is an
-    /// assertion that the representation on the host and on the guest is the
-    /// same.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if this guest pointer is out of bounds or if the length
-    /// of this guest pointer is not equal to the length of the slice provided.
-    pub fn copy_from_slice(&self, slice: &[T]) -> Result<(), GuestError>
-    where
-        T: GuestTypeTransparent<'a> + Copy + 'a,
-    {
-        self.as_unsafe_slice_mut()?.copy_from_slice(slice)
-    }
-
     /// Returns a `GuestPtr` pointing to the base of the array for the interior
     /// type `T`.
-    pub fn as_ptr(&self) -> GuestPtr<'a, T> {
-        GuestPtr::new(self.mem, self.offset_base())
+    pub fn as_ptr(&self) -> GuestPtr<T> {
+        GuestPtr::new(self.offset_base())
     }
 
-    pub fn get(&self, index: u32) -> Option<GuestPtr<'a, T>>
+    pub fn get(&self, index: u32) -> Option<GuestPtr<T>>
     where
-        T: GuestType<'a>,
+        T: GuestType,
     {
         if index < self.len() {
             Some(
@@ -670,9 +469,9 @@ impl<'a, T> GuestPtr<'a, [T]> {
         }
     }
 
-    pub fn get_range(&self, r: std::ops::Range<u32>) -> Option<GuestPtr<'a, [T]>>
+    pub fn get_range(&self, r: std::ops::Range<u32>) -> Option<GuestPtr<[T]>>
     where
-        T: GuestType<'a>,
+        T: GuestType,
     {
         if r.end < r.start {
             return None;
@@ -691,7 +490,7 @@ impl<'a, T> GuestPtr<'a, [T]> {
     }
 }
 
-impl<'a> GuestPtr<'a, str> {
+impl GuestPtr<str> {
     /// For strings, returns the relative pointer to the base of the string
     /// allocation.
     pub fn offset_base(&self) -> u32 {
@@ -705,420 +504,28 @@ impl<'a> GuestPtr<'a, str> {
 
     /// Returns a raw pointer for the underlying slice of bytes that this
     /// pointer points to.
-    pub fn as_bytes(&self) -> GuestPtr<'a, [u8]> {
-        GuestPtr::new(self.mem, self.pointer)
-    }
-
-    /// Attempts to create a [`GuestStr<'_>`] from this pointer, performing
-    /// bounds checks and utf-8 checks. The resulting `GuestStr` can be used as
-    /// a `&str` via the `Deref` trait. The region of memory backing the `str`
-    /// will be marked as shareably borrowed by the [`GuestMemory`] until the
-    /// `GuestStr` is dropped.
-    ///
-    /// This function will return `GuestStr` into host memory if all checks
-    /// succeed (valid utf-8, valid pointers, etc). If any checks fail then
-    /// `GuestError` will be returned.
-    ///
-    /// Additionally, because it is `unsafe` to have a `GuestStr` of shared
-    /// memory, this function will return `None` in this case (see
-    /// [`GuestPtr<'_, str>::as_cow`]).
-    pub fn as_str(&self) -> Result<Option<GuestStr<'a>>, GuestError> {
-        match self.as_bytes().as_unsafe_slice_mut()?.shared_borrow() {
-            UnsafeBorrowResult::Ok(s) => Ok(Some(s.try_into()?)),
-            UnsafeBorrowResult::Shared(_) => Ok(None),
-            UnsafeBorrowResult::Err(e) => Err(e),
-        }
-    }
-
-    /// Attempts to create a [`GuestStrMut<'_>`] from this pointer, performing
-    /// bounds checks and utf-8 checks. The resulting `GuestStrMut` can be used
-    /// as a `&str` or `&mut str` via the `Deref` and `DerefMut` traits. The
-    /// region of memory backing the `str` will be marked as borrowed by the
-    /// [`GuestMemory`] until the `GuestStrMut` is dropped.
-    ///
-    /// This function will return `GuestStrMut` into host memory if all checks
-    /// succeed (valid utf-8, valid pointers, etc). If any checks fail then
-    /// `GuestError` will be returned.
-    ///
-    /// Additionally, because it is `unsafe` to have a `GuestStrMut` of shared
-    /// memory, this function will return `None` in this case.
-    pub fn as_str_mut(&self) -> Result<Option<GuestStrMut<'a>>, GuestError> {
-        match self.as_bytes().as_unsafe_slice_mut()?.mut_borrow() {
-            UnsafeBorrowResult::Ok(s) => Ok(Some(s.try_into()?)),
-            UnsafeBorrowResult::Shared(_) => Ok(None),
-            UnsafeBorrowResult::Err(e) => Err(e),
-        }
-    }
-
-    /// Attempts to create a [`GuestStrCow<'_>`] from this pointer, performing
-    /// bounds checks and utf-8 checks. Whereas [`GuestPtr::as_str`] will fail
-    /// with `None` if attempting to access Wasm shared memory, this call will
-    /// succeed: if used on shared memory, this function will copy the string
-    /// into [`GuestStrCow::Copied`]. If the memory is non-shared, this returns
-    /// a [`GuestStrCow::Borrowed`] (a thin wrapper over [`GuestStr<'_, T>]`).
-    pub fn as_cow(&self) -> Result<GuestStrCow<'a>, GuestError> {
-        match self.as_bytes().as_unsafe_slice_mut()?.shared_borrow() {
-            UnsafeBorrowResult::Ok(s) => Ok(GuestStrCow::Borrowed(s.try_into()?)),
-            UnsafeBorrowResult::Shared(_) => {
-                let copied = self.as_bytes().to_vec()?;
-                let utf8_string = String::from_utf8(copied).map_err(|e| e.utf8_error())?;
-                Ok(GuestStrCow::Copied(utf8_string))
-            }
-            UnsafeBorrowResult::Err(e) => Err(e),
-        }
-    }
-}
-
-impl<'a> GuestPtr<'a, [u8]> {
-    /// Returns a pointer to the string represented by a `[u8]` without
-    /// validating whether each u8 is a utf-8 codepoint.
-    pub fn as_str_ptr(&self) -> GuestPtr<'a, str> {
-        GuestPtr::new(self.mem, self.pointer)
+    pub fn as_bytes(&self) -> GuestPtr<[u8]> {
+        GuestPtr::new(self.pointer)
     }
 }
 
-impl<T: ?Sized + Pointee> Clone for GuestPtr<'_, T> {
+impl<T: ?Sized + Pointee> Clone for GuestPtr<T> {
     fn clone(&self) -> Self {
         *self
     }
 }
 
-impl<T: ?Sized + Pointee> Copy for GuestPtr<'_, T> {}
+impl<T: ?Sized + Pointee> Copy for GuestPtr<T> {}
 
-impl<T: ?Sized + Pointee> fmt::Debug for GuestPtr<'_, T> {
+impl<T: ?Sized + Pointee> fmt::Debug for GuestPtr<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         T::debug(self.pointer, f)
     }
 }
 
-/// A smart pointer to an shareable slice in guest memory.
-///
-/// Usable as a `&'a [T]` via [`std::ops::Deref`].
-pub struct GuestSlice<'a, T> {
-    ptr: &'a [UnsafeCell<T>],
-    mem: &'a dyn GuestMemory,
-    borrow: BorrowHandle,
-}
-
-// This is a wrapper around `&[T]` and must mirror send/sync impls due to the
-// interior usage of `&[UnsafeCell<T>]`.
-unsafe impl<T: Send> Send for GuestSlice<'_, T> {}
-unsafe impl<T: Sync> Sync for GuestSlice<'_, T> {}
-
-impl<'a, T> std::ops::Deref for GuestSlice<'a, T> {
-    type Target = [T];
-
-    fn deref(&self) -> &Self::Target {
-        // SAFETY: The presence of `GuestSlice` indicates that this is an
-        // unshared memory meaning concurrent accesses will not happen.
-        // Furthermore the validity of the slice has already been established
-        // and a runtime borrow has been recorded to prevent conflicting views.
-        // This all adds up to the ability to return a safe slice from this
-        // method whose lifetime is connected to `self`.
-        unsafe { slice::from_raw_parts(self.ptr.as_ptr().cast(), self.ptr.len()) }
-    }
-}
-
-impl<'a, T> Drop for GuestSlice<'a, T> {
-    fn drop(&mut self) {
-        self.mem.shared_unborrow(self.borrow)
-    }
-}
-
-/// A smart pointer to a mutable slice in guest memory.
-///
-/// Usable as a `&'a [T]` via [`std::ops::Deref`] and as a `&'a mut [T]` via
-/// [`std::ops::DerefMut`].
-pub struct GuestSliceMut<'a, T> {
-    ptr: &'a [UnsafeCell<T>],
-    mem: &'a dyn GuestMemory,
-    borrow: BorrowHandle,
-}
-
-// See docs in these impls for `GuestSlice` above.
-unsafe impl<T: Send> Send for GuestSliceMut<'_, T> {}
-unsafe impl<T: Sync> Sync for GuestSliceMut<'_, T> {}
-
-impl<'a, T> std::ops::Deref for GuestSliceMut<'a, T> {
-    type Target = [T];
-    fn deref(&self) -> &Self::Target {
-        // SAFETY: See docs in `Deref for GuestSlice`
-        unsafe { slice::from_raw_parts(self.ptr.as_ptr().cast(), self.ptr.len()) }
-    }
-}
-
-impl<'a, T> std::ops::DerefMut for GuestSliceMut<'a, T> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        // SAFETY: See docs in `Deref for GuestSlice`
-        unsafe { slice::from_raw_parts_mut(self.ptr.as_ptr() as *mut T, self.ptr.len()) }
-    }
-}
-
-impl<'a, T> Drop for GuestSliceMut<'a, T> {
-    fn drop(&mut self) {
-        self.mem.mut_unborrow(self.borrow)
-    }
-}
-
-/// A smart pointer for distinguishing between different kinds of Wasm memory:
-/// shared and non-shared.
-///
-/// As with `GuestSlice`, this is usable as a `&'a [T]` via [`std::ops::Deref`].
-/// The major difference is that, for shared memories, the memory will be copied
-/// out of Wasm linear memory to avoid the possibility of concurrent mutation by
-/// another thread. This extra copy exists solely to maintain the Rust
-/// guarantees regarding `&[T]`.
-pub enum GuestCow<'a, T> {
-    Borrowed(GuestSlice<'a, T>),
-    Copied(Vec<T>),
-}
-
-impl<'a, T> std::ops::Deref for GuestCow<'a, T> {
-    type Target = [T];
-
-    fn deref(&self) -> &Self::Target {
-        match self {
-            GuestCow::Borrowed(s) => s,
-            GuestCow::Copied(s) => s,
-        }
-    }
-}
-
-/// A smart pointer to an `unsafe` slice in guest memory.
-///
-/// Accessing guest memory (e.g., WebAssembly linear memory) is inherently
-/// `unsafe`. Even though this structure expects that we will have validated the
-/// addresses, lengths, and alignment, we must be extra careful to maintain the
-/// Rust borrowing guarantees if we hand out slices to the underlying memory.
-/// This is done in two ways:
-///
-/// - with shared memory (i.e., memory that may be accessed concurrently by
-///   multiple threads), we have no guarantee that the underlying data will not
-///   be changed; thus, we can only hand out slices `unsafe`-ly (TODO:
-///   eventually with `UnsafeGuestSlice::as_slice`,
-///   `UnsafeGuestSlice::as_slice_mut`)
-/// - with non-shared memory, we _can_ maintain the Rust slice guarantees, but
-///   only by manually performing borrow-checking of the underlying regions that
-///   are accessed; this kind of borrowing is wrapped up in the [`GuestSlice`]
-///   and [`GuestSliceMut`] smart pointers (see
-///   [`UnsafeGuestSlice::shared_borrow`], [`UnsafeGuestSlice::mut_borrow`]).
-pub struct UnsafeGuestSlice<'a, T> {
-    /// A raw pointer to the bytes in memory.
-    ptr: &'a [UnsafeCell<T>],
-    /// The (validated) address bounds of the slice in memory.
-    region: Region,
-    /// The original memory.
-    mem: &'a dyn GuestMemory,
-}
-
-// SAFETY: `UnsafeGuestSlice` can be used across an `await` and therefore must
-// be `Send` and `Sync`. As with `GuestSlice` and friends, we mirror the
-// `Send`/`Sync` impls due to the interior usage of `&[UnsafeCell<T>]`.
-unsafe impl<T: Sync> Sync for UnsafeGuestSlice<'_, T> {}
-unsafe impl<T: Send> Send for UnsafeGuestSlice<'_, T> {}
-
-impl<'a, T> UnsafeGuestSlice<'a, T> {
-    /// See `GuestPtr::copy_from_slice`.
-    pub fn copy_from_slice(self, slice: &[T]) -> Result<(), GuestError>
-    where
-        T: GuestTypeTransparent<'a> + Copy + 'a,
-    {
-        // Check the length...
-        if self.ptr.len() != slice.len() {
-            return Err(GuestError::SliceLengthsDiffer);
-        }
-        if slice.len() == 0 {
-            return Ok(());
-        }
-
-        // ... and copy the bytes.
-        match self.mut_borrow() {
-            UnsafeBorrowResult::Ok(mut dst) => dst.copy_from_slice(slice),
-            UnsafeBorrowResult::Shared(guest_slice) => {
-                // SAFETY: in the shared memory case, we copy and accept that
-                // the guest data may be concurrently modified. TODO: audit that
-                // this use of `std::ptr::copy` is safe with shared memory
-                // (https://github.com/bytecodealliance/wasmtime/issues/4203)
-                //
-                // Also note that the validity of `guest_slice` has already been
-                // determined by the `as_unsafe_slice_mut` call above.
-                unsafe {
-                    std::ptr::copy(
-                        slice.as_ptr(),
-                        guest_slice.ptr[0].get(),
-                        guest_slice.ptr.len(),
-                    )
-                };
-            }
-            UnsafeBorrowResult::Err(e) => return Err(e),
-        }
-        Ok(())
-    }
-
-    /// Return the number of items in this slice.
-    pub fn len(&self) -> usize {
-        self.ptr.len()
-    }
-
-    /// Check if this slice comes from WebAssembly shared memory.
-    pub fn is_shared_memory(&self) -> bool {
-        self.mem.is_shared_memory()
-    }
-
-    /// See `GuestPtr::as_slice_mut`.
-    pub fn as_slice_mut(self) -> Result<Option<GuestSliceMut<'a, T>>, GuestError>
-    where
-        T: GuestTypeTransparent<'a>,
-    {
-        match self.mut_borrow() {
-            UnsafeBorrowResult::Ok(slice) => Ok(Some(slice)),
-            UnsafeBorrowResult::Shared(_) => Ok(None),
-            UnsafeBorrowResult::Err(e) => Err(e),
-        }
-    }
-
-    /// Transform an `unsafe` guest slice to a [`GuestSliceMut`].
-    ///
-    /// # Safety
-    ///
-    /// This function is safe if and only if:
-    /// - the memory is not shared (it will return `None` in this case) and
-    /// - there are no overlapping mutable borrows for this region.
-    fn shared_borrow(self) -> UnsafeBorrowResult<GuestSlice<'a, T>, Self> {
-        if self.mem.is_shared_memory() {
-            UnsafeBorrowResult::Shared(self)
-        } else {
-            match self.mem.shared_borrow(self.region) {
-                Ok(borrow) => UnsafeBorrowResult::Ok(GuestSlice {
-                    ptr: self.ptr,
-                    mem: self.mem,
-                    borrow,
-                }),
-                Err(e) => UnsafeBorrowResult::Err(e),
-            }
-        }
-    }
-
-    /// Transform an `unsafe` guest slice to a [`GuestSliceMut`].
-    ///
-    /// # Safety
-    ///
-    /// This function is safe if and only if:
-    /// - the memory is not shared (it will return `None` in this case) and
-    /// - there are no overlapping borrows of any kind (shared or mutable) for
-    ///   this region.
-    fn mut_borrow(self) -> UnsafeBorrowResult<GuestSliceMut<'a, T>, Self> {
-        if self.mem.is_shared_memory() {
-            UnsafeBorrowResult::Shared(self)
-        } else {
-            match self.mem.mut_borrow(self.region) {
-                Ok(borrow) => UnsafeBorrowResult::Ok(GuestSliceMut {
-                    ptr: self.ptr,
-                    mem: self.mem,
-                    borrow,
-                }),
-                Err(e) => UnsafeBorrowResult::Err(e),
-            }
-        }
-    }
-}
-
-/// A three-way result type for expressing that borrowing from an
-/// [`UnsafeGuestSlice`] could fail in multiple ways. Retaining the
-/// [`UnsafeGuestSlice`] in the `Shared` case allows us to reuse it.
-enum UnsafeBorrowResult<T, S> {
-    /// The borrow succeeded.
-    Ok(T),
-    /// The borrow failed because the underlying memory was shared--we cannot
-    /// safely borrow in this case and return the original unsafe slice.
-    Shared(S),
-    /// The borrow failed for some other reason, e.g., the region was already
-    /// borrowed.
-    Err(GuestError),
-}
-
-impl<T, S> From<GuestError> for UnsafeBorrowResult<T, S> {
-    fn from(e: GuestError) -> Self {
-        UnsafeBorrowResult::Err(e)
-    }
-}
-
-/// A smart pointer to an shareable `str` in guest memory.
-/// Usable as a `&'a str` via [`std::ops::Deref`].
-pub struct GuestStr<'a>(GuestSlice<'a, u8>);
-
-impl<'a> std::convert::TryFrom<GuestSlice<'a, u8>> for GuestStr<'a> {
-    type Error = GuestError;
-    fn try_from(slice: GuestSlice<'a, u8>) -> Result<Self, Self::Error> {
-        match str::from_utf8(&slice) {
-            Ok(_) => Ok(Self(slice)),
-            Err(e) => Err(GuestError::InvalidUtf8(e)),
-        }
-    }
-}
-
-impl<'a> std::ops::Deref for GuestStr<'a> {
-    type Target = str;
-    fn deref(&self) -> &Self::Target {
-        // SAFETY: every slice in a `GuestStr` has already been checked for
-        // UTF-8 validity during construction (i.e., `TryFrom`).
-        unsafe { str::from_utf8_unchecked(&self.0) }
-    }
-}
-
-/// A smart pointer to a mutable `str` in guest memory.
-/// Usable as a `&'a str` via [`std::ops::Deref`] and as a `&'a mut str` via
-/// [`std::ops::DerefMut`].
-pub struct GuestStrMut<'a>(GuestSliceMut<'a, u8>);
-
-impl<'a> std::convert::TryFrom<GuestSliceMut<'a, u8>> for GuestStrMut<'a> {
-    type Error = GuestError;
-    fn try_from(slice: GuestSliceMut<'a, u8>) -> Result<Self, Self::Error> {
-        match str::from_utf8(&slice) {
-            Ok(_) => Ok(Self(slice)),
-            Err(e) => Err(GuestError::InvalidUtf8(e)),
-        }
-    }
-}
-
-impl<'a> std::ops::Deref for GuestStrMut<'a> {
-    type Target = str;
-    fn deref(&self) -> &Self::Target {
-        // SAFETY: every slice in a `GuestStrMut` has already been checked for
-        // UTF-8 validity during construction (i.e., `TryFrom`).
-        unsafe { str::from_utf8_unchecked(&self.0) }
-    }
-}
-
-impl<'a> std::ops::DerefMut for GuestStrMut<'a> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        // SAFETY: every slice in a `GuestStrMut` has already been checked for
-        // UTF-8 validity during construction (i.e., `TryFrom`).
-        unsafe { str::from_utf8_unchecked_mut(&mut self.0) }
-    }
-}
-
-/// A smart pointer to a `str` for distinguishing between different kinds of
-/// Wasm memory: shared and non-shared.
-///
-/// As with `GuestStr`, this is usable as a `&'a str` via [`std::ops::Deref`].
-/// The major difference is that, for shared memories, the string will be copied
-/// out of Wasm linear memory to avoid the possibility of concurrent mutation by
-/// another thread. This extra copy exists solely to maintain the Rust
-/// guarantees regarding `&str`.
-pub enum GuestStrCow<'a> {
-    Borrowed(GuestStr<'a>),
-    Copied(String),
-}
-
-impl<'a> std::ops::Deref for GuestStrCow<'a> {
-    type Target = str;
-
-    fn deref(&self) -> &Self::Target {
-        match self {
-            GuestStrCow::Borrowed(s) => s,
-            GuestStrCow::Copied(s) => s,
-        }
+impl<T: ?Sized + Pointee> PartialEq for GuestPtr<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.pointer == other.pointer
     }
 }
 
@@ -1135,7 +542,7 @@ mod private {
 /// `str` and `[T]` which have special implementations.
 pub trait Pointee: private::Sealed {
     #[doc(hidden)]
-    type Pointer: Copy;
+    type Pointer: Copy + PartialEq;
     #[doc(hidden)]
     fn debug(pointer: Self::Pointer, f: &mut fmt::Formatter) -> fmt::Result;
 }
@@ -1143,7 +550,7 @@ pub trait Pointee: private::Sealed {
 impl<T> Pointee for T {
     type Pointer = u32;
     fn debug(pointer: Self::Pointer, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "*guest {:#x}", pointer)
+        write!(f, "*guest {pointer:#x}")
     }
 }
 
diff --git a/crates/wiggle/src/wasmtime.rs b/crates/wiggle/src/wasmtime.rs
deleted file mode 100644
index 6972c52698b0..000000000000
--- a/crates/wiggle/src/wasmtime.rs
+++ /dev/null
@@ -1,101 +0,0 @@
-use crate::borrow::BorrowChecker;
-use crate::{BorrowHandle, GuestError, GuestMemory, Region};
-use std::cell::UnsafeCell;
-
-/// Lightweight `wasmtime::Memory` wrapper so we can implement the
-/// `wiggle::GuestMemory` trait on it.
-pub struct WasmtimeGuestMemory<'a> {
-    mem: &'a [UnsafeCell<u8>],
-    bc: BorrowChecker,
-    shared: bool,
-}
-
-// These need to be reapplied due to the usage of `UnsafeCell` internally.
-unsafe impl Send for WasmtimeGuestMemory<'_> {}
-unsafe impl Sync for WasmtimeGuestMemory<'_> {}
-
-impl<'a> WasmtimeGuestMemory<'a> {
-    pub fn new(mem: &'a mut [u8]) -> Self {
-        Self {
-            // SAFETY: here the `&mut [u8]` is casted to `&[UnsafeCell<u8>]`
-            // which is losing in effect the `&mut` access but retaining the
-            // borrow. This is done to reflect how the memory is not safe to
-            // access while multiple borrows are handed out internally, checked
-            // with `bc` below.
-            //
-            // Additionally this allows unshared memories to have the same
-            // internal representation as shared memories.
-            mem: unsafe { std::slice::from_raw_parts(mem.as_ptr().cast(), mem.len()) },
-
-            // Wiggle does not expose any methods for functions to re-enter
-            // the WebAssembly instance, or expose the memory via non-wiggle
-            // mechanisms. However, the user-defined code may end up
-            // re-entering the instance, in which case this is an incorrect
-            // implementation - we require exactly one BorrowChecker exist per
-            // instance.
-            // This BorrowChecker construction is a holdover until it is
-            // integrated fully with wasmtime:
-            // https://github.com/bytecodealliance/wasmtime/issues/1917
-            bc: BorrowChecker::new(),
-            shared: false,
-        }
-    }
-
-    pub fn shared(mem: &'a [UnsafeCell<u8>]) -> Self {
-        Self {
-            mem,
-            bc: BorrowChecker::new(),
-            shared: true,
-        }
-    }
-}
-
-unsafe impl GuestMemory for WasmtimeGuestMemory<'_> {
-    #[inline]
-    fn base(&self) -> &[UnsafeCell<u8>] {
-        self.mem
-    }
-
-    // Note that this implementation has special cases for shared memory
-    // specifically because no regions of a shared memory can ever be borrowed.
-    // In the shared memory cases `shared_borrow` and `mut_borrow` are never
-    // called so that can be used to optimize the other methods by quickly
-    // checking a flag before calling the more expensive borrow-checker methods.
-
-    #[inline]
-    fn has_outstanding_borrows(&self) -> bool {
-        !self.shared && self.bc.has_outstanding_borrows()
-    }
-    #[inline]
-    fn is_shared_borrowed(&self, r: Region) -> bool {
-        !self.shared && self.bc.is_shared_borrowed(r)
-    }
-    #[inline]
-    fn is_mut_borrowed(&self, r: Region) -> bool {
-        !self.shared && self.bc.is_mut_borrowed(r)
-    }
-    #[inline]
-    fn shared_borrow(&self, r: Region) -> Result<BorrowHandle, GuestError> {
-        debug_assert!(!self.shared);
-        self.bc.shared_borrow(r)
-    }
-    #[inline]
-    fn mut_borrow(&self, r: Region) -> Result<BorrowHandle, GuestError> {
-        debug_assert!(!self.shared);
-        self.bc.mut_borrow(r)
-    }
-    #[inline]
-    fn shared_unborrow(&self, h: BorrowHandle) {
-        debug_assert!(!self.shared);
-        self.bc.shared_unborrow(h)
-    }
-    #[inline]
-    fn mut_unborrow(&self, h: BorrowHandle) {
-        debug_assert!(!self.shared);
-        self.bc.mut_unborrow(h)
-    }
-    #[inline]
-    fn is_shared_memory(&self) -> bool {
-        self.shared
-    }
-}
diff --git a/crates/wiggle/test-helpers/Cargo.toml b/crates/wiggle/test-helpers/Cargo.toml
index f09c25dca087..df2212e5f264 100644
--- a/crates/wiggle/test-helpers/Cargo.toml
+++ b/crates/wiggle/test-helpers/Cargo.toml
@@ -4,6 +4,7 @@ version = "0.0.0"
 authors = ["Pat Hickey <phickey@fastly.com>", "Jakub Konka <kubkon@jakubkonka.com>", "Alex Crichton <alex@alexcrichton.com>"]
 license = "Apache-2.0 WITH LLVM-exception"
 edition.workspace = true
+rust-version.workspace = true
 description = "Reusable testing components for wiggle code generator. Only intended to be used by tests in `wiggle` crate."
 categories = ["wasm"]
 keywords = ["webassembly", "wasm"]
@@ -11,6 +12,9 @@ repository = "https://github.com/bytecodealliance/wasmtime"
 include = ["src/**/*", "LICENSE"]
 publish = false
 
+[lints]
+workspace = true
+
 [dependencies]
 proptest = "1.0.0"
 wiggle = { path = "..", features = ["tracing_log"] }
diff --git a/crates/wiggle/test-helpers/examples/tracing.rs b/crates/wiggle/test-helpers/examples/tracing.rs
index 8de56c8dba63..6680b1f81e0c 100644
--- a/crates/wiggle/test-helpers/examples/tracing.rs
+++ b/crates/wiggle/test-helpers/examples/tracing.rs
@@ -1,4 +1,5 @@
 use anyhow::Result;
+use wiggle::GuestMemory;
 use wiggle_test::{impl_errno, HostMemory, WasiCtx};
 
 /// The `errors` argument to the wiggle gives us a hook to map a rich error
@@ -53,7 +54,12 @@ impl<'a> types::UserErrorConversion for WasiCtx<'a> {
 }
 
 impl<'a> one_error_conversion::OneErrorConversion for WasiCtx<'a> {
-    fn foo(&mut self, strike: u32, _s: &types::S) -> Result<types::T, RichError> {
+    fn foo(
+        &mut self,
+        _: &mut GuestMemory<'_>,
+        strike: u32,
+        _s: &types::S,
+    ) -> Result<types::T, RichError> {
         // We use the argument to this function to exercise all of the
         // possible error cases we could hit here
         match strike {
@@ -62,7 +68,7 @@ impl<'a> one_error_conversion::OneErrorConversion for WasiCtx<'a> {
                 f2: 456.78,
             }),
             1 => Err(RichError::PicketLine(format!("I'm not a scab"))),
-            _ => Err(RichError::InvalidArg(format!("out-of-bounds: {}", strike))),
+            _ => Err(RichError::InvalidArg(format!("out-of-bounds: {strike}"))),
         }
     }
 }
@@ -83,11 +89,12 @@ fn main() {
     }
 
     let mut ctx = WasiCtx::new();
-    let host_memory = HostMemory::new();
+    let mut host_memory = HostMemory::new();
+    let mut memory = host_memory.guest_memory();
 
     // Exercise each of the branches in `foo`.
     // Start with the success case:
-    let r0 = one_error_conversion::foo(&mut ctx, &host_memory, 0, 0, 8).unwrap();
+    let r0 = one_error_conversion::foo(&mut ctx, &mut memory, 0, 0, 8).unwrap();
     assert_eq!(
         r0,
         types::Errno::Ok as i32,
@@ -96,7 +103,7 @@ fn main() {
     assert!(ctx.log.borrow().is_empty(), "No error log for strike=0");
 
     // First error case:
-    let r1 = one_error_conversion::foo(&mut ctx, &host_memory, 1, 0, 8).unwrap();
+    let r1 = one_error_conversion::foo(&mut ctx, &mut memory, 1, 0, 8).unwrap();
     assert_eq!(
         r1,
         types::Errno::PicketLine as i32,
@@ -109,7 +116,7 @@ fn main() {
     );
 
     // Second error case:
-    let r2 = one_error_conversion::foo(&mut ctx, &host_memory, 2, 0, 8).unwrap();
+    let r2 = one_error_conversion::foo(&mut ctx, &mut memory, 2, 0, 8).unwrap();
     assert_eq!(
         r2,
         types::Errno::InvalidArg as i32,
diff --git a/crates/wiggle/test-helpers/src/lib.rs b/crates/wiggle/test-helpers/src/lib.rs
index 0a29b3a56aca..4ba544c33281 100644
--- a/crates/wiggle/test-helpers/src/lib.rs
+++ b/crates/wiggle/test-helpers/src/lib.rs
@@ -1,7 +1,6 @@
 use proptest::prelude::*;
-use std::cell::UnsafeCell;
 use std::marker;
-use wiggle::{borrow::BorrowChecker, BorrowHandle, GuestMemory, Region};
+use wiggle::GuestMemory;
 
 #[derive(Debug, Clone)]
 pub struct MemAreas(Vec<MemArea>);
@@ -44,7 +43,7 @@ impl Into<Vec<MemArea>> for MemAreas {
 
 #[repr(align(4096))]
 struct HostBuffer {
-    cell: UnsafeCell<[u8; 4096]>,
+    cell: [u8; 4096],
 }
 
 unsafe impl Send for HostBuffer {}
@@ -52,18 +51,22 @@ unsafe impl Sync for HostBuffer {}
 
 pub struct HostMemory {
     buffer: HostBuffer,
-    bc: BorrowChecker,
 }
 impl HostMemory {
     pub fn new() -> Self {
         HostMemory {
-            buffer: HostBuffer {
-                cell: UnsafeCell::new([0; 4096]),
-            },
-            bc: BorrowChecker::new(),
+            buffer: HostBuffer { cell: [0; 4096] },
         }
     }
 
+    pub fn guest_memory(&mut self) -> GuestMemory<'_> {
+        GuestMemory::Unshared(&mut self.buffer.cell)
+    }
+
+    pub fn base(&self) -> *const u8 {
+        self.buffer.cell.as_ptr()
+    }
+
     pub fn mem_area_strat(align: u32) -> BoxedStrategy<MemArea> {
         prop::num::u32::ANY
             .prop_filter_map("needs to fit in memory", move |p| {
@@ -116,34 +119,6 @@ impl HostMemory {
     }
 }
 
-unsafe impl GuestMemory for HostMemory {
-    fn base(&self) -> &[UnsafeCell<u8>] {
-        let ptr = self.buffer.cell.get();
-        unsafe { std::slice::from_raw_parts(ptr.cast(), (*ptr).len()) }
-    }
-    fn has_outstanding_borrows(&self) -> bool {
-        self.bc.has_outstanding_borrows()
-    }
-    fn is_shared_borrowed(&self, r: Region) -> bool {
-        self.bc.is_shared_borrowed(r)
-    }
-    fn is_mut_borrowed(&self, r: Region) -> bool {
-        self.bc.is_mut_borrowed(r)
-    }
-    fn mut_borrow(&self, r: Region) -> Result<BorrowHandle, GuestError> {
-        self.bc.mut_borrow(r)
-    }
-    fn shared_borrow(&self, r: Region) -> Result<BorrowHandle, GuestError> {
-        self.bc.shared_borrow(r)
-    }
-    fn shared_unborrow(&self, h: BorrowHandle) {
-        self.bc.shared_unborrow(h)
-    }
-    fn mut_unborrow(&self, h: BorrowHandle) {
-        self.bc.mut_unborrow(h)
-    }
-}
-
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub struct MemArea {
     pub ptr: u32,
@@ -151,7 +126,7 @@ pub struct MemArea {
 }
 
 impl MemArea {
-    // This code is a whole lot like the Region::overlaps func thats at the core of the code under
+    // This code is a whole lot like the Region::overlaps func that's at the core of the code under
     // test.
     // So, I implemented this one with std::ops::Range so it is less likely I wrote the same bug in two
     // places.
@@ -216,9 +191,9 @@ mod test {
     #[test]
     fn hostmemory_is_aligned() {
         let h = HostMemory::new();
-        assert_eq!(h.base().as_ptr() as usize % 4096, 0);
+        assert_eq!(h.base() as usize % 4096, 0);
         let h = Box::new(h);
-        assert_eq!(h.base().as_ptr() as usize % 4096, 0);
+        assert_eq!(h.base() as usize % 4096, 0);
     }
 
     #[test]
diff --git a/crates/wiggle/tests/atoms.rs b/crates/wiggle/tests/atoms.rs
index 3b97717b4dc7..7954e5fbc1e0 100644
--- a/crates/wiggle/tests/atoms.rs
+++ b/crates/wiggle/tests/atoms.rs
@@ -1,5 +1,5 @@
 use proptest::prelude::*;
-use wiggle::GuestMemory;
+use wiggle::{GuestMemory, GuestPtr};
 use wiggle_test::{impl_errno, HostMemory, MemArea, WasiCtx};
 
 wiggle::from_witx!({
@@ -9,12 +9,18 @@ wiggle::from_witx!({
 impl_errno!(types::Errno);
 
 impl<'a> atoms::Atoms for WasiCtx<'a> {
-    fn int_float_args(&mut self, an_int: u32, an_float: f32) -> Result<(), types::Errno> {
-        println!("INT FLOAT ARGS: {} {}", an_int, an_float);
+    fn int_float_args(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        an_int: u32,
+        an_float: f32,
+    ) -> Result<(), types::Errno> {
+        println!("INT FLOAT ARGS: {an_int} {an_float}");
         Ok(())
     }
     fn double_int_return_float(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         an_int: u32,
     ) -> Result<types::AliasToFloat, types::Errno> {
         Ok((an_int as f32) * 2.0)
@@ -32,10 +38,15 @@ struct IntFloatExercise {
 impl IntFloatExercise {
     pub fn test(&self) {
         let mut ctx = WasiCtx::new();
-        let host_memory = HostMemory::new();
+        let mut host_memory = HostMemory::new();
 
-        let e = atoms::int_float_args(&mut ctx, &host_memory, self.an_int as i32, self.an_float)
-            .unwrap();
+        let e = atoms::int_float_args(
+            &mut ctx,
+            &mut host_memory.guest_memory(),
+            self.an_int as i32,
+            self.an_float,
+        )
+        .unwrap();
 
         assert_eq!(e, types::Errno::Ok as i32, "int_float_args error");
     }
@@ -62,19 +73,19 @@ struct DoubleIntExercise {
 impl DoubleIntExercise {
     pub fn test(&self) {
         let mut ctx = WasiCtx::new();
-        let host_memory = HostMemory::new();
+        let mut host_memory = HostMemory::new();
+        let mut memory = host_memory.guest_memory();
 
         let e = atoms::double_int_return_float(
             &mut ctx,
-            &host_memory,
+            &mut memory,
             self.input as i32,
             self.return_loc.ptr as i32,
         )
         .unwrap();
 
-        let return_val = host_memory
-            .ptr::<types::AliasToFloat>(self.return_loc.ptr)
-            .read()
+        let return_val = memory
+            .read(GuestPtr::<types::AliasToFloat>::new(self.return_loc.ptr))
             .expect("failed to read return");
         assert_eq!(e, types::Errno::Ok as i32, "errno");
         assert_eq!(return_val, (self.input as f32) * 2.0, "return val");
diff --git a/crates/wiggle/tests/atoms_async.rs b/crates/wiggle/tests/atoms_async.rs
index 0fc9660b37ff..34ecfb04ec6a 100644
--- a/crates/wiggle/tests/atoms_async.rs
+++ b/crates/wiggle/tests/atoms_async.rs
@@ -2,7 +2,7 @@ use proptest::prelude::*;
 use std::future::Future;
 use std::pin::Pin;
 use std::task::{Context, Poll, RawWaker, RawWakerVTable, Waker};
-use wiggle::GuestMemory;
+use wiggle::{GuestMemory, GuestPtr};
 use wiggle_test::{impl_errno, HostMemory, MemArea, WasiCtx};
 
 wiggle::from_witx!({
@@ -14,12 +14,18 @@ impl_errno!(types::Errno);
 
 #[wiggle::async_trait]
 impl<'a> atoms::Atoms for WasiCtx<'a> {
-    async fn int_float_args(&mut self, an_int: u32, an_float: f32) -> Result<(), types::Errno> {
-        println!("INT FLOAT ARGS: {} {}", an_int, an_float);
+    async fn int_float_args(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        an_int: u32,
+        an_float: f32,
+    ) -> Result<(), types::Errno> {
+        println!("INT FLOAT ARGS: {an_int} {an_float}");
         Ok(())
     }
     async fn double_int_return_float(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         an_int: u32,
     ) -> Result<types::AliasToFloat, types::Errno> {
         Ok((an_int as f32) * 2.0)
@@ -37,11 +43,12 @@ struct IntFloatExercise {
 impl IntFloatExercise {
     pub fn test(&self) {
         let mut ctx = WasiCtx::new();
-        let host_memory = HostMemory::new();
+        let mut host_memory = HostMemory::new();
+        let mut memory = host_memory.guest_memory();
 
         let e = run(atoms::int_float_args(
             &mut ctx,
-            &host_memory,
+            &mut memory,
             self.an_int as i32,
             self.an_float,
         ))
@@ -72,19 +79,19 @@ struct DoubleIntExercise {
 impl DoubleIntExercise {
     pub fn test(&self) {
         let mut ctx = WasiCtx::new();
-        let host_memory = HostMemory::new();
+        let mut host_memory = HostMemory::new();
+        let mut memory = host_memory.guest_memory();
 
         let e = run(atoms::double_int_return_float(
             &mut ctx,
-            &host_memory,
+            &mut memory,
             self.input as i32,
             self.return_loc.ptr as i32,
         ))
         .unwrap();
 
-        let return_val = host_memory
-            .ptr::<types::AliasToFloat>(self.return_loc.ptr)
-            .read()
+        let return_val = memory
+            .read(GuestPtr::<types::AliasToFloat>::new(self.return_loc.ptr))
             .expect("failed to read return");
         assert_eq!(e, types::Errno::Ok as i32, "errno");
         assert_eq!(return_val, (self.input as f32) * 2.0, "return val");
diff --git a/crates/wiggle/tests/errors.rs b/crates/wiggle/tests/errors.rs
index 594937843003..9687d98ddbc7 100644
--- a/crates/wiggle/tests/errors.rs
+++ b/crates/wiggle/tests/errors.rs
@@ -1,6 +1,7 @@
 /// Execute the wiggle guest conversion code to exercise it
 mod convert_just_errno {
     use anyhow::Result;
+    use wiggle::GuestMemory;
     use wiggle_test::{impl_errno, HostMemory, WasiCtx};
 
     /// The `errors` argument to the wiggle gives us a hook to map a rich error
@@ -43,13 +44,13 @@ mod convert_just_errno {
     }
 
     impl<'a> one_error_conversion::OneErrorConversion for WasiCtx<'a> {
-        fn foo(&mut self, strike: u32) -> Result<(), types::ErrnoT> {
+        fn foo(&mut self, _memory: &mut GuestMemory<'_>, strike: u32) -> Result<(), types::ErrnoT> {
             // We use the argument to this function to exercise all of the
             // possible error cases we could hit here
             match strike {
                 0 => Ok(()),
                 1 => Err(RichError::PicketLine(format!("I'm not a scab")))?,
-                _ => Err(RichError::InvalidArg(format!("out-of-bounds: {}", strike)))?,
+                _ => Err(RichError::InvalidArg(format!("out-of-bounds: {strike}")))?,
             }
         }
     }
@@ -57,11 +58,12 @@ mod convert_just_errno {
     #[test]
     fn one_error_conversion_test() {
         let mut ctx = WasiCtx::new();
-        let host_memory = HostMemory::new();
+        let mut host_memory = HostMemory::new();
+        let mut memory = host_memory.guest_memory();
 
         // Exercise each of the branches in `foo`.
         // Start with the success case:
-        let r0 = one_error_conversion::foo(&mut ctx, &host_memory, 0).unwrap();
+        let r0 = one_error_conversion::foo(&mut ctx, &mut memory, 0).unwrap();
         assert_eq!(
             r0,
             types::Errno::Ok as i32,
@@ -70,7 +72,7 @@ mod convert_just_errno {
         assert!(ctx.log.borrow().is_empty(), "No error log for strike=0");
 
         // First error case:
-        let r1 = one_error_conversion::foo(&mut ctx, &host_memory, 1).unwrap();
+        let r1 = one_error_conversion::foo(&mut ctx, &mut memory, 1).unwrap();
         assert_eq!(
             r1,
             types::Errno::PicketLine as i32,
@@ -78,7 +80,7 @@ mod convert_just_errno {
         );
 
         // Second error case:
-        let r2 = one_error_conversion::foo(&mut ctx, &host_memory, 2).unwrap();
+        let r2 = one_error_conversion::foo(&mut ctx, &mut memory, 2).unwrap();
         assert_eq!(
             r2,
             types::Errno::InvalidArg as i32,
@@ -92,6 +94,7 @@ mod convert_just_errno {
 mod convert_multiple_error_types {
     pub use super::convert_just_errno::RichError;
     use anyhow::Result;
+    use wiggle::GuestMemory;
     use wiggle_test::{impl_errno, WasiCtx};
 
     /// Test that we can map multiple types of errors.
@@ -143,13 +146,13 @@ mod convert_multiple_error_types {
 
     // And here's the witx module trait impl, bodies elided
     impl<'a> two_error_conversions::TwoErrorConversions for WasiCtx<'a> {
-        fn foo(&mut self, _: u32) -> Result<(), RichError> {
+        fn foo(&mut self, _: &mut GuestMemory<'_>, _: u32) -> Result<(), RichError> {
             unimplemented!()
         }
-        fn bar(&mut self, _: u32) -> Result<(), AnotherRichError> {
+        fn bar(&mut self, _: &mut GuestMemory<'_>, _: u32) -> Result<(), AnotherRichError> {
             unimplemented!()
         }
-        fn baz(&mut self, _: u32) -> anyhow::Error {
+        fn baz(&mut self, _: &mut GuestMemory<'_>, _: u32) -> anyhow::Error {
             unimplemented!()
         }
     }
diff --git a/crates/wiggle/tests/flags.rs b/crates/wiggle/tests/flags.rs
index a08fc4de9c37..1bdb11e1c4f4 100644
--- a/crates/wiggle/tests/flags.rs
+++ b/crates/wiggle/tests/flags.rs
@@ -1,5 +1,4 @@
 use proptest::prelude::*;
-use std::convert::TryFrom;
 use wiggle::{GuestMemory, GuestPtr};
 use wiggle_test::{impl_errno, HostMemory, MemArea, WasiCtx};
 
@@ -12,11 +11,12 @@ impl_errno!(types::Errno);
 impl<'a> flags::Flags for WasiCtx<'a> {
     fn configure_car(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         old_config: types::CarConfig,
-        other_config_ptr: &GuestPtr<types::CarConfig>,
+        other_config_ptr: GuestPtr<types::CarConfig>,
     ) -> Result<types::CarConfig, types::Errno> {
-        let other_config = other_config_ptr.read().map_err(|e| {
-            eprintln!("old_config_ptr error: {}", e);
+        let other_config = memory.read(other_config_ptr).map_err(|e| {
+            eprintln!("old_config_ptr error: {e}");
             types::Errno::InvalidArg
         })?;
         Ok(old_config ^ other_config)
@@ -63,17 +63,20 @@ impl ConfigureCarExercise {
 
     pub fn test(&self) {
         let mut ctx = WasiCtx::new();
-        let host_memory = HostMemory::new();
+        let mut host_memory = HostMemory::new();
+        let mut memory = host_memory.guest_memory();
 
         // Populate input ptr
-        host_memory
-            .ptr(self.other_config_by_ptr.ptr)
-            .write(self.other_config)
+        memory
+            .write(
+                GuestPtr::new(self.other_config_by_ptr.ptr),
+                self.other_config,
+            )
             .expect("deref ptr mut to CarConfig");
 
         let res = flags::configure_car(
             &mut ctx,
-            &host_memory,
+            &mut memory,
             self.old_config.bits() as i32,
             self.other_config_by_ptr.ptr as i32,
             self.return_ptr_loc.ptr as i32,
@@ -81,9 +84,8 @@ impl ConfigureCarExercise {
         .unwrap();
         assert_eq!(res, types::Errno::Ok as i32, "configure car errno");
 
-        let res_config = host_memory
-            .ptr::<types::CarConfig>(self.return_ptr_loc.ptr)
-            .read()
+        let res_config = memory
+            .read(GuestPtr::<types::CarConfig>::new(self.return_ptr_loc.ptr))
             .expect("deref to CarConfig value");
 
         assert_eq!(
diff --git a/crates/wiggle/tests/handles.rs b/crates/wiggle/tests/handles.rs
index ea1e0abcdd22..09f6d988993c 100644
--- a/crates/wiggle/tests/handles.rs
+++ b/crates/wiggle/tests/handles.rs
@@ -1,5 +1,5 @@
 use proptest::prelude::*;
-use wiggle::{GuestMemory, GuestType};
+use wiggle::{GuestMemory, GuestPtr, GuestType};
 use wiggle_test::{impl_errno, HostMemory, MemArea, WasiCtx};
 
 const FD_VAL: u32 = 123;
@@ -11,11 +11,15 @@ wiggle::from_witx!({
 impl_errno!(types::Errno);
 
 impl<'a> handle_examples::HandleExamples for WasiCtx<'a> {
-    fn fd_create(&mut self) -> Result<types::Fd, types::Errno> {
+    fn fd_create(&mut self, _memory: &mut GuestMemory<'_>) -> Result<types::Fd, types::Errno> {
         Ok(types::Fd::from(FD_VAL))
     }
-    fn fd_consume(&mut self, fd: types::Fd) -> Result<(), types::Errno> {
-        println!("FD_CONSUME {}", fd);
+    fn fd_consume(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        fd: types::Fd,
+    ) -> Result<(), types::Errno> {
+        println!("FD_CONSUME {fd}");
         if fd == types::Fd::from(FD_VAL) {
             Ok(())
         } else {
@@ -32,25 +36,25 @@ struct HandleExercise {
 impl HandleExercise {
     pub fn test(&self) {
         let mut ctx = WasiCtx::new();
-        let host_memory = HostMemory::new();
+        let mut host_memory = HostMemory::new();
+        let mut memory = host_memory.guest_memory();
 
         let e =
-            handle_examples::fd_create(&mut ctx, &host_memory, self.return_loc.ptr as i32).unwrap();
+            handle_examples::fd_create(&mut ctx, &mut memory, self.return_loc.ptr as i32).unwrap();
 
         assert_eq!(e, types::Errno::Ok as i32, "fd_create error");
 
-        let h_got: u32 = host_memory
-            .ptr(self.return_loc.ptr)
-            .read()
+        let h_got: u32 = memory
+            .read(GuestPtr::new(self.return_loc.ptr))
             .expect("return ref_mut");
 
         assert_eq!(h_got, 123, "fd_create return val");
 
-        let e = handle_examples::fd_consume(&mut ctx, &host_memory, h_got as i32).unwrap();
+        let e = handle_examples::fd_consume(&mut ctx, &mut memory, h_got as i32).unwrap();
 
         assert_eq!(e, types::Errno::Ok as i32, "fd_consume error");
 
-        let e = handle_examples::fd_consume(&mut ctx, &host_memory, h_got as i32 + 1).unwrap();
+        let e = handle_examples::fd_consume(&mut ctx, &mut memory, h_got as i32 + 1).unwrap();
 
         assert_eq!(
             e,
diff --git a/crates/wiggle/tests/ints.rs b/crates/wiggle/tests/ints.rs
index b342e0ec2829..21fb40db1897 100644
--- a/crates/wiggle/tests/ints.rs
+++ b/crates/wiggle/tests/ints.rs
@@ -1,6 +1,5 @@
 use proptest::prelude::*;
-use std::convert::TryFrom;
-use wiggle::GuestMemory;
+use wiggle::{GuestMemory, GuestPtr};
 use wiggle_test::{impl_errno, HostMemory, MemArea, WasiCtx};
 
 wiggle::from_witx!({
@@ -10,7 +9,11 @@ wiggle::from_witx!({
 impl_errno!(types::Errno);
 
 impl<'a> ints::Ints for WasiCtx<'a> {
-    fn cookie_cutter(&mut self, init_cookie: types::Cookie) -> Result<types::Bool, types::Errno> {
+    fn cookie_cutter(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        init_cookie: types::Cookie,
+    ) -> Result<types::Bool, types::Errno> {
         let res = if init_cookie == types::COOKIE_START {
             types::Bool::True
         } else {
@@ -44,20 +47,20 @@ impl CookieCutterExercise {
 
     pub fn test(&self) {
         let mut ctx = WasiCtx::new();
-        let host_memory = HostMemory::new();
+        let mut host_memory = HostMemory::new();
+        let mut memory = host_memory.guest_memory();
 
         let res = ints::cookie_cutter(
             &mut ctx,
-            &host_memory,
+            &mut memory,
             self.cookie as i64,
             self.return_ptr_loc.ptr as i32,
         )
         .unwrap();
         assert_eq!(res, types::Errno::Ok as i32, "cookie cutter errno");
 
-        let is_cookie_start = host_memory
-            .ptr::<types::Bool>(self.return_ptr_loc.ptr)
-            .read()
+        let is_cookie_start = memory
+            .read(GuestPtr::<types::Bool>::new(self.return_ptr_loc.ptr))
             .expect("deref to Bool value");
 
         assert_eq!(
diff --git a/crates/wiggle/tests/keywords.rs b/crates/wiggle/tests/keywords.rs
index eda062b81977..6c0f7a1df124 100644
--- a/crates/wiggle/tests/keywords.rs
+++ b/crates/wiggle/tests/keywords.rs
@@ -33,7 +33,7 @@ mod module_trait_fn_and_arg_test {
     });
     impl<'a> self_::Self_ for WasiCtx<'a> {
         #[allow(unused_variables)]
-        fn fn_(&mut self, use_: u32, virtual_: u32) {
+        fn fn_(&mut self, _memory: &mut wiggle::GuestMemory<'_>, use_: u32, virtual_: u32) {
             unimplemented!();
         }
     }
diff --git a/crates/wiggle/tests/lists.rs b/crates/wiggle/tests/lists.rs
index 5f94238a4565..44e4958a6944 100644
--- a/crates/wiggle/tests/lists.rs
+++ b/crates/wiggle/tests/lists.rs
@@ -11,26 +11,32 @@ impl_errno!(types::Errno);
 impl<'a> lists::Lists for WasiCtx<'a> {
     fn reduce_excuses(
         &mut self,
-        excuses: &types::ConstExcuseArray,
+        memory: &mut GuestMemory<'_>,
+        excuses: types::ConstExcuseArray,
     ) -> Result<types::Excuse, types::Errno> {
-        let last = &excuses
-            .iter()
-            .last()
-            .expect("input array is non-empty")
-            .expect("valid ptr to ptr")
-            .read()
+        let last = memory
+            .read(
+                excuses
+                    .iter()
+                    .last()
+                    .expect("input array is non-empty")
+                    .expect("valid ptr to ptr"),
+            )
             .expect("valid ptr to some Excuse value");
-        Ok(last.read().expect("dereferencing ptr should succeed"))
+        Ok(memory.read(last).expect("dereferencing ptr should succeed"))
     }
 
-    fn populate_excuses(&mut self, excuses: &types::ExcuseArray) -> Result<(), types::Errno> {
+    fn populate_excuses(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        excuses: types::ExcuseArray,
+    ) -> Result<(), types::Errno> {
         for excuse in excuses.iter() {
-            let ptr_to_excuse = excuse
-                .expect("valid ptr to ptr")
-                .read()
+            let ptr_to_excuse = memory
+                .read(excuse.expect("valid ptr to ptr"))
                 .expect("valid ptr to some Excuse value");
-            ptr_to_excuse
-                .write(types::Excuse::Sleeping)
+            memory
+                .write(ptr_to_excuse, types::Excuse::Sleeping)
                 .expect("dereferencing mut ptr should succeed");
         }
         Ok(())
@@ -38,14 +44,14 @@ impl<'a> lists::Lists for WasiCtx<'a> {
 }
 
 #[derive(Debug)]
-struct ReduceExcusesExcercise {
+struct ReduceExcusesExercise {
     excuse_values: Vec<types::Excuse>,
     excuse_ptr_locs: Vec<MemArea>,
     array_ptr_loc: MemArea,
     return_ptr_loc: MemArea,
 }
 
-impl ReduceExcusesExcercise {
+impl ReduceExcusesExercise {
     pub fn strat() -> BoxedStrategy<Self> {
         (1..256u32)
             .prop_flat_map(|len| {
@@ -75,30 +81,31 @@ impl ReduceExcusesExcercise {
 
     pub fn test(&self) {
         let mut ctx = WasiCtx::new();
-        let host_memory = HostMemory::new();
+        let mut host_memory = HostMemory::new();
+        let mut memory = host_memory.guest_memory();
 
         // Populate memory with pointers to generated Excuse values
         for (&excuse, ptr) in self.excuse_values.iter().zip(self.excuse_ptr_locs.iter()) {
-            host_memory
-                .ptr(ptr.ptr)
-                .write(excuse)
+            memory
+                .write(GuestPtr::new(ptr.ptr), excuse)
                 .expect("deref ptr mut to Excuse value");
         }
 
         // Populate the array with pointers to generated Excuse values
         {
-            let array: GuestPtr<'_, [GuestPtr<types::Excuse>]> =
-                host_memory.ptr((self.array_ptr_loc.ptr, self.excuse_ptr_locs.len() as u32));
+            let array: GuestPtr<[GuestPtr<types::Excuse>]> =
+                GuestPtr::new((self.array_ptr_loc.ptr, self.excuse_ptr_locs.len() as u32));
             for (slot, ptr) in array.iter().zip(&self.excuse_ptr_locs) {
                 let slot = slot.expect("array should be in bounds");
-                slot.write(host_memory.ptr(ptr.ptr))
+                memory
+                    .write(slot, GuestPtr::new(ptr.ptr))
                     .expect("should succeed in writing array");
             }
         }
 
         let res = lists::reduce_excuses(
             &mut ctx,
-            &host_memory,
+            &mut memory,
             self.array_ptr_loc.ptr as i32,
             self.excuse_ptr_locs.len() as i32,
             self.return_ptr_loc.ptr as i32,
@@ -111,16 +118,15 @@ impl ReduceExcusesExcercise {
             .excuse_values
             .last()
             .expect("generated vec of excuses should be non-empty");
-        let given: types::Excuse = host_memory
-            .ptr(self.return_ptr_loc.ptr)
-            .read()
+        let given: types::Excuse = memory
+            .read(GuestPtr::new(self.return_ptr_loc.ptr))
             .expect("deref ptr to returned value");
         assert_eq!(expected, given, "reduce excuses return val");
     }
 }
 proptest! {
     #[test]
-    fn reduce_excuses(e in ReduceExcusesExcercise::strat()) {
+    fn reduce_excuses(e in ReduceExcusesExercise::strat()) {
         e.test()
     }
 }
@@ -135,12 +141,12 @@ fn excuse_strat() -> impl Strategy<Value = types::Excuse> {
 }
 
 #[derive(Debug)]
-struct PopulateExcusesExcercise {
+struct PopulateExcusesExercise {
     array_ptr_loc: MemArea,
     elements: Vec<MemArea>,
 }
 
-impl PopulateExcusesExcercise {
+impl PopulateExcusesExercise {
     pub fn strat() -> BoxedStrategy<Self> {
         (1..256u32)
             .prop_flat_map(|len| {
@@ -164,38 +170,41 @@ impl PopulateExcusesExcercise {
 
     pub fn test(&self) {
         let mut ctx = WasiCtx::new();
-        let host_memory = HostMemory::new();
+        let mut host_memory = HostMemory::new();
+        let mut memory = host_memory.guest_memory();
 
         // Populate array with valid pointers to Excuse type in memory
-        let ptr = host_memory.ptr::<[GuestPtr<'_, types::Excuse>]>((
+        let ptr = GuestPtr::<[GuestPtr<types::Excuse>]>::new((
             self.array_ptr_loc.ptr,
             self.elements.len() as u32,
         ));
         for (ptr, val) in ptr.iter().zip(&self.elements) {
-            ptr.expect("should be valid pointer")
-                .write(host_memory.ptr(val.ptr))
+            memory
+                .write(
+                    ptr.expect("should be valid pointer"),
+                    GuestPtr::new(val.ptr),
+                )
                 .expect("failed to write value");
         }
 
         let res = lists::populate_excuses(
             &mut ctx,
-            &host_memory,
+            &mut memory,
             self.array_ptr_loc.ptr as i32,
             self.elements.len() as i32,
         )
         .unwrap();
         assert_eq!(res, types::Errno::Ok as i32, "populate excuses errno");
 
-        let arr: GuestPtr<'_, [GuestPtr<'_, types::Excuse>]> =
-            host_memory.ptr((self.array_ptr_loc.ptr, self.elements.len() as u32));
+        let arr: GuestPtr<[GuestPtr<types::Excuse>]> =
+            GuestPtr::new((self.array_ptr_loc.ptr, self.elements.len() as u32));
         for el in arr.iter() {
-            let ptr_to_ptr = el
-                .expect("valid ptr to ptr")
-                .read()
+            let ptr_to_ptr = memory
+                .read(el.expect("valid ptr to ptr"))
                 .expect("valid ptr to some Excuse value");
             assert_eq!(
-                ptr_to_ptr
-                    .read()
+                memory
+                    .read(ptr_to_ptr)
                     .expect("dereferencing ptr to some Excuse value"),
                 types::Excuse::Sleeping,
                 "element should equal Excuse::Sleeping"
@@ -205,7 +214,7 @@ impl PopulateExcusesExcercise {
 }
 proptest! {
     #[test]
-    fn populate_excuses(e in PopulateExcusesExcercise::strat()) {
+    fn populate_excuses(e in PopulateExcusesExercise::strat()) {
         e.test()
     }
 }
@@ -213,16 +222,20 @@ proptest! {
 impl<'a> array_traversal::ArrayTraversal for WasiCtx<'a> {
     fn sum_of_element(
         &mut self,
-        elements: &GuestPtr<[types::PairInts]>,
+        memory: &mut GuestMemory<'_>,
+        elements: GuestPtr<[types::PairInts]>,
         index: u32,
     ) -> Result<i32, types::Errno> {
         let elem_ptr = elements.get(index).ok_or(types::Errno::InvalidArg)?;
-        let pair = elem_ptr.read().map_err(|_| types::Errno::DontWantTo)?;
+        let pair = memory
+            .read(elem_ptr)
+            .map_err(|_| types::Errno::DontWantTo)?;
         Ok(pair.first.wrapping_add(pair.second))
     }
     fn sum_of_elements(
         &mut self,
-        elements: &GuestPtr<[types::PairInts]>,
+        memory: &mut GuestMemory<'_>,
+        elements: GuestPtr<[types::PairInts]>,
         start: u32,
         end: u32,
     ) -> Result<i32, types::Errno> {
@@ -231,9 +244,8 @@ impl<'a> array_traversal::ArrayTraversal for WasiCtx<'a> {
             .ok_or(types::Errno::InvalidArg)?;
         let mut sum: i32 = 0;
         for e in elem_range.iter() {
-            let pair = e
-                .map_err(|_| types::Errno::DontWantTo)?
-                .read()
+            let pair = memory
+                .read(e.map_err(|_| types::Errno::DontWantTo)?)
                 .map_err(|_| types::Errno::PhysicallyUnable)?;
             sum = sum.wrapping_add(pair.first).wrapping_add(pair.second);
         }
@@ -291,20 +303,21 @@ impl SumElementsExercise {
     }
     pub fn test(&self) {
         let mut ctx = WasiCtx::new();
-        let host_memory = HostMemory::new();
+        let mut host_memory = HostMemory::new();
+        let mut memory = host_memory.guest_memory();
 
         // Populate array
-        let ptr = host_memory
-            .ptr::<[types::PairInts]>((self.element_loc.ptr, self.elements.len() as u32));
+        let ptr =
+            GuestPtr::<[types::PairInts]>::new((self.element_loc.ptr, self.elements.len() as u32));
         for (ptr, val) in ptr.iter().zip(&self.elements) {
-            ptr.expect("should be valid pointer")
-                .write(val.clone())
+            memory
+                .write(ptr.expect("should be valid pointer"), val.clone())
                 .expect("failed to write value");
         }
 
         let res = array_traversal::sum_of_element(
             &mut ctx,
-            &host_memory,
+            &mut memory,
             self.element_loc.ptr as i32,
             self.elements.len() as i32,
             self.start_ix as i32,
@@ -312,8 +325,8 @@ impl SumElementsExercise {
         )
         .unwrap();
         assert_eq!(res, types::Errno::Ok as i32, "sum_of_element errno");
-        let result_ptr = host_memory.ptr::<i32>(self.return_loc.ptr);
-        let result = result_ptr.read().expect("read result");
+        let result_ptr = GuestPtr::<i32>::new(self.return_loc.ptr);
+        let result = memory.read(result_ptr).expect("read result");
 
         let e = self
             .elements
@@ -324,7 +337,7 @@ impl SumElementsExercise {
         // Off the end of the array:
         let res = array_traversal::sum_of_element(
             &mut ctx,
-            &host_memory,
+            &mut memory,
             self.element_loc.ptr as i32,
             self.elements.len() as i32,
             self.elements.len() as i32,
@@ -339,7 +352,7 @@ impl SumElementsExercise {
 
         let res = array_traversal::sum_of_elements(
             &mut ctx,
-            &host_memory,
+            &mut memory,
             self.element_loc.ptr as i32,
             self.elements.len() as i32,
             self.start_ix as i32,
@@ -353,8 +366,8 @@ impl SumElementsExercise {
                 types::Errno::Ok as i32,
                 "expected ok sum_of_elements errno"
             );
-            let result_ptr = host_memory.ptr::<i32>(self.return_loc.ptr);
-            let result = result_ptr.read().expect("read result");
+            let result_ptr = GuestPtr::<i32>::new(self.return_loc.ptr);
+            let result = memory.read(result_ptr).expect("read result");
 
             let mut expected_sum: i32 = 0;
             for elem in self
@@ -379,7 +392,7 @@ impl SumElementsExercise {
         // Index an array off the end of the array:
         let res = array_traversal::sum_of_elements(
             &mut ctx,
-            &host_memory,
+            &mut memory,
             self.element_loc.ptr as i32,
             self.elements.len() as i32,
             self.start_ix as i32,
diff --git a/crates/wiggle/tests/pointers.rs b/crates/wiggle/tests/pointers.rs
index d3c4ac7e53ad..128935ca6435 100644
--- a/crates/wiggle/tests/pointers.rs
+++ b/crates/wiggle/tests/pointers.rs
@@ -9,50 +9,51 @@ wiggle::from_witx!({
 impl_errno!(types::Errno);
 
 impl<'a> pointers::Pointers for WasiCtx<'a> {
-    fn pointers_and_enums<'b>(
+    fn pointers_and_enums(
         &mut self,
+        memory: &mut GuestMemory<'_>,
         input1: types::Excuse,
-        input2_ptr: &GuestPtr<'b, types::Excuse>,
-        input3_ptr: &GuestPtr<'b, types::Excuse>,
-        input4_ptr_ptr: &GuestPtr<'b, GuestPtr<'b, types::Excuse>>,
+        input2_ptr: GuestPtr<types::Excuse>,
+        input3_ptr: GuestPtr<types::Excuse>,
+        input4_ptr_ptr: GuestPtr<GuestPtr<types::Excuse>>,
     ) -> Result<(), types::Errno> {
-        println!("BAZ input1 {:?}", input1);
-        let input2: types::Excuse = input2_ptr.read().map_err(|e| {
-            eprintln!("input2_ptr error: {}", e);
+        println!("BAZ input1 {input1:?}");
+        let input2: types::Excuse = memory.read(input2_ptr).map_err(|e| {
+            eprintln!("input2_ptr error: {e}");
             types::Errno::InvalidArg
         })?;
-        println!("input2 {:?}", input2);
+        println!("input2 {input2:?}");
 
         // Read enum value from immutable ptr:
-        let input3 = input3_ptr.read().map_err(|e| {
-            eprintln!("input3_ptr error: {}", e);
+        let input3 = memory.read(input3_ptr).map_err(|e| {
+            eprintln!("input3_ptr error: {e}");
             types::Errno::InvalidArg
         })?;
-        println!("input3 {:?}", input3);
+        println!("input3 {input3:?}");
 
         // Write enum to mutable ptr:
-        input2_ptr.write(input3).map_err(|e| {
-            eprintln!("input2_ptr error: {}", e);
+        memory.write(input2_ptr, input3).map_err(|e| {
+            eprintln!("input2_ptr error: {e}");
             types::Errno::InvalidArg
         })?;
-        println!("wrote to input2_ref {:?}", input3);
+        println!("wrote to input2_ref {input3:?}");
 
         // Read ptr value from mutable ptr:
-        let input4_ptr: GuestPtr<types::Excuse> = input4_ptr_ptr.read().map_err(|e| {
-            eprintln!("input4_ptr_ptr error: {}", e);
+        let input4_ptr: GuestPtr<types::Excuse> = memory.read(input4_ptr_ptr).map_err(|e| {
+            eprintln!("input4_ptr_ptr error: {e}");
             types::Errno::InvalidArg
         })?;
 
         // Read enum value from that ptr:
-        let input4: types::Excuse = input4_ptr.read().map_err(|e| {
-            eprintln!("input4_ptr error: {}", e);
+        let input4: types::Excuse = memory.read(input4_ptr).map_err(|e| {
+            eprintln!("input4_ptr error: {e}");
             types::Errno::InvalidArg
         })?;
-        println!("input4 {:?}", input4);
+        println!("input4 {input4:?}");
 
         // Write ptr value to mutable ptr:
-        input4_ptr_ptr.write(*input2_ptr).map_err(|e| {
-            eprintln!("input4_ptr_ptr error: {}", e);
+        memory.write(input4_ptr_ptr, input2_ptr).map_err(|e| {
+            eprintln!("input4_ptr_ptr error: {e}");
             types::Errno::InvalidArg
         })?;
 
@@ -126,31 +127,28 @@ impl PointersAndEnumsExercise {
     }
     pub fn test(&self) {
         let mut ctx = WasiCtx::new();
-        let host_memory = HostMemory::new();
+        let mut host_memory = HostMemory::new();
+        let mut memory = host_memory.guest_memory();
 
-        host_memory
-            .ptr(self.input2_loc.ptr)
-            .write(self.input2)
+        memory
+            .write(GuestPtr::new(self.input2_loc.ptr), self.input2)
             .expect("input2 ref_mut");
 
-        host_memory
-            .ptr(self.input3_loc.ptr)
-            .write(self.input3)
+        memory
+            .write(GuestPtr::new(self.input3_loc.ptr), self.input3)
             .expect("input3 ref_mut");
 
-        host_memory
-            .ptr(self.input4_loc.ptr)
-            .write(self.input4)
+        memory
+            .write(GuestPtr::new(self.input4_loc.ptr), self.input4)
             .expect("input4 ref_mut");
 
-        host_memory
-            .ptr(self.input4_ptr_loc.ptr)
-            .write(self.input4_loc.ptr)
+        memory
+            .write(GuestPtr::new(self.input4_ptr_loc.ptr), self.input4_loc.ptr)
             .expect("input4 ptr ref_mut");
 
         let e = pointers::pointers_and_enums(
             &mut ctx,
-            &host_memory,
+            &mut memory,
             self.input1 as i32,
             self.input2_loc.ptr as i32,
             self.input3_loc.ptr as i32,
@@ -160,9 +158,8 @@ impl PointersAndEnumsExercise {
         assert_eq!(e, types::Errno::Ok as i32, "errno");
 
         // Implementation of pointers_and_enums writes input3 to the input2_loc:
-        let written_to_input2_loc: i32 = host_memory
-            .ptr(self.input2_loc.ptr)
-            .read()
+        let written_to_input2_loc: i32 = memory
+            .read(GuestPtr::new(self.input2_loc.ptr))
             .expect("input2 ref");
 
         assert_eq!(
@@ -171,9 +168,8 @@ impl PointersAndEnumsExercise {
         );
 
         // Implementation of pointers_and_enums writes input2_loc to input4_ptr_loc:
-        let written_to_input4_ptr: u32 = host_memory
-            .ptr(self.input4_ptr_loc.ptr)
-            .read()
+        let written_to_input4_ptr: u32 = memory
+            .read(GuestPtr::new(self.input4_ptr_loc.ptr))
             .expect("input4_ptr_loc ref");
 
         assert_eq!(
diff --git a/crates/wiggle/tests/records.rs b/crates/wiggle/tests/records.rs
index 713015d27d6c..1642a7ed09f3 100644
--- a/crates/wiggle/tests/records.rs
+++ b/crates/wiggle/tests/records.rs
@@ -9,66 +9,83 @@ wiggle::from_witx!({
 impl_errno!(types::Errno);
 
 impl<'a> records::Records for WasiCtx<'a> {
-    fn sum_of_pair(&mut self, an_pair: &types::PairInts) -> Result<i64, types::Errno> {
+    fn sum_of_pair(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        an_pair: &types::PairInts,
+    ) -> Result<i64, types::Errno> {
         Ok(an_pair.first as i64 + an_pair.second as i64)
     }
 
-    fn sum_of_pair_of_ptrs(&mut self, an_pair: &types::PairIntPtrs) -> Result<i64, types::Errno> {
-        let first = an_pair
-            .first
-            .read()
+    fn sum_of_pair_of_ptrs(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        an_pair: &types::PairIntPtrs,
+    ) -> Result<i64, types::Errno> {
+        let first = memory
+            .read(an_pair.first)
+            .expect("dereferencing GuestPtr should succeed");
+        let second = memory
+            .read(an_pair.second)
             .expect("dereferencing GuestPtr should succeed");
-        let second = an_pair
-            .second
-            .read()
-            .expect("dereferncing GuestPtr should succeed");
         Ok(first as i64 + second as i64)
     }
 
-    fn sum_of_int_and_ptr(&mut self, an_pair: &types::PairIntAndPtr) -> Result<i64, types::Errno> {
-        let first = an_pair
-            .first
-            .read()
+    fn sum_of_int_and_ptr(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        an_pair: &types::PairIntAndPtr,
+    ) -> Result<i64, types::Errno> {
+        let first = memory
+            .read(an_pair.first)
             .expect("dereferencing GuestPtr should succeed");
         let second = an_pair.second as i64;
         Ok(first as i64 + second)
     }
 
-    fn return_pair_ints(&mut self) -> Result<types::PairInts, types::Errno> {
+    fn return_pair_ints(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+    ) -> Result<types::PairInts, types::Errno> {
         Ok(types::PairInts {
             first: 10,
             second: 20,
         })
     }
 
-    fn return_pair_of_ptrs<'b>(
+    fn return_pair_of_ptrs(
         &mut self,
-        first: &GuestPtr<'b, i32>,
-        second: &GuestPtr<'b, i32>,
-    ) -> Result<types::PairIntPtrs<'b>, types::Errno> {
+        _memory: &mut GuestMemory<'_>,
+        first: GuestPtr<i32>,
+        second: GuestPtr<i32>,
+    ) -> Result<types::PairIntPtrs, types::Errno> {
         Ok(types::PairIntPtrs {
-            first: *first,
-            second: *second,
+            first: first,
+            second: second,
         })
     }
 
-    fn sum_array<'b>(
+    fn sum_array(
         &mut self,
-        record_of_list: &types::RecordOfList<'b>,
+        memory: &mut GuestMemory<'_>,
+        record_of_list: &types::RecordOfList,
     ) -> Result<u16, types::Errno> {
         // my kingdom for try blocks
-        fn aux(record_of_list: &types::RecordOfList) -> Result<u16, wiggle::GuestError> {
+        fn aux(
+            memory: &mut GuestMemory<'_>,
+            record_of_list: &types::RecordOfList,
+        ) -> Result<u16, wiggle::GuestError> {
             let mut s = 0;
             for elem in record_of_list.arr.iter() {
-                let v = elem?.read()?;
+                let v = memory.read(elem?)?;
                 s += v as u16;
             }
             Ok(s)
         }
-        match aux(record_of_list) {
+        match aux(memory, record_of_list) {
             Ok(s) => Ok(s),
             Err(guest_err) => {
-                eprintln!("guest error summing array: {:?}", guest_err);
+                eprintln!("guest error summing array: {guest_err:?}");
                 Err(types::Errno::PicketLine)
             }
         }
@@ -103,19 +120,18 @@ impl SumOfPairExercise {
 
     pub fn test(&self) {
         let mut ctx = WasiCtx::new();
-        let host_memory = HostMemory::new();
+        let mut host_memory = HostMemory::new();
+        let mut memory = host_memory.guest_memory();
 
-        host_memory
-            .ptr(self.input_loc.ptr)
-            .write(self.input.first)
+        memory
+            .write(GuestPtr::new(self.input_loc.ptr), self.input.first)
             .expect("input ref_mut");
-        host_memory
-            .ptr(self.input_loc.ptr + 4)
-            .write(self.input.second)
+        memory
+            .write(GuestPtr::new(self.input_loc.ptr + 4), self.input.second)
             .expect("input ref_mut");
         let sum_err = records::sum_of_pair(
             &mut ctx,
-            &host_memory,
+            &mut memory,
             self.input_loc.ptr as i32,
             self.return_loc.ptr as i32,
         )
@@ -123,9 +139,8 @@ impl SumOfPairExercise {
 
         assert_eq!(sum_err, types::Errno::Ok as i32, "sum errno");
 
-        let return_val: i64 = host_memory
-            .ptr(self.return_loc.ptr)
-            .read()
+        let return_val: i64 = memory
+            .read(GuestPtr::new(self.return_loc.ptr))
             .expect("return ref");
 
         assert_eq!(
@@ -192,29 +207,32 @@ impl SumPairPtrsExercise {
     }
     pub fn test(&self) {
         let mut ctx = WasiCtx::new();
-        let host_memory = HostMemory::new();
+        let mut host_memory = HostMemory::new();
+        let mut memory = host_memory.guest_memory();
 
-        host_memory
-            .ptr(self.input_first_loc.ptr)
-            .write(self.input_first)
+        memory
+            .write(GuestPtr::new(self.input_first_loc.ptr), self.input_first)
             .expect("input_first ref");
-        host_memory
-            .ptr(self.input_second_loc.ptr)
-            .write(self.input_second)
+        memory
+            .write(GuestPtr::new(self.input_second_loc.ptr), self.input_second)
             .expect("input_second ref");
 
-        host_memory
-            .ptr(self.input_struct_loc.ptr)
-            .write(self.input_first_loc.ptr)
+        memory
+            .write(
+                GuestPtr::new(self.input_struct_loc.ptr),
+                self.input_first_loc.ptr,
+            )
             .expect("input_struct ref");
-        host_memory
-            .ptr(self.input_struct_loc.ptr + 4)
-            .write(self.input_second_loc.ptr)
+        memory
+            .write(
+                GuestPtr::new(self.input_struct_loc.ptr + 4),
+                self.input_second_loc.ptr,
+            )
             .expect("input_struct ref");
 
         let res = records::sum_of_pair_of_ptrs(
             &mut ctx,
-            &host_memory,
+            &mut memory,
             self.input_struct_loc.ptr as i32,
             self.return_loc.ptr as i32,
         )
@@ -222,9 +240,8 @@ impl SumPairPtrsExercise {
 
         assert_eq!(res, types::Errno::Ok as i32, "sum of pair of ptrs errno");
 
-        let doubled: i64 = host_memory
-            .ptr(self.return_loc.ptr)
-            .read()
+        let doubled: i64 = memory
+            .read(GuestPtr::new(self.return_loc.ptr))
             .expect("return ref");
 
         assert_eq!(
@@ -277,24 +294,28 @@ impl SumIntAndPtrExercise {
     }
     pub fn test(&self) {
         let mut ctx = WasiCtx::new();
-        let host_memory = HostMemory::new();
+        let mut host_memory = HostMemory::new();
+        let mut memory = host_memory.guest_memory();
 
-        host_memory
-            .ptr(self.input_first_loc.ptr)
-            .write(self.input_first)
+        memory
+            .write(GuestPtr::new(self.input_first_loc.ptr), self.input_first)
             .expect("input_first ref");
-        host_memory
-            .ptr(self.input_struct_loc.ptr)
-            .write(self.input_first_loc.ptr)
+        memory
+            .write(
+                GuestPtr::new(self.input_struct_loc.ptr),
+                self.input_first_loc.ptr,
+            )
             .expect("input_struct ref");
-        host_memory
-            .ptr(self.input_struct_loc.ptr + 4)
-            .write(self.input_second)
+        memory
+            .write(
+                GuestPtr::new(self.input_struct_loc.ptr + 4),
+                self.input_second,
+            )
             .expect("input_struct ref");
 
         let res = records::sum_of_int_and_ptr(
             &mut ctx,
-            &host_memory,
+            &mut memory,
             self.input_struct_loc.ptr as i32,
             self.return_loc.ptr as i32,
         )
@@ -302,9 +323,8 @@ impl SumIntAndPtrExercise {
 
         assert_eq!(res, types::Errno::Ok as i32, "sum of int and ptr errno");
 
-        let doubled: i64 = host_memory
-            .ptr(self.return_loc.ptr)
-            .read()
+        let doubled: i64 = memory
+            .read(GuestPtr::new(self.return_loc.ptr))
             .expect("return ref");
 
         assert_eq!(
@@ -335,16 +355,16 @@ impl ReturnPairInts {
 
     pub fn test(&self) {
         let mut ctx = WasiCtx::new();
-        let host_memory = HostMemory::new();
+        let mut host_memory = HostMemory::new();
+        let mut memory = host_memory.guest_memory();
 
         let err =
-            records::return_pair_ints(&mut ctx, &host_memory, self.return_loc.ptr as i32).unwrap();
+            records::return_pair_ints(&mut ctx, &mut memory, self.return_loc.ptr as i32).unwrap();
 
         assert_eq!(err, types::Errno::Ok as i32, "return struct errno");
 
-        let return_struct: types::PairInts = host_memory
-            .ptr(self.return_loc.ptr)
-            .read()
+        let return_struct: types::PairInts = memory
+            .read(GuestPtr::new(self.return_loc.ptr))
             .expect("return ref");
 
         assert_eq!(
@@ -401,20 +421,19 @@ impl ReturnPairPtrsExercise {
     }
     pub fn test(&self) {
         let mut ctx = WasiCtx::new();
-        let host_memory = HostMemory::new();
+        let mut host_memory = HostMemory::new();
+        let mut memory = host_memory.guest_memory();
 
-        host_memory
-            .ptr(self.input_first_loc.ptr)
-            .write(self.input_first)
+        memory
+            .write(GuestPtr::new(self.input_first_loc.ptr), self.input_first)
             .expect("input_first ref");
-        host_memory
-            .ptr(self.input_second_loc.ptr)
-            .write(self.input_second)
+        memory
+            .write(GuestPtr::new(self.input_second_loc.ptr), self.input_second)
             .expect("input_second ref");
 
         let res = records::return_pair_of_ptrs(
             &mut ctx,
-            &host_memory,
+            &mut memory,
             self.input_first_loc.ptr as i32,
             self.input_second_loc.ptr as i32,
             self.return_loc.ptr as i32,
@@ -423,22 +442,21 @@ impl ReturnPairPtrsExercise {
 
         assert_eq!(res, types::Errno::Ok as i32, "return pair of ptrs errno");
 
-        let ptr_pair_int_ptrs: types::PairIntPtrs<'_> = host_memory
-            .ptr(self.return_loc.ptr)
-            .read()
+        let ptr_pair_int_ptrs: types::PairIntPtrs = memory
+            .read(GuestPtr::new(self.return_loc.ptr))
             .expect("failed to read return location");
         let ret_first_ptr = ptr_pair_int_ptrs.first;
         let ret_second_ptr = ptr_pair_int_ptrs.second;
         assert_eq!(
             self.input_first,
-            ret_first_ptr
-                .read()
+            memory
+                .read(ret_first_ptr)
                 .expect("deref extracted ptr to first element")
         );
         assert_eq!(
             self.input_second,
-            ret_second_ptr
-                .read()
+            memory
+                .read(ret_second_ptr)
                 .expect("deref extracted ptr to second element")
         );
     }
@@ -472,7 +490,7 @@ impl SumArrayExercise {
             .prop_filter(
                 "non-overlapping input struct and output pointers",
                 |(_inputs, input_struct_loc, output_loc)| {
-                    MemArea::non_overlapping_set(&[input_struct_loc.clone(), output_loc.clone()])
+                    MemArea::non_overlapping_set(&[*input_struct_loc, *output_loc])
                 },
             )
             .prop_flat_map(|(inputs, input_struct_loc, output_loc)| {
@@ -483,8 +501,8 @@ impl SumArrayExercise {
                         1,
                         &MemAreas::from([input_struct_loc, output_loc]),
                     ),
-                    Just(input_struct_loc.clone()),
-                    Just(output_loc.clone()),
+                    Just(input_struct_loc),
+                    Just(output_loc),
                 )
             })
             .prop_map(
@@ -499,31 +517,35 @@ impl SumArrayExercise {
     }
     pub fn test(&self) {
         let mut ctx = WasiCtx::new();
-        let host_memory = HostMemory::new();
+        let mut host_memory = HostMemory::new();
+        let mut memory = host_memory.guest_memory();
 
         // Write inputs to memory as an array
         for (ix, val) in self.inputs.iter().enumerate() {
             let ix = ix as u32;
-            host_memory
-                .ptr(self.input_array_loc.ptr + ix)
-                .write(*val)
+            memory
+                .write(GuestPtr::new(self.input_array_loc.ptr + ix), *val)
                 .expect("write val to array memory");
         }
 
         // Write struct that contains the array
-        host_memory
-            .ptr(self.input_struct_loc.ptr)
-            .write(self.input_array_loc.ptr)
+        memory
+            .write(
+                GuestPtr::new(self.input_struct_loc.ptr),
+                self.input_array_loc.ptr,
+            )
             .expect("write ptr to struct memory");
-        host_memory
-            .ptr(self.input_struct_loc.ptr + 4)
-            .write(self.inputs.len() as u32)
+        memory
+            .write(
+                GuestPtr::new(self.input_struct_loc.ptr + 4),
+                self.inputs.len() as u32,
+            )
             .expect("write len to struct memory");
 
         // Call wiggle-generated func
         let res = records::sum_array(
             &mut ctx,
-            &host_memory,
+            &mut memory,
             self.input_struct_loc.ptr as i32,
             self.output_loc.ptr as i32,
         )
@@ -536,9 +558,8 @@ impl SumArrayExercise {
         let expected: u16 = self.inputs.iter().map(|v| *v as u16).sum();
 
         // Wiggle stored output value in memory as u16
-        let given: u16 = host_memory
-            .ptr(self.output_loc.ptr)
-            .read()
+        let given: u16 = memory
+            .read(GuestPtr::new(self.output_loc.ptr))
             .expect("deref ptr to returned value");
 
         // Assert the two calculations match
diff --git a/crates/wiggle/tests/strings.rs b/crates/wiggle/tests/strings.rs
index a3ccdcab945a..6e820d209e31 100644
--- a/crates/wiggle/tests/strings.rs
+++ b/crates/wiggle/tests/strings.rs
@@ -9,9 +9,13 @@ wiggle::from_witx!({
 impl_errno!(types::Errno);
 
 impl<'a> strings::Strings for WasiCtx<'a> {
-    fn hello_string(&mut self, a_string: &GuestPtr<str>) -> Result<u32, types::Errno> {
-        let s = a_string
-            .as_str()
+    fn hello_string(
+        &mut self,
+        memory: &mut GuestMemory<'_>,
+        a_string: GuestPtr<str>,
+    ) -> Result<u32, types::Errno> {
+        let s = memory
+            .as_str(a_string)
             .expect("should be valid string")
             .expect("expected non-shared memory");
         println!("a_string='{}'", &*s);
@@ -20,20 +24,21 @@ impl<'a> strings::Strings for WasiCtx<'a> {
 
     fn multi_string(
         &mut self,
-        a: &GuestPtr<str>,
-        b: &GuestPtr<str>,
-        c: &GuestPtr<str>,
+        memory: &mut GuestMemory<'_>,
+        a: GuestPtr<str>,
+        b: GuestPtr<str>,
+        c: GuestPtr<str>,
     ) -> Result<u32, types::Errno> {
-        let sa = a
-            .as_str()
+        let sa = memory
+            .as_str(a)
             .expect("A should be valid string")
             .expect("expected non-shared memory");
-        let sb = b
-            .as_str()
+        let sb = memory
+            .as_str(b)
             .expect("B should be valid string")
             .expect("expected non-shared memory");
-        let sc = c
-            .as_str()
+        let sc = memory
+            .as_str(c)
             .expect("C should be valid string")
             .expect("expected non-shared memory");
         let total_len = sa.len() + sb.len() + sc.len();
@@ -82,19 +87,20 @@ impl HelloStringExercise {
 
     pub fn test(&self) {
         let mut ctx = WasiCtx::new();
-        let host_memory = HostMemory::new();
+        let mut host_memory = HostMemory::new();
+        let mut memory = host_memory.guest_memory();
 
         // Populate string in guest's memory
-        let ptr = host_memory.ptr::<str>((self.string_ptr_loc.ptr, self.test_word.len() as u32));
+        let ptr = GuestPtr::<str>::new((self.string_ptr_loc.ptr, self.test_word.len() as u32));
         for (slot, byte) in ptr.as_bytes().iter().zip(self.test_word.bytes()) {
-            slot.expect("should be valid pointer")
-                .write(byte)
+            memory
+                .write(slot.expect("should be valid pointer"), byte)
                 .expect("failed to write");
         }
 
         let res = strings::hello_string(
             &mut ctx,
-            &host_memory,
+            &mut memory,
             self.string_ptr_loc.ptr as i32,
             self.test_word.len() as i32,
             self.return_ptr_loc.ptr as i32,
@@ -102,9 +108,8 @@ impl HelloStringExercise {
         .unwrap();
         assert_eq!(res, types::Errno::Ok as i32, "hello string errno");
 
-        let given = host_memory
-            .ptr::<u32>(self.return_ptr_loc.ptr)
-            .read()
+        let given = memory
+            .read(GuestPtr::<u32>::new(self.return_ptr_loc.ptr))
             .expect("deref ptr to return value");
         assert_eq!(self.test_word.len() as u32, given);
     }
@@ -195,13 +200,14 @@ impl MultiStringExercise {
 
     pub fn test(&self) {
         let mut ctx = WasiCtx::new();
-        let host_memory = HostMemory::new();
+        let mut host_memory = HostMemory::new();
+        let mut memory = host_memory.guest_memory();
 
-        let write_string = |val: &str, loc: MemArea| {
-            let ptr = host_memory.ptr::<str>((loc.ptr, val.len() as u32));
+        let mut write_string = |val: &str, loc: MemArea| {
+            let ptr = GuestPtr::<str>::new((loc.ptr, val.len() as u32));
             for (slot, byte) in ptr.as_bytes().iter().zip(val.bytes()) {
-                slot.expect("should be valid pointer")
-                    .write(byte)
+                memory
+                    .write(slot.expect("should be valid pointer"), byte)
                     .expect("failed to write");
             }
         };
@@ -212,7 +218,7 @@ impl MultiStringExercise {
 
         let res = strings::multi_string(
             &mut ctx,
-            &host_memory,
+            &mut memory,
             self.sa_ptr_loc.ptr as i32,
             self.a.len() as i32,
             self.sb_ptr_loc.ptr as i32,
@@ -224,9 +230,8 @@ impl MultiStringExercise {
         .unwrap();
         assert_eq!(res, types::Errno::Ok as i32, "multi string errno");
 
-        let given = host_memory
-            .ptr::<u32>(self.return_ptr_loc.ptr)
-            .read()
+        let given = memory
+            .read(GuestPtr::<u32>::new(self.return_ptr_loc.ptr))
             .expect("deref ptr to return value");
         assert_eq!((self.a.len() + self.b.len() + self.c.len()) as u32, given);
     }
@@ -275,13 +280,14 @@ impl OverlappingStringExercise {
 
     pub fn test(&self) {
         let mut ctx = WasiCtx::new();
-        let host_memory = HostMemory::new();
+        let mut host_memory = HostMemory::new();
+        let mut memory = host_memory.guest_memory();
 
-        let write_string = |val: &str, loc: MemArea| {
-            let ptr = host_memory.ptr::<str>((loc.ptr, val.len() as u32));
+        let mut write_string = |val: &str, loc: MemArea| {
+            let ptr = GuestPtr::<str>::new((loc.ptr, val.len() as u32));
             for (slot, byte) in ptr.as_bytes().iter().zip(val.bytes()) {
-                slot.expect("should be valid pointer")
-                    .write(byte)
+                memory
+                    .write(slot.expect("should be valid pointer"), byte)
                     .expect("failed to write");
             }
         };
@@ -291,7 +297,7 @@ impl OverlappingStringExercise {
         let a_len = self.a.as_bytes().len() as i32;
         let res = strings::multi_string(
             &mut ctx,
-            &host_memory,
+            &mut memory,
             self.sa_ptr_loc.ptr as i32,
             a_len,
             (self.sa_ptr_loc.ptr + self.offset_b) as i32,
@@ -303,9 +309,8 @@ impl OverlappingStringExercise {
         .unwrap();
         assert_eq!(res, types::Errno::Ok as i32, "multi string errno");
 
-        let given = host_memory
-            .ptr::<u32>(self.return_ptr_loc.ptr)
-            .read()
+        let given = memory
+            .read(GuestPtr::<u32>::new(self.return_ptr_loc.ptr))
             .expect("deref ptr to return value");
         assert_eq!(
             ((3 * a_len) - (self.offset_b as i32 + self.offset_c as i32)) as u32,
diff --git a/crates/wiggle/tests/typenames.witx b/crates/wiggle/tests/typenames.witx
index df60c5c34e17..5cb1c0a13028 100644
--- a/crates/wiggle/tests/typenames.witx
+++ b/crates/wiggle/tests/typenames.witx
@@ -523,7 +523,7 @@
     (field $userdata $userdata)
     ;;; If non-zero, an error that occurred while processing the subscription request.
     (field $error $errno)
-    ;;; The type of event that occured
+    ;;; The type of event that occurred
     (field $type $eventtype)
     ;;; The contents of the event, if it is an `eventtype::fd_read` or
     ;;; `eventtype::fd_write`. `eventtype::clock` events ignore this field.
diff --git a/crates/wiggle/tests/variant.rs b/crates/wiggle/tests/variant.rs
index c6b5ab4d58aa..43c2943cc167 100644
--- a/crates/wiggle/tests/variant.rs
+++ b/crates/wiggle/tests/variant.rs
@@ -1,5 +1,5 @@
 use proptest::prelude::*;
-use wiggle::{GuestMemory, GuestType};
+use wiggle::{GuestMemory, GuestPtr, GuestType};
 use wiggle_test::{impl_errno, HostMemory, MemArea, WasiCtx};
 
 wiggle::from_witx!({
@@ -31,8 +31,12 @@ fn mult_zero_nan(a: f32, b: u32) -> f32 {
 }
 
 impl<'a> variant_example::VariantExample for WasiCtx<'a> {
-    fn get_tag(&mut self, u: &types::Reason) -> Result<types::Excuse, types::Errno> {
-        println!("GET TAG: {:?}", u);
+    fn get_tag(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        u: &types::Reason,
+    ) -> Result<types::Excuse, types::Errno> {
+        println!("GET TAG: {u:?}");
         match u {
             types::Reason::DogAte { .. } => Ok(types::Excuse::DogAte),
             types::Reason::Traffic { .. } => Ok(types::Excuse::Traffic),
@@ -41,20 +45,23 @@ impl<'a> variant_example::VariantExample for WasiCtx<'a> {
     }
     fn reason_mult(
         &mut self,
-        u: &types::ReasonMut<'_>,
+        memory: &mut GuestMemory<'_>,
+        u: &types::ReasonMut,
         multiply_by: u32,
     ) -> Result<(), types::Errno> {
         match u {
             types::ReasonMut::DogAte(fptr) => {
-                let val = fptr.read().expect("valid pointer");
-                println!("REASON MULT DogAte({})", val);
-                fptr.write(mult_zero_nan(val, multiply_by))
+                let val = memory.read(*fptr).expect("valid pointer");
+                println!("REASON MULT DogAte({val})");
+                memory
+                    .write(*fptr, mult_zero_nan(val, multiply_by))
                     .expect("valid pointer");
             }
             types::ReasonMut::Traffic(iptr) => {
-                let val = iptr.read().expect("valid pointer");
-                println!("REASON MULT Traffic({})", val);
-                iptr.write(mult_lose_overflow(val, multiply_by))
+                let val = memory.read(*iptr).expect("valid pointer");
+                println!("REASON MULT Traffic({val})");
+                memory
+                    .write(*iptr, mult_lose_overflow(val, multiply_by))
                     .expect("valid pointer");
             }
             types::ReasonMut::Sleeping => {
@@ -109,29 +116,27 @@ impl GetTagExercise {
 
     pub fn test(&self) {
         let mut ctx = WasiCtx::new();
-        let host_memory = HostMemory::new();
+        let mut host_memory = HostMemory::new();
+        let mut memory = host_memory.guest_memory();
 
         let discriminant = reason_tag(&self.input) as u8;
-        host_memory
-            .ptr(self.input_loc.ptr)
-            .write(discriminant)
+        memory
+            .write(GuestPtr::new(self.input_loc.ptr), discriminant)
             .expect("input discriminant ptr");
         match self.input {
             types::Reason::DogAte(f) => {
-                host_memory
-                    .ptr(self.input_loc.ptr + 4)
-                    .write(f)
+                memory
+                    .write(GuestPtr::new(self.input_loc.ptr + 4), f)
                     .expect("input contents ref_mut");
             }
-            types::Reason::Traffic(v) => host_memory
-                .ptr(self.input_loc.ptr + 4)
-                .write(v)
+            types::Reason::Traffic(v) => memory
+                .write(GuestPtr::new(self.input_loc.ptr + 4), v)
                 .expect("input contents ref_mut"),
             types::Reason::Sleeping => {} // Do nothing
         }
         let e = variant_example::get_tag(
             &mut ctx,
-            &host_memory,
+            &mut memory,
             self.input_loc.ptr as i32,
             self.return_loc.ptr as i32,
         )
@@ -139,9 +144,8 @@ impl GetTagExercise {
 
         assert_eq!(e, types::Errno::Ok as i32, "get_tag errno");
 
-        let return_val: types::Excuse = host_memory
-            .ptr(self.return_loc.ptr)
-            .read()
+        let return_val: types::Excuse = memory
+            .read(GuestPtr::new(self.return_loc.ptr))
             .expect("return ref");
 
         assert_eq!(return_val, reason_tag(&self.input), "get_tag return value");
@@ -187,36 +191,36 @@ impl ReasonMultExercise {
 
     pub fn test(&self) {
         let mut ctx = WasiCtx::new();
-        let host_memory = HostMemory::new();
+        let mut host_memory = HostMemory::new();
+        let mut memory = host_memory.guest_memory();
 
         let discriminant = reason_tag(&self.input) as u8;
-        host_memory
-            .ptr(self.input_loc.ptr)
-            .write(discriminant)
+        memory
+            .write(GuestPtr::new(self.input_loc.ptr), discriminant)
             .expect("input discriminant ref_mut");
-        host_memory
-            .ptr(self.input_loc.ptr + 4)
-            .write(self.input_pointee_loc.ptr)
+        memory
+            .write(
+                GuestPtr::new(self.input_loc.ptr + 4),
+                self.input_pointee_loc.ptr,
+            )
             .expect("input pointer ref_mut");
 
         match self.input {
             types::Reason::DogAte(f) => {
-                host_memory
-                    .ptr(self.input_pointee_loc.ptr)
-                    .write(f)
+                memory
+                    .write(GuestPtr::new(self.input_pointee_loc.ptr), f)
                     .expect("input contents ref_mut");
             }
             types::Reason::Traffic(v) => {
-                host_memory
-                    .ptr(self.input_pointee_loc.ptr)
-                    .write(v)
+                memory
+                    .write(GuestPtr::new(self.input_pointee_loc.ptr), v)
                     .expect("input contents ref_mut");
             }
             types::Reason::Sleeping => {} // Do nothing
         }
         let e = variant_example::reason_mult(
             &mut ctx,
-            &host_memory,
+            &mut memory,
             self.input_loc.ptr as i32,
             self.multiply_by as i32,
         )
@@ -226,9 +230,8 @@ impl ReasonMultExercise {
 
         match self.input {
             types::Reason::DogAte(f) => {
-                let f_result: f32 = host_memory
-                    .ptr(self.input_pointee_loc.ptr)
-                    .read()
+                let f_result: f32 = memory
+                    .read(GuestPtr::new(self.input_pointee_loc.ptr))
                     .expect("input contents ref_mut");
                 assert_eq!(
                     mult_zero_nan(f, self.multiply_by),
@@ -237,9 +240,8 @@ impl ReasonMultExercise {
                 )
             }
             types::Reason::Traffic(v) => {
-                let v_result: i32 = host_memory
-                    .ptr(self.input_pointee_loc.ptr)
-                    .read()
+                let v_result: i32 = memory
+                    .read(GuestPtr::new(self.input_pointee_loc.ptr))
                     .expect("input contents ref_mut");
                 assert_eq!(
                     mult_lose_overflow(v, self.multiply_by),
diff --git a/crates/wiggle/tests/wasi.rs b/crates/wiggle/tests/wasi.rs
index 6f0b4880ff3c..8056bda8ff0d 100644
--- a/crates/wiggle/tests/wasi.rs
+++ b/crates/wiggle/tests/wasi.rs
@@ -1,4 +1,4 @@
-use wiggle::{GuestErrorType, GuestPtr, GuestSlice};
+use wiggle::{GuestErrorType, GuestMemory, GuestPtr};
 use wiggle_test::WasiCtx;
 
 // This test file exists to make sure that the entire `wasi.witx` file can be
@@ -32,32 +32,49 @@ impl GuestErrorType for types::Errno {
 }
 
 impl<'a> crate::wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx<'a> {
-    fn args_get(&mut self, _argv: &GuestPtr<GuestPtr<u8>>, _argv_buf: &GuestPtr<u8>) -> Result<()> {
+    fn args_get(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        _argv: GuestPtr<GuestPtr<u8>>,
+        _argv_buf: GuestPtr<u8>,
+    ) -> Result<()> {
         unimplemented!("args_get")
     }
 
-    fn args_sizes_get(&mut self) -> Result<(types::Size, types::Size)> {
+    fn args_sizes_get(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+    ) -> Result<(types::Size, types::Size)> {
         unimplemented!("args_sizes_get")
     }
 
     fn environ_get(
         &mut self,
-        _environ: &GuestPtr<GuestPtr<u8>>,
-        _environ_buf: &GuestPtr<u8>,
+        _memory: &mut GuestMemory<'_>,
+        _environ: GuestPtr<GuestPtr<u8>>,
+        _environ_buf: GuestPtr<u8>,
     ) -> Result<()> {
         unimplemented!("environ_get")
     }
 
-    fn environ_sizes_get(&mut self) -> Result<(types::Size, types::Size)> {
+    fn environ_sizes_get(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+    ) -> Result<(types::Size, types::Size)> {
         unimplemented!("environ_sizes_get")
     }
 
-    fn clock_res_get(&mut self, _id: types::Clockid) -> Result<types::Timestamp> {
+    fn clock_res_get(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        _id: types::Clockid,
+    ) -> Result<types::Timestamp> {
         unimplemented!("clock_res_get")
     }
 
     fn clock_time_get(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         _id: types::Clockid,
         _precision: types::Timestamp,
     ) -> Result<types::Timestamp> {
@@ -66,6 +83,7 @@ impl<'a> crate::wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx<'a> {
 
     fn fd_advise(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         _fd: types::Fd,
         _offset: types::Filesize,
         _len: types::Filesize,
@@ -76,6 +94,7 @@ impl<'a> crate::wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx<'a> {
 
     fn fd_allocate(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         _fd: types::Fd,
         _offset: types::Filesize,
         _len: types::Filesize,
@@ -83,24 +102,34 @@ impl<'a> crate::wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx<'a> {
         unimplemented!("fd_allocate")
     }
 
-    fn fd_close(&mut self, _fd: types::Fd) -> Result<()> {
+    fn fd_close(&mut self, _memory: &mut GuestMemory<'_>, _fd: types::Fd) -> Result<()> {
         unimplemented!("fd_close")
     }
 
-    fn fd_datasync(&mut self, _fd: types::Fd) -> Result<()> {
+    fn fd_datasync(&mut self, _memory: &mut GuestMemory<'_>, _fd: types::Fd) -> Result<()> {
         unimplemented!("fd_datasync")
     }
 
-    fn fd_fdstat_get(&mut self, _fd: types::Fd) -> Result<types::Fdstat> {
+    fn fd_fdstat_get(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        _fd: types::Fd,
+    ) -> Result<types::Fdstat> {
         unimplemented!("fd_fdstat_get")
     }
 
-    fn fd_fdstat_set_flags(&mut self, _fd: types::Fd, _flags: types::Fdflags) -> Result<()> {
+    fn fd_fdstat_set_flags(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        _fd: types::Fd,
+        _flags: types::Fdflags,
+    ) -> Result<()> {
         unimplemented!("fd_fdstat_set_flags")
     }
 
     fn fd_fdstat_set_rights(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         _fd: types::Fd,
         _fs_rights_base: types::Rights,
         _fs_rights_inherting: types::Rights,
@@ -108,16 +137,26 @@ impl<'a> crate::wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx<'a> {
         unimplemented!("fd_fdstat_set_rights")
     }
 
-    fn fd_filestat_get(&mut self, _fd: types::Fd) -> Result<types::Filestat> {
+    fn fd_filestat_get(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        _fd: types::Fd,
+    ) -> Result<types::Filestat> {
         unimplemented!("fd_filestat_get")
     }
 
-    fn fd_filestat_set_size(&mut self, _fd: types::Fd, _size: types::Filesize) -> Result<()> {
+    fn fd_filestat_set_size(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        _fd: types::Fd,
+        _size: types::Filesize,
+    ) -> Result<()> {
         unimplemented!("fd_filestat_set_size")
     }
 
     fn fd_filestat_set_times(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         _fd: types::Fd,
         _atim: types::Timestamp,
         _mtim: types::Timestamp,
@@ -128,47 +167,27 @@ impl<'a> crate::wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx<'a> {
 
     fn fd_pread(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         _fd: types::Fd,
-        iovs: &types::IovecArray<'_>,
+        _iovs: types::IovecArray,
         _offset: types::Filesize,
     ) -> Result<types::Size> {
-        // This is not functional code, but the type annotations demonstrate
-        // that we can use the wiggle API to create the datastructures we want
-        // for efficient implementation of this function elsewhere.
-
-        let mut slices: Vec<GuestSlice<'_, u8>> = Vec::new();
-        for iov_ptr in iovs.iter() {
-            let iov_ptr = iov_ptr.expect("iovec element pointer is valid");
-
-            // Borrow checker will make sure the pointee of this read() doesn't overlap with any
-            // existing borrows:
-            let iov: types::Iovec = iov_ptr.read().expect("read iovec element");
-            let base: GuestPtr<u8> = iov.buf;
-            let len: u32 = iov.buf_len;
-            let buf: GuestPtr<[u8]> = base.as_array(len);
-            // GuestSlice will remain borrowed until dropped:
-            let slice = buf
-                .as_slice()
-                .expect("borrow slice from iovec")
-                .expect("expected non-shared memory");
-            slices.push(slice);
-        }
-        println!("iovec slices: [");
-        for slice in slices {
-            println!("  {:?},", &*slice);
-        }
-        println!("]");
         unimplemented!("fd_pread")
     }
 
-    fn fd_prestat_get(&mut self, _fd: types::Fd) -> Result<types::Prestat> {
+    fn fd_prestat_get(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        _fd: types::Fd,
+    ) -> Result<types::Prestat> {
         unimplemented!("fd_prestat_get")
     }
 
     fn fd_prestat_dir_name(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         _fd: types::Fd,
-        _path: &GuestPtr<u8>,
+        _path: GuestPtr<u8>,
         _path_len: types::Size,
     ) -> Result<()> {
         unimplemented!("fd_prestat_dir_name")
@@ -176,33 +195,46 @@ impl<'a> crate::wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx<'a> {
 
     fn fd_pwrite(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         _fd: types::Fd,
-        _ciovs: &types::CiovecArray<'_>,
+        _ciovs: types::CiovecArray,
         _offset: types::Filesize,
     ) -> Result<types::Size> {
         unimplemented!("fd_pwrite")
     }
 
-    fn fd_read(&mut self, _fd: types::Fd, _iovs: &types::IovecArray<'_>) -> Result<types::Size> {
+    fn fd_read(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        _fd: types::Fd,
+        _iovs: types::IovecArray,
+    ) -> Result<types::Size> {
         unimplemented!("fd_read")
     }
 
     fn fd_readdir(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         _fd: types::Fd,
-        _buf: &GuestPtr<u8>,
+        _buf: GuestPtr<u8>,
         _buf_len: types::Size,
         _cookie: types::Dircookie,
     ) -> Result<types::Size> {
         unimplemented!("fd_readdir")
     }
 
-    fn fd_renumber(&mut self, _fd: types::Fd, _to: types::Fd) -> Result<()> {
+    fn fd_renumber(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        _fd: types::Fd,
+        _to: types::Fd,
+    ) -> Result<()> {
         unimplemented!("fd_renumber")
     }
 
     fn fd_seek(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         _fd: types::Fd,
         _offset: types::Filedelta,
         _whence: types::Whence,
@@ -210,36 +242,52 @@ impl<'a> crate::wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx<'a> {
         unimplemented!("fd_seek")
     }
 
-    fn fd_sync(&mut self, _fd: types::Fd) -> Result<()> {
+    fn fd_sync(&mut self, _memory: &mut GuestMemory<'_>, _fd: types::Fd) -> Result<()> {
         unimplemented!("fd_sync")
     }
 
-    fn fd_tell(&mut self, _fd: types::Fd) -> Result<types::Filesize> {
+    fn fd_tell(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        _fd: types::Fd,
+    ) -> Result<types::Filesize> {
         unimplemented!("fd_tell")
     }
 
-    fn fd_write(&mut self, _fd: types::Fd, _ciovs: &types::CiovecArray<'_>) -> Result<types::Size> {
+    fn fd_write(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        _fd: types::Fd,
+        _ciovs: types::CiovecArray,
+    ) -> Result<types::Size> {
         unimplemented!("fd_write")
     }
 
-    fn path_create_directory(&mut self, _fd: types::Fd, _path: &GuestPtr<'_, str>) -> Result<()> {
+    fn path_create_directory(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        _fd: types::Fd,
+        _path: GuestPtr<str>,
+    ) -> Result<()> {
         unimplemented!("path_create_directory")
     }
 
     fn path_filestat_get(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         _fd: types::Fd,
         _flags: types::Lookupflags,
-        _path: &GuestPtr<'_, str>,
+        _path: GuestPtr<str>,
     ) -> Result<types::Filestat> {
         unimplemented!("path_filestat_get")
     }
 
     fn path_filestat_set_times(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         _fd: types::Fd,
         _flags: types::Lookupflags,
-        _path: &GuestPtr<'_, str>,
+        _path: GuestPtr<str>,
         _atim: types::Timestamp,
         _mtim: types::Timestamp,
         _fst_flags: types::Fstflags,
@@ -249,20 +297,22 @@ impl<'a> crate::wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx<'a> {
 
     fn path_link(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         _old_fd: types::Fd,
         _old_flags: types::Lookupflags,
-        _old_path: &GuestPtr<'_, str>,
+        _old_path: GuestPtr<str>,
         _new_fd: types::Fd,
-        _new_path: &GuestPtr<'_, str>,
+        _new_path: GuestPtr<str>,
     ) -> Result<()> {
         unimplemented!("path_link")
     }
 
     fn path_open(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         _fd: types::Fd,
         _dirflags: types::Lookupflags,
-        _path: &GuestPtr<'_, str>,
+        _path: GuestPtr<str>,
         _oflags: types::Oflags,
         _fs_rights_base: types::Rights,
         _fs_rights_inherting: types::Rights,
@@ -273,70 +323,94 @@ impl<'a> crate::wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx<'a> {
 
     fn path_readlink(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         _fd: types::Fd,
-        _path: &GuestPtr<'_, str>,
-        _buf: &GuestPtr<u8>,
+        _path: GuestPtr<str>,
+        _buf: GuestPtr<u8>,
         _buf_len: types::Size,
     ) -> Result<types::Size> {
         unimplemented!("path_readlink")
     }
 
-    fn path_remove_directory(&mut self, _fd: types::Fd, _path: &GuestPtr<'_, str>) -> Result<()> {
+    fn path_remove_directory(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        _fd: types::Fd,
+        _path: GuestPtr<str>,
+    ) -> Result<()> {
         unimplemented!("path_remove_directory")
     }
 
     fn path_rename(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         _fd: types::Fd,
-        _old_path: &GuestPtr<'_, str>,
+        _old_path: GuestPtr<str>,
         _new_fd: types::Fd,
-        _new_path: &GuestPtr<'_, str>,
+        _new_path: GuestPtr<str>,
     ) -> Result<()> {
         unimplemented!("path_rename")
     }
 
     fn path_symlink(
         &mut self,
-        _old_path: &GuestPtr<'_, str>,
+        _memory: &mut GuestMemory<'_>,
+        _old_path: GuestPtr<str>,
         _fd: types::Fd,
-        _new_path: &GuestPtr<'_, str>,
+        _new_path: GuestPtr<str>,
     ) -> Result<()> {
         unimplemented!("path_symlink")
     }
 
-    fn path_unlink_file(&mut self, _fd: types::Fd, _path: &GuestPtr<'_, str>) -> Result<()> {
+    fn path_unlink_file(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        _fd: types::Fd,
+        _path: GuestPtr<str>,
+    ) -> Result<()> {
         unimplemented!("path_unlink_file")
     }
 
     fn poll_oneoff(
         &mut self,
-        _in_: &GuestPtr<types::Subscription>,
-        _out: &GuestPtr<types::Event>,
+        _memory: &mut GuestMemory<'_>,
+        _in_: GuestPtr<types::Subscription>,
+        _out: GuestPtr<types::Event>,
         _nsubscriptions: types::Size,
     ) -> Result<types::Size> {
         unimplemented!("poll_oneoff")
     }
 
-    fn proc_exit(&mut self, _rval: types::Exitcode) -> anyhow::Error {
+    fn proc_exit(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        _rval: types::Exitcode,
+    ) -> anyhow::Error {
         unimplemented!("proc_exit")
     }
 
-    fn proc_raise(&mut self, _sig: types::Signal) -> Result<()> {
+    fn proc_raise(&mut self, _memory: &mut GuestMemory<'_>, _sig: types::Signal) -> Result<()> {
         unimplemented!("proc_raise")
     }
 
-    fn sched_yield(&mut self) -> Result<()> {
+    fn sched_yield(&mut self, _memory: &mut GuestMemory<'_>) -> Result<()> {
         unimplemented!("sched_yield")
     }
 
-    fn random_get(&mut self, _buf: &GuestPtr<u8>, _buf_len: types::Size) -> Result<()> {
+    fn random_get(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        _buf: GuestPtr<u8>,
+        _buf_len: types::Size,
+    ) -> Result<()> {
         unimplemented!("random_get")
     }
 
     fn sock_recv(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         _fd: types::Fd,
-        _ri_data: &types::IovecArray<'_>,
+        _ri_data: types::IovecArray,
         _ri_flags: types::Riflags,
     ) -> Result<(types::Size, types::Roflags)> {
         unimplemented!("sock_recv")
@@ -344,14 +418,20 @@ impl<'a> crate::wasi_snapshot_preview1::WasiSnapshotPreview1 for WasiCtx<'a> {
 
     fn sock_send(
         &mut self,
+        _memory: &mut GuestMemory<'_>,
         _fd: types::Fd,
-        _si_data: &types::CiovecArray<'_>,
+        _si_data: types::CiovecArray,
         _si_flags: types::Siflags,
     ) -> Result<types::Size> {
         unimplemented!("sock_send")
     }
 
-    fn sock_shutdown(&mut self, _fd: types::Fd, _how: types::Sdflags) -> Result<()> {
+    fn sock_shutdown(
+        &mut self,
+        _memory: &mut GuestMemory<'_>,
+        _fd: types::Fd,
+        _how: types::Sdflags,
+    ) -> Result<()> {
         unimplemented!("sock_shutdown")
     }
 }
diff --git a/crates/wiggle/tests/wasmtime_async.rs b/crates/wiggle/tests/wasmtime_async.rs
index 19209f9fc21e..9833d75de798 100644
--- a/crates/wiggle/tests/wasmtime_async.rs
+++ b/crates/wiggle/tests/wasmtime_async.rs
@@ -1,4 +1,5 @@
 use wasmtime::{Config, Engine, Linker, Module, Store, Val};
+use wiggle::GuestMemory;
 
 wiggle::from_witx!({
     witx: ["$CARGO_MANIFEST_DIR/tests/atoms.witx"],
@@ -16,12 +17,18 @@ impl wiggle::GuestErrorType for types::Errno {
 
 #[wiggle::async_trait]
 impl atoms::Atoms for Ctx {
-    fn int_float_args(&mut self, an_int: u32, an_float: f32) -> Result<(), types::Errno> {
-        println!("INT FLOAT ARGS: {} {}", an_int, an_float);
+    fn int_float_args(
+        &mut self,
+        _: &mut GuestMemory<'_>,
+        an_int: u32,
+        an_float: f32,
+    ) -> Result<(), types::Errno> {
+        println!("INT FLOAT ARGS: {an_int} {an_float}");
         Ok(())
     }
     async fn double_int_return_float(
         &mut self,
+        _: &mut GuestMemory<'_>,
         an_int: u32,
     ) -> Result<types::AliasToFloat, types::Errno> {
         // Do something inside this test that is Pending for a trivial amount of time,
diff --git a/crates/wiggle/tests/wasmtime_integration.rs b/crates/wiggle/tests/wasmtime_integration.rs
index 8617c6d757cc..419dc70e2a39 100644
--- a/crates/wiggle/tests/wasmtime_integration.rs
+++ b/crates/wiggle/tests/wasmtime_integration.rs
@@ -1,4 +1,5 @@
 use wasmtime::{Engine, Linker, Module, Store, Val};
+use wiggle::GuestMemory;
 
 // from_witx invocation says the func is async. This context doesn't support async!
 wiggle::from_witx!({
@@ -28,12 +29,18 @@ impl wiggle::GuestErrorType for types::Errno {
 
 #[wiggle::async_trait]
 impl atoms::Atoms for Ctx {
-    fn int_float_args(&mut self, an_int: u32, an_float: f32) -> Result<(), types::Errno> {
-        println!("INT FLOAT ARGS: {} {}", an_int, an_float);
+    fn int_float_args(
+        &mut self,
+        _: &mut GuestMemory<'_>,
+        an_int: u32,
+        an_float: f32,
+    ) -> Result<(), types::Errno> {
+        println!("INT FLOAT ARGS: {an_int} {an_float}");
         Ok(())
     }
     async fn double_int_return_float(
         &mut self,
+        _: &mut GuestMemory<'_>,
         an_int: u32,
     ) -> Result<types::AliasToFloat, types::Errno> {
         Ok((an_int as f32) * 2.0)
diff --git a/crates/wiggle/tests/wasmtime_sync.rs b/crates/wiggle/tests/wasmtime_sync.rs
index 43c303286bc3..8152da0a7446 100644
--- a/crates/wiggle/tests/wasmtime_sync.rs
+++ b/crates/wiggle/tests/wasmtime_sync.rs
@@ -1,4 +1,5 @@
 use wasmtime::{Engine, Linker, Module, Store, Val};
+use wiggle::GuestMemory;
 
 wiggle::from_witx!({
     witx: ["$CARGO_MANIFEST_DIR/tests/atoms.witx"],
@@ -18,12 +19,18 @@ const TRIGGER_PENDING: u32 = 0;
 
 #[wiggle::async_trait]
 impl atoms::Atoms for Ctx {
-    fn int_float_args(&mut self, an_int: u32, an_float: f32) -> Result<(), types::Errno> {
-        println!("INT FLOAT ARGS: {} {}", an_int, an_float);
+    fn int_float_args(
+        &mut self,
+        _: &mut GuestMemory<'_>,
+        an_int: u32,
+        an_float: f32,
+    ) -> Result<(), types::Errno> {
+        println!("INT FLOAT ARGS: {an_int} {an_float}");
         Ok(())
     }
     async fn double_int_return_float(
         &mut self,
+        _: &mut GuestMemory<'_>,
         an_int: u32,
     ) -> Result<types::AliasToFloat, types::Errno> {
         if an_int == TRIGGER_PENDING {
@@ -132,9 +139,8 @@ fn test_async_host_func_pending() {
         )
         .unwrap_err();
     assert!(
-        format!("{:?}", trap).contains("Cannot wait on pending future"),
-        "expected get a pending future Trap from dummy executor, got: {}",
-        trap
+        format!("{trap:?}").contains("Cannot wait on pending future"),
+        "expected get a pending future Trap from dummy executor, got: {trap}"
     );
 }
 
diff --git a/crates/winch/Cargo.toml b/crates/winch/Cargo.toml
index c1901b2d8185..506abf459de6 100644
--- a/crates/winch/Cargo.toml
+++ b/crates/winch/Cargo.toml
@@ -4,20 +4,27 @@ description = "Integration between Wasmtime and Winch"
 version.workspace = true
 authors.workspace = true
 edition.workspace = true
+rust-version.workspace = true
 license = "Apache-2.0 WITH LLVM-exception"
 repository = "https://github.com/bytecodealliance/wasmtime"
 
+[lints]
+workspace = true
+
 [dependencies]
 winch-codegen = { workspace = true }
 target-lexicon = { workspace = true }
 wasmtime-environ = { workspace = true }
 anyhow = { workspace = true }
-object = { workspace = true }
+object = { workspace = true, features = ['std'] }
 cranelift-codegen = { workspace = true }
-wasmtime-cranelift-shared = { workspace = true }
+wasmtime-cranelift = { workspace = true }
 wasmparser = { workspace = true }
-gimli = { workspace = true }
+gimli = { workspace = true, features = ['std'] }
 
 [features]
-component-model = ["wasmtime-environ/component-model"]
+component-model = [
+    "wasmtime-environ/component-model",
+    "wasmtime-cranelift/component-model",
+]
 all-arch = ["winch-codegen/all-arch"]
diff --git a/crates/winch/src/builder.rs b/crates/winch/src/builder.rs
index d9d534cc7a74..dfe0412183be 100644
--- a/crates/winch/src/builder.rs
+++ b/crates/winch/src/builder.rs
@@ -1,19 +1,28 @@
 use crate::compiler::Compiler;
 use anyhow::{bail, Result};
 use std::sync::Arc;
-use wasmtime_cranelift_shared::isa_builder::IsaBuilder;
-use wasmtime_environ::{CompilerBuilder, Setting};
+use target_lexicon::Triple;
+use wasmtime_cranelift::isa_builder::IsaBuilder;
+use wasmtime_environ::{CompilerBuilder, Setting, Tunables};
 use winch_codegen::{isa, TargetIsa};
 
 /// Compiler builder.
 struct Builder {
     inner: IsaBuilder<Result<Box<dyn TargetIsa>>>,
+    cranelift: Box<dyn CompilerBuilder>,
+    tunables: Option<Tunables>,
 }
 
-pub fn builder() -> Box<dyn CompilerBuilder> {
-    Box::new(Builder {
-        inner: IsaBuilder::new(|triple| isa::lookup(triple).map_err(|e| e.into())),
-    })
+pub fn builder(triple: Option<Triple>) -> Result<Box<dyn CompilerBuilder>> {
+    let inner = IsaBuilder::new(triple.clone(), |triple| {
+        isa::lookup(triple).map_err(|e| e.into())
+    })?;
+    let cranelift = wasmtime_cranelift::builder(triple)?;
+    Ok(Box::new(Builder {
+        inner,
+        cranelift,
+        tunables: None,
+    }))
 }
 
 impl CompilerBuilder for Builder {
@@ -22,31 +31,43 @@ impl CompilerBuilder for Builder {
     }
 
     fn target(&mut self, target: target_lexicon::Triple) -> Result<()> {
-        self.inner.target(target)?;
+        self.inner.target(target.clone())?;
+        self.cranelift.target(target)?;
         Ok(())
     }
 
     fn set(&mut self, name: &str, value: &str) -> Result<()> {
-        self.inner.set(name, value)
+        self.inner.set(name, value)?;
+        self.cranelift.set(name, value)?;
+        Ok(())
     }
 
     fn enable(&mut self, name: &str) -> Result<()> {
-        self.inner.enable(name)
+        self.inner.enable(name)?;
+        self.cranelift.enable(name)?;
+        Ok(())
     }
 
     fn settings(&self) -> Vec<Setting> {
         self.inner.settings()
     }
 
-    fn set_tunables(&mut self, tunables: wasmtime_environ::Tunables) -> Result<()> {
-        let _ = tunables;
+    fn set_tunables(&mut self, tunables: Tunables) -> Result<()> {
+        assert!(tunables.winch_callable);
+        self.tunables = Some(tunables.clone());
+        self.cranelift.set_tunables(tunables)?;
         Ok(())
     }
 
     fn build(&self) -> Result<Box<dyn wasmtime_environ::Compiler>> {
         let isa = self.inner.build()?;
-
-        Ok(Box::new(Compiler::new(isa)))
+        let cranelift = self.cranelift.build()?;
+        let tunables = self
+            .tunables
+            .as_ref()
+            .expect("set_tunables not called")
+            .clone();
+        Ok(Box::new(Compiler::new(isa, cranelift, tunables)))
     }
 
     fn enable_incremental_compilation(
diff --git a/crates/winch/src/compiler.rs b/crates/winch/src/compiler.rs
index 37ff419335e6..f6438723dc6b 100644
--- a/crates/winch/src/compiler.rs
+++ b/crates/winch/src/compiler.rs
@@ -1,49 +1,86 @@
 use anyhow::Result;
+use cranelift_codegen::isa::unwind::UnwindInfoKind;
 use object::write::{Object, SymbolId};
 use std::any::Any;
+use std::mem;
 use std::sync::Mutex;
 use wasmparser::FuncValidatorAllocations;
-use wasmtime_cranelift_shared::{CompiledFunction, ModuleTextBuilder};
+use wasmtime_cranelift::{CompiledFunction, ModuleTextBuilder};
 use wasmtime_environ::{
-    CompileError, DefinedFuncIndex, FilePos, FuncIndex, FunctionBodyData, FunctionLoc,
-    ModuleTranslation, ModuleTypes, PrimaryMap, TrapEncodingBuilder, WasmFunctionInfo,
+    AddressMapSection, BuiltinFunctionIndex, CompileError, DefinedFuncIndex, FunctionBodyData,
+    FunctionLoc, ModuleTranslation, ModuleTypesBuilder, PrimaryMap, RelocationTarget,
+    StaticModuleIndex, TrapEncodingBuilder, Tunables, VMOffsets, WasmFunctionInfo,
 };
-use winch_codegen::{TargetIsa, TrampolineKind};
+use winch_codegen::{BuiltinFunctions, TargetIsa};
+
+/// Function compilation context.
+/// This struct holds information that can be shared globally across
+/// all function compilations.
+struct CompilationContext {
+    /// Validator allocations.
+    allocations: FuncValidatorAllocations,
+    /// Builtin functions available to JIT code.
+    builtins: BuiltinFunctions,
+}
 
 pub(crate) struct Compiler {
     isa: Box<dyn TargetIsa>,
-    allocations: Mutex<Vec<FuncValidatorAllocations>>,
-}
-
-/// The compiled function environment.
-pub struct CompiledFuncEnv;
-impl wasmtime_cranelift_shared::CompiledFuncEnv for CompiledFuncEnv {
-    fn resolve_user_external_name_ref(
-        &self,
-        external: cranelift_codegen::ir::UserExternalNameRef,
-    ) -> (u32, u32) {
-        (0, external.as_u32())
-    }
+    trampolines: Box<dyn wasmtime_environ::Compiler>,
+    contexts: Mutex<Vec<CompilationContext>>,
+    tunables: Tunables,
 }
 
 impl Compiler {
-    pub fn new(isa: Box<dyn TargetIsa>) -> Self {
+    pub fn new(
+        isa: Box<dyn TargetIsa>,
+        trampolines: Box<dyn wasmtime_environ::Compiler>,
+        tunables: Tunables,
+    ) -> Self {
         Self {
             isa,
-            allocations: Mutex::new(Vec::new()),
+            trampolines,
+            contexts: Mutex::new(Vec::new()),
+            tunables,
         }
     }
 
-    fn take_allocations(&self) -> FuncValidatorAllocations {
-        self.allocations
-            .lock()
-            .unwrap()
-            .pop()
-            .unwrap_or_else(Default::default)
+    /// Get a compilation context or create a new one if none available.
+    fn get_context(&self, translation: &ModuleTranslation) -> CompilationContext {
+        self.contexts.lock().unwrap().pop().unwrap_or_else(|| {
+            let pointer_size = self.isa.pointer_bytes();
+            let vmoffsets = VMOffsets::new(pointer_size, &translation.module);
+            CompilationContext {
+                allocations: Default::default(),
+                builtins: BuiltinFunctions::new(&vmoffsets, self.isa.wasmtime_call_conv()),
+            }
+        })
     }
 
-    fn save_allocations(&self, allocs: FuncValidatorAllocations) {
-        self.allocations.lock().unwrap().push(allocs)
+    /// Save a compilation context.
+    fn save_context(&self, mut context: CompilationContext, allocs: FuncValidatorAllocations) {
+        context.allocations = allocs;
+        self.contexts.lock().unwrap().push(context);
+    }
+
+    /// Emit unwind info into the [`CompiledFunction`].
+    fn emit_unwind_info(
+        &self,
+        compiled_function: &mut CompiledFunction,
+    ) -> Result<(), CompileError> {
+        let kind = match self.isa.triple().operating_system {
+            target_lexicon::OperatingSystem::Windows => UnwindInfoKind::Windows,
+            _ => UnwindInfoKind::SystemV,
+        };
+
+        if let Some(info) = self
+            .isa
+            .emit_unwind_info(&compiled_function.buffer, kind)
+            .map_err(|e| CompileError::Codegen(format!("{e:?}")))?
+        {
+            compiled_function.set_unwind_info(info);
+        }
+
+        Ok(())
     }
 }
 
@@ -53,109 +90,87 @@ impl wasmtime_environ::Compiler for Compiler {
         translation: &ModuleTranslation<'_>,
         index: DefinedFuncIndex,
         data: FunctionBodyData<'_>,
-        types: &ModuleTypes,
+        types: &ModuleTypesBuilder,
     ) -> Result<(WasmFunctionInfo, Box<dyn Any + Send>), CompileError> {
         let index = translation.module.func_index(index);
         let sig = translation.module.functions[index].signature;
-        let ty = &types[sig];
-        let FunctionBodyData { body, validator } = data;
-        let start_srcloc = FilePos::new(
-            body.get_binary_reader()
-                .original_position()
-                .try_into()
-                .unwrap(),
-        );
-        let mut validator = validator.into_validator(self.take_allocations());
-        let buffer = self
+        let ty = types[sig].unwrap_func();
+        let FunctionBodyData {
+            body, validator, ..
+        } = data;
+        let mut context = self.get_context(translation);
+        let mut validator = validator.into_validator(mem::take(&mut context.allocations));
+        let func = self
             .isa
-            .compile_function(ty, types, &body, &translation, &mut validator)
+            .compile_function(
+                ty,
+                &body,
+                translation,
+                types,
+                &mut context.builtins,
+                &mut validator,
+            )
             .map_err(|e| CompileError::Codegen(format!("{e:?}")));
-        self.save_allocations(validator.into_allocations());
-        let buffer = buffer?;
-        let compiled_function =
-            CompiledFunction::new(buffer, CompiledFuncEnv {}, self.isa.function_alignment());
+        self.save_context(context, validator.into_allocations());
+        let mut func = func?;
+
+        let reader = body.get_binary_reader();
+        func.set_address_map(
+            reader.original_position() as u32,
+            reader.bytes_remaining() as u32,
+            self.tunables.generate_address_map,
+        );
+
+        if self.isa.flags().unwind_info() {
+            self.emit_unwind_info(&mut func)?;
+        }
 
         Ok((
             WasmFunctionInfo {
-                start_srcloc,
+                start_srcloc: func.metadata().address_map.start_srcloc,
                 stack_maps: Box::new([]),
             },
-            Box::new(compiled_function),
+            Box::new(func),
         ))
     }
 
     fn compile_array_to_wasm_trampoline(
         &self,
         translation: &ModuleTranslation<'_>,
-        types: &ModuleTypes,
+        types: &ModuleTypesBuilder,
         index: DefinedFuncIndex,
     ) -> Result<Box<dyn Any + Send>, CompileError> {
-        let func_index = translation.module.func_index(index);
-        let sig = translation.module.functions[func_index].signature;
-        let ty = &types[sig];
-        let buffer = self
-            .isa
-            .compile_trampoline(&ty, TrampolineKind::ArrayToWasm(func_index))
-            .map_err(|e| CompileError::Codegen(format!("{:?}", e)))?;
-        let compiled_function =
-            CompiledFunction::new(buffer, CompiledFuncEnv {}, self.isa.function_alignment());
-
-        Ok(Box::new(compiled_function))
+        self.trampolines
+            .compile_array_to_wasm_trampoline(translation, types, index)
     }
 
-    fn compile_native_to_wasm_trampoline(
-        &self,
-        translation: &ModuleTranslation<'_>,
-        types: &ModuleTypes,
-        index: DefinedFuncIndex,
-    ) -> Result<Box<dyn Any + Send>, CompileError> {
-        let func_index = translation.module.func_index(index);
-        let sig = translation.module.functions[func_index].signature;
-        let ty = &types[sig];
-
-        let buffer = self
-            .isa
-            .compile_trampoline(ty, TrampolineKind::NativeToWasm(func_index))
-            .map_err(|e| CompileError::Codegen(format!("{:?}", e)))?;
-
-        let compiled_function =
-            CompiledFunction::new(buffer, CompiledFuncEnv {}, self.isa.function_alignment());
-
-        Ok(Box::new(compiled_function))
-    }
-
-    fn compile_wasm_to_native_trampoline(
+    fn compile_wasm_to_array_trampoline(
         &self,
         wasm_func_ty: &wasmtime_environ::WasmFuncType,
     ) -> Result<Box<dyn Any + Send>, CompileError> {
-        let buffer = self
-            .isa
-            .compile_trampoline(wasm_func_ty, TrampolineKind::WasmToNative)
-            .map_err(|e| CompileError::Codegen(format!("{:?}", e)))?;
-
-        let compiled_function =
-            CompiledFunction::new(buffer, CompiledFuncEnv {}, self.isa.function_alignment());
-
-        Ok(Box::new(compiled_function))
+        self.trampolines
+            .compile_wasm_to_array_trampoline(wasm_func_ty)
     }
 
     fn append_code(
         &self,
         obj: &mut Object<'static>,
         funcs: &[(String, Box<dyn Any + Send>)],
-        resolve_reloc: &dyn Fn(usize, FuncIndex) -> usize,
+        resolve_reloc: &dyn Fn(usize, wasmtime_environ::RelocationTarget) -> usize,
     ) -> Result<Vec<(SymbolId, FunctionLoc)>> {
         let mut builder =
             ModuleTextBuilder::new(obj, self, self.isa.text_section_builder(funcs.len()));
         let mut traps = TrapEncodingBuilder::default();
+        let mut addrs = AddressMapSection::default();
 
         let mut ret = Vec::with_capacity(funcs.len());
         for (i, (sym, func)) in funcs.iter().enumerate() {
-            let func = func
-                .downcast_ref::<CompiledFunction<CompiledFuncEnv>>()
-                .unwrap();
+            let func = func.downcast_ref::<CompiledFunction>().unwrap();
 
             let (sym, range) = builder.append_func(&sym, func, |idx| resolve_reloc(i, idx));
+            if self.tunables.generate_address_map {
+                addrs.push(range.clone(), &func.address_map().instructions);
+            }
             traps.push(range.clone(), &func.traps().collect::<Vec<_>>());
 
             let info = FunctionLoc {
@@ -165,32 +180,23 @@ impl wasmtime_environ::Compiler for Compiler {
             ret.push((sym, info));
         }
         builder.finish();
+        if self.tunables.generate_address_map {
+            addrs.append_to(obj);
+        }
         traps.append_to(obj);
         Ok(ret)
     }
 
-    fn emit_trampolines_for_array_call_host_func(
-        &self,
-        ty: &wasmtime_environ::WasmFuncType,
-        // Actually `host_fn: VMArrayCallFunction` but that type is not
-        // available in `wasmtime-environ`.
-        host_fn: usize,
-        obj: &mut Object<'static>,
-    ) -> Result<(FunctionLoc, FunctionLoc)> {
-        drop((ty, host_fn, obj));
-        todo!()
-    }
-
     fn triple(&self) -> &target_lexicon::Triple {
         self.isa.triple()
     }
 
-    fn flags(&self) -> std::collections::BTreeMap<String, wasmtime_environ::FlagValue> {
-        wasmtime_cranelift_shared::clif_flags_to_wasmtime(self.isa.flags().iter())
+    fn flags(&self) -> Vec<(&'static str, wasmtime_environ::FlagValue<'static>)> {
+        wasmtime_cranelift::clif_flags_to_wasmtime(self.isa.flags().iter())
     }
 
-    fn isa_flags(&self) -> std::collections::BTreeMap<String, wasmtime_environ::FlagValue> {
-        wasmtime_cranelift_shared::clif_flags_to_wasmtime(self.isa.isa_flags())
+    fn isa_flags(&self) -> Vec<(&'static str, wasmtime_environ::FlagValue<'static>)> {
+        wasmtime_cranelift::clif_flags_to_wasmtime(self.isa.isa_flags())
     }
 
     fn is_branch_protection_enabled(&self) -> bool {
@@ -199,14 +205,19 @@ impl wasmtime_environ::Compiler for Compiler {
 
     #[cfg(feature = "component-model")]
     fn component_compiler(&self) -> &dyn wasmtime_environ::component::ComponentCompiler {
-        todo!()
+        self.trampolines.component_compiler()
     }
 
-    fn append_dwarf(
+    fn append_dwarf<'a>(
         &self,
         _obj: &mut Object<'_>,
-        _translation: &ModuleTranslation<'_>,
-        _funcs: &PrimaryMap<DefinedFuncIndex, (SymbolId, &(dyn Any + Send))>,
+        _translations: &'a PrimaryMap<StaticModuleIndex, ModuleTranslation<'a>>,
+        _get_func: &'a dyn Fn(
+            StaticModuleIndex,
+            DefinedFuncIndex,
+        ) -> (SymbolId, &'a (dyn Any + Send)),
+        _dwarf_package_bytes: Option<&'a [u8]>,
+        _tunables: &'a Tunables,
     ) -> Result<()> {
         todo!()
     }
@@ -214,4 +225,18 @@ impl wasmtime_environ::Compiler for Compiler {
     fn create_systemv_cie(&self) -> Option<gimli::write::CommonInformationEntry> {
         self.isa.create_systemv_cie()
     }
+
+    fn compile_wasm_to_builtin(
+        &self,
+        index: BuiltinFunctionIndex,
+    ) -> Result<Box<dyn Any + Send>, CompileError> {
+        self.trampolines.compile_wasm_to_builtin(index)
+    }
+
+    fn compiled_function_relocation_targets<'a>(
+        &'a self,
+        func: &'a dyn Any,
+    ) -> Box<dyn Iterator<Item = RelocationTarget> + 'a> {
+        self.trampolines.compiled_function_relocation_targets(func)
+    }
 }
diff --git a/crates/wit-bindgen/Cargo.toml b/crates/wit-bindgen/Cargo.toml
index cc4b27260bbe..90e8ea3e9959 100644
--- a/crates/wit-bindgen/Cargo.toml
+++ b/crates/wit-bindgen/Cargo.toml
@@ -7,9 +7,16 @@ license = "Apache-2.0 WITH LLVM-exception"
 repository = "https://github.com/bytecodealliance/wasmtime"
 documentation = "https://docs.rs/wasmtime-wit-bindgen/"
 edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
 
 [dependencies]
 anyhow = { workspace = true }
 heck = { workspace = true }
 wit-parser = { workspace = true }
 indexmap = { workspace = true }
+
+[features]
+std = []
diff --git a/crates/wit-bindgen/src/lib.rs b/crates/wit-bindgen/src/lib.rs
index 45fe6aedf3b1..e82e9e090a81 100644
--- a/crates/wit-bindgen/src/lib.rs
+++ b/crates/wit-bindgen/src/lib.rs
@@ -1,9 +1,9 @@
 use crate::rust::{to_rust_ident, to_rust_upper_camel_case, RustGenerator, TypeMode};
 use crate::types::{TypeInfo, Types};
-use anyhow::{anyhow, bail, Context};
+use anyhow::bail;
 use heck::*;
-use indexmap::IndexMap;
-use std::collections::{BTreeMap, HashMap, HashSet};
+use indexmap::{IndexMap, IndexSet};
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::fmt::Write as _;
 use std::io::{Read, Write};
 use std::mem;
@@ -27,45 +27,77 @@ mod source;
 mod types;
 use source::Source;
 
-struct InterfaceName {
-    /// True when this interface name has been remapped through the use of `with` in the `bindgen!`
-    /// macro invocation.
-    remapped: bool,
+#[derive(Clone)]
+enum InterfaceName {
+    /// This interface was remapped using `with` to some other Rust code.
+    Remapped {
+        /// This is the `::`-separated string which is the path to the mapped
+        /// item relative to the root of the `bindgen!` macro invocation.
+        ///
+        /// This path currently starts with `__with_name$N` and will then
+        /// optionally have `::` projections through to the actual item
+        /// depending on how `with` was configured.
+        name_at_root: String,
+
+        /// This is currently only used for exports and is the relative path to
+        /// where this mapped name would be located if `with` were not
+        /// specified. Basically it's the same as the `Path` variant of this
+        /// enum if the mapping weren't present.
+        local_path: Vec<String>,
+    },
 
-    /// The string name for this interface.
-    path: String,
+    /// This interface is generated in the module hierarchy specified.
+    ///
+    /// The path listed here is the path, from the root of the `bindgen!` macro,
+    /// to where this interface is generated.
+    Path(Vec<String>),
 }
 
 #[derive(Default)]
 struct Wasmtime {
     src: Source,
     opts: Opts,
-    import_interfaces: BTreeMap<Option<PackageName>, Vec<ImportInterface>>,
+    /// A list of all interfaces which were imported by this world.
+    ///
+    /// The first value here is the contents of the module that this interface
+    /// generated. The second value is the name of the interface as also present
+    /// in `self.interface_names`.
+    import_interfaces: Vec<(String, InterfaceName)>,
     import_functions: Vec<ImportFunction>,
     exports: Exports,
     types: Types,
     sizes: SizeAlign,
     interface_names: HashMap<InterfaceId, InterfaceName>,
-    with_name_counter: usize,
     interface_last_seen_as_import: HashMap<InterfaceId, bool>,
+    trappable_errors: IndexMap<TypeId, String>,
+    // Track the with options that were used. Remapped interfaces provided via `with`
+    // are required to be used.
+    used_with_opts: HashSet<String>,
+    // Track the imports that matched the `trappable_imports` spec.
+    used_trappable_imports_opts: HashSet<String>,
 }
 
-struct ImportInterface {
-    snake: String,
-    module: String,
-}
 struct ImportFunction {
+    func: Function,
     add_to_linker: String,
-    sig: String,
+    sig: Option<String>,
 }
 
 #[derive(Default)]
 struct Exports {
-    fields: BTreeMap<String, (String, String)>,
-    modules: BTreeMap<Option<PackageName>, Vec<String>>,
+    fields: BTreeMap<String, ExportField>,
+    modules: Vec<(String, InterfaceName)>,
     funcs: Vec<String>,
 }
 
+struct ExportField {
+    ty: String,
+    ty_index: String,
+    load: String,
+    get_index_from_component: String,
+    get_index_from_instance: String,
+}
+
 #[derive(Default, Debug, Clone, Copy)]
 pub enum Ownership {
     /// Generated types will be composed entirely of owning fields, regardless
@@ -106,23 +138,59 @@ pub struct Opts {
     /// Whether or not to generate code for only the interfaces of this wit file or not.
     pub only_interfaces: bool,
 
+    /// Configuration of which imports are allowed to generate a trap.
+    pub trappable_imports: TrappableImports,
+
     /// Remapping of interface names to rust module names.
     /// TODO: is there a better type to use for the value of this map?
     pub with: HashMap<String, String>,
+
+    /// Additional derive attributes to add to generated types. If using in a CLI, this flag can be
+    /// specified multiple times to add multiple attributes.
+    ///
+    /// These derive attributes will be added to any generated structs or enums
+    pub additional_derive_attributes: Vec<String>,
+
+    /// Evaluate to a string literal containing the generated code rather than the generated tokens
+    /// themselves. Mostly useful for Wasmtime internal debugging and development.
+    pub stringify: bool,
+
+    /// Temporary option to skip `impl<T: Trait> Trait for &mut T` for the
+    /// `wasmtime-wasi` crate while that's given a chance to update its b
+    /// indings.
+    pub skip_mut_forwarding_impls: bool,
+
+    /// Indicates that the `T` in `Store<T>` should be send even if async is not
+    /// enabled.
+    ///
+    /// This is helpful when sync bindings depend on generated functions from
+    /// async bindings as is the case with WASI in-tree.
+    pub require_store_data_send: bool,
+
+    /// Path to the `wasmtime` crate if it's not the default path.
+    pub wasmtime_crate: Option<String>,
 }
 
 #[derive(Debug, Clone)]
 pub struct TrappableError {
-    /// The package and interface that define the error type being mapped.
-    pub wit_package_path: String,
-
-    /// The name of the error type in WIT that is being mapped.
-    pub wit_type_name: String,
+    /// Full path to the error, such as `wasi:io/streams/error`.
+    pub wit_path: String,
 
     /// The name, in Rust, of the error type to generate.
     pub rust_type_name: String,
 }
 
+/// Which imports should be generated as async functions.
+///
+/// The imports should be declared in the following format:
+/// - Regular functions: `"{function-name}"`
+/// - Resource methods: `"[method]{resource-name}.{method-name}"`
+/// - Resource destructors: `"[drop]{resource-name}"`
+///
+/// Examples:
+/// - Regular function: `"get-environment"`
+/// - Resource method: `"[method]input-stream.read"`
+/// - Resource destructor: `"[drop]input-stream"`
 #[derive(Default, Debug, Clone)]
 pub enum AsyncConfig {
     /// No functions are `async`.
@@ -149,6 +217,10 @@ impl AsyncConfig {
         }
     }
 
+    pub fn is_drop_async(&self, r: &str) -> bool {
+        self.is_import_async(&format!("[drop]{r}"))
+    }
+
     pub fn maybe_async(&self) -> bool {
         match self {
             AsyncConfig::None => false,
@@ -159,13 +231,38 @@ impl AsyncConfig {
     }
 }
 
+#[derive(Default, Debug, Clone)]
+pub enum TrappableImports {
+    /// No imports are allowed to trap.
+    #[default]
+    None,
+    /// All imports may trap.
+    All,
+    /// Only the specified set of functions may trap.
+    Only(HashSet<String>),
+}
+
+impl TrappableImports {
+    fn can_trap(&self, f: &Function) -> bool {
+        match self {
+            TrappableImports::None => false,
+            TrappableImports::All => true,
+            TrappableImports::Only(set) => set.contains(&f.name),
+        }
+    }
+}
+
 impl Opts {
-    pub fn generate(&self, resolve: &Resolve, world: WorldId) -> String {
+    pub fn generate(&self, resolve: &Resolve, world: WorldId) -> anyhow::Result<String> {
         let mut r = Wasmtime::default();
         r.sizes.fill(resolve);
         r.opts = self.clone();
         r.generate(resolve, world)
     }
+
+    fn is_store_data_send(&self) -> bool {
+        self.async_.maybe_async() || self.require_store_data_send
+    }
 }
 
 impl Wasmtime {
@@ -176,56 +273,151 @@ impl Wasmtime {
         name: &WorldKey,
         is_export: bool,
     ) -> bool {
-        let with_name = resolve.name_world_key(name);
-        let entry = if let Some(remapped_path) = self.opts.with.get(&with_name) {
-            let name = format!("__with_name{}", self.with_name_counter);
-            self.with_name_counter += 1;
-            uwriteln!(self.src, "use {remapped_path} as {name};");
-            InterfaceName {
-                remapped: true,
-                path: name,
+        let mut path = Vec::new();
+        if is_export {
+            path.push("exports".to_string());
+        }
+        match name {
+            WorldKey::Name(name) => {
+                path.push(name.to_snake_case());
             }
-        } else {
-            let path = match name {
-                WorldKey::Name(name) => name.to_snake_case(),
-                WorldKey::Interface(_) => {
-                    let iface = &resolve.interfaces[id];
-                    let pkgname = &resolve.packages[iface.package.unwrap()].name;
-                    format!(
-                        "{}::{}::{}",
-                        pkgname.namespace.to_snake_case(),
-                        pkgname.name.to_snake_case(),
-                        iface.name.as_ref().unwrap().to_snake_case()
-                    )
-                }
-            };
-            let path = if is_export {
-                format!("exports::{path}")
-            } else {
-                path
-            };
-            InterfaceName {
-                remapped: false,
-                path,
+            WorldKey::Interface(_) => {
+                let iface = &resolve.interfaces[id];
+                let pkgname = &resolve.packages[iface.package.unwrap()].name;
+                path.push(pkgname.namespace.to_snake_case());
+                path.push(self.name_package_module(resolve, iface.package.unwrap()));
+                path.push(to_rust_ident(iface.name.as_ref().unwrap()));
+            }
+        }
+        let entry = if let Some(name_at_root) = self.lookup_replacement(resolve, name, None) {
+            InterfaceName::Remapped {
+                name_at_root,
+                local_path: path,
             }
+        } else {
+            InterfaceName::Path(path)
         };
 
-        let remapped = entry.remapped;
+        let remapped = matches!(entry, InterfaceName::Remapped { .. });
         self.interface_names.insert(id, entry);
-
         remapped
     }
 
-    fn generate(&mut self, resolve: &Resolve, id: WorldId) -> String {
+    /// If the package `id` is the only package with its namespace/name combo
+    /// then pass through the name unmodified. If, however, there are multiple
+    /// versions of this package then the package module is going to get version
+    /// information.
+    fn name_package_module(&self, resolve: &Resolve, id: PackageId) -> String {
+        let pkg = &resolve.packages[id];
+        let versions_with_same_name = resolve
+            .packages
+            .iter()
+            .filter_map(|(_, p)| {
+                if p.name.namespace == pkg.name.namespace && p.name.name == pkg.name.name {
+                    Some(&p.name.version)
+                } else {
+                    None
+                }
+            })
+            .collect::<Vec<_>>();
+        let base = pkg.name.name.to_snake_case();
+        if versions_with_same_name.len() == 1 {
+            return base;
+        }
+
+        let version = match &pkg.name.version {
+            Some(version) => version,
+            // If this package didn't have a version then don't mangle its name
+            // and other packages with the same name but with versions present
+            // will have their names mangled.
+            None => return base,
+        };
+
+        // Here there's multiple packages with the same name that differ only in
+        // version, so the version needs to be mangled into the Rust module name
+        // that we're generating. This in theory could look at all of
+        // `versions_with_same_name` and produce a minimal diff, e.g. for 0.1.0
+        // and 0.2.0 this could generate "foo1" and "foo2", but for now
+        // a simpler path is chosen to generate "foo0_1_0" and "foo0_2_0".
+        let version = version
+            .to_string()
+            .replace('.', "_")
+            .replace('-', "_")
+            .replace('+', "_")
+            .to_snake_case();
+        format!("{base}{version}")
+    }
+
+    fn generate(&mut self, resolve: &Resolve, id: WorldId) -> anyhow::Result<String> {
         self.types.analyze(resolve, id);
+
+        // Resolve the `trappable_error_type` configuration values to `TypeId`
+        // values. This is done by iterating over each `trappable_error_type`
+        // and then locating the interface that it corresponds to as well as the
+        // type within that interface.
+        //
+        // Note that `LookupItem::InterfaceNoPop` is used here as the full
+        // hierarchical behavior of `lookup_keys` isn't used as the interface
+        // must be named here.
+        'outer: for (i, te) in self.opts.trappable_error_type.iter().enumerate() {
+            let error_name = format!("_TrappableError{i}");
+            for (id, iface) in resolve.interfaces.iter() {
+                for (key, projection) in lookup_keys(
+                    resolve,
+                    &WorldKey::Interface(id),
+                    LookupItem::InterfaceNoPop,
+                ) {
+                    assert!(projection.is_empty());
+
+                    // If `wit_path` looks like `{key}/{type_name}` where
+                    // `type_name` is a type within `iface` then we've found a
+                    // match. Otherwise continue to the next lookup key if there
+                    // is one, and failing that continue to the next interface.
+                    let suffix = match te.wit_path.strip_prefix(&key) {
+                        Some(s) => s,
+                        None => continue,
+                    };
+                    let suffix = match suffix.strip_prefix('/') {
+                        Some(s) => s,
+                        None => continue,
+                    };
+                    if let Some(id) = iface.types.get(suffix) {
+                        uwriteln!(self.src, "type {error_name} = {};", te.rust_type_name);
+                        let prev = self.trappable_errors.insert(*id, error_name);
+                        assert!(prev.is_none());
+                        continue 'outer;
+                    }
+                }
+            }
+
+            bail!(
+                "failed to locate a WIT error type corresponding to the \
+                   `trappable_error_type` name `{}` provided",
+                te.wit_path
+            )
+        }
+
+        // Convert all entries in `with` as relative to the root of where the
+        // macro itself is invoked. This emits a `pub use` to bring the name
+        // into scope under an "anonymous name" which then replaces the `with`
+        // map entry.
+        let mut with = self.opts.with.iter_mut().collect::<Vec<_>>();
+        with.sort();
+        for (i, (_k, v)) in with.into_iter().enumerate() {
+            let name = format!("__with_name{i}");
+            uwriteln!(self.src, "#[doc(hidden)]\npub use {v} as {name};");
+            *v = name;
+        }
+
         let world = &resolve.worlds[id];
         for (name, import) in world.imports.iter() {
-            if !self.opts.only_interfaces || matches!(import, WorldItem::Interface(_)) {
+            if !self.opts.only_interfaces || matches!(import, WorldItem::Interface { .. }) {
                 self.import(resolve, id, name, import);
             }
         }
+
         for (name, export) in world.exports.iter() {
-            if !self.opts.only_interfaces || matches!(export, WorldItem::Interface(_)) {
+            if !self.opts.only_interfaces || matches!(export, WorldItem::Interface { .. }) {
                 self.export(resolve, name, export);
             }
         }
@@ -239,28 +431,23 @@ impl Wasmtime {
                 // Only generate a trait signature for free functions since
                 // resource-related functions get their trait signatures
                 // during `type_resource`.
-                if let FunctionKind::Freestanding = func.kind {
+                let sig = if let FunctionKind::Freestanding = func.kind {
                     gen.generate_function_trait_sig(func);
-                }
-                let sig = mem::take(&mut gen.src).into();
+                    Some(mem::take(&mut gen.src).into())
+                } else {
+                    None
+                };
                 gen.generate_add_function_to_linker(TypeOwner::World(world), func, "linker");
                 let add_to_linker = gen.src.into();
-                self.import_functions
-                    .push(ImportFunction { sig, add_to_linker });
+                self.import_functions.push(ImportFunction {
+                    func: func.clone(),
+                    sig,
+                    add_to_linker,
+                });
             }
-            WorldItem::Interface(id) => {
+            WorldItem::Interface { id, .. } => {
                 gen.gen.interface_last_seen_as_import.insert(*id, true);
-                if gen.gen.name_interface(resolve, *id, name, false) {
-                    return;
-                }
                 gen.current_interface = Some((*id, name, false));
-                gen.types(*id);
-                let key_name = resolve.name_world_key(name);
-
-                gen.generate_add_to_linker(*id, &key_name);
-
-                let module = &gen.src[..];
-
                 let snake = match name {
                     WorldKey::Name(s) => s.to_snake_case(),
                     WorldKey::Interface(id) => resolve.interfaces[*id]
@@ -269,26 +456,51 @@ impl Wasmtime {
                         .unwrap()
                         .to_snake_case(),
                 };
-                let module = format!(
-                    "
-                        #[allow(clippy::all)]
-                        pub mod {snake} {{
-                            #[allow(unused_imports)]
-                            use wasmtime::component::__internal::anyhow;
+                let module = if gen.gen.name_interface(resolve, *id, name, false) {
+                    // If this interface is remapped then that means that it was
+                    // provided via the `with` key in the bindgen configuration.
+                    // That means that bindings generation is skipped here. To
+                    // accommodate future bindgens depending on this bindgen
+                    // though we still generate a module which reexports the
+                    // original module. This helps maintain the same output
+                    // structure regardless of whether `with` is used.
+                    let name_at_root = match &gen.gen.interface_names[id] {
+                        InterfaceName::Remapped { name_at_root, .. } => name_at_root,
+                        InterfaceName::Path(_) => unreachable!(),
+                    };
+                    let path_to_root = gen.path_to_root();
+                    format!(
+                        "
+                            pub mod {snake} {{
+                                #[allow(unused_imports)]
+                                pub use {path_to_root}{name_at_root}::*;
+                            }}
+                        "
+                    )
+                } else {
+                    // If this interface is not remapped then it's time to
+                    // actually generate bindings here.
+                    gen.types(*id);
+                    let key_name = resolve.name_world_key(name);
+                    gen.generate_add_to_linker(*id, &key_name);
 
-                            {module}
-                        }}
-                    "
-                );
-                let pkg = resolve.interfaces[*id].package.unwrap();
-                let pkgname = match name {
-                    WorldKey::Name(_) => None,
-                    WorldKey::Interface(_) => Some(resolve.packages[pkg].name.clone()),
+                    let module = &gen.src[..];
+                    let wt = gen.gen.wasmtime_path();
+
+                    format!(
+                        "
+                            #[allow(clippy::all)]
+                            pub mod {snake} {{
+                                #[allow(unused_imports)]
+                                use {wt}::component::__internal::anyhow;
+
+                                {module}
+                            }}
+                        "
+                    )
                 };
                 self.import_interfaces
-                    .entry(pkgname)
-                    .or_insert(Vec::new())
-                    .push(ImportInterface { snake, module });
+                    .push((module, self.interface_names[id].clone()));
             }
             WorldItem::Type(ty) => {
                 let name = match name {
@@ -303,49 +515,141 @@ impl Wasmtime {
     }
 
     fn export(&mut self, resolve: &Resolve, name: &WorldKey, item: &WorldItem) {
+        let wt = self.wasmtime_path();
         let mut gen = InterfaceGenerator::new(self, resolve);
-        let (field, ty, getter) = match item {
+        let field;
+        let ty;
+        let ty_index;
+        let load;
+        let get_index_from_component;
+        let get_index_from_instance;
+        match item {
             WorldItem::Function(func) => {
                 gen.define_rust_guest_export(resolve, None, func);
                 let body = mem::take(&mut gen.src).into();
-                let (_name, getter) = gen.extract_typed_function(func);
+                load = gen.extract_typed_function(func).1;
                 assert!(gen.src.is_empty());
                 self.exports.funcs.push(body);
-                (
-                    func_field_name(resolve, func),
-                    "wasmtime::component::Func".to_string(),
-                    getter,
-                )
+                ty_index = format!("{wt}::component::ComponentExportIndex");
+                field = func_field_name(resolve, func);
+                ty = format!("{wt}::component::Func");
+                get_index_from_component = format!(
+                    "_component.export_index(None, \"{}\")
+                        .ok_or_else(|| anyhow::anyhow!(\"no function export `{0}` found\"))?.1",
+                    func.name
+                );
+                get_index_from_instance = format!(
+                    "_instance.get_export(&mut store, None, \"{}\")
+                        .ok_or_else(|| anyhow::anyhow!(\"no function export `{0}` found\"))?",
+                    func.name
+                );
             }
             WorldItem::Type(_) => unreachable!(),
-            WorldItem::Interface(id) => {
+            WorldItem::Interface { id, .. } => {
                 gen.gen.interface_last_seen_as_import.insert(*id, false);
                 gen.gen.name_interface(resolve, *id, name, true);
                 gen.current_interface = Some((*id, name, true));
                 gen.types(*id);
+                let struct_name = "Guest";
                 let iface = &resolve.interfaces[*id];
                 let iface_name = match name {
                     WorldKey::Name(name) => name,
                     WorldKey::Interface(_) => iface.name.as_ref().unwrap(),
                 };
-                let camel = to_rust_upper_camel_case(iface_name);
-                uwriteln!(gen.src, "pub struct {camel} {{");
+                uwriteln!(gen.src, "pub struct {struct_name} {{");
+                for (_, func) in iface.functions.iter() {
+                    uwriteln!(
+                        gen.src,
+                        "{}: {wt}::component::Func,",
+                        func_field_name(resolve, func)
+                    );
+                }
+                uwriteln!(gen.src, "}}");
+
+                uwriteln!(gen.src, "#[derive(Clone)]");
+                uwriteln!(gen.src, "pub struct {struct_name}Indices {{");
                 for (_, func) in iface.functions.iter() {
                     uwriteln!(
                         gen.src,
-                        "{}: wasmtime::component::Func,",
+                        "{}: {wt}::component::ComponentExportIndex,",
                         func_field_name(resolve, func)
                     );
                 }
                 uwriteln!(gen.src, "}}");
 
-                uwriteln!(gen.src, "impl {camel} {{");
+                uwriteln!(gen.src, "impl {struct_name}Indices {{");
+                let instance_name = resolve.name_world_key(name);
                 uwrite!(
                     gen.src,
                     "
-                        pub fn new(
-                            __exports: &mut wasmtime::component::ExportInstance<'_, '_>,
-                        ) -> wasmtime::Result<{camel}> {{
+/// Constructor for [`{struct_name}Indices`] which takes a
+/// [`Component`]({wt}::component::Component) as input and can be executed
+/// before instantiation.
+///
+/// This constructor can be used to front-load string lookups to find exports
+/// within a component.
+pub fn new(
+    component: &{wt}::component::Component,
+) -> {wt}::Result<{struct_name}Indices> {{
+    let (_, instance) = component.export_index(None, \"{instance_name}\")
+        .ok_or_else(|| anyhow::anyhow!(\"no exported instance named `{instance_name}`\"))?;
+    Self::_new(|name| {{
+        component.export_index(Some(&instance), name)
+            .map(|p| p.1)
+    }})
+}}
+
+/// This constructor is similar to [`{struct_name}Indices::new`] except that it
+/// performs string lookups after instantiation time.
+pub fn new_instance(
+    mut store: impl {wt}::AsContextMut,
+    instance: &{wt}::component::Instance,
+) -> {wt}::Result<{struct_name}Indices> {{
+    let instance_export = instance.get_export(&mut store, None, \"{instance_name}\")
+        .ok_or_else(|| anyhow::anyhow!(\"no exported instance named `{instance_name}`\"))?;
+    Self::_new(|name| {{
+        instance.get_export(&mut store, Some(&instance_export), name)
+    }})
+}}
+
+fn _new(
+    mut lookup: impl FnMut (&str) -> Option<{wt}::component::ComponentExportIndex>,
+) -> {wt}::Result<{struct_name}Indices> {{
+    let mut lookup = move |name| {{
+        lookup(name).ok_or_else(|| {{
+            anyhow::anyhow!(
+                \"instance export `{instance_name}` does \\
+                  not have export `{{name}}`\"
+            )
+        }})
+    }};
+    let _ = &mut lookup;
+                    "
+                );
+                let mut fields = Vec::new();
+                for (_, func) in iface.functions.iter() {
+                    let name = func_field_name(resolve, func);
+                    uwriteln!(gen.src, "let {name} = lookup(\"{}\")?;", func.name);
+                    fields.push(name);
+                }
+                uwriteln!(gen.src, "Ok({struct_name}Indices {{");
+                for name in fields {
+                    uwriteln!(gen.src, "{name},");
+                }
+                uwriteln!(gen.src, "}})");
+                uwriteln!(gen.src, "}}"); // end `fn _new`
+
+                uwrite!(
+                    gen.src,
+                    "
+                        pub fn load(
+                            &self,
+                            mut store: impl {wt}::AsContextMut,
+                            instance: &{wt}::component::Instance,
+                        ) -> {wt}::Result<{struct_name}> {{
+                            let mut store = store.as_context_mut();
+                            let _ = &mut store;
+                            let _instance = instance;
                     "
                 );
                 let mut fields = Vec::new();
@@ -354,13 +658,15 @@ impl Wasmtime {
                     uwriteln!(gen.src, "let {name} = {getter};");
                     fields.push(name);
                 }
-                uwriteln!(gen.src, "Ok({camel} {{");
+                uwriteln!(gen.src, "Ok({struct_name} {{");
                 for name in fields {
                     uwriteln!(gen.src, "{name},");
                 }
                 uwriteln!(gen.src, "}})");
-                uwriteln!(gen.src, "}}");
+                uwriteln!(gen.src, "}}"); // end `fn new`
+                uwriteln!(gen.src, "}}"); // end `impl {struct_name}Indices`
 
+                uwriteln!(gen.src, "impl {struct_name} {{");
                 let mut resource_methods = IndexMap::new();
 
                 for (_, func) in iface.functions.iter() {
@@ -401,14 +707,14 @@ impl Wasmtime {
                 }
 
                 let module = &gen.src[..];
-                let snake = iface_name.to_snake_case();
+                let snake = to_rust_ident(iface_name);
 
                 let module = format!(
                     "
                         #[allow(clippy::all)]
                         pub mod {snake} {{
                             #[allow(unused_imports)]
-                            use wasmtime::component::__internal::anyhow;
+                            use {wt}::component::__internal::anyhow;
 
                             {module}
                         }}
@@ -422,35 +728,25 @@ impl Wasmtime {
                 };
                 self.exports
                     .modules
-                    .entry(pkgname.clone())
-                    .or_insert(Vec::new())
-                    .push(module);
+                    .push((module, self.interface_names[id].clone()));
 
-                let name = resolve.name_world_key(name);
                 let (path, method_name) = match pkgname {
                     Some(pkgname) => (
                         format!(
-                            "exports::{}::{}::{snake}::{camel}",
+                            "exports::{}::{}::{snake}::{struct_name}",
                             pkgname.namespace.to_snake_case(),
-                            pkgname.name.to_snake_case(),
+                            self.name_package_module(resolve, iface.package.unwrap()),
                         ),
                         format!(
                             "{}_{}_{snake}",
                             pkgname.namespace.to_snake_case(),
-                            pkgname.name.to_snake_case()
+                            self.name_package_module(resolve, iface.package.unwrap())
                         ),
                     ),
-                    None => (format!("exports::{snake}::{camel}"), snake.clone()),
+                    None => (format!("exports::{snake}::{struct_name}"), snake.clone()),
                 };
-                let getter = format!(
-                    "\
-                        {path}::new(
-                            &mut __exports.instance(\"{name}\")
-                                .ok_or_else(|| anyhow::anyhow!(\"exported instance `{name}` not present\"))?
-                        )?\
-                    "
-                );
-                let field = format!("interface{}", self.exports.fields.len());
+                field = format!("interface{}", self.exports.fields.len());
+                load = format!("self.{field}.load(&mut store, &_instance)?");
                 self.exports.funcs.push(format!(
                     "
                         pub fn {method_name}(&self) -> &{path} {{
@@ -458,86 +754,273 @@ impl Wasmtime {
                         }}
                     ",
                 ));
-                (field, path, getter)
+                ty_index = format!("{path}Indices");
+                ty = path;
+                get_index_from_component = format!("{ty_index}::new(_component)?");
+                get_index_from_instance =
+                    format!("{ty_index}::new_instance(&mut store, _instance)?");
             }
-        };
-        let prev = self.exports.fields.insert(field, (ty, getter));
+        }
+        let prev = self.exports.fields.insert(
+            field,
+            ExportField {
+                ty,
+                ty_index,
+                load,
+                get_index_from_component,
+                get_index_from_instance,
+            },
+        );
         assert!(prev.is_none());
     }
 
-    fn build_struct(&mut self, resolve: &Resolve, world: WorldId) {
-        let camel = to_rust_upper_camel_case(&resolve.worlds[world].name);
-        uwriteln!(self.src, "pub struct {camel} {{");
-        for (name, (ty, _)) in self.exports.fields.iter() {
-            uwriteln!(self.src, "{name}: {ty},");
-        }
-        self.src.push_str("}\n");
-
-        let (async_, async__, send, await_) = if self.opts.async_.maybe_async() {
-            ("async", "_async", ":Send", ".await")
+    fn build_world_struct(&mut self, resolve: &Resolve, world: WorldId) {
+        let wt = self.wasmtime_path();
+        let world_name = &resolve.worlds[world].name;
+        let camel = to_rust_upper_camel_case(&world_name);
+        let (async_, async__, where_clause, await_) = if self.opts.async_.maybe_async() {
+            ("async", "_async", "where _T: Send", ".await")
         } else {
             ("", "", "", "")
         };
+        uwriteln!(
+            self.src,
+            "
+/// Auto-generated bindings for a pre-instantiated version of a
+/// component which implements the world `{world_name}`.
+///
+/// This structure is created through [`{camel}Pre::new`] which
+/// takes a [`InstancePre`]({wt}::component::InstancePre) that
+/// has been created through a [`Linker`]({wt}::component::Linker).
+///
+/// For more information see [`{camel}`] as well.
+pub struct {camel}Pre<T> {{
+    instance_pre: {wt}::component::InstancePre<T>,
+    indices: {camel}Indices,
+}}
+
+impl<T> Clone for {camel}Pre<T> {{
+    fn clone(&self) -> Self {{
+        Self {{
+            instance_pre: self.instance_pre.clone(),
+            indices: self.indices.clone(),
+        }}
+    }}
+}}
+
+impl<_T> {camel}Pre<_T> {{
+    /// Creates a new copy of `{camel}Pre` bindings which can then
+    /// be used to instantiate into a particular store.
+    ///
+    /// This method may fail if the component behind `instance_pre`
+    /// does not have the required exports.
+    pub fn new(instance_pre: {wt}::component::InstancePre<_T>) -> {wt}::Result<Self> {{
+        let indices = {camel}Indices::new(instance_pre.component())?;
+        Ok(Self {{ instance_pre, indices }})
+    }}
+
+    pub fn engine(&self) -> &{wt}::Engine {{
+        self.instance_pre.engine()
+    }}
+
+    pub fn instance_pre(&self) -> &{wt}::component::InstancePre<_T> {{
+        &self.instance_pre
+    }}
+
+    /// Instantiates a new instance of [`{camel}`] within the
+    /// `store` provided.
+    ///
+    /// This function will use `self` as the pre-instantiated
+    /// instance to perform instantiation. Afterwards the preloaded
+    /// indices in `self` are used to lookup all exports on the
+    /// resulting instance.
+    pub {async_} fn instantiate{async__}(
+        &self,
+        mut store: impl {wt}::AsContextMut<Data = _T>,
+    ) -> {wt}::Result<{camel}>
+        {where_clause}
+    {{
+        let mut store = store.as_context_mut();
+        let instance = self.instance_pre.instantiate{async__}(&mut store){await_}?;
+        self.indices.load(&mut store, &instance)
+    }}
+}}
+"
+        );
 
-        self.toplevel_import_trait(resolve, world);
+        uwriteln!(
+            self.src,
+            "
+            /// Auto-generated bindings for index of the exports of
+            /// `{world_name}`.
+            ///
+            /// This is an implementation detail of [`{camel}Pre`] and can
+            /// be constructed if needed as well.
+            ///
+            /// For more information see [`{camel}`] as well.
+            #[derive(Clone)]
+            pub struct {camel}Indices {{"
+        );
+        for (name, field) in self.exports.fields.iter() {
+            uwriteln!(self.src, "{name}: {},", field.ty_index);
+        }
+        self.src.push_str("}\n");
 
-        uwriteln!(self.src, "const _: () = {{");
-        uwriteln!(self.src, "use wasmtime::component::__internal::anyhow;");
+        uwriteln!(
+            self.src,
+            "
+                /// Auto-generated bindings for an instance a component which
+                /// implements the world `{world_name}`.
+                ///
+                /// This structure can be created through a number of means
+                /// depending on your requirements and what you have on hand:
+                ///
+                /// * The most convenient way is to use
+                ///   [`{camel}::instantiate{async__}`] which only needs a
+                ///   [`Store`], [`Component`], and [`Linker`].
+                ///
+                /// * Alternatively you can create a [`{camel}Pre`] ahead of
+                ///   time with a [`Component`] to front-load string lookups
+                ///   of exports once instead of per-instantiation. This
+                ///   method then uses [`{camel}Pre::instantiate{async__}`] to
+                ///   create a [`{camel}`].
+                ///
+                /// * If you've instantiated the instance yourself already
+                ///   then you can use [`{camel}::new`].
+                ///
+                /// * You can also access the guts of instantiation through
+                ///   [`{camel}Indices::new_instance`] followed
+                ///   by [`{camel}Indices::load`] to crate an instance of this
+                ///   type.
+                ///
+                /// These methods are all equivalent to one another and move
+                /// around the tradeoff of what work is performed when.
+                ///
+                /// [`Store`]: {wt}::Store
+                /// [`Component`]: {wt}::component::Component
+                /// [`Linker`]: {wt}::component::Linker
+                pub struct {camel} {{"
+        );
+        for (name, field) in self.exports.fields.iter() {
+            uwriteln!(self.src, "{name}: {},", field.ty);
+        }
+        self.src.push_str("}\n");
+
+        self.world_imports_trait(resolve, world);
 
-        uwriteln!(self.src, "impl {camel} {{");
-        self.toplevel_add_to_linker(resolve, world);
+        uwriteln!(self.src, "const _: () = {{");
         uwriteln!(
             self.src,
             "
-                /// Instantiates the provided `module` using the specified
-                /// parameters, wrapping up the result in a structure that
-                /// translates between wasm and the host.
-                pub {async_} fn instantiate{async__}<T {send}>(
-                    mut store: impl wasmtime::AsContextMut<Data = T>,
-                    component: &wasmtime::component::Component,
-                    linker: &wasmtime::component::Linker<T>,
-                ) -> wasmtime::Result<(Self, wasmtime::component::Instance)> {{
-                    let instance = linker.instantiate{async__}(&mut store, component){await_}?;
-                    Ok((Self::new(store, &instance)?, instance))
-                }}
+                #[allow(unused_imports)]
+                use {wt}::component::__internal::anyhow;
+            "
+        );
 
-                /// Instantiates a pre-instantiated module using the specified
-                /// parameters, wrapping up the result in a structure that
-                /// translates between wasm and the host.
-                pub {async_} fn instantiate_pre<T {send}>(
-                    mut store: impl wasmtime::AsContextMut<Data = T>,
-                    instance_pre: &wasmtime::component::InstancePre<T>,
-                ) -> wasmtime::Result<(Self, wasmtime::component::Instance)> {{
-                    let instance = instance_pre.instantiate{async__}(&mut store){await_}?;
-                    Ok((Self::new(store, &instance)?, instance))
-                }}
+        uwriteln!(
+            self.src,
+            "impl {camel}Indices {{
+                /// Creates a new copy of `{camel}Indices` bindings which can then
+                /// be used to instantiate into a particular store.
+                ///
+                /// This method may fail if the component does not have the
+                /// required exports.
+                pub fn new(component: &{wt}::component::Component) -> {wt}::Result<Self> {{
+                    let _component = component;
+            ",
+        );
+        for (name, field) in self.exports.fields.iter() {
+            uwriteln!(self.src, "let {name} = {};", field.get_index_from_component);
+        }
+        uwriteln!(self.src, "Ok({camel}Indices {{");
+        for (name, _) in self.exports.fields.iter() {
+            uwriteln!(self.src, "{name},");
+        }
+        uwriteln!(self.src, "}})");
+        uwriteln!(self.src, "}}"); // close `fn new`
 
-                /// Low-level creation wrapper for wrapping up the exports
-                /// of the `instance` provided in this structure of wasm
-                /// exports.
+        uwriteln!(
+            self.src,
+            "
+                /// Creates a new instance of [`{camel}Indices`] from an
+                /// instantiated component.
                 ///
-                /// This function will extract exports from the `instance`
-                /// defined within `store` and wrap them all up in the
-                /// returned structure which can be used to interact with
-                /// the wasm module.
-                pub fn new(
-                    mut store: impl wasmtime::AsContextMut,
-                    instance: &wasmtime::component::Instance,
-                ) -> wasmtime::Result<Self> {{
-                    let mut store = store.as_context_mut();
-                    let mut exports = instance.exports(&mut store);
-                    let mut __exports = exports.root();
+                /// This method of creating a [`{camel}`] will perform string
+                /// lookups for all exports when this method is called. This
+                /// will only succeed if the provided instance matches the
+                /// requirements of [`{camel}`].
+                pub fn new_instance(
+                    mut store: impl {wt}::AsContextMut,
+                    instance: &{wt}::component::Instance,
+                ) -> {wt}::Result<Self> {{
+                    let _instance = instance;
             ",
         );
-        for (name, (_, get)) in self.exports.fields.iter() {
-            uwriteln!(self.src, "let {name} = {get};");
+        for (name, field) in self.exports.fields.iter() {
+            uwriteln!(self.src, "let {name} = {};", field.get_index_from_instance);
+        }
+        uwriteln!(self.src, "Ok({camel}Indices {{");
+        for (name, _) in self.exports.fields.iter() {
+            uwriteln!(self.src, "{name},");
+        }
+        uwriteln!(self.src, "}})");
+        uwriteln!(self.src, "}}"); // close `fn new_instance`
+
+        uwriteln!(
+            self.src,
+            "
+                /// Uses the indices stored in `self` to load an instance
+                /// of [`{camel}`] from the instance provided.
+                ///
+                /// Note that at this time this method will additionally
+                /// perform type-checks of all exports.
+                pub fn load(
+                    &self,
+                    mut store: impl {wt}::AsContextMut,
+                    instance: &{wt}::component::Instance,
+                ) -> {wt}::Result<{camel}> {{
+                    let _instance = instance;
+            ",
+        );
+        for (name, field) in self.exports.fields.iter() {
+            uwriteln!(self.src, "let {name} = {};", field.load);
         }
         uwriteln!(self.src, "Ok({camel} {{");
         for (name, _) in self.exports.fields.iter() {
             uwriteln!(self.src, "{name},");
         }
         uwriteln!(self.src, "}})");
-        uwriteln!(self.src, "}}"); // close `fn new`
+        uwriteln!(self.src, "}}"); // close `fn load`
+        uwriteln!(self.src, "}}"); // close `impl {camel}Indices`
+
+        uwriteln!(
+            self.src,
+            "impl {camel} {{
+                /// Convenience wrapper around [`{camel}Pre::new`] and
+                /// [`{camel}Pre::instantiate{async__}`].
+                pub {async_} fn instantiate{async__}<_T>(
+                    mut store: impl {wt}::AsContextMut<Data = _T>,
+                    component: &{wt}::component::Component,
+                    linker: &{wt}::component::Linker<_T>,
+                ) -> {wt}::Result<{camel}>
+                    {where_clause}
+                {{
+                    let pre = linker.instantiate_pre(component)?;
+                    {camel}Pre::new(pre)?.instantiate{async__}(store){await_}
+                }}
+
+                /// Convenience wrapper around [`{camel}Indices::new_instance`] and
+                /// [`{camel}Indices::load`].
+                pub fn new(
+                    mut store: impl {wt}::AsContextMut,
+                    instance: &{wt}::component::Instance,
+                ) -> {wt}::Result<{camel}> {{
+                    let indices = {camel}Indices::new_instance(&mut store, instance)?;
+                    indices.load(store, instance)
+                }}
+            ",
+        );
+        self.world_add_to_linker(resolve, world);
 
         for func in self.exports.funcs.iter() {
             self.src.push_str(func);
@@ -548,24 +1031,41 @@ impl Wasmtime {
         uwriteln!(self.src, "}};"); // close `const _: () = ...
     }
 
-    fn finish(&mut self, resolve: &Resolve, world: WorldId) -> String {
+    fn finish(&mut self, resolve: &Resolve, world: WorldId) -> anyhow::Result<String> {
+        let remapping_keys = self.opts.with.keys().cloned().collect::<HashSet<String>>();
+
+        let mut unused_keys = remapping_keys
+            .difference(&self.used_with_opts)
+            .map(|s| s.as_str())
+            .collect::<Vec<&str>>();
+
+        unused_keys.sort();
+
+        if !unused_keys.is_empty() {
+            anyhow::bail!("interfaces were specified in the `with` config option but are not referenced in the target world: {unused_keys:?}");
+        }
+
+        if let TrappableImports::Only(only) = &self.opts.trappable_imports {
+            let mut unused_imports = Vec::from_iter(
+                only.difference(&self.used_trappable_imports_opts)
+                    .map(|s| s.as_str()),
+            );
+
+            if !unused_imports.is_empty() {
+                unused_imports.sort();
+                anyhow::bail!("names specified in the `trappable_imports` config option but are not referenced in the target world: {unused_imports:?}");
+            }
+        }
+
         if !self.opts.only_interfaces {
-            self.build_struct(resolve, world)
+            self.build_world_struct(resolve, world)
         }
 
         let imports = mem::take(&mut self.import_interfaces);
-        self.emit_modules(
-            &imports
-                .into_iter()
-                .map(|(k, v)| (k, v.into_iter().map(|m| m.module).collect()))
-                .collect(),
-        );
-        if !self.exports.modules.is_empty() {
-            uwriteln!(self.src, "pub mod exports {{");
-            let exports = mem::take(&mut self.exports.modules);
-            self.emit_modules(&exports);
-            uwriteln!(self.src, "}}");
-        }
+        self.emit_modules(imports);
+
+        let exports = mem::take(&mut self.exports.modules);
+        self.emit_modules(exports);
 
         let mut src = mem::take(&mut self.src);
         if self.opts.rustfmt {
@@ -592,244 +1092,457 @@ impl Wasmtime {
             assert!(status.success());
         }
 
-        src.into()
+        Ok(src.into())
     }
 
-    fn emit_modules(&mut self, modules: &BTreeMap<Option<PackageName>, Vec<String>>) {
-        let mut map = BTreeMap::new();
-        for (pkg, modules) in modules {
-            match pkg {
-                Some(pkg) => {
-                    let prev = map
-                        .entry(&pkg.namespace)
-                        .or_insert(BTreeMap::new())
-                        .insert(&pkg.name, modules);
-                    assert!(prev.is_none());
+    fn emit_modules(&mut self, modules: Vec<(String, InterfaceName)>) {
+        #[derive(Default)]
+        struct Module {
+            submodules: BTreeMap<String, Module>,
+            contents: Vec<String>,
+        }
+        let mut map = Module::default();
+        for (module, name) in modules {
+            let path = match name {
+                InterfaceName::Remapped { local_path, .. } => local_path,
+                InterfaceName::Path(path) => path,
+            };
+            let mut cur = &mut map;
+            for name in path[..path.len() - 1].iter() {
+                cur = cur
+                    .submodules
+                    .entry(name.clone())
+                    .or_insert(Module::default());
+            }
+            cur.contents.push(module);
+        }
+
+        emit(&mut self.src, map);
+
+        fn emit(me: &mut Source, module: Module) {
+            for (name, submodule) in module.submodules {
+                uwriteln!(me, "pub mod {name} {{");
+                emit(me, submodule);
+                uwriteln!(me, "}}");
+            }
+            for submodule in module.contents {
+                uwriteln!(me, "{submodule}");
+            }
+        }
+    }
+
+    /// Attempts to find the `key`, possibly with the resource projection
+    /// `item`, within the `with` map provided to bindings configuration.
+    fn lookup_replacement(
+        &mut self,
+        resolve: &Resolve,
+        key: &WorldKey,
+        item: Option<&str>,
+    ) -> Option<String> {
+        let item = match item {
+            Some(item) => LookupItem::Name(item),
+            None => LookupItem::None,
+        };
+
+        for (lookup, mut projection) in lookup_keys(resolve, key, item) {
+            if let Some(renamed) = self.opts.with.get(&lookup) {
+                projection.push(renamed.clone());
+                projection.reverse();
+                self.used_with_opts.insert(lookup);
+                return Some(projection.join("::"));
+            }
+        }
+
+        None
+    }
+
+    fn wasmtime_path(&self) -> String {
+        self.opts
+            .wasmtime_crate
+            .clone()
+            .unwrap_or("wasmtime".to_string())
+    }
+}
+
+enum LookupItem<'a> {
+    None,
+    Name(&'a str),
+    InterfaceNoPop,
+}
+
+fn lookup_keys(
+    resolve: &Resolve,
+    key: &WorldKey,
+    item: LookupItem<'_>,
+) -> Vec<(String, Vec<String>)> {
+    struct Name<'a> {
+        prefix: Prefix,
+        item: Option<&'a str>,
+    }
+
+    #[derive(Copy, Clone)]
+    enum Prefix {
+        Namespace(PackageId),
+        UnversionedPackage(PackageId),
+        VersionedPackage(PackageId),
+        UnversionedInterface(InterfaceId),
+        VersionedInterface(InterfaceId),
+    }
+
+    let prefix = match key {
+        WorldKey::Interface(id) => Prefix::VersionedInterface(*id),
+
+        // Non-interface-keyed names don't get the lookup logic below,
+        // they're relatively uncommon so only lookup the precise key here.
+        WorldKey::Name(key) => {
+            let to_lookup = match item {
+                LookupItem::Name(item) => format!("{key}/{item}"),
+                LookupItem::None | LookupItem::InterfaceNoPop => key.to_string(),
+            };
+            return vec![(to_lookup, Vec::new())];
+        }
+    };
+
+    // Here names are iteratively attempted as `key` + `item` is "walked to
+    // its root" and each attempt is consulted in `self.opts.with`. This
+    // loop will start at the leaf, the most specific path, and then walk to
+    // the root, popping items, trying to find a result.
+    //
+    // Each time a name is "popped" the projection from the next path is
+    // pushed onto `projection`. This means that if we actually find a match
+    // then `projection` is a collection of namespaces that results in the
+    // final replacement name.
+    let (interface_required, item) = match item {
+        LookupItem::None => (false, None),
+        LookupItem::Name(s) => (false, Some(s)),
+        LookupItem::InterfaceNoPop => (true, None),
+    };
+    let mut name = Name { prefix, item };
+    let mut projection = Vec::new();
+    let mut ret = Vec::new();
+    loop {
+        let lookup = name.lookup_key(resolve);
+        ret.push((lookup, projection.clone()));
+        if !name.pop(resolve, &mut projection) {
+            break;
+        }
+        if interface_required {
+            match name.prefix {
+                Prefix::VersionedInterface(_) | Prefix::UnversionedInterface(_) => {}
+                _ => break,
+            }
+        }
+    }
+
+    return ret;
+
+    impl<'a> Name<'a> {
+        fn lookup_key(&self, resolve: &Resolve) -> String {
+            let mut s = self.prefix.lookup_key(resolve);
+            if let Some(item) = self.item {
+                s.push_str("/");
+                s.push_str(item);
+            }
+            s
+        }
+
+        fn pop(&mut self, resolve: &'a Resolve, projection: &mut Vec<String>) -> bool {
+            match (self.item, self.prefix) {
+                // If this is a versioned resource name, try the unversioned
+                // resource name next.
+                (Some(_), Prefix::VersionedInterface(id)) => {
+                    self.prefix = Prefix::UnversionedInterface(id);
+                    true
                 }
-                None => {
-                    for module in modules {
-                        uwriteln!(self.src, "{module}");
-                    }
+                // If this is an unversioned resource name then time to
+                // ignore the resource itself and move on to the next most
+                // specific item, versioned interface names.
+                (Some(item), Prefix::UnversionedInterface(id)) => {
+                    self.prefix = Prefix::VersionedInterface(id);
+                    self.item = None;
+                    projection.push(item.to_upper_camel_case());
+                    true
                 }
+                (Some(_), _) => unreachable!(),
+                (None, _) => self.prefix.pop(resolve, projection),
             }
         }
-        for (ns, pkgs) in map {
-            uwriteln!(self.src, "pub mod {} {{", ns.to_snake_case());
-            for (pkg, modules) in pkgs {
-                uwriteln!(self.src, "pub mod {} {{", pkg.to_snake_case());
-                for module in modules {
-                    uwriteln!(self.src, "{module}");
+    }
+
+    impl Prefix {
+        fn lookup_key(&self, resolve: &Resolve) -> String {
+            match *self {
+                Prefix::Namespace(id) => resolve.packages[id].name.namespace.clone(),
+                Prefix::UnversionedPackage(id) => {
+                    let mut name = resolve.packages[id].name.clone();
+                    name.version = None;
+                    name.to_string()
                 }
-                uwriteln!(self.src, "}}");
+                Prefix::VersionedPackage(id) => resolve.packages[id].name.to_string(),
+                Prefix::UnversionedInterface(id) => {
+                    let id = resolve.id_of(id).unwrap();
+                    match id.find('@') {
+                        Some(i) => id[..i].to_string(),
+                        None => id,
+                    }
+                }
+                Prefix::VersionedInterface(id) => resolve.id_of(id).unwrap(),
             }
-            uwriteln!(self.src, "}}");
+        }
+
+        fn pop(&mut self, resolve: &Resolve, projection: &mut Vec<String>) -> bool {
+            *self = match *self {
+                // try the unversioned interface next
+                Prefix::VersionedInterface(id) => Prefix::UnversionedInterface(id),
+                // try this interface's versioned package next
+                Prefix::UnversionedInterface(id) => {
+                    let iface = &resolve.interfaces[id];
+                    let name = iface.name.as_ref().unwrap();
+                    projection.push(to_rust_ident(name));
+                    Prefix::VersionedPackage(iface.package.unwrap())
+                }
+                // try the unversioned package next
+                Prefix::VersionedPackage(id) => Prefix::UnversionedPackage(id),
+                // try this package's namespace next
+                Prefix::UnversionedPackage(id) => {
+                    let name = &resolve.packages[id].name;
+                    projection.push(to_rust_ident(&name.name));
+                    Prefix::Namespace(id)
+                }
+                // nothing left to try any more
+                Prefix::Namespace(_) => return false,
+            };
+            true
         }
     }
 }
 
 impl Wasmtime {
-    fn has_world_trait(&self, resolve: &Resolve, world: WorldId) -> bool {
+    fn has_world_imports_trait(&self, resolve: &Resolve, world: WorldId) -> bool {
         !self.import_functions.is_empty() || get_world_resources(resolve, world).count() > 0
     }
 
-    fn toplevel_import_trait(&mut self, resolve: &Resolve, world: WorldId) {
-        if !self.has_world_trait(resolve, world) {
+    fn world_imports_trait(&mut self, resolve: &Resolve, world: WorldId) {
+        if !self.has_world_imports_trait(resolve, world) {
             return;
         }
 
+        let wt = self.wasmtime_path();
         let world_camel = to_rust_upper_camel_case(&resolve.worlds[world].name);
         if self.opts.async_.maybe_async() {
-            uwriteln!(self.src, "#[wasmtime::component::__internal::async_trait]")
+            uwriteln!(self.src, "#[{wt}::component::__internal::async_trait]")
         }
         uwrite!(self.src, "pub trait {world_camel}Imports");
-        for (i, resource) in get_world_resources(resolve, world).enumerate() {
-            if i == 0 {
-                uwrite!(self.src, ": ");
-            } else {
-                uwrite!(self.src, " + ");
-            }
-            uwrite!(self.src, "Host{}", resource.to_upper_camel_case());
+        let mut supertraits = vec![];
+        if self.opts.async_.maybe_async() {
+            supertraits.push("Send".to_string());
         }
-        uwriteln!(self.src, " {{");
-        for f in self.import_functions.iter() {
-            self.src.push_str(&f.sig);
-            self.src.push_str("\n");
+        for resource in get_world_resources(resolve, world) {
+            supertraits.push(format!("Host{}", resource.to_upper_camel_case()));
         }
-        uwriteln!(self.src, "}}");
-    }
-
-    fn toplevel_add_to_linker(&mut self, resolve: &Resolve, world: WorldId) {
-        let has_world_trait = self.has_world_trait(resolve, world);
-        if self.import_interfaces.is_empty() && !has_world_trait {
-            return;
+        if !supertraits.is_empty() {
+            uwrite!(self.src, ": {}", supertraits.join(" + "));
         }
-        let mut interfaces = Vec::new();
-        for (pkg, imports) in self.import_interfaces.iter() {
-            for import in imports {
-                let mut path = String::new();
-                if let Some(pkg) = pkg {
-                    path.push_str(&pkg.namespace.to_snake_case());
-                    path.push_str("::");
-                    path.push_str(&pkg.name.to_snake_case());
-                    path.push_str("::");
-                }
-
-                path.push_str(&import.snake);
-                interfaces.push(path);
+        uwriteln!(self.src, " {{");
+        for f in self.import_functions.iter() {
+            if let Some(sig) = &f.sig {
+                self.src.push_str(sig);
+                self.src.push_str(";\n");
             }
         }
+        uwriteln!(self.src, "}}");
 
-        uwrite!(
+        uwriteln!(
             self.src,
             "
-                pub fn add_to_linker<T, U>(
-                    linker: &mut wasmtime::component::Linker<T>,
-                    get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
-                ) -> wasmtime::Result<()>
-                    where U: \
+                pub trait {world_camel}ImportsGetHost<T>:
+                    Fn(T) -> <Self as {world_camel}ImportsGetHost<T>>::Host
+                        + Send
+                        + Sync
+                        + Copy
+                        + 'static
+                {{
+                    type Host: {world_camel}Imports;
+                }}
+
+                impl<F, T, O> {world_camel}ImportsGetHost<T> for F
+                where
+                    F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                    O: {world_camel}Imports
+                {{
+                    type Host = O;
+                }}
             "
         );
-        let world_camel = to_rust_upper_camel_case(&resolve.worlds[world].name);
-        let world_trait = format!("{world_camel}Imports");
-        for (i, name) in interfaces
-            .iter()
-            .map(|n| format!("{n}::Host"))
-            .chain(if has_world_trait {
-                Some(world_trait.clone())
-            } else {
-                None
-            })
-            .enumerate()
-        {
-            if i > 0 {
-                self.src.push_str(" + ");
-            }
-            self.src.push_str(&name);
-        }
 
-        let maybe_send = if self.opts.async_.maybe_async() {
-            " + Send, T: Send"
+        // Generate impl WorldImports for &mut WorldImports
+        let (async_trait, maybe_send) = if self.opts.async_.maybe_async() {
+            (
+                format!("#[{wt}::component::__internal::async_trait]\n"),
+                "+ Send",
+            )
         } else {
-            ""
+            (String::new(), "")
         };
-
-        self.src.push_str(maybe_send);
-        self.src.push_str(",\n{\n");
-        for name in interfaces.iter() {
-            uwriteln!(self.src, "{name}::add_to_linker(linker, get)?;");
-        }
-        if has_world_trait {
-            uwriteln!(self.src, "Self::add_root_to_linker(linker, get)?;");
-        }
-        uwriteln!(self.src, "Ok(())\n}}");
-        if !has_world_trait {
-            return;
-        }
-
-        uwrite!(
-            self.src,
-            "
-                pub fn add_root_to_linker<T, U>(
-                    linker: &mut wasmtime::component::Linker<T>,
-                    get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
-                ) -> wasmtime::Result<()>
-                    where U: {world_trait}{maybe_send}
-                {{
-                    let mut linker = linker.root();
-            ",
-        );
-        for name in get_world_resources(resolve, world) {
-            let camel = name.to_upper_camel_case();
+        if !self.opts.skip_mut_forwarding_impls {
             uwriteln!(
                 self.src,
-                "linker.resource::<{camel}>(
-                    \"{name}\",
-                    move |mut store, rep| -> wasmtime::Result<()> {{
-                        Host{camel}::drop(get(store.data_mut()), wasmtime::component::Resource::new_own(rep))
-                    }},
-                )?;"
-            )
-        }
-
-        for f in self.import_functions.iter() {
-            self.src.push_str(&f.add_to_linker);
-            self.src.push_str("\n");
+                "{async_trait}impl<_T: {world_camel}Imports + ?Sized {maybe_send}> {world_camel}Imports for &mut _T {{"
+            );
+            // Forward each method call to &mut T
+            for f in self.import_functions.iter() {
+                if let Some(sig) = &f.sig {
+                    self.src.push_str(sig);
+                    uwrite!(
+                        self.src,
+                        "{{ {world_camel}Imports::{}(*self,",
+                        rust_function_name(&f.func)
+                    );
+                    for (name, _) in f.func.params.iter() {
+                        uwrite!(self.src, "{},", to_rust_ident(name));
+                    }
+                    uwrite!(self.src, ")");
+                    if self.opts.async_.is_import_async(&f.func.name) {
+                        uwrite!(self.src, ".await");
+                    }
+                    uwriteln!(self.src, "}}");
+                }
+            }
+            uwriteln!(self.src, "}}");
         }
-        uwriteln!(self.src, "Ok(())\n}}");
     }
-}
-
-fn resolve_type_in_package(
-    resolve: &Resolve,
-    package_path: &str,
-    type_name: &str,
-) -> anyhow::Result<TypeId> {
-    // foo:bar/baz
-
-    let (namespace, rest) = package_path
-        .split_once(':')
-        .ok_or_else(|| anyhow!("Invalid package path: missing package identifier"))?;
 
-    let (package_name, iface_name) = rest
-        .split_once('/')
-        .ok_or_else(|| anyhow!("Invalid package path: missing namespace separator"))?;
-
-    // TODO: we should handle version annotations
-    if package_name.contains('@') {
-        bail!("Invalid package path: version parsing is not currently handled");
+    fn import_interface_paths(&self) -> Vec<String> {
+        self.import_interfaces
+            .iter()
+            .map(|(_, name)| match name {
+                InterfaceName::Path(path) => path.join("::"),
+                InterfaceName::Remapped { name_at_root, .. } => name_at_root.clone(),
+            })
+            .collect()
     }
 
-    let packages = Vec::from_iter(
-        resolve
-            .package_names
+    fn world_host_traits(&self, resolve: &Resolve, world: WorldId) -> Vec<String> {
+        let mut traits = self
+            .import_interface_paths()
             .iter()
-            .filter(|(pname, _)| pname.namespace == namespace && pname.name == package_name),
-    );
+            .map(|path| format!("{path}::Host"))
+            .collect::<Vec<_>>();
+        if self.has_world_imports_trait(resolve, world) {
+            let world_camel = to_rust_upper_camel_case(&resolve.worlds[world].name);
+            traits.push(format!("{world_camel}Imports"));
+        }
+        if self.opts.async_.maybe_async() {
+            traits.push("Send".to_string());
+        }
+        traits
+    }
+
+    fn world_add_to_linker(&mut self, resolve: &Resolve, world: WorldId) {
+        let has_world_imports_trait = self.has_world_imports_trait(resolve, world);
+        if self.import_interfaces.is_empty() && !has_world_imports_trait {
+            return;
+        }
 
-    if packages.len() != 1 {
-        if packages.is_empty() {
-            bail!("No package named `{}`", namespace);
+        let camel = to_rust_upper_camel_case(&resolve.worlds[world].name);
+        let data_bounds = if self.opts.is_store_data_send() {
+            "T: Send,"
         } else {
-            // Getting here is a bug, parsing version identifiers would disambiguate the intended
-            // package.
-            bail!(
-                "Multiple packages named `{}` found ({:?})",
-                namespace,
-                packages
+            ""
+        };
+        let wt = self.wasmtime_path();
+        if has_world_imports_trait {
+            uwrite!(
+                self.src,
+                "
+                    pub fn add_to_linker_imports_get_host<T>(
+                        linker: &mut {wt}::component::Linker<T>,
+                        host_getter: impl for<'a> {camel}ImportsGetHost<&'a mut T>,
+                    ) -> {wt}::Result<()>
+                        where {data_bounds}
+                    {{
+                        let mut linker = linker.root();
+                "
+            );
+            for name in get_world_resources(resolve, world) {
+                Self::generate_add_resource_to_linker(
+                    &mut self.src,
+                    &self.opts,
+                    &wt,
+                    "linker",
+                    name,
+                );
+            }
+            for f in self.import_functions.iter() {
+                self.src.push_str(&f.add_to_linker);
+                self.src.push_str("\n");
+            }
+            uwriteln!(self.src, "Ok(())\n}}");
+        }
+
+        let host_bounds = format!("U: {}", self.world_host_traits(resolve, world).join(" + "));
+
+        if !self.opts.skip_mut_forwarding_impls {
+            uwriteln!(
+                self.src,
+                "
+                    pub fn add_to_linker<T, U>(
+                        linker: &mut {wt}::component::Linker<T>,
+                        get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+                    ) -> {wt}::Result<()>
+                        where
+                            {data_bounds}
+                            {host_bounds}
+                    {{
+                "
             );
+            if has_world_imports_trait {
+                uwriteln!(
+                    self.src,
+                    "Self::add_to_linker_imports_get_host(linker, get)?;"
+                );
+            }
+            for path in self.import_interface_paths() {
+                uwriteln!(self.src, "{path}::add_to_linker(linker, get)?;");
+            }
+            uwriteln!(self.src, "Ok(())\n}}");
         }
     }
 
-    let (_, &package_id) = packages[0];
-    let package = &resolve.packages[package_id];
-
-    let (_, &iface_id) = package
-        .interfaces
-        .iter()
-        .find(|(name, _)| name.as_str() == iface_name)
-        .ok_or_else(|| {
-            anyhow!(
-                "Unknown interface `{}` in package `{}`",
-                iface_name,
-                package_path
+    fn generate_add_resource_to_linker(
+        src: &mut Source,
+        opts: &Opts,
+        wt: &str,
+        inst: &str,
+        name: &str,
+    ) {
+        let camel = name.to_upper_camel_case();
+        if opts.async_.is_drop_async(name) {
+            uwriteln!(
+                src,
+                "{inst}.resource_async(
+                    \"{name}\",
+                    {wt}::component::ResourceType::host::<{camel}>(),
+                    move |mut store, rep| {{
+                        std::boxed::Box::new(async move {{
+                            Host{camel}::drop(&mut host_getter(store.data_mut()), {wt}::component::Resource::new_own(rep)).await
+                        }})
+                    }},
+                )?;"
             )
-        })?;
-
-    let iface = &resolve.interfaces[iface_id];
-
-    let (_, &type_id) = iface
-        .types
-        .iter()
-        .find(|(n, _)| n.as_str() == type_name)
-        .ok_or_else(|| {
-            anyhow!(
-                "No type named `{}` in package `{}`",
-                package_name,
-                package_path
+        } else {
+            uwriteln!(
+                src,
+                "{inst}.resource(
+                    \"{name}\",
+                    {wt}::component::ResourceType::host::<{camel}>(),
+                    move |mut store, rep| -> {wt}::Result<()> {{
+                        Host{camel}::drop(&mut host_getter(store.data_mut()), {wt}::component::Resource::new_own(rep))
+                    }},
+                )?;"
             )
-        })?;
-
-    Ok(type_id)
+        }
+    }
 }
 
 struct InterfaceGenerator<'a> {
@@ -837,32 +1550,15 @@ struct InterfaceGenerator<'a> {
     gen: &'a mut Wasmtime,
     resolve: &'a Resolve,
     current_interface: Option<(InterfaceId, &'a WorldKey, bool)>,
-
-    /// A mapping of wit types to their rust type name equivalent. This is the pre-processed
-    /// version of `gen.opts.trappable_error_types`, where the types have been eagerly resolved.
-    trappable_errors: IndexMap<TypeId, String>,
 }
 
 impl<'a> InterfaceGenerator<'a> {
     fn new(gen: &'a mut Wasmtime, resolve: &'a Resolve) -> InterfaceGenerator<'a> {
-        let trappable_errors = gen
-            .opts
-            .trappable_error_type
-            .iter()
-            .map(|te| {
-                let id = resolve_type_in_package(resolve, &te.wit_package_path, &te.wit_type_name)
-                    .context(format!("resolving {:?}", te))?;
-                Ok((id, te.rust_type_name.clone()))
-            })
-            .collect::<anyhow::Result<IndexMap<_, _>>>()
-            .unwrap();
-
         InterfaceGenerator {
             src: Source::default(),
             gen,
             resolve,
             current_interface: None,
-            trappable_errors,
         }
     }
 
@@ -876,10 +1572,6 @@ impl<'a> InterfaceGenerator<'a> {
     fn types(&mut self, id: InterfaceId) {
         for (name, id) in self.resolve.interfaces[id].types.iter() {
             self.define_type(name, *id);
-
-            if let Some(rust_name) = self.trappable_errors.get(id) {
-                self.define_trappable_error_type(*id, rust_name.clone())
-            }
         }
     }
 
@@ -914,15 +1606,19 @@ impl<'a> InterfaceGenerator<'a> {
 
     fn type_resource(&mut self, id: TypeId, name: &str, resource: &TypeDef, docs: &Docs) {
         let camel = name.to_upper_camel_case();
+        let wt = self.gen.wasmtime_path();
 
         if self.types_imported() {
             self.rustdoc(docs);
 
-            let with_key = match self.current_interface {
-                Some((_, key, _)) => format!("{}/{name}", self.resolve.name_world_key(key)),
-                None => name.to_string(),
+            let replacement = match self.current_interface {
+                Some((_, key, _)) => self.gen.lookup_replacement(self.resolve, key, Some(name)),
+                None => {
+                    self.gen.used_with_opts.insert(name.into());
+                    self.gen.opts.with.get(name).cloned()
+                }
             };
-            match self.gen.opts.with.get(&with_key) {
+            match replacement {
                 Some(path) => {
                     uwriteln!(
                         self.src,
@@ -935,13 +1631,13 @@ impl<'a> InterfaceGenerator<'a> {
                 }
             }
 
+            // Generate resource trait
             if self.gen.opts.async_.maybe_async() {
-                uwriteln!(self.src, "#[wasmtime::component::__internal::async_trait]")
+                uwriteln!(self.src, "#[{wt}::component::__internal::async_trait]")
             }
-
             uwriteln!(self.src, "pub trait Host{camel} {{");
 
-            let functions = match resource.owner {
+            let mut functions = match resource.owner {
                 TypeOwner::World(id) => self.resolve.worlds[id]
                     .imports
                     .values()
@@ -959,40 +1655,82 @@ impl<'a> InterfaceGenerator<'a> {
                 }
             };
 
-            for func in functions {
-                match func.kind {
-                    FunctionKind::Method(resource)
-                    | FunctionKind::Static(resource)
-                    | FunctionKind::Constructor(resource)
-                        if id == resource => {}
-                    _ => continue,
-                }
+            functions.retain(|func| match func.kind {
+                FunctionKind::Freestanding => false,
+                FunctionKind::Method(resource)
+                | FunctionKind::Static(resource)
+                | FunctionKind::Constructor(resource) => id == resource,
+            });
 
+            for func in &functions {
                 self.generate_function_trait_sig(func);
+                self.push_str(";\n");
             }
 
+            if self.gen.opts.async_.is_drop_async(name) {
+                uwrite!(self.src, "async ");
+            }
             uwrite!(
                 self.src,
-                "fn drop(&mut self, rep: wasmtime::component::Resource<{camel}>) -> wasmtime::Result<()>;");
+                "fn drop(&mut self, rep: {wt}::component::Resource<{camel}>) -> {wt}::Result<()>;"
+            );
 
             uwriteln!(self.src, "}}");
+
+            // Generate impl HostResource for &mut HostResource
+            if !self.gen.opts.skip_mut_forwarding_impls {
+                let (async_trait, maybe_send) = if self.gen.opts.async_.maybe_async() {
+                    (
+                        format!("#[{wt}::component::__internal::async_trait]\n"),
+                        "+ Send",
+                    )
+                } else {
+                    (String::new(), "")
+                };
+                uwriteln!(
+                    self.src,
+                    "{async_trait}impl <_T: Host{camel} + ?Sized {maybe_send}> Host{camel} for &mut _T {{"
+                );
+                for func in &functions {
+                    self.generate_function_trait_sig(func);
+                    uwrite!(
+                        self.src,
+                        "{{ Host{camel}::{}(*self,",
+                        rust_function_name(func)
+                    );
+                    for (name, _) in func.params.iter() {
+                        uwrite!(self.src, "{},", to_rust_ident(name));
+                    }
+                    uwrite!(self.src, ")");
+                    if self.gen.opts.async_.is_import_async(&func.name) {
+                        uwrite!(self.src, ".await");
+                    }
+                    uwriteln!(self.src, "}}");
+                }
+                if self.gen.opts.async_.is_drop_async(name) {
+                    uwriteln!(self.src, "
+                        async fn drop(&mut self, rep: {wt}::component::Resource<{camel}>) -> {wt}::Result<()> {{
+                            Host{camel}::drop(*self, rep).await
+                        }}",
+                    );
+                } else {
+                    uwriteln!(self.src, "
+                        fn drop(&mut self, rep: {wt}::component::Resource<{camel}>) -> {wt}::Result<()> {{
+                            Host{camel}::drop(*self, rep)
+                        }}",
+                    );
+                }
+                uwriteln!(self.src, "}}");
+            }
         } else {
-            let iface_name = match self.current_interface.unwrap().1 {
-                WorldKey::Name(name) => name.to_upper_camel_case(),
-                WorldKey::Interface(i) => self.resolve.interfaces[*i]
-                    .name
-                    .as_ref()
-                    .unwrap()
-                    .to_upper_camel_case(),
-            };
             self.rustdoc(docs);
             uwriteln!(
                 self.src,
                 "
-                    pub type {camel} = wasmtime::component::ResourceAny;
+                    pub type {camel} = {wt}::component::ResourceAny;
 
                     pub struct Guest{camel}<'a> {{
-                        funcs: &'a {iface_name},
+                        funcs: &'a Guest,
                     }}
                 "
             );
@@ -1001,23 +1739,46 @@ impl<'a> InterfaceGenerator<'a> {
 
     fn type_record(&mut self, id: TypeId, _name: &str, record: &Record, docs: &Docs) {
         let info = self.info(id);
+        let wt = self.gen.wasmtime_path();
+
+        // We use a BTree set to make sure we don't have any duplicates and we have a stable order
+        let additional_derives: BTreeSet<String> = self
+            .gen
+            .opts
+            .additional_derive_attributes
+            .iter()
+            .cloned()
+            .collect();
+
         for (name, mode) in self.modes_of(id) {
             let lt = self.lifetime_for(&info, mode);
             self.rustdoc(docs);
 
-            self.push_str("#[derive(wasmtime::component::ComponentType)]\n");
+            let mut derives = additional_derives.clone();
+
+            uwriteln!(self.src, "#[derive({wt}::component::ComponentType)]");
             if lt.is_none() {
-                self.push_str("#[derive(wasmtime::component::Lift)]\n");
+                uwriteln!(self.src, "#[derive({wt}::component::Lift)]");
             }
-            self.push_str("#[derive(wasmtime::component::Lower)]\n");
+            uwriteln!(self.src, "#[derive({wt}::component::Lower)]");
             self.push_str("#[component(record)]\n");
+            if let Some(path) = &self.gen.opts.wasmtime_crate {
+                uwriteln!(self.src, "#[component(wasmtime_crate = {path})]\n");
+            }
 
             if info.is_copy() {
-                self.push_str("#[derive(Copy, Clone)]\n");
+                derives.extend(["Copy", "Clone"].into_iter().map(|s| s.to_string()));
             } else if info.is_clone() {
-                self.push_str("#[derive(Clone)]\n");
+                derives.insert("Clone".to_string());
+            }
+
+            if !derives.is_empty() {
+                self.push_str("#[derive(");
+                self.push_str(&derives.into_iter().collect::<Vec<_>>().join(", "));
+                self.push_str(")]\n")
             }
-            self.push_str(&format!("pub struct {}", name));
+
+            self.push_str(&format!("pub struct {name}"));
             self.print_generics(lt);
             self.push_str(" {\n");
             for field in record.fields.iter() {
@@ -1040,7 +1801,7 @@ impl<'a> InterfaceGenerator<'a> {
             self.push_str(
                 "fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {\n",
             );
-            self.push_str(&format!("f.debug_struct(\"{}\")", name));
+            self.push_str(&format!("f.debug_struct(\"{name}\")"));
             for field in record.fields.iter() {
                 self.push_str(&format!(
                     ".field(\"{}\", &self.{})",
@@ -1065,9 +1826,12 @@ impl<'a> InterfaceGenerator<'a> {
                 self.push_str("write!(f, \"{:?}\", self)\n");
                 self.push_str("}\n");
                 self.push_str("}\n");
-                self.push_str("impl std::error::Error for ");
-                self.push_str(&name);
-                self.push_str("{}\n");
+
+                if cfg!(feature = "std") {
+                    self.push_str("impl std::error::Error for ");
+                    self.push_str(&name);
+                    self.push_str("{}\n");
+                }
             }
             self.assert_type(id, &name);
         }
@@ -1078,7 +1842,7 @@ impl<'a> InterfaceGenerator<'a> {
         for (name, mode) in self.modes_of(id) {
             let lt = self.lifetime_for(&info, mode);
             self.rustdoc(docs);
-            self.push_str(&format!("pub type {}", name));
+            self.push_str(&format!("pub type {name}"));
             self.print_generics(lt);
             self.push_str(" = (");
             for ty in tuple.types.iter() {
@@ -1092,11 +1856,12 @@ impl<'a> InterfaceGenerator<'a> {
 
     fn type_flags(&mut self, id: TypeId, name: &str, flags: &Flags, docs: &Docs) {
         self.rustdoc(docs);
+        let wt = self.gen.wasmtime_path();
         let rust_name = to_rust_upper_camel_case(name);
-        self.src.push_str("wasmtime::component::flags!(\n");
+        uwriteln!(self.src, "{wt}::component::flags!(\n");
         self.src.push_str(&format!("{rust_name} {{\n"));
         for flag in flags.flags.iter() {
-            // TODO wasmtime-component-macro doesnt support docs for flags rn
+            // TODO wasmtime-component-macro doesn't support docs for flags rn
             uwrite!(
                 self.src,
                 "#[component(name=\"{}\")] const {};\n",
@@ -1131,7 +1896,7 @@ impl<'a> InterfaceGenerator<'a> {
         for (name, mode) in self.modes_of(id) {
             self.rustdoc(docs);
             let lt = self.lifetime_for(&info, mode);
-            self.push_str(&format!("pub type {}", name));
+            self.push_str(&format!("pub type {name}"));
             self.print_generics(lt);
             self.push_str("= Option<");
             self.print_ty(payload, mode);
@@ -1144,15 +1909,16 @@ impl<'a> InterfaceGenerator<'a> {
     // with the Wasmtime-understood size of a type.
     fn assert_type(&mut self, id: TypeId, name: &str) {
         self.push_str("const _: () = {\n");
+        let wt = self.gen.wasmtime_path();
         uwriteln!(
             self.src,
-            "assert!({} == <{name} as wasmtime::component::ComponentType>::SIZE32);",
-            self.gen.sizes.size(&Type::Id(id)),
+            "assert!({} == <{name} as {wt}::component::ComponentType>::SIZE32);",
+            self.gen.sizes.size(&Type::Id(id)).size_wasm32(),
         );
         uwriteln!(
             self.src,
-            "assert!({} == <{name} as wasmtime::component::ComponentType>::ALIGN32);",
-            self.gen.sizes.align(&Type::Id(id)),
+            "assert!({} == <{name} as {wt}::component::ComponentType>::ALIGN32);",
+            self.gen.sizes.align(&Type::Id(id)).align_wasm32(),
         );
         self.push_str("};\n");
     }
@@ -1167,30 +1933,52 @@ impl<'a> InterfaceGenerator<'a> {
         Self: Sized,
     {
         let info = self.info(id);
+        let wt = self.gen.wasmtime_path();
+
+        // We use a BTree set to make sure we don't have any duplicates and we have a stable order
+        let additional_derives: BTreeSet<String> = self
+            .gen
+            .opts
+            .additional_derive_attributes
+            .iter()
+            .cloned()
+            .collect();
 
         for (name, mode) in self.modes_of(id) {
             let name = to_rust_upper_camel_case(&name);
 
+            let mut derives = additional_derives.clone();
+
             self.rustdoc(docs);
             let lt = self.lifetime_for(&info, mode);
-            self.push_str("#[derive(wasmtime::component::ComponentType)]\n");
+            uwriteln!(self.src, "#[derive({wt}::component::ComponentType)]");
             if lt.is_none() {
-                self.push_str("#[derive(wasmtime::component::Lift)]\n");
+                uwriteln!(self.src, "#[derive({wt}::component::Lift)]");
+            }
+            uwriteln!(self.src, "#[derive({wt}::component::Lower)]");
+            self.push_str(&format!("#[component({derive_component})]\n"));
+            if let Some(path) = &self.gen.opts.wasmtime_crate {
+                uwriteln!(self.src, "#[component(wasmtime_crate = {path})]\n");
             }
-            self.push_str("#[derive(wasmtime::component::Lower)]\n");
-            self.push_str(&format!("#[component({})]\n", derive_component));
             if info.is_copy() {
-                self.push_str("#[derive(Copy, Clone)]\n");
+                derives.extend(["Copy", "Clone"].into_iter().map(|s| s.to_string()));
             } else if info.is_clone() {
-                self.push_str("#[derive(Clone)]\n");
+                derives.insert("Clone".to_string());
+            }
+
+            if !derives.is_empty() {
+                self.push_str("#[derive(");
+                self.push_str(&derives.into_iter().collect::<Vec<_>>().join(", "));
+                self.push_str(")]\n")
             }
+
             self.push_str(&format!("pub enum {name}"));
             self.print_generics(lt);
             self.push_str("{\n");
             for (case_name, component_name, docs, payload) in cases.clone() {
                 self.rustdoc(docs);
                 if let Some(n) = component_name {
-                    self.push_str(&format!("#[component(name = \"{}\")] ", n));
+                    self.push_str(&format!("#[component(name = \"{n}\")] "));
                 }
                 self.push_str(&case_name);
                 if let Some(ty) = payload {
@@ -1227,12 +2015,14 @@ impl<'a> InterfaceGenerator<'a> {
                 self.push_str("}\n");
                 self.push_str("\n");
 
-                self.push_str("impl");
-                self.print_generics(lt);
-                self.push_str(" std::error::Error for ");
-                self.push_str(&name);
-                self.print_generics(lt);
-                self.push_str(" {}\n");
+                if cfg!(feature = "std") {
+                    self.push_str("impl");
+                    self.print_generics(lt);
+                    self.push_str(" std::error::Error for ");
+                    self.push_str(&name);
+                    self.print_generics(lt);
+                    self.push_str(" {}\n");
+                }
             }
 
             self.assert_type(id, &name);
@@ -1266,7 +2056,7 @@ impl<'a> InterfaceGenerator<'a> {
                 self.push_str("(e)");
             }
             self.push_str(" => {\n");
-            self.push_str(&format!("f.debug_tuple(\"{}::{}\")", name, case_name));
+            self.push_str(&format!("f.debug_tuple(\"{name}::{case_name}\")"));
             if payload.is_some() {
                 self.push_str(".field(e)");
             }
@@ -1284,7 +2074,7 @@ impl<'a> InterfaceGenerator<'a> {
         for (name, mode) in self.modes_of(id) {
             self.rustdoc(docs);
             let lt = self.lifetime_for(&info, mode);
-            self.push_str(&format!("pub type {}", name));
+            self.push_str(&format!("pub type {name}"));
             self.print_generics(lt);
             self.push_str("= Result<");
             self.print_optional_ty(result.ok.as_ref(), mode);
@@ -1297,15 +2087,45 @@ impl<'a> InterfaceGenerator<'a> {
 
     fn type_enum(&mut self, id: TypeId, name: &str, enum_: &Enum, docs: &Docs) {
         let info = self.info(id);
+        let wt = self.gen.wasmtime_path();
+
+        // We use a BTree set to make sure we don't have any duplicates and have a stable order
+        let mut derives: BTreeSet<String> = self
+            .gen
+            .opts
+            .additional_derive_attributes
+            .iter()
+            .cloned()
+            .collect();
+
+        derives.extend(
+            ["Clone", "Copy", "PartialEq", "Eq"]
+                .into_iter()
+                .map(|s| s.to_string()),
+        );
 
         let name = to_rust_upper_camel_case(name);
         self.rustdoc(docs);
-        self.push_str("#[derive(wasmtime::component::ComponentType)]\n");
-        self.push_str("#[derive(wasmtime::component::Lift)]\n");
-        self.push_str("#[derive(wasmtime::component::Lower)]\n");
+        uwriteln!(self.src, "#[derive({wt}::component::ComponentType)]");
+        uwriteln!(self.src, "#[derive({wt}::component::Lift)]");
+        uwriteln!(self.src, "#[derive({wt}::component::Lower)]");
         self.push_str("#[component(enum)]\n");
-        self.push_str("#[derive(Clone, Copy, PartialEq, Eq)]\n");
-        self.push_str(&format!("pub enum {} {{\n", name));
+        if let Some(path) = &self.gen.opts.wasmtime_crate {
+            uwriteln!(self.src, "#[component(wasmtime_crate = {path})]\n");
+        }
+
+        self.push_str("#[derive(");
+        self.push_str(&derives.into_iter().collect::<Vec<_>>().join(", "));
+        self.push_str(")]\n");
+
+        let repr = match enum_.cases.len().ilog2() {
+            0..=7 => "u8",
+            8..=15 => "u16",
+            _ => "u32",
+        };
+        uwriteln!(self.src, "#[repr({repr})]");
+
+        self.push_str(&format!("pub enum {name} {{\n"));
         for case in enum_.cases.iter() {
             self.rustdoc(&case.docs);
             self.push_str(&format!("#[component(name = \"{}\")]", case.name));
@@ -1375,9 +2195,11 @@ impl<'a> InterfaceGenerator<'a> {
             self.push_str("}\n");
             self.push_str("}\n");
             self.push_str("\n");
-            self.push_str("impl std::error::Error for ");
-            self.push_str(&name);
-            self.push_str("{}\n");
+            if cfg!(feature = "std") {
+                self.push_str("impl std::error::Error for ");
+                self.push_str(&name);
+                self.push_str("{}\n");
+            }
         } else {
             self.print_rust_enum_debug(
                 id,
@@ -1396,7 +2218,7 @@ impl<'a> InterfaceGenerator<'a> {
         let info = self.info(id);
         for (name, mode) in self.modes_of(id) {
             self.rustdoc(docs);
-            self.push_str(&format!("pub type {}", name));
+            self.push_str(&format!("pub type {name}"));
             let lt = self.lifetime_for(&info, mode);
             self.print_generics(lt);
             self.push_str(" = ");
@@ -1414,7 +2236,7 @@ impl<'a> InterfaceGenerator<'a> {
         for (name, mode) in self.modes_of(id) {
             let lt = self.lifetime_for(&info, mode);
             self.rustdoc(docs);
-            self.push_str(&format!("pub type {}", name));
+            self.push_str(&format!("pub type {name}"));
             self.print_generics(lt);
             self.push_str(" = ");
             self.print_list(ty, mode);
@@ -1444,9 +2266,15 @@ impl<'a> InterfaceGenerator<'a> {
     }
 
     fn special_case_trappable_error(
-        &self,
-        results: &Results,
+        &mut self,
+        func: &Function,
     ) -> Option<(&'a Result_, TypeId, String)> {
+        let results = &func.results;
+
+        self.gen
+            .used_trappable_imports_opts
+            .insert(func.name.clone());
+
         // We fillin a special trappable error type in the case when a function has just one
         // result, which is itself a `result<a, e>`, and the `e` is *not* a primitive
         // (i.e. defined in std) type, and matches the typename given by the user.
@@ -1467,29 +2295,35 @@ impl<'a> InterfaceGenerator<'a> {
             _ => return None,
         };
 
-        let rust_type = self.trappable_errors.get(&error_typeid)?;
+        let name = self.gen.trappable_errors.get(&error_typeid)?;
 
-        Some((result, error_typeid, rust_type.clone()))
+        let mut path = self.path_to_root();
+        uwrite!(path, "{name}");
+        Some((result, error_typeid, path))
     }
 
     fn generate_add_to_linker(&mut self, id: InterfaceId, name: &str) {
         let iface = &self.resolve.interfaces[id];
         let owner = TypeOwner::Interface(id);
+        let wt = self.gen.wasmtime_path();
 
-        if self.gen.opts.async_.maybe_async() {
-            uwriteln!(self.src, "#[wasmtime::component::__internal::async_trait]")
+        let is_maybe_async = self.gen.opts.async_.maybe_async();
+        if is_maybe_async {
+            uwriteln!(self.src, "#[{wt}::component::__internal::async_trait]")
         }
         // Generate the `pub trait` which represents the host functionality for
         // this import which additionally inherits from all resource traits
         // for this interface defined by `type_resource`.
         uwrite!(self.src, "pub trait Host");
-        for (i, resource) in get_resources(self.resolve, id).enumerate() {
-            if i == 0 {
-                uwrite!(self.src, ": ");
-            } else {
-                uwrite!(self.src, " + ");
-            }
-            uwrite!(self.src, "Host{}", resource.to_upper_camel_case());
+        let mut host_supertraits = vec![];
+        if is_maybe_async {
+            host_supertraits.push("Send".to_string());
+        }
+        for resource in get_resources(self.resolve, id) {
+            host_supertraits.push(format!("Host{}", resource.to_upper_camel_case()));
+        }
+        if !host_supertraits.is_empty() {
+            uwrite!(self.src, ": {}", host_supertraits.join(" + "));
         }
         uwriteln!(self.src, " {{");
         for (_, func) in iface.functions.iter() {
@@ -1498,39 +2332,101 @@ impl<'a> InterfaceGenerator<'a> {
                 _ => continue,
             }
             self.generate_function_trait_sig(func);
+            self.push_str(";\n");
+        }
+
+        // Generate `convert_*` functions to convert custom trappable errors
+        // into the representation required by Wasmtime's component API.
+        let mut required_conversion_traits = IndexSet::new();
+        let mut errors_converted = IndexMap::new();
+        let mut my_error_types = iface
+            .types
+            .iter()
+            .filter(|(_, id)| self.gen.trappable_errors.contains_key(*id))
+            .map(|(_, id)| *id)
+            .collect::<Vec<_>>();
+        my_error_types.extend(
+            iface
+                .functions
+                .iter()
+                .filter_map(|(_, func)| self.special_case_trappable_error(func))
+                .map(|(_, id, _)| id),
+        );
+        let root = self.path_to_root();
+        for err_id in my_error_types {
+            let custom_name = &self.gen.trappable_errors[&err_id];
+            let err = &self.resolve.types[resolve_type_definition_id(self.resolve, err_id)];
+            let err_name = err.name.as_ref().unwrap();
+            let err_snake = err_name.to_snake_case();
+            let err_camel = err_name.to_upper_camel_case();
+            let owner = match err.owner {
+                TypeOwner::Interface(i) => i,
+                _ => unimplemented!(),
+            };
+            match self.path_to_interface(owner) {
+                Some(path) => {
+                    required_conversion_traits.insert(format!("{path}::Host"));
+                }
+                None => {
+                    if errors_converted.insert(err_name, err_id).is_none() {
+                        uwriteln!(
+                            self.src,
+                            "fn convert_{err_snake}(&mut self, err: {root}{custom_name}) -> {wt}::Result<{err_camel}>;"
+                        );
+                    }
+                }
+            }
         }
         uwriteln!(self.src, "}}");
 
-        let where_clause = if self.gen.opts.async_.maybe_async() {
-            "T: Send, U: Host + Send".to_string()
+        let (data_bounds, mut host_bounds) = if self.gen.opts.is_store_data_send() {
+            ("T: Send,", "Host + Send".to_string())
         } else {
-            "U: Host".to_string()
+            ("", "Host".to_string())
         };
+        for ty in required_conversion_traits {
+            uwrite!(host_bounds, " + {ty}");
+        }
 
         uwriteln!(
             self.src,
             "
-                pub fn add_to_linker<T, U>(
-                    linker: &mut wasmtime::component::Linker<T>,
-                    get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
-                ) -> wasmtime::Result<()>
-                    where {where_clause}
+                pub trait GetHost<T>:
+                    Fn(T) -> <Self as GetHost<T>>::Host
+                        + Send
+                        + Sync
+                        + Copy
+                        + 'static
+                {{
+                    type Host: {host_bounds};
+                }}
+
+                impl<F, T, O> GetHost<T> for F
+                where
+                    F: Fn(T) -> O + Send + Sync + Copy + 'static,
+                    O: {host_bounds},
+                {{
+                    type Host = O;
+                }}
+
+                pub fn add_to_linker_get_host<T>(
+                    linker: &mut {wt}::component::Linker<T>,
+                    host_getter: impl for<'a> GetHost<&'a mut T>,
+                ) -> {wt}::Result<()>
+                    where {data_bounds}
                 {{
             "
         );
         uwriteln!(self.src, "let mut inst = linker.instance(\"{name}\")?;");
 
         for name in get_resources(self.resolve, id) {
-            let camel = name.to_upper_camel_case();
-            uwriteln!(
-                self.src,
-                "inst.resource::<{camel}>(
-                    \"{name}\",
-                    move |mut store, rep| -> wasmtime::Result<()> {{
-                        Host{camel}::drop(get(store.data_mut()), wasmtime::component::Resource::new_own(rep))
-                    }},
-                )?;"
-            )
+            Wasmtime::generate_add_resource_to_linker(
+                &mut self.src,
+                &self.gen.opts,
+                &wt,
+                "inst",
+                name,
+            );
         }
 
         for (_, func) in iface.functions.iter() {
@@ -1538,6 +2434,68 @@ impl<'a> InterfaceGenerator<'a> {
         }
         uwriteln!(self.src, "Ok(())");
         uwriteln!(self.src, "}}");
+
+        if !self.gen.opts.skip_mut_forwarding_impls {
+            // Generate add_to_linker (with closure)
+            uwriteln!(
+                self.src,
+                "
+                pub fn add_to_linker<T, U>(
+                    linker: &mut {wt}::component::Linker<T>,
+                    get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static,
+                ) -> {wt}::Result<()>
+                    where
+                        U: {host_bounds}, {data_bounds}
+                {{
+                    add_to_linker_get_host(linker, get)
+                }}
+                "
+            );
+
+            // Generate impl Host for &mut Host
+            let (async_trait, maybe_send) = if is_maybe_async {
+                (
+                    format!("#[{wt}::component::__internal::async_trait]"),
+                    "+ Send",
+                )
+            } else {
+                (String::new(), "")
+            };
+
+            uwriteln!(
+                self.src,
+                "{async_trait}impl<_T: Host + ?Sized {maybe_send}> Host for &mut _T {{"
+            );
+            // Forward each method call to &mut T
+            for (_, func) in iface.functions.iter() {
+                match func.kind {
+                    FunctionKind::Freestanding => {}
+                    _ => continue,
+                }
+                self.generate_function_trait_sig(func);
+                uwrite!(self.src, "{{ Host::{}(*self,", rust_function_name(func));
+                for (name, _) in func.params.iter() {
+                    uwrite!(self.src, "{},", to_rust_ident(name));
+                }
+                uwrite!(self.src, ")");
+                if self.gen.opts.async_.is_import_async(&func.name) {
+                    uwrite!(self.src, ".await");
+                }
+                uwriteln!(self.src, "}}");
+            }
+            for (err_name, err_id) in errors_converted {
+                uwriteln!(
+                    self.src,
+                    "fn convert_{err_snake}(&mut self, err: {root}{custom_name}) -> {wt}::Result<{err_camel}> {{
+                        Host::convert_{err_snake}(*self, err)
+                    }}",
+                    custom_name = self.gen.trappable_errors[&err_id],
+                    err_snake = err_name.to_snake_case(),
+                    err_camel = err_name.to_upper_camel_case(),
+                );
+            }
+            uwriteln!(self.src, "}}");
+        }
     }
 
     fn generate_add_function_to_linker(&mut self, owner: TypeOwner, func: &Function, linker: &str) {
@@ -1559,8 +2517,11 @@ impl<'a> InterfaceGenerator<'a> {
         // Generate the closure that's passed to a `Linker`, the final piece of
         // codegen here.
 
-        self.src
-            .push_str("move |mut caller: wasmtime::StoreContextMut<'_, T>, (");
+        let wt = self.gen.wasmtime_path();
+        uwrite!(
+            self.src,
+            "move |mut caller: {wt}::StoreContextMut<'_, T>, ("
+        );
         for (i, _param) in func.params.iter().enumerate() {
             uwrite!(self.src, "arg{},", i);
         }
@@ -1574,7 +2535,10 @@ impl<'a> InterfaceGenerator<'a> {
         }
         self.src.push_str(") |");
         if self.gen.opts.async_.is_import_async(&func.name) {
-            self.src.push_str(" Box::new(async move { \n");
+            uwriteln!(
+                self.src,
+                " {wt}::component::__internal::Box::new(async move {{ "
+            );
         } else {
             self.src.push_str(" { \n");
         }
@@ -1618,7 +2582,8 @@ impl<'a> InterfaceGenerator<'a> {
             );
         }
 
-        self.src.push_str("let host = get(caller.data_mut());\n");
+        self.src
+            .push_str("let host = &mut host_getter(caller.data_mut());\n");
         let func_name = rust_function_name(func);
         let host_trait = match func.kind {
             FunctionKind::Freestanding => match owner {
@@ -1655,16 +2620,30 @@ impl<'a> InterfaceGenerator<'a> {
             );
         }
 
-        if self.special_case_trappable_error(&func.results).is_some() {
+        if !self.gen.opts.trappable_imports.can_trap(&func) {
+            if func.results.iter_types().len() == 1 {
+                uwrite!(self.src, "Ok((r,))\n");
+            } else {
+                uwrite!(self.src, "Ok(r)\n");
+            }
+        } else if let Some((_, err, _)) = self.special_case_trappable_error(func) {
+            let err = &self.resolve.types[resolve_type_definition_id(self.resolve, err)];
+            let err_name = err.name.as_ref().unwrap();
+            let owner = match err.owner {
+                TypeOwner::Interface(i) => i,
+                _ => unimplemented!(),
+            };
+            let convert_trait = match self.path_to_interface(owner) {
+                Some(path) => format!("{path}::Host"),
+                None => format!("Host"),
+            };
+            let convert = format!("{}::convert_{}", convert_trait, err_name.to_snake_case());
             uwrite!(
                 self.src,
-                "match r {{
-                    Ok(a) => Ok((Ok(a),)),
-                    Err(e) => match e.downcast() {{
-                        Ok(api_error) => Ok((Err(api_error),)),
-                        Err(anyhow_error) => Err(anyhow_error),
-                    }}
-                }}"
+                "Ok((match r {{
+                    Ok(a) => Ok(a),
+                    Err(e) => Err({convert}(host, e)?),
+                }},))"
             );
         } else if func.results.iter_types().len() == 1 {
             uwrite!(self.src, "Ok((r?,))\n");
@@ -1681,6 +2660,7 @@ impl<'a> InterfaceGenerator<'a> {
     }
 
     fn generate_function_trait_sig(&mut self, func: &Function) {
+        let wt = self.gen.wasmtime_path();
         self.rustdoc(&func.docs);
 
         if self.gen.opts.async_.is_import_async(&func.name) {
@@ -1699,12 +2679,12 @@ impl<'a> InterfaceGenerator<'a> {
         self.push_str(")");
         self.push_str(" -> ");
 
-        if let Some((r, error_id, error_typename)) =
-            self.special_case_trappable_error(&func.results)
-        {
+        if !self.gen.opts.trappable_imports.can_trap(func) {
+            self.print_result_ty(&func.results, TypeMode::Owned);
+        } else if let Some((r, _id, error_typename)) = self.special_case_trappable_error(func) {
             // Functions which have a single result `result<ok,err>` get special
             // cased to use the host_wasmtime_rust::Error<err>, making it possible
-            // for them to trap or use `?` to propogate their errors
+            // for them to trap or use `?` to propagate their errors
             self.push_str("Result<");
             if let Some(ok) = r.ok {
                 self.print_ty(&ok, TypeMode::Owned);
@@ -1712,29 +2692,21 @@ impl<'a> InterfaceGenerator<'a> {
                 self.push_str("()");
             }
             self.push_str(",");
-            if let TypeOwner::Interface(id) = self.resolve.types[error_id].owner {
-                if let Some(path) = self.path_to_interface(id) {
-                    self.push_str(&path);
-                    self.push_str("::");
-                }
-            }
             self.push_str(&error_typename);
             self.push_str(">");
         } else {
             // All other functions get their return values wrapped in an wasmtime::Result.
             // Returning the anyhow::Error case can be used to trap.
-            self.push_str("wasmtime::Result<");
+            uwrite!(self.src, "{wt}::Result<");
             self.print_result_ty(&func.results, TypeMode::Owned);
             self.push_str(">");
         }
-
-        self.push_str(";\n");
     }
 
     fn extract_typed_function(&mut self, func: &Function) -> (String, String) {
         let prev = mem::take(&mut self.src);
         let snake = func_field_name(self.resolve, func);
-        uwrite!(self.src, "*__exports.typed_func::<(");
+        uwrite!(self.src, "*_instance.get_typed_func::<(");
         for (_, ty) in func.params.iter() {
             self.print_ty(ty, TypeMode::AllBorrowed("'_"));
             self.push_str(", ");
@@ -1744,9 +2716,7 @@ impl<'a> InterfaceGenerator<'a> {
             self.print_ty(ty, TypeMode::Owned);
             self.push_str(", ");
         }
-        self.src.push_str(")>(\"");
-        self.src.push_str(&func.name);
-        self.src.push_str("\")?.func()");
+        uwriteln!(self.src, ")>(&mut store, &self.{snake})?.func()");
 
         let ret = (snake, mem::take(&mut self.src).to_string());
         self.src = prev;
@@ -1770,10 +2740,11 @@ impl<'a> InterfaceGenerator<'a> {
         };
 
         self.rustdoc(&func.docs);
+        let wt = self.gen.wasmtime_path();
 
         uwrite!(
             self.src,
-            "pub {async_} fn call_{}<S: wasmtime::AsContextMut>(&self, mut store: S, ",
+            "pub {async_} fn call_{}<S: {wt}::AsContextMut>(&self, mut store: S, ",
             func.item_name().to_snake_case(),
         );
 
@@ -1783,12 +2754,11 @@ impl<'a> InterfaceGenerator<'a> {
             self.push_str(",");
         }
 
-        self.src.push_str(") -> wasmtime::Result<");
+        uwrite!(self.src, ") -> {wt}::Result<");
         self.print_result_ty(&func.results, TypeMode::Owned);
 
         if is_async {
-            self.src
-                .push_str("> where <S as wasmtime::AsContext>::Data: Send {\n");
+            uwriteln!(self.src, "> where <S as {wt}::AsContext>::Data: Send {{");
         } else {
             self.src.push_str("> {\n");
         }
@@ -1813,7 +2783,7 @@ impl<'a> InterfaceGenerator<'a> {
         }
 
         self.src.push_str("let callee = unsafe {\n");
-        self.src.push_str("wasmtime::component::TypedFunc::<(");
+        uwrite!(self.src, "{wt}::component::TypedFunc::<(");
         for (_, ty) in func.params.iter() {
             self.print_ty(ty, TypeMode::AllBorrowed("'_"));
             self.push_str(", ");
@@ -1867,53 +2837,6 @@ impl<'a> InterfaceGenerator<'a> {
         self.src.push_str("}\n");
     }
 
-    fn define_trappable_error_type(&mut self, id: TypeId, rust_name: String) {
-        let info = self.info(id);
-        if self.lifetime_for(&info, TypeMode::Owned).is_some() {
-            panic!("wit error for {rust_name} is not 'static")
-        }
-        let abi_type = self.param_name(id);
-
-        uwriteln!(
-            self.src,
-            "
-                #[derive(Debug)]
-                pub struct {rust_name} {{
-                    inner: anyhow::Error,
-                }}
-                impl std::fmt::Display for {rust_name} {{
-                    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {{
-                        write!(f, \"{{}}\", self.inner)
-                    }}
-                }}
-                impl std::error::Error for {rust_name} {{
-                    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {{
-                        self.inner.source()
-                    }}
-                }}
-                impl {rust_name} {{
-                    pub fn trap(inner: anyhow::Error) -> Self {{
-                        Self {{ inner }}
-                    }}
-                    pub fn downcast(self) -> Result<{abi_type}, anyhow::Error> {{
-                        self.inner.downcast()
-                    }}
-                    pub fn downcast_ref(&self) -> Option<&{abi_type}> {{
-                        self.inner.downcast_ref()
-                    }}
-                    pub fn context(self, s: impl Into<String>) -> Self {{
-                        Self {{ inner: self.inner.context(s.into()) }}
-                    }}
-                }}
-                impl From<{abi_type}> for {rust_name} {{
-                    fn from(abi: {abi_type}) -> {rust_name} {{
-                        {rust_name} {{ inner: anyhow::Error::from(abi) }}
-                    }}
-                }}
-           "
-        );
-    }
-
     fn rustdoc(&mut self, docs: &Docs) {
         let docs = match &docs.contents {
             Some(docs) => docs,
@@ -1961,8 +2884,17 @@ impl<'a> RustGenerator<'a> for InterfaceGenerator<'a> {
             }
         }
         let mut path_to_root = self.path_to_root();
-        let InterfaceName { path, .. } = &self.gen.interface_names[&interface];
-        path_to_root.push_str(path);
+        match &self.gen.interface_names[&interface] {
+            InterfaceName::Remapped { name_at_root, .. } => path_to_root.push_str(name_at_root),
+            InterfaceName::Path(path) => {
+                for (i, name) in path.iter().enumerate() {
+                    if i > 0 {
+                        path_to_root.push_str("::");
+                    }
+                    path_to_root.push_str(name);
+                }
+            }
+        }
         Some(path_to_root)
     }
 
@@ -1977,6 +2909,10 @@ impl<'a> RustGenerator<'a> for InterfaceGenerator<'a> {
     fn is_imported_interface(&self, interface: InterfaceId) -> bool {
         self.gen.interface_last_seen_as_import[&interface]
     }
+
+    fn wasmtime_path(&self) -> String {
+        self.gen.wasmtime_path()
+    }
 }
 
 /// When an interface `use`s a type from another interface, it creates a new TypeId
diff --git a/crates/wit-bindgen/src/rust.rs b/crates/wit-bindgen/src/rust.rs
index 009bebffbbe8..d676d095f60d 100644
--- a/crates/wit-bindgen/src/rust.rs
+++ b/crates/wit-bindgen/src/rust.rs
@@ -15,6 +15,7 @@ pub trait RustGenerator<'a> {
     fn info(&self, ty: TypeId) -> TypeInfo;
     fn path_to_interface(&self, interface: InterfaceId) -> Option<String>;
     fn is_imported_interface(&self, interface: InterfaceId) -> bool;
+    fn wasmtime_path(&self) -> String;
 
     /// This determines whether we generate owning types or (where appropriate)
     /// borrowing types.
@@ -39,8 +40,8 @@ pub trait RustGenerator<'a> {
             Type::S16 => self.push_str("i16"),
             Type::S32 => self.push_str("i32"),
             Type::S64 => self.push_str("i64"),
-            Type::Float32 => self.push_str("f32"),
-            Type::Float64 => self.push_str("f64"),
+            Type::F32 => self.push_str("f32"),
+            Type::F64 => self.push_str("f64"),
             Type::Char => self.push_str("char"),
             Type::String => match mode {
                 TypeMode::AllBorrowed(lt) => {
@@ -51,7 +52,10 @@ pub trait RustGenerator<'a> {
                     }
                     self.push_str("str");
                 }
-                TypeMode::Owned => self.push_str("String"),
+                TypeMode::Owned => {
+                    let wt = self.wasmtime_path();
+                    self.push_str(&format!("{wt}::component::__internal::String"))
+                }
             },
         }
     }
@@ -212,7 +216,8 @@ pub trait RustGenerator<'a> {
                 self.push_str("]");
             }
             TypeMode::Owned => {
-                self.push_str("Vec<");
+                let wt = self.wasmtime_path();
+                self.push_str(&format!("{wt}::component::__internal::Vec<"));
                 self.print_ty(ty, next_mode);
                 self.push_str(">");
             }
@@ -242,15 +247,16 @@ pub trait RustGenerator<'a> {
             TypeOwner::Interface(i) => self.is_imported_interface(i),
             _ => true,
         };
+        let wt = self.wasmtime_path();
         if is_host_defined {
-            self.push_str("wasmtime::component::Resource<");
+            self.push_str(&format!("{wt}::component::Resource<"));
             self.print_type_name_in_interface(
                 ty.owner,
                 &ty.name.as_ref().unwrap().to_upper_camel_case(),
             );
             self.push_str(">");
         } else {
-            self.push_str("wasmtime::component::ResourceAny");
+            self.push_str(&format!("{wt}::component::ResourceAny"));
         }
     }
 
@@ -286,75 +292,6 @@ pub trait RustGenerator<'a> {
         result
     }
 
-    /// Writes the camel-cased 'name' of the passed type to `out`, as used to name union variants.
-    fn write_name(&self, ty: &Type, out: &mut String) {
-        match ty {
-            Type::Bool => out.push_str("Bool"),
-            Type::U8 => out.push_str("U8"),
-            Type::U16 => out.push_str("U16"),
-            Type::U32 => out.push_str("U32"),
-            Type::U64 => out.push_str("U64"),
-            Type::S8 => out.push_str("I8"),
-            Type::S16 => out.push_str("I16"),
-            Type::S32 => out.push_str("I32"),
-            Type::S64 => out.push_str("I64"),
-            Type::Float32 => out.push_str("F32"),
-            Type::Float64 => out.push_str("F64"),
-            Type::Char => out.push_str("Char"),
-            Type::String => out.push_str("String"),
-            Type::Id(id) => {
-                let ty = &self.resolve().types[*id];
-                match &ty.name {
-                    Some(name) => out.push_str(&name.to_upper_camel_case()),
-                    None => match &ty.kind {
-                        TypeDefKind::Option(ty) => {
-                            out.push_str("Optional");
-                            self.write_name(ty, out);
-                        }
-                        TypeDefKind::Result(_) => out.push_str("Result"),
-                        TypeDefKind::Tuple(_) => out.push_str("Tuple"),
-                        TypeDefKind::List(ty) => {
-                            self.write_name(ty, out);
-                            out.push_str("List")
-                        }
-                        TypeDefKind::Future(ty) => {
-                            self.write_optional_name(ty.as_ref(), out);
-                            out.push_str("Future");
-                        }
-                        TypeDefKind::Stream(s) => {
-                            self.write_optional_name(s.element.as_ref(), out);
-                            self.write_optional_name(s.end.as_ref(), out);
-                            out.push_str("Stream");
-                        }
-
-                        TypeDefKind::Type(ty) => self.write_name(ty, out),
-                        TypeDefKind::Record(_) => out.push_str("Record"),
-                        TypeDefKind::Flags(_) => out.push_str("Flags"),
-                        TypeDefKind::Variant(_) => out.push_str("Variant"),
-                        TypeDefKind::Enum(_) => out.push_str("Enum"),
-                        TypeDefKind::Handle(Handle::Borrow(id)) => {
-                            out.push_str("Borrow");
-                            self.write_name(&Type::Id(*id), out);
-                        }
-                        TypeDefKind::Handle(Handle::Own(id)) => {
-                            out.push_str("Own");
-                            self.write_name(&Type::Id(*id), out);
-                        }
-                        TypeDefKind::Resource => unreachable!(),
-                        TypeDefKind::Unknown => unreachable!(),
-                    },
-                }
-            }
-        }
-    }
-
-    fn write_optional_name(&self, ty: Option<&Type>, out: &mut String) {
-        match ty {
-            Some(ty) => self.write_name(ty, out),
-            None => out.push_str("()"),
-        }
-    }
-
     fn param_name(&self, ty: TypeId) -> String {
         let info = self.info(ty);
         let name = self.resolve().types[ty]
@@ -363,7 +300,7 @@ pub trait RustGenerator<'a> {
             .unwrap()
             .to_upper_camel_case();
         if self.uses_two_names(&info) {
-            format!("{}Param", name)
+            format!("{name}Param")
         } else {
             name
         }
@@ -377,7 +314,7 @@ pub trait RustGenerator<'a> {
             .unwrap()
             .to_upper_camel_case();
         if self.uses_two_names(&info) {
-            format!("{}Result", name)
+            format!("{name}Result")
         } else {
             name
         }
diff --git a/crates/wit-bindgen/src/types.rs b/crates/wit-bindgen/src/types.rs
index 208b2f865850..c45d3d80f159 100644
--- a/crates/wit-bindgen/src/types.rs
+++ b/crates/wit-bindgen/src/types.rs
@@ -40,6 +40,14 @@ impl std::ops::BitOrAssign for TypeInfo {
 
 impl Types {
     pub fn analyze(&mut self, resolve: &Resolve, world: WorldId) {
+        // Build up all type information first which is inherited through types,
+        // such as properties of borrows/lists/etc.
+        for (t, _) in resolve.types.iter() {
+            self.type_id_info(resolve, t);
+        }
+
+        // ... next handle borrowed/owned flags which aren't inherited through
+        // types.
         let world = &resolve.worlds[world];
         for (import, (_, item)) in world
             .imports
@@ -49,7 +57,7 @@ impl Types {
         {
             match item {
                 WorldItem::Function(f) => self.type_info_func(resolve, f, import),
-                WorldItem::Interface(id) => {
+                WorldItem::Interface { id, .. } => {
                     let iface = &resolve.interfaces[*id];
 
                     for (_, t) in iface.types.iter() {
diff --git a/crates/wmemcheck/Cargo.toml b/crates/wmemcheck/Cargo.toml
index af62cc4541cb..ee4ff45a30fa 100644
--- a/crates/wmemcheck/Cargo.toml
+++ b/crates/wmemcheck/Cargo.toml
@@ -7,5 +7,7 @@ license = "Apache-2.0 WITH LLVM-exception"
 repository = "https://github.com/bytecodealliance/wasmtime"
 documentation = "https://docs.rs/wasmtime-cranelift/"
 edition.workspace = true
+rust-version.workspace = true
 
-[dependencies]
+[lints]
+workspace = true
diff --git a/deny.toml b/deny.toml
index 026b19a2c8d9..1ecdf0cbea06 100644
--- a/deny.toml
+++ b/deny.toml
@@ -59,4 +59,10 @@ skip-tree = [
     # They want to publish version 2.0 to upgrade `hashbrown` so in the meantime
     # it is duplicated for us.
     { name = "indexmap", depth = 2 },
+
+    # criterion is on old version, will update on next release.
+    { name = "itertools" },
+
+    # right now terminal_size pulls in an older version of io-lifetimes
+    { name = "io-lifetimes" },
 ]
diff --git a/docs/SUMMARY.md b/docs/SUMMARY.md
index c9cb56991e01..d6ce4a5d9530 100644
--- a/docs/SUMMARY.md
+++ b/docs/SUMMARY.md
@@ -1,16 +1,13 @@
 # Summary
 
 - [Introduction](./introduction.md)
-- [Examples](./examples.md)
-  - [Debugging WebAssembly](./examples-debugging.md)
-    - [Debugging with `gdb` and `lldb`](./examples-debugging-native-debugger.md)
-    - [Debugging with Core Dumps](./examples-debugging-core-dumps.md)
-  - [Profiling WebAssembly](./examples-profiling.md)
-    - [Profiling with Perf](./examples-profiling-perf.md)
-    - [Profiling with VTune](./examples-profiling-vtune.md)
-    - [Profiling with samply](./examples-profiling-samply.md)
-    - [Cross-platform Profiling](./examples-profiling-guest.md)
-  - [Embedding in Rust](./examples-rust-embed.md)
+- [Using the Wasmtime CLI](./cli.md)
+  - [Installation](./cli-install.md)
+  - [CLI Options](./cli-options.md)
+  - [CLI Logging](./cli-logging.md)
+  - [Cache Configuration](./cli-cache.md)
+- [Using the Wasmtime API](./lang.md)
+  - [Rust](./lang-rust.md)
     - [Hello, world!](./examples-rust-hello-world.md)
     - [Calculating the GCD](./examples-rust-gcd.md)
     - [Using Linear Memory](./examples-rust-memory.md)
@@ -19,7 +16,7 @@
     - [Debugging](./examples-rust-debugging.md)
     - [Core Dumps](./examples-rust-core-dumps.md)
     - [Using Multi-Value](./examples-rust-multi-value.md)
-  - [Embedding in C](./examples-c-embed.md)
+  - [C](./lang-c.md)
     - [Hello, World!](./examples-c-hello-world.md)
     - [Calculating the GCD](./examples-c-gcd.md)
     - [Using Linear Memory](./examples-c-memory.md)
@@ -27,32 +24,37 @@
     - [Linking Modules](./examples-c-linking.md)
     - [Debugging](./examples-c-debugging.md)
     - [Using Multi-Value](./examples-c-multi-value.md)
-  - [Checking Guests' Memory Accesses](./wmemcheck.md)
-- [Using WebAssembly from your language](./lang.md)
-  - [Rust](./lang-rust.md)
-  - [C](./lang-c.md)
   - [Python](./lang-python.md)
   - [.NET](./lang-dotnet.md)
   - [Go](./lang-go.md)
   - [Bash](./lang-bash.md)
   - [Ruby](./lang-ruby.md)
-- [Using the `wasmtime` CLI](./cli.md)
-  - [Installation](./cli-install.md)
-  - [CLI Options](./cli-options.md)
-  - [CLI Logging](./cli-logging.md)
-  - [Cache Configuration](./cli-cache.md)
+  - [Elixir](./lang-elixir.md)
+- [Further Examples](./examples.md)
+  - [Debugging WebAssembly](./examples-debugging.md)
+    - [Debugging with `gdb` and `lldb`](./examples-debugging-native-debugger.md)
+    - [Debugging with Core Dumps](./examples-debugging-core-dumps.md)
+  - [Profiling WebAssembly](./examples-profiling.md)
+    - [Profiling with Perf](./examples-profiling-perf.md)
+    - [Profiling with VTune](./examples-profiling-vtune.md)
+    - [Profiling with samply](./examples-profiling-samply.md)
+    - [Cross-platform Profiling](./examples-profiling-guest.md)
+  - [Checking Guests' Memory Accesses](./wmemcheck.md)
+  - [Building a minimal embedding](./examples-minimal.md)
 - [Stability](stability.md)
   - [Release Process](./stability-release.md)
   - [Tiers of support](./stability-tiers.md)
   - [Platform Support](./stability-platform-support.md)
 - [Security](security.md)
   - [Disclosure Policy](./security-disclosure.md)
+  - [What is considered a security bug?](./security-what-is-considered-a-security-vulnerability.md)
 - [Contributing](contributing.md)
   - [Architecture](./contributing-architecture.md)
   - [Building](./contributing-building.md)
   - [Testing](./contributing-testing.md)
   - [Fuzzing](./contributing-fuzzing.md)
   - [CI](./contributing-ci.md)
+  - [Reducing Test Cases](./contributing-reducing-test-cases.md)
   - [Cross Compiling](./contributing-cross-compiling.md)
   - [Coding Guidelines](./contributing-coding-guidelines.md)
   - [Development Process](./contributing-development-process.md)
diff --git a/docs/WASI-intro.md b/docs/WASI-intro.md
index 187f3003c44e..76984c8d4a50 100644
--- a/docs/WASI-intro.md
+++ b/docs/WASI-intro.md
@@ -27,12 +27,12 @@ toolchains will be able to implement WASI as well!
 ### Rust
 
 To install a WASI-enabled Rust toolchain, see the [online section of the
-guide](https://bytecodealliance.github.io/wasmtime/wasm-rust.html)
+guide](https://bytecodealliance.github.io/wasmtime/examples-rust-embed.html)
 
 ### C/C++
 
 To install a WASI-enabled C/C++ toolchain, see the [online section of the
-guide](https://bytecodealliance.github.io/wasmtime/wasm-c.html)
+guide](https://bytecodealliance.github.io/wasmtime/lang-c.html)
 
 ## How can I run programs that use WASI?
 
@@ -40,7 +40,7 @@ Currently the options are [Wasmtime] and the [browser polyfill], though we
 intend WASI to be implementable in many wasm VMs.
 
 [Wasmtime]: https://github.com/bytecodealliance/wasmtime
-[browser polyfill]: https://wasi.dev/polyfill/
+[browser polyfill]: https://github.com/bjorn3/browser_wasi_shim
 
 ### Wasmtime
 
@@ -52,9 +52,7 @@ or `cargo run --bin wasmtime foo.wasm`.
 
 ### The browser polyfill
 
-The polyfill is online [here](https://wasi.dev/polyfill/).
-
-The source is [here](https://github.com/bytecodealliance/wasmtime/tree/main/crates/wasi-c/js-polyfill).
+The source is [here](https://github.com/bjorn3/browser_wasi_shim).
 
 ## Where can I learn more?
 
diff --git a/docs/WASI-overview.md b/docs/WASI-overview.md
index 46952f82733b..8c3f465aa6fb 100644
--- a/docs/WASI-overview.md
+++ b/docs/WASI-overview.md
@@ -24,7 +24,7 @@ still can run in browsers; see below).
 ## Capability-Oriented
 
 The design follows
-[CloudABI](https://cloudabi.org/)'s
+[CloudABI](https://github.com/NuxiNL/cloudlibc)'s
 (and in turn
 [Capsicum](https://www.cl.cam.ac.uk/research/security/capsicum/))'s concept of
 [capability-based security](https://en.wikipedia.org/wiki/Capability-based_security),
diff --git a/docs/WASI-tutorial.md b/docs/WASI-tutorial.md
index e1e83faebbc7..6e9e7a22717c 100644
--- a/docs/WASI-tutorial.md
+++ b/docs/WASI-tutorial.md
@@ -10,11 +10,11 @@ this using the `wasmtime` runtime.
     - [Compiling to WASI](#compiling-to-wasi)
         - [From C](#from-c)
         - [From Rust](#from-rust)
-    - [Executing in `wasmtime` runtime](#executing-in-wasmtime-runtime)
+    - [Executing in Wasmtime](#executing-in-wasmtime)
   - [Web assembly text example](#web-assembly-text-example)
 
 ## Running common languages with WASI
-## Compiling to WASI
+### Compiling to WASI
 #### From C
 Let's start with a simple C program which performs a file copy, which will
 show to compile and run programs, as well as perform simple sandbox
@@ -154,18 +154,18 @@ Let's put this source in the main file of our crate `src/main.rs`.
 In order to build it, we first need to install a WASI-enabled Rust toolchain:
 
 ```
-$ rustup target add wasm32-wasi
-$ cargo build --target wasm32-wasi
+$ rustup target add wasm32-wasip1
+$ cargo build --target wasm32-wasip1
 ```
 
-We should now have the WebAssembly module created in `target/wasm32-wasi/debug`:
+We should now have the WebAssembly module created in `target/wasm32-wasip1/debug`:
 
 ```
-$ file target/wasm32-wasi/debug/demo.wasm
+$ file target/wasm32-wasip1/debug/demo.wasm
 demo.wasm: WebAssembly (wasm) binary module version 0x1 (MVP)
 ```
 
-## Executing in `wasmtime` runtime
+### Executing in Wasmtime
 The resultant WebAssembly module `demo.wasm` compiled either from C or Rust is simply
 a single file containing a self-contained wasm module, that doesn't require
 any supporting JS code.
@@ -240,7 +240,7 @@ links as well.
 `wasmtime` also has the ability to remap directories:
 
 ```
-$ wasmtime --dir=. --dir=/tmp::/var/tmp demo.wasm test.txt /tmp/somewhere.txt
+$ wasmtime --dir=. --dir=/var/tmp::/tmp demo.wasm test.txt /tmp/somewhere.txt
 $ cat /var/tmp/somewhere.txt
 hello world
 ```
@@ -269,8 +269,8 @@ First, create a new `demo.wat` file:
 (module
     ;; Import the required fd_write WASI function which will write the given io vectors to stdout
     ;; The function signature for fd_write is:
-    ;; (File Descriptor, *iovs, iovs_len, nwritten) -> Returns number of bytes written
-    (import "wasi_unstable" "fd_write" (func $fd_write (param i32 i32 i32 i32) (result i32)))
+    ;; (File Descriptor, *iovs, iovs_len, *nwritten) -> Returns 0 on success, nonzero on error
+    (import "wasi_snapshot_preview1" "fd_write" (func $fd_write (param i32 i32 i32 i32) (result i32)))
 
     (memory 1)
     (export "memory" (memory 0))
diff --git a/docs/cli-install.md b/docs/cli-install.md
index 510170e33974..ffd370f624a2 100644
--- a/docs/cli-install.md
+++ b/docs/cli-install.md
@@ -2,7 +2,7 @@
 
 Here we'll show you how to install the `wasmtime` command line tool. Note that
 this is distinct from embedding the Wasmtime project into another, for that
-you'll want to consult the [embedding documentation](embed.md).
+you'll want to consult the [embedding documentation](lang.md).
 
 The easiest way to install the `wasmtime` CLI tool is through our installation
 script. Linux and macOS users can execute the following:
@@ -11,7 +11,7 @@ script. Linux and macOS users can execute the following:
 $ curl https://wasmtime.dev/install.sh -sSf | bash
 ```
 
-This will download a precompiled version of `wasmtime` and place it in
+This will download a precompiled version of `wasmtime`, place it in
 `$HOME/.wasmtime`, and update your shell configuration to place the right
 directory in `PATH`.
 
diff --git a/docs/cli-logging.md b/docs/cli-logging.md
index b05d2d29e9e4..7d0b1ba0c575 100644
--- a/docs/cli-logging.md
+++ b/docs/cli-logging.md
@@ -1,21 +1,22 @@
 # Logging in the `wasmtime` CLI
 
 Wasmtime's libraries use Rust's [`log`] crate to log diagnostic
-information, and the `wasmtime` CLI executable uses [`pretty_env_logger`]
-by default for logging this information to the console.
+information, and the `wasmtime` CLI executable uses [`tracing-subscriber`]
+for displaying this information on the console.
 
-Basic logging is controlled by the `RUST_LOG` environment variable. For example,
+Basic logging is controlled by the `WASMTIME_LOG` environment variable. For example,
 To enable logging of WASI system calls, similar to the `strace` command on Linux,
-set `RUST_LOG=wasi_common=trace`.
+set `WASMTIME_LOG=wasmtime_wasi=trace`. For more information on specifying
+filters, see [tracing-subscriber's EnvFilter docs].
 
 ```sh
-$ RUST_LOG=wasi_common=trace wasmtime hello.wasm
+$ WASMTIME_LOG=wasmtime_wasi=trace wasmtime hello.wasm
 [...]
- TRACE wasi_common::hostcalls_impl::fs                       > fd_write(fd=1, iovs_ptr=0x10408, iovs_len=1, nwritten=0x10404)
+TRACE wiggle abi{module="wasi_snapshot_preview1" function="fd_write"} wasmtime_wasi::preview1::wasi_snapshot_preview1                     > fd=Fd(1) iovs=*guest 0x14/1
 Hello, world!
- TRACE wasi_common::hostcalls_impl::fs                       >      | *nwritten=14
- TRACE wasi_common::hostcalls                                >      | errno=ESUCCESS (No error occurred. System call completed successfully.)
- TRACE wasi_common::hostcalls_impl::misc                     > proc_exit(rval=1)
+TRACE wiggle abi{module="wasi_snapshot_preview1" function="fd_write"}: wasmtime_wasi::preview1::wasi_snapshot_preview1: result=Ok(14)
+TRACE wiggle abi{module="wasi_snapshot_preview1" function="proc_exit"}: wasmtime_wasi::preview1::wasi_snapshot_preview1: rval=1
+TRACE wiggle abi{module="wasi_snapshot_preview1" function="proc_exit"}: wasmtime_wasi::preview1::wasi_snapshot_preview1: result=Exited with i32 exit status 1
 ```
 
 Wasmtime can also redirect the log messages into log files, with the
@@ -23,4 +24,5 @@ Wasmtime can also redirect the log messages into log files, with the
 the files named `wasmtime.dbg.*`.
 
 [`log`]: https://crates.io/crates/log
-[`pretty_env_logger`]: https://crates.io/crates/pretty_env_logger
+[`tracing-subscriber`]: https://crates.io/crates/tracing-subscriber
+[tracing-subscriber's EnvFilter docs]: https://docs.rs/tracing-subscriber/latest/tracing_subscriber/filter/struct.EnvFilter.html#directives
diff --git a/docs/cli-options.md b/docs/cli-options.md
index d6ffe74adcc9..6cf53438012b 100644
--- a/docs/cli-options.md
+++ b/docs/cli-options.md
@@ -52,6 +52,29 @@ an exported function of the module to run.
 $ wasmtime run foo.wasm --invoke initialize
 ```
 
+## `serve`
+
+The `serve` subcommand runs a WebAssembly component in the `wasi:http/proxy`
+world via the WASI HTTP API, which is available since Wasmtime 18.0.0. The goal
+of this world is to support sending and receiving HTTP requests.
+
+The `serve` command takes one positional argument which is the name of the
+component to run:
+
+```sh
+$ wasmtime serve foo.wasm
+```
+
+Furthermore, an address can be specified via:
+
+```sh
+$ wasmtime serve --addr=0.0.0.0:8081 foo.wasm
+```
+
+At the time of writing, the `wasi:http/proxy` world is still experimental and
+requires setup of some `wit` dependencies. For more information, see
+the [hello-wasi-http](https://github.com/sunfishcode/hello-wasi-http/) example.
+
 ## `wast`
 
 The `wast` command executes a `*.wast` file which is the test format for the
diff --git a/docs/contributing-architecture.md b/docs/contributing-architecture.md
index fc7ff3033970..a2d6bc288934 100644
--- a/docs/contributing-architecture.md
+++ b/docs/contributing-architecture.md
@@ -47,7 +47,7 @@ their implications in Wasmtime:
   involves acquiring a lock, whereas for `Store` below no locks are necessary.
 
 * `wasmtime::Store` - this is the concept of a "store" in WebAssembly. While
-  there's also a formal definition to go of this it can be thought of as a bag
+  there's also a formal definition to go off of, it can be thought of as a bag
   of related WebAssembly objects. This includes instances, globals, memories,
   tables, etc. A `Store` does not implement any form of garbage collection of
   the internal items (there is a `gc` function but that's just for `externref`
@@ -63,9 +63,9 @@ their implications in Wasmtime:
   other. A `Store` cannot be used simultaneously from multiple threads (almost
   all operations require `&mut self`).
 
-* `wasmtime_runtime::InstanceHandle` - this is the low-level representation of a
+* `wasmtime::runtime::vm::InstanceHandle` - this is the low-level representation of a
   WebAssembly instance. At the same time this is also used as the representation
-  for all host-defined object. For example if you call `wasmtime::Memory::new`
+  for all host-defined objects. For example if you call `wasmtime::Memory::new`
   it'll create an `InstanceHandle` under the hood. This is a very `unsafe` type
   that should probably have all of its functions marked `unsafe` or otherwise
   have more strict guarantees documented about it, but it's an internal type
@@ -82,13 +82,13 @@ their implications in Wasmtime:
   `wasmtime::Table::new`), but for an instantiated WebAssembly module these
   fields will have more information. After an `InstanceHandle` in memory is a
   `VMContext`, which will be discussed next. `InstanceHandle` values are the
-  main internal runtime representation and what the `wasmtime_runtime` crate
+  main internal runtime representation and what the `crate::runtime::vm` code
   works with. The `wasmtime::Store` holds onto all these `InstanceHandle` values
   and deallocates them at the appropriate time. From the runtime perspective it
   simplifies things so the graph of wasm modules communicating to each other is
   reduced to simply `InstanceHandle` values all talking to themselves.
 
-* `wasmtime_runtime::VMContext` - this is a raw pointer, within an allocation of
+* `crate::runtime::vm::VMContext` - this is a raw pointer, within an allocation of
   an `InstanceHandle`, that is passed around in JIT code. A `VMContext` does not
   have a structure defined in Rust (it's a 0-sized structure) because its
   contents are dynamically determined based on the `VMOffsets`, or the source
@@ -111,7 +111,7 @@ their implications in Wasmtime:
     stack overflow.
   * Hold a pointer to a `VMExternRefActivationsTable` for fast-path insertion of
     `externref` values into the table.
-  * Hold a pointer to a `*mut dyn wasmtime_runtime::Store` so store-level
+  * Hold a pointer to a `*mut dyn crate::runtime::vm::Store` so store-level
     operations can be performed in libcalls.
 
   A comment about the layout of a `VMContext` can be found in the `vmoffsets.rs`
@@ -180,7 +180,7 @@ Compilation is roughly broken down into a few phases:
    point the module is ready to be instantiated.
 
 A `wasmtime::Module` is an atomically-reference-counted object where upon
-instantiation into a `Store` the `Store` will hold a strong reference to the
+instantiation into a `Store`, the `Store` will hold a strong reference to the
 internals of the module. This means that all instances of a `wasmtime::Module`
 share the same compiled code. Additionally a `wasmtime::Module` is one of the
 few objects that lives outside of a `wasmtime::Store`. This means that
@@ -268,11 +268,11 @@ The rough flow of instantiation looks like:
    completed before instantiation is finished. For MVP wasm this only involves
    loading the import into the correct index array, but for module linking this
    could involve instantiating other modules, handling `alias` fields, etc. In
-   any case the result of this step is a `wasmtime_runtime::Imports` array which
-   has the values for all imported items into the wasm module. Note that in
-   this case an import is typically some sort of raw pointer to the actual
-   state plus the `VMContext` of the instance that was imported from. The
-   final result of this step is an `InstanceAllocationRequest`, which is then
+   any case the result of this step is a `crate::runtime::vm::Imports` array
+   which has the values for all imported items into the wasm module. Note that
+   in this case an import is typically some sort of raw pointer to the actual
+   state plus the `VMContext` of the instance that was imported from. The final
+   result of this step is an `InstanceAllocationRequest`, which is then
    submitted to the configured instance allocator, either on-demand or pooling.
 
 3. The `InstanceHandle` corresponding to this instance is allocated. How this
@@ -315,11 +315,11 @@ traps.
 Wasmtime today implements traps with `longjmp` and `setjmp`. The `setjmp`
 function cannot be defined in Rust (even unsafely --
 (https://github.com/rust-lang/rfcs/issues/2625) so the
-`crates/runtime/src/helpers.c` file actually calls setjmp/longjmp. Note that in
-general the operation of `longjmp` is not safe to execute in Rust because it
-skips stack-based destructors, so after `setjmp` when we call back into Rust to
-execute wasm we need to be careful in Wasmtime to not have any significant
-destructors on the stack once wasm is called.
+`crates/wasmtime/src/runtime/vm/helpers.c` file actually calls
+setjmp/longjmp. Note that in general the operation of `longjmp` is not safe to
+execute in Rust because it skips stack-based destructors, so after `setjmp` when
+we call back into Rust to execute wasm we need to be careful in Wasmtime to not
+have any significant destructors on the stack once wasm is called.
 
 Traps can happen from a few different sources:
 
@@ -457,14 +457,9 @@ values that are actively in use on the stack.
 The main Wasmtime internal crates are:
 
 * `wasmtime` - the safe public API of `wasmtime`.
-* `wasmtime-jit` - JIT-specific support for Wasmtime. This is the concrete
-  implementation that manages executable memory generated at Runtime. Currently
-  all modules are compiled this way, but one day Wasmtime may be able to be
-  compiled without JIT support where only precompiled modules can be loaded.
-* `wasmtime-runtime` - low-level runtime implementation of Wasmtime. This
-  is where `VMContext` and `InstanceHandle` live. This crate is theoretically
-  agnostic to how JIT code was compiled and the runtime that it's running
-  within.
+  * `wasmtime::runtime::vm` - low-level runtime implementation of Wasmtime. This
+    is where `VMContext` and `InstanceHandle` live. This module used to be a
+    crate, but has since been folding into `wasmtime`.
 * `wasmtime-environ` - low-level compilation support. This is where translation
   of the `Module` and its environment happens, although no compilation actually
   happens in this crate (although it defines an interface for compilers). The
diff --git a/docs/contributing-building.md b/docs/contributing-building.md
index fcbb281c8964..9387d2b566ea 100644
--- a/docs/contributing-building.md
+++ b/docs/contributing-building.md
@@ -54,31 +54,24 @@ with `cargo run`.
 
 ## Building the Wasmtime C API
 
-To build the C API of Wasmtime you can run:
-
-```shell
-cargo build --release --manifest-path crates/c-api/Cargo.toml
-```
-
-This will place the shared library inside of `target/release`. On Linux it will
-be called `libwasmtime.{a,so}`, on macOS it will be called
-`libwasmtime.{a,dylib}`, and on Windows it will be called
-`wasmtime.{lib,dll,dll.lib}`.
+See
+[`crates/c-api/README.md`](https://github.com/bytecodealliance/wasmtime/blob/main/crates/c-api/README.md)
+for details.
 
 ## Building Other Wasmtime Crates
 
 You can build any of the Wasmtime crates by appending `-p wasmtime-whatever` to
-the `cargo build` invocation. For example, to build the `wasmtime-jit` crate,
+the `cargo build` invocation. For example, to build the `wasmtime-environ` crate,
 execute this command:
 
 ```shell
-cargo build -p wasmtime-jit
+cargo build -p wasmtime-environ
 ```
 
 Alternatively, you can `cd` into the crate's directory, and run `cargo build`
 there, without needing to supply the `-p` flag:
 
 ```shell
-cd crates/jit/
+cd crates/environ/
 cargo build
 ```
diff --git a/docs/contributing-ci.md b/docs/contributing-ci.md
index 5b7306f66160..fc69f243b0fd 100644
--- a/docs/contributing-ci.md
+++ b/docs/contributing-ci.md
@@ -13,14 +13,32 @@ directory][dir] of the repository.
 
 ## PRs and CI
 
-Currently the full CI test suite runs on every Pull Request. All PRs need to
-have that lovely green checkmark before being candidates for being merged. If a
-test is failing you'll want to check out the logs on CI and fix it before the PR
-can be merged.
+Currently on sample of the full CI test suite is run on every Pull Request. CI
+on PRs is intended to be relatively quick and catch the majority of mistakes and
+errors. By default the test suite is run on x86\_64 Linux but this may change
+depending on what files the PR is modifying. The intention is to run "mostly
+relevant" CI on a PR by default.
 
 PR authors are expected to fix CI failures in their PR, unless the CI failure is
 systemic and unrelated to the PR. In that case other maintainers should be
-alerted to ensure that the problem can be addressed.
+alerted to ensure that the problem can be addressed. Some reviewers may also
+wait to perform a review until CI is green on the PR as otherwise it may
+indicate changes are needed.
+
+The Wasmtime repository uses GitHub's Merge Queue feature to merge PRs which.
+Entry in to the merge queue requires green CI on the PR beforehand. Maintainers
+who have approved a PR will flag it for entry into the merge queue, and the PR
+will automatically enter the merge queue once CI is green.
+
+When entering the merge queue a PR will have the full test suite executed which
+may include tests that weren't previously run on the PR. This may surface new
+failures, and contributors are expected to fix these failures as well.
+
+To force PRs to execute the full test suite, which takes longer than the default
+test suite for PRs, then contributors can place the string "prtest:full"
+somewhere in any commit of the PR. From that point on the PR will automatically
+run the full test suite as-if it were in the merge queue. Note that when going
+through the merge queue this will rerun tests.
 
 ## Tests run on CI
 
@@ -64,22 +82,23 @@ documentation of Wasmtime and Cranelift. Currently this consists of:
   Linux build in a really old CentOS container to have a very low glibc
   requirement.
 
-* Tarballs of the Python extension - also produced on the main three platforms
-  these wheels are compiled on each commit.
+* Tarballs of the Wasmtime C API - produced for the same set of platforms as the
+  CLI above.
 
 * Book and API documentation - the book is rendered with `mdbook` and we also
   build all documentation with `cargo doc`.
 
-Artifacts are produced for every single commit and every single PR. You should
-be able to find a downloadable version of all artifacts produced on the "runs"
-page in GitHub Actions. For example [here's an example
-job](https://github.com/bytecodealliance/wasmtime/actions/runs/50372673), and if
-you're looking at [a specific
-builder](https://github.com/bytecodealliance/wasmtime/runs/488719677?check_suite_focus=true)
-you can see the artifacts link in the top right. Note that artifacts don't
-become available until the whole run finishes.
-
-Commits merged into the `main` branch will rerun CI and will also produce
-artifacts as usual. On the `main` branch, however, documentation is pushed to
-the `gh-pages` branch as well, and binaries are pushed to the `dev` release on
-GitHub. Finally, tagged commits get a whole dedicated release to them too.
+* A source code tarball which is entirely self-contained. This source tarball
+  has all dependencies vendored so the network is not needed to build it.
+
+* WebAssembly adapters for the component model to translate
+  `wasi_snapshot_preview1` to WASI Preview 2.
+
+Artifacts are produced as part of the full CI suite. This means that artifacts
+are not produced on a PR by default but can be requested via "prtest:full". All
+runs through the merge queue though, which means all merges to `main`, will
+produce a full suite of artifacts. The latest artifacts are available through
+Wasmtime's [`dev` release][dev] and downloads are also available for recent CI
+runs through the CI page in GitHub Actions.
+
+[dev]: https://github.com/bytecodealliance/wasmtime/releases/tag/dev
diff --git a/docs/contributing-coding-guidelines.md b/docs/contributing-coding-guidelines.md
index 40d4f0543044..b29ba01b6324 100644
--- a/docs/contributing-coding-guidelines.md
+++ b/docs/contributing-coding-guidelines.md
@@ -33,4 +33,127 @@ periodically and the general repository does not depend on nightly features.
 Updating Wasmtime's MSRV is done by editing the `rust-version` field in the
 workspace root's `Cargo.toml`
 
-[Rust Update Policy for Firefox]: https://wiki.mozilla.org/Rust_Update_Policy_for_Firefox#Schedule
+### Dependencies of Wasmtime
+
+Wasmtime and Cranelift have a higher threshold than default for adding
+dependencies to the project. All dependencies are required to be "vetted"
+through the [`cargo vet` tool](https://mozilla.github.io/cargo-vet/). This is
+checked on CI and will run on all modifications to `Cargo.lock`.
+
+A "vet" for Wasmtime is not a meticulous code review of a dependency for
+correctness but rather it is a statement that the crate does not contain
+malicious code and is safe for us to run during development and (optionally)
+users to run when they run Wasmtime themselves. Wasmtime's vet entries are used
+by other organizations which means that this isn't simply for our own personal
+use. Wasmtime additionally uses vet entries from other organizations as well
+which means we don't have to vet everything ourselves.
+
+New vet entries are required to be made by trusted contributors to Wasmtime.
+This is all configured in the `supply-chain` folder of Wasmtime. These files
+generally aren't hand-edited though and are instead managed through the `cargo
+vet` tool itself. Note that our `supply-chain/audits.toml` additionally contains
+entries which indicates that authors are trusted as opposed to vets of
+individual crates. This lowers the burden of updating version of a crate from a
+trusted author.
+
+When put together this means that contributions to Wasmtime and Cranelift which
+update existing dependencies or add new dependencies will not be mergeable by
+default (CI will fail). This is expected from our project's configuration and
+this situation will be handled one of a few ways:
+
+Note that this process is not in place to prevent new dependencies or prevent
+updates, but rather it ensures that development of Wasmtime is done with a
+trusted set of code that has been reviewed by trusted parties. We welcome
+dependency updates and new functionality, so please don't be too alarmed when
+contributing and seeing a failure of `cargo vet` on CI!
+
+### `cargo vet` for Contributors
+
+If you're a contributor to Wasmtime and you've landed on this documentation,
+hello and thanks for your contribution! Here's some guidelines for changing the
+set of dependencies in Wasmtime:
+
+* If a new dependency is being added it might be worth trying to slim down
+  what's required or avoiding the dependency altogether. Avoiding new
+  dependencies is best when reasonable, but it is not always reasonable to do
+  so. This is left to the judgement of the author and reviewer.
+
+* When updating dependencies this should be done for a specific purpose relevant
+  to the PR-at-hand. For example if the PR implements a new feature then the
+  dependency update should be required for the new feature. Otherwise it's best
+  to leave dependency updates to their own PRs. It's ok to update dependencies
+  "just for the update" but we prefer to have that as separate PRs.
+
+Dependency additions or updates require action on behalf of project maintainers
+so we ask that you don't run `cargo vet` yourself or update the `supply-chain`
+folder yourself. Instead a maintainer will review your PR and perform the `cargo
+vet` entries themselves. Reviewers will typically make a separate pull request
+to add `cargo vet` entries and once that lands yours will be added to the queue.
+
+### `cargo vet` for Maintainers
+
+Maintainers of Wasmtime are required to explicitly vet and approve all
+dependency updates and modifications to Wasmtime. This means that when reviewing
+a PR you should ensure that contributors are not modifying the `supply-chain`
+directory themselves outside of commits authored by other maintainers. Otherwise
+though to add vet entries this is done through one of a few methods:
+
+* For a PR where maintainers themselves are modifying dependencies the `cargo
+  vet` entries can be included inline with the PR itself by the author. The
+  reviewer knows that the author of the PR is themself a maintainer.
+
+* PRs that "just update dependencies" are ok to have at any time. You can do
+  this in preparation for a future feature or for a future contributor. This
+  more-or-less is the same as the previous categories.
+
+* For contributors who should not add vet entries themselves maintainers should
+  review the PR and add vet entries either in a separate PR or as part of the
+  contributor's PR itself. As a separate PR you'll check out the branch, run
+  `cargo vet`, then rebase away the contributor's commits and push your `cargo
+  vet` commit alone to merge. For pushing directly to the contributor's own PR
+  be sure to read the notes below.
+
+Note for the last case it's important to ensure that if you push directly to a
+contributor's PR any future updates pushed by the contributor either contain or
+don't overwrite your vet entries. Also verify that if the PR branch is rebased
+or force-pushed, the details of your previously pushed vetting remain the same:
+e.g., versions were not bumped and descriptive reasons remain the same. If
+pushing a vetting commit to a contributor's PR and also asking for more changes,
+request that the contributor make the requested fixes in an additional commit
+rather than force-pushing a rewritten history, so your existing vetting commit
+remains untouched. These guidelines make it easier to verify no tampering has
+occurred.
+
+### Policy for adding `cargo vet` entries
+
+For maintainers this is intended to document the project's policy on adding
+`cargo vet` entries. The goal of this policy is to not make dependency updates
+so onerous that they never happen while still achieving much of the intended
+benefit of `cargo vet` in protection against supply-chain style attacks.
+
+* For dependencies **that receive at least 10,000 downloads a day** on crates.io
+  it's ok to add an entry to `exemptions` in `supply-chain/config.toml`. This
+  does not require careful review or review at all of these dependencies. The
+  assumption here is that a supply chain attack against a popular crate is
+  statistically likely to be discovered relatively quickly. Changes to `main` in
+  Wasmtime take at least 2 weeks to be released due to our release process, so
+  the assumption is that popular crates that are victim of a supply chain attack
+  would be discovered during this time. This policy additionally greatly helps
+  when updating dependencies on popular crates that are common to see without
+  increasing the burden too much on maintainers.
+
+* For other dependencies a manual vet is required. The `cargo vet` tool will
+  assist in adding a vet by pointing you towards the source code, as published
+  on crates.io, to be browsed online. Manual review should be done to ensure
+  that "nothing nefarious" is happening. For example `unsafe` should be
+  inspected as well as use of ambient system capabilities such as `std::fs`,
+  `std::net`, or `std::process`, and build scripts. Note that you're not
+  reviewing for correctness, instead only for whether a supply-chain attack
+  appears to be present.
+
+This policy intends to strike a rough balance between usability and security.
+It's always recommended to add vet entries where possible, but the first bullet
+above can be used to update an `exemptions` entry or add a new entry. Note that
+when the "popular threshold" is used **do not add a vet entry** because the
+crate is, in fact, not vetted. This is required to go through an
+`[[exemptions]]` entry.
diff --git a/docs/contributing-implementing-wasm-proposals.md b/docs/contributing-implementing-wasm-proposals.md
index ce42e7e8fbb1..5de4590f90d9 100644
--- a/docs/contributing-implementing-wasm-proposals.md
+++ b/docs/contributing-implementing-wasm-proposals.md
@@ -124,3 +124,31 @@ default in Wasmtime, and can be used as a review checklist.
 
 [phases]: https://github.com/WebAssembly/meetings/blob/master/process/phases.md
 [WABT]: https://github.com/WebAssembly/wabt/
+
+## Adding component functionality to WASI
+The [cap-std](https://github.com/bytecodealliance/cap-std) repository contains
+crates which implement the capability-based version of the Rust standard library
+and extensions to that functionality. Once the functionality has been added to
+the relevant crates of that repository, they can be added into wasmtime by
+including them in the preview2 directory of the [wasi crate](https://github.com/bytecodealliance/wasmtime/tree/main/crates/wasi).
+
+Currently, WebAssembly modules which rely on preview2 ABI cannot be directly
+executed by the wasmtime command. The following steps allow for testing such
+changes.
+
+1. Build wasmtime with the changes `cargo build --release`
+
+2. Create a simple Webassembly module to test the new component functionality by
+compiling your test code to the `wasm32-wasip1` build target.
+
+3. Build the [wasi-preview1-component-adapter](https://github.com/bytecodealliance/wasmtime/tree/main/crates/wasi-preview1-component-adapter)
+as a command adapter. `cargo build -p wasi-preview1-component-adapter --target
+wasm32-wasip1 --release --features command --no-default-features`
+
+4. Use [wasm-tools](https://github.com/bytecodealliance/wasm-tools) to convert
+the test module to a component. `wasm-tools component new --adapt
+wasi_snapshot_preview1=wasi_snapshot_preview1.command.wasm -o component.wasm
+path/to/test/module`
+
+5. Run the test component created in the previous step with the locally built
+wasmtime. `wasmtime -W component-model=y -S preview2=y component.wasm`
diff --git a/docs/contributing-reducing-test-cases.md b/docs/contributing-reducing-test-cases.md
new file mode 100644
index 000000000000..ce81b1be3596
--- /dev/null
+++ b/docs/contributing-reducing-test-cases.md
@@ -0,0 +1,110 @@
+# Reducing Test Cases
+
+When reporting a bug, or investing a bug report, in Wasmtime it is easier for
+everyone involved when there is a test case that reproduces the bug. It is even
+better when that test case is as small as possible, so that developers don't
+need to wade through megabytes of unrelated Wasm that isn't necessary to
+showcase the bug. The process of taking a large test case and stripping out the
+unnecessary bits is called *test case reduction*.
+
+[The `wasm-tools shrink` tool](github.com/bytecodealliance/wasm-tools) can
+automatically reduce Wasm test cases when given
+
+1. the original, unreduced test case, and
+2. a predicate script to determine whether the bug reproduces on a given reduced
+   test case candidate.
+
+If the test case causes Wasmtime to segfault, the script can run Wasmtime and
+check its exit code. If the test case produces a different result in Wasmtime vs
+another Wasm engine, the script can run both engines and compare their
+results. It is also often useful to `grep` through the candidate's WAT
+disassembly to make sure that relevant features and instructions are present.
+
+## Case Study: [Issue #7779](https://github.com/bytecodealliance/wasmtime/issues/7779)
+
+A bug was reported involving the `memory.init` instruction. The attached test
+case was larger than it needed to be and contained a bunch of functions and
+other things that were irrelevant. A perfect use case for `wasm-tools shrink`!
+
+First, we needed a predicate script to identify the reported buggy behavior. The
+script is given the candidate test case as its first argument and must exit zero
+if the candidate exhibits the bug and non-zero otherwise.
+
+```bash
+#!/usr/bin/env bash
+
+# Propagate failure: exit non-zero if any individual command exits non-zero.
+set -e
+
+# Disassembly the candidate into WAT. Make sure the `memory.init` instruction
+# is present, since the bug report is about that instruction. Additionally, make
+# sure it is referencing the same data segment.
+wasm-tools print $1 | grep -q 'memory.init 2'
+
+# Make sure that the data segment in question remains unchanged, as mutating its
+# length can change the semantics of the `memory.init` instruction.
+wasm-tools print $1 | grep -Eq '\(data \(;2;\) \(i32\.const 32\) "\\01\\02\\03\\04\\05\\06\\07\\08\\ff"\)'
+
+# Make sure that the `_start` function that contains the `memory.init` is still
+# exported, so that running the Wasm will run the `memory.init` instruction.
+wasm-tools print $1 | grep -Eq '\(export "_start" \(func 0\)\)'
+
+# Run the testcase in Wasmtime and make sure that it traps the same way as the
+# original test case.
+cargo run --manifest-path ~/wasmtime/Cargo.toml -- run $1 2>&1 \
+    | grep -q 'wasm trap: out of bounds memory access'
+```
+
+Note that this script is a little fuzzy! It just checks for `memory.init` and a
+particular trap. That trap can correctly occur according to Wasm semantics when
+`memory.init` is given certain inputs! This means we need to double check that
+the reduced test case actually exhibits a real bug and its inputs haven't been
+transformed into something that Wasm semantics specify should indeed
+trap. Sometimes writing very precise predicate scripts is difficult, but we do
+the best we can and usually it works out fine.
+
+With the predicate script in hand, we can automatically reduce the original test
+case:
+
+```shell-session
+$ wasm-tools shrink predicate.sh test-case.wasm
+369 bytes (1.07% smaller)
+359 bytes (3.75% smaller)
+357 bytes (4.29% smaller)
+354 bytes (5.09% smaller)
+344 bytes (7.77% smaller)
+...
+118 bytes (68.36% smaller)
+106 bytes (71.58% smaller)
+94 bytes (74.80% smaller)
+91 bytes (75.60% smaller)
+90 bytes (75.87% smaller)
+
+test-case.shrunken.wasm :: 90 bytes (75.87% smaller)
+================================================================================
+(module
+  (type (;0;) (func))
+  (func (;0;) (type 0)
+    (local i32 f32 i64 f64)
+    i32.const 0
+    i32.const 9
+    i32.const 0
+    memory.init 2
+  )
+  (memory (;0;) 1 5)
+  (export "_start" (func 0))
+  (data (;0;) (i32.const 8) "")
+  (data (;1;) (i32.const 16) "")
+  (data (;2;) (i32.const 32) "\01\02\03\04\05\06\07\08\ff")
+)
+================================================================================
+```
+
+In this case, the arguments to the original `memory.init` instruction haven't
+changed, and neither has the relevant data segment, so the reduced test case
+should exhibit the same behavior as the original.
+
+In the end, it was [determined that Wasmtime was behaving as
+expected](https://github.com/bytecodealliance/wasmtime/issues/7779#issuecomment-1894350625),
+but the presence of the reduced test case makes it much easier to make that
+determination.
diff --git a/docs/contributing-release-process.md b/docs/contributing-release-process.md
index b25d690567d1..123a891f114d 100644
--- a/docs/contributing-release-process.md
+++ b/docs/contributing-release-process.md
@@ -6,7 +6,7 @@ others might be curious in this as well!
 
 ## Releasing a major version
 
-Major versions of Wasmtime are relased once-a-month. Most of this is automatic
+Major versions of Wasmtime are released once-a-month. Most of this is automatic
 and all that needs to be done is to merge GitHub PRs that CI will
 generate. At a high-level the structure of Wasmtime's release process is:
 
@@ -42,34 +42,27 @@ automatic and this is documenting what automation does.
 3. **Time passes and the `release-X.Y.Z` branch is maintained**
    * All changes land on `main` first, then are backported to `release-X.Y.Z` as
      necessary.
-   * Even changes to `RELEASES.md` are pushed to `main` first.
 4. On the 20th of every month (same CI job as before) another CI job will run
    performing:
-   * Download the current `main` branch.
-   * Update the release date of `X.Y.Z` to today in `RELEASES.md`
-   * Open a PR against `main` for this change
    * Reset to `release-X.Y.Z`
    * Update the release date of `X.Y.Z` to today in `RELEASES.md`
    * Add a special marker to the commit message to indicate a tag should be made.
    * Open a PR against `release-X.Y.Z` for this change
    * This step can also be [triggered manually][ci-trigger] with the `main`
      branch and the `release-latest` argument.
-5. **A maintainer of Wasmtime merges these two PRs**
-   * The PR against `main` is a small update to the release notes and should be
-     mergeable immediately.
-   * The PR against `release-X.Y.Z`, when merged, will trigger the next steps due
+5. **A maintainer of Wasmtime merges this PR**
+   * When merged, will trigger the next steps due
      to the marker in the commit message. A maintainer should double-check there
      are [no open security issues][rustsec-issues], but otherwise it's expected
      that all other release issues are resolved by this point.
-6. The `.github/workflow/push-tag.yml` workflow is triggered on all commits
-   including the one just created with a PR merge. This workflow will:
-   * Scan the git logs of pushed changes for the special marker added by
-     `release-process.yml`.
-   * If found, tags the current `main` commit and pushes that to the main
-     repository.
-7. Once a tag is created CI runs in full on the tag itself. CI for tags will
-   create a GitHub release with release artifacts and it will also publish
-   crates to crates.io. This is orchestrated by `.github/workflows/main.yml`.
+6. The main CI workflow at `.github/workflow/main.yml` has special logic
+   at the end such that pushes to the `release-*` branch will scan the git logs
+   of pushed changes for the special marker added by `release-process.yml`. If
+   found and CI passes a tag is created and pushed.
+7. Once a tag is created the `.github/workflows/publish-*` workflows run. One
+   publishes all crates as-is to crates.io and the other will download all
+   artifacts from the `main.yml` workflow and then upload them all as an
+   [official release](https://github.com/bytecodealliance/wasmtime/releases).
 
 If all goes well you won't have to read up much on this and after hitting the
 Big Green Button for the automatically created PRs everything will merrily
@@ -112,9 +105,9 @@ Like above human interaction is indicated with **bold** text in these steps.
    * This will resume from step 6 above in the major release process where the
      special marker in the commit message generated by CI will trigger a tag to
      get pushed which will further trigger the rest of the release process.
-
-After a patch release has been made you'll also want to double-check that the
-release notes on the patch branch are in sync with the `main` branch.
+   * Please make sure to update the `RELEASES.md` at this point to include the
+     `Released on` date by pushing directly to the branch associated with the
+     PR.
 
 [bump-version]: https://github.com/bytecodealliance/wasmtime/actions/workflows/bump-version.yml
 
@@ -161,5 +154,19 @@ the runbook is merged.
      Note that the actual security fixes should be merged either before or as
      part of this PR.
 
-After a security release has been made you'll also want to double-check that
-the release notes on the branch are in sync with the `main` branch.
+## Releasing Notes
+
+Release notes for Wasmtime are written in the `RELEASES.md` file in the root of
+the repository. Management of this file looks like:
+
+* (theoretically) All changes on `main` which need to write an entry in
+  `RELEASES.md`.
+* When the `main` branch gets a version the `RELEASES.md` file is emptied and
+  replaced with `ci/RELEASES-template.md`. An entry for the upcoming release is
+  added to the bulleted list at the bottom.
+* (realistically) After a `release-X.Y.Z` branch is created release notes are
+  updated and edited on the release branch.
+
+This means that `RELEASES.md` only has release notes for the release branch that
+it is on. Historical release notes can be found through links at the bottom to
+previous copies of `RELEASES.md`
diff --git a/docs/contributing-testing.md b/docs/contributing-testing.md
index 188a0d06a36a..c8cff4347561 100644
--- a/docs/contributing-testing.md
+++ b/docs/contributing-testing.md
@@ -6,26 +6,23 @@ Before continuing, make sure you can [build
 Wasmtime](./contributing-building.md) successfully. Can't run the tests if you
 can't build it!
 
-## Running All Tests
+## Installing `wasm32` Targets
 
-To run all of Wasmtime's tests (excluding WASI integration tests), execute this command:
+To compile the tests, you'll need the `wasm32-wasip1` and
+`wasm32-unknown-unknown` targets installed, which, assuming you're using
+[rustup.rs](https://rustup.rs) to manage your Rust versions, can be done as
+follows:
 
 ```shell
-cargo test --all
+rustup target add wasm32-wasip1 wasm32-unknown-unknown
 ```
 
-To include WASI integration tests, you'll need `wasm32-wasi` target installed, which,
-assuming you're using [rustup.rs](https://rustup.rs) to manage your Rust versions,
-can be done as follows:
-
-```shell
-rustup target add wasm32-wasi
-```
+## Running All Tests
 
-Next, to run all tests including the WASI integration tests, execute this command:
+To run all of Wasmtime's tests, execute this command:
 
 ```shell
-cargo test --features test-programs/test_programs --all
+cargo test --workspace
 ```
 
 You can also exclude a particular crate from testing with `--exclude`. For
@@ -34,7 +31,13 @@ requires that `libclang` is installed on your system, and for some reason maybe
 you don't have it — you can run:
 
 ```shell
-cargo test --all --exclude wasmtime-fuzzing
+cargo test --workspace --exclude wasmtime-fuzzing
+```
+
+Similarly, to skip WASI integration tests, run:
+
+```shell
+cargo test --workspace --exclude test-programs
 ```
 
 ## Testing a Specific Crate
@@ -78,7 +81,7 @@ can be useful when working on the `wasi-common` crate. This can be done by
 executing this command:
 
 ```shell
-cargo test --features test-programs/test_programs -p test-programs
+cargo test -p test-programs
 ```
 
 ## Adding New Tests
diff --git a/docs/examples-c-embed.md b/docs/examples-c-embed.md
index c6dc5b678780..57b88955ad09 100644
--- a/docs/examples-c-embed.md
+++ b/docs/examples-c-embed.md
@@ -1,6 +1 @@
-# Embedding in C
-
-This section is intended to showcase the C embedding API for Wasmtime. Full
-reference documentation for the C API [can be found online][online]
-
-[online]: https://bytecodealliance.github.io/wasmtime/c-api/
+# C
diff --git a/docs/examples-coredump.md b/docs/examples-coredump.md
index 419d2eac5b64..f0e8c8bdf5a3 100644
--- a/docs/examples-coredump.md
+++ b/docs/examples-coredump.md
@@ -5,7 +5,7 @@ The following steps describe how to debug using Wasm coredump in Wasmtime:
 1. Compile your WebAssembly with debug info enabled; for example:
 
     ```sh
-    $ rustc foo.rs --target=wasm32-wasi -C debuginfo=2
+    $ rustc foo.rs --target=wasm32-wasip1 -C debuginfo=2
     ```
 
 <details>
diff --git a/docs/examples-debugging-core-dumps.md b/docs/examples-debugging-core-dumps.md
index 5f03f368aae9..58c196639dce 100644
--- a/docs/examples-debugging-core-dumps.md
+++ b/docs/examples-debugging-core-dumps.md
@@ -35,7 +35,7 @@ fn baz(x: u32) {
 We can compile it to Wasm with the following command:
 
 ```shell-session
-$ rustc --target wasm32-wasi -o ./trap.wasm ./trap.rs
+$ rustc --target wasm32-wasip1 -o ./trap.wasm ./trap.rs
 ```
 
 Next, we can run it in Wasmtime and capture a core dump when it traps:
diff --git a/docs/examples-debugging-native-debugger.md b/docs/examples-debugging-native-debugger.md
index b61fe494fef3..1a64538ae8dd 100644
--- a/docs/examples-debugging-native-debugger.md
+++ b/docs/examples-debugging-native-debugger.md
@@ -13,7 +13,8 @@ the same time:
 
 2. Run Wasmtime with the debug info enabled; this is `-D debug-info` from the
    CLI and `Config::debug_info(true)` in an embedding (e.g. see [debugging in a
-   Rust embedding](./examples-rust-debugging.md))
+   Rust embedding](./examples-rust-debugging.md)). It's also recommended to use
+   `-O opt-level=0` for better inspection of local variables if desired.
 
 3. Use a supported debugger:
 
@@ -21,7 +22,7 @@ the same time:
     lldb -- wasmtime run -D debug-info foo.wasm
     ```
     ```sh
-    gdb --args wasmtime run -D debug-info foo.wasm
+    gdb --args wasmtime run -D debug-info -O opt-level=0 foo.wasm
     ```
 
 If you run into trouble, the following discussions might help:
diff --git a/docs/examples-minimal.md b/docs/examples-minimal.md
new file mode 100644
index 000000000000..b6f813552e5f
--- /dev/null
+++ b/docs/examples-minimal.md
@@ -0,0 +1,328 @@
+# Building a Minimal Wasmtime embedding
+
+Wasmtime embeddings may wish to optimize for binary size and runtime footprint
+to fit on a small system. This documentation is intended to guide some features
+of Wasmtime and how to best produce a minimal build of Wasmtime.
+
+## Building a minimal CLI
+
+> *Note*: the exact numbers in this section were last updated on 2023-10-18 on a
+> macOS aarch64 host. For up-to-date numbers consult the artifacts in the [`dev`
+> release of Wasmtime][dev] where the `wasmtime-min` executable represents the
+> culmination of these steps.
+
+[dev]: https://github.com/bytecodealliance/wasmtime/releases/tag/dev
+
+Many Wasmtime embeddings go through the `wasmtime` crate as opposed to the
+`wasmtime` CLI executable, but to start out let's take a look at minimizing the
+command line executable. By default the wasmtime command line executable is
+relatively large:
+
+```shell
+$ cargo build
+$ ls -l ./target/debug/wasmtime
+-rwxr-xr-x@ 1 root  root    140M Oct 18 08:33 target/debug/wasmtime
+```
+
+The easiest size optimization is to compile with optimizations. This will strip
+lots of dead code and additionally generate much less debug information by
+default
+
+```shell
+$ cargo build --release
+$ ls -l ./target/release/wasmtime
+-rwxr-xr-x@ 1 root  root     33M Oct 18 08:34 target/release/wasmtime
+```
+
+Much better, but still relatively large! The next thing that can be done is to
+disable the default features of the `wasmtime-cli` crate. This will remove all
+optional functionality from the crate and strip it down to the bare bones
+functionality. Note though that `run` is included to keep the ability to run
+precompiled WebAssembly files as otherwise the CLI doesn't have any
+functionality which isn't too useful.
+
+```shell
+$ cargo build --release --no-default-features --features run
+$ ls -l ./target/release/wasmtime
+-rwxr-xr-x@ 1 root  root    6.7M Oct 18 08:37 target/release/wasmtime
+```
+
+Note that this executable is stripped to the bare minimum of functionality which
+notably means it does not have a compiler for WebAssembly files. This means that
+`wasmtime compile` is no longer supported meaning that `*.cwasm` files must be
+fed to `wasmtime run` to execute files. Additionally error messages will be
+worse in this mode as less contextual information is provided.
+
+The final Wasmtime-specific optimization you can apply is to disable logging
+statements. Wasmtime and its dependencies make use of the [`log`
+crate](https://docs.rs/log) and [`tracing` crate](https://docs.rs/tracing) for
+debugging and diagnosing. For a minimal build this isn't needed though so this
+can all be disabled through Cargo features to shave off a small amount of code.
+Note that for custom embeddings you'd need to replicate the `disable-logging`
+feature which sets the `max_level_off` feature for the `log` and `tracing`
+crate.
+
+```shell
+$ cargo build --release --no-default-features --features run,disable-logging
+$ ls -l ./target/release/wasmtime
+-rwxr-xr-x@ 1 root  root    6.7M Oct 18 08:37 target/release/wasmtime
+```
+
+At this point the next line of tricks to apply to minimize binary size are
+[general tricks-of-the-trade for Rust
+programs](https://github.com/johnthagen/min-sized-rust) and are no longer
+specific to Wasmtime. For example the first thing that can be done is to
+optimize for size rather than speed via rustc's `s` optimization level.
+This uses Cargo's [environment-variable based configuration][cargo-env-config]
+via the `CARGO_PROFILE_RELEASE_OPT_LEVEL=s` environment variable to configure
+this.
+
+[cargo-env-config]: https://doc.rust-lang.org/cargo/reference/config.html#profile
+
+```shell
+$ export CARGO_PROFILE_RELEASE_OPT_LEVEL=s
+$ cargo build --release --no-default-features --features run,disable-logging
+$ ls -l ./target/release/wasmtime
+-rwxr-xr-x@ 1 root  root    6.8M Oct 18 08:40 target/release/wasmtime
+```
+
+Note that the size has increased here slightly instead of going down. Optimizing
+for speed-vs-size can affect a number of heuristics in LLVM so it's best to test
+out locally what's best for your embedding. Further examples below continue to
+pass this flag since by the end it will produce a smaller binary than the
+default optimization level of "3" for release mode. You may wish to also try an
+optimization level of "2" and see which produces a smaller build for you.
+
+After optimizations levels the next compilation setting to configure is
+Rust's "panic=abort" mode where panics translate to process aborts rather than
+unwinding. This removes landing pads from code as well as unwind tables from the
+executable.
+
+```shell
+$ export CARGO_PROFILE_RELEASE_OPT_LEVEL=s
+$ export CARGO_PROFILE_RELEASE_PANIC=abort
+$ cargo build --release --no-default-features --features run,disable-logging
+$ ls -l ./target/release/wasmtime
+-rwxr-xr-x@ 1 root  root    5.0M Oct 18 08:40 target/release/wasmtime
+```
+
+Next, if the compile time hit is acceptable, LTO can be enabled to provide
+deeper opportunities for compiler optimizations to remove dead code and
+deduplicate. Do note that this will take a significantly longer amount of time
+to compile than previously. Here LTO is configured with
+`CARGO_PROFILE_RELEASE_LTO=true`.
+
+```shell
+$ export CARGO_PROFILE_RELEASE_OPT_LEVEL=s
+$ export CARGO_PROFILE_RELEASE_PANIC=abort
+$ export CARGO_PROFILE_RELEASE_LTO=true
+$ cargo build --release --no-default-features --features run,disable-logging
+$ ls -l ./target/release/wasmtime
+-rwxr-xr-x@ 1 root  root    3.3M Oct 18 08:42 target/release/wasmtime
+```
+
+Similar to LTO above rustc can be further instructed to place all crates into
+their own single object file instead of multiple by default. This again
+increases compile times. Here that's done with
+`CARGO_PROFILE_RELEASE_CODEGEN_UNITS=1`.
+
+```shell
+$ export CARGO_PROFILE_RELEASE_OPT_LEVEL=s
+$ export CARGO_PROFILE_RELEASE_PANIC=abort
+$ export CARGO_PROFILE_RELEASE_LTO=true
+$ export CARGO_PROFILE_RELEASE_CODEGEN_UNITS=1
+$ cargo build --release --no-default-features --features run,disable-logging
+$ ls -l ./target/release/wasmtime
+-rwxr-xr-x@ 1 root  root    3.3M Oct 18 08:43 target/release/wasmtime
+```
+
+Note that with LTO using a single codegen unit may only have marginal benefit.
+If not using LTO, however, a single codegen unit will likely provide benefit
+over the default 16 codegen units.
+
+One final flag before getting to nightly features is to strip debug information
+from the standard library. In `--release` mode Cargo by default doesn't generate
+debug information for local crates, but the Rust standard library may have debug
+information still included with it. This is configured via
+`CARGO_PROFILE_RELEASE_STRIP=debuginfo`
+
+```shell
+$ export CARGO_PROFILE_RELEASE_OPT_LEVEL=s
+$ export CARGO_PROFILE_RELEASE_PANIC=abort
+$ export CARGO_PROFILE_RELEASE_LTO=true
+$ export CARGO_PROFILE_RELEASE_CODEGEN_UNITS=1
+$ export CARGO_PROFILE_RELEASE_STRIP=debuginfo
+$ cargo build --release --no-default-features --features run,disable-logging
+$ ls -l ./target/release/wasmtime
+-rwxr-xr-x@ 1 root  root    2.4M Oct 18 08:44 target/release/wasmtime
+```
+
+Next, if your use case allows it, the Nightly Rust toolchain provides a number
+of other options to minimize the size of binaries. Note the usage of `+nightly` here
+to the `cargo` command to use a Nightly toolchain (assuming your local toolchain
+is installed with rustup). Also note that due to the nature of nightly the exact
+flags here may not work in the future. Please open an issue with Wasmtime if
+these commands don't work and we'll update the documentation.
+
+The first nightly feature we can leverage is to remove filename and line number
+information in panics with `-Zlocation-detail=none`
+
+```shell
+$ export CARGO_PROFILE_RELEASE_OPT_LEVEL=s
+$ export CARGO_PROFILE_RELEASE_PANIC=abort
+$ export CARGO_PROFILE_RELEASE_LTO=true
+$ export CARGO_PROFILE_RELEASE_CODEGEN_UNITS=1
+$ export CARGO_PROFILE_RELEASE_STRIP=debuginfo
+$ export RUSTFLAGS="-Zlocation-detail=none"
+$ cargo +nightly build --release --no-default-features --features run,disable-logging
+$ ls -l ./target/release/wasmtime
+-rwxr-xr-x@ 1 root  root    2.4M Oct 18 08:43 target/release/wasmtime
+```
+
+Further along the line of nightly features the next optimization will recompile
+the standard library without unwinding information, trimming out a bit more from
+the standard library. This uses the `-Zbuild-std` flag to Cargo. Note that this
+additionally requires `--target` as well which will need to be configured for
+your particular platform.
+
+```shell
+$ export CARGO_PROFILE_RELEASE_OPT_LEVEL=s
+$ export CARGO_PROFILE_RELEASE_PANIC=abort
+$ export CARGO_PROFILE_RELEASE_LTO=true
+$ export CARGO_PROFILE_RELEASE_CODEGEN_UNITS=1
+$ export CARGO_PROFILE_RELEASE_STRIP=debuginfo
+$ export RUSTFLAGS="-Zlocation-detail=none"
+$ cargo +nightly build --release --no-default-features --features run,disable-logging \
+    -Z build-std=std,panic_abort --target aarch64-apple-darwin
+$ ls -l ./target/aarch64-apple-darwin/release/wasmtime
+-rwxr-xr-x@ 1 root  root    2.3M Oct 18 09:39 target/aarch64-apple-darwin/release/wasmtime
+```
+
+Next the Rust standard library has some optional features in addition to
+Wasmtime, such as printing of backtraces. This may not be required in minimal
+environments so the features of the standard library can be disabled with the
+`-Zbuild-std-features=` flag which configures the set of enabled features to be
+empty.
+
+```shell
+$ export CARGO_PROFILE_RELEASE_OPT_LEVEL=s
+$ export CARGO_PROFILE_RELEASE_PANIC=abort
+$ export CARGO_PROFILE_RELEASE_LTO=true
+$ export CARGO_PROFILE_RELEASE_CODEGEN_UNITS=1
+$ export CARGO_PROFILE_RELEASE_STRIP=debuginfo
+$ export RUSTFLAGS="-Zlocation-detail=none"
+$ cargo +nightly build --release --no-default-features --features run,disable-logging \
+    -Z build-std=std,panic_abort --target aarch64-apple-darwin \
+    -Z build-std-features=
+$ ls -l ./target/aarch64-apple-darwin/release/wasmtime
+-rwxr-xr-x@ 1 root  root    2.1M Oct 18 09:39 target/aarch64-apple-darwin/release/wasmtime
+```
+
+## Minimizing further
+
+Above shows an example of taking the default `cargo build` result of 130M down
+to a 2.1M binary for the `wasmtime` executable. Similar steps can be done to
+reduce the size of the C API binary artifact as well which currently produces a
+~2.8M dynamic library. This is currently the smallest size with the source code
+as-is, but there are more size reductions which haven't been implemented yet.
+
+This is a listing of some example sources of binary size. Some sources of binary
+size may not apply to custom embeddings since, for example, your custom
+embedding might already not use WASI and might already not be included.
+
+* WASI in the Wasmtime CLI - currently the CLI includes all of WASI. This
+  includes two separate implementations of WASI - one for preview2 and one for
+  preview1. This accounts for 1M+ of space which is a significant chunk of the
+  remaining 2.1M.  While removing just preview2 or preview1 would be easy enough
+  with a Cargo feature, the resulting executable wouldn't be able to do
+  anything. Something like a [plugin feature for the
+  CLI](https://github.com/bytecodealliance/wasmtime/issues/7348), however, would
+  enable removing WASI while still being a usable executable.
+
+* Argument parsing in the Wasmtime CLI - as a command line executable `wasmtime`
+  contains parsing of command line arguments which currently uses the `clap`
+  crate. This contributes ~200k of binary size to the final executable which
+  would likely not be present in a custom embedding of Wasmtime. While this
+  can't be removed from Wasmtime it's something to consider when evaluating the
+  size of CI artifacts.
+
+* Cranelift in the C API - one of the features of Wasmtime is the ability to
+  have a runtime without Cranelift that only supports precompiled (AOT) wasm
+  modules. It's [not possible to build the C API without
+  Cranelift](https://github.com/bytecodealliance/wasmtime/issues/7349) though
+  because defining host functions requires Cranelift at this time to emit some
+  stubs.  This means that the C API is significantly larger than a custom Rust
+  embedding which doesn't suffer from the same restriction. This means that
+  while it's still possible to build an embedding of Wasmtime which doesn't have
+  Cranelift it's not easy to see what it might look like size-wise from
+  looking at the C API artifacts.
+
+* Formatting strings in Wasmtime - Wasmtime makes extensive use of formatting
+  strings for error messages and other purposes throughout the implementation.
+  Most of this is intended for debugging and understanding more when something
+  goes wrong, but much of this is not necessary for a truly minimal embedding.
+  In theory much of this could be conditionally compiled out of the Wasmtime
+  project to produce a smaller executable. Just how much of the final binary
+  size is accounted for by formatting string is unknown, but it's well known in
+  Rust that `std::fmt` is not the slimmest of modules.
+
+* Cranelift vs Winch - the "min" builds on CI try to exclude Cranelift from
+  their binary footprint (e.g. the CLI excludes it) but this comes at a cost of
+  the final executable not supporting compilation of wasm modules. If this is
+  required then no effort has yet been put into minimizing the code size of
+  Cranelift itself. One possible tradeoff that can be made though is to choose
+  between the Winch baseline compiler vs Cranelift. Winch should be much smaller
+  from a compiled footprint point of view while not sacrificing everything in
+  terms of performance. Note though that Winch is still under development.
+
+Above are some future avenues to take in terms of reducing the binary size of
+Wasmtime and various tradeoffs that can be made. The Wasmtime project is eager
+to hear embedder use cases/profiles if Wasmtime is not suitable for binary size
+reasons today. Please feel free to [open an
+issue](https://github.com/bytecodealliance/wasmtime/issues/new) and let us know
+and we'd be happy to discuss more how best to handle a particular use case.
+
+# Building Wasmtime for a Custom Platform
+
+If you're not running on a built-in supported platform such as Windows, macOS,
+or Linux, then Wasmtime won't work out-of-the-box for you. Wasmtime includes a
+compilation mode, however, that enables you to define how to work with the
+platform externally.
+
+This mode is enabled when `--cfg wasmtime_custom_platform` is passed to rustc,
+via `RUSTFLAGS` for example when building through Cargo, when an existing
+platform is not matched. This means that with this configuration Wasmtime may be
+compiled for custom or previously unknown targets.
+
+Wasmtime's current "platform embedding API" which is required to operate is
+defined at `examples/min-platform/embedding/wasmtime-platform.h`. That directory
+additionally has an example of building a minimal `*.so` on Linux which has the
+platform API implemented in C using Linux syscalls. While a bit contrived it
+effectively shows a minimal Wasmtime embedding which has no dependencies other
+than the platform API.
+
+Building Wasmtime for a custom platform is not a turnkey process right now,
+there are a number of points that need to be considered:
+
+* For a truly custom platform you'll probably want to create a [custom Rust
+  target](https://docs.rust-embedded.org/embedonomicon/custom-target.html). This
+  means that Nightly Rust will be required.
+
+* Wasmtime and its dependencies require the Rust standard library `std` to be
+  available. The Rust standard library can be compiled for any target with
+  unsupported functionality being stubbed out. This mode of compiling the Rust
+  standard library is not stable, however. Currently this is done through the
+  `-Zbuild-std` argument to Cargo along with a
+  `+RUSTC_BOOTSTRAP_SYNTHETIC_TARGET=1` environment variable.
+
+* Wasmtime additionally depends on the availability of a memory allocator (e.g.
+  `malloc`). Wasmtime assumes that failed memory allocation aborts the process.
+
+* Not all features for Wasmtime can be built for custom targets. For example
+  WASI support does not work on custom targets. When building Wasmtime you'll
+  probably want `--no-default-features` and will then want to incrementally add
+  features back in as needed.
+
+The `examples/min-platform` directory has an example of building this minimal
+embedding and some necessary steps. Combined with the above features about
+producing a minimal build currently produces a 400K library on Linux.
diff --git a/docs/examples-profiling-perf.md b/docs/examples-profiling-perf.md
index 63317aeddf10..32ebfe00a6fc 100644
--- a/docs/examples-profiling-perf.md
+++ b/docs/examples-profiling-perf.md
@@ -123,7 +123,7 @@ have any problems, please don't hesitate to [file an issue]!
 If the jitdump profile doesn't give you enough information by default, you can
 also enable dwarf debug information to be generated for JIT code which should
 give the `perf` profiler more information about what's being profiled. This can
-include information like more desriptive function names, filenames, and line
+include information like more descriptive function names, filenames, and line
 numbers.
 
 Enabling dwarf debug information for JIT code depends on how you're using
@@ -162,7 +162,7 @@ fn fib(n: u32) -> u32 {
 To collect perf information for this wasm module we'll execute:
 
 ```sh
-$ rustc --target wasm32-wasi fib.rs -O
+$ rustc --target wasm32-wasip1 fib.rs -O
 $ perf record -k mono wasmtime --profile=jitdump fib.wasm
 fib(42) = 267914296
 [ perf record: Woken up 1 times to write data ]
@@ -170,7 +170,7 @@ fib(42) = 267914296
 $ perf inject --jit --input perf.data --output perf.jit.data
 ```
 
-And we should have all out information now! We can execute `perf report` for
+And we should have all our information now! We can execute `perf report` for
 example to see that 99% of our runtime (as expected) is spent in our `fib`
 function. Note that the symbol has been demangled to `fib::fib` which is what
 the Rust symbol is:
diff --git a/docs/examples-profiling-vtune.md b/docs/examples-profiling-vtune.md
index 61c67d1b572f..3e1716e4c16d 100644
--- a/docs/examples-profiling-vtune.md
+++ b/docs/examples-profiling-vtune.md
@@ -4,7 +4,7 @@
 and 64-bit x86 architectures. The tool collects profiling data during runtime
 and then, either through the command line or GUI, provides a variety of options
 for viewing and analyzing that data. VTune Profiler is available in both
-commerical and free options. The free, downloadable version is available
+commercial and free options. The free, downloadable version is available
 [here][download] and is backed by a community forum for support. This version is
 appropriate for detailed analysis of your Wasm program.
 
@@ -65,7 +65,7 @@ This command tells the VTune collector (`vtune`) to collect hot spot
 profiling data as Wasmtime is executing `foo.wasm`. The `--profile=vtune` flag enables
 VTune support in Wasmtime so that the collector is also alerted to JIT events
 that take place during runtime. The first time this is run, the result of the
-command is a results diretory `r000hs/` which contains profiling data for
+command is a results directory `r000hs/` which contains profiling data for
 Wasmtime and the execution of `foo.wasm`. This data can then be read and
 displayed via the command line or via the VTune GUI by importing the result.
 
@@ -92,7 +92,7 @@ fn fib(n: u32) -> u32 {
 We compile the example to Wasm:
 
 ```sh
-$ rustc --target wasm32-wasi fib.rs -C opt-level=z -C lto=yes
+$ rustc --target wasm32-wasip1 fib.rs -C opt-level=z -C lto=yes
 ```
 
 Then we execute the Wasmtime runtime (built with the `vtune` feature and
@@ -101,7 +101,7 @@ application, `vtune`, which must already be installed and available on the
 path. To collect hot spot profiling information, we execute:
 
 ```sh
-$ rustc --target wasm32-wasi fib.rs -C opt-level=z -C lto=yes
+$ rustc --target wasm32-wasip1 fib.rs -C opt-level=z -C lto=yes
 $ vtune -run-pass-thru=--no-altstack -v -collect hotspots target/debug/wasmtime --profile=vtune fib.wasm
 fib(45) = 1134903170
 amplxe: Collection stopped.
diff --git a/docs/examples-profiling.md b/docs/examples-profiling.md
index 348979c03705..d1b0ab0c7109 100644
--- a/docs/examples-profiling.md
+++ b/docs/examples-profiling.md
@@ -20,14 +20,16 @@ platforms:
 - For Intel's x86 CPUs on Linux or Windows, we support
   [VTune](./examples-profiling-vtune.md).
 
-- For everything else, see the cross-platform profiler below.
+- For Linux and macOS, we support [samply](./examples-profiling-samply.md).
+
+- For everything else, see the [cross-platform
+  profiler](./examples-profiling-guest.md).
 
 The native profilers can measure time spent in WebAssembly guest code as well as
 time spent in the Wasmtime host and potentially even time spent in the kernel.
 This provides a comprehensive view of performance.
 
-If the native profiling tools don't work for you, Wasmtime also provides a
-[cross-platform profiler](./examples-profiling-guest.md). This profiler can only
-measure time spent in WebAssembly guest code, and its timing measurements are
-not as precise as the native profilers. However, it works on every platform that
-Wasmtime supports.
+The cross-platform-profiler can only measure time spent in WebAssembly guest
+code, and its timing measurements are not as precise as the native profilers.
+However, it works on every platform that Wasmtime supports.
+
diff --git a/docs/examples-rust-embed.md b/docs/examples-rust-embed.md
deleted file mode 100644
index 14b4b1ebbe27..000000000000
--- a/docs/examples-rust-embed.md
+++ /dev/null
@@ -1,6 +0,0 @@
-# Embedding in Rust
-
-This section is intended to showcase the Rust embedding API for Wasmtime. This
-is done through the [`wasmtime` crate](https://crates.io/crates/wasmtime). In
-addition to browsing the following examples you can also browse the [full API
-documentation](https://docs.rs/wasmtime).
diff --git a/docs/examples-rust-wasi.md b/docs/examples-rust-wasi.md
index 1cafb1c87e9d..ee5dfa43abaf 100644
--- a/docs/examples-rust-wasi.md
+++ b/docs/examples-rust-wasi.md
@@ -5,21 +5,29 @@ repository to run the example locally.
 
 [code]: https://github.com/bytecodealliance/wasmtime/blob/main/examples/wasi/main.rs
 
-This example shows how to use the [`wasmtime-wasi`] crate to define WASI
+This example shows how to use the [`wasi-common`] crate to define WASI
 functions within a [`Linker`] which can then be used to instantiate a
 WebAssembly module.
 
-[`wasmtime-wasi`]: https://crates.io/crates/wasmtime-wasi
+[`wasi-common`]: https://crates.io/crates/wasi-common
 [`Linker`]: https://docs.rs/wasmtime/*/wasmtime/struct.Linker.html
 
-## Wasm Source code
+### WebAssembly module source code
 
+For this WASI example, this Hello World program is compiled to a WebAssembly module using the WASI Preview 1 API.
+
+`wasi.rs`
 ```rust
 {{#include ../examples/wasi/wasm/wasi.rs}}
 ```
 
-## `wasi.rs`
+Building this program generates `target/wasm32-wasip1/debug/wasi.wasm`, used below.
+
+### Invoke the WASM module
 
+This example shows adding and configuring the WASI imports to invoke the above WASM module.
+
+`main.rs`
 ```rust,ignore
 {{#include ../examples/wasi/main.rs}}
 ```
@@ -31,19 +39,19 @@ WasiCtx` from within the `T` stored in the `Store<T>` itself. In the above
 example this is trivial because the `T` in `Store<T>` is `WasiCtx` itself, but
 you can also store other state in `Store` like so:
 
-[`add_to_linker`]: https://docs.rs/wasmtime-wasi/*/wasmtime_wasi/sync/fn.add_to_linker.html
-[`Store`]: https://docs.rs/wasmtime/0.26.0/wasmtime/struct.Store.html
+[`add_to_linker`]: https://docs.rs/wasi-common/*/wasi_common/sync/fn.add_to_linker.html
+[`Store`]: https://docs.rs/wasmtime/*/wasmtime/struct.Store.html
 [`BorrowMut<WasiCtx>`]: https://doc.rust-lang.org/stable/std/borrow/trait.BorrowMut.html
-[`WasiCtx`]: https://docs.rs/wasmtime-wasi/*/wasmtime_wasi/struct.WasiCtx.html
+[`WasiCtx`]: https://docs.rs/wasi-common/*/wasi_common/struct.WasiCtx.html
 
 ```rust
 # extern crate wasmtime;
-# extern crate wasmtime_wasi;
+# extern crate wasi_common;
 # extern crate anyhow;
 use anyhow::Result;
 use std::borrow::{Borrow, BorrowMut};
 use wasmtime::*;
-use wasmtime_wasi::{WasiCtx, sync::WasiCtxBuilder};
+use wasi_common::{WasiCtx, sync::WasiCtxBuilder};
 
 struct MyState {
     message: String,
@@ -53,7 +61,7 @@ struct MyState {
 fn main() -> Result<()> {
     let engine = Engine::default();
     let mut linker = Linker::new(&engine);
-    wasmtime_wasi::add_to_linker(&mut linker, |state: &mut MyState| &mut state.wasi)?;
+    wasi_common::sync::add_to_linker(&mut linker, |state: &mut MyState| &mut state.wasi)?;
 
     let wasi = WasiCtxBuilder::new()
         .inherit_stdio()
@@ -70,3 +78,24 @@ fn main() -> Result<()> {
     Ok(())
 }
 ```
+
+## WASI Preview 2
+
+An experimental implementation of the WASI Preview 2 API is also available, along with an adapter layer for  WASI Preview 1 WebAssembly modules. In future this `preview2` API will become the default. There are some features which are currently only accessible through the `preview2` API such as async support and overriding the clock and random implementations.
+
+### Async example
+
+This [async example code][code2] shows how to use the [wasmtime-wasi::preview2][`preview2`] module to
+execute the same WASI Preview 1 WebAssembly module from the example above. This example requires the `wasmtime` crate `async` feature to be enabled.
+
+This does not require any change to the WebAssembly module, it's just the WASI API host functions which are implemented to be async. See [wasmtime async support](https://docs.wasmtime.dev/api/wasmtime/struct.Config.html#method.async_support).
+
+[code2]: https://github.com/bytecodealliance/wasmtime/blob/main/examples/wasi-async/main.rs
+[`preview2`]: https://docs.rs/wasmtime-wasi/*/wasmtime_wasi/preview2/index.html
+
+```rust,ignore
+{{#include ../examples/wasi-async/main.rs}}
+```
+
+You can also [browse this source code online][code2] and clone the wasmtime
+repository to run the example locally.
diff --git a/docs/examples.md b/docs/examples.md
index f2cc544ef8c4..1ab9078d1692 100644
--- a/docs/examples.md
+++ b/docs/examples.md
@@ -1,4 +1,4 @@
-# Examples
+# Further Examples
 
 The examples contained in this section explain how to use Wasmtime in several
 common scenarios.
diff --git a/docs/introduction.md b/docs/introduction.md
index 207285c71866..f48745b7665f 100644
--- a/docs/introduction.md
+++ b/docs/introduction.md
@@ -1,10 +1,36 @@
 # Introduction
 
-[Wasmtime][github] is a [Bytecode Alliance][BA] project that is a standalone
-optimizing runtime for [WebAssembly], [the Component Model], and [WASI]. It runs
-WebAssembly code [outside of the Web], and can be used both as a command-line
-utility or as a library embedded in a larger application. Wasmtime strives to be
-a highly configurable and embeddable runtime to run on any scale of application.
+[Wasmtime][github] is a standalone runtime for WebAssembly, WASI, and the
+Component Model by the [Bytecode Alliance][BA].
+
+[WebAssembly] (abbreviated Wasm) is a binary instruction format that is designed
+to be a portable compilation target for programming languages. Wasm binaries
+typically have a `.wasm` file extension. In this documentation, we'll also use
+the textual representation of the binary files, which have a `.wat` file
+extension.
+
+[WASI] (the WebAssembly System Interface) defines interfaces that provide a
+secure and portable way to access several operating-system-like features such as
+filesystems, networking, clocks, and random numbers.
+
+[The Component Model] is a Wasm architecture that provides a binary format for
+portable, cross-language composition. More specifically, it supports the use of
+interfaces via which components can communicate with each other. WASI
+is defined in terms of component model interfaces.
+
+Wasmtime runs WebAssembly code [outside of the Web], and can be used both as a
+command-line utility or as a library embedded in a larger application. It
+strives to be
+
+- **Fast**: Wasmtime is built on the optimizing [Cranelift] code generator.
+- **Secure**: Wasmtime's development is strongly focused on correctness and
+  security.
+- **Configurable**: Wasmtime uses sensible defaults, but can also be configured
+  to provide more fine-grained control over things like CPU and memory
+  consumption.
+- **Standards Compliant**: Wasmtime passes the official WebAssembly test suite
+  and the Wasmtime developers are intimately engaged with the WebAssembly
+  standards process.
 
 This documentation is intended to serve a number of purposes and within you'll
 find:
@@ -21,8 +47,9 @@ contributions are welcome!
 
 [github]: https://github.com/bytecodealliance/wasmtime
 [BA]: https://bytecodealliance.org/
+[Cranelift]: https://github.com/bytecodealliance/wasmtime/blob/main/cranelift/README.md
 [WebAssembly]: https://webassembly.org/
 [WASI]: https://wasi.dev
 [outside of the Web]: https://webassembly.org/docs/non-web/
 [issue]: https://github.com/bytecodealliance/wasmtime/issues/new
-[the Component Model]: https://github.com/WebAssembly/component-model
+[The Component Model]: https://github.com/WebAssembly/component-model
diff --git a/docs/lang-bash.md b/docs/lang-bash.md
index fba5f9a741f3..bc1f8f829493 100644
--- a/docs/lang-bash.md
+++ b/docs/lang-bash.md
@@ -30,7 +30,7 @@ function gcd() {
   local x=$(($1))
   local y=$(($2))
   # Invoke GCD from module; suppress stderr
-  local result=$(wasmtime examples/gcd.wat --invoke gcd $x $y 2>/dev/null)
+  local result=$(wasmtime --invoke gcd examples/gcd.wat $x $y 2>/dev/null)
   echo "$result"
 }
 
diff --git a/docs/lang-c.md b/docs/lang-c.md
index a40cd10d12ce..5db21c9277e6 100644
--- a/docs/lang-c.md
+++ b/docs/lang-c.md
@@ -1,7 +1,6 @@
-# C
+# Embedding in C
 
-... more coming soon
+This section is intended to showcase the C embedding API for Wasmtime. Full
+reference documentation for the C API [can be found online][online].
 
-In the meantime, have a look at the [C API docs].
-
-[C API docs]: https://bytecodealliance.github.io/wasmtime/c-api/
+[online]: https://bytecodealliance.github.io/wasmtime/c-api/
diff --git a/docs/lang-python.md b/docs/lang-python.md
index 04be40d7a77f..baef9de08581 100644
--- a/docs/lang-python.md
+++ b/docs/lang-python.md
@@ -11,7 +11,7 @@ started!
 
 ## Getting started and simple example
 
-First, copy this example WebAssembly text module into your project. It exports a
+First, copy this example WebAssembly text module into your project with the filename `gcd.wat`. It exports a
 function for calculating the greatest common denominator of two numbers.
 
 ```wat
diff --git a/docs/lang-rust.md b/docs/lang-rust.md
index cc5d57248d0f..99bccbccfc8b 100644
--- a/docs/lang-rust.md
+++ b/docs/lang-rust.md
@@ -3,18 +3,16 @@
 This document shows an example of how to embed Wasmtime using the [Rust
 API][apidoc] to execute a simple wasm program. Be sure to also check out the
 [full API documentation][apidoc] for a full listing of what the [`wasmtime`
-crate][wasmtime] has to offer and the [book examples for
-Rust](./examples-rust-embed.md) for more information.
+crate][wasmtime] has to offer.
 
 [apidoc]: https://bytecodealliance.github.io/wasmtime/api/wasmtime/
 [wasmtime]: https://crates.io/crates/wasmtime
 
 ## Creating the WebAssembly to execute
 
-Creation of a WebAssembly file is generally covered by the [Writing
-WebAssembly chapter](./wasm.md), so we'll just assume that you've already got a
-wasm file on hand for the rest of this tutorial. To make things simple we'll
-also just assume you've got a `hello.wat` file which looks like this:
+We'll just assume that you've already got a wasm file on hand for the rest of
+this tutorial. To make things simple we'll also just assume you've got a
+`hello.wat` file which looks like this:
 
 ```wat
 (module
@@ -38,12 +36,11 @@ $ cd wasmtime_hello
 
 Next you'll want to add `hello.wat` to the root of your project.
 
-We will be using the `wasmtime` crate to run the wasm file, so next up we need a
-dependency in `Cargo.toml`:
+We will be using the `wasmtime` crate to run the wasm file. Please execute the command `cargo add wasmtime` to use the latest version of the crate. The `dependencies` block in the `Cargo.toml` file will appear as follows:
 
 ```toml
 [dependencies]
-wasmtime = "1.0.0"
+wasmtime = "19.0.0"
 ```
 
 Next up let's write the code that we need to execute this wasm file. The
diff --git a/docs/lang.md b/docs/lang.md
index 94e38d1b0859..be222bf6eab7 100644
--- a/docs/lang.md
+++ b/docs/lang.md
@@ -1,4 +1,4 @@
-# Using WebAssembly from your Language
+# Using the Wasmtime API
 
 Wasmtime can be used as a library to embed WebAssembly execution support
 within applications. Wasmtime is written in Rust, but bindings are available
diff --git a/docs/rust_wasi_markdown_parser/Cargo.toml b/docs/rust_wasi_markdown_parser/Cargo.toml
deleted file mode 100644
index a9562ff1a4e5..000000000000
--- a/docs/rust_wasi_markdown_parser/Cargo.toml
+++ /dev/null
@@ -1,10 +0,0 @@
-[package]
-name = "rust_wasi_markdown_parser"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-pulldown-cmark = "0.1.2"
-structopt = "0.3.22"
diff --git a/docs/rust_wasi_markdown_parser/example_markdown.md b/docs/rust_wasi_markdown_parser/example_markdown.md
deleted file mode 100644
index c43cf286e056..000000000000
--- a/docs/rust_wasi_markdown_parser/example_markdown.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# Hello!
-
-I am example markdown for this demo!
diff --git a/docs/rust_wasi_markdown_parser/src/main.rs b/docs/rust_wasi_markdown_parser/src/main.rs
deleted file mode 100644
index b588b6ad40b9..000000000000
--- a/docs/rust_wasi_markdown_parser/src/main.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-// Import our CLI parsing libraries (And PathBuf for reading paths)
-extern crate structopt;
-
-use structopt::StructOpt;
-use std::path::PathBuf;
-
-// Import our markdown parser library, crate
-extern crate pulldown_cmark;
-
-use pulldown_cmark::{html, Parser};
-
-// Import from the standard library, to allow reading from the file system
-use std::fs;
-
-// Define our CLI options using structopt
-#[derive(StructOpt)]
-#[structopt(name = "rust_wasi_markdown_parser", about = "Markdown to HTML renderer CLI, written with Rust & WASI")]
-pub struct Options {
-    /// The markdown file to render
-    #[structopt(parse(from_os_str))]
-    filename: PathBuf,
-}
-
-// Our entrypoint into our WASI module
-fn main() {
-
-    // Get the passed CLI options
-    let options = Options::from_args();
-
-    // Read the markdown file into a string
-    let contents = fs::read_to_string(options.filename)
-        .expect("Something went wrong reading the file");
-
-    // Run our parsing function to get back an HTML string
-    let result = render_markdown(contents);
-
-    // Print out the resulting HTML to standard out
-    println!("{}", result);
-}
-
-pub fn render_markdown(markdown: String) -> String {
-    let mut html_buf = String::new();
-    let parser = Parser::new(&markdown[..]);
-    html::push_html(&mut html_buf, parser);
-    html_buf
-}
diff --git a/docs/security-what-is-considered-a-security-vulnerability.md b/docs/security-what-is-considered-a-security-vulnerability.md
new file mode 100644
index 000000000000..b89310e86dce
--- /dev/null
+++ b/docs/security-what-is-considered-a-security-vulnerability.md
@@ -0,0 +1,75 @@
+# What is considered a security vulnerability?
+
+**If you are still unsure whether an issue you are filing is a security
+vulnerability or not after reading this page, always err on the side of caution
+and report it as a security vulnerability!**
+
+Bugs must affect [a tier 1 platform or feature](./stability-tiers.md) to be
+considered a security vulnerability.
+
+The security of the host and integrity of the sandbox when executing Wasm is
+paramount. Anything that undermines the Wasm execution sandbox is a security
+vulnerability.
+
+On the other hand, execution that diverges from Wasm semantics (such as
+computing incorrect values) are not considered security vulnerabilities so long
+as they remain confined within the sandbox. This has a couple repercussions that
+are worth highlighting:
+
+* Even though it is safe from the *host's* point of view, an incorrectly
+  computed value could lead to classic memory unsafety bugs from the *Wasm
+  guest's* point of view, such as corruption of its `malloc`'s free list or
+  reading past the end of a source-level array.
+
+* Wasmtime embedders should never blindly trust values from the guest &mdash; no
+  matter how trusted the guest program is, even if it was written by the
+  embedders themselves &mdash; and should always validate these values before
+  performing unsafe operations on behalf of the guest.
+
+Denials of service when *executing* Wasm (either originating inside compiled
+Wasm code or Wasmtime's runtime subroutines) are considered security
+vulnerabilities. For example, if you configure Wasmtime to run Wasm guests with
+the async
+[fuel](https://docs.rs/wasmtime/latest/wasmtime/struct.Config.html#method.consume_fuel)
+mechanism, and then executing the Wasm goes into an infinite loop that never
+yields, that is considered a security vulnerability.
+
+Denials of service when *compiling* Wasm, however, are not considered security
+vulnerabilities. For example, an infinite loop during register allocation is not
+a security vulnerability.
+
+Any kind of memory unsafety (e.g. use-after-free bugs, out-of-bounds memory
+accesses, etc...) in the host is always a security vulnerability.
+
+### Cheat Sheet: Is this bug considered a security vulnerability?
+
+| Type of bug                                     | At Wasm Compile Time | At Wasm Execution Time |
+|-------------------------------------------------------------------------------------|-----|-----|
+| Sandbox escape                                                                      | -   | Yes |
+| <ul>Uncaught out-of-bounds memory access                                            | -   | Yes |
+| <ul>Uncaught out-of-bounds table access                                             | -   | Yes |
+| <ul>Failure to uphold Wasm's control-flow integrity                                 | -   | Yes |
+| <ul>File system access outside of the WASI file system's mapped directories         | -   | Yes |
+| <ul>Use of a WASI resource without having been given the associated WASI capability | -   | Yes |
+| <ul>Etc...                                                                          | -   | Yes |
+| Divergence from Wasm semantics (without escaping the sandbox)                       | -   | No  |
+| <ul>Computing incorrect value                                                       | -   | No  |
+| <ul>Raising errant trap                                                             | -   | No  |
+| <ul>Etc...                                                                          | -   | No  |
+| Memory unsafety                                                                     | Yes | Yes |
+| <ul>Use-after-free                                                                  | Yes | Yes |
+| <ul>Out-of-bounds memory access                                                     | Yes | Yes |
+| <ul>Use of uninitialized memory                                                     | Yes | Yes |
+| <ul>Etc...                                                                          | Yes | Yes |
+| Denial of service                                                                   | No  | Yes |
+| <ul>Panic                                                                           | No  | Yes |
+| <ul>Process abort                                                                   | No  | Yes |
+| <ul>Uninterruptible infinite loops                                                  | No  | Yes |
+| <ul>User-controlled memory exhaustion                                               | No  | Yes |
+| <ul>Uncontrolled recursion over user-supplied input                                 | No  | Yes |
+| <ul>Etc...                                                                          | No  | Yes |
+
+Note that we still want to fix every bug mentioned above even if it is not a
+security vulnerability! We appreciate when issues are filed for
+non-vulnerability bugs, particularly when they come with test cases and steps to
+reproduce!
diff --git a/docs/security.md b/docs/security.md
index 8eeea3a9beb8..77c527c0a4ba 100644
--- a/docs/security.md
+++ b/docs/security.md
@@ -80,7 +80,7 @@ correct execution of WebAssembly but can help mitigate issues if bugs are found:
   of the security guarantees of WebAssembly are still upheld.
 
 * Wasmtime is in the [process of implementing control-flow-integrity
-  mechanisms][cfi-rfc] to leverage hardware state for futher guaranteeing that
+  mechanisms][cfi-rfc] to leverage hardware state for further guaranteeing that
   WebAssembly stays within its sandbox. In the event of a bug in Cranelift this
   can help mitigate the impact of where control flow can go to.
 
diff --git a/docs/stability-platform-support.md b/docs/stability-platform-support.md
index b9d8e68c559d..bdd2428158f2 100644
--- a/docs/stability-platform-support.md
+++ b/docs/stability-platform-support.md
@@ -1,139 +1,81 @@
 # Platform Support
 
-The `wasmtime` project is a configurable and lightweight runtime for WebAssembly
-which has a number of ways it can be configured. Not all features are supported
-on all platforms, but it is intended that `wasmtime` can run in some capacity on
-almost all platforms! The matrix of what's being tested, what works, and what's
-supported where is evolving over time, and this document hopes to capture a
-snapshot of what the current state of the world looks like.
-
-All features of `wasmtime` should work on the following platforms:
-
-* Linux x86\_64
-* Linux aarch64
-* macOS x86\_64
+This page is intended to give a high-level overview of Wasmtime's platform
+support along with some aspirations of Wasmtime. For more details see the
+documentation on [tiers of stability](./stability-tiers.md) which has specific
+information about what's supported in Wasmtime on a per-matrix-combination
+basis.
+
+Wasmtime strives to support hardware that anyone wants to run WebAssembly on.
+Maintainers of Wasmtime support a number of "major" platforms themselves but
+porting work may be required to support platforms that maintainers are not
+themselves familiar with. Out-of-the box Wasmtime supports:
+
+* Linux x86\_64, aarch64, s390x, and riscv64
+* macOS x86\_64, aarch64
 * Windows x86\_64
 
-For more detailed information about supported platforms, please check out the
-sections below!
+Other platforms such as Android, iOS, and the BSD family of OSes are not
+built-in yet. PRs for porting are welcome and maintainers are happy to add more
+entries to the CI matrix for these platforms.
 
-## JIT compiler support
+## Compiler Support
 
-The JIT compiler, backed by Cranelift, supports the x86\_64 and aarch64
-architectures at this time. Support for at least ARM and x86 is planned as well.
+Cranelift supports x86\_64, aarch64, s390x, and riscv64. No 32-bit platform is
+currently supported. Building a new backend for Cranelift is a relatively large
+undertaking which maintainers are willing to help with but it's recommended to
+reach out to Cranelift maintainers first to discuss this.
 
-Usage of the JIT compiler will require a host operating system which supports
-creating executable memory pages on-the-fly. In Rust terms this generally means
-that `std` needs to be supported on this platform.
+Winch supports x86\_64. The aarch64 backend is in development. Winch is built on
+Cranelift's support for emitting instructions so Winch's possible backend list
+is currently limited to what Cranelift supports.
+
+Usage of the Cranelift or Winch requires a host operating system which supports
+creating executable memory pages on-the-fly. Support for statically linking in a
+single precompiled module is not supported at this time.
+
+Both Cranelift and Winch can be used either in AOT or JIT mode. In AOT mode one
+process precompiles a module/component and then loads it into another process.
+In JIT mode this is all done within the same process.
+
+Neither Cranelift nor Winch support tiering at this time in the sense of having
+a WebAssembly module start from a Winch compilation and automatically switch to
+a Cranelift compilation. Modules are either entirely compiled with Winch or
+Cranelift.
 
 ## Interpreter support
 
 At this time `wasmtime` does not have a mode in which it simply interprets
-WebAssembly code. It is planned to add support for an interpreter, however, and
+WebAssembly code. It is desired to add support for an interpreter, however, and
 this will have minimal system dependencies. It is planned that the system will
 need to support some form of dynamic memory allocation, but other than that not
 much else will be needed.
 
-## What about `#[no_std]`?
-
-The `wasmtime` project does not currently use `#[no_std]` for its crates, but
-this is not because it won't support it! At this time we're still gathering use
-cases for for what `#[no_std]` might entail, so if you're interested in this
-we'd love to hear about your use case! Feel free to [open an
-issue](https://github.com/bytecodealliance/wasmtime/issues/new) on the
-`wasmtime` repository to discuss this.
-
-This is a common question we are asked, however, so to provide some more context
-on why Wasmtime is the way it is, here's some responses to frequent points
-raised about `#![no_std]`:
-
-* **What if my platform doesn't have `std`?** - For platforms without support
-  for the Rust standard library the JIT compiler of Wasmtime often won't run on
-  the platform as well. The JIT compiler requires `mmap` (or an equivalent), and
-  presence of `mmap` often implies presence of a libc which means Rust's `std`
-  library works.
-
-  Cargo's [`-Z build-std` feature][zbuild-std] feature is also intended to help
-  easily build the standard library for all platforms. With this feature you can
-  recompile the standard library (using Nightly Rust for now) with a [custom
-  target specification][custom-target] if necessary. Additionally the intention
-  at this time is to get `std` building for all platforms, regardless of what
-  the platform actually supports. This change is taking time to implement, but
-  [rust-lang/rust#74033] is an example of this support growing over time.
-
-  We're also interested in running Wasmtime without a JIT compiler in the
-  future, but that is not implemented at this time. Implementing this will
-  require a lot more work than tagging crates `#![no_std]`. The Wasmtime
-  developers are also very interested in supporting as many targets as possible,
-  so if Wasmtime doesn't work on your platform yet we'd love to learn why and
-  what we can do to support that platform, but the conversation here is
-  typically more nuanced than simply making `wasmtime` compile without `std`.
-
-* **Doesn't `#![no_std]` have smaller binary sizes?** - There's a lot of factors
-  that affect binary size in Rust. Compilation options are a huge one but beyond
-  that idioms and libraries linked matter quite a lot as well. Code is not
-  inherently large when using `std` instead of `core`, it's just that often code
-  using `std` has more dependencies (like `std::thread`) which requires code to
-  bind. Code size improvements can be made to code using `std` and `core`
-  equally, and switching to `#![no_std]` is not a silver bullet for compile
-  sizes.
-
-* **The patch to switch to `#![no_std]` is small, why not accept it?** - PRs to
-  switch to `#![no_std]` are often relatively small or don't impact too many
-  parts of the system. There's a lot more to developing a `#![no_std]`
-  WebAssembly runtime than switching a few crates, however. Maintaining a
-  `#![no_std]` library over time has a number of costs associated with it:
-
-  * Rust has no stable way to diagnose `no_std` errors in an otherwise `std`
-    build, which means that to support this feature it must be tested on CI with
-    a `no_std` target. This is costly in terms of CI time, CI maintenance, and
-    developers having to do extra builds to avoid CI errors. Note that this
-    isn't *more* costly than any other platform supported by Wasmtime, but it's
-    a cost nonetheless.
-
-  * Idioms in `#![no_std]` are quite different than normal Rust code. You'll
-    import from different crates (`core` instead of `std`) and data structures
-    have to all be manually imported from `alloc`. These idioms are difficult to
-    learn for newcomers to the project and are not well documented in the
-    ecosystem. This cost of development and maintenance is not unique to
-    Wasmtime but in general affects the `#![no_std]` ecosystem at large,
-    unfortunately.
-
-  * Currently Wasmtime does not have a target use case which requires
-    `#![no_std]` support, so it's hard to justify these costs of development.
-    We're very interested in supporting as many use cases and targets as
-    possible, but the decision to support a target needs to take into account
-    the costs associated so we can plan accordingly. Effectively we need to have
-    a goal in mind instead of taking on the costs of `#![no_std]` blindly.
-
-  * At this time it's not clear whether `#![no_std]` will be needed long-term,
-    so eating short-term costs may not pay off in the long run. Features like
-    Cargo's [`-Z build-std`][zbuild-std] may mean that `#![no_std]` is less and
-    less necessary over time.
-
-* **How can Wasmtime support `#![no_std]` if it uses X?** - Wasmtime as-is today
-  is not suitable for many `#![no_std]` contexts. For example it might use
-  `mmap` for allocating JIT code memory, leverage threads for caching, or use
-  thread locals when calling into JIT code. These features are difficult to
-  support in their full fidelity on all platforms, but the Wasmtime developers
-  are very much aware of this! Wasmtime is intended to be configurable where
-  many of these features are compile-time or runtime options. For example caches
-  can be disabled, JITs can be removed and replaced with interpreters, or users
-  could provide a callback to allocate memory instead of using the OS.
-  This is sort of a long-winded way of saying that Wasmtime on the surface may
-  today look like it won't support `#![no_std]`, but this is almost always
-  simply a matter of time and development priorities rather than a fundamental
-  reason why Wasmtime *couldn't* support `#![no_std]`.
-
-Note that at this time these guidelines apply not only to Wasmtime but also to
-some of its dependencies developed by the Bytecode Alliance such as the
-[wasm-tools repository](https://github.com/bytecodealliance/wasm-tools). These
-projects don't have the same runtime requirements as Wasmtime (e.g. `wasmparser`
-doesn't need `mmap`), but we're following the same guidelines above at this
-time. Patches to add `#![no_std]`, while possibly small, incur many of the same
-costs and also have an unclear longevity as features like [`-Z
-build-std`][zbuild-std] evolve.
-
-[zbuild-std]: https://doc.rust-lang.org/nightly/cargo/reference/unstable.html#build-std
-[custom-target]: https://doc.rust-lang.org/rustc/targets/custom.html
-[rust-lang/rust#74033]: https://github.com/rust-lang/rust/pull/74033
+## Support for `#![no_std]`
+
+The `wasmtime` crate supports being build on no\_std platforms in Rust, but
+only for a subset of its compile-time Cargo features. Currently supported
+Cargo features are:
+
+* `runtime`
+* `gc`
+* `component-model`
+
+This notably does not include the `default` feature which means that when
+depending on Wasmtime you'll need to specify `default-features = false`. This
+also notably does not include Cranelift or Winch at this time meaning that
+no\_std platforms must be used in AOT mode where the module is precompiled
+elsewhere.
+
+Wasmtime's support for no\_std requires the embedder to implement the equivalent
+of a C header file to indicate how to perform basic OS operations such as
+allocating virtual memory. This API can be found as `wasmtime-platform.h` in
+Wasmtime's release artifacts or at
+`examples/min-platform/embedding/wasmtime-platform.h` in the source tree. Note
+that this API is not guaranteed to be stable at this time, it'll need to be
+updated when Wasmtime is updated.
+
+Wasmtime's runtime will use the symbols defined in this file meaning that if
+they're not defined then a link-time error will be generated. Embedders are
+required to implement these functions in accordance with their documentation to
+enable Wasmtime to run on custom platforms.
diff --git a/docs/stability-tiers.md b/docs/stability-tiers.md
index 19c052919241..7a9a20465ddf 100644
--- a/docs/stability-tiers.md
+++ b/docs/stability-tiers.md
@@ -25,8 +25,7 @@ For explanations of what each tier means see below.
 | Target               | `x86_64-apple-darwin`                      |
 | Target               | `x86_64-pc-windows-msvc`                   |
 | Target               | `x86_64-unknown-linux-gnu`                 |
-| WASI Proposal        | `wasi_snapshot_preview1`                   |
-| WASI Proposal        | `wasi_unstable`                            |
+| Compiler Backend     | Cranelift                                  |
 | WebAssembly Proposal | [`mutable-globals`]                        |
 | WebAssembly Proposal | [`sign-extension-ops`]                     |
 | WebAssembly Proposal | [`nontrapping-float-to-int-conversion`]    |
@@ -34,6 +33,19 @@ For explanations of what each tier means see below.
 | WebAssembly Proposal | [`bulk-memory`]                            |
 | WebAssembly Proposal | [`reference-types`]                        |
 | WebAssembly Proposal | [`simd`]                                   |
+| WebAssembly Proposal | [`component-model`]                        |
+| WebAssembly Proposal | [`relaxed-simd`]                           |
+| WebAssembly Proposal | [`multi-memory`]                           |
+| WebAssembly Proposal | [`threads`]                                |
+| WebAssembly Proposal | [`tail-call`]                              |
+| WASI Proposal        | [`wasi-io`]                                |
+| WASI Proposal        | [`wasi-clocks`]                            |
+| WASI Proposal        | [`wasi-filesystem`]                        |
+| WASI Proposal        | [`wasi-random`]                            |
+| WASI Proposal        | [`wasi-sockets`]                           |
+| WASI Proposal        | [`wasi-http`]                              |
+| WASI Proposal        | `wasi_snapshot_preview1`                   |
+| WASI Proposal        | `wasi_unstable`                            |
 
 [`mutable-globals`]: https://github.com/WebAssembly/mutable-global/blob/master/proposals/mutable-global/Overview.md
 [`sign-extension-ops`]: https://github.com/WebAssembly/spec/blob/master/proposals/sign-extension-ops/Overview.md
@@ -42,58 +54,58 @@ For explanations of what each tier means see below.
 [`bulk-memory`]: https://github.com/WebAssembly/bulk-memory-operations/blob/master/proposals/bulk-memory-operations/Overview.md
 [`reference-types`]: https://github.com/WebAssembly/reference-types/blob/master/proposals/reference-types/Overview.md
 [`simd`]: https://github.com/WebAssembly/simd/blob/master/proposals/simd/SIMD.md
+[`wasi-clocks`]: https://github.com/WebAssembly/wasi-clocks
+[`wasi-filesystem`]: https://github.com/WebAssembly/wasi-filesystem
+[`wasi-io`]: https://github.com/WebAssembly/wasi-io
+[`wasi-random`]: https://github.com/WebAssembly/wasi-random
+[`wasi-sockets`]: https://github.com/WebAssembly/wasi-sockets
+[`wasi-http`]: https://github.com/WebAssembly/wasi-http
+[`tail-call`]: https://github.com/WebAssembly/tail-call/blob/main/proposals/tail-call/Overview.md
 
 #### Tier 2
 
 | Category             | Description                | Missing Tier 1 Requirements |
 |----------------------|----------------------------|-----------------------------|
 | Target               | `aarch64-unknown-linux-gnu`| Continuous fuzzing          |
+| Target               | `aarch64-apple-darwin`     | Continuous fuzzing          |
 | Target               | `s390x-unknown-linux-gnu`  | Continuous fuzzing          |
 | Target               | `x86_64-pc-windows-gnu`    | Clear owner of the target   |
-| WebAssembly Proposal | [`memory64`]]              | Unstable wasm proposal      |
-| WebAssembly Proposal | [`multi-memory`]           | Unstable wasm proposal      |
-| WebAssembly Proposal | [`threads`]                | Unstable wasm proposal      |
-| WebAssembly Proposal | [`component-model`]        | Unstable wasm proposal      |
-| WebAssembly Proposal | [`tail-call`]              | Unstable wasm proposal, performance work |
-| WebAssembly Proposal | [`relaxed-simd`]           | Unstable wasm proposal      |
+| Target               | Support for `#![no_std]`   | Support beyond CI checks    |
+| Compiler Backend     | Winch on x86\_64           | Consenus on moving to Tier 1 |
+| WebAssembly Proposal | [`memory64`]               | Unstable wasm proposal      |
 | WebAssembly Proposal | [`function-references`]    | Unstable wasm proposal      |
-| WASI Proposal        | [`wasi-io`]                | Unstable WASI proposal      |
-| WASI Proposal        | [`wasi-clocks`]            | Unstable WASI proposal      |
-| WASI Proposal        | [`wasi-filesystem`]        | Unstable WASI proposal      |
-| WASI Proposal        | [`wasi-random`]            | Unstable WASI proposal      |
-| WASI Proposal        | [`wasi-poll`]              | Unstable WASI proposal      |
 
 [`memory64`]: https://github.com/WebAssembly/memory64/blob/master/proposals/memory64/Overview.md
 [`multi-memory`]: https://github.com/WebAssembly/multi-memory/blob/master/proposals/multi-memory/Overview.md
 [`threads`]: https://github.com/WebAssembly/threads/blob/master/proposals/threads/Overview.md
 [`component-model`]: https://github.com/WebAssembly/component-model/blob/main/design/mvp/Explainer.md
-[`tail-call`]: https://github.com/WebAssembly/tail-call/blob/main/proposals/tail-call/Overview.md
 [`relaxed-simd`]: https://github.com/WebAssembly/relaxed-simd/blob/main/proposals/relaxed-simd/Overview.md
 [`function-references`]: https://github.com/WebAssembly/function-references/blob/main/proposals/function-references/Overview.md
-[`wasi-clocks`]: https://github.com/WebAssembly/wasi-clocks
-[`wasi-filesystem`]: https://github.com/WebAssembly/wasi-filesystem
-[`wasi-io`]: https://github.com/WebAssembly/wasi-io
-[`wasi-random`]: https://github.com/WebAssembly/wasi-random
-[`wasi-poll`]: https://github.com/WebAssembly/wasi-poll
 
 #### Tier 3
 
 | Category             | Description                       | Missing Tier 2 Requirements |
 |----------------------|-----------------------------------|-----------------------------|
-| Target               | `aarch64-apple-darwin`            | CI testing                  |
 | Target               | `aarch64-pc-windows-msvc`         | CI testing, unwinding, full-time maintainer |
 | Target               | `riscv64gc-unknown-linux-gnu`     | full-time maintainer        |
+| Target               | `wasm32-wasip1` [^3]              | Supported but not tested    |
+| Target               | `aarch64-linux-android`           | CI testing, full-time maintainer |
+| Target               | `x86_64-linux-android`            | CI testing, full-time maintainer |
+| Target               | `x86_64-unknown-linux-musl` [^4]  | CI testing, full-time maintainer |
+| Compiler Backend     | Winch on aarch64                  | finished implementation     |
+| WebAssembly Proposal | [`gc`]                            | Complete implementation     |
 | WASI Proposal        | [`wasi-nn`]                       | More expansive CI testing   |
 | WASI Proposal        | [`wasi-threads`]                  | More CI, unstable proposal  |
-| WASI Proposal        | [`wasi-sockets`]                  | Complete implementation     |
-| WASI Proposal        | [`wasi-http`]                     | Complete implementation     |
+| WASI Proposal        | [`wasi-runtime-config`]           | unstable proposal           |
+| WASI Proposal        | [`wasi-keyvalue`]                 | unstable proposal           |
 | *misc*               | Non-Wasmtime Cranelift usage [^1] | CI testing, full-time maintainer |
 | *misc*               | DWARF debugging [^2]              | CI testing, full-time maintainer, improved quality |
 
-[`wasi-sockets`]: https://github.com/WebAssembly/wasi-sockets
 [`wasi-nn`]: https://github.com/WebAssembly/wasi-nn
 [`wasi-threads`]: https://github.com/WebAssembly/wasi-threads
-[`wasi-http`]: https://github.com/WebAssembly/wasi-http
+[`wasi-runtime-config`]: https://github.com/WebAssembly/wasi-runtime-config
+[`wasi-keyvalue`]: https://github.com/WebAssembly/wasi-keyvalue
+[`gc`]: https://github.com/WebAssembly/gc
 
 [^1]: This is intended to encompass features that Cranelift supports as a
 general-purpose code generator such as integer value types other than `i32` and
@@ -108,6 +120,15 @@ support is currently best-effort. Additionally there are known shortcomings
 and bugs. At this time there's no developer time to improve the situation here
 as well.
 
+[^3]: Wasmtime's `cranelift` and `winch` features can be compiled to WebAssembly
+but not the `runtime` feature at this time. This means that
+Wasmtime-compiled-to-wasm can itself compile wasm but cannot execute wasm.
+
+[^4]: Binary artifacts for MUSL are dynamically linked, not statically
+linked, meaning that they are not suitable for "run on any linux distribution"
+style use cases. Wasmtime does not have static binary artifacts at this time and
+that will require building from source.
+
 #### Unsupported features and platforms
 
 While this is not an exhaustive list, Wasmtime does not currently have support
@@ -118,7 +139,6 @@ features to figure out how best to implement them and at least move them to Tier
 3 above.
 
 * Target: ARM 32-bit
-* Target: WebAssembly (compiling Wasmtime to WebAssembly itself)
 * Target: [FreeBSD](https://github.com/bytecodealliance/wasmtime/issues/5499)
 * Target: [NetBSD/OpenBSD](https://github.com/bytecodealliance/wasmtime/issues/6962)
 * Target: [i686 (32-bit Intel targets)](https://github.com/bytecodealliance/wasmtime/issues/1980)
@@ -131,7 +151,6 @@ features to figure out how best to implement them and at least move them to Tier
 * [WebAssembly proposal: `exception-handling`](https://github.com/WebAssembly/exception-handling)
 * [WebAssembly proposal: `extended-const`](https://github.com/WebAssembly/extended-const)
 * [WebAssembly proposal: `flexible-vectors`](https://github.com/WebAssembly/flexible-vectors)
-* [WebAssembly proposal: `gc`](https://github.com/WebAssembly/gc)
 * [WebAssembly proposal: `memory-control`](https://github.com/WebAssembly/memory-control)
 * [WebAssembly proposal: `stack-switching`](https://github.com/WebAssembly/stack-switching)
 * [WASI proposal: `proxy-wasm`](https://github.com/proxy-wasm/spec)
@@ -140,11 +159,9 @@ features to figure out how best to implement them and at least move them to Tier
 * [WASI proposal: `wasi-data`](https://github.com/WebAssembly/wasi-data)
 * [WASI proposal: `wasi-distributed-lock-service`](https://github.com/WebAssembly/wasi-distributed-lock-service)
 * [WASI proposal: `wasi-grpc`](https://github.com/WebAssembly/wasi-grpc)
-* [WASI proposal: `wasi-kv-store`](https://github.com/WebAssembly/wasi-kv-store)
 * [WASI proposal: `wasi-message-queue`](https://github.com/WebAssembly/wasi-message-queue)
 * [WASI proposal: `wasi-parallel`](https://github.com/WebAssembly/wasi-parallel)
 * [WASI proposal: `wasi-pubsub`](https://github.com/WebAssembly/wasi-pubsub)
-* [WASI proposal: `wasi-runtime-config`](https://github.com/WebAssembly/wasi-runtime-config)
 * [WASI proposal: `wasi-sql`](https://github.com/WebAssembly/wasi-sql)
 * [WASI proposal: `wasi-url`](https://github.com/WebAssembly/wasi-url)
 
diff --git a/docs/wmemcheck.md b/docs/wmemcheck.md
index 76d731f2cce7..6869fa04a94f 100644
--- a/docs/wmemcheck.md
+++ b/docs/wmemcheck.md
@@ -10,8 +10,8 @@ How to use:
 
 1. When building Wasmtime, add the CLI flag "--features wmemcheck" to compile with wmemcheck configured.
     > cargo build --features wmemcheck
-2. When running your wasm module, add the CLI flag "--wmemcheck".
-    > wasmtime run --wmemcheck test.wasm
+2. When running your wasm module, add the CLI flag "-W wmemcheck".
+    > wasmtime run -W wmemcheck test.wasm
 
 If your program executes an invalid operation (load or store to non-allocated
 address, double-free, or an internal error in malloc that allocates the same
@@ -37,7 +37,7 @@ $ /opt/wasi-sdk/bin/clang -o test.wasm test.c
 you can observe the memory checker working like so:
 
 ```plain
-$ wasmtime run --wmemcheck ./test.wasm
+$ wasmtime run -W wmemcheck ./test.wasm
 Error: failed to run main module `./test.wasm`
 
 Caused by:
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index 32343ddae679..84a02e46fb56 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -22,6 +22,9 @@ function(CREATE_TARGET TARGET TARGET_PATH)
 
 	target_include_directories(wasmtime-${TARGET} PUBLIC wasmtime)
 	target_link_libraries(wasmtime-${TARGET} PUBLIC wasmtime)
+	if(APPLE)
+		target_link_libraries(wasmtime-${TARGET} PRIVATE "-framework CoreFoundation")
+	endif()
 	add_test(NAME ${TARGET}-c COMMAND $<TARGET_FILE:wasmtime-${TARGET}> WORKING_DIRECTORY ../..)
 endfunction()
 
@@ -40,6 +43,7 @@ endfunction()
 enable_testing()
 
 # Add all examples
+create_target(anyref anyref.c)
 create_target(async async.cpp)
 create_target(externref externref.c)
 create_target(fib-debug fib-debug/main.c)
@@ -56,9 +60,11 @@ create_target(threads threads.c)
 create_target(wasi wasi/main.c)
 
 # Add rust tests
+create_rust_test(anyref)
 create_rust_wasm(fib-debug wasm32-unknown-unknown)
-create_rust_wasm(tokio wasm32-wasi)
-create_rust_wasm(wasi wasm32-wasi)
+create_rust_wasm(tokio wasm32-wasip1)
+create_rust_wasm(wasi wasm32-wasip1)
+create_rust_wasm(component wasm32-unknown-unknown)
 create_rust_test(epochs)
 create_rust_test(externref)
 create_rust_test(fib-debug)
@@ -73,4 +79,5 @@ create_rust_test(multimemory)
 create_rust_test(serialize)
 create_rust_test(threads)
 create_rust_test(wasi)
-create_rust_test(tokio wasmtime-wasi/tokio)
+create_rust_test(tokio wasi-common/tokio)
+create_rust_test(component)
diff --git a/examples/anyref.c b/examples/anyref.c
new file mode 100644
index 000000000000..cf0a67f3bf8e
--- /dev/null
+++ b/examples/anyref.c
@@ -0,0 +1,228 @@
+/*
+Example of using `anyref` values.
+
+You can compile and run this example on Linux with:
+
+   cargo build --release -p wasmtime-c-api
+   cc examples/anyref.c \
+       -I crates/c-api/include \
+       -I crates/c-api/wasm-c-api/include \
+       target/release/libwasmtime.a \
+       -lpthread -ldl -lm \
+       -o anyref
+   ./anyref
+
+Note that on Windows and macOS the command will be similar, but you'll need
+to tweak the `-lpthread` and such annotations as well as the name of the
+`libwasmtime.a` file on Windows.
+
+You can also build using cmake:
+
+mkdir build && cd build && cmake .. && \
+  cmake --build . --target wasmtime-anyref
+*/
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <wasm.h>
+#include <wasmtime.h>
+
+static void exit_with_error(const char *message, wasmtime_error_t *error,
+                            wasm_trap_t *trap);
+
+int main() {
+  bool ok = true;
+  // Create a new configuration with Wasm GC enabled.
+  printf("Initializing...\n");
+  wasm_config_t *config = wasm_config_new();
+  assert(config != NULL);
+  wasmtime_config_wasm_reference_types_set(config, true);
+  wasmtime_config_wasm_function_references_set(config, true);
+  wasmtime_config_wasm_gc_set(config, true);
+
+  // Create an *engine*, which is a compilation context, with our configured
+  // options.
+  wasm_engine_t *engine = wasm_engine_new_with_config(config);
+  assert(engine != NULL);
+
+  // With an engine we can create a *store* which is a group of wasm instances
+  // that can interact with each other.
+  wasmtime_store_t *store = wasmtime_store_new(engine, NULL, NULL);
+  assert(store != NULL);
+  wasmtime_context_t *context = wasmtime_store_context(store);
+
+  // Read our input file, which in this case is a wasm text file.
+  FILE *file = fopen("examples/anyref.wat", "r");
+  assert(file != NULL);
+  fseek(file, 0L, SEEK_END);
+  size_t file_size = ftell(file);
+  fseek(file, 0L, SEEK_SET);
+  wasm_byte_vec_t wat;
+  wasm_byte_vec_new_uninitialized(&wat, file_size);
+  if (fread(wat.data, file_size, 1, file) != 1) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
+  fclose(file);
+
+  // Parse the wat into the binary wasm format
+  wasm_byte_vec_t wasm;
+  wasmtime_error_t *error = wasmtime_wat2wasm(wat.data, wat.size, &wasm);
+  if (error != NULL)
+    exit_with_error("failed to parse wat", error, NULL);
+  wasm_byte_vec_delete(&wat);
+
+  // Now that we've got our binary webassembly we can compile our module.
+  printf("Compiling module...\n");
+  wasmtime_module_t *module = NULL;
+  error = wasmtime_module_new(engine, (uint8_t *)wasm.data, wasm.size, &module);
+  wasm_byte_vec_delete(&wasm);
+  if (error != NULL)
+    exit_with_error("failed to compile module", error, NULL);
+
+  // Instantiate the module.
+  printf("Instantiating module...\n");
+  wasm_trap_t *trap = NULL;
+  wasmtime_instance_t instance;
+  error = wasmtime_instance_new(context, module, NULL, 0, &instance, &trap);
+  if (error != NULL || trap != NULL)
+    exit_with_error("failed to instantiate", error, trap);
+
+  printf("Creating new `anyref` from i31...\n");
+
+  // Create a new `anyref` value from an i31 (`i31ref` is a subtype of
+  // `anyref`).
+  wasmtime_anyref_t anyref;
+  wasmtime_anyref_from_i31(context, 1234, &anyref);
+  assert(!wasmtime_anyref_is_null(&anyref));
+
+  // The `anyref`'s inner i31 value should be 1234.
+  uint32_t i31val = 0;
+  bool is_i31 = wasmtime_anyref_i31_get_u(context, &anyref, &i31val);
+  assert(is_i31);
+  assert(i31val == 1234);
+
+  printf("Touching `anyref` table...\n");
+
+  wasmtime_extern_t item;
+
+  // Lookup the `table` export.
+  ok = wasmtime_instance_export_get(context, &instance, "table",
+                                    strlen("table"), &item);
+  assert(ok);
+  assert(item.kind == WASMTIME_EXTERN_TABLE);
+
+  // Set `table[3]` to our `anyref`.
+  wasmtime_val_t anyref_val;
+  anyref_val.kind = WASMTIME_ANYREF;
+  anyref_val.of.anyref = anyref;
+  error = wasmtime_table_set(context, &item.of.table, 3, &anyref_val);
+  if (error != NULL)
+    exit_with_error("failed to set table", error, NULL);
+
+  // `table[3]` should now be our `anyref`.
+  wasmtime_val_t elem;
+  ok = wasmtime_table_get(context, &item.of.table, 3, &elem);
+  assert(ok);
+  assert(elem.kind == WASMTIME_ANYREF);
+  is_i31 = false;
+  i31val = 0;
+  is_i31 = wasmtime_anyref_i31_get_u(context, &elem.of.anyref, &i31val);
+  assert(is_i31);
+  assert(i31val == 1234);
+  wasmtime_val_unroot(context, &elem);
+
+  printf("Touching `anyref` global...\n");
+
+  // Lookup the `global` export.
+  ok = wasmtime_instance_export_get(context, &instance, "global",
+                                    strlen("global"), &item);
+  assert(ok);
+  assert(item.kind == WASMTIME_EXTERN_GLOBAL);
+
+  // Set the global to our `anyref`.
+  error = wasmtime_global_set(context, &item.of.global, &anyref_val);
+  if (error != NULL)
+    exit_with_error("failed to set global", error, NULL);
+
+  // Get the global, and it should return our `anyref` again.
+  wasmtime_val_t global_val;
+  wasmtime_global_get(context, &item.of.global, &global_val);
+  assert(global_val.kind == WASMTIME_ANYREF);
+  is_i31 = false;
+  i31val = 0;
+  is_i31 = wasmtime_anyref_i31_get_u(context, &global_val.of.anyref, &i31val);
+  assert(is_i31);
+  assert(i31val == 1234);
+  wasmtime_val_unroot(context, &global_val);
+
+  printf("Passing `anyref` into func...\n");
+
+  // Lookup the `take_anyref` export.
+  ok = wasmtime_instance_export_get(context, &instance, "take_anyref",
+                                    strlen("take_anyref"), &item);
+  assert(ok);
+  assert(item.kind == WASMTIME_EXTERN_FUNC);
+
+  // And call it!
+  error = wasmtime_func_call(context, &item.of.func, &anyref_val, 1, NULL, 0,
+                             &trap);
+  if (error != NULL || trap != NULL)
+    exit_with_error("failed to call function", error, trap);
+
+  printf("Getting `anyref` from func...\n");
+
+  // Lookup the `return_anyref` export.
+  ok = wasmtime_instance_export_get(context, &instance, "return_anyref",
+                                    strlen("return_anyref"), &item);
+  assert(ok);
+  assert(item.kind == WASMTIME_EXTERN_FUNC);
+
+  // And call it!
+  wasmtime_val_t results[1];
+  error =
+      wasmtime_func_call(context, &item.of.func, NULL, 0, results, 1, &trap);
+  if (error != NULL || trap != NULL)
+    exit_with_error("failed to call function", error, trap);
+
+  // `return_anyfunc` returns an `i31ref` that wraps `42`.
+  assert(results[0].kind == WASMTIME_ANYREF);
+  is_i31 = false;
+  i31val = 0;
+  is_i31 = wasmtime_anyref_i31_get_u(context, &results[0].of.anyref, &i31val);
+  assert(is_i31);
+  assert(i31val == 42);
+  wasmtime_val_unroot(context, &results[0]);
+  wasmtime_val_unroot(context, &anyref_val);
+
+  // We can GC any now-unused references to our anyref that the store is
+  // holding.
+  printf("GCing within the store...\n");
+  wasmtime_context_gc(context);
+
+  // Clean up after ourselves at this point
+  printf("All finished!\n");
+
+  wasmtime_store_delete(store);
+  wasmtime_module_delete(module);
+  wasm_engine_delete(engine);
+  return 0;
+}
+
+static void exit_with_error(const char *message, wasmtime_error_t *error,
+                            wasm_trap_t *trap) {
+  fprintf(stderr, "error: %s\n", message);
+  wasm_byte_vec_t error_message;
+  if (error != NULL) {
+    wasmtime_error_message(error, &error_message);
+    wasmtime_error_delete(error);
+  } else {
+    wasm_trap_message(trap, &error_message);
+    wasm_trap_delete(trap);
+  }
+  fprintf(stderr, "%.*s\n", (int)error_message.size, error_message.data);
+  wasm_byte_vec_delete(&error_message);
+  exit(1);
+}
diff --git a/examples/anyref.rs b/examples/anyref.rs
new file mode 100644
index 000000000000..74b69d27981f
--- /dev/null
+++ b/examples/anyref.rs
@@ -0,0 +1,61 @@
+//! Small example of how to use `anyref`s.
+
+// You can execute this example with `cargo run --example anyref`
+
+use wasmtime::*;
+
+fn main() -> Result<()> {
+    println!("Initializing...");
+    let mut config = Config::new();
+    config.wasm_reference_types(true);
+    config.wasm_function_references(true);
+    config.wasm_gc(true);
+    let engine = Engine::new(&config)?;
+    let mut store = Store::new(&engine, ());
+
+    println!("Compiling module...");
+    let module = Module::from_file(&engine, "examples/anyref.wat")?;
+
+    println!("Instantiating module...");
+    let instance = Instance::new(&mut store, &module, &[])?;
+
+    println!("Creating new `anyref` from i31...");
+    let i31 = I31::wrapping_u32(1234);
+    let anyref = AnyRef::from_i31(&mut store, i31);
+    assert!(anyref.is_i31(&store)?);
+    assert_eq!(anyref.as_i31(&store)?, Some(i31));
+
+    println!("Touching `anyref` table...");
+    let table = instance.get_table(&mut store, "table").unwrap();
+    table.set(&mut store, 3, anyref.into())?;
+    let elem = table
+        .get(&mut store, 3)
+        .unwrap() // assert in bounds
+        .unwrap_any() // assert it's an anyref table
+        .copied()
+        .unwrap(); // assert the anyref isn't null
+    assert!(Rooted::ref_eq(&store, &elem, &anyref)?);
+
+    println!("Touching `anyref` global...");
+    let global = instance.get_global(&mut store, "global").unwrap();
+    global.set(&mut store, Some(anyref).into())?;
+    let global_val = global.get(&mut store).unwrap_anyref().copied().unwrap();
+    assert!(Rooted::ref_eq(&store, &global_val, &anyref)?);
+
+    println!("Passing `anyref` into func...");
+    let func = instance.get_typed_func::<Option<Rooted<AnyRef>>, ()>(&mut store, "take_anyref")?;
+    func.call(&mut store, Some(anyref))?;
+
+    println!("Getting `anyref` from func...");
+    let func =
+        instance.get_typed_func::<(), Option<Rooted<AnyRef>>>(&mut store, "return_anyref")?;
+    let ret = func.call(&mut store, ())?;
+    assert!(ret.is_some());
+    assert_eq!(ret.unwrap().unwrap_i31(&store)?, I31::wrapping_u32(42));
+
+    println!("GCing within the store...");
+    store.gc();
+
+    println!("Done.");
+    Ok(())
+}
diff --git a/examples/anyref.wat b/examples/anyref.wat
new file mode 100644
index 000000000000..23badab77aae
--- /dev/null
+++ b/examples/anyref.wat
@@ -0,0 +1,14 @@
+(module
+  (table $table (export "table") 10 anyref)
+
+  (global $global (export "global") (mut anyref) (ref.null any))
+
+  (func (export "take_anyref") (param anyref)
+    nop
+  )
+
+  (func (export "return_anyref") (result anyref)
+    i32.const 42
+    ref.i31
+  )
+)
diff --git a/examples/async.cpp b/examples/async.cpp
index 2656e73d1d91..523f327f963f 100644
--- a/examples/async.cpp
+++ b/examples/async.cpp
@@ -7,7 +7,6 @@ You can compile and run this example on Linux with:
    cargo build --release -p wasmtime-c-api
    c++ examples/async.cpp \
        -I crates/c-api/include \
-       -I crates/c-api/wasm-c-api/include \
        target/release/libwasmtime.a \
        -std=c++11 \
        -lpthread -ldl -lm \
@@ -166,7 +165,7 @@ int main() {
   // A thread that will async perform host function calls.
   std::thread printer_thread([]() {
     int32_t value_to_print = printer_state.get_value_to_print();
-    std::cout << "recieved value to print!" << std::endl;
+    std::cout << "received value to print!" << std::endl;
     std::this_thread::sleep_for(std::chrono::milliseconds(500));
     std::cout << "printing: " << value_to_print << std::endl;
     std::this_thread::sleep_for(std::chrono::milliseconds(500));
@@ -181,9 +180,8 @@ int main() {
   // This pointer is unowned.
   auto *context = wasmtime_store_context(store.get());
   // Configure the store to periodically yield control
-  wasmtime_context_out_of_fuel_async_yield(context,
-                                           /*injection_count=*/10,
-                                           /*fuel_to_inject=*/10000);
+  wasmtime_context_set_fuel(context, 100000);
+  wasmtime_context_fuel_async_yield_interval(context, /*interval=*/10000);
 
   auto compiled_module =
       compile_wat_module_from_file(engine.get(), "examples/async.wat");
@@ -206,13 +204,13 @@ int main() {
       host_func_name.data(), host_func_name.size(), functype.get(),
       [](void *, wasmtime_caller_t *, const wasmtime_val_t *args, size_t,
          wasmtime_val_t *, size_t, wasm_trap_t **trap_ret,
-         wasmtime_async_continuation_t *continutation_ret) {
+         wasmtime_async_continuation_t *continuation_ret) {
         std::cout << "invoking async host function" << std::endl;
         printer_state.set_value_to_print(args[0].of.i32);
 
-        continutation_ret->callback = &poll_print_finished_state;
-        continutation_ret->env = new async_call_env{trap_ret};
-        continutation_ret->finalizer = [](void *env) {
+        continuation_ret->callback = &poll_print_finished_state;
+        continuation_ret->env = new async_call_env{trap_ret};
+        continuation_ret->finalizer = [](void *env) {
           std::cout << "deleting async_call_env" << std::endl;
           delete static_cast<async_call_env *>(env);
         };
diff --git a/examples/component/convert.wit b/examples/component/convert.wit
new file mode 100644
index 000000000000..1a10ce5be4f2
--- /dev/null
+++ b/examples/component/convert.wit
@@ -0,0 +1,11 @@
+package local:demo;
+
+world convert {
+    /// This interface needs to be provided by the host
+    import host: interface {
+      /// Example function that does a simple a × b operation
+      multiply: func(a: float32, b: float32) -> float32;
+    }
+    /// Exported function for computing: (°C × 9/5) + 32 = °F
+    export convert-celsius-to-fahrenheit: func(x: float32) -> float32;
+}
diff --git a/examples/component/main.rs b/examples/component/main.rs
new file mode 100644
index 000000000000..c26e70b57607
--- /dev/null
+++ b/examples/component/main.rs
@@ -0,0 +1,62 @@
+use anyhow::Context;
+use std::{fs, path::Path};
+
+use wasmtime::{
+    component::{bindgen, Component, Linker},
+    Config, Engine, Result, Store,
+};
+
+// Generate bindings of the guest and host components.
+bindgen!("convert" in "./examples/component/convert.wit");
+
+struct HostComponent;
+
+// Implementation of the host interface defined in the wit file.
+impl host::Host for HostComponent {
+    fn multiply(&mut self, a: f32, b: f32) -> f32 {
+        a * b
+    }
+}
+
+struct MyState {
+    host: HostComponent,
+}
+
+/// This function is only needed until rust can natively output a component.
+///
+/// Generally embeddings should not be expected to do this programmatically, but instead
+/// language specific tooling should be used, for example in Rust `cargo component`
+/// is a good way of doing that: https://github.com/bytecodealliance/cargo-component
+///
+/// In this example we convert the code here to simplify the testing process and build system.
+fn convert_to_component(path: impl AsRef<Path>) -> Result<Vec<u8>> {
+    let bytes = &fs::read(&path).context("failed to read input file")?;
+    wit_component::ComponentEncoder::default()
+        .module(&bytes)?
+        .encode()
+}
+
+fn main() -> Result<()> {
+    // Create an engine with the component model enabled (disabled by default).
+    let engine = Engine::new(Config::new().wasm_component_model(true))?;
+
+    // NOTE: The wasm32-unknown-unknown target is used here for simplicity, real world use cases
+    // should probably use the wasm32-wasip1 target, and enable wasi preview2 within the component
+    // model.
+    let component = convert_to_component("target/wasm32-unknown-unknown/debug/guest.wasm")?;
+
+    // Create our component and call our generated host function.
+    let component = Component::from_binary(&engine, &component)?;
+    let mut store = Store::new(
+        &engine,
+        MyState {
+            host: HostComponent {},
+        },
+    );
+    let mut linker = Linker::new(&engine);
+    host::add_to_linker(&mut linker, |state: &mut MyState| &mut state.host)?;
+    let convert = Convert::instantiate(&mut store, &component, &linker)?;
+    let result = convert.call_convert_celsius_to_fahrenheit(&mut store, 23.4)?;
+    println!("Converted to: {result:?}");
+    Ok(())
+}
diff --git a/examples/component/wasm/Cargo.toml b/examples/component/wasm/Cargo.toml
new file mode 100644
index 000000000000..d3380f5120a3
--- /dev/null
+++ b/examples/component/wasm/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "example-component-wasm"
+version = "0.0.0"
+authors = ["The Wasmtime Project Developers"]
+edition = "2021"
+publish = false
+
+[dependencies]
+wit-bindgen = { workspace = true, default-features = true }
+
+[lib]
+path = "guest.rs"
+name = "guest"
+crate-type = ["cdylib"]
diff --git a/examples/component/wasm/guest.rs b/examples/component/wasm/guest.rs
new file mode 100644
index 000000000000..8af47944470f
--- /dev/null
+++ b/examples/component/wasm/guest.rs
@@ -0,0 +1,16 @@
+// Use wit_bindgen to generate the bindings from the component model to Rust.
+// For more information see: https://github.com/bytecodealliance/wit-bindgen/
+wit_bindgen::generate!({
+    path: "..",
+    world: "convert",
+});
+
+struct GuestComponent;
+
+export!(GuestComponent);
+
+impl Guest for GuestComponent {
+    fn convert_celsius_to_fahrenheit(x: f32) -> f32 {
+        host::multiply(x, 1.8) + 32.0
+    }
+}
diff --git a/examples/coredump.rs b/examples/coredump.rs
index cd4405476696..59df7759c3a9 100644
--- a/examples/coredump.rs
+++ b/examples/coredump.rs
@@ -3,7 +3,6 @@
 
 // You can execute this example with `cargo run --example coredump`.
 
-use anyhow::Result;
 use wasmtime::*;
 
 fn main() -> Result<()> {
diff --git a/examples/externref.c b/examples/externref.c
index b0107c8db437..fe8098a6bf59 100644
--- a/examples/externref.c
+++ b/examples/externref.c
@@ -18,7 +18,8 @@ to tweak the `-lpthread` and such annotations as well as the name of the
 
 You can also build using cmake:
 
-mkdir build && cd build && cmake .. && cmake --build . --target wasmtime-externref
+mkdir build && cd build && cmake .. && \
+  cmake --build . --target wasmtime-externref
 */
 
 #include <assert.h>
@@ -28,10 +29,10 @@ mkdir build && cd build && cmake .. && cmake --build . --target wasmtime-externr
 #include <wasm.h>
 #include <wasmtime.h>
 
-static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap);
+static void exit_with_error(const char *message, wasmtime_error_t *error,
+                            wasm_trap_t *trap);
 
 int main() {
-  int ret = 0;
   bool ok = true;
   // Create a new configuration with Wasm reference types enabled.
   printf("Initializing...\n");
@@ -44,21 +45,24 @@ int main() {
   wasm_engine_t *engine = wasm_engine_new_with_config(config);
   assert(engine != NULL);
 
-  // With an engine we can create a *store* which is a long-lived group of wasm
-  // modules.
+  // With an engine we can create a *store* which is a group of wasm instances
+  // that can interact with each other.
   wasmtime_store_t *store = wasmtime_store_new(engine, NULL, NULL);
   assert(store != NULL);
   wasmtime_context_t *context = wasmtime_store_context(store);
 
   // Read our input file, which in this case is a wasm text file.
-  FILE* file = fopen("examples/externref.wat", "r");
+  FILE *file = fopen("examples/externref.wat", "r");
   assert(file != NULL);
   fseek(file, 0L, SEEK_END);
   size_t file_size = ftell(file);
   fseek(file, 0L, SEEK_SET);
   wasm_byte_vec_t wat;
   wasm_byte_vec_new_uninitialized(&wat, file_size);
-  assert(fread(wat.data, file_size, 1, file) == 1);
+  if (fread(wat.data, file_size, 1, file) != 1) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
   fclose(file);
 
   // Parse the wat into the binary wasm format
@@ -71,7 +75,7 @@ int main() {
   // Now that we've got our binary webassembly we can compile our module.
   printf("Compiling module...\n");
   wasmtime_module_t *module = NULL;
-  error = wasmtime_module_new(engine, (uint8_t*) wasm.data, wasm.size, &module);
+  error = wasmtime_module_new(engine, (uint8_t *)wasm.data, wasm.size, &module);
   wasm_byte_vec_delete(&wasm);
   if (error != NULL)
     exit_with_error("failed to compile module", error, NULL);
@@ -90,74 +94,91 @@ int main() {
   //
   // Note that the NULL here is a finalizer callback, but we don't need one for
   // this example.
-  wasmtime_externref_t *externref = wasmtime_externref_new("Hello, World!", NULL);
+  wasmtime_externref_t externref;
+  ok = wasmtime_externref_new(context, "Hello, World!", NULL, &externref);
+  assert(ok);
 
   // The `externref`'s wrapped data should be the string "Hello, World!".
-  void* data = wasmtime_externref_data(externref);
-  assert(strcmp((char*)data, "Hello, World!") == 0);
-
-  printf("Touching `externref` table...\n");
+  void *data = wasmtime_externref_data(context, &externref);
+  assert(strcmp((char *)data, "Hello, World!") == 0);
 
   wasmtime_extern_t item;
-
-  // Lookup the `table` export.
-  ok = wasmtime_instance_export_get(context, &instance, "table", strlen("table"), &item);
-  assert(ok);
-  assert(item.kind == WASMTIME_EXTERN_TABLE);
-
-  // Set `table[3]` to our `externref`.
   wasmtime_val_t externref_val;
   externref_val.kind = WASMTIME_EXTERNREF;
   externref_val.of.externref = externref;
-  error = wasmtime_table_set(context, &item.of.table, 3, &externref_val);
-  if (error != NULL)
-    exit_with_error("failed to set table", error, NULL);
 
-  // `table[3]` should now be our `externref`.
-  wasmtime_val_t elem;
-  ok = wasmtime_table_get(context, &item.of.table, 3, &elem);
-  assert(ok);
-  assert(elem.kind == WASMTIME_EXTERNREF);
-  assert(strcmp((char*)wasmtime_externref_data(elem.of.externref), "Hello, World!") == 0);
-  wasmtime_val_delete(&elem);
+  // Lookup the `table` export.
+  printf("Touching `externref` table...\n");
+  {
+    ok = wasmtime_instance_export_get(context, &instance, "table",
+                                      strlen("table"), &item);
+    assert(ok);
+    assert(item.kind == WASMTIME_EXTERN_TABLE);
+
+    // Set `table[3]` to our `externref`.
+    error = wasmtime_table_set(context, &item.of.table, 3, &externref_val);
+    if (error != NULL)
+      exit_with_error("failed to set table", error, NULL);
+
+    // `table[3]` should now be our `externref`.
+    wasmtime_val_t elem;
+    ok = wasmtime_table_get(context, &item.of.table, 3, &elem);
+    assert(ok);
+    assert(elem.kind == WASMTIME_EXTERNREF);
+    assert(strcmp((char *)wasmtime_externref_data(context, &elem.of.externref),
+                  "Hello, World!") == 0);
+    wasmtime_val_unroot(context, &elem);
+  }
 
   printf("Touching `externref` global...\n");
 
   // Lookup the `global` export.
-  ok = wasmtime_instance_export_get(context, &instance, "global", strlen("global"), &item);
-  assert(ok);
-  assert(item.kind == WASMTIME_EXTERN_GLOBAL);
-
-  // Set the global to our `externref`.
-  error = wasmtime_global_set(context, &item.of.global, &externref_val);
-  if (error != NULL)
-    exit_with_error("failed to set global", error, NULL);
-
-  // Get the global, and it should return our `externref` again.
-  wasmtime_val_t global_val;
-  wasmtime_global_get(context, &item.of.global, &global_val);
-  assert(global_val.kind == WASMTIME_EXTERNREF);
-  assert(strcmp((char*)wasmtime_externref_data(elem.of.externref), "Hello, World!") == 0);
-  wasmtime_val_delete(&global_val);
+  {
+    ok = wasmtime_instance_export_get(context, &instance, "global",
+                                      strlen("global"), &item);
+    assert(ok);
+    assert(item.kind == WASMTIME_EXTERN_GLOBAL);
+
+    // Set the global to our `externref`.
+    error = wasmtime_global_set(context, &item.of.global, &externref_val);
+    if (error != NULL)
+      exit_with_error("failed to set global", error, NULL);
+
+    // Get the global, and it should return our `externref` again.
+    wasmtime_val_t global_val;
+    wasmtime_global_get(context, &item.of.global, &global_val);
+    assert(global_val.kind == WASMTIME_EXTERNREF);
+    assert(strcmp((char *)wasmtime_externref_data(context,
+                                                  &global_val.of.externref),
+                  "Hello, World!") == 0);
+    wasmtime_val_unroot(context, &global_val);
+  }
 
   printf("Calling `externref` func...\n");
 
   // Lookup the `func` export.
-  ok = wasmtime_instance_export_get(context, &instance, "func", strlen("func"), &item);
-  assert(ok);
-  assert(item.kind == WASMTIME_EXTERN_FUNC);
-
-  // And call it!
-  wasmtime_val_t results[1];
-  error = wasmtime_func_call(context, &item.of.func, &externref_val, 1, results, 1, &trap);
-  if (error != NULL || trap != NULL)
-    exit_with_error("failed to call function", error, trap);
-
-  // `func` returns the same reference we gave it, so `results[0]` should be our
-  // `externref`.
-  assert(results[0].kind == WASMTIME_EXTERNREF);
-  assert(strcmp((char*)wasmtime_externref_data(results[0].of.externref), "Hello, World!") == 0);
-  wasmtime_val_delete(&results[0]);
+  {
+    ok = wasmtime_instance_export_get(context, &instance, "func",
+                                      strlen("func"), &item);
+    assert(ok);
+    assert(item.kind == WASMTIME_EXTERN_FUNC);
+
+    // And call it!
+    wasmtime_val_t results[1];
+    error = wasmtime_func_call(context, &item.of.func, &externref_val, 1,
+                               results, 1, &trap);
+    if (error != NULL || trap != NULL)
+      exit_with_error("failed to call function", error, trap);
+
+    // `func` returns the same reference we gave it, so `results[0]` should be
+    // our `externref`.
+    assert(results[0].kind == WASMTIME_EXTERNREF);
+    assert(strcmp((char *)wasmtime_externref_data(context,
+                                                  &results[0].of.externref),
+                  "Hello, World!") == 0);
+    wasmtime_val_unroot(context, &results[0]);
+  }
+  wasmtime_val_unroot(context, &externref_val);
 
   // We can GC any now-unused references to our externref that the store is
   // holding.
@@ -166,7 +187,6 @@ int main() {
 
   // Clean up after ourselves at this point
   printf("All finished!\n");
-  ret = 0;
 
   wasmtime_store_delete(store);
   wasmtime_module_delete(module);
@@ -174,7 +194,8 @@ int main() {
   return 0;
 }
 
-static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap) {
+static void exit_with_error(const char *message, wasmtime_error_t *error,
+                            wasm_trap_t *trap) {
   fprintf(stderr, "error: %s\n", message);
   wasm_byte_vec_t error_message;
   if (error != NULL) {
@@ -184,7 +205,7 @@ static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_t
     wasm_trap_message(trap, &error_message);
     wasm_trap_delete(trap);
   }
-  fprintf(stderr, "%.*s\n", (int) error_message.size, error_message.data);
+  fprintf(stderr, "%.*s\n", (int)error_message.size, error_message.data);
   wasm_byte_vec_delete(&error_message);
   exit(1);
 }
diff --git a/examples/externref.rs b/examples/externref.rs
index 67c91d8af0a7..7739fd8a1268 100644
--- a/examples/externref.rs
+++ b/examples/externref.rs
@@ -2,7 +2,6 @@
 
 // You can execute this example with `cargo run --example externref`
 
-use anyhow::Result;
 use wasmtime::*;
 
 fn main() -> Result<()> {
@@ -19,35 +18,40 @@ fn main() -> Result<()> {
     let instance = Instance::new(&mut store, &module, &[])?;
 
     println!("Creating new `externref`...");
-    let externref = ExternRef::new("Hello, World!");
-    assert!(externref.data().is::<&'static str>());
+    let externref = ExternRef::new(&mut store, "Hello, World!")?;
+    assert!(externref.data(&store)?.is::<&'static str>());
     assert_eq!(
-        *externref.data().downcast_ref::<&'static str>().unwrap(),
+        *externref
+            .data(&store)?
+            .downcast_ref::<&'static str>()
+            .unwrap(),
         "Hello, World!"
     );
 
     println!("Touching `externref` table...");
     let table = instance.get_table(&mut store, "table").unwrap();
-    table.set(&mut store, 3, Some(externref.clone()).into())?;
+    table.set(&mut store, 3, Some(externref).into())?;
     let elem = table
         .get(&mut store, 3)
         .unwrap() // assert in bounds
-        .unwrap_externref() // assert it's an externref table
+        .unwrap_extern() // assert it's an externref table
+        .copied()
         .unwrap(); // assert the externref isn't null
-    assert!(elem.ptr_eq(&externref));
+    assert!(Rooted::ref_eq(&store, &elem, &externref)?);
 
     println!("Touching `externref` global...");
     let global = instance.get_global(&mut store, "global").unwrap();
-    global.set(&mut store, Some(externref.clone()).into())?;
-    let global_val = global.get(&mut store).unwrap_externref().unwrap();
-    assert!(global_val.ptr_eq(&externref));
+    global.set(&mut store, Some(externref).into())?;
+    let global_val = global.get(&mut store).unwrap_externref().copied().unwrap();
+    assert!(Rooted::ref_eq(&store, &global_val, &externref)?);
 
     println!("Calling `externref` func...");
-    let func =
-        instance.get_typed_func::<Option<ExternRef>, Option<ExternRef>>(&mut store, "func")?;
-    let ret = func.call(&mut store, Some(externref.clone()))?;
+    let func = instance.get_typed_func::<Option<Rooted<ExternRef>>, Option<Rooted<ExternRef>>>(
+        &mut store, "func",
+    )?;
+    let ret = func.call(&mut store, Some(externref))?;
     assert!(ret.is_some());
-    assert!(ret.unwrap().ptr_eq(&externref));
+    assert!(Rooted::ref_eq(&store, &ret.unwrap(), &externref)?);
 
     println!("GCing within the store...");
     store.gc();
diff --git a/examples/fib-debug/main.c b/examples/fib-debug/main.c
index 20f0b0acb2ad..8633fb030129 100644
--- a/examples/fib-debug/main.c
+++ b/examples/fib-debug/main.c
@@ -1,30 +1,32 @@
+#include <inttypes.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <inttypes.h>
 #include <wasm.h>
 #include <wasmtime.h>
 
 #define own
 
-static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap);
+static void exit_with_error(const char *message, wasmtime_error_t *error,
+                            wasm_trap_t *trap);
 
-int main(int argc, const char* argv[]) {
+int main(int argc, const char *argv[]) {
   // Configuring engine to support generating of DWARF info.
   // lldb can be used to attach to the program and observe
   // original fib-wasm.c source code and variables.
-  wasm_config_t* config = wasm_config_new();
+  wasm_config_t *config = wasm_config_new();
   wasmtime_config_debug_info_set(config, true);
+  wasmtime_config_cranelift_opt_level_set(config, WASMTIME_OPT_LEVEL_NONE);
 
   // Initialize.
   printf("Initializing...\n");
-  wasm_engine_t* engine = wasm_engine_new_with_config(config);
-  wasmtime_store_t* store = wasmtime_store_new(engine, NULL, NULL);
-  wasmtime_context_t* context = wasmtime_store_context(store);
+  wasm_engine_t *engine = wasm_engine_new_with_config(config);
+  wasmtime_store_t *store = wasmtime_store_new(engine, NULL, NULL);
+  wasmtime_context_t *context = wasmtime_store_context(store);
 
   // Load binary.
   printf("Loading binary...\n");
-  FILE* file = fopen("target/wasm32-unknown-unknown/debug/fib.wasm", "rb");
+  FILE *file = fopen("target/wasm32-unknown-unknown/debug/fib.wasm", "rb");
   if (!file) {
     printf("> Error opening module!\n");
     return 1;
@@ -43,7 +45,8 @@ int main(int argc, const char* argv[]) {
   // Compile.
   printf("Compiling module...\n");
   wasmtime_module_t *module = NULL;
-  wasmtime_error_t* error = wasmtime_module_new(engine, (uint8_t*) binary.data, binary.size, &module);
+  wasmtime_error_t *error =
+      wasmtime_module_new(engine, (uint8_t *)binary.data, binary.size, &module);
   if (!module)
     exit_with_error("failed to compile module", error, NULL);
   wasm_byte_vec_delete(&binary);
@@ -68,7 +71,8 @@ int main(int argc, const char* argv[]) {
   params[0].kind = WASMTIME_I32;
   params[0].of.i32 = 6;
   wasmtime_val_t results[1];
-  error = wasmtime_func_call(context, &fib.of.func, params, 1, results, 1, &trap);
+  error =
+      wasmtime_func_call(context, &fib.of.func, params, 1, results, 1, &trap);
   if (error != NULL || trap != NULL)
     exit_with_error("failed to call function", error, trap);
 
@@ -85,7 +89,8 @@ int main(int argc, const char* argv[]) {
   return 0;
 }
 
-static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap) {
+static void exit_with_error(const char *message, wasmtime_error_t *error,
+                            wasm_trap_t *trap) {
   fprintf(stderr, "error: %s\n", message);
   wasm_byte_vec_t error_message;
   if (error != NULL) {
@@ -93,7 +98,7 @@ static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_t
   } else {
     wasm_trap_message(trap, &error_message);
   }
-  fprintf(stderr, "%.*s\n", (int) error_message.size, error_message.data);
+  fprintf(stderr, "%.*s\n", (int)error_message.size, error_message.data);
   wasm_byte_vec_delete(&error_message);
   exit(1);
 }
diff --git a/examples/fib-debug/main.rs b/examples/fib-debug/main.rs
index b9e51f229d3d..55a6e84cafe2 100644
--- a/examples/fib-debug/main.rs
+++ b/examples/fib-debug/main.rs
@@ -8,14 +8,17 @@
 //      cargo build -p example-fib-debug-wasm --target wasm32-unknown-unknown
 //      cargo run --example fib-debug
 
-use anyhow::Result;
 use wasmtime::*;
 
 fn main() -> Result<()> {
     // Load our previously compiled wasm file (built previously with Cargo) and
     // also ensure that we generate debuginfo so this executable can be
     // debugged in GDB.
-    let engine = Engine::new(Config::new().debug_info(true))?;
+    let engine = Engine::new(
+        Config::new()
+            .debug_info(true)
+            .cranelift_opt_level(OptLevel::None),
+    )?;
     let mut store = Store::new(&engine, ());
     let module = Module::from_file(&engine, "target/wasm32-unknown-unknown/debug/fib.wasm")?;
     let instance = Instance::new(&mut store, &module, &[])?;
diff --git a/examples/fib-debug/wasm/Cargo.toml b/examples/fib-debug/wasm/Cargo.toml
index 483a0b05a772..d0b7c908c33e 100644
--- a/examples/fib-debug/wasm/Cargo.toml
+++ b/examples/fib-debug/wasm/Cargo.toml
@@ -5,6 +5,9 @@ authors = ["The Wasmtime Project Developers"]
 edition = "2021"
 publish = false
 
+[lints]
+workspace = true
+
 [lib]
 crate-type = ["cdylib"]
 path = "fib.rs"
diff --git a/examples/fuel.c b/examples/fuel.c
index 9b0eaa6b09ac..521d0562835d 100644
--- a/examples/fuel.c
+++ b/examples/fuel.c
@@ -7,7 +7,6 @@ You can compile and run this example on Linux with:
    cargo build --release -p wasmtime-c-api
    cc examples/fuel.c \
        -I crates/c-api/include \
-       -I crates/c-api/wasm-c-api/include \
        target/release/libwasmtime.a \
        -lpthread -ldl -lm \
        -o fuel
@@ -27,7 +26,8 @@ mkdir build && cd build && cmake .. && cmake --build . --target wasmtime-fuel
 #include <wasm.h>
 #include <wasmtime.h>
 
-static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap);
+static void exit_with_error(const char *message, wasmtime_error_t *error,
+                            wasm_trap_t *trap);
 
 int main() {
   wasmtime_error_t *error = NULL;
@@ -36,19 +36,20 @@ int main() {
   assert(config != NULL);
   wasmtime_config_consume_fuel_set(config, true);
 
-  // Create an *engine*, which is a compilation context, with our configured options.
+  // Create an *engine*, which is a compilation context, with our configured
+  // options.
   wasm_engine_t *engine = wasm_engine_new_with_config(config);
   assert(engine != NULL);
   wasmtime_store_t *store = wasmtime_store_new(engine, NULL, NULL);
   assert(store != NULL);
   wasmtime_context_t *context = wasmtime_store_context(store);
 
-  error = wasmtime_context_add_fuel(context, 10000);
+  error = wasmtime_context_set_fuel(context, 10000);
   if (error != NULL)
-    exit_with_error("failed to add fuel", error, NULL);
+    exit_with_error("failed to set fuel", error, NULL);
 
   // Load our input file to parse it next
-  FILE* file = fopen("examples/fuel.wat", "r");
+  FILE *file = fopen("examples/fuel.wat", "r");
   if (!file) {
     printf("> Error loading file!\n");
     return 1;
@@ -73,7 +74,7 @@ int main() {
 
   // Compile and instantiate our module
   wasmtime_module_t *module = NULL;
-  error = wasmtime_module_new(engine, (uint8_t*) wasm.data, wasm.size, &module);
+  error = wasmtime_module_new(engine, (uint8_t *)wasm.data, wasm.size, &module);
   if (module == NULL)
     exit_with_error("failed to compile module", error, NULL);
   wasm_byte_vec_delete(&wasm);
@@ -86,19 +87,21 @@ int main() {
 
   // Lookup our `fibonacci` export function
   wasmtime_extern_t fib;
-  bool ok = wasmtime_instance_export_get(context, &instance, "fibonacci", strlen("fibonacci"), &fib);
+  bool ok = wasmtime_instance_export_get(context, &instance, "fibonacci",
+                                         strlen("fibonacci"), &fib);
   assert(ok);
   assert(fib.kind == WASMTIME_EXTERN_FUNC);
 
   // Call it repeatedly until it fails
-  for (int n = 1; ; n++) {
+  for (int n = 1;; n++) {
     uint64_t fuel_before;
-    wasmtime_context_fuel_consumed(context, &fuel_before);
+    wasmtime_context_get_fuel(context, &fuel_before);
     wasmtime_val_t params[1];
     params[0].kind = WASMTIME_I32;
     params[0].of.i32 = n;
     wasmtime_val_t results[1];
-    error = wasmtime_func_call(context, &fib.of.func, params, 1, results, 1, &trap);
+    error =
+        wasmtime_func_call(context, &fib.of.func, params, 1, results, 1, &trap);
     if (error != NULL || trap != NULL) {
       if (trap != NULL) {
         wasmtime_trap_code_t code;
@@ -110,13 +113,14 @@ int main() {
     }
 
     uint64_t fuel_after;
-    wasmtime_context_fuel_consumed(context, &fuel_after);
+    wasmtime_context_get_fuel(context, &fuel_after);
     assert(results[0].kind == WASMTIME_I32);
-    printf("fib(%d) = %d [consumed %lld fuel]\n", n, results[0].of.i32, fuel_after - fuel_before);
+    printf("fib(%d) = %d [consumed %lu fuel]\n", n, results[0].of.i32,
+           fuel_after - fuel_before);
 
-    error = wasmtime_context_add_fuel(context, fuel_after - fuel_before);
+    error = wasmtime_context_set_fuel(context, 10000);
     if (error != NULL)
-      exit_with_error("failed to add fuel", error, NULL);
+      exit_with_error("failed to set fuel", error, NULL);
   }
 
   // Clean up after ourselves at this point
@@ -126,7 +130,8 @@ int main() {
   return 0;
 }
 
-static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap) {
+static void exit_with_error(const char *message, wasmtime_error_t *error,
+                            wasm_trap_t *trap) {
   fprintf(stderr, "error: %s\n", message);
   wasm_byte_vec_t error_message;
   if (error != NULL) {
@@ -134,7 +139,7 @@ static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_t
   } else {
     wasm_trap_message(trap, &error_message);
   }
-  fprintf(stderr, "%.*s\n", (int) error_message.size, error_message.data);
+  fprintf(stderr, "%.*s\n", (int)error_message.size, error_message.data);
   wasm_byte_vec_delete(&error_message);
   exit(1);
 }
diff --git a/examples/fuel.rs b/examples/fuel.rs
index e6f4c74ecb37..fdbca35a1d4c 100644
--- a/examples/fuel.rs
+++ b/examples/fuel.rs
@@ -2,7 +2,6 @@
 
 // You can execute this example with `cargo run --example fuel`
 
-use anyhow::Result;
 use wasmtime::*;
 
 fn main() -> Result<()> {
@@ -10,25 +9,25 @@ fn main() -> Result<()> {
     config.consume_fuel(true);
     let engine = Engine::new(&config)?;
     let mut store = Store::new(&engine, ());
-    store.add_fuel(10_000)?;
+    store.set_fuel(10_000)?;
     let module = Module::from_file(store.engine(), "examples/fuel.wat")?;
     let instance = Instance::new(&mut store, &module, &[])?;
 
     // Invoke `fibonacci` export with higher and higher numbers until we exhaust our fuel.
     let fibonacci = instance.get_typed_func::<i32, i32>(&mut store, "fibonacci")?;
     for n in 1.. {
-        let fuel_before = store.fuel_consumed().unwrap();
+        let fuel_before = store.get_fuel().unwrap();
         let output = match fibonacci.call(&mut store, n) {
             Ok(v) => v,
             Err(e) => {
                 assert_eq!(e.downcast::<Trap>()?, Trap::OutOfFuel);
-                println!("Exhausted fuel computing fib({})", n);
+                println!("Exhausted fuel computing fib({n})");
                 break;
             }
         };
-        let fuel_consumed = store.fuel_consumed().unwrap() - fuel_before;
-        println!("fib({}) = {} [consumed {} fuel]", n, output, fuel_consumed);
-        store.add_fuel(fuel_consumed)?;
+        let fuel_consumed = fuel_before - store.get_fuel().unwrap();
+        println!("fib({n}) = {output} [consumed {fuel_consumed} fuel]");
+        store.set_fuel(10_000)?;
     }
     Ok(())
 }
diff --git a/examples/gcd.c b/examples/gcd.c
index cac7f6bb0dd4..7447f8f4ac48 100644
--- a/examples/gcd.c
+++ b/examples/gcd.c
@@ -7,7 +7,6 @@ You can compile and run this example on Linux with:
    cargo build --release -p wasmtime-c-api
    cc examples/gcd.c \
        -I crates/c-api/include \
-       -I crates/c-api/wasm-c-api/include \
        target/release/libwasmtime.a \
        -lpthread -ldl -lm \
        -o gcd
@@ -27,7 +26,8 @@ mkdir build && cd build && cmake .. && cmake --build . --target wasmtime-gcd
 #include <wasm.h>
 #include <wasmtime.h>
 
-static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap);
+static void exit_with_error(const char *message, wasmtime_error_t *error,
+                            wasm_trap_t *trap);
 
 int main() {
   int ret = 0;
@@ -39,7 +39,7 @@ int main() {
   wasmtime_context_t *context = wasmtime_store_context(store);
 
   // Load our input file to parse it next
-  FILE* file = fopen("examples/gcd.wat", "r");
+  FILE *file = fopen("examples/gcd.wat", "r");
   if (!file) {
     printf("> Error loading file!\n");
     return 1;
@@ -64,7 +64,7 @@ int main() {
 
   // Compile and instantiate our module
   wasmtime_module_t *module = NULL;
-  error = wasmtime_module_new(engine, (uint8_t*) wasm.data, wasm.size, &module);
+  error = wasmtime_module_new(engine, (uint8_t *)wasm.data, wasm.size, &module);
   if (module == NULL)
     exit_with_error("failed to compile module", error, NULL);
   wasm_byte_vec_delete(&wasm);
@@ -90,7 +90,8 @@ int main() {
   params[1].kind = WASMTIME_I32;
   params[1].of.i32 = b;
   wasmtime_val_t results[1];
-  error = wasmtime_func_call(context, &gcd.of.func, params, 2, results, 1, &trap);
+  error =
+      wasmtime_func_call(context, &gcd.of.func, params, 2, results, 1, &trap);
   if (error != NULL || trap != NULL)
     exit_with_error("failed to call gcd", error, trap);
   assert(results[0].kind == WASMTIME_I32);
@@ -106,7 +107,8 @@ int main() {
   return ret;
 }
 
-static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap) {
+static void exit_with_error(const char *message, wasmtime_error_t *error,
+                            wasm_trap_t *trap) {
   fprintf(stderr, "error: %s\n", message);
   wasm_byte_vec_t error_message;
   if (error != NULL) {
@@ -114,7 +116,7 @@ static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_t
   } else {
     wasm_trap_message(trap, &error_message);
   }
-  fprintf(stderr, "%.*s\n", (int) error_message.size, error_message.data);
+  fprintf(stderr, "%.*s\n", (int)error_message.size, error_message.data);
   wasm_byte_vec_delete(&error_message);
   exit(1);
 }
diff --git a/examples/gcd.rs b/examples/gcd.rs
index 176ee656e052..0a01cd11feb8 100644
--- a/examples/gcd.rs
+++ b/examples/gcd.rs
@@ -3,7 +3,6 @@
 
 // You can execute this example with `cargo run --example gcd`
 
-use anyhow::Result;
 use wasmtime::*;
 
 fn main() -> Result<()> {
diff --git a/examples/hello.c b/examples/hello.c
index 5adf97b9b9ad..45ff62072861 100644
--- a/examples/hello.c
+++ b/examples/hello.c
@@ -7,7 +7,6 @@ You can compile and run this example on Linux with:
    cargo build --release -p wasmtime-c-api
    cc examples/hello.c \
        -I crates/c-api/include \
-       -I crates/c-api/wasm-c-api/include \
        target/release/libwasmtime.a \
        -lpthread -ldl -lm \
        -o hello
@@ -28,16 +27,12 @@ mkdir build && cd build && cmake .. && cmake --build . --target wasmtime-hello
 #include <wasm.h>
 #include <wasmtime.h>
 
-static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap);
+static void exit_with_error(const char *message, wasmtime_error_t *error,
+                            wasm_trap_t *trap);
 
-static wasm_trap_t* hello_callback(
-    void *env,
-    wasmtime_caller_t *caller,
-    const wasmtime_val_t *args,
-    size_t nargs,
-    wasmtime_val_t *results,
-    size_t nresults
-) {
+static wasm_trap_t *hello_callback(void *env, wasmtime_caller_t *caller,
+                                   const wasmtime_val_t *args, size_t nargs,
+                                   wasmtime_val_t *results, size_t nresults) {
   printf("Calling back...\n");
   printf("> Hello World!\n");
   return NULL;
@@ -60,14 +55,17 @@ int main() {
   wasmtime_context_t *context = wasmtime_store_context(store);
 
   // Read our input file, which in this case is a wasm text file.
-  FILE* file = fopen("examples/hello.wat", "r");
+  FILE *file = fopen("examples/hello.wat", "r");
   assert(file != NULL);
   fseek(file, 0L, SEEK_END);
   size_t file_size = ftell(file);
   fseek(file, 0L, SEEK_SET);
   wasm_byte_vec_t wat;
   wasm_byte_vec_new_uninitialized(&wat, file_size);
-  assert(fread(wat.data, file_size, 1, file) == 1);
+  if (fread(wat.data, file_size, 1, file) != 1) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
   fclose(file);
 
   // Parse the wat into the binary wasm format
@@ -80,7 +78,7 @@ int main() {
   // Now that we've got our binary webassembly we can compile our module.
   printf("Compiling module...\n");
   wasmtime_module_t *module = NULL;
-  error = wasmtime_module_new(engine, (uint8_t*) wasm.data, wasm.size, &module);
+  error = wasmtime_module_new(engine, (uint8_t *)wasm.data, wasm.size, &module);
   wasm_byte_vec_delete(&wasm);
   if (error != NULL)
     exit_with_error("failed to compile module", error, NULL);
@@ -131,7 +129,8 @@ int main() {
   return ret;
 }
 
-static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap) {
+static void exit_with_error(const char *message, wasmtime_error_t *error,
+                            wasm_trap_t *trap) {
   fprintf(stderr, "error: %s\n", message);
   wasm_byte_vec_t error_message;
   if (error != NULL) {
@@ -141,7 +140,7 @@ static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_t
     wasm_trap_message(trap, &error_message);
     wasm_trap_delete(trap);
   }
-  fprintf(stderr, "%.*s\n", (int) error_message.size, error_message.data);
+  fprintf(stderr, "%.*s\n", (int)error_message.size, error_message.data);
   wasm_byte_vec_delete(&error_message);
   exit(1);
 }
diff --git a/examples/hello.rs b/examples/hello.rs
index 67df450ecb2c..fb0311f9c76f 100644
--- a/examples/hello.rs
+++ b/examples/hello.rs
@@ -3,7 +3,6 @@
 
 // You can execute this example with `cargo run --example hello`
 
-use anyhow::Result;
 use wasmtime::*;
 
 struct MyState {
diff --git a/examples/interrupt.c b/examples/interrupt.c
index 900bd2b64cd5..3866cec1adeb 100644
--- a/examples/interrupt.c
+++ b/examples/interrupt.c
@@ -7,7 +7,6 @@ You can compile and run this example on Linux with:
    cargo build --release -p wasmtime-c-api
    cc examples/interrupt.c \
        -I crates/c-api/include \
-       -I crates/c-api/wasm-c-api/include \
        target/release/libwasmtime.a \
        -lpthread -ldl -lm \
        -o interrupt
@@ -19,7 +18,8 @@ to tweak the `-lpthread` and such annotations as well as the name of the
 
 You can also build using cmake:
 
-mkdir build && cd build && cmake .. && cmake --build . --target wasmtime-interrupt
+mkdir build && cd build && cmake .. && \
+  cmake --build . --target wasmtime-interrupt
 */
 
 #include <assert.h>
@@ -36,7 +36,7 @@ static void spawn_interrupt(wasm_engine_t *engine) {
 #include <pthread.h>
 #include <time.h>
 
-static void* helper(void *_engine) {
+static void *helper(void *_engine) {
   wasm_engine_t *engine = _engine;
   struct timespec sleep_dur;
   sleep_dur.tv_sec = 1;
@@ -54,7 +54,8 @@ static void spawn_interrupt(wasm_engine_t *engine) {
 }
 #endif
 
-static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap);
+static void exit_with_error(const char *message, wasmtime_error_t *error,
+                            wasm_trap_t *trap);
 
 int main() {
   // Create a `wasm_store_t` with interrupts enabled
@@ -71,14 +72,17 @@ int main() {
   wasmtime_context_set_epoch_deadline(context, 1);
 
   // Read our input file, which in this case is a wasm text file.
-  FILE* file = fopen("examples/interrupt.wat", "r");
+  FILE *file = fopen("examples/interrupt.wat", "r");
   assert(file != NULL);
   fseek(file, 0L, SEEK_END);
   size_t file_size = ftell(file);
   fseek(file, 0L, SEEK_SET);
   wasm_byte_vec_t wat;
   wasm_byte_vec_new_uninitialized(&wat, file_size);
-  assert(fread(wat.data, file_size, 1, file) == 1);
+  if (fread(wat.data, file_size, 1, file) != 1) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
   fclose(file);
 
   // Parse the wat into the binary wasm format
@@ -90,7 +94,7 @@ int main() {
 
   // Now that we've got our binary webassembly we can compile our module.
   wasmtime_module_t *module = NULL;
-  error = wasmtime_module_new(engine, (uint8_t*) wasm.data, wasm.size, &module);
+  error = wasmtime_module_new(engine, (uint8_t *)wasm.data, wasm.size, &module);
   wasm_byte_vec_delete(&wasm);
   if (error != NULL)
     exit_with_error("failed to compile module", error, NULL);
@@ -123,7 +127,8 @@ int main() {
   return 0;
 }
 
-static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap) {
+static void exit_with_error(const char *message, wasmtime_error_t *error,
+                            wasm_trap_t *trap) {
   fprintf(stderr, "error: %s\n", message);
   wasm_byte_vec_t error_message;
   if (error != NULL) {
@@ -133,7 +138,7 @@ static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_t
     wasm_trap_message(trap, &error_message);
     wasm_trap_delete(trap);
   }
-  fprintf(stderr, "%.*s\n", (int) error_message.size, error_message.data);
+  fprintf(stderr, "%.*s\n", (int)error_message.size, error_message.data);
   wasm_byte_vec_delete(&error_message);
   exit(1);
 }
diff --git a/examples/interrupt.rs b/examples/interrupt.rs
index 87d6d4dd0e89..bbe2444777f5 100644
--- a/examples/interrupt.rs
+++ b/examples/interrupt.rs
@@ -3,7 +3,6 @@
 
 // You can execute this example with `cargo run --example interrupt`
 
-use anyhow::Result;
 use wasmtime::*;
 
 fn main() -> Result<()> {
diff --git a/examples/linking.c b/examples/linking.c
index b32d46890c0a..d9741ab97642 100644
--- a/examples/linking.c
+++ b/examples/linking.c
@@ -7,7 +7,6 @@ You can compile and run this example on Linux with:
    cargo build --release -p wasmtime-c-api
    cc examples/linking.c \
        -I crates/c-api/include \
-       -I crates/c-api/wasm-c-api/include \
        target/release/libwasmtime.a \
        -lpthread -ldl -lm \
        -o linking
@@ -24,14 +23,16 @@ mkdir build && cd build && cmake .. && cmake --build . --target wasmtime-linking
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <wasm.h>
 #include <wasi.h>
+#include <wasm.h>
 #include <wasmtime.h>
 
 #define MIN(a, b) ((a) < (b) ? (a) : (b))
 
-static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap);
-static void read_wat_file(wasm_engine_t *engine, wasm_byte_vec_t *bytes, const char *file);
+static void exit_with_error(const char *message, wasmtime_error_t *error,
+                            wasm_trap_t *trap);
+static void read_wat_file(wasm_engine_t *engine, wasm_byte_vec_t *bytes,
+                          const char *file);
 
 int main() {
   // Set up our context
@@ -49,10 +50,12 @@ int main() {
   wasmtime_error_t *error;
   wasmtime_module_t *linking1_module = NULL;
   wasmtime_module_t *linking2_module = NULL;
-  error = wasmtime_module_new(engine, (uint8_t*) linking1_wasm.data, linking1_wasm.size, &linking1_module);
+  error = wasmtime_module_new(engine, (uint8_t *)linking1_wasm.data,
+                              linking1_wasm.size, &linking1_module);
   if (error != NULL)
     exit_with_error("failed to compile linking1", error, NULL);
-  error = wasmtime_module_new(engine, (uint8_t*) linking2_wasm.data, linking2_wasm.size, &linking2_module);
+  error = wasmtime_module_new(engine, (uint8_t *)linking2_wasm.data,
+                              linking2_wasm.size, &linking2_module);
   if (error != NULL)
     exit_with_error("failed to compile linking2", error, NULL);
   wasm_byte_vec_delete(&linking1_wasm);
@@ -80,18 +83,21 @@ int main() {
 
   // Instantiate `linking2` with our linker.
   wasmtime_instance_t linking2;
-  error = wasmtime_linker_instantiate(linker, context, linking2_module, &linking2, &trap);
+  error = wasmtime_linker_instantiate(linker, context, linking2_module,
+                                      &linking2, &trap);
   if (error != NULL || trap != NULL)
     exit_with_error("failed to instantiate linking2", error, trap);
 
   // Register our new `linking2` instance with the linker
-  error = wasmtime_linker_define_instance(linker, context, "linking2", strlen("linking2"), &linking2);
+  error = wasmtime_linker_define_instance(linker, context, "linking2",
+                                          strlen("linking2"), &linking2);
   if (error != NULL)
     exit_with_error("failed to link linking2", error, NULL);
 
   // Instantiate `linking1` with the linker now that `linking2` is defined
   wasmtime_instance_t linking1;
-  error = wasmtime_linker_instantiate(linker, context, linking1_module, &linking1, &trap);
+  error = wasmtime_linker_instantiate(linker, context, linking1_module,
+                                      &linking1, &trap);
   if (error != NULL || trap != NULL)
     exit_with_error("failed to instantiate linking1", error, trap);
 
@@ -113,14 +119,11 @@ int main() {
   return 0;
 }
 
-static void read_wat_file(
-  wasm_engine_t *engine,
-  wasm_byte_vec_t *bytes,
-  const char *filename
-) {
+static void read_wat_file(wasm_engine_t *engine, wasm_byte_vec_t *bytes,
+                          const char *filename) {
   wasm_byte_vec_t wat;
   // Load our input file to parse it next
-  FILE* file = fopen(filename, "r");
+  FILE *file = fopen(filename, "r");
   if (!file) {
     printf("> Error loading file!\n");
     exit(1);
@@ -142,7 +145,8 @@ static void read_wat_file(
   wasm_byte_vec_delete(&wat);
 }
 
-static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap) {
+static void exit_with_error(const char *message, wasmtime_error_t *error,
+                            wasm_trap_t *trap) {
   fprintf(stderr, "error: %s\n", message);
   wasm_byte_vec_t error_message;
   if (error != NULL) {
@@ -152,7 +156,7 @@ static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_t
     wasm_trap_message(trap, &error_message);
     wasm_trap_delete(trap);
   }
-  fprintf(stderr, "%.*s\n", (int) error_message.size, error_message.data);
+  fprintf(stderr, "%.*s\n", (int)error_message.size, error_message.data);
   wasm_byte_vec_delete(&error_message);
   exit(1);
 }
diff --git a/examples/linking.rs b/examples/linking.rs
index a2d75605725a..d54766701818 100644
--- a/examples/linking.rs
+++ b/examples/linking.rs
@@ -2,9 +2,8 @@
 
 // You can execute this example with `cargo run --example linking`
 
-use anyhow::Result;
+use wasi_common::sync::WasiCtxBuilder;
 use wasmtime::*;
-use wasmtime_wasi::sync::WasiCtxBuilder;
 
 fn main() -> Result<()> {
     let engine = Engine::default();
@@ -12,7 +11,7 @@ fn main() -> Result<()> {
     // First set up our linker which is going to be linking modules together. We
     // want our linker to have wasi available, so we set that up here as well.
     let mut linker = Linker::new(&engine);
-    wasmtime_wasi::add_to_linker(&mut linker, |s| s)?;
+    wasi_common::sync::add_to_linker(&mut linker, |s| s)?;
 
     // Load and compile our two modules
     let linking1 = Module::from_file(&engine, "examples/linking1.wat")?;
diff --git a/examples/memory.c b/examples/memory.c
index 37eaf0e13744..2edca2198421 100644
--- a/examples/memory.c
+++ b/examples/memory.c
@@ -7,7 +7,6 @@ You can compile and run this example on Linux with:
    cargo build --release -p wasmtime-c-api
    cc examples/memory.c \
        -I crates/c-api/include \
-       -I crates/c-api/wasm-c-api/include \
        target/release/libwasmtime.a \
        -lpthread -ldl -lm \
        -o memory
@@ -32,7 +31,8 @@ originally
 #include <wasm.h>
 #include <wasmtime.h>
 
-static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap);
+static void exit_with_error(const char *message, wasmtime_error_t *error,
+                            wasm_trap_t *trap);
 
 void check(bool success) {
   if (!success) {
@@ -41,16 +41,12 @@ void check(bool success) {
   }
 }
 
-void check_call(wasmtime_context_t *store,
-                wasmtime_func_t *func,
-                const wasmtime_val_t* args,
-                size_t nargs,
-                int32_t expected) {
+void check_call(wasmtime_context_t *store, wasmtime_func_t *func,
+                const wasmtime_val_t *args, size_t nargs, int32_t expected) {
   wasmtime_val_t results[1];
   wasm_trap_t *trap = NULL;
-  wasmtime_error_t *error = wasmtime_func_call(
-      store, func, args, nargs, results, 1, &trap
-  );
+  wasmtime_error_t *error =
+      wasmtime_func_call(store, func, args, nargs, results, 1, &trap);
   if (error != NULL || trap != NULL)
     exit_with_error("failed to call function", error, trap);
   if (results[0].of.i32 != expected) {
@@ -59,18 +55,21 @@ void check_call(wasmtime_context_t *store,
   }
 }
 
-void check_call0(wasmtime_context_t *store, wasmtime_func_t *func, int32_t expected) {
+void check_call0(wasmtime_context_t *store, wasmtime_func_t *func,
+                 int32_t expected) {
   check_call(store, func, NULL, 0, expected);
 }
 
-void check_call1(wasmtime_context_t *store, wasmtime_func_t *func, int32_t arg, int32_t expected) {
+void check_call1(wasmtime_context_t *store, wasmtime_func_t *func, int32_t arg,
+                 int32_t expected) {
   wasmtime_val_t args[1];
   args[0].kind = WASMTIME_I32;
   args[0].of.i32 = arg;
   check_call(store, func, args, 1, expected);
 }
 
-void check_call2(wasmtime_context_t *store, wasmtime_func_t *func, int32_t arg1, int32_t arg2, int32_t expected) {
+void check_call2(wasmtime_context_t *store, wasmtime_func_t *func, int32_t arg1,
+                 int32_t arg2, int32_t expected) {
   wasmtime_val_t args[2];
   args[0].kind = WASMTIME_I32;
   args[0].of.i32 = arg1;
@@ -79,14 +78,17 @@ void check_call2(wasmtime_context_t *store, wasmtime_func_t *func, int32_t arg1,
   check_call(store, func, args, 2, expected);
 }
 
-void check_ok(wasmtime_context_t *store, wasmtime_func_t *func, const wasmtime_val_t* args, size_t nargs) {
+void check_ok(wasmtime_context_t *store, wasmtime_func_t *func,
+              const wasmtime_val_t *args, size_t nargs) {
   wasm_trap_t *trap = NULL;
-  wasmtime_error_t *error = wasmtime_func_call(store, func, args, nargs, NULL, 0, &trap);
+  wasmtime_error_t *error =
+      wasmtime_func_call(store, func, args, nargs, NULL, 0, &trap);
   if (error != NULL || trap != NULL)
     exit_with_error("failed to call function", error, trap);
 }
 
-void check_ok2(wasmtime_context_t *store, wasmtime_func_t *func, int32_t arg1, int32_t arg2) {
+void check_ok2(wasmtime_context_t *store, wasmtime_func_t *func, int32_t arg1,
+               int32_t arg2) {
   wasmtime_val_t args[2];
   args[0].kind = WASMTIME_I32;
   args[0].of.i32 = arg1;
@@ -95,15 +97,13 @@ void check_ok2(wasmtime_context_t *store, wasmtime_func_t *func, int32_t arg1, i
   check_ok(store, func, args, 2);
 }
 
-void check_trap(wasmtime_context_t *store,
-                wasmtime_func_t *func,
-                const wasmtime_val_t *args,
-                size_t nargs,
-                size_t num_results) {
+void check_trap(wasmtime_context_t *store, wasmtime_func_t *func,
+                const wasmtime_val_t *args, size_t nargs, size_t num_results) {
   assert(num_results <= 1);
   wasmtime_val_t results[1];
   wasm_trap_t *trap = NULL;
-  wasmtime_error_t *error = wasmtime_func_call(store, func, args, nargs, results, num_results, &trap);
+  wasmtime_error_t *error =
+      wasmtime_func_call(store, func, args, nargs, results, num_results, &trap);
   if (error != NULL)
     exit_with_error("failed to call function", error, NULL);
   if (trap == NULL) {
@@ -113,14 +113,16 @@ void check_trap(wasmtime_context_t *store,
   wasm_trap_delete(trap);
 }
 
-void check_trap1(wasmtime_context_t *store, wasmtime_func_t *func, int32_t arg) {
+void check_trap1(wasmtime_context_t *store, wasmtime_func_t *func,
+                 int32_t arg) {
   wasmtime_val_t args[1];
   args[0].kind = WASMTIME_I32;
   args[0].of.i32 = arg;
   check_trap(store, func, args, 1, 1);
 }
 
-void check_trap2(wasmtime_context_t *store, wasmtime_func_t *func, int32_t arg1, int32_t arg2) {
+void check_trap2(wasmtime_context_t *store, wasmtime_func_t *func, int32_t arg1,
+                 int32_t arg2) {
   wasmtime_val_t args[2];
   args[0].kind = WASMTIME_I32;
   args[0].of.i32 = arg1;
@@ -129,15 +131,15 @@ void check_trap2(wasmtime_context_t *store, wasmtime_func_t *func, int32_t arg1,
   check_trap(store, func, args, 2, 0);
 }
 
-int main(int argc, const char* argv[]) {
+int main(int argc, const char *argv[]) {
   // Initialize.
   printf("Initializing...\n");
-  wasm_engine_t* engine = wasm_engine_new();
-  wasmtime_store_t* store = wasmtime_store_new(engine, NULL, NULL);
+  wasm_engine_t *engine = wasm_engine_new();
+  wasmtime_store_t *store = wasmtime_store_new(engine, NULL, NULL);
   wasmtime_context_t *context = wasmtime_store_context(store);
 
   // Load our input file to parse it next
-  FILE* file = fopen("examples/memory.wat", "r");
+  FILE *file = fopen("examples/memory.wat", "r");
   if (!file) {
     printf("> Error loading file!\n");
     return 1;
@@ -162,8 +164,9 @@ int main(int argc, const char* argv[]) {
 
   // Compile.
   printf("Compiling module...\n");
-  wasmtime_module_t* module = NULL;
-  error = wasmtime_module_new(engine, (uint8_t*) binary.data, binary.size, &module);
+  wasmtime_module_t *module = NULL;
+  error =
+      wasmtime_module_new(engine, (uint8_t *)binary.data, binary.size, &module);
   if (error)
     exit_with_error("failed to compile module", error, NULL);
   wasm_byte_vec_delete(&binary);
@@ -183,16 +186,20 @@ int main(int argc, const char* argv[]) {
   wasmtime_func_t size_func, load_func, store_func;
   wasmtime_extern_t item;
   bool ok;
-  ok = wasmtime_instance_export_get(context, &instance, "memory", strlen("memory"), &item);
+  ok = wasmtime_instance_export_get(context, &instance, "memory",
+                                    strlen("memory"), &item);
   assert(ok && item.kind == WASMTIME_EXTERN_MEMORY);
   memory = item.of.memory;
-  ok = wasmtime_instance_export_get(context, &instance, "size", strlen("size"), &item);
+  ok = wasmtime_instance_export_get(context, &instance, "size", strlen("size"),
+                                    &item);
   assert(ok && item.kind == WASMTIME_EXTERN_FUNC);
   size_func = item.of.func;
-  ok = wasmtime_instance_export_get(context, &instance, "load", strlen("load"), &item);
+  ok = wasmtime_instance_export_get(context, &instance, "load", strlen("load"),
+                                    &item);
   assert(ok && item.kind == WASMTIME_EXTERN_FUNC);
   load_func = item.of.func;
-  ok = wasmtime_instance_export_get(context, &instance, "store", strlen("store"), &item);
+  ok = wasmtime_instance_export_get(context, &instance, "store",
+                                    strlen("store"), &item);
   assert(ok && item.kind == WASMTIME_EXTERN_FUNC);
   store_func = item.of.func;
 
@@ -246,7 +253,7 @@ int main(int argc, const char* argv[]) {
   // Create stand-alone memory.
   printf("Creating stand-alone memory...\n");
   wasm_limits_t limits = {5, 5};
-  wasm_memorytype_t* memorytype = wasm_memorytype_new(&limits);
+  wasm_memorytype_t *memorytype = wasm_memorytype_new(&limits);
   wasmtime_memory_t memory2;
   error = wasmtime_memory_new(context, memorytype, &memory2);
   if (error != NULL)
@@ -264,7 +271,8 @@ int main(int argc, const char* argv[]) {
   return 0;
 }
 
-static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap) {
+static void exit_with_error(const char *message, wasmtime_error_t *error,
+                            wasm_trap_t *trap) {
   fprintf(stderr, "error: %s\n", message);
   wasm_byte_vec_t error_message;
   if (error != NULL) {
@@ -274,7 +282,7 @@ static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_t
     wasm_trap_message(trap, &error_message);
     wasm_trap_delete(trap);
   }
-  fprintf(stderr, "%.*s\n", (int) error_message.size, error_message.data);
+  fprintf(stderr, "%.*s\n", (int)error_message.size, error_message.data);
   wasm_byte_vec_delete(&error_message);
   exit(1);
 }
diff --git a/examples/memory.rs b/examples/memory.rs
index 5d57a73217a2..59f1f6fd2fc2 100644
--- a/examples/memory.rs
+++ b/examples/memory.rs
@@ -6,7 +6,6 @@
 
 // You can execute this example with `cargo run --example memory`
 
-use anyhow::Result;
 use wasmtime::*;
 
 fn main() -> Result<()> {
diff --git a/examples/min-platform/.gitignore b/examples/min-platform/.gitignore
new file mode 100644
index 000000000000..207ca41be7cb
--- /dev/null
+++ b/examples/min-platform/.gitignore
@@ -0,0 +1,2 @@
+libwasmtime-platform.so
+libembedding.so
diff --git a/examples/min-platform/Cargo.toml b/examples/min-platform/Cargo.toml
new file mode 100644
index 000000000000..3cb9339ec5b9
--- /dev/null
+++ b/examples/min-platform/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "min-platform-host"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
+
+[dependencies]
+anyhow = { workspace = true, features = ['std'] }
+libloading = "0.8"
+object = { workspace = true, features = ['std'] }
+wasmtime = { workspace = true, features = ['cranelift', 'wat'] }
diff --git a/examples/min-platform/README.md b/examples/min-platform/README.md
new file mode 100644
index 000000000000..14eac757df96
--- /dev/null
+++ b/examples/min-platform/README.md
@@ -0,0 +1,77 @@
+# Example: Minimal Platform Build of Wasmtime
+
+This example is a showcase of what it looks like to build Wasmtime with a
+minimal set of platform dependencies. This might be suitable when running
+WebAssembly outside of Linux on a smaller system with a custom operating system
+for example. Support here is built on Wasmtime's support of "custom platforms"
+and more details can be found [online as
+well](https://docs.wasmtime.dev/examples-minimal.html).
+
+The example is organized into a few locations:
+
+* `examples/min-platform/embedding/{Cargo.toml,src}` - source code for the
+  embedding of Wasmtime itself. This is compiled to the target architecture
+  and will have a minimal set of dependencies.
+
+* `examples/min-platform/embedding/*.json` - custom Rust target definitions
+  which are used when compiling this example. These are the custom target files
+  that are the compilation target of the `embedding` crate. This is a feature
+  of nightly Rust to be able to use these. Note that the contents can be
+  customized and these files are only examples.
+
+* `examples/min-platform/embedding/wasmtime-platform.{h,c}` - an example
+  implementation of the platform dependencies that Wasmtime requires. This is
+  defined and documented in
+  `crates/wasmtime/src/runtime/vm/sys/custom/capi.rs`. The example here
+  implements the required functions with Linux syscalls.
+
+* `examples/min-platform/{Cargo.toml,src}` - an example "host embedding" which
+  loads and runs the `embedding` from above. This is a bit contrived and mostly
+  serves as a bit of a test case for Wasmtime itself to execute in CI. The
+  general idea though is that this is a Linux program which will load the
+  `embedding` project above and execute it to showcase that the code works.
+
+* `examples/min-platform/build.sh` - a script to build/run this example.
+
+Taken together this example is unlikely to satisfy any one individual use case
+but should set up the scaffolding to show how Wasmtime can be built for a
+nonstandard platform. Wasmtime effectively only has one requirement from the
+system which is management of virtual memory, and beyond that everything else
+can be internalized.
+
+Note that at this time this support all relies on the fact that the Rust
+standard library can be built for a custom target. Most of the Rust standard
+library will be "stubbed out" however and won't work (e.g. opening a file would
+return an error). This means that not all of the `wasmtime` crate will work, nor
+will all features of the `wasmtime` crate, but the set of features activated
+here should suffice.
+
+## Description
+
+This example will compile Wasmtime to a custom Rust target specified in
+`*.json` files. This custom target, for the example, is modeled after Linux
+except for the fact that Rust won't be able to know that (e.g. the `#[cfg]`
+directives aren't set so code won't know it actually runs on Linux). The
+embedding will run a few small examples of WebAssembly modules and then return.
+
+The host for this is a Linux program which supplies the platform dependencies
+that the embedding requires, for example the `wasmtime_*` symbols. This host
+program will load the embedding and execute it.
+
+## Points of Note
+
+* Due to the usage of custom `*.json` targets, this example requires a nightly
+  Rust compiler.
+* Compiling the embedding requires `--cfg wasmtime_custom_platform` in the
+  `RUSTFLAGS` environment variable. to indicate that Wasmtime's custom C
+  API-based definition of platform support is desired.
+* Due to the usage of a custom target most of libstd doesn't work. For example
+  panics can't print anything and the process can only abort.
+* Due to the custom target not all features of Wasmtime can be enabled because
+  some crates may require platform functionality which can't be defined due to
+  the lack of knowledge of what platform is being targeted.
+
+## Running this example
+
+This example can be built and run with the `./build.sh` script in this
+directory. Example output looks like.
diff --git a/examples/min-platform/build.sh b/examples/min-platform/build.sh
new file mode 100755
index 000000000000..3e6f9d1f0449
--- /dev/null
+++ b/examples/min-platform/build.sh
@@ -0,0 +1,61 @@
+#!/bin/sh
+
+# An example script to build and run the `min-platform` example by building both
+# the embedding itself as well as the example host which will run it.
+#
+# This script takes a single argument which is a path to a Rust target json
+# file. Example targets are `x86_64-unknown-none` or `aarch64-unknown-none`.
+#
+# This script must be executed with the current-working-directory as
+# `examples/min-platform`.
+
+target=$1
+if [ "$target" = "" ]; then
+  echo "Usage: $0 <target>"
+  exit 1
+fi
+
+REPO_DIR=$(dirname $0)/../..
+HOST_DIR=$REPO_DIR/examples/min-platform
+EMBEDDING_DIR=$HOST_DIR/embedding
+
+set -ex
+
+# First compile the C implementation of the platform symbols that will be
+# required by our embedding. This is the `embedding/wasmtime-platform.c` file.
+# The header file used is generated from Rust source code with the `cbindgen`
+# utility which can be installed with:
+#
+#   cargo install cbindgen
+#
+# which ensures that Rust & C agree on types and such.
+cbindgen "$REPO_DIR/crates/wasmtime/src/runtime/vm/sys/custom/capi.rs" \
+    --config "$EMBEDDING_DIR/cbindgen.toml" > "$EMBEDDING_DIR/wasmtime-platform.h"
+clang -shared -O2 -o "$HOST_DIR/libwasmtime-platform.so" "$EMBEDDING_DIR/wasmtime-platform.c" \
+  -D_GNU_SOURCE
+
+# Next the embedding itself is built.
+#
+# Note that this builds the embedding as a static library, here
+# `libembedding.a`. This embedding is then turned into a dynamic library for the
+# host platform using `cc` afterwards. The `*-unknown-none` targets themselves
+# don't support dynamic libraries so this is a bit of a dance to get around the
+# fact that we're pretending this examples in't being compiled for linux.
+cargo build \
+  --manifest-path $EMBEDDING_DIR/Cargo.toml \
+  --target $target \
+  --release
+cc \
+  -Wl,--gc-sections \
+  -Wl,--whole-archive \
+  "$REPO_DIR/target/$target/release/libembedding.a" \
+  -Wl,--no-whole-archive \
+  -shared \
+  -o "$HOST_DIR/libembedding.so"
+
+# The final step here is running the host, in the current directory, which will
+# load the embedding and execute it.
+cargo run --manifest-path "$HOST_DIR/Cargo.toml" --release -- \
+  "$target" \
+  "$HOST_DIR/libembedding.so" \
+  "$HOST_DIR/libwasmtime-platform.so"
diff --git a/examples/min-platform/embedding/Cargo.toml b/examples/min-platform/embedding/Cargo.toml
new file mode 100644
index 000000000000..e218d897fec4
--- /dev/null
+++ b/examples/min-platform/embedding/Cargo.toml
@@ -0,0 +1,25 @@
+[package]
+name = "embedding"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
+
+[dependencies]
+anyhow = { workspace = true }
+
+# Note that default-features of wasmtime are disabled and only those required
+# are enabled, in this case compilation is done in the guest from the wasm text
+# format so `cranelift` and `wat` are enabled.
+wasmtime = { workspace = true, features = ['runtime'] }
+
+# Memory allocator used in this example (not required, however)
+dlmalloc = "0.2.4"
+
+[lib]
+crate-type = ['staticlib']
+test = false
+doctest = false
diff --git a/examples/min-platform/embedding/cbindgen.toml b/examples/min-platform/embedding/cbindgen.toml
new file mode 100644
index 000000000000..081d2ae23b1c
--- /dev/null
+++ b/examples/min-platform/embedding/cbindgen.toml
@@ -0,0 +1,20 @@
+language = "C"
+include_guard = "_WASMTIME_PLATFORM_H"
+include_version = true
+cpp_compat = true
+
+header = """
+// Platform support for Wasmtime's `no_std` build.
+//
+// This header file is what Wasmtime will rely on when it does not otherwise
+// have support for the native platform. This can happen with `no_std` binaries
+// for example where the traditional Unix-or-Windows implementation is not
+// suitable.
+//
+// Embedders are expected to implement the symbols defined in this header file.
+// These symbols can be defined either in C/C++ or in Rust (using
+// `#[no_mangle]`).
+//
+// Some more information about this header can additionally be found at
+// <https://docs.wasmtime.dev/stability-platform-support.html>.
+"""
diff --git a/examples/min-platform/embedding/src/allocator.rs b/examples/min-platform/embedding/src/allocator.rs
new file mode 100644
index 000000000000..821119b0ffb1
--- /dev/null
+++ b/examples/min-platform/embedding/src/allocator.rs
@@ -0,0 +1,165 @@
+//! An allocator definition for this embedding.
+//!
+//! The Rust standard library and Wasmtime require a memory allocator to be
+//! configured. For custom embeddings of Wasmtime this might likely already be
+//! defined elsewhere in the system in which case that should be used. This file
+//! contains an example implementation using the Rust `dlmalloc` crate using
+//! memory created by `wasmtime_*` platform symbols. This provides a file that
+//! manages memory without any extra runtime dependencies, but this is just an
+//! example.
+//!
+//! Allocators in Rust are configured with the `#[global_allocator]` attribute
+//! and the `GlobalAlloc for T` trait impl. This should be used when hooking
+//! up to an allocator elsewhere in the system.
+
+use alloc::alloc::{GlobalAlloc, Layout};
+use core::cell::UnsafeCell;
+use core::ops::{Deref, DerefMut};
+use core::ptr;
+use core::sync::atomic::{
+    AtomicBool,
+    Ordering::{Acquire, Release},
+};
+use dlmalloc::Dlmalloc;
+
+#[global_allocator]
+static MALLOC: MyGlobalDmalloc = MyGlobalDmalloc {
+    dlmalloc: Mutex::new(Dlmalloc::new_with_allocator(MyAllocator)),
+};
+
+struct MyGlobalDmalloc {
+    dlmalloc: Mutex<Dlmalloc<MyAllocator>>,
+}
+
+struct MyAllocator;
+
+unsafe impl GlobalAlloc for MyGlobalDmalloc {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        self.dlmalloc
+            .try_lock()
+            .unwrap()
+            .malloc(layout.size(), layout.align())
+    }
+
+    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
+        self.dlmalloc
+            .try_lock()
+            .unwrap()
+            .calloc(layout.size(), layout.align())
+    }
+
+    unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
+        self.dlmalloc
+            .try_lock()
+            .unwrap()
+            .realloc(ptr, layout.size(), layout.align(), new_size)
+    }
+
+    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+        self.dlmalloc
+            .try_lock()
+            .unwrap()
+            .free(ptr, layout.size(), layout.align())
+    }
+}
+
+// Hand-copied from `crates/wasmtime/src/runtime/vm/sys/custom/capi.rs`.
+const PROT_READ: u32 = 1 << 0;
+const PROT_WRITE: u32 = 1 << 1;
+extern "C" {
+    fn wasmtime_mmap_new(size: usize, prot_flags: u32, ret: &mut *mut u8) -> i32;
+    fn wasmtime_page_size() -> usize;
+    fn wasmtime_munmap(ptr: *mut u8, size: usize) -> i32;
+}
+
+unsafe impl dlmalloc::Allocator for MyAllocator {
+    fn alloc(&self, size: usize) -> (*mut u8, usize, u32) {
+        unsafe {
+            let mut ptr = ptr::null_mut();
+            let rc = wasmtime_mmap_new(size, PROT_READ | PROT_WRITE, &mut ptr);
+            if rc != 0 {
+                (ptr::null_mut(), 0, 0)
+            } else {
+                (ptr, size, 0)
+            }
+        }
+    }
+
+    fn remap(&self, _ptr: *mut u8, _old: usize, _new: usize, _can_move: bool) -> *mut u8 {
+        core::ptr::null_mut()
+    }
+
+    fn free_part(&self, _ptr: *mut u8, _old: usize, _new: usize) -> bool {
+        false
+    }
+
+    fn free(&self, ptr: *mut u8, size: usize) -> bool {
+        unsafe {
+            wasmtime_munmap(ptr, size);
+            true
+        }
+    }
+
+    fn can_release_part(&self, _flags: u32) -> bool {
+        false
+    }
+
+    fn allocates_zeros(&self) -> bool {
+        true
+    }
+
+    fn page_size(&self) -> usize {
+        unsafe { wasmtime_page_size() }
+    }
+}
+
+// Simple mutex which only supports `try_lock` at this time. This would probably
+// be replaced with a "real" mutex in a "real" embedding.
+struct Mutex<T> {
+    data: UnsafeCell<T>,
+    locked: AtomicBool,
+}
+
+unsafe impl<T: Send> Send for Mutex<T> {}
+unsafe impl<T: Send> Sync for Mutex<T> {}
+
+impl<T> Mutex<T> {
+    const fn new(val: T) -> Mutex<T> {
+        Mutex {
+            data: UnsafeCell::new(val),
+            locked: AtomicBool::new(false),
+        }
+    }
+
+    fn try_lock(&self) -> Option<impl DerefMut<Target = T> + '_> {
+        if self.locked.swap(true, Acquire) {
+            None
+        } else {
+            Some(MutexGuard { lock: self })
+        }
+    }
+}
+
+struct MutexGuard<'a, T> {
+    lock: &'a Mutex<T>,
+}
+
+impl<T> Deref for MutexGuard<'_, T> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        unsafe { &*self.lock.data.get() }
+    }
+}
+
+impl<T> DerefMut for MutexGuard<'_, T> {
+    fn deref_mut(&mut self) -> &mut T {
+        unsafe { &mut *self.lock.data.get() }
+    }
+}
+
+impl<T> Drop for MutexGuard<'_, T> {
+    fn drop(&mut self) {
+        self.lock.locked.store(false, Release);
+    }
+}
diff --git a/examples/min-platform/embedding/src/lib.rs b/examples/min-platform/embedding/src/lib.rs
new file mode 100644
index 000000000000..49d0ecaf316f
--- /dev/null
+++ b/examples/min-platform/embedding/src/lib.rs
@@ -0,0 +1,81 @@
+#![no_std]
+
+#[macro_use]
+extern crate alloc;
+
+use anyhow::Result;
+use wasmtime::{Engine, Instance, Linker, Module, Store};
+
+mod allocator;
+mod panic;
+
+/// Entrypoint of this embedding.
+///
+/// This takes a number of parameters which are the precompiled module AOT
+/// images that are run for each of the various tests below. The first parameter
+/// is also where to put an error string, if any, if anything fails.
+#[no_mangle]
+pub unsafe extern "C" fn run(
+    error_buf: *mut u8,
+    error_size: usize,
+    smoke_module: *const u8,
+    smoke_size: usize,
+    simple_add_module: *const u8,
+    simple_add_size: usize,
+    simple_host_fn_module: *const u8,
+    simple_host_fn_size: usize,
+) -> usize {
+    let buf = core::slice::from_raw_parts_mut(error_buf, error_size);
+    let smoke = core::slice::from_raw_parts(smoke_module, smoke_size);
+    let simple_add = core::slice::from_raw_parts(simple_add_module, simple_add_size);
+    let simple_host_fn = core::slice::from_raw_parts(simple_host_fn_module, simple_host_fn_size);
+    match run_result(smoke, simple_add, simple_host_fn) {
+        Ok(()) => 0,
+        Err(e) => {
+            let msg = format!("{e:?}");
+            let len = buf.len().min(msg.len());
+            buf[..len].copy_from_slice(&msg.as_bytes()[..len]);
+            len
+        }
+    }
+}
+
+fn run_result(
+    smoke_module: &[u8],
+    simple_add_module: &[u8],
+    simple_host_fn_module: &[u8],
+) -> Result<()> {
+    smoke(smoke_module)?;
+    simple_add(simple_add_module)?;
+    simple_host_fn(simple_host_fn_module)?;
+    Ok(())
+}
+
+fn smoke(module: &[u8]) -> Result<()> {
+    let engine = Engine::default();
+    let module = unsafe { Module::deserialize(&engine, module)? };
+    Instance::new(&mut Store::new(&engine, ()), &module, &[])?;
+    Ok(())
+}
+
+fn simple_add(module: &[u8]) -> Result<()> {
+    let engine = Engine::default();
+    let module = unsafe { Module::deserialize(&engine, module)? };
+    let mut store = Store::new(&engine, ());
+    let instance = Linker::new(&engine).instantiate(&mut store, &module)?;
+    let func = instance.get_typed_func::<(u32, u32), u32>(&mut store, "add")?;
+    assert_eq!(func.call(&mut store, (2, 3))?, 5);
+    Ok(())
+}
+
+fn simple_host_fn(module: &[u8]) -> Result<()> {
+    let engine = Engine::default();
+    let module = unsafe { Module::deserialize(&engine, module)? };
+    let mut linker = Linker::<()>::new(&engine);
+    linker.func_wrap("host", "multiply", |a: u32, b: u32| a.saturating_mul(b))?;
+    let mut store = Store::new(&engine, ());
+    let instance = linker.instantiate(&mut store, &module)?;
+    let func = instance.get_typed_func::<(u32, u32, u32), u32>(&mut store, "add_and_mul")?;
+    assert_eq!(func.call(&mut store, (2, 3, 4))?, 10);
+    Ok(())
+}
diff --git a/examples/min-platform/embedding/src/panic.rs b/examples/min-platform/embedding/src/panic.rs
new file mode 100644
index 000000000000..81e24c9a539d
--- /dev/null
+++ b/examples/min-platform/embedding/src/panic.rs
@@ -0,0 +1,12 @@
+#![cfg(not(unix))] // gets `cargo clippy` working
+
+use core::panic::PanicInfo;
+
+#[panic_handler]
+fn handler(_info: &PanicInfo) -> ! {
+    // NB: should ideally print something here but for this example this is left
+    // out. A more complete embedding would likely turn `info` into a
+    // stack-allocated string and then pass that as a message to the outer
+    // system to get printed and trigger a failure.
+    loop {}
+}
diff --git a/examples/min-platform/embedding/wasmtime-platform.c b/examples/min-platform/embedding/wasmtime-platform.c
new file mode 100644
index 000000000000..b02783597aae
--- /dev/null
+++ b/examples/min-platform/embedding/wasmtime-platform.c
@@ -0,0 +1,143 @@
+#include <assert.h>
+#include <errno.h>
+#include <setjmp.h>
+#include <signal.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/ucontext.h>
+#include <unistd.h>
+
+#include "wasmtime-platform.h"
+
+static int wasmtime_to_mmap_prot_flags(uint32_t prot_flags) {
+  int flags = 0;
+  if (prot_flags & WASMTIME_PROT_READ)
+    flags |= PROT_READ;
+  if (prot_flags & WASMTIME_PROT_WRITE)
+    flags |= PROT_WRITE;
+  if (prot_flags & WASMTIME_PROT_EXEC)
+    flags |= PROT_EXEC;
+  return flags;
+}
+
+int wasmtime_mmap_new(uintptr_t size, uint32_t prot_flags, uint8_t **ret) {
+  void *rc = mmap(NULL, size, wasmtime_to_mmap_prot_flags(prot_flags),
+                  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+  if (rc == MAP_FAILED)
+    return errno;
+  *ret = rc;
+  return 0;
+}
+
+int wasmtime_mmap_remap(uint8_t *addr, uintptr_t size, uint32_t prot_flags) {
+  void *rc = mmap(addr, size, wasmtime_to_mmap_prot_flags(prot_flags),
+                  MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+  if (rc == MAP_FAILED)
+    return errno;
+  return 0;
+}
+
+int wasmtime_munmap(uint8_t *ptr, uintptr_t size) {
+  int rc = munmap(ptr, size);
+  if (rc != 0)
+    return errno;
+  return 0;
+}
+
+int wasmtime_mprotect(uint8_t *ptr, uintptr_t size, uint32_t prot_flags) {
+  int rc = mprotect(ptr, size, wasmtime_to_mmap_prot_flags(prot_flags));
+  if (rc != 0)
+    return errno;
+  return 0;
+}
+
+uintptr_t wasmtime_page_size(void) { return sysconf(_SC_PAGESIZE); }
+
+int32_t wasmtime_setjmp(const uint8_t **jmp_buf_out,
+                        void (*callback)(uint8_t *, uint8_t *),
+                        uint8_t *payload, uint8_t *callee) {
+  jmp_buf buf;
+  if (setjmp(buf) != 0)
+    return 0;
+  *jmp_buf_out = (uint8_t *)&buf;
+  callback(payload, callee);
+  return 1;
+}
+
+void wasmtime_longjmp(const uint8_t *jmp_buf_ptr) {
+  longjmp(*(jmp_buf *)jmp_buf_ptr, 1);
+}
+
+static wasmtime_trap_handler_t g_handler = NULL;
+
+static void handle_signal(int signo, siginfo_t *info, void *context) {
+  assert(g_handler != NULL);
+  uintptr_t ip, fp;
+#if defined(__aarch64__)
+  ucontext_t *cx = context;
+  ip = cx->uc_mcontext.pc;
+  fp = cx->uc_mcontext.regs[29];
+#elif defined(__x86_64__)
+  ucontext_t *cx = context;
+  ip = cx->uc_mcontext.gregs[REG_RIP];
+  fp = cx->uc_mcontext.gregs[REG_RBP];
+#else
+#error "Unsupported platform"
+#endif
+
+  bool has_faulting_addr = signo == SIGSEGV;
+  uintptr_t faulting_addr = 0;
+  if (has_faulting_addr)
+    faulting_addr = (uintptr_t)info->si_addr;
+  g_handler(ip, fp, has_faulting_addr, faulting_addr);
+
+  // If wasmtime didn't handle this trap then reset the handler to the default
+  // behavior which will probably abort the process.
+  signal(signo, SIG_DFL);
+}
+
+int wasmtime_init_traps(wasmtime_trap_handler_t handler) {
+  int rc;
+  g_handler = handler;
+
+  struct sigaction action;
+  memset(&action, 0, sizeof(action));
+
+  action.sa_sigaction = handle_signal;
+  action.sa_flags = SA_SIGINFO | SA_NODEFER;
+  sigemptyset(&action.sa_mask);
+
+  rc = sigaction(SIGILL, &action, NULL);
+  if (rc != 0)
+    return errno;
+  rc = sigaction(SIGSEGV, &action, NULL);
+  if (rc != 0)
+    return errno;
+  rc = sigaction(SIGFPE, &action, NULL);
+  if (rc != 0)
+    return errno;
+  return 0;
+}
+
+int wasmtime_memory_image_new(const uint8_t *ptr, uintptr_t len,
+                              struct wasmtime_memory_image **ret) {
+  *ret = NULL;
+  return 0;
+}
+
+int wasmtime_memory_image_map_at(struct wasmtime_memory_image *image,
+                                 uint8_t *addr, uintptr_t len) {
+  abort();
+}
+
+void wasmtime_memory_image_free(struct wasmtime_memory_image *image) {
+  abort();
+}
+
+// Pretend that this platform doesn't have threads where storing in a static is
+// ok.
+static uint8_t *WASMTIME_TLS = NULL;
+
+uint8_t *wasmtime_tls_get() { return WASMTIME_TLS; }
+
+void wasmtime_tls_set(uint8_t *val) { WASMTIME_TLS = val; }
diff --git a/examples/min-platform/embedding/wasmtime-platform.h b/examples/min-platform/embedding/wasmtime-platform.h
new file mode 100644
index 000000000000..6583e40d9ece
--- /dev/null
+++ b/examples/min-platform/embedding/wasmtime-platform.h
@@ -0,0 +1,259 @@
+// Platform support for Wasmtime's `no_std` build.
+//
+// This header file is what Wasmtime will rely on when it does not otherwise
+// have support for the native platform. This can happen with `no_std` binaries
+// for example where the traditional Unix-or-Windows implementation is not
+// suitable.
+//
+// Embedders are expected to implement the symbols defined in this header file.
+// These symbols can be defined either in C/C++ or in Rust (using
+// `#[no_mangle]`).
+//
+// Some more information about this header can additionally be found at
+// <https://docs.wasmtime.dev/stability-platform-support.html>.
+
+
+#ifndef _WASMTIME_PLATFORM_H
+#define _WASMTIME_PLATFORM_H
+
+/* Generated with cbindgen:0.26.0 */
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+/**
+ * Indicates that the memory region should be readable.
+ */
+#define WASMTIME_PROT_READ (1 << 0)
+
+/**
+ * Indicates that the memory region should be writable.
+ */
+#define WASMTIME_PROT_WRITE (1 << 1)
+
+/**
+ * Indicates that the memory region should be executable.
+ */
+#define WASMTIME_PROT_EXEC (1 << 2)
+
+/**
+ * Abstract pointer type used in the `wasmtime_memory_image_*` APIs which
+ * is defined by the embedder.
+ */
+typedef struct wasmtime_memory_image wasmtime_memory_image;
+
+/**
+ * Handler function for traps in Wasmtime passed to `wasmtime_init_traps`.
+ *
+ * This function is invoked whenever a trap is caught by the system. For
+ * example this would be invoked during a signal handler on Linux. This
+ * function is passed a number of parameters indicating information about the
+ * trap:
+ *
+ * * `ip` - the instruction pointer at the time of the trap.
+ * * `fp` - the frame pointer register's value at the time of the trap.
+ * * `has_faulting_addr` - whether this trap is associated with an access
+ *   violation (e.g. a segfault) meaning memory was accessed when it shouldn't
+ *   be. If this is `true` then the next parameter is filled in.
+ * * `faulting_addr` - if `has_faulting_addr` is true then this is the address
+ *   that was attempted to be accessed. Otherwise this value is not used.
+ *
+ * If this function returns then the trap was not handled by Wasmtime. This
+ * means that it's left up to the embedder how to deal with the trap/signal
+ * depending on its default behavior. This could mean forwarding to a
+ * non-Wasmtime handler, aborting the process, logging then crashing, etc. The
+ * meaning of a trap that's not handled by Wasmtime depends on the context in
+ * which the trap was generated.
+ *
+ * When this function does not return it's because `wasmtime_longjmp` is
+ * used to handle a Wasm-based trap.
+ */
+typedef void (*wasmtime_trap_handler_t)(uintptr_t ip,
+                                        uintptr_t fp,
+                                        bool has_faulting_addr,
+                                        uintptr_t faulting_addr);
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+/**
+ * Creates a new virtual memory mapping of the `size` specified with
+ * protection bits specified in `prot_flags`.
+ *
+ * Memory can be lazily committed.
+ *
+ * Stores the base pointer of the new mapping in `ret` on success.
+ *
+ * Returns 0 on success and an error code on failure.
+ *
+ * Similar to `mmap(0, size, prot_flags, MAP_PRIVATE, 0, -1)` on Linux.
+ */
+extern int32_t wasmtime_mmap_new(uintptr_t size, uint32_t prot_flags, uint8_t **ret);
+
+/**
+ * Remaps the virtual memory starting at `addr` going for `size` bytes to
+ * the protections specified with a new blank mapping.
+ *
+ * This will unmap any prior mappings and decommit them. New mappings for
+ * anonymous memory are used to replace these mappings and the new area
+ * should have the protection specified by `prot_flags`.
+ *
+ * Returns 0 on success and an error code on failure.
+ *
+ * Similar to `mmap(addr, size, prot_flags, MAP_PRIVATE | MAP_FIXED, 0, -1)` on Linux.
+ */
+extern int32_t wasmtime_mmap_remap(uint8_t *addr, uintptr_t size, uint32_t prot_flags);
+
+/**
+ * Unmaps memory at the specified `ptr` for `size` bytes.
+ *
+ * The memory should be discarded and decommitted and should generate a
+ * segfault if accessed after this function call.
+ *
+ * Returns 0 on success and an error code on failure.
+ *
+ * Similar to `munmap` on Linux.
+ */
+extern int32_t wasmtime_munmap(uint8_t *ptr, uintptr_t size);
+
+/**
+ * Configures the protections associated with a region of virtual memory
+ * starting at `ptr` and going to `size`.
+ *
+ * Returns 0 on success and an error code on failure.
+ *
+ * Similar to `mprotect` on Linux.
+ */
+extern int32_t wasmtime_mprotect(uint8_t *ptr, uintptr_t size, uint32_t prot_flags);
+
+/**
+ * Returns the page size, in bytes, of the current system.
+ */
+extern uintptr_t wasmtime_page_size(void);
+
+/**
+ * Used to setup a frame on the stack to longjmp back to in the future.
+ *
+ * This function is used for handling traps in WebAssembly and is paried
+ * with `wasmtime_longjmp`.
+ *
+ * * `jmp_buf` - this argument is filled in with a pointer which if used
+ *   will be passed to `wasmtime_longjmp` later on by the runtime.
+ * * `callback` - this callback should be invoked after `jmp_buf` is
+ *   configured.
+ * * `payload` and `callee` - the two arguments to pass to `callback`.
+ *
+ * Returns 0 if `wasmtime_longjmp` was used to return to this function.
+ * Returns 1 if `wasmtime_longjmp` was not called and `callback` returned.
+ */
+extern int32_t wasmtime_setjmp(const uint8_t **jmp_buf,
+                               void (*callback)(uint8_t*, uint8_t*),
+                               uint8_t *payload,
+                               uint8_t *callee);
+
+/**
+ * Paired with `wasmtime_setjmp` this is used to jump back to the `setjmp`
+ * point.
+ *
+ * The argument here was originally passed to `wasmtime_setjmp` through its
+ * out-param.
+ *
+ * This function cannot return.
+ *
+ * This function may be invoked from the `wasmtime_trap_handler_t`
+ * configured by `wasmtime_init_traps`.
+ */
+extern void wasmtime_longjmp(const uint8_t *jmp_buf);
+
+/**
+ * Initializes trap-handling logic for this platform.
+ *
+ * Wasmtime's implementation of WebAssembly relies on the ability to catch
+ * signals/traps/etc. For example divide-by-zero may raise a machine
+ * exception. Out-of-bounds memory accesses may also raise a machine
+ * exception. This function is used to initialize trap handling.
+ *
+ * The `handler` provided is a function pointer to invoke whenever a trap
+ * is encountered. The `handler` is invoked whenever a trap is caught by
+ * the system.
+ *
+ * Returns 0 on success and an error code on failure.
+ */
+extern int32_t wasmtime_init_traps(wasmtime_trap_handler_t handler);
+
+/**
+ * Attempts to create a new in-memory image of the `ptr`/`len` combo which
+ * can be mapped to virtual addresses in the future.
+ *
+ * On success the returned `wasmtime_memory_image` pointer is stored into `ret`.
+ * This value stored can be `NULL` to indicate that an image cannot be
+ * created but no failure occurred. The structure otherwise will later be
+ * deallocated with `wasmtime_memory_image_free` and
+ * `wasmtime_memory_image_map_at` will be used to map the image into new
+ * regions of the address space.
+ *
+ * The `ptr` and `len` arguments are only valid for this function call, if
+ * the image needs to refer to them in the future then it must make a copy.
+ *
+ * Both `ptr` and `len` are guaranteed to be page-aligned.
+ *
+ * Returns 0 on success and an error code on failure. Note that storing
+ * `NULL` into `ret` is not considered a failure, and failure is used to
+ * indicate that something fatal has happened and Wasmtime will propagate
+ * the error upwards.
+ */
+extern int32_t wasmtime_memory_image_new(const uint8_t *ptr,
+                                         uintptr_t len,
+                                         struct wasmtime_memory_image **ret);
+
+/**
+ * Maps the `image` provided to the virtual address at `addr` and `len`.
+ *
+ * This semantically should make it such that `addr` and `len` looks the
+ * same as the contents of what the memory image was first created with.
+ * The mappings of `addr` should be private and changes do not reflect back
+ * to `wasmtime_memory_image`.
+ *
+ * In effect this is to create a copy-on-write mapping at `addr`/`len`
+ * pointing back to the memory used by the image originally.
+ *
+ * Note that the memory region will be unmapped with `wasmtime_munmap` in
+ * the future.
+ *
+ * Aborts the process on failure.
+ */
+extern int32_t wasmtime_memory_image_map_at(struct wasmtime_memory_image *image,
+                                            uint8_t *addr,
+                                            uintptr_t len);
+
+/**
+ * Deallocates the provided `wasmtime_memory_image`.
+ *
+ * Note that mappings created from this image are not guaranteed to be
+ * deallocated and/or unmapped before this is called.
+ */
+extern void wasmtime_memory_image_free(struct wasmtime_memory_image *image);
+
+/**
+ * Wasmtime requires a single pointer's space of TLS to be used at runtime,
+ * and this function returns the current value of the TLS variable.
+ *
+ * This value should default to `NULL`.
+ */
+extern uint8_t *wasmtime_tls_get(void);
+
+/**
+ * Sets the current TLS value for Wasmtime to the provided value.
+ *
+ * This value should be returned when later calling `wasmtime_tls_get`.
+ */
+extern void wasmtime_tls_set(uint8_t *ptr);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus
+
+#endif /* _WASMTIME_PLATFORM_H */
diff --git a/examples/min-platform/src/main.rs b/examples/min-platform/src/main.rs
new file mode 100644
index 000000000000..8fd6c063de4c
--- /dev/null
+++ b/examples/min-platform/src/main.rs
@@ -0,0 +1,147 @@
+use anyhow::Result;
+
+#[cfg(not(target_os = "linux"))]
+fn main() -> Result<()> {
+    eprintln!("This example only runs on Linux right now");
+    Ok(())
+}
+
+#[cfg(target_os = "linux")]
+fn main() -> Result<()> {
+    use anyhow::{anyhow, Context};
+    use libloading::os::unix::{Library, Symbol, RTLD_GLOBAL, RTLD_NOW};
+    use object::{Object, ObjectSymbol};
+    use std::io::Write;
+    use wasmtime::{Config, Engine};
+
+    let mut args = std::env::args();
+    let _current_exe = args.next();
+    let triple = args
+        .next()
+        .ok_or_else(|| anyhow!("missing argument 1: triple"))?;
+    let embedding_so_path = args
+        .next()
+        .ok_or_else(|| anyhow!("missing argument 2: path to libembedding.so"))?;
+    let platform_so_path = args
+        .next()
+        .ok_or_else(|| anyhow!("missing argument 3: path to libwasmtime-platform.so"))?;
+
+    // Path to the artifact which is the build of the embedding.
+    //
+    // In this example this is a dynamic library intended to be run on Linux.
+    // Note that this is just an example of an artifact and custom build
+    // processes can produce different kinds of artifacts.
+    let binary = std::fs::read(&embedding_so_path)?;
+    let object = object::File::parse(&binary[..])?;
+
+    // Showcase verification that the dynamic library in question doesn't depend
+    // on much. Wasmtime build in a "minimal platform" mode is allowed to
+    // depend on some standard C symbols such as `memcpy` but any OS-related
+    // symbol must be prefixed by `wasmtime_*` and be documented in
+    // `crates/wasmtime/src/runtime/vm/sys/custom/capi.rs`.
+    //
+    // This is effectively a double-check of the above assertion and showing how
+    // running `libembedding.so` in this case requires only minimal
+    // dependencies.
+    for sym in object.symbols() {
+        if !sym.is_undefined() || sym.is_weak() {
+            continue;
+        }
+
+        match sym.name()? {
+            "memmove" | "memset" | "memcmp" | "memcpy" | "bcmp" | "__tls_get_addr" => {}
+            s if s.starts_with("wasmtime_") => {}
+            other => {
+                panic!("unexpected dependency on symbol `{other}`")
+            }
+        }
+    }
+
+    // Precompile modules for the embedding. Right now Wasmtime in no_std mode
+    // does not have support for Cranelift meaning that AOT mode must be used.
+    // Modules are compiled here and then given to the embedding via the `run`
+    // function below.
+    //
+    // Note that `Config::target` is used here to enable cross-compilation.
+    let mut config = Config::new();
+    config.target(&triple)?;
+    let engine = Engine::new(&config)?;
+    let smoke = engine.precompile_module(b"(module)")?;
+    let simple_add = engine.precompile_module(
+        br#"
+            (module
+                (func (export "add") (param i32 i32) (result i32)
+                    (i32.add (local.get 0) (local.get 1)))
+            )
+        "#,
+    )?;
+    let simple_host_fn = engine.precompile_module(
+        br#"
+            (module
+                (import "host" "multiply" (func $multiply (param i32 i32) (result i32)))
+                (func (export "add_and_mul") (param i32 i32 i32) (result i32)
+                    (i32.add (call $multiply (local.get 0) (local.get 1)) (local.get 2)))
+            )
+        "#,
+    )?;
+
+    // Next is an example of running this embedding, which also serves as test
+    // that basic functionality actually works.
+    //
+    // Here the `wasmtime_*` symbols are implemented by
+    // `./embedding/wasmtime-platform.c` which is an example implementation
+    // against glibc on Linux. This library is compiled into
+    // `libwasmtime-platform.so` and is dynamically opened here to make it
+    // available for later symbol resolution. This is just an implementation
+    // detail of this exable to enably dynamically loading `libembedding.so`
+    // next.
+    //
+    // Next the `libembedding.so` library is opened and the `run` symbol is
+    // run. The dependencies of `libembedding.so` are either satisfied by our
+    // ambient libc (e.g. `memcpy` and friends) or `libwasmtime-platform.so`
+    // (e.g. `wasmtime_*` symbols).
+    //
+    // The embedding is then run to showcase an example and then an error, if
+    // any, is written to stderr.
+    unsafe {
+        let _platform_symbols = Library::open(Some(&platform_so_path), RTLD_NOW | RTLD_GLOBAL)
+            .with_context(|| {
+                format!(
+                    "failed to open {platform_so_path:?}; cwd = {:?}",
+                    std::env::current_dir()
+                )
+            })?;
+
+        let lib = Library::new(&embedding_so_path).context("failed to create new library")?;
+        let run: Symbol<
+            extern "C" fn(
+                *mut u8,
+                usize,
+                *const u8,
+                usize,
+                *const u8,
+                usize,
+                *const u8,
+                usize,
+            ) -> usize,
+        > = lib
+            .get(b"run")
+            .context("failed to find the `run` symbol in the library")?;
+
+        let mut error_buf = Vec::with_capacity(1024);
+        let len = run(
+            error_buf.as_mut_ptr(),
+            error_buf.capacity(),
+            smoke.as_ptr(),
+            smoke.len(),
+            simple_add.as_ptr(),
+            simple_add.len(),
+            simple_host_fn.as_ptr(),
+            simple_host_fn.len(),
+        );
+        error_buf.set_len(len);
+
+        std::io::stderr().write_all(&error_buf).unwrap();
+    }
+    Ok(())
+}
diff --git a/examples/mpk-available.rs b/examples/mpk-available.rs
new file mode 100644
index 000000000000..e486631123b9
--- /dev/null
+++ b/examples/mpk-available.rs
@@ -0,0 +1,16 @@
+//! This example checks if memory protection keys (MPK) are available on the
+//! current system using the
+//! [`PoolingAllocationConfig::are_memory_protection_keys_available`] API.
+
+use std::process::exit;
+use wasmtime::*;
+
+fn main() {
+    if PoolingAllocationConfig::are_memory_protection_keys_available() {
+        eprintln!("MPK is available");
+        exit(0);
+    } else {
+        eprintln!("MPK is not available");
+        exit(1);
+    }
+}
diff --git a/examples/mpk.rs b/examples/mpk.rs
new file mode 100644
index 000000000000..232160b151dd
--- /dev/null
+++ b/examples/mpk.rs
@@ -0,0 +1,263 @@
+//! This example demonstrates:
+//! - how to enable memory protection keys (MPK) in a Wasmtime embedding (see
+//!   [`build_engine`])
+//! - the expected memory compression from using MPK: it will probe the system
+//!   by creating larger and larger memory pools until system memory is
+//!   exhausted (see [`probe_engine_size`]). Then, it prints a comparison of the
+//!   memory used in both the MPK enabled and MPK disabled configurations.
+//!
+//! You can execute this example with:
+//!
+//! ```console
+//! $ cargo run --example mpk
+//! ```
+//!
+//! Append `-- --help` for details about the configuring the memory size of the
+//! pool. Also, to inspect interesting configuration values used for
+//! constructing the pool, turn on logging:
+//!
+//! ```console
+//! $ RUST_LOG=debug cargo run --example mpk -- --memory-size 512MiB
+//! ```
+//!
+//! Note that MPK support is limited to x86 Linux systems. OS limits on the
+//! number of virtual memory areas (VMAs) can significantly restrict the total
+//! number MPK-striped memory slots; each MPK-protected slot ends up using a new
+//! VMA entry. On Linux, one can raise this limit:
+//!
+//! ```console
+//! $ sysctl vm.max_map_count
+//! 65530
+//! $ sysctl vm.max_map_count=$LARGER_LIMIT
+//! ```
+
+use anyhow::anyhow;
+use bytesize::ByteSize;
+use clap::Parser;
+use log::{info, warn};
+use std::str::FromStr;
+use wasmtime::*;
+
+fn main() -> Result<()> {
+    env_logger::init();
+    let args = Args::parse();
+    info!("{:?}", args);
+
+    let without_mpk = probe_engine_size(&args, MpkEnabled::Disable)?;
+    println!("without MPK:\t{}", without_mpk.to_string());
+
+    if PoolingAllocationConfig::are_memory_protection_keys_available() {
+        let with_mpk = probe_engine_size(&args, MpkEnabled::Enable)?;
+        println!("with MPK:\t{}", with_mpk.to_string());
+        println!(
+            "\t\t{}x more slots per reserved memory",
+            with_mpk.compare(&without_mpk)
+        );
+    } else {
+        println!("with MPK:\tunavailable\t\tunavailable");
+    }
+
+    Ok(())
+}
+
+#[derive(Debug, Parser)]
+#[command(author, version, about, long_about = None)]
+struct Args {
+    /// The maximum number of bytes for each WebAssembly linear memory in the
+    /// pool.
+    #[arg(long, default_value = "128MiB", value_parser = parse_byte_size)]
+    memory_size: usize,
+
+    /// The maximum number of bytes a memory is considered static; see
+    /// `Config::static_memory_maximum_size` for more details and the default
+    /// value if unset.
+    #[arg(long, value_parser = parse_byte_size)]
+    static_memory_maximum_size: Option<u64>,
+
+    /// The size in bytes of the guard region to expect between static memory
+    /// slots; see [`Config::static_memory_guard_size`] for more details and the
+    /// default value if unset.
+    #[arg(long, value_parser = parse_byte_size)]
+    static_memory_guard_size: Option<u64>,
+}
+
+/// Parse a human-readable byte size--e.g., "512 MiB"--into the correct number
+/// of bytes.
+fn parse_byte_size(value: &str) -> Result<u64> {
+    let size = ByteSize::from_str(value).map_err(|e| anyhow!(e))?;
+    Ok(size.as_u64())
+}
+
+/// Find the engine with the largest number of memories we can create on this
+/// machine.
+fn probe_engine_size(args: &Args, mpk: MpkEnabled) -> Result<Pool> {
+    let mut search = ExponentialSearch::new();
+    let mut mapped_bytes = 0;
+    while !search.done() {
+        match build_engine(&args, search.next(), mpk) {
+            Ok(rb) => {
+                // TODO: assert!(rb >= mapped_bytes);
+                mapped_bytes = rb;
+                search.record(true)
+            }
+            Err(e) => {
+                warn!("failed engine allocation, continuing search: {:?}", e);
+                search.record(false)
+            }
+        }
+    }
+    Ok(Pool {
+        num_memories: search.next(),
+        mapped_bytes,
+    })
+}
+
+#[derive(Debug)]
+#[allow(dead_code)]
+struct Pool {
+    num_memories: u32,
+    mapped_bytes: usize,
+}
+impl Pool {
+    /// Print a human-readable, tab-separated description of this structure.
+    fn to_string(&self) -> String {
+        let human_size = ByteSize::b(self.mapped_bytes as u64).to_string_as(true);
+        format!(
+            "{} memory slots\t{} reserved",
+            self.num_memories, human_size
+        )
+    }
+    /// Return the number of times more memory slots in `self` than `other`
+    /// after normalizing by the mapped bytes sizes. Rounds to three decimal
+    /// places arbitrarily; no significance intended.
+    fn compare(&self, other: &Pool) -> f64 {
+        let size_ratio = other.mapped_bytes as f64 / self.mapped_bytes as f64;
+        let slots_ratio = self.num_memories as f64 / other.num_memories as f64;
+        let times_more_efficient = slots_ratio * size_ratio;
+        (times_more_efficient * 1000.0).round() / 1000.0
+    }
+}
+
+/// Exponentially increase the `next` value until the attempts fail, then
+/// perform a binary search to find the maximum attempted value that still
+/// succeeds.
+#[derive(Debug)]
+struct ExponentialSearch {
+    /// Determines if we are in the growth phase.
+    growing: bool,
+    /// The last successful value tried; this is the algorithm's lower bound.
+    last: u32,
+    /// The next value to try; this is the algorithm's upper bound.
+    next: u32,
+}
+impl ExponentialSearch {
+    fn new() -> Self {
+        Self {
+            growing: true,
+            last: 0,
+            next: 1,
+        }
+    }
+    fn next(&self) -> u32 {
+        self.next
+    }
+    fn record(&mut self, success: bool) {
+        if !success {
+            self.growing = false
+        }
+        let diff = if self.growing {
+            (self.next - self.last) * 2
+        } else {
+            (self.next - self.last + 1) / 2
+        };
+        if success {
+            self.last = self.next;
+            self.next = self.next + diff;
+        } else {
+            self.next = self.next - diff;
+        }
+    }
+    fn done(&self) -> bool {
+        self.last == self.next
+    }
+}
+
+/// Build a pool-allocated engine with `num_memories` slots.
+fn build_engine(args: &Args, num_memories: u32, enable_mpk: MpkEnabled) -> Result<usize> {
+    // Configure the memory pool.
+    let mut pool = PoolingAllocationConfig::default();
+    pool.max_memory_size(args.memory_size);
+    pool.total_memories(num_memories)
+        .memory_protection_keys(enable_mpk);
+
+    // Configure the engine itself.
+    let mut config = Config::new();
+    if let Some(static_memory_maximum_size) = args.static_memory_maximum_size {
+        config.static_memory_maximum_size(static_memory_maximum_size);
+    }
+    if let Some(static_memory_guard_size) = args.static_memory_guard_size {
+        config.static_memory_guard_size(static_memory_guard_size);
+    }
+    config.allocation_strategy(InstanceAllocationStrategy::Pooling(pool));
+
+    // Measure memory use before and after the engine is built.
+    let mapped_bytes_before = num_bytes_mapped()?;
+    let engine = Engine::new(&config)?;
+    let mapped_bytes_after = num_bytes_mapped()?;
+
+    // Ensure we actually use the engine somehow.
+    engine.increment_epoch();
+
+    let mapped_bytes = mapped_bytes_after - mapped_bytes_before;
+    info!(
+        "{}-slot pool ({:?}): {} bytes mapped",
+        num_memories, enable_mpk, mapped_bytes
+    );
+    Ok(mapped_bytes)
+}
+
+/// Add up the sizes of all the mapped virtual memory regions for the current
+/// Linux process.
+///
+/// This manually parses `/proc/self/maps` to avoid a rather-large `proc-maps`
+/// dependency. We do expect this example to be Linux-specific anyways. For
+/// reference, lines of that file look like:
+///
+/// ```text
+/// 5652d4418000-5652d441a000 r--p 00000000 00:23 84629427 /usr/bin/...
+/// ```
+///
+/// We parse the start and end addresses: <start>-<end> [ignore the rest].
+#[cfg(target_os = "linux")]
+fn num_bytes_mapped() -> Result<usize> {
+    use std::fs::File;
+    use std::io::{BufRead, BufReader};
+
+    let file = File::open("/proc/self/maps")?;
+    let reader = BufReader::new(file);
+    let mut total = 0;
+    for line in reader.lines() {
+        let line = line?;
+        let range = line
+            .split_whitespace()
+            .next()
+            .ok_or(anyhow!("parse failure: expected whitespace"))?;
+        let mut addresses = range.split("-");
+        let start = addresses
+            .next()
+            .ok_or(anyhow!("parse failure: expected dash-separated address"))?;
+        let start = usize::from_str_radix(start, 16)?;
+        let end = addresses
+            .next()
+            .ok_or(anyhow!("parse failure: expected dash-separated address"))?;
+        let end = usize::from_str_radix(end, 16)?;
+
+        total += end - start;
+    }
+    Ok(total)
+}
+
+#[cfg(not(target_os = "linux"))]
+fn num_bytes_mapped() -> Result<usize> {
+    anyhow::bail!("this example can only read virtual memory maps on Linux")
+}
diff --git a/examples/multi.c b/examples/multi.c
index 4039e2a89eb8..af1e611579c0 100644
--- a/examples/multi.c
+++ b/examples/multi.c
@@ -7,7 +7,6 @@ You can compile and run this example on Linux with:
    cargo build --release -p wasmtime-c-api
    cc examples/multi.c \
        -I crates/c-api/include \
-       -I crates/c-api/wasm-c-api/include \
        target/release/libwasmtime.a \
        -lpthread -ldl -lm \
        -o multi
@@ -25,26 +24,22 @@ Also note that this example was taken from
 originally
 */
 
+#include <inttypes.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <inttypes.h>
 #include <wasm.h>
 #include <wasmtime.h>
 
-static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap);
+static void exit_with_error(const char *message, wasmtime_error_t *error,
+                            wasm_trap_t *trap);
 
 // A function to be called from Wasm code.
-wasm_trap_t* callback(
-  void *env,
-  wasmtime_caller_t *caller,
-  const wasmtime_val_t* args,
-  size_t nargs,
-  wasmtime_val_t* results,
-  size_t nresults
-) {
+wasm_trap_t *callback(void *env, wasmtime_caller_t *caller,
+                      const wasmtime_val_t *args, size_t nargs,
+                      wasmtime_val_t *results, size_t nresults) {
   printf("Calling back...\n");
-  printf("> %"PRIu32" %"PRIu64"\n", args[0].of.i32, args[1].of.i64);
+  printf("> %" PRIu32 " %" PRIu64 "\n", args[0].of.i32, args[1].of.i64);
   printf("\n");
 
   results[0] = args[1];
@@ -52,17 +47,11 @@ wasm_trap_t* callback(
   return NULL;
 }
 
-
 // A function closure.
-wasm_trap_t* closure_callback(
-  void* env,
-  wasmtime_caller_t *caller,
-  const wasmtime_val_t* args,
-  size_t nargs,
-  wasmtime_val_t* results,
-  size_t nresults
-) {
-  int i = *(int*)env;
+wasm_trap_t *closure_callback(void *env, wasmtime_caller_t *caller,
+                              const wasmtime_val_t *args, size_t nargs,
+                              wasmtime_val_t *results, size_t nresults) {
+  int i = *(int *)env;
   printf("Calling back closure...\n");
   printf("> %d\n", i);
 
@@ -71,16 +60,15 @@ wasm_trap_t* closure_callback(
   return NULL;
 }
 
-
-int main(int argc, const char* argv[]) {
+int main(int argc, const char *argv[]) {
   // Initialize.
   printf("Initializing...\n");
-  wasm_engine_t* engine = wasm_engine_new();
-  wasmtime_store_t* store = wasmtime_store_new(engine, NULL, NULL);
+  wasm_engine_t *engine = wasm_engine_new();
+  wasmtime_store_t *store = wasmtime_store_new(engine, NULL, NULL);
   wasmtime_context_t *context = wasmtime_store_context(store);
 
   // Load our input file to parse it next
-  FILE* file = fopen("examples/multi.wat", "r");
+  FILE *file = fopen("examples/multi.wat", "r");
   if (!file) {
     printf("> Error loading file!\n");
     return 1;
@@ -105,22 +93,21 @@ int main(int argc, const char* argv[]) {
 
   // Compile.
   printf("Compiling module...\n");
-  wasmtime_module_t* module = NULL;
-  error = wasmtime_module_new(engine, (uint8_t*) binary.data, binary.size, &module);
+  wasmtime_module_t *module = NULL;
+  error =
+      wasmtime_module_new(engine, (uint8_t *)binary.data, binary.size, &module);
   if (error)
     exit_with_error("failed to compile module", error, NULL);
   wasm_byte_vec_delete(&binary);
 
   // Create external print functions.
   printf("Creating callback...\n");
-  wasm_functype_t* callback_type = wasm_functype_new_2_2(
-      wasm_valtype_new_i32(),
-      wasm_valtype_new_i64(),
-      wasm_valtype_new_i64(),
-      wasm_valtype_new_i32()
-  );
+  wasm_functype_t *callback_type =
+      wasm_functype_new_2_2(wasm_valtype_new_i32(), wasm_valtype_new_i64(),
+                            wasm_valtype_new_i64(), wasm_valtype_new_i32());
   wasmtime_func_t callback_func;
-  wasmtime_func_new(context, callback_type, callback, NULL, NULL, &callback_func);
+  wasmtime_func_new(context, callback_type, callback, NULL, NULL,
+                    &callback_func);
   wasm_functype_delete(callback_type);
 
   // Instantiate.
@@ -129,7 +116,7 @@ int main(int argc, const char* argv[]) {
   imports[0].kind = WASMTIME_EXTERN_FUNC;
   imports[0].of.func = callback_func;
   wasmtime_instance_t instance;
-  wasm_trap_t* trap = NULL;
+  wasm_trap_t *trap = NULL;
   error = wasmtime_instance_new(context, module, imports, 1, &instance, &trap);
   if (error != NULL || trap != NULL)
     exit_with_error("failed to instantiate", error, trap);
@@ -156,8 +143,7 @@ int main(int argc, const char* argv[]) {
 
   // Print result.
   printf("Printing result...\n");
-  printf("> %"PRIu64" %"PRIu32"\n",
-    results[0].of.i64, results[1].of.i32);
+  printf("> %" PRIu64 " %" PRIu32 "\n", results[0].of.i64, results[1].of.i32);
 
   assert(results[0].kind == WASMTIME_I64);
   assert(results[0].of.i64 == 2);
@@ -174,7 +160,8 @@ int main(int argc, const char* argv[]) {
   return 0;
 }
 
-static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap) {
+static void exit_with_error(const char *message, wasmtime_error_t *error,
+                            wasm_trap_t *trap) {
   fprintf(stderr, "error: %s\n", message);
   wasm_byte_vec_t error_message;
   if (error != NULL) {
@@ -184,7 +171,7 @@ static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_t
     wasm_trap_message(trap, &error_message);
     wasm_trap_delete(trap);
   }
-  fprintf(stderr, "%.*s\n", (int) error_message.size, error_message.data);
+  fprintf(stderr, "%.*s\n", (int)error_message.size, error_message.data);
   wasm_byte_vec_delete(&error_message);
   exit(1);
 }
diff --git a/examples/multi.rs b/examples/multi.rs
index 8f495847b867..57ec84c9f5e4 100644
--- a/examples/multi.rs
+++ b/examples/multi.rs
@@ -40,7 +40,7 @@ fn main() -> Result<()> {
     let (a, b) = g.call(&mut store, (1, 3))?;
 
     println!("Printing result...");
-    println!("> {} {}", a, b);
+    println!("> {a} {b}");
 
     assert_eq!(a, 4);
     assert_eq!(b, 2);
@@ -56,7 +56,7 @@ fn main() -> Result<()> {
     let results = round_trip_many.call(&mut store, (0, 1, 2, 3, 4, 5, 6, 7, 8, 9))?;
 
     println!("Printing result...");
-    println!("> {:?}", results);
+    println!("> {results:?}");
     assert_eq!(results, (0, 1, 2, 3, 4, 5, 6, 7, 8, 9));
 
     Ok(())
diff --git a/examples/multimemory.c b/examples/multimemory.c
index 3f1823d6d326..8fa4973e77da 100644
--- a/examples/multimemory.c
+++ b/examples/multimemory.c
@@ -6,7 +6,6 @@ You can compile and run this example on Linux with:
    cargo build --release -p wasmtime-c-api
    cc examples/multimemory.c \
        -I crates/c-api/include \
-       -I crates/c-api/wasm-c-api/include \
        target/release/libwasmtime.a \
        -lpthread -ldl -lm \
        -o multimemory
@@ -17,7 +16,8 @@ to tweak the `-lpthread` and such annotations.
 
 You can also build using cmake:
 
-mkdir build && cd build && cmake .. && cmake --build . --target wasmtime-multimemory
+mkdir build && cd build && cmake .. && \
+  cmake --build . --target wasmtime-multimemory
 */
 
 #include <inttypes.h>
@@ -27,7 +27,8 @@ mkdir build && cd build && cmake .. && cmake --build . --target wasmtime-multime
 #include <wasm.h>
 #include <wasmtime.h>
 
-static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap);
+static void exit_with_error(const char *message, wasmtime_error_t *error,
+                            wasm_trap_t *trap);
 
 void check(bool success) {
   if (!success) {
@@ -36,16 +37,12 @@ void check(bool success) {
   }
 }
 
-void check_call(wasmtime_context_t *store,
-                wasmtime_func_t *func,
-                const wasmtime_val_t* args,
-                size_t nargs,
-                int32_t expected) {
+void check_call(wasmtime_context_t *store, wasmtime_func_t *func,
+                const wasmtime_val_t *args, size_t nargs, int32_t expected) {
   wasmtime_val_t results[1];
   wasm_trap_t *trap = NULL;
-  wasmtime_error_t *error = wasmtime_func_call(
-      store, func, args, nargs, results, 1, &trap
-  );
+  wasmtime_error_t *error =
+      wasmtime_func_call(store, func, args, nargs, results, 1, &trap);
   if (error != NULL || trap != NULL)
     exit_with_error("failed to call function", error, trap);
   if (results[0].of.i32 != expected) {
@@ -54,18 +51,21 @@ void check_call(wasmtime_context_t *store,
   }
 }
 
-void check_call0(wasmtime_context_t *store, wasmtime_func_t *func, int32_t expected) {
+void check_call0(wasmtime_context_t *store, wasmtime_func_t *func,
+                 int32_t expected) {
   check_call(store, func, NULL, 0, expected);
 }
 
-void check_call1(wasmtime_context_t *store, wasmtime_func_t *func, int32_t arg, int32_t expected) {
+void check_call1(wasmtime_context_t *store, wasmtime_func_t *func, int32_t arg,
+                 int32_t expected) {
   wasmtime_val_t args[1];
   args[0].kind = WASMTIME_I32;
   args[0].of.i32 = arg;
   check_call(store, func, args, 1, expected);
 }
 
-void check_call2(wasmtime_context_t *store, wasmtime_func_t *func, int32_t arg1, int32_t arg2, int32_t expected) {
+void check_call2(wasmtime_context_t *store, wasmtime_func_t *func, int32_t arg1,
+                 int32_t arg2, int32_t expected) {
   wasmtime_val_t args[2];
   args[0].kind = WASMTIME_I32;
   args[0].of.i32 = arg1;
@@ -74,14 +74,17 @@ void check_call2(wasmtime_context_t *store, wasmtime_func_t *func, int32_t arg1,
   check_call(store, func, args, 2, expected);
 }
 
-void check_ok(wasmtime_context_t *store, wasmtime_func_t *func, const wasmtime_val_t* args, size_t nargs) {
+void check_ok(wasmtime_context_t *store, wasmtime_func_t *func,
+              const wasmtime_val_t *args, size_t nargs) {
   wasm_trap_t *trap = NULL;
-  wasmtime_error_t *error = wasmtime_func_call(store, func, args, nargs, NULL, 0, &trap);
+  wasmtime_error_t *error =
+      wasmtime_func_call(store, func, args, nargs, NULL, 0, &trap);
   if (error != NULL || trap != NULL)
     exit_with_error("failed to call function", error, trap);
 }
 
-void check_ok2(wasmtime_context_t *store, wasmtime_func_t *func, int32_t arg1, int32_t arg2) {
+void check_ok2(wasmtime_context_t *store, wasmtime_func_t *func, int32_t arg1,
+               int32_t arg2) {
   wasmtime_val_t args[2];
   args[0].kind = WASMTIME_I32;
   args[0].of.i32 = arg1;
@@ -90,15 +93,13 @@ void check_ok2(wasmtime_context_t *store, wasmtime_func_t *func, int32_t arg1, i
   check_ok(store, func, args, 2);
 }
 
-void check_trap(wasmtime_context_t *store,
-                wasmtime_func_t *func,
-                const wasmtime_val_t *args,
-                size_t nargs,
-                size_t num_results) {
+void check_trap(wasmtime_context_t *store, wasmtime_func_t *func,
+                const wasmtime_val_t *args, size_t nargs, size_t num_results) {
   assert(num_results <= 1);
   wasmtime_val_t results[1];
   wasm_trap_t *trap = NULL;
-  wasmtime_error_t *error = wasmtime_func_call(store, func, args, nargs, results, num_results, &trap);
+  wasmtime_error_t *error =
+      wasmtime_func_call(store, func, args, nargs, results, num_results, &trap);
   if (error != NULL)
     exit_with_error("failed to call function", error, NULL);
   if (trap == NULL) {
@@ -108,14 +109,16 @@ void check_trap(wasmtime_context_t *store,
   wasm_trap_delete(trap);
 }
 
-void check_trap1(wasmtime_context_t *store, wasmtime_func_t *func, int32_t arg) {
+void check_trap1(wasmtime_context_t *store, wasmtime_func_t *func,
+                 int32_t arg) {
   wasmtime_val_t args[1];
   args[0].kind = WASMTIME_I32;
   args[0].of.i32 = arg;
   check_trap(store, func, args, 1, 1);
 }
 
-void check_trap2(wasmtime_context_t *store, wasmtime_func_t *func, int32_t arg1, int32_t arg2) {
+void check_trap2(wasmtime_context_t *store, wasmtime_func_t *func, int32_t arg1,
+                 int32_t arg2) {
   wasmtime_val_t args[2];
   args[0].kind = WASMTIME_I32;
   args[0].of.i32 = arg1;
@@ -124,7 +127,7 @@ void check_trap2(wasmtime_context_t *store, wasmtime_func_t *func, int32_t arg1,
   check_trap(store, func, args, 2, 0);
 }
 
-int main(int argc, const char* argv[]) {
+int main(int argc, const char *argv[]) {
   // Initialize.
   printf("Initializing...\n");
 
@@ -135,11 +138,11 @@ int main(int argc, const char* argv[]) {
   wasm_engine_t *engine = wasm_engine_new_with_config(config);
   assert(engine != NULL);
 
-  wasmtime_store_t* store = wasmtime_store_new(engine, NULL, NULL);
+  wasmtime_store_t *store = wasmtime_store_new(engine, NULL, NULL);
   wasmtime_context_t *context = wasmtime_store_context(store);
 
   // Load our input file to parse it next
-  FILE* file = fopen("examples/multimemory.wat", "r");
+  FILE *file = fopen("examples/multimemory.wat", "r");
   if (!file) {
     printf("> Error loading file!\n");
     return 1;
@@ -164,8 +167,9 @@ int main(int argc, const char* argv[]) {
 
   // Compile.
   printf("Compiling module...\n");
-  wasmtime_module_t* module = NULL;
-  error = wasmtime_module_new(engine, (uint8_t*) binary.data, binary.size, &module);
+  wasmtime_module_t *module = NULL;
+  error =
+      wasmtime_module_new(engine, (uint8_t *)binary.data, binary.size, &module);
   if (error)
     exit_with_error("failed to compile module", error, NULL);
   wasm_byte_vec_delete(&binary);
@@ -185,28 +189,36 @@ int main(int argc, const char* argv[]) {
   wasmtime_func_t size0, load0, store0, size1, load1, store1;
   wasmtime_extern_t item;
   bool ok;
-  ok = wasmtime_instance_export_get(context, &instance, "memory0", strlen("memory0"), &item);
+  ok = wasmtime_instance_export_get(context, &instance, "memory0",
+                                    strlen("memory0"), &item);
   assert(ok && item.kind == WASMTIME_EXTERN_MEMORY);
   memory0 = item.of.memory;
-  ok = wasmtime_instance_export_get(context, &instance, "size0", strlen("size0"), &item);
+  ok = wasmtime_instance_export_get(context, &instance, "size0",
+                                    strlen("size0"), &item);
   assert(ok && item.kind == WASMTIME_EXTERN_FUNC);
   size0 = item.of.func;
-  ok = wasmtime_instance_export_get(context, &instance, "load0", strlen("load0"), &item);
+  ok = wasmtime_instance_export_get(context, &instance, "load0",
+                                    strlen("load0"), &item);
   assert(ok && item.kind == WASMTIME_EXTERN_FUNC);
   load0 = item.of.func;
-  ok = wasmtime_instance_export_get(context, &instance, "store0", strlen("store0"), &item);
+  ok = wasmtime_instance_export_get(context, &instance, "store0",
+                                    strlen("store0"), &item);
   assert(ok && item.kind == WASMTIME_EXTERN_FUNC);
   store0 = item.of.func;
-  ok = wasmtime_instance_export_get(context, &instance, "memory1", strlen("memory1"), &item);
+  ok = wasmtime_instance_export_get(context, &instance, "memory1",
+                                    strlen("memory1"), &item);
   assert(ok && item.kind == WASMTIME_EXTERN_MEMORY);
   memory1 = item.of.memory;
-  ok = wasmtime_instance_export_get(context, &instance, "size1", strlen("size1"), &item);
+  ok = wasmtime_instance_export_get(context, &instance, "size1",
+                                    strlen("size1"), &item);
   assert(ok && item.kind == WASMTIME_EXTERN_FUNC);
   size1 = item.of.func;
-  ok = wasmtime_instance_export_get(context, &instance, "load1", strlen("load1"), &item);
+  ok = wasmtime_instance_export_get(context, &instance, "load1",
+                                    strlen("load1"), &item);
   assert(ok && item.kind == WASMTIME_EXTERN_FUNC);
   load1 = item.of.func;
-  ok = wasmtime_instance_export_get(context, &instance, "store1", strlen("store1"), &item);
+  ok = wasmtime_instance_export_get(context, &instance, "store1",
+                                    strlen("store1"), &item);
   assert(ok && item.kind == WASMTIME_EXTERN_FUNC);
   store1 = item.of.func;
 
@@ -315,7 +327,8 @@ int main(int argc, const char* argv[]) {
   return 0;
 }
 
-static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap) {
+static void exit_with_error(const char *message, wasmtime_error_t *error,
+                            wasm_trap_t *trap) {
   fprintf(stderr, "error: %s\n", message);
   wasm_byte_vec_t error_message;
   if (error != NULL) {
@@ -325,7 +338,7 @@ static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_t
     wasm_trap_message(trap, &error_message);
     wasm_trap_delete(trap);
   }
-  fprintf(stderr, "%.*s\n", (int) error_message.size, error_message.data);
+  fprintf(stderr, "%.*s\n", (int)error_message.size, error_message.data);
   wasm_byte_vec_delete(&error_message);
   exit(1);
 }
diff --git a/examples/multimemory.rs b/examples/multimemory.rs
index 023817f6a657..7964c8c4451a 100644
--- a/examples/multimemory.rs
+++ b/examples/multimemory.rs
@@ -6,7 +6,6 @@
 
 // You can execute this example with `cargo run --example example`
 
-use anyhow::Result;
 use wasmtime::*;
 
 fn main() -> Result<()> {
diff --git a/examples/serialize.c b/examples/serialize.c
index 19052571d432..65fb7263a85b 100644
--- a/examples/serialize.c
+++ b/examples/serialize.c
@@ -7,7 +7,6 @@ You can compile and run this example on Linux with:
    cargo build --release -p wasmtime-c-api
    cc examples/hello.c \
        -I crates/c-api/include \
-       -I crates/c-api/wasm-c-api/include \
        target/release/libwasmtime.a \
        -lpthread -ldl -lm \
        -o hello
@@ -19,7 +18,8 @@ to tweak the `-lpthread` and such annotations as well as the name of the
 
 You can also build using cmake:
 
-mkdir build && cd build && cmake .. && cmake --build . --target wasmtime-serialize
+mkdir build && cd build && cmake .. && \
+  cmake --build . --target wasmtime-serialize
 */
 
 #include <assert.h>
@@ -28,21 +28,18 @@ mkdir build && cd build && cmake .. && cmake --build . --target wasmtime-seriali
 #include <wasm.h>
 #include <wasmtime.h>
 
-static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap);
+static void exit_with_error(const char *message, wasmtime_error_t *error,
+                            wasm_trap_t *trap);
 
-static wasm_trap_t* hello_callback(
-    void *env,
-    wasmtime_caller_t *caller,
-    const wasmtime_val_t* args,
-    size_t nargs,
-    wasmtime_val_t* results,
-    size_t nresults) {
+static wasm_trap_t *hello_callback(void *env, wasmtime_caller_t *caller,
+                                   const wasmtime_val_t *args, size_t nargs,
+                                   wasmtime_val_t *results, size_t nresults) {
   printf("Calling back...\n");
   printf("> Hello World!\n");
   return NULL;
 }
 
-int serialize(wasm_byte_vec_t* buffer) {
+int serialize(wasm_byte_vec_t *buffer) {
   // Set up our compilation context. Note that we could also work with a
   // `wasm_config_t` here to configure what feature are enabled and various
   // compilation settings.
@@ -51,14 +48,17 @@ int serialize(wasm_byte_vec_t* buffer) {
   assert(engine != NULL);
 
   // Read our input file, which in this case is a wasm text file.
-  FILE* file = fopen("examples/hello.wat", "r");
+  FILE *file = fopen("examples/hello.wat", "r");
   assert(file != NULL);
   fseek(file, 0L, SEEK_END);
   size_t file_size = ftell(file);
   fseek(file, 0L, SEEK_SET);
   wasm_byte_vec_t wat;
   wasm_byte_vec_new_uninitialized(&wat, file_size);
-  assert(fread(wat.data, file_size, 1, file) == 1);
+  if (fread(wat.data, file_size, 1, file) != 1) {
+    printf("> Error loading module!\n");
+    return 1;
+  }
   fclose(file);
 
   // Parse the wat into the binary wasm format
@@ -72,7 +72,7 @@ int serialize(wasm_byte_vec_t* buffer) {
   // and serialize into buffer.
   printf("Compiling and serializing module...\n");
   wasmtime_module_t *module = NULL;
-  error = wasmtime_module_new(engine, (uint8_t*)wasm.data, wasm.size, &module);
+  error = wasmtime_module_new(engine, (uint8_t *)wasm.data, wasm.size, &module);
   wasm_byte_vec_delete(&wasm);
   if (error != NULL)
     exit_with_error("failed to compile module", error, NULL);
@@ -87,7 +87,7 @@ int serialize(wasm_byte_vec_t* buffer) {
   return 0;
 }
 
-int deserialize(wasm_byte_vec_t* buffer) {
+int deserialize(wasm_byte_vec_t *buffer) {
   // Set up our compilation context. Note that we could also work with a
   // `wasm_config_t` here to configure what feature are enabled and various
   // compilation settings.
@@ -104,7 +104,8 @@ int deserialize(wasm_byte_vec_t* buffer) {
   // Deserialize compiled module.
   printf("Deserialize module...\n");
   wasmtime_module_t *module = NULL;
-  wasmtime_error_t *error = wasmtime_module_deserialize(engine, (uint8_t*) buffer->data, buffer->size, &module);
+  wasmtime_error_t *error = wasmtime_module_deserialize(
+      engine, (uint8_t *)buffer->data, buffer->size, &module);
   if (error != NULL)
     exit_with_error("failed to compile module", error, NULL);
 
@@ -163,7 +164,8 @@ int main() {
   return 0;
 }
 
-static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap) {
+static void exit_with_error(const char *message, wasmtime_error_t *error,
+                            wasm_trap_t *trap) {
   fprintf(stderr, "error: %s\n", message);
   wasm_byte_vec_t error_message;
   if (error != NULL) {
@@ -173,7 +175,7 @@ static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_t
     wasm_trap_message(trap, &error_message);
     wasm_trap_delete(trap);
   }
-  fprintf(stderr, "%.*s\n", (int) error_message.size, error_message.data);
+  fprintf(stderr, "%.*s\n", (int)error_message.size, error_message.data);
   wasm_byte_vec_delete(&error_message);
   exit(1);
 }
diff --git a/examples/serialize.rs b/examples/serialize.rs
index 0d38fd5f5757..b8abbac6a267 100644
--- a/examples/serialize.rs
+++ b/examples/serialize.rs
@@ -3,7 +3,6 @@
 
 // You can execute this example with `cargo run --example serialize`
 
-use anyhow::Result;
 use wasmtime::*;
 
 fn serialize() -> Result<Vec<u8>> {
diff --git a/examples/threads.c b/examples/threads.c
index 707601be53cf..d89480db6143 100644
--- a/examples/threads.c
+++ b/examples/threads.c
@@ -7,7 +7,6 @@ You can compile and run this example on Linux with:
    cargo build --release -p wasmtime-c-api
    cc examples/threads.c \
        -I crates/c-api/include \
-       -I crates/c-api/wasm-c-api/include \
        target/release/libwasmtime.a \
        -lpthread -ldl -lm \
        -o threads
@@ -25,64 +24,66 @@ mkdir build && cd build && cmake .. && cmake --build . --target wasmtime-threads
 #ifndef _WIN32
 
 #include <inttypes.h>
+#include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <pthread.h>
 #include <unistd.h>
 #include <wasm.h>
 #include <wasmtime.h>
 
 #define own
 
-static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap);
+static void exit_with_error(const char *message, wasmtime_error_t *error,
+                            wasm_trap_t *trap);
 
 const int N_THREADS = 10;
 const int N_REPS = 3;
 
 // A function to be called from Wasm code.
-own wasm_trap_t* callback(const wasm_val_vec_t* args, wasm_val_vec_t* results) {
+own wasm_trap_t *callback(const wasm_val_vec_t *args, wasm_val_vec_t *results) {
   assert(args->data[0].kind == WASM_I32);
   printf("> Thread %d running\n", args->data[0].of.i32);
   return NULL;
 }
 
-
 typedef struct {
-  wasm_engine_t* engine;
-  wasm_shared_module_t* module;
+  wasm_engine_t *engine;
+  wasm_shared_module_t *module;
   int id;
 } thread_args;
 
-void* run(void* args_abs) {
-  thread_args* args = (thread_args*)args_abs;
+void *run(void *args_abs) {
+  thread_args *args = (thread_args *)args_abs;
 
   // Rereate store and module.
-  own wasm_store_t* store = wasm_store_new(args->engine);
-  own wasm_module_t* module = wasm_module_obtain(store, args->module);
+  own wasm_store_t *store = wasm_store_new(args->engine);
+  own wasm_module_t *module = wasm_module_obtain(store, args->module);
 
   // Run the example N times.
   for (int i = 0; i < N_REPS; ++i) {
     usleep(100000);
 
     // Create imports.
-    own wasm_functype_t* func_type = wasm_functype_new_1_0(wasm_valtype_new_i32());
-    own wasm_func_t* func = wasm_func_new(store, func_type, callback);
+    own wasm_functype_t *func_type =
+        wasm_functype_new_1_0(wasm_valtype_new_i32());
+    own wasm_func_t *func = wasm_func_new(store, func_type, callback);
     wasm_functype_delete(func_type);
 
     wasm_val_t val = {.kind = WASM_I32, .of = {.i32 = (int32_t)args->id}};
-    own wasm_globaltype_t* global_type =
-      wasm_globaltype_new(wasm_valtype_new_i32(), WASM_CONST);
-    own wasm_global_t* global = wasm_global_new(store, global_type, &val);
+    own wasm_globaltype_t *global_type =
+        wasm_globaltype_new(wasm_valtype_new_i32(), WASM_CONST);
+    own wasm_global_t *global = wasm_global_new(store, global_type, &val);
     wasm_globaltype_delete(global_type);
 
     // Instantiate.
-    wasm_extern_t* imports[] = {
-      wasm_func_as_extern(func), wasm_global_as_extern(global),
+    wasm_extern_t *imports[] = {
+        wasm_func_as_extern(func),
+        wasm_global_as_extern(global),
     };
     wasm_extern_vec_t imports_vec = WASM_ARRAY_VEC(imports);
-    own wasm_instance_t* instance =
-      wasm_instance_new(store, module, &imports_vec, NULL);
+    own wasm_instance_t *instance =
+        wasm_instance_new(store, module, &imports_vec, NULL);
     if (!instance) {
       printf("> Error instantiating module!\n");
       return NULL;
@@ -127,10 +128,10 @@ void* run(void* args_abs) {
 
 int main(int argc, const char *argv[]) {
   // Initialize.
-  wasm_engine_t* engine = wasm_engine_new();
+  wasm_engine_t *engine = wasm_engine_new();
 
   // Load our input file to parse it next
-  FILE* file = fopen("examples/threads.wat", "r");
+  FILE *file = fopen("examples/threads.wat", "r");
   if (!file) {
     printf("> Error loading file!\n");
     return 1;
@@ -154,8 +155,8 @@ int main(int argc, const char *argv[]) {
   wasm_byte_vec_delete(&wat);
 
   // Compile and share.
-  own wasm_store_t* store = wasm_store_new(engine);
-  own wasm_module_t* module = wasm_module_new(store, &binary);
+  own wasm_store_t *store = wasm_store_new(engine);
+  own wasm_module_t *module = wasm_module_new(store, &binary);
   if (!module) {
     printf("> Error compiling module!\n");
     return 1;
@@ -163,7 +164,7 @@ int main(int argc, const char *argv[]) {
 
   wasm_byte_vec_delete(&binary);
 
-  own wasm_shared_module_t* shared = wasm_module_share(module);
+  own wasm_shared_module_t *shared = wasm_module_share(module);
 
   wasm_module_delete(module);
   wasm_store_delete(store);
@@ -171,12 +172,19 @@ int main(int argc, const char *argv[]) {
   // Spawn threads.
   pthread_t threads[N_THREADS];
   for (int i = 0; i < N_THREADS; i++) {
-    thread_args* args = malloc(sizeof(thread_args));
+    thread_args *args = malloc(sizeof(thread_args));
     args->id = i;
     args->engine = engine;
     args->module = shared;
     printf("Initializing thread %d...\n", i);
-    pthread_create(&threads[i], NULL, &run, args);
+
+    // Guarantee at least 2MB of stack to allow running Cranelift in debug mode
+    // on CI.
+    pthread_attr_t attrs;
+    pthread_attr_init(&attrs);
+    pthread_attr_setstacksize(&attrs, 2 << 20);
+    pthread_create(&threads[i], &attrs, &run, args);
+    pthread_attr_destroy(&attrs);
   }
 
   for (int i = 0; i < N_THREADS; i++) {
@@ -190,7 +198,8 @@ int main(int argc, const char *argv[]) {
   return 0;
 }
 
-static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap) {
+static void exit_with_error(const char *message, wasmtime_error_t *error,
+                            wasm_trap_t *trap) {
   fprintf(stderr, "error: %s\n", message);
   wasm_byte_vec_t error_message;
   if (error != NULL) {
@@ -198,14 +207,12 @@ static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_t
   } else {
     wasm_trap_message(trap, &error_message);
   }
-  fprintf(stderr, "%.*s\n", (int) error_message.size, error_message.data);
+  fprintf(stderr, "%.*s\n", (int)error_message.size, error_message.data);
   wasm_byte_vec_delete(&error_message);
   exit(1);
 }
 
 #else
 // TODO implement example for Windows
-int main(int argc, const char *argv[]) {
-  return 0;
-}
+int main(int argc, const char *argv[]) { return 0; }
 #endif // _WIN32
diff --git a/examples/threads.rs b/examples/threads.rs
index 3c3564833e76..312c7b411ffc 100644
--- a/examples/threads.rs
+++ b/examples/threads.rs
@@ -3,7 +3,6 @@
 
 // You can execute this example with `cargo run --example threads`
 
-use anyhow::Result;
 use std::sync::Arc;
 use std::thread;
 use std::time;
@@ -15,7 +14,7 @@ const N_REPS: i32 = 3;
 fn main() -> Result<()> {
     println!("Initializing...");
 
-    // Initialize global per-process state. This state will be shared amonst all
+    // Initialize global per-process state. This state will be shared amongst all
     // threads. Notably this includes the compiled module as well as a `Linker`,
     // which contains all our host functions we want to define.
     let engine = Engine::default();
diff --git a/examples/tokio/main.rs b/examples/tokio/main.rs
index e90f6de9727c..f35138fe7525 100644
--- a/examples/tokio/main.rs
+++ b/examples/tokio/main.rs
@@ -2,10 +2,10 @@ use anyhow::Error;
 use std::sync::Arc;
 use tokio::time::Duration;
 use wasmtime::{Config, Engine, Linker, Module, Store};
-// For this example we want to use the async version of wasmtime_wasi.
+// For this example we want to use the async version of wasi_common.
 // Notably, this version of wasi uses a scheduler that will async yield
 // when sleeping in `poll_oneoff`.
-use wasmtime_wasi::{tokio::WasiCtxBuilder, WasiCtx};
+use wasi_common::{tokio::WasiCtxBuilder, WasiCtx};
 
 #[tokio::main]
 async fn main() -> Result<(), Error> {
@@ -54,14 +54,14 @@ impl Environment {
         config.consume_fuel(true);
 
         let engine = Engine::new(&config)?;
-        let module = Module::from_file(&engine, "target/wasm32-wasi/debug/tokio-wasi.wasm")?;
+        let module = Module::from_file(&engine, "target/wasm32-wasip1/debug/tokio-wasi.wasm")?;
 
         // A `Linker` is shared in the environment amongst all stores, and this
         // linker is used to instantiate the `module` above. This example only
         // adds WASI functions to the linker, notably the async versions built
         // on tokio.
         let mut linker = Linker::new(&engine);
-        wasmtime_wasi::tokio::add_to_linker(&mut linker, |cx| cx)?;
+        wasi_common::tokio::add_to_linker(&mut linker, |cx| cx)?;
 
         Ok(Self {
             engine,
@@ -94,9 +94,11 @@ async fn run_wasm(inputs: Inputs) -> Result<(), Error> {
         .build();
     let mut store = Store::new(&inputs.env.engine, wasi);
 
+    // Put effectively unlimited fuel so it can run forever.
+    store.set_fuel(u64::MAX)?;
     // WebAssembly execution will be paused for an async yield every time it
-    // consumes 10000 fuel. Fuel will be refilled u64::MAX times.
-    store.out_of_fuel_async_yield(u64::MAX, 10000);
+    // consumes 10000 fuel.
+    store.fuel_async_yield_interval(Some(10000))?;
 
     // Instantiate into our own unique store using the shared linker, afterwards
     // acquiring the `_start` function for the module and executing it.
diff --git a/examples/wasi-async/main.rs b/examples/wasi-async/main.rs
new file mode 100644
index 000000000000..b1c3a4d19b34
--- /dev/null
+++ b/examples/wasi-async/main.rs
@@ -0,0 +1,47 @@
+//! Example of instantiating a wasm module which uses WASI preview1 imports
+//! implemented through the async preview2 WASI implementation.
+
+/*
+You can execute this example with:
+    cmake examples/
+    cargo run --example wasi-async
+*/
+
+use anyhow::Result;
+use wasmtime::{Config, Engine, Linker, Module, Store};
+use wasmtime_wasi::preview1::{self, WasiP1Ctx};
+use wasmtime_wasi::WasiCtxBuilder;
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    // Construct the wasm engine with async support enabled.
+    let mut config = Config::new();
+    config.async_support(true);
+    let engine = Engine::new(&config)?;
+
+    // Add the WASI preview1 API to the linker (will be implemented in terms of
+    // the preview2 API)
+    let mut linker: Linker<WasiP1Ctx> = Linker::new(&engine);
+    preview1::add_to_linker_async(&mut linker, |t| t)?;
+
+    // Add capabilities (e.g. filesystem access) to the WASI preview2 context
+    // here. Here only stdio is inherited, but see docs of `WasiCtxBuilder` for
+    // more.
+    let wasi_ctx = WasiCtxBuilder::new().inherit_stdio().build_p1();
+
+    let mut store = Store::new(&engine, wasi_ctx);
+
+    // Instantiate our 'Hello World' wasm module.
+    // Note: This is a module built against the preview1 WASI API.
+    let module = Module::from_file(&engine, "target/wasm32-wasip1/debug/wasi.wasm")?;
+    let func = linker
+        .module_async(&mut store, "", &module)
+        .await?
+        .get_default(&mut store, "")?
+        .typed::<(), ()>(&store)?;
+
+    // Invoke the WASI program default function.
+    func.call_async(&mut store, ()).await?;
+
+    Ok(())
+}
diff --git a/examples/wasi/main.c b/examples/wasi/main.c
index 2a2ab07324c2..c933be4dc588 100644
--- a/examples/wasi/main.c
+++ b/examples/wasi/main.c
@@ -3,11 +3,10 @@ Example of instantiating a WebAssembly which uses WASI imports.
 
 You can compile and run this example on Linux with:
 
-   cmake example/
+   cmake examples/
    cargo build --release -p wasmtime-c-api
    cc examples/wasi/main.c \
        -I crates/c-api/include \
-       -I crates/c-api/wasm-c-api/include \
        target/release/libwasmtime.a \
        -lpthread -ldl -lm \
        -o wasi
@@ -24,13 +23,14 @@ mkdir build && cd build && cmake .. && cmake --build . --target wasmtime-wasi
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <wasm.h>
 #include <wasi.h>
+#include <wasm.h>
 #include <wasmtime.h>
 
 #define MIN(a, b) ((a) < (b) ? (a) : (b))
 
-static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap);
+static void exit_with_error(const char *message, wasmtime_error_t *error,
+                            wasm_trap_t *trap);
 
 int main() {
   // Set up our context
@@ -48,7 +48,7 @@ int main() {
 
   wasm_byte_vec_t wasm;
   // Load our input file to parse it next
-  FILE* file = fopen("target/wasm32-wasi/debug/wasi.wasm", "rb");
+  FILE *file = fopen("target/wasm32-wasip1/debug/wasi.wasm", "rb");
   if (!file) {
     printf("> Error loading file!\n");
     exit(1);
@@ -65,7 +65,7 @@ int main() {
 
   // Compile our modules
   wasmtime_module_t *module = NULL;
-  error = wasmtime_module_new(engine, (uint8_t*)wasm.data, wasm.size, &module);
+  error = wasmtime_module_new(engine, (uint8_t *)wasm.data, wasm.size, &module);
   if (!module)
     exit_with_error("failed to compile module", error, NULL);
   wasm_byte_vec_delete(&wasm);
@@ -105,7 +105,8 @@ int main() {
   return 0;
 }
 
-static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_trap_t *trap) {
+static void exit_with_error(const char *message, wasmtime_error_t *error,
+                            wasm_trap_t *trap) {
   fprintf(stderr, "error: %s\n", message);
   wasm_byte_vec_t error_message;
   if (error != NULL) {
@@ -115,7 +116,7 @@ static void exit_with_error(const char *message, wasmtime_error_t *error, wasm_t
     wasm_trap_message(trap, &error_message);
     wasm_trap_delete(trap);
   }
-  fprintf(stderr, "%.*s\n", (int) error_message.size, error_message.data);
+  fprintf(stderr, "%.*s\n", (int)error_message.size, error_message.data);
   wasm_byte_vec_delete(&error_message);
   exit(1);
 }
diff --git a/examples/wasi/main.rs b/examples/wasi/main.rs
index 30d8e1f2aed7..c6a3592436fa 100644
--- a/examples/wasi/main.rs
+++ b/examples/wasi/main.rs
@@ -2,19 +2,18 @@
 
 /*
 You can execute this example with:
-    cmake example/
+    cmake examples/
     cargo run --example wasi
 */
 
-use anyhow::Result;
+use wasi_common::sync::WasiCtxBuilder;
 use wasmtime::*;
-use wasmtime_wasi::sync::WasiCtxBuilder;
 
 fn main() -> Result<()> {
     // Define the WASI functions globally on the `Config`.
     let engine = Engine::default();
     let mut linker = Linker::new(&engine);
-    wasmtime_wasi::add_to_linker(&mut linker, |s| s)?;
+    wasi_common::sync::add_to_linker(&mut linker, |s| s)?;
 
     // Create a WASI context and put it in a Store; all instances in the store
     // share this context. `WasiCtxBuilder` provides a number of ways to
@@ -26,7 +25,7 @@ fn main() -> Result<()> {
     let mut store = Store::new(&engine, wasi);
 
     // Instantiate our module with the imports we've created, and run it.
-    let module = Module::from_file(&engine, "target/wasm32-wasi/debug/wasi.wasm")?;
+    let module = Module::from_file(&engine, "target/wasm32-wasip1/debug/wasi.wasm")?;
     linker.module(&mut store, "", &module)?;
     linker
         .get_default(&mut store, "")?
diff --git a/fuzz/Cargo.toml b/fuzz/Cargo.toml
index ef6f2ded09a4..7525a359ddc2 100644
--- a/fuzz/Cargo.toml
+++ b/fuzz/Cargo.toml
@@ -2,13 +2,18 @@
 name = "wasmtime-fuzz"
 version = "0.0.0"
 edition.workspace = true
+rust-version.workspace = true
 publish = false
 
+[lints]
+workspace = true
+
 [package.metadata]
 cargo-fuzz = true
 
 [dependencies]
 anyhow = { workspace = true }
+env_logger = { workspace = true }
 once_cell = { workspace = true }
 cranelift-codegen = { workspace = true, features = ["incremental-cache", "x86", "arm64", "s390x", "riscv64"] }
 cranelift-reader = { workspace = true }
@@ -20,6 +25,7 @@ cranelift-native = { workspace = true }
 cranelift-control = { workspace = true }
 libfuzzer-sys = { workspace = true, features = ["arbitrary-derive"] }
 target-lexicon = { workspace = true }
+pulley-interpreter-fuzz = { workspace = true }
 smallvec = { workspace = true }
 wasmparser = { workspace = true }
 wasmtime = { workspace = true, features = ["winch"] }
@@ -30,7 +36,7 @@ component-fuzz-util = { workspace = true }
 [build-dependencies]
 anyhow = { workspace = true }
 proc-macro2 = "1.0"
-arbitrary = { version = "1.1.0", features = ["derive"] }
+arbitrary = { workspace = true, features = ["derive"] }
 rand = { version = "0.8.0" }
 quote = "1.0"
 component-fuzz-util = { workspace = true }
@@ -65,8 +71,8 @@ test = false
 doc = false
 
 [[bin]]
-name = "spectests"
-path = "fuzz_targets/spectests.rs"
+name = "wast_tests"
+path = "fuzz_targets/wast_tests.rs"
 test = false
 doc = false
 
@@ -82,12 +88,6 @@ path = "fuzz_targets/stacks.rs"
 test = false
 doc = false
 
-[[bin]]
-name = "compile-maybe-invalid"
-path = "fuzz_targets/compile-maybe-invalid.rs"
-test = false
-doc = false
-
 [[bin]]
 name = "cranelift-fuzzgen"
 path = "fuzz_targets/cranelift-fuzzgen.rs"
@@ -111,3 +111,23 @@ name = "cranelift-icache"
 path = "fuzz_targets/cranelift-icache.rs"
 test = false
 doc = false
+
+[[bin]]
+name = "call_async"
+path = "fuzz_targets/call_async.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "memory_accesses"
+path = "fuzz_targets/memory_accesses.rs"
+test = false
+doc = false
+bench = false
+
+[[bin]]
+name = "pulley"
+path = "fuzz_targets/pulley.rs"
+test = false
+doc = false
+bench = false
diff --git a/fuzz/README.md b/fuzz/README.md
index f52c2c71b97c..b8b348991a09 100644
--- a/fuzz/README.md
+++ b/fuzz/README.md
@@ -9,6 +9,31 @@ oracles and pass libFuzzer-provided inputs to them. The test case generators and
 oracles themselves are independent from the fuzzing engine that is driving the
 fuzzing process and are defined in `wasmtime/crates/fuzzing`.
 
+## Safety warning
+
+Fuzzers exist to generate random garbage and then try running it. **You
+should not trust these fuzz targets**: they could in theory try to read
+or write files on your disk, send your private data to reporters, or do
+anything else. If they succeed at doing something malicious, they are
+doing a great job at identifying dangerous bugs and we're proud of them.
+
+In addition, some of these fuzz targets use other libraries, such as to
+test that our implementation matches other WebAssembly runtimes. **We
+have not reviewed those runtimes or libraries** for safety, security,
+correctness, supply-chain attacks, or any other properties. Software
+used only during fuzzing is not subject to [our usual `cargo vet`
+requirements][vet-docs].
+
+[vet-docs]: https://docs.wasmtime.dev/contributing-coding-guidelines.html#dependencies-of-wasmtime
+
+Paragraphs 7 and 8 of the license which this work is distributed to you
+under are especially important here: **We disclaim all warranties and
+liability** if running some fuzz target causes you any harm.
+
+Therefore, **if you are at all concerned about the safety of your
+computer**, then you should either not run these fuzz targets, or only
+run them in a sandbox with sufficient isolation for your threat model.
+
 ## Example
 
 To start fuzzing run the following command, where `$MY_FUZZ_TARGET` is one of
@@ -88,3 +113,15 @@ following steps to reproduce it locally:
    to print the configuration and WebAssembly input used by the test case (see
    uses of  `log_wasm` in the `wasmtime-fuzzing` crate).
 
+## Target specific options
+
+### `cranelift-fuzzgen`
+
+Fuzzgen supports passing the `FUZZGEN_ALLOWED_OPS` environment variable, which when available restricts the instructions that it will generate.
+
+Running `FUZZGEN_ALLOWED_OPS=ineg,ishl cargo fuzz run cranelift-fuzzgen` will run fuzzgen but only generate `ineg` or `ishl` opcodes.
+
+### `cranelift-icache`
+
+The icache target also uses the fuzzgen library, thus also supports the `FUZZGEN_ALLOWED_OPS` environment variable as described in the `cranelift-fuzzgen` section above.
+
diff --git a/fuzz/build.rs b/fuzz/build.rs
index 745a6bb16c9f..5a623e907888 100644
--- a/fuzz/build.rs
+++ b/fuzz/build.rs
@@ -7,7 +7,7 @@ fn main() -> anyhow::Result<()> {
 mod component {
     use anyhow::{anyhow, Context, Error, Result};
     use arbitrary::Unstructured;
-    use component_fuzz_util::{self, Declarations, TestCase, Type, MAX_TYPE_DEPTH};
+    use component_fuzz_util::{Declarations, TestCase, Type, MAX_TYPE_DEPTH};
     use proc_macro2::TokenStream;
     use quote::quote;
     use rand::rngs::StdRng;
diff --git a/fuzz/fuzz_targets/call_async.rs b/fuzz/fuzz_targets/call_async.rs
new file mode 100644
index 000000000000..306872d45ba9
--- /dev/null
+++ b/fuzz/fuzz_targets/call_async.rs
@@ -0,0 +1,39 @@
+#![no_main]
+
+use libfuzzer_sys::arbitrary::{Result, Unstructured};
+use libfuzzer_sys::fuzz_target;
+use wasmtime_fuzzing::{generators, oracles};
+
+fuzz_target!(|data: &[u8]| {
+    // errors in `run` have to do with not enough input in `data`, which we
+    // ignore here since it doesn't affect how we'd like to fuzz.
+    let _ = run_one(data);
+});
+
+fn run_one(data: &[u8]) -> Result<()> {
+    let mut u = Unstructured::new(data);
+    let mut config: generators::Config = u.arbitrary()?;
+
+    // Try to ensure imports/exports/etc are generated by adding one to the
+    // minimums/maximums.
+    config.module_config.config.min_types = 1;
+    config.module_config.config.max_types += 1;
+    config.module_config.config.min_imports = 1;
+    config.module_config.config.max_imports += 1;
+    config.module_config.config.min_funcs = 1;
+    config.module_config.config.max_funcs += 1;
+    config.module_config.config.min_exports = 1;
+    config.module_config.config.max_exports += 1;
+
+    // Use the fuzz input to select an async strategy.
+    config.enable_async(&mut u)?;
+
+    let mut poll_amts = Vec::with_capacity(u.arbitrary_len::<u32>()?);
+    for _ in 0..poll_amts.capacity() {
+        poll_amts.push(u.int_in_range(0..=10_000)?);
+    }
+    let module = config.module_config.generate(&mut u, None)?;
+    oracles::call_async(&module.to_bytes(), &config, &poll_amts);
+
+    Ok(())
+}
diff --git a/fuzz/fuzz_targets/compile-maybe-invalid.rs b/fuzz/fuzz_targets/compile-maybe-invalid.rs
deleted file mode 100644
index 2cdb282f8598..000000000000
--- a/fuzz/fuzz_targets/compile-maybe-invalid.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-#![no_main]
-
-use libfuzzer_sys::fuzz_target;
-use wasmtime::{Engine, Module};
-use wasmtime_fuzzing::wasm_smith::MaybeInvalidModule;
-
-fuzz_target!(|module: MaybeInvalidModule| {
-    let engine = Engine::default();
-    let wasm = module.to_bytes();
-    wasmtime_fuzzing::oracles::log_wasm(&wasm);
-    drop(Module::new(&engine, &wasm));
-});
diff --git a/fuzz/fuzz_targets/cranelift-fuzzgen.rs b/fuzz/fuzz_targets/cranelift-fuzzgen.rs
index 3aa9cb0ef0fd..0582b035cc1a 100644
--- a/fuzz/fuzz_targets/cranelift-fuzzgen.rs
+++ b/fuzz/fuzz_targets/cranelift-fuzzgen.rs
@@ -62,13 +62,13 @@ impl Statistics {
         let run_result_timeout = self.run_result_timeout.load(Ordering::SeqCst);
 
         println!("== FuzzGen Statistics  ====================");
-        println!("Valid Inputs: {}", valid_inputs);
+        println!("Valid Inputs: {valid_inputs}");
         println!(
             "Invalid Inputs: {} ({:.1}% of Total Inputs)",
             invalid_inputs,
             (invalid_inputs as f64 / (valid_inputs + invalid_inputs) as f64) * 100.0
         );
-        println!("Total Runs: {}", total_runs);
+        println!("Total Runs: {total_runs}");
         println!(
             "Successful Runs: {} ({:.1}% of Total Runs)",
             run_result_success,
@@ -107,7 +107,6 @@ impl Default for Statistics {
         // Pre-Register all trap codes since we can't modify this hashmap atomically.
         let mut run_result_trap = HashMap::new();
         run_result_trap.insert(CraneliftTrap::Debug, AtomicU64::new(0));
-        run_result_trap.insert(CraneliftTrap::Resumable, AtomicU64::new(0));
         for trapcode in TrapCode::non_user_traps() {
             run_result_trap.insert(CraneliftTrap::User(*trapcode), AtomicU64::new(0));
         }
@@ -172,6 +171,7 @@ impl fmt::Debug for TestCase {
 
 impl<'a> Arbitrary<'a> for TestCase {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {
+        let _ = env_logger::try_init();
         Self::generate(u).map_err(|_| {
             STATISTICS.invalid_inputs.fetch_add(1, Ordering::SeqCst);
             arbitrary::Error::IncorrectFormat
@@ -236,12 +236,14 @@ impl TestCase {
     }
 
     fn to_optimized(&self) -> Self {
+        let mut ctrl_planes = self.ctrl_planes.clone();
         let optimized_functions: Vec<Function> = self
             .functions
             .iter()
-            .map(|func| {
+            .zip(ctrl_planes.iter_mut())
+            .map(|(func, ctrl_plane)| {
                 let mut ctx = Context::for_function(func.clone());
-                ctx.optimize(self.isa.as_ref()).unwrap();
+                ctx.optimize(self.isa.as_ref(), ctrl_plane).unwrap();
                 ctx.func
             })
             .collect();
@@ -249,7 +251,7 @@ impl TestCase {
         TestCase {
             isa: self.isa.clone(),
             functions: optimized_functions,
-            ctrl_planes: self.ctrl_planes.clone(),
+            ctrl_planes,
             inputs: self.inputs.clone(),
             compare_against_host: false,
         }
@@ -269,7 +271,7 @@ fn run_in_interpreter(interpreter: &mut Interpreter, args: &[DataValue]) -> RunR
     match res {
         Ok(ControlFlow::Return(results)) => RunResult::Success(results.to_vec()),
         Ok(ControlFlow::Trap(trap)) => RunResult::Trap(trap),
-        Ok(cf) => RunResult::Error(format!("Unrecognized exit ControlFlow: {:?}", cf).into()),
+        Ok(cf) => RunResult::Error(format!("Unrecognized exit ControlFlow: {cf:?}").into()),
         Err(InterpreterError::FuelExhausted) => RunResult::Timeout,
         Err(e) => RunResult::Error(e.into()),
     }
@@ -346,7 +348,7 @@ fn run_test_inputs(testcase: &TestCase, run: impl Fn(&[DataValue]) -> RunResult)
                 STATISTICS.run_result_timeout.fetch_add(1, Ordering::SeqCst);
                 return;
             }
-            RunResult::Error(_) => panic!("interpreter failed: {:?}", int_res),
+            RunResult::Error(e) => panic!("interpreter failed: {e:?}"),
         }
 
         let res = run(args);
diff --git a/fuzz/fuzz_targets/differential.rs b/fuzz/fuzz_targets/differential.rs
index 34164666ebf0..1ed970da6fbb 100644
--- a/fuzz/fuzz_targets/differential.rs
+++ b/fuzz/fuzz_targets/differential.rs
@@ -5,7 +5,6 @@ use libfuzzer_sys::fuzz_target;
 use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering::SeqCst;
 use std::sync::Once;
-use wasmtime_fuzzing::generators::CompilerStrategy;
 use wasmtime_fuzzing::generators::{Config, DiffValue, DiffValueType, SingleInstModule};
 use wasmtime_fuzzing::oracles::diff_wasmtime::WasmtimeInstance;
 use wasmtime_fuzzing::oracles::engine::{build_allowed_env_list, parse_env_list};
@@ -23,10 +22,8 @@ static SETUP: Once = Once::new();
 // - ALLOWED_ENGINES=wasmi,spec cargo +nightly fuzz run ...
 // - ALLOWED_ENGINES=-v8 cargo +nightly fuzz run ...
 // - ALLOWED_MODULES=single-inst cargo +nightly fuzz run ...
-// - FUZZ_WINCH=1 cargo +nightly fuzz run ...
 static mut ALLOWED_ENGINES: Vec<&str> = vec![];
 static mut ALLOWED_MODULES: Vec<&str> = vec![];
-static mut FUZZ_WINCH: bool = false;
 
 // Statistics about what's actually getting executed during fuzzing
 static STATS: RuntimeStats = RuntimeStats::new();
@@ -41,22 +38,16 @@ fuzz_target!(|data: &[u8]| {
         // environment variables.
         let allowed_engines = build_allowed_env_list(
             parse_env_list("ALLOWED_ENGINES"),
-            &["wasmtime", "wasmi", "spec", "v8"],
+            &["wasmtime", "wasmi", "spec", "v8", "winch"],
         );
         let allowed_modules = build_allowed_env_list(
             parse_env_list("ALLOWED_MODULES"),
             &["wasm-smith", "single-inst"],
         );
 
-        let fuzz_winch = match std::env::var("FUZZ_WINCH").map(|v| v == "1") {
-            Ok(v) => v,
-            _ => false,
-        };
-
         unsafe {
             ALLOWED_ENGINES = allowed_engines;
             ALLOWED_MODULES = allowed_modules;
-            FUZZ_WINCH = fuzz_winch;
         }
     });
 
@@ -69,7 +60,6 @@ fn execute_one(data: &[u8]) -> Result<()> {
     STATS.bump_attempts();
 
     let mut u = Unstructured::new(data);
-    let fuzz_winch = unsafe { FUZZ_WINCH };
 
     // Generate a Wasmtime and module configuration and update its settings
     // initially to be suitable for differential execution where the generated
@@ -78,19 +68,10 @@ fn execute_one(data: &[u8]) -> Result<()> {
     let mut config: Config = u.arbitrary()?;
     config.set_differential_config();
 
-    // When fuzzing Winch, explicitly override the compiler strategy, which by
-    // default its arbitrary implementation unconditionally returns
-    // `Cranelift`.
-    // We also explicitly disable multi-value support.
-    if fuzz_winch {
-        config.wasmtime.compiler_strategy = CompilerStrategy::Winch;
-        config.module_config.config.multi_value_enabled = false;
-    }
-
     // Choose an engine that Wasmtime will be differentially executed against.
     // The chosen engine is then created, which might update `config`, and
     // returned as a trait object.
-    let lhs = u.choose(unsafe { &ALLOWED_ENGINES })?;
+    let lhs = u.choose(unsafe { &*std::ptr::addr_of!(ALLOWED_ENGINES) })?;
     let mut lhs = match engine::build(&mut u, lhs, &mut config)? {
         Some(engine) => engine,
         // The chosen engine does not have support compiled into the fuzzer,
@@ -120,10 +101,6 @@ fn execute_one(data: &[u8]) -> Result<()> {
         _ => unreachable!(),
     };
 
-    if fuzz_winch && !winch_supports_module(&wasm) {
-        return Ok(());
-    }
-
     log_wasm(&wasm);
 
     // Instantiate the generated wasm file in the chosen differential engine.
@@ -208,6 +185,7 @@ struct RuntimeStats {
     v8: AtomicUsize,
     spec: AtomicUsize,
     wasmtime: AtomicUsize,
+    winch: AtomicUsize,
 
     // Counters for which style of module is chosen
     wasm_smith_modules: AtomicUsize,
@@ -224,6 +202,7 @@ impl RuntimeStats {
             v8: AtomicUsize::new(0),
             spec: AtomicUsize::new(0),
             wasmtime: AtomicUsize::new(0),
+            winch: AtomicUsize::new(0),
             wasm_smith_modules: AtomicUsize::new(0),
             single_instruction_modules: AtomicUsize::new(0),
         }
@@ -246,13 +225,15 @@ impl RuntimeStats {
         let spec = self.spec.load(SeqCst);
         let wasmi = self.wasmi.load(SeqCst);
         let wasmtime = self.wasmtime.load(SeqCst);
-        let total = v8 + spec + wasmi + wasmtime;
+        let winch = self.winch.load(SeqCst);
+        let total = v8 + spec + wasmi + wasmtime + winch;
         println!(
-            "\twasmi: {:.02}%, spec: {:.02}%, wasmtime: {:.02}%, v8: {:.02}%",
+            "\twasmi: {:.02}%, spec: {:.02}%, wasmtime: {:.02}%, v8: {:.02}%, winch: {:.02}%",
             wasmi as f64 / total as f64 * 100f64,
             spec as f64 / total as f64 * 100f64,
             wasmtime as f64 / total as f64 * 100f64,
             v8 as f64 / total as f64 * 100f64,
+            winch as f64 / total as f64 * 100f64,
         );
 
         let wasm_smith = self.wasm_smith_modules.load(SeqCst);
@@ -271,121 +252,8 @@ impl RuntimeStats {
             "wasmtime" => self.wasmtime.fetch_add(1, SeqCst),
             "spec" => self.spec.fetch_add(1, SeqCst),
             "v8" => self.v8.fetch_add(1, SeqCst),
+            "winch" => self.winch.fetch_add(1, SeqCst),
             _ => return,
         };
     }
 }
-
-// Returns true if the module only contains operators supported by
-// Winch. Winch's x86_64 target has broader support for Wasm operators
-// than the aarch64 target. This list assumes fuzzing on the x86_64
-// target.
-fn winch_supports_module(module: &[u8]) -> bool {
-    use wasmparser::{Operator::*, Parser, Payload};
-
-    let mut supported = true;
-    let mut parser = Parser::new(0).parse_all(module);
-
-    'main: while let Some(payload) = parser.next() {
-        match payload.unwrap() {
-            Payload::CodeSectionEntry(body) => {
-                let op_reader = body.get_operators_reader().unwrap();
-                for op in op_reader {
-                    match op.unwrap() {
-                        I32Const { .. }
-                        | I64Const { .. }
-                        | I32Add { .. }
-                        | I64Add { .. }
-                        | I32Sub { .. }
-                        | I32Mul { .. }
-                        | I32DivS { .. }
-                        | I32DivU { .. }
-                        | I64DivS { .. }
-                        | I64DivU { .. }
-                        | I64RemU { .. }
-                        | I64RemS { .. }
-                        | I32RemU { .. }
-                        | I32RemS { .. }
-                        | I64Mul { .. }
-                        | I64Sub { .. }
-                        | I32Eq { .. }
-                        | I64Eq { .. }
-                        | I32Ne { .. }
-                        | I64Ne { .. }
-                        | I32LtS { .. }
-                        | I64LtS { .. }
-                        | I32LtU { .. }
-                        | I64LtU { .. }
-                        | I32LeS { .. }
-                        | I64LeS { .. }
-                        | I32LeU { .. }
-                        | I64LeU { .. }
-                        | I32GtS { .. }
-                        | I64GtS { .. }
-                        | I32GtU { .. }
-                        | I64GtU { .. }
-                        | I32GeS { .. }
-                        | I64GeS { .. }
-                        | I32GeU { .. }
-                        | I64GeU { .. }
-                        | I32Eqz { .. }
-                        | I64Eqz { .. }
-                        | I32And { .. }
-                        | I64And { .. }
-                        | I32Or { .. }
-                        | I64Or { .. }
-                        | I32Xor { .. }
-                        | I64Xor { .. }
-                        | I32Shl { .. }
-                        | I64Shl { .. }
-                        | I32ShrS { .. }
-                        | I64ShrS { .. }
-                        | I32ShrU { .. }
-                        | I64ShrU { .. }
-                        | I32Rotl { .. }
-                        | I64Rotl { .. }
-                        | I32Rotr { .. }
-                        | I64Rotr { .. }
-                        | I32Clz { .. }
-                        | I64Clz { .. }
-                        | I32Ctz { .. }
-                        | I64Ctz { .. }
-                        | I32Popcnt { .. }
-                        | I64Popcnt { .. }
-                        | LocalGet { .. }
-                        | LocalSet { .. }
-                        | LocalTee { .. }
-                        | GlobalGet { .. }
-                        | GlobalSet { .. }
-                        | Call { .. }
-                        | Nop { .. }
-                        | End { .. }
-                        | If { .. }
-                        | Else { .. }
-                        | Block { .. }
-                        | Loop { .. }
-                        | Br { .. }
-                        | BrIf { .. }
-                        | BrTable { .. }
-                        | Unreachable { .. }
-                        | Return { .. }
-                        | F32Const { .. }
-                        | F64Const { .. }
-                        | F32Abs { .. }
-                        | F64Abs { .. }
-                        | F32Neg { .. }
-                        | F64Neg { .. }
-                        | CallIndirect { .. } => {}
-                        _ => {
-                            supported = false;
-                            break 'main;
-                        }
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
-
-    supported
-}
diff --git a/fuzz/fuzz_targets/instantiate-many.rs b/fuzz/fuzz_targets/instantiate-many.rs
index 48f1248a181d..0ee9fa2ebcbc 100644
--- a/fuzz/fuzz_targets/instantiate-many.rs
+++ b/fuzz/fuzz_targets/instantiate-many.rs
@@ -5,6 +5,7 @@
 
 use libfuzzer_sys::arbitrary::{Result, Unstructured};
 use libfuzzer_sys::fuzz_target;
+use wasmtime_fuzzing::single_module_fuzzer::KnownValid;
 use wasmtime_fuzzing::{generators, oracles};
 
 const MAX_MODULES: usize = 5;
@@ -56,7 +57,7 @@ fn execute_one(data: &[u8]) -> Result<()> {
             .collect::<Result<Vec<_>>>()?,
     );
 
-    oracles::instantiate_many(&modules, true, &config, &commands);
+    oracles::instantiate_many(&modules, KnownValid::Yes, &config, &commands);
 
     Ok(())
 }
diff --git a/fuzz/fuzz_targets/instantiate.rs b/fuzz/fuzz_targets/instantiate.rs
index 8e552bea0dcd..cc5ae10f516b 100644
--- a/fuzz/fuzz_targets/instantiate.rs
+++ b/fuzz/fuzz_targets/instantiate.rs
@@ -3,6 +3,7 @@
 use libfuzzer_sys::arbitrary::{Arbitrary, Result, Unstructured};
 use wasmtime_fuzzing::generators::Config;
 use wasmtime_fuzzing::oracles::{instantiate, Timeout};
+use wasmtime_fuzzing::single_module_fuzzer::KnownValid;
 
 wasmtime_fuzzing::single_module_fuzzer!(execute gen_module);
 
@@ -31,7 +32,7 @@ impl<'a> Arbitrary<'a> for InstantiateInput {
 
 fn execute(
     module: &[u8],
-    known_valid: bool,
+    known_valid: KnownValid,
     mut input: InstantiateInput,
     u: &mut Unstructured<'_>,
 ) -> Result<()> {
@@ -39,21 +40,40 @@ fn execute(
         // If the input module isn't a "known valid" module then it can't be
         // relied on self-regulating itself, so force a timeout via epochs/fuel
         // in the configuration.
-        Timeout::None if !known_valid => input.config.generate_timeout(u)?,
+        Timeout::None if known_valid == KnownValid::No => input.config.generate_timeout(u)?,
         other => other,
     };
     instantiate(module, known_valid, &input.config, timeout);
     Ok(())
 }
 
-fn gen_module(input: &mut InstantiateInput, u: &mut Unstructured<'_>) -> Result<Vec<u8>> {
-    let module = input.config.generate(
-        u,
-        if let Timeout::None = input.timeout {
-            Some(1000)
-        } else {
-            None
-        },
-    )?;
-    Ok(module.to_bytes())
+fn gen_module(
+    input: &mut InstantiateInput,
+    u: &mut Unstructured<'_>,
+) -> Result<(Vec<u8>, KnownValid)> {
+    // With a small-ish chance take raw fuzz input and put it in the module to
+    // stress module compilation/validation. In such a situation we can't use
+    // `ensure_termination` in wasm-smith so list the timeout as `None` to time
+    // out via epochs or Wasmtime-level fuel.
+    //
+    // Otherwise though if no timeout is configured use wasm-smith fuel to
+    // ensure termination.
+    let allow_invalid_funcs = u.ratio(1, 10)?;
+
+    let default_fuel = if allow_invalid_funcs {
+        input.config.module_config.config.allow_invalid_funcs = true;
+        input.timeout = Timeout::None;
+        None
+    } else if let Timeout::None = input.timeout {
+        Some(1000)
+    } else {
+        None
+    };
+    let module = input.config.generate(u, default_fuel)?;
+    let known_valid = if allow_invalid_funcs {
+        KnownValid::No
+    } else {
+        KnownValid::Yes
+    };
+    Ok((module.to_bytes(), known_valid))
 }
diff --git a/fuzz/fuzz_targets/memory_accesses.rs b/fuzz/fuzz_targets/memory_accesses.rs
new file mode 100644
index 000000000000..1386a069b8e7
--- /dev/null
+++ b/fuzz/fuzz_targets/memory_accesses.rs
@@ -0,0 +1,8 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use wasmtime_fuzzing::{generators::MemoryAccesses, oracles::memory::check_memory_accesses};
+
+fuzz_target!(|input: MemoryAccesses| {
+    check_memory_accesses(input);
+});
diff --git a/fuzz/fuzz_targets/pulley.rs b/fuzz/fuzz_targets/pulley.rs
new file mode 100644
index 000000000000..d3bebbff4ee3
--- /dev/null
+++ b/fuzz/fuzz_targets/pulley.rs
@@ -0,0 +1,21 @@
+#![no_main]
+
+use libfuzzer_sys::{arbitrary::*, fuzz_target};
+use pulley_interpreter_fuzz::{interp, roundtrip};
+
+fuzz_target!(|data| {
+    let _ = fuzz(data);
+});
+
+fn fuzz(data: &[u8]) -> Result<()> {
+    let _ = env_logger::try_init();
+
+    let mut u = Unstructured::new(data);
+    match u.int_in_range(0..=1)? {
+        0 => roundtrip(Arbitrary::arbitrary_take_rest(u)?),
+        1 => interp(Arbitrary::arbitrary_take_rest(u)?),
+        _ => unreachable!(),
+    }
+
+    Ok(())
+}
diff --git a/fuzz/fuzz_targets/spectests.rs b/fuzz/fuzz_targets/spectests.rs
deleted file mode 100644
index 9ab1df1fe02c..000000000000
--- a/fuzz/fuzz_targets/spectests.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-#![no_main]
-
-use libfuzzer_sys::fuzz_target;
-use wasmtime_fuzzing::generators::{Config, SpecTest};
-
-fuzz_target!(|pair: (Config, SpecTest)| {
-    let (config, test) = pair;
-    wasmtime_fuzzing::oracles::spectest(config, test);
-});
diff --git a/fuzz/fuzz_targets/table_ops.rs b/fuzz/fuzz_targets/table_ops.rs
index b17637157ee4..93c9cecce714 100644
--- a/fuzz/fuzz_targets/table_ops.rs
+++ b/fuzz/fuzz_targets/table_ops.rs
@@ -5,5 +5,5 @@ use wasmtime_fuzzing::generators::{table_ops::TableOps, Config};
 
 fuzz_target!(|pair: (Config, TableOps)| {
     let (config, ops) = pair;
-    wasmtime_fuzzing::oracles::table_ops(config, ops);
+    let _ = wasmtime_fuzzing::oracles::table_ops(config, ops);
 });
diff --git a/fuzz/fuzz_targets/wast_tests.rs b/fuzz/fuzz_targets/wast_tests.rs
new file mode 100644
index 000000000000..ed027cafcf4f
--- /dev/null
+++ b/fuzz/fuzz_targets/wast_tests.rs
@@ -0,0 +1,9 @@
+#![no_main]
+
+use libfuzzer_sys::fuzz_target;
+use wasmtime_fuzzing::generators::{Config, WastTest};
+
+fuzz_target!(|pair: (Config, WastTest)| {
+    let (config, test) = pair;
+    wasmtime_fuzzing::oracles::wast_test(config, test);
+});
diff --git a/pulley/Cargo.toml b/pulley/Cargo.toml
new file mode 100644
index 000000000000..b8c9f3138e1c
--- /dev/null
+++ b/pulley/Cargo.toml
@@ -0,0 +1,33 @@
+[package]
+authors = ["The Pulley Project Developers"]
+description = "The Pulley interpreter, its bytecode definition, encoder, decoder, and etc..."
+edition.workspace = true
+rust-version.workspace = true
+license = "Apache-2.0 WITH LLVM-exception"
+name = "pulley-interpreter"
+readme = "./README.md"
+repository = "https://github.com/bytecodealliance/wasmtime/tree/main/pulley"
+version = "0.1.0"
+
+[lints]
+workspace = true
+
+[dependencies]
+arbitrary = { workspace = true, optional = true }
+cranelift-bitset = { workspace = true } 
+log = { workspace = true }
+sptr = { workspace = true }
+
+[dev-dependencies]
+env_logger = { workspace = true }
+
+[features]
+std = []
+arbitrary = ["dep:arbitrary", "arbitrary/derive", "std", "cranelift-bitset/arbitrary"]
+encode = []
+decode = []
+disas = ["decode"]
+interp = ["decode"]
+
+[package.metadata.docs.rs]
+all-features = true
diff --git a/pulley/README.md b/pulley/README.md
new file mode 100644
index 000000000000..8460c4d907a6
--- /dev/null
+++ b/pulley/README.md
@@ -0,0 +1,109 @@
+<div align="center">
+  <h1>Pulley</h1>
+
+  <h3>Portable, Universal, Low-Level Execution strategY</h3>
+
+  <p>
+    <strong>A portable bytecode and fast interpreter</strong>
+  </p>
+
+  <strong>A <a href="https://bytecodealliance.org/">Bytecode Alliance</a> project</strong>
+
+  <p>
+    <a href="https://github.com/bytecodealliance/wasmtime/actions?query=workflow%3ACI"><img src="https://github.com/bytecodealliance/wasmtime/workflows/CI/badge.svg" alt="build status" /></a>
+    <a href="https://bytecodealliance.zulipchat.com/#narrow/stream/217126-wasmtime"><img src="https://img.shields.io/badge/zulip-join_chat-brightgreen.svg" alt="zulip chat" /></a>
+    <img src="https://img.shields.io/badge/rustc-stable+-green.svg" alt="supported rustc stable" />
+    <a href="https://docs.rs/pulley-interpreter"><img src="https://docs.rs/pulley-interpreter/badge.svg" alt="Documentation Status" /></a>
+  </p>
+
+  <h3>
+    <a href="https://bytecodealliance.zulipchat.com/#narrow/stream/217126-wasmtime">Chat</a>
+  </h3>
+</div>
+
+## About
+
+Pulley is a portable bytecode and fast interpreter for use in Wasmtime.
+
+Pulley's primary goal is portability and its secondary goal is fast
+interpretation.
+
+Pulley is not intended to be a simple reference interpreter, support dynamically
+switching to just-in-time compiled code, or even to be the very fastest
+interpreter in the world.
+
+For more details on Pulley's motivation, goals, and non-goals, see [the Bytecode
+Alliance RFC that originally proposed Pulley][rfc].
+
+[rfc]: https://github.com/bytecodealliance/rfcs/blob/main/accepted/pulley.md
+
+## Status
+
+Pulley is very much still a work in progress! Expect the details of the bytecode
+to change, instructions to appear and disappear, and APIs to be overhauled.
+
+## Example
+
+Here is the disassembly of `f(a, b) = a + b` in Pulley today:
+
+```
+       0: 2f                              push_frame
+       1: 12 00 04                        xadd32 x0, x0, x1
+       4: 30                              pop_frame
+       5: 00                              ret
+```
+
+Note that there are a number of things that could be improved here:
+
+* We could avoid allocating and deallocating a stack frame because this function's
+  body doesn't use any stack slots.
+
+As mentioned above, Pulley is very much a work in progress.
+
+## Principles
+
+What follows are some general, incomplete, and sometimes-conflicting principles
+that we try and follow when designing the Pulley bytecode format and its
+interpreter:
+
+* The bytecode should be simple and fast to decode in software. For example, we
+  should avoid overly-complicated bitpacking, and only reach for that kind of
+  thing when benchmarks and profiles show it to be of benefit.
+
+* The interpreter never materializes `enum Instruction { .. }` values. Instead,
+  it decodes immediates and operands as needed in each opcode handler. This
+  avoids constructing unnecessary temporary storage and branching on opcode
+  multiple times.
+
+* Because we never materialize `enum Instruction { .. }` values, we don't have
+  to worry about unused padding or one very-large instruction inflating the size
+  of all the rest of our small instructions. To put it concisely: we can lean
+  into a variable-length encoding where some instructions require only a single
+  byte and others require many. This helps keep the bytecode compact and
+  cache-efficient.
+
+* We lean into defining super-instructions (sometimes called "macro ops") that
+  perform the work of multiple operations in a single instruction. The more work
+  we do in each turn of the interpreter loop the less we are impacted by its
+  overhead. Additionally, Cranelift, as the primary Pulley bytecode producer,
+  can leverage ISLE lowering patterns to easily identify opportunities for
+  emitting super-instructions.
+
+* We do not, in general, define sub-opcodes. There should be only one branch, on
+  the initial opcode, when evaluating any given instruction. For example, we do
+  *not* have a generic `load` instruction that is followed by a sub-opcode to
+  discriminate between different addressing modes. Instead, we have many
+  different kinds of `load` instructions, one for each of our addressing modes.
+
+  The one exception is the split between regular and extended ops. Regular ops
+  are a single `u8` opcode, where `255` is reserved for all extended ops, and a
+  `u16` opcode follows after the `255` regular opcode. This keeps the most
+  common instructions extra small, and provides a pressure release valve for
+  defining an unbounded number of additional, colder, ops.
+
+* We strive to cut down on boilerplate as much as possible, and try to avoid
+  matching on every opcode repeatedly throughout the whole code base. We do this
+  via heavy `macro_rules` usage where we define the bytecode inside a
+  higher-order macro and then automatically derive a disassembler, decoder,
+  encoder, etc... from that definition. This also avoids any kind of drift where
+  the encoder and decoder get out of sync with each other, for example.
diff --git a/pulley/fuzz/.gitignore b/pulley/fuzz/.gitignore
new file mode 100644
index 000000000000..1a45eee7760d
--- /dev/null
+++ b/pulley/fuzz/.gitignore
@@ -0,0 +1,4 @@
+target
+corpus
+artifacts
+coverage
diff --git a/pulley/fuzz/Cargo.toml b/pulley/fuzz/Cargo.toml
new file mode 100644
index 000000000000..fc9737559158
--- /dev/null
+++ b/pulley/fuzz/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "pulley-interpreter-fuzz"
+version = "0.0.0"
+publish = false
+edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
+
+[dependencies]
+pulley-interpreter = { path = "..", features = ["encode", "decode", "disas", "interp", "arbitrary"] }
+env_logger = { workspace = true }
+log = { workspace = true }
diff --git a/pulley/fuzz/src/interp.rs b/pulley/fuzz/src/interp.rs
new file mode 100644
index 000000000000..424cfc588026
--- /dev/null
+++ b/pulley/fuzz/src/interp.rs
@@ -0,0 +1,122 @@
+use pulley_interpreter::{
+    interp::Vm,
+    op::{self, ExtendedOp, Op},
+    *,
+};
+use std::ptr::NonNull;
+
+pub fn interp(ops: Vec<Op>) {
+    let _ = env_logger::try_init();
+
+    log::trace!("input: {ops:#?}");
+
+    let mut ops = ops;
+    ops.retain(|op| op_is_safe_for_fuzzing(op));
+    // Make sure that we end with a `ret` so that the interpreter returns
+    // control to us instead of continuing off the end of the ops and into
+    // undefined memory.
+    ops.push(Op::Ret(op::Ret {}));
+
+    log::trace!("filtered to only safe ops: {ops:#?}");
+
+    let mut encoded = vec![];
+    for op in &ops {
+        op.encode(&mut encoded);
+    }
+    log::trace!("encoded: {encoded:?}");
+
+    let mut vm = Vm::new();
+    unsafe {
+        let args = &[];
+        let rets = &[];
+        match vm.call(NonNull::from(&encoded[0]), args, rets.into_iter().copied()) {
+            Ok(rets) => assert_eq!(rets.count(), 0),
+            Err(pc) => {
+                let pc = pc as usize;
+
+                let start = &encoded[0] as *const u8 as usize;
+                let end = encoded.last().unwrap() as *const u8 as usize;
+                assert!(
+                    start <= pc && pc < end,
+                    "pc should be in range {start:#018x}..{end:#018x}, got {pc:#018x}"
+                );
+
+                let index = pc - start;
+                assert_eq!(encoded[index], Opcode::ExtendedOp as u8);
+                let [a, b] = (ExtendedOpcode::Trap as u16).to_le_bytes();
+                assert_eq!(encoded[index + 1], a);
+                assert_eq!(encoded[index + 2], b);
+            }
+        };
+    }
+}
+
+fn op_is_safe_for_fuzzing(op: &Op) -> bool {
+    match op {
+        Op::Ret(_) => true,
+        Op::Jump(_) => false,
+        Op::BrIf(_) => false,
+        Op::BrIfNot(_) => false,
+        Op::BrIfXeq32(_) => false,
+        Op::BrIfXneq32(_) => false,
+        Op::BrIfXult32(_) => false,
+        Op::BrIfXulteq32(_) => false,
+        Op::BrIfXslt32(_) => false,
+        Op::BrIfXslteq32(_) => false,
+        Op::Xmov(op::Xmov { dst, .. }) => !dst.is_special(),
+        Op::Fmov(_) => true,
+        Op::Vmov(_) => true,
+        Op::Xconst8(op::Xconst8 { dst, .. }) => !dst.is_special(),
+        Op::Xconst16(op::Xconst16 { dst, .. }) => !dst.is_special(),
+        Op::Xconst32(op::Xconst32 { dst, .. }) => !dst.is_special(),
+        Op::Xconst64(op::Xconst64 { dst, .. }) => !dst.is_special(),
+        Op::Load32U(_) => false,
+        Op::Load32S(_) => false,
+        Op::Load64(_) => false,
+        Op::Load32UOffset8(_) => false,
+        Op::Load32SOffset8(_) => false,
+        Op::Load32UOffset64(_) => false,
+        Op::Load32SOffset64(_) => false,
+        Op::Load64Offset8(_) => false,
+        Op::Load64Offset64(_) => false,
+        Op::Store32(_) => false,
+        Op::Store64(_) => false,
+        Op::Store32SOffset8(_) => false,
+        Op::Store32SOffset64(_) => false,
+        Op::Store64Offset8(_) => false,
+        Op::Store64Offset64(_) => false,
+        Op::BitcastIntFromFloat32(op::BitcastIntFromFloat32 { dst, .. }) => !dst.is_special(),
+        Op::BitcastIntFromFloat64(op::BitcastIntFromFloat64 { dst, .. }) => !dst.is_special(),
+        Op::BitcastFloatFromInt32(_) => true,
+        Op::BitcastFloatFromInt64(_) => true,
+        Op::ExtendedOp(op) => extended_op_is_safe_for_fuzzing(op),
+        Op::Call(_) => false,
+        Op::Xadd32(Xadd32 { operands, .. })
+        | Op::Xadd64(Xadd64 { operands, .. })
+        | Op::Xeq64(Xeq64 { operands, .. })
+        | Op::Xneq64(Xneq64 { operands, .. })
+        | Op::Xslt64(Xslt64 { operands, .. })
+        | Op::Xslteq64(Xslteq64 { operands, .. })
+        | Op::Xult64(Xult64 { operands, .. })
+        | Op::Xulteq64(Xulteq64 { operands, .. })
+        | Op::Xeq32(Xeq32 { operands, .. })
+        | Op::Xneq32(Xneq32 { operands, .. })
+        | Op::Xslt32(Xslt32 { operands, .. })
+        | Op::Xslteq32(Xslteq32 { operands, .. })
+        | Op::Xult32(Xult32 { operands, .. })
+        | Op::Xulteq32(Xulteq32 { operands, .. }) => !operands.dst.is_special(),
+        Op::PushFrame(_) | Op::PopFrame(_) => false,
+        Op::XPush32(_) | Op::XPush64(_) => false,
+        Op::XPop32(_) | Op::XPop64(_) => false,
+        Op::XPush32Many(_) | Op::XPush64Many(_) => false,
+        Op::XPop32Many(_) | Op::XPop64Many(_) => false,
+    }
+}
+
+fn extended_op_is_safe_for_fuzzing(op: &ExtendedOp) -> bool {
+    match op {
+        ExtendedOp::Trap(_) => true,
+        ExtendedOp::Nop(_) => true,
+        ExtendedOp::GetSp(GetSp { dst, .. }) => !dst.is_special(),
+    }
+}
diff --git a/pulley/fuzz/src/lib.rs b/pulley/fuzz/src/lib.rs
new file mode 100644
index 000000000000..b041d1676312
--- /dev/null
+++ b/pulley/fuzz/src/lib.rs
@@ -0,0 +1,5 @@
+mod roundtrip;
+pub use roundtrip::*;
+
+mod interp;
+pub use interp::*;
diff --git a/pulley/fuzz/src/roundtrip.rs b/pulley/fuzz/src/roundtrip.rs
new file mode 100644
index 000000000000..3f88db1b7dd8
--- /dev/null
+++ b/pulley/fuzz/src/roundtrip.rs
@@ -0,0 +1,25 @@
+use pulley_interpreter::{
+    decode::{Decoder, SafeBytecodeStream},
+    op::{MaterializeOpsVisitor, Op},
+};
+
+pub fn roundtrip(ops: Vec<Op>) {
+    let _ = env_logger::try_init();
+
+    log::trace!("input: {ops:#?}");
+
+    let mut encoded = vec![];
+    for op in &ops {
+        op.encode(&mut encoded);
+    }
+    log::trace!("encoded: {encoded:?}");
+
+    let mut materializer = MaterializeOpsVisitor::new(SafeBytecodeStream::new(&encoded));
+    let decoded = Decoder::decode_all(&mut materializer).expect("should decode okay");
+    log::trace!("decoded: {decoded:#?}");
+
+    assert_eq!(
+        decoded, ops,
+        "`decode(encode(ops))` should be equal to the original `ops`"
+    );
+}
diff --git a/pulley/src/decode.rs b/pulley/src/decode.rs
new file mode 100644
index 000000000000..09f4da80d901
--- /dev/null
+++ b/pulley/src/decode.rs
@@ -0,0 +1,657 @@
+//! Decoding support for pulley bytecode.
+
+use alloc::vec::Vec;
+use cranelift_bitset::scalar::ScalarBitSetStorage;
+use cranelift_bitset::ScalarBitSet;
+
+use crate::imms::*;
+use crate::opcode::*;
+use crate::regs::*;
+
+/// Either an `Ok(T)` or an `Err(DecodingError)`.
+pub type Result<T, E = DecodingError> = core::result::Result<T, E>;
+
+/// An error when decoding Pulley bytecode.
+pub enum DecodingError {
+    /// Reached the end of the bytecode stream before we finished decoding a
+    /// single bytecode.
+    UnexpectedEof {
+        /// The position in the bytecode stream where this error occurred.
+        position: usize,
+    },
+
+    /// Found an invalid opcode.
+    InvalidOpcode {
+        /// The position in the bytecode stream where this error occurred.
+        position: usize,
+        /// The invalid opcode that was found.
+        code: u8,
+    },
+
+    /// Found an invalid extended opcode.
+    InvalidExtendedOpcode {
+        /// The position in the bytecode stream where this error occurred.
+        position: usize,
+        /// The invalid extended opcode that was found.
+        code: u16,
+    },
+
+    /// Found an invalid register.
+    InvalidReg {
+        /// The position in the bytecode stream where this error occurred.
+        position: usize,
+        /// The invalid register that was found.
+        reg: u8,
+    },
+}
+
+impl core::fmt::Debug for DecodingError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        core::fmt::Display::fmt(self, f)
+    }
+}
+
+impl core::fmt::Display for DecodingError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::UnexpectedEof { position } => {
+                write!(f, "unexpected end-of-file at bytecode offset {position:#x}")
+            }
+            Self::InvalidOpcode { position, code } => {
+                write!(
+                    f,
+                    "found invalid opcode {code:#x} at bytecode offset {position:#x}"
+                )
+            }
+            Self::InvalidExtendedOpcode { position, code } => {
+                write!(
+                    f,
+                    "found invalid opcode {code:#x} at bytecode offset {position:#x}"
+                )
+            }
+            Self::InvalidReg { position, reg } => {
+                write!(
+                    f,
+                    "found invalid register {reg:#x} at bytecode offset {position:#x}"
+                )
+            }
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for DecodingError {}
+
+/// An abstraction over any kind of bytecode stream.
+///
+/// There are two primary implementations:
+///
+/// 1. `SafeBytecodeStream`: A thin wrapper around an index into a `&[u8]`. This
+///    implementation is 100% safe code.
+///
+/// 2. `UnsafeBytecodeStream`: A thin wrapper over a raw pointer. This
+///    implementation is wildly unsafe and will result in memory unsafety and
+///    other terrors when given invalid bytecode, or even valid bytecode
+///    encoding a program that itself does not preserve memory safety.
+pub trait BytecodeStream: Copy {
+    /// The type of error that this bytecode stream produces on invalid
+    /// operations.
+    type Error;
+
+    /// Create an "unexpected end-of-stream" error at the current position.
+    fn unexpected_eof(&self) -> Self::Error;
+
+    /// Create an "invalid opcode" error at the current position.
+    fn invalid_opcode(&self, code: u8) -> Self::Error;
+
+    /// Create an "invalid extended opcode" error at the current position.
+    fn invalid_extended_opcode(&self, code: u16) -> Self::Error;
+
+    /// Create an "invalid register" error at the current position.
+    fn invalid_reg(&self, reg: u8) -> Self::Error;
+
+    /// Read `N` bytes from this bytecode stream, advancing the stream's
+    /// position at the same time.
+    fn read<const N: usize>(&mut self) -> Result<[u8; N], Self::Error>;
+}
+
+/// A 100% safe implementation of a bytecode stream.
+///
+/// This is a thin wrapper around an index into a `&[u8]`.
+#[derive(Clone, Copy, Debug)]
+pub struct SafeBytecodeStream<'a> {
+    bytecode: &'a [u8],
+    position: usize,
+}
+
+impl<'a> SafeBytecodeStream<'a> {
+    /// Create a new `SafeBytecodeStream` from the given slice and with an
+    /// initial position pointing at the start of the slice.
+    pub fn new(bytecode: &'a [u8]) -> Self {
+        Self {
+            bytecode,
+            position: 0,
+        }
+    }
+
+    /// Get this stream's current position within its underlying slice.
+    pub fn position(&self) -> usize {
+        self.position
+    }
+
+    /// Get this stream's underlying bytecode slice.
+    pub fn as_slice(&self) -> &[u8] {
+        &self.bytecode
+    }
+}
+
+impl BytecodeStream for SafeBytecodeStream<'_> {
+    fn read<const N: usize>(&mut self) -> Result<[u8; N], Self::Error> {
+        let bytes = *self
+            .bytecode
+            .first_chunk::<N>()
+            .ok_or_else(|| self.unexpected_eof())?;
+        self.bytecode = &self.bytecode[N..];
+        self.position += N;
+        Ok(bytes)
+    }
+
+    type Error = DecodingError;
+
+    fn unexpected_eof(&self) -> Self::Error {
+        DecodingError::UnexpectedEof {
+            position: self.position,
+        }
+    }
+
+    fn invalid_opcode(&self, code: u8) -> Self::Error {
+        DecodingError::InvalidOpcode {
+            position: self.position - 1,
+            code,
+        }
+    }
+
+    fn invalid_extended_opcode(&self, code: u16) -> Self::Error {
+        DecodingError::InvalidExtendedOpcode {
+            position: self.position,
+            code,
+        }
+    }
+
+    fn invalid_reg(&self, reg: u8) -> Self::Error {
+        DecodingError::InvalidReg {
+            position: self.position,
+            reg,
+        }
+    }
+}
+
+/// An uninhabited type that cannot be constructed at runtime.
+#[derive(Debug)]
+pub enum Uninhabited {}
+
+/// An unsafe bytecode stream.
+///
+/// This is a wrapper over a raw pointer to bytecode somewhere in memory.
+#[derive(Clone, Copy, Debug)]
+pub struct UnsafeBytecodeStream(*mut u8);
+
+impl UnsafeBytecodeStream {
+    /// Construct a new `UnsafeBytecodeStream` pointing at the given PC.
+    ///
+    /// # Safety
+    ///
+    /// The given `pc` must point to valid Pulley bytecode, and it is the
+    /// caller's responsibility to ensure that the resulting
+    /// `UnsafeBytecodeStream` is only used to access the valid bytecode. For
+    /// example, if the current bytecode instruction unconditionally jumps to a
+    /// new PC, this stream must not be used to read just after the
+    /// unconditional jump instruction because there is no guarantee that that
+    /// memory is part of the bytecode stream or not.
+    pub unsafe fn new(pc: *mut u8) -> Self {
+        assert!(!pc.is_null());
+        UnsafeBytecodeStream(pc)
+    }
+
+    /// Get a new `UnsafeBytecodeStream` pointing at the bytecode that is at the
+    /// given relative offset from this stream's current position.
+    ///
+    /// # Safety
+    ///
+    /// Same as the `new` constructor. May only be used when it is guaranteed
+    /// that the address at `self._as_ptr() + offset` contains valid Pulley
+    /// bytecode.
+    pub unsafe fn offset(&self, offset: isize) -> Self {
+        UnsafeBytecodeStream(self.0.offset(offset))
+    }
+
+    /// Get this stream's underlying raw pointer.
+    pub fn as_ptr(&self) -> *mut u8 {
+        self.0
+    }
+}
+
+impl BytecodeStream for UnsafeBytecodeStream {
+    fn read<const N: usize>(&mut self) -> Result<[u8; N], Self::Error> {
+        debug_assert!(!self.0.is_null());
+        let bytes = unsafe { self.0.cast::<[u8; N]>().read() };
+        self.0 = unsafe { self.0.add(N) };
+        Ok(bytes)
+    }
+
+    type Error = Uninhabited;
+
+    fn unexpected_eof(&self) -> Self::Error {
+        unsafe { crate::unreachable_unchecked() }
+    }
+
+    fn invalid_opcode(&self, _code: u8) -> Self::Error {
+        unsafe { crate::unreachable_unchecked() }
+    }
+
+    fn invalid_extended_opcode(&self, _code: u16) -> Self::Error {
+        unsafe { crate::unreachable_unchecked() }
+    }
+
+    fn invalid_reg(&self, _reg: u8) -> Self::Error {
+        unsafe { crate::unreachable_unchecked() }
+    }
+}
+
+/// Anything that can be decoded from a bytecode stream, e.g. opcodes,
+/// immediates, registers, etc...
+trait Decode: Sized {
+    fn decode<T>(bytecode: &mut T) -> Result<Self, T::Error>
+    where
+        T: BytecodeStream;
+}
+
+impl Decode for u8 {
+    fn decode<T>(bytecode: &mut T) -> Result<Self, T::Error>
+    where
+        T: BytecodeStream,
+    {
+        bytecode.read::<1>().map(|a| a[0])
+    }
+}
+
+impl Decode for u16 {
+    fn decode<T>(bytecode: &mut T) -> Result<Self, T::Error>
+    where
+        T: BytecodeStream,
+    {
+        Ok(u16::from_le_bytes(bytecode.read()?))
+    }
+}
+
+impl Decode for u32 {
+    fn decode<T>(bytecode: &mut T) -> Result<Self, T::Error>
+    where
+        T: BytecodeStream,
+    {
+        Ok(u32::from_le_bytes(bytecode.read()?))
+    }
+}
+
+impl Decode for u64 {
+    fn decode<T>(bytecode: &mut T) -> Result<Self, T::Error>
+    where
+        T: BytecodeStream,
+    {
+        Ok(u64::from_le_bytes(bytecode.read()?))
+    }
+}
+
+impl Decode for i8 {
+    fn decode<T>(bytecode: &mut T) -> Result<Self, T::Error>
+    where
+        T: BytecodeStream,
+    {
+        bytecode.read::<1>().map(|a| a[0] as i8)
+    }
+}
+
+impl Decode for i16 {
+    fn decode<T>(bytecode: &mut T) -> Result<Self, T::Error>
+    where
+        T: BytecodeStream,
+    {
+        Ok(i16::from_le_bytes(bytecode.read()?))
+    }
+}
+
+impl Decode for i32 {
+    fn decode<T>(bytecode: &mut T) -> Result<Self, T::Error>
+    where
+        T: BytecodeStream,
+    {
+        Ok(i32::from_le_bytes(bytecode.read()?))
+    }
+}
+
+impl Decode for i64 {
+    fn decode<T>(bytecode: &mut T) -> Result<Self, T::Error>
+    where
+        T: BytecodeStream,
+    {
+        Ok(i64::from_le_bytes(bytecode.read()?))
+    }
+}
+
+impl Decode for XReg {
+    fn decode<T>(bytecode: &mut T) -> Result<Self, T::Error>
+    where
+        T: BytecodeStream,
+    {
+        let byte = u8::decode(bytecode)?;
+        XReg::new(byte).ok_or_else(|| bytecode.invalid_reg(byte))
+    }
+}
+
+impl Decode for FReg {
+    fn decode<T>(bytecode: &mut T) -> Result<Self, T::Error>
+    where
+        T: BytecodeStream,
+    {
+        let byte = u8::decode(bytecode)?;
+        FReg::new(byte).ok_or_else(|| bytecode.invalid_reg(byte))
+    }
+}
+
+impl Decode for VReg {
+    fn decode<T>(bytecode: &mut T) -> Result<Self, T::Error>
+    where
+        T: BytecodeStream,
+    {
+        let byte = u8::decode(bytecode)?;
+        VReg::new(byte).ok_or_else(|| bytecode.invalid_reg(byte))
+    }
+}
+
+impl Decode for PcRelOffset {
+    fn decode<T>(bytecode: &mut T) -> Result<Self, T::Error>
+    where
+        T: BytecodeStream,
+    {
+        i32::decode(bytecode).map(|x| Self::from(x))
+    }
+}
+
+impl<R: Reg> Decode for BinaryOperands<R> {
+    fn decode<T>(bytecode: &mut T) -> Result<Self, T::Error>
+    where
+        T: BytecodeStream,
+    {
+        u16::decode(bytecode).map(|bits| Self::from_bits(bits))
+    }
+}
+
+impl<S: Decode + ScalarBitSetStorage> Decode for ScalarBitSet<S> {
+    fn decode<T>(bytecode: &mut T) -> Result<Self, T::Error>
+    where
+        T: BytecodeStream,
+    {
+        S::decode(bytecode).map(ScalarBitSet::from)
+    }
+}
+
+impl<R: Reg + Decode> Decode for RegSet<R> {
+    fn decode<T>(bytecode: &mut T) -> Result<Self, T::Error>
+    where
+        T: BytecodeStream,
+    {
+        ScalarBitSet::decode(bytecode).map(Self::from)
+    }
+}
+
+/// A Pulley bytecode decoder.
+///
+/// Does not materialize bytecode instructions, instead all decoding methods are
+/// given an `OpVisitor` implementation and the appropriate visitor methods are
+/// called upon decoding an instruction. This minimizes the amount of times we
+/// branch on the opcode, avoids constructing temporary storage, and plays well
+/// with our variable-length instruction encoding.
+#[derive(Default)]
+pub struct Decoder {
+    _private: (),
+}
+
+impl Decoder {
+    /// Create a new decoder.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Decode all instructions in the visitor's bytecode stream.
+    ///
+    /// The associated visitor method is invoked after each instruction is
+    /// decoded.
+    pub fn decode_all<'a, V>(visitor: &mut V) -> Result<Vec<V::Return>>
+    where
+        V: OpVisitor<BytecodeStream = SafeBytecodeStream<'a>> + ExtendedOpVisitor,
+    {
+        let mut decoder = Decoder::new();
+        let mut results = Vec::new();
+
+        while !visitor.bytecode().as_slice().is_empty() {
+            results.push(decoder.decode_one(visitor)?);
+        }
+
+        Ok(results)
+    }
+}
+
+/// An `OpVisitor` combinator to sequence one visitor and then another.
+pub struct SequencedVisitor<'a, F, V1, V2> {
+    join: F,
+    v1: &'a mut V1,
+    v2: &'a mut V2,
+}
+
+impl<'a, F, V1, V2> SequencedVisitor<'a, F, V1, V2> {
+    /// Create a new sequenced visitor.
+    ///
+    /// The given `join` function is used to combine the results of each
+    /// sub-visitor so that it can be returned from this combined visitor.
+    pub fn new(join: F, v1: &'a mut V1, v2: &'a mut V2) -> Self {
+        SequencedVisitor { join, v1, v2 }
+    }
+}
+
+macro_rules! define_decoder {
+    (
+        $(
+            $( #[$attr:meta] )*
+                $snake_name:ident = $name:ident $( {
+                $(
+                    $( #[$field_attr:meta] )*
+                    $field:ident : $field_ty:ty
+                ),*
+            } )? ;
+        )*
+    ) => {
+        impl Decoder {
+            /// Decode one instruction from the visitor's bytestream.
+            ///
+            /// Upon decoding, the visitor's associated callback is invoked and
+            /// the results returned.
+            #[inline(always)]
+            pub fn decode_one<V>(
+                &mut self,
+                visitor: &mut V,
+            ) -> Result<V::Return, <V::BytecodeStream as BytecodeStream>::Error>
+            where
+                V: OpVisitor + ExtendedOpVisitor,
+            {
+                visitor.before_visit();
+
+                let byte = u8::decode(visitor.bytecode())?;
+                let opcode = Opcode::new(byte).ok_or_else(|| {
+                    visitor.bytecode().invalid_opcode(byte)
+                })?;
+
+                match opcode {
+                    $(
+                        Opcode::$name => {
+                            $(
+                                $(
+                                    let $field = <$field_ty>::decode(
+                                        visitor.bytecode(),
+                                    )?;
+                                )*
+                            )?
+
+                            let ret = visitor.$snake_name($( $( $field ),* )?);
+                            visitor.after_visit();
+                            Ok(ret)
+                        },
+                    )*
+                    Opcode::ExtendedOp => {
+                        decode_one_extended(visitor)
+                    }
+                }
+            }
+        }
+
+        /// Callbacks upon decoding instructions from bytecode.
+        ///
+        /// Implement this trait for your type, give an instance of your type to
+        /// a `Decoder` method, and the `Decoder` will invoke the associated
+        /// method for each instruction that it decodes. For example, if the
+        /// `Decoder` decodes an `xadd32` instruction, then it will invoke the
+        /// `xadd32` visitor method, passing along any decoded immediates,
+        /// operands, etc... as arguments.
+        pub trait OpVisitor {
+            /// The type of this visitor's bytecode stream.
+            type BytecodeStream: BytecodeStream;
+
+            /// Get this visitor's underlying bytecode stream.
+            fn bytecode(&mut self) -> &mut Self::BytecodeStream;
+
+            /// The type of values returned by each visitor method.
+            type Return;
+
+            /// A callback invoked before starting to decode an instruction.
+            ///
+            /// Does nothing by default.
+            fn before_visit(&mut self) {}
+
+            /// A callback invoked after an instruction has been completely
+            /// decoded.
+            ///
+            /// Does nothing by default.
+            fn after_visit(&mut self) {}
+
+            $(
+                $( #[$attr] )*
+                fn $snake_name(&mut self $( $( , $field : $field_ty )* )? ) -> Self::Return;
+            )*
+        }
+
+        impl<F, T, V1, V2> OpVisitor for SequencedVisitor<'_, F, V1, V2>
+        where
+            F: FnMut(V1::Return, V2::Return) -> T,
+            V1: OpVisitor,
+            V2: OpVisitor<BytecodeStream = V1::BytecodeStream>,
+        {
+            type BytecodeStream = V1::BytecodeStream;
+
+            fn bytecode(&mut self) -> &mut Self::BytecodeStream {
+                self.v1.bytecode()
+            }
+
+            type Return = T;
+
+            fn before_visit(&mut self) {
+                self.v1.before_visit();
+                self.v2.before_visit();
+            }
+
+            fn after_visit(&mut self) {
+                *self.v2.bytecode() = *self.v1.bytecode();
+                self.v1.after_visit();
+                self.v2.after_visit();
+            }
+
+            $(
+                $( #[$attr] )*
+                fn $snake_name(&mut self $( $( , $field : $field_ty )* )? ) -> Self::Return {
+                    let a = self.v1.$snake_name( $( $( $field , )* )? );
+                    let b = self.v2.$snake_name( $( $( $field , )* )? );
+                    (self.join)(a, b)
+                }
+            )*
+        }
+    };
+}
+for_each_op!(define_decoder);
+
+macro_rules! define_extended_decoder {
+    (
+        $(
+            $( #[$attr:meta] )*
+                $snake_name:ident = $name:ident $( {
+                $(
+                    $( #[$field_attr:meta] )*
+                    $field:ident : $field_ty:ty
+                ),*
+            } )? ;
+        )*
+    ) => {
+        /// Like `OpVisitor` but for extended operations.
+        pub trait ExtendedOpVisitor: OpVisitor {
+            $(
+                $( #[$attr] )*
+                fn $snake_name(&mut self $( $( , $field : $field_ty )* )? ) -> Self::Return;
+            )*
+        }
+
+        fn decode_one_extended<V>(
+            visitor: &mut V,
+        ) -> Result<V::Return, <V::BytecodeStream as BytecodeStream>::Error>
+        where
+            V: ExtendedOpVisitor,
+        {
+            let code = u16::decode(visitor.bytecode())?;
+            let opcode = ExtendedOpcode::new(code).ok_or_else(|| {
+                visitor.bytecode().invalid_extended_opcode(code)
+            })?;
+
+            match opcode {
+                $(
+                    ExtendedOpcode::$name => {
+                        $(
+                            $(
+                                let $field = <$field_ty>::decode(
+                                    visitor.bytecode(),
+                                )?;
+                            )*
+                        )?
+
+                        let ret = visitor.$snake_name($( $( $field ),* )?);
+                        visitor.after_visit();
+                        Ok(ret)
+                    }
+                )*
+            }
+        }
+
+
+        impl<F, T, V1, V2> ExtendedOpVisitor for SequencedVisitor<'_, F, V1, V2>
+        where
+            F: FnMut(V1::Return, V2::Return) -> T,
+            V1: ExtendedOpVisitor,
+            V2: ExtendedOpVisitor<BytecodeStream = V1::BytecodeStream>,
+        {
+            $(
+                $( #[$attr] )*
+                fn $snake_name(&mut self $( $( , $field : $field_ty )* )? ) -> Self::Return {
+                    let a = self.v1.$snake_name( $( $( $field , )* )? );
+                    let b = self.v2.$snake_name( $( $( $field , )* )? );
+                    (self.join)(a, b)
+                }
+            )*
+        }
+    };
+}
+for_each_extended_op!(define_extended_decoder);
diff --git a/pulley/src/disas.rs b/pulley/src/disas.rs
new file mode 100644
index 000000000000..912b1756d159
--- /dev/null
+++ b/pulley/src/disas.rs
@@ -0,0 +1,256 @@
+//! Disassembly support for pulley bytecode.
+
+use crate::decode::*;
+use crate::imms::*;
+use crate::regs::*;
+use alloc::string::String;
+use core::fmt::Write;
+
+/// A Pulley bytecode disassembler.
+///
+/// This is implemented as an `OpVisitor`, where you pass a `Disassembler` to a
+/// `Decoder` in order to disassemble instructions from a bytecode stream.
+///
+/// Alternatively, you can use the `Disassembler::disassemble_all` method to
+/// disassemble a complete bytecode stream.
+pub struct Disassembler<'a> {
+    raw_bytecode: &'a [u8],
+    bytecode: SafeBytecodeStream<'a>,
+    disas: String,
+    start: usize,
+    temp: String,
+}
+
+impl<'a> Disassembler<'a> {
+    /// Disassemble every instruction in the given bytecode stream.
+    pub fn disassemble_all(bytecode: &'a [u8]) -> Result<String> {
+        let mut disas = Self::new(bytecode);
+        Decoder::decode_all(&mut disas)?;
+        Ok(disas.disas)
+    }
+
+    /// Create a new `Disassembler` that can be used to incrementally
+    /// disassemble instructions from the given bytecode stream.
+    pub fn new(bytecode: &'a [u8]) -> Self {
+        Self {
+            raw_bytecode: bytecode,
+            bytecode: SafeBytecodeStream::new(bytecode),
+            disas: String::new(),
+            start: 0,
+            temp: String::new(),
+        }
+    }
+
+    /// Get the disassembly thus far.
+    pub fn disas(&self) -> &str {
+        &self.disas
+    }
+}
+
+/// Anything inside an instruction that can be disassembled: registers,
+/// immediates, etc...
+trait Disas {
+    fn disas(&self, position: usize, disas: &mut String);
+}
+
+impl Disas for XReg {
+    fn disas(&self, _position: usize, disas: &mut String) {
+        write!(disas, "{self}").unwrap();
+    }
+}
+
+impl Disas for FReg {
+    fn disas(&self, _position: usize, disas: &mut String) {
+        write!(disas, "{self}").unwrap();
+    }
+}
+
+impl Disas for VReg {
+    fn disas(&self, _position: usize, disas: &mut String) {
+        write!(disas, "{self}").unwrap();
+    }
+}
+
+impl Disas for i8 {
+    fn disas(&self, _position: usize, disas: &mut String) {
+        write!(disas, "{self}").unwrap();
+    }
+}
+
+impl Disas for i16 {
+    fn disas(&self, _position: usize, disas: &mut String) {
+        write!(disas, "{self}").unwrap();
+    }
+}
+
+impl Disas for i32 {
+    fn disas(&self, _position: usize, disas: &mut String) {
+        write!(disas, "{self}").unwrap();
+    }
+}
+
+impl Disas for i64 {
+    fn disas(&self, _position: usize, disas: &mut String) {
+        write!(disas, "{self}").unwrap();
+    }
+}
+
+impl Disas for u8 {
+    fn disas(&self, _position: usize, disas: &mut String) {
+        write!(disas, "{self}").unwrap();
+    }
+}
+
+impl Disas for u16 {
+    fn disas(&self, _position: usize, disas: &mut String) {
+        write!(disas, "{self}").unwrap();
+    }
+}
+
+impl Disas for u32 {
+    fn disas(&self, _position: usize, disas: &mut String) {
+        write!(disas, "{self}").unwrap();
+    }
+}
+
+impl Disas for u64 {
+    fn disas(&self, _position: usize, disas: &mut String) {
+        write!(disas, "{self}").unwrap();
+    }
+}
+
+impl Disas for PcRelOffset {
+    fn disas(&self, position: usize, disas: &mut String) {
+        let offset = isize::try_from(i32::from(*self)).unwrap();
+        let target = position.wrapping_add(offset as usize);
+        write!(disas, "{offset:#x}    // target = {target:#x}").unwrap()
+    }
+}
+
+fn disas_list<T: Disas>(position: usize, disas: &mut String, iter: impl IntoIterator<Item = T>) {
+    let mut iter = iter.into_iter();
+    let Some(first) = iter.next() else { return };
+    first.disas(position, disas);
+
+    for item in iter {
+        write!(disas, ", ").unwrap();
+        item.disas(position, disas);
+    }
+}
+
+impl<R: Reg + Disas> Disas for BinaryOperands<R> {
+    fn disas(&self, position: usize, disas: &mut String) {
+        disas_list(position, disas, [self.dst, self.src1, self.src2])
+    }
+}
+
+impl<R: Reg + Disas> Disas for RegSet<R> {
+    fn disas(&self, position: usize, disas: &mut String) {
+        disas_list(position, disas, *self)
+    }
+}
+
+macro_rules! impl_disas {
+    (
+        $(
+            $( #[$attr:meta] )*
+                $snake_name:ident = $name:ident $( {
+                $(
+                    $( #[$field_attr:meta] )*
+                    $field:ident : $field_ty:ty
+                ),*
+            } )? ;
+        )*
+    ) => {
+        impl<'a> OpVisitor for Disassembler<'a> {
+            type BytecodeStream = SafeBytecodeStream<'a>;
+
+            fn bytecode(&mut self) -> &mut Self::BytecodeStream {
+                &mut self.bytecode
+            }
+
+            type Return = ();
+
+            fn before_visit(&mut self) {
+                self.start = self.bytecode.position();
+            }
+
+            fn after_visit(&mut self) {
+                let size = self.bytecode.position() - self.start;
+
+                write!(&mut self.disas, "{:8x}: ", self.start).unwrap();
+                let mut need_space = false;
+                for byte in &self.raw_bytecode[self.start..][..size] {
+                    write!(&mut self.disas, "{}{byte:02x}", if need_space { " " } else { "" }).unwrap();
+                    need_space = true;
+                }
+                for _ in 0..11_usize.saturating_sub(size) {
+                    write!(&mut self.disas, "   ").unwrap();
+                }
+
+                self.disas.push_str(&self.temp);
+                self.temp.clear();
+
+                self.disas.push('\n');
+            }
+
+            $(
+                fn $snake_name(&mut self $( $( , $field : $field_ty )* )? ) {
+                    let mnemonic = stringify!($snake_name);
+                    write!(&mut self.temp, "{mnemonic}").unwrap();
+                    $(
+                        let mut need_comma = false;
+                        $(
+                            let val = $field;
+                            if need_comma {
+                                write!(&mut self.temp, ",").unwrap();
+                            }
+                            write!(&mut self.temp, " ").unwrap();
+                            val.disas(self.start, &mut self.temp);
+                            #[allow(unused_assignments)]
+                            { need_comma = true; }
+                        )*
+                    )?
+                }
+            )*
+        }
+    };
+}
+for_each_op!(impl_disas);
+
+macro_rules! impl_extended_disas {
+    (
+        $(
+            $( #[$attr:meta] )*
+                $snake_name:ident = $name:ident $( {
+                $(
+                    $( #[$field_attr:meta] )*
+                    $field:ident : $field_ty:ty
+                ),*
+            } )? ;
+        )*
+    ) => {
+        impl ExtendedOpVisitor for Disassembler<'_> {
+            $(
+                fn $snake_name(&mut self $( $( , $field : $field_ty )* )? ) {
+                    let mnemonic = stringify!($snake_name);
+                    write!(&mut self.temp, "{mnemonic}").unwrap();
+                    $(
+                        let mut need_comma = false;
+                        $(
+                            let val = $field;
+                            if need_comma {
+                                write!(&mut self.temp, ",").unwrap();
+                            }
+                            write!(&mut self.temp, " ").unwrap();
+                            val.disas(self.start, &mut self.temp);
+                            #[allow(unused_assignments)]
+                            { need_comma = true; }
+                        )*
+                    )?
+                }
+            )*
+        }
+    };
+}
+for_each_extended_op!(impl_extended_disas);
diff --git a/pulley/src/encode.rs b/pulley/src/encode.rs
new file mode 100644
index 000000000000..dcc5894c50ef
--- /dev/null
+++ b/pulley/src/encode.rs
@@ -0,0 +1,198 @@
+//! Encoding support for pulley bytecode.
+
+use crate::imms::*;
+use crate::opcode::{ExtendedOpcode, Opcode};
+use crate::regs::*;
+
+trait Encode {
+    fn encode<E>(&self, sink: &mut E)
+    where
+        E: Extend<u8>;
+}
+
+impl Encode for u8 {
+    fn encode<E>(&self, sink: &mut E)
+    where
+        E: Extend<u8>,
+    {
+        sink.extend(core::iter::once(*self));
+    }
+}
+
+impl Encode for u16 {
+    fn encode<E>(&self, sink: &mut E)
+    where
+        E: Extend<u8>,
+    {
+        sink.extend(self.to_le_bytes());
+    }
+}
+
+impl Encode for u32 {
+    fn encode<E>(&self, sink: &mut E)
+    where
+        E: Extend<u8>,
+    {
+        sink.extend(self.to_le_bytes());
+    }
+}
+
+impl Encode for u64 {
+    fn encode<E>(&self, sink: &mut E)
+    where
+        E: Extend<u8>,
+    {
+        sink.extend(self.to_le_bytes());
+    }
+}
+
+impl Encode for i8 {
+    fn encode<E>(&self, sink: &mut E)
+    where
+        E: Extend<u8>,
+    {
+        sink.extend(core::iter::once(*self as u8));
+    }
+}
+
+impl Encode for i16 {
+    fn encode<E>(&self, sink: &mut E)
+    where
+        E: Extend<u8>,
+    {
+        sink.extend(self.to_le_bytes());
+    }
+}
+
+impl Encode for i32 {
+    fn encode<E>(&self, sink: &mut E)
+    where
+        E: Extend<u8>,
+    {
+        sink.extend(self.to_le_bytes());
+    }
+}
+
+impl Encode for i64 {
+    fn encode<E>(&self, sink: &mut E)
+    where
+        E: Extend<u8>,
+    {
+        sink.extend(self.to_le_bytes());
+    }
+}
+
+impl Encode for XReg {
+    fn encode<E>(&self, sink: &mut E)
+    where
+        E: Extend<u8>,
+    {
+        sink.extend(core::iter::once(self.to_u8()));
+    }
+}
+
+impl Encode for FReg {
+    fn encode<E>(&self, sink: &mut E)
+    where
+        E: Extend<u8>,
+    {
+        sink.extend(core::iter::once(self.to_u8()));
+    }
+}
+
+impl Encode for VReg {
+    fn encode<E>(&self, sink: &mut E)
+    where
+        E: Extend<u8>,
+    {
+        sink.extend(core::iter::once(self.to_u8()));
+    }
+}
+
+impl Encode for PcRelOffset {
+    fn encode<E>(&self, sink: &mut E)
+    where
+        E: Extend<u8>,
+    {
+        i32::from(*self).encode(sink);
+    }
+}
+
+impl<R: Reg> Encode for BinaryOperands<R> {
+    fn encode<E>(&self, sink: &mut E)
+    where
+        E: Extend<u8>,
+    {
+        self.to_bits().encode(sink);
+    }
+}
+
+impl<R: Reg + Encode> Encode for RegSet<R> {
+    fn encode<E>(&self, sink: &mut E)
+    where
+        E: Extend<u8>,
+    {
+        self.to_bitset().0.encode(sink);
+    }
+}
+
+macro_rules! impl_encoders {
+    (
+        $(
+            $( #[$attr:meta] )*
+                $snake_name:ident = $name:ident $( {
+                $(
+                    $( #[$field_attr:meta] )*
+                    $field:ident : $field_ty:ty
+                ),*
+            } )? ;
+        )*
+    ) => {
+        $(
+            $( #[$attr] )*
+            pub fn $snake_name<E>(into: &mut E $( $( , $field : impl Into<$field_ty> )* )? )
+            where
+                E: Extend<u8>,
+            {
+                into.extend(core::iter::once(Opcode::$name as u8));
+                $(
+                    $(
+                        $field.into().encode(into);
+                    )*
+                )?
+            }
+        )*
+    };
+}
+for_each_op!(impl_encoders);
+
+macro_rules! impl_extended_encoders {
+    (
+        $(
+            $( #[$attr:meta] )*
+                $snake_name:ident = $name:ident $( {
+                    $(
+                        $( #[$field_attr:meta] )*
+                        $field:ident : $field_ty:ty
+                    ),*
+                } )? ;
+        )*
+    ) => {
+        $(
+            $( #[$attr] )*
+            pub fn $snake_name<E>(into: &mut E $( $( , $field : impl Into<$field_ty> )* )? )
+            where
+                E: Extend<u8>,
+            {
+                into.extend(core::iter::once(Opcode::ExtendedOp as u8));
+                into.extend((ExtendedOpcode::$name as u16).to_le_bytes());
+                $(
+                    $(
+                        $field.into().encode(into);
+                    )*
+                )?
+            }
+        )*
+    };
+}
+for_each_extended_op!(impl_extended_encoders);
diff --git a/pulley/src/imms.rs b/pulley/src/imms.rs
new file mode 100644
index 000000000000..cd331e2cd639
--- /dev/null
+++ b/pulley/src/imms.rs
@@ -0,0 +1,31 @@
+//! Immediates.
+
+/// A PC-relative offset.
+///
+/// This is relative to the start of this offset's containing instruction.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct PcRelOffset(i32);
+
+#[cfg(feature = "arbitrary")]
+impl<'a> arbitrary::Arbitrary<'a> for PcRelOffset {
+    fn arbitrary(_u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
+        // We can't possibly choose valid offsets for jumping to, so just use
+        // zero as the least dangerous option. It is up to whoever is generating
+        // arbitrary ops to clean this up.
+        Ok(Self(0))
+    }
+}
+
+impl From<i32> for PcRelOffset {
+    #[inline]
+    fn from(offset: i32) -> Self {
+        PcRelOffset(offset)
+    }
+}
+
+impl From<PcRelOffset> for i32 {
+    #[inline]
+    fn from(offset: PcRelOffset) -> Self {
+        offset.0
+    }
+}
diff --git a/pulley/src/interp.rs b/pulley/src/interp.rs
new file mode 100644
index 000000000000..4eed9bfe592b
--- /dev/null
+++ b/pulley/src/interp.rs
@@ -0,0 +1,1113 @@
+//! Interpretation of pulley bytecode.
+
+use crate::decode::*;
+use crate::imms::*;
+use crate::regs::*;
+use crate::ExtendedOpcode;
+use alloc::string::ToString;
+use alloc::{vec, vec::Vec};
+use core::fmt;
+use core::mem;
+use core::ops::{Index, IndexMut};
+use core::ptr::{self, NonNull};
+use sptr::Strict;
+
+const DEFAULT_STACK_SIZE: usize = 1 << 20; // 1 MiB
+
+/// A virtual machine for interpreting Pulley bytecode.
+pub struct Vm {
+    decoder: Decoder,
+    state: MachineState,
+}
+
+impl Default for Vm {
+    fn default() -> Self {
+        Vm::new()
+    }
+}
+
+impl Vm {
+    /// Create a new virtual machine with the default stack size.
+    pub fn new() -> Self {
+        Self::with_stack(vec![0; DEFAULT_STACK_SIZE])
+    }
+
+    /// Create a new virtual machine with the given stack.
+    pub fn with_stack(stack: Vec<u8>) -> Self {
+        Self {
+            decoder: Decoder::new(),
+            state: MachineState::with_stack(stack),
+        }
+    }
+
+    /// Get a shared reference to this VM's machine state.
+    pub fn state(&self) -> &MachineState {
+        &self.state
+    }
+
+    /// Get an exclusive reference to this VM's machine state.
+    pub fn state_mut(&mut self) -> &mut MachineState {
+        &mut self.state
+    }
+
+    /// Consumer this VM and return its stack storage.
+    pub fn into_stack(self) -> Vec<u8> {
+        self.state.stack
+    }
+
+    /// Call a bytecode function.
+    ///
+    /// The given `func` must point to the beginning of a valid Pulley bytecode
+    /// function.
+    ///
+    /// The given `args` must match the number and type of arguments that
+    /// function expects.
+    ///
+    /// The given `rets` must match the function's actual return types.
+    ///
+    /// Returns either the resulting values, or the PC at which a trap was
+    /// raised.
+    pub unsafe fn call<'a>(
+        &'a mut self,
+        func: NonNull<u8>,
+        args: &[Val],
+        rets: impl IntoIterator<Item = RegType> + 'a,
+    ) -> Result<impl Iterator<Item = Val> + 'a, *mut u8> {
+        // NB: make sure this method stays in sync with
+        // `PulleyMachineDeps::compute_arg_locs`!
+
+        let mut x_args = (0..16).map(|x| XReg::new_unchecked(x));
+        let mut f_args = (0..16).map(|f| FReg::new_unchecked(f));
+        let mut v_args = (0..16).map(|v| VReg::new_unchecked(v));
+
+        for arg in args {
+            match arg {
+                Val::XReg(val) => match x_args.next() {
+                    Some(reg) => self.state[reg] = *val,
+                    None => todo!("stack slots"),
+                },
+                Val::FReg(val) => match f_args.next() {
+                    Some(reg) => self.state[reg] = *val,
+                    None => todo!("stack slots"),
+                },
+                Val::VReg(val) => match v_args.next() {
+                    Some(reg) => self.state[reg] = *val,
+                    None => todo!("stack slots"),
+                },
+            }
+        }
+
+        self.run(func.as_ptr())?;
+
+        let mut x_rets = (0..16).map(|x| XReg::new_unchecked(x));
+        let mut f_rets = (0..16).map(|f| FReg::new_unchecked(f));
+        let mut v_rets = (0..16).map(|v| VReg::new_unchecked(v));
+
+        Ok(rets.into_iter().map(move |ty| match ty {
+            RegType::XReg => match x_rets.next() {
+                Some(reg) => Val::XReg(self.state[reg]),
+                None => todo!("stack slots"),
+            },
+            RegType::FReg => match f_rets.next() {
+                Some(reg) => Val::FReg(self.state[reg]),
+                None => todo!("stack slots"),
+            },
+            RegType::VReg => match v_rets.next() {
+                Some(reg) => Val::VReg(self.state[reg]),
+                None => todo!("stack slots"),
+            },
+        }))
+    }
+
+    unsafe fn run(&mut self, pc: *mut u8) -> Result<(), *mut u8> {
+        let mut visitor = InterpreterVisitor {
+            state: &mut self.state,
+            pc: UnsafeBytecodeStream::new(pc),
+        };
+
+        loop {
+            let continuation = self.decoder.decode_one(&mut visitor).unwrap();
+
+            // Really wish we had `feature(explicit_tail_calls)`...
+            match continuation {
+                Continuation::Continue => {
+                    continue;
+                }
+
+                // Out-of-line slow paths marked `cold` and `inline(never)` to
+                // improve codegen.
+                Continuation::Trap => {
+                    let pc = visitor.pc.as_ptr();
+                    return self.trap(pc);
+                }
+                Continuation::ReturnToHost => return self.return_to_host(),
+                Continuation::HostCall => return self.host_call(),
+            }
+        }
+    }
+
+    #[cold]
+    #[inline(never)]
+    fn return_to_host(&self) -> Result<(), *mut u8> {
+        Ok(())
+    }
+
+    #[cold]
+    #[inline(never)]
+    fn trap(&self, pc: *mut u8) -> Result<(), *mut u8> {
+        // We are given the VM's PC upon having executed a trap instruction,
+        // which is actually pointing to the next instruction after the
+        // trap. Back the PC up to point exactly at the trap.
+        let trap_pc = unsafe { pc.byte_sub(ExtendedOpcode::ENCODED_SIZE_OF_TRAP) };
+        Err(trap_pc)
+    }
+
+    #[cold]
+    #[inline(never)]
+    fn host_call(&self) -> Result<(), *mut u8> {
+        todo!()
+    }
+}
+
+/// The type of a register in the Pulley machine state.
+#[derive(Clone, Copy, Debug)]
+pub enum RegType {
+    /// An `x` register: integers.
+    XReg,
+
+    /// An `f` register: floats.
+    FReg,
+
+    /// A `v` register: vectors.
+    VReg,
+}
+
+/// A value that can be stored in a register.
+#[derive(Clone, Copy, Debug)]
+pub enum Val {
+    /// An `x` register value: integers.
+    XReg(XRegVal),
+
+    /// An `f` register value: floats.
+    FReg(FRegVal),
+
+    /// A `v` register value: vectors.
+    VReg(VRegVal),
+}
+
+impl fmt::LowerHex for Val {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Val::XReg(v) => fmt::LowerHex::fmt(v, f),
+            Val::FReg(v) => fmt::LowerHex::fmt(v, f),
+            Val::VReg(v) => fmt::LowerHex::fmt(v, f),
+        }
+    }
+}
+
+impl From<XRegVal> for Val {
+    fn from(value: XRegVal) -> Self {
+        Val::XReg(value)
+    }
+}
+
+impl From<u64> for Val {
+    fn from(value: u64) -> Self {
+        XRegVal::new_u64(value).into()
+    }
+}
+
+impl From<u32> for Val {
+    fn from(value: u32) -> Self {
+        XRegVal::new_u32(value).into()
+    }
+}
+
+impl From<i64> for Val {
+    fn from(value: i64) -> Self {
+        XRegVal::new_i64(value).into()
+    }
+}
+
+impl From<i32> for Val {
+    fn from(value: i32) -> Self {
+        XRegVal::new_i32(value).into()
+    }
+}
+
+impl<T> From<*mut T> for Val {
+    fn from(value: *mut T) -> Self {
+        XRegVal::new_ptr(value).into()
+    }
+}
+
+impl From<FRegVal> for Val {
+    fn from(value: FRegVal) -> Self {
+        Val::FReg(value)
+    }
+}
+
+impl From<f64> for Val {
+    fn from(value: f64) -> Self {
+        FRegVal::new_f64(value).into()
+    }
+}
+
+impl From<f32> for Val {
+    fn from(value: f32) -> Self {
+        FRegVal::new_f32(value).into()
+    }
+}
+
+impl From<VRegVal> for Val {
+    fn from(value: VRegVal) -> Self {
+        Val::VReg(value)
+    }
+}
+
+/// An `x` register value: integers.
+#[derive(Copy, Clone)]
+pub struct XRegVal(XRegUnion);
+
+impl fmt::Debug for XRegVal {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("XRegVal")
+            .field("as_u64", &self.get_u64())
+            .finish()
+    }
+}
+
+impl fmt::LowerHex for XRegVal {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::LowerHex::fmt(&self.get_u64(), f)
+    }
+}
+
+// NB: we always store these in little endian, so we have to `from_le_bytes`
+// whenever we read and `to_le_bytes` whenever we store.
+#[derive(Copy, Clone)]
+union XRegUnion {
+    i32: i32,
+    u32: u32,
+    i64: i64,
+    u64: u64,
+    ptr: *mut u8,
+}
+
+impl Default for XRegVal {
+    fn default() -> Self {
+        Self(unsafe { mem::zeroed() })
+    }
+}
+
+#[allow(missing_docs)]
+impl XRegVal {
+    pub fn new_i32(x: i32) -> Self {
+        let mut val = XRegVal::default();
+        val.set_i32(x);
+        val
+    }
+
+    pub fn new_u32(x: u32) -> Self {
+        let mut val = XRegVal::default();
+        val.set_u32(x);
+        val
+    }
+
+    pub fn new_i64(x: i64) -> Self {
+        let mut val = XRegVal::default();
+        val.set_i64(x);
+        val
+    }
+
+    pub fn new_u64(x: u64) -> Self {
+        let mut val = XRegVal::default();
+        val.set_u64(x);
+        val
+    }
+
+    pub fn new_ptr<T>(ptr: *mut T) -> Self {
+        let mut val = XRegVal::default();
+        val.set_ptr(ptr);
+        val
+    }
+
+    pub fn get_i32(&self) -> i32 {
+        let x = unsafe { self.0.i32 };
+        i32::from_le(x)
+    }
+
+    pub fn get_u32(&self) -> u32 {
+        let x = unsafe { self.0.u32 };
+        u32::from_le(x)
+    }
+
+    pub fn get_i64(&self) -> i64 {
+        let x = unsafe { self.0.i64 };
+        i64::from_le(x)
+    }
+
+    pub fn get_u64(&self) -> u64 {
+        let x = unsafe { self.0.u64 };
+        u64::from_le(x)
+    }
+
+    pub fn get_ptr<T>(&self) -> *mut T {
+        let ptr = unsafe { self.0.ptr };
+        Strict::map_addr(ptr, |p| usize::from_le(p)).cast()
+    }
+
+    pub fn set_i32(&mut self, x: i32) {
+        self.0.i32 = x.to_le();
+    }
+
+    pub fn set_u32(&mut self, x: u32) {
+        self.0.u32 = x.to_le();
+    }
+
+    pub fn set_i64(&mut self, x: i64) {
+        self.0.i64 = x.to_le();
+    }
+
+    pub fn set_u64(&mut self, x: u64) {
+        self.0.u64 = x.to_le();
+    }
+
+    pub fn set_ptr<T>(&mut self, ptr: *mut T) {
+        self.0.ptr = Strict::map_addr(ptr, |p| p.to_le()).cast();
+    }
+}
+
+/// An `f` register value: floats.
+#[derive(Copy, Clone)]
+pub struct FRegVal(FRegUnion);
+
+impl fmt::Debug for FRegVal {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FRegVal")
+            .field("as_f32", &self.get_f32())
+            .field("as_f64", &self.get_f64())
+            .finish()
+    }
+}
+
+impl fmt::LowerHex for FRegVal {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::LowerHex::fmt(&self.get_f64().to_bits(), f)
+    }
+}
+
+// NB: we always store these in little endian, so we have to `from_le_bytes`
+// whenever we read and `to_le_bytes` whenever we store.
+#[derive(Copy, Clone)]
+union FRegUnion {
+    f32: u32,
+    f64: u64,
+}
+
+impl Default for FRegVal {
+    fn default() -> Self {
+        Self(unsafe { mem::zeroed() })
+    }
+}
+
+#[allow(missing_docs)]
+impl FRegVal {
+    pub fn new_f32(f: f32) -> Self {
+        let mut val = Self::default();
+        val.set_f32(f);
+        val
+    }
+
+    pub fn new_f64(f: f64) -> Self {
+        let mut val = Self::default();
+        val.set_f64(f);
+        val
+    }
+
+    pub fn get_f32(&self) -> f32 {
+        let val = unsafe { self.0.f32 };
+        f32::from_le_bytes(val.to_ne_bytes())
+    }
+
+    pub fn get_f64(&self) -> f64 {
+        let val = unsafe { self.0.f64 };
+        f64::from_le_bytes(val.to_ne_bytes())
+    }
+
+    pub fn set_f32(&mut self, val: f32) {
+        self.0.f32 = u32::from_ne_bytes(val.to_le_bytes());
+    }
+
+    pub fn set_f64(&mut self, val: f64) {
+        self.0.f64 = u64::from_ne_bytes(val.to_le_bytes());
+    }
+}
+
+/// A `v` register value: vectors.
+#[derive(Copy, Clone)]
+pub struct VRegVal(VRegUnion);
+
+impl fmt::Debug for VRegVal {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("VRegVal")
+            .field("as_u128", &unsafe { self.0.u128 })
+            .finish()
+    }
+}
+
+impl fmt::LowerHex for VRegVal {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::LowerHex::fmt(unsafe { &self.0.u128 }, f)
+    }
+}
+
+#[derive(Copy, Clone)]
+union VRegUnion {
+    // TODO: need to figure out how we are going to handle portability of lane
+    // ordering on top of each lane's endianness.
+    u128: u128,
+}
+
+impl Default for VRegVal {
+    fn default() -> Self {
+        Self(unsafe { mem::zeroed() })
+    }
+}
+
+/// The machine state for a Pulley virtual machine: the various registers and
+/// stack.
+pub struct MachineState {
+    x_regs: [XRegVal; XReg::RANGE.end as usize],
+    f_regs: [FRegVal; FReg::RANGE.end as usize],
+    v_regs: [VRegVal; VReg::RANGE.end as usize],
+    stack: Vec<u8>,
+}
+
+unsafe impl Send for MachineState {}
+unsafe impl Sync for MachineState {}
+
+impl fmt::Debug for MachineState {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let MachineState {
+            x_regs,
+            f_regs,
+            v_regs,
+            stack: _,
+        } = self;
+
+        struct RegMap<'a, R>(&'a [R], fn(u8) -> alloc::string::String);
+
+        impl<R: fmt::Debug> fmt::Debug for RegMap<'_, R> {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                let mut f = f.debug_map();
+                for (i, r) in self.0.iter().enumerate() {
+                    f.entry(&(self.1)(i as u8), r);
+                }
+                f.finish()
+            }
+        }
+
+        f.debug_struct("MachineState")
+            .field(
+                "x_regs",
+                &RegMap(x_regs, |i| XReg::new(i).unwrap().to_string()),
+            )
+            .field(
+                "f_regs",
+                &RegMap(f_regs, |i| FReg::new(i).unwrap().to_string()),
+            )
+            .field(
+                "v_regs",
+                &RegMap(v_regs, |i| VReg::new(i).unwrap().to_string()),
+            )
+            .finish_non_exhaustive()
+    }
+}
+
+macro_rules! index_reg {
+    ($reg_ty:ty,$value_ty:ty,$field:ident) => {
+        impl Index<$reg_ty> for MachineState {
+            type Output = $value_ty;
+
+            fn index(&self, reg: $reg_ty) -> &Self::Output {
+                &self.$field[reg.index()]
+            }
+        }
+
+        impl IndexMut<$reg_ty> for MachineState {
+            fn index_mut(&mut self, reg: $reg_ty) -> &mut Self::Output {
+                &mut self.$field[reg.index()]
+            }
+        }
+    };
+}
+
+index_reg!(XReg, XRegVal, x_regs);
+index_reg!(FReg, FRegVal, f_regs);
+index_reg!(VReg, VRegVal, v_regs);
+
+impl MachineState {
+    fn with_stack(stack: Vec<u8>) -> Self {
+        assert!(stack.len() > 0);
+        let mut state = Self {
+            x_regs: [Default::default(); XReg::RANGE.end as usize],
+            f_regs: Default::default(),
+            v_regs: Default::default(),
+            stack,
+        };
+
+        // Take care to construct SP such that we preserve pointer provenance
+        // for the whole stack.
+        let len = state.stack.len();
+        let sp = &mut state.stack[..];
+        let sp = sp.as_mut_ptr();
+        let sp = unsafe { sp.add(len) };
+        state[XReg::sp] = XRegVal::new_ptr(sp);
+        state[XReg::fp] = XRegVal::new_i64(-1);
+        state[XReg::lr] = XRegVal::new_i64(-1);
+
+        state
+    }
+
+    /// `*sp = val; sp += size_of::<T>()`
+    fn push<T>(&mut self, val: T) {
+        let sp = self[XReg::sp].get_ptr::<T>();
+        unsafe { sp.write_unaligned(val) }
+        self[XReg::sp].set_ptr(sp.wrapping_add(1));
+    }
+
+    /// `ret = *sp; sp -= size_of::<T>()`
+    fn pop<T>(&mut self) -> T {
+        let sp = self[XReg::sp].get_ptr::<T>();
+        let val = unsafe { sp.read_unaligned() };
+        self[XReg::sp].set_ptr(sp.wrapping_sub(1));
+        val
+    }
+}
+
+enum Continuation {
+    Continue,
+    ReturnToHost,
+    Trap,
+
+    #[allow(dead_code)]
+    HostCall,
+}
+
+struct InterpreterVisitor<'a> {
+    state: &'a mut MachineState,
+    pc: UnsafeBytecodeStream,
+}
+
+impl InterpreterVisitor<'_> {
+    #[inline(always)]
+    fn pc_rel_jump(&mut self, offset: PcRelOffset, inst_size: isize) -> Continuation {
+        let offset = isize::try_from(i32::from(offset)).unwrap();
+        self.pc = unsafe { self.pc.offset(offset - inst_size) };
+        Continuation::Continue
+    }
+}
+
+#[doc(hidden)]
+impl OpVisitor for InterpreterVisitor<'_> {
+    type BytecodeStream = UnsafeBytecodeStream;
+
+    fn bytecode(&mut self) -> &mut Self::BytecodeStream {
+        &mut self.pc
+    }
+
+    type Return = Continuation;
+
+    fn ret(&mut self) -> Self::Return {
+        if self.state[XReg::lr].get_u64() == u64::MAX {
+            Continuation::ReturnToHost
+        } else {
+            let return_addr = self.state[XReg::lr].get_ptr();
+            self.pc = unsafe { UnsafeBytecodeStream::new(return_addr) };
+            // log::trace!("returning to {return_addr:#p}");
+            Continuation::Continue
+        }
+    }
+
+    fn call(&mut self, offset: PcRelOffset) -> Self::Return {
+        let return_addr = u64::try_from(self.pc.as_ptr() as usize).unwrap();
+        self.state[XReg::lr].set_u64(return_addr);
+        self.pc_rel_jump(offset, 5)
+    }
+
+    fn jump(&mut self, offset: PcRelOffset) -> Self::Return {
+        self.pc_rel_jump(offset, 5)
+    }
+
+    fn br_if(&mut self, cond: XReg, offset: PcRelOffset) -> Self::Return {
+        let cond = self.state[cond].get_u64();
+        if cond != 0 {
+            self.pc_rel_jump(offset, 6)
+        } else {
+            Continuation::Continue
+        }
+    }
+
+    fn br_if_not(&mut self, cond: XReg, offset: PcRelOffset) -> Self::Return {
+        let cond = self.state[cond].get_u64();
+        if cond == 0 {
+            self.pc_rel_jump(offset, 6)
+        } else {
+            Continuation::Continue
+        }
+    }
+
+    fn br_if_xeq32(&mut self, a: XReg, b: XReg, offset: PcRelOffset) -> Self::Return {
+        let a = self.state[a].get_u32();
+        let b = self.state[b].get_u32();
+        if a == b {
+            self.pc_rel_jump(offset, 7)
+        } else {
+            Continuation::Continue
+        }
+    }
+
+    fn br_if_xneq32(&mut self, a: XReg, b: XReg, offset: PcRelOffset) -> Self::Return {
+        let a = self.state[a].get_u32();
+        let b = self.state[b].get_u32();
+        if a != b {
+            self.pc_rel_jump(offset, 7)
+        } else {
+            Continuation::Continue
+        }
+    }
+
+    fn br_if_xslt32(&mut self, a: XReg, b: XReg, offset: PcRelOffset) -> Self::Return {
+        let a = self.state[a].get_i32();
+        let b = self.state[b].get_i32();
+        if a < b {
+            self.pc_rel_jump(offset, 7)
+        } else {
+            Continuation::Continue
+        }
+    }
+
+    fn br_if_xslteq32(&mut self, a: XReg, b: XReg, offset: PcRelOffset) -> Self::Return {
+        let a = self.state[a].get_i32();
+        let b = self.state[b].get_i32();
+        if a <= b {
+            self.pc_rel_jump(offset, 7)
+        } else {
+            Continuation::Continue
+        }
+    }
+
+    fn br_if_xult32(&mut self, a: XReg, b: XReg, offset: PcRelOffset) -> Self::Return {
+        let a = self.state[a].get_u32();
+        let b = self.state[b].get_u32();
+        if a < b {
+            self.pc_rel_jump(offset, 7)
+        } else {
+            Continuation::Continue
+        }
+    }
+
+    fn br_if_xulteq32(&mut self, a: XReg, b: XReg, offset: PcRelOffset) -> Self::Return {
+        let a = self.state[a].get_u32();
+        let b = self.state[b].get_u32();
+        if a <= b {
+            self.pc_rel_jump(offset, 7)
+        } else {
+            Continuation::Continue
+        }
+    }
+
+    fn xmov(&mut self, dst: XReg, src: XReg) -> Self::Return {
+        let val = self.state[src];
+        self.state[dst] = val;
+        Continuation::Continue
+    }
+
+    fn fmov(&mut self, dst: FReg, src: FReg) -> Self::Return {
+        let val = self.state[src];
+        self.state[dst] = val;
+        Continuation::Continue
+    }
+
+    fn vmov(&mut self, dst: VReg, src: VReg) -> Self::Return {
+        let val = self.state[src];
+        self.state[dst] = val;
+        Continuation::Continue
+    }
+
+    fn xconst8(&mut self, dst: XReg, imm: i8) -> Self::Return {
+        self.state[dst].set_i64(i64::from(imm));
+        Continuation::Continue
+    }
+
+    fn xconst16(&mut self, dst: XReg, imm: i16) -> Self::Return {
+        self.state[dst].set_i64(i64::from(imm));
+        Continuation::Continue
+    }
+
+    fn xconst32(&mut self, dst: XReg, imm: i32) -> Self::Return {
+        self.state[dst].set_i64(i64::from(imm));
+        Continuation::Continue
+    }
+
+    fn xconst64(&mut self, dst: XReg, imm: i64) -> Self::Return {
+        self.state[dst].set_i64(imm);
+        Continuation::Continue
+    }
+
+    fn xadd32(&mut self, operands: BinaryOperands<XReg>) -> Self::Return {
+        let a = self.state[operands.src1].get_u32();
+        let b = self.state[operands.src2].get_u32();
+        self.state[operands.dst].set_u32(a.wrapping_add(b));
+        Continuation::Continue
+    }
+
+    fn xadd64(&mut self, operands: BinaryOperands<XReg>) -> Self::Return {
+        let a = self.state[operands.src1].get_u64();
+        let b = self.state[operands.src2].get_u64();
+        self.state[operands.dst].set_u64(a.wrapping_add(b));
+        Continuation::Continue
+    }
+
+    fn xeq64(&mut self, operands: BinaryOperands<XReg>) -> Self::Return {
+        let a = self.state[operands.src1].get_u64();
+        let b = self.state[operands.src2].get_u64();
+        self.state[operands.dst].set_u64(u64::from(a == b));
+        Continuation::Continue
+    }
+
+    fn xneq64(&mut self, operands: BinaryOperands<XReg>) -> Self::Return {
+        let a = self.state[operands.src1].get_u64();
+        let b = self.state[operands.src2].get_u64();
+        self.state[operands.dst].set_u64(u64::from(a != b));
+        Continuation::Continue
+    }
+
+    fn xslt64(&mut self, operands: BinaryOperands<XReg>) -> Self::Return {
+        let a = self.state[operands.src1].get_i64();
+        let b = self.state[operands.src2].get_i64();
+        self.state[operands.dst].set_u64(u64::from(a < b));
+        Continuation::Continue
+    }
+
+    fn xslteq64(&mut self, operands: BinaryOperands<XReg>) -> Self::Return {
+        let a = self.state[operands.src1].get_i64();
+        let b = self.state[operands.src2].get_i64();
+        self.state[operands.dst].set_u64(u64::from(a <= b));
+        Continuation::Continue
+    }
+
+    fn xult64(&mut self, operands: BinaryOperands<XReg>) -> Self::Return {
+        let a = self.state[operands.src1].get_u64();
+        let b = self.state[operands.src2].get_u64();
+        self.state[operands.dst].set_u64(u64::from(a < b));
+        Continuation::Continue
+    }
+
+    fn xulteq64(&mut self, operands: BinaryOperands<XReg>) -> Self::Return {
+        let a = self.state[operands.src1].get_u64();
+        let b = self.state[operands.src2].get_u64();
+        self.state[operands.dst].set_u64(u64::from(a <= b));
+        Continuation::Continue
+    }
+
+    fn xeq32(&mut self, operands: BinaryOperands<XReg>) -> Self::Return {
+        let a = self.state[operands.src1].get_u32();
+        let b = self.state[operands.src2].get_u32();
+        self.state[operands.dst].set_u64(u64::from(a == b));
+        Continuation::Continue
+    }
+
+    fn xneq32(&mut self, operands: BinaryOperands<XReg>) -> Self::Return {
+        let a = self.state[operands.src1].get_u32();
+        let b = self.state[operands.src2].get_u32();
+        self.state[operands.dst].set_u64(u64::from(a != b));
+        Continuation::Continue
+    }
+
+    fn xslt32(&mut self, operands: BinaryOperands<XReg>) -> Self::Return {
+        let a = self.state[operands.src1].get_i32();
+        let b = self.state[operands.src2].get_i32();
+        self.state[operands.dst].set_u64(u64::from(a < b));
+        Continuation::Continue
+    }
+
+    fn xslteq32(&mut self, operands: BinaryOperands<XReg>) -> Self::Return {
+        let a = self.state[operands.src1].get_i32();
+        let b = self.state[operands.src2].get_i32();
+        self.state[operands.dst].set_u64(u64::from(a <= b));
+        Continuation::Continue
+    }
+
+    fn xult32(&mut self, operands: BinaryOperands<XReg>) -> Self::Return {
+        let a = self.state[operands.src1].get_u32();
+        let b = self.state[operands.src2].get_u32();
+        self.state[operands.dst].set_u64(u64::from(a < b));
+        Continuation::Continue
+    }
+
+    fn xulteq32(&mut self, operands: BinaryOperands<XReg>) -> Self::Return {
+        let a = self.state[operands.src1].get_u32();
+        let b = self.state[operands.src2].get_u32();
+        self.state[operands.dst].set_u64(u64::from(a <= b));
+        Continuation::Continue
+    }
+
+    fn load32_u(&mut self, dst: XReg, ptr: XReg) -> Self::Return {
+        let ptr = self.state[ptr].get_ptr::<u32>();
+        let val = unsafe { ptr::read_unaligned(ptr) };
+        self.state[dst].set_u64(u64::from(val));
+        Continuation::Continue
+    }
+
+    fn load32_s(&mut self, dst: XReg, ptr: XReg) -> Self::Return {
+        let ptr = self.state[ptr].get_ptr::<i32>();
+        let val = unsafe { ptr::read_unaligned(ptr) };
+        self.state[dst].set_i64(i64::from(val));
+        Continuation::Continue
+    }
+
+    fn load64(&mut self, dst: XReg, ptr: XReg) -> Self::Return {
+        let ptr = self.state[ptr].get_ptr::<u64>();
+        let val = unsafe { ptr::read_unaligned(ptr) };
+        self.state[dst].set_u64(val);
+        Continuation::Continue
+    }
+
+    fn load32_u_offset8(&mut self, dst: XReg, ptr: XReg, offset: i8) -> Self::Return {
+        let val = unsafe {
+            self.state[ptr]
+                .get_ptr::<u32>()
+                .byte_offset(offset.into())
+                .read_unaligned()
+        };
+        self.state[dst].set_u64(u64::from(val));
+        Continuation::Continue
+    }
+
+    fn load32_s_offset8(&mut self, dst: XReg, ptr: XReg, offset: i8) -> Self::Return {
+        let val = unsafe {
+            self.state[ptr]
+                .get_ptr::<i32>()
+                .byte_offset(offset.into())
+                .read_unaligned()
+        };
+        self.state[dst].set_i64(i64::from(val));
+        Continuation::Continue
+    }
+
+    fn load32_u_offset64(&mut self, dst: XReg, ptr: XReg, offset: i64) -> Self::Return {
+        let val = unsafe {
+            self.state[ptr]
+                .get_ptr::<u32>()
+                .byte_offset(offset as isize)
+                .read_unaligned()
+        };
+        self.state[dst].set_u64(u64::from(val));
+        Continuation::Continue
+    }
+
+    fn load32_s_offset64(&mut self, dst: XReg, ptr: XReg, offset: i64) -> Self::Return {
+        let val = unsafe {
+            self.state[ptr]
+                .get_ptr::<i32>()
+                .byte_offset(offset as isize)
+                .read_unaligned()
+        };
+        self.state[dst].set_i64(i64::from(val));
+        Continuation::Continue
+    }
+
+    fn load64_offset8(&mut self, dst: XReg, ptr: XReg, offset: i8) -> Self::Return {
+        let val = unsafe {
+            self.state[ptr]
+                .get_ptr::<u64>()
+                .byte_offset(offset.into())
+                .read_unaligned()
+        };
+        self.state[dst].set_u64(val);
+        Continuation::Continue
+    }
+
+    fn load64_offset64(&mut self, dst: XReg, ptr: XReg, offset: i64) -> Self::Return {
+        let val = unsafe {
+            self.state[ptr]
+                .get_ptr::<u64>()
+                .byte_offset(offset as isize)
+                .read_unaligned()
+        };
+        self.state[dst].set_u64(val);
+        Continuation::Continue
+    }
+
+    fn store32(&mut self, ptr: XReg, src: XReg) -> Self::Return {
+        let ptr = self.state[ptr].get_ptr::<u32>();
+        let val = self.state[src].get_u32();
+        unsafe {
+            ptr::write_unaligned(ptr, val);
+        }
+        Continuation::Continue
+    }
+
+    fn store64(&mut self, ptr: XReg, src: XReg) -> Self::Return {
+        let ptr = self.state[ptr].get_ptr::<u64>();
+        let val = self.state[src].get_u64();
+        unsafe {
+            ptr::write_unaligned(ptr, val);
+        }
+        Continuation::Continue
+    }
+
+    fn store32_offset8(&mut self, ptr: XReg, offset: i8, src: XReg) -> Self::Return {
+        let val = self.state[src].get_u32();
+        unsafe {
+            self.state[ptr]
+                .get_ptr::<u32>()
+                .byte_offset(offset.into())
+                .write_unaligned(val);
+        }
+        Continuation::Continue
+    }
+
+    fn store64_offset8(&mut self, ptr: XReg, offset: i8, src: XReg) -> Self::Return {
+        let val = self.state[src].get_u64();
+        unsafe {
+            self.state[ptr]
+                .get_ptr::<u64>()
+                .byte_offset(offset.into())
+                .write_unaligned(val);
+        }
+        Continuation::Continue
+    }
+
+    fn store32_offset64(&mut self, ptr: XReg, offset: i64, src: XReg) -> Self::Return {
+        let val = self.state[src].get_u32();
+        unsafe {
+            self.state[ptr]
+                .get_ptr::<u32>()
+                .byte_offset(offset as isize)
+                .write_unaligned(val);
+        }
+        Continuation::Continue
+    }
+
+    fn store64_offset64(&mut self, ptr: XReg, offset: i64, src: XReg) -> Self::Return {
+        let val = self.state[src].get_u64();
+        unsafe {
+            self.state[ptr]
+                .get_ptr::<u64>()
+                .byte_offset(offset as isize)
+                .write_unaligned(val);
+        }
+        Continuation::Continue
+    }
+
+    fn xpush32(&mut self, src: XReg) -> Self::Return {
+        self.state.push(self.state[src].get_u32());
+        Continuation::Continue
+    }
+
+    fn xpush32_many(&mut self, srcs: RegSet<XReg>) -> Self::Return {
+        for src in srcs {
+            self.xpush32(src);
+        }
+        Continuation::Continue
+    }
+
+    fn xpush64(&mut self, src: XReg) -> Self::Return {
+        self.state.push(self.state[src].get_u64());
+        Continuation::Continue
+    }
+
+    fn xpush64_many(&mut self, srcs: RegSet<XReg>) -> Self::Return {
+        for src in srcs {
+            self.xpush64(src);
+        }
+        Continuation::Continue
+    }
+
+    fn xpop32(&mut self, dst: XReg) -> Self::Return {
+        let val = self.state.pop();
+        self.state[dst].set_u32(val);
+        Continuation::Continue
+    }
+
+    fn xpop32_many(&mut self, dsts: RegSet<XReg>) -> Self::Return {
+        for dst in dsts.into_iter().rev() {
+            self.xpop32(dst);
+        }
+        Continuation::Continue
+    }
+
+    fn xpop64(&mut self, dst: XReg) -> Self::Return {
+        let val = self.state.pop();
+        self.state[dst].set_u64(val);
+        Continuation::Continue
+    }
+
+    fn xpop64_many(&mut self, dsts: RegSet<XReg>) -> Self::Return {
+        for dst in dsts.into_iter().rev() {
+            self.xpop64(dst);
+        }
+        Continuation::Continue
+    }
+
+    /// `push lr; push fp; fp = sp`
+    fn push_frame(&mut self) -> Self::Return {
+        self.state.push(self.state[XReg::lr].get_ptr::<u8>());
+        self.state.push(self.state[XReg::fp].get_ptr::<u8>());
+        self.state[XReg::fp] = self.state[XReg::sp];
+        Continuation::Continue
+    }
+
+    /// `sp = fp; pop fp; pop lr`
+    fn pop_frame(&mut self) -> Self::Return {
+        self.state[XReg::sp] = self.state[XReg::fp];
+        let fp = self.state.pop();
+        let lr = self.state.pop();
+        self.state[XReg::fp].set_ptr::<u8>(fp);
+        self.state[XReg::lr].set_ptr::<u8>(lr);
+        Continuation::Continue
+    }
+
+    fn bitcast_int_from_float_32(&mut self, dst: XReg, src: FReg) -> Self::Return {
+        let val = self.state[src].get_f32();
+        self.state[dst].set_u64(u32::from_ne_bytes(val.to_ne_bytes()).into());
+        Continuation::Continue
+    }
+
+    fn bitcast_int_from_float_64(&mut self, dst: XReg, src: FReg) -> Self::Return {
+        let val = self.state[src].get_f64();
+        self.state[dst].set_u64(u64::from_ne_bytes(val.to_ne_bytes()));
+        Continuation::Continue
+    }
+
+    fn bitcast_float_from_int_32(&mut self, dst: FReg, src: XReg) -> Self::Return {
+        let val = self.state[src].get_u32();
+        self.state[dst].set_f32(f32::from_ne_bytes(val.to_ne_bytes()));
+        Continuation::Continue
+    }
+
+    fn bitcast_float_from_int_64(&mut self, dst: FReg, src: XReg) -> Self::Return {
+        let val = self.state[src].get_u64();
+        self.state[dst].set_f64(f64::from_ne_bytes(val.to_ne_bytes()));
+        Continuation::Continue
+    }
+}
+
+impl ExtendedOpVisitor for InterpreterVisitor<'_> {
+    fn nop(&mut self) -> Self::Return {
+        Continuation::Continue
+    }
+
+    fn trap(&mut self) -> Self::Return {
+        Continuation::Trap
+    }
+
+    fn get_sp(&mut self, dst: XReg) -> Self::Return {
+        let sp = self.state[XReg::sp].get_u64();
+        self.state[dst].set_u64(sp);
+        Continuation::Continue
+    }
+}
diff --git a/pulley/src/lib.rs b/pulley/src/lib.rs
new file mode 100644
index 000000000000..0b454f5939fe
--- /dev/null
+++ b/pulley/src/lib.rs
@@ -0,0 +1,215 @@
+//! The pulley bytecode for fast interpreters.
+
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![deny(missing_docs)]
+#![no_std]
+
+#[cfg(feature = "std")]
+#[macro_use]
+extern crate std;
+
+#[allow(unused_extern_crates)] // Some cfg's don't use this.
+extern crate alloc;
+
+/// Calls the given macro with each opcode.
+macro_rules! for_each_op {
+    ( $macro:ident ) => {
+        $macro! {
+            /// Transfer control the address in the `lr` register.
+            ret = Ret;
+
+            /// Transfer control to the PC at the given offset and set the `lr`
+            /// register to the PC just after this instruction.
+            call = Call { offset: PcRelOffset };
+
+            /// Unconditionally transfer control to the PC at the given offset.
+            jump = Jump { offset: PcRelOffset };
+
+            /// Conditionally transfer control to the given PC offset if `cond`
+            /// contains a non-zero value.
+            br_if = BrIf { cond: XReg, offset: PcRelOffset };
+
+            /// Conditionally transfer control to the given PC offset if `cond`
+            /// contains a zero value.
+            br_if_not = BrIfNot { cond: XReg, offset: PcRelOffset };
+
+            /// Branch if `a == b`.
+            br_if_xeq32 = BrIfXeq32 { a: XReg, b: XReg, offset: PcRelOffset };
+            /// Branch if `a != `b.
+            br_if_xneq32 = BrIfXneq32 { a: XReg, b: XReg, offset: PcRelOffset };
+            /// Branch if signed `a < b`.
+            br_if_xslt32 = BrIfXslt32 { a: XReg, b: XReg, offset: PcRelOffset };
+            /// Branch if signed `a <= b`.
+            br_if_xslteq32 = BrIfXslteq32 { a: XReg, b: XReg, offset: PcRelOffset };
+            /// Branch if unsigned `a < b`.
+            br_if_xult32 = BrIfXult32 { a: XReg, b: XReg, offset: PcRelOffset };
+            /// Branch if unsigned `a <= b`.
+            br_if_xulteq32 = BrIfXulteq32 { a: XReg, b: XReg, offset: PcRelOffset };
+
+            /// Move between `x` registers.
+            xmov = Xmov { dst: XReg, src: XReg };
+            /// Move between `f` registers.
+            fmov = Fmov { dst: FReg, src: FReg };
+            /// Move between `v` registers.
+            vmov = Vmov { dst: VReg, src: VReg };
+
+            /// Set `dst = sign_extend(imm8)`.
+            xconst8 = Xconst8 { dst: XReg, imm: i8 };
+            /// Set `dst = sign_extend(imm16)`.
+            xconst16 = Xconst16 { dst: XReg, imm: i16 };
+            /// Set `dst = sign_extend(imm32)`.
+            xconst32 = Xconst32 { dst: XReg, imm: i32 };
+            /// Set `dst = imm64`.
+            xconst64 = Xconst64 { dst: XReg, imm: i64 };
+
+            /// 32-bit wrapping addition: `low32(dst) = low32(src1) + low32(src2)`.
+            ///
+            /// The upper 32-bits of `dst` are unmodified.
+            xadd32 = Xadd32 { operands: BinaryOperands<XReg> };
+
+            /// 64-bit wrapping addition: `dst = src1 + src2`.
+            xadd64 = Xadd64 { operands: BinaryOperands<XReg> };
+
+            /// 64-bit equality.
+            xeq64 = Xeq64 { operands: BinaryOperands<XReg> };
+            /// 64-bit inequality.
+            xneq64 = Xneq64 { operands: BinaryOperands<XReg> };
+            /// 64-bit signed less-than.
+            xslt64 = Xslt64 { operands: BinaryOperands<XReg> };
+            /// 64-bit signed less-than-equal.
+            xslteq64 = Xslteq64 { operands: BinaryOperands<XReg> };
+            /// 64-bit unsigned less-than.
+            xult64 = Xult64 { operands: BinaryOperands<XReg> };
+            /// 64-bit unsigned less-than-equal.
+            xulteq64 = Xulteq64 { operands: BinaryOperands<XReg> };
+            /// 32-bit equality.
+            xeq32 = Xeq32 { operands: BinaryOperands<XReg> };
+            /// 32-bit inequality.
+            xneq32 = Xneq32 { operands: BinaryOperands<XReg> };
+            /// 32-bit signed less-than.
+            xslt32 = Xslt32 { operands: BinaryOperands<XReg> };
+            /// 32-bit signed less-than-equal.
+            xslteq32 = Xslteq32 { operands: BinaryOperands<XReg> };
+            /// 32-bit unsigned less-than.
+            xult32 = Xult32 { operands: BinaryOperands<XReg> };
+            /// 32-bit unsigned less-than-equal.
+            xulteq32 = Xulteq32 { operands: BinaryOperands<XReg> };
+
+            /// `dst = zero_extend(load32(ptr))`
+            load32_u = Load32U { dst: XReg, ptr: XReg };
+            /// `dst = sign_extend(load32(ptr))`
+            load32_s = Load32S { dst: XReg, ptr: XReg };
+            /// `dst = load64(ptr)`
+            load64 = Load64 { dst: XReg, ptr: XReg };
+
+            /// `dst = zero_extend(load32(ptr + offset8))`
+            load32_u_offset8 = Load32UOffset8 { dst: XReg, ptr: XReg, offset: i8 };
+            /// `dst = sign_extend(load32(ptr + offset8))`
+            load32_s_offset8 = Load32SOffset8 { dst: XReg, ptr: XReg, offset: i8 };
+            /// `dst = load64(ptr + offset8)`
+            load64_offset8 = Load64Offset8 { dst: XReg, ptr: XReg, offset: i8 };
+
+            /// `dst = zero_extend(load32(ptr + offset64))`
+            load32_u_offset64 = Load32UOffset64 { dst: XReg, ptr: XReg, offset: i64 };
+            /// `dst = sign_extend(load32(ptr + offset64))`
+            load32_s_offset64 = Load32SOffset64 { dst: XReg, ptr: XReg, offset: i64 };
+            /// `dst = load64(ptr + offset64)`
+            load64_offset64 = Load64Offset64 { dst: XReg, ptr: XReg, offset: i64 };
+
+            /// `*ptr = low32(src)`
+            store32 = Store32 { ptr: XReg, src: XReg };
+            /// `*ptr = src`
+            store64 = Store64 { ptr: XReg, src: XReg };
+
+            /// `*(ptr + sign_extend(offset8)) = low32(src)`
+            store32_offset8 = Store32SOffset8 { ptr: XReg, offset: i8, src: XReg };
+            /// `*(ptr + sign_extend(offset8)) = src`
+            store64_offset8 = Store64Offset8 { ptr: XReg, offset: i8, src: XReg };
+
+            /// `*(ptr + sign_extend(offset64)) = low32(src)`
+            store32_offset64 = Store32SOffset64 { ptr: XReg, offset: i64, src: XReg };
+            /// `*(ptr + sign_extend(offset64)) = src`
+            store64_offset64 = Store64Offset64 { ptr: XReg, offset: i64, src: XReg };
+
+            /// `push lr; push fp; fp = sp`
+            push_frame = PushFrame ;
+            /// `sp = fp; pop fp; pop lr`
+            pop_frame = PopFrame ;
+
+            /// `*sp = low32(src); sp += 4`
+            xpush32 = XPush32 { src: XReg };
+            /// `for src in srcs { xpush32 src }`
+            xpush32_many = XPush32Many { srcs: RegSet<XReg> };
+            /// `*sp = src; sp += 8`
+            xpush64 = XPush64 { src: XReg };
+            /// `for src in srcs { xpush64 src }`
+            xpush64_many = XPush64Many { srcs: RegSet<XReg> };
+
+            /// `*dst = *sp; sp -= 4`
+            xpop32 = XPop32 { dst: XReg };
+            /// `for dst in dsts.rev() { xpop32 dst }`
+            xpop32_many = XPop32Many { dsts: RegSet<XReg> };
+            /// `*dst = *sp; sp -= 8`
+            xpop64 = XPop64 { dst: XReg };
+            /// `for dst in dsts.rev() { xpop64 dst }`
+            xpop64_many = XPop64Many { dsts: RegSet<XReg> };
+
+            /// `low32(dst) = bitcast low32(src) as i32`
+            bitcast_int_from_float_32 = BitcastIntFromFloat32 { dst: XReg, src: FReg };
+            /// `dst = bitcast src as i64`
+            bitcast_int_from_float_64 = BitcastIntFromFloat64 { dst: XReg, src: FReg };
+            /// `low32(dst) = bitcast low32(src) as f32`
+            bitcast_float_from_int_32 = BitcastFloatFromInt32 { dst: FReg, src: XReg };
+            /// `dst = bitcast src as f64`
+            bitcast_float_from_int_64 = BitcastFloatFromInt64 { dst: FReg, src: XReg };
+        }
+    };
+}
+
+/// Calls the given macro with each extended opcode.
+macro_rules! for_each_extended_op {
+    ( $macro:ident ) => {
+        $macro! {
+            /// Raise a trap.
+            trap = Trap;
+
+            /// Do nothing.
+            nop = Nop;
+
+            /// Copy the special `sp` stack pointer register into an `x` register.
+            get_sp = GetSp { dst: XReg };
+        }
+    };
+}
+
+#[cfg(feature = "decode")]
+pub mod decode;
+#[cfg(feature = "disas")]
+pub mod disas;
+#[cfg(feature = "encode")]
+pub mod encode;
+#[cfg(feature = "interp")]
+pub mod interp;
+
+pub mod regs;
+pub use regs::*;
+
+pub mod imms;
+pub use imms::*;
+
+pub mod op;
+pub use op::*;
+
+pub mod opcode;
+pub use opcode::*;
+
+#[allow(dead_code)] // Unused in some `cfg`s.
+pub(crate) unsafe fn unreachable_unchecked<T>() -> T {
+    #[cfg(debug_assertions)]
+    unreachable!();
+
+    #[cfg_attr(debug_assertions, allow(unreachable_code))]
+    unsafe {
+        core::hint::unreachable_unchecked()
+    }
+}
diff --git a/pulley/src/op.rs b/pulley/src/op.rs
new file mode 100644
index 000000000000..9caa63fffa16
--- /dev/null
+++ b/pulley/src/op.rs
@@ -0,0 +1,256 @@
+//! Pulley bytecode operations with their operands.
+
+use crate::imms::*;
+use crate::regs::*;
+
+macro_rules! define_op {
+    (
+        $(
+            $( #[$attr:meta] )*
+            $snake_name:ident = $name:ident $( { $( $field:ident : $field_ty:ty ),* } )? ;
+        )*
+    ) => {
+        /// A complete, materialized operation/instruction.
+        ///
+        /// This type is useful for debugging, writing tests, etc... but is not
+        /// actually ever used by the interpreter, encoder, or decoder, all of
+        /// which avoid materializing ops.
+        #[derive(Clone, Copy, Debug, PartialEq, Eq)]
+        #[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
+        pub enum Op {
+            $(
+                $( #[$attr] )*
+                $name($name),
+            )*
+            /// An extended operation/instruction.
+            ExtendedOp(ExtendedOp),
+        }
+
+        $(
+            $( #[$attr] )*
+            #[derive(Clone, Copy, Debug, PartialEq, Eq)]
+            #[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
+            pub struct $name { $(
+                $(
+                    // TODO: add doc comments to all fields and update all
+                    // the macros to match them.
+                    #[allow(missing_docs)]
+                    pub $field : $field_ty,
+                )*
+            )? }
+
+            impl From<$name> for Op {
+                #[inline]
+                fn from(op: $name) -> Self {
+                    Self::$name(op)
+                }
+            }
+        )*
+    };
+}
+for_each_op!(define_op);
+
+impl From<ExtendedOp> for Op {
+    #[inline]
+    fn from(op: ExtendedOp) -> Self {
+        Op::ExtendedOp(op)
+    }
+}
+
+macro_rules! define_extended_op {
+    (
+        $(
+            $( #[$attr:meta] )*
+            $snake_name:ident = $name:ident $( { $( $field:ident : $field_ty:ty ),* } )? ;
+        )*
+    ) => {
+        /// An extended operation/instruction.
+        ///
+        /// These tend to be colder than `Op`s.
+        #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+        #[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
+        pub enum ExtendedOp {
+            $(
+                $( #[$attr] )*
+                $name($name),
+            )*
+        }
+
+        $(
+            $( #[$attr] )*
+            #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+            #[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
+            pub struct $name { $(
+                $(
+                    // TODO: add doc comments to all fields and update all
+                    // the macros to match them.
+                    #[allow(missing_docs)]
+                    pub $field : $field_ty,
+                )*
+            )? }
+
+            impl From<$name> for Op {
+                #[inline]
+                fn from(op: $name) -> Self {
+                    Self::ExtendedOp(ExtendedOp::$name(op))
+                }
+            }
+
+            impl From<$name> for ExtendedOp {
+                #[inline]
+                fn from(op: $name) -> Self {
+                    Self::$name(op)
+                }
+            }
+        )*
+    };
+}
+for_each_extended_op!(define_extended_op);
+
+macro_rules! define_op_encode {
+    (
+        $(
+            $( #[$attr:meta] )*
+            $snake_name:ident = $name:ident $( { $( $field:ident : $field_ty:ty ),* } )? ;
+        )*
+    ) => {
+        impl Op {
+            /// Encode this op into the given sink.
+            #[cfg(feature = "encode")]
+            pub fn encode<E>(&self, into: &mut E)
+            where
+                E: Extend<u8>,
+            {
+                match self {
+                    $(
+                        Self::$name(op) => op.encode(into),
+                    )*
+                    Self::ExtendedOp(op) => op.encode(into),
+                }
+            }
+        }
+
+        $(
+            impl $name {
+                /// Encode this
+                #[doc = concat!("`", stringify!($name), "`")]
+                /// op into the given sink.
+                #[cfg(feature = "encode")]
+                pub fn encode<E>(&self, into: &mut E)
+                where
+                    E: Extend<u8>,
+                {
+                    crate::encode::$snake_name(into $( $( , self.$field )* )?);
+                }
+            }
+        )*
+    };
+}
+for_each_op!(define_op_encode);
+
+macro_rules! define_extended_op_encode {
+    (
+        $(
+            $( #[$attr:meta] )*
+            $snake_name:ident = $name:ident $( { $( $field:ident : $field_ty:ty ),* } )? ;
+        )*
+    ) => {
+        impl ExtendedOp {
+            /// Encode this extended op into the given sink.
+            #[cfg(feature = "encode")]
+            pub fn encode<E>(&self, into: &mut E)
+            where
+                E: Extend<u8>,
+            {
+                match self {
+                    $(
+                        Self::$name(op) => op.encode(into),
+                    )*
+                }
+            }
+        }
+
+        $(
+            impl $name {
+                /// Encode this
+                #[doc = concat!("`", stringify!($name), "`")]
+                /// op into the given sink.
+                #[cfg(feature = "encode")]
+                pub fn encode<E>(&self, into: &mut E)
+                where
+                    E: Extend<u8>,
+                {
+                    crate::encode::$snake_name(into $( $( , self.$field )* )?);
+                }
+            }
+        )*
+    };
+}
+for_each_extended_op!(define_extended_op_encode);
+
+/// A visitor that materializes whole `Op`s as it decodes the bytecode stream.
+#[cfg(feature = "decode")]
+#[derive(Default)]
+pub struct MaterializeOpsVisitor<B> {
+    bytecode: B,
+}
+
+#[cfg(feature = "decode")]
+impl<B> MaterializeOpsVisitor<B> {
+    /// Create a new op-materializing visitor for the given bytecode.
+    pub fn new(bytecode: B) -> Self {
+        Self { bytecode }
+    }
+}
+
+macro_rules! define_materialize_op_visitor {
+    (
+        $(
+            $( #[$attr:meta] )*
+            $snake_name:ident = $name:ident $( { $( $field:ident : $field_ty:ty ),* } )? ;
+        )*
+    ) => {
+        #[cfg(feature = "decode")]
+        impl<B: crate::decode::BytecodeStream> crate::decode::OpVisitor for MaterializeOpsVisitor<B> {
+            type BytecodeStream = B;
+
+            fn bytecode(&mut self) -> &mut Self::BytecodeStream {
+                &mut self.bytecode
+            }
+
+            type Return = crate::op::Op;
+
+            $(
+                $( #[$attr] )*
+                fn $snake_name(&mut self $( $( , $field : $field_ty )* )? ) -> Self::Return {
+                    crate::op::Op::$name(crate::op::$name { $( $(
+                        $field,
+                    )* )? })
+                }
+            )*
+        }
+    };
+}
+for_each_op!(define_materialize_op_visitor);
+
+macro_rules! define_materialize_extended_op_visitor {
+    (
+        $(
+            $( #[$attr:meta] )*
+            $snake_name:ident = $name:ident $( { $( $field:ident : $field_ty:ty ),* } )? ;
+        )*
+    ) => {
+        #[cfg(feature = "decode")]
+        impl<B: crate::decode::BytecodeStream> crate::decode::ExtendedOpVisitor for MaterializeOpsVisitor<B> {
+            $(
+                $( #[$attr] )*
+                fn $snake_name(&mut self $( $( , $field : $field_ty )* )? ) -> Self::Return {
+                    crate::op::ExtendedOp::$name(crate::op::$name { $( $(
+                        $field,
+                    )* )? }).into()
+                }
+            )*
+        }
+    };
+}
+for_each_extended_op!(define_materialize_extended_op_visitor);
diff --git a/pulley/src/opcode.rs b/pulley/src/opcode.rs
new file mode 100644
index 000000000000..3b79481e0dd5
--- /dev/null
+++ b/pulley/src/opcode.rs
@@ -0,0 +1,126 @@
+//! Pulley opcodes (without operands).
+
+macro_rules! define_opcode {
+    (
+        $(
+            $( #[$attr:meta] )*
+            $snake_name:ident = $name:ident $( {
+                $(
+                    $( #[$field_attr:meta] )*
+                    $field:ident : $field_ty:ty
+                ),*
+            } )? ;
+        )*
+    ) => {
+        /// An opcode without its immediates and operands.
+        #[repr(u8)]
+        #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+        pub enum Opcode {
+            $(
+                $( #[$attr] )*
+                $name,
+            )*
+            /// The extended-op opcode. An `ExtendedOpcode` follows this opcode.
+            ExtendedOp,
+        }
+
+        impl Opcode {
+            /// The value of the maximum defined opcode.
+            pub const MAX: u8 = define_opcode!( @max $( $name )* ) + 1;
+        }
+    };
+
+    ( @max $x:ident ) => { 0 };
+    ( @max $x:ident $( $xs:ident )* ) => { 1 + define_opcode!(@max $( $xs )* ) };
+}
+for_each_op!(define_opcode);
+
+impl Opcode {
+    /// Create a new `Opcode` from the given byte.
+    ///
+    /// Returns `None` if `byte` is not a valid opcode.
+    pub fn new(byte: u8) -> Option<Self> {
+        if byte <= Self::MAX {
+            Some(unsafe { Self::unchecked_new(byte) })
+        } else {
+            None
+        }
+    }
+
+    /// Like `new` but does not check whether `byte` is a valid opcode.
+    ///
+    /// # Safety
+    ///
+    /// It is unsafe to pass a `byte` that is not a valid opcode.
+    pub unsafe fn unchecked_new(byte: u8) -> Self {
+        debug_assert!(byte <= Self::MAX);
+        core::mem::transmute(byte)
+    }
+}
+
+macro_rules! define_extended_opcode {
+    (
+        $(
+            $( #[$attr:meta] )*
+            $snake_name:ident = $name:ident $( { $( $field:ident : $field_ty:ty ),* } )? ;
+        )*
+    ) => {
+        /// An extended opcode.
+        #[repr(u16)]
+        #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+        pub enum ExtendedOpcode {
+            $(
+                $( #[$attr] )*
+                    $name,
+            )*
+        }
+
+        impl ExtendedOpcode {
+            /// The value of the maximum defined extended opcode.
+            pub const MAX: u16 = define_opcode!( @max $( $name )* );
+        }
+    };
+
+    ( @max $x:ident ) => { 0 };
+    ( @max $x:ident $( $xs:ident )* ) => { 1 + define_opcode!(@max $( $xs )* ) };
+}
+for_each_extended_op!(define_extended_opcode);
+
+impl ExtendedOpcode {
+    #[cfg_attr(not(feature = "interp"), allow(unused))]
+    pub(crate) const ENCODED_SIZE_OF_TRAP: usize = 3;
+
+    /// Create a new `ExtendedOpcode` from the given bytes.
+    ///
+    /// Returns `None` if `bytes` is not a valid extended opcode.
+    pub fn new(bytes: u16) -> Option<Self> {
+        if bytes <= Self::MAX {
+            Some(unsafe { Self::unchecked_new(bytes) })
+        } else {
+            None
+        }
+    }
+
+    /// Like `new` but does not check whether `bytes` is a valid opcode.
+    ///
+    /// # Safety
+    ///
+    /// It is unsafe to pass `bytes` that is not a valid opcode.
+    pub unsafe fn unchecked_new(byte: u16) -> Self {
+        debug_assert!(byte <= Self::MAX);
+        core::mem::transmute(byte)
+    }
+}
+
+#[cfg(all(test, feature = "encode"))]
+mod tests {
+    use super::*;
+    use alloc::vec::Vec;
+
+    #[test]
+    fn encoded_size_of_trap() {
+        let mut buf = Vec::new();
+        crate::encode::trap(&mut buf);
+        assert_eq!(ExtendedOpcode::ENCODED_SIZE_OF_TRAP, buf.len());
+    }
+}
diff --git a/pulley/src/regs.rs b/pulley/src/regs.rs
new file mode 100644
index 000000000000..2b651aae8a88
--- /dev/null
+++ b/pulley/src/regs.rs
@@ -0,0 +1,329 @@
+//! Pulley registers.
+
+use core::hash::Hash;
+use core::marker::PhantomData;
+use core::{fmt, ops::Range};
+
+use cranelift_bitset::ScalarBitSet;
+
+/// Trait for common register operations.
+pub trait Reg: Sized + Copy + Eq + Ord + Hash + Into<AnyReg> + fmt::Debug + fmt::Display {
+    /// Range of valid register indices.
+    const RANGE: Range<u8>;
+
+    /// Convert a register index to a register, without bounds checking.
+    unsafe fn new_unchecked(index: u8) -> Self;
+
+    /// Convert a register index to a register, with bounds checking.
+    fn new(index: u8) -> Option<Self> {
+        if Self::RANGE.contains(&index) {
+            Some(unsafe { Self::new_unchecked(index) })
+        } else {
+            None
+        }
+    }
+
+    /// Convert a register to its index.
+    fn to_u8(self) -> u8;
+
+    /// Convert a register to its index.
+    fn index(self) -> usize {
+        self.to_u8().into()
+    }
+}
+
+macro_rules! impl_reg {
+    ($reg_ty:ty, $any:ident, $range:expr) => {
+        impl From<$reg_ty> for AnyReg {
+            fn from(r: $reg_ty) -> Self {
+                AnyReg::$any(r)
+            }
+        }
+
+        impl fmt::Display for $reg_ty {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                fmt::Debug::fmt(&self, f)
+            }
+        }
+
+        impl Reg for $reg_ty {
+            const RANGE: Range<u8> = $range;
+
+            unsafe fn new_unchecked(index: u8) -> Self {
+                core::mem::transmute(index)
+            }
+
+            fn to_u8(self) -> u8 {
+                self as u8
+            }
+        }
+    };
+}
+
+/// An `x` register: integers.
+#[repr(u8)]
+#[derive(Debug,Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
+#[allow(non_camel_case_types, missing_docs)]
+#[rustfmt::skip]
+pub enum XReg {
+    x0,  x1,  x2,  x3,  x4,  x5,  x6,  x7,  x8,  x9,
+    x10, x11, x12, x13, x14, x15, x16, x17, x18, x19,
+    x20, x21, x22, x23, x24, x25, x26,
+
+    /// The special `sp` stack pointer register.
+    sp,
+
+    /// The special `lr` link register.
+    lr,
+
+    /// The special `fp` frame pointer register.
+    fp,
+
+    /// The special `spilltmp0` scratch register.
+    spilltmp0,
+
+    /// The special `spilltmp1` scratch register.
+    spilltmp1,
+}
+
+impl XReg {
+    /// Is this `x` register a special register?
+    pub fn is_special(self) -> bool {
+        matches!(
+            self,
+            Self::sp | Self::lr | Self::fp | Self::spilltmp0 | Self::spilltmp1
+        )
+    }
+}
+
+/// An `f` register: floats.
+#[repr(u8)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
+#[allow(non_camel_case_types, missing_docs)]
+#[rustfmt::skip]
+pub enum FReg {
+    f0,  f1,  f2,  f3,  f4,  f5,  f6,  f7,  f8,  f9,
+    f10, f11, f12, f13, f14, f15, f16, f17, f18, f19,
+    f20, f21, f22, f23, f24, f25, f26, f27, f28, f29,
+    f30, f31,
+}
+
+/// A `v` register: vectors.
+#[repr(u8)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
+#[allow(non_camel_case_types, missing_docs)]
+#[rustfmt::skip]
+pub enum VReg {
+    v0,  v1,  v2,  v3,  v4,  v5,  v6,  v7,  v8,  v9,
+    v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,
+    v20, v21, v22, v23, v24, v25, v26, v27, v28, v29,
+    v30, v31,
+}
+
+impl_reg!(XReg, X, 0..32);
+impl_reg!(FReg, F, 0..32);
+impl_reg!(VReg, V, 0..32);
+
+/// Any register, regardless of class.
+///
+/// Never appears inside an instruction -- instructions always name a particular
+/// class of register -- but this is useful for testing and things like that.
+#[allow(missing_docs)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
+pub enum AnyReg {
+    X(XReg),
+    F(FReg),
+    V(VReg),
+}
+
+impl fmt::Display for AnyReg {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Debug::fmt(self, f)
+    }
+}
+
+impl fmt::Debug for AnyReg {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            AnyReg::X(r) => fmt::Debug::fmt(r, f),
+            AnyReg::F(r) => fmt::Debug::fmt(r, f),
+            AnyReg::V(r) => fmt::Debug::fmt(r, f),
+        }
+    }
+}
+
+/// Operands to a binary operation, packed into a 16-bit word (5 bits per register).
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
+pub struct BinaryOperands<R> {
+    /// The destination register, packed in bits 0..5.
+    pub dst: R,
+    /// The first source register, packed in bits 5..10.
+    pub src1: R,
+    /// The second source register, packed in bits 10..15.
+    pub src2: R,
+}
+
+impl<R: Reg> BinaryOperands<R> {
+    /// Convenience constructor for applying `Into`
+    pub fn new(dst: impl Into<R>, src1: impl Into<R>, src2: impl Into<R>) -> Self {
+        Self {
+            dst: dst.into(),
+            src1: src1.into(),
+            src2: src2.into(),
+        }
+    }
+
+    /// Convert to dense 16 bit encoding.
+    pub fn to_bits(self) -> u16 {
+        let dst = self.dst.to_u8();
+        let src1 = self.src1.to_u8();
+        let src2 = self.src2.to_u8();
+        (dst as u16) | ((src1 as u16) << 5) | ((src2 as u16) << 10)
+    }
+
+    /// Convert from dense 16 bit encoding. The topmost bit is ignored.
+    pub fn from_bits(bits: u16) -> Self {
+        Self {
+            dst: R::new((bits & 0b11111) as u8).unwrap(),
+            src1: R::new(((bits >> 5) & 0b11111) as u8).unwrap(),
+            src2: R::new(((bits >> 10) & 0b11111) as u8).unwrap(),
+        }
+    }
+}
+
+/// A set of registers, packed into a 32-bit bitset.
+pub struct RegSet<R> {
+    bitset: ScalarBitSet<u32>,
+    phantom: PhantomData<R>,
+}
+
+impl<R: Reg> RegSet<R> {
+    /// Create a `RegSet` from a `ScalarBitSet`.
+    pub fn from_bitset(bitset: ScalarBitSet<u32>) -> Self {
+        Self {
+            bitset,
+            phantom: PhantomData,
+        }
+    }
+
+    /// Convert a `RegSet` into a `ScalarBitSet`.
+    pub fn to_bitset(self) -> ScalarBitSet<u32> {
+        self.bitset
+    }
+}
+
+impl<R: Reg> From<ScalarBitSet<u32>> for RegSet<R> {
+    fn from(bitset: ScalarBitSet<u32>) -> Self {
+        Self {
+            bitset,
+            phantom: PhantomData,
+        }
+    }
+}
+
+impl<R: Reg> Into<ScalarBitSet<u32>> for RegSet<R> {
+    fn into(self) -> ScalarBitSet<u32> {
+        self.bitset
+    }
+}
+
+impl<R: Reg> IntoIterator for RegSet<R> {
+    type Item = R;
+    type IntoIter = core::iter::FilterMap<cranelift_bitset::scalar::Iter<u32>, fn(u8) -> Option<R>>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.bitset.into_iter().filter_map(R::new)
+    }
+}
+
+impl<R: Reg> FromIterator<R> for RegSet<R> {
+    fn from_iter<I: IntoIterator<Item = R>>(iter: I) -> Self {
+        let mut set = ScalarBitSet::new();
+        for reg in iter {
+            set.insert(reg.to_u8());
+        }
+        RegSet::from(set)
+    }
+}
+
+impl<R: Reg> Default for RegSet<R> {
+    fn default() -> Self {
+        Self {
+            bitset: Default::default(),
+            phantom: Default::default(),
+        }
+    }
+}
+
+impl<R: Reg> Copy for RegSet<R> {}
+impl<R: Reg> Clone for RegSet<R> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<R: Reg> PartialEq for RegSet<R> {
+    fn eq(&self, other: &Self) -> bool {
+        self.bitset == other.bitset
+    }
+}
+impl<R: Reg> Eq for RegSet<R> {}
+
+impl<R: Reg> fmt::Debug for RegSet<R> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_set().entries(self.into_iter()).finish()
+    }
+}
+
+#[cfg(feature = "arbitrary")]
+impl<'a, R: Reg> arbitrary::Arbitrary<'a> for RegSet<R> {
+    fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
+        ScalarBitSet::arbitrary(u).map(Self::from)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn special_x_regs() {
+        assert!(XReg::sp.is_special());
+        assert!(XReg::lr.is_special());
+        assert!(XReg::fp.is_special());
+        assert!(XReg::spilltmp0.is_special());
+        assert!(XReg::spilltmp1.is_special());
+    }
+
+    #[test]
+    fn not_special_x_regs() {
+        for i in 0..27 {
+            assert!(!XReg::new(i).unwrap().is_special());
+        }
+    }
+
+    #[test]
+    fn binary_operands() {
+        let mut i = 0;
+        for src2 in XReg::RANGE {
+            for src1 in XReg::RANGE {
+                for dst in XReg::RANGE {
+                    let operands = BinaryOperands {
+                        dst: XReg::new(dst).unwrap(),
+                        src1: XReg::new(src1).unwrap(),
+                        src2: XReg::new(src2).unwrap(),
+                    };
+                    assert_eq!(operands.to_bits(), i);
+                    assert_eq!(BinaryOperands::from_bits(i), operands);
+                    assert_eq!(BinaryOperands::from_bits(0x8000 | i), operands);
+                    i += 1;
+                }
+            }
+        }
+    }
+}
diff --git a/pulley/tests/all/disas.rs b/pulley/tests/all/disas.rs
new file mode 100644
index 000000000000..eb2b49a5687c
--- /dev/null
+++ b/pulley/tests/all/disas.rs
@@ -0,0 +1,87 @@
+//! Disassembly tests.
+
+use pulley_interpreter::*;
+
+fn encoded(ops: &[Op]) -> Vec<u8> {
+    let mut encoded = vec![];
+    for op in ops {
+        op.encode(&mut encoded);
+    }
+    log::trace!("encoded: {encoded:?}");
+    encoded
+}
+
+fn assert_disas(ops: &[Op], expected: &str) {
+    let expected = expected.trim();
+    eprintln!("=== expected ===\n{expected}");
+
+    let bytecode = encoded(ops);
+
+    let actual = disas::Disassembler::disassemble_all(&bytecode).expect("decoding failed");
+    let actual = actual.trim();
+    eprintln!("=== actual ===\n{actual}");
+
+    assert_eq!(expected, actual);
+}
+
+#[test]
+fn simple() {
+    assert_disas(
+        &[
+            // Prologue.
+            Op::PushFrame(PushFrame {}),
+            // Function body.
+            Op::Xadd32(Xadd32 {
+                operands: BinaryOperands {
+                    dst: XReg::x0,
+                    src1: XReg::x0,
+                    src2: XReg::x1,
+                },
+            }),
+            // Epilogue.
+            Op::PopFrame(PopFrame {}),
+            Op::Ret(Ret {}),
+        ],
+        r#"
+       0: 2f                              push_frame
+       1: 12 00 04                        xadd32 x0, x0, x1
+       4: 30                              pop_frame
+       5: 00                              ret
+        "#,
+    );
+}
+
+#[test]
+fn push_pop_many() {
+    assert_disas(
+        &[
+            // Prologue.
+            Op::PushFrame(PushFrame {}),
+            Op::XPush32Many(XPush32Many {
+                srcs: RegSet::from_iter([XReg::x0, XReg::x1, XReg::x2, XReg::x3, XReg::x4]),
+            }),
+            // Function body.
+            Op::Xadd32(Xadd32 {
+                operands: BinaryOperands {
+                    dst: XReg::x0,
+                    src1: XReg::x0,
+                    src2: XReg::x1,
+                },
+            }),
+            // Epilogue.
+            Op::XPop32Many(XPop32Many {
+                dsts: RegSet::from_iter([XReg::x0, XReg::x1, XReg::x2, XReg::x3, XReg::x4]),
+            }),
+            Op::PopFrame(PopFrame {}),
+            Op::Ret(Ret {}),
+        ],
+        r#"
+       0: 2f                              push_frame
+       1: 32 1f 00 00 00                  xpush32_many x0, x1, x2, x3, x4
+       6: 12 00 04                        xadd32 x0, x0, x1
+       9: 36 1f 00 00 00                  xpop32_many x0, x1, x2, x3, x4
+       e: 30                              pop_frame
+       f: 00                              ret
+        "#,
+    );
+}
diff --git a/pulley/tests/all/interp.rs b/pulley/tests/all/interp.rs
new file mode 100644
index 000000000000..085c09cf3044
--- /dev/null
+++ b/pulley/tests/all/interp.rs
@@ -0,0 +1,1216 @@
+//! Interpreter tests.
+
+use interp::Val;
+use pulley_interpreter::{interp::Vm, *};
+use std::{cell::UnsafeCell, fmt::Debug, ptr::NonNull};
+
+fn encoded(ops: &[Op]) -> Vec<u8> {
+    let mut encoded = vec![];
+    for op in ops {
+        op.encode(&mut encoded);
+    }
+    log::trace!("encoded: {encoded:?}");
+    encoded
+}
+
+unsafe fn run(vm: &mut Vm, ops: &[Op]) -> Result<(), *mut u8> {
+    let _ = env_logger::try_init();
+    let ops = encoded(ops);
+    let _ = vm.call(NonNull::from(&ops[..]).cast(), &[], [])?;
+    Ok(())
+}
+
+unsafe fn assert_one<R0, R1, V>(
+    xs: impl IntoIterator<Item = (R0, V)>,
+    op: impl Into<Op> + Debug,
+    result: R1,
+    expected: u64,
+) where
+    R0: Into<AnyReg>,
+    R1: Into<AnyReg>,
+    V: Into<Val>,
+{
+    eprintln!("=======================================================");
+    let mut vm = Vm::new();
+
+    for (reg, val) in xs {
+        let reg = reg.into();
+        let val = val.into();
+        eprintln!("{reg} = {val:#018x}");
+        match (reg, val) {
+            (AnyReg::X(r), Val::XReg(v)) => vm.state_mut()[r] = v,
+            (AnyReg::F(r), Val::FReg(v)) => vm.state_mut()[r] = v,
+            (AnyReg::V(_), Val::VReg(_)) => todo!(),
+            (kind, val) => panic!("register kind and value mismatch: {kind:?} and {val:?}"),
+        }
+    }
+
+    eprintln!("op = {op:?}");
+    let op = op.into();
+
+    run(&mut vm, &[op, Op::Ret(Ret {})]).expect("should not trap");
+
+    eprintln!("expected = {expected:#018x}");
+
+    let actual = match result.into() {
+        AnyReg::X(r) => vm.state_mut()[r].get_u64(),
+        AnyReg::F(r) => vm.state_mut()[r].get_f64().to_bits(),
+        AnyReg::V(_) => todo!(),
+    };
+    eprintln!("actual   = {actual:#018x}");
+
+    assert_eq!(expected, actual);
+}
+
+fn x(x: u8) -> XReg {
+    XReg::new(x).unwrap()
+}
+
+fn f(f: u8) -> FReg {
+    FReg::new(f).unwrap()
+}
+
+#[test]
+fn xconst8() {
+    for (expected, imm) in [(42u64, 42i8), (u64::MAX, -1i8)] {
+        unsafe {
+            assert_one(
+                [(x(0), 0x1234567812345678u64)],
+                Xconst8 { dst: x(0), imm },
+                x(0),
+                expected,
+            );
+        }
+    }
+}
+
+#[test]
+fn xconst16() {
+    for (expected, imm) in [(42u64, 42i16), (u64::MAX, -1i16)] {
+        unsafe {
+            assert_one(
+                [(x(0), 0x1234567812345678u64)],
+                Xconst16 { dst: x(0), imm },
+                x(0),
+                expected,
+            );
+        }
+    }
+}
+
+#[test]
+fn xconst32() {
+    for (expected, imm) in [(42u64, 42i32), (u64::MAX, -1i32)] {
+        unsafe {
+            assert_one(
+                [(x(0), 0x1234567812345678u64)],
+                Xconst32 { dst: x(0), imm },
+                x(0),
+                expected,
+            );
+        }
+    }
+}
+
+#[test]
+fn xconst64() {
+    for (expected, imm) in [(42u64, 42i64), (u64::MAX, -1i64)] {
+        unsafe {
+            assert_one(
+                [(x(0), 0x1234567812345678u64)],
+                Xconst64 { dst: x(0), imm },
+                x(0),
+                expected,
+            );
+        }
+    }
+}
+
+#[test]
+fn xadd32() {
+    for (expected, a, b) in [
+        (42u64 | 0x1234567800000000, 10u64, 32u64),
+        (0x1234567800000000, u32::MAX as _, 1),
+    ] {
+        unsafe {
+            assert_one(
+                [(x(0), 0x1234567812345678), (x(1), a), (x(2), b)],
+                Xadd32 {
+                    operands: BinaryOperands {
+                        dst: x(0),
+                        src1: x(1),
+                        src2: x(2),
+                    },
+                },
+                x(0),
+                expected,
+            );
+        }
+    }
+}
+
+#[test]
+fn xadd64() {
+    for (expected, a, b) in [(42u64, 10u64, 32u64), (0, u64::MAX, 1)] {
+        unsafe {
+            assert_one(
+                [(x(0), 0x1234567812345678), (x(1), a), (x(2), b)],
+                Xadd64 {
+                    operands: BinaryOperands {
+                        dst: x(0),
+                        src1: x(1),
+                        src2: x(2),
+                    },
+                },
+                x(0),
+                expected,
+            );
+        }
+    }
+}
+
+#[test]
+fn xeq64() {
+    for (expected, a, b) in [
+        (1u64, 0u64, 0u64),
+        (0, 0, 1),
+        (1, u64::MAX, u64::MAX),
+        (0, u64::MAX, u64::MAX - 1),
+    ] {
+        unsafe {
+            assert_one(
+                [(x(0), 0x1234567812345678), (x(1), a), (x(2), b)],
+                Xeq64 {
+                    operands: BinaryOperands {
+                        dst: x(0),
+                        src1: x(1),
+                        src2: x(2),
+                    },
+                },
+                x(0),
+                expected,
+            );
+        }
+    }
+}
+
+#[test]
+fn xneq64() {
+    for (expected, a, b) in [
+        (0u64, 0u64, 0u64),
+        (1, 0, 1),
+        (0, u64::MAX, u64::MAX),
+        (1, u64::MAX, u64::MAX - 1),
+    ] {
+        unsafe {
+            assert_one(
+                [(x(0), 0x1234567812345678), (x(1), a), (x(2), b)],
+                Xneq64 {
+                    operands: BinaryOperands {
+                        dst: x(0),
+                        src1: x(1),
+                        src2: x(2),
+                    },
+                },
+                x(0),
+                expected,
+            );
+        }
+    }
+}
+
+#[test]
+fn xslt64() {
+    for (expected, a, b) in [
+        (0u64, 0u64, 0u64),
+        (0, 1, 0),
+        (1, 0, 1),
+        (0, 0, -1 as _),
+        (1, -1 as _, 0),
+        (0, i64::MAX as u64, i64::MAX as u64),
+        (0, i64::MAX as u64, i64::MAX as u64 - 1),
+        (1, i64::MAX as u64 - 1, i64::MAX as u64),
+        (0, i64::MIN as u64, i64::MIN as u64),
+        (0, i64::MIN as u64 + 1, i64::MIN as u64),
+        (1, i64::MIN as u64, i64::MIN as u64 + 1),
+    ] {
+        unsafe {
+            assert_one(
+                [(x(0), 0x1234567812345678), (x(1), a), (x(2), b)],
+                Xslt64 {
+                    operands: BinaryOperands {
+                        dst: x(0),
+                        src1: x(1),
+                        src2: x(2),
+                    },
+                },
+                x(0),
+                expected,
+            );
+        }
+    }
+}
+
+#[test]
+fn xslteq64() {
+    for (expected, a, b) in [
+        (1u64, 0u64, 0u64),
+        (0, 1, 0),
+        (1, 0, 1),
+        (0, 0, -1 as _),
+        (1, -1 as _, 0),
+        (1, i64::MAX as u64, i64::MAX as u64),
+        (0, i64::MAX as u64, i64::MAX as u64 - 1),
+        (1, i64::MAX as u64 - 1, i64::MAX as u64),
+        (1, i64::MIN as u64, i64::MIN as u64),
+        (0, i64::MIN as u64 + 1, i64::MIN as u64),
+        (1, i64::MIN as u64, i64::MIN as u64 + 1),
+    ] {
+        unsafe {
+            assert_one(
+                [(x(0), 0x1234567812345678), (x(1), a), (x(2), b)],
+                Xslteq64 {
+                    operands: BinaryOperands {
+                        dst: x(0),
+                        src1: x(1),
+                        src2: x(2),
+                    },
+                },
+                x(0),
+                expected,
+            );
+        }
+    }
+}
+
+#[test]
+fn xult64() {
+    for (expected, a, b) in [
+        (0u64, 0u64, 0u64),
+        (0, 1, 0),
+        (1, 0, 1),
+        (0, u64::MAX, u64::MAX),
+        (0, u64::MAX, u64::MAX - 1),
+        (1, u64::MAX - 1, u64::MAX),
+        (0, i64::MIN as u64, 0),
+        (1, 0, i64::MIN as u64),
+    ] {
+        unsafe {
+            assert_one(
+                [(x(0), 0x1234567812345678), (x(1), a), (x(2), b)],
+                Xult64 {
+                    operands: BinaryOperands {
+                        dst: x(0),
+                        src1: x(1),
+                        src2: x(2),
+                    },
+                },
+                x(0),
+                expected,
+            );
+        }
+    }
+}
+
+#[test]
+fn xulteq64() {
+    for (expected, a, b) in [
+        (1u64, 0u64, 0u64),
+        (0, 1, 0),
+        (1, 0, 1),
+        (1, u64::MAX, u64::MAX),
+        (0, u64::MAX, u64::MAX - 1),
+        (1, u64::MAX - 1, u64::MAX),
+        (0, i64::MIN as u64, 0),
+        (1, 0, i64::MIN as u64),
+    ] {
+        unsafe {
+            assert_one(
+                [(x(0), 0x1234567812345678), (x(1), a), (x(2), b)],
+                Xulteq64 {
+                    operands: BinaryOperands {
+                        dst: x(0),
+                        src1: x(1),
+                        src2: x(2),
+                    },
+                },
+                x(0),
+                expected,
+            );
+        }
+    }
+}
+
+#[test]
+fn xeq32() {
+    for (expected, a, b) in [
+        (1u64, 0u64, 0u64),
+        (0, 0, 1),
+        (1, u64::MAX, u64::MAX),
+        (0, u64::MAX, u64::MAX - 1),
+        (1, 0xffffffff00000001, 1),
+        (0, 0xffffffff00000000, 1),
+        (0, 0xffffffff00000001, 0),
+        (1, 0xffffffff00000000, 0),
+    ] {
+        unsafe {
+            assert_one(
+                [(x(0), 0x1234567812345678), (x(1), a), (x(2), b)],
+                Xeq32 {
+                    operands: BinaryOperands {
+                        dst: x(0),
+                        src1: x(1),
+                        src2: x(2),
+                    },
+                },
+                x(0),
+                expected,
+            );
+        }
+    }
+}
+
+#[test]
+fn xneq32() {
+    for (expected, a, b) in [
+        (0u64, 0u64, 0u64),
+        (1, 0, 1),
+        (0, u64::MAX, u64::MAX),
+        (1, u64::MAX, u64::MAX - 1),
+        (0, 0xffffffff00000000, 0),
+    ] {
+        unsafe {
+            assert_one(
+                [(x(0), 0x1234567812345678), (x(1), a), (x(2), b)],
+                Xneq32 {
+                    operands: BinaryOperands {
+                        dst: x(0),
+                        src1: x(1),
+                        src2: x(2),
+                    },
+                },
+                x(0),
+                expected,
+            );
+        }
+    }
+}
+
+#[test]
+fn xslt32() {
+    for (expected, a, b) in [
+        (0u64, 0u64, 0u64),
+        (0, 1, 0),
+        (1, 0, 1),
+        (0, 0, -1 as _),
+        (1, -1 as _, 0),
+        (0, i64::MAX as u64, i64::MAX as u64),
+        (0, i64::MAX as u64, i64::MAX as u64 - 1),
+        (1, i64::MAX as u64 - 1, i64::MAX as u64),
+        (0, i64::MIN as u64, i64::MIN as u64),
+        (0, i64::MIN as u64 + 1, i64::MIN as u64),
+        (1, i64::MIN as u64, i64::MIN as u64 + 1),
+        (1, 0x00000000ffffffff, 0),
+        (0, 0, 0x00000000ffffffff),
+    ] {
+        unsafe {
+            assert_one(
+                [(x(0), 0x1234567812345678), (x(1), a), (x(2), b)],
+                Xslt32 {
+                    operands: BinaryOperands {
+                        dst: x(0),
+                        src1: x(1),
+                        src2: x(2),
+                    },
+                },
+                x(0),
+                expected,
+            );
+        }
+    }
+}
+
+#[test]
+fn xslteq32() {
+    for (expected, a, b) in [
+        (1u64, 0u64, 0u64),
+        (0, 1, 0),
+        (1, 0, 1),
+        (0, 0, -1 as _),
+        (1, -1 as _, 0),
+        (1, i64::MAX as u64, i64::MAX as u64),
+        (0, i64::MAX as u64, i64::MAX as u64 - 1),
+        (1, i64::MAX as u64 - 1, i64::MAX as u64),
+        (1, i64::MIN as u64, i64::MIN as u64),
+        (0, i64::MIN as u64 + 1, i64::MIN as u64),
+        (1, i64::MIN as u64, i64::MIN as u64 + 1),
+    ] {
+        unsafe {
+            assert_one(
+                [(x(0), 0x1234567812345678), (x(1), a), (x(2), b)],
+                Xslteq32 {
+                    operands: BinaryOperands {
+                        dst: x(0),
+                        src1: x(1),
+                        src2: x(2),
+                    },
+                },
+                x(0),
+                expected,
+            );
+        }
+    }
+}
+
+#[test]
+fn xult32() {
+    for (expected, a, b) in [
+        (0u64, 0u64, 0u64),
+        (0, 1, 0),
+        (1, 0, 1),
+        (0, 0x00000000ffffffff, 0xfffffffffffffffe),
+        (1, 0xfffffffffffffffe, 0x00000000ffffffff),
+        (0, 0x00000000ffffffff, 0xffffffffffffffff),
+        (0, 0xfffffffffffffffe, 0x00000000fffffffe),
+    ] {
+        unsafe {
+            assert_one(
+                [(x(0), 0x1234567812345678), (x(1), a), (x(2), b)],
+                Xult32 {
+                    operands: BinaryOperands {
+                        dst: x(0),
+                        src1: x(1),
+                        src2: x(2),
+                    },
+                },
+                x(0),
+                expected,
+            );
+        }
+    }
+}
+
+#[test]
+fn xulteq32() {
+    for (expected, a, b) in [
+        (1u64, 0u64, 0u64),
+        (0, 1, 0),
+        (1, 0, 1),
+        (0, 0x00000000ffffffff, 0xfffffffffffffffe),
+        (1, 0xfffffffffffffffe, 0x00000000ffffffff),
+        (1, 0x00000000ffffffff, 0xffffffffffffffff),
+        (1, 0xfffffffffffffffe, 0x00000000fffffffe),
+    ] {
+        unsafe {
+            assert_one(
+                [(x(0), 0x1234567812345678), (x(1), a), (x(2), b)],
+                Xulteq32 {
+                    operands: BinaryOperands {
+                        dst: x(0),
+                        src1: x(1),
+                        src2: x(2),
+                    },
+                },
+                x(0),
+                expected,
+            );
+        }
+    }
+}
+
+#[test]
+fn load32_u() {
+    let a = UnsafeCell::new(11u32);
+    let b = UnsafeCell::new(22u32);
+    let c = UnsafeCell::new(33u32);
+    let d = UnsafeCell::new(i32::MIN as u32);
+
+    for (expected, addr) in [
+        (11, a.get()),
+        (22, b.get()),
+        (33, c.get()),
+        (i32::MIN as u32 as u64, d.get()),
+    ] {
+        unsafe {
+            assert_one(
+                [
+                    (x(0), Val::from(0x1234567812345678u64)),
+                    (x(1), Val::from(addr.cast::<u8>())),
+                ],
+                Load32U {
+                    dst: x(0),
+                    ptr: x(1),
+                },
+                x(0),
+                expected,
+            );
+        }
+    }
+}
+
+#[test]
+fn load32_s() {
+    let a = UnsafeCell::new(11u32);
+    let b = UnsafeCell::new(22u32);
+    let c = UnsafeCell::new(33u32);
+    let d = UnsafeCell::new(-1i32 as u32);
+
+    for (expected, addr) in [
+        (11, a.get()),
+        (22, b.get()),
+        (33, c.get()),
+        (-1i64 as u64, d.get()),
+    ] {
+        unsafe {
+            assert_one(
+                [
+                    (x(0), Val::from(0x1234567812345678u64)),
+                    (x(1), Val::from(addr.cast::<u8>())),
+                ],
+                Load32S {
+                    dst: x(0),
+                    ptr: x(1),
+                },
+                x(0),
+                expected,
+            );
+        }
+    }
+}
+
+#[test]
+fn load64() {
+    let a = UnsafeCell::new(11u64);
+    let b = UnsafeCell::new(22u64);
+    let c = UnsafeCell::new(33u64);
+    let d = UnsafeCell::new(-1i64 as u64);
+
+    for (expected, addr) in [
+        (11, a.get()),
+        (22, b.get()),
+        (33, c.get()),
+        (-1i64 as u64, d.get()),
+    ] {
+        unsafe {
+            assert_one(
+                [
+                    (x(0), Val::from(0x1234567812345678u64)),
+                    (x(1), Val::from(addr)),
+                ],
+                Load64 {
+                    dst: x(0),
+                    ptr: x(1),
+                },
+                x(0),
+                expected,
+            );
+        }
+    }
+}
+
+#[test]
+fn load32_u_offset8() {
+    let a = UnsafeCell::new([11u32, 22]);
+    let b = UnsafeCell::new([33u32, 44]);
+    let c = UnsafeCell::new([55u32, 66]);
+    let d = UnsafeCell::new([i32::MIN as u32, i32::MAX as u32]);
+
+    for (expected, addr, offset) in [
+        (11, a.get(), 0),
+        (22, a.get(), 4),
+        (33, b.get(), 0),
+        (44, b.get(), 4),
+        (55, c.get(), 0),
+        (66, c.get(), 4),
+        (i32::MIN as u32 as u64, d.get(), 0),
+        (i32::MAX as u32 as u64, d.get(), 4),
+    ] {
+        unsafe {
+            assert_one(
+                [
+                    (x(0), Val::from(0x1234567812345678u64)),
+                    (x(1), Val::from(addr.cast::<u8>())),
+                ],
+                Load32UOffset8 {
+                    dst: x(0),
+                    ptr: x(1),
+                    offset,
+                },
+                x(0),
+                expected,
+            );
+        }
+    }
+}
+
+#[test]
+fn load32_s_offset8() {
+    let a = UnsafeCell::new([11u32, 22]);
+    let b = UnsafeCell::new([33u32, 44]);
+    let c = UnsafeCell::new([55u32, 66]);
+    let d = UnsafeCell::new([-1i32 as u32, i32::MAX as u32]);
+
+    for (expected, addr, offset) in [
+        (11, a.get(), 0),
+        (22, a.get(), 4),
+        (33, b.get(), 0),
+        (44, b.get(), 4),
+        (55, c.get(), 0),
+        (55, unsafe { c.get().byte_add(4) }, -4),
+        (66, c.get(), 4),
+        (-1i64 as u64, d.get(), 0),
+        (i32::MAX as u32 as u64, d.get(), 4),
+    ] {
+        unsafe {
+            assert_one(
+                [
+                    (x(0), Val::from(0x1234567812345678u64)),
+                    (x(1), Val::from(addr.cast::<u8>())),
+                ],
+                Load32SOffset8 {
+                    dst: x(0),
+                    ptr: x(1),
+                    offset,
+                },
+                x(0),
+                expected,
+            );
+        }
+    }
+}
+
+#[test]
+fn load64_offset8() {
+    let a = UnsafeCell::new([11u64, 22]);
+    let b = UnsafeCell::new([33u64, 44]);
+    let c = UnsafeCell::new([55u64, 66]);
+    let d = UnsafeCell::new([-1i64 as u64, i64::MAX as u64]);
+
+    for (expected, addr, offset) in [
+        (11, a.get(), 0),
+        (22, a.get(), 8),
+        (33, b.get(), 0),
+        (44, b.get(), 8),
+        (55, c.get(), 0),
+        (66, c.get(), 8),
+        (-1i64 as u64, d.get(), 0),
+        (i64::MAX as u64, d.get(), 8),
+    ] {
+        unsafe {
+            assert_one(
+                [
+                    (x(0), Val::from(0x1234567812345678u64)),
+                    (x(1), Val::from(addr)),
+                ],
+                Load64Offset8 {
+                    dst: x(0),
+                    ptr: x(1),
+                    offset,
+                },
+                x(0),
+                expected,
+            );
+        }
+    }
+}
+
+#[test]
+fn load32_u_offset64() {
+    let a = UnsafeCell::new([11u32, 22]);
+    let b = UnsafeCell::new([33u32, 44]);
+    let c = UnsafeCell::new([55u32, 66]);
+    let d = UnsafeCell::new([i32::MIN as u32, i32::MAX as u32]);
+
+    for (expected, addr, offset) in [
+        (11, a.get(), 0),
+        (22, a.get(), 4),
+        (33, b.get(), 0),
+        (44, b.get(), 4),
+        (55, c.get(), 0),
+        (66, c.get(), 4),
+        (i32::MIN as u32 as u64, d.get(), 0),
+        (i32::MAX as u32 as u64, d.get(), 4),
+    ] {
+        unsafe {
+            assert_one(
+                [
+                    (x(0), Val::from(0x1234567812345678u64)),
+                    (x(1), Val::from(addr.cast::<u8>())),
+                ],
+                Load32UOffset64 {
+                    dst: x(0),
+                    ptr: x(1),
+                    offset,
+                },
+                x(0),
+                expected,
+            );
+        }
+    }
+}
+
+#[test]
+fn load32_s_offset64() {
+    let a = UnsafeCell::new([11u32, 22]);
+    let b = UnsafeCell::new([33u32, 44]);
+    let c = UnsafeCell::new([55u32, 66]);
+    let d = UnsafeCell::new([-1i32 as u32, i32::MAX as u32]);
+
+    for (expected, addr, offset) in [
+        (11, a.get(), 0),
+        (22, a.get(), 4),
+        (33, b.get(), 0),
+        (44, b.get(), 4),
+        (55, c.get(), 0),
+        (55, unsafe { c.get().byte_add(4) }, -4),
+        (66, c.get(), 4),
+        (-1i64 as u64, d.get(), 0),
+        (i32::MAX as u32 as u64, d.get(), 4),
+    ] {
+        unsafe {
+            assert_one(
+                [
+                    (x(0), Val::from(0x1234567812345678u64)),
+                    (x(1), Val::from(addr.cast::<u8>())),
+                ],
+                Load32SOffset64 {
+                    dst: x(0),
+                    ptr: x(1),
+                    offset,
+                },
+                x(0),
+                expected,
+            );
+        }
+    }
+}
+
+#[test]
+fn load64_offset64() {
+    let a = UnsafeCell::new([11u64, 22]);
+    let b = UnsafeCell::new([33u64, 44]);
+    let c = UnsafeCell::new([55u64, 66]);
+    let d = UnsafeCell::new([-1i64 as u64, i64::MAX as u64]);
+
+    for (expected, addr, offset) in [
+        (11, a.get(), 0),
+        (22, a.get(), 8),
+        (33, b.get(), 0),
+        (44, b.get(), 8),
+        (55, c.get(), 0),
+        (66, c.get(), 8),
+        (-1i64 as u64, d.get(), 0),
+        (i64::MAX as u64, d.get(), 8),
+    ] {
+        unsafe {
+            assert_one(
+                [
+                    (x(0), Val::from(0x1234567812345678u64)),
+                    (x(1), Val::from(addr)),
+                ],
+                Load64Offset64 {
+                    dst: x(0),
+                    ptr: x(1),
+                    offset,
+                },
+                x(0),
+                expected,
+            );
+        }
+    }
+}
+
+#[test]
+fn store32() {
+    let a = UnsafeCell::new([0x12u8, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78]);
+    let b = UnsafeCell::new([0x12u8, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78]);
+    let c = UnsafeCell::new([0x12u8, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78]);
+
+    unsafe {
+        for (val, addr) in [
+            (0x11111111u32, a.get()),
+            (0x22222222, b.get().byte_add(4)),
+            (0x33333333, c.get().byte_add(2)),
+        ] {
+            let val = val as u64;
+            assert_one(
+                [(x(0), Val::from(addr)), (x(1), Val::from(val))],
+                Store32 {
+                    ptr: x(0),
+                    src: x(1),
+                },
+                x(1),
+                val,
+            );
+        }
+    }
+
+    let a = u64::from_be_bytes(a.into_inner());
+    let expected = 0x1111111112345678u64;
+    eprintln!("expected(a) = {expected:#018x}");
+    eprintln!("actual(a)   = {a:#018x}");
+    assert_eq!(a, expected);
+
+    let b = u64::from_be_bytes(b.into_inner());
+    let expected = 0x1234567822222222u64;
+    eprintln!("expected(b) = {expected:#018x}");
+    eprintln!("actual(b)   = {b:#018x}");
+    assert_eq!(b, expected);
+
+    let c = u64::from_be_bytes(c.into_inner());
+    let expected = 0x1234333333335678u64;
+    eprintln!("expected(c) = {expected:#018x}");
+    eprintln!("actual(c)   = {c:#018x}");
+    assert_eq!(c, expected);
+}
+
+#[test]
+fn store64() {
+    let a = UnsafeCell::new(0x1234567812345678);
+    let b = UnsafeCell::new(0x1234567812345678);
+    let c = UnsafeCell::new(0x1234567812345678);
+
+    unsafe {
+        for (val, addr) in [
+            (0x1111111111111111u64, a.get()),
+            (0x2222222222222222, b.get()),
+            (0x3333333333333333, c.get()),
+        ] {
+            assert_one(
+                [(x(0), Val::from(addr)), (x(1), Val::from(val))],
+                Store64 {
+                    ptr: x(0),
+                    src: x(1),
+                },
+                x(1),
+                val,
+            );
+        }
+    }
+
+    let a = a.into_inner();
+    let expected = 0x1111111111111111u64;
+    eprintln!("expected(a) = {expected:#018x}");
+    eprintln!("actual(a)   = {a:#018x}");
+    assert_eq!(a, expected);
+
+    let b = b.into_inner();
+    let expected = 0x2222222222222222u64;
+    eprintln!("expected(b) = {expected:#018x}");
+    eprintln!("actual(b)   = {b:#018x}");
+    assert_eq!(b, expected);
+
+    let c = c.into_inner();
+    let expected = 0x3333333333333333u64;
+    eprintln!("expected(c) = {expected:#018x}");
+    eprintln!("actual(c)   = {c:#018x}");
+    assert_eq!(c, expected);
+}
+
+#[test]
+fn store32_offset8() {
+    let a = UnsafeCell::new([0x12u8, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78]);
+    let b = UnsafeCell::new([0x12u8, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78]);
+    let c = UnsafeCell::new([0x12u8, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78]);
+
+    unsafe {
+        for (val, addr, offset) in [
+            (0x11111111u32, a.get(), 0),
+            (0x22222222, b.get(), 4),
+            (0x33333333, c.get(), 2),
+        ] {
+            let val = val as u64;
+            assert_one(
+                [(x(0), Val::from(addr)), (x(1), Val::from(val))],
+                Store32SOffset8 {
+                    ptr: x(0),
+                    src: x(1),
+                    offset,
+                },
+                x(1),
+                val,
+            );
+        }
+    }
+
+    let a = u64::from_be_bytes(a.into_inner());
+    let expected = 0x1111111112345678u64;
+    eprintln!("expected(a) = {expected:#018x}");
+    eprintln!("actual(a)   = {a:#018x}");
+    assert_eq!(a, expected);
+
+    let b = u64::from_be_bytes(b.into_inner());
+    let expected = 0x1234567822222222u64;
+    eprintln!("expected(b) = {expected:#018x}");
+    eprintln!("actual(b)   = {b:#018x}");
+    assert_eq!(b, expected);
+
+    let c = u64::from_be_bytes(c.into_inner());
+    let expected = 0x1234333333335678u64;
+    eprintln!("expected(c) = {expected:#018x}");
+    eprintln!("actual(c)   = {c:#018x}");
+    assert_eq!(c, expected);
+}
+
+#[test]
+fn store64_offset8() {
+    let a = UnsafeCell::new([0x1234567812345678, 0x1234567812345678, 0x1234567812345678]);
+
+    unsafe {
+        for (val, addr, offset) in [
+            (0x1111111111111111u64, a.get(), 0),
+            (0x2222222222222222, a.get(), 8),
+            (0x3333333333333333, a.get(), 16),
+        ] {
+            assert_one(
+                [(x(0), Val::from(addr)), (x(1), Val::from(val))],
+                Store64Offset8 {
+                    ptr: x(0),
+                    src: x(1),
+                    offset,
+                },
+                x(1),
+                val,
+            );
+        }
+    }
+
+    let [a, b, c] = a.into_inner();
+
+    let expected = 0x1111111111111111u64;
+    eprintln!("expected(a) = {expected:#018x}");
+    eprintln!("actual(a)   = {a:#018x}");
+    assert_eq!(a, expected);
+
+    let expected = 0x2222222222222222u64;
+    eprintln!("expected(b) = {expected:#018x}");
+    eprintln!("actual(b)   = {b:#018x}");
+    assert_eq!(b, expected);
+
+    let expected = 0x3333333333333333u64;
+    eprintln!("expected(c) = {expected:#018x}");
+    eprintln!("actual(c)   = {c:#018x}");
+    assert_eq!(c, expected);
+}
+
+#[test]
+fn store32_offset64() {
+    let a = UnsafeCell::new([0x12u8, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78]);
+    let b = UnsafeCell::new([0x12u8, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78]);
+    let c = UnsafeCell::new([0x12u8, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78]);
+
+    unsafe {
+        for (val, addr, offset) in [
+            (0x11111111u32, a.get(), 0),
+            (0x22222222, b.get(), 4),
+            (0x33333333, c.get(), 2),
+        ] {
+            let val = val as u64;
+            assert_one(
+                [(x(0), Val::from(addr)), (x(1), Val::from(val))],
+                Store32SOffset64 {
+                    ptr: x(0),
+                    src: x(1),
+                    offset,
+                },
+                x(1),
+                val,
+            );
+        }
+    }
+
+    let a = u64::from_be_bytes(a.into_inner());
+    let expected = 0x1111111112345678u64;
+    eprintln!("expected(a) = {expected:#018x}");
+    eprintln!("actual(a)   = {a:#018x}");
+    assert_eq!(a, expected);
+
+    let b = u64::from_be_bytes(b.into_inner());
+    let expected = 0x1234567822222222u64;
+    eprintln!("expected(b) = {expected:#018x}");
+    eprintln!("actual(b)   = {b:#018x}");
+    assert_eq!(b, expected);
+
+    let c = u64::from_be_bytes(c.into_inner());
+    let expected = 0x1234333333335678u64;
+    eprintln!("expected(c) = {expected:#018x}");
+    eprintln!("actual(c)   = {c:#018x}");
+    assert_eq!(c, expected);
+}
+
+#[test]
+fn store64_offset64() {
+    let a = UnsafeCell::new([0x1234567812345678, 0x1234567812345678, 0x1234567812345678]);
+
+    unsafe {
+        for (val, addr, offset) in [
+            (0x1111111111111111u64, a.get(), 0),
+            (0x2222222222222222, a.get(), 8),
+            (0x3333333333333333, a.get(), 16),
+        ] {
+            assert_one(
+                [(x(0), Val::from(addr)), (x(1), Val::from(val))],
+                Store64Offset64 {
+                    ptr: x(0),
+                    src: x(1),
+                    offset,
+                },
+                x(1),
+                val,
+            );
+        }
+    }
+
+    let [a, b, c] = a.into_inner();
+
+    let expected = 0x1111111111111111u64;
+    eprintln!("expected(a) = {expected:#018x}");
+    eprintln!("actual(a)   = {a:#018x}");
+    assert_eq!(a, expected);
+
+    let expected = 0x2222222222222222u64;
+    eprintln!("expected(b) = {expected:#018x}");
+    eprintln!("actual(b)   = {b:#018x}");
+    assert_eq!(b, expected);
+
+    let expected = 0x3333333333333333u64;
+    eprintln!("expected(c) = {expected:#018x}");
+    eprintln!("actual(c)   = {c:#018x}");
+    assert_eq!(c, expected);
+}
+
+#[test]
+fn bitcast_int_from_float_32() {
+    for val in [
+        0.0,
+        1.0,
+        9.87654321,
+        f32::MAX,
+        f32::MIN,
+        f32::NAN,
+        f32::INFINITY,
+        f32::NEG_INFINITY,
+        f32::EPSILON,
+        f32::MIN_POSITIVE,
+    ] {
+        unsafe {
+            assert_one(
+                [(f(0), val)],
+                BitcastIntFromFloat32 {
+                    dst: x(0),
+                    src: f(0),
+                },
+                x(0),
+                val.to_bits() as u64,
+            );
+        }
+    }
+}
+
+#[test]
+fn bitcast_int_from_float_64() {
+    for val in [
+        0.0,
+        1.0,
+        9.87654321,
+        f64::MAX,
+        f64::MIN,
+        f64::NAN,
+        f64::INFINITY,
+        f64::NEG_INFINITY,
+        f64::EPSILON,
+        f64::MIN_POSITIVE,
+    ] {
+        unsafe {
+            assert_one(
+                [(f(0), val)],
+                BitcastIntFromFloat64 {
+                    dst: x(0),
+                    src: f(0),
+                },
+                x(0),
+                val.to_bits(),
+            );
+        }
+    }
+}
+
+#[test]
+fn bitcast_float_from_int_32() {
+    for val in [
+        0.0,
+        1.0,
+        9.87654321,
+        f32::MAX,
+        f32::MIN,
+        f32::NAN,
+        f32::INFINITY,
+        f32::NEG_INFINITY,
+        f32::EPSILON,
+        f32::MIN_POSITIVE,
+    ] {
+        let val = val.to_bits() as u64;
+        unsafe {
+            assert_one(
+                [(x(0), val)],
+                BitcastFloatFromInt32 {
+                    dst: f(0),
+                    src: x(0),
+                },
+                f(0),
+                val,
+            );
+        }
+    }
+}
+
+#[test]
+fn bitcast_float_from_int_64() {
+    for val in [
+        0.0,
+        1.0,
+        9.87654321,
+        f64::MAX,
+        f64::MIN,
+        f64::NAN,
+        f64::INFINITY,
+        f64::NEG_INFINITY,
+        f64::EPSILON,
+        f64::MIN_POSITIVE,
+    ] {
+        let val = val.to_bits();
+        unsafe {
+            assert_one(
+                [(x(0), val)],
+                BitcastFloatFromInt64 {
+                    dst: f(0),
+                    src: x(0),
+                },
+                f(0),
+                val,
+            );
+        }
+    }
+}
+
+#[test]
+fn trap() {
+    let mut vm = Vm::new();
+    let dst = XReg::new(0).unwrap();
+
+    unsafe {
+        run(
+            &mut vm,
+            &[
+                Op::Xconst16(Xconst16 { dst, imm: 1 }),
+                Op::ExtendedOp(ExtendedOp::Trap(Trap {})),
+                Op::Xconst16(Xconst16 { dst, imm: 2 }),
+                Op::Ret(Ret {}),
+            ],
+        )
+        .unwrap_err();
+    }
+
+    // `dst` should not have been written to the second time.
+    assert_eq!(vm.state()[dst].get_u32(), 1);
+}
diff --git a/pulley/tests/all/main.rs b/pulley/tests/all/main.rs
new file mode 100644
index 000000000000..38e113a178b6
--- /dev/null
+++ b/pulley/tests/all/main.rs
@@ -0,0 +1,5 @@
+#[cfg(feature = "disas")]
+mod disas;
+
+#[cfg(feature = "interp")]
+mod interp;
diff --git a/scripts/publish.rs b/scripts/publish.rs
index 598dd40c0901..c72a1cb600e6 100644
--- a/scripts/publish.rs
+++ b/scripts/publish.rs
@@ -11,12 +11,15 @@ use std::collections::HashMap;
 use std::env;
 use std::fs;
 use std::path::{Path, PathBuf};
-use std::process::{Command, Stdio};
+use std::process::{Command, ExitStatus, Output, Stdio};
 use std::thread;
 use std::time::Duration;
 
 // note that this list must be topologically sorted by dependencies
 const CRATES_TO_PUBLISH: &[&str] = &[
+    // pulley
+    "cranelift-bitset",
+    "pulley-interpreter",
     // cranelift
     "cranelift-isle",
     "cranelift-entity",
@@ -35,9 +38,9 @@ const CRATES_TO_PUBLISH: &[&str] = &[
     "cranelift-native",
     "cranelift-object",
     "cranelift-interpreter",
-    "cranelift",
     "wasmtime-jit-icache-coherence",
     "cranelift-jit",
+    "cranelift",
     // wiggle
     "wiggle-generate",
     "wiggle-macro",
@@ -46,6 +49,7 @@ const CRATES_TO_PUBLISH: &[&str] = &[
     // wasmtime
     "wasmtime-asm-macros",
     "wasmtime-versioned-export-macros",
+    "wasmtime-slab",
     "wasmtime-component-util",
     "wasmtime-wit-bindgen",
     "wasmtime-component-macro",
@@ -53,10 +57,7 @@ const CRATES_TO_PUBLISH: &[&str] = &[
     "wasmtime-fiber",
     "wasmtime-environ",
     "wasmtime-wmemcheck",
-    "wasmtime-runtime",
-    "wasmtime-cranelift-shared",
     "wasmtime-cranelift",
-    "wasmtime-jit",
     "wasmtime-cache",
     "winch-codegen",
     "wasmtime-winch",
@@ -64,14 +65,16 @@ const CRATES_TO_PUBLISH: &[&str] = &[
     // wasi-common/wiggle
     "wiggle",
     "wasi-common",
-    "wasi-cap-std-sync",
-    "wasi-tokio",
     // other misc wasmtime crates
     "wasmtime-wasi",
     "wasmtime-wasi-http",
     "wasmtime-wasi-nn",
+    "wasmtime-wasi-runtime-config",
+    "wasmtime-wasi-keyvalue",
     "wasmtime-wasi-threads",
     "wasmtime-wast",
+    "wasmtime-c-api-macros",
+    "wasmtime-c-api-impl",
     "wasmtime-cli-flags",
     "wasmtime-explorer",
     "wasmtime-cli",
@@ -82,20 +85,20 @@ const CRATES_TO_PUBLISH: &[&str] = &[
 // releases since everything not mentioned here is just an organizational detail
 // that no one else should rely on.
 const PUBLIC_CRATES: &[&str] = &[
-    // just here to appease the script because these are submodules of this
-    // repository.
-    "witx",
     // these are actually public crates which we cannot break the API of in
     // patch releases.
     "wasmtime",
     "wasmtime-wasi",
     "wasmtime-wasi-nn",
+    "wasmtime-wasi-runtime-config",
+    "wasmtime-wasi-keyvalue",
     "wasmtime-wasi-threads",
     "wasmtime-cli",
     // all cranelift crates are considered "public" in that they can't
     // have breaking API changes in patch releases
     "cranelift-entity",
     "cranelift-bforest",
+    "cranelift-bitset",
     "cranelift-codegen-shared",
     "cranelift-codegen-meta",
     "cranelift-egraph",
@@ -138,6 +141,7 @@ fn main() {
     crates.push(root);
     find_crates("crates".as_ref(), &ws, &mut crates);
     find_crates("cranelift".as_ref(), &ws, &mut crates);
+    find_crates("pulley".as_ref(), &ws, &mut crates);
     find_crates("winch".as_ref(), &ws, &mut crates);
 
     let pos = CRATES_TO_PUBLISH
@@ -155,11 +159,7 @@ fn main() {
             // update C API version in wasmtime.h
             update_capi_version();
             // update the lock file
-            assert!(Command::new("cargo")
-                .arg("fetch")
-                .status()
-                .unwrap()
-                .success());
+            run_cmd(Command::new("cargo").arg("fetch"));
         }
 
         "publish" => {
@@ -203,6 +203,32 @@ fn main() {
     }
 }
 
+fn cmd_output(cmd: &mut Command) -> Output {
+    eprintln!("Running: `{:?}`", cmd);
+    match cmd.output() {
+        Ok(o) => o,
+        Err(e) => panic!("Failed to run `{:?}`: {}", cmd, e),
+    }
+}
+
+fn cmd_status(cmd: &mut Command) -> ExitStatus {
+    eprintln!("Running: `{:?}`", cmd);
+    match cmd.status() {
+        Ok(s) => s,
+        Err(e) => panic!("Failed to run `{:?}`: {}", cmd, e),
+    }
+}
+
+fn run_cmd(cmd: &mut Command) {
+    let status = cmd_status(cmd);
+    assert!(
+        status.success(),
+        "Command `{:?}` exited with failure status: {}",
+        cmd,
+        status
+    );
+}
+
 fn find_crates(dir: &Path, ws: &Workspace, dst: &mut Vec<Crate>) {
     if dir.join("Cargo.toml").exists() {
         let krate = read_crate(Some(ws), &dir.join("Cargo.toml"));
@@ -253,9 +279,6 @@ fn read_crate(ws: Option<&Workspace>, manifest: &Path) -> Crate {
     }
     let name = name.unwrap();
     let version = version.unwrap();
-    if ["witx", "witx-cli"].contains(&&name[..]) {
-        publish = false;
-    }
     Crate {
         manifest: manifest.to_path_buf(),
         name,
@@ -405,10 +428,9 @@ fn publish(krate: &Crate) -> bool {
 
     // First make sure the crate isn't already published at this version. This
     // script may be re-run and there's no need to re-attempt previous work.
-    let output = Command::new("curl")
-        .arg(&format!("https://crates.io/api/v1/crates/{}", krate.name))
-        .output()
-        .expect("failed to invoke `curl`");
+    let output = cmd_output(
+        Command::new("curl").arg(&format!("https://crates.io/api/v1/crates/{}", krate.name)),
+    );
     if output.status.success()
         && String::from_utf8_lossy(&output.stdout)
             .contains(&format!("\"newest_version\":\"{}\"", krate.version))
@@ -420,12 +442,12 @@ fn publish(krate: &Crate) -> bool {
         return true;
     }
 
-    let status = Command::new("cargo")
-        .arg("publish")
-        .current_dir(krate.manifest.parent().unwrap())
-        .arg("--no-verify")
-        .status()
-        .expect("failed to run cargo");
+    let status = cmd_status(
+        Command::new("cargo")
+            .arg("publish")
+            .current_dir(krate.manifest.parent().unwrap())
+            .arg("--no-verify"),
+    );
     if !status.success() {
         println!("FAIL: failed to publish `{}`: {}", krate.name, status);
         return false;
@@ -434,13 +456,10 @@ fn publish(krate: &Crate) -> bool {
     // After we've published then make sure that the `wasmtime-publish` group is
     // added to this crate for future publications. If it's already present
     // though we can skip the `cargo owner` modification.
-    let output = Command::new("curl")
-        .arg(&format!(
-            "https://crates.io/api/v1/crates/{}/owners",
-            krate.name
-        ))
-        .output()
-        .expect("failed to invoke `curl`");
+    let output = cmd_output(Command::new("curl").arg(&format!(
+        "https://crates.io/api/v1/crates/{}/owners",
+        krate.name
+    )));
     if output.status.success()
         && String::from_utf8_lossy(&output.stdout).contains("wasmtime-publish")
     {
@@ -454,19 +473,13 @@ fn publish(krate: &Crate) -> bool {
     // Note that the status is ignored here. This fails most of the time because
     // the owner is already set and present, so we only want to add this to
     // crates which haven't previously been published.
-    let status = Command::new("cargo")
-        .arg("owner")
-        .arg("-a")
-        .arg("github:bytecodealliance:wasmtime-publish")
-        .arg(&krate.name)
-        .status()
-        .expect("failed to run cargo");
-    if !status.success() {
-        panic!(
-            "FAIL: failed to add wasmtime-publish as owner `{}`: {}",
-            krate.name, status
-        );
-    }
+    run_cmd(
+        Command::new("cargo")
+            .arg("owner")
+            .arg("-a")
+            .arg("github:bytecodealliance:wasmtime-publish")
+            .arg(&krate.name),
+    );
 
     true
 }
@@ -479,26 +492,23 @@ fn publish(krate: &Crate) -> bool {
 fn verify(crates: &[Crate]) {
     verify_capi();
 
-    drop(fs::remove_dir_all(".cargo"));
-    drop(fs::remove_dir_all("vendor"));
-    let vendor = Command::new("cargo")
-        .arg("vendor")
-        .stderr(Stdio::inherit())
-        .output()
-        .unwrap();
+    if Path::new(".cargo").exists() {
+        panic!(
+            "`.cargo` already exists on the file system, remove it and then run the script again"
+        );
+    }
+    if Path::new("vendor").exists() {
+        panic!(
+            "`vendor` already exists on the file system, remove it and then run the script again"
+        );
+    }
+
+    let vendor = cmd_output(Command::new("cargo").arg("vendor").stderr(Stdio::inherit()));
     assert!(vendor.status.success());
 
     fs::create_dir_all(".cargo").unwrap();
     fs::write(".cargo/config.toml", vendor.stdout).unwrap();
 
-    // Vendor witx which wasn't vendored because it's a path dependency, but
-    // it'll need to be in our directory registry for crates that depend on it.
-    let witx = crates
-        .iter()
-        .find(|c| c.name == "witx" && c.manifest.iter().any(|p| p == "wasi-common"))
-        .unwrap();
-    verify_and_vendor(&witx);
-
     for krate in crates {
         if !krate.publish {
             continue;
@@ -512,21 +522,19 @@ fn verify(crates: &[Crate]) {
             .arg("--manifest-path")
             .arg(&krate.manifest)
             .env("CARGO_TARGET_DIR", "./target");
-        if krate.name == "witx" || krate.name.contains("wasi-nn") {
+        if krate.name.contains("wasi-nn") {
             cmd.arg("--no-verify");
         }
-        let status = cmd.status().unwrap();
-        assert!(status.success(), "failed to verify {:?}", &krate.manifest);
-        let tar = Command::new("tar")
-            .arg("xf")
-            .arg(format!(
-                "../target/package/{}-{}.crate",
-                krate.name, krate.version
-            ))
-            .current_dir("./vendor")
-            .status()
-            .unwrap();
-        assert!(tar.success());
+        run_cmd(&mut cmd);
+        run_cmd(
+            Command::new("tar")
+                .arg("xf")
+                .arg(format!(
+                    "../target/package/{}-{}.crate",
+                    krate.name, krate.version
+                ))
+                .current_dir("./vendor"),
+        );
         fs::write(
             format!(
                 "./vendor/{}-{}/.cargo-checksum.json",
diff --git a/src/bin/wasmtime.rs b/src/bin/wasmtime.rs
index 46868b3aca05..fb64c0d76ec4 100644
--- a/src/bin/wasmtime.rs
+++ b/src/bin/wasmtime.rs
@@ -5,16 +5,12 @@
 
 use anyhow::Result;
 use clap::Parser;
-#[cfg(feature = "serve")]
-use wasmtime_cli::commands::ServeCommand;
-use wasmtime_cli::commands::{
-    CompileCommand, ConfigCommand, ExploreCommand, RunCommand, SettingsCommand, WastCommand,
-};
 
 /// Wasmtime WebAssembly Runtime
-#[derive(Parser)]
-#[clap(
-    version,
+#[derive(Parser, PartialEq)]
+#[command(
+    name = "wasmtime",
+    version = version(),
     after_help = "If a subcommand is not provided, the `run` subcommand will be used.\n\
                   \n\
                   Usage examples:\n\
@@ -29,7 +25,7 @@ use wasmtime_cli::commands::{
                   \n\
                   Invoking a specific function (e.g. `add`) in a WebAssembly module:\n\
                   \n  \
-                  wasmtime example.wasm --invoke add 1 2\n",
+                  wasmtime --invoke add example.wasm 1 2\n",
 
     // This option enables the pattern below where we ask clap to parse twice
     // sorta: once where it's trying to find a subcommand and once assuming
@@ -39,50 +35,89 @@ use wasmtime_cli::commands::{
     args_conflicts_with_subcommands = true
 )]
 struct Wasmtime {
-    #[clap(subcommand)]
+    #[cfg(not(feature = "run"))]
+    #[command(subcommand)]
+    subcommand: Subcommand,
+
+    #[cfg(feature = "run")]
+    #[command(subcommand)]
     subcommand: Option<Subcommand>,
-    #[clap(flatten)]
-    run: RunCommand,
+    #[command(flatten)]
+    #[cfg(feature = "run")]
+    run: wasmtime_cli::commands::RunCommand,
+}
+
+/// If WASMTIME_VERSION_INFO is set, use it, otherwise use CARGO_PKG_VERSION.
+fn version() -> &'static str {
+    option_env!("WASMTIME_VERSION_INFO").unwrap_or(env!("CARGO_PKG_VERSION"))
 }
 
-#[derive(Parser)]
+#[derive(Parser, PartialEq)]
 enum Subcommand {
+    /// Runs a WebAssembly module
+    #[cfg(feature = "run")]
+    Run(wasmtime_cli::commands::RunCommand),
+
     /// Controls Wasmtime configuration settings
-    Config(ConfigCommand),
+    #[cfg(feature = "cache")]
+    Config(wasmtime_cli::commands::ConfigCommand),
+
     /// Compiles a WebAssembly module.
-    Compile(CompileCommand),
+    #[cfg(feature = "compile")]
+    Compile(wasmtime_cli::commands::CompileCommand),
+
     /// Explore the compilation of a WebAssembly module to native code.
-    Explore(ExploreCommand),
-    /// Runs a WebAssembly module
-    Run(RunCommand),
+    #[cfg(feature = "explore")]
+    Explore(wasmtime_cli::commands::ExploreCommand),
+
     /// Serves requests from a wasi-http proxy component.
     #[cfg(feature = "serve")]
-    Serve(ServeCommand),
+    Serve(wasmtime_cli::commands::ServeCommand),
+
     /// Displays available Cranelift settings for a target.
-    Settings(SettingsCommand),
+    #[cfg(feature = "cranelift")]
+    Settings(wasmtime_cli::commands::SettingsCommand),
+
     /// Runs a WebAssembly test script file
-    Wast(WastCommand),
+    #[cfg(feature = "wast")]
+    Wast(wasmtime_cli::commands::WastCommand),
 }
 
 impl Wasmtime {
     /// Executes the command.
     pub fn execute(self) -> Result<()> {
+        #[cfg(feature = "run")]
         let subcommand = self.subcommand.unwrap_or(Subcommand::Run(self.run));
+        #[cfg(not(feature = "run"))]
+        let subcommand = self.subcommand;
+
         match subcommand {
+            #[cfg(feature = "run")]
+            Subcommand::Run(c) => c.execute(),
+
+            #[cfg(feature = "cache")]
             Subcommand::Config(c) => c.execute(),
+
+            #[cfg(feature = "compile")]
             Subcommand::Compile(c) => c.execute(),
+
+            #[cfg(feature = "explore")]
             Subcommand::Explore(c) => c.execute(),
-            Subcommand::Run(c) => c.execute(),
+
             #[cfg(feature = "serve")]
             Subcommand::Serve(c) => c.execute(),
+
+            #[cfg(feature = "cranelift")]
             Subcommand::Settings(c) => c.execute(),
+
+            #[cfg(feature = "wast")]
             Subcommand::Wast(c) => c.execute(),
         }
     }
 }
 
 fn main() -> Result<()> {
-    Wasmtime::parse().execute()
+    return Wasmtime::parse().execute();
 }
 
 #[test]
diff --git a/src/commands.rs b/src/commands.rs
index ae46a2264e17..bd498d1734b0 100644
--- a/src/commands.rs
+++ b/src/commands.rs
@@ -1,16 +1,36 @@
 //! The module for the Wasmtime CLI commands.
 
-mod compile;
-mod config;
-mod explore;
+#[cfg(feature = "run")]
 mod run;
-mod settings;
-mod wast;
+#[cfg(feature = "run")]
+pub use self::run::*;
 
 #[cfg(feature = "serve")]
 mod serve;
-
-pub use self::{compile::*, config::*, explore::*, run::*, settings::*, wast::*};
-
 #[cfg(feature = "serve")]
 pub use self::serve::*;
+
+#[cfg(feature = "explore")]
+mod explore;
+#[cfg(feature = "explore")]
+pub use self::explore::*;
+
+#[cfg(feature = "wast")]
+mod wast;
+#[cfg(feature = "wast")]
+pub use self::wast::*;
+
+#[cfg(feature = "cache")]
+mod config;
+#[cfg(feature = "cache")]
+pub use self::config::*;
+
+#[cfg(feature = "compile")]
+mod compile;
+#[cfg(feature = "compile")]
+pub use self::compile::*;
+
+#[cfg(feature = "cranelift")]
+mod settings;
+#[cfg(feature = "cranelift")]
+pub use self::settings::*;
diff --git a/src/commands/compile.rs b/src/commands/compile.rs
index a26fee670702..791f44de3863 100644
--- a/src/commands/compile.rs
+++ b/src/commands/compile.rs
@@ -5,7 +5,7 @@ use clap::Parser;
 use once_cell::sync::Lazy;
 use std::fs;
 use std::path::PathBuf;
-use wasmtime::Engine;
+use wasmtime::{CodeBuilder, CodeHint, Engine};
 use wasmtime_cli_flags::CommonOptions;
 
 static AFTER_HELP: Lazy<String> = Lazy::new(|| {
@@ -29,39 +29,39 @@ static AFTER_HELP: Lazy<String> = Lazy::new(|| {
 });
 
 /// Compiles a WebAssembly module.
-#[derive(Parser)]
-#[structopt(
-    name = "compile",
+#[derive(Parser, PartialEq)]
+#[command(
     version,
     after_help = AFTER_HELP.as_str()
 )]
 pub struct CompileCommand {
-    #[clap(flatten)]
-    common: CommonOptions,
+    #[command(flatten)]
+    #[allow(missing_docs)]
+    pub common: CommonOptions,
 
     /// The target triple; default is the host triple
-    #[clap(long, value_name = "TARGET")]
-    target: Option<String>,
+    #[arg(long, value_name = "TARGET")]
+    pub target: Option<String>,
 
-    /// The path of the output compiled module; defaults to <MODULE>.cwasm
-    #[clap(short = 'o', long, value_name = "OUTPUT")]
-    output: Option<PathBuf>,
+    /// The path of the output compiled module; defaults to `<MODULE>.cwasm`
+    #[arg(short = 'o', long, value_name = "OUTPUT")]
+    pub output: Option<PathBuf>,
 
     /// The directory path to write clif files into, one clif file per wasm function.
-    #[clap(long = "emit-clif", value_name = "PATH")]
-    emit_clif: Option<PathBuf>,
+    #[arg(long = "emit-clif", value_name = "PATH")]
+    pub emit_clif: Option<PathBuf>,
 
     /// The path of the WebAssembly to compile
-    #[clap(index = 1, value_name = "MODULE")]
-    module: PathBuf,
+    #[arg(index = 1, value_name = "MODULE")]
+    pub module: PathBuf,
 }
 
 impl CompileCommand {
     /// Executes the command.
     pub fn execute(mut self) -> Result<()> {
-        self.common.init_logging();
+        self.common.init_logging()?;
 
-        let mut config = self.common.config(self.target.as_deref())?;
+        let mut config = self.common.config(self.target.as_deref(), None)?;
 
         if let Some(path) = self.emit_clif {
             if !path.exists() {
@@ -87,7 +87,8 @@ impl CompileCommand {
             );
         }
 
-        let input = wat::parse_file(&self.module).with_context(|| "failed to read input file")?;
+        let mut code = CodeBuilder::new(&engine);
+        code.wasm_binary_or_text_file(&self.module)?;
 
         let output = self.output.take().unwrap_or_else(|| {
             let mut output: PathBuf = self.module.file_name().unwrap().into();
@@ -95,10 +96,14 @@ impl CompileCommand {
             output
         });
 
-        let output_bytes = if wasmparser::Parser::is_component(&input) {
-            engine.precompile_component(&input)?
-        } else {
-            engine.precompile_module(&input)?
+        let output_bytes = match code.hint() {
+            #[cfg(feature = "component-model")]
+            Some(CodeHint::Component) => code.compile_component_serialized()?,
+            #[cfg(not(feature = "component-model"))]
+            Some(CodeHint::Component) => {
+                bail!("component model support was disabled at compile time")
+            }
+            Some(CodeHint::Module) | None => code.compile_module_serialized()?,
         };
         fs::write(&output, output_bytes)
             .with_context(|| format!("failed to write output: {}", output.display()))?;
@@ -197,6 +202,7 @@ mod test {
             "-Dlogging=n",
             "-Ccranelift-has-lse",
             "-Ccranelift-has-pauth",
+            "-Ccranelift-has-fp16",
             "-Ccranelift-sign-return-address",
             "-Ccranelift-sign-return-address-all",
             "-Ccranelift-sign-return-address-with-bkey",
diff --git a/src/commands/config.rs b/src/commands/config.rs
index a3709a47b2e5..d53b8f9a1299 100644
--- a/src/commands/config.rs
+++ b/src/commands/config.rs
@@ -1,23 +1,22 @@
 //! The module that implements the `wasmtime config` command.
 
 use anyhow::Result;
-use clap::Parser;
+use clap::{Parser, Subcommand};
 
 const CONFIG_NEW_AFTER_HELP: &str =
     "If no file path is specified, the system configuration file path will be used.";
 
 /// Controls Wasmtime configuration settings
-#[derive(Parser)]
-#[clap(name = "config")]
+#[derive(Parser, PartialEq)]
 pub struct ConfigCommand {
-    #[clap(subcommand)]
+    #[command(subcommand)]
     subcommand: ConfigSubcommand,
 }
 
-#[derive(clap::Subcommand)]
+#[derive(Subcommand, PartialEq)]
 enum ConfigSubcommand {
     /// Creates a new Wasmtime configuration file
-    #[clap(after_help = CONFIG_NEW_AFTER_HELP)]
+    #[command(after_help = CONFIG_NEW_AFTER_HELP)]
     New(ConfigNewCommand),
 }
 
@@ -31,11 +30,10 @@ impl ConfigCommand {
 }
 
 /// Creates a new Wasmtime configuration file
-#[derive(Parser)]
-#[clap(name = "new", after_help = CONFIG_NEW_AFTER_HELP)]
+#[derive(Parser, PartialEq)]
 pub struct ConfigNewCommand {
     /// The path of the new configuration file
-    #[clap(index = 1, value_name = "FILE_PATH")]
+    #[arg(index = 1, value_name = "FILE_PATH")]
     path: Option<String>,
 }
 
diff --git a/src/commands/explore.rs b/src/commands/explore.rs
index 59ca4baa6ed6..d390ec067770 100644
--- a/src/commands/explore.rs
+++ b/src/commands/explore.rs
@@ -2,39 +2,47 @@
 
 use anyhow::{Context, Result};
 use clap::Parser;
-use std::path::PathBuf;
+use std::{borrow::Cow, path::PathBuf};
+use tempfile::tempdir;
+use wasmtime::Strategy;
 use wasmtime_cli_flags::CommonOptions;
 
 /// Explore the compilation of a WebAssembly module to native code.
-#[derive(Parser)]
-#[clap(name = "explore")]
+#[derive(Parser, PartialEq)]
 pub struct ExploreCommand {
-    #[clap(flatten)]
+    #[command(flatten)]
     common: CommonOptions,
 
     /// The target triple; default is the host triple
-    #[clap(long, value_name = "TARGET")]
+    #[arg(long, value_name = "TARGET")]
     target: Option<String>,
 
     /// The path of the WebAssembly module to compile
-    #[clap(required = true, value_name = "MODULE")]
+    #[arg(required = true, value_name = "MODULE")]
     module: PathBuf,
 
     /// The path of the explorer output (derived from the MODULE name if none
     /// provided)
-    #[clap(short, long)]
+    #[arg(short, long)]
     output: Option<PathBuf>,
 }
 
 impl ExploreCommand {
     /// Executes the command.
     pub fn execute(mut self) -> Result<()> {
-        self.common.init_logging();
+        self.common.init_logging()?;
 
-        let config = self.common.config(self.target.as_deref())?;
+        let mut config = self.common.config(self.target.as_deref(), None)?;
 
-        let wasm = std::fs::read(&self.module)
-            .with_context(|| format!("failed to read Wasm module: {}", self.module.display()))?;
+        let bytes =
+            Cow::Owned(std::fs::read(&self.module).with_context(|| {
+                format!("failed to read Wasm module: {}", self.module.display())
+            })?);
+        #[cfg(feature = "wat")]
+        let bytes = wat::parse_bytes(&bytes).map_err(|mut e| {
+            e.set_path(&self.module);
+            e
+        })?;
 
         let output = self
             .output
@@ -44,7 +52,23 @@ impl ExploreCommand {
             .with_context(|| format!("failed to create file: {}", output.display()))?;
         let mut output_file = std::io::BufWriter::new(output_file);
 
-        wasmtime_explorer::generate(&config, self.target.as_deref(), &wasm, &mut output_file)?;
+        let clif_dir = if let Some(Strategy::Cranelift) | None = self.common.codegen.compiler {
+            let clif_dir = tempdir()?;
+            config.emit_clif(clif_dir.path());
+            config.disable_cache(); // cache does not emit clif
+            Some(clif_dir)
+        } else {
+            None
+        };
+
+        wasmtime_explorer::generate(
+            &config,
+            self.target.as_deref(),
+            clif_dir.as_ref().map(|tmp_dir| tmp_dir.path()),
+            &bytes,
+            &mut output_file,
+        )?;
+
         println!("Exploration written to {}", output.display());
         Ok(())
     }
diff --git a/src/commands/run.rs b/src/commands/run.rs
index b45f48a5ae6b..d06108576367 100644
--- a/src/commands/run.rs
+++ b/src/commands/run.rs
@@ -9,45 +9,26 @@ use crate::common::{Profile, RunCommon, RunTarget};
 
 use anyhow::{anyhow, bail, Context as _, Error, Result};
 use clap::Parser;
-use std::fs::File;
-use std::io::Write;
-use std::path::PathBuf;
-use std::sync::Arc;
+use std::ffi::OsString;
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, Mutex};
 use std::thread;
-use wasmtime::{
-    AsContextMut, Engine, Func, GuestProfiler, Module, Store, StoreLimits, UpdateDeadline, Val,
-    ValType,
-};
-use wasmtime_wasi::maybe_exit_on_error;
-use wasmtime_wasi::preview2;
-use wasmtime_wasi::sync::{ambient_authority, Dir, TcpListener, WasiCtxBuilder};
+use wasi_common::sync::{ambient_authority, Dir, TcpListener, WasiCtxBuilder};
+use wasmtime::{Engine, Func, Module, Store, StoreLimits, Val, ValType};
+use wasmtime_wasi::WasiView;
 
 #[cfg(feature = "wasi-nn")]
-use wasmtime_wasi_nn::WasiNnCtx;
+use wasmtime_wasi_nn::wit::WasiNnView;
 
 #[cfg(feature = "wasi-threads")]
 use wasmtime_wasi_threads::WasiThreadsCtx;
 
 #[cfg(feature = "wasi-http")]
 use wasmtime_wasi_http::WasiHttpCtx;
-
-fn parse_env_var(s: &str) -> Result<(String, Option<String>)> {
-    let mut parts = s.splitn(2, '=');
-    Ok((
-        parts.next().unwrap().to_string(),
-        parts.next().map(|s| s.to_string()),
-    ))
-}
-
-fn parse_dirs(s: &str) -> Result<(String, String)> {
-    let mut parts = s.split("::");
-    let guest = parts.next().unwrap();
-    let host = match parts.next() {
-        Some(host) => host,
-        None => guest,
-    };
-    Ok((guest.into(), host.into()))
-}
+#[cfg(feature = "wasi-keyvalue")]
+use wasmtime_wasi_keyvalue::{WasiKeyValue, WasiKeyValueCtx, WasiKeyValueCtxBuilder};
+#[cfg(feature = "wasi-runtime-config")]
+use wasmtime_wasi_runtime_config::{WasiRuntimeConfig, WasiRuntimeConfigVariables};
 
 fn parse_preloads(s: &str) -> Result<(String, PathBuf)> {
     let parts: Vec<&str> = s.splitn(2, '=').collect();
@@ -58,51 +39,41 @@ fn parse_preloads(s: &str) -> Result<(String, PathBuf)> {
 }
 
 /// Runs a WebAssembly module
-#[derive(Parser)]
-#[structopt(name = "run")]
+#[derive(Parser, PartialEq)]
 pub struct RunCommand {
-    #[clap(flatten)]
-    run: RunCommon,
-
-    /// Grant access of a host directory to a guest.
-    ///
-    /// If specified as just `GUEST_DIR` then the same directory name on the
-    /// host is made available within the guest. If specified as `GUEST::HOST`
-    /// then the `HOST` directory is opened and made available as the name
-    /// `GUEST` in the guest.
-    #[clap(long = "dir", value_name = "GUEST_DIR[::HOST_DIR]", value_parser = parse_dirs)]
-    dirs: Vec<(String, String)>,
-
-    /// Pass an environment variable to the program.
-    ///
-    /// The `--env FOO=BAR` form will set the environment variable named `FOO`
-    /// to the value `BAR` for the guest program using WASI. The `--env FOO`
-    /// form will set the environment variable named `FOO` to the same value it
-    /// has in the calling process for the guest, or in other words it will
-    /// cause the environment variable `FOO` to be inherited.
-    #[clap(long = "env", number_of_values = 1, value_name = "NAME[=VAL]", value_parser = parse_env_var)]
-    vars: Vec<(String, Option<String>)>,
+    #[command(flatten)]
+    #[allow(missing_docs)]
+    pub run: RunCommon,
 
     /// The name of the function to run
-    #[clap(long, value_name = "FUNCTION")]
-    invoke: Option<String>,
+    #[arg(long, value_name = "FUNCTION")]
+    pub invoke: Option<String>,
 
     /// Load the given WebAssembly module before the main module
-    #[clap(
+    #[arg(
         long = "preload",
         number_of_values = 1,
         value_name = "NAME=MODULE_PATH",
         value_parser = parse_preloads,
     )]
-    preloads: Vec<(String, PathBuf)>,
+    pub preloads: Vec<(String, PathBuf)>,
+
+    /// Override the value of `argv[0]`, typically the name of the executable of
+    /// the application being run.
+    ///
+    /// This can be useful to pass in situations where a CLI tool is being
+    /// executed that dispatches its functionality on the value of `argv[0]`
+    /// without needing to rename the original wasm binary.
+    #[arg(long)]
+    pub argv0: Option<String>,
 
     /// The WebAssembly module to run and arguments to pass to it.
     ///
     /// Arguments passed to the wasm module will be configured as WASI CLI
     /// arguments unless the `--invoke` CLI argument is passed in which case
     /// arguments will be interpreted as arguments to the function specified.
-    #[clap(value_name = "WASM", trailing_var_arg = true, required = true)]
-    module_and_args: Vec<PathBuf>,
+    #[arg(value_name = "WASM", trailing_var_arg = true, required = true)]
+    pub module_and_args: Vec<OsString>,
 }
 
 enum CliLinker {
@@ -114,9 +85,10 @@ enum CliLinker {
 impl RunCommand {
     /// Executes the command.
     pub fn execute(mut self) -> Result<()> {
-        self.run.common.init_logging();
+        self.run.common.init_logging()?;
 
-        let mut config = self.run.common.config(None)?;
+        let mut config = self.run.common.config(None, None)?;
+        config.async_support(true);
 
         if self.run.common.wasm.timeout.is_some() {
             config.epoch_interruption(true);
@@ -135,7 +107,9 @@ impl RunCommand {
         let engine = Engine::new(&config)?;
 
         // Read the wasm module binary either as `*.wat` or a raw binary.
-        let main = self.run.load_module(&engine, &self.module_and_args[0])?;
+        let main = self
+            .run
+            .load_module(&engine, self.module_and_args[0].as_ref())?;
 
         // Validate coredump-on-trap argument
         if let Some(path) = &self.run.common.debug.coredump {
@@ -173,88 +147,116 @@ impl RunCommand {
         // If fuel has been configured, we want to add the configured
         // fuel amount to this store.
         if let Some(fuel) = self.run.common.wasm.fuel {
-            store.add_fuel(fuel)?;
-        }
-
-        // Load the preload wasm modules.
-        let mut modules = Vec::new();
-        if let RunTarget::Core(m) = &main {
-            modules.push((String::new(), m.clone()));
-        }
-        for (name, path) in self.preloads.iter() {
-            // Read the wasm module binary either as `*.wat` or a raw binary
-            let module = match self.run.load_module(&engine, path)? {
-                RunTarget::Core(m) => m,
-                #[cfg(feature = "component-model")]
-                RunTarget::Component(_) => bail!("components cannot be loaded with `--preload`"),
-            };
-            modules.push((name.clone(), module.clone()));
-
-            // Add the module's functions to the linker.
-            match &mut linker {
-                CliLinker::Core(linker) => {
-                    linker.module(&mut store, name, &module).context(format!(
-                        "failed to process preload `{}` at `{}`",
-                        name,
-                        path.display()
-                    ))?;
+            store.set_fuel(fuel)?;
+        }
+
+        // Always run the module asynchronously to ensure that the module can be
+        // interrupted, even if it is blocking on I/O or a timeout or something.
+        let runtime = tokio::runtime::Builder::new_multi_thread()
+            .enable_time()
+            .enable_io()
+            .build()?;
+
+        let dur = self
+            .run
+            .common
+            .wasm
+            .timeout
+            .unwrap_or(std::time::Duration::MAX);
+        let result = runtime.block_on(async {
+            tokio::time::timeout(dur, async {
+                // Load the preload wasm modules.
+                let mut modules = Vec::new();
+                if let RunTarget::Core(m) = &main {
+                    modules.push((String::new(), m.clone()));
                 }
-                #[cfg(feature = "component-model")]
-                CliLinker::Component(_) => {
-                    bail!("--preload cannot be used with components");
+                for (name, path) in self.preloads.iter() {
+                    // Read the wasm module binary either as `*.wat` or a raw binary
+                    let module = match self.run.load_module(&engine, path)? {
+                        RunTarget::Core(m) => m,
+                        #[cfg(feature = "component-model")]
+                        RunTarget::Component(_) => {
+                            bail!("components cannot be loaded with `--preload`")
+                        }
+                    };
+                    modules.push((name.clone(), module.clone()));
+
+                    // Add the module's functions to the linker.
+                    match &mut linker {
+                        #[cfg(feature = "cranelift")]
+                        CliLinker::Core(linker) => {
+                            linker
+                                .module_async(&mut store, name, &module)
+                                .await
+                                .context(format!(
+                                    "failed to process preload `{}` at `{}`",
+                                    name,
+                                    path.display()
+                                ))?;
+                        }
+                        #[cfg(not(feature = "cranelift"))]
+                        CliLinker::Core(_) => {
+                            bail!("support for --preload disabled at compile time");
+                        }
+                        #[cfg(feature = "component-model")]
+                        CliLinker::Component(_) => {
+                            bail!("--preload cannot be used with components");
+                        }
+                    }
                 }
-            }
-        }
+
+                self.load_main_module(&mut store, &mut linker, &main, modules)
+                    .await
+                    .with_context(|| {
+                        format!(
+                            "failed to run main module `{}`",
+                            self.module_and_args[0].to_string_lossy()
+                        )
+                    })
+            })
+            .await
+        });
 
         // Load the main wasm module.
-        match self
-            .load_main_module(&mut store, &mut linker, &main, modules)
-            .with_context(|| {
-                format!(
-                    "failed to run main module `{}`",
-                    self.module_and_args[0].display()
-                )
-            }) {
+        match result.unwrap_or_else(|elapsed| {
+            Err(anyhow::Error::from(wasmtime::Trap::Interrupt))
+                .with_context(|| format!("timed out after {elapsed}"))
+        }) {
             Ok(()) => (),
             Err(e) => {
                 // Exit the process if Wasmtime understands the error;
                 // otherwise, fall back on Rust's default error printing/return
                 // code.
-                return Err(maybe_exit_on_error(e));
+                if store.data().preview1_ctx.is_some() {
+                    return Err(wasi_common::maybe_exit_on_error(e));
+                } else if store.data().preview2_ctx.is_some() {
+                    if let Some(exit) = e
+                        .downcast_ref::<wasmtime_wasi::I32Exit>()
+                        .map(|c| c.process_exit_code())
+                    {
+                        std::process::exit(exit);
+                    }
+                    if e.is::<wasmtime::Trap>() {
+                        eprintln!("Error: {e:?}");
+                        cfg_if::cfg_if! {
+                            if #[cfg(unix)] {
+                                std::process::exit(rustix::process::EXIT_SIGNALED_SIGABRT);
+                            } else if #[cfg(windows)] {
+                                // https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/abort?view=vs-2019
+                                std::process::exit(3);
+                            }
+                        }
+                    }
+                    return Err(e);
+                } else {
+                    unreachable!("either preview1_ctx or preview2_ctx present")
+                }
             }
         }
 
         Ok(())
     }
 
-    fn compute_preopen_dirs(&self) -> Result<Vec<(String, Dir)>> {
-        let mut preopen_dirs = Vec::new();
-
-        for (guest, host) in self.dirs.iter() {
-            preopen_dirs.push((
-                guest.clone(),
-                Dir::open_ambient_dir(host, ambient_authority())
-                    .with_context(|| format!("failed to open directory '{}'", host))?,
-            ));
-        }
-
-        Ok(preopen_dirs)
-    }
-
-    fn compute_preopen_sockets(&self) -> Result<Vec<TcpListener>> {
-        let mut listeners = vec![];
-
-        for address in &self.run.common.wasi.tcplisten {
-            let stdlistener = std::net::TcpListener::bind(address)
-                .with_context(|| format!("failed to bind to address '{}'", address))?;
-
-            let _ = stdlistener.set_nonblocking(true)?;
-
-            listeners.push(TcpListener::from_std(stdlistener))
-        }
-        Ok(listeners)
-    }
-
     fn compute_argv(&self) -> Result<Vec<String>> {
         let mut result = Vec::new();
 
@@ -262,7 +264,10 @@ impl RunCommand {
             // For argv[0], which is the program name. Only include the base
             // name of the main wasm module, to avoid leaking path information.
             let arg = if i == 0 {
-                arg.components().next_back().unwrap().as_os_str()
+                match &self.argv0 {
+                    Some(s) => s.as_ref(),
+                    None => Path::new(arg).components().next_back().unwrap().as_os_str(),
+                }
             } else {
                 arg.as_ref()
             };
@@ -280,81 +285,107 @@ impl RunCommand {
         &self,
         store: &mut Store<Host>,
         modules: Vec<(String, Module)>,
-    ) -> Box<dyn FnOnce(&mut Store<Host>)> {
+    ) -> Result<Box<dyn FnOnce(&mut Store<Host>)>> {
         if let Some(Profile::Guest { path, interval }) = &self.run.profile {
-            let module_name = self.module_and_args[0].to_str().unwrap_or("<main module>");
-            let interval = *interval;
-            store.data_mut().guest_profiler =
-                Some(Arc::new(GuestProfiler::new(module_name, interval, modules)));
-
-            fn sample(mut store: impl AsContextMut<Data = Host>) {
-                let mut profiler = store
-                    .as_context_mut()
-                    .data_mut()
-                    .guest_profiler
-                    .take()
-                    .unwrap();
-                Arc::get_mut(&mut profiler)
-                    .expect("profiling doesn't support threads yet")
-                    .sample(&store);
-                store.as_context_mut().data_mut().guest_profiler = Some(profiler);
-            }
-
-            if let Some(timeout) = self.run.common.wasm.timeout {
-                let mut timeout = (timeout.as_secs_f64() / interval.as_secs_f64()).ceil() as u64;
-                assert!(timeout > 0);
-                store.epoch_deadline_callback(move |mut store| {
-                    sample(&mut store);
-                    timeout -= 1;
-                    if timeout == 0 {
-                        bail!("timeout exceeded");
-                    }
-                    Ok(UpdateDeadline::Continue(1))
-                });
-            } else {
-                store.epoch_deadline_callback(move |mut store| {
-                    sample(&mut store);
-                    Ok(UpdateDeadline::Continue(1))
-                });
+            #[cfg(feature = "profiling")]
+            return Ok(self.setup_guest_profiler(store, modules, path, *interval));
+            #[cfg(not(feature = "profiling"))]
+            {
+                let _ = (modules, path, interval);
+                bail!("support for profiling disabled at compile time");
             }
+        }
 
+        if let Some(timeout) = self.run.common.wasm.timeout {
             store.set_epoch_deadline(1);
             let engine = store.engine().clone();
-            thread::spawn(move || loop {
-                thread::sleep(interval);
+            thread::spawn(move || {
+                thread::sleep(timeout);
                 engine.increment_epoch();
             });
+        }
 
-            let path = path.clone();
-            return Box::new(move |store| {
-                let profiler = Arc::try_unwrap(store.data_mut().guest_profiler.take().unwrap())
-                    .expect("profiling doesn't support threads yet");
-                if let Err(e) = std::fs::File::create(&path)
-                    .map_err(anyhow::Error::new)
-                    .and_then(|output| profiler.finish(std::io::BufWriter::new(output)))
-                {
-                    eprintln!("failed writing profile at {path}: {e:#}");
-                } else {
-                    eprintln!();
-                    eprintln!("Profile written to: {path}");
-                    eprintln!("View this profile at https://profiler.firefox.com/.");
-                }
-            });
+        Ok(Box::new(|_store| {}))
+    }
+
+    #[cfg(feature = "profiling")]
+    fn setup_guest_profiler(
+        &self,
+        store: &mut Store<Host>,
+        modules: Vec<(String, Module)>,
+        path: &str,
+        interval: std::time::Duration,
+    ) -> Box<dyn FnOnce(&mut Store<Host>)> {
+        use wasmtime::{AsContext, GuestProfiler, StoreContext, StoreContextMut, UpdateDeadline};
+
+        let module_name = self.module_and_args[0].to_str().unwrap_or("<main module>");
+        store.data_mut().guest_profiler =
+            Some(Arc::new(GuestProfiler::new(module_name, interval, modules)));
+
+        fn sample(
+            mut store: StoreContextMut<Host>,
+            f: impl FnOnce(&mut GuestProfiler, StoreContext<Host>),
+        ) {
+            let mut profiler = store.data_mut().guest_profiler.take().unwrap();
+            f(
+                Arc::get_mut(&mut profiler).expect("profiling doesn't support threads yet"),
+                store.as_context(),
+            );
+            store.data_mut().guest_profiler = Some(profiler);
         }
 
+        store.call_hook(|store, kind| {
+            sample(store, |profiler, store| profiler.call_hook(store, kind));
+            Ok(())
+        });
+
         if let Some(timeout) = self.run.common.wasm.timeout {
-            store.set_epoch_deadline(1);
-            let engine = store.engine().clone();
-            thread::spawn(move || {
-                thread::sleep(timeout);
-                engine.increment_epoch();
+            let mut timeout = (timeout.as_secs_f64() / interval.as_secs_f64()).ceil() as u64;
+            assert!(timeout > 0);
+            store.epoch_deadline_callback(move |store| {
+                sample(store, |profiler, store| {
+                    profiler.sample(store, std::time::Duration::ZERO)
+                });
+                timeout -= 1;
+                if timeout == 0 {
+                    bail!("timeout exceeded");
+                }
+                Ok(UpdateDeadline::Continue(1))
+            });
+        } else {
+            store.epoch_deadline_callback(move |store| {
+                sample(store, |profiler, store| {
+                    profiler.sample(store, std::time::Duration::ZERO)
+                });
+                Ok(UpdateDeadline::Continue(1))
             });
         }
 
-        Box::new(|_store| {})
+        store.set_epoch_deadline(1);
+        let engine = store.engine().clone();
+        thread::spawn(move || loop {
+            thread::sleep(interval);
+            engine.increment_epoch();
+        });
+
+        let path = path.to_string();
+        return Box::new(move |store| {
+            let profiler = Arc::try_unwrap(store.data_mut().guest_profiler.take().unwrap())
+                .expect("profiling doesn't support threads yet");
+            if let Err(e) = std::fs::File::create(&path)
+                .map_err(anyhow::Error::new)
+                .and_then(|output| profiler.finish(std::io::BufWriter::new(output)))
+            {
+                eprintln!("failed writing profile at {path}: {e:#}");
+            } else {
+                eprintln!();
+                eprintln!("Profile written to: {path}");
+                eprintln!("View this profile at https://profiler.firefox.com/.");
+            }
+        });
     }
 
-    fn load_main_module(
+    async fn load_main_module(
         &self,
         store: &mut Store<Host>,
         linker: &mut CliLinker,
@@ -368,7 +399,10 @@ impl RunCommand {
                 CliLinker::Core(linker) => {
                     linker.define_unknown_imports_as_traps(module.unwrap_core())?;
                 }
-                _ => bail!("cannot use `--trap-unknown-imports` with components"),
+                #[cfg(feature = "component-model")]
+                CliLinker::Component(linker) => {
+                    linker.define_unknown_imports_as_traps(module.unwrap_component())?;
+                }
             }
         }
 
@@ -382,32 +416,45 @@ impl RunCommand {
             }
         }
 
-        let finish_epoch_handler = self.setup_epoch_handler(store, modules);
+        let finish_epoch_handler = self.setup_epoch_handler(store, modules)?;
 
         let result = match linker {
             CliLinker::Core(linker) => {
-                // Use "" as a default module name.
                 let module = module.unwrap_core();
-                linker.module(&mut *store, "", &module).context(format!(
-                    "failed to instantiate {:?}",
-                    self.module_and_args[0]
-                ))?;
+                let instance = linker
+                    .instantiate_async(&mut *store, &module)
+                    .await
+                    .context(format!(
+                        "failed to instantiate {:?}",
+                        self.module_and_args[0]
+                    ))?;
 
-                // If a function to invoke was given, invoke it.
+                // If `_initialize` is present, meaning a reactor, then invoke
+                // the function.
+                if let Some(func) = instance.get_func(&mut *store, "_initialize") {
+                    func.typed::<(), ()>(&store)?
+                        .call_async(&mut *store, ())
+                        .await?;
+                }
+
+                // Look for the specific function provided or otherwise look for
+                // "" or "_start" exports to run as a "main" function.
                 let func = if let Some(name) = &self.invoke {
-                    match linker
-                        .get(&mut *store, "", name)
-                        .ok_or_else(|| anyhow!("no export named `{}` found", name))?
-                        .into_func()
-                    {
-                        Some(func) => func,
-                        None => bail!("export of `{}` wasn't a function", name),
-                    }
+                    Some(
+                        instance
+                            .get_func(&mut *store, name)
+                            .ok_or_else(|| anyhow!("no func export named `{}` found", name))?,
+                    )
                 } else {
-                    linker.get_default(&mut *store, "")?
+                    instance
+                        .get_func(&mut *store, "")
+                        .or_else(|| instance.get_func(&mut *store, "_start"))
                 };
 
-                self.invoke_func(store, func)
+                match func {
+                    Some(func) => self.invoke_func(store, func).await,
+                    None => Ok(()),
+                }
             }
             #[cfg(feature = "component-model")]
             CliLinker::Component(linker) => {
@@ -417,11 +464,16 @@ impl RunCommand {
 
                 let component = module.unwrap_component();
 
-                let (command, _instance) =
-                    preview2::command::sync::Command::instantiate(&mut *store, component, linker)?;
+                let command = wasmtime_wasi::bindings::Command::instantiate_async(
+                    &mut *store,
+                    component,
+                    linker,
+                )
+                .await?;
                 let result = command
                     .wasi_cli_run()
                     .call_run(&mut *store)
+                    .await
                     .context("failed to invoke `run` function")
                     .map_err(|e| self.handle_core_dump(&mut *store, e));
 
@@ -438,7 +490,7 @@ impl RunCommand {
         result
     }
 
-    fn invoke_func(&self, store: &mut Store<Host>, func: Func) -> Result<()> {
+    async fn invoke_func(&self, store: &mut Store<Host>, func: Func) -> Result<()> {
         let ty = func.ty(&store);
         if ty.params().len() > 0 {
             eprintln!(
@@ -468,20 +520,21 @@ impl RunCommand {
                 // parses base-10 representations.
                 ValType::I32 => Val::I32(val.parse()?),
                 ValType::I64 => Val::I64(val.parse()?),
-                ValType::F32 => Val::F32(val.parse()?),
-                ValType::F64 => Val::F64(val.parse()?),
+                ValType::F32 => Val::F32(val.parse::<f32>()?.to_bits()),
+                ValType::F64 => Val::F64(val.parse::<f64>()?.to_bits()),
                 t => bail!("unsupported argument type {:?}", t),
             });
         }
 
         // Invoke the function and then afterwards print all the results that came
         // out, if there are any.
-        let mut results = vec![Val::null(); ty.results().len()];
+        let mut results = vec![Val::null_func_ref(); ty.results().len()];
         let invoke_res = func
-            .call(&mut *store, &values, &mut results)
+            .call_async(&mut *store, &values, &mut results)
+            .await
             .with_context(|| {
                 if let Some(name) = &self.invoke {
-                    format!("failed to invoke `{}`", name)
+                    format!("failed to invoke `{name}`")
                 } else {
                     format!("failed to invoke command default")
                 }
@@ -500,19 +553,24 @@ impl RunCommand {
 
         for result in results {
             match result {
-                Val::I32(i) => println!("{}", i),
-                Val::I64(i) => println!("{}", i),
+                Val::I32(i) => println!("{i}"),
+                Val::I64(i) => println!("{i}"),
                 Val::F32(f) => println!("{}", f32::from_bits(f)),
                 Val::F64(f) => println!("{}", f64::from_bits(f)),
-                Val::ExternRef(_) => println!("<externref>"),
-                Val::FuncRef(_) => println!("<funcref>"),
                 Val::V128(i) => println!("{}", i.as_u128()),
+                Val::ExternRef(None) => println!("<null externref>"),
+                Val::ExternRef(Some(_)) => println!("<externref>"),
+                Val::FuncRef(None) => println!("<null funcref>"),
+                Val::FuncRef(Some(_)) => println!("<funcref>"),
+                Val::AnyRef(None) => println!("<null anyref>"),
+                Val::AnyRef(Some(_)) => println!("<anyref>"),
             }
         }
 
         Ok(())
     }
 
+    #[cfg(feature = "coredump")]
     fn handle_core_dump(&self, store: &mut Store<Host>, err: Error) -> Error {
         let coredump_path = match &self.run.common.debug.coredump {
             Some(path) => path,
@@ -526,13 +584,18 @@ impl RunCommand {
             .unwrap_or_else(|| "unknown");
 
         if let Err(coredump_err) = write_core_dump(store, &err, &source_name, coredump_path) {
-            eprintln!("warning: coredump failed to generate: {}", coredump_err);
+            eprintln!("warning: coredump failed to generate: {coredump_err}");
             err
         } else {
-            err.context(format!("core dumped at {}", coredump_path))
+            err.context(format!("core dumped at {coredump_path}"))
         }
     }
 
+    #[cfg(not(feature = "coredump"))]
+    fn handle_core_dump(&self, _store: &mut Store<Host>, err: Error) -> Error {
+        err
+    }
+
     /// Populates the given `Linker` with WASI APIs.
     fn populate_with_wasi(
         &self,
@@ -540,22 +603,56 @@ impl RunCommand {
         store: &mut Store<Host>,
         module: &RunTarget,
     ) -> Result<()> {
-        if self.run.common.wasi.common != Some(false) {
+        let mut cli = self.run.common.wasi.cli;
+
+        // Accept -Scommon as a deprecated alias for -Scli.
+        if let Some(common) = self.run.common.wasi.common {
+            if cli.is_some() {
+                bail!(
+                    "The -Scommon option should not be use with -Scli as it is a deprecated alias"
+                );
+            } else {
+                // In the future, we may add a warning here to tell users to use
+                // `-S cli` instead of `-S common`.
+                cli = Some(common);
+            }
+        }
+
+        if cli != Some(false) {
             match linker {
                 CliLinker::Core(linker) => {
-                    if self.run.common.wasi.preview2 == Some(true) {
-                        preview2::preview1::add_to_linker_sync(linker)?;
-                        self.set_preview2_ctx(store)?;
-                    } else {
-                        wasmtime_wasi::add_to_linker(linker, |host| {
-                            host.preview1_ctx.as_mut().unwrap()
-                        })?;
-                        self.set_preview1_ctx(store)?;
+                    match (self.run.common.wasi.preview2, self.run.common.wasi.threads) {
+                        // If preview2 is explicitly disabled, or if threads
+                        // are enabled, then use the historical preview1
+                        // implementation.
+                        (Some(false), _) | (None, Some(true)) => {
+                            wasi_common::tokio::add_to_linker(linker, |host| {
+                                host.preview1_ctx.as_mut().unwrap()
+                            })?;
+                            self.set_preview1_ctx(store)?;
+                        }
+                        // If preview2 was explicitly requested, always use it.
+                        // Otherwise use it so long as threads are disabled.
+                        //
+                        // Note that for now `preview0` is currently
+                        // default-enabled but this may turn into
+                        // default-disabled in the future.
+                        (Some(true), _) | (None, Some(false) | None) => {
+                            if self.run.common.wasi.preview0 != Some(false) {
+                                wasmtime_wasi::preview0::add_to_linker_async(linker, |t| {
+                                    t.preview2_ctx()
+                                })?;
+                            }
+                            wasmtime_wasi::preview1::add_to_linker_async(linker, |t| {
+                                t.preview2_ctx()
+                            })?;
+                            self.set_preview2_ctx(store)?;
+                        }
                     }
                 }
                 #[cfg(feature = "component-model")]
                 CliLinker::Component(linker) => {
-                    preview2::command::sync::add_to_linker(linker)?;
+                    wasmtime_wasi::add_to_linker_async(linker)?;
                     self.set_preview2_ctx(store)?;
                 }
             }
@@ -566,40 +663,108 @@ impl RunCommand {
             {
                 bail!("Cannot enable wasi-nn when the binary is not compiled with this feature.");
             }
-            #[cfg(feature = "wasi-nn")]
+            #[cfg(all(feature = "wasi-nn", feature = "component-model"))]
             {
+                let (backends, registry) = self.collect_preloaded_nn_graphs()?;
                 match linker {
                     CliLinker::Core(linker) => {
                         wasmtime_wasi_nn::witx::add_to_linker(linker, |host| {
-                            // This WASI proposal is currently not protected against
-                            // concurrent access--i.e., when wasi-threads is actively
-                            // spawning new threads, we cannot (yet) safely allow access and
-                            // fail if more than one thread has `Arc`-references to the
-                            // context. Once this proposal is updated (as wasi-common has
-                            // been) to allow concurrent access, this `Arc::get_mut`
-                            // limitation can be removed.
-                            Arc::get_mut(host.wasi_nn.as_mut().unwrap())
+                            Arc::get_mut(host.wasi_nn_witx.as_mut().unwrap())
                                 .expect("wasi-nn is not implemented with multi-threading support")
                         })?;
+                        store.data_mut().wasi_nn_witx = Some(Arc::new(
+                            wasmtime_wasi_nn::witx::WasiNnCtx::new(backends, registry),
+                        ));
                     }
                     #[cfg(feature = "component-model")]
                     CliLinker::Component(linker) => {
-                        wasmtime_wasi_nn::wit::ML::add_to_linker(linker, |host| {
-                            Arc::get_mut(host.wasi_nn.as_mut().unwrap())
-                                .expect("wasi-nn is not implemented with multi-threading support")
+                        wasmtime_wasi_nn::wit::add_to_linker(linker, |h: &mut Host| {
+                            let preview2_ctx =
+                                h.preview2_ctx.as_mut().expect("wasip2 is not configured");
+                            let preview2_ctx = Arc::get_mut(preview2_ctx)
+                                .expect("wasmtime_wasi is not compatible with threads")
+                                .get_mut()
+                                .unwrap();
+                            let nn_ctx = Arc::get_mut(h.wasi_nn_wit.as_mut().unwrap())
+                                .expect("wasi-nn is not implemented with multi-threading support");
+                            WasiNnView::new(preview2_ctx.table(), nn_ctx)
                         })?;
+                        store.data_mut().wasi_nn_wit = Some(Arc::new(
+                            wasmtime_wasi_nn::wit::WasiNnCtx::new(backends, registry),
+                        ));
+                    }
+                }
+            }
+        }
+
+        if self.run.common.wasi.runtime_config == Some(true) {
+            #[cfg(not(feature = "wasi-runtime-config"))]
+            {
+                bail!("Cannot enable wasi-runtime-config when the binary is not compiled with this feature.");
+            }
+            #[cfg(all(feature = "wasi-runtime-config", feature = "component-model"))]
+            {
+                match linker {
+                    CliLinker::Core(_) => {
+                        bail!("Cannot enable wasi-runtime-config for core wasm modules");
+                    }
+                    CliLinker::Component(linker) => {
+                        let vars = WasiRuntimeConfigVariables::from_iter(
+                            self.run
+                                .common
+                                .wasi
+                                .runtime_config_var
+                                .iter()
+                                .map(|v| (v.key.clone(), v.value.clone())),
+                        );
+
+                        wasmtime_wasi_runtime_config::add_to_linker(linker, |h| {
+                            WasiRuntimeConfig::new(
+                                Arc::get_mut(h.wasi_runtime_config.as_mut().unwrap()).unwrap(),
+                            )
+                        })?;
+                        store.data_mut().wasi_runtime_config = Some(Arc::new(vars));
+                    }
+                }
+            }
+        }
+
+        if self.run.common.wasi.keyvalue == Some(true) {
+            #[cfg(not(feature = "wasi-keyvalue"))]
+            {
+                bail!("Cannot enable wasi-keyvalue when the binary is not compiled with this feature.");
+            }
+            #[cfg(all(feature = "wasi-keyvalue", feature = "component-model"))]
+            {
+                match linker {
+                    CliLinker::Core(_) => {
+                        bail!("Cannot enable wasi-keyvalue for core wasm modules");
+                    }
+                    CliLinker::Component(linker) => {
+                        let ctx = WasiKeyValueCtxBuilder::new()
+                            .in_memory_data(
+                                self.run
+                                    .common
+                                    .wasi
+                                    .keyvalue_in_memory_data
+                                    .iter()
+                                    .map(|v| (v.key.clone(), v.value.clone())),
+                            )
+                            .build();
+
+                        wasmtime_wasi_keyvalue::add_to_linker(linker, |h| {
+                            let preview2_ctx =
+                                h.preview2_ctx.as_mut().expect("wasip2 is not configured");
+                            let preview2_ctx =
+                                Arc::get_mut(preview2_ctx).unwrap().get_mut().unwrap();
+                            WasiKeyValue::new(
+                                Arc::get_mut(h.wasi_keyvalue.as_mut().unwrap()).unwrap(),
+                                preview2_ctx.table(),
+                            )
+                        })?;
+                        store.data_mut().wasi_keyvalue = Some(Arc::new(ctx));
                     }
                 }
-                let graphs = self
-                    .run
-                    .common
-                    .wasi
-                    .nn_graph
-                    .iter()
-                    .map(|g| (g.format.clone(), g.dir.clone()))
-                    .collect::<Vec<_>>();
-                let (backends, registry) = wasmtime_wasi_nn::preload(&graphs)?;
-                store.data_mut().wasi_nn = Some(Arc::new(WasiNnCtx::new(backends, registry)));
             }
         }
 
@@ -608,7 +773,7 @@ impl RunCommand {
             {
                 // Silence the unused warning for `module` as it is only used in the
                 // conditionally-compiled wasi-threads.
-                drop(&module);
+                let _ = &module;
 
                 bail!(
                     "Cannot enable wasi-threads when the binary is not compiled with this feature."
@@ -643,11 +808,11 @@ impl RunCommand {
                         bail!("Cannot enable wasi-http for core wasm modules");
                     }
                     CliLinker::Component(linker) => {
-                        wasmtime_wasi_http::proxy::add_to_linker(linker)?;
+                        wasmtime_wasi_http::add_only_http_to_linker_sync(linker)?;
                     }
                 }
 
-                store.data_mut().wasi_http = Some(Arc::new(WasiHttpCtx {}));
+                store.data_mut().wasi_http = Some(Arc::new(WasiHttpCtx::new()));
             }
         }
 
@@ -658,11 +823,23 @@ impl RunCommand {
         let mut builder = WasiCtxBuilder::new();
         builder.inherit_stdio().args(&self.compute_argv()?)?;
 
-        for (key, value) in self.vars.iter() {
+        if self.run.common.wasi.inherit_env == Some(true) {
+            for (k, v) in std::env::vars() {
+                builder.env(&k, &v)?;
+            }
+        }
+        for (key, value) in self.run.vars.iter() {
             let value = match value {
                 Some(value) => value.clone(),
-                None => std::env::var(key)
-                    .map_err(|_| anyhow!("environment variable `{key}` not found"))?,
+                None => match std::env::var_os(key) {
+                    Some(val) => val
+                        .into_string()
+                        .map_err(|_| anyhow!("environment variable `{key}` not valid utf-8"))?,
+                    None => {
+                        // leave the env var un-set in the guest
+                        continue;
+                    }
+                },
             };
             builder.env(key, &value)?;
         }
@@ -673,13 +850,16 @@ impl RunCommand {
             num_fd = ctx_set_listenfd(num_fd, &mut builder)?;
         }
 
-        for listener in self.compute_preopen_sockets()? {
+        for listener in self.run.compute_preopen_sockets()? {
+            let listener = TcpListener::from_std(listener);
             builder.preopened_socket(num_fd as _, listener)?;
             num_fd += 1;
         }
 
-        for (name, dir) in self.compute_preopen_dirs()? {
-            builder.preopened_dir(dir, name)?;
+        for (host, guest) in self.run.dirs.iter() {
+            let dir = Dir::open_ambient_dir(host, ambient_authority())
+                .with_context(|| format!("failed to open directory '{host}'"))?;
+            builder.preopened_dir(dir, guest)?;
         }
 
         store.data_mut().preview1_ctx = Some(builder.build());
@@ -687,96 +867,78 @@ impl RunCommand {
     }
 
     fn set_preview2_ctx(&self, store: &mut Store<Host>) -> Result<()> {
-        let mut builder = preview2::WasiCtxBuilder::new();
+        let mut builder = wasmtime_wasi::WasiCtxBuilder::new();
         builder.inherit_stdio().args(&self.compute_argv()?);
-
-        for (key, value) in self.vars.iter() {
-            let value = match value {
-                Some(value) => value.clone(),
-                None => std::env::var(key)
-                    .map_err(|_| anyhow!("environment variable `{key}` not found"))?,
-            };
-            builder.env(key, &value);
-        }
-
-        if self.run.common.wasi.listenfd == Some(true) {
-            bail!("components do not support --listenfd");
-        }
-        for _ in self.compute_preopen_sockets()? {
-            bail!("components do not support --tcplisten");
-        }
-
-        for (name, dir) in self.compute_preopen_dirs()? {
-            builder.preopened_dir(
-                dir,
-                preview2::DirPerms::all(),
-                preview2::FilePerms::all(),
-                name,
-            );
-        }
-
-        if self.run.common.wasi.inherit_network == Some(true) {
-            builder.inherit_network(ambient_authority());
-        }
-        if let Some(enable) = self.run.common.wasi.allow_ip_name_lookup {
-            builder.allow_ip_name_lookup(enable);
-        }
-
-        store.data_mut().preview2_ctx = Some(Arc::new(builder.build()));
+        self.run.configure_wasip2(&mut builder)?;
+        let ctx = builder.build_p1();
+        store.data_mut().preview2_ctx = Some(Arc::new(Mutex::new(ctx)));
         Ok(())
     }
+
+    #[cfg(feature = "wasi-nn")]
+    fn collect_preloaded_nn_graphs(
+        &self,
+    ) -> Result<(Vec<wasmtime_wasi_nn::Backend>, wasmtime_wasi_nn::Registry)> {
+        let graphs = self
+            .run
+            .common
+            .wasi
+            .nn_graph
+            .iter()
+            .map(|g| (g.format.clone(), g.dir.clone()))
+            .collect::<Vec<_>>();
+        wasmtime_wasi_nn::preload(&graphs)
+    }
 }
 
 #[derive(Default, Clone)]
 struct Host {
-    preview1_ctx: Option<wasmtime_wasi::WasiCtx>,
-    preview2_ctx: Option<Arc<preview2::WasiCtx>>,
-
-    // Resource table for preview2 if the `preview2_ctx` is in use, otherwise
-    // "just" an empty table.
-    preview2_table: Arc<preview2::Table>,
+    preview1_ctx: Option<wasi_common::WasiCtx>,
 
-    // State necessary for the preview1 implementation of WASI backed by the
-    // preview2 host implementation. Only used with the `--preview2` flag right
-    // now when running core modules.
-    preview2_adapter: Arc<preview2::preview1::WasiPreview1Adapter>,
+    // The Mutex is only needed to satisfy the Sync constraint but we never
+    // actually perform any locking on it as we use Mutex::get_mut for every
+    // access.
+    preview2_ctx: Option<Arc<Mutex<wasmtime_wasi::preview1::WasiP1Ctx>>>,
 
     #[cfg(feature = "wasi-nn")]
-    wasi_nn: Option<Arc<WasiNnCtx>>,
+    wasi_nn_wit: Option<Arc<wasmtime_wasi_nn::wit::WasiNnCtx>>,
+    #[cfg(feature = "wasi-nn")]
+    wasi_nn_witx: Option<Arc<wasmtime_wasi_nn::witx::WasiNnCtx>>,
+
     #[cfg(feature = "wasi-threads")]
     wasi_threads: Option<Arc<WasiThreadsCtx<Host>>>,
     #[cfg(feature = "wasi-http")]
     wasi_http: Option<Arc<WasiHttpCtx>>,
     limits: StoreLimits,
-    guest_profiler: Option<Arc<GuestProfiler>>,
-}
-
-impl preview2::WasiView for Host {
-    fn table(&self) -> &preview2::Table {
-        &self.preview2_table
-    }
+    #[cfg(feature = "profiling")]
+    guest_profiler: Option<Arc<wasmtime::GuestProfiler>>,
 
-    fn table_mut(&mut self) -> &mut preview2::Table {
-        Arc::get_mut(&mut self.preview2_table).expect("preview2 is not compatible with threads")
-    }
-
-    fn ctx(&self) -> &preview2::WasiCtx {
-        self.preview2_ctx.as_ref().unwrap()
-    }
+    #[cfg(feature = "wasi-runtime-config")]
+    wasi_runtime_config: Option<Arc<WasiRuntimeConfigVariables>>,
+    #[cfg(feature = "wasi-keyvalue")]
+    wasi_keyvalue: Option<Arc<WasiKeyValueCtx>>,
+}
 
-    fn ctx_mut(&mut self) -> &mut preview2::WasiCtx {
-        let ctx = self.preview2_ctx.as_mut().unwrap();
-        Arc::get_mut(ctx).expect("preview2 is not compatible with threads")
+impl Host {
+    fn preview2_ctx(&mut self) -> &mut wasmtime_wasi::preview1::WasiP1Ctx {
+        let ctx = self
+            .preview2_ctx
+            .as_mut()
+            .expect("wasip2 is not configured");
+        Arc::get_mut(ctx)
+            .expect("wasmtime_wasi is not compatible with threads")
+            .get_mut()
+            .unwrap()
     }
 }
 
-impl preview2::preview1::WasiPreview1View for Host {
-    fn adapter(&self) -> &preview2::preview1::WasiPreview1Adapter {
-        &self.preview2_adapter
+impl WasiView for Host {
+    fn table(&mut self) -> &mut wasmtime::component::ResourceTable {
+        self.preview2_ctx().table()
     }
 
-    fn adapter_mut(&mut self) -> &mut preview2::preview1::WasiPreview1Adapter {
-        Arc::get_mut(&mut self.preview2_adapter).expect("preview2 is not compatible with threads")
+    fn ctx(&mut self) -> &mut wasmtime_wasi::WasiCtx {
+        self.preview2_ctx().ctx()
     }
 }
 
@@ -784,11 +946,11 @@ impl preview2::preview1::WasiPreview1View for Host {
 impl wasmtime_wasi_http::types::WasiHttpView for Host {
     fn ctx(&mut self) -> &mut WasiHttpCtx {
         let ctx = self.wasi_http.as_mut().unwrap();
-        Arc::get_mut(ctx).expect("preview2 is not compatible with threads")
+        Arc::get_mut(ctx).expect("wasmtime_wasi is not compatible with threads")
     }
 
-    fn table(&mut self) -> &mut preview2::Table {
-        Arc::get_mut(&mut self.preview2_table).expect("preview2 is not compatible with threads")
+    fn table(&mut self) -> &mut wasmtime::component::ResourceTable {
+        self.preview2_ctx().table()
     }
 }
 
@@ -821,12 +983,16 @@ fn ctx_set_listenfd(mut num_fd: usize, builder: &mut WasiCtxBuilder) -> Result<u
     Ok(num_fd)
 }
 
+#[cfg(feature = "coredump")]
 fn write_core_dump(
     store: &mut Store<Host>,
     err: &anyhow::Error,
     name: &str,
     path: &str,
 ) -> Result<()> {
+    use std::fs::File;
+    use std::io::Write;
+
     let core_dump = err
         .downcast_ref::<wasmtime::WasmCoreDump>()
         .expect("should have been configured to capture core dumps");
@@ -834,9 +1000,9 @@ fn write_core_dump(
     let core_dump = core_dump.serialize(store, name);
 
     let mut core_dump_file =
-        File::create(path).context(format!("failed to create file at `{}`", path))?;
+        File::create(path).context(format!("failed to create file at `{path}`"))?;
     core_dump_file
         .write_all(&core_dump)
-        .with_context(|| format!("failed to write core dump file at `{}`", path))?;
+        .with_context(|| format!("failed to write core dump file at `{path}`"))?;
     Ok(())
 }
diff --git a/src/commands/serve.rs b/src/commands/serve.rs
index 6993217839a7..6f80fc4b08ef 100644
--- a/src/commands/serve.rs
+++ b/src/commands/serve.rs
@@ -1,24 +1,31 @@
 use crate::common::{Profile, RunCommon, RunTarget};
-use anyhow::{bail, Result};
+use anyhow::{anyhow, bail, Result};
 use clap::Parser;
+use std::net::SocketAddr;
 use std::{
     path::PathBuf,
-    pin::Pin,
     sync::{
-        atomic::{AtomicBool, Ordering},
+        atomic::{AtomicBool, AtomicU64, Ordering},
         Arc,
     },
 };
-use wasmtime::component::{InstancePre, Linker};
-use wasmtime::{Engine, Store, StoreLimits};
-use wasmtime_wasi::preview2::{Table, WasiCtx, WasiCtxBuilder, WasiView};
+use wasmtime::component::Linker;
+use wasmtime::{Config, Engine, Memory, MemoryType, Store, StoreLimits};
+use wasmtime_wasi::{StreamError, StreamResult, WasiCtx, WasiCtxBuilder, WasiView};
+use wasmtime_wasi_http::bindings::http::types::Scheme;
+use wasmtime_wasi_http::bindings::ProxyPre;
+use wasmtime_wasi_http::io::TokioIo;
 use wasmtime_wasi_http::{body::HyperOutgoingBody, WasiHttpCtx, WasiHttpView};
 
+#[cfg(feature = "wasi-keyvalue")]
+use wasmtime_wasi_keyvalue::{WasiKeyValue, WasiKeyValueCtx, WasiKeyValueCtxBuilder};
 #[cfg(feature = "wasi-nn")]
-use wasmtime_wasi_nn::WasiNnCtx;
+use wasmtime_wasi_nn::wit::WasiNnCtx;
+#[cfg(feature = "wasi-runtime-config")]
+use wasmtime_wasi_runtime_config::{WasiRuntimeConfig, WasiRuntimeConfigVariables};
 
 struct Host {
-    table: Table,
+    table: wasmtime::component::ResourceTable,
     ctx: WasiCtx,
     http: WasiHttpCtx,
 
@@ -26,28 +33,26 @@ struct Host {
 
     #[cfg(feature = "wasi-nn")]
     nn: Option<WasiNnCtx>,
+
+    #[cfg(feature = "wasi-runtime-config")]
+    wasi_runtime_config: Option<WasiRuntimeConfigVariables>,
+
+    #[cfg(feature = "wasi-keyvalue")]
+    wasi_keyvalue: Option<WasiKeyValueCtx>,
 }
 
 impl WasiView for Host {
-    fn table(&self) -> &Table {
-        &self.table
-    }
-
-    fn table_mut(&mut self) -> &mut Table {
+    fn table(&mut self) -> &mut wasmtime::component::ResourceTable {
         &mut self.table
     }
 
-    fn ctx(&self) -> &WasiCtx {
-        &self.ctx
-    }
-
-    fn ctx_mut(&mut self) -> &mut WasiCtx {
+    fn ctx(&mut self) -> &mut WasiCtx {
         &mut self.ctx
     }
 }
 
 impl WasiHttpView for Host {
-    fn table(&mut self) -> &mut Table {
+    fn table(&mut self) -> &mut wasmtime::component::ResourceTable {
         &mut self.table
     }
 
@@ -62,35 +67,27 @@ const DEFAULT_ADDR: std::net::SocketAddr = std::net::SocketAddr::new(
 );
 
 /// Runs a WebAssembly module
-#[derive(Parser)]
-#[structopt(name = "serve")]
+#[derive(Parser, PartialEq)]
 pub struct ServeCommand {
-    #[clap(flatten)]
+    #[command(flatten)]
     run: RunCommon,
 
     /// Socket address for the web server to bind to.
-    #[clap(long = "addr", value_name = "SOCKADDR", default_value_t = DEFAULT_ADDR )]
-    addr: std::net::SocketAddr,
+    #[arg(long = "addr", value_name = "SOCKADDR", default_value_t = DEFAULT_ADDR )]
+    addr: SocketAddr,
 
     /// The WebAssembly component to run.
-    #[clap(value_name = "WASM", required = true)]
+    #[arg(value_name = "WASM", required = true)]
     component: PathBuf,
 }
 
 impl ServeCommand {
     /// Start a server to run the given wasi-http proxy component
     pub fn execute(mut self) -> Result<()> {
-        self.run.common.init_logging();
-
-        // We force cli errors before starting to listen for connections so tha we don't
-        // accidentally delay them to the first request.
-        if self.run.common.wasi.nn == Some(true) {
-            #[cfg(not(feature = "wasi-nn"))]
-            {
-                bail!("Cannot enable wasi-nn when the binary is not compiled with this feature.");
-            }
-        }
+        self.run.common.init_logging()?;
 
+        // We force cli errors before starting to listen for connections so then
+        // we don't accidentally delay them to the first request.
         if let Some(Profile::Guest { .. }) = &self.run.profile {
             bail!("Cannot use the guest profiler with components");
         }
@@ -106,8 +103,8 @@ impl ServeCommand {
             bail!("wasi-threads does not support components yet")
         }
 
-        // The serve command requires both wasi-http and the component model, so we enable those by
-        // default here.
+        // The serve command requires both wasi-http and the component model, so
+        // we enable those by default here.
         if self.run.common.wasi.http.replace(true) == Some(false) {
             bail!("wasi-http is required for the serve command, and must not be disabled");
         }
@@ -135,20 +132,35 @@ impl ServeCommand {
         Ok(())
     }
 
-    fn new_store(&self, engine: &Engine) -> Result<Store<Host>> {
+    fn new_store(&self, engine: &Engine, req_id: u64) -> Result<Store<Host>> {
         let mut builder = WasiCtxBuilder::new();
+        self.run.configure_wasip2(&mut builder)?;
+
+        builder.env("REQUEST_ID", req_id.to_string());
+
+        builder.stdout(LogStream::new(
+            format!("stdout [{req_id}] :: "),
+            Output::Stdout,
+        ));
 
-        // TODO: connect stdio to logging infrastructure
+        builder.stderr(LogStream::new(
+            format!("stderr [{req_id}] :: "),
+            Output::Stderr,
+        ));
 
         let mut host = Host {
-            table: Table::new(),
+            table: wasmtime::component::ResourceTable::new(),
             ctx: builder.build(),
-            http: WasiHttpCtx,
+            http: WasiHttpCtx::new(),
 
             limits: StoreLimits::default(),
 
             #[cfg(feature = "wasi-nn")]
             nn: None,
+            #[cfg(feature = "wasi-runtime-config")]
+            wasi_runtime_config: None,
+            #[cfg(feature = "wasi-keyvalue")]
+            wasi_keyvalue: None,
         };
 
         if self.run.common.wasi.nn == Some(true) {
@@ -167,10 +179,42 @@ impl ServeCommand {
             }
         }
 
+        if self.run.common.wasi.runtime_config == Some(true) {
+            #[cfg(feature = "wasi-runtime-config")]
+            {
+                let vars = WasiRuntimeConfigVariables::from_iter(
+                    self.run
+                        .common
+                        .wasi
+                        .runtime_config_var
+                        .iter()
+                        .map(|v| (v.key.clone(), v.value.clone())),
+                );
+                host.wasi_runtime_config.replace(vars);
+            }
+        }
+
+        if self.run.common.wasi.keyvalue == Some(true) {
+            #[cfg(feature = "wasi-keyvalue")]
+            {
+                let ctx = WasiKeyValueCtxBuilder::new()
+                    .in_memory_data(
+                        self.run
+                            .common
+                            .wasi
+                            .keyvalue_in_memory_data
+                            .iter()
+                            .map(|v| (v.key.clone(), v.value.clone())),
+                    )
+                    .build();
+                host.wasi_keyvalue.replace(ctx);
+            }
+        }
+
         let mut store = Store::new(engine, host);
 
         if self.run.common.wasm.timeout.is_some() {
-            store.set_epoch_deadline(1);
+            store.set_epoch_deadline(u64::from(EPOCH_PRECISION) + 1);
         }
 
         store.data_mut().limits = self.run.store_limits();
@@ -179,24 +223,89 @@ impl ServeCommand {
         // If fuel has been configured, we want to add the configured
         // fuel amount to this store.
         if let Some(fuel) = self.run.common.wasm.fuel {
-            store.add_fuel(fuel)?;
+            store.set_fuel(fuel)?;
         }
 
         Ok(store)
     }
 
     fn add_to_linker(&self, linker: &mut Linker<Host>) -> Result<()> {
-        // wasi-http and the component model are implicitly enabled for `wasmtime serve`, so we
-        // don't test for `self.run.common.wasi.common` or `self.run.common.wasi.http` in this
-        // function.
+        let mut cli = self.run.common.wasi.cli;
+
+        // Accept -Scommon as a deprecated alias for -Scli.
+        if let Some(common) = self.run.common.wasi.common {
+            if cli.is_some() {
+                bail!(
+                    "The -Scommon option should not be use with -Scli as it is a deprecated alias"
+                );
+            } else {
+                // In the future, we may add a warning here to tell users to use
+                // `-S cli` instead of `-S common`.
+                cli = Some(common);
+            }
+        }
 
-        wasmtime_wasi_http::proxy::add_to_linker(linker)?;
+        // Repurpose the `-Scli` flag of `wasmtime run` for `wasmtime serve`
+        // to serve as a signal to enable all WASI interfaces instead of just
+        // those in the `proxy` world. If `-Scli` is present then add all
+        // `command` APIs and then additionally add in the required HTTP APIs.
+        //
+        // If `-Scli` isn't passed then use the `add_to_linker_async`
+        // bindings which adds just those interfaces that the proxy interface
+        // uses.
+        if cli == Some(true) {
+            wasmtime_wasi::add_to_linker_async(linker)?;
+            wasmtime_wasi_http::add_only_http_to_linker_async(linker)?;
+        } else {
+            wasmtime_wasi_http::add_to_linker_async(linker)?;
+        }
 
         if self.run.common.wasi.nn == Some(true) {
+            #[cfg(not(feature = "wasi-nn"))]
+            {
+                bail!("support for wasi-nn was disabled at compile time");
+            }
             #[cfg(feature = "wasi-nn")]
             {
-                wasmtime_wasi_nn::wit::ML::add_to_linker(linker, |host| host.nn.as_mut().unwrap())?;
+                wasmtime_wasi_nn::wit::add_to_linker(linker, |h: &mut Host| {
+                    let ctx = h.nn.as_mut().unwrap();
+                    wasmtime_wasi_nn::wit::WasiNnView::new(&mut h.table, ctx)
+                })?;
+            }
+        }
+
+        if self.run.common.wasi.runtime_config == Some(true) {
+            #[cfg(not(feature = "wasi-runtime-config"))]
+            {
+                bail!("support for wasi-runtime-config was disabled at compile time");
             }
+            #[cfg(feature = "wasi-runtime-config")]
+            {
+                wasmtime_wasi_runtime_config::add_to_linker(linker, |h| {
+                    WasiRuntimeConfig::from(h.wasi_runtime_config.as_ref().unwrap())
+                })?;
+            }
+        }
+
+        if self.run.common.wasi.keyvalue == Some(true) {
+            #[cfg(not(feature = "wasi-keyvalue"))]
+            {
+                bail!("support for wasi-keyvalue was disabled at compile time");
+            }
+            #[cfg(feature = "wasi-keyvalue")]
+            {
+                wasmtime_wasi_keyvalue::add_to_linker(linker, |h: &mut Host| {
+                    WasiKeyValue::new(h.wasi_keyvalue.as_ref().unwrap(), &mut h.table)
+                })?;
+            }
+        }
+
+        if self.run.common.wasi.threads == Some(true) {
+            bail!("support for wasi-threads is not available with components");
+        }
+
+        if self.run.common.wasi.http == Some(false) {
+            bail!("support for wasi-http must be enabled for `serve` subcommand");
         }
 
         Ok(())
@@ -205,7 +314,10 @@ impl ServeCommand {
     async fn serve(mut self) -> Result<()> {
         use hyper::server::conn::http1;
 
-        let mut config = self.run.common.config(None)?;
+        let mut config = self
+            .run
+            .common
+            .config(None, use_pooling_allocator_by_default().unwrap_or(None))?;
         config.wasm_component_model(true);
         config.async_support(true);
 
@@ -235,24 +347,50 @@ impl ServeCommand {
         };
 
         let instance = linker.instantiate_pre(&component)?;
+        let instance = ProxyPre::new(instance)?;
 
-        let listener = tokio::net::TcpListener::bind(self.addr).await?;
+        let socket = match &self.addr {
+            SocketAddr::V4(_) => tokio::net::TcpSocket::new_v4()?,
+            SocketAddr::V6(_) => tokio::net::TcpSocket::new_v6()?,
+        };
+        // Conditionally enable `SO_REUSEADDR` depending on the current
+        // platform. On Unix we want this to be able to rebind an address in
+        // the `TIME_WAIT` state which can happen then a server is killed with
+        // active TCP connections and then restarted. On Windows though if
+        // `SO_REUSEADDR` is specified then it enables multiple applications to
+        // bind the port at the same time which is not something we want. Hence
+        // this is conditionally set based on the platform (and deviates from
+        // Tokio's default from always-on).
+        socket.set_reuseaddr(!cfg!(windows))?;
+        socket.bind(self.addr)?;
+        let listener = socket.listen(100)?;
+
+        eprintln!("Serving HTTP on http://{}/", listener.local_addr()?);
 
         let _epoch_thread = if let Some(timeout) = self.run.common.wasm.timeout {
-            Some(EpochThread::spawn(timeout, engine.clone()))
+            Some(EpochThread::spawn(
+                timeout / EPOCH_PRECISION,
+                engine.clone(),
+            ))
         } else {
             None
         };
 
+        log::info!("Listening on {}", self.addr);
+
         let handler = ProxyHandler::new(self, engine, instance);
 
         loop {
             let (stream, _) = listener.accept().await?;
+            let stream = TokioIo::new(stream);
             let h = handler.clone();
-            tokio::task::spawn(async move {
+            tokio::task::spawn(async {
                 if let Err(e) = http1::Builder::new()
                     .keep_alive(true)
-                    .serve_connection(stream, h)
+                    .serve_connection(
+                        stream,
+                        hyper::service::service_fn(move |req| handle_request(h.clone(), req)),
+                    )
                     .await
                 {
                     eprintln!("error: {e:?}");
@@ -262,6 +400,12 @@ impl ServeCommand {
     }
 }
 
+/// This is the number of epochs that we will observe before expiring a request handler. As
+/// instances may be started at any point within an epoch, and epochs are counted globally per
+/// engine, we expire after `EPOCH_PRECISION + 1` epochs have been observed. This gives a maximum
+/// overshoot of `timeout / EPOCH_PRECISION`, which is more desirable than expiring early.
+const EPOCH_PRECISION: u32 = 10;
+
 struct EpochThread {
     shutdown: Arc<AtomicBool>,
     handle: Option<std::thread::JoinHandle<()>>,
@@ -297,63 +441,215 @@ impl Drop for EpochThread {
 struct ProxyHandlerInner {
     cmd: ServeCommand,
     engine: Engine,
-    instance_pre: InstancePre<Host>,
+    instance_pre: ProxyPre<Host>,
+    next_id: AtomicU64,
+}
+
+impl ProxyHandlerInner {
+    fn next_req_id(&self) -> u64 {
+        self.next_id.fetch_add(1, Ordering::Relaxed)
+    }
 }
 
 #[derive(Clone)]
 struct ProxyHandler(Arc<ProxyHandlerInner>);
 
 impl ProxyHandler {
-    fn new(cmd: ServeCommand, engine: Engine, instance_pre: InstancePre<Host>) -> Self {
+    fn new(cmd: ServeCommand, engine: Engine, instance_pre: ProxyPre<Host>) -> Self {
         Self(Arc::new(ProxyHandlerInner {
             cmd,
             engine,
             instance_pre,
+            next_id: AtomicU64::from(0),
         }))
     }
 }
 
 type Request = hyper::Request<hyper::body::Incoming>;
 
-impl hyper::service::Service<Request> for ProxyHandler {
-    type Response = hyper::Response<HyperOutgoingBody>;
-    type Error = anyhow::Error;
-    type Future = Pin<Box<dyn std::future::Future<Output = Result<Self::Response>> + Send>>;
+async fn handle_request(
+    ProxyHandler(inner): ProxyHandler,
+    req: Request,
+) -> Result<hyper::Response<HyperOutgoingBody>> {
+    let (sender, receiver) = tokio::sync::oneshot::channel();
+
+    let req_id = inner.next_req_id();
+
+    log::info!(
+        "Request {req_id} handling {} to {}",
+        req.method(),
+        req.uri()
+    );
+
+    let mut store = inner.cmd.new_store(&inner.engine, req_id)?;
+
+    let req = store.data_mut().new_incoming_request(Scheme::Http, req)?;
+    let out = store.data_mut().new_response_outparam(sender)?;
+    let proxy = inner.instance_pre.instantiate_async(&mut store).await?;
+
+    let task = tokio::task::spawn(async move {
+        if let Err(e) = proxy
+            .wasi_http_incoming_handler()
+            .call_handle(store, req, out)
+            .await
+        {
+            log::error!("[{req_id}] :: {:#?}", e);
+            return Err(e);
+        }
 
-    fn call(&mut self, req: Request) -> Self::Future {
-        use http_body_util::BodyExt;
+        Ok(())
+    });
+
+    match receiver.await {
+        Ok(Ok(resp)) => Ok(resp),
+        Ok(Err(e)) => Err(e.into()),
+        Err(_) => {
+            // An error in the receiver (`RecvError`) only indicates that the
+            // task exited before a response was sent (i.e., the sender was
+            // dropped); it does not describe the underlying cause of failure.
+            // Instead we retrieve and propagate the error from inside the task
+            // which should more clearly tell the user what went wrong. Note
+            // that we assume the task has already exited at this point so the
+            // `await` should resolve immediately.
+            let e = match task.await {
+                Ok(r) => r.expect_err("if the receiver has an error, the task must have failed"),
+                Err(e) => e.into(),
+            };
+            bail!("guest never invoked `response-outparam::set` method: {e:?}")
+        }
+    }
+}
 
-        let handler = self.clone();
+#[derive(Clone)]
+enum Output {
+    Stdout,
+    Stderr,
+}
 
-        let (sender, receiver) = tokio::sync::oneshot::channel();
+impl Output {
+    fn write_all(&self, buf: &[u8]) -> anyhow::Result<()> {
+        use std::io::Write;
 
-        // TODO: need to track the join handle, but don't want to block the response on it
-        tokio::task::spawn(async move {
-            let mut store = handler.0.cmd.new_store(&handler.0.engine)?;
+        match self {
+            Output::Stdout => std::io::stdout().write_all(buf),
+            Output::Stderr => std::io::stderr().write_all(buf),
+        }
+        .map_err(|e| anyhow!(e))
+    }
+}
 
-            let req = store.data_mut().new_incoming_request(
-                req.map(|body| body.map_err(|e| anyhow::anyhow!(e)).boxed()),
-            )?;
+#[derive(Clone)]
+struct LogStream {
+    prefix: String,
+    output: Output,
+    needs_prefix_on_next_write: bool,
+}
 
-            let out = store.data_mut().new_response_outparam(sender)?;
+impl LogStream {
+    fn new(prefix: String, output: Output) -> LogStream {
+        LogStream {
+            prefix,
+            output,
+            needs_prefix_on_next_write: true,
+        }
+    }
+}
 
-            let (proxy, _inst) = wasmtime_wasi_http::proxy::Proxy::instantiate_pre(
-                &mut store,
-                &handler.0.instance_pre,
-            )
-            .await?;
+impl wasmtime_wasi::StdoutStream for LogStream {
+    fn stream(&self) -> Box<dyn wasmtime_wasi::HostOutputStream> {
+        Box::new(self.clone())
+    }
+
+    fn isatty(&self) -> bool {
+        use std::io::IsTerminal;
+
+        match &self.output {
+            Output::Stdout => std::io::stdout().is_terminal(),
+            Output::Stderr => std::io::stderr().is_terminal(),
+        }
+    }
+}
+
+impl wasmtime_wasi::HostOutputStream for LogStream {
+    fn write(&mut self, bytes: bytes::Bytes) -> StreamResult<()> {
+        let mut bytes = &bytes[..];
+
+        while !bytes.is_empty() {
+            if self.needs_prefix_on_next_write {
+                self.output
+                    .write_all(self.prefix.as_bytes())
+                    .map_err(StreamError::LastOperationFailed)?;
+                self.needs_prefix_on_next_write = false;
+            }
+            match bytes.iter().position(|b| *b == b'\n') {
+                Some(i) => {
+                    let (a, b) = bytes.split_at(i + 1);
+                    bytes = b;
+                    self.output
+                        .write_all(a)
+                        .map_err(StreamError::LastOperationFailed)?;
+                    self.needs_prefix_on_next_write = true;
+                }
+                None => {
+                    self.output
+                        .write_all(bytes)
+                        .map_err(StreamError::LastOperationFailed)?;
+                    break;
+                }
+            }
+        }
 
-            proxy
-                .wasi_http_incoming_handler()
-                .call_handle(store, req, out)
-                .await?;
+        Ok(())
+    }
 
-            Ok::<_, anyhow::Error>(())
-        });
+    fn flush(&mut self) -> StreamResult<()> {
+        Ok(())
+    }
+
+    fn check_write(&mut self) -> StreamResult<usize> {
+        Ok(1024 * 1024)
+    }
+}
+
+#[async_trait::async_trait]
+impl wasmtime_wasi::Subscribe for LogStream {
+    async fn ready(&mut self) {}
+}
 
-        Box::pin(async move {
-            let resp = receiver.await.unwrap()?;
-            Ok(resp)
-        })
+/// The pooling allocator is tailor made for the `wasmtime serve` use case, so
+/// try to use it when we can. The main cost of the pooling allocator, however,
+/// is the virtual memory required to run it. Not all systems support the same
+/// amount of virtual memory, for example some aarch64 and riscv64 configuration
+/// only support 39 bits of virtual address space.
+///
+/// The pooling allocator, by default, will request 1000 linear memories each
+/// sized at 6G per linear memory. This is 6T of virtual memory which ends up
+/// being about 42 bits of the address space. This exceeds the 39 bit limit of
+/// some systems, so there the pooling allocator will fail by default.
+///
+/// This function attempts to dynamically determine the hint for the pooling
+/// allocator. This returns `Some(true)` if the pooling allocator should be used
+/// by default, or `None` or an error otherwise.
+///
+/// The method for testing this is to allocate a 0-sized 64-bit linear memory
+/// with a maximum size that's N bits large where we force all memories to be
+/// static. This should attempt to acquire N bits of the virtual address space.
+/// If successful that should mean that the pooling allocator is OK to use, but
+/// if it fails then the pooling allocator is not used and the normal mmap-based
+/// implementation is used instead.
+fn use_pooling_allocator_by_default() -> Result<Option<bool>> {
+    const BITS_TO_TEST: u32 = 42;
+    let mut config = Config::new();
+    config.wasm_memory64(true);
+    config.static_memory_maximum_size(1 << BITS_TO_TEST);
+    let engine = Engine::new(&config)?;
+    let mut store = Store::new(&engine, ());
+    // NB: the maximum size is in wasm pages to take out the 16-bits of wasm
+    // page size here from the maximum size.
+    let ty = MemoryType::new64(0, Some(1 << (BITS_TO_TEST - 16)));
+    if Memory::new(&mut store, ty).is_ok() {
+        Ok(Some(true))
+    } else {
+        Ok(None)
     }
 }
diff --git a/src/commands/settings.rs b/src/commands/settings.rs
index b51475d90554..23de74bce7d3 100644
--- a/src/commands/settings.rs
+++ b/src/commands/settings.rs
@@ -5,18 +5,17 @@ use clap::Parser;
 use serde::{ser::SerializeMap, Serialize};
 use std::collections::BTreeMap;
 use std::str::FromStr;
-use wasmtime_environ::{CompilerBuilder, FlagValue, Setting, SettingKind};
+use wasmtime_environ::{CompilerBuilder, FlagValue, Setting, SettingKind, Tunables};
 
 /// Displays available Cranelift settings for a target.
-#[derive(Parser)]
-#[clap(name = "run")]
+#[derive(Parser, PartialEq)]
 pub struct SettingsCommand {
     /// The target triple to get the settings for; defaults to the host triple.
-    #[clap(long, value_name = "TARGET")]
+    #[arg(long, value_name = "TARGET")]
     target: Option<String>,
 
     /// Switch output format to JSON
-    #[clap(long)]
+    #[arg(long)]
     json: bool,
 }
 
@@ -45,7 +44,7 @@ struct Settings {
     bools: Vec<SettingData>,
     presets: Vec<SettingData>,
 
-    inferred: Option<Vec<String>>,
+    inferred: Option<Vec<&'static str>>,
 }
 
 impl Settings {
@@ -108,11 +107,17 @@ impl SettingsCommand {
     /// Executes the command.
     pub fn execute(self) -> Result<()> {
         // Gather settings from the cranelift compiler builder
-        let mut builder = wasmtime_cranelift::builder();
-        if let Some(target) = &self.target {
+        let mut builder = wasmtime_cranelift::builder(None)?;
+        let tunables = if let Some(target) = &self.target {
             let target = target_lexicon::Triple::from_str(target).map_err(|e| anyhow!(e))?;
+            let tunables = Tunables::default_for_target(&target)?;
             builder.target(target)?;
-        }
+            tunables
+        } else {
+            Tunables::default_host()
+        };
+
+        builder.set_tunables(tunables)?;
         let mut settings = Settings::from_builder(&builder);
 
         // Add inferred settings if no target specified
@@ -151,7 +156,7 @@ impl SettingsCommand {
             println!("Settings inferred for the current host:");
 
             for name in inferred {
-                println!("  {}", name);
+                println!("  {name}");
             }
         }
 
@@ -164,7 +169,7 @@ impl SettingsCommand {
         }
 
         println!();
-        println!("{}", header);
+        println!("{header}");
 
         let width = settings.iter().map(|s| s.0.name.len()).max().unwrap_or(0);
 
diff --git a/src/commands/wast.rs b/src/commands/wast.rs
index 9e02ebd0ae89..4d4cf5000e1e 100644
--- a/src/commands/wast.rs
+++ b/src/commands/wast.rs
@@ -5,31 +5,33 @@ use clap::Parser;
 use std::path::PathBuf;
 use wasmtime::{Engine, Store};
 use wasmtime_cli_flags::CommonOptions;
-use wasmtime_wast::WastContext;
+use wasmtime_wast::{SpectestConfig, WastContext};
 
 /// Runs a WebAssembly test script file
-#[derive(Parser)]
-#[clap(name = "wast", version)]
+#[derive(Parser, PartialEq)]
 pub struct WastCommand {
-    #[clap(flatten)]
+    #[command(flatten)]
     common: CommonOptions,
 
     /// The path of the WebAssembly test script to run
-    #[clap(required = true, value_name = "SCRIPT_FILE")]
+    #[arg(required = true, value_name = "SCRIPT_FILE")]
     scripts: Vec<PathBuf>,
 }
 
 impl WastCommand {
     /// Executes the command.
     pub fn execute(mut self) -> Result<()> {
-        self.common.init_logging();
+        self.common.init_logging()?;
 
-        let config = self.common.config(None)?;
+        let config = self.common.config(None, None)?;
         let store = Store::new(&Engine::new(&config)?, ());
         let mut wast_context = WastContext::new(store);
 
         wast_context
-            .register_spectest(true)
+            .register_spectest(&SpectestConfig {
+                use_shared_memory: true,
+                suppress_prints: false,
+            })
             .expect("error instantiating \"spectest\"");
 
         for script in self.scripts.iter() {
diff --git a/src/common.rs b/src/common.rs
index 92708335d1b6..a0599b3329a5 100644
--- a/src/common.rs
+++ b/src/common.rs
@@ -1,10 +1,12 @@
 //! Common functionality shared between command implementations.
 
-use anyhow::{bail, Context, Result};
+use anyhow::{anyhow, bail, Context, Result};
 use clap::Parser;
+use std::net::TcpListener;
 use std::{path::Path, time::Duration};
 use wasmtime::{Engine, Module, Precompiled, StoreLimits, StoreLimitsBuilder};
 use wasmtime_cli_flags::{opt::WasmtimeOptionValue, CommonOptions};
+use wasmtime_wasi::WasiCtxBuilder;
 
 #[cfg(feature = "component-model")]
 use wasmtime::component::Component;
@@ -35,9 +37,9 @@ impl RunTarget {
 }
 
 /// Common command line arguments for run commands.
-#[derive(Parser)]
+#[derive(Parser, PartialEq)]
 pub struct RunCommon {
-    #[clap(flatten)]
+    #[command(flatten)]
     pub common: CommonOptions,
 
     /// Allow executing precompiled WebAssembly modules as `*.cwasm` files.
@@ -46,7 +48,7 @@ pub struct RunCommon {
     /// is arbitrary user input. Only `wasmtime`-precompiled modules generated
     /// via the `wasmtime compile` command or equivalent should be passed as an
     /// argument with this option specified.
-    #[clap(long = "allow-precompiled")]
+    #[arg(long = "allow-precompiled")]
     pub allow_precompiled: bool,
 
     /// Profiling strategy (valid options are: perfmap, jitdump, vtune, guest)
@@ -64,12 +66,49 @@ pub struct RunCommon {
     /// where `path` is where to write the profile and `interval` is the
     /// duration between samples. When used with `--wasm-timeout` the timeout
     /// will be rounded up to the nearest multiple of this interval.
-    #[clap(
+    #[arg(
         long,
         value_name = "STRATEGY",
         value_parser = Profile::parse,
     )]
     pub profile: Option<Profile>,
+
+    /// Grant access of a host directory to a guest.
+    ///
+    /// If specified as just `HOST_DIR` then the same directory name on the
+    /// host is made available within the guest. If specified as `HOST::GUEST`
+    /// then the `HOST` directory is opened and made available as the name
+    /// `GUEST` in the guest.
+    #[arg(long = "dir", value_name = "HOST_DIR[::GUEST_DIR]", value_parser = parse_dirs)]
+    pub dirs: Vec<(String, String)>,
+
+    /// Pass an environment variable to the program.
+    ///
+    /// The `--env FOO=BAR` form will set the environment variable named `FOO`
+    /// to the value `BAR` for the guest program using WASI. The `--env FOO`
+    /// form will set the environment variable named `FOO` to the same value it
+    /// has in the calling process for the guest, or in other words it will
+    /// cause the environment variable `FOO` to be inherited.
+    #[arg(long = "env", number_of_values = 1, value_name = "NAME[=VAL]", value_parser = parse_env_var)]
+    pub vars: Vec<(String, Option<String>)>,
+}
+
+fn parse_env_var(s: &str) -> Result<(String, Option<String>)> {
+    let mut parts = s.splitn(2, '=');
+    Ok((
+        parts.next().unwrap().to_string(),
+        parts.next().map(|s| s.to_string()),
+    ))
+}
+
+fn parse_dirs(s: &str) -> Result<(String, String)> {
+    let mut parts = s.split("::");
+    let host = parts.next().unwrap();
+    let guest = match parts.next() {
+        Some(guest) => guest,
+        None => host,
+    };
+    Ok((host.into(), guest.into()))
 }
 
 impl RunCommon {
@@ -107,7 +146,7 @@ impl RunCommon {
 
     #[cfg(feature = "component-model")]
     fn ensure_allow_components(&self) -> Result<()> {
-        if self.common.wasm.component_model != Some(true) {
+        if self.common.wasm.component_model == Some(false) {
             bail!("cannot execute a component without `--wasm component-model`");
         }
 
@@ -135,11 +174,11 @@ impl RunCommon {
         // modules on disk that they're opened once to detect what they are and
         // then again internally in Wasmtime as part of the `deserialize_file`
         // API. Currently there's no way to pass the `MmapVec` here through to
-        // Wasmtime itself (that'd require making `wasmtime-runtime` a public
-        // dependency or `MmapVec` a public type, both of which aren't ready to
-        // happen at this time). It's hoped though that opening a file twice
-        // isn't too bad in the grand scheme of things with respect to the CLI.
-        match wasmtime_runtime::MmapVec::from_file(path) {
+        // Wasmtime itself (that'd require making `MmapVec` a public type, both
+        // which isn't ready to happen at this time). It's hoped though that
+        // opening a file twice isn't too bad in the grand scheme of things with
+        // respect to the CLI.
+        match wasmtime::_internal::MmapVec::from_file(path) {
             Ok(map) => self.load_module_contents(
                 engine,
                 path,
@@ -186,32 +225,116 @@ impl RunCommon {
             Some(Precompiled::Component) => {
                 bail!("support for components was not enabled at compile time");
             }
+            #[cfg(any(feature = "cranelift", feature = "winch"))]
             None => {
-                // Parse the text format here specifically to add the `path` to
-                // the error message if there's a syntax error.
-                let wasm = wat::parse_bytes(bytes).map_err(|mut e| {
-                    e.set_path(path);
-                    e
-                })?;
-                if wasmparser::Parser::is_component(&wasm) {
-                    #[cfg(feature = "component-model")]
-                    {
-                        self.ensure_allow_components()?;
-                        RunTarget::Component(Component::new(engine, &wasm)?)
+                let mut code = wasmtime::CodeBuilder::new(engine);
+                code.wasm_binary_or_text(bytes, Some(path))?;
+                match code.hint() {
+                    Some(wasmtime::CodeHint::Component) => {
+                        #[cfg(feature = "component-model")]
+                        {
+                            self.ensure_allow_components()?;
+                            RunTarget::Component(code.compile_component()?)
+                        }
+                        #[cfg(not(feature = "component-model"))]
+                        {
+                            bail!("support for components was not enabled at compile time");
+                        }
                     }
-                    #[cfg(not(feature = "component-model"))]
-                    {
-                        bail!("support for components was not enabled at compile time");
+                    Some(wasmtime::CodeHint::Module) | None => {
+                        RunTarget::Core(code.compile_module()?)
                     }
-                } else {
-                    RunTarget::Core(Module::new(engine, &wasm)?)
                 }
             }
+
+            #[cfg(not(any(feature = "cranelift", feature = "winch")))]
+            None => {
+                let _ = path;
+                bail!("support for compiling modules was disabled at compile time");
+            }
         })
     }
+
+    pub fn configure_wasip2(&self, builder: &mut WasiCtxBuilder) -> Result<()> {
+        // It's ok to block the current thread since we're the only thread in
+        // the program as the CLI. This helps improve the performance of some
+        // blocking operations in WASI, for example, by skipping the
+        // back-and-forth between sync and async.
+        //
+        // However, do not set this if a timeout is configured, as that would
+        // cause the timeout to be ignored if the guest does, for example,
+        // something like `sleep(FOREVER)`.
+        builder.allow_blocking_current_thread(self.common.wasm.timeout.is_none());
+
+        if self.common.wasi.inherit_env == Some(true) {
+            for (k, v) in std::env::vars() {
+                builder.env(&k, &v);
+            }
+        }
+        for (key, value) in self.vars.iter() {
+            let value = match value {
+                Some(value) => value.clone(),
+                None => match std::env::var_os(key) {
+                    Some(val) => val
+                        .into_string()
+                        .map_err(|_| anyhow!("environment variable `{key}` not valid utf-8"))?,
+                    None => {
+                        // leave the env var un-set in the guest
+                        continue;
+                    }
+                },
+            };
+            builder.env(key, &value);
+        }
+
+        for (host, guest) in self.dirs.iter() {
+            builder.preopened_dir(
+                host,
+                guest,
+                wasmtime_wasi::DirPerms::all(),
+                wasmtime_wasi::FilePerms::all(),
+            )?;
+        }
+
+        if self.common.wasi.listenfd == Some(true) {
+            bail!("components do not support --listenfd");
+        }
+        for _ in self.compute_preopen_sockets()? {
+            bail!("components do not support --tcplisten");
+        }
+
+        if self.common.wasi.inherit_network == Some(true) {
+            builder.inherit_network();
+        }
+        if let Some(enable) = self.common.wasi.allow_ip_name_lookup {
+            builder.allow_ip_name_lookup(enable);
+        }
+        if let Some(enable) = self.common.wasi.tcp {
+            builder.allow_tcp(enable);
+        }
+        if let Some(enable) = self.common.wasi.udp {
+            builder.allow_udp(enable);
+        }
+
+        Ok(())
+    }
+
+    pub fn compute_preopen_sockets(&self) -> Result<Vec<TcpListener>> {
+        let mut listeners = vec![];
+
+        for address in &self.common.wasi.tcplisten {
+            let stdlistener = std::net::TcpListener::bind(address)
+                .with_context(|| format!("failed to bind to address '{address}'"))?;
+
+            let _ = stdlistener.set_nonblocking(true)?;
+
+            listeners.push(stdlistener)
+        }
+        Ok(listeners)
+    }
 }
 
-#[derive(Clone)]
+#[derive(Clone, PartialEq)]
 pub enum Profile {
     Native(wasmtime::ProfilingStrategy),
     Guest { path: String, interval: Duration },
diff --git a/src/lib.rs b/src/lib.rs
index 11473981a467..296c75d85853 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -2,14 +2,9 @@
 //!
 //! This crate implements the Wasmtime command line tools.
 
-#![deny(
-    missing_docs,
-    trivial_numeric_casts,
-    unused_extern_crates,
-    unstable_features
-)]
-#![warn(unused_import_braces)]
+#![deny(missing_docs)]
 
 pub mod commands;
 
+#[cfg(feature = "run")]
 pub(crate) mod common;
diff --git a/supply-chain/README b/supply-chain/README
deleted file mode 100644
index 26b31a631189..000000000000
--- a/supply-chain/README
+++ /dev/null
@@ -1,7 +0,0 @@
-This directory contains the state for cargo-vet, a tool to help projects ensure
-that third-party Rust dependencies have been audited by a trusted entity.
-
-More about the tool can be found here: https://mozilla.github.io/cargo-vet/
-
-The audits.toml file may be imported by other projects, and therefore should be
-handled with care. Ask for help if you're not sure.
diff --git a/supply-chain/README.md b/supply-chain/README.md
new file mode 100644
index 000000000000..066484407d6e
--- /dev/null
+++ b/supply-chain/README.md
@@ -0,0 +1,8 @@
+# Wasmtime's Configuration of `cargo vet`
+
+This directory contains the state for [`cargo vet`], a tool to help projects
+ensure that third-party Rust dependencies have been audited by a trusted entity.
+For more information about Wasmtime's usage of `cargo vet` see our
+[documentation](https://docs.wasmtime.dev/contributing-coding-guidelines.html#dependencies-of-wasmtime).
+
+[`cargo vet`]: https://mozilla.github.io/cargo-vet/
diff --git a/supply-chain/audits.toml b/supply-chain/audits.toml
index 075dd2052ca5..4624fdcfe6a9 100644
--- a/supply-chain/audits.toml
+++ b/supply-chain/audits.toml
@@ -6,7 +6,7 @@ who = "Nick Fitzgerald <fitzgen@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 696 # Nick Fitzgerald (fitzgen)
 start = "2020-01-14"
-end = "2024-04-21"
+end = "2025-07-30"
 notes = "I am an author of this crate."
 
 [[wildcard-audits.bumpalo]]
@@ -14,14 +14,14 @@ who = "Nick Fitzgerald <fitzgen@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 696 # Nick Fitzgerald (fitzgen)
 start = "2019-03-16"
-end = "2024-03-10"
+end = "2025-07-30"
 
 [[wildcard-audits.cranelift]]
 who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.cranelift-bforest]]
@@ -29,7 +29,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.cranelift-codegen]]
@@ -37,7 +37,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.cranelift-codegen-meta]]
@@ -45,7 +45,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.cranelift-codegen-shared]]
@@ -53,7 +53,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.cranelift-control]]
@@ -61,7 +61,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2023-05-22"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.cranelift-entity]]
@@ -69,7 +69,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.cranelift-frontend]]
@@ -77,7 +77,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.cranelift-interpreter]]
@@ -85,7 +85,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.cranelift-isle]]
@@ -93,7 +93,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-12-13"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.cranelift-jit]]
@@ -101,7 +101,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.cranelift-module]]
@@ -109,7 +109,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.cranelift-native]]
@@ -117,7 +117,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.cranelift-object]]
@@ -125,7 +125,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.cranelift-reader]]
@@ -133,7 +133,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.cranelift-serde]]
@@ -141,7 +141,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.cranelift-wasm]]
@@ -149,7 +149,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.derive_arbitrary]]
@@ -157,7 +157,7 @@ who = "Nick Fitzgerald <fitzgen@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 696 # Nick Fitzgerald (fitzgen)
 start = "2020-01-14"
-end = "2024-04-27"
+end = "2025-07-30"
 notes = "I am an author of this crate"
 
 [[wildcard-audits.regalloc2]]
@@ -165,15 +165,15 @@ who = "Chris Fallin <chris@cfallin.org>"
 criteria = "safe-to-deploy"
 user-id = 3726 # Chris Fallin (cfallin)
 start = "2021-12-03"
-end = "2024-05-02"
+end = "2025-07-30"
 notes = "We (Bytecode Alliance) are the primary authors of regalloc2 and co-develop it with Cranelift/Wasmtime, with the same code-review, testing/fuzzing, and security standards."
 
 [[wildcard-audits.regalloc2]]
 who = "Trevor Elliott <telliott@fastly.com>"
 criteria = "safe-to-deploy"
-user-id = 187138
+user-id = 187138 # Trevor Elliott (elliottt)
 start = "2022-11-29"
-end = "2024-05-02"
+end = "2025-07-30"
 notes = """
 This is a Bytecode Alliance authored crate maintained in the `regalloc2`
 repository of which I'm one of the maintainers and publishers for. I am employed
@@ -186,7 +186,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wasi-common]]
@@ -194,7 +194,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wasi-tokio]]
@@ -202,7 +202,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wasm-encoder]]
@@ -210,7 +210,7 @@ who = "Alex Crichton <alex@alexcrichton.com>"
 criteria = "safe-to-deploy"
 user-id = 1 # Alex Crichton (alexcrichton)
 start = "2020-12-11"
-end = "2024-04-14"
+end = "2025-07-30"
 notes = """
 This is a Bytecode Alliance authored crate maintained in the `wasm-tools`
 repository of which I'm one of the primary maintainers and publishers for.
@@ -218,12 +218,24 @@ I am employed by a member of the Bytecode Alliance and plan to continue doing
 so and will actively maintain this crate over time.
 """
 
+[[wildcard-audits.wasm-encoder]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+user-id = 73222 # wasmtime-publish
+start = "2023-01-01"
+end = "2025-05-08"
+notes = """
+The Bytecode Alliance uses the `wasmtime-publish` crates.io account to automate
+publication of this crate from CI. This repository requires all PRs are reviewed
+by a Bytecode Alliance maintainer and it owned by the Bytecode Alliance itself.
+"""
+
 [[wildcard-audits.wasm-metadata]]
 who = "Alex Crichton <alex@alexcrichton.com>"
 criteria = "safe-to-deploy"
 user-id = 1 # Alex Crichton (alexcrichton)
 start = "2020-12-11"
-end = "2024-04-14"
+end = "2025-07-30"
 notes = """
 This is a Bytecode Alliance authored crate maintained in the `wasm-tools`
 repository of which I'm one of the primary maintainers and publishers for.
@@ -231,19 +243,31 @@ I am employed by a member of the Bytecode Alliance and plan to continue doing
 so and will actively maintain this crate over time.
 """
 
+[[wildcard-audits.wasm-metadata]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+user-id = 73222 # wasmtime-publish
+start = "2023-01-01"
+end = "2025-05-08"
+notes = """
+The Bytecode Alliance uses the `wasmtime-publish` crates.io account to automate
+publication of this crate from CI. This repository requires all PRs are reviewed
+by a Bytecode Alliance maintainer and it owned by the Bytecode Alliance itself.
+"""
+
 [[wildcard-audits.wasm-mutate]]
 who = "Nick Fitzgerald <fitzgen@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 696 # Nick Fitzgerald (fitzgen)
 start = "2022-02-17"
-end = "2024-03-10"
+end = "2025-07-30"
 
 [[wildcard-audits.wasm-mutate]]
 who = "Alex Crichton <alex@alexcrichton.com>"
 criteria = "safe-to-deploy"
 user-id = 1 # Alex Crichton (alexcrichton)
 start = "2022-01-05"
-end = "2024-04-14"
+end = "2025-07-30"
 notes = """
 This is a Bytecode Alliance authored crate maintained in the `wasm-tools`
 repository of which I'm one of the primary maintainers and publishers for.
@@ -256,7 +280,7 @@ who = "Alex Crichton <alex@alexcrichton.com>"
 criteria = "safe-to-deploy"
 user-id = 1 # Alex Crichton (alexcrichton)
 start = "2020-09-03"
-end = "2024-04-14"
+end = "2025-07-30"
 notes = """
 This is a Bytecode Alliance authored crate maintained in the `wasm-tools`
 repository of which I'm one of the primary maintainers and publishers for.
@@ -269,7 +293,7 @@ who = "Alex Crichton <alex@alexcrichton.com>"
 criteria = "safe-to-deploy"
 user-id = 1 # Alex Crichton (alexcrichton)
 start = "2020-07-13"
-end = "2024-04-14"
+end = "2025-07-30"
 notes = """
 This is a Bytecode Alliance authored crate maintained in the `wasm-tools`
 repository of which I'm one of the primary maintainers and publishers for.
@@ -277,19 +301,31 @@ I am employed by a member of the Bytecode Alliance and plan to continue doing
 so and will actively maintain this crate over time.
 """
 
+[[wildcard-audits.wasmparser]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+user-id = 73222 # wasmtime-publish
+start = "2023-01-01"
+end = "2025-05-08"
+notes = """
+The Bytecode Alliance uses the `wasmtime-publish` crates.io account to automate
+publication of this crate from CI. This repository requires all PRs are reviewed
+by a Bytecode Alliance maintainer and it owned by the Bytecode Alliance itself.
+"""
+
 [[wildcard-audits.wasmprinter]]
 who = "Nick Fitzgerald <fitzgen@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 696 # Nick Fitzgerald (fitzgen)
 start = "2021-04-28"
-end = "2024-03-10"
+end = "2025-07-30"
 
 [[wildcard-audits.wasmprinter]]
 who = "Alex Crichton <alex@alexcrichton.com>"
 criteria = "safe-to-deploy"
 user-id = 1 # Alex Crichton (alexcrichton)
 start = "2019-11-18"
-end = "2024-04-14"
+end = "2025-07-30"
 notes = """
 This is a Bytecode Alliance authored crate maintained in the `wasm-tools`
 repository of which I'm one of the primary maintainers and publishers for.
@@ -297,12 +333,24 @@ I am employed by a member of the Bytecode Alliance and plan to continue doing
 so and will actively maintain this crate over time.
 """
 
+[[wildcard-audits.wasmprinter]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+user-id = 73222 # wasmtime-publish
+start = "2023-01-01"
+end = "2025-05-08"
+notes = """
+The Bytecode Alliance uses the `wasmtime-publish` crates.io account to automate
+publication of this crate from CI. This repository requires all PRs are reviewed
+by a Bytecode Alliance maintainer and it owned by the Bytecode Alliance itself.
+"""
+
 [[wildcard-audits.wasmtime]]
 who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wasmtime-asm-macros]]
@@ -310,7 +358,23 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2022-08-22"
-end = "2024-06-26"
+end = "2025-07-30"
+notes = "The Bytecode Alliance is the author of this crate."
+
+[[wildcard-audits.wasmtime-c-api-impl]]
+who = "Trevor Elliott <telliott@fastly.com>"
+criteria = "safe-to-deploy"
+user-id = 73222 # wasmtime-publish
+start = "2024-02-20"
+end = "2025-02-28"
+notes = "The Bytecode Alliance is the author of this crate."
+
+[[wildcard-audits.wasmtime-c-api-macros]]
+who = "Trevor Elliott <telliott@fastly.com>"
+criteria = "safe-to-deploy"
+user-id = 73222 # wasmtime-publish
+start = "2024-02-20"
+end = "2025-02-28"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wasmtime-cache]]
@@ -318,7 +382,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wasmtime-cli]]
@@ -326,7 +390,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wasmtime-cli-flags]]
@@ -334,7 +398,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2022-05-20"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wasmtime-component-macro]]
@@ -342,7 +406,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2022-07-20"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wasmtime-component-util]]
@@ -350,7 +414,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2022-08-22"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wasmtime-cranelift]]
@@ -358,7 +422,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wasmtime-cranelift-shared]]
@@ -366,7 +430,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2023-04-20"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wasmtime-environ]]
@@ -374,7 +438,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wasmtime-explorer]]
@@ -382,7 +446,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2023-04-20"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wasmtime-fiber]]
@@ -390,7 +454,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wasmtime-jit]]
@@ -398,7 +462,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wasmtime-jit-debug]]
@@ -406,7 +470,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2022-03-07"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wasmtime-jit-icache-coherence]]
@@ -414,7 +478,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2022-11-21"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wasmtime-runtime]]
@@ -422,15 +486,27 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
+[[wildcard-audits.wasmtime-slab]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+user-id = 73222 # wasmtime-publish
+start = "2023-01-01"
+end = "2025-05-08"
+notes = """
+The Bytecode Alliance uses the `wasmtime-publish` crates.io account to automate
+publication of this crate from CI. This repository requires all PRs are reviewed
+by a Bytecode Alliance maintainer and it owned by the Bytecode Alliance itself.
+"""
+
 [[wildcard-audits.wasmtime-types]]
 who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wasmtime-wasi]]
@@ -438,7 +514,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wasmtime-wasi-crypto]]
@@ -446,7 +522,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wasmtime-wasi-http]]
@@ -454,7 +530,15 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2023-05-22"
-end = "2024-06-26"
+end = "2025-07-30"
+notes = "The Bytecode Alliance is the author of this crate."
+
+[[wildcard-audits.wasmtime-wasi-keyvalue]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+user-id = 73222 # wasmtime-publish
+start = "2021-10-29"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wasmtime-wasi-nn]]
@@ -462,7 +546,15 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
+notes = "The Bytecode Alliance is the author of this crate."
+
+[[wildcard-audits.wasmtime-wasi-runtime-config]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+user-id = 73222 # wasmtime-publish
+start = "2021-10-29"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wasmtime-wasi-threads]]
@@ -470,7 +562,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2023-03-20"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wasmtime-wast]]
@@ -478,7 +570,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wasmtime-winch]]
@@ -486,7 +578,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2022-11-21"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wasmtime-wit-bindgen]]
@@ -494,7 +586,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2023-01-20"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wasmtime-wmemcheck]]
@@ -502,7 +594,7 @@ who = "Pat Hickey <pat@moreproductive.org>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2022-11-27"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wast]]
@@ -510,7 +602,7 @@ who = "Alex Crichton <alex@alexcrichton.com>"
 criteria = "safe-to-deploy"
 user-id = 1 # Alex Crichton (alexcrichton)
 start = "2019-10-16"
-end = "2024-04-14"
+end = "2025-07-30"
 notes = """
 This is a Bytecode Alliance authored crate maintained in the `wasm-tools`
 repository of which I'm one of the primary maintainers and publishers for.
@@ -518,12 +610,24 @@ I am employed by a member of the Bytecode Alliance and plan to continue doing
 so and will actively maintain this crate over time.
 """
 
+[[wildcard-audits.wast]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+user-id = 73222 # wasmtime-publish
+start = "2023-01-01"
+end = "2025-05-08"
+notes = """
+The Bytecode Alliance uses the `wasmtime-publish` crates.io account to automate
+publication of this crate from CI. This repository requires all PRs are reviewed
+by a Bytecode Alliance maintainer and it owned by the Bytecode Alliance itself.
+"""
+
 [[wildcard-audits.wat]]
 who = "Alex Crichton <alex@alexcrichton.com>"
 criteria = "safe-to-deploy"
 user-id = 1 # Alex Crichton (alexcrichton)
 start = "2019-10-18"
-end = "2024-04-14"
+end = "2025-07-30"
 notes = """
 This is a Bytecode Alliance authored crate maintained in the `wasm-tools`
 repository of which I'm one of the primary maintainers and publishers for.
@@ -531,12 +635,24 @@ I am employed by a member of the Bytecode Alliance and plan to continue doing
 so and will actively maintain this crate over time.
 """
 
+[[wildcard-audits.wat]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+user-id = 73222 # wasmtime-publish
+start = "2023-01-01"
+end = "2025-05-08"
+notes = """
+The Bytecode Alliance uses the `wasmtime-publish` crates.io account to automate
+publication of this crate from CI. This repository requires all PRs are reviewed
+by a Bytecode Alliance maintainer and it owned by the Bytecode Alliance itself.
+"""
+
 [[wildcard-audits.wiggle]]
 who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wiggle-generate]]
@@ -544,7 +660,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wiggle-macro]]
@@ -552,7 +668,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2021-10-29"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wiggle-test]]
@@ -560,7 +676,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 18162 # Pat Hickey (pchickey)
 start = "2020-03-12"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.winch-codegen]]
@@ -568,7 +684,7 @@ who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 73222 # wasmtime-publish
 start = "2022-11-21"
-end = "2024-06-26"
+end = "2025-07-30"
 notes = "The Bytecode Alliance is the author of this crate."
 
 [[wildcard-audits.wit-bindgen]]
@@ -576,7 +692,7 @@ who = "Alex Crichton <alex@alexcrichton.com>"
 criteria = "safe-to-deploy"
 user-id = 1 # Alex Crichton (alexcrichton)
 start = "2020-12-11"
-end = "2024-04-14"
+end = "2025-07-30"
 notes = """
 This is a Bytecode Alliance authored crate maintained in the `wit-bindgen`
 repository of which I'm one of the primary maintainers and publishers for.
@@ -584,12 +700,24 @@ I am employed by a member of the Bytecode Alliance and plan to continue doing
 so and will actively maintain this crate over time.
 """
 
+[[wildcard-audits.wit-bindgen]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+user-id = 73222 # wasmtime-publish
+start = "2023-01-01"
+end = "2025-05-08"
+notes = """
+The Bytecode Alliance uses the `wasmtime-publish` crates.io account to automate
+publication of this crate from CI. This repository requires all PRs are reviewed
+by a Bytecode Alliance maintainer and it owned by the Bytecode Alliance itself.
+"""
+
 [[wildcard-audits.wit-bindgen-core]]
 who = "Alex Crichton <alex@alexcrichton.com>"
 criteria = "safe-to-deploy"
 user-id = 1 # Alex Crichton (alexcrichton)
 start = "2020-12-11"
-end = "2024-04-14"
+end = "2025-07-30"
 notes = """
 This is a Bytecode Alliance authored crate maintained in the `wit-bindgen`
 repository of which I'm one of the primary maintainers and publishers for.
@@ -597,12 +725,36 @@ I am employed by a member of the Bytecode Alliance and plan to continue doing
 so and will actively maintain this crate over time.
 """
 
+[[wildcard-audits.wit-bindgen-core]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+user-id = 73222 # wasmtime-publish
+start = "2023-01-01"
+end = "2025-05-08"
+notes = """
+The Bytecode Alliance uses the `wasmtime-publish` crates.io account to automate
+publication of this crate from CI. This repository requires all PRs are reviewed
+by a Bytecode Alliance maintainer and it owned by the Bytecode Alliance itself.
+"""
+
+[[wildcard-audits.wit-bindgen-rt]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+user-id = 73222 # wasmtime-publish
+start = "2023-01-01"
+end = "2025-05-08"
+notes = """
+The Bytecode Alliance uses the `wasmtime-publish` crates.io account to automate
+publication of this crate from CI. This repository requires all PRs are reviewed
+by a Bytecode Alliance maintainer and it owned by the Bytecode Alliance itself.
+"""
+
 [[wildcard-audits.wit-bindgen-rust]]
 who = "Alex Crichton <alex@alexcrichton.com>"
 criteria = "safe-to-deploy"
 user-id = 1 # Alex Crichton (alexcrichton)
 start = "2020-12-11"
-end = "2024-04-14"
+end = "2025-07-30"
 notes = """
 This is a Bytecode Alliance authored crate maintained in the `wit-bindgen`
 repository of which I'm one of the primary maintainers and publishers for.
@@ -610,12 +762,24 @@ I am employed by a member of the Bytecode Alliance and plan to continue doing
 so and will actively maintain this crate over time.
 """
 
+[[wildcard-audits.wit-bindgen-rust]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+user-id = 73222 # wasmtime-publish
+start = "2023-01-01"
+end = "2025-05-08"
+notes = """
+The Bytecode Alliance uses the `wasmtime-publish` crates.io account to automate
+publication of this crate from CI. This repository requires all PRs are reviewed
+by a Bytecode Alliance maintainer and it owned by the Bytecode Alliance itself.
+"""
+
 [[wildcard-audits.wit-bindgen-rust-lib]]
 who = "Alex Crichton <alex@alexcrichton.com>"
 criteria = "safe-to-deploy"
 user-id = 1 # Alex Crichton (alexcrichton)
 start = "2020-12-11"
-end = "2024-04-14"
+end = "2025-07-30"
 notes = """
 This is a Bytecode Alliance authored crate maintained in the `wit-bindgen`
 repository of which I'm one of the primary maintainers and publishers for.
@@ -628,7 +792,7 @@ who = "Alex Crichton <alex@alexcrichton.com>"
 criteria = "safe-to-deploy"
 user-id = 1 # Alex Crichton (alexcrichton)
 start = "2020-12-11"
-end = "2024-04-14"
+end = "2025-07-30"
 notes = """
 This is a Bytecode Alliance authored crate maintained in the `wit-bindgen`
 repository of which I'm one of the primary maintainers and publishers for.
@@ -636,12 +800,24 @@ I am employed by a member of the Bytecode Alliance and plan to continue doing
 so and will actively maintain this crate over time.
 """
 
+[[wildcard-audits.wit-bindgen-rust-macro]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+user-id = 73222 # wasmtime-publish
+start = "2023-01-01"
+end = "2025-05-08"
+notes = """
+The Bytecode Alliance uses the `wasmtime-publish` crates.io account to automate
+publication of this crate from CI. This repository requires all PRs are reviewed
+by a Bytecode Alliance maintainer and it owned by the Bytecode Alliance itself.
+"""
+
 [[wildcard-audits.wit-component]]
 who = "Alex Crichton <alex@alexcrichton.com>"
 criteria = "safe-to-deploy"
 user-id = 1 # Alex Crichton (alexcrichton)
 start = "2020-12-11"
-end = "2024-04-14"
+end = "2025-07-30"
 notes = """
 This is a Bytecode Alliance authored crate maintained in the `wasm-tools`
 repository of which I'm one of the primary maintainers and publishers for.
@@ -654,14 +830,26 @@ who = "Nick Fitzgerald <fitzgen@gmail.com>"
 criteria = "safe-to-deploy"
 user-id = 696 # Nick Fitzgerald (fitzgen)
 start = "2019-03-16"
-end = "2024-03-10"
+end = "2025-07-30"
+
+[[wildcard-audits.wit-component]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+user-id = 73222 # wasmtime-publish
+start = "2023-01-01"
+end = "2025-05-08"
+notes = """
+The Bytecode Alliance uses the `wasmtime-publish` crates.io account to automate
+publication of this crate from CI. This repository requires all PRs are reviewed
+by a Bytecode Alliance maintainer and it owned by the Bytecode Alliance itself.
+"""
 
 [[wildcard-audits.wit-parser]]
 who = "Alex Crichton <alex@alexcrichton.com>"
 criteria = "safe-to-deploy"
 user-id = 1 # Alex Crichton (alexcrichton)
 start = "2019-12-02"
-end = "2024-04-14"
+end = "2025-07-30"
 notes = """
 This is a Bytecode Alliance authored crate maintained in the `wasm-tools`
 repository of which I'm one of the primary maintainers and publishers for.
@@ -669,6 +857,18 @@ I am employed by a member of the Bytecode Alliance and plan to continue doing
 so and will actively maintain this crate over time.
 """
 
+[[wildcard-audits.wit-parser]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+user-id = 73222 # wasmtime-publish
+start = "2023-01-01"
+end = "2025-05-08"
+notes = """
+The Bytecode Alliance uses the `wasmtime-publish` crates.io account to automate
+publication of this crate from CI. This repository requires all PRs are reviewed
+by a Bytecode Alliance maintainer and it owned by the Bytecode Alliance itself.
+"""
+
 [[audits.addr2line]]
 who = "Alex Crichton <alex@alexcrichton.com>"
 criteria = "safe-to-deploy"
@@ -690,6 +890,11 @@ criteria = "safe-to-deploy"
 delta = "0.20.0 -> 0.21.0"
 notes = "This version bump updated some dependencies and optimized some internals. All looks good."
 
+[[audits.addr2line]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+delta = "0.21.0 -> 0.22.0"
+
 [[audits.adler]]
 who = "Alex Crichton <alex@alexcrichton.com>"
 criteria = "safe-to-deploy"
@@ -701,6 +906,15 @@ who = "Chris Fallin <chris@cfallin.org>"
 criteria = "safe-to-deploy"
 delta = "0.7.6 -> 0.8.2"
 
+[[audits.ahash]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+delta = "0.8.2 -> 0.8.7"
+notes = """
+Shuffling of features in this update and while there are updates to `unsafe`
+code it's no different than before and the usage remains the same.
+"""
+
 [[audits.ambient-authority]]
 who = "Dan Gohman <dev@sunfishcode.online>"
 criteria = "safe-to-deploy"
@@ -797,6 +1011,11 @@ criteria = "safe-to-run"
 version = "0.21.0"
 notes = "This crate has no dependencies, no build.rs, and contains no unsafe code."
 
+[[audits.base64]]
+who = "Andrew Brown <andrew.brown@intel.com>"
+criteria = "safe-to-deploy"
+delta = "0.21.3 -> 0.22.1"
+
 [[audits.bitflags]]
 who = "Jamey Sharp <jsharp@fastly.com>"
 criteria = "safe-to-deploy"
@@ -833,6 +1052,11 @@ criteria = "safe-to-deploy"
 version = "3.11.1"
 notes = "I am the author of this crate."
 
+[[audits.bytesize]]
+who = "Andrew Brown <andrew.brown@intel.com>"
+criteria = "safe-to-deploy"
+version = "1.3.0"
+
 [[audits.camino]]
 who = "Pat Hickey <phickey@fastly.com>"
 criteria = "safe-to-deploy"
@@ -982,6 +1206,12 @@ criteria = "safe-to-deploy"
 version = "0.15.3"
 notes = "no build, no unsafe, inputs to cargo command are reasonably sanitized"
 
+[[audits.cargo_metadata]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+delta = "0.17.0 -> 0.18.1"
+notes = "No major changes, no unsafe code here."
+
 [[audits.cast]]
 who = "Alex Crichton <alex@alexcrichton.com>"
 criteria = "safe-to-run"
@@ -993,12 +1223,23 @@ Otherwise no major changes except what was presumably minor API breaking changes
 due to the major version bump.
 """
 
+[[audits.castaway]]
+who = "Andrew Brown <andrew.brown@intel.com>"
+criteria = "safe-to-deploy"
+version = "0.2.2"
+notes = "Very unsafe `transmute_unchecked` is used internally for downcasting; the crate is carefully written to maintain the necessary invariants."
+
 [[audits.cc]]
 who = "Alex Crichton <alex@alexcrichton.com>"
 criteria = "safe-to-deploy"
 version = "1.0.73"
 notes = "I am the author of this crate."
 
+[[audits.cc]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+delta = "1.0.83 -> 1.1.6"
+
 [[audits.cfg-if]]
 who = "Alex Crichton <alex@alexcrichton.com>"
 criteria = "safe-to-deploy"
@@ -1020,18 +1261,45 @@ who = "Pat Hickey <phickey@fastly.com>"
 criteria = "safe-to-deploy"
 version = "0.2.0"
 
+[[audits.cobs]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+version = "0.2.3"
+notes = "No `unsafe` code in the crate and no usage of `std`"
+
 [[audits.codespan-reporting]]
 who = "Jamey Sharp <jsharp@fastly.com>"
 criteria = "safe-to-deploy"
 version = "0.11.1"
 notes = "This library uses `forbid(unsafe_code)` and has no filesystem or network I/O."
 
+[[audits.compact_str]]
+who = "David Justice <david@justice.dev"
+criteria = "safe-to-deploy"
+version = "0.7.1"
+notes = "This library has many uses of unsafe, but contains extensive fuzzing and miri testing."
+
 [[audits.constant_time_eq]]
 who = "Nick Fitzgerald <fitzgen@gmail.com>"
 criteria = "safe-to-deploy"
 version = "0.2.4"
 notes = "A few tiny blocks of `unsafe` but each of them is very obviously correct."
 
+[[audits.core-foundation-sys]]
+who = "Dan Gohman <dev@sunfishcode.online>"
+criteria = "safe-to-deploy"
+delta = "0.8.4 -> 0.8.6"
+notes = """
+The changes here are all typical bindings updates: new functions, types, and
+constants. I have not audited all the bindings for ABI conformance.
+"""
+
+[[audits.cpp_demangle]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+delta = "0.3.5 -> 0.4.3"
+notes = "No substantive changes to `unsafe` code and otherwise all looks good."
+
 [[audits.cpufeatures]]
 who = "Alex Crichton <alex@alexcrichton.com>"
 criteria = "safe-to-deploy"
@@ -1134,6 +1402,12 @@ This diff brings in a number of minor updates of which none are related to
 `unsafe` code or anything system-related like filesystems.
 """
 
+[[audits.embedded-io]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+version = "0.4.0"
+notes = "No `unsafe` code and only uses `std` in ways one would expect the crate to do so."
+
 [[audits.errno]]
 who = "Dan Gohman <dev@sunfishcode.online>"
 criteria = "safe-to-deploy"
@@ -1152,6 +1426,12 @@ criteria = "safe-to-deploy"
 version = "0.1.2"
 notes = "This should be portable to any POSIX system and seems like it should be part of the libc crate, but at any rate it's safe as is."
 
+[[audits.escape8259]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-run"
+version = "0.5.2"
+notes = "No unsafe code, crate does what it says on the tin, small crate."
+
 [[audits.fallible-iterator]]
 who = "Alex Crichton <alex@alexcrichton.com>"
 criteria = "safe-to-deploy"
@@ -1162,6 +1442,15 @@ this crate has to do with iterators and `Result` and such. No `unsafe` or
 anything like that, all looks good.
 """
 
+[[audits.fastrand]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+delta = "2.0.0 -> 2.0.1"
+notes = """
+This update had a few doc updates but no otherwise-substantial source code
+updates.
+"""
+
 [[audits.fd-lock]]
 who = "Pat Hickey <phickey@fastly.com>"
 criteria = "safe-to-deploy"
@@ -1202,6 +1491,12 @@ criteria = "safe-to-deploy"
 delta = "0.1.5 -> 0.1.6"
 notes = "Just a dependency version bump"
 
+[[audits.flate2]]
+who = "Andrew Brown <andrew.brown@intel.com>"
+criteria = "safe-to-deploy"
+delta = "1.0.26 -> 1.0.28"
+notes = "No new `unsafe` and no large changes in function. This diff is mostly refactoring with a lot of docs, CI, test changes. Adds some defensive clearing out of certain variables as a safeguard."
+
 [[audits.foreign-types]]
 who = "Pat Hickey <phickey@fastly.com>"
 criteria = "safe-to-deploy"
@@ -1241,6 +1536,12 @@ criteria = "safe-to-deploy"
 delta = "0.18.1 -> 0.19.1"
 notes = "Just a dependency version bump"
 
+[[audits.fslock]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-run"
+delta = "0.1.8 -> 0.2.1"
+notes = "Internal and external refactorings plus `unsafe` where one would expect."
+
 [[audits.futures]]
 who = "Pat Hickey <phickey@fastly.com>"
 criteria = "safe-to-deploy"
@@ -1311,11 +1612,28 @@ Still looks like a good DWARF-parsing crate, nothing major was added or deleted
 and no `unsafe` code to review here.
 """
 
+[[audits.gimli]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+delta = "0.28.0 -> 0.29.0"
+
 [[audits.glob]]
 who = "Jamey Sharp <jsharp@fastly.com>"
 criteria = "safe-to-deploy"
 delta = "0.3.1 -> 0.3.0"
 
+[[audits.h2]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+delta = "0.3.19 -> 0.4.0"
+notes = "A number of changes but nothing adding new `unsafe` or anything outside the purview of what this crate already manages."
+
+[[audits.h2]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+delta = "0.4.0 -> 0.4.2"
+notes = "Minor updates and fixes in this version bump, nothing major."
+
 [[audits.hashbrown]]
 who = "Chris Fallin <chris@cfallin.org>"
 criteria = "safe-to-deploy"
@@ -1334,28 +1652,82 @@ criteria = "safe-to-deploy"
 version = "0.4.0"
 notes = "Contains `forbid_unsafe` and only uses `std::fmt` from the standard library. Otherwise only contains string manipulation."
 
+[[audits.heck]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+delta = "0.4.1 -> 0.5.0"
+notes = "Minor changes for a `no_std` upgrade but otherwise everything looks as expected."
+
 [[audits.hermit-abi]]
 who = "Pat Hickey <phickey@fastly.com>"
 criteria = "safe-to-deploy"
 delta = "0.2.0 -> 0.3.0"
 
+[[audits.home]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-run"
+delta = "0.5.3 -> 0.5.9"
+notes = "No major changes, just some internal refactorings."
+
+[[audits.http]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+delta = "0.2.9 -> 1.0.0"
+notes = "Minor changes leading up to the 1.0.0 release and nothing fundamentally new here."
+
 [[audits.http-body]]
 who = "Pat Hickey <phickey@fastly.com>"
 criteria = "safe-to-deploy"
 version = "1.0.0-rc.2"
 
+[[audits.http-body]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+delta = "1.0.0-rc.2 -> 1.0.0"
+notes = "Only minor changes made for a stable release."
+
 [[audits.http-body-util]]
 who = "Pat Hickey <phickey@fastly.com>"
 criteria = "safe-to-deploy"
 version = "0.1.0-rc.2"
 notes = "only one use of unsafe related to pin projection. unclear to me why pin_project! is used in many modules of the project, but the expanded output of that macro is inlined in either.rs"
 
+[[audits.http-body-util]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+delta = "0.1.0-rc.2 -> 0.1.0"
+notes = "Minor documentation updates an additions, nothing major."
+
 [[audits.httpdate]]
 who = "Pat Hickey <phickey@fastly.com>"
 criteria = "safe-to-deploy"
 version = "1.0.2"
 notes = "No unsafety, no io"
 
+[[audits.hyper]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+delta = "1.0.0-rc.3 -> 1.0.1"
+notes = """
+Quite a few changes here relative to the last RC but everything is related to
+refactorings and such. No new fundamental addition of functionality or
+substantially new unsafe code.
+"""
+
+[[audits.iana-time-zone]]
+who = "Dan Gohman <dev@sunfishcode.online>"
+criteria = "safe-to-deploy"
+version = "0.1.59"
+notes = """
+I also manually ran windows-bindgen and confirmed that the output matches
+the bindings checked into the repo.
+"""
+
+[[audits.iana-time-zone-haiku]]
+who = "Dan Gohman <dev@sunfishcode.online>"
+criteria = "safe-to-deploy"
+version = "0.1.2"
+
 [[audits.id-arena]]
 who = "Nick Fitzgerald <fitzgen@gmail.com>"
 criteria = "safe-to-deploy"
@@ -1446,6 +1818,15 @@ criteria = "safe-to-deploy"
 delta = "0.4.1 -> 0.4.3"
 notes = "The Bytecode Alliance is the author of this crate."
 
+[[audits.itertools]]
+who = "Nick Fitzgerald <fitzgen@gmail.com>"
+criteria = "safe-to-deploy"
+delta = "0.10.5 -> 0.12.1"
+notes = """
+Minimal `unsafe` usage. Few blocks that existed looked reasonable. Does what it
+says on the tin: lots of iterators.
+"""
+
 [[audits.ittapi]]
 who = "Andrew Brown <andrew.brown@intel.com>"
 criteria = "safe-to-deploy"
@@ -1457,6 +1838,11 @@ criteria = "safe-to-deploy"
 delta = "0.3.1 -> 0.3.3"
 notes = "I am the author of this crate."
 
+[[audits.ittapi]]
+who = "rahulchaphalkar <rahul.s.chaphalkar@intel.com>"
+criteria = "safe-to-deploy"
+delta = "0.3.4 -> 0.4.0"
+
 [[audits.ittapi-sys]]
 who = "Andrew Brown <andrew.brown@intel.com>"
 criteria = "safe-to-deploy"
@@ -1468,6 +1854,16 @@ criteria = "safe-to-deploy"
 delta = "0.3.1 -> 0.3.3"
 notes = "Unsafe code is due to auto-generated bindings to a widely-deployed C library."
 
+[[audits.ittapi-sys]]
+who = "rahulchaphalkar <rahul.s.chaphalkar@intel.com>"
+criteria = "safe-to-deploy"
+delta = "0.3.4 -> 0.4.0"
+
+[[audits.jobserver]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+delta = "0.1.25 -> 0.1.32"
+
 [[audits.leb128]]
 who = "Nick Fitzgerald <fitzgen@gmail.com>"
 criteria = "safe-to-deploy"
@@ -1496,6 +1892,24 @@ criteria = "safe-to-deploy"
 delta = "0.2.146 -> 0.2.147"
 notes = "Only new type definitions and updating others for some platforms, no major changes"
 
+[[audits.libc]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+delta = "0.2.148 -> 0.2.149"
+notes = "Lots of new functions and constants for new platforms and nothing out of the ordinary for what one would expect of the `libc` crate."
+
+[[audits.libc]]
+who = "Dan Gohman <dev@sunfishcode.online>"
+criteria = "safe-to-deploy"
+delta = "0.2.149 -> 0.2.151"
+notes = "More new functions, types, and constants, as is usual for the `libc` crate, as well as various minor code cleanups."
+
+[[audits.libc]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+delta = "0.2.151 -> 0.2.153"
+notes = "More bindings for more platforms. I have not verified that everything is exactly as-is on the platform as specified but nothing major is otherwise introduced as part of this bump."
+
 [[audits.libfuzzer-sys]]
 who = "Nick Fitzgerald <fitzgen@gmail.com>"
 criteria = "safe-to-run"
@@ -1508,6 +1922,11 @@ criteria = "safe-to-run"
 delta = "0.4.4 -> 0.4.5"
 notes = "I am the author of this crate."
 
+[[audits.libloading]]
+who = "Iceber Gu <caiwei95@hotmail.com>"
+criteria = "safe-to-deploy"
+delta = "0.7.3 -> 0.8.1"
+
 [[audits.libm]]
 who = "Alex Crichton <alex@alexcrichton.com>"
 criteria = "safe-to-deploy"
@@ -1527,6 +1946,12 @@ This is a minor update which has some testing affordances as well as some
 updated math algorithms.
 """
 
+[[audits.libtest-mimic]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-run"
+delta = "0.6.1 -> 0.7.0"
+notes = "Only minor changes with new flags and such, no major updates to `unsafe` or anything outside of a test framework."
+
 [[audits.linux-raw-sys]]
 who = "Dan Gohman <dev@sunfishcode.online>"
 criteria = "safe-to-deploy"
@@ -1539,6 +1964,12 @@ criteria = "safe-to-deploy"
 version = "0.3.3"
 notes = "I am the author of this crate."
 
+[[audits.mach2]]
+who = "Nick Fitzgerald <fitzgen@gmail.com>"
+criteria = "safe-to-deploy"
+delta = "0.4.1 -> 0.4.2"
+notes = "It does unsafe FFI bindings, as expected. I didn't check the FFI bindings against the C headers."
+
 [[audits.matchers]]
 who = "Pat Hickey <phickey@fastly.com>"
 criteria = "safe-to-deploy"
@@ -1569,6 +2000,12 @@ criteria = "safe-to-deploy"
 delta = "0.6.2 -> 0.6.3"
 notes = "Just a dependency version bump and documentation update"
 
+[[audits.memfd]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+delta = "0.6.3 -> 0.6.4"
+notes = "This commit only updated the dependency `rustix`, so same as before."
+
 [[audits.memoffset]]
 who = "Alex Crichton <alex@alexcrichton.com>"
 criteria = "safe-to-deploy"
@@ -1626,6 +2063,24 @@ criteria = "safe-to-deploy"
 version = "0.2.11"
 notes = "build is only looking for environment variables to set cfg. only two minor uses of unsafe,on macos, with ffi bindings to digest primitives and libc atexit. otherwise, this is an abstraction over three very complex systems (schannel, security-framework, and openssl) which may end up having subtle differences, but none of those are apparent from the implementation of this crate"
 
+[[audits.nu-ansi-term]]
+who = "Pat Hickey <phickey@fastly.com>"
+criteria = "safe-to-deploy"
+version = "0.46.0"
+notes = "one use of unsafe to call windows specific api to get console handle."
+
+[[audits.num-traits]]
+who = "Andrew Brown <andrew.brown@intel.com>"
+criteria = "safe-to-deploy"
+version = "0.2.19"
+notes = "As advertised: a numeric library. The only `unsafe` is from some float-to-int conversions, which seems expected."
+
+[[audits.num_cpus]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+delta = "1.15.0 -> 1.16.0"
+notes = "Some minor platform updates but no major change to any code."
+
 [[audits.object]]
 who = "Chris Fallin <chris@cfallin.org>"
 criteria = "safe-to-deploy"
@@ -1652,6 +2107,15 @@ criteria = "safe-to-deploy"
 delta = "0.31.1 -> 0.32.0"
 notes = "Various new features and refactorings as one would expect from an object parsing crate, all looks good."
 
+[[audits.object]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+delta = "0.32.0 -> 0.33.0"
+notes = """
+No `unsafe` code in this update. Lots of changes but all
+object-file-format-related, everything looks good.
+"""
+
 [[audits.once_cell]]
 who = "Chris Fallin <chris@cfallin.org>"
 criteria = "safe-to-deploy"
@@ -1681,6 +2145,16 @@ who = "Andrew Brown <andrew.brown@intel.com>"
 criteria = "safe-to-deploy"
 delta = "0.4.2 -> 0.5.0"
 
+[[audits.openvino]]
+who = "Iceber Gu <caiwei95@hotmail.com>"
+criteria = "safe-to-deploy"
+delta = "0.5.0 -> 0.6.0"
+
+[[audits.openvino]]
+who = "Andrew Brown <andrew.brown@intel.com>"
+criteria = "safe-to-deploy"
+delta = "0.6.0 -> 0.7.2"
+
 [[audits.openvino-finder]]
 who = "Matthew Tamayo-Rios <matthew@geekbeast.com>"
 criteria = "safe-to-deploy"
@@ -1694,6 +2168,16 @@ who = "Andrew Brown <andrew.brown@intel.com>"
 criteria = "safe-to-deploy"
 delta = "0.4.2 -> 0.5.0"
 
+[[audits.openvino-finder]]
+who = "Iceber Gu <caiwei95@hotmail.com>"
+criteria = "safe-to-deploy"
+delta = "0.5.0 -> 0.6.0"
+
+[[audits.openvino-finder]]
+who = "Andrew Brown <andrew.brown@intel.com>"
+criteria = "safe-to-deploy"
+delta = "0.6.0 -> 0.7.2"
+
 [[audits.openvino-sys]]
 who = "Matthew Tamayo-Rios <matthew@geekbeast.com>"
 criteria = "safe-to-deploy"
@@ -1707,6 +2191,46 @@ who = "Andrew Brown <andrew.brown@intel.com>"
 criteria = "safe-to-deploy"
 delta = "0.4.2 -> 0.5.0"
 
+[[audits.openvino-sys]]
+who = "Iceber Gu <caiwei95@hotmail.com>"
+criteria = "safe-to-deploy"
+delta = "0.5.0 -> 0.6.0"
+
+[[audits.openvino-sys]]
+who = "Andrew Brown <andrew.brown@intel.com>"
+criteria = "safe-to-deploy"
+delta = "0.6.0 -> 0.7.2"
+
+[[audits.ort]]
+who = "Andrew Brown <andrew.brown@intel.com>"
+criteria = "safe-to-deploy"
+version = "2.0.0-rc.0"
+notes = "As expected, this crate uses `unsafe` to access the `unsafe` `ort-sys` FFI functions; it also includes several `unsafe` implementations of `Send` for several structures. With the `load-dynamic` feature enabled, this crate will be `libloading` external libraries to call FFI functions. With the `fetch-models` feature enabled, this crate can also download arbitrary models to the local filesystem."
+
+[[audits.ort]]
+who = "Andrew Brown <andrew.brown@intel.com>"
+criteria = "safe-to-deploy"
+delta = "2.0.0-rc.0 -> 2.0.0-rc.2"
+notes = "Same as previous audit: the crate inherently uses `unsafe` FFI calls for using ONNX through `ort-sys` (e.g., logging C error strings). The changes are relatively uninteresting: a lot of documentation, some `must_use`, and general refactoring due to changes in the underlying API."
+
+[[audits.ort-sys]]
+who = "Andrew Brown <andrew.brown@intel.com>"
+criteria = "safe-to-deploy"
+version = "2.0.0-rc.0"
+notes = "As expected, this crate contains a significant number of `unsafe` definitions to expose the FFI surface of the ONNX libraries. Perhaps surprisingly, it also contains some `unsafe` system calls to locate the user's home directory. Another interesting bit is the `build.rs` script: with the `download-binaries` feature enabled, this script will retrieve and link various ONNX libraries from https://parcel.pyke.io. This seems par for the course with this kind of library, though; the alternative--attempting to find the library on an arbitrary system--can be quite complex."
+
+[[audits.ort-sys]]
+who = "Andrew Brown <andrew.brown@intel.com>"
+criteria = "safe-to-deploy"
+delta = "2.0.0-rc.0 -> 2.0.0-rc.2"
+notes = "This crate still downloads the ONNX libraries as a part of the `build.rs` script; now with more platform options for pre-built binaries stored in a `dist.txt` file. Otherwise largely unchanged since the previous audit."
+
+[[audits.overload]]
+who = "Pat Hickey <phickey@fastly.com>"
+criteria = "safe-to-deploy"
+version = "0.1.1"
+notes = "small crate, only defines macro-rules!, nicely documented as well"
+
 [[audits.peeking_take_while]]
 who = "Nick Fitzgerald <fitzgen@gmail.com>"
 criteria = "safe-to-deploy"
@@ -1723,6 +2247,12 @@ a few `unsafe` blocks related to utf-8 validation which are locally verifiable
 as correct and otherwise this crate is good to go.
 """
 
+[[audits.pin-project-lite]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+delta = "0.2.13 -> 0.2.14"
+notes = "No substantive changes in this update"
+
 [[audits.pin-utils]]
 who = "Pat Hickey <phickey@fastly.com>"
 criteria = "safe-to-deploy"
@@ -1734,6 +2264,24 @@ criteria = "safe-to-deploy"
 version = "0.3.25"
 notes = "This crate shells out to the pkg-config executable, but it appears to sanitize inputs reasonably."
 
+[[audits.pkg-config]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+delta = "0.3.26 -> 0.3.29"
+notes = """
+No `unsafe` additions or anything outside of the purview of the crate in this
+change.
+"""
+
+[[audits.postcard]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+version = "1.0.8"
+notes = """
+I've audited the unsafe code to do what it looks like it's doing. Otherwise the
+crate is a standard serializer/deserializer crate.
+"""
+
 [[audits.pretty_env_logger]]
 who = "Alex Crichton <alex@alexcrichton.com>"
 criteria = "safe-to-deploy"
@@ -1841,6 +2389,11 @@ criteria = "safe-to-deploy"
 version = "0.1.21"
 notes = "I am the author of this crate."
 
+[[audits.rustc-demangle]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+delta = "0.1.21 -> 0.1.24"
+
 [[audits.rustix]]
 who = "Dan Gohman <dev@sunfishcode.online>"
 criteria = "safe-to-deploy"
@@ -1876,6 +2429,12 @@ who = "Pat Hickey <phickey@fastly.com>"
 criteria = "safe-to-deploy"
 delta = "0.21.0 -> 0.21.6"
 
+[[audits.rustls]]
+who = "Andrew Brown <andrew.brown@intel.com>"
+criteria = "safe-to-deploy"
+delta = "0.22.4 -> 0.23.7"
+notes = "No new unsafe code."
+
 [[audits.rustls-webpki]]
 who = "Pat Hickey <phickey@fastly.com>"
 criteria = "safe-to-deploy"
@@ -1898,12 +2457,23 @@ criteria = "safe-to-deploy"
 version = "1.0.17"
 notes = "plenty of unsafe pointer and vec tricks, but in well-structured and commented code that appears to be correct"
 
+[[audits.sha1_smol]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+version = "1.0.1"
+
 [[audits.sha2]]
 who = "Benjamin Bouvier <public@benj.me>"
 criteria = "safe-to-deploy"
 delta = "0.9.9 -> 0.10.2"
 notes = "This upgrade is mostly a code refactor, as far as I can tell. No new uses of unsafe nor any new ambient capabilities usage."
 
+[[audits.sharded-slab]]
+who = "Pat Hickey <phickey@fastly.com>"
+criteria = "safe-to-deploy"
+version = "0.1.4"
+notes = "I always really enjoy reading eliza's code, she left perfect comments at every use of unsafe."
+
 [[audits.signal-hook-registry]]
 who = "Pat Hickey <phickey@fastly.com>"
 criteria = "safe-to-deploy"
@@ -1944,6 +2514,11 @@ criteria = "safe-to-deploy"
 delta = "0.4.7 -> 0.4.9"
 notes = "Minor OS compat updates but otherwise nothing major here."
 
+[[audits.socket2]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+delta = "0.4.9 -> 0.4.4"
+
 [[audits.spin]]
 who = "Alex Crichton <alex@alexcrichton.com>"
 criteria = "safe-to-run"
@@ -1966,6 +2541,12 @@ but it's all doing what it says on the tin: being a stable polyfill for strict
 provenance APIs in the standard library while they're on Nightly.
 """
 
+[[audits.static_assertions]]
+who = "Andrew Brown <andrew.brown@intel.com>"
+criteria = "safe-to-deploy"
+version = "1.1.0"
+notes = "No dependencies and completely a compile-time crate as advertised. Uses `unsafe` in one module as a compile-time check only: `mem::transmute` and `ptr::write` are wrapped in an impossible-to-run closure."
+
 [[audits.syn]]
 who = "Pat Hickey <phickey@fastly.com>"
 criteria = "safe-to-deploy"
@@ -2012,11 +2593,23 @@ criteria = "safe-to-deploy"
 delta = "3.5.0 -> 3.6.0"
 notes = "Dependency updates and new optimized trait implementations, but otherwise everything looks normal."
 
+[[audits.terminal_size]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+delta = "0.1.17 -> 0.2.6"
+notes = "Minor updates around using some utilities from the standard library, nothing major."
+
 [[audits.test-log]]
 who = "Pat Hickey <phickey@fastly.com>"
 criteria = "safe-to-deploy"
 version = "0.2.11"
 
+[[audits.thread_local]]
+who = "Pat Hickey <phickey@fastly.com>"
+criteria = "safe-to-deploy"
+version = "1.1.4"
+notes = "uses unsafe to implement thread local storage of objects"
+
 [[audits.tinyvec]]
 who = "Alex Crichton <alex@alexcrichton.com>"
 criteria = "safe-to-deploy"
@@ -2096,6 +2689,20 @@ This is a relatively minor set of releases with minor refactorings and bug
 fixes. Nothing fundamental was added in these changes.
 """
 
+[[audits.tracing-log]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+version = "0.1.3"
+notes = """
+This is a standard adapter between the `log` ecosystem and the `tracing`
+ecosystem. There's one `unsafe` block in this crate and it's well-scoped.
+"""
+
+[[audits.tracing-subscriber]]
+who = "Pat Hickey <phickey@fastly.com>"
+criteria = "safe-to-deploy"
+version = "0.3.17"
+
 [[audits.tracing-subscriber]]
 who = "Alex Crichton <alex@alexcrichton.com>"
 criteria = "safe-to-run"
@@ -2147,6 +2754,18 @@ throughout the ecosystem and skimming the crate shows no usage of `std::*` APIs
 and nothing suspicious.
 """
 
+[[audits.ureq]]
+who = "Andrew Brown <andrew.brown@intel.com>"
+criteria = "safe-to-deploy"
+version = "2.9.1"
+notes = "As advertised, the crate is a blocking HTTP client library; it uses no `unsafe`. Security-conscious users might want to audit its dependencies for crypto-related functionality (e.g., TLS)."
+
+[[audits.ureq]]
+who = "Andrew Brown <andrew.brown@intel.com>"
+criteria = "safe-to-deploy"
+delta = "2.9.6 -> 2.10.0"
+notes = "No `unsafe` changes; this audit observed mainly license and documentation changes."
+
 [[audits.url]]
 who = "Alex Crichton <alex@alexcrichton.com>"
 criteria = "safe-to-deploy"
@@ -2177,6 +2796,12 @@ who = "Pat Hickey <phickey@fastly.com>"
 criteria = "safe-to-deploy"
 version = "0.3.0"
 
+[[audits.wasi-nn]]
+who = "Andrew Brown <andrew.brown@intel.com>"
+criteria = "safe-to-deploy"
+version = "0.6.0"
+notes = "This crate contains `unsafe` code due to its purpose: it wraps up `witx-bindgen`-generated code that calls the raw wasi-nn API."
+
 [[audits.wasm-bindgen-shared]]
 who = "Pat Hickey <phickey@fastly.com>"
 criteria = "safe-to-deploy"
@@ -2827,6 +3452,18 @@ who = "Pat Hickey <phickey@fastly.com>"
 criteria = "safe-to-deploy"
 delta = "0.23.0 -> 0.25.2"
 
+[[audits.which]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-run"
+delta = "4.4.0 -> 5.0.0"
+notes = "Only one `unsafe` block, it's what a `which` crate is expected to be."
+
+[[audits.windows-implement]]
+who = "Andrew Brown <andrew.brown@intel.com>"
+criteria = "safe-to-deploy"
+version = "0.52.0"
+notes = "Procedural macros for accessing COM interfaces; necessarily `unsafe` but safety rationale is clearly documented."
+
 [[audits.winx]]
 who = "Dan Gohman <dev@sunfishcode.online>"
 criteria = "safe-to-deploy"
@@ -2893,6 +3530,37 @@ criteria = "safe-to-deploy"
 version = "0.6.4"
 notes = "The Bytecode Alliance is the author of this crate."
 
+[[audits.xattr]]
+who = "Andrew Brown <andrew.brown@intel.com>"
+criteria = "safe-to-deploy"
+version = "1.2.0"
+notes = "This crate contains `unsafe` calls to libc `extattr_*` functions as one would expect from the crate's purpose."
+
+[[audits.xattr]]
+who = "Andrew Brown <andrew.brown@intel.com>"
+criteria = "safe-to-deploy"
+delta = "1.2.0 -> 1.3.1"
+notes = "Minor changes to MacOS-specific code."
+
+[[audits.zstd]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+delta = "0.11.1+zstd.1.5.2 -> 0.13.0"
+notes = """
+No major updates to the crate here. Small updates to `unsafe` code which are
+refactorings of what was there prior.
+"""
+
+[[audits.zstd-safe]]
+who = "Alex Crichton <alex@alexcrichton.com>"
+criteria = "safe-to-deploy"
+delta = "5.0.1+zstd.1.5.2 -> 7.0.0"
+notes = """
+Lots of new comments around methods and refactorings for updates in zstd itself.
+Does contain new unsafe code, notably an implementation of an internal trait for
+the standard library `io::Cursor` type.
+"""
+
 [[trusted.aho-corasick]]
 criteria = "safe-to-deploy"
 user-id = 189 # Andrew Gallant (BurntSushi)
@@ -2959,6 +3627,12 @@ user-id = 189 # Andrew Gallant (BurntSushi)
 start = "2019-06-09"
 end = "2024-07-15"
 
+[[trusted.bytes]]
+criteria = "safe-to-deploy"
+user-id = 6741 # Alice Ryhl (Darksonn)
+start = "2021-01-11"
+end = "2025-02-15"
+
 [[trusted.cap-fs-ext]]
 criteria = "safe-to-deploy"
 user-id = 6825 # Dan Gohman (sunfishcode)
@@ -3025,12 +3699,36 @@ user-id = 6743 # Ed Page (epage)
 start = "2022-04-15"
 end = "2024-07-06"
 
+[[trusted.cpp_demangle]]
+criteria = "safe-to-deploy"
+user-id = 696 # Nick Fitzgerald (fitzgen)
+start = "2019-07-30"
+end = "2025-02-12"
+
+[[trusted.cranelift-bitset]]
+criteria = "safe-to-deploy"
+user-id = 73222 # wasmtime-publish
+start = "2024-07-22"
+end = "2025-07-30"
+
+[[trusted.dlmalloc]]
+criteria = "safe-to-deploy"
+user-id = 1 # Alex Crichton (alexcrichton)
+start = "2020-05-19"
+end = "2025-02-23"
+
 [[trusted.equivalent]]
 criteria = "safe-to-deploy"
 user-id = 539 # Josh Stone (cuviper)
 start = "2023-02-05"
 end = "2024-07-11"
 
+[[trusted.errno]]
+criteria = "safe-to-deploy"
+user-id = 6825 # Dan Gohman (sunfishcode)
+start = "2023-08-29"
+end = "2024-11-14"
+
 [[trusted.fd-lock]]
 criteria = "safe-to-deploy"
 user-id = 6825 # Dan Gohman (sunfishcode)
@@ -3043,6 +3741,18 @@ user-id = 6825 # Dan Gohman (sunfishcode)
 start = "2020-03-17"
 end = "2024-07-14"
 
+[[trusted.filetime]]
+criteria = "safe-to-deploy"
+user-id = 1 # Alex Crichton (alexcrichton)
+start = "2019-04-23"
+end = "2025-02-15"
+
+[[trusted.flate2]]
+criteria = "safe-to-deploy"
+user-id = 4333 # Josh Triplett (joshtriplett)
+start = "2020-09-30"
+end = "2025-02-15"
+
 [[trusted.fs-set-times]]
 criteria = "safe-to-deploy"
 user-id = 6825 # Dan Gohman (sunfishcode)
@@ -3133,6 +3843,24 @@ user-id = 3618 # David Tolnay (dtolnay)
 start = "2019-03-19"
 end = "2024-07-06"
 
+[[trusted.prettyplease]]
+criteria = "safe-to-deploy"
+user-id = 3618 # David Tolnay (dtolnay)
+start = "2022-01-04"
+end = "2025-05-06"
+
+[[trusted.proc-macro2]]
+criteria = "safe-to-deploy"
+user-id = 3618 # David Tolnay (dtolnay)
+start = "2019-04-23"
+end = "2025-05-06"
+
+[[trusted.pulley-interpreter]]
+criteria = "safe-to-deploy"
+user-id = 696 # Nick Fitzgerald (fitzgen)
+start = "2024-07-30"
+end = "2025-08-08"
+
 [[trusted.quote]]
 criteria = "safe-to-deploy"
 user-id = 3618 # David Tolnay (dtolnay)
@@ -3199,6 +3927,12 @@ user-id = 3618 # David Tolnay (dtolnay)
 start = "2019-02-28"
 end = "2024-07-06"
 
+[[trusted.serde_spanned]]
+criteria = "safe-to-deploy"
+user-id = 6743 # Ed Page (epage)
+start = "2023-01-20"
+end = "2025-02-12"
+
 [[trusted.syn]]
 criteria = "safe-to-deploy"
 user-id = 3618 # David Tolnay (dtolnay)
@@ -3211,12 +3945,24 @@ user-id = 6825 # Dan Gohman (sunfishcode)
 start = "2020-10-27"
 end = "2024-07-14"
 
+[[trusted.tar]]
+criteria = "safe-to-deploy"
+user-id = 1 # Alex Crichton (alexcrichton)
+start = "2019-03-04"
+end = "2025-02-15"
+
 [[trusted.target-lexicon]]
 criteria = "safe-to-deploy"
 user-id = 6825 # Dan Gohman (sunfishcode)
 start = "2019-03-06"
 end = "2024-07-14"
 
+[[trusted.target-lexicon]]
+criteria = "safe-to-deploy"
+user-id = 696 # Nick Fitzgerald (fitzgen)
+start = "2024-07-30"
+end = "2025-07-30"
+
 [[trusted.termcolor]]
 criteria = "safe-to-deploy"
 user-id = 189 # Andrew Gallant (BurntSushi)
@@ -3241,6 +3987,24 @@ user-id = 1 # Alex Crichton (alexcrichton)
 start = "2019-05-16"
 end = "2024-07-06"
 
+[[trusted.toml]]
+criteria = "safe-to-deploy"
+user-id = 6743 # Ed Page (epage)
+start = "2022-12-14"
+end = "2025-02-12"
+
+[[trusted.toml_datetime]]
+criteria = "safe-to-deploy"
+user-id = 6743 # Ed Page (epage)
+start = "2022-10-21"
+end = "2025-02-12"
+
+[[trusted.toml_edit]]
+criteria = "safe-to-deploy"
+user-id = 6743 # Ed Page (epage)
+start = "2021-09-13"
+end = "2025-02-12"
+
 [[trusted.walkdir]]
 criteria = "safe-to-deploy"
 user-id = 189 # Andrew Gallant (BurntSushi)
@@ -3277,18 +4041,30 @@ user-id = 1 # Alex Crichton (alexcrichton)
 start = "2019-03-04"
 end = "2024-07-14"
 
-[[trusted.wasmtime-wmemcheck]]
-criteria = "safe-to-deploy"
-user-id = 73222 # wasmtime-publish
-start = "2023-09-20"
-end = "2024-09-27"
-
 [[trusted.winapi-util]]
 criteria = "safe-to-deploy"
 user-id = 189 # Andrew Gallant (BurntSushi)
 start = "2020-01-11"
 end = "2024-07-15"
 
+[[trusted.windows]]
+criteria = "safe-to-deploy"
+user-id = 64539 # Kenny Kerr (kennykerr)
+start = "2021-01-15"
+end = "2025-01-30"
+
+[[trusted.windows-core]]
+criteria = "safe-to-deploy"
+user-id = 64539 # Kenny Kerr (kennykerr)
+start = "2021-11-15"
+end = "2025-01-02"
+
+[[trusted.windows-interface]]
+criteria = "safe-to-deploy"
+user-id = 64539 # Kenny Kerr (kennykerr)
+start = "2022-02-18"
+end = "2025-08-07"
+
 [[trusted.windows-sys]]
 criteria = "safe-to-deploy"
 user-id = 64539 # Kenny Kerr (kennykerr)
@@ -3343,8 +4119,20 @@ user-id = 64539 # Kenny Kerr (kennykerr)
 start = "2021-10-27"
 end = "2024-06-17"
 
+[[trusted.winnow]]
+criteria = "safe-to-deploy"
+user-id = 6743 # Ed Page (epage)
+start = "2023-02-22"
+end = "2025-02-12"
+
 [[trusted.winx]]
 criteria = "safe-to-deploy"
 user-id = 6825 # Dan Gohman (sunfishcode)
 start = "2019-08-20"
 end = "2024-07-14"
+
+[[trusted.witx]]
+criteria = "safe-to-deploy"
+user-id = 1 # Alex Crichton (alexcrichton)
+start = "2021-06-22"
+end = "2025-02-22"
diff --git a/supply-chain/config.toml b/supply-chain/config.toml
index 429251b49472..092792af92af 100644
--- a/supply-chain/config.toml
+++ b/supply-chain/config.toml
@@ -2,7 +2,7 @@
 # cargo-vet config file
 
 [cargo-vet]
-version = "0.8"
+version = "0.9"
 
 [imports.embark-studios]
 url = "https://raw.githubusercontent.com/EmbarkStudios/rust-ecosystem/main/audits.toml"
@@ -28,6 +28,9 @@ audit-as-crates-io = true
 [policy.cranelift-bforest]
 audit-as-crates-io = true
 
+[policy.cranelift-bitset]
+audit-as-crates-io = true
+
 [policy.cranelift-codegen]
 audit-as-crates-io = true
 
@@ -46,6 +49,9 @@ audit-as-crates-io = true
 [policy.cranelift-frontend]
 audit-as-crates-io = true
 
+[policy.cranelift-fuzzgen]
+criteria = []
+
 [policy.cranelift-interpreter]
 audit-as-crates-io = true
 
@@ -74,15 +80,15 @@ audit-as-crates-io = true
 audit-as-crates-io = true
 
 [policy.isle-fuzz]
-criteria = "safe-to-run"
+criteria = []
 
-[policy.wasi-cap-std-sync]
+[policy.pulley-interpreter]
 audit-as-crates-io = true
 
-[policy.wasi-common]
-audit-as-crates-io = true
+[policy.pulley-interpreter-fuzz]
+criteria = []
 
-[policy.wasi-tokio]
+[policy.wasi-common]
 audit-as-crates-io = true
 
 [policy.wasmtime]
@@ -91,6 +97,12 @@ audit-as-crates-io = true
 [policy.wasmtime-asm-macros]
 audit-as-crates-io = true
 
+[policy.wasmtime-c-api-impl]
+audit-as-crates-io = false
+
+[policy.wasmtime-c-api-macros]
+audit-as-crates-io = false
+
 [policy.wasmtime-cache]
 audit-as-crates-io = true
 
@@ -109,14 +121,11 @@ audit-as-crates-io = true
 [policy.wasmtime-cranelift]
 audit-as-crates-io = true
 
-[policy.wasmtime-cranelift-shared]
-audit-as-crates-io = true
-
 [policy.wasmtime-environ]
 audit-as-crates-io = true
 
 [policy.wasmtime-environ-fuzz]
-criteria = "safe-to-run"
+criteria = []
 
 [policy.wasmtime-explorer]
 audit-as-crates-io = true
@@ -125,13 +134,10 @@ audit-as-crates-io = true
 audit-as-crates-io = true
 
 [policy.wasmtime-fuzz]
-criteria = "safe-to-run"
+criteria = []
 
 [policy.wasmtime-fuzzing]
-criteria = "safe-to-run"
-
-[policy.wasmtime-jit]
-audit-as-crates-io = true
+criteria = []
 
 [policy.wasmtime-jit-debug]
 audit-as-crates-io = true
@@ -139,7 +145,7 @@ audit-as-crates-io = true
 [policy.wasmtime-jit-icache-coherence]
 audit-as-crates-io = true
 
-[policy.wasmtime-runtime]
+[policy.wasmtime-slab]
 audit-as-crates-io = true
 
 [policy.wasmtime-types]
@@ -154,9 +160,15 @@ audit-as-crates-io = true
 [policy.wasmtime-wasi-http]
 audit-as-crates-io = true
 
+[policy.wasmtime-wasi-keyvalue]
+audit-as-crates-io = true
+
 [policy.wasmtime-wasi-nn]
 audit-as-crates-io = true
 
+[policy.wasmtime-wasi-runtime-config]
+audit-as-crates-io = true
+
 [policy.wasmtime-wasi-threads]
 audit-as-crates-io = true
 
@@ -187,41 +199,26 @@ audit-as-crates-io = true
 [policy.winch-codegen]
 audit-as-crates-io = true
 
-[policy.witx]
-audit-as-crates-io = false
-
 [[exemptions.addr2line]]
 version = "0.17.0"
 criteria = "safe-to-deploy"
 
 [[exemptions.ahash]]
-version = "0.7.6"
-criteria = "safe-to-deploy"
-
-[[exemptions.bincode]]
-version = "1.3.3"
+version = "0.8.11"
 criteria = "safe-to-deploy"
 
 [[exemptions.bitflags]]
 version = "1.3.2"
 criteria = "safe-to-deploy"
 
-[[exemptions.bytes]]
-version = "1.1.0"
-criteria = "safe-to-deploy"
-
 [[exemptions.capstone]]
-version = "0.9.0"
+version = "0.12.0"
 criteria = "safe-to-deploy"
 
 [[exemptions.capstone-sys]]
-version = "0.13.0"
+version = "0.16.0"
 criteria = "safe-to-deploy"
 
-[[exemptions.cast]]
-version = "0.2.7"
-criteria = "safe-to-run"
-
 [[exemptions.console]]
 version = "0.15.0"
 criteria = "safe-to-deploy"
@@ -246,10 +243,6 @@ criteria = "safe-to-run"
 version = "0.4.4"
 criteria = "safe-to-run"
 
-[[exemptions.crossbeam-channel]]
-version = "0.5.4"
-criteria = "safe-to-deploy"
-
 [[exemptions.crossbeam-deque]]
 version = "0.8.1"
 criteria = "safe-to-deploy"
@@ -270,30 +263,14 @@ criteria = "safe-to-deploy"
 version = "2.0.0"
 criteria = "safe-to-deploy"
 
-[[exemptions.dirs-next]]
-version = "2.0.0"
-criteria = "safe-to-deploy"
-
 [[exemptions.dirs-sys-next]]
 version = "0.1.2"
 criteria = "safe-to-deploy"
 
-[[exemptions.downcast-rs]]
-version = "1.2.0"
-criteria = "safe-to-run"
-
-[[exemptions.egg]]
-version = "0.6.0"
-criteria = "safe-to-run"
-
 [[exemptions.encode_unicode]]
 version = "0.3.6"
 criteria = "safe-to-deploy"
 
-[[exemptions.env_logger]]
-version = "0.7.1"
-criteria = "safe-to-deploy"
-
 [[exemptions.env_logger]]
 version = "0.9.0"
 criteria = "safe-to-deploy"
@@ -302,14 +279,6 @@ criteria = "safe-to-deploy"
 version = "0.2.0"
 criteria = "safe-to-deploy"
 
-[[exemptions.filetime]]
-version = "0.2.16"
-criteria = "safe-to-run"
-
-[[exemptions.fslock]]
-version = "0.1.8"
-criteria = "safe-to-run"
-
 [[exemptions.futures-task]]
 version = "0.3.27"
 criteria = "safe-to-deploy"
@@ -333,12 +302,7 @@ version = "0.26.1"
 criteria = "safe-to-deploy"
 
 [[exemptions.h2]]
-version = "0.3.19"
-criteria = "safe-to-deploy"
-notes = "we are exempting tokio, hyper, and their tightly coupled dependencies by the same authors, expecting that the authors at aws will publish attestions we can import at some point soon"
-
-[[exemptions.hermit-abi]]
-version = "0.1.19"
+version = "0.4.4"
 criteria = "safe-to-deploy"
 
 [[exemptions.hermit-abi]]
@@ -355,10 +319,6 @@ version = "1.8.0"
 criteria = "safe-to-deploy"
 notes = "we are exempting tokio, hyper, and their tightly coupled dependencies by the same authors, expecting that the authors at aws will publish attestions we can import at some point soon"
 
-[[exemptions.humantime]]
-version = "1.3.0"
-criteria = "safe-to-deploy"
-
 [[exemptions.humantime]]
 version = "2.1.0"
 criteria = "safe-to-deploy"
@@ -372,10 +332,6 @@ notes = "we are exempting tokio, hyper, and their tightly coupled dependencies b
 version = "0.13.0"
 criteria = "safe-to-deploy"
 
-[[exemptions.instant]]
-version = "0.1.12"
-criteria = "safe-to-deploy"
-
 [[exemptions.ipnet]]
 version = "2.5.0"
 criteria = "safe-to-deploy"
@@ -418,9 +374,8 @@ version = "0.6.5"
 criteria = "safe-to-deploy"
 
 [[exemptions.mio]]
-version = "0.8.6"
+version = "0.8.11"
 criteria = "safe-to-deploy"
-notes = "we are exempting tokio, hyper, and their tightly coupled dependencies by the same authors, expecting that the authors at aws will publish attestions we can import at some point soon"
 
 [[exemptions.num_cpus]]
 version = "1.13.1"
@@ -431,21 +386,9 @@ version = "0.3.0"
 criteria = "safe-to-deploy"
 
 [[exemptions.object]]
-version = "0.29.0"
+version = "0.36.0"
 criteria = "safe-to-deploy"
 
-[[exemptions.ocaml-boxroot-sys]]
-version = "0.2.0"
-criteria = "safe-to-run"
-
-[[exemptions.ocaml-interop]]
-version = "0.8.8"
-criteria = "safe-to-run"
-
-[[exemptions.ocaml-sys]]
-version = "0.22.3"
-criteria = "safe-to-run"
-
 [[exemptions.once_cell]]
 version = "1.12.0"
 criteria = "safe-to-deploy"
@@ -458,18 +401,6 @@ criteria = "safe-to-deploy"
 version = "0.4.1"
 criteria = "safe-to-deploy"
 
-[[exemptions.plotters]]
-version = "0.3.1"
-criteria = "safe-to-run"
-
-[[exemptions.plotters-backend]]
-version = "0.3.2"
-criteria = "safe-to-run"
-
-[[exemptions.plotters-svg]]
-version = "0.3.1"
-criteria = "safe-to-run"
-
 [[exemptions.ppv-lite86]]
 version = "0.2.16"
 criteria = "safe-to-deploy"
@@ -498,10 +429,6 @@ criteria = "safe-to-deploy"
 version = "0.8.5"
 criteria = "safe-to-deploy"
 
-[[exemptions.rand_chacha]]
-version = "0.3.1"
-criteria = "safe-to-deploy"
-
 [[exemptions.rand_xorshift]]
 version = "0.3.0"
 criteria = "safe-to-deploy"
@@ -510,10 +437,6 @@ criteria = "safe-to-deploy"
 version = "0.2.13"
 criteria = "safe-to-deploy"
 
-[[exemptions.redox_syscall]]
-version = "0.3.5"
-criteria = "safe-to-deploy"
-
 [[exemptions.redox_users]]
 version = "0.4.3"
 criteria = "safe-to-deploy"
@@ -523,18 +446,25 @@ version = "2.2.0"
 criteria = "safe-to-deploy"
 
 [[exemptions.ring]]
-version = "0.16.20"
+version = "0.17.3"
+criteria = "safe-to-deploy"
+
+[[exemptions.rustls]]
+version = "0.22.4"
+criteria = "safe-to-deploy"
+
+[[exemptions.rustls-pki-types]]
+version = "1.3.1"
+criteria = "safe-to-deploy"
+
+[[exemptions.rustls-webpki]]
+version = "0.102.2"
 criteria = "safe-to-deploy"
-notes = "contains assembly language and object file implementations of crypto primitives for a very large number of platforms"
 
 [[exemptions.rusty-fork]]
 version = "0.3.0"
 criteria = "safe-to-deploy"
 
-[[exemptions.sharded-slab]]
-version = "0.1.4"
-criteria = "safe-to-run"
-
 [[exemptions.shellexpand]]
 version = "2.1.0"
 criteria = "safe-to-deploy"
@@ -560,7 +490,7 @@ version = "2.1.0"
 criteria = "safe-to-deploy"
 
 [[exemptions.spin]]
-version = "0.5.2"
+version = "0.9.4"
 criteria = "safe-to-deploy"
 
 [[exemptions.stable_deref_trait]]
@@ -571,10 +501,6 @@ criteria = "safe-to-deploy"
 version = "0.10.0"
 criteria = "safe-to-deploy"
 
-[[exemptions.symbolic_expressions]]
-version = "5.0.3"
-criteria = "safe-to-run"
-
 [[exemptions.tempfile]]
 version = "3.3.0"
 criteria = "safe-to-deploy"
@@ -583,16 +509,8 @@ criteria = "safe-to-deploy"
 version = "0.1.17"
 criteria = "safe-to-deploy"
 
-[[exemptions.thread_local]]
-version = "1.1.4"
-criteria = "safe-to-run"
-
-[[exemptions.tinytemplate]]
-version = "1.2.1"
-criteria = "safe-to-run"
-
 [[exemptions.tokio]]
-version = "1.29.1"
+version = "1.30.0"
 criteria = "safe-to-deploy"
 notes = "we are exempting tokio, hyper, and their tightly coupled dependencies by the same authors, expecting that the authors at aws will publish attestions we can import at some point soon"
 
@@ -600,6 +518,10 @@ notes = "we are exempting tokio, hyper, and their tightly coupled dependencies b
 version = "1.7.0"
 criteria = "safe-to-deploy"
 
+[[exemptions.tokio-rustls]]
+version = "0.25.0"
+criteria = "safe-to-deploy"
+
 [[exemptions.tracing]]
 version = "0.1.34"
 criteria = "safe-to-deploy"
@@ -612,22 +534,22 @@ criteria = "safe-to-deploy"
 version = "0.1.28"
 criteria = "safe-to-deploy"
 
-[[exemptions.tracing-subscriber]]
-version = "0.3.11"
-criteria = "safe-to-run"
-
 [[exemptions.typenum]]
 version = "1.15.0"
 criteria = "safe-to-deploy"
 
+[[exemptions.untrusted]]
+version = "0.9.0"
+criteria = "safe-to-deploy"
+
+[[exemptions.ureq]]
+version = "2.9.6"
+criteria = "safe-to-deploy"
+
 [[exemptions.uuid]]
 version = "1.0.0"
 criteria = "safe-to-deploy"
 
-[[exemptions.v8]]
-version = "0.74.1"
-criteria = "safe-to-run"
-
 [[exemptions.wait-timeout]]
 version = "0.2.0"
 criteria = "safe-to-deploy"
@@ -641,9 +563,9 @@ version = "0.3.57"
 criteria = "safe-to-deploy"
 notes = "dependency of ring for wasm32 browser platform, which our project does not target"
 
-[[exemptions.which]]
-version = "4.2.5"
-criteria = "safe-to-run"
+[[exemptions.webpki-roots]]
+version = "0.26.1"
+criteria = "safe-to-deploy"
 
 [[exemptions.winapi]]
 version = "0.3.9"
@@ -657,6 +579,10 @@ criteria = "safe-to-deploy"
 version = "0.4.0"
 criteria = "safe-to-deploy"
 
+[[exemptions.zeroize]]
+version = "1.7.0"
+criteria = "safe-to-deploy"
+
 [[exemptions.zstd]]
 version = "0.11.1+zstd.1.5.2"
 criteria = "safe-to-deploy"
@@ -666,5 +592,5 @@ version = "5.0.1+zstd.1.5.2"
 criteria = "safe-to-deploy"
 
 [[exemptions.zstd-sys]]
-version = "2.0.1+zstd.1.5.2"
+version = "2.0.9+zstd.1.5.5"
 criteria = "safe-to-deploy"
diff --git a/supply-chain/imports.lock b/supply-chain/imports.lock
index c1301305ab8d..d7e34d94470b 100644
--- a/supply-chain/imports.lock
+++ b/supply-chain/imports.lock
@@ -2,396 +2,388 @@
 # cargo-vet imports lock
 
 [[unpublished.cranelift]]
-version = "0.100.0"
-audited_as = "0.98.1"
+version = "0.111.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift]]
-version = "0.101.0"
-audited_as = "0.99.1"
+version = "0.112.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-bforest]]
-version = "0.100.0"
-audited_as = "0.98.1"
+version = "0.111.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-bforest]]
-version = "0.101.0"
-audited_as = "0.99.1"
+version = "0.112.0"
+audited_as = "0.110.1"
+
+[[unpublished.cranelift-bitset]]
+version = "0.111.0"
+audited_as = "0.110.1"
+
+[[unpublished.cranelift-bitset]]
+version = "0.112.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-codegen]]
-version = "0.100.0"
-audited_as = "0.98.1"
+version = "0.111.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-codegen]]
-version = "0.101.0"
-audited_as = "0.99.1"
+version = "0.112.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-codegen-meta]]
-version = "0.100.0"
-audited_as = "0.98.1"
+version = "0.111.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-codegen-meta]]
-version = "0.101.0"
-audited_as = "0.99.1"
+version = "0.112.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-codegen-shared]]
-version = "0.100.0"
-audited_as = "0.98.1"
+version = "0.111.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-codegen-shared]]
-version = "0.101.0"
-audited_as = "0.99.1"
+version = "0.112.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-control]]
-version = "0.100.0"
-audited_as = "0.98.1"
+version = "0.111.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-control]]
-version = "0.101.0"
-audited_as = "0.99.1"
+version = "0.112.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-entity]]
-version = "0.100.0"
-audited_as = "0.98.1"
+version = "0.111.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-entity]]
-version = "0.101.0"
-audited_as = "0.99.1"
+version = "0.112.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-frontend]]
-version = "0.100.0"
-audited_as = "0.98.1"
+version = "0.111.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-frontend]]
-version = "0.101.0"
-audited_as = "0.99.1"
+version = "0.112.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-interpreter]]
-version = "0.100.0"
-audited_as = "0.98.1"
+version = "0.111.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-interpreter]]
-version = "0.101.0"
-audited_as = "0.99.1"
+version = "0.112.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-isle]]
-version = "0.100.0"
-audited_as = "0.98.1"
+version = "0.111.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-isle]]
-version = "0.101.0"
-audited_as = "0.99.1"
+version = "0.112.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-jit]]
-version = "0.100.0"
-audited_as = "0.98.1"
+version = "0.111.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-jit]]
-version = "0.101.0"
-audited_as = "0.99.1"
+version = "0.112.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-module]]
-version = "0.100.0"
-audited_as = "0.98.1"
+version = "0.111.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-module]]
-version = "0.101.0"
-audited_as = "0.99.1"
+version = "0.112.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-native]]
-version = "0.100.0"
-audited_as = "0.98.1"
+version = "0.111.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-native]]
-version = "0.101.0"
-audited_as = "0.99.1"
+version = "0.112.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-object]]
-version = "0.100.0"
-audited_as = "0.98.1"
+version = "0.111.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-object]]
-version = "0.101.0"
-audited_as = "0.99.1"
+version = "0.112.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-reader]]
-version = "0.100.0"
-audited_as = "0.98.1"
+version = "0.111.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-reader]]
-version = "0.101.0"
-audited_as = "0.99.1"
+version = "0.112.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-serde]]
-version = "0.100.0"
-audited_as = "0.98.1"
+version = "0.111.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-serde]]
-version = "0.101.0"
-audited_as = "0.99.1"
+version = "0.112.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-wasm]]
-version = "0.100.0"
-audited_as = "0.98.1"
+version = "0.111.0"
+audited_as = "0.110.1"
 
 [[unpublished.cranelift-wasm]]
-version = "0.101.0"
-audited_as = "0.99.1"
-
-[[unpublished.wasi-cap-std-sync]]
-version = "13.0.0"
-audited_as = "11.0.1"
+version = "0.112.0"
+audited_as = "0.110.1"
 
-[[unpublished.wasi-cap-std-sync]]
-version = "14.0.0"
-audited_as = "12.0.1"
+[[unpublished.pulley-interpreter]]
+version = "0.1.0"
+audited_as = "0.0.0"
 
 [[unpublished.wasi-common]]
-version = "13.0.0"
-audited_as = "11.0.1"
+version = "24.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasi-common]]
-version = "14.0.0"
-audited_as = "12.0.1"
-
-[[unpublished.wasi-tokio]]
-version = "13.0.0"
-audited_as = "11.0.1"
-
-[[unpublished.wasi-tokio]]
-version = "14.0.0"
-audited_as = "12.0.1"
+version = "25.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime]]
-version = "13.0.0"
-audited_as = "11.0.1"
+version = "24.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime]]
-version = "14.0.0"
-audited_as = "12.0.1"
+version = "25.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-asm-macros]]
-version = "13.0.0"
-audited_as = "11.0.1"
+version = "24.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-asm-macros]]
-version = "14.0.0"
-audited_as = "12.0.1"
+version = "25.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-cache]]
-version = "13.0.0"
-audited_as = "11.0.1"
+version = "24.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-cache]]
-version = "14.0.0"
-audited_as = "12.0.1"
+version = "25.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-cli]]
-version = "13.0.0"
-audited_as = "11.0.1"
+version = "24.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-cli]]
-version = "14.0.0"
-audited_as = "12.0.1"
+version = "25.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-cli-flags]]
-version = "13.0.0"
-audited_as = "11.0.1"
+version = "24.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-cli-flags]]
-version = "14.0.0"
-audited_as = "12.0.1"
+version = "25.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-component-macro]]
-version = "13.0.0"
-audited_as = "11.0.1"
+version = "24.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-component-macro]]
-version = "14.0.0"
-audited_as = "12.0.1"
+version = "25.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-component-util]]
-version = "13.0.0"
-audited_as = "11.0.1"
+version = "24.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-component-util]]
-version = "14.0.0"
-audited_as = "12.0.1"
+version = "25.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-cranelift]]
-version = "13.0.0"
-audited_as = "11.0.1"
+version = "24.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-cranelift]]
-version = "14.0.0"
-audited_as = "12.0.1"
-
-[[unpublished.wasmtime-cranelift-shared]]
-version = "13.0.0"
-audited_as = "11.0.1"
-
-[[unpublished.wasmtime-cranelift-shared]]
-version = "14.0.0"
-audited_as = "12.0.1"
+version = "25.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-environ]]
-version = "13.0.0"
-audited_as = "11.0.1"
+version = "24.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-environ]]
-version = "14.0.0"
-audited_as = "12.0.1"
+version = "25.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-explorer]]
-version = "13.0.0"
-audited_as = "11.0.1"
+version = "24.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-explorer]]
-version = "14.0.0"
-audited_as = "12.0.1"
+version = "25.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-fiber]]
-version = "13.0.0"
-audited_as = "11.0.1"
+version = "24.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-fiber]]
-version = "14.0.0"
-audited_as = "12.0.1"
-
-[[unpublished.wasmtime-jit]]
-version = "13.0.0"
-audited_as = "11.0.1"
-
-[[unpublished.wasmtime-jit]]
-version = "14.0.0"
-audited_as = "12.0.1"
+version = "25.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-jit-debug]]
-version = "13.0.0"
-audited_as = "11.0.1"
+version = "24.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-jit-debug]]
-version = "14.0.0"
-audited_as = "12.0.1"
+version = "25.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-jit-icache-coherence]]
-version = "13.0.0"
-audited_as = "11.0.1"
+version = "24.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-jit-icache-coherence]]
-version = "14.0.0"
-audited_as = "12.0.1"
+version = "25.0.0"
+audited_as = "23.0.1"
 
-[[unpublished.wasmtime-runtime]]
-version = "13.0.0"
-audited_as = "11.0.1"
+[[unpublished.wasmtime-slab]]
+version = "24.0.0"
+audited_as = "23.0.1"
 
-[[unpublished.wasmtime-runtime]]
-version = "14.0.0"
-audited_as = "12.0.1"
+[[unpublished.wasmtime-slab]]
+version = "25.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-types]]
-version = "13.0.0"
-audited_as = "11.0.1"
+version = "24.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-types]]
-version = "14.0.0"
-audited_as = "12.0.1"
+version = "25.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-wasi]]
-version = "13.0.0"
-audited_as = "11.0.1"
+version = "24.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-wasi]]
-version = "14.0.0"
-audited_as = "12.0.1"
+version = "25.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-wasi-http]]
-version = "13.0.0"
-audited_as = "11.0.1"
+version = "24.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-wasi-http]]
-version = "14.0.0"
-audited_as = "12.0.1"
+version = "25.0.0"
+audited_as = "23.0.1"
+
+[[unpublished.wasmtime-wasi-keyvalue]]
+version = "25.0.0"
+audited_as = "24.0.0"
 
 [[unpublished.wasmtime-wasi-nn]]
-version = "13.0.0"
-audited_as = "11.0.1"
+version = "24.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-wasi-nn]]
-version = "14.0.0"
-audited_as = "12.0.1"
+version = "25.0.0"
+audited_as = "23.0.1"
+
+[[unpublished.wasmtime-wasi-runtime-config]]
+version = "25.0.0"
+audited_as = "24.0.0"
 
 [[unpublished.wasmtime-wasi-threads]]
-version = "13.0.0"
-audited_as = "11.0.1"
+version = "24.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-wasi-threads]]
-version = "14.0.0"
-audited_as = "12.0.1"
+version = "25.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-wast]]
-version = "13.0.0"
-audited_as = "11.0.1"
+version = "24.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-wast]]
-version = "14.0.0"
-audited_as = "12.0.1"
+version = "25.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-winch]]
-version = "13.0.0"
-audited_as = "11.0.1"
+version = "24.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-winch]]
-version = "14.0.0"
-audited_as = "12.0.1"
+version = "25.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-wit-bindgen]]
-version = "13.0.0"
-audited_as = "11.0.1"
+version = "24.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-wit-bindgen]]
-version = "14.0.0"
-audited_as = "12.0.1"
+version = "25.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wasmtime-wmemcheck]]
-version = "14.0.0"
-audited_as = "13.0.0"
+version = "24.0.0"
+audited_as = "23.0.1"
+
+[[unpublished.wasmtime-wmemcheck]]
+version = "25.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wiggle]]
-version = "13.0.0"
-audited_as = "11.0.1"
+version = "24.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wiggle]]
-version = "14.0.0"
-audited_as = "12.0.1"
+version = "25.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wiggle-generate]]
-version = "13.0.0"
-audited_as = "11.0.1"
+version = "24.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wiggle-generate]]
-version = "14.0.0"
-audited_as = "12.0.1"
+version = "25.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wiggle-macro]]
-version = "13.0.0"
-audited_as = "11.0.1"
+version = "24.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wiggle-macro]]
-version = "14.0.0"
-audited_as = "12.0.1"
+version = "25.0.0"
+audited_as = "23.0.1"
 
 [[unpublished.wiggle-test]]
 version = "0.0.0"
 audited_as = "0.1.0"
 
 [[unpublished.winch-codegen]]
-version = "0.11.0"
-audited_as = "0.9.1"
+version = "0.22.0"
+audited_as = "0.21.1"
 
 [[unpublished.winch-codegen]]
-version = "0.12.0"
-audited_as = "0.10.1"
+version = "0.23.0"
+audited_as = "0.21.1"
 
 [[publisher.aho-corasick]]
 version = "1.0.2"
@@ -443,8 +435,8 @@ user-login = "dtolnay"
 user-name = "David Tolnay"
 
 [[publisher.arbitrary]]
-version = "1.3.0"
-when = "2023-03-13"
+version = "1.3.1"
+when = "2023-10-11"
 user-id = 696
 user-login = "fitzgen"
 user-name = "Nick Fitzgerald"
@@ -457,15 +449,8 @@ user-login = "dtolnay"
 user-name = "David Tolnay"
 
 [[publisher.backtrace]]
-version = "0.3.68"
-when = "2023-06-29"
-user-id = 2915
-user-login = "Amanieu"
-user-name = "Amanieu d'Antras"
-
-[[publisher.backtrace]]
-version = "0.3.69"
-when = "2023-08-22"
+version = "0.3.73"
+when = "2024-06-12"
 user-id = 2915
 user-login = "Amanieu"
 user-name = "Amanieu d'Antras"
@@ -478,8 +463,8 @@ user-login = "BurntSushi"
 user-name = "Andrew Gallant"
 
 [[publisher.bumpalo]]
-version = "3.12.0"
-when = "2023-01-17"
+version = "3.14.0"
+when = "2023-09-14"
 user-id = 696
 user-login = "fitzgen"
 user-name = "Nick Fitzgerald"
@@ -491,51 +476,51 @@ user-id = 189
 user-login = "BurntSushi"
 user-name = "Andrew Gallant"
 
+[[publisher.bytes]]
+version = "1.5.0"
+when = "2023-09-07"
+user-id = 6741
+user-login = "Darksonn"
+user-name = "Alice Ryhl"
+
 [[publisher.cap-fs-ext]]
-version = "2.0.0"
-when = "2023-06-30"
+version = "3.0.0"
+when = "2024-01-11"
 user-id = 6825
 user-login = "sunfishcode"
 user-name = "Dan Gohman"
 
 [[publisher.cap-net-ext]]
-version = "2.0.0"
-when = "2023-06-30"
+version = "3.0.0"
+when = "2024-01-11"
 user-id = 6825
 user-login = "sunfishcode"
 user-name = "Dan Gohman"
 
 [[publisher.cap-primitives]]
-version = "2.0.0"
-when = "2023-06-30"
+version = "3.0.0"
+when = "2024-01-11"
 user-id = 6825
 user-login = "sunfishcode"
 user-name = "Dan Gohman"
 
 [[publisher.cap-rand]]
-version = "2.0.0"
-when = "2023-06-30"
+version = "3.0.0"
+when = "2024-01-11"
 user-id = 6825
 user-login = "sunfishcode"
 user-name = "Dan Gohman"
 
 [[publisher.cap-std]]
-version = "2.0.0"
-when = "2023-06-30"
-user-id = 6825
-user-login = "sunfishcode"
-user-name = "Dan Gohman"
-
-[[publisher.cap-tempfile]]
-version = "2.0.0"
-when = "2023-06-30"
+version = "3.0.0"
+when = "2024-01-11"
 user-id = 6825
 user-login = "sunfishcode"
 user-name = "Dan Gohman"
 
 [[publisher.cap-time-ext]]
-version = "2.0.0"
-when = "2023-06-30"
+version = "3.0.0"
+when = "2024-01-11"
 user-id = 6825
 user-login = "sunfishcode"
 user-name = "Dan Gohman"
@@ -568,207 +553,118 @@ user-id = 6743
 user-login = "epage"
 user-name = "Ed Page"
 
-[[publisher.cranelift]]
-version = "0.98.1"
-when = "2023-07-24"
-user-id = 73222
-user-login = "wasmtime-publish"
+[[publisher.core-foundation-sys]]
+version = "0.8.4"
+when = "2023-04-03"
+user-id = 5946
+user-login = "jrmuizel"
+user-name = "Jeff Muizelaar"
 
 [[publisher.cranelift]]
-version = "0.99.1"
-when = "2023-08-24"
+version = "0.110.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.cranelift-bforest]]
-version = "0.98.1"
-when = "2023-07-24"
+version = "0.110.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
-[[publisher.cranelift-bforest]]
-version = "0.99.1"
-when = "2023-08-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.cranelift-codegen]]
-version = "0.98.1"
-when = "2023-07-24"
+[[publisher.cranelift-bitset]]
+version = "0.110.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.cranelift-codegen]]
-version = "0.99.1"
-when = "2023-08-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.cranelift-codegen-meta]]
-version = "0.98.1"
-when = "2023-07-24"
+version = "0.110.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.cranelift-codegen-meta]]
-version = "0.99.1"
-when = "2023-08-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.cranelift-codegen-shared]]
-version = "0.98.1"
-when = "2023-07-24"
+version = "0.110.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.cranelift-codegen-shared]]
-version = "0.99.1"
-when = "2023-08-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.cranelift-control]]
-version = "0.98.1"
-when = "2023-07-24"
+version = "0.110.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.cranelift-control]]
-version = "0.99.1"
-when = "2023-08-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.cranelift-entity]]
-version = "0.98.1"
-when = "2023-07-24"
+version = "0.110.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.cranelift-entity]]
-version = "0.99.1"
-when = "2023-08-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.cranelift-frontend]]
-version = "0.98.1"
-when = "2023-07-24"
+version = "0.110.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.cranelift-frontend]]
-version = "0.99.1"
-when = "2023-08-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.cranelift-interpreter]]
-version = "0.98.1"
-when = "2023-07-24"
+version = "0.110.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.cranelift-interpreter]]
-version = "0.99.1"
-when = "2023-08-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.cranelift-isle]]
-version = "0.98.1"
-when = "2023-07-24"
+version = "0.110.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.cranelift-isle]]
-version = "0.99.1"
-when = "2023-08-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.cranelift-jit]]
-version = "0.98.1"
-when = "2023-07-24"
+version = "0.110.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.cranelift-jit]]
-version = "0.99.1"
-when = "2023-08-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.cranelift-module]]
-version = "0.98.1"
-when = "2023-07-24"
+version = "0.110.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.cranelift-module]]
-version = "0.99.1"
-when = "2023-08-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.cranelift-native]]
-version = "0.98.1"
-when = "2023-07-24"
+version = "0.110.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.cranelift-native]]
-version = "0.99.1"
-when = "2023-08-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.cranelift-object]]
-version = "0.98.1"
-when = "2023-07-24"
+version = "0.110.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.cranelift-object]]
-version = "0.99.1"
-when = "2023-08-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.cranelift-reader]]
-version = "0.98.1"
-when = "2023-07-24"
+version = "0.110.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.cranelift-reader]]
-version = "0.99.1"
-when = "2023-08-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.cranelift-serde]]
-version = "0.98.1"
-when = "2023-07-24"
+version = "0.110.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.cranelift-serde]]
-version = "0.99.1"
-when = "2023-08-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.cranelift-wasm]]
-version = "0.98.1"
-when = "2023-07-24"
+version = "0.110.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.cranelift-wasm]]
-version = "0.99.1"
-when = "2023-08-24"
+version = "0.110.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
@@ -779,6 +675,13 @@ user-id = 696
 user-login = "fitzgen"
 user-name = "Nick Fitzgerald"
 
+[[publisher.dlmalloc]]
+version = "0.2.4"
+when = "2022-08-17"
+user-id = 1
+user-login = "alexcrichton"
+user-name = "Alex Crichton"
+
 [[publisher.equivalent]]
 version = "1.0.1"
 when = "2023-07-10"
@@ -786,9 +689,16 @@ user-id = 539
 user-login = "cuviper"
 user-name = "Josh Stone"
 
+[[publisher.errno]]
+version = "0.3.8"
+when = "2023-11-28"
+user-id = 6825
+user-login = "sunfishcode"
+user-name = "Dan Gohman"
+
 [[publisher.fd-lock]]
-version = "4.0.0"
-when = "2023-06-30"
+version = "4.0.2"
+when = "2023-12-29"
 user-id = 6825
 user-login = "sunfishcode"
 user-name = "Dan Gohman"
@@ -800,44 +710,65 @@ user-id = 6825
 user-login = "sunfishcode"
 user-name = "Dan Gohman"
 
+[[publisher.filetime]]
+version = "0.2.16"
+when = "2022-04-15"
+user-id = 1
+user-login = "alexcrichton"
+user-name = "Alex Crichton"
+
+[[publisher.flate2]]
+version = "1.0.26"
+when = "2023-04-28"
+user-id = 4333
+user-login = "joshtriplett"
+user-name = "Josh Triplett"
+
 [[publisher.fs-set-times]]
-version = "0.20.0"
-when = "2023-06-29"
+version = "0.20.1"
+when = "2023-12-01"
 user-id = 6825
 user-login = "sunfishcode"
 user-name = "Dan Gohman"
 
 [[publisher.hashbrown]]
-version = "0.14.0"
-when = "2023-06-05"
+version = "0.14.3"
+when = "2023-11-26"
 user-id = 2915
 user-login = "Amanieu"
 user-name = "Amanieu d'Antras"
 
 [[publisher.indexmap]]
-version = "1.9.1"
-when = "2022-06-21"
-user-id = 539
-user-login = "cuviper"
-user-name = "Josh Stone"
-
-[[publisher.indexmap]]
-version = "2.0.0"
-when = "2023-06-23"
+version = "2.2.6"
+when = "2024-03-23"
 user-id = 539
 user-login = "cuviper"
 user-name = "Josh Stone"
 
 [[publisher.io-extras]]
-version = "0.18.0"
-when = "2023-06-11"
+version = "0.18.1"
+when = "2023-12-01"
+user-id = 6825
+user-login = "sunfishcode"
+user-name = "Dan Gohman"
+
+[[publisher.io-lifetimes]]
+version = "1.0.11"
+when = "2023-05-24"
 user-id = 6825
 user-login = "sunfishcode"
 user-name = "Dan Gohman"
 
 [[publisher.io-lifetimes]]
-version = "2.0.2"
-when = "2023-06-30"
+version = "2.0.3"
+when = "2023-12-01"
+user-id = 6825
+user-login = "sunfishcode"
+user-name = "Dan Gohman"
+
+[[publisher.is-terminal]]
+version = "0.4.10"
+when = "2023-12-28"
 user-id = 6825
 user-login = "sunfishcode"
 user-name = "Dan Gohman"
@@ -864,8 +795,15 @@ user-login = "Amanieu"
 user-name = "Amanieu d'Antras"
 
 [[publisher.linux-raw-sys]]
-version = "0.4.3"
-when = "2023-06-14"
+version = "0.3.8"
+when = "2023-05-19"
+user-id = 6825
+user-login = "sunfishcode"
+user-name = "Dan Gohman"
+
+[[publisher.linux-raw-sys]]
+version = "0.4.12"
+when = "2023-11-30"
 user-id = 6825
 user-login = "sunfishcode"
 user-name = "Dan Gohman"
@@ -884,20 +822,48 @@ user-id = 3618
 user-login = "dtolnay"
 user-name = "David Tolnay"
 
+[[publisher.prettyplease]]
+version = "0.2.20"
+when = "2024-05-07"
+user-id = 3618
+user-login = "dtolnay"
+user-name = "David Tolnay"
+
+[[publisher.proc-macro2]]
+version = "1.0.81"
+when = "2024-04-17"
+user-id = 3618
+user-login = "dtolnay"
+user-name = "David Tolnay"
+
+[[publisher.pulley-interpreter]]
+version = "0.0.0"
+when = "2024-07-30"
+user-id = 696
+user-login = "fitzgen"
+user-name = "Nick Fitzgerald"
+
 [[publisher.quote]]
-version = "1.0.29"
-when = "2023-06-29"
+version = "1.0.36"
+when = "2024-04-10"
 user-id = 3618
 user-login = "dtolnay"
 user-name = "David Tolnay"
 
 [[publisher.regalloc2]]
-version = "0.9.2"
-when = "2023-07-14"
+version = "0.9.3"
+when = "2023-10-05"
 user-id = 3726
 user-login = "cfallin"
 user-name = "Chris Fallin"
 
+[[publisher.regalloc2]]
+version = "0.9.4"
+when = "2024-08-30"
+user-id = 187138
+user-login = "elliottt"
+user-name = "Trevor Elliott"
+
 [[publisher.regex]]
 version = "1.9.1"
 when = "2023-07-07"
@@ -934,15 +900,15 @@ user-login = "BurntSushi"
 user-name = "Andrew Gallant"
 
 [[publisher.rustix]]
-version = "0.38.4"
-when = "2023-07-11"
+version = "0.37.27"
+when = "2023-10-26"
 user-id = 6825
 user-login = "sunfishcode"
 user-name = "Dan Gohman"
 
 [[publisher.rustix]]
-version = "0.38.8"
-when = "2023-08-10"
+version = "0.38.31"
+when = "2024-02-01"
 user-id = 6825
 user-login = "sunfishcode"
 user-name = "Dan Gohman"
@@ -968,13 +934,6 @@ user-id = 2915
 user-login = "Amanieu"
 user-name = "Amanieu d'Antras"
 
-[[publisher.serde]]
-version = "1.0.171"
-when = "2023-07-10"
-user-id = 3618
-user-login = "dtolnay"
-user-name = "David Tolnay"
-
 [[publisher.serde]]
 version = "1.0.188"
 when = "2023-08-26"
@@ -982,13 +941,6 @@ user-id = 3618
 user-login = "dtolnay"
 user-name = "David Tolnay"
 
-[[publisher.serde_derive]]
-version = "1.0.171"
-when = "2023-07-10"
-user-id = 3618
-user-login = "dtolnay"
-user-name = "David Tolnay"
-
 [[publisher.serde_derive]]
 version = "1.0.188"
 when = "2023-08-26"
@@ -996,13 +948,6 @@ user-id = 3618
 user-login = "dtolnay"
 user-name = "David Tolnay"
 
-[[publisher.serde_json]]
-version = "1.0.80"
-when = "2022-04-30"
-user-id = 3618
-user-login = "dtolnay"
-user-name = "David Tolnay"
-
 [[publisher.serde_json]]
 version = "1.0.107"
 when = "2023-09-13"
@@ -1010,6 +955,13 @@ user-id = 3618
 user-login = "dtolnay"
 user-name = "David Tolnay"
 
+[[publisher.serde_spanned]]
+version = "0.6.5"
+when = "2023-12-19"
+user-id = 6743
+user-login = "epage"
+user-name = "Ed Page"
+
 [[publisher.spdx]]
 version = "0.10.1"
 when = "2023-04-06"
@@ -1024,36 +976,43 @@ user-login = "dtolnay"
 user-name = "David Tolnay"
 
 [[publisher.syn]]
-version = "2.0.25"
-when = "2023-07-09"
-user-id = 3618
-user-login = "dtolnay"
-user-name = "David Tolnay"
-
-[[publisher.syn]]
-version = "2.0.29"
-when = "2023-08-17"
+version = "2.0.60"
+when = "2024-04-17"
 user-id = 3618
 user-login = "dtolnay"
 user-name = "David Tolnay"
 
 [[publisher.system-interface]]
-version = "0.26.0"
-when = "2023-06-30"
+version = "0.27.1"
+when = "2024-02-13"
 user-id = 6825
 user-login = "sunfishcode"
 user-name = "Dan Gohman"
 
+[[publisher.tar]]
+version = "0.4.40"
+when = "2023-08-07"
+user-id = 1
+user-login = "alexcrichton"
+user-name = "Alex Crichton"
+
+[[publisher.tar]]
+version = "0.4.41"
+when = "2024-06-04"
+user-id = 1
+user-login = "alexcrichton"
+user-name = "Alex Crichton"
+
 [[publisher.target-lexicon]]
-version = "0.12.3"
-when = "2022-02-01"
-user-id = 6825
-user-login = "sunfishcode"
-user-name = "Dan Gohman"
+version = "0.12.16"
+when = "2024-07-30"
+user-id = 696
+user-login = "fitzgen"
+user-name = "Nick Fitzgerald"
 
 [[publisher.termcolor]]
-version = "1.1.3"
-when = "2022-03-02"
+version = "1.4.1"
+when = "2024-01-10"
 user-id = 189
 user-login = "BurntSushi"
 user-name = "Andrew Gallant"
@@ -1073,18 +1032,25 @@ user-login = "dtolnay"
 user-name = "David Tolnay"
 
 [[publisher.toml]]
-version = "0.5.7"
-when = "2020-10-11"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
+version = "0.8.10"
+when = "2024-02-05"
+user-id = 6743
+user-login = "epage"
+user-name = "Ed Page"
 
-[[publisher.unicode-segmentation]]
-version = "1.10.1"
-when = "2023-01-31"
-user-id = 1139
-user-login = "Manishearth"
-user-name = "Manish Goregaokar"
+[[publisher.toml_datetime]]
+version = "0.6.5"
+when = "2023-10-23"
+user-id = 6743
+user-login = "epage"
+user-name = "Ed Page"
+
+[[publisher.toml_edit]]
+version = "0.22.4"
+when = "2024-02-06"
+user-id = 6743
+user-login = "epage"
+user-name = "Ed Page"
 
 [[publisher.unicode-width]]
 version = "0.1.9"
@@ -1107,39 +1073,9 @@ user-id = 189
 user-login = "BurntSushi"
 user-name = "Andrew Gallant"
 
-[[publisher.wasi-cap-std-sync]]
-version = "11.0.1"
-when = "2023-07-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.wasi-cap-std-sync]]
-version = "12.0.1"
-when = "2023-08-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
 [[publisher.wasi-common]]
-version = "11.0.1"
-when = "2023-07-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.wasi-common]]
-version = "12.0.1"
-when = "2023-08-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.wasi-tokio]]
-version = "11.0.1"
-when = "2023-07-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.wasi-tokio]]
-version = "12.0.1"
-when = "2023-08-24"
+version = "23.0.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
@@ -1179,626 +1115,278 @@ user-login = "alexcrichton"
 user-name = "Alex Crichton"
 
 [[publisher.wasm-encoder]]
-version = "0.30.0"
-when = "2023-07-11"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasm-encoder]]
-version = "0.31.1"
-when = "2023-07-26"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasm-encoder]]
-version = "0.32.0"
-when = "2023-08-25"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasm-encoder]]
-version = "0.33.1"
-when = "2023-09-18"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasm-encoder]]
-version = "0.33.2"
-when = "2023-09-26"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasm-metadata]]
-version = "0.9.0"
-when = "2023-07-11"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasm-metadata]]
-version = "0.10.1"
-when = "2023-07-26"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasm-metadata]]
-version = "0.10.2"
-when = "2023-08-18"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasm-metadata]]
-version = "0.10.3"
-when = "2023-08-25"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasm-metadata]]
-version = "0.10.5"
-when = "2023-09-18"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasm-metadata]]
-version = "0.10.6"
-when = "2023-09-26"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasm-mutate]]
-version = "0.2.30"
-when = "2023-07-26"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasm-mutate]]
-version = "0.2.31"
-when = "2023-08-18"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasm-mutate]]
-version = "0.2.32"
-when = "2023-08-25"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasm-mutate]]
-version = "0.2.34"
-when = "2023-09-18"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasm-mutate]]
-version = "0.2.35"
-when = "2023-09-26"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasm-smith]]
-version = "0.12.13"
-when = "2023-07-26"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasm-smith]]
-version = "0.12.14"
-when = "2023-08-18"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasm-smith]]
-version = "0.12.15"
-when = "2023-08-25"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasm-smith]]
-version = "0.12.17"
-when = "2023-09-18"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasm-smith]]
-version = "0.12.18"
-when = "2023-09-26"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasmparser]]
-version = "0.108.0"
-when = "2023-07-11"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasmparser]]
-version = "0.110.0"
-when = "2023-07-26"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasmparser]]
-version = "0.111.0"
-when = "2023-08-18"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasmparser]]
-version = "0.112.0"
-when = "2023-08-25"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasmparser]]
-version = "0.113.1"
-when = "2023-09-18"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasmparser]]
-version = "0.113.2"
-when = "2023-09-26"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasmprinter]]
-version = "0.2.62"
-when = "2023-07-26"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasmprinter]]
-version = "0.2.63"
-when = "2023-08-18"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasmprinter]]
-version = "0.2.64"
-when = "2023-08-25"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasmprinter]]
-version = "0.2.66"
-when = "2023-09-18"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasmprinter]]
-version = "0.2.67"
-when = "2023-09-26"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wasmtime]]
-version = "11.0.1"
-when = "2023-07-24"
+version = "0.214.0"
+when = "2024-07-16"
 user-id = 73222
 user-login = "wasmtime-publish"
 
-[[publisher.wasmtime]]
-version = "12.0.1"
-when = "2023-08-24"
+[[publisher.wasm-encoder]]
+version = "0.215.0"
+when = "2024-07-31"
 user-id = 73222
 user-login = "wasmtime-publish"
 
-[[publisher.wasmtime-asm-macros]]
-version = "11.0.1"
-when = "2023-07-24"
+[[publisher.wasm-encoder]]
+version = "0.216.0"
+when = "2024-08-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
-[[publisher.wasmtime-asm-macros]]
-version = "12.0.1"
-when = "2023-08-24"
+[[publisher.wasm-metadata]]
+version = "0.214.0"
+when = "2024-07-16"
 user-id = 73222
 user-login = "wasmtime-publish"
 
-[[publisher.wasmtime-cache]]
-version = "11.0.1"
-when = "2023-07-24"
+[[publisher.wasm-metadata]]
+version = "0.215.0"
+when = "2024-07-31"
 user-id = 73222
 user-login = "wasmtime-publish"
 
-[[publisher.wasmtime-cache]]
-version = "12.0.1"
-when = "2023-08-24"
+[[publisher.wasm-metadata]]
+version = "0.216.0"
+when = "2024-08-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
-[[publisher.wasmtime-cli]]
-version = "11.0.1"
-when = "2023-07-24"
+[[publisher.wasmparser]]
+version = "0.214.0"
+when = "2024-07-16"
 user-id = 73222
 user-login = "wasmtime-publish"
 
-[[publisher.wasmtime-cli]]
-version = "12.0.1"
-when = "2023-08-24"
+[[publisher.wasmparser]]
+version = "0.215.0"
+when = "2024-07-31"
 user-id = 73222
 user-login = "wasmtime-publish"
 
-[[publisher.wasmtime-cli-flags]]
-version = "11.0.1"
-when = "2023-07-24"
+[[publisher.wasmparser]]
+version = "0.216.0"
+when = "2024-08-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
-[[publisher.wasmtime-cli-flags]]
-version = "12.0.1"
-when = "2023-08-24"
+[[publisher.wasmprinter]]
+version = "0.214.0"
+when = "2024-07-16"
 user-id = 73222
 user-login = "wasmtime-publish"
 
-[[publisher.wasmtime-component-macro]]
-version = "11.0.1"
-when = "2023-07-24"
+[[publisher.wasmprinter]]
+version = "0.215.0"
+when = "2024-07-31"
 user-id = 73222
 user-login = "wasmtime-publish"
 
-[[publisher.wasmtime-component-macro]]
-version = "12.0.1"
-when = "2023-08-24"
+[[publisher.wasmprinter]]
+version = "0.216.0"
+when = "2024-08-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
-[[publisher.wasmtime-component-util]]
-version = "11.0.1"
-when = "2023-07-24"
+[[publisher.wasmtime]]
+version = "23.0.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
-[[publisher.wasmtime-component-util]]
-version = "12.0.1"
-when = "2023-08-24"
+[[publisher.wasmtime-asm-macros]]
+version = "23.0.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
-[[publisher.wasmtime-cranelift]]
-version = "11.0.1"
-when = "2023-07-24"
+[[publisher.wasmtime-cache]]
+version = "23.0.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
-[[publisher.wasmtime-cranelift]]
-version = "12.0.1"
-when = "2023-08-24"
+[[publisher.wasmtime-cli]]
+version = "23.0.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
-[[publisher.wasmtime-cranelift-shared]]
-version = "11.0.1"
-when = "2023-07-24"
+[[publisher.wasmtime-cli-flags]]
+version = "23.0.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
-[[publisher.wasmtime-cranelift-shared]]
-version = "12.0.1"
-when = "2023-08-24"
+[[publisher.wasmtime-component-macro]]
+version = "23.0.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
-[[publisher.wasmtime-environ]]
-version = "11.0.1"
-when = "2023-07-24"
+[[publisher.wasmtime-component-util]]
+version = "23.0.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
-[[publisher.wasmtime-environ]]
-version = "12.0.1"
-when = "2023-08-24"
+[[publisher.wasmtime-cranelift]]
+version = "23.0.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
-[[publisher.wasmtime-explorer]]
-version = "11.0.1"
-when = "2023-07-24"
+[[publisher.wasmtime-environ]]
+version = "23.0.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.wasmtime-explorer]]
-version = "12.0.1"
-when = "2023-08-24"
+version = "23.0.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.wasmtime-fiber]]
-version = "11.0.1"
-when = "2023-07-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.wasmtime-fiber]]
-version = "12.0.1"
-when = "2023-08-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.wasmtime-jit]]
-version = "11.0.1"
-when = "2023-07-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.wasmtime-jit]]
-version = "12.0.1"
-when = "2023-08-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.wasmtime-jit-debug]]
-version = "11.0.1"
-when = "2023-07-24"
+version = "23.0.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.wasmtime-jit-debug]]
-version = "12.0.1"
-when = "2023-08-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.wasmtime-jit-icache-coherence]]
-version = "11.0.1"
-when = "2023-07-24"
+version = "23.0.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.wasmtime-jit-icache-coherence]]
-version = "12.0.1"
-when = "2023-08-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.wasmtime-runtime]]
-version = "11.0.1"
-when = "2023-07-24"
+version = "23.0.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
-[[publisher.wasmtime-runtime]]
-version = "12.0.1"
-when = "2023-08-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.wasmtime-types]]
-version = "11.0.1"
-when = "2023-07-24"
+[[publisher.wasmtime-slab]]
+version = "23.0.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.wasmtime-types]]
-version = "12.0.1"
-when = "2023-08-24"
+version = "23.0.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.wasmtime-wasi]]
-version = "11.0.1"
-when = "2023-07-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.wasmtime-wasi]]
-version = "12.0.1"
-when = "2023-08-24"
+version = "23.0.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.wasmtime-wasi-http]]
-version = "11.0.1"
-when = "2023-07-24"
+version = "23.0.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
-[[publisher.wasmtime-wasi-http]]
-version = "12.0.1"
-when = "2023-08-24"
+[[publisher.wasmtime-wasi-keyvalue]]
+version = "24.0.0"
+when = "2024-08-20"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.wasmtime-wasi-nn]]
-version = "11.0.1"
-when = "2023-07-24"
+version = "23.0.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
-[[publisher.wasmtime-wasi-nn]]
-version = "12.0.1"
-when = "2023-08-24"
+[[publisher.wasmtime-wasi-runtime-config]]
+version = "24.0.0"
+when = "2024-08-20"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.wasmtime-wasi-threads]]
-version = "11.0.1"
-when = "2023-07-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.wasmtime-wasi-threads]]
-version = "12.0.1"
-when = "2023-08-24"
+version = "23.0.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.wasmtime-wast]]
-version = "11.0.1"
-when = "2023-07-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.wasmtime-wast]]
-version = "12.0.1"
-when = "2023-08-24"
+version = "23.0.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.wasmtime-winch]]
-version = "11.0.1"
-when = "2023-07-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.wasmtime-winch]]
-version = "12.0.1"
-when = "2023-08-24"
-user-id = 73222
-user-login = "wasmtime-publish"
-
-[[publisher.wasmtime-wit-bindgen]]
-version = "11.0.1"
-when = "2023-07-24"
+version = "23.0.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.wasmtime-wit-bindgen]]
-version = "12.0.1"
-when = "2023-08-24"
+version = "23.0.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.wasmtime-wmemcheck]]
-version = "13.0.0"
-when = "2023-09-20"
+version = "23.0.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.wast]]
-version = "62.0.1"
-when = "2023-07-26"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wast]]
-version = "63.0.0"
-when = "2023-08-18"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wast]]
-version = "64.0.0"
-when = "2023-08-25"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
+version = "214.0.0"
+when = "2024-07-16"
+user-id = 73222
+user-login = "wasmtime-publish"
 
 [[publisher.wast]]
-version = "65.0.1"
-when = "2023-09-18"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
+version = "215.0.0"
+when = "2024-07-31"
+user-id = 73222
+user-login = "wasmtime-publish"
 
 [[publisher.wast]]
-version = "65.0.2"
-when = "2023-09-26"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wat]]
-version = "1.0.69"
-when = "2023-07-26"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wat]]
-version = "1.0.70"
-when = "2023-08-18"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wat]]
-version = "1.0.71"
-when = "2023-08-25"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wat]]
-version = "1.0.73"
-when = "2023-09-18"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
+version = "216.0.0"
+when = "2024-08-22"
+user-id = 73222
+user-login = "wasmtime-publish"
 
 [[publisher.wat]]
-version = "1.0.74"
-when = "2023-09-26"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wiggle]]
-version = "11.0.1"
-when = "2023-07-24"
+version = "1.214.0"
+when = "2024-07-16"
 user-id = 73222
 user-login = "wasmtime-publish"
 
-[[publisher.wiggle]]
-version = "12.0.1"
-when = "2023-08-24"
+[[publisher.wat]]
+version = "1.215.0"
+when = "2024-07-31"
 user-id = 73222
 user-login = "wasmtime-publish"
 
-[[publisher.wiggle-generate]]
-version = "11.0.1"
-when = "2023-07-24"
+[[publisher.wat]]
+version = "1.216.0"
+when = "2024-08-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
-[[publisher.wiggle-generate]]
-version = "12.0.1"
-when = "2023-08-24"
+[[publisher.wiggle]]
+version = "23.0.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
-[[publisher.wiggle-macro]]
-version = "11.0.1"
-when = "2023-07-24"
+[[publisher.wiggle-generate]]
+version = "23.0.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
 [[publisher.wiggle-macro]]
-version = "12.0.1"
-when = "2023-08-24"
+version = "23.0.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
@@ -1817,16 +1405,31 @@ user-login = "BurntSushi"
 user-name = "Andrew Gallant"
 
 [[publisher.winch-codegen]]
-version = "0.9.1"
-when = "2023-07-24"
+version = "0.21.1"
+when = "2024-07-22"
 user-id = 73222
 user-login = "wasmtime-publish"
 
-[[publisher.winch-codegen]]
-version = "0.10.1"
-when = "2023-08-24"
-user-id = 73222
-user-login = "wasmtime-publish"
+[[publisher.windows]]
+version = "0.52.0"
+when = "2023-11-15"
+user-id = 64539
+user-login = "kennykerr"
+user-name = "Kenny Kerr"
+
+[[publisher.windows-core]]
+version = "0.52.0"
+when = "2023-11-15"
+user-id = 64539
+user-login = "kennykerr"
+user-name = "Kenny Kerr"
+
+[[publisher.windows-interface]]
+version = "0.52.0"
+when = "2023-11-15"
+user-id = 64539
+user-login = "kennykerr"
+user-name = "Kenny Kerr"
 
 [[publisher.windows-sys]]
 version = "0.48.0"
@@ -1835,261 +1438,268 @@ user-id = 64539
 user-login = "kennykerr"
 user-name = "Kenny Kerr"
 
+[[publisher.windows-sys]]
+version = "0.52.0"
+when = "2023-11-15"
+user-id = 64539
+user-login = "kennykerr"
+user-name = "Kenny Kerr"
+
 [[publisher.windows-targets]]
-version = "0.48.0"
-when = "2023-03-31"
+version = "0.48.5"
+when = "2023-08-18"
+user-id = 64539
+user-login = "kennykerr"
+user-name = "Kenny Kerr"
+
+[[publisher.windows-targets]]
+version = "0.52.0"
+when = "2023-11-15"
 user-id = 64539
 user-login = "kennykerr"
 user-name = "Kenny Kerr"
 
 [[publisher.windows_aarch64_gnullvm]]
-version = "0.48.0"
-when = "2023-03-31"
+version = "0.48.5"
+when = "2023-08-18"
+user-id = 64539
+user-login = "kennykerr"
+user-name = "Kenny Kerr"
+
+[[publisher.windows_aarch64_gnullvm]]
+version = "0.52.0"
+when = "2023-11-15"
 user-id = 64539
 user-login = "kennykerr"
 user-name = "Kenny Kerr"
 
 [[publisher.windows_aarch64_msvc]]
-version = "0.48.0"
-when = "2023-03-31"
+version = "0.48.5"
+when = "2023-08-18"
+user-id = 64539
+user-login = "kennykerr"
+user-name = "Kenny Kerr"
+
+[[publisher.windows_aarch64_msvc]]
+version = "0.52.0"
+when = "2023-11-15"
 user-id = 64539
 user-login = "kennykerr"
 user-name = "Kenny Kerr"
 
 [[publisher.windows_i686_gnu]]
-version = "0.48.0"
-when = "2023-03-31"
+version = "0.48.5"
+when = "2023-08-18"
+user-id = 64539
+user-login = "kennykerr"
+user-name = "Kenny Kerr"
+
+[[publisher.windows_i686_gnu]]
+version = "0.52.0"
+when = "2023-11-15"
 user-id = 64539
 user-login = "kennykerr"
 user-name = "Kenny Kerr"
 
 [[publisher.windows_i686_msvc]]
-version = "0.48.0"
-when = "2023-03-31"
+version = "0.48.5"
+when = "2023-08-18"
+user-id = 64539
+user-login = "kennykerr"
+user-name = "Kenny Kerr"
+
+[[publisher.windows_i686_msvc]]
+version = "0.52.0"
+when = "2023-11-15"
 user-id = 64539
 user-login = "kennykerr"
 user-name = "Kenny Kerr"
 
 [[publisher.windows_x86_64_gnu]]
-version = "0.48.0"
-when = "2023-03-31"
+version = "0.48.5"
+when = "2023-08-18"
+user-id = 64539
+user-login = "kennykerr"
+user-name = "Kenny Kerr"
+
+[[publisher.windows_x86_64_gnu]]
+version = "0.52.0"
+when = "2023-11-15"
 user-id = 64539
 user-login = "kennykerr"
 user-name = "Kenny Kerr"
 
 [[publisher.windows_x86_64_gnullvm]]
-version = "0.48.0"
-when = "2023-03-31"
+version = "0.48.5"
+when = "2023-08-18"
+user-id = 64539
+user-login = "kennykerr"
+user-name = "Kenny Kerr"
+
+[[publisher.windows_x86_64_gnullvm]]
+version = "0.52.0"
+when = "2023-11-15"
 user-id = 64539
 user-login = "kennykerr"
 user-name = "Kenny Kerr"
 
 [[publisher.windows_x86_64_msvc]]
-version = "0.48.0"
-when = "2023-03-31"
+version = "0.48.5"
+when = "2023-08-18"
 user-id = 64539
 user-login = "kennykerr"
 user-name = "Kenny Kerr"
 
+[[publisher.windows_x86_64_msvc]]
+version = "0.52.0"
+when = "2023-11-15"
+user-id = 64539
+user-login = "kennykerr"
+user-name = "Kenny Kerr"
+
+[[publisher.winnow]]
+version = "0.5.39"
+when = "2024-02-06"
+user-id = 6743
+user-login = "epage"
+user-name = "Ed Page"
+
 [[publisher.winx]]
-version = "0.36.1"
-when = "2023-06-29"
+version = "0.36.3"
+when = "2023-12-01"
 user-id = 6825
 user-login = "sunfishcode"
 user-name = "Dan Gohman"
 
 [[publisher.wit-bindgen]]
-version = "0.9.0"
-when = "2023-07-15"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
+version = "0.28.0"
+when = "2024-07-16"
+user-id = 73222
+user-login = "wasmtime-publish"
 
 [[publisher.wit-bindgen]]
-version = "0.11.0"
-when = "2023-08-28"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
+version = "0.29.0"
+when = "2024-08-02"
+user-id = 73222
+user-login = "wasmtime-publish"
 
 [[publisher.wit-bindgen]]
-version = "0.12.0"
-when = "2023-09-18"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
+version = "0.30.0"
+when = "2024-08-12"
+user-id = 73222
+user-login = "wasmtime-publish"
 
 [[publisher.wit-bindgen-core]]
-version = "0.9.0"
-when = "2023-07-15"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
+version = "0.28.0"
+when = "2024-07-16"
+user-id = 73222
+user-login = "wasmtime-publish"
 
 [[publisher.wit-bindgen-core]]
-version = "0.11.0"
-when = "2023-08-28"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
+version = "0.29.0"
+when = "2024-08-02"
+user-id = 73222
+user-login = "wasmtime-publish"
 
 [[publisher.wit-bindgen-core]]
-version = "0.12.0"
-when = "2023-09-18"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wit-bindgen-rust]]
-version = "0.9.0"
-when = "2023-07-15"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wit-bindgen-rust]]
-version = "0.11.0"
-when = "2023-08-28"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wit-bindgen-rust]]
-version = "0.12.0"
-when = "2023-09-18"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wit-bindgen-rust-lib]]
-version = "0.9.0"
-when = "2023-07-15"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wit-bindgen-rust-lib]]
-version = "0.11.0"
-when = "2023-08-28"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
+version = "0.30.0"
+when = "2024-08-12"
+user-id = 73222
+user-login = "wasmtime-publish"
 
-[[publisher.wit-bindgen-rust-lib]]
-version = "0.12.0"
-when = "2023-09-18"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
+[[publisher.wit-bindgen-rt]]
+version = "0.28.0"
+when = "2024-07-16"
+user-id = 73222
+user-login = "wasmtime-publish"
 
-[[publisher.wit-bindgen-rust-macro]]
-version = "0.9.0"
-when = "2023-07-15"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
+[[publisher.wit-bindgen-rt]]
+version = "0.29.0"
+when = "2024-08-02"
+user-id = 73222
+user-login = "wasmtime-publish"
 
-[[publisher.wit-bindgen-rust-macro]]
-version = "0.11.0"
-when = "2023-08-28"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
+[[publisher.wit-bindgen-rt]]
+version = "0.30.0"
+when = "2024-08-12"
+user-id = 73222
+user-login = "wasmtime-publish"
 
-[[publisher.wit-bindgen-rust-macro]]
-version = "0.12.0"
-when = "2023-09-18"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
+[[publisher.wit-bindgen-rust]]
+version = "0.28.0"
+when = "2024-07-16"
+user-id = 73222
+user-login = "wasmtime-publish"
 
-[[publisher.wit-component]]
-version = "0.12.0"
-when = "2023-07-11"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
+[[publisher.wit-bindgen-rust]]
+version = "0.29.0"
+when = "2024-08-02"
+user-id = 73222
+user-login = "wasmtime-publish"
 
-[[publisher.wit-component]]
-version = "0.13.1"
-when = "2023-07-26"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
+[[publisher.wit-bindgen-rust]]
+version = "0.30.0"
+when = "2024-08-12"
+user-id = 73222
+user-login = "wasmtime-publish"
 
-[[publisher.wit-component]]
-version = "0.13.2"
-when = "2023-08-18"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
+[[publisher.wit-bindgen-rust-macro]]
+version = "0.28.0"
+when = "2024-07-16"
+user-id = 73222
+user-login = "wasmtime-publish"
 
-[[publisher.wit-component]]
-version = "0.14.0"
-when = "2023-08-25"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
+[[publisher.wit-bindgen-rust-macro]]
+version = "0.29.0"
+when = "2024-08-02"
+user-id = 73222
+user-login = "wasmtime-publish"
 
-[[publisher.wit-component]]
-version = "0.14.2"
-when = "2023-09-18"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
+[[publisher.wit-bindgen-rust-macro]]
+version = "0.30.0"
+when = "2024-08-12"
+user-id = 73222
+user-login = "wasmtime-publish"
 
 [[publisher.wit-component]]
-version = "0.14.3"
-when = "2023-09-26"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
+version = "0.214.0"
+when = "2024-07-16"
+user-id = 73222
+user-login = "wasmtime-publish"
 
 [[publisher.wit-component]]
-version = "0.14.4"
-when = "2023-09-27"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
-
-[[publisher.wit-parser]]
-version = "0.9.2"
-when = "2023-07-26"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
+version = "0.215.0"
+when = "2024-07-31"
+user-id = 73222
+user-login = "wasmtime-publish"
 
-[[publisher.wit-parser]]
-version = "0.10.0"
-when = "2023-08-18"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
+[[publisher.wit-component]]
+version = "0.216.0"
+when = "2024-08-22"
+user-id = 73222
+user-login = "wasmtime-publish"
 
 [[publisher.wit-parser]]
-version = "0.11.0"
-when = "2023-08-25"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
+version = "0.214.0"
+when = "2024-07-16"
+user-id = 73222
+user-login = "wasmtime-publish"
 
 [[publisher.wit-parser]]
-version = "0.11.1"
-when = "2023-09-18"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
+version = "0.215.0"
+when = "2024-07-31"
+user-id = 73222
+user-login = "wasmtime-publish"
 
 [[publisher.wit-parser]]
-version = "0.11.2"
-when = "2023-09-26"
-user-id = 1
-user-login = "alexcrichton"
-user-name = "Alex Crichton"
+version = "0.216.0"
+when = "2024-08-22"
+user-id = 73222
+user-login = "wasmtime-publish"
 
-[[publisher.wit-parser]]
-version = "0.11.3"
-when = "2023-09-27"
+[[publisher.witx]]
+version = "0.9.1"
+when = "2021-06-22"
 user-id = 1
 user-login = "alexcrichton"
 user-name = "Alex Crichton"
@@ -2102,38 +1712,23 @@ start = "2020-01-01"
 end = "2024-05-23"
 notes = "Maintained by Embark. No unsafe usage or ambient capabilities"
 
-[[audits.embark-studios.audits.anyhow]]
-who = "Johan Andersson <opensource@embark-studios.com>"
-criteria = "safe-to-deploy"
-version = "1.0.58"
-
-[[audits.embark-studios.audits.colorchoice]]
-who = "Johan Andersson <opensource@embark-studios.com>"
-criteria = "safe-to-deploy"
-version = "1.0.0"
-notes = "No unsafe usage or ambient capabilities"
-
-[[audits.embark-studios.audits.cty]]
+[[audits.embark-studios.audits.cargo_metadata]]
 who = "Johan Andersson <opensource@embark-studios.com>"
 criteria = "safe-to-deploy"
-version = "0.2.2"
-notes = "Inspected it and is a tiny crate with just type definitions"
+delta = "0.15.3 -> 0.15.4"
+notes = "No notable changes"
 
-[[audits.embark-studios.audits.ittapi]]
+[[audits.embark-studios.audits.cargo_metadata]]
 who = "Johan Andersson <opensource@embark-studios.com>"
 criteria = "safe-to-deploy"
-version = "0.3.3"
-notes = "Lots of unsafe code for calling into C FFI functions, looks pretty simple and sound though. No ambient capabilities"
+delta = "0.15.4 -> 0.17.0"
+notes = "No notable changes"
 
-[[audits.embark-studios.audits.ittapi-sys]]
+[[audits.embark-studios.audits.colorchoice]]
 who = "Johan Andersson <opensource@embark-studios.com>"
 criteria = "safe-to-deploy"
-version = "0.3.3"
-notes = """
-Builds C/asm dependency which this review has not audited in detail, but is well established from Intel. 
-Exposes FFI types & functions generated through bindgen. No other logic.
-No ambient capabilities
-"""
+version = "1.0.0"
+notes = "No unsafe usage or ambient capabilities"
 
 [[audits.embark-studios.audits.utf8parse]]
 who = "Johan Andersson <opensource@embark-studios.com>"
@@ -2141,17 +1736,29 @@ criteria = "safe-to-deploy"
 version = "0.2.1"
 notes = "Single unsafe usage that looks sound, no ambient capabilities"
 
-[[audits.embark-studios.audits.webpki-roots]]
+[[audits.embark-studios.audits.valuable]]
 who = "Johan Andersson <opensource@embark-studios.com>"
 criteria = "safe-to-deploy"
-version = "0.22.4"
-notes = "Inspected it to confirm that it only contains data definitions and no runtime code"
+version = "0.1.0"
+notes = "No unsafe usage or ambient capabilities, sane build script"
 
 [[audits.fermyon.audits.oorandom]]
 who = "Radu Matei <radu.matei@fermyon.com>"
 criteria = "safe-to-run"
 version = "11.1.3"
 
+[[audits.google.audits.cast]]
+who = "George Burgess IV <gbiv@google.com>"
+criteria = "safe-to-run"
+version = "0.3.0"
+aggregated-from = "https://chromium.googlesource.com/chromiumos/third_party/rust_crates/+/main/cargo-vet/audits.toml?format=TEXT"
+
+[[audits.google.audits.dirs-next]]
+who = "George Burgess IV <gbiv@google.com>"
+criteria = "safe-to-deploy"
+version = "2.0.0"
+aggregated-from = "https://chromium.googlesource.com/chromiumos/third_party/rust_crates/+/main/cargo-vet/audits.toml?format=TEXT"
+
 [[audits.google.audits.fastrand]]
 who = "George Burgess IV <gbiv@google.com>"
 criteria = "safe-to-deploy"
@@ -2162,16 +1769,23 @@ that the RNG here is not cryptographically secure.
 """
 aggregated-from = "https://chromium.googlesource.com/chromiumos/third_party/rust_crates/+/main/cargo-vet/audits.toml?format=TEXT"
 
-[[audits.google.audits.glob]]
-who = "George Burgess IV <gbiv@google.com>"
-criteria = "safe-to-deploy"
-version = "0.3.1"
+[[audits.google.audits.itertools]]
+who = "ChromeOS"
+criteria = "safe-to-run"
+version = "0.10.5"
 aggregated-from = "https://chromium.googlesource.com/chromiumos/third_party/rust_crates/+/main/cargo-vet/audits.toml?format=TEXT"
 
-[[audits.google.audits.libfuzzer-sys]]
-who = "ChromeOS"
+[[audits.google.audits.libtest-mimic]]
+who = "Dennis Kempin <denniskempin@google.com>"
+criteria = "safe-to-run"
+version = "0.6.0"
+notes = "Used in tests only"
+aggregated-from = "https://chromium.googlesource.com/chromiumos/third_party/rust_crates/+/main/cargo-vet/audits.toml?format=TEXT"
+
+[[audits.google.audits.libtest-mimic]]
+who = "George Burgess IV <gbiv@google.com>"
 criteria = "safe-to-run"
-version = "0.4.4"
+delta = "0.6.0 -> 0.6.1"
 aggregated-from = "https://chromium.googlesource.com/chromiumos/third_party/rust_crates/+/main/cargo-vet/audits.toml?format=TEXT"
 
 [[audits.google.audits.pin-project-lite]]
@@ -2181,10 +1795,30 @@ version = "0.2.9"
 notes = "Reviewed on https://fxrev.dev/824504"
 aggregated-from = "https://fuchsia.googlesource.com/fuchsia/+/refs/heads/main/third_party/rust_crates/supply-chain/audits.toml?format=TEXT"
 
-[[audits.google.audits.static_assertions]]
-who = "ChromeOS"
+[[audits.google.audits.pin-project-lite]]
+who = "David Koloski <dkoloski@google.com>"
+criteria = "safe-to-deploy"
+delta = "0.2.9 -> 0.2.13"
+notes = "Audited at https://fxrev.dev/946396"
+aggregated-from = "https://fuchsia.googlesource.com/fuchsia/+/refs/heads/main/third_party/rust_crates/supply-chain/audits.toml?format=TEXT"
+
+[[audits.google.audits.socket2]]
+who = "David Koloski <dkoloski@google.com>"
+criteria = "safe-to-deploy"
+delta = "0.4.4 -> 0.5.5"
+notes = "Reviewed at https://fxrev.dev/946307"
+aggregated-from = "https://fuchsia.googlesource.com/fuchsia/+/refs/heads/main/third_party/rust_crates/supply-chain/audits.toml?format=TEXT"
+
+[[audits.google.audits.threadpool]]
+who = "Dennis Kempin <denniskempin@google.com>"
 criteria = "safe-to-run"
-version = "1.1.0"
+version = "1.8.1"
+aggregated-from = "https://chromium.googlesource.com/chromiumos/third_party/rust_crates/+/main/cargo-vet/audits.toml?format=TEXT"
+
+[[audits.google.audits.tinytemplate]]
+who = "Ying Hsu <yinghsu@chromium.org>"
+criteria = "safe-to-run"
+version = "1.2.1"
 aggregated-from = "https://chromium.googlesource.com/chromiumos/third_party/rust_crates/+/main/cargo-vet/audits.toml?format=TEXT"
 
 [[audits.google.audits.version_check]]
@@ -2193,6 +1827,21 @@ criteria = "safe-to-deploy"
 version = "0.9.4"
 aggregated-from = "https://chromium.googlesource.com/chromiumos/third_party/rust_crates/+/main/cargo-vet/audits.toml?format=TEXT"
 
+[[audits.isrg.audits.base64]]
+who = "Tim Geoghegan <timg@letsencrypt.org>"
+criteria = "safe-to-deploy"
+delta = "0.21.0 -> 0.21.1"
+
+[[audits.isrg.audits.base64]]
+who = "Brandon Pitman <bran@bran.land>"
+criteria = "safe-to-deploy"
+delta = "0.21.1 -> 0.21.2"
+
+[[audits.isrg.audits.base64]]
+who = "David Cook <dcook@divviup.org>"
+criteria = "safe-to-deploy"
+delta = "0.21.2 -> 0.21.3"
+
 [[audits.isrg.audits.block-buffer]]
 who = "David Cook <dcook@divviup.org>"
 criteria = "safe-to-deploy"
@@ -2213,28 +1862,44 @@ who = "David Cook <dcook@divviup.org>"
 criteria = "safe-to-deploy"
 delta = "1.17.2 -> 1.18.0"
 
+[[audits.isrg.audits.once_cell]]
+who = "Brandon Pitman <bran@bran.land>"
+criteria = "safe-to-deploy"
+delta = "1.18.0 -> 1.19.0"
+
+[[audits.isrg.audits.rand_chacha]]
+who = "David Cook <dcook@divviup.org>"
+criteria = "safe-to-deploy"
+version = "0.3.1"
+
 [[audits.isrg.audits.rand_core]]
 who = "David Cook <dcook@divviup.org>"
 criteria = "safe-to-deploy"
 version = "0.6.3"
 
-[[audits.isrg.audits.sha2]]
+[[audits.isrg.audits.rayon-core]]
+who = "Brandon Pitman <bran@bran.land>"
+criteria = "safe-to-deploy"
+delta = "1.10.2 -> 1.11.0"
+
+[[audits.isrg.audits.rayon-core]]
 who = "David Cook <dcook@divviup.org>"
 criteria = "safe-to-deploy"
-version = "0.10.2"
+delta = "1.11.0 -> 1.12.0"
 
-[[audits.isrg.audits.untrusted]]
+[[audits.isrg.audits.sha2]]
 who = "David Cook <dcook@divviup.org>"
 criteria = "safe-to-deploy"
-version = "0.7.1"
+version = "0.10.2"
 
-[[audits.mozilla.wildcard-audits.unicode-segmentation]]
-who = "Manish Goregaokar <manishsmail@gmail.com>"
+[[audits.mozilla.wildcard-audits.core-foundation-sys]]
+who = "Bobby Holley <bobbyholley@gmail.com>"
 criteria = "safe-to-deploy"
-user-id = 1139 # Manish Goregaokar (Manishearth)
-start = "2019-05-15"
-end = "2024-05-03"
-notes = "All code written or reviewed by Manish"
+user-id = 5946 # Jeff Muizelaar (jrmuizel)
+start = "2020-10-14"
+end = "2023-05-04"
+renew = false
+notes = "I've reviewed every source contribution that was neither authored nor reviewed by Mozilla."
 aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
 
 [[audits.mozilla.wildcard-audits.unicode-width]]
@@ -2255,35 +1920,23 @@ end = "2024-05-03"
 notes = "All code written or reviewed by Manish"
 aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
 
-[[audits.mozilla.audits.anyhow]]
-who = "Mike Hommey <mh+mozilla@glandium.org>"
-criteria = "safe-to-deploy"
-delta = "1.0.57 -> 1.0.61"
-aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
-
-[[audits.mozilla.audits.anyhow]]
-who = "Bobby Holley <bobbyholley@gmail.com>"
-criteria = "safe-to-deploy"
-delta = "1.0.58 -> 1.0.57"
-notes = "No functional differences, just CI config and docs."
-aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
-
-[[audits.mozilla.audits.anyhow]]
-who = "Mike Hommey <mh+mozilla@glandium.org>"
+[[audits.mozilla.audits.android_system_properties]]
+who = "Nicolas Silva <nical@fastmail.com>"
 criteria = "safe-to-deploy"
-delta = "1.0.61 -> 1.0.62"
+version = "0.1.2"
+notes = "I wrote this crate, reviewed by jimb. It is mostly a Rust port of some C++ code we already ship."
 aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
 
-[[audits.mozilla.audits.anyhow]]
+[[audits.mozilla.audits.android_system_properties]]
 who = "Mike Hommey <mh+mozilla@glandium.org>"
 criteria = "safe-to-deploy"
-delta = "1.0.62 -> 1.0.68"
+delta = "0.1.2 -> 0.1.4"
 aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
 
-[[audits.mozilla.audits.anyhow]]
+[[audits.mozilla.audits.android_system_properties]]
 who = "Mike Hommey <mh+mozilla@glandium.org>"
 criteria = "safe-to-deploy"
-delta = "1.0.68 -> 1.0.69"
+delta = "0.1.4 -> 0.1.5"
 aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
 
 [[audits.mozilla.audits.autocfg]]
@@ -2326,24 +1979,31 @@ criteria = "safe-to-deploy"
 delta = "2.2.1 -> 2.3.2"
 aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
 
-[[audits.mozilla.audits.bytes]]
+[[audits.mozilla.audits.bitflags]]
 who = "Mike Hommey <mh+mozilla@glandium.org>"
 criteria = "safe-to-deploy"
-delta = "1.1.0 -> 1.2.1"
+delta = "2.3.3 -> 2.4.0"
 aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
 
-[[audits.mozilla.audits.bytes]]
-who = "Mike Hommey <mh+mozilla@glandium.org>"
+[[audits.mozilla.audits.bitflags]]
+who = "Jan-Erik Rediger <jrediger@mozilla.com>"
 criteria = "safe-to-deploy"
-delta = "1.2.1 -> 1.3.0"
-aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
+delta = "2.4.0 -> 2.4.1"
+notes = "Only allowing new clippy lints"
+aggregated-from = "https://raw.githubusercontent.com/mozilla/glean/main/supply-chain/audits.toml"
 
-[[audits.mozilla.audits.bytes]]
+[[audits.mozilla.audits.cc]]
 who = "Mike Hommey <mh+mozilla@glandium.org>"
 criteria = "safe-to-deploy"
-delta = "1.3.0 -> 1.4.0"
+delta = "1.0.73 -> 1.0.78"
 aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
 
+[[audits.mozilla.audits.cc]]
+who = "Jan-Erik Rediger <jrediger@mozilla.com>"
+criteria = "safe-to-deploy"
+delta = "1.0.78 -> 1.0.83"
+aggregated-from = "https://raw.githubusercontent.com/mozilla/glean/main/supply-chain/audits.toml"
+
 [[audits.mozilla.audits.crypto-common]]
 who = "Mike Hommey <mh+mozilla@glandium.org>"
 criteria = "safe-to-deploy"
@@ -2386,11 +2046,17 @@ criteria = "safe-to-deploy"
 delta = "0.9.3 -> 0.10.0"
 aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
 
-[[audits.mozilla.audits.flagset]]
-who = "Ryan Hunt <rhunt@eqrion.net>"
+[[audits.mozilla.audits.fastrand]]
+who = "Mike Hommey <mh+mozilla@glandium.org>"
+criteria = "safe-to-deploy"
+delta = "1.9.0 -> 2.0.0"
+aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
+
+[[audits.mozilla.audits.flate2]]
+who = "Alex Franchuk <afranchuk@mozilla.com>"
 criteria = "safe-to-deploy"
-version = "0.4.3"
-notes = "Uses no ambient capabilities, vetted the one instance of unsafe."
+delta = "1.0.28 -> 1.0.30"
+notes = "Some new unsafe code, however it has been verified and there are unit tests as well."
 aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
 
 [[audits.mozilla.audits.fnv]]
@@ -2449,10 +2115,22 @@ version = "0.12.3"
 notes = "This version is used in rust's libstd, so effectively we're already trusting it"
 aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
 
-[[audits.mozilla.audits.hermit-abi]]
+[[audits.mozilla.audits.heck]]
+who = "Mike Hommey <mh+mozilla@glandium.org>"
+criteria = "safe-to-deploy"
+delta = "0.4.0 -> 0.4.1"
+aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
+
+[[audits.mozilla.audits.itertools]]
+who = "Mike Hommey <mh+mozilla@glandium.org>"
+criteria = "safe-to-deploy"
+delta = "0.10.3 -> 0.10.5"
+aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
+
+[[audits.mozilla.audits.jobserver]]
 who = "Mike Hommey <mh+mozilla@glandium.org>"
 criteria = "safe-to-deploy"
-delta = "0.1.19 -> 0.2.6"
+delta = "0.1.24 -> 0.1.25"
 aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
 
 [[audits.mozilla.audits.lazy_static]]
@@ -2462,23 +2140,28 @@ version = "1.4.0"
 notes = "I have read over the macros, and audited the unsafe code."
 aggregated-from = "https://raw.githubusercontent.com/mozilla/cargo-vet/main/supply-chain/audits.toml"
 
+[[audits.mozilla.audits.libc]]
+who = "Mike Hommey <mh+mozilla@glandium.org>"
+criteria = "safe-to-deploy"
+delta = "0.2.147 -> 0.2.148"
+aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
+
 [[audits.mozilla.audits.log]]
 who = "Mike Hommey <mh+mozilla@glandium.org>"
 criteria = "safe-to-deploy"
 version = "0.4.17"
 aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
 
-[[audits.mozilla.audits.memoffset]]
+[[audits.mozilla.audits.mach2]]
 who = "Gabriele Svelto <gsvelto@mozilla.com>"
 criteria = "safe-to-deploy"
-delta = "0.6.5 -> 0.7.1"
+version = "0.4.1"
 aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
 
-[[audits.mozilla.audits.num-traits]]
-who = "Josh Stone <jistone@redhat.com>"
+[[audits.mozilla.audits.memoffset]]
+who = "Gabriele Svelto <gsvelto@mozilla.com>"
 criteria = "safe-to-deploy"
-version = "0.2.15"
-notes = "All code written or reviewed by Josh Stone."
+delta = "0.6.5 -> 0.7.1"
 aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
 
 [[audits.mozilla.audits.num_cpus]]
@@ -2511,74 +2194,49 @@ criteria = "safe-to-deploy"
 delta = "1.16.0 -> 1.17.1"
 aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
 
-[[audits.mozilla.audits.proc-macro2]]
-who = "Nika Layzell <nika@thelayzells.com>"
+[[audits.mozilla.audits.pkg-config]]
+who = "Mike Hommey <mh+mozilla@glandium.org>"
 criteria = "safe-to-deploy"
-version = "1.0.39"
-notes = """
-`proc-macro2` acts as either a thin(-ish) wrapper around the std-provided
-`proc_macro` crate, or as a fallback implementation of the crate, depending on
-where it is used.
-
-If using this crate on older versions of rustc (1.56 and earlier), it will
-temporarily replace the panic handler while initializing in order to detect if
-it is running within a `proc_macro`, which could lead to surprising behaviour.
-This should not be an issue for more recent compiler versions, which support
-`proc_macro::is_available()`.
-
-The `proc-macro2` crate's fallback behaviour is not identical to the complex
-behaviour of the rustc compiler (e.g. it does not perform unicode normalization
-for identifiers), however it behaves well enough for its intended use-case
-(tests and scripts processing rust code).
-
-`proc-macro2` does not use unsafe code, however exposes one `unsafe` API to
-allow bypassing checks in the fallback implementation when constructing
-`Literal` using `from_str_unchecked`. This was intended to only be used by the
-`quote!` macro, however it has been removed
-(https://github.com/dtolnay/quote/commit/f621fe64a8a501cae8e95ebd6848e637bbc79078),
-and is likely completely unused. Even when used, this API shouldn't be able to
-cause unsoundness.
-"""
+delta = "0.3.25 -> 0.3.26"
 aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
 
-[[audits.mozilla.audits.proc-macro2]]
-who = "Mike Hommey <mh+mozilla@glandium.org>"
+[[audits.mozilla.audits.rayon]]
+who = "Josh Stone <jistone@redhat.com>"
 criteria = "safe-to-deploy"
-delta = "1.0.39 -> 1.0.43"
+version = "1.5.3"
+notes = "All code written or reviewed by Josh Stone or Niko Matsakis."
 aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
 
-[[audits.mozilla.audits.proc-macro2]]
-who = "Mike Hommey <mh+mozilla@glandium.org>"
+[[audits.mozilla.audits.rayon-core]]
+who = "Josh Stone <jistone@redhat.com>"
 criteria = "safe-to-deploy"
-delta = "1.0.43 -> 1.0.49"
+version = "1.9.3"
+notes = "All code written or reviewed by Josh Stone or Niko Matsakis."
 aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
 
-[[audits.mozilla.audits.proc-macro2]]
+[[audits.mozilla.audits.rayon-core]]
 who = "Mike Hommey <mh+mozilla@glandium.org>"
 criteria = "safe-to-deploy"
-delta = "1.0.49 -> 1.0.51"
+delta = "1.9.3 -> 1.10.1"
 aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
 
-[[audits.mozilla.audits.proc-macro2]]
-who = "Jan-Erik Rediger <jrediger@mozilla.com>"
+[[audits.mozilla.audits.rayon-core]]
+who = "Mike Hommey <mh+mozilla@glandium.org>"
 criteria = "safe-to-deploy"
-delta = "1.0.57 -> 1.0.59"
-notes = "Enabled on Wasm"
-aggregated-from = "https://raw.githubusercontent.com/mozilla/glean/main/supply-chain/audits.toml"
+delta = "1.10.1 -> 1.10.2"
+aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
 
-[[audits.mozilla.audits.rayon]]
-who = "Josh Stone <jistone@redhat.com>"
+[[audits.mozilla.audits.redox_syscall]]
+who = "Mike Hommey <mh+mozilla@glandium.org>"
 criteria = "safe-to-deploy"
-version = "1.5.3"
-notes = "All code written or reviewed by Josh Stone or Niko Matsakis."
+delta = "0.2.13 -> 0.2.16"
 aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
 
-[[audits.mozilla.audits.rayon-core]]
-who = "Josh Stone <jistone@redhat.com>"
+[[audits.mozilla.audits.redox_syscall]]
+who = "Jan-Erik Rediger <jrediger@mozilla.com>"
 criteria = "safe-to-deploy"
-version = "1.9.3"
-notes = "All code written or reviewed by Josh Stone or Niko Matsakis."
-aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
+delta = "0.2.16 -> 0.3.5"
+aggregated-from = "https://raw.githubusercontent.com/mozilla/glean/main/supply-chain/audits.toml"
 
 [[audits.mozilla.audits.rustc-hash]]
 who = "Bobby Holley <bobbyholley@gmail.com>"
@@ -2587,6 +2245,25 @@ version = "1.1.0"
 notes = "Straightforward crate with no unsafe code, does what it says on the tin."
 aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
 
+[[audits.mozilla.audits.rustversion]]
+who = "Bobby Holley <bobbyholley@gmail.com>"
+criteria = "safe-to-deploy"
+version = "1.0.9"
+notes = """
+This crate has a build-time component and procedural macro logic, which I looked
+at enough to convince myself it wasn't going to do anything dramatically wrong.
+I don't think logic bugs in the version parsing etc can realistically introduce
+a security vulnerability.
+"""
+aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
+
+[[audits.mozilla.audits.rustversion]]
+who = "Jan-Erik Rediger <jrediger@mozilla.com>"
+criteria = "safe-to-deploy"
+delta = "1.0.9 -> 1.0.14"
+notes = "Doc updates, minimal CI changes and a fix to build-script reruns"
+aggregated-from = "https://raw.githubusercontent.com/mozilla/glean/main/supply-chain/audits.toml"
+
 [[audits.mozilla.audits.similar]]
 who = "Nika Layzell <nika@thelayzells.com>"
 criteria = "safe-to-deploy"
@@ -2604,15 +2281,22 @@ delta = "0.4.6 -> 0.4.7"
 aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
 
 [[audits.mozilla.audits.socket2]]
-who = "Mike Hommey <mh+mozilla@glandium.org>"
+who = "Kershaw Chang <kershaw@mozilla.com>"
 criteria = "safe-to-deploy"
-delta = "0.4.4 -> 0.4.7"
+delta = "0.5.5 -> 0.5.7"
 aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
 
-[[audits.mozilla.audits.toml]]
-who = "Bobby Holley <bobbyholley@gmail.com>"
+[[audits.mozilla.audits.subtle]]
+who = "Simon Friedberger <simon@mozilla.com>"
+criteria = "safe-to-deploy"
+version = "2.5.0"
+notes = "The goal is to provide some constant-time correctness for cryptographic implementations. The approach is reasonable, it is known to be insufficient but this is pointed out in the documentation."
+aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
+
+[[audits.mozilla.audits.tempfile]]
+who = "Mike Hommey <mh+mozilla@glandium.org>"
 criteria = "safe-to-deploy"
-delta = "0.5.7 -> 0.5.9"
+delta = "3.6.0 -> 3.8.0"
 aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
 
 [[audits.mozilla.audits.unicode-normalization]]
@@ -2627,3 +2311,23 @@ who = "Mike Hommey <mh+mozilla@glandium.org>"
 criteria = "safe-to-deploy"
 delta = "0.1.20 -> 0.1.21"
 aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
+
+[[audits.mozilla.audits.zerocopy]]
+who = "Alex Franchuk <afranchuk@mozilla.com>"
+criteria = "safe-to-deploy"
+version = "0.7.32"
+notes = """
+This crate is `no_std` so doesn't use any side-effectful std functions. It
+contains quite a lot of `unsafe` code, however. I verified portions of this. It
+also has a large, thorough test suite. The project claims to run tests with
+Miri to have stronger soundness checks, and also claims to use formal
+verification tools to prove correctness.
+"""
+aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
+
+[[audits.mozilla.audits.zerocopy-derive]]
+who = "Alex Franchuk <afranchuk@mozilla.com>"
+criteria = "safe-to-deploy"
+version = "0.7.32"
+notes = "Clean, safe macros for zerocopy."
+aggregated-from = "https://hg.mozilla.org/mozilla-central/raw-file/tip/supply-chain/audits.toml"
diff --git a/tests/all/arrays.rs b/tests/all/arrays.rs
new file mode 100644
index 000000000000..3a2d271af0b4
--- /dev/null
+++ b/tests/all/arrays.rs
@@ -0,0 +1,888 @@
+use wasmtime::*;
+
+fn gc_store() -> Result<Store<()>> {
+    let _ = env_logger::try_init();
+
+    let mut config = Config::new();
+    config.wasm_function_references(true);
+    config.wasm_gc(true);
+
+    let engine = Engine::new(&config)?;
+    Ok(Store::new(&engine, ()))
+}
+
+#[test]
+fn array_new_empty() -> Result<()> {
+    let mut store = gc_store()?;
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Const, StorageType::I8),
+    );
+    let pre = ArrayRefPre::new(&mut store, array_ty);
+    let array = ArrayRef::new(&mut store, &pre, &Val::I32(0), 0)?;
+    assert_eq!(array.len(&store)?, 0);
+    Ok(())
+}
+
+#[test]
+fn array_new_with_elems() -> Result<()> {
+    let mut store = gc_store()?;
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Const, ValType::I32.into()),
+    );
+    let pre = ArrayRefPre::new(&mut store, array_ty);
+    let array = ArrayRef::new(&mut store, &pre, &Val::I32(99), 3)?;
+    assert_eq!(array.len(&store)?, 3);
+    for i in 0..3 {
+        assert_eq!(array.get(&mut store, i)?.unwrap_i32(), 99);
+    }
+    Ok(())
+}
+
+#[test]
+fn array_new_unrooted_initial_elem() -> Result<()> {
+    let mut store = gc_store()?;
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Var, StorageType::ValType(ValType::ANYREF)),
+    );
+    let pre = ArrayRefPre::new(&mut store, array_ty);
+
+    // Passing an unrooted `anyref` to `StructRef::new` results in an error.
+    let anyref = {
+        let mut scope = RootScope::new(&mut store);
+        AnyRef::from_i31(&mut scope, I31::new_i32(1234).unwrap())
+    };
+
+    assert!(ArrayRef::new(&mut store, &pre, &anyref.into(), 3).is_err());
+    Ok(())
+}
+
+#[test]
+#[should_panic = "wrong store"]
+fn array_new_cross_store_initial_elem() {
+    let mut store1 = gc_store().unwrap();
+    let mut store2 = gc_store().unwrap();
+
+    let array_ty = ArrayType::new(
+        store1.engine(),
+        FieldType::new(Mutability::Var, StorageType::ValType(ValType::ANYREF)),
+    );
+    let pre = ArrayRefPre::new(&mut store1, array_ty);
+
+    // Passing an `anyref` from a different store to `ArrayRef::new` results in
+    // a panic.
+    let anyref = AnyRef::from_i31(&mut store2, I31::new_i32(1234).unwrap());
+    ArrayRef::new(&mut store1, &pre, &anyref.into(), 3).unwrap();
+}
+
+#[test]
+#[should_panic = "wrong store"]
+fn array_new_cross_store_pre() {
+    let mut store1 = gc_store().unwrap();
+    let mut store2 = gc_store().unwrap();
+
+    let array_ty = ArrayType::new(
+        store1.engine(),
+        FieldType::new(Mutability::Var, StorageType::ValType(ValType::ANYREF)),
+    );
+    let pre = ArrayRefPre::new(&mut store2, array_ty);
+
+    ArrayRef::new(&mut store1, &pre, &Val::I32(0), 3).unwrap();
+}
+
+#[test]
+fn array_new_fixed_empty() -> Result<()> {
+    let mut store = gc_store()?;
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Const, ValType::I32.into()),
+    );
+    let pre = ArrayRefPre::new(&mut store, array_ty);
+    let array = ArrayRef::new_fixed(&mut store, &pre, &[])?;
+    assert_eq!(array.len(&store)?, 0);
+    Ok(())
+}
+
+#[test]
+fn array_new_fixed_with_elems() -> Result<()> {
+    let mut store = gc_store()?;
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Const, ValType::I32.into()),
+    );
+    let pre = ArrayRefPre::new(&mut store, array_ty);
+    let array = ArrayRef::new_fixed(
+        &mut store,
+        &pre,
+        &[Val::I32(11), Val::I32(22), Val::I32(33)],
+    )?;
+    assert_eq!(array.len(&store)?, 3);
+    for i in 0..3 {
+        assert_eq!(array.get(&mut store, i)?.unwrap_i32(), (i as i32 + 1) * 11);
+    }
+    Ok(())
+}
+
+#[test]
+fn array_new_fixed_unrooted_initial_elem() -> Result<()> {
+    let mut store = gc_store()?;
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Var, StorageType::ValType(ValType::ANYREF)),
+    );
+    let pre = ArrayRefPre::new(&mut store, array_ty);
+
+    // Passing an unrooted `anyref` to `StructRef::new` results in an error.
+    let anyref = {
+        let mut scope = RootScope::new(&mut store);
+        AnyRef::from_i31(&mut scope, I31::new_i32(1234).unwrap())
+    };
+
+    assert!(ArrayRef::new_fixed(&mut store, &pre, &[anyref.into()]).is_err());
+    Ok(())
+}
+
+#[test]
+#[should_panic = "wrong store"]
+fn array_new_fixed_cross_store_initial_elem() {
+    let mut store1 = gc_store().unwrap();
+    let mut store2 = gc_store().unwrap();
+
+    let array_ty = ArrayType::new(
+        store1.engine(),
+        FieldType::new(Mutability::Var, StorageType::ValType(ValType::ANYREF)),
+    );
+    let pre = ArrayRefPre::new(&mut store1, array_ty);
+
+    // Passing an `anyref` from a different store to `ArrayRef::new_fixed`
+    // results in a panic.
+    let anyref = AnyRef::from_i31(&mut store2, I31::new_i32(1234).unwrap());
+    ArrayRef::new_fixed(&mut store1, &pre, &[anyref.into()]).unwrap();
+}
+
+#[test]
+#[should_panic = "wrong store"]
+fn array_new_fixed_cross_store_pre() {
+    let mut store1 = gc_store().unwrap();
+    let mut store2 = gc_store().unwrap();
+
+    let array_ty = ArrayType::new(
+        store1.engine(),
+        FieldType::new(Mutability::Var, StorageType::ValType(ValType::ANYREF)),
+    );
+    let pre = ArrayRefPre::new(&mut store2, array_ty);
+
+    ArrayRef::new_fixed(&mut store1, &pre, &[Val::I32(0)]).unwrap();
+}
+
+#[test]
+fn anyref_as_array() -> Result<()> {
+    let mut store = gc_store()?;
+
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Const, StorageType::ValType(ValType::I32)),
+    );
+    let pre = ArrayRefPre::new(&mut store, array_ty);
+    let a0 = ArrayRef::new_fixed(&mut store, &pre, &[])?;
+
+    let anyref: Rooted<AnyRef> = a0.into();
+    assert!(anyref.is_array(&store)?);
+    let a1 = anyref.as_array(&store)?.unwrap();
+    assert!(Rooted::ref_eq(&store, &a0, &a1)?);
+
+    let anyref = AnyRef::from_i31(&mut store, I31::new_i32(42).unwrap());
+    assert!(!anyref.is_array(&store)?);
+    assert!(anyref.as_array(&store)?.is_none());
+
+    Ok(())
+}
+
+#[test]
+fn array_len_empty() -> Result<()> {
+    let mut store = gc_store()?;
+
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Const, ValType::I32.into()),
+    );
+    let pre = ArrayRefPre::new(&mut store, array_ty);
+
+    let array = ArrayRef::new_fixed(&mut store, &pre, &[])?;
+    assert_eq!(array.len(&store)?, 0);
+
+    Ok(())
+}
+
+#[test]
+fn array_len_non_empty() -> Result<()> {
+    let mut store = gc_store()?;
+
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Const, ValType::I32.into()),
+    );
+    let pre = ArrayRefPre::new(&mut store, array_ty);
+
+    let array = ArrayRef::new_fixed(
+        &mut store,
+        &pre,
+        &[Val::I32(11), Val::I32(22), Val::I32(33)],
+    )?;
+    assert_eq!(array.len(&store)?, 3);
+
+    Ok(())
+}
+
+#[test]
+fn array_get_in_bounds() -> Result<()> {
+    let mut store = gc_store()?;
+
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Const, ValType::I32.into()),
+    );
+    let pre = ArrayRefPre::new(&mut store, array_ty);
+
+    let array = ArrayRef::new_fixed(
+        &mut store,
+        &pre,
+        &[Val::I32(11), Val::I32(22), Val::I32(33)],
+    )?;
+
+    assert_eq!(array.get(&mut store, 0)?.unwrap_i32(), 11);
+    assert_eq!(array.get(&mut store, 1)?.unwrap_i32(), 22);
+    assert_eq!(array.get(&mut store, 2)?.unwrap_i32(), 33);
+
+    Ok(())
+}
+
+#[test]
+fn array_get_out_of_bounds() -> Result<()> {
+    let mut store = gc_store()?;
+
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Const, ValType::I32.into()),
+    );
+    let pre = ArrayRefPre::new(&mut store, array_ty);
+
+    let array = ArrayRef::new_fixed(
+        &mut store,
+        &pre,
+        &[Val::I32(11), Val::I32(22), Val::I32(33)],
+    )?;
+
+    assert!(array.get(&mut store, 3).is_err());
+    assert!(array.get(&mut store, 4).is_err());
+
+    Ok(())
+}
+
+#[test]
+fn array_get_on_unrooted() -> Result<()> {
+    let mut store = gc_store()?;
+
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Const, ValType::I32.into()),
+    );
+    let pre = ArrayRefPre::new(&mut store, array_ty);
+
+    let array = {
+        let mut scope = RootScope::new(&mut store);
+        ArrayRef::new_fixed(&mut scope, &pre, &[Val::I32(11)])?
+    };
+
+    assert!(array.get(&mut store, 0).is_err());
+    Ok(())
+}
+
+#[test]
+#[should_panic = "wrong store"]
+fn array_get_wrong_store() {
+    let mut store1 = gc_store().unwrap();
+    let mut store2 = gc_store().unwrap();
+
+    let array_ty = ArrayType::new(
+        store1.engine(),
+        FieldType::new(Mutability::Const, ValType::I32.into()),
+    );
+    let pre = ArrayRefPre::new(&mut store1, array_ty);
+
+    let array = ArrayRef::new_fixed(&mut store1, &pre, &[Val::I32(11)]).unwrap();
+
+    // Should panic.
+    let _ = array.get(&mut store2, 0);
+}
+
+#[test]
+fn array_set_in_bounds() -> Result<()> {
+    let mut store = gc_store()?;
+
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Var, ValType::I32.into()),
+    );
+    let pre = ArrayRefPre::new(&mut store, array_ty);
+
+    let array = ArrayRef::new_fixed(&mut store, &pre, &[Val::I32(11)])?;
+
+    assert_eq!(array.get(&mut store, 0)?.unwrap_i32(), 11);
+    array.set(&mut store, 0, Val::I32(22))?;
+    assert_eq!(array.get(&mut store, 0)?.unwrap_i32(), 22);
+
+    Ok(())
+}
+
+#[test]
+fn array_set_out_of_bounds() -> Result<()> {
+    let mut store = gc_store()?;
+
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Var, ValType::I32.into()),
+    );
+    let pre = ArrayRefPre::new(&mut store, array_ty);
+
+    let array = ArrayRef::new_fixed(&mut store, &pre, &[Val::I32(11)])?;
+
+    assert!(array.set(&mut store, 1, Val::I32(22)).is_err());
+    assert!(array.set(&mut store, 2, Val::I32(33)).is_err());
+
+    Ok(())
+}
+
+#[test]
+fn array_set_on_unrooted() -> Result<()> {
+    let mut store = gc_store()?;
+
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Var, ValType::I32.into()),
+    );
+    let pre = ArrayRefPre::new(&mut store, array_ty);
+
+    let array = {
+        let mut scope = RootScope::new(&mut store);
+        ArrayRef::new_fixed(&mut scope, &pre, &[Val::I32(11)])?
+    };
+
+    assert!(array.set(&mut store, 0, Val::I32(22)).is_err());
+    Ok(())
+}
+
+#[test]
+fn array_set_given_unrooted() -> Result<()> {
+    let mut store = gc_store()?;
+
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Var, ValType::ANYREF.into()),
+    );
+    let pre = ArrayRefPre::new(&mut store, array_ty);
+
+    let array = ArrayRef::new_fixed(&mut store, &pre, &[Val::AnyRef(None)])?;
+
+    let anyref = {
+        let mut scope = RootScope::new(&mut store);
+        AnyRef::from_i31(&mut scope, I31::new_i32(1234).unwrap())
+    };
+
+    assert!(array.set(&mut store, 0, anyref.into()).is_err());
+    Ok(())
+}
+
+#[test]
+#[should_panic = "wrong store"]
+fn array_set_cross_store_value() {
+    let mut store1 = gc_store().unwrap();
+    let mut store2 = gc_store().unwrap();
+
+    let array_ty = ArrayType::new(
+        store1.engine(),
+        FieldType::new(Mutability::Var, ValType::ANYREF.into()),
+    );
+    let pre = ArrayRefPre::new(&mut store1, array_ty);
+
+    let array = ArrayRef::new_fixed(&mut store1, &pre, &[Val::AnyRef(None)]).unwrap();
+
+    let anyref = AnyRef::from_i31(&mut store2, I31::new_i32(1234).unwrap());
+
+    // Should panic.
+    let _ = array.set(&mut store1, 0, anyref.into());
+}
+
+#[test]
+fn array_set_immutable_elems() -> Result<()> {
+    let mut store = gc_store()?;
+
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Const, ValType::I32.into()),
+    );
+    let pre = ArrayRefPre::new(&mut store, array_ty);
+
+    let array = ArrayRef::new_fixed(
+        &mut store,
+        &pre,
+        &[Val::I32(11), Val::I32(22), Val::I32(33)],
+    )?;
+
+    assert!(array.set(&mut store, 0, Val::I32(22)).is_err());
+    assert!(array.set(&mut store, 1, Val::I32(33)).is_err());
+    assert!(array.set(&mut store, 2, Val::I32(44)).is_err());
+
+    Ok(())
+}
+
+#[test]
+fn array_set_wrong_field_type() -> Result<()> {
+    let mut store = gc_store()?;
+
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Var, ValType::I32.into()),
+    );
+    let pre = ArrayRefPre::new(&mut store, array_ty);
+
+    let array = ArrayRef::new_fixed(&mut store, &pre, &[Val::I32(11)])?;
+
+    assert!(array.set(&mut store, 0, Val::I64(22)).is_err());
+    Ok(())
+}
+
+#[test]
+fn array_ty() -> Result<()> {
+    let mut store = gc_store()?;
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Const, ValType::I32.into()),
+    );
+    let pre = ArrayRefPre::new(&mut store, array_ty.clone());
+    let a = ArrayRef::new_fixed(&mut store, &pre, &[Val::I32(11)])?;
+    assert!(ArrayType::eq(&array_ty, &a.ty(&store)?));
+    Ok(())
+}
+
+#[test]
+fn array_ty_unrooted() -> Result<()> {
+    let mut store = gc_store()?;
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Const, ValType::I32.into()),
+    );
+    let pre = ArrayRefPre::new(&mut store, array_ty);
+    let a = {
+        let mut scope = RootScope::new(&mut store);
+        ArrayRef::new_fixed(&mut scope, &pre, &[Val::I32(11)])?
+    };
+    assert!(a.ty(&store).is_err());
+    Ok(())
+}
+
+#[test]
+fn array_elems_empty() -> Result<()> {
+    let mut store = gc_store()?;
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Const, ValType::I32.into()),
+    );
+    let pre = ArrayRefPre::new(&mut store, array_ty);
+    let array = ArrayRef::new_fixed(&mut store, &pre, &[])?;
+    let mut elems = array.elems(&mut store)?;
+    assert_eq!(elems.len(), 0);
+    assert!(elems.next().is_none());
+    Ok(())
+}
+
+#[test]
+fn array_elems_non_empty() -> Result<()> {
+    let mut store = gc_store()?;
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Const, ValType::I32.into()),
+    );
+    let pre = ArrayRefPre::new(&mut store, array_ty);
+    let array = ArrayRef::new_fixed(
+        &mut store,
+        &pre,
+        &[Val::I32(11), Val::I32(22), Val::I32(33)],
+    )?;
+    let mut elems = array.elems(&mut store)?;
+    assert_eq!(elems.len(), 3);
+    assert_eq!(elems.next().unwrap().unwrap_i32(), 11);
+    assert_eq!(elems.next().unwrap().unwrap_i32(), 22);
+    assert_eq!(elems.next().unwrap().unwrap_i32(), 33);
+    assert!(elems.next().is_none());
+    Ok(())
+}
+
+#[test]
+fn array_elems_unrooted() -> Result<()> {
+    let mut store = gc_store()?;
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Const, ValType::I32.into()),
+    );
+    let pre = ArrayRefPre::new(&mut store, array_ty);
+    let array = {
+        let mut scope = RootScope::new(&mut store);
+        ArrayRef::new_fixed(&mut scope, &pre, &[Val::I32(11)])?
+    };
+    assert!(array.elems(&mut store).is_err());
+    Ok(())
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn passing_arrays_through_wasm_with_untyped_calls() -> Result<()> {
+    let mut store = gc_store()?;
+
+    let module = Module::new(
+        store.engine(),
+        r#"
+            (module
+                (type (array i8))
+                (import "" "" (func $f (param (ref 0)) (result (ref 0))))
+                (func (export "run") (param (ref 0)) (result (ref 0))
+                    (call $f (local.get 0))
+                )
+            )
+        "#,
+    )?;
+
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Const, StorageType::I8),
+    );
+
+    let ref_ty = RefType::new(false, HeapType::ConcreteArray(array_ty.clone()));
+    let func_ty = FuncType::new(store.engine(), [ref_ty.clone().into()], [ref_ty.into()]);
+
+    let func = Func::new(&mut store, func_ty, |mut caller, args, results| {
+        let a = args[0].unwrap_any_ref().unwrap();
+        let a = a.unwrap_array(&mut caller)?;
+        assert_eq!(a.len(&mut caller)?, 1);
+        assert_eq!(a.get(&mut caller, 0)?.unwrap_i32(), 42);
+        results[0] = args[0];
+        Ok(())
+    });
+
+    let instance = Instance::new(&mut store, &module, &[func.into()])?;
+    let run = instance.get_func(&mut store, "run").unwrap();
+
+    let pre = ArrayRefPre::new(&mut store, array_ty.clone());
+    let a = ArrayRef::new_fixed(&mut store, &pre, &[Val::I32(42)])?;
+
+    let mut results = vec![Val::null_any_ref()];
+    run.call(&mut store, &[a.into()], &mut results)?;
+
+    let a2 = results[0].unwrap_any_ref().unwrap();
+    let a2 = a2.unwrap_array(&mut store)?;
+    assert_eq!(a2.len(&mut store)?, 1);
+    assert_eq!(a2.get(&mut store, 0)?.unwrap_i32(), 42);
+    assert!(Rooted::ref_eq(&store, &a, &a2)?);
+
+    Ok(())
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn passing_arrays_through_wasm_with_typed_calls() -> Result<()> {
+    let mut store = gc_store()?;
+
+    let module = Module::new(
+        store.engine(),
+        r#"
+            (module
+                (type (array i8))
+                (import "" "" (func $f (param (ref array)) (result (ref array))))
+                (func (export "run") (param (ref 0)) (result (ref array))
+                    (call $f (local.get 0))
+                )
+            )
+        "#,
+    )?;
+
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Const, StorageType::I8),
+    );
+
+    let func = Func::wrap(
+        &mut store,
+        |mut caller: Caller<()>, a: Rooted<ArrayRef>| -> Result<Rooted<ArrayRef>> {
+            assert_eq!(a.len(&caller)?, 1);
+            assert_eq!(a.get(&mut caller, 0)?.unwrap_i32(), 42);
+            Ok(a)
+        },
+    );
+
+    let instance = Instance::new(&mut store, &module, &[func.into()])?;
+    let run = instance.get_typed_func::<Rooted<ArrayRef>, Rooted<ArrayRef>>(&mut store, "run")?;
+
+    let pre = ArrayRefPre::new(&mut store, array_ty.clone());
+    let a = ArrayRef::new_fixed(&mut store, &pre, &[Val::I32(42)])?;
+
+    let a2 = run.call(&mut store, a)?;
+
+    assert_eq!(a2.len(&store)?, 1);
+    assert_eq!(a2.get(&mut store, 0)?.unwrap_i32(), 42);
+    assert!(Rooted::ref_eq(&store, &a, &a2)?);
+
+    Ok(())
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn host_sets_array_global() -> Result<()> {
+    let mut store = gc_store()?;
+
+    let module = Module::new(
+        store.engine(),
+        r#"
+            (module
+                (type (array i8))
+                (global $g (export "g") (mut (ref null 0)) (ref.null 0))
+                (func (export "f") (result (ref null 0))
+                    global.get $g
+                )
+            )
+        "#,
+    )?;
+
+    let instance = Instance::new(&mut store, &module, &[])?;
+    let g = instance.get_global(&mut store, "g").unwrap();
+
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Const, StorageType::I8),
+    );
+    let pre = ArrayRefPre::new(&mut store, array_ty.clone());
+    let a0 = ArrayRef::new_fixed(&mut store, &pre, &[Val::I32(42)])?;
+    g.set(&mut store, a0.into())?;
+
+    // Get the global from the host.
+    let val = g.get(&mut store);
+    let anyref = val.unwrap_anyref().expect("non-null");
+    let a1 = anyref.unwrap_array(&store)?;
+    assert_eq!(a1.len(&store)?, 1);
+    assert_eq!(a1.get(&mut store, 0)?.unwrap_i32(), 42);
+    assert!(Rooted::ref_eq(&store, &a0, &a1)?);
+
+    // Get the global from the guest.
+    let f = instance.get_typed_func::<(), Option<Rooted<ArrayRef>>>(&mut store, "f")?;
+    let a2 = f.call(&mut store, ())?.expect("non-null");
+    assert_eq!(a2.len(&store)?, 1);
+    assert_eq!(a2.get(&mut store, 0)?.unwrap_i32(), 42);
+    assert!(Rooted::ref_eq(&store, &a0, &a2)?);
+
+    Ok(())
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn wasm_sets_array_global() -> Result<()> {
+    let mut store = gc_store()?;
+
+    let module = Module::new(
+        store.engine(),
+        r#"
+            (module
+                (type (array i8))
+                (global $g (export "g") (mut (ref null 0)) (ref.null 0))
+                (func (export "get") (result (ref null 0))
+                    global.get $g
+                )
+                (func (export "set") (param (ref null 0))
+                    local.get 0
+                    global.set $g
+                )
+            )
+        "#,
+    )?;
+
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Const, StorageType::I8),
+    );
+    let pre = ArrayRefPre::new(&mut store, array_ty.clone());
+    let a0 = ArrayRef::new_fixed(&mut store, &pre, &[Val::I32(42)])?;
+
+    let instance = Instance::new(&mut store, &module, &[])?;
+    let set = instance.get_func(&mut store, "set").unwrap();
+    set.call(&mut store, &[a0.into()], &mut [])?;
+
+    // Get the global from the host.
+    let g = instance.get_global(&mut store, "g").unwrap();
+    let val = g.get(&mut store);
+    let anyref = val.unwrap_anyref().expect("non-null");
+    let a1 = anyref.unwrap_array(&store)?;
+    assert_eq!(a1.len(&store)?, 1);
+    assert_eq!(a1.get(&mut store, 0)?.unwrap_i32(), 42);
+    assert!(Rooted::ref_eq(&store, &a0, &a1)?);
+
+    // Get the global from the guest.
+    let f = instance.get_typed_func::<(), Option<Rooted<ArrayRef>>>(&mut store, "get")?;
+    let a2 = f.call(&mut store, ())?.expect("non-null");
+    assert_eq!(a2.len(&store)?, 1);
+    assert_eq!(a2.get(&mut store, 0)?.unwrap_i32(), 42);
+    assert!(Rooted::ref_eq(&store, &a0, &a2)?);
+
+    Ok(())
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn host_sets_array_in_table() -> Result<()> {
+    let mut store = gc_store()?;
+
+    let module = Module::new(
+        store.engine(),
+        r#"
+            (module
+                (type (array i8))
+                (table $t (export "t") 1 1 (ref null 0) (ref.null 0))
+                (func (export "f") (result (ref null 0))
+                    i32.const 0
+                    table.get $t
+                )
+            )
+        "#,
+    )?;
+
+    let instance = Instance::new(&mut store, &module, &[])?;
+    let t = instance.get_table(&mut store, "t").unwrap();
+
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Const, StorageType::I8),
+    );
+    let pre = ArrayRefPre::new(&mut store, array_ty.clone());
+    let a0 = ArrayRef::new_fixed(&mut store, &pre, &[Val::I32(42)])?;
+    t.set(&mut store, 0, a0.into())?;
+
+    // Get the global from the host.
+    let val = t.get(&mut store, 0).expect("in bounds");
+    let anyref = val.unwrap_any().expect("non-null");
+    let a1 = anyref.unwrap_array(&store)?;
+    assert_eq!(a1.len(&store)?, 1);
+    assert_eq!(a1.get(&mut store, 0)?.unwrap_i32(), 42);
+    assert!(Rooted::ref_eq(&store, &a0, &a1)?);
+
+    // Get the global from the guest.
+    let f = instance.get_typed_func::<(), Option<Rooted<ArrayRef>>>(&mut store, "f")?;
+    let a2 = f.call(&mut store, ())?.expect("non-null");
+    assert_eq!(a2.len(&store)?, 1);
+    assert_eq!(a2.get(&mut store, 0)?.unwrap_i32(), 42);
+    assert!(Rooted::ref_eq(&store, &a0, &a2)?);
+
+    Ok(())
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn wasm_sets_array_in_table() -> Result<()> {
+    let mut store = gc_store()?;
+
+    let module = Module::new(
+        store.engine(),
+        r#"
+            (module
+                (type (array i8))
+                (table $t (export "t") 1 1 (ref null 0) (ref.null 0))
+                (func (export "get") (result (ref null 0))
+                    i32.const 0
+                    table.get $t
+                )
+                (func (export "set") (param (ref null 0))
+                    i32.const 0
+                    local.get 0
+                    table.set $t
+                )
+            )
+        "#,
+    )?;
+
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Const, StorageType::I8),
+    );
+    let pre = ArrayRefPre::new(&mut store, array_ty.clone());
+    let a0 = ArrayRef::new_fixed(&mut store, &pre, &[Val::I32(42)])?;
+
+    let instance = Instance::new(&mut store, &module, &[])?;
+    let set = instance.get_func(&mut store, "set").unwrap();
+    set.call(&mut store, &[a0.into()], &mut [])?;
+
+    // Get the global from the host.
+    let t = instance.get_table(&mut store, "t").unwrap();
+    let val = t.get(&mut store, 0).expect("in bounds");
+    let anyref = val.unwrap_any().expect("non-null");
+    let a1 = anyref.unwrap_array(&store)?;
+    assert_eq!(a1.len(&mut store)?, 1);
+    assert_eq!(a1.get(&mut store, 0)?.unwrap_i32(), 42);
+    assert!(Rooted::ref_eq(&store, &a0, &a1)?);
+
+    // Get the global from the guest.
+    let f = instance.get_typed_func::<(), Option<Rooted<ArrayRef>>>(&mut store, "get")?;
+    let a2 = f.call(&mut store, ())?.expect("non-null");
+    assert_eq!(a2.len(&mut store)?, 1);
+    assert_eq!(a2.get(&mut store, 0)?.unwrap_i32(), 42);
+    assert!(Rooted::ref_eq(&store, &a0, &a2)?);
+
+    Ok(())
+}
+
+#[test]
+fn instantiate_with_array_global() -> Result<()> {
+    let mut store = gc_store()?;
+
+    let module = Module::new(
+        store.engine(),
+        r#"
+            (module
+                (type (array i8))
+                (import "" "" (global (ref null 0)))
+                (export "g" (global 0))
+            )
+        "#,
+    )?;
+
+    let array_ty = ArrayType::new(
+        store.engine(),
+        FieldType::new(Mutability::Const, StorageType::I8),
+    );
+    let global_ty = GlobalType::new(
+        ValType::Ref(RefType::new(
+            true,
+            HeapType::ConcreteArray(array_ty.clone()),
+        )),
+        Mutability::Const,
+    );
+
+    // Instantiate with a null-ref global.
+    let g = Global::new(&mut store, global_ty.clone(), Val::AnyRef(None))?;
+    let instance = Instance::new(&mut store, &module, &[g.into()])?;
+    let g = instance.get_global(&mut store, "g").expect("export exists");
+    let val = g.get(&mut store);
+    assert!(val.unwrap_anyref().is_none());
+
+    // Instantiate with a non-null-ref global.
+    let pre = ArrayRefPre::new(&mut store, array_ty);
+    let a0 = ArrayRef::new_fixed(&mut store, &pre, &[Val::I32(42)])?;
+    let g = Global::new(&mut store, global_ty, a0.into())?;
+    let instance = Instance::new(&mut store, &module, &[g.into()])?;
+    let g = instance.get_global(&mut store, "g").expect("export exists");
+    let val = g.get(&mut store);
+    let anyref = val.unwrap_anyref().expect("non-null");
+    let a1 = anyref.unwrap_array(&store)?;
+    assert_eq!(a1.len(&mut store)?, 1);
+    assert_eq!(a1.get(&mut store, 0)?.unwrap_i32(), 42);
+    assert!(Rooted::ref_eq(&store, &a0, &a1)?);
+
+    Ok(())
+}
diff --git a/tests/all/async_functions.rs b/tests/all/async_functions.rs
index f2cac9ffdd77..c94dc4e3b650 100644
--- a/tests/all/async_functions.rs
+++ b/tests/all/async_functions.rs
@@ -1,6 +1,6 @@
 #![cfg(not(miri))]
 
-use anyhow::{anyhow, bail, Result};
+use anyhow::{anyhow, bail};
 use std::future::Future;
 use std::pin::Pin;
 use std::sync::{Arc, Mutex};
@@ -25,15 +25,14 @@ async fn run_smoke_typed_test(store: &mut Store<()>, func: Func) {
 #[tokio::test]
 async fn smoke() {
     let mut store = async_store();
-    let func = Func::new_async(
-        &mut store,
-        FuncType::new(None, None),
-        move |_caller, _params, _results| Box::new(async { Ok(()) }),
-    );
+    let func_ty = FuncType::new(store.engine(), None, None);
+    let func = Func::new_async(&mut store, func_ty, move |_caller, _params, _results| {
+        Box::new(async { Ok(()) })
+    });
     run_smoke_test(&mut store, func).await;
     run_smoke_typed_test(&mut store, func).await;
 
-    let func = Func::wrap0_async(&mut store, move |_caller| Box::new(async { Ok(()) }));
+    let func = Func::wrap_async(&mut store, move |_caller, _: ()| Box::new(async { Ok(()) }));
     run_smoke_test(&mut store, func).await;
     run_smoke_typed_test(&mut store, func).await;
 }
@@ -46,11 +45,13 @@ async fn smoke_host_func() -> Result<()> {
     linker.func_new_async(
         "",
         "first",
-        FuncType::new(None, None),
+        FuncType::new(store.engine(), None, None),
         move |_caller, _params, _results| Box::new(async { Ok(()) }),
     )?;
 
-    linker.func_wrap0_async("", "second", move |_caller| Box::new(async { Ok(()) }))?;
+    linker.func_wrap_async("", "second", move |_caller, _: ()| {
+        Box::new(async { Ok(()) })
+    })?;
 
     let func = linker
         .get(&mut store, "", "first")
@@ -74,20 +75,17 @@ async fn smoke_host_func() -> Result<()> {
 #[tokio::test]
 async fn smoke_with_suspension() {
     let mut store = async_store();
-    let func = Func::new_async(
-        &mut store,
-        FuncType::new(None, None),
-        move |_caller, _params, _results| {
-            Box::new(async {
-                tokio::task::yield_now().await;
-                Ok(())
-            })
-        },
-    );
+    let func_ty = FuncType::new(store.engine(), None, None);
+    let func = Func::new_async(&mut store, func_ty, move |_caller, _params, _results| {
+        Box::new(async {
+            tokio::task::yield_now().await;
+            Ok(())
+        })
+    });
     run_smoke_test(&mut store, func).await;
     run_smoke_typed_test(&mut store, func).await;
 
-    let func = Func::wrap0_async(&mut store, move |_caller| {
+    let func = Func::wrap_async(&mut store, move |_caller, _: ()| {
         Box::new(async {
             tokio::task::yield_now().await;
             Ok(())
@@ -105,7 +103,7 @@ async fn smoke_host_func_with_suspension() -> Result<()> {
     linker.func_new_async(
         "",
         "first",
-        FuncType::new(None, None),
+        FuncType::new(store.engine(), None, None),
         move |_caller, _params, _results| {
             Box::new(async {
                 tokio::task::yield_now().await;
@@ -114,7 +112,7 @@ async fn smoke_host_func_with_suspension() -> Result<()> {
         },
     )?;
 
-    linker.func_wrap0_async("", "second", move |_caller| {
+    linker.func_wrap_async("", "second", move |_caller, _: ()| {
         Box::new(async {
             tokio::task::yield_now().await;
             Ok(())
@@ -143,32 +141,26 @@ async fn smoke_host_func_with_suspension() -> Result<()> {
 #[tokio::test]
 async fn recursive_call() {
     let mut store = async_store();
-    let async_wasm_func = Func::new_async(
-        &mut store,
-        FuncType::new(None, None),
-        |_caller, _params, _results| {
-            Box::new(async {
-                tokio::task::yield_now().await;
-                Ok(())
-            })
-        },
-    );
+    let func_ty = FuncType::new(store.engine(), None, None);
+    let async_wasm_func = Func::new_async(&mut store, func_ty, |_caller, _params, _results| {
+        Box::new(async {
+            tokio::task::yield_now().await;
+            Ok(())
+        })
+    });
 
     // Create an imported function which recursively invokes another wasm
     // function asynchronously, although this one is just our own host function
     // which suffices for this test.
-    let func2 = Func::new_async(
-        &mut store,
-        FuncType::new(None, None),
-        move |mut caller, _params, _results| {
-            Box::new(async move {
-                async_wasm_func
-                    .call_async(&mut caller, &[], &mut [])
-                    .await?;
-                Ok(())
-            })
-        },
-    );
+    let func_ty = FuncType::new(store.engine(), None, None);
+    let func2 = Func::new_async(&mut store, func_ty, move |mut caller, _params, _results| {
+        Box::new(async move {
+            async_wasm_func
+                .call_async(&mut caller, &[], &mut [])
+                .await?;
+            Ok(())
+        })
+    });
 
     // Create an instance which calls an async import twice.
     let module = Module::new(
@@ -204,36 +196,30 @@ async fn suspend_while_suspending() {
     // The purpose of this test is intended to stress various cases in how
     // we manage pointers in ways that are not necessarily common but are still
     // possible in safe code.
-    let async_thunk = Func::new_async(
-        &mut store,
-        FuncType::new(None, None),
-        |_caller, _params, _results| Box::new(async { Ok(()) }),
-    );
-    let sync_call_async_thunk = Func::new(
-        &mut store,
-        FuncType::new(None, None),
-        move |mut caller, _params, _results| {
+    let func_ty = FuncType::new(store.engine(), None, None);
+    let async_thunk = Func::new_async(&mut store, func_ty, |_caller, _params, _results| {
+        Box::new(async { Ok(()) })
+    });
+    let func_ty = FuncType::new(store.engine(), None, None);
+    let sync_call_async_thunk =
+        Func::new(&mut store, func_ty, move |mut caller, _params, _results| {
             let mut future = Box::pin(async_thunk.call_async(&mut caller, &[], &mut []));
             let poll = future
                 .as_mut()
                 .poll(&mut Context::from_waker(&noop_waker()));
             assert!(poll.is_ready());
             Ok(())
-        },
-    );
+        });
 
     // A small async function that simply awaits once to pump the loops and
     // then finishes.
-    let async_import = Func::new_async(
-        &mut store,
-        FuncType::new(None, None),
-        move |_caller, _params, _results| {
-            Box::new(async move {
-                tokio::task::yield_now().await;
-                Ok(())
-            })
-        },
-    );
+    let func_ty = FuncType::new(store.engine(), None, None);
+    let async_import = Func::new_async(&mut store, func_ty, move |_caller, _params, _results| {
+        Box::new(async move {
+            tokio::task::yield_now().await;
+            Ok(())
+        })
+    });
 
     let module = Module::new(
         store.engine(),
@@ -264,23 +250,20 @@ async fn suspend_while_suspending() {
 async fn cancel_during_run() {
     let mut store = Store::new(&Engine::new(Config::new().async_support(true)).unwrap(), 0);
 
-    let async_thunk = Func::new_async(
-        &mut store,
-        FuncType::new(None, None),
-        move |mut caller, _params, _results| {
-            assert_eq!(*caller.data(), 0);
-            *caller.data_mut() = 1;
-            let dtor = SetOnDrop(caller);
-            Box::new(async move {
-                // SetOnDrop is not destroyed when dropping the reference of it
-                // here. Instead, it is moved into the future where it's forced
-                // to live in and will be destroyed at the end of the future.
-                let _ = &dtor;
-                tokio::task::yield_now().await;
-                Ok(())
-            })
-        },
-    );
+    let func_ty = FuncType::new(store.engine(), None, None);
+    let async_thunk = Func::new_async(&mut store, func_ty, move |mut caller, _params, _results| {
+        assert_eq!(*caller.data(), 0);
+        *caller.data_mut() = 1;
+        let dtor = SetOnDrop(caller);
+        Box::new(async move {
+            // SetOnDrop is not destroyed when dropping the reference of it
+            // here. Instead, it is moved into the future where it's forced
+            // to live in and will be destroyed at the end of the future.
+            let _ = &dtor;
+            tokio::task::yield_now().await;
+            Ok(())
+        })
+    });
     // Shouldn't have called anything yet...
     assert_eq!(*store.data(), 0);
 
@@ -311,7 +294,8 @@ async fn cancel_during_run() {
 async fn iloop_with_fuel() {
     let engine = Engine::new(Config::new().async_support(true).consume_fuel(true)).unwrap();
     let mut store = Store::new(&engine, ());
-    store.out_of_fuel_async_yield(1_000, 10);
+    store.set_fuel(10_000).unwrap();
+    store.fuel_async_yield_interval(Some(100)).unwrap();
     let module = Module::new(
         &engine,
         "
@@ -326,14 +310,15 @@ async fn iloop_with_fuel() {
 
     // This should yield a bunch of times but eventually finish
     let (_, pending) = CountPending::new(Box::pin(instance)).await;
-    assert!(pending > 100);
+    assert_eq!(pending, 99);
 }
 
 #[tokio::test]
 async fn fuel_eventually_finishes() {
     let engine = Engine::new(Config::new().async_support(true).consume_fuel(true)).unwrap();
     let mut store = Store::new(&engine, ());
-    store.out_of_fuel_async_yield(u64::max_value(), 10);
+    store.set_fuel(u64::MAX).unwrap();
+    store.fuel_async_yield_interval(Some(10)).unwrap();
     let module = Module::new(
         &engine,
         "
@@ -361,21 +346,22 @@ async fn fuel_eventually_finishes() {
 #[tokio::test]
 async fn async_with_pooling_stacks() {
     let mut pool = crate::small_pool_config();
-    pool.total_stacks(1).memory_pages(1).table_elements(0);
+    pool.total_stacks(1)
+        .max_memory_size(1 << 16)
+        .table_elements(0);
     let mut config = Config::new();
     config.async_support(true);
     config.allocation_strategy(InstanceAllocationStrategy::Pooling(pool));
     config.dynamic_memory_guard_size(0);
     config.static_memory_guard_size(0);
-    config.static_memory_maximum_size(65536);
+    config.static_memory_maximum_size(1 << 16);
 
     let engine = Engine::new(&config).unwrap();
     let mut store = Store::new(&engine, ());
-    let func = Func::new_async(
-        &mut store,
-        FuncType::new(None, None),
-        move |_caller, _params, _results| Box::new(async { Ok(()) }),
-    );
+    let func_ty = FuncType::new(store.engine(), None, None);
+    let func = Func::new_async(&mut store, func_ty, move |_caller, _params, _results| {
+        Box::new(async { Ok(()) })
+    });
 
     run_smoke_test(&mut store, func).await;
     run_smoke_typed_test(&mut store, func).await;
@@ -384,20 +370,23 @@ async fn async_with_pooling_stacks() {
 #[tokio::test]
 async fn async_host_func_with_pooling_stacks() -> Result<()> {
     let mut pooling = crate::small_pool_config();
-    pooling.total_stacks(1).memory_pages(1).table_elements(0);
+    pooling
+        .total_stacks(1)
+        .max_memory_size(1 << 16)
+        .table_elements(0);
     let mut config = Config::new();
     config.async_support(true);
     config.allocation_strategy(InstanceAllocationStrategy::Pooling(pooling));
     config.dynamic_memory_guard_size(0);
     config.static_memory_guard_size(0);
-    config.static_memory_maximum_size(65536);
+    config.static_memory_maximum_size(1 << 16);
 
     let mut store = Store::new(&Engine::new(&config)?, ());
     let mut linker = Linker::new(store.engine());
     linker.func_new_async(
         "",
         "",
-        FuncType::new(None, None),
+        FuncType::new(store.engine(), None, None),
         move |_caller, _params, _results| Box::new(async { Ok(()) }),
     )?;
 
@@ -407,6 +396,84 @@ async fn async_host_func_with_pooling_stacks() -> Result<()> {
     Ok(())
 }
 
+#[tokio::test]
+async fn async_mpk_protection() -> Result<()> {
+    let _ = env_logger::try_init();
+
+    // Construct a pool with MPK protection enabled; note that the MPK
+    // protection is configured in `small_pool_config`.
+    let mut pooling = crate::small_pool_config();
+    pooling
+        .total_memories(10)
+        .total_stacks(2)
+        .max_memory_size(1 << 16)
+        .table_elements(0);
+    let mut config = Config::new();
+    config.async_support(true);
+    config.allocation_strategy(InstanceAllocationStrategy::Pooling(pooling));
+    config.static_memory_maximum_size(1 << 26);
+    config.epoch_interruption(true);
+    let engine = Engine::new(&config)?;
+
+    // Craft a module that loops for several iterations and checks whether it
+    // has access to its memory range (0x0-0x10000).
+    const WAT: &str = "
+    (module
+        (func $start
+            (local $i i32)
+            (local.set $i (i32.const 3))
+            (loop $cont
+                (drop (i32.load (i32.const 0)))
+                (drop (i32.load (i32.const 0xfffc)))
+                (br_if $cont (local.tee $i (i32.sub (local.get $i) (i32.const 1))))))
+        (memory 1)
+        (start $start))
+    ";
+
+    // Start two instances of the module in separate fibers, `a` and `b`.
+    async fn run_instance(engine: &Engine, name: &str) -> Instance {
+        let mut store = Store::new(&engine, ());
+        store.set_epoch_deadline(0);
+        store.epoch_deadline_async_yield_and_update(0);
+        let module = Module::new(store.engine(), WAT).unwrap();
+        println!("[{name}] building instance");
+        Instance::new_async(&mut store, &module, &[]).await.unwrap()
+    }
+    let mut a = Box::pin(run_instance(&engine, "a"));
+    let mut b = Box::pin(run_instance(&engine, "b"));
+
+    // Alternately poll each instance until completion. This should exercise
+    // fiber suspensions requiring the `Store` to appropriately save and restore
+    // the PKRU context between suspensions (see `AsyncCx::block_on`).
+    for i in 0..10 {
+        if i % 2 == 0 {
+            match PollOnce::new(a).await {
+                Ok(_) => {
+                    println!("[a] done");
+                    break;
+                }
+                Err(a_) => {
+                    println!("[a] not done");
+                    a = a_;
+                }
+            }
+        } else {
+            match PollOnce::new(b).await {
+                Ok(_) => {
+                    println!("[b] done");
+                    break;
+                }
+                Err(b_) => {
+                    println!("[b] not done");
+                    b = b_;
+                }
+            }
+        }
+    }
+
+    Ok(())
+}
+
 /// This will execute the `future` provided to completion and each invocation of
 /// `poll` for the future will be executed on a separate thread.
 pub async fn execute_across_threads<F>(future: F) -> F::Output
@@ -444,7 +511,7 @@ async fn resume_separate_thread() {
             ",
         )
         .unwrap();
-        let func = Func::wrap0_async(&mut store, |_| {
+        let func = Func::wrap_async(&mut store, |_, _: ()| {
             Box::new(async {
                 tokio::task::yield_now().await;
                 Err::<(), _>(anyhow!("test"))
@@ -476,7 +543,7 @@ async fn resume_separate_thread2() {
             ",
         )
         .unwrap();
-        let func = Func::wrap0_async(&mut store, |_| {
+        let func = Func::wrap_async(&mut store, |_, _: ()| {
             Box::new(async {
                 tokio::task::yield_now().await;
             })
@@ -517,7 +584,7 @@ async fn resume_separate_thread3() {
                 ",
             )
             .unwrap();
-            let func = Func::wrap0_async(&mut store, |_| {
+            let func = Func::wrap_async(&mut store, |_, _: ()| {
                 Box::new(async {
                     tokio::task::yield_now().await;
                 })
@@ -562,7 +629,9 @@ async fn recursive_async() -> Result<()> {
     let i = Instance::new_async(&mut store, &m, &[]).await?;
     let overflow = i.get_typed_func::<(), ()>(&mut store, "overflow")?;
     let normal = i.get_typed_func::<(), ()>(&mut store, "normal")?;
-    let f2 = Func::wrap0_async(&mut store, move |mut caller| {
+    let f2 = Func::wrap_async(&mut store, move |mut caller, _: ()| {
+        let normal = normal.clone();
+        let overflow = overflow.clone();
         Box::new(async move {
             // recursive async calls shouldn't immediately stack overflow...
             normal.call_async(&mut caller, ()).await?;
@@ -586,6 +655,7 @@ async fn recursive_async() -> Result<()> {
 async fn linker_module_command() -> Result<()> {
     let mut store = async_store();
     let mut linker = Linker::new(store.engine());
+
     let module1 = Module::new(
         store.engine(),
         r#"
@@ -601,6 +671,7 @@ async fn linker_module_command() -> Result<()> {
             )
         "#,
     )?;
+
     let module2 = Module::new(
         store.engine(),
         r#"
@@ -762,17 +833,17 @@ async fn non_stacky_async_activations() -> Result<()> {
         stacks.push(wasmtime::WasmBacktrace::force_capture(store));
     }
 
-    linker1.func_wrap0_async("", "host_capture_stack", {
+    linker1.func_wrap_async("", "host_capture_stack", {
         let stacks = stacks.clone();
-        move |caller| {
+        move |caller, _: ()| {
             capture_stack(&stacks, &caller);
             Box::new(async { Ok(()) })
         }
     })?;
 
-    linker1.func_wrap0_async("", "start_async_instance", {
+    linker1.func_wrap_async("", "start_async_instance", {
         let stacks = stacks.clone();
-        move |mut caller| {
+        move |mut caller, _: ()| {
             let stacks = stacks.clone();
             capture_stack(&stacks, &caller);
 
@@ -780,9 +851,9 @@ async fn non_stacky_async_activations() -> Result<()> {
             let mut store2 = Store::new(caller.engine(), ());
             let mut linker2 = Linker::new(caller.engine());
             linker2
-                .func_wrap0_async("", "yield", {
+                .func_wrap_async("", "yield", {
                     let stacks = stacks.clone();
-                    move |caller| {
+                    move |caller, _: ()| {
                         let stacks = stacks.clone();
                         Box::new(async move {
                             capture_stack(&stacks, &caller);
@@ -858,6 +929,8 @@ async fn non_stacky_async_activations() -> Result<()> {
 
 #[tokio::test]
 async fn gc_preserves_externref_on_historical_async_stacks() -> Result<()> {
+    let _ = env_logger::try_init();
+
     let mut config = Config::new();
     config.async_support(true);
     let engine = Engine::new(&config)?;
@@ -888,27 +961,98 @@ async fn gc_preserves_externref_on_historical_async_stacks() -> Result<()> {
         "#,
     )?;
 
-    type F = TypedFunc<(i32, Option<ExternRef>), ()>;
+    type F = TypedFunc<(i32, Option<Rooted<ExternRef>>), ()>;
 
     let mut store = Store::new(&engine, None);
     let mut linker = Linker::<Option<F>>::new(&engine);
     linker.func_wrap("", "gc", |mut cx: Caller<'_, _>| cx.gc())?;
-    linker.func_wrap("", "test", |val: i32, handle: Option<ExternRef>| {
-        assert_eq!(handle.unwrap().data().downcast_ref(), Some(&val));
+    linker.func_wrap(
+        "",
+        "test",
+        |cx: Caller<'_, _>, val: i32, handle: Option<Rooted<ExternRef>>| -> Result<()> {
+            assert_eq!(handle.unwrap().data(&cx)?.downcast_ref(), Some(&val));
+            Ok(())
+        },
+    )?;
+    linker.func_wrap_async(
+        "",
+        "recurse",
+        |mut cx: Caller<'_, Option<F>>, (val,): (i32,)| {
+            let func = cx.data().clone().unwrap();
+            Box::new(async move {
+                let r = Some(ExternRef::new(&mut cx, val)?);
+                Ok(func.call_async(&mut cx, (val, r)).await)
+            })
+        },
+    )?;
+    let instance = linker.instantiate_async(&mut store, &module).await?;
+    let func: F = instance.get_typed_func(&mut store, "run")?;
+    *store.data_mut() = Some(func.clone());
+
+    let r = Some(ExternRef::new(&mut store, 5)?);
+    func.call_async(&mut store, (5, r)).await?;
+
+    Ok(())
+}
+
+#[tokio::test]
+async fn async_gc_with_func_new_and_func_wrap() -> Result<()> {
+    let _ = env_logger::try_init();
+
+    let mut config = Config::new();
+    config.async_support(true);
+    let engine = Engine::new(&config)?;
+
+    let module = Module::new(
+        &engine,
+        r#"
+            (module $m1
+                (import "" "a" (func $a (result externref)))
+                (import "" "b" (func $b (result externref)))
+
+                (table 2 funcref)
+                (elem (i32.const 0) func $a $b)
+
+                (func (export "a")
+                    (call $call (i32.const 0))
+                )
+                (func (export "b")
+                    (call $call (i32.const 1))
+                )
+
+                (func $call (param i32)
+                    (local $cnt i32)
+                    (loop $l
+                        (drop (call_indirect (result externref) (local.get 0)))
+                        (local.set $cnt (i32.add (local.get $cnt) (i32.const 1)))
+
+                        (if (i32.lt_u (local.get $cnt) (i32.const 1000))
+                         (then (br $l)))
+                    )
+                )
+            )
+        "#,
+    )?;
+
+    let mut linker = Linker::new(&engine);
+    linker.func_wrap("", "a", |mut cx: Caller<'_, _>| {
+        Ok(Some(ExternRef::new(&mut cx, 100)?))
     })?;
-    linker.func_wrap1_async("", "recurse", |mut cx: Caller<'_, _>, val: i32| {
-        let func = cx.data().unwrap();
-        Box::new(async move {
-            func.call_async(&mut cx, (val, Some(ExternRef::new(val))))
-                .await
-        })
+    let ty = FuncType::new(&engine, [], [ValType::EXTERNREF]);
+    linker.func_new("", "b", ty, |mut cx, _, results| {
+        results[0] = ExternRef::new(&mut cx, 100)?.into();
+        Ok(())
     })?;
+
+    let mut store = Store::new(&engine, ());
     let instance = linker.instantiate_async(&mut store, &module).await?;
-    let func: F = instance.get_typed_func(&mut store, "run")?;
-    *store.data_mut() = Some(func);
+    let a = instance.get_typed_func::<(), ()>(&mut store, "a")?;
+    a.call_async(&mut store, ()).await?;
 
-    func.call_async(&mut store, (5, Some(ExternRef::new(5))))
-        .await?;
+    let mut store = Store::new(&engine, ());
+    let instance = linker.instantiate_async(&mut store, &module).await?;
+    let b = instance.get_typed_func::<(), ()>(&mut store, "b")?;
+    b.call_async(&mut store, ()).await?;
 
     Ok(())
 }
diff --git a/tests/all/call_hook.rs b/tests/all/call_hook.rs
index 9d47ecb85d8b..ef565f6261aa 100644
--- a/tests/all/call_hook.rs
+++ b/tests/all/call_hook.rs
@@ -1,6 +1,6 @@
 #![cfg(not(miri))]
 
-use anyhow::{bail, Error, Result};
+use anyhow::bail;
 use std::future::Future;
 use std::pin::Pin;
 use std::task::{self, Poll};
@@ -10,7 +10,7 @@ use wasmtime::*;
 #[test]
 fn call_wrapped_func() -> Result<(), Error> {
     let mut store = Store::<State>::default();
-    store.call_hook(State::call_hook);
+    store.call_hook(sync_call_hook);
 
     fn verify(state: &State) {
         // Calling this func will switch context into wasm, then back to host:
@@ -32,9 +32,14 @@ fn call_wrapped_func() -> Result<(), Error> {
             assert_eq!(d, 4.0);
         },
     ));
+    let func_ty = FuncType::new(
+        store.engine(),
+        [ValType::I32, ValType::I64, ValType::F32, ValType::F64],
+        [],
+    );
     funcs.push(Func::new(
         &mut store,
-        FuncType::new([ValType::I32, ValType::I64, ValType::F32, ValType::F64], []),
+        func_ty,
         |caller: Caller<State>, params, results| {
             verify(caller.data());
 
@@ -47,20 +52,21 @@ fn call_wrapped_func() -> Result<(), Error> {
             Ok(())
         },
     ));
+    let func_ty = FuncType::new(
+        store.engine(),
+        [ValType::I32, ValType::I64, ValType::F32, ValType::F64],
+        [],
+    );
     funcs.push(unsafe {
-        Func::new_unchecked(
-            &mut store,
-            FuncType::new([ValType::I32, ValType::I64, ValType::F32, ValType::F64], []),
-            |caller: Caller<State>, space| {
-                verify(caller.data());
-
-                assert_eq!(space[0].get_i32(), 1i32);
-                assert_eq!(space[1].get_i64(), 2i64);
-                assert_eq!(space[2].get_f32(), 3.0f32.to_bits());
-                assert_eq!(space[3].get_f64(), 4.0f64.to_bits());
-                Ok(())
-            },
-        )
+        Func::new_unchecked(&mut store, func_ty, |caller: Caller<State>, space| {
+            verify(caller.data());
+
+            assert_eq!(space[0].get_i32(), 1i32);
+            assert_eq!(space[1].get_i64(), 2i64);
+            assert_eq!(space[2].get_f32(), 3.0f32.to_bits());
+            assert_eq!(space[3].get_f64(), 4.0f64.to_bits());
+            Ok(())
+        })
     });
 
     let mut n = 0;
@@ -89,10 +95,10 @@ fn call_wrapped_func() -> Result<(), Error> {
 
         unsafe {
             let mut args = [
-                Val::I32(1).to_raw(&mut store),
-                Val::I64(2).to_raw(&mut store),
-                Val::F32(3.0f32.to_bits()).to_raw(&mut store),
-                Val::F64(4.0f64.to_bits()).to_raw(&mut store),
+                Val::I32(1).to_raw(&mut store)?,
+                Val::I64(2).to_raw(&mut store)?,
+                Val::F32(3.0f32.to_bits()).to_raw(&mut store)?,
+                Val::F64(4.0f64.to_bits()).to_raw(&mut store)?,
             ];
             f.call_unchecked(&mut store, args.as_mut_ptr(), args.len())?;
         }
@@ -114,10 +120,10 @@ async fn call_wrapped_async_func() -> Result<(), Error> {
     config.async_support(true);
     let engine = Engine::new(&config)?;
     let mut store = Store::new(&engine, State::default());
-    store.call_hook(State::call_hook);
-    let f = Func::wrap4_async(
+    store.call_hook(sync_call_hook);
+    let f = Func::wrap_async(
         &mut store,
-        |caller: Caller<State>, a: i32, b: i64, c: f32, d: f64| {
+        |caller: Caller<State>, (a, b, c, d): (i32, i64, f32, f64)| {
             Box::new(async move {
                 // Calling this func will switch context into wasm, then back to host:
                 assert_eq!(caller.data().context, vec![Context::Wasm, Context::Host]);
@@ -169,7 +175,7 @@ async fn call_wrapped_async_func() -> Result<(), Error> {
 fn call_linked_func() -> Result<(), Error> {
     let engine = Engine::default();
     let mut store = Store::new(&engine, State::default());
-    store.call_hook(State::call_hook);
+    store.call_hook(sync_call_hook);
     let mut linker = Linker::new(&engine);
 
     linker.func_wrap(
@@ -237,11 +243,11 @@ async fn call_linked_func_async() -> Result<(), Error> {
     config.async_support(true);
     let engine = Engine::new(&config)?;
     let mut store = Store::new(&engine, State::default());
-    store.call_hook(State::call_hook);
+    store.call_hook(sync_call_hook);
 
-    let f = Func::wrap4_async(
+    let f = Func::wrap_async(
         &mut store,
-        |caller: Caller<State>, a: i32, b: i64, c: f32, d: f64| {
+        |caller: Caller<State>, (a, b, c, d): (i32, i64, f32, f64)| {
             Box::new(async move {
                 // Calling this func will switch context into wasm, then back to host:
                 assert_eq!(caller.data().context, vec![Context::Wasm, Context::Host]);
@@ -307,7 +313,7 @@ async fn call_linked_func_async() -> Result<(), Error> {
 #[test]
 fn instantiate() -> Result<(), Error> {
     let mut store = Store::<State>::default();
-    store.call_hook(State::call_hook);
+    store.call_hook(sync_call_hook);
 
     let m = Module::new(store.engine(), "(module)")?;
     Instance::new(&mut store, &m, &[])?;
@@ -328,7 +334,7 @@ async fn instantiate_async() -> Result<(), Error> {
     config.async_support(true);
     let engine = Engine::new(&config)?;
     let mut store = Store::new(&engine, State::default());
-    store.call_hook(State::call_hook);
+    store.call_hook(sync_call_hook);
 
     let m = Module::new(store.engine(), "(module)")?;
     Instance::new_async(&mut store, &m, &[]).await?;
@@ -349,7 +355,7 @@ fn recursion() -> Result<(), Error> {
 
     let engine = Engine::default();
     let mut store = Store::new(&engine, State::default());
-    store.call_hook(State::call_hook);
+    store.call_hook(sync_call_hook);
     let mut linker = Linker::new(&engine);
 
     linker.func_wrap("host", "f", |mut caller: Caller<State>, n: i32| {
@@ -440,7 +446,7 @@ fn trapping() -> Result<(), Error> {
             }
 
             // recur so that we can trigger a next call.
-            // propogate its trap, if it traps!
+            // propagate its trap, if it traps!
             if recur > 0 {
                 let _ = caller
                     .get_export("export")
@@ -468,7 +474,7 @@ fn trapping() -> Result<(), Error> {
 
     let run = |action: i32, recur: bool| -> (State, Option<Error>) {
         let mut store = Store::new(&engine, State::default());
-        store.call_hook(State::call_hook);
+        store.call_hook(sync_call_hook);
         let inst = linker
             .instantiate(&mut store, &module)
             .expect("instantiate");
@@ -517,7 +523,7 @@ fn trapping() -> Result<(), Error> {
     assert_eq!(s.calls_into_wasm, 1);
     assert_eq!(s.returns_from_wasm, 1);
 
-    // trap in next call to wasm. No calls after the bit is set, so this trap shouldnt happen:
+    // trap in next call to wasm. No calls after the bit is set, so this trap shouldn't happen:
     let (s, e) = run(TRAP_NEXT_CALL_WASM, false);
     assert!(e.is_none());
     assert_eq!(s.calls_into_host, 1);
@@ -550,8 +556,12 @@ async fn basic_async_hook() -> Result<(), Error> {
 
     #[async_trait::async_trait]
     impl CallHookHandler<State> for HandlerR {
-        async fn handle_call_event(&self, obj: &mut State, ch: CallHook) -> Result<()> {
-            State::call_hook(obj, ch)
+        async fn handle_call_event(
+            &self,
+            ctx: StoreContextMut<'_, State>,
+            ch: CallHook,
+        ) -> Result<()> {
+            sync_call_hook(ctx, ch)
         }
     }
     let mut config = Config::new();
@@ -624,7 +634,12 @@ async fn timeout_async_hook() -> Result<(), Error> {
 
     #[async_trait::async_trait]
     impl CallHookHandler<State> for HandlerR {
-        async fn handle_call_event(&self, obj: &mut State, ch: CallHook) -> Result<()> {
+        async fn handle_call_event(
+            &self,
+            mut ctx: StoreContextMut<'_, State>,
+            ch: CallHook,
+        ) -> Result<()> {
+            let obj = ctx.data_mut();
             if obj.calls_into_host > 200 {
                 bail!("timeout");
             }
@@ -700,7 +715,12 @@ async fn drop_suspended_async_hook() -> Result<(), Error> {
 
     #[async_trait::async_trait]
     impl CallHookHandler<u32> for Handler {
-        async fn handle_call_event(&self, state: &mut u32, _ch: CallHook) -> Result<()> {
+        async fn handle_call_event(
+            &self,
+            mut ctx: StoreContextMut<'_, u32>,
+            _ch: CallHook,
+        ) -> Result<()> {
+            let state = ctx.data_mut();
             assert_eq!(*state, 0);
             *state += 1;
             let _dec = Decrement(state);
@@ -722,13 +742,13 @@ async fn drop_suspended_async_hook() -> Result<(), Error> {
     let mut linker = Linker::new(&engine);
 
     // Simulate a host function that has lots of yields with an infinite loop.
-    linker.func_wrap0_async("host", "f", |mut cx| {
+    linker.func_wrap_async("host", "f", |mut cx, _: ()| {
         Box::new(async move {
             let state = cx.data_mut();
             assert_eq!(*state, 0);
             *state += 1;
             let _dec = Decrement(state);
-            loop {
+            for _ in 0.. {
                 tokio::task::yield_now().await;
             }
         })
@@ -885,3 +905,7 @@ impl State {
         Ok(())
     }
 }
+
+fn sync_call_hook(mut ctx: StoreContextMut<'_, State>, transition: CallHook) -> Result<()> {
+    ctx.data_mut().call_hook(transition)
+}
diff --git a/tests/all/cli_tests.rs b/tests/all/cli_tests.rs
index da2e7adedc97..dfb31842a91b 100644
--- a/tests/all/cli_tests.rs
+++ b/tests/all/cli_tests.rs
@@ -32,7 +32,7 @@ pub fn get_wasmtime_command() -> Result<Command> {
     // If we're running tests with a "runner" then we might be doing something
     // like cross-emulation, so spin up the emulator rather than the tests
     // itself, which may not be natively executable.
-    let cmd = if let Some((_, runner)) = runner {
+    let mut cmd = if let Some((_, runner)) = runner {
         let mut parts = runner.split_whitespace();
         let mut cmd = Command::new(parts.next().unwrap());
         for arg in parts {
@@ -44,6 +44,10 @@ pub fn get_wasmtime_command() -> Result<Command> {
         Command::new(&me)
     };
 
+    // Ignore this if it's specified in the environment to allow tests to run in
+    // "default mode" by default.
+    cmd.env_remove("WASMTIME_NEW_CLI");
+
     Ok(cmd)
 }
 
@@ -184,8 +188,10 @@ fn run_wasmtime_unreachable_wat() -> Result<()> {
 #[test]
 fn hello_wasi_snapshot0() -> Result<()> {
     let wasm = build_wasm("tests/all/cli_tests/hello_wasi_snapshot0.wat")?;
-    let stdout = run_wasmtime(&["-Ccache=n", wasm.path().to_str().unwrap()])?;
-    assert_eq!(stdout, "Hello, world!\n");
+    for preview2 in ["-Spreview2=n", "-Spreview2=y"] {
+        let stdout = run_wasmtime(&["-Ccache=n", preview2, wasm.path().to_str().unwrap()])?;
+        assert_eq!(stdout, "Hello, world!\n");
+    }
     Ok(())
 }
 
@@ -215,8 +221,7 @@ fn timeout_in_start() -> Result<()> {
     let stderr = String::from_utf8_lossy(&output.stderr);
     assert!(
         stderr.contains("wasm trap: interrupt"),
-        "bad stderr: {}",
-        stderr
+        "bad stderr: {stderr}"
     );
     Ok(())
 }
@@ -238,8 +243,7 @@ fn timeout_in_invoke() -> Result<()> {
     let stderr = String::from_utf8_lossy(&output.stderr);
     assert!(
         stderr.contains("wasm trap: interrupt"),
-        "bad stderr: {}",
-        stderr
+        "bad stderr: {stderr}"
     );
     Ok(())
 }
@@ -248,8 +252,14 @@ fn timeout_in_invoke() -> Result<()> {
 #[test]
 fn exit2_wasi_snapshot0() -> Result<()> {
     let wasm = build_wasm("tests/all/cli_tests/exit2_wasi_snapshot0.wat")?;
-    let output = run_wasmtime_for_output(&["-Ccache=n", wasm.path().to_str().unwrap()], None)?;
-    assert_eq!(output.status.code().unwrap(), 2);
+
+    for preview2 in ["-Spreview2=n", "-Spreview2=y"] {
+        let output = run_wasmtime_for_output(
+            &["-Ccache=n", preview2, wasm.path().to_str().unwrap()],
+            None,
+        )?;
+        assert_eq!(output.status.code().unwrap(), 2);
+    }
     Ok(())
 }
 
@@ -266,11 +276,17 @@ fn exit2_wasi_snapshot1() -> Result<()> {
 #[test]
 fn exit125_wasi_snapshot0() -> Result<()> {
     let wasm = build_wasm("tests/all/cli_tests/exit125_wasi_snapshot0.wat")?;
-    let output = run_wasmtime_for_output(&["-Ccache=n", wasm.path().to_str().unwrap()], None)?;
-    if cfg!(windows) {
-        assert_eq!(output.status.code().unwrap(), 1);
-    } else {
-        assert_eq!(output.status.code().unwrap(), 125);
+    for preview2 in ["-Spreview2=n", "-Spreview2=y"] {
+        let output = run_wasmtime_for_output(
+            &["-Ccache=n", preview2, wasm.path().to_str().unwrap()],
+            None,
+        )?;
+        dbg!(&output);
+        if cfg!(windows) {
+            assert_eq!(output.status.code().unwrap(), 1);
+        } else {
+            assert_eq!(output.status.code().unwrap(), 125);
+        }
     }
     Ok(())
 }
@@ -292,10 +308,16 @@ fn exit125_wasi_snapshot1() -> Result<()> {
 #[test]
 fn exit126_wasi_snapshot0() -> Result<()> {
     let wasm = build_wasm("tests/all/cli_tests/exit126_wasi_snapshot0.wat")?;
-    let output = run_wasmtime_for_output(&["-Ccache=n", wasm.path().to_str().unwrap()], None)?;
-    assert_eq!(output.status.code().unwrap(), 1);
-    assert!(output.stdout.is_empty());
-    assert!(String::from_utf8_lossy(&output.stderr).contains("invalid exit status"));
+
+    for preview2 in ["-Spreview2=n", "-Spreview2=y"] {
+        let output = run_wasmtime_for_output(
+            &["-Ccache=n", preview2, wasm.path().to_str().unwrap()],
+            None,
+        )?;
+        assert_eq!(output.status.code().unwrap(), 1);
+        assert!(output.stdout.is_empty());
+        assert!(String::from_utf8_lossy(&output.stderr).contains("invalid exit status"));
+    }
     Ok(())
 }
 
@@ -437,20 +459,22 @@ fn hello_wasi_snapshot0_from_stdin() -> Result<()> {
     // Run a simple WASI hello world, snapshot0 edition.
     // The module is piped from standard input.
     let wasm = build_wasm("tests/all/cli_tests/hello_wasi_snapshot0.wat")?;
-    let stdout = {
-        let path = wasm.path();
-        let args: &[&str] = &["-Ccache=n", "-"];
-        let output = run_wasmtime_for_output(args, Some(path))?;
-        if !output.status.success() {
-            bail!(
-                "Failed to execute wasmtime with: {:?}\n{}",
-                args,
-                String::from_utf8_lossy(&output.stderr)
-            );
-        }
-        Ok::<_, anyhow::Error>(String::from_utf8(output.stdout).unwrap())
-    }?;
-    assert_eq!(stdout, "Hello, world!\n");
+    for preview2 in ["-Spreview2=n", "-Spreview2=y"] {
+        let stdout = {
+            let path = wasm.path();
+            let args: &[&str] = &["-Ccache=n", preview2, "-"];
+            let output = run_wasmtime_for_output(args, Some(path))?;
+            if !output.status.success() {
+                bail!(
+                    "Failed to execute wasmtime with: {:?}\n{}",
+                    args,
+                    String::from_utf8_lossy(&output.stderr)
+                );
+            }
+            Ok::<_, anyhow::Error>(String::from_utf8(output.stdout).unwrap())
+        }?;
+        assert_eq!(stdout, "Hello, world!\n");
+    }
     Ok(())
 }
 
@@ -493,7 +517,16 @@ fn specify_env() -> Result<()> {
             "tests/all/cli_tests/print_env.wat",
         ])
         .output()?;
-    assert!(!output.status.success());
+    assert!(output.status.success());
+
+    // Inherit all env vars
+    let output = get_wasmtime_command()?
+        .args(&["run", "-Sinherit-env", "tests/all/cli_tests/print_env.wat"])
+        .env("FOO", "bar")
+        .output()?;
+    assert!(output.status.success());
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    assert!(stdout.contains("FOO=bar"), "bad output: {stdout}");
 
     Ok(())
 }
@@ -589,6 +622,7 @@ fn wasm_flags() -> Result<()> {
     // command itself
     let stdout = run_wasmtime(&[
         "run",
+        "--",
         "tests/all/cli_tests/print-arguments.wat",
         "--argument",
         "-for",
@@ -605,7 +639,7 @@ fn wasm_flags() -> Result<()> {
             command\n\
         "
     );
-    let stdout = run_wasmtime(&["run", "tests/all/cli_tests/print-arguments.wat", "-"])?;
+    let stdout = run_wasmtime(&["run", "--", "tests/all/cli_tests/print-arguments.wat", "-"])?;
     assert_eq!(
         stdout,
         "\
@@ -613,7 +647,7 @@ fn wasm_flags() -> Result<()> {
             -\n\
         "
     );
-    let stdout = run_wasmtime(&["run", "tests/all/cli_tests/print-arguments.wat", "--"])?;
+    let stdout = run_wasmtime(&["run", "--", "tests/all/cli_tests/print-arguments.wat", "--"])?;
     assert_eq!(
         stdout,
         "\
@@ -623,6 +657,7 @@ fn wasm_flags() -> Result<()> {
     );
     let stdout = run_wasmtime(&[
         "run",
+        "--",
         "tests/all/cli_tests/print-arguments.wat",
         "--",
         "--",
@@ -732,6 +767,7 @@ fn component_missing_feature() -> Result<()> {
     let wasm = build_wasm(path)?;
     let output = get_wasmtime_command()?
         .arg("-Ccache=n")
+        .arg("-Wcomponent-model=n")
         .arg(wasm.path())
         .output()?;
     assert!(!output.status.success());
@@ -744,6 +780,7 @@ fn component_missing_feature() -> Result<()> {
     // also tests with raw *.wat input
     let output = get_wasmtime_command()?
         .arg("-Ccache=n")
+        .arg("-Wcomponent-model=n")
         .arg(path)
         .output()?;
     assert!(!output.status.success());
@@ -756,6 +793,27 @@ fn component_missing_feature() -> Result<()> {
     Ok(())
 }
 
+#[test]
+#[cfg_attr(not(feature = "component-model"), ignore)]
+fn component_enabled_by_default() -> Result<()> {
+    let path = "tests/all/cli_tests/component-basic.wat";
+    let wasm = build_wasm(path)?;
+    let output = get_wasmtime_command()?
+        .arg("-Ccache=n")
+        .arg(wasm.path())
+        .output()?;
+    assert!(output.status.success());
+
+    // also tests with raw *.wat input
+    let output = get_wasmtime_command()?
+        .arg("-Ccache=n")
+        .arg(path)
+        .output()?;
+    assert!(output.status.success());
+
+    Ok(())
+}
+
 // If the text format is invalid then the filename should be mentioned in the
 // error message.
 #[test]
@@ -790,26 +848,6 @@ fn run_basic_component() -> Result<()> {
     Ok(())
 }
 
-#[cfg(feature = "wasi-http")]
-#[ignore = "needs to be ported to components"]
-#[test]
-fn run_wasi_http_module() -> Result<()> {
-    let output = run_wasmtime_for_output(
-        &[
-            "-Shttp,preview2",
-            "-Ccache=no",
-            "tests/all/cli_tests/wasi-http.wat",
-        ],
-        None,
-    )?;
-    println!("{}", String::from_utf8_lossy(&output.stderr));
-    assert!(String::from_utf8(output.stdout)
-        .unwrap()
-        .starts_with("Called _start\n"));
-    assert!(!output.status.success());
-    Ok(())
-}
-
 #[test]
 #[cfg_attr(not(feature = "component-model"), ignore)]
 fn run_precompiled_component() -> Result<()> {
@@ -1017,3 +1055,895 @@ fn preview2_stdin() -> Result<()> {
     }
     Ok(())
 }
+
+#[test]
+fn float_args() -> Result<()> {
+    let result = run_wasmtime(&[
+        "--invoke",
+        "echo_f32",
+        "tests/all/cli_tests/simple.wat",
+        "1.0",
+    ])?;
+    assert_eq!(result, "1\n");
+    let result = run_wasmtime(&[
+        "--invoke",
+        "echo_f64",
+        "tests/all/cli_tests/simple.wat",
+        "1.1",
+    ])?;
+    assert_eq!(result, "1.1\n");
+    Ok(())
+}
+
+#[test]
+fn mpk_without_pooling() -> Result<()> {
+    let output = get_wasmtime_command()?
+        .args(&[
+            "run",
+            "-O",
+            "memory-protection-keys=y",
+            "--invoke",
+            "echo_f32",
+            "tests/all/cli_tests/simple.wat",
+            "1.0",
+        ])
+        .env("WASMTIME_NEW_CLI", "1")
+        .output()?;
+    assert!(!output.status.success());
+    Ok(())
+}
+
+mod test_programs {
+    use super::{get_wasmtime_command, run_wasmtime};
+    use anyhow::{bail, Context, Result};
+    use http_body_util::BodyExt;
+    use hyper::header::HeaderValue;
+    use std::io::{BufRead, BufReader, Read, Write};
+    use std::net::SocketAddr;
+    use std::process::{Child, Command, Stdio};
+    use test_programs_artifacts::*;
+    use tokio::net::TcpStream;
+
+    macro_rules! assert_test_exists {
+        ($name:ident) => {
+            #[allow(unused_imports)]
+            use self::$name as _;
+        };
+    }
+    foreach_cli!(assert_test_exists);
+
+    #[test]
+    fn cli_hello_stdout() -> Result<()> {
+        run_wasmtime(&[
+            "run",
+            "-Wcomponent-model",
+            CLI_HELLO_STDOUT_COMPONENT,
+            "gussie",
+            "sparky",
+            "willa",
+        ])?;
+        Ok(())
+    }
+
+    #[test]
+    fn cli_args() -> Result<()> {
+        run_wasmtime(&[
+            "run",
+            "-Wcomponent-model",
+            CLI_ARGS_COMPONENT,
+            "hello",
+            "this",
+            "",
+            "is an argument",
+            "with 🚩 emoji",
+        ])?;
+        Ok(())
+    }
+
+    #[test]
+    fn cli_stdin() -> Result<()> {
+        let mut child = get_wasmtime_command()?
+            .args(&["run", "-Wcomponent-model", CLI_STDIN_COMPONENT])
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .stdin(Stdio::piped())
+            .spawn()?;
+        child
+            .stdin
+            .take()
+            .unwrap()
+            .write_all(b"So rested he by the Tumtum tree")
+            .unwrap();
+        let output = child.wait_with_output()?;
+        println!("stdout: {}", String::from_utf8_lossy(&output.stdout));
+        println!("stderr: {}", String::from_utf8_lossy(&output.stderr));
+        assert!(output.status.success());
+        Ok(())
+    }
+
+    #[test]
+    fn cli_splice_stdin() -> Result<()> {
+        let mut child = get_wasmtime_command()?
+            .args(&["run", "-Wcomponent-model", CLI_SPLICE_STDIN_COMPONENT])
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .stdin(Stdio::piped())
+            .spawn()?;
+        let msg = "So rested he by the Tumtum tree";
+        child
+            .stdin
+            .take()
+            .unwrap()
+            .write_all(msg.as_bytes())
+            .unwrap();
+        let output = child.wait_with_output()?;
+        assert!(output.status.success());
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        if !stderr.is_empty() {
+            eprintln!("{stderr}");
+        }
+
+        assert_eq!(
+            format!(
+                "before splice\n{msg}\ncompleted splicing {} bytes\n",
+                msg.as_bytes().len()
+            ),
+            stdout
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn cli_env() -> Result<()> {
+        run_wasmtime(&[
+            "run",
+            "-Wcomponent-model",
+            "--env=frabjous=day",
+            "--env=callooh=callay",
+            CLI_ENV_COMPONENT,
+        ])?;
+        Ok(())
+    }
+
+    #[test]
+    fn cli_file_read() -> Result<()> {
+        let dir = tempfile::tempdir()?;
+
+        std::fs::write(dir.path().join("bar.txt"), b"And stood awhile in thought")?;
+
+        run_wasmtime(&[
+            "run",
+            "-Wcomponent-model",
+            &format!("--dir={}::/", dir.path().to_str().unwrap()),
+            CLI_FILE_READ_COMPONENT,
+        ])?;
+        Ok(())
+    }
+
+    #[test]
+    fn cli_file_append() -> Result<()> {
+        let dir = tempfile::tempdir()?;
+
+        std::fs::File::create(dir.path().join("bar.txt"))?
+            .write_all(b"'Twas brillig, and the slithy toves.\n")?;
+
+        run_wasmtime(&[
+            "run",
+            "-Wcomponent-model",
+            &format!("--dir={}::/", dir.path().to_str().unwrap()),
+            CLI_FILE_APPEND_COMPONENT,
+        ])?;
+
+        let contents = std::fs::read(dir.path().join("bar.txt"))?;
+        assert_eq!(
+            std::str::from_utf8(&contents).unwrap(),
+            "'Twas brillig, and the slithy toves.\n\
+                   Did gyre and gimble in the wabe;\n\
+                   All mimsy were the borogoves,\n\
+                   And the mome raths outgrabe.\n"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn cli_file_dir_sync() -> Result<()> {
+        let dir = tempfile::tempdir()?;
+
+        std::fs::File::create(dir.path().join("bar.txt"))?
+            .write_all(b"'Twas brillig, and the slithy toves.\n")?;
+
+        run_wasmtime(&[
+            "run",
+            "-Wcomponent-model",
+            &format!("--dir={}::/", dir.path().to_str().unwrap()),
+            CLI_FILE_DIR_SYNC_COMPONENT,
+        ])?;
+
+        Ok(())
+    }
+
+    #[test]
+    fn cli_exit_success() -> Result<()> {
+        run_wasmtime(&["run", "-Wcomponent-model", CLI_EXIT_SUCCESS_COMPONENT])?;
+        Ok(())
+    }
+
+    #[test]
+    fn cli_exit_default() -> Result<()> {
+        run_wasmtime(&["run", "-Wcomponent-model", CLI_EXIT_DEFAULT_COMPONENT])?;
+        Ok(())
+    }
+
+    #[test]
+    fn cli_exit_failure() -> Result<()> {
+        let output = get_wasmtime_command()?
+            .args(&["run", "-Wcomponent-model", CLI_EXIT_FAILURE_COMPONENT])
+            .output()?;
+        assert!(!output.status.success());
+        assert_eq!(output.status.code(), Some(1));
+        Ok(())
+    }
+
+    #[test]
+    fn cli_exit_panic() -> Result<()> {
+        let output = get_wasmtime_command()?
+            .args(&["run", "-Wcomponent-model", CLI_EXIT_PANIC_COMPONENT])
+            .output()?;
+        assert!(!output.status.success());
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        assert!(stderr.contains("Curiouser and curiouser!"));
+        Ok(())
+    }
+
+    #[test]
+    fn cli_directory_list() -> Result<()> {
+        let dir = tempfile::tempdir()?;
+
+        std::fs::File::create(dir.path().join("foo.txt"))?;
+        std::fs::File::create(dir.path().join("bar.txt"))?;
+        std::fs::File::create(dir.path().join("baz.txt"))?;
+        std::fs::create_dir(dir.path().join("sub"))?;
+        std::fs::File::create(dir.path().join("sub").join("wow.txt"))?;
+        std::fs::File::create(dir.path().join("sub").join("yay.txt"))?;
+
+        run_wasmtime(&[
+            "run",
+            "-Wcomponent-model",
+            &format!("--dir={}::/", dir.path().to_str().unwrap()),
+            CLI_DIRECTORY_LIST_COMPONENT,
+        ])?;
+        Ok(())
+    }
+
+    #[test]
+    fn cli_default_clocks() -> Result<()> {
+        run_wasmtime(&["run", "-Wcomponent-model", CLI_DEFAULT_CLOCKS_COMPONENT])?;
+        Ok(())
+    }
+
+    #[test]
+    fn cli_export_cabi_realloc() -> Result<()> {
+        run_wasmtime(&[
+            "run",
+            "-Wcomponent-model",
+            CLI_EXPORT_CABI_REALLOC_COMPONENT,
+        ])?;
+        Ok(())
+    }
+
+    #[test]
+    fn run_wasi_http_component() -> Result<()> {
+        let output = super::run_wasmtime_for_output(
+            &[
+                "-Ccache=no",
+                "-Wcomponent-model",
+                "-Scli,http,preview2",
+                HTTP_OUTBOUND_REQUEST_RESPONSE_BUILD_COMPONENT,
+            ],
+            None,
+        )?;
+        println!("{}", String::from_utf8_lossy(&output.stderr));
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        println!("{stdout}");
+        assert!(stdout.starts_with("Called _start\n"));
+        assert!(stdout.ends_with("Done\n"));
+        assert!(output.status.success());
+        Ok(())
+    }
+
+    // Test to ensure that prints in the guest aren't buffered on the host by
+    // accident. The test here will print something without a newline and then
+    // wait for input on stdin, and the test here is to ensure that the
+    // character shows up here even as the guest is waiting on input via stdin.
+    #[test]
+    fn cli_stdio_write_flushes() -> Result<()> {
+        fn run(args: &[&str]) -> Result<()> {
+            println!("running {args:?}");
+            let mut child = get_wasmtime_command()?
+                .args(args)
+                .stdin(Stdio::piped())
+                .stdout(Stdio::piped())
+                .spawn()?;
+            let mut stdout = child.stdout.take().unwrap();
+            let mut buf = [0; 10];
+            match stdout.read(&mut buf) {
+                Ok(2) => assert_eq!(&buf[..2], b"> "),
+                e => panic!("unexpected read result {e:?}"),
+            }
+            drop(stdout);
+            drop(child.stdin.take().unwrap());
+            let status = child.wait()?;
+            assert!(status.success());
+            Ok(())
+        }
+
+        run(&["run", "-Spreview2=n", CLI_STDIO_WRITE_FLUSHES])?;
+        run(&["run", "-Spreview2=y", CLI_STDIO_WRITE_FLUSHES])?;
+        run(&[
+            "run",
+            "-Wcomponent-model",
+            CLI_STDIO_WRITE_FLUSHES_COMPONENT,
+        ])?;
+        Ok(())
+    }
+
+    #[test]
+    fn cli_no_tcp() -> Result<()> {
+        let output = super::run_wasmtime_for_output(
+            &[
+                "-Wcomponent-model",
+                // Turn on network but turn off TCP
+                "-Sinherit-network,tcp=no",
+                CLI_NO_TCP_COMPONENT,
+            ],
+            None,
+        )?;
+        println!("{}", String::from_utf8_lossy(&output.stderr));
+        assert!(output.status.success());
+        Ok(())
+    }
+
+    #[test]
+    fn cli_no_udp() -> Result<()> {
+        let output = super::run_wasmtime_for_output(
+            &[
+                "-Wcomponent-model",
+                // Turn on network but turn off UDP
+                "-Sinherit-network,udp=no",
+                CLI_NO_UDP_COMPONENT,
+            ],
+            None,
+        )?;
+        println!("{}", String::from_utf8_lossy(&output.stderr));
+        assert!(output.status.success());
+        Ok(())
+    }
+
+    #[test]
+    fn cli_no_ip_name_lookup() -> Result<()> {
+        let output = super::run_wasmtime_for_output(
+            &[
+                "-Wcomponent-model",
+                // Turn on network but ensure name lookup is disabled
+                "-Sinherit-network,allow-ip-name-lookup=no",
+                CLI_NO_IP_NAME_LOOKUP_COMPONENT,
+            ],
+            None,
+        )?;
+        println!("{}", String::from_utf8_lossy(&output.stderr));
+        assert!(output.status.success());
+        Ok(())
+    }
+
+    #[test]
+    fn cli_sleep() -> Result<()> {
+        run_wasmtime(&["run", CLI_SLEEP])?;
+        run_wasmtime(&["run", CLI_SLEEP_COMPONENT])?;
+        Ok(())
+    }
+
+    #[test]
+    fn cli_sleep_forever() -> Result<()> {
+        for timeout in [
+            // Tests still pass when we race with going to sleep.
+            "-Wtimeout=1ns",
+            // Tests pass when we wait till the Wasm has (likely) gone to sleep.
+            "-Wtimeout=250ms",
+        ] {
+            let e = run_wasmtime(&["run", timeout, CLI_SLEEP_FOREVER]).unwrap_err();
+            let e = e.to_string();
+            println!("Got error: {e}");
+            assert!(e.contains("interrupt"));
+
+            let e = run_wasmtime(&["run", timeout, CLI_SLEEP_FOREVER_COMPONENT]).unwrap_err();
+            let e = e.to_string();
+            println!("Got error: {e}");
+            assert!(e.contains("interrupt"));
+        }
+
+        Ok(())
+    }
+
+    /// Helper structure to manage an invocation of `wasmtime serve`
+    struct WasmtimeServe {
+        child: Option<Child>,
+        addr: SocketAddr,
+    }
+
+    impl WasmtimeServe {
+        /// Creates a new server which will serve the wasm component pointed to
+        /// by `wasm`.
+        ///
+        /// A `configure` callback is provided to specify how `wasmtime serve`
+        /// will be invoked and configure arguments such as headers.
+        fn new(wasm: &str, configure: impl FnOnce(&mut Command)) -> Result<WasmtimeServe> {
+            // Spawn `wasmtime serve` on port 0 which will randomly assign it a
+            // port.
+            let mut cmd = super::get_wasmtime_command()?;
+            cmd.arg("serve").arg("--addr=127.0.0.1:0").arg(wasm);
+            configure(&mut cmd);
+            Self::spawn(&mut cmd)
+        }
+
+        fn spawn(cmd: &mut Command) -> Result<WasmtimeServe> {
+            cmd.stdin(Stdio::null());
+            cmd.stdout(Stdio::piped());
+            cmd.stderr(Stdio::piped());
+            let mut child = cmd.spawn()?;
+
+            // Read the first line of stderr which will say which address it's
+            // listening on.
+            //
+            // NB: this intentionally discards any extra buffered data in the
+            // `BufReader` once the newline is found. The server shouldn't print
+            // anything interesting other than the address so once we get a line
+            // all remaining output is left to be captured by future requests
+            // send to the server.
+            let mut line = String::new();
+            let mut reader = BufReader::new(child.stderr.take().unwrap());
+            reader.read_line(&mut line)?;
+
+            match line.find("127.0.0.1").and_then(|addr_start| {
+                let addr = &line[addr_start..];
+                let addr_end = addr.find("/")?;
+                addr[..addr_end].parse().ok()
+            }) {
+                Some(addr) => {
+                    assert!(reader.buffer().is_empty());
+                    child.stderr = Some(reader.into_inner());
+                    Ok(WasmtimeServe {
+                        child: Some(child),
+                        addr,
+                    })
+                }
+                None => {
+                    child.kill()?;
+                    child.wait()?;
+                    reader.read_to_string(&mut line)?;
+                    bail!("failed to start child: {line}")
+                }
+            }
+        }
+
+        /// Completes this server gracefully by printing the output on failure.
+        fn finish(mut self) -> Result<(String, String)> {
+            let mut child = self.child.take().unwrap();
+
+            // If the child process has already exited then collect the output
+            // and test if it succeeded. Otherwise it's still running so kill it
+            // and then reap it. Assume that if it's still running then the test
+            // has otherwise passed so no need to print the output.
+            let known_failure = if child.try_wait()?.is_some() {
+                false
+            } else {
+                child.kill()?;
+                true
+            };
+            let output = child.wait_with_output()?;
+            if !known_failure && !output.status.success() {
+                bail!("child failed {output:?}");
+            }
+
+            Ok((
+                String::from_utf8_lossy(&output.stdout).into_owned(),
+                String::from_utf8_lossy(&output.stderr).into_owned(),
+            ))
+        }
+
+        /// Send a request to this server and wait for the response.
+        async fn send_request(&self, req: http::Request<String>) -> Result<http::Response<String>> {
+            let (mut send, conn_task) = self.start_requests().await?;
+
+            let response = send
+                .send_request(req)
+                .await
+                .context("error sending request")?;
+            drop(send);
+            let (parts, body) = response.into_parts();
+
+            let body = body.collect().await.context("failed to read body")?;
+            assert!(body.trailers().is_none());
+            let body = std::str::from_utf8(&body.to_bytes())?.to_string();
+
+            conn_task.await??;
+
+            Ok(http::Response::from_parts(parts, body))
+        }
+
+        async fn start_requests(
+            &self,
+        ) -> Result<(
+            hyper::client::conn::http1::SendRequest<String>,
+            tokio::task::JoinHandle<hyper::Result<()>>,
+        )> {
+            let tcp = TcpStream::connect(&self.addr)
+                .await
+                .context("failed to connect")?;
+            let tcp = wasmtime_wasi_http::io::TokioIo::new(tcp);
+            let (send, conn) = hyper::client::conn::http1::handshake(tcp)
+                .await
+                .context("failed http handshake")?;
+            Ok((send, tokio::task::spawn(conn)))
+        }
+    }
+
+    // Don't leave child processes running by accident so kill the child process
+    // if our server goes away.
+    impl Drop for WasmtimeServe {
+        fn drop(&mut self) {
+            let mut child = match self.child.take() {
+                Some(child) => child,
+                None => return,
+            };
+            if child.kill().is_err() {
+                return;
+            }
+            let output = match child.wait_with_output() {
+                Ok(output) => output,
+                Err(_) => return,
+            };
+
+            println!("server status: {}", output.status);
+            if !output.stdout.is_empty() {
+                println!(
+                    "server stdout:\n{}",
+                    String::from_utf8_lossy(&output.stdout)
+                );
+            }
+            if !output.stderr.is_empty() {
+                println!(
+                    "server stderr:\n{}",
+                    String::from_utf8_lossy(&output.stderr)
+                );
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn cli_serve_echo_env() -> Result<()> {
+        let server = WasmtimeServe::new(CLI_SERVE_ECHO_ENV_COMPONENT, |cmd| {
+            cmd.arg("--env=FOO=bar");
+            cmd.arg("--env=BAR");
+            cmd.arg("-Scli");
+            cmd.env_remove("BAR");
+        })?;
+
+        let foo_env = server
+            .send_request(
+                hyper::Request::builder()
+                    .uri("http://localhost/")
+                    .header("env", "FOO")
+                    .body(String::new())
+                    .context("failed to make request")?,
+            )
+            .await?;
+
+        assert!(foo_env.status().is_success());
+        assert!(foo_env.body().is_empty());
+        let headers = foo_env.headers();
+        assert_eq!(headers.get("env"), Some(&HeaderValue::from_static("bar")));
+
+        let bar_env = server
+            .send_request(
+                hyper::Request::builder()
+                    .uri("http://localhost/")
+                    .header("env", "BAR")
+                    .body(String::new())
+                    .context("failed to make request")?,
+            )
+            .await?;
+
+        assert!(bar_env.status().is_success());
+        assert!(bar_env.body().is_empty());
+        let headers = bar_env.headers();
+        assert_eq!(headers.get("env"), None);
+
+        server.finish()?;
+        Ok(())
+    }
+
+    #[tokio::test]
+    #[ignore] // TODO: printing stderr in the child and killing the child at the
+              // end of this test race so the stderr may be present or not. Need
+              // to implement a more graceful shutdown routine for `wasmtime
+              // serve`.
+    async fn cli_serve_respect_pooling_options() -> Result<()> {
+        let server = WasmtimeServe::new(CLI_SERVE_ECHO_ENV_COMPONENT, |cmd| {
+            cmd.arg("-Opooling-total-memories=0").arg("-Scli");
+        })?;
+
+        let result = server
+            .send_request(
+                hyper::Request::builder()
+                    .uri("http://localhost/")
+                    .header("env", "FOO")
+                    .body(String::new())
+                    .context("failed to make request")?,
+            )
+            .await;
+        assert!(result.is_err());
+        let (_, stderr) = server.finish()?;
+        assert!(
+            stderr.contains("maximum concurrent memory limit of 0 reached"),
+            "bad stderr: {stderr}",
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn cli_large_env() -> Result<()> {
+        for wasm in [CLI_LARGE_ENV, CLI_LARGE_ENV_COMPONENT] {
+            println!("run {wasm:?}");
+            let mut cmd = get_wasmtime_command()?;
+            cmd.arg("run").arg("-Sinherit-env").arg(wasm);
+
+            let debug_cmd = format!("{cmd:?}");
+            for i in 0..512 {
+                let var = format!("KEY{i}");
+                let val = (0..1024).map(|_| 'x').collect::<String>();
+                cmd.env(&var, &val);
+            }
+            let output = cmd.output()?;
+            if !output.status.success() {
+                bail!(
+                    "Failed to execute wasmtime with: {debug_cmd}\n{}",
+                    String::from_utf8_lossy(&output.stderr)
+                );
+            }
+        }
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn cli_serve_only_one_process_allowed() -> Result<()> {
+        let wasm = CLI_SERVE_ECHO_ENV_COMPONENT;
+        let server = WasmtimeServe::new(wasm, |cmd| {
+            cmd.arg("-Scli");
+        })?;
+
+        let err = WasmtimeServe::spawn(
+            super::get_wasmtime_command()?
+                .arg("serve")
+                .arg("-Scli")
+                .arg(format!("--addr={}", server.addr))
+                .arg(wasm),
+        )
+        .err()
+        .expect("server spawn should have failed but it succeeded");
+        drop(server);
+
+        let err = format!("{err:?}");
+        println!("{err}");
+        assert!(err.contains("os error"));
+        Ok(())
+    }
+
+    // Technically this test is a little racy. This binds port 0 to acquire a
+    // random port, issues a single request to this port, but then kills this
+    // server while the request is still processing. The port is then rebound
+    // in the next process while it technically could be stolen by another
+    // process.
+    #[tokio::test]
+    async fn cli_serve_quick_rebind_allowed() -> Result<()> {
+        let wasm = CLI_SERVE_ECHO_ENV_COMPONENT;
+        let server = WasmtimeServe::new(wasm, |cmd| {
+            cmd.arg("-Scli");
+        })?;
+        let addr = server.addr;
+
+        // Start up a `send` and `conn_task` which represents a connection to
+        // this server.
+        let (mut send, conn_task) = server.start_requests().await?;
+        let _ = send
+            .send_request(
+                hyper::Request::builder()
+                    .uri("http://localhost/")
+                    .header("env", "FOO")
+                    .body(String::new())
+                    .context("failed to make request")?,
+            )
+            .await;
+
+        // ... once a response has been received (or at least the status
+        // code/headers) then kill the server. THis is done while `conn_task`
+        // and `send` are still alive so we're guaranteed that the other side
+        // got a request (we got a response) and our connection is still open.
+        //
+        // This forces the address/port into the `TIME_WAIT` state. The rebind
+        // below in the next process will fail if `SO_REUSEADDR` isn't set.
+        drop(server);
+        drop(send);
+        let _ = conn_task.await;
+
+        // If this is successfully bound then we'll create `WasmtimeServe`
+        // which reads off the first line of output to know which address was
+        // bound.
+        let _server2 = WasmtimeServe::spawn(
+            super::get_wasmtime_command()?
+                .arg("serve")
+                .arg("-Scli")
+                .arg(format!("--addr={addr}"))
+                .arg(wasm),
+        )?;
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn cli_serve_with_print() -> Result<()> {
+        let server = WasmtimeServe::new(CLI_SERVE_WITH_PRINT_COMPONENT, |cmd| {
+            cmd.arg("-Scli");
+        })?;
+
+        for _ in 0..2 {
+            let resp = server
+                .send_request(
+                    hyper::Request::builder()
+                        .uri("http://localhost/")
+                        .body(String::new())
+                        .context("failed to make request")?,
+                )
+                .await?;
+            assert!(resp.status().is_success());
+        }
+
+        let (out, err) = server.finish()?;
+        assert_eq!(
+            out,
+            "\
+stdout [0] :: this is half a print to stdout
+stdout [0] :: \n\
+stdout [0] :: after empty
+stdout [1] :: this is half a print to stdout
+stdout [1] :: \n\
+stdout [1] :: after empty
+"
+        );
+        assert_eq!(
+            err,
+            "\
+stderr [0] :: this is half a print to stderr
+stderr [0] :: \n\
+stderr [0] :: after empty
+stderr [1] :: this is half a print to stderr
+stderr [1] :: \n\
+stderr [1] :: after empty
+"
+        );
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn cli_serve_authority_and_scheme() -> Result<()> {
+        let server = WasmtimeServe::new(CLI_SERVE_AUTHORITY_AND_SCHEME_COMPONENT, |cmd| {
+            cmd.arg("-Scli");
+        })?;
+
+        let resp = server
+            .send_request(
+                hyper::Request::builder()
+                    .uri("/")
+                    .header("Host", "localhost")
+                    .body(String::new())
+                    .context("failed to make request")?,
+            )
+            .await?;
+        assert!(resp.status().is_success());
+
+        let resp = server
+            .send_request(
+                hyper::Request::builder()
+                    .method("CONNECT")
+                    .uri("http://localhost/")
+                    .body(String::new())
+                    .context("failed to make request")?,
+            )
+            .await?;
+        assert!(resp.status().is_success());
+
+        Ok(())
+    }
+
+    #[test]
+    fn cli_argv0() -> Result<()> {
+        run_wasmtime(&["run", "--argv0=a", CLI_ARGV0, "a"])?;
+        run_wasmtime(&["run", "--argv0=b", CLI_ARGV0_COMPONENT, "b"])?;
+        run_wasmtime(&["run", "--argv0=foo.wasm", CLI_ARGV0, "foo.wasm"])?;
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn cli_serve_runtime_config() -> Result<()> {
+        let server = WasmtimeServe::new(CLI_SERVE_RUNTIME_CONFIG_COMPONENT, |cmd| {
+            cmd.arg("-Scli");
+            cmd.arg("-Sruntime-config");
+            cmd.arg("-Sruntime-config-var=hello=world");
+        })?;
+
+        let resp = server
+            .send_request(
+                hyper::Request::builder()
+                    .uri("http://localhost/")
+                    .body(String::new())
+                    .context("failed to make request")?,
+            )
+            .await?;
+
+        assert!(resp.status().is_success());
+        assert_eq!(resp.body(), "world");
+        Ok(())
+    }
+
+    #[test]
+    fn cli_runtime_config() -> Result<()> {
+        run_wasmtime(&[
+            "run",
+            "-Sruntime-config",
+            "-Sruntime-config-var=hello=world",
+            RUNTIME_CONFIG_GET_COMPONENT,
+        ])?;
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn cli_serve_keyvalue() -> Result<()> {
+        let server = WasmtimeServe::new(CLI_SERVE_KEYVALUE_COMPONENT, |cmd| {
+            cmd.arg("-Scli");
+            cmd.arg("-Skeyvalue");
+            cmd.arg("-Skeyvalue-in-memory-data=hello=world");
+        })?;
+
+        let resp = server
+            .send_request(
+                hyper::Request::builder()
+                    .uri("http://localhost/")
+                    .body(String::new())
+                    .context("failed to make request")?,
+            )
+            .await?;
+
+        assert!(resp.status().is_success());
+        assert_eq!(resp.body(), "world");
+        Ok(())
+    }
+
+    #[test]
+    fn cli_keyvalue() -> Result<()> {
+        run_wasmtime(&[
+            "run",
+            "-Skeyvalue",
+            "-Skeyvalue-in-memory-data=atomics_key=5",
+            KEYVALUE_MAIN_COMPONENT,
+        ])?;
+        Ok(())
+    }
+}
+
+#[test]
+fn settings_command() -> Result<()> {
+    let output = run_wasmtime(&["settings"])?;
+    assert!(output.contains("Cranelift settings for target"));
+    Ok(())
+}
diff --git a/tests/all/cli_tests/component-basic.wat b/tests/all/cli_tests/component-basic.wat
index 19a5fb2c6f50..057ee944a529 100644
--- a/tests/all/cli_tests/component-basic.wat
+++ b/tests/all/cli_tests/component-basic.wat
@@ -7,6 +7,6 @@
   (func $run (result (result))
     (canon lift (core func $i "run")))
 
-  (instance (export (interface "wasi:cli/run"))
+  (instance (export (interface "wasi:cli/run@0.2.0"))
     (export "run" (func $run)))
 )
diff --git a/tests/all/cli_tests/rs2wasm-add-func.wat b/tests/all/cli_tests/rs2wasm-add-func.wat
index 89af3ffc4dca..660cd87434dd 100644
--- a/tests/all/cli_tests/rs2wasm-add-func.wat
+++ b/tests/all/cli_tests/rs2wasm-add-func.wat
@@ -6,7 +6,7 @@
     local.get 0
     i32.add)
   (func $start (type 0))
-  (table (;0;) 1 1 anyfunc)
+  (table (;0;) 1 1 funcref)
   (memory (;0;) 17)
   (global (;0;) i32 (i32.const 1049114))
   (global (;1;) i32 (i32.const 1049114))
diff --git a/tests/all/cli_tests/simple.wat b/tests/all/cli_tests/simple.wat
index a851dfa00e2b..a62319c5e179 100644
--- a/tests/all/cli_tests/simple.wat
+++ b/tests/all/cli_tests/simple.wat
@@ -4,4 +4,6 @@
     )
     (func (export "get_f32") (result f32) f32.const 100)
     (func (export "get_f64") (result f64) f64.const 100)
+    (func (export "echo_f32") (param f32) (result f32) local.get 0)
+    (func (export "echo_f64") (param f64) (result f64) local.get 0)
 )
diff --git a/tests/all/cli_tests/wasi-http.wat b/tests/all/cli_tests/wasi-http.wat
deleted file mode 100644
index 8893c3ca4584..000000000000
--- a/tests/all/cli_tests/wasi-http.wat
+++ /dev/null
@@ -1,93 +0,0 @@
-(module
-  (import "wasi_snapshot_preview1" "proc_exit"
-    (func $__wasi_proc_exit (param i32)))
-  (import "wasi:io/streams" "write"
-    (func $__wasi_io_streams_write (param i32 i32 i32 i32)))
-  (import "wasi:io/streams" "blocking-write-and-flush"
-    (func $__wasi_io_streams_blocking_write_and_flush (param i32 i32 i32 i32)))
-  (import "wasi:io/streams" "subscribe-to-output-stream"
-    (func $__wasi_io_streams_subscribe_to_output_stream (param i32) (result i32)))
-  (import "wasi:http/types" "new-fields"
-    (func $__wasi_http_types_new_fields (param i32 i32) (result i32)))
-  (import "wasi:http/types" "drop-fields"
-    (func $__wasi_http_types_drop_fields (param i32)))
-  (import "wasi:http/types" "new-outgoing-request"
-    (func $__wasi_http_types_new_outgoing_request (param i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32 i32) (result i32)))
-  (import "wasi:http/types" "outgoing-request-write"
-    (func $__wasi_http_types_outgoing_request_write (param i32 i32)))
-  (import "wasi:http/types" "drop-outgoing-request"
-    (func $__wasi_http_types_drop_outgoing_request (param i32)))
-  (func $_start
-    (local i32)
-    (local $headers_id i32)
-    (local $request_id i32)
-    (local $body_stream_id i32)
-
-    ;; Print "Called _start".
-    (call $print (i32.const 32) (i32.const 14))
-
-    (local.set $headers_id (call $__wasi_http_types_new_fields
-      i32.const 0 ;; base pointer
-      i32.const 0 ;; length
-    ))
-    (local.set $request_id (call $__wasi_http_types_new_outgoing_request
-      i32.const 0 ;; method = Method::Get
-      i32.const 0 ;; method pointer
-      i32.const 0 ;; method length
-      i32.const 0 ;; path is some = None
-      i32.const 0 ;; path pointer
-      i32.const 0 ;; path length
-      i32.const 1 ;; scheme is some = Some
-      i32.const 1 ;; scheme = Scheme::Https
-      i32.const 0 ;; scheme pointer
-      i32.const 0 ;; scheme length
-      i32.const 1 ;; authority is some = Some
-      i32.const 96 ;; authority pointer = Constant value
-      i32.const 15 ;; authority length
-      local.get $headers_id ;; headers id
-    ))
-    (call $__wasi_http_types_outgoing_request_write (local.get $request_id) (local.get 0))
-    local.get 0
-    i32.const 4
-    i32.add
-    i32.load
-    local.set $body_stream_id
-    (call $__wasi_io_streams_write
-      (local.get $body_stream_id) ;; body stream id (usually 8)
-      (i32.const 128) ;; body stream pointer
-      (i32.const 4) ;; body stream length
-      (i32.const 0)
-    )
-    (drop (call $__wasi_io_streams_subscribe_to_output_stream (local.get $body_stream_id)))
-    (call $__wasi_http_types_drop_fields (local.get $headers_id))
-    (call $__wasi_http_types_drop_outgoing_request (local.get $request_id))
-
-    (call $print (i32.const 64) (i32.const 5))
-    (drop (call $__wasi_io_streams_subscribe_to_output_stream (i32.const 4)))
-
-    (call $__wasi_proc_exit (i32.const 1))
-  )
-
-  ;; A helper function for printing ptr-len strings.
-  (func $print (param $ptr i32) (param $len i32)
-    (call $__wasi_io_streams_blocking_write_and_flush
-      i32.const 4 ;; Value for stdout
-      local.get $ptr
-      local.get $len
-      i32.const 0
-    )
-  )
-
-  (func $cabi_realloc (param i32 i32 i32 i32) (result i32)
-    i32.const 0
-  )
-
-  (memory 1)
-  (export "memory" (memory 0))
-  (export "_start" (func $_start))
-  (export "cabi_realloc" (func $cabi_realloc))
-  (data (i32.const 32) "Called _start\0a")
-  (data (i32.const 64) "Done\0a")
-  (data (i32.const 96) "www.example.com")
-  (data (i32.const 128) "body")
-)
diff --git a/tests/all/code_too_large.rs b/tests/all/code_too_large.rs
index c7c5080dcbce..dff359d7daae 100644
--- a/tests/all/code_too_large.rs
+++ b/tests/all/code_too_large.rs
@@ -1,6 +1,5 @@
 #![cfg(not(miri))]
 
-use anyhow::Result;
 use wasmtime::*;
 
 #[test]
diff --git a/tests/all/component_model.rs b/tests/all/component_model.rs
index 7e5e21f90cf3..da4c1abcdf5d 100644
--- a/tests/all/component_model.rs
+++ b/tests/all/component_model.rs
@@ -12,6 +12,7 @@ mod dynamic;
 mod func;
 mod import;
 mod instance;
+mod linker;
 mod macros;
 mod nested;
 mod post_return;
diff --git a/tests/all/component_model/aot.rs b/tests/all/component_model/aot.rs
index 5fc5c8890a6d..676de39d190b 100644
--- a/tests/all/component_model/aot.rs
+++ b/tests/all/component_model/aot.rs
@@ -1,5 +1,6 @@
 use anyhow::Result;
-use wasmtime::component::{Component, Linker};
+use wasmtime::component::types::ComponentItem;
+use wasmtime::component::{Component, Linker, Type};
 use wasmtime::{Module, Precompiled, Store};
 
 #[test]
@@ -133,3 +134,76 @@ fn detect_precompiled() -> Result<()> {
     );
     Ok(())
 }
+
+#[test]
+fn reflect_resource_import() -> Result<()> {
+    let engine = super::engine();
+    let c = Component::new(
+        &engine,
+        r#"
+        (component
+            (import "x" (type $x (sub resource)))
+            (import "y" (func (result (own $x))))
+        )
+        "#,
+    )?;
+    let ty = c.component_type();
+    let mut imports = ty.imports(&engine);
+    let (_, x) = imports.next().unwrap();
+    let (_, y) = imports.next().unwrap();
+    let x = match x {
+        ComponentItem::Resource(t) => t,
+        _ => unreachable!(),
+    };
+    let y = match y {
+        ComponentItem::ComponentFunc(t) => t,
+        _ => unreachable!(),
+    };
+    let result = y.results().next().unwrap();
+    assert_eq!(result, Type::Own(x));
+
+    Ok(())
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn truncated_component_binaries_dont_panic() -> Result<()> {
+    let engine = super::engine();
+
+    let binary = wat::parse_str(
+        r#"
+        (component
+            (import "a" (core module $m0
+                (import "" "" (func))
+            ))
+
+            (core module $m1
+                (func (export ""))
+            )
+            (core instance $i1 (instantiate (module $m1)))
+            (func $f (canon lift (core func $i1 "f")))
+
+            (component $c1
+                (import "f" (func))
+                (core module $m2
+                    (func (export "g"))
+                )
+                (core instance $i2 (instantiate $m2))
+                (func (export "g")
+                    (canon lift (core func $i2 "g"))
+                )
+            )
+            (instance $i3 (instantiate $c1 (with "f" (func $f))))
+            (func (export "g") (alias export $i3 "g"))
+        )
+        "#,
+    )?;
+
+    // Check that if we feed each truncation of the component binary into
+    // `Component::new` we don't get any panics.
+    for i in 1..binary.len() - 1 {
+        let _ = Component::from_binary(&engine, &binary[0..i]);
+    }
+
+    Ok(())
+}
diff --git a/tests/all/component_model/async.rs b/tests/all/component_model/async.rs
index 116ced19cc14..26a2df86a954 100644
--- a/tests/all/component_model/async.rs
+++ b/tests/all/component_model/async.rs
@@ -155,7 +155,8 @@ async fn resume_separate_thread() -> Result<()> {
 
     execute_across_threads(async move {
         let mut store = Store::new(&engine, ());
-        store.out_of_fuel_async_yield(u64::MAX, 1);
+        store.set_fuel(u64::MAX).unwrap();
+        store.fuel_async_yield_interval(Some(1)).unwrap();
         linker.instantiate_async(&mut store, &component).await?;
         Ok::<_, anyhow::Error>(())
     })
@@ -207,7 +208,8 @@ async fn poll_through_wasm_activation() -> Result<()> {
         let engine = engine.clone();
         async move {
             let mut store = Store::new(&engine, ());
-            store.out_of_fuel_async_yield(u64::MAX, 1);
+            store.set_fuel(u64::MAX).unwrap();
+            store.fuel_async_yield_interval(Some(1)).unwrap();
             let instance = linker.instantiate_async(&mut store, &component).await?;
             let func = instance.get_typed_func::<(Vec<u8>,), ()>(&mut store, "run")?;
             func.call_async(&mut store, (vec![1, 2, 3],)).await?;
@@ -217,7 +219,7 @@ async fn poll_through_wasm_activation() -> Result<()> {
 
     execute_across_threads(async move {
         let mut store = Store::new(&engine, Some(Box::pin(invoke_component)));
-        let poll_once = wasmtime::Func::wrap0_async(&mut store, |mut cx| {
+        let poll_once = wasmtime::Func::wrap_async(&mut store, |mut cx, _: ()| {
             let invoke_component = cx.data_mut().take().unwrap();
             Box::new(async move {
                 match PollOnce::new(invoke_component).await {
@@ -241,3 +243,71 @@ async fn poll_through_wasm_activation() -> Result<()> {
     .await?;
     Ok(())
 }
+
+/// Test async drop method for host resources.
+#[tokio::test]
+async fn drop_resource_async() -> Result<()> {
+    use std::sync::Arc;
+    use std::sync::Mutex;
+
+    let engine = super::async_engine();
+    let c = Component::new(
+        &engine,
+        r#"
+            (component
+                (import "t" (type $t (sub resource)))
+
+                (core func $drop (canon resource.drop $t))
+
+                (core module $m
+                    (import "" "drop" (func $drop (param i32)))
+                    (func (export "f") (param i32)
+                        (call $drop (local.get 0))
+                    )
+                )
+                (core instance $i (instantiate $m
+                    (with "" (instance
+                        (export "drop" (func $drop))
+                    ))
+                ))
+
+                (func (export "f") (param "x" (own $t))
+                    (canon lift (core func $i "f")))
+            )
+        "#,
+    )?;
+
+    struct MyType;
+
+    let mut store = Store::new(&engine, ());
+    let mut linker = Linker::new(&engine);
+
+    let drop_status = Arc::new(Mutex::new("not dropped"));
+    let ds = drop_status.clone();
+
+    linker
+        .root()
+        .resource_async("t", ResourceType::host::<MyType>(), move |_, _| {
+            let ds = ds.clone();
+            Box::new(async move {
+                *ds.lock().unwrap() = "before yield";
+                tokio::task::yield_now().await;
+                *ds.lock().unwrap() = "after yield";
+                Ok(())
+            })
+        })?;
+    let i = linker.instantiate_async(&mut store, &c).await?;
+    let f = i.get_typed_func::<(Resource<MyType>,), ()>(&mut store, "f")?;
+
+    execute_across_threads(async move {
+        let resource = Resource::new_own(100);
+        f.call_async(&mut store, (resource,)).await?;
+        f.post_return_async(&mut store).await?;
+        Ok::<_, anyhow::Error>(())
+    })
+    .await?;
+
+    assert_eq!("after yield", *drop_status.lock().unwrap());
+
+    Ok(())
+}
diff --git a/tests/all/component_model/bindgen.rs b/tests/all/component_model/bindgen.rs
index 583e1b32bf59..9685910f2df2 100644
--- a/tests/all/component_model/bindgen.rs
+++ b/tests/all/component_model/bindgen.rs
@@ -1,4 +1,5 @@
 #![cfg(not(miri))]
+#![allow(dead_code)]
 
 use super::engine;
 use anyhow::Result;
@@ -15,14 +16,14 @@ mod no_imports {
 
     wasmtime::component::bindgen!({
         inline: "
-            package foo:foo
+            package foo:foo;
 
             world no-imports {
                 export foo: interface {
-                    foo: func()
+                    foo: func();
                 }
 
-                export bar: func()
+                export bar: func();
             }
         ",
     });
@@ -50,7 +51,7 @@ mod no_imports {
 
         let linker = Linker::new(&engine);
         let mut store = Store::new(&engine, ());
-        let (no_imports, _) = NoImports::instantiate(&mut store, &component, &linker)?;
+        let no_imports = NoImports::instantiate(&mut store, &component, &linker)?;
         no_imports.call_bar(&mut store)?;
         no_imports.foo().call_foo(&mut store)?;
         Ok(())
@@ -62,14 +63,14 @@ mod one_import {
 
     wasmtime::component::bindgen!({
         inline: "
-            package foo:foo
+            package foo:foo;
 
             world one-import {
                 import foo: interface {
-                    foo: func()
+                    foo: func();
                 }
 
-                export bar: func()
+                export bar: func();
             }
         ",
     });
@@ -105,16 +106,15 @@ mod one_import {
         }
 
         impl foo::Host for MyImports {
-            fn foo(&mut self) -> Result<()> {
+            fn foo(&mut self) {
                 self.hit = true;
-                Ok(())
             }
         }
 
         let mut linker = Linker::new(&engine);
         foo::add_to_linker(&mut linker, |f: &mut MyImports| f)?;
         let mut store = Store::new(&engine, MyImports::default());
-        let (one_import, _) = OneImport::instantiate(&mut store, &component, &linker)?;
+        let one_import = OneImport::instantiate(&mut store, &component, &linker)?;
         one_import.call_bar(&mut store)?;
         assert!(store.data().hit);
         Ok(())
@@ -127,14 +127,14 @@ mod resources_at_world_level {
 
     wasmtime::component::bindgen!({
         inline: "
-            package foo:foo
+            package foo:foo;
 
             world resources {
                 resource x {
-                    constructor()
+                    constructor();
                 }
 
-                export y: func(x: x)
+                export y: func(x: x);
             }
         ",
     });
@@ -181,9 +181,9 @@ mod resources_at_world_level {
         }
 
         impl HostX for MyImports {
-            fn new(&mut self) -> Result<Resource<X>> {
+            fn new(&mut self) -> Resource<X> {
                 self.ctor_hit = true;
-                Ok(Resource::new_own(80))
+                Resource::new_own(80)
             }
 
             fn drop(&mut self, val: Resource<X>) -> Result<()> {
@@ -202,7 +202,7 @@ mod resources_at_world_level {
         let mut linker = Linker::new(&engine);
         Resources::add_to_linker(&mut linker, |f: &mut MyImports| f)?;
         let mut store = Store::new(&engine, MyImports::default());
-        let (one_import, _) = Resources::instantiate(&mut store, &component, &linker)?;
+        let one_import = Resources::instantiate(&mut store, &component, &linker)?;
         one_import.call_y(&mut store, Resource::new_own(40))?;
         assert!(store.data().ctor_hit);
         assert_eq!(store.data().drops, 2);
@@ -216,22 +216,22 @@ mod resources_at_interface_level {
 
     wasmtime::component::bindgen!({
         inline: "
-            package foo:foo
+            package foo:foo;
 
             interface def {
                 resource x {
-                    constructor()
+                    constructor();
                 }
             }
 
             interface user {
-                use def.{x}
+                use def.{x};
 
-                y: func(x: x)
+                y: func(x: x);
             }
 
             world resources {
-                export user
+                export user;
             }
         ",
     });
@@ -286,9 +286,9 @@ mod resources_at_interface_level {
         use foo::foo::def::X;
 
         impl foo::foo::def::HostX for MyImports {
-            fn new(&mut self) -> Result<Resource<X>> {
+            fn new(&mut self) -> Resource<X> {
                 self.ctor_hit = true;
-                Ok(Resource::new_own(80))
+                Resource::new_own(80)
             }
 
             fn drop(&mut self, val: Resource<X>) -> Result<()> {
@@ -307,7 +307,7 @@ mod resources_at_interface_level {
         let mut linker = Linker::new(&engine);
         Resources::add_to_linker(&mut linker, |f: &mut MyImports| f)?;
         let mut store = Store::new(&engine, MyImports::default());
-        let (one_import, _) = Resources::instantiate(&mut store, &component, &linker)?;
+        let one_import = Resources::instantiate(&mut store, &component, &linker)?;
         one_import
             .foo_foo_user()
             .call_y(&mut store, Resource::new_own(40))?;
@@ -322,12 +322,15 @@ mod async_config {
 
     wasmtime::component::bindgen!({
         inline: "
-            package foo:foo
+            package foo:foo;
 
             world t1 {
-                import x: func()
-                import y: func()
-                export z: func()
+                import foo: interface {
+                    foo: func();
+                }
+                import x: func();
+                import y: func();
+                export z: func();
             }
         ",
         async: true,
@@ -337,13 +340,9 @@ mod async_config {
 
     #[async_trait::async_trait]
     impl T1Imports for T {
-        async fn x(&mut self) -> Result<()> {
-            Ok(())
-        }
+        async fn x(&mut self) {}
 
-        async fn y(&mut self) -> Result<()> {
-            Ok(())
-        }
+        async fn y(&mut self) {}
     }
 
     async fn _test_t1(t1: &T1, store: &mut Store<()>) {
@@ -352,12 +351,12 @@ mod async_config {
 
     wasmtime::component::bindgen!({
         inline: "
-            package foo:foo
+            package foo:foo;
 
             world t2 {
-                import x: func()
-                import y: func()
-                export z: func()
+                import x: func();
+                import y: func();
+                export z: func();
             }
         ",
         async: {
@@ -367,13 +366,9 @@ mod async_config {
 
     #[async_trait::async_trait]
     impl T2Imports for T {
-        fn x(&mut self) -> Result<()> {
-            Ok(())
-        }
+        fn x(&mut self) {}
 
-        async fn y(&mut self) -> Result<()> {
-            Ok(())
-        }
+        async fn y(&mut self) {}
     }
 
     async fn _test_t2(t2: &T2, store: &mut Store<()>) {
@@ -382,12 +377,12 @@ mod async_config {
 
     wasmtime::component::bindgen!({
         inline: "
-            package foo:foo
+            package foo:foo;
 
             world t3 {
-                import x: func()
-                import y: func()
-                export z: func()
+                import x: func();
+                import y: func();
+                export z: func();
             }
         ",
         async: {
@@ -397,13 +392,9 @@ mod async_config {
 
     #[async_trait::async_trait]
     impl T3Imports for T {
-        async fn x(&mut self) -> Result<()> {
-            Ok(())
-        }
+        async fn x(&mut self) {}
 
-        fn y(&mut self) -> Result<()> {
-            Ok(())
-        }
+        fn y(&mut self) {}
     }
 
     async fn _test_t3(t3: &T3, store: &mut Store<()>) {
@@ -418,27 +409,27 @@ mod exported_resources {
 
     wasmtime::component::bindgen!({
         inline: "
-            package foo:foo
+            package foo:foo;
 
             interface a {
                 resource x {
-                    constructor()
+                    constructor();
                 }
             }
 
             world resources {
                 export b: interface {
-                    use a.{x as y}
+                    use a.{x as y};
 
                     resource x {
-                        constructor(y: y)
-                        foo: func() -> u32
+                        constructor(y: y);
+                        foo: func() -> u32;
                     }
                 }
 
-                resource x
+                resource x;
 
-                export f: func(x1: x, x2: x) -> x
+                export f: func(x1: x, x2: x) -> x;
             }
         ",
     });
@@ -468,11 +459,11 @@ mod exported_resources {
     }
 
     impl a::HostX for MyImports {
-        fn new(&mut self) -> Result<Resource<a::X>> {
+        fn new(&mut self) -> Resource<a::X> {
             let rep = self.next_a_x;
             self.next_a_x += 1;
             self.hostcalls.push(Hostcall::NewA);
-            Ok(Resource::new_own(rep))
+            Resource::new_own(rep)
         }
 
         fn drop(&mut self, val: Resource<a::X>) -> Result<()> {
@@ -605,7 +596,7 @@ mod exported_resources {
         let mut linker = Linker::new(&engine);
         Resources::add_to_linker(&mut linker, |f: &mut MyImports| f)?;
         let mut store = Store::new(&engine, MyImports::default());
-        let (i, _) = Resources::instantiate(&mut store, &component, &linker)?;
+        let i = Resources::instantiate(&mut store, &component, &linker)?;
 
         // call the root export `f` twice
         let ret = i.call_f(&mut store, Resource::new_own(1), Resource::new_own(2))?;
@@ -628,7 +619,7 @@ mod exported_resources {
             mem::take(&mut store.data_mut().hostcalls),
             [Hostcall::DropAX(5), Hostcall::NewA]
         );
-        b.x().call_foo(&mut store, b_x.clone())?;
+        b.x().call_foo(&mut store, b_x)?;
         assert_eq!(mem::take(&mut store.data_mut().hostcalls), []);
         b_x.resource_drop(&mut store)?;
         assert_eq!(
diff --git a/tests/all/component_model/bindgen/ownership.rs b/tests/all/component_model/bindgen/ownership.rs
index fd0dd89da269..14417a3c281c 100644
--- a/tests/all/component_model/bindgen/ownership.rs
+++ b/tests/all/component_model/bindgen/ownership.rs
@@ -114,14 +114,15 @@ fn component() -> String {
     )
 }
 
-#[test]
-fn owning() -> Result<()> {
+mod owning {
+    use super::*;
+
     wasmtime::component::bindgen!({
         inline: "
-        package inline:inline
+        package inline:inline;
         world test {
             export lists: interface {
-                foo: func(a: list<list<string>>) -> list<list<string>>
+                foo: func(a: list<list<string>>) -> list<list<string>>;
             }
 
             export thing-in: interface {
@@ -130,7 +131,7 @@ fn owning() -> Result<()> {
                     value: list<string>
                 }
 
-                bar: func(a: thing)
+                bar: func(a: thing);
             }
 
             export thing-in-and-out: interface {
@@ -139,7 +140,7 @@ fn owning() -> Result<()> {
                     value: list<string>
                 }
 
-                baz: func(a: thing) -> thing
+                baz: func(a: thing) -> thing;
             }
         }",
         ownership: Owning
@@ -157,39 +158,42 @@ fn owning() -> Result<()> {
         }
     }
 
-    let engine = engine();
-    let component = Component::new(&engine, component())?;
+    #[test]
+    fn owning() -> Result<()> {
+        let engine = engine();
+        let component = Component::new(&engine, component())?;
 
-    let linker = Linker::new(&engine);
-    let mut store = Store::new(&engine, ());
-    let (test, _) = Test::instantiate(&mut store, &component, &linker)?;
+        let linker = Linker::new(&engine);
+        let mut store = Store::new(&engine, ());
+        let test = Test::instantiate(&mut store, &component, &linker)?;
 
-    let value = vec![vec!["a".to_owned(), "b".to_owned()]];
-    assert_eq!(value, test.lists().call_foo(&mut store, &value)?);
+        let value = vec![vec!["a".to_owned(), "b".to_owned()]];
+        assert_eq!(value, test.lists().call_foo(&mut store, &value)?);
 
-    let value = exports::thing_in::Thing {
-        name: "thing 1".to_owned(),
-        value: vec!["some value".to_owned(), "another value".to_owned()],
-    };
-    test.thing_in().call_bar(&mut store, &value)?;
+        let value = exports::thing_in::Thing {
+            name: "thing 1".to_owned(),
+            value: vec!["some value".to_owned(), "another value".to_owned()],
+        };
+        test.thing_in().call_bar(&mut store, &value)?;
 
-    let value = exports::thing_in_and_out::Thing {
-        name: "thing 1".to_owned(),
-        value: vec!["some value".to_owned(), "another value".to_owned()],
-    };
-    assert_eq!(value, test.thing_in_and_out().call_baz(&mut store, &value)?);
+        let value = exports::thing_in_and_out::Thing {
+            name: "thing 1".to_owned(),
+            value: vec!["some value".to_owned(), "another value".to_owned()],
+        };
+        assert_eq!(value, test.thing_in_and_out().call_baz(&mut store, &value)?);
 
-    Ok(())
+        Ok(())
+    }
 }
 
-#[test]
-fn borrowing_no_duplication() -> Result<()> {
+mod borrowing_no_duplication {
+    use super::*;
     wasmtime::component::bindgen!({
         inline: "
-        package inline:inline
+        package inline:inline;
         world test {
             export lists: interface {
-                foo: func(a: list<list<string>>) -> list<list<string>>
+                foo: func(a: list<list<string>>) -> list<list<string>>;
             }
 
             export thing-in: interface {
@@ -198,7 +202,7 @@ fn borrowing_no_duplication() -> Result<()> {
                     value: list<string>
                 }
 
-                bar: func(a: thing)
+                bar: func(a: thing);
             }
 
             export thing-in-and-out: interface {
@@ -207,7 +211,7 @@ fn borrowing_no_duplication() -> Result<()> {
                     value: list<string>
                 }
 
-                baz: func(a: thing) -> thing
+                baz: func(a: thing) -> thing;
             }
         }",
         ownership: Borrowing {
@@ -227,39 +231,43 @@ fn borrowing_no_duplication() -> Result<()> {
         }
     }
 
-    let engine = engine();
-    let component = Component::new(&engine, component())?;
+    #[test]
+    fn borrowing_no_duplication() -> Result<()> {
+        let engine = engine();
+        let component = Component::new(&engine, component())?;
 
-    let linker = Linker::new(&engine);
-    let mut store = Store::new(&engine, ());
-    let (test, _) = Test::instantiate(&mut store, &component, &linker)?;
+        let linker = Linker::new(&engine);
+        let mut store = Store::new(&engine, ());
+        let test = Test::instantiate(&mut store, &component, &linker)?;
 
-    let value = &[&["a", "b"] as &[_]] as &[_];
-    assert_eq!(value, test.lists().call_foo(&mut store, value)?);
+        let value = &[&["a", "b"] as &[_]] as &[_];
+        assert_eq!(value, test.lists().call_foo(&mut store, value)?);
 
-    let value = exports::thing_in::Thing {
-        name: "thing 1",
-        value: &["some value", "another value"],
-    };
-    test.thing_in().call_bar(&mut store, value)?;
+        let value = exports::thing_in::Thing {
+            name: "thing 1",
+            value: &["some value", "another value"],
+        };
+        test.thing_in().call_bar(&mut store, value)?;
 
-    let value = exports::thing_in_and_out::Thing {
-        name: "thing 1".to_owned(),
-        value: vec!["some value".to_owned(), "another value".to_owned()],
-    };
-    assert_eq!(value, test.thing_in_and_out().call_baz(&mut store, &value)?);
+        let value = exports::thing_in_and_out::Thing {
+            name: "thing 1".to_owned(),
+            value: vec!["some value".to_owned(), "another value".to_owned()],
+        };
+        assert_eq!(value, test.thing_in_and_out().call_baz(&mut store, &value)?);
 
-    Ok(())
+        Ok(())
+    }
 }
 
-#[test]
-fn borrowing_with_duplication() -> Result<()> {
+mod borrowing_with_duplication {
+    use super::*;
+
     wasmtime::component::bindgen!({
         inline: "
-        package inline:inline
+        package inline:inline;
         world test {
             export lists: interface {
-                foo: func(a: list<list<string>>) -> list<list<string>>
+                foo: func(a: list<list<string>>) -> list<list<string>>;
             }
 
             export thing-in: interface {
@@ -268,7 +276,7 @@ fn borrowing_with_duplication() -> Result<()> {
                     value: list<string>
                 }
 
-                bar: func(a: thing)
+                bar: func(a: thing);
             }
 
             export thing-in-and-out: interface {
@@ -277,7 +285,7 @@ fn borrowing_with_duplication() -> Result<()> {
                     value: list<string>
                 }
 
-                baz: func(a: thing) -> thing
+                baz: func(a: thing) -> thing;
             }
         }",
         ownership: Borrowing {
@@ -297,33 +305,36 @@ fn borrowing_with_duplication() -> Result<()> {
         }
     }
 
-    let engine = engine();
-    let component = Component::new(&engine, component())?;
-
-    let linker = Linker::new(&engine);
-    let mut store = Store::new(&engine, ());
-    let (test, _) = Test::instantiate(&mut store, &component, &linker)?;
-
-    let value = &[&["a", "b"] as &[_]] as &[_];
-    assert_eq!(value, test.lists().call_foo(&mut store, value)?);
-
-    let value = exports::thing_in::Thing {
-        name: "thing 1",
-        value: &["some value", "another value"],
-    };
-    test.thing_in().call_bar(&mut store, value)?;
-
-    let value = exports::thing_in_and_out::ThingParam {
-        name: "thing 1",
-        value: &["some value", "another value"],
-    };
-    assert_eq!(
-        exports::thing_in_and_out::ThingResult {
-            name: "thing 1".to_owned(),
-            value: vec!["some value".to_owned(), "another value".to_owned()],
-        },
-        test.thing_in_and_out().call_baz(&mut store, value)?
-    );
-
-    Ok(())
+    #[test]
+    fn borrowing_with_duplication() -> Result<()> {
+        let engine = engine();
+        let component = Component::new(&engine, component())?;
+
+        let linker = Linker::new(&engine);
+        let mut store = Store::new(&engine, ());
+        let test = Test::instantiate(&mut store, &component, &linker)?;
+
+        let value = &[&["a", "b"] as &[_]] as &[_];
+        assert_eq!(value, test.lists().call_foo(&mut store, value)?);
+
+        let value = exports::thing_in::Thing {
+            name: "thing 1",
+            value: &["some value", "another value"],
+        };
+        test.thing_in().call_bar(&mut store, value)?;
+
+        let value = exports::thing_in_and_out::ThingParam {
+            name: "thing 1",
+            value: &["some value", "another value"],
+        };
+        assert_eq!(
+            exports::thing_in_and_out::ThingResult {
+                name: "thing 1".to_owned(),
+                value: vec!["some value".to_owned(), "another value".to_owned()],
+            },
+            test.thing_in_and_out().call_baz(&mut store, value)?
+        );
+
+        Ok(())
+    }
 }
diff --git a/tests/all/component_model/bindgen/results.rs b/tests/all/component_model/bindgen/results.rs
index 6c0b3f8b6472..c8b7d82d0897 100644
--- a/tests/all/component_model/bindgen/results.rs
+++ b/tests/all/component_model/bindgen/results.rs
@@ -9,14 +9,15 @@ mod empty_error {
     use super::*;
     wasmtime::component::bindgen!({
         inline: "
-        package inline:inline
+        package inline:inline;
         world result-playground {
             import imports: interface {
-                empty-error: func(a: float64) -> result<float64>
+                empty-error: func(a: float64) -> result<float64>;
             }
 
-            export empty-error: func(a: float64) -> result<float64>
+            export empty-error: func(a: float64) -> result<float64>;
         }",
+        trappable_imports: true,
     });
 
     #[test]
@@ -77,7 +78,7 @@ mod empty_error {
         imports::add_to_linker(&mut linker, |f: &mut MyImports| f)?;
 
         let mut store = Store::new(&engine, MyImports::default());
-        let (results, _) = ResultPlayground::instantiate(&mut store, &component, &linker)?;
+        let results = ResultPlayground::instantiate(&mut store, &component, &linker)?;
 
         assert_eq!(
             results
@@ -110,14 +111,15 @@ mod string_error {
     use super::*;
     wasmtime::component::bindgen!({
         inline: "
-        package inline:inline
+        package inline:inline;
         world result-playground {
             import imports: interface {
-                string-error: func(a: float64) -> result<float64, string>
+                string-error: func(a: float64) -> result<float64, string>;
             }
 
-            export string-error: func(a: float64) -> result<float64, string>
+            export string-error: func(a: float64) -> result<float64, string>;
         }",
+        trappable_imports: true,
     });
 
     #[test]
@@ -189,7 +191,7 @@ mod string_error {
         imports::add_to_linker(&mut linker, |f: &mut MyImports| f)?;
 
         let mut store = Store::new(&engine, MyImports::default());
-        let (results, _) = ResultPlayground::instantiate(&mut store, &component, &linker)?;
+        let results = ResultPlayground::instantiate(&mut store, &component, &linker)?;
 
         assert_eq!(
             results
@@ -226,21 +228,55 @@ mod enum_error {
 
     wasmtime::component::bindgen!({
         inline: "
-        package inline:inline
+        package inline:inline;
         interface imports {
             enum e1 { a, b, c }
-            enum-error: func(a: float64) -> result<float64, e1>
+            enum-error: func(a: float64) -> result<float64, e1>;
         }
         world result-playground {
-            import imports
+            import imports;
             export foo: interface {
                 enum e1 { a, b, c }
-                enum-error: func(a: float64) -> result<float64, e1>
+                enum-error: func(a: float64) -> result<float64, e1>;
             }
         }",
-        trappable_error_type: { "inline:inline/imports"::e1: TrappableE1 }
+        trappable_error_type: { "inline:inline/imports/e1" => TrappableE1 },
+        trappable_imports: true,
     });
 
+    // You can create concrete trap types which make it all the way out to the
+    // host caller, via downcast_ref below.
+    #[derive(Debug)]
+    pub struct MyTrap;
+
+    impl std::fmt::Display for MyTrap {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            write!(f, "{self:?}")
+        }
+    }
+    impl std::error::Error for MyTrap {}
+
+    pub enum TrappableE1 {
+        Normal(imports::E1),
+        MyTrap(MyTrap),
+    }
+
+    // It is possible to define From impls that target these generated trappable
+    // types. This allows you to integrate libraries with other error types, or
+    // use your own more descriptive error types, and use ? to convert them at
+    // their throw site.
+    impl From<MyTrap> for TrappableE1 {
+        fn from(t: MyTrap) -> TrappableE1 {
+            TrappableE1::MyTrap(t)
+        }
+    }
+
+    impl From<imports::E1> for TrappableE1 {
+        fn from(t: imports::E1) -> TrappableE1 {
+            TrappableE1::Normal(t)
+        }
+    }
+
     #[test]
     fn run() -> Result<(), Error> {
         let engine = engine();
@@ -305,33 +341,18 @@ mod enum_error {
             ),
         )?;
 
-        // You can create concrete trap types which make it all the way out to the
-        // host caller, via downcast_ref below.
-        #[derive(Debug)]
-        struct MyTrap;
-
-        impl std::fmt::Display for MyTrap {
-            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                write!(f, "{:?}", self)
-            }
-        }
-        impl std::error::Error for MyTrap {}
-
-        // It is possible to define From impls that target these generated trappable
-        // types. This allows you to integrate libraries with other error types, or
-        // use your own more descriptive error types, and use ? to convert them at
-        // their throw site.
-        impl From<MyTrap> for imports::TrappableE1 {
-            fn from(t: MyTrap) -> imports::TrappableE1 {
-                imports::TrappableE1::trap(anyhow!(t))
-            }
-        }
-
         #[derive(Default)]
         struct MyImports {}
 
         impl imports::Host for MyImports {
-            fn enum_error(&mut self, a: f64) -> Result<f64, imports::TrappableE1> {
+            fn convert_e1(&mut self, err: TrappableE1) -> anyhow::Result<imports::E1> {
+                match err {
+                    TrappableE1::Normal(e) => Ok(e),
+                    TrappableE1::MyTrap(e) => Err(e.into()),
+                }
+            }
+
+            fn enum_error(&mut self, a: f64) -> Result<f64, TrappableE1> {
                 if a == 0.0 {
                     Ok(a)
                 } else if a == 1.0 {
@@ -346,7 +367,7 @@ mod enum_error {
         imports::add_to_linker(&mut linker, |f: &mut MyImports| f)?;
 
         let mut store = Store::new(&engine, MyImports::default());
-        let (results, _) = ResultPlayground::instantiate(&mut store, &component, &linker)?;
+        let results = ResultPlayground::instantiate(&mut store, &component, &linker)?;
 
         assert_eq!(
             results
@@ -388,23 +409,33 @@ mod record_error {
 
     wasmtime::component::bindgen!({
         inline: "
-        package inline:inline
+        package inline:inline;
         interface imports {
             record e2 { line: u32, col: u32 }
-            record-error: func(a: float64) -> result<float64, e2>
+            record-error: func(a: float64) -> result<float64, e2>;
         }
         world result-playground {
-            import imports
+            import imports;
             export foo: interface {
                 record e2 { line: u32, col: u32 }
-                record-error: func(a: float64) -> result<float64, e2>
+                record-error: func(a: float64) -> result<float64, e2>;
             }
         }",
-        // Literal strings can be used for the interface and typename fields instead of
-        // identifiers, because wit identifiers arent always Rust identifiers.
-        trappable_error_type: { "inline:inline/imports"::"e2": TrappableE2 }
+        trappable_error_type: { "inline:inline/imports/e2" => TrappableE2 },
+        trappable_imports: true,
     });
 
+    pub enum TrappableE2 {
+        Normal(imports::E2),
+        Trap(anyhow::Error),
+    }
+
+    impl From<imports::E2> for TrappableE2 {
+        fn from(t: imports::E2) -> TrappableE2 {
+            TrappableE2::Normal(t)
+        }
+    }
+
     #[test]
     fn run() -> Result<(), Error> {
         let engine = engine();
@@ -476,7 +507,13 @@ mod record_error {
         struct MyImports {}
 
         impl imports::Host for MyImports {
-            fn record_error(&mut self, a: f64) -> Result<f64, imports::TrappableE2> {
+            fn convert_e2(&mut self, err: TrappableE2) -> anyhow::Result<imports::E2> {
+                match err {
+                    TrappableE2::Normal(e) => Ok(e),
+                    TrappableE2::Trap(e) => Err(e.into()),
+                }
+            }
+            fn record_error(&mut self, a: f64) -> Result<f64, TrappableE2> {
                 if a == 0.0 {
                     Ok(a)
                 } else if a == 1.0 {
@@ -485,7 +522,7 @@ mod record_error {
                         col: 1312,
                     })?
                 } else {
-                    Err(imports::TrappableE2::trap(anyhow!("record_error: trap")))
+                    Err(TrappableE2::Trap(anyhow!("record_error: trap")))
                 }
             }
         }
@@ -494,7 +531,7 @@ mod record_error {
         imports::add_to_linker(&mut linker, |f: &mut MyImports| f)?;
 
         let mut store = Store::new(&engine, MyImports::default());
-        let (results, _) = ResultPlayground::instantiate(&mut store, &component, &linker)?;
+        let results = ResultPlayground::instantiate(&mut store, &component, &linker)?;
 
         assert_eq!(
             results
@@ -540,25 +577,37 @@ mod variant_error {
 
     wasmtime::component::bindgen!({
         inline: "
-        package inline:inline
+        package inline:inline;
         interface imports {
             enum e1 { a, b, c }
             record e2 { line: u32, col: u32 }
             variant e3 { E1(e1), E2(e2) }
-            variant-error: func(a: float64) -> result<float64, e3>
+            variant-error: func(a: float64) -> result<float64, e3>;
         }
         world result-playground {
-            import imports
+            import imports;
             export foo: interface {
                 enum e1 { a, b, c }
                 record e2 { line: u32, col: u32 }
                 variant e3 { E1(e1), E2(e2) }
-                variant-error: func(a: float64) -> result<float64, e3>
+                variant-error: func(a: float64) -> result<float64, e3>;
             }
         }",
-        trappable_error_type: { "inline:inline/imports"::e3: TrappableE3 }
+        trappable_error_type: { "inline:inline/imports/e3" => TrappableE3 },
+        trappable_imports: true,
     });
 
+    pub enum TrappableE3 {
+        Normal(imports::E3),
+        Trap(anyhow::Error),
+    }
+
+    impl From<imports::E3> for TrappableE3 {
+        fn from(t: imports::E3) -> TrappableE3 {
+            TrappableE3::Normal(t)
+        }
+    }
+
     #[test]
     fn run() -> Result<(), Error> {
         let engine = engine();
@@ -653,7 +702,13 @@ mod variant_error {
         struct MyImports {}
 
         impl imports::Host for MyImports {
-            fn variant_error(&mut self, a: f64) -> Result<f64, imports::TrappableE3> {
+            fn convert_e3(&mut self, err: TrappableE3) -> anyhow::Result<imports::E3> {
+                match err {
+                    TrappableE3::Normal(e) => Ok(e),
+                    TrappableE3::Trap(e) => Err(e.into()),
+                }
+            }
+            fn variant_error(&mut self, a: f64) -> Result<f64, TrappableE3> {
                 if a == 0.0 {
                     Ok(a)
                 } else if a == 1.0 {
@@ -662,7 +717,7 @@ mod variant_error {
                         col: 1312,
                     }))?
                 } else {
-                    Err(imports::TrappableE3::trap(anyhow!("variant_error: trap")))
+                    Err(TrappableE3::Trap(anyhow!("variant_error: trap")))
                 }
             }
         }
@@ -671,7 +726,7 @@ mod variant_error {
         imports::add_to_linker(&mut linker, |f: &mut MyImports| f)?;
 
         let mut store = Store::new(&engine, MyImports::default());
-        let (results, _) = ResultPlayground::instantiate(&mut store, &component, &linker)?;
+        let results = ResultPlayground::instantiate(&mut store, &component, &linker)?;
 
         assert_eq!(
             results
@@ -718,25 +773,37 @@ mod multiple_interfaces_error {
 
     wasmtime::component::bindgen!({
         inline: "
-        package inline:inline
+        package inline:inline;
         interface types {
             enum e1 { a, b, c }
-            enum-error: func(a: float64) -> result<float64, e1>
+            enum-error: func(a: float64) -> result<float64, e1>;
         }
         interface imports {
-            use types.{e1}
-            enum-error: func(a: float64) -> result<float64, e1>
+            use types.{e1};
+            enum-error: func(a: float64) -> result<float64, e1>;
         }
         world result-playground {
-            import imports
+            import imports;
             export foo: interface {
                 enum e1 { a, b, c }
-                enum-error: func(a: float64) -> result<float64, e1>
+                enum-error: func(a: float64) -> result<float64, e1>;
             }
         }",
-        trappable_error_type: { "inline:inline/types"::e1: TrappableE1 }
+        trappable_error_type: { "inline:inline/types/e1" => TrappableE1 },
+        trappable_imports: true,
     });
 
+    pub enum TrappableE1 {
+        Normal(types::E1),
+        Trap(anyhow::Error),
+    }
+
+    impl From<types::E1> for TrappableE1 {
+        fn from(t: imports::E1) -> TrappableE1 {
+            TrappableE1::Normal(t)
+        }
+    }
+
     #[test]
     fn run() -> Result<(), Error> {
         let engine = engine();
@@ -810,7 +877,7 @@ mod multiple_interfaces_error {
 
         impl std::fmt::Display for MyTrap {
             fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                write!(f, "{:?}", self)
+                write!(f, "{self:?}")
             }
         }
         impl std::error::Error for MyTrap {}
@@ -819,9 +886,9 @@ mod multiple_interfaces_error {
         // types. This allows you to integrate libraries with other error types, or
         // use your own more descriptive error types, and use ? to convert them at
         // their throw site.
-        impl From<MyTrap> for types::TrappableE1 {
-            fn from(t: MyTrap) -> types::TrappableE1 {
-                types::TrappableE1::trap(anyhow!(t))
+        impl From<MyTrap> for TrappableE1 {
+            fn from(t: MyTrap) -> TrappableE1 {
+                TrappableE1::Trap(anyhow!(t))
             }
         }
 
@@ -829,7 +896,13 @@ mod multiple_interfaces_error {
         struct MyImports {}
 
         impl types::Host for MyImports {
-            fn enum_error(&mut self, a: f64) -> Result<f64, types::TrappableE1> {
+            fn convert_e1(&mut self, err: TrappableE1) -> anyhow::Result<imports::E1> {
+                match err {
+                    TrappableE1::Normal(e) => Ok(e),
+                    TrappableE1::Trap(e) => Err(e.into()),
+                }
+            }
+            fn enum_error(&mut self, a: f64) -> Result<f64, TrappableE1> {
                 if a == 0.0 {
                     Ok(a)
                 } else if a == 1.0 {
@@ -841,7 +914,7 @@ mod multiple_interfaces_error {
         }
 
         impl imports::Host for MyImports {
-            fn enum_error(&mut self, a: f64) -> Result<f64, types::TrappableE1> {
+            fn enum_error(&mut self, a: f64) -> Result<f64, TrappableE1> {
                 if a == 0.0 {
                     Ok(a)
                 } else if a == 1.0 {
@@ -856,7 +929,7 @@ mod multiple_interfaces_error {
         imports::add_to_linker(&mut linker, |f: &mut MyImports| f)?;
 
         let mut store = Store::new(&engine, MyImports::default());
-        let (results, _) = ResultPlayground::instantiate(&mut store, &component, &linker)?;
+        let results = ResultPlayground::instantiate(&mut store, &component, &linker)?;
 
         assert_eq!(
             results
@@ -898,24 +971,26 @@ mod with_remapping {
         wasmtime::component::bindgen!({
             interfaces: "
             import imports: interface {
-                empty-error: func(a: float64) -> result<float64>
+                empty-error: func(a: float64) -> result<float64>;
             }",
+            trappable_imports: true,
         });
     }
 
     wasmtime::component::bindgen!({
         inline: "
-        package inline:inline
+        package inline:inline;
         world result-playground {
             import imports: interface {
-                empty-error: func(a: float64) -> result<float64>
+                empty-error: func(a: float64) -> result<float64>;
             }
 
-            export empty-error: func(a: float64) -> result<float64>
+            export empty-error: func(a: float64) -> result<float64>;
         }",
         with: {
             "imports": interfaces::imports,
         },
+        trappable_imports: true,
     });
 
     #[test]
@@ -976,7 +1051,7 @@ mod with_remapping {
         interfaces::imports::add_to_linker(&mut linker, |f: &mut MyImports| f)?;
 
         let mut store = Store::new(&engine, MyImports::default());
-        let (results, _) = ResultPlayground::instantiate(&mut store, &component, &linker)?;
+        let results = ResultPlayground::instantiate(&mut store, &component, &linker)?;
 
         assert_eq!(
             results
diff --git a/tests/all/component_model/dynamic.rs b/tests/all/component_model/dynamic.rs
index 6d24163c58f0..e01742a79b2f 100644
--- a/tests/all/component_model/dynamic.rs
+++ b/tests/all/component_model/dynamic.rs
@@ -3,8 +3,10 @@
 use super::{make_echo_component, make_echo_component_with_params, Param, Type};
 use anyhow::Result;
 use component_test_util::FuncExt;
-use wasmtime::component::{self, Component, Linker, Val};
-use wasmtime::Store;
+use wasmtime::component::types::{self, Case, ComponentItem, Field};
+use wasmtime::component::{Component, Linker, ResourceType, Val};
+use wasmtime::{Module, Store};
+use wasmtime_component_util::REALLOC_AND_FREE;
 
 #[test]
 fn primitives() -> Result<()> {
@@ -100,7 +102,7 @@ fn strings() -> Result<()> {
     let component = Component::new(&engine, make_echo_component("string", 8))?;
     let instance = Linker::new(&engine).instantiate(&mut store, &component)?;
     let func = instance.get_func(&mut store, "echo").unwrap();
-    let input = Val::String(Box::from("hello, component!"));
+    let input = Val::String("hello, component!".into());
     let mut output = [Val::Bool(false)];
     func.call_and_post_return(&mut store, &[input.clone()], &mut output)?;
     assert_eq!(input, output[0]);
@@ -116,12 +118,11 @@ fn lists() -> Result<()> {
     let component = Component::new(&engine, make_echo_component("(list u32)", 8))?;
     let instance = Linker::new(&engine).instantiate(&mut store, &component)?;
     let func = instance.get_func(&mut store, "echo").unwrap();
-    let ty = &func.params(&store)[0];
-    let input = ty.unwrap_list().new_val(Box::new([
+    let input = Val::List(vec![
         Val::U32(32343),
         Val::U32(79023439),
         Val::U32(2084037802),
-    ]))?;
+    ]);
     let mut output = [Val::Bool(false)];
     func.call_and_post_return(&mut store, &[input.clone()], &mut output)?;
 
@@ -129,15 +130,14 @@ fn lists() -> Result<()> {
 
     // Sad path: type mismatch
 
-    let err = ty
-        .unwrap_list()
-        .new_val(Box::new([
-            Val::U32(32343),
-            Val::U32(79023439),
-            Val::Float32(3.14159265),
-        ]))
+    let err = Val::List(vec![
+        Val::U32(32343),
+        Val::U32(79023439),
+        Val::Float32(3.14159265),
+    ]);
+    let err = func
+        .call_and_post_return(&mut store, &[err], &mut output)
         .unwrap_err();
-
     assert!(err.to_string().contains("type mismatch"), "{err}");
 
     Ok(())
@@ -173,18 +173,17 @@ fn records() -> Result<()> {
     )?;
     let instance = Linker::new(&engine).instantiate(&mut store, &component)?;
     let func = instance.get_func(&mut store, "echo").unwrap();
-    let ty = &func.params(&store)[0];
-    let inner_type = &ty.unwrap_record().fields().nth(2).unwrap().ty;
-    let input = ty.unwrap_record().new_val([
-        ("A", Val::U32(32343)),
-        ("B", Val::Float64(3.14159265)),
+    let input = Val::Record(vec![
+        ("A".into(), Val::U32(32343)),
+        ("B".into(), Val::Float64(3.14159265)),
         (
-            "C",
-            inner_type
-                .unwrap_record()
-                .new_val([("D", Val::Bool(false)), ("E", Val::U32(2084037802))])?,
+            "C".into(),
+            Val::Record(vec![
+                ("D".into(), Val::Bool(false)),
+                ("E".into(), Val::U32(2084037802)),
+            ]),
         ),
-    ])?;
+    ]);
     let mut output = [Val::Bool(false)];
     func.call_and_post_return(&mut store, &[input.clone()], &mut output)?;
 
@@ -192,53 +191,61 @@ fn records() -> Result<()> {
 
     // Sad path: type mismatch
 
-    let err = ty
-        .unwrap_record()
-        .new_val([
-            ("A", Val::S32(32343)),
-            ("B", Val::Float64(3.14159265)),
-            (
-                "C",
-                inner_type
-                    .unwrap_record()
-                    .new_val([("D", Val::Bool(false)), ("E", Val::U32(2084037802))])?,
-            ),
-        ])
+    let err = Val::Record(vec![
+        ("A".into(), Val::S32(32343)),
+        ("B".into(), Val::Float64(3.14159265)),
+        (
+            "C".into(),
+            Val::Record(vec![
+                ("D".into(), Val::Bool(false)),
+                ("E".into(), Val::U32(2084037802)),
+            ]),
+        ),
+    ]);
+    let instance = Linker::new(&engine).instantiate(&mut store, &component)?;
+    let func = instance.get_func(&mut store, "echo").unwrap();
+    let err = func
+        .call_and_post_return(&mut store, &[err], &mut output)
         .unwrap_err();
-
     assert!(err.to_string().contains("type mismatch"), "{err}");
 
     // Sad path: too many fields
 
-    let err = ty
-        .unwrap_record()
-        .new_val([
-            ("A", Val::U32(32343)),
-            ("B", Val::Float64(3.14159265)),
-            (
-                "C",
-                inner_type
-                    .unwrap_record()
-                    .new_val([("D", Val::Bool(false)), ("E", Val::U32(2084037802))])?,
-            ),
-            ("F", Val::Bool(true)),
-        ])
+    let err = Val::Record(vec![
+        ("A".into(), Val::U32(32343)),
+        ("B".into(), Val::Float64(3.14159265)),
+        (
+            "C".into(),
+            Val::Record(vec![
+                ("D".into(), Val::Bool(false)),
+                ("E".into(), Val::U32(2084037802)),
+            ]),
+        ),
+        ("F".into(), Val::Bool(true)),
+    ]);
+    let instance = Linker::new(&engine).instantiate(&mut store, &component)?;
+    let func = instance.get_func(&mut store, "echo").unwrap();
+    let err = func
+        .call_and_post_return(&mut store, &[err], &mut output)
         .unwrap_err();
-
     assert!(
-        err.to_string().contains("expected 3 value(s); got 4"),
+        err.to_string().contains("expected 3 fields, got 4"),
         "{err}"
     );
 
     // Sad path: too few fields
 
-    let err = ty
-        .unwrap_record()
-        .new_val([("A", Val::U32(32343)), ("B", Val::Float64(3.14159265))])
+    let err = Val::Record(vec![
+        ("A".into(), Val::U32(32343)),
+        ("B".into(), Val::Float64(3.14159265)),
+    ]);
+    let instance = Linker::new(&engine).instantiate(&mut store, &component)?;
+    let func = instance.get_func(&mut store, "echo").unwrap();
+    let err = func
+        .call_and_post_return(&mut store, &[err], &mut output)
         .unwrap_err();
-
     assert!(
-        err.to_string().contains("expected 3 value(s); got 2"),
+        err.to_string().contains("expected 3 fields, got 2"),
         "{err}"
     );
 
@@ -273,10 +280,7 @@ fn variants() -> Result<()> {
     )?;
     let instance = Linker::new(&engine).instantiate(&mut store, &component)?;
     let func = instance.get_func(&mut store, "echo").unwrap();
-    let ty = &func.params(&store)[0];
-    let input = ty
-        .unwrap_variant()
-        .new_val("B", Some(Val::Float64(3.14159265)))?;
+    let input = Val::Variant("B".into(), Some(Box::new(Val::Float64(3.14159265))));
     let mut output = [Val::Bool(false)];
     func.call_and_post_return(&mut store, &[input.clone()], &mut output)?;
 
@@ -297,28 +301,33 @@ fn variants() -> Result<()> {
     )?;
     let instance = Linker::new(&engine).instantiate(&mut store, &component)?;
     let func = instance.get_func(&mut store, "echo").unwrap();
-    let ty = &func.params(&store)[0];
-    let c_type = &ty.unwrap_variant().cases().nth(2).unwrap().ty.unwrap();
-    let input = ty.unwrap_variant().new_val(
-        "C",
-        Some(
-            c_type
-                .unwrap_record()
-                .new_val([("D", Val::Bool(true)), ("E", Val::U32(314159265))])?,
-        ),
-    )?;
+    let input = Val::Variant(
+        "C".into(),
+        Some(Box::new(Val::Record(vec![
+            ("D".into(), Val::Bool(true)),
+            ("E".into(), Val::U32(314159265)),
+        ]))),
+    );
     func.call_and_post_return(&mut store, &[input.clone()], &mut output)?;
 
     assert_eq!(input, output[0]);
 
     // Sad path: type mismatch
 
-    let err = ty
-        .unwrap_variant()
-        .new_val("B", Some(Val::U64(314159265)))
+    let instance = Linker::new(&engine).instantiate(&mut store, &component)?;
+    let func = instance.get_func(&mut store, "echo").unwrap();
+    let err = Val::Variant("B".into(), Some(Box::new(Val::U64(314159265))));
+    let err = func
+        .call_and_post_return(&mut store, &[err], &mut output)
         .unwrap_err();
     assert!(err.to_string().contains("type mismatch"), "{err}");
-    let err = ty.unwrap_variant().new_val("B", None).unwrap_err();
+
+    let instance = Linker::new(&engine).instantiate(&mut store, &component)?;
+    let func = instance.get_func(&mut store, "echo").unwrap();
+    let err = Val::Variant("B".into(), None);
+    let err = func
+        .call_and_post_return(&mut store, &[err], &mut output)
+        .unwrap_err();
     assert!(
         err.to_string().contains("expected a payload for case `B`"),
         "{err}"
@@ -326,12 +335,20 @@ fn variants() -> Result<()> {
 
     // Sad path: unknown case
 
-    let err = ty
-        .unwrap_variant()
-        .new_val("D", Some(Val::U64(314159265)))
+    let instance = Linker::new(&engine).instantiate(&mut store, &component)?;
+    let func = instance.get_func(&mut store, "echo").unwrap();
+    let err = Val::Variant("D".into(), Some(Box::new(Val::U64(314159265))));
+    let err = func
+        .call_and_post_return(&mut store, &[err], &mut output)
         .unwrap_err();
     assert!(err.to_string().contains("unknown variant case"), "{err}");
-    let err = ty.unwrap_variant().new_val("D", None).unwrap_err();
+
+    let instance = Linker::new(&engine).instantiate(&mut store, &component)?;
+    let func = instance.get_func(&mut store, "echo").unwrap();
+    let err = Val::Variant("D".into(), None);
+    let err = func
+        .call_and_post_return(&mut store, &[err], &mut output)
+        .unwrap_err();
     assert!(err.to_string().contains("unknown variant case"), "{err}");
 
     // Make sure we lift variants which have cases of different sizes with the correct alignment
@@ -363,17 +380,13 @@ fn variants() -> Result<()> {
     )?;
     let instance = Linker::new(&engine).instantiate(&mut store, &component)?;
     let func = instance.get_func(&mut store, "echo").unwrap();
-    let ty = &func.params(&store)[0];
-    let a_type = &ty.unwrap_record().fields().nth(0).unwrap().ty;
-    let input = ty.unwrap_record().new_val([
+    let input = Val::Record(vec![
         (
-            "A",
-            a_type
-                .unwrap_variant()
-                .new_val("A", Some(Val::U32(314159265)))?,
+            "A".into(),
+            Val::Variant("A".into(), Some(Box::new(Val::U32(314159265)))),
         ),
-        ("B", Val::U32(628318530)),
-    ])?;
+        ("B".into(), Val::U32(628318530)),
+    ]);
     func.call_and_post_return(&mut store, &[input.clone()], &mut output)?;
 
     assert_eq!(input, output[0]);
@@ -395,8 +408,7 @@ fn flags() -> Result<()> {
     )?;
     let instance = Linker::new(&engine).instantiate(&mut store, &component)?;
     let func = instance.get_func(&mut store, "echo").unwrap();
-    let ty = &func.params(&store)[0];
-    let input = ty.unwrap_flags().new_val(&["B", "D"])?;
+    let input = Val::Flags(vec!["B".into(), "D".into()]);
     let mut output = [Val::Bool(false)];
     func.call_and_post_return(&mut store, &[input.clone()], &mut output)?;
 
@@ -404,8 +416,10 @@ fn flags() -> Result<()> {
 
     // Sad path: unknown flags
 
-    let err = ty.unwrap_flags().new_val(&["B", "D", "F"]).unwrap_err();
-
+    let err = Val::Flags(vec!["B".into(), "D".into(), "F".into()]);
+    let err = func
+        .call_and_post_return(&mut store, &[err], &mut output)
+        .unwrap_err();
     assert!(err.to_string().contains("unknown flag"), "{err}");
 
     Ok(())
@@ -488,62 +502,42 @@ fn everything() -> Result<()> {
     )?;
     let instance = Linker::new(&engine).instantiate(&mut store, &component)?;
     let func = instance.get_func(&mut store, "echo").unwrap();
-    let ty = &func.params(&store)[0];
-    let types = ty
-        .unwrap_record()
-        .fields()
-        .map(|field| field.ty)
-        .collect::<Box<[component::Type]>>();
-    let (b_type, c_type, f_type, j_type, y_type, aa_type, bb_type) = (
-        &types[1], &types[2], &types[3], &types[4], &types[13], &types[14], &types[15],
-    );
-    let f_element_type = &f_type.unwrap_list().ty();
-    let input = ty.unwrap_record().new_val([
-        ("A", Val::U32(32343)),
-        ("B", b_type.unwrap_enum().new_val("b")?),
-        (
-            "C",
-            c_type
-                .unwrap_record()
-                .new_val([("D", Val::Bool(false)), ("E", Val::U32(2084037802))])?,
-        ),
+    let input = Val::Record(vec![
+        ("A".into(), Val::U32(32343)),
+        ("B".into(), Val::Enum("b".to_string())),
         (
-            "F",
-            f_type.unwrap_list().new_val(Box::new([f_element_type
-                .unwrap_flags()
-                .new_val(&["G", "I"])?]))?,
+            "C".into(),
+            Val::Record(vec![
+                ("D".to_string(), Val::Bool(false)),
+                ("E".to_string(), Val::U32(2084037802)),
+            ]),
         ),
         (
-            "J",
-            j_type
-                .unwrap_variant()
-                .new_val("L", Some(Val::Float64(3.14159265)))?,
+            "F".into(),
+            Val::List(vec![Val::Flags(vec!["G".to_string(), "I".to_string()])]),
         ),
-        ("P", Val::S8(42)),
-        ("Q", Val::S16(4242)),
-        ("R", Val::S32(42424242)),
-        ("S", Val::S64(424242424242424242)),
-        ("T", Val::Float32(3.14159265)),
-        ("U", Val::Float64(3.14159265)),
-        ("V", Val::String(Box::from("wow, nice types"))),
-        ("W", Val::Char('🦀')),
         (
-            "Y",
-            y_type
-                .unwrap_tuple()
-                .new_val(Box::new([Val::U32(42), Val::U32(24)]))?,
+            "J".into(),
+            Val::Variant("L".to_string(), Some(Box::new(Val::Float64(3.14159265)))),
         ),
+        ("P".into(), Val::S8(42)),
+        ("Q".into(), Val::S16(4242)),
+        ("R".into(), Val::S32(42424242)),
+        ("S".into(), Val::S64(424242424242424242)),
+        ("T".into(), Val::Float32(3.14159265)),
+        ("U".into(), Val::Float64(3.14159265)),
+        ("V".into(), Val::String("wow, nice types".to_string())),
+        ("W".into(), Val::Char('🦀')),
+        ("Y".into(), Val::Tuple(vec![Val::U32(42), Val::U32(24)])),
         (
-            "AA",
-            aa_type.unwrap_option().new_val(Some(Val::U32(314159265)))?,
+            "AA".into(),
+            Val::Option(Some(Box::new(Val::U32(314159265)))),
         ),
         (
-            "BB",
-            bb_type
-                .unwrap_result()
-                .new_val(Ok(Some(Val::String(Box::from("no problem")))))?,
+            "BB".into(),
+            Val::Result(Ok(Some(Box::new(Val::String("no problem".to_string()))))),
         ),
-    ])?;
+    ]);
     let mut output = [Val::Bool(false)];
     func.call_and_post_return(&mut store, &[input.clone()], &mut output)?;
 
@@ -551,3 +545,379 @@ fn everything() -> Result<()> {
 
     Ok(())
 }
+
+#[test]
+fn introspection() -> Result<()> {
+    let engine = super::engine();
+
+    let component = Component::new(
+        &engine,
+        format!(
+            r#"
+            (component
+                (import "res" (type $res (sub resource)))
+
+                (import "ai" (instance $i))
+                (import "bi" (instance $i2 (export "m" (core module))))
+
+                (alias export $i2 "m" (core module $m))
+
+                (type $t (func (param "a" u32) (result u32)))
+                (component $a
+                  (core module $m
+                    (func (export "add-five") (param i32) (result i32)
+                      local.get 0
+                      i32.const 5
+                      i32.add)
+                  )
+                  (core instance $m (instantiate $m))
+                  (func (export "add-five") (type $t) (canon lift (core func $m "add-five")))
+                )
+                (component $b
+                  (import "interface-v1" (instance $i
+                    (export "add-five" (func (type $t)))))
+                  (core module $m
+                    (func $add-five (import "interface-0.1.0" "add-five") (param i32) (result i32))
+                    (func) ;; causes index out of bounds
+                    (func (export "run") (result i32) i32.const 0 call $add-five)
+                  )
+                  (core func $add-five (canon lower (func $i "add-five")))
+                  (core instance $i (instantiate 0
+                    (with "interface-0.1.0" (instance
+                      (export "add-five" (func $add-five))
+                    ))
+                  ))
+                  (func (result u32) (canon lift (core func $i "run")))
+                  (export "run" (func 1))
+                )
+                (instance $a (instantiate $a))
+                (instance $b (instantiate $b (with "interface-v1" (instance $a))))
+                (export "run" (func $b "run"))
+
+                (component $c
+                    (component $c
+                        (export "m" (core module $m))
+                    )
+                    (instance $c (instantiate $c))
+                    (export "i" (instance $c))
+                )
+                (instance $c (instantiate $c))
+                (export "i" (instance $c))
+                (export "r" (instance $i))
+                (export "r2" (instance $i2))
+
+                (type $b' (enum "a" "b"))
+                (export $b "b" (type $b'))
+                (type $c' (record (field "D" bool) (field "E" u32)))
+                (export $c "c" (type $c'))
+                (type $f' (flags "G" "H" "I"))
+                (export $f "f" (type $f'))
+                (type $m' (record (field "N" bool) (field "O" u32)))
+                (export $m "m" (type $m'))
+                (type $j' (variant
+                    (case "K" u32)
+                    (case "L" float64)
+                    (case "M" $m)
+                ))
+                (export $j "j" (type $j'))
+
+                (type $Foo' (record
+                    (field "A" u32)
+                    (field "B" $b)
+                    (field "C" $c)
+                    (field "F" (list $f))
+                    (field "J" $j)
+                    (field "P" s8)
+                    (field "Q" s16)
+                    (field "R" s32)
+                    (field "S" s64)
+                    (field "T" float32)
+                    (field "U" float64)
+                    (field "V" string)
+                    (field "W" char)
+                    (field "Y" (tuple u32 u32))
+                    (field "AA" (option u32))
+                    (field "BB" (result string (error string)))
+                    (field "CC" (own $res))
+                ))
+                (export $Foo "foo" (type $Foo'))
+
+                (core module $m2
+                    (func (export "f") (param i32) (result i32)
+                        local.get 0
+                    )
+                    (memory (export "memory") 1)
+                    {REALLOC_AND_FREE}
+                )
+                (core instance $i3 (instantiate $m2))
+
+                (func (export "fn") (param "x" (option $Foo)) (result (option (tuple u32 u32)))
+                    (canon lift
+                        (core func $i3 "f")
+                        (memory $i3 "memory")
+                        (realloc (func $i3 "realloc"))
+                    )
+                )
+            )
+        "#
+        ),
+    )?;
+
+    struct MyType;
+
+    let mut linker = Linker::<()>::new(&engine);
+    linker
+        .root()
+        .resource("res", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
+    linker.instance("ai")?;
+    linker
+        .instance("bi")?
+        .module("m", &Module::new(&engine, "(module)")?)?;
+
+    let component_ty = linker.substituted_component_type(&component)?;
+
+    let mut imports = component_ty.imports(linker.engine());
+    assert_eq!(imports.len(), 3);
+    let (name, res_ty) = imports.next().unwrap();
+    assert_eq!(name, "res");
+    let ComponentItem::Resource(res_ty) = res_ty else {
+        panic!("`res` import item of wrong type")
+    };
+    assert_eq!(res_ty, ResourceType::host::<MyType>());
+
+    let (name, ai_ty) = imports.next().unwrap();
+    assert_eq!(name, "ai");
+    let ComponentItem::ComponentInstance(ai_ty) = ai_ty else {
+        panic!("`ai` import item of wrong type")
+    };
+    assert_eq!(ai_ty.exports(linker.engine()).len(), 0);
+
+    let (name, bi_ty) = imports.next().unwrap();
+    assert_eq!(name, "bi");
+    let ComponentItem::ComponentInstance(bi_ty) = bi_ty else {
+        panic!("`bi` import item of wrong type")
+    };
+    let mut bi_exports = bi_ty.exports(linker.engine());
+    assert_eq!(bi_exports.len(), 1);
+    let (name, bi_m_ty) = bi_exports.next().unwrap();
+    assert_eq!(name, "m");
+    let ComponentItem::Module(bi_m_ty) = bi_m_ty else {
+        panic!("`bi.m` import item of wrong type")
+    };
+    assert_eq!(bi_m_ty.imports(linker.engine()).len(), 0);
+    assert_eq!(bi_m_ty.exports(linker.engine()).len(), 0);
+
+    let mut exports = component_ty.exports(linker.engine());
+    assert_eq!(exports.len(), 11);
+
+    let (name, run_ty) = exports.next().unwrap();
+    assert_eq!(name, "run");
+    let ComponentItem::ComponentFunc(run_ty) = run_ty else {
+        panic!("`run` export item of wrong type")
+    };
+    assert_eq!(run_ty.params().len(), 0);
+
+    let mut run_results = run_ty.results();
+    assert_eq!(run_results.len(), 1);
+    assert_eq!(run_results.next().unwrap(), types::Type::U32);
+
+    let (name, i_ty) = exports.next().unwrap();
+    assert_eq!(name, "i");
+    let ComponentItem::ComponentInstance(i_ty) = i_ty else {
+        panic!("`i` export item of wrong type")
+    };
+    let mut i_ty_exports = i_ty.exports(linker.engine());
+    assert_eq!(i_ty_exports.len(), 1);
+    let (name, i_i_ty) = i_ty_exports.next().unwrap();
+    assert_eq!(name, "i");
+    let ComponentItem::ComponentInstance(i_i_ty) = i_i_ty else {
+        panic!("`i.i` import item of wrong type")
+    };
+    let mut i_i_ty_exports = i_i_ty.exports(linker.engine());
+    assert_eq!(i_i_ty_exports.len(), 1);
+    let (name, i_i_m_ty) = i_i_ty_exports.next().unwrap();
+    assert_eq!(name, "m");
+    let ComponentItem::Module(i_i_m_ty) = i_i_m_ty else {
+        panic!("`i.i.m` import item of wrong type")
+    };
+    assert_eq!(i_i_m_ty.imports(linker.engine()).len(), 0);
+    assert_eq!(i_i_m_ty.exports(linker.engine()).len(), 0);
+
+    let (name, r_ty) = exports.next().unwrap();
+    assert_eq!(name, "r");
+    let ComponentItem::ComponentInstance(r_ty) = r_ty else {
+        panic!("`r` export item of wrong type")
+    };
+    assert_eq!(r_ty.exports(linker.engine()).len(), 0);
+
+    let (name, r2_ty) = exports.next().unwrap();
+    assert_eq!(name, "r2");
+    let ComponentItem::ComponentInstance(r2_ty) = r2_ty else {
+        panic!("`r2` export item of wrong type")
+    };
+    let mut r2_exports = r2_ty.exports(linker.engine());
+    assert_eq!(r2_exports.len(), 1);
+    let (name, r2_m_ty) = r2_exports.next().unwrap();
+    assert_eq!(name, "m");
+    let ComponentItem::Module(r2_m_ty) = r2_m_ty else {
+        panic!("`r2.m` export item of wrong type")
+    };
+    assert_eq!(r2_m_ty.imports(linker.engine()).len(), 0);
+    assert_eq!(r2_m_ty.exports(linker.engine()).len(), 0);
+
+    let (name, b_ty) = exports.next().unwrap();
+    assert_eq!(name, "b");
+    let ComponentItem::Type(b_ty) = b_ty else {
+        panic!("`b` export item of wrong type")
+    };
+    assert_eq!(b_ty.unwrap_enum().names().collect::<Vec<_>>(), ["a", "b"]);
+
+    let (name, c_ty) = exports.next().unwrap();
+    assert_eq!(name, "c");
+    let ComponentItem::Type(c_ty) = c_ty else {
+        panic!("`c` export item of wrong type")
+    };
+    let mut fields = c_ty.unwrap_record().fields();
+    {
+        let Field { name, ty } = fields.next().unwrap();
+        assert_eq!(name, "D");
+        assert_eq!(ty, types::Type::Bool);
+        let Field { name, ty } = fields.next().unwrap();
+        assert_eq!(name, "E");
+        assert_eq!(ty, types::Type::U32);
+    }
+
+    let (name, f_ty) = exports.next().unwrap();
+    assert_eq!(name, "f");
+    let ComponentItem::Type(f_ty) = f_ty else {
+        panic!("`f` export item of wrong type")
+    };
+    assert_eq!(
+        f_ty.unwrap_flags().names().collect::<Vec<_>>(),
+        ["G", "H", "I"]
+    );
+
+    let (name, m_ty) = exports.next().unwrap();
+    assert_eq!(name, "m");
+    let ComponentItem::Type(m_ty) = m_ty else {
+        panic!("`m` export item of wrong type")
+    };
+    {
+        let mut fields = m_ty.unwrap_record().fields();
+        let Field { name, ty } = fields.next().unwrap();
+        assert_eq!(name, "N");
+        assert_eq!(ty, types::Type::Bool);
+        let Field { name, ty } = fields.next().unwrap();
+        assert_eq!(name, "O");
+        assert_eq!(ty, types::Type::U32);
+    }
+
+    let (name, j_ty) = exports.next().unwrap();
+    assert_eq!(name, "j");
+    let ComponentItem::Type(j_ty) = j_ty else {
+        panic!("`j` export item of wrong type")
+    };
+    let mut cases = j_ty.unwrap_variant().cases();
+    {
+        let Case { name, ty } = cases.next().unwrap();
+        assert_eq!(name, "K");
+        assert_eq!(ty, Some(types::Type::U32));
+        let Case { name, ty } = cases.next().unwrap();
+        assert_eq!(name, "L");
+        assert_eq!(ty, Some(types::Type::Float64));
+        let Case { name, ty } = cases.next().unwrap();
+        assert_eq!(name, "M");
+        assert_eq!(ty, Some(m_ty));
+    }
+
+    let (name, foo_ty) = exports.next().unwrap();
+    assert_eq!(name, "foo");
+    let ComponentItem::Type(foo_ty) = foo_ty else {
+        panic!("`foo` export item of wrong type")
+    };
+    {
+        let mut fields = foo_ty.unwrap_record().fields();
+        assert_eq!(fields.len(), 17);
+        let Field { name, ty } = fields.next().unwrap();
+        assert_eq!(name, "A");
+        assert_eq!(ty, types::Type::U32);
+        let Field { name, ty } = fields.next().unwrap();
+        assert_eq!(name, "B");
+        assert_eq!(ty, b_ty);
+        let Field { name, ty } = fields.next().unwrap();
+        assert_eq!(name, "C");
+        assert_eq!(ty, c_ty);
+        let Field { name, ty } = fields.next().unwrap();
+        assert_eq!(name, "F");
+        let ty = ty.unwrap_list();
+        assert_eq!(ty.ty(), f_ty);
+        let Field { name, ty } = fields.next().unwrap();
+        assert_eq!(name, "J");
+        assert_eq!(ty, j_ty);
+        let Field { name, ty } = fields.next().unwrap();
+        assert_eq!(name, "P");
+        assert_eq!(ty, types::Type::S8);
+        let Field { name, ty } = fields.next().unwrap();
+        assert_eq!(name, "Q");
+        assert_eq!(ty, types::Type::S16);
+        let Field { name, ty } = fields.next().unwrap();
+        assert_eq!(name, "R");
+        assert_eq!(ty, types::Type::S32);
+        let Field { name, ty } = fields.next().unwrap();
+        assert_eq!(name, "S");
+        assert_eq!(ty, types::Type::S64);
+        let Field { name, ty } = fields.next().unwrap();
+        assert_eq!(name, "T");
+        assert_eq!(ty, types::Type::Float32);
+        let Field { name, ty } = fields.next().unwrap();
+        assert_eq!(name, "U");
+        assert_eq!(ty, types::Type::Float64);
+        let Field { name, ty } = fields.next().unwrap();
+        assert_eq!(name, "V");
+        assert_eq!(ty, types::Type::String);
+        let Field { name, ty } = fields.next().unwrap();
+        assert_eq!(name, "W");
+        assert_eq!(ty, types::Type::Char);
+        let Field { name, ty } = fields.next().unwrap();
+        assert_eq!(name, "Y");
+        assert_eq!(
+            ty.unwrap_tuple().types().collect::<Vec<_>>(),
+            [types::Type::U32, types::Type::U32]
+        );
+        let Field { name, ty } = fields.next().unwrap();
+        assert_eq!(name, "AA");
+        assert_eq!(ty.unwrap_option().ty(), types::Type::U32);
+        let Field { name, ty } = fields.next().unwrap();
+        assert_eq!(name, "BB");
+        let ty = ty.unwrap_result();
+        assert_eq!(ty.ok(), Some(types::Type::String));
+        assert_eq!(ty.err(), Some(types::Type::String));
+        let Field { name, ty } = fields.next().unwrap();
+        assert_eq!(name, "CC");
+        assert_eq!(*ty.unwrap_own(), res_ty);
+    }
+
+    let (name, fn_ty) = exports.next().unwrap();
+    assert_eq!(name, "fn");
+    let ComponentItem::ComponentFunc(fn_ty) = fn_ty else {
+        panic!("`fn` export item of wrong type")
+    };
+    let mut params = fn_ty.params();
+    assert_eq!(params.len(), 1);
+    assert_eq!(params.next().unwrap().unwrap_option().ty(), foo_ty);
+
+    let mut results = fn_ty.results();
+    assert_eq!(results.len(), 1);
+    assert_eq!(
+        results
+            .next()
+            .unwrap()
+            .unwrap_option()
+            .ty()
+            .unwrap_tuple()
+            .types()
+            .collect::<Vec<_>>(),
+        [types::Type::U32, types::Type::U32]
+    );
+    Ok(())
+}
diff --git a/tests/all/component_model/func.rs b/tests/all/component_model/func.rs
index b7481df02774..36ddfe015e5c 100644
--- a/tests/all/component_model/func.rs
+++ b/tests/all/component_model/func.rs
@@ -5,7 +5,7 @@ use anyhow::Result;
 use std::rc::Rc;
 use std::sync::Arc;
 use wasmtime::component::*;
-use wasmtime::{Store, StoreContextMut, Trap};
+use wasmtime::{Config, Engine, Store, StoreContextMut, Trap};
 
 const CANON_32BIT_NAN: u32 = 0b01111111110000000000000000000000;
 const CANON_64BIT_NAN: u64 = 0b0111111111111000000000000000000000000000000000000000000000000000;
@@ -83,7 +83,9 @@ fn typecheck() -> Result<()> {
         )
     "#;
 
-    let engine = super::engine();
+    let mut config = Config::new();
+    config.wasm_component_model_multiple_returns(true);
+    let engine = Engine::new(&config)?;
     let component = Component::new(&engine, component)?;
     let mut store = Store::new(&engine, ());
     let instance = Linker::new(&engine).instantiate(&mut store, &component)?;
@@ -874,8 +876,7 @@ fn many_parameters() -> Result<()> {
                 (param "pc" (list char))     ;; offset 56, size 8
                 (param "pd" (list string))   ;; offset 64, size 8
 
-                (result "all-memory" (list u8))
-                (result "pointer" u32)
+                (result (tuple (list u8) u32))
             ))
             (func (export "many-param") (type $t)
                 (canon lift
@@ -905,7 +906,7 @@ fn many_parameters() -> Result<()> {
         &[bool],
         &[char],
         &[&str],
-    ), (WasmList<u8>, u32)>(&mut store, "many-param")?;
+    ), ((WasmList<u8>, u32),)>(&mut store, "many-param")?;
 
     let input = (
         -100,
@@ -929,7 +930,7 @@ fn many_parameters() -> Result<()> {
         ]
         .as_slice(),
     );
-    let (memory, pointer) = func.call(&mut store, input)?;
+    let ((memory, pointer),) = func.call(&mut store, input)?;
     let memory = memory.as_le_slice(&store);
 
     let mut actual = &memory[pointer as usize..][..72];
@@ -1123,8 +1124,7 @@ fn some_traps() -> Result<()> {
         assert!(
             err.to_string()
                 .contains("realloc return: beyond end of memory"),
-            "{:?}",
-            err,
+            "{err:?}",
         );
     }
     let err = instance(&mut store)?
@@ -1246,7 +1246,7 @@ fn char_bool_memory() -> Result<()> {
             )
             (core instance $i (instantiate $m))
 
-            (func (export "ret-tuple") (param "a" u32) (param "b" u32) (result "c" bool) (result "d" char)
+            (func (export "ret-tuple") (param "a" u32) (param "b" u32) (result (tuple bool char))
                 (canon lift (core func $i "ret-tuple")
                     (memory $i "memory")
                     (realloc (func $i "realloc")))
@@ -1258,17 +1258,17 @@ fn char_bool_memory() -> Result<()> {
     let component = Component::new(&engine, component)?;
     let mut store = Store::new(&engine, ());
     let instance = Linker::new(&engine).instantiate(&mut store, &component)?;
-    let func = instance.get_typed_func::<(u32, u32), (bool, char)>(&mut store, "ret-tuple")?;
+    let func = instance.get_typed_func::<(u32, u32), ((bool, char),)>(&mut store, "ret-tuple")?;
 
-    let ret = func.call(&mut store, (0, 'a' as u32))?;
+    let (ret,) = func.call(&mut store, (0, 'a' as u32))?;
     assert_eq!(ret, (false, 'a'));
     func.post_return(&mut store)?;
 
-    let ret = func.call(&mut store, (1, '🍰' as u32))?;
+    let (ret,) = func.call(&mut store, (1, '🍰' as u32))?;
     assert_eq!(ret, (true, '🍰'));
     func.post_return(&mut store)?;
 
-    let ret = func.call(&mut store, (2, 'a' as u32))?;
+    let (ret,) = func.call(&mut store, (2, 'a' as u32))?;
     assert_eq!(ret, (true, 'a'));
     func.post_return(&mut store)?;
 
@@ -1441,13 +1441,13 @@ fn option() -> Result<()> {
             )
             (core instance $i (instantiate $m))
 
-            (func (export "option-u8-to-tuple") (param "a" (option u8)) (result "a" u32) (result "b" u32)
+            (func (export "option-u8-to-tuple") (param "a" (option u8)) (result (tuple u32 u32))
                 (canon lift (core func $i "pass1") (memory $i "memory"))
             )
-            (func (export "option-u32-to-tuple") (param "a" (option u32)) (result "a" u32) (result "b" u32)
+            (func (export "option-u32-to-tuple") (param "a" (option u32)) (result (tuple u32 u32))
                 (canon lift (core func $i "pass1") (memory $i "memory"))
             )
-            (func (export "option-string-to-tuple") (param "a" (option string)) (result "a" u32) (result "b" string)
+            (func (export "option-string-to-tuple") (param "a" (option string)) (result (tuple u32 string))
                 (canon lift
                     (core func $i "pass2")
                     (memory $i "memory")
@@ -1479,38 +1479,43 @@ fn option() -> Result<()> {
     let linker = Linker::new(&engine);
     let instance = linker.instantiate(&mut store, &component)?;
 
-    let option_u8_to_tuple =
-        instance.get_typed_func::<(Option<u8>,), (u32, u32)>(&mut store, "option-u8-to-tuple")?;
-    assert_eq!(option_u8_to_tuple.call(&mut store, (None,))?, (0, 0));
+    let option_u8_to_tuple = instance
+        .get_typed_func::<(Option<u8>,), ((u32, u32),)>(&mut store, "option-u8-to-tuple")?;
+    assert_eq!(option_u8_to_tuple.call(&mut store, (None,))?, ((0, 0),));
     option_u8_to_tuple.post_return(&mut store)?;
-    assert_eq!(option_u8_to_tuple.call(&mut store, (Some(0),))?, (1, 0));
+    assert_eq!(option_u8_to_tuple.call(&mut store, (Some(0),))?, ((1, 0),));
     option_u8_to_tuple.post_return(&mut store)?;
-    assert_eq!(option_u8_to_tuple.call(&mut store, (Some(100),))?, (1, 100));
+    assert_eq!(
+        option_u8_to_tuple.call(&mut store, (Some(100),))?,
+        ((1, 100),)
+    );
     option_u8_to_tuple.post_return(&mut store)?;
 
-    let option_u32_to_tuple =
-        instance.get_typed_func::<(Option<u32>,), (u32, u32)>(&mut store, "option-u32-to-tuple")?;
-    assert_eq!(option_u32_to_tuple.call(&mut store, (None,))?, (0, 0));
+    let option_u32_to_tuple = instance
+        .get_typed_func::<(Option<u32>,), ((u32, u32),)>(&mut store, "option-u32-to-tuple")?;
+    assert_eq!(option_u32_to_tuple.call(&mut store, (None,))?, ((0, 0),));
     option_u32_to_tuple.post_return(&mut store)?;
-    assert_eq!(option_u32_to_tuple.call(&mut store, (Some(0),))?, (1, 0));
+    assert_eq!(option_u32_to_tuple.call(&mut store, (Some(0),))?, ((1, 0),));
     option_u32_to_tuple.post_return(&mut store)?;
     assert_eq!(
         option_u32_to_tuple.call(&mut store, (Some(100),))?,
-        (1, 100)
+        ((1, 100),)
     );
     option_u32_to_tuple.post_return(&mut store)?;
 
-    let option_string_to_tuple = instance
-        .get_typed_func::<(Option<&str>,), (u32, WasmStr)>(&mut store, "option-string-to-tuple")?;
-    let (a, b) = option_string_to_tuple.call(&mut store, (None,))?;
+    let option_string_to_tuple = instance.get_typed_func::<(Option<&str>,), ((u32, WasmStr),)>(
+        &mut store,
+        "option-string-to-tuple",
+    )?;
+    let ((a, b),) = option_string_to_tuple.call(&mut store, (None,))?;
     assert_eq!(a, 0);
     assert_eq!(b.to_str(&store)?, "");
     option_string_to_tuple.post_return(&mut store)?;
-    let (a, b) = option_string_to_tuple.call(&mut store, (Some(""),))?;
+    let ((a, b),) = option_string_to_tuple.call(&mut store, (Some(""),))?;
     assert_eq!(a, 1);
     assert_eq!(b.to_str(&store)?, "");
     option_string_to_tuple.post_return(&mut store)?;
-    let (a, b) = option_string_to_tuple.call(&mut store, (Some("hello"),))?;
+    let ((a, b),) = option_string_to_tuple.call(&mut store, (Some("hello"),))?;
     assert_eq!(a, 1);
     assert_eq!(b.to_str(&store)?, "hello");
     option_string_to_tuple.post_return(&mut store)?;
@@ -1613,11 +1618,11 @@ fn expected() -> Result<()> {
             (func (export "take-expected-unit") (param "a" (result)) (result u32)
                 (canon lift (core func $i "pass0"))
             )
-            (func (export "take-expected-u8-f32") (param "a" (result u8 (error float32))) (result "a" u32) (result "b" u32)
+            (func (export "take-expected-u8-f32") (param "a" (result u8 (error float32))) (result (tuple u32 u32))
                 (canon lift (core func $i "pass1") (memory $i "memory"))
             )
             (type $list (list u8))
-            (func (export "take-expected-string") (param "a" (result string (error $list))) (result "a" u32) (result "b" string)
+            (func (export "take-expected-string") (param "a" (result string (error $list))) (result (tuple u32 string))
                 (canon lift
                     (core func $i "pass2")
                     (memory $i "memory")
@@ -1650,24 +1655,25 @@ fn expected() -> Result<()> {
     take_expected_unit.post_return(&mut store)?;
 
     let take_expected_u8_f32 = instance
-        .get_typed_func::<(Result<u8, f32>,), (u32, u32)>(&mut store, "take-expected-u8-f32")?;
-    assert_eq!(take_expected_u8_f32.call(&mut store, (Ok(1),))?, (0, 1));
+        .get_typed_func::<(Result<u8, f32>,), ((u32, u32),)>(&mut store, "take-expected-u8-f32")?;
+    assert_eq!(take_expected_u8_f32.call(&mut store, (Ok(1),))?, ((0, 1),));
     take_expected_u8_f32.post_return(&mut store)?;
     assert_eq!(
         take_expected_u8_f32.call(&mut store, (Err(2.0),))?,
-        (1, 2.0f32.to_bits())
+        ((1, 2.0f32.to_bits()),)
     );
     take_expected_u8_f32.post_return(&mut store)?;
 
-    let take_expected_string = instance.get_typed_func::<(Result<&str, &[u8]>,), (u32, WasmStr)>(
-        &mut store,
-        "take-expected-string",
-    )?;
-    let (a, b) = take_expected_string.call(&mut store, (Ok("hello"),))?;
+    let take_expected_string = instance
+        .get_typed_func::<(Result<&str, &[u8]>,), ((u32, WasmStr),)>(
+            &mut store,
+            "take-expected-string",
+        )?;
+    let ((a, b),) = take_expected_string.call(&mut store, (Ok("hello"),))?;
     assert_eq!(a, 0);
     assert_eq!(b.to_str(&store)?, "hello");
     take_expected_string.post_return(&mut store)?;
-    let (a, b) = take_expected_string.call(&mut store, (Err(b"goodbye"),))?;
+    let ((a, b),) = take_expected_string.call(&mut store, (Err(b"goodbye"),))?;
     assert_eq!(a, 1);
     assert_eq!(b.to_str(&store)?, "goodbye");
     take_expected_string.post_return(&mut store)?;
@@ -1746,9 +1752,7 @@ fn fancy_list() -> Result<()> {
             (type $input (list (tuple $a $b)))
             (func (export "take")
                 (param "a" $input)
-                (result "ptr" u32)
-                (result "len" u32)
-                (result "list" (list u8))
+                (result (tuple u32 u32 (list u8)))
                 (canon lift
                     (core func $i "take")
                     (memory $i "memory")
@@ -1764,7 +1768,7 @@ fn fancy_list() -> Result<()> {
     let instance = Linker::new(&engine).instantiate(&mut store, &component)?;
 
     let func = instance
-        .get_typed_func::<(&[(Option<u8>, Result<(), &str>)],), (u32, u32, WasmList<u8>)>(
+        .get_typed_func::<(&[(Option<u8>, Result<(), &str>)],), ((u32, u32, WasmList<u8>),)>(
             &mut store, "take",
         )?;
 
@@ -1773,7 +1777,7 @@ fn fancy_list() -> Result<()> {
         (Some(2), Err("hello there")),
         (Some(200), Err("general kenobi")),
     ];
-    let (ptr, len, list) = func.call(&mut store, (&input,))?;
+    let ((ptr, len, list),) = func.call(&mut store, (&input,))?;
     let memory = list.as_le_slice(&store);
     let ptr = usize::try_from(ptr).unwrap();
     let len = usize::try_from(len).unwrap();
diff --git a/tests/all/component_model/import.rs b/tests/all/component_model/import.rs
index 9f8ae09f0a7c..2dfd6a37ce09 100644
--- a/tests/all/component_model/import.rs
+++ b/tests/all/component_model/import.rs
@@ -147,7 +147,6 @@ fn simple() -> Result<()> {
     *store.data_mut() = None;
     let mut linker = Linker::new(&engine);
     linker.root().func_new(
-        &component,
         "a",
         |mut store: StoreContextMut<'_, Option<String>>, args, _results| {
             if let Val::String(s) = &args[0] {
@@ -220,6 +219,10 @@ fn functions_in_instances() -> Result<()> {
 
     let engine = super::engine();
     let component = Component::new(&engine, component)?;
+    let (_, instance_index) = component.export_index(None, "test:test/foo").unwrap();
+    let (_, func_index) = component
+        .export_index(Some(&instance_index), "call")
+        .unwrap();
     let mut store = Store::new(&engine, None);
     assert!(store.data().is_none());
 
@@ -236,11 +239,7 @@ fn functions_in_instances() -> Result<()> {
         },
     )?;
     let instance = linker.instantiate(&mut store, &component)?;
-    let func = instance
-        .exports(&mut store)
-        .instance("test:test/foo")
-        .unwrap()
-        .typed_func::<(), ()>("call")?;
+    let func = instance.get_typed_func::<(), ()>(&mut store, &func_index)?;
     func.call(&mut store, ())?;
     assert_eq!(store.data().as_ref().unwrap(), "hello world");
 
@@ -249,7 +248,6 @@ fn functions_in_instances() -> Result<()> {
     *store.data_mut() = None;
     let mut linker = Linker::new(&engine);
     linker.instance("test:test/foo")?.func_new(
-        &component,
         "a",
         |mut store: StoreContextMut<'_, Option<String>>, args, _results| {
             if let Val::String(s) = &args[0] {
@@ -262,12 +260,7 @@ fn functions_in_instances() -> Result<()> {
         },
     )?;
     let instance = linker.instantiate(&mut store, &component)?;
-    let func = instance
-        .exports(&mut store)
-        .instance("test:test/foo")
-        .unwrap()
-        .func("call")
-        .unwrap();
+    let func = instance.get_func(&mut store, func_index).unwrap();
     func.call(&mut store, &[], &mut [])?;
     assert_eq!(store.data().as_ref().unwrap(), "hello world");
 
@@ -468,7 +461,6 @@ fn attempt_to_reenter_during_host() -> Result<()> {
     let mut store = Store::new(&engine, DynamicState { func: None });
     let mut linker = Linker::new(&engine);
     linker.root().func_new(
-        &component,
         "thunk",
         |mut store: StoreContextMut<'_, DynamicState>, _, _| {
             let func = store.data_mut().func.take().unwrap();
@@ -691,58 +683,50 @@ fn stack_and_heap_args_and_rets() -> Result<()> {
     // Next, test the dynamic API
 
     let mut linker = Linker::new(&engine);
-    linker
-        .root()
-        .func_new(&component, "f1", |_, args, results| {
-            if let Val::U32(x) = &args[0] {
-                assert_eq!(*x, 1);
-                results[0] = Val::U32(2);
+    linker.root().func_new("f1", |_, args, results| {
+        if let Val::U32(x) = &args[0] {
+            assert_eq!(*x, 1);
+            results[0] = Val::U32(2);
+            Ok(())
+        } else {
+            panic!()
+        }
+    })?;
+    linker.root().func_new("f2", |_, args, results| {
+        if let Val::Tuple(tuple) = &args[0] {
+            if let Val::String(s) = &tuple[0] {
+                assert_eq!(s.deref(), "abc");
+                results[0] = Val::U32(3);
                 Ok(())
             } else {
                 panic!()
             }
-        })?;
-    linker
-        .root()
-        .func_new(&component, "f2", |_, args, results| {
-            if let Val::Tuple(tuple) = &args[0] {
-                if let Val::String(s) = &tuple.values()[0] {
-                    assert_eq!(s.deref(), "abc");
-                    results[0] = Val::U32(3);
-                    Ok(())
-                } else {
-                    panic!()
-                }
-            } else {
-                panic!()
-            }
-        })?;
-    linker
-        .root()
-        .func_new(&component, "f3", |_, args, results| {
-            if let Val::U32(x) = &args[0] {
-                assert_eq!(*x, 8);
+        } else {
+            panic!()
+        }
+    })?;
+    linker.root().func_new("f3", |_, args, results| {
+        if let Val::U32(x) = &args[0] {
+            assert_eq!(*x, 8);
+            results[0] = Val::String("xyz".into());
+            Ok(())
+        } else {
+            panic!();
+        }
+    })?;
+    linker.root().func_new("f4", |_, args, results| {
+        if let Val::Tuple(tuple) = &args[0] {
+            if let Val::String(s) = &tuple[0] {
+                assert_eq!(s.deref(), "abc");
                 results[0] = Val::String("xyz".into());
                 Ok(())
-            } else {
-                panic!();
-            }
-        })?;
-    linker
-        .root()
-        .func_new(&component, "f4", |_, args, results| {
-            if let Val::Tuple(tuple) = &args[0] {
-                if let Val::String(s) = &tuple.values()[0] {
-                    assert_eq!(s.deref(), "abc");
-                    results[0] = Val::String("xyz".into());
-                    Ok(())
-                } else {
-                    panic!()
-                }
             } else {
                 panic!()
             }
-        })?;
+        } else {
+            panic!()
+        }
+    })?;
     let instance = linker.instantiate(&mut store, &component)?;
     instance
         .get_func(&mut store, "run")
@@ -836,7 +820,7 @@ fn bad_import_alignment() -> Result<()> {
         .call(&mut store, ())
         .unwrap_err();
     assert!(
-        format!("{:?}", trap).contains("pointer not aligned"),
+        format!("{trap:?}").contains("pointer not aligned"),
         "{}",
         trap
     );
@@ -846,7 +830,7 @@ fn bad_import_alignment() -> Result<()> {
         .call(&mut store, ())
         .unwrap_err();
     assert!(
-        format!("{:?}", trap).contains("pointer not aligned"),
+        format!("{trap:?}").contains("pointer not aligned"),
         "{}",
         trap
     );
@@ -906,14 +890,12 @@ fn no_actual_wasm_code() -> Result<()> {
 
     *store.data_mut() = 0;
     let mut linker = Linker::new(&engine);
-    linker.root().func_new(
-        &component,
-        "f",
-        |mut store: StoreContextMut<'_, u32>, _, _| {
+    linker
+        .root()
+        .func_new("f", |mut store: StoreContextMut<'_, u32>, _, _| {
             *store.data_mut() += 1;
             Ok(())
-        },
-    )?;
+        })?;
 
     let instance = linker.instantiate(&mut store, &component)?;
     let thunk = instance.get_func(&mut store, "thunk").unwrap();
diff --git a/tests/all/component_model/instance.rs b/tests/all/component_model/instance.rs
index 8d57886a259b..a398c2e5cfeb 100644
--- a/tests/all/component_model/instance.rs
+++ b/tests/all/component_model/instance.rs
@@ -34,24 +34,139 @@ fn instance_exports() -> Result<()> {
         .module("m", &Module::new(&engine, "(module)")?)?;
     let instance = linker.instantiate(&mut store, &component)?;
 
-    let mut exports = instance.exports(&mut store);
-    assert!(exports.instance("not an instance").is_none());
-    let mut i = exports.instance("r").unwrap();
-    assert!(i.func("x").is_none());
-    drop(i);
-    exports.root().instance("i").unwrap();
-    let mut i2 = exports.instance("r2").unwrap();
-    assert!(i2.func("m").is_none());
-    assert!(i2.module("m").is_some());
-    drop(i2);
-
-    exports
-        .instance("i")
-        .unwrap()
-        .instance("i")
-        .unwrap()
-        .module("m")
+    assert!(instance
+        .get_export(&mut store, None, "not an instance")
+        .is_none());
+    let i = instance.get_export(&mut store, None, "r").unwrap();
+    assert!(instance.get_export(&mut store, Some(&i), "x").is_none());
+    instance.get_export(&mut store, None, "i").unwrap();
+    let i2 = instance.get_export(&mut store, None, "r2").unwrap();
+    let m = instance.get_export(&mut store, Some(&i2), "m").unwrap();
+    assert!(instance.get_func(&mut store, &m).is_none());
+    assert!(instance.get_module(&mut store, &m).is_some());
+
+    let i = instance.get_export(&mut store, None, "i").unwrap();
+    let i = instance.get_export(&mut store, Some(&i), "i").unwrap();
+    let m = instance.get_export(&mut store, Some(&i), "m").unwrap();
+    instance.get_module(&mut store, &m).unwrap();
+
+    Ok(())
+}
+
+#[test]
+fn export_old_get_new() -> Result<()> {
+    let engine = super::engine();
+    let component = r#"
+        (component
+            (core module $m)
+            (export "a:b/m@1.0.0" (core module $m))
+
+            (instance $i (export "m" (core module $m)))
+            (export "a:b/i@1.0.0" (instance $i))
+        )
+    "#;
+
+    let component = Component::new(&engine, component)?;
+    component.export_index(None, "a:b/m@1.0.1").unwrap();
+    let (_, i) = component.export_index(None, "a:b/i@1.0.1").unwrap();
+    component.export_index(Some(&i), "m").unwrap();
+
+    let mut store = Store::new(&engine, ());
+    let linker = Linker::new(&engine);
+    let instance = linker.instantiate(&mut store, &component)?;
+
+    instance.get_module(&mut store, "a:b/m@1.0.1").unwrap();
+    instance
+        .get_export(&mut store, None, "a:b/m@1.0.1")
+        .unwrap();
+
+    let i = instance
+        .get_export(&mut store, None, "a:b/i@1.0.1")
+        .unwrap();
+    instance.get_export(&mut store, Some(&i), "m").unwrap();
+
+    Ok(())
+}
+
+#[test]
+fn export_new_get_old() -> Result<()> {
+    let engine = super::engine();
+    let component = r#"
+        (component
+            (core module $m)
+            (export "a:b/m@1.0.1" (core module $m))
+
+            (instance $i (export "m" (core module $m)))
+            (export "a:b/i@1.0.1" (instance $i))
+        )
+    "#;
+
+    let component = Component::new(&engine, component)?;
+    component.export_index(None, "a:b/m@1.0.0").unwrap();
+    let (_, i) = component.export_index(None, "a:b/i@1.0.0").unwrap();
+    component.export_index(Some(&i), "m").unwrap();
+
+    let mut store = Store::new(&engine, ());
+    let linker = Linker::new(&engine);
+    let instance = linker.instantiate(&mut store, &component)?;
+
+    instance.get_module(&mut store, "a:b/m@1.0.0").unwrap();
+    instance
+        .get_export(&mut store, None, "a:b/m@1.0.0")
+        .unwrap();
+
+    let i = instance
+        .get_export(&mut store, None, "a:b/i@1.0.0")
         .unwrap();
+    instance.get_export(&mut store, Some(&i), "m").unwrap();
+
+    Ok(())
+}
+
+#[test]
+fn export_missing_get_max() -> Result<()> {
+    let engine = super::engine();
+    let component = r#"
+        (component
+            (core module $m1)
+            (core module $m2 (import "" "" (func)))
+            (export "a:b/m@1.0.1" (core module $m1))
+            (export "a:b/m@1.0.3" (core module $m2))
+        )
+    "#;
+
+    fn assert_m2(module: &Module) {
+        assert_eq!(module.imports().len(), 1);
+    }
+    fn assert_m1(module: &Module) {
+        assert_eq!(module.imports().len(), 0);
+    }
+
+    let component = Component::new(&engine, component)?;
+    let mut store = Store::new(&engine, ());
+    let instance = Linker::new(&engine).instantiate(&mut store, &component)?;
+
+    let tests = [
+        ("a:b/m@1.0.0", assert_m2 as fn(&_)), // no exact, should pick max available
+        ("a:b/m@1.0.1", assert_m1),           // exact hit
+        ("a:b/m@1.0.2", assert_m2),           // no exact, should pick max available
+        ("a:b/m@1.0.3", assert_m2),           // exact hit
+        ("a:b/m@1.0.4", assert_m2),           // no exact, should pick max available
+    ];
+
+    for (name, test_fn) in tests {
+        println!("test {name}");
+        let (_, m) = component.export_index(None, name).unwrap();
+        let m = instance.get_module(&mut store, &m).unwrap();
+        test_fn(&m);
+
+        let m = instance.get_module(&mut store, name).unwrap();
+        test_fn(&m);
+
+        let m = instance.get_export(&mut store, None, name).unwrap();
+        let m = instance.get_module(&mut store, &m).unwrap();
+        test_fn(&m);
+    }
 
     Ok(())
 }
diff --git a/tests/all/component_model/linker.rs b/tests/all/component_model/linker.rs
new file mode 100644
index 000000000000..d7c6e4916420
--- /dev/null
+++ b/tests/all/component_model/linker.rs
@@ -0,0 +1,183 @@
+use anyhow::Result;
+use wasmtime::component::types::ComponentItem;
+use wasmtime::component::{Component, Linker, ResourceType};
+use wasmtime::{Engine, Store};
+
+#[test]
+fn old_import_importing_new_item() -> Result<()> {
+    let engine = Engine::default();
+    let mut linker = Linker::<()>::new(&engine);
+
+    let ty = ResourceType::host::<u32>();
+    linker.root().resource("a:b/c@1.0.1", ty, |_, _| Ok(()))?;
+
+    let component = Component::new(
+        &engine,
+        r#"(component
+            (import "a:b/c@1.0.0" (type $t (sub resource)))
+            (export "a" (type $t))
+        )"#,
+    )?;
+    let mut store = Store::new(&engine, ());
+    let i = linker.instantiate(&mut store, &component)?;
+
+    assert_eq!(i.get_resource(&mut store, "a"), Some(ty));
+
+    Ok(())
+}
+
+#[test]
+fn new_import_importing_old_item() -> Result<()> {
+    let engine = Engine::default();
+    let mut linker = Linker::<()>::new(&engine);
+
+    let ty = ResourceType::host::<u32>();
+    linker.root().resource("a:b/c@1.0.0", ty, |_, _| Ok(()))?;
+
+    let component = Component::new(
+        &engine,
+        r#"(component
+            (import "a:b/c@1.0.1" (type $t (sub resource)))
+            (export "a" (type $t))
+        )"#,
+    )?;
+    let mut store = Store::new(&engine, ());
+    let i = linker.instantiate(&mut store, &component)?;
+
+    assert_eq!(i.get_resource(&mut store, "a"), Some(ty));
+
+    Ok(())
+}
+
+#[test]
+fn import_both_old_and_new() -> Result<()> {
+    let engine = Engine::default();
+    let mut linker = Linker::<()>::new(&engine);
+
+    let t1 = ResourceType::host::<u32>();
+    let t2 = ResourceType::host::<i32>();
+    linker.root().resource("a:b/c@1.0.0", t1, |_, _| Ok(()))?;
+    linker.root().resource("a:b/c@1.0.1", t2, |_, _| Ok(()))?;
+
+    let component = Component::new(
+        &engine,
+        r#"(component
+            (import "a:b/c@1.0.0" (type $t1 (sub resource)))
+            (import "a:b/c@1.0.1" (type $t2 (sub resource)))
+            (export "t1" (type $t1))
+            (export "t2" (type $t2))
+        )"#,
+    )?;
+    let mut store = Store::new(&engine, ());
+    let i = linker.instantiate(&mut store, &component)?;
+
+    assert_eq!(i.get_resource(&mut store, "t1"), Some(t1));
+    assert_eq!(i.get_resource(&mut store, "t2"), Some(t2));
+
+    Ok(())
+}
+
+#[test]
+fn missing_import_selects_max() -> Result<()> {
+    let engine = Engine::default();
+    let mut linker = Linker::<()>::new(&engine);
+
+    let t1 = ResourceType::host::<u32>();
+    let t2 = ResourceType::host::<i32>();
+    linker.root().resource("a:b/c@1.0.1", t1, |_, _| Ok(()))?;
+    linker.root().resource("a:b/c@1.0.2", t2, |_, _| Ok(()))?;
+
+    let component = Component::new(
+        &engine,
+        r#"(component
+            (import "a:b/c@1.0.0" (type $t1 (sub resource)))
+            (import "a:b/c@1.0.3" (type $t2 (sub resource)))
+            (export "t1" (type $t1))
+            (export "t2" (type $t2))
+        )"#,
+    )?;
+    let mut store = Store::new(&engine, ());
+    let i = linker.instantiate(&mut store, &component)?;
+
+    assert_eq!(i.get_resource(&mut store, "t1"), Some(t2));
+    assert_eq!(i.get_resource(&mut store, "t2"), Some(t2));
+
+    Ok(())
+}
+
+#[test]
+fn linker_substituting_types_issue_8003() -> Result<()> {
+    let engine = Engine::default();
+    let linker = Linker::<()>::new(&engine);
+    let component = Component::new(
+        &engine,
+        r#"
+            (component
+              (component $foo
+                (type $_myres (resource (rep i32)))
+                (export $myres "myres" (type $_myres))
+
+                (core module $m
+                  (func (export "make") (result i32) unreachable)
+                )
+                (core instance $m (instantiate $m))
+
+                (func (export "make") (result (own $myres))
+                  (canon lift (core func $m "make")))
+              )
+              (instance $foo (instantiate $foo))
+              (export "foo" (instance $foo))
+            )
+        "#,
+    )?;
+
+    let component_ty = linker.substituted_component_type(&component)?;
+    let exports = component_ty.exports(&engine);
+    for (_name, item) in exports {
+        match item {
+            ComponentItem::ComponentInstance(instance) => {
+                for _ in instance.exports(&engine) {
+                    // ..
+                }
+            }
+            _ => {}
+        }
+    }
+    Ok(())
+}
+
+#[test]
+fn linker_defines_unknown_imports_as_traps() -> Result<()> {
+    let engine = Engine::default();
+    let mut linker = Linker::<()>::new(&engine);
+
+    let component = Component::new(
+        &engine,
+        r#"(component
+            (import "foo" (func))
+            (import "bar" (instance (export "baz" (func))))
+            (import "qux" (type (sub resource)))
+        )"#,
+    )?;
+    linker.define_unknown_imports_as_traps(&component)?;
+    let mut store = Store::new(&engine, ());
+    let _ = linker.instantiate(&mut store, &component)?;
+
+    Ok(())
+}
+
+#[test]
+fn linker_fails_to_define_unknown_core_module_imports_as_traps() -> Result<()> {
+    let engine = Engine::default();
+    let mut linker = Linker::<()>::new(&engine);
+
+    let component = Component::new(
+        &engine,
+        r#"(component
+            (import "foo" (core module))
+        )"#,
+    )?;
+    assert!(linker.define_unknown_imports_as_traps(&component).is_err());
+
+    Ok(())
+}
diff --git a/tests/all/component_model/macros.rs b/tests/all/component_model/macros.rs
index cf59adb484c9..9e7dc50386f9 100644
--- a/tests/all/component_model/macros.rs
+++ b/tests/all/component_model/macros.rs
@@ -4,7 +4,7 @@ use super::{make_echo_component, TypedFuncExt};
 use anyhow::Result;
 use component_macro_test::{add_variants, flags_test};
 use wasmtime::component::{Component, ComponentType, Lift, Linker, Lower};
-use wasmtime::Store;
+use wasmtime::{Engine, Store};
 
 #[test]
 fn record_derive() -> Result<()> {
@@ -236,6 +236,7 @@ fn variant_derive() -> Result<()> {
 fn enum_derive() -> Result<()> {
     #[derive(ComponentType, Lift, Lower, PartialEq, Eq, Debug, Copy, Clone)]
     #[component(enum)]
+    #[repr(u8)]
     enum Foo {
         #[component(name = "foo-bar-baz")]
         A,
@@ -299,6 +300,7 @@ fn enum_derive() -> Result<()> {
     #[add_variants(257)]
     #[derive(ComponentType, Lift, Lower, PartialEq, Eq, Debug, Copy, Clone)]
     #[component(enum)]
+    #[repr(u16)]
     enum Many {}
 
     let component = Component::new(
@@ -307,7 +309,7 @@ fn enum_derive() -> Result<()> {
             &format!(
                 "(enum {})",
                 (0..257)
-                    .map(|index| format!(r#""V{}""#, index))
+                    .map(|index| format!(r#""V{index}""#))
                     .collect::<Vec<_>>()
                     .join(" ")
             ),
@@ -330,6 +332,7 @@ fn enum_derive() -> Result<()> {
     // #[add_variants(65537)]
     // #[derive(ComponentType, Lift, Lower, PartialEq, Eq, Debug, Copy, Clone)]
     // #[component(enum)]
+    // #[repr(u32)]
     // enum ManyMore {}
 
     Ok(())
@@ -337,7 +340,9 @@ fn enum_derive() -> Result<()> {
 
 #[test]
 fn flags() -> Result<()> {
-    let engine = super::engine();
+    let mut config = component_test_util::config();
+    config.wasm_component_model_more_flags(true);
+    let engine = Engine::new(&config)?;
     let mut store = Store::new(&engine, ());
 
     // Simple 8-bit flags
@@ -451,7 +456,7 @@ fn flags() -> Result<()> {
             &format!(
                 r#"(flags {})"#,
                 (0..8)
-                    .map(|index| format!(r#""F{}""#, index))
+                    .map(|index| format!(r#""F{index}""#))
                     .collect::<Vec<_>>()
                     .join(" ")
             ),
@@ -500,7 +505,7 @@ fn flags() -> Result<()> {
             &format!(
                 "(flags {})",
                 (0..9)
-                    .map(|index| format!(r#""F{}""#, index))
+                    .map(|index| format!(r#""F{index}""#))
                     .collect::<Vec<_>>()
                     .join(" ")
             ),
@@ -548,7 +553,7 @@ fn flags() -> Result<()> {
             &format!(
                 r#"(flags {})"#,
                 (0..16)
-                    .map(|index| format!(r#""F{}""#, index))
+                    .map(|index| format!(r#""F{index}""#))
                     .collect::<Vec<_>>()
                     .join(" ")
             ),
@@ -587,7 +592,7 @@ fn flags() -> Result<()> {
             &format!(
                 "(flags {})",
                 (0..17)
-                    .map(|index| format!(r#""F{}""#, index))
+                    .map(|index| format!(r#""F{index}""#))
                     .collect::<Vec<_>>()
                     .join(" ")
             ),
@@ -635,7 +640,7 @@ fn flags() -> Result<()> {
             &format!(
                 r#"(flags {})"#,
                 (0..32)
-                    .map(|index| format!(r#""F{}""#, index))
+                    .map(|index| format!(r#""F{index}""#))
                     .collect::<Vec<_>>()
                     .join(" ")
             ),
@@ -674,7 +679,7 @@ fn flags() -> Result<()> {
             &format!(
                 "(flags {})",
                 (0..33)
-                    .map(|index| format!(r#""F{}""#, index))
+                    .map(|index| format!(r#""F{index}""#))
                     .collect::<Vec<_>>()
                     .join(" ")
             ),
@@ -707,7 +712,7 @@ fn flags() -> Result<()> {
             &format!(
                 "(flags {})",
                 (0..65)
-                    .map(|index| format!(r#""F{}""#, index))
+                    .map(|index| format!(r#""F{index}""#))
                     .collect::<Vec<_>>()
                     .join(" ")
             ),
diff --git a/tests/all/component_model/post_return.rs b/tests/all/component_model/post_return.rs
index ffdbdf931f6f..6d86c4db69b2 100644
--- a/tests/all/component_model/post_return.rs
+++ b/tests/all/component_model/post_return.rs
@@ -74,10 +74,10 @@ fn assert_panics(f: impl FnOnce(), msg: &str) {
         Ok(()) => panic!("expected closure to panic"),
         Err(e) => match e.downcast::<String>() {
             Ok(s) => {
-                assert!(s.contains(msg), "bad panic: {}", s);
+                assert!(s.contains(msg), "bad panic: {s}");
             }
             Err(e) => match e.downcast::<&'static str>() {
-                Ok(s) => assert!(s.contains(msg), "bad panic: {}", s),
+                Ok(s) => assert!(s.contains(msg), "bad panic: {s}"),
                 Err(_) => panic!("bad panic"),
             },
         },
diff --git a/tests/all/component_model/resources.rs b/tests/all/component_model/resources.rs
index ba821251f79c..d4fca6a65e86 100644
--- a/tests/all/component_model/resources.rs
+++ b/tests/all/component_model/resources.rs
@@ -37,8 +37,12 @@ fn host_resource_types() -> Result<()> {
 
     let mut store = Store::new(&engine, ());
     let mut linker = Linker::new(&engine);
-    linker.root().resource::<T>("t", |_, _| Ok(()))?;
-    linker.root().resource::<U>("u", |_, _| Ok(()))?;
+    linker
+        .root()
+        .resource("t", ResourceType::host::<T>(), |_, _| Ok(()))?;
+    linker
+        .root()
+        .resource("u", ResourceType::host::<U>(), |_, _| Ok(()))?;
     let i = linker.instantiate(&mut store, &c)?;
     let t1 = i.get_resource(&mut store, "t1").unwrap();
     let t2 = i.get_resource(&mut store, "t2").unwrap();
@@ -133,44 +137,70 @@ fn resource_any() -> Result<()> {
         "#,
     )?;
 
-    let mut store = Store::new(&engine, ());
     let linker = Linker::new(&engine);
-    let i = linker.instantiate(&mut store, &c)?;
-    let t = i.get_resource(&mut store, "t").unwrap();
-    let u = i.get_resource(&mut store, "u").unwrap();
+    {
+        let mut store = Store::new(&engine, ());
+        let i = linker.instantiate(&mut store, &c)?;
+        let t = i.get_resource(&mut store, "t").unwrap();
+        let u = i.get_resource(&mut store, "u").unwrap();
+
+        assert_ne!(t, u);
+
+        let t_ctor = i.get_typed_func::<(u32,), (ResourceAny,)>(&mut store, "[constructor]t")?;
+        let u_ctor = i.get_typed_func::<(u32,), (ResourceAny,)>(&mut store, "[constructor]u")?;
+        let t_dtor = i.get_typed_func::<(ResourceAny,), ()>(&mut store, "drop-t")?;
+        let u_dtor = i.get_typed_func::<(ResourceAny,), ()>(&mut store, "drop-u")?;
+
+        let (t1,) = t_ctor.call(&mut store, (100,))?;
+        t_ctor.post_return(&mut store)?;
+        let (t2,) = t_ctor.call(&mut store, (200,))?;
+        t_ctor.post_return(&mut store)?;
+        let (u1,) = u_ctor.call(&mut store, (300,))?;
+        u_ctor.post_return(&mut store)?;
+        let (u2,) = u_ctor.call(&mut store, (400,))?;
+        u_ctor.post_return(&mut store)?;
 
-    assert_ne!(t, u);
+        assert_eq!(t1.ty(), t);
+        assert_eq!(t2.ty(), t);
+        assert_eq!(u1.ty(), u);
+        assert_eq!(u2.ty(), u);
 
-    let t_ctor = i.get_typed_func::<(u32,), (ResourceAny,)>(&mut store, "[constructor]t")?;
-    let u_ctor = i.get_typed_func::<(u32,), (ResourceAny,)>(&mut store, "[constructor]u")?;
-    let t_dtor = i.get_typed_func::<(ResourceAny,), ()>(&mut store, "drop-t")?;
-    let u_dtor = i.get_typed_func::<(ResourceAny,), ()>(&mut store, "drop-u")?;
+        u_dtor.call(&mut store, (u2,))?;
+        u_dtor.post_return(&mut store)?;
 
-    let (t1,) = t_ctor.call(&mut store, (100,))?;
-    t_ctor.post_return(&mut store)?;
-    let (t2,) = t_ctor.call(&mut store, (200,))?;
-    t_ctor.post_return(&mut store)?;
-    let (u1,) = u_ctor.call(&mut store, (300,))?;
-    u_ctor.post_return(&mut store)?;
-    let (u2,) = u_ctor.call(&mut store, (400,))?;
-    u_ctor.post_return(&mut store)?;
+        u_dtor.call(&mut store, (u1,))?;
+        u_dtor.post_return(&mut store)?;
 
-    assert_eq!(t1.ty(), t);
-    assert_eq!(t2.ty(), t);
-    assert_eq!(u1.ty(), u);
-    assert_eq!(u2.ty(), u);
+        t_dtor.call(&mut store, (t1,))?;
+        t_dtor.post_return(&mut store)?;
 
-    u_dtor.call(&mut store, (u2,))?;
-    u_dtor.post_return(&mut store)?;
+        t_dtor.call(&mut store, (t2,))?;
+        t_dtor.post_return(&mut store)?;
+    }
 
-    u_dtor.call(&mut store, (u1,))?;
-    u_dtor.post_return(&mut store)?;
+    {
+        let mut store = Store::new(&engine, ());
+        let i = linker.instantiate(&mut store, &c)?;
+        let t_ctor = i.get_typed_func::<(u32,), (ResourceAny,)>(&mut store, "[constructor]t")?;
+        let u_ctor = i.get_typed_func::<(u32,), (ResourceAny,)>(&mut store, "[constructor]u")?;
+        let t_dtor = i.get_typed_func::<(ResourceAny,), ()>(&mut store, "drop-t")?;
 
-    t_dtor.call(&mut store, (t1,))?;
-    t_dtor.post_return(&mut store)?;
+        // `t` is placed at host index 0
+        let (t,) = t_ctor.call(&mut store, (100,))?;
+        t_ctor.post_return(&mut store)?;
+        t_dtor.call(&mut store, (t,))?;
+        t_dtor.post_return(&mut store)?;
 
-    t_dtor.call(&mut store, (t2,))?;
-    t_dtor.post_return(&mut store)?;
+        // `u` is also placed at host index 0 since `t` was deallocated
+        let (_u,) = u_ctor.call(&mut store, (100,))?;
+        u_ctor.post_return(&mut store)?;
+
+        // reuse of `t` should fail, despite it pointing to a valid resource
+        assert_eq!(
+            t_dtor.call(&mut store, (t,)).unwrap_err().to_string(),
+            "host-owned resource is being used with the wrong type"
+        );
+    }
 
     Ok(())
 }
@@ -203,7 +233,7 @@ fn mismatch_intrinsics() -> Result<()> {
     let ctor = i.get_typed_func::<(u32,), (ResourceAny,)>(&mut store, "ctor")?;
     assert_eq!(
         ctor.call(&mut store, (100,)).unwrap_err().to_string(),
-        "unknown handle index 0"
+        "unknown handle index 1"
     );
 
     Ok(())
@@ -341,7 +371,7 @@ fn drop_guest_twice() -> Result<()> {
 
     assert_eq!(
         dtor.call(&mut store, (&t,)).unwrap_err().to_string(),
-        "unknown handle index 0"
+        "unknown handle index 1"
     );
 
     Ok(())
@@ -367,7 +397,9 @@ fn drop_host_twice() -> Result<()> {
 
     let mut store = Store::new(&engine, ());
     let mut linker = Linker::new(&engine);
-    linker.root().resource::<MyType>("t", |_, _| Ok(()))?;
+    linker
+        .root()
+        .resource("t", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
     let i = linker.instantiate(&mut store, &c)?;
     let dtor = i.get_typed_func::<(&Resource<MyType>,), ()>(&mut store, "dtor")?;
 
@@ -431,12 +463,14 @@ fn manually_destroy() -> Result<()> {
 
     let mut store = Store::new(&engine, Data::default());
     let mut linker = Linker::new(&engine);
-    linker.root().resource::<MyType>("t1", |mut cx, rep| {
-        let data: &mut Data = cx.data_mut();
-        data.drops += 1;
-        data.last_drop = Some(rep);
-        Ok(())
-    })?;
+    linker
+        .root()
+        .resource("t1", ResourceType::host::<MyType>(), |mut cx, rep| {
+            let data: &mut Data = cx.data_mut();
+            data.drops += 1;
+            data.last_drop = Some(rep);
+            Ok(())
+        })?;
     let i = linker.instantiate(&mut store, &c)?;
     let t2_ctor = i.get_typed_func::<(u32,), (ResourceAny,)>(&mut store, "[constructor]t2")?;
     let t2_drops = i.get_typed_func::<(), (u32,)>(&mut store, "[static]t2.drops")?;
@@ -497,7 +531,9 @@ fn dynamic_type() -> Result<()> {
 
     let mut store = Store::new(&engine, ());
     let mut linker = Linker::new(&engine);
-    linker.root().resource::<MyType>("t1", |_, _| Ok(()))?;
+    linker
+        .root()
+        .resource("t1", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
     let i = linker.instantiate(&mut store, &c)?;
 
     let a = i.get_func(&mut store, "a").unwrap();
@@ -548,11 +584,16 @@ fn dynamic_val() -> Result<()> {
 
     let mut store = Store::new(&engine, ());
     let mut linker = Linker::new(&engine);
-    linker.root().resource::<MyType>("t1", |_, _| Ok(()))?;
-    let i = linker.instantiate(&mut store, &c)?;
+    linker
+        .root()
+        .resource("t1", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
+    let i_pre = linker.instantiate_pre(&c)?;
+    let i = i_pre.instantiate(&mut store)?;
 
     let a = i.get_func(&mut store, "a").unwrap();
     let a_typed = i.get_typed_func::<(Resource<MyType>,), (ResourceAny,)>(&mut store, "a")?;
+    let a_typed_result =
+        i.get_typed_func::<(Resource<MyType>,), (Resource<MyType>,)>(&mut store, "a")?;
     let b = i.get_func(&mut store, "b").unwrap();
     let t2 = i.get_resource(&mut store, "t2").unwrap();
 
@@ -567,6 +608,66 @@ fn dynamic_val() -> Result<()> {
     match &results[0] {
         Val::Resource(resource) => {
             assert_eq!(resource.ty(), ResourceType::host::<MyType>());
+            assert!(resource.owned());
+
+            let resource = resource.try_into_resource::<MyType>(&mut store)?;
+            assert_eq!(resource.rep(), 100);
+            assert!(resource.owned());
+
+            let resource = resource.try_into_resource_any(&mut store)?;
+            assert_eq!(resource.ty(), ResourceType::host::<MyType>());
+            assert!(resource.owned());
+        }
+        _ => unreachable!(),
+    }
+
+    let t1_any = Resource::<MyType>::new_own(100).try_into_resource_any(&mut store)?;
+    let mut results = [Val::Bool(false)];
+    a.call(&mut store, &[Val::Resource(t1_any)], &mut results)?;
+    a.post_return(&mut store)?;
+    match &results[0] {
+        Val::Resource(resource) => {
+            assert_eq!(resource.ty(), ResourceType::host::<MyType>());
+            assert!(resource.owned());
+
+            let resource = resource.try_into_resource::<MyType>(&mut store)?;
+            assert_eq!(resource.rep(), 100);
+            assert!(resource.owned());
+
+            let resource = resource.try_into_resource_any(&mut store)?;
+            assert_eq!(resource.ty(), ResourceType::host::<MyType>());
+            assert!(resource.owned());
+        }
+        _ => unreachable!(),
+    }
+
+    let t1 = Resource::<MyType>::new_own(100)
+        .try_into_resource_any(&mut store)?
+        .try_into_resource(&mut store)?;
+    let (t1,) = a_typed_result.call(&mut store, (t1,))?;
+    a_typed_result.post_return(&mut store)?;
+    assert_eq!(t1.rep(), 100);
+    assert!(t1.owned());
+
+    let t1_any = t1
+        .try_into_resource_any(&mut store)?
+        .try_into_resource::<MyType>(&mut store)?
+        .try_into_resource_any(&mut store)?;
+    let mut results = [Val::Bool(false)];
+    a.call(&mut store, &[Val::Resource(t1_any)], &mut results)?;
+    a.post_return(&mut store)?;
+    match &results[0] {
+        Val::Resource(resource) => {
+            assert_eq!(resource.ty(), ResourceType::host::<MyType>());
+            assert!(resource.owned());
+
+            let resource = resource.try_into_resource::<MyType>(&mut store)?;
+            assert_eq!(resource.rep(), 100);
+            assert!(resource.owned());
+
+            let resource = resource.try_into_resource_any(&mut store)?;
+            assert_eq!(resource.ty(), ResourceType::host::<MyType>());
+            assert!(resource.owned());
         }
         _ => unreachable!(),
     }
@@ -665,7 +766,9 @@ fn active_borrows_at_end_of_call() -> Result<()> {
 
     let mut store = Store::new(&engine, ());
     let mut linker = Linker::new(&engine);
-    linker.root().resource::<MyType>("t", |_, _| Ok(()))?;
+    linker
+        .root()
+        .resource("t", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
     let i = linker.instantiate(&mut store, &c)?;
 
     let f = i.get_typed_func::<(&Resource<MyType>,), ()>(&mut store, "f")?;
@@ -720,7 +823,9 @@ fn thread_through_borrow() -> Result<()> {
 
     let mut store = Store::new(&engine, ());
     let mut linker = Linker::new(&engine);
-    linker.root().resource::<MyType>("t", |_, _| Ok(()))?;
+    linker
+        .root()
+        .resource("t", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
     linker
         .root()
         .func_wrap("f", |_cx, (r,): (Resource<MyType>,)| {
@@ -764,7 +869,9 @@ fn cannot_use_borrow_for_own() -> Result<()> {
 
     let mut store = Store::new(&engine, ());
     let mut linker = Linker::new(&engine);
-    linker.root().resource::<MyType>("t", |_, _| Ok(()))?;
+    linker
+        .root()
+        .resource("t", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
     let i = linker.instantiate(&mut store, &c)?;
 
     let f = i.get_typed_func::<(&Resource<MyType>,), (Resource<MyType>,)>(&mut store, "f")?;
@@ -775,6 +882,71 @@ fn cannot_use_borrow_for_own() -> Result<()> {
     Ok(())
 }
 
+#[test]
+fn can_use_own_for_borrow() -> Result<()> {
+    let engine = super::engine();
+    let c = Component::new(
+        &engine,
+        r#"
+            (component
+                (import "t" (type $t (sub resource)))
+
+                (core func $drop (canon resource.drop $t))
+
+                (core module $m
+                    (import "" "drop" (func $drop (param i32)))
+                    (func (export "f") (param i32)
+                        (call $drop (local.get 0))
+                    )
+                )
+                (core instance $i (instantiate $m
+                    (with "" (instance
+                        (export "drop" (func $drop))
+                    ))
+                ))
+
+                (func (export "f") (param "x" (borrow $t))
+                    (canon lift (core func $i "f")))
+            )
+        "#,
+    )?;
+
+    struct MyType;
+
+    let mut store = Store::new(&engine, ());
+    let mut linker = Linker::new(&engine);
+    linker
+        .root()
+        .resource("t", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
+    let i_pre = linker.instantiate_pre(&c)?;
+    let i = i_pre.instantiate(&mut store)?;
+
+    let f = i.get_func(&mut store, "f").unwrap();
+    let f_typed = i.get_typed_func::<(&Resource<MyType>,), ()>(&mut store, "f")?;
+
+    let resource = Resource::new_own(100);
+    f_typed.call(&mut store, (&resource,))?;
+    f_typed.post_return(&mut store)?;
+
+    let resource = Resource::new_borrow(200);
+    f_typed.call(&mut store, (&resource,))?;
+    f_typed.post_return(&mut store)?;
+
+    let resource = Resource::<MyType>::new_own(300).try_into_resource_any(&mut store)?;
+    f.call(&mut store, &[Val::Resource(resource)], &mut [])?;
+    f.post_return(&mut store)?;
+    resource.resource_drop(&mut store)?;
+
+    // TODO: Enable once https://github.com/bytecodealliance/wasmtime/issues/7793 is fixed
+    //let resource =
+    //    Resource::<MyType>::new_borrow(400).try_into_resource_any(&mut store, &i_pre, ty_idx)?;
+    //f.call(&mut store, &[Val::Resource(resource)], &mut [])?;
+    //f.post_return(&mut store)?;
+    //resource.resource_drop(&mut store)?;
+
+    Ok(())
+}
+
 #[test]
 fn passthrough_wrong_type() -> Result<()> {
     let engine = super::engine();
@@ -809,7 +981,9 @@ fn passthrough_wrong_type() -> Result<()> {
 
     let mut store = Store::new(&engine, ());
     let mut linker = Linker::new(&engine);
-    linker.root().resource::<MyType>("t", |_, _| Ok(()))?;
+    linker
+        .root()
+        .resource("t", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
     linker
         .root()
         .func_wrap("f", |_cx, (r,): (Resource<MyType>,)| Ok((r,)))?;
@@ -849,7 +1023,9 @@ fn pass_moved_resource() -> Result<()> {
 
     let mut store = Store::new(&engine, ());
     let mut linker = Linker::new(&engine);
-    linker.root().resource::<MyType>("t", |_, _| Ok(()))?;
+    linker
+        .root()
+        .resource("t", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
     let i = linker.instantiate(&mut store, &c)?;
 
     let f = i.get_typed_func::<(&Resource<MyType>, &Resource<MyType>), ()>(&mut store, "f")?;
@@ -980,7 +1156,9 @@ fn host_borrow_as_resource_any() -> Result<()> {
     // First test the above component where the host properly drops the argument
     {
         let mut linker = Linker::new(&engine);
-        linker.root().resource::<MyType>("t", |_, _| Ok(()))?;
+        linker
+            .root()
+            .resource("t", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
         linker
             .root()
             .func_wrap("f", |mut cx, (r,): (ResourceAny,)| {
@@ -998,7 +1176,9 @@ fn host_borrow_as_resource_any() -> Result<()> {
     // Then also test the case where the host forgets a drop
     {
         let mut linker = Linker::new(&engine);
-        linker.root().resource::<MyType>("t", |_, _| Ok(()))?;
+        linker
+            .root()
+            .resource("t", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
         linker.root().func_wrap("f", |_cx, (_r,): (ResourceAny,)| {
             // ... no drop here
             Ok(())
@@ -1069,7 +1249,7 @@ fn pass_guest_back_as_borrow() -> Result<()> {
 
     // Should not be valid to use `resource` again
     let err = take.call(&mut store, (&resource,)).unwrap_err();
-    assert_eq!(err.to_string(), "unknown handle index 0");
+    assert_eq!(err.to_string(), "unknown handle index 1");
 
     Ok(())
 }
@@ -1107,7 +1287,9 @@ fn pass_host_borrow_to_guest() -> Result<()> {
 
     let mut store = Store::new(&engine, ());
     let mut linker = Linker::new(&engine);
-    linker.root().resource::<MyType>("t", |_, _| Ok(()))?;
+    linker
+        .root()
+        .resource("t", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
     let i = linker.instantiate(&mut store, &c)?;
     let take = i.get_typed_func::<(&Resource<MyType>,), ()>(&mut store, "take")?;
 
@@ -1180,7 +1362,9 @@ fn drop_on_owned_resource() -> Result<()> {
 
     let mut store = Store::new(&engine, ());
     let mut linker = Linker::new(&engine);
-    linker.root().resource::<MyType>("t", |_, _| Ok(()))?;
+    linker
+        .root()
+        .resource("t", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
     linker.root().func_wrap("[constructor]t", |_cx, ()| {
         Ok((Resource::<MyType>::new_own(300),))
     })?;
@@ -1227,9 +1411,9 @@ fn guest_different_host_same() -> Result<()> {
                     (import "" "drop2" (func $drop2 (param i32)))
 
                     (func (export "f") (param i32 i32)
-                        ;; separate tables both have initial index of 0
-                        (if (i32.ne (local.get 0) (i32.const 0)) (then (unreachable)))
-                        (if (i32.ne (local.get 1) (i32.const 0)) (then (unreachable)))
+                        ;; separate tables both have initial index of 1
+                        (if (i32.ne (local.get 0) (i32.const 1)) (then (unreachable)))
+                        (if (i32.ne (local.get 1) (i32.const 1)) (then (unreachable)))
 
                         ;; host should end up getting the same resource
                         (call $f (local.get 0) (local.get 1))
@@ -1257,8 +1441,12 @@ fn guest_different_host_same() -> Result<()> {
 
     let mut store = Store::new(&engine, ());
     let mut linker = Linker::new(&engine);
-    linker.root().resource::<MyType>("t1", |_, _| Ok(()))?;
-    linker.root().resource::<MyType>("t2", |_, _| Ok(()))?;
+    linker
+        .root()
+        .resource("t1", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
+    linker
+        .root()
+        .resource("t2", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
     linker.root().func_wrap(
         "f",
         |_cx, (r1, r2): (Resource<MyType>, Resource<MyType>)| {
@@ -1283,3 +1471,60 @@ fn guest_different_host_same() -> Result<()> {
 
     Ok(())
 }
+
+#[test]
+fn resource_any_to_typed_handles_borrow() -> Result<()> {
+    let engine = super::engine();
+    let c = Component::new(
+        &engine,
+        r#"
+            (component
+                (import "t" (type $t (sub resource)))
+
+                (import "f" (func $f (param "a" (borrow $t))))
+
+                (core func $f (canon lower (func $f)))
+
+                (core module $m
+                    (import "" "f" (func $f (param i32)))
+
+                    (func (export "f") (param i32)
+                        (call $f (local.get 0))
+                    )
+                )
+                (core instance $i (instantiate $m
+                    (with "" (instance
+                        (export "f" (func $f))
+                    ))
+                ))
+
+                (func (export "f") (param "a" (own $t))
+                    (canon lift (core func $i "f")))
+            )
+        "#,
+    )?;
+
+    struct MyType;
+
+    let mut store = Store::new(&engine, ());
+    let mut linker = Linker::new(&engine);
+    linker
+        .root()
+        .resource("t", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
+    linker
+        .root()
+        .func_wrap("f", |mut cx, (r,): (ResourceAny,)| {
+            let r = r.try_into_resource::<MyType>(&mut cx).unwrap();
+            assert_eq!(r.rep(), 100);
+            assert!(!r.owned());
+            Ok(())
+        })?;
+    let i = linker.instantiate(&mut store, &c)?;
+    let f = i.get_typed_func::<(&Resource<MyType>,), ()>(&mut store, "f")?;
+
+    let resource = Resource::new_own(100);
+    f.call(&mut store, (&resource,))?;
+    f.post_return(&mut store)?;
+
+    Ok(())
+}
diff --git a/tests/all/component_model/strings.rs b/tests/all/component_model/strings.rs
index ad46ddb0a6ab..67d42ab45664 100644
--- a/tests/all/component_model/strings.rs
+++ b/tests/all/component_model/strings.rs
@@ -500,9 +500,8 @@ fn test_invalid_string_encoding(
     let trap = test_raw_when_encoded(engine, src, dst, bytes, len)?.unwrap();
     let src = src.replace("latin1+", "");
     assert!(
-        format!("{:?}", trap).contains(&format!("invalid {src} encoding")),
-        "bad error: {:?}",
-        trap,
+        format!("{trap:?}").contains(&format!("invalid {src} encoding")),
+        "bad error: {trap:?}",
     );
     Ok(())
 }
diff --git a/tests/all/coredump.rs b/tests/all/coredump.rs
index 492bce76db64..945322fe78dd 100644
--- a/tests/all/coredump.rs
+++ b/tests/all/coredump.rs
@@ -1,4 +1,4 @@
-use anyhow::{bail, Result};
+use anyhow::bail;
 use wasmtime::*;
 
 #[test]
@@ -17,7 +17,7 @@ fn coredump_attached_to_error() -> Result<()> {
     "#;
 
     let module = Module::new(store.engine(), wat)?;
-    let hello_type = FuncType::new(None, None);
+    let hello_type = FuncType::new(store.engine(), None, None);
     let hello_func = Func::new(&mut store, hello_type, |_, _, _| bail!("test 123"));
 
     let instance = Instance::new(&mut store, &module, &[hello_func.into()])?;
diff --git a/tests/all/custom_signal_handler.rs b/tests/all/custom_signal_handler.rs
deleted file mode 100644
index fdfc22a7fef3..000000000000
--- a/tests/all/custom_signal_handler.rs
+++ /dev/null
@@ -1,336 +0,0 @@
-#[cfg(any(
-    target_os = "linux",
-    all(target_os = "macos", feature = "posix-signals-on-macos")
-))]
-#[cfg(not(miri))]
-mod tests {
-    use anyhow::Result;
-    use rustix::mm::{mprotect, MprotectFlags};
-    use std::sync::atomic::{AtomicBool, Ordering};
-    use std::sync::Arc;
-    use wasmtime::unix::StoreExt;
-    use wasmtime::*;
-
-    const WAT1: &str = r#"
-(module
-  (func $hostcall_read (import "" "hostcall_read") (result i32))
-  (func $read (export "read") (result i32)
-    (i32.load (i32.const 0))
-  )
-  (func $read_out_of_bounds (export "read_out_of_bounds") (result i32)
-    (i32.load
-      (i32.mul
-        ;; memory size in Wasm pages
-        (memory.size)
-        ;; Wasm page size
-        (i32.const 65536)
-      )
-    )
-  )
-  (func (export "hostcall_read") (result i32)
-    call $hostcall_read
-  )
-  (func $start
-    (i32.store (i32.const 0) (i32.const 123))
-  )
-  (start $start)
-  (memory (export "memory") 1 4)
-)
-"#;
-
-    const WAT2: &str = r#"
-(module
-  (import "other_module" "read" (func $other_module.read (result i32)))
-  (func $run (export "run") (result i32)
-      call $other_module.read)
-)
-"#;
-
-    fn invoke_export(store: &mut Store<()>, instance: Instance, func_name: &str) -> Result<i32> {
-        let ret = instance
-            .get_typed_func::<(), i32>(&mut *store, func_name)?
-            .call(store, ())?;
-        Ok(ret)
-    }
-
-    // Locate "memory" export, get base address and size and set memory protection to PROT_NONE
-    fn set_up_memory(store: &mut Store<()>, instance: Instance) -> (usize, usize) {
-        let mem_export = instance.get_memory(&mut *store, "memory").unwrap();
-        let base = mem_export.data_ptr(&store);
-        let length = mem_export.data_size(&store);
-
-        // So we can later trigger SIGSEGV by performing a read
-        unsafe {
-            mprotect(
-                base as *mut std::ffi::c_void,
-                length,
-                MprotectFlags::empty(),
-            )
-            .unwrap();
-        }
-
-        println!("memory: base={:?}, length={}", base, length);
-
-        (base as usize, length)
-    }
-
-    fn handle_sigsegv(
-        base: usize,
-        length: usize,
-        signum: libc::c_int,
-        siginfo: *const libc::siginfo_t,
-    ) -> bool {
-        println!("Hello from instance signal handler!");
-        // SIGSEGV on Linux, SIGBUS on Mac
-        if libc::SIGSEGV == signum || libc::SIGBUS == signum {
-            let si_addr: *mut libc::c_void = unsafe { (*siginfo).si_addr() };
-            // Any signal from within module's memory we handle ourselves
-            let result = (si_addr as u64) < (base as u64) + (length as u64);
-            // Remove protections so the execution may resume
-            unsafe {
-                mprotect(
-                    base as *mut libc::c_void,
-                    length,
-                    MprotectFlags::READ | MprotectFlags::WRITE,
-                )
-                .unwrap();
-            }
-            println!("signal handled: {}", result);
-            result
-        } else {
-            // Otherwise, we forward to wasmtime's signal handler.
-            false
-        }
-    }
-
-    fn make_externs(store: &mut Store<()>, module: &Module) -> Vec<Extern> {
-        module
-            .imports()
-            .map(|import| {
-                assert_eq!("hostcall_read", import.name());
-                let func = Func::wrap(&mut *store, {
-                    move |mut caller: Caller<'_, _>| {
-                        let mem = caller.get_export("memory").unwrap().into_memory().unwrap();
-                        let memory = mem.data(&caller);
-                        i32::from_le_bytes(memory[0..4].try_into().unwrap())
-                    }
-                });
-                wasmtime::Extern::Func(func)
-            })
-            .collect::<Vec<_>>()
-    }
-
-    // This test will only succeed if the SIGSEGV signal originating from the
-    // hostcall can be handled.
-    #[test]
-    fn test_custom_signal_handler_single_instance_hostcall() -> Result<()> {
-        let engine = Engine::default();
-        let mut store = Store::new(&engine, ());
-        let module = Module::new(&engine, WAT1)?;
-
-        let externs = make_externs(&mut store, &module);
-        let instance = Instance::new(&mut store, &module, &externs)?;
-
-        let (base, length) = set_up_memory(&mut store, instance);
-        unsafe {
-            store.set_signal_handler(move |signum, siginfo, _| {
-                handle_sigsegv(base, length, signum, siginfo)
-            });
-        }
-        println!("calling hostcall_read...");
-        let result = invoke_export(&mut store, instance, "hostcall_read").unwrap();
-        assert_eq!(123, result);
-        Ok(())
-    }
-
-    #[test]
-    fn test_custom_signal_handler_single_instance() -> Result<()> {
-        let engine = Engine::new(&Config::default())?;
-        let mut store = Store::new(&engine, ());
-        let module = Module::new(&engine, WAT1)?;
-
-        let externs = make_externs(&mut store, &module);
-        let instance = Instance::new(&mut store, &module, &externs)?;
-
-        let (base, length) = set_up_memory(&mut store, instance);
-        unsafe {
-            store.set_signal_handler(move |signum, siginfo, _| {
-                handle_sigsegv(base, length, signum, siginfo)
-            });
-        }
-
-        // these invoke wasmtime_call_trampoline from action.rs
-        {
-            println!("calling read...");
-            let result = invoke_export(&mut store, instance, "read").expect("read succeeded");
-            assert_eq!(123, result);
-        }
-
-        {
-            println!("calling read_out_of_bounds...");
-            let trap = invoke_export(&mut store, instance, "read_out_of_bounds")
-                .unwrap_err()
-                .downcast::<Trap>()?;
-            assert_eq!(trap, Trap::MemoryOutOfBounds);
-        }
-
-        // these invoke wasmtime_call_trampoline from callable.rs
-        {
-            let read_func = instance.get_typed_func::<(), i32>(&mut store, "read")?;
-            println!("calling read...");
-            let result = read_func
-                .call(&mut store, ())
-                .expect("expected function not to trap");
-            assert_eq!(123i32, result);
-        }
-
-        {
-            let read_out_of_bounds_func =
-                instance.get_typed_func::<(), i32>(&mut store, "read_out_of_bounds")?;
-            println!("calling read_out_of_bounds...");
-            let trap = read_out_of_bounds_func
-                .call(&mut store, ())
-                .unwrap_err()
-                .downcast::<Trap>()?;
-            assert_eq!(trap, Trap::MemoryOutOfBounds);
-        }
-        Ok(())
-    }
-
-    #[test]
-    fn test_custom_signal_handler_multiple_instances() -> Result<()> {
-        let engine = Engine::default();
-        let mut store = Store::new(&engine, ());
-        let module = Module::new(&engine, WAT1)?;
-
-        // Set up multiple instances
-
-        let externs = make_externs(&mut store, &module);
-        let instance1 = Instance::new(&mut store, &module, &externs)?;
-        let instance1_handler_triggered = Arc::new(AtomicBool::new(false));
-
-        unsafe {
-            let (base1, length1) = set_up_memory(&mut store, instance1);
-
-            store.set_signal_handler({
-                let instance1_handler_triggered = instance1_handler_triggered.clone();
-                move |_signum, _siginfo, _context| {
-                    // Remove protections so the execution may resume
-                    mprotect(
-                        base1 as *mut libc::c_void,
-                        length1,
-                        MprotectFlags::READ | MprotectFlags::WRITE,
-                    )
-                    .unwrap();
-                    instance1_handler_triggered.store(true, Ordering::SeqCst);
-                    println!(
-                        "Hello from instance1 signal handler! {}",
-                        instance1_handler_triggered.load(Ordering::SeqCst)
-                    );
-                    true
-                }
-            });
-        }
-
-        // Invoke both instances and trigger both signal handlers
-
-        // First instance1
-        {
-            let mut exports1 = instance1.exports(&mut store);
-            assert!(exports1.next().is_some());
-            drop(exports1);
-
-            println!("calling instance1.read...");
-            let result = invoke_export(&mut store, instance1, "read").expect("read succeeded");
-            assert_eq!(123, result);
-            assert_eq!(
-                instance1_handler_triggered.load(Ordering::SeqCst),
-                true,
-                "instance1 signal handler has been triggered"
-            );
-        }
-
-        let externs = make_externs(&mut store, &module);
-        let instance2 =
-            Instance::new(&mut store, &module, &externs).expect("failed to instantiate module");
-        let instance2_handler_triggered = Arc::new(AtomicBool::new(false));
-
-        unsafe {
-            let (base2, length2) = set_up_memory(&mut store, instance2);
-
-            store.set_signal_handler({
-                let instance2_handler_triggered = instance2_handler_triggered.clone();
-                move |_signum, _siginfo, _context| {
-                    // Remove protections so the execution may resume
-                    mprotect(
-                        base2 as *mut libc::c_void,
-                        length2,
-                        MprotectFlags::READ | MprotectFlags::WRITE,
-                    )
-                    .unwrap();
-                    instance2_handler_triggered.store(true, Ordering::SeqCst);
-                    println!(
-                        "Hello from instance2 signal handler! {}",
-                        instance2_handler_triggered.load(Ordering::SeqCst)
-                    );
-                    true
-                }
-            });
-        }
-
-        // And then instance2
-        {
-            let mut exports2 = instance2.exports(&mut store);
-            assert!(exports2.next().is_some());
-            drop(exports2);
-
-            println!("calling instance2.read...");
-            let result = invoke_export(&mut store, instance2, "read").expect("read succeeded");
-            assert_eq!(123, result);
-            assert_eq!(
-                instance2_handler_triggered.load(Ordering::SeqCst),
-                true,
-                "instance1 signal handler has been triggered"
-            );
-        }
-        Ok(())
-    }
-
-    #[test]
-    fn test_custom_signal_handler_instance_calling_another_instance() -> Result<()> {
-        let engine = Engine::default();
-        let mut store = Store::new(&engine, ());
-
-        // instance1 which defines 'read'
-        let module1 = Module::new(&engine, WAT1)?;
-        let externs = make_externs(&mut store, &module1);
-        let instance1 = Instance::new(&mut store, &module1, &externs)?;
-        let (base1, length1) = set_up_memory(&mut store, instance1);
-        unsafe {
-            store.set_signal_handler(move |signum, siginfo, _| {
-                println!("instance1");
-                handle_sigsegv(base1, length1, signum, siginfo)
-            });
-        }
-
-        let mut instance1_exports = instance1.exports(&mut store);
-        let instance1_read = instance1_exports.next().unwrap().clone().into_extern();
-        drop(instance1_exports);
-
-        // instance2 which calls 'instance1.read'
-        let module2 = Module::new(&engine, WAT2)?;
-        let instance2 = Instance::new(&mut store, &module2, &[instance1_read])?;
-        // since 'instance2.run' calls 'instance1.read' we need to set up the signal handler to handle
-        // SIGSEGV originating from within the memory of instance1
-        unsafe {
-            store.set_signal_handler(move |signum, siginfo, _| {
-                handle_sigsegv(base1, length1, signum, siginfo)
-            });
-        }
-
-        println!("calling instance2.run");
-        let result = invoke_export(&mut store, instance2, "run")?;
-        assert_eq!(123, result);
-        Ok(())
-    }
-}
diff --git a/tests/all/debug/lldb.rs b/tests/all/debug/lldb.rs
index 14c093b31917..3e0659931d35 100644
--- a/tests/all/debug/lldb.rs
+++ b/tests/all/debug/lldb.rs
@@ -34,14 +34,18 @@ fn lldb_with_script(args: &[&str], script: &str) -> Result<String> {
     cmd.args(args);
 
     let output = cmd.output().expect("success");
+    let stdout = String::from_utf8(output.stdout)?;
+    let stderr = String::from_utf8(output.stderr)?;
     if !output.status.success() {
         bail!(
-            "failed to execute {:?}: {}",
-            cmd,
-            String::from_utf8_lossy(&output.stderr),
+            "failed to execute {cmd:?}:\n\
+            --- stderr ---\n\
+            {stderr}\n\
+            --- stdout ---\n\
+            {stdout}",
         );
     }
-    Ok(String::from_utf8(output.stdout)?)
+    Ok(stdout)
 }
 
 fn check_lldb_output(output: &str, directives: &str) -> Result<()> {
@@ -139,6 +143,47 @@ check: exited with status
     Ok(())
 }
 
+#[test]
+#[ignore]
+#[cfg(all(
+    any(target_os = "linux", target_os = "macos"),
+    target_pointer_width = "64"
+))]
+pub fn test_debug_split_dwarf4_lldb() -> Result<()> {
+    let output = lldb_with_script(
+        &[
+            "-Ccache=n",
+            "-Ddebug-info",
+            "--invoke",
+            "fib",
+            "tests/all/debug/testsuite/fib-wasm-split4.wasm",
+            "3",
+        ],
+        r#"b fib
+r
+fr v
+c"#,
+    )?;
+
+    check_lldb_output(
+        &output,
+        r#"
+check: Breakpoint 1: no locations (pending)
+check: Unable to resolve breakpoint to any actual locations.
+check: 1 location added to breakpoint 1
+check: stop reason = breakpoint 1.1
+check: frame #0
+sameln: JIT
+sameln: fib(n=3)
+check: n = 3
+check: a = 0
+check: resuming
+check: exited with status
+"#,
+    )?;
+    Ok(())
+}
+
 #[test]
 #[ignore]
 #[cfg(all(
@@ -166,7 +211,7 @@ check: Breakpoint 1: no locations (pending)
 check: stop reason = breakpoint 1.1
 check: frame #0
 sameln: norm(n=(__ptr =
-check: = 27
+check: 27
 check: resuming
 "#,
     )?;
@@ -247,3 +292,171 @@ check: exited with status
     )?;
     Ok(())
 }
+
+/* C program used for this test, dwarf_fission.c, compiled with `emcc dwarf_fission.c -o dwarf_fission.wasm -gsplit-dwarf -gdwarf-5 -gpubnames -sWASM_BIGINT`:
+#include <stdio.h>
+
+int main()
+{
+    int i = 1;
+    i++;
+    return i - 2;
+}
+ */
+#[test]
+#[ignore]
+#[cfg(all(
+    any(target_os = "linux", target_os = "macos"),
+    target_pointer_width = "64"
+))]
+pub fn test_debug_dwarf5_fission_lldb() -> Result<()> {
+    let output = lldb_with_script(
+        &[
+            "-Ccache=n",
+            "-Ddebug-info",
+            "tests/all/debug/testsuite/dwarf_fission.wasm",
+        ],
+        r#"breakpoint set --file dwarf_fission.c --line 6
+r
+fr v
+s
+fr v
+c"#,
+    )?;
+
+    check_lldb_output(
+        &output,
+        r#"
+check: Breakpoint 1: no locations (pending)
+check: Unable to resolve breakpoint to any actual locations.
+check: 1 location added to breakpoint 1
+check: stop reason = breakpoint 1.1
+check: i = 1
+check: stop reason = step in
+check: i = 2
+check: resuming
+check: exited with status = 0
+"#,
+    )?;
+    Ok(())
+}
+
+#[cfg(all(
+    any(target_os = "linux", target_os = "macos"),
+    target_pointer_width = "64"
+))]
+mod test_programs {
+    use super::{check_lldb_output, lldb_with_script};
+    use anyhow::Result;
+    use test_programs_artifacts::*;
+
+    macro_rules! assert_test_exists {
+        ($name:ident) => {
+            #[allow(unused_imports)]
+            use self::$name as _;
+        };
+    }
+    foreach_dwarf!(assert_test_exists);
+
+    fn test_dwarf_simple(wasm: &str, extra_args: &[&str]) -> Result<()> {
+        println!("testing {wasm:?}");
+        let mut args = vec!["-Ccache=n", "-Oopt-level=0", "-Ddebug-info"];
+        args.extend(extra_args);
+        args.push(wasm);
+        let output = lldb_with_script(
+            &args,
+            r#"
+breakpoint set --file dwarf_simple.rs --line 3
+breakpoint set --file dwarf_simple.rs --line 5
+r
+fr v
+c
+fr v
+c"#,
+        )?;
+
+        check_lldb_output(
+            &output,
+            r#"
+check: Breakpoint 1: no locations (pending)
+check: Unable to resolve breakpoint to any actual locations.
+check: 1 location added to breakpoint 1
+check: stop reason = breakpoint 1.1
+check: dwarf_simple.rs:3
+check: a = 100
+check: dwarf_simple.rs:5
+check: a = 110
+check: b = 117
+check: resuming
+check: exited with status = 0
+"#,
+        )?;
+        Ok(())
+    }
+
+    #[test]
+    #[ignore]
+    fn dwarf_simple() -> Result<()> {
+        for wasm in [DWARF_SIMPLE, DWARF_SIMPLE_COMPONENT] {
+            test_dwarf_simple(wasm, &[])?;
+        }
+        Ok(())
+    }
+
+    #[test]
+    #[ignore]
+    fn dwarf_imported_memory() -> Result<()> {
+        test_dwarf_simple(
+            DWARF_IMPORTED_MEMORY,
+            &["--preload=env=./tests/all/debug/satisfy_memory_import.wat"],
+        )
+    }
+
+    #[test]
+    #[ignore]
+    fn dwarf_shared_memory() -> Result<()> {
+        test_dwarf_simple(DWARF_SHARED_MEMORY, &[])
+    }
+
+    #[test]
+    #[ignore]
+    fn dwarf_multiple_codegen_units() -> Result<()> {
+        for wasm in [
+            DWARF_MULTIPLE_CODEGEN_UNITS,
+            DWARF_MULTIPLE_CODEGEN_UNITS_COMPONENT,
+        ] {
+            println!("testing {wasm:?}");
+            let output = lldb_with_script(
+                &["-Ccache=n", "-Oopt-level=0", "-Ddebug-info", wasm],
+                r#"
+breakpoint set --file dwarf_multiple_codegen_units.rs --line 3
+breakpoint set --file dwarf_multiple_codegen_units.rs --line 10
+r
+fr v
+c
+fr v
+breakpoint delete 2
+finish
+c"#,
+            )?;
+
+            check_lldb_output(
+                &output,
+                r#"
+check: Breakpoint 1: no locations (pending)
+check: Breakpoint 2: no locations (pending)
+check: stop reason = breakpoint 1.1
+check: foo::bar(a)
+check: a = 3
+check: sum += i
+check: x = 3
+check: sum = 0
+check: 1 breakpoints deleted
+check: Return value: $(=.*) 3
+check: exited with status = 0
+"#,
+            )?;
+        }
+        Ok(())
+    }
+}
diff --git a/tests/all/debug/obj.rs b/tests/all/debug/obj.rs
index d83edad19bfa..4395da771b9d 100644
--- a/tests/all/debug/obj.rs
+++ b/tests/all/debug/obj.rs
@@ -3,10 +3,11 @@ use std::fs::File;
 use std::io::Write;
 use std::path::Path;
 use target_lexicon::Triple;
-use wasmtime::{Config, Engine, Module};
+use wasmtime::{CodeBuilder, Config, Engine};
 
 pub fn compile_cranelift(
     wasm: &[u8],
+    path: Option<&Path>,
     target: Option<Triple>,
     output: impl AsRef<Path>,
 ) -> Result<()> {
@@ -16,7 +17,9 @@ pub fn compile_cranelift(
         config.target(&target.to_string())?;
     }
     let engine = Engine::new(&config)?;
-    let module = Module::new(&engine, wasm)?;
+    let module = CodeBuilder::new(&engine)
+        .wasm_binary_or_text(wasm, path)?
+        .compile_module()?;
     let bytes = module.serialize()?;
 
     let mut file = File::create(output).context("failed to create object file")?;
diff --git a/tests/all/debug/satisfy_memory_import.wat b/tests/all/debug/satisfy_memory_import.wat
new file mode 100644
index 000000000000..ea6f28c5eaf5
--- /dev/null
+++ b/tests/all/debug/satisfy_memory_import.wat
@@ -0,0 +1,3 @@
+(module
+  (memory (export "memory") 100)
+)
diff --git a/tests/all/debug/simulate.rs b/tests/all/debug/simulate.rs
index 4ed9f9847c20..10571e35fa6e 100644
--- a/tests/all/debug/simulate.rs
+++ b/tests/all/debug/simulate.rs
@@ -10,7 +10,7 @@ fn check_wat(wat: &str) -> Result<()> {
     let wasm = parse_str(wat)?;
     let obj_file = NamedTempFile::new()?;
     let obj_path = obj_file.path().to_str().unwrap();
-    compile_cranelift(&wasm, None, obj_path)?;
+    compile_cranelift(&wasm, None, None, obj_path)?;
     let dump = get_dwarfdump(obj_path, DwarfDumpSection::DebugInfo)?;
     let mut builder = CheckerBuilder::new();
     builder
diff --git a/tests/all/debug/testsuite/dead_code.c b/tests/all/debug/testsuite/dead_code.c
index 61067a78daa8..ea65e8efbc44 100644
--- a/tests/all/debug/testsuite/dead_code.c
+++ b/tests/all/debug/testsuite/dead_code.c
@@ -1,5 +1,4 @@
-int bar(int a)
-{
+int bar(int a) {
   int b[50];
   b[0] = a;
   b[29] = a;
@@ -8,12 +7,6 @@ int bar(int a)
 
 int baz(int a);
 
-__attribute__((export_name("foo"))) int foo()
-{
-  return baz(10);
-}
+__attribute__((export_name("foo"))) int foo() { return baz(10); }
 
-__attribute__((noinline)) int baz(int a)
-{
-  return a + 5;
-}
+__attribute__((noinline)) int baz(int a) { return a + 5; }
diff --git a/tests/all/debug/testsuite/dwarf_fission.c b/tests/all/debug/testsuite/dwarf_fission.c
new file mode 100644
index 000000000000..4dc174f90155
--- /dev/null
+++ b/tests/all/debug/testsuite/dwarf_fission.c
@@ -0,0 +1,7 @@
+#include <stdio.h>
+
+int main() {
+  int i = 1;
+  i++;
+  return i - 2;
+}
diff --git a/tests/all/debug/testsuite/dwarf_fission.dwp b/tests/all/debug/testsuite/dwarf_fission.dwp
new file mode 100644
index 000000000000..e155c21fddb7
Binary files /dev/null and b/tests/all/debug/testsuite/dwarf_fission.dwp differ
diff --git a/tests/all/debug/testsuite/dwarf_fission.wasm b/tests/all/debug/testsuite/dwarf_fission.wasm
new file mode 100644
index 000000000000..ed7a49a83b02
Binary files /dev/null and b/tests/all/debug/testsuite/dwarf_fission.wasm differ
diff --git a/tests/all/debug/testsuite/fib-wasm-split4.dwp b/tests/all/debug/testsuite/fib-wasm-split4.dwp
new file mode 100644
index 000000000000..03e198faa042
Binary files /dev/null and b/tests/all/debug/testsuite/fib-wasm-split4.dwp differ
diff --git a/tests/all/debug/testsuite/fib-wasm-split4.wasm b/tests/all/debug/testsuite/fib-wasm-split4.wasm
new file mode 100755
index 000000000000..819d2c3a35c3
Binary files /dev/null and b/tests/all/debug/testsuite/fib-wasm-split4.wasm differ
diff --git a/tests/all/debug/testsuite/fib-wasm.c b/tests/all/debug/testsuite/fib-wasm.c
index 3170af3e3101..16bad0ebc766 100644
--- a/tests/all/debug/testsuite/fib-wasm.c
+++ b/tests/all/debug/testsuite/fib-wasm.c
@@ -14,3 +14,10 @@ int fib(int n) {
   }
   return b;
 }
+
+// Placed at the end so that line numbers are stable.
+//
+//   clang --target=wasm32 fib-wasm.c -o fib-wasm-split4.wasm \
+//     -gdwarf-4 -gsplit-dwarf \
+//     -Wl,--no-entry,--export=fib -nostdlib -fdebug-prefix-map=$PWD=.
+//   llvm-dwp -e fib-wasm-split4.wasm -o fib-wasm-split4.dwp
diff --git a/tests/all/debug/testsuite/reverse-str.c b/tests/all/debug/testsuite/reverse-str.c
index 0cad1b2f0fe2..d7585a87fbcd 100644
--- a/tests/all/debug/testsuite/reverse-str.c
+++ b/tests/all/debug/testsuite/reverse-str.c
@@ -3,19 +3,18 @@
 //     -O0 -nostdlib -fdebug-prefix-map=$PWD=.
 #include <stdlib.h>
 
-void reverse(char *s, size_t len)
-{
-    if (!len) return;
-    size_t i = 0, j = len - 1;
-    while (i < j) {
-        char t = s[i];
-        s[i++] = s[j];
-        s[j--] = t;
-    }
+void reverse(char *s, size_t len) {
+  if (!len)
+    return;
+  size_t i = 0, j = len - 1;
+  while (i < j) {
+    char t = s[i];
+    s[i++] = s[j];
+    s[j--] = t;
+  }
 }
 
-void _start()
-{
-    char hello[] = "Hello, world.";
-    reverse(hello, 13);
+void _start() {
+  char hello[] = "Hello, world.";
+  reverse(hello, 13);
 }
diff --git a/tests/all/debug/testsuite/spilled_frame_base.c b/tests/all/debug/testsuite/spilled_frame_base.c
index d0733681201a..8948ac6cf2cc 100644
--- a/tests/all/debug/testsuite/spilled_frame_base.c
+++ b/tests/all/debug/testsuite/spilled_frame_base.c
@@ -1,16 +1,21 @@
-// Originally built using WASI SDK 20.0, "clang spilled_frame_base.c -o spilled_frame_base.wasm -g -target wasm32-wasi"
-void func_11(int x, int y, int z, int a, int b, int c, int d, int e, int f, int g, int h) { }
-void func_12(int x, int y, int z, int a, int b, int c, int d, int e, int f, int g, int h, int i) { }
-void func_13(int x, int y, int z, int a, int b, int c, int d, int e, int f, int g, int h, int i, int j) { }
-void func_14(int x, int y, int z, int a, int b, int c, int d, int e, int f, int g, int h, int i, int j, int k) { }
+// Originally built using WASI SDK 20.0, "clang spilled_frame_base.c -o
+// spilled_frame_base.wasm -g -target wasm32-wasi"
+void func_11(int x, int y, int z, int a, int b, int c, int d, int e, int f,
+             int g, int h) {}
+void func_12(int x, int y, int z, int a, int b, int c, int d, int e, int f,
+             int g, int h, int i) {}
+void func_13(int x, int y, int z, int a, int b, int c, int d, int e, int f,
+             int g, int h, int i, int j) {}
+void func_14(int x, int y, int z, int a, int b, int c, int d, int e, int f,
+             int g, int h, int i, int j, int k) {}
 
 int main() {
-    int i = 1;
+  int i = 1;
 
-    func_11(55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65);
-    func_12(66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77);
-    func_13(78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90);
-    func_14(91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104);
+  func_11(55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65);
+  func_12(66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77);
+  func_13(78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90);
+  func_14(91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104);
 
-    return i + i;
+  return i + i;
 }
diff --git a/tests/all/debug/translate.rs b/tests/all/debug/translate.rs
index 4e72dcd39f0c..15c314ea2f31 100644
--- a/tests/all/debug/translate.rs
+++ b/tests/all/debug/translate.rs
@@ -10,7 +10,7 @@ fn check_wasm(wasm_path: &str, directives: &str) -> Result<()> {
     let wasm = read(wasm_path)?;
     let obj_file = NamedTempFile::new()?;
     let obj_path = obj_file.path().to_str().unwrap();
-    compile_cranelift(&wasm, None, obj_path)?;
+    compile_cranelift(&wasm, Some(wasm_path.as_ref()), None, obj_path)?;
     let dump = get_dwarfdump(obj_path, DwarfDumpSection::DebugInfo)?;
     let mut builder = CheckerBuilder::new();
     builder
@@ -29,7 +29,7 @@ fn check_line_program(wasm_path: &str, directives: &str) -> Result<()> {
     let wasm = read(wasm_path)?;
     let obj_file = NamedTempFile::new()?;
     let obj_path = obj_file.path().to_str().unwrap();
-    compile_cranelift(&wasm, None, obj_path)?;
+    compile_cranelift(&wasm, Some(wasm_path.as_ref()), None, obj_path)?;
     let dump = get_dwarfdump(obj_path, DwarfDumpSection::DebugLine)?;
     let mut builder = CheckerBuilder::new();
     builder
@@ -132,3 +132,80 @@ check:        DW_AT_decl_line	(10)
     "##,
     )
 }
+
+#[test]
+#[ignore]
+#[cfg(all(
+    any(target_os = "linux", target_os = "macos"),
+    target_pointer_width = "64"
+))]
+fn test_debug_split_dwarf4_translate() -> Result<()> {
+    check_wasm(
+        "tests/all/debug/testsuite/fib-wasm-split4.wasm",
+        r##"
+check: DW_TAG_compile_unit
+# We have "fib" function
+check: DW_TAG_subprogram
+check:      DW_AT_name	("fib")
+# Accepts one parameter
+check:      DW_TAG_formal_parameter
+check:        DW_AT_name	("n")
+check:        DW_AT_decl_line	(8)
+# Has four locals: t, a, b, i
+check:      DW_TAG_variable
+check:        DW_AT_name	("t")
+check:        DW_AT_decl_line	(9)
+check:      DW_TAG_variable
+check:        DW_AT_name	("a")
+check:      DW_TAG_variable
+check:        DW_AT_name	("b")
+check:      DW_TAG_variable
+check:        DW_AT_name	("i")
+check:        DW_AT_decl_line	(10)
+    "##,
+    )
+}
+
+#[test]
+#[ignore]
+#[cfg(all(
+    any(target_os = "linux", target_os = "macos"),
+    target_pointer_width = "64"
+))]
+fn test_debug_dwarf_translate_generated() -> Result<()> {
+    check_wasm(
+        "tests/all/debug/testsuite/fraction-norm.wasm",
+        r##"
+check: DW_TAG_compile_unit
+check: DW_TAG_compile_unit
+check:   DW_AT_producer	("wasmtime")
+check:   DW_AT_name	("<gen-$(=\d+)>.wasm")
+check:   DW_AT_comp_dir	("/<wasm-module>")
+check:   DW_TAG_subprogram
+check:     DW_AT_name	("__wasm_call_ctors")
+check:     DW_AT_decl_file	("/<wasm-module>/<gen-$(=\d+)>.wasm")
+check:     DW_AT_decl_line	(124)
+    "##,
+    )
+}
+
+#[test]
+#[ignore]
+#[cfg(all(
+    any(target_os = "linux", target_os = "macos"),
+    target_pointer_width = "64"
+))]
+fn test_debug_dwarf_translate_fission() -> Result<()> {
+    check_wasm(
+        "tests/all/debug/testsuite/dwarf_fission.wasm",
+        r##"
+check: DW_TAG_compile_unit
+check:   DW_AT_producer	("clang version 19.0.0git (https:/github.com/llvm/llvm-project ccdebbae4d77d3efc236af92c22941de5d437e01)")
+check:   DW_AT_language	(DW_LANG_C11)
+check:   DW_AT_name	("dwarf_fission.c")
+check:   DW_AT_ranges	(0x00000000
+check:   DW_AT_stmt_list	(0x00000000)
+check:   DW_AT_comp_dir	("C:\\tmp\\dwarfc")
+    "##,
+    )
+}
diff --git a/tests/all/defaults.rs b/tests/all/defaults.rs
new file mode 100644
index 000000000000..670758078f0b
--- /dev/null
+++ b/tests/all/defaults.rs
@@ -0,0 +1,70 @@
+use wasmtime::*;
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn test_tail_call_default() -> Result<()> {
+    for (line, expected, cfg) in [
+        (
+            line!(),
+            true,
+            Config::new()
+                .strategy(Strategy::Cranelift)
+                .target("x86_64")?,
+        ),
+        (
+            line!(),
+            true,
+            Config::new()
+                .strategy(Strategy::Cranelift)
+                .target("aarch64")?,
+        ),
+        (
+            line!(),
+            true,
+            Config::new()
+                .strategy(Strategy::Cranelift)
+                .target("riscv64")?,
+        ),
+        (
+            line!(),
+            true,
+            Config::new()
+                .strategy(Strategy::Cranelift)
+                .target("s390x")?,
+        ),
+        (
+            line!(),
+            false,
+            Config::new().strategy(Strategy::Winch).target("x86_64")?,
+        ),
+        (
+            line!(),
+            false,
+            Config::new().strategy(Strategy::Winch).target("aarch64")?,
+        ),
+        (
+            line!(),
+            false,
+            Config::new()
+                .strategy(Strategy::Cranelift)
+                .wasm_tail_call(false)
+                .target("x86_64")?,
+        ),
+    ] {
+        let engine = Engine::new(cfg)?;
+
+        let wat = r#"
+            (module $from_name_section
+                (func (export "run") (return_call 0))
+            )
+        "#;
+
+        let result = engine.precompile_module(wat.as_bytes()).map(|_| ());
+
+        eprintln!("for config on line {line}, got: {result:?}");
+
+        assert_eq!(expected, result.is_ok());
+    }
+
+    Ok(())
+}
diff --git a/tests/all/epoch_interruption.rs b/tests/all/epoch_interruption.rs
index 51d4b831c166..e59d435b560c 100644
--- a/tests/all/epoch_interruption.rs
+++ b/tests/all/epoch_interruption.rs
@@ -1,7 +1,7 @@
 #![cfg(not(miri))]
 
 use crate::async_functions::{CountPending, PollOnce};
-use anyhow::{anyhow, Result};
+use anyhow::anyhow;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 use wasmtime::*;
@@ -21,7 +21,7 @@ fn make_env<T>(engine: &Engine) -> Linker<T> {
         .func_new(
             "",
             "bump_epoch",
-            FuncType::new(None, None),
+            FuncType::new(&engine, None, None),
             move |_caller, _params, _results| {
                 engine.increment_epoch();
                 Ok(())
@@ -418,7 +418,7 @@ async fn drop_future_on_epoch_yield() {
         .func_new(
             "",
             "oops",
-            FuncType::new(None, None),
+            FuncType::new(&engine, None, None),
             move |_caller, _params, _results| {
                 panic!("Should not have reached this point!");
             },
@@ -428,7 +428,7 @@ async fn drop_future_on_epoch_yield() {
         .func_new(
             "",
             "im_alive",
-            FuncType::new(None, None),
+            FuncType::new(&engine, None, None),
             move |_caller, _params, _results| {
                 alive_flag_clone.store(true, Ordering::Release);
                 Ok(())
diff --git a/tests/all/externals.rs b/tests/all/externals.rs
index eb256d3ba28d..1b36359c1e5b 100644
--- a/tests/all/externals.rs
+++ b/tests/all/externals.rs
@@ -17,50 +17,38 @@ fn bad_globals() {
     assert!(g.set(&mut store, Val::I64(0)).is_err());
 }
 
-#[test]
-#[should_panic]
-fn bad_tables_i32() {
-    // NOTE(dhil): The below test does not make sense after the
-    // implementation of the function-references proposal, since the
-    // type component of a TableType is now a reference type (I32 is
-    // not a reference type constructor).
-
-    // i32 not supported yet
-    TableType::new(ValType::I32, 0, Some(1));
-}
-
 #[test]
 fn bad_tables() {
     let mut store = Store::<()>::default();
 
     // mismatched initializer
-    let ty = TableType::new(ValType::FuncRef, 0, Some(1));
-    assert!(Table::new(&mut store, ty.clone(), Val::I32(0)).is_err());
+    let ty = TableType::new(RefType::FUNCREF, 0, Some(1));
+    assert!(Table::new(&mut store, ty.clone(), Ref::Extern(None)).is_err());
 
     // get out of bounds
-    let ty = TableType::new(ValType::FuncRef, 0, Some(1));
-    let t = Table::new(&mut store, ty.clone(), Val::FuncRef(None)).unwrap();
+    let ty = TableType::new(RefType::FUNCREF, 0, Some(1));
+    let t = Table::new(&mut store, ty.clone(), Ref::Func(None)).unwrap();
     assert!(t.get(&mut store, 0).is_none());
     assert!(t.get(&mut store, u32::max_value()).is_none());
 
     // set out of bounds or wrong type
-    let ty = TableType::new(ValType::FuncRef, 1, Some(1));
-    let t = Table::new(&mut store, ty.clone(), Val::FuncRef(None)).unwrap();
-    assert!(t.set(&mut store, 0, Val::I32(0)).is_err());
-    assert!(t.set(&mut store, 0, Val::FuncRef(None)).is_ok());
-    assert!(t.set(&mut store, 1, Val::FuncRef(None)).is_err());
+    let ty = TableType::new(RefType::FUNCREF, 1, Some(1));
+    let t = Table::new(&mut store, ty.clone(), Ref::Func(None)).unwrap();
+    assert!(t.set(&mut store, 0, Ref::Extern(None)).is_err());
+    assert!(t.set(&mut store, 0, Ref::Func(None)).is_ok());
+    assert!(t.set(&mut store, 1, Ref::Func(None)).is_err());
 
     // grow beyond max
-    let ty = TableType::new(ValType::FuncRef, 1, Some(1));
-    let t = Table::new(&mut store, ty.clone(), Val::FuncRef(None)).unwrap();
-    assert!(t.grow(&mut store, 0, Val::FuncRef(None)).is_ok());
-    assert!(t.grow(&mut store, 1, Val::FuncRef(None)).is_err());
+    let ty = TableType::new(RefType::FUNCREF, 1, Some(1));
+    let t = Table::new(&mut store, ty.clone(), Ref::Func(None)).unwrap();
+    assert!(t.grow(&mut store, 0, Ref::Func(None)).is_ok());
+    assert!(t.grow(&mut store, 1, Ref::Func(None)).is_err());
     assert_eq!(t.size(&store), 1);
 
     // grow wrong type
-    let ty = TableType::new(ValType::FuncRef, 1, Some(2));
-    let t = Table::new(&mut store, ty.clone(), Val::FuncRef(None)).unwrap();
-    assert!(t.grow(&mut store, 1, Val::I32(0)).is_err());
+    let ty = TableType::new(RefType::FUNCREF, 1, Some(2));
+    let t = Table::new(&mut store, ty.clone(), Ref::Func(None)).unwrap();
+    assert!(t.grow(&mut store, 1, Ref::Extern(None)).is_err());
     assert_eq!(t.size(&store), 1);
 }
 
@@ -73,15 +61,15 @@ fn cross_store() -> anyhow::Result<()> {
     let mut store1 = Store::new(&engine, ());
     let mut store2 = Store::new(&engine, ());
 
-    // ============ Cross-store instantiation ==============
+    eprintln!("============ Cross-store instantiation ==============");
 
     let func = Func::wrap(&mut store2, || {});
     let ty = GlobalType::new(ValType::I32, Mutability::Const);
     let global = Global::new(&mut store2, ty, Val::I32(0))?;
     let ty = MemoryType::new(1, None);
     let memory = Memory::new(&mut store2, ty)?;
-    let ty = TableType::new(ValType::FuncRef, 1, None);
-    let table = Table::new(&mut store2, ty, Val::FuncRef(None))?;
+    let ty = TableType::new(RefType::FUNCREF, 1, None);
+    let table = Table::new(&mut store2, ty, Ref::Func(None))?;
 
     let need_func = Module::new(&engine, r#"(module (import "" "" (func)))"#)?;
     assert!(Instance::new(&mut store1, &need_func, &[func.into()]).is_err());
@@ -95,27 +83,29 @@ fn cross_store() -> anyhow::Result<()> {
     let need_memory = Module::new(&engine, r#"(module (import "" "" (memory 1)))"#)?;
     assert!(Instance::new(&mut store1, &need_memory, &[memory.into()]).is_err());
 
-    // ============ Cross-store globals ==============
+    eprintln!("============ Cross-store globals ==============");
 
     let store1val = Val::FuncRef(Some(Func::wrap(&mut store1, || {})));
+    let store1ref = store1val.ref_().unwrap();
     let store2val = Val::FuncRef(Some(Func::wrap(&mut store2, || {})));
+    let store2ref = store2val.ref_().unwrap();
 
-    let ty = GlobalType::new(ValType::FuncRef, Mutability::Var);
-    assert!(Global::new(&mut store2, ty.clone(), store1val.clone()).is_err());
-    if let Ok(g) = Global::new(&mut store2, ty.clone(), store2val.clone()) {
-        assert!(g.set(&mut store2, store1val.clone()).is_err());
+    let ty = GlobalType::new(ValType::FUNCREF, Mutability::Var);
+    assert!(Global::new(&mut store2, ty.clone(), store1val).is_err());
+    if let Ok(g) = Global::new(&mut store2, ty.clone(), store2val) {
+        assert!(g.set(&mut store2, store1val).is_err());
     }
 
-    // ============ Cross-store tables ==============
+    eprintln!("============ Cross-store tables ==============");
 
-    let ty = TableType::new(ValType::FuncRef, 1, None);
-    assert!(Table::new(&mut store2, ty.clone(), store1val.clone()).is_err());
-    let t1 = Table::new(&mut store2, ty.clone(), store2val.clone())?;
-    assert!(t1.set(&mut store2, 0, store1val.clone()).is_err());
-    assert!(t1.grow(&mut store2, 0, store1val.clone()).is_err());
-    assert!(t1.fill(&mut store2, 0, store1val.clone(), 1).is_err());
+    let ty = TableType::new(RefType::FUNCREF, 1, None);
+    assert!(Table::new(&mut store2, ty.clone(), store1ref.clone()).is_err());
+    let t1 = Table::new(&mut store2, ty.clone(), store2ref.clone())?;
+    assert!(t1.set(&mut store2, 0, store1ref.clone()).is_err());
+    assert!(t1.grow(&mut store2, 0, store1ref.clone()).is_err());
+    assert!(t1.fill(&mut store2, 0, store1ref.clone(), 1).is_err());
 
-    // ============ Cross-store funcs ==============
+    eprintln!("============ Cross-store funcs ==============");
 
     let module = Module::new(&engine, r#"(module (func (export "f") (param funcref)))"#)?;
     let s1_inst = Instance::new(&mut store1, &module, &[])?;
@@ -130,16 +120,16 @@ fn cross_store() -> anyhow::Result<()> {
         .call(&mut store2, &[Val::FuncRef(None)], &mut [])
         .is_ok());
     assert!(s1_f
-        .call(&mut store1, &[Some(s1_f.clone()).into()], &mut [])
+        .call(&mut store1, &[Some(s1_f).into()], &mut [])
         .is_ok());
     assert!(s1_f
-        .call(&mut store1, &[Some(s2_f.clone()).into()], &mut [])
+        .call(&mut store1, &[Some(s2_f).into()], &mut [])
         .is_err());
     assert!(s2_f
-        .call(&mut store2, &[Some(s1_f.clone()).into()], &mut [])
+        .call(&mut store2, &[Some(s1_f).into()], &mut [])
         .is_err());
     assert!(s2_f
-        .call(&mut store2, &[Some(s2_f.clone()).into()], &mut [])
+        .call(&mut store2, &[Some(s2_f).into()], &mut [])
         .is_ok());
 
     let s1_f_t = s1_f.typed::<Option<Func>, ()>(&store1)?;
@@ -147,10 +137,10 @@ fn cross_store() -> anyhow::Result<()> {
 
     assert!(s1_f_t.call(&mut store1, None).is_ok());
     assert!(s2_f_t.call(&mut store2, None).is_ok());
-    assert!(s1_f_t.call(&mut store1, Some(s1_f.clone())).is_ok());
-    assert!(s1_f_t.call(&mut store1, Some(s2_f.clone())).is_err());
-    assert!(s2_f_t.call(&mut store2, Some(s1_f.clone())).is_err());
-    assert!(s2_f_t.call(&mut store2, Some(s2_f.clone())).is_ok());
+    assert!(s1_f_t.call(&mut store1, Some(s1_f)).is_ok());
+    assert!(s1_f_t.call(&mut store1, Some(s2_f)).is_err());
+    assert!(s2_f_t.call(&mut store2, Some(s1_f)).is_err());
+    assert!(s2_f_t.call(&mut store2, Some(s2_f)).is_ok());
 
     Ok(())
 }
@@ -166,29 +156,28 @@ fn get_set_externref_globals_via_api() -> anyhow::Result<()> {
 
     let global = Global::new(
         &mut store,
-        GlobalType::new(ValType::ExternRef, Mutability::Var),
+        GlobalType::new(ValType::EXTERNREF, Mutability::Var),
         Val::ExternRef(None),
     )?;
     assert!(global.get(&mut store).unwrap_externref().is_none());
 
-    global.set(
-        &mut store,
-        Val::ExternRef(Some(ExternRef::new("hello".to_string()))),
-    )?;
-    let r = global.get(&mut store).unwrap_externref().unwrap();
-    assert!(r.data().is::<String>());
-    assert_eq!(r.data().downcast_ref::<String>().unwrap(), "hello");
+    let hello = ExternRef::new(&mut store, "hello".to_string())?;
+    global.set(&mut store, hello.into())?;
+    let r = global.get(&mut store).unwrap_externref().cloned().unwrap();
+    assert!(r.data(&store)?.is::<String>());
+    assert_eq!(r.data(&store)?.downcast_ref::<String>().unwrap(), "hello");
 
     // Initialize with a non-null externref.
 
+    let externref = ExternRef::new(&mut store, 42_i32)?;
     let global = Global::new(
         &mut store,
-        GlobalType::new(ValType::ExternRef, Mutability::Const),
-        Val::ExternRef(Some(ExternRef::new(42_i32))),
+        GlobalType::new(ValType::EXTERNREF, Mutability::Const),
+        externref.into(),
     )?;
-    let r = global.get(&mut store).unwrap_externref().unwrap();
-    assert!(r.data().is::<i32>());
-    assert_eq!(r.data().downcast_ref::<i32>().copied().unwrap(), 42);
+    let r = global.get(&mut store).unwrap_externref().cloned().unwrap();
+    assert!(r.data(&store)?.is::<i32>());
+    assert_eq!(r.data(&store)?.downcast_ref::<i32>().copied().unwrap(), 42);
 
     Ok(())
 }
@@ -206,24 +195,24 @@ fn get_set_funcref_globals_via_api() -> anyhow::Result<()> {
 
     let global = Global::new(
         &mut store,
-        GlobalType::new(ValType::FuncRef, Mutability::Var),
+        GlobalType::new(ValType::FUNCREF, Mutability::Var),
         Val::FuncRef(None),
     )?;
     assert!(global.get(&mut store).unwrap_funcref().is_none());
 
-    global.set(&mut store, Val::FuncRef(Some(f.clone())))?;
+    global.set(&mut store, Val::FuncRef(Some(f)))?;
     let f2 = global.get(&mut store).unwrap_funcref().cloned().unwrap();
-    assert_eq!(f.ty(&store), f2.ty(&store));
+    assert!(FuncType::eq(&f.ty(&store), &f2.ty(&store)));
 
     // Initialize with a non-null funcref.
 
     let global = Global::new(
         &mut store,
-        GlobalType::new(ValType::FuncRef, Mutability::Var),
-        Val::FuncRef(Some(f.clone())),
+        GlobalType::new(ValType::FUNCREF, Mutability::Var),
+        Val::FuncRef(Some(f)),
     )?;
     let f2 = global.get(&mut store).unwrap_funcref().cloned().unwrap();
-    assert_eq!(f.ty(&store), f2.ty(&store));
+    assert!(FuncType::eq(&f.ty(&store), &f2.ty(&store)));
 
     Ok(())
 }
@@ -235,13 +224,13 @@ fn create_get_set_funcref_tables_via_api() -> anyhow::Result<()> {
     let engine = Engine::new(&cfg)?;
     let mut store = Store::new(&engine, ());
 
-    let table_ty = TableType::new(ValType::FuncRef, 10, None);
-    let init = Val::FuncRef(Some(Func::wrap(&mut store, || {})));
+    let table_ty = TableType::new(RefType::FUNCREF, 10, None);
+    let init = Ref::Func(Some(Func::wrap(&mut store, || {})));
     let table = Table::new(&mut store, table_ty, init)?;
 
-    assert!(table.get(&mut store, 5).unwrap().unwrap_funcref().is_some());
-    table.set(&mut store, 5, Val::FuncRef(None))?;
-    assert!(table.get(&mut store, 5).unwrap().unwrap_funcref().is_none());
+    assert!(table.get(&mut store, 5).unwrap().unwrap_func().is_some());
+    table.set(&mut store, 5, Ref::Func(None))?;
+    assert!(table.get(&mut store, 5).unwrap().unwrap_func().is_none());
 
     Ok(())
 }
@@ -253,21 +242,21 @@ fn fill_funcref_tables_via_api() -> anyhow::Result<()> {
     let engine = Engine::new(&cfg)?;
     let mut store = Store::new(&engine, ());
 
-    let table_ty = TableType::new(ValType::FuncRef, 10, None);
-    let table = Table::new(&mut store, table_ty, Val::FuncRef(None))?;
+    let table_ty = TableType::new(RefType::FUNCREF, 10, None);
+    let table = Table::new(&mut store, table_ty, Ref::Func(None))?;
 
     for i in 0..10 {
-        assert!(table.get(&mut store, i).unwrap().unwrap_funcref().is_none());
+        assert!(table.get(&mut store, i).unwrap().unwrap_func().is_none());
     }
 
-    let fill = Val::FuncRef(Some(Func::wrap(&mut store, || {})));
+    let fill = Ref::Func(Some(Func::wrap(&mut store, || {})));
     table.fill(&mut store, 2, fill, 4)?;
 
     for i in (0..2).chain(7..10) {
-        assert!(table.get(&mut store, i).unwrap().unwrap_funcref().is_none());
+        assert!(table.get(&mut store, i).unwrap().unwrap_func().is_none());
     }
     for i in 2..6 {
-        assert!(table.get(&mut store, i).unwrap().unwrap_funcref().is_some());
+        assert!(table.get(&mut store, i).unwrap().unwrap_func().is_some());
     }
 
     Ok(())
@@ -280,11 +269,11 @@ fn grow_funcref_tables_via_api() -> anyhow::Result<()> {
     let engine = Engine::new(&cfg)?;
     let mut store = Store::new(&engine, ());
 
-    let table_ty = TableType::new(ValType::FuncRef, 10, None);
-    let table = Table::new(&mut store, table_ty, Val::FuncRef(None))?;
+    let table_ty = TableType::new(RefType::FUNCREF, 10, None);
+    let table = Table::new(&mut store, table_ty, Ref::Func(None))?;
 
     assert_eq!(table.size(&store), 10);
-    table.grow(&mut store, 3, Val::FuncRef(None))?;
+    table.grow(&mut store, 3, Ref::Func(None))?;
     assert_eq!(table.size(&store), 13);
 
     Ok(())
@@ -297,30 +286,23 @@ fn create_get_set_externref_tables_via_api() -> anyhow::Result<()> {
     let engine = Engine::new(&cfg)?;
     let mut store = Store::new(&engine, ());
 
-    let table_ty = TableType::new(ValType::ExternRef, 10, None);
-    let table = Table::new(
-        &mut store,
-        table_ty,
-        Val::ExternRef(Some(ExternRef::new(42_usize))),
-    )?;
+    let table_ty = TableType::new(RefType::EXTERNREF, 10, None);
+    let init = ExternRef::new(&mut store, 42_usize)?;
+    let table = Table::new(&mut store, table_ty, init.into())?;
 
     assert_eq!(
         *table
             .get(&mut store, 5)
             .unwrap()
-            .unwrap_externref()
+            .unwrap_extern()
             .unwrap()
-            .data()
+            .data(&store)?
             .downcast_ref::<usize>()
             .unwrap(),
         42
     );
-    table.set(&mut store, 5, Val::ExternRef(None))?;
-    assert!(table
-        .get(&mut store, 5)
-        .unwrap()
-        .unwrap_externref()
-        .is_none());
+    table.set(&mut store, 5, Ref::Extern(None))?;
+    assert!(table.get(&mut store, 5).unwrap().unwrap_extern().is_none());
 
     Ok(())
 }
@@ -332,39 +314,27 @@ fn fill_externref_tables_via_api() -> anyhow::Result<()> {
     let engine = Engine::new(&cfg)?;
     let mut store = Store::new(&engine, ());
 
-    let table_ty = TableType::new(ValType::ExternRef, 10, None);
-    let table = Table::new(&mut store, table_ty, Val::ExternRef(None))?;
+    let table_ty = TableType::new(RefType::EXTERNREF, 10, None);
+    let table = Table::new(&mut store, table_ty, Ref::Extern(None))?;
 
     for i in 0..10 {
-        assert!(table
-            .get(&mut store, i)
-            .unwrap()
-            .unwrap_externref()
-            .is_none());
+        assert!(table.get(&mut store, i).unwrap().unwrap_extern().is_none());
     }
 
-    table.fill(
-        &mut store,
-        2,
-        Val::ExternRef(Some(ExternRef::new(42_usize))),
-        4,
-    )?;
+    let val = ExternRef::new(&mut store, 42_usize)?;
+    table.fill(&mut store, 2, val.into(), 4)?;
 
     for i in (0..2).chain(7..10) {
-        assert!(table
-            .get(&mut store, i)
-            .unwrap()
-            .unwrap_externref()
-            .is_none());
+        assert!(table.get(&mut store, i).unwrap().unwrap_extern().is_none());
     }
     for i in 2..6 {
         assert_eq!(
             *table
                 .get(&mut store, i)
                 .unwrap()
-                .unwrap_externref()
+                .unwrap_extern()
                 .unwrap()
-                .data()
+                .data(&store)?
                 .downcast_ref::<usize>()
                 .unwrap(),
             42
@@ -381,11 +351,11 @@ fn grow_externref_tables_via_api() -> anyhow::Result<()> {
     let engine = Engine::new(&cfg)?;
     let mut store = Store::new(&engine, ());
 
-    let table_ty = TableType::new(ValType::ExternRef, 10, None);
-    let table = Table::new(&mut store, table_ty, Val::ExternRef(None))?;
+    let table_ty = TableType::new(RefType::EXTERNREF, 10, None);
+    let table = Table::new(&mut store, table_ty, Ref::Extern(None))?;
 
     assert_eq!(table.size(&store), 10);
-    table.grow(&mut store, 3, Val::ExternRef(None))?;
+    table.grow(&mut store, 3, Ref::Extern(None))?;
     assert_eq!(table.size(&store), 13);
 
     Ok(())
@@ -440,3 +410,370 @@ fn read_write_memory_via_api() {
     let res = mem.write(&mut store, usize::MAX, &mut buffer);
     assert!(res.is_err());
 }
+
+// Returns (a, b, c) pairs of function type and function such that
+//
+//     a <: b <: c
+//
+// The functions will panic if actually called.
+fn dummy_funcs_and_subtypes(
+    store: &mut Store<()>,
+) -> (FuncType, Func, FuncType, Func, FuncType, Func) {
+    let engine = store.engine().clone();
+
+    let c_ty = FuncType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        None,
+        [],
+        [ValType::FUNCREF],
+    )
+    .unwrap();
+    let c = Func::new(
+        &mut *store,
+        c_ty.clone(),
+        |_caller, _args, _results| unreachable!(),
+    );
+
+    let b_ty = FuncType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        Some(&c_ty),
+        [],
+        [ValType::Ref(RefType::new(
+            true,
+            HeapType::ConcreteFunc(FuncType::new(&engine, None, None)),
+        ))],
+    )
+    .unwrap();
+    let b = Func::new(
+        &mut *store,
+        b_ty.clone(),
+        |_caller, _args, _results| unreachable!(),
+    );
+
+    let a_ty = FuncType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        Some(&b_ty),
+        [],
+        [ValType::NULLFUNCREF],
+    )
+    .unwrap();
+    let a = Func::new(
+        &mut *store,
+        a_ty.clone(),
+        |_caller, _args, _results| unreachable!(),
+    );
+
+    assert!(a_ty.matches(&a_ty));
+    assert!(a_ty.matches(&b_ty));
+    assert!(a_ty.matches(&c_ty));
+    assert!(!b_ty.matches(&a_ty));
+    assert!(b_ty.matches(&b_ty));
+    assert!(b_ty.matches(&c_ty));
+    assert!(!c_ty.matches(&a_ty));
+    assert!(!c_ty.matches(&b_ty));
+    assert!(c_ty.matches(&c_ty));
+
+    assert!(a.matches_ty(&store, &a_ty));
+    assert!(a.matches_ty(&store, &b_ty));
+    assert!(a.matches_ty(&store, &c_ty));
+    assert!(!b.matches_ty(&store, &a_ty));
+    assert!(b.matches_ty(&store, &b_ty));
+    assert!(b.matches_ty(&store, &c_ty));
+    assert!(!c.matches_ty(&store, &a_ty));
+    assert!(!c.matches_ty(&store, &b_ty));
+    assert!(c.matches_ty(&store, &c_ty));
+
+    (a_ty, a, b_ty, b, c_ty, c)
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn new_global_func_subtyping() {
+    let engine = Engine::default();
+    let mut store = Store::new(&engine, ());
+
+    let (a_ty, a, b_ty, b, c_ty, c) = dummy_funcs_and_subtypes(&mut store);
+
+    for (global_ty, a_expected, b_expected, c_expected) in [
+        // a <: a, b </: a, c </: a
+        (a_ty, true, false, false),
+        // a <: b, b <: b, c </: a
+        (b_ty, true, true, false),
+        // a <: c, b <: c, c <: c
+        (c_ty, true, true, true),
+    ] {
+        for (val, expected) in [(a, a_expected), (b, b_expected), (c, c_expected)] {
+            for mutability in [Mutability::Var, Mutability::Const] {
+                match Global::new(
+                    &mut store,
+                    GlobalType::new(
+                        RefType::new(true, global_ty.clone().into()).into(),
+                        mutability,
+                    ),
+                    val.into(),
+                ) {
+                    Ok(_) if expected => {}
+                    Ok(_) => panic!("should have got type mismatch, but didn't"),
+                    Err(e) if !expected => assert!(e.to_string().contains("type mismatch")),
+                    Err(e) => panic!("should have created global, but got error: {e:?}"),
+                }
+            }
+        }
+    }
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn global_set_func_subtyping() {
+    let engine = Engine::default();
+    let mut store = Store::new(&engine, ());
+
+    let (a_ty, a, b_ty, b, c_ty, c) = dummy_funcs_and_subtypes(&mut store);
+
+    for (global_ty, a_expected, b_expected, c_expected) in [
+        // a <: a, b </: a, c </: a
+        (a_ty, true, false, false),
+        // a <: b, b <: b, c </: a
+        (b_ty, true, true, false),
+        // a <: c, b <: c, c <: c
+        (c_ty, true, true, true),
+    ] {
+        let global = Global::new(
+            &mut store,
+            GlobalType::new(
+                RefType::new(true, global_ty.clone().into()).into(),
+                Mutability::Var,
+            ),
+            Val::null_func_ref(),
+        )
+        .unwrap();
+
+        for (val, expected) in [(a, a_expected), (b, b_expected), (c, c_expected)] {
+            match global.set(&mut store, val.into()) {
+                Ok(_) if expected => {}
+                Ok(_) => panic!("should have got type mismatch, but didn't"),
+                Err(e) if !expected => assert!(e.to_string().contains("type mismatch")),
+                Err(e) => panic!("should have set global, but got error: {e:?}"),
+            }
+        }
+    }
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn new_table_func_subtyping() {
+    let engine = Engine::default();
+    let mut store = Store::new(&engine, ());
+
+    let (a_ty, a, b_ty, b, c_ty, c) = dummy_funcs_and_subtypes(&mut store);
+
+    for (table_ty, a_expected, b_expected, c_expected) in [
+        // a <: a, b </: a, c </: a
+        (a_ty, true, false, false),
+        // a <: b, b <: b, c </: a
+        (b_ty, true, true, false),
+        // a <: c, b <: c, c <: c
+        (c_ty, true, true, true),
+    ] {
+        for (val, expected) in [(a, a_expected), (b, b_expected), (c, c_expected)] {
+            match Table::new(
+                &mut store,
+                TableType::new(RefType::new(true, table_ty.clone().into()), 0, None),
+                val.into(),
+            ) {
+                Ok(_) if expected => {}
+                Ok(_) => panic!("should have got type mismatch, but didn't"),
+                Err(e) if !expected => assert!(e.to_string().contains("type mismatch")),
+                Err(e) => panic!("should have created table, but got error: {e:?}"),
+            }
+        }
+    }
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn table_set_func_subtyping() {
+    let engine = Engine::default();
+    let mut store = Store::new(&engine, ());
+
+    let (a_ty, a, b_ty, b, c_ty, c) = dummy_funcs_and_subtypes(&mut store);
+
+    for (table_ty, a_expected, b_expected, c_expected) in [
+        // a <: a, b </: a, c </: a
+        (a_ty, true, false, false),
+        // a <: b, b <: b, c </: a
+        (b_ty, true, true, false),
+        // a <: c, b <: c, c <: c
+        (c_ty, true, true, true),
+    ] {
+        let table = Table::new(
+            &mut store,
+            TableType::new(RefType::new(true, table_ty.clone().into()), 3, None),
+            Ref::Func(None),
+        )
+        .unwrap();
+
+        let mut i = 0;
+        for (val, expected) in [(a, a_expected), (b, b_expected), (c, c_expected)] {
+            assert!(table.get(&mut store, i).expect("in bounds").is_null());
+
+            match table.set(&mut store, i, val.into()) {
+                Ok(_) if expected => {}
+                Ok(_) => panic!("should have got type mismatch, but didn't"),
+                Err(e) if !expected => assert!(e.to_string().contains("type mismatch")),
+                Err(e) => panic!("should have set table element, but got error: {e:?}"),
+            }
+
+            if expected {
+                assert!(table.get(&mut store, i).expect("in bounds").is_non_null());
+            }
+
+            i += 1;
+        }
+    }
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn table_grow_func_subtyping() {
+    let engine = Engine::default();
+    let mut store = Store::new(&engine, ());
+
+    let (a_ty, a, b_ty, b, c_ty, c) = dummy_funcs_and_subtypes(&mut store);
+
+    for (table_ty, a_expected, b_expected, c_expected) in [
+        // a <: a, b </: a, c </: a
+        (a_ty, true, false, false),
+        // a <: b, b <: b, c </: a
+        (b_ty, true, true, false),
+        // a <: c, b <: c, c <: c
+        (c_ty, true, true, true),
+    ] {
+        let table = Table::new(
+            &mut store,
+            TableType::new(RefType::new(true, table_ty.clone().into()), 3, None),
+            Ref::Func(None),
+        )
+        .unwrap();
+
+        for (val, expected) in [(a, a_expected), (b, b_expected), (c, c_expected)] {
+            let orig_size = table.size(&store);
+
+            match table.grow(&mut store, 10, val.into()) {
+                Ok(_) if expected => {}
+                Ok(_) => panic!("should have got type mismatch, but didn't"),
+                Err(e) if !expected => assert!(e.to_string().contains("type mismatch")),
+                Err(e) => panic!("should have done table grow, but got error: {e:?}"),
+            }
+
+            if expected {
+                let new_size = table.size(&store);
+                assert_eq!(new_size, orig_size + 10);
+                for i in orig_size..new_size {
+                    assert!(table.get(&mut store, i).expect("in bounds").is_non_null());
+                }
+            }
+        }
+    }
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn table_fill_func_subtyping() {
+    let engine = Engine::default();
+    let mut store = Store::new(&engine, ());
+
+    let (a_ty, a, b_ty, b, c_ty, c) = dummy_funcs_and_subtypes(&mut store);
+
+    for (table_ty, a_expected, b_expected, c_expected) in [
+        // a <: a, b </: a, c </: a
+        (a_ty, true, false, false),
+        // a <: b, b <: b, c </: a
+        (b_ty, true, true, false),
+        // a <: c, b <: c, c <: c
+        (c_ty, true, true, true),
+    ] {
+        for (val, expected) in [(a, a_expected), (b, b_expected), (c, c_expected)] {
+            let table = Table::new(
+                &mut store,
+                TableType::new(RefType::new(true, table_ty.clone().into()), 10, None),
+                Ref::Func(None),
+            )
+            .unwrap();
+
+            match table.fill(&mut store, 3, val.into(), 4) {
+                Ok(_) if expected => {}
+                Ok(_) => panic!("should have got type mismatch, but didn't"),
+                Err(e) if !expected => assert!(e.to_string().contains("type mismatch")),
+                Err(e) => panic!("should have done table fill, but got error: {e:?}"),
+            }
+
+            if expected {
+                for i in 3..7 {
+                    assert!(table.get(&mut store, i).expect("in bounds").is_non_null());
+                }
+            }
+        }
+    }
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn table_copy_func_subtyping() {
+    let _ = env_logger::try_init();
+
+    let engine = Engine::default();
+    let mut store = Store::new(&engine, ());
+
+    let (a_ty, a, b_ty, b, c_ty, c) = dummy_funcs_and_subtypes(&mut store);
+
+    for (dst_ty, a_expected, b_expected, c_expected) in [
+        // a <: a, b </: a, c </: a
+        (a_ty.clone(), true, false, false),
+        // a <: b, b <: b, c </: a
+        (b_ty.clone(), true, true, false),
+        // a <: c, b <: c, c <: c
+        (c_ty.clone(), true, true, true),
+    ] {
+        let dest_table = Table::new(
+            &mut store,
+            TableType::new(RefType::new(true, dst_ty.clone().into()), 10, None),
+            Ref::Func(None),
+        )
+        .unwrap();
+
+        for (val, src_ty, expected) in [
+            (a, a_ty.clone(), a_expected),
+            (b, b_ty.clone(), b_expected),
+            (c, c_ty.clone(), c_expected),
+        ] {
+            dest_table.fill(&mut store, 0, Ref::Func(None), 10).unwrap();
+
+            let src_table = Table::new(
+                &mut store,
+                TableType::new(RefType::new(true, src_ty.into()), 10, None),
+                val.into(),
+            )
+            .unwrap();
+
+            match Table::copy(&mut store, &dest_table, 2, &src_table, 3, 5) {
+                Ok(_) if expected => {}
+                Ok(_) => panic!("should have got type mismatch, but didn't"),
+                Err(e) if !expected => assert!(e.to_string().contains("type mismatch")),
+                Err(e) => panic!("should have done table copy, but got error: {e:?}"),
+            }
+
+            if expected {
+                for i in 2..7 {
+                    assert!(dest_table
+                        .get(&mut store, i)
+                        .expect("in bounds")
+                        .is_non_null());
+                }
+            }
+        }
+    }
+}
diff --git a/tests/all/fuel.rs b/tests/all/fuel.rs
index c3f300d09a33..ebc39ade0bea 100644
--- a/tests/all/fuel.rs
+++ b/tests/all/fuel.rs
@@ -1,4 +1,3 @@
-use anyhow::Result;
 use wasmtime::*;
 use wast::parser::{self, Parse, ParseBuffer, Parser};
 use wast::token::Span;
@@ -53,9 +52,9 @@ fn fuel_consumed(wasm: &[u8]) -> u64 {
     let engine = Engine::new(&config).unwrap();
     let module = Module::new(&engine, wasm).unwrap();
     let mut store = Store::new(&engine, ());
-    store.add_fuel(u64::max_value()).unwrap();
+    store.set_fuel(u64::MAX).unwrap();
     drop(Instance::new(&mut store, &module, &[]));
-    store.fuel_consumed().unwrap()
+    u64::MAX - store.get_fuel().unwrap()
 }
 
 #[test]
@@ -116,7 +115,7 @@ fn iloop() {
         let engine = Engine::new(&config).unwrap();
         let module = Module::new(&engine, wat).unwrap();
         let mut store = Store::new(&engine, ());
-        store.add_fuel(10_000).unwrap();
+        store.set_fuel(10_000).unwrap();
         let error = Instance::new(&mut store, &module, &[]).err().unwrap();
         assert_eq!(error.downcast::<Trap>().unwrap(), Trap::OutOfFuel);
     }
@@ -128,21 +127,10 @@ fn manual_fuel() {
     config.consume_fuel(true);
     let engine = Engine::new(&config).unwrap();
     let mut store = Store::new(&engine, ());
-    store.add_fuel(10_000).unwrap();
-    assert_eq!(store.fuel_consumed(), Some(0));
-    assert_eq!(store.fuel_remaining(), Some(10_000));
-    assert_eq!(store.consume_fuel(1).unwrap(), 9_999);
-    assert_eq!(store.fuel_consumed(), Some(1));
-    assert_eq!(store.fuel_remaining(), Some(9_999));
-    assert!(store.consume_fuel(10_000).is_err());
-    assert_eq!(store.consume_fuel(999).unwrap(), 9_000);
-    assert!(store.consume_fuel(10_000).is_err());
-    assert_eq!(store.consume_fuel(8998).unwrap(), 2);
-    assert!(store.consume_fuel(3).is_err());
-    assert_eq!(store.consume_fuel(1).unwrap(), 1);
-    assert_eq!(store.consume_fuel(1).unwrap(), 0);
-    assert_eq!(store.consume_fuel(0).unwrap(), 0);
-    assert_eq!(store.fuel_remaining(), Some(0));
+    store.set_fuel(10_000).unwrap();
+    assert_eq!(store.get_fuel().ok(), Some(10_000));
+    assert_eq!(store.set_fuel(1).ok(), Some(()));
+    assert_eq!(store.get_fuel().ok(), Some(1));
 }
 
 #[test]
@@ -165,10 +153,11 @@ fn host_function_consumes_all() {
     )
     .unwrap();
     let mut store = Store::new(&engine, ());
-    store.add_fuel(FUEL).unwrap();
+    store.set_fuel(FUEL).unwrap();
     let func = Func::wrap(&mut store, |mut caller: Caller<'_, ()>| {
-        let consumed = caller.fuel_consumed().unwrap();
-        assert_eq!(caller.consume_fuel((FUEL - consumed) - 1).unwrap(), 1);
+        let remaining = caller.get_fuel().unwrap();
+        assert_eq!(remaining, FUEL - 2);
+        assert!(caller.set_fuel(1).is_ok());
     });
 
     let instance = Instance::new(&mut store, &module, &[func.into()]).unwrap();
@@ -183,11 +172,8 @@ fn manual_edge_cases() {
     config.consume_fuel(true);
     let engine = Engine::new(&config).unwrap();
     let mut store = Store::new(&engine, ());
-    store.add_fuel(u64::MAX).unwrap();
-    assert_eq!(store.fuel_consumed(), Some(0));
-    assert!(store.consume_fuel(u64::MAX).is_err());
-    assert!(store.consume_fuel(i64::MAX as u64 + 1).is_err());
-    assert_eq!(store.consume_fuel(i64::MAX as u64).unwrap(), 0);
+    store.set_fuel(u64::MAX).unwrap();
+    assert_eq!(store.get_fuel().unwrap(), u64::MAX);
 }
 
 #[test]
@@ -217,8 +203,8 @@ fn unconditionally_trapping_memory_accesses_save_fuel_before_trapping() {
 
     let mut store = Store::new(&engine, ());
     let init_fuel = 1_000;
-    store.add_fuel(init_fuel).unwrap();
-    assert_eq!(init_fuel, store.fuel_remaining().unwrap());
+    store.set_fuel(init_fuel).unwrap();
+    assert_eq!(init_fuel, store.get_fuel().unwrap());
 
     let instance = Instance::new(&mut store, &module, &[]).unwrap();
     let f = instance
@@ -230,7 +216,43 @@ fn unconditionally_trapping_memory_accesses_save_fuel_before_trapping() {
 
     // The `i32.add` consumed some fuel before the unconditionally trapping
     // memory access.
-    let consumed_fuel = store.fuel_consumed().unwrap();
+    let consumed_fuel = init_fuel - store.get_fuel().unwrap();
     assert!(consumed_fuel > 0);
-    assert_eq!(init_fuel, consumed_fuel + store.fuel_remaining().unwrap());
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn get_fuel_clamps_at_zero() -> Result<()> {
+    let engine = Engine::new(Config::new().consume_fuel(true))?;
+    let mut store = Store::new(&engine, ());
+    let module = Module::new(
+        &engine,
+        r#"
+(module
+  (func $add2 (export "add2") (param $n i32) (result i32)
+    (i32.add (local.get $n) (i32.const 2))
+  )
+)
+        "#,
+    )?;
+    let instance = Instance::new(&mut store, &module, &[])?;
+
+    let add2 = instance.get_typed_func::<i32, i32>(&mut store, "add2")?;
+
+    // Start with 6 fuel and one invocation of this function should cost 4 fuel
+    store.set_fuel(6)?;
+    assert_eq!(store.get_fuel()?, 6);
+    add2.call(&mut store, 10)?;
+    assert_eq!(store.get_fuel()?, 2);
+
+    // One more invocation of the function would technically take us to -2 fuel,
+    // but that's not representable, so the store should report 0 fuel after
+    // this completes.
+    add2.call(&mut store, 10)?;
+    assert_eq!(store.get_fuel()?, 0);
+
+    // Any further attempts should fail.
+    assert!(add2.call(&mut store, 10).is_err());
+
+    Ok(())
 }
diff --git a/tests/all/func.rs b/tests/all/func.rs
index fab609520497..c408952b4eec 100644
--- a/tests/all/func.rs
+++ b/tests/all/func.rs
@@ -1,11 +1,13 @@
-use anyhow::{bail, Result};
+use anyhow::bail;
+use std::sync::atomic::Ordering;
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst};
 use std::sync::Arc;
 use wasmtime::*;
+use wasmtime_test_macros::wasmtime_test;
 
-#[test]
+#[wasmtime_test]
 #[cfg_attr(miri, ignore)]
-fn call_wasm_to_wasm() -> Result<()> {
+fn call_wasm_to_wasm(config: &mut Config) -> Result<()> {
     let wasm = wat::parse_str(
         r#"
           (module
@@ -20,7 +22,8 @@ fn call_wasm_to_wasm() -> Result<()> {
           )
         "#,
     )?;
-    let mut store = Store::<()>::default();
+    let engine = Engine::new(&config)?;
+    let mut store = Store::<()>::new(&engine, ());
     let module = Module::new(store.engine(), &wasm)?;
     let instance = Instance::new(&mut store, &module, &[])?;
     let func = instance
@@ -31,9 +34,9 @@ fn call_wasm_to_wasm() -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[wasmtime_test]
 #[cfg_attr(miri, ignore)]
-fn call_wasm_to_native() -> Result<()> {
+fn call_wasm_to_native(config: &mut Config) -> Result<()> {
     let wasm = wat::parse_str(
         r#"
           (module
@@ -44,7 +47,8 @@ fn call_wasm_to_native() -> Result<()> {
           )
         "#,
     )?;
-    let mut store = Store::<()>::default();
+    let engine = Engine::new(&config)?;
+    let mut store = Store::<()>::new(&engine, ());
     let module = Module::new(store.engine(), &wasm)?;
     let import_func = Func::wrap(&mut store, || (1_i32, 2_i32, 3_i32));
     let instance = Instance::new(&mut store, &module, &[import_func.into()])?;
@@ -56,9 +60,9 @@ fn call_wasm_to_native() -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[wasmtime_test]
 #[cfg_attr(miri, ignore)]
-fn call_wasm_to_array() -> Result<()> {
+fn call_wasm_to_array(config: &mut Config) -> Result<()> {
     let wasm = wat::parse_str(
         r#"
           (module
@@ -69,18 +73,20 @@ fn call_wasm_to_array() -> Result<()> {
           )
         "#,
     )?;
-    let mut store = Store::<()>::default();
+    let engine = Engine::new(&config)?;
+    let mut store = Store::<()>::new(&engine, ());
     let module = Module::new(store.engine(), &wasm)?;
-    let import_func = Func::new(
-        &mut store,
-        FuncType::new(vec![], vec![ValType::I32, ValType::I32, ValType::I32]),
-        |_, _params, results| {
-            results[0] = Val::I32(1);
-            results[1] = Val::I32(2);
-            results[2] = Val::I32(3);
-            Ok(())
-        },
+    let func_ty = FuncType::new(
+        store.engine(),
+        vec![],
+        vec![ValType::I32, ValType::I32, ValType::I32],
     );
+    let import_func = Func::new(&mut store, func_ty, |_, _params, results| {
+        results[0] = Val::I32(1);
+        results[1] = Val::I32(2);
+        results[2] = Val::I32(3);
+        Ok(())
+    });
     let instance = Instance::new(&mut store, &module, &[import_func.into()])?;
     let func = instance
         .get_typed_func::<(), (i32, i32, i32)>(&mut store, "run")
@@ -90,9 +96,9 @@ fn call_wasm_to_array() -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[wasmtime_test]
 #[cfg_attr(miri, ignore)]
-fn call_native_to_wasm() -> Result<()> {
+fn call_native_to_wasm(config: &mut Config) -> Result<()> {
     let wasm = wat::parse_str(
         r#"
           (module
@@ -104,7 +110,8 @@ fn call_native_to_wasm() -> Result<()> {
           )
         "#,
     )?;
-    let mut store = Store::<()>::default();
+    let engine = Engine::new(&config)?;
+    let mut store = Store::<()>::new(&engine, ());
     let module = Module::new(store.engine(), &wasm)?;
     let instance = Instance::new(&mut store, &module, &[])?;
     let func = instance
@@ -133,28 +140,26 @@ fn call_native_to_native() -> Result<()> {
 fn call_native_to_array() -> Result<()> {
     let mut store = Store::<()>::default();
 
-    let func = Func::new(
-        &mut store,
-        FuncType::new(
-            [ValType::I32, ValType::I32, ValType::I32],
-            [ValType::I32, ValType::I32, ValType::I32],
-        ),
-        |_caller, params, results| {
-            results[0] = params[2].clone();
-            results[1] = params[0].clone();
-            results[2] = params[1].clone();
-            Ok(())
-        },
+    let func_ty = FuncType::new(
+        store.engine(),
+        [ValType::I32, ValType::I32, ValType::I32],
+        [ValType::I32, ValType::I32, ValType::I32],
     );
+    let func = Func::new(&mut store, func_ty, |_caller, params, results| {
+        results[0] = params[2];
+        results[1] = params[0];
+        results[2] = params[1];
+        Ok(())
+    });
     let func = func.typed::<(i32, i32, i32), (i32, i32, i32)>(&store)?;
     let results = func.call(&mut store, (1, 2, 3))?;
     assert_eq!(results, (3, 1, 2));
     Ok(())
 }
 
-#[test]
+#[wasmtime_test]
 #[cfg_attr(miri, ignore)]
-fn call_array_to_wasm() -> Result<()> {
+fn call_array_to_wasm(config: &mut Config) -> Result<()> {
     let wasm = wat::parse_str(
         r#"
           (module
@@ -166,7 +171,8 @@ fn call_array_to_wasm() -> Result<()> {
           )
         "#,
     )?;
-    let mut store = Store::<()>::default();
+    let engine = Engine::new(&config)?;
+    let mut store = Store::<()>::new(&engine, ());
     let module = Module::new(store.engine(), &wasm)?;
     let instance = Instance::new(&mut store, &module, &[])?;
     let func = instance.get_func(&mut store, "run").unwrap();
@@ -204,19 +210,17 @@ fn call_array_to_native() -> Result<()> {
 #[cfg_attr(miri, ignore)]
 fn call_array_to_array() -> Result<()> {
     let mut store = Store::<()>::default();
-    let func = Func::new(
-        &mut store,
-        FuncType::new(
-            [ValType::I32, ValType::I32, ValType::I32],
-            [ValType::I32, ValType::I32, ValType::I32],
-        ),
-        |_caller, params, results| {
-            results[0] = params[2].clone();
-            results[1] = params[0].clone();
-            results[2] = params[1].clone();
-            Ok(())
-        },
+    let func_ty = FuncType::new(
+        store.engine(),
+        [ValType::I32, ValType::I32, ValType::I32],
+        [ValType::I32, ValType::I32, ValType::I32],
     );
+    let func = Func::new(&mut store, func_ty, |_caller, params, results| {
+        results[0] = params[2];
+        results[1] = params[0];
+        results[2] = params[1];
+        Ok(())
+    });
     let mut results = [Val::I32(0), Val::I32(0), Val::I32(0)];
     func.call(
         &mut store,
@@ -229,9 +233,9 @@ fn call_array_to_array() -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[wasmtime_test]
 #[cfg_attr(miri, ignore)]
-fn call_indirect_native_from_wasm_import_global() -> Result<()> {
+fn call_indirect_native_from_wasm_import_global(config: &mut Config) -> Result<()> {
     let wasm = wat::parse_str(
         r#"
           (module
@@ -247,12 +251,13 @@ fn call_indirect_native_from_wasm_import_global() -> Result<()> {
           )
         "#,
     )?;
-    let mut store = Store::<()>::default();
+    let engine = Engine::new(&config)?;
+    let mut store = Store::<()>::new(&engine, ());
     let module = Module::new(store.engine(), &wasm)?;
     let func = Func::wrap(&mut store, || -> (i32, i32, i32) { (10, 20, 30) });
     let global = Global::new(
         &mut store,
-        GlobalType::new(ValType::FuncRef, Mutability::Const),
+        GlobalType::new(ValType::FUNCREF, Mutability::Const),
         Val::FuncRef(Some(func)),
     )?;
     let instance = Instance::new(&mut store, &module, &[global.into()])?;
@@ -262,9 +267,9 @@ fn call_indirect_native_from_wasm_import_global() -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[wasmtime_test]
 #[cfg_attr(miri, ignore)]
-fn call_indirect_native_from_wasm_import_table() -> Result<()> {
+fn call_indirect_native_from_wasm_import_table(config: &mut Config) -> Result<()> {
     let wasm = wat::parse_str(
         r#"
           (module
@@ -276,13 +281,14 @@ fn call_indirect_native_from_wasm_import_table() -> Result<()> {
           )
         "#,
     )?;
-    let mut store = Store::<()>::default();
+    let engine = Engine::new(&config)?;
+    let mut store = Store::<()>::new(&engine, ());
     let module = Module::new(store.engine(), &wasm)?;
     let func = Func::wrap(&mut store, || -> (i32, i32, i32) { (10, 20, 30) });
     let table = Table::new(
         &mut store,
-        TableType::new(ValType::FuncRef, 1, Some(1)),
-        Val::FuncRef(Some(func)),
+        TableType::new(RefType::FUNCREF, 1, Some(1)),
+        Ref::Func(Some(func)),
     )?;
     let instance = Instance::new(&mut store, &module, &[table.into()])?;
     let func = instance.get_typed_func::<(), (i32, i32, i32)>(&mut store, "run")?;
@@ -291,9 +297,9 @@ fn call_indirect_native_from_wasm_import_table() -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[wasmtime_test]
 #[cfg_attr(miri, ignore)]
-fn call_indirect_native_from_wasm_import_func_returns_funcref() -> Result<()> {
+fn call_indirect_native_from_wasm_import_func_returns_funcref(config: &mut Config) -> Result<()> {
     let wasm = wat::parse_str(
         r#"
           (module
@@ -309,7 +315,8 @@ fn call_indirect_native_from_wasm_import_func_returns_funcref() -> Result<()> {
           )
         "#,
     )?;
-    let mut store = Store::<()>::default();
+    let engine = Engine::new(&config)?;
+    let mut store = Store::<()>::new(&engine, ());
     let module = Module::new(store.engine(), &wasm)?;
     let func = Func::wrap(&mut store, || -> (i32, i32, i32) { (10, 20, 30) });
     let get_func = Func::wrap(&mut store, move || -> Option<Func> { Some(func) });
@@ -320,9 +327,9 @@ fn call_indirect_native_from_wasm_import_func_returns_funcref() -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[wasmtime_test]
 #[cfg_attr(miri, ignore)]
-fn call_indirect_native_from_exported_table() -> Result<()> {
+fn call_indirect_native_from_exported_table(config: &mut Config) -> Result<()> {
     let wasm = wat::parse_str(
         r#"
           (module
@@ -334,7 +341,8 @@ fn call_indirect_native_from_exported_table() -> Result<()> {
           )
         "#,
     )?;
-    let mut store = Store::<()>::default();
+    let engine = Engine::new(&config)?;
+    let mut store = Store::<()>::new(&engine, ());
     let module = Module::new(store.engine(), &wasm)?;
     let func = Func::wrap(&mut store, || -> (i32, i32, i32) { (10, 20, 30) });
     let instance = Instance::new(&mut store, &module, &[])?;
@@ -347,9 +355,9 @@ fn call_indirect_native_from_exported_table() -> Result<()> {
 }
 
 // wasm exports global, host puts native-call funcref in global, wasm calls funcref
-#[test]
+#[wasmtime_test]
 #[cfg_attr(miri, ignore)]
-fn call_indirect_native_from_exported_global() -> Result<()> {
+fn call_indirect_native_from_exported_global(config: &mut Config) -> Result<()> {
     let wasm = wat::parse_str(
         r#"
           (module
@@ -365,7 +373,8 @@ fn call_indirect_native_from_exported_global() -> Result<()> {
           )
         "#,
     )?;
-    let mut store = Store::<()>::default();
+    let engine = Engine::new(&config)?;
+    let mut store = Store::<()>::new(&engine, ());
     let module = Module::new(store.engine(), &wasm)?;
     let func = Func::wrap(&mut store, || -> (i32, i32, i32) { (10, 20, 30) });
     let instance = Instance::new(&mut store, &module, &[])?;
@@ -388,16 +397,53 @@ fn func_constructors() {
     Func::wrap(&mut store, || -> i64 { 0 });
     Func::wrap(&mut store, || -> f32 { 0.0 });
     Func::wrap(&mut store, || -> f64 { 0.0 });
-    Func::wrap(&mut store, || -> Option<ExternRef> { None });
+    Func::wrap(&mut store, || -> Rooted<ExternRef> { loop {} });
+    Func::wrap(&mut store, || -> Option<Rooted<ExternRef>> { None });
+    Func::wrap(&mut store, || -> ManuallyRooted<ExternRef> { loop {} });
+    Func::wrap(&mut store, || -> Option<ManuallyRooted<ExternRef>> { None });
+    Func::wrap(&mut store, || -> Rooted<AnyRef> { loop {} });
+    Func::wrap(&mut store, || -> Option<Rooted<AnyRef>> { None });
+    Func::wrap(&mut store, || -> ManuallyRooted<AnyRef> { loop {} });
+    Func::wrap(&mut store, || -> Option<ManuallyRooted<AnyRef>> { None });
+    Func::wrap(&mut store, || -> I31 { loop {} });
+    Func::wrap(&mut store, || -> Option<I31> { None });
+    Func::wrap(&mut store, || -> Func { loop {} });
     Func::wrap(&mut store, || -> Option<Func> { None });
+    Func::wrap(&mut store, || -> NoFunc { loop {} });
+    Func::wrap(&mut store, || -> Option<NoFunc> { None });
+    Func::wrap(&mut store, || -> NoExtern { loop {} });
+    Func::wrap(&mut store, || -> Option<NoExtern> { None });
 
     Func::wrap(&mut store, || -> Result<()> { loop {} });
     Func::wrap(&mut store, || -> Result<i32> { loop {} });
     Func::wrap(&mut store, || -> Result<i64> { loop {} });
     Func::wrap(&mut store, || -> Result<f32> { loop {} });
     Func::wrap(&mut store, || -> Result<f64> { loop {} });
-    Func::wrap(&mut store, || -> Result<Option<ExternRef>> { loop {} });
+    Func::wrap(&mut store, || -> Result<Rooted<ExternRef>> { loop {} });
+    Func::wrap(&mut store, || -> Result<Option<Rooted<ExternRef>>> {
+        loop {}
+    });
+    Func::wrap(&mut store, || -> Result<ManuallyRooted<ExternRef>> {
+        loop {}
+    });
+    Func::wrap(
+        &mut store,
+        || -> Result<Option<ManuallyRooted<ExternRef>>> { loop {} },
+    );
+    Func::wrap(&mut store, || -> Result<Rooted<AnyRef>> { loop {} });
+    Func::wrap(&mut store, || -> Result<Option<Rooted<AnyRef>>> { loop {} });
+    Func::wrap(&mut store, || -> Result<ManuallyRooted<AnyRef>> { loop {} });
+    Func::wrap(&mut store, || -> Result<Option<ManuallyRooted<AnyRef>>> {
+        loop {}
+    });
+    Func::wrap(&mut store, || -> Result<I31> { loop {} });
+    Func::wrap(&mut store, || -> Result<Option<I31>> { loop {} });
+    Func::wrap(&mut store, || -> Result<Func> { loop {} });
     Func::wrap(&mut store, || -> Result<Option<Func>> { loop {} });
+    Func::wrap(&mut store, || -> Result<NoFunc> { loop {} });
+    Func::wrap(&mut store, || -> Result<Option<NoFunc>> { loop {} });
+    Func::wrap(&mut store, || -> Result<NoExtern> { loop {} });
+    Func::wrap(&mut store, || -> Result<Option<NoExtern>> { loop {} });
 }
 
 #[test]
@@ -455,49 +501,65 @@ fn signatures_match() {
     let mut store = Store::<()>::default();
 
     let f = Func::wrap(&mut store, || {});
-    assert_eq!(f.ty(&store).params().collect::<Vec<_>>(), &[]);
-    assert_eq!(f.ty(&store).results().collect::<Vec<_>>(), &[]);
+    assert_eq!(f.ty(&store).params().len(), 0);
+    assert_eq!(f.ty(&store).results().len(), 0);
 
     let f = Func::wrap(&mut store, || -> i32 { loop {} });
-    assert_eq!(f.ty(&store).params().collect::<Vec<_>>(), &[]);
-    assert_eq!(f.ty(&store).results().collect::<Vec<_>>(), &[ValType::I32]);
+    assert_eq!(f.ty(&store).params().len(), 0);
+    assert_eq!(f.ty(&store).results().len(), 1);
+    assert!(f.ty(&store).results().nth(0).unwrap().is_i32());
 
     let f = Func::wrap(&mut store, || -> i64 { loop {} });
-    assert_eq!(f.ty(&store).params().collect::<Vec<_>>(), &[]);
-    assert_eq!(f.ty(&store).results().collect::<Vec<_>>(), &[ValType::I64]);
+    assert_eq!(f.ty(&store).params().len(), 0);
+    assert_eq!(f.ty(&store).results().len(), 1);
+    assert!(f.ty(&store).results().nth(0).unwrap().is_i64());
 
     let f = Func::wrap(&mut store, || -> f32 { loop {} });
-    assert_eq!(f.ty(&store).params().collect::<Vec<_>>(), &[]);
-    assert_eq!(f.ty(&store).results().collect::<Vec<_>>(), &[ValType::F32]);
+    assert_eq!(f.ty(&store).params().len(), 0);
+    assert_eq!(f.ty(&store).results().len(), 1);
+    assert!(f.ty(&store).results().nth(0).unwrap().is_f32());
 
     let f = Func::wrap(&mut store, || -> f64 { loop {} });
-    assert_eq!(f.ty(&store).params().collect::<Vec<_>>(), &[]);
-    assert_eq!(f.ty(&store).results().collect::<Vec<_>>(), &[ValType::F64]);
+    assert_eq!(f.ty(&store).params().len(), 0);
+    assert_eq!(f.ty(&store).results().len(), 1);
+    assert!(f.ty(&store).results().nth(0).unwrap().is_f64());
 
     let f = Func::wrap(
         &mut store,
-        |_: f32, _: f64, _: i32, _: i64, _: i32, _: Option<ExternRef>, _: Option<Func>| -> f64 {
-            loop {}
-        },
+        |_: f32,
+         _: f64,
+         _: i32,
+         _: i64,
+         _: i32,
+         _: Option<Rooted<ExternRef>>,
+         _: Option<ManuallyRooted<ExternRef>>,
+         _: Option<Rooted<AnyRef>>,
+         _: Option<ManuallyRooted<AnyRef>>,
+         _: Option<Func>|
+         -> f64 { loop {} },
     );
-    assert_eq!(
-        f.ty(&store).params().collect::<Vec<_>>(),
-        &[
-            ValType::F32,
-            ValType::F64,
-            ValType::I32,
-            ValType::I64,
-            ValType::I32,
-            ValType::ExternRef,
-            ValType::FuncRef,
-        ]
-    );
-    assert_eq!(f.ty(&store).results().collect::<Vec<_>>(), &[ValType::F64]);
+
+    assert_eq!(f.ty(&store).params().len(), 10);
+    assert!(f.ty(&store).params().nth(0).unwrap().is_f32());
+    assert!(f.ty(&store).params().nth(1).unwrap().is_f64());
+    assert!(f.ty(&store).params().nth(2).unwrap().is_i32());
+    assert!(f.ty(&store).params().nth(3).unwrap().is_i64());
+    assert!(f.ty(&store).params().nth(4).unwrap().is_i32());
+    assert!(f.ty(&store).params().nth(5).unwrap().is_externref());
+    assert!(f.ty(&store).params().nth(6).unwrap().is_externref());
+    assert!(f.ty(&store).params().nth(7).unwrap().is_anyref());
+    assert!(f.ty(&store).params().nth(8).unwrap().is_anyref());
+    assert!(f.ty(&store).params().nth(9).unwrap().is_funcref());
+
+    assert_eq!(f.ty(&store).results().len(), 1);
+    assert!(f.ty(&store).results().nth(0).unwrap().is_f64());
 }
 
 #[test]
 #[cfg_attr(miri, ignore)]
 fn import_works() -> Result<()> {
+    let _ = env_logger::try_init();
+
     static HITS: AtomicUsize = AtomicUsize::new(0);
 
     let wasm = wat::parse_str(
@@ -505,9 +567,9 @@ fn import_works() -> Result<()> {
             (import "" "" (func))
             (import "" "" (func (param i32) (result i32)))
             (import "" "" (func (param i32) (param i64)))
-            (import "" "" (func (param i32 i64 i32 f32 f64 externref funcref)))
+            (import "" "" (func (param i32 i64 i32 f32 f64 externref externref funcref anyref anyref i31ref)))
 
-            (func (export "run") (param externref funcref)
+            (func (export "run") (param externref externref funcref)
                 call 0
                 i32.const 0
                 call 1
@@ -523,15 +585,24 @@ fn import_works() -> Result<()> {
                 f64.const 500
                 local.get 0
                 local.get 1
+                local.get 2
+                (ref.i31 (i32.const 36))
+                (ref.i31 (i32.const 42))
+                (ref.i31 (i32.const 0x1234))
                 call 3
             )
         "#,
     )?;
+
     let mut config = Config::new();
     config.wasm_reference_types(true);
+    config.wasm_function_references(true);
+    config.wasm_gc(true);
+
     let engine = Engine::new(&config)?;
     let mut store = Store::new(&engine, ());
     let module = Module::new(&engine, &wasm)?;
+
     let imports = [
         Func::wrap(&mut store, || {
             assert_eq!(HITS.fetch_add(1, SeqCst), 0);
@@ -557,44 +628,69 @@ fn import_works() -> Result<()> {
              c: i32,
              d: f32,
              e: f64,
-             f: Option<ExternRef>,
-             g: Option<Func>| {
+             f: Option<Rooted<ExternRef>>,
+             g: Option<ManuallyRooted<ExternRef>>,
+             h: Option<Func>,
+             i: Option<Rooted<AnyRef>>,
+             j: Option<ManuallyRooted<AnyRef>>,
+             k: Option<I31>|
+             -> Result<()> {
                 assert_eq!(a, 100);
                 assert_eq!(b, 200);
                 assert_eq!(c, 300);
                 assert_eq!(d, 400.0);
                 assert_eq!(e, 500.0);
                 assert_eq!(
-                    f.as_ref().unwrap().data().downcast_ref::<String>().unwrap(),
+                    f.as_ref()
+                        .unwrap()
+                        .data(&caller)?
+                        .downcast_ref::<String>()
+                        .unwrap(),
                     "hello"
                 );
+                assert_eq!(
+                    g.as_ref()
+                        .unwrap()
+                        .data(&caller)?
+                        .downcast_ref::<String>()
+                        .unwrap(),
+                    "goodbye"
+                );
+                assert_eq!(
+                    i.unwrap().as_i31(&caller).unwrap().unwrap(),
+                    I31::wrapping_u32(36)
+                );
+                assert_eq!(
+                    j.unwrap().as_i31(&caller).unwrap().unwrap(),
+                    I31::wrapping_u32(42)
+                );
+                assert_eq!(k, Some(I31::wrapping_u32(0x1234)));
                 let mut results = [Val::I32(0)];
-                g.as_ref()
+                h.as_ref()
                     .unwrap()
                     .call(&mut caller, &[], &mut results)
                     .unwrap();
                 assert_eq!(results[0].unwrap_i32(), 42);
                 assert_eq!(HITS.fetch_add(1, SeqCst), 3);
+                Ok(())
             },
         )
         .into(),
     ];
+
     let instance = Instance::new(&mut store, &module, &imports)?;
     let run = instance.get_func(&mut store, "run").unwrap();
+    let hello = Val::ExternRef(Some(ExternRef::new(&mut store, "hello".to_string())?));
+    let goodbye = Val::ExternRef(Some(ExternRef::new(&mut store, "goodbye".to_string())?));
     let funcref = Val::FuncRef(Some(Func::wrap(&mut store, || -> i32 { 42 })));
-    run.call(
-        &mut store,
-        &[
-            Val::ExternRef(Some(ExternRef::new("hello".to_string()))),
-            funcref,
-        ],
-        &mut [],
-    )?;
+    run.call(&mut store, &[hello, goodbye, funcref], &mut [])?;
+
     assert_eq!(HITS.load(SeqCst), 4);
     Ok(())
 }
 
 #[test]
+#[cfg_attr(miri, ignore)]
 fn trap_smoke() -> Result<()> {
     let mut store = Store::<()>::default();
     let f = Func::wrap(&mut store, || -> Result<()> { bail!("test") });
@@ -603,16 +699,17 @@ fn trap_smoke() -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[wasmtime_test]
 #[cfg_attr(miri, ignore)]
-fn trap_import() -> Result<()> {
+fn trap_import(config: &mut Config) -> Result<()> {
     let wasm = wat::parse_str(
         r#"
             (import "" "" (func))
             (start 0)
         "#,
     )?;
-    let mut store = Store::<()>::default();
+    let engine = Engine::new(&config)?;
+    let mut store = Store::<()>::new(&engine, ());
     let module = Module::new(store.engine(), &wasm)?;
     let import = Func::wrap(&mut store, || -> Result<()> { bail!("foo") });
     let trap = Instance::new(&mut store, &module, &[import.into()]).unwrap_err();
@@ -638,8 +735,34 @@ fn get_from_wrapper() {
     assert!(f.typed::<(), f32>(&store).is_ok());
     let f = Func::wrap(&mut store, || -> f64 { loop {} });
     assert!(f.typed::<(), f64>(&store).is_ok());
-    let f = Func::wrap(&mut store, || -> Option<ExternRef> { loop {} });
-    assert!(f.typed::<(), Option<ExternRef>>(&store).is_ok());
+    let f = Func::wrap(&mut store, || -> Rooted<ExternRef> { loop {} });
+    assert!(f.typed::<(), Rooted<ExternRef>>(&store).is_ok());
+    let f = Func::wrap(&mut store, || -> Option<Rooted<ExternRef>> { loop {} });
+    assert!(f.typed::<(), Option<Rooted<ExternRef>>>(&store).is_ok());
+    let f = Func::wrap(&mut store, || -> ManuallyRooted<ExternRef> { loop {} });
+    assert!(f.typed::<(), ManuallyRooted<ExternRef>>(&store).is_ok());
+    let f = Func::wrap(&mut store, || -> Option<ManuallyRooted<ExternRef>> {
+        loop {}
+    });
+    assert!(f
+        .typed::<(), Option<ManuallyRooted<ExternRef>>>(&store)
+        .is_ok());
+    let f = Func::wrap(&mut store, || -> Rooted<AnyRef> { loop {} });
+    assert!(f.typed::<(), Rooted<AnyRef>>(&store).is_ok());
+    let f = Func::wrap(&mut store, || -> Option<Rooted<AnyRef>> { loop {} });
+    assert!(f.typed::<(), Option<Rooted<AnyRef>>>(&store).is_ok());
+    let f = Func::wrap(&mut store, || -> ManuallyRooted<AnyRef> { loop {} });
+    assert!(f.typed::<(), ManuallyRooted<AnyRef>>(&store).is_ok());
+    let f = Func::wrap(&mut store, || -> Option<ManuallyRooted<AnyRef>> { loop {} });
+    assert!(f
+        .typed::<(), Option<ManuallyRooted<AnyRef>>>(&store)
+        .is_ok());
+    let f = Func::wrap(&mut store, || -> I31 { loop {} });
+    assert!(f.typed::<(), I31>(&store).is_ok());
+    let f = Func::wrap(&mut store, || -> Option<I31> { loop {} });
+    assert!(f.typed::<(), Option<I31>>(&store).is_ok());
+    let f = Func::wrap(&mut store, || -> Func { loop {} });
+    assert!(f.typed::<(), Func>(&store).is_ok());
     let f = Func::wrap(&mut store, || -> Option<Func> { loop {} });
     assert!(f.typed::<(), Option<Func>>(&store).is_ok());
 
@@ -654,8 +777,32 @@ fn get_from_wrapper() {
     assert!(f.typed::<f32, ()>(&store).is_ok());
     let f = Func::wrap(&mut store, |_: f64| {});
     assert!(f.typed::<f64, ()>(&store).is_ok());
-    let f = Func::wrap(&mut store, |_: Option<ExternRef>| {});
-    assert!(f.typed::<Option<ExternRef>, ()>(&store).is_ok());
+    let f = Func::wrap(&mut store, |_: Rooted<ExternRef>| {});
+    assert!(f.typed::<Rooted<ExternRef>, ()>(&store).is_ok());
+    let f = Func::wrap(&mut store, |_: Option<Rooted<ExternRef>>| {});
+    assert!(f.typed::<Option<Rooted<ExternRef>>, ()>(&store).is_ok());
+    let f = Func::wrap(&mut store, |_: ManuallyRooted<ExternRef>| {});
+    assert!(f.typed::<ManuallyRooted<ExternRef>, ()>(&store).is_ok());
+    let f = Func::wrap(&mut store, |_: Option<ManuallyRooted<ExternRef>>| {});
+    assert!(f
+        .typed::<Option<ManuallyRooted<ExternRef>>, ()>(&store)
+        .is_ok());
+    let f = Func::wrap(&mut store, |_: Rooted<AnyRef>| {});
+    assert!(f.typed::<Rooted<AnyRef>, ()>(&store).is_ok());
+    let f = Func::wrap(&mut store, |_: Option<Rooted<AnyRef>>| {});
+    assert!(f.typed::<Option<Rooted<AnyRef>>, ()>(&store).is_ok());
+    let f = Func::wrap(&mut store, |_: ManuallyRooted<AnyRef>| {});
+    assert!(f.typed::<ManuallyRooted<AnyRef>, ()>(&store).is_ok());
+    let f = Func::wrap(&mut store, |_: Option<ManuallyRooted<AnyRef>>| {});
+    assert!(f
+        .typed::<Option<ManuallyRooted<AnyRef>>, ()>(&store)
+        .is_ok());
+    let f = Func::wrap(&mut store, |_: I31| {});
+    assert!(f.typed::<I31, ()>(&store).is_ok());
+    let f = Func::wrap(&mut store, |_: Option<I31>| {});
+    assert!(f.typed::<Option<I31>, ()>(&store).is_ok());
+    let f = Func::wrap(&mut store, |_: Func| {});
+    assert!(f.typed::<Func, ()>(&store).is_ok());
     let f = Func::wrap(&mut store, |_: Option<Func>| {});
     assert!(f.typed::<Option<Func>, ()>(&store).is_ok());
 }
@@ -664,13 +811,13 @@ fn get_from_wrapper() {
 #[cfg_attr(miri, ignore)]
 fn get_from_signature() {
     let mut store = Store::<()>::default();
-    let ty = FuncType::new(None, None);
+    let ty = FuncType::new(store.engine(), None, None);
     let f = Func::new(&mut store, ty, |_, _, _| panic!());
     assert!(f.typed::<(), ()>(&store).is_ok());
     assert!(f.typed::<(), i32>(&store).is_err());
     assert!(f.typed::<i32, ()>(&store).is_err());
 
-    let ty = FuncType::new(Some(ValType::I32), Some(ValType::F64));
+    let ty = FuncType::new(store.engine(), Some(ValType::I32), Some(ValType::F64));
     let f = Func::new(&mut store, ty, |_, _, _| panic!());
     assert!(f.typed::<(), ()>(&store).is_err());
     assert!(f.typed::<(), i32>(&store).is_err());
@@ -678,10 +825,11 @@ fn get_from_signature() {
     assert!(f.typed::<i32, f64>(&store).is_ok());
 }
 
-#[test]
+#[wasmtime_test]
 #[cfg_attr(miri, ignore)]
-fn get_from_module() -> anyhow::Result<()> {
-    let mut store = Store::<()>::default();
+fn get_from_module(config: &mut Config) -> anyhow::Result<()> {
+    let engine = Engine::new(&config)?;
+    let mut store = Store::<()>::new(&engine, ());
     let module = Module::new(
         store.engine(),
         r#"
@@ -750,10 +898,11 @@ fn call_wrapped_func() -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[wasmtime_test]
 #[cfg_attr(miri, ignore)]
-fn caller_memory() -> anyhow::Result<()> {
-    let mut store = Store::<()>::default();
+fn caller_memory(config: &mut Config) -> anyhow::Result<()> {
+    let engine = Engine::new(config)?;
+    let mut store = Store::<()>::new(&engine, ());
     let f = Func::wrap(&mut store, |mut c: Caller<'_, ()>| {
         assert!(c.get_export("x").is_none());
         assert!(c.get_export("y").is_none());
@@ -820,7 +969,7 @@ fn caller_memory() -> anyhow::Result<()> {
 #[cfg_attr(miri, ignore)]
 fn func_write_nothing() -> anyhow::Result<()> {
     let mut store = Store::<()>::default();
-    let ty = FuncType::new(None, Some(ValType::I32));
+    let ty = FuncType::new(store.engine(), None, Some(ValType::I32));
     let f = Func::new(&mut store, ty, |_, _, _| Ok(()));
     let err = f.call(&mut store, &[], &mut [Val::I32(0)]).unwrap_err();
     assert!(err
@@ -829,9 +978,9 @@ fn func_write_nothing() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[test]
+#[wasmtime_test(wasm_features(reference_types))]
 #[cfg_attr(miri, ignore)]
-fn return_cross_store_value() -> anyhow::Result<()> {
+fn return_cross_store_value(config: &mut Config) -> anyhow::Result<()> {
     let _ = env_logger::try_init();
 
     let wasm = wat::parse_str(
@@ -843,8 +992,6 @@ fn return_cross_store_value() -> anyhow::Result<()> {
             )
         "#,
     )?;
-    let mut config = Config::new();
-    config.wasm_reference_types(true);
     let engine = Engine::new(&config)?;
     let module = Module::new(&engine, &wasm)?;
 
@@ -852,7 +999,7 @@ fn return_cross_store_value() -> anyhow::Result<()> {
     let mut store2 = Store::new(&engine, ());
 
     let store2_func = Func::wrap(&mut store2, || {});
-    let return_cross_store_func = Func::wrap(&mut store1, move || Some(store2_func.clone()));
+    let return_cross_store_func = Func::wrap(&mut store1, move || Some(store2_func));
 
     let instance = Instance::new(&mut store1, &module, &[return_cross_store_func.into()])?;
 
@@ -864,10 +1011,8 @@ fn return_cross_store_value() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[test]
-fn pass_cross_store_arg() -> anyhow::Result<()> {
-    let mut config = Config::new();
-    config.wasm_reference_types(true);
+#[wasmtime_test(wasm_features(reference_types))]
+fn pass_cross_store_arg(config: &mut Config) -> anyhow::Result<()> {
     let engine = Engine::new(&config)?;
 
     let mut store1 = Store::new(&engine, ());
@@ -878,11 +1023,7 @@ fn pass_cross_store_arg() -> anyhow::Result<()> {
 
     // Using regular `.call` fails with cross-Store arguments.
     assert!(store1_func
-        .call(
-            &mut store1,
-            &[Val::FuncRef(Some(store2_func.clone()))],
-            &mut []
-        )
+        .call(&mut store1, &[Val::FuncRef(Some(store2_func))], &mut [])
         .is_err());
 
     // And using `.get` followed by a function call also fails with cross-Store
@@ -902,22 +1043,21 @@ fn externref_signature_no_reference_types() -> anyhow::Result<()> {
     config.wasm_reference_types(false);
     let mut store = Store::new(&Engine::new(&config)?, ());
     Func::wrap(&mut store, |_: Option<Func>| {});
-    Func::new(
-        &mut store,
-        FuncType::new(
-            [ValType::FuncRef, ValType::ExternRef].iter().cloned(),
-            [ValType::FuncRef, ValType::ExternRef].iter().cloned(),
-        ),
-        |_, _, _| Ok(()),
+    let func_ty = FuncType::new(
+        store.engine(),
+        [ValType::FUNCREF, ValType::EXTERNREF].iter().cloned(),
+        [ValType::FUNCREF, ValType::EXTERNREF].iter().cloned(),
     );
+    Func::new(&mut store, func_ty, |_, _, _| Ok(()));
     Ok(())
 }
 
-#[test]
+#[wasmtime_test]
 #[cfg_attr(miri, ignore)]
-fn trampolines_always_valid() -> anyhow::Result<()> {
+fn trampolines_always_valid(config: &mut Config) -> anyhow::Result<()> {
     // Compile two modules up front
-    let mut store = Store::<()>::default();
+    let engine = Engine::new(&config)?;
+    let mut store = Store::<()>::new(&engine, ());
     let module1 = Module::new(store.engine(), "(module (import \"\" \"\" (func)))")?;
     let module2 = Module::new(store.engine(), "(module (func (export \"\")))")?;
     // Start instantiating the first module, but this will fail.
@@ -940,10 +1080,11 @@ fn trampolines_always_valid() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[test]
+#[wasmtime_test]
 #[cfg_attr(miri, ignore)]
-fn typed_multiple_results() -> anyhow::Result<()> {
-    let mut store = Store::<()>::default();
+fn typed_multiple_results(config: &mut Config) -> anyhow::Result<()> {
+    let engine = Engine::new(&config)?;
+    let mut store = Store::<()>::new(&engine, ());
     let module = Module::new(
         store.engine(),
         r#"
@@ -1004,7 +1145,8 @@ fn trap_doesnt_leak() -> anyhow::Result<()> {
     // test that `Func::new` is correct
     let canary2 = Canary::default();
     let dtor2_run = canary2.0.clone();
-    let f2 = Func::new(&mut store, FuncType::new(None, None), move |_, _, _| {
+    let func_ty = FuncType::new(store.engine(), None, None);
+    let f2 = Func::new(&mut store, func_ty, move |_, _, _| {
         let _ = &canary2;
         bail!("")
     });
@@ -1018,9 +1160,9 @@ fn trap_doesnt_leak() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[test]
+#[wasmtime_test]
 #[cfg_attr(miri, ignore)]
-fn wrap_multiple_results() -> anyhow::Result<()> {
+fn wrap_multiple_results(config: &mut Config) -> anyhow::Result<()> {
     fn test<T>(store: &mut Store<()>, t: T) -> anyhow::Result<()>
     where
         T: WasmRet
@@ -1049,7 +1191,8 @@ fn wrap_multiple_results() -> anyhow::Result<()> {
         Ok(())
     }
 
-    let mut store = Store::default();
+    let engine = Engine::new(&config)?;
+    let mut store = Store::new(&engine, ());
     // 0 element
     test(&mut store, ())?;
 
@@ -1183,10 +1326,10 @@ fn wrap_multiple_results() -> anyhow::Result<()> {
     }
 }
 
-#[test]
+#[wasmtime_test(wasm_features(reference_types))]
 #[cfg_attr(miri, ignore)]
-fn trampoline_for_declared_elem() -> anyhow::Result<()> {
-    let engine = Engine::default();
+fn trampoline_for_declared_elem(config: &mut Config) -> anyhow::Result<()> {
+    let engine = Engine::new(&config)?;
 
     let module = Module::new(
         &engine,
@@ -1211,10 +1354,11 @@ fn trampoline_for_declared_elem() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[test]
+#[wasmtime_test]
 #[cfg_attr(miri, ignore)]
-fn wasm_ty_roundtrip() -> Result<(), anyhow::Error> {
-    let mut store = Store::<()>::default();
+fn wasm_ty_roundtrip(config: &mut Config) -> Result<(), anyhow::Error> {
+    let engine = Engine::new(&config)?;
+    let mut store = Store::<()>::new(&engine, ());
     let debug = Func::wrap(
         &mut store,
         |a: i32, b: u32, c: f32, d: i64, e: u64, f: f64| {
@@ -1267,10 +1411,11 @@ fn wasm_ty_roundtrip() -> Result<(), anyhow::Error> {
     Ok(())
 }
 
-#[test]
+#[wasmtime_test]
 #[cfg_attr(miri, ignore)]
-fn typed_funcs_count_params_correctly_in_error_messages() -> anyhow::Result<()> {
-    let mut store = Store::<()>::default();
+fn typed_funcs_count_params_correctly_in_error_messages(config: &mut Config) -> anyhow::Result<()> {
+    let engine = Engine::new(&config)?;
+    let mut store = Store::<()>::new(&engine, ());
     let module = Module::new(
         store.engine(),
         r#"
@@ -1286,14 +1431,14 @@ fn typed_funcs_count_params_correctly_in_error_messages() -> anyhow::Result<()>
     match instance.get_typed_func::<(), ()>(&mut store, "f") {
         Ok(_) => panic!("should be wrong signature"),
         Err(e) => {
-            let msg = format!("{:?}", e);
+            let msg = format!("{e:?}");
             assert!(dbg!(msg).contains("expected 0 types, found 2"))
         }
     }
     match instance.get_typed_func::<(i32,), ()>(&mut store, "f") {
         Ok(_) => panic!("should be wrong signature"),
         Err(e) => {
-            let msg = format!("{:?}", e);
+            let msg = format!("{e:?}");
             assert!(dbg!(msg).contains("expected 1 types, found 2"))
         }
     }
@@ -1302,7 +1447,7 @@ fn typed_funcs_count_params_correctly_in_error_messages() -> anyhow::Result<()>
     match instance.get_typed_func::<(i32, i32, i32), ()>(&mut store, "f") {
         Ok(_) => panic!("should be wrong signature"),
         Err(e) => {
-            let msg = format!("{:?}", e);
+            let msg = format!("{e:?}");
             assert!(dbg!(msg).contains("expected 3 types, found 2"))
         }
     }
@@ -1310,10 +1455,11 @@ fn typed_funcs_count_params_correctly_in_error_messages() -> anyhow::Result<()>
     Ok(())
 }
 
-#[test]
+#[wasmtime_test(wasm_features(reference_types))]
 #[cfg_attr(miri, ignore)]
-fn calls_with_funcref_and_externref() -> anyhow::Result<()> {
-    let mut store = Store::<()>::default();
+fn calls_with_funcref_and_externref(config: &mut Config) -> anyhow::Result<()> {
+    let engine = Engine::new(&config)?;
+    let mut store = Store::<()>::new(&engine, ());
     let module = Module::new(
         store.engine(),
         r#"
@@ -1334,12 +1480,12 @@ fn calls_with_funcref_and_externref() -> anyhow::Result<()> {
     linker.func_wrap(
         "",
         "witness",
-        |mut caller: Caller<'_, ()>, func: Option<Func>, externref: Option<ExternRef>| {
+        |mut caller: Caller<'_, ()>, func: Option<Func>, externref: Option<Rooted<ExternRef>>| {
             if func.is_some() {
                 assert_my_funcref(&mut caller, func.as_ref())?;
             }
             if externref.is_some() {
-                assert_my_externref(externref.as_ref());
+                assert_my_externref(&caller, externref);
             }
             Ok(())
         },
@@ -1347,13 +1493,13 @@ fn calls_with_funcref_and_externref() -> anyhow::Result<()> {
     let instance = linker.instantiate(&mut store, &module)?;
 
     let typed = instance
-        .get_typed_func::<(Option<Func>, Option<ExternRef>), (Option<ExternRef>, Option<Func>)>(
+        .get_typed_func::<(Option<Func>, Option<Rooted<ExternRef>>), (Option<Rooted<ExternRef>>, Option<Func>)>(
             &mut store, "f",
         )?;
     let untyped = typed.func();
 
     let my_funcref = Func::wrap(&mut store, || 100u32);
-    let my_externref = ExternRef::new(99u32);
+    let my_externref = ExternRef::new(&mut store, 99u32)?;
     let mut results = [Val::I32(0), Val::I32(0)];
 
     fn assert_my_funcref(mut store: impl AsContextMut, func: Option<&Func>) -> Result<()> {
@@ -1362,8 +1508,11 @@ fn calls_with_funcref_and_externref() -> anyhow::Result<()> {
         assert_eq!(func.typed::<(), u32>(&store)?.call(&mut store, ())?, 100);
         Ok(())
     }
-    fn assert_my_externref(externref: Option<&ExternRef>) {
-        assert_eq!(externref.unwrap().data().downcast_ref(), Some(&99u32));
+    fn assert_my_externref(store: impl AsContext, externref: Option<Rooted<ExternRef>>) {
+        assert_eq!(
+            externref.unwrap().data(&store).unwrap().downcast_ref(),
+            Some(&99u32)
+        );
     }
 
     // funcref=null, externref=null
@@ -1391,43 +1540,362 @@ fn calls_with_funcref_and_externref() -> anyhow::Result<()> {
     assert_my_funcref(&mut store, results[1].unwrap_funcref())?;
 
     // funcref=null, externref=Some
-    let (a, b) = typed.call(&mut store, (None, Some(my_externref.clone())))?;
-    assert_my_externref(a.as_ref());
+    let (a, b) = typed.call(&mut store, (None, Some(my_externref)))?;
+    assert_my_externref(&store, a);
     assert!(b.is_none());
     untyped.call(
         &mut store,
-        &[
-            Val::FuncRef(None),
-            Val::ExternRef(Some(my_externref.clone())),
-        ],
+        &[Val::FuncRef(None), Val::ExternRef(Some(my_externref))],
         &mut results,
     )?;
-    assert_my_externref(results[0].unwrap_externref().as_ref());
+    assert_my_externref(&store, results[0].unwrap_externref().copied());
     assert!(results[1].unwrap_funcref().is_none());
 
     // funcref=Some, externref=Some
-    let (a, b) = typed.call(&mut store, (Some(my_funcref), Some(my_externref.clone())))?;
-    assert_my_externref(a.as_ref());
+    let (a, b) = typed.call(&mut store, (Some(my_funcref), Some(my_externref)))?;
+    assert_my_externref(&store, a);
     assert_my_funcref(&mut store, b.as_ref())?;
     untyped.call(
         &mut store,
         &[
             Val::FuncRef(Some(my_funcref)),
-            Val::ExternRef(Some(my_externref.clone())),
+            Val::ExternRef(Some(my_externref)),
         ],
         &mut results,
     )?;
-    assert_my_externref(results[0].unwrap_externref().as_ref());
+    assert_my_externref(&store, results[0].unwrap_externref().copied());
     assert_my_funcref(&mut store, results[1].unwrap_funcref())?;
 
     Ok(())
 }
 
+#[wasmtime_test(wasm_features(function_references))]
+#[cfg_attr(miri, ignore)]
+fn typed_concrete_param(config: &mut Config) -> anyhow::Result<()> {
+    let engine = Engine::new(&config)?;
+    let module = Module::new(
+        &engine,
+        r#"
+            (module
+                (type $t (func))
+                (func (export "f") (param (ref null $t)))
+            )
+        "#,
+    )?;
+    let mut store = Store::new(&engine, ());
+    let instance = Instance::new(&mut store, &module, &[])?;
+
+    let nop = Func::new(
+        &mut store,
+        FuncType::new(&engine, None, None),
+        |_caller, _params, _results| Ok(()),
+    );
+
+    let f = instance.get_func(&mut store, "f").unwrap();
+
+    // Can type with a subtype, which should avoid all dynamic type checks after
+    // successful construction.
+    let a = f.typed::<Option<NoFunc>, ()>(&store)?;
+    a.call(&mut store, None)?;
+    // NB: Cannot call with Some(_) as `NoFunc` is uninhabited.
+
+    // Can call `typed` with a supertype, falling back to dynamic type checks on
+    // each call.
+    let a = f.typed::<Option<Func>, ()>(&store)?;
+    a.call(&mut store, None)?;
+    a.call(&mut store, Some(nop))?;
+    let e = a.call(&mut store, Some(f)).expect_err(
+        "should return an error because while we did pass an instance of \
+         `Option<Func>`, it was not an instance of `(ref null $t)`",
+    );
+    let e = format!("{e:?}");
+    assert!(e.contains("argument type mismatch for reference to concrete type"));
+    assert!(e.contains(
+        "type mismatch: expected (type (func)), \
+         found (type (func (param (ref null (concrete func VMSharedTypeIndex(0))))))"
+    ));
+
+    // And dynamic checks also work with a non-nullable super type.
+    let a = f.typed::<Func, ()>(&store)?;
+    a.call(&mut store, nop)?;
+    let e = a.call(&mut store, f).expect_err(
+        "should return an error because while we did pass an instance of \
+         `Func`, it was not an instance of `(ref null $t)`",
+    );
+    let e = format!("{e:?}");
+    assert!(e.contains("argument type mismatch for reference to concrete type"));
+    assert!(e.contains(
+        "type mismatch: expected (type (func)), \
+         found (type (func (param (ref null (concrete func VMSharedTypeIndex(0))))))"
+    ));
+
+    // Calling `typed` with a type that is not a supertype nor a subtype fails
+    // the initial type check.
+    let e = f
+        .typed::<Option<Rooted<ExternRef>>, ()>(&store)
+        .err()
+        .unwrap();
+    let e = format!("{e:?}");
+    assert!(e.contains("type mismatch with parameters"));
+    assert!(e.contains("type mismatch: expected func, found extern"));
+
+    Ok(())
+}
+
+#[wasmtime_test(wasm_features(function_references))]
+#[cfg_attr(miri, ignore)]
+fn typed_concrete_result(config: &mut Config) -> anyhow::Result<()> {
+    let engine = Engine::new(&config)?;
+    let module = Module::new(
+        &engine,
+        r#"
+            (module
+                (type $t (func))
+                (func $nop)
+                (elem declare func $nop)
+                (func (export "f") (result (ref $t))
+                    ref.func $nop
+                )
+            )
+        "#,
+    )?;
+    let mut store = Store::new(&engine, ());
+    let instance = Instance::new(&mut store, &module, &[])?;
+
+    let f = instance.get_func(&mut store, "f").unwrap();
+
+    // Can type `f` with a supertype of the declared result type, and we get the
+    // expected return value.
+    let a = f.typed::<(), Func>(&store)?;
+    let g = a.call(&mut store, ())?;
+    g.typed::<(), ()>(&store)?.call(&mut store, ())?;
+
+    // Also works with a nullable supertype.
+    let a = f.typed::<(), Option<Func>>(&store)?;
+    let g = a.call(&mut store, ())?;
+    g.unwrap().typed::<(), ()>(&store)?.call(&mut store, ())?;
+
+    // But we can't claim that `f` returns a particular subtype of its actual
+    // return type.
+    let e = f.typed::<(), NoFunc>(&store).err().unwrap();
+    let e = format!("{e:?}");
+    assert!(e.contains("type mismatch with results"));
+    assert!(e.contains(
+        "type mismatch: expected (ref nofunc), found (ref (concrete func VMSharedTypeIndex(0)))"
+    ));
+
+    // Nor some unrelated type that it is neither a subtype or supertype of.
+    let e = f.typed::<(), Rooted<ExternRef>>(&store).err().unwrap();
+    let e = format!("{e:?}");
+    assert!(e.contains("type mismatch with results"));
+    assert!(e.contains(
+        "type mismatch: expected (ref extern), found (ref (concrete func VMSharedTypeIndex(0)))"
+    ));
+
+    Ok(())
+}
+
 #[test]
 #[cfg_attr(miri, ignore)]
-#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
-fn typed_v128() -> anyhow::Result<()> {
+fn wrap_subtype_param() -> anyhow::Result<()> {
     let mut store = Store::<()>::default();
+    let f = Func::wrap(&mut store, |_caller: Caller<'_, ()>, _: Option<Func>| {
+        // No-op.
+    });
+
+    // Precise type.
+    let a = f.typed::<Option<Func>, ()>(&store)?;
+    a.call(&mut store, None)?;
+    a.call(&mut store, Some(f))?;
+
+    // Subtype via heap type.
+    let a = f.typed::<Option<NoFunc>, ()>(&store)?;
+    a.call(&mut store, None)?;
+
+    // Subtype via non-null.
+    let a = f.typed::<Func, ()>(&store)?;
+    a.call(&mut store, f)?;
+
+    Ok(())
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn wrap_supertype_result() -> anyhow::Result<()> {
+    let mut store = Store::<()>::default();
+    let f = Func::wrap(&mut store, |_caller: Caller<'_, ()>| -> NoFunc {
+        unreachable!()
+    });
+
+    // Precise type.
+    let _ = f.typed::<(), NoFunc>(&store)?;
+
+    // Supertype via heap type.
+    let _ = f.typed::<(), Func>(&store)?;
+
+    // Supertype via nullability.
+    let _ = f.typed::<(), Option<NoFunc>>(&store)?;
+
+    Ok(())
+}
+
+#[wasmtime_test(wasm_features(function_references))]
+#[cfg_attr(miri, ignore)]
+fn call_wasm_passing_subtype_func_param(config: &mut Config) -> anyhow::Result<()> {
+    config.wasm_function_references(true);
+    let engine = Engine::new(&config)?;
+    let mut store = Store::new(&engine, ());
+
+    let module = Module::new(
+        &engine,
+        r#"
+            (module
+                (type $ty (func (result funcref)))
+                (func (export "f") (param (ref null $ty)) (result funcref)
+                    ;; Return null if the funcref is null.
+                    ref.null func
+                    local.get 0
+                    ref.is_null
+                    br_if 0
+                    drop
+
+                    ;; Otherwise, call it.
+                    local.get 0
+                    call_ref $ty
+                )
+            )
+        "#,
+    )?;
+
+    let instance = Instance::new(&mut store, &module, &[])?;
+    let f = instance.get_func(&mut store, "f").unwrap();
+
+    let g_ty = FuncType::new(&engine, None, Some(ValType::I32));
+    let g = Func::new(&mut store, g_ty.clone(), |_caller, _params, results| {
+        results[0] = Val::I32(0x1234_5678);
+        Ok(())
+    });
+
+    // h's type is a subtype of the Wasm-defined `$ty`:
+    //
+    //     (func (result (ref null g_ty))) <: (func (result funcref))
+    let h_ty = FuncType::new(
+        &engine,
+        None,
+        Some(ValType::Ref(RefType::new(
+            true,
+            HeapType::ConcreteFunc(g_ty),
+        ))),
+    );
+    let h = Func::new(&mut store, h_ty, move |_caller, _params, results| {
+        results[0] = Val::FuncRef(Some(g));
+        Ok(())
+    });
+
+    // Array call, passing in a subtype of the expected parameter.
+
+    let mut results = vec![Val::I32(0)];
+    f.call(&mut store, &[Val::null_func_ref()], &mut results)?;
+    assert!(results[0].unwrap_func_ref().is_none());
+
+    f.call(&mut store, &[h.into()], &mut results)?;
+    let g = results[0];
+    let g = g.unwrap_func_ref().unwrap();
+    g.call(&mut store, &[], &mut results)?;
+    assert_eq!(results[0].unwrap_i32(), 0x1234_5678);
+
+    // Native call, passing in a subtype of the expected parameter.
+
+    let f = f.typed::<Option<Func>, Option<Func>>(&store)?;
+    let r = f.call(&mut store, None)?;
+    assert!(r.is_none());
+
+    let g = f.call(&mut store, Some(h))?;
+    let g = g.unwrap().typed::<(), u32>(&mut store)?;
+    let x = g.call(&mut store, ())?;
+    assert_eq!(x, 0x1234_5678);
+
+    Ok(())
+}
+
+#[wasmtime_test(wasm_features(gc, function_references))]
+#[cfg_attr(miri, ignore)]
+fn call_wasm_getting_subtype_func_return(config: &mut Config) -> anyhow::Result<()> {
+    let engine = Engine::new(&config)?;
+    let mut store = Store::new(&engine, ());
+
+    let module = Module::new(
+        &engine,
+        r#"
+            (module
+                (type $ty (func (result funcref)))
+
+                (func $a (result i32)
+                    i32.const 0x12345678
+                )
+
+                (func $b (result funcref)
+                    ref.func $a
+                )
+
+                (elem declare func $a $b)
+
+                ;; Returns a `(ref null nofunc)` if called with `0`, otherwise
+                ;; returns `(ref null $ty)`, both of which are subtypes of
+                ;; `funcref`.
+                (func (export "f") (param i32) (result funcref)
+                    block
+                        local.get 0
+                        br_if 0
+                        ref.null nofunc
+                        return
+                    end
+                    ref.func $b
+                )
+            )
+        "#,
+    )?;
+
+    let instance = Instance::new(&mut store, &module, &[])?;
+    let f = instance.get_func(&mut store, "f").unwrap();
+
+    // Array call, receiving a subtype of the expected result.
+
+    let mut results = vec![Val::I32(0)];
+    f.call(&mut store, &[Val::I32(0)], &mut results)?;
+    assert!(results[0].unwrap_func_ref().is_none());
+
+    f.call(&mut store, &[Val::I32(1)], &mut results)?;
+    let b = results[0];
+    let b = b.unwrap_func_ref().unwrap();
+    b.call(&mut store, &[], &mut results)?;
+    let a = results[0];
+    let a = a.unwrap_func_ref().unwrap();
+    a.call(&mut store, &[], &mut results)?;
+    assert_eq!(results[0].unwrap_i32(), 0x1234_5678);
+
+    // Native call, receiving a subtype of the expected result.
+
+    let f = f.typed::<u32, Option<Func>>(&store)?;
+    let r = f.call(&mut store, 0)?;
+    assert!(r.is_none());
+
+    let b = f.call(&mut store, 1)?;
+    let b = b.unwrap().typed::<(), Option<Func>>(&store)?;
+    let a = b.call(&mut store, ())?;
+    let a = a.unwrap().typed::<(), u32>(&store)?;
+    let x = a.call(&mut store, ())?;
+    assert_eq!(x, 0x1234_5678);
+
+    Ok(())
+}
+
+#[wasmtime_test(wasm_features(simd))]
+#[cfg_attr(miri, ignore)]
+#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
+fn typed_v128(config: &mut Config) -> anyhow::Result<()> {
+    let engine = Engine::new(&config)?;
+    let mut store = Store::<()>::new(&engine, ());
     let module = Module::new(
         store.engine(),
         r#"
@@ -1492,11 +1960,12 @@ fn typed_v128() -> anyhow::Result<()> {
     Ok(())
 }
 
-#[test]
+#[wasmtime_test]
 #[cfg_attr(miri, ignore)]
 #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
-fn typed_v128_imports() -> anyhow::Result<()> {
-    let mut store = Store::<()>::default();
+fn typed_v128_imports(config: &mut Config) -> anyhow::Result<()> {
+    let engine = Engine::new(&config)?;
+    let mut store = Store::<()>::new(&engine, ());
     let module = Module::new(
         store.engine(),
         r#"
@@ -1599,3 +2068,179 @@ fn typed_v128_imports() -> anyhow::Result<()> {
 
     Ok(())
 }
+
+#[wasmtime_test(wasm_features(function_references, gc))]
+#[cfg_attr(miri, ignore)]
+fn wrap_and_typed_i31ref(config: &mut Config) -> Result<()> {
+    let engine = Engine::new(&config)?;
+    let mut store = Store::new(&engine, ());
+
+    static HITS: AtomicUsize = AtomicUsize::new(0);
+    let mut linker = Linker::new(&engine);
+    linker.func_wrap("env", "i31ref", |x: Option<I31>| -> Option<I31> {
+        assert_eq!(HITS.fetch_add(1, Ordering::SeqCst), 0);
+        x
+    })?;
+    linker.func_wrap("env", "ref-i31", |x: I31| -> I31 {
+        assert_eq!(HITS.fetch_add(1, Ordering::SeqCst), 1);
+        x
+    })?;
+
+    let module = Module::new(
+        &engine,
+        r#"
+            (module
+                (import "env" "i31ref" (func (param i31ref) (result i31ref)))
+                (import "env" "ref-i31" (func (param (ref i31)) (result (ref i31))))
+
+                (func (export "i31ref") (param i31ref) (result i31ref)
+                    local.get 0
+                    call 0
+                )
+
+                (func (export "ref-i31") (param (ref i31)) (result (ref i31))
+                    local.get 0
+                    call 1
+                )
+            )
+        "#,
+    )?;
+
+    let instance = linker.instantiate(&mut store, &module)?;
+
+    let i31ref = instance.get_typed_func::<Option<I31>, Option<I31>>(&mut store, "i31ref")?;
+    let x = i31ref.call(&mut store, Some(I31::wrapping_u32(42)))?;
+    assert_eq!(x, Some(I31::wrapping_u32(42)));
+
+    let ref_i31 = instance.get_typed_func::<I31, I31>(&mut store, "ref-i31")?;
+    let x = ref_i31.call(&mut store, I31::wrapping_u32(0x1234))?;
+    assert_eq!(x, I31::wrapping_u32(0x1234));
+
+    assert_eq!(HITS.load(Ordering::SeqCst), 2);
+    Ok(())
+}
+
+#[wasmtime_test(wasm_features(function_references, gc))]
+fn call_func_with_funcref_both_typed_and_untyped(config: &mut Config) -> Result<()> {
+    let engine = Engine::new(&config)?;
+    let mut store = Store::new(&engine, ());
+
+    let f1 = Func::wrap(&mut store, |_: Option<Func>| {});
+    let f2 = Func::wrap(&mut store, || {});
+
+    f1.typed::<Func, ()>(&mut store)?.call(&mut store, f2)?;
+    f1.call(&mut store, &[Val::FuncRef(Some(f2))], &mut [])?;
+    Ok(())
+}
+
+#[wasmtime_test(wasm_features(function_references, gc))]
+#[cfg_attr(miri, ignore)]
+fn wasm_to_host_trampolines_and_subtyping(config: &mut Config) -> Result<()> {
+    let _ = env_logger::try_init();
+
+    let engine = Engine::new(&config)?;
+
+    let module = Module::new(
+        &engine,
+        r#"
+            (module
+                (type $ty (func (result (ref null extern))))
+
+                (import "" "a" (func $imported_func (type $ty)))
+                (import "" "return_func" (func $return_func (result (ref $ty))))
+                (global $g (export "g") (mut (ref null $ty)) (ref.null $ty))
+                (table $t (export "t") 10 10 (ref null $ty))
+
+                (func (export "f")
+                    (drop (call $imported_func))
+                    (drop (call_ref $ty (call $return_func)))
+                    (drop (call_ref $ty (global.get $g)))
+                    (drop (call_ref $ty (table.get $t (i32.const 0))))
+                )
+            )
+        "#,
+    )?;
+
+    // This defines functions of type `(func (result (ref extern)))` and not of
+    // type `(func (result (ref null extern)))` that the Wasm imports. But it is
+    // still a subtype of the Wasm import's type, so we should be able to use
+    // the Wasm's precompiled trampolines with this host function.
+    //
+    // But this means we also need to look up the trampoline by the caller's
+    // type, rather than the callee's type.
+    //
+    // So take each kind of function we can define, and give it to Wasm in every
+    // way that Wasm can receive a function, and make sure we find the correct
+    // trampolines in all cases and everything works.
+    //
+    // Note that we create multiple versions of the same function by calling
+    // these constructors multiple times in the loop below. This is to avoid the
+    // scenario where we reuse the function, the first time it is exposed to
+    // Wasm its trampoline is filled in, and then all subsequent uses don't
+    // actually exercise their associated code paths for finding and
+    // initializing their trampoline.
+    let func_ty = FuncType::new(&engine, [], [RefType::new(false, HeapType::Extern).into()]);
+    let func_ctors: Vec<Box<dyn Fn(&mut Store<_>) -> Func>> = vec![
+        Box::new(|store| {
+            Func::wrap(store, |mut caller: Caller<'_, ()>| {
+                ExternRef::new(&mut caller, 100)
+            })
+        }),
+        Box::new(|store| {
+            Func::new(
+                store,
+                func_ty.clone(),
+                |mut caller: Caller<'_, ()>, _args, results| {
+                    results[0] = ExternRef::new(&mut caller, 200)?.into();
+                    Ok(())
+                },
+            )
+        }),
+    ];
+
+    let return_func_ty = module.imports().nth(1).unwrap().ty().unwrap_func().clone();
+
+    for make_func in func_ctors {
+        let mut store = Store::new(&engine, ());
+
+        let imported_func = make_func(&mut store);
+        assert!(FuncType::eq(&imported_func.ty(&store), &func_ty));
+
+        let returned_func = make_func(&mut store);
+        assert!(FuncType::eq(&returned_func.ty(&store), &func_ty));
+
+        let return_func = Func::new(
+            &mut store,
+            return_func_ty.clone(),
+            move |_caller, _args, results| {
+                results[0] = returned_func.into();
+                Ok(())
+            },
+        );
+
+        let instance = Instance::new(
+            &mut store,
+            &module,
+            &[imported_func.into(), return_func.into()],
+        )?;
+
+        let g = make_func(&mut store);
+        assert!(FuncType::eq(&g.ty(&store), &func_ty));
+        instance
+            .get_global(&mut store, "g")
+            .unwrap()
+            .set(&mut store, g.into())?;
+
+        let t = make_func(&mut store);
+        assert!(FuncType::eq(&t.ty(&store), &func_ty));
+        instance
+            .get_table(&mut store, "t")
+            .unwrap()
+            .set(&mut store, 0, t.into())?;
+
+        let f = instance.get_typed_func::<(), ()>(&mut store, "f")?;
+        f.call(&mut store, ())?;
+    }
+
+    Ok(())
+}
diff --git a/tests/all/funcref.rs b/tests/all/funcref.rs
index eab2d593927f..09fc5f727ec4 100644
--- a/tests/all/funcref.rs
+++ b/tests/all/funcref.rs
@@ -23,15 +23,11 @@ fn pass_funcref_in_and_out_of_wasm() -> anyhow::Result<()> {
     // Pass in a non-null funcref.
     {
         let mut results = [Val::I32(0)];
-        func.call(
-            &mut store,
-            &[Val::FuncRef(Some(func.clone()))],
-            &mut results,
-        )?;
+        func.call(&mut store, &[Val::FuncRef(Some(func))], &mut results)?;
 
         // Can't compare `Func` for equality, so this is the best we can do here.
         let result_func = results[0].unwrap_funcref().unwrap();
-        assert_eq!(func.ty(&store), result_func.ty(&store));
+        assert!(FuncType::eq(&func.ty(&store), &result_func.ty(&store)));
     }
 
     // Pass in a null funcref.
@@ -50,14 +46,17 @@ fn pass_funcref_in_and_out_of_wasm() -> anyhow::Result<()> {
         let mut results = [Val::I32(0)];
         func.call(
             &mut store,
-            &[Val::FuncRef(Some(other_instance_func.clone()))],
+            &[Val::FuncRef(Some(other_instance_func))],
             &mut results,
         )?;
         assert_eq!(results.len(), 1);
 
         // Can't compare `Func` for equality, so this is the best we can do here.
         let result_func = results[0].unwrap_funcref().unwrap();
-        assert_eq!(other_instance_func.ty(&store), result_func.ty(&store));
+        assert!(FuncType::eq(
+            &other_instance_func.ty(&store),
+            &result_func.ty(&store),
+        ));
     }
 
     // Passing in a `funcref` from another store fails.
@@ -113,7 +112,7 @@ fn wrong_store() -> anyhow::Result<()> {
         let f1 = Func::wrap(&mut store1, move || {
             let _ = &set;
         });
-        let f2 = Func::wrap(&mut store2, move || Some(f1.clone()));
+        let f2 = Func::wrap(&mut store2, move || Some(f1));
         assert!(f2.call(&mut store2, &[], &mut []).is_err());
     }
     assert!(dropped.load(SeqCst));
@@ -141,14 +140,11 @@ fn func_new_returns_wrong_store() -> anyhow::Result<()> {
         let f1 = Func::wrap(&mut store1, move || {
             let _ = &set;
         });
-        let f2 = Func::new(
-            &mut store2,
-            FuncType::new(None, Some(ValType::FuncRef)),
-            move |_, _, results| {
-                results[0] = f1.clone().into();
-                Ok(())
-            },
-        );
+        let func_ty = FuncType::new(store2.engine(), None, Some(ValType::FUNCREF));
+        let f2 = Func::new(&mut store2, func_ty, move |_, _, results| {
+            results[0] = f1.into();
+            Ok(())
+        });
         assert!(f2.call(&mut store2, &[], &mut [Val::I32(0)]).is_err());
     }
     assert!(dropped.load(SeqCst));
diff --git a/tests/all/gc.rs b/tests/all/gc.rs
index c8ef7eaf1fbf..8dbfbb540d6e 100644
--- a/tests/all/gc.rs
+++ b/tests/all/gc.rs
@@ -14,17 +14,17 @@ impl Drop for SetFlagOnDrop {
 
 #[test]
 #[cfg_attr(miri, ignore)]
-fn smoke_test_gc() -> anyhow::Result<()> {
+fn smoke_test_gc_no_epochs() -> Result<()> {
     smoke_test_gc_impl(false)
 }
 
 #[test]
 #[cfg_attr(miri, ignore)]
-fn smoke_test_gc_epochs() -> anyhow::Result<()> {
+fn smoke_test_gc_yes_epochs() -> Result<()> {
     smoke_test_gc_impl(true)
 }
 
-fn smoke_test_gc_impl(use_epochs: bool) -> anyhow::Result<()> {
+fn smoke_test_gc_impl(use_epochs: bool) -> Result<()> {
     let (mut store, module) = ref_types_module(
         use_epochs,
         r#"
@@ -56,23 +56,26 @@ fn smoke_test_gc_impl(use_epochs: bool) -> anyhow::Result<()> {
     let func = instance.get_func(&mut store, "func").unwrap();
 
     let inner_dropped = Arc::new(AtomicBool::new(false));
-    let r = ExternRef::new(SetFlagOnDrop(inner_dropped.clone()));
+
     {
-        let args = [Val::I32(5), Val::ExternRef(Some(r.clone()))];
-        func.call(&mut store, &args, &mut [Val::I32(0)])?;
-    }
+        let mut scope = RootScope::new(&mut store);
 
-    // Still held alive by the `VMExternRefActivationsTable` (potentially in
-    // multiple slots within the table) and by this `r` local.
-    assert!(r.strong_count() >= 2);
+        let r = ExternRef::new(&mut scope, SetFlagOnDrop(inner_dropped.clone()))?;
+        {
+            let args = [Val::I32(5), Val::ExternRef(Some(r))];
+            func.call(&mut scope, &args, &mut [Val::I32(0)])?;
+        }
 
-    // Doing a GC should see that there aren't any `externref`s on the stack in
-    // Wasm frames anymore.
-    store.gc();
-    assert_eq!(r.strong_count(), 1);
+        // Doing a GC should see that there aren't any `externref`s on the stack in
+        // Wasm frames anymore.
+        scope.as_context_mut().gc();
 
-    // Dropping `r` should drop the inner `SetFlagOnDrop` value.
-    drop(r);
+        // But the scope should still be rooting `r`.
+        assert!(!inner_dropped.load(SeqCst));
+    }
+
+    // Exiting the scope and unrooting `r` should have dropped the inner
+    // `SetFlagOnDrop` value.
     assert!(inner_dropped.load(SeqCst));
 
     Ok(())
@@ -80,7 +83,7 @@ fn smoke_test_gc_impl(use_epochs: bool) -> anyhow::Result<()> {
 
 #[test]
 #[cfg_attr(miri, ignore)]
-fn wasm_dropping_refs() -> anyhow::Result<()> {
+fn wasm_dropping_refs() -> Result<()> {
     let (mut store, module) = ref_types_module(
         false,
         r#"
@@ -100,9 +103,10 @@ fn wasm_dropping_refs() -> anyhow::Result<()> {
     // NB: 4096 is greater than the initial `VMExternRefActivationsTable`
     // capacity, so this will trigger at least one GC.
     for _ in 0..4096 {
-        let r = ExternRef::new(CountDrops(num_refs_dropped.clone()));
+        let mut scope = RootScope::new(&mut store);
+        let r = ExternRef::new(&mut scope, CountDrops(num_refs_dropped.clone()))?;
         let args = [Val::ExternRef(Some(r))];
-        drop_ref.call(&mut store, &args, &mut [])?;
+        drop_ref.call(&mut scope, &args, &mut [])?;
     }
 
     assert!(num_refs_dropped.load(SeqCst) > 0);
@@ -124,7 +128,7 @@ fn wasm_dropping_refs() -> anyhow::Result<()> {
 
 #[test]
 #[cfg_attr(miri, ignore)]
-fn many_live_refs() -> anyhow::Result<()> {
+fn many_live_refs() -> Result<()> {
     let mut wat = r#"
         (module
             ;; Make new `externref`s.
@@ -166,21 +170,33 @@ fn many_live_refs() -> anyhow::Result<()> {
 
     let make_ref = Func::wrap(&mut store, {
         let live_refs = live_refs.clone();
-        move || Some(ExternRef::new(CountLiveRefs::new(live_refs.clone())))
+        move |mut caller: Caller<'_, _>| {
+            Ok(Some(ExternRef::new(
+                &mut caller,
+                CountLiveRefs::new(live_refs.clone()),
+            )?))
+        }
     });
 
-    let observe_ref = Func::wrap(&mut store, |r: Option<ExternRef>| {
-        let r = r.unwrap();
-        let r = r.data().downcast_ref::<CountLiveRefs>().unwrap();
-        assert!(r.live_refs.load(SeqCst) > 0);
-    });
+    let observe_ref = Func::wrap(
+        &mut store,
+        |caller: Caller<'_, _>, r: Option<Rooted<ExternRef>>| {
+            let r = r
+                .unwrap()
+                .data(&caller)
+                .unwrap()
+                .downcast_ref::<CountLiveRefs>()
+                .unwrap();
+            assert!(r.live_refs.load(SeqCst) > 0);
+        },
+    );
 
     let instance = Instance::new(&mut store, &module, &[make_ref.into(), observe_ref.into()])?;
     let many_live_refs = instance.get_func(&mut store, "many_live_refs").unwrap();
 
     many_live_refs.call(&mut store, &[], &mut [])?;
 
-    store.gc();
+    store.as_context_mut().gc();
     assert_eq!(live_refs.load(SeqCst), 0);
 
     return Ok(());
@@ -205,7 +221,7 @@ fn many_live_refs() -> anyhow::Result<()> {
 
 #[test]
 #[cfg_attr(miri, ignore)]
-fn drop_externref_via_table_set() -> anyhow::Result<()> {
+fn drop_externref_via_table_set() -> Result<()> {
     let (mut store, module) = ref_types_module(
         false,
         r#"
@@ -225,21 +241,27 @@ fn drop_externref_via_table_set() -> anyhow::Result<()> {
     let foo_is_dropped = Arc::new(AtomicBool::new(false));
     let bar_is_dropped = Arc::new(AtomicBool::new(false));
 
-    let foo = ExternRef::new(SetFlagOnDrop(foo_is_dropped.clone()));
-    let bar = ExternRef::new(SetFlagOnDrop(bar_is_dropped.clone()));
-
     {
-        let args = vec![Val::ExternRef(Some(foo))];
-        table_set.call(&mut store, &args, &mut [])?;
-    }
-    store.gc();
-    assert!(!foo_is_dropped.load(SeqCst));
-    assert!(!bar_is_dropped.load(SeqCst));
+        let mut scope = RootScope::new(&mut store);
 
-    {
-        let args = vec![Val::ExternRef(Some(bar))];
-        table_set.call(&mut store, &args, &mut [])?;
+        let foo = ExternRef::new(&mut scope, SetFlagOnDrop(foo_is_dropped.clone()))?;
+        let bar = ExternRef::new(&mut scope, SetFlagOnDrop(bar_is_dropped.clone()))?;
+
+        {
+            let args = vec![Val::ExternRef(Some(foo))];
+            table_set.call(&mut scope, &args, &mut [])?;
+        }
+
+        scope.as_context_mut().gc();
+        assert!(!foo_is_dropped.load(SeqCst));
+        assert!(!bar_is_dropped.load(SeqCst));
+
+        {
+            let args = vec![Val::ExternRef(Some(bar))];
+            table_set.call(&mut scope, &args, &mut [])?;
+        }
     }
+
     store.gc();
     assert!(foo_is_dropped.load(SeqCst));
     assert!(!bar_is_dropped.load(SeqCst));
@@ -253,7 +275,8 @@ fn drop_externref_via_table_set() -> anyhow::Result<()> {
 
 #[test]
 #[cfg_attr(miri, ignore)]
-fn global_drops_externref() -> anyhow::Result<()> {
+fn global_drops_externref() -> Result<()> {
+    let _ = env_logger::try_init();
     test_engine(&Engine::default())?;
 
     if !skip_pooling_allocator_tests() {
@@ -264,13 +287,13 @@ fn global_drops_externref() -> anyhow::Result<()> {
 
     return Ok(());
 
-    fn test_engine(engine: &Engine) -> anyhow::Result<()> {
+    fn test_engine(engine: &Engine) -> Result<()> {
         let mut store = Store::new(&engine, ());
         let flag = Arc::new(AtomicBool::new(false));
-        let externref = ExternRef::new(SetFlagOnDrop(flag.clone()));
+        let externref = ExternRef::new(&mut store, SetFlagOnDrop(flag.clone()))?;
         Global::new(
             &mut store,
-            GlobalType::new(ValType::ExternRef, Mutability::Const),
+            GlobalType::new(ValType::EXTERNREF, Mutability::Const),
             externref.into(),
         )?;
         drop(store);
@@ -291,9 +314,9 @@ fn global_drops_externref() -> anyhow::Result<()> {
             "#,
         )?;
         let instance = Instance::new(&mut store, &module, &[])?;
-        let run = instance.get_typed_func::<Option<ExternRef>, ()>(&mut store, "run")?;
+        let run = instance.get_typed_func::<Option<Rooted<ExternRef>>, ()>(&mut store, "run")?;
         let flag = Arc::new(AtomicBool::new(false));
-        let externref = ExternRef::new(SetFlagOnDrop(flag.clone()));
+        let externref = ExternRef::new(&mut store, SetFlagOnDrop(flag.clone()))?;
         run.call(&mut store, Some(externref))?;
         drop(store);
         assert!(flag.load(SeqCst));
@@ -303,7 +326,8 @@ fn global_drops_externref() -> anyhow::Result<()> {
 
 #[test]
 #[cfg_attr(miri, ignore)]
-fn table_drops_externref() -> anyhow::Result<()> {
+fn table_drops_externref() -> Result<()> {
+    let _ = env_logger::try_init();
     test_engine(&Engine::default())?;
 
     if !skip_pooling_allocator_tests() {
@@ -314,13 +338,13 @@ fn table_drops_externref() -> anyhow::Result<()> {
 
     return Ok(());
 
-    fn test_engine(engine: &Engine) -> anyhow::Result<()> {
+    fn test_engine(engine: &Engine) -> Result<()> {
         let mut store = Store::new(&engine, ());
         let flag = Arc::new(AtomicBool::new(false));
-        let externref = ExternRef::new(SetFlagOnDrop(flag.clone()));
+        let externref = ExternRef::new(&mut store, SetFlagOnDrop(flag.clone()))?;
         Table::new(
             &mut store,
-            TableType::new(ValType::ExternRef, 1, None),
+            TableType::new(RefType::EXTERNREF, 1, None),
             externref.into(),
         )?;
         drop(store);
@@ -342,9 +366,9 @@ fn table_drops_externref() -> anyhow::Result<()> {
         "#,
         )?;
         let instance = Instance::new(&mut store, &module, &[])?;
-        let run = instance.get_typed_func::<Option<ExternRef>, ()>(&mut store, "run")?;
+        let run = instance.get_typed_func::<Option<Rooted<ExternRef>>, ()>(&mut store, "run")?;
         let flag = Arc::new(AtomicBool::new(false));
-        let externref = ExternRef::new(SetFlagOnDrop(flag.clone()));
+        let externref = ExternRef::new(&mut store, SetFlagOnDrop(flag.clone()))?;
         run.call(&mut store, Some(externref))?;
         drop(store);
         assert!(flag.load(SeqCst));
@@ -353,72 +377,7 @@ fn table_drops_externref() -> anyhow::Result<()> {
 }
 
 #[test]
-#[cfg_attr(miri, ignore)]
-fn gee_i_sure_hope_refcounting_is_atomic() -> anyhow::Result<()> {
-    let mut config = Config::new();
-    config.wasm_reference_types(true);
-    config.epoch_interruption(true);
-    let engine = Engine::new(&config)?;
-    let mut store = Store::new(&engine, ());
-    let module = Module::new(
-        &engine,
-        r#"
-            (module
-                (global (mut externref) (ref.null extern))
-                (table 1 externref)
-
-                (func (export "run") (param externref)
-                    local.get 0
-                    global.set 0
-                    i32.const 0
-                    local.get 0
-                    table.set 0
-                    loop
-                        global.get 0
-                        global.set 0
-
-                        i32.const 0
-                        i32.const 0
-                        table.get
-                        table.set
-
-                        local.get 0
-                        call $f
-
-                        br 0
-                    end
-                )
-
-                (func $f (param externref))
-            )
-        "#,
-    )?;
-
-    let instance = Instance::new(&mut store, &module, &[])?;
-    let run = instance.get_typed_func::<Option<ExternRef>, ()>(&mut store, "run")?;
-
-    let flag = Arc::new(AtomicBool::new(false));
-    let externref = ExternRef::new(SetFlagOnDrop(flag.clone()));
-    let externref2 = externref.clone();
-
-    let child = std::thread::spawn(move || run.call(&mut store, Some(externref2)));
-
-    for _ in 0..10000 {
-        drop(externref.clone());
-    }
-    engine.increment_epoch();
-
-    assert!(child.join().unwrap().is_err());
-    assert!(!flag.load(SeqCst));
-    assert_eq!(externref.strong_count(), 1);
-    drop(externref);
-    assert!(flag.load(SeqCst));
-
-    Ok(())
-}
-
-#[test]
-fn global_init_no_leak() -> anyhow::Result<()> {
+fn global_init_no_leak() -> Result<()> {
     let (mut store, module) = ref_types_module(
         false,
         r#"
@@ -429,22 +388,23 @@ fn global_init_no_leak() -> anyhow::Result<()> {
         "#,
     )?;
 
-    let externref = ExternRef::new(());
+    let flag = Arc::new(AtomicBool::new(false));
+    let externref = ExternRef::new(&mut store, SetFlagOnDrop(flag.clone()))?;
     let global = Global::new(
         &mut store,
-        GlobalType::new(ValType::ExternRef, Mutability::Const),
-        externref.clone().into(),
+        GlobalType::new(ValType::EXTERNREF, Mutability::Const),
+        externref.into(),
     )?;
     Instance::new(&mut store, &module, &[global.into()])?;
     drop(store);
-    assert_eq!(externref.strong_count(), 1);
+    assert!(flag.load(SeqCst));
 
     Ok(())
 }
 
 #[test]
 #[cfg_attr(miri, ignore)]
-fn no_gc_middle_of_args() -> anyhow::Result<()> {
+fn no_gc_middle_of_args() -> Result<()> {
     let (mut store, module) = ref_types_module(
         false,
         r#"
@@ -470,23 +430,43 @@ fn no_gc_middle_of_args() -> anyhow::Result<()> {
     )?;
 
     let mut linker = Linker::new(store.engine());
-    linker.func_wrap("", "return_some", || {
-        (
-            Some(ExternRef::new("a".to_string())),
-            Some(ExternRef::new("b".to_string())),
-            Some(ExternRef::new("c".to_string())),
-        )
+    linker.func_wrap("", "return_some", |mut caller: Caller<'_, _>| {
+        let a = Some(ExternRef::new(&mut caller, String::from("a"))?);
+        let b = Some(ExternRef::new(&mut caller, String::from("b"))?);
+        let c = Some(ExternRef::new(&mut caller, String::from("c"))?);
+        Ok((a, b, c))
     })?;
     linker.func_wrap(
         "",
         "take_some",
-        |a: Option<ExternRef>, b: Option<ExternRef>, c: Option<ExternRef>| {
+        |caller: Caller<'_, _>,
+         a: Option<Rooted<ExternRef>>,
+         b: Option<Rooted<ExternRef>>,
+         c: Option<Rooted<ExternRef>>| {
             let a = a.unwrap();
             let b = b.unwrap();
             let c = c.unwrap();
-            assert_eq!(a.data().downcast_ref::<String>().unwrap(), "a");
-            assert_eq!(b.data().downcast_ref::<String>().unwrap(), "b");
-            assert_eq!(c.data().downcast_ref::<String>().unwrap(), "c");
+            assert_eq!(
+                a.data(&caller)
+                    .expect("rooted")
+                    .downcast_ref::<String>()
+                    .expect("is string"),
+                "a"
+            );
+            assert_eq!(
+                b.data(&caller)
+                    .expect("rooted")
+                    .downcast_ref::<String>()
+                    .expect("is string"),
+                "b"
+            );
+            assert_eq!(
+                c.data(&caller)
+                    .expect("rooted")
+                    .downcast_ref::<String>()
+                    .expect("is string"),
+                "c"
+            );
         },
     )?;
 
@@ -498,12 +478,8 @@ fn no_gc_middle_of_args() -> anyhow::Result<()> {
 }
 
 #[test]
-#[cfg_attr(any(
-    miri,
-    // TODO(6530): s390x doesn't support tail calls yet.
-    target_arch = "s390x"
-), ignore)]
-fn gc_and_tail_calls_and_stack_arguments() -> anyhow::Result<()> {
+#[cfg_attr(miri, ignore)]
+fn gc_and_tail_calls_and_stack_arguments() -> Result<()> {
     // Test that GC refs in tail-calls' stack arguments get properly accounted
     // for in stack maps.
     //
@@ -622,23 +598,35 @@ fn gc_and_tail_calls_and_stack_arguments() -> anyhow::Result<()> {
     )?;
 
     let mut linker = Linker::new(store.engine());
-    linker.func_wrap("", "make_some", || {
-        (
-            Some(ExternRef::new("a".to_string())),
-            Some(ExternRef::new("b".to_string())),
-            Some(ExternRef::new("c".to_string())),
-        )
+    linker.func_wrap("", "make_some", |mut caller: Caller<'_, _>| {
+        Ok((
+            Some(ExternRef::new(&mut caller, "a".to_string())?),
+            Some(ExternRef::new(&mut caller, "b".to_string())?),
+            Some(ExternRef::new(&mut caller, "c".to_string())?),
+        ))
     })?;
     linker.func_wrap(
         "",
         "take_some",
-        |a: Option<ExternRef>, b: Option<ExternRef>, c: Option<ExternRef>| {
+        |caller: Caller<'_, _>,
+         a: Option<Rooted<ExternRef>>,
+         b: Option<Rooted<ExternRef>>,
+         c: Option<Rooted<ExternRef>>| {
             let a = a.unwrap();
             let b = b.unwrap();
             let c = c.unwrap();
-            assert_eq!(a.data().downcast_ref::<String>().unwrap(), "a");
-            assert_eq!(b.data().downcast_ref::<String>().unwrap(), "b");
-            assert_eq!(c.data().downcast_ref::<String>().unwrap(), "c");
+            assert_eq!(
+                a.data(&caller).unwrap().downcast_ref::<String>().unwrap(),
+                "a"
+            );
+            assert_eq!(
+                b.data(&caller).unwrap().downcast_ref::<String>().unwrap(),
+                "b"
+            );
+            assert_eq!(
+                c.data(&caller).unwrap().downcast_ref::<String>().unwrap(),
+                "c"
+            );
         },
     )?;
     linker.func_wrap("", "gc", |mut caller: Caller<()>| {
@@ -651,3 +639,230 @@ fn gc_and_tail_calls_and_stack_arguments() -> anyhow::Result<()> {
 
     Ok(())
 }
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn no_leak_with_global_get_elem_segment() -> anyhow::Result<()> {
+    let dropped = Arc::new(AtomicBool::new(false));
+
+    let engine = Engine::default();
+    let mut store = Store::new(&engine, ());
+    let module = Module::new(
+        &engine,
+        r#"
+            (module
+                (import "" "" (global $init externref))
+                (start $f)
+                (table $t 1 externref)
+                (elem $e externref (global.get $init))
+
+                (func $f
+                    i32.const 0
+                    i32.const 0
+                    i32.const 1
+                    table.init $t $e
+
+                    i32.const 0
+                    i32.const 0
+                    i32.const 1
+                    table.init $t $e
+                )
+            )
+        "#,
+    )?;
+
+    let externref = ExternRef::new(&mut store, SetFlagOnDrop(dropped.clone()))?;
+    let global = Global::new(
+        &mut store,
+        GlobalType::new(ValType::EXTERNREF, Mutability::Const),
+        externref.into(),
+    )?;
+
+    Instance::new(&mut store, &module, &[global.into()])?;
+
+    drop(store);
+
+    assert!(dropped.load(SeqCst));
+    Ok(())
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn table_init_with_externref_global_get() -> anyhow::Result<()> {
+    let dropped = Arc::new(AtomicBool::new(false));
+
+    let mut config = Config::new();
+    config.wasm_function_references(true);
+    let engine = Engine::new(&config)?;
+    let mut store = Store::new(&engine, ());
+    let module = Module::new(
+        &engine,
+        r#"
+            (module
+                (import "" "" (global $init externref))
+                (table $t 1 externref (global.get $init))
+            )
+        "#,
+    )?;
+
+    let externref = ExternRef::new(&mut store, SetFlagOnDrop(dropped.clone()))?;
+    let global = Global::new(
+        &mut store,
+        GlobalType::new(ValType::EXTERNREF, Mutability::Const),
+        externref.into(),
+    )?;
+
+    Instance::new(&mut store, &module, &[global.into()])?;
+
+    drop(store);
+
+    assert!(dropped.load(SeqCst));
+    Ok(())
+}
+
+#[test]
+fn rooted_gets_collected_after_scope_exit() -> Result<()> {
+    let mut store = Store::<()>::default();
+    let flag = Arc::new(AtomicBool::new(false));
+
+    {
+        let mut scope = RootScope::new(&mut store);
+        let _externref = ExternRef::new(&mut scope, SetFlagOnDrop(flag.clone()))?;
+
+        scope.as_context_mut().gc();
+        assert!(!flag.load(SeqCst), "not dropped when still rooted");
+    }
+
+    store.as_context_mut().gc();
+    assert!(flag.load(SeqCst), "dropped after being unrooted");
+
+    Ok(())
+}
+
+#[test]
+fn manually_rooted_gets_collected_after_unrooting() -> Result<()> {
+    let mut store = Store::<()>::default();
+    let flag = Arc::new(AtomicBool::new(false));
+
+    let externref = ExternRef::new_manually_rooted(&mut store, SetFlagOnDrop(flag.clone()))?;
+
+    store.gc();
+    assert!(!flag.load(SeqCst), "not dropped when still rooted");
+
+    externref.unroot(&mut store);
+    store.gc();
+    assert!(flag.load(SeqCst), "dropped after being unrooted");
+
+    Ok(())
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn round_trip_gc_ref_through_typed_wasm_func() -> Result<()> {
+    let mut store = Store::<()>::default();
+    let module = Module::new(
+        store.engine(),
+        r#"
+            (module
+                (import "" "" (func $gc))
+                (func (export "f") (param externref) (result externref)
+                    call $gc
+                    local.get 0
+                )
+            )
+        "#,
+    )?;
+    let gc = Func::wrap(&mut store, |mut caller: Caller<'_, _>| caller.gc());
+    let instance = Instance::new(&mut store, &module, &[gc.into()])?;
+    let f = instance
+        .get_typed_func::<Option<Rooted<ExternRef>>, Option<Rooted<ExternRef>>>(&mut store, "f")?;
+    let x1 = ExternRef::new(&mut store, 1234)?;
+    let x2 = f.call(&mut store, Some(x1))?.unwrap();
+    assert!(Rooted::ref_eq(&store, &x1, &x2)?);
+    Ok(())
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn round_trip_gc_ref_through_func_wrap() -> Result<()> {
+    let mut store = Store::<()>::default();
+    let f = Func::wrap(
+        &mut store,
+        |mut caller: Caller<'_, _>, x: Rooted<ExternRef>| {
+            caller.gc();
+            x
+        },
+    );
+    let f = f.typed::<Rooted<ExternRef>, Rooted<ExternRef>>(&store)?;
+    let x1 = ExternRef::new(&mut store, 1234)?;
+    let x2 = f.call(&mut store, x1)?;
+    assert!(Rooted::ref_eq(&store, &x1, &x2)?);
+    Ok(())
+}
+
+#[test]
+fn to_raw_from_raw_doesnt_leak() -> Result<()> {
+    let mut store = Store::<()>::default();
+    let flag = Arc::new(AtomicBool::new(false));
+
+    {
+        let mut scope = RootScope::new(&mut store);
+        let x = ExternRef::new(&mut scope, SetFlagOnDrop(flag.clone()))?;
+        let raw = unsafe { x.to_raw(&mut scope)? };
+        let _x = unsafe { ExternRef::from_raw(&mut scope, raw) };
+    }
+
+    store.gc();
+    assert!(flag.load(SeqCst));
+    Ok(())
+}
+
+#[test]
+fn table_fill_doesnt_leak() -> Result<()> {
+    let _ = env_logger::try_init();
+
+    let mut store = Store::<()>::default();
+    let flag = Arc::new(AtomicBool::new(false));
+
+    {
+        let mut scope = RootScope::new(&mut store);
+        let x = ExternRef::new(&mut scope, SetFlagOnDrop(flag.clone()))?;
+        let table = Table::new(
+            &mut scope,
+            TableType::new(RefType::EXTERNREF, 10, Some(10)),
+            x.into(),
+        )?;
+        table.fill(&mut scope, 0, Ref::Extern(None), 10)?;
+    }
+
+    store.gc();
+    assert!(flag.load(SeqCst));
+    Ok(())
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn table_copy_doesnt_leak() -> Result<()> {
+    let _ = env_logger::try_init();
+
+    let mut store = Store::<()>::default();
+    let flag = Arc::new(AtomicBool::new(false));
+
+    {
+        let mut scope = RootScope::new(&mut store);
+        let table = Table::new(
+            &mut scope,
+            TableType::new(RefType::EXTERNREF, 10, Some(10)),
+            Ref::Extern(None),
+        )?;
+
+        let x = ExternRef::new(&mut scope, SetFlagOnDrop(flag.clone()))?;
+        table.fill(&mut scope, 2, x.into(), 3)?;
+
+        Table::copy(&mut scope, &table, 0, &table, 5, 5)?;
+    }
+
+    store.gc();
+    assert!(flag.load(SeqCst));
+    Ok(())
+}
diff --git a/tests/all/globals.rs b/tests/all/globals.rs
index bfd18746568d..1fa2b214f1e2 100644
--- a/tests/all/globals.rs
+++ b/tests/all/globals.rs
@@ -102,3 +102,251 @@ fn v128() -> anyhow::Result<()> {
     assert_eq!(g.get(&mut store).v128(), Some(V128::from(1)));
     Ok(())
 }
+
+#[test]
+fn i31ref_global_new() -> Result<()> {
+    let mut config = Config::new();
+    config.wasm_function_references(true);
+    config.wasm_gc(true);
+
+    let engine = Engine::new(&config)?;
+    let mut store = Store::new(&engine, ());
+
+    for mutability in [Mutability::Const, Mutability::Var] {
+        for val in [
+            Some(AnyRef::from_i31(&mut store, I31::new_u32(42).unwrap())),
+            None,
+        ] {
+            Global::new(
+                &mut store,
+                GlobalType::new(ValType::I31REF, mutability),
+                val.into(),
+            )?;
+        }
+    }
+    Ok(())
+}
+
+#[test]
+fn i31ref_global_get() -> Result<()> {
+    let mut config = Config::new();
+    config.wasm_function_references(true);
+    config.wasm_gc(true);
+
+    let engine = Engine::new(&config)?;
+    let mut store = Store::new(&engine, ());
+
+    for mutability in [Mutability::Const, Mutability::Var] {
+        for val in [
+            Some(AnyRef::from_i31(&mut store, I31::new_u32(42).unwrap())),
+            None,
+        ] {
+            let val = Val::from(val);
+            let global = Global::new(
+                &mut store,
+                GlobalType::new(ValType::I31REF, mutability),
+                val,
+            )?;
+
+            let got = global.get(&mut store);
+
+            let val = val
+                .anyref()
+                .and_then(|a| a.and_then(|a| a.as_i31(&store).unwrap()));
+            let got = got
+                .anyref()
+                .and_then(|a| a.and_then(|a| a.as_i31(&store).unwrap()));
+
+            assert_eq!(val, got);
+        }
+    }
+    Ok(())
+}
+
+#[test]
+fn i31ref_global_set() -> Result<()> {
+    let mut config = Config::new();
+    config.wasm_function_references(true);
+    config.wasm_gc(true);
+
+    let engine = Engine::new(&config)?;
+    let mut store = Store::new(&engine, ());
+
+    for init in [
+        Some(AnyRef::from_i31(&mut store, I31::new_u32(42).unwrap())),
+        None,
+    ] {
+        for new_val in [
+            Some(AnyRef::from_i31(&mut store, I31::new_u32(36).unwrap())),
+            None,
+        ] {
+            let global = Global::new(
+                &mut store,
+                GlobalType::new(ValType::I31REF, Mutability::Var),
+                init.into(),
+            )?;
+
+            let new_val = Val::from(new_val);
+            global.set(&mut store, new_val)?;
+            let got = global.get(&mut store);
+
+            let new_val = new_val
+                .anyref()
+                .and_then(|a| a.and_then(|a| a.as_i31(&store).unwrap()));
+            let got = got
+                .anyref()
+                .and_then(|a| a.and_then(|a| a.as_i31(&store).unwrap()));
+
+            assert_eq!(new_val, got);
+        }
+    }
+    Ok(())
+}
+
+#[test]
+fn i31ref_global_ty() -> Result<()> {
+    let mut config = Config::new();
+    config.wasm_function_references(true);
+    config.wasm_gc(true);
+
+    let engine = Engine::new(&config)?;
+    let mut store = Store::new(&engine, ());
+
+    for mutability in [Mutability::Const, Mutability::Var] {
+        for val in [
+            Some(AnyRef::from_i31(&mut store, I31::new_u32(42).unwrap())),
+            None,
+        ] {
+            let expected_ty = GlobalType::new(ValType::I31REF, mutability);
+            let global = Global::new(&mut store, expected_ty.clone(), val.into())?;
+            let actual_ty = global.ty(&store);
+            assert_eq!(expected_ty.mutability(), actual_ty.mutability());
+            assert!(ValType::eq(expected_ty.content(), actual_ty.content()));
+        }
+    }
+    Ok(())
+}
+
+#[test]
+fn i31ref_as_anyref_global_new() -> Result<()> {
+    let mut config = Config::new();
+    config.wasm_function_references(true);
+    config.wasm_gc(true);
+
+    let engine = Engine::new(&config)?;
+    let mut store = Store::new(&engine, ());
+
+    for mutability in [Mutability::Const, Mutability::Var] {
+        for val in [
+            Some(AnyRef::from_i31(&mut store, I31::new_u32(42).unwrap())),
+            None,
+        ] {
+            Global::new(
+                &mut store,
+                GlobalType::new(ValType::ANYREF, mutability),
+                val.into(),
+            )?;
+        }
+    }
+    Ok(())
+}
+
+#[test]
+fn i31ref_as_anyref_global_get() -> Result<()> {
+    let mut config = Config::new();
+    config.wasm_function_references(true);
+    config.wasm_gc(true);
+
+    let engine = Engine::new(&config)?;
+    let mut store = Store::new(&engine, ());
+
+    for mutability in [Mutability::Const, Mutability::Var] {
+        for val in [
+            Some(AnyRef::from_i31(&mut store, I31::new_u32(42).unwrap())),
+            None,
+        ] {
+            let val = Val::from(val);
+            let global = Global::new(
+                &mut store,
+                GlobalType::new(ValType::ANYREF, mutability),
+                val,
+            )?;
+
+            let got = global.get(&mut store);
+
+            let val = val
+                .anyref()
+                .and_then(|a| a.and_then(|a| a.as_i31(&store).unwrap()));
+            let got = got
+                .anyref()
+                .and_then(|a| a.and_then(|a| a.as_i31(&store).unwrap()));
+
+            assert_eq!(val, got);
+        }
+    }
+    Ok(())
+}
+
+#[test]
+fn i31ref_as_anyref_global_set() -> Result<()> {
+    let mut config = Config::new();
+    config.wasm_function_references(true);
+    config.wasm_gc(true);
+
+    let engine = Engine::new(&config)?;
+    let mut store = Store::new(&engine, ());
+
+    for init in [
+        Some(AnyRef::from_i31(&mut store, I31::new_u32(42).unwrap())),
+        None,
+    ] {
+        for new_val in [
+            Some(AnyRef::from_i31(&mut store, I31::new_u32(36).unwrap())),
+            None,
+        ] {
+            let global = Global::new(
+                &mut store,
+                GlobalType::new(ValType::ANYREF, Mutability::Var),
+                init.into(),
+            )?;
+
+            let new_val = Val::from(new_val);
+            global.set(&mut store, new_val)?;
+            let got = global.get(&mut store);
+
+            let new_val = new_val
+                .anyref()
+                .and_then(|a| a.and_then(|a| a.as_i31(&store).unwrap()));
+            let got = got
+                .anyref()
+                .and_then(|a| a.and_then(|a| a.as_i31(&store).unwrap()));
+
+            assert_eq!(new_val, got);
+        }
+    }
+    Ok(())
+}
+
+#[test]
+fn i31ref_as_anyref_global_ty() -> Result<()> {
+    let mut config = Config::new();
+    config.wasm_function_references(true);
+    config.wasm_gc(true);
+
+    let engine = Engine::new(&config)?;
+    let mut store = Store::new(&engine, ());
+
+    for mutability in [Mutability::Const, Mutability::Var] {
+        for val in [
+            Some(AnyRef::from_i31(&mut store, I31::new_u32(42).unwrap())),
+            None,
+        ] {
+            let expected_ty = GlobalType::new(ValType::ANYREF, mutability);
+            let global = Global::new(&mut store, expected_ty.clone(), val.into())?;
+            let actual_ty = global.ty(&store);
+            assert_eq!(expected_ty.mutability(), actual_ty.mutability());
+            assert!(ValType::eq(expected_ty.content(), actual_ty.content()));
+        }
+    }
+    Ok(())
+}
diff --git a/tests/all/host_funcs.rs b/tests/all/host_funcs.rs
index 76033acd62ca..8a61c74a0398 100644
--- a/tests/all/host_funcs.rs
+++ b/tests/all/host_funcs.rs
@@ -1,8 +1,6 @@
-use anyhow::{bail, Result};
+use anyhow::bail;
 use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
 use wasmtime::*;
-use wasmtime_wasi::sync::WasiCtxBuilder;
-use wasmtime_wasi::I32Exit;
 
 #[test]
 #[should_panic = "cannot use `func_new_async` without enabling async support"]
@@ -12,7 +10,7 @@ fn async_required() {
     drop(linker.func_new_async(
         "",
         "",
-        FuncType::new(None, None),
+        FuncType::new(&engine, None, None),
         move |_caller, _params, _results| Box::new(async { Ok(()) }),
     ));
 }
@@ -31,7 +29,7 @@ fn wrap_func() -> Result<()> {
     linker.func_wrap("", "", || -> i64 { 0 })?;
     linker.func_wrap("m", "f", || -> f32 { 0.0 })?;
     linker.func_wrap("m2", "f", || -> f64 { 0.0 })?;
-    linker.func_wrap("m3", "", || -> Option<ExternRef> { None })?;
+    linker.func_wrap("m3", "", || -> Option<Rooted<ExternRef>> { None })?;
     linker.func_wrap("m3", "f", || -> Option<Func> { None })?;
 
     linker.func_wrap("", "f1", || -> Result<()> { loop {} })?;
@@ -39,7 +37,9 @@ fn wrap_func() -> Result<()> {
     linker.func_wrap("", "f3", || -> Result<i64> { loop {} })?;
     linker.func_wrap("", "f4", || -> Result<f32> { loop {} })?;
     linker.func_wrap("", "f5", || -> Result<f64> { loop {} })?;
-    linker.func_wrap("", "f6", || -> Result<Option<ExternRef>> { loop {} })?;
+    linker.func_wrap("", "f6", || -> Result<Option<Rooted<ExternRef>>> {
+        loop {}
+    })?;
     linker.func_wrap("", "f7", || -> Result<Option<Func>> { loop {} })?;
     Ok(())
 }
@@ -142,9 +142,14 @@ fn signatures_match() -> Result<()> {
     linker.func_wrap(
         "",
         "f6",
-        |_: f32, _: f64, _: i32, _: i64, _: i32, _: Option<ExternRef>, _: Option<Func>| -> f64 {
-            loop {}
-        },
+        |_: f32,
+         _: f64,
+         _: i32,
+         _: i64,
+         _: i32,
+         _: Option<Rooted<ExternRef>>,
+         _: Option<Func>|
+         -> f64 { loop {} },
     )?;
 
     let mut store = Store::new(&engine, ());
@@ -154,59 +159,62 @@ fn signatures_match() -> Result<()> {
         .unwrap()
         .into_func()
         .unwrap();
-    assert_eq!(f.ty(&store).params().collect::<Vec<_>>(), &[]);
-    assert_eq!(f.ty(&store).results().collect::<Vec<_>>(), &[]);
+    assert_eq!(f.ty(&store).params().len(), 0);
+    assert_eq!(f.ty(&store).results().len(), 0);
 
     let f = linker
         .get(&mut store, "", "f2")
         .unwrap()
         .into_func()
         .unwrap();
-    assert_eq!(f.ty(&store).params().collect::<Vec<_>>(), &[]);
-    assert_eq!(f.ty(&store).results().collect::<Vec<_>>(), &[ValType::I32]);
+    assert_eq!(f.ty(&store).params().len(), 0);
+    assert_eq!(f.ty(&store).results().len(), 1);
+    assert!(f.ty(&store).results().nth(0).unwrap().is_i32());
 
     let f = linker
         .get(&mut store, "", "f3")
         .unwrap()
         .into_func()
         .unwrap();
-    assert_eq!(f.ty(&store).params().collect::<Vec<_>>(), &[]);
-    assert_eq!(f.ty(&store).results().collect::<Vec<_>>(), &[ValType::I64]);
+    assert_eq!(f.ty(&store).params().len(), 0);
+    assert_eq!(f.ty(&store).results().len(), 1);
+    assert!(f.ty(&store).results().nth(0).unwrap().is_i64());
 
     let f = linker
         .get(&mut store, "", "f4")
         .unwrap()
         .into_func()
         .unwrap();
-    assert_eq!(f.ty(&store).params().collect::<Vec<_>>(), &[]);
-    assert_eq!(f.ty(&store).results().collect::<Vec<_>>(), &[ValType::F32]);
+    assert_eq!(f.ty(&store).params().len(), 0);
+    assert_eq!(f.ty(&store).results().len(), 1);
+    assert!(f.ty(&store).results().nth(0).unwrap().is_f32());
 
     let f = linker
         .get(&mut store, "", "f5")
         .unwrap()
         .into_func()
         .unwrap();
-    assert_eq!(f.ty(&store).params().collect::<Vec<_>>(), &[]);
-    assert_eq!(f.ty(&store).results().collect::<Vec<_>>(), &[ValType::F64]);
+    assert_eq!(f.ty(&store).params().len(), 0);
+    assert_eq!(f.ty(&store).results().len(), 1);
+    assert!(f.ty(&store).results().nth(0).unwrap().is_f64());
 
     let f = linker
         .get(&mut store, "", "f6")
         .unwrap()
         .into_func()
         .unwrap();
-    assert_eq!(
-        f.ty(&store).params().collect::<Vec<_>>(),
-        &[
-            ValType::F32,
-            ValType::F64,
-            ValType::I32,
-            ValType::I64,
-            ValType::I32,
-            ValType::ExternRef,
-            ValType::FuncRef,
-        ]
-    );
-    assert_eq!(f.ty(&store).results().collect::<Vec<_>>(), &[ValType::F64]);
+
+    assert_eq!(f.ty(&store).params().len(), 7);
+    assert!(f.ty(&store).params().nth(0).unwrap().is_f32());
+    assert!(f.ty(&store).params().nth(1).unwrap().is_f64());
+    assert!(f.ty(&store).params().nth(2).unwrap().is_i32());
+    assert!(f.ty(&store).params().nth(3).unwrap().is_i64());
+    assert!(f.ty(&store).params().nth(4).unwrap().is_i32());
+    assert!(f.ty(&store).params().nth(5).unwrap().is_externref());
+    assert!(f.ty(&store).params().nth(6).unwrap().is_funcref());
+
+    assert_eq!(f.ty(&store).results().len(), 1);
+    assert!(f.ty(&store).results().nth(0).unwrap().is_f64());
 
     Ok(())
 }
@@ -272,7 +280,7 @@ fn import_works() -> Result<()> {
          c: i32,
          d: f32,
          e: f64,
-         f: Option<ExternRef>,
+         f: Option<Rooted<ExternRef>>,
          g: Option<Func>| {
             assert_eq!(a, 100);
             assert_eq!(b, 200);
@@ -280,7 +288,12 @@ fn import_works() -> Result<()> {
             assert_eq!(d, 400.0);
             assert_eq!(e, 500.0);
             assert_eq!(
-                f.as_ref().unwrap().data().downcast_ref::<String>().unwrap(),
+                f.as_ref()
+                    .unwrap()
+                    .data(&caller)
+                    .unwrap()
+                    .downcast_ref::<String>()
+                    .unwrap(),
                 "hello"
             );
             let mut results = [Val::I32(0)];
@@ -299,14 +312,8 @@ fn import_works() -> Result<()> {
     let instance = linker.instantiate(&mut store, &module)?;
     let run = instance.get_func(&mut store, "run").unwrap();
     let funcref = Val::FuncRef(Some(Func::wrap(&mut store, || -> i32 { 42 })));
-    run.call(
-        &mut store,
-        &[
-            Val::ExternRef(Some(ExternRef::new("hello".to_string()))),
-            funcref,
-        ],
-        &mut [],
-    )?;
+    let externref = Val::ExternRef(Some(ExternRef::new(&mut store, "hello".to_string())?));
+    run.call(&mut store, &[externref, funcref], &mut [])?;
 
     assert_eq!(HITS.load(SeqCst), 4);
 
@@ -447,6 +454,7 @@ fn call_wasm_many_args() -> Result<()> {
 }
 
 #[test]
+#[cfg_attr(miri, ignore)]
 fn trap_smoke() -> Result<()> {
     let engine = Engine::default();
     let mut linker = Linker::<()>::new(&engine);
@@ -493,10 +501,10 @@ fn new_from_signature() -> Result<()> {
     let engine = Engine::default();
     let mut linker = Linker::new(&engine);
 
-    let ty = FuncType::new(None, None);
+    let ty = FuncType::new(&engine, None, None);
     linker.func_new("", "f1", ty, |_, _, _| panic!())?;
 
-    let ty = FuncType::new(Some(ValType::I32), Some(ValType::F64));
+    let ty = FuncType::new(&engine, Some(ValType::I32), Some(ValType::F64));
     linker.func_new("", "f2", ty, |_, _, _| panic!())?;
 
     let mut store = Store::new(&engine, ());
@@ -603,7 +611,7 @@ fn call_wrapped_func() -> Result<()> {
 fn func_return_nothing() -> Result<()> {
     let engine = Engine::default();
     let mut linker = Linker::new(&engine);
-    let ty = FuncType::new(None, Some(ValType::I32));
+    let ty = FuncType::new(&engine, None, Some(ValType::I32));
     linker.func_new("", "", ty, |_, _, _| Ok(()))?;
 
     let mut store = Store::new(&engine, ());
@@ -708,7 +716,7 @@ fn store_with_context() -> Result<()> {
 fn wasi_imports() -> Result<()> {
     let engine = Engine::default();
     let mut linker = Linker::new(&engine);
-    wasmtime_wasi::add_to_linker(&mut linker, |s| s)?;
+    wasmtime_wasi::preview1::add_to_linker_sync(&mut linker, |t| t)?;
 
     let wasm = wat::parse_str(
         r#"
@@ -721,14 +729,14 @@ fn wasi_imports() -> Result<()> {
     )?;
 
     let module = Module::new(&engine, wasm)?;
-    let mut store = Store::new(&engine, WasiCtxBuilder::new().build());
+    let mut store = Store::new(&engine, wasmtime_wasi::WasiCtxBuilder::new().build_p1());
     let instance = linker.instantiate(&mut store, &module)?;
 
     let start = instance.get_typed_func::<(), ()>(&mut store, "_start")?;
     let exit = start
         .call(&mut store, ())
         .unwrap_err()
-        .downcast::<I32Exit>()?;
+        .downcast::<wasmtime_wasi::I32Exit>()?;
     assert_eq!(exit.0, 123);
 
     Ok(())
diff --git a/tests/all/i31ref.rs b/tests/all/i31ref.rs
new file mode 100644
index 000000000000..de5308f24e7f
--- /dev/null
+++ b/tests/all/i31ref.rs
@@ -0,0 +1,21 @@
+use wasmtime::*;
+
+#[test]
+fn always_pop_i31ref_lifo_roots() -> Result<()> {
+    let mut config = Config::new();
+    config.wasm_function_references(true);
+    config.wasm_gc(true);
+
+    let engine = Engine::new(&config)?;
+    let mut store = Store::new(&engine, ());
+
+    let anyref = {
+        let mut scope = RootScope::new(&mut store);
+        AnyRef::from_i31(&mut scope, I31::wrapping_u32(42))
+    };
+
+    // The anyref has left its rooting scope and been unrooted.
+    assert!(anyref.is_i31(&store).is_err());
+
+    Ok(())
+}
diff --git a/tests/all/import_calling_export.rs b/tests/all/import_calling_export.rs
index 247fbcd1ebc0..0a6eb98ccd66 100644
--- a/tests/all/import_calling_export.rs
+++ b/tests/all/import_calling_export.rs
@@ -1,6 +1,5 @@
 #![cfg(not(miri))]
 
-use anyhow::Result;
 use wasmtime::*;
 
 #[test]
@@ -19,18 +18,15 @@ fn test_import_calling_export() {
     let mut store = Store::<Option<Func>>::default();
     let module = Module::new(store.engine(), WAT).expect("failed to create module");
 
-    let callback_func = Func::new(
-        &mut store,
-        FuncType::new(None, None),
-        move |mut caller, _, _| {
-            caller
-                .data()
-                .unwrap()
-                .call(&mut caller, &[], &mut [])
-                .expect("expected function not to trap");
-            Ok(())
-        },
-    );
+    let func_ty = FuncType::new(store.engine(), None, None);
+    let callback_func = Func::new(&mut store, func_ty, move |mut caller, _, _| {
+        caller
+            .data()
+            .unwrap()
+            .call(&mut caller, &[], &mut [])
+            .expect("expected function not to trap");
+        Ok(())
+    });
 
     let imports = vec![callback_func.into()];
     let instance = Instance::new(&mut store, &module, imports.as_slice())
@@ -64,15 +60,12 @@ fn test_returns_incorrect_type() -> Result<()> {
     let mut store = Store::<()>::default();
     let module = Module::new(store.engine(), WAT)?;
 
-    let callback_func = Func::new(
-        &mut store,
-        FuncType::new(None, Some(ValType::I32)),
-        |_, _, results| {
-            // Evil! Returns I64 here instead of promised in the signature I32.
-            results[0] = Val::I64(228);
-            Ok(())
-        },
-    );
+    let func_ty = FuncType::new(store.engine(), None, Some(ValType::I32));
+    let callback_func = Func::new(&mut store, func_ty, |_, _, results| {
+        // Evil! Returns I64 here instead of promised in the signature I32.
+        results[0] = Val::I64(228);
+        Ok(())
+    });
 
     let imports = vec![callback_func.into()];
     let instance = Instance::new(&mut store, &module, imports.as_slice())?;
@@ -85,6 +78,6 @@ fn test_returns_incorrect_type() -> Result<()> {
     let trap = run_func
         .call(&mut store, &[], &mut result)
         .expect_err("the execution should fail");
-    assert!(format!("{:?}", trap).contains("function attempted to return an incompatible value"));
+    assert!(format!("{trap:?}").contains("function attempted to return an incompatible value"));
     Ok(())
 }
diff --git a/tests/all/import_indexes.rs b/tests/all/import_indexes.rs
index 6383d576e34c..6a92ddd2836b 100644
--- a/tests/all/import_indexes.rs
+++ b/tests/all/import_indexes.rs
@@ -17,12 +17,13 @@ fn same_import_names_still_distinct() -> anyhow::Result<()> {
     "#;
 
     let mut store = Store::<()>::default();
-    let module = Module::new(store.engine(), WAT)?;
+    let engine = store.engine().clone();
+    let module = Module::new(&engine, WAT)?;
 
     let imports = [
         Func::new(
             &mut store,
-            FuncType::new(None, Some(ValType::I32)),
+            FuncType::new(&engine, None, Some(ValType::I32)),
             |_, params, results| {
                 assert!(params.is_empty());
                 assert_eq!(results.len(), 1);
@@ -33,7 +34,7 @@ fn same_import_names_still_distinct() -> anyhow::Result<()> {
         .into(),
         Func::new(
             &mut store,
-            FuncType::new(None, Some(ValType::F32)),
+            FuncType::new(&engine, None, Some(ValType::F32)),
             |_, params, results| {
                 assert!(params.is_empty());
                 assert_eq!(results.len(), 1);
diff --git a/tests/all/instance.rs b/tests/all/instance.rs
index abc7c8c29c0a..57aab2ce563b 100644
--- a/tests/all/instance.rs
+++ b/tests/all/instance.rs
@@ -1,4 +1,3 @@
-use anyhow::Result;
 use wasmtime::*;
 
 #[test]
@@ -8,7 +7,7 @@ fn wrong_import_numbers() -> Result<()> {
 
     assert!(Instance::new(&mut store, &module, &[]).is_err());
     let func = Func::wrap(&mut store, || {});
-    assert!(Instance::new(&mut store, &module, &[func.clone().into(), func.into()]).is_err());
+    assert!(Instance::new(&mut store, &module, &[func.into(), func.into()]).is_err());
     Ok(())
 }
 
@@ -43,7 +42,7 @@ fn linear_memory_limits() -> Result<()> {
     }
     test(&Engine::default())?;
     let mut pool = crate::small_pool_config();
-    pool.memory_pages(65536);
+    pool.max_memory_size(1 << 32);
     test(&Engine::new(Config::new().allocation_strategy(
         InstanceAllocationStrategy::Pooling(pool),
     ))?)?;
diff --git a/tests/all/invoke_func_via_table.rs b/tests/all/invoke_func_via_table.rs
index 8edb1838645b..9504baea1b1f 100644
--- a/tests/all/invoke_func_via_table.rs
+++ b/tests/all/invoke_func_via_table.rs
@@ -1,6 +1,6 @@
 #![cfg(not(miri))]
 
-use anyhow::{Context as _, Result};
+use anyhow::Context as _;
 use wasmtime::*;
 
 #[test]
@@ -11,7 +11,7 @@ fn test_invoke_func_via_table() -> Result<()> {
       (module
         (func $f (result i64) (i64.const 42))
 
-        (table (export "table") 1 1 anyfunc)
+        (table (export "table") 1 1 funcref)
         (elem (i32.const 0) $f)
       )
     "#;
@@ -19,15 +19,13 @@ fn test_invoke_func_via_table() -> Result<()> {
     let instance =
         Instance::new(&mut store, &module, &[]).context("> Error instantiating module!")?;
 
-    let f = instance
+    let f = *instance
         .get_table(&mut store, "table")
         .unwrap()
         .get(&mut store, 0)
         .unwrap()
-        .funcref()
-        .unwrap()
-        .unwrap()
-        .clone();
+        .unwrap_func()
+        .unwrap();
     let mut results = [Val::I32(0)];
     f.call(&mut store, &[], &mut results).unwrap();
     assert_eq!(results[0].unwrap_i64(), 42);
diff --git a/tests/all/limits.rs b/tests/all/limits.rs
index cd357d5dc78f..9150ce20de78 100644
--- a/tests/all/limits.rs
+++ b/tests/all/limits.rs
@@ -1,7 +1,6 @@
-use anyhow::Result;
 use wasmtime::*;
 
-const WASM_PAGE_SIZE: usize = wasmtime_environ::WASM_PAGE_SIZE as usize;
+const WASM_PAGE_SIZE: usize = wasmtime_environ::Memory::DEFAULT_PAGE_SIZE as usize;
 
 #[test]
 #[cfg_attr(miri, ignore)]
@@ -11,7 +10,7 @@ fn test_limits() -> Result<()> {
         &engine,
         r#"(module
             (memory $m (export "m") 0)
-            (table (export "t") 0 anyfunc)
+            (table (export "t") 0 funcref)
             (func (export "grow") (param i32) (result i32)
               (memory.grow $m (local.get 0)))
            )"#,
@@ -51,17 +50,17 @@ fn test_limits() -> Result<()> {
         instance.get_table(&mut store, "t").unwrap(),
         Table::new(
             &mut store,
-            TableType::new(ValType::FuncRef, 0, None),
-            Val::FuncRef(None),
+            TableType::new(RefType::FUNCREF, 0, None),
+            Ref::Func(None),
         )?,
     ]) {
-        table.grow(&mut store, 2, Val::FuncRef(None))?;
-        table.grow(&mut store, 1, Val::FuncRef(None))?;
-        table.grow(&mut store, 2, Val::FuncRef(None))?;
+        table.grow(&mut store, 2, Ref::Func(None))?;
+        table.grow(&mut store, 1, Ref::Func(None))?;
+        table.grow(&mut store, 2, Ref::Func(None))?;
 
         assert_eq!(
             table
-                .grow(&mut store, 1, Val::FuncRef(None))
+                .grow(&mut store, 1, Ref::Func(None))
                 .map_err(|e| e.to_string())
                 .unwrap_err(),
             "failed to grow table by `1`"
@@ -99,7 +98,7 @@ async fn test_limits_async() -> Result<()> {
     let engine = Engine::new(&config).unwrap();
     let module = Module::new(
         &engine,
-        r#"(module (memory (export "m") 0) (table (export "t") 0 anyfunc))"#,
+        r#"(module (memory (export "m") 0) (table (export "t") 0 funcref))"#,
     )?;
 
     struct LimitsAsync {
@@ -162,18 +161,18 @@ async fn test_limits_async() -> Result<()> {
         instance.get_table(&mut store, "t").unwrap(),
         Table::new_async(
             &mut store,
-            TableType::new(ValType::FuncRef, 0, None),
-            Val::FuncRef(None),
+            TableType::new(RefType::FUNCREF, 0, None),
+            Ref::Func(None),
         )
         .await?,
     ]) {
-        table.grow_async(&mut store, 2, Val::FuncRef(None)).await?;
-        table.grow_async(&mut store, 1, Val::FuncRef(None)).await?;
-        table.grow_async(&mut store, 2, Val::FuncRef(None)).await?;
+        table.grow_async(&mut store, 2, Ref::Func(None)).await?;
+        table.grow_async(&mut store, 1, Ref::Func(None)).await?;
+        table.grow_async(&mut store, 2, Ref::Func(None)).await?;
 
         assert_eq!(
             table
-                .grow_async(&mut store, 1, Val::FuncRef(None))
+                .grow_async(&mut store, 1, Ref::Func(None))
                 .await
                 .map_err(|e| e.to_string())
                 .unwrap_err(),
@@ -189,7 +188,7 @@ fn test_limits_memory_only() -> Result<()> {
     let engine = Engine::default();
     let module = Module::new(
         &engine,
-        r#"(module (memory (export "m") 0) (table (export "t") 0 anyfunc))"#,
+        r#"(module (memory (export "m") 0) (table (export "t") 0 funcref))"#,
     )?;
 
     let mut store = Store::new(
@@ -225,14 +224,14 @@ fn test_limits_memory_only() -> Result<()> {
         instance.get_table(&mut store, "t").unwrap(),
         Table::new(
             &mut store,
-            TableType::new(ValType::FuncRef, 0, None),
-            Val::FuncRef(None),
+            TableType::new(RefType::FUNCREF, 0, None),
+            Ref::Func(None),
         )?,
     ]) {
-        table.grow(&mut store, 2, Val::FuncRef(None))?;
-        table.grow(&mut store, 1, Val::FuncRef(None))?;
-        table.grow(&mut store, 2, Val::FuncRef(None))?;
-        table.grow(&mut store, 1, Val::FuncRef(None))?;
+        table.grow(&mut store, 2, Ref::Func(None))?;
+        table.grow(&mut store, 1, Ref::Func(None))?;
+        table.grow(&mut store, 2, Ref::Func(None))?;
+        table.grow(&mut store, 1, Ref::Func(None))?;
     }
 
     Ok(())
@@ -275,7 +274,7 @@ fn test_limits_table_only() -> Result<()> {
     let engine = Engine::default();
     let module = Module::new(
         &engine,
-        r#"(module (memory (export "m") 0) (table (export "t") 0 anyfunc))"#,
+        r#"(module (memory (export "m") 0) (table (export "t") 0 funcref))"#,
     )?;
 
     let mut store = Store::new(&engine, StoreLimitsBuilder::new().table_elements(5).build());
@@ -299,17 +298,17 @@ fn test_limits_table_only() -> Result<()> {
         instance.get_table(&mut store, "t").unwrap(),
         Table::new(
             &mut store,
-            TableType::new(ValType::FuncRef, 0, None),
-            Val::FuncRef(None),
+            TableType::new(RefType::FUNCREF, 0, None),
+            Ref::Func(None),
         )?,
     ]) {
-        table.grow(&mut store, 2, Val::FuncRef(None))?;
-        table.grow(&mut store, 1, Val::FuncRef(None))?;
-        table.grow(&mut store, 2, Val::FuncRef(None))?;
+        table.grow(&mut store, 2, Ref::Func(None))?;
+        table.grow(&mut store, 1, Ref::Func(None))?;
+        table.grow(&mut store, 2, Ref::Func(None))?;
 
         assert_eq!(
             table
-                .grow(&mut store, 1, Val::FuncRef(None))
+                .grow(&mut store, 1, Ref::Func(None))
                 .map_err(|e| e.to_string())
                 .unwrap_err(),
             "failed to grow table by `1`"
@@ -322,7 +321,7 @@ fn test_limits_table_only() -> Result<()> {
 #[test]
 fn test_initial_table_limits_exceeded() -> Result<()> {
     let engine = Engine::default();
-    let module = Module::new(&engine, r#"(module (table (export "t") 23 anyfunc))"#)?;
+    let module = Module::new(&engine, r#"(module (table (export "t") 23 funcref))"#)?;
 
     let mut store = Store::new(&engine, StoreLimitsBuilder::new().table_elements(4).build());
     store.limiter(|s| s as &mut dyn ResourceLimiter);
@@ -337,8 +336,8 @@ fn test_initial_table_limits_exceeded() -> Result<()> {
 
     match Table::new(
         &mut store,
-        TableType::new(ValType::FuncRef, 99, None),
-        Val::FuncRef(None),
+        TableType::new(RefType::FUNCREF, 99, None),
+        Ref::Func(None),
     ) {
         Ok(_) => unreachable!(),
         Err(e) => assert_eq!(
@@ -355,7 +354,8 @@ fn test_pooling_allocator_initial_limits_exceeded() -> Result<()> {
     let mut pool = crate::small_pool_config();
     pool.total_memories(2)
         .max_memories_per_module(2)
-        .memory_pages(5);
+        .max_memory_size(5 << 16)
+        .memory_protection_keys(MpkEnabled::Disable);
     let mut config = Config::new();
     config.wasm_multi_memory(true);
     config.allocation_strategy(InstanceAllocationStrategy::Pooling(pool));
@@ -407,8 +407,7 @@ impl ResourceLimiter for MemoryContext {
         // Check if the desired exceeds a maximum (either from Wasm or from the host)
         assert!(desired < maximum.unwrap_or(usize::MAX));
 
-        assert_eq!(current as usize, self.wasm_memory_used);
-        let desired = desired as usize;
+        assert_eq!(current, self.wasm_memory_used);
 
         if desired + self.host_memory_used > self.memory_limit {
             self.limit_exceeded = true;
@@ -522,8 +521,7 @@ impl ResourceLimiterAsync for MemoryContext {
         // Check if the desired exceeds a maximum (either from Wasm or from the host)
         assert!(desired < maximum.unwrap_or(usize::MAX));
 
-        assert_eq!(current as usize, self.wasm_memory_used);
-        let desired = desired as usize;
+        assert_eq!(current, self.wasm_memory_used);
 
         if desired + self.host_memory_used > self.memory_limit {
             self.limit_exceeded = true;
@@ -661,7 +659,7 @@ fn test_custom_table_limiter() -> Result<()> {
     let engine = Engine::default();
     let linker = Linker::new(&engine);
 
-    let module = Module::new(&engine, r#"(module (table (export "t") 0 anyfunc))"#)?;
+    let module = Module::new(&engine, r#"(module (table (export "t") 0 funcref))"#)?;
 
     let context = TableContext {
         elements_used: 0,
@@ -675,9 +673,9 @@ fn test_custom_table_limiter() -> Result<()> {
     let table = instance.get_table(&mut store, "t").unwrap();
 
     // Grow the table by 10 elements
-    table.grow(&mut store, 3, Val::FuncRef(None))?;
-    table.grow(&mut store, 5, Val::FuncRef(None))?;
-    table.grow(&mut store, 2, Val::FuncRef(None))?;
+    table.grow(&mut store, 3, Ref::Func(None))?;
+    table.grow(&mut store, 5, Ref::Func(None))?;
+    table.grow(&mut store, 2, Ref::Func(None))?;
 
     assert!(!store.data().limit_exceeded);
 
@@ -687,7 +685,7 @@ fn test_custom_table_limiter() -> Result<()> {
     // Try to grow the memory again
     assert_eq!(
         table
-            .grow(&mut store, 1, Val::FuncRef(None))
+            .grow(&mut store, 1, Ref::Func(None))
             .map_err(|e| e.to_string())
             .unwrap_err(),
         "failed to grow table by `1`"
@@ -744,7 +742,7 @@ fn custom_limiter_detect_grow_failure() -> Result<()> {
         return Ok(());
     }
     let mut pool = crate::small_pool_config();
-    pool.memory_pages(10).table_elements(10);
+    pool.max_memory_size(10 << 16).table_elements(10);
     let mut config = Config::new();
     config.allocation_strategy(InstanceAllocationStrategy::Pooling(pool));
     let engine = Engine::new(&config).unwrap();
@@ -752,7 +750,7 @@ fn custom_limiter_detect_grow_failure() -> Result<()> {
 
     let module = Module::new(
         &engine,
-        r#"(module (memory (export "m") 0) (table (export "t") 0 anyfunc))"#,
+        r#"(module (memory (export "m") 0) (table (export "t") 0 funcref))"#,
     )?;
 
     let context = FailureDetector::default();
@@ -785,7 +783,7 @@ fn custom_limiter_detect_grow_failure() -> Result<()> {
 
     let table = instance.get_table(&mut store, "t").unwrap();
     // Grow the table 10 elements
-    table.grow(&mut store, 10, Val::FuncRef(None))?;
+    table.grow(&mut store, 10, Ref::Func(None))?;
 
     assert!(store.data().table_error.is_none());
     assert_eq!(store.data().table_current, 0);
@@ -795,7 +793,7 @@ fn custom_limiter_detect_grow_failure() -> Result<()> {
     // The ResourceLimiter will permit this, but the grow will fail.
     assert_eq!(
         table
-            .grow(&mut store, 1, Val::FuncRef(None))
+            .grow(&mut store, 1, Ref::Func(None))
             .unwrap_err()
             .to_string(),
         "failed to grow table by `1`"
@@ -855,7 +853,7 @@ async fn custom_limiter_async_detect_grow_failure() -> Result<()> {
         return Ok(());
     }
     let mut pool = crate::small_pool_config();
-    pool.memory_pages(10).table_elements(10);
+    pool.max_memory_size(10 << 16).table_elements(10);
     let mut config = Config::new();
     config.async_support(true);
     config.allocation_strategy(InstanceAllocationStrategy::Pooling(pool));
@@ -864,7 +862,7 @@ async fn custom_limiter_async_detect_grow_failure() -> Result<()> {
 
     let module = Module::new(
         &engine,
-        r#"(module (memory (export "m") 0) (table (export "t") 0 anyfunc))"#,
+        r#"(module (memory (export "m") 0) (table (export "t") 0 funcref))"#,
     )?;
 
     let context = FailureDetector::default();
@@ -901,7 +899,7 @@ async fn custom_limiter_async_detect_grow_failure() -> Result<()> {
 
     let table = instance.get_table(&mut store, "t").unwrap();
     // Grow the table 10 elements
-    table.grow_async(&mut store, 10, Val::FuncRef(None)).await?;
+    table.grow_async(&mut store, 10, Ref::Func(None)).await?;
 
     assert!(store.data().table_error.is_none());
     assert_eq!(store.data().table_current, 0);
@@ -911,7 +909,7 @@ async fn custom_limiter_async_detect_grow_failure() -> Result<()> {
     // The ResourceLimiter will permit this, but the grow will fail.
     assert_eq!(
         table
-            .grow_async(&mut store, 1, Val::FuncRef(None))
+            .grow_async(&mut store, 1, Ref::Func(None))
             .await
             .unwrap_err()
             .to_string(),
@@ -1023,7 +1021,7 @@ fn panic_in_table_limiter() {
     let engine = Engine::default();
     let linker = Linker::new(&engine);
 
-    let module = Module::new(&engine, r#"(module (table (export "t") 0 anyfunc))"#).unwrap();
+    let module = Module::new(&engine, r#"(module (table (export "t") 0 funcref))"#).unwrap();
 
     let mut store = Store::new(&engine, Panic);
     store.limiter(|s| s as &mut dyn ResourceLimiter);
@@ -1031,7 +1029,7 @@ fn panic_in_table_limiter() {
     let table = instance.get_table(&mut store, "t").unwrap();
 
     // Grow the table, which should panic
-    table.grow(&mut store, 3, Val::FuncRef(None)).unwrap();
+    table.grow(&mut store, 3, Ref::Func(None)).unwrap();
 }
 
 #[tokio::test]
@@ -1095,7 +1093,7 @@ async fn panic_in_async_table_limiter() {
     let engine = Engine::new(&config).unwrap();
     let linker = Linker::new(&engine);
 
-    let module = Module::new(&engine, r#"(module (table (export "t") 0 anyfunc))"#).unwrap();
+    let module = Module::new(&engine, r#"(module (table (export "t") 0 funcref))"#).unwrap();
 
     let mut store = Store::new(&engine, Panic);
     store.limiter_async(|s| s as &mut dyn ResourceLimiterAsync);
@@ -1104,7 +1102,7 @@ async fn panic_in_async_table_limiter() {
 
     // Grow the table, which should panic
     table
-        .grow_async(&mut store, 3, Val::FuncRef(None))
+        .grow_async(&mut store, 3, Ref::Func(None))
         .await
         .unwrap();
 }
@@ -1117,7 +1115,7 @@ fn growth_trap() -> Result<()> {
         &engine,
         r#"(module
             (memory $m (export "m") 0)
-            (table (export "t") 0 anyfunc)
+            (table (export "t") 0 funcref)
             (func (export "grow") (param i32) (result i32)
               (memory.grow $m (local.get 0)))
            )"#,
@@ -1149,12 +1147,12 @@ fn growth_trap() -> Result<()> {
         instance.get_table(&mut store, "t").unwrap(),
         Table::new(
             &mut store,
-            TableType::new(ValType::FuncRef, 0, None),
-            Val::FuncRef(None),
+            TableType::new(RefType::FUNCREF, 0, None),
+            Ref::Func(None),
         )?,
     ] {
-        table.grow(&mut store, 1, Val::FuncRef(None))?;
-        assert!(table.grow(&mut store, 1, Val::FuncRef(None)).is_err());
+        table.grow(&mut store, 1, Ref::Func(None))?;
+        assert!(table.grow(&mut store, 1, Ref::Func(None)).is_err());
     }
 
     let mut store = Store::new(&engine, store.data().clone());
diff --git a/tests/all/linker.rs b/tests/all/linker.rs
index 64bbf43c07ef..e02ea2d54712 100644
--- a/tests/all/linker.rs
+++ b/tests/all/linker.rs
@@ -1,4 +1,3 @@
-use anyhow::Result;
 use std::cell::Cell;
 use std::rc::Rc;
 use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
@@ -56,36 +55,36 @@ fn link_twice_bad() -> Result<()> {
     // globals
     let ty = GlobalType::new(ValType::I32, Mutability::Const);
     let global = Global::new(&mut store, ty, Val::I32(0))?;
-    linker.define(&mut store, "g", "1", global.clone())?;
-    assert!(linker.define(&mut store, "g", "1", global.clone()).is_err());
+    linker.define(&mut store, "g", "1", global)?;
+    assert!(linker.define(&mut store, "g", "1", global).is_err());
 
     let ty = GlobalType::new(ValType::I32, Mutability::Var);
     let global = Global::new(&mut store, ty, Val::I32(0))?;
-    linker.define(&mut store, "g", "2", global.clone())?;
-    assert!(linker.define(&mut store, "g", "2", global.clone()).is_err());
+    linker.define(&mut store, "g", "2", global)?;
+    assert!(linker.define(&mut store, "g", "2", global).is_err());
 
     let ty = GlobalType::new(ValType::I64, Mutability::Const);
     let global = Global::new(&mut store, ty, Val::I64(0))?;
-    linker.define(&mut store, "g", "3", global.clone())?;
-    assert!(linker.define(&mut store, "g", "3", global.clone()).is_err());
+    linker.define(&mut store, "g", "3", global)?;
+    assert!(linker.define(&mut store, "g", "3", global).is_err());
 
     // memories
     let ty = MemoryType::new(1, None);
     let memory = Memory::new(&mut store, ty)?;
-    linker.define(&mut store, "m", "", memory.clone())?;
-    assert!(linker.define(&mut store, "m", "", memory.clone()).is_err());
+    linker.define(&mut store, "m", "", memory)?;
+    assert!(linker.define(&mut store, "m", "", memory).is_err());
     let ty = MemoryType::new(2, None);
     let memory = Memory::new(&mut store, ty)?;
-    assert!(linker.define(&mut store, "m", "", memory.clone()).is_err());
+    assert!(linker.define(&mut store, "m", "", memory).is_err());
 
     // tables
-    let ty = TableType::new(ValType::FuncRef, 1, None);
-    let table = Table::new(&mut store, ty, Val::FuncRef(None))?;
-    linker.define(&mut store, "t", "", table.clone())?;
-    assert!(linker.define(&mut store, "t", "", table.clone()).is_err());
-    let ty = TableType::new(ValType::FuncRef, 2, None);
-    let table = Table::new(&mut store, ty, Val::FuncRef(None))?;
-    assert!(linker.define(&mut store, "t", "", table.clone()).is_err());
+    let ty = TableType::new(RefType::FUNCREF, 1, None);
+    let table = Table::new(&mut store, ty, Ref::Func(None))?;
+    linker.define(&mut store, "t", "", table)?;
+    assert!(linker.define(&mut store, "t", "", table).is_err());
+    let ty = TableType::new(RefType::FUNCREF, 2, None);
+    let table = Table::new(&mut store, ty, Ref::Func(None))?;
+    assert!(linker.define(&mut store, "t", "", table).is_err());
     Ok(())
 }
 
@@ -436,3 +435,299 @@ fn test_default_value_unknown_import() -> Result<()> {
 
     Ok(())
 }
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn linker_instantiate_with_concrete_func_refs() -> Result<()> {
+    let mut config = Config::new();
+    config.wasm_function_references(true);
+    let engine = Engine::new(&config)?;
+
+    let module = Module::new(
+        &engine,
+        r#"
+            (module
+                (type $a (func (result i32)))
+                (type $b (func (result (ref null $a))))
+                (type $c (func (result (ref null $b))))
+
+                (import "env" "f" (func $f (result (ref null $c))))
+
+                (func (export "g") (result funcref)
+                    call $f
+                )
+            )
+        "#,
+    )?;
+
+    let a = FuncType::new(&engine, None, Some(ValType::I32));
+    let ref_null_a = ValType::from(RefType::new(true, HeapType::ConcreteFunc(a.clone())));
+
+    let b = FuncType::new(&engine, None, Some(ref_null_a));
+    let ref_null_b = ValType::from(RefType::new(true, HeapType::ConcreteFunc(b.clone())));
+
+    let c = FuncType::new(&engine, None, Some(ref_null_b));
+    let ref_null_c = ValType::from(RefType::new(true, HeapType::ConcreteFunc(c.clone())));
+
+    let mut store = Store::new(&engine, ());
+    let a_func = Func::new(&mut store, a, |_caller, _args, results| {
+        results[0] = Val::I32(0x1234_5678);
+        Ok(())
+    });
+
+    let b_func = Func::new(&mut store, b, move |_caller, _args, results| {
+        results[0] = Val::FuncRef(Some(a_func));
+        Ok(())
+    });
+
+    let c_func = Func::new(&mut store, c, move |_caller, _args, results| {
+        results[0] = Val::FuncRef(Some(b_func));
+        Ok(())
+    });
+
+    let mut linker = Linker::new(&engine);
+    linker.func_new(
+        "env",
+        "f",
+        FuncType::new(&engine, None, Some(ref_null_c)),
+        move |_caller, _args, results| {
+            results[0] = Val::FuncRef(Some(c_func));
+            Ok(())
+        },
+    )?;
+
+    let instance = linker.instantiate(&mut store, &module)?;
+
+    let g = instance.get_typed_func::<(), Option<Func>>(&mut store, "g")?;
+
+    let c = g.call(&mut store, ())?;
+    let c = c.expect("func ref c is non null");
+    let c = c.typed::<(), Option<Func>>(&mut store)?;
+
+    let b = c.call(&mut store, ())?;
+    let b = b.expect("func ref b is non null");
+    let b = b.typed::<(), Option<Func>>(&mut store)?;
+
+    let a = b.call(&mut store, ())?;
+    let a = a.expect("func ref a is non null");
+    let a = a.typed::<(), u32>(&mut store)?;
+
+    let x = a.call(&mut store, ())?;
+    assert_eq!(x, 0x1234_5678);
+
+    Ok(())
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn linker_defines_func_subtype() -> Result<()> {
+    let mut config = Config::new();
+    config.wasm_function_references(true);
+    config.wasm_gc(true);
+    let engine = Engine::new(&config)?;
+
+    let mut linker = Linker::new(&engine);
+    linker.func_new(
+        "env",
+        "f",
+        FuncType::new(&engine, Some(ValType::FUNCREF), None),
+        |_caller, _args, _results| Ok(()),
+    )?;
+    linker.func_new(
+        "env",
+        "g",
+        FuncType::new(&engine, None, Some(ValType::NULLFUNCREF)),
+        |_caller, _args, _results| Ok(()),
+    )?;
+    let nop_ty = FuncType::new(&engine, None, None);
+    let ref_null_nop = ValType::from(RefType::new(true, HeapType::ConcreteFunc(nop_ty)));
+    linker.func_new(
+        "env",
+        "h",
+        FuncType::new(&engine, Some(ref_null_nop.clone()), Some(ref_null_nop)),
+        |_caller, _args, _results| Ok(()),
+    )?;
+
+    let module = Module::new(
+        &engine,
+        r#"
+            (module
+                ;; wasm's declared nullfuncref <: f's actual funcref
+                (import "env" "f" (func (param nullfuncref)))
+
+                ;; g's actual nullfuncref <: wasm's declared funcref
+                (import "env" "g" (func (result funcref)))
+
+                ;; wasm's declared nullfuncref param <: h's actual (ref null $nop) param, and
+                ;; h's actual (ref null $nop) result <: wasm's declared funcref result
+                (import "env" "h" (func (param nullfuncref) (result funcref)))
+            )
+        "#,
+    )?;
+
+    let mut store = Store::new(&engine, ());
+    let _ = linker.instantiate(&mut store, &module)?;
+
+    Ok(())
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn linker_defines_global_subtype_const_ok() -> Result<()> {
+    let mut config = Config::new();
+    config.wasm_function_references(true);
+    let engine = Engine::new(&config)?;
+    let mut store = Store::new(&engine, ());
+    let mut linker = Linker::new(&engine);
+
+    let module = Module::new(
+        &engine,
+        r#"
+            (module
+                (import "env" "g" (global funcref))
+            )
+        "#,
+    )?;
+
+    let g = Global::new(
+        &mut store,
+        GlobalType::new(ValType::NULLFUNCREF, Mutability::Const),
+        Val::FuncRef(None),
+    )?;
+    linker.define(&store, "env", "g", g)?;
+
+    let _ = linker.instantiate(&mut store, &module)?;
+    Ok(())
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn linker_defines_global_subtype_const_err() -> Result<()> {
+    let mut config = Config::new();
+    config.wasm_function_references(true);
+    config.wasm_gc(true);
+    let engine = Engine::new(&config)?;
+    let mut store = Store::new(&engine, ());
+    let mut linker = Linker::new(&engine);
+
+    let module = Module::new(
+        &engine,
+        r#"
+            (module
+                (import "env" "g" (global nullfuncref))
+            )
+        "#,
+    )?;
+
+    // funcref </: nullfuncref
+    let g = Global::new(
+        &mut store,
+        GlobalType::new(ValType::FUNCREF, Mutability::Const),
+        Val::FuncRef(None),
+    )?;
+    linker.define(&store, "env", "g", g)?;
+
+    let e = linker.instantiate(&mut store, &module).unwrap_err();
+    assert_eq!(e.to_string(), "incompatible import type for `env::g`");
+
+    Ok(())
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn linker_defines_global_subtype_mut_err() -> Result<()> {
+    let mut config = Config::new();
+    config.wasm_function_references(true);
+    let engine = Engine::new(&config)?;
+    let mut store = Store::new(&engine, ());
+
+    let module = Module::new(
+        &engine,
+        r#"
+            (module
+                (type $nop (func))
+                (import "env" "g" (global (mut (ref null $nop))))
+            )
+        "#,
+    )?;
+
+    // Supertype, not precise type.
+    let mut linker = Linker::new(&engine);
+    let g = Global::new(
+        &mut store,
+        GlobalType::new(ValType::FUNCREF, Mutability::Var),
+        Val::FuncRef(None),
+    )?;
+    linker.define(&store, "env", "g", g)?;
+    let e = linker.instantiate(&mut store, &module).unwrap_err();
+    assert_eq!(e.to_string(), "incompatible import type for `env::g`");
+
+    // Subtype, not precise type.
+    let mut linker = Linker::new(&engine);
+    let g = Global::new(
+        &mut store,
+        GlobalType::new(ValType::NULLFUNCREF, Mutability::Var),
+        Val::FuncRef(None),
+    )?;
+    linker.define(&store, "env", "g", g)?;
+    let e = linker.instantiate(&mut store, &module).unwrap_err();
+    assert_eq!(e.to_string(), "incompatible import type for `env::g`");
+
+    // Not mutable.
+    let mut linker = Linker::new(&engine);
+    let nop = FuncType::new(&engine, None, None);
+    let ref_null_nop = ValType::from(RefType::new(true, HeapType::ConcreteFunc(nop)));
+    let g = Global::new(
+        &mut store,
+        GlobalType::new(ref_null_nop, Mutability::Const),
+        Val::FuncRef(None),
+    )?;
+    linker.define(&store, "env", "g", g)?;
+    let e = linker.instantiate(&mut store, &module).unwrap_err();
+    assert_eq!(e.to_string(), "incompatible import type for `env::g`");
+
+    Ok(())
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn linker_defines_table_subtype_err() -> Result<()> {
+    let mut config = Config::new();
+    config.wasm_function_references(true);
+    let engine = Engine::new(&config)?;
+    let mut store = Store::new(&engine, ());
+
+    let module = Module::new(
+        &engine,
+        r#"
+            (module
+                (type $nop (func))
+                (import "env" "t" (table 0 (ref null $nop)))
+            )
+        "#,
+    )?;
+
+    // Supertype, not precise type.
+    let mut linker = Linker::new(&engine);
+    let t = Table::new(
+        &mut store,
+        TableType::new(RefType::FUNCREF, 0, None),
+        Ref::Func(None),
+    )?;
+    linker.define(&store, "env", "t", t)?;
+    let e = linker.instantiate(&mut store, &module).unwrap_err();
+    assert_eq!(e.to_string(), "incompatible import type for `env::t`");
+
+    // Subtype, not precise type.
+    let mut linker = Linker::new(&engine);
+    let t = Table::new(
+        &mut store,
+        TableType::new(RefType::NULLFUNCREF, 0, None),
+        Ref::Func(None),
+    )?;
+    linker.define(&store, "env", "t", t)?;
+    let e = linker.instantiate(&mut store, &module).unwrap_err();
+    assert_eq!(e.to_string(), "incompatible import type for `env::t`");
+
+    Ok(())
+}
diff --git a/tests/all/main.rs b/tests/all/main.rs
index 54c8229b8eb1..dd2eb6158be2 100644
--- a/tests/all/main.rs
+++ b/tests/all/main.rs
@@ -1,13 +1,14 @@
 #![cfg_attr(miri, allow(dead_code, unused_imports))]
 
+mod arrays;
 mod async_functions;
 mod call_hook;
 mod cli_tests;
 mod code_too_large;
 mod component_model;
 mod coredump;
-mod custom_signal_handler;
 mod debug;
+mod defaults;
 mod epoch_interruption;
 mod externals;
 mod fuel;
@@ -16,6 +17,7 @@ mod funcref;
 mod gc;
 mod globals;
 mod host_funcs;
+mod i31ref;
 mod iloop;
 mod import_calling_export;
 mod import_indexes;
@@ -28,19 +30,20 @@ mod memory_creator;
 mod module;
 mod module_serialize;
 mod name;
+mod noextern;
+mod piped_tests;
 mod pooling_allocator;
 mod relocs;
+mod stack_creator;
 mod stack_overflow;
 mod store;
+mod structs;
 mod table;
 mod threads;
 mod traps;
+mod types;
 mod wait_notify;
 mod wasi_testsuite;
-mod wast;
-// Currently Winch is only supported in x86_64.
-#[cfg(all(target_arch = "x86_64"))]
-mod winch;
 
 /// A helper to compile a module in a new store with reference types enabled.
 pub(crate) fn ref_types_module(
@@ -54,10 +57,7 @@ pub(crate) fn ref_types_module(
     let mut config = Config::new();
     config.wasm_reference_types(true);
 
-    if !cfg!(target_arch = "s390x") {
-        // TODO(6530): s390x doesn't support tail calls yet.
-        config.wasm_tail_call(true);
-    }
+    config.wasm_tail_call(true);
 
     if use_epochs {
         config.epoch_interruption(true);
@@ -88,11 +88,16 @@ pub(crate) fn small_pool_config() -> wasmtime::PoolingAllocationConfig {
     let mut config = wasmtime::PoolingAllocationConfig::default();
 
     config.total_memories(1);
-    config.memory_pages(1);
+    config.max_memory_size(1 << 16);
     config.total_tables(1);
     config.table_elements(10);
 
-    #[cfg(feature = "async")]
+    // When testing, we may choose to start with MPK force-enabled to ensure
+    // we use that functionality.
+    if std::env::var("WASMTIME_TEST_FORCE_MPK").is_ok() {
+        config.memory_protection_keys(wasmtime::MpkEnabled::Enable);
+    }
+
     config.total_stacks(1);
 
     config
diff --git a/tests/all/memory.rs b/tests/all/memory.rs
index 6375854507a6..24746f204faf 100644
--- a/tests/all/memory.rs
+++ b/tests/all/memory.rs
@@ -1,8 +1,8 @@
-use anyhow::Result;
 use rayon::prelude::*;
 use std::sync::atomic::{AtomicU32, Ordering::SeqCst};
-use std::time::{Duration, Instant};
+use std::time::Duration;
 use wasmtime::*;
+use wasmtime_test_macros::wasmtime_test;
 
 fn module(engine: &Engine) -> Result<Module> {
     let mut wat = format!("(module\n");
@@ -28,12 +28,11 @@ fn module(engine: &Engine) -> Result<Module> {
         {
             for (j, instr) in instr.iter().enumerate() {
                 wat.push_str(&format!(
-                    "(func (export \"{} {} v{}\") (param i32)\n",
-                    width, offset, j
+                    "(func (export \"{width} {offset} v{j}\") (param i32)\n"
                 ));
                 wat.push_str("local.get 0\n");
                 wat.push_str(instr);
-                wat.push_str(&format!(" offset={}\n", offset));
+                wat.push_str(&format!(" offset={offset}\n"));
                 wat.push_str("drop\n)");
             }
         }
@@ -91,9 +90,9 @@ fn test_traps(store: &mut Store<()>, funcs: &[TestFunc], addr: u32, mem: &Memory
     }
 }
 
-#[test]
+#[wasmtime_test(wasm_features(simd))]
 #[cfg_attr(miri, ignore)]
-fn offsets_static_dynamic_oh_my() -> Result<()> {
+fn offsets_static_dynamic_oh_my(config: &mut Config) -> Result<()> {
     const GB: u64 = 1 << 30;
 
     let mut engines = Vec::new();
@@ -101,8 +100,6 @@ fn offsets_static_dynamic_oh_my() -> Result<()> {
     for &static_memory_maximum_size in sizes.iter() {
         for &guard_size in sizes.iter() {
             for &guard_before_linear_memory in [true, false].iter() {
-                let mut config = Config::new();
-                config.wasm_simd(true);
                 config.static_memory_maximum_size(static_memory_maximum_size);
                 config.dynamic_memory_guard_size(guard_size);
                 config.static_memory_guard_size(guard_size);
@@ -186,14 +183,77 @@ fn guards_present() -> Result<()> {
     Ok(())
 }
 
-#[test]
+#[wasmtime_test]
 #[cfg_attr(miri, ignore)]
-fn guards_present_pooling() -> Result<()> {
+fn guards_present_pooling(config: &mut Config) -> Result<()> {
     const GUARD_SIZE: u64 = 65536;
 
     let mut pool = crate::small_pool_config();
-    pool.total_memories(2).memory_pages(10);
-    let mut config = Config::new();
+    pool.total_memories(2)
+        .max_memory_size(10 << 16)
+        .memory_protection_keys(MpkEnabled::Disable);
+    config.static_memory_maximum_size(1 << 20);
+    config.dynamic_memory_guard_size(GUARD_SIZE);
+    config.static_memory_guard_size(GUARD_SIZE);
+    config.guard_before_linear_memory(true);
+    config.allocation_strategy(InstanceAllocationStrategy::Pooling(pool));
+    let engine = Engine::new(&config)?;
+
+    let mut store = Store::new(&engine, ());
+
+    let mem1 = {
+        let m = Module::new(&engine, "(module (memory (export \"\") 1 2))")?;
+        Instance::new(&mut store, &m, &[])?
+            .get_memory(&mut store, "")
+            .unwrap()
+    };
+    let mem2 = {
+        let m = Module::new(&engine, "(module (memory (export \"\") 1))")?;
+        Instance::new(&mut store, &m, &[])?
+            .get_memory(&mut store, "")
+            .unwrap()
+    };
+
+    unsafe fn assert_guards(store: &Store<()>, mem: &Memory) {
+        // guards before
+        println!("check pre-mem");
+        assert_faults(mem.data_ptr(&store).offset(-(GUARD_SIZE as isize)));
+
+        // unmapped just after memory
+        println!("check mem");
+        assert_faults(mem.data_ptr(&store).add(mem.data_size(&store)));
+
+        // guards after memory
+        println!("check post-mem");
+        assert_faults(mem.data_ptr(&store).add(1 << 20));
+    }
+    unsafe {
+        assert_guards(&store, &mem1);
+        assert_guards(&store, &mem2);
+        println!("growing");
+        mem1.grow(&mut store, 1).unwrap();
+        mem2.grow(&mut store, 1).unwrap();
+        assert_guards(&store, &mem1);
+        assert_guards(&store, &mem2);
+    }
+
+    Ok(())
+}
+
+#[wasmtime_test]
+#[cfg_attr(miri, ignore)]
+fn guards_present_pooling_mpk(config: &mut Config) -> Result<()> {
+    if !wasmtime::PoolingAllocationConfig::are_memory_protection_keys_available() {
+        println!("skipping `guards_present_pooling_mpk` test; mpk is not supported");
+        return Ok(());
+    }
+
+    const GUARD_SIZE: u64 = 65536;
+    let mut pool = crate::small_pool_config();
+    pool.total_memories(4)
+        .max_memory_size(10 << 16)
+        .memory_protection_keys(MpkEnabled::Enable)
+        .max_memory_protection_keys(2);
     config.static_memory_maximum_size(1 << 20);
     config.dynamic_memory_guard_size(GUARD_SIZE);
     config.static_memory_guard_size(GUARD_SIZE);
@@ -293,7 +353,7 @@ fn massive_64_bit_still_limited() -> Result<()> {
 
     let mut store = Store::new(&engine, MyLimiter { hit: false });
     store.limiter(|x| x);
-    let ty = MemoryType::new64(1 << 48, None);
+    let ty = MemoryType::new64(1 << 46, None);
     assert!(Memory::new(&mut store, ty).is_err());
     assert!(store.data().hit);
 
@@ -324,15 +384,14 @@ fn massive_64_bit_still_limited() -> Result<()> {
     }
 }
 
-#[test]
+#[wasmtime_test]
 #[cfg_attr(miri, ignore)]
-fn tiny_static_heap() -> Result<()> {
+fn tiny_static_heap(config: &mut Config) -> Result<()> {
     // The size of the memory in the module below is the exact same size as
     // the static memory size limit in the configuration. This is intended to
     // specifically test that a load of all the valid addresses of the memory
     // all pass bounds-checks in cranelift to help weed out any off-by-one bugs.
-    let mut config = Config::new();
-    config.static_memory_maximum_size(65536);
+    config.static_memory_maximum_size(1 << 16);
     let engine = Engine::new(&config)?;
     let mut store = Store::new(&engine, ());
 
@@ -365,7 +424,7 @@ fn tiny_static_heap() -> Result<()> {
 #[test]
 fn static_forced_max() -> Result<()> {
     let mut config = Config::new();
-    config.static_memory_maximum_size(5 * 65536);
+    config.static_memory_maximum_size(5 << 16);
     config.static_memory_forced(true);
     let engine = Engine::new(&config)?;
     let mut store = Store::new(&engine, ());
@@ -376,10 +435,9 @@ fn static_forced_max() -> Result<()> {
     Ok(())
 }
 
-#[test]
-fn dynamic_extra_growth_unchanged_pointer() -> Result<()> {
+#[wasmtime_test]
+fn dynamic_extra_growth_unchanged_pointer(config: &mut Config) -> Result<()> {
     const EXTRA_PAGES: u64 = 5;
-    let mut config = Config::new();
     config.static_memory_maximum_size(0);
     // 5 wasm pages extra
     config.dynamic_memory_reserved_for_growth(EXTRA_PAGES * (1 << 16));
@@ -435,14 +493,30 @@ fn dynamic_extra_growth_unchanged_pointer() -> Result<()> {
 // size of `1 << 48` pages. This should always fail but in the process of
 // determining this failure we shouldn't hit any overflows or anything like that
 // (checked via debug-mode tests).
-#[test]
-fn memory64_maximum_minimum() -> Result<()> {
-    let mut config = Config::new();
+#[wasmtime_test]
+fn memory64_maximum_minimum(config: &mut Config) -> Result<()> {
     config.wasm_memory64(true);
     let engine = Engine::new(&config)?;
     let mut store = Store::new(&engine, ());
 
-    assert!(Memory::new(&mut store, MemoryType::new64(1 << 48, None)).is_err());
+    assert!(MemoryTypeBuilder::default()
+        .memory64(true)
+        .min(1 << 48)
+        .build()
+        .is_err());
+
+    let module = Module::new(
+        &engine,
+        format!(r#"(module (import "" "" (memory i64 {})))"#, 1u64 << 48),
+    )?;
+    let mem_ty = module
+        .imports()
+        .next()
+        .unwrap()
+        .ty()
+        .unwrap_memory()
+        .clone();
+    assert!(Memory::new(&mut store, mem_ty).is_err());
 
     let module = Module::new(
         &engine,
@@ -481,7 +555,12 @@ fn shared_memory_basics() -> Result<()> {
     assert!(SharedMemory::new(&engine, MemoryType::new(1, Some(1))).is_err());
     assert!(SharedMemory::new(&engine, MemoryType::new64(1, None)).is_err());
     assert!(SharedMemory::new(&engine, MemoryType::new64(1, Some(1))).is_err());
-    assert!(SharedMemory::new(&engine, MemoryType::shared(1, 0)).is_err());
+    assert!(MemoryTypeBuilder::default()
+        .shared(true)
+        .min(1)
+        .max(Some(0))
+        .build()
+        .is_err());
 
     let memory = SharedMemory::new(&engine, MemoryType::shared(1, 1))?;
     assert!(memory.ty().is_shared());
@@ -523,7 +602,7 @@ fn shared_memory_basics() -> Result<()> {
     assert_eq!(memory.atomic_wait64(8, 1, None), Ok(WaitResult::Mismatch));
 
     // timeout
-    let near_future = Instant::now() + Duration::new(0, 100);
+    let near_future = Duration::new(0, 100);
     assert_eq!(
         memory.atomic_wait32(8, 0, Some(near_future)),
         Ok(WaitResult::TimedOut)
@@ -544,8 +623,8 @@ fn shared_memory_wait_notify() -> Result<()> {
 
     let engine = Engine::default();
     let memory = SharedMemory::new(&engine, MemoryType::shared(1, 1))?;
-    let data = unsafe { &*(memory.data().as_ptr() as *const AtomicU32) };
-    let locked = unsafe { &*(memory.data().as_ptr().add(4) as *const AtomicU32) };
+    let data = unsafe { AtomicU32::from_ptr(memory.data().as_ptr().cast_mut().cast()) };
+    let locked = unsafe { AtomicU32::from_ptr(memory.data().as_ptr().add(4).cast_mut().cast()) };
 
     // Note that `SeqCst` is used here to not think much about the orderings
     // here, and it also somewhat more closely mirrors what's happening in wasm.
@@ -576,3 +655,86 @@ fn shared_memory_wait_notify() -> Result<()> {
 
     Ok(())
 }
+
+#[wasmtime_test]
+#[cfg_attr(miri, ignore)]
+fn init_with_negative_segment(_: &mut Config) -> Result<()> {
+    let engine = Engine::default();
+    let module = Module::new(
+        &engine,
+        r#"
+            (module
+                (memory 65536)
+                (data (i32.const 0x8000_0000) "x")
+            )
+        "#,
+    )?;
+    let mut store = Store::new(&engine, ());
+    Instance::new(&mut store, &module, &[])?;
+    Ok(())
+}
+
+#[test]
+fn non_page_aligned_static_memory() -> Result<()> {
+    let mut config = Config::new();
+    config.static_memory_maximum_size(100_000);
+    config.static_memory_forced(true);
+    let engine = Engine::new(&config)?;
+    let ty = MemoryType::new(1, None);
+    Memory::new(&mut Store::new(&engine, ()), ty)?;
+    Ok(())
+}
+
+#[test]
+fn new_memory_with_custom_page_size() -> Result<()> {
+    let engine = Engine::default();
+    let mut store = Store::new(&engine, ());
+
+    let ty = MemoryTypeBuilder::default()
+        .page_size_log2(0)
+        .min(4096)
+        .max(Some(9000))
+        .build()?;
+
+    let mem = Memory::new(&mut store, ty)?;
+    assert_eq!(mem.data_size(&store), 4096);
+    assert_eq!(mem.size(&store), 4096);
+
+    mem.grow(&mut store, 9000 - 4096)?;
+    assert_eq!(mem.data_size(&store), 9000);
+    assert_eq!(mem.size(&store), 9000);
+
+    assert!(mem.grow(&mut store, 1).is_err());
+    assert_eq!(mem.data_size(&store), 9000);
+    assert_eq!(mem.size(&store), 9000);
+
+    Ok(())
+}
+
+#[wasmtime_test]
+#[cfg_attr(miri, ignore)]
+fn get_memory_type_with_custom_page_size_from_wasm(config: &mut Config) -> Result<()> {
+    config.wasm_custom_page_sizes(true);
+    let engine = Engine::new(&config)?;
+    let mut store = Store::new(&engine, ());
+
+    let module = Module::new(
+        &engine,
+        r#"
+            (module
+                (memory (export "memory") 1 0xffffffff (pagesize 1))
+            )
+        "#,
+    )?;
+
+    let instance = Instance::new(&mut store, &module, &[])?;
+    let memory = instance.get_memory(&mut store, "memory").unwrap();
+    let mem_ty = memory.ty(&store);
+
+    assert_eq!(mem_ty.minimum(), 1);
+    assert_eq!(mem_ty.maximum(), Some(0xffffffff));
+    assert_eq!(mem_ty.page_size(), 1);
+    assert_eq!(mem_ty.page_size_log2(), 0);
+
+    Ok(())
+}
diff --git a/tests/all/memory_creator.rs b/tests/all/memory_creator.rs
index 3984b2e00c42..69db3417375c 100644
--- a/tests/all/memory_creator.rs
+++ b/tests/all/memory_creator.rs
@@ -1,11 +1,10 @@
 #[cfg(all(not(target_os = "windows"), not(miri)))]
 mod not_for_windows {
     use wasmtime::*;
-    use wasmtime_environ::{WASM32_MAX_PAGES, WASM_PAGE_SIZE};
+    use wasmtime_environ::WASM32_MAX_SIZE;
 
     use rustix::mm::{mmap_anonymous, mprotect, munmap, MapFlags, MprotectFlags, ProtFlags};
 
-    use std::convert::TryFrom;
     use std::ops::Range;
     use std::ptr::null_mut;
     use std::sync::{Arc, Mutex};
@@ -23,11 +22,15 @@ mod not_for_windows {
             let page_size = rustix::param::page_size();
             let guard_size = page_size;
             let size = maximum + guard_size;
-            assert_eq!(size % page_size, 0); // we rely on WASM_PAGE_SIZE being multiple of host page size
+            // We rely on the Wasm page size being multiple of host page size.
+            assert_eq!(size % page_size, 0);
 
             let mem = mmap_anonymous(null_mut(), size, ProtFlags::empty(), MapFlags::PRIVATE)
                 .expect("mmap failed");
 
+            // NOTE: mmap_anonymous returns zero initialized memory, which is relied upon by this
+            // API.
+
             mprotect(mem, minimum, MprotectFlags::READ | MprotectFlags::WRITE)
                 .expect("mprotect failed");
             *glob_counter.lock().unwrap() += minimum;
@@ -59,7 +62,7 @@ mod not_for_windows {
         }
 
         fn grow_to(&mut self, new_size: usize) -> wasmtime::Result<()> {
-            println!("grow to {:x}", new_size);
+            println!("grow to {new_size:x}");
             let delta = new_size - self.used_wasm_bytes;
             unsafe {
                 let start = (self.mem as *mut u8).add(self.used_wasm_bytes) as _;
@@ -77,7 +80,7 @@ mod not_for_windows {
         }
 
         fn wasm_accessible(&self) -> Range<usize> {
-            let base = self.mem as usize;
+            let base = self.mem;
             let end = base + self.size;
             base..end
         }
@@ -112,9 +115,7 @@ mod not_for_windows {
             unsafe {
                 let mem = Box::new(CustomMemory::new(
                     minimum,
-                    maximum.unwrap_or(
-                        usize::try_from(WASM32_MAX_PAGES * u64::from(WASM_PAGE_SIZE)).unwrap(),
-                    ),
+                    maximum.unwrap_or(usize::try_from(WASM32_MAX_SIZE).unwrap()),
                     self.num_total_bytes.clone(),
                 ));
                 *self.num_created_memories.lock().unwrap() += 1;
@@ -180,7 +181,10 @@ mod not_for_windows {
 
         // we take the lock outside the assert, so it won't get poisoned on assert failure
         let tot_pages = *mem_creator.num_total_bytes.lock().unwrap();
-        assert_eq!(tot_pages, (4 * WASM_PAGE_SIZE) as usize);
+        assert_eq!(
+            tot_pages,
+            (4 * wasmtime_environ::Memory::DEFAULT_PAGE_SIZE) as usize
+        );
 
         drop(store);
         let tot_pages = *mem_creator.num_total_bytes.lock().unwrap();
diff --git a/tests/all/module.rs b/tests/all/module.rs
index 9efedb94bde6..8cb55a3c5b18 100644
--- a/tests/all/module.rs
+++ b/tests/all/module.rs
@@ -1,4 +1,3 @@
-use anyhow::Result;
 use wasmtime::*;
 
 #[test]
@@ -11,9 +10,8 @@ fn checks_incompatible_target() -> Result<()> {
     ) {
         Ok(_) => unreachable!(),
         Err(e) => assert!(
-            format!("{:?}", e).contains("configuration does not match the host"),
-            "bad error: {:?}",
-            e
+            format!("{e:?}").contains("configuration does not match the host"),
+            "bad error: {e:?}"
         ),
     }
 
@@ -43,7 +41,7 @@ fn caches_across_engines() {
         // differ in wasm features enabled (which can affect
         // runtime/compilation settings)
         let res = Module::deserialize(
-            &Engine::new(Config::new().wasm_simd(false)).unwrap(),
+            &Engine::new(Config::new().wasm_threads(false)).unwrap(),
             &bytes,
         );
         assert!(res.is_err());
@@ -78,28 +76,28 @@ fn serialize_deterministic() {
         let p1 = engine.precompile_module(wasm.as_bytes()).unwrap();
         let p2 = engine.precompile_module(wasm.as_bytes()).unwrap();
         if p1 != p2 {
-            panic!("precompile_module not deterministic for:\n{}", wasm);
+            panic!("precompile_module not deterministic for:\n{wasm}");
         }
 
         let module1 = Module::new(&engine, wasm).unwrap();
         let a1 = module1.serialize().unwrap();
         let a2 = module1.serialize().unwrap();
         if a1 != a2 {
-            panic!("Module::serialize not deterministic for:\n{}", wasm);
+            panic!("Module::serialize not deterministic for:\n{wasm}");
         }
 
         let module2 = Module::new(&engine, wasm).unwrap();
         let b1 = module2.serialize().unwrap();
         let b2 = module2.serialize().unwrap();
         if b1 != b2 {
-            panic!("Module::serialize not deterministic for:\n{}", wasm);
+            panic!("Module::serialize not deterministic for:\n{wasm}");
         }
 
         if a1 != b2 {
-            panic!("not matching across modules:\n{}", wasm);
+            panic!("not matching across modules:\n{wasm}");
         }
         if b1 != p2 {
-            panic!("not matching across engine/module:\n{}", wasm);
+            panic!("not matching across engine/module:\n{wasm}");
         }
     };
 
@@ -123,7 +121,7 @@ fn serialize_not_overly_massive() -> Result<()> {
     let engine = Engine::new(&config)?;
 
     let assert_smaller_than_1mb = |module: &str| -> Result<()> {
-        println!("{}", module);
+        println!("{module}");
         let bytes = Module::new(&engine, module)?.serialize()?;
         assert!(bytes.len() < (1 << 20));
         Ok(())
@@ -182,7 +180,7 @@ fn serialize_not_overly_massive() -> Result<()> {
 #[cfg_attr(any(not(target_arch = "x86_64"), miri), ignore)]
 fn missing_sse_and_floats_still_works() -> Result<()> {
     let mut config = Config::new();
-    config.wasm_simd(false);
+    config.wasm_simd(false).wasm_relaxed_simd(false);
     unsafe {
         config.cranelift_flag_set("has_sse41", "false");
     }
@@ -239,3 +237,62 @@ fn large_add_chain_no_stack_overflow() -> Result<()> {
 
     Ok(())
 }
+
+#[test]
+fn compile_a_component() -> Result<()> {
+    let engine = Engine::default();
+    let err = Module::new(&engine, "(component)").unwrap_err();
+    let err = format!("{err:?}");
+    assert!(
+        err.contains("expected a WebAssembly module but was given a WebAssembly component"),
+        "bad error: {err}"
+    );
+    Ok(())
+}
+
+#[test]
+fn tail_call_defaults() -> Result<()> {
+    let wasm_with_tail_calls = "(module (func $a return_call $a))";
+
+    // on by default
+    Module::new(&Engine::default(), wasm_with_tail_calls)?;
+
+    // on by default for cranelift
+    Module::new(
+        &Engine::new(Config::new().strategy(Strategy::Cranelift))?,
+        wasm_with_tail_calls,
+    )?;
+
+    if cfg!(target_arch = "x86_64") {
+        // off by default for winch
+        let err = Module::new(
+            &Engine::new(Config::new().strategy(Strategy::Winch))?,
+            wasm_with_tail_calls,
+        );
+        assert!(err.is_err());
+    }
+    Ok(())
+}
+
+#[test]
+fn cross_engine_module_exports() -> Result<()> {
+    let a_engine = Engine::default();
+    let b_engine = Engine::default();
+
+    let a_module = Module::new(&a_engine, "(module)")?;
+    let b_module = Module::new(
+        &b_engine,
+        r#"
+            (module
+                (func (export "x"))
+            )
+        "#,
+    )?;
+
+    let export = b_module.get_export_index("x").unwrap();
+
+    let mut store = Store::new(&a_engine, ());
+    let instance = Instance::new(&mut store, &a_module, &[])?;
+    assert!(instance.get_module_export(&mut store, &export).is_none());
+    Ok(())
+}
diff --git a/tests/all/module_serialize.rs b/tests/all/module_serialize.rs
index 6f83b3b3b0fc..92f202c56ad6 100644
--- a/tests/all/module_serialize.rs
+++ b/tests/all/module_serialize.rs
@@ -1,4 +1,4 @@
-use anyhow::{bail, Result};
+use anyhow::bail;
 use std::fs;
 use wasmtime::*;
 
diff --git a/tests/all/noextern.rs b/tests/all/noextern.rs
new file mode 100644
index 000000000000..59394d4f14b6
--- /dev/null
+++ b/tests/all/noextern.rs
@@ -0,0 +1,71 @@
+use std::sync::atomic::{AtomicU32, Ordering};
+use wasmtime::*;
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn func_wrap_no_extern() -> Result<()> {
+    let mut config = Config::default();
+    config.wasm_function_references(true);
+    config.wasm_gc(true);
+
+    let engine = Engine::new(&config)?;
+
+    let module = Module::new(
+        &engine,
+        r#"
+            (module
+                (import "" "" (func (param nullexternref) (result nullexternref)))
+                (func $main
+                    ref.null noextern
+                    call 0
+                    drop
+                )
+                (start $main)
+            )
+        "#,
+    )?;
+
+    let mut store = Store::new(&engine, ());
+
+    static HITS: AtomicU32 = AtomicU32::new(0);
+
+    let f = Func::wrap(&mut store, |x: Option<NoExtern>| -> Option<NoExtern> {
+        assert!(x.is_none());
+        HITS.fetch_add(1, Ordering::SeqCst);
+        x
+    });
+
+    let _ = Instance::new(&mut store, &module, &[f.into()])?;
+    assert_eq!(HITS.load(Ordering::SeqCst), 1);
+
+    Ok(())
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn func_typed_no_extern() -> Result<()> {
+    let mut config = Config::default();
+    config.wasm_function_references(true);
+    config.wasm_gc(true);
+
+    let engine = Engine::new(&config)?;
+
+    let module = Module::new(
+        &engine,
+        r#"
+            (module
+                (func (export "f") (param nullexternref) (result nullexternref)
+                    local.get 0
+                )
+            )
+        "#,
+    )?;
+
+    let mut store = Store::new(&engine, ());
+    let instance = Instance::new(&mut store, &module, &[])?;
+    let f = instance.get_typed_func::<Option<NoExtern>, Option<NoExtern>>(&mut store, "f")?;
+    let result = f.call(&mut store, None)?;
+    assert!(result.is_none());
+
+    Ok(())
+}
diff --git a/tests/all/piped_tests.rs b/tests/all/piped_tests.rs
new file mode 100644
index 000000000000..b4bda7ce3f5a
--- /dev/null
+++ b/tests/all/piped_tests.rs
@@ -0,0 +1,69 @@
+#![cfg(not(miri))]
+
+use super::cli_tests::get_wasmtime_command;
+use anyhow::Result;
+use std::process::Stdio;
+
+pub fn run_wasmtime_piped(component_path: &str) -> Result<()> {
+    let mut producer = get_wasmtime_command()?
+        .arg("run")
+        .arg("-Wcomponent-model")
+        .arg("--env")
+        .arg("PIPED_SIDE=PRODUCER")
+        .arg(component_path)
+        .stdout(Stdio::piped())
+        .spawn()?;
+
+    let mut consumer = get_wasmtime_command()?
+        .arg("run")
+        .arg("-Wcomponent-model")
+        .arg("--env")
+        .arg("PIPED_SIDE=CONSUMER")
+        .arg(component_path)
+        .stdin(producer.stdout.take().unwrap())
+        .spawn()?;
+
+    let producer = producer.wait()?;
+    if !producer.success() {
+        // make sure the consumer gets killed off
+        if consumer.try_wait().is_err() {
+            consumer.kill().expect("Failed to kill consumer");
+        }
+
+        panic!("Producer failed");
+    }
+
+    assert!(consumer.wait()?.success(), "Consumer failed");
+
+    Ok(())
+}
+
+mod test_programs {
+    use super::run_wasmtime_piped;
+    use test_programs_artifacts::*;
+
+    macro_rules! assert_test_exists {
+        ($name:ident) => {
+            #[allow(unused_imports)]
+            use self::$name as _;
+        };
+    }
+    foreach_piped!(assert_test_exists);
+
+    // Below here is mechanical: there should be one test for every binary in
+    // wasi-tests.
+    #[test]
+    fn piped_simple() {
+        run_wasmtime_piped(PIPED_SIMPLE_COMPONENT).unwrap()
+    }
+
+    #[test]
+    fn piped_multiple() {
+        run_wasmtime_piped(PIPED_MULTIPLE_COMPONENT).unwrap()
+    }
+
+    #[test]
+    fn piped_polling() {
+        run_wasmtime_piped(PIPED_POLLING_COMPONENT).unwrap()
+    }
+}
diff --git a/tests/all/pooling_allocator.rs b/tests/all/pooling_allocator.rs
index dc23686de885..aa95d0acf5ae 100644
--- a/tests/all/pooling_allocator.rs
+++ b/tests/all/pooling_allocator.rs
@@ -1,5 +1,4 @@
 use super::skip_pooling_allocator_tests;
-use anyhow::Result;
 use wasmtime::*;
 
 #[test]
@@ -9,7 +8,7 @@ fn successful_instantiation() -> Result<()> {
     config.allocation_strategy(InstanceAllocationStrategy::Pooling(pool));
     config.dynamic_memory_guard_size(0);
     config.static_memory_guard_size(0);
-    config.static_memory_maximum_size(65536);
+    config.static_memory_maximum_size(1 << 16);
 
     let engine = Engine::new(&config)?;
     let module = Module::new(&engine, r#"(module (memory 1) (table 10 funcref))"#)?;
@@ -25,12 +24,12 @@ fn successful_instantiation() -> Result<()> {
 #[cfg_attr(miri, ignore)]
 fn memory_limit() -> Result<()> {
     let mut pool = crate::small_pool_config();
-    pool.memory_pages(3);
+    pool.max_memory_size(3 << 16);
     let mut config = Config::new();
     config.allocation_strategy(InstanceAllocationStrategy::Pooling(pool));
     config.dynamic_memory_guard_size(0);
-    config.static_memory_guard_size(65536);
-    config.static_memory_maximum_size(3 * 65536);
+    config.static_memory_guard_size(1 << 16);
+    config.static_memory_maximum_size(3 << 16);
     config.wasm_multi_memory(true);
 
     let engine = Engine::new(&config)?;
@@ -50,7 +49,7 @@ fn memory_limit() -> Result<()> {
         Ok(_) => panic!("module instantiation should fail"),
         Err(e) => assert_eq!(
             e.to_string(),
-            "memory index 0 has a minimum page size of 4 which exceeds the limit of 3",
+            "memory index 0 has a minimum byte size of 262144 which exceeds the limit of 196608 bytes",
         ),
     }
 
@@ -98,7 +97,7 @@ fn memory_limit() -> Result<()> {
 #[test]
 fn memory_init() -> Result<()> {
     let mut pool = crate::small_pool_config();
-    pool.memory_pages(2).table_elements(0);
+    pool.max_memory_size(2 << 16).table_elements(0);
     let mut config = Config::new();
     config.allocation_strategy(InstanceAllocationStrategy::Pooling(pool));
 
@@ -132,7 +131,7 @@ fn memory_init() -> Result<()> {
 #[cfg_attr(miri, ignore)]
 fn memory_guard_page_trap() -> Result<()> {
     let mut pool = crate::small_pool_config();
-    pool.memory_pages(2).table_elements(0);
+    pool.max_memory_size(2 << 16).table_elements(0);
     let mut config = Config::new();
     config.allocation_strategy(InstanceAllocationStrategy::Pooling(pool));
 
@@ -199,12 +198,12 @@ fn memory_zeroed() -> Result<()> {
     }
 
     let mut pool = crate::small_pool_config();
-    pool.memory_pages(1).table_elements(0);
+    pool.max_memory_size(1 << 16).table_elements(0);
     let mut config = Config::new();
     config.allocation_strategy(InstanceAllocationStrategy::Pooling(pool));
     config.dynamic_memory_guard_size(0);
     config.static_memory_guard_size(0);
-    config.static_memory_maximum_size(65536);
+    config.static_memory_maximum_size(1 << 16);
 
     let engine = Engine::new(&config)?;
 
@@ -242,7 +241,7 @@ fn table_limit() -> Result<()> {
     config.allocation_strategy(InstanceAllocationStrategy::Pooling(pool));
     config.dynamic_memory_guard_size(0);
     config.static_memory_guard_size(0);
-    config.static_memory_maximum_size(65536);
+    config.static_memory_maximum_size(1 << 16);
 
     let engine = Engine::new(&config)?;
 
@@ -303,14 +302,14 @@ fn table_limit() -> Result<()> {
         assert_eq!(table.size(&store), i);
         assert_eq!(
             table
-                .grow(&mut store, 1, Val::FuncRef(None))
+                .grow(&mut store, 1, Ref::Func(None))
                 .expect("table should grow"),
             i
         );
     }
 
     assert_eq!(table.size(&store), TABLE_ELEMENTS);
-    assert!(table.grow(&mut store, 1, Val::FuncRef(None)).is_err());
+    assert!(table.grow(&mut store, 1, Ref::Func(None)).is_err());
 
     Ok(())
 }
@@ -319,7 +318,7 @@ fn table_limit() -> Result<()> {
 #[cfg_attr(miri, ignore)]
 fn table_init() -> Result<()> {
     let mut pool = crate::small_pool_config();
-    pool.memory_pages(0).table_elements(6);
+    pool.max_memory_size(0).table_elements(6);
     let mut config = Config::new();
     config.allocation_strategy(InstanceAllocationStrategy::Pooling(pool));
 
@@ -348,7 +347,7 @@ fn table_init() -> Result<()> {
     for i in 0..5 {
         let v = table.get(&mut store, i).expect("table should have entry");
         let f = v
-            .funcref()
+            .as_func()
             .expect("expected funcref")
             .expect("expected non-null value");
         assert_eq!(f.ty(&store).params().len(), i as usize);
@@ -358,7 +357,7 @@ fn table_init() -> Result<()> {
         table
             .get(&mut store, 5)
             .expect("table should have entry")
-            .funcref()
+            .as_func()
             .expect("expected funcref")
             .is_none(),
         "funcref should be null"
@@ -378,7 +377,7 @@ fn table_zeroed() -> Result<()> {
     config.allocation_strategy(InstanceAllocationStrategy::Pooling(pool));
     config.dynamic_memory_guard_size(0);
     config.static_memory_guard_size(0);
-    config.static_memory_maximum_size(65536);
+    config.static_memory_maximum_size(1 << 16);
 
     let engine = Engine::new(&config)?;
 
@@ -395,12 +394,10 @@ fn table_zeroed() -> Result<()> {
 
         for i in 0..10 {
             match table.get(&mut store, i).unwrap() {
-                Val::FuncRef(r) => assert!(r.is_none()),
+                Ref::Func(r) => assert!(r.is_none()),
                 _ => panic!("expected a funcref"),
             }
-            table
-                .set(&mut store, i, Val::FuncRef(Some(f.clone())))
-                .unwrap();
+            table.set(&mut store, i, Ref::Func(Some(f))).unwrap();
         }
     }
 
@@ -416,7 +413,7 @@ fn total_core_instances_limit() -> Result<()> {
     config.allocation_strategy(InstanceAllocationStrategy::Pooling(pool));
     config.dynamic_memory_guard_size(0);
     config.static_memory_guard_size(0);
-    config.static_memory_maximum_size(65536);
+    config.static_memory_maximum_size(1 << 16);
 
     let engine = Engine::new(&config)?;
     let module = Module::new(&engine, r#"(module)"#)?;
@@ -431,13 +428,7 @@ fn total_core_instances_limit() -> Result<()> {
 
         match Instance::new(&mut store, &module, &[]) {
             Ok(_) => panic!("instantiation should fail"),
-            Err(e) => assert_eq!(
-                e.to_string(),
-                format!(
-                    "maximum concurrent core instance limit of {} reached",
-                    INSTANCE_LIMIT
-                )
-            ),
+            Err(e) => assert!(e.is::<PoolConcurrencyLimitError>()),
         }
     }
 
@@ -649,13 +640,23 @@ fn instance_too_large() -> Result<()> {
     config.allocation_strategy(InstanceAllocationStrategy::Pooling(pool));
 
     let engine = Engine::new(&config)?;
-    let expected = "\
-instance allocation for this module requires 240 bytes which exceeds the \
+    let expected = if cfg!(feature = "wmemcheck") {
+        "\
+        instance allocation for this module requires 336 bytes which exceeds the \
 configured maximum of 16 bytes; breakdown of allocation requirement:
 
- * 66.67% - 160 bytes - instance state management
- * 6.67% - 16 bytes - jit store state
-";
+ * 71.43% - 240 bytes - instance state management
+ * 26.19% - 88 bytes - static vmctx data
+"
+    } else {
+        "\
+        instance allocation for this module requires 240 bytes which exceeds the \
+configured maximum of 16 bytes; breakdown of allocation requirement:
+
+ * 60.00% - 144 bytes - instance state management
+ * 36.67% - 88 bytes - static vmctx data
+"
+    };
     match Module::new(&engine, "(module)") {
         Ok(_) => panic!("should have failed to compile"),
         Err(e) => assert_eq!(e.to_string(), expected),
@@ -667,13 +668,23 @@ configured maximum of 16 bytes; breakdown of allocation requirement:
     }
     lots_of_globals.push_str(")");
 
-    let expected = "\
+    let expected = if cfg!(feature = "wmemcheck") {
+        "\
+instance allocation for this module requires 1936 bytes which exceeds the \
+configured maximum of 16 bytes; breakdown of allocation requirement:
+
+ * 12.40% - 240 bytes - instance state management
+ * 82.64% - 1600 bytes - defined globals
+"
+    } else {
+        "\
 instance allocation for this module requires 1840 bytes which exceeds the \
 configured maximum of 16 bytes; breakdown of allocation requirement:
 
- * 8.70% - 160 bytes - instance state management
+ * 7.83% - 144 bytes - instance state management
  * 86.96% - 1600 bytes - defined globals
-";
+"
+    };
     match Module::new(&engine, &lots_of_globals) {
         Ok(_) => panic!("should have failed to compile"),
         Err(e) => assert_eq!(e.to_string(), expected),
@@ -688,7 +699,7 @@ fn dynamic_memory_pooling_allocator() -> Result<()> {
     for guard_size in [0, 1 << 16] {
         let max_size = 128 << 20;
         let mut pool = crate::small_pool_config();
-        pool.memory_pages(max_size / (64 * 1024));
+        pool.max_memory_size(max_size as usize);
         let mut config = Config::new();
         config.static_memory_maximum_size(max_size);
         config.dynamic_memory_guard_size(guard_size);
@@ -794,7 +805,7 @@ fn dynamic_memory_pooling_allocator() -> Result<()> {
 #[cfg_attr(miri, ignore)]
 fn zero_memory_pages_disallows_oob() -> Result<()> {
     let mut pool = crate::small_pool_config();
-    pool.memory_pages(0);
+    pool.max_memory_size(0);
     let mut config = Config::new();
     config.allocation_strategy(InstanceAllocationStrategy::Pooling(pool));
 
@@ -849,13 +860,7 @@ fn total_component_instances_limit() -> Result<()> {
 
     match linker.instantiate(&mut store, &component) {
         Ok(_) => panic!("should have hit component instance limit"),
-        Err(e) => assert_eq!(
-            e.to_string(),
-            format!(
-                "maximum concurrent component instance limit of {} reached",
-                TOTAL_COMPONENT_INSTANCES
-            ),
-        ),
+        Err(e) => assert!(e.is::<PoolConcurrencyLimitError>()),
     }
 
     drop(store);
@@ -911,10 +916,7 @@ fn total_tables_limit() -> Result<()> {
 
     match linker.instantiate(&mut store, &module) {
         Ok(_) => panic!("should have hit table limit"),
-        Err(e) => assert_eq!(
-            e.to_string(),
-            format!("maximum concurrent table limit of {} reached", TOTAL_TABLES),
-        ),
+        Err(e) => assert!(e.is::<PoolConcurrencyLimitError>()),
     }
 
     drop(store);
@@ -946,7 +948,7 @@ async fn total_stacks_limit() -> Result<()> {
     linker.func_new_async(
         "async",
         "yield",
-        FuncType::new([], []),
+        FuncType::new(&engine, [], []),
         |_caller, _params, _results| {
             Box::new(async {
                 tokio::task::yield_now().await;
@@ -988,10 +990,7 @@ async fn total_stacks_limit() -> Result<()> {
     let mut store3 = Store::new(&engine, ());
     match linker.instantiate_async(&mut store3, &module).await {
         Ok(_) => panic!("should have hit stack limit"),
-        Err(e) => assert_eq!(
-            e.to_string(),
-            format!("maximum concurrent fiber limit of {} reached", TOTAL_STACKS),
-        ),
+        Err(e) => assert!(e.is::<PoolConcurrencyLimitError>()),
     }
 
     // Finish the futures and return their Wasm stacks to the pool.
@@ -1151,7 +1150,8 @@ fn total_memories_limit() -> Result<()> {
 
     let mut pool = crate::small_pool_config();
     pool.total_memories(TOTAL_MEMORIES)
-        .total_core_instances(TOTAL_MEMORIES + 1);
+        .total_core_instances(TOTAL_MEMORIES + 1)
+        .memory_protection_keys(MpkEnabled::Disable);
     let mut config = Config::new();
     config.allocation_strategy(InstanceAllocationStrategy::Pooling(pool));
 
@@ -1166,13 +1166,7 @@ fn total_memories_limit() -> Result<()> {
 
     match linker.instantiate(&mut store, &module) {
         Ok(_) => panic!("should have hit memory limit"),
-        Err(e) => assert_eq!(
-            e.to_string(),
-            format!(
-                "maximum concurrent memory limit of {} reached for stripe 0",
-                TOTAL_MEMORIES
-            ),
-        ),
+        Err(e) => assert!(e.is::<PoolConcurrencyLimitError>()),
     }
 
     drop(store);
@@ -1183,3 +1177,41 @@ fn total_memories_limit() -> Result<()> {
 
     Ok(())
 }
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn decommit_batching() -> Result<()> {
+    for (capacity, batch_size) in [
+        // A reasonable batch size.
+        (10, 5),
+        // Batch sizes of zero and one should effectively disable batching.
+        (10, 1),
+        (10, 0),
+        // A bigger batch size than capacity, which forces the allocation path
+        // to flush the decommit queue.
+        (10, 99),
+    ] {
+        let mut pool = crate::small_pool_config();
+        pool.total_memories(capacity)
+            .total_core_instances(capacity)
+            .decommit_batch_size(batch_size)
+            .memory_protection_keys(MpkEnabled::Disable);
+        let mut config = Config::new();
+        config.allocation_strategy(InstanceAllocationStrategy::Pooling(pool));
+
+        let engine = Engine::new(&config)?;
+        let linker = Linker::new(&engine);
+        let module = Module::new(&engine, "(module (memory 1 1))")?;
+
+        // Just make sure that we can instantiate all slots a few times and the
+        // pooling allocator must be flushing the decommit queue as necessary.
+        for _ in 0..3 {
+            let mut store = Store::new(&engine, ());
+            for _ in 0..capacity {
+                linker.instantiate(&mut store, &module)?;
+            }
+        }
+    }
+
+    Ok(())
+}
diff --git a/tests/all/relocs.rs b/tests/all/relocs.rs
index db2feee5dbc3..f04472efe146 100644
--- a/tests/all/relocs.rs
+++ b/tests/all/relocs.rs
@@ -10,7 +10,6 @@
 
 #![cfg(not(miri))]
 
-use anyhow::Result;
 use wasmtime::*;
 
 const MB: usize = 1 << 20;
@@ -93,12 +92,12 @@ fn test_many_call_module(mut store: Store<()>) -> Result<()> {
     wat.push_str("(module\n");
     wat.push_str("(func $first (result i32) (i32.const 1))\n");
     for i in 0..N {
-        wat.push_str(&format!("(func (export \"{}\") (result i32 i32)\n", i));
+        wat.push_str(&format!("(func (export \"{i}\") (result i32 i32)\n"));
         wat.push_str("call $first\n");
-        wat.push_str(&format!("i32.const {}\n", i));
+        wat.push_str(&format!("i32.const {i}\n"));
         wat.push_str("i32.add\n");
         wat.push_str("call $last\n");
-        wat.push_str(&format!("i32.const {}\n", i));
+        wat.push_str(&format!("i32.const {i}\n"));
         wat.push_str("i32.add)\n");
     }
     wat.push_str("(func $last (result i32) (i32.const 2))\n");
diff --git a/tests/all/stack_creator.rs b/tests/all/stack_creator.rs
new file mode 100644
index 000000000000..9545908d1a18
--- /dev/null
+++ b/tests/all/stack_creator.rs
@@ -0,0 +1,157 @@
+#![cfg(all(not(target_os = "windows"), not(miri)))]
+use anyhow::{bail, Context};
+use std::{
+    alloc::{GlobalAlloc, Layout, System},
+    ops::Range,
+    ptr::NonNull,
+    sync::Arc,
+};
+use wasmtime::*;
+
+fn align_up(v: usize, align: usize) -> usize {
+    return (v + (align - 1)) & (!(align - 1));
+}
+
+struct CustomStack {
+    base: NonNull<u8>,
+    len: usize,
+}
+unsafe impl Send for CustomStack {}
+unsafe impl Sync for CustomStack {}
+impl CustomStack {
+    fn new(base: NonNull<u8>, len: usize) -> Self {
+        CustomStack { base, len }
+    }
+}
+unsafe impl StackMemory for CustomStack {
+    fn top(&self) -> *mut u8 {
+        unsafe { self.base.as_ptr().add(self.len) }
+    }
+    fn range(&self) -> Range<usize> {
+        let base = self.base.as_ptr() as usize;
+        base..base + self.len
+    }
+}
+
+// A creator that allocates stacks on the heap instead of mmap'ing.
+struct CustomStackCreator {
+    memory: NonNull<u8>,
+    size: usize,
+    layout: Layout,
+}
+
+unsafe impl Send for CustomStackCreator {}
+unsafe impl Sync for CustomStackCreator {}
+impl CustomStackCreator {
+    fn new() -> Result<Self> {
+        // 1MB
+        const MINIMUM_STACK_SIZE: usize = 1 * 1_024 * 1_024;
+        let page_size = rustix::param::page_size();
+        let size = align_up(MINIMUM_STACK_SIZE, page_size);
+        // Add an extra page for the guard page
+        let layout = Layout::from_size_align(size + page_size, page_size)
+            .context("unable to compute stack layout")?;
+        let memory = unsafe {
+            let mem = System.alloc(layout);
+            let notnull = NonNull::new(mem);
+            if let Some(mem) = notnull {
+                // It's required that stack memory is zeroed for wasmtime
+                libc::memset(mem.as_ptr().cast(), 0, layout.size());
+                // Mark guard page as protected
+                rustix::mm::mprotect(
+                    mem.as_ptr().cast(),
+                    page_size,
+                    rustix::mm::MprotectFlags::empty(),
+                )?;
+            }
+            notnull
+        }
+        .context("unable to allocate stack memory")?;
+        Ok(CustomStackCreator {
+            memory,
+            size,
+            layout,
+        })
+    }
+    fn range(&self) -> Range<usize> {
+        let page_size = rustix::param::page_size();
+        let base = unsafe { self.memory.as_ptr().add(page_size) as usize };
+        base..base + self.size
+    }
+}
+impl Drop for CustomStackCreator {
+    fn drop(&mut self) {
+        let page_size = rustix::param::page_size();
+        unsafe {
+            // Unprotect the guard page as the allocator could reuse it.
+            rustix::mm::mprotect(
+                self.memory.as_ptr().cast(),
+                page_size,
+                rustix::mm::MprotectFlags::READ | rustix::mm::MprotectFlags::WRITE,
+            )
+            .unwrap();
+            System.dealloc(self.memory.as_ptr(), self.layout);
+        }
+    }
+}
+unsafe impl StackCreator for CustomStackCreator {
+    fn new_stack(&self, size: usize) -> Result<Box<dyn StackMemory>> {
+        if size != self.size {
+            bail!("must use the size we allocated for this stack memory creator");
+        }
+        let page_size = rustix::param::page_size();
+        // skip over the page size
+        let base_ptr = unsafe { self.memory.as_ptr().add(page_size) };
+        let base = NonNull::new(base_ptr).context("unable to compute stack base")?;
+        Ok(Box::new(CustomStack::new(base, self.size)))
+    }
+}
+
+fn config() -> (Store<()>, Arc<CustomStackCreator>) {
+    let stack_creator = Arc::new(CustomStackCreator::new().unwrap());
+    let mut config = Config::new();
+    config
+        .async_support(true)
+        .max_wasm_stack(stack_creator.size / 2)
+        .async_stack_size(stack_creator.size)
+        .with_host_stack(stack_creator.clone());
+    (
+        Store::new(&Engine::new(&config).unwrap(), ()),
+        stack_creator,
+    )
+}
+
+#[tokio::test]
+async fn called_on_custom_heap_stack() -> Result<()> {
+    let (mut store, stack_creator) = config();
+    let module = Module::new(
+        store.engine(),
+        r#"
+            (module
+                (import "host" "callback" (func $callback (result i64)))
+                (func $f (result i64) (call $callback))
+                (export "f" (func $f))
+            )
+        "#,
+    )?;
+
+    let ty = FuncType::new(store.engine(), [], [ValType::I64]);
+    let host_func = Func::new(&mut store, ty, move |_caller, _params, results| {
+        let foo = 42;
+        // output an address on the stack
+        results[0] = Val::I64((&foo as *const i32) as usize as i64);
+        Ok(())
+    });
+    let export = wasmtime::Extern::Func(host_func);
+    let instance = Instance::new_async(&mut store, &module, &[export]).await?;
+    let mut results = [Val::I64(0)];
+    instance
+        .get_func(&mut store, "f")
+        .context("missing function export")?
+        .call_async(&mut store, &[], &mut results)
+        .await?;
+    // Make sure the stack address we wrote was within our custom stack range
+    let stack_address = results[0].i64().unwrap() as usize;
+    assert!(stack_creator.range().contains(&stack_address));
+    Ok(())
+}
diff --git a/tests/all/stack_overflow.rs b/tests/all/stack_overflow.rs
index ec534b7af594..791d481d8870 100644
--- a/tests/all/stack_overflow.rs
+++ b/tests/all/stack_overflow.rs
@@ -1,6 +1,5 @@
 #![cfg(not(miri))]
 
-use anyhow::Result;
 use std::sync::atomic::{AtomicUsize, Ordering::SeqCst};
 use wasmtime::*;
 
@@ -10,35 +9,97 @@ fn host_always_has_some_stack() -> Result<()> {
     // assume hosts always have at least 128k of stack
     const HOST_STACK: usize = 128 * 1024;
 
-    let mut store = Store::<()>::default();
+    let mut store = if cfg!(target_arch = "x86_64") {
+        let mut config = Config::new();
+        // Force cranelift-based libcalls to show up by ensuring that platform
+        // support is turned off.
+        unsafe {
+            config.cranelift_flag_set("has_avx", "false");
+            config.cranelift_flag_set("has_sse42", "false");
+            config.cranelift_flag_set("has_sse41", "false");
+            config.cranelift_flag_set("has_ssse3", "false");
+            config.cranelift_flag_set("has_sse3", "false");
+        }
+        Store::new(&Engine::new(&config)?, ())
+    } else {
+        Store::<()>::default()
+    };
 
     // Create a module that's infinitely recursive, but calls the host on each
     // level of wasm stack to always test how much host stack we have left.
+    //
+    // Each of the function exports of this module calls out to the host in a
+    // different way, and each one is tested below to make sure that the way of
+    // exiting out to the host is tested thoroughly.
     let module = Module::new(
         store.engine(),
         r#"
             (module
-                (import "" "" (func $host))
-                (func $recursive (export "foo")
-                    call $host
-                    call $recursive)
+                (import "" "" (func $host1))
+                (import "" "" (func $host2))
+
+                ;; exit via wasm-to-native trampoline
+                (func $recursive1 (export "f1")
+                    call $host1
+                    call $recursive1)
+
+                ;; exit via wasm-to-array trampoline
+                (func $recursive2 (export "f2")
+                    call $host2
+                    call $recursive2)
+
+                ;; exit via a wasmtime-based libcall
+                (memory 1)
+                (func $recursive3 (export "f3")
+                    (drop (memory.grow (i32.const 0)))
+                    call $recursive3)
+
+                ;; exit via a cranelift-based libcall
+                (func $recursive4 (export "f4")
+                    (drop (call $f32_ceil (f32.const 0)))
+                    call $recursive4)
+                (func $f32_ceil (param f32) (result f32)
+                    (f32.ceil (local.get 0)))
             )
         "#,
     )?;
-    let func = Func::wrap(&mut store, test_host_stack);
-    let instance = Instance::new(&mut store, &module, &[func.into()])?;
-    let foo = instance.get_typed_func::<(), ()>(&mut store, "foo")?;
+    let host1 = Func::wrap(&mut store, test_host_stack);
+    let ty = FuncType::new(store.engine(), [], []);
+    let host2 = Func::new(&mut store, ty, |_, _, _| {
+        test_host_stack();
+        Ok(())
+    });
+    let instance = Instance::new(&mut store, &module, &[host1.into(), host2.into()])?;
+    let f1 = instance.get_typed_func::<(), ()>(&mut store, "f1")?;
+    let f2 = instance.get_typed_func::<(), ()>(&mut store, "f2")?;
+    let f3 = instance.get_typed_func::<(), ()>(&mut store, "f3")?;
+    let f4 = instance.get_typed_func::<(), ()>(&mut store, "f4")?;
 
     // Make sure that our function traps and the trap says that the call stack
     // has been exhausted.
-    let trap = foo.call(&mut store, ()).unwrap_err().downcast::<Trap>()?;
+    let hits1 = HITS.load(SeqCst);
+    let trap = f1.call(&mut store, ()).unwrap_err().downcast::<Trap>()?;
+    assert_eq!(trap, Trap::StackOverflow);
+    let hits2 = HITS.load(SeqCst);
+    let trap = f2.call(&mut store, ()).unwrap_err().downcast::<Trap>()?;
+    assert_eq!(trap, Trap::StackOverflow);
+    let hits3 = HITS.load(SeqCst);
+    let trap = f3.call(&mut store, ()).unwrap_err().downcast::<Trap>()?;
+    assert_eq!(trap, Trap::StackOverflow);
+    let hits4 = HITS.load(SeqCst);
+    let trap = f4.call(&mut store, ()).unwrap_err().downcast::<Trap>()?;
     assert_eq!(trap, Trap::StackOverflow);
+    let hits5 = HITS.load(SeqCst);
 
     // Additionally, however, and this is the crucial test, make sure that the
     // host function actually completed. If HITS is 1 then we entered but didn't
     // exit meaning we segfaulted while executing the host, yet still tried to
     // recover from it with longjmp.
-    assert_eq!(HITS.load(SeqCst), 0);
+    assert_eq!(hits1, 0);
+    assert_eq!(hits2, 0);
+    assert_eq!(hits3, 0);
+    assert_eq!(hits4, 0);
+    assert_eq!(hits5, 0);
 
     return Ok(());
 
diff --git a/tests/all/structs.rs b/tests/all/structs.rs
new file mode 100644
index 000000000000..e73d9e069d05
--- /dev/null
+++ b/tests/all/structs.rs
@@ -0,0 +1,709 @@
+use wasmtime::*;
+
+fn gc_store() -> Result<Store<()>> {
+    let _ = env_logger::try_init();
+
+    let mut config = Config::new();
+    config.wasm_function_references(true);
+    config.wasm_gc(true);
+
+    let engine = Engine::new(&config)?;
+    Ok(Store::new(&engine, ()))
+}
+
+#[test]
+fn struct_new_empty() -> Result<()> {
+    let mut store = gc_store()?;
+    let struct_ty = StructType::new(store.engine(), [])?;
+    let pre = StructRefPre::new(&mut store, struct_ty);
+    StructRef::new(store, &pre, &[])?;
+    Ok(())
+}
+
+#[test]
+fn struct_new_with_fields() -> Result<()> {
+    let mut store = gc_store()?;
+    let struct_ty = StructType::new(
+        store.engine(),
+        [
+            FieldType::new(Mutability::Const, StorageType::I8),
+            FieldType::new(Mutability::Const, StorageType::ValType(ValType::I32)),
+            FieldType::new(Mutability::Var, StorageType::ValType(ValType::ANYREF)),
+        ],
+    )?;
+    let pre = StructRefPre::new(&mut store, struct_ty);
+    StructRef::new(
+        store,
+        &pre,
+        &[Val::I32(1), Val::I32(2), Val::null_any_ref()],
+    )?;
+    Ok(())
+}
+
+#[test]
+fn struct_new_unrooted_field() -> Result<()> {
+    let mut store = gc_store()?;
+    let struct_ty = StructType::new(
+        store.engine(),
+        [FieldType::new(
+            Mutability::Var,
+            StorageType::ValType(ValType::ANYREF),
+        )],
+    )?;
+    // Passing an unrooted `anyref` to `StructRef::new` results in an error.
+    let anyref = {
+        let mut scope = RootScope::new(&mut store);
+        AnyRef::from_i31(&mut scope, I31::new_i32(1234).unwrap())
+    };
+    assert!(anyref.is_i31(&store).is_err());
+    let pre = StructRefPre::new(&mut store, struct_ty);
+    assert!(StructRef::new(store, &pre, &[anyref.into()]).is_err());
+    Ok(())
+}
+
+#[test]
+#[should_panic = "wrong store"]
+fn struct_new_cross_store_field() {
+    let mut store = gc_store().unwrap();
+    let struct_ty = StructType::new(
+        store.engine(),
+        [FieldType::new(
+            Mutability::Var,
+            StorageType::ValType(ValType::ANYREF),
+        )],
+    )
+    .unwrap();
+
+    let mut other_store = gc_store().unwrap();
+    let anyref = AnyRef::from_i31(&mut other_store, I31::new_i32(1234).unwrap());
+
+    let pre = StructRefPre::new(&mut store, struct_ty);
+
+    // This should panic.
+    let _ = StructRef::new(store, &pre, &[anyref.into()]);
+}
+
+#[test]
+#[should_panic = "wrong store"]
+fn struct_new_cross_store_pre() {
+    let mut store = gc_store().unwrap();
+    let struct_ty = StructType::new(store.engine(), []).unwrap();
+
+    let mut other_store = gc_store().unwrap();
+    let pre = StructRefPre::new(&mut other_store, struct_ty);
+
+    // This should panic.
+    let _ = StructRef::new(&mut store, &pre, &[]);
+}
+
+#[test]
+fn anyref_as_struct() -> Result<()> {
+    let mut store = gc_store()?;
+
+    let struct_ty = StructType::new(
+        store.engine(),
+        [FieldType::new(Mutability::Const, StorageType::I8)],
+    )?;
+    let pre = StructRefPre::new(&mut store, struct_ty.clone());
+    let s0 = StructRef::new(&mut store, &pre, &[Val::I32(42)])?;
+
+    let anyref: Rooted<AnyRef> = s0.into();
+    assert!(anyref.is_struct(&store)?);
+    let s1 = anyref.as_struct(&store)?.unwrap();
+    assert_eq!(s1.field(&mut store, 0)?.unwrap_i32(), 42);
+    assert!(Rooted::ref_eq(&store, &s0, &s1)?);
+
+    let anyref: Rooted<AnyRef> = AnyRef::from_i31(&mut store, I31::new_i32(42).unwrap());
+    assert!(!anyref.is_struct(&store)?);
+    assert!(anyref.as_struct(&store)?.is_none());
+
+    Ok(())
+}
+
+#[test]
+fn struct_field_simple() -> Result<()> {
+    let mut store = gc_store()?;
+    let struct_ty = StructType::new(
+        store.engine(),
+        [FieldType::new(
+            Mutability::Var,
+            StorageType::ValType(ValType::I32),
+        )],
+    )?;
+    let pre = StructRefPre::new(&mut store, struct_ty);
+    let s = StructRef::new(&mut store, &pre, &[Val::I32(1234)])?;
+    let val = s.field(&mut store, 0)?;
+    assert_eq!(val.unwrap_i32(), 1234);
+    Ok(())
+}
+
+#[test]
+fn struct_field_out_of_bounds() -> Result<()> {
+    let mut store = gc_store()?;
+    let struct_ty = StructType::new(
+        store.engine(),
+        [FieldType::new(
+            Mutability::Var,
+            StorageType::ValType(ValType::I32),
+        )],
+    )?;
+    let pre = StructRefPre::new(&mut store, struct_ty);
+    let s = StructRef::new(&mut store, &pre, &[Val::I32(1234)])?;
+    assert!(s.field(&mut store, 1).is_err());
+    Ok(())
+}
+
+#[test]
+fn struct_field_on_unrooted() -> Result<()> {
+    let mut store = gc_store()?;
+    let struct_ty = StructType::new(
+        store.engine(),
+        [FieldType::new(
+            Mutability::Var,
+            StorageType::ValType(ValType::I32),
+        )],
+    )?;
+    let pre = StructRefPre::new(&mut store, struct_ty);
+    let s = {
+        let mut scope = RootScope::new(&mut store);
+        StructRef::new(&mut scope, &pre, &[Val::I32(1234)])?
+    };
+    // The root scope ended and unrooted `s`.
+    assert!(s.field(&mut store, 0).is_err());
+    Ok(())
+}
+
+#[test]
+fn struct_set_field_simple() -> Result<()> {
+    let mut store = gc_store()?;
+    let struct_ty = StructType::new(
+        store.engine(),
+        [FieldType::new(
+            Mutability::Var,
+            StorageType::ValType(ValType::I32),
+        )],
+    )?;
+    let pre = StructRefPre::new(&mut store, struct_ty);
+    let s = StructRef::new(&mut store, &pre, &[Val::I32(1234)])?;
+    s.set_field(&mut store, 0, Val::I32(5678))?;
+    let val = s.field(&mut store, 0)?;
+    assert_eq!(val.unwrap_i32(), 5678);
+    Ok(())
+}
+
+#[test]
+fn struct_set_field_out_of_bounds() -> Result<()> {
+    let mut store = gc_store()?;
+    let struct_ty = StructType::new(
+        store.engine(),
+        [FieldType::new(
+            Mutability::Var,
+            StorageType::ValType(ValType::I32),
+        )],
+    )?;
+    let pre = StructRefPre::new(&mut store, struct_ty);
+    let s = StructRef::new(&mut store, &pre, &[Val::I32(1234)])?;
+    assert!(s.set_field(&mut store, 1, Val::I32(1)).is_err());
+    Ok(())
+}
+
+#[test]
+fn struct_set_field_on_unrooted() -> Result<()> {
+    let mut store = gc_store()?;
+    let struct_ty = StructType::new(
+        store.engine(),
+        [FieldType::new(
+            Mutability::Var,
+            StorageType::ValType(ValType::I32),
+        )],
+    )?;
+    let pre = StructRefPre::new(&mut store, struct_ty);
+    let s = {
+        let mut scope = RootScope::new(&mut store);
+        StructRef::new(&mut scope, &pre, &[Val::I32(1234)])?
+    };
+    // The root scope ended and unrooted `s`.
+    assert!(s.set_field(&mut store, 0, Val::I32(1)).is_err());
+    Ok(())
+}
+
+#[test]
+fn struct_set_field_with_unrooted() -> Result<()> {
+    let mut store = gc_store()?;
+    let struct_ty = StructType::new(
+        store.engine(),
+        [FieldType::new(
+            Mutability::Var,
+            StorageType::ValType(ValType::ANYREF),
+        )],
+    )?;
+    let pre = StructRefPre::new(&mut store, struct_ty);
+    let s = StructRef::new(&mut store, &pre, &[Val::null_any_ref()])?;
+    let anyref = {
+        let mut scope = RootScope::new(&mut store);
+        AnyRef::from_i31(&mut scope, I31::wrapping_i32(42))
+    };
+    // The root scope ended and `anyref` is unrooted.
+    assert!(s.set_field(&mut store, 0, anyref.into()).is_err());
+    Ok(())
+}
+
+#[test]
+fn struct_set_field_cross_store_value() -> Result<()> {
+    let mut store = gc_store()?;
+    let struct_ty = StructType::new(
+        store.engine(),
+        [FieldType::new(
+            Mutability::Var,
+            StorageType::ValType(ValType::EXTERNREF),
+        )],
+    )?;
+    let pre = StructRefPre::new(&mut store, struct_ty);
+    let s = StructRef::new(&mut store, &pre, &[Val::null_extern_ref()])?;
+
+    let mut other_store = gc_store()?;
+    let externref = ExternRef::new(&mut other_store, "blah")?;
+
+    assert!(s.set_field(&mut store, 0, externref.into()).is_err());
+    Ok(())
+}
+
+#[test]
+fn struct_set_field_immutable() -> Result<()> {
+    let mut store = gc_store()?;
+    let struct_ty = StructType::new(
+        store.engine(),
+        [FieldType::new(
+            Mutability::Const,
+            StorageType::ValType(ValType::I32),
+        )],
+    )?;
+    let pre = StructRefPre::new(&mut store, struct_ty);
+    let s = StructRef::new(&mut store, &pre, &[Val::I32(1234)])?;
+    assert!(s.set_field(&mut store, 0, Val::I32(5678)).is_err());
+    Ok(())
+}
+
+#[test]
+fn struct_set_field_wrong_type() -> Result<()> {
+    let mut store = gc_store()?;
+    let struct_ty = StructType::new(
+        store.engine(),
+        [FieldType::new(
+            Mutability::Const,
+            StorageType::ValType(ValType::I32),
+        )],
+    )?;
+    let pre = StructRefPre::new(&mut store, struct_ty);
+    let s = StructRef::new(&mut store, &pre, &[Val::I32(1234)])?;
+    assert!(s.set_field(&mut store, 0, Val::I64(5678)).is_err());
+    Ok(())
+}
+
+#[test]
+fn struct_ty() -> Result<()> {
+    let mut store = gc_store()?;
+    let struct_ty = StructType::new(store.engine(), [])?;
+    let pre = StructRefPre::new(&mut store, struct_ty.clone());
+    let s = StructRef::new(&mut store, &pre, &[])?;
+    assert!(StructType::eq(&struct_ty, &s.ty(&store)?));
+    Ok(())
+}
+
+#[test]
+fn struct_ty_unrooted() -> Result<()> {
+    let mut store = gc_store()?;
+    let struct_ty = StructType::new(store.engine(), [])?;
+    let pre = StructRefPre::new(&mut store, struct_ty);
+    let s = {
+        let mut scope = RootScope::new(&mut store);
+        StructRef::new(&mut scope, &pre, &[])?
+    };
+    // The root scope ended and `s` is unrooted.
+    assert!(s.ty(&mut store).is_err());
+    Ok(())
+}
+
+#[test]
+fn struct_fields_empty() -> Result<()> {
+    let mut store = gc_store()?;
+    let struct_ty = StructType::new(store.engine(), [])?;
+    let pre = StructRefPre::new(&mut store, struct_ty.clone());
+    let s = StructRef::new(&mut store, &pre, &[])?;
+    let fields = s.fields(&mut store)?;
+    assert_eq!(fields.len(), 0);
+    assert!(fields.collect::<Vec<_>>().is_empty());
+    Ok(())
+}
+
+#[test]
+fn struct_fields_non_empty() -> Result<()> {
+    let mut store = gc_store()?;
+    let struct_ty = StructType::new(
+        store.engine(),
+        [
+            FieldType::new(Mutability::Const, StorageType::I8),
+            FieldType::new(Mutability::Var, StorageType::ValType(ValType::ANYREF)),
+        ],
+    )?;
+    let pre = StructRefPre::new(&mut store, struct_ty.clone());
+    let s = StructRef::new(&mut store, &pre, &[Val::I32(36), Val::null_any_ref()])?;
+    let mut fields = s.fields(&mut store)?;
+    assert_eq!(fields.len(), 2);
+    assert_eq!(fields.next().unwrap().unwrap_i32(), 36);
+    assert!(fields.next().unwrap().unwrap_any_ref().is_none());
+    assert!(fields.next().is_none());
+    Ok(())
+}
+
+#[test]
+fn struct_fields_unrooted() -> Result<()> {
+    let mut store = gc_store()?;
+    let struct_ty = StructType::new(store.engine(), [])?;
+    let pre = StructRefPre::new(&mut store, struct_ty);
+    let s = {
+        let mut scope = RootScope::new(&mut store);
+        StructRef::new(&mut scope, &pre, &[])?
+    };
+    // The root scope ended and `s` is unrooted.
+    assert!(s.fields(&mut store).is_err());
+    Ok(())
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn passing_structs_through_wasm_with_untyped_calls() -> Result<()> {
+    let mut store = gc_store()?;
+
+    let module = Module::new(
+        store.engine(),
+        r#"
+            (module
+                (type (struct (field i8)))
+                (import "" "" (func $f (param (ref 0)) (result (ref 0))))
+                (func (export "run") (param (ref 0)) (result (ref 0))
+                    (call $f (local.get 0))
+                )
+            )
+        "#,
+    )?;
+
+    let struct_ty = StructType::new(
+        store.engine(),
+        [FieldType::new(Mutability::Const, StorageType::I8)],
+    )?;
+
+    let ref_ty = RefType::new(false, HeapType::ConcreteStruct(struct_ty.clone()));
+    let func_ty = FuncType::new(store.engine(), [ref_ty.clone().into()], [ref_ty.into()]);
+
+    let func = Func::new(&mut store, func_ty, |mut caller, args, results| {
+        let s = args[0].unwrap_any_ref().unwrap();
+        let s = s.unwrap_struct(&mut caller)?;
+        assert_eq!(s.field(&mut caller, 0)?.unwrap_i32(), 42);
+        results[0] = args[0];
+        Ok(())
+    });
+
+    let instance = Instance::new(&mut store, &module, &[func.into()])?;
+    let run = instance.get_func(&mut store, "run").unwrap();
+
+    let pre = StructRefPre::new(&mut store, struct_ty.clone());
+    let s = StructRef::new(&mut store, &pre, &[Val::I32(42)])?;
+
+    let mut results = vec![Val::null_any_ref()];
+    run.call(&mut store, &[s.into()], &mut results)?;
+
+    let t = results[0].unwrap_any_ref().unwrap();
+    let t = t.unwrap_struct(&mut store)?;
+    assert_eq!(t.field(&mut store, 0)?.unwrap_i32(), 42);
+    assert!(Rooted::ref_eq(&store, &s, &t)?);
+
+    Ok(())
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn passing_structs_through_wasm_with_typed_calls() -> Result<()> {
+    let mut store = gc_store()?;
+
+    let module = Module::new(
+        store.engine(),
+        r#"
+            (module
+                (type (struct (field i8)))
+                (import "" "" (func $f (param (ref struct)) (result (ref struct))))
+                (func (export "run") (param (ref 0)) (result (ref struct))
+                    (call $f (local.get 0))
+                )
+            )
+        "#,
+    )?;
+
+    let struct_ty = StructType::new(
+        store.engine(),
+        [FieldType::new(Mutability::Const, StorageType::I8)],
+    )?;
+
+    let func = Func::wrap(
+        &mut store,
+        |mut caller: Caller<()>, s: Rooted<StructRef>| -> Result<Rooted<StructRef>> {
+            assert_eq!(s.field(&mut caller, 0)?.unwrap_i32(), 42);
+            Ok(s)
+        },
+    );
+
+    let instance = Instance::new(&mut store, &module, &[func.into()])?;
+    let run = instance.get_typed_func::<Rooted<StructRef>, Rooted<StructRef>>(&mut store, "run")?;
+
+    let pre = StructRefPre::new(&mut store, struct_ty.clone());
+    let s = StructRef::new(&mut store, &pre, &[Val::I32(42)])?;
+
+    let t = run.call(&mut store, s)?;
+
+    assert_eq!(t.field(&mut store, 0)?.unwrap_i32(), 42);
+    assert!(Rooted::ref_eq(&store, &s, &t)?);
+
+    Ok(())
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn host_sets_struct_global() -> Result<()> {
+    let mut store = gc_store()?;
+
+    let module = Module::new(
+        store.engine(),
+        r#"
+            (module
+                (type (struct (field i8)))
+                (global $g (export "g") (mut (ref null 0)) (ref.null 0))
+                (func (export "f") (result (ref null 0))
+                    global.get $g
+                )
+            )
+        "#,
+    )?;
+
+    let instance = Instance::new(&mut store, &module, &[])?;
+    let g = instance.get_global(&mut store, "g").unwrap();
+
+    let struct_ty = StructType::new(
+        store.engine(),
+        [FieldType::new(Mutability::Const, StorageType::I8)],
+    )?;
+    let pre = StructRefPre::new(&mut store, struct_ty.clone());
+    let s0 = StructRef::new(&mut store, &pre, &[Val::I32(42)])?;
+    g.set(&mut store, s0.into())?;
+
+    // Get the global from the host.
+    let val = g.get(&mut store);
+    let anyref = val.unwrap_anyref().expect("non-null");
+    let s1 = anyref.unwrap_struct(&store)?;
+    assert_eq!(s1.field(&mut store, 0)?.unwrap_i32(), 42);
+    assert!(Rooted::ref_eq(&store, &s0, &s1)?);
+
+    // Get the global from the guest.
+    let f = instance.get_typed_func::<(), Option<Rooted<StructRef>>>(&mut store, "f")?;
+    let s2 = f.call(&mut store, ())?.expect("non-null");
+    assert_eq!(s2.field(&mut store, 0)?.unwrap_i32(), 42);
+    assert!(Rooted::ref_eq(&store, &s0, &s2)?);
+
+    Ok(())
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn wasm_sets_struct_global() -> Result<()> {
+    let mut store = gc_store()?;
+
+    let module = Module::new(
+        store.engine(),
+        r#"
+            (module
+                (type (struct (field i8)))
+                (global $g (export "g") (mut (ref null 0)) (ref.null 0))
+                (func (export "get") (result (ref null 0))
+                    global.get $g
+                )
+                (func (export "set") (param (ref null 0))
+                    local.get 0
+                    global.set $g
+                )
+            )
+        "#,
+    )?;
+
+    let struct_ty = StructType::new(
+        store.engine(),
+        [FieldType::new(Mutability::Const, StorageType::I8)],
+    )?;
+    let pre = StructRefPre::new(&mut store, struct_ty.clone());
+    let s0 = StructRef::new(&mut store, &pre, &[Val::I32(42)])?;
+
+    let instance = Instance::new(&mut store, &module, &[])?;
+    let set = instance.get_func(&mut store, "set").unwrap();
+    set.call(&mut store, &[s0.into()], &mut [])?;
+
+    // Get the global from the host.
+    let g = instance.get_global(&mut store, "g").unwrap();
+    let val = g.get(&mut store);
+    let anyref = val.unwrap_anyref().expect("non-null");
+    let s1 = anyref.unwrap_struct(&store)?;
+    assert_eq!(s1.field(&mut store, 0)?.unwrap_i32(), 42);
+    assert!(Rooted::ref_eq(&store, &s0, &s1)?);
+
+    // Get the global from the guest.
+    let f = instance.get_typed_func::<(), Option<Rooted<StructRef>>>(&mut store, "get")?;
+    let s2 = f.call(&mut store, ())?.expect("non-null");
+    assert_eq!(s2.field(&mut store, 0)?.unwrap_i32(), 42);
+    assert!(Rooted::ref_eq(&store, &s0, &s2)?);
+
+    Ok(())
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn host_sets_struct_in_table() -> Result<()> {
+    let mut store = gc_store()?;
+
+    let module = Module::new(
+        store.engine(),
+        r#"
+            (module
+                (type (struct (field i8)))
+                (table $t (export "t") 1 1 (ref null 0) (ref.null 0))
+                (func (export "f") (result (ref null 0))
+                    i32.const 0
+                    table.get $t
+                )
+            )
+        "#,
+    )?;
+
+    let instance = Instance::new(&mut store, &module, &[])?;
+    let t = instance.get_table(&mut store, "t").unwrap();
+
+    let struct_ty = StructType::new(
+        store.engine(),
+        [FieldType::new(Mutability::Const, StorageType::I8)],
+    )?;
+    let pre = StructRefPre::new(&mut store, struct_ty.clone());
+    let s0 = StructRef::new(&mut store, &pre, &[Val::I32(42)])?;
+    t.set(&mut store, 0, s0.into())?;
+
+    // Get the global from the host.
+    let val = t.get(&mut store, 0).expect("in bounds");
+    let anyref = val.unwrap_any().expect("non-null");
+    let s1 = anyref.unwrap_struct(&store)?;
+    assert_eq!(s1.field(&mut store, 0)?.unwrap_i32(), 42);
+    assert!(Rooted::ref_eq(&store, &s0, &s1)?);
+
+    // Get the global from the guest.
+    let f = instance.get_typed_func::<(), Option<Rooted<StructRef>>>(&mut store, "f")?;
+    let s2 = f.call(&mut store, ())?.expect("non-null");
+    assert_eq!(s2.field(&mut store, 0)?.unwrap_i32(), 42);
+    assert!(Rooted::ref_eq(&store, &s0, &s2)?);
+
+    Ok(())
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn wasm_sets_struct_in_table() -> Result<()> {
+    let mut store = gc_store()?;
+
+    let module = Module::new(
+        store.engine(),
+        r#"
+            (module
+                (type (struct (field i8)))
+                (table $t (export "t") 1 1 (ref null 0) (ref.null 0))
+                (func (export "get") (result (ref null 0))
+                    i32.const 0
+                    table.get $t
+                )
+                (func (export "set") (param (ref null 0))
+                    i32.const 0
+                    local.get 0
+                    table.set $t
+                )
+            )
+        "#,
+    )?;
+
+    let struct_ty = StructType::new(
+        store.engine(),
+        [FieldType::new(Mutability::Const, StorageType::I8)],
+    )?;
+    let pre = StructRefPre::new(&mut store, struct_ty.clone());
+    let s0 = StructRef::new(&mut store, &pre, &[Val::I32(42)])?;
+
+    let instance = Instance::new(&mut store, &module, &[])?;
+    let set = instance.get_func(&mut store, "set").unwrap();
+    set.call(&mut store, &[s0.into()], &mut [])?;
+
+    // Get the global from the host.
+    let t = instance.get_table(&mut store, "t").unwrap();
+    let val = t.get(&mut store, 0).expect("in bounds");
+    let anyref = val.unwrap_any().expect("non-null");
+    let s1 = anyref.unwrap_struct(&store)?;
+    assert_eq!(s1.field(&mut store, 0)?.unwrap_i32(), 42);
+    assert!(Rooted::ref_eq(&store, &s0, &s1)?);
+
+    // Get the global from the guest.
+    let f = instance.get_typed_func::<(), Option<Rooted<StructRef>>>(&mut store, "get")?;
+    let s2 = f.call(&mut store, ())?.expect("non-null");
+    assert_eq!(s2.field(&mut store, 0)?.unwrap_i32(), 42);
+    assert!(Rooted::ref_eq(&store, &s0, &s2)?);
+
+    Ok(())
+}
+
+#[test]
+fn instantiate_with_struct_global() -> Result<()> {
+    let mut store = gc_store()?;
+
+    let module = Module::new(
+        store.engine(),
+        r#"
+            (module
+                (type (struct (field i8)))
+                (import "" "" (global (ref null 0)))
+                (export "g" (global 0))
+            )
+        "#,
+    )?;
+
+    let struct_ty = StructType::new(
+        store.engine(),
+        [FieldType::new(Mutability::Const, StorageType::I8)],
+    )?;
+    let global_ty = GlobalType::new(
+        ValType::Ref(RefType::new(
+            true,
+            HeapType::ConcreteStruct(struct_ty.clone()),
+        )),
+        Mutability::Const,
+    );
+
+    // Instantiate with a null-ref global.
+    let g = Global::new(&mut store, global_ty.clone(), Val::AnyRef(None))?;
+    let instance = Instance::new(&mut store, &module, &[g.into()])?;
+    let g = instance.get_global(&mut store, "g").expect("export exists");
+    let val = g.get(&mut store);
+    assert!(val.unwrap_anyref().is_none());
+
+    // Instantiate with a non-null-ref global.
+    let pre = StructRefPre::new(&mut store, struct_ty);
+    let s0 = StructRef::new(&mut store, &pre, &[Val::I32(42)])?;
+    let g = Global::new(&mut store, global_ty, s0.into())?;
+    let instance = Instance::new(&mut store, &module, &[g.into()])?;
+    let g = instance.get_global(&mut store, "g").expect("export exists");
+    let val = g.get(&mut store);
+    let anyref = val.unwrap_anyref().expect("non-null");
+    let s1 = anyref.unwrap_struct(&store)?;
+    assert_eq!(s1.field(&mut store, 0)?.unwrap_i32(), 42);
+    assert!(Rooted::ref_eq(&store, &s0, &s1)?);
+
+    Ok(())
+}
diff --git a/tests/all/table.rs b/tests/all/table.rs
index 2b22c2ee7631..c119dc0152d9 100644
--- a/tests/all/table.rs
+++ b/tests/all/table.rs
@@ -1,13 +1,12 @@
-use anyhow::Result;
 use wasmtime::*;
 
 #[test]
 fn get_none() {
     let mut store = Store::<()>::default();
-    let ty = TableType::new(ValType::FuncRef, 1, None);
-    let table = Table::new(&mut store, ty, Val::FuncRef(None)).unwrap();
+    let ty = TableType::new(RefType::FUNCREF, 1, None);
+    let table = Table::new(&mut store, ty, Ref::Func(None)).unwrap();
     match table.get(&mut store, 0) {
-        Some(Val::FuncRef(None)) => {}
+        Some(Ref::Func(None)) => {}
         _ => panic!(),
     }
     assert!(table.get(&mut store, 1).is_none());
@@ -16,39 +15,39 @@ fn get_none() {
 #[test]
 fn fill_wrong() {
     let mut store = Store::<()>::default();
-    let ty = TableType::new(ValType::FuncRef, 1, None);
-    let table = Table::new(&mut store, ty, Val::FuncRef(None)).unwrap();
+    let ty = TableType::new(RefType::FUNCREF, 1, None);
+    let table = Table::new(&mut store, ty, Ref::Func(None)).unwrap();
     assert_eq!(
         table
-            .fill(&mut store, 0, Val::ExternRef(None), 1)
+            .fill(&mut store, 0, Ref::Extern(None), 1)
             .map_err(|e| e.to_string())
             .unwrap_err(),
-        "value does not match table element type"
+        "type mismatch: value does not match table element type"
     );
 
-    let ty = TableType::new(ValType::ExternRef, 1, None);
-    let table = Table::new(&mut store, ty, Val::ExternRef(None)).unwrap();
+    let ty = TableType::new(RefType::EXTERNREF, 1, None);
+    let table = Table::new(&mut store, ty, Ref::Extern(None)).unwrap();
     assert_eq!(
         table
-            .fill(&mut store, 0, Val::FuncRef(None), 1)
+            .fill(&mut store, 0, Ref::Func(None), 1)
             .map_err(|e| e.to_string())
             .unwrap_err(),
-        "value does not match table element type"
+        "type mismatch: value does not match table element type"
     );
 }
 
 #[test]
 fn copy_wrong() {
     let mut store = Store::<()>::default();
-    let ty = TableType::new(ValType::FuncRef, 1, None);
-    let table1 = Table::new(&mut store, ty, Val::FuncRef(None)).unwrap();
-    let ty = TableType::new(ValType::ExternRef, 1, None);
-    let table2 = Table::new(&mut store, ty, Val::ExternRef(None)).unwrap();
+    let ty = TableType::new(RefType::FUNCREF, 1, None);
+    let table1 = Table::new(&mut store, ty, Ref::Func(None)).unwrap();
+    let ty = TableType::new(RefType::EXTERNREF, 1, None);
+    let table2 = Table::new(&mut store, ty, Ref::Extern(None)).unwrap();
     assert_eq!(
         Table::copy(&mut store, &table1, 0, &table2, 0, 1)
             .map_err(|e| e.to_string())
             .unwrap_err(),
-        "tables do not have the same element type"
+        "type mismatch: source table's element type does not match destination table's element type"
     );
 }
 
@@ -56,8 +55,8 @@ fn copy_wrong() {
 #[cfg_attr(miri, ignore)]
 fn null_elem_segment_works_with_imported_table() -> Result<()> {
     let mut store = Store::<()>::default();
-    let ty = TableType::new(ValType::FuncRef, 1, None);
-    let table = Table::new(&mut store, ty, Val::FuncRef(None))?;
+    let ty = TableType::new(RefType::FUNCREF, 1, None);
+    let table = Table::new(&mut store, ty, Ref::Func(None))?;
     let module = Module::new(
         store.engine(),
         r#"
@@ -76,3 +75,265 @@ fn null_elem_segment_works_with_imported_table() -> Result<()> {
     Instance::new(&mut store, &module, &[table.into()])?;
     Ok(())
 }
+
+#[test]
+fn i31ref_table_new() -> Result<()> {
+    let mut config = Config::new();
+    config.wasm_function_references(true);
+    config.wasm_gc(true);
+
+    let engine = Engine::new(&config)?;
+    let mut store = Store::new(&engine, ());
+
+    for (elem_ty, inits) in [
+        (
+            RefType::I31REF,
+            vec![
+                Ref::Any(None),
+                AnyRef::from_i31(&mut store, I31::default()).into(),
+            ],
+        ),
+        (
+            RefType::new(false, HeapType::I31),
+            vec![AnyRef::from_i31(&mut store, I31::default()).into()],
+        ),
+    ] {
+        let table_ty = TableType::new(elem_ty, 10, None);
+        for init in inits {
+            Table::new(&mut store, table_ty.clone(), init)?;
+        }
+    }
+
+    Ok(())
+}
+
+#[test]
+fn i31ref_table_get() -> Result<()> {
+    let mut config = Config::new();
+    config.wasm_function_references(true);
+    config.wasm_gc(true);
+
+    let engine = Engine::new(&config)?;
+    let mut store = Store::new(&engine, ());
+
+    for (elem_ty, inits) in [
+        (
+            RefType::I31REF,
+            vec![
+                Ref::Any(None),
+                AnyRef::from_i31(&mut store, I31::default()).into(),
+            ],
+        ),
+        (
+            RefType::new(false, HeapType::I31),
+            vec![AnyRef::from_i31(&mut store, I31::default()).into()],
+        ),
+    ] {
+        let table_ty = TableType::new(elem_ty, 10, None);
+        for init in inits {
+            let table = Table::new(&mut store, table_ty.clone(), init.clone())?;
+            for i in 0..10 {
+                let val = table.get(&mut store, i).unwrap();
+                assert_eq!(init.is_null(), val.is_null());
+                assert_eq!(
+                    init.as_any()
+                        .expect("is anyref")
+                        .map(|a| a.as_i31(&store).expect("is in scope")),
+                    val.as_any()
+                        .expect("is anyref")
+                        .map(|a| a.as_i31(&store).expect("is in scope"))
+                )
+            }
+        }
+    }
+
+    Ok(())
+}
+
+#[test]
+fn i31ref_table_set() -> Result<()> {
+    let mut config = Config::new();
+    config.wasm_function_references(true);
+    config.wasm_gc(true);
+
+    let engine = Engine::new(&config)?;
+    let mut store = Store::new(&engine, ());
+
+    for (elem_ty, inits, vals) in [
+        (
+            RefType::I31REF,
+            vec![
+                Ref::Any(None),
+                AnyRef::from_i31(&mut store, I31::default()).into(),
+            ],
+            vec![
+                Ref::Any(None),
+                AnyRef::from_i31(&mut store, I31::wrapping_u32(42)).into(),
+            ],
+        ),
+        (
+            RefType::new(false, HeapType::I31),
+            vec![AnyRef::from_i31(&mut store, I31::default()).into()],
+            vec![AnyRef::from_i31(&mut store, I31::wrapping_u32(42)).into()],
+        ),
+    ] {
+        let table_ty = TableType::new(elem_ty, 10, None);
+        for init in inits {
+            for expected in vals.clone() {
+                let table = Table::new(&mut store, table_ty.clone(), init.clone())?;
+                for i in 0..10 {
+                    table.set(&mut store, i, expected.clone())?;
+                    let actual = table.get(&mut store, i).unwrap();
+                    assert_eq!(expected.is_null(), actual.is_null());
+                    assert_eq!(
+                        expected
+                            .as_any()
+                            .expect("is anyref")
+                            .map(|a| a.as_i31(&store).expect("is in scope")),
+                        actual
+                            .as_any()
+                            .expect("is anyref")
+                            .map(|a| a.as_i31(&store).expect("is in scope"))
+                    )
+                }
+            }
+        }
+    }
+
+    Ok(())
+}
+
+#[test]
+fn i31ref_table_grow() -> Result<()> {
+    let mut config = Config::new();
+    config.wasm_function_references(true);
+    config.wasm_gc(true);
+
+    let engine = Engine::new(&config)?;
+    let mut store = Store::new(&engine, ());
+
+    for (elem_ty, init) in [
+        (RefType::I31REF, Ref::Any(None)),
+        (
+            RefType::new(false, HeapType::I31),
+            AnyRef::from_i31(&mut store, I31::default()).into(),
+        ),
+    ] {
+        let table_ty = TableType::new(elem_ty, 10, None);
+        let table = Table::new(&mut store, table_ty, init)?;
+        assert_eq!(table.size(&store), 10);
+        for i in 10..20 {
+            assert!(table.get(&mut store, i).is_none());
+        }
+        let expected = I31::wrapping_u32(42);
+        let grow_val = AnyRef::from_i31(&mut store, expected);
+        table.grow(&mut store, 10, grow_val.into())?;
+        for i in 10..20 {
+            let actual = table.get(&mut store, i).unwrap();
+            assert_eq!(
+                actual
+                    .as_any()
+                    .expect("is anyref")
+                    .expect("is non null")
+                    .as_i31(&store)
+                    .expect("is in scope")
+                    .expect("is i31"),
+                expected,
+            );
+        }
+        assert!(table.get(&mut store, 20).is_none());
+    }
+
+    Ok(())
+}
+
+#[test]
+fn i31ref_table_fill() -> Result<()> {
+    let mut config = Config::new();
+    config.wasm_function_references(true);
+    config.wasm_gc(true);
+
+    let engine = Engine::new(&config)?;
+    let mut store = Store::new(&engine, ());
+
+    let table_ty = TableType::new(RefType::I31REF, 10, None);
+    let table = Table::new(&mut store, table_ty, Ref::Any(None))?;
+
+    let expected = I31::wrapping_u32(42);
+    let fill_val = AnyRef::from_i31(&mut store, expected);
+    let dst = 3;
+    let len = 4;
+    table.fill(&mut store, dst, fill_val.into(), len)?;
+
+    for i in 0..dst {
+        let actual = table.get(&mut store, i).unwrap();
+        assert!(actual.as_any().expect("is anyref").is_none());
+    }
+    for i in dst..dst + len {
+        let actual = table.get(&mut store, i).unwrap();
+        assert_eq!(
+            actual
+                .as_any()
+                .expect("is anyref")
+                .expect("is non null")
+                .as_i31(&store)
+                .expect("is in scope")
+                .expect("is i31"),
+            expected,
+        );
+    }
+    for i in dst + len..10 {
+        let actual = table.get(&mut store, i).unwrap();
+        assert!(actual.as_any().expect("is anyref").is_none());
+    }
+
+    Ok(())
+}
+
+#[test]
+fn i31ref_table_copy() -> Result<()> {
+    let mut config = Config::new();
+    config.wasm_function_references(true);
+    config.wasm_gc(true);
+
+    let engine = Engine::new(&config)?;
+    let mut store = Store::new(&engine, ());
+
+    let table_ty = TableType::new(RefType::I31REF, 10, None);
+    let dst_table = Table::new(&mut store, table_ty.clone(), Ref::Any(None))?;
+
+    let expected = I31::wrapping_u32(42);
+    let init_val = AnyRef::from_i31(&mut store, expected);
+    let src_table = Table::new(&mut store, table_ty, init_val.into())?;
+
+    let dst_index = 1;
+    let src_index = 2;
+    let len = 3;
+    Table::copy(
+        &mut store, &dst_table, dst_index, &src_table, src_index, len,
+    )?;
+
+    for i in 0..dst_index {
+        let actual = dst_table.get(&mut store, i).unwrap();
+        assert!(actual.as_any().expect("is anyref").is_none());
+    }
+    for i in dst_index..dst_index + len {
+        let actual = dst_table.get(&mut store, i).unwrap();
+        assert_eq!(
+            actual
+                .as_any()
+                .expect("is anyref")
+                .expect("is non null")
+                .as_i31(&store)
+                .expect("is in scope")
+                .expect("is i31"),
+            expected,
+        );
+    }
+    for i in dst_index + len..10 {
+        let actual = dst_table.get(&mut store, i).unwrap();
+        assert!(actual.as_any().expect("is anyref").is_none());
+    }
+
+    Ok(())
+}
diff --git a/tests/all/threads.rs b/tests/all/threads.rs
index b08daf279163..20fc7d3e34fa 100644
--- a/tests/all/threads.rs
+++ b/tests/all/threads.rs
@@ -1,4 +1,3 @@
-use anyhow::Result;
 use std::{
     collections::{hash_map::RandomState, HashSet},
     sync::{
@@ -252,7 +251,7 @@ fn test_memory_size_accessibility() -> Result<()> {
     let grow_thread = std::thread::spawn(move || {
         for i in 0..NUM_GROW_OPS {
             if grow_memory.grow(1).is_err() {
-                println!("stopping at grow operation #{}", i);
+                println!("stopping at grow operation #{i}");
                 break;
             }
         }
diff --git a/tests/all/traps.rs b/tests/all/traps.rs
index cb33af235b49..bfd39e0a5451 100644
--- a/tests/all/traps.rs
+++ b/tests/all/traps.rs
@@ -1,6 +1,6 @@
 #![cfg(not(miri))]
 
-use anyhow::{bail, Error, Result};
+use anyhow::bail;
 use std::panic::{self, AssertUnwindSafe};
 use std::process::Command;
 use std::sync::{Arc, Mutex};
@@ -17,7 +17,7 @@ fn test_trap_return() -> Result<()> {
     "#;
 
     let module = Module::new(store.engine(), wat)?;
-    let hello_type = FuncType::new(None, None);
+    let hello_type = FuncType::new(store.engine(), None, None);
     let hello_func = Func::new(&mut store, hello_type, |_, _, _| bail!("test 123"));
 
     let instance = Instance::new(&mut store, &module, &[hello_func.into()])?;
@@ -45,7 +45,7 @@ fn test_anyhow_error_return() -> Result<()> {
     "#;
 
     let module = Module::new(store.engine(), wat)?;
-    let hello_type = FuncType::new(None, None);
+    let hello_type = FuncType::new(store.engine(), None, None);
     let hello_func = Func::new(&mut store, hello_type, |_, _, _| {
         Err(anyhow::Error::msg("test 1234"))
     });
@@ -55,7 +55,7 @@ fn test_anyhow_error_return() -> Result<()> {
 
     let e = run_func.call(&mut store, ()).unwrap_err();
     assert!(!e.to_string().contains("test 1234"));
-    assert!(format!("{:?}", e).contains("Caused by:\n    test 1234"));
+    assert!(format!("{e:?}").contains("Caused by:\n    test 1234"));
 
     assert!(e.downcast_ref::<Trap>().is_none());
     assert!(e.downcast_ref::<WasmBacktrace>().is_some());
@@ -83,7 +83,7 @@ fn test_trap_return_downcast() -> Result<()> {
     impl std::error::Error for MyTrap {}
 
     let module = Module::new(store.engine(), wat)?;
-    let hello_type = FuncType::new(None, None);
+    let hello_type = FuncType::new(store.engine(), None, None);
     let hello_func = Func::new(&mut store, hello_type, |_, _, _| {
         Err(anyhow::Error::from(MyTrap))
     });
@@ -95,8 +95,8 @@ fn test_trap_return_downcast() -> Result<()> {
         .call(&mut store, ())
         .err()
         .expect("error calling function");
-    let dbg = format!("{:?}", e);
-    println!("{}", dbg);
+    let dbg = format!("{e:?}");
+    println!("{dbg}");
 
     assert!(!e.to_string().contains("my trap"));
     assert!(dbg.contains("Caused by:\n    my trap"));
@@ -107,7 +107,7 @@ fn test_trap_return_downcast() -> Result<()> {
         .downcast_ref::<WasmBacktrace>()
         .expect("error downcasts to WasmBacktrace");
     assert_eq!(bt.frames().len(), 1);
-    println!("{:?}", bt);
+    println!("{bt:?}");
 
     Ok(())
 }
@@ -169,7 +169,7 @@ fn test_trap_through_host() -> Result<()> {
 
     let host_func_a = Func::new(
         &mut store,
-        FuncType::new(vec![], vec![]),
+        FuncType::new(&engine, vec![], vec![]),
         |mut caller, _args, _results| {
             caller
                 .get_export("b")
@@ -182,7 +182,7 @@ fn test_trap_through_host() -> Result<()> {
     );
     let host_func_b = Func::new(
         &mut store,
-        FuncType::new(vec![], vec![]),
+        FuncType::new(&engine, vec![], vec![]),
         |mut caller, _args, _results| {
             caller
                 .get_export("c")
@@ -243,7 +243,7 @@ fn test_trap_trace_cb() -> Result<()> {
         )
     "#;
 
-    let fn_type = FuncType::new(None, None);
+    let fn_type = FuncType::new(store.engine(), None, None);
     let fn_func = Func::new(&mut store, fn_type, |_, _, _| bail!("cb throw"));
 
     let module = Module::new(store.engine(), wat)?;
@@ -307,8 +307,8 @@ fn trap_display_pretty() -> Result<()> {
     let run_func = instance.get_typed_func::<(), ()>(&mut store, "bar")?;
 
     let e = run_func.call(&mut store, ()).unwrap_err();
-    assert_eq!(
-        format!("{:?}", e),
+    let e = format!("{e:?}");
+    assert!(e.contains(
         "\
 error while executing at wasm backtrace:
     0:   0x23 - m!die
@@ -319,7 +319,7 @@ error while executing at wasm backtrace:
 Caused by:
     wasm trap: wasm `unreachable` instruction executed\
 "
-    );
+    ));
     Ok(())
 }
 
@@ -351,8 +351,8 @@ fn trap_display_multi_module() -> Result<()> {
     let bar2 = instance.get_typed_func::<(), ()>(&mut store, "bar2")?;
 
     let e = bar2.call(&mut store, ()).unwrap_err();
-    assert_eq!(
-        format!("{e:?}"),
+    let e = format!("{e:?}");
+    assert!(e.contains(
         "\
 error while executing at wasm backtrace:
     0:   0x23 - a!die
@@ -365,7 +365,7 @@ error while executing at wasm backtrace:
 Caused by:
     wasm trap: wasm `unreachable` instruction executed\
 "
-    );
+    ));
     Ok(())
 }
 
@@ -382,7 +382,7 @@ fn trap_start_function_import() -> Result<()> {
     )?;
 
     let module = Module::new(store.engine(), &binary)?;
-    let sig = FuncType::new(None, None);
+    let sig = FuncType::new(store.engine(), None, None);
     let func = Func::new(&mut store, sig, |_, _, _| bail!("user trap"));
     let err = Instance::new(&mut store, &module, &[func.into()]).unwrap_err();
     assert!(format!("{err:?}").contains("user trap"));
@@ -404,9 +404,9 @@ fn rust_panic_import() -> Result<()> {
     )?;
 
     let module = Module::new(store.engine(), &binary)?;
-    let sig = FuncType::new(None, None);
+    let sig = FuncType::new(store.engine(), None, None);
     let func = Func::new(&mut store, sig, |_, _, _| panic!("this is a panic"));
-    let func2 = Func::wrap(&mut store, || panic!("this is another panic"));
+    let func2 = Func::wrap(&mut store, || -> () { panic!("this is another panic") });
     let instance = Instance::new(&mut store, &module, &[func.into(), func2.into()])?;
     let func = instance.get_typed_func::<(), ()>(&mut store, "foo")?;
     let err =
@@ -448,7 +448,7 @@ fn rust_catch_panic_import() -> Result<()> {
 
     let module = Module::new(store.engine(), &binary)?;
     let num_panics = std::sync::Arc::new(std::sync::atomic::AtomicU32::new(0));
-    let sig = FuncType::new(None, None);
+    let sig = FuncType::new(store.engine(), None, None);
     let panic = Func::new(&mut store, sig, {
         let num_panics = num_panics.clone();
         move |_, _, _| {
@@ -493,7 +493,7 @@ fn rust_panic_start_function() -> Result<()> {
     )?;
 
     let module = Module::new(store.engine(), &binary)?;
-    let sig = FuncType::new(None, None);
+    let sig = FuncType::new(store.engine(), None, None);
     let func = Func::new(&mut store, sig, |_, _, _| panic!("this is a panic"));
     let err = panic::catch_unwind(AssertUnwindSafe(|| {
         drop(Instance::new(&mut store, &module, &[func.into()]));
@@ -501,7 +501,7 @@ fn rust_panic_start_function() -> Result<()> {
     .unwrap_err();
     assert_eq!(err.downcast_ref::<&'static str>(), Some(&"this is a panic"));
 
-    let func = Func::wrap(&mut store, || panic!("this is another panic"));
+    let func = Func::wrap(&mut store, || -> () { panic!("this is another panic") });
     let err = panic::catch_unwind(AssertUnwindSafe(|| {
         drop(Instance::new(&mut store, &module, &[func.into()]));
     }))
@@ -531,12 +531,10 @@ fn mismatched_arguments() -> Result<()> {
         func.call(&mut store, &[], &mut []).unwrap_err().to_string(),
         "expected 1 arguments, got 0"
     );
-    assert_eq!(
-        func.call(&mut store, &[Val::F32(0)], &mut [])
-            .unwrap_err()
-            .to_string(),
-        "argument type mismatch: found f32 but expected i32",
-    );
+    let e = func.call(&mut store, &[Val::F32(0)], &mut []).unwrap_err();
+    let e = format!("{e:?}");
+    assert!(e.contains("argument type mismatch"));
+    assert!(e.contains("expected i32, found f32"));
     assert_eq!(
         func.call(&mut store, &[Val::I32(0), Val::I32(1)], &mut [])
             .unwrap_err()
@@ -558,7 +556,7 @@ fn call_signature_mismatch() -> Result<()> {
                 (func $bar (param i32))
                 (start $foo)
 
-                (table 1 anyfunc)
+                (table 1 funcref)
                 (elem (i32.const 0) 1)
             )
         "#,
@@ -592,11 +590,10 @@ fn start_trap_pretty() -> Result<()> {
     let module = Module::new(store.engine(), wat)?;
     let e = match Instance::new(&mut store, &module, &[]) {
         Ok(_) => panic!("expected failure"),
-        Err(e) => e,
+        Err(e) => format!("{e:?}"),
     };
 
-    assert_eq!(
-        format!("{e:?}"),
+    assert!(e.contains(
         "\
 error while executing at wasm backtrace:
     0:   0x1d - m!die
@@ -607,7 +604,7 @@ error while executing at wasm backtrace:
 Caused by:
     wasm trap: wasm `unreachable` instruction executed\
 "
-    );
+    ));
     Ok(())
 }
 
@@ -627,7 +624,7 @@ fn present_after_module_drop() -> Result<()> {
     return Ok(());
 
     fn assert_trap(t: Error) {
-        println!("{:?}", t);
+        println!("{t:?}");
         let trace = t.downcast_ref::<WasmBacktrace>().unwrap().frames();
         assert_eq!(trace.len(), 1);
         assert_eq!(trace[0].func_index(), 0);
@@ -726,7 +723,7 @@ fn rustc(src: &str) -> Vec<u8> {
         .arg("-o")
         .arg(&output)
         .arg("--target")
-        .arg("wasm32-wasi")
+        .arg("wasm32-wasip1")
         .arg("-g")
         .output()
         .unwrap();
@@ -754,13 +751,8 @@ fn parse_dwarf_info() -> Result<()> {
     let engine = Engine::new(&config)?;
     let module = Module::new(&engine, &wasm)?;
     let mut linker = Linker::new(&engine);
-    wasmtime_wasi::add_to_linker(&mut linker, |s| s)?;
-    let mut store = Store::new(
-        &engine,
-        wasmtime_wasi::sync::WasiCtxBuilder::new()
-            .inherit_stdio()
-            .build(),
-    );
+    wasmtime_wasi::preview1::add_to_linker_sync(&mut linker, |t| t)?;
+    let mut store = Store::new(&engine, wasmtime_wasi::WasiCtxBuilder::new().build_p1());
     linker.module(&mut store, "", &module)?;
     let run = linker.get_default(&mut store, "")?;
     let trap = run.call(&mut store, &[], &mut []).unwrap_err();
@@ -800,8 +792,8 @@ fn no_hint_even_with_dwarf_info() -> Result<()> {
         "#,
     )?;
     let trap = Instance::new(&mut store, &module, &[]).unwrap_err();
-    assert_eq!(
-        format!("{trap:?}"),
+    let trap = format!("{trap:?}");
+    assert!(trap.contains(
         "\
 error while executing at wasm backtrace:
     0:   0x1a - <unknown>!start
@@ -809,7 +801,8 @@ error while executing at wasm backtrace:
 Caused by:
     wasm trap: wasm `unreachable` instruction executed\
 "
-    );
+    ));
+    assert!(!trap.contains("WASM_BACKTRACE_DETAILS"));
     Ok(())
 }
 
@@ -833,17 +826,16 @@ fn hint_with_dwarf_info() -> Result<()> {
         "#,
     )?;
     let trap = Instance::new(&mut store, &module, &[]).unwrap_err();
-    assert_eq!(
-        format!("{trap:?}"),
+    let trap = format!("{trap:?}");
+    assert!(trap.contains(
         "\
 error while executing at wasm backtrace:
     0:   0x1a - <unknown>!start
 note: using the `WASMTIME_BACKTRACE_DETAILS=1` environment variable may show more debugging information
 
 Caused by:
-    wasm trap: wasm `unreachable` instruction executed\
-"
-    );
+    wasm trap: wasm `unreachable` instruction executed"
+    ));
     Ok(())
 }
 
@@ -1015,7 +1007,7 @@ async fn async_then_sync_trap() -> Result<()> {
     let sync_module = Module::new(sync_store.engine(), wat)?;
 
     let mut sync_linker = Linker::new(sync_store.engine());
-    sync_linker.func_wrap("", "b", |_caller: Caller<_>| unreachable!())?;
+    sync_linker.func_wrap("", "b", |_caller: Caller<_>| -> () { unreachable!() })?;
 
     let sync_instance = sync_linker.instantiate(&mut sync_store, &sync_module)?;
 
@@ -1093,7 +1085,7 @@ async fn sync_then_async_trap() -> Result<()> {
     let async_module = Module::new(async_store.engine(), wat)?;
 
     let mut async_linker = Linker::new(async_store.engine());
-    async_linker.func_wrap("", "b", |_caller: Caller<_>| unreachable!())?;
+    async_linker.func_wrap("", "b", |_caller: Caller<_>| -> () { unreachable!() })?;
 
     let async_instance = async_linker
         .instantiate_async(&mut async_store, &async_module)
@@ -1349,12 +1341,13 @@ fn wasm_fault_address_reported_by_default() -> Result<()> {
 
     // NB: at this time there's no programmatic access to the fault address
     // because it's not always available for load/store traps. Only static
-    // memories on 32-bit have this information, but bounds-checked memories
-    // use manual trapping instructions and otherwise don't have a means of
+    // memories on 32-bit have this information, but bounds-checked memories use
+    // manual trapping instructions and otherwise don't have a means of
     // communicating the faulting address at this time.
     //
     // It looks like the exact reported fault address may not be deterministic,
-    // so assert that we have the right error message, but not the exact address.
+    // so assert that we have the right error message, but not the exact
+    // address.
     let err = format!("{err:?}");
     assert!(
         err.contains("memory fault at wasm address ")
@@ -1364,6 +1357,44 @@ fn wasm_fault_address_reported_by_default() -> Result<()> {
     Ok(())
 }
 
+#[cfg(target_arch = "x86_64")]
+#[test]
+fn wasm_fault_address_reported_from_mpk_protected_memory() -> Result<()> {
+    // Trigger the case where an OOB memory access causes a segfault and the
+    // store attempts to convert it into a `WasmFault`, calculating the Wasm
+    // address from the raw faulting address. Previously, a store could not do
+    // this calculation for MPK-protected, causing an abort.
+    let mut pool = crate::small_pool_config();
+    pool.total_memories(16);
+    pool.memory_protection_keys(MpkEnabled::Auto);
+    let mut config = Config::new();
+    config.allocation_strategy(InstanceAllocationStrategy::Pooling(pool));
+    let engine = Engine::new(&config)?;
+
+    let mut store = Store::new(&engine, ());
+    let module = Module::new(
+        &engine,
+        r#"
+            (module
+                (memory 1)
+                (func $start
+                    i32.const 0xdeadbeef
+                    i32.load
+                    drop)
+                (start $start)
+            )
+        "#,
+    )?;
+    let err = Instance::new(&mut store, &module, &[]).unwrap_err();
+
+    // We expect an error here, not an abort; but we also check that the store
+    // can now calculate the correct Wasm address. If this test is failing with
+    // an abort, use `--nocapture` to see more details.
+    let err = format!("{err:?}");
+    assert!(err.contains("0xdeadbeef"), "bad error: {err}");
+    Ok(())
+}
+
 #[test]
 fn trap_with_array_to_wasm_stack_args() -> Result<()> {
     let engine = Engine::default();
@@ -1496,14 +1527,14 @@ fn dont_see_stale_stack_walking_registers() -> Result<()> {
 
     let host_start = Func::new(
         &mut store,
-        FuncType::new([], []),
+        FuncType::new(&engine, [], []),
         |_caller, _args, _results| Ok(()),
     );
     linker.define(&store, "", "host_start", host_start)?;
 
     let host_get_trap = Func::new(
         &mut store,
-        FuncType::new([], []),
+        FuncType::new(&engine, [], []),
         |_caller, _args, _results| Err(anyhow::anyhow!("trap!!!")),
     );
     linker.define(&store, "", "host_get_trap", host_get_trap)?;
@@ -1554,7 +1585,7 @@ fn same_module_multiple_stores() -> Result<()> {
     let stacks = Arc::new(Mutex::new(vec![]));
 
     let mut store3 = Store::new(&engine, ());
-    let f3 = Func::new(&mut store3, FuncType::new([], []), {
+    let f3 = Func::new(&mut store3, FuncType::new(&engine, [], []), {
         let stacks = stacks.clone();
         move |caller, _params, _results| {
             stacks
@@ -1570,7 +1601,7 @@ fn same_module_multiple_stores() -> Result<()> {
     let instance3 = Instance::new(&mut store3, &module, &[f3.into(), call_ref3.into()])?;
 
     let mut store2 = Store::new(&engine, store3);
-    let f2 = Func::new(&mut store2, FuncType::new([], []), {
+    let f2 = Func::new(&mut store2, FuncType::new(&engine, [], []), {
         let stacks = stacks.clone();
         move |mut caller, _params, _results| {
             stacks
@@ -1591,7 +1622,7 @@ fn same_module_multiple_stores() -> Result<()> {
     let instance2 = Instance::new(&mut store2, &module, &[f2.into(), call_ref2.into()])?;
 
     let mut store1 = Store::new(&engine, store2);
-    let f1 = Func::new(&mut store1, FuncType::new([], []), {
+    let f1 = Func::new(&mut store1, FuncType::new(&engine, [], []), {
         let stacks = stacks.clone();
         move |mut caller, _params, _results| {
             stacks
@@ -1612,7 +1643,7 @@ fn same_module_multiple_stores() -> Result<()> {
     let instance1 = Instance::new(&mut store1, &module, &[f1.into(), call_ref1.into()])?;
 
     instance1
-        .get_typed_func(&mut store1, "a")?
+        .get_typed_func::<(), ()>(&mut store1, "a")?
         .call(&mut store1, ())?;
 
     let expected_stacks = vec![
@@ -1625,7 +1656,7 @@ fn same_module_multiple_stores() -> Result<()> {
     ];
     eprintln!("expected = {expected_stacks:#?}");
     let actual_stacks = stacks.lock().unwrap();
-    eprintln!("actaul = {actual_stacks:#?}");
+    eprintln!("actual = {actual_stacks:#?}");
 
     assert_eq!(actual_stacks.len(), expected_stacks.len());
     for (expected_stack, actual_stack) in expected_stacks.into_iter().zip(actual_stacks.iter()) {
diff --git a/tests/all/types.rs b/tests/all/types.rs
new file mode 100644
index 000000000000..993a5354bc39
--- /dev/null
+++ b/tests/all/types.rs
@@ -0,0 +1,630 @@
+use wasmtime::*;
+
+fn field(heap_ty: HeapType) -> FieldType {
+    FieldType::new(
+        Mutability::Var,
+        StorageType::ValType(RefType::new(true, heap_ty).into()),
+    )
+}
+
+fn valty(heap_ty: HeapType) -> ValType {
+    ValType::Ref(RefType::new(true, heap_ty))
+}
+
+#[test]
+fn basic_array_types() -> Result<()> {
+    let engine = Engine::default();
+    for mutability in [Mutability::Const, Mutability::Var] {
+        for storage_ty in [
+            StorageType::I8,
+            StorageType::I16,
+            StorageType::ValType(ValType::I32),
+            StorageType::ValType(RefType::new(true, FuncType::new(&engine, [], []).into()).into()),
+        ] {
+            let field_ty = FieldType::new(mutability, storage_ty.clone());
+            assert_eq!(field_ty.mutability(), mutability);
+            assert!(StorageType::eq(field_ty.element_type(), &storage_ty));
+
+            let array_ty = ArrayType::new(&engine, field_ty.clone());
+            assert!(Engine::same(array_ty.engine(), &engine));
+            assert!(FieldType::eq(&array_ty.field_type(), &field_ty));
+            assert_eq!(array_ty.mutability(), mutability);
+            assert!(StorageType::eq(&array_ty.element_type(), &storage_ty));
+        }
+    }
+    Ok(())
+}
+
+#[test]
+fn empty_struct_type() -> Result<()> {
+    let engine = Engine::default();
+    let struct_ty = StructType::new(&engine, [])?;
+    assert_eq!(struct_ty.fields().len(), 0);
+    assert!(struct_ty.field(0).is_none());
+    Ok(())
+}
+
+#[test]
+fn basic_struct_types() -> Result<()> {
+    let engine = Engine::default();
+
+    let field_types = || {
+        [Mutability::Const, Mutability::Var]
+            .into_iter()
+            .flat_map(|mutability| {
+                [
+                    StorageType::I8,
+                    StorageType::I16,
+                    StorageType::ValType(ValType::I32),
+                    StorageType::ValType(
+                        RefType::new(true, FuncType::new(&engine, [], []).into()).into(),
+                    ),
+                ]
+                .into_iter()
+                .map(move |storage_ty| FieldType::new(mutability, storage_ty))
+            })
+    };
+
+    let struct_ty = StructType::new(&engine, field_types())?;
+
+    assert_eq!(struct_ty.fields().len(), field_types().count());
+    for ((i, expected), actual) in field_types().enumerate().zip(struct_ty.fields()) {
+        assert!(FieldType::eq(&expected, &actual));
+        assert!(FieldType::eq(&expected, &struct_ty.field(i).unwrap()));
+    }
+    assert!(struct_ty.field(struct_ty.fields().len()).is_none());
+
+    Ok(())
+}
+
+#[test]
+fn struct_type_matches() -> Result<()> {
+    let engine = Engine::default();
+
+    let super_ty = StructType::new(&engine, [field(HeapType::Func)])?;
+
+    // Depth.
+    let sub_ty = StructType::new(&engine, [field(HeapType::NoFunc)])?;
+    assert!(sub_ty.matches(&super_ty));
+
+    // Width.
+    let sub_ty = StructType::new(&engine, [field(HeapType::Func), field(HeapType::Extern)])?;
+    assert!(sub_ty.matches(&super_ty));
+
+    // Depth and width.
+    let sub_ty = StructType::new(&engine, [field(HeapType::NoFunc), field(HeapType::Extern)])?;
+    assert!(sub_ty.matches(&super_ty));
+
+    // Not depth.
+    let not_sub_ty = StructType::new(&engine, [field(HeapType::Extern)])?;
+    assert!(!not_sub_ty.matches(&super_ty));
+
+    // Not width.
+    let not_sub_ty = StructType::new(&engine, [])?;
+    assert!(!not_sub_ty.matches(&super_ty));
+
+    Ok(())
+}
+
+#[test]
+fn struct_subtyping_fields_must_match() -> Result<()> {
+    let engine = Engine::default();
+    let a = StructType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        None,
+        [field(HeapType::Any)],
+    )?;
+
+    for (expected, fields) in [
+        // Missing field.
+        (false, vec![]),
+        // Non-matching field.
+        (false, vec![field(HeapType::Extern)]),
+        // Exact match is okay.
+        (true, vec![field(HeapType::Any)]),
+        // Subtype of the field is okay.
+        (true, vec![field(HeapType::Eq)]),
+        // Extra fields are okay.
+        (true, vec![field(HeapType::Any), field(HeapType::Extern)]),
+    ] {
+        let actual =
+            StructType::with_finality_and_supertype(&engine, Finality::NonFinal, Some(&a), fields)
+                .is_ok();
+        assert_eq!(expected, actual);
+    }
+
+    Ok(())
+}
+
+#[test]
+fn struct_subtyping_supertype_and_finality() -> Result<()> {
+    let engine = Engine::default();
+
+    for (expected, finality) in [(true, Finality::NonFinal), (false, Finality::Final)] {
+        let a = StructType::with_finality_and_supertype(&engine, finality, None, [])?;
+        let actual =
+            StructType::with_finality_and_supertype(&engine, Finality::Final, Some(&a), []).is_ok();
+        assert_eq!(expected, actual);
+    }
+
+    Ok(())
+}
+
+#[test]
+fn struct_subtyping() -> Result<()> {
+    let engine = Engine::default();
+
+    // These types produce the following trees:
+    //
+    //                base               g
+    //               /    \             /
+    //              a      b           h
+    //             / \                /
+    //            c   d              i
+    //           /
+    //          e
+    //         /
+    //        f
+    let base = StructType::with_finality_and_supertype(&engine, Finality::NonFinal, None, [])?;
+    let a = StructType::with_finality_and_supertype(&engine, Finality::NonFinal, Some(&base), [])?;
+    let b = StructType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        Some(&base),
+        // Have to add a field so that `b` doesn't dedupe to `a`.
+        [field(HeapType::Any)],
+    )?;
+    let c = StructType::with_finality_and_supertype(&engine, Finality::NonFinal, Some(&a), [])?;
+    let d = StructType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        Some(&a),
+        // Have to add a field so that `d` doesn't dedupe to `c`.
+        [field(HeapType::Any)],
+    )?;
+    let e = StructType::with_finality_and_supertype(&engine, Finality::NonFinal, Some(&c), [])?;
+    let f = StructType::with_finality_and_supertype(&engine, Finality::NonFinal, Some(&e), [])?;
+    let g = StructType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        None,
+        // Have to add a field so that `g` doesn't dedupe to `base`.
+        [field(HeapType::Any)],
+    )?;
+    let h = StructType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        Some(&g),
+        [field(HeapType::Any)],
+    )?;
+    let i = StructType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        Some(&h),
+        [field(HeapType::Any)],
+    )?;
+
+    for (expected, sub_name, sub, sup_name, sup) in [
+        // Identity, at root.
+        (true, "base", &base, "base", &base),
+        // Identity, in middle.
+        (true, "c", &c, "c", &c),
+        // Identity, at leaf.
+        (true, "f", &f, "f", &f),
+        // Direct, at root.
+        (true, "a", &a, "base", &base),
+        // Direct, in middle.
+        (true, "c", &c, "a", &a),
+        // Direct, at leaf.
+        (true, "f", &f, "e", &e),
+        // Transitive, at root.
+        (true, "c", &c, "base", &base),
+        // Transitive, in middle.
+        (true, "e", &e, "a", &a),
+        // Transitive, at leaf.
+        (true, "f", &f, "c", &c),
+        // Unrelated roots.
+        (false, "base", &base, "g", &g),
+        (false, "g", &g, "base", &base),
+        // Unrelated siblings.
+        (false, "a", &a, "b", &b),
+        (false, "b", &b, "a", &a),
+        (false, "c", &c, "d", &d),
+        (false, "d", &d, "c", &c),
+        // Unrelated root and middle.
+        (false, "base", &base, "h", &h),
+        (false, "h", &h, "base", &base),
+        // Unrelated root and leaf.
+        (false, "base", &base, "i", &i),
+        (false, "i", &i, "base", &base),
+        // Unrelated middles.
+        (false, "a", &a, "h", &h),
+        (false, "h", &h, "a", &a),
+        // Unrelated middle and leaf.
+        (false, "a", &a, "i", &i),
+        (false, "i", &i, "a", &a),
+    ] {
+        eprintln!("expect that `{sub_name} <: {sup_name}` is `{expected}`");
+        let sub = HeapType::ConcreteStruct(sub.clone());
+        let sup = HeapType::ConcreteStruct(sup.clone());
+        let actual = sub.matches(&sup);
+        assert_eq!(expected, actual);
+    }
+
+    Ok(())
+}
+
+#[test]
+fn array_subtyping_field_must_match() -> Result<()> {
+    let engine = Engine::default();
+
+    let a = ArrayType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        None,
+        field(HeapType::Any),
+    )?;
+
+    for (expected, field) in [
+        // Non-matching field.
+        (false, field(HeapType::Extern)),
+        // Exact match is okay.
+        (true, field(HeapType::Any)),
+        // Subtype of the field is okay.
+        (true, field(HeapType::Eq)),
+    ] {
+        let actual =
+            ArrayType::with_finality_and_supertype(&engine, Finality::NonFinal, Some(&a), field)
+                .is_ok();
+        assert_eq!(expected, actual);
+    }
+
+    Ok(())
+}
+
+#[test]
+fn array_subtyping_supertype_and_finality() -> Result<()> {
+    let engine = Engine::default();
+
+    for (expected, finality) in [(true, Finality::NonFinal), (false, Finality::Final)] {
+        let superty =
+            ArrayType::with_finality_and_supertype(&engine, finality, None, field(HeapType::Any))?;
+        let actual = ArrayType::with_finality_and_supertype(
+            &engine,
+            Finality::Final,
+            Some(&superty),
+            field(HeapType::Any),
+        )
+        .is_ok();
+        assert_eq!(expected, actual);
+    }
+
+    Ok(())
+}
+
+#[test]
+fn array_subtyping() -> Result<()> {
+    let engine = Engine::default();
+
+    // These types produce the following trees:
+    //
+    //                base               g
+    //               /    \             /
+    //              a      b           h
+    //             / \                /
+    //            c   d              i
+    //           /
+    //          e
+    //         /
+    //        f
+    let base = ArrayType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        None,
+        field(HeapType::Any),
+    )?;
+    let a = ArrayType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        Some(&base),
+        field(HeapType::Any),
+    )?;
+    let b = ArrayType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        Some(&base),
+        field(HeapType::Eq),
+    )?;
+    let c = ArrayType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        Some(&a),
+        field(HeapType::Any),
+    )?;
+    let d = ArrayType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        Some(&a),
+        field(HeapType::Eq),
+    )?;
+    let e = ArrayType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        Some(&c),
+        field(HeapType::Any),
+    )?;
+    let f = ArrayType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        Some(&e),
+        field(HeapType::Any),
+    )?;
+    let g = ArrayType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        None,
+        field(HeapType::Eq),
+    )?;
+    let h = ArrayType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        Some(&g),
+        field(HeapType::Eq),
+    )?;
+    let i = ArrayType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        Some(&h),
+        field(HeapType::Eq),
+    )?;
+
+    for (expected, sub_name, sub, sup_name, sup) in [
+        // Identity, at root.
+        (true, "base", &base, "base", &base),
+        // Identity, in middle.
+        (true, "c", &c, "c", &c),
+        // Identity, at leaf.
+        (true, "f", &f, "f", &f),
+        // Direct, at root.
+        (true, "a", &a, "base", &base),
+        // Direct, in middle.
+        (true, "c", &c, "a", &a),
+        // Direct, at leaf.
+        (true, "f", &f, "e", &e),
+        // Transitive, at root.
+        (true, "c", &c, "base", &base),
+        // Transitive, in middle.
+        (true, "e", &e, "a", &a),
+        // Transitive, at leaf.
+        (true, "f", &f, "c", &c),
+        // Unrelated roots.
+        (false, "base", &base, "g", &g),
+        (false, "g", &g, "base", &base),
+        // Unrelated siblings.
+        (false, "a", &a, "b", &b),
+        (false, "b", &b, "a", &a),
+        (false, "c", &c, "d", &d),
+        (false, "d", &d, "c", &c),
+        // Unrelated root and middle.
+        (false, "base", &base, "h", &h),
+        (false, "h", &h, "base", &base),
+        // Unrelated root and leaf.
+        (false, "base", &base, "i", &i),
+        (false, "i", &i, "base", &base),
+        // Unrelated middles.
+        (false, "a", &a, "h", &h),
+        (false, "h", &h, "a", &a),
+        // Unrelated middle and leaf.
+        (false, "a", &a, "i", &i),
+        (false, "i", &i, "a", &a),
+    ] {
+        eprintln!("expect that `{sub_name} <: {sup_name}` is `{expected}`");
+        let sub = HeapType::ConcreteArray(sub.clone());
+        let sup = HeapType::ConcreteArray(sup.clone());
+        let actual = sub.matches(&sup);
+        assert_eq!(expected, actual);
+    }
+
+    Ok(())
+}
+
+#[test]
+fn func_subtyping_field_must_match() -> Result<()> {
+    let engine = Engine::default();
+
+    let superty = FuncType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        None,
+        [valty(HeapType::Struct)],
+        [valty(HeapType::Any)],
+    )?;
+
+    for (expected, param, ret) in [
+        // Non-matching param type.
+        (false, valty(HeapType::Extern), valty(HeapType::Any)),
+        // Non-matching return type.
+        (false, valty(HeapType::Struct), valty(HeapType::Extern)),
+        // Exact match is okay.
+        (true, valty(HeapType::Struct), valty(HeapType::Any)),
+        // Subtype of the return type is okay.
+        (true, valty(HeapType::Struct), valty(HeapType::Eq)),
+        // Supertype of the param type is okay.
+        (true, valty(HeapType::Eq), valty(HeapType::Any)),
+    ] {
+        let actual = FuncType::with_finality_and_supertype(
+            &engine,
+            Finality::NonFinal,
+            Some(&superty),
+            [param],
+            [ret],
+        )
+        .is_ok();
+        assert_eq!(expected, actual);
+    }
+
+    Ok(())
+}
+
+#[test]
+fn func_subtyping_supertype_and_finality() -> Result<()> {
+    let engine = Engine::default();
+
+    for (expected, finality) in [(true, Finality::NonFinal), (false, Finality::Final)] {
+        let superty = FuncType::with_finality_and_supertype(
+            &engine,
+            finality,
+            None,
+            [],
+            [valty(HeapType::Any)],
+        )?;
+        let actual = FuncType::with_finality_and_supertype(
+            &engine,
+            Finality::Final,
+            Some(&superty),
+            [],
+            [valty(HeapType::Any)],
+        )
+        .is_ok();
+        assert_eq!(expected, actual);
+    }
+
+    Ok(())
+}
+
+#[test]
+fn func_subtyping() -> Result<()> {
+    let engine = Engine::default();
+
+    // These types produce the following trees:
+    //
+    //                base               g
+    //               /    \             /
+    //              a      b           h
+    //             / \                /
+    //            c   d              i
+    //           /
+    //          e
+    //         /
+    //        f
+    let base = FuncType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        None,
+        [],
+        [valty(HeapType::Any)],
+    )?;
+    let a = FuncType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        Some(&base),
+        [],
+        [valty(HeapType::Any)],
+    )?;
+    let b = FuncType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        Some(&base),
+        [],
+        [valty(HeapType::Eq)],
+    )?;
+    let c = FuncType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        Some(&a),
+        [],
+        [valty(HeapType::Any)],
+    )?;
+    let d = FuncType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        Some(&a),
+        [],
+        [valty(HeapType::Eq)],
+    )?;
+    let e = FuncType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        Some(&c),
+        [],
+        [valty(HeapType::Any)],
+    )?;
+    let f = FuncType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        Some(&e),
+        [],
+        [valty(HeapType::Any)],
+    )?;
+    let g = FuncType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        None,
+        [],
+        [valty(HeapType::Eq)],
+    )?;
+    let h = FuncType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        Some(&g),
+        [],
+        [valty(HeapType::Eq)],
+    )?;
+    let i = FuncType::with_finality_and_supertype(
+        &engine,
+        Finality::NonFinal,
+        Some(&h),
+        [],
+        [valty(HeapType::Eq)],
+    )?;
+
+    for (expected, sub_name, sub, sup_name, sup) in [
+        // Identity, at root.
+        (true, "base", &base, "base", &base),
+        // Identity, in middle.
+        (true, "c", &c, "c", &c),
+        // Identity, at leaf.
+        (true, "f", &f, "f", &f),
+        // Direct, at root.
+        (true, "a", &a, "base", &base),
+        // Direct, in middle.
+        (true, "c", &c, "a", &a),
+        // Direct, at leaf.
+        (true, "f", &f, "e", &e),
+        // Transitive, at root.
+        (true, "c", &c, "base", &base),
+        // Transitive, in middle.
+        (true, "e", &e, "a", &a),
+        // Transitive, at leaf.
+        (true, "f", &f, "c", &c),
+        // Unrelated roots.
+        (false, "base", &base, "g", &g),
+        (false, "g", &g, "base", &base),
+        // Unrelated siblings.
+        (false, "a", &a, "b", &b),
+        (false, "b", &b, "a", &a),
+        (false, "c", &c, "d", &d),
+        (false, "d", &d, "c", &c),
+        // Unrelated root and middle.
+        (false, "base", &base, "h", &h),
+        (false, "h", &h, "base", &base),
+        // Unrelated root and leaf.
+        (false, "base", &base, "i", &i),
+        (false, "i", &i, "base", &base),
+        // Unrelated middles.
+        (false, "a", &a, "h", &h),
+        (false, "h", &h, "a", &a),
+        // Unrelated middle and leaf.
+        (false, "a", &a, "i", &i),
+        (false, "i", &i, "a", &a),
+    ] {
+        eprintln!("expect that `{sub_name} <: {sup_name}` is `{expected}`");
+        let sub = HeapType::ConcreteFunc(sub.clone());
+        let sup = HeapType::ConcreteFunc(sup.clone());
+        let actual = sub.matches(&sup);
+        assert_eq!(expected, actual);
+    }
+
+    Ok(())
+}
diff --git a/tests/all/wait_notify.rs b/tests/all/wait_notify.rs
index fb95e5d6baa9..6d9e3a0ac9d4 100644
--- a/tests/all/wait_notify.rs
+++ b/tests/all/wait_notify.rs
@@ -1,6 +1,5 @@
 #![cfg(not(miri))]
 
-use anyhow::Result;
 use std::time::Instant;
 use wasmtime::*;
 
diff --git a/tests/all/wasi_testsuite.rs b/tests/all/wasi_testsuite.rs
index 093a633c9826..2b02c722306e 100644
--- a/tests/all/wasi_testsuite.rs
+++ b/tests/all/wasi_testsuite.rs
@@ -30,7 +30,25 @@ fn wasi_testsuite() -> Result<()> {
     // `cargo test wasi_testsuite -- --nocapture`. The printed output will show
     // the expected result, the actual result, and a command to replicate the
     // failure from the command line.
-    const WASI_COMMON_IGNORE_LIST: &[&str] = &["fd_advise.wasm"];
+    const WASI_COMMON_IGNORE_LIST: &[&str] = &[
+        // Uses functions not supported in Wasmtime due to portability concerns
+        "fd_advise.wasm",
+        "file_allocate.wasm",
+        // #8828
+        "remove_directory_trailing_slashes.wasm",
+        // Working with rights which are removed from wasmtime
+        "truncation_rights.wasm",
+        "fd_fdstat_set_rights.wasm",
+        "path_open_preopen.wasm",
+        "path_link.wasm",
+        // This test wants an operation to fail that wasmtime thinks is valid
+        "renumber.wasm",
+        // Works with FDFLAGS_SYNC which isn't supported
+        "path_filestat.wasm",
+        // this test asserts semantics of pwrite which don't match Linux so
+        // ignore the test for now.
+        "pwrite-with-append.wasm",
+    ];
     run_all(
         "tests/wasi_testsuite/wasi-common",
         &[],
@@ -65,7 +83,19 @@ fn run_all(testsuite_dir: &str, extra_flags: &[&str], ignore: &[&str]) -> Result
             if spec != result {
                 println!("  command: {cmd:?}");
                 println!("  spec: {spec:#?}");
-                println!("  result: {result:#?}");
+                println!("  result.status: {}", result.status);
+                if !result.stdout.is_empty() {
+                    println!(
+                        "  result.stdout:\n    {}",
+                        String::from_utf8_lossy(&result.stdout).replace("\n", "\n    ")
+                    );
+                }
+                if !result.stderr.is_empty() {
+                    println!(
+                        "  result.stderr:\n    {}",
+                        String::from_utf8_lossy(&result.stderr).replace("\n", "\n    ")
+                    );
+                }
                 panic!("FAILED! The result does not match the specification");
             }
         }
@@ -110,7 +140,7 @@ fn build_command<P: AsRef<Path>>(module: P, extra_flags: &[&str], spec: &Spec) -
     if let Some(dirs) = &spec.dirs {
         for dir in dirs {
             cmd.arg("--dir");
-            cmd.arg(format!("{}::{}", dir, parent_dir.join(dir).display()));
+            cmd.arg(format!("{}::{}", parent_dir.join(dir).display(), dir));
         }
     }
     // Add environment variables as CLI arguments.
@@ -133,7 +163,7 @@ fn clean_garbage(testsuite_dir: &str) -> Result<()> {
     for path in list_files(testsuite_dir, is_garbage) {
         println!("Removing {}", path.display());
         if path.is_dir() {
-            fs::remove_dir(path)?;
+            fs::remove_dir_all(path)?;
         } else {
             fs::remove_file(path)?;
         }
diff --git a/tests/all/wast.rs b/tests/all/wast.rs
deleted file mode 100644
index 8f2f357be67d..000000000000
--- a/tests/all/wast.rs
+++ /dev/null
@@ -1,217 +0,0 @@
-use anyhow::Context;
-use bstr::ByteSlice;
-use once_cell::sync::Lazy;
-use std::path::Path;
-use std::sync::{Condvar, Mutex};
-use wasmtime::{
-    Config, Engine, InstanceAllocationStrategy, PoolingAllocationConfig, Store, Strategy,
-};
-use wasmtime_environ::WASM_PAGE_SIZE;
-use wasmtime_wast::WastContext;
-
-include!(concat!(env!("OUT_DIR"), "/wast_testsuite_tests.rs"));
-
-// Each of the tests included from `wast_testsuite_tests` will call this
-// function which actually executes the `wast` test suite given the `strategy`
-// to compile it.
-fn run_wast(wast: &str, strategy: Strategy, pooling: bool) -> anyhow::Result<()> {
-    drop(env_logger::try_init());
-
-    let wast_bytes = std::fs::read(wast).with_context(|| format!("failed to read `{}`", wast))?;
-
-    let wast = Path::new(wast);
-
-    let memory64 = feature_found(wast, "memory64");
-    let multi_memory = feature_found(wast, "multi-memory");
-    let threads = feature_found(wast, "threads");
-    let function_references = feature_found(wast, "function-references");
-    let reference_types = !(threads && feature_found(wast, "proposals"));
-    let relaxed_simd = feature_found(wast, "relaxed-simd");
-    let tail_call = feature_found(wast, "tail-call") || feature_found(wast, "function-references");
-    let use_shared_memory = feature_found_src(&wast_bytes, "shared_memory")
-        || feature_found_src(&wast_bytes, "shared)");
-
-    if pooling && use_shared_memory {
-        eprintln!("skipping pooling test with shared memory");
-        return Ok(());
-    }
-
-    let is_cranelift = match strategy {
-        Strategy::Cranelift => true,
-        _ => false,
-    };
-
-    let mut cfg = Config::new();
-    cfg.wasm_multi_memory(multi_memory)
-        .wasm_threads(threads)
-        .wasm_memory64(memory64)
-        .wasm_function_references(function_references)
-        .wasm_reference_types(reference_types)
-        .wasm_relaxed_simd(relaxed_simd)
-        .wasm_tail_call(tail_call)
-        .strategy(strategy);
-
-    if is_cranelift {
-        cfg.cranelift_debug_verifier(true);
-    }
-
-    cfg.wasm_component_model(feature_found(wast, "component-model"));
-
-    if feature_found(wast, "canonicalize-nan") && is_cranelift {
-        cfg.cranelift_nan_canonicalization(true);
-    }
-    let test_allocates_lots_of_memory = wast.ends_with("more-than-4gb.wast");
-
-    // By default we'll allocate huge chunks (6gb) of the address space for each
-    // linear memory. This is typically fine but when we emulate tests with QEMU
-    // it turns out that it causes memory usage to balloon massively. Leave a
-    // knob here so on CI we can cut down the memory usage of QEMU and avoid the
-    // OOM killer.
-    //
-    // Locally testing this out this drops QEMU's memory usage running this
-    // tests suite from 10GiB to 600MiB. Previously we saw that crossing the
-    // 10GiB threshold caused our processes to get OOM killed on CI.
-    if std::env::var("WASMTIME_TEST_NO_HOG_MEMORY").is_ok() {
-        // The pooling allocator hogs ~6TB of virtual address space for each
-        // store, so if we don't to hog memory then ignore pooling tests.
-        if pooling {
-            return Ok(());
-        }
-
-        // If the test allocates a lot of memory, that's considered "hogging"
-        // memory, so skip it.
-        if test_allocates_lots_of_memory {
-            return Ok(());
-        }
-
-        // Don't use 4gb address space reservations when not hogging memory, and
-        // also don't reserve lots of memory after dynamic memories for growth
-        // (makes growth slower).
-        if use_shared_memory {
-            cfg.static_memory_maximum_size(2 * WASM_PAGE_SIZE as u64);
-        } else {
-            cfg.static_memory_maximum_size(0);
-        }
-        cfg.dynamic_memory_reserved_for_growth(0);
-        cfg.static_memory_guard_size(0);
-        cfg.dynamic_memory_guard_size(0);
-    }
-
-    let _pooling_lock = if pooling {
-        // Some memory64 tests take more than 4gb of resident memory to test,
-        // but we don't want to configure the pooling allocator to allow that
-        // (that's a ton of memory to reserve), so we skip those tests.
-        if test_allocates_lots_of_memory {
-            return Ok(());
-        }
-
-        // Reduce the virtual memory required to run multi-memory-based tests.
-        //
-        // The configuration parameters below require that a bare minimum
-        // virtual address space reservation of 450*9*805*65536 == 200G be made
-        // to support each test. If 6G reservations are made for each linear
-        // memory then not that many tests can run concurrently with much else.
-        //
-        // When multiple memories are used and are configured in the pool then
-        // force the usage of static memories without guards to reduce the VM
-        // impact.
-        if multi_memory {
-            cfg.static_memory_maximum_size(0);
-            cfg.dynamic_memory_reserved_for_growth(0);
-            cfg.static_memory_guard_size(0);
-            cfg.dynamic_memory_guard_size(0);
-        }
-
-        // The limits here are crafted such that the wast tests should pass.
-        // However, these limits may become insufficient in the future as the wast tests change.
-        // If a wast test fails because of a limit being "exceeded" or if memory/table
-        // fails to grow, the values here will need to be adjusted.
-        let mut pool = PoolingAllocationConfig::default();
-        pool.total_memories(450)
-            .memory_pages(805)
-            .max_memories_per_module(if multi_memory { 9 } else { 1 })
-            .max_tables_per_module(4);
-        cfg.allocation_strategy(InstanceAllocationStrategy::Pooling(pool));
-        Some(lock_pooling())
-    } else {
-        None
-    };
-
-    let mut engines = vec![(Engine::new(&cfg)?, "default")];
-
-    // For tests that use relaxed-simd test both the default engine and the
-    // guaranteed-deterministic engine to ensure that both the 'native'
-    // semantics of the instructions plus the canonical semantics work.
-    if relaxed_simd {
-        engines.push((
-            Engine::new(cfg.relaxed_simd_deterministic(true))?,
-            "deterministic",
-        ));
-    }
-
-    for (engine, desc) in engines {
-        let store = Store::new(&engine, ());
-        let mut wast_context = WastContext::new(store);
-        wast_context.register_spectest(use_shared_memory)?;
-        wast_context
-            .run_buffer(wast.to_str().unwrap(), &wast_bytes)
-            .with_context(|| format!("failed to run spec test with {desc} engine"))?;
-    }
-
-    Ok(())
-}
-
-fn feature_found(path: &Path, name: &str) -> bool {
-    path.iter().any(|part| match part.to_str() {
-        Some(s) => s.contains(name),
-        None => false,
-    })
-}
-
-fn feature_found_src(bytes: &[u8], name: &str) -> bool {
-    bytes.contains_str(name)
-}
-
-// The pooling tests make about 6TB of address space reservation which means
-// that we shouldn't let too many of them run concurrently at once. On
-// high-cpu-count systems (e.g. 80 threads) this leads to mmap failures because
-// presumably too much of the address space has been reserved with our limits
-// specified above. By keeping the number of active pooling-related tests to a
-// specified maximum we can put a cap on the virtual address space reservations
-// made.
-fn lock_pooling() -> impl Drop {
-    const MAX_CONCURRENT_POOLING: u32 = 8;
-
-    static ACTIVE: Lazy<MyState> = Lazy::new(MyState::default);
-
-    #[derive(Default)]
-    struct MyState {
-        lock: Mutex<u32>,
-        waiters: Condvar,
-    }
-
-    impl MyState {
-        fn lock(&self) -> impl Drop + '_ {
-            let state = self.lock.lock().unwrap();
-            let mut state = self
-                .waiters
-                .wait_while(state, |cnt| *cnt >= MAX_CONCURRENT_POOLING)
-                .unwrap();
-            *state += 1;
-            LockGuard { state: self }
-        }
-    }
-
-    struct LockGuard<'a> {
-        state: &'a MyState,
-    }
-
-    impl Drop for LockGuard<'_> {
-        fn drop(&mut self) {
-            *self.state.lock.lock().unwrap() -= 1;
-            self.state.waiters.notify_one();
-        }
-    }
-
-    ACTIVE.lock()
-}
diff --git a/tests/all/winch.rs b/tests/all/winch.rs
deleted file mode 100644
index 03318b45a41f..000000000000
--- a/tests/all/winch.rs
+++ /dev/null
@@ -1,241 +0,0 @@
-use anyhow::{bail, Result};
-use wasmtime::*;
-
-const MODULE: &'static str = r#"
-    (module
-      (import "" "" (func $add (param i32 i32) (result i32)))
-      (func $test (result i32)
-        (i32.const 42)
-      )
-
-      (func $sum10 (param $arg_1 i32) (param $arg_2 i32) (param $arg_3 i32) (param $arg_4 i32) (param $arg_5 i32) (param $arg_6 i32) (param $arg_7 i32) (param $arg_8 i32) (param $arg_9 i32) (param $arg_10 i32) (result i32)
-        local.get $arg_1
-        local.get $arg_2
-        i32.add
-        local.get $arg_3
-        i32.add
-        local.get $arg_4
-        i32.add
-        local.get $arg_5
-        i32.add
-        local.get $arg_6
-        i32.add
-        local.get $arg_7
-        i32.add
-        local.get $arg_8
-        i32.add
-        local.get $arg_9
-        i32.add
-        local.get $arg_10
-        i32.add)
-
-      (func $call_add (param i32 i32) (result i32)
-        (local.get 0)
-        (local.get 1)
-        (call $add))
-
-      (export "42" (func $test))
-      (export "sum10" (func $sum10))
-      (export "call_add" (func $call_add))
-    )
-    "#;
-
-const MIXED: &'static str = r#"
-    (module
-      (import "" "" (func $id_float (param f64 f64 f64 f64 f32 f32 f32 f32 f64 i32 i64) (result f64)))
-      (func $call_id_float (param f64 f64 f64 f64 f32 f32 f32 f32 f64 i32 i64) (result f64)
-         (local.get 0)
-         (local.get 1)
-         (local.get 2)
-         (local.get 3)
-         (local.get 4)
-         (local.get 5)
-         (local.get 6)
-         (local.get 7)
-         (local.get 8)
-         (local.get 9)
-         (local.get 10)
-         (call $id_float)
-      )
-      (export "call_id_float" (func $call_id_float)))
-"#;
-
-fn add_fn(store: impl AsContextMut) -> Func {
-    Func::wrap(store, |a: i32, b: i32| a + b)
-}
-
-fn id_float(store: impl AsContextMut) -> Func {
-    Func::wrap(
-        store,
-        |_: f64, _: f64, _: f64, _: f64, _: f32, _: f32, _: f32, _: f32, x: f64, _: i32, _: i64| x,
-    )
-}
-
-#[test]
-#[cfg_attr(miri, ignore)]
-fn array_to_wasm() -> Result<()> {
-    let mut c = Config::new();
-    c.strategy(Strategy::Winch);
-    let engine = Engine::new(&c)?;
-    let mut store = Store::new(&engine, ());
-    let module = Module::new(&engine, MODULE)?;
-
-    let add_fn = add_fn(store.as_context_mut());
-    let instance = Instance::new(&mut store, &module, &[add_fn.into()])?;
-
-    let constant = instance
-        .get_func(&mut store, "42")
-        .ok_or(anyhow::anyhow!("test function not found"))?;
-    let mut returns = vec![Val::null(); 1];
-    constant.call(&mut store, &[], &mut returns)?;
-
-    assert_eq!(returns.len(), 1);
-    assert_eq!(returns[0].unwrap_i32(), 42);
-
-    let sum = instance
-        .get_func(&mut store, "sum10")
-        .ok_or(anyhow::anyhow!("sum10 function not found"))?;
-    let mut returns = vec![Val::null(); 1];
-    let args = vec![Val::I32(1); 10];
-    sum.call(&mut store, &args, &mut returns)?;
-
-    assert_eq!(returns.len(), 1);
-    assert_eq!(returns[0].unwrap_i32(), 10);
-    Ok(())
-}
-
-#[test]
-#[cfg_attr(miri, ignore)]
-fn native_to_wasm() -> Result<()> {
-    let mut c = Config::new();
-    c.strategy(Strategy::Winch);
-    let engine = Engine::new(&c)?;
-    let mut store = Store::new(&engine, ());
-    let module = Module::new(&engine, MODULE)?;
-
-    let add_fn = add_fn(store.as_context_mut());
-    let instance = Instance::new(&mut store, &module, &[add_fn.into()])?;
-
-    let f = instance.get_typed_func::<(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32), i32>(
-        &mut store, "sum10",
-    )?;
-
-    let args = (1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
-    let result = f.call(&mut store, args)?;
-
-    assert_eq!(result, 10);
-    Ok(())
-}
-
-#[test]
-#[cfg_attr(miri, ignore)]
-fn wasm_to_native() -> Result<()> {
-    let mut c = Config::new();
-    c.strategy(Strategy::Winch);
-    let engine = Engine::new(&c)?;
-    let mut store = Store::new(&engine, ());
-
-    let module = Module::new(&engine, MODULE)?;
-    let add_fn = add_fn(store.as_context_mut());
-
-    let instance = Instance::new(&mut store, &module, &[add_fn.into()])?;
-
-    let call_add = instance.get_typed_func::<(i32, i32), i32>(&mut store, "call_add")?;
-    let result = call_add.call(&mut store, (41, 1))?;
-    assert_eq!(result, 42);
-
-    Ok(())
-}
-
-#[test]
-#[cfg_attr(miri, ignore)]
-fn mixed_roundtrip() -> Result<()> {
-    let mut c = Config::new();
-    c.strategy(Strategy::Winch);
-    let engine = Engine::new(&c)?;
-    let mut store = Store::new(&engine, ());
-
-    let module = Module::new(&engine, MIXED)?;
-    let import = id_float(store.as_context_mut());
-
-    let instance = Instance::new(&mut store, &module, &[import.into()])?;
-    let call_id_float = instance
-        .get_typed_func::<(f64, f64, f64, f64, f32, f32, f32, f32, f64, i32, i64), f64>(
-            &mut store,
-            "call_id_float",
-        )?;
-
-    let result = call_id_float.call(
-        &mut store,
-        (1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 0, 5),
-    )?;
-    assert_eq!(result, 1.9);
-    Ok(())
-}
-
-#[test]
-#[cfg_attr(miri, ignore)]
-#[cfg_attr(windows, ignore)]
-// NB
-//
-// This and the following test(`native_to_wasm_trap` and `wasm_to_native_trap`),
-// are mostly smoke tests to ensure Winch's trampolines are compliant with fast
-// stack walking. The ideal state is one in which we should not have to worry
-// about testing the backtrace implementation per compiler, but instead be
-// certain that a single set of test cases is enough to ensure that the machine
-// code generated by Winch and Cranelift is compliant. One way to achieve this
-// could be to share the implementation of trampolines between Cranelift and
-// Winch.
-//
-// FIXME The following two tests are also temporarily ignored on Windows, since
-// we are not emitting the require unwind information yet.
-fn native_to_wasm_trap() -> Result<()> {
-    let mut c = Config::new();
-    c.strategy(Strategy::Winch);
-    let engine = Engine::new(&c)?;
-    let wat = r#"
-        (module
-          (func $div_by_zero (result i32)
-            (i32.const 1)
-            (i32.const 0)
-            i32.div_u)
-
-          (export "div_by_zero" (func $div_by_zero)))
-    "#;
-    let mut store = Store::new(&engine, ());
-    let module = Module::new(&engine, wat)?;
-    let instance = Instance::new(&mut store, &module, &[])?;
-    let f = instance.get_typed_func::<(), i32>(&mut store, "div_by_zero")?;
-    let result = f.call(&mut store, ()).unwrap_err();
-
-    assert!(result.downcast_ref::<WasmBacktrace>().is_some());
-
-    Ok(())
-}
-
-#[test]
-#[cfg_attr(miri, ignore)]
-#[cfg_attr(windows, ignore)]
-fn wasm_to_native_trap() -> Result<()> {
-    let mut c = Config::new();
-    c.strategy(Strategy::Winch);
-    let engine = Engine::new(&c)?;
-    let wat = r#"
-        (module
-          (import "" "" (func $fail))
-          (func $call_fail
-            call $fail)
-
-          (export "call_fail" (func $call_fail)))
-    "#;
-    let mut store = Store::new(&engine, ());
-    let module = Module::new(&engine, wat)?;
-    let func = Func::wrap::<(), (), Result<()>>(&mut store, || bail!("error"));
-    let instance = Instance::new(&mut store, &module, &[func.into()])?;
-    let f = instance.get_typed_func::<(), ()>(&mut store, "call_fail")?;
-    let result = f.call(&mut store, ()).unwrap_err();
-
-    assert!(result.downcast_ref::<WasmBacktrace>().is_some());
-
-    Ok(())
-}
diff --git a/tests/custom_signal_handler.rs b/tests/custom_signal_handler.rs
new file mode 100644
index 000000000000..6bbce9ae7597
--- /dev/null
+++ b/tests/custom_signal_handler.rs
@@ -0,0 +1,340 @@
+// NB: this is a separate test file because on macOS this should use signals
+// instead of Mach Ports and only one can be configured globally per process.
+
+#![cfg(any(target_os = "linux", target_os = "macos"))]
+#![cfg(not(miri))]
+
+use rustix::mm::{mprotect, MprotectFlags};
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+use wasmtime::unix::StoreExt;
+use wasmtime::*;
+
+const WAT1: &str = r#"
+(module
+  (func $hostcall_read (import "" "hostcall_read") (result i32))
+  (func $read (export "read") (result i32)
+    (i32.load (i32.const 0))
+  )
+  (func $read_out_of_bounds (export "read_out_of_bounds") (result i32)
+    (i32.load
+      (i32.mul
+        ;; memory size in Wasm pages
+        (memory.size)
+        ;; Wasm page size
+        (i32.const 65536)
+      )
+    )
+  )
+  (func (export "hostcall_read") (result i32)
+    call $hostcall_read
+  )
+  (func $start
+    (i32.store (i32.const 0) (i32.const 123))
+  )
+  (start $start)
+  (memory (export "memory") 1 4)
+)
+"#;
+
+const WAT2: &str = r#"
+(module
+  (import "other_module" "read" (func $other_module.read (result i32)))
+  (func $run (export "run") (result i32)
+      call $other_module.read)
+)
+"#;
+
+fn invoke_export(store: &mut Store<()>, instance: Instance, func_name: &str) -> Result<i32> {
+    let ret = instance
+        .get_typed_func::<(), i32>(&mut *store, func_name)?
+        .call(store, ())?;
+    Ok(ret)
+}
+
+// Locate "memory" export, get base address and size and set memory protection to PROT_NONE
+fn set_up_memory(store: &mut Store<()>, instance: Instance) -> (usize, usize) {
+    let mem_export = instance.get_memory(&mut *store, "memory").unwrap();
+    let base = mem_export.data_ptr(&store);
+    let length = mem_export.data_size(&store);
+
+    // So we can later trigger SIGSEGV by performing a read
+    unsafe {
+        mprotect(
+            base as *mut std::ffi::c_void,
+            length,
+            MprotectFlags::empty(),
+        )
+        .unwrap();
+    }
+
+    println!("memory: base={base:?}, length={length}");
+
+    (base as usize, length)
+}
+
+fn handle_sigsegv(
+    base: usize,
+    length: usize,
+    signum: libc::c_int,
+    siginfo: *const libc::siginfo_t,
+) -> bool {
+    println!("Hello from instance signal handler!");
+    // SIGSEGV on Linux, SIGBUS on Mac
+    if libc::SIGSEGV == signum || libc::SIGBUS == signum {
+        let si_addr: *mut libc::c_void = unsafe { (*siginfo).si_addr() };
+        // Any signal from within module's memory we handle ourselves
+        let result = (si_addr as u64) < (base as u64) + (length as u64);
+        // Remove protections so the execution may resume
+        unsafe {
+            mprotect(
+                base as *mut libc::c_void,
+                length,
+                MprotectFlags::READ | MprotectFlags::WRITE,
+            )
+            .unwrap();
+        }
+        println!("signal handled: {result}");
+        result
+    } else {
+        // Otherwise, we forward to wasmtime's signal handler.
+        false
+    }
+}
+
+fn make_externs(store: &mut Store<()>, module: &Module) -> Vec<Extern> {
+    module
+        .imports()
+        .map(|import| {
+            assert_eq!("hostcall_read", import.name());
+            let func = Func::wrap(&mut *store, {
+                move |mut caller: Caller<'_, _>| {
+                    let mem = caller.get_export("memory").unwrap().into_memory().unwrap();
+                    let memory = mem.data(&caller);
+                    i32::from_le_bytes(memory[0..4].try_into().unwrap())
+                }
+            });
+            wasmtime::Extern::Func(func)
+        })
+        .collect::<Vec<_>>()
+}
+
+fn engine() -> Engine {
+    let mut config = Config::new();
+    config.macos_use_mach_ports(false);
+    Engine::new(&config).unwrap()
+}
+
+// This test will only succeed if the SIGSEGV signal originating from the
+// hostcall can be handled.
+#[test]
+fn test_custom_signal_handler_single_instance_hostcall() -> Result<()> {
+    let engine = engine();
+    let mut store = Store::new(&engine, ());
+    let module = Module::new(&engine, WAT1)?;
+
+    let externs = make_externs(&mut store, &module);
+    let instance = Instance::new(&mut store, &module, &externs)?;
+
+    let (base, length) = set_up_memory(&mut store, instance);
+    unsafe {
+        store.set_signal_handler(move |signum, siginfo, _| {
+            handle_sigsegv(base, length, signum, siginfo)
+        });
+    }
+    println!("calling hostcall_read...");
+    let result = invoke_export(&mut store, instance, "hostcall_read").unwrap();
+    assert_eq!(123, result);
+    Ok(())
+}
+
+#[test]
+fn test_custom_signal_handler_single_instance() -> Result<()> {
+    let engine = engine();
+    let mut store = Store::new(&engine, ());
+    let module = Module::new(&engine, WAT1)?;
+
+    let externs = make_externs(&mut store, &module);
+    let instance = Instance::new(&mut store, &module, &externs)?;
+
+    let (base, length) = set_up_memory(&mut store, instance);
+    unsafe {
+        store.set_signal_handler(move |signum, siginfo, _| {
+            handle_sigsegv(base, length, signum, siginfo)
+        });
+    }
+
+    // these invoke wasmtime_call_trampoline from action.rs
+    {
+        println!("calling read...");
+        let result = invoke_export(&mut store, instance, "read").expect("read succeeded");
+        assert_eq!(123, result);
+    }
+
+    {
+        println!("calling read_out_of_bounds...");
+        let trap = invoke_export(&mut store, instance, "read_out_of_bounds")
+            .unwrap_err()
+            .downcast::<Trap>()?;
+        assert_eq!(trap, Trap::MemoryOutOfBounds);
+    }
+
+    // these invoke wasmtime_call_trampoline from callable.rs
+    {
+        let read_func = instance.get_typed_func::<(), i32>(&mut store, "read")?;
+        println!("calling read...");
+        let result = read_func
+            .call(&mut store, ())
+            .expect("expected function not to trap");
+        assert_eq!(123i32, result);
+    }
+
+    {
+        let read_out_of_bounds_func =
+            instance.get_typed_func::<(), i32>(&mut store, "read_out_of_bounds")?;
+        println!("calling read_out_of_bounds...");
+        let trap = read_out_of_bounds_func
+            .call(&mut store, ())
+            .unwrap_err()
+            .downcast::<Trap>()?;
+        assert_eq!(trap, Trap::MemoryOutOfBounds);
+    }
+    Ok(())
+}
+
+#[test]
+fn test_custom_signal_handler_multiple_instances() -> Result<()> {
+    let engine = engine();
+    let mut store = Store::new(&engine, ());
+    let module = Module::new(&engine, WAT1)?;
+
+    // Set up multiple instances
+
+    let externs = make_externs(&mut store, &module);
+    let instance1 = Instance::new(&mut store, &module, &externs)?;
+    let instance1_handler_triggered = Arc::new(AtomicBool::new(false));
+
+    unsafe {
+        let (base1, length1) = set_up_memory(&mut store, instance1);
+
+        store.set_signal_handler({
+            let instance1_handler_triggered = instance1_handler_triggered.clone();
+            move |_signum, _siginfo, _context| {
+                // Remove protections so the execution may resume
+                mprotect(
+                    base1 as *mut libc::c_void,
+                    length1,
+                    MprotectFlags::READ | MprotectFlags::WRITE,
+                )
+                .unwrap();
+                instance1_handler_triggered.store(true, Ordering::SeqCst);
+                println!(
+                    "Hello from instance1 signal handler! {}",
+                    instance1_handler_triggered.load(Ordering::SeqCst)
+                );
+                true
+            }
+        });
+    }
+
+    // Invoke both instances and trigger both signal handlers
+
+    // First instance1
+    {
+        let mut exports1 = instance1.exports(&mut store);
+        assert!(exports1.next().is_some());
+        drop(exports1);
+
+        println!("calling instance1.read...");
+        let result = invoke_export(&mut store, instance1, "read").expect("read succeeded");
+        assert_eq!(123, result);
+        assert_eq!(
+            instance1_handler_triggered.load(Ordering::SeqCst),
+            true,
+            "instance1 signal handler has been triggered"
+        );
+    }
+
+    let externs = make_externs(&mut store, &module);
+    let instance2 =
+        Instance::new(&mut store, &module, &externs).expect("failed to instantiate module");
+    let instance2_handler_triggered = Arc::new(AtomicBool::new(false));
+
+    unsafe {
+        let (base2, length2) = set_up_memory(&mut store, instance2);
+
+        store.set_signal_handler({
+            let instance2_handler_triggered = instance2_handler_triggered.clone();
+            move |_signum, _siginfo, _context| {
+                // Remove protections so the execution may resume
+                mprotect(
+                    base2 as *mut libc::c_void,
+                    length2,
+                    MprotectFlags::READ | MprotectFlags::WRITE,
+                )
+                .unwrap();
+                instance2_handler_triggered.store(true, Ordering::SeqCst);
+                println!(
+                    "Hello from instance2 signal handler! {}",
+                    instance2_handler_triggered.load(Ordering::SeqCst)
+                );
+                true
+            }
+        });
+    }
+
+    // And then instance2
+    {
+        let mut exports2 = instance2.exports(&mut store);
+        assert!(exports2.next().is_some());
+        drop(exports2);
+
+        println!("calling instance2.read...");
+        let result = invoke_export(&mut store, instance2, "read").expect("read succeeded");
+        assert_eq!(123, result);
+        assert_eq!(
+            instance2_handler_triggered.load(Ordering::SeqCst),
+            true,
+            "instance1 signal handler has been triggered"
+        );
+    }
+    Ok(())
+}
+
+#[test]
+fn test_custom_signal_handler_instance_calling_another_instance() -> Result<()> {
+    let engine = engine();
+    let mut store = Store::new(&engine, ());
+
+    // instance1 which defines 'read'
+    let module1 = Module::new(&engine, WAT1)?;
+    let externs = make_externs(&mut store, &module1);
+    let instance1 = Instance::new(&mut store, &module1, &externs)?;
+    let (base1, length1) = set_up_memory(&mut store, instance1);
+    unsafe {
+        store.set_signal_handler(move |signum, siginfo, _| {
+            println!("instance1");
+            handle_sigsegv(base1, length1, signum, siginfo)
+        });
+    }
+
+    let mut instance1_exports = instance1.exports(&mut store);
+    let instance1_read = instance1_exports.next().unwrap().clone().into_extern();
+    drop(instance1_exports);
+
+    // instance2 which calls 'instance1.read'
+    let module2 = Module::new(&engine, WAT2)?;
+    let instance2 = Instance::new(&mut store, &module2, &[instance1_read])?;
+    // since 'instance2.run' calls 'instance1.read' we need to set up the signal handler to handle
+    // SIGSEGV originating from within the memory of instance1
+    unsafe {
+        store.set_signal_handler(move |signum, siginfo, _| {
+            handle_sigsegv(base1, length1, signum, siginfo)
+        });
+    }
+
+    println!("calling instance2.run");
+    let result = invoke_export(&mut store, instance2, "run")?;
+    assert_eq!(123, result);
+    Ok(())
+}
diff --git a/tests/disas.rs b/tests/disas.rs
new file mode 100644
index 000000000000..1a07e8d698e5
--- /dev/null
+++ b/tests/disas.rs
@@ -0,0 +1,467 @@
+//! A filetest-lookalike test suite using Cranelift tooling but built on
+//! Wasmtime's code generator.
+//!
+//! This test will read the `tests/disas/*` directory and interpret all files in
+//! that directory as a test. Each test must be in the wasm text format and
+//! start with directives that look like:
+//!
+//! ```wasm
+//! ;;! target = "x86_64"
+//! ;;! compile = true
+//!
+//! (module
+//!     ;; ...
+//! )
+//! ```
+//!
+//! Tests must configure a `target` and then can optionally specify a kind of
+//! test:
+//!
+//! * No specifier - the output CLIF from translation is inspected.
+//! * `optimize = true` - CLIF is emitted, then optimized, then inspected.
+//! * `compile = true` - backends are run to produce machine code and that's inspected.
+//!
+//! Tests may also have a `flags` directive which are CLI flags to Wasmtime
+//! itself:
+//!
+//! ```wasm
+//! ;;! target = "x86_64"
+//! ;;! flags = "-O opt-level=s"
+//!
+//! (module
+//!     ;; ...
+//! )
+//! ```
+//!
+//! Flags are parsed by the `wasmtime_cli_flags` crate to build a `Config`.
+//!
+//! Configuration of tests is prefixed with `;;!` comments and must be present
+//! at the start of the file. These comments are then parsed as TOML and
+//! deserialized into `TestConfig` in this crate.
+
+use anyhow::{bail, Context, Result};
+use clap::Parser;
+use cranelift_codegen::ir::{Function, UserExternalName, UserFuncName};
+use cranelift_codegen::isa::{lookup_by_name, TargetIsa};
+use cranelift_codegen::settings::{Configurable, Flags, SetError};
+use libtest_mimic::{Arguments, Trial};
+use serde::de::DeserializeOwned;
+use serde_derive::Deserialize;
+use similar::TextDiff;
+use std::fmt::Write;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use tempfile::TempDir;
+use wasmtime::{Engine, OptLevel, Strategy};
+use wasmtime_cli_flags::CommonOptions;
+
+fn main() -> Result<()> {
+    if cfg!(miri) {
+        return Ok(());
+    }
+
+    let mut tests = Vec::new();
+    find_tests("./tests/disas".as_ref(), &mut tests)?;
+
+    let mut trials = Vec::new();
+    for test in tests {
+        trials.push(Trial::test(test.to_str().unwrap().to_string(), move || {
+            run_test(&test)
+                .with_context(|| format!("failed to run tests {test:?}"))
+                .map_err(|e| format!("{e:?}").into())
+        }))
+    }
+
+    // These tests have some long names so use the "quiet" output by default.
+    let mut arguments = Arguments::parse();
+    if arguments.format.is_none() {
+        arguments.quiet = true;
+    }
+    libtest_mimic::run(&arguments, trials).exit()
+}
+
+fn find_tests(path: &Path, dst: &mut Vec<PathBuf>) -> Result<()> {
+    for file in path
+        .read_dir()
+        .with_context(|| format!("failed to read {path:?}"))?
+    {
+        let file = file.context("failed to read directory entry")?;
+        let path = file.path();
+        if file.file_type()?.is_dir() {
+            find_tests(&path, dst)?;
+        } else if path.extension().and_then(|s| s.to_str()) == Some("wat") {
+            dst.push(path);
+        }
+    }
+    Ok(())
+}
+
+fn run_test(path: &Path) -> Result<()> {
+    let mut test = Test::new(path)?;
+    let output = test.compile()?;
+    let isa = test.build_target_isa()?;
+
+    assert_output(&test.path, &test.contents, &*isa, test.config.test, output)?;
+
+    Ok(())
+}
+#[derive(Debug, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct TestConfig {
+    target: String,
+    #[serde(default)]
+    test: TestKind,
+    flags: Option<TestConfigFlags>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(untagged)]
+enum TestConfigFlags {
+    SpaceSeparated(String),
+    List(Vec<String>),
+}
+
+struct Test {
+    path: PathBuf,
+    contents: String,
+    opts: CommonOptions,
+    config: TestConfig,
+}
+
+/// Which kind of test is being performed.
+#[derive(Default, Debug, Deserialize)]
+#[serde(rename_all = "lowercase")]
+enum TestKind {
+    /// Test the CLIF output, raw from translation.
+    #[default]
+    Clif,
+    /// Compile output to machine code.
+    Compile,
+    /// Test the CLIF output, optimized.
+    Optimize,
+    /// Alias for "compile" plus `-C compiler=winch`
+    Winch,
+}
+
+impl Test {
+    /// Parse the contents of `path` looking for directive-based comments
+    /// starting with `;;!` near the top of the file.
+    fn new(path: &Path) -> Result<Test> {
+        let contents =
+            std::fs::read_to_string(path).with_context(|| format!("failed to read {path:?}"))?;
+        let config: TestConfig = Test::parse_test_config(&contents)
+            .context("failed to parse test configuration as TOML")?;
+        let mut flags = vec!["wasmtime"];
+        match &config.flags {
+            Some(TestConfigFlags::SpaceSeparated(s)) => flags.extend(s.split_whitespace()),
+            Some(TestConfigFlags::List(s)) => flags.extend(s.iter().map(|s| s.as_str())),
+            None => {}
+        }
+        let opts = wasmtime_cli_flags::CommonOptions::try_parse_from(&flags)?;
+
+        Ok(Test {
+            path: path.to_path_buf(),
+            config,
+            opts,
+            contents,
+        })
+    }
+
+    /// Parse test configuration from the specified test, comments starting with
+    /// `;;!`.
+    fn parse_test_config<T>(wat: &str) -> Result<T>
+    where
+        T: DeserializeOwned,
+    {
+        // The test config source is the leading lines of the WAT file that are
+        // prefixed with `;;!`.
+        let config_lines: Vec<_> = wat
+            .lines()
+            .take_while(|l| l.starts_with(";;!"))
+            .map(|l| &l[3..])
+            .collect();
+        let config_text = config_lines.join("\n");
+
+        toml::from_str(&config_text).context("failed to parse the test configuration")
+    }
+
+    /// Generates CLIF for all the wasm functions in this test.
+    fn compile(&mut self) -> Result<CompileOutput> {
+        // Use wasmtime::Config with its `emit_clif` option to get Wasmtime's
+        // code generator to jettison CLIF out the back.
+        let tempdir = TempDir::new().context("failed to make a tempdir")?;
+        let mut config = self.opts.config(Some(&self.config.target), None)?;
+        match self.config.test {
+            TestKind::Clif | TestKind::Optimize => {
+                config.emit_clif(tempdir.path());
+            }
+            TestKind::Compile => {}
+            TestKind::Winch => {
+                config.strategy(Strategy::Winch);
+            }
+        }
+        let engine = Engine::new(&config).context("failed to create engine")?;
+        let module = wat::parse_file(&self.path)?;
+        let elf = engine
+            .precompile_module(&module)
+            .context("failed to compile module")?;
+
+        match self.config.test {
+            TestKind::Clif | TestKind::Optimize => {
+                // Read all `*.clif` files from the clif directory that the
+                // compilation process just emitted.
+                let mut clifs = Vec::new();
+                for entry in tempdir
+                    .path()
+                    .read_dir()
+                    .context("failed to read tempdir")?
+                {
+                    let entry = entry.context("failed to iterate over tempdir")?;
+                    let path = entry.path();
+                    let clif = std::fs::read_to_string(&path)
+                        .with_context(|| format!("failed to read clif file {path:?}"))?;
+                    clifs.push(clif);
+                }
+
+                // Parse the text format CLIF which is emitted by Wasmtime back
+                // into in-memory data structures.
+                let mut functions = clifs
+                    .iter()
+                    .map(|clif| {
+                        let mut funcs = cranelift_reader::parse_functions(clif)?;
+                        if funcs.len() != 1 {
+                            bail!("expected one function per clif");
+                        }
+                        Ok(funcs.remove(0))
+                    })
+                    .collect::<Result<Vec<_>>>()?;
+                functions.sort_by_key(|f| match f.name {
+                    UserFuncName::User(UserExternalName { namespace, index }) => (namespace, index),
+                    UserFuncName::Testcase(_) => unreachable!(),
+                });
+                Ok(CompileOutput::Clif(functions))
+            }
+            TestKind::Compile | TestKind::Winch => Ok(CompileOutput::Elf(elf)),
+        }
+    }
+
+    /// Use the test configuration present with CLI flags to build a
+    /// `TargetIsa` to compile/optimize the CLIF.
+    fn build_target_isa(&self) -> Result<Arc<dyn TargetIsa>> {
+        let mut builder = lookup_by_name(&self.config.target)?;
+        let mut flags = cranelift_codegen::settings::builder();
+        let opt_level = match self.opts.opts.opt_level {
+            None | Some(OptLevel::Speed) => "speed",
+            Some(OptLevel::SpeedAndSize) => "speed_and_size",
+            Some(OptLevel::None) => "none",
+            _ => unreachable!(),
+        };
+        flags.set("opt_level", opt_level)?;
+        for (key, val) in self.opts.codegen.cranelift.iter() {
+            let key = &key.replace("-", "_");
+            let target_res = match val {
+                Some(val) => builder.set(key, val),
+                None => builder.enable(key),
+            };
+            match target_res {
+                Ok(()) => continue,
+                Err(SetError::BadName(_)) => {}
+                Err(e) => bail!(e),
+            }
+            match val {
+                Some(val) => flags.set(key, val)?,
+                None => flags.enable(key)?,
+            }
+        }
+        let isa = builder.finish(Flags::new(flags))?;
+        Ok(isa)
+    }
+}
+
+enum CompileOutput {
+    Clif(Vec<Function>),
+    Elf(Vec<u8>),
+}
+
+/// Assert that `wat` contains the test expectations necessary for `funcs`.
+fn assert_output(
+    path: &Path,
+    wat: &str,
+    isa: &dyn TargetIsa,
+    kind: TestKind,
+    output: CompileOutput,
+) -> Result<()> {
+    let mut actual = String::new();
+    match output {
+        CompileOutput::Clif(funcs) => {
+            for mut func in funcs {
+                match kind {
+                    TestKind::Compile | TestKind::Winch => unreachable!(),
+                    TestKind::Optimize => {
+                        let mut ctx = cranelift_codegen::Context::for_function(func.clone());
+                        ctx.optimize(isa, &mut Default::default())
+                            .map_err(|e| codegen_error_to_anyhow_error(&ctx.func, e))?;
+                        ctx.func.dfg.resolve_all_aliases();
+                        writeln!(&mut actual, "{}", ctx.func.display()).unwrap();
+                    }
+                    TestKind::Clif => {
+                        func.dfg.resolve_all_aliases();
+                        writeln!(&mut actual, "{}", func.display()).unwrap();
+                    }
+                }
+            }
+        }
+        CompileOutput::Elf(bytes) => {
+            let disas = isa.to_capstone()?;
+            disas_elf(&disas, &mut actual, &bytes)?;
+        }
+    }
+    let actual = actual.trim();
+    assert_or_bless_output(path, wat, actual)
+}
+
+fn disas_elf(disas: &capstone::Capstone, result: &mut String, elf: &[u8]) -> Result<()> {
+    use capstone::InsnGroupType::{CS_GRP_JUMP, CS_GRP_RET};
+    use object::{Endianness, Object, ObjectSection, ObjectSymbol};
+
+    let elf = object::read::elf::ElfFile64::<Endianness>::parse(elf)?;
+    let text = elf.section_by_name(".text").unwrap();
+    let text = text.data()?;
+    let mut first = true;
+    for sym in elf.symbols() {
+        let name = match sym.name() {
+            Ok(name) => name,
+            Err(_) => continue,
+        };
+        if !name.contains("wasm") || !name.contains("function") {
+            continue;
+        }
+
+        let bytes = &text[sym.address() as usize..][..sym.size() as usize];
+
+        if first {
+            first = false;
+        } else {
+            result.push_str("\n");
+        }
+        writeln!(result, "{name}:")?;
+
+        // By default don't write all the offsets of all the instructions. That
+        // means that small changes in the instruction sequence cause large
+        // diffs which aren't always the most readable. As a rough balance,
+        // print offset of instructions-after-jumps and anything-after-ret as
+        // that's a decent-enough heuristic for jump targets.
+        let mut prev_jump = false;
+        let mut write_offsets = false;
+
+        for inst in disas.disasm_all(bytes, sym.address())?.iter() {
+            let detail = disas.insn_detail(&inst).ok();
+            let detail = detail.as_ref();
+            let is_jump = detail
+                .map(|d| {
+                    d.groups()
+                        .iter()
+                        .find(|g| g.0 as u32 == CS_GRP_JUMP)
+                        .is_some()
+                })
+                .unwrap_or(false);
+
+            if write_offsets || (prev_jump && !is_jump) {
+                write!(result, "{:>4x}: ", inst.address())?;
+            } else {
+                write!(result, "      ")?;
+            }
+
+            match (inst.mnemonic(), inst.op_str()) {
+                (Some(i), Some(o)) => {
+                    if o.is_empty() {
+                        writeln!(result, "{i}")?;
+                    } else {
+                        writeln!(result, "{i:7} {o}")?;
+                    }
+                }
+                (Some(i), None) => writeln!(result, "{i}")?,
+                _ => unreachable!(),
+            }
+
+            prev_jump = is_jump;
+
+            // Flip write_offsets to true once we've seen a `ret`, as
+            // instructions that follow the return are often related to trap
+            // tables.
+            write_offsets = write_offsets
+                || detail
+                    .map(|d| {
+                        d.groups()
+                            .iter()
+                            .find(|g| g.0 as u32 == CS_GRP_RET)
+                            .is_some()
+                    })
+                    .unwrap_or(false);
+        }
+    }
+    Ok(())
+}
+
+fn assert_or_bless_output(path: &Path, wat: &str, actual: &str) -> Result<()> {
+    log::debug!("=== actual ===\n{actual}");
+    // The test's expectation is the final comment.
+    let mut expected_lines: Vec<_> = wat
+        .lines()
+        .rev()
+        .map_while(|l| l.strip_prefix(";;"))
+        .map(|l| l.strip_prefix(" ").unwrap_or(l))
+        .collect();
+    expected_lines.reverse();
+    let expected = expected_lines.join("\n");
+    let expected = expected.trim();
+    log::debug!("=== expected ===\n{expected}");
+
+    if actual == expected {
+        return Ok(());
+    }
+
+    if std::env::var("WASMTIME_TEST_BLESS").unwrap_or_default() == "1" {
+        let old_expectation_line_count = wat
+            .lines()
+            .rev()
+            .take_while(|l| l.starts_with(";;"))
+            .count();
+        let old_wat_line_count = wat.lines().count();
+        let new_wat_lines: Vec<_> = wat
+            .lines()
+            .take(old_wat_line_count - old_expectation_line_count)
+            .map(|l| l.to_string())
+            .chain(actual.lines().map(|l| {
+                if l.is_empty() {
+                    ";;".to_string()
+                } else {
+                    format!(";; {l}")
+                }
+            }))
+            .collect();
+        let mut new_wat = new_wat_lines.join("\n");
+        new_wat.push('\n');
+        std::fs::write(path, new_wat)
+            .with_context(|| format!("failed to write file: {}", path.display()))?;
+        return Ok(());
+    }
+
+    bail!(
+        "Did not get the expected CLIF translation:\n\n\
+         {}\n\n\
+         Note: You can re-run with the `WASMTIME_TEST_BLESS=1` environment\n\
+         variable set to update test expectations.",
+        TextDiff::from_lines(expected, actual)
+            .unified_diff()
+            .header("expected", "actual")
+    )
+}
+
+fn codegen_error_to_anyhow_error(
+    func: &cranelift_codegen::ir::Function,
+    err: cranelift_codegen::CodegenError,
+) -> anyhow::Error {
+    let s = cranelift_codegen::print_errors::pretty_error(func, err);
+    anyhow::anyhow!("{}", s)
+}
diff --git a/tests/disas/aarch64-relaxed-simd.wat b/tests/disas/aarch64-relaxed-simd.wat
new file mode 100644
index 000000000000..b4f036a53a15
--- /dev/null
+++ b/tests/disas/aarch64-relaxed-simd.wat
@@ -0,0 +1,87 @@
+;;! target = "aarch64"
+;;! test = "compile"
+
+(module
+  (func (param v128) (result v128)
+    local.get 0
+    i32x4.relaxed_trunc_f32x4_s
+  )
+
+  (func (param v128) (result v128)
+    local.get 0
+    i32x4.relaxed_trunc_f32x4_u
+  )
+
+  (func (param v128) (result v128)
+    local.get 0
+    i32x4.relaxed_trunc_f64x2_s_zero
+  )
+
+  (func (param v128) (result v128)
+    local.get 0
+    i32x4.relaxed_trunc_f64x2_u_zero
+  )
+
+  (func (param v128 v128) (result v128)
+    local.get 0
+    local.get 1
+    i16x8.relaxed_dot_i8x16_i7x16_s
+  )
+
+  (func (param v128 v128 v128) (result v128)
+    local.get 0
+    local.get 1
+    local.get 2
+    i32x4.relaxed_dot_i8x16_i7x16_add_s
+  )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       fcvtzs  v0.4s, v0.4s
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       fcvtzu  v0.4s, v0.4s
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[2]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       fcvtzs  v4.2d, v0.2d
+;;       sqxtn   v0.2s, v4.2d
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[3]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       fcvtzu  v4.2d, v0.2d
+;;       uqxtn   v0.2s, v4.2d
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[4]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       smull   v6.8h, v0.8b, v1.8b
+;;       smull2  v7.8h, v0.16b, v1.16b
+;;       addp    v0.8h, v6.8h, v7.8h
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[5]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       smull   v17.8h, v0.8b, v1.8b
+;;       smull2  v18.8h, v0.16b, v1.16b
+;;       addp    v17.8h, v17.8h, v18.8h
+;;       saddlp  v17.4s, v17.8h
+;;       add     v0.4s, v17.4s, v2.4s
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/arith.wat b/tests/disas/arith.wat
new file mode 100644
index 000000000000..cbb04ee8debe
--- /dev/null
+++ b/tests/disas/arith.wat
@@ -0,0 +1,43 @@
+;;! target = "x86_64"
+
+(module
+  (memory 1)
+  (func $main (local i32)
+      (local.set 0 (i32.sub (i32.const 4) (i32.const 4)))
+      (if
+          (local.get 0)
+          (then unreachable)
+          (else (drop (i32.mul (i32.const 6) (local.get 0))))
+       )
+  )
+  (start $main)
+  (data (i32.const 0) "abcdefgh")
+)
+
+;; function u0:0(i64 vmctx, i64) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @001f                               v2 = iconst.i32 0
+;; @0021                               v3 = iconst.i32 4
+;; @0023                               v4 = iconst.i32 4
+;; @0025                               v5 = isub v3, v4  ; v3 = 4, v4 = 4
+;; @002a                               brif v5, block2, block4
+;;
+;;                                 block2:
+;; @002c                               trap unreachable
+;;
+;;                                 block4:
+;; @002e                               v6 = iconst.i32 6
+;; @0032                               v7 = imul v6, v5  ; v6 = 6
+;; @0034                               jump block3
+;;
+;;                                 block3:
+;; @0035                               jump block1
+;;
+;;                                 block1:
+;; @0035                               return
+;; }
diff --git a/tests/disas/basic-wat-test.wat b/tests/disas/basic-wat-test.wat
new file mode 100644
index 000000000000..c936204d602f
--- /dev/null
+++ b/tests/disas/basic-wat-test.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+
+(module
+  (memory 0)
+  (func (param i32 i32) (result i32)
+    local.get 0
+    i32.load
+    local.get 1
+    i32.load
+    i32.add))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0021                               v5 = uextend.i64 v2
+;; @0021                               v6 = global_value.i64 gv4
+;; @0021                               v7 = iadd v6, v5
+;; @0021                               v8 = load.i32 little heap v7
+;; @0026                               v9 = uextend.i64 v3
+;; @0026                               v10 = global_value.i64 gv4
+;; @0026                               v11 = iadd v10, v9
+;; @0026                               v12 = load.i32 little heap v11
+;; @0029                               v13 = iadd v8, v12
+;; @002a                               jump block1(v13)
+;;
+;;                                 block1(v4: i32):
+;; @002a                               return v4
+;; }
diff --git a/tests/disas/br_table.wat b/tests/disas/br_table.wat
new file mode 100644
index 000000000000..3f83a93ed602
--- /dev/null
+++ b/tests/disas/br_table.wat
@@ -0,0 +1,152 @@
+;;! target = "x86_64"
+
+(module
+  (func (result i32)
+    (block (result i32)
+      (block (result i32)
+        (block (result i32)
+          (br_table 0 1 2 3 (i32.const 42) (i32.const 0))
+        )
+      )
+    )
+  )
+  (func (result i32)
+    (block (result i32)
+      (block (result i32)
+        (block (result i32)
+          (br_table 3 2 1 0 (i32.const 42) (i32.const 0))
+        )
+      )
+    )
+  )
+  (func (result i32)
+    (block (result i32)
+      (br_table 0 0 1 1 (i32.const 42) (i32.const 0))
+    )
+  )
+  (func (result i32)
+    (block (result i32)
+      (br_table 1 1 0 0 (i32.const 42) (i32.const 0))
+    )
+  )
+)
+
+;; function u0:0(i64 vmctx, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @0021                               v6 = iconst.i32 42
+;; @0023                               v7 = iconst.i32 0
+;; @0025                               br_table v7, block8, [block5, block6, block7]  ; v7 = 0
+;;
+;;                                 block5:
+;; @0025                               jump block4(v6)  ; v6 = 42
+;;
+;;                                 block6:
+;; @0025                               jump block3(v6)  ; v6 = 42
+;;
+;;                                 block7:
+;; @0025                               jump block2(v6)  ; v6 = 42
+;;
+;;                                 block8:
+;; @0025                               jump block1(v6)  ; v6 = 42
+;;
+;;                                 block4(v5: i32):
+;; @002c                               jump block3(v5)
+;;
+;;                                 block3(v4: i32):
+;; @002d                               jump block2(v4)
+;;
+;;                                 block2(v3: i32):
+;; @002e                               jump block1(v3)
+;;
+;;                                 block1(v2: i32):
+;; @002e                               return v2
+;; }
+;;
+;; function u0:1(i64 vmctx, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @0037                               v6 = iconst.i32 42
+;; @0039                               v7 = iconst.i32 0
+;; @003b                               br_table v7, block8, [block5, block6, block7]  ; v7 = 0
+;;
+;;                                 block5:
+;; @003b                               jump block1(v6)  ; v6 = 42
+;;
+;;                                 block6:
+;; @003b                               jump block2(v6)  ; v6 = 42
+;;
+;;                                 block7:
+;; @003b                               jump block3(v6)  ; v6 = 42
+;;
+;;                                 block8:
+;; @003b                               jump block4(v6)  ; v6 = 42
+;;
+;;                                 block4(v5: i32):
+;; @0042                               jump block3(v5)
+;;
+;;                                 block3(v4: i32):
+;; @0043                               jump block2(v4)
+;;
+;;                                 block2(v3: i32):
+;; @0044                               jump block1(v3)
+;;
+;;                                 block1(v2: i32):
+;; @0044                               return v2
+;; }
+;;
+;; function u0:2(i64 vmctx, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @0049                               v4 = iconst.i32 42
+;; @004b                               v5 = iconst.i32 0
+;; @004d                               br_table v5, block4, [block3, block3, block4]  ; v5 = 0
+;;
+;;                                 block3:
+;; @004d                               jump block2(v4)  ; v4 = 42
+;;
+;;                                 block4:
+;; @004d                               jump block1(v4)  ; v4 = 42
+;;
+;;                                 block2(v3: i32):
+;; @0054                               jump block1(v3)
+;;
+;;                                 block1(v2: i32):
+;; @0054                               return v2
+;; }
+;;
+;; function u0:3(i64 vmctx, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @0059                               v4 = iconst.i32 42
+;; @005b                               v5 = iconst.i32 0
+;; @005d                               br_table v5, block4, [block3, block3, block4]  ; v5 = 0
+;;
+;;                                 block3:
+;; @005d                               jump block1(v4)  ; v4 = 42
+;;
+;;                                 block4:
+;; @005d                               jump block2(v4)  ; v4 = 42
+;;
+;;                                 block2(v3: i32):
+;; @0064                               jump block1(v3)
+;;
+;;                                 block1(v2: i32):
+;; @0064                               return v2
+;; }
diff --git a/tests/disas/byteswap.wat b/tests/disas/byteswap.wat
new file mode 100644
index 000000000000..0a837e088b17
--- /dev/null
+++ b/tests/disas/byteswap.wat
@@ -0,0 +1,100 @@
+;;! target = "x86_64"
+;;! test = "optimize"
+
+(module
+  (func (export "bswap32") (param i32) (result i32)
+    local.get 0
+    i32.const 24
+    i32.shl
+    local.get 0
+    i32.const 65280
+    i32.and
+    i32.const 8
+    i32.shl
+    i32.or
+    local.get 0
+    i32.const 8
+    i32.shr_u
+    i32.const 65280
+    i32.and
+    local.get 0
+    i32.const 24
+    i32.shr_u
+    i32.or
+    i32.or
+  )
+
+  (func (export "bswap64") (param i64) (result i64)
+    local.get 0
+    i64.const 56
+    i64.shl
+    local.get 0
+    i64.const 65280
+    i64.and
+    i64.const 40
+    i64.shl
+    i64.or
+    local.get 0
+    i64.const 16711680
+    i64.and
+    i64.const 24
+    i64.shl
+    local.get 0
+    i64.const 4278190080
+    i64.and
+    i64.const 8
+    i64.shl
+    i64.or
+    i64.or
+    local.get 0
+    i64.const 8
+    i64.shr_u
+    i64.const 4278190080
+    i64.and
+    local.get 0
+    i64.const 24
+    i64.shr_u
+    i64.const 16711680
+    i64.and
+    i64.or
+    local.get 0
+    i64.const 40
+    i64.shr_u
+    i64.const 65280
+    i64.and
+    local.get 0
+    i64.const 56
+    i64.shr_u
+    i64.or
+    i64.or
+    i64.or
+  )
+)
+
+;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0057                               jump block1
+;;
+;;                                 block1:
+;;                                     v19 = bswap.i32 v2
+;; @0057                               return v19
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i64 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @00ad                               jump block1
+;;
+;;                                 block1:
+;;                                     v39 = bswap.i64 v2
+;; @00ad                               return v39
+;; }
diff --git a/tests/disas/call-simd.wat b/tests/disas/call-simd.wat
new file mode 100644
index 000000000000..1631291581c2
--- /dev/null
+++ b/tests/disas/call-simd.wat
@@ -0,0 +1,52 @@
+;;! target = "x86_64"
+
+(module
+  (func $main
+    (v128.const i32x4 1 2 3 4)
+    (v128.const i32x4 1 2 3 4)
+    (call $add)
+    drop
+  )
+  (func $add (param $a v128) (param $b v128) (result v128)
+    (local.get $a)
+    (local.get $b)
+    (i32x4.add)
+  )
+  (start $main)
+)
+
+;; function u0:0(i64 vmctx, i64) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     sig0 = (i64 vmctx, i64, i8x16, i8x16) -> i8x16 tail
+;;     fn0 = colocated u0:1 sig0
+;;     const0 = 0x00000004000000030000000200000001
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @0021                               v2 = vconst.i8x16 const0
+;; @0033                               v3 = vconst.i8x16 const0
+;; @0045                               v4 = call fn0(v0, v0, v2, v3)  ; v2 = const0, v3 = const0
+;; @0048                               jump block1
+;;
+;;                                 block1:
+;; @0048                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i8x16, i8x16) -> i8x16 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16, v3: i8x16):
+;; @004f                               v5 = bitcast.i32x4 little v2
+;; @004f                               v6 = bitcast.i32x4 little v3
+;; @004f                               v7 = iadd v5, v6
+;; @0052                               v8 = bitcast.i8x16 little v7
+;; @0052                               jump block1(v8)
+;;
+;;                                 block1(v4: i8x16):
+;; @0052                               return v4
+;; }
diff --git a/tests/disas/call.wat b/tests/disas/call.wat
new file mode 100644
index 000000000000..cf62b7a7a6ae
--- /dev/null
+++ b/tests/disas/call.wat
@@ -0,0 +1,44 @@
+;;! target = "x86_64"
+
+(module
+  (func $main (local i32)
+    (local.set 0 (i32.const 0))
+    (drop (call $inc))
+  )
+  (func $inc (result i32)
+    (i32.const 1)
+  )
+  (start $main)
+)
+
+;; function u0:0(i64 vmctx, i64) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     sig0 = (i64 vmctx, i64) -> i32 tail
+;;     fn0 = colocated u0:1 sig0
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @001f                               v2 = iconst.i32 0
+;; @0021                               v3 = iconst.i32 0
+;; @0025                               v4 = call fn0(v0, v0)
+;; @0028                               jump block1
+;;
+;;                                 block1:
+;; @0028                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @002b                               v3 = iconst.i32 1
+;; @002d                               jump block1(v3)  ; v3 = 1
+;;
+;;                                 block1(v2: i32):
+;; @002d                               return v2
+;; }
diff --git a/tests/disas/dead-code.wat b/tests/disas/dead-code.wat
new file mode 100644
index 000000000000..64f468204941
--- /dev/null
+++ b/tests/disas/dead-code.wat
@@ -0,0 +1,84 @@
+;;! target = "x86_64"
+
+(module
+  (func (param i32)
+    (loop
+      (block
+        local.get 0
+        br_if 0
+        br 1)))
+
+  (func (param i32)
+    (loop
+      (block
+        br 1
+        call $empty)))
+
+  (func $empty)
+
+  (func (param i32) (result i32)
+    i32.const 1
+    return
+    i32.const 42)
+)
+;; function u0:0(i64 vmctx, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0023                               jump block2
+;;
+;;                                 block2:
+;; @0029                               brif.i32 v2, block4, block5
+;;
+;;                                 block5:
+;; @002b                               jump block2
+;;
+;;                                 block4:
+;; @002e                               jump block3
+;;
+;;                                 block3:
+;; @002f                               jump block1
+;;
+;;                                 block1:
+;; @002f                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0032                               jump block2
+;;
+;;                                 block2:
+;; @0036                               jump block2
+;; }
+;;
+;; function u0:2(i64 vmctx, i64) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @003f                               jump block1
+;;
+;;                                 block1:
+;; @003f                               return
+;; }
+;;
+;; function u0:3(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0042                               v4 = iconst.i32 1
+;; @0044                               return v4  ; v4 = 1
+;; }
diff --git a/tests/disas/duplicate-loads-dynamic-memory.wat b/tests/disas/duplicate-loads-dynamic-memory.wat
new file mode 100644
index 000000000000..ed1bd8e3c010
--- /dev/null
+++ b/tests/disas/duplicate-loads-dynamic-memory.wat
@@ -0,0 +1,73 @@
+;;! target = "x86_64"
+;;! test = "optimize"
+;;! flags = [
+;;!   "-Ccranelift-enable-heap-access-spectre-mitigation",
+;;!   "-Oopt-level=s",
+;;!   "-Ostatic-memory-maximum-size=0",
+;;! ]
+
+(module
+  (memory (export "memory") 0)
+  (func (export "load-without-offset") (param i32) (result i32 i32)
+    local.get 0
+    i32.load
+    local.get 0
+    i32.load
+  )
+  (func (export "load-with-offset") (param i32) (result i32 i32)
+    local.get 0
+    i32.load offset=1234
+    local.get 0
+    i32.load offset=1234
+  )
+)
+
+;; function u0:0(i64 vmctx, i64, i32) -> i32, i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0057                               v6 = load.i64 notrap aligned v0+104
+;; @0057                               v8 = load.i64 notrap aligned checked v0+96
+;; @0057                               v5 = uextend.i64 v2
+;; @0057                               v7 = icmp ugt v5, v6
+;; @0057                               v10 = iconst.i64 0
+;; @0057                               v9 = iadd v8, v5
+;; @0057                               v11 = select_spectre_guard v7, v10, v9  ; v10 = 0
+;; @0057                               v12 = load.i32 little heap v11
+;; @005f                               jump block1
+;;
+;;                                 block1:
+;; @005f                               return v12, v12
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32, i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0064                               v6 = load.i64 notrap aligned v0+104
+;; @0064                               v8 = load.i64 notrap aligned checked v0+96
+;; @0064                               v5 = uextend.i64 v2
+;; @0064                               v7 = icmp ugt v5, v6
+;; @0064                               v12 = iconst.i64 0
+;; @0064                               v9 = iadd v8, v5
+;; @0064                               v10 = iconst.i64 1234
+;; @0064                               v11 = iadd v9, v10  ; v10 = 1234
+;; @0064                               v13 = select_spectre_guard v7, v12, v11  ; v12 = 0
+;; @0064                               v14 = load.i32 little heap v13
+;; @006e                               jump block1
+;;
+;;                                 block1:
+;; @006e                               return v14, v14
+;; }
diff --git a/tests/disas/duplicate-loads-static-memory.wat b/tests/disas/duplicate-loads-static-memory.wat
new file mode 100644
index 000000000000..1857c02e5840
--- /dev/null
+++ b/tests/disas/duplicate-loads-static-memory.wat
@@ -0,0 +1,58 @@
+;;! target = "x86_64"
+;;! test = "optimize"
+
+(module
+  (memory (export "memory") 1)
+  (func (export "load-without-offset") (param i32) (result i32 i32)
+    local.get 0
+    i32.load
+    local.get 0
+    i32.load
+  )
+  (func (export "load-with-offset") (param i32) (result i32 i32)
+    local.get 0
+    i32.load offset=1234
+    local.get 0
+    i32.load offset=1234
+  )
+)
+
+;; function u0:0(i64 vmctx, i64, i32) -> i32, i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0057                               v6 = load.i64 notrap aligned readonly checked v0+96
+;; @0057                               v5 = uextend.i64 v2
+;; @0057                               v7 = iadd v6, v5
+;; @0057                               v8 = load.i32 little heap v7
+;; @005f                               jump block1
+;;
+;;                                 block1:
+;; @005f                               return v8, v8
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32, i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0064                               v6 = load.i64 notrap aligned readonly checked v0+96
+;; @0064                               v5 = uextend.i64 v2
+;; @0064                               v7 = iadd v6, v5
+;; @0064                               v8 = iconst.i64 1234
+;; @0064                               v9 = iadd v7, v8  ; v8 = 1234
+;; @0064                               v10 = load.i32 little heap v9
+;; @006e                               jump block1
+;;
+;;                                 block1:
+;; @006e                               return v10, v10
+;; }
diff --git a/tests/disas/dynamic-memory-no-spectre-access-same-index-different-offsets.wat b/tests/disas/dynamic-memory-no-spectre-access-same-index-different-offsets.wat
new file mode 100644
index 000000000000..e555465c81de
--- /dev/null
+++ b/tests/disas/dynamic-memory-no-spectre-access-same-index-different-offsets.wat
@@ -0,0 +1,138 @@
+;;! target = "x86_64"
+;;! test = "optimize"
+;;! flags = [
+;;!   "-Ccranelift-enable-heap-access-spectre-mitigation=false",
+;;!   "-Ostatic-memory-maximum-size=0",
+;;!   "-Odynamic-memory-guard-size=0xffff",
+;;! ]
+
+(module
+  (memory (export "memory") 0)
+
+  (func (export "loads") (param i32) (result i32 i32 i32)
+    ;; Within the guard region.
+    local.get 0
+    i32.load offset=0
+    ;; Also within the guard region, bounds check should GVN with previous.
+    local.get 0
+    i32.load offset=4
+    ;; Outside the guard region, needs additional bounds checks.
+    local.get 0
+    i32.load offset=0x000fffff
+  )
+
+  ;; Same as above, but for stores.
+  (func (export "stores") (param i32 i32 i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0
+    local.get 0
+    local.get 2
+    i32.store offset=4
+    local.get 0
+    local.get 3
+    i32.store offset=0x000fffff
+  )
+)
+
+;; function u0:0(i64 vmctx, i64, i32) -> i32, i32, i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0047                               v7 = load.i64 notrap aligned v0+104
+;; @0047                               v6 = uextend.i64 v2
+;; @0047                               v8 = icmp ugt v6, v7
+;; @0047                               brif v8, block2, block3
+;;
+;;                                 block2 cold:
+;; @0047                               trap heap_oob
+;;
+;;                                 block3:
+;; @0047                               v9 = load.i64 notrap aligned checked v0+96
+;; @0047                               v10 = iadd v9, v6
+;; @0047                               v11 = load.i32 little heap v10
+;; @004c                               brif.i8 v8, block4, block5
+;;
+;;                                 block4 cold:
+;; @004c                               trap heap_oob
+;;
+;;                                 block5:
+;; @004c                               v17 = iconst.i64 4
+;; @004c                               v18 = iadd.i64 v10, v17  ; v17 = 4
+;; @004c                               v19 = load.i32 little heap v18
+;; @0051                               v21 = iconst.i64 0x0010_0003
+;; @0051                               v22 = uadd_overflow_trap.i64 v6, v21, heap_oob  ; v21 = 0x0010_0003
+;; @0051                               v24 = icmp ugt v22, v7
+;; @0051                               brif v24, block6, block7
+;;
+;;                                 block6 cold:
+;; @0051                               trap heap_oob
+;;
+;;                                 block7:
+;; @0051                               v25 = load.i64 notrap aligned checked v0+96
+;; @0051                               v26 = iadd v25, v6
+;; @0051                               v27 = iconst.i64 0x000f_ffff
+;; @0051                               v28 = iadd v26, v27  ; v27 = 0x000f_ffff
+;; @0051                               v29 = load.i32 little heap v28
+;; @0056                               jump block1
+;;
+;;                                 block1:
+;; @0056                               return v11, v19, v29
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32, i32, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
+;; @005d                               v7 = load.i64 notrap aligned v0+104
+;; @005d                               v6 = uextend.i64 v2
+;; @005d                               v8 = icmp ugt v6, v7
+;; @005d                               brif v8, block2, block3
+;;
+;;                                 block2 cold:
+;; @005d                               trap heap_oob
+;;
+;;                                 block3:
+;; @005d                               v9 = load.i64 notrap aligned checked v0+96
+;; @005d                               v10 = iadd v9, v6
+;; @005d                               store.i32 little heap v3, v10
+;; @0064                               brif.i8 v8, block4, block5
+;;
+;;                                 block4 cold:
+;; @0064                               trap heap_oob
+;;
+;;                                 block5:
+;; @0064                               v16 = iconst.i64 4
+;; @0064                               v17 = iadd.i64 v10, v16  ; v16 = 4
+;; @0064                               store.i32 little heap v4, v17
+;; @006b                               v19 = iconst.i64 0x0010_0003
+;; @006b                               v20 = uadd_overflow_trap.i64 v6, v19, heap_oob  ; v19 = 0x0010_0003
+;; @006b                               v22 = icmp ugt v20, v7
+;; @006b                               brif v22, block6, block7
+;;
+;;                                 block6 cold:
+;; @006b                               trap heap_oob
+;;
+;;                                 block7:
+;; @006b                               v23 = load.i64 notrap aligned checked v0+96
+;; @006b                               v24 = iadd v23, v6
+;; @006b                               v25 = iconst.i64 0x000f_ffff
+;; @006b                               v26 = iadd v24, v25  ; v25 = 0x000f_ffff
+;; @006b                               store.i32 little heap v5, v26
+;; @0070                               jump block1
+;;
+;;                                 block1:
+;; @0070                               return
+;; }
diff --git a/tests/disas/dynamic-memory-yes-spectre-access-same-index-different-offsets.wat b/tests/disas/dynamic-memory-yes-spectre-access-same-index-different-offsets.wat
new file mode 100644
index 000000000000..4763eaf3dfe5
--- /dev/null
+++ b/tests/disas/dynamic-memory-yes-spectre-access-same-index-different-offsets.wat
@@ -0,0 +1,102 @@
+;;! target = "x86_64"
+;;! test = "optimize"
+;;! flags = "-O static-memory-maximum-size=0 -O dynamic-memory-guard-size=0xffff"
+
+(module
+  (memory (export "memory") 0)
+
+  (func (export "loads") (param i32) (result i32 i32 i32)
+    ;; Within the guard region.
+    local.get 0
+    i32.load offset=0
+    ;; Also within the guard region, bounds check should GVN with previous.
+    local.get 0
+    i32.load offset=4
+    ;; Outside the guard region, needs additional bounds checks.
+    local.get 0
+    i32.load offset=0x000fffff
+  )
+
+  ;; Same as above, but for stores.
+  (func (export "stores") (param i32 i32 i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0
+    local.get 0
+    local.get 2
+    i32.store offset=4
+    local.get 0
+    local.get 3
+    i32.store offset=0x000fffff
+  )
+)
+
+;; function u0:0(i64 vmctx, i64, i32) -> i32, i32, i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0047                               v7 = load.i64 notrap aligned v0+104
+;; @0047                               v9 = load.i64 notrap aligned checked v0+96
+;; @0047                               v6 = uextend.i64 v2
+;; @0047                               v8 = icmp ugt v6, v7
+;; @0047                               v11 = iconst.i64 0
+;; @0047                               v10 = iadd v9, v6
+;; @0047                               v12 = select_spectre_guard v8, v11, v10  ; v11 = 0
+;; @0047                               v13 = load.i32 little heap v12
+;; @004c                               v19 = iconst.i64 4
+;; @004c                               v20 = iadd v10, v19  ; v19 = 4
+;; @004c                               v22 = select_spectre_guard v8, v11, v20  ; v11 = 0
+;; @004c                               v23 = load.i32 little heap v22
+;; @0051                               v25 = iconst.i64 0x0010_0003
+;; @0051                               v26 = uadd_overflow_trap v6, v25, heap_oob  ; v25 = 0x0010_0003
+;; @0051                               v28 = icmp ugt v26, v7
+;; @0051                               v31 = iconst.i64 0x000f_ffff
+;; @0051                               v32 = iadd v10, v31  ; v31 = 0x000f_ffff
+;; @0051                               v34 = select_spectre_guard v28, v11, v32  ; v11 = 0
+;; @0051                               v35 = load.i32 little heap v34
+;; @0056                               jump block1
+;;
+;;                                 block1:
+;; @0056                               return v13, v23, v35
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32, i32, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
+;; @005d                               v7 = load.i64 notrap aligned v0+104
+;; @005d                               v9 = load.i64 notrap aligned checked v0+96
+;; @005d                               v6 = uextend.i64 v2
+;; @005d                               v8 = icmp ugt v6, v7
+;; @005d                               v11 = iconst.i64 0
+;; @005d                               v10 = iadd v9, v6
+;; @005d                               v12 = select_spectre_guard v8, v11, v10  ; v11 = 0
+;; @005d                               store little heap v3, v12
+;; @0064                               v18 = iconst.i64 4
+;; @0064                               v19 = iadd v10, v18  ; v18 = 4
+;; @0064                               v21 = select_spectre_guard v8, v11, v19  ; v11 = 0
+;; @0064                               store little heap v4, v21
+;; @006b                               v23 = iconst.i64 0x0010_0003
+;; @006b                               v24 = uadd_overflow_trap v6, v23, heap_oob  ; v23 = 0x0010_0003
+;; @006b                               v26 = icmp ugt v24, v7
+;; @006b                               v29 = iconst.i64 0x000f_ffff
+;; @006b                               v30 = iadd v10, v29  ; v29 = 0x000f_ffff
+;; @006b                               v32 = select_spectre_guard v26, v11, v30  ; v11 = 0
+;; @006b                               store little heap v5, v32
+;; @0070                               jump block1
+;;
+;;                                 block1:
+;; @0070                               return
+;; }
diff --git a/tests/disas/epoch-interruption-x86.wat b/tests/disas/epoch-interruption-x86.wat
new file mode 100644
index 000000000000..b4f4719083c9
--- /dev/null
+++ b/tests/disas/epoch-interruption-x86.wat
@@ -0,0 +1,39 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = ["-Wepoch-interruption=y"]
+
+(module (func (loop (br 0))))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r10
+;;       movq    (%r10), %r10
+;;       addq    $0x30, %r10
+;;       cmpq    %rsp, %r10
+;;       ja      0x7f
+;;   18: subq    $0x20, %rsp
+;;       movq    %rbx, (%rsp)
+;;       movq    %r12, 8(%rsp)
+;;       movq    %r13, 0x10(%rsp)
+;;       movq    8(%rdi), %r12
+;;       movq    0x20(%rdi), %rbx
+;;       movq    %rdi, %r13
+;;       movq    (%rbx), %r9
+;;       movq    0x10(%r12), %rax
+;;       cmpq    %rax, %r9
+;;       jae     0x57
+;;   46: movq    (%rbx), %rdi
+;;       cmpq    %rax, %rdi
+;;       jae     0x64
+;;       jmp     0x46
+;;   57: movq    %r13, %rdi
+;;       callq   0xdf
+;;       jmp     0x46
+;;   64: movq    0x10(%r12), %rax
+;;       cmpq    %rax, %rdi
+;;       jb      0x46
+;;   72: movq    %r13, %rdi
+;;       callq   0xdf
+;;       jmp     0x46
+;;   7f: ud2
diff --git a/tests/disas/epoch-interruption.wat b/tests/disas/epoch-interruption.wat
new file mode 100644
index 000000000000..c11016ee7510
--- /dev/null
+++ b/tests/disas/epoch-interruption.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "optimize"
+;;! flags = ["-Wepoch-interruption=y"]
+
+(module (func (loop (br 0))))
+
+;; function u0:0(i64 vmctx, i64) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     sig0 = (i64 vmctx) -> i64 system_v
+;;     fn0 = colocated u1:16 sig0
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @0016                               v3 = load.i64 notrap aligned v0+8
+;; @0016                               v5 = load.i64 notrap aligned v0+32
+;; @0016                               v6 = load.i64 notrap aligned v5
+;; @0016                               v7 = load.i64 notrap aligned v3+16
+;; @0016                               v8 = icmp uge v6, v7
+;; @0016                               brif v8, block3, block2(v7)
+;;
+;;                                 block3 cold:
+;; @0016                               v10 = call fn0(v0)
+;; @0016                               jump block2(v10)
+;;
+;;                                 block2(v21: i64):
+;; @0017                               jump block4(v21)
+;;
+;;                                 block4(v13: i64):
+;; @0017                               v12 = load.i64 notrap aligned v5
+;; @0017                               v14 = icmp uge v12, v13
+;; @0017                               brif v14, block7, block6(v13)
+;;
+;;                                 block7 cold:
+;; @0017                               v15 = load.i64 notrap aligned v3+16
+;; @0017                               v16 = icmp.i64 uge v12, v15
+;; @0017                               brif v16, block8, block6(v15)
+;;
+;;                                 block8 cold:
+;; @0017                               v18 = call fn0(v0)
+;; @0017                               jump block6(v18)
+;;
+;;                                 block6(v22: i64):
+;; @0019                               jump block4(v22)
+;; }
diff --git a/tests/disas/f32-load.wat b/tests/disas/f32-load.wat
new file mode 100644
index 000000000000..961ab900f090
--- /dev/null
+++ b/tests/disas/f32-load.wat
@@ -0,0 +1,26 @@
+;;! target = "x86_64"
+
+(module
+  (memory 1)
+  (func (export "f32.load") (param i32) (result f32)
+    local.get 0
+    f32.load))
+
+;; function u0:0(i64 vmctx, i64, i32) -> f32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @002e                               v4 = uextend.i64 v2
+;; @002e                               v5 = global_value.i64 gv4
+;; @002e                               v6 = iadd v5, v4
+;; @002e                               v7 = load.f32 little heap v6
+;; @0031                               jump block1(v7)
+;;
+;;                                 block1(v3: f32):
+;; @0031                               return v3
+;; }
diff --git a/tests/disas/f32-store.wat b/tests/disas/f32-store.wat
new file mode 100644
index 000000000000..8a7d8ad5db00
--- /dev/null
+++ b/tests/disas/f32-store.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+
+;; Test basic code generation for f32 memory WebAssembly instructions.
+
+(module
+  (memory 1)
+  (func (export "f32.store") (param i32 f32)
+    local.get 0
+    local.get 1
+    f32.store))
+
+;; function u0:0(i64 vmctx, i64, i32, f32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: f32):
+;; @0031                               v4 = uextend.i64 v2
+;; @0031                               v5 = global_value.i64 gv4
+;; @0031                               v6 = iadd v5, v4
+;; @0031                               store little heap v3, v6
+;; @0034                               jump block1
+;;
+;;                                 block1:
+;; @0034                               return
+;; }
diff --git a/tests/disas/f64-load.wat b/tests/disas/f64-load.wat
new file mode 100644
index 000000000000..e4de181c7514
--- /dev/null
+++ b/tests/disas/f64-load.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+
+;; Test basic code generation for f64 memory WebAssembly instructions.
+
+(module
+  (memory 1)
+  (func (export "f64.load") (param i32) (result f64)
+    local.get 0
+    f64.load))
+
+;; function u0:0(i64 vmctx, i64, i32) -> f64 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @002e                               v4 = uextend.i64 v2
+;; @002e                               v5 = global_value.i64 gv4
+;; @002e                               v6 = iadd v5, v4
+;; @002e                               v7 = load.f64 little heap v6
+;; @0031                               jump block1(v7)
+;;
+;;                                 block1(v3: f64):
+;; @0031                               return v3
+;; }
diff --git a/tests/disas/f64-store.wat b/tests/disas/f64-store.wat
new file mode 100644
index 000000000000..d6f8b1abfef8
--- /dev/null
+++ b/tests/disas/f64-store.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+
+;; Test basic code generation for f64 memory WebAssembly instructions.
+
+(module
+  (memory 1)
+  (func (export "f64.store") (param i32 f64)
+    local.get 0
+    local.get 1
+    f64.store))
+
+;; function u0:0(i64 vmctx, i64, i32, f64) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: f64):
+;; @0031                               v4 = uextend.i64 v2
+;; @0031                               v5 = global_value.i64 gv4
+;; @0031                               v6 = iadd v5, v4
+;; @0031                               store little heap v3, v6
+;; @0034                               jump block1
+;;
+;;                                 block1:
+;; @0034                               return
+;; }
diff --git a/tests/disas/fac-multi-value.wat b/tests/disas/fac-multi-value.wat
new file mode 100644
index 000000000000..d39353d8fae1
--- /dev/null
+++ b/tests/disas/fac-multi-value.wat
@@ -0,0 +1,78 @@
+;;! target = "x86_64"
+
+(module
+  ;; Iterative factorial without locals.
+  (func $pick0 (param i64) (result i64 i64)
+    (local.get 0) (local.get 0)
+  )
+  (func $pick1 (param i64 i64) (result i64 i64 i64)
+    (local.get 0) (local.get 1) (local.get 0)
+  )
+  (func (export "fac-ssa") (param i64) (result i64)
+    (i64.const 1) (local.get 0)
+    (loop $l (param i64 i64) (result i64)
+      (call $pick1) (call $pick1) (i64.mul)
+      (call $pick1) (i64.const 1) (i64.sub)
+      (call $pick0) (i64.const 0) (i64.gt_u)
+      (br_if $l)
+      (drop) (return)
+    )
+  )
+)
+
+;; function u0:0(i64 vmctx, i64, i64) -> i64, i64 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0040                               jump block1(v2, v2)
+;;
+;;                                 block1(v3: i64, v4: i64):
+;; @0040                               return v3, v4
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64, i64) -> i64, i64, i64 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i64):
+;; @0049                               jump block1(v2, v3, v2)
+;;
+;;                                 block1(v4: i64, v5: i64, v6: i64):
+;; @0049                               return v4, v5, v6
+;; }
+;;
+;; function u0:2(i64 vmctx, i64, i64) -> i64 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     sig0 = (i64 vmctx, i64, i64, i64) -> i64, i64, i64 tail
+;;     sig1 = (i64 vmctx, i64, i64) -> i64, i64 tail
+;;     fn0 = colocated u0:1 sig0
+;;     fn1 = colocated u0:0 sig1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @004c                               v4 = iconst.i64 1
+;; @0050                               jump block2(v4, v2)  ; v4 = 1
+;;
+;;                                 block2(v5: i64, v6: i64):
+;; @0052                               v8, v9, v10 = call fn0(v0, v0, v5, v6)
+;; @0054                               v11, v12, v13 = call fn0(v0, v0, v9, v10)
+;; @0056                               v14 = imul v12, v13
+;; @0057                               v15, v16, v17 = call fn0(v0, v0, v11, v14)
+;; @0059                               v18 = iconst.i64 1
+;; @005b                               v19 = isub v17, v18  ; v18 = 1
+;; @005c                               v20, v21 = call fn1(v0, v0, v19)
+;; @005e                               v22 = iconst.i64 0
+;; @0060                               v23 = icmp ugt v21, v22  ; v22 = 0
+;; @0060                               v24 = uextend.i32 v23
+;; @0061                               brif v24, block2(v16, v20), block4
+;;
+;;                                 block4:
+;; @0064                               return v16
+;; }
diff --git a/tests/disas/fibonacci.wat b/tests/disas/fibonacci.wat
new file mode 100644
index 000000000000..2cad836c8cac
--- /dev/null
+++ b/tests/disas/fibonacci.wat
@@ -0,0 +1,64 @@
+;;! target = "x86_64"
+
+(module
+  (memory 1)
+  (func $main (local i32 i32 i32 i32)
+    (local.set 0 (i32.const 0))
+    (local.set 1 (i32.const 1))
+    (local.set 2 (i32.const 1))
+    (local.set 3 (i32.const 0))
+    (block
+    (loop
+        (br_if 1 (i32.gt_s (local.get 0) (i32.const 5)))
+        (local.set 3 (local.get 2))
+        (local.set 2 (i32.add (local.get 2) (local.get 1)))
+        (local.set 1 (local.get 3))
+        (local.set 0 (i32.add (local.get 0) (i32.const 1)))
+        (br 0)
+    )
+    )
+    (i32.store (i32.const 0) (local.get 2))
+  )
+  (start $main)
+  (data (i32.const 0) "0000")
+)
+
+;; function u0:0(i64 vmctx, i64) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @001f                               v2 = iconst.i32 0
+;; @0021                               v3 = iconst.i32 0
+;; @0025                               v4 = iconst.i32 1
+;; @0029                               v5 = iconst.i32 1
+;; @002d                               v6 = iconst.i32 0
+;; @0033                               jump block3(v3, v5, v4)  ; v3 = 0, v5 = 1, v4 = 1
+;;
+;;                                 block3(v7: i32, v11: i32, v12: i32):
+;; @0037                               v8 = iconst.i32 5
+;; @0039                               v9 = icmp sgt v7, v8  ; v8 = 5
+;; @0039                               v10 = uextend.i32 v9
+;; @003a                               brif v10, block2, block5
+;;
+;;                                 block5:
+;; @0044                               v13 = iadd.i32 v11, v12
+;; @004d                               v14 = iconst.i32 1
+;; @004f                               v15 = iadd.i32 v7, v14  ; v14 = 1
+;; @0052                               jump block3(v15, v13, v11)
+;;
+;;                                 block2:
+;; @0056                               v16 = iconst.i32 0
+;; @005a                               v17 = uextend.i64 v16  ; v16 = 0
+;; @005a                               v18 = global_value.i64 gv4
+;; @005a                               v19 = iadd v18, v17
+;; @005a                               store.i32 little heap v11, v19
+;; @005d                               jump block1
+;;
+;;                                 block1:
+;; @005d                               return
+;; }
diff --git a/tests/disas/fixed-size-memory.wat b/tests/disas/fixed-size-memory.wat
new file mode 100644
index 000000000000..64f0c8802a41
--- /dev/null
+++ b/tests/disas/fixed-size-memory.wat
@@ -0,0 +1,67 @@
+;;! target = "x86_64"
+;;! flags = [
+;;!   "-Ccranelift-enable-heap-access-spectre-mitigation=false",
+;;!   "-Ostatic-memory-maximum-size=0",
+;;!   "-Odynamic-memory-guard-size=0",
+;;! ]
+
+;; Test that dynamic memories with `min_size == max_size` don't actually load
+;; their dynamic memory bound, since it is a constant.
+
+(module
+  (memory 1 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0041                               v4 = uextend.i64 v2
+;; @0041                               v5 = iconst.i64 0x0001_0000
+;; @0041                               v6 = icmp uge v4, v5  ; v5 = 0x0001_0000
+;; @0041                               trapnz v6, heap_oob
+;; @0041                               v7 = global_value.i64 gv5
+;; @0041                               v8 = iadd v7, v4
+;; @0041                               istore8 little heap v3, v8
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0049                               v4 = uextend.i64 v2
+;; @0049                               v5 = iconst.i64 0x0001_0000
+;; @0049                               v6 = icmp uge v4, v5  ; v5 = 0x0001_0000
+;; @0049                               trapnz v6, heap_oob
+;; @0049                               v7 = global_value.i64 gv5
+;; @0049                               v8 = iadd v7, v4
+;; @0049                               v9 = uload8.i32 little heap v8
+;; @004c                               jump block1(v9)
+;;
+;;                                 block1(v3: i32):
+;; @004c                               return v3
+;; }
diff --git a/tests/disas/globals.wat b/tests/disas/globals.wat
new file mode 100644
index 000000000000..ebcd13d1f9fc
--- /dev/null
+++ b/tests/disas/globals.wat
@@ -0,0 +1,33 @@
+;;! target = "x86_64"
+
+(module
+  (global $x (mut i32) (i32.const 4))
+  (memory 1)
+  (func $main (local i32)
+    (i32.store (i32.const 0) (global.get $x))
+  )
+  (start $main)
+)
+
+;; function u0:0(i64 vmctx, i64) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @0027                               v2 = iconst.i32 0
+;; @0029                               v3 = iconst.i32 0
+;; @002b                               v4 = global_value.i64 gv3
+;; @002b                               v5 = load.i32 notrap aligned table v4+112
+;; @002d                               v6 = uextend.i64 v3  ; v3 = 0
+;; @002d                               v7 = global_value.i64 gv4
+;; @002d                               v8 = iadd v7, v6
+;; @002d                               store little heap v5, v8
+;; @0030                               jump block1
+;;
+;;                                 block1:
+;; @0030                               return
+;; }
diff --git a/tests/disas/i128-cmp.wat b/tests/disas/i128-cmp.wat
new file mode 100644
index 000000000000..4bfafc56e3a3
--- /dev/null
+++ b/tests/disas/i128-cmp.wat
@@ -0,0 +1,236 @@
+;;! target = "x86_64"
+;;! test = "optimize"
+
+(module
+  (func $lt_s (param i64 i64 i64 i64) (result i32)
+    local.get 0
+    local.get 2
+    i64.lt_u
+    local.get 1
+    local.get 3
+    i64.lt_s
+    local.get 1
+    local.get 3
+    i64.eq
+    select
+  )
+  (func $lt_u (param i64 i64 i64 i64) (result i32)
+    local.get 0
+    local.get 2
+    i64.lt_u
+    local.get 1
+    local.get 3
+    i64.lt_u
+    local.get 1
+    local.get 3
+    i64.eq
+    select
+  )
+  (func $le_s (param i64 i64 i64 i64) (result i32)
+    local.get 0
+    local.get 2
+    i64.le_u
+    local.get 1
+    local.get 3
+    i64.le_s
+    local.get 1
+    local.get 3
+    i64.eq
+    select
+  )
+  (func $le_u (param i64 i64 i64 i64) (result i32)
+    local.get 0
+    local.get 2
+    i64.le_u
+    local.get 1
+    local.get 3
+    i64.le_u
+    local.get 1
+    local.get 3
+    i64.eq
+    select
+  )
+  (func $gt_s (param i64 i64 i64 i64) (result i32)
+    local.get 0
+    local.get 2
+    i64.gt_u
+    local.get 1
+    local.get 3
+    i64.gt_s
+    local.get 1
+    local.get 3
+    i64.eq
+    select
+  )
+  (func $gt_u (param i64 i64 i64 i64) (result i32)
+    local.get 0
+    local.get 2
+    i64.gt_u
+    local.get 1
+    local.get 3
+    i64.gt_u
+    local.get 1
+    local.get 3
+    i64.eq
+    select
+  )
+  (func $ge_s (param i64 i64 i64 i64) (result i32)
+    local.get 0
+    local.get 2
+    i64.ge_u
+    local.get 1
+    local.get 3
+    i64.ge_s
+    local.get 1
+    local.get 3
+    i64.eq
+    select
+  )
+  (func $ge_u (param i64 i64 i64 i64) (result i32)
+    local.get 0
+    local.get 2
+    i64.ge_u
+    local.get 1
+    local.get 3
+    i64.ge_u
+    local.get 1
+    local.get 3
+    i64.eq
+    select
+  )
+)
+;; function u0:0(i64 vmctx, i64, i64, i64, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64):
+;; @0034                               jump block1
+;;
+;;                                 block1:
+;;                                     v16 = iconcat.i64 v2, v3
+;;                                     v17 = iconcat.i64 v4, v5
+;;                                     v18 = icmp slt v16, v17
+;;                                     v20 = uextend.i32 v18
+;; @0034                               return v20
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64, i64, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64):
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;;                                     v16 = iconcat.i64 v2, v3
+;;                                     v17 = iconcat.i64 v4, v5
+;;                                     v18 = icmp ult v16, v17
+;;                                     v20 = uextend.i32 v18
+;; @0047                               return v20
+;; }
+;;
+;; function u0:2(i64 vmctx, i64, i64, i64, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64):
+;; @005a                               jump block1
+;;
+;;                                 block1:
+;;                                     v16 = iconcat.i64 v2, v3
+;;                                     v17 = iconcat.i64 v4, v5
+;;                                     v18 = icmp sle v16, v17
+;;                                     v20 = uextend.i32 v18
+;; @005a                               return v20
+;; }
+;;
+;; function u0:3(i64 vmctx, i64, i64, i64, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64):
+;; @006d                               jump block1
+;;
+;;                                 block1:
+;;                                     v16 = iconcat.i64 v2, v3
+;;                                     v17 = iconcat.i64 v4, v5
+;;                                     v18 = icmp ule v16, v17
+;;                                     v20 = uextend.i32 v18
+;; @006d                               return v20
+;; }
+;;
+;; function u0:4(i64 vmctx, i64, i64, i64, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64):
+;; @0080                               jump block1
+;;
+;;                                 block1:
+;;                                     v16 = iconcat.i64 v2, v3
+;;                                     v17 = iconcat.i64 v4, v5
+;;                                     v18 = icmp sgt v16, v17
+;;                                     v20 = uextend.i32 v18
+;; @0080                               return v20
+;; }
+;;
+;; function u0:5(i64 vmctx, i64, i64, i64, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64):
+;; @0093                               jump block1
+;;
+;;                                 block1:
+;;                                     v16 = iconcat.i64 v2, v3
+;;                                     v17 = iconcat.i64 v4, v5
+;;                                     v18 = icmp ugt v16, v17
+;;                                     v20 = uextend.i32 v18
+;; @0093                               return v20
+;; }
+;;
+;; function u0:6(i64 vmctx, i64, i64, i64, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64):
+;; @00a6                               jump block1
+;;
+;;                                 block1:
+;;                                     v16 = iconcat.i64 v2, v3
+;;                                     v17 = iconcat.i64 v4, v5
+;;                                     v18 = icmp sge v16, v17
+;;                                     v20 = uextend.i32 v18
+;; @00a6                               return v20
+;; }
+;;
+;; function u0:7(i64 vmctx, i64, i64, i64, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64, v5: i64):
+;; @00b9                               jump block1
+;;
+;;                                 block1:
+;;                                     v16 = iconcat.i64 v2, v3
+;;                                     v17 = iconcat.i64 v4, v5
+;;                                     v18 = icmp uge v16, v17
+;;                                     v20 = uextend.i32 v18
+;; @00b9                               return v20
+;; }
diff --git a/tests/disas/i32-load.wat b/tests/disas/i32-load.wat
new file mode 100644
index 000000000000..ec40907be1ae
--- /dev/null
+++ b/tests/disas/i32-load.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+
+;; Test basic code generation for i32 memory WebAssembly instructions.
+
+(module
+  (memory 1)
+  (func (export "i32.load") (param i32) (result i32)
+    local.get 0
+    i32.load))
+
+;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @002e                               v4 = uextend.i64 v2
+;; @002e                               v5 = global_value.i64 gv4
+;; @002e                               v6 = iadd v5, v4
+;; @002e                               v7 = load.i32 little heap v6
+;; @0031                               jump block1(v7)
+;;
+;;                                 block1(v3: i32):
+;; @0031                               return v3
+;; }
diff --git a/tests/disas/i32-load16-s.wat b/tests/disas/i32-load16-s.wat
new file mode 100644
index 000000000000..a10d1014ca58
--- /dev/null
+++ b/tests/disas/i32-load16-s.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+
+;; Test basic code generation for i32 memory WebAssembly instructions.
+
+(module
+  (memory 1)
+  (func (export "i32.load16_s") (param i32) (result i32)
+    local.get 0
+    i32.load16_s))
+
+;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0032                               v4 = uextend.i64 v2
+;; @0032                               v5 = global_value.i64 gv4
+;; @0032                               v6 = iadd v5, v4
+;; @0032                               v7 = sload16.i32 little heap v6
+;; @0035                               jump block1(v7)
+;;
+;;                                 block1(v3: i32):
+;; @0035                               return v3
+;; }
diff --git a/tests/disas/i32-load16-u.wat b/tests/disas/i32-load16-u.wat
new file mode 100644
index 000000000000..9a193e1356a6
--- /dev/null
+++ b/tests/disas/i32-load16-u.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+
+;; Test basic code generation for i32 memory WebAssembly instructions.
+
+(module
+  (memory 1)
+  (func (export "i32.load16_u") (param i32) (result i32)
+    local.get 0
+    i32.load16_u))
+
+;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0032                               v4 = uextend.i64 v2
+;; @0032                               v5 = global_value.i64 gv4
+;; @0032                               v6 = iadd v5, v4
+;; @0032                               v7 = uload16.i32 little heap v6
+;; @0035                               jump block1(v7)
+;;
+;;                                 block1(v3: i32):
+;; @0035                               return v3
+;; }
diff --git a/tests/disas/i32-load8-s.wat b/tests/disas/i32-load8-s.wat
new file mode 100644
index 000000000000..0619967d657d
--- /dev/null
+++ b/tests/disas/i32-load8-s.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+
+;; Test basic code generation for i32 memory WebAssembly instructions.
+
+(module
+  (memory 1)
+  (func (export "i32.load8_s") (param i32) (result i32)
+    local.get 0
+    i32.load8_s))
+
+;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0031                               v4 = uextend.i64 v2
+;; @0031                               v5 = global_value.i64 gv4
+;; @0031                               v6 = iadd v5, v4
+;; @0031                               v7 = sload8.i32 little heap v6
+;; @0034                               jump block1(v7)
+;;
+;;                                 block1(v3: i32):
+;; @0034                               return v3
+;; }
diff --git a/tests/disas/i32-load8-u.wat b/tests/disas/i32-load8-u.wat
new file mode 100644
index 000000000000..054660c44910
--- /dev/null
+++ b/tests/disas/i32-load8-u.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+
+;; Test basic code generation for i32 memory WebAssembly instructions.
+
+(module
+  (memory 1)
+  (func (export "i32.load8_u") (param i32) (result i32)
+    local.get 0
+    i32.load8_u))
+
+;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0031                               v4 = uextend.i64 v2
+;; @0031                               v5 = global_value.i64 gv4
+;; @0031                               v6 = iadd v5, v4
+;; @0031                               v7 = uload8.i32 little heap v6
+;; @0034                               jump block1(v7)
+;;
+;;                                 block1(v3: i32):
+;; @0034                               return v3
+;; }
diff --git a/tests/disas/i32-not-x64.wat b/tests/disas/i32-not-x64.wat
new file mode 100644
index 000000000000..f60df7ef8a06
--- /dev/null
+++ b/tests/disas/i32-not-x64.wat
@@ -0,0 +1,36 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = "-C cranelift-has-bmi1"
+
+(module
+  ;; this should get optimized to a `bnot` in clif
+  (func (param i32) (result i32)
+    i32.const -1
+    local.get 0
+    i32.xor)
+
+  ;; this should get optimized to a single `andn` instruction
+  (func (param i32 i32) (result i32)
+    local.get 0
+    i32.const -1
+    local.get 1
+    i32.xor
+    i32.and)
+)
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    %rdx, %rax
+;;       notl    %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       andnl   %edx, %ecx, %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/i32-store.wat b/tests/disas/i32-store.wat
new file mode 100644
index 000000000000..d56a260df6c1
--- /dev/null
+++ b/tests/disas/i32-store.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+
+;; Test basic code generation for i32 memory WebAssembly instructions.
+
+(module
+  (memory 1)
+  (func (export "i32.store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0031                               v4 = uextend.i64 v2
+;; @0031                               v5 = global_value.i64 gv4
+;; @0031                               v6 = iadd v5, v4
+;; @0031                               store little heap v3, v6
+;; @0034                               jump block1
+;;
+;;                                 block1:
+;; @0034                               return
+;; }
diff --git a/tests/disas/i32-store16.wat b/tests/disas/i32-store16.wat
new file mode 100644
index 000000000000..93426b68c99b
--- /dev/null
+++ b/tests/disas/i32-store16.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+
+;; Test basic code generation for i32 memory WebAssembly instructions.
+
+(module
+  (memory 1)
+  (func (export "i32.store16") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store16))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0033                               v4 = uextend.i64 v2
+;; @0033                               v5 = global_value.i64 gv4
+;; @0033                               v6 = iadd v5, v4
+;; @0033                               istore16 little heap v3, v6
+;; @0036                               jump block1
+;;
+;;                                 block1:
+;; @0036                               return
+;; }
diff --git a/tests/disas/i32-store8.wat b/tests/disas/i32-store8.wat
new file mode 100644
index 000000000000..949aaad4086a
--- /dev/null
+++ b/tests/disas/i32-store8.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+
+;; Test basic code generation for i32 memory WebAssembly instructions.
+
+(module
+  (memory 1)
+  (func (export "i32.store8") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0032                               v4 = uextend.i64 v2
+;; @0032                               v5 = global_value.i64 gv4
+;; @0032                               v6 = iadd v5, v4
+;; @0032                               istore8 little heap v3, v6
+;; @0035                               jump block1
+;;
+;;                                 block1:
+;; @0035                               return
+;; }
diff --git a/tests/disas/i64-load.wat b/tests/disas/i64-load.wat
new file mode 100644
index 000000000000..c3136d0714d2
--- /dev/null
+++ b/tests/disas/i64-load.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+
+;; Test basic code generation for i32 memory WebAssembly instructions.
+
+(module
+  (memory 1)
+  (func (export "i64.load") (param i32) (result i64)
+    local.get 0
+    i64.load))
+
+;; function u0:0(i64 vmctx, i64, i32) -> i64 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @002e                               v4 = uextend.i64 v2
+;; @002e                               v5 = global_value.i64 gv4
+;; @002e                               v6 = iadd v5, v4
+;; @002e                               v7 = load.i64 little heap v6
+;; @0031                               jump block1(v7)
+;;
+;;                                 block1(v3: i64):
+;; @0031                               return v3
+;; }
diff --git a/tests/disas/i64-load16-s.wat b/tests/disas/i64-load16-s.wat
new file mode 100644
index 000000000000..59dc1f4ba992
--- /dev/null
+++ b/tests/disas/i64-load16-s.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+
+;; Test basic code generation for i64 memory WebAssembly instructions.
+
+(module
+  (memory 1)
+  (func (export "i64.load16_s") (param i32) (result i64)
+    local.get 0
+    i64.load16_s))
+
+;; function u0:0(i64 vmctx, i64, i32) -> i64 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0032                               v4 = uextend.i64 v2
+;; @0032                               v5 = global_value.i64 gv4
+;; @0032                               v6 = iadd v5, v4
+;; @0032                               v7 = sload16.i64 little heap v6
+;; @0035                               jump block1(v7)
+;;
+;;                                 block1(v3: i64):
+;; @0035                               return v3
+;; }
diff --git a/tests/disas/i64-load16-u.wat b/tests/disas/i64-load16-u.wat
new file mode 100644
index 000000000000..53abb949d826
--- /dev/null
+++ b/tests/disas/i64-load16-u.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+
+;; Test basic code generation for i64 memory WebAssembly instructions.
+
+(module
+  (memory 1)
+  (func (export "i64.load16_u") (param i32) (result i64)
+    local.get 0
+    i64.load16_u))
+
+;; function u0:0(i64 vmctx, i64, i32) -> i64 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0032                               v4 = uextend.i64 v2
+;; @0032                               v5 = global_value.i64 gv4
+;; @0032                               v6 = iadd v5, v4
+;; @0032                               v7 = uload16.i64 little heap v6
+;; @0035                               jump block1(v7)
+;;
+;;                                 block1(v3: i64):
+;; @0035                               return v3
+;; }
diff --git a/tests/disas/i64-load8-s.wat b/tests/disas/i64-load8-s.wat
new file mode 100644
index 000000000000..7e4c78801254
--- /dev/null
+++ b/tests/disas/i64-load8-s.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+
+;; Test basic code generation for i64 memory WebAssembly instructions.
+
+(module
+  (memory 1)
+  (func (export "i64.load8_s") (param i32) (result i64)
+    local.get 0
+    i64.load8_s))
+
+;; function u0:0(i64 vmctx, i64, i32) -> i64 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0031                               v4 = uextend.i64 v2
+;; @0031                               v5 = global_value.i64 gv4
+;; @0031                               v6 = iadd v5, v4
+;; @0031                               v7 = sload8.i64 little heap v6
+;; @0034                               jump block1(v7)
+;;
+;;                                 block1(v3: i64):
+;; @0034                               return v3
+;; }
diff --git a/tests/disas/i64-load8-u.wat b/tests/disas/i64-load8-u.wat
new file mode 100644
index 000000000000..6a6063c7d2a4
--- /dev/null
+++ b/tests/disas/i64-load8-u.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+
+;; Test basic code generation for i64 memory WebAssembly instructions.
+
+(module
+  (memory 1)
+  (func (export "i64.load8_u") (param i32) (result i64)
+    local.get 0
+    i64.load8_u))
+
+;; function u0:0(i64 vmctx, i64, i32) -> i64 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0031                               v4 = uextend.i64 v2
+;; @0031                               v5 = global_value.i64 gv4
+;; @0031                               v6 = iadd v5, v4
+;; @0031                               v7 = uload8.i64 little heap v6
+;; @0034                               jump block1(v7)
+;;
+;;                                 block1(v3: i64):
+;; @0034                               return v3
+;; }
diff --git a/tests/disas/i64-store.wat b/tests/disas/i64-store.wat
new file mode 100644
index 000000000000..0abafce94a1d
--- /dev/null
+++ b/tests/disas/i64-store.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+
+;; Test basic code generation for i32 memory WebAssembly instructions.
+
+(module
+  (memory 1)
+  (func (export "i64.store") (param i32 i64)
+    local.get 0
+    local.get 1
+    i64.store))
+
+;; function u0:0(i64 vmctx, i64, i32, i64) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i64):
+;; @0031                               v4 = uextend.i64 v2
+;; @0031                               v5 = global_value.i64 gv4
+;; @0031                               v6 = iadd v5, v4
+;; @0031                               store little heap v3, v6
+;; @0034                               jump block1
+;;
+;;                                 block1:
+;; @0034                               return
+;; }
diff --git a/tests/disas/i64-store16.wat b/tests/disas/i64-store16.wat
new file mode 100644
index 000000000000..1aa5ec37a792
--- /dev/null
+++ b/tests/disas/i64-store16.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+
+;; Test basic code generation for i64 memory WebAssembly instructions.
+
+(module
+  (memory 1)
+  (func (export "i64.store16") (param i32 i64)
+    local.get 0
+    local.get 1
+    i64.store16))
+
+;; function u0:0(i64 vmctx, i64, i32, i64) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i64):
+;; @0033                               v4 = uextend.i64 v2
+;; @0033                               v5 = global_value.i64 gv4
+;; @0033                               v6 = iadd v5, v4
+;; @0033                               istore16 little heap v3, v6
+;; @0036                               jump block1
+;;
+;;                                 block1:
+;; @0036                               return
+;; }
diff --git a/tests/disas/i64-store32.wat b/tests/disas/i64-store32.wat
new file mode 100644
index 000000000000..b6095ae2569c
--- /dev/null
+++ b/tests/disas/i64-store32.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+
+;; Test basic code generation for i64 memory WebAssembly instructions.
+
+(module
+  (memory 1)
+  (func (export "i64.store32") (param i32 i64)
+    local.get 0
+    local.get 1
+    i64.store32))
+
+;; function u0:0(i64 vmctx, i64, i32, i64) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i64):
+;; @0033                               v4 = uextend.i64 v2
+;; @0033                               v5 = global_value.i64 gv4
+;; @0033                               v6 = iadd v5, v4
+;; @0033                               istore32 little heap v3, v6
+;; @0036                               jump block1
+;;
+;;                                 block1:
+;; @0036                               return
+;; }
diff --git a/tests/disas/i64-store8.wat b/tests/disas/i64-store8.wat
new file mode 100644
index 000000000000..f81d1cdbbb23
--- /dev/null
+++ b/tests/disas/i64-store8.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+
+;; Test basic code generation for i64 memory WebAssembly instructions.
+
+(module
+  (memory 1)
+  (func (export "i64.store8") (param i32 i64)
+    local.get 0
+    local.get 1
+    i64.store8))
+
+;; function u0:0(i64 vmctx, i64, i32, i64) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i64):
+;; @0032                               v4 = uextend.i64 v2
+;; @0032                               v5 = global_value.i64 gv4
+;; @0032                               v6 = iadd v5, v4
+;; @0032                               istore8 little heap v3, v6
+;; @0035                               jump block1
+;;
+;;                                 block1:
+;; @0035                               return
+;; }
diff --git a/tests/disas/icall-loop.wat b/tests/disas/icall-loop.wat
new file mode 100644
index 000000000000..80d55efdb302
--- /dev/null
+++ b/tests/disas/icall-loop.wat
@@ -0,0 +1,126 @@
+;;! target = "x86_64"
+;;! test = "optimize"
+
+;; When `call_indirect` is used in a loop with the same table index on every
+;; iteration, we can hoist part of the work out of the loop. This test tracks
+;; how much we're successfully pulling out.
+
+(module
+  (type $fn (func (result i32)))
+  (table $fnptrs 2 2 funcref)
+  (func (param i32)
+        loop
+          local.get 0
+          call_indirect $fnptrs (type $fn)
+          br 0
+        end)
+  (func
+        loop
+          i32.const 1
+          call_indirect $fnptrs (type $fn)
+          br 0
+        end)
+)
+
+;; function u0:0(i64 vmctx, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly gv3+88
+;;     sig0 = (i64 vmctx, i64) -> i32 tail
+;;     sig1 = (i64 vmctx, i32 uext, i32 uext) -> i64 system_v
+;;     fn0 = colocated u1:9 sig1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @002b                               v4 = iconst.i32 2
+;; @002b                               v5 = icmp uge v2, v4  ; v4 = 2
+;; @002b                               v10 = iconst.i64 0
+;; @002b                               v7 = load.i64 notrap aligned readonly v0+88
+;; @002b                               v6 = uextend.i64 v2
+;;                                     v28 = iconst.i64 3
+;; @002b                               v8 = ishl v6, v28  ; v28 = 3
+;; @002b                               v9 = iadd v7, v8
+;; @002b                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;;                                     v29 = iconst.i64 -2
+;; @002b                               v15 = iconst.i32 0
+;; @002b                               v19 = load.i64 notrap aligned readonly v0+80
+;; @002b                               v20 = load.i32 notrap aligned readonly v19
+;; @0027                               jump block2
+;;
+;;                                 block2:
+;; @002b                               v12 = load.i64 table_oob aligned table v11
+;;                                     v30 = iconst.i64 -2
+;;                                     v31 = band v12, v30  ; v30 = -2
+;; @002b                               brif v12, block5(v31), block4
+;;
+;;                                 block4 cold:
+;;                                     v32 = iconst.i32 0
+;; @002b                               v17 = call fn0(v0, v32, v2)  ; v32 = 0
+;; @002b                               jump block5(v17)
+;;
+;;                                 block5(v14: i64):
+;; @002b                               v21 = load.i32 icall_null aligned readonly v14+16
+;; @002b                               v22 = icmp eq v21, v20
+;; @002b                               brif v22, block7, block6
+;;
+;;                                 block6 cold:
+;; @002b                               trap bad_sig
+;;
+;;                                 block7:
+;; @002b                               v23 = load.i64 notrap aligned readonly v14+8
+;; @002b                               v24 = load.i64 notrap aligned readonly v14+24
+;; @002b                               v25 = call_indirect sig0, v23(v24, v0)
+;; @002e                               jump block2
+;; }
+;;
+;; function u0:1(i64 vmctx, i64) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly gv3+88
+;;     sig0 = (i64 vmctx, i64) -> i32 tail
+;;     sig1 = (i64 vmctx, i32 uext, i32 uext) -> i64 system_v
+;;     fn0 = colocated u1:9 sig1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @0038                               v6 = load.i64 notrap aligned readonly v0+88
+;;                                     v36 = iconst.i64 8
+;; @0038                               v8 = iadd v6, v36  ; v36 = 8
+;;                                     v27 = iconst.i64 -2
+;; @0038                               v14 = iconst.i32 0
+;; @0036                               v2 = iconst.i32 1
+;; @0038                               v18 = load.i64 notrap aligned readonly v0+80
+;; @0038                               v19 = load.i32 notrap aligned readonly v18
+;; @0034                               jump block2
+;;
+;;                                 block2:
+;;                                     v37 = iadd.i64 v6, v36  ; v36 = 8
+;; @0038                               v11 = load.i64 table_oob aligned table v37
+;;                                     v38 = iconst.i64 -2
+;;                                     v39 = band v11, v38  ; v38 = -2
+;; @0038                               brif v11, block5(v39), block4
+;;
+;;                                 block4 cold:
+;;                                     v40 = iconst.i32 0
+;;                                     v41 = iconst.i32 1
+;; @0038                               v16 = call fn0(v0, v40, v41)  ; v40 = 0, v41 = 1
+;; @0038                               jump block5(v16)
+;;
+;;                                 block5(v13: i64):
+;; @0038                               v20 = load.i32 icall_null aligned readonly v13+16
+;; @0038                               v21 = icmp eq v20, v19
+;; @0038                               brif v21, block7, block6
+;;
+;;                                 block6 cold:
+;; @0038                               trap bad_sig
+;;
+;;                                 block7:
+;; @0038                               v22 = load.i64 notrap aligned readonly v13+8
+;; @0038                               v23 = load.i64 notrap aligned readonly v13+24
+;; @0038                               v24 = call_indirect sig0, v22(v23, v0)
+;; @003b                               jump block2
+;; }
diff --git a/tests/disas/icall-simd.wat b/tests/disas/icall-simd.wat
new file mode 100644
index 000000000000..523948634e7e
--- /dev/null
+++ b/tests/disas/icall-simd.wat
@@ -0,0 +1,55 @@
+;;! target = "x86_64"
+
+(module
+  (type $ft (func (param v128) (result v128)))
+  (func $foo (export "foo") (param i32) (param v128) (result v128)
+    (call_indirect (type $ft) (local.get 1) (local.get 0))
+  )
+  (table (;0;) 23 23 funcref)
+)
+
+;; function u0:0(i64 vmctx, i64, i32, i8x16) -> i8x16 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly gv3+88
+;;     sig0 = (i64 vmctx, i64, i8x16) -> i8x16 tail
+;;     sig1 = (i64 vmctx, i32 uext, i32 uext) -> i64 system_v
+;;     fn0 = colocated u1:9 sig1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i8x16):
+;; @0033                               v5 = iconst.i32 23
+;; @0033                               v6 = icmp uge v2, v5  ; v5 = 23
+;; @0033                               v7 = uextend.i64 v2
+;; @0033                               v8 = global_value.i64 gv4
+;; @0033                               v9 = ishl_imm v7, 3
+;; @0033                               v10 = iadd v8, v9
+;; @0033                               v11 = iconst.i64 0
+;; @0033                               v12 = select_spectre_guard v6, v11, v10  ; v11 = 0
+;; @0033                               v13 = load.i64 table_oob aligned table v12
+;; @0033                               v14 = band_imm v13, -2
+;; @0033                               brif v13, block3(v14), block2
+;;
+;;                                 block2 cold:
+;; @0033                               v16 = iconst.i32 0
+;; @0033                               v17 = global_value.i64 gv3
+;; @0033                               v18 = call fn0(v17, v16, v2)  ; v16 = 0
+;; @0033                               jump block3(v18)
+;;
+;;                                 block3(v15: i64):
+;; @0033                               v19 = global_value.i64 gv3
+;; @0033                               v20 = load.i64 notrap aligned readonly v19+80
+;; @0033                               v21 = load.i32 notrap aligned readonly v20
+;; @0033                               v22 = load.i32 icall_null aligned readonly v15+16
+;; @0033                               v23 = icmp eq v22, v21
+;; @0033                               trapz v23, bad_sig
+;; @0033                               v24 = load.i64 notrap aligned readonly v15+8
+;; @0033                               v25 = load.i64 notrap aligned readonly v15+24
+;; @0033                               v26 = call_indirect sig0, v24(v25, v0, v3)
+;; @0036                               jump block1(v26)
+;;
+;;                                 block1(v4: i8x16):
+;; @0036                               return v4
+;; }
diff --git a/tests/disas/icall.wat b/tests/disas/icall.wat
new file mode 100644
index 000000000000..bdf6d722e9bc
--- /dev/null
+++ b/tests/disas/icall.wat
@@ -0,0 +1,55 @@
+;;! target = "x86_64"
+
+(module
+  (type $ft (func (param f32) (result i32)))
+  (func $foo (export "foo") (param i32 f32) (result i32)
+    (call_indirect (type $ft) (local.get 1) (local.get 0))
+  )
+  (table (;0;) 23 23 funcref)
+)
+
+;; function u0:0(i64 vmctx, i64, i32, f32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly gv3+88
+;;     sig0 = (i64 vmctx, i64, f32) -> i32 tail
+;;     sig1 = (i64 vmctx, i32 uext, i32 uext) -> i64 system_v
+;;     fn0 = colocated u1:9 sig1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: f32):
+;; @0033                               v5 = iconst.i32 23
+;; @0033                               v6 = icmp uge v2, v5  ; v5 = 23
+;; @0033                               v7 = uextend.i64 v2
+;; @0033                               v8 = global_value.i64 gv4
+;; @0033                               v9 = ishl_imm v7, 3
+;; @0033                               v10 = iadd v8, v9
+;; @0033                               v11 = iconst.i64 0
+;; @0033                               v12 = select_spectre_guard v6, v11, v10  ; v11 = 0
+;; @0033                               v13 = load.i64 table_oob aligned table v12
+;; @0033                               v14 = band_imm v13, -2
+;; @0033                               brif v13, block3(v14), block2
+;;
+;;                                 block2 cold:
+;; @0033                               v16 = iconst.i32 0
+;; @0033                               v17 = global_value.i64 gv3
+;; @0033                               v18 = call fn0(v17, v16, v2)  ; v16 = 0
+;; @0033                               jump block3(v18)
+;;
+;;                                 block3(v15: i64):
+;; @0033                               v19 = global_value.i64 gv3
+;; @0033                               v20 = load.i64 notrap aligned readonly v19+80
+;; @0033                               v21 = load.i32 notrap aligned readonly v20
+;; @0033                               v22 = load.i32 icall_null aligned readonly v15+16
+;; @0033                               v23 = icmp eq v22, v21
+;; @0033                               trapz v23, bad_sig
+;; @0033                               v24 = load.i64 notrap aligned readonly v15+8
+;; @0033                               v25 = load.i64 notrap aligned readonly v15+24
+;; @0033                               v26 = call_indirect sig0, v24(v25, v0, v3)
+;; @0036                               jump block1(v26)
+;;
+;;                                 block1(v4: i32):
+;; @0036                               return v4
+;; }
diff --git a/tests/disas/if-reachability-translation-0.wat b/tests/disas/if-reachability-translation-0.wat
new file mode 100644
index 000000000000..9b45a4b22571
--- /dev/null
+++ b/tests/disas/if-reachability-translation-0.wat
@@ -0,0 +1,24 @@
+;;! target = "x86_64"
+
+;; An unreachable `if` means that the consequent, alternative, and following
+;; block are also unreachable.
+
+(module
+  (func (param i32) (result i32)
+    unreachable
+    if  ;; label = @2
+      nop
+    else
+      nop
+    end
+    i32.const 0))
+
+;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0019                               trap unreachable
+;; }
diff --git a/tests/disas/if-reachability-translation-1.wat b/tests/disas/if-reachability-translation-1.wat
new file mode 100644
index 000000000000..db3093f01f90
--- /dev/null
+++ b/tests/disas/if-reachability-translation-1.wat
@@ -0,0 +1,37 @@
+;;! target = "x86_64"
+
+;; Reachable `if` head and reachable consequent and alternative means that the
+;; following block is also reachable.
+
+(module
+  (func (param i32) (result i32)
+    local.get 0
+    if  ;; label = @2
+      nop
+    else
+      nop
+    end
+    i32.const 0))
+
+;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @001b                               brif v2, block2, block4
+;;
+;;                                 block2:
+;; @001e                               jump block3
+;;
+;;                                 block4:
+;; @0020                               jump block3
+;;
+;;                                 block3:
+;; @0021                               v4 = iconst.i32 0
+;; @0023                               jump block1(v4)  ; v4 = 0
+;;
+;;                                 block1(v3: i32):
+;; @0023                               return v3
+;; }
diff --git a/tests/disas/if-reachability-translation-2.wat b/tests/disas/if-reachability-translation-2.wat
new file mode 100644
index 000000000000..ea2dfed1bc27
--- /dev/null
+++ b/tests/disas/if-reachability-translation-2.wat
@@ -0,0 +1,37 @@
+;;! target = "x86_64"
+
+;; Reachable `if` head and unreachable consequent and reachable alternative
+;; means that the following block is also reachable.
+
+(module
+  (func (param i32) (result i32)
+    local.get 0
+    if
+      unreachable
+    else
+      nop
+    end
+    i32.const 0))
+
+;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @001b                               brif v2, block2, block4
+;;
+;;                                 block2:
+;; @001d                               trap unreachable
+;;
+;;                                 block4:
+;; @0020                               jump block3
+;;
+;;                                 block3:
+;; @0021                               v4 = iconst.i32 0
+;; @0023                               jump block1(v4)  ; v4 = 0
+;;
+;;                                 block1(v3: i32):
+;; @0023                               return v3
+;; }
diff --git a/tests/disas/if-reachability-translation-3.wat b/tests/disas/if-reachability-translation-3.wat
new file mode 100644
index 000000000000..1512933d48ec
--- /dev/null
+++ b/tests/disas/if-reachability-translation-3.wat
@@ -0,0 +1,37 @@
+;;! target = "x86_64"
+
+;; Reachable `if` head and consequent and unreachable alternative means that the
+;; following block is also reachable.
+
+(module
+  (func (param i32) (result i32)
+    local.get 0
+    if
+      nop
+    else
+      unreachable
+    end
+    i32.const 0))
+
+;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @001b                               brif v2, block2, block4
+;;
+;;                                 block2:
+;; @001e                               jump block3
+;;
+;;                                 block4:
+;; @001f                               trap unreachable
+;;
+;;                                 block3:
+;; @0021                               v4 = iconst.i32 0
+;; @0023                               jump block1(v4)  ; v4 = 0
+;;
+;;                                 block1(v3: i32):
+;; @0023                               return v3
+;; }
diff --git a/tests/disas/if-reachability-translation-4.wat b/tests/disas/if-reachability-translation-4.wat
new file mode 100644
index 000000000000..c6fca4f46ec6
--- /dev/null
+++ b/tests/disas/if-reachability-translation-4.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+
+;; Reachable `if` head and unreachable consequent and alternative means that the
+;; following block is unreachable.
+
+(module
+  (func (param i32) (result i32)
+    local.get 0
+    if
+      unreachable
+    else
+      unreachable
+    end
+    i32.const 0))
+
+;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @001b                               brif v2, block2, block4
+;;
+;;                                 block2:
+;; @001d                               trap unreachable
+;;
+;;                                 block4:
+;; @001f                               trap unreachable
+;; }
diff --git a/tests/disas/if-reachability-translation-5.wat b/tests/disas/if-reachability-translation-5.wat
new file mode 100644
index 000000000000..54b68fb91b22
--- /dev/null
+++ b/tests/disas/if-reachability-translation-5.wat
@@ -0,0 +1,42 @@
+;;! target = "x86_64"
+
+;; Reachable `if` head and unreachable consequent and alternative, but with a
+;; branch out of the consequent, means that the following block is reachable.
+
+(module
+  (func (param i32 i32) (result i32)
+    local.get 0
+    if
+      local.get 1
+      br_if 0
+      unreachable
+    else
+      unreachable
+    end
+    i32.const 0))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @001c                               brif v2, block2, block5
+;;
+;;                                 block2:
+;; @0020                               brif.i32 v3, block3, block4
+;;
+;;                                 block4:
+;; @0022                               trap unreachable
+;;
+;;                                 block5:
+;; @0024                               trap unreachable
+;;
+;;                                 block3:
+;; @0026                               v5 = iconst.i32 0
+;; @0028                               jump block1(v5)  ; v5 = 0
+;;
+;;                                 block1(v4: i32):
+;; @0028                               return v4
+;; }
diff --git a/tests/disas/if-reachability-translation-6.wat b/tests/disas/if-reachability-translation-6.wat
new file mode 100644
index 000000000000..82992e3512f8
--- /dev/null
+++ b/tests/disas/if-reachability-translation-6.wat
@@ -0,0 +1,42 @@
+;;! target = "x86_64"
+
+;; Reachable `if` head and unreachable consequent and alternative, but with a
+;; branch out of the alternative, means that the following block is reachable.
+
+(module
+  (func (param i32 i32) (result i32)
+    local.get 0
+    if
+      unreachable
+    else
+      local.get 1
+      br_if 0
+      unreachable
+    end
+    i32.const 0))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @001c                               brif v2, block2, block4
+;;
+;;                                 block2:
+;; @001e                               trap unreachable
+;;
+;;                                 block4:
+;; @0022                               brif.i32 v3, block3, block5
+;;
+;;                                 block5:
+;; @0024                               trap unreachable
+;;
+;;                                 block3:
+;; @0026                               v5 = iconst.i32 0
+;; @0028                               jump block1(v5)  ; v5 = 0
+;;
+;;                                 block1(v4: i32):
+;; @0028                               return v4
+;; }
diff --git a/tests/disas/if-unreachable-else-params-2.wat b/tests/disas/if-unreachable-else-params-2.wat
new file mode 100644
index 000000000000..b2c8926779fc
--- /dev/null
+++ b/tests/disas/if-unreachable-else-params-2.wat
@@ -0,0 +1,49 @@
+;;! target = "x86_64"
+
+(module
+  (type (;0;) (func (param i32 i32) (result f64)))
+  (func $main (type 0) (param i32 i32) (result f64)
+    f64.const 1.0
+    local.get 0
+    local.get 1
+    if (param i32)  ;; label = @2
+      i64.load16_s align=1
+      drop
+    else
+      unreachable
+    end)
+  (table (;0;) 63 255 funcref)
+  (memory (;0;) 13 16)
+  (export "t1" (table 0))
+  (export "m1" (memory 0))
+  (export "main" (func $main))
+  (export "memory" (memory 0)))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) -> f64 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+112
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0049                               v5 = f64const 0x1.0000000000000p0
+;; @0056                               brif v3, block2, block4(v2)
+;;
+;;                                 block2:
+;; @0058                               v7 = uextend.i64 v2
+;; @0058                               v8 = global_value.i64 gv4
+;; @0058                               v9 = iadd v8, v7
+;; @0058                               v10 = sload16.i64 little heap v9
+;; @005c                               jump block3
+;;
+;;                                 block4(v6: i32):
+;; @005d                               trap unreachable
+;;
+;;                                 block3:
+;; @005f                               jump block1(v5)  ; v5 = 0x1.0000000000000p0
+;;
+;;                                 block1(v4: f64):
+;; @005f                               return v4
+;; }
diff --git a/tests/disas/if-unreachable-else-params.wat b/tests/disas/if-unreachable-else-params.wat
new file mode 100644
index 000000000000..58b2cd988b9a
--- /dev/null
+++ b/tests/disas/if-unreachable-else-params.wat
@@ -0,0 +1,70 @@
+;;! target = "x86_64"
+
+(module
+  (type (;0;) (func (param i32)))
+  (func $main (type 0) (param i32)
+    i32.const 35
+    loop (param i32)  ;; label = @1
+      local.get 0
+      if (param i32)  ;; label = @2
+        i64.load16_s align=1
+        unreachable
+        unreachable
+        unreachable
+        unreachable
+        unreachable
+        local.get 0
+        unreachable
+        unreachable
+        i64.load8_u offset=11789
+        unreachable
+      else
+        i32.popcnt
+        local.set 0
+        return
+        unreachable
+      end
+      unreachable
+      unreachable
+      nop
+      f32.lt
+      i32.store8 offset=82
+      unreachable
+    end
+    unreachable
+    unreachable
+    unreachable
+    unreachable)
+  (table (;0;) 63 255 funcref)
+  (memory (;0;) 13 16)
+  (export "t1" (table 0))
+  (export "m1" (memory 0))
+  (export "main" (func $main))
+  (export "memory" (memory 0)))
+
+;; function u0:0(i64 vmctx, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+112
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0043                               v3 = iconst.i32 35
+;; @0045                               jump block2(v3)  ; v3 = 35
+;;
+;;                                 block2(v4: i32):
+;; @0049                               brif.i32 v2, block4, block6(v4)
+;;
+;;                                 block4:
+;; @004b                               v7 = uextend.i64 v4
+;; @004b                               v8 = global_value.i64 gv4
+;; @004b                               v9 = iadd v8, v7
+;; @004b                               v10 = sload16.i64 little heap v9
+;; @004e                               trap unreachable
+;;
+;;                                 block6(v6: i32):
+;; @005d                               v11 = popcnt.i32 v4
+;; @0060                               return
+;; }
diff --git a/tests/disas/indirect-call-no-caching.wat b/tests/disas/indirect-call-no-caching.wat
new file mode 100644
index 000000000000..bb9e7e4fce76
--- /dev/null
+++ b/tests/disas/indirect-call-no-caching.wat
@@ -0,0 +1,109 @@
+;;! target = "x86_64"
+
+;; This test checks that we do *not* get the indirect-call caching optimization
+;; when it is not enabled, because it is off by default.
+;;
+;; The key bit in the expectation below is that the call sequence in
+;; `u0:3` below goes straight to the bounds-check (v5), lazy-table
+;; init (masking of bits with v13), and loading of the funcref fields
+;; in block3, with no caching fastpath.
+
+(module
+ (table 10 10 funcref)
+
+ (func $f1 (result i32) i32.const 1)
+ (func $f2 (result i32) i32.const 2)
+ (func $f3 (result i32) i32.const 3)
+
+ (func (export "call_it") (param i32) (result i32)
+  local.get 0
+  call_indirect (result i32))
+
+ (elem (i32.const 1) func $f1 $f2 $f3))
+;; function u0:0(i64 vmctx, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @003f                               v3 = iconst.i32 1
+;; @0041                               jump block1(v3)  ; v3 = 1
+;;
+;;                                 block1(v2: i32):
+;; @0041                               return v2
+;; }
+;;
+;; function u0:1(i64 vmctx, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @0044                               v3 = iconst.i32 2
+;; @0046                               jump block1(v3)  ; v3 = 2
+;;
+;;                                 block1(v2: i32):
+;; @0046                               return v2
+;; }
+;;
+;; function u0:2(i64 vmctx, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @0049                               v3 = iconst.i32 3
+;; @004b                               jump block1(v3)  ; v3 = 3
+;;
+;;                                 block1(v2: i32):
+;; @004b                               return v2
+;; }
+;;
+;; function u0:3(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly gv3+88
+;;     sig0 = (i64 vmctx, i64) -> i32 tail
+;;     sig1 = (i64 vmctx, i32 uext, i32 uext) -> i64 system_v
+;;     fn0 = colocated u1:9 sig1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0050                               v4 = iconst.i32 10
+;; @0050                               v5 = icmp uge v2, v4  ; v4 = 10
+;; @0050                               v6 = uextend.i64 v2
+;; @0050                               v7 = global_value.i64 gv4
+;; @0050                               v8 = ishl_imm v6, 3
+;; @0050                               v9 = iadd v7, v8
+;; @0050                               v10 = iconst.i64 0
+;; @0050                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @0050                               v12 = load.i64 table_oob aligned table v11
+;; @0050                               v13 = band_imm v12, -2
+;; @0050                               brif v12, block3(v13), block2
+;;
+;;                                 block2 cold:
+;; @0050                               v15 = iconst.i32 0
+;; @0050                               v16 = global_value.i64 gv3
+;; @0050                               v17 = call fn0(v16, v15, v2)  ; v15 = 0
+;; @0050                               jump block3(v17)
+;;
+;;                                 block3(v14: i64):
+;; @0050                               v18 = global_value.i64 gv3
+;; @0050                               v19 = load.i64 notrap aligned readonly v18+80
+;; @0050                               v20 = load.i32 notrap aligned readonly v19
+;; @0050                               v21 = load.i32 icall_null aligned readonly v14+16
+;; @0050                               v22 = icmp eq v21, v20
+;; @0050                               trapz v22, bad_sig
+;; @0050                               v23 = load.i64 notrap aligned readonly v14+8
+;; @0050                               v24 = load.i64 notrap aligned readonly v14+24
+;; @0050                               v25 = call_indirect sig0, v23(v24, v0)
+;; @0053                               jump block1(v25)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/issue-5696.wat b/tests/disas/issue-5696.wat
new file mode 100644
index 000000000000..862715376a0d
--- /dev/null
+++ b/tests/disas/issue-5696.wat
@@ -0,0 +1,24 @@
+;;! target = "x86_64"
+;;! test = "optimize"
+
+(module
+  (func (;0;) (param i64) (result i64)
+    i64.const 32
+    i64.const -19
+    i64.shr_u
+    ;; call 0
+  )
+)
+;; function u0:0(i64 vmctx, i64, i64) -> i64 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @001e                               jump block1
+;;
+;;                                 block1:
+;;                                     v7 = iconst.i64 0
+;; @001e                               return v7  ; v7 = 0
+;; }
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..c73b4c9e0d02
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x7, [x2, #0x68]
+;;       mov     w8, w4
+;;       sub     x7, x7, #4
+;;       cmp     x8, x7
+;;       b.hi    #0x2c
+;;   1c: ldr     x9, [x2, #0x60]
+;;       str     w5, [x9, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   2c: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x7, [x2, #0x68]
+;;       mov     w8, w4
+;;       sub     x7, x7, #4
+;;       cmp     x8, x7
+;;       b.hi    #0x6c
+;;   5c: ldr     x9, [x2, #0x60]
+;;       ldr     w2, [x9, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   6c: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..7427770f8f08
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x9, [x2, #0x68]
+;;       mov     w10, w4
+;;       mov     x11, #0x1004
+;;       sub     x9, x9, x11
+;;       cmp     x10, x9
+;;       b.hi    #0x34
+;;   20: ldr     x11, [x2, #0x60]
+;;       add     x11, x11, #1, lsl #12
+;;       str     w5, [x11, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   34: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x9, [x2, #0x68]
+;;       mov     w10, w4
+;;       mov     x11, #0x1004
+;;       sub     x9, x9, x11
+;;       cmp     x10, x9
+;;       b.hi    #0x74
+;;   60: ldr     x11, [x2, #0x60]
+;;       add     x10, x11, #1, lsl #12
+;;       ldr     w2, [x10, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   74: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..a81f4511e7d7
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w10, w4
+;;       mov     w11, #-0xfffc
+;;       adds    x10, x10, x11
+;;       b.hs    #0x40
+;;   18: ldr     x11, [x2, #0x68]
+;;       cmp     x10, x11
+;;       b.hi    #0x3c
+;;   24: ldr     x13, [x2, #0x60]
+;;       add     x13, x13, w4, uxtw
+;;       mov     x14, #0xffff0000
+;;       str     w5, [x13, x14]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   3c: .byte   0x1f, 0xc1, 0x00, 0x00
+;;   40: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w10, w4
+;;       mov     w11, #-0xfffc
+;;       adds    x10, x10, x11
+;;       b.hs    #0xa0
+;;   78: ldr     x11, [x2, #0x68]
+;;       cmp     x10, x11
+;;       b.hi    #0x9c
+;;   84: ldr     x13, [x2, #0x60]
+;;       add     x13, x13, w4, uxtw
+;;       mov     x14, #0xffff0000
+;;       ldr     w2, [x13, x14]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   9c: .byte   0x1f, 0xc1, 0x00, 0x00
+;;   a0: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..0c9363f61d84
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x68]
+;;       mov     w7, w4
+;;       cmp     x7, x6
+;;       b.hs    #0x28
+;;   18: ldr     x8, [x2, #0x60]
+;;       strb    w5, [x8, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   28: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x68]
+;;       mov     w7, w4
+;;       cmp     x7, x6
+;;       b.hs    #0x68
+;;   58: ldr     x8, [x2, #0x60]
+;;       ldrb    w2, [x8, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   68: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..d5bdd6b2a3c1
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x9, [x2, #0x68]
+;;       mov     w10, w4
+;;       mov     x11, #0x1001
+;;       sub     x9, x9, x11
+;;       cmp     x10, x9
+;;       b.hi    #0x34
+;;   20: ldr     x11, [x2, #0x60]
+;;       add     x11, x11, #1, lsl #12
+;;       strb    w5, [x11, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   34: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x9, [x2, #0x68]
+;;       mov     w10, w4
+;;       mov     x11, #0x1001
+;;       sub     x9, x9, x11
+;;       cmp     x10, x9
+;;       b.hi    #0x74
+;;   60: ldr     x11, [x2, #0x60]
+;;       add     x10, x11, #1, lsl #12
+;;       ldrb    w2, [x10, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   74: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..6d06771316f7
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w10, w4
+;;       mov     w11, #-0xffff
+;;       adds    x10, x10, x11
+;;       b.hs    #0x40
+;;   18: ldr     x11, [x2, #0x68]
+;;       cmp     x10, x11
+;;       b.hi    #0x3c
+;;   24: ldr     x13, [x2, #0x60]
+;;       add     x13, x13, w4, uxtw
+;;       mov     x14, #0xffff0000
+;;       strb    w5, [x13, x14]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   3c: .byte   0x1f, 0xc1, 0x00, 0x00
+;;   40: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w10, w4
+;;       mov     w11, #-0xffff
+;;       adds    x10, x10, x11
+;;       b.hs    #0xa0
+;;   78: ldr     x11, [x2, #0x68]
+;;       cmp     x10, x11
+;;       b.hi    #0x9c
+;;   84: ldr     x13, [x2, #0x60]
+;;       add     x13, x13, w4, uxtw
+;;       mov     x14, #0xffff0000
+;;       ldrb    w2, [x13, x14]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   9c: .byte   0x1f, 0xc1, 0x00, 0x00
+;;   a0: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..0c2d8d5c4656
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x12, [x2, #0x68]
+;;       ldr     x10, [x2, #0x60]
+;;       mov     w11, w4
+;;       sub     x12, x12, #4
+;;       mov     x13, #0
+;;       add     x10, x10, w4, uxtw
+;;       cmp     x11, x12
+;;       csel    x11, x13, x10, hi
+;;       csdb
+;;       str     w5, [x11]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x12, [x2, #0x68]
+;;       ldr     x10, [x2, #0x60]
+;;       mov     w11, w4
+;;       sub     x12, x12, #4
+;;       mov     x13, #0
+;;       add     x10, x10, w4, uxtw
+;;       cmp     x11, x12
+;;       csel    x11, x13, x10, hi
+;;       csdb
+;;       ldr     w2, [x11]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..8f67fc90c312
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x14, [x2, #0x68]
+;;       ldr     x13, [x2, #0x60]
+;;       mov     w12, w4
+;;       mov     x15, #0x1004
+;;       sub     x14, x14, x15
+;;       mov     x15, #0
+;;       add     x13, x13, w4, uxtw
+;;       add     x13, x13, #1, lsl #12
+;;       cmp     x12, x14
+;;       csel    x13, x15, x13, hi
+;;       csdb
+;;       str     w5, [x13]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x14, [x2, #0x68]
+;;       ldr     x13, [x2, #0x60]
+;;       mov     w12, w4
+;;       mov     x15, #0x1004
+;;       sub     x14, x14, x15
+;;       mov     x15, #0
+;;       add     x13, x13, w4, uxtw
+;;       add     x13, x13, #1, lsl #12
+;;       cmp     x12, x14
+;;       csel    x13, x15, x13, hi
+;;       csdb
+;;       ldr     w2, [x13]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..a85f305440f7
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w13, w4
+;;       mov     w14, #-0xfffc
+;;       adds    x13, x13, x14
+;;       b.hs    #0x48
+;;   18: ldr     x14, [x2, #0x68]
+;;       ldr     x0, [x2, #0x60]
+;;       mov     x15, #0
+;;       add     x0, x0, w4, uxtw
+;;       mov     x1, #0xffff0000
+;;       add     x0, x0, x1
+;;       cmp     x13, x14
+;;       csel    x15, x15, x0, hi
+;;       csdb
+;;       str     w5, [x15]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   48: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w13, w4
+;;       mov     w14, #-0xfffc
+;;       adds    x13, x13, x14
+;;       b.hs    #0xa8
+;;   78: ldr     x14, [x2, #0x68]
+;;       ldr     x0, [x2, #0x60]
+;;       mov     x15, #0
+;;       add     x0, x0, w4, uxtw
+;;       mov     x1, #0xffff0000
+;;       add     x0, x0, x1
+;;       cmp     x13, x14
+;;       csel    x15, x15, x0, hi
+;;       csdb
+;;       ldr     w2, [x15]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   a8: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..298b807e54ad
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x9, [x2, #0x68]
+;;       ldr     x10, [x2, #0x60]
+;;       mov     w11, w4
+;;       mov     x12, #0
+;;       add     x10, x10, w4, uxtw
+;;       cmp     x11, x9
+;;       csel    x10, x12, x10, hs
+;;       csdb
+;;       strb    w5, [x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x9, [x2, #0x68]
+;;       ldr     x10, [x2, #0x60]
+;;       mov     w11, w4
+;;       mov     x12, #0
+;;       add     x10, x10, w4, uxtw
+;;       cmp     x11, x9
+;;       csel    x10, x12, x10, hs
+;;       csdb
+;;       ldrb    w2, [x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..1b56a34567e7
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x14, [x2, #0x68]
+;;       ldr     x13, [x2, #0x60]
+;;       mov     w12, w4
+;;       mov     x15, #0x1001
+;;       sub     x14, x14, x15
+;;       mov     x15, #0
+;;       add     x13, x13, w4, uxtw
+;;       add     x13, x13, #1, lsl #12
+;;       cmp     x12, x14
+;;       csel    x13, x15, x13, hi
+;;       csdb
+;;       strb    w5, [x13]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x14, [x2, #0x68]
+;;       ldr     x13, [x2, #0x60]
+;;       mov     w12, w4
+;;       mov     x15, #0x1001
+;;       sub     x14, x14, x15
+;;       mov     x15, #0
+;;       add     x13, x13, w4, uxtw
+;;       add     x13, x13, #1, lsl #12
+;;       cmp     x12, x14
+;;       csel    x13, x15, x13, hi
+;;       csdb
+;;       ldrb    w2, [x13]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..5e741a7e7ee1
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w13, w4
+;;       mov     w14, #-0xffff
+;;       adds    x13, x13, x14
+;;       b.hs    #0x48
+;;   18: ldr     x14, [x2, #0x68]
+;;       ldr     x0, [x2, #0x60]
+;;       mov     x15, #0
+;;       add     x0, x0, w4, uxtw
+;;       mov     x1, #0xffff0000
+;;       add     x0, x0, x1
+;;       cmp     x13, x14
+;;       csel    x15, x15, x0, hi
+;;       csdb
+;;       strb    w5, [x15]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   48: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w13, w4
+;;       mov     w14, #-0xffff
+;;       adds    x13, x13, x14
+;;       b.hs    #0xa8
+;;   78: ldr     x14, [x2, #0x68]
+;;       ldr     x0, [x2, #0x60]
+;;       mov     x15, #0
+;;       add     x0, x0, w4, uxtw
+;;       mov     x1, #0xffff0000
+;;       add     x0, x0, x1
+;;       cmp     x13, x14
+;;       csel    x15, x15, x0, hi
+;;       csdb
+;;       ldrb    w2, [x15]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   a8: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..e2f7e0183761
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x68]
+;;       mov     w7, w4
+;;       cmp     x7, x6
+;;       b.hi    #0x28
+;;   18: ldr     x8, [x2, #0x60]
+;;       str     w5, [x8, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   28: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x68]
+;;       mov     w7, w4
+;;       cmp     x7, x6
+;;       b.hi    #0x68
+;;   58: ldr     x8, [x2, #0x60]
+;;       ldr     w2, [x8, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   68: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..8971cb9073af
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x7, [x2, #0x68]
+;;       mov     w8, w4
+;;       cmp     x8, x7
+;;       b.hi    #0x2c
+;;   18: ldr     x9, [x2, #0x60]
+;;       add     x9, x9, #1, lsl #12
+;;       str     w5, [x9, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   2c: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x7, [x2, #0x68]
+;;       mov     w8, w4
+;;       cmp     x8, x7
+;;       b.hi    #0x6c
+;;   58: ldr     x9, [x2, #0x60]
+;;       add     x8, x9, #1, lsl #12
+;;       ldr     w2, [x8, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   6c: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..a1dbf391c7c0
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x8, [x2, #0x68]
+;;       mov     w9, w4
+;;       cmp     x9, x8
+;;       b.hi    #0x30
+;;   18: ldr     x10, [x2, #0x60]
+;;       add     x10, x10, w4, uxtw
+;;       mov     x11, #0xffff0000
+;;       str     w5, [x10, x11]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   30: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x8, [x2, #0x68]
+;;       mov     w9, w4
+;;       cmp     x9, x8
+;;       b.hi    #0x70
+;;   58: ldr     x10, [x2, #0x60]
+;;       add     x10, x10, w4, uxtw
+;;       mov     x11, #0xffff0000
+;;       ldr     w2, [x10, x11]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   70: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..df845666261a
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x68]
+;;       mov     w7, w4
+;;       cmp     x7, x6
+;;       b.hs    #0x28
+;;   18: ldr     x8, [x2, #0x60]
+;;       strb    w5, [x8, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   28: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x68]
+;;       mov     w7, w4
+;;       cmp     x7, x6
+;;       b.hs    #0x68
+;;   58: ldr     x8, [x2, #0x60]
+;;       ldrb    w2, [x8, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   68: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..8e9dc7990cbb
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x7, [x2, #0x68]
+;;       mov     w8, w4
+;;       cmp     x8, x7
+;;       b.hi    #0x2c
+;;   18: ldr     x9, [x2, #0x60]
+;;       add     x9, x9, #1, lsl #12
+;;       strb    w5, [x9, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   2c: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x7, [x2, #0x68]
+;;       mov     w8, w4
+;;       cmp     x8, x7
+;;       b.hi    #0x6c
+;;   58: ldr     x9, [x2, #0x60]
+;;       add     x8, x9, #1, lsl #12
+;;       ldrb    w2, [x8, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   6c: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..6aa6868cf2d1
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x8, [x2, #0x68]
+;;       mov     w9, w4
+;;       cmp     x9, x8
+;;       b.hi    #0x30
+;;   18: ldr     x10, [x2, #0x60]
+;;       add     x10, x10, w4, uxtw
+;;       mov     x11, #0xffff0000
+;;       strb    w5, [x10, x11]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   30: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x8, [x2, #0x68]
+;;       mov     w9, w4
+;;       cmp     x9, x8
+;;       b.hi    #0x70
+;;   58: ldr     x10, [x2, #0x60]
+;;       add     x10, x10, w4, uxtw
+;;       mov     x11, #0xffff0000
+;;       ldrb    w2, [x10, x11]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   70: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..f3903541f550
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x9, [x2, #0x68]
+;;       ldr     x10, [x2, #0x60]
+;;       mov     w11, w4
+;;       mov     x12, #0
+;;       add     x10, x10, w4, uxtw
+;;       cmp     x11, x9
+;;       csel    x10, x12, x10, hi
+;;       csdb
+;;       str     w5, [x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x9, [x2, #0x68]
+;;       ldr     x10, [x2, #0x60]
+;;       mov     w11, w4
+;;       mov     x12, #0
+;;       add     x10, x10, w4, uxtw
+;;       cmp     x11, x9
+;;       csel    x10, x12, x10, hi
+;;       csdb
+;;       ldr     w2, [x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..9686f819ac41
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x10, [x2, #0x68]
+;;       ldr     x13, [x2, #0x60]
+;;       mov     w11, w4
+;;       mov     x12, #0
+;;       add     x13, x13, w4, uxtw
+;;       add     x13, x13, #1, lsl #12
+;;       cmp     x11, x10
+;;       csel    x11, x12, x13, hi
+;;       csdb
+;;       str     w5, [x11]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x10, [x2, #0x68]
+;;       ldr     x13, [x2, #0x60]
+;;       mov     w11, w4
+;;       mov     x12, #0
+;;       add     x13, x13, w4, uxtw
+;;       add     x13, x13, #1, lsl #12
+;;       cmp     x11, x10
+;;       csel    x11, x12, x13, hi
+;;       csdb
+;;       ldr     w2, [x11]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..754ce447cec7
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,53 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x11, [x2, #0x68]
+;;       ldr     x14, [x2, #0x60]
+;;       mov     w12, w4
+;;       mov     x13, #0
+;;       add     x14, x14, w4, uxtw
+;;       mov     x15, #0xffff0000
+;;       add     x14, x14, x15
+;;       cmp     x12, x11
+;;       csel    x12, x13, x14, hi
+;;       csdb
+;;       str     w5, [x12]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x11, [x2, #0x68]
+;;       ldr     x14, [x2, #0x60]
+;;       mov     w12, w4
+;;       mov     x13, #0
+;;       add     x14, x14, w4, uxtw
+;;       mov     x15, #0xffff0000
+;;       add     x14, x14, x15
+;;       cmp     x12, x11
+;;       csel    x12, x13, x14, hi
+;;       csdb
+;;       ldr     w2, [x12]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..721814701f2d
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x9, [x2, #0x68]
+;;       ldr     x10, [x2, #0x60]
+;;       mov     w11, w4
+;;       mov     x12, #0
+;;       add     x10, x10, w4, uxtw
+;;       cmp     x11, x9
+;;       csel    x10, x12, x10, hs
+;;       csdb
+;;       strb    w5, [x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x9, [x2, #0x68]
+;;       ldr     x10, [x2, #0x60]
+;;       mov     w11, w4
+;;       mov     x12, #0
+;;       add     x10, x10, w4, uxtw
+;;       cmp     x11, x9
+;;       csel    x10, x12, x10, hs
+;;       csdb
+;;       ldrb    w2, [x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..d309f16cf7df
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x10, [x2, #0x68]
+;;       ldr     x13, [x2, #0x60]
+;;       mov     w11, w4
+;;       mov     x12, #0
+;;       add     x13, x13, w4, uxtw
+;;       add     x13, x13, #1, lsl #12
+;;       cmp     x11, x10
+;;       csel    x11, x12, x13, hi
+;;       csdb
+;;       strb    w5, [x11]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x10, [x2, #0x68]
+;;       ldr     x13, [x2, #0x60]
+;;       mov     w11, w4
+;;       mov     x12, #0
+;;       add     x13, x13, w4, uxtw
+;;       add     x13, x13, #1, lsl #12
+;;       cmp     x11, x10
+;;       csel    x11, x12, x13, hi
+;;       csdb
+;;       ldrb    w2, [x11]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..9446be12e395
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,53 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x11, [x2, #0x68]
+;;       ldr     x14, [x2, #0x60]
+;;       mov     w12, w4
+;;       mov     x13, #0
+;;       add     x14, x14, w4, uxtw
+;;       mov     x15, #0xffff0000
+;;       add     x14, x14, x15
+;;       cmp     x12, x11
+;;       csel    x12, x13, x14, hi
+;;       csdb
+;;       strb    w5, [x12]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x11, [x2, #0x68]
+;;       ldr     x14, [x2, #0x60]
+;;       mov     w12, w4
+;;       mov     x13, #0
+;;       add     x14, x14, w4, uxtw
+;;       mov     x15, #0xffff0000
+;;       add     x14, x14, x15
+;;       cmp     x12, x11
+;;       csel    x12, x13, x14, hi
+;;       csdb
+;;       ldrb    w2, [x12]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..719549a9eb3a
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x68]
+;;       sub     x6, x6, #4
+;;       cmp     x4, x6
+;;       b.hi    #0x28
+;;   18: ldr     x8, [x2, #0x60]
+;;       str     w5, [x8, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   28: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x68]
+;;       sub     x6, x6, #4
+;;       cmp     x4, x6
+;;       b.hi    #0x68
+;;   58: ldr     x8, [x2, #0x60]
+;;       ldr     w2, [x8, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   68: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..da07acf2e9d5
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x8, [x2, #0x68]
+;;       mov     x9, #0x1004
+;;       sub     x8, x8, x9
+;;       cmp     x4, x8
+;;       b.hi    #0x30
+;;   1c: ldr     x10, [x2, #0x60]
+;;       add     x10, x10, #1, lsl #12
+;;       str     w5, [x10, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   30: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x8, [x2, #0x68]
+;;       mov     x9, #0x1004
+;;       sub     x8, x8, x9
+;;       cmp     x4, x8
+;;       b.hi    #0x70
+;;   5c: ldr     x10, [x2, #0x60]
+;;       add     x9, x10, #1, lsl #12
+;;       ldr     w2, [x9, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   70: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..5137953a1840
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w9, #-0xfffc
+;;       adds    x9, x4, x9
+;;       b.hs    #0x3c
+;;   14: ldr     x10, [x2, #0x68]
+;;       cmp     x9, x10
+;;       b.hi    #0x38
+;;   20: ldr     x12, [x2, #0x60]
+;;       add     x12, x12, x4
+;;       mov     x13, #0xffff0000
+;;       str     w5, [x12, x13]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   38: .byte   0x1f, 0xc1, 0x00, 0x00
+;;   3c: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w9, #-0xfffc
+;;       adds    x9, x4, x9
+;;       b.hs    #0x7c
+;;   54: ldr     x10, [x2, #0x68]
+;;       cmp     x9, x10
+;;       b.hi    #0x78
+;;   60: ldr     x12, [x2, #0x60]
+;;       add     x12, x12, x4
+;;       mov     x13, #0xffff0000
+;;       ldr     w2, [x12, x13]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   78: .byte   0x1f, 0xc1, 0x00, 0x00
+;;   7c: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..6670a6f858e3
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,43 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x68]
+;;       cmp     x4, x6
+;;       b.hs    #0x24
+;;   14: ldr     x7, [x2, #0x60]
+;;       strb    w5, [x7, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   24: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x5, [x2, #0x68]
+;;       cmp     x4, x5
+;;       b.hs    #0x64
+;;   54: ldr     x7, [x2, #0x60]
+;;       ldrb    w2, [x7, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   64: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..57708d062dbc
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x8, [x2, #0x68]
+;;       mov     x9, #0x1001
+;;       sub     x8, x8, x9
+;;       cmp     x4, x8
+;;       b.hi    #0x30
+;;   1c: ldr     x10, [x2, #0x60]
+;;       add     x10, x10, #1, lsl #12
+;;       strb    w5, [x10, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   30: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x8, [x2, #0x68]
+;;       mov     x9, #0x1001
+;;       sub     x8, x8, x9
+;;       cmp     x4, x8
+;;       b.hi    #0x70
+;;   5c: ldr     x10, [x2, #0x60]
+;;       add     x9, x10, #1, lsl #12
+;;       ldrb    w2, [x9, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   70: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..3178f60ec3b3
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w9, #-0xffff
+;;       adds    x9, x4, x9
+;;       b.hs    #0x3c
+;;   14: ldr     x10, [x2, #0x68]
+;;       cmp     x9, x10
+;;       b.hi    #0x38
+;;   20: ldr     x12, [x2, #0x60]
+;;       add     x12, x12, x4
+;;       mov     x13, #0xffff0000
+;;       strb    w5, [x12, x13]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   38: .byte   0x1f, 0xc1, 0x00, 0x00
+;;   3c: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w9, #-0xffff
+;;       adds    x9, x4, x9
+;;       b.hs    #0x7c
+;;   54: ldr     x10, [x2, #0x68]
+;;       cmp     x9, x10
+;;       b.hi    #0x78
+;;   60: ldr     x12, [x2, #0x60]
+;;       add     x12, x12, x4
+;;       mov     x13, #0xffff0000
+;;       ldrb    w2, [x12, x13]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   78: .byte   0x1f, 0xc1, 0x00, 0x00
+;;   7c: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..b80fd679d465
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x10, [x2, #0x68]
+;;       ldr     x9, [x2, #0x60]
+;;       sub     x10, x10, #4
+;;       mov     x11, #0
+;;       add     x9, x9, x4
+;;       cmp     x4, x10
+;;       csel    x10, x11, x9, hi
+;;       csdb
+;;       str     w5, [x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x10, [x2, #0x68]
+;;       ldr     x9, [x2, #0x60]
+;;       sub     x10, x10, #4
+;;       mov     x11, #0
+;;       add     x9, x9, x4
+;;       cmp     x4, x10
+;;       csel    x10, x11, x9, hi
+;;       csdb
+;;       ldr     w2, [x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..b138a1099b35
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,53 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x12, [x2, #0x68]
+;;       ldr     x11, [x2, #0x60]
+;;       mov     x13, #0x1004
+;;       sub     x12, x12, x13
+;;       mov     x13, #0
+;;       add     x11, x11, x4
+;;       add     x11, x11, #1, lsl #12
+;;       cmp     x4, x12
+;;       csel    x12, x13, x11, hi
+;;       csdb
+;;       str     w5, [x12]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x12, [x2, #0x68]
+;;       ldr     x11, [x2, #0x60]
+;;       mov     x13, #0x1004
+;;       sub     x12, x12, x13
+;;       mov     x13, #0
+;;       add     x11, x11, x4
+;;       add     x11, x11, #1, lsl #12
+;;       cmp     x4, x12
+;;       csel    x12, x13, x11, hi
+;;       csdb
+;;       ldr     w2, [x12]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..2d1c0ef7e1f9
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w12, #-0xfffc
+;;       adds    x12, x4, x12
+;;       b.hs    #0x44
+;;   14: ldr     x13, [x2, #0x68]
+;;       ldr     x15, [x2, #0x60]
+;;       mov     x14, #0
+;;       add     x15, x15, x4
+;;       mov     x0, #0xffff0000
+;;       add     x15, x15, x0
+;;       cmp     x12, x13
+;;       csel    x14, x14, x15, hi
+;;       csdb
+;;       str     w5, [x14]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   44: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w12, #-0xfffc
+;;       adds    x12, x4, x12
+;;       b.hs    #0xa4
+;;   74: ldr     x13, [x2, #0x68]
+;;       ldr     x15, [x2, #0x60]
+;;       mov     x14, #0
+;;       add     x15, x15, x4
+;;       mov     x0, #0xffff0000
+;;       add     x15, x15, x0
+;;       cmp     x12, x13
+;;       csel    x14, x14, x15, hi
+;;       csdb
+;;       ldr     w2, [x14]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   a4: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..9dd106e73189
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x8, [x2, #0x68]
+;;       ldr     x10, [x2, #0x60]
+;;       mov     x9, #0
+;;       add     x10, x10, x4
+;;       cmp     x4, x8
+;;       csel    x9, x9, x10, hs
+;;       csdb
+;;       strb    w5, [x9]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x8, [x2, #0x68]
+;;       ldr     x10, [x2, #0x60]
+;;       mov     x9, #0
+;;       add     x10, x10, x4
+;;       cmp     x4, x8
+;;       csel    x9, x9, x10, hs
+;;       csdb
+;;       ldrb    w2, [x9]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..4f4cb67b89d8
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,53 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x12, [x2, #0x68]
+;;       ldr     x11, [x2, #0x60]
+;;       mov     x13, #0x1001
+;;       sub     x12, x12, x13
+;;       mov     x13, #0
+;;       add     x11, x11, x4
+;;       add     x11, x11, #1, lsl #12
+;;       cmp     x4, x12
+;;       csel    x12, x13, x11, hi
+;;       csdb
+;;       strb    w5, [x12]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x12, [x2, #0x68]
+;;       ldr     x11, [x2, #0x60]
+;;       mov     x13, #0x1001
+;;       sub     x12, x12, x13
+;;       mov     x13, #0
+;;       add     x11, x11, x4
+;;       add     x11, x11, #1, lsl #12
+;;       cmp     x4, x12
+;;       csel    x12, x13, x11, hi
+;;       csdb
+;;       ldrb    w2, [x12]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..bbbe7259652e
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w12, #-0xffff
+;;       adds    x12, x4, x12
+;;       b.hs    #0x44
+;;   14: ldr     x13, [x2, #0x68]
+;;       ldr     x15, [x2, #0x60]
+;;       mov     x14, #0
+;;       add     x15, x15, x4
+;;       mov     x0, #0xffff0000
+;;       add     x15, x15, x0
+;;       cmp     x12, x13
+;;       csel    x14, x14, x15, hi
+;;       csdb
+;;       strb    w5, [x14]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   44: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w12, #-0xffff
+;;       adds    x12, x4, x12
+;;       b.hs    #0xa4
+;;   74: ldr     x13, [x2, #0x68]
+;;       ldr     x15, [x2, #0x60]
+;;       mov     x14, #0
+;;       add     x15, x15, x4
+;;       mov     x0, #0xffff0000
+;;       add     x15, x15, x0
+;;       cmp     x12, x13
+;;       csel    x14, x14, x15, hi
+;;       csdb
+;;       ldrb    w2, [x14]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   a4: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..cbec65031552
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,43 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x68]
+;;       cmp     x4, x6
+;;       b.hi    #0x24
+;;   14: ldr     x7, [x2, #0x60]
+;;       str     w5, [x7, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   24: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x5, [x2, #0x68]
+;;       cmp     x4, x5
+;;       b.hi    #0x64
+;;   54: ldr     x7, [x2, #0x60]
+;;       ldr     w2, [x7, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   64: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..f6a0ffbe85ff
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x68]
+;;       cmp     x4, x6
+;;       b.hi    #0x28
+;;   14: ldr     x8, [x2, #0x60]
+;;       add     x8, x8, #1, lsl #12
+;;       str     w5, [x8, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   28: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x68]
+;;       cmp     x4, x6
+;;       b.hi    #0x68
+;;   54: ldr     x8, [x2, #0x60]
+;;       add     x7, x8, #1, lsl #12
+;;       ldr     w2, [x7, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   68: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..c985ed4c19da
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x7, [x2, #0x68]
+;;       cmp     x4, x7
+;;       b.hi    #0x2c
+;;   14: ldr     x9, [x2, #0x60]
+;;       add     x9, x9, x4
+;;       mov     x10, #0xffff0000
+;;       str     w5, [x9, x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   2c: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x7, [x2, #0x68]
+;;       cmp     x4, x7
+;;       b.hi    #0x6c
+;;   54: ldr     x9, [x2, #0x60]
+;;       add     x9, x9, x4
+;;       mov     x10, #0xffff0000
+;;       ldr     w2, [x9, x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   6c: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..2687a25e3a30
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,43 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x68]
+;;       cmp     x4, x6
+;;       b.hs    #0x24
+;;   14: ldr     x7, [x2, #0x60]
+;;       strb    w5, [x7, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   24: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x5, [x2, #0x68]
+;;       cmp     x4, x5
+;;       b.hs    #0x64
+;;   54: ldr     x7, [x2, #0x60]
+;;       ldrb    w2, [x7, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   64: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..4ce6d128905d
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x68]
+;;       cmp     x4, x6
+;;       b.hi    #0x28
+;;   14: ldr     x8, [x2, #0x60]
+;;       add     x8, x8, #1, lsl #12
+;;       strb    w5, [x8, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   28: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x68]
+;;       cmp     x4, x6
+;;       b.hi    #0x68
+;;   54: ldr     x8, [x2, #0x60]
+;;       add     x7, x8, #1, lsl #12
+;;       ldrb    w2, [x7, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   68: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..df6ce52da6b8
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x7, [x2, #0x68]
+;;       cmp     x4, x7
+;;       b.hi    #0x2c
+;;   14: ldr     x9, [x2, #0x60]
+;;       add     x9, x9, x4
+;;       mov     x10, #0xffff0000
+;;       strb    w5, [x9, x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   2c: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x7, [x2, #0x68]
+;;       cmp     x4, x7
+;;       b.hi    #0x6c
+;;   54: ldr     x9, [x2, #0x60]
+;;       add     x9, x9, x4
+;;       mov     x10, #0xffff0000
+;;       ldrb    w2, [x9, x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   6c: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..490d79313b09
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x8, [x2, #0x68]
+;;       ldr     x10, [x2, #0x60]
+;;       mov     x9, #0
+;;       add     x10, x10, x4
+;;       cmp     x4, x8
+;;       csel    x9, x9, x10, hi
+;;       csdb
+;;       str     w5, [x9]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x8, [x2, #0x68]
+;;       ldr     x10, [x2, #0x60]
+;;       mov     x9, #0
+;;       add     x10, x10, x4
+;;       cmp     x4, x8
+;;       csel    x9, x9, x10, hi
+;;       csdb
+;;       ldr     w2, [x9]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..5b3596475a7b
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x9, [x2, #0x68]
+;;       ldr     x11, [x2, #0x60]
+;;       mov     x10, #0
+;;       add     x11, x11, x4
+;;       add     x11, x11, #1, lsl #12
+;;       cmp     x4, x9
+;;       csel    x10, x10, x11, hi
+;;       csdb
+;;       str     w5, [x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x9, [x2, #0x68]
+;;       ldr     x11, [x2, #0x60]
+;;       mov     x10, #0
+;;       add     x11, x11, x4
+;;       add     x11, x11, #1, lsl #12
+;;       cmp     x4, x9
+;;       csel    x10, x10, x11, hi
+;;       csdb
+;;       ldr     w2, [x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..531779ba6151
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x10, [x2, #0x68]
+;;       ldr     x12, [x2, #0x60]
+;;       mov     x11, #0
+;;       add     x12, x12, x4
+;;       mov     x13, #0xffff0000
+;;       add     x12, x12, x13
+;;       cmp     x4, x10
+;;       csel    x11, x11, x12, hi
+;;       csdb
+;;       str     w5, [x11]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x10, [x2, #0x68]
+;;       ldr     x12, [x2, #0x60]
+;;       mov     x11, #0
+;;       add     x12, x12, x4
+;;       mov     x13, #0xffff0000
+;;       add     x12, x12, x13
+;;       cmp     x4, x10
+;;       csel    x11, x11, x12, hi
+;;       csdb
+;;       ldr     w2, [x11]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..8ca435057a07
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x8, [x2, #0x68]
+;;       ldr     x10, [x2, #0x60]
+;;       mov     x9, #0
+;;       add     x10, x10, x4
+;;       cmp     x4, x8
+;;       csel    x9, x9, x10, hs
+;;       csdb
+;;       strb    w5, [x9]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x8, [x2, #0x68]
+;;       ldr     x10, [x2, #0x60]
+;;       mov     x9, #0
+;;       add     x10, x10, x4
+;;       cmp     x4, x8
+;;       csel    x9, x9, x10, hs
+;;       csdb
+;;       ldrb    w2, [x9]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..6860cd7a43ef
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x9, [x2, #0x68]
+;;       ldr     x11, [x2, #0x60]
+;;       mov     x10, #0
+;;       add     x11, x11, x4
+;;       add     x11, x11, #1, lsl #12
+;;       cmp     x4, x9
+;;       csel    x10, x10, x11, hi
+;;       csdb
+;;       strb    w5, [x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x9, [x2, #0x68]
+;;       ldr     x11, [x2, #0x60]
+;;       mov     x10, #0
+;;       add     x11, x11, x4
+;;       add     x11, x11, #1, lsl #12
+;;       cmp     x4, x9
+;;       csel    x10, x10, x11, hi
+;;       csdb
+;;       ldrb    w2, [x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..1d6ace91cb87
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x10, [x2, #0x68]
+;;       ldr     x12, [x2, #0x60]
+;;       mov     x11, #0
+;;       add     x12, x12, x4
+;;       mov     x13, #0xffff0000
+;;       add     x12, x12, x13
+;;       cmp     x4, x10
+;;       csel    x11, x11, x12, hi
+;;       csdb
+;;       strb    w5, [x11]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x10, [x2, #0x68]
+;;       ldr     x12, [x2, #0x60]
+;;       mov     x11, #0
+;;       add     x12, x12, x4
+;;       mov     x13, #0xffff0000
+;;       add     x12, x12, x13
+;;       cmp     x4, x10
+;;       csel    x11, x11, x12, hi
+;;       csdb
+;;       ldrb    w2, [x11]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..5b802801ed8b
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w6, w4
+;;       orr     x7, xzr, #0xfffffffc
+;;       cmp     x6, x7
+;;       b.hi    #0x28
+;;   18: ldr     x8, [x2, #0x60]
+;;       str     w5, [x8, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   28: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w6, w4
+;;       orr     x7, xzr, #0xfffffffc
+;;       cmp     x6, x7
+;;       b.hi    #0x68
+;;   58: ldr     x8, [x2, #0x60]
+;;       ldr     w2, [x8, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   68: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..7fb2fe9e27ce
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w7, w4
+;;       mov     w8, #-0x1004
+;;       cmp     x7, x8
+;;       b.hi    #0x2c
+;;   18: ldr     x9, [x2, #0x60]
+;;       add     x9, x9, #1, lsl #12
+;;       str     w5, [x9, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   2c: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w7, w4
+;;       mov     w8, #-0x1004
+;;       cmp     x7, x8
+;;       b.hi    #0x6c
+;;   58: ldr     x9, [x2, #0x60]
+;;       add     x8, x9, #1, lsl #12
+;;       ldr     w2, [x8, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   6c: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..9232a441458f
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w8, w4
+;;       mov     x9, #0xfffc
+;;       cmp     x8, x9
+;;       b.hi    #0x30
+;;   18: ldr     x10, [x2, #0x60]
+;;       add     x10, x10, w4, uxtw
+;;       mov     x11, #0xffff0000
+;;       str     w5, [x10, x11]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   30: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w8, w4
+;;       mov     x9, #0xfffc
+;;       cmp     x8, x9
+;;       b.hi    #0x70
+;;   58: ldr     x10, [x2, #0x60]
+;;       add     x10, x10, w4, uxtw
+;;       mov     x11, #0xffff0000
+;;       ldr     w2, [x10, x11]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   70: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..bdf65c50b524
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,35 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x60]
+;;       strb    w5, [x6, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x5, [x2, #0x60]
+;;       ldrb    w2, [x5, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..6c4df5a797e2
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w7, w4
+;;       mov     w8, #-0x1001
+;;       cmp     x7, x8
+;;       b.hi    #0x2c
+;;   18: ldr     x9, [x2, #0x60]
+;;       add     x9, x9, #1, lsl #12
+;;       strb    w5, [x9, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   2c: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w7, w4
+;;       mov     w8, #-0x1001
+;;       cmp     x7, x8
+;;       b.hi    #0x6c
+;;   58: ldr     x9, [x2, #0x60]
+;;       add     x8, x9, #1, lsl #12
+;;       ldrb    w2, [x8, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   6c: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..6299a1f11fb8
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w8, w4
+;;       mov     x9, #0xffff
+;;       cmp     x8, x9
+;;       b.hi    #0x30
+;;   18: ldr     x10, [x2, #0x60]
+;;       add     x10, x10, w4, uxtw
+;;       mov     x11, #0xffff0000
+;;       strb    w5, [x10, x11]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   30: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w8, w4
+;;       mov     x9, #0xffff
+;;       cmp     x8, x9
+;;       b.hi    #0x70
+;;   58: ldr     x10, [x2, #0x60]
+;;       add     x10, x10, w4, uxtw
+;;       mov     x11, #0xffff0000
+;;       ldrb    w2, [x10, x11]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   70: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..2a2f42d13f2e
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w9, w4
+;;       mov     x10, #0
+;;       ldr     x11, [x2, #0x60]
+;;       add     x11, x11, w4, uxtw
+;;       orr     x8, xzr, #0xfffffffc
+;;       cmp     x9, x8
+;;       csel    x11, x10, x11, hi
+;;       csdb
+;;       str     w5, [x11]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w9, w4
+;;       mov     x10, #0
+;;       ldr     x11, [x2, #0x60]
+;;       add     x11, x11, w4, uxtw
+;;       orr     x8, xzr, #0xfffffffc
+;;       cmp     x9, x8
+;;       csel    x11, x10, x11, hi
+;;       csdb
+;;       ldr     w2, [x11]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..1ad46aa95d77
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w10, w4
+;;       mov     x11, #0
+;;       ldr     x12, [x2, #0x60]
+;;       add     x12, x12, w4, uxtw
+;;       add     x12, x12, #1, lsl #12
+;;       mov     w9, #-0x1004
+;;       cmp     x10, x9
+;;       csel    x12, x11, x12, hi
+;;       csdb
+;;       str     w5, [x12]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w10, w4
+;;       mov     x11, #0
+;;       ldr     x12, [x2, #0x60]
+;;       add     x12, x12, w4, uxtw
+;;       add     x12, x12, #1, lsl #12
+;;       mov     w9, #-0x1004
+;;       cmp     x10, x9
+;;       csel    x12, x11, x12, hi
+;;       csdb
+;;       ldr     w2, [x12]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..a99f48bbd7a3
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,53 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w11, w4
+;;       mov     x12, #0
+;;       ldr     x13, [x2, #0x60]
+;;       add     x13, x13, w4, uxtw
+;;       mov     x14, #0xffff0000
+;;       add     x13, x13, x14
+;;       mov     x10, #0xfffc
+;;       cmp     x11, x10
+;;       csel    x13, x12, x13, hi
+;;       csdb
+;;       str     w5, [x13]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w11, w4
+;;       mov     x12, #0
+;;       ldr     x13, [x2, #0x60]
+;;       add     x13, x13, w4, uxtw
+;;       mov     x14, #0xffff0000
+;;       add     x13, x13, x14
+;;       mov     x10, #0xfffc
+;;       cmp     x11, x10
+;;       csel    x13, x12, x13, hi
+;;       csdb
+;;       ldr     w2, [x13]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..947cd23f62b3
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,35 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x60]
+;;       strb    w5, [x6, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x5, [x2, #0x60]
+;;       ldrb    w2, [x5, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..f559890ec540
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w10, w4
+;;       mov     x11, #0
+;;       ldr     x12, [x2, #0x60]
+;;       add     x12, x12, w4, uxtw
+;;       add     x12, x12, #1, lsl #12
+;;       mov     w9, #-0x1001
+;;       cmp     x10, x9
+;;       csel    x12, x11, x12, hi
+;;       csdb
+;;       strb    w5, [x12]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w10, w4
+;;       mov     x11, #0
+;;       ldr     x12, [x2, #0x60]
+;;       add     x12, x12, w4, uxtw
+;;       add     x12, x12, #1, lsl #12
+;;       mov     w9, #-0x1001
+;;       cmp     x10, x9
+;;       csel    x12, x11, x12, hi
+;;       csdb
+;;       ldrb    w2, [x12]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..01af96a488b6
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,53 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w11, w4
+;;       mov     x12, #0
+;;       ldr     x13, [x2, #0x60]
+;;       add     x13, x13, w4, uxtw
+;;       mov     x14, #0xffff0000
+;;       add     x13, x13, x14
+;;       mov     x10, #0xffff
+;;       cmp     x11, x10
+;;       csel    x13, x12, x13, hi
+;;       csdb
+;;       strb    w5, [x13]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w11, w4
+;;       mov     x12, #0
+;;       ldr     x13, [x2, #0x60]
+;;       add     x13, x13, w4, uxtw
+;;       mov     x14, #0xffff0000
+;;       add     x13, x13, x14
+;;       mov     x10, #0xffff
+;;       cmp     x11, x10
+;;       csel    x13, x12, x13, hi
+;;       csdb
+;;       ldrb    w2, [x13]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..52666478fc49
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,35 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x60]
+;;       str     w5, [x6, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x5, [x2, #0x60]
+;;       ldr     w2, [x5, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..a858346ba573
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,37 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x60]
+;;       add     x6, x6, #1, lsl #12
+;;       str     w5, [x6, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x5, [x2, #0x60]
+;;       add     x5, x5, #1, lsl #12
+;;       ldr     w2, [x5, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..7f62a9cd3614
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,39 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x60]
+;;       add     x6, x6, w4, uxtw
+;;       mov     x7, #0xffff0000
+;;       str     w5, [x6, x7]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x60]
+;;       add     x6, x6, w4, uxtw
+;;       mov     x7, #0xffff0000
+;;       ldr     w2, [x6, x7]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..87ff7c870f3a
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,35 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x60]
+;;       strb    w5, [x6, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x5, [x2, #0x60]
+;;       ldrb    w2, [x5, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..8aeab764d10e
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,37 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x60]
+;;       add     x6, x6, #1, lsl #12
+;;       strb    w5, [x6, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x5, [x2, #0x60]
+;;       add     x5, x5, #1, lsl #12
+;;       ldrb    w2, [x5, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..759f4302dea5
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,39 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x60]
+;;       add     x6, x6, w4, uxtw
+;;       mov     x7, #0xffff0000
+;;       strb    w5, [x6, x7]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x60]
+;;       add     x6, x6, w4, uxtw
+;;       mov     x7, #0xffff0000
+;;       ldrb    w2, [x6, x7]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..60743158f12e
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,35 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x60]
+;;       str     w5, [x6, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x5, [x2, #0x60]
+;;       ldr     w2, [x5, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..f9e85fe699c7
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,37 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x60]
+;;       add     x6, x6, #1, lsl #12
+;;       str     w5, [x6, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x5, [x2, #0x60]
+;;       add     x5, x5, #1, lsl #12
+;;       ldr     w2, [x5, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..45f6d856cfc8
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,39 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x60]
+;;       add     x6, x6, w4, uxtw
+;;       mov     x7, #0xffff0000
+;;       str     w5, [x6, x7]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x60]
+;;       add     x6, x6, w4, uxtw
+;;       mov     x7, #0xffff0000
+;;       ldr     w2, [x6, x7]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..43d6cf4d10a9
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,35 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x60]
+;;       strb    w5, [x6, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x5, [x2, #0x60]
+;;       ldrb    w2, [x5, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..23787e0a51d1
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,37 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x60]
+;;       add     x6, x6, #1, lsl #12
+;;       strb    w5, [x6, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x5, [x2, #0x60]
+;;       add     x5, x5, #1, lsl #12
+;;       ldrb    w2, [x5, w4, uxtw]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..5c317ff30e0f
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,39 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x60]
+;;       add     x6, x6, w4, uxtw
+;;       mov     x7, #0xffff0000
+;;       strb    w5, [x6, x7]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       ldr     x6, [x2, #0x60]
+;;       add     x6, x6, w4, uxtw
+;;       mov     x7, #0xffff0000
+;;       ldrb    w2, [x6, x7]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..184491cef2f0
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,43 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       orr     x6, xzr, #0xfffffffc
+;;       cmp     x4, x6
+;;       b.hi    #0x24
+;;   14: ldr     x7, [x2, #0x60]
+;;       str     w5, [x7, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   24: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       orr     x5, xzr, #0xfffffffc
+;;       cmp     x4, x5
+;;       b.hi    #0x64
+;;   54: ldr     x7, [x2, #0x60]
+;;       ldr     w2, [x7, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   64: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..ccc6f69c5b5c
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w6, #-0x1004
+;;       cmp     x4, x6
+;;       b.hi    #0x28
+;;   14: ldr     x8, [x2, #0x60]
+;;       add     x8, x8, #1, lsl #12
+;;       str     w5, [x8, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   28: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w6, #-0x1004
+;;       cmp     x4, x6
+;;       b.hi    #0x68
+;;   54: ldr     x8, [x2, #0x60]
+;;       add     x7, x8, #1, lsl #12
+;;       ldr     w2, [x7, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   68: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..41d79ee047e5
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x7, #0xfffc
+;;       cmp     x4, x7
+;;       b.hi    #0x2c
+;;   14: ldr     x9, [x2, #0x60]
+;;       add     x9, x9, x4
+;;       mov     x10, #0xffff0000
+;;       str     w5, [x9, x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   2c: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x7, #0xfffc
+;;       cmp     x4, x7
+;;       b.hi    #0x6c
+;;   54: ldr     x9, [x2, #0x60]
+;;       add     x9, x9, x4
+;;       mov     x10, #0xffff0000
+;;       ldr     w2, [x9, x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   6c: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..b60b895fea65
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,43 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       orr     x6, xzr, #0xffffffff
+;;       cmp     x4, x6
+;;       b.hi    #0x24
+;;   14: ldr     x7, [x2, #0x60]
+;;       strb    w5, [x7, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   24: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       orr     x5, xzr, #0xffffffff
+;;       cmp     x4, x5
+;;       b.hi    #0x64
+;;   54: ldr     x7, [x2, #0x60]
+;;       ldrb    w2, [x7, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   64: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..b56c8532c8b3
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w6, #-0x1001
+;;       cmp     x4, x6
+;;       b.hi    #0x28
+;;   14: ldr     x8, [x2, #0x60]
+;;       add     x8, x8, #1, lsl #12
+;;       strb    w5, [x8, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   28: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w6, #-0x1001
+;;       cmp     x4, x6
+;;       b.hi    #0x68
+;;   54: ldr     x8, [x2, #0x60]
+;;       add     x7, x8, #1, lsl #12
+;;       ldrb    w2, [x7, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   68: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..9f8c7969965e
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x7, #0xffff
+;;       cmp     x4, x7
+;;       b.hi    #0x2c
+;;   14: ldr     x9, [x2, #0x60]
+;;       add     x9, x9, x4
+;;       mov     x10, #0xffff0000
+;;       strb    w5, [x9, x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   2c: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x7, #0xffff
+;;       cmp     x4, x7
+;;       b.hi    #0x6c
+;;   54: ldr     x9, [x2, #0x60]
+;;       add     x9, x9, x4
+;;       mov     x10, #0xffff0000
+;;       ldrb    w2, [x9, x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   6c: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..e17df6ffa803
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x8, #0
+;;       ldr     x9, [x2, #0x60]
+;;       add     x9, x9, x4
+;;       orr     x7, xzr, #0xfffffffc
+;;       cmp     x4, x7
+;;       csel    x10, x8, x9, hi
+;;       csdb
+;;       str     w5, [x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x8, #0
+;;       ldr     x9, [x2, #0x60]
+;;       add     x9, x9, x4
+;;       orr     x7, xzr, #0xfffffffc
+;;       cmp     x4, x7
+;;       csel    x10, x8, x9, hi
+;;       csdb
+;;       ldr     w2, [x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..f187c41f8d9e
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x9, #0
+;;       ldr     x10, [x2, #0x60]
+;;       add     x10, x10, x4
+;;       add     x10, x10, #1, lsl #12
+;;       mov     w8, #-0x1004
+;;       cmp     x4, x8
+;;       csel    x11, x9, x10, hi
+;;       csdb
+;;       str     w5, [x11]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x9, #0
+;;       ldr     x10, [x2, #0x60]
+;;       add     x10, x10, x4
+;;       add     x10, x10, #1, lsl #12
+;;       mov     w8, #-0x1004
+;;       cmp     x4, x8
+;;       csel    x11, x9, x10, hi
+;;       csdb
+;;       ldr     w2, [x11]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..0cb2e2f96e40
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x10, #0
+;;       ldr     x11, [x2, #0x60]
+;;       add     x11, x11, x4
+;;       mov     x12, #0xffff0000
+;;       add     x11, x11, x12
+;;       mov     x9, #0xfffc
+;;       cmp     x4, x9
+;;       csel    x12, x10, x11, hi
+;;       csdb
+;;       str     w5, [x12]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x10, #0
+;;       ldr     x11, [x2, #0x60]
+;;       add     x11, x11, x4
+;;       mov     x12, #0xffff0000
+;;       add     x11, x11, x12
+;;       mov     x9, #0xfffc
+;;       cmp     x4, x9
+;;       csel    x12, x10, x11, hi
+;;       csdb
+;;       ldr     w2, [x12]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..f656c7e15176
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x8, #0
+;;       ldr     x9, [x2, #0x60]
+;;       add     x9, x9, x4
+;;       orr     x7, xzr, #0xffffffff
+;;       cmp     x4, x7
+;;       csel    x10, x8, x9, hi
+;;       csdb
+;;       strb    w5, [x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x8, #0
+;;       ldr     x9, [x2, #0x60]
+;;       add     x9, x9, x4
+;;       orr     x7, xzr, #0xffffffff
+;;       cmp     x4, x7
+;;       csel    x10, x8, x9, hi
+;;       csdb
+;;       ldrb    w2, [x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..0dab697bc75d
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x9, #0
+;;       ldr     x10, [x2, #0x60]
+;;       add     x10, x10, x4
+;;       add     x10, x10, #1, lsl #12
+;;       mov     w8, #-0x1001
+;;       cmp     x4, x8
+;;       csel    x11, x9, x10, hi
+;;       csdb
+;;       strb    w5, [x11]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x9, #0
+;;       ldr     x10, [x2, #0x60]
+;;       add     x10, x10, x4
+;;       add     x10, x10, #1, lsl #12
+;;       mov     w8, #-0x1001
+;;       cmp     x4, x8
+;;       csel    x11, x9, x10, hi
+;;       csdb
+;;       ldrb    w2, [x11]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..9710e552d1f4
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x10, #0
+;;       ldr     x11, [x2, #0x60]
+;;       add     x11, x11, x4
+;;       mov     x12, #0xffff0000
+;;       add     x11, x11, x12
+;;       mov     x9, #0xffff
+;;       cmp     x4, x9
+;;       csel    x12, x10, x11, hi
+;;       csdb
+;;       strb    w5, [x12]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x10, #0
+;;       ldr     x11, [x2, #0x60]
+;;       add     x11, x11, x4
+;;       mov     x12, #0xffff0000
+;;       add     x11, x11, x12
+;;       mov     x9, #0xffff
+;;       cmp     x4, x9
+;;       csel    x12, x10, x11, hi
+;;       csdb
+;;       ldrb    w2, [x12]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..fe0d3c54c708
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,43 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       orr     x6, xzr, #0xfffffffc
+;;       cmp     x4, x6
+;;       b.hi    #0x24
+;;   14: ldr     x7, [x2, #0x60]
+;;       str     w5, [x7, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   24: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       orr     x5, xzr, #0xfffffffc
+;;       cmp     x4, x5
+;;       b.hi    #0x64
+;;   54: ldr     x7, [x2, #0x60]
+;;       ldr     w2, [x7, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   64: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..937a8fa6c0e0
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w6, #-0x1004
+;;       cmp     x4, x6
+;;       b.hi    #0x28
+;;   14: ldr     x8, [x2, #0x60]
+;;       add     x8, x8, #1, lsl #12
+;;       str     w5, [x8, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   28: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w6, #-0x1004
+;;       cmp     x4, x6
+;;       b.hi    #0x68
+;;   54: ldr     x8, [x2, #0x60]
+;;       add     x7, x8, #1, lsl #12
+;;       ldr     w2, [x7, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   68: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..8ec2010aea62
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x7, #0xfffc
+;;       cmp     x4, x7
+;;       b.hi    #0x2c
+;;   14: ldr     x9, [x2, #0x60]
+;;       add     x9, x9, x4
+;;       mov     x10, #0xffff0000
+;;       str     w5, [x9, x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   2c: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x7, #0xfffc
+;;       cmp     x4, x7
+;;       b.hi    #0x6c
+;;   54: ldr     x9, [x2, #0x60]
+;;       add     x9, x9, x4
+;;       mov     x10, #0xffff0000
+;;       ldr     w2, [x9, x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   6c: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..3d6de06ee44c
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,43 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       orr     x6, xzr, #0xffffffff
+;;       cmp     x4, x6
+;;       b.hi    #0x24
+;;   14: ldr     x7, [x2, #0x60]
+;;       strb    w5, [x7, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   24: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       orr     x5, xzr, #0xffffffff
+;;       cmp     x4, x5
+;;       b.hi    #0x64
+;;   54: ldr     x7, [x2, #0x60]
+;;       ldrb    w2, [x7, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   64: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..f30f403d854c
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w6, #-0x1001
+;;       cmp     x4, x6
+;;       b.hi    #0x28
+;;   14: ldr     x8, [x2, #0x60]
+;;       add     x8, x8, #1, lsl #12
+;;       strb    w5, [x8, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   28: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     w6, #-0x1001
+;;       cmp     x4, x6
+;;       b.hi    #0x68
+;;   54: ldr     x8, [x2, #0x60]
+;;       add     x7, x8, #1, lsl #12
+;;       ldrb    w2, [x7, x4]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   68: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..cd35f5efd9fd
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x7, #0xffff
+;;       cmp     x4, x7
+;;       b.hi    #0x2c
+;;   14: ldr     x9, [x2, #0x60]
+;;       add     x9, x9, x4
+;;       mov     x10, #0xffff0000
+;;       strb    w5, [x9, x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   2c: .byte   0x1f, 0xc1, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x7, #0xffff
+;;       cmp     x4, x7
+;;       b.hi    #0x6c
+;;   54: ldr     x9, [x2, #0x60]
+;;       add     x9, x9, x4
+;;       mov     x10, #0xffff0000
+;;       ldrb    w2, [x9, x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;   6c: .byte   0x1f, 0xc1, 0x00, 0x00
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..a379138cade4
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x8, #0
+;;       ldr     x9, [x2, #0x60]
+;;       add     x9, x9, x4
+;;       orr     x7, xzr, #0xfffffffc
+;;       cmp     x4, x7
+;;       csel    x10, x8, x9, hi
+;;       csdb
+;;       str     w5, [x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x8, #0
+;;       ldr     x9, [x2, #0x60]
+;;       add     x9, x9, x4
+;;       orr     x7, xzr, #0xfffffffc
+;;       cmp     x4, x7
+;;       csel    x10, x8, x9, hi
+;;       csdb
+;;       ldr     w2, [x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..dc3c83021c0c
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x9, #0
+;;       ldr     x10, [x2, #0x60]
+;;       add     x10, x10, x4
+;;       add     x10, x10, #1, lsl #12
+;;       mov     w8, #-0x1004
+;;       cmp     x4, x8
+;;       csel    x11, x9, x10, hi
+;;       csdb
+;;       str     w5, [x11]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x9, #0
+;;       ldr     x10, [x2, #0x60]
+;;       add     x10, x10, x4
+;;       add     x10, x10, #1, lsl #12
+;;       mov     w8, #-0x1004
+;;       cmp     x4, x8
+;;       csel    x11, x9, x10, hi
+;;       csdb
+;;       ldr     w2, [x11]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..a948473cb26f
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x10, #0
+;;       ldr     x11, [x2, #0x60]
+;;       add     x11, x11, x4
+;;       mov     x12, #0xffff0000
+;;       add     x11, x11, x12
+;;       mov     x9, #0xfffc
+;;       cmp     x4, x9
+;;       csel    x12, x10, x11, hi
+;;       csdb
+;;       str     w5, [x12]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x10, #0
+;;       ldr     x11, [x2, #0x60]
+;;       add     x11, x11, x4
+;;       mov     x12, #0xffff0000
+;;       add     x11, x11, x12
+;;       mov     x9, #0xfffc
+;;       cmp     x4, x9
+;;       csel    x12, x10, x11, hi
+;;       csdb
+;;       ldr     w2, [x12]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..3f286f6a28b1
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x8, #0
+;;       ldr     x9, [x2, #0x60]
+;;       add     x9, x9, x4
+;;       orr     x7, xzr, #0xffffffff
+;;       cmp     x4, x7
+;;       csel    x10, x8, x9, hi
+;;       csdb
+;;       strb    w5, [x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x8, #0
+;;       ldr     x9, [x2, #0x60]
+;;       add     x9, x9, x4
+;;       orr     x7, xzr, #0xffffffff
+;;       cmp     x4, x7
+;;       csel    x10, x8, x9, hi
+;;       csdb
+;;       ldrb    w2, [x10]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..218823a1d585
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x9, #0
+;;       ldr     x10, [x2, #0x60]
+;;       add     x10, x10, x4
+;;       add     x10, x10, #1, lsl #12
+;;       mov     w8, #-0x1001
+;;       cmp     x4, x8
+;;       csel    x11, x9, x10, hi
+;;       csdb
+;;       strb    w5, [x11]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x9, #0
+;;       ldr     x10, [x2, #0x60]
+;;       add     x10, x10, x4
+;;       add     x10, x10, #1, lsl #12
+;;       mov     w8, #-0x1001
+;;       cmp     x4, x8
+;;       csel    x11, x9, x10, hi
+;;       csdb
+;;       ldrb    w2, [x11]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..e2773393ad44
--- /dev/null
+++ b/tests/disas/load-store/aarch64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "aarch64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x10, #0
+;;       ldr     x11, [x2, #0x60]
+;;       add     x11, x11, x4
+;;       mov     x12, #0xffff0000
+;;       add     x11, x11, x12
+;;       mov     x9, #0xffff
+;;       cmp     x4, x9
+;;       csel    x12, x10, x11, hi
+;;       csdb
+;;       strb    w5, [x12]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x10, #0
+;;       ldr     x11, [x2, #0x60]
+;;       add     x11, x11, x4
+;;       mov     x12, #0xffff0000
+;;       add     x11, x11, x12
+;;       mov     x9, #0xffff
+;;       cmp     x4, x9
+;;       csel    x12, x10, x11, hi
+;;       csdb
+;;       ldrb    w2, [x12]
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..9110f19d688d
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,69 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = iconst.i64 4
+;; @0040                               v7 = isub v5, v6  ; v6 = 4
+;; @0040                               v8 = icmp ugt v4, v7
+;; @0040                               trapnz v8, heap_oob
+;; @0040                               v9 = global_value.i64 gv5
+;; @0040                               v10 = iadd v9, v4
+;; @0040                               store little heap v3, v10
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0048                               v4 = uextend.i64 v2
+;; @0048                               v5 = global_value.i64 gv4
+;; @0048                               v6 = iconst.i64 4
+;; @0048                               v7 = isub v5, v6  ; v6 = 4
+;; @0048                               v8 = icmp ugt v4, v7
+;; @0048                               trapnz v8, heap_oob
+;; @0048                               v9 = global_value.i64 gv5
+;; @0048                               v10 = iadd v9, v4
+;; @0048                               v11 = load.i32 little heap v10
+;; @004b                               jump block1(v11)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..541493266d2f
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,73 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = iconst.i64 4100
+;; @0040                               v7 = isub v5, v6  ; v6 = 4100
+;; @0040                               v8 = icmp ugt v4, v7
+;; @0040                               trapnz v8, heap_oob
+;; @0040                               v9 = global_value.i64 gv5
+;; @0040                               v10 = iadd v9, v4
+;; @0040                               v11 = iconst.i64 4096
+;; @0040                               v12 = iadd v10, v11  ; v11 = 4096
+;; @0040                               store little heap v3, v12
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0049                               v4 = uextend.i64 v2
+;; @0049                               v5 = global_value.i64 gv4
+;; @0049                               v6 = iconst.i64 4100
+;; @0049                               v7 = isub v5, v6  ; v6 = 4100
+;; @0049                               v8 = icmp ugt v4, v7
+;; @0049                               trapnz v8, heap_oob
+;; @0049                               v9 = global_value.i64 gv5
+;; @0049                               v10 = iadd v9, v4
+;; @0049                               v11 = iconst.i64 4096
+;; @0049                               v12 = iadd v10, v11  ; v11 = 4096
+;; @0049                               v13 = load.i32 little heap v12
+;; @004d                               jump block1(v13)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..13825e06b8e2
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,73 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = iconst.i64 0xffff_0004
+;; @0040                               v6 = uadd_overflow_trap v4, v5, heap_oob  ; v5 = 0xffff_0004
+;; @0040                               v7 = global_value.i64 gv4
+;; @0040                               v8 = icmp ugt v6, v7
+;; @0040                               trapnz v8, heap_oob
+;; @0040                               v9 = global_value.i64 gv5
+;; @0040                               v10 = iadd v9, v4
+;; @0040                               v11 = iconst.i64 0xffff_0000
+;; @0040                               v12 = iadd v10, v11  ; v11 = 0xffff_0000
+;; @0040                               store little heap v3, v12
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @004c                               v4 = uextend.i64 v2
+;; @004c                               v5 = iconst.i64 0xffff_0004
+;; @004c                               v6 = uadd_overflow_trap v4, v5, heap_oob  ; v5 = 0xffff_0004
+;; @004c                               v7 = global_value.i64 gv4
+;; @004c                               v8 = icmp ugt v6, v7
+;; @004c                               trapnz v8, heap_oob
+;; @004c                               v9 = global_value.i64 gv5
+;; @004c                               v10 = iadd v9, v4
+;; @004c                               v11 = iconst.i64 0xffff_0000
+;; @004c                               v12 = iadd v10, v11  ; v11 = 0xffff_0000
+;; @004c                               v13 = load.i32 little heap v12
+;; @0053                               jump block1(v13)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..3fdabff3fbde
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,65 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = icmp uge v4, v5
+;; @0040                               trapnz v6, heap_oob
+;; @0040                               v7 = global_value.i64 gv5
+;; @0040                               v8 = iadd v7, v4
+;; @0040                               istore8 little heap v3, v8
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0048                               v4 = uextend.i64 v2
+;; @0048                               v5 = global_value.i64 gv4
+;; @0048                               v6 = icmp uge v4, v5
+;; @0048                               trapnz v6, heap_oob
+;; @0048                               v7 = global_value.i64 gv5
+;; @0048                               v8 = iadd v7, v4
+;; @0048                               v9 = uload8.i32 little heap v8
+;; @004b                               jump block1(v9)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..ad10e3c9d395
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,73 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = iconst.i64 4097
+;; @0040                               v7 = isub v5, v6  ; v6 = 4097
+;; @0040                               v8 = icmp ugt v4, v7
+;; @0040                               trapnz v8, heap_oob
+;; @0040                               v9 = global_value.i64 gv5
+;; @0040                               v10 = iadd v9, v4
+;; @0040                               v11 = iconst.i64 4096
+;; @0040                               v12 = iadd v10, v11  ; v11 = 4096
+;; @0040                               istore8 little heap v3, v12
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0049                               v4 = uextend.i64 v2
+;; @0049                               v5 = global_value.i64 gv4
+;; @0049                               v6 = iconst.i64 4097
+;; @0049                               v7 = isub v5, v6  ; v6 = 4097
+;; @0049                               v8 = icmp ugt v4, v7
+;; @0049                               trapnz v8, heap_oob
+;; @0049                               v9 = global_value.i64 gv5
+;; @0049                               v10 = iadd v9, v4
+;; @0049                               v11 = iconst.i64 4096
+;; @0049                               v12 = iadd v10, v11  ; v11 = 4096
+;; @0049                               v13 = uload8.i32 little heap v12
+;; @004d                               jump block1(v13)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..7a44c8c0c043
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,73 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = iconst.i64 0xffff_0001
+;; @0040                               v6 = uadd_overflow_trap v4, v5, heap_oob  ; v5 = 0xffff_0001
+;; @0040                               v7 = global_value.i64 gv4
+;; @0040                               v8 = icmp ugt v6, v7
+;; @0040                               trapnz v8, heap_oob
+;; @0040                               v9 = global_value.i64 gv5
+;; @0040                               v10 = iadd v9, v4
+;; @0040                               v11 = iconst.i64 0xffff_0000
+;; @0040                               v12 = iadd v10, v11  ; v11 = 0xffff_0000
+;; @0040                               istore8 little heap v3, v12
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @004c                               v4 = uextend.i64 v2
+;; @004c                               v5 = iconst.i64 0xffff_0001
+;; @004c                               v6 = uadd_overflow_trap v4, v5, heap_oob  ; v5 = 0xffff_0001
+;; @004c                               v7 = global_value.i64 gv4
+;; @004c                               v8 = icmp ugt v6, v7
+;; @004c                               trapnz v8, heap_oob
+;; @004c                               v9 = global_value.i64 gv5
+;; @004c                               v10 = iadd v9, v4
+;; @004c                               v11 = iconst.i64 0xffff_0000
+;; @004c                               v12 = iadd v10, v11  ; v11 = 0xffff_0000
+;; @004c                               v13 = uload8.i32 little heap v12
+;; @0053                               jump block1(v13)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..4cc1826dff96
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,71 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = iconst.i64 4
+;; @0040                               v7 = isub v5, v6  ; v6 = 4
+;; @0040                               v8 = icmp ugt v4, v7
+;; @0040                               v9 = global_value.i64 gv5
+;; @0040                               v10 = iadd v9, v4
+;; @0040                               v11 = iconst.i64 0
+;; @0040                               v12 = select_spectre_guard v8, v11, v10  ; v11 = 0
+;; @0040                               store little heap v3, v12
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0048                               v4 = uextend.i64 v2
+;; @0048                               v5 = global_value.i64 gv4
+;; @0048                               v6 = iconst.i64 4
+;; @0048                               v7 = isub v5, v6  ; v6 = 4
+;; @0048                               v8 = icmp ugt v4, v7
+;; @0048                               v9 = global_value.i64 gv5
+;; @0048                               v10 = iadd v9, v4
+;; @0048                               v11 = iconst.i64 0
+;; @0048                               v12 = select_spectre_guard v8, v11, v10  ; v11 = 0
+;; @0048                               v13 = load.i32 little heap v12
+;; @004b                               jump block1(v13)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..43ce1df45bea
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,75 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = iconst.i64 4100
+;; @0040                               v7 = isub v5, v6  ; v6 = 4100
+;; @0040                               v8 = icmp ugt v4, v7
+;; @0040                               v9 = global_value.i64 gv5
+;; @0040                               v10 = iadd v9, v4
+;; @0040                               v11 = iconst.i64 4096
+;; @0040                               v12 = iadd v10, v11  ; v11 = 4096
+;; @0040                               v13 = iconst.i64 0
+;; @0040                               v14 = select_spectre_guard v8, v13, v12  ; v13 = 0
+;; @0040                               store little heap v3, v14
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0049                               v4 = uextend.i64 v2
+;; @0049                               v5 = global_value.i64 gv4
+;; @0049                               v6 = iconst.i64 4100
+;; @0049                               v7 = isub v5, v6  ; v6 = 4100
+;; @0049                               v8 = icmp ugt v4, v7
+;; @0049                               v9 = global_value.i64 gv5
+;; @0049                               v10 = iadd v9, v4
+;; @0049                               v11 = iconst.i64 4096
+;; @0049                               v12 = iadd v10, v11  ; v11 = 4096
+;; @0049                               v13 = iconst.i64 0
+;; @0049                               v14 = select_spectre_guard v8, v13, v12  ; v13 = 0
+;; @0049                               v15 = load.i32 little heap v14
+;; @004d                               jump block1(v15)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..f3c592fef8fa
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,75 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = iconst.i64 0xffff_0004
+;; @0040                               v6 = uadd_overflow_trap v4, v5, heap_oob  ; v5 = 0xffff_0004
+;; @0040                               v7 = global_value.i64 gv4
+;; @0040                               v8 = icmp ugt v6, v7
+;; @0040                               v9 = global_value.i64 gv5
+;; @0040                               v10 = iadd v9, v4
+;; @0040                               v11 = iconst.i64 0xffff_0000
+;; @0040                               v12 = iadd v10, v11  ; v11 = 0xffff_0000
+;; @0040                               v13 = iconst.i64 0
+;; @0040                               v14 = select_spectre_guard v8, v13, v12  ; v13 = 0
+;; @0040                               store little heap v3, v14
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @004c                               v4 = uextend.i64 v2
+;; @004c                               v5 = iconst.i64 0xffff_0004
+;; @004c                               v6 = uadd_overflow_trap v4, v5, heap_oob  ; v5 = 0xffff_0004
+;; @004c                               v7 = global_value.i64 gv4
+;; @004c                               v8 = icmp ugt v6, v7
+;; @004c                               v9 = global_value.i64 gv5
+;; @004c                               v10 = iadd v9, v4
+;; @004c                               v11 = iconst.i64 0xffff_0000
+;; @004c                               v12 = iadd v10, v11  ; v11 = 0xffff_0000
+;; @004c                               v13 = iconst.i64 0
+;; @004c                               v14 = select_spectre_guard v8, v13, v12  ; v13 = 0
+;; @004c                               v15 = load.i32 little heap v14
+;; @0053                               jump block1(v15)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..007d6ac4a6eb
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = icmp uge v4, v5
+;; @0040                               v7 = global_value.i64 gv5
+;; @0040                               v8 = iadd v7, v4
+;; @0040                               v9 = iconst.i64 0
+;; @0040                               v10 = select_spectre_guard v6, v9, v8  ; v9 = 0
+;; @0040                               istore8 little heap v3, v10
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0048                               v4 = uextend.i64 v2
+;; @0048                               v5 = global_value.i64 gv4
+;; @0048                               v6 = icmp uge v4, v5
+;; @0048                               v7 = global_value.i64 gv5
+;; @0048                               v8 = iadd v7, v4
+;; @0048                               v9 = iconst.i64 0
+;; @0048                               v10 = select_spectre_guard v6, v9, v8  ; v9 = 0
+;; @0048                               v11 = uload8.i32 little heap v10
+;; @004b                               jump block1(v11)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..0ad86c625ec1
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,75 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = iconst.i64 4097
+;; @0040                               v7 = isub v5, v6  ; v6 = 4097
+;; @0040                               v8 = icmp ugt v4, v7
+;; @0040                               v9 = global_value.i64 gv5
+;; @0040                               v10 = iadd v9, v4
+;; @0040                               v11 = iconst.i64 4096
+;; @0040                               v12 = iadd v10, v11  ; v11 = 4096
+;; @0040                               v13 = iconst.i64 0
+;; @0040                               v14 = select_spectre_guard v8, v13, v12  ; v13 = 0
+;; @0040                               istore8 little heap v3, v14
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0049                               v4 = uextend.i64 v2
+;; @0049                               v5 = global_value.i64 gv4
+;; @0049                               v6 = iconst.i64 4097
+;; @0049                               v7 = isub v5, v6  ; v6 = 4097
+;; @0049                               v8 = icmp ugt v4, v7
+;; @0049                               v9 = global_value.i64 gv5
+;; @0049                               v10 = iadd v9, v4
+;; @0049                               v11 = iconst.i64 4096
+;; @0049                               v12 = iadd v10, v11  ; v11 = 4096
+;; @0049                               v13 = iconst.i64 0
+;; @0049                               v14 = select_spectre_guard v8, v13, v12  ; v13 = 0
+;; @0049                               v15 = uload8.i32 little heap v14
+;; @004d                               jump block1(v15)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..a7fb24691d96
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,75 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = iconst.i64 0xffff_0001
+;; @0040                               v6 = uadd_overflow_trap v4, v5, heap_oob  ; v5 = 0xffff_0001
+;; @0040                               v7 = global_value.i64 gv4
+;; @0040                               v8 = icmp ugt v6, v7
+;; @0040                               v9 = global_value.i64 gv5
+;; @0040                               v10 = iadd v9, v4
+;; @0040                               v11 = iconst.i64 0xffff_0000
+;; @0040                               v12 = iadd v10, v11  ; v11 = 0xffff_0000
+;; @0040                               v13 = iconst.i64 0
+;; @0040                               v14 = select_spectre_guard v8, v13, v12  ; v13 = 0
+;; @0040                               istore8 little heap v3, v14
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @004c                               v4 = uextend.i64 v2
+;; @004c                               v5 = iconst.i64 0xffff_0001
+;; @004c                               v6 = uadd_overflow_trap v4, v5, heap_oob  ; v5 = 0xffff_0001
+;; @004c                               v7 = global_value.i64 gv4
+;; @004c                               v8 = icmp ugt v6, v7
+;; @004c                               v9 = global_value.i64 gv5
+;; @004c                               v10 = iadd v9, v4
+;; @004c                               v11 = iconst.i64 0xffff_0000
+;; @004c                               v12 = iadd v10, v11  ; v11 = 0xffff_0000
+;; @004c                               v13 = iconst.i64 0
+;; @004c                               v14 = select_spectre_guard v8, v13, v12  ; v13 = 0
+;; @004c                               v15 = uload8.i32 little heap v14
+;; @0053                               jump block1(v15)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..c9c519d65ae3
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,65 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = icmp ugt v4, v5
+;; @0040                               trapnz v6, heap_oob
+;; @0040                               v7 = global_value.i64 gv5
+;; @0040                               v8 = iadd v7, v4
+;; @0040                               store little heap v3, v8
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0048                               v4 = uextend.i64 v2
+;; @0048                               v5 = global_value.i64 gv4
+;; @0048                               v6 = icmp ugt v4, v5
+;; @0048                               trapnz v6, heap_oob
+;; @0048                               v7 = global_value.i64 gv5
+;; @0048                               v8 = iadd v7, v4
+;; @0048                               v9 = load.i32 little heap v8
+;; @004b                               jump block1(v9)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..da269c999092
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,69 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = icmp ugt v4, v5
+;; @0040                               trapnz v6, heap_oob
+;; @0040                               v7 = global_value.i64 gv5
+;; @0040                               v8 = iadd v7, v4
+;; @0040                               v9 = iconst.i64 4096
+;; @0040                               v10 = iadd v8, v9  ; v9 = 4096
+;; @0040                               store little heap v3, v10
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0049                               v4 = uextend.i64 v2
+;; @0049                               v5 = global_value.i64 gv4
+;; @0049                               v6 = icmp ugt v4, v5
+;; @0049                               trapnz v6, heap_oob
+;; @0049                               v7 = global_value.i64 gv5
+;; @0049                               v8 = iadd v7, v4
+;; @0049                               v9 = iconst.i64 4096
+;; @0049                               v10 = iadd v8, v9  ; v9 = 4096
+;; @0049                               v11 = load.i32 little heap v10
+;; @004d                               jump block1(v11)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..55fa529ec02a
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,69 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = icmp ugt v4, v5
+;; @0040                               trapnz v6, heap_oob
+;; @0040                               v7 = global_value.i64 gv5
+;; @0040                               v8 = iadd v7, v4
+;; @0040                               v9 = iconst.i64 0xffff_0000
+;; @0040                               v10 = iadd v8, v9  ; v9 = 0xffff_0000
+;; @0040                               store little heap v3, v10
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @004c                               v4 = uextend.i64 v2
+;; @004c                               v5 = global_value.i64 gv4
+;; @004c                               v6 = icmp ugt v4, v5
+;; @004c                               trapnz v6, heap_oob
+;; @004c                               v7 = global_value.i64 gv5
+;; @004c                               v8 = iadd v7, v4
+;; @004c                               v9 = iconst.i64 0xffff_0000
+;; @004c                               v10 = iadd v8, v9  ; v9 = 0xffff_0000
+;; @004c                               v11 = load.i32 little heap v10
+;; @0053                               jump block1(v11)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..4cd1d590c714
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,65 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = icmp uge v4, v5
+;; @0040                               trapnz v6, heap_oob
+;; @0040                               v7 = global_value.i64 gv5
+;; @0040                               v8 = iadd v7, v4
+;; @0040                               istore8 little heap v3, v8
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0048                               v4 = uextend.i64 v2
+;; @0048                               v5 = global_value.i64 gv4
+;; @0048                               v6 = icmp uge v4, v5
+;; @0048                               trapnz v6, heap_oob
+;; @0048                               v7 = global_value.i64 gv5
+;; @0048                               v8 = iadd v7, v4
+;; @0048                               v9 = uload8.i32 little heap v8
+;; @004b                               jump block1(v9)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..e895e2282613
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,69 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = icmp ugt v4, v5
+;; @0040                               trapnz v6, heap_oob
+;; @0040                               v7 = global_value.i64 gv5
+;; @0040                               v8 = iadd v7, v4
+;; @0040                               v9 = iconst.i64 4096
+;; @0040                               v10 = iadd v8, v9  ; v9 = 4096
+;; @0040                               istore8 little heap v3, v10
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0049                               v4 = uextend.i64 v2
+;; @0049                               v5 = global_value.i64 gv4
+;; @0049                               v6 = icmp ugt v4, v5
+;; @0049                               trapnz v6, heap_oob
+;; @0049                               v7 = global_value.i64 gv5
+;; @0049                               v8 = iadd v7, v4
+;; @0049                               v9 = iconst.i64 4096
+;; @0049                               v10 = iadd v8, v9  ; v9 = 4096
+;; @0049                               v11 = uload8.i32 little heap v10
+;; @004d                               jump block1(v11)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..4c39cd866194
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,69 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = icmp ugt v4, v5
+;; @0040                               trapnz v6, heap_oob
+;; @0040                               v7 = global_value.i64 gv5
+;; @0040                               v8 = iadd v7, v4
+;; @0040                               v9 = iconst.i64 0xffff_0000
+;; @0040                               v10 = iadd v8, v9  ; v9 = 0xffff_0000
+;; @0040                               istore8 little heap v3, v10
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @004c                               v4 = uextend.i64 v2
+;; @004c                               v5 = global_value.i64 gv4
+;; @004c                               v6 = icmp ugt v4, v5
+;; @004c                               trapnz v6, heap_oob
+;; @004c                               v7 = global_value.i64 gv5
+;; @004c                               v8 = iadd v7, v4
+;; @004c                               v9 = iconst.i64 0xffff_0000
+;; @004c                               v10 = iadd v8, v9  ; v9 = 0xffff_0000
+;; @004c                               v11 = uload8.i32 little heap v10
+;; @0053                               jump block1(v11)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..f176d795af19
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = icmp ugt v4, v5
+;; @0040                               v7 = global_value.i64 gv5
+;; @0040                               v8 = iadd v7, v4
+;; @0040                               v9 = iconst.i64 0
+;; @0040                               v10 = select_spectre_guard v6, v9, v8  ; v9 = 0
+;; @0040                               store little heap v3, v10
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0048                               v4 = uextend.i64 v2
+;; @0048                               v5 = global_value.i64 gv4
+;; @0048                               v6 = icmp ugt v4, v5
+;; @0048                               v7 = global_value.i64 gv5
+;; @0048                               v8 = iadd v7, v4
+;; @0048                               v9 = iconst.i64 0
+;; @0048                               v10 = select_spectre_guard v6, v9, v8  ; v9 = 0
+;; @0048                               v11 = load.i32 little heap v10
+;; @004b                               jump block1(v11)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..3ec0847ea518
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,71 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = icmp ugt v4, v5
+;; @0040                               v7 = global_value.i64 gv5
+;; @0040                               v8 = iadd v7, v4
+;; @0040                               v9 = iconst.i64 4096
+;; @0040                               v10 = iadd v8, v9  ; v9 = 4096
+;; @0040                               v11 = iconst.i64 0
+;; @0040                               v12 = select_spectre_guard v6, v11, v10  ; v11 = 0
+;; @0040                               store little heap v3, v12
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0049                               v4 = uextend.i64 v2
+;; @0049                               v5 = global_value.i64 gv4
+;; @0049                               v6 = icmp ugt v4, v5
+;; @0049                               v7 = global_value.i64 gv5
+;; @0049                               v8 = iadd v7, v4
+;; @0049                               v9 = iconst.i64 4096
+;; @0049                               v10 = iadd v8, v9  ; v9 = 4096
+;; @0049                               v11 = iconst.i64 0
+;; @0049                               v12 = select_spectre_guard v6, v11, v10  ; v11 = 0
+;; @0049                               v13 = load.i32 little heap v12
+;; @004d                               jump block1(v13)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..d45203ee56ea
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,71 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = icmp ugt v4, v5
+;; @0040                               v7 = global_value.i64 gv5
+;; @0040                               v8 = iadd v7, v4
+;; @0040                               v9 = iconst.i64 0xffff_0000
+;; @0040                               v10 = iadd v8, v9  ; v9 = 0xffff_0000
+;; @0040                               v11 = iconst.i64 0
+;; @0040                               v12 = select_spectre_guard v6, v11, v10  ; v11 = 0
+;; @0040                               store little heap v3, v12
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @004c                               v4 = uextend.i64 v2
+;; @004c                               v5 = global_value.i64 gv4
+;; @004c                               v6 = icmp ugt v4, v5
+;; @004c                               v7 = global_value.i64 gv5
+;; @004c                               v8 = iadd v7, v4
+;; @004c                               v9 = iconst.i64 0xffff_0000
+;; @004c                               v10 = iadd v8, v9  ; v9 = 0xffff_0000
+;; @004c                               v11 = iconst.i64 0
+;; @004c                               v12 = select_spectre_guard v6, v11, v10  ; v11 = 0
+;; @004c                               v13 = load.i32 little heap v12
+;; @0053                               jump block1(v13)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..0450ac481545
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = icmp uge v4, v5
+;; @0040                               v7 = global_value.i64 gv5
+;; @0040                               v8 = iadd v7, v4
+;; @0040                               v9 = iconst.i64 0
+;; @0040                               v10 = select_spectre_guard v6, v9, v8  ; v9 = 0
+;; @0040                               istore8 little heap v3, v10
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0048                               v4 = uextend.i64 v2
+;; @0048                               v5 = global_value.i64 gv4
+;; @0048                               v6 = icmp uge v4, v5
+;; @0048                               v7 = global_value.i64 gv5
+;; @0048                               v8 = iadd v7, v4
+;; @0048                               v9 = iconst.i64 0
+;; @0048                               v10 = select_spectre_guard v6, v9, v8  ; v9 = 0
+;; @0048                               v11 = uload8.i32 little heap v10
+;; @004b                               jump block1(v11)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..41d5b4fabb1c
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,71 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = icmp ugt v4, v5
+;; @0040                               v7 = global_value.i64 gv5
+;; @0040                               v8 = iadd v7, v4
+;; @0040                               v9 = iconst.i64 4096
+;; @0040                               v10 = iadd v8, v9  ; v9 = 4096
+;; @0040                               v11 = iconst.i64 0
+;; @0040                               v12 = select_spectre_guard v6, v11, v10  ; v11 = 0
+;; @0040                               istore8 little heap v3, v12
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0049                               v4 = uextend.i64 v2
+;; @0049                               v5 = global_value.i64 gv4
+;; @0049                               v6 = icmp ugt v4, v5
+;; @0049                               v7 = global_value.i64 gv5
+;; @0049                               v8 = iadd v7, v4
+;; @0049                               v9 = iconst.i64 4096
+;; @0049                               v10 = iadd v8, v9  ; v9 = 4096
+;; @0049                               v11 = iconst.i64 0
+;; @0049                               v12 = select_spectre_guard v6, v11, v10  ; v11 = 0
+;; @0049                               v13 = uload8.i32 little heap v12
+;; @004d                               jump block1(v13)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..808e8e59456c
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,71 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = icmp ugt v4, v5
+;; @0040                               v7 = global_value.i64 gv5
+;; @0040                               v8 = iadd v7, v4
+;; @0040                               v9 = iconst.i64 0xffff_0000
+;; @0040                               v10 = iadd v8, v9  ; v9 = 0xffff_0000
+;; @0040                               v11 = iconst.i64 0
+;; @0040                               v12 = select_spectre_guard v6, v11, v10  ; v11 = 0
+;; @0040                               istore8 little heap v3, v12
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @004c                               v4 = uextend.i64 v2
+;; @004c                               v5 = global_value.i64 gv4
+;; @004c                               v6 = icmp ugt v4, v5
+;; @004c                               v7 = global_value.i64 gv5
+;; @004c                               v8 = iadd v7, v4
+;; @004c                               v9 = iconst.i64 0xffff_0000
+;; @004c                               v10 = iadd v8, v9  ; v9 = 0xffff_0000
+;; @004c                               v11 = iconst.i64 0
+;; @004c                               v12 = select_spectre_guard v6, v11, v10  ; v11 = 0
+;; @004c                               v13 = uload8.i32 little heap v12
+;; @0053                               jump block1(v13)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..1242b79e7314
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = global_value.i64 gv4
+;; @0040                               v5 = iconst.i64 4
+;; @0040                               v6 = isub v4, v5  ; v5 = 4
+;; @0040                               v7 = icmp ugt v2, v6
+;; @0040                               trapnz v7, heap_oob
+;; @0040                               v8 = global_value.i64 gv5
+;; @0040                               v9 = iadd v8, v2
+;; @0040                               store little heap v3, v9
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0048                               v4 = global_value.i64 gv4
+;; @0048                               v5 = iconst.i64 4
+;; @0048                               v6 = isub v4, v5  ; v5 = 4
+;; @0048                               v7 = icmp ugt v2, v6
+;; @0048                               trapnz v7, heap_oob
+;; @0048                               v8 = global_value.i64 gv5
+;; @0048                               v9 = iadd v8, v2
+;; @0048                               v10 = load.i32 little heap v9
+;; @004b                               jump block1(v10)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..537444f8028d
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,71 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = global_value.i64 gv4
+;; @0040                               v5 = iconst.i64 4100
+;; @0040                               v6 = isub v4, v5  ; v5 = 4100
+;; @0040                               v7 = icmp ugt v2, v6
+;; @0040                               trapnz v7, heap_oob
+;; @0040                               v8 = global_value.i64 gv5
+;; @0040                               v9 = iadd v8, v2
+;; @0040                               v10 = iconst.i64 4096
+;; @0040                               v11 = iadd v9, v10  ; v10 = 4096
+;; @0040                               store little heap v3, v11
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0049                               v4 = global_value.i64 gv4
+;; @0049                               v5 = iconst.i64 4100
+;; @0049                               v6 = isub v4, v5  ; v5 = 4100
+;; @0049                               v7 = icmp ugt v2, v6
+;; @0049                               trapnz v7, heap_oob
+;; @0049                               v8 = global_value.i64 gv5
+;; @0049                               v9 = iadd v8, v2
+;; @0049                               v10 = iconst.i64 4096
+;; @0049                               v11 = iadd v9, v10  ; v10 = 4096
+;; @0049                               v12 = load.i32 little heap v11
+;; @004d                               jump block1(v12)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..93fb7439c3e1
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,71 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = iconst.i64 0xffff_0004
+;; @0040                               v5 = uadd_overflow_trap v2, v4, heap_oob  ; v4 = 0xffff_0004
+;; @0040                               v6 = global_value.i64 gv4
+;; @0040                               v7 = icmp ugt v5, v6
+;; @0040                               trapnz v7, heap_oob
+;; @0040                               v8 = global_value.i64 gv5
+;; @0040                               v9 = iadd v8, v2
+;; @0040                               v10 = iconst.i64 0xffff_0000
+;; @0040                               v11 = iadd v9, v10  ; v10 = 0xffff_0000
+;; @0040                               store little heap v3, v11
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @004c                               v4 = iconst.i64 0xffff_0004
+;; @004c                               v5 = uadd_overflow_trap v2, v4, heap_oob  ; v4 = 0xffff_0004
+;; @004c                               v6 = global_value.i64 gv4
+;; @004c                               v7 = icmp ugt v5, v6
+;; @004c                               trapnz v7, heap_oob
+;; @004c                               v8 = global_value.i64 gv5
+;; @004c                               v9 = iadd v8, v2
+;; @004c                               v10 = iconst.i64 0xffff_0000
+;; @004c                               v11 = iadd v9, v10  ; v10 = 0xffff_0000
+;; @004c                               v12 = load.i32 little heap v11
+;; @0053                               jump block1(v12)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..4b5f8327a982
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = global_value.i64 gv4
+;; @0040                               v5 = icmp uge v2, v4
+;; @0040                               trapnz v5, heap_oob
+;; @0040                               v6 = global_value.i64 gv5
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               istore8 little heap v3, v7
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0048                               v4 = global_value.i64 gv4
+;; @0048                               v5 = icmp uge v2, v4
+;; @0048                               trapnz v5, heap_oob
+;; @0048                               v6 = global_value.i64 gv5
+;; @0048                               v7 = iadd v6, v2
+;; @0048                               v8 = uload8.i32 little heap v7
+;; @004b                               jump block1(v8)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..6aefd36e5d84
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,71 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = global_value.i64 gv4
+;; @0040                               v5 = iconst.i64 4097
+;; @0040                               v6 = isub v4, v5  ; v5 = 4097
+;; @0040                               v7 = icmp ugt v2, v6
+;; @0040                               trapnz v7, heap_oob
+;; @0040                               v8 = global_value.i64 gv5
+;; @0040                               v9 = iadd v8, v2
+;; @0040                               v10 = iconst.i64 4096
+;; @0040                               v11 = iadd v9, v10  ; v10 = 4096
+;; @0040                               istore8 little heap v3, v11
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0049                               v4 = global_value.i64 gv4
+;; @0049                               v5 = iconst.i64 4097
+;; @0049                               v6 = isub v4, v5  ; v5 = 4097
+;; @0049                               v7 = icmp ugt v2, v6
+;; @0049                               trapnz v7, heap_oob
+;; @0049                               v8 = global_value.i64 gv5
+;; @0049                               v9 = iadd v8, v2
+;; @0049                               v10 = iconst.i64 4096
+;; @0049                               v11 = iadd v9, v10  ; v10 = 4096
+;; @0049                               v12 = uload8.i32 little heap v11
+;; @004d                               jump block1(v12)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..de1dd94f3782
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,71 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = iconst.i64 0xffff_0001
+;; @0040                               v5 = uadd_overflow_trap v2, v4, heap_oob  ; v4 = 0xffff_0001
+;; @0040                               v6 = global_value.i64 gv4
+;; @0040                               v7 = icmp ugt v5, v6
+;; @0040                               trapnz v7, heap_oob
+;; @0040                               v8 = global_value.i64 gv5
+;; @0040                               v9 = iadd v8, v2
+;; @0040                               v10 = iconst.i64 0xffff_0000
+;; @0040                               v11 = iadd v9, v10  ; v10 = 0xffff_0000
+;; @0040                               istore8 little heap v3, v11
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @004c                               v4 = iconst.i64 0xffff_0001
+;; @004c                               v5 = uadd_overflow_trap v2, v4, heap_oob  ; v4 = 0xffff_0001
+;; @004c                               v6 = global_value.i64 gv4
+;; @004c                               v7 = icmp ugt v5, v6
+;; @004c                               trapnz v7, heap_oob
+;; @004c                               v8 = global_value.i64 gv5
+;; @004c                               v9 = iadd v8, v2
+;; @004c                               v10 = iconst.i64 0xffff_0000
+;; @004c                               v11 = iadd v9, v10  ; v10 = 0xffff_0000
+;; @004c                               v12 = uload8.i32 little heap v11
+;; @0053                               jump block1(v12)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..6fe0aece2e7a
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,69 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = global_value.i64 gv4
+;; @0040                               v5 = iconst.i64 4
+;; @0040                               v6 = isub v4, v5  ; v5 = 4
+;; @0040                               v7 = icmp ugt v2, v6
+;; @0040                               v8 = global_value.i64 gv5
+;; @0040                               v9 = iadd v8, v2
+;; @0040                               v10 = iconst.i64 0
+;; @0040                               v11 = select_spectre_guard v7, v10, v9  ; v10 = 0
+;; @0040                               store little heap v3, v11
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0048                               v4 = global_value.i64 gv4
+;; @0048                               v5 = iconst.i64 4
+;; @0048                               v6 = isub v4, v5  ; v5 = 4
+;; @0048                               v7 = icmp ugt v2, v6
+;; @0048                               v8 = global_value.i64 gv5
+;; @0048                               v9 = iadd v8, v2
+;; @0048                               v10 = iconst.i64 0
+;; @0048                               v11 = select_spectre_guard v7, v10, v9  ; v10 = 0
+;; @0048                               v12 = load.i32 little heap v11
+;; @004b                               jump block1(v12)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..cbc70bddc465
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,73 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = global_value.i64 gv4
+;; @0040                               v5 = iconst.i64 4100
+;; @0040                               v6 = isub v4, v5  ; v5 = 4100
+;; @0040                               v7 = icmp ugt v2, v6
+;; @0040                               v8 = global_value.i64 gv5
+;; @0040                               v9 = iadd v8, v2
+;; @0040                               v10 = iconst.i64 4096
+;; @0040                               v11 = iadd v9, v10  ; v10 = 4096
+;; @0040                               v12 = iconst.i64 0
+;; @0040                               v13 = select_spectre_guard v7, v12, v11  ; v12 = 0
+;; @0040                               store little heap v3, v13
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0049                               v4 = global_value.i64 gv4
+;; @0049                               v5 = iconst.i64 4100
+;; @0049                               v6 = isub v4, v5  ; v5 = 4100
+;; @0049                               v7 = icmp ugt v2, v6
+;; @0049                               v8 = global_value.i64 gv5
+;; @0049                               v9 = iadd v8, v2
+;; @0049                               v10 = iconst.i64 4096
+;; @0049                               v11 = iadd v9, v10  ; v10 = 4096
+;; @0049                               v12 = iconst.i64 0
+;; @0049                               v13 = select_spectre_guard v7, v12, v11  ; v12 = 0
+;; @0049                               v14 = load.i32 little heap v13
+;; @004d                               jump block1(v14)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..8e99878a9789
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,73 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = iconst.i64 0xffff_0004
+;; @0040                               v5 = uadd_overflow_trap v2, v4, heap_oob  ; v4 = 0xffff_0004
+;; @0040                               v6 = global_value.i64 gv4
+;; @0040                               v7 = icmp ugt v5, v6
+;; @0040                               v8 = global_value.i64 gv5
+;; @0040                               v9 = iadd v8, v2
+;; @0040                               v10 = iconst.i64 0xffff_0000
+;; @0040                               v11 = iadd v9, v10  ; v10 = 0xffff_0000
+;; @0040                               v12 = iconst.i64 0
+;; @0040                               v13 = select_spectre_guard v7, v12, v11  ; v12 = 0
+;; @0040                               store little heap v3, v13
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @004c                               v4 = iconst.i64 0xffff_0004
+;; @004c                               v5 = uadd_overflow_trap v2, v4, heap_oob  ; v4 = 0xffff_0004
+;; @004c                               v6 = global_value.i64 gv4
+;; @004c                               v7 = icmp ugt v5, v6
+;; @004c                               v8 = global_value.i64 gv5
+;; @004c                               v9 = iadd v8, v2
+;; @004c                               v10 = iconst.i64 0xffff_0000
+;; @004c                               v11 = iadd v9, v10  ; v10 = 0xffff_0000
+;; @004c                               v12 = iconst.i64 0
+;; @004c                               v13 = select_spectre_guard v7, v12, v11  ; v12 = 0
+;; @004c                               v14 = load.i32 little heap v13
+;; @0053                               jump block1(v14)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..d6e77e794266
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,65 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = global_value.i64 gv4
+;; @0040                               v5 = icmp uge v2, v4
+;; @0040                               v6 = global_value.i64 gv5
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 0
+;; @0040                               v9 = select_spectre_guard v5, v8, v7  ; v8 = 0
+;; @0040                               istore8 little heap v3, v9
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0048                               v4 = global_value.i64 gv4
+;; @0048                               v5 = icmp uge v2, v4
+;; @0048                               v6 = global_value.i64 gv5
+;; @0048                               v7 = iadd v6, v2
+;; @0048                               v8 = iconst.i64 0
+;; @0048                               v9 = select_spectre_guard v5, v8, v7  ; v8 = 0
+;; @0048                               v10 = uload8.i32 little heap v9
+;; @004b                               jump block1(v10)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..64283d11c4b4
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,73 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = global_value.i64 gv4
+;; @0040                               v5 = iconst.i64 4097
+;; @0040                               v6 = isub v4, v5  ; v5 = 4097
+;; @0040                               v7 = icmp ugt v2, v6
+;; @0040                               v8 = global_value.i64 gv5
+;; @0040                               v9 = iadd v8, v2
+;; @0040                               v10 = iconst.i64 4096
+;; @0040                               v11 = iadd v9, v10  ; v10 = 4096
+;; @0040                               v12 = iconst.i64 0
+;; @0040                               v13 = select_spectre_guard v7, v12, v11  ; v12 = 0
+;; @0040                               istore8 little heap v3, v13
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0049                               v4 = global_value.i64 gv4
+;; @0049                               v5 = iconst.i64 4097
+;; @0049                               v6 = isub v4, v5  ; v5 = 4097
+;; @0049                               v7 = icmp ugt v2, v6
+;; @0049                               v8 = global_value.i64 gv5
+;; @0049                               v9 = iadd v8, v2
+;; @0049                               v10 = iconst.i64 4096
+;; @0049                               v11 = iadd v9, v10  ; v10 = 4096
+;; @0049                               v12 = iconst.i64 0
+;; @0049                               v13 = select_spectre_guard v7, v12, v11  ; v12 = 0
+;; @0049                               v14 = uload8.i32 little heap v13
+;; @004d                               jump block1(v14)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..15bfd29c54d4
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,73 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = iconst.i64 0xffff_0001
+;; @0040                               v5 = uadd_overflow_trap v2, v4, heap_oob  ; v4 = 0xffff_0001
+;; @0040                               v6 = global_value.i64 gv4
+;; @0040                               v7 = icmp ugt v5, v6
+;; @0040                               v8 = global_value.i64 gv5
+;; @0040                               v9 = iadd v8, v2
+;; @0040                               v10 = iconst.i64 0xffff_0000
+;; @0040                               v11 = iadd v9, v10  ; v10 = 0xffff_0000
+;; @0040                               v12 = iconst.i64 0
+;; @0040                               v13 = select_spectre_guard v7, v12, v11  ; v12 = 0
+;; @0040                               istore8 little heap v3, v13
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @004c                               v4 = iconst.i64 0xffff_0001
+;; @004c                               v5 = uadd_overflow_trap v2, v4, heap_oob  ; v4 = 0xffff_0001
+;; @004c                               v6 = global_value.i64 gv4
+;; @004c                               v7 = icmp ugt v5, v6
+;; @004c                               v8 = global_value.i64 gv5
+;; @004c                               v9 = iadd v8, v2
+;; @004c                               v10 = iconst.i64 0xffff_0000
+;; @004c                               v11 = iadd v9, v10  ; v10 = 0xffff_0000
+;; @004c                               v12 = iconst.i64 0
+;; @004c                               v13 = select_spectre_guard v7, v12, v11  ; v12 = 0
+;; @004c                               v14 = uload8.i32 little heap v13
+;; @0053                               jump block1(v14)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..52a70ec44bda
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = global_value.i64 gv4
+;; @0040                               v5 = icmp ugt v2, v4
+;; @0040                               trapnz v5, heap_oob
+;; @0040                               v6 = global_value.i64 gv5
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               store little heap v3, v7
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0048                               v4 = global_value.i64 gv4
+;; @0048                               v5 = icmp ugt v2, v4
+;; @0048                               trapnz v5, heap_oob
+;; @0048                               v6 = global_value.i64 gv5
+;; @0048                               v7 = iadd v6, v2
+;; @0048                               v8 = load.i32 little heap v7
+;; @004b                               jump block1(v8)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..4ea819504969
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = global_value.i64 gv4
+;; @0040                               v5 = icmp ugt v2, v4
+;; @0040                               trapnz v5, heap_oob
+;; @0040                               v6 = global_value.i64 gv5
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 4096
+;; @0040                               v9 = iadd v7, v8  ; v8 = 4096
+;; @0040                               store little heap v3, v9
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0049                               v4 = global_value.i64 gv4
+;; @0049                               v5 = icmp ugt v2, v4
+;; @0049                               trapnz v5, heap_oob
+;; @0049                               v6 = global_value.i64 gv5
+;; @0049                               v7 = iadd v6, v2
+;; @0049                               v8 = iconst.i64 4096
+;; @0049                               v9 = iadd v7, v8  ; v8 = 4096
+;; @0049                               v10 = load.i32 little heap v9
+;; @004d                               jump block1(v10)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..97f801b8fd55
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = global_value.i64 gv4
+;; @0040                               v5 = icmp ugt v2, v4
+;; @0040                               trapnz v5, heap_oob
+;; @0040                               v6 = global_value.i64 gv5
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 0xffff_0000
+;; @0040                               v9 = iadd v7, v8  ; v8 = 0xffff_0000
+;; @0040                               store little heap v3, v9
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @004c                               v4 = global_value.i64 gv4
+;; @004c                               v5 = icmp ugt v2, v4
+;; @004c                               trapnz v5, heap_oob
+;; @004c                               v6 = global_value.i64 gv5
+;; @004c                               v7 = iadd v6, v2
+;; @004c                               v8 = iconst.i64 0xffff_0000
+;; @004c                               v9 = iadd v7, v8  ; v8 = 0xffff_0000
+;; @004c                               v10 = load.i32 little heap v9
+;; @0053                               jump block1(v10)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..6c72aac6eae0
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = global_value.i64 gv4
+;; @0040                               v5 = icmp uge v2, v4
+;; @0040                               trapnz v5, heap_oob
+;; @0040                               v6 = global_value.i64 gv5
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               istore8 little heap v3, v7
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0048                               v4 = global_value.i64 gv4
+;; @0048                               v5 = icmp uge v2, v4
+;; @0048                               trapnz v5, heap_oob
+;; @0048                               v6 = global_value.i64 gv5
+;; @0048                               v7 = iadd v6, v2
+;; @0048                               v8 = uload8.i32 little heap v7
+;; @004b                               jump block1(v8)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..57e3dcab4806
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = global_value.i64 gv4
+;; @0040                               v5 = icmp ugt v2, v4
+;; @0040                               trapnz v5, heap_oob
+;; @0040                               v6 = global_value.i64 gv5
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 4096
+;; @0040                               v9 = iadd v7, v8  ; v8 = 4096
+;; @0040                               istore8 little heap v3, v9
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0049                               v4 = global_value.i64 gv4
+;; @0049                               v5 = icmp ugt v2, v4
+;; @0049                               trapnz v5, heap_oob
+;; @0049                               v6 = global_value.i64 gv5
+;; @0049                               v7 = iadd v6, v2
+;; @0049                               v8 = iconst.i64 4096
+;; @0049                               v9 = iadd v7, v8  ; v8 = 4096
+;; @0049                               v10 = uload8.i32 little heap v9
+;; @004d                               jump block1(v10)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..167bd6449e2f
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = global_value.i64 gv4
+;; @0040                               v5 = icmp ugt v2, v4
+;; @0040                               trapnz v5, heap_oob
+;; @0040                               v6 = global_value.i64 gv5
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 0xffff_0000
+;; @0040                               v9 = iadd v7, v8  ; v8 = 0xffff_0000
+;; @0040                               istore8 little heap v3, v9
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @004c                               v4 = global_value.i64 gv4
+;; @004c                               v5 = icmp ugt v2, v4
+;; @004c                               trapnz v5, heap_oob
+;; @004c                               v6 = global_value.i64 gv5
+;; @004c                               v7 = iadd v6, v2
+;; @004c                               v8 = iconst.i64 0xffff_0000
+;; @004c                               v9 = iadd v7, v8  ; v8 = 0xffff_0000
+;; @004c                               v10 = uload8.i32 little heap v9
+;; @0053                               jump block1(v10)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..f48bb4d18026
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,65 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = global_value.i64 gv4
+;; @0040                               v5 = icmp ugt v2, v4
+;; @0040                               v6 = global_value.i64 gv5
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 0
+;; @0040                               v9 = select_spectre_guard v5, v8, v7  ; v8 = 0
+;; @0040                               store little heap v3, v9
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0048                               v4 = global_value.i64 gv4
+;; @0048                               v5 = icmp ugt v2, v4
+;; @0048                               v6 = global_value.i64 gv5
+;; @0048                               v7 = iadd v6, v2
+;; @0048                               v8 = iconst.i64 0
+;; @0048                               v9 = select_spectre_guard v5, v8, v7  ; v8 = 0
+;; @0048                               v10 = load.i32 little heap v9
+;; @004b                               jump block1(v10)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..d037e93d4f84
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,69 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = global_value.i64 gv4
+;; @0040                               v5 = icmp ugt v2, v4
+;; @0040                               v6 = global_value.i64 gv5
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 4096
+;; @0040                               v9 = iadd v7, v8  ; v8 = 4096
+;; @0040                               v10 = iconst.i64 0
+;; @0040                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @0040                               store little heap v3, v11
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0049                               v4 = global_value.i64 gv4
+;; @0049                               v5 = icmp ugt v2, v4
+;; @0049                               v6 = global_value.i64 gv5
+;; @0049                               v7 = iadd v6, v2
+;; @0049                               v8 = iconst.i64 4096
+;; @0049                               v9 = iadd v7, v8  ; v8 = 4096
+;; @0049                               v10 = iconst.i64 0
+;; @0049                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @0049                               v12 = load.i32 little heap v11
+;; @004d                               jump block1(v12)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..59d05d9e0346
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,69 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = global_value.i64 gv4
+;; @0040                               v5 = icmp ugt v2, v4
+;; @0040                               v6 = global_value.i64 gv5
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 0xffff_0000
+;; @0040                               v9 = iadd v7, v8  ; v8 = 0xffff_0000
+;; @0040                               v10 = iconst.i64 0
+;; @0040                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @0040                               store little heap v3, v11
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @004c                               v4 = global_value.i64 gv4
+;; @004c                               v5 = icmp ugt v2, v4
+;; @004c                               v6 = global_value.i64 gv5
+;; @004c                               v7 = iadd v6, v2
+;; @004c                               v8 = iconst.i64 0xffff_0000
+;; @004c                               v9 = iadd v7, v8  ; v8 = 0xffff_0000
+;; @004c                               v10 = iconst.i64 0
+;; @004c                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @004c                               v12 = load.i32 little heap v11
+;; @0053                               jump block1(v12)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..d9be2cebfcd5
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,65 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = global_value.i64 gv4
+;; @0040                               v5 = icmp uge v2, v4
+;; @0040                               v6 = global_value.i64 gv5
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 0
+;; @0040                               v9 = select_spectre_guard v5, v8, v7  ; v8 = 0
+;; @0040                               istore8 little heap v3, v9
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0048                               v4 = global_value.i64 gv4
+;; @0048                               v5 = icmp uge v2, v4
+;; @0048                               v6 = global_value.i64 gv5
+;; @0048                               v7 = iadd v6, v2
+;; @0048                               v8 = iconst.i64 0
+;; @0048                               v9 = select_spectre_guard v5, v8, v7  ; v8 = 0
+;; @0048                               v10 = uload8.i32 little heap v9
+;; @004b                               jump block1(v10)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..47bb18061d32
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,69 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = global_value.i64 gv4
+;; @0040                               v5 = icmp ugt v2, v4
+;; @0040                               v6 = global_value.i64 gv5
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 4096
+;; @0040                               v9 = iadd v7, v8  ; v8 = 4096
+;; @0040                               v10 = iconst.i64 0
+;; @0040                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @0040                               istore8 little heap v3, v11
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0049                               v4 = global_value.i64 gv4
+;; @0049                               v5 = icmp ugt v2, v4
+;; @0049                               v6 = global_value.i64 gv5
+;; @0049                               v7 = iadd v6, v2
+;; @0049                               v8 = iconst.i64 4096
+;; @0049                               v9 = iadd v7, v8  ; v8 = 4096
+;; @0049                               v10 = iconst.i64 0
+;; @0049                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @0049                               v12 = uload8.i32 little heap v11
+;; @004d                               jump block1(v12)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..4967bb39f4ea
--- /dev/null
+++ b/tests/disas/load-store/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,69 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = global_value.i64 gv4
+;; @0040                               v5 = icmp ugt v2, v4
+;; @0040                               v6 = global_value.i64 gv5
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 0xffff_0000
+;; @0040                               v9 = iadd v7, v8  ; v8 = 0xffff_0000
+;; @0040                               v10 = iconst.i64 0
+;; @0040                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @0040                               istore8 little heap v3, v11
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @004c                               v4 = global_value.i64 gv4
+;; @004c                               v5 = icmp ugt v2, v4
+;; @004c                               v6 = global_value.i64 gv5
+;; @004c                               v7 = iadd v6, v2
+;; @004c                               v8 = iconst.i64 0xffff_0000
+;; @004c                               v9 = iadd v7, v8  ; v8 = 0xffff_0000
+;; @004c                               v10 = iconst.i64 0
+;; @004c                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @004c                               v12 = uload8.i32 little heap v11
+;; @0053                               jump block1(v12)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..9dc5c0495396
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = iconst.i64 0xffff_fffc
+;; @0040                               v6 = icmp ugt v4, v5  ; v5 = 0xffff_fffc
+;; @0040                               trapnz v6, heap_oob
+;; @0040                               v7 = global_value.i64 gv4
+;; @0040                               v8 = iadd v7, v4
+;; @0040                               store little heap v3, v8
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0048                               v4 = uextend.i64 v2
+;; @0048                               v5 = iconst.i64 0xffff_fffc
+;; @0048                               v6 = icmp ugt v4, v5  ; v5 = 0xffff_fffc
+;; @0048                               trapnz v6, heap_oob
+;; @0048                               v7 = global_value.i64 gv4
+;; @0048                               v8 = iadd v7, v4
+;; @0048                               v9 = load.i32 little heap v8
+;; @004b                               jump block1(v9)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..3ebc7f9adee0
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = iconst.i64 0xffff_effc
+;; @0040                               v6 = icmp ugt v4, v5  ; v5 = 0xffff_effc
+;; @0040                               trapnz v6, heap_oob
+;; @0040                               v7 = global_value.i64 gv4
+;; @0040                               v8 = iadd v7, v4
+;; @0040                               v9 = iconst.i64 4096
+;; @0040                               v10 = iadd v8, v9  ; v9 = 4096
+;; @0040                               store little heap v3, v10
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0049                               v4 = uextend.i64 v2
+;; @0049                               v5 = iconst.i64 0xffff_effc
+;; @0049                               v6 = icmp ugt v4, v5  ; v5 = 0xffff_effc
+;; @0049                               trapnz v6, heap_oob
+;; @0049                               v7 = global_value.i64 gv4
+;; @0049                               v8 = iadd v7, v4
+;; @0049                               v9 = iconst.i64 4096
+;; @0049                               v10 = iadd v8, v9  ; v9 = 4096
+;; @0049                               v11 = load.i32 little heap v10
+;; @004d                               jump block1(v11)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..f1fb58f88217
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = iconst.i64 0xfffc
+;; @0040                               v6 = icmp ugt v4, v5  ; v5 = 0xfffc
+;; @0040                               trapnz v6, heap_oob
+;; @0040                               v7 = global_value.i64 gv4
+;; @0040                               v8 = iadd v7, v4
+;; @0040                               v9 = iconst.i64 0xffff_0000
+;; @0040                               v10 = iadd v8, v9  ; v9 = 0xffff_0000
+;; @0040                               store little heap v3, v10
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @004c                               v4 = uextend.i64 v2
+;; @004c                               v5 = iconst.i64 0xfffc
+;; @004c                               v6 = icmp ugt v4, v5  ; v5 = 0xfffc
+;; @004c                               trapnz v6, heap_oob
+;; @004c                               v7 = global_value.i64 gv4
+;; @004c                               v8 = iadd v7, v4
+;; @004c                               v9 = iconst.i64 0xffff_0000
+;; @004c                               v10 = iadd v8, v9  ; v9 = 0xffff_0000
+;; @004c                               v11 = load.i32 little heap v10
+;; @0053                               jump block1(v11)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..6dc327980495
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = iadd v5, v4
+;; @0040                               istore8 little heap v3, v6
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0048                               v4 = uextend.i64 v2
+;; @0048                               v5 = global_value.i64 gv4
+;; @0048                               v6 = iadd v5, v4
+;; @0048                               v7 = uload8.i32 little heap v6
+;; @004b                               jump block1(v7)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..4a36d8d362cb
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = iconst.i64 0xffff_efff
+;; @0040                               v6 = icmp ugt v4, v5  ; v5 = 0xffff_efff
+;; @0040                               trapnz v6, heap_oob
+;; @0040                               v7 = global_value.i64 gv4
+;; @0040                               v8 = iadd v7, v4
+;; @0040                               v9 = iconst.i64 4096
+;; @0040                               v10 = iadd v8, v9  ; v9 = 4096
+;; @0040                               istore8 little heap v3, v10
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0049                               v4 = uextend.i64 v2
+;; @0049                               v5 = iconst.i64 0xffff_efff
+;; @0049                               v6 = icmp ugt v4, v5  ; v5 = 0xffff_efff
+;; @0049                               trapnz v6, heap_oob
+;; @0049                               v7 = global_value.i64 gv4
+;; @0049                               v8 = iadd v7, v4
+;; @0049                               v9 = iconst.i64 4096
+;; @0049                               v10 = iadd v8, v9  ; v9 = 4096
+;; @0049                               v11 = uload8.i32 little heap v10
+;; @004d                               jump block1(v11)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..83a08b1d9d0b
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = iconst.i64 0xffff
+;; @0040                               v6 = icmp ugt v4, v5  ; v5 = 0xffff
+;; @0040                               trapnz v6, heap_oob
+;; @0040                               v7 = global_value.i64 gv4
+;; @0040                               v8 = iadd v7, v4
+;; @0040                               v9 = iconst.i64 0xffff_0000
+;; @0040                               v10 = iadd v8, v9  ; v9 = 0xffff_0000
+;; @0040                               istore8 little heap v3, v10
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @004c                               v4 = uextend.i64 v2
+;; @004c                               v5 = iconst.i64 0xffff
+;; @004c                               v6 = icmp ugt v4, v5  ; v5 = 0xffff
+;; @004c                               trapnz v6, heap_oob
+;; @004c                               v7 = global_value.i64 gv4
+;; @004c                               v8 = iadd v7, v4
+;; @004c                               v9 = iconst.i64 0xffff_0000
+;; @004c                               v10 = iadd v8, v9  ; v9 = 0xffff_0000
+;; @004c                               v11 = uload8.i32 little heap v10
+;; @0053                               jump block1(v11)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..8debee397c91
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,65 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = iconst.i64 0xffff_fffc
+;; @0040                               v6 = icmp ugt v4, v5  ; v5 = 0xffff_fffc
+;; @0040                               v7 = global_value.i64 gv4
+;; @0040                               v8 = iadd v7, v4
+;; @0040                               v9 = iconst.i64 0
+;; @0040                               v10 = select_spectre_guard v6, v9, v8  ; v9 = 0
+;; @0040                               store little heap v3, v10
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0048                               v4 = uextend.i64 v2
+;; @0048                               v5 = iconst.i64 0xffff_fffc
+;; @0048                               v6 = icmp ugt v4, v5  ; v5 = 0xffff_fffc
+;; @0048                               v7 = global_value.i64 gv4
+;; @0048                               v8 = iadd v7, v4
+;; @0048                               v9 = iconst.i64 0
+;; @0048                               v10 = select_spectre_guard v6, v9, v8  ; v9 = 0
+;; @0048                               v11 = load.i32 little heap v10
+;; @004b                               jump block1(v11)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..b839c0b852f0
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,69 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = iconst.i64 0xffff_effc
+;; @0040                               v6 = icmp ugt v4, v5  ; v5 = 0xffff_effc
+;; @0040                               v7 = global_value.i64 gv4
+;; @0040                               v8 = iadd v7, v4
+;; @0040                               v9 = iconst.i64 4096
+;; @0040                               v10 = iadd v8, v9  ; v9 = 4096
+;; @0040                               v11 = iconst.i64 0
+;; @0040                               v12 = select_spectre_guard v6, v11, v10  ; v11 = 0
+;; @0040                               store little heap v3, v12
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0049                               v4 = uextend.i64 v2
+;; @0049                               v5 = iconst.i64 0xffff_effc
+;; @0049                               v6 = icmp ugt v4, v5  ; v5 = 0xffff_effc
+;; @0049                               v7 = global_value.i64 gv4
+;; @0049                               v8 = iadd v7, v4
+;; @0049                               v9 = iconst.i64 4096
+;; @0049                               v10 = iadd v8, v9  ; v9 = 4096
+;; @0049                               v11 = iconst.i64 0
+;; @0049                               v12 = select_spectre_guard v6, v11, v10  ; v11 = 0
+;; @0049                               v13 = load.i32 little heap v12
+;; @004d                               jump block1(v13)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..3a9a2ddd70b7
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,69 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = iconst.i64 0xfffc
+;; @0040                               v6 = icmp ugt v4, v5  ; v5 = 0xfffc
+;; @0040                               v7 = global_value.i64 gv4
+;; @0040                               v8 = iadd v7, v4
+;; @0040                               v9 = iconst.i64 0xffff_0000
+;; @0040                               v10 = iadd v8, v9  ; v9 = 0xffff_0000
+;; @0040                               v11 = iconst.i64 0
+;; @0040                               v12 = select_spectre_guard v6, v11, v10  ; v11 = 0
+;; @0040                               store little heap v3, v12
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @004c                               v4 = uextend.i64 v2
+;; @004c                               v5 = iconst.i64 0xfffc
+;; @004c                               v6 = icmp ugt v4, v5  ; v5 = 0xfffc
+;; @004c                               v7 = global_value.i64 gv4
+;; @004c                               v8 = iadd v7, v4
+;; @004c                               v9 = iconst.i64 0xffff_0000
+;; @004c                               v10 = iadd v8, v9  ; v9 = 0xffff_0000
+;; @004c                               v11 = iconst.i64 0
+;; @004c                               v12 = select_spectre_guard v6, v11, v10  ; v11 = 0
+;; @004c                               v13 = load.i32 little heap v12
+;; @0053                               jump block1(v13)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..417e11927274
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = iadd v5, v4
+;; @0040                               istore8 little heap v3, v6
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0048                               v4 = uextend.i64 v2
+;; @0048                               v5 = global_value.i64 gv4
+;; @0048                               v6 = iadd v5, v4
+;; @0048                               v7 = uload8.i32 little heap v6
+;; @004b                               jump block1(v7)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..5df7626cc1b9
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,69 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = iconst.i64 0xffff_efff
+;; @0040                               v6 = icmp ugt v4, v5  ; v5 = 0xffff_efff
+;; @0040                               v7 = global_value.i64 gv4
+;; @0040                               v8 = iadd v7, v4
+;; @0040                               v9 = iconst.i64 4096
+;; @0040                               v10 = iadd v8, v9  ; v9 = 4096
+;; @0040                               v11 = iconst.i64 0
+;; @0040                               v12 = select_spectre_guard v6, v11, v10  ; v11 = 0
+;; @0040                               istore8 little heap v3, v12
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0049                               v4 = uextend.i64 v2
+;; @0049                               v5 = iconst.i64 0xffff_efff
+;; @0049                               v6 = icmp ugt v4, v5  ; v5 = 0xffff_efff
+;; @0049                               v7 = global_value.i64 gv4
+;; @0049                               v8 = iadd v7, v4
+;; @0049                               v9 = iconst.i64 4096
+;; @0049                               v10 = iadd v8, v9  ; v9 = 4096
+;; @0049                               v11 = iconst.i64 0
+;; @0049                               v12 = select_spectre_guard v6, v11, v10  ; v11 = 0
+;; @0049                               v13 = uload8.i32 little heap v12
+;; @004d                               jump block1(v13)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..085392263f4b
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,69 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = iconst.i64 0xffff
+;; @0040                               v6 = icmp ugt v4, v5  ; v5 = 0xffff
+;; @0040                               v7 = global_value.i64 gv4
+;; @0040                               v8 = iadd v7, v4
+;; @0040                               v9 = iconst.i64 0xffff_0000
+;; @0040                               v10 = iadd v8, v9  ; v9 = 0xffff_0000
+;; @0040                               v11 = iconst.i64 0
+;; @0040                               v12 = select_spectre_guard v6, v11, v10  ; v11 = 0
+;; @0040                               istore8 little heap v3, v12
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @004c                               v4 = uextend.i64 v2
+;; @004c                               v5 = iconst.i64 0xffff
+;; @004c                               v6 = icmp ugt v4, v5  ; v5 = 0xffff
+;; @004c                               v7 = global_value.i64 gv4
+;; @004c                               v8 = iadd v7, v4
+;; @004c                               v9 = iconst.i64 0xffff_0000
+;; @004c                               v10 = iadd v8, v9  ; v9 = 0xffff_0000
+;; @004c                               v11 = iconst.i64 0
+;; @004c                               v12 = select_spectre_guard v6, v11, v10  ; v11 = 0
+;; @004c                               v13 = uload8.i32 little heap v12
+;; @0053                               jump block1(v13)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..591590044dce
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = iadd v5, v4
+;; @0040                               store little heap v3, v6
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0048                               v4 = uextend.i64 v2
+;; @0048                               v5 = global_value.i64 gv4
+;; @0048                               v6 = iadd v5, v4
+;; @0048                               v7 = load.i32 little heap v6
+;; @004b                               jump block1(v7)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..ddc6c0310640
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = iadd v5, v4
+;; @0040                               v7 = iconst.i64 4096
+;; @0040                               v8 = iadd v6, v7  ; v7 = 4096
+;; @0040                               store little heap v3, v8
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0049                               v4 = uextend.i64 v2
+;; @0049                               v5 = global_value.i64 gv4
+;; @0049                               v6 = iadd v5, v4
+;; @0049                               v7 = iconst.i64 4096
+;; @0049                               v8 = iadd v6, v7  ; v7 = 4096
+;; @0049                               v9 = load.i32 little heap v8
+;; @004d                               jump block1(v9)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..b19052c18676
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = iadd v5, v4
+;; @0040                               v7 = iconst.i64 0xffff_0000
+;; @0040                               v8 = iadd v6, v7  ; v7 = 0xffff_0000
+;; @0040                               store little heap v3, v8
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @004c                               v4 = uextend.i64 v2
+;; @004c                               v5 = global_value.i64 gv4
+;; @004c                               v6 = iadd v5, v4
+;; @004c                               v7 = iconst.i64 0xffff_0000
+;; @004c                               v8 = iadd v6, v7  ; v7 = 0xffff_0000
+;; @004c                               v9 = load.i32 little heap v8
+;; @0053                               jump block1(v9)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..8e1233b4130f
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = iadd v5, v4
+;; @0040                               istore8 little heap v3, v6
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0048                               v4 = uextend.i64 v2
+;; @0048                               v5 = global_value.i64 gv4
+;; @0048                               v6 = iadd v5, v4
+;; @0048                               v7 = uload8.i32 little heap v6
+;; @004b                               jump block1(v7)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..5db465d32d82
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = iadd v5, v4
+;; @0040                               v7 = iconst.i64 4096
+;; @0040                               v8 = iadd v6, v7  ; v7 = 4096
+;; @0040                               istore8 little heap v3, v8
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0049                               v4 = uextend.i64 v2
+;; @0049                               v5 = global_value.i64 gv4
+;; @0049                               v6 = iadd v5, v4
+;; @0049                               v7 = iconst.i64 4096
+;; @0049                               v8 = iadd v6, v7  ; v7 = 4096
+;; @0049                               v9 = uload8.i32 little heap v8
+;; @004d                               jump block1(v9)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..9231c1e61865
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = iadd v5, v4
+;; @0040                               v7 = iconst.i64 0xffff_0000
+;; @0040                               v8 = iadd v6, v7  ; v7 = 0xffff_0000
+;; @0040                               istore8 little heap v3, v8
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @004c                               v4 = uextend.i64 v2
+;; @004c                               v5 = global_value.i64 gv4
+;; @004c                               v6 = iadd v5, v4
+;; @004c                               v7 = iconst.i64 0xffff_0000
+;; @004c                               v8 = iadd v6, v7  ; v7 = 0xffff_0000
+;; @004c                               v9 = uload8.i32 little heap v8
+;; @0053                               jump block1(v9)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..e11000e2251d
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = iadd v5, v4
+;; @0040                               store little heap v3, v6
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0048                               v4 = uextend.i64 v2
+;; @0048                               v5 = global_value.i64 gv4
+;; @0048                               v6 = iadd v5, v4
+;; @0048                               v7 = load.i32 little heap v6
+;; @004b                               jump block1(v7)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..1771016a2c80
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = iadd v5, v4
+;; @0040                               v7 = iconst.i64 4096
+;; @0040                               v8 = iadd v6, v7  ; v7 = 4096
+;; @0040                               store little heap v3, v8
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0049                               v4 = uextend.i64 v2
+;; @0049                               v5 = global_value.i64 gv4
+;; @0049                               v6 = iadd v5, v4
+;; @0049                               v7 = iconst.i64 4096
+;; @0049                               v8 = iadd v6, v7  ; v7 = 4096
+;; @0049                               v9 = load.i32 little heap v8
+;; @004d                               jump block1(v9)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..765e3d3c25ca
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = iadd v5, v4
+;; @0040                               v7 = iconst.i64 0xffff_0000
+;; @0040                               v8 = iadd v6, v7  ; v7 = 0xffff_0000
+;; @0040                               store little heap v3, v8
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @004c                               v4 = uextend.i64 v2
+;; @004c                               v5 = global_value.i64 gv4
+;; @004c                               v6 = iadd v5, v4
+;; @004c                               v7 = iconst.i64 0xffff_0000
+;; @004c                               v8 = iadd v6, v7  ; v7 = 0xffff_0000
+;; @004c                               v9 = load.i32 little heap v8
+;; @0053                               jump block1(v9)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..c923bb06a666
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = iadd v5, v4
+;; @0040                               istore8 little heap v3, v6
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0048                               v4 = uextend.i64 v2
+;; @0048                               v5 = global_value.i64 gv4
+;; @0048                               v6 = iadd v5, v4
+;; @0048                               v7 = uload8.i32 little heap v6
+;; @004b                               jump block1(v7)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..4acf22d3e411
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = iadd v5, v4
+;; @0040                               v7 = iconst.i64 4096
+;; @0040                               v8 = iadd v6, v7  ; v7 = 4096
+;; @0040                               istore8 little heap v3, v8
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0049                               v4 = uextend.i64 v2
+;; @0049                               v5 = global_value.i64 gv4
+;; @0049                               v6 = iadd v5, v4
+;; @0049                               v7 = iconst.i64 4096
+;; @0049                               v8 = iadd v6, v7  ; v7 = 4096
+;; @0049                               v9 = uload8.i32 little heap v8
+;; @004d                               jump block1(v9)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..c53777b96668
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0040                               v4 = uextend.i64 v2
+;; @0040                               v5 = global_value.i64 gv4
+;; @0040                               v6 = iadd v5, v4
+;; @0040                               v7 = iconst.i64 0xffff_0000
+;; @0040                               v8 = iadd v6, v7  ; v7 = 0xffff_0000
+;; @0040                               istore8 little heap v3, v8
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @004c                               v4 = uextend.i64 v2
+;; @004c                               v5 = global_value.i64 gv4
+;; @004c                               v6 = iadd v5, v4
+;; @004c                               v7 = iconst.i64 0xffff_0000
+;; @004c                               v8 = iadd v6, v7  ; v7 = 0xffff_0000
+;; @004c                               v9 = uload8.i32 little heap v8
+;; @0053                               jump block1(v9)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..46f1516a7842
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = iconst.i64 0xffff_fffc
+;; @0040                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_fffc
+;; @0040                               trapnz v5, heap_oob
+;; @0040                               v6 = global_value.i64 gv4
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               store little heap v3, v7
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0048                               v4 = iconst.i64 0xffff_fffc
+;; @0048                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_fffc
+;; @0048                               trapnz v5, heap_oob
+;; @0048                               v6 = global_value.i64 gv4
+;; @0048                               v7 = iadd v6, v2
+;; @0048                               v8 = load.i32 little heap v7
+;; @004b                               jump block1(v8)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..431dd7b3d8e0
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,65 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = iconst.i64 0xffff_effc
+;; @0040                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_effc
+;; @0040                               trapnz v5, heap_oob
+;; @0040                               v6 = global_value.i64 gv4
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 4096
+;; @0040                               v9 = iadd v7, v8  ; v8 = 4096
+;; @0040                               store little heap v3, v9
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0049                               v4 = iconst.i64 0xffff_effc
+;; @0049                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_effc
+;; @0049                               trapnz v5, heap_oob
+;; @0049                               v6 = global_value.i64 gv4
+;; @0049                               v7 = iadd v6, v2
+;; @0049                               v8 = iconst.i64 4096
+;; @0049                               v9 = iadd v7, v8  ; v8 = 4096
+;; @0049                               v10 = load.i32 little heap v9
+;; @004d                               jump block1(v10)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..674a7c9d3940
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,65 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = iconst.i64 0xfffc
+;; @0040                               v5 = icmp ugt v2, v4  ; v4 = 0xfffc
+;; @0040                               trapnz v5, heap_oob
+;; @0040                               v6 = global_value.i64 gv4
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 0xffff_0000
+;; @0040                               v9 = iadd v7, v8  ; v8 = 0xffff_0000
+;; @0040                               store little heap v3, v9
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @004c                               v4 = iconst.i64 0xfffc
+;; @004c                               v5 = icmp ugt v2, v4  ; v4 = 0xfffc
+;; @004c                               trapnz v5, heap_oob
+;; @004c                               v6 = global_value.i64 gv4
+;; @004c                               v7 = iadd v6, v2
+;; @004c                               v8 = iconst.i64 0xffff_0000
+;; @004c                               v9 = iadd v7, v8  ; v8 = 0xffff_0000
+;; @004c                               v10 = load.i32 little heap v9
+;; @0053                               jump block1(v10)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..99a72feb8c28
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = iconst.i64 0xffff_ffff
+;; @0040                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_ffff
+;; @0040                               trapnz v5, heap_oob
+;; @0040                               v6 = global_value.i64 gv4
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               istore8 little heap v3, v7
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0048                               v4 = iconst.i64 0xffff_ffff
+;; @0048                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_ffff
+;; @0048                               trapnz v5, heap_oob
+;; @0048                               v6 = global_value.i64 gv4
+;; @0048                               v7 = iadd v6, v2
+;; @0048                               v8 = uload8.i32 little heap v7
+;; @004b                               jump block1(v8)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..11483f9cd189
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,65 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = iconst.i64 0xffff_efff
+;; @0040                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_efff
+;; @0040                               trapnz v5, heap_oob
+;; @0040                               v6 = global_value.i64 gv4
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 4096
+;; @0040                               v9 = iadd v7, v8  ; v8 = 4096
+;; @0040                               istore8 little heap v3, v9
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0049                               v4 = iconst.i64 0xffff_efff
+;; @0049                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_efff
+;; @0049                               trapnz v5, heap_oob
+;; @0049                               v6 = global_value.i64 gv4
+;; @0049                               v7 = iadd v6, v2
+;; @0049                               v8 = iconst.i64 4096
+;; @0049                               v9 = iadd v7, v8  ; v8 = 4096
+;; @0049                               v10 = uload8.i32 little heap v9
+;; @004d                               jump block1(v10)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..21e08e3f85bb
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,65 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = iconst.i64 0xffff
+;; @0040                               v5 = icmp ugt v2, v4  ; v4 = 0xffff
+;; @0040                               trapnz v5, heap_oob
+;; @0040                               v6 = global_value.i64 gv4
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 0xffff_0000
+;; @0040                               v9 = iadd v7, v8  ; v8 = 0xffff_0000
+;; @0040                               istore8 little heap v3, v9
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @004c                               v4 = iconst.i64 0xffff
+;; @004c                               v5 = icmp ugt v2, v4  ; v4 = 0xffff
+;; @004c                               trapnz v5, heap_oob
+;; @004c                               v6 = global_value.i64 gv4
+;; @004c                               v7 = iadd v6, v2
+;; @004c                               v8 = iconst.i64 0xffff_0000
+;; @004c                               v9 = iadd v7, v8  ; v8 = 0xffff_0000
+;; @004c                               v10 = uload8.i32 little heap v9
+;; @0053                               jump block1(v10)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..028cf8b2a49d
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = iconst.i64 0xffff_fffc
+;; @0040                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_fffc
+;; @0040                               v6 = global_value.i64 gv4
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 0
+;; @0040                               v9 = select_spectre_guard v5, v8, v7  ; v8 = 0
+;; @0040                               store little heap v3, v9
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0048                               v4 = iconst.i64 0xffff_fffc
+;; @0048                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_fffc
+;; @0048                               v6 = global_value.i64 gv4
+;; @0048                               v7 = iadd v6, v2
+;; @0048                               v8 = iconst.i64 0
+;; @0048                               v9 = select_spectre_guard v5, v8, v7  ; v8 = 0
+;; @0048                               v10 = load.i32 little heap v9
+;; @004b                               jump block1(v10)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..c8ffe5231558
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = iconst.i64 0xffff_effc
+;; @0040                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_effc
+;; @0040                               v6 = global_value.i64 gv4
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 4096
+;; @0040                               v9 = iadd v7, v8  ; v8 = 4096
+;; @0040                               v10 = iconst.i64 0
+;; @0040                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @0040                               store little heap v3, v11
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0049                               v4 = iconst.i64 0xffff_effc
+;; @0049                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_effc
+;; @0049                               v6 = global_value.i64 gv4
+;; @0049                               v7 = iadd v6, v2
+;; @0049                               v8 = iconst.i64 4096
+;; @0049                               v9 = iadd v7, v8  ; v8 = 4096
+;; @0049                               v10 = iconst.i64 0
+;; @0049                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @0049                               v12 = load.i32 little heap v11
+;; @004d                               jump block1(v12)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..5e680cff302d
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = iconst.i64 0xfffc
+;; @0040                               v5 = icmp ugt v2, v4  ; v4 = 0xfffc
+;; @0040                               v6 = global_value.i64 gv4
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 0xffff_0000
+;; @0040                               v9 = iadd v7, v8  ; v8 = 0xffff_0000
+;; @0040                               v10 = iconst.i64 0
+;; @0040                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @0040                               store little heap v3, v11
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @004c                               v4 = iconst.i64 0xfffc
+;; @004c                               v5 = icmp ugt v2, v4  ; v4 = 0xfffc
+;; @004c                               v6 = global_value.i64 gv4
+;; @004c                               v7 = iadd v6, v2
+;; @004c                               v8 = iconst.i64 0xffff_0000
+;; @004c                               v9 = iadd v7, v8  ; v8 = 0xffff_0000
+;; @004c                               v10 = iconst.i64 0
+;; @004c                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @004c                               v12 = load.i32 little heap v11
+;; @0053                               jump block1(v12)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..f808f9d622be
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = iconst.i64 0xffff_ffff
+;; @0040                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_ffff
+;; @0040                               v6 = global_value.i64 gv4
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 0
+;; @0040                               v9 = select_spectre_guard v5, v8, v7  ; v8 = 0
+;; @0040                               istore8 little heap v3, v9
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0048                               v4 = iconst.i64 0xffff_ffff
+;; @0048                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_ffff
+;; @0048                               v6 = global_value.i64 gv4
+;; @0048                               v7 = iadd v6, v2
+;; @0048                               v8 = iconst.i64 0
+;; @0048                               v9 = select_spectre_guard v5, v8, v7  ; v8 = 0
+;; @0048                               v10 = uload8.i32 little heap v9
+;; @004b                               jump block1(v10)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..1fe7bd8602ff
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = iconst.i64 0xffff_efff
+;; @0040                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_efff
+;; @0040                               v6 = global_value.i64 gv4
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 4096
+;; @0040                               v9 = iadd v7, v8  ; v8 = 4096
+;; @0040                               v10 = iconst.i64 0
+;; @0040                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @0040                               istore8 little heap v3, v11
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0049                               v4 = iconst.i64 0xffff_efff
+;; @0049                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_efff
+;; @0049                               v6 = global_value.i64 gv4
+;; @0049                               v7 = iadd v6, v2
+;; @0049                               v8 = iconst.i64 4096
+;; @0049                               v9 = iadd v7, v8  ; v8 = 4096
+;; @0049                               v10 = iconst.i64 0
+;; @0049                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @0049                               v12 = uload8.i32 little heap v11
+;; @004d                               jump block1(v12)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..f72b18166c02
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = iconst.i64 0xffff
+;; @0040                               v5 = icmp ugt v2, v4  ; v4 = 0xffff
+;; @0040                               v6 = global_value.i64 gv4
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 0xffff_0000
+;; @0040                               v9 = iadd v7, v8  ; v8 = 0xffff_0000
+;; @0040                               v10 = iconst.i64 0
+;; @0040                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @0040                               istore8 little heap v3, v11
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @004c                               v4 = iconst.i64 0xffff
+;; @004c                               v5 = icmp ugt v2, v4  ; v4 = 0xffff
+;; @004c                               v6 = global_value.i64 gv4
+;; @004c                               v7 = iadd v6, v2
+;; @004c                               v8 = iconst.i64 0xffff_0000
+;; @004c                               v9 = iadd v7, v8  ; v8 = 0xffff_0000
+;; @004c                               v10 = iconst.i64 0
+;; @004c                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @004c                               v12 = uload8.i32 little heap v11
+;; @0053                               jump block1(v12)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..10b03a83c142
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = iconst.i64 0xffff_fffc
+;; @0040                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_fffc
+;; @0040                               trapnz v5, heap_oob
+;; @0040                               v6 = global_value.i64 gv4
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               store little heap v3, v7
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0048                               v4 = iconst.i64 0xffff_fffc
+;; @0048                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_fffc
+;; @0048                               trapnz v5, heap_oob
+;; @0048                               v6 = global_value.i64 gv4
+;; @0048                               v7 = iadd v6, v2
+;; @0048                               v8 = load.i32 little heap v7
+;; @004b                               jump block1(v8)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..140fd148b482
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,65 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = iconst.i64 0xffff_effc
+;; @0040                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_effc
+;; @0040                               trapnz v5, heap_oob
+;; @0040                               v6 = global_value.i64 gv4
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 4096
+;; @0040                               v9 = iadd v7, v8  ; v8 = 4096
+;; @0040                               store little heap v3, v9
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0049                               v4 = iconst.i64 0xffff_effc
+;; @0049                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_effc
+;; @0049                               trapnz v5, heap_oob
+;; @0049                               v6 = global_value.i64 gv4
+;; @0049                               v7 = iadd v6, v2
+;; @0049                               v8 = iconst.i64 4096
+;; @0049                               v9 = iadd v7, v8  ; v8 = 4096
+;; @0049                               v10 = load.i32 little heap v9
+;; @004d                               jump block1(v10)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..d3b2860f93e2
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,65 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = iconst.i64 0xfffc
+;; @0040                               v5 = icmp ugt v2, v4  ; v4 = 0xfffc
+;; @0040                               trapnz v5, heap_oob
+;; @0040                               v6 = global_value.i64 gv4
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 0xffff_0000
+;; @0040                               v9 = iadd v7, v8  ; v8 = 0xffff_0000
+;; @0040                               store little heap v3, v9
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @004c                               v4 = iconst.i64 0xfffc
+;; @004c                               v5 = icmp ugt v2, v4  ; v4 = 0xfffc
+;; @004c                               trapnz v5, heap_oob
+;; @004c                               v6 = global_value.i64 gv4
+;; @004c                               v7 = iadd v6, v2
+;; @004c                               v8 = iconst.i64 0xffff_0000
+;; @004c                               v9 = iadd v7, v8  ; v8 = 0xffff_0000
+;; @004c                               v10 = load.i32 little heap v9
+;; @0053                               jump block1(v10)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..b9cf164a6c3f
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = iconst.i64 0xffff_ffff
+;; @0040                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_ffff
+;; @0040                               trapnz v5, heap_oob
+;; @0040                               v6 = global_value.i64 gv4
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               istore8 little heap v3, v7
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0048                               v4 = iconst.i64 0xffff_ffff
+;; @0048                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_ffff
+;; @0048                               trapnz v5, heap_oob
+;; @0048                               v6 = global_value.i64 gv4
+;; @0048                               v7 = iadd v6, v2
+;; @0048                               v8 = uload8.i32 little heap v7
+;; @004b                               jump block1(v8)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..56b7047d0d9b
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,65 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = iconst.i64 0xffff_efff
+;; @0040                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_efff
+;; @0040                               trapnz v5, heap_oob
+;; @0040                               v6 = global_value.i64 gv4
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 4096
+;; @0040                               v9 = iadd v7, v8  ; v8 = 4096
+;; @0040                               istore8 little heap v3, v9
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0049                               v4 = iconst.i64 0xffff_efff
+;; @0049                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_efff
+;; @0049                               trapnz v5, heap_oob
+;; @0049                               v6 = global_value.i64 gv4
+;; @0049                               v7 = iadd v6, v2
+;; @0049                               v8 = iconst.i64 4096
+;; @0049                               v9 = iadd v7, v8  ; v8 = 4096
+;; @0049                               v10 = uload8.i32 little heap v9
+;; @004d                               jump block1(v10)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..21f305afd4b0
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,65 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = iconst.i64 0xffff
+;; @0040                               v5 = icmp ugt v2, v4  ; v4 = 0xffff
+;; @0040                               trapnz v5, heap_oob
+;; @0040                               v6 = global_value.i64 gv4
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 0xffff_0000
+;; @0040                               v9 = iadd v7, v8  ; v8 = 0xffff_0000
+;; @0040                               istore8 little heap v3, v9
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @004c                               v4 = iconst.i64 0xffff
+;; @004c                               v5 = icmp ugt v2, v4  ; v4 = 0xffff
+;; @004c                               trapnz v5, heap_oob
+;; @004c                               v6 = global_value.i64 gv4
+;; @004c                               v7 = iadd v6, v2
+;; @004c                               v8 = iconst.i64 0xffff_0000
+;; @004c                               v9 = iadd v7, v8  ; v8 = 0xffff_0000
+;; @004c                               v10 = uload8.i32 little heap v9
+;; @0053                               jump block1(v10)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..778c099aed0c
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = iconst.i64 0xffff_fffc
+;; @0040                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_fffc
+;; @0040                               v6 = global_value.i64 gv4
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 0
+;; @0040                               v9 = select_spectre_guard v5, v8, v7  ; v8 = 0
+;; @0040                               store little heap v3, v9
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0048                               v4 = iconst.i64 0xffff_fffc
+;; @0048                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_fffc
+;; @0048                               v6 = global_value.i64 gv4
+;; @0048                               v7 = iadd v6, v2
+;; @0048                               v8 = iconst.i64 0
+;; @0048                               v9 = select_spectre_guard v5, v8, v7  ; v8 = 0
+;; @0048                               v10 = load.i32 little heap v9
+;; @004b                               jump block1(v10)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..4a6fbdd639b9
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = iconst.i64 0xffff_effc
+;; @0040                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_effc
+;; @0040                               v6 = global_value.i64 gv4
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 4096
+;; @0040                               v9 = iadd v7, v8  ; v8 = 4096
+;; @0040                               v10 = iconst.i64 0
+;; @0040                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @0040                               store little heap v3, v11
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0049                               v4 = iconst.i64 0xffff_effc
+;; @0049                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_effc
+;; @0049                               v6 = global_value.i64 gv4
+;; @0049                               v7 = iadd v6, v2
+;; @0049                               v8 = iconst.i64 4096
+;; @0049                               v9 = iadd v7, v8  ; v8 = 4096
+;; @0049                               v10 = iconst.i64 0
+;; @0049                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @0049                               v12 = load.i32 little heap v11
+;; @004d                               jump block1(v12)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..5b0c14c5e9f2
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = iconst.i64 0xfffc
+;; @0040                               v5 = icmp ugt v2, v4  ; v4 = 0xfffc
+;; @0040                               v6 = global_value.i64 gv4
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 0xffff_0000
+;; @0040                               v9 = iadd v7, v8  ; v8 = 0xffff_0000
+;; @0040                               v10 = iconst.i64 0
+;; @0040                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @0040                               store little heap v3, v11
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @004c                               v4 = iconst.i64 0xfffc
+;; @004c                               v5 = icmp ugt v2, v4  ; v4 = 0xfffc
+;; @004c                               v6 = global_value.i64 gv4
+;; @004c                               v7 = iadd v6, v2
+;; @004c                               v8 = iconst.i64 0xffff_0000
+;; @004c                               v9 = iadd v7, v8  ; v8 = 0xffff_0000
+;; @004c                               v10 = iconst.i64 0
+;; @004c                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @004c                               v12 = load.i32 little heap v11
+;; @0053                               jump block1(v12)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..92f576bd4223
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = iconst.i64 0xffff_ffff
+;; @0040                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_ffff
+;; @0040                               v6 = global_value.i64 gv4
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 0
+;; @0040                               v9 = select_spectre_guard v5, v8, v7  ; v8 = 0
+;; @0040                               istore8 little heap v3, v9
+;; @0043                               jump block1
+;;
+;;                                 block1:
+;; @0043                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0048                               v4 = iconst.i64 0xffff_ffff
+;; @0048                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_ffff
+;; @0048                               v6 = global_value.i64 gv4
+;; @0048                               v7 = iadd v6, v2
+;; @0048                               v8 = iconst.i64 0
+;; @0048                               v9 = select_spectre_guard v5, v8, v7  ; v8 = 0
+;; @0048                               v10 = uload8.i32 little heap v9
+;; @004b                               jump block1(v10)
+;;
+;;                                 block1(v3: i32):
+;; @004b                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..8e6132627cac
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = iconst.i64 0xffff_efff
+;; @0040                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_efff
+;; @0040                               v6 = global_value.i64 gv4
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 4096
+;; @0040                               v9 = iadd v7, v8  ; v8 = 4096
+;; @0040                               v10 = iconst.i64 0
+;; @0040                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @0040                               istore8 little heap v3, v11
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @0049                               v4 = iconst.i64 0xffff_efff
+;; @0049                               v5 = icmp ugt v2, v4  ; v4 = 0xffff_efff
+;; @0049                               v6 = global_value.i64 gv4
+;; @0049                               v7 = iadd v6, v2
+;; @0049                               v8 = iconst.i64 4096
+;; @0049                               v9 = iadd v7, v8  ; v8 = 4096
+;; @0049                               v10 = iconst.i64 0
+;; @0049                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @0049                               v12 = uload8.i32 little heap v11
+;; @004d                               jump block1(v12)
+;;
+;;                                 block1(v3: i32):
+;; @004d                               return v3
+;; }
diff --git a/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..ee8ce6711cba
--- /dev/null
+++ b/tests/disas/load-store/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "x86_64"
+;;! test = "clif"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0040                               v4 = iconst.i64 0xffff
+;; @0040                               v5 = icmp ugt v2, v4  ; v4 = 0xffff
+;; @0040                               v6 = global_value.i64 gv4
+;; @0040                               v7 = iadd v6, v2
+;; @0040                               v8 = iconst.i64 0xffff_0000
+;; @0040                               v9 = iadd v7, v8  ; v8 = 0xffff_0000
+;; @0040                               v10 = iconst.i64 0
+;; @0040                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @0040                               istore8 little heap v3, v11
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @004c                               v4 = iconst.i64 0xffff
+;; @004c                               v5 = icmp ugt v2, v4  ; v4 = 0xffff
+;; @004c                               v6 = global_value.i64 gv4
+;; @004c                               v7 = iadd v6, v2
+;; @004c                               v8 = iconst.i64 0xffff_0000
+;; @004c                               v9 = iadd v7, v8  ; v8 = 0xffff_0000
+;; @004c                               v10 = iconst.i64 0
+;; @004c                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @004c                               v12 = uload8.i32 little heap v11
+;; @0053                               jump block1(v12)
+;;
+;;                                 block1(v3: i32):
+;; @0053                               return v3
+;; }
diff --git a/tests/disas/load-store/make-load-store-tests.sh b/tests/disas/load-store/make-load-store-tests.sh
new file mode 100755
index 000000000000..d0cd1e0080db
--- /dev/null
+++ b/tests/disas/load-store/make-load-store-tests.sh
@@ -0,0 +1,116 @@
+#!/usr/bin/env bash
+
+# This script generates the `load_store_*.clif` test files.
+#
+# Usage:
+#
+#     $ ./make-load-store-tests.sh
+
+set -e
+cd $(dirname "$0")
+
+function main {
+    for spectre in "yes" "no"; do
+        for guard in "0" "0xffffffff"; do
+            for index_type in "i32" "i64"; do
+                for kind in "static" "dynamic"; do
+                    for access_type in "i32" "i8"; do
+                        for offset in "0" "0x1000" "0xffff0000"; do
+                            generate_one_test $kind $index_type $guard $spectre $access_type $offset x86_64 clif
+                            for target in "x86_64" "aarch64" "s390x" "riscv64"; do
+                                generate_one_test $kind $index_type $guard $spectre $access_type $offset $target compile
+                            done
+                        done
+                    done
+                done
+            done
+        done
+    done
+    echo "Done!"
+}
+
+function generate_one_test() {
+    local kind=$1
+    local index_type=$2
+    local guard=$3
+    local spectre=$4
+    local access_type=$5
+    local offset=$6
+    local target=$7
+    local test_kind=$8
+
+    local filename="load_store_${kind}_kind_${index_type}_index_${guard}_guard_${spectre}_spectre_${access_type}_access_${offset}_offset.wat"
+    if [[ $test_kind == "compile" ]]; then
+        local target_dir=${target}
+        if [[ $target == "x86_64" ]]; then
+            target_dir="x64"
+        fi
+        mkdir -p "${target_dir}"
+        filename="${target_dir}/${filename}"
+    fi
+    echo "Generating $filename..."
+
+    local flags=""
+    if [[ $spectre == "yes" ]]; then
+        flags="$flags -C cranelift-enable-heap-access-spectre-mitigation"
+    else
+        flags="$flags -C cranelift-enable-heap-access-spectre-mitigation=false"
+    fi
+
+    if [[ $index_type == "i64" ]]; then
+        flags="$flags -W memory64"
+    fi
+
+    local store_op=
+    local load_op=
+    case $access_type in
+        "i32")
+            store_op="i32.store"
+            load_op="i32.load"
+            ;;
+        "i8")
+            store_op="i32.store8"
+            load_op="i32.load8_u"
+            ;;
+    esac
+
+    local bound_global=""
+    local style=""
+    case $kind in
+        "dynamic")
+            flags="$flags -O static-memory-maximum-size=0"
+            ;;
+        "static")
+            flags="$flags -O static-memory-forced"
+        ;;
+    esac
+    flags="$flags -O static-memory-guard-size=$(($guard))"
+    flags="$flags -O dynamic-memory-guard-size=$(($guard))"
+
+    cat <<EOF > "$filename"
+;;! target = "${target}"
+;;! test = "${test_kind}"
+;;! flags = "${flags}"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory ${index_type} 1)
+
+  (func (export "do_store") (param ${index_type} i32)
+    local.get 0
+    local.get 1
+    ${store_op} offset=${offset})
+
+  (func (export "do_load") (param ${index_type}) (result i32)
+    local.get 0
+    ${load_op} offset=${offset}))
+
+;; TODO: run with the 'CRANELIFT_TEST_BLESS=1' env var set to update this test's
+;; expected output.
+EOF
+}
+
+main
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..7696328f044c
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a5, 0x68(a0)
+;;       slli    a2, a2, 0x20
+;;       srli    a4, a2, 0x20
+;;       addi    a5, a5, -4
+;;       bltu    a5, a4, 0x20
+;;       ld      a5, 0x60(a0)
+;;       add     a4, a5, a4
+;;       sw      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a3, 0x68(a0)
+;;       slli    a2, a2, 0x20
+;;       srli    a4, a2, 0x20
+;;       addi    a3, a3, -4
+;;       bltu    a3, a4, 0x20
+;;       ld      a5, 0x60(a0)
+;;       add     a4, a5, a4
+;;       lw      a0, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..b42e657f517f
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,65 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a5, 0x68(a0)
+;;       slli    a4, a2, 0x20
+;;       srli    a1, a4, 0x20
+;;       lui     a4, 1
+;;       addi    a2, a4, 4
+;;       sub     a5, a5, a2
+;;       bltu    a5, a1, 0x28
+;;       ld      a0, 0x60(a0)
+;;       add     a0, a0, a1
+;;       lui     t6, 1
+;;       add     t6, t6, a0
+;;       sw      a3, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a5, 0x68(a0)
+;;       slli    a4, a2, 0x20
+;;       srli    a1, a4, 0x20
+;;       lui     a4, 1
+;;       addi    a2, a4, 4
+;;       sub     a5, a5, a2
+;;       bltu    a5, a1, 0x28
+;;       ld      a0, 0x60(a0)
+;;       add     a0, a0, a1
+;;       lui     t6, 1
+;;       add     t6, t6, a0
+;;       lw      a0, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..e14683cde5d0
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,73 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       slli    a2, a2, 0x20
+;;       srli    a4, a2, 0x20
+;;       lui     a1, 0x3fffc
+;;       addi    a5, a1, 1
+;;       slli    a5, a5, 2
+;;       add     a5, a4, a5
+;;       bgeu    a5, a4, 8
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       ld      a1, 0x68(a0)
+;;       bltu    a1, a5, 0x2c
+;;       ld      a5, 0x60(a0)
+;;       add     a5, a5, a4
+;;       lui     a4, 0xffff
+;;       slli    a0, a4, 4
+;;       add     a5, a5, a0
+;;       sw      a3, 0(a5)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       slli    a2, a2, 0x20
+;;       srli    a4, a2, 0x20
+;;       lui     a1, 0x3fffc
+;;       addi    a3, a1, 1
+;;       slli    a5, a3, 2
+;;       add     a3, a4, a5
+;;       bgeu    a3, a4, 8
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       ld      a5, 0x68(a0)
+;;       bltu    a5, a3, 0x2c
+;;       ld      a5, 0x60(a0)
+;;       add     a5, a5, a4
+;;       lui     a4, 0xffff
+;;       slli    a0, a4, 4
+;;       add     a5, a5, a0
+;;       lw      a0, 0(a5)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..e8adc7325cd4
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a5, 0x68(a0)
+;;       slli    a1, a2, 0x20
+;;       srli    a4, a1, 0x20
+;;       bgeu    a4, a5, 0x20
+;;       ld      a5, 0x60(a0)
+;;       add     a4, a5, a4
+;;       sb      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x68(a0)
+;;       slli    a1, a2, 0x20
+;;       srli    a3, a1, 0x20
+;;       bgeu    a3, a4, 0x20
+;;       ld      a4, 0x60(a0)
+;;       add     a3, a4, a3
+;;       lbu     a0, 0(a3)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..b02c9a1c6580
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,65 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a5, 0x68(a0)
+;;       slli    a4, a2, 0x20
+;;       srli    a1, a4, 0x20
+;;       lui     a4, 1
+;;       addi    a2, a4, 1
+;;       sub     a5, a5, a2
+;;       bltu    a5, a1, 0x28
+;;       ld      a0, 0x60(a0)
+;;       add     a0, a0, a1
+;;       lui     t6, 1
+;;       add     t6, t6, a0
+;;       sb      a3, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a5, 0x68(a0)
+;;       slli    a4, a2, 0x20
+;;       srli    a1, a4, 0x20
+;;       lui     a4, 1
+;;       addi    a2, a4, 1
+;;       sub     a5, a5, a2
+;;       bltu    a5, a1, 0x28
+;;       ld      a0, 0x60(a0)
+;;       add     a0, a0, a1
+;;       lui     t6, 1
+;;       add     t6, t6, a0
+;;       lbu     a0, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..c6136a36de8c
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,75 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       slli    a1, a2, 0x20
+;;       srli    a2, a1, 0x20
+;;       auipc   a1, 0
+;;       ld      a1, 0x48(a1)
+;;       add     a1, a2, a1
+;;       bgeu    a1, a2, 8
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       ld      a4, 0x68(a0)
+;;       bltu    a4, a1, 0x2c
+;;       ld      a4, 0x60(a0)
+;;       add     a4, a4, a2
+;;       lui     a2, 0xffff
+;;       slli    a5, a2, 4
+;;       add     a4, a4, a5
+;;       sb      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0x01, 0x00, 0xff, 0xff
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       slli    a1, a2, 0x20
+;;       srli    a2, a1, 0x20
+;;       auipc   a1, 0
+;;       ld      a1, 0x48(a1)
+;;       add     a1, a2, a1
+;;       bgeu    a1, a2, 8
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       ld      a3, 0x68(a0)
+;;       bltu    a3, a1, 0x2c
+;;       ld      a3, 0x60(a0)
+;;       add     a3, a3, a2
+;;       lui     a2, 0xffff
+;;       slli    a4, a2, 4
+;;       add     a3, a3, a4
+;;       lbu     a0, 0(a3)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0x01, 0x00, 0xff, 0xff
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..1b8081d102af
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a5, 0x68(a0)
+;;       ld      a1, 0x60(a0)
+;;       slli    a0, a2, 0x20
+;;       srli    a4, a0, 0x20
+;;       addi    a2, a5, -4
+;;       sltu    a2, a2, a4
+;;       add     a1, a1, a4
+;;       neg     a5, a2
+;;       not     a2, a5
+;;       and     a4, a1, a2
+;;       sw      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x68(a0)
+;;       ld      a1, 0x60(a0)
+;;       slli    a0, a2, 0x20
+;;       srli    a3, a0, 0x20
+;;       addi    a2, a4, -4
+;;       sltu    a2, a2, a3
+;;       add     a1, a1, a3
+;;       neg     a5, a2
+;;       not     a2, a5
+;;       and     a3, a1, a2
+;;       lw      a0, 0(a3)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..7ce194786d3c
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,69 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x68(a0)
+;;       ld      a5, 0x60(a0)
+;;       slli    a0, a2, 0x20
+;;       srli    a1, a0, 0x20
+;;       lui     a0, 1
+;;       addi    a0, a0, 4
+;;       sub     a0, a4, a0
+;;       sltu    a0, a0, a1
+;;       add     a5, a5, a1
+;;       lui     a1, 1
+;;       add     a5, a5, a1
+;;       neg     a4, a0
+;;       not     a0, a4
+;;       and     a1, a5, a0
+;;       sw      a3, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a3, 0x68(a0)
+;;       ld      a5, 0x60(a0)
+;;       slli    a4, a2, 0x20
+;;       srli    a1, a4, 0x20
+;;       lui     a4, 1
+;;       addi    a0, a4, 4
+;;       sub     a0, a3, a0
+;;       sltu    a0, a0, a1
+;;       add     a5, a5, a1
+;;       lui     a1, 1
+;;       add     a5, a5, a1
+;;       neg     a3, a0
+;;       not     a0, a3
+;;       and     a1, a5, a0
+;;       lw      a0, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..ab45a00f16e1
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,77 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       slli    a1, a2, 0x20
+;;       srli    a2, a1, 0x20
+;;       lui     a5, 0x3fffc
+;;       addi    a1, a5, 1
+;;       slli    a4, a1, 2
+;;       add     a1, a2, a4
+;;       bgeu    a1, a2, 8
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       ld      a4, 0x68(a0)
+;;       ld      a5, 0x60(a0)
+;;       sltu    a4, a4, a1
+;;       add     a2, a5, a2
+;;       lui     a1, 0xffff
+;;       slli    a5, a1, 4
+;;       add     a2, a2, a5
+;;       neg     a0, a4
+;;       not     a4, a0
+;;       and     a4, a2, a4
+;;       sw      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       slli    a1, a2, 0x20
+;;       srli    a2, a1, 0x20
+;;       lui     a5, 0x3fffc
+;;       addi    a1, a5, 1
+;;       slli    a3, a1, 2
+;;       add     a1, a2, a3
+;;       bgeu    a1, a2, 8
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       ld      a3, 0x68(a0)
+;;       ld      a4, 0x60(a0)
+;;       sltu    a3, a3, a1
+;;       add     a2, a4, a2
+;;       lui     a1, 0xffff
+;;       slli    a4, a1, 4
+;;       add     a2, a2, a4
+;;       neg     a0, a3
+;;       not     a3, a0
+;;       and     a4, a2, a3
+;;       lw      a0, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..0dc87a643aeb
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a5, 0x68(a0)
+;;       ld      a1, 0x60(a0)
+;;       slli    a0, a2, 0x20
+;;       srli    a4, a0, 0x20
+;;       sltu    a0, a4, a5
+;;       xori    a2, a0, 1
+;;       add     a1, a1, a4
+;;       neg     a5, a2
+;;       not     a2, a5
+;;       and     a4, a1, a2
+;;       sb      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x68(a0)
+;;       ld      a1, 0x60(a0)
+;;       slli    a0, a2, 0x20
+;;       srli    a3, a0, 0x20
+;;       sltu    a0, a3, a4
+;;       xori    a2, a0, 1
+;;       add     a1, a1, a3
+;;       neg     a5, a2
+;;       not     a2, a5
+;;       and     a3, a1, a2
+;;       lbu     a0, 0(a3)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..200c4d13312c
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,69 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x68(a0)
+;;       ld      a5, 0x60(a0)
+;;       slli    a0, a2, 0x20
+;;       srli    a1, a0, 0x20
+;;       lui     a0, 1
+;;       addi    a0, a0, 1
+;;       sub     a0, a4, a0
+;;       sltu    a0, a0, a1
+;;       add     a5, a5, a1
+;;       lui     a1, 1
+;;       add     a5, a5, a1
+;;       neg     a4, a0
+;;       not     a0, a4
+;;       and     a1, a5, a0
+;;       sb      a3, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a3, 0x68(a0)
+;;       ld      a5, 0x60(a0)
+;;       slli    a4, a2, 0x20
+;;       srli    a1, a4, 0x20
+;;       lui     a4, 1
+;;       addi    a0, a4, 1
+;;       sub     a0, a3, a0
+;;       sltu    a0, a0, a1
+;;       add     a5, a5, a1
+;;       lui     a1, 1
+;;       add     a5, a5, a1
+;;       neg     a3, a0
+;;       not     a0, a3
+;;       and     a1, a5, a0
+;;       lbu     a0, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..2a54231215f3
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,83 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       mv      a1, a0
+;;       slli    a4, a2, 0x20
+;;       srli    a0, a4, 0x20
+;;       auipc   a5, 0
+;;       ld      a5, 0x54(a5)
+;;       add     a5, a0, a5
+;;       bgeu    a5, a0, 8
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       mv      a2, a1
+;;       ld      a1, 0x68(a2)
+;;       ld      a2, 0x60(a2)
+;;       sltu    a1, a1, a5
+;;       add     a0, a2, a0
+;;       lui     a5, 0xffff
+;;       slli    a2, a5, 4
+;;       add     a0, a0, a2
+;;       neg     a4, a1
+;;       not     a1, a4
+;;       and     a2, a0, a1
+;;       sb      a3, 0(a2)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x01, 0x00, 0xff, 0xff
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       mv      a1, a0
+;;       slli    a4, a2, 0x20
+;;       srli    a0, a4, 0x20
+;;       auipc   a5, 0
+;;       ld      a5, 0x54(a5)
+;;       add     a5, a0, a5
+;;       bgeu    a5, a0, 8
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       mv      a2, a1
+;;       ld      a1, 0x68(a2)
+;;       ld      a2, 0x60(a2)
+;;       sltu    a1, a1, a5
+;;       add     a0, a2, a0
+;;       lui     a5, 0xffff
+;;       slli    a2, a5, 4
+;;       add     a0, a0, a2
+;;       neg     a4, a1
+;;       not     a1, a4
+;;       and     a2, a0, a1
+;;       lbu     a0, 0(a2)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x01, 0x00, 0xff, 0xff
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..531e11a4a2f3
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a5, 0x68(a0)
+;;       slli    a1, a2, 0x20
+;;       srli    a4, a1, 0x20
+;;       bltu    a5, a4, 0x20
+;;       ld      a5, 0x60(a0)
+;;       add     a4, a5, a4
+;;       sw      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x68(a0)
+;;       slli    a1, a2, 0x20
+;;       srli    a3, a1, 0x20
+;;       bltu    a4, a3, 0x20
+;;       ld      a4, 0x60(a0)
+;;       add     a3, a4, a3
+;;       lw      a0, 0(a3)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..6a20f42beaa6
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a5, 0x68(a0)
+;;       slli    a1, a2, 0x20
+;;       srli    a4, a1, 0x20
+;;       bltu    a5, a4, 0x28
+;;       ld      a5, 0x60(a0)
+;;       add     a4, a5, a4
+;;       lui     t6, 1
+;;       add     t6, t6, a4
+;;       sw      a3, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x68(a0)
+;;       slli    a1, a2, 0x20
+;;       srli    a3, a1, 0x20
+;;       bltu    a4, a3, 0x28
+;;       ld      a4, 0x60(a0)
+;;       add     a3, a4, a3
+;;       lui     t6, 1
+;;       add     t6, t6, a3
+;;       lw      a0, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..159e8b29ee34
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a5, 0x68(a0)
+;;       slli    a4, a2, 0x20
+;;       srli    a1, a4, 0x20
+;;       bltu    a5, a1, 0x2c
+;;       ld      a0, 0x60(a0)
+;;       add     a0, a0, a1
+;;       lui     a5, 0xffff
+;;       slli    a1, a5, 4
+;;       add     a0, a0, a1
+;;       sw      a3, 0(a0)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a5, 0x68(a0)
+;;       slli    a4, a2, 0x20
+;;       srli    a1, a4, 0x20
+;;       bltu    a5, a1, 0x2c
+;;       ld      a0, 0x60(a0)
+;;       add     a0, a0, a1
+;;       lui     a5, 0xffff
+;;       slli    a1, a5, 4
+;;       add     a0, a0, a1
+;;       lw      a0, 0(a0)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..16656d257426
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a5, 0x68(a0)
+;;       slli    a1, a2, 0x20
+;;       srli    a4, a1, 0x20
+;;       bgeu    a4, a5, 0x20
+;;       ld      a5, 0x60(a0)
+;;       add     a4, a5, a4
+;;       sb      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x68(a0)
+;;       slli    a1, a2, 0x20
+;;       srli    a3, a1, 0x20
+;;       bgeu    a3, a4, 0x20
+;;       ld      a4, 0x60(a0)
+;;       add     a3, a4, a3
+;;       lbu     a0, 0(a3)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..e6697dc26624
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a5, 0x68(a0)
+;;       slli    a1, a2, 0x20
+;;       srli    a4, a1, 0x20
+;;       bltu    a5, a4, 0x28
+;;       ld      a5, 0x60(a0)
+;;       add     a4, a5, a4
+;;       lui     t6, 1
+;;       add     t6, t6, a4
+;;       sb      a3, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x68(a0)
+;;       slli    a1, a2, 0x20
+;;       srli    a3, a1, 0x20
+;;       bltu    a4, a3, 0x28
+;;       ld      a4, 0x60(a0)
+;;       add     a3, a4, a3
+;;       lui     t6, 1
+;;       add     t6, t6, a3
+;;       lbu     a0, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..923f81e025cb
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a5, 0x68(a0)
+;;       slli    a4, a2, 0x20
+;;       srli    a1, a4, 0x20
+;;       bltu    a5, a1, 0x2c
+;;       ld      a0, 0x60(a0)
+;;       add     a0, a0, a1
+;;       lui     a5, 0xffff
+;;       slli    a1, a5, 4
+;;       add     a0, a0, a1
+;;       sb      a3, 0(a0)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a5, 0x68(a0)
+;;       slli    a4, a2, 0x20
+;;       srli    a1, a4, 0x20
+;;       bltu    a5, a1, 0x2c
+;;       ld      a0, 0x60(a0)
+;;       add     a0, a0, a1
+;;       lui     a5, 0xffff
+;;       slli    a1, a5, 4
+;;       add     a0, a0, a1
+;;       lbu     a0, 0(a0)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..d76a8eb4c916
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x68(a0)
+;;       ld      a1, 0x60(a0)
+;;       slli    a5, a2, 0x20
+;;       srli    a2, a5, 0x20
+;;       sltu    a4, a4, a2
+;;       add     a0, a1, a2
+;;       neg     a4, a4
+;;       not     a1, a4
+;;       and     a2, a0, a1
+;;       sw      a3, 0(a2)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a3, 0x68(a0)
+;;       ld      a1, 0x60(a0)
+;;       slli    a5, a2, 0x20
+;;       srli    a2, a5, 0x20
+;;       sltu    a3, a3, a2
+;;       add     a0, a1, a2
+;;       neg     a4, a3
+;;       not     a1, a4
+;;       and     a2, a0, a1
+;;       lw      a0, 0(a2)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..91c6c80ce620
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a5, 0x68(a0)
+;;       ld      a4, 0x60(a0)
+;;       slli    a1, a2, 0x20
+;;       srli    a0, a1, 0x20
+;;       sltu    a2, a5, a0
+;;       add     a4, a4, a0
+;;       lui     a5, 1
+;;       add     a4, a4, a5
+;;       neg     a0, a2
+;;       not     a2, a0
+;;       and     a4, a4, a2
+;;       sw      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x68(a0)
+;;       ld      a3, 0x60(a0)
+;;       slli    a1, a2, 0x20
+;;       srli    a5, a1, 0x20
+;;       sltu    a2, a4, a5
+;;       add     a3, a3, a5
+;;       lui     a4, 1
+;;       add     a3, a3, a4
+;;       neg     a0, a2
+;;       not     a2, a0
+;;       and     a4, a3, a2
+;;       lw      a0, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..1eb8ed65abab
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,65 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x68(a0)
+;;       ld      a5, 0x60(a0)
+;;       slli    a2, a2, 0x20
+;;       srli    a0, a2, 0x20
+;;       sltu    a4, a4, a0
+;;       add     a5, a5, a0
+;;       lui     a2, 0xffff
+;;       slli    a0, a2, 4
+;;       add     a5, a5, a0
+;;       neg     a1, a4
+;;       not     a4, a1
+;;       and     a5, a5, a4
+;;       sw      a3, 0(a5)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a3, 0x68(a0)
+;;       ld      a4, 0x60(a0)
+;;       slli    a2, a2, 0x20
+;;       srli    a5, a2, 0x20
+;;       sltu    a3, a3, a5
+;;       add     a4, a4, a5
+;;       lui     a2, 0xffff
+;;       slli    a5, a2, 4
+;;       add     a4, a4, a5
+;;       neg     a1, a3
+;;       not     a3, a1
+;;       and     a5, a4, a3
+;;       lw      a0, 0(a5)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..84168df87edd
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a5, 0x68(a0)
+;;       ld      a1, 0x60(a0)
+;;       slli    a0, a2, 0x20
+;;       srli    a4, a0, 0x20
+;;       sltu    a0, a4, a5
+;;       xori    a2, a0, 1
+;;       add     a1, a1, a4
+;;       neg     a5, a2
+;;       not     a2, a5
+;;       and     a4, a1, a2
+;;       sb      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x68(a0)
+;;       ld      a1, 0x60(a0)
+;;       slli    a0, a2, 0x20
+;;       srli    a3, a0, 0x20
+;;       sltu    a0, a3, a4
+;;       xori    a2, a0, 1
+;;       add     a1, a1, a3
+;;       neg     a5, a2
+;;       not     a2, a5
+;;       and     a3, a1, a2
+;;       lbu     a0, 0(a3)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..01269284adf7
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a5, 0x68(a0)
+;;       ld      a4, 0x60(a0)
+;;       slli    a1, a2, 0x20
+;;       srli    a0, a1, 0x20
+;;       sltu    a2, a5, a0
+;;       add     a4, a4, a0
+;;       lui     a5, 1
+;;       add     a4, a4, a5
+;;       neg     a0, a2
+;;       not     a2, a0
+;;       and     a4, a4, a2
+;;       sb      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x68(a0)
+;;       ld      a3, 0x60(a0)
+;;       slli    a1, a2, 0x20
+;;       srli    a5, a1, 0x20
+;;       sltu    a2, a4, a5
+;;       add     a3, a3, a5
+;;       lui     a4, 1
+;;       add     a3, a3, a4
+;;       neg     a0, a2
+;;       not     a2, a0
+;;       and     a4, a3, a2
+;;       lbu     a0, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..43e39e778e8e
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,65 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x68(a0)
+;;       ld      a5, 0x60(a0)
+;;       slli    a2, a2, 0x20
+;;       srli    a0, a2, 0x20
+;;       sltu    a4, a4, a0
+;;       add     a5, a5, a0
+;;       lui     a2, 0xffff
+;;       slli    a0, a2, 4
+;;       add     a5, a5, a0
+;;       neg     a1, a4
+;;       not     a4, a1
+;;       and     a5, a5, a4
+;;       sb      a3, 0(a5)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a3, 0x68(a0)
+;;       ld      a4, 0x60(a0)
+;;       slli    a2, a2, 0x20
+;;       srli    a5, a2, 0x20
+;;       sltu    a3, a3, a5
+;;       add     a4, a4, a5
+;;       lui     a2, 0xffff
+;;       slli    a5, a2, 4
+;;       add     a4, a4, a5
+;;       neg     a1, a3
+;;       not     a3, a1
+;;       and     a5, a4, a3
+;;       lbu     a0, 0(a5)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..7b2f9bf937bf
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,53 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x68(a0)
+;;       addi    a1, a1, -4
+;;       bltu    a1, a2, 0x20
+;;       ld      a4, 0x60(a0)
+;;       add     a2, a4, a2
+;;       sw      a3, 0(a2)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x68(a0)
+;;       addi    a1, a1, -4
+;;       bltu    a1, a2, 0x20
+;;       ld      a3, 0x60(a0)
+;;       add     a2, a3, a2
+;;       lw      a0, 0(a2)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..c1d9cc6ed516
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x68(a0)
+;;       lui     a5, 1
+;;       addi    a5, a5, 4
+;;       sub     a4, a4, a5
+;;       bltu    a4, a2, 0x28
+;;       ld      a4, 0x60(a0)
+;;       add     a4, a4, a2
+;;       lui     t6, 1
+;;       add     t6, t6, a4
+;;       sw      a3, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a3, 0x68(a0)
+;;       lui     a4, 1
+;;       addi    a4, a4, 4
+;;       sub     a3, a3, a4
+;;       bltu    a3, a2, 0x28
+;;       ld      a4, 0x60(a0)
+;;       add     a4, a4, a2
+;;       lui     t6, 1
+;;       add     t6, t6, a4
+;;       lw      a0, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..8a218c77ac33
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,69 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a5, 0x3fffc
+;;       addi    a1, a5, 1
+;;       slli    a4, a1, 2
+;;       add     a1, a2, a4
+;;       bgeu    a1, a2, 8
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       ld      a4, 0x68(a0)
+;;       bltu    a4, a1, 0x2c
+;;       ld      a4, 0x60(a0)
+;;       add     a4, a4, a2
+;;       lui     a2, 0xffff
+;;       slli    a5, a2, 4
+;;       add     a4, a4, a5
+;;       sw      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a5, 0x3fffc
+;;       addi    a1, a5, 1
+;;       slli    a3, a1, 2
+;;       add     a1, a2, a3
+;;       bgeu    a1, a2, 8
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       ld      a3, 0x68(a0)
+;;       bltu    a3, a1, 0x2c
+;;       ld      a3, 0x60(a0)
+;;       add     a3, a3, a2
+;;       lui     a2, 0xffff
+;;       slli    a4, a2, 4
+;;       add     a3, a3, a4
+;;       lw      a0, 0(a3)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..92ee6333ddfa
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x68(a0)
+;;       bgeu    a2, a1, 0x20
+;;       ld      a1, 0x60(a0)
+;;       add     a1, a1, a2
+;;       sb      a3, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x68(a0)
+;;       bgeu    a2, a1, 0x20
+;;       ld      a1, 0x60(a0)
+;;       add     a1, a1, a2
+;;       lbu     a0, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..1fcb05531e0e
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x68(a0)
+;;       lui     a5, 1
+;;       addi    a5, a5, 1
+;;       sub     a4, a4, a5
+;;       bltu    a4, a2, 0x28
+;;       ld      a4, 0x60(a0)
+;;       add     a4, a4, a2
+;;       lui     t6, 1
+;;       add     t6, t6, a4
+;;       sb      a3, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a3, 0x68(a0)
+;;       lui     a4, 1
+;;       addi    a4, a4, 1
+;;       sub     a3, a3, a4
+;;       bltu    a3, a2, 0x28
+;;       ld      a4, 0x60(a0)
+;;       add     a4, a4, a2
+;;       lui     t6, 1
+;;       add     t6, t6, a4
+;;       lbu     a0, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..f5c120dea3b2
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,71 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       auipc   a5, 0
+;;       ld      a5, 0x48(a5)
+;;       add     a5, a2, a5
+;;       bgeu    a5, a2, 8
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       ld      a1, 0x68(a0)
+;;       bltu    a1, a5, 0x2c
+;;       ld      a1, 0x60(a0)
+;;       add     a1, a1, a2
+;;       lui     a0, 0xffff
+;;       slli    a2, a0, 4
+;;       add     a1, a1, a2
+;;       sb      a3, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0x01, 0x00, 0xff, 0xff
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       auipc   a5, 0
+;;       ld      a5, 0x48(a5)
+;;       add     a5, a2, a5
+;;       bgeu    a5, a2, 8
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       ld      a1, 0x68(a0)
+;;       bltu    a1, a5, 0x2c
+;;       ld      a1, 0x60(a0)
+;;       add     a1, a1, a2
+;;       lui     a0, 0xffff
+;;       slli    a2, a0, 4
+;;       add     a1, a1, a2
+;;       lbu     a0, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0x01, 0x00, 0xff, 0xff
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..e7554d6aa4f4
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x68(a0)
+;;       ld      a5, 0x60(a0)
+;;       addi    a0, a1, -4
+;;       sltu    a0, a0, a2
+;;       add     a5, a5, a2
+;;       neg     a4, a0
+;;       not     a0, a4
+;;       and     a1, a5, a0
+;;       sw      a3, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x68(a0)
+;;       ld      a5, 0x60(a0)
+;;       addi    a0, a1, -4
+;;       sltu    a0, a0, a2
+;;       add     a5, a5, a2
+;;       neg     a3, a0
+;;       not     a0, a3
+;;       and     a1, a5, a0
+;;       lw      a0, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..4dcc45bac03d
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,65 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a5, 0x68(a0)
+;;       ld      a4, 0x60(a0)
+;;       lui     a0, 1
+;;       addi    a0, a0, 4
+;;       sub     a5, a5, a0
+;;       sltu    a5, a5, a2
+;;       add     a4, a4, a2
+;;       lui     a0, 1
+;;       add     a4, a4, a0
+;;       neg     a1, a5
+;;       not     a5, a1
+;;       and     a5, a4, a5
+;;       sw      a3, 0(a5)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x68(a0)
+;;       ld      a3, 0x60(a0)
+;;       lui     a5, 1
+;;       addi    a5, a5, 4
+;;       sub     a4, a4, a5
+;;       sltu    a4, a4, a2
+;;       add     a3, a3, a2
+;;       lui     a5, 1
+;;       add     a3, a3, a5
+;;       neg     a1, a4
+;;       not     a4, a1
+;;       and     a5, a3, a4
+;;       lw      a0, 0(a5)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..b7f47a785a81
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,73 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a4, 0x3fffc
+;;       addi    a5, a4, 1
+;;       slli    a1, a5, 2
+;;       add     a5, a2, a1
+;;       bgeu    a5, a2, 8
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       ld      a1, 0x68(a0)
+;;       ld      a4, 0x60(a0)
+;;       sltu    a0, a1, a5
+;;       add     a1, a4, a2
+;;       lui     a5, 0xffff
+;;       slli    a2, a5, 4
+;;       add     a1, a1, a2
+;;       neg     a4, a0
+;;       not     a0, a4
+;;       and     a2, a1, a0
+;;       sw      a3, 0(a2)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a3, 0x3fffc
+;;       addi    a5, a3, 1
+;;       slli    a1, a5, 2
+;;       add     a5, a2, a1
+;;       bgeu    a5, a2, 8
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       ld      a1, 0x68(a0)
+;;       ld      a3, 0x60(a0)
+;;       sltu    a0, a1, a5
+;;       add     a1, a3, a2
+;;       lui     a5, 0xffff
+;;       slli    a2, a5, 4
+;;       add     a1, a1, a2
+;;       neg     a4, a0
+;;       not     a0, a4
+;;       and     a2, a1, a0
+;;       lw      a0, 0(a2)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..97236a0d80b2
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x68(a0)
+;;       ld      a5, 0x60(a0)
+;;       sltu    a4, a2, a1
+;;       xori    a0, a4, 1
+;;       add     a5, a5, a2
+;;       neg     a4, a0
+;;       not     a0, a4
+;;       and     a1, a5, a0
+;;       sb      a3, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x68(a0)
+;;       ld      a5, 0x60(a0)
+;;       sltu    a4, a2, a1
+;;       xori    a0, a4, 1
+;;       add     a5, a5, a2
+;;       neg     a3, a0
+;;       not     a0, a3
+;;       and     a1, a5, a0
+;;       lbu     a0, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..1c6c61ee05b4
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,65 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a5, 0x68(a0)
+;;       ld      a4, 0x60(a0)
+;;       lui     a0, 1
+;;       addi    a0, a0, 1
+;;       sub     a5, a5, a0
+;;       sltu    a5, a5, a2
+;;       add     a4, a4, a2
+;;       lui     a0, 1
+;;       add     a4, a4, a0
+;;       neg     a1, a5
+;;       not     a5, a1
+;;       and     a5, a4, a5
+;;       sb      a3, 0(a5)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x68(a0)
+;;       ld      a3, 0x60(a0)
+;;       lui     a5, 1
+;;       addi    a5, a5, 1
+;;       sub     a4, a4, a5
+;;       sltu    a4, a4, a2
+;;       add     a3, a3, a2
+;;       lui     a5, 1
+;;       add     a3, a3, a5
+;;       neg     a1, a4
+;;       not     a4, a1
+;;       and     a5, a3, a4
+;;       lbu     a0, 0(a5)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..323626ddae04
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,75 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       auipc   a4, 0
+;;       ld      a4, 0x50(a4)
+;;       add     a4, a2, a4
+;;       bgeu    a4, a2, 8
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       ld      a5, 0x68(a0)
+;;       ld      a0, 0x60(a0)
+;;       sltu    a4, a5, a4
+;;       add     a5, a0, a2
+;;       lui     a0, 0xffff
+;;       slli    a0, a0, 4
+;;       add     a5, a5, a0
+;;       neg     a2, a4
+;;       not     a4, a2
+;;       and     a0, a5, a4
+;;       sb      a3, 0(a0)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x01, 0x00, 0xff, 0xff
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       auipc   a3, 0
+;;       ld      a3, 0x50(a3)
+;;       add     a3, a2, a3
+;;       bgeu    a3, a2, 8
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       ld      a4, 0x68(a0)
+;;       ld      a5, 0x60(a0)
+;;       sltu    a4, a4, a3
+;;       add     a5, a5, a2
+;;       lui     a3, 0xffff
+;;       slli    a0, a3, 4
+;;       add     a5, a5, a0
+;;       neg     a2, a4
+;;       not     a4, a2
+;;       and     a0, a5, a4
+;;       lbu     a0, 0(a0)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x01, 0x00, 0xff, 0xff
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..abf8c248ea69
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x68(a0)
+;;       bltu    a1, a2, 0x20
+;;       ld      a1, 0x60(a0)
+;;       add     a1, a1, a2
+;;       sw      a3, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x68(a0)
+;;       bltu    a1, a2, 0x20
+;;       ld      a1, 0x60(a0)
+;;       add     a1, a1, a2
+;;       lw      a0, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..95600c8d78dc
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x68(a0)
+;;       bltu    a1, a2, 0x28
+;;       ld      a1, 0x60(a0)
+;;       add     a1, a1, a2
+;;       lui     t6, 1
+;;       add     t6, t6, a1
+;;       sw      a3, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x68(a0)
+;;       bltu    a1, a2, 0x28
+;;       ld      a1, 0x60(a0)
+;;       add     a1, a1, a2
+;;       lui     t6, 1
+;;       add     t6, t6, a1
+;;       lw      a0, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..815e2763b3b0
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x68(a0)
+;;       bltu    a4, a2, 0x2c
+;;       ld      a4, 0x60(a0)
+;;       add     a4, a4, a2
+;;       lui     a5, 0xffff
+;;       slli    a5, a5, 4
+;;       add     a4, a4, a5
+;;       sw      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a3, 0x68(a0)
+;;       bltu    a3, a2, 0x2c
+;;       ld      a4, 0x60(a0)
+;;       add     a4, a4, a2
+;;       lui     a3, 0xffff
+;;       slli    a5, a3, 4
+;;       add     a4, a4, a5
+;;       lw      a0, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..1c1ef6ce23da
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x68(a0)
+;;       bgeu    a2, a1, 0x20
+;;       ld      a1, 0x60(a0)
+;;       add     a1, a1, a2
+;;       sb      a3, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x68(a0)
+;;       bgeu    a2, a1, 0x20
+;;       ld      a1, 0x60(a0)
+;;       add     a1, a1, a2
+;;       lbu     a0, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..f07db908a25e
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x68(a0)
+;;       bltu    a1, a2, 0x28
+;;       ld      a1, 0x60(a0)
+;;       add     a1, a1, a2
+;;       lui     t6, 1
+;;       add     t6, t6, a1
+;;       sb      a3, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x68(a0)
+;;       bltu    a1, a2, 0x28
+;;       ld      a1, 0x60(a0)
+;;       add     a1, a1, a2
+;;       lui     t6, 1
+;;       add     t6, t6, a1
+;;       lbu     a0, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..9ac86b8e944f
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x68(a0)
+;;       bltu    a4, a2, 0x2c
+;;       ld      a4, 0x60(a0)
+;;       add     a4, a4, a2
+;;       lui     a5, 0xffff
+;;       slli    a5, a5, 4
+;;       add     a4, a4, a5
+;;       sb      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a3, 0x68(a0)
+;;       bltu    a3, a2, 0x2c
+;;       ld      a4, 0x60(a0)
+;;       add     a4, a4, a2
+;;       lui     a3, 0xffff
+;;       slli    a5, a3, 4
+;;       add     a4, a4, a5
+;;       lbu     a0, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..eeca2add1495
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x68(a0)
+;;       ld      a5, 0x60(a0)
+;;       sltu    a0, a4, a2
+;;       add     a4, a5, a2
+;;       neg     a2, a0
+;;       not     a5, a2
+;;       and     a0, a4, a5
+;;       sw      a3, 0(a0)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x68(a0)
+;;       ld      a5, 0x60(a0)
+;;       sltu    a0, a4, a2
+;;       add     a4, a5, a2
+;;       neg     a2, a0
+;;       not     a5, a2
+;;       and     a0, a4, a5
+;;       lw      a0, 0(a0)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..2a5b76471165
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x68(a0)
+;;       ld      a1, 0x60(a0)
+;;       sltu    a0, a4, a2
+;;       add     a1, a1, a2
+;;       lui     a2, 1
+;;       add     a1, a1, a2
+;;       neg     a4, a0
+;;       not     a0, a4
+;;       and     a2, a1, a0
+;;       sw      a3, 0(a2)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a3, 0x68(a0)
+;;       ld      a1, 0x60(a0)
+;;       sltu    a0, a3, a2
+;;       add     a1, a1, a2
+;;       lui     a2, 1
+;;       add     a1, a1, a2
+;;       neg     a4, a0
+;;       not     a0, a4
+;;       and     a2, a1, a0
+;;       lw      a0, 0(a2)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..752474ac45fe
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x68(a0)
+;;       ld      a4, 0x60(a0)
+;;       sltu    a1, a1, a2
+;;       add     a2, a4, a2
+;;       lui     a0, 0xffff
+;;       slli    a4, a0, 4
+;;       add     a2, a2, a4
+;;       neg     a5, a1
+;;       not     a1, a5
+;;       and     a4, a2, a1
+;;       sw      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x68(a0)
+;;       ld      a3, 0x60(a0)
+;;       sltu    a1, a1, a2
+;;       add     a2, a3, a2
+;;       lui     a0, 0xffff
+;;       slli    a3, a0, 4
+;;       add     a2, a2, a3
+;;       neg     a5, a1
+;;       not     a1, a5
+;;       and     a3, a2, a1
+;;       lw      a0, 0(a3)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..a3db45b2da6c
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x68(a0)
+;;       ld      a5, 0x60(a0)
+;;       sltu    a4, a2, a1
+;;       xori    a0, a4, 1
+;;       add     a5, a5, a2
+;;       neg     a4, a0
+;;       not     a0, a4
+;;       and     a1, a5, a0
+;;       sb      a3, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x68(a0)
+;;       ld      a5, 0x60(a0)
+;;       sltu    a4, a2, a1
+;;       xori    a0, a4, 1
+;;       add     a5, a5, a2
+;;       neg     a3, a0
+;;       not     a0, a3
+;;       and     a1, a5, a0
+;;       lbu     a0, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..82785a1f0a1f
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x68(a0)
+;;       ld      a1, 0x60(a0)
+;;       sltu    a0, a4, a2
+;;       add     a1, a1, a2
+;;       lui     a2, 1
+;;       add     a1, a1, a2
+;;       neg     a4, a0
+;;       not     a0, a4
+;;       and     a2, a1, a0
+;;       sb      a3, 0(a2)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a3, 0x68(a0)
+;;       ld      a1, 0x60(a0)
+;;       sltu    a0, a3, a2
+;;       add     a1, a1, a2
+;;       lui     a2, 1
+;;       add     a1, a1, a2
+;;       neg     a4, a0
+;;       not     a0, a4
+;;       and     a2, a1, a0
+;;       lbu     a0, 0(a2)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..62e2e2ea7a9a
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x68(a0)
+;;       ld      a4, 0x60(a0)
+;;       sltu    a1, a1, a2
+;;       add     a2, a4, a2
+;;       lui     a0, 0xffff
+;;       slli    a4, a0, 4
+;;       add     a2, a2, a4
+;;       neg     a5, a1
+;;       not     a1, a5
+;;       and     a4, a2, a1
+;;       sb      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x68(a0)
+;;       ld      a3, 0x60(a0)
+;;       sltu    a1, a1, a2
+;;       add     a2, a3, a2
+;;       lui     a0, 0xffff
+;;       slli    a3, a0, 4
+;;       add     a2, a2, a3
+;;       neg     a5, a1
+;;       not     a1, a5
+;;       and     a3, a2, a1
+;;       lbu     a0, 0(a3)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..982320fd6470
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       slli    a4, a2, 0x20
+;;       srli    a5, a4, 0x20
+;;       lui     a2, 0x40000
+;;       addi    a4, a2, -1
+;;       slli    a1, a4, 2
+;;       bltu    a1, a5, 0x20
+;;       ld      a0, 0x60(a0)
+;;       add     a5, a0, a5
+;;       sw      a3, 0(a5)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       slli    a3, a2, 0x20
+;;       srli    a5, a3, 0x20
+;;       lui     a2, 0x40000
+;;       addi    a4, a2, -1
+;;       slli    a1, a4, 2
+;;       bltu    a1, a5, 0x20
+;;       ld      a0, 0x60(a0)
+;;       add     a5, a0, a5
+;;       lw      a0, 0(a5)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..e55fa02b8a0b
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       slli    a4, a2, 0x20
+;;       srli    a5, a4, 0x20
+;;       lui     a2, 0x40000
+;;       addi    a4, a2, -0x401
+;;       slli    a1, a4, 2
+;;       bltu    a1, a5, 0x28
+;;       ld      a0, 0x60(a0)
+;;       add     a5, a0, a5
+;;       lui     t6, 1
+;;       add     t6, t6, a5
+;;       sw      a3, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       slli    a3, a2, 0x20
+;;       srli    a5, a3, 0x20
+;;       lui     a2, 0x40000
+;;       addi    a4, a2, -0x401
+;;       slli    a1, a4, 2
+;;       bltu    a1, a5, 0x28
+;;       ld      a0, 0x60(a0)
+;;       add     a5, a0, a5
+;;       lui     t6, 1
+;;       add     t6, t6, a5
+;;       lw      a0, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..f74acab0a517
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       slli    a5, a2, 0x20
+;;       srli    a1, a5, 0x20
+;;       lui     a5, 0x10
+;;       addi    a2, a5, -4
+;;       bltu    a2, a1, 0x2c
+;;       ld      a2, 0x60(a0)
+;;       add     a1, a2, a1
+;;       lui     a0, 0xffff
+;;       slli    a2, a0, 4
+;;       add     a1, a1, a2
+;;       sw      a3, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       slli    a5, a2, 0x20
+;;       srli    a1, a5, 0x20
+;;       lui     a5, 0x10
+;;       addi    a2, a5, -4
+;;       bltu    a2, a1, 0x2c
+;;       ld      a2, 0x60(a0)
+;;       add     a1, a2, a1
+;;       lui     a0, 0xffff
+;;       slli    a2, a0, 4
+;;       add     a1, a1, a2
+;;       lw      a0, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..c927e909f9fd
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x60(a0)
+;;       slli    a0, a2, 0x20
+;;       srli    a2, a0, 0x20
+;;       add     a1, a1, a2
+;;       sb      a3, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x60(a0)
+;;       slli    a0, a2, 0x20
+;;       srli    a2, a0, 0x20
+;;       add     a1, a1, a2
+;;       lbu     a0, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..4ad149903941
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       slli    a1, a2, 0x20
+;;       srli    a4, a1, 0x20
+;;       auipc   a2, 0
+;;       ld      a2, 0x38(a2)
+;;       bltu    a2, a4, 0x28
+;;       ld      a5, 0x60(a0)
+;;       add     a4, a5, a4
+;;       lui     t6, 1
+;;       add     t6, t6, a4
+;;       sb      a3, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0xff, 0xef, 0xff, 0xff
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       slli    a1, a2, 0x20
+;;       srli    a3, a1, 0x20
+;;       auipc   a2, 0
+;;       ld      a2, 0x38(a2)
+;;       bltu    a2, a3, 0x28
+;;       ld      a4, 0x60(a0)
+;;       add     a3, a4, a3
+;;       lui     t6, 1
+;;       add     t6, t6, a3
+;;       lbu     a0, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0xff, 0xef, 0xff, 0xff
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..d6c835c0bb27
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       slli    a5, a2, 0x20
+;;       srli    a1, a5, 0x20
+;;       lui     a5, 0x10
+;;       addi    a2, a5, -1
+;;       bltu    a2, a1, 0x2c
+;;       ld      a2, 0x60(a0)
+;;       add     a1, a2, a1
+;;       lui     a0, 0xffff
+;;       slli    a2, a0, 4
+;;       add     a1, a1, a2
+;;       sb      a3, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       slli    a5, a2, 0x20
+;;       srli    a1, a5, 0x20
+;;       lui     a5, 0x10
+;;       addi    a2, a5, -1
+;;       bltu    a2, a1, 0x2c
+;;       ld      a2, 0x60(a0)
+;;       add     a1, a2, a1
+;;       lui     a0, 0xffff
+;;       slli    a2, a0, 4
+;;       add     a1, a1, a2
+;;       lbu     a0, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..6b615f558d2b
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       slli    a1, a2, 0x20
+;;       srli    a4, a1, 0x20
+;;       lui     a1, 0x40000
+;;       addi    a2, a1, -1
+;;       slli    a5, a2, 2
+;;       sltu    a2, a5, a4
+;;       ld      a5, 0x60(a0)
+;;       add     a4, a5, a4
+;;       neg     a0, a2
+;;       not     a2, a0
+;;       and     a4, a4, a2
+;;       sw      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       slli    a1, a2, 0x20
+;;       srli    a3, a1, 0x20
+;;       lui     a1, 0x40000
+;;       addi    a2, a1, -1
+;;       slli    a4, a2, 2
+;;       sltu    a2, a4, a3
+;;       ld      a4, 0x60(a0)
+;;       add     a3, a4, a3
+;;       neg     a0, a2
+;;       not     a2, a0
+;;       and     a4, a3, a2
+;;       lw      a0, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..6f5efbb61e43
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       slli    a4, a2, 0x20
+;;       srli    a5, a4, 0x20
+;;       lui     a2, 0x40000
+;;       addi    a4, a2, -0x401
+;;       slli    a1, a4, 2
+;;       sltu    a4, a1, a5
+;;       ld      a0, 0x60(a0)
+;;       add     a5, a0, a5
+;;       lui     a0, 1
+;;       add     a5, a5, a0
+;;       neg     a2, a4
+;;       not     a4, a2
+;;       and     a0, a5, a4
+;;       sw      a3, 0(a0)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       slli    a3, a2, 0x20
+;;       srli    a5, a3, 0x20
+;;       lui     a2, 0x40000
+;;       addi    a4, a2, -0x401
+;;       slli    a1, a4, 2
+;;       sltu    a4, a1, a5
+;;       ld      a0, 0x60(a0)
+;;       add     a5, a0, a5
+;;       lui     a0, 1
+;;       add     a5, a5, a0
+;;       neg     a2, a4
+;;       not     a4, a2
+;;       and     a0, a5, a4
+;;       lw      a0, 0(a0)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..a00b13b89977
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       slli    a4, a2, 0x20
+;;       srli    a5, a4, 0x20
+;;       lui     a4, 0x10
+;;       addi    a1, a4, -4
+;;       sltu    a4, a1, a5
+;;       ld      a0, 0x60(a0)
+;;       add     a5, a0, a5
+;;       lui     a0, 0xffff
+;;       slli    a0, a0, 4
+;;       add     a5, a5, a0
+;;       neg     a2, a4
+;;       not     a4, a2
+;;       and     a0, a5, a4
+;;       sw      a3, 0(a0)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       slli    a3, a2, 0x20
+;;       srli    a5, a3, 0x20
+;;       lui     a3, 0x10
+;;       addi    a1, a3, -4
+;;       sltu    a4, a1, a5
+;;       ld      a0, 0x60(a0)
+;;       add     a5, a0, a5
+;;       lui     a3, 0xffff
+;;       slli    a0, a3, 4
+;;       add     a5, a5, a0
+;;       neg     a2, a4
+;;       not     a4, a2
+;;       and     a0, a5, a4
+;;       lw      a0, 0(a0)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..9924e63e1328
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x60(a0)
+;;       slli    a0, a2, 0x20
+;;       srli    a2, a0, 0x20
+;;       add     a1, a1, a2
+;;       sb      a3, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x60(a0)
+;;       slli    a0, a2, 0x20
+;;       srli    a2, a0, 0x20
+;;       add     a1, a1, a2
+;;       lbu     a0, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..9974f44aba34
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,71 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       slli    a1, a2, 0x20
+;;       srli    a4, a1, 0x20
+;;       auipc   a2, 0
+;;       ld      a2, 0x40(a2)
+;;       sltu    a2, a2, a4
+;;       ld      a5, 0x60(a0)
+;;       add     a4, a5, a4
+;;       lui     a5, 1
+;;       add     a4, a4, a5
+;;       neg     a0, a2
+;;       not     a2, a0
+;;       and     a4, a4, a2
+;;       sb      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0xff, 0xef, 0xff, 0xff
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       slli    a1, a2, 0x20
+;;       srli    a3, a1, 0x20
+;;       auipc   a2, 0
+;;       ld      a2, 0x40(a2)
+;;       sltu    a2, a2, a3
+;;       ld      a4, 0x60(a0)
+;;       add     a3, a4, a3
+;;       lui     a4, 1
+;;       add     a3, a3, a4
+;;       neg     a0, a2
+;;       not     a2, a0
+;;       and     a4, a3, a2
+;;       lbu     a0, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0xff, 0xef, 0xff, 0xff
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..48bb4518e484
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       slli    a4, a2, 0x20
+;;       srli    a5, a4, 0x20
+;;       lui     a4, 0x10
+;;       addi    a1, a4, -1
+;;       sltu    a4, a1, a5
+;;       ld      a0, 0x60(a0)
+;;       add     a5, a0, a5
+;;       lui     a0, 0xffff
+;;       slli    a0, a0, 4
+;;       add     a5, a5, a0
+;;       neg     a2, a4
+;;       not     a4, a2
+;;       and     a0, a5, a4
+;;       sb      a3, 0(a0)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       slli    a3, a2, 0x20
+;;       srli    a5, a3, 0x20
+;;       lui     a3, 0x10
+;;       addi    a1, a3, -1
+;;       sltu    a4, a1, a5
+;;       ld      a0, 0x60(a0)
+;;       add     a5, a0, a5
+;;       lui     a3, 0xffff
+;;       slli    a0, a3, 4
+;;       add     a5, a5, a0
+;;       neg     a2, a4
+;;       not     a4, a2
+;;       and     a0, a5, a4
+;;       lbu     a0, 0(a0)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..d56561f6b267
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x60(a0)
+;;       slli    a0, a2, 0x20
+;;       srli    a2, a0, 0x20
+;;       add     a1, a1, a2
+;;       sw      a3, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x60(a0)
+;;       slli    a0, a2, 0x20
+;;       srli    a2, a0, 0x20
+;;       add     a1, a1, a2
+;;       lw      a0, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..337497a5ed3b
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,53 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x60(a0)
+;;       slli    a0, a2, 0x20
+;;       srli    a2, a0, 0x20
+;;       add     a1, a1, a2
+;;       lui     t6, 1
+;;       add     t6, t6, a1
+;;       sw      a3, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x60(a0)
+;;       slli    a0, a2, 0x20
+;;       srli    a2, a0, 0x20
+;;       add     a1, a1, a2
+;;       lui     t6, 1
+;;       add     t6, t6, a1
+;;       lw      a0, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..816b48888f47
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x60(a0)
+;;       slli    a5, a2, 0x20
+;;       srli    a5, a5, 0x20
+;;       add     a4, a4, a5
+;;       lui     a5, 0xffff
+;;       slli    a5, a5, 4
+;;       add     a4, a4, a5
+;;       sw      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x60(a0)
+;;       slli    a3, a2, 0x20
+;;       srli    a5, a3, 0x20
+;;       add     a4, a4, a5
+;;       lui     a3, 0xffff
+;;       slli    a5, a3, 4
+;;       add     a4, a4, a5
+;;       lw      a0, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..74732dd284c4
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x60(a0)
+;;       slli    a0, a2, 0x20
+;;       srli    a2, a0, 0x20
+;;       add     a1, a1, a2
+;;       sb      a3, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x60(a0)
+;;       slli    a0, a2, 0x20
+;;       srli    a2, a0, 0x20
+;;       add     a1, a1, a2
+;;       lbu     a0, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..f24783aa6471
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,53 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x60(a0)
+;;       slli    a0, a2, 0x20
+;;       srli    a2, a0, 0x20
+;;       add     a1, a1, a2
+;;       lui     t6, 1
+;;       add     t6, t6, a1
+;;       sb      a3, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x60(a0)
+;;       slli    a0, a2, 0x20
+;;       srli    a2, a0, 0x20
+;;       add     a1, a1, a2
+;;       lui     t6, 1
+;;       add     t6, t6, a1
+;;       lbu     a0, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..5634077bd436
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x60(a0)
+;;       slli    a5, a2, 0x20
+;;       srli    a5, a5, 0x20
+;;       add     a4, a4, a5
+;;       lui     a5, 0xffff
+;;       slli    a5, a5, 4
+;;       add     a4, a4, a5
+;;       sb      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x60(a0)
+;;       slli    a3, a2, 0x20
+;;       srli    a5, a3, 0x20
+;;       add     a4, a4, a5
+;;       lui     a3, 0xffff
+;;       slli    a5, a3, 4
+;;       add     a4, a4, a5
+;;       lbu     a0, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..874d04aacb72
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x60(a0)
+;;       slli    a0, a2, 0x20
+;;       srli    a2, a0, 0x20
+;;       add     a1, a1, a2
+;;       sw      a3, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x60(a0)
+;;       slli    a0, a2, 0x20
+;;       srli    a2, a0, 0x20
+;;       add     a1, a1, a2
+;;       lw      a0, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..618466d83329
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,53 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x60(a0)
+;;       slli    a0, a2, 0x20
+;;       srli    a2, a0, 0x20
+;;       add     a1, a1, a2
+;;       lui     t6, 1
+;;       add     t6, t6, a1
+;;       sw      a3, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x60(a0)
+;;       slli    a0, a2, 0x20
+;;       srli    a2, a0, 0x20
+;;       add     a1, a1, a2
+;;       lui     t6, 1
+;;       add     t6, t6, a1
+;;       lw      a0, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..a10b0ae6eb88
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x60(a0)
+;;       slli    a5, a2, 0x20
+;;       srli    a5, a5, 0x20
+;;       add     a4, a4, a5
+;;       lui     a5, 0xffff
+;;       slli    a5, a5, 4
+;;       add     a4, a4, a5
+;;       sw      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x60(a0)
+;;       slli    a3, a2, 0x20
+;;       srli    a5, a3, 0x20
+;;       add     a4, a4, a5
+;;       lui     a3, 0xffff
+;;       slli    a5, a3, 4
+;;       add     a4, a4, a5
+;;       lw      a0, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..7ac732954dab
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x60(a0)
+;;       slli    a0, a2, 0x20
+;;       srli    a2, a0, 0x20
+;;       add     a1, a1, a2
+;;       sb      a3, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x60(a0)
+;;       slli    a0, a2, 0x20
+;;       srli    a2, a0, 0x20
+;;       add     a1, a1, a2
+;;       lbu     a0, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..d9a703654a3c
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,53 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x60(a0)
+;;       slli    a0, a2, 0x20
+;;       srli    a2, a0, 0x20
+;;       add     a1, a1, a2
+;;       lui     t6, 1
+;;       add     t6, t6, a1
+;;       sb      a3, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a1, 0x60(a0)
+;;       slli    a0, a2, 0x20
+;;       srli    a2, a0, 0x20
+;;       add     a1, a1, a2
+;;       lui     t6, 1
+;;       add     t6, t6, a1
+;;       lbu     a0, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..162cbe7770c8
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x60(a0)
+;;       slli    a5, a2, 0x20
+;;       srli    a5, a5, 0x20
+;;       add     a4, a4, a5
+;;       lui     a5, 0xffff
+;;       slli    a5, a5, 4
+;;       add     a4, a4, a5
+;;       sb      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       ld      a4, 0x60(a0)
+;;       slli    a3, a2, 0x20
+;;       srli    a5, a3, 0x20
+;;       add     a4, a4, a5
+;;       lui     a3, 0xffff
+;;       slli    a5, a3, 4
+;;       add     a4, a4, a5
+;;       lbu     a0, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..b57ddf1e207f
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a1, 0x40000
+;;       addi    a4, a1, -1
+;;       slli    a4, a4, 2
+;;       bltu    a4, a2, 0x20
+;;       ld      a4, 0x60(a0)
+;;       add     a4, a4, a2
+;;       sw      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a1, 0x40000
+;;       addi    a3, a1, -1
+;;       slli    a4, a3, 2
+;;       bltu    a4, a2, 0x20
+;;       ld      a3, 0x60(a0)
+;;       add     a3, a3, a2
+;;       lw      a0, 0(a3)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..6f8bfba67380
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a1, 0x40000
+;;       addi    a4, a1, -0x401
+;;       slli    a4, a4, 2
+;;       bltu    a4, a2, 0x28
+;;       ld      a4, 0x60(a0)
+;;       add     a4, a4, a2
+;;       lui     t6, 1
+;;       add     t6, t6, a4
+;;       sw      a3, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a1, 0x40000
+;;       addi    a3, a1, -0x401
+;;       slli    a4, a3, 2
+;;       bltu    a4, a2, 0x28
+;;       ld      a3, 0x60(a0)
+;;       add     a3, a3, a2
+;;       lui     t6, 1
+;;       add     t6, t6, a3
+;;       lw      a0, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..a2b7d42b694b
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a4, 0x10
+;;       addi    a5, a4, -4
+;;       bltu    a5, a2, 0x2c
+;;       ld      a5, 0x60(a0)
+;;       add     a5, a5, a2
+;;       lui     a4, 0xffff
+;;       slli    a0, a4, 4
+;;       add     a5, a5, a0
+;;       sw      a3, 0(a5)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a3, 0x10
+;;       addi    a5, a3, -4
+;;       bltu    a5, a2, 0x2c
+;;       ld      a5, 0x60(a0)
+;;       add     a5, a5, a2
+;;       lui     a4, 0xffff
+;;       slli    a0, a4, 4
+;;       add     a5, a5, a0
+;;       lw      a0, 0(a5)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..4657f41687b4
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       auipc   a1, 0
+;;       ld      a1, 0x30(a1)
+;;       bltu    a1, a2, 0x20
+;;       ld      a1, 0x60(a0)
+;;       add     a1, a1, a2
+;;       sb      a3, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0xff, 0xff, 0xff, 0xff
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       auipc   a1, 0
+;;       ld      a1, 0x30(a1)
+;;       bltu    a1, a2, 0x20
+;;       ld      a1, 0x60(a0)
+;;       add     a1, a1, a2
+;;       lbu     a0, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0xff, 0xff, 0xff, 0xff
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..ffb700415b59
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       auipc   a1, 0
+;;       ld      a1, 0x38(a1)
+;;       bltu    a1, a2, 0x28
+;;       ld      a1, 0x60(a0)
+;;       add     a1, a1, a2
+;;       lui     t6, 1
+;;       add     t6, t6, a1
+;;       sb      a3, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0xff, 0xef, 0xff, 0xff
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       auipc   a1, 0
+;;       ld      a1, 0x38(a1)
+;;       bltu    a1, a2, 0x28
+;;       ld      a1, 0x60(a0)
+;;       add     a1, a1, a2
+;;       lui     t6, 1
+;;       add     t6, t6, a1
+;;       lbu     a0, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0xff, 0xef, 0xff, 0xff
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..a11c473ce869
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a4, 0x10
+;;       addi    a5, a4, -1
+;;       bltu    a5, a2, 0x2c
+;;       ld      a5, 0x60(a0)
+;;       add     a5, a5, a2
+;;       lui     a4, 0xffff
+;;       slli    a0, a4, 4
+;;       add     a5, a5, a0
+;;       sb      a3, 0(a5)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a3, 0x10
+;;       addi    a5, a3, -1
+;;       bltu    a5, a2, 0x2c
+;;       ld      a5, 0x60(a0)
+;;       add     a5, a5, a2
+;;       lui     a4, 0xffff
+;;       slli    a0, a4, 4
+;;       add     a5, a5, a0
+;;       lbu     a0, 0(a5)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..0c2c47461dab
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a4, 0x40000
+;;       addi    a1, a4, -1
+;;       slli    a4, a1, 2
+;;       sltu    a1, a4, a2
+;;       ld      a0, 0x60(a0)
+;;       add     a0, a0, a2
+;;       neg     a4, a1
+;;       not     a1, a4
+;;       and     a2, a0, a1
+;;       sw      a3, 0(a2)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a4, 0x40000
+;;       addi    a1, a4, -1
+;;       slli    a3, a1, 2
+;;       sltu    a1, a3, a2
+;;       ld      a0, 0x60(a0)
+;;       add     a0, a0, a2
+;;       neg     a4, a1
+;;       not     a1, a4
+;;       and     a2, a0, a1
+;;       lw      a0, 0(a2)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..26eb6b645f8e
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a1, 0x40000
+;;       addi    a4, a1, -0x401
+;;       slli    a4, a4, 2
+;;       sltu    a4, a4, a2
+;;       ld      a5, 0x60(a0)
+;;       add     a2, a5, a2
+;;       lui     a5, 1
+;;       add     a2, a2, a5
+;;       neg     a0, a4
+;;       not     a4, a0
+;;       and     a4, a2, a4
+;;       sw      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a1, 0x40000
+;;       addi    a3, a1, -0x401
+;;       slli    a4, a3, 2
+;;       sltu    a3, a4, a2
+;;       ld      a4, 0x60(a0)
+;;       add     a2, a4, a2
+;;       lui     a4, 1
+;;       add     a2, a2, a4
+;;       neg     a0, a3
+;;       not     a3, a0
+;;       and     a4, a2, a3
+;;       lw      a0, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..39f2edf81046
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a1, 0x10
+;;       addi    a4, a1, -4
+;;       sltu    a4, a4, a2
+;;       ld      a5, 0x60(a0)
+;;       add     a2, a5, a2
+;;       lui     a1, 0xffff
+;;       slli    a5, a1, 4
+;;       add     a2, a2, a5
+;;       neg     a0, a4
+;;       not     a4, a0
+;;       and     a4, a2, a4
+;;       sw      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a1, 0x10
+;;       addi    a3, a1, -4
+;;       sltu    a3, a3, a2
+;;       ld      a4, 0x60(a0)
+;;       add     a2, a4, a2
+;;       lui     a1, 0xffff
+;;       slli    a4, a1, 4
+;;       add     a2, a2, a4
+;;       neg     a0, a3
+;;       not     a3, a0
+;;       and     a4, a2, a3
+;;       lw      a0, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..db3edf38668b
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       auipc   a4, 0
+;;       ld      a4, 0x38(a4)
+;;       sltu    a4, a4, a2
+;;       ld      a5, 0x60(a0)
+;;       add     a5, a5, a2
+;;       neg     a2, a4
+;;       not     a4, a2
+;;       and     a0, a5, a4
+;;       sb      a3, 0(a0)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0xff, 0xff, 0xff, 0xff
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       auipc   a4, 0
+;;       ld      a4, 0x38(a4)
+;;       sltu    a4, a4, a2
+;;       ld      a5, 0x60(a0)
+;;       add     a5, a5, a2
+;;       neg     a2, a4
+;;       not     a4, a2
+;;       and     a0, a5, a4
+;;       lbu     a0, 0(a0)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0xff, 0xff, 0xff, 0xff
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..77e05429ceae
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       auipc   a1, 0
+;;       ld      a1, 0x40(a1)
+;;       sltu    a4, a1, a2
+;;       ld      a0, 0x60(a0)
+;;       add     a0, a0, a2
+;;       lui     a1, 1
+;;       add     a1, a0, a1
+;;       neg     a4, a4
+;;       not     a0, a4
+;;       and     a2, a1, a0
+;;       sb      a3, 0(a2)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0xff, 0xef, 0xff, 0xff
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       auipc   a1, 0
+;;       ld      a1, 0x40(a1)
+;;       sltu    a3, a1, a2
+;;       ld      a0, 0x60(a0)
+;;       add     a0, a0, a2
+;;       lui     a1, 1
+;;       add     a1, a0, a1
+;;       neg     a4, a3
+;;       not     a0, a4
+;;       and     a2, a1, a0
+;;       lbu     a0, 0(a2)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0xff, 0xef, 0xff, 0xff
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..f5ecd2332706
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a1, 0x10
+;;       addi    a4, a1, -1
+;;       sltu    a4, a4, a2
+;;       ld      a5, 0x60(a0)
+;;       add     a2, a5, a2
+;;       lui     a1, 0xffff
+;;       slli    a5, a1, 4
+;;       add     a2, a2, a5
+;;       neg     a0, a4
+;;       not     a4, a0
+;;       and     a4, a2, a4
+;;       sb      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a1, 0x10
+;;       addi    a3, a1, -1
+;;       sltu    a3, a3, a2
+;;       ld      a4, 0x60(a0)
+;;       add     a2, a4, a2
+;;       lui     a1, 0xffff
+;;       slli    a4, a1, 4
+;;       add     a2, a2, a4
+;;       neg     a0, a3
+;;       not     a3, a0
+;;       and     a4, a2, a3
+;;       lbu     a0, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..3b15bd0cd0ae
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a1, 0x40000
+;;       addi    a4, a1, -1
+;;       slli    a4, a4, 2
+;;       bltu    a4, a2, 0x20
+;;       ld      a4, 0x60(a0)
+;;       add     a4, a4, a2
+;;       sw      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a1, 0x40000
+;;       addi    a3, a1, -1
+;;       slli    a4, a3, 2
+;;       bltu    a4, a2, 0x20
+;;       ld      a3, 0x60(a0)
+;;       add     a3, a3, a2
+;;       lw      a0, 0(a3)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..3b1b6dc73d5e
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a1, 0x40000
+;;       addi    a4, a1, -0x401
+;;       slli    a4, a4, 2
+;;       bltu    a4, a2, 0x28
+;;       ld      a4, 0x60(a0)
+;;       add     a4, a4, a2
+;;       lui     t6, 1
+;;       add     t6, t6, a4
+;;       sw      a3, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a1, 0x40000
+;;       addi    a3, a1, -0x401
+;;       slli    a4, a3, 2
+;;       bltu    a4, a2, 0x28
+;;       ld      a3, 0x60(a0)
+;;       add     a3, a3, a2
+;;       lui     t6, 1
+;;       add     t6, t6, a3
+;;       lw      a0, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..0bb1672ce39c
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a4, 0x10
+;;       addi    a5, a4, -4
+;;       bltu    a5, a2, 0x2c
+;;       ld      a5, 0x60(a0)
+;;       add     a5, a5, a2
+;;       lui     a4, 0xffff
+;;       slli    a0, a4, 4
+;;       add     a5, a5, a0
+;;       sw      a3, 0(a5)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a3, 0x10
+;;       addi    a5, a3, -4
+;;       bltu    a5, a2, 0x2c
+;;       ld      a5, 0x60(a0)
+;;       add     a5, a5, a2
+;;       lui     a4, 0xffff
+;;       slli    a0, a4, 4
+;;       add     a5, a5, a0
+;;       lw      a0, 0(a5)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..3321dde769f9
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       auipc   a1, 0
+;;       ld      a1, 0x30(a1)
+;;       bltu    a1, a2, 0x20
+;;       ld      a1, 0x60(a0)
+;;       add     a1, a1, a2
+;;       sb      a3, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0xff, 0xff, 0xff, 0xff
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       auipc   a1, 0
+;;       ld      a1, 0x30(a1)
+;;       bltu    a1, a2, 0x20
+;;       ld      a1, 0x60(a0)
+;;       add     a1, a1, a2
+;;       lbu     a0, 0(a1)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0xff, 0xff, 0xff, 0xff
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..044a39c4324e
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       auipc   a1, 0
+;;       ld      a1, 0x38(a1)
+;;       bltu    a1, a2, 0x28
+;;       ld      a1, 0x60(a0)
+;;       add     a1, a1, a2
+;;       lui     t6, 1
+;;       add     t6, t6, a1
+;;       sb      a3, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0xff, 0xef, 0xff, 0xff
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       auipc   a1, 0
+;;       ld      a1, 0x38(a1)
+;;       bltu    a1, a2, 0x28
+;;       ld      a1, 0x60(a0)
+;;       add     a1, a1, a2
+;;       lui     t6, 1
+;;       add     t6, t6, a1
+;;       lbu     a0, 0(t6)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0xff, 0xef, 0xff, 0xff
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..814f7f7a6999
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a4, 0x10
+;;       addi    a5, a4, -1
+;;       bltu    a5, a2, 0x2c
+;;       ld      a5, 0x60(a0)
+;;       add     a5, a5, a2
+;;       lui     a4, 0xffff
+;;       slli    a0, a4, 4
+;;       add     a5, a5, a0
+;;       sb      a3, 0(a5)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a3, 0x10
+;;       addi    a5, a3, -1
+;;       bltu    a5, a2, 0x2c
+;;       ld      a5, 0x60(a0)
+;;       add     a5, a5, a2
+;;       lui     a4, 0xffff
+;;       slli    a0, a4, 4
+;;       add     a5, a5, a0
+;;       lbu     a0, 0(a5)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..89b6ce2b9a08
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a4, 0x40000
+;;       addi    a1, a4, -1
+;;       slli    a4, a1, 2
+;;       sltu    a1, a4, a2
+;;       ld      a0, 0x60(a0)
+;;       add     a0, a0, a2
+;;       neg     a4, a1
+;;       not     a1, a4
+;;       and     a2, a0, a1
+;;       sw      a3, 0(a2)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a4, 0x40000
+;;       addi    a1, a4, -1
+;;       slli    a3, a1, 2
+;;       sltu    a1, a3, a2
+;;       ld      a0, 0x60(a0)
+;;       add     a0, a0, a2
+;;       neg     a4, a1
+;;       not     a1, a4
+;;       and     a2, a0, a1
+;;       lw      a0, 0(a2)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..080c265181da
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a1, 0x40000
+;;       addi    a4, a1, -0x401
+;;       slli    a4, a4, 2
+;;       sltu    a4, a4, a2
+;;       ld      a5, 0x60(a0)
+;;       add     a2, a5, a2
+;;       lui     a5, 1
+;;       add     a2, a2, a5
+;;       neg     a0, a4
+;;       not     a4, a0
+;;       and     a4, a2, a4
+;;       sw      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a1, 0x40000
+;;       addi    a3, a1, -0x401
+;;       slli    a4, a3, 2
+;;       sltu    a3, a4, a2
+;;       ld      a4, 0x60(a0)
+;;       add     a2, a4, a2
+;;       lui     a4, 1
+;;       add     a2, a2, a4
+;;       neg     a0, a3
+;;       not     a3, a0
+;;       and     a4, a2, a3
+;;       lw      a0, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..630be0970290
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a1, 0x10
+;;       addi    a4, a1, -4
+;;       sltu    a4, a4, a2
+;;       ld      a5, 0x60(a0)
+;;       add     a2, a5, a2
+;;       lui     a1, 0xffff
+;;       slli    a5, a1, 4
+;;       add     a2, a2, a5
+;;       neg     a0, a4
+;;       not     a4, a0
+;;       and     a4, a2, a4
+;;       sw      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a1, 0x10
+;;       addi    a3, a1, -4
+;;       sltu    a3, a3, a2
+;;       ld      a4, 0x60(a0)
+;;       add     a2, a4, a2
+;;       lui     a1, 0xffff
+;;       slli    a4, a1, 4
+;;       add     a2, a2, a4
+;;       neg     a0, a3
+;;       not     a3, a0
+;;       and     a4, a2, a3
+;;       lw      a0, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..21dac8f8eca5
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       auipc   a4, 0
+;;       ld      a4, 0x38(a4)
+;;       sltu    a4, a4, a2
+;;       ld      a5, 0x60(a0)
+;;       add     a5, a5, a2
+;;       neg     a2, a4
+;;       not     a4, a2
+;;       and     a0, a5, a4
+;;       sb      a3, 0(a0)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0xff, 0xff, 0xff, 0xff
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       auipc   a4, 0
+;;       ld      a4, 0x38(a4)
+;;       sltu    a4, a4, a2
+;;       ld      a5, 0x60(a0)
+;;       add     a5, a5, a2
+;;       neg     a2, a4
+;;       not     a4, a2
+;;       and     a0, a5, a4
+;;       lbu     a0, 0(a0)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0xff, 0xff, 0xff, 0xff
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..80489270b510
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       auipc   a1, 0
+;;       ld      a1, 0x40(a1)
+;;       sltu    a4, a1, a2
+;;       ld      a0, 0x60(a0)
+;;       add     a0, a0, a2
+;;       lui     a1, 1
+;;       add     a1, a0, a1
+;;       neg     a4, a4
+;;       not     a0, a4
+;;       and     a2, a1, a0
+;;       sb      a3, 0(a2)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0xff, 0xef, 0xff, 0xff
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       auipc   a1, 0
+;;       ld      a1, 0x40(a1)
+;;       sltu    a3, a1, a2
+;;       ld      a0, 0x60(a0)
+;;       add     a0, a0, a2
+;;       lui     a1, 1
+;;       add     a1, a0, a1
+;;       neg     a4, a3
+;;       not     a0, a4
+;;       and     a2, a1, a0
+;;       lbu     a0, 0(a2)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;       .byte   0x00, 0x00, 0x00, 0x00
+;;       .byte   0xff, 0xef, 0xff, 0xff
+;;       .byte   0x00, 0x00, 0x00, 0x00
diff --git a/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..147f94856b8a
--- /dev/null
+++ b/tests/disas/load-store/riscv64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a1, 0x10
+;;       addi    a4, a1, -1
+;;       sltu    a4, a4, a2
+;;       ld      a5, 0x60(a0)
+;;       add     a2, a5, a2
+;;       lui     a1, 0xffff
+;;       slli    a5, a1, 4
+;;       add     a2, a2, a5
+;;       neg     a0, a4
+;;       not     a4, a0
+;;       and     a4, a2, a4
+;;       sb      a3, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       lui     a1, 0x10
+;;       addi    a3, a1, -1
+;;       sltu    a3, a3, a2
+;;       ld      a4, 0x60(a0)
+;;       add     a2, a4, a2
+;;       lui     a1, 0xffff
+;;       slli    a4, a1, 4
+;;       add     a2, a2, a4
+;;       neg     a0, a3
+;;       not     a3, a0
+;;       and     a4, a2, a3
+;;       lbu     a0, 0(a4)
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..85b05d1ddf85
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lgr     %r6, %r4
+;;       lg      %r4, 0x68(%r2)
+;;       llgfr   %r3, %r6
+;;       aghi    %r4, -4
+;;       clgr    %r3, %r4
+;;       jgh     0x58
+;;       lg      %r6, 0x60(%r2)
+;;       strv    %r5, 0(%r3, %r6)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lgr     %r5, %r4
+;;       lg      %r4, 0x68(%r2)
+;;       llgfr   %r3, %r5
+;;       aghi    %r4, -4
+;;       clgr    %r3, %r4
+;;       jgh     0xb4
+;;       lg      %r5, 0x60(%r2)
+;;       lrv     %r2, 0(%r3, %r5)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..64a0afc6c83a
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lgr     %r6, %r4
+;;       lg      %r4, 0x68(%r2)
+;;       llgfr   %r3, %r6
+;;       aghi    %r4, -0x1004
+;;       clgr    %r3, %r4
+;;       jgh     0x5c
+;;       ag      %r3, 0x60(%r2)
+;;       lghi    %r6, 0x1000
+;;       strv    %r5, 0(%r6, %r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lgr     %r6, %r4
+;;       lg      %r4, 0x68(%r2)
+;;       llgfr   %r3, %r6
+;;       aghi    %r4, -0x1004
+;;       clgr    %r3, %r4
+;;       jgh     0xbc
+;;       ag      %r3, 0x60(%r2)
+;;       lghi    %r6, 0x1000
+;;       lrv     %r2, 0(%r6, %r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..42b7d4660489
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       lgr     %r3, %r4
+;;       llilf   %r4, 0xffff0004
+;;       algfr   %r4, %r3
+;;       jgnle   0x3c
+;;       lg      %r6, 0x68(%r2)
+;;       clgr    %r4, %r6
+;;       jgh     0x68
+;;       ag      %r7, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       strv    %r5, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       lgr     %r3, %r4
+;;       llilf   %r4, 0xffff0004
+;;       algfr   %r4, %r3
+;;       jgnle   0xa8
+;;       lg      %r6, 0x68(%r2)
+;;       clgr    %r4, %r6
+;;       jgh     0xd4
+;;       ag      %r7, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       lrv     %r2, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..c8340fc1f934
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lgr     %r6, %r4
+;;       lg      %r4, 0x68(%r2)
+;;       llgfr   %r3, %r6
+;;       clgr    %r3, %r4
+;;       jghe    0x52
+;;       lg      %r4, 0x60(%r2)
+;;       stc     %r5, 0(%r3, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lgr     %r5, %r4
+;;       lg      %r4, 0x68(%r2)
+;;       llgfr   %r3, %r5
+;;       clgr    %r3, %r4
+;;       jghe    0xa8
+;;       lg      %r4, 0x60(%r2)
+;;       llc     %r2, 0(%r3, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..9eb78571aed2
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lgr     %r6, %r4
+;;       lg      %r4, 0x68(%r2)
+;;       llgfr   %r3, %r6
+;;       aghi    %r4, -0x1001
+;;       clgr    %r3, %r4
+;;       jgh     0x5a
+;;       ag      %r3, 0x60(%r2)
+;;       lghi    %r6, 0x1000
+;;       stc     %r5, 0(%r6, %r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lgr     %r6, %r4
+;;       lg      %r4, 0x68(%r2)
+;;       llgfr   %r3, %r6
+;;       aghi    %r4, -0x1001
+;;       clgr    %r3, %r4
+;;       jgh     0xb8
+;;       ag      %r3, 0x60(%r2)
+;;       lghi    %r6, 0x1000
+;;       llc     %r2, 0(%r6, %r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..b3fd40f50cdb
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       lgr     %r3, %r4
+;;       llilf   %r4, 0xffff0001
+;;       algfr   %r4, %r3
+;;       jgnle   0x3c
+;;       lg      %r6, 0x68(%r2)
+;;       clgr    %r4, %r6
+;;       jgh     0x66
+;;       ag      %r7, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       stc     %r5, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       lgr     %r3, %r4
+;;       llilf   %r4, 0xffff0001
+;;       algfr   %r4, %r3
+;;       jgnle   0xa4
+;;       lg      %r6, 0x68(%r2)
+;;       clgr    %r4, %r6
+;;       jgh     0xd0
+;;       ag      %r7, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       llc     %r2, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..f1dfbbf17166
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x68(%r2)
+;;       llgfr   %r6, %r4
+;;       aghik   %r3, %r7, -4
+;;       lghi    %r7, 0
+;;       lgr     %r4, %r6
+;;       ag      %r4, 0x60(%r2)
+;;       clgr    %r6, %r3
+;;       locgrh  %r4, %r7
+;;       strv    %r5, 0(%r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r6, 0x68(%r2)
+;;       llgfr   %r5, %r4
+;;       aghik   %r7, %r6, -4
+;;       lghi    %r6, 0
+;;       lgr     %r4, %r5
+;;       ag      %r4, 0x60(%r2)
+;;       clgr    %r5, %r7
+;;       locgrh  %r4, %r6
+;;       lrv     %r2, 0(%r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..2a48fa145b9f
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x68(%r2)
+;;       llgfr   %r6, %r4
+;;       aghik   %r3, %r7, -0x1004
+;;       lghi    %r7, 0
+;;       lgr     %r4, %r6
+;;       ag      %r4, 0x60(%r2)
+;;       aghik   %r2, %r4, 0x1000
+;;       clgr    %r6, %r3
+;;       locgrh  %r2, %r7
+;;       strv    %r5, 0(%r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x68(%r2)
+;;       llgfr   %r6, %r4
+;;       aghik   %r3, %r7, -0x1004
+;;       lghi    %r7, 0
+;;       lgr     %r4, %r6
+;;       ag      %r4, 0x60(%r2)
+;;       aghik   %r5, %r4, 0x1000
+;;       clgr    %r6, %r3
+;;       locgrh  %r5, %r7
+;;       lrv     %r2, 0(%r5)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..1109f7cc9a99
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r3, %r4
+;;       llilf   %r7, 0xffff0004
+;;       algfr   %r7, %r4
+;;       jgnle   0x38
+;;       lg      %r6, 0x68(%r2)
+;;       lghi    %r4, 0
+;;       ag      %r3, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       agrk    %r2, %r3, %r2
+;;       clgr    %r7, %r6
+;;       locgrh  %r2, %r4
+;;       strv    %r5, 0(%r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r3, %r4
+;;       llilf   %r7, 0xffff0004
+;;       algfr   %r7, %r4
+;;       jgnle   0xa4
+;;       lg      %r5, 0x68(%r2)
+;;       lghi    %r4, 0
+;;       ag      %r3, 0x60(%r2)
+;;       llilh   %r6, 0xffff
+;;       agrk    %r2, %r3, %r6
+;;       clgr    %r7, %r5
+;;       locgrh  %r2, %r4
+;;       lrv     %r2, 0(%r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..6b8f885f15fb
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r9, %r15, 0x48(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r9, 0x68(%r2)
+;;       llgfr   %r7, %r4
+;;       lghi    %r6, 0
+;;       lgr     %r3, %r7
+;;       ag      %r3, 0x60(%r2)
+;;       clgr    %r7, %r9
+;;       locgrhe %r3, %r6
+;;       stc     %r5, 0(%r3)
+;;       lmg     %r9, %r15, 0xe8(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x68(%r2)
+;;       llgfr   %r6, %r4
+;;       lghi    %r5, 0
+;;       lgr     %r3, %r6
+;;       ag      %r3, 0x60(%r2)
+;;       clgr    %r6, %r7
+;;       locgrhe %r3, %r5
+;;       llc     %r2, 0(%r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..0996d8af6f1f
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x68(%r2)
+;;       llgfr   %r6, %r4
+;;       aghik   %r3, %r7, -0x1001
+;;       lghi    %r7, 0
+;;       lgr     %r4, %r6
+;;       ag      %r4, 0x60(%r2)
+;;       aghik   %r2, %r4, 0x1000
+;;       clgr    %r6, %r3
+;;       locgrh  %r2, %r7
+;;       stc     %r5, 0(%r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x68(%r2)
+;;       llgfr   %r6, %r4
+;;       aghik   %r3, %r7, -0x1001
+;;       lghi    %r7, 0
+;;       lgr     %r4, %r6
+;;       ag      %r4, 0x60(%r2)
+;;       aghik   %r5, %r4, 0x1000
+;;       clgr    %r6, %r3
+;;       locgrh  %r5, %r7
+;;       llc     %r2, 0(%r5)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..9b581e0fe87e
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r3, %r4
+;;       llilf   %r7, 0xffff0001
+;;       algfr   %r7, %r4
+;;       jgnle   0x38
+;;       lg      %r6, 0x68(%r2)
+;;       lghi    %r4, 0
+;;       ag      %r3, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       agrk    %r2, %r3, %r2
+;;       clgr    %r7, %r6
+;;       locgrh  %r2, %r4
+;;       stc     %r5, 0(%r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r3, %r4
+;;       llilf   %r7, 0xffff0001
+;;       algfr   %r7, %r4
+;;       jgnle   0xa0
+;;       lg      %r5, 0x68(%r2)
+;;       lghi    %r4, 0
+;;       ag      %r3, 0x60(%r2)
+;;       llilh   %r6, 0xffff
+;;       agrk    %r2, %r3, %r6
+;;       clgr    %r7, %r5
+;;       locgrh  %r2, %r4
+;;       llc     %r2, 0(%r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..d577e16b09b0
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lgr     %r6, %r4
+;;       lg      %r4, 0x68(%r2)
+;;       llgfr   %r3, %r6
+;;       clgr    %r3, %r4
+;;       jgh     0x54
+;;       lg      %r4, 0x60(%r2)
+;;       strv    %r5, 0(%r3, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lgr     %r5, %r4
+;;       lg      %r4, 0x68(%r2)
+;;       llgfr   %r3, %r5
+;;       clgr    %r3, %r4
+;;       jgh     0xac
+;;       lg      %r4, 0x60(%r2)
+;;       lrv     %r2, 0(%r3, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..dc5d8153cc0f
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lgr     %r6, %r4
+;;       lg      %r4, 0x68(%r2)
+;;       llgfr   %r3, %r6
+;;       clgr    %r3, %r4
+;;       jgh     0x58
+;;       ag      %r3, 0x60(%r2)
+;;       lghi    %r6, 0x1000
+;;       strv    %r5, 0(%r6, %r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lgr     %r5, %r4
+;;       lg      %r4, 0x68(%r2)
+;;       llgfr   %r3, %r5
+;;       clgr    %r3, %r4
+;;       jgh     0xb4
+;;       ag      %r3, 0x60(%r2)
+;;       lghi    %r5, 0x1000
+;;       lrv     %r2, 0(%r5, %r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..ecbf7279a0bf
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lgr     %r6, %r4
+;;       lg      %r4, 0x68(%r2)
+;;       llgfr   %r3, %r6
+;;       clgr    %r3, %r4
+;;       jgh     0x58
+;;       ag      %r3, 0x60(%r2)
+;;       llilh   %r6, 0xffff
+;;       strv    %r5, 0(%r6, %r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lgr     %r5, %r4
+;;       lg      %r4, 0x68(%r2)
+;;       llgfr   %r3, %r5
+;;       clgr    %r3, %r4
+;;       jgh     0xb4
+;;       ag      %r3, 0x60(%r2)
+;;       llilh   %r5, 0xffff
+;;       lrv     %r2, 0(%r5, %r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..28fc26491118
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lgr     %r6, %r4
+;;       lg      %r4, 0x68(%r2)
+;;       llgfr   %r3, %r6
+;;       clgr    %r3, %r4
+;;       jghe    0x52
+;;       lg      %r4, 0x60(%r2)
+;;       stc     %r5, 0(%r3, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lgr     %r5, %r4
+;;       lg      %r4, 0x68(%r2)
+;;       llgfr   %r3, %r5
+;;       clgr    %r3, %r4
+;;       jghe    0xa8
+;;       lg      %r4, 0x60(%r2)
+;;       llc     %r2, 0(%r3, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..c104fe02a309
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lgr     %r6, %r4
+;;       lg      %r4, 0x68(%r2)
+;;       llgfr   %r3, %r6
+;;       clgr    %r3, %r4
+;;       jgh     0x56
+;;       ag      %r3, 0x60(%r2)
+;;       lghi    %r6, 0x1000
+;;       stc     %r5, 0(%r6, %r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lgr     %r5, %r4
+;;       lg      %r4, 0x68(%r2)
+;;       llgfr   %r3, %r5
+;;       clgr    %r3, %r4
+;;       jgh     0xb0
+;;       ag      %r3, 0x60(%r2)
+;;       lghi    %r5, 0x1000
+;;       llc     %r2, 0(%r5, %r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..72f47e35dfe1
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lgr     %r6, %r4
+;;       lg      %r4, 0x68(%r2)
+;;       llgfr   %r3, %r6
+;;       clgr    %r3, %r4
+;;       jgh     0x56
+;;       ag      %r3, 0x60(%r2)
+;;       llilh   %r6, 0xffff
+;;       stc     %r5, 0(%r6, %r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lgr     %r5, %r4
+;;       lg      %r4, 0x68(%r2)
+;;       llgfr   %r3, %r5
+;;       clgr    %r3, %r4
+;;       jgh     0xb0
+;;       ag      %r3, 0x60(%r2)
+;;       llilh   %r5, 0xffff
+;;       llc     %r2, 0(%r5, %r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..7b27381b85c5
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r9, %r15, 0x48(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r9, 0x68(%r2)
+;;       llgfr   %r7, %r4
+;;       lghi    %r6, 0
+;;       lgr     %r3, %r7
+;;       ag      %r3, 0x60(%r2)
+;;       clgr    %r7, %r9
+;;       locgrh  %r3, %r6
+;;       strv    %r5, 0(%r3)
+;;       lmg     %r9, %r15, 0xe8(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x68(%r2)
+;;       llgfr   %r6, %r4
+;;       lghi    %r5, 0
+;;       lgr     %r3, %r6
+;;       ag      %r3, 0x60(%r2)
+;;       clgr    %r6, %r7
+;;       locgrh  %r3, %r5
+;;       lrv     %r2, 0(%r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..39782629a3d2
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r6, 0x68(%r2)
+;;       llgfr   %r3, %r4
+;;       lghi    %r7, 0
+;;       lgr     %r4, %r3
+;;       ag      %r4, 0x60(%r2)
+;;       aghi    %r4, 0x1000
+;;       clgr    %r3, %r6
+;;       locgrh  %r4, %r7
+;;       strv    %r5, 0(%r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r5, 0x68(%r2)
+;;       llgfr   %r7, %r4
+;;       lghi    %r6, 0
+;;       lgr     %r3, %r7
+;;       ag      %r3, 0x60(%r2)
+;;       aghik   %r4, %r3, 0x1000
+;;       clgr    %r7, %r5
+;;       locgrh  %r4, %r6
+;;       lrv     %r2, 0(%r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..2523a8a49959
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r6, 0x68(%r2)
+;;       lgr     %r3, %r2
+;;       llgfr   %r2, %r4
+;;       lghi    %r7, 0
+;;       lgr     %r4, %r3
+;;       lgr     %r3, %r2
+;;       ag      %r3, 0x60(%r4)
+;;       llilh   %r4, 0xffff
+;;       agr     %r3, %r4
+;;       clgr    %r2, %r6
+;;       locgrh  %r3, %r7
+;;       strv    %r5, 0(%r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r6, 0x68(%r2)
+;;       lgr     %r3, %r2
+;;       llgfr   %r2, %r4
+;;       lghi    %r7, 0
+;;       lgr     %r4, %r3
+;;       lgr     %r3, %r2
+;;       ag      %r3, 0x60(%r4)
+;;       llilh   %r4, 0xffff
+;;       agrk    %r5, %r3, %r4
+;;       clgr    %r2, %r6
+;;       locgrh  %r5, %r7
+;;       lrv     %r2, 0(%r5)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..30d87dab2b83
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r9, %r15, 0x48(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r9, 0x68(%r2)
+;;       llgfr   %r7, %r4
+;;       lghi    %r6, 0
+;;       lgr     %r3, %r7
+;;       ag      %r3, 0x60(%r2)
+;;       clgr    %r7, %r9
+;;       locgrhe %r3, %r6
+;;       stc     %r5, 0(%r3)
+;;       lmg     %r9, %r15, 0xe8(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x68(%r2)
+;;       llgfr   %r6, %r4
+;;       lghi    %r5, 0
+;;       lgr     %r3, %r6
+;;       ag      %r3, 0x60(%r2)
+;;       clgr    %r6, %r7
+;;       locgrhe %r3, %r5
+;;       llc     %r2, 0(%r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..7ccb3ad0cd58
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r6, 0x68(%r2)
+;;       llgfr   %r3, %r4
+;;       lghi    %r7, 0
+;;       lgr     %r4, %r3
+;;       ag      %r4, 0x60(%r2)
+;;       aghi    %r4, 0x1000
+;;       clgr    %r3, %r6
+;;       locgrh  %r4, %r7
+;;       stc     %r5, 0(%r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r5, 0x68(%r2)
+;;       llgfr   %r7, %r4
+;;       lghi    %r6, 0
+;;       lgr     %r3, %r7
+;;       ag      %r3, 0x60(%r2)
+;;       aghik   %r4, %r3, 0x1000
+;;       clgr    %r7, %r5
+;;       locgrh  %r4, %r6
+;;       llc     %r2, 0(%r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..b699f46183e8
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r6, 0x68(%r2)
+;;       lgr     %r3, %r2
+;;       llgfr   %r2, %r4
+;;       lghi    %r7, 0
+;;       lgr     %r4, %r3
+;;       lgr     %r3, %r2
+;;       ag      %r3, 0x60(%r4)
+;;       llilh   %r4, 0xffff
+;;       agr     %r3, %r4
+;;       clgr    %r2, %r6
+;;       locgrh  %r3, %r7
+;;       stc     %r5, 0(%r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r6, 0x68(%r2)
+;;       lgr     %r3, %r2
+;;       llgfr   %r2, %r4
+;;       lghi    %r7, 0
+;;       lgr     %r4, %r3
+;;       lgr     %r3, %r2
+;;       ag      %r3, 0x60(%r4)
+;;       llilh   %r4, 0xffff
+;;       agrk    %r5, %r3, %r4
+;;       clgr    %r2, %r6
+;;       locgrh  %r5, %r7
+;;       llc     %r2, 0(%r5)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..6a53f642bcbb
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r3, 0x68(%r2)
+;;       aghi    %r3, -4
+;;       clgr    %r4, %r3
+;;       jgh     0x50
+;;       lg      %r6, 0x60(%r2)
+;;       strv    %r5, 0(%r4, %r6)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r3, 0x68(%r2)
+;;       aghi    %r3, -4
+;;       clgr    %r4, %r3
+;;       jgh     0xa4
+;;       lg      %r5, 0x60(%r2)
+;;       lrv     %r2, 0(%r4, %r5)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..63a909f8cf57
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r3, 0x68(%r2)
+;;       aghi    %r3, -0x1004
+;;       clgr    %r4, %r3
+;;       jgh     0x54
+;;       ag      %r4, 0x60(%r2)
+;;       lghi    %r6, 0x1000
+;;       strv    %r5, 0(%r6, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r3, 0x68(%r2)
+;;       aghi    %r3, -0x1004
+;;       clgr    %r4, %r3
+;;       jgh     0xac
+;;       ag      %r4, 0x60(%r2)
+;;       lghi    %r5, 0x1000
+;;       lrv     %r2, 0(%r5, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..8354f291d0dc
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lgr     %r3, %r4
+;;       algfi   %r3, 0xffff0004
+;;       jgnle   0x34
+;;       lg      %r6, 0x68(%r2)
+;;       clgr    %r3, %r6
+;;       jgh     0x60
+;;       ag      %r4, 0x60(%r2)
+;;       llilh   %r6, 0xffff
+;;       strv    %r5, 0(%r6, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lgr     %r3, %r4
+;;       algfi   %r3, 0xffff0004
+;;       jgnle   0x98
+;;       lg      %r5, 0x68(%r2)
+;;       clgr    %r3, %r5
+;;       jgh     0xc4
+;;       ag      %r4, 0x60(%r2)
+;;       llilh   %r6, 0xffff
+;;       lrv     %r2, 0(%r6, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..ec1c7cb896d3
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x68(%r2)
+;;       clgr    %r4, %r7
+;;       jghe    0x4a
+;;       lg      %r3, 0x60(%r2)
+;;       stc     %r5, 0(%r4, %r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x68(%r2)
+;;       clgr    %r4, %r7
+;;       jghe    0x98
+;;       lg      %r3, 0x60(%r2)
+;;       llc     %r2, 0(%r4, %r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..c7eadf41d84b
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r3, 0x68(%r2)
+;;       aghi    %r3, -0x1001
+;;       clgr    %r4, %r3
+;;       jgh     0x52
+;;       ag      %r4, 0x60(%r2)
+;;       lghi    %r6, 0x1000
+;;       stc     %r5, 0(%r6, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r3, 0x68(%r2)
+;;       aghi    %r3, -0x1001
+;;       clgr    %r4, %r3
+;;       jgh     0xa8
+;;       ag      %r4, 0x60(%r2)
+;;       lghi    %r5, 0x1000
+;;       llc     %r2, 0(%r5, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..6ff863baa9da
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,63 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lgr     %r3, %r4
+;;       algfi   %r3, 0xffff0001
+;;       jgnle   0x34
+;;       lg      %r6, 0x68(%r2)
+;;       clgr    %r3, %r6
+;;       jgh     0x5e
+;;       ag      %r4, 0x60(%r2)
+;;       llilh   %r6, 0xffff
+;;       stc     %r5, 0(%r6, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lgr     %r3, %r4
+;;       algfi   %r3, 0xffff0001
+;;       jgnle   0x94
+;;       lg      %r5, 0x68(%r2)
+;;       clgr    %r3, %r5
+;;       jgh     0xc0
+;;       ag      %r4, 0x60(%r2)
+;;       llilh   %r6, 0xffff
+;;       llc     %r2, 0(%r6, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..ed8cc3dc207a
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r6, 0x68(%r2)
+;;       aghik   %r7, %r6, -4
+;;       lghi    %r6, 0
+;;       lgr     %r3, %r4
+;;       ag      %r3, 0x60(%r2)
+;;       clgr    %r4, %r7
+;;       locgrh  %r3, %r6
+;;       strv    %r5, 0(%r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r5, 0x68(%r2)
+;;       aghik   %r6, %r5, -4
+;;       lghi    %r5, 0
+;;       lgr     %r3, %r4
+;;       ag      %r3, 0x60(%r2)
+;;       clgr    %r4, %r6
+;;       locgrh  %r3, %r5
+;;       lrv     %r2, 0(%r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..9fc733daef7f
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r6, 0x68(%r2)
+;;       aghik   %r7, %r6, -0x1004
+;;       lghi    %r6, 0
+;;       lgr     %r3, %r4
+;;       ag      %r3, 0x60(%r2)
+;;       aghik   %r2, %r3, 0x1000
+;;       clgr    %r4, %r7
+;;       locgrh  %r2, %r6
+;;       strv    %r5, 0(%r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r5, 0x68(%r2)
+;;       aghik   %r6, %r5, -0x1004
+;;       lghi    %r5, 0
+;;       lgr     %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       aghi    %r7, 0x1000
+;;       clgr    %r4, %r6
+;;       locgrh  %r7, %r5
+;;       lrv     %r2, 0(%r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..3e3f68ec3f55
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,65 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lgr     %r6, %r4
+;;       algfi   %r6, 0xffff0004
+;;       jgnle   0x34
+;;       lg      %r3, 0x68(%r2)
+;;       lghi    %r7, 0
+;;       ag      %r4, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       agrk    %r2, %r4, %r2
+;;       clgr    %r6, %r3
+;;       locgrh  %r2, %r7
+;;       strv    %r5, 0(%r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lgr     %r6, %r4
+;;       algfi   %r6, 0xffff0004
+;;       jgnle   0x9c
+;;       lg      %r3, 0x68(%r2)
+;;       lghi    %r7, 0
+;;       ag      %r4, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       agrk    %r2, %r4, %r2
+;;       clgr    %r6, %r3
+;;       locgrh  %r2, %r7
+;;       lrv     %r2, 0(%r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..422e6546653f
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r6, 0x68(%r2)
+;;       lghi    %r3, 0
+;;       lgr     %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       clgr    %r4, %r6
+;;       locgrhe %r7, %r3
+;;       stc     %r5, 0(%r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r5, 0x68(%r2)
+;;       lghi    %r3, 0
+;;       lgr     %r6, %r4
+;;       ag      %r6, 0x60(%r2)
+;;       clgr    %r4, %r5
+;;       locgrhe %r6, %r3
+;;       llc     %r2, 0(%r6)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..ab5eea784168
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r6, 0x68(%r2)
+;;       aghik   %r7, %r6, -0x1001
+;;       lghi    %r6, 0
+;;       lgr     %r3, %r4
+;;       ag      %r3, 0x60(%r2)
+;;       aghik   %r2, %r3, 0x1000
+;;       clgr    %r4, %r7
+;;       locgrh  %r2, %r6
+;;       stc     %r5, 0(%r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r5, 0x68(%r2)
+;;       aghik   %r6, %r5, -0x1001
+;;       lghi    %r5, 0
+;;       lgr     %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       aghi    %r7, 0x1000
+;;       clgr    %r4, %r6
+;;       locgrh  %r7, %r5
+;;       llc     %r2, 0(%r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..59a97b2f898a
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,65 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lgr     %r6, %r4
+;;       algfi   %r6, 0xffff0001
+;;       jgnle   0x34
+;;       lg      %r3, 0x68(%r2)
+;;       lghi    %r7, 0
+;;       ag      %r4, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       agrk    %r2, %r4, %r2
+;;       clgr    %r6, %r3
+;;       locgrh  %r2, %r7
+;;       stc     %r5, 0(%r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lgr     %r6, %r4
+;;       algfi   %r6, 0xffff0001
+;;       jgnle   0x98
+;;       lg      %r3, 0x68(%r2)
+;;       lghi    %r7, 0
+;;       ag      %r4, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       agrk    %r2, %r4, %r2
+;;       clgr    %r6, %r3
+;;       locgrh  %r2, %r7
+;;       llc     %r2, 0(%r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..f52b6aa752e3
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x68(%r2)
+;;       clgr    %r4, %r7
+;;       jgh     0x4c
+;;       lg      %r3, 0x60(%r2)
+;;       strv    %r5, 0(%r4, %r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x68(%r2)
+;;       clgr    %r4, %r7
+;;       jgh     0x9c
+;;       lg      %r3, 0x60(%r2)
+;;       lrv     %r2, 0(%r4, %r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..b5768eadc2ab
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r3, 0x68(%r2)
+;;       clgr    %r4, %r3
+;;       jgh     0x50
+;;       ag      %r4, 0x60(%r2)
+;;       lghi    %r6, 0x1000
+;;       strv    %r5, 0(%r6, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r3, 0x68(%r2)
+;;       clgr    %r4, %r3
+;;       jgh     0xa4
+;;       ag      %r4, 0x60(%r2)
+;;       lghi    %r5, 0x1000
+;;       lrv     %r2, 0(%r5, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..afe268acb2b6
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r3, 0x68(%r2)
+;;       clgr    %r4, %r3
+;;       jgh     0x50
+;;       ag      %r4, 0x60(%r2)
+;;       llilh   %r6, 0xffff
+;;       strv    %r5, 0(%r6, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r3, 0x68(%r2)
+;;       clgr    %r4, %r3
+;;       jgh     0xa4
+;;       ag      %r4, 0x60(%r2)
+;;       llilh   %r5, 0xffff
+;;       lrv     %r2, 0(%r5, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..a04f732d210a
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x68(%r2)
+;;       clgr    %r4, %r7
+;;       jghe    0x4a
+;;       lg      %r3, 0x60(%r2)
+;;       stc     %r5, 0(%r4, %r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x68(%r2)
+;;       clgr    %r4, %r7
+;;       jghe    0x98
+;;       lg      %r3, 0x60(%r2)
+;;       llc     %r2, 0(%r4, %r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..ac51422bf888
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r3, 0x68(%r2)
+;;       clgr    %r4, %r3
+;;       jgh     0x4e
+;;       ag      %r4, 0x60(%r2)
+;;       lghi    %r6, 0x1000
+;;       stc     %r5, 0(%r6, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r3, 0x68(%r2)
+;;       clgr    %r4, %r3
+;;       jgh     0xa0
+;;       ag      %r4, 0x60(%r2)
+;;       lghi    %r5, 0x1000
+;;       llc     %r2, 0(%r5, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..95b9a6c820e1
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r3, 0x68(%r2)
+;;       clgr    %r4, %r3
+;;       jgh     0x4e
+;;       ag      %r4, 0x60(%r2)
+;;       llilh   %r6, 0xffff
+;;       stc     %r5, 0(%r6, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r3, 0x68(%r2)
+;;       clgr    %r4, %r3
+;;       jgh     0xa0
+;;       ag      %r4, 0x60(%r2)
+;;       llilh   %r5, 0xffff
+;;       llc     %r2, 0(%r5, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..3d1ab482a302
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r6, 0x68(%r2)
+;;       lghi    %r3, 0
+;;       lgr     %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       clgr    %r4, %r6
+;;       locgrh  %r7, %r3
+;;       strv    %r5, 0(%r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r5, 0x68(%r2)
+;;       lghi    %r3, 0
+;;       lgr     %r6, %r4
+;;       ag      %r6, 0x60(%r2)
+;;       clgr    %r4, %r5
+;;       locgrh  %r6, %r3
+;;       lrv     %r2, 0(%r6)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..ce0a5c387941
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x68(%r2)
+;;       lghi    %r6, 0
+;;       lgr     %r3, %r4
+;;       ag      %r3, 0x60(%r2)
+;;       aghi    %r3, 0x1000
+;;       clgr    %r4, %r7
+;;       locgrh  %r3, %r6
+;;       strv    %r5, 0(%r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r6, 0x68(%r2)
+;;       lghi    %r5, 0
+;;       lgr     %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       aghik   %r3, %r7, 0x1000
+;;       clgr    %r4, %r6
+;;       locgrh  %r3, %r5
+;;       lrv     %r2, 0(%r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..55b9b7b99619
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x68(%r2)
+;;       lghi    %r6, 0
+;;       lgr     %r3, %r4
+;;       ag      %r3, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       agrk    %r2, %r3, %r2
+;;       clgr    %r4, %r7
+;;       locgrh  %r2, %r6
+;;       strv    %r5, 0(%r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r6, 0x68(%r2)
+;;       lghi    %r5, 0
+;;       lgr     %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       agr     %r7, %r2
+;;       clgr    %r4, %r6
+;;       locgrh  %r7, %r5
+;;       lrv     %r2, 0(%r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..af6bea4e52b6
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r6, 0x68(%r2)
+;;       lghi    %r3, 0
+;;       lgr     %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       clgr    %r4, %r6
+;;       locgrhe %r7, %r3
+;;       stc     %r5, 0(%r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r5, 0x68(%r2)
+;;       lghi    %r3, 0
+;;       lgr     %r6, %r4
+;;       ag      %r6, 0x60(%r2)
+;;       clgr    %r4, %r5
+;;       locgrhe %r6, %r3
+;;       llc     %r2, 0(%r6)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..718633e01cb0
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x68(%r2)
+;;       lghi    %r6, 0
+;;       lgr     %r3, %r4
+;;       ag      %r3, 0x60(%r2)
+;;       aghi    %r3, 0x1000
+;;       clgr    %r4, %r7
+;;       locgrh  %r3, %r6
+;;       stc     %r5, 0(%r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r6, 0x68(%r2)
+;;       lghi    %r5, 0
+;;       lgr     %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       aghik   %r3, %r7, 0x1000
+;;       clgr    %r4, %r6
+;;       locgrh  %r3, %r5
+;;       llc     %r2, 0(%r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..a13d6c0847a0
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x68(%r2)
+;;       lghi    %r6, 0
+;;       lgr     %r3, %r4
+;;       ag      %r3, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       agrk    %r2, %r3, %r2
+;;       clgr    %r4, %r7
+;;       locgrh  %r2, %r6
+;;       stc     %r5, 0(%r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r6, 0x68(%r2)
+;;       lghi    %r5, 0
+;;       lgr     %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       agr     %r7, %r2
+;;       clgr    %r4, %r6
+;;       locgrh  %r7, %r5
+;;       llc     %r2, 0(%r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..a23a706f2803
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       clgfi   %r7, 0xfffffffc
+;;       jgh     0x4c
+;;       lg      %r3, 0x60(%r2)
+;;       strv    %r5, 0(%r7, %r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       clgfi   %r7, 0xfffffffc
+;;       jgh     0x9c
+;;       lg      %r3, 0x60(%r2)
+;;       lrv     %r2, 0(%r7, %r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..f562184bdaab
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       clgfi   %r7, 0xffffeffc
+;;       jgh     0x50
+;;       ag      %r7, 0x60(%r2)
+;;       lghi    %r4, 0x1000
+;;       strv    %r5, 0(%r4, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       clgfi   %r7, 0xffffeffc
+;;       jgh     0xa4
+;;       ag      %r7, 0x60(%r2)
+;;       lghi    %r4, 0x1000
+;;       lrv     %r2, 0(%r4, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..f33a75360081
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       clgfi   %r7, 0xfffc
+;;       jgh     0x50
+;;       ag      %r7, 0x60(%r2)
+;;       llilh   %r4, 0xffff
+;;       strv    %r5, 0(%r4, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       clgfi   %r7, 0xfffc
+;;       jgh     0xa4
+;;       ag      %r7, 0x60(%r2)
+;;       llilh   %r4, 0xffff
+;;       lrv     %r2, 0(%r4, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..bb49fc48d0c1
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x60(%r2)
+;;       llgfr   %r2, %r4
+;;       stc     %r5, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x60(%r2)
+;;       llgfr   %r2, %r4
+;;       llc     %r2, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..bef7cdd55593
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       clgfi   %r7, 0xffffefff
+;;       jgh     0x4e
+;;       ag      %r7, 0x60(%r2)
+;;       lghi    %r4, 0x1000
+;;       stc     %r5, 0(%r4, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       clgfi   %r7, 0xffffefff
+;;       jgh     0xa0
+;;       ag      %r7, 0x60(%r2)
+;;       lghi    %r4, 0x1000
+;;       llc     %r2, 0(%r4, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..b934f0d3cacc
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       clgfi   %r7, 0xffff
+;;       jgh     0x4e
+;;       ag      %r7, 0x60(%r2)
+;;       llilh   %r4, 0xffff
+;;       stc     %r5, 0(%r4, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       clgfi   %r7, 0xffff
+;;       jgh     0xa0
+;;       ag      %r7, 0x60(%r2)
+;;       llilh   %r4, 0xffff
+;;       llc     %r2, 0(%r4, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..a7ba8979d938
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r4, %r4
+;;       lghi    %r3, 0
+;;       lgr     %r6, %r4
+;;       ag      %r6, 0x60(%r2)
+;;       clgfi   %r4, 0xfffffffc
+;;       locgrh  %r6, %r3
+;;       strv    %r5, 0(%r6)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r4, %r4
+;;       lghi    %r3, 0
+;;       lgr     %r5, %r4
+;;       ag      %r5, 0x60(%r2)
+;;       clgfi   %r4, 0xfffffffc
+;;       locgrh  %r5, %r3
+;;       lrv     %r2, 0(%r5)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..64eca648e498
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r6, %r4
+;;       lghi    %r4, 0
+;;       lgr     %r7, %r6
+;;       ag      %r7, 0x60(%r2)
+;;       aghik   %r3, %r7, 0x1000
+;;       clgfi   %r6, 0xffffeffc
+;;       locgrh  %r3, %r4
+;;       strv    %r5, 0(%r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r5, %r4
+;;       lghi    %r4, 0
+;;       lgr     %r6, %r5
+;;       ag      %r6, 0x60(%r2)
+;;       aghik   %r3, %r6, 0x1000
+;;       clgfi   %r5, 0xffffeffc
+;;       locgrh  %r3, %r4
+;;       lrv     %r2, 0(%r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..aa2fb70a46f3
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       lghi    %r6, 0
+;;       lgr     %r3, %r7
+;;       ag      %r3, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       agrk    %r4, %r3, %r2
+;;       clgfi   %r7, 0xfffc
+;;       locgrh  %r4, %r6
+;;       strv    %r5, 0(%r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r6, %r4
+;;       lghi    %r5, 0
+;;       lgr     %r7, %r6
+;;       ag      %r7, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       agrk    %r4, %r7, %r2
+;;       clgfi   %r6, 0xfffc
+;;       locgrh  %r4, %r5
+;;       lrv     %r2, 0(%r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..39a7accf5de2
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x60(%r2)
+;;       llgfr   %r2, %r4
+;;       stc     %r5, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x60(%r2)
+;;       llgfr   %r2, %r4
+;;       llc     %r2, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..cef7fc44ed54
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r6, %r4
+;;       lghi    %r4, 0
+;;       lgr     %r7, %r6
+;;       ag      %r7, 0x60(%r2)
+;;       aghik   %r3, %r7, 0x1000
+;;       clgfi   %r6, 0xffffefff
+;;       locgrh  %r3, %r4
+;;       stc     %r5, 0(%r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r5, %r4
+;;       lghi    %r4, 0
+;;       lgr     %r6, %r5
+;;       ag      %r6, 0x60(%r2)
+;;       aghik   %r3, %r6, 0x1000
+;;       clgfi   %r5, 0xffffefff
+;;       locgrh  %r3, %r4
+;;       llc     %r2, 0(%r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..1ce45cc36510
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,61 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       lghi    %r6, 0
+;;       lgr     %r3, %r7
+;;       ag      %r3, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       agrk    %r4, %r3, %r2
+;;       clgfi   %r7, 0xffff
+;;       locgrh  %r4, %r6
+;;       stc     %r5, 0(%r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r6, %r4
+;;       lghi    %r5, 0
+;;       lgr     %r7, %r6
+;;       ag      %r7, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       agrk    %r4, %r7, %r2
+;;       clgfi   %r6, 0xffff
+;;       locgrh  %r4, %r5
+;;       llc     %r2, 0(%r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..8b2797c08e76
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x60(%r2)
+;;       llgfr   %r2, %r4
+;;       strv    %r5, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x60(%r2)
+;;       llgfr   %r2, %r4
+;;       lrv     %r2, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..6ed1831ef97b
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       lghi    %r2, 0x1000
+;;       strv    %r5, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       lghi    %r2, 0x1000
+;;       lrv     %r2, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..e129bb79f3e9
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       strv    %r5, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       lrv     %r2, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..0231db83877f
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x60(%r2)
+;;       llgfr   %r2, %r4
+;;       stc     %r5, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x60(%r2)
+;;       llgfr   %r2, %r4
+;;       llc     %r2, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..4a063981f5bf
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       lghi    %r2, 0x1000
+;;       stc     %r5, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       lghi    %r2, 0x1000
+;;       llc     %r2, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..7d384d06a4b4
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       stc     %r5, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       llc     %r2, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..bae40c3459ce
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x60(%r2)
+;;       llgfr   %r2, %r4
+;;       strv    %r5, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x60(%r2)
+;;       llgfr   %r2, %r4
+;;       lrv     %r2, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..f77f65369dba
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       lghi    %r2, 0x1000
+;;       strv    %r5, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       lghi    %r2, 0x1000
+;;       lrv     %r2, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..fae2571ae9b7
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       strv    %r5, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       lrv     %r2, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..cdf1255906c0
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x60(%r2)
+;;       llgfr   %r2, %r4
+;;       stc     %r5, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lg      %r7, 0x60(%r2)
+;;       llgfr   %r2, %r4
+;;       llc     %r2, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..6d6b51783f8d
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       lghi    %r2, 0x1000
+;;       stc     %r5, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       lghi    %r2, 0x1000
+;;       llc     %r2, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..26ba9d297a41
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       stc     %r5, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       llgfr   %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       llc     %r2, 0(%r2, %r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..96e0148a5746
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,53 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       clgfi   %r4, 0xfffffffc
+;;       jgh     0x48
+;;       lg      %r2, 0x60(%r2)
+;;       strv    %r5, 0(%r4, %r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       clgfi   %r4, 0xfffffffc
+;;       jgh     0x94
+;;       lg      %r2, 0x60(%r2)
+;;       lrv     %r2, 0(%r4, %r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..d5406d493527
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       clgfi   %r4, 0xffffeffc
+;;       jgh     0x4c
+;;       ag      %r4, 0x60(%r2)
+;;       lghi    %r3, 0x1000
+;;       strv    %r5, 0(%r3, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       clgfi   %r4, 0xffffeffc
+;;       jgh     0x9c
+;;       ag      %r4, 0x60(%r2)
+;;       lghi    %r3, 0x1000
+;;       lrv     %r2, 0(%r3, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..f8936bfbdd1f
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       clgfi   %r4, 0xfffc
+;;       jgh     0x4c
+;;       ag      %r4, 0x60(%r2)
+;;       llilh   %r3, 0xffff
+;;       strv    %r5, 0(%r3, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       clgfi   %r4, 0xfffc
+;;       jgh     0x9c
+;;       ag      %r4, 0x60(%r2)
+;;       llilh   %r3, 0xffff
+;;       lrv     %r2, 0(%r3, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..73437230ec38
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,53 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       clgfi   %r4, 0xffffffff
+;;       jgh     0x46
+;;       lg      %r2, 0x60(%r2)
+;;       stc     %r5, 0(%r4, %r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       clgfi   %r4, 0xffffffff
+;;       jgh     0x90
+;;       lg      %r2, 0x60(%r2)
+;;       llc     %r2, 0(%r4, %r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..53d2802a238f
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       clgfi   %r4, 0xffffefff
+;;       jgh     0x4a
+;;       ag      %r4, 0x60(%r2)
+;;       lghi    %r3, 0x1000
+;;       stc     %r5, 0(%r3, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       clgfi   %r4, 0xffffefff
+;;       jgh     0x98
+;;       ag      %r4, 0x60(%r2)
+;;       lghi    %r3, 0x1000
+;;       llc     %r2, 0(%r3, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..1ffc02888bd7
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       clgfi   %r4, 0xffff
+;;       jgh     0x4a
+;;       ag      %r4, 0x60(%r2)
+;;       llilh   %r3, 0xffff
+;;       stc     %r5, 0(%r3, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       clgfi   %r4, 0xffff
+;;       jgh     0x98
+;;       ag      %r4, 0x60(%r2)
+;;       llilh   %r3, 0xffff
+;;       llc     %r2, 0(%r3, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..3639f39c0207
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lghi    %r3, 0
+;;       lgr     %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       clgfi   %r4, 0xfffffffc
+;;       locgrh  %r7, %r3
+;;       strv    %r5, 0(%r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lghi    %r3, 0
+;;       lgr     %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       clgfi   %r4, 0xfffffffc
+;;       locgrh  %r7, %r3
+;;       lrv     %r2, 0(%r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..cb1cbbccf4ce
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lghi    %r3, 0
+;;       lgr     %r6, %r4
+;;       ag      %r6, 0x60(%r2)
+;;       aghik   %r2, %r6, 0x1000
+;;       clgfi   %r4, 0xffffeffc
+;;       locgrh  %r2, %r3
+;;       strv    %r5, 0(%r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lghi    %r3, 0
+;;       lgr     %r5, %r4
+;;       ag      %r5, 0x60(%r2)
+;;       aghik   %r2, %r5, 0x1000
+;;       clgfi   %r4, 0xffffeffc
+;;       locgrh  %r2, %r3
+;;       lrv     %r2, 0(%r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..736e0ebf333b
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lghi    %r6, 0
+;;       lgr     %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       agrk    %r3, %r7, %r2
+;;       clgfi   %r4, 0xfffc
+;;       locgrh  %r3, %r6
+;;       strv    %r5, 0(%r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lghi    %r5, 0
+;;       lgr     %r6, %r4
+;;       ag      %r6, 0x60(%r2)
+;;       llilh   %r7, 0xffff
+;;       agrk    %r3, %r6, %r7
+;;       clgfi   %r4, 0xfffc
+;;       locgrh  %r3, %r5
+;;       lrv     %r2, 0(%r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..950088c0fffa
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lghi    %r3, 0
+;;       lgr     %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       clgfi   %r4, 0xffffffff
+;;       locgrh  %r7, %r3
+;;       stc     %r5, 0(%r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lghi    %r3, 0
+;;       lgr     %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       clgfi   %r4, 0xffffffff
+;;       locgrh  %r7, %r3
+;;       llc     %r2, 0(%r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..17e5ca856140
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lghi    %r3, 0
+;;       lgr     %r6, %r4
+;;       ag      %r6, 0x60(%r2)
+;;       aghik   %r2, %r6, 0x1000
+;;       clgfi   %r4, 0xffffefff
+;;       locgrh  %r2, %r3
+;;       stc     %r5, 0(%r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lghi    %r3, 0
+;;       lgr     %r5, %r4
+;;       ag      %r5, 0x60(%r2)
+;;       aghik   %r2, %r5, 0x1000
+;;       clgfi   %r4, 0xffffefff
+;;       locgrh  %r2, %r3
+;;       llc     %r2, 0(%r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..eb4b5c7c97cd
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lghi    %r6, 0
+;;       lgr     %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       agrk    %r3, %r7, %r2
+;;       clgfi   %r4, 0xffff
+;;       locgrh  %r3, %r6
+;;       stc     %r5, 0(%r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lghi    %r5, 0
+;;       lgr     %r6, %r4
+;;       ag      %r6, 0x60(%r2)
+;;       llilh   %r7, 0xffff
+;;       agrk    %r3, %r6, %r7
+;;       clgfi   %r4, 0xffff
+;;       locgrh  %r3, %r5
+;;       llc     %r2, 0(%r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..99f27ccb0b7a
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,53 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       clgfi   %r4, 0xfffffffc
+;;       jgh     0x48
+;;       lg      %r2, 0x60(%r2)
+;;       strv    %r5, 0(%r4, %r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       clgfi   %r4, 0xfffffffc
+;;       jgh     0x94
+;;       lg      %r2, 0x60(%r2)
+;;       lrv     %r2, 0(%r4, %r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..0c0f219107a4
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       clgfi   %r4, 0xffffeffc
+;;       jgh     0x4c
+;;       ag      %r4, 0x60(%r2)
+;;       lghi    %r3, 0x1000
+;;       strv    %r5, 0(%r3, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       clgfi   %r4, 0xffffeffc
+;;       jgh     0x9c
+;;       ag      %r4, 0x60(%r2)
+;;       lghi    %r3, 0x1000
+;;       lrv     %r2, 0(%r3, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..64475212daae
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       clgfi   %r4, 0xfffc
+;;       jgh     0x4c
+;;       ag      %r4, 0x60(%r2)
+;;       llilh   %r3, 0xffff
+;;       strv    %r5, 0(%r3, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       clgfi   %r4, 0xfffc
+;;       jgh     0x9c
+;;       ag      %r4, 0x60(%r2)
+;;       llilh   %r3, 0xffff
+;;       lrv     %r2, 0(%r3, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..9dbb46ebf0c0
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,53 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       clgfi   %r4, 0xffffffff
+;;       jgh     0x46
+;;       lg      %r2, 0x60(%r2)
+;;       stc     %r5, 0(%r4, %r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       clgfi   %r4, 0xffffffff
+;;       jgh     0x90
+;;       lg      %r2, 0x60(%r2)
+;;       llc     %r2, 0(%r4, %r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..c7921680a995
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       clgfi   %r4, 0xffffefff
+;;       jgh     0x4a
+;;       ag      %r4, 0x60(%r2)
+;;       lghi    %r3, 0x1000
+;;       stc     %r5, 0(%r3, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       clgfi   %r4, 0xffffefff
+;;       jgh     0x98
+;;       ag      %r4, 0x60(%r2)
+;;       lghi    %r3, 0x1000
+;;       llc     %r2, 0(%r3, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..ec043f14ef8f
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       clgfi   %r4, 0xffff
+;;       jgh     0x4a
+;;       ag      %r4, 0x60(%r2)
+;;       llilh   %r3, 0xffff
+;;       stc     %r5, 0(%r3, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       clgfi   %r4, 0xffff
+;;       jgh     0x98
+;;       ag      %r4, 0x60(%r2)
+;;       llilh   %r3, 0xffff
+;;       llc     %r2, 0(%r3, %r4)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;       .byte   0x00, 0x00
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..e467498e6fbc
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lghi    %r3, 0
+;;       lgr     %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       clgfi   %r4, 0xfffffffc
+;;       locgrh  %r7, %r3
+;;       strv    %r5, 0(%r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lghi    %r3, 0
+;;       lgr     %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       clgfi   %r4, 0xfffffffc
+;;       locgrh  %r7, %r3
+;;       lrv     %r2, 0(%r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..9b1fa374fbc6
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lghi    %r3, 0
+;;       lgr     %r6, %r4
+;;       ag      %r6, 0x60(%r2)
+;;       aghik   %r2, %r6, 0x1000
+;;       clgfi   %r4, 0xffffeffc
+;;       locgrh  %r2, %r3
+;;       strv    %r5, 0(%r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lghi    %r3, 0
+;;       lgr     %r5, %r4
+;;       ag      %r5, 0x60(%r2)
+;;       aghik   %r2, %r5, 0x1000
+;;       clgfi   %r4, 0xffffeffc
+;;       locgrh  %r2, %r3
+;;       lrv     %r2, 0(%r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..3d66b13075af
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lghi    %r6, 0
+;;       lgr     %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       agrk    %r3, %r7, %r2
+;;       clgfi   %r4, 0xfffc
+;;       locgrh  %r3, %r6
+;;       strv    %r5, 0(%r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lghi    %r5, 0
+;;       lgr     %r6, %r4
+;;       ag      %r6, 0x60(%r2)
+;;       llilh   %r7, 0xffff
+;;       agrk    %r3, %r6, %r7
+;;       clgfi   %r4, 0xfffc
+;;       locgrh  %r3, %r5
+;;       lrv     %r2, 0(%r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..f4c268626b39
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lghi    %r3, 0
+;;       lgr     %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       clgfi   %r4, 0xffffffff
+;;       locgrh  %r7, %r3
+;;       stc     %r5, 0(%r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lghi    %r3, 0
+;;       lgr     %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       clgfi   %r4, 0xffffffff
+;;       locgrh  %r7, %r3
+;;       llc     %r2, 0(%r7)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..4a2608ac1120
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,57 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lghi    %r3, 0
+;;       lgr     %r6, %r4
+;;       ag      %r6, 0x60(%r2)
+;;       aghik   %r2, %r6, 0x1000
+;;       clgfi   %r4, 0xffffefff
+;;       locgrh  %r2, %r3
+;;       stc     %r5, 0(%r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lghi    %r3, 0
+;;       lgr     %r5, %r4
+;;       ag      %r5, 0x60(%r2)
+;;       aghik   %r2, %r5, 0x1000
+;;       clgfi   %r4, 0xffffefff
+;;       locgrh  %r2, %r3
+;;       llc     %r2, 0(%r2)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..5b7dbda410f7
--- /dev/null
+++ b/tests/disas/load-store/s390x/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "s390x"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lghi    %r6, 0
+;;       lgr     %r7, %r4
+;;       ag      %r7, 0x60(%r2)
+;;       llilh   %r2, 0xffff
+;;       agrk    %r3, %r7, %r2
+;;       clgfi   %r4, 0xffff
+;;       locgrh  %r3, %r6
+;;       stc     %r5, 0(%r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
+;;
+;; wasm[0]::function[1]:
+;;       lg      %r1, 8(%r2)
+;;       lg      %r1, 0(%r1)
+;;       la      %r1, 0xa0(%r1)
+;;       clgrtle %r15, %r1
+;;       stmg    %r14, %r15, 0x70(%r15)
+;;       lgr     %r1, %r15
+;;       aghi    %r15, -0xa0
+;;       stg     %r1, 0(%r15)
+;;       lghi    %r5, 0
+;;       lgr     %r6, %r4
+;;       ag      %r6, 0x60(%r2)
+;;       llilh   %r7, 0xffff
+;;       agrk    %r3, %r6, %r7
+;;       clgfi   %r4, 0xffff
+;;       locgrh  %r3, %r5
+;;       llc     %r2, 0(%r3)
+;;       lmg     %r14, %r15, 0x110(%r15)
+;;       br      %r14
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..5da0bbc76ca5
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r8
+;;       movl    %edx, %r10d
+;;       subq    $4, %r8
+;;       cmpq    %r8, %r10
+;;       ja      0x25
+;;   18: movq    0x60(%rdi), %rsi
+;;       movl    %ecx, (%rsi, %r10)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   25: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r8
+;;       movl    %edx, %r10d
+;;       subq    $4, %r8
+;;       cmpq    %r8, %r10
+;;       ja      0x65
+;;   58: movq    0x60(%rdi), %rsi
+;;       movl    (%rsi, %r10), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   65: ud2
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..9f07e9a6f462
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r8
+;;       movl    %edx, %r10d
+;;       subq    $0x1004, %r8
+;;       cmpq    %r8, %r10
+;;       ja      0x2c
+;;   1b: movq    0x60(%rdi), %rsi
+;;       movl    %ecx, 0x1000(%rsi, %r10)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   2c: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r8
+;;       movl    %edx, %r10d
+;;       subq    $0x1004, %r8
+;;       cmpq    %r8, %r10
+;;       ja      0x6c
+;;   5b: movq    0x60(%rdi), %rsi
+;;       movl    0x1000(%rsi, %r10), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6c: ud2
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..68b6836c71c9
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,65 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r8d
+;;       movq    %r8, %r11
+;;       addq    0x2f(%rip), %r11
+;;       jb      0x38
+;;   17: movq    0x68(%rdi), %rsi
+;;       cmpq    %rsi, %r11
+;;       ja      0x36
+;;   24: addq    0x60(%rdi), %r8
+;;       movl    $0xffff0000, %eax
+;;       movl    %ecx, (%r8, %rax)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   36: ud2
+;;   38: ud2
+;;   3a: addb    %al, (%rax)
+;;   3c: addb    %al, (%rax)
+;;   3e: addb    %al, (%rax)
+;;   40: addb    $0, %al
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r8d
+;;       movq    %r8, %r11
+;;       addq    0x2f(%rip), %r11
+;;       jb      0x98
+;;   77: movq    0x68(%rdi), %rsi
+;;       cmpq    %rsi, %r11
+;;       ja      0x96
+;;   84: addq    0x60(%rdi), %r8
+;;       movl    $0xffff0000, %eax
+;;       movl    (%r8, %rax), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   96: ud2
+;;   98: ud2
+;;   9a: addb    %al, (%rax)
+;;   9c: addb    %al, (%rax)
+;;   9e: addb    %al, (%rax)
+;;   a0: addb    $0, %al
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..cbbcc72745a3
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r10
+;;       movl    %edx, %r9d
+;;       cmpq    %r10, %r9
+;;       jae     0x21
+;;   14: movq    0x60(%rdi), %r11
+;;       movb    %cl, (%r11, %r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   21: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r10
+;;       movl    %edx, %r9d
+;;       cmpq    %r10, %r9
+;;       jae     0x62
+;;   54: movq    0x60(%rdi), %r11
+;;       movzbq  (%r11, %r9), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   62: ud2
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..e2bcf2d12a14
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r8
+;;       movl    %edx, %r10d
+;;       subq    $0x1001, %r8
+;;       cmpq    %r8, %r10
+;;       ja      0x2c
+;;   1b: movq    0x60(%rdi), %rsi
+;;       movb    %cl, 0x1000(%rsi, %r10)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   2c: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r8
+;;       movl    %edx, %r10d
+;;       subq    $0x1001, %r8
+;;       cmpq    %r8, %r10
+;;       ja      0x6d
+;;   5b: movq    0x60(%rdi), %rsi
+;;       movzbq  0x1000(%rsi, %r10), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6d: ud2
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..2634eba9c362
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r8d
+;;       movq    %r8, %r11
+;;       addq    0x2f(%rip), %r11
+;;       jb      0x38
+;;   17: movq    0x68(%rdi), %rsi
+;;       cmpq    %rsi, %r11
+;;       ja      0x36
+;;   24: addq    0x60(%rdi), %r8
+;;       movl    $0xffff0000, %eax
+;;       movb    %cl, (%r8, %rax)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   36: ud2
+;;   38: ud2
+;;   3a: addb    %al, (%rax)
+;;   3c: addb    %al, (%rax)
+;;   3e: addb    %al, (%rax)
+;;   40: addl    %eax, (%rax)
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r8d
+;;       movq    %r8, %r11
+;;       addq    0x2f(%rip), %r11
+;;       jb      0x99
+;;   77: movq    0x68(%rdi), %rsi
+;;       cmpq    %rsi, %r11
+;;       ja      0x97
+;;   84: addq    0x60(%rdi), %r8
+;;       movl    $0xffff0000, %eax
+;;       movzbq  (%r8, %rax), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   97: ud2
+;;   99: ud2
+;;   9b: addb    %al, (%rax)
+;;   9d: addb    %al, (%rax)
+;;   9f: addb    %al, (%rcx)
+;;   a1: addb    %bh, %bh
+;;   a3: incl    (%rax)
+;;   a5: addb    %al, (%rax)
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..8a12388ffc0d
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r10
+;;       movl    %edx, %esi
+;;       subq    $4, %r10
+;;       xorq    %rax, %rax
+;;       movq    %rsi, %r11
+;;       addq    0x60(%rdi), %r11
+;;       cmpq    %r10, %rsi
+;;       cmovaq  %rax, %r11
+;;       movl    %ecx, (%r11)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r10
+;;       movl    %edx, %esi
+;;       subq    $4, %r10
+;;       xorq    %rax, %rax
+;;       movq    %rsi, %r11
+;;       addq    0x60(%rdi), %r11
+;;       cmpq    %r10, %rsi
+;;       cmovaq  %rax, %r11
+;;       movl    (%r11), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..7346bca4259b
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r10
+;;       movq    0x60(%rdi), %rdi
+;;       movl    %edx, %eax
+;;       subq    $0x1004, %r10
+;;       xorq    %rdx, %rdx
+;;       leaq    0x1000(%rdi, %rax), %rsi
+;;       cmpq    %r10, %rax
+;;       cmovaq  %rdx, %rsi
+;;       movl    %ecx, (%rsi)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r10
+;;       movq    0x60(%rdi), %rdi
+;;       movl    %edx, %eax
+;;       subq    $0x1004, %r10
+;;       xorq    %rcx, %rcx
+;;       leaq    0x1000(%rdi, %rax), %rsi
+;;       cmpq    %r10, %rax
+;;       cmovaq  %rcx, %rsi
+;;       movl    (%rsi), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..1acefc22de0f
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,65 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r10d
+;;       movq    %r10, %rax
+;;       addq    0x2f(%rip), %rax
+;;       jb      0x3a
+;;   17: movq    0x68(%rdi), %r8
+;;       xorq    %rdx, %rdx
+;;       addq    0x60(%rdi), %r10
+;;       movl    $0xffff0000, %r9d
+;;       addq    %r10, %r9
+;;       cmpq    %r8, %rax
+;;       cmovaq  %rdx, %r9
+;;       movl    %ecx, (%r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3a: ud2
+;;   3c: addb    %al, (%rax)
+;;   3e: addb    %al, (%rax)
+;;   40: addb    $0, %al
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r10d
+;;       movq    %r10, %rax
+;;       addq    0x2f(%rip), %rax
+;;       jb      0x9a
+;;   77: movq    0x68(%rdi), %rdx
+;;       xorq    %rcx, %rcx
+;;       addq    0x60(%rdi), %r10
+;;       movl    $0xffff0000, %r8d
+;;       addq    %r10, %r8
+;;       cmpq    %rdx, %rax
+;;       cmovaq  %rcx, %r8
+;;       movl    (%r8), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   9a: ud2
+;;   9c: addb    %al, (%rax)
+;;   9e: addb    %al, (%rax)
+;;   a0: addb    $0, %al
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..af5f121d99d6
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r11
+;;       movl    %edx, %eax
+;;       xorq    %rsi, %rsi
+;;       movq    %rax, %r10
+;;       addq    0x60(%rdi), %r10
+;;       cmpq    %r11, %rax
+;;       cmovaeq %rsi, %r10
+;;       movb    %cl, (%r10)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r11
+;;       movl    %edx, %eax
+;;       xorq    %rsi, %rsi
+;;       movq    %rax, %r10
+;;       addq    0x60(%rdi), %r10
+;;       cmpq    %r11, %rax
+;;       cmovaeq %rsi, %r10
+;;       movzbq  (%r10), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..57a59dc7b6e3
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r10
+;;       movq    0x60(%rdi), %rdi
+;;       movl    %edx, %eax
+;;       subq    $0x1001, %r10
+;;       xorq    %rdx, %rdx
+;;       leaq    0x1000(%rdi, %rax), %rsi
+;;       cmpq    %r10, %rax
+;;       cmovaq  %rdx, %rsi
+;;       movb    %cl, (%rsi)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r10
+;;       movq    0x60(%rdi), %rdi
+;;       movl    %edx, %eax
+;;       subq    $0x1001, %r10
+;;       xorq    %rcx, %rcx
+;;       leaq    0x1000(%rdi, %rax), %rsi
+;;       cmpq    %r10, %rax
+;;       cmovaq  %rcx, %rsi
+;;       movzbq  (%rsi), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..ea8de970b5df
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,67 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r10d
+;;       movq    %r10, %rax
+;;       addq    0x2f(%rip), %rax
+;;       jb      0x3a
+;;   17: movq    0x68(%rdi), %r8
+;;       xorq    %rdx, %rdx
+;;       addq    0x60(%rdi), %r10
+;;       movl    $0xffff0000, %r9d
+;;       addq    %r10, %r9
+;;       cmpq    %r8, %rax
+;;       cmovaq  %rdx, %r9
+;;       movb    %cl, (%r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3a: ud2
+;;   3c: addb    %al, (%rax)
+;;   3e: addb    %al, (%rax)
+;;   40: addl    %eax, (%rax)
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r10d
+;;       movq    %r10, %rax
+;;       addq    0x2f(%rip), %rax
+;;       jb      0x9b
+;;   77: movq    0x68(%rdi), %rdx
+;;       xorq    %rcx, %rcx
+;;       addq    0x60(%rdi), %r10
+;;       movl    $0xffff0000, %r8d
+;;       addq    %r10, %r8
+;;       cmpq    %rdx, %rax
+;;       cmovaq  %rcx, %r8
+;;       movzbq  (%r8), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   9b: ud2
+;;   9d: addb    %al, (%rax)
+;;   9f: addb    %al, (%rcx)
+;;   a1: addb    %bh, %bh
+;;   a3: incl    (%rax)
+;;   a5: addb    %al, (%rax)
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..0ab64fe1a2e2
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r10
+;;       movl    %edx, %r9d
+;;       cmpq    %r10, %r9
+;;       ja      0x21
+;;   14: movq    0x60(%rdi), %r11
+;;       movl    %ecx, (%r11, %r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   21: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r10
+;;       movl    %edx, %r9d
+;;       cmpq    %r10, %r9
+;;       ja      0x61
+;;   54: movq    0x60(%rdi), %r11
+;;       movl    (%r11, %r9), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   61: ud2
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..db1892e2f2d6
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r10
+;;       movl    %edx, %r9d
+;;       cmpq    %r10, %r9
+;;       ja      0x25
+;;   14: movq    0x60(%rdi), %r11
+;;       movl    %ecx, 0x1000(%r11, %r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   25: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r10
+;;       movl    %edx, %r9d
+;;       cmpq    %r10, %r9
+;;       ja      0x65
+;;   54: movq    0x60(%rdi), %r11
+;;       movl    0x1000(%r11, %r9), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   65: ud2
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..8acf83f529d2
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r10
+;;       movl    %edx, %r9d
+;;       cmpq    %r10, %r9
+;;       ja      0x26
+;;   14: addq    0x60(%rdi), %r9
+;;       movl    $0xffff0000, %esi
+;;       movl    %ecx, (%r9, %rsi)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   26: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r10
+;;       movl    %edx, %r9d
+;;       cmpq    %r10, %r9
+;;       ja      0x66
+;;   54: addq    0x60(%rdi), %r9
+;;       movl    $0xffff0000, %esi
+;;       movl    (%r9, %rsi), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   66: ud2
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..d90fb8880cb7
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r10
+;;       movl    %edx, %r9d
+;;       cmpq    %r10, %r9
+;;       jae     0x21
+;;   14: movq    0x60(%rdi), %r11
+;;       movb    %cl, (%r11, %r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   21: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r10
+;;       movl    %edx, %r9d
+;;       cmpq    %r10, %r9
+;;       jae     0x62
+;;   54: movq    0x60(%rdi), %r11
+;;       movzbq  (%r11, %r9), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   62: ud2
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..9dd6d5593272
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r10
+;;       movl    %edx, %r9d
+;;       cmpq    %r10, %r9
+;;       ja      0x25
+;;   14: movq    0x60(%rdi), %r11
+;;       movb    %cl, 0x1000(%r11, %r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   25: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r10
+;;       movl    %edx, %r9d
+;;       cmpq    %r10, %r9
+;;       ja      0x66
+;;   54: movq    0x60(%rdi), %r11
+;;       movzbq  0x1000(%r11, %r9), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   66: ud2
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..5d6ced0bd78b
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r10
+;;       movl    %edx, %r9d
+;;       cmpq    %r10, %r9
+;;       ja      0x26
+;;   14: addq    0x60(%rdi), %r9
+;;       movl    $0xffff0000, %esi
+;;       movb    %cl, (%r9, %rsi)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   26: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r10
+;;       movl    %edx, %r9d
+;;       cmpq    %r10, %r9
+;;       ja      0x67
+;;   54: addq    0x60(%rdi), %r9
+;;       movl    $0xffff0000, %esi
+;;       movzbq  (%r9, %rsi), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   67: ud2
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..438006449694
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r11
+;;       movl    %edx, %eax
+;;       xorq    %rsi, %rsi
+;;       movq    %rax, %r10
+;;       addq    0x60(%rdi), %r10
+;;       cmpq    %r11, %rax
+;;       cmovaq  %rsi, %r10
+;;       movl    %ecx, (%r10)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r11
+;;       movl    %edx, %eax
+;;       xorq    %rsi, %rsi
+;;       movq    %rax, %r10
+;;       addq    0x60(%rdi), %r10
+;;       cmpq    %r11, %rax
+;;       cmovaq  %rsi, %r10
+;;       movl    (%r10), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..48be030254e4
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %rsi
+;;       movq    0x60(%rdi), %rax
+;;       movl    %edx, %edx
+;;       xorq    %rdi, %rdi
+;;       leaq    0x1000(%rax, %rdx), %r11
+;;       cmpq    %rsi, %rdx
+;;       cmovaq  %rdi, %r11
+;;       movl    %ecx, (%r11)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %rsi
+;;       movq    0x60(%rdi), %rax
+;;       movl    %edx, %ecx
+;;       xorq    %rdi, %rdi
+;;       leaq    0x1000(%rax, %rcx), %r11
+;;       cmpq    %rsi, %rcx
+;;       cmovaq  %rdi, %r11
+;;       movl    (%r11), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..9540ec4a922e
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,53 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r8
+;;       movl    %edx, %edx
+;;       xorq    %rax, %rax
+;;       movq    %rdx, %r9
+;;       addq    0x60(%rdi), %r9
+;;       movl    $0xffff0000, %edi
+;;       leaq    (%r9, %rdi), %rsi
+;;       cmpq    %r8, %rdx
+;;       cmovaq  %rax, %rsi
+;;       movl    %ecx, (%rsi)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r9
+;;       movl    %edx, %ecx
+;;       xorq    %rax, %rax
+;;       movq    %rcx, %r8
+;;       addq    0x60(%rdi), %r8
+;;       movl    $0xffff0000, %edi
+;;       leaq    (%r8, %rdi), %rsi
+;;       cmpq    %r9, %rcx
+;;       cmovaq  %rax, %rsi
+;;       movl    (%rsi), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..7c48c64b549a
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r11
+;;       movl    %edx, %eax
+;;       xorq    %rsi, %rsi
+;;       movq    %rax, %r10
+;;       addq    0x60(%rdi), %r10
+;;       cmpq    %r11, %rax
+;;       cmovaeq %rsi, %r10
+;;       movb    %cl, (%r10)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r11
+;;       movl    %edx, %eax
+;;       xorq    %rsi, %rsi
+;;       movq    %rax, %r10
+;;       addq    0x60(%rdi), %r10
+;;       cmpq    %r11, %rax
+;;       cmovaeq %rsi, %r10
+;;       movzbq  (%r10), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..b90e22a09c94
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %rsi
+;;       movq    0x60(%rdi), %rax
+;;       movl    %edx, %edx
+;;       xorq    %rdi, %rdi
+;;       leaq    0x1000(%rax, %rdx), %r11
+;;       cmpq    %rsi, %rdx
+;;       cmovaq  %rdi, %r11
+;;       movb    %cl, (%r11)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %rsi
+;;       movq    0x60(%rdi), %rax
+;;       movl    %edx, %ecx
+;;       xorq    %rdi, %rdi
+;;       leaq    0x1000(%rax, %rcx), %r11
+;;       cmpq    %rsi, %rcx
+;;       cmovaq  %rdi, %r11
+;;       movzbq  (%r11), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..a060373e4f4f
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,53 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r8
+;;       movl    %edx, %edx
+;;       xorq    %rax, %rax
+;;       movq    %rdx, %r9
+;;       addq    0x60(%rdi), %r9
+;;       movl    $0xffff0000, %edi
+;;       leaq    (%r9, %rdi), %rsi
+;;       cmpq    %r8, %rdx
+;;       cmovaq  %rax, %rsi
+;;       movb    %cl, (%rsi)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r9
+;;       movl    %edx, %ecx
+;;       xorq    %rax, %rax
+;;       movq    %rcx, %r8
+;;       addq    0x60(%rdi), %r8
+;;       movl    $0xffff0000, %edi
+;;       leaq    (%r8, %rdi), %rsi
+;;       cmpq    %r9, %rcx
+;;       cmovaq  %rax, %rsi
+;;       movzbq  (%rsi), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..d2977ae41a7b
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r8
+;;       subq    $4, %r8
+;;       cmpq    %r8, %rdx
+;;       ja      0x22
+;;   15: movq    0x60(%rdi), %r11
+;;       movl    %ecx, (%r11, %rdx)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   22: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r8
+;;       subq    $4, %r8
+;;       cmpq    %r8, %rdx
+;;       ja      0x62
+;;   55: movq    0x60(%rdi), %r11
+;;       movl    (%r11, %rdx), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   62: ud2
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..b8f90a710d12
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r8
+;;       subq    $0x1004, %r8
+;;       cmpq    %r8, %rdx
+;;       ja      0x29
+;;   18: movq    0x60(%rdi), %r11
+;;       movl    %ecx, 0x1000(%r11, %rdx)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   29: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r8
+;;       subq    $0x1004, %r8
+;;       cmpq    %r8, %rdx
+;;       ja      0x69
+;;   58: movq    0x60(%rdi), %r11
+;;       movl    0x1000(%r11, %rdx), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   69: ud2
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..bb753a19a9f6
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,59 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    %rdx, %r10
+;;       addq    0x2a(%rip), %r10
+;;       jb      0x34
+;;   14: movq    0x68(%rdi), %r11
+;;       cmpq    %r11, %r10
+;;       ja      0x32
+;;   21: addq    0x60(%rdi), %rdx
+;;       movl    $0xffff0000, %edi
+;;       movl    %ecx, (%rdx, %rdi)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   32: ud2
+;;   34: ud2
+;;   36: addb    %al, (%rax)
+;;   38: addb    $0, %al
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    %rdx, %r10
+;;       addq    0x2a(%rip), %r10
+;;       jb      0x74
+;;   54: movq    0x68(%rdi), %r11
+;;       cmpq    %r11, %r10
+;;       ja      0x72
+;;   61: addq    0x60(%rdi), %rdx
+;;       movl    $0xffff0000, %edi
+;;       movl    (%rdx, %rdi), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   72: ud2
+;;   74: ud2
+;;   76: addb    %al, (%rax)
+;;   78: addb    $0, %al
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..96710088e94d
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r8
+;;       cmpq    %r8, %rdx
+;;       jae     0x1e
+;;   11: movq    0x60(%rdi), %r10
+;;       movb    %cl, (%r10, %rdx)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   1e: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r8
+;;       cmpq    %r8, %rdx
+;;       jae     0x3f
+;;   31: movq    0x60(%rdi), %r10
+;;       movzbq  (%r10, %rdx), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3f: ud2
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..b92422983012
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r8
+;;       subq    $0x1001, %r8
+;;       cmpq    %r8, %rdx
+;;       ja      0x29
+;;   18: movq    0x60(%rdi), %r11
+;;       movb    %cl, 0x1000(%r11, %rdx)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   29: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r8
+;;       subq    $0x1001, %r8
+;;       cmpq    %r8, %rdx
+;;       ja      0x6a
+;;   58: movq    0x60(%rdi), %r11
+;;       movzbq  0x1000(%r11, %rdx), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6a: ud2
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..ef5f64ec5265
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,58 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    %rdx, %r10
+;;       addq    0x2a(%rip), %r10
+;;       jb      0x34
+;;   14: movq    0x68(%rdi), %r11
+;;       cmpq    %r11, %r10
+;;       ja      0x32
+;;   21: addq    0x60(%rdi), %rdx
+;;       movl    $0xffff0000, %edi
+;;       movb    %cl, (%rdx, %rdi)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   32: ud2
+;;   34: ud2
+;;   36: addb    %al, (%rax)
+;;   38: addl    %eax, (%rax)
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    %rdx, %r10
+;;       addq    0x2a(%rip), %r10
+;;       jb      0x76
+;;   54: movq    0x68(%rdi), %r11
+;;       cmpq    %r11, %r10
+;;       ja      0x74
+;;   61: addq    0x60(%rdi), %rdx
+;;       movl    $0xffff0000, %edi
+;;       movzbq  (%rdx, %rdi), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   74: ud2
+;;   76: ud2
+;;   78: addl    %eax, (%rax)
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..5164f66bd022
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r10
+;;       subq    $4, %r10
+;;       xorq    %r11, %r11
+;;       movq    %rdx, %rsi
+;;       addq    0x60(%rdi), %rsi
+;;       cmpq    %r10, %rdx
+;;       cmovaq  %r11, %rsi
+;;       movl    %ecx, (%rsi)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r10
+;;       subq    $4, %r10
+;;       xorq    %r11, %r11
+;;       movq    %rdx, %rsi
+;;       addq    0x60(%rdi), %rsi
+;;       cmpq    %r10, %rdx
+;;       cmovaq  %r11, %rsi
+;;       movl    (%rsi), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..6c1608ad0e9f
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r10
+;;       movq    0x60(%rdi), %rdi
+;;       subq    $0x1004, %r10
+;;       xorq    %rsi, %rsi
+;;       leaq    0x1000(%rdi, %rdx), %r11
+;;       cmpq    %r10, %rdx
+;;       cmovaq  %rsi, %r11
+;;       movl    %ecx, (%r11)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r10
+;;       movq    0x60(%rdi), %rdi
+;;       subq    $0x1004, %r10
+;;       xorq    %rsi, %rsi
+;;       leaq    0x1000(%rdi, %rdx), %r11
+;;       cmpq    %r10, %rdx
+;;       cmovaq  %rsi, %r11
+;;       movl    (%r11), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..3b3311e7c753
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,65 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    %rdx, %r8
+;;       addq    0x32(%rip), %r8
+;;       jb      0x37
+;;   14: movq    0x68(%rdi), %r9
+;;       xorq    %rax, %rax
+;;       addq    0x60(%rdi), %rdx
+;;       movl    $0xffff0000, %r10d
+;;       leaq    (%rdx, %r10), %rdi
+;;       cmpq    %r9, %r8
+;;       cmovaq  %rax, %rdi
+;;       movl    %ecx, (%rdi)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   37: ud2
+;;   39: addb    %al, (%rax)
+;;   3b: addb    %al, (%rax)
+;;   3d: addb    %al, (%rax)
+;;   3f: addb    %al, (%rax, %rax)
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    %rdx, %rcx
+;;       addq    0x32(%rip), %rcx
+;;       jb      0x97
+;;   74: movq    0x68(%rdi), %r8
+;;       xorq    %rax, %rax
+;;       addq    0x60(%rdi), %rdx
+;;       movl    $0xffff0000, %r9d
+;;       leaq    (%rdx, %r9), %rdi
+;;       cmpq    %r8, %rcx
+;;       cmovaq  %rax, %rdi
+;;       movl    (%rdi), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   97: ud2
+;;   99: addb    %al, (%rax)
+;;   9b: addb    %al, (%rax)
+;;   9d: addb    %al, (%rax)
+;;   9f: addb    %al, (%rax, %rax)
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..cee7e6281ebd
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r11
+;;       xorq    %r10, %r10
+;;       movq    %rdx, %r9
+;;       addq    0x60(%rdi), %r9
+;;       cmpq    %r11, %rdx
+;;       cmovaeq %r10, %r9
+;;       movb    %cl, (%r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r11
+;;       xorq    %r10, %r10
+;;       movq    %rdx, %r9
+;;       addq    0x60(%rdi), %r9
+;;       cmpq    %r11, %rdx
+;;       cmovaeq %r10, %r9
+;;       movzbq  (%r9), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..162a098a1c51
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r10
+;;       movq    0x60(%rdi), %rdi
+;;       subq    $0x1001, %r10
+;;       xorq    %rsi, %rsi
+;;       leaq    0x1000(%rdi, %rdx), %r11
+;;       cmpq    %r10, %rdx
+;;       cmovaq  %rsi, %r11
+;;       movb    %cl, (%r11)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r10
+;;       movq    0x60(%rdi), %rdi
+;;       subq    $0x1001, %r10
+;;       xorq    %rsi, %rsi
+;;       leaq    0x1000(%rdi, %rdx), %r11
+;;       cmpq    %r10, %rdx
+;;       cmovaq  %rsi, %r11
+;;       movzbq  (%r11), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..47a8518b70f5
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,70 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    %rdx, %r8
+;;       addq    0x32(%rip), %r8
+;;       jb      0x37
+;;   14: movq    0x68(%rdi), %r9
+;;       xorq    %rax, %rax
+;;       addq    0x60(%rdi), %rdx
+;;       movl    $0xffff0000, %r10d
+;;       leaq    (%rdx, %r10), %rdi
+;;       cmpq    %r9, %r8
+;;       cmovaq  %rax, %rdi
+;;       movb    %cl, (%rdi)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   37: ud2
+;;   39: addb    %al, (%rax)
+;;   3b: addb    %al, (%rax)
+;;   3d: addb    %al, (%rax)
+;;   3f: addb    %al, (%rcx)
+;;   41: addb    %bh, %bh
+;;   43: incl    (%rax)
+;;   45: addb    %al, (%rax)
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    %rdx, %rcx
+;;       addq    0x32(%rip), %rcx
+;;       jb      0x99
+;;   74: movq    0x68(%rdi), %r8
+;;       xorq    %rax, %rax
+;;       addq    0x60(%rdi), %rdx
+;;       movl    $0xffff0000, %r9d
+;;       leaq    (%rdx, %r9), %rdi
+;;       cmpq    %r8, %rcx
+;;       cmovaq  %rax, %rdi
+;;       movzbq  (%rdi), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   99: ud2
+;;   9b: addb    %al, (%rax)
+;;   9d: addb    %al, (%rax)
+;;   9f: addb    %al, (%rcx)
+;;   a1: addb    %bh, %bh
+;;   a3: incl    (%rax)
+;;   a5: addb    %al, (%rax)
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..f67856a4ea39
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r8
+;;       cmpq    %r8, %rdx
+;;       ja      0x1e
+;;   11: movq    0x60(%rdi), %r10
+;;       movl    %ecx, (%r10, %rdx)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   1e: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r8
+;;       cmpq    %r8, %rdx
+;;       ja      0x3e
+;;   31: movq    0x60(%rdi), %r10
+;;       movl    (%r10, %rdx), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3e: ud2
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..b5714171eae9
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r8
+;;       cmpq    %r8, %rdx
+;;       ja      0x22
+;;   11: movq    0x60(%rdi), %r10
+;;       movl    %ecx, 0x1000(%r10, %rdx)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   22: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r8
+;;       cmpq    %r8, %rdx
+;;       ja      0x62
+;;   51: movq    0x60(%rdi), %r10
+;;       movl    0x1000(%r10, %rdx), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   62: ud2
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..7d4001522ca9
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r9
+;;       cmpq    %r9, %rdx
+;;       ja      0x24
+;;   11: addq    0x60(%rdi), %rdx
+;;       movl    $0xffff0000, %r11d
+;;       movl    %ecx, (%rdx, %r11)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   24: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r9
+;;       cmpq    %r9, %rdx
+;;       ja      0x64
+;;   51: addq    0x60(%rdi), %rdx
+;;       movl    $0xffff0000, %r11d
+;;       movl    (%rdx, %r11), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   64: ud2
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..204fed8ae17e
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r8
+;;       cmpq    %r8, %rdx
+;;       jae     0x1e
+;;   11: movq    0x60(%rdi), %r10
+;;       movb    %cl, (%r10, %rdx)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   1e: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r8
+;;       cmpq    %r8, %rdx
+;;       jae     0x3f
+;;   31: movq    0x60(%rdi), %r10
+;;       movzbq  (%r10, %rdx), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3f: ud2
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..c42d1978e6cf
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r8
+;;       cmpq    %r8, %rdx
+;;       ja      0x22
+;;   11: movq    0x60(%rdi), %r10
+;;       movb    %cl, 0x1000(%r10, %rdx)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   22: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r8
+;;       cmpq    %r8, %rdx
+;;       ja      0x63
+;;   51: movq    0x60(%rdi), %r10
+;;       movzbq  0x1000(%r10, %rdx), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   63: ud2
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..547b9aab3e30
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r9
+;;       cmpq    %r9, %rdx
+;;       ja      0x24
+;;   11: addq    0x60(%rdi), %rdx
+;;       movl    $0xffff0000, %r11d
+;;       movb    %cl, (%rdx, %r11)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   24: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r9
+;;       cmpq    %r9, %rdx
+;;       ja      0x65
+;;   51: addq    0x60(%rdi), %rdx
+;;       movl    $0xffff0000, %r11d
+;;       movzbq  (%rdx, %r11), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   65: ud2
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..7f519759d58d
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r11
+;;       xorq    %r10, %r10
+;;       movq    %rdx, %r9
+;;       addq    0x60(%rdi), %r9
+;;       cmpq    %r11, %rdx
+;;       cmovaq  %r10, %r9
+;;       movl    %ecx, (%r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r11
+;;       xorq    %r10, %r10
+;;       movq    %rdx, %r9
+;;       addq    0x60(%rdi), %r9
+;;       cmpq    %r11, %rdx
+;;       cmovaq  %r10, %r9
+;;       movl    (%r9), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..31ee2cb41064
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r11
+;;       movq    0x60(%rdi), %rdi
+;;       xorq    %rsi, %rsi
+;;       leaq    0x1000(%rdi, %rdx), %r10
+;;       cmpq    %r11, %rdx
+;;       cmovaq  %rsi, %r10
+;;       movl    %ecx, (%r10)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r11
+;;       movq    0x60(%rdi), %rdi
+;;       xorq    %rsi, %rsi
+;;       leaq    0x1000(%rdi, %rdx), %r10
+;;       cmpq    %r11, %rdx
+;;       cmovaq  %rsi, %r10
+;;       movl    (%r10), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..b4e0bfd742e1
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %rax
+;;       xorq    %rsi, %rsi
+;;       movq    %rdx, %r8
+;;       addq    0x60(%rdi), %r8
+;;       movl    $0xffff0000, %edi
+;;       leaq    (%r8, %rdi), %r11
+;;       cmpq    %rax, %rdx
+;;       cmovaq  %rsi, %r11
+;;       movl    %ecx, (%r11)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %rax
+;;       xorq    %rsi, %rsi
+;;       movq    %rdx, %rcx
+;;       addq    0x60(%rdi), %rcx
+;;       movl    $0xffff0000, %edi
+;;       leaq    (%rcx, %rdi), %r11
+;;       cmpq    %rax, %rdx
+;;       cmovaq  %rsi, %r11
+;;       movl    (%r11), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..5c023c883ebe
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r11
+;;       xorq    %r10, %r10
+;;       movq    %rdx, %r9
+;;       addq    0x60(%rdi), %r9
+;;       cmpq    %r11, %rdx
+;;       cmovaeq %r10, %r9
+;;       movb    %cl, (%r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r11
+;;       xorq    %r10, %r10
+;;       movq    %rdx, %r9
+;;       addq    0x60(%rdi), %r9
+;;       cmpq    %r11, %rdx
+;;       cmovaeq %r10, %r9
+;;       movzbq  (%r9), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..f704da3202c0
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r11
+;;       movq    0x60(%rdi), %rdi
+;;       xorq    %rsi, %rsi
+;;       leaq    0x1000(%rdi, %rdx), %r10
+;;       cmpq    %r11, %rdx
+;;       cmovaq  %rsi, %r10
+;;       movb    %cl, (%r10)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %r11
+;;       movq    0x60(%rdi), %rdi
+;;       xorq    %rsi, %rsi
+;;       leaq    0x1000(%rdi, %rdx), %r10
+;;       cmpq    %r11, %rdx
+;;       cmovaq  %rsi, %r10
+;;       movzbq  (%r10), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..4cf845349c34
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_dynamic_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-maximum-size=0 -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %rax
+;;       xorq    %rsi, %rsi
+;;       movq    %rdx, %r8
+;;       addq    0x60(%rdi), %r8
+;;       movl    $0xffff0000, %edi
+;;       leaq    (%r8, %rdi), %r11
+;;       cmpq    %rax, %rdx
+;;       cmovaq  %rsi, %r11
+;;       movb    %cl, (%r11)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x68(%rdi), %rax
+;;       xorq    %rsi, %rsi
+;;       movq    %rdx, %rcx
+;;       addq    0x60(%rdi), %rcx
+;;       movl    $0xffff0000, %edi
+;;       leaq    (%rcx, %rdi), %r11
+;;       cmpq    %rax, %rdx
+;;       cmovaq  %rsi, %r11
+;;       movzbq  (%r11), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..bb673770a4f9
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r8d
+;;       cmpq    0x1a(%rip), %r8
+;;       ja      0x21
+;;   14: movq    0x60(%rdi), %r10
+;;       movl    %ecx, (%r10, %r8)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   21: ud2
+;;   23: addb    %al, (%rax)
+;;   25: addb    %al, (%rax)
+;;   27: addb    %bh, %ah
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r8d
+;;       cmpq    0x1a(%rip), %r8
+;;       ja      0x61
+;;   54: movq    0x60(%rdi), %r10
+;;       movl    (%r10, %r8), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   61: ud2
+;;   63: addb    %al, (%rax)
+;;   65: addb    %al, (%rax)
+;;   67: addb    %bh, %ah
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..f5a88f0c47dd
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r8d
+;;       cmpq    0x1a(%rip), %r8
+;;       ja      0x25
+;;   14: movq    0x60(%rdi), %r10
+;;       movl    %ecx, 0x1000(%r10, %r8)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   25: ud2
+;;   27: addb    %bh, %ah
+;;   29: outl    %eax, %dx
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r8d
+;;       cmpq    0x1a(%rip), %r8
+;;       ja      0x65
+;;   54: movq    0x60(%rdi), %r10
+;;       movl    0x1000(%r10, %r8), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   65: ud2
+;;   67: addb    %bh, %ah
+;;   69: outl    %eax, %dx
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..c5ba9f5e0669
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r8d
+;;       cmpq    $0xfffc, %r8
+;;       ja      0x27
+;;   14: addq    0x60(%rdi), %r8
+;;       movl    $0xffff0000, %r11d
+;;       movl    %ecx, (%r8, %r11)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   27: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r8d
+;;       cmpq    $0xfffc, %r8
+;;       ja      0x67
+;;   54: addq    0x60(%rdi), %r8
+;;       movl    $0xffff0000, %r11d
+;;       movl    (%r8, %r11), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   67: ud2
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..5712d826325f
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,39 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x60(%rdi), %r8
+;;       movl    %edx, %r9d
+;;       movb    %cl, (%r8, %r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x60(%rdi), %r8
+;;       movl    %edx, %r9d
+;;       movzbq  (%r8, %r9), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..da12a01d60fa
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r8d
+;;       cmpq    0x1a(%rip), %r8
+;;       ja      0x25
+;;   14: movq    0x60(%rdi), %r10
+;;       movb    %cl, 0x1000(%r10, %r8)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   25: ud2
+;;   27: addb    %bh, %bh
+;;   29: outl    %eax, %dx
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r8d
+;;       cmpq    0x1a(%rip), %r8
+;;       ja      0x66
+;;   54: movq    0x60(%rdi), %r10
+;;       movzbq  0x1000(%r10, %r8), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   66: ud2
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..2237b3d40a31
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r8d
+;;       cmpq    $0xffff, %r8
+;;       ja      0x27
+;;   14: addq    0x60(%rdi), %r8
+;;       movl    $0xffff0000, %r11d
+;;       movb    %cl, (%r8, %r11)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   27: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r8d
+;;       cmpq    $0xffff, %r8
+;;       ja      0x68
+;;   54: addq    0x60(%rdi), %r8
+;;       movl    $0xffff0000, %r11d
+;;       movzbq  (%r8, %r11), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   68: ud2
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..b6846ae71622
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,53 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r11d
+;;       xorq    %r10, %r10
+;;       movq    %r11, %r9
+;;       addq    0x60(%rdi), %r9
+;;       cmpq    0x10(%rip), %r11
+;;       cmovaq  %r10, %r9
+;;       movl    %ecx, (%r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   24: addb    %al, (%rax)
+;;   26: addb    %al, (%rax)
+;;   28: cld
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r11d
+;;       xorq    %r10, %r10
+;;       movq    %r11, %r9
+;;       addq    0x60(%rdi), %r9
+;;       cmpq    0x10(%rip), %r11
+;;       cmovaq  %r10, %r9
+;;       movl    (%r9), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   64: addb    %al, (%rax)
+;;   66: addb    %al, (%rax)
+;;   68: cld
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..03ea375c31e1
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %esi
+;;       xorq    %r11, %r11
+;;       movq    0x60(%rdi), %rdi
+;;       leaq    0x1000(%rdi, %rsi), %r10
+;;       cmpq    0xc(%rip), %rsi
+;;       cmovaq  %r11, %r10
+;;       movl    %ecx, (%r10)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   28: cld
+;;   29: outl    %eax, %dx
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %esi
+;;       xorq    %r11, %r11
+;;       movq    0x60(%rdi), %rdi
+;;       leaq    0x1000(%rdi, %rsi), %r10
+;;       cmpq    0xc(%rip), %rsi
+;;       cmovaq  %r11, %r10
+;;       movl    (%r10), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   68: cld
+;;   69: outl    %eax, %dx
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..856b32fc43fd
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    %rdi, %rax
+;;       movl    %edx, %edi
+;;       xorq    %rsi, %rsi
+;;       movq    %rax, %rdx
+;;       movq    %rdi, %rax
+;;       addq    0x60(%rdx), %rax
+;;       movl    $0xffff0000, %edx
+;;       leaq    (%rax, %rdx), %r11
+;;       cmpq    $0xfffc, %rdi
+;;       cmovaq  %rsi, %r11
+;;       movl    %ecx, (%r11)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    %rdi, %rax
+;;       movl    %edx, %edi
+;;       xorq    %rsi, %rsi
+;;       movq    %rax, %rcx
+;;       movq    %rdi, %rax
+;;       addq    0x60(%rcx), %rax
+;;       movl    $0xffff0000, %ecx
+;;       leaq    (%rax, %rcx), %r11
+;;       cmpq    $0xfffc, %rdi
+;;       cmovaq  %rsi, %r11
+;;       movl    (%r11), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..48fe91f2704c
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,39 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x60(%rdi), %r8
+;;       movl    %edx, %r9d
+;;       movb    %cl, (%r8, %r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x60(%rdi), %r8
+;;       movl    %edx, %r9d
+;;       movzbq  (%r8, %r9), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..459e9494fce5
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,52 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %esi
+;;       xorq    %r11, %r11
+;;       movq    0x60(%rdi), %rdi
+;;       leaq    0x1000(%rdi, %rsi), %r10
+;;       cmpq    0xc(%rip), %rsi
+;;       cmovaq  %r11, %r10
+;;       movb    %cl, (%r10)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %esi
+;;       xorq    %r11, %r11
+;;       movq    0x60(%rdi), %rdi
+;;       leaq    0x1000(%rdi, %rsi), %r10
+;;       cmpq    0x14(%rip), %rsi
+;;       cmovaq  %r11, %r10
+;;       movzbq  (%r10), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   69: addb    %al, (%rax)
+;;   6b: addb    %al, (%rax)
+;;   6d: addb    %al, (%rax)
+;;   6f: addb    %bh, %bh
+;;   71: outl    %eax, %dx
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..51cd3cc1945f
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,55 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    %rdi, %rax
+;;       movl    %edx, %edi
+;;       xorq    %rsi, %rsi
+;;       movq    %rax, %rdx
+;;       movq    %rdi, %rax
+;;       addq    0x60(%rdx), %rax
+;;       movl    $0xffff0000, %edx
+;;       leaq    (%rax, %rdx), %r11
+;;       cmpq    $0xffff, %rdi
+;;       cmovaq  %rsi, %r11
+;;       movb    %cl, (%r11)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    %rdi, %rax
+;;       movl    %edx, %edi
+;;       xorq    %rsi, %rsi
+;;       movq    %rax, %rcx
+;;       movq    %rdi, %rax
+;;       addq    0x60(%rcx), %rax
+;;       movl    $0xffff0000, %ecx
+;;       leaq    (%rax, %rcx), %r11
+;;       cmpq    $0xffff, %rdi
+;;       cmovaq  %rsi, %r11
+;;       movzbq  (%r11), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..aca51c94c07d
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,39 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x60(%rdi), %r8
+;;       movl    %edx, %r9d
+;;       movl    %ecx, (%r8, %r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x60(%rdi), %r8
+;;       movl    %edx, %r9d
+;;       movl    (%r8, %r9), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..bc57084458af
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,39 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x60(%rdi), %r8
+;;       movl    %edx, %r9d
+;;       movl    %ecx, 0x1000(%r8, %r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x60(%rdi), %r8
+;;       movl    %edx, %r9d
+;;       movl    0x1000(%r8, %r9), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..deef00268665
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,41 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r8d
+;;       addq    0x60(%rdi), %r8
+;;       movl    $0xffff0000, %r9d
+;;       movl    %ecx, (%r8, %r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r8d
+;;       addq    0x60(%rdi), %r8
+;;       movl    $0xffff0000, %r9d
+;;       movl    (%r8, %r9), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..6de3fa29acea
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,39 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x60(%rdi), %r8
+;;       movl    %edx, %r9d
+;;       movb    %cl, (%r8, %r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x60(%rdi), %r8
+;;       movl    %edx, %r9d
+;;       movzbq  (%r8, %r9), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..87ed65e6152e
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,39 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x60(%rdi), %r8
+;;       movl    %edx, %r9d
+;;       movb    %cl, 0x1000(%r8, %r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x60(%rdi), %r8
+;;       movl    %edx, %r9d
+;;       movzbq  0x1000(%r8, %r9), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..a81364b402ef
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,41 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r8d
+;;       addq    0x60(%rdi), %r8
+;;       movl    $0xffff0000, %r9d
+;;       movb    %cl, (%r8, %r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r8d
+;;       addq    0x60(%rdi), %r8
+;;       movl    $0xffff0000, %r9d
+;;       movzbq  (%r8, %r9), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..093142268a91
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,39 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x60(%rdi), %r8
+;;       movl    %edx, %r9d
+;;       movl    %ecx, (%r8, %r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x60(%rdi), %r8
+;;       movl    %edx, %r9d
+;;       movl    (%r8, %r9), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..210d32e74585
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,39 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x60(%rdi), %r8
+;;       movl    %edx, %r9d
+;;       movl    %ecx, 0x1000(%r8, %r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x60(%rdi), %r8
+;;       movl    %edx, %r9d
+;;       movl    0x1000(%r8, %r9), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..ed9ca45988bf
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,41 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r8d
+;;       addq    0x60(%rdi), %r8
+;;       movl    $0xffff0000, %r9d
+;;       movl    %ecx, (%r8, %r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r8d
+;;       addq    0x60(%rdi), %r8
+;;       movl    $0xffff0000, %r9d
+;;       movl    (%r8, %r9), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..3a1948e413f4
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,39 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x60(%rdi), %r8
+;;       movl    %edx, %r9d
+;;       movb    %cl, (%r8, %r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x60(%rdi), %r8
+;;       movl    %edx, %r9d
+;;       movzbq  (%r8, %r9), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..9ba899575d77
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,39 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x60(%rdi), %r8
+;;       movl    %edx, %r9d
+;;       movb    %cl, 0x1000(%r8, %r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x60(%rdi), %r8
+;;       movl    %edx, %r9d
+;;       movzbq  0x1000(%r8, %r9), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..ac3ff9a33731
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i32_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,41 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i32 1)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r8d
+;;       addq    0x60(%rdi), %r8
+;;       movl    $0xffff0000, %r9d
+;;       movb    %cl, (%r8, %r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r8d
+;;       addq    0x60(%rdi), %r8
+;;       movl    $0xffff0000, %r9d
+;;       movzbq  (%r8, %r9), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..f8122487e822
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       cmpq    0x15(%rip), %rdx
+;;       ja      0x1e
+;;   11: movq    0x60(%rdi), %r9
+;;       movl    %ecx, (%r9, %rdx)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   1e: ud2
+;;   20: cld
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       cmpq    0x15(%rip), %rdx
+;;       ja      0x5e
+;;   51: movq    0x60(%rdi), %r9
+;;       movl    (%r9, %rdx), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   5e: ud2
+;;   60: cld
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..1a52ad746b3b
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       cmpq    0x1d(%rip), %rdx
+;;       ja      0x22
+;;   11: movq    0x60(%rdi), %r9
+;;       movl    %ecx, 0x1000(%r9, %rdx)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   22: ud2
+;;   24: addb    %al, (%rax)
+;;   26: addb    %al, (%rax)
+;;   28: cld
+;;   29: outl    %eax, %dx
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       cmpq    0x1d(%rip), %rdx
+;;       ja      0x62
+;;   51: movq    0x60(%rdi), %r9
+;;       movl    0x1000(%r9, %rdx), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   62: ud2
+;;   64: addb    %al, (%rax)
+;;   66: addb    %al, (%rax)
+;;   68: cld
+;;   69: outl    %eax, %dx
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..8f70d5375c35
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       cmpq    $0xfffc, %rdx
+;;       ja      0x24
+;;   11: addq    0x60(%rdi), %rdx
+;;       movl    $0xffff0000, %r10d
+;;       movl    %ecx, (%rdx, %r10)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   24: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       cmpq    $0xfffc, %rdx
+;;       ja      0x64
+;;   51: addq    0x60(%rdi), %rdx
+;;       movl    $0xffff0000, %r10d
+;;       movl    (%rdx, %r10), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   64: ud2
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..31b44b07cd75
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       cmpq    0x15(%rip), %rdx
+;;       ja      0x1e
+;;   11: movq    0x60(%rdi), %r9
+;;       movb    %cl, (%r9, %rdx)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   1e: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       cmpq    0x1d(%rip), %rdx
+;;       ja      0x5f
+;;   51: movq    0x60(%rdi), %r9
+;;       movzbq  (%r9, %rdx), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   5f: ud2
+;;   61: addb    %al, (%rax)
+;;   63: addb    %al, (%rax)
+;;   65: addb    %al, (%rax)
+;;   67: addb    %bh, %bh
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..e9b29d3660f9
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,48 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       cmpq    0x1d(%rip), %rdx
+;;       ja      0x22
+;;   11: movq    0x60(%rdi), %r9
+;;       movb    %cl, 0x1000(%r9, %rdx)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   22: ud2
+;;   24: addb    %al, (%rax)
+;;   26: addb    %al, (%rax)
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       cmpq    0x1d(%rip), %rdx
+;;       ja      0x63
+;;   51: movq    0x60(%rdi), %r9
+;;       movzbq  0x1000(%r9, %rdx), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   63: ud2
+;;   65: addb    %al, (%rax)
+;;   67: addb    %bh, %bh
+;;   69: outl    %eax, %dx
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..c1840a1b1356
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       cmpq    $0xffff, %rdx
+;;       ja      0x24
+;;   11: addq    0x60(%rdi), %rdx
+;;       movl    $0xffff0000, %r10d
+;;       movb    %cl, (%rdx, %r10)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   24: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       cmpq    $0xffff, %rdx
+;;       ja      0x65
+;;   51: addq    0x60(%rdi), %rdx
+;;       movl    $0xffff0000, %r10d
+;;       movzbq  (%rdx, %r10), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   65: ud2
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..321f0552670e
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,53 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       xorq    %r9, %r9
+;;       movq    %rdx, %r8
+;;       addq    0x60(%rdi), %r8
+;;       cmpq    0x13(%rip), %rdx
+;;       cmovaq  %r9, %r8
+;;       movl    %ecx, (%r8)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   21: addb    %al, (%rax)
+;;   23: addb    %al, (%rax)
+;;   25: addb    %al, (%rax)
+;;   27: addb    %bh, %ah
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       xorq    %r9, %r9
+;;       movq    %rdx, %r8
+;;       addq    0x60(%rdi), %r8
+;;       cmpq    0x13(%rip), %rdx
+;;       cmovaq  %r9, %r8
+;;       movl    (%r8), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   61: addb    %al, (%rax)
+;;   63: addb    %al, (%rax)
+;;   65: addb    %al, (%rax)
+;;   67: addb    %bh, %ah
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..788c55ecec2c
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       xorq    %r10, %r10
+;;       movq    0x60(%rdi), %r11
+;;       leaq    0x1000(%r11, %rdx), %r9
+;;       cmpq    0xe(%rip), %rdx
+;;       cmovaq  %r10, %r9
+;;       movl    %ecx, (%r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   26: addb    %al, (%rax)
+;;   28: cld
+;;   29: outl    %eax, %dx
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       xorq    %r10, %r10
+;;       movq    0x60(%rdi), %r11
+;;       leaq    0x1000(%r11, %rdx), %r9
+;;       cmpq    0xe(%rip), %rdx
+;;       cmovaq  %r10, %r9
+;;       movl    (%r9), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   66: addb    %al, (%rax)
+;;   68: cld
+;;   69: outl    %eax, %dx
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..56b11420f564
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       xorq    %r11, %r11
+;;       movq    %rdx, %rsi
+;;       addq    0x60(%rdi), %rsi
+;;       movl    $0xffff0000, %edi
+;;       leaq    (%rsi, %rdi), %r10
+;;       cmpq    $0xfffc, %rdx
+;;       cmovaq  %r11, %r10
+;;       movl    %ecx, (%r10)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       xorq    %r11, %r11
+;;       movq    %rdx, %rsi
+;;       addq    0x60(%rdi), %rsi
+;;       movl    $0xffff0000, %edi
+;;       leaq    (%rsi, %rdi), %r10
+;;       cmpq    $0xfffc, %rdx
+;;       cmovaq  %r11, %r10
+;;       movl    (%r10), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..084a1f9c5d8f
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,52 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       xorq    %r9, %r9
+;;       movq    %rdx, %r8
+;;       addq    0x60(%rdi), %r8
+;;       cmpq    0x13(%rip), %rdx
+;;       cmovaq  %r9, %r8
+;;       movb    %cl, (%r8)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   21: addb    %al, (%rax)
+;;   23: addb    %al, (%rax)
+;;   25: addb    %al, (%rax)
+;;   27: addb    %bh, %bh
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       xorq    %r9, %r9
+;;       movq    %rdx, %r8
+;;       addq    0x60(%rdi), %r8
+;;       cmpq    0x13(%rip), %rdx
+;;       cmovaq  %r9, %r8
+;;       movzbq  (%r8), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   62: addb    %al, (%rax)
+;;   64: addb    %al, (%rax)
+;;   66: addb    %al, (%rax)
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..84697b310e62
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,48 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       xorq    %r10, %r10
+;;       movq    0x60(%rdi), %r11
+;;       leaq    0x1000(%r11, %rdx), %r9
+;;       cmpq    0xe(%rip), %rdx
+;;       cmovaq  %r10, %r9
+;;       movb    %cl, (%r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   26: addb    %al, (%rax)
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       xorq    %r10, %r10
+;;       movq    0x60(%rdi), %r11
+;;       leaq    0x1000(%r11, %rdx), %r9
+;;       cmpq    0xe(%rip), %rdx
+;;       cmovaq  %r10, %r9
+;;       movzbq  (%r9), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   67: addb    %bh, %bh
+;;   69: outl    %eax, %dx
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..4ddc91eb0038
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=0 -O dynamic-memory-guard-size=0"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       xorq    %r11, %r11
+;;       movq    %rdx, %rsi
+;;       addq    0x60(%rdi), %rsi
+;;       movl    $0xffff0000, %edi
+;;       leaq    (%rsi, %rdi), %r10
+;;       cmpq    $0xffff, %rdx
+;;       cmovaq  %r11, %r10
+;;       movb    %cl, (%r10)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       xorq    %r11, %r11
+;;       movq    %rdx, %rsi
+;;       addq    0x60(%rdi), %rsi
+;;       movl    $0xffff0000, %edi
+;;       leaq    (%rsi, %rdi), %r10
+;;       cmpq    $0xffff, %rdx
+;;       cmovaq  %r11, %r10
+;;       movzbq  (%r10), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..e375f5962dd8
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0_offset.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       cmpq    0x15(%rip), %rdx
+;;       ja      0x1e
+;;   11: movq    0x60(%rdi), %r9
+;;       movl    %ecx, (%r9, %rdx)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   1e: ud2
+;;   20: cld
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       cmpq    0x15(%rip), %rdx
+;;       ja      0x5e
+;;   51: movq    0x60(%rdi), %r9
+;;       movl    (%r9, %rdx), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   5e: ud2
+;;   60: cld
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..a35dbc72b039
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       cmpq    0x1d(%rip), %rdx
+;;       ja      0x22
+;;   11: movq    0x60(%rdi), %r9
+;;       movl    %ecx, 0x1000(%r9, %rdx)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   22: ud2
+;;   24: addb    %al, (%rax)
+;;   26: addb    %al, (%rax)
+;;   28: cld
+;;   29: outl    %eax, %dx
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       cmpq    0x1d(%rip), %rdx
+;;       ja      0x62
+;;   51: movq    0x60(%rdi), %r9
+;;       movl    0x1000(%r9, %rdx), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   62: ud2
+;;   64: addb    %al, (%rax)
+;;   66: addb    %al, (%rax)
+;;   68: cld
+;;   69: outl    %eax, %dx
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..a08a798c3bc4
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       cmpq    $0xfffc, %rdx
+;;       ja      0x24
+;;   11: addq    0x60(%rdi), %rdx
+;;       movl    $0xffff0000, %r10d
+;;       movl    %ecx, (%rdx, %r10)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   24: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       cmpq    $0xfffc, %rdx
+;;       ja      0x64
+;;   51: addq    0x60(%rdi), %rdx
+;;       movl    $0xffff0000, %r10d
+;;       movl    (%rdx, %r10), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   64: ud2
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..a6edea0e59d1
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0_offset.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       cmpq    0x15(%rip), %rdx
+;;       ja      0x1e
+;;   11: movq    0x60(%rdi), %r9
+;;       movb    %cl, (%r9, %rdx)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   1e: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       cmpq    0x1d(%rip), %rdx
+;;       ja      0x5f
+;;   51: movq    0x60(%rdi), %r9
+;;       movzbq  (%r9, %rdx), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   5f: ud2
+;;   61: addb    %al, (%rax)
+;;   63: addb    %al, (%rax)
+;;   65: addb    %al, (%rax)
+;;   67: addb    %bh, %bh
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..ab3509ac1b74
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,48 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       cmpq    0x1d(%rip), %rdx
+;;       ja      0x22
+;;   11: movq    0x60(%rdi), %r9
+;;       movb    %cl, 0x1000(%r9, %rdx)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   22: ud2
+;;   24: addb    %al, (%rax)
+;;   26: addb    %al, (%rax)
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       cmpq    0x1d(%rip), %rdx
+;;       ja      0x63
+;;   51: movq    0x60(%rdi), %r9
+;;       movzbq  0x1000(%r9, %rdx), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   63: ud2
+;;   65: addb    %al, (%rax)
+;;   67: addb    %bh, %bh
+;;   69: outl    %eax, %dx
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..713c662f50ad
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_no_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation=false -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       cmpq    $0xffff, %rdx
+;;       ja      0x24
+;;   11: addq    0x60(%rdi), %rdx
+;;       movl    $0xffff0000, %r10d
+;;       movb    %cl, (%rdx, %r10)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   24: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       cmpq    $0xffff, %rdx
+;;       ja      0x65
+;;   51: addq    0x60(%rdi), %rdx
+;;       movl    $0xffff0000, %r10d
+;;       movzbq  (%rdx, %r10), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   65: ud2
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
new file mode 100644
index 000000000000..27c0b2585867
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0_offset.wat
@@ -0,0 +1,53 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       xorq    %r9, %r9
+;;       movq    %rdx, %r8
+;;       addq    0x60(%rdi), %r8
+;;       cmpq    0x13(%rip), %rdx
+;;       cmovaq  %r9, %r8
+;;       movl    %ecx, (%r8)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   21: addb    %al, (%rax)
+;;   23: addb    %al, (%rax)
+;;   25: addb    %al, (%rax)
+;;   27: addb    %bh, %ah
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       xorq    %r9, %r9
+;;       movq    %rdx, %r8
+;;       addq    0x60(%rdi), %r8
+;;       cmpq    0x13(%rip), %rdx
+;;       cmovaq  %r9, %r8
+;;       movl    (%r8), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   61: addb    %al, (%rax)
+;;   63: addb    %al, (%rax)
+;;   65: addb    %al, (%rax)
+;;   67: addb    %bh, %ah
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
new file mode 100644
index 000000000000..e9ce3d55890d
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0x1000_offset.wat
@@ -0,0 +1,51 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       xorq    %r10, %r10
+;;       movq    0x60(%rdi), %r11
+;;       leaq    0x1000(%r11, %rdx), %r9
+;;       cmpq    0xe(%rip), %rdx
+;;       cmovaq  %r10, %r9
+;;       movl    %ecx, (%r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   26: addb    %al, (%rax)
+;;   28: cld
+;;   29: outl    %eax, %dx
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       xorq    %r10, %r10
+;;       movq    0x60(%rdi), %r11
+;;       leaq    0x1000(%r11, %rdx), %r9
+;;       cmpq    0xe(%rip), %rdx
+;;       cmovaq  %r10, %r9
+;;       movl    (%r9), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   66: addb    %al, (%rax)
+;;   68: cld
+;;   69: outl    %eax, %dx
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..c94d42088bfb
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i32_access_0xffff0000_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       xorq    %r11, %r11
+;;       movq    %rdx, %rsi
+;;       addq    0x60(%rdi), %rsi
+;;       movl    $0xffff0000, %edi
+;;       leaq    (%rsi, %rdi), %r10
+;;       cmpq    $0xfffc, %rdx
+;;       cmovaq  %r11, %r10
+;;       movl    %ecx, (%r10)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       xorq    %r11, %r11
+;;       movq    %rdx, %rsi
+;;       addq    0x60(%rdi), %rsi
+;;       movl    $0xffff0000, %edi
+;;       leaq    (%rsi, %rdi), %r10
+;;       cmpq    $0xfffc, %rdx
+;;       cmovaq  %r11, %r10
+;;       movl    (%r10), %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
new file mode 100644
index 000000000000..a886cda8c1ac
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0_offset.wat
@@ -0,0 +1,52 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       xorq    %r9, %r9
+;;       movq    %rdx, %r8
+;;       addq    0x60(%rdi), %r8
+;;       cmpq    0x13(%rip), %rdx
+;;       cmovaq  %r9, %r8
+;;       movb    %cl, (%r8)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   21: addb    %al, (%rax)
+;;   23: addb    %al, (%rax)
+;;   25: addb    %al, (%rax)
+;;   27: addb    %bh, %bh
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       xorq    %r9, %r9
+;;       movq    %rdx, %r8
+;;       addq    0x60(%rdi), %r8
+;;       cmpq    0x13(%rip), %rdx
+;;       cmovaq  %r9, %r8
+;;       movzbq  (%r8), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   62: addb    %al, (%rax)
+;;   64: addb    %al, (%rax)
+;;   66: addb    %al, (%rax)
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
new file mode 100644
index 000000000000..3075aa877a9f
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0x1000_offset.wat
@@ -0,0 +1,48 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0x1000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0x1000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       xorq    %r10, %r10
+;;       movq    0x60(%rdi), %r11
+;;       leaq    0x1000(%r11, %rdx), %r9
+;;       cmpq    0xe(%rip), %rdx
+;;       cmovaq  %r10, %r9
+;;       movb    %cl, (%r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   26: addb    %al, (%rax)
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       xorq    %r10, %r10
+;;       movq    0x60(%rdi), %r11
+;;       leaq    0x1000(%r11, %rdx), %r9
+;;       cmpq    0xe(%rip), %rdx
+;;       cmovaq  %r10, %r9
+;;       movzbq  (%r9), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   67: addb    %bh, %bh
+;;   69: outl    %eax, %dx
diff --git a/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
new file mode 100644
index 000000000000..344514b0980b
--- /dev/null
+++ b/tests/disas/load-store/x64/load_store_static_kind_i64_index_0xffffffff_guard_yes_spectre_i8_access_0xffff0000_offset.wat
@@ -0,0 +1,49 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = " -C cranelift-enable-heap-access-spectre-mitigation -W memory64 -O static-memory-forced -O static-memory-guard-size=4294967295 -O dynamic-memory-guard-size=4294967295"
+
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+;; !!! GENERATED BY 'make-load-store-tests.sh' DO NOT EDIT !!!
+;; !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+(module
+  (memory i64 1)
+
+  (func (export "do_store") (param i64 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0xffff0000)
+
+  (func (export "do_load") (param i64) (result i32)
+    local.get 0
+    i32.load8_u offset=0xffff0000))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       xorq    %r11, %r11
+;;       movq    %rdx, %rsi
+;;       addq    0x60(%rdi), %rsi
+;;       movl    $0xffff0000, %edi
+;;       leaq    (%rsi, %rdi), %r10
+;;       cmpq    $0xffff, %rdx
+;;       cmovaq  %r11, %r10
+;;       movb    %cl, (%r10)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       xorq    %r11, %r11
+;;       movq    %rdx, %rsi
+;;       addq    0x60(%rdi), %rsi
+;;       movl    $0xffff0000, %edi
+;;       leaq    (%rsi, %rdi), %r10
+;;       cmpq    $0xffff, %rdx
+;;       cmovaq  %r11, %r10
+;;       movzbq  (%r10), %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/memory.wat b/tests/disas/memory.wat
new file mode 100644
index 000000000000..e3126929145f
--- /dev/null
+++ b/tests/disas/memory.wat
@@ -0,0 +1,61 @@
+;;! target = "x86_64"
+
+(module
+  (memory 1)
+  (func $main (local i32)
+    (i32.store (i32.const 0) (i32.const 0x0))
+    (if (i32.load (i32.const 0))
+        (then (i32.store (i32.const 0) (i32.const 0xa)))
+        (else (i32.store (i32.const 0) (i32.const 0xb))))
+  )
+  (start $main)
+  (data (i32.const 0) "0000")
+)
+
+;; function u0:0(i64 vmctx, i64) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @001f                               v2 = iconst.i32 0
+;; @0021                               v3 = iconst.i32 0
+;; @0023                               v4 = iconst.i32 0
+;; @0025                               v5 = uextend.i64 v3  ; v3 = 0
+;; @0025                               v6 = global_value.i64 gv4
+;; @0025                               v7 = iadd v6, v5
+;; @0025                               store little heap v4, v7  ; v4 = 0
+;; @0028                               v8 = iconst.i32 0
+;; @002a                               v9 = uextend.i64 v8  ; v8 = 0
+;; @002a                               v10 = global_value.i64 gv4
+;; @002a                               v11 = iadd v10, v9
+;; @002a                               v12 = load.i32 little heap v11
+;; @002d                               brif v12, block2, block4
+;;
+;;                                 block2:
+;; @002f                               v13 = iconst.i32 0
+;; @0031                               v14 = iconst.i32 10
+;; @0033                               v15 = uextend.i64 v13  ; v13 = 0
+;; @0033                               v16 = global_value.i64 gv4
+;; @0033                               v17 = iadd v16, v15
+;; @0033                               store little heap v14, v17  ; v14 = 10
+;; @0036                               jump block3
+;;
+;;                                 block4:
+;; @0037                               v18 = iconst.i32 0
+;; @0039                               v19 = iconst.i32 11
+;; @003b                               v20 = uextend.i64 v18  ; v18 = 0
+;; @003b                               v21 = global_value.i64 gv4
+;; @003b                               v22 = iadd v21, v20
+;; @003b                               store little heap v19, v22  ; v19 = 11
+;; @003e                               jump block3
+;;
+;;                                 block3:
+;; @003f                               jump block1
+;;
+;;                                 block1:
+;; @003f                               return
+;; }
diff --git a/tests/disas/multi-0.wat b/tests/disas/multi-0.wat
new file mode 100644
index 000000000000..3376be1886e3
--- /dev/null
+++ b/tests/disas/multi-0.wat
@@ -0,0 +1,18 @@
+;;! target = "x86_64"
+
+(module
+  (func (export "i64.dup") (param i64) (result i64 i64)
+    (local.get 0) (local.get 0)))
+
+;; function u0:0(i64 vmctx, i64, i64) -> i64, i64 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @002b                               jump block1(v2, v2)
+;;
+;;                                 block1(v3: i64, v4: i64):
+;; @002b                               return v3, v4
+;; }
diff --git a/tests/disas/multi-1.wat b/tests/disas/multi-1.wat
new file mode 100644
index 000000000000..7fc7a96411b9
--- /dev/null
+++ b/tests/disas/multi-1.wat
@@ -0,0 +1,25 @@
+;;! target = "x86_64"
+
+(module
+  (func (export "multiBlock") (param i64 i32) (result i32 i64 f64)
+    (local.get 1)
+    (local.get 0)
+    (block (param i32 i64) (result i32 i64 f64)
+      (f64.const 1234.5))))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) -> i32, i64, f64 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @003a                               v10 = f64const 0x1.34a0000000000p10
+;; @0043                               jump block2(v3, v2, v10)  ; v10 = 0x1.34a0000000000p10
+;;
+;;                                 block2(v7: i32, v8: i64, v9: f64):
+;; @0044                               jump block1(v7, v8, v9)
+;;
+;;                                 block1(v4: i32, v5: i64, v6: f64):
+;; @0044                               return v4, v5, v6
+;; }
diff --git a/tests/disas/multi-10.wat b/tests/disas/multi-10.wat
new file mode 100644
index 000000000000..eca150ddc50f
--- /dev/null
+++ b/tests/disas/multi-10.wat
@@ -0,0 +1,36 @@
+;;! target = "x86_64"
+
+(module
+  (func (export "f") (param i64 i32) (result i64 i64)
+    (local.get 0)
+    (local.get 1)
+    ;; If with else. Fewer params than results.
+    (if (param i64) (result i64 i64)
+      (then
+        (i64.const -1))
+      (else
+        (i64.const -2)))))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) -> i64, i64 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @002c                               brif v3, block2, block4(v2)
+;;
+;;                                 block2:
+;; @002e                               v9 = iconst.i64 -1
+;; @0030                               jump block3(v2, v9)  ; v9 = -1
+;;
+;;                                 block4(v8: i64):
+;; @0031                               v10 = iconst.i64 -2
+;; @0033                               jump block3(v2, v10)  ; v10 = -2
+;;
+;;                                 block3(v6: i64, v7: i64):
+;; @0034                               jump block1(v6, v7)
+;;
+;;                                 block1(v4: i64, v5: i64):
+;; @0034                               return v4, v5
+;; }
diff --git a/tests/disas/multi-11.wat b/tests/disas/multi-11.wat
new file mode 100644
index 000000000000..053e745d27b0
--- /dev/null
+++ b/tests/disas/multi-11.wat
@@ -0,0 +1,23 @@
+;;! target = "x86_64"
+
+(module
+  (func (export "multiLoop") (param i64) (result i64 i64)
+    (local.get 0)
+    ;; Fewer params than results.
+    (loop (param i64) (result i64 i64)
+      i64.const 42
+      return)))
+
+;; function u0:0(i64 vmctx, i64, i64) -> i64, i64 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64):
+;; @002b                               jump block2(v2)
+;;
+;;                                 block2(v5: i64):
+;; @002d                               v8 = iconst.i64 42
+;; @002f                               return v5, v8  ; v8 = 42
+;; }
diff --git a/tests/disas/multi-12.wat b/tests/disas/multi-12.wat
new file mode 100644
index 000000000000..f0cf66d68ecf
--- /dev/null
+++ b/tests/disas/multi-12.wat
@@ -0,0 +1,24 @@
+;;! target = "x86_64"
+
+(module
+  (func (export "multiLoop") (param i64 i64 i64) (result i64 i64)
+    (local.get 2)
+    (local.get 1)
+    (local.get 0)
+    ;; More params than results.
+    (loop (param i64 i64 i64) (result i64 i64)
+      drop
+      return)))
+
+;; function u0:0(i64 vmctx, i64, i64, i64, i64) -> i64, i64 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i64, v4: i64):
+;; @0031                               jump block2(v4, v3, v2)
+;;
+;;                                 block2(v7: i64, v8: i64, v9: i64):
+;; @0034                               return v7, v8
+;; }
diff --git a/tests/disas/multi-13.wat b/tests/disas/multi-13.wat
new file mode 100644
index 000000000000..35755f77d8f6
--- /dev/null
+++ b/tests/disas/multi-13.wat
@@ -0,0 +1,38 @@
+;;! target = "x86_64"
+
+(module
+  (func (export "as-if-then") (param i32 i32) (result i32)
+    (block (result i32)
+      (if (result i32) (local.get 0)
+        (then (br 1 (i32.const 3)))
+        (else (local.get 1))
+      )
+    )
+  )
+)
+
+;; function u0:0(i64 vmctx, i64, i32, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @002e                               brif v2, block3, block5
+;;
+;;                                 block3:
+;; @0030                               v7 = iconst.i32 3
+;; @0032                               jump block2(v7)  ; v7 = 3
+;;
+;;                                 block5:
+;; @0037                               jump block4(v3)
+;;
+;;                                 block4(v6: i32):
+;; @0038                               jump block2(v6)
+;;
+;;                                 block2(v5: i32):
+;; @0039                               jump block1(v5)
+;;
+;;                                 block1(v4: i32):
+;; @0039                               return v4
+;; }
diff --git a/tests/disas/multi-14.wat b/tests/disas/multi-14.wat
new file mode 100644
index 000000000000..0de1f71e81d5
--- /dev/null
+++ b/tests/disas/multi-14.wat
@@ -0,0 +1,38 @@
+;;! target = "x86_64"
+
+(module
+  (func (export "as-if-else") (param i32 i32) (result i32)
+    (block (result i32)
+      (if (result i32) (local.get 0)
+        (then (local.get 1))
+        (else (br 1 (i32.const 4)))
+      )
+    )
+  )
+)
+
+;; function u0:0(i64 vmctx, i64, i32, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @002e                               brif v2, block3, block5
+;;
+;;                                 block3:
+;; @0032                               jump block4(v3)
+;;
+;;                                 block5:
+;; @0033                               v7 = iconst.i32 4
+;; @0035                               jump block2(v7)  ; v7 = 4
+;;
+;;                                 block4(v6: i32):
+;; @0038                               jump block2(v6)
+;;
+;;                                 block2(v5: i32):
+;; @0039                               jump block1(v5)
+;;
+;;                                 block1(v4: i32):
+;; @0039                               return v4
+;; }
diff --git a/tests/disas/multi-15.wat b/tests/disas/multi-15.wat
new file mode 100644
index 000000000000..760121683584
--- /dev/null
+++ b/tests/disas/multi-15.wat
@@ -0,0 +1,37 @@
+;;! target = "x86_64"
+
+(module
+  (func (export "large-sig")
+    (param i32 i64 f32 f32 i32 f64 f32 i32 i32 i32 f32 f64 f64 f64 i32 i32 f32)
+    (result f64 f32 i32 i32 i32 i64 f32 i32 i32 f32 f64 f64 i32 f32 i32 f64)
+    (local.get 5)
+    (local.get 2)
+    (local.get 0)
+    (local.get 8)
+    (local.get 7)
+    (local.get 1)
+    (local.get 3)
+    (local.get 9)
+    (local.get 4)
+    (local.get 6)
+    (local.get 13)
+    (local.get 11)
+    (local.get 15)
+    (local.get 16)
+    (local.get 14)
+    (local.get 12)
+  )
+)
+
+;; function u0:0(i64 vmctx, i64, i32, i64, f32, f32, i32, f64, f32, i32, i32, i32, f32, f64, f64, f64, i32, i32, f32) -> f64, f32, i32, i32, i32, i64, f32, i32, i32, f32, f64, f64, i32, f32, i32, f64 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i64, v4: f32, v5: f32, v6: i32, v7: f64, v8: f32, v9: i32, v10: i32, v11: i32, v12: f32, v13: f64, v14: f64, v15: f64, v16: i32, v17: i32, v18: f32):
+;; @0067                               jump block1(v7, v4, v2, v10, v9, v3, v5, v11, v6, v8, v15, v13, v17, v18, v16, v14)
+;;
+;;                                 block1(v19: f64, v20: f32, v21: i32, v22: i32, v23: i32, v24: i64, v25: f32, v26: i32, v27: i32, v28: f32, v29: f64, v30: f64, v31: i32, v32: f32, v33: i32, v34: f64):
+;; @0067                               return v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34
+;; }
diff --git a/tests/disas/multi-16.wat b/tests/disas/multi-16.wat
new file mode 100644
index 000000000000..a18bf3f4a8fb
--- /dev/null
+++ b/tests/disas/multi-16.wat
@@ -0,0 +1,38 @@
+;;! target = "x86_64"
+
+(module
+  (func (export "param") (param i32) (result i32)
+    (i32.const 1)
+    (if (param i32) (result i32) (local.get 0)
+      (then (i32.const 2) (i32.add))
+      (else (i32.const -2) (i32.add))
+    )
+  )
+)
+
+;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0024                               v4 = iconst.i32 1
+;; @0028                               brif v2, block2, block4(v4)  ; v4 = 1
+;;
+;;                                 block2:
+;; @002a                               v6 = iconst.i32 2
+;; @002c                               v7 = iadd.i32 v4, v6  ; v4 = 1, v6 = 2
+;; @002d                               jump block3(v7)
+;;
+;;                                 block4(v8: i32):
+;; @002e                               v9 = iconst.i32 -2
+;; @0030                               v10 = iadd.i32 v4, v9  ; v4 = 1, v9 = -2
+;; @0031                               jump block3(v10)
+;;
+;;                                 block3(v5: i32):
+;; @0032                               jump block1(v5)
+;;
+;;                                 block1(v3: i32):
+;; @0032                               return v3
+;; }
diff --git a/tests/disas/multi-17.wat b/tests/disas/multi-17.wat
new file mode 100644
index 000000000000..9613d5fae832
--- /dev/null
+++ b/tests/disas/multi-17.wat
@@ -0,0 +1,69 @@
+;;! target = "x86_64"
+
+(module
+  (func $main (type 0) (param i32 i32 i32) (result i32)
+    i32.const 0
+    i32.const 0
+    i32.const 0
+    i32.const 0
+
+    i32.const 0
+    if (param i32 i32 i32) (result i32)  ;; label = @1
+      br 0 (;@1;)
+    else
+      call $main
+    end
+
+    i32.const 0
+
+    i32.const 0
+    if (param i32 i32 i32) (result i32)  ;; label = @1
+      drop
+      drop
+    else
+      drop
+      drop
+    end
+  )
+  (export "main" (func $main)))
+
+;; function u0:0(i64 vmctx, i64, i32, i32, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     sig0 = (i64 vmctx, i64, i32, i32, i32) -> i32 tail
+;;     fn0 = colocated u0:0 sig0
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32):
+;; @0025                               v6 = iconst.i32 0
+;; @0027                               v7 = iconst.i32 0
+;; @0029                               v8 = iconst.i32 0
+;; @002b                               v9 = iconst.i32 0
+;; @002d                               v10 = iconst.i32 0
+;; @002f                               brif v10, block2, block4(v7, v8, v9)  ; v10 = 0, v7 = 0, v8 = 0, v9 = 0
+;;
+;;                                 block2:
+;; @0031                               jump block3(v9)  ; v9 = 0
+;;
+;;                                 block4(v12: i32, v13: i32, v14: i32):
+;; @0034                               v15 = call fn0(v0, v0, v7, v8, v9)  ; v7 = 0, v8 = 0, v9 = 0
+;; @0036                               jump block3(v15)
+;;
+;;                                 block3(v11: i32):
+;; @0037                               v16 = iconst.i32 0
+;; @0039                               v17 = iconst.i32 0
+;; @003b                               brif v17, block5, block7(v6, v11, v16)  ; v17 = 0, v6 = 0, v16 = 0
+;;
+;;                                 block5:
+;; @003f                               jump block6(v6)  ; v6 = 0
+;;
+;;                                 block7(v19: i32, v20: i32, v21: i32):
+;; @0042                               jump block6(v6)  ; v6 = 0
+;;
+;;                                 block6(v18: i32):
+;; @0043                               jump block1(v18)
+;;
+;;                                 block1(v5: i32):
+;; @0043                               return v5
+;; }
diff --git a/tests/disas/multi-2.wat b/tests/disas/multi-2.wat
new file mode 100644
index 000000000000..085cfdabb686
--- /dev/null
+++ b/tests/disas/multi-2.wat
@@ -0,0 +1,21 @@
+;;! target = "x86_64"
+
+(module
+  (func (export "multiLoop") (param i64 i64) (result i64 i64)
+    (local.get 1)
+    (local.get 0)
+    (loop (param i64 i64) (result i64 i64)
+       return)))
+
+;; function u0:0(i64 vmctx, i64, i64, i64) -> i64, i64 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i64):
+;; @002e                               jump block2(v3, v2)
+;;
+;;                                 block2(v6: i64, v7: i64):
+;; @0030                               return v6, v7
+;; }
diff --git a/tests/disas/multi-3.wat b/tests/disas/multi-3.wat
new file mode 100644
index 000000000000..8db7aea0b61f
--- /dev/null
+++ b/tests/disas/multi-3.wat
@@ -0,0 +1,39 @@
+;;! target = "x86_64"
+
+(module
+  (func (export "multiIf") (param i32 i64 i64) (result i64 i64)
+    (local.get 2)
+    (local.get 1)
+    (local.get 0)
+    (if (param i64 i64) (result i64 i64)
+      (then return)
+      ;; Hits the code path for an `else` after a block that ends unreachable.
+      (else
+        (drop)
+        (drop)
+        (i64.const 0)
+        (i64.const 0)))))
+
+;; function u0:0(i64 vmctx, i64, i32, i64, i64) -> i64, i64 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i64, v4: i64):
+;; @0036                               brif v2, block2, block4(v4, v3)
+;;
+;;                                 block2:
+;; @0038                               return v4, v3
+;;
+;;                                 block4(v9: i64, v10: i64):
+;; @003c                               v11 = iconst.i64 0
+;; @003e                               v12 = iconst.i64 0
+;; @0040                               jump block3(v11, v12)  ; v11 = 0, v12 = 0
+;;
+;;                                 block3(v7: i64, v8: i64):
+;; @0041                               jump block1(v7, v8)
+;;
+;;                                 block1(v5: i64, v6: i64):
+;; @0041                               return v5, v6
+;; }
diff --git a/tests/disas/multi-4.wat b/tests/disas/multi-4.wat
new file mode 100644
index 000000000000..1cb514b85ff7
--- /dev/null
+++ b/tests/disas/multi-4.wat
@@ -0,0 +1,41 @@
+;;! target = "x86_64"
+
+(module
+  (func (export "multiIf2") (param i32 i64 i64) (result i64 i64)
+    (local.get 2)
+    (local.get 1)
+    (local.get 0)
+    (if (param i64 i64) (result i64 i64)
+      (then
+        i64.add
+        i64.const 1)
+      ;; Hits the code path for an `else` after a block that does not end unreachable.
+      (else
+        i64.sub
+        i64.const 2))))
+
+;; function u0:0(i64 vmctx, i64, i32, i64, i64) -> i64, i64 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i64, v4: i64):
+;; @0037                               brif v2, block2, block4(v4, v3)
+;;
+;;                                 block2:
+;; @0039                               v9 = iadd.i64 v4, v3
+;; @003a                               v10 = iconst.i64 1
+;; @003c                               jump block3(v9, v10)  ; v10 = 1
+;;
+;;                                 block4(v11: i64, v12: i64):
+;; @003d                               v13 = isub.i64 v4, v3
+;; @003e                               v14 = iconst.i64 2
+;; @0040                               jump block3(v13, v14)  ; v14 = 2
+;;
+;;                                 block3(v7: i64, v8: i64):
+;; @0041                               jump block1(v7, v8)
+;;
+;;                                 block1(v5: i64, v6: i64):
+;; @0041                               return v5, v6
+;; }
diff --git a/tests/disas/multi-5.wat b/tests/disas/multi-5.wat
new file mode 100644
index 000000000000..0c4e99ad2567
--- /dev/null
+++ b/tests/disas/multi-5.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+
+(module
+  (func (export "foo")
+    i32.const 1
+    i64.const 2
+    ;; More params than results.
+    (block (param i32 i64) (result i32)
+      drop
+    )
+    drop
+  )
+)
+
+;; function u0:0(i64 vmctx, i64) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @0026                               v2 = iconst.i32 1
+;; @0028                               v3 = iconst.i64 2
+;; @002d                               jump block2(v2)  ; v2 = 1
+;;
+;;                                 block2(v4: i32):
+;; @002f                               jump block1
+;;
+;;                                 block1:
+;; @002f                               return
+;; }
diff --git a/tests/disas/multi-6.wat b/tests/disas/multi-6.wat
new file mode 100644
index 000000000000..573fbea893cb
--- /dev/null
+++ b/tests/disas/multi-6.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+
+(module
+  (func (export "foo")
+    i32.const 1
+    ;; Fewer params than results.
+    (block (param i32) (result i32 i64)
+      i64.const 2
+    )
+    drop
+    drop
+  )
+)
+
+;; function u0:0(i64 vmctx, i64) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @0026                               v2 = iconst.i32 1
+;; @002a                               v5 = iconst.i64 2
+;; @002c                               jump block2(v2, v5)  ; v2 = 1, v5 = 2
+;;
+;;                                 block2(v3: i32, v4: i64):
+;; @002f                               jump block1
+;;
+;;                                 block1:
+;; @002f                               return
+;; }
diff --git a/tests/disas/multi-7.wat b/tests/disas/multi-7.wat
new file mode 100644
index 000000000000..a4f591c330a1
--- /dev/null
+++ b/tests/disas/multi-7.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+
+(module
+  (func (export "f") (param i64 i32) (result i64)
+    (local.get 0)
+    (local.get 1)
+    ;; If with no else. Same number of params and results.
+    (if (param i64) (result i64)
+      (then
+        (drop)
+        (i64.const -1)))))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) -> i64 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @002a                               brif v3, block2, block3(v2)
+;;
+;;                                 block2:
+;; @002d                               v6 = iconst.i64 -1
+;; @002f                               jump block3(v6)  ; v6 = -1
+;;
+;;                                 block3(v5: i64):
+;; @0030                               jump block1(v5)
+;;
+;;                                 block1(v4: i64):
+;; @0030                               return v4
+;; }
diff --git a/tests/disas/multi-8.wat b/tests/disas/multi-8.wat
new file mode 100644
index 000000000000..d20d71e26ec8
--- /dev/null
+++ b/tests/disas/multi-8.wat
@@ -0,0 +1,38 @@
+;;! target = "x86_64"
+
+(module
+  (func (export "f") (param i64 i32) (result i64)
+    (local.get 0)
+    (local.get 1)
+    ;; If with else. Same number of params and results.
+    (if (param i64) (result i64)
+      (then
+        (drop)
+        (i64.const -1))
+      (else
+        (drop)
+        (i64.const -2)))))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) -> i64 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @002a                               brif v3, block2, block4(v2)
+;;
+;;                                 block2:
+;; @002d                               v6 = iconst.i64 -1
+;; @002f                               jump block3(v6)  ; v6 = -1
+;;
+;;                                 block4(v7: i64):
+;; @0031                               v8 = iconst.i64 -2
+;; @0033                               jump block3(v8)  ; v8 = -2
+;;
+;;                                 block3(v5: i64):
+;; @0034                               jump block1(v5)
+;;
+;;                                 block1(v4: i64):
+;; @0034                               return v4
+;; }
diff --git a/tests/disas/multi-9.wat b/tests/disas/multi-9.wat
new file mode 100644
index 000000000000..1ac0593af685
--- /dev/null
+++ b/tests/disas/multi-9.wat
@@ -0,0 +1,41 @@
+;;! target = "x86_64"
+
+(module
+  (func (export "f") (param i64 i32) (result i64)
+    (local.get 0)
+    (local.get 1)
+    (local.get 1)
+    ;; If with else. More params than results.
+    (if (param i64 i32) (result i64)
+      (then
+        (drop)
+        (drop)
+        (i64.const -1))
+      (else
+        (drop)
+        (drop)
+        (i64.const -2)))))
+
+;; function u0:0(i64 vmctx, i64, i64, i32) -> i64 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i64, v3: i32):
+;; @0027                               brif v3, block2, block4(v2, v3)
+;;
+;;                                 block2:
+;; @002b                               v8 = iconst.i64 -1
+;; @002d                               jump block3(v8)  ; v8 = -1
+;;
+;;                                 block4(v6: i64, v7: i32):
+;; @0030                               v9 = iconst.i64 -2
+;; @0032                               jump block3(v9)  ; v9 = -2
+;;
+;;                                 block3(v5: i64):
+;; @0033                               jump block1(v5)
+;;
+;;                                 block1(v4: i64):
+;; @0033                               return v4
+;; }
diff --git a/tests/disas/non-fixed-size-memory.wat b/tests/disas/non-fixed-size-memory.wat
new file mode 100644
index 000000000000..9df90fe3b851
--- /dev/null
+++ b/tests/disas/non-fixed-size-memory.wat
@@ -0,0 +1,67 @@
+;;! target = "x86_64"
+;;! flags = [
+;;!   "-Ccranelift-enable-heap-access-spectre-mitigation=false",
+;;!   "-Ostatic-memory-maximum-size=0",
+;;!   "-Odynamic-memory-guard-size=0",
+;;! ]
+
+;; Dual test to `fixed-size-memory.wat` that checks that we _don't_ use a
+;; constant for the heap bound when `min_size != max_size`.
+
+(module
+  (memory 1 2)
+
+  (func (export "do_store") (param i32 i32)
+    local.get 0
+    local.get 1
+    i32.store8 offset=0)
+
+  (func (export "do_load") (param i32) (result i32)
+    local.get 0
+    i32.load8_u offset=0))
+
+;; function u0:0(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @0041                               v4 = uextend.i64 v2
+;; @0041                               v5 = global_value.i64 gv4
+;; @0041                               v6 = icmp uge v4, v5
+;; @0041                               trapnz v6, heap_oob
+;; @0041                               v7 = global_value.i64 gv5
+;; @0041                               v8 = iadd v7, v4
+;; @0041                               istore8 little heap v3, v8
+;; @0044                               jump block1
+;;
+;;                                 block1:
+;; @0044                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+104
+;;     gv5 = load.i64 notrap aligned checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0049                               v4 = uextend.i64 v2
+;; @0049                               v5 = global_value.i64 gv4
+;; @0049                               v6 = icmp uge v4, v5
+;; @0049                               trapnz v6, heap_oob
+;; @0049                               v7 = global_value.i64 gv5
+;; @0049                               v8 = iadd v7, v4
+;; @0049                               v9 = uload8.i32 little heap v8
+;; @004c                               jump block1(v9)
+;;
+;;                                 block1(v3: i32):
+;; @004c                               return v3
+;; }
diff --git a/tests/disas/nullref.wat b/tests/disas/nullref.wat
new file mode 100644
index 000000000000..b298809d8745
--- /dev/null
+++ b/tests/disas/nullref.wat
@@ -0,0 +1,44 @@
+;;! target = "x86_64"
+
+(module
+	(func (result externref)
+		(ref.null extern)
+	)
+
+	(func (result externref)
+		(block (result externref)
+			(ref.null extern)
+		)
+	)
+)
+
+;; function u0:0(i64 vmctx, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @0019                               v3 = iconst.i32 0
+;; @001b                               jump block1(v3)  ; v3 = 0
+;;
+;;                                 block1(v2: i32):
+;; @001b                               return v2
+;; }
+;;
+;; function u0:1(i64 vmctx, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @0020                               v4 = iconst.i32 0
+;; @0022                               jump block2(v4)  ; v4 = 0
+;;
+;;                                 block2(v3: i32):
+;; @0023                               jump block1(v3)
+;;
+;;                                 block1(v2: i32):
+;; @0023                               return v2
+;; }
diff --git a/tests/disas/passive-data.wat b/tests/disas/passive-data.wat
new file mode 100644
index 000000000000..70ea0489ef5b
--- /dev/null
+++ b/tests/disas/passive-data.wat
@@ -0,0 +1,55 @@
+;;! target = "x86_64"
+
+(module
+  (data $passive "this is a passive data segment")
+  (memory 0)
+
+  (func (export "init") (param i32 i32 i32)
+    local.get 0 ;; dst
+    local.get 1 ;; src
+    local.get 2 ;; cnt
+    memory.init $passive)
+
+  (func (export "drop")
+    data.drop $passive))
+
+;; function u0:0(i64 vmctx, i64, i32, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     sig0 = (i64 vmctx, i32 uext, i32 uext, i64, i32 uext, i32 uext) system_v
+;;     fn0 = colocated u1:6 sig0
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32):
+;; @003d                               v5 = iconst.i32 0
+;; @003d                               v6 = iconst.i32 0
+;; @003d                               v7 = global_value.i64 gv3
+;; @003d                               v8 = uextend.i64 v2
+;; @003d                               call fn0(v7, v5, v6, v8, v3, v4)  ; v5 = 0, v6 = 0
+;; @0041                               jump block1
+;;
+;;                                 block1:
+;; @0041                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     sig0 = (i64 vmctx, i32 uext) system_v
+;;     fn0 = colocated u1:8 sig0
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @0044                               v2 = iconst.i32 0
+;; @0044                               v3 = global_value.i64 gv3
+;; @0044                               call fn0(v3, v2)  ; v2 = 0
+;; @0047                               jump block1
+;;
+;;                                 block1:
+;; @0047                               return
+;; }
diff --git a/tests/disas/pcc-imported-memory.wat b/tests/disas/pcc-imported-memory.wat
new file mode 100644
index 000000000000..616cb5bc3e26
--- /dev/null
+++ b/tests/disas/pcc-imported-memory.wat
@@ -0,0 +1,58 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = [ "-Oopt-level=2", "-Cpcc=y" ]
+
+(module
+  (type (;0;) (func))
+  (import "" "" (memory (;0;) 1))
+  (func (;0;) (type 0)
+    (local i32 i32)
+    memory.size
+    local.set 0
+    block  ;; label = @1
+      block  ;; label = @2
+        memory.size
+        i32.const 65536
+        i32.mul
+        i32.const 4
+        local.get 0
+        i32.add
+        i32.le_u
+        br_if 0 (;@2;)
+        local.get 0
+        i32.const 0
+        i32.le_s
+        br_if 0 (;@2;)
+        local.get 0
+        i32.load align=1
+        local.set 1
+        br 1 (;@1;)
+      end
+      i32.const 0
+      local.set 1
+    end
+    local.get 1
+    drop))
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x58(%rdi), %rcx
+;;       movq    8(%rcx), %rax
+;;       shrq    $0x10, %rax
+;;       movq    %rax, %rcx
+;;       shll    $0x10, %ecx
+;;       leal    4(%rax), %edx
+;;       cmpl    %edx, %ecx
+;;       jbe     0x3b
+;;   21: testl   %eax, %eax
+;;       jle     0x3b
+;;   29: movq    0x58(%rdi), %rsi
+;;       movq    (%rsi), %rsi
+;;       movl    %eax, %edi
+;;       movl    (%rsi, %rdi), %r10d
+;;       jmp     0x3e
+;;   3b: xorl    %r10d, %r10d
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/pcc-insertlane-x64-avx.wat b/tests/disas/pcc-insertlane-x64-avx.wat
new file mode 100644
index 000000000000..7361cb01d32b
--- /dev/null
+++ b/tests/disas/pcc-insertlane-x64-avx.wat
@@ -0,0 +1,223 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = [ "-Oopt-level=0", "-Cpcc=y", "-Ccranelift-has-sse41=true", "-Ccranelift-has-avx=true" ]
+
+(module
+  (memory 1 1)
+  (func (param i32) (result v128)
+      local.get 0
+      v128.const i32x4 0x29292928 0x206e6928 0x616d286d 0x206f7263
+      v128.load8_lane align=1 1)
+  (func (param i32) (result v128)
+      local.get 0
+      v128.const i32x4 0x29292928 0x206e6928 0x616d286d 0x206f7263
+      v128.load16_lane align=1 1)
+  (func (param i32) (result v128)
+      local.get 0
+      v128.const i32x4 0x29292928 0x206e6928 0x616d286d 0x206f7263
+      v128.load32_lane align=1 1)
+  (func (param i32) (result v128)
+      local.get 0
+      v128.const i32x4 0x29292928 0x206e6928 0x616d286d 0x206f7263
+      v128.load64_lane align=1 1)
+  (func (param v128 i32) (result v128)
+		local.get 0
+		local.get 1
+		f32.load
+		f32x4.replace_lane 0)
+  (func (param v128 i32) (result v128)
+		local.get 0
+		local.get 1
+		f64.load
+		f64x2.replace_lane 1)
+  (func (param v128 i32) (result v128)
+		local.get 0
+		local.get 1
+		f64.load
+		f64x2.replace_lane 0)
+  (func (param v128 i32)
+		local.get 1
+		local.get 0
+		f64x2.extract_lane 1
+		f64.store)
+  (func (param v128 i32)
+		local.get 1
+		local.get 0
+		f32x4.extract_lane 1
+		f32.store)
+  (func (param v128 i32)
+		local.get 1
+		local.get 0
+		i8x16.extract_lane_s 1
+		i32.store8)
+  (func (param v128 i32)
+		local.get 1
+		local.get 0
+		i16x8.extract_lane_s 1
+		i32.store16)
+  (func (param v128 i32)
+		local.get 1
+		local.get 0
+		i32x4.extract_lane 1
+		i32.store)
+  (func (param v128 i32)
+		local.get 1
+		local.get 0
+		i64x2.extract_lane 1
+		i64.store))
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       vmovdqu 0x14(%rip), %xmm6
+;;       movl    %edx, %r9d
+;;       movq    0x60(%rdi), %r10
+;;       vpinsrb $1, (%r10, %r9), %xmm6, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   1f: addb    %ch, (%rax)
+;;   21: subl    %ebp, (%rcx)
+;;   23: subl    %ebp, (%rax)
+;;   25: imull   $0x616d286d, 0x20(%rsi), %ebp
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       vmovdqu 0x14(%rip), %xmm6
+;;       movl    %edx, %r9d
+;;       movq    0x60(%rdi), %r10
+;;       vpinsrw $1, (%r10, %r9), %xmm6, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   5f: addb    %ch, (%rax)
+;;   61: subl    %ebp, (%rcx)
+;;   63: subl    %ebp, (%rax)
+;;   65: imull   $0x616d286d, 0x20(%rsi), %ebp
+;;
+;; wasm[0]::function[2]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       vmovdqu 0x14(%rip), %xmm6
+;;       movl    %edx, %r9d
+;;       movq    0x60(%rdi), %r10
+;;       vpinsrd $1, (%r10, %r9), %xmm6, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   9f: addb    %ch, (%rax)
+;;   a1: subl    %ebp, (%rcx)
+;;   a3: subl    %ebp, (%rax)
+;;   a5: imull   $0x616d286d, 0x20(%rsi), %ebp
+;;
+;; wasm[0]::function[3]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       vmovdqu 0x14(%rip), %xmm6
+;;       movl    %edx, %r9d
+;;       movq    0x60(%rdi), %r10
+;;       vpinsrq $1, (%r10, %r9), %xmm6, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   df: addb    %ch, (%rax)
+;;   e1: subl    %ebp, (%rcx)
+;;   e3: subl    %ebp, (%rax)
+;;   e5: imull   $0x616d286d, 0x20(%rsi), %ebp
+;;
+;; wasm[0]::function[4]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r9d
+;;       movq    0x60(%rdi), %r10
+;;       vinsertps $0, (%r10, %r9), %xmm0, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[5]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r9d
+;;       movq    0x60(%rdi), %r10
+;;       vmovhps (%r10, %r9), %xmm0, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[6]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r10d
+;;       movq    0x60(%rdi), %r11
+;;       vmovsd  (%r11, %r10), %xmm7
+;;       vmovsd  %xmm7, %xmm0, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[7]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       vpshufd $0xee, %xmm0, %xmm6
+;;       movl    %edx, %r9d
+;;       movq    0x60(%rdi), %r10
+;;       vmovsd  %xmm6, (%r10, %r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[8]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       vpshufd $1, %xmm0, %xmm6
+;;       movl    %edx, %r9d
+;;       movq    0x60(%rdi), %r10
+;;       vmovss  %xmm6, (%r10, %r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[9]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       vpextrb $1, %xmm0, %r10d
+;;       movsbl  %r10b, %r10d
+;;       movl    %edx, %r11d
+;;       movq    0x60(%rdi), %rsi
+;;       movb    %r10b, (%rsi, %r11)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[10]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       vpextrw $1, %xmm0, %r10d
+;;       movswl  %r10w, %r10d
+;;       movl    %edx, %r11d
+;;       movq    0x60(%rdi), %rsi
+;;       movw    %r10w, (%rsi, %r11)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[11]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r8d
+;;       movq    0x60(%rdi), %r9
+;;       vpextrd $1, %xmm0, (%r9, %r8)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[12]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r8d
+;;       movq    0x60(%rdi), %r9
+;;       vpextrq $1, %xmm0, (%r9, %r8)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/pcc-insertlane-x64.wat b/tests/disas/pcc-insertlane-x64.wat
new file mode 100644
index 000000000000..b82db8486261
--- /dev/null
+++ b/tests/disas/pcc-insertlane-x64.wat
@@ -0,0 +1,227 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = [ "-Oopt-level=0", "-Cpcc=y", "-Ccranelift-has-sse41=true", "-Ccranelift-has-avx=false" ]
+
+(module
+  (memory 1 1)
+  (func (param i32) (result v128)
+		local.get 0
+		v128.const i32x4 0x29292928 0x206e6928 0x616d286d 0x206f7263
+		v128.load8_lane align=1 1)
+  (func (param i32) (result v128)
+		local.get 0
+		v128.const i32x4 0x29292928 0x206e6928 0x616d286d 0x206f7263
+		v128.load16_lane align=1 1)
+  (func (param i32) (result v128)
+		local.get 0
+		v128.const i32x4 0x29292928 0x206e6928 0x616d286d 0x206f7263
+		v128.load32_lane align=1 1)
+  (func (param i32) (result v128)
+		local.get 0
+		v128.const i32x4 0x29292928 0x206e6928 0x616d286d 0x206f7263
+		v128.load64_lane align=1 1)
+  (func (param v128 i32) (result v128)
+		local.get 0
+		local.get 1
+		f32.load
+		f32x4.replace_lane 0)
+  (func (param v128 i32) (result v128)
+		local.get 0
+		local.get 1
+		f64.load
+		f64x2.replace_lane 1)
+  (func (param v128 i32) (result v128)
+		local.get 0
+		local.get 1
+		f64.load
+		f64x2.replace_lane 0)
+  (func (param v128 i32)
+		local.get 1
+		local.get 0
+		f64x2.extract_lane 1
+		f64.store)
+  (func (param v128 i32)
+		local.get 1
+		local.get 0
+		f32x4.extract_lane 1
+		f32.store)
+  (func (param v128 i32)
+		local.get 1
+		local.get 0
+		i8x16.extract_lane_s 1
+		i32.store8)
+  (func (param v128 i32)
+		local.get 1
+		local.get 0
+		i16x8.extract_lane_s 1
+		i32.store16)
+  (func (param v128 i32)
+		local.get 1
+		local.get 0
+		i32x4.extract_lane 1
+		i32.store)
+  (func (param v128 i32)
+		local.get 1
+		local.get 0
+		i64x2.extract_lane 1
+		i64.store))
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movdqu  0x14(%rip), %xmm0
+;;       movl    %edx, %r9d
+;;       movq    0x60(%rdi), %r10
+;;       pinsrb  $1, (%r10, %r9), %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   20: subb    %ch, (%rcx)
+;;   22: subl    %ebp, (%rcx)
+;;   24: subb    %ch, 0x6e(%rcx)
+;;   27: andb    %ch, 0x28(%rbp)
+;;   2a: insl    %dx, (%rdi)
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movdqu  0x14(%rip), %xmm0
+;;       movl    %edx, %r9d
+;;       movq    0x60(%rdi), %r10
+;;       pinsrw  $1, (%r10, %r9), %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   5f: addb    %ch, (%rax)
+;;   61: subl    %ebp, (%rcx)
+;;   63: subl    %ebp, (%rax)
+;;   65: imull   $0x616d286d, 0x20(%rsi), %ebp
+;;
+;; wasm[0]::function[2]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movdqu  0x14(%rip), %xmm0
+;;       movl    %edx, %r9d
+;;       movq    0x60(%rdi), %r10
+;;       pinsrd  $1, (%r10, %r9), %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   a0: subb    %ch, (%rcx)
+;;   a2: subl    %ebp, (%rcx)
+;;   a4: subb    %ch, 0x6e(%rcx)
+;;   a7: andb    %ch, 0x28(%rbp)
+;;   aa: insl    %dx, (%rdi)
+;;
+;; wasm[0]::function[3]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movdqu  0x14(%rip), %xmm0
+;;       movl    %edx, %r9d
+;;       movq    0x60(%rdi), %r10
+;;       pinsrq  $1, (%r10, %r9), %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   e0: subb    %ch, (%rcx)
+;;   e2: subl    %ebp, (%rcx)
+;;   e4: subb    %ch, 0x6e(%rcx)
+;;   e7: andb    %ch, 0x28(%rbp)
+;;   ea: insl    %dx, (%rdi)
+;;
+;; wasm[0]::function[4]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r9d
+;;       movq    0x60(%rdi), %r10
+;;       insertps $0, (%r10, %r9), %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[5]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r10d
+;;       movq    0x60(%rdi), %r11
+;;       movdqu  (%r11, %r10), %xmm6
+;;       movlhps %xmm6, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[6]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r10d
+;;       movq    0x60(%rdi), %r11
+;;       movsd   (%r11, %r10), %xmm7
+;;       movsd   %xmm7, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[7]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       pshufd  $0xee, %xmm0, %xmm6
+;;       movl    %edx, %r9d
+;;       movq    0x60(%rdi), %r10
+;;       movsd   %xmm6, (%r10, %r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[8]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       pshufd  $1, %xmm0, %xmm6
+;;       movl    %edx, %r9d
+;;       movq    0x60(%rdi), %r10
+;;       movss   %xmm6, (%r10, %r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[9]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       pextrb  $1, %xmm0, %r10d
+;;       movsbl  %r10b, %r10d
+;;       movl    %edx, %r11d
+;;       movq    0x60(%rdi), %rsi
+;;       movb    %r10b, (%rsi, %r11)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[10]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       pextrw  $1, %xmm0, %r10d
+;;       movswl  %r10w, %r10d
+;;       movl    %edx, %r11d
+;;       movq    0x60(%rdi), %rsi
+;;       movw    %r10w, (%rsi, %r11)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[11]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r8d
+;;       movq    0x60(%rdi), %r9
+;;       pextrd  $1, %xmm0, (%r9, %r8)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[12]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    %edx, %r8d
+;;       movq    0x60(%rdi), %r9
+;;       pextrq  $1, %xmm0, (%r9, %r8)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/pcc-loads-x64-avx.wat b/tests/disas/pcc-loads-x64-avx.wat
new file mode 100644
index 000000000000..94cf0413f64c
--- /dev/null
+++ b/tests/disas/pcc-loads-x64-avx.wat
@@ -0,0 +1,59 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = [ "-Oopt-level=2", "-Cpcc=y", "-Ccranelift-has-avx=true" ]
+
+(module
+  (memory 1 1)
+  (func (export "load_f32") (param i32) (result f32)
+    local.get 0
+    f32.load)
+  (func (export "load_f64") (param i32) (result f64)
+    local.get 0
+    f64.load)
+  (func (export "store_f32") (param i32 f32)
+    local.get 0
+    local.get 1
+    f32.store)
+  (func (export "store_f64") (param i32 f64)
+    local.get 0
+    local.get 1
+    f64.store))
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x60(%rdi), %r8
+;;       movl    %edx, %r9d
+;;       vmovss  (%r8, %r9), %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x60(%rdi), %r8
+;;       movl    %edx, %r9d
+;;       vmovsd  (%r8, %r9), %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[2]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x60(%rdi), %r8
+;;       movl    %edx, %r9d
+;;       vmovss  %xmm0, (%r8, %r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[3]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x60(%rdi), %r8
+;;       movl    %edx, %r9d
+;;       vmovsd  %xmm0, (%r8, %r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/pcc-loads-x64.wat b/tests/disas/pcc-loads-x64.wat
new file mode 100644
index 000000000000..51fdaf1b9f7f
--- /dev/null
+++ b/tests/disas/pcc-loads-x64.wat
@@ -0,0 +1,59 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = [ "-Oopt-level=2", "-Cpcc=y", "-Ccranelift-has-avx=false" ]
+
+(module
+  (memory 1 1)
+  (func (export "load_f32") (param i32) (result f32)
+    local.get 0
+    f32.load)
+  (func (export "load_f64") (param i32) (result f64)
+    local.get 0
+    f64.load)
+  (func (export "store_f32") (param i32 f32)
+    local.get 0
+    local.get 1
+    f32.store)
+  (func (export "store_f64") (param i32 f64)
+    local.get 0
+    local.get 1
+    f64.store))
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x60(%rdi), %r8
+;;       movl    %edx, %r9d
+;;       movss   (%r8, %r9), %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x60(%rdi), %r8
+;;       movl    %edx, %r9d
+;;       movsd   (%r8, %r9), %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[2]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x60(%rdi), %r8
+;;       movl    %edx, %r9d
+;;       movss   %xmm0, (%r8, %r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[3]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    0x60(%rdi), %r8
+;;       movl    %edx, %r9d
+;;       movsd   %xmm0, (%r8, %r9)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/pr2303.wat b/tests/disas/pr2303.wat
new file mode 100644
index 000000000000..9dd422d5c25b
--- /dev/null
+++ b/tests/disas/pr2303.wat
@@ -0,0 +1,77 @@
+;;! target = "x86_64"
+
+(module
+    (memory (export "mem") 1 1)
+    (func (export "runif") (param $cond i32)
+      i32.const 48
+      (v128.load (i32.const 0))
+      (v128.load (i32.const 16))
+      (if (param v128) (param v128) (result v128 v128)
+          (local.get $cond)
+          (then i64x2.add
+                (v128.load (i32.const 32)))
+          (else i32x4.sub
+                (v128.load (i32.const 0))))
+      i16x8.mul
+      v128.store)
+)
+
+;; function u0:0(i64 vmctx, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0036                               v3 = iconst.i32 48
+;; @0038                               v4 = iconst.i32 0
+;; @003a                               v5 = uextend.i64 v4  ; v4 = 0
+;; @003a                               v6 = global_value.i64 gv4
+;; @003a                               v7 = iadd v6, v5
+;; @003a                               v8 = load.i8x16 little heap v7
+;; @003e                               v9 = iconst.i32 16
+;; @0040                               v10 = uextend.i64 v9  ; v9 = 16
+;; @0040                               v11 = global_value.i64 gv4
+;; @0040                               v12 = iadd v11, v10
+;; @0040                               v13 = load.i8x16 little heap v12
+;; @0046                               brif v2, block2, block4(v8, v13)
+;;
+;;                                 block2:
+;; @0048                               v16 = bitcast.i64x2 little v8
+;; @0048                               v17 = bitcast.i64x2 little v13
+;; @0048                               v18 = iadd v16, v17
+;; @004b                               v19 = iconst.i32 32
+;; @004d                               v20 = uextend.i64 v19  ; v19 = 32
+;; @004d                               v21 = global_value.i64 gv4
+;; @004d                               v22 = iadd v21, v20
+;; @004d                               v23 = load.i8x16 little heap v22
+;; @0051                               v26 = bitcast.i8x16 little v18
+;; @0051                               jump block3(v26, v23)
+;;
+;;                                 block4(v24: i8x16, v25: i8x16):
+;; @0052                               v27 = bitcast.i32x4 little v8
+;; @0052                               v28 = bitcast.i32x4 little v13
+;; @0052                               v29 = isub v27, v28
+;; @0055                               v30 = iconst.i32 0
+;; @0057                               v31 = uextend.i64 v30  ; v30 = 0
+;; @0057                               v32 = global_value.i64 gv4
+;; @0057                               v33 = iadd v32, v31
+;; @0057                               v34 = load.i8x16 little heap v33
+;; @005b                               v35 = bitcast.i8x16 little v29
+;; @005b                               jump block3(v35, v34)
+;;
+;;                                 block3(v14: i8x16, v15: i8x16):
+;; @005c                               v36 = bitcast.i16x8 little v14
+;; @005c                               v37 = bitcast.i16x8 little v15
+;; @005c                               v38 = imul v36, v37
+;; @005f                               v39 = uextend.i64 v3  ; v3 = 48
+;; @005f                               v40 = global_value.i64 gv4
+;; @005f                               v41 = iadd v40, v39
+;; @005f                               store little heap v38, v41
+;; @0063                               jump block1
+;;
+;;                                 block1:
+;; @0063                               return
+;; }
diff --git a/tests/disas/pr2559.wat b/tests/disas/pr2559.wat
new file mode 100644
index 000000000000..895355ac1ae2
--- /dev/null
+++ b/tests/disas/pr2559.wat
@@ -0,0 +1,133 @@
+;;! target = "x86_64"
+
+(module
+  (type (;0;) (func (result v128 v128 v128)))
+
+  (func $main1 (type 0) (result v128 v128 v128)
+    call $main1
+    i8x16.add
+    call $main1
+    i8x16.ge_u
+    i16x8.ne
+    i32.const 13
+    br_if 0 (;@0;)
+    i32.const 43
+    br_if 0 (;@0;)
+    i32.const 13
+    br_if 0 (;@0;)
+    i32.const 87
+    select
+    unreachable
+    i32.const 0
+    br_if 0 (;@0;)
+    i32.const 13
+    br_if 0 (;@0;)
+    i32.const 43
+    br_if 0 (;@0;)
+  )
+  (export "main1" (func $main1))
+
+  (func $main2 (type 0) (result v128 v128 v128)
+    call $main2
+    i8x16.add
+    call $main2
+    i8x16.ge_u
+    i16x8.ne
+    i32.const 13
+    br_if 0 (;@0;)
+    i32.const 43
+    br_if 0 (;@0;)
+    i32.const 13
+    br_if 0 (;@0;)
+    i32.const 87
+    select (result v128)
+    unreachable
+    i32.const 0
+    br_if 0 (;@0;)
+    i32.const 13
+    br_if 0 (;@0;)
+    i32.const 43
+    br_if 0 (;@0;)
+  )
+  (export "main2" (func $main2))
+)
+
+;; function u0:0(i64 vmctx, i64) -> i8x16, i8x16, i8x16 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     sig0 = (i64 vmctx, i64) -> i8x16, i8x16, i8x16 tail
+;;     fn0 = colocated u0:0 sig0
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @002e                               v5, v6, v7 = call fn0(v0, v0)
+;; @0030                               v8 = iadd v6, v7
+;; @0032                               v9, v10, v11 = call fn0(v0, v0)
+;; @0034                               v12 = icmp uge v10, v11
+;; @0036                               v13 = bitcast.i16x8 little v9
+;; @0036                               v14 = bitcast.i16x8 little v12
+;; @0036                               v15 = icmp ne v13, v14
+;; @0038                               v16 = iconst.i32 13
+;; @003a                               v17 = bitcast.i8x16 little v15
+;; @003a                               brif v16, block1(v5, v8, v17), block2  ; v16 = 13
+;;
+;;                                 block2:
+;; @003c                               v18 = iconst.i32 43
+;; @003e                               v19 = bitcast.i8x16 little v15
+;; @003e                               brif v18, block1(v5, v8, v19), block3  ; v18 = 43
+;;
+;;                                 block3:
+;; @0040                               v20 = iconst.i32 13
+;; @0042                               v21 = bitcast.i8x16 little v15
+;; @0042                               brif v20, block1(v5, v8, v21), block4  ; v20 = 13
+;;
+;;                                 block4:
+;; @0044                               v22 = iconst.i32 87
+;; @0047                               v23 = bitcast.i8x16 little v15
+;; @0047                               v24 = select.i8x16 v22, v8, v23  ; v22 = 87
+;; @0048                               trap unreachable
+;;
+;;                                 block1(v2: i8x16, v3: i8x16, v4: i8x16):
+;; @0055                               return v2, v3, v4
+;; }
+;;
+;; function u0:1(i64 vmctx, i64) -> i8x16, i8x16, i8x16 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     sig0 = (i64 vmctx, i64) -> i8x16, i8x16, i8x16 tail
+;;     fn0 = colocated u0:1 sig0
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @0058                               v5, v6, v7 = call fn0(v0, v0)
+;; @005a                               v8 = iadd v6, v7
+;; @005c                               v9, v10, v11 = call fn0(v0, v0)
+;; @005e                               v12 = icmp uge v10, v11
+;; @0060                               v13 = bitcast.i16x8 little v9
+;; @0060                               v14 = bitcast.i16x8 little v12
+;; @0060                               v15 = icmp ne v13, v14
+;; @0062                               v16 = iconst.i32 13
+;; @0064                               v17 = bitcast.i8x16 little v15
+;; @0064                               brif v16, block1(v5, v8, v17), block2  ; v16 = 13
+;;
+;;                                 block2:
+;; @0066                               v18 = iconst.i32 43
+;; @0068                               v19 = bitcast.i8x16 little v15
+;; @0068                               brif v18, block1(v5, v8, v19), block3  ; v18 = 43
+;;
+;;                                 block3:
+;; @006a                               v20 = iconst.i32 13
+;; @006c                               v21 = bitcast.i8x16 little v15
+;; @006c                               brif v20, block1(v5, v8, v21), block4  ; v20 = 13
+;;
+;;                                 block4:
+;; @006e                               v22 = iconst.i32 87
+;; @0071                               v23 = bitcast.i8x16 little v15
+;; @0071                               v24 = select.i8x16 v22, v8, v23  ; v22 = 87
+;; @0074                               trap unreachable
+;;
+;;                                 block1(v2: i8x16, v3: i8x16, v4: i8x16):
+;; @0081                               return v2, v3, v4
+;; }
diff --git a/tests/disas/readonly-funcrefs.wat b/tests/disas/readonly-funcrefs.wat
new file mode 100644
index 000000000000..2346abfbfed5
--- /dev/null
+++ b/tests/disas/readonly-funcrefs.wat
@@ -0,0 +1,83 @@
+;;! target = "x86_64"
+;;! test = "optimize"
+
+;; Current WebAssembly toolchains represent source-language function pointers
+;; by constructing a single WebAssembly funcref table, initializing it with an
+;; element section, and never writing to it again. This test tracks what code
+;; we generate for that pattern.
+
+;; Motivated by https://github.com/bytecodealliance/wasmtime/issues/8195
+
+(module
+  (type $fn (func))
+  (table $fnptrs 2 2 funcref)
+  (func $callee)
+  (func $caller (param i32)
+        local.get 0
+        call_indirect $fnptrs (type $fn))
+  (elem $fnptrs (i32.const 1) func $callee)
+)
+
+;; function u0:0(i64 vmctx, i64) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @002c                               jump block1
+;;
+;;                                 block1:
+;; @002c                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly gv3+88
+;;     sig0 = (i64 vmctx, i64) tail
+;;     sig1 = (i64 vmctx, i32 uext, i32 uext) -> i64 system_v
+;;     fn0 = colocated u1:9 sig1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0031                               v3 = iconst.i32 2
+;; @0031                               v4 = icmp uge v2, v3  ; v3 = 2
+;; @0031                               v9 = iconst.i64 0
+;; @0031                               v6 = load.i64 notrap aligned readonly v0+88
+;; @0031                               v5 = uextend.i64 v2
+;;                                     v25 = iconst.i64 3
+;; @0031                               v7 = ishl v5, v25  ; v25 = 3
+;; @0031                               v8 = iadd v6, v7
+;; @0031                               v10 = select_spectre_guard v4, v9, v8  ; v9 = 0
+;; @0031                               v11 = load.i64 table_oob aligned table v10
+;;                                     v26 = iconst.i64 -2
+;; @0031                               v12 = band v11, v26  ; v26 = -2
+;; @0031                               brif v11, block3(v12), block2
+;;
+;;                                 block2 cold:
+;; @0031                               v14 = iconst.i32 0
+;; @0031                               v16 = call fn0(v0, v14, v2)  ; v14 = 0
+;; @0031                               jump block3(v16)
+;;
+;;                                 block3(v13: i64):
+;; @0031                               v20 = load.i32 icall_null aligned readonly v13+16
+;; @0031                               v18 = load.i64 notrap aligned readonly v0+80
+;; @0031                               v19 = load.i32 notrap aligned readonly v18
+;; @0031                               v21 = icmp eq v20, v19
+;; @0031                               brif v21, block5, block4
+;;
+;;                                 block4 cold:
+;; @0031                               trap bad_sig
+;;
+;;                                 block5:
+;; @0031                               v22 = load.i64 notrap aligned readonly v13+8
+;; @0031                               v23 = load.i64 notrap aligned readonly v13+24
+;; @0031                               call_indirect sig0, v22(v23, v0)
+;; @0034                               jump block1
+;;
+;;                                 block1:
+;; @0034                               return
+;; }
diff --git a/tests/disas/ref-func-0.wat b/tests/disas/ref-func-0.wat
new file mode 100644
index 000000000000..d0dcc9d94e0b
--- /dev/null
+++ b/tests/disas/ref-func-0.wat
@@ -0,0 +1,43 @@
+;;! target = "x86_64"
+
+(module
+  (func $imported (import "env" "f") (param i32) (result i32))
+  (func $local (result externref externref funcref funcref)
+    global.get 0
+    global.get 1
+    global.get 2
+    global.get 3)
+
+  (global (export "externref-imported") externref (ref.null extern))
+  (global (export "externref-local") externref (ref.null extern))
+  (global (export "funcref-imported") funcref (ref.func $imported))
+  (global (export "funcref-local") funcref (ref.func $local)))
+
+;; function u0:1(i64 vmctx, i64) -> i32, i32, i64, i64 tail {
+;;     ss0 = explicit_slot 4, align = 4
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     sig0 = (i64 vmctx, i32 uext) -> i32 system_v
+;;     fn0 = colocated u1:27 sig0
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @008f                               v6 = global_value.i64 gv3
+;; @008f                               v7 = iconst.i32 0
+;; @008f                               v8 = call fn0(v6, v7)  ; v7 = 0
+;;                                     stack_store v8, ss0
+;; @0091                               v9 = global_value.i64 gv3
+;; @0091                               v10 = iconst.i32 1
+;; @0091                               v11 = call fn0(v9, v10), stack_map=[i32 @ ss0+0]  ; v10 = 1
+;; @0093                               v12 = global_value.i64 gv3
+;; @0093                               v13 = load.i64 notrap aligned table v12+144
+;; @0095                               v14 = global_value.i64 gv3
+;; @0095                               v15 = load.i64 notrap aligned table v14+160
+;;                                     v16 = stack_load.i32 ss0
+;; @0097                               jump block1(v16, v11, v13, v15)
+;;
+;;                                 block1(v2: i32, v3: i32, v4: i64, v5: i64):
+;; @0097                               return v2, v3, v4, v5
+;; }
diff --git a/tests/disas/riscv64-zbb.wat b/tests/disas/riscv64-zbb.wat
new file mode 100644
index 000000000000..ca191da41e5e
--- /dev/null
+++ b/tests/disas/riscv64-zbb.wat
@@ -0,0 +1,163 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = "-Ccranelift-has-zbb"
+
+(module
+  (func (export "rolw") (param i32 i32) (result i32)
+    (i32.rotl (local.get 0) (local.get 1)))
+  (func (export "rol") (param i64 i64) (result i64)
+    (i64.rotl (local.get 0) (local.get 1)))
+  (func (export "rolwi") (param i32 ) (result i32)
+    (i32.rotl (local.get 0) (i32.const 100)))
+  (func (export "roli") (param i64) (result i64)
+    (i64.rotl (local.get 0) (i64.const 40)))
+
+  (func (export "rorw") (param i32 i32) (result i32)
+    (i32.rotr (local.get 0) (local.get 1)))
+  (func (export "ror") (param i64 i64) (result i64)
+    (i64.rotr (local.get 0) (local.get 1)))
+  (func (export "rorwi") (param i32 ) (result i32)
+    (i32.rotr (local.get 0) (i32.const 100)))
+  (func (export "rori") (param i64) (result i64)
+    (i64.rotr (local.get 0) (i64.const 40)))
+
+  (func (export "xnor32_1") (param i32 i32) (result i32)
+    (i32.xor (i32.xor (local.get 0) (local.get 1)) (i32.const -1)))
+  (func (export "xnor32_2") (param i32 i32) (result i32)
+    (i32.xor (i32.const -1) (i32.xor (local.get 0) (local.get 1))))
+  (func (export "xnor64_1") (param i64 i64) (result i64)
+    (i64.xor (i64.xor (local.get 0) (local.get 1)) (i64.const -1)))
+  (func (export "xnor64_2") (param i64 i64) (result i64)
+    (i64.xor (i64.const -1) (i64.xor (local.get 0) (local.get 1))))
+)
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x3b, 0x15, 0xd6, 0x60
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x33, 0x15, 0xd6, 0x60
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[2]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x1b, 0x55, 0xc6, 0x61
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[3]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x13, 0x55, 0x86, 0x61
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[4]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x3b, 0x55, 0xd6, 0x60
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[5]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x33, 0x55, 0xd6, 0x60
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[6]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x1b, 0x55, 0x46, 0x60
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[7]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x13, 0x55, 0x86, 0x62
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[8]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x33, 0x45, 0xd6, 0x40
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[9]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x33, 0x45, 0xd6, 0x40
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[10]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x33, 0x45, 0xd6, 0x40
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[11]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x33, 0x45, 0xd6, 0x40
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/riscv64-zbs.wat b/tests/disas/riscv64-zbs.wat
new file mode 100644
index 000000000000..667f5d643234
--- /dev/null
+++ b/tests/disas/riscv64-zbs.wat
@@ -0,0 +1,550 @@
+;;! target = "riscv64"
+;;! test = "compile"
+;;! flags = "-Ccranelift-has-zbs"
+
+(module
+  (func (export "bclr32") (param i32 i32) (result i32)
+    (i32.and (local.get 0) (i32.xor (i32.shl (i32.const 1) (local.get 1)) (i32.const -1)))
+  )
+  (func (export "bclr64") (param i64 i64) (result i64)
+    (i64.and (i64.xor (i64.shl (i64.const 1) (local.get 1)) (i64.const -1)) (local.get 0))
+  )
+  (func (export "bclri32_4") (param i32) (result i32)
+    (i32.and (local.get 0) (i32.xor (i32.shl (i32.const 1) (i32.const 4)) (i32.const -1)))
+  )
+  (func (export "bclri32_20") (param i32) (result i32)
+    (i32.and (i32.xor (i32.shl (i32.const 1) (i32.const 20)) (i32.const -1)) (local.get 0))
+  )
+  (func (export "bclri64_4") (param i64) (result i64)
+    (i64.and (local.get 0) (i64.xor (i64.shl (i64.const 1) (i64.const 4)) (i64.const -1)))
+  )
+  (func (export "bclri64_52") (param i64) (result i64)
+    (i64.and (local.get 0) (i64.xor (i64.shl (i64.const 1) (i64.const 52)) (i64.const -1)))
+  )
+
+  (func (export "bext32_1") (param i32 i32) (result i32)
+    (i32.and (i32.shr_u (local.get 0) (local.get 1)) (i32.const 1))
+  )
+  (func (export "bext32_2") (param i32 i32) (result i32)
+    (i32.and (i32.shr_s (local.get 0) (local.get 1)) (i32.const 1))
+  )
+  (func (export "bext32_3") (param i32 i32) (result i32)
+    (i32.and (i32.const 1) (i32.shr_u (local.get 0) (local.get 1)))
+  )
+  (func (export "bext32_4") (param i32 i32) (result i32)
+    (i32.and (i32.const 1) (i32.shr_s (local.get 0) (local.get 1)))
+  )
+  (func (export "bext64_1") (param i64 i64) (result i64)
+    (i64.and (i64.shr_u (local.get 0) (local.get 1)) (i64.const 1))
+  )
+  (func (export "bext64_2") (param i64 i64) (result i64)
+    (i64.and (i64.shr_s (local.get 0) (local.get 1)) (i64.const 1))
+  )
+  (func (export "bext64_3") (param i64 i64) (result i64)
+    (i64.and (i64.const 1) (i64.shr_u (local.get 0) (local.get 1)))
+  )
+  (func (export "bext64_4") (param i64 i64) (result i64)
+    (i64.and (i64.const 1) (i64.shr_s (local.get 0) (local.get 1)))
+  )
+
+  (func (export "bexti32_1") (param i32) (result i32)
+    (i32.and (i32.shr_u (local.get 0) (i32.const 10)) (i32.const 1))
+  )
+  (func (export "bexti32_2") (param i32) (result i32)
+    (i32.and (i32.shr_s (local.get 0) (i32.const 20)) (i32.const 1))
+  )
+  (func (export "bexti32_3") (param i32) (result i32)
+    (i32.and (i32.shr_u (i32.const 1) (local.get 0) (i32.const 30)))
+  )
+  (func (export "bexti32_4") (param i32) (result i32)
+    (i32.and (i32.shr_s (i32.const 1) (local.get 0) (i32.const 40)))
+  )
+  (func (export "bexti64_1") (param i64) (result i64)
+    (i64.and (i64.shr_u (local.get 0) (i64.const 10)) (i64.const 1))
+  )
+  (func (export "bexti64_2") (param i64) (result i64)
+    (i64.and (i64.shr_s (local.get 0) (i64.const 20)) (i64.const 1))
+  )
+  (func (export "bexti64_3") (param i64) (result i64)
+    (i64.and (i64.shr_u (i64.const 1) (local.get 0) (i64.const 30)))
+  )
+  (func (export "bexti64_4") (param i64) (result i64)
+    (i64.and (i64.shr_s (i64.const 1) (local.get 0) (i64.const 40)))
+  )
+
+  (func (export "binv32_1") (param i32 i32) (result i32)
+    (i32.xor (local.get 0) (i32.shl (i32.const 1) (local.get 1)))
+  )
+  (func (export "binv32_2") (param i32 i32) (result i32)
+    (i32.xor (i32.shl (i32.const 1) (local.get 1)) (local.get 0))
+  )
+  (func (export "binv64_1") (param i64 i64) (result i64)
+    (i64.xor (local.get 0) (i64.shl (i64.const 1) (local.get 1)))
+  )
+  (func (export "binv64_2") (param i64 i64) (result i64)
+    (i64.xor (i64.shl (i64.const 1) (local.get 1)) (local.get 0))
+  )
+  (func (export "binvi32_1") (param i32) (result i32)
+    (i32.xor (local.get 0) (i32.shl (i32.const 1) (i32.const 10)))
+  )
+  (func (export "binvi32_2") (param i32) (result i32)
+    (i32.xor (i32.shl (i32.const 1) (i32.const 20)) (local.get 0))
+  )
+  (func (export "binvi64_1") (param i64) (result i64)
+    (i64.xor (local.get 0) (i64.shl (i64.const 1) (i64.const 30)))
+  )
+  (func (export "binvi64_2") (param i64) (result i64)
+    (i64.xor (i64.shl (i64.const 1) (i64.const 40)) (local.get 0))
+  )
+
+  (func (export "bset32_1") (param i32 i32) (result i32)
+    (i32.or (local.get 0) (i32.shl (i32.const 1) (local.get 1)))
+  )
+  (func (export "bset32_2") (param i32 i32) (result i32)
+    (i32.or (i32.shl (i32.const 1) (local.get 1)) (local.get 0))
+  )
+  (func (export "bset64_1") (param i64 i64) (result i64)
+    (i64.or (local.get 0) (i64.shl (i64.const 1) (local.get 1)))
+  )
+  (func (export "bset64_2") (param i64 i64) (result i64)
+    (i64.or (i64.shl (i64.const 1) (local.get 1)) (local.get 0))
+  )
+  (func (export "bseti32_1") (param i32) (result i32)
+    (i32.or (local.get 0) (i32.shl (i32.const 1) (i32.const 10)))
+  )
+  (func (export "bseti32_2") (param i32) (result i32)
+    (i32.or (i32.shl (i32.const 1) (i32.const 20)) (local.get 0))
+  )
+  (func (export "bseti64_1") (param i64) (result i64)
+    (i64.or (local.get 0) (i64.shl (i64.const 1) (i64.const 30)))
+  )
+  (func (export "bseti64_2") (param i64) (result i64)
+    (i64.or (i64.shl (i64.const 1) (i64.const 40)) (local.get 0))
+  )
+)
+;; wasm[0]::function[0]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       andi    a4, a3, 0x1f
+;;       .byte   0x33, 0x15, 0xe6, 0x48
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[1]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x33, 0x15, 0xd6, 0x48
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[2]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x13, 0x15, 0x46, 0x48
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[3]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x13, 0x15, 0x46, 0x49
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[4]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x13, 0x15, 0x46, 0x48
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[5]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x13, 0x15, 0x46, 0x4b
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[6]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       andi    a4, a3, 0x1f
+;;       .byte   0x33, 0x55, 0xe6, 0x48
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[7]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       andi    a4, a3, 0x1f
+;;       .byte   0x33, 0x55, 0xe6, 0x48
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[8]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       andi    a4, a3, 0x1f
+;;       .byte   0x33, 0x55, 0xe6, 0x48
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[9]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       andi    a4, a3, 0x1f
+;;       .byte   0x33, 0x55, 0xe6, 0x48
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[10]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x33, 0x55, 0xd6, 0x48
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[11]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x33, 0x55, 0xd6, 0x48
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[12]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x33, 0x55, 0xd6, 0x48
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[13]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x33, 0x55, 0xd6, 0x48
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[14]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x13, 0x55, 0xa6, 0x48
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[15]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x13, 0x55, 0x46, 0x49
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[16]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x13, 0x55, 0xe6, 0x49
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[17]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x13, 0x55, 0x86, 0x48
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[18]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x13, 0x55, 0xa6, 0x48
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[19]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x13, 0x55, 0x46, 0x49
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[20]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x13, 0x55, 0xe6, 0x49
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[21]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x13, 0x55, 0x86, 0x4a
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[22]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       andi    a4, a3, 0x1f
+;;       .byte   0x33, 0x15, 0xe6, 0x68
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[23]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       andi    a4, a3, 0x1f
+;;       .byte   0x33, 0x15, 0xe6, 0x68
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[24]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x33, 0x15, 0xd6, 0x68
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[25]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x33, 0x15, 0xd6, 0x68
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[26]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x13, 0x15, 0xa6, 0x68
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[27]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x13, 0x15, 0x46, 0x69
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[28]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x13, 0x15, 0xe6, 0x69
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[29]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x13, 0x15, 0x86, 0x6a
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[30]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       andi    a4, a3, 0x1f
+;;       .byte   0x33, 0x15, 0xe6, 0x28
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[31]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       andi    a4, a3, 0x1f
+;;       .byte   0x33, 0x15, 0xe6, 0x28
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[32]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x33, 0x15, 0xd6, 0x28
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[33]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x33, 0x15, 0xd6, 0x28
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[34]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x13, 0x15, 0xa6, 0x28
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[35]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x13, 0x15, 0x46, 0x29
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[36]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x13, 0x15, 0xe6, 0x29
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
+;;
+;; wasm[0]::function[37]:
+;;       addi    sp, sp, -0x10
+;;       sd      ra, 8(sp)
+;;       sd      s0, 0(sp)
+;;       mv      s0, sp
+;;       .byte   0x13, 0x15, 0x86, 0x2a
+;;       ld      ra, 8(sp)
+;;       ld      s0, 0(sp)
+;;       addi    sp, sp, 0x10
+;;       ret
diff --git a/tests/disas/select.wat b/tests/disas/select.wat
new file mode 100644
index 000000000000..f618353adfad
--- /dev/null
+++ b/tests/disas/select.wat
@@ -0,0 +1,71 @@
+;;! target = "x86_64"
+
+(module
+  (func $untyped-select (result i32)
+  	i32.const 42
+  	i32.const 24
+  	i32.const 1
+  	select)
+
+  (func $typed-select-1 (result externref)
+  	ref.null extern
+  	ref.null extern
+  	i32.const 1
+  	select (result externref))
+
+  (func $typed-select-2 (param externref) (result externref)
+    ref.null extern
+    local.get 0
+    i32.const 1
+    select (result externref))
+)
+
+;; function u0:0(i64 vmctx, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @0023                               v3 = iconst.i32 42
+;; @0025                               v4 = iconst.i32 24
+;; @0027                               v5 = iconst.i32 1
+;; @0029                               v6 = select v5, v3, v4  ; v5 = 1, v3 = 42, v4 = 24
+;; @002a                               jump block1(v6)
+;;
+;;                                 block1(v2: i32):
+;; @002a                               return v2
+;; }
+;;
+;; function u0:1(i64 vmctx, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @002d                               v3 = iconst.i32 0
+;; @002f                               v4 = iconst.i32 0
+;; @0031                               v5 = iconst.i32 1
+;; @0033                               v6 = select v5, v3, v4  ; v5 = 1, v3 = 0, v4 = 0
+;; @0036                               jump block1(v6)
+;;
+;;                                 block1(v2: i32):
+;; @0036                               return v2
+;; }
+;;
+;; function u0:2(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0039                               v4 = iconst.i32 0
+;; @003d                               v5 = iconst.i32 1
+;; @003f                               v6 = select v5, v4, v2  ; v5 = 1, v4 = 0
+;; @0042                               jump block1(v6)
+;;
+;;                                 block1(v3: i32):
+;; @0042                               return v3
+;; }
diff --git a/tests/disas/simd-store.wat b/tests/disas/simd-store.wat
new file mode 100644
index 000000000000..234e0985471e
--- /dev/null
+++ b/tests/disas/simd-store.wat
@@ -0,0 +1,855 @@
+;;! target = "x86_64"
+
+(module
+  (func (param v128)
+    (v128.store (i32.const 0) (i8x16.eq (local.get 0) (local.get 0))))
+  (func (param v128)
+    (v128.store (i32.const 0) (i16x8.eq (local.get 0) (local.get 0))))
+  (func (param v128)
+    (v128.store (i32.const 0) (i32x4.eq (local.get 0) (local.get 0))))
+  (func (param v128)
+    (v128.store (i32.const 0) (i64x2.eq (local.get 0) (local.get 0))))
+
+  (func (param v128)
+    (v128.store (i32.const 0) (i8x16.ne (local.get 0) (local.get 0))))
+  (func (param v128)
+    (v128.store (i32.const 0) (i16x8.ne (local.get 0) (local.get 0))))
+  (func (param v128)
+    (v128.store (i32.const 0) (i32x4.ne (local.get 0) (local.get 0))))
+  (func (param v128)
+    (v128.store (i32.const 0) (i64x2.ne (local.get 0) (local.get 0))))
+
+  (func (param v128)
+    (v128.store (i32.const 0) (i8x16.lt_s (local.get 0) (local.get 0))))
+  (func (param v128)
+    (v128.store (i32.const 0) (i16x8.lt_s (local.get 0) (local.get 0))))
+  (func (param v128)
+    (v128.store (i32.const 0) (i32x4.lt_s (local.get 0) (local.get 0))))
+  (func (param v128)
+    (v128.store (i32.const 0) (i64x2.lt_s (local.get 0) (local.get 0))))
+
+  (func (param v128)
+    (v128.store (i32.const 0) (i8x16.lt_u (local.get 0) (local.get 0))))
+  (func (param v128)
+    (v128.store (i32.const 0) (i16x8.lt_u (local.get 0) (local.get 0))))
+  (func (param v128)
+    (v128.store (i32.const 0) (i32x4.lt_u (local.get 0) (local.get 0))))
+
+  (func (param v128)
+    (v128.store (i32.const 0) (i8x16.gt_s (local.get 0) (local.get 0))))
+  (func (param v128)
+    (v128.store (i32.const 0) (i16x8.gt_s (local.get 0) (local.get 0))))
+  (func (param v128)
+    (v128.store (i32.const 0) (i32x4.gt_s (local.get 0) (local.get 0))))
+  (func (param v128)
+    (v128.store (i32.const 0) (i64x2.gt_s (local.get 0) (local.get 0))))
+
+  (func (param v128)
+    (v128.store (i32.const 0) (i8x16.gt_u (local.get 0) (local.get 0))))
+  (func (param v128)
+    (v128.store (i32.const 0) (i16x8.gt_u (local.get 0) (local.get 0))))
+  (func (param v128)
+    (v128.store (i32.const 0) (i32x4.gt_u (local.get 0) (local.get 0))))
+
+  (func (param v128)
+    (v128.store (i32.const 0) (f32x4.eq (local.get 0) (local.get 0))))
+  (func (param v128)
+    (v128.store (i32.const 0) (f64x2.eq (local.get 0) (local.get 0))))
+
+  (func (param v128)
+    (v128.store (i32.const 0) (f32x4.ne (local.get 0) (local.get 0))))
+  (func (param v128)
+    (v128.store (i32.const 0) (f64x2.ne (local.get 0) (local.get 0))))
+
+  (func (param v128)
+    (v128.store (i32.const 0) (f32x4.lt (local.get 0) (local.get 0))))
+  (func (param v128)
+    (v128.store (i32.const 0) (f64x2.lt (local.get 0) (local.get 0))))
+
+  (func (param v128)
+    (v128.store (i32.const 0) (f32x4.le (local.get 0) (local.get 0))))
+  (func (param v128)
+    (v128.store (i32.const 0) (f64x2.le (local.get 0) (local.get 0))))
+
+  (func (param v128)
+    (v128.store (i32.const 0) (f32x4.gt (local.get 0) (local.get 0))))
+  (func (param v128)
+    (v128.store (i32.const 0) (f64x2.gt (local.get 0) (local.get 0))))
+
+  (func (param v128)
+    (v128.store (i32.const 0) (f32x4.ge (local.get 0) (local.get 0))))
+  (func (param v128)
+    (v128.store (i32.const 0) (f64x2.ge (local.get 0) (local.get 0))))
+
+  (memory 0)
+)
+
+;; function u0:0(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @003f                               v3 = iconst.i32 0
+;; @0045                               v4 = icmp eq v2, v2
+;; @0047                               v5 = uextend.i64 v3  ; v3 = 0
+;; @0047                               v6 = global_value.i64 gv4
+;; @0047                               v7 = iadd v6, v5
+;; @0047                               store little heap v4, v7
+;; @004b                               jump block1
+;;
+;;                                 block1:
+;; @004b                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @004e                               v3 = iconst.i32 0
+;; @0054                               v4 = bitcast.i16x8 little v2
+;; @0054                               v5 = bitcast.i16x8 little v2
+;; @0054                               v6 = icmp eq v4, v5
+;; @0056                               v7 = uextend.i64 v3  ; v3 = 0
+;; @0056                               v8 = global_value.i64 gv4
+;; @0056                               v9 = iadd v8, v7
+;; @0056                               store little heap v6, v9
+;; @005a                               jump block1
+;;
+;;                                 block1:
+;; @005a                               return
+;; }
+;;
+;; function u0:2(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @005d                               v3 = iconst.i32 0
+;; @0063                               v4 = bitcast.i32x4 little v2
+;; @0063                               v5 = bitcast.i32x4 little v2
+;; @0063                               v6 = icmp eq v4, v5
+;; @0065                               v7 = uextend.i64 v3  ; v3 = 0
+;; @0065                               v8 = global_value.i64 gv4
+;; @0065                               v9 = iadd v8, v7
+;; @0065                               store little heap v6, v9
+;; @0069                               jump block1
+;;
+;;                                 block1:
+;; @0069                               return
+;; }
+;;
+;; function u0:3(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @006c                               v3 = iconst.i32 0
+;; @0072                               v4 = bitcast.i64x2 little v2
+;; @0072                               v5 = bitcast.i64x2 little v2
+;; @0072                               v6 = icmp eq v4, v5
+;; @0075                               v7 = uextend.i64 v3  ; v3 = 0
+;; @0075                               v8 = global_value.i64 gv4
+;; @0075                               v9 = iadd v8, v7
+;; @0075                               store little heap v6, v9
+;; @0079                               jump block1
+;;
+;;                                 block1:
+;; @0079                               return
+;; }
+;;
+;; function u0:4(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @007c                               v3 = iconst.i32 0
+;; @0082                               v4 = icmp ne v2, v2
+;; @0084                               v5 = uextend.i64 v3  ; v3 = 0
+;; @0084                               v6 = global_value.i64 gv4
+;; @0084                               v7 = iadd v6, v5
+;; @0084                               store little heap v4, v7
+;; @0088                               jump block1
+;;
+;;                                 block1:
+;; @0088                               return
+;; }
+;;
+;; function u0:5(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @008b                               v3 = iconst.i32 0
+;; @0091                               v4 = bitcast.i16x8 little v2
+;; @0091                               v5 = bitcast.i16x8 little v2
+;; @0091                               v6 = icmp ne v4, v5
+;; @0093                               v7 = uextend.i64 v3  ; v3 = 0
+;; @0093                               v8 = global_value.i64 gv4
+;; @0093                               v9 = iadd v8, v7
+;; @0093                               store little heap v6, v9
+;; @0097                               jump block1
+;;
+;;                                 block1:
+;; @0097                               return
+;; }
+;;
+;; function u0:6(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @009a                               v3 = iconst.i32 0
+;; @00a0                               v4 = bitcast.i32x4 little v2
+;; @00a0                               v5 = bitcast.i32x4 little v2
+;; @00a0                               v6 = icmp ne v4, v5
+;; @00a2                               v7 = uextend.i64 v3  ; v3 = 0
+;; @00a2                               v8 = global_value.i64 gv4
+;; @00a2                               v9 = iadd v8, v7
+;; @00a2                               store little heap v6, v9
+;; @00a6                               jump block1
+;;
+;;                                 block1:
+;; @00a6                               return
+;; }
+;;
+;; function u0:7(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @00a9                               v3 = iconst.i32 0
+;; @00af                               v4 = bitcast.i64x2 little v2
+;; @00af                               v5 = bitcast.i64x2 little v2
+;; @00af                               v6 = icmp ne v4, v5
+;; @00b2                               v7 = uextend.i64 v3  ; v3 = 0
+;; @00b2                               v8 = global_value.i64 gv4
+;; @00b2                               v9 = iadd v8, v7
+;; @00b2                               store little heap v6, v9
+;; @00b6                               jump block1
+;;
+;;                                 block1:
+;; @00b6                               return
+;; }
+;;
+;; function u0:8(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @00b9                               v3 = iconst.i32 0
+;; @00bf                               v4 = icmp slt v2, v2
+;; @00c1                               v5 = uextend.i64 v3  ; v3 = 0
+;; @00c1                               v6 = global_value.i64 gv4
+;; @00c1                               v7 = iadd v6, v5
+;; @00c1                               store little heap v4, v7
+;; @00c5                               jump block1
+;;
+;;                                 block1:
+;; @00c5                               return
+;; }
+;;
+;; function u0:9(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @00c8                               v3 = iconst.i32 0
+;; @00ce                               v4 = bitcast.i16x8 little v2
+;; @00ce                               v5 = bitcast.i16x8 little v2
+;; @00ce                               v6 = icmp slt v4, v5
+;; @00d0                               v7 = uextend.i64 v3  ; v3 = 0
+;; @00d0                               v8 = global_value.i64 gv4
+;; @00d0                               v9 = iadd v8, v7
+;; @00d0                               store little heap v6, v9
+;; @00d4                               jump block1
+;;
+;;                                 block1:
+;; @00d4                               return
+;; }
+;;
+;; function u0:10(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @00d7                               v3 = iconst.i32 0
+;; @00dd                               v4 = bitcast.i32x4 little v2
+;; @00dd                               v5 = bitcast.i32x4 little v2
+;; @00dd                               v6 = icmp slt v4, v5
+;; @00df                               v7 = uextend.i64 v3  ; v3 = 0
+;; @00df                               v8 = global_value.i64 gv4
+;; @00df                               v9 = iadd v8, v7
+;; @00df                               store little heap v6, v9
+;; @00e3                               jump block1
+;;
+;;                                 block1:
+;; @00e3                               return
+;; }
+;;
+;; function u0:11(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @00e6                               v3 = iconst.i32 0
+;; @00ec                               v4 = bitcast.i64x2 little v2
+;; @00ec                               v5 = bitcast.i64x2 little v2
+;; @00ec                               v6 = icmp slt v4, v5
+;; @00ef                               v7 = uextend.i64 v3  ; v3 = 0
+;; @00ef                               v8 = global_value.i64 gv4
+;; @00ef                               v9 = iadd v8, v7
+;; @00ef                               store little heap v6, v9
+;; @00f3                               jump block1
+;;
+;;                                 block1:
+;; @00f3                               return
+;; }
+;;
+;; function u0:12(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @00f6                               v3 = iconst.i32 0
+;; @00fc                               v4 = icmp ult v2, v2
+;; @00fe                               v5 = uextend.i64 v3  ; v3 = 0
+;; @00fe                               v6 = global_value.i64 gv4
+;; @00fe                               v7 = iadd v6, v5
+;; @00fe                               store little heap v4, v7
+;; @0102                               jump block1
+;;
+;;                                 block1:
+;; @0102                               return
+;; }
+;;
+;; function u0:13(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @0105                               v3 = iconst.i32 0
+;; @010b                               v4 = bitcast.i16x8 little v2
+;; @010b                               v5 = bitcast.i16x8 little v2
+;; @010b                               v6 = icmp ult v4, v5
+;; @010d                               v7 = uextend.i64 v3  ; v3 = 0
+;; @010d                               v8 = global_value.i64 gv4
+;; @010d                               v9 = iadd v8, v7
+;; @010d                               store little heap v6, v9
+;; @0111                               jump block1
+;;
+;;                                 block1:
+;; @0111                               return
+;; }
+;;
+;; function u0:14(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @0114                               v3 = iconst.i32 0
+;; @011a                               v4 = bitcast.i32x4 little v2
+;; @011a                               v5 = bitcast.i32x4 little v2
+;; @011a                               v6 = icmp ult v4, v5
+;; @011c                               v7 = uextend.i64 v3  ; v3 = 0
+;; @011c                               v8 = global_value.i64 gv4
+;; @011c                               v9 = iadd v8, v7
+;; @011c                               store little heap v6, v9
+;; @0120                               jump block1
+;;
+;;                                 block1:
+;; @0120                               return
+;; }
+;;
+;; function u0:15(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @0123                               v3 = iconst.i32 0
+;; @0129                               v4 = icmp sgt v2, v2
+;; @012b                               v5 = uextend.i64 v3  ; v3 = 0
+;; @012b                               v6 = global_value.i64 gv4
+;; @012b                               v7 = iadd v6, v5
+;; @012b                               store little heap v4, v7
+;; @012f                               jump block1
+;;
+;;                                 block1:
+;; @012f                               return
+;; }
+;;
+;; function u0:16(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @0132                               v3 = iconst.i32 0
+;; @0138                               v4 = bitcast.i16x8 little v2
+;; @0138                               v5 = bitcast.i16x8 little v2
+;; @0138                               v6 = icmp sgt v4, v5
+;; @013a                               v7 = uextend.i64 v3  ; v3 = 0
+;; @013a                               v8 = global_value.i64 gv4
+;; @013a                               v9 = iadd v8, v7
+;; @013a                               store little heap v6, v9
+;; @013e                               jump block1
+;;
+;;                                 block1:
+;; @013e                               return
+;; }
+;;
+;; function u0:17(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @0141                               v3 = iconst.i32 0
+;; @0147                               v4 = bitcast.i32x4 little v2
+;; @0147                               v5 = bitcast.i32x4 little v2
+;; @0147                               v6 = icmp sgt v4, v5
+;; @0149                               v7 = uextend.i64 v3  ; v3 = 0
+;; @0149                               v8 = global_value.i64 gv4
+;; @0149                               v9 = iadd v8, v7
+;; @0149                               store little heap v6, v9
+;; @014d                               jump block1
+;;
+;;                                 block1:
+;; @014d                               return
+;; }
+;;
+;; function u0:18(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @0150                               v3 = iconst.i32 0
+;; @0156                               v4 = bitcast.i64x2 little v2
+;; @0156                               v5 = bitcast.i64x2 little v2
+;; @0156                               v6 = icmp sgt v4, v5
+;; @0159                               v7 = uextend.i64 v3  ; v3 = 0
+;; @0159                               v8 = global_value.i64 gv4
+;; @0159                               v9 = iadd v8, v7
+;; @0159                               store little heap v6, v9
+;; @015d                               jump block1
+;;
+;;                                 block1:
+;; @015d                               return
+;; }
+;;
+;; function u0:19(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @0160                               v3 = iconst.i32 0
+;; @0166                               v4 = icmp ugt v2, v2
+;; @0168                               v5 = uextend.i64 v3  ; v3 = 0
+;; @0168                               v6 = global_value.i64 gv4
+;; @0168                               v7 = iadd v6, v5
+;; @0168                               store little heap v4, v7
+;; @016c                               jump block1
+;;
+;;                                 block1:
+;; @016c                               return
+;; }
+;;
+;; function u0:20(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @016f                               v3 = iconst.i32 0
+;; @0175                               v4 = bitcast.i16x8 little v2
+;; @0175                               v5 = bitcast.i16x8 little v2
+;; @0175                               v6 = icmp ugt v4, v5
+;; @0177                               v7 = uextend.i64 v3  ; v3 = 0
+;; @0177                               v8 = global_value.i64 gv4
+;; @0177                               v9 = iadd v8, v7
+;; @0177                               store little heap v6, v9
+;; @017b                               jump block1
+;;
+;;                                 block1:
+;; @017b                               return
+;; }
+;;
+;; function u0:21(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @017e                               v3 = iconst.i32 0
+;; @0184                               v4 = bitcast.i32x4 little v2
+;; @0184                               v5 = bitcast.i32x4 little v2
+;; @0184                               v6 = icmp ugt v4, v5
+;; @0186                               v7 = uextend.i64 v3  ; v3 = 0
+;; @0186                               v8 = global_value.i64 gv4
+;; @0186                               v9 = iadd v8, v7
+;; @0186                               store little heap v6, v9
+;; @018a                               jump block1
+;;
+;;                                 block1:
+;; @018a                               return
+;; }
+;;
+;; function u0:22(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @018d                               v3 = iconst.i32 0
+;; @0193                               v4 = bitcast.f32x4 little v2
+;; @0193                               v5 = bitcast.f32x4 little v2
+;; @0193                               v6 = fcmp eq v4, v5
+;; @0195                               v7 = uextend.i64 v3  ; v3 = 0
+;; @0195                               v8 = global_value.i64 gv4
+;; @0195                               v9 = iadd v8, v7
+;; @0195                               store little heap v6, v9
+;; @0199                               jump block1
+;;
+;;                                 block1:
+;; @0199                               return
+;; }
+;;
+;; function u0:23(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @019c                               v3 = iconst.i32 0
+;; @01a2                               v4 = bitcast.f64x2 little v2
+;; @01a2                               v5 = bitcast.f64x2 little v2
+;; @01a2                               v6 = fcmp eq v4, v5
+;; @01a4                               v7 = uextend.i64 v3  ; v3 = 0
+;; @01a4                               v8 = global_value.i64 gv4
+;; @01a4                               v9 = iadd v8, v7
+;; @01a4                               store little heap v6, v9
+;; @01a8                               jump block1
+;;
+;;                                 block1:
+;; @01a8                               return
+;; }
+;;
+;; function u0:24(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @01ab                               v3 = iconst.i32 0
+;; @01b1                               v4 = bitcast.f32x4 little v2
+;; @01b1                               v5 = bitcast.f32x4 little v2
+;; @01b1                               v6 = fcmp ne v4, v5
+;; @01b3                               v7 = uextend.i64 v3  ; v3 = 0
+;; @01b3                               v8 = global_value.i64 gv4
+;; @01b3                               v9 = iadd v8, v7
+;; @01b3                               store little heap v6, v9
+;; @01b7                               jump block1
+;;
+;;                                 block1:
+;; @01b7                               return
+;; }
+;;
+;; function u0:25(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @01ba                               v3 = iconst.i32 0
+;; @01c0                               v4 = bitcast.f64x2 little v2
+;; @01c0                               v5 = bitcast.f64x2 little v2
+;; @01c0                               v6 = fcmp ne v4, v5
+;; @01c2                               v7 = uextend.i64 v3  ; v3 = 0
+;; @01c2                               v8 = global_value.i64 gv4
+;; @01c2                               v9 = iadd v8, v7
+;; @01c2                               store little heap v6, v9
+;; @01c6                               jump block1
+;;
+;;                                 block1:
+;; @01c6                               return
+;; }
+;;
+;; function u0:26(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @01c9                               v3 = iconst.i32 0
+;; @01cf                               v4 = bitcast.f32x4 little v2
+;; @01cf                               v5 = bitcast.f32x4 little v2
+;; @01cf                               v6 = fcmp lt v4, v5
+;; @01d1                               v7 = uextend.i64 v3  ; v3 = 0
+;; @01d1                               v8 = global_value.i64 gv4
+;; @01d1                               v9 = iadd v8, v7
+;; @01d1                               store little heap v6, v9
+;; @01d5                               jump block1
+;;
+;;                                 block1:
+;; @01d5                               return
+;; }
+;;
+;; function u0:27(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @01d8                               v3 = iconst.i32 0
+;; @01de                               v4 = bitcast.f64x2 little v2
+;; @01de                               v5 = bitcast.f64x2 little v2
+;; @01de                               v6 = fcmp lt v4, v5
+;; @01e0                               v7 = uextend.i64 v3  ; v3 = 0
+;; @01e0                               v8 = global_value.i64 gv4
+;; @01e0                               v9 = iadd v8, v7
+;; @01e0                               store little heap v6, v9
+;; @01e4                               jump block1
+;;
+;;                                 block1:
+;; @01e4                               return
+;; }
+;;
+;; function u0:28(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @01e7                               v3 = iconst.i32 0
+;; @01ed                               v4 = bitcast.f32x4 little v2
+;; @01ed                               v5 = bitcast.f32x4 little v2
+;; @01ed                               v6 = fcmp le v4, v5
+;; @01ef                               v7 = uextend.i64 v3  ; v3 = 0
+;; @01ef                               v8 = global_value.i64 gv4
+;; @01ef                               v9 = iadd v8, v7
+;; @01ef                               store little heap v6, v9
+;; @01f3                               jump block1
+;;
+;;                                 block1:
+;; @01f3                               return
+;; }
+;;
+;; function u0:29(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @01f6                               v3 = iconst.i32 0
+;; @01fc                               v4 = bitcast.f64x2 little v2
+;; @01fc                               v5 = bitcast.f64x2 little v2
+;; @01fc                               v6 = fcmp le v4, v5
+;; @01fe                               v7 = uextend.i64 v3  ; v3 = 0
+;; @01fe                               v8 = global_value.i64 gv4
+;; @01fe                               v9 = iadd v8, v7
+;; @01fe                               store little heap v6, v9
+;; @0202                               jump block1
+;;
+;;                                 block1:
+;; @0202                               return
+;; }
+;;
+;; function u0:30(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @0205                               v3 = iconst.i32 0
+;; @020b                               v4 = bitcast.f32x4 little v2
+;; @020b                               v5 = bitcast.f32x4 little v2
+;; @020b                               v6 = fcmp gt v4, v5
+;; @020d                               v7 = uextend.i64 v3  ; v3 = 0
+;; @020d                               v8 = global_value.i64 gv4
+;; @020d                               v9 = iadd v8, v7
+;; @020d                               store little heap v6, v9
+;; @0211                               jump block1
+;;
+;;                                 block1:
+;; @0211                               return
+;; }
+;;
+;; function u0:31(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @0214                               v3 = iconst.i32 0
+;; @021a                               v4 = bitcast.f64x2 little v2
+;; @021a                               v5 = bitcast.f64x2 little v2
+;; @021a                               v6 = fcmp gt v4, v5
+;; @021c                               v7 = uextend.i64 v3  ; v3 = 0
+;; @021c                               v8 = global_value.i64 gv4
+;; @021c                               v9 = iadd v8, v7
+;; @021c                               store little heap v6, v9
+;; @0220                               jump block1
+;;
+;;                                 block1:
+;; @0220                               return
+;; }
+;;
+;; function u0:32(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @0223                               v3 = iconst.i32 0
+;; @0229                               v4 = bitcast.f32x4 little v2
+;; @0229                               v5 = bitcast.f32x4 little v2
+;; @0229                               v6 = fcmp ge v4, v5
+;; @022b                               v7 = uextend.i64 v3  ; v3 = 0
+;; @022b                               v8 = global_value.i64 gv4
+;; @022b                               v9 = iadd v8, v7
+;; @022b                               store little heap v6, v9
+;; @022f                               jump block1
+;;
+;;                                 block1:
+;; @022f                               return
+;; }
+;;
+;; function u0:33(i64 vmctx, i64, i8x16) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly checked gv3+96
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i8x16):
+;; @0232                               v3 = iconst.i32 0
+;; @0238                               v4 = bitcast.f64x2 little v2
+;; @0238                               v5 = bitcast.f64x2 little v2
+;; @0238                               v6 = fcmp ge v4, v5
+;; @023a                               v7 = uextend.i64 v3  ; v3 = 0
+;; @023a                               v8 = global_value.i64 gv4
+;; @023a                               v9 = iadd v8, v7
+;; @023a                               store little heap v6, v9
+;; @023e                               jump block1
+;;
+;;                                 block1:
+;; @023e                               return
+;; }
diff --git a/tests/disas/simd.wat b/tests/disas/simd.wat
new file mode 100644
index 000000000000..1e8cb36c068a
--- /dev/null
+++ b/tests/disas/simd.wat
@@ -0,0 +1,101 @@
+;;! target = "x86_64"
+
+(module
+  (func $test_splat (result i32)
+    i32.const 42
+    i32x4.splat
+    i32x4.extract_lane 0
+  )
+
+  (func $test_insert_lane (result i32)
+      v128.const i64x2 0 0
+      i32.const 99
+      i32x4.replace_lane 1
+      i32x4.extract_lane 1
+  )
+
+  (func $test_const (result i32)
+    v128.const i32x4 1 2 3 4
+    i32x4.extract_lane 3
+  )
+
+  (func $test_locals (local i32 v128)
+    local.get 0
+    i32x4.splat
+    local.set 1
+  )
+
+  (export "test_splat" (func $test_splat))
+  (export "test_insert_lane" (func $test_insert_lane))
+  (export "test_const" (func $test_const))
+)
+
+;; function u0:0(i64 vmctx, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @004e                               v3 = iconst.i32 42
+;; @0050                               v4 = splat.i32x4 v3  ; v3 = 42
+;; @0052                               v5 = extractlane v4, 0
+;; @0055                               jump block1(v5)
+;;
+;;                                 block1(v2: i32):
+;; @0055                               return v2
+;; }
+;;
+;; function u0:1(i64 vmctx, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     const0 = 0x00000000000000000000000000000000
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @0058                               v3 = vconst.i8x16 const0
+;; @006a                               v4 = iconst.i32 99
+;; @006d                               v5 = bitcast.i32x4 little v3  ; v3 = const0
+;; @006d                               v6 = insertlane v5, v4, 1  ; v4 = 99
+;; @0070                               v7 = extractlane v6, 1
+;; @0073                               jump block1(v7)
+;;
+;;                                 block1(v2: i32):
+;; @0073                               return v2
+;; }
+;;
+;; function u0:2(i64 vmctx, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     const0 = 0x00000004000000030000000200000001
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @0076                               v3 = vconst.i8x16 const0
+;; @0088                               v4 = bitcast.i32x4 little v3  ; v3 = const0
+;; @0088                               v5 = extractlane v4, 3
+;; @008b                               jump block1(v5)
+;;
+;;                                 block1(v2: i32):
+;; @008b                               return v2
+;; }
+;;
+;; function u0:3(i64 vmctx, i64) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     const0 = 0x00000000000000000000000000000000
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @008e                               v2 = iconst.i32 0
+;; @0090                               v3 = vconst.i8x16 const0
+;; @0094                               v4 = splat.i32x4 v2  ; v2 = 0
+;; @0096                               v5 = bitcast.i8x16 little v4
+;; @0098                               jump block1
+;;
+;;                                 block1:
+;; @0098                               return
+;; }
diff --git a/tests/disas/simple.wat b/tests/disas/simple.wat
new file mode 100644
index 000000000000..5eea958467ba
--- /dev/null
+++ b/tests/disas/simple.wat
@@ -0,0 +1,62 @@
+;;! target = "x86_64"
+
+(module
+    (func $small1 (param i32) (result i32)
+        (i32.add (local.get 0) (i32.const 1))
+    )
+
+    (func $small2 (param i32) (result i32)
+        (return (i32.add (local.get 0) (i32.const 1)))
+    )
+
+    (func $infloop (result i32)
+        (local i32)
+        (loop (result i32)
+            (i32.add (local.get 0) (i32.const 1))
+            (local.set 0)
+            (br 0)
+        )
+    )
+)
+;; function u0:0(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0021                               v4 = iconst.i32 1
+;; @0023                               v5 = iadd v2, v4  ; v4 = 1
+;; @0024                               jump block1(v5)
+;;
+;;                                 block1(v3: i32):
+;; @0024                               return v3
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0029                               v4 = iconst.i32 1
+;; @002b                               v5 = iadd v2, v4  ; v4 = 1
+;; @002c                               return v5
+;; }
+;;
+;; function u0:2(i64 vmctx, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @0030                               v3 = iconst.i32 0
+;; @0032                               jump block2(v3)  ; v3 = 0
+;;
+;;                                 block2(v5: i32):
+;; @0036                               v6 = iconst.i32 1
+;; @0038                               v7 = iadd v5, v6  ; v6 = 1
+;; @003b                               jump block2(v7)
+;; }
diff --git a/tests/disas/table-copy.wat b/tests/disas/table-copy.wat
new file mode 100644
index 000000000000..c596de21a3ff
--- /dev/null
+++ b/tests/disas/table-copy.wat
@@ -0,0 +1,103 @@
+;;! target = "x86_64"
+
+(module $n
+  (table $t (import "m" "t") 6 funcref)
+
+  (func $i (param i32 i32 i32 i32 i32 i32) (result i32) (local.get 3))
+  (func $j (param i32 i32 i32 i32 i32 i32) (result i32) (local.get 4))
+  (func $k (param i32 i32 i32 i32 i32 i32) (result i32) (local.get 5))
+
+  (table $u (export "u") funcref (elem $i $j $k $i $j $k))
+
+  (func (export "copy_to_t_from_u") (param i32 i32 i32 i32) (result i32)
+    local.get 0
+    local.get 1
+    local.get 2
+    local.get 3
+    table.copy $t $u)
+
+  (func (export "copy_to_u_from_t") (param i32 i32 i32 i32) (result i32)
+    local.get 0
+    local.get 1
+    local.get 2
+    local.get 3
+    table.copy $u $t))
+
+;; function u0:0(i64 vmctx, i64, i32, i32, i32, i32, i32, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32, v6: i32, v7: i32):
+;; @007b                               jump block1(v5)
+;;
+;;                                 block1(v8: i32):
+;; @007b                               return v8
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32, i32, i32, i32, i32, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32, v6: i32, v7: i32):
+;; @0080                               jump block1(v6)
+;;
+;;                                 block1(v8: i32):
+;; @0080                               return v8
+;; }
+;;
+;; function u0:2(i64 vmctx, i64, i32, i32, i32, i32, i32, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32, v6: i32, v7: i32):
+;; @0085                               jump block1(v7)
+;;
+;;                                 block1(v8: i32):
+;; @0085                               return v8
+;; }
+;;
+;; function u0:3(i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     sig0 = (i64 vmctx, i32 uext, i32 uext, i32 uext, i32 uext, i32 uext) system_v
+;;     fn0 = colocated u1:1 sig0
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
+;; @0090                               v7 = iconst.i32 0
+;; @0090                               v8 = iconst.i32 1
+;; @0090                               v9 = global_value.i64 gv3
+;; @0090                               call fn0(v9, v7, v8, v3, v4, v5)  ; v7 = 0, v8 = 1
+;; @0094                               jump block1(v2)
+;;
+;;                                 block1(v6: i32):
+;; @0094                               return v6
+;; }
+;;
+;; function u0:4(i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     sig0 = (i64 vmctx, i32 uext, i32 uext, i32 uext, i32 uext, i32 uext) system_v
+;;     fn0 = colocated u1:1 sig0
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
+;; @009f                               v7 = iconst.i32 1
+;; @009f                               v8 = iconst.i32 0
+;; @009f                               v9 = global_value.i64 gv3
+;; @009f                               call fn0(v9, v7, v8, v3, v4, v5)  ; v7 = 1, v8 = 0
+;; @00a3                               jump block1(v2)
+;;
+;;                                 block1(v6: i32):
+;; @00a3                               return v6
+;; }
diff --git a/tests/disas/table-get-fixed-size.wat b/tests/disas/table-get-fixed-size.wat
new file mode 100644
index 000000000000..4024ed37ca8f
--- /dev/null
+++ b/tests/disas/table-get-fixed-size.wat
@@ -0,0 +1,215 @@
+;;! target = "x86_64"
+;;! test = "optimize"
+;;! flags = "-O opt-level=0"
+
+;; Test basic code generation for table WebAssembly instructions on
+;; non-resizeable tables. Use optimized but with `opt-level=0` to legalize away
+;; macro instructions.
+
+(module
+  (table (export "table") 7 7 externref)
+  (func (export "table.get.const") (result externref)
+    i32.const 0
+    table.get 0)
+  (func (export "table.get.var") (param i32) (result externref)
+    local.get 0
+    table.get 0))
+
+;; function u0:0(i64 vmctx, i64) -> i32 tail {
+;;     ss0 = explicit_slot 4, align = 4
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly gv3+88
+;;     sig0 = (i64 vmctx, i32) -> i32 system_v
+;;     fn0 = colocated u1:26 sig0
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @0052                               v3 = iconst.i32 0
+;; @0054                               v4 = iconst.i32 7
+;; @0054                               v5 = icmp uge v3, v4  ; v3 = 0, v4 = 7
+;; @0054                               v6 = uextend.i64 v3  ; v3 = 0
+;; @0054                               v7 = load.i64 notrap aligned readonly v0+88
+;;                                     v51 = iconst.i64 2
+;; @0054                               v8 = ishl v6, v51  ; v51 = 2
+;; @0054                               v9 = iadd v7, v8
+;; @0054                               v10 = iconst.i64 0
+;; @0054                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @0054                               v12 = load.i32 table_oob aligned table v11
+;;                                     v52 = stack_addr.i64 ss0
+;;                                     store notrap v12, v52
+;;                                     v53 = stack_addr.i64 ss0
+;;                                     v49 = load.i32 notrap v53
+;;                                     v54 = iconst.i32 0
+;; @0054                               v13 = icmp eq v49, v54  ; v54 = 0
+;; @0054                               brif v13, block5, block2
+;;
+;;                                 block2:
+;; @0054                               v15 = load.i64 notrap aligned v0+56
+;; @0054                               v16 = load.i64 notrap aligned v15
+;; @0054                               v17 = load.i64 notrap aligned v15+8
+;; @0054                               v18 = icmp eq v16, v17
+;; @0054                               brif v18, block3, block4
+;;
+;;                                 block4:
+;; @0054                               v20 = load.i64 notrap aligned readonly v0+40
+;; @0054                               v21 = load.i64 notrap aligned readonly v0+48
+;;                                     v55 = stack_addr.i64 ss0
+;;                                     v48 = load.i32 notrap v55
+;; @0054                               v22 = uextend.i64 v48
+;; @0054                               v23 = iconst.i64 8
+;; @0054                               v24 = uadd_overflow_trap v22, v23, user65535  ; v23 = 8
+;; @0054                               v25 = iconst.i64 8
+;; @0054                               v26 = uadd_overflow_trap v24, v25, user65535  ; v25 = 8
+;; @0054                               v27 = icmp ult v26, v21
+;; @0054                               brif v27, block7, block6
+;;
+;;                                 block6 cold:
+;; @0054                               trap user65535
+;;
+;;                                 block7:
+;; @0054                               v28 = iadd.i64 v20, v24
+;; @0054                               v29 = load.i64 notrap aligned v28
+;;                                     v56 = iconst.i64 1
+;; @0054                               v30 = iadd v29, v56  ; v56 = 1
+;; @0054                               v32 = load.i64 notrap aligned readonly v0+40
+;; @0054                               v33 = load.i64 notrap aligned readonly v0+48
+;;                                     v57 = stack_addr.i64 ss0
+;;                                     v47 = load.i32 notrap v57
+;; @0054                               v34 = uextend.i64 v47
+;; @0054                               v35 = iconst.i64 8
+;; @0054                               v36 = uadd_overflow_trap v34, v35, user65535  ; v35 = 8
+;; @0054                               v37 = iconst.i64 8
+;; @0054                               v38 = uadd_overflow_trap v36, v37, user65535  ; v37 = 8
+;; @0054                               v39 = icmp ult v38, v33
+;; @0054                               brif v39, block9, block8
+;;
+;;                                 block8 cold:
+;; @0054                               trap user65535
+;;
+;;                                 block9:
+;; @0054                               v40 = iadd.i64 v32, v36
+;; @0054                               store.i64 notrap aligned v30, v40
+;;                                     v58 = stack_addr.i64 ss0
+;;                                     v46 = load.i32 notrap v58
+;; @0054                               store notrap aligned v46, v16
+;;                                     v59 = iconst.i64 4
+;; @0054                               v41 = iadd.i64 v16, v59  ; v59 = 4
+;; @0054                               store notrap aligned v41, v15
+;; @0054                               jump block5
+;;
+;;                                 block3 cold:
+;;                                     v60 = stack_addr.i64 ss0
+;;                                     v45 = load.i32 notrap v60
+;; @0054                               v43 = call fn0(v0, v45), stack_map=[i32 @ ss0+0]
+;; @0054                               jump block5
+;;
+;;                                 block5:
+;;                                     v61 = stack_addr.i64 ss0
+;;                                     v44 = load.i32 notrap v61
+;; @0056                               jump block1
+;;
+;;                                 block1:
+;; @0056                               return v44
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     ss0 = explicit_slot 4, align = 4
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly gv3+88
+;;     sig0 = (i64 vmctx, i32) -> i32 system_v
+;;     fn0 = colocated u1:26 sig0
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @005b                               v4 = iconst.i32 7
+;; @005b                               v5 = icmp uge v2, v4  ; v4 = 7
+;; @005b                               v6 = uextend.i64 v2
+;; @005b                               v7 = load.i64 notrap aligned readonly v0+88
+;;                                     v51 = iconst.i64 2
+;; @005b                               v8 = ishl v6, v51  ; v51 = 2
+;; @005b                               v9 = iadd v7, v8
+;; @005b                               v10 = iconst.i64 0
+;; @005b                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @005b                               v12 = load.i32 table_oob aligned table v11
+;;                                     v52 = stack_addr.i64 ss0
+;;                                     store notrap v12, v52
+;;                                     v53 = stack_addr.i64 ss0
+;;                                     v49 = load.i32 notrap v53
+;;                                     v54 = iconst.i32 0
+;; @005b                               v13 = icmp eq v49, v54  ; v54 = 0
+;; @005b                               brif v13, block5, block2
+;;
+;;                                 block2:
+;; @005b                               v15 = load.i64 notrap aligned v0+56
+;; @005b                               v16 = load.i64 notrap aligned v15
+;; @005b                               v17 = load.i64 notrap aligned v15+8
+;; @005b                               v18 = icmp eq v16, v17
+;; @005b                               brif v18, block3, block4
+;;
+;;                                 block4:
+;; @005b                               v20 = load.i64 notrap aligned readonly v0+40
+;; @005b                               v21 = load.i64 notrap aligned readonly v0+48
+;;                                     v55 = stack_addr.i64 ss0
+;;                                     v48 = load.i32 notrap v55
+;; @005b                               v22 = uextend.i64 v48
+;; @005b                               v23 = iconst.i64 8
+;; @005b                               v24 = uadd_overflow_trap v22, v23, user65535  ; v23 = 8
+;; @005b                               v25 = iconst.i64 8
+;; @005b                               v26 = uadd_overflow_trap v24, v25, user65535  ; v25 = 8
+;; @005b                               v27 = icmp ult v26, v21
+;; @005b                               brif v27, block7, block6
+;;
+;;                                 block6 cold:
+;; @005b                               trap user65535
+;;
+;;                                 block7:
+;; @005b                               v28 = iadd.i64 v20, v24
+;; @005b                               v29 = load.i64 notrap aligned v28
+;;                                     v56 = iconst.i64 1
+;; @005b                               v30 = iadd v29, v56  ; v56 = 1
+;; @005b                               v32 = load.i64 notrap aligned readonly v0+40
+;; @005b                               v33 = load.i64 notrap aligned readonly v0+48
+;;                                     v57 = stack_addr.i64 ss0
+;;                                     v47 = load.i32 notrap v57
+;; @005b                               v34 = uextend.i64 v47
+;; @005b                               v35 = iconst.i64 8
+;; @005b                               v36 = uadd_overflow_trap v34, v35, user65535  ; v35 = 8
+;; @005b                               v37 = iconst.i64 8
+;; @005b                               v38 = uadd_overflow_trap v36, v37, user65535  ; v37 = 8
+;; @005b                               v39 = icmp ult v38, v33
+;; @005b                               brif v39, block9, block8
+;;
+;;                                 block8 cold:
+;; @005b                               trap user65535
+;;
+;;                                 block9:
+;; @005b                               v40 = iadd.i64 v32, v36
+;; @005b                               store.i64 notrap aligned v30, v40
+;;                                     v58 = stack_addr.i64 ss0
+;;                                     v46 = load.i32 notrap v58
+;; @005b                               store notrap aligned v46, v16
+;;                                     v59 = iconst.i64 4
+;; @005b                               v41 = iadd.i64 v16, v59  ; v59 = 4
+;; @005b                               store notrap aligned v41, v15
+;; @005b                               jump block5
+;;
+;;                                 block3 cold:
+;;                                     v60 = stack_addr.i64 ss0
+;;                                     v45 = load.i32 notrap v60
+;; @005b                               v43 = call fn0(v0, v45), stack_map=[i32 @ ss0+0]
+;; @005b                               jump block5
+;;
+;;                                 block5:
+;;                                     v61 = stack_addr.i64 ss0
+;;                                     v44 = load.i32 notrap v61
+;; @005d                               jump block1
+;;
+;;                                 block1:
+;; @005d                               return v44
+;; }
diff --git a/tests/disas/table-get.wat b/tests/disas/table-get.wat
new file mode 100644
index 000000000000..2a2207b1a7f3
--- /dev/null
+++ b/tests/disas/table-get.wat
@@ -0,0 +1,216 @@
+;;! target = "x86_64"
+;;! test = "optimize"
+;;! flags = "-O opt-level=0"
+
+;; Test basic code generation for table WebAssembly instructions.
+;; Use optimization but with `opt-level=0` to legalize away table_addr instructions.
+
+(module
+  (table (export "table") 1 externref)
+  (func (export "table.get.const") (result externref)
+    i32.const 0
+    table.get 0)
+  (func (export "table.get.var") (param i32) (result externref)
+    local.get 0
+    table.get 0))
+
+;; function u0:0(i64 vmctx, i64) -> i32 tail {
+;;     ss0 = explicit_slot 4, align = 4
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+88
+;;     gv5 = load.i32 notrap aligned gv3+96
+;;     sig0 = (i64 vmctx, i32) -> i32 system_v
+;;     fn0 = colocated u1:26 sig0
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @0051                               v3 = iconst.i32 0
+;; @0053                               v4 = load.i32 notrap aligned v0+96
+;; @0053                               v5 = icmp uge v3, v4  ; v3 = 0
+;; @0053                               v6 = uextend.i64 v3  ; v3 = 0
+;; @0053                               v7 = load.i64 notrap aligned v0+88
+;;                                     v52 = iconst.i64 2
+;; @0053                               v8 = ishl v6, v52  ; v52 = 2
+;; @0053                               v9 = iadd v7, v8
+;; @0053                               v10 = iconst.i64 0
+;; @0053                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @0053                               v12 = load.i32 table_oob aligned table v11
+;;                                     v53 = stack_addr.i64 ss0
+;;                                     store notrap v12, v53
+;;                                     v54 = stack_addr.i64 ss0
+;;                                     v49 = load.i32 notrap v54
+;;                                     v55 = iconst.i32 0
+;; @0053                               v13 = icmp eq v49, v55  ; v55 = 0
+;; @0053                               brif v13, block5, block2
+;;
+;;                                 block2:
+;; @0053                               v15 = load.i64 notrap aligned v0+56
+;; @0053                               v16 = load.i64 notrap aligned v15
+;; @0053                               v17 = load.i64 notrap aligned v15+8
+;; @0053                               v18 = icmp eq v16, v17
+;; @0053                               brif v18, block3, block4
+;;
+;;                                 block4:
+;; @0053                               v20 = load.i64 notrap aligned readonly v0+40
+;; @0053                               v21 = load.i64 notrap aligned readonly v0+48
+;;                                     v56 = stack_addr.i64 ss0
+;;                                     v48 = load.i32 notrap v56
+;; @0053                               v22 = uextend.i64 v48
+;; @0053                               v23 = iconst.i64 8
+;; @0053                               v24 = uadd_overflow_trap v22, v23, user65535  ; v23 = 8
+;; @0053                               v25 = iconst.i64 8
+;; @0053                               v26 = uadd_overflow_trap v24, v25, user65535  ; v25 = 8
+;; @0053                               v27 = icmp ult v26, v21
+;; @0053                               brif v27, block7, block6
+;;
+;;                                 block6 cold:
+;; @0053                               trap user65535
+;;
+;;                                 block7:
+;; @0053                               v28 = iadd.i64 v20, v24
+;; @0053                               v29 = load.i64 notrap aligned v28
+;;                                     v57 = iconst.i64 1
+;; @0053                               v30 = iadd v29, v57  ; v57 = 1
+;; @0053                               v32 = load.i64 notrap aligned readonly v0+40
+;; @0053                               v33 = load.i64 notrap aligned readonly v0+48
+;;                                     v58 = stack_addr.i64 ss0
+;;                                     v47 = load.i32 notrap v58
+;; @0053                               v34 = uextend.i64 v47
+;; @0053                               v35 = iconst.i64 8
+;; @0053                               v36 = uadd_overflow_trap v34, v35, user65535  ; v35 = 8
+;; @0053                               v37 = iconst.i64 8
+;; @0053                               v38 = uadd_overflow_trap v36, v37, user65535  ; v37 = 8
+;; @0053                               v39 = icmp ult v38, v33
+;; @0053                               brif v39, block9, block8
+;;
+;;                                 block8 cold:
+;; @0053                               trap user65535
+;;
+;;                                 block9:
+;; @0053                               v40 = iadd.i64 v32, v36
+;; @0053                               store.i64 notrap aligned v30, v40
+;;                                     v59 = stack_addr.i64 ss0
+;;                                     v46 = load.i32 notrap v59
+;; @0053                               store notrap aligned v46, v16
+;;                                     v60 = iconst.i64 4
+;; @0053                               v41 = iadd.i64 v16, v60  ; v60 = 4
+;; @0053                               store notrap aligned v41, v15
+;; @0053                               jump block5
+;;
+;;                                 block3 cold:
+;;                                     v61 = stack_addr.i64 ss0
+;;                                     v45 = load.i32 notrap v61
+;; @0053                               v43 = call fn0(v0, v45), stack_map=[i32 @ ss0+0]
+;; @0053                               jump block5
+;;
+;;                                 block5:
+;;                                     v62 = stack_addr.i64 ss0
+;;                                     v44 = load.i32 notrap v62
+;; @0055                               jump block1
+;;
+;;                                 block1:
+;; @0055                               return v44
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32) -> i32 tail {
+;;     ss0 = explicit_slot 4, align = 4
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+88
+;;     gv5 = load.i32 notrap aligned gv3+96
+;;     sig0 = (i64 vmctx, i32) -> i32 system_v
+;;     fn0 = colocated u1:26 sig0
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @005a                               v4 = load.i32 notrap aligned v0+96
+;; @005a                               v5 = icmp uge v2, v4
+;; @005a                               v6 = uextend.i64 v2
+;; @005a                               v7 = load.i64 notrap aligned v0+88
+;;                                     v52 = iconst.i64 2
+;; @005a                               v8 = ishl v6, v52  ; v52 = 2
+;; @005a                               v9 = iadd v7, v8
+;; @005a                               v10 = iconst.i64 0
+;; @005a                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @005a                               v12 = load.i32 table_oob aligned table v11
+;;                                     v53 = stack_addr.i64 ss0
+;;                                     store notrap v12, v53
+;;                                     v54 = stack_addr.i64 ss0
+;;                                     v49 = load.i32 notrap v54
+;;                                     v55 = iconst.i32 0
+;; @005a                               v13 = icmp eq v49, v55  ; v55 = 0
+;; @005a                               brif v13, block5, block2
+;;
+;;                                 block2:
+;; @005a                               v15 = load.i64 notrap aligned v0+56
+;; @005a                               v16 = load.i64 notrap aligned v15
+;; @005a                               v17 = load.i64 notrap aligned v15+8
+;; @005a                               v18 = icmp eq v16, v17
+;; @005a                               brif v18, block3, block4
+;;
+;;                                 block4:
+;; @005a                               v20 = load.i64 notrap aligned readonly v0+40
+;; @005a                               v21 = load.i64 notrap aligned readonly v0+48
+;;                                     v56 = stack_addr.i64 ss0
+;;                                     v48 = load.i32 notrap v56
+;; @005a                               v22 = uextend.i64 v48
+;; @005a                               v23 = iconst.i64 8
+;; @005a                               v24 = uadd_overflow_trap v22, v23, user65535  ; v23 = 8
+;; @005a                               v25 = iconst.i64 8
+;; @005a                               v26 = uadd_overflow_trap v24, v25, user65535  ; v25 = 8
+;; @005a                               v27 = icmp ult v26, v21
+;; @005a                               brif v27, block7, block6
+;;
+;;                                 block6 cold:
+;; @005a                               trap user65535
+;;
+;;                                 block7:
+;; @005a                               v28 = iadd.i64 v20, v24
+;; @005a                               v29 = load.i64 notrap aligned v28
+;;                                     v57 = iconst.i64 1
+;; @005a                               v30 = iadd v29, v57  ; v57 = 1
+;; @005a                               v32 = load.i64 notrap aligned readonly v0+40
+;; @005a                               v33 = load.i64 notrap aligned readonly v0+48
+;;                                     v58 = stack_addr.i64 ss0
+;;                                     v47 = load.i32 notrap v58
+;; @005a                               v34 = uextend.i64 v47
+;; @005a                               v35 = iconst.i64 8
+;; @005a                               v36 = uadd_overflow_trap v34, v35, user65535  ; v35 = 8
+;; @005a                               v37 = iconst.i64 8
+;; @005a                               v38 = uadd_overflow_trap v36, v37, user65535  ; v37 = 8
+;; @005a                               v39 = icmp ult v38, v33
+;; @005a                               brif v39, block9, block8
+;;
+;;                                 block8 cold:
+;; @005a                               trap user65535
+;;
+;;                                 block9:
+;; @005a                               v40 = iadd.i64 v32, v36
+;; @005a                               store.i64 notrap aligned v30, v40
+;;                                     v59 = stack_addr.i64 ss0
+;;                                     v46 = load.i32 notrap v59
+;; @005a                               store notrap aligned v46, v16
+;;                                     v60 = iconst.i64 4
+;; @005a                               v41 = iadd.i64 v16, v60  ; v60 = 4
+;; @005a                               store notrap aligned v41, v15
+;; @005a                               jump block5
+;;
+;;                                 block3 cold:
+;;                                     v61 = stack_addr.i64 ss0
+;;                                     v45 = load.i32 notrap v61
+;; @005a                               v43 = call fn0(v0, v45), stack_map=[i32 @ ss0+0]
+;; @005a                               jump block5
+;;
+;;                                 block5:
+;;                                     v62 = stack_addr.i64 ss0
+;;                                     v44 = load.i32 notrap v62
+;; @005c                               jump block1
+;;
+;;                                 block1:
+;; @005c                               return v44
+;; }
diff --git a/tests/disas/table-set-fixed-size.wat b/tests/disas/table-set-fixed-size.wat
new file mode 100644
index 000000000000..0360fc3276b6
--- /dev/null
+++ b/tests/disas/table-set-fixed-size.wat
@@ -0,0 +1,260 @@
+;;! target = "x86_64"
+;;! test = "optimize"
+;;! flags = "-O opt-level=0"
+
+;; Test basic code generation for table WebAssembly instructions on
+;; non-resizeable tables. Use optimized but with `opt-level=0` to legalize away
+;; macro instructions.
+
+(module
+  (table (export "table") 7 7 externref)
+  (func (export "table.set.const") (param externref)
+    i32.const 0
+    local.get 0
+    table.set 0)
+  (func (export "table.set.var") (param i32 externref)
+    local.get 0
+    local.get 1
+    table.set 0))
+;; function u0:0(i64 vmctx, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly gv3+88
+;;     sig0 = (i64 vmctx, i32 uext) system_v
+;;     fn0 = colocated u1:25 sig0
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0052                               v3 = iconst.i32 0
+;; @0056                               v4 = iconst.i32 7
+;; @0056                               v5 = icmp uge v3, v4  ; v3 = 0, v4 = 7
+;; @0056                               v6 = uextend.i64 v3  ; v3 = 0
+;; @0056                               v7 = load.i64 notrap aligned readonly v0+88
+;;                                     v62 = iconst.i64 2
+;; @0056                               v8 = ishl v6, v62  ; v62 = 2
+;; @0056                               v9 = iadd v7, v8
+;; @0056                               v10 = iconst.i64 0
+;; @0056                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @0056                               v12 = load.i32 table_oob aligned table v11
+;;                                     v63 = iconst.i32 0
+;; @0056                               v13 = icmp eq v2, v63  ; v63 = 0
+;; @0056                               brif v13, block3, block2
+;;
+;;                                 block2:
+;; @0056                               v15 = load.i64 notrap aligned readonly v0+40
+;; @0056                               v16 = load.i64 notrap aligned readonly v0+48
+;; @0056                               v17 = uextend.i64 v2
+;; @0056                               v18 = iconst.i64 8
+;; @0056                               v19 = uadd_overflow_trap v17, v18, user65535  ; v18 = 8
+;; @0056                               v20 = iconst.i64 8
+;; @0056                               v21 = uadd_overflow_trap v19, v20, user65535  ; v20 = 8
+;; @0056                               v22 = icmp ult v21, v16
+;; @0056                               brif v22, block9, block8
+;;
+;;                                 block8 cold:
+;; @0056                               trap user65535
+;;
+;;                                 block9:
+;; @0056                               v23 = iadd.i64 v15, v19
+;; @0056                               v24 = load.i64 notrap aligned v23
+;;                                     v64 = iconst.i64 1
+;; @0056                               v25 = iadd v24, v64  ; v64 = 1
+;; @0056                               v27 = load.i64 notrap aligned readonly v0+40
+;; @0056                               v28 = load.i64 notrap aligned readonly v0+48
+;; @0056                               v29 = uextend.i64 v2
+;; @0056                               v30 = iconst.i64 8
+;; @0056                               v31 = uadd_overflow_trap v29, v30, user65535  ; v30 = 8
+;; @0056                               v32 = iconst.i64 8
+;; @0056                               v33 = uadd_overflow_trap v31, v32, user65535  ; v32 = 8
+;; @0056                               v34 = icmp ult v33, v28
+;; @0056                               brif v34, block11, block10
+;;
+;;                                 block10 cold:
+;; @0056                               trap user65535
+;;
+;;                                 block11:
+;; @0056                               v35 = iadd.i64 v27, v31
+;; @0056                               store.i64 notrap aligned v25, v35
+;; @0056                               jump block3
+;;
+;;                                 block3:
+;; @0056                               store.i32 table_oob aligned table v2, v11
+;;                                     v65 = iconst.i32 0
+;; @0056                               v36 = icmp.i32 eq v12, v65  ; v65 = 0
+;; @0056                               brif v36, block7, block4
+;;
+;;                                 block4:
+;; @0056                               v38 = load.i64 notrap aligned readonly v0+40
+;; @0056                               v39 = load.i64 notrap aligned readonly v0+48
+;; @0056                               v40 = uextend.i64 v12
+;; @0056                               v41 = iconst.i64 8
+;; @0056                               v42 = uadd_overflow_trap v40, v41, user65535  ; v41 = 8
+;; @0056                               v43 = iconst.i64 8
+;; @0056                               v44 = uadd_overflow_trap v42, v43, user65535  ; v43 = 8
+;; @0056                               v45 = icmp ult v44, v39
+;; @0056                               brif v45, block13, block12
+;;
+;;                                 block12 cold:
+;; @0056                               trap user65535
+;;
+;;                                 block13:
+;; @0056                               v46 = iadd.i64 v38, v42
+;; @0056                               v47 = load.i64 notrap aligned v46
+;;                                     v66 = iconst.i64 -1
+;; @0056                               v48 = iadd v47, v66  ; v66 = -1
+;;                                     v67 = iconst.i64 0
+;; @0056                               v49 = icmp eq v48, v67  ; v67 = 0
+;; @0056                               brif v49, block5, block6
+;;
+;;                                 block5 cold:
+;; @0056                               call fn0(v0, v12)
+;; @0056                               jump block7
+;;
+;;                                 block6:
+;; @0056                               v52 = load.i64 notrap aligned readonly v0+40
+;; @0056                               v53 = load.i64 notrap aligned readonly v0+48
+;; @0056                               v54 = uextend.i64 v12
+;; @0056                               v55 = iconst.i64 8
+;; @0056                               v56 = uadd_overflow_trap v54, v55, user65535  ; v55 = 8
+;; @0056                               v57 = iconst.i64 8
+;; @0056                               v58 = uadd_overflow_trap v56, v57, user65535  ; v57 = 8
+;; @0056                               v59 = icmp ult v58, v53
+;; @0056                               brif v59, block15, block14
+;;
+;;                                 block14 cold:
+;; @0056                               trap user65535
+;;
+;;                                 block15:
+;; @0056                               v60 = iadd.i64 v52, v56
+;; @0056                               store.i64 notrap aligned v48, v60
+;; @0056                               jump block7
+;;
+;;                                 block7:
+;; @0058                               jump block1
+;;
+;;                                 block1:
+;; @0058                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly gv3+88
+;;     sig0 = (i64 vmctx, i32 uext) system_v
+;;     fn0 = colocated u1:25 sig0
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @005f                               v4 = iconst.i32 7
+;; @005f                               v5 = icmp uge v2, v4  ; v4 = 7
+;; @005f                               v6 = uextend.i64 v2
+;; @005f                               v7 = load.i64 notrap aligned readonly v0+88
+;;                                     v62 = iconst.i64 2
+;; @005f                               v8 = ishl v6, v62  ; v62 = 2
+;; @005f                               v9 = iadd v7, v8
+;; @005f                               v10 = iconst.i64 0
+;; @005f                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @005f                               v12 = load.i32 table_oob aligned table v11
+;;                                     v63 = iconst.i32 0
+;; @005f                               v13 = icmp eq v3, v63  ; v63 = 0
+;; @005f                               brif v13, block3, block2
+;;
+;;                                 block2:
+;; @005f                               v15 = load.i64 notrap aligned readonly v0+40
+;; @005f                               v16 = load.i64 notrap aligned readonly v0+48
+;; @005f                               v17 = uextend.i64 v3
+;; @005f                               v18 = iconst.i64 8
+;; @005f                               v19 = uadd_overflow_trap v17, v18, user65535  ; v18 = 8
+;; @005f                               v20 = iconst.i64 8
+;; @005f                               v21 = uadd_overflow_trap v19, v20, user65535  ; v20 = 8
+;; @005f                               v22 = icmp ult v21, v16
+;; @005f                               brif v22, block9, block8
+;;
+;;                                 block8 cold:
+;; @005f                               trap user65535
+;;
+;;                                 block9:
+;; @005f                               v23 = iadd.i64 v15, v19
+;; @005f                               v24 = load.i64 notrap aligned v23
+;;                                     v64 = iconst.i64 1
+;; @005f                               v25 = iadd v24, v64  ; v64 = 1
+;; @005f                               v27 = load.i64 notrap aligned readonly v0+40
+;; @005f                               v28 = load.i64 notrap aligned readonly v0+48
+;; @005f                               v29 = uextend.i64 v3
+;; @005f                               v30 = iconst.i64 8
+;; @005f                               v31 = uadd_overflow_trap v29, v30, user65535  ; v30 = 8
+;; @005f                               v32 = iconst.i64 8
+;; @005f                               v33 = uadd_overflow_trap v31, v32, user65535  ; v32 = 8
+;; @005f                               v34 = icmp ult v33, v28
+;; @005f                               brif v34, block11, block10
+;;
+;;                                 block10 cold:
+;; @005f                               trap user65535
+;;
+;;                                 block11:
+;; @005f                               v35 = iadd.i64 v27, v31
+;; @005f                               store.i64 notrap aligned v25, v35
+;; @005f                               jump block3
+;;
+;;                                 block3:
+;; @005f                               store.i32 table_oob aligned table v3, v11
+;;                                     v65 = iconst.i32 0
+;; @005f                               v36 = icmp.i32 eq v12, v65  ; v65 = 0
+;; @005f                               brif v36, block7, block4
+;;
+;;                                 block4:
+;; @005f                               v38 = load.i64 notrap aligned readonly v0+40
+;; @005f                               v39 = load.i64 notrap aligned readonly v0+48
+;; @005f                               v40 = uextend.i64 v12
+;; @005f                               v41 = iconst.i64 8
+;; @005f                               v42 = uadd_overflow_trap v40, v41, user65535  ; v41 = 8
+;; @005f                               v43 = iconst.i64 8
+;; @005f                               v44 = uadd_overflow_trap v42, v43, user65535  ; v43 = 8
+;; @005f                               v45 = icmp ult v44, v39
+;; @005f                               brif v45, block13, block12
+;;
+;;                                 block12 cold:
+;; @005f                               trap user65535
+;;
+;;                                 block13:
+;; @005f                               v46 = iadd.i64 v38, v42
+;; @005f                               v47 = load.i64 notrap aligned v46
+;;                                     v66 = iconst.i64 -1
+;; @005f                               v48 = iadd v47, v66  ; v66 = -1
+;;                                     v67 = iconst.i64 0
+;; @005f                               v49 = icmp eq v48, v67  ; v67 = 0
+;; @005f                               brif v49, block5, block6
+;;
+;;                                 block5 cold:
+;; @005f                               call fn0(v0, v12)
+;; @005f                               jump block7
+;;
+;;                                 block6:
+;; @005f                               v52 = load.i64 notrap aligned readonly v0+40
+;; @005f                               v53 = load.i64 notrap aligned readonly v0+48
+;; @005f                               v54 = uextend.i64 v12
+;; @005f                               v55 = iconst.i64 8
+;; @005f                               v56 = uadd_overflow_trap v54, v55, user65535  ; v55 = 8
+;; @005f                               v57 = iconst.i64 8
+;; @005f                               v58 = uadd_overflow_trap v56, v57, user65535  ; v57 = 8
+;; @005f                               v59 = icmp ult v58, v53
+;; @005f                               brif v59, block15, block14
+;;
+;;                                 block14 cold:
+;; @005f                               trap user65535
+;;
+;;                                 block15:
+;; @005f                               v60 = iadd.i64 v52, v56
+;; @005f                               store.i64 notrap aligned v48, v60
+;; @005f                               jump block7
+;;
+;;                                 block7:
+;; @0061                               jump block1
+;;
+;;                                 block1:
+;; @0061                               return
+;; }
diff --git a/tests/disas/table-set.wat b/tests/disas/table-set.wat
new file mode 100644
index 000000000000..54029fe7ceee
--- /dev/null
+++ b/tests/disas/table-set.wat
@@ -0,0 +1,262 @@
+;;! target = "x86_64"
+;;! test = "optimize"
+;;! flags = "-O opt-level=0"
+
+;; Test basic code generation for table WebAssembly instructions.
+;; Use optimization but with `opt-level=0` to legalize away table_addr instructions.
+
+(module
+  (table (export "table") 1 externref)
+  (func (export "table.set.const") (param externref)
+    i32.const 0
+    local.get 0
+    table.set 0)
+  (func (export "table.set.var") (param i32 externref)
+    local.get 0
+    local.get 1
+    table.set 0))
+
+;; function u0:0(i64 vmctx, i64, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+88
+;;     gv5 = load.i32 notrap aligned gv3+96
+;;     sig0 = (i64 vmctx, i32 uext) system_v
+;;     fn0 = colocated u1:25 sig0
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32):
+;; @0051                               v3 = iconst.i32 0
+;; @0055                               v4 = load.i32 notrap aligned v0+96
+;; @0055                               v5 = icmp uge v3, v4  ; v3 = 0
+;; @0055                               v6 = uextend.i64 v3  ; v3 = 0
+;; @0055                               v7 = load.i64 notrap aligned v0+88
+;;                                     v63 = iconst.i64 2
+;; @0055                               v8 = ishl v6, v63  ; v63 = 2
+;; @0055                               v9 = iadd v7, v8
+;; @0055                               v10 = iconst.i64 0
+;; @0055                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @0055                               v12 = load.i32 table_oob aligned table v11
+;;                                     v64 = iconst.i32 0
+;; @0055                               v13 = icmp eq v2, v64  ; v64 = 0
+;; @0055                               brif v13, block3, block2
+;;
+;;                                 block2:
+;; @0055                               v15 = load.i64 notrap aligned readonly v0+40
+;; @0055                               v16 = load.i64 notrap aligned readonly v0+48
+;; @0055                               v17 = uextend.i64 v2
+;; @0055                               v18 = iconst.i64 8
+;; @0055                               v19 = uadd_overflow_trap v17, v18, user65535  ; v18 = 8
+;; @0055                               v20 = iconst.i64 8
+;; @0055                               v21 = uadd_overflow_trap v19, v20, user65535  ; v20 = 8
+;; @0055                               v22 = icmp ult v21, v16
+;; @0055                               brif v22, block9, block8
+;;
+;;                                 block8 cold:
+;; @0055                               trap user65535
+;;
+;;                                 block9:
+;; @0055                               v23 = iadd.i64 v15, v19
+;; @0055                               v24 = load.i64 notrap aligned v23
+;;                                     v65 = iconst.i64 1
+;; @0055                               v25 = iadd v24, v65  ; v65 = 1
+;; @0055                               v27 = load.i64 notrap aligned readonly v0+40
+;; @0055                               v28 = load.i64 notrap aligned readonly v0+48
+;; @0055                               v29 = uextend.i64 v2
+;; @0055                               v30 = iconst.i64 8
+;; @0055                               v31 = uadd_overflow_trap v29, v30, user65535  ; v30 = 8
+;; @0055                               v32 = iconst.i64 8
+;; @0055                               v33 = uadd_overflow_trap v31, v32, user65535  ; v32 = 8
+;; @0055                               v34 = icmp ult v33, v28
+;; @0055                               brif v34, block11, block10
+;;
+;;                                 block10 cold:
+;; @0055                               trap user65535
+;;
+;;                                 block11:
+;; @0055                               v35 = iadd.i64 v27, v31
+;; @0055                               store.i64 notrap aligned v25, v35
+;; @0055                               jump block3
+;;
+;;                                 block3:
+;; @0055                               store.i32 table_oob aligned table v2, v11
+;;                                     v66 = iconst.i32 0
+;; @0055                               v36 = icmp.i32 eq v12, v66  ; v66 = 0
+;; @0055                               brif v36, block7, block4
+;;
+;;                                 block4:
+;; @0055                               v38 = load.i64 notrap aligned readonly v0+40
+;; @0055                               v39 = load.i64 notrap aligned readonly v0+48
+;; @0055                               v40 = uextend.i64 v12
+;; @0055                               v41 = iconst.i64 8
+;; @0055                               v42 = uadd_overflow_trap v40, v41, user65535  ; v41 = 8
+;; @0055                               v43 = iconst.i64 8
+;; @0055                               v44 = uadd_overflow_trap v42, v43, user65535  ; v43 = 8
+;; @0055                               v45 = icmp ult v44, v39
+;; @0055                               brif v45, block13, block12
+;;
+;;                                 block12 cold:
+;; @0055                               trap user65535
+;;
+;;                                 block13:
+;; @0055                               v46 = iadd.i64 v38, v42
+;; @0055                               v47 = load.i64 notrap aligned v46
+;;                                     v67 = iconst.i64 -1
+;; @0055                               v48 = iadd v47, v67  ; v67 = -1
+;;                                     v68 = iconst.i64 0
+;; @0055                               v49 = icmp eq v48, v68  ; v68 = 0
+;; @0055                               brif v49, block5, block6
+;;
+;;                                 block5 cold:
+;; @0055                               call fn0(v0, v12)
+;; @0055                               jump block7
+;;
+;;                                 block6:
+;; @0055                               v52 = load.i64 notrap aligned readonly v0+40
+;; @0055                               v53 = load.i64 notrap aligned readonly v0+48
+;; @0055                               v54 = uextend.i64 v12
+;; @0055                               v55 = iconst.i64 8
+;; @0055                               v56 = uadd_overflow_trap v54, v55, user65535  ; v55 = 8
+;; @0055                               v57 = iconst.i64 8
+;; @0055                               v58 = uadd_overflow_trap v56, v57, user65535  ; v57 = 8
+;; @0055                               v59 = icmp ult v58, v53
+;; @0055                               brif v59, block15, block14
+;;
+;;                                 block14 cold:
+;; @0055                               trap user65535
+;;
+;;                                 block15:
+;; @0055                               v60 = iadd.i64 v52, v56
+;; @0055                               store.i64 notrap aligned v48, v60
+;; @0055                               jump block7
+;;
+;;                                 block7:
+;; @0057                               jump block1
+;;
+;;                                 block1:
+;; @0057                               return
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32, i32) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned gv3+88
+;;     gv5 = load.i32 notrap aligned gv3+96
+;;     sig0 = (i64 vmctx, i32 uext) system_v
+;;     fn0 = colocated u1:25 sig0
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32):
+;; @005e                               v4 = load.i32 notrap aligned v0+96
+;; @005e                               v5 = icmp uge v2, v4
+;; @005e                               v6 = uextend.i64 v2
+;; @005e                               v7 = load.i64 notrap aligned v0+88
+;;                                     v63 = iconst.i64 2
+;; @005e                               v8 = ishl v6, v63  ; v63 = 2
+;; @005e                               v9 = iadd v7, v8
+;; @005e                               v10 = iconst.i64 0
+;; @005e                               v11 = select_spectre_guard v5, v10, v9  ; v10 = 0
+;; @005e                               v12 = load.i32 table_oob aligned table v11
+;;                                     v64 = iconst.i32 0
+;; @005e                               v13 = icmp eq v3, v64  ; v64 = 0
+;; @005e                               brif v13, block3, block2
+;;
+;;                                 block2:
+;; @005e                               v15 = load.i64 notrap aligned readonly v0+40
+;; @005e                               v16 = load.i64 notrap aligned readonly v0+48
+;; @005e                               v17 = uextend.i64 v3
+;; @005e                               v18 = iconst.i64 8
+;; @005e                               v19 = uadd_overflow_trap v17, v18, user65535  ; v18 = 8
+;; @005e                               v20 = iconst.i64 8
+;; @005e                               v21 = uadd_overflow_trap v19, v20, user65535  ; v20 = 8
+;; @005e                               v22 = icmp ult v21, v16
+;; @005e                               brif v22, block9, block8
+;;
+;;                                 block8 cold:
+;; @005e                               trap user65535
+;;
+;;                                 block9:
+;; @005e                               v23 = iadd.i64 v15, v19
+;; @005e                               v24 = load.i64 notrap aligned v23
+;;                                     v65 = iconst.i64 1
+;; @005e                               v25 = iadd v24, v65  ; v65 = 1
+;; @005e                               v27 = load.i64 notrap aligned readonly v0+40
+;; @005e                               v28 = load.i64 notrap aligned readonly v0+48
+;; @005e                               v29 = uextend.i64 v3
+;; @005e                               v30 = iconst.i64 8
+;; @005e                               v31 = uadd_overflow_trap v29, v30, user65535  ; v30 = 8
+;; @005e                               v32 = iconst.i64 8
+;; @005e                               v33 = uadd_overflow_trap v31, v32, user65535  ; v32 = 8
+;; @005e                               v34 = icmp ult v33, v28
+;; @005e                               brif v34, block11, block10
+;;
+;;                                 block10 cold:
+;; @005e                               trap user65535
+;;
+;;                                 block11:
+;; @005e                               v35 = iadd.i64 v27, v31
+;; @005e                               store.i64 notrap aligned v25, v35
+;; @005e                               jump block3
+;;
+;;                                 block3:
+;; @005e                               store.i32 table_oob aligned table v3, v11
+;;                                     v66 = iconst.i32 0
+;; @005e                               v36 = icmp.i32 eq v12, v66  ; v66 = 0
+;; @005e                               brif v36, block7, block4
+;;
+;;                                 block4:
+;; @005e                               v38 = load.i64 notrap aligned readonly v0+40
+;; @005e                               v39 = load.i64 notrap aligned readonly v0+48
+;; @005e                               v40 = uextend.i64 v12
+;; @005e                               v41 = iconst.i64 8
+;; @005e                               v42 = uadd_overflow_trap v40, v41, user65535  ; v41 = 8
+;; @005e                               v43 = iconst.i64 8
+;; @005e                               v44 = uadd_overflow_trap v42, v43, user65535  ; v43 = 8
+;; @005e                               v45 = icmp ult v44, v39
+;; @005e                               brif v45, block13, block12
+;;
+;;                                 block12 cold:
+;; @005e                               trap user65535
+;;
+;;                                 block13:
+;; @005e                               v46 = iadd.i64 v38, v42
+;; @005e                               v47 = load.i64 notrap aligned v46
+;;                                     v67 = iconst.i64 -1
+;; @005e                               v48 = iadd v47, v67  ; v67 = -1
+;;                                     v68 = iconst.i64 0
+;; @005e                               v49 = icmp eq v48, v68  ; v68 = 0
+;; @005e                               brif v49, block5, block6
+;;
+;;                                 block5 cold:
+;; @005e                               call fn0(v0, v12)
+;; @005e                               jump block7
+;;
+;;                                 block6:
+;; @005e                               v52 = load.i64 notrap aligned readonly v0+40
+;; @005e                               v53 = load.i64 notrap aligned readonly v0+48
+;; @005e                               v54 = uextend.i64 v12
+;; @005e                               v55 = iconst.i64 8
+;; @005e                               v56 = uadd_overflow_trap v54, v55, user65535  ; v55 = 8
+;; @005e                               v57 = iconst.i64 8
+;; @005e                               v58 = uadd_overflow_trap v56, v57, user65535  ; v57 = 8
+;; @005e                               v59 = icmp ult v58, v53
+;; @005e                               brif v59, block15, block14
+;;
+;;                                 block14 cold:
+;; @005e                               trap user65535
+;;
+;;                                 block15:
+;; @005e                               v60 = iadd.i64 v52, v56
+;; @005e                               store.i64 notrap aligned v48, v60
+;; @005e                               jump block7
+;;
+;;                                 block7:
+;; @0060                               jump block1
+;;
+;;                                 block1:
+;; @0060                               return
+;; }
diff --git a/tests/disas/typed-funcrefs-eager-init.wat b/tests/disas/typed-funcrefs-eager-init.wat
new file mode 100644
index 000000000000..d8f7b15aa281
--- /dev/null
+++ b/tests/disas/typed-funcrefs-eager-init.wat
@@ -0,0 +1,211 @@
+;;! target = "x86_64"
+;;! test = "optimize"
+;;! flags = [ "-Wfunction-references=y", "-Otable-lazy-init=n" ]
+
+;; This test is meant to simulate how typed funcrefs in a table may be
+;; used for ICs (inline caches) in a Wasm module compiled from a dynamic
+;; language. In native JIT engines, IC chains have head pointers that
+;; are raw code pointers and IC-using code can call each with a few ops
+;; (load pointer, call indirect). We'd like similar efficiency by
+;; storing funcrefs for the first IC in each chain in a typed-funcref
+;; table.
+
+(module
+  (type $ic-stub (func (param i32 i32 i32 i32) (result i32)))
+
+  ;; This syntax declares a table that is exactly 100 elements, whose
+  ;; elements are nullable function references, and whose default
+  ;; value is `null`.
+  (table $ic-sites 100 100 (ref null $ic-stub))
+
+  (func $ic1 (param i32 i32 i32 i32) (result i32)
+        local.get 0)
+
+  ;; A function which uses ICs through `table.get` plus `call_ref`
+  (func $call-ics-with-call-ref (param i32 i32 i32 i32) (result i32)
+        (local $sum i32)
+
+        ;; IC callsite index 1 (arbitrary).
+        local.get 0
+        local.get 1
+        local.get 2
+        local.get 3
+        i32.const 1
+        table.get $ic-sites
+        call_ref $ic-stub
+        local.get $sum
+        i32.add
+        local.set $sum
+
+        ;; IC callsite index 2 (arbitrary).
+        local.get 0
+        local.get 1
+        local.get 2
+        local.get 3
+        i32.const 2
+        table.get $ic-sites
+        call_ref $ic-stub
+        local.get $sum
+        i32.add
+        local.set $sum
+
+        local.get $sum)
+
+  ;; Same as the above function, but uses `call_indirect` rather than
+  ;; `call_ref`.
+  (func $call-ics-with-call-indirect (param i32 i32 i32 i32) (result i32)
+        (local $sum i32)
+
+        ;; IC callsite index 1 (arbitrary).
+        local.get 0
+        local.get 1
+        local.get 2
+        local.get 3
+        i32.const 1
+        call_indirect $ic-sites (type $ic-stub)
+        local.get $sum
+        i32.add
+        local.set $sum
+
+        ;; IC callsite index 2 (arbitrary).
+        local.get 0
+        local.get 1
+        local.get 2
+        local.get 3
+        i32.const 2
+        call_indirect $ic-sites (type $ic-stub)
+        local.get $sum
+        i32.add
+        local.set $sum
+
+        local.get $sum)
+
+  (global $ic-site0 (mut (ref $ic-stub)) (ref.func $ic1))
+  (global $ic-site1 (mut (ref $ic-stub)) (ref.func $ic1))
+
+  ;; Sort of similar to the previous two functions, but uses globals instead of
+  ;; tables to store ICs. Mostly just here for comparison in terms of codegen.
+  (func $call-ics-with-global-get (param i32 i32 i32 i32) (result i32)
+        (local $sum i32)
+
+        ;; IC callsite index 1 (arbitrary).
+        local.get 0
+        local.get 1
+        local.get 2
+        local.get 3
+        global.get $ic-site0
+        call_ref $ic-stub
+        local.get $sum
+        i32.add
+        local.set $sum
+
+        ;; IC callsite index 2 (arbitrary).
+        local.get 0
+        local.get 1
+        local.get 2
+        local.get 3
+        global.get $ic-site1
+        call_ref $ic-stub
+        local.get $sum
+        i32.add
+        local.set $sum
+
+        local.get $sum)
+)
+
+;; function u0:0(i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
+;; @0039                               jump block1
+;;
+;;                                 block1:
+;; @0039                               return v2
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly gv3+88
+;;     sig0 = (i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
+;; @0048                               v12 = load.i64 notrap aligned readonly v0+88
+;;                                     v48 = iconst.i64 8
+;; @0048                               v14 = iadd v12, v48  ; v48 = 8
+;; @0048                               v17 = load.i64 table_oob aligned table v14
+;; @004a                               v18 = load.i64 null_reference aligned readonly v17+8
+;; @004a                               v19 = load.i64 notrap aligned readonly v17+24
+;; @004a                               v20 = call_indirect sig0, v18(v19, v0, v2, v3, v4, v5)
+;;                                     v56 = iconst.i64 16
+;; @005b                               v28 = iadd v12, v56  ; v56 = 16
+;; @005b                               v31 = load.i64 table_oob aligned table v28
+;; @005d                               v32 = load.i64 null_reference aligned readonly v31+8
+;; @005d                               v33 = load.i64 notrap aligned readonly v31+24
+;; @005d                               v34 = call_indirect sig0, v32(v33, v0, v2, v3, v4, v5)
+;; @0066                               jump block1
+;;
+;;                                 block1:
+;; @0061                               v35 = iadd.i32 v34, v20
+;; @0066                               return v35
+;; }
+;;
+;; function u0:2(i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly gv3+88
+;;     sig0 = (i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
+;; @0075                               v12 = load.i64 notrap aligned readonly v0+88
+;;                                     v48 = iconst.i64 8
+;; @0075                               v14 = iadd v12, v48  ; v48 = 8
+;; @0075                               v17 = load.i64 table_oob aligned table v14
+;; @0075                               v18 = load.i64 icall_null aligned readonly v17+8
+;; @0075                               v19 = load.i64 notrap aligned readonly v17+24
+;; @0075                               v20 = call_indirect sig0, v18(v19, v0, v2, v3, v4, v5)
+;;                                     v56 = iconst.i64 16
+;; @0087                               v28 = iadd v12, v56  ; v56 = 16
+;; @0087                               v31 = load.i64 table_oob aligned table v28
+;; @0087                               v32 = load.i64 icall_null aligned readonly v31+8
+;; @0087                               v33 = load.i64 notrap aligned readonly v31+24
+;; @0087                               v34 = call_indirect sig0, v32(v33, v0, v2, v3, v4, v5)
+;; @0091                               jump block1
+;;
+;;                                 block1:
+;; @008c                               v35 = iadd.i32 v34, v20
+;; @0091                               return v35
+;; }
+;;
+;; function u0:3(i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     sig0 = (i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
+;; @009e                               v9 = load.i64 notrap aligned table v0+112
+;; @00a0                               v10 = load.i64 null_reference aligned readonly v9+8
+;; @00a0                               v11 = load.i64 notrap aligned readonly v9+24
+;; @00a0                               v12 = call_indirect sig0, v10(v11, v0, v2, v3, v4, v5)
+;; @00af                               v15 = load.i64 notrap aligned table v0+128
+;; @00b1                               v16 = load.i64 null_reference aligned readonly v15+8
+;; @00b1                               v17 = load.i64 notrap aligned readonly v15+24
+;; @00b1                               v18 = call_indirect sig0, v16(v17, v0, v2, v3, v4, v5)
+;; @00ba                               jump block1
+;;
+;;                                 block1:
+;; @00b5                               v19 = iadd.i32 v18, v12
+;; @00ba                               return v19
+;; }
diff --git a/tests/disas/typed-funcrefs.wat b/tests/disas/typed-funcrefs.wat
new file mode 100644
index 000000000000..da55d039dfd7
--- /dev/null
+++ b/tests/disas/typed-funcrefs.wat
@@ -0,0 +1,259 @@
+;;! target = "x86_64"
+;;! test = "optimize"
+;;! flags = [ "-Wfunction-references=y", "-Otable-lazy-init=y" ]
+
+;; This test is meant to simulate how typed funcrefs in a table may be
+;; used for ICs (inline caches) in a Wasm module compiled from a dynamic
+;; language. In native JIT engines, IC chains have head pointers that
+;; are raw code pointers and IC-using code can call each with a few ops
+;; (load pointer, call indirect). We'd like similar efficiency by
+;; storing funcrefs for the first IC in each chain in a typed-funcref
+;; table.
+
+(module
+  (type $ic-stub (func (param i32 i32 i32 i32) (result i32)))
+
+  ;; This syntax declares a table that is exactly 100 elements, whose
+  ;; elements are nullable function references, and whose default
+  ;; value is `null`.
+  (table $ic-sites 100 100 (ref null $ic-stub))
+
+  (func $ic1 (param i32 i32 i32 i32) (result i32)
+        local.get 0)
+
+  ;; A function which uses ICs through `table.get` plus `call_ref`
+  (func $call-ics-with-call-ref (param i32 i32 i32 i32) (result i32)
+        (local $sum i32)
+
+        ;; IC callsite index 1 (arbitrary).
+        local.get 0
+        local.get 1
+        local.get 2
+        local.get 3
+        i32.const 1
+        table.get $ic-sites
+        call_ref $ic-stub
+        local.get $sum
+        i32.add
+        local.set $sum
+
+        ;; IC callsite index 2 (arbitrary).
+        local.get 0
+        local.get 1
+        local.get 2
+        local.get 3
+        i32.const 2
+        table.get $ic-sites
+        call_ref $ic-stub
+        local.get $sum
+        i32.add
+        local.set $sum
+
+        local.get $sum)
+
+  ;; Same as the above function, but uses `call_indirect` rather than
+  ;; `call_ref`.
+  (func $call-ics-with-call-indirect (param i32 i32 i32 i32) (result i32)
+        (local $sum i32)
+
+        ;; IC callsite index 1 (arbitrary).
+        local.get 0
+        local.get 1
+        local.get 2
+        local.get 3
+        i32.const 1
+        call_indirect $ic-sites (type $ic-stub)
+        local.get $sum
+        i32.add
+        local.set $sum
+
+        ;; IC callsite index 2 (arbitrary).
+        local.get 0
+        local.get 1
+        local.get 2
+        local.get 3
+        i32.const 2
+        call_indirect $ic-sites (type $ic-stub)
+        local.get $sum
+        i32.add
+        local.set $sum
+
+        local.get $sum)
+
+  (global $ic-site0 (mut (ref $ic-stub)) (ref.func $ic1))
+  (global $ic-site1 (mut (ref $ic-stub)) (ref.func $ic1))
+
+  ;; Sort of similar to the previous two functions, but uses globals instead of
+  ;; tables to store ICs. Mostly just here for comparison in terms of codegen.
+  (func $call-ics-with-global-get (param i32 i32 i32 i32) (result i32)
+        (local $sum i32)
+
+        ;; IC callsite index 1 (arbitrary).
+        local.get 0
+        local.get 1
+        local.get 2
+        local.get 3
+        global.get $ic-site0
+        call_ref $ic-stub
+        local.get $sum
+        i32.add
+        local.set $sum
+
+        ;; IC callsite index 2 (arbitrary).
+        local.get 0
+        local.get 1
+        local.get 2
+        local.get 3
+        global.get $ic-site1
+        call_ref $ic-stub
+        local.get $sum
+        i32.add
+        local.set $sum
+
+        local.get $sum)
+)
+
+;; function u0:0(i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
+;; @0039                               jump block1
+;;
+;;                                 block1:
+;; @0039                               return v2
+;; }
+;;
+;; function u0:1(i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly gv3+88
+;;     sig0 = (i64 vmctx, i32 uext, i32 uext) -> i64 system_v
+;;     sig1 = (i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail
+;;     fn0 = colocated u1:9 sig0
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
+;; @0048                               v12 = load.i64 notrap aligned readonly v0+88
+;;                                     v66 = iconst.i64 8
+;; @0048                               v14 = iadd v12, v66  ; v66 = 8
+;; @0048                               v17 = load.i64 table_oob aligned table v14
+;;                                     v54 = iconst.i64 -2
+;; @0048                               v18 = band v17, v54  ; v54 = -2
+;; @0048                               brif v17, block3(v18), block2
+;;
+;;                                 block2 cold:
+;; @003c                               v7 = iconst.i32 0
+;; @0046                               v8 = iconst.i32 1
+;; @0048                               v22 = call fn0(v0, v7, v8)  ; v7 = 0, v8 = 1
+;; @0048                               jump block3(v22)
+;;
+;;                                 block3(v19: i64):
+;; @004a                               v23 = load.i64 null_reference aligned readonly v19+8
+;; @004a                               v24 = load.i64 notrap aligned readonly v19+24
+;; @004a                               v25 = call_indirect sig1, v23(v24, v0, v2, v3, v4, v5)
+;;                                     v74 = iconst.i64 16
+;; @005b                               v38 = iadd.i64 v12, v74  ; v74 = 16
+;; @005b                               v41 = load.i64 table_oob aligned table v38
+;;                                     v75 = iconst.i64 -2
+;;                                     v76 = band v41, v75  ; v75 = -2
+;; @005b                               brif v41, block5(v76), block4
+;;
+;;                                 block4 cold:
+;;                                     v77 = iconst.i32 0
+;; @0059                               v32 = iconst.i32 2
+;; @005b                               v46 = call fn0(v0, v77, v32)  ; v77 = 0, v32 = 2
+;; @005b                               jump block5(v46)
+;;
+;;                                 block5(v43: i64):
+;; @005d                               v47 = load.i64 null_reference aligned readonly v43+8
+;; @005d                               v48 = load.i64 notrap aligned readonly v43+24
+;; @005d                               v49 = call_indirect sig1, v47(v48, v0, v2, v3, v4, v5)
+;; @0066                               jump block1
+;;
+;;                                 block1:
+;; @0061                               v51 = iadd.i32 v49, v25
+;; @0066                               return v51
+;; }
+;;
+;; function u0:2(i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     gv4 = load.i64 notrap aligned readonly gv3+88
+;;     sig0 = (i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail
+;;     sig1 = (i64 vmctx, i32 uext, i32 uext) -> i64 system_v
+;;     fn0 = colocated u1:9 sig1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
+;; @0075                               v12 = load.i64 notrap aligned readonly v0+88
+;;                                     v66 = iconst.i64 8
+;; @0075                               v14 = iadd v12, v66  ; v66 = 8
+;; @0075                               v17 = load.i64 table_oob aligned table v14
+;;                                     v54 = iconst.i64 -2
+;; @0075                               v18 = band v17, v54  ; v54 = -2
+;; @0075                               brif v17, block3(v18), block2
+;;
+;;                                 block2 cold:
+;; @0069                               v7 = iconst.i32 0
+;; @0073                               v8 = iconst.i32 1
+;; @0075                               v22 = call fn0(v0, v7, v8)  ; v7 = 0, v8 = 1
+;; @0075                               jump block3(v22)
+;;
+;;                                 block3(v19: i64):
+;; @0075                               v23 = load.i64 icall_null aligned readonly v19+8
+;; @0075                               v24 = load.i64 notrap aligned readonly v19+24
+;; @0075                               v25 = call_indirect sig0, v23(v24, v0, v2, v3, v4, v5)
+;;                                     v74 = iconst.i64 16
+;; @0087                               v38 = iadd.i64 v12, v74  ; v74 = 16
+;; @0087                               v41 = load.i64 table_oob aligned table v38
+;;                                     v75 = iconst.i64 -2
+;;                                     v76 = band v41, v75  ; v75 = -2
+;; @0087                               brif v41, block5(v76), block4
+;;
+;;                                 block4 cold:
+;;                                     v77 = iconst.i32 0
+;; @0085                               v32 = iconst.i32 2
+;; @0087                               v46 = call fn0(v0, v77, v32)  ; v77 = 0, v32 = 2
+;; @0087                               jump block5(v46)
+;;
+;;                                 block5(v43: i64):
+;; @0087                               v47 = load.i64 icall_null aligned readonly v43+8
+;; @0087                               v48 = load.i64 notrap aligned readonly v43+24
+;; @0087                               v49 = call_indirect sig0, v47(v48, v0, v2, v3, v4, v5)
+;; @0091                               jump block1
+;;
+;;                                 block1:
+;; @008c                               v51 = iadd.i32 v49, v25
+;; @0091                               return v51
+;; }
+;;
+;; function u0:3(i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     gv3 = vmctx
+;;     sig0 = (i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
+;; @009e                               v9 = load.i64 notrap aligned table v0+112
+;; @00a0                               v10 = load.i64 null_reference aligned readonly v9+8
+;; @00a0                               v11 = load.i64 notrap aligned readonly v9+24
+;; @00a0                               v12 = call_indirect sig0, v10(v11, v0, v2, v3, v4, v5)
+;; @00af                               v15 = load.i64 notrap aligned table v0+128
+;; @00b1                               v16 = load.i64 null_reference aligned readonly v15+8
+;; @00b1                               v17 = load.i64 notrap aligned readonly v15+24
+;; @00b1                               v18 = call_indirect sig0, v16(v17, v0, v2, v3, v4, v5)
+;; @00ba                               jump block1
+;;
+;;                                 block1:
+;; @00b5                               v19 = iadd.i32 v18, v12
+;; @00ba                               return v19
+;; }
diff --git a/tests/disas/unreachable_code.wat b/tests/disas/unreachable_code.wat
new file mode 100644
index 000000000000..a4328feb558e
--- /dev/null
+++ b/tests/disas/unreachable_code.wat
@@ -0,0 +1,151 @@
+;;! target = "x86_64"
+
+(module
+  (type (;0;) (func (param i32 i64 f64) (result f64)))
+  (type (;1;) (func))
+  (type (;2;) (func (result f32)))
+  (type (;3;) (func (result f64)))
+  (type (;4;) (func (param f64 f64) (result f64)))
+  (type (;5;) (func (result i32)))
+  (func (result i32)
+      block (result i32)
+        unreachable
+      end
+      block
+      end
+      i32.clz
+  )
+  (func (result i32)
+      loop (result i32)
+        unreachable
+      end
+      block
+      end
+      i32.clz
+  )
+  (func (;0;) (type 5) (result i32)
+    nop
+    block (result i32)  ;; label = @1
+      block  ;; label = @2
+        block  ;; label = @3
+          nop
+          block  ;; label = @4
+            i32.const 1
+            if  ;; label = @5
+              nop
+              block  ;; label = @6
+                nop
+                nop
+                loop (result i32)  ;; label = @7
+                  nop
+                  block (result i32)  ;; label = @8
+                    nop
+                    nop
+                    block (result i32)  ;; label = @9
+                      nop
+                      unreachable
+                    end
+                  end
+                end
+                block (result i32)  ;; label = @7
+                  block  ;; label = @8
+                    nop
+                  end
+                  i32.const 0
+                end
+                br_if 5 (;@1;)
+                drop
+              end
+            else
+              nop
+            end
+            nop
+          end
+        end
+      end
+      unreachable
+    end)
+  (func
+    block (result i32)
+      block (result i32)
+        i32.const 1
+        br 1
+      end
+    end
+    drop
+  )
+  (table (;0;) 16 funcref)
+  (elem (i32.const 0))
+)
+
+;; function u0:0(i64 vmctx, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @0043                               trap unreachable
+;; }
+;;
+;; function u0:1(i64 vmctx, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @004c                               jump block2
+;;
+;;                                 block2:
+;; @004e                               trap unreachable
+;; }
+;;
+;; function u0:2(i64 vmctx, i64) -> i32 tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @0061                               v4 = iconst.i32 1
+;; @0063                               brif v4, block6, block13  ; v4 = 1
+;;
+;;                                 block6:
+;; @006a                               jump block9
+;;
+;;                                 block9:
+;; @0074                               trap unreachable
+;;
+;;                                 block13:
+;; @0087                               jump block7
+;;
+;;                                 block7:
+;; @0089                               jump block5
+;;
+;;                                 block5:
+;; @008a                               jump block4
+;;
+;;                                 block4:
+;; @008b                               jump block3
+;;
+;;                                 block3:
+;; @008c                               trap unreachable
+;; }
+;;
+;; function u0:3(i64 vmctx, i64) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @0095                               v4 = iconst.i32 1
+;; @0097                               jump block2(v4)  ; v4 = 1
+;;
+;;                                 block2(v2: i32):
+;; @009c                               jump block1
+;;
+;;                                 block1:
+;; @009c                               return
+;; }
diff --git a/tests/disas/winch/aarch64/br/as_br_if_cond.wat b/tests/disas/winch/aarch64/br/as_br_if_cond.wat
new file mode 100644
index 000000000000..a4c2b3baf097
--- /dev/null
+++ b/tests/disas/winch/aarch64/br/as_br_if_cond.wat
@@ -0,0 +1,20 @@
+;;! target = "aarch64"
+;;! test = "winch"
+(module
+    (func (export "as-br_if-cond")
+    (block (br_if 0 (br 0)))
+  )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/br/as_br_value.wat b/tests/disas/winch/aarch64/br/as_br_value.wat
new file mode 100644
index 000000000000..932c18679c69
--- /dev/null
+++ b/tests/disas/winch/aarch64/br/as_br_value.wat
@@ -0,0 +1,22 @@
+;;! target = "aarch64"
+;;! test = "winch"
+(module
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (br 0 (i32.const 9))))
+  )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #9
+;;       mov     w0, w16
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/br/as_if_cond.wat b/tests/disas/winch/aarch64/br/as_if_cond.wat
new file mode 100644
index 000000000000..a86ded6f7b21
--- /dev/null
+++ b/tests/disas/winch/aarch64/br/as_if_cond.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+(module
+  (func (export "as-if-cond") (result i32)
+    (block (result i32)
+      (if (result i32) (br 0 (i32.const 2))
+        (then (i32.const 0))
+        (else (i32.const 1))
+      )
+    )
+  )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #2
+;;       mov     w0, w16
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/br/as_if_else.wat b/tests/disas/winch/aarch64/br/as_if_else.wat
new file mode 100644
index 000000000000..aceb081f1a17
--- /dev/null
+++ b/tests/disas/winch/aarch64/br/as_if_else.wat
@@ -0,0 +1,35 @@
+;;! target = "aarch64"
+;;! test = "winch"
+(module
+  (func (export "as-if-else") (param i32 i32) (result i32)
+    (block (result i32)
+      (if (result i32) (local.get 0)
+        (then (local.get 1))
+        (else (br 1 (i32.const 4)))
+      )
+    )
+  )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       stur    w3, [x28]
+;;       ldur    w0, [x28, #4]
+;;       tst     w0, w0
+;;       b.eq    #0x40
+;;       b       #0x38
+;;   38: ldur    w0, [x28]
+;;       b       #0x48
+;;   40: mov     x16, #4
+;;       mov     w0, w16
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/br/as_if_then.wat b/tests/disas/winch/aarch64/br/as_if_then.wat
new file mode 100644
index 000000000000..f319367a9827
--- /dev/null
+++ b/tests/disas/winch/aarch64/br/as_if_then.wat
@@ -0,0 +1,35 @@
+;;! target = "aarch64"
+;;! test = "winch"
+(module
+  (func (export "as-if-then") (param i32 i32) (result i32)
+    (block (result i32)
+      (if (result i32) (local.get 0)
+        (then (br 1 (i32.const 3)))
+        (else (local.get 1))
+      )
+    )
+  )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       stur    w3, [x28]
+;;       ldur    w0, [x28, #4]
+;;       tst     w0, w0
+;;       b.eq    #0x44
+;;       b       #0x38
+;;   38: mov     x16, #3
+;;       mov     w0, w16
+;;       b       #0x48
+;;   44: ldur    w0, [x28]
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/br/as_loop_first.wat b/tests/disas/winch/aarch64/br/as_loop_first.wat
new file mode 100644
index 000000000000..2c08b25b424d
--- /dev/null
+++ b/tests/disas/winch/aarch64/br/as_loop_first.wat
@@ -0,0 +1,23 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+  (func (export "as-loop-first") (result i32)
+    (block (result i32) (loop (result i32) (br 1 (i32.const 3)) (i32.const 2)))
+  )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #3
+;;       mov     w0, w16
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/br/br_jump.wat b/tests/disas/winch/aarch64/br/br_jump.wat
new file mode 100644
index 000000000000..6f70315187fa
--- /dev/null
+++ b/tests/disas/winch/aarch64/br/br_jump.wat
@@ -0,0 +1,41 @@
+;;! target = "aarch64"
+;;! test = "winch"
+(module
+  (func (;0;) (result i32)
+    (local i32)
+    local.get 0
+    loop ;; label = @1
+      local.get 0
+      block ;; label = @2
+      end
+      br 0 (;@1;)
+    end
+  )
+  (export "" (func 0))
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       ldur    w16, [x28, #4]
+;;       sub     sp, sp, #8
+;;       mov     x28, sp
+;;       stur    x16, [x28, #8]
+;;       ldur    w16, [x28, #0xc]
+;;       sub     sp, sp, #8
+;;       mov     x28, sp
+;;       stur    x16, [x28, #8]
+;;       add     sp, sp, #8
+;;       mov     x28, sp
+;;       b       #0x38
+;;   54: add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/br_if/as_br_if_cond.wat b/tests/disas/winch/aarch64/br_if/as_br_if_cond.wat
new file mode 100644
index 000000000000..cdc2ce73c77a
--- /dev/null
+++ b/tests/disas/winch/aarch64/br_if/as_br_if_cond.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+(module
+  (func (export "as-br-if-cond")
+    (block (br_if 0 (br_if 0 (i32.const 1) (i32.const 1))))
+  )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       tst     w0, w0
+;;       b.ne    #0x48
+;;       b       #0x34
+;;   34: mov     x16, #1
+;;       mov     w0, w16
+;;       tst     w0, w0
+;;       b.ne    #0x48
+;;       b       #0x48
+;;   48: add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/br_if/as_br_value.wat b/tests/disas/winch/aarch64/br_if/as_br_value.wat
new file mode 100644
index 000000000000..9199431a6058
--- /dev/null
+++ b/tests/disas/winch/aarch64/br_if/as_br_value.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+(module
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (br_if 0 (i32.const 1) (i32.const 2))))
+  )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #2
+;;       mov     w1, w16
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       tst     w1, w1
+;;       b.ne    #0x3c
+;;       b       #0x3c
+;;   3c: add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/br_if/as_if_cond.wat b/tests/disas/winch/aarch64/br_if/as_if_cond.wat
new file mode 100644
index 000000000000..4cf84a022d81
--- /dev/null
+++ b/tests/disas/winch/aarch64/br_if/as_if_cond.wat
@@ -0,0 +1,41 @@
+;;! target = "aarch64"
+;;! test = "winch"
+(module
+  (func (export "as-if-cond") (param i32) (result i32)
+    (block (result i32)
+      (if (result i32)
+        (br_if 0 (i32.const 1) (local.get 0))
+        (then (i32.const 2))
+        (else (i32.const 3))
+      )
+    )
+  )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       ldur    w1, [x28, #4]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       tst     w1, w1
+;;       b.ne    #0x5c
+;;       b       #0x3c
+;;   3c: tst     w0, w0
+;;       b.eq    #0x54
+;;       b       #0x48
+;;   48: mov     x16, #2
+;;       mov     w0, w16
+;;       b       #0x5c
+;;   54: mov     x16, #3
+;;       mov     w0, w16
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/br_if/as_local_set_value.wat b/tests/disas/winch/aarch64/br_if/as_local_set_value.wat
new file mode 100644
index 000000000000..54557e5ea58f
--- /dev/null
+++ b/tests/disas/winch/aarch64/br_if/as_local_set_value.wat
@@ -0,0 +1,37 @@
+;;! target = "aarch64"
+;;! test = "winch"
+(module
+  (func (export "as-local-set-value") (param i32) (result i32)
+    (local i32)
+    (block (result i32)
+      (local.set 0 (br_if 0 (i32.const 17) (local.get 0)))
+      (i32.const -1)
+    )
+  )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       mov     x16, #0
+;;       stur    w16, [x28]
+;;       mov     x16, #0
+;;       ldur    w1, [x28, #4]
+;;       mov     x16, #0x11
+;;       mov     w0, w16
+;;       tst     w1, w1
+;;       b.ne    #0x54
+;;       b       #0x48
+;;   48: stur    w0, [x28, #4]
+;;       orr     x16, xzr, #0xffffffff
+;;       mov     w0, w16
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/br_table/large.wat b/tests/disas/winch/aarch64/br_table/large.wat
new file mode 100644
index 000000000000..6757f69364e7
--- /dev/null
+++ b/tests/disas/winch/aarch64/br_table/large.wat
@@ -0,0 +1,25384 @@
+;;! target = "aarch64"
+;;! test = "winch"
+(module
+  (func (export "large") (param i32) (result i32)
+    (block
+      (block
+        (br_table
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          (local.get 0)
+        )
+        (return (i32.const -1))
+      )
+      (return (i32.const 0))
+    )
+    (return (i32.const 1))
+  )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       ldur    w0, [x28, #4]
+;;       mov     x16, #0x6027
+;;       cmp     x0, x16, uxtx
+;;       b.hs    #0x180f4
+;;   34: csel    x1, xzr, x0, hs
+;;       csdb
+;;       adr     x16, #0x4c
+;;       ldrsw   x1, [x16, w1, uxtw #2]
+;;       add     x16, x16, x1
+;;       br      x16
+;;   4c: .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       .byte   0xa8, 0x80, 0x01, 0x00
+;;       .byte   0x9c, 0x80, 0x01, 0x00
+;;       mov     x16, #0
+;;       mov     w0, w16
+;;       b       #0x180fc
+;; 180f4: mov     x16, #1
+;;       mov     w0, w16
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/br_table/nested_br_table_loop_block.wat b/tests/disas/winch/aarch64/br_table/nested_br_table_loop_block.wat
new file mode 100644
index 000000000000..465544eed40d
--- /dev/null
+++ b/tests/disas/winch/aarch64/br_table/nested_br_table_loop_block.wat
@@ -0,0 +1,62 @@
+;;! target = "aarch64"
+;;! test = "winch"
+(module
+  (func (export "nested-br_table-loop-block") (param i32) (result i32)
+    (local.set 0
+      (loop (result i32)
+        (block
+          (br_table 1 0 0 (local.get 0))
+        )
+        (i32.const 0)
+      )
+    )
+    (loop (result i32)
+      (block
+        (br_table 0 1 1 (local.get 0))
+      )
+      (i32.const 3)
+    )
+  )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       ldur    w0, [x28, #4]
+;;       cmp     x0, #2
+;;       b.hs    #0x54
+;;   30: csel    x1, xzr, x0, hs
+;;       csdb
+;;       adr     x16, #0x48
+;;       ldrsw   x1, [x16, w1, uxtw #2]
+;;       add     x16, x16, x1
+;;       br      x16
+;;   48: .byte   0xdc, 0xff, 0xff, 0xff
+;;       .byte   0x0c, 0x00, 0x00, 0x00
+;;       b       #0x24
+;;   54: mov     x16, #0
+;;       mov     w0, w16
+;;       stur    w0, [x28, #4]
+;;       ldur    w0, [x28, #4]
+;;       cmp     x0, #2
+;;       b.hs    #0x60
+;;   6c: csel    x1, xzr, x0, hs
+;;       csdb
+;;       adr     x16, #0x84
+;;       ldrsw   x1, [x16, w1, uxtw #2]
+;;       add     x16, x16, x1
+;;       br      x16
+;;   84: .byte   0x08, 0x00, 0x00, 0x00
+;;       .byte   0xdc, 0xff, 0xff, 0xff
+;;       mov     x16, #3
+;;       mov     w0, w16
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_abs/f32_abs_const.wat b/tests/disas/winch/aarch64/f32_abs/f32_abs_const.wat
new file mode 100644
index 000000000000..cdb328425488
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_abs/f32_abs_const.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (f32.const -1.32)
+        (f32.abs)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     w16, #0xf5c3
+;;       movk    w16, #0xbfa8, lsl #16
+;;       fmov    s0, w16
+;;       fabs    s0, s0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_abs/f32_abs_param.wat b/tests/disas/winch/aarch64/f32_abs/f32_abs_param.wat
new file mode 100644
index 000000000000..2486629e0cda
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_abs/f32_abs_param.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (result f32)
+        (local.get 0)
+        (f32.abs)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    s0, [x28, #4]
+;;       ldur    s0, [x28, #4]
+;;       fabs    s0, s0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_add/const.wat b/tests/disas/winch/aarch64/f32_add/const.wat
new file mode 100644
index 000000000000..94d811f6b197
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_add/const.wat
@@ -0,0 +1,31 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (f32.const 1.1)
+        (f32.const 2.2)
+        (f32.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     w16, #0xcccd
+;;       movk    w16, #0x400c, lsl #16
+;;       fmov    s0, w16
+;;       mov     w16, #0xcccd
+;;       movk    w16, #0x3f8c, lsl #16
+;;       fmov    s1, w16
+;;       fadd    s1, s1, s0
+;;       fmov    s0, s1
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_add/locals.wat b/tests/disas/winch/aarch64/f32_add/locals.wat
new file mode 100644
index 000000000000..602657d8198b
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_add/locals.wat
@@ -0,0 +1,46 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (local $foo f32)  
+        (local $bar f32)
+
+        (f32.const 1.1)
+        (local.set $foo)
+
+        (f32.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f32.add
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     w16, #0xcccd
+;;       movk    w16, #0x3f8c, lsl #16
+;;       fmov    s0, w16
+;;       stur    s0, [x28, #4]
+;;       mov     w16, #0xcccd
+;;       movk    w16, #0x400c, lsl #16
+;;       fmov    s0, w16
+;;       stur    s0, [x28]
+;;       ldur    s0, [x28]
+;;       ldur    s1, [x28, #4]
+;;       fadd    s1, s1, s0
+;;       fmov    s0, s1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_add/params.wat b/tests/disas/winch/aarch64/f32_add/params.wat
new file mode 100644
index 000000000000..a94b2ede0172
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_add/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (param f32) (result f32)
+        (local.get 0)
+        (local.get 1)
+        (f32.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    s0, [x28, #4]
+;;       stur    s1, [x28]
+;;       ldur    s0, [x28]
+;;       ldur    s1, [x28, #4]
+;;       fadd    s1, s1, s0
+;;       fmov    s0, s1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_ceil/f32_ceil_const.wat b/tests/disas/winch/aarch64/f32_ceil/f32_ceil_const.wat
new file mode 100644
index 000000000000..3ad47e206f61
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_ceil/f32_ceil_const.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (f32.const -1.32)
+        (f32.ceil)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     w16, #0xf5c3
+;;       movk    w16, #0xbfa8, lsl #16
+;;       fmov    s0, w16
+;;       frintp  s0, s0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_ceil/f32_ceil_param.wat b/tests/disas/winch/aarch64/f32_ceil/f32_ceil_param.wat
new file mode 100644
index 000000000000..9dcdf4215430
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_ceil/f32_ceil_param.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (result f32)
+        (local.get 0)
+        (f32.ceil)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    s0, [x28, #4]
+;;       ldur    s0, [x28, #4]
+;;       frintp  s0, s0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_copysign/const.wat b/tests/disas/winch/aarch64/f32_copysign/const.wat
new file mode 100644
index 000000000000..a1c1b01a5c34
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_copysign/const.wat
@@ -0,0 +1,32 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (f32.const -1.1)
+        (f32.const 2.2)
+        (f32.copysign)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     w16, #0xcccd
+;;       movk    w16, #0x400c, lsl #16
+;;       fmov    s0, w16
+;;       mov     w16, #0xcccd
+;;       movk    w16, #0xbf8c, lsl #16
+;;       fmov    s1, w16
+;;       ushr    v0.2s, v0.2s, #0x1f
+;;       sli     v1.2s, v0.2s, #0x1f
+;;       fmov    s0, s1
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_copysign/locals.wat b/tests/disas/winch/aarch64/f32_copysign/locals.wat
new file mode 100644
index 000000000000..59a6811dee64
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_copysign/locals.wat
@@ -0,0 +1,47 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (local $foo f32)  
+        (local $bar f32)
+
+        (f32.const -1.1)
+        (local.set $foo)
+
+        (f32.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f32.copysign
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     w16, #0xcccd
+;;       movk    w16, #0xbf8c, lsl #16
+;;       fmov    s0, w16
+;;       stur    s0, [x28, #4]
+;;       mov     w16, #0xcccd
+;;       movk    w16, #0x400c, lsl #16
+;;       fmov    s0, w16
+;;       stur    s0, [x28]
+;;       ldur    s0, [x28]
+;;       ldur    s1, [x28, #4]
+;;       ushr    v0.2s, v0.2s, #0x1f
+;;       sli     v1.2s, v0.2s, #0x1f
+;;       fmov    s0, s1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_copysign/params.wat b/tests/disas/winch/aarch64/f32_copysign/params.wat
new file mode 100644
index 000000000000..120b363dd016
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_copysign/params.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (param f32) (result f32)
+        (local.get 0)
+        (local.get 1)
+        (f32.copysign)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    s0, [x28, #4]
+;;       stur    s1, [x28]
+;;       ldur    s0, [x28]
+;;       ldur    s1, [x28, #4]
+;;       ushr    v0.2s, v0.2s, #0x1f
+;;       sli     v1.2s, v0.2s, #0x1f
+;;       fmov    s0, s1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_demote_f64/const.wat b/tests/disas/winch/aarch64/f32_demote_f64/const.wat
new file mode 100644
index 000000000000..2417d4ec9b84
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_demote_f64/const.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (f64.const 1.0)
+        (f32.demote_f64)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0x3ff0000000000000
+;;       fmov    d0, x16
+;;       fcvt    s0, d0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_demote_f64/locals.wat b/tests/disas/winch/aarch64/f32_demote_f64/locals.wat
new file mode 100644
index 000000000000..8a6bde99155a
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_demote_f64/locals.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (local f64)  
+
+        (local.get 0)
+        (f32.demote_f64)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       ldur    d0, [x28]
+;;       fcvt    s0, d0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_demote_f64/params.wat b/tests/disas/winch/aarch64/f32_demote_f64/params.wat
new file mode 100644
index 000000000000..8e69ab7be3fc
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_demote_f64/params.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (result f32)
+        (local.get 0)
+        (f32.demote_f64)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    d0, [x28]
+;;       ldur    d0, [x28]
+;;       fcvt    s0, d0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_div/const.wat b/tests/disas/winch/aarch64/f32_div/const.wat
new file mode 100644
index 000000000000..9fa99babdd8a
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_div/const.wat
@@ -0,0 +1,31 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (f32.const 1.1)
+        (f32.const 2.2)
+        (f32.div)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     w16, #0xcccd
+;;       movk    w16, #0x400c, lsl #16
+;;       fmov    s0, w16
+;;       mov     w16, #0xcccd
+;;       movk    w16, #0x3f8c, lsl #16
+;;       fmov    s1, w16
+;;       fdiv    s1, s1, s0
+;;       fmov    s0, s1
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_div/locals.wat b/tests/disas/winch/aarch64/f32_div/locals.wat
new file mode 100644
index 000000000000..8d467e5c314b
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_div/locals.wat
@@ -0,0 +1,46 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (local $foo f32)  
+        (local $bar f32)
+
+        (f32.const 1.1)
+        (local.set $foo)
+
+        (f32.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f32.div
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     w16, #0xcccd
+;;       movk    w16, #0x3f8c, lsl #16
+;;       fmov    s0, w16
+;;       stur    s0, [x28, #4]
+;;       mov     w16, #0xcccd
+;;       movk    w16, #0x400c, lsl #16
+;;       fmov    s0, w16
+;;       stur    s0, [x28]
+;;       ldur    s0, [x28]
+;;       ldur    s1, [x28, #4]
+;;       fdiv    s1, s1, s0
+;;       fmov    s0, s1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_div/params.wat b/tests/disas/winch/aarch64/f32_div/params.wat
new file mode 100644
index 000000000000..e3dc8d6ed3ee
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_div/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (param f32) (result f32)
+        (local.get 0)
+        (local.get 1)
+        (f32.div)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    s0, [x28, #4]
+;;       stur    s1, [x28]
+;;       ldur    s0, [x28]
+;;       ldur    s1, [x28, #4]
+;;       fdiv    s1, s1, s0
+;;       fmov    s0, s1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_eq/const.wat b/tests/disas/winch/aarch64/f32_eq/const.wat
new file mode 100644
index 000000000000..3b259da259bb
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_eq/const.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (f32.const 1)
+        (f32.const 1)
+        (f32.eq)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0x3f800000
+;;       fmov    s0, w16
+;;       mov     x16, #0x3f800000
+;;       fmov    s1, w16
+;;       fcmp    s0, s1
+;;       cset    x0, eq
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_eq/locals.wat b/tests/disas/winch/aarch64/f32_eq/locals.wat
new file mode 100644
index 000000000000..2b6acca027df
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_eq/locals.wat
@@ -0,0 +1,44 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo f32)
+        (local $bar f32)
+
+        (f32.const 2)
+        (local.set $foo)
+        (f32.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (f32.eq)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     x16, #0x40000000
+;;       fmov    s0, w16
+;;       stur    s0, [x28, #4]
+;;       mov     x16, #0x40400000
+;;       fmov    s0, w16
+;;       stur    s0, [x28]
+;;       ldur    s0, [x28]
+;;       ldur    s1, [x28, #4]
+;;       fcmp    s0, s1
+;;       cset    x0, eq
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_eq/params.wat b/tests/disas/winch/aarch64/f32_eq/params.wat
new file mode 100644
index 000000000000..7cdf60228e59
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_eq/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (param f32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (f32.eq)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    s0, [x28, #4]
+;;       stur    s1, [x28]
+;;       ldur    s0, [x28]
+;;       ldur    s1, [x28, #4]
+;;       fcmp    s0, s1
+;;       cset    x0, eq
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_floor/f32_floor_const.wat b/tests/disas/winch/aarch64/f32_floor/f32_floor_const.wat
new file mode 100644
index 000000000000..18877fe3735f
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_floor/f32_floor_const.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (f32.const -1.32)
+        (f32.floor)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     w16, #0xf5c3
+;;       movk    w16, #0xbfa8, lsl #16
+;;       fmov    s0, w16
+;;       frintm  s0, s0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_floor/f32_floor_param.wat b/tests/disas/winch/aarch64/f32_floor/f32_floor_param.wat
new file mode 100644
index 000000000000..367b76e34602
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_floor/f32_floor_param.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (result f32)
+        (local.get 0)
+        (f32.floor)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    s0, [x28, #4]
+;;       ldur    s0, [x28, #4]
+;;       frintm  s0, s0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_ge/const.wat b/tests/disas/winch/aarch64/f32_ge/const.wat
new file mode 100644
index 000000000000..fdcc5e297496
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_ge/const.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (f32.const -1)
+        (f32.const -2)
+        (f32.ge)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0xc0000000
+;;       fmov    s0, w16
+;;       mov     x16, #0xbf800000
+;;       fmov    s1, w16
+;;       fcmp    s0, s1
+;;       cset    x0, ge
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_ge/locals.wat b/tests/disas/winch/aarch64/f32_ge/locals.wat
new file mode 100644
index 000000000000..7fb8d52d8337
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_ge/locals.wat
@@ -0,0 +1,44 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo f32)
+        (local $bar f32)
+
+        (f32.const -2)
+        (local.set $foo)
+        (f32.const -3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (f32.ge)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     x16, #0xc0000000
+;;       fmov    s0, w16
+;;       stur    s0, [x28, #4]
+;;       mov     x16, #0xc0400000
+;;       fmov    s0, w16
+;;       stur    s0, [x28]
+;;       ldur    s0, [x28]
+;;       ldur    s1, [x28, #4]
+;;       fcmp    s0, s1
+;;       cset    x0, ge
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_ge/params.wat b/tests/disas/winch/aarch64/f32_ge/params.wat
new file mode 100644
index 000000000000..261a7b9e91db
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_ge/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (param f32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (f32.ge)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    s0, [x28, #4]
+;;       stur    s1, [x28]
+;;       ldur    s0, [x28]
+;;       ldur    s1, [x28, #4]
+;;       fcmp    s0, s1
+;;       cset    x0, ge
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_gt/const.wat b/tests/disas/winch/aarch64/f32_gt/const.wat
new file mode 100644
index 000000000000..a5f6f8b91f3f
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_gt/const.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (f32.const -1)
+        (f32.const -2)
+        (f32.gt)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0xc0000000
+;;       fmov    s0, w16
+;;       mov     x16, #0xbf800000
+;;       fmov    s1, w16
+;;       fcmp    s0, s1
+;;       cset    x0, gt
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_gt/locals.wat b/tests/disas/winch/aarch64/f32_gt/locals.wat
new file mode 100644
index 000000000000..08f85ea126ff
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_gt/locals.wat
@@ -0,0 +1,44 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo f32)
+        (local $bar f32)
+
+        (f32.const -2)
+        (local.set $foo)
+        (f32.const -3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (f32.gt)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     x16, #0xc0000000
+;;       fmov    s0, w16
+;;       stur    s0, [x28, #4]
+;;       mov     x16, #0xc0400000
+;;       fmov    s0, w16
+;;       stur    s0, [x28]
+;;       ldur    s0, [x28]
+;;       ldur    s1, [x28, #4]
+;;       fcmp    s0, s1
+;;       cset    x0, gt
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_gt/params.wat b/tests/disas/winch/aarch64/f32_gt/params.wat
new file mode 100644
index 000000000000..8f879b802ede
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_gt/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (param f32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (f32.gt)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    s0, [x28, #4]
+;;       stur    s1, [x28]
+;;       ldur    s0, [x28]
+;;       ldur    s1, [x28, #4]
+;;       fcmp    s0, s1
+;;       cset    x0, gt
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_le/const.wat b/tests/disas/winch/aarch64/f32_le/const.wat
new file mode 100644
index 000000000000..f2997fd7107c
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_le/const.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (f32.const -1)
+        (f32.const -2)
+        (f32.le)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0xc0000000
+;;       fmov    s0, w16
+;;       mov     x16, #0xbf800000
+;;       fmov    s1, w16
+;;       fcmp    s0, s1
+;;       cset    x0, ls
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_le/locals.wat b/tests/disas/winch/aarch64/f32_le/locals.wat
new file mode 100644
index 000000000000..f00c4f424438
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_le/locals.wat
@@ -0,0 +1,44 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo f32)
+        (local $bar f32)
+
+        (f32.const -2)
+        (local.set $foo)
+        (f32.const -3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (f32.le)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     x16, #0xc0000000
+;;       fmov    s0, w16
+;;       stur    s0, [x28, #4]
+;;       mov     x16, #0xc0400000
+;;       fmov    s0, w16
+;;       stur    s0, [x28]
+;;       ldur    s0, [x28]
+;;       ldur    s1, [x28, #4]
+;;       fcmp    s0, s1
+;;       cset    x0, ls
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_le/params.wat b/tests/disas/winch/aarch64/f32_le/params.wat
new file mode 100644
index 000000000000..9928d133b722
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_le/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (param f32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (f32.le)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    s0, [x28, #4]
+;;       stur    s1, [x28]
+;;       ldur    s0, [x28]
+;;       ldur    s1, [x28, #4]
+;;       fcmp    s0, s1
+;;       cset    x0, ls
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_lt/const.wat b/tests/disas/winch/aarch64/f32_lt/const.wat
new file mode 100644
index 000000000000..0964c59b05de
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_lt/const.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (f32.const -1)
+        (f32.const -2)
+        (f32.lt)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0xc0000000
+;;       fmov    s0, w16
+;;       mov     x16, #0xbf800000
+;;       fmov    s1, w16
+;;       fcmp    s0, s1
+;;       cset    x0, mi
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_lt/locals.wat b/tests/disas/winch/aarch64/f32_lt/locals.wat
new file mode 100644
index 000000000000..58c3b3f4923d
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_lt/locals.wat
@@ -0,0 +1,44 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo f32)
+        (local $bar f32)
+
+        (f32.const -2)
+        (local.set $foo)
+        (f32.const -3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (f32.lt)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     x16, #0xc0000000
+;;       fmov    s0, w16
+;;       stur    s0, [x28, #4]
+;;       mov     x16, #0xc0400000
+;;       fmov    s0, w16
+;;       stur    s0, [x28]
+;;       ldur    s0, [x28]
+;;       ldur    s1, [x28, #4]
+;;       fcmp    s0, s1
+;;       cset    x0, mi
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_lt/params.wat b/tests/disas/winch/aarch64/f32_lt/params.wat
new file mode 100644
index 000000000000..56f31d238b41
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_lt/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (param f32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (f32.lt)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    s0, [x28, #4]
+;;       stur    s1, [x28]
+;;       ldur    s0, [x28]
+;;       ldur    s1, [x28, #4]
+;;       fcmp    s0, s1
+;;       cset    x0, mi
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_max/const.wat b/tests/disas/winch/aarch64/f32_max/const.wat
new file mode 100644
index 000000000000..1776544f2327
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_max/const.wat
@@ -0,0 +1,31 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (f32.const 1.1)
+        (f32.const 2.2)
+        (f32.max)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     w16, #0xcccd
+;;       movk    w16, #0x400c, lsl #16
+;;       fmov    s0, w16
+;;       mov     w16, #0xcccd
+;;       movk    w16, #0x3f8c, lsl #16
+;;       fmov    s1, w16
+;;       fmax    s1, s1, s0
+;;       fmov    s0, s1
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_max/locals.wat b/tests/disas/winch/aarch64/f32_max/locals.wat
new file mode 100644
index 000000000000..2570965c0507
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_max/locals.wat
@@ -0,0 +1,46 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (local $foo f32)  
+        (local $bar f32)
+
+        (f32.const 1.1)
+        (local.set $foo)
+
+        (f32.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f32.max
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     w16, #0xcccd
+;;       movk    w16, #0x3f8c, lsl #16
+;;       fmov    s0, w16
+;;       stur    s0, [x28, #4]
+;;       mov     w16, #0xcccd
+;;       movk    w16, #0x400c, lsl #16
+;;       fmov    s0, w16
+;;       stur    s0, [x28]
+;;       ldur    s0, [x28]
+;;       ldur    s1, [x28, #4]
+;;       fmax    s1, s1, s0
+;;       fmov    s0, s1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_max/params.wat b/tests/disas/winch/aarch64/f32_max/params.wat
new file mode 100644
index 000000000000..5333168e4020
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_max/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (param f32) (result f32)
+        (local.get 0)
+        (local.get 1)
+        (f32.max)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    s0, [x28, #4]
+;;       stur    s1, [x28]
+;;       ldur    s0, [x28]
+;;       ldur    s1, [x28, #4]
+;;       fmax    s1, s1, s0
+;;       fmov    s0, s1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_min/const.wat b/tests/disas/winch/aarch64/f32_min/const.wat
new file mode 100644
index 000000000000..eab83fe9e11a
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_min/const.wat
@@ -0,0 +1,31 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (f32.const 1.1)
+        (f32.const 2.2)
+        (f32.min)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     w16, #0xcccd
+;;       movk    w16, #0x400c, lsl #16
+;;       fmov    s0, w16
+;;       mov     w16, #0xcccd
+;;       movk    w16, #0x3f8c, lsl #16
+;;       fmov    s1, w16
+;;       fmin    s1, s1, s0
+;;       fmov    s0, s1
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_min/locals.wat b/tests/disas/winch/aarch64/f32_min/locals.wat
new file mode 100644
index 000000000000..dcab615fc6b5
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_min/locals.wat
@@ -0,0 +1,46 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (local $foo f32)  
+        (local $bar f32)
+
+        (f32.const 1.1)
+        (local.set $foo)
+
+        (f32.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f32.min
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     w16, #0xcccd
+;;       movk    w16, #0x3f8c, lsl #16
+;;       fmov    s0, w16
+;;       stur    s0, [x28, #4]
+;;       mov     w16, #0xcccd
+;;       movk    w16, #0x400c, lsl #16
+;;       fmov    s0, w16
+;;       stur    s0, [x28]
+;;       ldur    s0, [x28]
+;;       ldur    s1, [x28, #4]
+;;       fmin    s1, s1, s0
+;;       fmov    s0, s1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_min/params.wat b/tests/disas/winch/aarch64/f32_min/params.wat
new file mode 100644
index 000000000000..988a5b4d4672
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_min/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (param f32) (result f32)
+        (local.get 0)
+        (local.get 1)
+        (f32.min)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    s0, [x28, #4]
+;;       stur    s1, [x28]
+;;       ldur    s0, [x28]
+;;       ldur    s1, [x28, #4]
+;;       fmin    s1, s1, s0
+;;       fmov    s0, s1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_mul/const.wat b/tests/disas/winch/aarch64/f32_mul/const.wat
new file mode 100644
index 000000000000..5f0d0bf055e1
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_mul/const.wat
@@ -0,0 +1,31 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (f32.const 1.1)
+        (f32.const 2.2)
+        (f32.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     w16, #0xcccd
+;;       movk    w16, #0x400c, lsl #16
+;;       fmov    s0, w16
+;;       mov     w16, #0xcccd
+;;       movk    w16, #0x3f8c, lsl #16
+;;       fmov    s1, w16
+;;       fmul    s1, s1, s0
+;;       fmov    s0, s1
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_mul/locals.wat b/tests/disas/winch/aarch64/f32_mul/locals.wat
new file mode 100644
index 000000000000..9f05bc2cd33b
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_mul/locals.wat
@@ -0,0 +1,46 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (local $foo f32)  
+        (local $bar f32)
+
+        (f32.const 1.1)
+        (local.set $foo)
+
+        (f32.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f32.mul
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     w16, #0xcccd
+;;       movk    w16, #0x3f8c, lsl #16
+;;       fmov    s0, w16
+;;       stur    s0, [x28, #4]
+;;       mov     w16, #0xcccd
+;;       movk    w16, #0x400c, lsl #16
+;;       fmov    s0, w16
+;;       stur    s0, [x28]
+;;       ldur    s0, [x28]
+;;       ldur    s1, [x28, #4]
+;;       fmul    s1, s1, s0
+;;       fmov    s0, s1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_mul/params.wat b/tests/disas/winch/aarch64/f32_mul/params.wat
new file mode 100644
index 000000000000..56aeec8f4316
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_mul/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (param f32) (result f32)
+        (local.get 0)
+        (local.get 1)
+        (f32.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    s0, [x28, #4]
+;;       stur    s1, [x28]
+;;       ldur    s0, [x28]
+;;       ldur    s1, [x28, #4]
+;;       fmul    s1, s1, s0
+;;       fmov    s0, s1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_ne/const.wat b/tests/disas/winch/aarch64/f32_ne/const.wat
new file mode 100644
index 000000000000..cfded0a52f26
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_ne/const.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (f32.const 1)
+        (f32.const 2)
+        (f32.ne)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0x40000000
+;;       fmov    s0, w16
+;;       mov     x16, #0x3f800000
+;;       fmov    s1, w16
+;;       fcmp    s0, s1
+;;       cset    x0, ne
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_ne/locals.wat b/tests/disas/winch/aarch64/f32_ne/locals.wat
new file mode 100644
index 000000000000..29c35514dc2b
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_ne/locals.wat
@@ -0,0 +1,44 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo f32)
+        (local $bar f32)
+
+        (f32.const 2)
+        (local.set $foo)
+        (f32.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (f32.ne)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     x16, #0x40000000
+;;       fmov    s0, w16
+;;       stur    s0, [x28, #4]
+;;       mov     x16, #0x40400000
+;;       fmov    s0, w16
+;;       stur    s0, [x28]
+;;       ldur    s0, [x28]
+;;       ldur    s1, [x28, #4]
+;;       fcmp    s0, s1
+;;       cset    x0, ne
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_ne/params.wat b/tests/disas/winch/aarch64/f32_ne/params.wat
new file mode 100644
index 000000000000..5da87b1ea612
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_ne/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (param f32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (f32.ne)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    s0, [x28, #4]
+;;       stur    s1, [x28]
+;;       ldur    s0, [x28]
+;;       ldur    s1, [x28, #4]
+;;       fcmp    s0, s1
+;;       cset    x0, ne
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_nearest/f32_nearest_const.wat b/tests/disas/winch/aarch64/f32_nearest/f32_nearest_const.wat
new file mode 100644
index 000000000000..fec54319487e
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_nearest/f32_nearest_const.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (f32.const -1.32)
+        (f32.nearest)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     w16, #0xf5c3
+;;       movk    w16, #0xbfa8, lsl #16
+;;       fmov    s0, w16
+;;       frintn  s0, s0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_nearest/f32_nearest_param.wat b/tests/disas/winch/aarch64/f32_nearest/f32_nearest_param.wat
new file mode 100644
index 000000000000..a2a5ab26b010
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_nearest/f32_nearest_param.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (result f32)
+        (local.get 0)
+        (f32.nearest)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    s0, [x28, #4]
+;;       ldur    s0, [x28, #4]
+;;       frintn  s0, s0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_neg/f32_neg_const.wat b/tests/disas/winch/aarch64/f32_neg/f32_neg_const.wat
new file mode 100644
index 000000000000..7998653eaf86
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_neg/f32_neg_const.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (f32.const -1.32)
+        (f32.neg)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     w16, #0xf5c3
+;;       movk    w16, #0xbfa8, lsl #16
+;;       fmov    s0, w16
+;;       fneg    s0, s0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_neg/f32_neg_param.wat b/tests/disas/winch/aarch64/f32_neg/f32_neg_param.wat
new file mode 100644
index 000000000000..b2477edca911
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_neg/f32_neg_param.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (result f32)
+        (local.get 0)
+        (f32.neg)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    s0, [x28, #4]
+;;       ldur    s0, [x28, #4]
+;;       fneg    s0, s0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_sqrt/f32_sqrt_const.wat b/tests/disas/winch/aarch64/f32_sqrt/f32_sqrt_const.wat
new file mode 100644
index 000000000000..4c10b9ed69cd
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_sqrt/f32_sqrt_const.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (f32.const 1.32)
+        (f32.sqrt)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     w16, #0xf5c3
+;;       movk    w16, #0x3fa8, lsl #16
+;;       fmov    s0, w16
+;;       fsqrt   s0, s0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_sqrt/f32_sqrt_param.wat b/tests/disas/winch/aarch64/f32_sqrt/f32_sqrt_param.wat
new file mode 100644
index 000000000000..426da3f07c14
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_sqrt/f32_sqrt_param.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (result f32)
+        (local.get 0)
+        (f32.sqrt)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    s0, [x28, #4]
+;;       ldur    s0, [x28, #4]
+;;       fsqrt   s0, s0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_sub/const.wat b/tests/disas/winch/aarch64/f32_sub/const.wat
new file mode 100644
index 000000000000..786e3fc9c6c9
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_sub/const.wat
@@ -0,0 +1,31 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (f32.const 1.1)
+        (f32.const 2.2)
+        (f32.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     w16, #0xcccd
+;;       movk    w16, #0x400c, lsl #16
+;;       fmov    s0, w16
+;;       mov     w16, #0xcccd
+;;       movk    w16, #0x3f8c, lsl #16
+;;       fmov    s1, w16
+;;       fsub    s1, s1, s0
+;;       fmov    s0, s1
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_sub/locals.wat b/tests/disas/winch/aarch64/f32_sub/locals.wat
new file mode 100644
index 000000000000..5db3c4410882
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_sub/locals.wat
@@ -0,0 +1,46 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (local $foo f32)  
+        (local $bar f32)
+
+        (f32.const 1.1)
+        (local.set $foo)
+
+        (f32.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f32.sub
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     w16, #0xcccd
+;;       movk    w16, #0x3f8c, lsl #16
+;;       fmov    s0, w16
+;;       stur    s0, [x28, #4]
+;;       mov     w16, #0xcccd
+;;       movk    w16, #0x400c, lsl #16
+;;       fmov    s0, w16
+;;       stur    s0, [x28]
+;;       ldur    s0, [x28]
+;;       ldur    s1, [x28, #4]
+;;       fsub    s1, s1, s0
+;;       fmov    s0, s1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_sub/params.wat b/tests/disas/winch/aarch64/f32_sub/params.wat
new file mode 100644
index 000000000000..079cef501832
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_sub/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (param f32) (result f32)
+        (local.get 0)
+        (local.get 1)
+        (f32.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    s0, [x28, #4]
+;;       stur    s1, [x28]
+;;       ldur    s0, [x28]
+;;       ldur    s1, [x28, #4]
+;;       fsub    s1, s1, s0
+;;       fmov    s0, s1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_trunc/f32_trunc_const.wat b/tests/disas/winch/aarch64/f32_trunc/f32_trunc_const.wat
new file mode 100644
index 000000000000..263b3e6711b0
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_trunc/f32_trunc_const.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (f32.const -1.32)
+        (f32.trunc)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     w16, #0xf5c3
+;;       movk    w16, #0xbfa8, lsl #16
+;;       fmov    s0, w16
+;;       frintz  s0, s0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f32_trunc/f32_trunc_param.wat b/tests/disas/winch/aarch64/f32_trunc/f32_trunc_param.wat
new file mode 100644
index 000000000000..8609a5ce4d84
--- /dev/null
+++ b/tests/disas/winch/aarch64/f32_trunc/f32_trunc_param.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (result f32)
+        (local.get 0)
+        (f32.trunc)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    s0, [x28, #4]
+;;       ldur    s0, [x28, #4]
+;;       frintz  s0, s0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_abs/f64_abs_const.wat b/tests/disas/winch/aarch64/f64_abs/f64_abs_const.wat
new file mode 100644
index 000000000000..066de19546c1
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_abs/f64_abs_const.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (f64.const -1.32)
+        (f64.abs)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0x851f
+;;       movk    x16, #0x51eb, lsl #16
+;;       movk    x16, #0x1eb8, lsl #32
+;;       movk    x16, #0xbff5, lsl #48
+;;       fmov    d0, x16
+;;       fabs    d0, d0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_abs/f64_abs_param.wat b/tests/disas/winch/aarch64/f64_abs/f64_abs_param.wat
new file mode 100644
index 000000000000..2b56f55866ac
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_abs/f64_abs_param.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (result f64)
+        (local.get 0)
+        (f64.abs)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    d0, [x28]
+;;       ldur    d0, [x28]
+;;       fabs    d0, d0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_add/const.wat b/tests/disas/winch/aarch64/f64_add/const.wat
new file mode 100644
index 000000000000..c734942ad277
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_add/const.wat
@@ -0,0 +1,35 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (f64.const 1.1)
+        (f64.const 2.2)
+        (f64.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0x999a
+;;       movk    x16, #0x9999, lsl #16
+;;       movk    x16, #0x9999, lsl #32
+;;       movk    x16, #0x4001, lsl #48
+;;       fmov    d0, x16
+;;       mov     x16, #0x999a
+;;       movk    x16, #0x9999, lsl #16
+;;       movk    x16, #0x9999, lsl #32
+;;       movk    x16, #0x3ff1, lsl #48
+;;       fmov    d1, x16
+;;       fadd    d1, d1, d0
+;;       fmov    d0, d1
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_add/locals.wat b/tests/disas/winch/aarch64/f64_add/locals.wat
new file mode 100644
index 000000000000..12011b318dd3
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_add/locals.wat
@@ -0,0 +1,51 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (local $foo f64)  
+        (local $bar f64)
+
+        (f64.const 1.1)
+        (local.set $foo)
+
+        (f64.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f64.add
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #0x999a
+;;       movk    x16, #0x9999, lsl #16
+;;       movk    x16, #0x9999, lsl #32
+;;       movk    x16, #0x3ff1, lsl #48
+;;       fmov    d0, x16
+;;       stur    d0, [x28, #8]
+;;       mov     x16, #0x999a
+;;       movk    x16, #0x9999, lsl #16
+;;       movk    x16, #0x9999, lsl #32
+;;       movk    x16, #0x4001, lsl #48
+;;       fmov    d0, x16
+;;       stur    d0, [x28]
+;;       ldur    d0, [x28]
+;;       ldur    d1, [x28, #8]
+;;       fadd    d1, d1, d0
+;;       fmov    d0, d1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_add/params.wat b/tests/disas/winch/aarch64/f64_add/params.wat
new file mode 100644
index 000000000000..5e1ee9e0dc4d
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_add/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (param f64) (result f64)
+        (local.get 0)
+        (local.get 1)
+        (f64.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    d0, [x28, #8]
+;;       stur    d1, [x28]
+;;       ldur    d0, [x28]
+;;       ldur    d1, [x28, #8]
+;;       fadd    d1, d1, d0
+;;       fmov    d0, d1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_ceil/f64_ceil_const.wat b/tests/disas/winch/aarch64/f64_ceil/f64_ceil_const.wat
new file mode 100644
index 000000000000..9da2b062e7ca
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_ceil/f64_ceil_const.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (f64.const -1.32)
+        (f64.ceil)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0x851f
+;;       movk    x16, #0x51eb, lsl #16
+;;       movk    x16, #0x1eb8, lsl #32
+;;       movk    x16, #0xbff5, lsl #48
+;;       fmov    d0, x16
+;;       frintp  d0, d0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_ceil/f64_ceil_param.wat b/tests/disas/winch/aarch64/f64_ceil/f64_ceil_param.wat
new file mode 100644
index 000000000000..05d472d440f4
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_ceil/f64_ceil_param.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (result f64)
+        (local.get 0)
+        (f64.ceil)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    d0, [x28]
+;;       ldur    d0, [x28]
+;;       frintp  d0, d0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_copysign/const.wat b/tests/disas/winch/aarch64/f64_copysign/const.wat
new file mode 100644
index 000000000000..5f6e7ce15a05
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_copysign/const.wat
@@ -0,0 +1,36 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (f64.const -1.1)
+        (f64.const 2.2)
+        (f64.copysign)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0x999a
+;;       movk    x16, #0x9999, lsl #16
+;;       movk    x16, #0x9999, lsl #32
+;;       movk    x16, #0x4001, lsl #48
+;;       fmov    d0, x16
+;;       mov     x16, #0x999a
+;;       movk    x16, #0x9999, lsl #16
+;;       movk    x16, #0x9999, lsl #32
+;;       movk    x16, #0xbff1, lsl #48
+;;       fmov    d1, x16
+;;       ushr    d0, d0, #0x3f
+;;       sli     d1, d0, #0x3f
+;;       fmov    d0, d1
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_copysign/locals.wat b/tests/disas/winch/aarch64/f64_copysign/locals.wat
new file mode 100644
index 000000000000..a57c206af371
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_copysign/locals.wat
@@ -0,0 +1,52 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (local $foo f64)  
+        (local $bar f64)
+
+        (f64.const -1.1)
+        (local.set $foo)
+
+        (f64.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f64.copysign
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #0x999a
+;;       movk    x16, #0x9999, lsl #16
+;;       movk    x16, #0x9999, lsl #32
+;;       movk    x16, #0xbff1, lsl #48
+;;       fmov    d0, x16
+;;       stur    d0, [x28, #8]
+;;       mov     x16, #0x999a
+;;       movk    x16, #0x9999, lsl #16
+;;       movk    x16, #0x9999, lsl #32
+;;       movk    x16, #0x4001, lsl #48
+;;       fmov    d0, x16
+;;       stur    d0, [x28]
+;;       ldur    d0, [x28]
+;;       ldur    d1, [x28, #8]
+;;       ushr    d0, d0, #0x3f
+;;       sli     d1, d0, #0x3f
+;;       fmov    d0, d1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_copysign/params.wat b/tests/disas/winch/aarch64/f64_copysign/params.wat
new file mode 100644
index 000000000000..acc24a9f3ce5
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_copysign/params.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (param f64) (result f64)
+        (local.get 0)
+        (local.get 1)
+        (f64.copysign)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    d0, [x28, #8]
+;;       stur    d1, [x28]
+;;       ldur    d0, [x28]
+;;       ldur    d1, [x28, #8]
+;;       ushr    d0, d0, #0x3f
+;;       sli     d1, d0, #0x3f
+;;       fmov    d0, d1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_div/const.wat b/tests/disas/winch/aarch64/f64_div/const.wat
new file mode 100644
index 000000000000..26e1c9d58b31
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_div/const.wat
@@ -0,0 +1,35 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (f64.const 1.1)
+        (f64.const 2.2)
+        (f64.div)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0x999a
+;;       movk    x16, #0x9999, lsl #16
+;;       movk    x16, #0x9999, lsl #32
+;;       movk    x16, #0x4001, lsl #48
+;;       fmov    d0, x16
+;;       mov     x16, #0x999a
+;;       movk    x16, #0x9999, lsl #16
+;;       movk    x16, #0x9999, lsl #32
+;;       movk    x16, #0x3ff1, lsl #48
+;;       fmov    d1, x16
+;;       fdiv    d1, d1, d0
+;;       fmov    d0, d1
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_div/locals.wat b/tests/disas/winch/aarch64/f64_div/locals.wat
new file mode 100644
index 000000000000..b340a8972d9f
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_div/locals.wat
@@ -0,0 +1,51 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (local $foo f64)  
+        (local $bar f64)
+
+        (f64.const 1.1)
+        (local.set $foo)
+
+        (f64.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f64.div
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #0x999a
+;;       movk    x16, #0x9999, lsl #16
+;;       movk    x16, #0x9999, lsl #32
+;;       movk    x16, #0x3ff1, lsl #48
+;;       fmov    d0, x16
+;;       stur    d0, [x28, #8]
+;;       mov     x16, #0x999a
+;;       movk    x16, #0x9999, lsl #16
+;;       movk    x16, #0x9999, lsl #32
+;;       movk    x16, #0x4001, lsl #48
+;;       fmov    d0, x16
+;;       stur    d0, [x28]
+;;       ldur    d0, [x28]
+;;       ldur    d1, [x28, #8]
+;;       fdiv    d1, d1, d0
+;;       fmov    d0, d1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_div/params.wat b/tests/disas/winch/aarch64/f64_div/params.wat
new file mode 100644
index 000000000000..d23cce7a23a3
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_div/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (param f64) (result f64)
+        (local.get 0)
+        (local.get 1)
+        (f64.div)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    d0, [x28, #8]
+;;       stur    d1, [x28]
+;;       ldur    d0, [x28]
+;;       ldur    d1, [x28, #8]
+;;       fdiv    d1, d1, d0
+;;       fmov    d0, d1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_eq/const.wat b/tests/disas/winch/aarch64/f64_eq/const.wat
new file mode 100644
index 000000000000..333a7ee6d91e
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_eq/const.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (f64.const 1)
+        (f64.const 1)
+        (f64.eq)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0x3ff0000000000000
+;;       fmov    d0, x16
+;;       mov     x16, #0x3ff0000000000000
+;;       fmov    d1, x16
+;;       fcmp    d0, d1
+;;       cset    x0, eq
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_eq/locals.wat b/tests/disas/winch/aarch64/f64_eq/locals.wat
new file mode 100644
index 000000000000..5411e9afff2b
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_eq/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo f64)
+        (local $bar f64)
+
+        (f64.const 2)
+        (local.set $foo)
+        (f64.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (f64.eq)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #0x4000000000000000
+;;       fmov    d0, x16
+;;       stur    d0, [x28, #8]
+;;       mov     x16, #0x4008000000000000
+;;       fmov    d0, x16
+;;       stur    d0, [x28]
+;;       ldur    d0, [x28]
+;;       ldur    d1, [x28, #8]
+;;       fcmp    d0, d1
+;;       cset    x0, eq
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_eq/params.wat b/tests/disas/winch/aarch64/f64_eq/params.wat
new file mode 100644
index 000000000000..a94b7c04d5b3
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_eq/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (param f64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (f64.eq)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    d0, [x28, #8]
+;;       stur    d1, [x28]
+;;       ldur    d0, [x28]
+;;       ldur    d1, [x28, #8]
+;;       fcmp    d0, d1
+;;       cset    x0, eq
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_floor/f64_floor_const.wat b/tests/disas/winch/aarch64/f64_floor/f64_floor_const.wat
new file mode 100644
index 000000000000..b99ed31387b1
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_floor/f64_floor_const.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (f64.const -1.32)
+        (f64.floor)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0x851f
+;;       movk    x16, #0x51eb, lsl #16
+;;       movk    x16, #0x1eb8, lsl #32
+;;       movk    x16, #0xbff5, lsl #48
+;;       fmov    d0, x16
+;;       frintm  d0, d0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_floor/f64_floor_param.wat b/tests/disas/winch/aarch64/f64_floor/f64_floor_param.wat
new file mode 100644
index 000000000000..b17ef0572bfd
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_floor/f64_floor_param.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (result f64)
+        (local.get 0)
+        (f64.floor)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    d0, [x28]
+;;       ldur    d0, [x28]
+;;       frintm  d0, d0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_ge/const.wat b/tests/disas/winch/aarch64/f64_ge/const.wat
new file mode 100644
index 000000000000..1ac82b3f995f
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_ge/const.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (f64.const -1)
+        (f64.const -2)
+        (f64.ge)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #-0x4000000000000000
+;;       fmov    d0, x16
+;;       mov     x16, #-0x4010000000000000
+;;       fmov    d1, x16
+;;       fcmp    d0, d1
+;;       cset    x0, ge
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_ge/locals.wat b/tests/disas/winch/aarch64/f64_ge/locals.wat
new file mode 100644
index 000000000000..1f03d6958c43
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_ge/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo f64)
+        (local $bar f64)
+
+        (f64.const -2)
+        (local.set $foo)
+        (f64.const -3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (f64.ge)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #-0x4000000000000000
+;;       fmov    d0, x16
+;;       stur    d0, [x28, #8]
+;;       mov     x16, #-0x3ff8000000000000
+;;       fmov    d0, x16
+;;       stur    d0, [x28]
+;;       ldur    d0, [x28]
+;;       ldur    d1, [x28, #8]
+;;       fcmp    d0, d1
+;;       cset    x0, ge
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_ge/params.wat b/tests/disas/winch/aarch64/f64_ge/params.wat
new file mode 100644
index 000000000000..cc013f8f77b5
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_ge/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (param f64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (f64.ge)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    d0, [x28, #8]
+;;       stur    d1, [x28]
+;;       ldur    d0, [x28]
+;;       ldur    d1, [x28, #8]
+;;       fcmp    d0, d1
+;;       cset    x0, ge
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_gt/const.wat b/tests/disas/winch/aarch64/f64_gt/const.wat
new file mode 100644
index 000000000000..d369f6a26a9d
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_gt/const.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (f64.const -1)
+        (f64.const -2)
+        (f64.gt)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #-0x4000000000000000
+;;       fmov    d0, x16
+;;       mov     x16, #-0x4010000000000000
+;;       fmov    d1, x16
+;;       fcmp    d0, d1
+;;       cset    x0, gt
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_gt/locals.wat b/tests/disas/winch/aarch64/f64_gt/locals.wat
new file mode 100644
index 000000000000..03b9ba36b02a
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_gt/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo f64)
+        (local $bar f64)
+
+        (f64.const -2)
+        (local.set $foo)
+        (f64.const -3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (f64.gt)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #-0x4000000000000000
+;;       fmov    d0, x16
+;;       stur    d0, [x28, #8]
+;;       mov     x16, #-0x3ff8000000000000
+;;       fmov    d0, x16
+;;       stur    d0, [x28]
+;;       ldur    d0, [x28]
+;;       ldur    d1, [x28, #8]
+;;       fcmp    d0, d1
+;;       cset    x0, gt
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_gt/params.wat b/tests/disas/winch/aarch64/f64_gt/params.wat
new file mode 100644
index 000000000000..5d5936cf074a
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_gt/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (param f64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (f64.gt)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    d0, [x28, #8]
+;;       stur    d1, [x28]
+;;       ldur    d0, [x28]
+;;       ldur    d1, [x28, #8]
+;;       fcmp    d0, d1
+;;       cset    x0, gt
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_le/const.wat b/tests/disas/winch/aarch64/f64_le/const.wat
new file mode 100644
index 000000000000..afc952995053
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_le/const.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (f64.const -1)
+        (f64.const -2)
+        (f64.le)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #-0x4000000000000000
+;;       fmov    d0, x16
+;;       mov     x16, #-0x4010000000000000
+;;       fmov    d1, x16
+;;       fcmp    d0, d1
+;;       cset    x0, ls
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_le/locals.wat b/tests/disas/winch/aarch64/f64_le/locals.wat
new file mode 100644
index 000000000000..92d5cfc1e0b6
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_le/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo f64)
+        (local $bar f64)
+
+        (f64.const -2)
+        (local.set $foo)
+        (f64.const -3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (f64.le)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #-0x4000000000000000
+;;       fmov    d0, x16
+;;       stur    d0, [x28, #8]
+;;       mov     x16, #-0x3ff8000000000000
+;;       fmov    d0, x16
+;;       stur    d0, [x28]
+;;       ldur    d0, [x28]
+;;       ldur    d1, [x28, #8]
+;;       fcmp    d0, d1
+;;       cset    x0, ls
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_le/params.wat b/tests/disas/winch/aarch64/f64_le/params.wat
new file mode 100644
index 000000000000..12a28272fce9
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_le/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (param f64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (f64.le)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    d0, [x28, #8]
+;;       stur    d1, [x28]
+;;       ldur    d0, [x28]
+;;       ldur    d1, [x28, #8]
+;;       fcmp    d0, d1
+;;       cset    x0, ls
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_lt/const.wat b/tests/disas/winch/aarch64/f64_lt/const.wat
new file mode 100644
index 000000000000..fcf83788dea3
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_lt/const.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (f64.const -1)
+        (f64.const -2)
+        (f64.lt)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #-0x4000000000000000
+;;       fmov    d0, x16
+;;       mov     x16, #-0x4010000000000000
+;;       fmov    d1, x16
+;;       fcmp    d0, d1
+;;       cset    x0, mi
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_lt/locals.wat b/tests/disas/winch/aarch64/f64_lt/locals.wat
new file mode 100644
index 000000000000..706d3bbc6ba7
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_lt/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo f64)
+        (local $bar f64)
+
+        (f64.const -2)
+        (local.set $foo)
+        (f64.const -3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (f64.lt)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #-0x4000000000000000
+;;       fmov    d0, x16
+;;       stur    d0, [x28, #8]
+;;       mov     x16, #-0x3ff8000000000000
+;;       fmov    d0, x16
+;;       stur    d0, [x28]
+;;       ldur    d0, [x28]
+;;       ldur    d1, [x28, #8]
+;;       fcmp    d0, d1
+;;       cset    x0, mi
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_lt/params.wat b/tests/disas/winch/aarch64/f64_lt/params.wat
new file mode 100644
index 000000000000..5866d149fce3
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_lt/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (param f64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (f64.lt)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    d0, [x28, #8]
+;;       stur    d1, [x28]
+;;       ldur    d0, [x28]
+;;       ldur    d1, [x28, #8]
+;;       fcmp    d0, d1
+;;       cset    x0, mi
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_max/const.wat b/tests/disas/winch/aarch64/f64_max/const.wat
new file mode 100644
index 000000000000..39b51913e12d
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_max/const.wat
@@ -0,0 +1,35 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (f64.const 1.1)
+        (f64.const 2.2)
+        (f64.max)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0x999a
+;;       movk    x16, #0x9999, lsl #16
+;;       movk    x16, #0x9999, lsl #32
+;;       movk    x16, #0x4001, lsl #48
+;;       fmov    d0, x16
+;;       mov     x16, #0x999a
+;;       movk    x16, #0x9999, lsl #16
+;;       movk    x16, #0x9999, lsl #32
+;;       movk    x16, #0x3ff1, lsl #48
+;;       fmov    d1, x16
+;;       fmax    d1, d1, d0
+;;       fmov    d0, d1
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_max/locals.wat b/tests/disas/winch/aarch64/f64_max/locals.wat
new file mode 100644
index 000000000000..4c74c88bbfdf
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_max/locals.wat
@@ -0,0 +1,51 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (local $foo f64)  
+        (local $bar f64)
+
+        (f64.const 1.1)
+        (local.set $foo)
+
+        (f64.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f64.max
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #0x999a
+;;       movk    x16, #0x9999, lsl #16
+;;       movk    x16, #0x9999, lsl #32
+;;       movk    x16, #0x3ff1, lsl #48
+;;       fmov    d0, x16
+;;       stur    d0, [x28, #8]
+;;       mov     x16, #0x999a
+;;       movk    x16, #0x9999, lsl #16
+;;       movk    x16, #0x9999, lsl #32
+;;       movk    x16, #0x4001, lsl #48
+;;       fmov    d0, x16
+;;       stur    d0, [x28]
+;;       ldur    d0, [x28]
+;;       ldur    d1, [x28, #8]
+;;       fmax    d1, d1, d0
+;;       fmov    d0, d1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_max/params.wat b/tests/disas/winch/aarch64/f64_max/params.wat
new file mode 100644
index 000000000000..af51424b4754
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_max/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (param f64) (result f64)
+        (local.get 0)
+        (local.get 1)
+        (f64.max)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    d0, [x28, #8]
+;;       stur    d1, [x28]
+;;       ldur    d0, [x28]
+;;       ldur    d1, [x28, #8]
+;;       fmax    d1, d1, d0
+;;       fmov    d0, d1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_min/const.wat b/tests/disas/winch/aarch64/f64_min/const.wat
new file mode 100644
index 000000000000..4f95658fcabe
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_min/const.wat
@@ -0,0 +1,35 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (f64.const 1.1)
+        (f64.const 2.2)
+        (f64.min)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0x999a
+;;       movk    x16, #0x9999, lsl #16
+;;       movk    x16, #0x9999, lsl #32
+;;       movk    x16, #0x4001, lsl #48
+;;       fmov    d0, x16
+;;       mov     x16, #0x999a
+;;       movk    x16, #0x9999, lsl #16
+;;       movk    x16, #0x9999, lsl #32
+;;       movk    x16, #0x3ff1, lsl #48
+;;       fmov    d1, x16
+;;       fmin    d1, d1, d0
+;;       fmov    d0, d1
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_min/locals.wat b/tests/disas/winch/aarch64/f64_min/locals.wat
new file mode 100644
index 000000000000..125d2fde894c
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_min/locals.wat
@@ -0,0 +1,51 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (local $foo f64)  
+        (local $bar f64)
+
+        (f64.const 1.1)
+        (local.set $foo)
+
+        (f64.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f64.min
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #0x999a
+;;       movk    x16, #0x9999, lsl #16
+;;       movk    x16, #0x9999, lsl #32
+;;       movk    x16, #0x3ff1, lsl #48
+;;       fmov    d0, x16
+;;       stur    d0, [x28, #8]
+;;       mov     x16, #0x999a
+;;       movk    x16, #0x9999, lsl #16
+;;       movk    x16, #0x9999, lsl #32
+;;       movk    x16, #0x4001, lsl #48
+;;       fmov    d0, x16
+;;       stur    d0, [x28]
+;;       ldur    d0, [x28]
+;;       ldur    d1, [x28, #8]
+;;       fmin    d1, d1, d0
+;;       fmov    d0, d1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_min/params.wat b/tests/disas/winch/aarch64/f64_min/params.wat
new file mode 100644
index 000000000000..a827496445ad
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_min/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (param f64) (result f64)
+        (local.get 0)
+        (local.get 1)
+        (f64.min)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    d0, [x28, #8]
+;;       stur    d1, [x28]
+;;       ldur    d0, [x28]
+;;       ldur    d1, [x28, #8]
+;;       fmin    d1, d1, d0
+;;       fmov    d0, d1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_mul/const.wat b/tests/disas/winch/aarch64/f64_mul/const.wat
new file mode 100644
index 000000000000..299d8a76dcca
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_mul/const.wat
@@ -0,0 +1,35 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (f64.const 1.1)
+        (f64.const 2.2)
+        (f64.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0x999a
+;;       movk    x16, #0x9999, lsl #16
+;;       movk    x16, #0x9999, lsl #32
+;;       movk    x16, #0x4001, lsl #48
+;;       fmov    d0, x16
+;;       mov     x16, #0x999a
+;;       movk    x16, #0x9999, lsl #16
+;;       movk    x16, #0x9999, lsl #32
+;;       movk    x16, #0x3ff1, lsl #48
+;;       fmov    d1, x16
+;;       fmul    d1, d1, d0
+;;       fmov    d0, d1
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_mul/locals.wat b/tests/disas/winch/aarch64/f64_mul/locals.wat
new file mode 100644
index 000000000000..e5f07b489032
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_mul/locals.wat
@@ -0,0 +1,51 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (local $foo f64)  
+        (local $bar f64)
+
+        (f64.const 1.1)
+        (local.set $foo)
+
+        (f64.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f64.mul
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #0x999a
+;;       movk    x16, #0x9999, lsl #16
+;;       movk    x16, #0x9999, lsl #32
+;;       movk    x16, #0x3ff1, lsl #48
+;;       fmov    d0, x16
+;;       stur    d0, [x28, #8]
+;;       mov     x16, #0x999a
+;;       movk    x16, #0x9999, lsl #16
+;;       movk    x16, #0x9999, lsl #32
+;;       movk    x16, #0x4001, lsl #48
+;;       fmov    d0, x16
+;;       stur    d0, [x28]
+;;       ldur    d0, [x28]
+;;       ldur    d1, [x28, #8]
+;;       fmul    d1, d1, d0
+;;       fmov    d0, d1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_mul/params.wat b/tests/disas/winch/aarch64/f64_mul/params.wat
new file mode 100644
index 000000000000..0c6ddc1ac56a
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_mul/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (param f64) (result f64)
+        (local.get 0)
+        (local.get 1)
+        (f64.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    d0, [x28, #8]
+;;       stur    d1, [x28]
+;;       ldur    d0, [x28]
+;;       ldur    d1, [x28, #8]
+;;       fmul    d1, d1, d0
+;;       fmov    d0, d1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_ne/const.wat b/tests/disas/winch/aarch64/f64_ne/const.wat
new file mode 100644
index 000000000000..e8ec2a9116f8
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_ne/const.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (f64.const 1)
+        (f64.const 2)
+        (f64.ne)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0x4000000000000000
+;;       fmov    d0, x16
+;;       mov     x16, #0x3ff0000000000000
+;;       fmov    d1, x16
+;;       fcmp    d0, d1
+;;       cset    x0, ne
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_ne/locals.wat b/tests/disas/winch/aarch64/f64_ne/locals.wat
new file mode 100644
index 000000000000..3dad452c30f4
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_ne/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo f64)
+        (local $bar f64)
+
+        (f64.const 2)
+        (local.set $foo)
+        (f64.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (f64.ne)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #0x4000000000000000
+;;       fmov    d0, x16
+;;       stur    d0, [x28, #8]
+;;       mov     x16, #0x4008000000000000
+;;       fmov    d0, x16
+;;       stur    d0, [x28]
+;;       ldur    d0, [x28]
+;;       ldur    d1, [x28, #8]
+;;       fcmp    d0, d1
+;;       cset    x0, ne
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_ne/params.wat b/tests/disas/winch/aarch64/f64_ne/params.wat
new file mode 100644
index 000000000000..93965d9013e4
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_ne/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (param f64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (f64.ne)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    d0, [x28, #8]
+;;       stur    d1, [x28]
+;;       ldur    d0, [x28]
+;;       ldur    d1, [x28, #8]
+;;       fcmp    d0, d1
+;;       cset    x0, ne
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_nearest/f64_nearest_const.wat b/tests/disas/winch/aarch64/f64_nearest/f64_nearest_const.wat
new file mode 100644
index 000000000000..c30cb810ba76
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_nearest/f64_nearest_const.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (f64.const -1.32)
+        (f64.nearest)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0x851f
+;;       movk    x16, #0x51eb, lsl #16
+;;       movk    x16, #0x1eb8, lsl #32
+;;       movk    x16, #0xbff5, lsl #48
+;;       fmov    d0, x16
+;;       frintn  d0, d0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_nearest/f64_nearest_param.wat b/tests/disas/winch/aarch64/f64_nearest/f64_nearest_param.wat
new file mode 100644
index 000000000000..9ba4184d4157
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_nearest/f64_nearest_param.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (result f64)
+        (local.get 0)
+        (f64.nearest)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    d0, [x28]
+;;       ldur    d0, [x28]
+;;       frintn  d0, d0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_neg/f64_neg_const.wat b/tests/disas/winch/aarch64/f64_neg/f64_neg_const.wat
new file mode 100644
index 000000000000..11307202dff2
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_neg/f64_neg_const.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (f64.const -1.32)
+        (f64.neg)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0x851f
+;;       movk    x16, #0x51eb, lsl #16
+;;       movk    x16, #0x1eb8, lsl #32
+;;       movk    x16, #0xbff5, lsl #48
+;;       fmov    d0, x16
+;;       fneg    d0, d0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_neg/f64_neg_param.wat b/tests/disas/winch/aarch64/f64_neg/f64_neg_param.wat
new file mode 100644
index 000000000000..64098dfaacc2
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_neg/f64_neg_param.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (result f64)
+        (local.get 0)
+        (f64.neg)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    d0, [x28]
+;;       ldur    d0, [x28]
+;;       fneg    d0, d0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_promote_f32/const.wat b/tests/disas/winch/aarch64/f64_promote_f32/const.wat
new file mode 100644
index 000000000000..7dedd414a7d9
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_promote_f32/const.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (f32.const 1.0)
+        (f64.promote_f32)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0x3f800000
+;;       fmov    s0, w16
+;;       fcvt    d0, s0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_promote_f32/locals.wat b/tests/disas/winch/aarch64/f64_promote_f32/locals.wat
new file mode 100644
index 000000000000..e4c97cc74b41
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_promote_f32/locals.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (local f32)  
+
+        (local.get 0)
+        (f64.promote_f32)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       ldur    s0, [x28, #4]
+;;       fcvt    d0, s0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_promote_f32/params.wat b/tests/disas/winch/aarch64/f64_promote_f32/params.wat
new file mode 100644
index 000000000000..e1b99a198eba
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_promote_f32/params.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (result f64)
+        (local.get 0)
+        (f64.promote_f32)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    s0, [x28, #4]
+;;       ldur    s0, [x28, #4]
+;;       fcvt    d0, s0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_sqrt/f64_sqrt_const.wat b/tests/disas/winch/aarch64/f64_sqrt/f64_sqrt_const.wat
new file mode 100644
index 000000000000..dc69fbad232e
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_sqrt/f64_sqrt_const.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (f64.const 1.32)
+        (f64.sqrt)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0x851f
+;;       movk    x16, #0x51eb, lsl #16
+;;       movk    x16, #0x1eb8, lsl #32
+;;       movk    x16, #0x3ff5, lsl #48
+;;       fmov    d0, x16
+;;       fsqrt   d0, d0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_sqrt/f64_sqrt_param.wat b/tests/disas/winch/aarch64/f64_sqrt/f64_sqrt_param.wat
new file mode 100644
index 000000000000..a9edc57ce4dd
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_sqrt/f64_sqrt_param.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (result f64)
+        (local.get 0)
+        (f64.sqrt)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    d0, [x28]
+;;       ldur    d0, [x28]
+;;       fsqrt   d0, d0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_sub/const.wat b/tests/disas/winch/aarch64/f64_sub/const.wat
new file mode 100644
index 000000000000..0f59f1168afc
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_sub/const.wat
@@ -0,0 +1,35 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (f64.const 1.1)
+        (f64.const 2.2)
+        (f64.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0x999a
+;;       movk    x16, #0x9999, lsl #16
+;;       movk    x16, #0x9999, lsl #32
+;;       movk    x16, #0x4001, lsl #48
+;;       fmov    d0, x16
+;;       mov     x16, #0x999a
+;;       movk    x16, #0x9999, lsl #16
+;;       movk    x16, #0x9999, lsl #32
+;;       movk    x16, #0x3ff1, lsl #48
+;;       fmov    d1, x16
+;;       fsub    d1, d1, d0
+;;       fmov    d0, d1
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_sub/locals.wat b/tests/disas/winch/aarch64/f64_sub/locals.wat
new file mode 100644
index 000000000000..f6eb2c9e945a
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_sub/locals.wat
@@ -0,0 +1,51 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (local $foo f64)  
+        (local $bar f64)
+
+        (f64.const 1.1)
+        (local.set $foo)
+
+        (f64.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f64.sub
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #0x999a
+;;       movk    x16, #0x9999, lsl #16
+;;       movk    x16, #0x9999, lsl #32
+;;       movk    x16, #0x3ff1, lsl #48
+;;       fmov    d0, x16
+;;       stur    d0, [x28, #8]
+;;       mov     x16, #0x999a
+;;       movk    x16, #0x9999, lsl #16
+;;       movk    x16, #0x9999, lsl #32
+;;       movk    x16, #0x4001, lsl #48
+;;       fmov    d0, x16
+;;       stur    d0, [x28]
+;;       ldur    d0, [x28]
+;;       ldur    d1, [x28, #8]
+;;       fsub    d1, d1, d0
+;;       fmov    d0, d1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_sub/params.wat b/tests/disas/winch/aarch64/f64_sub/params.wat
new file mode 100644
index 000000000000..200711aa3881
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_sub/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (param f64) (result f64)
+        (local.get 0)
+        (local.get 1)
+        (f64.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    d0, [x28, #8]
+;;       stur    d1, [x28]
+;;       ldur    d0, [x28]
+;;       ldur    d1, [x28, #8]
+;;       fsub    d1, d1, d0
+;;       fmov    d0, d1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_trunc/f64_trunc_const.wat b/tests/disas/winch/aarch64/f64_trunc/f64_trunc_const.wat
new file mode 100644
index 000000000000..134eea48d7f1
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_trunc/f64_trunc_const.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (f64.const -1.32)
+        (f64.trunc)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0x851f
+;;       movk    x16, #0x51eb, lsl #16
+;;       movk    x16, #0x1eb8, lsl #32
+;;       movk    x16, #0xbff5, lsl #48
+;;       fmov    d0, x16
+;;       frintz  d0, d0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/f64_trunc/f64_trunc_param.wat b/tests/disas/winch/aarch64/f64_trunc/f64_trunc_param.wat
new file mode 100644
index 000000000000..726f4e040694
--- /dev/null
+++ b/tests/disas/winch/aarch64/f64_trunc/f64_trunc_param.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (result f64)
+        (local.get 0)
+        (f64.trunc)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    d0, [x28]
+;;       ldur    d0, [x28]
+;;       frintz  d0, d0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_add/const.wat b/tests/disas/winch/aarch64/i32_add/const.wat
new file mode 100644
index 000000000000..2f93ea588c87
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_add/const.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const 10)
+	(i32.const 20)
+	(i32.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0xa
+;;       mov     w0, w16
+;;       add     w0, w0, #0x14
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_add/locals.wat b/tests/disas/winch/aarch64/i32_add/locals.wat
new file mode 100644
index 000000000000..6c7ae395175e
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_add/locals.wat
@@ -0,0 +1,44 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)  
+        (local $bar i32)
+
+        (i32.const 10)
+        (local.set $foo)
+
+        (i32.const 20)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        i32.add
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     x16, #0xa
+;;       mov     w0, w16
+;;       stur    w0, [x28, #4]
+;;       mov     x16, #0x14
+;;       mov     w0, w16
+;;       stur    w0, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       add     w1, w1, w0, uxtx
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_add/max.wat b/tests/disas/winch/aarch64/i32_add/max.wat
new file mode 100644
index 000000000000..85861590bbf9
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_add/max.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+(module
+    (func (result i32)
+	(i32.const 0x7fffffff)
+	(i32.const 1)
+	(i32.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       orr     x16, xzr, #0x7fffffff
+;;       mov     w0, w16
+;;       add     w0, w0, #1
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_add/max_one.wat b/tests/disas/winch/aarch64/i32_add/max_one.wat
new file mode 100644
index 000000000000..0ce06296181f
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_add/max_one.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const 0x80000000)
+	(i32.const -1)
+	(i32.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0x80000000
+;;       mov     w0, w16
+;;       orr     x16, xzr, #0xffffffff
+;;       add     w0, w0, w16, uxtx
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_add/mixed.wat b/tests/disas/winch/aarch64/i32_add/mixed.wat
new file mode 100644
index 000000000000..f97b740d1efe
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_add/mixed.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const -1)
+	(i32.const 1)
+	(i32.add)
+     )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       orr     x16, xzr, #0xffffffff
+;;       mov     w0, w16
+;;       add     w0, w0, #1
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_add/params.wat b/tests/disas/winch/aarch64/i32_add/params.wat
new file mode 100644
index 000000000000..9ccb2bbfbe72
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_add/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+	(local.get 0)
+	(local.get 1)
+	(i32.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       stur    w3, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       add     w1, w1, w0, uxtx
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_add/signed.wat b/tests/disas/winch/aarch64/i32_add/signed.wat
new file mode 100644
index 000000000000..8992b493dee8
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_add/signed.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const -1)
+	(i32.const -1)
+	(i32.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       orr     x16, xzr, #0xffffffff
+;;       mov     w0, w16
+;;       orr     x16, xzr, #0xffffffff
+;;       add     w0, w0, w16, uxtx
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_add/unsigned_with_zero.wat b/tests/disas/winch/aarch64/i32_add/unsigned_with_zero.wat
new file mode 100644
index 000000000000..772490e980cf
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_add/unsigned_with_zero.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+     	(i32.const 0)
+    	(i32.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       add     w0, w0, #0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_and/const.wat b/tests/disas/winch/aarch64/i32_and/const.wat
new file mode 100644
index 000000000000..51697a27061f
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_and/const.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 2)
+        (i32.and)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       and     w0, w0, #2
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_and/locals.wat b/tests/disas/winch/aarch64/i32_and/locals.wat
new file mode 100644
index 000000000000..907ad21d1bea
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_and/locals.wat
@@ -0,0 +1,44 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)  
+        (local $bar i32)
+
+        (i32.const 1)
+        (local.set $foo)
+
+        (i32.const 2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.and)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       stur    w0, [x28, #4]
+;;       mov     x16, #2
+;;       mov     w0, w16
+;;       stur    w0, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       and     w1, w1, w0
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_and/params.wat b/tests/disas/winch/aarch64/i32_and/params.wat
new file mode 100644
index 000000000000..f794d45bf75b
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_and/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.and)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       stur    w3, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       and     w1, w1, w0
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_clz/const.wat b/tests/disas/winch/aarch64/i32_clz/const.wat
new file mode 100644
index 000000000000..6cff99bdd99d
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_clz/const.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const 10)
+	(i32.clz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0xa
+;;       mov     w0, w16
+;;       clz     w0, w0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_clz/locals.wat b/tests/disas/winch/aarch64/i32_clz/locals.wat
new file mode 100644
index 000000000000..f8dbc4ae1dfd
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_clz/locals.wat
@@ -0,0 +1,32 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)
+
+        (i32.const 10)
+        (local.tee $foo)
+
+        i32.clz
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     x16, #0xa
+;;       mov     w0, w16
+;;       stur    w0, [x28, #4]
+;;       clz     w0, w0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_clz/params.wat b/tests/disas/winch/aarch64/i32_clz/params.wat
new file mode 100644
index 000000000000..af52405bd0a4
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_clz/params.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (result i32)
+	(local.get 0)
+	(i32.clz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       ldur    w0, [x28, #4]
+;;       clz     w0, w0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_ctz/const.wat b/tests/disas/winch/aarch64/i32_ctz/const.wat
new file mode 100644
index 000000000000..c0102d1f41db
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_ctz/const.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const 10)
+	(i32.ctz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0xa
+;;       mov     w0, w16
+;;       rbit    w16, w0
+;;       clz     w0, w16
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_ctz/locals.wat b/tests/disas/winch/aarch64/i32_ctz/locals.wat
new file mode 100644
index 000000000000..80775868c12f
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_ctz/locals.wat
@@ -0,0 +1,31 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)  
+        (i32.const 10)
+        (local.tee $foo)
+        i32.ctz
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     x16, #0xa
+;;       mov     w0, w16
+;;       stur    w0, [x28, #4]
+;;       rbit    w16, w0
+;;       clz     w0, w16
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_ctz/params.wat b/tests/disas/winch/aarch64/i32_ctz/params.wat
new file mode 100644
index 000000000000..08a81a76e599
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_ctz/params.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (result i32)
+    	(local.get 0)
+    	(i32.ctz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       ldur    w0, [x28, #4]
+;;       rbit    w16, w0
+;;       clz     w0, w16
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_eq/const.wat b/tests/disas/winch/aarch64/i32_eq/const.wat
new file mode 100644
index 000000000000..89ae08765daa
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_eq/const.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 1)
+        (i32.eq)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       cmp     w0, #1
+;;       cset    x0, eq
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_eq/locals.wat b/tests/disas/winch/aarch64/i32_eq/locals.wat
new file mode 100644
index 000000000000..aa3224116c36
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_eq/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)
+        (local $bar i32)
+
+        (i32.const 2)
+        (local.set $foo)
+        (i32.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.eq)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     x16, #2
+;;       mov     w0, w16
+;;       stur    w0, [x28, #4]
+;;       mov     x16, #3
+;;       mov     w0, w16
+;;       stur    w0, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       cmp     w1, w0, uxtx
+;;       cset    x1, eq
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_eq/params.wat b/tests/disas/winch/aarch64/i32_eq/params.wat
new file mode 100644
index 000000000000..94f41011418b
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_eq/params.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.eq)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       stur    w3, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       cmp     w1, w0, uxtx
+;;       cset    x1, eq
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_extend_16_s/const.wat b/tests/disas/winch/aarch64/i32_extend_16_s/const.wat
new file mode 100644
index 000000000000..0ca89a2a5cc7
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_extend_16_s/const.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.extend16_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       sxth    w0, w0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_extend_16_s/locals.wat b/tests/disas/winch/aarch64/i32_extend_16_s/locals.wat
new file mode 100644
index 000000000000..35a1edad1108
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_extend_16_s/locals.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local i32)
+
+        (local.get 0)
+        (i32.extend16_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       ldur    w0, [x28, #4]
+;;       sxth    w0, w0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_extend_16_s/params.wat b/tests/disas/winch/aarch64/i32_extend_16_s/params.wat
new file mode 100644
index 000000000000..5cea51c0af4b
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_extend_16_s/params.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (result i32)
+        (local.get 0)
+        (i32.extend16_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       ldur    w0, [x28, #4]
+;;       sxth    w0, w0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_extend_8_s/const.wat b/tests/disas/winch/aarch64/i32_extend_8_s/const.wat
new file mode 100644
index 000000000000..d0648cac5476
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_extend_8_s/const.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.extend8_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       sxtb    w0, w0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_extend_8_s/locals.wat b/tests/disas/winch/aarch64/i32_extend_8_s/locals.wat
new file mode 100644
index 000000000000..628a93401239
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_extend_8_s/locals.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local i32)
+
+        (local.get 0)
+        (i32.extend8_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       ldur    w0, [x28, #4]
+;;       sxtb    w0, w0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_extend_8_s/params.wat b/tests/disas/winch/aarch64/i32_extend_8_s/params.wat
new file mode 100644
index 000000000000..d5557babdffe
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_extend_8_s/params.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (result i32)
+        (local.get 0)
+        (i32.extend8_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       ldur    w0, [x28, #4]
+;;       sxtb    w0, w0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_ge_s/const.wat b/tests/disas/winch/aarch64/i32_ge_s/const.wat
new file mode 100644
index 000000000000..e3d81a8c334c
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_ge_s/const.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const -1)
+        (i32.const -2)
+        (i32.ge_s)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       orr     x16, xzr, #0xffffffff
+;;       mov     w0, w16
+;;       orr     x16, xzr, #0xfffffffe
+;;       cmp     w0, w16, uxtx
+;;       cset    x0, ge
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_ge_s/locals.wat b/tests/disas/winch/aarch64/i32_ge_s/locals.wat
new file mode 100644
index 000000000000..dae13023a03d
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_ge_s/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)
+        (local $bar i32)
+
+        (i32.const -2)
+        (local.set $foo)
+        (i32.const -3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.ge_s)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       orr     x16, xzr, #0xfffffffe
+;;       mov     w0, w16
+;;       stur    w0, [x28, #4]
+;;       mov     w16, #-3
+;;       mov     w0, w16
+;;       stur    w0, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       cmp     w1, w0, uxtx
+;;       cset    x1, ge
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_ge_s/params.wat b/tests/disas/winch/aarch64/i32_ge_s/params.wat
new file mode 100644
index 000000000000..4b2498342a0b
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_ge_s/params.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.ge_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       stur    w3, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       cmp     w1, w0, uxtx
+;;       cset    x1, ge
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_ge_u/const.wat b/tests/disas/winch/aarch64/i32_ge_u/const.wat
new file mode 100644
index 000000000000..16078d4de4ec
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_ge_u/const.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 2)
+        (i32.ge_u)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       cmp     w0, #2
+;;       cset    x0, hs
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_ge_u/locals.wat b/tests/disas/winch/aarch64/i32_ge_u/locals.wat
new file mode 100644
index 000000000000..6c27dfc17d7c
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_ge_u/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)
+        (local $bar i32)
+
+        (i32.const 2)
+        (local.set $foo)
+        (i32.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.ge_u)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     x16, #2
+;;       mov     w0, w16
+;;       stur    w0, [x28, #4]
+;;       mov     x16, #3
+;;       mov     w0, w16
+;;       stur    w0, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       cmp     w1, w0, uxtx
+;;       cset    x1, hs
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_ge_u/params.wat b/tests/disas/winch/aarch64/i32_ge_u/params.wat
new file mode 100644
index 000000000000..63b597d3537d
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_ge_u/params.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.ge_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       stur    w3, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       cmp     w1, w0, uxtx
+;;       cset    x1, hs
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_gt_s/const.wat b/tests/disas/winch/aarch64/i32_gt_s/const.wat
new file mode 100644
index 000000000000..0fb17efd0e81
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_gt_s/const.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const -1)
+        (i32.const -2)
+        (i32.gt_s)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       orr     x16, xzr, #0xffffffff
+;;       mov     w0, w16
+;;       orr     x16, xzr, #0xfffffffe
+;;       cmp     w0, w16, uxtx
+;;       cset    x0, gt
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_gt_s/locals.wat b/tests/disas/winch/aarch64/i32_gt_s/locals.wat
new file mode 100644
index 000000000000..922cf427f86d
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_gt_s/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)
+        (local $bar i32)
+
+        (i32.const -2)
+        (local.set $foo)
+        (i32.const -3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.gt_s)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       orr     x16, xzr, #0xfffffffe
+;;       mov     w0, w16
+;;       stur    w0, [x28, #4]
+;;       mov     w16, #-3
+;;       mov     w0, w16
+;;       stur    w0, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       cmp     w1, w0, uxtx
+;;       cset    x1, gt
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_gt_s/params.wat b/tests/disas/winch/aarch64/i32_gt_s/params.wat
new file mode 100644
index 000000000000..0b24729c600d
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_gt_s/params.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.gt_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       stur    w3, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       cmp     w1, w0, uxtx
+;;       cset    x1, gt
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_gt_u/const.wat b/tests/disas/winch/aarch64/i32_gt_u/const.wat
new file mode 100644
index 000000000000..c00e2057671c
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_gt_u/const.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 2)
+        (i32.gt_u)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       cmp     w0, #2
+;;       cset    x0, hi
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_gt_u/locals.wat b/tests/disas/winch/aarch64/i32_gt_u/locals.wat
new file mode 100644
index 000000000000..dfc704ea8e91
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_gt_u/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)
+        (local $bar i32)
+
+        (i32.const 2)
+        (local.set $foo)
+        (i32.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.gt_u)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     x16, #2
+;;       mov     w0, w16
+;;       stur    w0, [x28, #4]
+;;       mov     x16, #3
+;;       mov     w0, w16
+;;       stur    w0, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       cmp     w1, w0, uxtx
+;;       cset    x1, hi
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_gt_u/params.wat b/tests/disas/winch/aarch64/i32_gt_u/params.wat
new file mode 100644
index 000000000000..d1ea89c98646
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_gt_u/params.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.gt_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       stur    w3, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       cmp     w1, w0, uxtx
+;;       cset    x1, hi
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_le_s/const.wat b/tests/disas/winch/aarch64/i32_le_s/const.wat
new file mode 100644
index 000000000000..98f898a7b4aa
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_le_s/const.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const -1)
+        (i32.const -2)
+        (i32.le_s)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       orr     x16, xzr, #0xffffffff
+;;       mov     w0, w16
+;;       orr     x16, xzr, #0xfffffffe
+;;       cmp     w0, w16, uxtx
+;;       cset    x0, le
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_le_s/locals.wat b/tests/disas/winch/aarch64/i32_le_s/locals.wat
new file mode 100644
index 000000000000..3d92f525849d
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_le_s/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)
+        (local $bar i32)
+
+        (i32.const -2)
+        (local.set $foo)
+        (i32.const -3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.le_s)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       orr     x16, xzr, #0xfffffffe
+;;       mov     w0, w16
+;;       stur    w0, [x28, #4]
+;;       mov     w16, #-3
+;;       mov     w0, w16
+;;       stur    w0, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       cmp     w1, w0, uxtx
+;;       cset    x1, le
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_le_s/params.wat b/tests/disas/winch/aarch64/i32_le_s/params.wat
new file mode 100644
index 000000000000..6e21423911ad
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_le_s/params.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.le_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       stur    w3, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       cmp     w1, w0, uxtx
+;;       cset    x1, le
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_le_u/const.wat b/tests/disas/winch/aarch64/i32_le_u/const.wat
new file mode 100644
index 000000000000..ca03d021085c
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_le_u/const.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 2)
+        (i32.le_u)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       cmp     w0, #2
+;;       cset    x0, ls
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_le_u/locals.wat b/tests/disas/winch/aarch64/i32_le_u/locals.wat
new file mode 100644
index 000000000000..26db8ef1a6f8
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_le_u/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)
+        (local $bar i32)
+
+        (i32.const 2)
+        (local.set $foo)
+        (i32.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.le_u)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     x16, #2
+;;       mov     w0, w16
+;;       stur    w0, [x28, #4]
+;;       mov     x16, #3
+;;       mov     w0, w16
+;;       stur    w0, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       cmp     w1, w0, uxtx
+;;       cset    x1, ls
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_le_u/params.wat b/tests/disas/winch/aarch64/i32_le_u/params.wat
new file mode 100644
index 000000000000..7fe68e2d8f84
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_le_u/params.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.le_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       stur    w3, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       cmp     w1, w0, uxtx
+;;       cset    x1, ls
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_lt_s/const.wat b/tests/disas/winch/aarch64/i32_lt_s/const.wat
new file mode 100644
index 000000000000..c1d0592f6abe
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_lt_s/const.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const -1)
+        (i32.const -2)
+        (i32.lt_s)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       orr     x16, xzr, #0xffffffff
+;;       mov     w0, w16
+;;       orr     x16, xzr, #0xfffffffe
+;;       cmp     w0, w16, uxtx
+;;       cset    x0, lt
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_lt_s/locals.wat b/tests/disas/winch/aarch64/i32_lt_s/locals.wat
new file mode 100644
index 000000000000..fdbc515fad27
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_lt_s/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)
+        (local $bar i32)
+
+        (i32.const -2)
+        (local.set $foo)
+        (i32.const -3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.lt_s)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       orr     x16, xzr, #0xfffffffe
+;;       mov     w0, w16
+;;       stur    w0, [x28, #4]
+;;       mov     w16, #-3
+;;       mov     w0, w16
+;;       stur    w0, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       cmp     w1, w0, uxtx
+;;       cset    x1, lt
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_lt_s/params.wat b/tests/disas/winch/aarch64/i32_lt_s/params.wat
new file mode 100644
index 000000000000..87e02ee27cf6
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_lt_s/params.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.lt_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       stur    w3, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       cmp     w1, w0, uxtx
+;;       cset    x1, lt
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_lt_u/const.wat b/tests/disas/winch/aarch64/i32_lt_u/const.wat
new file mode 100644
index 000000000000..0f7101eb6aa1
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_lt_u/const.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 2)
+        (i32.lt_u)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       cmp     w0, #2
+;;       cset    x0, lo
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_lt_u/locals.wat b/tests/disas/winch/aarch64/i32_lt_u/locals.wat
new file mode 100644
index 000000000000..fbf9d9846264
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_lt_u/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)
+        (local $bar i32)
+
+        (i32.const 2)
+        (local.set $foo)
+        (i32.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.lt_u)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     x16, #2
+;;       mov     w0, w16
+;;       stur    w0, [x28, #4]
+;;       mov     x16, #3
+;;       mov     w0, w16
+;;       stur    w0, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       cmp     w1, w0, uxtx
+;;       cset    x1, lo
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_lt_u/params.wat b/tests/disas/winch/aarch64/i32_lt_u/params.wat
new file mode 100644
index 000000000000..9ed5e559ac32
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_lt_u/params.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.lt_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       stur    w3, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       cmp     w1, w0, uxtx
+;;       cset    x1, lo
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_mul/const.wat b/tests/disas/winch/aarch64/i32_mul/const.wat
new file mode 100644
index 000000000000..37cec7a415d1
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_mul/const.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const 10)
+	(i32.const 20)
+	(i32.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0xa
+;;       mov     w0, w16
+;;       mov     x16, #0x14
+;;       mul     w0, w0, w16
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_mul/locals.wat b/tests/disas/winch/aarch64/i32_mul/locals.wat
new file mode 100644
index 000000000000..aaeaea5d796b
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_mul/locals.wat
@@ -0,0 +1,44 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)  
+        (local $bar i32)
+
+        (i32.const 10)
+        (local.set $foo)
+
+        (i32.const 20)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        i32.mul
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     x16, #0xa
+;;       mov     w0, w16
+;;       stur    w0, [x28, #4]
+;;       mov     x16, #0x14
+;;       mov     w0, w16
+;;       stur    w0, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       mul     w1, w1, w0
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_mul/max.wat b/tests/disas/winch/aarch64/i32_mul/max.wat
new file mode 100644
index 000000000000..d480278a5a25
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_mul/max.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const 0x7fffffff)
+	(i32.const -1)
+	(i32.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       orr     x16, xzr, #0x7fffffff
+;;       mov     w0, w16
+;;       orr     x16, xzr, #0xffffffff
+;;       mul     w0, w0, w16
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_mul/max_one.wat b/tests/disas/winch/aarch64/i32_mul/max_one.wat
new file mode 100644
index 000000000000..ffd5529d82d0
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_mul/max_one.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const 0x80000000)
+	(i32.const -1)
+	(i32.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0x80000000
+;;       mov     w0, w16
+;;       orr     x16, xzr, #0xffffffff
+;;       mul     w0, w0, w16
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_mul/mixed.wat b/tests/disas/winch/aarch64/i32_mul/mixed.wat
new file mode 100644
index 000000000000..ed915f4f6a60
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_mul/mixed.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const -1)
+	(i32.const 1)
+	(i32.mul)
+     )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       orr     x16, xzr, #0xffffffff
+;;       mov     w0, w16
+;;       mov     x16, #1
+;;       mul     w0, w0, w16
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_mul/params.wat b/tests/disas/winch/aarch64/i32_mul/params.wat
new file mode 100644
index 000000000000..3fae69082c6e
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_mul/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+	(local.get 0)
+	(local.get 1)
+	(i32.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       stur    w3, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       mul     w1, w1, w0
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_mul/signed.wat b/tests/disas/winch/aarch64/i32_mul/signed.wat
new file mode 100644
index 000000000000..28398b1534e0
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_mul/signed.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const -1)
+	(i32.const -1)
+	(i32.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       orr     x16, xzr, #0xffffffff
+;;       mov     w0, w16
+;;       orr     x16, xzr, #0xffffffff
+;;       mul     w0, w0, w16
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_mul/unsigned_with_zero.wat b/tests/disas/winch/aarch64/i32_mul/unsigned_with_zero.wat
new file mode 100644
index 000000000000..7144814add31
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_mul/unsigned_with_zero.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+     	(i32.const 0)
+    	(i32.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       mov     x16, #0
+;;       mul     w0, w0, w16
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_ne/const.wat b/tests/disas/winch/aarch64/i32_ne/const.wat
new file mode 100644
index 000000000000..8a7d32d96bc2
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_ne/const.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 2)
+        (i32.ne)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       cmp     w0, #2
+;;       cset    x0, ne
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_ne/locals.wat b/tests/disas/winch/aarch64/i32_ne/locals.wat
new file mode 100644
index 000000000000..147a12e28ac2
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_ne/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)
+        (local $bar i32)
+
+        (i32.const 2)
+        (local.set $foo)
+        (i32.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.ne)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     x16, #2
+;;       mov     w0, w16
+;;       stur    w0, [x28, #4]
+;;       mov     x16, #3
+;;       mov     w0, w16
+;;       stur    w0, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       cmp     w1, w0, uxtx
+;;       cset    x1, ne
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_ne/params.wat b/tests/disas/winch/aarch64/i32_ne/params.wat
new file mode 100644
index 000000000000..e62f85594274
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_ne/params.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.ne)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       stur    w3, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       cmp     w1, w0, uxtx
+;;       cset    x1, ne
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_or/const.wat b/tests/disas/winch/aarch64/i32_or/const.wat
new file mode 100644
index 000000000000..710a188d15ab
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_or/const.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 2)
+        (i32.or)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       orr     w0, w0, #2
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_or/locals.wat b/tests/disas/winch/aarch64/i32_or/locals.wat
new file mode 100644
index 000000000000..a4493e038ff0
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_or/locals.wat
@@ -0,0 +1,44 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)  
+        (local $bar i32)
+
+        (i32.const 1)
+        (local.set $foo)
+
+        (i32.const 2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.or)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       stur    w0, [x28, #4]
+;;       mov     x16, #2
+;;       mov     w0, w16
+;;       stur    w0, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       orr     w1, w1, w0
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_or/params.wat b/tests/disas/winch/aarch64/i32_or/params.wat
new file mode 100644
index 000000000000..c61280c8e4b7
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_or/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.or)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       stur    w3, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       orr     w1, w1, w0
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_popcnt/const.wat b/tests/disas/winch/aarch64/i32_popcnt/const.wat
new file mode 100644
index 000000000000..c9ce796c3674
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_popcnt/const.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+      i32.const 3
+      i32.popcnt
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #3
+;;       mov     w0, w16
+;;       fmov    s31, w0
+;;       cnt     v31.8b, v31.8b
+;;       addv    b31, v31.8b
+;;       umov    w0, v31.b[0]
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_popcnt/reg.wat b/tests/disas/winch/aarch64/i32_popcnt/reg.wat
new file mode 100644
index 000000000000..ef040ec5e212
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_popcnt/reg.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (result i32)
+      local.get 0
+      i32.popcnt
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       ldur    w0, [x28, #4]
+;;       fmov    s31, w0
+;;       cnt     v31.8b, v31.8b
+;;       addv    b31, v31.8b
+;;       umov    w0, v31.b[0]
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_rotl/16_const.wat b/tests/disas/winch/aarch64/i32_rotl/16_const.wat
new file mode 100644
index 000000000000..b1cc4727cf9c
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_rotl/16_const.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 512)
+        (i32.rotl)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       sub     w0, w0, wzr
+;;       mov     x16, #0x200
+;;       ror     w0, w0, w16
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_rotl/8_const.wat b/tests/disas/winch/aarch64/i32_rotl/8_const.wat
new file mode 100644
index 000000000000..fb6048c26288
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_rotl/8_const.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 2)
+        (i32.rotl)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       sub     w0, w0, wzr
+;;       ror     w0, w0, #2
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_rotl/locals.wat b/tests/disas/winch/aarch64/i32_rotl/locals.wat
new file mode 100644
index 000000000000..a425fee868b0
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_rotl/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)  
+        (local $bar i32)
+
+        (i32.const 1)
+        (local.set $foo)
+
+        (i32.const 2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.rotl)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       stur    w0, [x28, #4]
+;;       mov     x16, #2
+;;       mov     w0, w16
+;;       stur    w0, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       sub     w0, w0, wzr
+;;       ror     w1, w1, w0
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_rotl/params.wat b/tests/disas/winch/aarch64/i32_rotl/params.wat
new file mode 100644
index 000000000000..2f3d857ab6df
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_rotl/params.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.rotl)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       stur    w3, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       sub     w0, w0, wzr
+;;       ror     w1, w1, w0
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_rotr/16_const.wat b/tests/disas/winch/aarch64/i32_rotr/16_const.wat
new file mode 100644
index 000000000000..82a0df5ab220
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_rotr/16_const.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 512)
+        (i32.rotr)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       mov     x16, #0x200
+;;       ror     w0, w0, w16
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_rotr/8_const.wat b/tests/disas/winch/aarch64/i32_rotr/8_const.wat
new file mode 100644
index 000000000000..68b98462b2a7
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_rotr/8_const.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 2)
+        (i32.rotr)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       ror     w0, w0, #2
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_rotr/locals.wat b/tests/disas/winch/aarch64/i32_rotr/locals.wat
new file mode 100644
index 000000000000..998edff0b1f8
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_rotr/locals.wat
@@ -0,0 +1,44 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)  
+        (local $bar i32)
+
+        (i32.const 1)
+        (local.set $foo)
+
+        (i32.const 2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.rotr)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       stur    w0, [x28, #4]
+;;       mov     x16, #2
+;;       mov     w0, w16
+;;       stur    w0, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       ror     w1, w1, w0
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_rotr/params.wat b/tests/disas/winch/aarch64/i32_rotr/params.wat
new file mode 100644
index 000000000000..73a2ba6910b2
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_rotr/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.rotr)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       stur    w3, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       ror     w1, w1, w0
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_shl/16_const.wat b/tests/disas/winch/aarch64/i32_shl/16_const.wat
new file mode 100644
index 000000000000..f792f5393284
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_shl/16_const.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 512)
+        (i32.shl)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       mov     x16, #0x200
+;;       lsl     w0, w0, w16
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_shl/8_const.wat b/tests/disas/winch/aarch64/i32_shl/8_const.wat
new file mode 100644
index 000000000000..9f2c79e05c09
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_shl/8_const.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 2)
+        (i32.shl)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       lsl     w0, w0, #2
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_shl/locals.wat b/tests/disas/winch/aarch64/i32_shl/locals.wat
new file mode 100644
index 000000000000..9d25ff10c15b
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_shl/locals.wat
@@ -0,0 +1,44 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)  
+        (local $bar i32)
+
+        (i32.const 1)
+        (local.set $foo)
+
+        (i32.const 2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.shl)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       stur    w0, [x28, #4]
+;;       mov     x16, #2
+;;       mov     w0, w16
+;;       stur    w0, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       lsl     w1, w1, w0
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_shl/params.wat b/tests/disas/winch/aarch64/i32_shl/params.wat
new file mode 100644
index 000000000000..750bae0c8bfc
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_shl/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.shl)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       stur    w3, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       lsl     w1, w1, w0
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_shr_s/16_const.wat b/tests/disas/winch/aarch64/i32_shr_s/16_const.wat
new file mode 100644
index 000000000000..2adbff3e191b
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_shr_s/16_const.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 512)
+        (i32.shr_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       mov     x16, #0x200
+;;       asr     w0, w0, w16
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_shr_s/8_const.wat b/tests/disas/winch/aarch64/i32_shr_s/8_const.wat
new file mode 100644
index 000000000000..ceff09d356db
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_shr_s/8_const.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 2)
+        (i32.shr_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       asr     w0, w0, #2
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_shr_s/locals.wat b/tests/disas/winch/aarch64/i32_shr_s/locals.wat
new file mode 100644
index 000000000000..5bc01fd76c40
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_shr_s/locals.wat
@@ -0,0 +1,44 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)  
+        (local $bar i32)
+
+        (i32.const 1)
+        (local.set $foo)
+
+        (i32.const 2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.shr_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       stur    w0, [x28, #4]
+;;       mov     x16, #2
+;;       mov     w0, w16
+;;       stur    w0, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       asr     w1, w1, w0
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_shr_s/params.wat b/tests/disas/winch/aarch64/i32_shr_s/params.wat
new file mode 100644
index 000000000000..2642370d5ee8
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_shr_s/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.shr_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       stur    w3, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       asr     w1, w1, w0
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_shr_u/16_const.wat b/tests/disas/winch/aarch64/i32_shr_u/16_const.wat
new file mode 100644
index 000000000000..a66a99857f98
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_shr_u/16_const.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 512)
+        (i32.shr_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       mov     x16, #0x200
+;;       lsr     w0, w0, w16
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_shr_u/8_const.wat b/tests/disas/winch/aarch64/i32_shr_u/8_const.wat
new file mode 100644
index 000000000000..c3bcff0c7880
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_shr_u/8_const.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 2)
+        (i32.shr_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       lsr     w0, w0, #2
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_shr_u/locals.wat b/tests/disas/winch/aarch64/i32_shr_u/locals.wat
new file mode 100644
index 000000000000..25045070d1f5
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_shr_u/locals.wat
@@ -0,0 +1,44 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)  
+        (local $bar i32)
+
+        (i32.const 1)
+        (local.set $foo)
+
+        (i32.const 2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.shr_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       stur    w0, [x28, #4]
+;;       mov     x16, #2
+;;       mov     w0, w16
+;;       stur    w0, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       lsr     w1, w1, w0
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_shr_u/params.wat b/tests/disas/winch/aarch64/i32_shr_u/params.wat
new file mode 100644
index 000000000000..e5658d370018
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_shr_u/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.shr_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       stur    w3, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       lsr     w1, w1, w0
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_sub/const.wat b/tests/disas/winch/aarch64/i32_sub/const.wat
new file mode 100644
index 000000000000..f9baec2113bd
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_sub/const.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const 10)
+	(i32.const 20)
+	(i32.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0xa
+;;       mov     w0, w16
+;;       sub     w0, w0, #0x14
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_sub/locals.wat b/tests/disas/winch/aarch64/i32_sub/locals.wat
new file mode 100644
index 000000000000..7847d1d4f89e
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_sub/locals.wat
@@ -0,0 +1,44 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)  
+        (local $bar i32)
+
+        (i32.const 10)
+        (local.set $foo)
+
+        (i32.const 20)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        i32.sub
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     x16, #0xa
+;;       mov     w0, w16
+;;       stur    w0, [x28, #4]
+;;       mov     x16, #0x14
+;;       mov     w0, w16
+;;       stur    w0, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       sub     w1, w1, w0, uxtx
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_sub/max.wat b/tests/disas/winch/aarch64/i32_sub/max.wat
new file mode 100644
index 000000000000..db3d65ec167c
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_sub/max.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+(module
+    (func (result i32)
+	(i32.const 0x7fffffff)
+	(i32.const -1)
+	(i32.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       orr     x16, xzr, #0x7fffffff
+;;       mov     w0, w16
+;;       orr     x16, xzr, #0xffffffff
+;;       sub     w0, w0, w16, uxtx
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_sub/max_one.wat b/tests/disas/winch/aarch64/i32_sub/max_one.wat
new file mode 100644
index 000000000000..8b0b5b5ce5fd
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_sub/max_one.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const 0x80000000)
+	(i32.const 1)
+	(i32.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0x80000000
+;;       mov     w0, w16
+;;       sub     w0, w0, #1
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_sub/mixed.wat b/tests/disas/winch/aarch64/i32_sub/mixed.wat
new file mode 100644
index 000000000000..8ca5aedc7b98
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_sub/mixed.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const -1)
+	(i32.const 1)
+	(i32.sub)
+     )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       orr     x16, xzr, #0xffffffff
+;;       mov     w0, w16
+;;       sub     w0, w0, #1
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_sub/params.wat b/tests/disas/winch/aarch64/i32_sub/params.wat
new file mode 100644
index 000000000000..b21a6fd85c7e
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_sub/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+	(local.get 0)
+	(local.get 1)
+	(i32.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       stur    w3, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       sub     w1, w1, w0, uxtx
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_sub/signed.wat b/tests/disas/winch/aarch64/i32_sub/signed.wat
new file mode 100644
index 000000000000..fad743f38a90
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_sub/signed.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const -1)
+	(i32.const -1)
+	(i32.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       orr     x16, xzr, #0xffffffff
+;;       mov     w0, w16
+;;       orr     x16, xzr, #0xffffffff
+;;       sub     w0, w0, w16, uxtx
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_sub/unsigned_with_zero.wat b/tests/disas/winch/aarch64/i32_sub/unsigned_with_zero.wat
new file mode 100644
index 000000000000..043368fe5c31
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_sub/unsigned_with_zero.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+     	(i32.const 0)
+    	(i32.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       sub     w0, w0, #0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_wrap_i64/const.wat b/tests/disas/winch/aarch64/i32_wrap_i64/const.wat
new file mode 100644
index 000000000000..4d4fca8249af
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_wrap_i64/const.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 1)
+        (i32.wrap_i64)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     x0, x16
+;;       mov     w0, w0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_wrap_i64/locals.wat b/tests/disas/winch/aarch64/i32_wrap_i64/locals.wat
new file mode 100644
index 000000000000..eacaa9979281
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_wrap_i64/locals.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local i64)
+
+        (local.get 0)
+        (i32.wrap_i64)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       ldur    x0, [x28]
+;;       mov     w0, w0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_wrap_i64/params.wat b/tests/disas/winch/aarch64/i32_wrap_i64/params.wat
new file mode 100644
index 000000000000..de8a217adf60
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_wrap_i64/params.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (result i32)
+        (local.get 0)
+        (i32.wrap_i64)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    x2, [x28]
+;;       ldur    x0, [x28]
+;;       mov     w0, w0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_xor/const.wat b/tests/disas/winch/aarch64/i32_xor/const.wat
new file mode 100644
index 000000000000..76bbd4b68da6
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_xor/const.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 2)
+        (i32.xor)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       eor     w0, w0, #2
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_xor/locals.wat b/tests/disas/winch/aarch64/i32_xor/locals.wat
new file mode 100644
index 000000000000..7cede8bad795
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_xor/locals.wat
@@ -0,0 +1,44 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)  
+        (local $bar i32)
+
+        (i32.const 1)
+        (local.set $foo)
+
+        (i32.const 2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.xor)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       stur    w0, [x28, #4]
+;;       mov     x16, #2
+;;       mov     w0, w16
+;;       stur    w0, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       eor     w1, w1, w0
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i32_xor/params.wat b/tests/disas/winch/aarch64/i32_xor/params.wat
new file mode 100644
index 000000000000..892e9abf6dd0
--- /dev/null
+++ b/tests/disas/winch/aarch64/i32_xor/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.xor)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       stur    w3, [x28]
+;;       ldur    w0, [x28]
+;;       ldur    w1, [x28, #4]
+;;       eor     w1, w1, w0
+;;       mov     w0, w1
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_add/const.wat b/tests/disas/winch/aarch64/i64_add/const.wat
new file mode 100644
index 000000000000..d59ee86df6e9
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_add/const.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const 10)
+	(i64.const 20)
+	(i64.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0xa
+;;       mov     x0, x16
+;;       add     x0, x0, #0x14
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_add/locals.wat b/tests/disas/winch/aarch64/i64_add/locals.wat
new file mode 100644
index 000000000000..2e5692601c88
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_add/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local $foo i64)  
+        (local $bar i64)
+
+        (i64.const 10)
+        (local.set $foo)
+
+        (i64.const 20)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        i64.add
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #0xa
+;;       mov     x0, x16
+;;       stur    x0, [x28, #8]
+;;       mov     x16, #0x14
+;;       mov     x0, x16
+;;       stur    x0, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       add     x1, x1, x0, uxtx
+;;       mov     x0, x1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_add/max.wat b/tests/disas/winch/aarch64/i64_add/max.wat
new file mode 100644
index 000000000000..531392865673
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_add/max.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+(module
+    (func (result i64)
+	(i64.const 1)
+	(i64.const 0x7fffffffffffffff)
+	(i64.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     x0, x16
+;;       mov     x16, #0x7fffffffffffffff
+;;       add     x0, x0, x16, uxtx
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_add/max_one.wat b/tests/disas/winch/aarch64/i64_add/max_one.wat
new file mode 100644
index 000000000000..cd9084a2349f
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_add/max_one.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const 0x8000000000000000)
+	(i64.const -1)
+	(i64.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #-0x8000000000000000
+;;       mov     x0, x16
+;;       mov     x16, #-1
+;;       add     x0, x0, x16, uxtx
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_add/mixed.wat b/tests/disas/winch/aarch64/i64_add/mixed.wat
new file mode 100644
index 000000000000..0d9c71c29a12
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_add/mixed.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const -1)
+	(i64.const 1)
+	(i64.add)
+     )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #-1
+;;       mov     x0, x16
+;;       add     x0, x0, #1
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_add/params.wat b/tests/disas/winch/aarch64/i64_add/params.wat
new file mode 100644
index 000000000000..06213211c1d5
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_add/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i64)
+	(local.get 0)
+	(local.get 1)
+	(i64.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    x2, [x28, #8]
+;;       stur    x3, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       add     x1, x1, x0, uxtx
+;;       mov     x0, x1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_add/signed.wat b/tests/disas/winch/aarch64/i64_add/signed.wat
new file mode 100644
index 000000000000..424e5e4b9dda
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_add/signed.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const -1)
+	(i64.const -1)
+	(i64.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #-1
+;;       mov     x0, x16
+;;       mov     x16, #-1
+;;       add     x0, x0, x16, uxtx
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_add/unsigned_with_zero.wat b/tests/disas/winch/aarch64/i64_add/unsigned_with_zero.wat
new file mode 100644
index 000000000000..9aefeb627146
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_add/unsigned_with_zero.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+     	(i64.const 0)
+    	(i64.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     x0, x16
+;;       add     x0, x0, #0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_and/32_const.wat b/tests/disas/winch/aarch64/i64_and/32_const.wat
new file mode 100644
index 000000000000..7e82c94f42ef
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_and/32_const.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 2)
+        (i64.const 3)
+        (i64.and)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #2
+;;       mov     x0, x16
+;;       and     x0, x0, #3
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_and/64_const.wat b/tests/disas/winch/aarch64/i64_and/64_const.wat
new file mode 100644
index 000000000000..232bddd07ea4
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_and/64_const.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 9223372036854775806)
+        (i64.const 9223372036854775807)
+        (i64.and)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       orr     x16, xzr, #0x7ffffffffffffffe
+;;       mov     x0, x16
+;;       and     x0, x0, #0x7fffffffffffffff
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_and/locals.wat b/tests/disas/winch/aarch64/i64_and/locals.wat
new file mode 100644
index 000000000000..6b0e94d70fcb
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_and/locals.wat
@@ -0,0 +1,44 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local $foo i64)
+        (local $bar i64)
+
+        (i64.const 2)
+        (local.set $foo)
+        (i64.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.and)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #2
+;;       mov     x0, x16
+;;       stur    x0, [x28, #8]
+;;       mov     x16, #3
+;;       mov     x0, x16
+;;       stur    x0, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       and     x1, x1, x0
+;;       mov     x0, x1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_and/params.wat b/tests/disas/winch/aarch64/i64_and/params.wat
new file mode 100644
index 000000000000..23e3fb66201b
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_and/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i64)
+        (local.get 0)
+        (local.get 1)
+        (i64.and)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    x2, [x28, #8]
+;;       stur    x3, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       and     x1, x1, x0
+;;       mov     x0, x1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_clz/const.wat b/tests/disas/winch/aarch64/i64_clz/const.wat
new file mode 100644
index 000000000000..ec97ed9b9090
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_clz/const.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const 10)
+	(i64.clz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0xa
+;;       mov     x0, x16
+;;       clz     x0, x0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_clz/locals.wat b/tests/disas/winch/aarch64/i64_clz/locals.wat
new file mode 100644
index 000000000000..48fcb979b552
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_clz/locals.wat
@@ -0,0 +1,32 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local $foo i64)  
+
+        (i64.const 10)
+        (local.tee $foo)
+
+        i64.clz
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     x16, #0xa
+;;       mov     x0, x16
+;;       stur    x0, [x28]
+;;       clz     x0, x0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_clz/params.wat b/tests/disas/winch/aarch64/i64_clz/params.wat
new file mode 100644
index 000000000000..c679dd4b9353
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_clz/params.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (result i64)
+	(local.get 0)
+	(i64.clz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    x2, [x28]
+;;       ldur    x0, [x28]
+;;       clz     x0, x0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_ctz/const.wat b/tests/disas/winch/aarch64/i64_ctz/const.wat
new file mode 100644
index 000000000000..b99642804e5d
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_ctz/const.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const 10)
+	(i64.ctz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0xa
+;;       mov     x0, x16
+;;       rbit    x16, x0
+;;       clz     x0, x16
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_ctz/locals.wat b/tests/disas/winch/aarch64/i64_ctz/locals.wat
new file mode 100644
index 000000000000..cd8ab595d1ab
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_ctz/locals.wat
@@ -0,0 +1,33 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local $foo i64)  
+
+        (i64.const 10)
+        (local.tee $foo)
+
+        i64.ctz
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       mov     x16, #0xa
+;;       mov     x0, x16
+;;       stur    x0, [x28]
+;;       rbit    x16, x0
+;;       clz     x0, x16
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_ctz/params.wat b/tests/disas/winch/aarch64/i64_ctz/params.wat
new file mode 100644
index 000000000000..cc7b20481f76
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_ctz/params.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (result i64)
+	(local.get 0)
+	(i64.ctz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    x2, [x28]
+;;       ldur    x0, [x28]
+;;       rbit    x16, x0
+;;       clz     x0, x16
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_eq/const.wat b/tests/disas/winch/aarch64/i64_eq/const.wat
new file mode 100644
index 000000000000..2928388bfaf1
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_eq/const.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 1)
+        (i64.const 1)
+        (i64.eq)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     x0, x16
+;;       cmp     x0, #1
+;;       cset    x0, eq
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_eq/locals.wat b/tests/disas/winch/aarch64/i64_eq/locals.wat
new file mode 100644
index 000000000000..a80dbf6af262
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_eq/locals.wat
@@ -0,0 +1,46 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i64)
+        (local $bar i64)
+
+        (i64.const 2)
+        (local.set $foo)
+        (i64.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.eq)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #2
+;;       mov     x0, x16
+;;       stur    x0, [x28, #8]
+;;       mov     x16, #3
+;;       mov     x0, x16
+;;       stur    x0, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       cmp     x1, x0, uxtx
+;;       cset    x1, eq
+;;       mov     w0, w1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_eq/params.wat b/tests/disas/winch/aarch64/i64_eq/params.wat
new file mode 100644
index 000000000000..8b8e2cfffd23
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_eq/params.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i64.eq)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    x2, [x28, #8]
+;;       stur    x3, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       cmp     x1, x0, uxtx
+;;       cset    x1, eq
+;;       mov     w0, w1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_extend_16_s/const.wat b/tests/disas/winch/aarch64/i64_extend_16_s/const.wat
new file mode 100644
index 000000000000..f045ac6d6540
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_extend_16_s/const.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.extend16_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     x0, x16
+;;       sxth    x0, w0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_extend_16_s/locals.wat b/tests/disas/winch/aarch64/i64_extend_16_s/locals.wat
new file mode 100644
index 000000000000..43d05bfaa7b8
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_extend_16_s/locals.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local i64)
+
+        (local.get 0)
+        (i64.extend16_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       ldur    x0, [x28]
+;;       sxth    x0, w0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_extend_16_s/params.wat b/tests/disas/winch/aarch64/i64_extend_16_s/params.wat
new file mode 100644
index 000000000000..343d6f99a0b5
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_extend_16_s/params.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (result i64)
+        (local.get 0)
+        (i64.extend16_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    x2, [x28]
+;;       ldur    x0, [x28]
+;;       sxth    x0, w0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_extend_32_s/const.wat b/tests/disas/winch/aarch64/i64_extend_32_s/const.wat
new file mode 100644
index 000000000000..1462c5fbc539
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_extend_32_s/const.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.extend32_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     x0, x16
+;;       sxtw    x0, w0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_extend_32_s/locals.wat b/tests/disas/winch/aarch64/i64_extend_32_s/locals.wat
new file mode 100644
index 000000000000..4b0848de1c7c
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_extend_32_s/locals.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local i64)
+
+        (local.get 0)
+        (i64.extend32_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       ldur    x0, [x28]
+;;       sxtw    x0, w0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_extend_32_s/params.wat b/tests/disas/winch/aarch64/i64_extend_32_s/params.wat
new file mode 100644
index 000000000000..dde5a053c311
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_extend_32_s/params.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (result i64)
+        (local.get 0)
+        (i64.extend32_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    x2, [x28]
+;;       ldur    x0, [x28]
+;;       sxtw    x0, w0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_extend_8_s/const.wat b/tests/disas/winch/aarch64/i64_extend_8_s/const.wat
new file mode 100644
index 000000000000..b7771a8ba117
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_extend_8_s/const.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.extend8_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     x0, x16
+;;       sxtb    x0, w0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_extend_8_s/locals.wat b/tests/disas/winch/aarch64/i64_extend_8_s/locals.wat
new file mode 100644
index 000000000000..caa7ffd46b7e
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_extend_8_s/locals.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local i64)
+
+        (local.get 0)
+        (i64.extend8_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       ldur    x0, [x28]
+;;       sxtb    x0, w0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_extend_8_s/params.wat b/tests/disas/winch/aarch64/i64_extend_8_s/params.wat
new file mode 100644
index 000000000000..6e1cf45556d0
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_extend_8_s/params.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (result i64)
+        (local.get 0)
+        (i64.extend8_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    x2, [x28]
+;;       ldur    x0, [x28]
+;;       sxtb    x0, w0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_extend_i32_s/const.wat b/tests/disas/winch/aarch64/i64_extend_i32_s/const.wat
new file mode 100644
index 000000000000..8dff976c745a
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_extend_i32_s/const.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i32.const 1)
+        (i64.extend_i32_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       sxtw    x0, w0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_extend_i32_s/locals.wat b/tests/disas/winch/aarch64/i64_extend_i32_s/locals.wat
new file mode 100644
index 000000000000..ec2c8473796a
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_extend_i32_s/locals.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local i32)
+
+        (local.get 0)
+        (i64.extend_i32_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       ldur    w0, [x28, #4]
+;;       sxtw    x0, w0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_extend_i32_s/params.wat b/tests/disas/winch/aarch64/i64_extend_i32_s/params.wat
new file mode 100644
index 000000000000..cabe373d626c
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_extend_i32_s/params.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (result i64)
+        (local.get 0)
+        (i64.extend_i32_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       ldur    w0, [x28, #4]
+;;       sxtw    x0, w0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_extend_i32_u/const.wat b/tests/disas/winch/aarch64/i64_extend_i32_u/const.wat
new file mode 100644
index 000000000000..5772d7e5ce9c
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_extend_i32_u/const.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i32.const 1)
+        (i64.extend_i32_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       mov     w0, w0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_extend_i32_u/locals.wat b/tests/disas/winch/aarch64/i64_extend_i32_u/locals.wat
new file mode 100644
index 000000000000..3be1cdf1688e
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_extend_i32_u/locals.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local i32)
+
+        (local.get 0)
+        (i64.extend_i32_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       mov     x16, #0
+;;       stur    x16, [x28]
+;;       ldur    w0, [x28, #4]
+;;       mov     w0, w0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_extend_i32_u/params.wat b/tests/disas/winch/aarch64/i64_extend_i32_u/params.wat
new file mode 100644
index 000000000000..530a50c37bda
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_extend_i32_u/params.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (result i64)
+        (local.get 0)
+        (i64.extend_i32_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    w2, [x28, #4]
+;;       ldur    w0, [x28, #4]
+;;       mov     w0, w0
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_ge_s/const.wat b/tests/disas/winch/aarch64/i64_ge_s/const.wat
new file mode 100644
index 000000000000..c3b39e6a59a9
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_ge_s/const.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const -1)
+        (i64.const -2)
+        (i64.ge_s)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #-1
+;;       mov     x0, x16
+;;       mov     x16, #-2
+;;       cmp     x0, x16, uxtx
+;;       cset    x0, ge
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_ge_s/locals.wat b/tests/disas/winch/aarch64/i64_ge_s/locals.wat
new file mode 100644
index 000000000000..ec56ac7a9116
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_ge_s/locals.wat
@@ -0,0 +1,46 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i64)
+        (local $bar i64)
+
+        (i64.const -2)
+        (local.set $foo)
+        (i64.const -3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.ge_s)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #-2
+;;       mov     x0, x16
+;;       stur    x0, [x28, #8]
+;;       mov     x16, #-3
+;;       mov     x0, x16
+;;       stur    x0, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       cmp     x1, x0, uxtx
+;;       cset    x1, ge
+;;       mov     w0, w1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_ge_s/params.wat b/tests/disas/winch/aarch64/i64_ge_s/params.wat
new file mode 100644
index 000000000000..a67a0d9cde93
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_ge_s/params.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i64.ge_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    x2, [x28, #8]
+;;       stur    x3, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       cmp     x1, x0, uxtx
+;;       cset    x1, ge
+;;       mov     w0, w1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_ge_u/const.wat b/tests/disas/winch/aarch64/i64_ge_u/const.wat
new file mode 100644
index 000000000000..b8455b1753aa
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_ge_u/const.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 1)
+        (i64.const 2)
+        (i64.ge_u)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     x0, x16
+;;       cmp     x0, #2
+;;       cset    x0, hs
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_ge_u/locals.wat b/tests/disas/winch/aarch64/i64_ge_u/locals.wat
new file mode 100644
index 000000000000..8c10aca609a4
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_ge_u/locals.wat
@@ -0,0 +1,46 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i64)
+        (local $bar i64)
+
+        (i64.const 2)
+        (local.set $foo)
+        (i64.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.ge_u)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #2
+;;       mov     x0, x16
+;;       stur    x0, [x28, #8]
+;;       mov     x16, #3
+;;       mov     x0, x16
+;;       stur    x0, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       cmp     x1, x0, uxtx
+;;       cset    x1, hs
+;;       mov     w0, w1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_ge_u/params.wat b/tests/disas/winch/aarch64/i64_ge_u/params.wat
new file mode 100644
index 000000000000..c8febe2c2b05
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_ge_u/params.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i64.ge_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    x2, [x28, #8]
+;;       stur    x3, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       cmp     x1, x0, uxtx
+;;       cset    x1, hs
+;;       mov     w0, w1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_gt_s/const.wat b/tests/disas/winch/aarch64/i64_gt_s/const.wat
new file mode 100644
index 000000000000..a2d7c74bbab4
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_gt_s/const.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const -1)
+        (i64.const -2)
+        (i64.gt_s)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #-1
+;;       mov     x0, x16
+;;       mov     x16, #-2
+;;       cmp     x0, x16, uxtx
+;;       cset    x0, gt
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_gt_s/locals.wat b/tests/disas/winch/aarch64/i64_gt_s/locals.wat
new file mode 100644
index 000000000000..9ba4a7834b87
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_gt_s/locals.wat
@@ -0,0 +1,46 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i64)
+        (local $bar i64)
+
+        (i64.const -2)
+        (local.set $foo)
+        (i64.const -3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.gt_s)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #-2
+;;       mov     x0, x16
+;;       stur    x0, [x28, #8]
+;;       mov     x16, #-3
+;;       mov     x0, x16
+;;       stur    x0, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       cmp     x1, x0, uxtx
+;;       cset    x1, gt
+;;       mov     w0, w1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_gt_s/params.wat b/tests/disas/winch/aarch64/i64_gt_s/params.wat
new file mode 100644
index 000000000000..3406a68ba7de
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_gt_s/params.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i64.gt_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    x2, [x28, #8]
+;;       stur    x3, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       cmp     x1, x0, uxtx
+;;       cset    x1, gt
+;;       mov     w0, w1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_gt_u/const.wat b/tests/disas/winch/aarch64/i64_gt_u/const.wat
new file mode 100644
index 000000000000..b04d294fafea
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_gt_u/const.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 1)
+        (i64.const 2)
+        (i64.gt_u)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     x0, x16
+;;       cmp     x0, #2
+;;       cset    x0, hi
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_gt_u/locals.wat b/tests/disas/winch/aarch64/i64_gt_u/locals.wat
new file mode 100644
index 000000000000..e342909dc7f9
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_gt_u/locals.wat
@@ -0,0 +1,46 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i64)
+        (local $bar i64)
+
+        (i64.const 2)
+        (local.set $foo)
+        (i64.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.gt_u)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #2
+;;       mov     x0, x16
+;;       stur    x0, [x28, #8]
+;;       mov     x16, #3
+;;       mov     x0, x16
+;;       stur    x0, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       cmp     x1, x0, uxtx
+;;       cset    x1, hi
+;;       mov     w0, w1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_gt_u/params.wat b/tests/disas/winch/aarch64/i64_gt_u/params.wat
new file mode 100644
index 000000000000..207122e679ee
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_gt_u/params.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i64.gt_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    x2, [x28, #8]
+;;       stur    x3, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       cmp     x1, x0, uxtx
+;;       cset    x1, hi
+;;       mov     w0, w1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_le_s/const.wat b/tests/disas/winch/aarch64/i64_le_s/const.wat
new file mode 100644
index 000000000000..19a6a387909e
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_le_s/const.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const -1)
+        (i64.const -2)
+        (i64.le_s)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #-1
+;;       mov     x0, x16
+;;       mov     x16, #-2
+;;       cmp     x0, x16, uxtx
+;;       cset    x0, le
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_le_s/locals.wat b/tests/disas/winch/aarch64/i64_le_s/locals.wat
new file mode 100644
index 000000000000..2ccb1a8f46ea
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_le_s/locals.wat
@@ -0,0 +1,46 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i64)
+        (local $bar i64)
+
+        (i64.const -2)
+        (local.set $foo)
+        (i64.const -3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.le_s)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #-2
+;;       mov     x0, x16
+;;       stur    x0, [x28, #8]
+;;       mov     x16, #-3
+;;       mov     x0, x16
+;;       stur    x0, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       cmp     x1, x0, uxtx
+;;       cset    x1, le
+;;       mov     w0, w1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_le_s/params.wat b/tests/disas/winch/aarch64/i64_le_s/params.wat
new file mode 100644
index 000000000000..58c71370252b
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_le_s/params.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i64.le_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    x2, [x28, #8]
+;;       stur    x3, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       cmp     x1, x0, uxtx
+;;       cset    x1, le
+;;       mov     w0, w1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_le_u/const.wat b/tests/disas/winch/aarch64/i64_le_u/const.wat
new file mode 100644
index 000000000000..83d1372fab92
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_le_u/const.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 1)
+        (i64.const 2)
+        (i64.le_u)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     x0, x16
+;;       cmp     x0, #2
+;;       cset    x0, ls
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_le_u/locals.wat b/tests/disas/winch/aarch64/i64_le_u/locals.wat
new file mode 100644
index 000000000000..179705e6887c
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_le_u/locals.wat
@@ -0,0 +1,46 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i64)
+        (local $bar i64)
+
+        (i64.const 2)
+        (local.set $foo)
+        (i64.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.le_u)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #2
+;;       mov     x0, x16
+;;       stur    x0, [x28, #8]
+;;       mov     x16, #3
+;;       mov     x0, x16
+;;       stur    x0, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       cmp     x1, x0, uxtx
+;;       cset    x1, ls
+;;       mov     w0, w1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_le_u/params.wat b/tests/disas/winch/aarch64/i64_le_u/params.wat
new file mode 100644
index 000000000000..16294f020c17
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_le_u/params.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i64.le_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    x2, [x28, #8]
+;;       stur    x3, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       cmp     x1, x0, uxtx
+;;       cset    x1, ls
+;;       mov     w0, w1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_lt_s/const.wat b/tests/disas/winch/aarch64/i64_lt_s/const.wat
new file mode 100644
index 000000000000..3766440e3203
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_lt_s/const.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const -1)
+        (i64.const -2)
+        (i64.lt_s)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #-1
+;;       mov     x0, x16
+;;       mov     x16, #-2
+;;       cmp     x0, x16, uxtx
+;;       cset    x0, lt
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_lt_s/locals.wat b/tests/disas/winch/aarch64/i64_lt_s/locals.wat
new file mode 100644
index 000000000000..25cee5286e07
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_lt_s/locals.wat
@@ -0,0 +1,46 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i64)
+        (local $bar i64)
+
+        (i64.const -2)
+        (local.set $foo)
+        (i64.const -3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.lt_s)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #-2
+;;       mov     x0, x16
+;;       stur    x0, [x28, #8]
+;;       mov     x16, #-3
+;;       mov     x0, x16
+;;       stur    x0, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       cmp     x1, x0, uxtx
+;;       cset    x1, lt
+;;       mov     w0, w1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_lt_s/params.wat b/tests/disas/winch/aarch64/i64_lt_s/params.wat
new file mode 100644
index 000000000000..e42bcf0722e6
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_lt_s/params.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i64.lt_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    x2, [x28, #8]
+;;       stur    x3, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       cmp     x1, x0, uxtx
+;;       cset    x1, lt
+;;       mov     w0, w1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_lt_u/const.wat b/tests/disas/winch/aarch64/i64_lt_u/const.wat
new file mode 100644
index 000000000000..9aa48b29af1e
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_lt_u/const.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 1)
+        (i64.const 2)
+        (i64.lt_u)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     x0, x16
+;;       cmp     x0, #2
+;;       cset    x0, lo
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_lt_u/locals.wat b/tests/disas/winch/aarch64/i64_lt_u/locals.wat
new file mode 100644
index 000000000000..a1e19ac93f69
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_lt_u/locals.wat
@@ -0,0 +1,46 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i64)
+        (local $bar i64)
+
+        (i64.const 2)
+        (local.set $foo)
+        (i64.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.lt_u)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #2
+;;       mov     x0, x16
+;;       stur    x0, [x28, #8]
+;;       mov     x16, #3
+;;       mov     x0, x16
+;;       stur    x0, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       cmp     x1, x0, uxtx
+;;       cset    x1, lo
+;;       mov     w0, w1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_lt_u/params.wat b/tests/disas/winch/aarch64/i64_lt_u/params.wat
new file mode 100644
index 000000000000..5483579b4ed3
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_lt_u/params.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i64.lt_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    x2, [x28, #8]
+;;       stur    x3, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       cmp     x1, x0, uxtx
+;;       cset    x1, lo
+;;       mov     w0, w1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_mul/const.wat b/tests/disas/winch/aarch64/i64_mul/const.wat
new file mode 100644
index 000000000000..e9fd4cb4e526
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_mul/const.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const 10)
+	(i64.const 20)
+	(i64.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0xa
+;;       mov     x0, x16
+;;       mov     x16, #0x14
+;;       mul     x0, x0, x16
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_mul/locals.wat b/tests/disas/winch/aarch64/i64_mul/locals.wat
new file mode 100644
index 000000000000..501ca8345104
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_mul/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local $foo i64)  
+        (local $bar i64)
+
+        (i64.const 10)
+        (local.set $foo)
+
+        (i64.const 20)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        i64.mul
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #0xa
+;;       mov     x0, x16
+;;       stur    x0, [x28, #8]
+;;       mov     x16, #0x14
+;;       mov     x0, x16
+;;       stur    x0, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       mul     x1, x1, x0
+;;       mov     x0, x1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_mul/max.wat b/tests/disas/winch/aarch64/i64_mul/max.wat
new file mode 100644
index 000000000000..dd1064c04b8b
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_mul/max.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+(module
+    (func (result i64)
+	(i64.const 0x7fffffffffffffff)
+	(i64.const -1)
+	(i64.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0x7fffffffffffffff
+;;       mov     x0, x16
+;;       mov     x16, #-1
+;;       mul     x0, x0, x16
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_mul/max_one.wat b/tests/disas/winch/aarch64/i64_mul/max_one.wat
new file mode 100644
index 000000000000..747c80ffef73
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_mul/max_one.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const 0x8000000000000000)
+	(i64.const -1)
+	(i64.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #-0x8000000000000000
+;;       mov     x0, x16
+;;       mov     x16, #-1
+;;       mul     x0, x0, x16
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_mul/mixed.wat b/tests/disas/winch/aarch64/i64_mul/mixed.wat
new file mode 100644
index 000000000000..edc3f950aebf
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_mul/mixed.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const -1)
+	(i64.const 1)
+	(i64.mul)
+     )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #-1
+;;       mov     x0, x16
+;;       mov     x16, #1
+;;       mul     x0, x0, x16
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_mul/params.wat b/tests/disas/winch/aarch64/i64_mul/params.wat
new file mode 100644
index 000000000000..41d9307e8ee4
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_mul/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i64)
+	(local.get 0)
+	(local.get 1)
+	(i64.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    x2, [x28, #8]
+;;       stur    x3, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       mul     x1, x1, x0
+;;       mov     x0, x1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_mul/signed.wat b/tests/disas/winch/aarch64/i64_mul/signed.wat
new file mode 100644
index 000000000000..6d433402e015
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_mul/signed.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const -1)
+	(i64.const -1)
+	(i64.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #-1
+;;       mov     x0, x16
+;;       mov     x16, #-1
+;;       mul     x0, x0, x16
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_mul/unsigned_with_zero.wat b/tests/disas/winch/aarch64/i64_mul/unsigned_with_zero.wat
new file mode 100644
index 000000000000..2cdb18cfea1c
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_mul/unsigned_with_zero.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+     	(i64.const 0)
+    	(i64.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     x0, x16
+;;       mov     x16, #0
+;;       mul     x0, x0, x16
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_ne/const.wat b/tests/disas/winch/aarch64/i64_ne/const.wat
new file mode 100644
index 000000000000..99cb1c2c43b1
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_ne/const.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 1)
+        (i64.const 2)
+        (i64.ne)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     x0, x16
+;;       cmp     x0, #2
+;;       cset    x0, ne
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_ne/locals.wat b/tests/disas/winch/aarch64/i64_ne/locals.wat
new file mode 100644
index 000000000000..71db0f7d3f53
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_ne/locals.wat
@@ -0,0 +1,46 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i64)
+        (local $bar i64)
+
+        (i64.const 2)
+        (local.set $foo)
+        (i64.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.ne)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #2
+;;       mov     x0, x16
+;;       stur    x0, [x28, #8]
+;;       mov     x16, #3
+;;       mov     x0, x16
+;;       stur    x0, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       cmp     x1, x0, uxtx
+;;       cset    x1, ne
+;;       mov     w0, w1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_ne/params.wat b/tests/disas/winch/aarch64/i64_ne/params.wat
new file mode 100644
index 000000000000..46cbdd867cc3
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_ne/params.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i64.ne)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    x2, [x28, #8]
+;;       stur    x3, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       cmp     x1, x0, uxtx
+;;       cset    x1, ne
+;;       mov     w0, w1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_or/32_const.wat b/tests/disas/winch/aarch64/i64_or/32_const.wat
new file mode 100644
index 000000000000..40a6e1864495
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_or/32_const.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 2)
+        (i64.const 3)
+        (i64.or)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #2
+;;       mov     x0, x16
+;;       orr     x0, x0, #3
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_or/64_const.wat b/tests/disas/winch/aarch64/i64_or/64_const.wat
new file mode 100644
index 000000000000..2e183b9866cb
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_or/64_const.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 9223372036854775806)
+        (i64.const 9223372036854775807)
+        (i64.or)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       orr     x16, xzr, #0x7ffffffffffffffe
+;;       mov     x0, x16
+;;       orr     x0, x0, #0x7fffffffffffffff
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_or/locals.wat b/tests/disas/winch/aarch64/i64_or/locals.wat
new file mode 100644
index 000000000000..02335a63bbaf
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_or/locals.wat
@@ -0,0 +1,44 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local $foo i64)
+        (local $bar i64)
+
+        (i64.const 2)
+        (local.set $foo)
+        (i64.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.or)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #2
+;;       mov     x0, x16
+;;       stur    x0, [x28, #8]
+;;       mov     x16, #3
+;;       mov     x0, x16
+;;       stur    x0, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       orr     x1, x1, x0
+;;       mov     x0, x1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_or/params.wat b/tests/disas/winch/aarch64/i64_or/params.wat
new file mode 100644
index 000000000000..65760cfbfd19
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_or/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i64)
+        (local.get 0)
+        (local.get 1)
+        (i64.or)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    x2, [x28, #8]
+;;       stur    x3, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       orr     x1, x1, x0
+;;       mov     x0, x1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_popcnt/const.wat b/tests/disas/winch/aarch64/i64_popcnt/const.wat
new file mode 100644
index 000000000000..21ea6f0064cd
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_popcnt/const.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+      i64.const 3
+      i64.popcnt
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #3
+;;       mov     x0, x16
+;;       fmov    d31, x0
+;;       cnt     v31.8b, v31.8b
+;;       addv    b31, v31.8b
+;;       umov    w0, v31.b[0]
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_popcnt/reg.wat b/tests/disas/winch/aarch64/i64_popcnt/reg.wat
new file mode 100644
index 000000000000..f2115db0ad58
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_popcnt/reg.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (result i64)
+      local.get 0
+      i64.popcnt
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    x2, [x28]
+;;       ldur    x0, [x28]
+;;       fmov    d31, x0
+;;       cnt     v31.8b, v31.8b
+;;       addv    b31, v31.8b
+;;       umov    w0, v31.b[0]
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_rotl/16_const.wat b/tests/disas/winch/aarch64/i64_rotl/16_const.wat
new file mode 100644
index 000000000000..54471ba1bbba
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_rotl/16_const.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.const 512)
+        (i64.rotl)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     x0, x16
+;;       sub     x0, x0, xzr
+;;       mov     x16, #0x200
+;;       ror     x0, x0, x16
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_rotl/8_const.wat b/tests/disas/winch/aarch64/i64_rotl/8_const.wat
new file mode 100644
index 000000000000..a61e486adc18
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_rotl/8_const.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.const 2)
+        (i64.rotl)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     x0, x16
+;;       sub     x0, x0, xzr
+;;       ror     x0, x0, #2
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_rotl/locals.wat b/tests/disas/winch/aarch64/i64_rotl/locals.wat
new file mode 100644
index 000000000000..9784c2509541
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_rotl/locals.wat
@@ -0,0 +1,46 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local $foo i64)  
+        (local $bar i64)
+
+        (i64.const 1)
+        (local.set $foo)
+
+        (i64.const 2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.rotl)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #1
+;;       mov     x0, x16
+;;       stur    x0, [x28, #8]
+;;       mov     x16, #2
+;;       mov     x0, x16
+;;       stur    x0, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       sub     x0, x0, xzr
+;;       ror     x1, x1, x0
+;;       mov     x0, x1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_rotl/params.wat b/tests/disas/winch/aarch64/i64_rotl/params.wat
new file mode 100644
index 000000000000..7ea35f4dacac
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_rotl/params.wat
@@ -0,0 +1,30 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i64)
+        (local.get 0)
+        (local.get 1)
+        (i64.rotl)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    x2, [x28, #8]
+;;       stur    x3, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       sub     x0, x0, xzr
+;;       ror     x1, x1, x0
+;;       mov     x0, x1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_rotr/16_const.wat b/tests/disas/winch/aarch64/i64_rotr/16_const.wat
new file mode 100644
index 000000000000..c1ead62d5f99
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_rotr/16_const.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.const 512)
+        (i64.rotr)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     x0, x16
+;;       mov     x16, #0x200
+;;       ror     x0, x0, x16
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_rotr/8_const.wat b/tests/disas/winch/aarch64/i64_rotr/8_const.wat
new file mode 100644
index 000000000000..287d7f178639
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_rotr/8_const.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.const 2)
+        (i64.rotr)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     x0, x16
+;;       ror     x0, x0, #2
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_rotr/locals.wat b/tests/disas/winch/aarch64/i64_rotr/locals.wat
new file mode 100644
index 000000000000..31db682d8eed
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_rotr/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local $foo i64)  
+        (local $bar i64)
+
+        (i64.const 1)
+        (local.set $foo)
+
+        (i64.const 2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.rotr)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #1
+;;       mov     x0, x16
+;;       stur    x0, [x28, #8]
+;;       mov     x16, #2
+;;       mov     x0, x16
+;;       stur    x0, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       ror     x1, x1, x0
+;;       mov     x0, x1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_rotr/params.wat b/tests/disas/winch/aarch64/i64_rotr/params.wat
new file mode 100644
index 000000000000..e44c129ea028
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_rotr/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i64)
+        (local.get 0)
+        (local.get 1)
+        (i64.rotr)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    x2, [x28, #8]
+;;       stur    x3, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       ror     x1, x1, x0
+;;       mov     x0, x1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_shl/16_const.wat b/tests/disas/winch/aarch64/i64_shl/16_const.wat
new file mode 100644
index 000000000000..e4e5d33e33bd
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_shl/16_const.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.const 512)
+        (i64.shl)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     x0, x16
+;;       mov     x16, #0x200
+;;       lsl     x0, x0, x16
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_shl/8_const.wat b/tests/disas/winch/aarch64/i64_shl/8_const.wat
new file mode 100644
index 000000000000..362642f61eff
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_shl/8_const.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.const 2)
+        (i64.shl)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     x0, x16
+;;       lsl     x0, x0, #2
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_shl/locals.wat b/tests/disas/winch/aarch64/i64_shl/locals.wat
new file mode 100644
index 000000000000..cd529ba3bde8
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_shl/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local $foo i64)  
+        (local $bar i64)
+
+        (i64.const 1)
+        (local.set $foo)
+
+        (i64.const 2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.shl)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #1
+;;       mov     x0, x16
+;;       stur    x0, [x28, #8]
+;;       mov     x16, #2
+;;       mov     x0, x16
+;;       stur    x0, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       lsl     x1, x1, x0
+;;       mov     x0, x1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_shl/params.wat b/tests/disas/winch/aarch64/i64_shl/params.wat
new file mode 100644
index 000000000000..0de3ca97efe9
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_shl/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i64)
+        (local.get 0)
+        (local.get 1)
+        (i64.shl)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    x2, [x28, #8]
+;;       stur    x3, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       lsl     x1, x1, x0
+;;       mov     x0, x1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_shr_s/16_const.wat b/tests/disas/winch/aarch64/i64_shr_s/16_const.wat
new file mode 100644
index 000000000000..99d67d884bb3
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_shr_s/16_const.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.const 512)
+        (i64.shr_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     x0, x16
+;;       mov     x16, #0x200
+;;       asr     x0, x0, x16
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_shr_s/8_const.wat b/tests/disas/winch/aarch64/i64_shr_s/8_const.wat
new file mode 100644
index 000000000000..0b07f24afcf1
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_shr_s/8_const.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.const 2)
+        (i64.shr_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     x0, x16
+;;       asr     x0, x0, #2
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_shr_s/locals.wat b/tests/disas/winch/aarch64/i64_shr_s/locals.wat
new file mode 100644
index 000000000000..5db726218e74
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_shr_s/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local $foo i64)  
+        (local $bar i64)
+
+        (i64.const 1)
+        (local.set $foo)
+
+        (i64.const 2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.shr_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #1
+;;       mov     x0, x16
+;;       stur    x0, [x28, #8]
+;;       mov     x16, #2
+;;       mov     x0, x16
+;;       stur    x0, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       asr     x1, x1, x0
+;;       mov     x0, x1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_shr_s/params.wat b/tests/disas/winch/aarch64/i64_shr_s/params.wat
new file mode 100644
index 000000000000..005f7e17e52d
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_shr_s/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i64)
+        (local.get 0)
+        (local.get 1)
+        (i64.shr_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    x2, [x28, #8]
+;;       stur    x3, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       asr     x1, x1, x0
+;;       mov     x0, x1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_shr_u/16_const.wat b/tests/disas/winch/aarch64/i64_shr_u/16_const.wat
new file mode 100644
index 000000000000..b0a759fd6048
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_shr_u/16_const.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.const 512)
+        (i64.shr_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     x0, x16
+;;       mov     x16, #0x200
+;;       lsr     x0, x0, x16
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_shr_u/8_const.wat b/tests/disas/winch/aarch64/i64_shr_u/8_const.wat
new file mode 100644
index 000000000000..8c45f245f358
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_shr_u/8_const.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.const 2)
+        (i64.shr_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     x0, x16
+;;       lsr     x0, x0, #2
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_shr_u/locals.wat b/tests/disas/winch/aarch64/i64_shr_u/locals.wat
new file mode 100644
index 000000000000..aa7906309baa
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_shr_u/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local $foo i64)  
+        (local $bar i64)
+
+        (i64.const 1)
+        (local.set $foo)
+
+        (i64.const 2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.shr_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #1
+;;       mov     x0, x16
+;;       stur    x0, [x28, #8]
+;;       mov     x16, #2
+;;       mov     x0, x16
+;;       stur    x0, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       lsr     x1, x1, x0
+;;       mov     x0, x1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_shr_u/params.wat b/tests/disas/winch/aarch64/i64_shr_u/params.wat
new file mode 100644
index 000000000000..39bcda73b378
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_shr_u/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i64)
+        (local.get 0)
+        (local.get 1)
+        (i64.shr_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    x2, [x28, #8]
+;;       stur    x3, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       lsr     x1, x1, x0
+;;       mov     x0, x1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_sub/const.wat b/tests/disas/winch/aarch64/i64_sub/const.wat
new file mode 100644
index 000000000000..4271d6e1902a
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_sub/const.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const 10)
+	(i64.const 20)
+	(i64.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0xa
+;;       mov     x0, x16
+;;       sub     x0, x0, #0x14
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_sub/locals.wat b/tests/disas/winch/aarch64/i64_sub/locals.wat
new file mode 100644
index 000000000000..87f221e0776f
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_sub/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local $foo i64)  
+        (local $bar i64)
+
+        (i64.const 10)
+        (local.set $foo)
+
+        (i64.const 20)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        i64.sub
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #0xa
+;;       mov     x0, x16
+;;       stur    x0, [x28, #8]
+;;       mov     x16, #0x14
+;;       mov     x0, x16
+;;       stur    x0, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       sub     x1, x1, x0, uxtx
+;;       mov     x0, x1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_sub/max.wat b/tests/disas/winch/aarch64/i64_sub/max.wat
new file mode 100644
index 000000000000..3e418166b845
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_sub/max.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+(module
+    (func (result i64)
+	(i64.const 0x7fffffffffffffff)
+	(i64.const -1)
+	(i64.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0x7fffffffffffffff
+;;       mov     x0, x16
+;;       mov     x16, #-1
+;;       sub     x0, x0, x16, uxtx
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_sub/max_one.wat b/tests/disas/winch/aarch64/i64_sub/max_one.wat
new file mode 100644
index 000000000000..7696e33e3e73
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_sub/max_one.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const 0x8000000000000000)
+	(i64.const 1)
+	(i64.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #-0x8000000000000000
+;;       mov     x0, x16
+;;       sub     x0, x0, #1
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_sub/mixed.wat b/tests/disas/winch/aarch64/i64_sub/mixed.wat
new file mode 100644
index 000000000000..ed52050077f5
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_sub/mixed.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const -1)
+	(i64.const 1)
+	(i64.sub)
+     )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #-1
+;;       mov     x0, x16
+;;       sub     x0, x0, #1
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_sub/params.wat b/tests/disas/winch/aarch64/i64_sub/params.wat
new file mode 100644
index 000000000000..1f992c93dc1d
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_sub/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i64)
+	(local.get 0)
+	(local.get 1)
+	(i64.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    x2, [x28, #8]
+;;       stur    x3, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       sub     x1, x1, x0, uxtx
+;;       mov     x0, x1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_sub/signed.wat b/tests/disas/winch/aarch64/i64_sub/signed.wat
new file mode 100644
index 000000000000..493e63e48961
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_sub/signed.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const -1)
+	(i64.const -1)
+	(i64.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #-1
+;;       mov     x0, x16
+;;       mov     x16, #-1
+;;       sub     x0, x0, x16, uxtx
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_sub/unsigned_with_zero.wat b/tests/disas/winch/aarch64/i64_sub/unsigned_with_zero.wat
new file mode 100644
index 000000000000..6ce1785a64c1
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_sub/unsigned_with_zero.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+     	(i64.const 0)
+    	(i64.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     x0, x16
+;;       sub     x0, x0, #0
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_xor/32_const.wat b/tests/disas/winch/aarch64/i64_xor/32_const.wat
new file mode 100644
index 000000000000..eb5235dff0a3
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_xor/32_const.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 2)
+        (i64.const 3)
+        (i64.xor)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #2
+;;       mov     x0, x16
+;;       eor     x0, x0, #3
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_xor/64_const.wat b/tests/disas/winch/aarch64/i64_xor/64_const.wat
new file mode 100644
index 000000000000..f5bc49de7f7e
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_xor/64_const.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 9223372036854775806)
+        (i64.const 9223372036854775807)
+        (i64.xor)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       orr     x16, xzr, #0x7ffffffffffffffe
+;;       mov     x0, x16
+;;       eor     x0, x0, #0x7fffffffffffffff
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_xor/locals.wat b/tests/disas/winch/aarch64/i64_xor/locals.wat
new file mode 100644
index 000000000000..b8a1fa5a2eec
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_xor/locals.wat
@@ -0,0 +1,44 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local $foo i64)
+        (local $bar i64)
+
+        (i64.const 2)
+        (local.set $foo)
+        (i64.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.xor)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       mov     x16, #0
+;;       stur    x16, [x28, #8]
+;;       stur    x16, [x28]
+;;       mov     x16, #2
+;;       mov     x0, x16
+;;       stur    x0, [x28, #8]
+;;       mov     x16, #3
+;;       mov     x0, x16
+;;       stur    x0, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       eor     x1, x1, x0
+;;       mov     x0, x1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/i64_xor/params.wat b/tests/disas/winch/aarch64/i64_xor/params.wat
new file mode 100644
index 000000000000..047db6184232
--- /dev/null
+++ b/tests/disas/winch/aarch64/i64_xor/params.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i64)
+        (local.get 0)
+        (local.get 1)
+        (i64.xor)
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x20
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x18]
+;;       stur    x1, [x28, #0x10]
+;;       stur    x2, [x28, #8]
+;;       stur    x3, [x28]
+;;       ldur    x0, [x28]
+;;       ldur    x1, [x28, #8]
+;;       eor     x1, x1, x0
+;;       mov     x0, x1
+;;       add     sp, sp, #0x20
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/load/f32.wat b/tests/disas/winch/aarch64/load/f32.wat
new file mode 100644
index 000000000000..71818bdd28d7
--- /dev/null
+++ b/tests/disas/winch/aarch64/load/f32.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+  (memory (data "\00\00\a0\7f"))
+
+  (func (export "f32.load") (result f32) (f32.load (i32.const 0)))
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0
+;;       mov     w0, w16
+;;       ldur    x1, [x9, #0x60]
+;;       add     x1, x1, x0, uxtx
+;;       ldur    s0, [x1]
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/load/f64.wat b/tests/disas/winch/aarch64/load/f64.wat
new file mode 100644
index 000000000000..70a9b8d5cb14
--- /dev/null
+++ b/tests/disas/winch/aarch64/load/f64.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+(module
+  (memory (data "\00\00\00\00\00\00\f4\7f"))
+
+  (func (export "f64.load") (result f64) (f64.load (i32.const 0)))
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0
+;;       mov     w0, w16
+;;       ldur    x1, [x9, #0x60]
+;;       add     x1, x1, x0, uxtx
+;;       ldur    d0, [x1]
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/load/i32.wat b/tests/disas/winch/aarch64/load/i32.wat
new file mode 100644
index 000000000000..0b65bcec2abe
--- /dev/null
+++ b/tests/disas/winch/aarch64/load/i32.wat
@@ -0,0 +1,26 @@
+;;! target = "aarch64"
+;;! test = "winch"
+(module
+  (memory 1)
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (i32.load (i32.const 0))))
+  )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0
+;;       mov     w0, w16
+;;       ldur    x1, [x9, #0x60]
+;;       add     x1, x1, x0, uxtx
+;;       ldur    w0, [x1]
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/load/i64.wat b/tests/disas/winch/aarch64/load/i64.wat
new file mode 100644
index 000000000000..c361d92129fd
--- /dev/null
+++ b/tests/disas/winch/aarch64/load/i64.wat
@@ -0,0 +1,34 @@
+;;! target = "aarch64"
+;;! test = "winch"
+(module
+  (memory 1)
+  (func (export "i64_load8_s") (param $i i64) (result i64)
+   (i64.store8 (i32.const 8) (local.get $i))
+   (i64.load8_s (i32.const 8))
+  )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x18
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x10]
+;;       stur    x1, [x28, #8]
+;;       stur    x2, [x28]
+;;       ldur    x0, [x28]
+;;       mov     x16, #8
+;;       mov     w1, w16
+;;       ldur    x2, [x9, #0x60]
+;;       add     x2, x2, x1, uxtx
+;;       sturb   w0, [x2]
+;;       mov     x16, #8
+;;       mov     w0, w16
+;;       ldur    x1, [x9, #0x60]
+;;       add     x1, x1, x0, uxtx
+;;       ldursb  x0, [x1]
+;;       add     sp, sp, #0x18
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/nop/nop.wat b/tests/disas/winch/aarch64/nop/nop.wat
new file mode 100644
index 000000000000..5b9f1acd902a
--- /dev/null
+++ b/tests/disas/winch/aarch64/nop/nop.wat
@@ -0,0 +1,21 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+    (func
+        nop
+    )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/params/400_params.wat b/tests/disas/winch/aarch64/params/400_params.wat
new file mode 100644
index 000000000000..07c9d9a74838
--- /dev/null
+++ b/tests/disas/winch/aarch64/params/400_params.wat
@@ -0,0 +1,71 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+  (type (;0;) (func (param
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+    i32 i32 i32 i32 i32 i32 i32 i32 i32 i32
+  )
+
+    (result i32)
+  ))
+  (func (export "x") (type 0) local.get 0)
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x28
+;;       mov     x28, sp
+;;       stur    x0, [x28, #0x20]
+;;       stur    x1, [x28, #0x18]
+;;       stur    w2, [x28, #0x14]
+;;       stur    w3, [x28, #0x10]
+;;       stur    w4, [x28, #0xc]
+;;       stur    w5, [x28, #8]
+;;       stur    w6, [x28, #4]
+;;       stur    w7, [x28]
+;;       ldur    w0, [x28, #0x14]
+;;       add     sp, sp, #0x28
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/store/f32.wat b/tests/disas/winch/aarch64/store/f32.wat
new file mode 100644
index 000000000000..b3401532dea2
--- /dev/null
+++ b/tests/disas/winch/aarch64/store/f32.wat
@@ -0,0 +1,27 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+  (memory (data "\00\00\a0\7f"))
+  (func (export "f32.store") (f32.store (i32.const 0) (f32.const nan:0x200000)))
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0x7fa00000
+;;       fmov    s0, w16
+;;       mov     x16, #0
+;;       mov     w0, w16
+;;       ldur    x1, [x9, #0x60]
+;;       add     x1, x1, x0, uxtx
+;;       stur    s0, [x1]
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/store/f64.wat b/tests/disas/winch/aarch64/store/f64.wat
new file mode 100644
index 000000000000..84d030e85a9e
--- /dev/null
+++ b/tests/disas/winch/aarch64/store/f64.wat
@@ -0,0 +1,28 @@
+;;! target = "aarch64"
+;;! test = "winch"
+
+(module
+  (memory (data "\00\00\00\00\00\00\f4\7f"))
+  (func (export "f64.store") (f64.store (i32.const 0) (f64.const nan:0x4000000000000)))
+)
+
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0x7ff4000000000000
+;;       fmov    d0, x16
+;;       mov     x16, #0
+;;       mov     w0, w16
+;;       ldur    x1, [x9, #0x60]
+;;       add     x1, x1, x0, uxtx
+;;       stur    d0, [x1]
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/store/i32.wat b/tests/disas/winch/aarch64/store/i32.wat
new file mode 100644
index 000000000000..37a3f6dceeec
--- /dev/null
+++ b/tests/disas/winch/aarch64/store/i32.wat
@@ -0,0 +1,29 @@
+;;! target = "aarch64"
+;;! test = "winch"
+(module
+  (memory 1)
+
+  (func (export "as-block-value")
+    (block (i32.store (i32.const 0) (i32.const 1)))
+  )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #1
+;;       mov     w0, w16
+;;       mov     x16, #0
+;;       mov     w1, w16
+;;       ldur    x2, [x9, #0x60]
+;;       add     x2, x2, x1, uxtx
+;;       stur    w0, [x2]
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/aarch64/store/i64.wat b/tests/disas/winch/aarch64/store/i64.wat
new file mode 100644
index 000000000000..ff968a2ba85f
--- /dev/null
+++ b/tests/disas/winch/aarch64/store/i64.wat
@@ -0,0 +1,25 @@
+;;! target = "aarch64"
+;;! test = "winch"
+(module
+  (memory 1)
+  (func (export "as-store-both") (result i32)
+    (block (result i32)
+      (i64.store (br 0 (i32.const 32))) (i32.const -1)
+    )
+  )
+)
+;; wasm[0]::function[0]:
+;;       stp     x29, x30, [sp, #-0x10]!
+;;       mov     x29, sp
+;;       mov     x28, sp
+;;       mov     x9, x0
+;;       sub     sp, sp, #0x10
+;;       mov     x28, sp
+;;       stur    x0, [x28, #8]
+;;       stur    x1, [x28]
+;;       mov     x16, #0x20
+;;       mov     w0, w16
+;;       add     sp, sp, #0x10
+;;       mov     x28, sp
+;;       ldp     x29, x30, [sp], #0x10
+;;       ret
diff --git a/tests/disas/winch/x64/block/as_if_cond.wat b/tests/disas/winch/x64/block/as_if_cond.wat
new file mode 100644
index 000000000000..7c1d774ee38d
--- /dev/null
+++ b/tests/disas/winch/x64/block/as_if_cond.wat
@@ -0,0 +1,50 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func $dummy)
+  (func (export "as-if-condition")
+   (block (result i32) (i32.const 1)) (if (then (call $dummy)))
+  )
+)
+  
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x8e
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       testl   %eax, %eax
+;;       je      0x88
+;;   78: movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   8e: ud2
diff --git a/tests/disas/winch/x64/block/as_if_else.wat b/tests/disas/winch/x64/block/as_if_else.wat
new file mode 100644
index 000000000000..de087f10898b
--- /dev/null
+++ b/tests/disas/winch/x64/block/as_if_else.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func (export "as-if-else") (result i32)
+      (if (result i32) (i32.const 1) (then (i32.const 2)) (else (block (result i32) (i32.const 1))))
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       testl   %eax, %eax
+;;       je      0x42
+;;   38: movl    $2, %eax
+;;       jmp     0x47
+;;   42: movl    $1, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4d: ud2
diff --git a/tests/disas/winch/x64/block/as_if_then.wat b/tests/disas/winch/x64/block/as_if_then.wat
new file mode 100644
index 000000000000..1bb6dd7a5626
--- /dev/null
+++ b/tests/disas/winch/x64/block/as_if_then.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+;;! test = "winch"
+ (module
+   (func (export "as-if-then") (result i32)
+      (if (result i32) (i32.const 1) (then (block (result i32) (i32.const 1))) (else (i32.const 2)))
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       testl   %eax, %eax
+;;       je      0x42
+;;   38: movl    $1, %eax
+;;       jmp     0x47
+;;   42: movl    $2, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4d: ud2
diff --git a/tests/disas/winch/x64/block/deep.wat b/tests/disas/winch/x64/block/deep.wat
new file mode 100644
index 000000000000..e578060aad6e
--- /dev/null
+++ b/tests/disas/winch/x64/block/deep.wat
@@ -0,0 +1,85 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func $dummy)
+  (func (export "deep") (result i32)
+    (block (result i32) (block (result i32)
+      (block (result i32) (block (result i32)
+        (block (result i32) (block (result i32)
+          (block (result i32) (block (result i32)
+            (block (result i32) (block (result i32)
+              (block (result i32) (block (result i32)
+                (block (result i32) (block (result i32)
+                  (block (result i32) (block (result i32)
+                    (block (result i32) (block (result i32)
+                      (block (result i32) (block (result i32)
+                        (block (result i32) (block (result i32)
+                          (block (result i32) (block (result i32)
+                            (block (result i32) (block (result i32)
+                              (block (result i32) (block (result i32)
+                                (block (result i32) (block (result i32)
+                                  (block (result i32) (block (result i32)
+                                    (block (result i32) (block (result i32)
+                                      (block (result i32) (block (result i32)
+                                        (block (result i32) (block (result i32)
+                                          (call $dummy) (i32.const 150)
+                                        ))
+                                      ))
+                                    ))
+                                  ))
+                                ))
+                              ))
+                            ))
+                          ))
+                        ))
+                      ))
+                    ))
+                  ))
+                ))
+              ))
+            ))
+          ))
+        ))
+      ))
+    ))
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x86
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       movl    $0x96, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   86: ud2
diff --git a/tests/disas/winch/x64/block/empty.wat b/tests/disas/winch/x64/block/empty.wat
new file mode 100644
index 000000000000..7730095b1681
--- /dev/null
+++ b/tests/disas/winch/x64/block/empty.wat
@@ -0,0 +1,44 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func $dummy)
+
+  (func (export "empty")
+    (block)
+    (block $l)
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x71
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   71: ud2
diff --git a/tests/disas/winch/x64/block/get_and_set.wat b/tests/disas/winch/x64/block/get_and_set.wat
new file mode 100644
index 000000000000..1f10e66a28c7
--- /dev/null
+++ b/tests/disas/winch/x64/block/get_and_set.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (export "") (param i32)
+    local.get 0
+    block
+    end
+    local.set 0
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x24, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %r11d
+;;       subq    $4, %rsp
+;;       movl    %r11d, (%rsp)
+;;       movl    (%rsp), %eax
+;;       addq    $4, %rsp
+;;       movl    %eax, 0xc(%rsp)
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4e: ud2
diff --git a/tests/disas/winch/x64/block/get_and_tee.wat b/tests/disas/winch/x64/block/get_and_tee.wat
new file mode 100644
index 000000000000..e5916c5c6d24
--- /dev/null
+++ b/tests/disas/winch/x64/block/get_and_tee.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (export "") (param i32) (result i32)
+    local.get 0
+    block
+    end
+    local.tee 0
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x24, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %r11d
+;;       subq    $4, %rsp
+;;       movl    %r11d, (%rsp)
+;;       movl    (%rsp), %eax
+;;       addq    $4, %rsp
+;;       movl    %eax, 0xc(%rsp)
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4e: ud2
diff --git a/tests/disas/winch/x64/block/nested.wat b/tests/disas/winch/x64/block/nested.wat
new file mode 100644
index 000000000000..4d97a9da5d40
--- /dev/null
+++ b/tests/disas/winch/x64/block/nested.wat
@@ -0,0 +1,54 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+
+  (func (export "nested") (result i32)
+    (block (result i32)
+      (block (call $dummy) (block) (nop))
+      (block (result i32) (call $dummy) (i32.const 9))
+    )
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x96
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       movl    $9, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   96: ud2
diff --git a/tests/disas/winch/x64/block/singular.wat b/tests/disas/winch/x64/block/singular.wat
new file mode 100644
index 000000000000..79187041b7c8
--- /dev/null
+++ b/tests/disas/winch/x64/block/singular.wat
@@ -0,0 +1,26 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (export "singular") (result i32)
+    (block (nop))
+    (block (result i32) (i32.const 7))
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x36
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $7, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   36: ud2
diff --git a/tests/disas/winch/x64/block/with_local_float.wat b/tests/disas/winch/x64/block/with_local_float.wat
new file mode 100644
index 000000000000..756e2a071ccf
--- /dev/null
+++ b/tests/disas/winch/x64/block/with_local_float.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (export "") (param f32) (result f32)
+    local.get 0
+    block
+    end
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x24, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x52
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0xc(%rsp), %xmm15
+;;       subq    $4, %rsp
+;;       movss   %xmm15, (%rsp)
+;;       movss   (%rsp), %xmm0
+;;       addq    $4, %rsp
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   52: ud2
diff --git a/tests/disas/winch/x64/br/as_block_first.wat b/tests/disas/winch/x64/br/as_block_first.wat
new file mode 100644
index 000000000000..ac9667ee1ccf
--- /dev/null
+++ b/tests/disas/winch/x64/br/as_block_first.wat
@@ -0,0 +1,42 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func $dummy)
+  (func (export "as-block-first")
+    (block (br 0) (call $dummy))
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x71
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   71: ud2
diff --git a/tests/disas/winch/x64/br/as_block_last.wat b/tests/disas/winch/x64/br/as_block_last.wat
new file mode 100644
index 000000000000..85c7aa243ced
--- /dev/null
+++ b/tests/disas/winch/x64/br/as_block_last.wat
@@ -0,0 +1,46 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func $dummy)
+  (func (export "as-block-last")
+    (block (nop) (call $dummy) (br 0))
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x81
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   81: ud2
diff --git a/tests/disas/winch/x64/br/as_block_mid.wat b/tests/disas/winch/x64/br/as_block_mid.wat
new file mode 100644
index 000000000000..8341c4852770
--- /dev/null
+++ b/tests/disas/winch/x64/br/as_block_mid.wat
@@ -0,0 +1,46 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func $dummy)
+  (func (export "as-block-mid")
+    (block (call $dummy) (br 0) (call $dummy))
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x81
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   81: ud2
diff --git a/tests/disas/winch/x64/br/as_block_value.wat b/tests/disas/winch/x64/br/as_block_value.wat
new file mode 100644
index 000000000000..6ae4818513e9
--- /dev/null
+++ b/tests/disas/winch/x64/br/as_block_value.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func $dummy)
+  (func (export "as-block-value") (result i32)
+    (block (result i32) (nop) (call $dummy) (br 0 (i32.const 2)))
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x86
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       movl    $2, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   86: ud2
diff --git a/tests/disas/winch/x64/br/as_br_if_cond.wat b/tests/disas/winch/x64/br/as_br_if_cond.wat
new file mode 100644
index 000000000000..7958e38d998a
--- /dev/null
+++ b/tests/disas/winch/x64/br/as_br_if_cond.wat
@@ -0,0 +1,23 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+    (func (export "as-br_if-cond")
+    (block (br_if 0 (br 0)))
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
diff --git a/tests/disas/winch/x64/br/as_br_value.wat b/tests/disas/winch/x64/br/as_br_value.wat
new file mode 100644
index 000000000000..1f5ac0bdd693
--- /dev/null
+++ b/tests/disas/winch/x64/br/as_br_value.wat
@@ -0,0 +1,24 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (br 0 (i32.const 9))))
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x36
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $9, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   36: ud2
diff --git a/tests/disas/winch/x64/br/as_call_all.wat b/tests/disas/winch/x64/br/as_call_all.wat
new file mode 100644
index 000000000000..b2305f66cf53
--- /dev/null
+++ b/tests/disas/winch/x64/br/as_call_all.wat
@@ -0,0 +1,46 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-all") (result i32)
+    (block (result i32) (call $f (br 0 (i32.const 15))))
+  )
+)
+;; wasm[0]::function[0]::f:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x44
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    %r8d, 4(%rsp)
+;;       movl    $0xffffffff, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   44: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x86
+;;   6b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0xf, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   86: ud2
diff --git a/tests/disas/winch/x64/br/as_call_first.wat b/tests/disas/winch/x64/br/as_call_first.wat
new file mode 100644
index 000000000000..ea2035e8f93d
--- /dev/null
+++ b/tests/disas/winch/x64/br/as_call_first.wat
@@ -0,0 +1,49 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (result i32)
+    (block (result i32)
+      (call $f (br 0 (i32.const 12)) (i32.const 2) (i32.const 3))
+    )
+  )
+)
+;; wasm[0]::function[0]::f:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x44
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    %r8d, 4(%rsp)
+;;       movl    $0xffffffff, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   44: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x86
+;;   6b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0xc, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   86: ud2
diff --git a/tests/disas/winch/x64/br/as_call_last.wat b/tests/disas/winch/x64/br/as_call_last.wat
new file mode 100644
index 000000000000..445f65c6db50
--- /dev/null
+++ b/tests/disas/winch/x64/br/as_call_last.wat
@@ -0,0 +1,48 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-last") (result i32)
+    (block (result i32)
+      (call $f (i32.const 1) (i32.const 2) (br 0 (i32.const 14)))
+    )
+  )
+)
+;; wasm[0]::function[0]::f:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x44
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    %r8d, 4(%rsp)
+;;       movl    $0xffffffff, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   44: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x86
+;;   6b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0xe, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   86: ud2
diff --git a/tests/disas/winch/x64/br/as_call_mid.wat b/tests/disas/winch/x64/br/as_call_mid.wat
new file mode 100644
index 000000000000..fdc019aa0e70
--- /dev/null
+++ b/tests/disas/winch/x64/br/as_call_mid.wat
@@ -0,0 +1,49 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-mid") (result i32)
+    (block (result i32)
+      (call $f (i32.const 1) (br 0 (i32.const 13)) (i32.const 3))
+    )
+  )
+)
+;; wasm[0]::function[0]::f:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x44
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    %r8d, 4(%rsp)
+;;       movl    $0xffffffff, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   44: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x86
+;;   6b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0xd, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   86: ud2
diff --git a/tests/disas/winch/x64/br/as_if_cond.wat b/tests/disas/winch/x64/br/as_if_cond.wat
new file mode 100644
index 000000000000..949479faab1e
--- /dev/null
+++ b/tests/disas/winch/x64/br/as_if_cond.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func (export "as-if-cond") (result i32)
+    (block (result i32)
+      (if (result i32) (br 0 (i32.const 2))
+        (then (i32.const 0))
+        (else (i32.const 1))
+      )
+    )
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x36
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $2, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   36: ud2
diff --git a/tests/disas/winch/x64/br/as_if_else.wat b/tests/disas/winch/x64/br/as_if_else.wat
new file mode 100644
index 000000000000..0e7fa3f48118
--- /dev/null
+++ b/tests/disas/winch/x64/br/as_if_else.wat
@@ -0,0 +1,36 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func (export "as-if-else") (param i32 i32) (result i32)
+    (block (result i32)
+      (if (result i32) (local.get 0)
+        (then (local.get 1))
+        (else (br 1 (i32.const 4)))
+      )
+    )
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x54
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       testl   %eax, %eax
+;;       je      0x49
+;;   40: movl    8(%rsp), %eax
+;;       jmp     0x4e
+;;   49: movl    $4, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   54: ud2
diff --git a/tests/disas/winch/x64/br/as_if_then.wat b/tests/disas/winch/x64/br/as_if_then.wat
new file mode 100644
index 000000000000..f560640d68df
--- /dev/null
+++ b/tests/disas/winch/x64/br/as_if_then.wat
@@ -0,0 +1,36 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func (export "as-if-then") (param i32 i32) (result i32)
+    (block (result i32)
+      (if (result i32) (local.get 0)
+        (then (br 1 (i32.const 3)))
+        (else (local.get 1))
+      )
+    )
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x54
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       testl   %eax, %eax
+;;       je      0x4a
+;;   40: movl    $3, %eax
+;;       jmp     0x4e
+;;   4a: movl    8(%rsp), %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   54: ud2
diff --git a/tests/disas/winch/x64/br/as_loop_first.wat b/tests/disas/winch/x64/br/as_loop_first.wat
new file mode 100644
index 000000000000..42f8813941c5
--- /dev/null
+++ b/tests/disas/winch/x64/br/as_loop_first.wat
@@ -0,0 +1,25 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (export "as-loop-first") (result i32)
+    (block (result i32) (loop (result i32) (br 1 (i32.const 3)) (i32.const 2)))
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x36
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $3, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   36: ud2
diff --git a/tests/disas/winch/x64/br/as_loop_last.wat b/tests/disas/winch/x64/br/as_loop_last.wat
new file mode 100644
index 000000000000..d8c08c3ee2f0
--- /dev/null
+++ b/tests/disas/winch/x64/br/as_loop_last.wat
@@ -0,0 +1,48 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "as-loop-last") (result i32)
+    (block (result i32)
+      (loop (result i32) (nop) (call $dummy) (br 1 (i32.const 5)))
+    )
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x86
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       movl    $5, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   86: ud2
diff --git a/tests/disas/winch/x64/br/as_loop_mid.wat b/tests/disas/winch/x64/br/as_loop_mid.wat
new file mode 100644
index 000000000000..12b0297c1e6f
--- /dev/null
+++ b/tests/disas/winch/x64/br/as_loop_mid.wat
@@ -0,0 +1,49 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func $dummy)
+  (func (export "as-loop-mid") (result i32)
+    (block (result i32)
+      (loop (result i32) (call $dummy) (br 1 (i32.const 4)) (i32.const 2))
+    )
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x86
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       movl    $4, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   86: ud2
diff --git a/tests/disas/winch/x64/br/br_jump.wat b/tests/disas/winch/x64/br/br_jump.wat
new file mode 100644
index 000000000000..7f0d65f81712
--- /dev/null
+++ b/tests/disas/winch/x64/br/br_jump.wat
@@ -0,0 +1,40 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func (;0;) (result i32)
+    (local i32)
+    local.get 0
+    loop ;; label = @1
+      local.get 0
+      block ;; label = @2
+      end
+      br 0 (;@1;)
+    end
+  )
+  (export "" (func 0))
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x28, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x5e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    0xc(%rsp), %r11d
+;;       subq    $4, %rsp
+;;       movl    %r11d, (%rsp)
+;;       movl    0x10(%rsp), %r11d
+;;       subq    $4, %rsp
+;;       movl    %r11d, (%rsp)
+;;       addq    $4, %rsp
+;;       jmp     0x42
+;;   58: addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   5e: ud2
diff --git a/tests/disas/winch/x64/br_if/as_block_last.wat b/tests/disas/winch/x64/br_if/as_block_last.wat
new file mode 100644
index 000000000000..5d303a48895c
--- /dev/null
+++ b/tests/disas/winch/x64/br_if/as_block_last.wat
@@ -0,0 +1,53 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "as-block-last") (param i32)
+    (block (call $dummy) (call $dummy) (br_if 0 (local.get 0)))
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0xa2
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    0x18(%rsp), %r14
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    0x18(%rsp), %r14
+;;       movl    0xc(%rsp), %eax
+;;       testl   %eax, %eax
+;;       jne     0x9c
+;;   9c: addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   a2: ud2
diff --git a/tests/disas/winch/x64/br_if/as_block_last_value.wat b/tests/disas/winch/x64/br_if/as_block_last_value.wat
new file mode 100644
index 000000000000..c03ccd48b3ba
--- /dev/null
+++ b/tests/disas/winch/x64/br_if/as_block_last_value.wat
@@ -0,0 +1,56 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "as-block-last-value") (param i32) (result i32)
+    (block (result i32)
+      (call $dummy) (call $dummy) (br_if 0 (i32.const 11) (local.get 0))
+    )
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0xa7
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    0x18(%rsp), %r14
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    0x18(%rsp), %r14
+;;       movl    0xc(%rsp), %ecx
+;;       movl    $0xb, %eax
+;;       testl   %ecx, %ecx
+;;       jne     0xa1
+;;   a1: addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   a7: ud2
diff --git a/tests/disas/winch/x64/br_if/as_br_if_cond.wat b/tests/disas/winch/x64/br_if/as_br_if_cond.wat
new file mode 100644
index 000000000000..5cfc25f8f896
--- /dev/null
+++ b/tests/disas/winch/x64/br_if/as_br_if_cond.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func (export "as-br-if-cond")
+    (block (br_if 0 (br_if 0 (i32.const 1) (i32.const 1))))
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4b
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       testl   %eax, %eax
+;;       jne     0x45
+;;   38: movl    $1, %eax
+;;       testl   %eax, %eax
+;;       jne     0x45
+;;   45: addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4b: ud2
diff --git a/tests/disas/winch/x64/br_if/as_br_value.wat b/tests/disas/winch/x64/br_if/as_br_value.wat
new file mode 100644
index 000000000000..98f263c72923
--- /dev/null
+++ b/tests/disas/winch/x64/br_if/as_br_value.wat
@@ -0,0 +1,27 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (br_if 0 (i32.const 1) (i32.const 2))))
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x43
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $2, %ecx
+;;       movl    $1, %eax
+;;       testl   %ecx, %ecx
+;;       jne     0x3d
+;;   3d: addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   43: ud2
diff --git a/tests/disas/winch/x64/br_if/as_call_first.wat b/tests/disas/winch/x64/br_if/as_call_first.wat
new file mode 100644
index 000000000000..1278b2ff05ce
--- /dev/null
+++ b/tests/disas/winch/x64/br_if/as_call_first.wat
@@ -0,0 +1,65 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (result i32)
+    (block (result i32)
+      (call $f
+        (br_if 0 (i32.const 12) (i32.const 1)) (i32.const 2) (i32.const 3)
+      )
+    )
+  )
+)
+;; wasm[0]::function[0]::f:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x44
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    %r8d, 4(%rsp)
+;;       movl    $0xffffffff, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   44: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0xc5
+;;   6b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %ecx
+;;       movl    $0xc, %eax
+;;       testl   %ecx, %ecx
+;;       jne     0xbf
+;;   8d: subq    $4, %rsp
+;;       movl    %eax, (%rsp)
+;;       subq    $0xc, %rsp
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       movl    0xc(%rsp), %edx
+;;       movl    $2, %ecx
+;;       movl    $3, %r8d
+;;       callq   0
+;;       addq    $0xc, %rsp
+;;       addq    $4, %rsp
+;;       movq    8(%rsp), %r14
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   c5: ud2
diff --git a/tests/disas/winch/x64/br_if/as_call_last.wat b/tests/disas/winch/x64/br_if/as_call_last.wat
new file mode 100644
index 000000000000..a28b592c270e
--- /dev/null
+++ b/tests/disas/winch/x64/br_if/as_call_last.wat
@@ -0,0 +1,65 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-last") (result i32)
+    (block (result i32)
+      (call $f
+        (i32.const 1) (i32.const 2) (br_if 0 (i32.const 14) (i32.const 1))
+      )
+    )
+  )
+)
+;; wasm[0]::function[0]::f:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x44
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    %r8d, 4(%rsp)
+;;       movl    $0xffffffff, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   44: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0xc5
+;;   6b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %ecx
+;;       movl    $0xe, %eax
+;;       testl   %ecx, %ecx
+;;       jne     0xbf
+;;   8d: subq    $4, %rsp
+;;       movl    %eax, (%rsp)
+;;       subq    $0xc, %rsp
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       movl    $1, %edx
+;;       movl    $2, %ecx
+;;       movl    0xc(%rsp), %r8d
+;;       callq   0
+;;       addq    $0xc, %rsp
+;;       addq    $4, %rsp
+;;       movq    8(%rsp), %r14
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   c5: ud2
diff --git a/tests/disas/winch/x64/br_if/as_call_mid.wat b/tests/disas/winch/x64/br_if/as_call_mid.wat
new file mode 100644
index 000000000000..ffc1cf196d49
--- /dev/null
+++ b/tests/disas/winch/x64/br_if/as_call_mid.wat
@@ -0,0 +1,65 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $f (param i32 i32 i32) (result i32) (i32.const -1)) 
+  (func (export "as-call-mid") (result i32)
+    (block (result i32)
+      (call $f
+        (i32.const 1) (br_if 0 (i32.const 13) (i32.const 1)) (i32.const 3)
+      )
+    )
+  )
+)
+;; wasm[0]::function[0]::f:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x44
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    %r8d, 4(%rsp)
+;;       movl    $0xffffffff, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   44: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0xc5
+;;   6b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %ecx
+;;       movl    $0xd, %eax
+;;       testl   %ecx, %ecx
+;;       jne     0xbf
+;;   8d: subq    $4, %rsp
+;;       movl    %eax, (%rsp)
+;;       subq    $0xc, %rsp
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       movl    $1, %edx
+;;       movl    0xc(%rsp), %ecx
+;;       movl    $3, %r8d
+;;       callq   0
+;;       addq    $0xc, %rsp
+;;       addq    $4, %rsp
+;;       movq    8(%rsp), %r14
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   c5: ud2
diff --git a/tests/disas/winch/x64/br_if/as_if_cond.wat b/tests/disas/winch/x64/br_if/as_if_cond.wat
new file mode 100644
index 000000000000..065c88022728
--- /dev/null
+++ b/tests/disas/winch/x64/br_if/as_if_cond.wat
@@ -0,0 +1,39 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func (export "as-if-cond") (param i32) (result i32)
+    (block (result i32)
+      (if (result i32)
+        (br_if 0 (i32.const 1) (local.get 0))
+        (then (i32.const 2))
+        (else (i32.const 3))
+      )
+    )
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x5e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %ecx
+;;       movl    $1, %eax
+;;       testl   %ecx, %ecx
+;;       jne     0x58
+;;   41: testl   %eax, %eax
+;;       je      0x53
+;;   49: movl    $2, %eax
+;;       jmp     0x58
+;;   53: movl    $3, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   5e: ud2
diff --git a/tests/disas/winch/x64/br_if/as_if_else.wat b/tests/disas/winch/x64/br_if/as_if_else.wat
new file mode 100644
index 000000000000..046dff66a8b7
--- /dev/null
+++ b/tests/disas/winch/x64/br_if/as_if_else.wat
@@ -0,0 +1,57 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "as-if-else") (param i32 i32)
+    (block
+      (if (local.get 0) (then (call $dummy)) (else (br_if 1 (local.get 1))))
+    )
+  )
+)
+
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0xa7
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       testl   %eax, %eax
+;;       je      0x95
+;;   80: movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    0x18(%rsp), %r14
+;;       jmp     0xa1
+;;   95: movl    8(%rsp), %eax
+;;       testl   %eax, %eax
+;;       jne     0xa1
+;;   a1: addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   a7: ud2
diff --git a/tests/disas/winch/x64/br_if/as_if_then.wat b/tests/disas/winch/x64/br_if/as_if_then.wat
new file mode 100644
index 000000000000..d5cf269e9c8e
--- /dev/null
+++ b/tests/disas/winch/x64/br_if/as_if_then.wat
@@ -0,0 +1,56 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "as-if-then") (param i32 i32)
+    (block
+      (if (local.get 0) (then (br_if 1 (local.get 1))) (else (call $dummy)))
+    )
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0xa7
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       testl   %eax, %eax
+;;       je      0x91
+;;   80: movl    8(%rsp), %eax
+;;       testl   %eax, %eax
+;;       jne     0xa1
+;;       jmp     0xa1
+;;   91: movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    0x18(%rsp), %r14
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   a7: ud2
diff --git a/tests/disas/winch/x64/br_if/as_local_set_value.wat b/tests/disas/winch/x64/br_if/as_local_set_value.wat
new file mode 100644
index 000000000000..f64a2337c411
--- /dev/null
+++ b/tests/disas/winch/x64/br_if/as_local_set_value.wat
@@ -0,0 +1,36 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func (export "as-local-set-value") (param i32) (result i32)
+    (local i32)
+    (block (result i32)
+      (local.set 0 (br_if 0 (i32.const 17) (local.get 0)))
+      (i32.const -1)
+    )
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x5b
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    $0, 8(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movl    0xc(%rsp), %ecx
+;;       movl    $0x11, %eax
+;;       testl   %ecx, %ecx
+;;       jne     0x55
+;;   4c: movl    %eax, 0xc(%rsp)
+;;       movl    $0xffffffff, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   5b: ud2
diff --git a/tests/disas/winch/x64/br_if/as_loop_last.wat b/tests/disas/winch/x64/br_if/as_loop_last.wat
new file mode 100644
index 000000000000..974f86397c79
--- /dev/null
+++ b/tests/disas/winch/x64/br_if/as_loop_last.wat
@@ -0,0 +1,49 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "as-loop-last") (param i32)
+    (loop (call $dummy) (br_if 1 (local.get 0)))
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x92
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    0x18(%rsp), %r14
+;;       movl    0xc(%rsp), %eax
+;;       testl   %eax, %eax
+;;       jne     0x8c
+;;   8c: addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   92: ud2
diff --git a/tests/disas/winch/x64/br_if/save_state_before_br_emission.wat b/tests/disas/winch/x64/br_if/save_state_before_br_emission.wat
new file mode 100644
index 000000000000..cc697f0bc052
--- /dev/null
+++ b/tests/disas/winch/x64/br_if/save_state_before_br_emission.wat
@@ -0,0 +1,103 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func (param f64 f64 f64 f64) (result f32 f64)
+    f64.const 0
+    local.get 0
+    i64.const 0
+    f64.const 0
+    i64.const 0
+    local.get 0
+    f64.const 0
+    i64.const 1
+    i32.const 1
+    i64.const 1
+    f32.const 0
+    local.get 0
+
+    i32.const 0
+    br_if 0
+
+    drop
+    drop
+    drop
+    drop
+    drop
+    drop
+    i64.reinterpret_f64
+    i64.const 0
+    i64.xor
+    drop
+    drop
+    drop
+    drop
+    drop
+    drop
+    f32.const 0
+    f64.const 0
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x58, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x106
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x40, %rsp
+;;       movq    %rdi, 0x38(%rsp)
+;;       movq    %rsi, 0x30(%rsp)
+;;       movsd   %xmm0, 0x28(%rsp)
+;;       movsd   %xmm1, 0x20(%rsp)
+;;       movsd   %xmm2, 0x18(%rsp)
+;;       movsd   %xmm3, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movl    $0, %eax
+;;       movsd   0x28(%rsp), %xmm15
+;;       subq    $8, %rsp
+;;       movsd   %xmm15, (%rsp)
+;;       movsd   0x30(%rsp), %xmm15
+;;       subq    $8, %rsp
+;;       movsd   %xmm15, (%rsp)
+;;       movsd   0x38(%rsp), %xmm15
+;;       subq    $8, %rsp
+;;       movsd   %xmm15, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       addq    $8, %rsp
+;;       subq    $4, %rsp
+;;       movss   0x71(%rip), %xmm15
+;;       movss   %xmm15, (%rsp)
+;;       testl   %eax, %eax
+;;       je      0xb7
+;;   a5: movl    (%rsp), %r11d
+;;       movl    %r11d, 0x10(%rsp)
+;;       addq    $0x10, %rsp
+;;       jmp     0xec
+;;   b7: addq    $4, %rsp
+;;       movsd   (%rsp), %xmm0
+;;       addq    $8, %rsp
+;;       movq    %xmm0, %rax
+;;       xorq    $0, %rax
+;;       addq    $8, %rsp
+;;       movsd   0x37(%rip), %xmm0
+;;       subq    $4, %rsp
+;;       movss   0x22(%rip), %xmm15
+;;       movss   %xmm15, (%rsp)
+;;       movq    0xc(%rsp), %rax
+;;       movss   (%rsp), %xmm15
+;;       addq    $4, %rsp
+;;       movss   %xmm15, (%rax)
+;;       addq    $0x40, %rsp
+;;       popq    %rbp
+;;       retq
+;;  106: ud2
+;;  108: addb    %al, (%rax)
+;;  10a: addb    %al, (%rax)
+;;  10c: addb    %al, (%rax)
+;;  10e: addb    %al, (%rax)
+;;  110: addb    %al, (%rax)
+;;  112: addb    %al, (%rax)
+;;  114: addb    %al, (%rax)
+;;  116: addb    %al, (%rax)
diff --git a/tests/disas/winch/x64/br_if/with_machine_stack_entry.wat b/tests/disas/winch/x64/br_if/with_machine_stack_entry.wat
new file mode 100644
index 000000000000..b5b22dd2c821
--- /dev/null
+++ b/tests/disas/winch/x64/br_if/with_machine_stack_entry.wat
@@ -0,0 +1,65 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (export "") 
+    call 1
+    call 1
+    br_if 0
+    drop
+  )
+  (func (;1;) (result i32)
+    i32.const 1
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x75
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0x80
+;;       movq    8(%rsp), %r14
+;;       subq    $4, %rsp
+;;       movl    %eax, (%rsp)
+;;       subq    $0xc, %rsp
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0x80
+;;       addq    $0xc, %rsp
+;;       movq    0xc(%rsp), %r14
+;;       testl   %eax, %eax
+;;       je      0x6b
+;;   62: addq    $4, %rsp
+;;       jmp     0x6f
+;;   6b: addq    $4, %rsp
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   75: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0xb6
+;;   9b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   b6: ud2
diff --git a/tests/disas/winch/x64/br_table/ensure_sp_state.wat b/tests/disas/winch/x64/br_table/ensure_sp_state.wat
new file mode 100644
index 000000000000..d374bda122c0
--- /dev/null
+++ b/tests/disas/winch/x64/br_table/ensure_sp_state.wat
@@ -0,0 +1,44 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (export "") (result i32)
+    block (result i32)
+       i32.const 0
+    end
+    i32.const 0
+    i32.const 0
+    br_table 0
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x14, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0, %eax
+;;       subq    $4, %rsp
+;;       movl    %eax, (%rsp)
+;;       movl    $0, %ecx
+;;       movl    $0, %eax
+;;       movl    $0, %edx
+;;       cmpl    %ecx, %edx
+;;       cmovbl  %edx, %ecx
+;;       leaq    0xa(%rip), %r11
+;;       movslq  (%r11, %rcx, 4), %rdx
+;;       addq    %rdx, %r11
+;;       jmpq    *%r11
+;;   5c: addb    $0, %al
+;;       addb    %al, (%rax)
+;;       addq    $4, %rsp
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6a: ud2
diff --git a/tests/disas/winch/x64/br_table/large.wat b/tests/disas/winch/x64/br_table/large.wat
new file mode 100644
index 000000000000..02e9f6f7e8ff
--- /dev/null
+++ b/tests/disas/winch/x64/br_table/large.wat
@@ -0,0 +1,25384 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func (export "large") (param i32) (result i32)
+    (block
+      (block
+        (br_table
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
+          (local.get 0)
+        )
+        (return (i32.const -1))
+      )
+      (return (i32.const 0))
+    )
+    (return (i32.const 1))
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x18104
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       movl    $0x6027, %ecx
+;;       cmpl    %eax, %ecx
+;;       cmovbl  %ecx, %eax
+;;       leaq    0xa(%rip), %r11
+;;       movslq  (%r11, %rax, 4), %rcx
+;;       addq    %rcx, %r11
+;;       jmpq    *%r11
+;;   4f: movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movabsb 0xa0000180aa000180, %al
+;;       addb    $0, (%rcx)
+;;       stosb   %al, (%rdi)
+;;       addb    $0, (%rcx)
+;;       movl    $0, %eax
+;;       jmp     0x180fe
+;; 180f9: movl    $1, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;; 18104: ud2
diff --git a/tests/disas/winch/x64/br_table/nested_br_table_loop_block.wat b/tests/disas/winch/x64/br_table/nested_br_table_loop_block.wat
new file mode 100644
index 000000000000..caaf54ac23fa
--- /dev/null
+++ b/tests/disas/winch/x64/br_table/nested_br_table_loop_block.wat
@@ -0,0 +1,42 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func (export "nested-br_table-loop-block") (param i32) (result i32)
+    (local.set 0
+      (loop (result i32)
+        (block
+          (br_table 1 0 0 (local.get 0))
+        )
+        (i32.const 0)
+      )
+    )
+    (loop (result i32)
+      (block
+        (br_table 0 1 1 (local.get 0))
+      )
+      (i32.const 3)
+    )
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x9f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       movl    $2, %ecx
+;;       cmpl    %eax, %ecx
+;;       cmovbl  %ecx, %eax
+;;       leaq    0xa(%rip), %r11
+;;       movslq  (%r11, %rax, 4), %rcx
+;;       addq    %rcx, %r11
+;;       jmpq    *%r11
+;;   4f: loope   0x50
diff --git a/tests/disas/winch/x64/br_table/stack_handling.wat b/tests/disas/winch/x64/br_table/stack_handling.wat
new file mode 100644
index 000000000000..e19371a72434
--- /dev/null
+++ b/tests/disas/winch/x64/br_table/stack_handling.wat
@@ -0,0 +1,51 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func (;0;) (param i32)
+    local.get 0
+    block ;; label = @1
+      i32.const 808727609
+      br_table 0 (;@1;) 1 (;@0;) 0 (;@1;)
+    end
+    drop
+  )
+  (export "main" (func 0))
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x24, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x81
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %r11d
+;;       subq    $4, %rsp
+;;       movl    %r11d, (%rsp)
+;;       movl    $0x30343439, %eax
+;;       movl    $2, %ecx
+;;       cmpl    %eax, %ecx
+;;       cmovbl  %ecx, %eax
+;;       leaq    0xa(%rip), %r11
+;;       movslq  (%r11, %rax, 4), %rcx
+;;       addq    %rcx, %r11
+;;       jmpq    *%r11
+;;   5d: sbbb    (%rax), %al
+;;       addb    %al, (%rax)
+;;       adcl    %eax, (%rax)
+;;       addb    %al, (%rax)
+;;       sbbb    (%rax), %al
+;;       addb    %al, (%rax)
+;;       jmp     0x77
+;;   6e: addq    $4, %rsp
+;;       jmp     0x7b
+;;   77: addq    $4, %rsp
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   81: ud2
diff --git a/tests/disas/winch/x64/call/params.wat b/tests/disas/winch/x64/call/params.wat
new file mode 100644
index 000000000000..81c0d7eae258
--- /dev/null
+++ b/tests/disas/winch/x64/call/params.wat
@@ -0,0 +1,159 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (export "main") (param i32) (param i32) (result i32)
+    (local.get 1)
+    (local.get 0)
+    (i32.div_u)
+
+    (call $add (i32.const 1) (i32.const 2) (i32.const 3) (i32.const 4) (i32.const 5) (i32.const 6) (i32.const 7) (i32.const 8))
+
+    (local.get 1)
+    (local.get 0)
+    (i32.div_u)
+
+    (call $add (i32.const 2) (i32.const 3) (i32.const 4) (i32.const 5) (i32.const 6) (i32.const 7) (i32.const 8))
+  )
+
+  (func $add (param i32 i32 i32 i32 i32 i32 i32 i32 i32) (result i32)
+    (local.get 0)
+    (local.get 1)
+    (i32.add)
+    (local.get 2)
+    (i32.add)
+    (local.get 3)
+    (i32.add)
+    (local.get 4)
+    (i32.add)
+    (local.get 5)
+    (i32.add)
+    (local.get 6)
+    (i32.add)
+    (local.get 7)
+    (i32.add)
+    (local.get 8)
+    (i32.add)
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x60, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x154
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    0xc(%rsp), %ecx
+;;       movl    8(%rsp), %eax
+;;       xorl    %edx, %edx
+;;       divl    %ecx
+;;       subq    $4, %rsp
+;;       movl    %eax, (%rsp)
+;;       subq    $0x3c, %rsp
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       movl    0x3c(%rsp), %edx
+;;       movl    $1, %ecx
+;;       movl    $2, %r8d
+;;       movl    $3, %r9d
+;;       movl    $4, %r11d
+;;       movl    %r11d, (%rsp)
+;;       movl    $5, %r11d
+;;       movl    %r11d, 8(%rsp)
+;;       movl    $6, %r11d
+;;       movl    %r11d, 0x10(%rsp)
+;;       movl    $7, %r11d
+;;       movl    %r11d, 0x18(%rsp)
+;;       movl    $8, %r11d
+;;       movl    %r11d, 0x20(%rsp)
+;;       callq   0x160
+;;       addq    $0x3c, %rsp
+;;       addq    $4, %rsp
+;;       movq    0x18(%rsp), %r14
+;;       subq    $4, %rsp
+;;       movl    %eax, (%rsp)
+;;       movl    0xc(%rsp), %r11d
+;;       subq    $4, %rsp
+;;       movl    %r11d, (%rsp)
+;;       movl    0x14(%rsp), %r11d
+;;       subq    $4, %rsp
+;;       movl    %r11d, (%rsp)
+;;       movl    (%rsp), %ecx
+;;       addq    $4, %rsp
+;;       movl    (%rsp), %eax
+;;       addq    $4, %rsp
+;;       xorl    %edx, %edx
+;;       divl    %ecx
+;;       subq    $4, %rsp
+;;       movl    %eax, (%rsp)
+;;       subq    $0x38, %rsp
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       movl    0x3c(%rsp), %edx
+;;       movl    0x38(%rsp), %ecx
+;;       movl    $2, %r8d
+;;       movl    $3, %r9d
+;;       movl    $4, %r11d
+;;       movl    %r11d, (%rsp)
+;;       movl    $5, %r11d
+;;       movl    %r11d, 8(%rsp)
+;;       movl    $6, %r11d
+;;       movl    %r11d, 0x10(%rsp)
+;;       movl    $7, %r11d
+;;       movl    %r11d, 0x18(%rsp)
+;;       movl    $8, %r11d
+;;       movl    %r11d, 0x20(%rsp)
+;;       callq   0x160
+;;       addq    $0x38, %rsp
+;;       addq    $8, %rsp
+;;       movq    0x18(%rsp), %r14
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;  154: ud2
+;;
+;; wasm[0]::function[1]::add:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x1d3
+;;  17b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    %r8d, 4(%rsp)
+;;       movl    %r9d, (%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       addl    %eax, %ecx
+;;       movl    4(%rsp), %eax
+;;       addl    %eax, %ecx
+;;       movl    (%rsp), %eax
+;;       addl    %eax, %ecx
+;;       movl    0x10(%rbp), %eax
+;;       addl    %eax, %ecx
+;;       movl    0x18(%rbp), %eax
+;;       addl    %eax, %ecx
+;;       movl    0x20(%rbp), %eax
+;;       addl    %eax, %ecx
+;;       movl    0x28(%rbp), %eax
+;;       addl    %eax, %ecx
+;;       movl    0x30(%rbp), %eax
+;;       addl    %eax, %ecx
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;  1d3: ud2
diff --git a/tests/disas/winch/x64/call/recursive.wat b/tests/disas/winch/x64/call/recursive.wat
new file mode 100644
index 000000000000..fe036b2893ff
--- /dev/null
+++ b/tests/disas/winch/x64/call/recursive.wat
@@ -0,0 +1,80 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func $fibonacci8 (param $n i32) (result i32)
+    (if (result i32) (i32.le_s (local.get $n) (i32.const 1))
+      (then
+        ;; If n <= 1, return n (base case)
+        (local.get $n)
+      )
+      (else
+        ;; Else, return fibonacci(n - 1) + fibonacci(n - 2)
+        (i32.add
+          (call $fibonacci8
+            (i32.sub (local.get $n) (i32.const 1)) ;; Calculate n - 1
+          )
+          (call $fibonacci8
+            (i32.sub (local.get $n) (i32.const 2)) ;; Calculate n - 2
+          )
+        )
+      )
+    )
+  )
+  (export "fib" (func $fibonacci8))
+)
+;; wasm[0]::function[0]::fibonacci8:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x30, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0xc5
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       cmpl    $1, %eax
+;;       movl    $0, %eax
+;;       setle   %al
+;;       testl   %eax, %eax
+;;       je      0x51
+;;   48: movl    0xc(%rsp), %eax
+;;       jmp     0xbf
+;;   51: movl    0xc(%rsp), %eax
+;;       subl    $1, %eax
+;;       subq    $4, %rsp
+;;       movl    %eax, (%rsp)
+;;       subq    $0xc, %rsp
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       movl    0xc(%rsp), %edx
+;;       callq   0
+;;       addq    $0xc, %rsp
+;;       addq    $4, %rsp
+;;       movq    0x18(%rsp), %r14
+;;       movl    0xc(%rsp), %ecx
+;;       subl    $2, %ecx
+;;       subq    $4, %rsp
+;;       movl    %eax, (%rsp)
+;;       subq    $4, %rsp
+;;       movl    %ecx, (%rsp)
+;;       subq    $8, %rsp
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       movl    8(%rsp), %edx
+;;       callq   0
+;;       addq    $8, %rsp
+;;       addq    $4, %rsp
+;;       movq    0x1c(%rsp), %r14
+;;       movl    (%rsp), %ecx
+;;       addq    $4, %rsp
+;;       addl    %eax, %ecx
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   c5: ud2
diff --git a/tests/disas/winch/x64/call/reg_on_stack.wat b/tests/disas/winch/x64/call/reg_on_stack.wat
new file mode 100644
index 000000000000..292dc2150b9a
--- /dev/null
+++ b/tests/disas/winch/x64/call/reg_on_stack.wat
@@ -0,0 +1,60 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func (export "") (param i32) (result i32)
+    local.get 0
+    i32.const 1
+    call 0
+    i32.const 1
+    call 0
+    br_if 0 (;@0;)
+    unreachable
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x30, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0xac
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %r11d
+;;       subq    $4, %rsp
+;;       movl    %r11d, (%rsp)
+;;       subq    $0xc, %rsp
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       movl    $1, %edx
+;;       callq   0
+;;       addq    $0xc, %rsp
+;;       movq    0x1c(%rsp), %r14
+;;       subq    $4, %rsp
+;;       movl    %eax, (%rsp)
+;;       subq    $8, %rsp
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       movl    $1, %edx
+;;       callq   0
+;;       addq    $8, %rsp
+;;       movq    0x20(%rsp), %r14
+;;       subq    $4, %rsp
+;;       movl    %eax, (%rsp)
+;;       movl    (%rsp), %ecx
+;;       addq    $4, %rsp
+;;       movl    (%rsp), %eax
+;;       addq    $4, %rsp
+;;       testl   %ecx, %ecx
+;;       je      0xa4
+;;   9b: addq    $4, %rsp
+;;       jmp     0xa6
+;;   a4: ud2
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   ac: ud2
diff --git a/tests/disas/winch/x64/call/simple.wat b/tests/disas/winch/x64/call/simple.wat
new file mode 100644
index 000000000000..f09932bd2ce0
--- /dev/null
+++ b/tests/disas/winch/x64/call/simple.wat
@@ -0,0 +1,75 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func $main (result i32)
+    (local $var i32)
+    (call $product (i32.const 20) (i32.const 80))
+    (local.set $var (i32.const 2))
+    (local.get $var)
+    (i32.div_u))
+
+  (func $product (param i32 i32) (result i32)
+    (local.get 0)
+    (local.get 1)
+    (i32.mul))
+)
+;; wasm[0]::function[0]::main:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x28, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x84
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       movl    $0x14, %edx
+;;       movl    $0x50, %ecx
+;;       callq   0x90
+;;       movq    0x18(%rsp), %r14
+;;       movl    $2, %ecx
+;;       movl    %ecx, 0xc(%rsp)
+;;       subq    $4, %rsp
+;;       movl    %eax, (%rsp)
+;;       movl    0x10(%rsp), %r11d
+;;       subq    $4, %rsp
+;;       movl    %r11d, (%rsp)
+;;       movl    (%rsp), %ecx
+;;       addq    $4, %rsp
+;;       movl    (%rsp), %eax
+;;       addq    $4, %rsp
+;;       xorl    %edx, %edx
+;;       divl    %ecx
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   84: ud2
+;;
+;; wasm[0]::function[1]::product:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0xd7
+;;   ab: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       imull   %eax, %ecx
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   d7: ud2
diff --git a/tests/disas/winch/x64/call_indirect/call_indirect.wat b/tests/disas/winch/x64/call_indirect/call_indirect.wat
new file mode 100644
index 000000000000..56dd4208cd1d
--- /dev/null
+++ b/tests/disas/winch/x64/call_indirect/call_indirect.wat
@@ -0,0 +1,169 @@
+;;! target="x86_64"
+;;! test = "winch"
+
+(module
+  (type $over-i32 (func (param i32) (result i32)))
+
+  (table funcref
+    (elem
+      $fib-i32
+    )
+  )
+
+  (func $fib-i32 (export "fib-i32") (type $over-i32)
+    (if (result i32) (i32.le_u (local.get 0) (i32.const 1))
+      (then (i32.const 1))
+      (else
+        (i32.add
+          (call_indirect (type $over-i32)
+            (i32.sub (local.get 0) (i32.const 2))
+            (i32.const 0)
+          )
+          (call_indirect (type $over-i32)
+            (i32.sub (local.get 0) (i32.const 1))
+            (i32.const 0)
+          )
+        )
+      )
+    )
+  )
+)
+
+
+;; wasm[0]::function[0]::fib-i32:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x30, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x1da
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       cmpl    $1, %eax
+;;       movl    $0, %eax
+;;       setbe   %al
+;;       testl   %eax, %eax
+;;       je      0x52
+;;   48: movl    $1, %eax
+;;       jmp     0x1d4
+;;   52: movl    0xc(%rsp), %eax
+;;       subl    $2, %eax
+;;       subq    $4, %rsp
+;;       movl    %eax, (%rsp)
+;;       movl    $0, %ecx
+;;       movq    %r14, %rdx
+;;       movl    0x60(%rdx), %ebx
+;;       cmpl    %ebx, %ecx
+;;       jae     0x1dc
+;;   73: movl    %ecx, %r11d
+;;       imulq   $8, %r11, %r11
+;;       movq    0x58(%rdx), %rdx
+;;       movq    %rdx, %rsi
+;;       addq    %r11, %rdx
+;;       cmpl    %ebx, %ecx
+;;       cmovaeq %rsi, %rdx
+;;       movq    (%rdx), %rax
+;;       testq   %rax, %rax
+;;       jne     0xc4
+;;   96: subq    $4, %rsp
+;;       movl    %ecx, (%rsp)
+;;       subq    $8, %rsp
+;;       movq    %r14, %rdi
+;;       movl    $0, %esi
+;;       movl    8(%rsp), %edx
+;;       callq   0x2ef
+;;       addq    $8, %rsp
+;;       addq    $4, %rsp
+;;       movq    0x1c(%rsp), %r14
+;;       jmp     0xc8
+;;   c4: andq    $0xfffffffffffffffe, %rax
+;;       testq   %rax, %rax
+;;       je      0x1de
+;;   d1: movq    0x50(%r14), %r11
+;;       movl    (%r11), %ecx
+;;       movl    0x10(%rax), %edx
+;;       cmpl    %edx, %ecx
+;;       jne     0x1e0
+;;   e3: pushq   %rax
+;;       popq    %rcx
+;;       movq    0x18(%rcx), %r8
+;;       movq    8(%rcx), %rbx
+;;       subq    $0xc, %rsp
+;;       movq    %r8, %rdi
+;;       movq    %r14, %rsi
+;;       movl    0xc(%rsp), %edx
+;;       callq   *%rbx
+;;       addq    $0xc, %rsp
+;;       addq    $4, %rsp
+;;       movq    0x18(%rsp), %r14
+;;       movl    0xc(%rsp), %ecx
+;;       subl    $1, %ecx
+;;       subq    $4, %rsp
+;;       movl    %eax, (%rsp)
+;;       subq    $4, %rsp
+;;       movl    %ecx, (%rsp)
+;;       movl    $0, %ecx
+;;       movq    %r14, %rdx
+;;       movl    0x60(%rdx), %ebx
+;;       cmpl    %ebx, %ecx
+;;       jae     0x1e2
+;;  132: movl    %ecx, %r11d
+;;       imulq   $8, %r11, %r11
+;;       movq    0x58(%rdx), %rdx
+;;       movq    %rdx, %rsi
+;;       addq    %r11, %rdx
+;;       cmpl    %ebx, %ecx
+;;       cmovaeq %rsi, %rdx
+;;       movq    (%rdx), %rax
+;;       testq   %rax, %rax
+;;       jne     0x183
+;;  155: subq    $4, %rsp
+;;       movl    %ecx, (%rsp)
+;;       subq    $4, %rsp
+;;       movq    %r14, %rdi
+;;       movl    $0, %esi
+;;       movl    4(%rsp), %edx
+;;       callq   0x2ef
+;;       addq    $4, %rsp
+;;       addq    $4, %rsp
+;;       movq    0x20(%rsp), %r14
+;;       jmp     0x187
+;;  183: andq    $0xfffffffffffffffe, %rax
+;;       testq   %rax, %rax
+;;       je      0x1e4
+;;  190: movq    0x50(%r14), %r11
+;;       movl    (%r11), %ecx
+;;       movl    0x10(%rax), %edx
+;;       cmpl    %edx, %ecx
+;;       jne     0x1e6
+;;  1a2: pushq   %rax
+;;       popq    %rcx
+;;       movq    0x18(%rcx), %r8
+;;       movq    8(%rcx), %rbx
+;;       subq    $8, %rsp
+;;       movq    %r8, %rdi
+;;       movq    %r14, %rsi
+;;       movl    8(%rsp), %edx
+;;       callq   *%rbx
+;;       addq    $8, %rsp
+;;       addq    $4, %rsp
+;;       movq    0x1c(%rsp), %r14
+;;       movl    (%rsp), %ecx
+;;       addq    $4, %rsp
+;;       addl    %eax, %ecx
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;  1da: ud2
+;;  1dc: ud2
+;;  1de: ud2
+;;  1e0: ud2
+;;  1e2: ud2
+;;  1e4: ud2
+;;  1e6: ud2
diff --git a/tests/disas/winch/x64/call_indirect/local_arg.wat b/tests/disas/winch/x64/call_indirect/local_arg.wat
new file mode 100644
index 000000000000..c90cd6dd26d2
--- /dev/null
+++ b/tests/disas/winch/x64/call_indirect/local_arg.wat
@@ -0,0 +1,104 @@
+;;! target="x86_64"
+;;! test = "winch"
+
+(module
+    (type $param-i32 (func (param i32)))
+
+    (func $param-i32 (type $param-i32))
+    (func (export "")
+        (local i32)
+        local.get 0
+        (call_indirect (type $param-i32) (i32.const 0))
+    )
+
+    (table funcref
+      (elem
+        $param-i32)
+    )
+)
+
+;; wasm[0]::function[0]::param-i32:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x36
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   36: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x30, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x130
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    0xc(%rsp), %r11d
+;;       subq    $4, %rsp
+;;       movl    %r11d, (%rsp)
+;;       movl    $0, %ecx
+;;       movq    %r14, %rdx
+;;       movl    0x60(%rdx), %ebx
+;;       cmpl    %ebx, %ecx
+;;       jae     0x132
+;;   95: movl    %ecx, %r11d
+;;       imulq   $8, %r11, %r11
+;;       movq    0x58(%rdx), %rdx
+;;       movq    %rdx, %rsi
+;;       addq    %r11, %rdx
+;;       cmpl    %ebx, %ecx
+;;       cmovaeq %rsi, %rdx
+;;       movq    (%rdx), %rax
+;;       testq   %rax, %rax
+;;       jne     0xe6
+;;   b8: subq    $4, %rsp
+;;       movl    %ecx, (%rsp)
+;;       subq    $8, %rsp
+;;       movq    %r14, %rdi
+;;       movl    $0, %esi
+;;       movl    8(%rsp), %edx
+;;       callq   0x30d
+;;       addq    $8, %rsp
+;;       addq    $4, %rsp
+;;       movq    0x1c(%rsp), %r14
+;;       jmp     0xea
+;;   e6: andq    $0xfffffffffffffffe, %rax
+;;       testq   %rax, %rax
+;;       je      0x134
+;;   f3: movq    0x50(%r14), %r11
+;;       movl    (%r11), %ecx
+;;       movl    0x10(%rax), %edx
+;;       cmpl    %edx, %ecx
+;;       jne     0x136
+;;  105: movq    0x18(%rax), %rbx
+;;       movq    8(%rax), %rcx
+;;       subq    $0xc, %rsp
+;;       movq    %rbx, %rdi
+;;       movq    %r14, %rsi
+;;       movl    0xc(%rsp), %edx
+;;       callq   *%rcx
+;;       addq    $0xc, %rsp
+;;       addq    $4, %rsp
+;;       movq    0x18(%rsp), %r14
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;  130: ud2
+;;  132: ud2
+;;  134: ud2
+;;  136: ud2
diff --git a/tests/disas/winch/x64/f32_abs/f32_abs_const.wat b/tests/disas/winch/x64/f32_abs/f32_abs_const.wat
new file mode 100644
index 000000000000..7574456ab55a
--- /dev/null
+++ b/tests/disas/winch/x64/f32_abs/f32_abs_const.wat
@@ -0,0 +1,35 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (f32.const -1.32)
+        (f32.abs)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x48
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movss   0x1d(%rip), %xmm0
+;;       movl    $0x7fffffff, %r11d
+;;       movd    %r11d, %xmm15
+;;       andps   %xmm15, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   48: ud2
+;;   4a: addb    %al, (%rax)
+;;   4c: addb    %al, (%rax)
+;;   4e: addb    %al, (%rax)
+;;   50: retq
+;;   51: cmc
+;;   52: testb   $0xbf, %al
diff --git a/tests/disas/winch/x64/f32_abs/f32_abs_param.wat b/tests/disas/winch/x64/f32_abs/f32_abs_param.wat
new file mode 100644
index 000000000000..248a9a923a1f
--- /dev/null
+++ b/tests/disas/winch/x64/f32_abs/f32_abs_param.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (result f32)
+        (local.get 0)
+        (f32.abs)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0xc(%rsp), %xmm0
+;;       movl    $0x7fffffff, %r11d
+;;       movd    %r11d, %xmm15
+;;       andps   %xmm15, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4d: ud2
diff --git a/tests/disas/winch/x64/f32_add/const.wat b/tests/disas/winch/x64/f32_add/const.wat
new file mode 100644
index 000000000000..5d66c86a9d19
--- /dev/null
+++ b/tests/disas/winch/x64/f32_add/const.wat
@@ -0,0 +1,38 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (f32.const 1.1)
+        (f32.const 2.2)
+        (f32.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x48
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movss   0x1d(%rip), %xmm0
+;;       movss   0x1d(%rip), %xmm1
+;;       addss   %xmm0, %xmm1
+;;       movaps  %xmm1, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   48: ud2
+;;   4a: addb    %al, (%rax)
+;;   4c: addb    %al, (%rax)
+;;   4e: addb    %al, (%rax)
+;;   50: int     $0xcc
+;;   52: orb     $0x40, %al
+;;   54: addb    %al, (%rax)
+;;   56: addb    %al, (%rax)
+;;   58: int     $0xcc
diff --git a/tests/disas/winch/x64/f32_add/locals.wat b/tests/disas/winch/x64/f32_add/locals.wat
new file mode 100644
index 000000000000..ba6b8e236db0
--- /dev/null
+++ b/tests/disas/winch/x64/f32_add/locals.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (local $foo f32)  
+        (local $bar f32)
+
+        (f32.const 1.1)
+        (local.set $foo)
+
+        (f32.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f32.add
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movss   0x33(%rip), %xmm0
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0x2d(%rip), %xmm0
+;;       movss   %xmm0, 8(%rsp)
+;;       movss   8(%rsp), %xmm0
+;;       movss   0xc(%rsp), %xmm1
+;;       addss   %xmm0, %xmm1
+;;       movaps  %xmm1, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6a: ud2
+;;   6c: addb    %al, (%rax)
+;;   6e: addb    %al, (%rax)
+;;   70: int     $0xcc
diff --git a/tests/disas/winch/x64/f32_add/params.wat b/tests/disas/winch/x64/f32_add/params.wat
new file mode 100644
index 000000000000..84f649bb8571
--- /dev/null
+++ b/tests/disas/winch/x64/f32_add/params.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (param f32) (result f32)
+        (local.get 0)
+        (local.get 1)
+        (f32.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x51
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   %xmm1, 8(%rsp)
+;;       movss   8(%rsp), %xmm0
+;;       movss   0xc(%rsp), %xmm1
+;;       addss   %xmm0, %xmm1
+;;       movaps  %xmm1, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   51: ud2
diff --git a/tests/disas/winch/x64/f32_ceil/f32_ceil_const_sse41.wat b/tests/disas/winch/x64/f32_ceil/f32_ceil_const_sse41.wat
new file mode 100644
index 000000000000..36d5ac39fd9b
--- /dev/null
+++ b/tests/disas/winch/x64/f32_ceil/f32_ceil_const_sse41.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_sse41"]
+
+(module
+    (func (result f32)
+        (f32.const -1.32)
+        (f32.ceil)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movss   0x15(%rip), %xmm0
+;;       roundss $2, %xmm0, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3f: ud2
+;;   41: addb    %al, (%rax)
+;;   43: addb    %al, (%rax)
+;;   45: addb    %al, (%rax)
+;;   47: addb    %al, %bl
+;;   49: cmc
+;;   4a: testb   $0xbf, %al
diff --git a/tests/disas/winch/x64/f32_ceil/f32_ceil_param.wat b/tests/disas/winch/x64/f32_ceil/f32_ceil_param.wat
new file mode 100644
index 000000000000..adbe1e2f1de5
--- /dev/null
+++ b/tests/disas/winch/x64/f32_ceil/f32_ceil_param.wat
@@ -0,0 +1,36 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (result f32)
+        (local.get 0)
+        (f32.ceil)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x30, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0xc(%rsp), %xmm15
+;;       subq    $4, %rsp
+;;       movss   %xmm15, (%rsp)
+;;       subq    $0xc, %rsp
+;;       movss   0xc(%rsp), %xmm0
+;;       movabsq $0, %r11
+;;       callq   *%r11
+;;       addq    $0xc, %rsp
+;;       addq    $4, %rsp
+;;       movq    0x18(%rsp), %r14
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6d: ud2
diff --git a/tests/disas/winch/x64/f32_ceil/f32_ceil_param_sse41.wat b/tests/disas/winch/x64/f32_ceil/f32_ceil_param_sse41.wat
new file mode 100644
index 000000000000..cc7def0f9c76
--- /dev/null
+++ b/tests/disas/winch/x64/f32_ceil/f32_ceil_param_sse41.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_sse41"]
+
+(module
+    (func (param f32) (result f32)
+        (local.get 0)
+        (f32.ceil)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x44
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0xc(%rsp), %xmm0
+;;       roundss $2, %xmm0, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   44: ud2
diff --git a/tests/disas/winch/x64/f32_const/call_id.wat b/tests/disas/winch/x64/f32_const/call_id.wat
new file mode 100644
index 000000000000..d4860d96681e
--- /dev/null
+++ b/tests/disas/winch/x64/f32_const/call_id.wat
@@ -0,0 +1,52 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func $id-f32 (param f32) (result f32) (local.get 0))
+  (func (export "type-first-f32") (result f32) (call $id-f32 (f32.const 1.32)))
+)
+;; wasm[0]::function[0]::id-f32:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0xc(%rsp), %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3e: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x89
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       movss   0x17(%rip), %xmm0
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   89: ud2
+;;   8b: addb    %al, (%rax)
+;;   8d: addb    %al, (%rax)
+;;   8f: addb    %al, %bl
+;;   91: cmc
+;;   92: testb   $0x3f, %al
diff --git a/tests/disas/winch/x64/f32_const/id.wat b/tests/disas/winch/x64/f32_const/id.wat
new file mode 100644
index 000000000000..6f06eb6f9b97
--- /dev/null
+++ b/tests/disas/winch/x64/f32_const/id.wat
@@ -0,0 +1,24 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (param f32) (result f32) (local.get 0))
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0xc(%rsp), %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3e: ud2
diff --git a/tests/disas/winch/x64/f32_convert_i32_s/const.wat b/tests/disas/winch/x64/f32_convert_i32_s/const.wat
new file mode 100644
index 000000000000..3eff1cd92d7b
--- /dev/null
+++ b/tests/disas/winch/x64/f32_convert_i32_s/const.wat
@@ -0,0 +1,27 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (i32.const 1)
+        (f32.convert_i32_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       cvtsi2ssl %eax, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3a: ud2
diff --git a/tests/disas/winch/x64/f32_convert_i32_s/locals.wat b/tests/disas/winch/x64/f32_convert_i32_s/locals.wat
new file mode 100644
index 000000000000..f7aced3fdf6a
--- /dev/null
+++ b/tests/disas/winch/x64/f32_convert_i32_s/locals.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (local i32)  
+
+        (local.get 0)
+        (f32.convert_i32_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x43
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       cvtsi2ssl %eax, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   43: ud2
diff --git a/tests/disas/winch/x64/f32_convert_i32_s/params.wat b/tests/disas/winch/x64/f32_convert_i32_s/params.wat
new file mode 100644
index 000000000000..65ed0fe7908e
--- /dev/null
+++ b/tests/disas/winch/x64/f32_convert_i32_s/params.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (result f32)
+        (local.get 0)
+        (f32.convert_i32_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       cvtsi2ssl %eax, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3e: ud2
diff --git a/tests/disas/winch/x64/f32_convert_i32_s/spilled.wat b/tests/disas/winch/x64/f32_convert_i32_s/spilled.wat
new file mode 100644
index 000000000000..3ce343d45f5f
--- /dev/null
+++ b/tests/disas/winch/x64/f32_convert_i32_s/spilled.wat
@@ -0,0 +1,33 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        i32.const 1
+        f32.convert_i32_s
+        block
+        end
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x14, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       cvtsi2ssl %eax, %xmm0
+;;       subq    $4, %rsp
+;;       movss   %xmm0, (%rsp)
+;;       movss   (%rsp), %xmm0
+;;       addq    $4, %rsp
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4c: ud2
diff --git a/tests/disas/winch/x64/f32_convert_i32_u/const.wat b/tests/disas/winch/x64/f32_convert_i32_u/const.wat
new file mode 100644
index 000000000000..f855665d3511
--- /dev/null
+++ b/tests/disas/winch/x64/f32_convert_i32_u/const.wat
@@ -0,0 +1,38 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (i32.const 1)
+        (f32.convert_i32_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x66
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %ecx
+;;       movl    %ecx, %ecx
+;;       cmpq    $0, %rcx
+;;       jl      0x46
+;;   3c: cvtsi2ssq %rcx, %xmm0
+;;       jmp     0x60
+;;   46: movq    %rcx, %r11
+;;       shrq    $1, %r11
+;;       movq    %rcx, %rax
+;;       andq    $1, %rax
+;;       orq     %r11, %rax
+;;       cvtsi2ssq %rax, %xmm0
+;;       addss   %xmm0, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   66: ud2
diff --git a/tests/disas/winch/x64/f32_convert_i32_u/locals.wat b/tests/disas/winch/x64/f32_convert_i32_u/locals.wat
new file mode 100644
index 000000000000..abcac7f12738
--- /dev/null
+++ b/tests/disas/winch/x64/f32_convert_i32_u/locals.wat
@@ -0,0 +1,41 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (local i32)  
+
+        (local.get 0)
+        (f32.convert_i32_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    0xc(%rsp), %ecx
+;;       movl    %ecx, %ecx
+;;       cmpq    $0, %rcx
+;;       jl      0x4f
+;;   45: cvtsi2ssq %rcx, %xmm0
+;;       jmp     0x69
+;;   4f: movq    %rcx, %r11
+;;       shrq    $1, %r11
+;;       movq    %rcx, %rax
+;;       andq    $1, %rax
+;;       orq     %r11, %rax
+;;       cvtsi2ssq %rax, %xmm0
+;;       addss   %xmm0, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6f: ud2
diff --git a/tests/disas/winch/x64/f32_convert_i32_u/params.wat b/tests/disas/winch/x64/f32_convert_i32_u/params.wat
new file mode 100644
index 000000000000..2bba922bdada
--- /dev/null
+++ b/tests/disas/winch/x64/f32_convert_i32_u/params.wat
@@ -0,0 +1,39 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (result f32)
+        (local.get 0)
+        (f32.convert_i32_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %ecx
+;;       movl    %ecx, %ecx
+;;       cmpq    $0, %rcx
+;;       jl      0x4a
+;;   40: cvtsi2ssq %rcx, %xmm0
+;;       jmp     0x64
+;;   4a: movq    %rcx, %r11
+;;       shrq    $1, %r11
+;;       movq    %rcx, %rax
+;;       andq    $1, %rax
+;;       orq     %r11, %rax
+;;       cvtsi2ssq %rax, %xmm0
+;;       addss   %xmm0, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6a: ud2
diff --git a/tests/disas/winch/x64/f32_convert_i32_u/spilled.wat b/tests/disas/winch/x64/f32_convert_i32_u/spilled.wat
new file mode 100644
index 000000000000..852c676471d8
--- /dev/null
+++ b/tests/disas/winch/x64/f32_convert_i32_u/spilled.wat
@@ -0,0 +1,44 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        i32.const 1
+        f32.convert_i32_u
+        block
+        end
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x14, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x78
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %ecx
+;;       movl    %ecx, %ecx
+;;       cmpq    $0, %rcx
+;;       jl      0x46
+;;   3c: cvtsi2ssq %rcx, %xmm0
+;;       jmp     0x60
+;;   46: movq    %rcx, %r11
+;;       shrq    $1, %r11
+;;       movq    %rcx, %rax
+;;       andq    $1, %rax
+;;       orq     %r11, %rax
+;;       cvtsi2ssq %rax, %xmm0
+;;       addss   %xmm0, %xmm0
+;;       subq    $4, %rsp
+;;       movss   %xmm0, (%rsp)
+;;       movss   (%rsp), %xmm0
+;;       addq    $4, %rsp
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   78: ud2
diff --git a/tests/disas/winch/x64/f32_convert_i64_s/const.wat b/tests/disas/winch/x64/f32_convert_i64_s/const.wat
new file mode 100644
index 000000000000..81b343697997
--- /dev/null
+++ b/tests/disas/winch/x64/f32_convert_i64_s/const.wat
@@ -0,0 +1,27 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (i64.const 1)
+        (f32.convert_i64_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       cvtsi2ssq %rax, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3d: ud2
diff --git a/tests/disas/winch/x64/f32_convert_i64_s/locals.wat b/tests/disas/winch/x64/f32_convert_i64_s/locals.wat
new file mode 100644
index 000000000000..bac36127b9dc
--- /dev/null
+++ b/tests/disas/winch/x64/f32_convert_i64_s/locals.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (local i64)  
+
+        (local.get 0)
+        (f32.convert_i64_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x45
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movq    8(%rsp), %rax
+;;       cvtsi2ssq %rax, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   45: ud2
diff --git a/tests/disas/winch/x64/f32_convert_i64_s/params.wat b/tests/disas/winch/x64/f32_convert_i64_s/params.wat
new file mode 100644
index 000000000000..46dd131aa727
--- /dev/null
+++ b/tests/disas/winch/x64/f32_convert_i64_s/params.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (result f32)
+        (local.get 0)
+        (f32.convert_i64_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x41
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    8(%rsp), %rax
+;;       cvtsi2ssq %rax, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   41: ud2
diff --git a/tests/disas/winch/x64/f32_convert_i64_s/spilled.wat b/tests/disas/winch/x64/f32_convert_i64_s/spilled.wat
new file mode 100644
index 000000000000..eb0724673711
--- /dev/null
+++ b/tests/disas/winch/x64/f32_convert_i64_s/spilled.wat
@@ -0,0 +1,33 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        i64.const 1
+        f32.convert_i64_s
+        block
+        end
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x14, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       cvtsi2ssq %rax, %xmm0
+;;       subq    $4, %rsp
+;;       movss   %xmm0, (%rsp)
+;;       movss   (%rsp), %xmm0
+;;       addq    $4, %rsp
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4f: ud2
diff --git a/tests/disas/winch/x64/f32_convert_i64_u/const.wat b/tests/disas/winch/x64/f32_convert_i64_u/const.wat
new file mode 100644
index 000000000000..2a8dd69d0bd6
--- /dev/null
+++ b/tests/disas/winch/x64/f32_convert_i64_u/const.wat
@@ -0,0 +1,37 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (i64.const 1)
+        (f32.convert_i64_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x66
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rcx
+;;       cmpq    $0, %rcx
+;;       jl      0x46
+;;   3c: cvtsi2ssq %rcx, %xmm0
+;;       jmp     0x60
+;;   46: movq    %rcx, %r11
+;;       shrq    $1, %r11
+;;       movq    %rcx, %rax
+;;       andq    $1, %rax
+;;       orq     %r11, %rax
+;;       cvtsi2ssq %rax, %xmm0
+;;       addss   %xmm0, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   66: ud2
diff --git a/tests/disas/winch/x64/f32_convert_i64_u/locals.wat b/tests/disas/winch/x64/f32_convert_i64_u/locals.wat
new file mode 100644
index 000000000000..d840164e6815
--- /dev/null
+++ b/tests/disas/winch/x64/f32_convert_i64_u/locals.wat
@@ -0,0 +1,40 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (local i64)  
+
+        (local.get 0)
+        (f32.convert_i64_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movq    8(%rsp), %rcx
+;;       cmpq    $0, %rcx
+;;       jl      0x4e
+;;   44: cvtsi2ssq %rcx, %xmm0
+;;       jmp     0x68
+;;   4e: movq    %rcx, %r11
+;;       shrq    $1, %r11
+;;       movq    %rcx, %rax
+;;       andq    $1, %rax
+;;       orq     %r11, %rax
+;;       cvtsi2ssq %rax, %xmm0
+;;       addss   %xmm0, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6e: ud2
diff --git a/tests/disas/winch/x64/f32_convert_i64_u/params.wat b/tests/disas/winch/x64/f32_convert_i64_u/params.wat
new file mode 100644
index 000000000000..0ebf2b4d950f
--- /dev/null
+++ b/tests/disas/winch/x64/f32_convert_i64_u/params.wat
@@ -0,0 +1,38 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (result f32)
+        (local.get 0)
+        (f32.convert_i64_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    8(%rsp), %rcx
+;;       cmpq    $0, %rcx
+;;       jl      0x4a
+;;   40: cvtsi2ssq %rcx, %xmm0
+;;       jmp     0x64
+;;   4a: movq    %rcx, %r11
+;;       shrq    $1, %r11
+;;       movq    %rcx, %rax
+;;       andq    $1, %rax
+;;       orq     %r11, %rax
+;;       cvtsi2ssq %rax, %xmm0
+;;       addss   %xmm0, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6a: ud2
diff --git a/tests/disas/winch/x64/f32_convert_i64_u/spilled.wat b/tests/disas/winch/x64/f32_convert_i64_u/spilled.wat
new file mode 100644
index 000000000000..7478de710715
--- /dev/null
+++ b/tests/disas/winch/x64/f32_convert_i64_u/spilled.wat
@@ -0,0 +1,43 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        i64.const 1
+        f32.convert_i64_u
+        block
+        end
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x14, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x78
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rcx
+;;       cmpq    $0, %rcx
+;;       jl      0x46
+;;   3c: cvtsi2ssq %rcx, %xmm0
+;;       jmp     0x60
+;;   46: movq    %rcx, %r11
+;;       shrq    $1, %r11
+;;       movq    %rcx, %rax
+;;       andq    $1, %rax
+;;       orq     %r11, %rax
+;;       cvtsi2ssq %rax, %xmm0
+;;       addss   %xmm0, %xmm0
+;;       subq    $4, %rsp
+;;       movss   %xmm0, (%rsp)
+;;       movss   (%rsp), %xmm0
+;;       addq    $4, %rsp
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   78: ud2
diff --git a/tests/disas/winch/x64/f32_copysign/const.wat b/tests/disas/winch/x64/f32_copysign/const.wat
new file mode 100644
index 000000000000..e81daece1218
--- /dev/null
+++ b/tests/disas/winch/x64/f32_copysign/const.wat
@@ -0,0 +1,40 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (f32.const -1.1)
+        (f32.const 2.2)
+        (f32.copysign)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x5e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movss   0x2d(%rip), %xmm0
+;;       movss   0x2d(%rip), %xmm1
+;;       movl    $0x80000000, %r11d
+;;       movd    %r11d, %xmm15
+;;       andps   %xmm15, %xmm0
+;;       andnps  %xmm1, %xmm15
+;;       movaps  %xmm15, %xmm1
+;;       orps    %xmm0, %xmm1
+;;       movaps  %xmm1, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   5e: ud2
+;;   60: int     $0xcc
+;;   62: orb     $0x40, %al
+;;   64: addb    %al, (%rax)
+;;   66: addb    %al, (%rax)
+;;   68: int     $0xcc
diff --git a/tests/disas/winch/x64/f32_copysign/locals.wat b/tests/disas/winch/x64/f32_copysign/locals.wat
new file mode 100644
index 000000000000..e7780e909202
--- /dev/null
+++ b/tests/disas/winch/x64/f32_copysign/locals.wat
@@ -0,0 +1,53 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (local $foo f32)  
+        (local $bar f32)
+
+        (f32.const -1.1)
+        (local.set $foo)
+
+        (f32.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f32.copysign
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x80
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movss   0x4b(%rip), %xmm0
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0x45(%rip), %xmm0
+;;       movss   %xmm0, 8(%rsp)
+;;       movss   8(%rsp), %xmm0
+;;       movss   0xc(%rsp), %xmm1
+;;       movl    $0x80000000, %r11d
+;;       movd    %r11d, %xmm15
+;;       andps   %xmm15, %xmm0
+;;       andnps  %xmm1, %xmm15
+;;       movaps  %xmm15, %xmm1
+;;       orps    %xmm0, %xmm1
+;;       movaps  %xmm1, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   80: ud2
+;;   82: addb    %al, (%rax)
+;;   84: addb    %al, (%rax)
+;;   86: addb    %al, (%rax)
+;;   88: int     $0xcc
diff --git a/tests/disas/winch/x64/f32_copysign/params.wat b/tests/disas/winch/x64/f32_copysign/params.wat
new file mode 100644
index 000000000000..c8fddff3a5ba
--- /dev/null
+++ b/tests/disas/winch/x64/f32_copysign/params.wat
@@ -0,0 +1,37 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (param f32) (result f32)
+        (local.get 0)
+        (local.get 1)
+        (f32.copysign)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x67
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   %xmm1, 8(%rsp)
+;;       movss   8(%rsp), %xmm0
+;;       movss   0xc(%rsp), %xmm1
+;;       movl    $0x80000000, %r11d
+;;       movd    %r11d, %xmm15
+;;       andps   %xmm15, %xmm0
+;;       andnps  %xmm1, %xmm15
+;;       movaps  %xmm15, %xmm1
+;;       orps    %xmm0, %xmm1
+;;       movaps  %xmm1, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   67: ud2
diff --git a/tests/disas/winch/x64/f32_demote_f64/const.wat b/tests/disas/winch/x64/f32_demote_f64/const.wat
new file mode 100644
index 000000000000..85c223f56601
--- /dev/null
+++ b/tests/disas/winch/x64/f32_demote_f64/const.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (f64.const 1.0)
+        (f32.demote_f64)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movsd   0xd(%rip), %xmm0
+;;       cvtsd2ss %xmm0, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3d: ud2
+;;   3f: addb    %al, (%rax)
+;;   41: addb    %al, (%rax)
+;;   43: addb    %al, (%rax)
+;;   45: addb    %dh, %al
diff --git a/tests/disas/winch/x64/f32_demote_f64/locals.wat b/tests/disas/winch/x64/f32_demote_f64/locals.wat
new file mode 100644
index 000000000000..b79a4e2581a2
--- /dev/null
+++ b/tests/disas/winch/x64/f32_demote_f64/locals.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (local f64)  
+
+        (local.get 0)
+        (f32.demote_f64)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x45
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movsd   8(%rsp), %xmm0
+;;       cvtsd2ss %xmm0, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   45: ud2
diff --git a/tests/disas/winch/x64/f32_demote_f64/params.wat b/tests/disas/winch/x64/f32_demote_f64/params.wat
new file mode 100644
index 000000000000..dbb08cd030cc
--- /dev/null
+++ b/tests/disas/winch/x64/f32_demote_f64/params.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (result f32)
+        (local.get 0)
+        (f32.demote_f64)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x42
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   8(%rsp), %xmm0
+;;       cvtsd2ss %xmm0, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   42: ud2
diff --git a/tests/disas/winch/x64/f32_demote_f64/spilled.wat b/tests/disas/winch/x64/f32_demote_f64/spilled.wat
new file mode 100644
index 000000000000..7268afdc8f56
--- /dev/null
+++ b/tests/disas/winch/x64/f32_demote_f64/spilled.wat
@@ -0,0 +1,40 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        f64.const 1.0
+        f32.demote_f64
+        block
+        end
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x14, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movsd   0x25(%rip), %xmm0
+;;       cvtsd2ss %xmm0, %xmm0
+;;       subq    $4, %rsp
+;;       movss   %xmm0, (%rsp)
+;;       movss   (%rsp), %xmm0
+;;       addq    $4, %rsp
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4f: ud2
+;;   51: addb    %al, (%rax)
+;;   53: addb    %al, (%rax)
+;;   55: addb    %al, (%rax)
+;;   57: addb    %al, (%rax)
+;;   59: addb    %al, (%rax)
+;;   5b: addb    %al, (%rax)
+;;   5d: addb    %dh, %al
diff --git a/tests/disas/winch/x64/f32_div/const.wat b/tests/disas/winch/x64/f32_div/const.wat
new file mode 100644
index 000000000000..d3924d71e20b
--- /dev/null
+++ b/tests/disas/winch/x64/f32_div/const.wat
@@ -0,0 +1,38 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (f32.const 1.1)
+        (f32.const 2.2)
+        (f32.div)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x48
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movss   0x1d(%rip), %xmm0
+;;       movss   0x1d(%rip), %xmm1
+;;       divss   %xmm0, %xmm1
+;;       movaps  %xmm1, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   48: ud2
+;;   4a: addb    %al, (%rax)
+;;   4c: addb    %al, (%rax)
+;;   4e: addb    %al, (%rax)
+;;   50: int     $0xcc
+;;   52: orb     $0x40, %al
+;;   54: addb    %al, (%rax)
+;;   56: addb    %al, (%rax)
+;;   58: int     $0xcc
diff --git a/tests/disas/winch/x64/f32_div/locals.wat b/tests/disas/winch/x64/f32_div/locals.wat
new file mode 100644
index 000000000000..b91dcdf4a093
--- /dev/null
+++ b/tests/disas/winch/x64/f32_div/locals.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (local $foo f32)  
+        (local $bar f32)
+
+        (f32.const 1.1)
+        (local.set $foo)
+
+        (f32.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f32.div
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movss   0x33(%rip), %xmm0
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0x2d(%rip), %xmm0
+;;       movss   %xmm0, 8(%rsp)
+;;       movss   8(%rsp), %xmm0
+;;       movss   0xc(%rsp), %xmm1
+;;       divss   %xmm0, %xmm1
+;;       movaps  %xmm1, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6a: ud2
+;;   6c: addb    %al, (%rax)
+;;   6e: addb    %al, (%rax)
+;;   70: int     $0xcc
diff --git a/tests/disas/winch/x64/f32_div/params.wat b/tests/disas/winch/x64/f32_div/params.wat
new file mode 100644
index 000000000000..47a15524e359
--- /dev/null
+++ b/tests/disas/winch/x64/f32_div/params.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (param f32) (result f32)
+        (local.get 0)
+        (local.get 1)
+        (f32.div)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x51
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   %xmm1, 8(%rsp)
+;;       movss   8(%rsp), %xmm0
+;;       movss   0xc(%rsp), %xmm1
+;;       divss   %xmm0, %xmm1
+;;       movaps  %xmm1, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   51: ud2
diff --git a/tests/disas/winch/x64/f32_eq/const.wat b/tests/disas/winch/x64/f32_eq/const.wat
new file mode 100644
index 000000000000..4fd4603688d2
--- /dev/null
+++ b/tests/disas/winch/x64/f32_eq/const.wat
@@ -0,0 +1,41 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (f32.const 1.1)
+        (f32.const 2.2)
+        (f32.eq)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x5a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movss   0x2d(%rip), %xmm0
+;;       movss   0x2d(%rip), %xmm1
+;;       ucomiss %xmm0, %xmm1
+;;       movl    $0, %eax
+;;       sete    %al
+;;       movl    $0, %r11d
+;;       setnp   %r11b
+;;       andl    %r11d, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   5a: ud2
+;;   5c: addb    %al, (%rax)
+;;   5e: addb    %al, (%rax)
+;;   60: int     $0xcc
+;;   62: orb     $0x40, %al
+;;   64: addb    %al, (%rax)
+;;   66: addb    %al, (%rax)
+;;   68: int     $0xcc
diff --git a/tests/disas/winch/x64/f32_eq/locals.wat b/tests/disas/winch/x64/f32_eq/locals.wat
new file mode 100644
index 000000000000..27c208ed97ec
--- /dev/null
+++ b/tests/disas/winch/x64/f32_eq/locals.wat
@@ -0,0 +1,50 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo f32)  
+        (local $bar f32)
+
+        (f32.const 1.1)
+        (local.set $foo)
+
+        (f32.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f32.eq
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x7c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movss   0x43(%rip), %xmm0
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0x3d(%rip), %xmm0
+;;       movss   %xmm0, 8(%rsp)
+;;       movss   8(%rsp), %xmm0
+;;       movss   0xc(%rsp), %xmm1
+;;       ucomiss %xmm0, %xmm1
+;;       movl    $0, %eax
+;;       sete    %al
+;;       movl    $0, %r11d
+;;       setnp   %r11b
+;;       andl    %r11d, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   7c: ud2
+;;   7e: addb    %al, (%rax)
+;;   80: int     $0xcc
diff --git a/tests/disas/winch/x64/f32_eq/params.wat b/tests/disas/winch/x64/f32_eq/params.wat
new file mode 100644
index 000000000000..76cad6a17c69
--- /dev/null
+++ b/tests/disas/winch/x64/f32_eq/params.wat
@@ -0,0 +1,36 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (param f32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (f32.eq)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x63
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   %xmm1, 8(%rsp)
+;;       movss   8(%rsp), %xmm0
+;;       movss   0xc(%rsp), %xmm1
+;;       ucomiss %xmm0, %xmm1
+;;       movl    $0, %eax
+;;       sete    %al
+;;       movl    $0, %r11d
+;;       setnp   %r11b
+;;       andl    %r11d, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   63: ud2
diff --git a/tests/disas/winch/x64/f32_floor/f32_floor_const_sse41.wat b/tests/disas/winch/x64/f32_floor/f32_floor_const_sse41.wat
new file mode 100644
index 000000000000..b14fbaf320a5
--- /dev/null
+++ b/tests/disas/winch/x64/f32_floor/f32_floor_const_sse41.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_sse41"]
+
+(module
+    (func (result f32)
+        (f32.const -1.32)
+        (f32.floor)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movss   0x15(%rip), %xmm0
+;;       roundss $1, %xmm0, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3f: ud2
+;;   41: addb    %al, (%rax)
+;;   43: addb    %al, (%rax)
+;;   45: addb    %al, (%rax)
+;;   47: addb    %al, %bl
+;;   49: cmc
+;;   4a: testb   $0xbf, %al
diff --git a/tests/disas/winch/x64/f32_floor/f32_floor_param.wat b/tests/disas/winch/x64/f32_floor/f32_floor_param.wat
new file mode 100644
index 000000000000..05336bd42b18
--- /dev/null
+++ b/tests/disas/winch/x64/f32_floor/f32_floor_param.wat
@@ -0,0 +1,36 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (result f32)
+        (local.get 0)
+        (f32.floor)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x30, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0xc(%rsp), %xmm15
+;;       subq    $4, %rsp
+;;       movss   %xmm15, (%rsp)
+;;       subq    $0xc, %rsp
+;;       movss   0xc(%rsp), %xmm0
+;;       movabsq $0, %r11
+;;       callq   *%r11
+;;       addq    $0xc, %rsp
+;;       addq    $4, %rsp
+;;       movq    0x18(%rsp), %r14
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6d: ud2
diff --git a/tests/disas/winch/x64/f32_floor/f32_floor_param_sse41.wat b/tests/disas/winch/x64/f32_floor/f32_floor_param_sse41.wat
new file mode 100644
index 000000000000..ff7507cb5e92
--- /dev/null
+++ b/tests/disas/winch/x64/f32_floor/f32_floor_param_sse41.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_sse41"]
+
+(module
+    (func (param f32) (result f32)
+        (local.get 0)
+        (f32.floor)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x44
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0xc(%rsp), %xmm0
+;;       roundss $1, %xmm0, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   44: ud2
diff --git a/tests/disas/winch/x64/f32_ge/const.wat b/tests/disas/winch/x64/f32_ge/const.wat
new file mode 100644
index 000000000000..5c6649845bf6
--- /dev/null
+++ b/tests/disas/winch/x64/f32_ge/const.wat
@@ -0,0 +1,41 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (f32.const 1.1)
+        (f32.const 2.2)
+        (f32.ge)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x5a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movss   0x2d(%rip), %xmm0
+;;       movss   0x2d(%rip), %xmm1
+;;       ucomiss %xmm0, %xmm1
+;;       movl    $0, %eax
+;;       setae   %al
+;;       movl    $0, %r11d
+;;       setnp   %r11b
+;;       andl    %r11d, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   5a: ud2
+;;   5c: addb    %al, (%rax)
+;;   5e: addb    %al, (%rax)
+;;   60: int     $0xcc
+;;   62: orb     $0x40, %al
+;;   64: addb    %al, (%rax)
+;;   66: addb    %al, (%rax)
+;;   68: int     $0xcc
diff --git a/tests/disas/winch/x64/f32_ge/locals.wat b/tests/disas/winch/x64/f32_ge/locals.wat
new file mode 100644
index 000000000000..5a6a056bfcb0
--- /dev/null
+++ b/tests/disas/winch/x64/f32_ge/locals.wat
@@ -0,0 +1,50 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo f32)  
+        (local $bar f32)
+
+        (f32.const 1.1)
+        (local.set $foo)
+
+        (f32.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f32.ge
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x7c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movss   0x43(%rip), %xmm0
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0x3d(%rip), %xmm0
+;;       movss   %xmm0, 8(%rsp)
+;;       movss   8(%rsp), %xmm0
+;;       movss   0xc(%rsp), %xmm1
+;;       ucomiss %xmm0, %xmm1
+;;       movl    $0, %eax
+;;       setae   %al
+;;       movl    $0, %r11d
+;;       setnp   %r11b
+;;       andl    %r11d, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   7c: ud2
+;;   7e: addb    %al, (%rax)
+;;   80: int     $0xcc
diff --git a/tests/disas/winch/x64/f32_ge/params.wat b/tests/disas/winch/x64/f32_ge/params.wat
new file mode 100644
index 000000000000..1912c01c1211
--- /dev/null
+++ b/tests/disas/winch/x64/f32_ge/params.wat
@@ -0,0 +1,36 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (param f32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (f32.ge)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x63
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   %xmm1, 8(%rsp)
+;;       movss   8(%rsp), %xmm0
+;;       movss   0xc(%rsp), %xmm1
+;;       ucomiss %xmm0, %xmm1
+;;       movl    $0, %eax
+;;       setae   %al
+;;       movl    $0, %r11d
+;;       setnp   %r11b
+;;       andl    %r11d, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   63: ud2
diff --git a/tests/disas/winch/x64/f32_gt/const.wat b/tests/disas/winch/x64/f32_gt/const.wat
new file mode 100644
index 000000000000..76d6b3e1247e
--- /dev/null
+++ b/tests/disas/winch/x64/f32_gt/const.wat
@@ -0,0 +1,41 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (f32.const 1.1)
+        (f32.const 2.2)
+        (f32.gt)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x5a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movss   0x2d(%rip), %xmm0
+;;       movss   0x2d(%rip), %xmm1
+;;       ucomiss %xmm0, %xmm1
+;;       movl    $0, %eax
+;;       seta    %al
+;;       movl    $0, %r11d
+;;       setnp   %r11b
+;;       andl    %r11d, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   5a: ud2
+;;   5c: addb    %al, (%rax)
+;;   5e: addb    %al, (%rax)
+;;   60: int     $0xcc
+;;   62: orb     $0x40, %al
+;;   64: addb    %al, (%rax)
+;;   66: addb    %al, (%rax)
+;;   68: int     $0xcc
diff --git a/tests/disas/winch/x64/f32_gt/locals.wat b/tests/disas/winch/x64/f32_gt/locals.wat
new file mode 100644
index 000000000000..4e3143f3d4ea
--- /dev/null
+++ b/tests/disas/winch/x64/f32_gt/locals.wat
@@ -0,0 +1,50 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo f32)  
+        (local $bar f32)
+
+        (f32.const 1.1)
+        (local.set $foo)
+
+        (f32.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f32.gt
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x7c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movss   0x43(%rip), %xmm0
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0x3d(%rip), %xmm0
+;;       movss   %xmm0, 8(%rsp)
+;;       movss   8(%rsp), %xmm0
+;;       movss   0xc(%rsp), %xmm1
+;;       ucomiss %xmm0, %xmm1
+;;       movl    $0, %eax
+;;       seta    %al
+;;       movl    $0, %r11d
+;;       setnp   %r11b
+;;       andl    %r11d, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   7c: ud2
+;;   7e: addb    %al, (%rax)
+;;   80: int     $0xcc
diff --git a/tests/disas/winch/x64/f32_gt/params.wat b/tests/disas/winch/x64/f32_gt/params.wat
new file mode 100644
index 000000000000..739ff45f4413
--- /dev/null
+++ b/tests/disas/winch/x64/f32_gt/params.wat
@@ -0,0 +1,36 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (param f32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (f32.gt)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x63
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   %xmm1, 8(%rsp)
+;;       movss   8(%rsp), %xmm0
+;;       movss   0xc(%rsp), %xmm1
+;;       ucomiss %xmm0, %xmm1
+;;       movl    $0, %eax
+;;       seta    %al
+;;       movl    $0, %r11d
+;;       setnp   %r11b
+;;       andl    %r11d, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   63: ud2
diff --git a/tests/disas/winch/x64/f32_le/const.wat b/tests/disas/winch/x64/f32_le/const.wat
new file mode 100644
index 000000000000..8196c81cd938
--- /dev/null
+++ b/tests/disas/winch/x64/f32_le/const.wat
@@ -0,0 +1,37 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (f32.const 1.1)
+        (f32.const 2.2)
+        (f32.le)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movss   0x1d(%rip), %xmm0
+;;       movss   0x1d(%rip), %xmm1
+;;       ucomiss %xmm1, %xmm0
+;;       movl    $0, %eax
+;;       setae   %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4d: ud2
+;;   4f: addb    %cl, %ch
+;;   51: int3
+;;   52: orb     $0x40, %al
+;;   54: addb    %al, (%rax)
+;;   56: addb    %al, (%rax)
+;;   58: int     $0xcc
diff --git a/tests/disas/winch/x64/f32_le/locals.wat b/tests/disas/winch/x64/f32_le/locals.wat
new file mode 100644
index 000000000000..c860de854afc
--- /dev/null
+++ b/tests/disas/winch/x64/f32_le/locals.wat
@@ -0,0 +1,50 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo f32)  
+        (local $bar f32)
+
+        (f32.const 1.1)
+        (local.set $foo)
+
+        (f32.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f32.le
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movss   0x3b(%rip), %xmm0
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0x35(%rip), %xmm0
+;;       movss   %xmm0, 8(%rsp)
+;;       movss   8(%rsp), %xmm0
+;;       movss   0xc(%rsp), %xmm1
+;;       ucomiss %xmm1, %xmm0
+;;       movl    $0, %eax
+;;       setae   %al
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6f: ud2
+;;   71: addb    %al, (%rax)
+;;   73: addb    %al, (%rax)
+;;   75: addb    %al, (%rax)
+;;   77: addb    %cl, %ch
+;;   79: int3
diff --git a/tests/disas/winch/x64/f32_le/params.wat b/tests/disas/winch/x64/f32_le/params.wat
new file mode 100644
index 000000000000..1f93e312b45c
--- /dev/null
+++ b/tests/disas/winch/x64/f32_le/params.wat
@@ -0,0 +1,33 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (param f32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (f32.le)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x56
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   %xmm1, 8(%rsp)
+;;       movss   8(%rsp), %xmm0
+;;       movss   0xc(%rsp), %xmm1
+;;       ucomiss %xmm1, %xmm0
+;;       movl    $0, %eax
+;;       setae   %al
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   56: ud2
diff --git a/tests/disas/winch/x64/f32_lt/const.wat b/tests/disas/winch/x64/f32_lt/const.wat
new file mode 100644
index 000000000000..8800c6078d79
--- /dev/null
+++ b/tests/disas/winch/x64/f32_lt/const.wat
@@ -0,0 +1,37 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (f32.const 1.1)
+        (f32.const 2.2)
+        (f32.lt)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movss   0x1d(%rip), %xmm0
+;;       movss   0x1d(%rip), %xmm1
+;;       ucomiss %xmm1, %xmm0
+;;       movl    $0, %eax
+;;       seta    %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4d: ud2
+;;   4f: addb    %cl, %ch
+;;   51: int3
+;;   52: orb     $0x40, %al
+;;   54: addb    %al, (%rax)
+;;   56: addb    %al, (%rax)
+;;   58: int     $0xcc
diff --git a/tests/disas/winch/x64/f32_lt/locals.wat b/tests/disas/winch/x64/f32_lt/locals.wat
new file mode 100644
index 000000000000..87bc63943c6e
--- /dev/null
+++ b/tests/disas/winch/x64/f32_lt/locals.wat
@@ -0,0 +1,50 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo f32)  
+        (local $bar f32)
+
+        (f32.const 1.1)
+        (local.set $foo)
+
+        (f32.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f32.lt
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movss   0x3b(%rip), %xmm0
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0x35(%rip), %xmm0
+;;       movss   %xmm0, 8(%rsp)
+;;       movss   8(%rsp), %xmm0
+;;       movss   0xc(%rsp), %xmm1
+;;       ucomiss %xmm1, %xmm0
+;;       movl    $0, %eax
+;;       seta    %al
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6f: ud2
+;;   71: addb    %al, (%rax)
+;;   73: addb    %al, (%rax)
+;;   75: addb    %al, (%rax)
+;;   77: addb    %cl, %ch
+;;   79: int3
diff --git a/tests/disas/winch/x64/f32_lt/params.wat b/tests/disas/winch/x64/f32_lt/params.wat
new file mode 100644
index 000000000000..d9d98a651c2a
--- /dev/null
+++ b/tests/disas/winch/x64/f32_lt/params.wat
@@ -0,0 +1,33 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (param f32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (f32.lt)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x56
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   %xmm1, 8(%rsp)
+;;       movss   8(%rsp), %xmm0
+;;       movss   0xc(%rsp), %xmm1
+;;       ucomiss %xmm1, %xmm0
+;;       movl    $0, %eax
+;;       seta    %al
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   56: ud2
diff --git a/tests/disas/winch/x64/f32_max/const.wat b/tests/disas/winch/x64/f32_max/const.wat
new file mode 100644
index 000000000000..137933de99a8
--- /dev/null
+++ b/tests/disas/winch/x64/f32_max/const.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (f32.const 1.1)
+        (f32.const 2.2)
+        (f32.max)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x69
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movss   0x3d(%rip), %xmm0
+;;       movss   0x3d(%rip), %xmm1
+;;       ucomiss %xmm0, %xmm1
+;;       jne     0x5c
+;;       jp      0x52
+;;   4a: andps   %xmm0, %xmm1
+;;       jmp     0x60
+;;   52: addss   %xmm0, %xmm1
+;;       jp      0x60
+;;   5c: maxss   %xmm0, %xmm1
+;;       movaps  %xmm1, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   69: ud2
+;;   6b: addb    %al, (%rax)
+;;   6d: addb    %al, (%rax)
+;;   6f: addb    %cl, %ch
+;;   71: int3
+;;   72: orb     $0x40, %al
+;;   74: addb    %al, (%rax)
+;;   76: addb    %al, (%rax)
+;;   78: int     $0xcc
diff --git a/tests/disas/winch/x64/f32_max/locals.wat b/tests/disas/winch/x64/f32_max/locals.wat
new file mode 100644
index 000000000000..973acd49d178
--- /dev/null
+++ b/tests/disas/winch/x64/f32_max/locals.wat
@@ -0,0 +1,54 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (local $foo f32)  
+        (local $bar f32)
+
+        (f32.const 1.1)
+        (local.set $foo)
+
+        (f32.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f32.max
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x8b
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movss   0x53(%rip), %xmm0
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0x4d(%rip), %xmm0
+;;       movss   %xmm0, 8(%rsp)
+;;       movss   8(%rsp), %xmm0
+;;       movss   0xc(%rsp), %xmm1
+;;       ucomiss %xmm0, %xmm1
+;;       jne     0x7e
+;;       jp      0x74
+;;   6c: andps   %xmm0, %xmm1
+;;       jmp     0x82
+;;   74: addss   %xmm0, %xmm1
+;;       jp      0x82
+;;   7e: maxss   %xmm0, %xmm1
+;;       movaps  %xmm1, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   8b: ud2
+;;   8d: addb    %al, (%rax)
+;;   8f: addb    %cl, %ch
+;;   91: int3
diff --git a/tests/disas/winch/x64/f32_max/params.wat b/tests/disas/winch/x64/f32_max/params.wat
new file mode 100644
index 000000000000..0b461d3f7505
--- /dev/null
+++ b/tests/disas/winch/x64/f32_max/params.wat
@@ -0,0 +1,39 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (param f32) (result f32)
+        (local.get 0)
+        (local.get 1)
+        (f32.max)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x72
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   %xmm1, 8(%rsp)
+;;       movss   8(%rsp), %xmm0
+;;       movss   0xc(%rsp), %xmm1
+;;       ucomiss %xmm0, %xmm1
+;;       jne     0x65
+;;       jp      0x5b
+;;   53: andps   %xmm0, %xmm1
+;;       jmp     0x69
+;;   5b: addss   %xmm0, %xmm1
+;;       jp      0x69
+;;   65: maxss   %xmm0, %xmm1
+;;       movaps  %xmm1, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   72: ud2
diff --git a/tests/disas/winch/x64/f32_min/const.wat b/tests/disas/winch/x64/f32_min/const.wat
new file mode 100644
index 000000000000..0b78caa6d081
--- /dev/null
+++ b/tests/disas/winch/x64/f32_min/const.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (f32.const 1.1)
+        (f32.const 2.2)
+        (f32.min)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x69
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movss   0x3d(%rip), %xmm0
+;;       movss   0x3d(%rip), %xmm1
+;;       ucomiss %xmm0, %xmm1
+;;       jne     0x5c
+;;       jp      0x52
+;;   4a: orps    %xmm0, %xmm1
+;;       jmp     0x60
+;;   52: addss   %xmm0, %xmm1
+;;       jp      0x60
+;;   5c: minss   %xmm0, %xmm1
+;;       movaps  %xmm1, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   69: ud2
+;;   6b: addb    %al, (%rax)
+;;   6d: addb    %al, (%rax)
+;;   6f: addb    %cl, %ch
+;;   71: int3
+;;   72: orb     $0x40, %al
+;;   74: addb    %al, (%rax)
+;;   76: addb    %al, (%rax)
+;;   78: int     $0xcc
diff --git a/tests/disas/winch/x64/f32_min/locals.wat b/tests/disas/winch/x64/f32_min/locals.wat
new file mode 100644
index 000000000000..f5051fad4ea7
--- /dev/null
+++ b/tests/disas/winch/x64/f32_min/locals.wat
@@ -0,0 +1,54 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (local $foo f32)  
+        (local $bar f32)
+
+        (f32.const 1.1)
+        (local.set $foo)
+
+        (f32.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f32.min
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x8b
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movss   0x53(%rip), %xmm0
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0x4d(%rip), %xmm0
+;;       movss   %xmm0, 8(%rsp)
+;;       movss   8(%rsp), %xmm0
+;;       movss   0xc(%rsp), %xmm1
+;;       ucomiss %xmm0, %xmm1
+;;       jne     0x7e
+;;       jp      0x74
+;;   6c: orps    %xmm0, %xmm1
+;;       jmp     0x82
+;;   74: addss   %xmm0, %xmm1
+;;       jp      0x82
+;;   7e: minss   %xmm0, %xmm1
+;;       movaps  %xmm1, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   8b: ud2
+;;   8d: addb    %al, (%rax)
+;;   8f: addb    %cl, %ch
+;;   91: int3
diff --git a/tests/disas/winch/x64/f32_min/params.wat b/tests/disas/winch/x64/f32_min/params.wat
new file mode 100644
index 000000000000..77a6da36e6e3
--- /dev/null
+++ b/tests/disas/winch/x64/f32_min/params.wat
@@ -0,0 +1,39 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (param f32) (result f32)
+        (local.get 0)
+        (local.get 1)
+        (f32.min)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x72
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   %xmm1, 8(%rsp)
+;;       movss   8(%rsp), %xmm0
+;;       movss   0xc(%rsp), %xmm1
+;;       ucomiss %xmm0, %xmm1
+;;       jne     0x65
+;;       jp      0x5b
+;;   53: orps    %xmm0, %xmm1
+;;       jmp     0x69
+;;   5b: addss   %xmm0, %xmm1
+;;       jp      0x69
+;;   65: minss   %xmm0, %xmm1
+;;       movaps  %xmm1, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   72: ud2
diff --git a/tests/disas/winch/x64/f32_mul/const.wat b/tests/disas/winch/x64/f32_mul/const.wat
new file mode 100644
index 000000000000..ffc1ae62a95e
--- /dev/null
+++ b/tests/disas/winch/x64/f32_mul/const.wat
@@ -0,0 +1,38 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (f32.const 1.1)
+        (f32.const 2.2)
+        (f32.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x48
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movss   0x1d(%rip), %xmm0
+;;       movss   0x1d(%rip), %xmm1
+;;       mulss   %xmm0, %xmm1
+;;       movaps  %xmm1, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   48: ud2
+;;   4a: addb    %al, (%rax)
+;;   4c: addb    %al, (%rax)
+;;   4e: addb    %al, (%rax)
+;;   50: int     $0xcc
+;;   52: orb     $0x40, %al
+;;   54: addb    %al, (%rax)
+;;   56: addb    %al, (%rax)
+;;   58: int     $0xcc
diff --git a/tests/disas/winch/x64/f32_mul/locals.wat b/tests/disas/winch/x64/f32_mul/locals.wat
new file mode 100644
index 000000000000..180a8c156473
--- /dev/null
+++ b/tests/disas/winch/x64/f32_mul/locals.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (local $foo f32)  
+        (local $bar f32)
+
+        (f32.const 1.1)
+        (local.set $foo)
+
+        (f32.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f32.mul
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movss   0x33(%rip), %xmm0
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0x2d(%rip), %xmm0
+;;       movss   %xmm0, 8(%rsp)
+;;       movss   8(%rsp), %xmm0
+;;       movss   0xc(%rsp), %xmm1
+;;       mulss   %xmm0, %xmm1
+;;       movaps  %xmm1, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6a: ud2
+;;   6c: addb    %al, (%rax)
+;;   6e: addb    %al, (%rax)
+;;   70: int     $0xcc
diff --git a/tests/disas/winch/x64/f32_mul/params.wat b/tests/disas/winch/x64/f32_mul/params.wat
new file mode 100644
index 000000000000..cd61bd697564
--- /dev/null
+++ b/tests/disas/winch/x64/f32_mul/params.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (param f32) (result f32)
+        (local.get 0)
+        (local.get 1)
+        (f32.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x51
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   %xmm1, 8(%rsp)
+;;       movss   8(%rsp), %xmm0
+;;       movss   0xc(%rsp), %xmm1
+;;       mulss   %xmm0, %xmm1
+;;       movaps  %xmm1, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   51: ud2
diff --git a/tests/disas/winch/x64/f32_ne/const.wat b/tests/disas/winch/x64/f32_ne/const.wat
new file mode 100644
index 000000000000..6a111ddfcd49
--- /dev/null
+++ b/tests/disas/winch/x64/f32_ne/const.wat
@@ -0,0 +1,41 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (f32.const 1.1)
+        (f32.const 2.2)
+        (f32.ne)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x5a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movss   0x2d(%rip), %xmm0
+;;       movss   0x2d(%rip), %xmm1
+;;       ucomiss %xmm0, %xmm1
+;;       movl    $0, %eax
+;;       setne   %al
+;;       movl    $0, %r11d
+;;       setp    %r11b
+;;       orl     %r11d, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   5a: ud2
+;;   5c: addb    %al, (%rax)
+;;   5e: addb    %al, (%rax)
+;;   60: int     $0xcc
+;;   62: orb     $0x40, %al
+;;   64: addb    %al, (%rax)
+;;   66: addb    %al, (%rax)
+;;   68: int     $0xcc
diff --git a/tests/disas/winch/x64/f32_ne/locals.wat b/tests/disas/winch/x64/f32_ne/locals.wat
new file mode 100644
index 000000000000..c5ad122246d8
--- /dev/null
+++ b/tests/disas/winch/x64/f32_ne/locals.wat
@@ -0,0 +1,50 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo f32)  
+        (local $bar f32)
+
+        (f32.const 1.1)
+        (local.set $foo)
+
+        (f32.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f32.ne
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x7c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movss   0x43(%rip), %xmm0
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0x3d(%rip), %xmm0
+;;       movss   %xmm0, 8(%rsp)
+;;       movss   8(%rsp), %xmm0
+;;       movss   0xc(%rsp), %xmm1
+;;       ucomiss %xmm0, %xmm1
+;;       movl    $0, %eax
+;;       setne   %al
+;;       movl    $0, %r11d
+;;       setp    %r11b
+;;       orl     %r11d, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   7c: ud2
+;;   7e: addb    %al, (%rax)
+;;   80: int     $0xcc
diff --git a/tests/disas/winch/x64/f32_ne/params.wat b/tests/disas/winch/x64/f32_ne/params.wat
new file mode 100644
index 000000000000..7830120d6ca8
--- /dev/null
+++ b/tests/disas/winch/x64/f32_ne/params.wat
@@ -0,0 +1,36 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (param f32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (f32.ne)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x63
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   %xmm1, 8(%rsp)
+;;       movss   8(%rsp), %xmm0
+;;       movss   0xc(%rsp), %xmm1
+;;       ucomiss %xmm0, %xmm1
+;;       movl    $0, %eax
+;;       setne   %al
+;;       movl    $0, %r11d
+;;       setp    %r11b
+;;       orl     %r11d, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   63: ud2
diff --git a/tests/disas/winch/x64/f32_nearest/f32_floor_const_sse41.wat b/tests/disas/winch/x64/f32_nearest/f32_floor_const_sse41.wat
new file mode 100644
index 000000000000..3576f85a34df
--- /dev/null
+++ b/tests/disas/winch/x64/f32_nearest/f32_floor_const_sse41.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_sse41"]
+
+(module
+    (func (result f32)
+        (f32.const -1.32)
+        (f32.nearest)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movss   0x15(%rip), %xmm0
+;;       roundss $0, %xmm0, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3f: ud2
+;;   41: addb    %al, (%rax)
+;;   43: addb    %al, (%rax)
+;;   45: addb    %al, (%rax)
+;;   47: addb    %al, %bl
+;;   49: cmc
+;;   4a: testb   $0xbf, %al
diff --git a/tests/disas/winch/x64/f32_nearest/f32_floor_param_sse41.wat b/tests/disas/winch/x64/f32_nearest/f32_floor_param_sse41.wat
new file mode 100644
index 000000000000..78b174fdda28
--- /dev/null
+++ b/tests/disas/winch/x64/f32_nearest/f32_floor_param_sse41.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_sse41"]
+
+(module
+    (func (param f32) (result f32)
+        (local.get 0)
+        (f32.nearest)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x44
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0xc(%rsp), %xmm0
+;;       roundss $0, %xmm0, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   44: ud2
diff --git a/tests/disas/winch/x64/f32_nearest/f32_nearest_param.wat b/tests/disas/winch/x64/f32_nearest/f32_nearest_param.wat
new file mode 100644
index 000000000000..ddb825e09b17
--- /dev/null
+++ b/tests/disas/winch/x64/f32_nearest/f32_nearest_param.wat
@@ -0,0 +1,36 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (result f32)
+        (local.get 0)
+        (f32.nearest)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x30, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0xc(%rsp), %xmm15
+;;       subq    $4, %rsp
+;;       movss   %xmm15, (%rsp)
+;;       subq    $0xc, %rsp
+;;       movss   0xc(%rsp), %xmm0
+;;       movabsq $0, %r11
+;;       callq   *%r11
+;;       addq    $0xc, %rsp
+;;       addq    $4, %rsp
+;;       movq    0x18(%rsp), %r14
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6d: ud2
diff --git a/tests/disas/winch/x64/f32_neg/f32_neg_const.wat b/tests/disas/winch/x64/f32_neg/f32_neg_const.wat
new file mode 100644
index 000000000000..d53966d2b5ee
--- /dev/null
+++ b/tests/disas/winch/x64/f32_neg/f32_neg_const.wat
@@ -0,0 +1,35 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (f32.const -1.32)
+        (f32.neg)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x48
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movss   0x1d(%rip), %xmm0
+;;       movl    $0x80000000, %r11d
+;;       movd    %r11d, %xmm15
+;;       xorps   %xmm15, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   48: ud2
+;;   4a: addb    %al, (%rax)
+;;   4c: addb    %al, (%rax)
+;;   4e: addb    %al, (%rax)
+;;   50: retq
+;;   51: cmc
+;;   52: testb   $0xbf, %al
diff --git a/tests/disas/winch/x64/f32_neg/f32_neg_param.wat b/tests/disas/winch/x64/f32_neg/f32_neg_param.wat
new file mode 100644
index 000000000000..9e38bf8d350a
--- /dev/null
+++ b/tests/disas/winch/x64/f32_neg/f32_neg_param.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (result f32)
+        (local.get 0)
+        (f32.neg)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0xc(%rsp), %xmm0
+;;       movl    $0x80000000, %r11d
+;;       movd    %r11d, %xmm15
+;;       xorps   %xmm15, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4d: ud2
diff --git a/tests/disas/winch/x64/f32_reinterpret_i32/const.wat b/tests/disas/winch/x64/f32_reinterpret_i32/const.wat
new file mode 100644
index 000000000000..f4cef682d430
--- /dev/null
+++ b/tests/disas/winch/x64/f32_reinterpret_i32/const.wat
@@ -0,0 +1,27 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (i32.const 1)
+        (f32.reinterpret_i32)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       movd    %eax, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3a: ud2
diff --git a/tests/disas/winch/x64/f32_reinterpret_i32/locals.wat b/tests/disas/winch/x64/f32_reinterpret_i32/locals.wat
new file mode 100644
index 000000000000..24f6aa51b744
--- /dev/null
+++ b/tests/disas/winch/x64/f32_reinterpret_i32/locals.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (local i32)  
+
+        (local.get 0)
+        (f32.reinterpret_i32)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x43
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       movd    %eax, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   43: ud2
diff --git a/tests/disas/winch/x64/f32_reinterpret_i32/params.wat b/tests/disas/winch/x64/f32_reinterpret_i32/params.wat
new file mode 100644
index 000000000000..57e2bca734f8
--- /dev/null
+++ b/tests/disas/winch/x64/f32_reinterpret_i32/params.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (result f32)
+        (local.get 0)
+        (f32.reinterpret_i32)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       movd    %eax, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3e: ud2
diff --git a/tests/disas/winch/x64/f32_reinterpret_i32/ret_int.wat b/tests/disas/winch/x64/f32_reinterpret_i32/ret_int.wat
new file mode 100644
index 000000000000..82a97b8d3fb0
--- /dev/null
+++ b/tests/disas/winch/x64/f32_reinterpret_i32/ret_int.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        i32.const 1
+        f32.reinterpret_i32
+        drop
+        i32.const 1
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       movd    %eax, %xmm0
+;;       movl    $1, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3f: ud2
diff --git a/tests/disas/winch/x64/f32_reinterpret_i32/spilled.wat b/tests/disas/winch/x64/f32_reinterpret_i32/spilled.wat
new file mode 100644
index 000000000000..b7a9a2f8e8d0
--- /dev/null
+++ b/tests/disas/winch/x64/f32_reinterpret_i32/spilled.wat
@@ -0,0 +1,33 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        i32.const 1
+        f32.reinterpret_i32
+        block
+        end
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x14, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       movd    %eax, %xmm0
+;;       subq    $4, %rsp
+;;       movss   %xmm0, (%rsp)
+;;       movss   (%rsp), %xmm0
+;;       addq    $4, %rsp
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4c: ud2
diff --git a/tests/disas/winch/x64/f32_sqrt/f32_sqrt_const.wat b/tests/disas/winch/x64/f32_sqrt/f32_sqrt_const.wat
new file mode 100644
index 000000000000..d37417b99920
--- /dev/null
+++ b/tests/disas/winch/x64/f32_sqrt/f32_sqrt_const.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (f32.const 1.32)
+        (f32.sqrt)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movss   0xd(%rip), %xmm0
+;;       sqrtss  %xmm0, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3d: ud2
+;;   3f: addb    %al, %bl
+;;   41: cmc
+;;   42: testb   $0x3f, %al
diff --git a/tests/disas/winch/x64/f32_sqrt/f32_sqrt_param.wat b/tests/disas/winch/x64/f32_sqrt/f32_sqrt_param.wat
new file mode 100644
index 000000000000..38764f30efba
--- /dev/null
+++ b/tests/disas/winch/x64/f32_sqrt/f32_sqrt_param.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (result f32)
+        (local.get 0)
+        (f32.sqrt)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x42
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0xc(%rsp), %xmm0
+;;       sqrtss  %xmm0, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   42: ud2
diff --git a/tests/disas/winch/x64/f32_sub/const.wat b/tests/disas/winch/x64/f32_sub/const.wat
new file mode 100644
index 000000000000..48daf4098ade
--- /dev/null
+++ b/tests/disas/winch/x64/f32_sub/const.wat
@@ -0,0 +1,38 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (f32.const 1.1)
+        (f32.const 2.2)
+        (f32.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x48
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movss   0x1d(%rip), %xmm0
+;;       movss   0x1d(%rip), %xmm1
+;;       subss   %xmm0, %xmm1
+;;       movaps  %xmm1, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   48: ud2
+;;   4a: addb    %al, (%rax)
+;;   4c: addb    %al, (%rax)
+;;   4e: addb    %al, (%rax)
+;;   50: int     $0xcc
+;;   52: orb     $0x40, %al
+;;   54: addb    %al, (%rax)
+;;   56: addb    %al, (%rax)
+;;   58: int     $0xcc
diff --git a/tests/disas/winch/x64/f32_sub/locals.wat b/tests/disas/winch/x64/f32_sub/locals.wat
new file mode 100644
index 000000000000..c8afe6e42f29
--- /dev/null
+++ b/tests/disas/winch/x64/f32_sub/locals.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        (local $foo f32)  
+        (local $bar f32)
+
+        (f32.const 1.1)
+        (local.set $foo)
+
+        (f32.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f32.sub
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movss   0x33(%rip), %xmm0
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0x2d(%rip), %xmm0
+;;       movss   %xmm0, 8(%rsp)
+;;       movss   8(%rsp), %xmm0
+;;       movss   0xc(%rsp), %xmm1
+;;       subss   %xmm0, %xmm1
+;;       movaps  %xmm1, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6a: ud2
+;;   6c: addb    %al, (%rax)
+;;   6e: addb    %al, (%rax)
+;;   70: int     $0xcc
diff --git a/tests/disas/winch/x64/f32_sub/params.wat b/tests/disas/winch/x64/f32_sub/params.wat
new file mode 100644
index 000000000000..bbfb9b4923fd
--- /dev/null
+++ b/tests/disas/winch/x64/f32_sub/params.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (param f32) (result f32)
+        (local.get 0)
+        (local.get 1)
+        (f32.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x51
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   %xmm1, 8(%rsp)
+;;       movss   8(%rsp), %xmm0
+;;       movss   0xc(%rsp), %xmm1
+;;       subss   %xmm0, %xmm1
+;;       movaps  %xmm1, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   51: ud2
diff --git a/tests/disas/winch/x64/f32_trunc/f32_trunc_const_sse41.wat b/tests/disas/winch/x64/f32_trunc/f32_trunc_const_sse41.wat
new file mode 100644
index 000000000000..7c574e2fc87c
--- /dev/null
+++ b/tests/disas/winch/x64/f32_trunc/f32_trunc_const_sse41.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_sse41"]
+
+(module
+    (func (result f32)
+        (f32.const -1.32)
+        (f32.trunc)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movss   0x15(%rip), %xmm0
+;;       roundss $3, %xmm0, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3f: ud2
+;;   41: addb    %al, (%rax)
+;;   43: addb    %al, (%rax)
+;;   45: addb    %al, (%rax)
+;;   47: addb    %al, %bl
+;;   49: cmc
+;;   4a: testb   $0xbf, %al
diff --git a/tests/disas/winch/x64/f32_trunc/f32_trunc_param.wat b/tests/disas/winch/x64/f32_trunc/f32_trunc_param.wat
new file mode 100644
index 000000000000..15a663ca7fd4
--- /dev/null
+++ b/tests/disas/winch/x64/f32_trunc/f32_trunc_param.wat
@@ -0,0 +1,36 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (result f32)
+        (local.get 0)
+        (f32.trunc)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x30, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0xc(%rsp), %xmm15
+;;       subq    $4, %rsp
+;;       movss   %xmm15, (%rsp)
+;;       subq    $0xc, %rsp
+;;       movss   0xc(%rsp), %xmm0
+;;       movabsq $0, %r11
+;;       callq   *%r11
+;;       addq    $0xc, %rsp
+;;       addq    $4, %rsp
+;;       movq    0x18(%rsp), %r14
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6d: ud2
diff --git a/tests/disas/winch/x64/f32_trunc/f32_trunc_param_sse41.wat b/tests/disas/winch/x64/f32_trunc/f32_trunc_param_sse41.wat
new file mode 100644
index 000000000000..2c34d929675c
--- /dev/null
+++ b/tests/disas/winch/x64/f32_trunc/f32_trunc_param_sse41.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_sse41"]
+
+(module
+    (func (param f32) (result f32)
+        (local.get 0)
+        (f32.trunc)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x44
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0xc(%rsp), %xmm0
+;;       roundss $3, %xmm0, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   44: ud2
diff --git a/tests/disas/winch/x64/f64_abs/f64_abs_const.wat b/tests/disas/winch/x64/f64_abs/f64_abs_const.wat
new file mode 100644
index 000000000000..4e584c09d964
--- /dev/null
+++ b/tests/disas/winch/x64/f64_abs/f64_abs_const.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (f64.const -1.32)
+        (f64.abs)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movsd   0x1d(%rip), %xmm0
+;;       movabsq $0x7fffffffffffffff, %r11
+;;       movq    %r11, %xmm15
+;;       andpd   %xmm15, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4d: ud2
+;;   4f: addb    %bl, (%rdi)
+;;   51: testl   %ebp, %ebx
+;;   53: pushq   %rcx
diff --git a/tests/disas/winch/x64/f64_abs/f64_abs_param.wat b/tests/disas/winch/x64/f64_abs/f64_abs_param.wat
new file mode 100644
index 000000000000..8483eb7ce052
--- /dev/null
+++ b/tests/disas/winch/x64/f64_abs/f64_abs_param.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (result f64)
+        (local.get 0)
+        (f64.abs)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x52
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   8(%rsp), %xmm0
+;;       movabsq $0x7fffffffffffffff, %r11
+;;       movq    %r11, %xmm15
+;;       andpd   %xmm15, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   52: ud2
diff --git a/tests/disas/winch/x64/f64_add/const.wat b/tests/disas/winch/x64/f64_add/const.wat
new file mode 100644
index 000000000000..3ffd678137cc
--- /dev/null
+++ b/tests/disas/winch/x64/f64_add/const.wat
@@ -0,0 +1,41 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (f64.const 1.1)
+        (f64.const 2.2)
+        (f64.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x49
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movsd   0x1d(%rip), %xmm0
+;;       movsd   0x1d(%rip), %xmm1
+;;       addsd   %xmm0, %xmm1
+;;       movapd  %xmm1, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   49: ud2
+;;   4b: addb    %al, (%rax)
+;;   4d: addb    %al, (%rax)
+;;   4f: addb    %bl, -0x66666667(%rdx)
+;;   55: cltd
+;;   56: addl    %eax, -0x66(%rax)
+;;   59: cltd
+;;   5a: cltd
+;;   5b: cltd
+;;   5c: cltd
+;;   5d: cltd
+;;   5e: int1
diff --git a/tests/disas/winch/x64/f64_add/locals.wat b/tests/disas/winch/x64/f64_add/locals.wat
new file mode 100644
index 000000000000..1a5daa3d48f3
--- /dev/null
+++ b/tests/disas/winch/x64/f64_add/locals.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (local $foo f64)  
+        (local $bar f64)
+
+        (f64.const 1.1)
+        (local.set $foo)
+
+        (f64.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f64.add
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movsd   0x30(%rip), %xmm0
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   0x2a(%rip), %xmm0
+;;       movsd   %xmm0, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       movsd   8(%rsp), %xmm1
+;;       addsd   %xmm0, %xmm1
+;;       movapd  %xmm1, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6c: ud2
+;;   6e: addb    %al, (%rax)
diff --git a/tests/disas/winch/x64/f64_add/params.wat b/tests/disas/winch/x64/f64_add/params.wat
new file mode 100644
index 000000000000..00d454d66af1
--- /dev/null
+++ b/tests/disas/winch/x64/f64_add/params.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (param f64) (result f64)
+        (local.get 0)
+        (local.get 1)
+        (f64.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x50
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   %xmm1, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       movsd   8(%rsp), %xmm1
+;;       addsd   %xmm0, %xmm1
+;;       movapd  %xmm1, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   50: ud2
diff --git a/tests/disas/winch/x64/f64_ceil/f64_ceil_const_sse41.wat b/tests/disas/winch/x64/f64_ceil/f64_ceil_const_sse41.wat
new file mode 100644
index 000000000000..9f7671fd28ba
--- /dev/null
+++ b/tests/disas/winch/x64/f64_ceil/f64_ceil_const_sse41.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_sse41"]
+
+(module
+    (func (result f64)
+        (f64.const -1.32)
+        (f64.ceil)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movsd   0x15(%rip), %xmm0
+;;       roundsd $2, %xmm0, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3f: ud2
+;;   41: addb    %al, (%rax)
+;;   43: addb    %al, (%rax)
+;;   45: addb    %al, (%rax)
+;;   47: addb    %bl, (%rdi)
+;;   49: testl   %ebp, %ebx
+;;   4b: pushq   %rcx
diff --git a/tests/disas/winch/x64/f64_ceil/f64_ceil_param.wat b/tests/disas/winch/x64/f64_ceil/f64_ceil_param.wat
new file mode 100644
index 000000000000..85d81bc5e05a
--- /dev/null
+++ b/tests/disas/winch/x64/f64_ceil/f64_ceil_param.wat
@@ -0,0 +1,36 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (result f64)
+        (local.get 0)
+        (f64.ceil)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x30, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   8(%rsp), %xmm15
+;;       subq    $8, %rsp
+;;       movsd   %xmm15, (%rsp)
+;;       subq    $8, %rsp
+;;       movsd   8(%rsp), %xmm0
+;;       movabsq $0, %r11
+;;       callq   *%r11
+;;       addq    $8, %rsp
+;;       addq    $8, %rsp
+;;       movq    0x18(%rsp), %r14
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6d: ud2
diff --git a/tests/disas/winch/x64/f64_ceil/f64_ceil_param_sse41.wat b/tests/disas/winch/x64/f64_ceil/f64_ceil_param_sse41.wat
new file mode 100644
index 000000000000..820c803205bc
--- /dev/null
+++ b/tests/disas/winch/x64/f64_ceil/f64_ceil_param_sse41.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_sse41"]
+
+(module
+    (func (param f64) (result f64)
+        (local.get 0)
+        (f64.ceil)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x44
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   8(%rsp), %xmm0
+;;       roundsd $2, %xmm0, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   44: ud2
diff --git a/tests/disas/winch/x64/f64_const/call_id.wat b/tests/disas/winch/x64/f64_const/call_id.wat
new file mode 100644
index 000000000000..5712752d2ded
--- /dev/null
+++ b/tests/disas/winch/x64/f64_const/call_id.wat
@@ -0,0 +1,52 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func $id-f64 (param f64) (result f64) (local.get 0))
+  (func (export "type-first-f64") (result f64) (call $id-f64 (f64.const 1.32)))
+)
+;; wasm[0]::function[0]::id-f64:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   8(%rsp), %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3e: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x89
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       movsd   0x17(%rip), %xmm0
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   89: ud2
+;;   8b: addb    %al, (%rax)
+;;   8d: addb    %al, (%rax)
+;;   8f: addb    %bl, (%rdi)
+;;   91: testl   %ebp, %ebx
+;;   93: pushq   %rcx
diff --git a/tests/disas/winch/x64/f64_const/id.wat b/tests/disas/winch/x64/f64_const/id.wat
new file mode 100644
index 000000000000..b12a6b089af4
--- /dev/null
+++ b/tests/disas/winch/x64/f64_const/id.wat
@@ -0,0 +1,24 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (param f64) (result f64) (local.get 0))
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   8(%rsp), %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3e: ud2
diff --git a/tests/disas/winch/x64/f64_convert_i32_s/const.wat b/tests/disas/winch/x64/f64_convert_i32_s/const.wat
new file mode 100644
index 000000000000..f89e4c292e72
--- /dev/null
+++ b/tests/disas/winch/x64/f64_convert_i32_s/const.wat
@@ -0,0 +1,27 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (i32.const 1)
+        (f64.convert_i32_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       cvtsi2sdl %eax, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3a: ud2
diff --git a/tests/disas/winch/x64/f64_convert_i32_s/locals.wat b/tests/disas/winch/x64/f64_convert_i32_s/locals.wat
new file mode 100644
index 000000000000..6f54b6ca53e4
--- /dev/null
+++ b/tests/disas/winch/x64/f64_convert_i32_s/locals.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (local i32)  
+
+        (local.get 0)
+        (f64.convert_i32_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x43
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       cvtsi2sdl %eax, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   43: ud2
diff --git a/tests/disas/winch/x64/f64_convert_i32_s/params.wat b/tests/disas/winch/x64/f64_convert_i32_s/params.wat
new file mode 100644
index 000000000000..d75ed2bd0c59
--- /dev/null
+++ b/tests/disas/winch/x64/f64_convert_i32_s/params.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (result f64)
+        (local.get 0)
+        (f64.convert_i32_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       cvtsi2sdl %eax, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3e: ud2
diff --git a/tests/disas/winch/x64/f64_convert_i32_s/spilled.wat b/tests/disas/winch/x64/f64_convert_i32_s/spilled.wat
new file mode 100644
index 000000000000..a565924173de
--- /dev/null
+++ b/tests/disas/winch/x64/f64_convert_i32_s/spilled.wat
@@ -0,0 +1,33 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        i32.const 1
+        f64.convert_i32_s
+        block
+        end
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x18, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       cvtsi2sdl %eax, %xmm0
+;;       subq    $8, %rsp
+;;       movsd   %xmm0, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       addq    $8, %rsp
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4c: ud2
diff --git a/tests/disas/winch/x64/f64_convert_i32_u/const.wat b/tests/disas/winch/x64/f64_convert_i32_u/const.wat
new file mode 100644
index 000000000000..ddda5fb25d95
--- /dev/null
+++ b/tests/disas/winch/x64/f64_convert_i32_u/const.wat
@@ -0,0 +1,38 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (i32.const 1)
+        (f64.convert_i32_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x66
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %ecx
+;;       movl    %ecx, %ecx
+;;       cmpq    $0, %rcx
+;;       jl      0x46
+;;   3c: cvtsi2sdq %rcx, %xmm0
+;;       jmp     0x60
+;;   46: movq    %rcx, %r11
+;;       shrq    $1, %r11
+;;       movq    %rcx, %rax
+;;       andq    $1, %rax
+;;       orq     %r11, %rax
+;;       cvtsi2sdq %rax, %xmm0
+;;       addsd   %xmm0, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   66: ud2
diff --git a/tests/disas/winch/x64/f64_convert_i32_u/locals.wat b/tests/disas/winch/x64/f64_convert_i32_u/locals.wat
new file mode 100644
index 000000000000..7c3a2810d840
--- /dev/null
+++ b/tests/disas/winch/x64/f64_convert_i32_u/locals.wat
@@ -0,0 +1,41 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (local i32)  
+
+        (local.get 0)
+        (f64.convert_i32_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    0xc(%rsp), %ecx
+;;       movl    %ecx, %ecx
+;;       cmpq    $0, %rcx
+;;       jl      0x4f
+;;   45: cvtsi2sdq %rcx, %xmm0
+;;       jmp     0x69
+;;   4f: movq    %rcx, %r11
+;;       shrq    $1, %r11
+;;       movq    %rcx, %rax
+;;       andq    $1, %rax
+;;       orq     %r11, %rax
+;;       cvtsi2sdq %rax, %xmm0
+;;       addsd   %xmm0, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6f: ud2
diff --git a/tests/disas/winch/x64/f64_convert_i32_u/params.wat b/tests/disas/winch/x64/f64_convert_i32_u/params.wat
new file mode 100644
index 000000000000..5fe5801b57ba
--- /dev/null
+++ b/tests/disas/winch/x64/f64_convert_i32_u/params.wat
@@ -0,0 +1,39 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (result f64)
+        (local.get 0)
+        (f64.convert_i32_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %ecx
+;;       movl    %ecx, %ecx
+;;       cmpq    $0, %rcx
+;;       jl      0x4a
+;;   40: cvtsi2sdq %rcx, %xmm0
+;;       jmp     0x64
+;;   4a: movq    %rcx, %r11
+;;       shrq    $1, %r11
+;;       movq    %rcx, %rax
+;;       andq    $1, %rax
+;;       orq     %r11, %rax
+;;       cvtsi2sdq %rax, %xmm0
+;;       addsd   %xmm0, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6a: ud2
diff --git a/tests/disas/winch/x64/f64_convert_i32_u/spilled.wat b/tests/disas/winch/x64/f64_convert_i32_u/spilled.wat
new file mode 100644
index 000000000000..129aebcf7b33
--- /dev/null
+++ b/tests/disas/winch/x64/f64_convert_i32_u/spilled.wat
@@ -0,0 +1,44 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        i32.const 1
+        f64.convert_i32_u
+        block
+        end
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x18, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x78
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %ecx
+;;       movl    %ecx, %ecx
+;;       cmpq    $0, %rcx
+;;       jl      0x46
+;;   3c: cvtsi2sdq %rcx, %xmm0
+;;       jmp     0x60
+;;   46: movq    %rcx, %r11
+;;       shrq    $1, %r11
+;;       movq    %rcx, %rax
+;;       andq    $1, %rax
+;;       orq     %r11, %rax
+;;       cvtsi2sdq %rax, %xmm0
+;;       addsd   %xmm0, %xmm0
+;;       subq    $8, %rsp
+;;       movsd   %xmm0, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       addq    $8, %rsp
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   78: ud2
diff --git a/tests/disas/winch/x64/f64_convert_i64_s/const.wat b/tests/disas/winch/x64/f64_convert_i64_s/const.wat
new file mode 100644
index 000000000000..893adef86c10
--- /dev/null
+++ b/tests/disas/winch/x64/f64_convert_i64_s/const.wat
@@ -0,0 +1,27 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (i64.const 1)
+        (f64.convert_i64_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       cvtsi2sdq %rax, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3d: ud2
diff --git a/tests/disas/winch/x64/f64_convert_i64_s/locals.wat b/tests/disas/winch/x64/f64_convert_i64_s/locals.wat
new file mode 100644
index 000000000000..58cf53418cba
--- /dev/null
+++ b/tests/disas/winch/x64/f64_convert_i64_s/locals.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (local i64)  
+
+        (local.get 0)
+        (f64.convert_i64_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x45
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movq    8(%rsp), %rax
+;;       cvtsi2sdq %rax, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   45: ud2
diff --git a/tests/disas/winch/x64/f64_convert_i64_s/params.wat b/tests/disas/winch/x64/f64_convert_i64_s/params.wat
new file mode 100644
index 000000000000..9b03d4df7e67
--- /dev/null
+++ b/tests/disas/winch/x64/f64_convert_i64_s/params.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (result f64)
+        (local.get 0)
+        (f64.convert_i64_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x41
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    8(%rsp), %rax
+;;       cvtsi2sdq %rax, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   41: ud2
diff --git a/tests/disas/winch/x64/f64_convert_i64_s/spilled.wat b/tests/disas/winch/x64/f64_convert_i64_s/spilled.wat
new file mode 100644
index 000000000000..bd74e70c1a47
--- /dev/null
+++ b/tests/disas/winch/x64/f64_convert_i64_s/spilled.wat
@@ -0,0 +1,33 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        i64.const 1
+        f64.convert_i64_s
+        block
+        end
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x18, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       cvtsi2sdq %rax, %xmm0
+;;       subq    $8, %rsp
+;;       movsd   %xmm0, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       addq    $8, %rsp
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4f: ud2
diff --git a/tests/disas/winch/x64/f64_convert_i64_u/const.wat b/tests/disas/winch/x64/f64_convert_i64_u/const.wat
new file mode 100644
index 000000000000..29b0fc0b0823
--- /dev/null
+++ b/tests/disas/winch/x64/f64_convert_i64_u/const.wat
@@ -0,0 +1,37 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (i64.const 1)
+        (f64.convert_i64_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x66
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rcx
+;;       cmpq    $0, %rcx
+;;       jl      0x46
+;;   3c: cvtsi2sdq %rcx, %xmm0
+;;       jmp     0x60
+;;   46: movq    %rcx, %r11
+;;       shrq    $1, %r11
+;;       movq    %rcx, %rax
+;;       andq    $1, %rax
+;;       orq     %r11, %rax
+;;       cvtsi2sdq %rax, %xmm0
+;;       addsd   %xmm0, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   66: ud2
diff --git a/tests/disas/winch/x64/f64_convert_i64_u/locals.wat b/tests/disas/winch/x64/f64_convert_i64_u/locals.wat
new file mode 100644
index 000000000000..89ceb3907d93
--- /dev/null
+++ b/tests/disas/winch/x64/f64_convert_i64_u/locals.wat
@@ -0,0 +1,40 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (local i64)  
+
+        (local.get 0)
+        (f64.convert_i64_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movq    8(%rsp), %rcx
+;;       cmpq    $0, %rcx
+;;       jl      0x4e
+;;   44: cvtsi2sdq %rcx, %xmm0
+;;       jmp     0x68
+;;   4e: movq    %rcx, %r11
+;;       shrq    $1, %r11
+;;       movq    %rcx, %rax
+;;       andq    $1, %rax
+;;       orq     %r11, %rax
+;;       cvtsi2sdq %rax, %xmm0
+;;       addsd   %xmm0, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6e: ud2
diff --git a/tests/disas/winch/x64/f64_convert_i64_u/params.wat b/tests/disas/winch/x64/f64_convert_i64_u/params.wat
new file mode 100644
index 000000000000..99c7d3cf970d
--- /dev/null
+++ b/tests/disas/winch/x64/f64_convert_i64_u/params.wat
@@ -0,0 +1,38 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (result f64)
+        (local.get 0)
+        (f64.convert_i64_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    8(%rsp), %rcx
+;;       cmpq    $0, %rcx
+;;       jl      0x4a
+;;   40: cvtsi2sdq %rcx, %xmm0
+;;       jmp     0x64
+;;   4a: movq    %rcx, %r11
+;;       shrq    $1, %r11
+;;       movq    %rcx, %rax
+;;       andq    $1, %rax
+;;       orq     %r11, %rax
+;;       cvtsi2sdq %rax, %xmm0
+;;       addsd   %xmm0, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6a: ud2
diff --git a/tests/disas/winch/x64/f64_convert_i64_u/spilled.wat b/tests/disas/winch/x64/f64_convert_i64_u/spilled.wat
new file mode 100644
index 000000000000..a4589c1ca6a9
--- /dev/null
+++ b/tests/disas/winch/x64/f64_convert_i64_u/spilled.wat
@@ -0,0 +1,43 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        i64.const 1
+        f64.convert_i64_u
+        block
+        end
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x18, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x78
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rcx
+;;       cmpq    $0, %rcx
+;;       jl      0x46
+;;   3c: cvtsi2sdq %rcx, %xmm0
+;;       jmp     0x60
+;;   46: movq    %rcx, %r11
+;;       shrq    $1, %r11
+;;       movq    %rcx, %rax
+;;       andq    $1, %rax
+;;       orq     %r11, %rax
+;;       cvtsi2sdq %rax, %xmm0
+;;       addsd   %xmm0, %xmm0
+;;       subq    $8, %rsp
+;;       movsd   %xmm0, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       addq    $8, %rsp
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   78: ud2
diff --git a/tests/disas/winch/x64/f64_copysign/const.wat b/tests/disas/winch/x64/f64_copysign/const.wat
new file mode 100644
index 000000000000..de3c43a00716
--- /dev/null
+++ b/tests/disas/winch/x64/f64_copysign/const.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (f64.const -1.1)
+        (f64.const 2.2)
+        (f64.copysign)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x67
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movsd   0x3d(%rip), %xmm0
+;;       movsd   0x3d(%rip), %xmm1
+;;       movabsq $9223372036854775808, %r11
+;;       movq    %r11, %xmm15
+;;       andpd   %xmm15, %xmm0
+;;       andnpd  %xmm1, %xmm15
+;;       movapd  %xmm15, %xmm1
+;;       orpd    %xmm0, %xmm1
+;;       movapd  %xmm1, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   67: ud2
+;;   69: addb    %al, (%rax)
+;;   6b: addb    %al, (%rax)
+;;   6d: addb    %al, (%rax)
+;;   6f: addb    %bl, -0x66666667(%rdx)
+;;   75: cltd
+;;   76: addl    %eax, -0x66(%rax)
+;;   79: cltd
+;;   7a: cltd
+;;   7b: cltd
+;;   7c: cltd
+;;   7d: cltd
+;;   7e: int1
diff --git a/tests/disas/winch/x64/f64_copysign/locals.wat b/tests/disas/winch/x64/f64_copysign/locals.wat
new file mode 100644
index 000000000000..85fa03ca49e9
--- /dev/null
+++ b/tests/disas/winch/x64/f64_copysign/locals.wat
@@ -0,0 +1,53 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (local $foo f64)  
+        (local $bar f64)
+
+        (f64.const -1.1)
+        (local.set $foo)
+
+        (f64.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f64.copysign
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x8a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movsd   0x50(%rip), %xmm0
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   0x4a(%rip), %xmm0
+;;       movsd   %xmm0, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       movsd   8(%rsp), %xmm1
+;;       movabsq $9223372036854775808, %r11
+;;       movq    %r11, %xmm15
+;;       andpd   %xmm15, %xmm0
+;;       andnpd  %xmm1, %xmm15
+;;       movapd  %xmm15, %xmm1
+;;       orpd    %xmm0, %xmm1
+;;       movapd  %xmm1, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   8a: ud2
+;;   8c: addb    %al, (%rax)
+;;   8e: addb    %al, (%rax)
diff --git a/tests/disas/winch/x64/f64_copysign/params.wat b/tests/disas/winch/x64/f64_copysign/params.wat
new file mode 100644
index 000000000000..ef2066e7f71e
--- /dev/null
+++ b/tests/disas/winch/x64/f64_copysign/params.wat
@@ -0,0 +1,37 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (param f64) (result f64)
+        (local.get 0)
+        (local.get 1)
+        (f64.copysign)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   %xmm1, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       movsd   8(%rsp), %xmm1
+;;       movabsq $9223372036854775808, %r11
+;;       movq    %r11, %xmm15
+;;       andpd   %xmm15, %xmm0
+;;       andnpd  %xmm1, %xmm15
+;;       movapd  %xmm15, %xmm1
+;;       orpd    %xmm0, %xmm1
+;;       movapd  %xmm1, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6e: ud2
diff --git a/tests/disas/winch/x64/f64_div/const.wat b/tests/disas/winch/x64/f64_div/const.wat
new file mode 100644
index 000000000000..0277d1b76590
--- /dev/null
+++ b/tests/disas/winch/x64/f64_div/const.wat
@@ -0,0 +1,41 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (f64.const 1.1)
+        (f64.const 2.2)
+        (f64.div)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x49
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movsd   0x1d(%rip), %xmm0
+;;       movsd   0x1d(%rip), %xmm1
+;;       divsd   %xmm0, %xmm1
+;;       movapd  %xmm1, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   49: ud2
+;;   4b: addb    %al, (%rax)
+;;   4d: addb    %al, (%rax)
+;;   4f: addb    %bl, -0x66666667(%rdx)
+;;   55: cltd
+;;   56: addl    %eax, -0x66(%rax)
+;;   59: cltd
+;;   5a: cltd
+;;   5b: cltd
+;;   5c: cltd
+;;   5d: cltd
+;;   5e: int1
diff --git a/tests/disas/winch/x64/f64_div/locals.wat b/tests/disas/winch/x64/f64_div/locals.wat
new file mode 100644
index 000000000000..6b183e12893a
--- /dev/null
+++ b/tests/disas/winch/x64/f64_div/locals.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (local $foo f64)  
+        (local $bar f64)
+
+        (f64.const 1.1)
+        (local.set $foo)
+
+        (f64.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f64.div
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movsd   0x30(%rip), %xmm0
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   0x2a(%rip), %xmm0
+;;       movsd   %xmm0, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       movsd   8(%rsp), %xmm1
+;;       divsd   %xmm0, %xmm1
+;;       movapd  %xmm1, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6c: ud2
+;;   6e: addb    %al, (%rax)
diff --git a/tests/disas/winch/x64/f64_div/params.wat b/tests/disas/winch/x64/f64_div/params.wat
new file mode 100644
index 000000000000..45aebc48eb06
--- /dev/null
+++ b/tests/disas/winch/x64/f64_div/params.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (param f64) (result f64)
+        (local.get 0)
+        (local.get 1)
+        (f64.div)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x50
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   %xmm1, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       movsd   8(%rsp), %xmm1
+;;       divsd   %xmm0, %xmm1
+;;       movapd  %xmm1, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   50: ud2
diff --git a/tests/disas/winch/x64/f64_eq/const.wat b/tests/disas/winch/x64/f64_eq/const.wat
new file mode 100644
index 000000000000..52baa7ae50f7
--- /dev/null
+++ b/tests/disas/winch/x64/f64_eq/const.wat
@@ -0,0 +1,44 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (f64.const 1.1)
+        (f64.const 2.2)
+        (f64.eq)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x5b
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movsd   0x2d(%rip), %xmm0
+;;       movsd   0x2d(%rip), %xmm1
+;;       ucomisd %xmm0, %xmm1
+;;       movl    $0, %eax
+;;       sete    %al
+;;       movl    $0, %r11d
+;;       setnp   %r11b
+;;       andq    %r11, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   5b: ud2
+;;   5d: addb    %al, (%rax)
+;;   5f: addb    %bl, -0x66666667(%rdx)
+;;   65: cltd
+;;   66: addl    %eax, -0x66(%rax)
+;;   69: cltd
+;;   6a: cltd
+;;   6b: cltd
+;;   6c: cltd
+;;   6d: cltd
+;;   6e: int1
diff --git a/tests/disas/winch/x64/f64_eq/locals.wat b/tests/disas/winch/x64/f64_eq/locals.wat
new file mode 100644
index 000000000000..0efba13c5059
--- /dev/null
+++ b/tests/disas/winch/x64/f64_eq/locals.wat
@@ -0,0 +1,50 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo f64)  
+        (local $bar f64)
+
+        (f64.const 1.1)
+        (local.set $foo)
+
+        (f64.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f64.eq
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x7e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movsd   0x40(%rip), %xmm0
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   0x3a(%rip), %xmm0
+;;       movsd   %xmm0, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       movsd   8(%rsp), %xmm1
+;;       ucomisd %xmm0, %xmm1
+;;       movl    $0, %eax
+;;       sete    %al
+;;       movl    $0, %r11d
+;;       setnp   %r11b
+;;       andq    %r11, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   7e: ud2
diff --git a/tests/disas/winch/x64/f64_eq/params.wat b/tests/disas/winch/x64/f64_eq/params.wat
new file mode 100644
index 000000000000..acd66e9db9b1
--- /dev/null
+++ b/tests/disas/winch/x64/f64_eq/params.wat
@@ -0,0 +1,36 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (param f64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (f64.eq)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x62
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   %xmm1, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       movsd   8(%rsp), %xmm1
+;;       ucomisd %xmm0, %xmm1
+;;       movl    $0, %eax
+;;       sete    %al
+;;       movl    $0, %r11d
+;;       setnp   %r11b
+;;       andq    %r11, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   62: ud2
diff --git a/tests/disas/winch/x64/f64_floor/f64_floor_const_sse41.wat b/tests/disas/winch/x64/f64_floor/f64_floor_const_sse41.wat
new file mode 100644
index 000000000000..e3cc19067543
--- /dev/null
+++ b/tests/disas/winch/x64/f64_floor/f64_floor_const_sse41.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_sse41"]
+
+(module
+    (func (result f64)
+        (f64.const -1.32)
+        (f64.floor)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movsd   0x15(%rip), %xmm0
+;;       roundsd $1, %xmm0, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3f: ud2
+;;   41: addb    %al, (%rax)
+;;   43: addb    %al, (%rax)
+;;   45: addb    %al, (%rax)
+;;   47: addb    %bl, (%rdi)
+;;   49: testl   %ebp, %ebx
+;;   4b: pushq   %rcx
diff --git a/tests/disas/winch/x64/f64_floor/f64_floor_param.wat b/tests/disas/winch/x64/f64_floor/f64_floor_param.wat
new file mode 100644
index 000000000000..1c9c6d158d3a
--- /dev/null
+++ b/tests/disas/winch/x64/f64_floor/f64_floor_param.wat
@@ -0,0 +1,36 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (result f64)
+        (local.get 0)
+        (f64.floor)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x30, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   8(%rsp), %xmm15
+;;       subq    $8, %rsp
+;;       movsd   %xmm15, (%rsp)
+;;       subq    $8, %rsp
+;;       movsd   8(%rsp), %xmm0
+;;       movabsq $0, %r11
+;;       callq   *%r11
+;;       addq    $8, %rsp
+;;       addq    $8, %rsp
+;;       movq    0x18(%rsp), %r14
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6d: ud2
diff --git a/tests/disas/winch/x64/f64_floor/f64_floor_param_sse41.wat b/tests/disas/winch/x64/f64_floor/f64_floor_param_sse41.wat
new file mode 100644
index 000000000000..080b9d6f1905
--- /dev/null
+++ b/tests/disas/winch/x64/f64_floor/f64_floor_param_sse41.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_sse41"]
+
+(module
+    (func (param f64) (result f64)
+        (local.get 0)
+        (f64.floor)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x44
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   8(%rsp), %xmm0
+;;       roundsd $1, %xmm0, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   44: ud2
diff --git a/tests/disas/winch/x64/f64_ge/const.wat b/tests/disas/winch/x64/f64_ge/const.wat
new file mode 100644
index 000000000000..3272307c7125
--- /dev/null
+++ b/tests/disas/winch/x64/f64_ge/const.wat
@@ -0,0 +1,44 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (f64.const 1.1)
+        (f64.const 2.2)
+        (f64.ge)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x5b
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movsd   0x2d(%rip), %xmm0
+;;       movsd   0x2d(%rip), %xmm1
+;;       ucomisd %xmm0, %xmm1
+;;       movl    $0, %eax
+;;       setae   %al
+;;       movl    $0, %r11d
+;;       setnp   %r11b
+;;       andq    %r11, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   5b: ud2
+;;   5d: addb    %al, (%rax)
+;;   5f: addb    %bl, -0x66666667(%rdx)
+;;   65: cltd
+;;   66: addl    %eax, -0x66(%rax)
+;;   69: cltd
+;;   6a: cltd
+;;   6b: cltd
+;;   6c: cltd
+;;   6d: cltd
+;;   6e: int1
diff --git a/tests/disas/winch/x64/f64_ge/locals.wat b/tests/disas/winch/x64/f64_ge/locals.wat
new file mode 100644
index 000000000000..b1b4283d14a2
--- /dev/null
+++ b/tests/disas/winch/x64/f64_ge/locals.wat
@@ -0,0 +1,50 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo f64)  
+        (local $bar f64)
+
+        (f64.const 1.1)
+        (local.set $foo)
+
+        (f64.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f64.ge
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x7e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movsd   0x40(%rip), %xmm0
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   0x3a(%rip), %xmm0
+;;       movsd   %xmm0, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       movsd   8(%rsp), %xmm1
+;;       ucomisd %xmm0, %xmm1
+;;       movl    $0, %eax
+;;       setae   %al
+;;       movl    $0, %r11d
+;;       setnp   %r11b
+;;       andq    %r11, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   7e: ud2
diff --git a/tests/disas/winch/x64/f64_ge/params.wat b/tests/disas/winch/x64/f64_ge/params.wat
new file mode 100644
index 000000000000..3daa9b5c0d6a
--- /dev/null
+++ b/tests/disas/winch/x64/f64_ge/params.wat
@@ -0,0 +1,36 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (param f64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (f64.ge)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x62
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   %xmm1, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       movsd   8(%rsp), %xmm1
+;;       ucomisd %xmm0, %xmm1
+;;       movl    $0, %eax
+;;       setae   %al
+;;       movl    $0, %r11d
+;;       setnp   %r11b
+;;       andq    %r11, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   62: ud2
diff --git a/tests/disas/winch/x64/f64_gt/const.wat b/tests/disas/winch/x64/f64_gt/const.wat
new file mode 100644
index 000000000000..6190cc35352b
--- /dev/null
+++ b/tests/disas/winch/x64/f64_gt/const.wat
@@ -0,0 +1,44 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (f64.const 1.1)
+        (f64.const 2.2)
+        (f64.gt)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x5b
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movsd   0x2d(%rip), %xmm0
+;;       movsd   0x2d(%rip), %xmm1
+;;       ucomisd %xmm0, %xmm1
+;;       movl    $0, %eax
+;;       seta    %al
+;;       movl    $0, %r11d
+;;       setnp   %r11b
+;;       andq    %r11, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   5b: ud2
+;;   5d: addb    %al, (%rax)
+;;   5f: addb    %bl, -0x66666667(%rdx)
+;;   65: cltd
+;;   66: addl    %eax, -0x66(%rax)
+;;   69: cltd
+;;   6a: cltd
+;;   6b: cltd
+;;   6c: cltd
+;;   6d: cltd
+;;   6e: int1
diff --git a/tests/disas/winch/x64/f64_gt/locals.wat b/tests/disas/winch/x64/f64_gt/locals.wat
new file mode 100644
index 000000000000..76130c7f4b56
--- /dev/null
+++ b/tests/disas/winch/x64/f64_gt/locals.wat
@@ -0,0 +1,50 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo f64)  
+        (local $bar f64)
+
+        (f64.const 1.1)
+        (local.set $foo)
+
+        (f64.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f64.gt
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x7e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movsd   0x40(%rip), %xmm0
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   0x3a(%rip), %xmm0
+;;       movsd   %xmm0, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       movsd   8(%rsp), %xmm1
+;;       ucomisd %xmm0, %xmm1
+;;       movl    $0, %eax
+;;       seta    %al
+;;       movl    $0, %r11d
+;;       setnp   %r11b
+;;       andq    %r11, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   7e: ud2
diff --git a/tests/disas/winch/x64/f64_gt/params.wat b/tests/disas/winch/x64/f64_gt/params.wat
new file mode 100644
index 000000000000..cb55a02f5183
--- /dev/null
+++ b/tests/disas/winch/x64/f64_gt/params.wat
@@ -0,0 +1,36 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (param f64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (f64.gt)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x62
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   %xmm1, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       movsd   8(%rsp), %xmm1
+;;       ucomisd %xmm0, %xmm1
+;;       movl    $0, %eax
+;;       seta    %al
+;;       movl    $0, %r11d
+;;       setnp   %r11b
+;;       andq    %r11, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   62: ud2
diff --git a/tests/disas/winch/x64/f64_le/const.wat b/tests/disas/winch/x64/f64_le/const.wat
new file mode 100644
index 000000000000..1f0333ca1325
--- /dev/null
+++ b/tests/disas/winch/x64/f64_le/const.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (f64.const 1.1)
+        (f64.const 2.2)
+        (f64.le)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movsd   0x1d(%rip), %xmm0
+;;       movsd   0x1d(%rip), %xmm1
+;;       ucomisd %xmm1, %xmm0
+;;       movl    $0, %eax
+;;       setae   %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4e: ud2
diff --git a/tests/disas/winch/x64/f64_le/locals.wat b/tests/disas/winch/x64/f64_le/locals.wat
new file mode 100644
index 000000000000..4a7f1bce6e88
--- /dev/null
+++ b/tests/disas/winch/x64/f64_le/locals.wat
@@ -0,0 +1,52 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo f64)  
+        (local $bar f64)
+
+        (f64.const 1.1)
+        (local.set $foo)
+
+        (f64.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f64.le
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x71
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movsd   0x38(%rip), %xmm0
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   0x32(%rip), %xmm0
+;;       movsd   %xmm0, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       movsd   8(%rsp), %xmm1
+;;       ucomisd %xmm1, %xmm0
+;;       movl    $0, %eax
+;;       setae   %al
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   71: ud2
+;;   73: addb    %al, (%rax)
+;;   75: addb    %al, (%rax)
+;;   77: addb    %bl, -0x66666667(%rdx)
+;;   7d: cltd
+;;   7e: int1
diff --git a/tests/disas/winch/x64/f64_le/params.wat b/tests/disas/winch/x64/f64_le/params.wat
new file mode 100644
index 000000000000..4a7f1bce6e88
--- /dev/null
+++ b/tests/disas/winch/x64/f64_le/params.wat
@@ -0,0 +1,52 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo f64)  
+        (local $bar f64)
+
+        (f64.const 1.1)
+        (local.set $foo)
+
+        (f64.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f64.le
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x71
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movsd   0x38(%rip), %xmm0
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   0x32(%rip), %xmm0
+;;       movsd   %xmm0, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       movsd   8(%rsp), %xmm1
+;;       ucomisd %xmm1, %xmm0
+;;       movl    $0, %eax
+;;       setae   %al
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   71: ud2
+;;   73: addb    %al, (%rax)
+;;   75: addb    %al, (%rax)
+;;   77: addb    %bl, -0x66666667(%rdx)
+;;   7d: cltd
+;;   7e: int1
diff --git a/tests/disas/winch/x64/f64_lt/const.wat b/tests/disas/winch/x64/f64_lt/const.wat
new file mode 100644
index 000000000000..a87a64568252
--- /dev/null
+++ b/tests/disas/winch/x64/f64_lt/const.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (f64.const 1.1)
+        (f64.const 2.2)
+        (f64.lt)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movsd   0x1d(%rip), %xmm0
+;;       movsd   0x1d(%rip), %xmm1
+;;       ucomisd %xmm1, %xmm0
+;;       movl    $0, %eax
+;;       seta    %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4e: ud2
diff --git a/tests/disas/winch/x64/f64_lt/locals.wat b/tests/disas/winch/x64/f64_lt/locals.wat
new file mode 100644
index 000000000000..d6a771d1dcf4
--- /dev/null
+++ b/tests/disas/winch/x64/f64_lt/locals.wat
@@ -0,0 +1,52 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo f64)  
+        (local $bar f64)
+
+        (f64.const 1.1)
+        (local.set $foo)
+
+        (f64.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f64.lt
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x71
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movsd   0x38(%rip), %xmm0
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   0x32(%rip), %xmm0
+;;       movsd   %xmm0, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       movsd   8(%rsp), %xmm1
+;;       ucomisd %xmm1, %xmm0
+;;       movl    $0, %eax
+;;       seta    %al
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   71: ud2
+;;   73: addb    %al, (%rax)
+;;   75: addb    %al, (%rax)
+;;   77: addb    %bl, -0x66666667(%rdx)
+;;   7d: cltd
+;;   7e: int1
diff --git a/tests/disas/winch/x64/f64_lt/params.wat b/tests/disas/winch/x64/f64_lt/params.wat
new file mode 100644
index 000000000000..6a34ab7029cc
--- /dev/null
+++ b/tests/disas/winch/x64/f64_lt/params.wat
@@ -0,0 +1,33 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (param f64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (f64.lt)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x55
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   %xmm1, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       movsd   8(%rsp), %xmm1
+;;       ucomisd %xmm1, %xmm0
+;;       movl    $0, %eax
+;;       seta    %al
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   55: ud2
diff --git a/tests/disas/winch/x64/f64_max/const.wat b/tests/disas/winch/x64/f64_max/const.wat
new file mode 100644
index 000000000000..016dec397f3b
--- /dev/null
+++ b/tests/disas/winch/x64/f64_max/const.wat
@@ -0,0 +1,38 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (f64.const 1.1)
+        (f64.const 2.2)
+        (f64.max)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movsd   0x3d(%rip), %xmm0
+;;       movsd   0x3d(%rip), %xmm1
+;;       ucomisd %xmm0, %xmm1
+;;       jne     0x5e
+;;       jp      0x54
+;;   4b: andpd   %xmm0, %xmm1
+;;       jmp     0x62
+;;   54: addsd   %xmm0, %xmm1
+;;       jp      0x62
+;;   5e: maxsd   %xmm0, %xmm1
+;;       movapd  %xmm1, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6c: ud2
+;;   6e: addb    %al, (%rax)
diff --git a/tests/disas/winch/x64/f64_max/locals.wat b/tests/disas/winch/x64/f64_max/locals.wat
new file mode 100644
index 000000000000..cd54a0dc894a
--- /dev/null
+++ b/tests/disas/winch/x64/f64_max/locals.wat
@@ -0,0 +1,59 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (local $foo f64)  
+        (local $bar f64)
+
+        (f64.const 1.1)
+        (local.set $foo)
+
+        (f64.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f64.max
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x8f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movsd   0x58(%rip), %xmm0
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   0x52(%rip), %xmm0
+;;       movsd   %xmm0, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       movsd   8(%rsp), %xmm1
+;;       ucomisd %xmm0, %xmm1
+;;       jne     0x81
+;;       jp      0x77
+;;   6e: andpd   %xmm0, %xmm1
+;;       jmp     0x85
+;;   77: addsd   %xmm0, %xmm1
+;;       jp      0x85
+;;   81: maxsd   %xmm0, %xmm1
+;;       movapd  %xmm1, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   8f: ud2
+;;   91: addb    %al, (%rax)
+;;   93: addb    %al, (%rax)
+;;   95: addb    %al, (%rax)
+;;   97: addb    %bl, -0x66666667(%rdx)
+;;   9d: cltd
+;;   9e: int1
diff --git a/tests/disas/winch/x64/f64_max/params.wat b/tests/disas/winch/x64/f64_max/params.wat
new file mode 100644
index 000000000000..ef3ffd9deb77
--- /dev/null
+++ b/tests/disas/winch/x64/f64_max/params.wat
@@ -0,0 +1,39 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (param f64) (result f64)
+        (local.get 0)
+        (local.get 1)
+        (f64.max)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x73
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   %xmm1, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       movsd   8(%rsp), %xmm1
+;;       ucomisd %xmm0, %xmm1
+;;       jne     0x65
+;;       jp      0x5b
+;;   52: andpd   %xmm0, %xmm1
+;;       jmp     0x69
+;;   5b: addsd   %xmm0, %xmm1
+;;       jp      0x69
+;;   65: maxsd   %xmm0, %xmm1
+;;       movapd  %xmm1, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   73: ud2
diff --git a/tests/disas/winch/x64/f64_min/const.wat b/tests/disas/winch/x64/f64_min/const.wat
new file mode 100644
index 000000000000..3cdbe17016b9
--- /dev/null
+++ b/tests/disas/winch/x64/f64_min/const.wat
@@ -0,0 +1,38 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (f64.const 1.1)
+        (f64.const 2.2)
+        (f64.min)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movsd   0x3d(%rip), %xmm0
+;;       movsd   0x3d(%rip), %xmm1
+;;       ucomisd %xmm0, %xmm1
+;;       jne     0x5e
+;;       jp      0x54
+;;   4b: orpd    %xmm0, %xmm1
+;;       jmp     0x62
+;;   54: addsd   %xmm0, %xmm1
+;;       jp      0x62
+;;   5e: minsd   %xmm0, %xmm1
+;;       movapd  %xmm1, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6c: ud2
+;;   6e: addb    %al, (%rax)
diff --git a/tests/disas/winch/x64/f64_min/locals.wat b/tests/disas/winch/x64/f64_min/locals.wat
new file mode 100644
index 000000000000..785591d45ef6
--- /dev/null
+++ b/tests/disas/winch/x64/f64_min/locals.wat
@@ -0,0 +1,59 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (local $foo f64)  
+        (local $bar f64)
+
+        (f64.const 1.1)
+        (local.set $foo)
+
+        (f64.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f64.min
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x8f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movsd   0x58(%rip), %xmm0
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   0x52(%rip), %xmm0
+;;       movsd   %xmm0, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       movsd   8(%rsp), %xmm1
+;;       ucomisd %xmm0, %xmm1
+;;       jne     0x81
+;;       jp      0x77
+;;   6e: orpd    %xmm0, %xmm1
+;;       jmp     0x85
+;;   77: addsd   %xmm0, %xmm1
+;;       jp      0x85
+;;   81: minsd   %xmm0, %xmm1
+;;       movapd  %xmm1, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   8f: ud2
+;;   91: addb    %al, (%rax)
+;;   93: addb    %al, (%rax)
+;;   95: addb    %al, (%rax)
+;;   97: addb    %bl, -0x66666667(%rdx)
+;;   9d: cltd
+;;   9e: int1
diff --git a/tests/disas/winch/x64/f64_min/params.wat b/tests/disas/winch/x64/f64_min/params.wat
new file mode 100644
index 000000000000..12d130888258
--- /dev/null
+++ b/tests/disas/winch/x64/f64_min/params.wat
@@ -0,0 +1,39 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (param f64) (result f64)
+        (local.get 0)
+        (local.get 1)
+        (f64.min)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x73
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   %xmm1, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       movsd   8(%rsp), %xmm1
+;;       ucomisd %xmm0, %xmm1
+;;       jne     0x65
+;;       jp      0x5b
+;;   52: orpd    %xmm0, %xmm1
+;;       jmp     0x69
+;;   5b: addsd   %xmm0, %xmm1
+;;       jp      0x69
+;;   65: minsd   %xmm0, %xmm1
+;;       movapd  %xmm1, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   73: ud2
diff --git a/tests/disas/winch/x64/f64_mul/const.wat b/tests/disas/winch/x64/f64_mul/const.wat
new file mode 100644
index 000000000000..88ce38431b2e
--- /dev/null
+++ b/tests/disas/winch/x64/f64_mul/const.wat
@@ -0,0 +1,41 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (f64.const 1.1)
+        (f64.const 2.2)
+        (f64.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x49
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movsd   0x1d(%rip), %xmm0
+;;       movsd   0x1d(%rip), %xmm1
+;;       mulsd   %xmm0, %xmm1
+;;       movapd  %xmm1, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   49: ud2
+;;   4b: addb    %al, (%rax)
+;;   4d: addb    %al, (%rax)
+;;   4f: addb    %bl, -0x66666667(%rdx)
+;;   55: cltd
+;;   56: addl    %eax, -0x66(%rax)
+;;   59: cltd
+;;   5a: cltd
+;;   5b: cltd
+;;   5c: cltd
+;;   5d: cltd
+;;   5e: int1
diff --git a/tests/disas/winch/x64/f64_mul/locals.wat b/tests/disas/winch/x64/f64_mul/locals.wat
new file mode 100644
index 000000000000..9e8f51066525
--- /dev/null
+++ b/tests/disas/winch/x64/f64_mul/locals.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (local $foo f64)  
+        (local $bar f64)
+
+        (f64.const 1.1)
+        (local.set $foo)
+
+        (f64.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f64.mul
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movsd   0x30(%rip), %xmm0
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   0x2a(%rip), %xmm0
+;;       movsd   %xmm0, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       movsd   8(%rsp), %xmm1
+;;       mulsd   %xmm0, %xmm1
+;;       movapd  %xmm1, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6c: ud2
+;;   6e: addb    %al, (%rax)
diff --git a/tests/disas/winch/x64/f64_mul/params.wat b/tests/disas/winch/x64/f64_mul/params.wat
new file mode 100644
index 000000000000..6a0ee16c5ff0
--- /dev/null
+++ b/tests/disas/winch/x64/f64_mul/params.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (param f64) (result f64)
+        (local.get 0)
+        (local.get 1)
+        (f64.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x50
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   %xmm1, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       movsd   8(%rsp), %xmm1
+;;       mulsd   %xmm0, %xmm1
+;;       movapd  %xmm1, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   50: ud2
diff --git a/tests/disas/winch/x64/f64_ne/const.wat b/tests/disas/winch/x64/f64_ne/const.wat
new file mode 100644
index 000000000000..8fc3e6fe6884
--- /dev/null
+++ b/tests/disas/winch/x64/f64_ne/const.wat
@@ -0,0 +1,44 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (f64.const 1.1)
+        (f64.const 2.2)
+        (f64.ne)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x5b
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movsd   0x2d(%rip), %xmm0
+;;       movsd   0x2d(%rip), %xmm1
+;;       ucomisd %xmm0, %xmm1
+;;       movl    $0, %eax
+;;       setne   %al
+;;       movl    $0, %r11d
+;;       setp    %r11b
+;;       orq     %r11, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   5b: ud2
+;;   5d: addb    %al, (%rax)
+;;   5f: addb    %bl, -0x66666667(%rdx)
+;;   65: cltd
+;;   66: addl    %eax, -0x66(%rax)
+;;   69: cltd
+;;   6a: cltd
+;;   6b: cltd
+;;   6c: cltd
+;;   6d: cltd
+;;   6e: int1
diff --git a/tests/disas/winch/x64/f64_ne/locals.wat b/tests/disas/winch/x64/f64_ne/locals.wat
new file mode 100644
index 000000000000..a1c322ab7a48
--- /dev/null
+++ b/tests/disas/winch/x64/f64_ne/locals.wat
@@ -0,0 +1,50 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo f64)  
+        (local $bar f64)
+
+        (f64.const 1.1)
+        (local.set $foo)
+
+        (f64.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f64.ne
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x7e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movsd   0x40(%rip), %xmm0
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   0x3a(%rip), %xmm0
+;;       movsd   %xmm0, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       movsd   8(%rsp), %xmm1
+;;       ucomisd %xmm0, %xmm1
+;;       movl    $0, %eax
+;;       setne   %al
+;;       movl    $0, %r11d
+;;       setp    %r11b
+;;       orq     %r11, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   7e: ud2
diff --git a/tests/disas/winch/x64/f64_ne/params.wat b/tests/disas/winch/x64/f64_ne/params.wat
new file mode 100644
index 000000000000..84a01f3919cb
--- /dev/null
+++ b/tests/disas/winch/x64/f64_ne/params.wat
@@ -0,0 +1,36 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (param f64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (f64.ne)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x62
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   %xmm1, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       movsd   8(%rsp), %xmm1
+;;       ucomisd %xmm0, %xmm1
+;;       movl    $0, %eax
+;;       setne   %al
+;;       movl    $0, %r11d
+;;       setp    %r11b
+;;       orq     %r11, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   62: ud2
diff --git a/tests/disas/winch/x64/f64_nearest/f64_nearest_const_sse41.wat b/tests/disas/winch/x64/f64_nearest/f64_nearest_const_sse41.wat
new file mode 100644
index 000000000000..1fb11ce99ab0
--- /dev/null
+++ b/tests/disas/winch/x64/f64_nearest/f64_nearest_const_sse41.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_sse41"]
+
+(module
+    (func (result f64)
+        (f64.const -1.32)
+        (f64.nearest)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movsd   0x15(%rip), %xmm0
+;;       roundsd $0, %xmm0, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3f: ud2
+;;   41: addb    %al, (%rax)
+;;   43: addb    %al, (%rax)
+;;   45: addb    %al, (%rax)
+;;   47: addb    %bl, (%rdi)
+;;   49: testl   %ebp, %ebx
+;;   4b: pushq   %rcx
diff --git a/tests/disas/winch/x64/f64_nearest/f64_nearest_param.wat b/tests/disas/winch/x64/f64_nearest/f64_nearest_param.wat
new file mode 100644
index 000000000000..a97dee25e041
--- /dev/null
+++ b/tests/disas/winch/x64/f64_nearest/f64_nearest_param.wat
@@ -0,0 +1,36 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (result f64)
+        (local.get 0)
+        (f64.nearest)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x30, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   8(%rsp), %xmm15
+;;       subq    $8, %rsp
+;;       movsd   %xmm15, (%rsp)
+;;       subq    $8, %rsp
+;;       movsd   8(%rsp), %xmm0
+;;       movabsq $0, %r11
+;;       callq   *%r11
+;;       addq    $8, %rsp
+;;       addq    $8, %rsp
+;;       movq    0x18(%rsp), %r14
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6d: ud2
diff --git a/tests/disas/winch/x64/f64_nearest/f64_nearest_param_sse41.wat b/tests/disas/winch/x64/f64_nearest/f64_nearest_param_sse41.wat
new file mode 100644
index 000000000000..8534b826dfb4
--- /dev/null
+++ b/tests/disas/winch/x64/f64_nearest/f64_nearest_param_sse41.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_sse41"]
+
+(module
+    (func (param f64) (result f64)
+        (local.get 0)
+        (f64.nearest)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x44
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   8(%rsp), %xmm0
+;;       roundsd $0, %xmm0, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   44: ud2
diff --git a/tests/disas/winch/x64/f64_neg/f64_neg_const.wat b/tests/disas/winch/x64/f64_neg/f64_neg_const.wat
new file mode 100644
index 000000000000..b94a507ef805
--- /dev/null
+++ b/tests/disas/winch/x64/f64_neg/f64_neg_const.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (f64.const -1.32)
+        (f64.neg)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movsd   0x1d(%rip), %xmm0
+;;       movabsq $9223372036854775808, %r11
+;;       movq    %r11, %xmm15
+;;       xorpd   %xmm15, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4d: ud2
+;;   4f: addb    %bl, (%rdi)
+;;   51: testl   %ebp, %ebx
+;;   53: pushq   %rcx
diff --git a/tests/disas/winch/x64/f64_neg/f64_neg_param.wat b/tests/disas/winch/x64/f64_neg/f64_neg_param.wat
new file mode 100644
index 000000000000..7eebf41f6128
--- /dev/null
+++ b/tests/disas/winch/x64/f64_neg/f64_neg_param.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (result f64)
+        (local.get 0)
+        (f64.neg)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x52
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   8(%rsp), %xmm0
+;;       movabsq $9223372036854775808, %r11
+;;       movq    %r11, %xmm15
+;;       xorpd   %xmm15, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   52: ud2
diff --git a/tests/disas/winch/x64/f64_promote_f32/const.wat b/tests/disas/winch/x64/f64_promote_f32/const.wat
new file mode 100644
index 000000000000..bf6007a5f926
--- /dev/null
+++ b/tests/disas/winch/x64/f64_promote_f32/const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (f32.const 1.0)
+        (f64.promote_f32)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movss   0xd(%rip), %xmm0
+;;       cvtss2sd %xmm0, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3d: ud2
+;;   3f: addb    %al, (%rax)
diff --git a/tests/disas/winch/x64/f64_promote_f32/locals.wat b/tests/disas/winch/x64/f64_promote_f32/locals.wat
new file mode 100644
index 000000000000..5a97ad1fed3a
--- /dev/null
+++ b/tests/disas/winch/x64/f64_promote_f32/locals.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (local f32)  
+
+        (local.get 0)
+        (f64.promote_f32)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x45
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movss   0xc(%rsp), %xmm0
+;;       cvtss2sd %xmm0, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   45: ud2
diff --git a/tests/disas/winch/x64/f64_promote_f32/params.wat b/tests/disas/winch/x64/f64_promote_f32/params.wat
new file mode 100644
index 000000000000..d8e2658cf37d
--- /dev/null
+++ b/tests/disas/winch/x64/f64_promote_f32/params.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (result f64)
+        (local.get 0)
+        (f64.promote_f32)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x42
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0xc(%rsp), %xmm0
+;;       cvtss2sd %xmm0, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   42: ud2
diff --git a/tests/disas/winch/x64/f64_promote_f32/spilled.wat b/tests/disas/winch/x64/f64_promote_f32/spilled.wat
new file mode 100644
index 000000000000..e23b0ef53ae7
--- /dev/null
+++ b/tests/disas/winch/x64/f64_promote_f32/spilled.wat
@@ -0,0 +1,37 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        f32.const 1.0
+        f64.promote_f32
+        block
+        end
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x18, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movss   0x25(%rip), %xmm0
+;;       cvtss2sd %xmm0, %xmm0
+;;       subq    $8, %rsp
+;;       movsd   %xmm0, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       addq    $8, %rsp
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4f: ud2
+;;   51: addb    %al, (%rax)
+;;   53: addb    %al, (%rax)
+;;   55: addb    %al, (%rax)
+;;   57: addb    %al, (%rax)
diff --git a/tests/disas/winch/x64/f64_reinterpret_i64/const.wat b/tests/disas/winch/x64/f64_reinterpret_i64/const.wat
new file mode 100644
index 000000000000..6fbb0d49c049
--- /dev/null
+++ b/tests/disas/winch/x64/f64_reinterpret_i64/const.wat
@@ -0,0 +1,27 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (i64.const 1)
+        (f64.reinterpret_i64)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       movq    %rax, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3d: ud2
diff --git a/tests/disas/winch/x64/f64_reinterpret_i64/locals.wat b/tests/disas/winch/x64/f64_reinterpret_i64/locals.wat
new file mode 100644
index 000000000000..133adaa90357
--- /dev/null
+++ b/tests/disas/winch/x64/f64_reinterpret_i64/locals.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (local i64)  
+
+        (local.get 0)
+        (f64.reinterpret_i64)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x45
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movq    8(%rsp), %rax
+;;       movq    %rax, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   45: ud2
diff --git a/tests/disas/winch/x64/f64_reinterpret_i64/params.wat b/tests/disas/winch/x64/f64_reinterpret_i64/params.wat
new file mode 100644
index 000000000000..70e496b8d11c
--- /dev/null
+++ b/tests/disas/winch/x64/f64_reinterpret_i64/params.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (result f64)
+        (local.get 0)
+        (f64.reinterpret_i64)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x41
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    8(%rsp), %rax
+;;       movq    %rax, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   41: ud2
diff --git a/tests/disas/winch/x64/f64_reinterpret_i64/ret_int.wat b/tests/disas/winch/x64/f64_reinterpret_i64/ret_int.wat
new file mode 100644
index 000000000000..4df7a8e36890
--- /dev/null
+++ b/tests/disas/winch/x64/f64_reinterpret_i64/ret_int.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        i64.const 1
+        f64.reinterpret_i64
+        drop
+        i64.const 1
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x44
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       movq    %rax, %xmm0
+;;       movq    $1, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   44: ud2
diff --git a/tests/disas/winch/x64/f64_reinterpret_i64/spilled.wat b/tests/disas/winch/x64/f64_reinterpret_i64/spilled.wat
new file mode 100644
index 000000000000..406792977d8a
--- /dev/null
+++ b/tests/disas/winch/x64/f64_reinterpret_i64/spilled.wat
@@ -0,0 +1,33 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        i64.const 1
+        f64.reinterpret_i64
+        block
+        end
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x18, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       movq    %rax, %xmm0
+;;       subq    $8, %rsp
+;;       movsd   %xmm0, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       addq    $8, %rsp
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4f: ud2
diff --git a/tests/disas/winch/x64/f64_sqrt/f64_sqrt_const.wat b/tests/disas/winch/x64/f64_sqrt/f64_sqrt_const.wat
new file mode 100644
index 000000000000..6014fb412d8d
--- /dev/null
+++ b/tests/disas/winch/x64/f64_sqrt/f64_sqrt_const.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (f64.const 1.32)
+        (f64.sqrt)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movsd   0xd(%rip), %xmm0
+;;       sqrtsd  %xmm0, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3d: ud2
+;;   3f: addb    %bl, (%rdi)
+;;   41: testl   %ebp, %ebx
+;;   43: pushq   %rcx
diff --git a/tests/disas/winch/x64/f64_sqrt/f64_sqrt_param.wat b/tests/disas/winch/x64/f64_sqrt/f64_sqrt_param.wat
new file mode 100644
index 000000000000..395ee90ce7c3
--- /dev/null
+++ b/tests/disas/winch/x64/f64_sqrt/f64_sqrt_param.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (result f64)
+        (local.get 0)
+        (f64.sqrt)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x42
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   8(%rsp), %xmm0
+;;       sqrtsd  %xmm0, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   42: ud2
diff --git a/tests/disas/winch/x64/f64_sub/const.wat b/tests/disas/winch/x64/f64_sub/const.wat
new file mode 100644
index 000000000000..d02a9496d1d6
--- /dev/null
+++ b/tests/disas/winch/x64/f64_sub/const.wat
@@ -0,0 +1,41 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (f64.const 1.1)
+        (f64.const 2.2)
+        (f64.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x49
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movsd   0x1d(%rip), %xmm0
+;;       movsd   0x1d(%rip), %xmm1
+;;       subsd   %xmm0, %xmm1
+;;       movapd  %xmm1, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   49: ud2
+;;   4b: addb    %al, (%rax)
+;;   4d: addb    %al, (%rax)
+;;   4f: addb    %bl, -0x66666667(%rdx)
+;;   55: cltd
+;;   56: addl    %eax, -0x66(%rax)
+;;   59: cltd
+;;   5a: cltd
+;;   5b: cltd
+;;   5c: cltd
+;;   5d: cltd
+;;   5e: int1
diff --git a/tests/disas/winch/x64/f64_sub/locals.wat b/tests/disas/winch/x64/f64_sub/locals.wat
new file mode 100644
index 000000000000..11f7d41ea664
--- /dev/null
+++ b/tests/disas/winch/x64/f64_sub/locals.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        (local $foo f64)  
+        (local $bar f64)
+
+        (f64.const 1.1)
+        (local.set $foo)
+
+        (f64.const 2.2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        f64.sub
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movsd   0x30(%rip), %xmm0
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   0x2a(%rip), %xmm0
+;;       movsd   %xmm0, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       movsd   8(%rsp), %xmm1
+;;       subsd   %xmm0, %xmm1
+;;       movapd  %xmm1, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6c: ud2
+;;   6e: addb    %al, (%rax)
diff --git a/tests/disas/winch/x64/f64_sub/params.wat b/tests/disas/winch/x64/f64_sub/params.wat
new file mode 100644
index 000000000000..2bfd0e23dc45
--- /dev/null
+++ b/tests/disas/winch/x64/f64_sub/params.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (param f64) (result f64)
+        (local.get 0)
+        (local.get 1)
+        (f64.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x50
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   %xmm1, (%rsp)
+;;       movsd   (%rsp), %xmm0
+;;       movsd   8(%rsp), %xmm1
+;;       subsd   %xmm0, %xmm1
+;;       movapd  %xmm1, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   50: ud2
diff --git a/tests/disas/winch/x64/f64_trunc/f64_trunc_const_sse41.wat b/tests/disas/winch/x64/f64_trunc/f64_trunc_const_sse41.wat
new file mode 100644
index 000000000000..b952e039af90
--- /dev/null
+++ b/tests/disas/winch/x64/f64_trunc/f64_trunc_const_sse41.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_sse41"]
+
+(module
+    (func (result f64)
+        (f64.const -1.32)
+        (f64.trunc)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movsd   0x15(%rip), %xmm0
+;;       roundsd $3, %xmm0, %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3f: ud2
+;;   41: addb    %al, (%rax)
+;;   43: addb    %al, (%rax)
+;;   45: addb    %al, (%rax)
+;;   47: addb    %bl, (%rdi)
+;;   49: testl   %ebp, %ebx
+;;   4b: pushq   %rcx
diff --git a/tests/disas/winch/x64/f64_trunc/f64_trunc_param.wat b/tests/disas/winch/x64/f64_trunc/f64_trunc_param.wat
new file mode 100644
index 000000000000..a8837dba16c7
--- /dev/null
+++ b/tests/disas/winch/x64/f64_trunc/f64_trunc_param.wat
@@ -0,0 +1,36 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (result f64)
+        (local.get 0)
+        (f64.trunc)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x30, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   8(%rsp), %xmm15
+;;       subq    $8, %rsp
+;;       movsd   %xmm15, (%rsp)
+;;       subq    $8, %rsp
+;;       movsd   8(%rsp), %xmm0
+;;       movabsq $0, %r11
+;;       callq   *%r11
+;;       addq    $8, %rsp
+;;       addq    $8, %rsp
+;;       movq    0x18(%rsp), %r14
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6d: ud2
diff --git a/tests/disas/winch/x64/f64_trunc/f64_trunc_param_sse41.wat b/tests/disas/winch/x64/f64_trunc/f64_trunc_param_sse41.wat
new file mode 100644
index 000000000000..0afaa68f8244
--- /dev/null
+++ b/tests/disas/winch/x64/f64_trunc/f64_trunc_param_sse41.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_sse41"]
+
+(module
+    (func (param f64) (result f64)
+        (local.get 0)
+        (f64.trunc)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x44
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   8(%rsp), %xmm0
+;;       roundsd $3, %xmm0, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   44: ud2
diff --git a/tests/disas/winch/x64/i32_add/const.wat b/tests/disas/winch/x64/i32_add/const.wat
new file mode 100644
index 000000000000..c7791e510638
--- /dev/null
+++ b/tests/disas/winch/x64/i32_add/const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const 10)
+	(i32.const 20)
+	(i32.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0xa, %eax
+;;       addl    $0x14, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_add/locals.wat b/tests/disas/winch/x64/i32_add/locals.wat
new file mode 100644
index 000000000000..27ab1335452f
--- /dev/null
+++ b/tests/disas/winch/x64/i32_add/locals.wat
@@ -0,0 +1,44 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)  
+        (local $bar i32)
+
+        (i32.const 10)
+        (local.set $foo)
+
+        (i32.const 20)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        i32.add
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x59
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $0xa, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    $0x14, %eax
+;;       movl    %eax, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       addl    %eax, %ecx
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   59: ud2
diff --git a/tests/disas/winch/x64/i32_add/max.wat b/tests/disas/winch/x64/i32_add/max.wat
new file mode 100644
index 000000000000..5afae0576253
--- /dev/null
+++ b/tests/disas/winch/x64/i32_add/max.wat
@@ -0,0 +1,27 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+    (func (result i32)
+	(i32.const 0x7fffffff)
+	(i32.const 1)
+	(i32.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0x7fffffff, %eax
+;;       addl    $1, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_add/max_one.wat b/tests/disas/winch/x64/i32_add/max_one.wat
new file mode 100644
index 000000000000..f37ee356c84a
--- /dev/null
+++ b/tests/disas/winch/x64/i32_add/max_one.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const 0x80000000)
+	(i32.const -1)
+	(i32.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0x80000000, %eax
+;;       addl    $-1, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_add/mixed.wat b/tests/disas/winch/x64/i32_add/mixed.wat
new file mode 100644
index 000000000000..057ef24f4fde
--- /dev/null
+++ b/tests/disas/winch/x64/i32_add/mixed.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const -1)
+	(i32.const 1)
+	(i32.add)
+     )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0xffffffff, %eax
+;;       addl    $1, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_add/params.wat b/tests/disas/winch/x64/i32_add/params.wat
new file mode 100644
index 000000000000..013fa6a45eaf
--- /dev/null
+++ b/tests/disas/winch/x64/i32_add/params.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+	(local.get 0)
+	(local.get 1)
+	(i32.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x46
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       addl    %eax, %ecx
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   46: ud2
diff --git a/tests/disas/winch/x64/i32_add/signed.wat b/tests/disas/winch/x64/i32_add/signed.wat
new file mode 100644
index 000000000000..a5a115a4b213
--- /dev/null
+++ b/tests/disas/winch/x64/i32_add/signed.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const -1)
+	(i32.const -1)
+	(i32.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0xffffffff, %eax
+;;       addl    $-1, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_add/unsigned_with_zero.wat b/tests/disas/winch/x64/i32_add/unsigned_with_zero.wat
new file mode 100644
index 000000000000..ae0e2409b16c
--- /dev/null
+++ b/tests/disas/winch/x64/i32_add/unsigned_with_zero.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+     	(i32.const 0)
+    	(i32.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       addl    $0, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_and/const.wat b/tests/disas/winch/x64/i32_and/const.wat
new file mode 100644
index 000000000000..8984367c73e6
--- /dev/null
+++ b/tests/disas/winch/x64/i32_and/const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 2)
+        (i32.and)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       andl    $2, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_and/locals.wat b/tests/disas/winch/x64/i32_and/locals.wat
new file mode 100644
index 000000000000..e130e200b77a
--- /dev/null
+++ b/tests/disas/winch/x64/i32_and/locals.wat
@@ -0,0 +1,44 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)  
+        (local $bar i32)
+
+        (i32.const 1)
+        (local.set $foo)
+
+        (i32.const 2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.and)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x59
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $1, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    $2, %eax
+;;       movl    %eax, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       andl    %eax, %ecx
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   59: ud2
diff --git a/tests/disas/winch/x64/i32_and/params.wat b/tests/disas/winch/x64/i32_and/params.wat
new file mode 100644
index 000000000000..985e82b2db02
--- /dev/null
+++ b/tests/disas/winch/x64/i32_and/params.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.and)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x46
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       andl    %eax, %ecx
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   46: ud2
diff --git a/tests/disas/winch/x64/i32_clz/lzcnt_const.wat b/tests/disas/winch/x64/i32_clz/lzcnt_const.wat
new file mode 100644
index 000000000000..13b3686c35c1
--- /dev/null
+++ b/tests/disas/winch/x64/i32_clz/lzcnt_const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_lzcnt"]
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.clz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       lzcntl  %eax, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3a: ud2
diff --git a/tests/disas/winch/x64/i32_clz/lzcnt_local.wat b/tests/disas/winch/x64/i32_clz/lzcnt_local.wat
new file mode 100644
index 000000000000..cac7db33bbed
--- /dev/null
+++ b/tests/disas/winch/x64/i32_clz/lzcnt_local.wat
@@ -0,0 +1,36 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_lzcnt"]
+
+(module
+    (func (result i32)
+        (local $foo i32)
+
+        (i32.const 2)
+        (local.set $foo)
+
+        (local.get $foo)
+        (i32.clz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $2, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       lzcntl  %eax, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4c: ud2
diff --git a/tests/disas/winch/x64/i32_clz/lzcnt_param.wat b/tests/disas/winch/x64/i32_clz/lzcnt_param.wat
new file mode 100644
index 000000000000..0c5edaf0e9c0
--- /dev/null
+++ b/tests/disas/winch/x64/i32_clz/lzcnt_param.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_lzcnt"]
+
+(module
+    (func (param i32) (result i32)
+        (local.get 0)
+        (i32.clz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       lzcntl  %eax, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3e: ud2
diff --git a/tests/disas/winch/x64/i32_clz/no_lzcnt_const.wat b/tests/disas/winch/x64/i32_clz/no_lzcnt_const.wat
new file mode 100644
index 000000000000..8259720bdfa3
--- /dev/null
+++ b/tests/disas/winch/x64/i32_clz/no_lzcnt_const.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.clz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4b
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       bsrl    %eax, %eax
+;;       movl    $0, %r11d
+;;       setne   %r11b
+;;       negl    %eax
+;;       addl    $0x20, %eax
+;;       subl    %r11d, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4b: ud2
diff --git a/tests/disas/winch/x64/i32_clz/no_lzcnt_local.wat b/tests/disas/winch/x64/i32_clz/no_lzcnt_local.wat
new file mode 100644
index 000000000000..f9d0496d7904
--- /dev/null
+++ b/tests/disas/winch/x64/i32_clz/no_lzcnt_local.wat
@@ -0,0 +1,40 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)
+
+        (i32.const 2)
+        (local.set $foo)
+
+        (local.get $foo)
+        (i32.clz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x5d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $2, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       bsrl    %eax, %eax
+;;       movl    $0, %r11d
+;;       setne   %r11b
+;;       negl    %eax
+;;       addl    $0x20, %eax
+;;       subl    %r11d, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   5d: ud2
diff --git a/tests/disas/winch/x64/i32_clz/no_lzcnt_param.wat b/tests/disas/winch/x64/i32_clz/no_lzcnt_param.wat
new file mode 100644
index 000000000000..25b78060ba5d
--- /dev/null
+++ b/tests/disas/winch/x64/i32_clz/no_lzcnt_param.wat
@@ -0,0 +1,33 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (result i32)
+        (local.get 0)
+        (i32.clz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       bsrl    %eax, %eax
+;;       movl    $0, %r11d
+;;       setne   %r11b
+;;       negl    %eax
+;;       addl    $0x20, %eax
+;;       subl    %r11d, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4f: ud2
diff --git a/tests/disas/winch/x64/i32_ctz/bmi1_const.wat b/tests/disas/winch/x64/i32_ctz/bmi1_const.wat
new file mode 100644
index 000000000000..15067c2fc0fc
--- /dev/null
+++ b/tests/disas/winch/x64/i32_ctz/bmi1_const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_bmi1"]
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.ctz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       tzcntl  %eax, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3a: ud2
diff --git a/tests/disas/winch/x64/i32_ctz/bmi1_local.wat b/tests/disas/winch/x64/i32_ctz/bmi1_local.wat
new file mode 100644
index 000000000000..16ffb193c93f
--- /dev/null
+++ b/tests/disas/winch/x64/i32_ctz/bmi1_local.wat
@@ -0,0 +1,37 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_bmi1"]
+
+(module
+    (func (result i32)
+        (local $foo i32)
+
+        (i32.const 2)
+        (local.set $foo)
+
+        (local.get $foo)
+        (i32.ctz)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $2, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       tzcntl  %eax, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4c: ud2
diff --git a/tests/disas/winch/x64/i32_ctz/bmi1_param.wat b/tests/disas/winch/x64/i32_ctz/bmi1_param.wat
new file mode 100644
index 000000000000..ca6306cc754a
--- /dev/null
+++ b/tests/disas/winch/x64/i32_ctz/bmi1_param.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_bmi1"]
+
+(module
+    (func (param i32) (result i32)
+        (local.get 0)
+        (i32.ctz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       tzcntl  %eax, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3e: ud2
diff --git a/tests/disas/winch/x64/i32_ctz/no_bmi1_const.wat b/tests/disas/winch/x64/i32_ctz/no_bmi1_const.wat
new file mode 100644
index 000000000000..df598706a976
--- /dev/null
+++ b/tests/disas/winch/x64/i32_ctz/no_bmi1_const.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.ctz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       bsfl    %eax, %eax
+;;       movl    $0, %r11d
+;;       sete    %r11b
+;;       shll    $5, %r11d
+;;       addl    %r11d, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4a: ud2
diff --git a/tests/disas/winch/x64/i32_ctz/no_bmi1_local.wat b/tests/disas/winch/x64/i32_ctz/no_bmi1_local.wat
new file mode 100644
index 000000000000..47744188b41f
--- /dev/null
+++ b/tests/disas/winch/x64/i32_ctz/no_bmi1_local.wat
@@ -0,0 +1,39 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)
+
+        (i32.const 2)
+        (local.set $foo)
+
+        (local.get $foo)
+        (i32.ctz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x5c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $2, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       bsfl    %eax, %eax
+;;       movl    $0, %r11d
+;;       sete    %r11b
+;;       shll    $5, %r11d
+;;       addl    %r11d, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   5c: ud2
diff --git a/tests/disas/winch/x64/i32_ctz/no_bmi1_param.wat b/tests/disas/winch/x64/i32_ctz/no_bmi1_param.wat
new file mode 100644
index 000000000000..0396cbbf9ebb
--- /dev/null
+++ b/tests/disas/winch/x64/i32_ctz/no_bmi1_param.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (result i32)
+        (local.get 0)
+        (i32.ctz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       bsfl    %eax, %eax
+;;       movl    $0, %r11d
+;;       sete    %r11b
+;;       shll    $5, %r11d
+;;       addl    %r11d, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4e: ud2
diff --git a/tests/disas/winch/x64/i32_divs/const.wat b/tests/disas/winch/x64/i32_divs/const.wat
new file mode 100644
index 000000000000..823ec5edb0cf
--- /dev/null
+++ b/tests/disas/winch/x64/i32_divs/const.wat
@@ -0,0 +1,33 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const 20)
+	(i32.const 10)
+	(i32.div_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x47
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0xa, %ecx
+;;       movl    $0x14, %eax
+;;       cmpl    $0, %ecx
+;;       je      0x49
+;;   3e: cltd
+;;       idivl   %ecx
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   47: ud2
+;;   49: ud2
diff --git a/tests/disas/winch/x64/i32_divs/one_zero.wat b/tests/disas/winch/x64/i32_divs/one_zero.wat
new file mode 100644
index 000000000000..c3b9d77a4c1d
--- /dev/null
+++ b/tests/disas/winch/x64/i32_divs/one_zero.wat
@@ -0,0 +1,33 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const 1)
+	(i32.const 0)
+	(i32.div_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x47
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0, %ecx
+;;       movl    $1, %eax
+;;       cmpl    $0, %ecx
+;;       je      0x49
+;;   3e: cltd
+;;       idivl   %ecx
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   47: ud2
+;;   49: ud2
diff --git a/tests/disas/winch/x64/i32_divs/overflow.wat b/tests/disas/winch/x64/i32_divs/overflow.wat
new file mode 100644
index 000000000000..87c943038db6
--- /dev/null
+++ b/tests/disas/winch/x64/i32_divs/overflow.wat
@@ -0,0 +1,33 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const 0x80000000)
+	(i32.const -1)
+	(i32.div_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x47
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0xffffffff, %ecx
+;;       movl    $0x80000000, %eax
+;;       cmpl    $0, %ecx
+;;       je      0x49
+;;   3e: cltd
+;;       idivl   %ecx
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   47: ud2
+;;   49: ud2
diff --git a/tests/disas/winch/x64/i32_divs/params.wat b/tests/disas/winch/x64/i32_divs/params.wat
new file mode 100644
index 000000000000..3204e2b0458d
--- /dev/null
+++ b/tests/disas/winch/x64/i32_divs/params.wat
@@ -0,0 +1,35 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+	(local.get 0)
+	(local.get 1)
+	(i32.div_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    8(%rsp), %ecx
+;;       movl    0xc(%rsp), %eax
+;;       cmpl    $0, %ecx
+;;       je      0x50
+;;   45: cltd
+;;       idivl   %ecx
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4e: ud2
+;;   50: ud2
diff --git a/tests/disas/winch/x64/i32_divs/zero_zero.wat b/tests/disas/winch/x64/i32_divs/zero_zero.wat
new file mode 100644
index 000000000000..2e3b56e87834
--- /dev/null
+++ b/tests/disas/winch/x64/i32_divs/zero_zero.wat
@@ -0,0 +1,33 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const 0)
+	(i32.const 0)
+	(i32.div_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x47
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0, %ecx
+;;       movl    $0, %eax
+;;       cmpl    $0, %ecx
+;;       je      0x49
+;;   3e: cltd
+;;       idivl   %ecx
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   47: ud2
+;;   49: ud2
diff --git a/tests/disas/winch/x64/i32_divu/const.wat b/tests/disas/winch/x64/i32_divu/const.wat
new file mode 100644
index 000000000000..1e909fd4131d
--- /dev/null
+++ b/tests/disas/winch/x64/i32_divu/const.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const 20)
+	(i32.const 10)
+	(i32.div_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0xa, %ecx
+;;       movl    $0x14, %eax
+;;       xorl    %edx, %edx
+;;       divl    %ecx
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3f: ud2
diff --git a/tests/disas/winch/x64/i32_divu/one_zero.wat b/tests/disas/winch/x64/i32_divu/one_zero.wat
new file mode 100644
index 000000000000..2f12d30eb7b3
--- /dev/null
+++ b/tests/disas/winch/x64/i32_divu/one_zero.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const 1)
+	(i32.const 0)
+	(i32.div_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0, %ecx
+;;       movl    $1, %eax
+;;       xorl    %edx, %edx
+;;       divl    %ecx
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3f: ud2
diff --git a/tests/disas/winch/x64/i32_divu/params.wat b/tests/disas/winch/x64/i32_divu/params.wat
new file mode 100644
index 000000000000..9e6957d0961a
--- /dev/null
+++ b/tests/disas/winch/x64/i32_divu/params.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+	(local.get 0)
+	(local.get 1)
+	(i32.div_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x46
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    8(%rsp), %ecx
+;;       movl    0xc(%rsp), %eax
+;;       xorl    %edx, %edx
+;;       divl    %ecx
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   46: ud2
diff --git a/tests/disas/winch/x64/i32_divu/signed.wat b/tests/disas/winch/x64/i32_divu/signed.wat
new file mode 100644
index 000000000000..0122f76e3aa5
--- /dev/null
+++ b/tests/disas/winch/x64/i32_divu/signed.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const -1)
+	(i32.const -1)
+	(i32.div_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0xffffffff, %ecx
+;;       movl    $0xffffffff, %eax
+;;       xorl    %edx, %edx
+;;       divl    %ecx
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3f: ud2
diff --git a/tests/disas/winch/x64/i32_divu/zero_zero.wat b/tests/disas/winch/x64/i32_divu/zero_zero.wat
new file mode 100644
index 000000000000..2c471cb8ba32
--- /dev/null
+++ b/tests/disas/winch/x64/i32_divu/zero_zero.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const 0)
+	(i32.const 0)
+	(i32.div_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0, %ecx
+;;       movl    $0, %eax
+;;       xorl    %edx, %edx
+;;       divl    %ecx
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3f: ud2
diff --git a/tests/disas/winch/x64/i32_eq/const.wat b/tests/disas/winch/x64/i32_eq/const.wat
new file mode 100644
index 000000000000..c94906bbb19e
--- /dev/null
+++ b/tests/disas/winch/x64/i32_eq/const.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 2)
+        (i32.const 3)
+        (i32.eq)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x42
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $2, %eax
+;;       cmpl    $3, %eax
+;;       movl    $0, %eax
+;;       sete    %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   42: ud2
diff --git a/tests/disas/winch/x64/i32_eq/locals.wat b/tests/disas/winch/x64/i32_eq/locals.wat
new file mode 100644
index 000000000000..b22bbdcf4c71
--- /dev/null
+++ b/tests/disas/winch/x64/i32_eq/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)
+        (local $bar i32)
+
+        (i32.const 2)
+        (local.set $foo)
+        (i32.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.eq)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x62
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $2, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    $3, %eax
+;;       movl    %eax, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       cmpl    %eax, %ecx
+;;       movl    $0, %ecx
+;;       sete    %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   62: ud2
diff --git a/tests/disas/winch/x64/i32_eq/params.wat b/tests/disas/winch/x64/i32_eq/params.wat
new file mode 100644
index 000000000000..4cd4cc234cde
--- /dev/null
+++ b/tests/disas/winch/x64/i32_eq/params.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.eq)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       cmpl    %eax, %ecx
+;;       movl    $0, %ecx
+;;       sete    %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4f: ud2
diff --git a/tests/disas/winch/x64/i32_eqz/const.wat b/tests/disas/winch/x64/i32_eqz/const.wat
new file mode 100644
index 000000000000..a4a2cf9416c2
--- /dev/null
+++ b/tests/disas/winch/x64/i32_eqz/const.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.eqz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x42
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       cmpl    $0, %eax
+;;       movl    $0, %eax
+;;       sete    %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   42: ud2
diff --git a/tests/disas/winch/x64/i32_eqz/local.wat b/tests/disas/winch/x64/i32_eqz/local.wat
new file mode 100644
index 000000000000..fbc995d8bbf4
--- /dev/null
+++ b/tests/disas/winch/x64/i32_eqz/local.wat
@@ -0,0 +1,37 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)
+
+        (i32.const 2)
+        (local.set $foo)
+
+        (local.get $foo)
+        (i32.eqz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x54
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $2, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       cmpl    $0, %eax
+;;       movl    $0, %eax
+;;       sete    %al
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   54: ud2
diff --git a/tests/disas/winch/x64/i32_eqz/param.wat b/tests/disas/winch/x64/i32_eqz/param.wat
new file mode 100644
index 000000000000..fced2a460122
--- /dev/null
+++ b/tests/disas/winch/x64/i32_eqz/param.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (result i32)
+        (local.get 0)
+        (i32.eqz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x46
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       cmpl    $0, %eax
+;;       movl    $0, %eax
+;;       sete    %al
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   46: ud2
diff --git a/tests/disas/winch/x64/i32_extend_16_s/const.wat b/tests/disas/winch/x64/i32_extend_16_s/const.wat
new file mode 100644
index 000000000000..2f7f2b821286
--- /dev/null
+++ b/tests/disas/winch/x64/i32_extend_16_s/const.wat
@@ -0,0 +1,27 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.extend16_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       movswl  %ax, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_extend_16_s/locals.wat b/tests/disas/winch/x64/i32_extend_16_s/locals.wat
new file mode 100644
index 000000000000..c1fb9cc9478c
--- /dev/null
+++ b/tests/disas/winch/x64/i32_extend_16_s/locals.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local i32)
+
+        (local.get 0)
+        (i32.extend16_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x42
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       movswl  %ax, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   42: ud2
diff --git a/tests/disas/winch/x64/i32_extend_16_s/params.wat b/tests/disas/winch/x64/i32_extend_16_s/params.wat
new file mode 100644
index 000000000000..55f6cbe75327
--- /dev/null
+++ b/tests/disas/winch/x64/i32_extend_16_s/params.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (result i32)
+        (local.get 0)
+        (i32.extend16_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       movswl  %ax, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3d: ud2
diff --git a/tests/disas/winch/x64/i32_extend_8_s/const.wat b/tests/disas/winch/x64/i32_extend_8_s/const.wat
new file mode 100644
index 000000000000..29a2729701e3
--- /dev/null
+++ b/tests/disas/winch/x64/i32_extend_8_s/const.wat
@@ -0,0 +1,27 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.extend8_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       movsbl  %al, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_extend_8_s/locals.wat b/tests/disas/winch/x64/i32_extend_8_s/locals.wat
new file mode 100644
index 000000000000..f6b807f8e4d4
--- /dev/null
+++ b/tests/disas/winch/x64/i32_extend_8_s/locals.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local i32)
+
+        (local.get 0)
+        (i32.extend8_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x42
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       movsbl  %al, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   42: ud2
diff --git a/tests/disas/winch/x64/i32_extend_8_s/params.wat b/tests/disas/winch/x64/i32_extend_8_s/params.wat
new file mode 100644
index 000000000000..5a6074fd06c7
--- /dev/null
+++ b/tests/disas/winch/x64/i32_extend_8_s/params.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (result i32)
+        (local.get 0)
+        (i32.extend8_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       movsbl  %al, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3d: ud2
diff --git a/tests/disas/winch/x64/i32_ge_s/const.wat b/tests/disas/winch/x64/i32_ge_s/const.wat
new file mode 100644
index 000000000000..fc0f79b566f4
--- /dev/null
+++ b/tests/disas/winch/x64/i32_ge_s/const.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 2)
+        (i32.const 3)
+        (i32.ge_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x42
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $2, %eax
+;;       cmpl    $3, %eax
+;;       movl    $0, %eax
+;;       setge   %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   42: ud2
diff --git a/tests/disas/winch/x64/i32_ge_s/locals.wat b/tests/disas/winch/x64/i32_ge_s/locals.wat
new file mode 100644
index 000000000000..d665149379ff
--- /dev/null
+++ b/tests/disas/winch/x64/i32_ge_s/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)
+        (local $bar i32)
+
+        (i32.const 2)
+        (local.set $foo)
+        (i32.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.ge_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x62
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $2, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    $3, %eax
+;;       movl    %eax, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       cmpl    %eax, %ecx
+;;       movl    $0, %ecx
+;;       setge   %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   62: ud2
diff --git a/tests/disas/winch/x64/i32_ge_s/params.wat b/tests/disas/winch/x64/i32_ge_s/params.wat
new file mode 100644
index 000000000000..637bc1df49f7
--- /dev/null
+++ b/tests/disas/winch/x64/i32_ge_s/params.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.ge_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       cmpl    %eax, %ecx
+;;       movl    $0, %ecx
+;;       setge   %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4f: ud2
diff --git a/tests/disas/winch/x64/i32_ge_u/const.wat b/tests/disas/winch/x64/i32_ge_u/const.wat
new file mode 100644
index 000000000000..583571985345
--- /dev/null
+++ b/tests/disas/winch/x64/i32_ge_u/const.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 2)
+        (i32.const 3)
+        (i32.ge_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x42
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $2, %eax
+;;       cmpl    $3, %eax
+;;       movl    $0, %eax
+;;       setae   %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   42: ud2
diff --git a/tests/disas/winch/x64/i32_ge_u/locals.wat b/tests/disas/winch/x64/i32_ge_u/locals.wat
new file mode 100644
index 000000000000..9af0de8e77dd
--- /dev/null
+++ b/tests/disas/winch/x64/i32_ge_u/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)
+        (local $bar i32)
+
+        (i32.const 2)
+        (local.set $foo)
+        (i32.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.ge_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x62
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $2, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    $3, %eax
+;;       movl    %eax, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       cmpl    %eax, %ecx
+;;       movl    $0, %ecx
+;;       setae   %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   62: ud2
diff --git a/tests/disas/winch/x64/i32_ge_u/params.wat b/tests/disas/winch/x64/i32_ge_u/params.wat
new file mode 100644
index 000000000000..47767ca6f8d1
--- /dev/null
+++ b/tests/disas/winch/x64/i32_ge_u/params.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.ge_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       cmpl    %eax, %ecx
+;;       movl    $0, %ecx
+;;       setae   %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4f: ud2
diff --git a/tests/disas/winch/x64/i32_gt_s/const.wat b/tests/disas/winch/x64/i32_gt_s/const.wat
new file mode 100644
index 000000000000..8c0b5efb8a8f
--- /dev/null
+++ b/tests/disas/winch/x64/i32_gt_s/const.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 2)
+        (i32.const 3)
+        (i32.gt_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x42
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $2, %eax
+;;       cmpl    $3, %eax
+;;       movl    $0, %eax
+;;       setg    %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   42: ud2
diff --git a/tests/disas/winch/x64/i32_gt_s/locals.wat b/tests/disas/winch/x64/i32_gt_s/locals.wat
new file mode 100644
index 000000000000..d4f248f65eeb
--- /dev/null
+++ b/tests/disas/winch/x64/i32_gt_s/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)
+        (local $bar i32)
+
+        (i32.const 2)
+        (local.set $foo)
+        (i32.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.gt_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x62
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $2, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    $3, %eax
+;;       movl    %eax, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       cmpl    %eax, %ecx
+;;       movl    $0, %ecx
+;;       setg    %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   62: ud2
diff --git a/tests/disas/winch/x64/i32_gt_s/params.wat b/tests/disas/winch/x64/i32_gt_s/params.wat
new file mode 100644
index 000000000000..51c7389a1793
--- /dev/null
+++ b/tests/disas/winch/x64/i32_gt_s/params.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.gt_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       cmpl    %eax, %ecx
+;;       movl    $0, %ecx
+;;       setg    %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4f: ud2
diff --git a/tests/disas/winch/x64/i32_gt_u/const.wat b/tests/disas/winch/x64/i32_gt_u/const.wat
new file mode 100644
index 000000000000..f55814102617
--- /dev/null
+++ b/tests/disas/winch/x64/i32_gt_u/const.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 2)
+        (i32.const 3)
+        (i32.gt_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x42
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $2, %eax
+;;       cmpl    $3, %eax
+;;       movl    $0, %eax
+;;       seta    %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   42: ud2
diff --git a/tests/disas/winch/x64/i32_gt_u/locals.wat b/tests/disas/winch/x64/i32_gt_u/locals.wat
new file mode 100644
index 000000000000..ed7b937fcdbb
--- /dev/null
+++ b/tests/disas/winch/x64/i32_gt_u/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)
+        (local $bar i32)
+
+        (i32.const 2)
+        (local.set $foo)
+        (i32.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.gt_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x62
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $2, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    $3, %eax
+;;       movl    %eax, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       cmpl    %eax, %ecx
+;;       movl    $0, %ecx
+;;       seta    %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   62: ud2
diff --git a/tests/disas/winch/x64/i32_gt_u/params.wat b/tests/disas/winch/x64/i32_gt_u/params.wat
new file mode 100644
index 000000000000..24135443a7b2
--- /dev/null
+++ b/tests/disas/winch/x64/i32_gt_u/params.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.gt_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       cmpl    %eax, %ecx
+;;       movl    $0, %ecx
+;;       seta    %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4f: ud2
diff --git a/tests/disas/winch/x64/i32_le_s/const.wat b/tests/disas/winch/x64/i32_le_s/const.wat
new file mode 100644
index 000000000000..751b0e0494df
--- /dev/null
+++ b/tests/disas/winch/x64/i32_le_s/const.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 2)
+        (i32.const 3)
+        (i32.le_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x42
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $2, %eax
+;;       cmpl    $3, %eax
+;;       movl    $0, %eax
+;;       setle   %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   42: ud2
diff --git a/tests/disas/winch/x64/i32_le_s/locals.wat b/tests/disas/winch/x64/i32_le_s/locals.wat
new file mode 100644
index 000000000000..bf76f8e4e191
--- /dev/null
+++ b/tests/disas/winch/x64/i32_le_s/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)
+        (local $bar i32)
+
+        (i32.const 2)
+        (local.set $foo)
+        (i32.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.le_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x62
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $2, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    $3, %eax
+;;       movl    %eax, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       cmpl    %eax, %ecx
+;;       movl    $0, %ecx
+;;       setle   %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   62: ud2
diff --git a/tests/disas/winch/x64/i32_le_s/params.wat b/tests/disas/winch/x64/i32_le_s/params.wat
new file mode 100644
index 000000000000..f198747e3d4b
--- /dev/null
+++ b/tests/disas/winch/x64/i32_le_s/params.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.le_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       cmpl    %eax, %ecx
+;;       movl    $0, %ecx
+;;       setle   %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4f: ud2
diff --git a/tests/disas/winch/x64/i32_le_u/const.wat b/tests/disas/winch/x64/i32_le_u/const.wat
new file mode 100644
index 000000000000..37e77eb0a785
--- /dev/null
+++ b/tests/disas/winch/x64/i32_le_u/const.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 2)
+        (i32.const 3)
+        (i32.le_u)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x42
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $2, %eax
+;;       cmpl    $3, %eax
+;;       movl    $0, %eax
+;;       setbe   %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   42: ud2
diff --git a/tests/disas/winch/x64/i32_le_u/locals.wat b/tests/disas/winch/x64/i32_le_u/locals.wat
new file mode 100644
index 000000000000..5d142231f523
--- /dev/null
+++ b/tests/disas/winch/x64/i32_le_u/locals.wat
@@ -0,0 +1,46 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)
+        (local $bar i32)
+
+        (i32.const 2)
+        (local.set $foo)
+        (i32.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.le_u)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x62
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $2, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    $3, %eax
+;;       movl    %eax, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       cmpl    %eax, %ecx
+;;       movl    $0, %ecx
+;;       setbe   %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   62: ud2
diff --git a/tests/disas/winch/x64/i32_le_u/params.wat b/tests/disas/winch/x64/i32_le_u/params.wat
new file mode 100644
index 000000000000..49861f2421d2
--- /dev/null
+++ b/tests/disas/winch/x64/i32_le_u/params.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.le_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       cmpl    %eax, %ecx
+;;       movl    $0, %ecx
+;;       setbe   %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4f: ud2
diff --git a/tests/disas/winch/x64/i32_lt_s/const.wat b/tests/disas/winch/x64/i32_lt_s/const.wat
new file mode 100644
index 000000000000..97fd85f2d08a
--- /dev/null
+++ b/tests/disas/winch/x64/i32_lt_s/const.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 2)
+        (i32.const 3)
+        (i32.lt_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x42
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $2, %eax
+;;       cmpl    $3, %eax
+;;       movl    $0, %eax
+;;       setl    %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   42: ud2
diff --git a/tests/disas/winch/x64/i32_lt_s/locals.wat b/tests/disas/winch/x64/i32_lt_s/locals.wat
new file mode 100644
index 000000000000..7e6be9cbb1b3
--- /dev/null
+++ b/tests/disas/winch/x64/i32_lt_s/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)
+        (local $bar i32)
+
+        (i32.const 2)
+        (local.set $foo)
+        (i32.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.lt_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x62
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $2, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    $3, %eax
+;;       movl    %eax, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       cmpl    %eax, %ecx
+;;       movl    $0, %ecx
+;;       setl    %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   62: ud2
diff --git a/tests/disas/winch/x64/i32_lt_s/params.wat b/tests/disas/winch/x64/i32_lt_s/params.wat
new file mode 100644
index 000000000000..0f96ca0bcb13
--- /dev/null
+++ b/tests/disas/winch/x64/i32_lt_s/params.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.lt_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       cmpl    %eax, %ecx
+;;       movl    $0, %ecx
+;;       setl    %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4f: ud2
diff --git a/tests/disas/winch/x64/i32_lt_u/const.wat b/tests/disas/winch/x64/i32_lt_u/const.wat
new file mode 100644
index 000000000000..686179cd6e97
--- /dev/null
+++ b/tests/disas/winch/x64/i32_lt_u/const.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 2)
+        (i32.const 3)
+        (i32.lt_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x42
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $2, %eax
+;;       cmpl    $3, %eax
+;;       movl    $0, %eax
+;;       setb    %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   42: ud2
diff --git a/tests/disas/winch/x64/i32_lt_u/locals.wat b/tests/disas/winch/x64/i32_lt_u/locals.wat
new file mode 100644
index 000000000000..22d3ee6ee844
--- /dev/null
+++ b/tests/disas/winch/x64/i32_lt_u/locals.wat
@@ -0,0 +1,46 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)
+        (local $bar i32)
+
+        (i32.const 2)
+        (local.set $foo)
+        (i32.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.lt_u)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x62
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $2, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    $3, %eax
+;;       movl    %eax, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       cmpl    %eax, %ecx
+;;       movl    $0, %ecx
+;;       setb    %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   62: ud2
diff --git a/tests/disas/winch/x64/i32_lt_u/params.wat b/tests/disas/winch/x64/i32_lt_u/params.wat
new file mode 100644
index 000000000000..37eb05e924b2
--- /dev/null
+++ b/tests/disas/winch/x64/i32_lt_u/params.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.lt_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       cmpl    %eax, %ecx
+;;       movl    $0, %ecx
+;;       setb    %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4f: ud2
diff --git a/tests/disas/winch/x64/i32_mul/const.wat b/tests/disas/winch/x64/i32_mul/const.wat
new file mode 100644
index 000000000000..08af3b9b3d96
--- /dev/null
+++ b/tests/disas/winch/x64/i32_mul/const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const 10)
+	(i32.const 20)
+	(i32.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0xa, %eax
+;;       imull   $0x14, %eax, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_mul/locals.wat b/tests/disas/winch/x64/i32_mul/locals.wat
new file mode 100644
index 000000000000..e51d2d71db76
--- /dev/null
+++ b/tests/disas/winch/x64/i32_mul/locals.wat
@@ -0,0 +1,44 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)  
+        (local $bar i32)
+
+        (i32.const 10)
+        (local.set $foo)
+
+        (i32.const 20)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        i32.mul
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x5a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $0xa, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    $0x14, %eax
+;;       movl    %eax, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       imull   %eax, %ecx
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   5a: ud2
diff --git a/tests/disas/winch/x64/i32_mul/max.wat b/tests/disas/winch/x64/i32_mul/max.wat
new file mode 100644
index 000000000000..a8ccdfb7475c
--- /dev/null
+++ b/tests/disas/winch/x64/i32_mul/max.wat
@@ -0,0 +1,27 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+    (func (result i32)
+	(i32.const 0x7fffffff)
+	(i32.const -1)
+	(i32.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0x7fffffff, %eax
+;;       imull   $-1, %eax, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_mul/max_one.wat b/tests/disas/winch/x64/i32_mul/max_one.wat
new file mode 100644
index 000000000000..5d8d122eb4d8
--- /dev/null
+++ b/tests/disas/winch/x64/i32_mul/max_one.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const 0x80000000)
+	(i32.const -1)
+	(i32.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0x80000000, %eax
+;;       imull   $-1, %eax, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_mul/mixed.wat b/tests/disas/winch/x64/i32_mul/mixed.wat
new file mode 100644
index 000000000000..2034307f7aaa
--- /dev/null
+++ b/tests/disas/winch/x64/i32_mul/mixed.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const -1)
+	(i32.const 1)
+	(i32.mul)
+     )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0xffffffff, %eax
+;;       imull   $1, %eax, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_mul/params.wat b/tests/disas/winch/x64/i32_mul/params.wat
new file mode 100644
index 000000000000..4078ab9ae68e
--- /dev/null
+++ b/tests/disas/winch/x64/i32_mul/params.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+	(local.get 0)
+	(local.get 1)
+	(i32.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x47
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       imull   %eax, %ecx
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   47: ud2
diff --git a/tests/disas/winch/x64/i32_mul/signed.wat b/tests/disas/winch/x64/i32_mul/signed.wat
new file mode 100644
index 000000000000..f62ab6f758cd
--- /dev/null
+++ b/tests/disas/winch/x64/i32_mul/signed.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const -1)
+	(i32.const -1)
+	(i32.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0xffffffff, %eax
+;;       imull   $-1, %eax, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_mul/unsigned_with_zero.wat b/tests/disas/winch/x64/i32_mul/unsigned_with_zero.wat
new file mode 100644
index 000000000000..6335ff448a65
--- /dev/null
+++ b/tests/disas/winch/x64/i32_mul/unsigned_with_zero.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+     	(i32.const 0)
+    	(i32.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       imull   $0, %eax, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_ne/const.wat b/tests/disas/winch/x64/i32_ne/const.wat
new file mode 100644
index 000000000000..4d565b09dbc8
--- /dev/null
+++ b/tests/disas/winch/x64/i32_ne/const.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 2)
+        (i32.const 3)
+        (i32.ne)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x42
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $2, %eax
+;;       cmpl    $3, %eax
+;;       movl    $0, %eax
+;;       setne   %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   42: ud2
diff --git a/tests/disas/winch/x64/i32_ne/locals.wat b/tests/disas/winch/x64/i32_ne/locals.wat
new file mode 100644
index 000000000000..15db22c2d7a8
--- /dev/null
+++ b/tests/disas/winch/x64/i32_ne/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)
+        (local $bar i32)
+
+        (i32.const 2)
+        (local.set $foo)
+        (i32.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.ne)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x62
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $2, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    $3, %eax
+;;       movl    %eax, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       cmpl    %eax, %ecx
+;;       movl    $0, %ecx
+;;       setne   %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   62: ud2
diff --git a/tests/disas/winch/x64/i32_ne/params.wat b/tests/disas/winch/x64/i32_ne/params.wat
new file mode 100644
index 000000000000..3a6ecac53f0c
--- /dev/null
+++ b/tests/disas/winch/x64/i32_ne/params.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.ne)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       cmpl    %eax, %ecx
+;;       movl    $0, %ecx
+;;       setne   %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4f: ud2
diff --git a/tests/disas/winch/x64/i32_or/const.wat b/tests/disas/winch/x64/i32_or/const.wat
new file mode 100644
index 000000000000..64beb07cf724
--- /dev/null
+++ b/tests/disas/winch/x64/i32_or/const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 2)
+        (i32.or)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       orl     $2, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_or/locals.wat b/tests/disas/winch/x64/i32_or/locals.wat
new file mode 100644
index 000000000000..68fb5396d066
--- /dev/null
+++ b/tests/disas/winch/x64/i32_or/locals.wat
@@ -0,0 +1,44 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)  
+        (local $bar i32)
+
+        (i32.const 1)
+        (local.set $foo)
+
+        (i32.const 2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.or)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x59
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $1, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    $2, %eax
+;;       movl    %eax, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       orl     %eax, %ecx
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   59: ud2
diff --git a/tests/disas/winch/x64/i32_or/params.wat b/tests/disas/winch/x64/i32_or/params.wat
new file mode 100644
index 000000000000..a0f96012eeef
--- /dev/null
+++ b/tests/disas/winch/x64/i32_or/params.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.or)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x46
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       orl     %eax, %ecx
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   46: ud2
diff --git a/tests/disas/winch/x64/i32_popcnt/const.wat b/tests/disas/winch/x64/i32_popcnt/const.wat
new file mode 100644
index 000000000000..2e26ab716779
--- /dev/null
+++ b/tests/disas/winch/x64/i32_popcnt/const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has-popcnt", "-Ccranelift-has-sse42"]
+
+(module
+    (func (result i32)
+      i32.const 3
+      i32.popcnt
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $3, %eax
+;;       popcntl %eax, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3a: ud2
diff --git a/tests/disas/winch/x64/i32_popcnt/fallback.wat b/tests/disas/winch/x64/i32_popcnt/fallback.wat
new file mode 100644
index 000000000000..fd9e7791797d
--- /dev/null
+++ b/tests/disas/winch/x64/i32_popcnt/fallback.wat
@@ -0,0 +1,42 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+      i32.const 15
+      i32.popcnt
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0xf, %eax
+;;       movl    %eax, %ecx
+;;       shrl    $1, %eax
+;;       andl    $0x55555555, %eax
+;;       subl    %eax, %ecx
+;;       movl    %ecx, %eax
+;;       movl    $0x33333333, %r11d
+;;       andl    %r11d, %eax
+;;       shrl    $2, %ecx
+;;       andl    %r11d, %ecx
+;;       addl    %eax, %ecx
+;;       movl    %ecx, %eax
+;;       shrl    $4, %eax
+;;       addl    %ecx, %eax
+;;       andl    $0xf0f0f0f, %eax
+;;       imull   $0x1010101, %eax, %eax
+;;       shrl    $0x18, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6c: ud2
diff --git a/tests/disas/winch/x64/i32_popcnt/no_sse42.wat b/tests/disas/winch/x64/i32_popcnt/no_sse42.wat
new file mode 100644
index 000000000000..cdd64bd38972
--- /dev/null
+++ b/tests/disas/winch/x64/i32_popcnt/no_sse42.wat
@@ -0,0 +1,43 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_popcnt"]
+
+(module
+    (func (result i32)
+      i32.const 3
+      i32.popcnt
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $3, %eax
+;;       movl    %eax, %ecx
+;;       shrl    $1, %eax
+;;       andl    $0x55555555, %eax
+;;       subl    %eax, %ecx
+;;       movl    %ecx, %eax
+;;       movl    $0x33333333, %r11d
+;;       andl    %r11d, %eax
+;;       shrl    $2, %ecx
+;;       andl    %r11d, %ecx
+;;       addl    %eax, %ecx
+;;       movl    %ecx, %eax
+;;       shrl    $4, %eax
+;;       addl    %ecx, %eax
+;;       andl    $0xf0f0f0f, %eax
+;;       imull   $0x1010101, %eax, %eax
+;;       shrl    $0x18, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6c: ud2
diff --git a/tests/disas/winch/x64/i32_popcnt/reg.wat b/tests/disas/winch/x64/i32_popcnt/reg.wat
new file mode 100644
index 000000000000..622be6127fbf
--- /dev/null
+++ b/tests/disas/winch/x64/i32_popcnt/reg.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_popcnt", "-Ccranelift-has_sse42"]
+
+(module
+    (func (param i32) (result i32)
+      local.get 0
+      i32.popcnt
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       popcntl %eax, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3e: ud2
diff --git a/tests/disas/winch/x64/i32_reinterpret_f32/const.wat b/tests/disas/winch/x64/i32_reinterpret_f32/const.wat
new file mode 100644
index 000000000000..beba89798252
--- /dev/null
+++ b/tests/disas/winch/x64/i32_reinterpret_f32/const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (f32.const 1.0)
+        (i32.reinterpret_f32)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movss   0xd(%rip), %xmm0
+;;       movd    %xmm0, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3d: ud2
+;;   3f: addb    %al, (%rax)
diff --git a/tests/disas/winch/x64/i32_reinterpret_f32/locals.wat b/tests/disas/winch/x64/i32_reinterpret_f32/locals.wat
new file mode 100644
index 000000000000..7d313635e78f
--- /dev/null
+++ b/tests/disas/winch/x64/i32_reinterpret_f32/locals.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local f32)  
+
+        (local.get 0)
+        (i32.reinterpret_f32)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x45
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movss   0xc(%rsp), %xmm0
+;;       movd    %xmm0, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   45: ud2
diff --git a/tests/disas/winch/x64/i32_reinterpret_f32/params.wat b/tests/disas/winch/x64/i32_reinterpret_f32/params.wat
new file mode 100644
index 000000000000..ef9bf0be6996
--- /dev/null
+++ b/tests/disas/winch/x64/i32_reinterpret_f32/params.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (result i32)
+        (local.get 0)
+        (i32.reinterpret_f32)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x42
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0xc(%rsp), %xmm0
+;;       movd    %xmm0, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   42: ud2
diff --git a/tests/disas/winch/x64/i32_reinterpret_f32/ret_float.wat b/tests/disas/winch/x64/i32_reinterpret_f32/ret_float.wat
new file mode 100644
index 000000000000..66c101ff2422
--- /dev/null
+++ b/tests/disas/winch/x64/i32_reinterpret_f32/ret_float.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f32)
+        f32.const 1.0
+        i32.reinterpret_f32
+        drop
+        f32.const 1.0
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x45
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movss   0x15(%rip), %xmm0
+;;       movd    %xmm0, %eax
+;;       movss   9(%rip), %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   45: ud2
+;;   47: addb    %al, (%rax)
diff --git a/tests/disas/winch/x64/i32_rems/const.wat b/tests/disas/winch/x64/i32_rems/const.wat
new file mode 100644
index 000000000000..8aa15694db9c
--- /dev/null
+++ b/tests/disas/winch/x64/i32_rems/const.wat
@@ -0,0 +1,35 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const 7)
+	(i32.const 5)
+	(i32.rem_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x53
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $5, %ecx
+;;       movl    $7, %eax
+;;       cltd
+;;       cmpl    $-1, %ecx
+;;       jne     0x49
+;;   3f: movl    $0, %edx
+;;       jmp     0x4b
+;;   49: idivl   %ecx
+;;       movl    %edx, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   53: ud2
diff --git a/tests/disas/winch/x64/i32_rems/one_zero.wat b/tests/disas/winch/x64/i32_rems/one_zero.wat
new file mode 100644
index 000000000000..af1f22e42a08
--- /dev/null
+++ b/tests/disas/winch/x64/i32_rems/one_zero.wat
@@ -0,0 +1,35 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const 1)
+	(i32.const 0)
+	(i32.rem_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x53
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0, %ecx
+;;       movl    $1, %eax
+;;       cltd
+;;       cmpl    $-1, %ecx
+;;       jne     0x49
+;;   3f: movl    $0, %edx
+;;       jmp     0x4b
+;;   49: idivl   %ecx
+;;       movl    %edx, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   53: ud2
diff --git a/tests/disas/winch/x64/i32_rems/overflow.wat b/tests/disas/winch/x64/i32_rems/overflow.wat
new file mode 100644
index 000000000000..3f1a27cba81f
--- /dev/null
+++ b/tests/disas/winch/x64/i32_rems/overflow.wat
@@ -0,0 +1,35 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const 0x80000000)
+	(i32.const -1)
+	(i32.rem_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x53
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0xffffffff, %ecx
+;;       movl    $0x80000000, %eax
+;;       cltd
+;;       cmpl    $-1, %ecx
+;;       jne     0x49
+;;   3f: movl    $0, %edx
+;;       jmp     0x4b
+;;   49: idivl   %ecx
+;;       movl    %edx, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   53: ud2
diff --git a/tests/disas/winch/x64/i32_rems/params.wat b/tests/disas/winch/x64/i32_rems/params.wat
new file mode 100644
index 000000000000..17d1e20dbae6
--- /dev/null
+++ b/tests/disas/winch/x64/i32_rems/params.wat
@@ -0,0 +1,37 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+	(local.get 0)
+	(local.get 1)
+	(i32.rem_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x5a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    8(%rsp), %ecx
+;;       movl    0xc(%rsp), %eax
+;;       cltd
+;;       cmpl    $-1, %ecx
+;;       jne     0x50
+;;   46: movl    $0, %edx
+;;       jmp     0x52
+;;   50: idivl   %ecx
+;;       movl    %edx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   5a: ud2
diff --git a/tests/disas/winch/x64/i32_rems/zero_zero.wat b/tests/disas/winch/x64/i32_rems/zero_zero.wat
new file mode 100644
index 000000000000..82f7e1a2a09b
--- /dev/null
+++ b/tests/disas/winch/x64/i32_rems/zero_zero.wat
@@ -0,0 +1,35 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const 0)
+	(i32.const 0)
+	(i32.rem_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x53
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0, %ecx
+;;       movl    $0, %eax
+;;       cltd
+;;       cmpl    $-1, %ecx
+;;       jne     0x49
+;;   3f: movl    $0, %edx
+;;       jmp     0x4b
+;;   49: idivl   %ecx
+;;       movl    %edx, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   53: ud2
diff --git a/tests/disas/winch/x64/i32_remu/const.wat b/tests/disas/winch/x64/i32_remu/const.wat
new file mode 100644
index 000000000000..194485baca7f
--- /dev/null
+++ b/tests/disas/winch/x64/i32_remu/const.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const 7)
+	(i32.const 5)
+	(i32.rem_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x41
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $5, %ecx
+;;       movl    $7, %eax
+;;       xorl    %edx, %edx
+;;       divl    %ecx
+;;       movl    %edx, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   41: ud2
diff --git a/tests/disas/winch/x64/i32_remu/one_zero.wat b/tests/disas/winch/x64/i32_remu/one_zero.wat
new file mode 100644
index 000000000000..5b81ae968d84
--- /dev/null
+++ b/tests/disas/winch/x64/i32_remu/one_zero.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const 1)
+	(i32.const 0)
+	(i32.rem_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x41
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0, %ecx
+;;       movl    $1, %eax
+;;       xorl    %edx, %edx
+;;       divl    %ecx
+;;       movl    %edx, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   41: ud2
diff --git a/tests/disas/winch/x64/i32_remu/params.wat b/tests/disas/winch/x64/i32_remu/params.wat
new file mode 100644
index 000000000000..c6efd3b3bc2a
--- /dev/null
+++ b/tests/disas/winch/x64/i32_remu/params.wat
@@ -0,0 +1,33 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+	(local.get 0)
+	(local.get 1)
+	(i32.rem_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x48
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    8(%rsp), %ecx
+;;       movl    0xc(%rsp), %eax
+;;       xorl    %edx, %edx
+;;       divl    %ecx
+;;       movl    %edx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   48: ud2
diff --git a/tests/disas/winch/x64/i32_remu/signed.wat b/tests/disas/winch/x64/i32_remu/signed.wat
new file mode 100644
index 000000000000..e31afe826d61
--- /dev/null
+++ b/tests/disas/winch/x64/i32_remu/signed.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const -1)
+	(i32.const -1)
+	(i32.rem_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x41
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0xffffffff, %ecx
+;;       movl    $0xffffffff, %eax
+;;       xorl    %edx, %edx
+;;       divl    %ecx
+;;       movl    %edx, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   41: ud2
diff --git a/tests/disas/winch/x64/i32_remu/zero_zero.wat b/tests/disas/winch/x64/i32_remu/zero_zero.wat
new file mode 100644
index 000000000000..1260580bc063
--- /dev/null
+++ b/tests/disas/winch/x64/i32_remu/zero_zero.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const 0)
+	(i32.const 0)
+	(i32.rem_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x41
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0, %ecx
+;;       movl    $0, %eax
+;;       xorl    %edx, %edx
+;;       divl    %ecx
+;;       movl    %edx, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   41: ud2
diff --git a/tests/disas/winch/x64/i32_rotl/16_const.wat b/tests/disas/winch/x64/i32_rotl/16_const.wat
new file mode 100644
index 000000000000..7c78787e4e3a
--- /dev/null
+++ b/tests/disas/winch/x64/i32_rotl/16_const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 512)
+        (i32.rotl)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       roll    $0, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_rotl/8_const.wat b/tests/disas/winch/x64/i32_rotl/8_const.wat
new file mode 100644
index 000000000000..2af7807c8d6e
--- /dev/null
+++ b/tests/disas/winch/x64/i32_rotl/8_const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 2)
+        (i32.rotl)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       roll    $2, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_rotl/locals.wat b/tests/disas/winch/x64/i32_rotl/locals.wat
new file mode 100644
index 000000000000..b24df5fa1bf4
--- /dev/null
+++ b/tests/disas/winch/x64/i32_rotl/locals.wat
@@ -0,0 +1,43 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)  
+        (local $bar i32)
+
+        (i32.const 1)
+        (local.set $foo)
+
+        (i32.const 2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.rotl)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x57
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $1, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    $2, %eax
+;;       movl    %eax, 8(%rsp)
+;;       movl    8(%rsp), %ecx
+;;       movl    0xc(%rsp), %eax
+;;       roll    %cl, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   57: ud2
diff --git a/tests/disas/winch/x64/i32_rotl/params.wat b/tests/disas/winch/x64/i32_rotl/params.wat
new file mode 100644
index 000000000000..75cb86388e66
--- /dev/null
+++ b/tests/disas/winch/x64/i32_rotl/params.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.rotl)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x44
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    8(%rsp), %ecx
+;;       movl    0xc(%rsp), %eax
+;;       roll    %cl, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   44: ud2
diff --git a/tests/disas/winch/x64/i32_rotr/16_const.wat b/tests/disas/winch/x64/i32_rotr/16_const.wat
new file mode 100644
index 000000000000..b3f04e5a526a
--- /dev/null
+++ b/tests/disas/winch/x64/i32_rotr/16_const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 512)
+        (i32.rotr)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       rorl    $0, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_rotr/8_const.wat b/tests/disas/winch/x64/i32_rotr/8_const.wat
new file mode 100644
index 000000000000..26975a918070
--- /dev/null
+++ b/tests/disas/winch/x64/i32_rotr/8_const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 2)
+        (i32.rotr)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       rorl    $2, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_rotr/locals.wat b/tests/disas/winch/x64/i32_rotr/locals.wat
new file mode 100644
index 000000000000..7c2f0ca0fa72
--- /dev/null
+++ b/tests/disas/winch/x64/i32_rotr/locals.wat
@@ -0,0 +1,43 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)  
+        (local $bar i32)
+
+        (i32.const 1)
+        (local.set $foo)
+
+        (i32.const 2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.rotr)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x57
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $1, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    $2, %eax
+;;       movl    %eax, 8(%rsp)
+;;       movl    8(%rsp), %ecx
+;;       movl    0xc(%rsp), %eax
+;;       rorl    %cl, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   57: ud2
diff --git a/tests/disas/winch/x64/i32_rotr/params.wat b/tests/disas/winch/x64/i32_rotr/params.wat
new file mode 100644
index 000000000000..d87d6a7f8809
--- /dev/null
+++ b/tests/disas/winch/x64/i32_rotr/params.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.rotr)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x44
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    8(%rsp), %ecx
+;;       movl    0xc(%rsp), %eax
+;;       rorl    %cl, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   44: ud2
diff --git a/tests/disas/winch/x64/i32_shl/16_const.wat b/tests/disas/winch/x64/i32_shl/16_const.wat
new file mode 100644
index 000000000000..da01d3a64557
--- /dev/null
+++ b/tests/disas/winch/x64/i32_shl/16_const.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 512)
+        (i32.shl)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       shll    $0, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_shl/8_const.wat b/tests/disas/winch/x64/i32_shl/8_const.wat
new file mode 100644
index 000000000000..4e6ab0f64104
--- /dev/null
+++ b/tests/disas/winch/x64/i32_shl/8_const.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 2)
+        (i32.shl)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       shll    $2, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_shl/locals.wat b/tests/disas/winch/x64/i32_shl/locals.wat
new file mode 100644
index 000000000000..9192e07b9403
--- /dev/null
+++ b/tests/disas/winch/x64/i32_shl/locals.wat
@@ -0,0 +1,43 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)  
+        (local $bar i32)
+
+        (i32.const 1)
+        (local.set $foo)
+
+        (i32.const 2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.shl)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x57
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $1, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    $2, %eax
+;;       movl    %eax, 8(%rsp)
+;;       movl    8(%rsp), %ecx
+;;       movl    0xc(%rsp), %eax
+;;       shll    %cl, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   57: ud2
diff --git a/tests/disas/winch/x64/i32_shl/params.wat b/tests/disas/winch/x64/i32_shl/params.wat
new file mode 100644
index 000000000000..e5dfc78c4d4c
--- /dev/null
+++ b/tests/disas/winch/x64/i32_shl/params.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.shl)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x44
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    8(%rsp), %ecx
+;;       movl    0xc(%rsp), %eax
+;;       shll    %cl, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   44: ud2
diff --git a/tests/disas/winch/x64/i32_shr_s/16_const.wat b/tests/disas/winch/x64/i32_shr_s/16_const.wat
new file mode 100644
index 000000000000..0596e265631c
--- /dev/null
+++ b/tests/disas/winch/x64/i32_shr_s/16_const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 512)
+        (i32.shr_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       sarl    $0, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_shr_s/8_const.wat b/tests/disas/winch/x64/i32_shr_s/8_const.wat
new file mode 100644
index 000000000000..07366a3fe499
--- /dev/null
+++ b/tests/disas/winch/x64/i32_shr_s/8_const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 2)
+        (i32.shr_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       sarl    $2, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_shr_s/locals.wat b/tests/disas/winch/x64/i32_shr_s/locals.wat
new file mode 100644
index 000000000000..3bc8d1e71eb3
--- /dev/null
+++ b/tests/disas/winch/x64/i32_shr_s/locals.wat
@@ -0,0 +1,43 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)  
+        (local $bar i32)
+
+        (i32.const 1)
+        (local.set $foo)
+
+        (i32.const 2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.shr_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x57
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $1, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    $2, %eax
+;;       movl    %eax, 8(%rsp)
+;;       movl    8(%rsp), %ecx
+;;       movl    0xc(%rsp), %eax
+;;       sarl    %cl, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   57: ud2
diff --git a/tests/disas/winch/x64/i32_shr_s/params.wat b/tests/disas/winch/x64/i32_shr_s/params.wat
new file mode 100644
index 000000000000..9fc6e0c05dbe
--- /dev/null
+++ b/tests/disas/winch/x64/i32_shr_s/params.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.shr_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x44
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    8(%rsp), %ecx
+;;       movl    0xc(%rsp), %eax
+;;       sarl    %cl, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   44: ud2
diff --git a/tests/disas/winch/x64/i32_shr_u/16_const.wat b/tests/disas/winch/x64/i32_shr_u/16_const.wat
new file mode 100644
index 000000000000..ad2e0e48f1fa
--- /dev/null
+++ b/tests/disas/winch/x64/i32_shr_u/16_const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 512)
+        (i32.shr_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       shrl    $0, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_shr_u/8_const.wat b/tests/disas/winch/x64/i32_shr_u/8_const.wat
new file mode 100644
index 000000000000..a83ceb2af4fc
--- /dev/null
+++ b/tests/disas/winch/x64/i32_shr_u/8_const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 2)
+        (i32.shr_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       shrl    $2, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_shr_u/locals.wat b/tests/disas/winch/x64/i32_shr_u/locals.wat
new file mode 100644
index 000000000000..9bd73df19636
--- /dev/null
+++ b/tests/disas/winch/x64/i32_shr_u/locals.wat
@@ -0,0 +1,43 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)  
+        (local $bar i32)
+
+        (i32.const 1)
+        (local.set $foo)
+
+        (i32.const 2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.shr_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x57
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $1, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    $2, %eax
+;;       movl    %eax, 8(%rsp)
+;;       movl    8(%rsp), %ecx
+;;       movl    0xc(%rsp), %eax
+;;       shrl    %cl, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   57: ud2
diff --git a/tests/disas/winch/x64/i32_shr_u/params.wat b/tests/disas/winch/x64/i32_shr_u/params.wat
new file mode 100644
index 000000000000..a1d71fb6ddbe
--- /dev/null
+++ b/tests/disas/winch/x64/i32_shr_u/params.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.shr_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x44
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    8(%rsp), %ecx
+;;       movl    0xc(%rsp), %eax
+;;       shrl    %cl, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   44: ud2
diff --git a/tests/disas/winch/x64/i32_sub/const.wat b/tests/disas/winch/x64/i32_sub/const.wat
new file mode 100644
index 000000000000..73dd3cc77db7
--- /dev/null
+++ b/tests/disas/winch/x64/i32_sub/const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const 10)
+	(i32.const 20)
+	(i32.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0xa, %eax
+;;       subl    $0x14, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_sub/locals.wat b/tests/disas/winch/x64/i32_sub/locals.wat
new file mode 100644
index 000000000000..22c2548a2089
--- /dev/null
+++ b/tests/disas/winch/x64/i32_sub/locals.wat
@@ -0,0 +1,44 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)  
+        (local $bar i32)
+
+        (i32.const 10)
+        (local.set $foo)
+
+        (i32.const 20)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        i32.sub
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x59
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $0xa, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    $0x14, %eax
+;;       movl    %eax, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       subl    %eax, %ecx
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   59: ud2
diff --git a/tests/disas/winch/x64/i32_sub/max.wat b/tests/disas/winch/x64/i32_sub/max.wat
new file mode 100644
index 000000000000..f39a20621e82
--- /dev/null
+++ b/tests/disas/winch/x64/i32_sub/max.wat
@@ -0,0 +1,27 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+    (func (result i32)
+	(i32.const 0x7fffffff)
+	(i32.const -1)
+	(i32.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0x7fffffff, %eax
+;;       subl    $-1, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_sub/max_one.wat b/tests/disas/winch/x64/i32_sub/max_one.wat
new file mode 100644
index 000000000000..51a47785fb00
--- /dev/null
+++ b/tests/disas/winch/x64/i32_sub/max_one.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+	(i32.const 0x80000000)
+	(i32.const 1)
+	(i32.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0x80000000, %eax
+;;       subl    $1, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_sub/mixed.wat b/tests/disas/winch/x64/i32_sub/mixed.wat
new file mode 100644
index 000000000000..012ddb4c2a1a
--- /dev/null
+++ b/tests/disas/winch/x64/i32_sub/mixed.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const -1)
+	(i32.const 1)
+	(i32.sub)
+     )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0xffffffff, %eax
+;;       subl    $1, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_sub/params.wat b/tests/disas/winch/x64/i32_sub/params.wat
new file mode 100644
index 000000000000..2acb8f47a43e
--- /dev/null
+++ b/tests/disas/winch/x64/i32_sub/params.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+	(local.get 0)
+	(local.get 1)
+	(i32.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x46
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       subl    %eax, %ecx
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   46: ud2
diff --git a/tests/disas/winch/x64/i32_sub/signed.wat b/tests/disas/winch/x64/i32_sub/signed.wat
new file mode 100644
index 000000000000..fd219c95346e
--- /dev/null
+++ b/tests/disas/winch/x64/i32_sub/signed.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const -1)
+	(i32.const -1)
+	(i32.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0xffffffff, %eax
+;;       subl    $-1, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_sub/unsigned_with_zero.wat b/tests/disas/winch/x64/i32_sub/unsigned_with_zero.wat
new file mode 100644
index 000000000000..e0e5203d6908
--- /dev/null
+++ b/tests/disas/winch/x64/i32_sub/unsigned_with_zero.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+     	(i32.const 0)
+    	(i32.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       subl    $0, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_trunc_f32_s/const.wat b/tests/disas/winch/x64/i32_trunc_f32_s/const.wat
new file mode 100644
index 000000000000..7b2cab7c2cd7
--- /dev/null
+++ b/tests/disas/winch/x64/i32_trunc_f32_s/const.wat
@@ -0,0 +1,44 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (f32.const 1.0)
+        (i32.trunc_f32_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x73
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movss   0x4d(%rip), %xmm0
+;;       cvttss2si %xmm0, %eax
+;;       cmpl    $1, %eax
+;;       jno     0x6d
+;;   40: ucomiss %xmm0, %xmm0
+;;       jp      0x75
+;;   49: movl    $0xcf000000, %r11d
+;;       movd    %r11d, %xmm15
+;;       ucomiss %xmm15, %xmm0
+;;       jb      0x77
+;;   5e: xorpd   %xmm15, %xmm15
+;;       ucomiss %xmm0, %xmm15
+;;       jb      0x79
+;;   6d: addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   73: ud2
+;;   75: ud2
+;;   77: ud2
+;;   79: ud2
+;;   7b: addb    %al, (%rax)
+;;   7d: addb    %al, (%rax)
+;;   7f: addb    %al, (%rax)
diff --git a/tests/disas/winch/x64/i32_trunc_f32_s/locals.wat b/tests/disas/winch/x64/i32_trunc_f32_s/locals.wat
new file mode 100644
index 000000000000..a9d1ae3a697d
--- /dev/null
+++ b/tests/disas/winch/x64/i32_trunc_f32_s/locals.wat
@@ -0,0 +1,44 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local f32)  
+
+        (local.get 0)
+        (i32.trunc_f32_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x7b
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movss   0xc(%rsp), %xmm0
+;;       cvttss2si %xmm0, %eax
+;;       cmpl    $1, %eax
+;;       jno     0x75
+;;   48: ucomiss %xmm0, %xmm0
+;;       jp      0x7d
+;;   51: movl    $0xcf000000, %r11d
+;;       movd    %r11d, %xmm15
+;;       ucomiss %xmm15, %xmm0
+;;       jb      0x7f
+;;   66: xorpd   %xmm15, %xmm15
+;;       ucomiss %xmm0, %xmm15
+;;       jb      0x81
+;;   75: addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   7b: ud2
+;;   7d: ud2
+;;   7f: ud2
+;;   81: ud2
diff --git a/tests/disas/winch/x64/i32_trunc_f32_s/params.wat b/tests/disas/winch/x64/i32_trunc_f32_s/params.wat
new file mode 100644
index 000000000000..774342027062
--- /dev/null
+++ b/tests/disas/winch/x64/i32_trunc_f32_s/params.wat
@@ -0,0 +1,42 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (result i32)
+        (local.get 0)
+        (i32.trunc_f32_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x78
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0xc(%rsp), %xmm0
+;;       cvttss2si %xmm0, %eax
+;;       cmpl    $1, %eax
+;;       jno     0x72
+;;   45: ucomiss %xmm0, %xmm0
+;;       jp      0x7a
+;;   4e: movl    $0xcf000000, %r11d
+;;       movd    %r11d, %xmm15
+;;       ucomiss %xmm15, %xmm0
+;;       jb      0x7c
+;;   63: xorpd   %xmm15, %xmm15
+;;       ucomiss %xmm0, %xmm15
+;;       jb      0x7e
+;;   72: addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   78: ud2
+;;   7a: ud2
+;;   7c: ud2
+;;   7e: ud2
diff --git a/tests/disas/winch/x64/i32_trunc_f32_u/const.wat b/tests/disas/winch/x64/i32_trunc_f32_u/const.wat
new file mode 100644
index 000000000000..fd797005e3b6
--- /dev/null
+++ b/tests/disas/winch/x64/i32_trunc_f32_u/const.wat
@@ -0,0 +1,46 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (f32.const 1.0)
+        (i32.trunc_f32_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x7e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movss   0x55(%rip), %xmm1
+;;       movl    $0x4f000000, %r11d
+;;       movd    %r11d, %xmm15
+;;       ucomiss %xmm15, %xmm1
+;;       jae     0x5d
+;;       jp      0x80
+;;   4e: cvttss2si %xmm1, %eax
+;;       cmpl    $0, %eax
+;;       jge     0x78
+;;   5b: ud2
+;;       movaps  %xmm1, %xmm0
+;;       subss   %xmm15, %xmm0
+;;       cvttss2si %xmm0, %eax
+;;       cmpl    $0, %eax
+;;       jl      0x82
+;;   72: addl    $0x80000000, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   7e: ud2
+;;   80: ud2
+;;   82: ud2
+;;   84: addb    %al, (%rax)
+;;   86: addb    %al, (%rax)
+;;   88: addb    %al, (%rax)
diff --git a/tests/disas/winch/x64/i32_trunc_f32_u/locals.wat b/tests/disas/winch/x64/i32_trunc_f32_u/locals.wat
new file mode 100644
index 000000000000..3a1f076d4ef9
--- /dev/null
+++ b/tests/disas/winch/x64/i32_trunc_f32_u/locals.wat
@@ -0,0 +1,46 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local f32)  
+
+        (local.get 0)
+        (i32.trunc_f32_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x86
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movss   0xc(%rsp), %xmm1
+;;       movl    $0x4f000000, %r11d
+;;       movd    %r11d, %xmm15
+;;       ucomiss %xmm15, %xmm1
+;;       jae     0x65
+;;       jp      0x88
+;;   56: cvttss2si %xmm1, %eax
+;;       cmpl    $0, %eax
+;;       jge     0x80
+;;   63: ud2
+;;       movaps  %xmm1, %xmm0
+;;       subss   %xmm15, %xmm0
+;;       cvttss2si %xmm0, %eax
+;;       cmpl    $0, %eax
+;;       jl      0x8a
+;;   7a: addl    $0x80000000, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   86: ud2
+;;   88: ud2
+;;   8a: ud2
diff --git a/tests/disas/winch/x64/i32_trunc_f32_u/params.wat b/tests/disas/winch/x64/i32_trunc_f32_u/params.wat
new file mode 100644
index 000000000000..b51d82cc5ab5
--- /dev/null
+++ b/tests/disas/winch/x64/i32_trunc_f32_u/params.wat
@@ -0,0 +1,44 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (result i32)
+        (local.get 0)
+        (i32.trunc_f32_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x83
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0xc(%rsp), %xmm1
+;;       movl    $0x4f000000, %r11d
+;;       movd    %r11d, %xmm15
+;;       ucomiss %xmm15, %xmm1
+;;       jae     0x62
+;;       jp      0x85
+;;   53: cvttss2si %xmm1, %eax
+;;       cmpl    $0, %eax
+;;       jge     0x7d
+;;   60: ud2
+;;       movaps  %xmm1, %xmm0
+;;       subss   %xmm15, %xmm0
+;;       cvttss2si %xmm0, %eax
+;;       cmpl    $0, %eax
+;;       jl      0x87
+;;   77: addl    $0x80000000, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   83: ud2
+;;   85: ud2
+;;   87: ud2
diff --git a/tests/disas/winch/x64/i32_trunc_f64_s/const.wat b/tests/disas/winch/x64/i32_trunc_f64_s/const.wat
new file mode 100644
index 000000000000..bbdade444d43
--- /dev/null
+++ b/tests/disas/winch/x64/i32_trunc_f64_s/const.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (f64.const 1.0)
+        (i32.trunc_f64_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x7a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movsd   0x55(%rip), %xmm0
+;;       cvttsd2si %xmm0, %eax
+;;       cmpl    $1, %eax
+;;       jno     0x74
+;;   40: ucomisd %xmm0, %xmm0
+;;       jp      0x7c
+;;   4a: movabsq $13970166044105375744, %r11
+;;       movq    %r11, %xmm15
+;;       ucomisd %xmm15, %xmm0
+;;       jbe     0x7e
+;;   64: xorpd   %xmm15, %xmm15
+;;       ucomisd %xmm0, %xmm15
+;;       jb      0x80
+;;   74: addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   7a: ud2
+;;   7c: ud2
+;;   7e: ud2
+;;   80: ud2
+;;   82: addb    %al, (%rax)
+;;   84: addb    %al, (%rax)
+;;   86: addb    %al, (%rax)
+;;   88: addb    %al, (%rax)
+;;   8a: addb    %al, (%rax)
+;;   8c: addb    %al, (%rax)
diff --git a/tests/disas/winch/x64/i32_trunc_f64_s/locals.wat b/tests/disas/winch/x64/i32_trunc_f64_s/locals.wat
new file mode 100644
index 000000000000..f90481b0307b
--- /dev/null
+++ b/tests/disas/winch/x64/i32_trunc_f64_s/locals.wat
@@ -0,0 +1,44 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local f64)  
+
+        (local.get 0)
+        (i32.trunc_f64_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x82
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movsd   8(%rsp), %xmm0
+;;       cvttsd2si %xmm0, %eax
+;;       cmpl    $1, %eax
+;;       jno     0x7c
+;;   48: ucomisd %xmm0, %xmm0
+;;       jp      0x84
+;;   52: movabsq $13970166044105375744, %r11
+;;       movq    %r11, %xmm15
+;;       ucomisd %xmm15, %xmm0
+;;       jbe     0x86
+;;   6c: xorpd   %xmm15, %xmm15
+;;       ucomisd %xmm0, %xmm15
+;;       jb      0x88
+;;   7c: addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   82: ud2
+;;   84: ud2
+;;   86: ud2
+;;   88: ud2
diff --git a/tests/disas/winch/x64/i32_trunc_f64_s/params.wat b/tests/disas/winch/x64/i32_trunc_f64_s/params.wat
new file mode 100644
index 000000000000..af4882b56200
--- /dev/null
+++ b/tests/disas/winch/x64/i32_trunc_f64_s/params.wat
@@ -0,0 +1,42 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (result i32)
+        (local.get 0)
+        (i32.trunc_f64_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x7f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   8(%rsp), %xmm0
+;;       cvttsd2si %xmm0, %eax
+;;       cmpl    $1, %eax
+;;       jno     0x79
+;;   45: ucomisd %xmm0, %xmm0
+;;       jp      0x81
+;;   4f: movabsq $13970166044105375744, %r11
+;;       movq    %r11, %xmm15
+;;       ucomisd %xmm15, %xmm0
+;;       jbe     0x83
+;;   69: xorpd   %xmm15, %xmm15
+;;       ucomisd %xmm0, %xmm15
+;;       jb      0x85
+;;   79: addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   7f: ud2
+;;   81: ud2
+;;   83: ud2
+;;   85: ud2
diff --git a/tests/disas/winch/x64/i32_trunc_f64_u/const.wat b/tests/disas/winch/x64/i32_trunc_f64_u/const.wat
new file mode 100644
index 000000000000..a15a80948f60
--- /dev/null
+++ b/tests/disas/winch/x64/i32_trunc_f64_u/const.wat
@@ -0,0 +1,50 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (f64.const 1.0)
+        (i32.trunc_f64_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x83
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movsd   0x5d(%rip), %xmm1
+;;       movabsq $0x41e0000000000000, %r11
+;;       movq    %r11, %xmm15
+;;       ucomisd %xmm15, %xmm1
+;;       jae     0x62
+;;       jp      0x85
+;;   53: cvttsd2si %xmm1, %eax
+;;       cmpl    $0, %eax
+;;       jge     0x7d
+;;   60: ud2
+;;       movaps  %xmm1, %xmm0
+;;       subsd   %xmm15, %xmm0
+;;       cvttsd2si %xmm0, %eax
+;;       cmpl    $0, %eax
+;;       jl      0x87
+;;   77: addl    $0x80000000, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   83: ud2
+;;   85: ud2
+;;   87: ud2
+;;   89: addb    %al, (%rax)
+;;   8b: addb    %al, (%rax)
+;;   8d: addb    %al, (%rax)
+;;   8f: addb    %al, (%rax)
+;;   91: addb    %al, (%rax)
+;;   93: addb    %al, (%rax)
+;;   95: addb    %dh, %al
diff --git a/tests/disas/winch/x64/i32_trunc_f64_u/locals.wat b/tests/disas/winch/x64/i32_trunc_f64_u/locals.wat
new file mode 100644
index 000000000000..51dfb9f6f2f6
--- /dev/null
+++ b/tests/disas/winch/x64/i32_trunc_f64_u/locals.wat
@@ -0,0 +1,46 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local f64)  
+
+        (local.get 0)
+        (i32.trunc_f64_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x8b
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movsd   8(%rsp), %xmm1
+;;       movabsq $0x41e0000000000000, %r11
+;;       movq    %r11, %xmm15
+;;       ucomisd %xmm15, %xmm1
+;;       jae     0x6a
+;;       jp      0x8d
+;;   5b: cvttsd2si %xmm1, %eax
+;;       cmpl    $0, %eax
+;;       jge     0x85
+;;   68: ud2
+;;       movaps  %xmm1, %xmm0
+;;       subsd   %xmm15, %xmm0
+;;       cvttsd2si %xmm0, %eax
+;;       cmpl    $0, %eax
+;;       jl      0x8f
+;;   7f: addl    $0x80000000, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   8b: ud2
+;;   8d: ud2
+;;   8f: ud2
diff --git a/tests/disas/winch/x64/i32_trunc_f64_u/params.wat b/tests/disas/winch/x64/i32_trunc_f64_u/params.wat
new file mode 100644
index 000000000000..a98c09654539
--- /dev/null
+++ b/tests/disas/winch/x64/i32_trunc_f64_u/params.wat
@@ -0,0 +1,44 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (result i32)
+        (local.get 0)
+        (i32.trunc_f64_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x88
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   8(%rsp), %xmm1
+;;       movabsq $0x41e0000000000000, %r11
+;;       movq    %r11, %xmm15
+;;       ucomisd %xmm15, %xmm1
+;;       jae     0x67
+;;       jp      0x8a
+;;   58: cvttsd2si %xmm1, %eax
+;;       cmpl    $0, %eax
+;;       jge     0x82
+;;   65: ud2
+;;       movaps  %xmm1, %xmm0
+;;       subsd   %xmm15, %xmm0
+;;       cvttsd2si %xmm0, %eax
+;;       cmpl    $0, %eax
+;;       jl      0x8c
+;;   7c: addl    $0x80000000, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   88: ud2
+;;   8a: ud2
+;;   8c: ud2
diff --git a/tests/disas/winch/x64/i32_wrap_i64/const.wat b/tests/disas/winch/x64/i32_wrap_i64/const.wat
new file mode 100644
index 000000000000..9a5b7129ad25
--- /dev/null
+++ b/tests/disas/winch/x64/i32_wrap_i64/const.wat
@@ -0,0 +1,27 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 1)
+        (i32.wrap_i64)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       movl    %eax, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3a: ud2
diff --git a/tests/disas/winch/x64/i32_wrap_i64/locals.wat b/tests/disas/winch/x64/i32_wrap_i64/locals.wat
new file mode 100644
index 000000000000..b4a6cd1ef67f
--- /dev/null
+++ b/tests/disas/winch/x64/i32_wrap_i64/locals.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local i64)
+
+        (local.get 0)
+        (i32.wrap_i64)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x42
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movq    8(%rsp), %rax
+;;       movl    %eax, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   42: ud2
diff --git a/tests/disas/winch/x64/i32_wrap_i64/params.wat b/tests/disas/winch/x64/i32_wrap_i64/params.wat
new file mode 100644
index 000000000000..22b338da1679
--- /dev/null
+++ b/tests/disas/winch/x64/i32_wrap_i64/params.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (result i32)
+        (local.get 0)
+        (i32.wrap_i64)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    8(%rsp), %rax
+;;       movl    %eax, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3e: ud2
diff --git a/tests/disas/winch/x64/i32_wrap_i64/spilled.wat b/tests/disas/winch/x64/i32_wrap_i64/spilled.wat
new file mode 100644
index 000000000000..af588e3a616f
--- /dev/null
+++ b/tests/disas/winch/x64/i32_wrap_i64/spilled.wat
@@ -0,0 +1,33 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        i64.const 1
+        i32.wrap_i64
+        block
+        end
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x14, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x48
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       movl    %eax, %eax
+;;       subq    $4, %rsp
+;;       movl    %eax, (%rsp)
+;;       movl    (%rsp), %eax
+;;       addq    $4, %rsp
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   48: ud2
diff --git a/tests/disas/winch/x64/i32_xor/const.wat b/tests/disas/winch/x64/i32_xor/const.wat
new file mode 100644
index 000000000000..d775a914f94d
--- /dev/null
+++ b/tests/disas/winch/x64/i32_xor/const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i32.const 1)
+        (i32.const 2)
+        (i32.xor)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       xorl    $2, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i32_xor/locals.wat b/tests/disas/winch/x64/i32_xor/locals.wat
new file mode 100644
index 000000000000..cb77a435c0e7
--- /dev/null
+++ b/tests/disas/winch/x64/i32_xor/locals.wat
@@ -0,0 +1,44 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i32)  
+        (local $bar i32)
+
+        (i32.const 1)
+        (local.set $foo)
+
+        (i32.const 2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i32.xor)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x59
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $1, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    $2, %eax
+;;       movl    %eax, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       xorl    %eax, %ecx
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   59: ud2
diff --git a/tests/disas/winch/x64/i32_xor/params.wat b/tests/disas/winch/x64/i32_xor/params.wat
new file mode 100644
index 000000000000..2546fccb1cca
--- /dev/null
+++ b/tests/disas/winch/x64/i32_xor/params.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (param i32) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i32.xor)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x46
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    8(%rsp), %eax
+;;       movl    0xc(%rsp), %ecx
+;;       xorl    %eax, %ecx
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   46: ud2
diff --git a/tests/disas/winch/x64/i64_add/const.wat b/tests/disas/winch/x64/i64_add/const.wat
new file mode 100644
index 000000000000..ac1514efadec
--- /dev/null
+++ b/tests/disas/winch/x64/i64_add/const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const 10)
+	(i64.const 20)
+	(i64.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $0xa, %rax
+;;       addq    $0x14, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
diff --git a/tests/disas/winch/x64/i64_add/locals.wat b/tests/disas/winch/x64/i64_add/locals.wat
new file mode 100644
index 000000000000..aa2271638540
--- /dev/null
+++ b/tests/disas/winch/x64/i64_add/locals.wat
@@ -0,0 +1,46 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local $foo i64)  
+        (local $bar i64)
+
+        (i64.const 10)
+        (local.set $foo)
+
+        (i64.const 20)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        i64.add
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x64
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movq    $0xa, %rax
+;;       movq    %rax, 8(%rsp)
+;;       movq    $0x14, %rax
+;;       movq    %rax, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       addq    %rax, %rcx
+;;       movq    %rcx, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   64: ud2
diff --git a/tests/disas/winch/x64/i64_add/max.wat b/tests/disas/winch/x64/i64_add/max.wat
new file mode 100644
index 000000000000..35c236cde295
--- /dev/null
+++ b/tests/disas/winch/x64/i64_add/max.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+    (func (result i64)
+	(i64.const 1)
+	(i64.const 0x7fffffffffffffff)
+	(i64.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x45
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       movabsq $0x7fffffffffffffff, %r11
+;;       addq    %r11, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   45: ud2
diff --git a/tests/disas/winch/x64/i64_add/max_one.wat b/tests/disas/winch/x64/i64_add/max_one.wat
new file mode 100644
index 000000000000..82c44cceaea7
--- /dev/null
+++ b/tests/disas/winch/x64/i64_add/max_one.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const 0x8000000000000000)
+	(i64.const -1)
+	(i64.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movabsq $9223372036854775808, %rax
+;;       addq    $-1, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3f: ud2
diff --git a/tests/disas/winch/x64/i64_add/mixed.wat b/tests/disas/winch/x64/i64_add/mixed.wat
new file mode 100644
index 000000000000..3224d883021c
--- /dev/null
+++ b/tests/disas/winch/x64/i64_add/mixed.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const -1)
+	(i64.const 1)
+	(i64.add)
+     )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $18446744073709551615, %rax
+;;       addq    $1, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
diff --git a/tests/disas/winch/x64/i64_add/params.wat b/tests/disas/winch/x64/i64_add/params.wat
new file mode 100644
index 000000000000..8e88b2fe8baf
--- /dev/null
+++ b/tests/disas/winch/x64/i64_add/params.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i64)
+	(local.get 0)
+	(local.get 1)
+	(i64.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    %rcx, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       addq    %rax, %rcx
+;;       movq    %rcx, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4a: ud2
diff --git a/tests/disas/winch/x64/i64_add/signed.wat b/tests/disas/winch/x64/i64_add/signed.wat
new file mode 100644
index 000000000000..ade6a5af0ea2
--- /dev/null
+++ b/tests/disas/winch/x64/i64_add/signed.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const -1)
+	(i64.const -1)
+	(i64.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $18446744073709551615, %rax
+;;       addq    $-1, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
diff --git a/tests/disas/winch/x64/i64_add/unsigned_with_zero.wat b/tests/disas/winch/x64/i64_add/unsigned_with_zero.wat
new file mode 100644
index 000000000000..4cd53a5f0ef0
--- /dev/null
+++ b/tests/disas/winch/x64/i64_add/unsigned_with_zero.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+     	(i64.const 0)
+    	(i64.add)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       addq    $0, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
diff --git a/tests/disas/winch/x64/i64_and/32_const.wat b/tests/disas/winch/x64/i64_and/32_const.wat
new file mode 100644
index 000000000000..94531f193569
--- /dev/null
+++ b/tests/disas/winch/x64/i64_and/32_const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 2)
+        (i64.const 3)
+        (i64.and)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $2, %rax
+;;       andq    $3, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
diff --git a/tests/disas/winch/x64/i64_and/64_const.wat b/tests/disas/winch/x64/i64_and/64_const.wat
new file mode 100644
index 000000000000..c9cfc813a197
--- /dev/null
+++ b/tests/disas/winch/x64/i64_and/64_const.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 9223372036854775806)
+        (i64.const 9223372036854775807)
+        (i64.and)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x48
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movabsq $0x7ffffffffffffffe, %rax
+;;       movabsq $0x7fffffffffffffff, %r11
+;;       andq    %r11, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   48: ud2
diff --git a/tests/disas/winch/x64/i64_and/locals.wat b/tests/disas/winch/x64/i64_and/locals.wat
new file mode 100644
index 000000000000..6571ab031c35
--- /dev/null
+++ b/tests/disas/winch/x64/i64_and/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local $foo i64)
+        (local $bar i64)
+
+        (i64.const 2)
+        (local.set $foo)
+        (i64.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.and)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x64
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movq    $2, %rax
+;;       movq    %rax, 8(%rsp)
+;;       movq    $3, %rax
+;;       movq    %rax, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       andq    %rax, %rcx
+;;       movq    %rcx, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   64: ud2
diff --git a/tests/disas/winch/x64/i64_and/params.wat b/tests/disas/winch/x64/i64_and/params.wat
new file mode 100644
index 000000000000..f5310b3100ae
--- /dev/null
+++ b/tests/disas/winch/x64/i64_and/params.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i64)
+        (local.get 0)
+        (local.get 1)
+        (i64.and)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    %rcx, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       andq    %rax, %rcx
+;;       movq    %rcx, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4a: ud2
diff --git a/tests/disas/winch/x64/i64_clz/lzcnt_const.wat b/tests/disas/winch/x64/i64_clz/lzcnt_const.wat
new file mode 100644
index 000000000000..62d318d3f72e
--- /dev/null
+++ b/tests/disas/winch/x64/i64_clz/lzcnt_const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_lzcnt"]
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.clz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       lzcntq  %rax, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3d: ud2
diff --git a/tests/disas/winch/x64/i64_clz/lzcnt_local.wat b/tests/disas/winch/x64/i64_clz/lzcnt_local.wat
new file mode 100644
index 000000000000..28f299c9635d
--- /dev/null
+++ b/tests/disas/winch/x64/i64_clz/lzcnt_local.wat
@@ -0,0 +1,36 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_lzcnt"]
+
+(module
+    (func (result i64)
+        (local $foo i64)
+
+        (i64.const 2)
+        (local.set $foo)
+
+        (local.get $foo)
+        (i64.clz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x51
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movq    $2, %rax
+;;       movq    %rax, 8(%rsp)
+;;       movq    8(%rsp), %rax
+;;       lzcntq  %rax, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   51: ud2
diff --git a/tests/disas/winch/x64/i64_clz/lzcnt_param.wat b/tests/disas/winch/x64/i64_clz/lzcnt_param.wat
new file mode 100644
index 000000000000..1064e6bcadf2
--- /dev/null
+++ b/tests/disas/winch/x64/i64_clz/lzcnt_param.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_lzcnt"]
+
+(module
+    (func (param i64) (result i64)
+        (local.get 0)
+        (i64.clz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x41
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    8(%rsp), %rax
+;;       lzcntq  %rax, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   41: ud2
diff --git a/tests/disas/winch/x64/i64_clz/no_lzcnt_const.wat b/tests/disas/winch/x64/i64_clz/no_lzcnt_const.wat
new file mode 100644
index 000000000000..fd2716740ad5
--- /dev/null
+++ b/tests/disas/winch/x64/i64_clz/no_lzcnt_const.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.clz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x50
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       bsrq    %rax, %rax
+;;       movl    $0, %r11d
+;;       setne   %r11b
+;;       negq    %rax
+;;       addq    $0x40, %rax
+;;       subq    %r11, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   50: ud2
diff --git a/tests/disas/winch/x64/i64_clz/no_lzcnt_local.wat b/tests/disas/winch/x64/i64_clz/no_lzcnt_local.wat
new file mode 100644
index 000000000000..7f95d62c876f
--- /dev/null
+++ b/tests/disas/winch/x64/i64_clz/no_lzcnt_local.wat
@@ -0,0 +1,40 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local $foo i64)
+
+        (i64.const 2)
+        (local.set $foo)
+
+        (local.get $foo)
+        (i64.clz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x64
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movq    $2, %rax
+;;       movq    %rax, 8(%rsp)
+;;       movq    8(%rsp), %rax
+;;       bsrq    %rax, %rax
+;;       movl    $0, %r11d
+;;       setne   %r11b
+;;       negq    %rax
+;;       addq    $0x40, %rax
+;;       subq    %r11, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   64: ud2
diff --git a/tests/disas/winch/x64/i64_clz/no_lzcnt_param.wat b/tests/disas/winch/x64/i64_clz/no_lzcnt_param.wat
new file mode 100644
index 000000000000..0802b7af50f9
--- /dev/null
+++ b/tests/disas/winch/x64/i64_clz/no_lzcnt_param.wat
@@ -0,0 +1,33 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (result i64)
+        (local.get 0)
+        (i64.clz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x54
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    8(%rsp), %rax
+;;       bsrq    %rax, %rax
+;;       movl    $0, %r11d
+;;       setne   %r11b
+;;       negq    %rax
+;;       addq    $0x40, %rax
+;;       subq    %r11, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   54: ud2
diff --git a/tests/disas/winch/x64/i64_ctz/bmi1_const.wat b/tests/disas/winch/x64/i64_ctz/bmi1_const.wat
new file mode 100644
index 000000000000..019f05f43744
--- /dev/null
+++ b/tests/disas/winch/x64/i64_ctz/bmi1_const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_bmi1"]
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.ctz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       tzcntq  %rax, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3d: ud2
diff --git a/tests/disas/winch/x64/i64_ctz/bmi1_local.wat b/tests/disas/winch/x64/i64_ctz/bmi1_local.wat
new file mode 100644
index 000000000000..5cd93805f246
--- /dev/null
+++ b/tests/disas/winch/x64/i64_ctz/bmi1_local.wat
@@ -0,0 +1,36 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_bmi1"]
+
+(module
+    (func (result i64)
+        (local $foo i64)
+
+        (i64.const 2)
+        (local.set $foo)
+
+        (local.get $foo)
+        (i64.ctz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x51
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movq    $2, %rax
+;;       movq    %rax, 8(%rsp)
+;;       movq    8(%rsp), %rax
+;;       tzcntq  %rax, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   51: ud2
diff --git a/tests/disas/winch/x64/i64_ctz/bmi1_param.wat b/tests/disas/winch/x64/i64_ctz/bmi1_param.wat
new file mode 100644
index 000000000000..cf4eaa7a625a
--- /dev/null
+++ b/tests/disas/winch/x64/i64_ctz/bmi1_param.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_bmi1"]
+
+(module
+    (func (param i64) (result i64)
+        (local.get 0)
+        (i64.ctz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x41
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    8(%rsp), %rax
+;;       tzcntq  %rax, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   41: ud2
diff --git a/tests/disas/winch/x64/i64_ctz/no_bmi1_const.wat b/tests/disas/winch/x64/i64_ctz/no_bmi1_const.wat
new file mode 100644
index 000000000000..9114939f2aa1
--- /dev/null
+++ b/tests/disas/winch/x64/i64_ctz/no_bmi1_const.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.ctz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       bsfq    %rax, %rax
+;;       movl    $0, %r11d
+;;       sete    %r11b
+;;       shlq    $6, %r11
+;;       addq    %r11, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4d: ud2
diff --git a/tests/disas/winch/x64/i64_ctz/no_bmi1_local.wat b/tests/disas/winch/x64/i64_ctz/no_bmi1_local.wat
new file mode 100644
index 000000000000..db19dee19d9d
--- /dev/null
+++ b/tests/disas/winch/x64/i64_ctz/no_bmi1_local.wat
@@ -0,0 +1,39 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local $foo i64)
+
+        (i64.const 2)
+        (local.set $foo)
+
+        (local.get $foo)
+        (i64.ctz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x61
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movq    $2, %rax
+;;       movq    %rax, 8(%rsp)
+;;       movq    8(%rsp), %rax
+;;       bsfq    %rax, %rax
+;;       movl    $0, %r11d
+;;       sete    %r11b
+;;       shlq    $6, %r11
+;;       addq    %r11, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   61: ud2
diff --git a/tests/disas/winch/x64/i64_ctz/no_bmi1_param.wat b/tests/disas/winch/x64/i64_ctz/no_bmi1_param.wat
new file mode 100644
index 000000000000..bf247bfef5b6
--- /dev/null
+++ b/tests/disas/winch/x64/i64_ctz/no_bmi1_param.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (result i64)
+        (local.get 0)
+        (i64.ctz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x51
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    8(%rsp), %rax
+;;       bsfq    %rax, %rax
+;;       movl    $0, %r11d
+;;       sete    %r11b
+;;       shlq    $6, %r11
+;;       addq    %r11, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   51: ud2
diff --git a/tests/disas/winch/x64/i64_divs/const.wat b/tests/disas/winch/x64/i64_divs/const.wat
new file mode 100644
index 000000000000..45d2d4283e03
--- /dev/null
+++ b/tests/disas/winch/x64/i64_divs/const.wat
@@ -0,0 +1,33 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const 20)
+	(i64.const 10)
+	(i64.div_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $0xa, %rcx
+;;       movq    $0x14, %rax
+;;       cmpq    $0, %rcx
+;;       je      0x50
+;;   43: cqto
+;;       idivq   %rcx
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4e: ud2
+;;   50: ud2
diff --git a/tests/disas/winch/x64/i64_divs/one_zero.wat b/tests/disas/winch/x64/i64_divs/one_zero.wat
new file mode 100644
index 000000000000..2419a3145f09
--- /dev/null
+++ b/tests/disas/winch/x64/i64_divs/one_zero.wat
@@ -0,0 +1,33 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const 1)
+	(i64.const 0)
+	(i64.div_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $0, %rcx
+;;       movq    $1, %rax
+;;       cmpq    $0, %rcx
+;;       je      0x50
+;;   43: cqto
+;;       idivq   %rcx
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4e: ud2
+;;   50: ud2
diff --git a/tests/disas/winch/x64/i64_divs/overflow.wat b/tests/disas/winch/x64/i64_divs/overflow.wat
new file mode 100644
index 000000000000..f000191b40eb
--- /dev/null
+++ b/tests/disas/winch/x64/i64_divs/overflow.wat
@@ -0,0 +1,33 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const 0x8000000000000000)
+	(i64.const -1)
+	(i64.div_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x51
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $18446744073709551615, %rcx
+;;       movabsq $9223372036854775808, %rax
+;;       cmpq    $0, %rcx
+;;       je      0x53
+;;   46: cqto
+;;       idivq   %rcx
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   51: ud2
+;;   53: ud2
diff --git a/tests/disas/winch/x64/i64_divs/params.wat b/tests/disas/winch/x64/i64_divs/params.wat
new file mode 100644
index 000000000000..d6751aaf2313
--- /dev/null
+++ b/tests/disas/winch/x64/i64_divs/params.wat
@@ -0,0 +1,35 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i64)
+	(local.get 0)
+	(local.get 1)
+	(i64.div_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x53
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    %rcx, (%rsp)
+;;       movq    (%rsp), %rcx
+;;       movq    8(%rsp), %rax
+;;       cmpq    $0, %rcx
+;;       je      0x55
+;;   48: cqto
+;;       idivq   %rcx
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   53: ud2
+;;   55: ud2
diff --git a/tests/disas/winch/x64/i64_divs/zero_zero.wat b/tests/disas/winch/x64/i64_divs/zero_zero.wat
new file mode 100644
index 000000000000..c664fcc579ef
--- /dev/null
+++ b/tests/disas/winch/x64/i64_divs/zero_zero.wat
@@ -0,0 +1,33 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const 0)
+	(i64.const 0)
+	(i64.div_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $0, %rcx
+;;       movq    $0, %rax
+;;       cmpq    $0, %rcx
+;;       je      0x50
+;;   43: cqto
+;;       idivq   %rcx
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4e: ud2
+;;   50: ud2
diff --git a/tests/disas/winch/x64/i64_divu/const.wat b/tests/disas/winch/x64/i64_divu/const.wat
new file mode 100644
index 000000000000..7e88ca7218d8
--- /dev/null
+++ b/tests/disas/winch/x64/i64_divu/const.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const 20)
+	(i64.const 10)
+	(i64.div_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x45
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $0xa, %rcx
+;;       movq    $0x14, %rax
+;;       xorq    %rdx, %rdx
+;;       divq    %rcx
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   45: ud2
diff --git a/tests/disas/winch/x64/i64_divu/one_zero.wat b/tests/disas/winch/x64/i64_divu/one_zero.wat
new file mode 100644
index 000000000000..1637e3583fad
--- /dev/null
+++ b/tests/disas/winch/x64/i64_divu/one_zero.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const 1)
+	(i64.const 0)
+	(i64.div_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x45
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $0, %rcx
+;;       movq    $1, %rax
+;;       xorq    %rdx, %rdx
+;;       divq    %rcx
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   45: ud2
diff --git a/tests/disas/winch/x64/i64_divu/params.wat b/tests/disas/winch/x64/i64_divu/params.wat
new file mode 100644
index 000000000000..1a2ce3ae76d8
--- /dev/null
+++ b/tests/disas/winch/x64/i64_divu/params.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i64)
+	(local.get 0)
+	(local.get 1)
+	(i64.div_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    %rcx, (%rsp)
+;;       movq    (%rsp), %rcx
+;;       movq    8(%rsp), %rax
+;;       xorq    %rdx, %rdx
+;;       divq    %rcx
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4a: ud2
diff --git a/tests/disas/winch/x64/i64_divu/signed.wat b/tests/disas/winch/x64/i64_divu/signed.wat
new file mode 100644
index 000000000000..a261bbafe052
--- /dev/null
+++ b/tests/disas/winch/x64/i64_divu/signed.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const -1)
+	(i64.const -1)
+	(i64.div_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x45
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $18446744073709551615, %rcx
+;;       movq    $18446744073709551615, %rax
+;;       xorq    %rdx, %rdx
+;;       divq    %rcx
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   45: ud2
diff --git a/tests/disas/winch/x64/i64_divu/zero_zero.wat b/tests/disas/winch/x64/i64_divu/zero_zero.wat
new file mode 100644
index 000000000000..fd663dfe7961
--- /dev/null
+++ b/tests/disas/winch/x64/i64_divu/zero_zero.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const 0)
+	(i64.const 0)
+	(i64.div_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x45
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $0, %rcx
+;;       movq    $0, %rax
+;;       xorq    %rdx, %rdx
+;;       divq    %rcx
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   45: ud2
diff --git a/tests/disas/winch/x64/i64_eq/32_const.wat b/tests/disas/winch/x64/i64_eq/32_const.wat
new file mode 100644
index 000000000000..6b9168f3422b
--- /dev/null
+++ b/tests/disas/winch/x64/i64_eq/32_const.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 2)
+        (i64.const 3)
+        (i64.eq)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x45
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $2, %rax
+;;       cmpq    $3, %rax
+;;       movl    $0, %eax
+;;       sete    %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   45: ud2
diff --git a/tests/disas/winch/x64/i64_eq/64_const.wat b/tests/disas/winch/x64/i64_eq/64_const.wat
new file mode 100644
index 000000000000..3a68c0a5764b
--- /dev/null
+++ b/tests/disas/winch/x64/i64_eq/64_const.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 9223372036854775806)
+        (i64.const 9223372036854775807)
+        (i64.eq)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x51
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movabsq $0x7ffffffffffffffe, %rax
+;;       movabsq $0x7fffffffffffffff, %r11
+;;       cmpq    %r11, %rax
+;;       movl    $0, %eax
+;;       sete    %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   51: ud2
diff --git a/tests/disas/winch/x64/i64_eq/locals.wat b/tests/disas/winch/x64/i64_eq/locals.wat
new file mode 100644
index 000000000000..4f98603e18c3
--- /dev/null
+++ b/tests/disas/winch/x64/i64_eq/locals.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i64)
+        (local $bar i64)
+
+        (i64.const 2)
+        (local.set $foo)
+        (i64.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.eq)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movq    $2, %rax
+;;       movq    %rax, 8(%rsp)
+;;       movq    $3, %rax
+;;       movq    %rax, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       cmpq    %rax, %rcx
+;;       movl    $0, %ecx
+;;       sete    %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6c: ud2
diff --git a/tests/disas/winch/x64/i64_eq/params.wat b/tests/disas/winch/x64/i64_eq/params.wat
new file mode 100644
index 000000000000..b26985ffb68d
--- /dev/null
+++ b/tests/disas/winch/x64/i64_eq/params.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i64.eq)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x52
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    %rcx, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       cmpq    %rax, %rcx
+;;       movl    $0, %ecx
+;;       sete    %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   52: ud2
diff --git a/tests/disas/winch/x64/i64_eqz/32_const.wat b/tests/disas/winch/x64/i64_eqz/32_const.wat
new file mode 100644
index 000000000000..63b99ba1cffd
--- /dev/null
+++ b/tests/disas/winch/x64/i64_eqz/32_const.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 1)
+        (i64.eqz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x45
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       cmpq    $0, %rax
+;;       movl    $0, %eax
+;;       sete    %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   45: ud2
diff --git a/tests/disas/winch/x64/i64_eqz/64_const.wat b/tests/disas/winch/x64/i64_eqz/64_const.wat
new file mode 100644
index 000000000000..8fe8ec5e2169
--- /dev/null
+++ b/tests/disas/winch/x64/i64_eqz/64_const.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 9223372036854775807)
+        (i64.eqz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x48
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movabsq $0x7fffffffffffffff, %rax
+;;       cmpq    $0, %rax
+;;       movl    $0, %eax
+;;       sete    %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   48: ud2
diff --git a/tests/disas/winch/x64/i64_eqz/local.wat b/tests/disas/winch/x64/i64_eqz/local.wat
new file mode 100644
index 000000000000..3c5de92fc4ba
--- /dev/null
+++ b/tests/disas/winch/x64/i64_eqz/local.wat
@@ -0,0 +1,37 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i64)
+
+        (i64.const 2)
+        (local.set $foo)
+
+        (local.get $foo)
+        (i64.eqz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x59
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movq    $2, %rax
+;;       movq    %rax, 8(%rsp)
+;;       movq    8(%rsp), %rax
+;;       cmpq    $0, %rax
+;;       movl    $0, %eax
+;;       sete    %al
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   59: ud2
diff --git a/tests/disas/winch/x64/i64_eqz/param.wat b/tests/disas/winch/x64/i64_eqz/param.wat
new file mode 100644
index 000000000000..073a7b7bd46e
--- /dev/null
+++ b/tests/disas/winch/x64/i64_eqz/param.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (result i32)
+        (local.get 0)
+        (i64.eqz)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x49
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    8(%rsp), %rax
+;;       cmpq    $0, %rax
+;;       movl    $0, %eax
+;;       sete    %al
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   49: ud2
diff --git a/tests/disas/winch/x64/i64_eqz/spilled.wat b/tests/disas/winch/x64/i64_eqz/spilled.wat
new file mode 100644
index 000000000000..1466e7158a6b
--- /dev/null
+++ b/tests/disas/winch/x64/i64_eqz/spilled.wat
@@ -0,0 +1,35 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        i64.const 1
+        i64.eqz
+        block
+        end
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x14, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x53
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       cmpq    $0, %rax
+;;       movl    $0, %eax
+;;       sete    %al
+;;       subq    $4, %rsp
+;;       movl    %eax, (%rsp)
+;;       movl    (%rsp), %eax
+;;       addq    $4, %rsp
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   53: ud2
diff --git a/tests/disas/winch/x64/i64_extend_16_s/const.wat b/tests/disas/winch/x64/i64_extend_16_s/const.wat
new file mode 100644
index 000000000000..1789634a3310
--- /dev/null
+++ b/tests/disas/winch/x64/i64_extend_16_s/const.wat
@@ -0,0 +1,27 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.extend16_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       movswq  %ax, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
diff --git a/tests/disas/winch/x64/i64_extend_16_s/locals.wat b/tests/disas/winch/x64/i64_extend_16_s/locals.wat
new file mode 100644
index 000000000000..fbc63570c254
--- /dev/null
+++ b/tests/disas/winch/x64/i64_extend_16_s/locals.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local i64)
+
+        (local.get 0)
+        (i64.extend16_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x44
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movq    8(%rsp), %rax
+;;       movswq  %ax, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   44: ud2
diff --git a/tests/disas/winch/x64/i64_extend_16_s/params.wat b/tests/disas/winch/x64/i64_extend_16_s/params.wat
new file mode 100644
index 000000000000..65fa91aa7770
--- /dev/null
+++ b/tests/disas/winch/x64/i64_extend_16_s/params.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (result i64)
+        (local.get 0)
+        (i64.extend16_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x40
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    8(%rsp), %rax
+;;       movswq  %ax, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   40: ud2
diff --git a/tests/disas/winch/x64/i64_extend_32_s/const.wat b/tests/disas/winch/x64/i64_extend_32_s/const.wat
new file mode 100644
index 000000000000..fe971266b321
--- /dev/null
+++ b/tests/disas/winch/x64/i64_extend_32_s/const.wat
@@ -0,0 +1,27 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.extend32_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3b
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       movslq  %eax, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3b: ud2
diff --git a/tests/disas/winch/x64/i64_extend_32_s/locals.wat b/tests/disas/winch/x64/i64_extend_32_s/locals.wat
new file mode 100644
index 000000000000..4ec636bc98a1
--- /dev/null
+++ b/tests/disas/winch/x64/i64_extend_32_s/locals.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local i64)
+
+        (local.get 0)
+        (i64.extend32_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x43
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movq    8(%rsp), %rax
+;;       movslq  %eax, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   43: ud2
diff --git a/tests/disas/winch/x64/i64_extend_32_s/params.wat b/tests/disas/winch/x64/i64_extend_32_s/params.wat
new file mode 100644
index 000000000000..25d62d7ba12b
--- /dev/null
+++ b/tests/disas/winch/x64/i64_extend_32_s/params.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (result i64)
+        (local.get 0)
+        (i64.extend32_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    8(%rsp), %rax
+;;       movslq  %eax, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3f: ud2
diff --git a/tests/disas/winch/x64/i64_extend_8_s/const.wat b/tests/disas/winch/x64/i64_extend_8_s/const.wat
new file mode 100644
index 000000000000..d8f0ec574bc5
--- /dev/null
+++ b/tests/disas/winch/x64/i64_extend_8_s/const.wat
@@ -0,0 +1,27 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.extend8_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       movsbq  %al, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
diff --git a/tests/disas/winch/x64/i64_extend_8_s/locals.wat b/tests/disas/winch/x64/i64_extend_8_s/locals.wat
new file mode 100644
index 000000000000..fa6f15bf4135
--- /dev/null
+++ b/tests/disas/winch/x64/i64_extend_8_s/locals.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local i64)
+
+        (local.get 0)
+        (i64.extend8_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x44
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movq    8(%rsp), %rax
+;;       movsbq  %al, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   44: ud2
diff --git a/tests/disas/winch/x64/i64_extend_8_s/params.wat b/tests/disas/winch/x64/i64_extend_8_s/params.wat
new file mode 100644
index 000000000000..97462e40971c
--- /dev/null
+++ b/tests/disas/winch/x64/i64_extend_8_s/params.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (result i64)
+        (local.get 0)
+        (i64.extend8_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x40
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    8(%rsp), %rax
+;;       movsbq  %al, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   40: ud2
diff --git a/tests/disas/winch/x64/i64_extend_i32_s/const.wat b/tests/disas/winch/x64/i64_extend_i32_s/const.wat
new file mode 100644
index 000000000000..4f63bf7f156e
--- /dev/null
+++ b/tests/disas/winch/x64/i64_extend_i32_s/const.wat
@@ -0,0 +1,27 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i32.const 1)
+        (i64.extend_i32_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x39
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       movslq  %eax, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   39: ud2
diff --git a/tests/disas/winch/x64/i64_extend_i32_s/locals.wat b/tests/disas/winch/x64/i64_extend_i32_s/locals.wat
new file mode 100644
index 000000000000..709e1774dafe
--- /dev/null
+++ b/tests/disas/winch/x64/i64_extend_i32_s/locals.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local i32)
+
+        (local.get 0)
+        (i64.extend_i32_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x42
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       movslq  %eax, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   42: ud2
diff --git a/tests/disas/winch/x64/i64_extend_i32_s/params.wat b/tests/disas/winch/x64/i64_extend_i32_s/params.wat
new file mode 100644
index 000000000000..a4967c22622a
--- /dev/null
+++ b/tests/disas/winch/x64/i64_extend_i32_s/params.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (result i64)
+        (local.get 0)
+        (i64.extend_i32_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       movslq  %eax, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3d: ud2
diff --git a/tests/disas/winch/x64/i64_extend_i32_s/spilled.wat b/tests/disas/winch/x64/i64_extend_i32_s/spilled.wat
new file mode 100644
index 000000000000..89e060332f78
--- /dev/null
+++ b/tests/disas/winch/x64/i64_extend_i32_s/spilled.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        i32.const 1
+        i64.extend_i32_s
+        block
+        end
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x18, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3b
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       movslq  %eax, %rax
+;;       pushq   %rax
+;;       popq    %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3b: ud2
diff --git a/tests/disas/winch/x64/i64_extend_i32_u/const.wat b/tests/disas/winch/x64/i64_extend_i32_u/const.wat
new file mode 100644
index 000000000000..7dee85992342
--- /dev/null
+++ b/tests/disas/winch/x64/i64_extend_i32_u/const.wat
@@ -0,0 +1,27 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i32.const 1)
+        (i64.extend_i32_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x38
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       movl    %eax, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   38: ud2
diff --git a/tests/disas/winch/x64/i64_extend_i32_u/locals.wat b/tests/disas/winch/x64/i64_extend_i32_u/locals.wat
new file mode 100644
index 000000000000..f84a64a1fa70
--- /dev/null
+++ b/tests/disas/winch/x64/i64_extend_i32_u/locals.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local i32)
+
+        (local.get 0)
+        (i64.extend_i32_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x41
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       movl    %eax, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   41: ud2
diff --git a/tests/disas/winch/x64/i64_extend_i32_u/params.wat b/tests/disas/winch/x64/i64_extend_i32_u/params.wat
new file mode 100644
index 000000000000..dd212978a97c
--- /dev/null
+++ b/tests/disas/winch/x64/i64_extend_i32_u/params.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i32) (result i64)
+        (local.get 0)
+        (i64.extend_i32_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       movl    %eax, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
diff --git a/tests/disas/winch/x64/i64_extend_i32_u/spilled.wat b/tests/disas/winch/x64/i64_extend_i32_u/spilled.wat
new file mode 100644
index 000000000000..445b554d0810
--- /dev/null
+++ b/tests/disas/winch/x64/i64_extend_i32_u/spilled.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        i32.const 1
+        i64.extend_i32_u
+        block
+        end
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x18, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       movl    %eax, %eax
+;;       pushq   %rax
+;;       popq    %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3a: ud2
diff --git a/tests/disas/winch/x64/i64_ge_s/32_const.wat b/tests/disas/winch/x64/i64_ge_s/32_const.wat
new file mode 100644
index 000000000000..cd416df62cc4
--- /dev/null
+++ b/tests/disas/winch/x64/i64_ge_s/32_const.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 2)
+        (i64.const 3)
+        (i64.ge_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x45
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $2, %rax
+;;       cmpq    $3, %rax
+;;       movl    $0, %eax
+;;       setge   %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   45: ud2
diff --git a/tests/disas/winch/x64/i64_ge_s/64_const.wat b/tests/disas/winch/x64/i64_ge_s/64_const.wat
new file mode 100644
index 000000000000..6e857e2ff0d0
--- /dev/null
+++ b/tests/disas/winch/x64/i64_ge_s/64_const.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 9223372036854775806)
+        (i64.const 9223372036854775807)
+        (i64.ge_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x51
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movabsq $0x7ffffffffffffffe, %rax
+;;       movabsq $0x7fffffffffffffff, %r11
+;;       cmpq    %r11, %rax
+;;       movl    $0, %eax
+;;       setge   %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   51: ud2
diff --git a/tests/disas/winch/x64/i64_ge_s/locals.wat b/tests/disas/winch/x64/i64_ge_s/locals.wat
new file mode 100644
index 000000000000..ea33cd885649
--- /dev/null
+++ b/tests/disas/winch/x64/i64_ge_s/locals.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i64)
+        (local $bar i64)
+
+        (i64.const 2)
+        (local.set $foo)
+        (i64.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.ge_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movq    $2, %rax
+;;       movq    %rax, 8(%rsp)
+;;       movq    $3, %rax
+;;       movq    %rax, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       cmpq    %rax, %rcx
+;;       movl    $0, %ecx
+;;       setge   %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6c: ud2
diff --git a/tests/disas/winch/x64/i64_ge_s/params.wat b/tests/disas/winch/x64/i64_ge_s/params.wat
new file mode 100644
index 000000000000..e0691bd3af14
--- /dev/null
+++ b/tests/disas/winch/x64/i64_ge_s/params.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i64.ge_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x52
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    %rcx, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       cmpq    %rax, %rcx
+;;       movl    $0, %ecx
+;;       setge   %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   52: ud2
diff --git a/tests/disas/winch/x64/i64_ge_u/32_const.wat b/tests/disas/winch/x64/i64_ge_u/32_const.wat
new file mode 100644
index 000000000000..603663b25e29
--- /dev/null
+++ b/tests/disas/winch/x64/i64_ge_u/32_const.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 2)
+        (i64.const 3)
+        (i64.ge_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x45
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $2, %rax
+;;       cmpq    $3, %rax
+;;       movl    $0, %eax
+;;       setae   %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   45: ud2
diff --git a/tests/disas/winch/x64/i64_ge_u/64_const.wat b/tests/disas/winch/x64/i64_ge_u/64_const.wat
new file mode 100644
index 000000000000..6eb2f240ca2a
--- /dev/null
+++ b/tests/disas/winch/x64/i64_ge_u/64_const.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 9223372036854775806)
+        (i64.const 9223372036854775807)
+        (i64.ge_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x51
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movabsq $0x7ffffffffffffffe, %rax
+;;       movabsq $0x7fffffffffffffff, %r11
+;;       cmpq    %r11, %rax
+;;       movl    $0, %eax
+;;       setae   %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   51: ud2
diff --git a/tests/disas/winch/x64/i64_ge_u/locals.wat b/tests/disas/winch/x64/i64_ge_u/locals.wat
new file mode 100644
index 000000000000..f782ccdc24de
--- /dev/null
+++ b/tests/disas/winch/x64/i64_ge_u/locals.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i64)
+        (local $bar i64)
+
+        (i64.const 2)
+        (local.set $foo)
+        (i64.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.ge_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movq    $2, %rax
+;;       movq    %rax, 8(%rsp)
+;;       movq    $3, %rax
+;;       movq    %rax, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       cmpq    %rax, %rcx
+;;       movl    $0, %ecx
+;;       setae   %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6c: ud2
diff --git a/tests/disas/winch/x64/i64_ge_u/params.wat b/tests/disas/winch/x64/i64_ge_u/params.wat
new file mode 100644
index 000000000000..faa78ff2aa62
--- /dev/null
+++ b/tests/disas/winch/x64/i64_ge_u/params.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i64.ge_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x52
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    %rcx, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       cmpq    %rax, %rcx
+;;       movl    $0, %ecx
+;;       setae   %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   52: ud2
diff --git a/tests/disas/winch/x64/i64_gt_s/32_const.wat b/tests/disas/winch/x64/i64_gt_s/32_const.wat
new file mode 100644
index 000000000000..89967bacd225
--- /dev/null
+++ b/tests/disas/winch/x64/i64_gt_s/32_const.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 2)
+        (i64.const 3)
+        (i64.gt_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x45
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $2, %rax
+;;       cmpq    $3, %rax
+;;       movl    $0, %eax
+;;       setg    %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   45: ud2
diff --git a/tests/disas/winch/x64/i64_gt_s/64_const.wat b/tests/disas/winch/x64/i64_gt_s/64_const.wat
new file mode 100644
index 000000000000..89fdff985f7f
--- /dev/null
+++ b/tests/disas/winch/x64/i64_gt_s/64_const.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 9223372036854775806)
+        (i64.const 9223372036854775807)
+        (i64.gt_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x51
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movabsq $0x7ffffffffffffffe, %rax
+;;       movabsq $0x7fffffffffffffff, %r11
+;;       cmpq    %r11, %rax
+;;       movl    $0, %eax
+;;       setg    %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   51: ud2
diff --git a/tests/disas/winch/x64/i64_gt_s/locals.wat b/tests/disas/winch/x64/i64_gt_s/locals.wat
new file mode 100644
index 000000000000..b652a2470c8d
--- /dev/null
+++ b/tests/disas/winch/x64/i64_gt_s/locals.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i64)
+        (local $bar i64)
+
+        (i64.const 2)
+        (local.set $foo)
+        (i64.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.gt_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movq    $2, %rax
+;;       movq    %rax, 8(%rsp)
+;;       movq    $3, %rax
+;;       movq    %rax, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       cmpq    %rax, %rcx
+;;       movl    $0, %ecx
+;;       setg    %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6c: ud2
diff --git a/tests/disas/winch/x64/i64_gt_s/params.wat b/tests/disas/winch/x64/i64_gt_s/params.wat
new file mode 100644
index 000000000000..7d88374bd88c
--- /dev/null
+++ b/tests/disas/winch/x64/i64_gt_s/params.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i64.gt_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x52
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    %rcx, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       cmpq    %rax, %rcx
+;;       movl    $0, %ecx
+;;       setg    %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   52: ud2
diff --git a/tests/disas/winch/x64/i64_gt_u/32_const.wat b/tests/disas/winch/x64/i64_gt_u/32_const.wat
new file mode 100644
index 000000000000..bffe835bb66b
--- /dev/null
+++ b/tests/disas/winch/x64/i64_gt_u/32_const.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 2)
+        (i64.const 3)
+        (i64.gt_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x45
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $2, %rax
+;;       cmpq    $3, %rax
+;;       movl    $0, %eax
+;;       seta    %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   45: ud2
diff --git a/tests/disas/winch/x64/i64_gt_u/64_const.wat b/tests/disas/winch/x64/i64_gt_u/64_const.wat
new file mode 100644
index 000000000000..ae404af3ddff
--- /dev/null
+++ b/tests/disas/winch/x64/i64_gt_u/64_const.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 9223372036854775806)
+        (i64.const 9223372036854775807)
+        (i64.gt_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x51
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movabsq $0x7ffffffffffffffe, %rax
+;;       movabsq $0x7fffffffffffffff, %r11
+;;       cmpq    %r11, %rax
+;;       movl    $0, %eax
+;;       seta    %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   51: ud2
diff --git a/tests/disas/winch/x64/i64_gt_u/locals.wat b/tests/disas/winch/x64/i64_gt_u/locals.wat
new file mode 100644
index 000000000000..60fe51003ec0
--- /dev/null
+++ b/tests/disas/winch/x64/i64_gt_u/locals.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i64)
+        (local $bar i64)
+
+        (i64.const 2)
+        (local.set $foo)
+        (i64.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.gt_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movq    $2, %rax
+;;       movq    %rax, 8(%rsp)
+;;       movq    $3, %rax
+;;       movq    %rax, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       cmpq    %rax, %rcx
+;;       movl    $0, %ecx
+;;       seta    %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6c: ud2
diff --git a/tests/disas/winch/x64/i64_gt_u/params.wat b/tests/disas/winch/x64/i64_gt_u/params.wat
new file mode 100644
index 000000000000..14e41b349aa0
--- /dev/null
+++ b/tests/disas/winch/x64/i64_gt_u/params.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i64.gt_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x52
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    %rcx, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       cmpq    %rax, %rcx
+;;       movl    $0, %ecx
+;;       seta    %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   52: ud2
diff --git a/tests/disas/winch/x64/i64_le_s/32_const.wat b/tests/disas/winch/x64/i64_le_s/32_const.wat
new file mode 100644
index 000000000000..bcac582318e8
--- /dev/null
+++ b/tests/disas/winch/x64/i64_le_s/32_const.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 2)
+        (i64.const 3)
+        (i64.le_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x45
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $2, %rax
+;;       cmpq    $3, %rax
+;;       movl    $0, %eax
+;;       setle   %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   45: ud2
diff --git a/tests/disas/winch/x64/i64_le_s/64_const.wat b/tests/disas/winch/x64/i64_le_s/64_const.wat
new file mode 100644
index 000000000000..d397ecff5ead
--- /dev/null
+++ b/tests/disas/winch/x64/i64_le_s/64_const.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 9223372036854775806)
+        (i64.const 9223372036854775807)
+        (i64.le_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x51
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movabsq $0x7ffffffffffffffe, %rax
+;;       movabsq $0x7fffffffffffffff, %r11
+;;       cmpq    %r11, %rax
+;;       movl    $0, %eax
+;;       setle   %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   51: ud2
diff --git a/tests/disas/winch/x64/i64_le_s/locals.wat b/tests/disas/winch/x64/i64_le_s/locals.wat
new file mode 100644
index 000000000000..dc7cd3401b27
--- /dev/null
+++ b/tests/disas/winch/x64/i64_le_s/locals.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i64)
+        (local $bar i64)
+
+        (i64.const 2)
+        (local.set $foo)
+        (i64.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.le_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movq    $2, %rax
+;;       movq    %rax, 8(%rsp)
+;;       movq    $3, %rax
+;;       movq    %rax, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       cmpq    %rax, %rcx
+;;       movl    $0, %ecx
+;;       setle   %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6c: ud2
diff --git a/tests/disas/winch/x64/i64_le_s/params.wat b/tests/disas/winch/x64/i64_le_s/params.wat
new file mode 100644
index 000000000000..62c1f128698c
--- /dev/null
+++ b/tests/disas/winch/x64/i64_le_s/params.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i64.le_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x52
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    %rcx, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       cmpq    %rax, %rcx
+;;       movl    $0, %ecx
+;;       setle   %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   52: ud2
diff --git a/tests/disas/winch/x64/i64_le_u/32_const.wat b/tests/disas/winch/x64/i64_le_u/32_const.wat
new file mode 100644
index 000000000000..954f730514ed
--- /dev/null
+++ b/tests/disas/winch/x64/i64_le_u/32_const.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 2)
+        (i64.const 3)
+        (i64.le_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x45
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $2, %rax
+;;       cmpq    $3, %rax
+;;       movl    $0, %eax
+;;       setbe   %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   45: ud2
diff --git a/tests/disas/winch/x64/i64_le_u/64_const.wat b/tests/disas/winch/x64/i64_le_u/64_const.wat
new file mode 100644
index 000000000000..639f916a06ca
--- /dev/null
+++ b/tests/disas/winch/x64/i64_le_u/64_const.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 9223372036854775806)
+        (i64.const 9223372036854775807)
+        (i64.le_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x51
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movabsq $0x7ffffffffffffffe, %rax
+;;       movabsq $0x7fffffffffffffff, %r11
+;;       cmpq    %r11, %rax
+;;       movl    $0, %eax
+;;       setbe   %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   51: ud2
diff --git a/tests/disas/winch/x64/i64_le_u/locals.wat b/tests/disas/winch/x64/i64_le_u/locals.wat
new file mode 100644
index 000000000000..4350a1e56c2c
--- /dev/null
+++ b/tests/disas/winch/x64/i64_le_u/locals.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i64)
+        (local $bar i64)
+
+        (i64.const 2)
+        (local.set $foo)
+        (i64.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.le_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movq    $2, %rax
+;;       movq    %rax, 8(%rsp)
+;;       movq    $3, %rax
+;;       movq    %rax, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       cmpq    %rax, %rcx
+;;       movl    $0, %ecx
+;;       setbe   %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6c: ud2
diff --git a/tests/disas/winch/x64/i64_le_u/params.wat b/tests/disas/winch/x64/i64_le_u/params.wat
new file mode 100644
index 000000000000..1a3ea206c620
--- /dev/null
+++ b/tests/disas/winch/x64/i64_le_u/params.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i64.le_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x52
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    %rcx, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       cmpq    %rax, %rcx
+;;       movl    $0, %ecx
+;;       setbe   %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   52: ud2
diff --git a/tests/disas/winch/x64/i64_lt_s/32_const.wat b/tests/disas/winch/x64/i64_lt_s/32_const.wat
new file mode 100644
index 000000000000..5130309e825b
--- /dev/null
+++ b/tests/disas/winch/x64/i64_lt_s/32_const.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 2)
+        (i64.const 3)
+        (i64.lt_s)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x45
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $2, %rax
+;;       cmpq    $3, %rax
+;;       movl    $0, %eax
+;;       setl    %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   45: ud2
diff --git a/tests/disas/winch/x64/i64_lt_s/64_const.wat b/tests/disas/winch/x64/i64_lt_s/64_const.wat
new file mode 100644
index 000000000000..427215c14473
--- /dev/null
+++ b/tests/disas/winch/x64/i64_lt_s/64_const.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 9223372036854775806)
+        (i64.const 9223372036854775807)
+        (i64.lt_s)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x51
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movabsq $0x7ffffffffffffffe, %rax
+;;       movabsq $0x7fffffffffffffff, %r11
+;;       cmpq    %r11, %rax
+;;       movl    $0, %eax
+;;       setl    %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   51: ud2
diff --git a/tests/disas/winch/x64/i64_lt_s/locals.wat b/tests/disas/winch/x64/i64_lt_s/locals.wat
new file mode 100644
index 000000000000..e5c74285f244
--- /dev/null
+++ b/tests/disas/winch/x64/i64_lt_s/locals.wat
@@ -0,0 +1,48 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i64)
+        (local $bar i64)
+
+        (i64.const 2)
+        (local.set $foo)
+        (i64.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.lt_s)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movq    $2, %rax
+;;       movq    %rax, 8(%rsp)
+;;       movq    $3, %rax
+;;       movq    %rax, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       cmpq    %rax, %rcx
+;;       movl    $0, %ecx
+;;       setl    %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6c: ud2
diff --git a/tests/disas/winch/x64/i64_lt_s/params.wat b/tests/disas/winch/x64/i64_lt_s/params.wat
new file mode 100644
index 000000000000..dee5cd289a8e
--- /dev/null
+++ b/tests/disas/winch/x64/i64_lt_s/params.wat
@@ -0,0 +1,35 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i64.lt_s)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x52
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    %rcx, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       cmpq    %rax, %rcx
+;;       movl    $0, %ecx
+;;       setl    %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   52: ud2
diff --git a/tests/disas/winch/x64/i64_lt_u/32_const.wat b/tests/disas/winch/x64/i64_lt_u/32_const.wat
new file mode 100644
index 000000000000..aeb4da191bbf
--- /dev/null
+++ b/tests/disas/winch/x64/i64_lt_u/32_const.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 2)
+        (i64.const 3)
+        (i64.lt_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x45
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $2, %rax
+;;       cmpq    $3, %rax
+;;       movl    $0, %eax
+;;       setb    %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   45: ud2
diff --git a/tests/disas/winch/x64/i64_lt_u/64_const.wat b/tests/disas/winch/x64/i64_lt_u/64_const.wat
new file mode 100644
index 000000000000..f7aafd8360f9
--- /dev/null
+++ b/tests/disas/winch/x64/i64_lt_u/64_const.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 9223372036854775806)
+        (i64.const 9223372036854775807)
+        (i64.lt_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x51
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movabsq $0x7ffffffffffffffe, %rax
+;;       movabsq $0x7fffffffffffffff, %r11
+;;       cmpq    %r11, %rax
+;;       movl    $0, %eax
+;;       setb    %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   51: ud2
diff --git a/tests/disas/winch/x64/i64_lt_u/locals.wat b/tests/disas/winch/x64/i64_lt_u/locals.wat
new file mode 100644
index 000000000000..98d076c95788
--- /dev/null
+++ b/tests/disas/winch/x64/i64_lt_u/locals.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i64)
+        (local $bar i64)
+
+        (i64.const 2)
+        (local.set $foo)
+        (i64.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.lt_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movq    $2, %rax
+;;       movq    %rax, 8(%rsp)
+;;       movq    $3, %rax
+;;       movq    %rax, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       cmpq    %rax, %rcx
+;;       movl    $0, %ecx
+;;       setb    %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6c: ud2
diff --git a/tests/disas/winch/x64/i64_lt_u/params.wat b/tests/disas/winch/x64/i64_lt_u/params.wat
new file mode 100644
index 000000000000..1130db4f69fe
--- /dev/null
+++ b/tests/disas/winch/x64/i64_lt_u/params.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i64.lt_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x52
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    %rcx, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       cmpq    %rax, %rcx
+;;       movl    $0, %ecx
+;;       setb    %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   52: ud2
diff --git a/tests/disas/winch/x64/i64_mul/const.wat b/tests/disas/winch/x64/i64_mul/const.wat
new file mode 100644
index 000000000000..981c0e21c7eb
--- /dev/null
+++ b/tests/disas/winch/x64/i64_mul/const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const 10)
+	(i64.const 20)
+	(i64.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $0xa, %rax
+;;       imulq   $0x14, %rax, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
diff --git a/tests/disas/winch/x64/i64_mul/locals.wat b/tests/disas/winch/x64/i64_mul/locals.wat
new file mode 100644
index 000000000000..799e39f584b3
--- /dev/null
+++ b/tests/disas/winch/x64/i64_mul/locals.wat
@@ -0,0 +1,46 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local $foo i64)  
+        (local $bar i64)
+
+        (i64.const 10)
+        (local.set $foo)
+
+        (i64.const 20)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        i64.mul
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x65
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movq    $0xa, %rax
+;;       movq    %rax, 8(%rsp)
+;;       movq    $0x14, %rax
+;;       movq    %rax, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       imulq   %rax, %rcx
+;;       movq    %rcx, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   65: ud2
diff --git a/tests/disas/winch/x64/i64_mul/max.wat b/tests/disas/winch/x64/i64_mul/max.wat
new file mode 100644
index 000000000000..baa823be345f
--- /dev/null
+++ b/tests/disas/winch/x64/i64_mul/max.wat
@@ -0,0 +1,27 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+    (func (result i64)
+	(i64.const 0x7fffffffffffffff)
+	(i64.const -1)
+	(i64.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movabsq $0x7fffffffffffffff, %rax
+;;       imulq   $-1, %rax, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3f: ud2
diff --git a/tests/disas/winch/x64/i64_mul/max_one.wat b/tests/disas/winch/x64/i64_mul/max_one.wat
new file mode 100644
index 000000000000..64f980eb838e
--- /dev/null
+++ b/tests/disas/winch/x64/i64_mul/max_one.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const 0x8000000000000000)
+	(i64.const -1)
+	(i64.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movabsq $9223372036854775808, %rax
+;;       imulq   $-1, %rax, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3f: ud2
diff --git a/tests/disas/winch/x64/i64_mul/mixed.wat b/tests/disas/winch/x64/i64_mul/mixed.wat
new file mode 100644
index 000000000000..a3480ba55d7a
--- /dev/null
+++ b/tests/disas/winch/x64/i64_mul/mixed.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const -1)
+	(i64.const 1)
+	(i64.mul)
+     )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $18446744073709551615, %rax
+;;       imulq   $1, %rax, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
diff --git a/tests/disas/winch/x64/i64_mul/params.wat b/tests/disas/winch/x64/i64_mul/params.wat
new file mode 100644
index 000000000000..1df640c996e5
--- /dev/null
+++ b/tests/disas/winch/x64/i64_mul/params.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i64)
+	(local.get 0)
+	(local.get 1)
+	(i64.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4b
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    %rcx, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       imulq   %rax, %rcx
+;;       movq    %rcx, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4b: ud2
diff --git a/tests/disas/winch/x64/i64_mul/signed.wat b/tests/disas/winch/x64/i64_mul/signed.wat
new file mode 100644
index 000000000000..824a073534cf
--- /dev/null
+++ b/tests/disas/winch/x64/i64_mul/signed.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const -1)
+	(i64.const -1)
+	(i64.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $18446744073709551615, %rax
+;;       imulq   $-1, %rax, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
diff --git a/tests/disas/winch/x64/i64_mul/unsigned_with_zero.wat b/tests/disas/winch/x64/i64_mul/unsigned_with_zero.wat
new file mode 100644
index 000000000000..42913e49aafd
--- /dev/null
+++ b/tests/disas/winch/x64/i64_mul/unsigned_with_zero.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+     	(i64.const 0)
+    	(i64.mul)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       imulq   $0, %rax, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
diff --git a/tests/disas/winch/x64/i64_ne/32_const.wat b/tests/disas/winch/x64/i64_ne/32_const.wat
new file mode 100644
index 000000000000..80ae4b37a8c8
--- /dev/null
+++ b/tests/disas/winch/x64/i64_ne/32_const.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 2)
+        (i64.const 3)
+        (i64.ne)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x45
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $2, %rax
+;;       cmpq    $3, %rax
+;;       movl    $0, %eax
+;;       setne   %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   45: ud2
diff --git a/tests/disas/winch/x64/i64_ne/64_const.wat b/tests/disas/winch/x64/i64_ne/64_const.wat
new file mode 100644
index 000000000000..23ddf11b031a
--- /dev/null
+++ b/tests/disas/winch/x64/i64_ne/64_const.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (i64.const 9223372036854775806)
+        (i64.const 9223372036854775807)
+        (i64.ne)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x51
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movabsq $0x7ffffffffffffffe, %rax
+;;       movabsq $0x7fffffffffffffff, %r11
+;;       cmpq    %r11, %rax
+;;       movl    $0, %eax
+;;       setne   %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   51: ud2
diff --git a/tests/disas/winch/x64/i64_ne/locals.wat b/tests/disas/winch/x64/i64_ne/locals.wat
new file mode 100644
index 000000000000..b57f5cc040f3
--- /dev/null
+++ b/tests/disas/winch/x64/i64_ne/locals.wat
@@ -0,0 +1,48 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i32)
+        (local $foo i64)
+        (local $bar i64)
+
+        (i64.const 2)
+        (local.set $foo)
+        (i64.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.ne)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movq    $2, %rax
+;;       movq    %rax, 8(%rsp)
+;;       movq    $3, %rax
+;;       movq    %rax, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       cmpq    %rax, %rcx
+;;       movl    $0, %ecx
+;;       setne   %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6c: ud2
diff --git a/tests/disas/winch/x64/i64_ne/params.wat b/tests/disas/winch/x64/i64_ne/params.wat
new file mode 100644
index 000000000000..8f6efa75901d
--- /dev/null
+++ b/tests/disas/winch/x64/i64_ne/params.wat
@@ -0,0 +1,35 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i32)
+        (local.get 0)
+        (local.get 1)
+        (i64.ne)
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x52
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    %rcx, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       cmpq    %rax, %rcx
+;;       movl    $0, %ecx
+;;       setne   %cl
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   52: ud2
diff --git a/tests/disas/winch/x64/i64_or/32_const.wat b/tests/disas/winch/x64/i64_or/32_const.wat
new file mode 100644
index 000000000000..1dcddddcb7b5
--- /dev/null
+++ b/tests/disas/winch/x64/i64_or/32_const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 2)
+        (i64.const 3)
+        (i64.or)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $2, %rax
+;;       orq     $3, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
diff --git a/tests/disas/winch/x64/i64_or/64_const.wat b/tests/disas/winch/x64/i64_or/64_const.wat
new file mode 100644
index 000000000000..ff256848cdb2
--- /dev/null
+++ b/tests/disas/winch/x64/i64_or/64_const.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 9223372036854775806)
+        (i64.const 9223372036854775807)
+        (i64.or)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x48
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movabsq $0x7ffffffffffffffe, %rax
+;;       movabsq $0x7fffffffffffffff, %r11
+;;       orq     %r11, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   48: ud2
diff --git a/tests/disas/winch/x64/i64_or/locals.wat b/tests/disas/winch/x64/i64_or/locals.wat
new file mode 100644
index 000000000000..55ef4f07a4f9
--- /dev/null
+++ b/tests/disas/winch/x64/i64_or/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local $foo i64)
+        (local $bar i64)
+
+        (i64.const 2)
+        (local.set $foo)
+        (i64.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.or)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x64
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movq    $2, %rax
+;;       movq    %rax, 8(%rsp)
+;;       movq    $3, %rax
+;;       movq    %rax, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       orq     %rax, %rcx
+;;       movq    %rcx, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   64: ud2
diff --git a/tests/disas/winch/x64/i64_or/params.wat b/tests/disas/winch/x64/i64_or/params.wat
new file mode 100644
index 000000000000..8651f5ac7963
--- /dev/null
+++ b/tests/disas/winch/x64/i64_or/params.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i64)
+        (local.get 0)
+        (local.get 1)
+        (i64.or)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    %rcx, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       orq     %rax, %rcx
+;;       movq    %rcx, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4a: ud2
diff --git a/tests/disas/winch/x64/i64_popcnt/const.wat b/tests/disas/winch/x64/i64_popcnt/const.wat
new file mode 100644
index 000000000000..f3a97174213f
--- /dev/null
+++ b/tests/disas/winch/x64/i64_popcnt/const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_popcnt", "-Ccranelift-has_sse42"]
+
+(module
+    (func (result i64)
+      i64.const 3
+      i64.popcnt
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $3, %rax
+;;       popcntq %rax, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3d: ud2
diff --git a/tests/disas/winch/x64/i64_popcnt/fallback.wat b/tests/disas/winch/x64/i64_popcnt/fallback.wat
new file mode 100644
index 000000000000..30f0aa85fa4c
--- /dev/null
+++ b/tests/disas/winch/x64/i64_popcnt/fallback.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+      i64.const 15
+      i64.popcnt
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x92
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $0xf, %rax
+;;       movq    %rax, %rcx
+;;       shrq    $1, %rax
+;;       movabsq $0x5555555555555555, %r11
+;;       andq    %r11, %rax
+;;       subq    %rax, %rcx
+;;       movq    %rcx, %rax
+;;       movabsq $0x3333333333333333, %r11
+;;       andq    %r11, %rax
+;;       shrq    $2, %rcx
+;;       andq    %r11, %rcx
+;;       addq    %rax, %rcx
+;;       movq    %rcx, %rax
+;;       shrq    $4, %rax
+;;       addq    %rcx, %rax
+;;       movabsq $0xf0f0f0f0f0f0f0f, %r11
+;;       andq    %r11, %rax
+;;       movabsq $0x101010101010101, %r11
+;;       imulq   %r11, %rax
+;;       shrq    $0x38, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   92: ud2
diff --git a/tests/disas/winch/x64/i64_popcnt/no_sse42.wat b/tests/disas/winch/x64/i64_popcnt/no_sse42.wat
new file mode 100644
index 000000000000..4cb4d7b2de85
--- /dev/null
+++ b/tests/disas/winch/x64/i64_popcnt/no_sse42.wat
@@ -0,0 +1,46 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_popcnt"]
+
+(module
+    (func (result i64)
+      i64.const 3
+      i64.popcnt
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x92
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $3, %rax
+;;       movq    %rax, %rcx
+;;       shrq    $1, %rax
+;;       movabsq $0x5555555555555555, %r11
+;;       andq    %r11, %rax
+;;       subq    %rax, %rcx
+;;       movq    %rcx, %rax
+;;       movabsq $0x3333333333333333, %r11
+;;       andq    %r11, %rax
+;;       shrq    $2, %rcx
+;;       andq    %r11, %rcx
+;;       addq    %rax, %rcx
+;;       movq    %rcx, %rax
+;;       shrq    $4, %rax
+;;       addq    %rcx, %rax
+;;       movabsq $0xf0f0f0f0f0f0f0f, %r11
+;;       andq    %r11, %rax
+;;       movabsq $0x101010101010101, %r11
+;;       imulq   %r11, %rax
+;;       shrq    $0x38, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   92: ud2
diff --git a/tests/disas/winch/x64/i64_popcnt/reg.wat b/tests/disas/winch/x64/i64_popcnt/reg.wat
new file mode 100644
index 000000000000..56acfe95f498
--- /dev/null
+++ b/tests/disas/winch/x64/i64_popcnt/reg.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = ["-Ccranelift-has_popcnt", "-Ccranelift-has_sse42"]
+
+(module
+    (func (param i64) (result i64)
+      local.get 0
+      i64.popcnt
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x41
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    8(%rsp), %rax
+;;       popcntq %rax, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   41: ud2
diff --git a/tests/disas/winch/x64/i64_reinterpret_f64/const.wat b/tests/disas/winch/x64/i64_reinterpret_f64/const.wat
new file mode 100644
index 000000000000..519ef6679e28
--- /dev/null
+++ b/tests/disas/winch/x64/i64_reinterpret_f64/const.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (f64.const 1.0)
+        (i64.reinterpret_f64)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movsd   0xd(%rip), %xmm0
+;;       movq    %xmm0, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3e: ud2
+;;   40: addb    %al, (%rax)
+;;   42: addb    %al, (%rax)
+;;   44: addb    %al, (%rax)
diff --git a/tests/disas/winch/x64/i64_reinterpret_f64/locals.wat b/tests/disas/winch/x64/i64_reinterpret_f64/locals.wat
new file mode 100644
index 000000000000..cc0afe76bdba
--- /dev/null
+++ b/tests/disas/winch/x64/i64_reinterpret_f64/locals.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local f64)  
+
+        (local.get 0)
+        (i64.reinterpret_f64)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x46
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movsd   8(%rsp), %xmm0
+;;       movq    %xmm0, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   46: ud2
diff --git a/tests/disas/winch/x64/i64_reinterpret_f64/params.wat b/tests/disas/winch/x64/i64_reinterpret_f64/params.wat
new file mode 100644
index 000000000000..0193adb2eae6
--- /dev/null
+++ b/tests/disas/winch/x64/i64_reinterpret_f64/params.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (result i64)
+        (local.get 0)
+        (i64.reinterpret_f64)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x43
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   8(%rsp), %xmm0
+;;       movq    %xmm0, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   43: ud2
diff --git a/tests/disas/winch/x64/i64_reinterpret_f64/ret_float.wat b/tests/disas/winch/x64/i64_reinterpret_f64/ret_float.wat
new file mode 100644
index 000000000000..2044728fd09a
--- /dev/null
+++ b/tests/disas/winch/x64/i64_reinterpret_f64/ret_float.wat
@@ -0,0 +1,33 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result f64)
+        f64.const 1.0
+        i64.reinterpret_f64
+        drop
+        f64.const 1.0
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x46
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movsd   0x15(%rip), %xmm0
+;;       movq    %xmm0, %rax
+;;       movsd   8(%rip), %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   46: ud2
+;;   48: addb    %al, (%rax)
+;;   4a: addb    %al, (%rax)
+;;   4c: addb    %al, (%rax)
diff --git a/tests/disas/winch/x64/i64_rems/const.wat b/tests/disas/winch/x64/i64_rems/const.wat
new file mode 100644
index 000000000000..a418dbef6b10
--- /dev/null
+++ b/tests/disas/winch/x64/i64_rems/const.wat
@@ -0,0 +1,35 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const 7)
+	(i64.const 5)
+	(i64.rem_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x5b
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $5, %rcx
+;;       movq    $7, %rax
+;;       cqto
+;;       cmpq    $-1, %rcx
+;;       jne     0x4f
+;;   45: movl    $0, %edx
+;;       jmp     0x52
+;;   4f: idivq   %rcx
+;;       movq    %rdx, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   5b: ud2
diff --git a/tests/disas/winch/x64/i64_rems/one_zero.wat b/tests/disas/winch/x64/i64_rems/one_zero.wat
new file mode 100644
index 000000000000..5f84f29dc104
--- /dev/null
+++ b/tests/disas/winch/x64/i64_rems/one_zero.wat
@@ -0,0 +1,35 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const 1)
+	(i64.const 0)
+	(i64.rem_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x5b
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $0, %rcx
+;;       movq    $1, %rax
+;;       cqto
+;;       cmpq    $-1, %rcx
+;;       jne     0x4f
+;;   45: movl    $0, %edx
+;;       jmp     0x52
+;;   4f: idivq   %rcx
+;;       movq    %rdx, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   5b: ud2
diff --git a/tests/disas/winch/x64/i64_rems/overflow.wat b/tests/disas/winch/x64/i64_rems/overflow.wat
new file mode 100644
index 000000000000..60ded3317223
--- /dev/null
+++ b/tests/disas/winch/x64/i64_rems/overflow.wat
@@ -0,0 +1,35 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const 0x8000000000000000)
+	(i64.const -1)
+	(i64.rem_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x5e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $18446744073709551615, %rcx
+;;       movabsq $9223372036854775808, %rax
+;;       cqto
+;;       cmpq    $-1, %rcx
+;;       jne     0x52
+;;   48: movl    $0, %edx
+;;       jmp     0x55
+;;   52: idivq   %rcx
+;;       movq    %rdx, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   5e: ud2
diff --git a/tests/disas/winch/x64/i64_rems/params.wat b/tests/disas/winch/x64/i64_rems/params.wat
new file mode 100644
index 000000000000..ca2eab2b19d9
--- /dev/null
+++ b/tests/disas/winch/x64/i64_rems/params.wat
@@ -0,0 +1,37 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i64)
+	(local.get 0)
+	(local.get 1)
+	(i64.rem_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x60
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    %rcx, (%rsp)
+;;       movq    (%rsp), %rcx
+;;       movq    8(%rsp), %rax
+;;       cqto
+;;       cmpq    $-1, %rcx
+;;       jne     0x54
+;;   4a: movl    $0, %edx
+;;       jmp     0x57
+;;   54: idivq   %rcx
+;;       movq    %rdx, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   60: ud2
diff --git a/tests/disas/winch/x64/i64_rems/zero_zero.wat b/tests/disas/winch/x64/i64_rems/zero_zero.wat
new file mode 100644
index 000000000000..b7307cda7769
--- /dev/null
+++ b/tests/disas/winch/x64/i64_rems/zero_zero.wat
@@ -0,0 +1,35 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const 0)
+	(i64.const 0)
+	(i64.rem_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x5b
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $0, %rcx
+;;       movq    $0, %rax
+;;       cqto
+;;       cmpq    $-1, %rcx
+;;       jne     0x4f
+;;   45: movl    $0, %edx
+;;       jmp     0x52
+;;   4f: idivq   %rcx
+;;       movq    %rdx, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   5b: ud2
diff --git a/tests/disas/winch/x64/i64_remu/const.wat b/tests/disas/winch/x64/i64_remu/const.wat
new file mode 100644
index 000000000000..a21a894463a2
--- /dev/null
+++ b/tests/disas/winch/x64/i64_remu/const.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const 7)
+	(i64.const 5)
+	(i64.rem_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x48
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $5, %rcx
+;;       movq    $7, %rax
+;;       xorq    %rdx, %rdx
+;;       divq    %rcx
+;;       movq    %rdx, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   48: ud2
diff --git a/tests/disas/winch/x64/i64_remu/one_zero.wat b/tests/disas/winch/x64/i64_remu/one_zero.wat
new file mode 100644
index 000000000000..a5be75ab8df8
--- /dev/null
+++ b/tests/disas/winch/x64/i64_remu/one_zero.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const 1)
+	(i64.const 0)
+	(i64.rem_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x48
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $0, %rcx
+;;       movq    $1, %rax
+;;       xorq    %rdx, %rdx
+;;       divq    %rcx
+;;       movq    %rdx, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   48: ud2
diff --git a/tests/disas/winch/x64/i64_remu/params.wat b/tests/disas/winch/x64/i64_remu/params.wat
new file mode 100644
index 000000000000..dee21d98551c
--- /dev/null
+++ b/tests/disas/winch/x64/i64_remu/params.wat
@@ -0,0 +1,33 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i64)
+	(local.get 0)
+	(local.get 1)
+	(i64.rem_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    %rcx, (%rsp)
+;;       movq    (%rsp), %rcx
+;;       movq    8(%rsp), %rax
+;;       xorq    %rdx, %rdx
+;;       divq    %rcx
+;;       movq    %rdx, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4d: ud2
diff --git a/tests/disas/winch/x64/i64_remu/signed.wat b/tests/disas/winch/x64/i64_remu/signed.wat
new file mode 100644
index 000000000000..8ba1928453dd
--- /dev/null
+++ b/tests/disas/winch/x64/i64_remu/signed.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const -1)
+	(i64.const -1)
+	(i64.rem_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x48
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $18446744073709551615, %rcx
+;;       movq    $18446744073709551615, %rax
+;;       xorq    %rdx, %rdx
+;;       divq    %rcx
+;;       movq    %rdx, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   48: ud2
diff --git a/tests/disas/winch/x64/i64_remu/zero_zero.wat b/tests/disas/winch/x64/i64_remu/zero_zero.wat
new file mode 100644
index 000000000000..92aa6601d12d
--- /dev/null
+++ b/tests/disas/winch/x64/i64_remu/zero_zero.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const 0)
+	(i64.const 0)
+	(i64.rem_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x48
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $0, %rcx
+;;       movq    $0, %rax
+;;       xorq    %rdx, %rdx
+;;       divq    %rcx
+;;       movq    %rdx, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   48: ud2
diff --git a/tests/disas/winch/x64/i64_rotl/16_const.wat b/tests/disas/winch/x64/i64_rotl/16_const.wat
new file mode 100644
index 000000000000..436da18f8541
--- /dev/null
+++ b/tests/disas/winch/x64/i64_rotl/16_const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.const 512)
+        (i64.rotl)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       rolq    $0, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
diff --git a/tests/disas/winch/x64/i64_rotl/8_const.wat b/tests/disas/winch/x64/i64_rotl/8_const.wat
new file mode 100644
index 000000000000..8312aaf3cb8e
--- /dev/null
+++ b/tests/disas/winch/x64/i64_rotl/8_const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.const 2)
+        (i64.rotl)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       rolq    $2, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
diff --git a/tests/disas/winch/x64/i64_rotl/locals.wat b/tests/disas/winch/x64/i64_rotl/locals.wat
new file mode 100644
index 000000000000..176df7b61fba
--- /dev/null
+++ b/tests/disas/winch/x64/i64_rotl/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local $foo i64)  
+        (local $bar i64)
+
+        (i64.const 1)
+        (local.set $foo)
+
+        (i64.const 2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.rotl)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x61
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movq    $1, %rax
+;;       movq    %rax, 8(%rsp)
+;;       movq    $2, %rax
+;;       movq    %rax, (%rsp)
+;;       movq    (%rsp), %rcx
+;;       movq    8(%rsp), %rax
+;;       rolq    %cl, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   61: ud2
diff --git a/tests/disas/winch/x64/i64_rotl/params.wat b/tests/disas/winch/x64/i64_rotl/params.wat
new file mode 100644
index 000000000000..198da72cc60f
--- /dev/null
+++ b/tests/disas/winch/x64/i64_rotl/params.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i64)
+        (local.get 0)
+        (local.get 1)
+        (i64.rotl)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x47
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    %rcx, (%rsp)
+;;       movq    (%rsp), %rcx
+;;       movq    8(%rsp), %rax
+;;       rolq    %cl, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   47: ud2
diff --git a/tests/disas/winch/x64/i64_rotr/16_const.wat b/tests/disas/winch/x64/i64_rotr/16_const.wat
new file mode 100644
index 000000000000..0b99748f167e
--- /dev/null
+++ b/tests/disas/winch/x64/i64_rotr/16_const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.const 512)
+        (i64.rotr)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       rorq    $0, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
diff --git a/tests/disas/winch/x64/i64_rotr/8_const.wat b/tests/disas/winch/x64/i64_rotr/8_const.wat
new file mode 100644
index 000000000000..81e333865d49
--- /dev/null
+++ b/tests/disas/winch/x64/i64_rotr/8_const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.const 2)
+        (i64.rotr)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       rorq    $2, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
diff --git a/tests/disas/winch/x64/i64_rotr/locals.wat b/tests/disas/winch/x64/i64_rotr/locals.wat
new file mode 100644
index 000000000000..7458dfcf4cae
--- /dev/null
+++ b/tests/disas/winch/x64/i64_rotr/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local $foo i64)  
+        (local $bar i64)
+
+        (i64.const 1)
+        (local.set $foo)
+
+        (i64.const 2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.rotr)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x61
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movq    $1, %rax
+;;       movq    %rax, 8(%rsp)
+;;       movq    $2, %rax
+;;       movq    %rax, (%rsp)
+;;       movq    (%rsp), %rcx
+;;       movq    8(%rsp), %rax
+;;       rorq    %cl, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   61: ud2
diff --git a/tests/disas/winch/x64/i64_rotr/params.wat b/tests/disas/winch/x64/i64_rotr/params.wat
new file mode 100644
index 000000000000..e37ede29d3d6
--- /dev/null
+++ b/tests/disas/winch/x64/i64_rotr/params.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i64)
+        (local.get 0)
+        (local.get 1)
+        (i64.rotr)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x47
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    %rcx, (%rsp)
+;;       movq    (%rsp), %rcx
+;;       movq    8(%rsp), %rax
+;;       rorq    %cl, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   47: ud2
diff --git a/tests/disas/winch/x64/i64_shl/16_const.wat b/tests/disas/winch/x64/i64_shl/16_const.wat
new file mode 100644
index 000000000000..5ea6775bbc5f
--- /dev/null
+++ b/tests/disas/winch/x64/i64_shl/16_const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.const 512)
+        (i64.shl)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       shlq    $0, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
diff --git a/tests/disas/winch/x64/i64_shl/8_const.wat b/tests/disas/winch/x64/i64_shl/8_const.wat
new file mode 100644
index 000000000000..efe65ff3dbb4
--- /dev/null
+++ b/tests/disas/winch/x64/i64_shl/8_const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.const 2)
+        (i64.shl)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       shlq    $2, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
diff --git a/tests/disas/winch/x64/i64_shl/locals.wat b/tests/disas/winch/x64/i64_shl/locals.wat
new file mode 100644
index 000000000000..b7cd8b15477a
--- /dev/null
+++ b/tests/disas/winch/x64/i64_shl/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local $foo i64)  
+        (local $bar i64)
+
+        (i64.const 1)
+        (local.set $foo)
+
+        (i64.const 2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.shl)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x61
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movq    $1, %rax
+;;       movq    %rax, 8(%rsp)
+;;       movq    $2, %rax
+;;       movq    %rax, (%rsp)
+;;       movq    (%rsp), %rcx
+;;       movq    8(%rsp), %rax
+;;       shlq    %cl, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   61: ud2
diff --git a/tests/disas/winch/x64/i64_shl/params.wat b/tests/disas/winch/x64/i64_shl/params.wat
new file mode 100644
index 000000000000..426799998fb0
--- /dev/null
+++ b/tests/disas/winch/x64/i64_shl/params.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i64)
+        (local.get 0)
+        (local.get 1)
+        (i64.shl)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x47
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    %rcx, (%rsp)
+;;       movq    (%rsp), %rcx
+;;       movq    8(%rsp), %rax
+;;       shlq    %cl, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   47: ud2
diff --git a/tests/disas/winch/x64/i64_shr_s/16_const.wat b/tests/disas/winch/x64/i64_shr_s/16_const.wat
new file mode 100644
index 000000000000..d29990af9acc
--- /dev/null
+++ b/tests/disas/winch/x64/i64_shr_s/16_const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.const 512)
+        (i64.shr_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       sarq    $0, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
diff --git a/tests/disas/winch/x64/i64_shr_s/8_const.wat b/tests/disas/winch/x64/i64_shr_s/8_const.wat
new file mode 100644
index 000000000000..ec8eaa03ffcb
--- /dev/null
+++ b/tests/disas/winch/x64/i64_shr_s/8_const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.const 2)
+        (i64.shr_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       sarq    $2, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
diff --git a/tests/disas/winch/x64/i64_shr_s/locals.wat b/tests/disas/winch/x64/i64_shr_s/locals.wat
new file mode 100644
index 000000000000..7fe21fbcafaa
--- /dev/null
+++ b/tests/disas/winch/x64/i64_shr_s/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local $foo i64)  
+        (local $bar i64)
+
+        (i64.const 1)
+        (local.set $foo)
+
+        (i64.const 2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.shr_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x61
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movq    $1, %rax
+;;       movq    %rax, 8(%rsp)
+;;       movq    $2, %rax
+;;       movq    %rax, (%rsp)
+;;       movq    (%rsp), %rcx
+;;       movq    8(%rsp), %rax
+;;       sarq    %cl, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   61: ud2
diff --git a/tests/disas/winch/x64/i64_shr_s/params.wat b/tests/disas/winch/x64/i64_shr_s/params.wat
new file mode 100644
index 000000000000..ea9d52c666c7
--- /dev/null
+++ b/tests/disas/winch/x64/i64_shr_s/params.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i64)
+        (local.get 0)
+        (local.get 1)
+        (i64.shr_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x47
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    %rcx, (%rsp)
+;;       movq    (%rsp), %rcx
+;;       movq    8(%rsp), %rax
+;;       sarq    %cl, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   47: ud2
diff --git a/tests/disas/winch/x64/i64_shr_u/16_const.wat b/tests/disas/winch/x64/i64_shr_u/16_const.wat
new file mode 100644
index 000000000000..62115deb56bd
--- /dev/null
+++ b/tests/disas/winch/x64/i64_shr_u/16_const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.const 512)
+        (i64.shr_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       shrq    $0, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
diff --git a/tests/disas/winch/x64/i64_shr_u/8_const.wat b/tests/disas/winch/x64/i64_shr_u/8_const.wat
new file mode 100644
index 000000000000..f9bd3c86355b
--- /dev/null
+++ b/tests/disas/winch/x64/i64_shr_u/8_const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+        (i64.const 2)
+        (i64.shr_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       shrq    $2, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
diff --git a/tests/disas/winch/x64/i64_shr_u/locals.wat b/tests/disas/winch/x64/i64_shr_u/locals.wat
new file mode 100644
index 000000000000..45f6b69d8a67
--- /dev/null
+++ b/tests/disas/winch/x64/i64_shr_u/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local $foo i64)  
+        (local $bar i64)
+
+        (i64.const 1)
+        (local.set $foo)
+
+        (i64.const 2)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.shr_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x61
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movq    $1, %rax
+;;       movq    %rax, 8(%rsp)
+;;       movq    $2, %rax
+;;       movq    %rax, (%rsp)
+;;       movq    (%rsp), %rcx
+;;       movq    8(%rsp), %rax
+;;       shrq    %cl, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   61: ud2
diff --git a/tests/disas/winch/x64/i64_shr_u/params.wat b/tests/disas/winch/x64/i64_shr_u/params.wat
new file mode 100644
index 000000000000..0da4cd55e80c
--- /dev/null
+++ b/tests/disas/winch/x64/i64_shr_u/params.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i64)
+        (local.get 0)
+        (local.get 1)
+        (i64.shr_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x47
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    %rcx, (%rsp)
+;;       movq    (%rsp), %rcx
+;;       movq    8(%rsp), %rax
+;;       shrq    %cl, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   47: ud2
diff --git a/tests/disas/winch/x64/i64_sub/const.wat b/tests/disas/winch/x64/i64_sub/const.wat
new file mode 100644
index 000000000000..7419fd775908
--- /dev/null
+++ b/tests/disas/winch/x64/i64_sub/const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const 10)
+	(i64.const 20)
+	(i64.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $0xa, %rax
+;;       subq    $0x14, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
diff --git a/tests/disas/winch/x64/i64_sub/locals.wat b/tests/disas/winch/x64/i64_sub/locals.wat
new file mode 100644
index 000000000000..2407ebef8d36
--- /dev/null
+++ b/tests/disas/winch/x64/i64_sub/locals.wat
@@ -0,0 +1,46 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local $foo i64)  
+        (local $bar i64)
+
+        (i64.const 10)
+        (local.set $foo)
+
+        (i64.const 20)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        i64.sub
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x64
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movq    $0xa, %rax
+;;       movq    %rax, 8(%rsp)
+;;       movq    $0x14, %rax
+;;       movq    %rax, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       subq    %rax, %rcx
+;;       movq    %rcx, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   64: ud2
diff --git a/tests/disas/winch/x64/i64_sub/max.wat b/tests/disas/winch/x64/i64_sub/max.wat
new file mode 100644
index 000000000000..ce1231892aff
--- /dev/null
+++ b/tests/disas/winch/x64/i64_sub/max.wat
@@ -0,0 +1,27 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+    (func (result i64)
+	(i64.const 0x7fffffffffffffff)
+	(i64.const -1)
+	(i64.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movabsq $0x7fffffffffffffff, %rax
+;;       subq    $-1, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3f: ud2
diff --git a/tests/disas/winch/x64/i64_sub/max_one.wat b/tests/disas/winch/x64/i64_sub/max_one.wat
new file mode 100644
index 000000000000..abf231c3cada
--- /dev/null
+++ b/tests/disas/winch/x64/i64_sub/max_one.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+	(i64.const 0x8000000000000000)
+	(i64.const 1)
+	(i64.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movabsq $9223372036854775808, %rax
+;;       subq    $1, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3f: ud2
diff --git a/tests/disas/winch/x64/i64_sub/mixed.wat b/tests/disas/winch/x64/i64_sub/mixed.wat
new file mode 100644
index 000000000000..65042efdcd37
--- /dev/null
+++ b/tests/disas/winch/x64/i64_sub/mixed.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const -1)
+	(i64.const 1)
+	(i64.sub)
+     )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $18446744073709551615, %rax
+;;       subq    $1, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
diff --git a/tests/disas/winch/x64/i64_sub/params.wat b/tests/disas/winch/x64/i64_sub/params.wat
new file mode 100644
index 000000000000..e19164e3cef5
--- /dev/null
+++ b/tests/disas/winch/x64/i64_sub/params.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i64)
+	(local.get 0)
+	(local.get 1)
+	(i64.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    %rcx, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       subq    %rax, %rcx
+;;       movq    %rcx, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4a: ud2
diff --git a/tests/disas/winch/x64/i64_sub/signed.wat b/tests/disas/winch/x64/i64_sub/signed.wat
new file mode 100644
index 000000000000..505dbebab7bf
--- /dev/null
+++ b/tests/disas/winch/x64/i64_sub/signed.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const -1)
+	(i64.const -1)
+	(i64.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $18446744073709551615, %rax
+;;       subq    $-1, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
diff --git a/tests/disas/winch/x64/i64_sub/unsigned_with_zero.wat b/tests/disas/winch/x64/i64_sub/unsigned_with_zero.wat
new file mode 100644
index 000000000000..6c95c06fb65c
--- /dev/null
+++ b/tests/disas/winch/x64/i64_sub/unsigned_with_zero.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 1)
+     	(i64.const 0)
+    	(i64.sub)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $1, %rax
+;;       subq    $0, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
diff --git a/tests/disas/winch/x64/i64_trunc_f32_s/const.wat b/tests/disas/winch/x64/i64_trunc_f32_s/const.wat
new file mode 100644
index 000000000000..35ea8307cddf
--- /dev/null
+++ b/tests/disas/winch/x64/i64_trunc_f32_s/const.wat
@@ -0,0 +1,43 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (f32.const 1.0)
+        (i64.trunc_f32_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x75
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movss   0x4d(%rip), %xmm0
+;;       cvttss2si %xmm0, %rax
+;;       cmpq    $1, %rax
+;;       jno     0x6f
+;;   42: ucomiss %xmm0, %xmm0
+;;       jp      0x77
+;;   4b: movl    $0xdf000000, %r11d
+;;       movd    %r11d, %xmm15
+;;       ucomiss %xmm15, %xmm0
+;;       jb      0x79
+;;   60: xorpd   %xmm15, %xmm15
+;;       ucomiss %xmm0, %xmm15
+;;       jb      0x7b
+;;   6f: addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   75: ud2
+;;   77: ud2
+;;   79: ud2
+;;   7b: ud2
+;;   7d: addb    %al, (%rax)
+;;   7f: addb    %al, (%rax)
diff --git a/tests/disas/winch/x64/i64_trunc_f32_s/locals.wat b/tests/disas/winch/x64/i64_trunc_f32_s/locals.wat
new file mode 100644
index 000000000000..b4632374b975
--- /dev/null
+++ b/tests/disas/winch/x64/i64_trunc_f32_s/locals.wat
@@ -0,0 +1,44 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local f32)  
+
+        (local.get 0)
+        (i64.trunc_f32_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x7d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movss   0xc(%rsp), %xmm0
+;;       cvttss2si %xmm0, %rax
+;;       cmpq    $1, %rax
+;;       jno     0x77
+;;   4a: ucomiss %xmm0, %xmm0
+;;       jp      0x7f
+;;   53: movl    $0xdf000000, %r11d
+;;       movd    %r11d, %xmm15
+;;       ucomiss %xmm15, %xmm0
+;;       jb      0x81
+;;   68: xorpd   %xmm15, %xmm15
+;;       ucomiss %xmm0, %xmm15
+;;       jb      0x83
+;;   77: addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   7d: ud2
+;;   7f: ud2
+;;   81: ud2
+;;   83: ud2
diff --git a/tests/disas/winch/x64/i64_trunc_f32_s/params.wat b/tests/disas/winch/x64/i64_trunc_f32_s/params.wat
new file mode 100644
index 000000000000..2e4e82e57535
--- /dev/null
+++ b/tests/disas/winch/x64/i64_trunc_f32_s/params.wat
@@ -0,0 +1,42 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (result i64)
+        (local.get 0)
+        (i64.trunc_f32_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x7a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0xc(%rsp), %xmm0
+;;       cvttss2si %xmm0, %rax
+;;       cmpq    $1, %rax
+;;       jno     0x74
+;;   47: ucomiss %xmm0, %xmm0
+;;       jp      0x7c
+;;   50: movl    $0xdf000000, %r11d
+;;       movd    %r11d, %xmm15
+;;       ucomiss %xmm15, %xmm0
+;;       jb      0x7e
+;;   65: xorpd   %xmm15, %xmm15
+;;       ucomiss %xmm0, %xmm15
+;;       jb      0x80
+;;   74: addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   7a: ud2
+;;   7c: ud2
+;;   7e: ud2
+;;   80: ud2
diff --git a/tests/disas/winch/x64/i64_trunc_f32_u/const.wat b/tests/disas/winch/x64/i64_trunc_f32_u/const.wat
new file mode 100644
index 000000000000..a87160cd03d8
--- /dev/null
+++ b/tests/disas/winch/x64/i64_trunc_f32_u/const.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (f32.const 1.0)
+        (i64.trunc_f32_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x89
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movss   0x5d(%rip), %xmm1
+;;       movl    $0x5f000000, %r11d
+;;       movd    %r11d, %xmm15
+;;       ucomiss %xmm15, %xmm1
+;;       jae     0x5f
+;;       jp      0x8b
+;;   4e: cvttss2si %xmm1, %rax
+;;       cmpq    $0, %rax
+;;       jge     0x83
+;;   5d: ud2
+;;       movaps  %xmm1, %xmm0
+;;       subss   %xmm15, %xmm0
+;;       cvttss2si %xmm0, %rax
+;;       cmpq    $0, %rax
+;;       jl      0x8d
+;;   76: movabsq $9223372036854775808, %r11
+;;       addq    %r11, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   89: ud2
+;;   8b: ud2
+;;   8d: ud2
+;;   8f: addb    %al, (%rax)
diff --git a/tests/disas/winch/x64/i64_trunc_f32_u/locals.wat b/tests/disas/winch/x64/i64_trunc_f32_u/locals.wat
new file mode 100644
index 000000000000..9a85f7d94493
--- /dev/null
+++ b/tests/disas/winch/x64/i64_trunc_f32_u/locals.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local f32)  
+
+        (local.get 0)
+        (i64.trunc_f32_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x91
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movss   0xc(%rsp), %xmm1
+;;       movl    $0x5f000000, %r11d
+;;       movd    %r11d, %xmm15
+;;       ucomiss %xmm15, %xmm1
+;;       jae     0x67
+;;       jp      0x93
+;;   56: cvttss2si %xmm1, %rax
+;;       cmpq    $0, %rax
+;;       jge     0x8b
+;;   65: ud2
+;;       movaps  %xmm1, %xmm0
+;;       subss   %xmm15, %xmm0
+;;       cvttss2si %xmm0, %rax
+;;       cmpq    $0, %rax
+;;       jl      0x95
+;;   7e: movabsq $9223372036854775808, %r11
+;;       addq    %r11, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   91: ud2
+;;   93: ud2
+;;   95: ud2
diff --git a/tests/disas/winch/x64/i64_trunc_f32_u/params.wat b/tests/disas/winch/x64/i64_trunc_f32_u/params.wat
new file mode 100644
index 000000000000..9d9cf404a288
--- /dev/null
+++ b/tests/disas/winch/x64/i64_trunc_f32_u/params.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f32) (result i64)
+        (local.get 0)
+        (i64.trunc_f32_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x8e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   0xc(%rsp), %xmm1
+;;       movl    $0x5f000000, %r11d
+;;       movd    %r11d, %xmm15
+;;       ucomiss %xmm15, %xmm1
+;;       jae     0x64
+;;       jp      0x90
+;;   53: cvttss2si %xmm1, %rax
+;;       cmpq    $0, %rax
+;;       jge     0x88
+;;   62: ud2
+;;       movaps  %xmm1, %xmm0
+;;       subss   %xmm15, %xmm0
+;;       cvttss2si %xmm0, %rax
+;;       cmpq    $0, %rax
+;;       jl      0x92
+;;   7b: movabsq $9223372036854775808, %r11
+;;       addq    %r11, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   8e: ud2
+;;   90: ud2
+;;   92: ud2
diff --git a/tests/disas/winch/x64/i64_trunc_f64_s/const.wat b/tests/disas/winch/x64/i64_trunc_f64_s/const.wat
new file mode 100644
index 000000000000..387531df7d57
--- /dev/null
+++ b/tests/disas/winch/x64/i64_trunc_f64_s/const.wat
@@ -0,0 +1,46 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (f64.const 1.0)
+        (i64.trunc_f64_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x7c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movsd   0x55(%rip), %xmm0
+;;       cvttsd2si %xmm0, %rax
+;;       cmpq    $1, %rax
+;;       jno     0x76
+;;   42: ucomisd %xmm0, %xmm0
+;;       jp      0x7e
+;;   4c: movabsq $14114281232179134464, %r11
+;;       movq    %r11, %xmm15
+;;       ucomisd %xmm15, %xmm0
+;;       jb      0x80
+;;   66: xorpd   %xmm15, %xmm15
+;;       ucomisd %xmm0, %xmm15
+;;       jb      0x82
+;;   76: addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   7c: ud2
+;;   7e: ud2
+;;   80: ud2
+;;   82: ud2
+;;   84: addb    %al, (%rax)
+;;   86: addb    %al, (%rax)
+;;   88: addb    %al, (%rax)
+;;   8a: addb    %al, (%rax)
+;;   8c: addb    %al, (%rax)
diff --git a/tests/disas/winch/x64/i64_trunc_f64_s/locals.wat b/tests/disas/winch/x64/i64_trunc_f64_s/locals.wat
new file mode 100644
index 000000000000..4e7f4d31a3a5
--- /dev/null
+++ b/tests/disas/winch/x64/i64_trunc_f64_s/locals.wat
@@ -0,0 +1,44 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local f64)  
+
+        (local.get 0)
+        (i64.trunc_f64_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x84
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movsd   8(%rsp), %xmm0
+;;       cvttsd2si %xmm0, %rax
+;;       cmpq    $1, %rax
+;;       jno     0x7e
+;;   4a: ucomisd %xmm0, %xmm0
+;;       jp      0x86
+;;   54: movabsq $14114281232179134464, %r11
+;;       movq    %r11, %xmm15
+;;       ucomisd %xmm15, %xmm0
+;;       jb      0x88
+;;   6e: xorpd   %xmm15, %xmm15
+;;       ucomisd %xmm0, %xmm15
+;;       jb      0x8a
+;;   7e: addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   84: ud2
+;;   86: ud2
+;;   88: ud2
+;;   8a: ud2
diff --git a/tests/disas/winch/x64/i64_trunc_f64_s/params.wat b/tests/disas/winch/x64/i64_trunc_f64_s/params.wat
new file mode 100644
index 000000000000..ca749c1e5c3f
--- /dev/null
+++ b/tests/disas/winch/x64/i64_trunc_f64_s/params.wat
@@ -0,0 +1,42 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (result i64)
+        (local.get 0)
+        (i64.trunc_f64_s)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x81
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   8(%rsp), %xmm0
+;;       cvttsd2si %xmm0, %rax
+;;       cmpq    $1, %rax
+;;       jno     0x7b
+;;   47: ucomisd %xmm0, %xmm0
+;;       jp      0x83
+;;   51: movabsq $14114281232179134464, %r11
+;;       movq    %r11, %xmm15
+;;       ucomisd %xmm15, %xmm0
+;;       jb      0x85
+;;   6b: xorpd   %xmm15, %xmm15
+;;       ucomisd %xmm0, %xmm15
+;;       jb      0x87
+;;   7b: addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   81: ud2
+;;   83: ud2
+;;   85: ud2
+;;   87: ud2
diff --git a/tests/disas/winch/x64/i64_trunc_f64_u/const.wat b/tests/disas/winch/x64/i64_trunc_f64_u/const.wat
new file mode 100644
index 000000000000..a72734625844
--- /dev/null
+++ b/tests/disas/winch/x64/i64_trunc_f64_u/const.wat
@@ -0,0 +1,49 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (f64.const 1.0)
+        (i64.trunc_f64_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x8e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movsd   0x65(%rip), %xmm1
+;;       movabsq $0x43e0000000000000, %r11
+;;       movq    %r11, %xmm15
+;;       ucomisd %xmm15, %xmm1
+;;       jae     0x64
+;;       jp      0x90
+;;   53: cvttsd2si %xmm1, %rax
+;;       cmpq    $0, %rax
+;;       jge     0x88
+;;   62: ud2
+;;       movaps  %xmm1, %xmm0
+;;       subsd   %xmm15, %xmm0
+;;       cvttsd2si %xmm0, %rax
+;;       cmpq    $0, %rax
+;;       jl      0x92
+;;   7b: movabsq $9223372036854775808, %r11
+;;       addq    %r11, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   8e: ud2
+;;   90: ud2
+;;   92: ud2
+;;   94: addb    %al, (%rax)
+;;   96: addb    %al, (%rax)
+;;   98: addb    %al, (%rax)
+;;   9a: addb    %al, (%rax)
+;;   9c: addb    %al, (%rax)
diff --git a/tests/disas/winch/x64/i64_trunc_f64_u/locals.wat b/tests/disas/winch/x64/i64_trunc_f64_u/locals.wat
new file mode 100644
index 000000000000..f057cd5b0a60
--- /dev/null
+++ b/tests/disas/winch/x64/i64_trunc_f64_u/locals.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local f64)  
+
+        (local.get 0)
+        (i64.trunc_f64_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x96
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movsd   8(%rsp), %xmm1
+;;       movabsq $0x43e0000000000000, %r11
+;;       movq    %r11, %xmm15
+;;       ucomisd %xmm15, %xmm1
+;;       jae     0x6c
+;;       jp      0x98
+;;   5b: cvttsd2si %xmm1, %rax
+;;       cmpq    $0, %rax
+;;       jge     0x90
+;;   6a: ud2
+;;       movaps  %xmm1, %xmm0
+;;       subsd   %xmm15, %xmm0
+;;       cvttsd2si %xmm0, %rax
+;;       cmpq    $0, %rax
+;;       jl      0x9a
+;;   83: movabsq $9223372036854775808, %r11
+;;       addq    %r11, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   96: ud2
+;;   98: ud2
+;;   9a: ud2
diff --git a/tests/disas/winch/x64/i64_trunc_f64_u/params.wat b/tests/disas/winch/x64/i64_trunc_f64_u/params.wat
new file mode 100644
index 000000000000..9b19890af47b
--- /dev/null
+++ b/tests/disas/winch/x64/i64_trunc_f64_u/params.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param f64) (result i64)
+        (local.get 0)
+        (i64.trunc_f64_u)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x93
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movsd   %xmm0, 8(%rsp)
+;;       movsd   8(%rsp), %xmm1
+;;       movabsq $0x43e0000000000000, %r11
+;;       movq    %r11, %xmm15
+;;       ucomisd %xmm15, %xmm1
+;;       jae     0x69
+;;       jp      0x95
+;;   58: cvttsd2si %xmm1, %rax
+;;       cmpq    $0, %rax
+;;       jge     0x8d
+;;   67: ud2
+;;       movaps  %xmm1, %xmm0
+;;       subsd   %xmm15, %xmm0
+;;       cvttsd2si %xmm0, %rax
+;;       cmpq    $0, %rax
+;;       jl      0x97
+;;   80: movabsq $9223372036854775808, %r11
+;;       addq    %r11, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   93: ud2
+;;   95: ud2
+;;   97: ud2
diff --git a/tests/disas/winch/x64/i64_xor/32_const.wat b/tests/disas/winch/x64/i64_xor/32_const.wat
new file mode 100644
index 000000000000..f44e0223fad5
--- /dev/null
+++ b/tests/disas/winch/x64/i64_xor/32_const.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 2)
+        (i64.const 3)
+        (i64.xor)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $2, %rax
+;;       xorq    $3, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
diff --git a/tests/disas/winch/x64/i64_xor/64_const.wat b/tests/disas/winch/x64/i64_xor/64_const.wat
new file mode 100644
index 000000000000..ea42b476065a
--- /dev/null
+++ b/tests/disas/winch/x64/i64_xor/64_const.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (i64.const 9223372036854775806)
+        (i64.const 9223372036854775807)
+        (i64.xor)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x48
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movabsq $0x7ffffffffffffffe, %rax
+;;       movabsq $0x7fffffffffffffff, %r11
+;;       xorq    %r11, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   48: ud2
diff --git a/tests/disas/winch/x64/i64_xor/locals.wat b/tests/disas/winch/x64/i64_xor/locals.wat
new file mode 100644
index 000000000000..b341152bec0d
--- /dev/null
+++ b/tests/disas/winch/x64/i64_xor/locals.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (result i64)
+        (local $foo i64)
+        (local $bar i64)
+
+        (i64.const 2)
+        (local.set $foo)
+        (i64.const 3)
+        (local.set $bar)
+
+        (local.get $foo)
+        (local.get $bar)
+        (i64.xor)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x64
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 8(%rsp)
+;;       movq    %r11, (%rsp)
+;;       movq    $2, %rax
+;;       movq    %rax, 8(%rsp)
+;;       movq    $3, %rax
+;;       movq    %rax, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       xorq    %rax, %rcx
+;;       movq    %rcx, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   64: ud2
diff --git a/tests/disas/winch/x64/i64_xor/params.wat b/tests/disas/winch/x64/i64_xor/params.wat
new file mode 100644
index 000000000000..4a3f3ca18b2f
--- /dev/null
+++ b/tests/disas/winch/x64/i64_xor/params.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func (param i64) (param i64) (result i64)
+        (local.get 0)
+        (local.get 1)
+        (i64.xor)
+    )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    %rcx, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       xorq    %rax, %rcx
+;;       movq    %rcx, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4a: ud2
diff --git a/tests/disas/winch/x64/if/as_binop.wat b/tests/disas/winch/x64/if/as_binop.wat
new file mode 100644
index 000000000000..f28b816b8134
--- /dev/null
+++ b/tests/disas/winch/x64/if/as_binop.wat
@@ -0,0 +1,91 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func $dummy)
+  (func (export "as-binary-operand") (param i32 i32) (result i32)
+    (i32.mul
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 3))
+        (else (call $dummy) (i32.const -3))
+      )
+      (if (result i32) (local.get 1)
+        (then (call $dummy) (i32.const 4))
+        (else (call $dummy) (i32.const -5))
+      )
+    )
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x30, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x113
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       testl   %eax, %eax
+;;       je      0x9a
+;;   80: movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    0x18(%rsp), %r14
+;;       movl    $3, %eax
+;;       jmp     0xaf
+;;   9a: movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    0x18(%rsp), %r14
+;;       movl    $0xfffffffd, %eax
+;;       movl    8(%rsp), %ecx
+;;       subq    $4, %rsp
+;;       movl    %eax, (%rsp)
+;;       testl   %ecx, %ecx
+;;       je      0xe4
+;;   c2: subq    $0xc, %rsp
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       addq    $0xc, %rsp
+;;       movq    0x1c(%rsp), %r14
+;;       movl    $4, %eax
+;;       jmp     0x101
+;;   e4: subq    $0xc, %rsp
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       addq    $0xc, %rsp
+;;       movq    0x1c(%rsp), %r14
+;;       movl    $0xfffffffb, %eax
+;;       movl    (%rsp), %ecx
+;;       addq    $4, %rsp
+;;       imull   %eax, %ecx
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;  113: ud2
diff --git a/tests/disas/winch/x64/if/as_br_if_last.wat b/tests/disas/winch/x64/if/as_br_if_last.wat
new file mode 100644
index 000000000000..dd7d8edbd733
--- /dev/null
+++ b/tests/disas/winch/x64/if/as_br_if_last.wat
@@ -0,0 +1,76 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "as-br_if-last") (param i32) (result i32)
+    (block (result i32)
+      (br_if 0
+        (i32.const 2)
+        (if (result i32) (local.get 0)
+          (then (call $dummy) (i32.const 1))
+          (else (call $dummy) (i32.const 0))
+        )
+      )
+      (return (i32.const 3))
+    )
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x24, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0xdc
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       testl   %eax, %eax
+;;       je      0x96
+;;   7c: movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    0x18(%rsp), %r14
+;;       movl    $1, %eax
+;;       jmp     0xab
+;;   96: movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    0x18(%rsp), %r14
+;;       movl    $0, %eax
+;;       subq    $4, %rsp
+;;       movl    %eax, (%rsp)
+;;       movl    (%rsp), %ecx
+;;       addq    $4, %rsp
+;;       movl    $2, %eax
+;;       testl   %ecx, %ecx
+;;       jne     0xd6
+;;   c6: subq    $4, %rsp
+;;       movl    %eax, (%rsp)
+;;       movl    $3, %eax
+;;       addq    $4, %rsp
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   dc: ud2
diff --git a/tests/disas/winch/x64/if/as_if_cond.wat b/tests/disas/winch/x64/if/as_if_cond.wat
new file mode 100644
index 000000000000..232fcf892ce8
--- /dev/null
+++ b/tests/disas/winch/x64/if/as_if_cond.wat
@@ -0,0 +1,68 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func $dummy)
+  (func (export "as-if-condition") (param i32) (result i32)
+    (if (result i32)
+      (if (result i32) (local.get 0)
+        (then (i32.const 1)) (else (i32.const 0))
+      )
+      (then (call $dummy) (i32.const 2))
+      (else (call $dummy) (i32.const 3))
+    )
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0xc8
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       testl   %eax, %eax
+;;       je      0x86
+;;   7c: movl    $1, %eax
+;;       jmp     0x8b
+;;   86: movl    $0, %eax
+;;       testl   %eax, %eax
+;;       je      0xad
+;;   93: movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    0x18(%rsp), %r14
+;;       movl    $2, %eax
+;;       jmp     0xc2
+;;   ad: movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    0x18(%rsp), %r14
+;;       movl    $3, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   c8: ud2
diff --git a/tests/disas/winch/x64/if/as_testop.wat b/tests/disas/winch/x64/if/as_testop.wat
new file mode 100644
index 000000000000..5b0947686063
--- /dev/null
+++ b/tests/disas/winch/x64/if/as_testop.wat
@@ -0,0 +1,64 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "as-test-operand") (param i32) (result i32)
+    (i32.eqz
+      (if (result i32) (local.get 0)
+        (then (call $dummy) (i32.const 13))
+        (else (call $dummy) (i32.const 0))
+      )
+    )
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0xbd
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       testl   %eax, %eax
+;;       je      0x96
+;;   7c: movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    0x18(%rsp), %r14
+;;       movl    $0xd, %eax
+;;       jmp     0xab
+;;   96: movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    0x18(%rsp), %r14
+;;       movl    $0, %eax
+;;       cmpl    $0, %eax
+;;       movl    $0, %eax
+;;       sete    %al
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   bd: ud2
diff --git a/tests/disas/winch/x64/if/break_value.wat b/tests/disas/winch/x64/if/break_value.wat
new file mode 100644
index 000000000000..1bf48ad855ed
--- /dev/null
+++ b/tests/disas/winch/x64/if/break_value.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (export "break-value") (param i32) (result i32)
+    (if (result i32) (local.get 0)
+      (then (br 0 (i32.const 18)) (i32.const 19))
+      (else (br 0 (i32.const 21)) (i32.const 20))
+    )
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x51
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       testl   %eax, %eax
+;;       je      0x46
+;;   3c: movl    $0x12, %eax
+;;       jmp     0x4b
+;;   46: movl    $0x15, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   51: ud2
diff --git a/tests/disas/winch/x64/if/nested.wat b/tests/disas/winch/x64/if/nested.wat
new file mode 100644
index 000000000000..6082c1a0f344
--- /dev/null
+++ b/tests/disas/winch/x64/if/nested.wat
@@ -0,0 +1,122 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "nested") (param i32 i32) (result i32)
+    (if (result i32) (local.get 0)
+      (then
+        (if (local.get 1) (then (call $dummy) (nop)))
+        (if (local.get 1) (then) (else (call $dummy) (nop)))
+        (if (result i32) (local.get 1)
+          (then (call $dummy) (i32.const 9))
+          (else (call $dummy) (i32.const 10))
+        )
+      )
+      (else
+        (if (local.get 1) (then (call $dummy) (nop)))
+        (if (local.get 1) (then) (else (call $dummy) (nop)))
+        (if (result i32) (local.get 1)
+          (then (call $dummy) (i32.const 10))
+          (else (call $dummy) (i32.const 11))
+        )
+      )
+    )
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x17b
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       testl   %eax, %eax
+;;       je      0xfd
+;;   80: movl    8(%rsp), %eax
+;;       testl   %eax, %eax
+;;       je      0x9c
+;;   8c: movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    0x18(%rsp), %r14
+;;       movl    8(%rsp), %eax
+;;       testl   %eax, %eax
+;;       je      0xad
+;;       jmp     0xbd
+;;   ad: movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    0x18(%rsp), %r14
+;;       movl    8(%rsp), %eax
+;;       testl   %eax, %eax
+;;       je      0xe3
+;;   c9: movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    0x18(%rsp), %r14
+;;       movl    $9, %eax
+;;       jmp     0x175
+;;   e3: movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    0x18(%rsp), %r14
+;;       movl    $0xa, %eax
+;;       jmp     0x175
+;;   fd: movl    8(%rsp), %eax
+;;       testl   %eax, %eax
+;;       je      0x119
+;;  109: movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    0x18(%rsp), %r14
+;;       movl    8(%rsp), %eax
+;;       testl   %eax, %eax
+;;       je      0x12a
+;;       jmp     0x13a
+;;  12a: movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    0x18(%rsp), %r14
+;;       movl    8(%rsp), %eax
+;;       testl   %eax, %eax
+;;       je      0x160
+;;  146: movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    0x18(%rsp), %r14
+;;       movl    $0xa, %eax
+;;       jmp     0x175
+;;  160: movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    0x18(%rsp), %r14
+;;       movl    $0xb, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;  17b: ud2
diff --git a/tests/disas/winch/x64/if/reachability.wat b/tests/disas/winch/x64/if/reachability.wat
new file mode 100644
index 000000000000..d760a1dff2bb
--- /dev/null
+++ b/tests/disas/winch/x64/if/reachability.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func (;0;) (param i32) (result i32)
+    local.get 0
+    local.get 0
+    if (result i32)
+      i32.const 1
+        return
+      else
+        i32.const 2
+      end
+      i32.sub
+  )
+  (export "main" (func 0))
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x24, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x6d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       movl    0xc(%rsp), %r11d
+;;       subq    $4, %rsp
+;;       movl    %r11d, (%rsp)
+;;       testl   %eax, %eax
+;;       je      0x57
+;;   49: movl    $1, %eax
+;;       addq    $4, %rsp
+;;       jmp     0x67
+;;   57: movl    $2, %eax
+;;       movl    (%rsp), %ecx
+;;       addq    $4, %rsp
+;;       subl    %eax, %ecx
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   6d: ud2
diff --git a/tests/disas/winch/x64/if/singular.wat b/tests/disas/winch/x64/if/singular.wat
new file mode 100644
index 000000000000..737293f9b553
--- /dev/null
+++ b/tests/disas/winch/x64/if/singular.wat
@@ -0,0 +1,57 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func $dummy)
+  (func (export "singular") (param i32) (result i32)
+    (if (local.get 0) (then (nop)))
+    (if (local.get 0) (then (nop)) (else (nop)))
+    (if (result i32) (local.get 0) (then (i32.const 7)) (else (i32.const 8)))
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0xa9
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       testl   %eax, %eax
+;;       je      0x7c
+;;   7c: movl    0xc(%rsp), %eax
+;;       testl   %eax, %eax
+;;       je      0x88
+;;   88: movl    0xc(%rsp), %eax
+;;       testl   %eax, %eax
+;;       je      0x9e
+;;   94: movl    $7, %eax
+;;       jmp     0xa3
+;;   9e: movl    $8, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   a9: ud2
diff --git a/tests/disas/winch/x64/load/f32.wat b/tests/disas/winch/x64/load/f32.wat
new file mode 100644
index 000000000000..4c32af906855
--- /dev/null
+++ b/tests/disas/winch/x64/load/f32.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (memory (data "\00\00\a0\7f"))
+
+  (func (export "f32.load") (result f32) (f32.load (i32.const 0)))
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x41
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0, %eax
+;;       movq    0x60(%r14), %rcx
+;;       addq    %rax, %rcx
+;;       movss   (%rcx), %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   41: ud2
diff --git a/tests/disas/winch/x64/load/f64.wat b/tests/disas/winch/x64/load/f64.wat
new file mode 100644
index 000000000000..ebcd6f3c5063
--- /dev/null
+++ b/tests/disas/winch/x64/load/f64.wat
@@ -0,0 +1,27 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (memory (data "\00\00\00\00\00\00\f4\7f"))
+
+  (func (export "f64.load") (result f64) (f64.load (i32.const 0)))
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x41
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0, %eax
+;;       movq    0x60(%r14), %rcx
+;;       addq    %rax, %rcx
+;;       movsd   (%rcx), %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   41: ud2
diff --git a/tests/disas/winch/x64/load/grow_load.wat b/tests/disas/winch/x64/load/grow_load.wat
new file mode 100644
index 000000000000..a67105050265
--- /dev/null
+++ b/tests/disas/winch/x64/load/grow_load.wat
@@ -0,0 +1,104 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (type (;0;) (func (param f32 f64 i64 i64 f64 f64 f32) (result f32 f64 f32)))
+  (func (;0;) (type 0) (param f32 f64 i64 i64 f64 f64 f32) (result f32 f64 f32)
+    global.get 1
+    i32.eqz
+    if ;; label = @1
+      unreachable
+    end
+    global.get 1
+    i32.const 1
+    i32.sub
+    global.set 1
+    memory.size
+    memory.grow
+    i64.load8_s offset=143396
+    (drop)
+    (f32.const 0)
+    (f64.const 0)
+    (f32.const 0)
+  )
+  (memory (;1;) 10 10)
+  (global (;0;) f32 f32.const 0x1.d6a0d6p+87 (;=284477330000000000000000000;))
+  (global (;1;) (mut i32) i32.const 1000)
+  (export "main" (func 0))
+  (export "0" (memory 0))
+  (export "1" (global 0))
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x70, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x120
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x60, %rsp
+;;       movq    %rdi, 0x58(%rsp)
+;;       movq    %rsi, 0x50(%rsp)
+;;       movss   %xmm0, 0x4c(%rsp)
+;;       movsd   %xmm1, 0x40(%rsp)
+;;       movq    %rdx, 0x38(%rsp)
+;;       movq    %rcx, 0x30(%rsp)
+;;       movsd   %xmm2, 0x28(%rsp)
+;;       movsd   %xmm3, 0x20(%rsp)
+;;       movss   %xmm4, 0x1c(%rsp)
+;;       movq    %r8, 8(%rsp)
+;;       movl    0x80(%r14), %eax
+;;       cmpl    $0, %eax
+;;       movl    $0, %eax
+;;       sete    %al
+;;       testl   %eax, %eax
+;;       je      0x76
+;;   74: ud2
+;;       movl    0x80(%r14), %eax
+;;       subl    $1, %eax
+;;       movl    %eax, 0x80(%r14)
+;;       movq    0x68(%r14), %rax
+;;       shrl    $0x10, %eax
+;;       subq    $4, %rsp
+;;       movl    %eax, (%rsp)
+;;       subq    $0xc, %rsp
+;;       movq    %r14, %rdi
+;;       movl    0xc(%rsp), %esi
+;;       movl    $0, %edx
+;;       callq   0x2c0
+;;       addq    $0xc, %rsp
+;;       addq    $4, %rsp
+;;       movq    0x58(%rsp), %r14
+;;       movl    %eax, %eax
+;;       movq    0x60(%r14), %rcx
+;;       addq    %rax, %rcx
+;;       addq    $0x23024, %rcx
+;;       movsbq  (%rcx), %rax
+;;       movss   0x55(%rip), %xmm0
+;;       subq    $0xc, %rsp
+;;       movsd   0x50(%rip), %xmm15
+;;       movsd   %xmm15, (%rsp)
+;;       movss   0x39(%rip), %xmm15
+;;       movss   %xmm15, 8(%rsp)
+;;       movq    0x14(%rsp), %rax
+;;       movsd   (%rsp), %xmm15
+;;       addq    $8, %rsp
+;;       movsd   %xmm15, (%rax)
+;;       movss   (%rsp), %xmm15
+;;       addq    $4, %rsp
+;;       movss   %xmm15, 8(%rax)
+;;       addq    $0x60, %rsp
+;;       popq    %rbp
+;;       retq
+;;  120: ud2
+;;  122: addb    %al, (%rax)
+;;  124: addb    %al, (%rax)
+;;  126: addb    %al, (%rax)
+;;  128: addb    %al, (%rax)
+;;  12a: addb    %al, (%rax)
+;;  12c: addb    %al, (%rax)
+;;  12e: addb    %al, (%rax)
+;;  130: addb    %al, (%rax)
+;;  132: addb    %al, (%rax)
+;;  134: addb    %al, (%rax)
+;;  136: addb    %al, (%rax)
diff --git a/tests/disas/winch/x64/load/i32.wat b/tests/disas/winch/x64/load/i32.wat
new file mode 100644
index 000000000000..2bc6a21bac06
--- /dev/null
+++ b/tests/disas/winch/x64/load/i32.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (memory 1)
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (i32.load (i32.const 0))))
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0, %eax
+;;       movq    0x60(%r14), %rcx
+;;       addq    %rax, %rcx
+;;       movl    (%rcx), %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3f: ud2
diff --git a/tests/disas/winch/x64/load/i64.wat b/tests/disas/winch/x64/load/i64.wat
new file mode 100644
index 000000000000..987ee8c764a5
--- /dev/null
+++ b/tests/disas/winch/x64/load/i64.wat
@@ -0,0 +1,35 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (memory 1)
+  (func (export "i64_load8_s") (param $i i64) (result i64)
+   (i64.store8 (i32.const 8) (local.get $i))
+   (i64.load8_s (i32.const 8))
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x5a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    8(%rsp), %rax
+;;       movl    $8, %ecx
+;;       movq    0x60(%r14), %rdx
+;;       addq    %rcx, %rdx
+;;       movb    %al, (%rdx)
+;;       movl    $8, %eax
+;;       movq    0x60(%r14), %rcx
+;;       addq    %rax, %rcx
+;;       movsbq  (%rcx), %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   5a: ud2
diff --git a/tests/disas/winch/x64/load/v128.wat b/tests/disas/winch/x64/load/v128.wat
new file mode 100644
index 000000000000..876ef2c150b2
--- /dev/null
+++ b/tests/disas/winch/x64/load/v128.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (memory (data "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\a0\7f"))
+
+  (func (export "v128.load") (result v128) (v128.load (i32.const 0)))
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x41
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0, %eax
+;;       movq    0x60(%r14), %rcx
+;;       addq    %rax, %rcx
+;;       movdqu  (%rcx), %xmm0
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   41: ud2
diff --git a/tests/disas/winch/x64/local/latent.wat b/tests/disas/winch/x64/local/latent.wat
new file mode 100644
index 000000000000..6576ad9131fe
--- /dev/null
+++ b/tests/disas/winch/x64/local/latent.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (export "") (param i32) (result i32)
+    local.get 0
+    i32.const 1
+    local.set 0
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x24, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x53
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %r11d
+;;       subq    $4, %rsp
+;;       movl    %r11d, (%rsp)
+;;       movl    $1, %eax
+;;       movl    %eax, 0x10(%rsp)
+;;       movl    (%rsp), %eax
+;;       addq    $4, %rsp
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   53: ud2
diff --git a/tests/disas/winch/x64/local/materialized.wat b/tests/disas/winch/x64/local/materialized.wat
new file mode 100644
index 000000000000..0987127d6f46
--- /dev/null
+++ b/tests/disas/winch/x64/local/materialized.wat
@@ -0,0 +1,28 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (export "") (param i32) (result i32)
+    local.get 0
+    local.tee 0
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3e
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3e: ud2
diff --git a/tests/disas/winch/x64/loop/as_binary_operand.wat b/tests/disas/winch/x64/loop/as_binary_operand.wat
new file mode 100644
index 000000000000..7df234a8c6e6
--- /dev/null
+++ b/tests/disas/winch/x64/loop/as_binary_operand.wat
@@ -0,0 +1,54 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "as-binary-operand") (result i32)
+    (i32.mul
+      (loop (result i32) (call $dummy) (i32.const 3))
+      (loop (result i32) (call $dummy) (i32.const 4))
+    )
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x99
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       movl    $3, %eax
+;;       imull   $4, %eax, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   99: ud2
diff --git a/tests/disas/winch/x64/loop/as_br_if_first.wat b/tests/disas/winch/x64/loop/as_br_if_first.wat
new file mode 100644
index 000000000000..e6dcb472c1a0
--- /dev/null
+++ b/tests/disas/winch/x64/loop/as_br_if_first.wat
@@ -0,0 +1,27 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func (export "as-br-if-first") (result i32)
+    (block (result i32) (br_if 0 (loop (result i32) (i32.const 1)) (i32.const 2)))
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x43
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $2, %ecx
+;;       movl    $1, %eax
+;;       testl   %ecx, %ecx
+;;       jne     0x3d
+;;   3d: addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   43: ud2
diff --git a/tests/disas/winch/x64/loop/as_br_if_last.wat b/tests/disas/winch/x64/loop/as_br_if_last.wat
new file mode 100644
index 000000000000..09d92110dd3c
--- /dev/null
+++ b/tests/disas/winch/x64/loop/as_br_if_last.wat
@@ -0,0 +1,27 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func (export "as-br-if-last") (result i32)
+    (block (result i32) (br_if 0 (i32.const 2) (loop (result i32) (i32.const 1))))
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x43
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %ecx
+;;       movl    $2, %eax
+;;       testl   %ecx, %ecx
+;;       jne     0x3d
+;;   3d: addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   43: ud2
diff --git a/tests/disas/winch/x64/loop/as_br_value.wat b/tests/disas/winch/x64/loop/as_br_value.wat
new file mode 100644
index 000000000000..da723169c409
--- /dev/null
+++ b/tests/disas/winch/x64/loop/as_br_value.wat
@@ -0,0 +1,24 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (loop (result i32) (i32.const 1))))
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x36
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   36: ud2
diff --git a/tests/disas/winch/x64/loop/as_call_value.wat b/tests/disas/winch/x64/loop/as_call_value.wat
new file mode 100644
index 000000000000..f9dbfb74debc
--- /dev/null
+++ b/tests/disas/winch/x64/loop/as_call_value.wat
@@ -0,0 +1,48 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $f (param i32) (result i32) (local.get 0))
+  (func (export "as-call-value") (result i32)
+    (call $f (loop (result i32) (i32.const 1)))
+  )
+)
+;; wasm[0]::function[0]::f:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3a: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x86
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       movl    $1, %edx
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   86: ud2
diff --git a/tests/disas/winch/x64/loop/as_if_condition.wat b/tests/disas/winch/x64/loop/as_if_condition.wat
new file mode 100644
index 000000000000..ce0eacb628a2
--- /dev/null
+++ b/tests/disas/winch/x64/loop/as_if_condition.wat
@@ -0,0 +1,48 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "as-if-condition")
+    (loop (result i32) (i32.const 1)) (if (then (call $dummy)))
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x8e
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       testl   %eax, %eax
+;;       je      0x88
+;;   78: movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   8e: ud2
diff --git a/tests/disas/winch/x64/loop/as_if_else.wat b/tests/disas/winch/x64/loop/as_if_else.wat
new file mode 100644
index 000000000000..a8f79f630585
--- /dev/null
+++ b/tests/disas/winch/x64/loop/as_if_else.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func (export "as-if-else") (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 2)) (else (loop (result i32) (i32.const 1))))
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       testl   %eax, %eax
+;;       je      0x42
+;;   38: movl    $2, %eax
+;;       jmp     0x47
+;;   42: movl    $1, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4d: ud2
diff --git a/tests/disas/winch/x64/loop/as_if_then.wat b/tests/disas/winch/x64/loop/as_if_then.wat
new file mode 100644
index 000000000000..a88a0dffa21b
--- /dev/null
+++ b/tests/disas/winch/x64/loop/as_if_then.wat
@@ -0,0 +1,29 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func (export "as-if-then") (result i32)
+    (if (result i32) (i32.const 1) (then (loop (result i32) (i32.const 1))) (else (i32.const 2)))
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4d
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       testl   %eax, %eax
+;;       je      0x42
+;;   38: movl    $1, %eax
+;;       jmp     0x47
+;;   42: movl    $2, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4d: ud2
diff --git a/tests/disas/winch/x64/loop/as_local_set_value.wat b/tests/disas/winch/x64/loop/as_local_set_value.wat
new file mode 100644
index 000000000000..7b43d4837a0c
--- /dev/null
+++ b/tests/disas/winch/x64/loop/as_local_set_value.wat
@@ -0,0 +1,27 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func (export "as-local-set-value") (result i32)
+    (local i32) (local.set 0 (loop (result i32) (i32.const 1))) (local.get 0)
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x48
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $1, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   48: ud2
diff --git a/tests/disas/winch/x64/loop/as_test_operand.wat b/tests/disas/winch/x64/loop/as_test_operand.wat
new file mode 100644
index 000000000000..5ddc5238aedb
--- /dev/null
+++ b/tests/disas/winch/x64/loop/as_test_operand.wat
@@ -0,0 +1,49 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "as-test-operand") (result i32)
+    (i32.eqz (loop (result i32) (call $dummy) (i32.const 13)))
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x92
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       movl    $0xd, %eax
+;;       cmpl    $0, %eax
+;;       movl    $0, %eax
+;;       sete    %al
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   92: ud2
diff --git a/tests/disas/winch/x64/loop/as_unary_operand.wat b/tests/disas/winch/x64/loop/as_unary_operand.wat
new file mode 100644
index 000000000000..13a5449182ef
--- /dev/null
+++ b/tests/disas/winch/x64/loop/as_unary_operand.wat
@@ -0,0 +1,51 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "as-unary-operand") (result i32)
+    (i32.ctz (loop (result i32) (call $dummy) (i32.const 13)))
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x9a
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       movl    $0xd, %eax
+;;       bsfl    %eax, %eax
+;;       movl    $0, %r11d
+;;       sete    %r11b
+;;       shll    $5, %r11d
+;;       addl    %r11d, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   9a: ud2
diff --git a/tests/disas/winch/x64/loop/break_inner.wat b/tests/disas/winch/x64/loop/break_inner.wat
new file mode 100644
index 000000000000..48ec1753b553
--- /dev/null
+++ b/tests/disas/winch/x64/loop/break_inner.wat
@@ -0,0 +1,74 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func (export "break-inner") (result i32)
+    (local i32)
+    (local.set 0 (i32.const 0))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (block (result i32) (br 2 (i32.const 0x1)))))))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (loop (result i32) (br 2 (i32.const 0x2)))))))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (block (result i32) (loop (result i32) (br 1 (i32.const 0x4))))))))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (i32.ctz (br 1 (i32.const 0x8)))))))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (i32.ctz (loop (result i32) (br 2 (i32.const 0x10))))))))
+    (local.get 0)
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x24, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0xe3
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $0, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    0xc(%rsp), %r11d
+;;       subq    $4, %rsp
+;;       movl    %r11d, (%rsp)
+;;       movl    $1, %eax
+;;       movl    (%rsp), %ecx
+;;       addq    $4, %rsp
+;;       addl    %eax, %ecx
+;;       movl    %ecx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %r11d
+;;       subq    $4, %rsp
+;;       movl    %r11d, (%rsp)
+;;       movl    $2, %eax
+;;       movl    (%rsp), %ecx
+;;       addq    $4, %rsp
+;;       addl    %eax, %ecx
+;;       movl    %ecx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %r11d
+;;       subq    $4, %rsp
+;;       movl    %r11d, (%rsp)
+;;       movl    $4, %eax
+;;       movl    (%rsp), %ecx
+;;       addq    $4, %rsp
+;;       addl    %eax, %ecx
+;;       movl    %ecx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %r11d
+;;       subq    $4, %rsp
+;;       movl    %r11d, (%rsp)
+;;       movl    $8, %eax
+;;       movl    (%rsp), %ecx
+;;       addq    $4, %rsp
+;;       addl    %eax, %ecx
+;;       movl    %ecx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %r11d
+;;       subq    $4, %rsp
+;;       movl    %r11d, (%rsp)
+;;       movl    $0x10, %eax
+;;       movl    (%rsp), %ecx
+;;       addq    $4, %rsp
+;;       addl    %eax, %ecx
+;;       movl    %ecx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   e3: ud2
diff --git a/tests/disas/winch/x64/loop/cont_inner.wat b/tests/disas/winch/x64/loop/cont_inner.wat
new file mode 100644
index 000000000000..1a1e7cb499bf
--- /dev/null
+++ b/tests/disas/winch/x64/loop/cont_inner.wat
@@ -0,0 +1,35 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func (export "cont-inner") (result i32)
+    (local i32)
+    (local.set 0 (i32.const 0))
+    (local.set 0 (i32.add (local.get 0) (loop (result i32) (loop (result i32) (br 1)))))
+    (local.set 0 (i32.add (local.get 0) (loop (result i32) (i32.ctz (br 0)))))
+    (local.set 0 (i32.add (local.get 0) (loop (result i32) (i32.ctz (loop (result i32) (br 1))))))
+    (local.get 0)
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x24, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x56
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $0, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    0xc(%rsp), %r11d
+;;       subq    $4, %rsp
+;;       movl    %r11d, (%rsp)
+;;       jmp     0x4b
+;;   50: addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   56: ud2
diff --git a/tests/disas/winch/x64/loop/deep.wat b/tests/disas/winch/x64/loop/deep.wat
new file mode 100644
index 000000000000..b60c55acf8c4
--- /dev/null
+++ b/tests/disas/winch/x64/loop/deep.wat
@@ -0,0 +1,87 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func $dummy)
+  (func (export "deep") (result i32)
+    (loop (result i32) (block (result i32)
+      (loop (result i32) (block (result i32)
+        (loop (result i32) (block (result i32)
+          (loop (result i32) (block (result i32)
+            (loop (result i32) (block (result i32)
+              (loop (result i32) (block (result i32)
+                (loop (result i32) (block (result i32)
+                  (loop (result i32) (block (result i32)
+                    (loop (result i32) (block (result i32)
+                      (loop (result i32) (block (result i32)
+                        (loop (result i32) (block (result i32)
+                          (loop (result i32) (block (result i32)
+                            (loop (result i32) (block (result i32)
+                              (loop (result i32) (block (result i32)
+                                (loop (result i32) (block (result i32)
+                                  (loop (result i32) (block (result i32)
+                                    (loop (result i32) (block (result i32)
+                                      (loop (result i32) (block (result i32)
+                                        (loop (result i32) (block (result i32)
+                                          (loop (result i32) (block (result i32)
+                                            (call $dummy) (i32.const 150)
+                                          ))
+                                        ))
+                                      ))
+                                    ))
+                                  ))
+                                ))
+                              ))
+                            ))
+                          ))
+                        ))
+                      ))
+                    ))
+                  ))
+                ))
+              ))
+            ))
+          ))
+        ))
+      ))
+    ))
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x86
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       movl    $0x96, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   86: ud2
diff --git a/tests/disas/winch/x64/loop/effects.wat b/tests/disas/winch/x64/loop/effects.wat
new file mode 100644
index 000000000000..dc88ca705898
--- /dev/null
+++ b/tests/disas/winch/x64/loop/effects.wat
@@ -0,0 +1,50 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $fx (export "effects") (result i32)
+    (local i32)
+    (block
+      (loop
+        (local.set 0 (i32.const 1))
+        (local.set 0 (i32.mul (local.get 0) (i32.const 3)))
+        (local.set 0 (i32.sub (local.get 0) (i32.const 5)))
+        (local.set 0 (i32.mul (local.get 0) (i32.const 7)))
+        (br 1)
+        (local.set 0 (i32.mul (local.get 0) (i32.const 100)))
+      )
+    )
+    (i32.eq (local.get 0) (i32.const -14))
+  )
+)
+;; wasm[0]::function[0]::fx:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x75
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    $1, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       imull   $3, %eax, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       subl    $5, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       imull   $7, %eax, %eax
+;;       movl    %eax, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       cmpl    $-0xe, %eax
+;;       movl    $0, %eax
+;;       sete    %al
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   75: ud2
diff --git a/tests/disas/winch/x64/loop/empty.wat b/tests/disas/winch/x64/loop/empty.wat
new file mode 100644
index 000000000000..3b830edf1b45
--- /dev/null
+++ b/tests/disas/winch/x64/loop/empty.wat
@@ -0,0 +1,25 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (export "empty")
+    (loop)
+    (loop $l)
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
diff --git a/tests/disas/winch/x64/loop/for.wat b/tests/disas/winch/x64/loop/for.wat
new file mode 100644
index 000000000000..98223aeade78
--- /dev/null
+++ b/tests/disas/winch/x64/loop/for.wat
@@ -0,0 +1,58 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func (export "for-") (param i64) (result i64)
+    (local i64 i64)
+    (local.set 1 (i64.const 1))
+    (local.set 2 (i64.const 2))
+    (block
+      (loop
+        (br_if 1 (i64.gt_u (local.get 2) (local.get 0)))
+        (local.set 1 (i64.mul (local.get 1) (local.get 2)))
+        (local.set 2 (i64.add (local.get 2) (i64.const 1)))
+        (br 0)
+      )
+    )
+    (local.get 1)
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x30, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0xa5
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x30, %rsp
+;;       movq    %rdi, 0x28(%rsp)
+;;       movq    %rsi, 0x20(%rsp)
+;;       movq    %rdx, 0x18(%rsp)
+;;       xorl    %r11d, %r11d
+;;       movq    %r11, 0x10(%rsp)
+;;       movq    %r11, 8(%rsp)
+;;       movq    $1, %rax
+;;       movq    %rax, 0x10(%rsp)
+;;       movq    $2, %rax
+;;       movq    %rax, 8(%rsp)
+;;       movq    0x18(%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       cmpq    %rax, %rcx
+;;       movl    $0, %ecx
+;;       seta    %cl
+;;       testl   %ecx, %ecx
+;;       jne     0x9a
+;;   74: movq    8(%rsp), %rax
+;;       movq    0x10(%rsp), %rcx
+;;       imulq   %rax, %rcx
+;;       movq    %rcx, 0x10(%rsp)
+;;       movq    8(%rsp), %rax
+;;       addq    $1, %rax
+;;       movq    %rax, 8(%rsp)
+;;       jmp     0x56
+;;   9a: movq    0x10(%rsp), %rax
+;;       addq    $0x30, %rsp
+;;       popq    %rbp
+;;       retq
+;;   a5: ud2
diff --git a/tests/disas/winch/x64/loop/multi.wat b/tests/disas/winch/x64/loop/multi.wat
new file mode 100644
index 000000000000..d43531681bc2
--- /dev/null
+++ b/tests/disas/winch/x64/loop/multi.wat
@@ -0,0 +1,72 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func $dummy)
+  (func (export "multi") (result i32)
+    (loop (call $dummy) (call $dummy) (call $dummy) (call $dummy))
+    (loop (result i32) (call $dummy) (call $dummy) (i32.const 8) (call $dummy))
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0xe6
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       movl    $8, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   e6: ud2
diff --git a/tests/disas/winch/x64/loop/nested.wat b/tests/disas/winch/x64/loop/nested.wat
new file mode 100644
index 000000000000..8c1fbd9bf2b6
--- /dev/null
+++ b/tests/disas/winch/x64/loop/nested.wat
@@ -0,0 +1,53 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "nested") (result i32)
+    (loop (result i32)
+      (loop (call $dummy) (block) (nop))
+      (loop (result i32) (call $dummy) (i32.const 9))
+    )
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x96
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       movl    $9, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   96: ud2
diff --git a/tests/disas/winch/x64/loop/singular.wat b/tests/disas/winch/x64/loop/singular.wat
new file mode 100644
index 000000000000..2947f1af7632
--- /dev/null
+++ b/tests/disas/winch/x64/loop/singular.wat
@@ -0,0 +1,26 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (export "singular") (result i32)
+    (loop (nop))
+    (loop (result i32) (i32.const 7))
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x36
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $7, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   36: ud2
diff --git a/tests/disas/winch/x64/loop/while.wat b/tests/disas/winch/x64/loop/while.wat
new file mode 100644
index 000000000000..b688b1a6ca2d
--- /dev/null
+++ b/tests/disas/winch/x64/loop/while.wat
@@ -0,0 +1,52 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func (export "while-") (param i64) (result i64)
+    (local i64)
+    (local.set 1 (i64.const 1))
+    (block
+      (loop
+        (br_if 1 (i64.eqz (local.get 0)))
+        (local.set 1 (i64.mul (local.get 0) (local.get 1)))
+        (local.set 0 (i64.sub (local.get 0) (i64.const 1)))
+        (br 0)
+      )
+    )
+    (local.get 1)
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x8c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    $0, (%rsp)
+;;       movq    $1, %rax
+;;       movq    %rax, (%rsp)
+;;       movq    8(%rsp), %rax
+;;       cmpq    $0, %rax
+;;       movl    $0, %eax
+;;       sete    %al
+;;       testl   %eax, %eax
+;;       jne     0x82
+;;   5e: movq    (%rsp), %rax
+;;       movq    8(%rsp), %rcx
+;;       imulq   %rax, %rcx
+;;       movq    %rcx, (%rsp)
+;;       movq    8(%rsp), %rax
+;;       subq    $1, %rax
+;;       movq    %rax, 8(%rsp)
+;;       jmp     0x44
+;;   82: movq    (%rsp), %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   8c: ud2
diff --git a/tests/disas/winch/x64/nop/nop.wat b/tests/disas/winch/x64/nop/nop.wat
new file mode 100644
index 000000000000..958735cd4b51
--- /dev/null
+++ b/tests/disas/winch/x64/nop/nop.wat
@@ -0,0 +1,25 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+    (func
+        nop
+    )
+)
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
diff --git a/tests/disas/winch/x64/return/as_block_first.wat b/tests/disas/winch/x64/return/as_block_first.wat
new file mode 100644
index 000000000000..0114f54772c1
--- /dev/null
+++ b/tests/disas/winch/x64/return/as_block_first.wat
@@ -0,0 +1,42 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "as-block-first")
+   (block (return) (call $dummy))
+  )
+)
+  
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x71
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   71: ud2
diff --git a/tests/disas/winch/x64/return/as_block_last.wat b/tests/disas/winch/x64/return/as_block_last.wat
new file mode 100644
index 000000000000..2caf07ccff92
--- /dev/null
+++ b/tests/disas/winch/x64/return/as_block_last.wat
@@ -0,0 +1,46 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "as-block-last")
+   (block (nop) (call $dummy) (return))
+  )
+)
+  
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x81
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   81: ud2
diff --git a/tests/disas/winch/x64/return/as_block_mid.wat b/tests/disas/winch/x64/return/as_block_mid.wat
new file mode 100644
index 000000000000..100de03d1528
--- /dev/null
+++ b/tests/disas/winch/x64/return/as_block_mid.wat
@@ -0,0 +1,46 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "as-block-mid")
+   (block (call $dummy) (return) (call $dummy))
+  )
+)
+  
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x81
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   81: ud2
diff --git a/tests/disas/winch/x64/return/as_block_value.wat b/tests/disas/winch/x64/return/as_block_value.wat
new file mode 100644
index 000000000000..7fa73dbeadd9
--- /dev/null
+++ b/tests/disas/winch/x64/return/as_block_value.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "as-block-value") (result i32)
+   (block (result i32) (nop) (call $dummy) (return (i32.const 2)))
+  )
+)
+  
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x86
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       movl    $2, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   86: ud2
diff --git a/tests/disas/winch/x64/return/as_br_if_cond.wat b/tests/disas/winch/x64/return/as_br_if_cond.wat
new file mode 100644
index 000000000000..bdee5f7286ac
--- /dev/null
+++ b/tests/disas/winch/x64/return/as_br_if_cond.wat
@@ -0,0 +1,42 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "as-br-if-cond")
+   (block (br_if 0 (return)))
+  )
+)
+  
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x71
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   71: ud2
diff --git a/tests/disas/winch/x64/return/as_br_value.wat b/tests/disas/winch/x64/return/as_br_value.wat
new file mode 100644
index 000000000000..752869e73df4
--- /dev/null
+++ b/tests/disas/winch/x64/return/as_br_value.wat
@@ -0,0 +1,43 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "as-br-value") (result i32)
+   (block (result i32) (br 0 (return (i32.const 9))))
+  )
+)
+  
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x76
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $9, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   76: ud2
diff --git a/tests/disas/winch/x64/return/as_call_fist.wat b/tests/disas/winch/x64/return/as_call_fist.wat
new file mode 100644
index 000000000000..58a6fe06f032
--- /dev/null
+++ b/tests/disas/winch/x64/return/as_call_fist.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (result i32)
+    (call $f (return (i32.const 12)) (i32.const 2) (i32.const 3))
+  )
+)
+  
+;; wasm[0]::function[0]::f:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x44
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    %r8d, 4(%rsp)
+;;       movl    $0xffffffff, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   44: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x86
+;;   6b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0xc, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   86: ud2
diff --git a/tests/disas/winch/x64/return/as_call_last.wat b/tests/disas/winch/x64/return/as_call_last.wat
new file mode 100644
index 000000000000..d58617f197d8
--- /dev/null
+++ b/tests/disas/winch/x64/return/as_call_last.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-last") (result i32)
+    (call $f (i32.const 1) (i32.const 2) (return (i32.const 14)))
+  )
+)
+  
+;; wasm[0]::function[0]::f:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x44
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    %r8d, 4(%rsp)
+;;       movl    $0xffffffff, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   44: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x86
+;;   6b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0xe, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   86: ud2
diff --git a/tests/disas/winch/x64/return/as_call_mid.wat b/tests/disas/winch/x64/return/as_call_mid.wat
new file mode 100644
index 000000000000..056ffee67299
--- /dev/null
+++ b/tests/disas/winch/x64/return/as_call_mid.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-mid") (result i32)
+    (call $f (i32.const 1) (return (i32.const 13)) (i32.const 3))
+  )
+)
+  
+;; wasm[0]::function[0]::f:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x44
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    %r8d, 4(%rsp)
+;;       movl    $0xffffffff, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   44: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x86
+;;   6b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0xd, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   86: ud2
diff --git a/tests/disas/winch/x64/return/as_func_first.wat b/tests/disas/winch/x64/return/as_func_first.wat
new file mode 100644
index 000000000000..7e0e5dd480f3
--- /dev/null
+++ b/tests/disas/winch/x64/return/as_func_first.wat
@@ -0,0 +1,43 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "as-func-first") (result i32)
+   (return (i32.const 1)) (i32.const 2)
+  )
+)
+  
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x76
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   76: ud2
diff --git a/tests/disas/winch/x64/return/as_func_last.wat b/tests/disas/winch/x64/return/as_func_last.wat
new file mode 100644
index 000000000000..0f6a545cb2c6
--- /dev/null
+++ b/tests/disas/winch/x64/return/as_func_last.wat
@@ -0,0 +1,22 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+)
+  
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
diff --git a/tests/disas/winch/x64/return/as_func_mid.wat b/tests/disas/winch/x64/return/as_func_mid.wat
new file mode 100644
index 000000000000..730073fcfc8a
--- /dev/null
+++ b/tests/disas/winch/x64/return/as_func_mid.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "as-func-mid") (result i32)
+   (call $dummy) (return (i32.const 2)) (i32.const 3)
+  )
+)
+  
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x86
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       movl    $2, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   86: ud2
diff --git a/tests/disas/winch/x64/return/as_func_value.wat b/tests/disas/winch/x64/return/as_func_value.wat
new file mode 100644
index 000000000000..3311f70de309
--- /dev/null
+++ b/tests/disas/winch/x64/return/as_func_value.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+    (func (export "as-func-value") (result i32)
+        (nop) (call $dummy) (return (i32.const 3))
+    )
+)
+  
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x86
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       movl    $3, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   86: ud2
diff --git a/tests/disas/winch/x64/return/as_if_cond.wat b/tests/disas/winch/x64/return/as_if_cond.wat
new file mode 100644
index 000000000000..c1b869dd2b0d
--- /dev/null
+++ b/tests/disas/winch/x64/return/as_if_cond.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "as-if-cond") (result i32)
+   (if (result i32)
+    (return (i32.const 2)) (then (i32.const 0)) (else (i32.const 1))
+   )
+  )
+)
+  
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x76
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $2, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   76: ud2
diff --git a/tests/disas/winch/x64/return/as_if_else.wat b/tests/disas/winch/x64/return/as_if_else.wat
new file mode 100644
index 000000000000..b96e50873d1b
--- /dev/null
+++ b/tests/disas/winch/x64/return/as_if_else.wat
@@ -0,0 +1,53 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+
+  (func (export "as-if-else") (param i32 i32) (result i32)
+   (if (result i32)
+    (local.get 0) (then (local.get 1)) (else (return (i32.const 4)))
+   )
+  )
+)
+  
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x94
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       testl   %eax, %eax
+;;       je      0x89
+;;   80: movl    8(%rsp), %eax
+;;       jmp     0x8e
+;;   89: movl    $4, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   94: ud2
diff --git a/tests/disas/winch/x64/return/as_if_then.wat b/tests/disas/winch/x64/return/as_if_then.wat
new file mode 100644
index 000000000000..c1037db9dbd0
--- /dev/null
+++ b/tests/disas/winch/x64/return/as_if_then.wat
@@ -0,0 +1,53 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+
+  (func (export "as-if-then") (param i32 i32) (result i32)
+   (if (result i32)
+    (local.get 0) (then (return (i32.const 3))) (else (local.get 1))
+   )
+  )
+)
+  
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x94
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       testl   %eax, %eax
+;;       je      0x8a
+;;   80: movl    $3, %eax
+;;       jmp     0x8e
+;;   8a: movl    8(%rsp), %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   94: ud2
diff --git a/tests/disas/winch/x64/return/as_loop_first.wat b/tests/disas/winch/x64/return/as_loop_first.wat
new file mode 100644
index 000000000000..ffc33d39aed2
--- /dev/null
+++ b/tests/disas/winch/x64/return/as_loop_first.wat
@@ -0,0 +1,43 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "as-loop-first") (result i32)
+   (loop (result i32) (return (i32.const 3)) (i32.const 2))
+  )
+)
+  
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x76
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $3, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   76: ud2
diff --git a/tests/disas/winch/x64/return/as_loop_last.wat b/tests/disas/winch/x64/return/as_loop_last.wat
new file mode 100644
index 000000000000..503a653055b4
--- /dev/null
+++ b/tests/disas/winch/x64/return/as_loop_last.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "as-loop-last") (result i32)
+   (loop (result i32) (nop) (call $dummy) (return (i32.const 5)))
+  )
+)
+  
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x86
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       movl    $5, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   86: ud2
diff --git a/tests/disas/winch/x64/return/as_loop_mid.wat b/tests/disas/winch/x64/return/as_loop_mid.wat
new file mode 100644
index 000000000000..7d238eca40da
--- /dev/null
+++ b/tests/disas/winch/x64/return/as_loop_mid.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "as-loop-mid") (result i32)
+   (loop (result i32) (call $dummy) (return (i32.const 4)) (i32.const 2))
+  )
+)
+  
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x86
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       movl    $4, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   86: ud2
diff --git a/tests/disas/winch/x64/return/as_return_value.wat b/tests/disas/winch/x64/return/as_return_value.wat
new file mode 100644
index 000000000000..d6273e7d70dc
--- /dev/null
+++ b/tests/disas/winch/x64/return/as_return_value.wat
@@ -0,0 +1,43 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "as-return-value") (result i64)
+    (return (return (i64.const 7)))
+  )
+)
+  
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x78
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $7, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   78: ud2
diff --git a/tests/disas/winch/x64/return/nullary.wat b/tests/disas/winch/x64/return/nullary.wat
new file mode 100644
index 000000000000..91b8d1fcd237
--- /dev/null
+++ b/tests/disas/winch/x64/return/nullary.wat
@@ -0,0 +1,40 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "nullary") (return))
+)
+  
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x71
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   71: ud2
diff --git a/tests/disas/winch/x64/return/type_i32.wat b/tests/disas/winch/x64/return/type_i32.wat
new file mode 100644
index 000000000000..66703bbc80f2
--- /dev/null
+++ b/tests/disas/winch/x64/return/type_i32.wat
@@ -0,0 +1,44 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+
+  (func (export "type-i32-value") (result i32)
+   (block (result i32) (i32.ctz (return (i32.const 1))))
+  )
+)
+  
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x76
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   76: ud2
diff --git a/tests/disas/winch/x64/return/type_i64_value.wat b/tests/disas/winch/x64/return/type_i64_value.wat
new file mode 100644
index 000000000000..802f3578e363
--- /dev/null
+++ b/tests/disas/winch/x64/return/type_i64_value.wat
@@ -0,0 +1,44 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+
+  (func (export "type-i64-value") (result i64)
+   (block (result i64) (i64.ctz (return (i64.const 2))))
+  )
+)
+  
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x78
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    $2, %rax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   78: ud2
diff --git a/tests/disas/winch/x64/select/f32.wat b/tests/disas/winch/x64/select/f32.wat
new file mode 100644
index 000000000000..caa5cf2e4024
--- /dev/null
+++ b/tests/disas/winch/x64/select/f32.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (export "select-f32") (param f32 f32 i32) (result f32)
+    (select (local.get 0) (local.get 1) (local.get 2))
+  )
+)
+ 
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x5f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movss   %xmm0, 0xc(%rsp)
+;;       movss   %xmm1, 8(%rsp)
+;;       movl    %edx, 4(%rsp)
+;;       movl    4(%rsp), %eax
+;;       movss   8(%rsp), %xmm0
+;;       movss   0xc(%rsp), %xmm1
+;;       cmpl    $0, %eax
+;;       je      0x59
+;;   55: movsd   %xmm1, %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   5f: ud2
diff --git a/tests/disas/winch/x64/select/f64.wat b/tests/disas/winch/x64/select/f64.wat
new file mode 100644
index 000000000000..e5a71bb39469
--- /dev/null
+++ b/tests/disas/winch/x64/select/f64.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (export "select-f64") (param f64 f64 i32) (result f64)
+    (select (local.get 0) (local.get 1) (local.get 2))
+  )
+)
+ 
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x30, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x5f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x30, %rsp
+;;       movq    %rdi, 0x28(%rsp)
+;;       movq    %rsi, 0x20(%rsp)
+;;       movsd   %xmm0, 0x18(%rsp)
+;;       movsd   %xmm1, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       movsd   0x10(%rsp), %xmm0
+;;       movsd   0x18(%rsp), %xmm1
+;;       cmpl    $0, %eax
+;;       je      0x59
+;;   55: movsd   %xmm1, %xmm0
+;;       addq    $0x30, %rsp
+;;       popq    %rbp
+;;       retq
+;;   5f: ud2
diff --git a/tests/disas/winch/x64/select/i32.wat b/tests/disas/winch/x64/select/i32.wat
new file mode 100644
index 000000000000..1ee0eacf0bd0
--- /dev/null
+++ b/tests/disas/winch/x64/select/i32.wat
@@ -0,0 +1,33 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (export "select-i32") (param i32 i32 i32) (result i32)
+    (select (local.get 0) (local.get 1) (local.get 2))
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x53
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    %r8d, 4(%rsp)
+;;       movl    4(%rsp), %eax
+;;       movl    8(%rsp), %ecx
+;;       movl    0xc(%rsp), %edx
+;;       cmpl    $0, %eax
+;;       cmovnel %edx, %ecx
+;;       movl    %ecx, %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   53: ud2
diff --git a/tests/disas/winch/x64/select/i64.wat b/tests/disas/winch/x64/select/i64.wat
new file mode 100644
index 000000000000..09a704c3fbbf
--- /dev/null
+++ b/tests/disas/winch/x64/select/i64.wat
@@ -0,0 +1,34 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (export "select-i64") (param i64 i64 i32) (result i64)
+    (select (local.get 0) (local.get 1) (local.get 2))
+  )
+)
+ 
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x30, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x59
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x30, %rsp
+;;       movq    %rdi, 0x28(%rsp)
+;;       movq    %rsi, 0x20(%rsp)
+;;       movq    %rdx, 0x18(%rsp)
+;;       movq    %rcx, 0x10(%rsp)
+;;       movl    %r8d, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       movq    0x10(%rsp), %rcx
+;;       movq    0x18(%rsp), %rdx
+;;       cmpl    $0, %eax
+;;       cmovneq %rdx, %rcx
+;;       movq    %rcx, %rax
+;;       addq    $0x30, %rsp
+;;       popq    %rbp
+;;       retq
+;;   59: ud2
diff --git a/tests/disas/winch/x64/store/f32.wat b/tests/disas/winch/x64/store/f32.wat
new file mode 100644
index 000000000000..a1c413c99752
--- /dev/null
+++ b/tests/disas/winch/x64/store/f32.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (memory (data "\00\00\a0\7f"))
+  (func (export "f32.store") (f32.store (i32.const 0) (f32.const nan:0x200000)))
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x49
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movss   0x1d(%rip), %xmm0
+;;       movl    $0, %eax
+;;       movq    0x60(%r14), %rcx
+;;       addq    %rax, %rcx
+;;       movss   %xmm0, (%rcx)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   49: ud2
+;;   4b: addb    %al, (%rax)
+;;   4d: addb    %al, (%rax)
+;;   4f: addb    %al, (%rax)
diff --git a/tests/disas/winch/x64/store/f64.wat b/tests/disas/winch/x64/store/f64.wat
new file mode 100644
index 000000000000..4f5debe8fc63
--- /dev/null
+++ b/tests/disas/winch/x64/store/f64.wat
@@ -0,0 +1,35 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (memory (data "\00\00\00\00\00\00\f4\7f"))
+  (func (export "f64.store") (f64.store (i32.const 0) (f64.const nan:0x4000000000000)))
+)
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x49
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movsd   0x1d(%rip), %xmm0
+;;       movl    $0, %eax
+;;       movq    0x60(%r14), %rcx
+;;       addq    %rax, %rcx
+;;       movsd   %xmm0, (%rcx)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   49: ud2
+;;   4b: addb    %al, (%rax)
+;;   4d: addb    %al, (%rax)
+;;   4f: addb    %al, (%rax)
+;;   51: addb    %al, (%rax)
+;;   53: addb    %al, (%rax)
+;;   55: addb    %dh, %ah
diff --git a/tests/disas/winch/x64/store/i32.wat b/tests/disas/winch/x64/store/i32.wat
new file mode 100644
index 000000000000..24c776709d19
--- /dev/null
+++ b/tests/disas/winch/x64/store/i32.wat
@@ -0,0 +1,30 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (memory 1)
+
+  (func (export "as-block-value")
+    (block (i32.store (i32.const 0) (i32.const 1)))
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x44
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $1, %eax
+;;       movl    $0, %ecx
+;;       movq    0x60(%r14), %rdx
+;;       addq    %rcx, %rdx
+;;       movl    %eax, (%rdx)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   44: ud2
diff --git a/tests/disas/winch/x64/store/i64.wat b/tests/disas/winch/x64/store/i64.wat
new file mode 100644
index 000000000000..0a4c451dc694
--- /dev/null
+++ b/tests/disas/winch/x64/store/i64.wat
@@ -0,0 +1,27 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (memory 1)
+  (func (export "as-store-both") (result i32)
+    (block (result i32)
+      (i64.store (br 0 (i32.const 32))) (i32.const -1)
+    )
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x36
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $0x20, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   36: ud2
diff --git a/tests/disas/winch/x64/store/oob.wat b/tests/disas/winch/x64/store/oob.wat
new file mode 100644
index 000000000000..4cb68e0d811a
--- /dev/null
+++ b/tests/disas/winch/x64/store/oob.wat
@@ -0,0 +1,48 @@
+;;! target = "x86_64"
+;;! test = "winch"
+;;! flags = " -O static-memory-maximum-size=0"
+(module
+  (memory 1)
+  (func (export "foo") (param $i i32)
+    i32.const 0
+    (local.get $i)
+    i32.store8 offset=4294967295
+  )
+)
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x85
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       movl    $0, %ecx
+;;       movq    0x68(%r14), %rdx
+;;       movl    %ecx, %ebx
+;;       movabsq $0x100000000, %r11
+;;       addq    %r11, %rbx
+;;       jb      0x87
+;;   52: cmpq    %rdx, %rbx
+;;       ja      0x89
+;;   5b: movq    0x60(%r14), %rsi
+;;       addq    %rcx, %rsi
+;;       movabsq $0xffffffff, %r11
+;;       addq    %r11, %rsi
+;;       movq    $0, %rdi
+;;       cmpq    %rdx, %rbx
+;;       cmovaq  %rdi, %rsi
+;;       movb    %al, (%rsi)
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   85: ud2
+;;   87: ud2
+;;   89: ud2
diff --git a/tests/disas/winch/x64/store/v128.wat b/tests/disas/winch/x64/store/v128.wat
new file mode 100644
index 000000000000..8ca447b28e12
--- /dev/null
+++ b/tests/disas/winch/x64/store/v128.wat
@@ -0,0 +1,38 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (memory (data "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\f4\7f"))
+  (func (export "v128.store") (v128.store (i32.const 0) (v128.const i64x2 1 2)))
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x49
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movdqu  0x1d(%rip), %xmm0
+;;       movl    $0, %eax
+;;       movq    0x60(%r14), %rcx
+;;       addq    %rax, %rcx
+;;       movdqu  %xmm0, (%rcx)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   49: ud2
+;;   4b: addb    %al, (%rax)
+;;   4d: addb    %al, (%rax)
+;;   4f: addb    %al, (%rcx)
+;;   51: addb    %al, (%rax)
+;;   53: addb    %al, (%rax)
+;;   55: addb    %al, (%rax)
+;;   57: addb    %al, (%rdx)
+;;   59: addb    %al, (%rax)
+;;   5b: addb    %al, (%rax)
+;;   5d: addb    %al, (%rax)
diff --git a/tests/disas/winch/x64/table/fill.wat b/tests/disas/winch/x64/table/fill.wat
new file mode 100644
index 000000000000..65ccb3e59b89
--- /dev/null
+++ b/tests/disas/winch/x64/table/fill.wat
@@ -0,0 +1,143 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (type $t0 (func))
+  (func $f1 (type $t0))
+  (func $f2 (type $t0))
+  (func $f3 (type $t0))
+
+  ;; Define two tables of funcref
+  (table $t1 3 funcref)
+  (table $t2 10 funcref)
+
+  ;; Initialize table $t1 with functions $f1, $f2, $f3
+  (elem (i32.const 0) $f1 $f2 $f3)
+
+  ;; Function to fill table $t1 using a function reference from table $t2
+  (func (export "fill") (param $i i32) (param $r i32) (param $n i32)
+    (local $ref funcref)
+    (local.set $ref (table.get $t1 (local.get $r)))
+    (table.fill $t2 (local.get $i) (local.get $ref) (local.get $n))
+  )
+)
+;; wasm[0]::function[0]::f1:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]::f2:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x71
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   71: ud2
+;;
+;; wasm[0]::function[2]::f3:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0xb1
+;;   9b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   b1: ud2
+;;
+;; wasm[0]::function[3]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x40, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x1d0
+;;   db: movq    %rdi, %r14
+;;       subq    $0x30, %rsp
+;;       movq    %rdi, 0x28(%rsp)
+;;       movq    %rsi, 0x20(%rsp)
+;;       movl    %edx, 0x1c(%rsp)
+;;       movl    %ecx, 0x18(%rsp)
+;;       movl    %r8d, 0x14(%rsp)
+;;       movl    $0, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    0x18(%rsp), %r11d
+;;       subq    $4, %rsp
+;;       movl    %r11d, (%rsp)
+;;       movl    (%rsp), %ecx
+;;       addq    $4, %rsp
+;;       movq    %r14, %rdx
+;;       movl    0x60(%rdx), %ebx
+;;       cmpl    %ebx, %ecx
+;;       jae     0x1d2
+;;  12c: movl    %ecx, %r11d
+;;       imulq   $8, %r11, %r11
+;;       movq    0x58(%rdx), %rdx
+;;       movq    %rdx, %rsi
+;;       addq    %r11, %rdx
+;;       cmpl    %ebx, %ecx
+;;       cmovaeq %rsi, %rdx
+;;       movq    (%rdx), %rax
+;;       testq   %rax, %rax
+;;       jne     0x17d
+;;  14f: subq    $4, %rsp
+;;       movl    %ecx, (%rsp)
+;;       subq    $0xc, %rsp
+;;       movq    %r14, %rdi
+;;       movl    $0, %esi
+;;       movl    0xc(%rsp), %edx
+;;       callq   0x4c1
+;;       addq    $0xc, %rsp
+;;       addq    $4, %rsp
+;;       movq    0x28(%rsp), %r14
+;;       jmp     0x181
+;;  17d: andq    $0xfffffffffffffffe, %rax
+;;       movq    %rax, 0xc(%rsp)
+;;       movl    0x1c(%rsp), %r11d
+;;       subq    $4, %rsp
+;;       movl    %r11d, (%rsp)
+;;       movq    0x10(%rsp), %r11
+;;       pushq   %r11
+;;       movl    0x20(%rsp), %r11d
+;;       subq    $4, %rsp
+;;       movl    %r11d, (%rsp)
+;;       movq    %r14, %rdi
+;;       movl    $1, %esi
+;;       movl    0xc(%rsp), %edx
+;;       movq    4(%rsp), %rcx
+;;       movl    (%rsp), %r8d
+;;       callq   0x503
+;;       addq    $0x10, %rsp
+;;       movq    0x28(%rsp), %r14
+;;       addq    $0x30, %rsp
+;;       popq    %rbp
+;;       retq
+;;  1d0: ud2
+;;  1d2: ud2
diff --git a/tests/disas/winch/x64/table/get.wat b/tests/disas/winch/x64/table/get.wat
new file mode 100644
index 000000000000..6639318329e4
--- /dev/null
+++ b/tests/disas/winch/x64/table/get.wat
@@ -0,0 +1,78 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (table $t3 3 funcref)
+  (elem (table $t3) (i32.const 1) func $dummy)
+  (func $dummy)
+  (func $f3 (export "get-funcref") (param $i i32) (result funcref)
+    (table.get $t3 (local.get $i))
+  )
+)
+
+
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]::f3:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x30, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0xed
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %r11d
+;;       subq    $4, %rsp
+;;       movl    %r11d, (%rsp)
+;;       movl    (%rsp), %ecx
+;;       addq    $4, %rsp
+;;       movq    %r14, %rdx
+;;       movl    0x60(%rdx), %ebx
+;;       cmpl    %ebx, %ecx
+;;       jae     0xef
+;;   92: movl    %ecx, %r11d
+;;       imulq   $8, %r11, %r11
+;;       movq    0x58(%rdx), %rdx
+;;       movq    %rdx, %rsi
+;;       addq    %r11, %rdx
+;;       cmpl    %ebx, %ecx
+;;       cmovaeq %rsi, %rdx
+;;       movq    (%rdx), %rax
+;;       testq   %rax, %rax
+;;       jne     0xe3
+;;   b5: subq    $4, %rsp
+;;       movl    %ecx, (%rsp)
+;;       subq    $0xc, %rsp
+;;       movq    %r14, %rdi
+;;       movl    $0, %esi
+;;       movl    0xc(%rsp), %edx
+;;       callq   0x2da
+;;       addq    $0xc, %rsp
+;;       addq    $4, %rsp
+;;       movq    0x18(%rsp), %r14
+;;       jmp     0xe7
+;;   e3: andq    $0xfffffffffffffffe, %rax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   ed: ud2
+;;   ef: ud2
diff --git a/tests/disas/winch/x64/table/grow.wat b/tests/disas/winch/x64/table/grow.wat
new file mode 100644
index 000000000000..c91fc1ce3daf
--- /dev/null
+++ b/tests/disas/winch/x64/table/grow.wat
@@ -0,0 +1,40 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (table $t1 0 funcref)
+
+  (func (export "grow-by-10") (param $r funcref) (result i32)
+    (table.grow $t1 (local.get $r) (i32.const 10))
+  )
+)
+
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x30, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x66
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movq    8(%rsp), %r11
+;;       pushq   %r11
+;;       subq    $8, %rsp
+;;       movq    %r14, %rdi
+;;       movl    $0, %esi
+;;       movl    $0xa, %edx
+;;       movq    8(%rsp), %rcx
+;;       callq   0x170
+;;       addq    $8, %rsp
+;;       addq    $8, %rsp
+;;       movq    0x18(%rsp), %r14
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   66: ud2
diff --git a/tests/disas/winch/x64/table/init_copy_drop.wat b/tests/disas/winch/x64/table/init_copy_drop.wat
new file mode 100644
index 000000000000..25183063e34d
--- /dev/null
+++ b/tests/disas/winch/x64/table/init_copy_drop.wat
@@ -0,0 +1,273 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (type (func (result i32)))  ;; type #0
+  (import "a" "ef0" (func (result i32)))    ;; index 0
+  (import "a" "ef1" (func (result i32)))
+  (import "a" "ef2" (func (result i32)))
+  (import "a" "ef3" (func (result i32)))
+  (import "a" "ef4" (func (result i32)))    ;; index 4
+  (table $t0 30 30 funcref)
+  (table $t1 30 30 funcref)
+  (elem (table $t0) (i32.const 2) func 3 1 4 1)
+  (elem funcref
+    (ref.func 2) (ref.func 7) (ref.func 1) (ref.func 8))
+  (elem (table $t0) (i32.const 12) func 7 5 2 3 6)
+  (elem funcref
+    (ref.func 5) (ref.func 9) (ref.func 2) (ref.func 7) (ref.func 6))
+  (func (result i32) (i32.const 5))  ;; index 5
+  (func (result i32) (i32.const 6))
+  (func (result i32) (i32.const 7))
+  (func (result i32) (i32.const 8))
+  (func (result i32) (i32.const 9))  ;; index 9
+  (func (export "test")
+    (table.init $t0 1 (i32.const 7) (i32.const 0) (i32.const 4))
+         (elem.drop 1)
+         (table.init $t0 3 (i32.const 15) (i32.const 1) (i32.const 3))
+         (elem.drop 3)
+         (table.copy $t0 0 (i32.const 20) (i32.const 15) (i32.const 5))
+         (table.copy $t0 0 (i32.const 21) (i32.const 29) (i32.const 1))
+         (table.copy $t0 0 (i32.const 24) (i32.const 10) (i32.const 1))
+         (table.copy $t0 0 (i32.const 13) (i32.const 11) (i32.const 4))
+         (table.copy $t0 0 (i32.const 19) (i32.const 20) (i32.const 5)))
+  (func (export "check") (param i32) (result i32)
+    (call_indirect $t0 (type 0) (local.get 0)))
+)
+;; wasm[0]::function[5]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x36
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $5, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   36: ud2
+;;
+;; wasm[0]::function[6]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x76
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $6, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   76: ud2
+;;
+;; wasm[0]::function[7]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0xb6
+;;   9b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $7, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   b6: ud2
+;;
+;; wasm[0]::function[8]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0xf6
+;;   db: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $8, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   f6: ud2
+;;
+;; wasm[0]::function[9]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x136
+;;  11b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movl    $9, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;  136: ud2
+;;
+;; wasm[0]::function[10]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x2ad
+;;  15b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movl    $0, %esi
+;;       movl    $1, %edx
+;;       movl    $7, %ecx
+;;       movl    $0, %r8d
+;;       movl    $4, %r9d
+;;       callq   0x8cd
+;;       movq    8(%rsp), %r14
+;;       movq    %r14, %rdi
+;;       movl    $1, %esi
+;;       callq   0x916
+;;       movq    8(%rsp), %r14
+;;       movq    %r14, %rdi
+;;       movl    $0, %esi
+;;       movl    $3, %edx
+;;       movl    $0xf, %ecx
+;;       movl    $1, %r8d
+;;       movl    $3, %r9d
+;;       callq   0x8cd
+;;       movq    8(%rsp), %r14
+;;       movq    %r14, %rdi
+;;       movl    $3, %esi
+;;       callq   0x916
+;;       movq    8(%rsp), %r14
+;;       movq    %r14, %rdi
+;;       movl    $0, %esi
+;;       movl    $0, %edx
+;;       movl    $0x14, %ecx
+;;       movl    $0xf, %r8d
+;;       movl    $5, %r9d
+;;       callq   0x955
+;;       movq    8(%rsp), %r14
+;;       movq    %r14, %rdi
+;;       movl    $0, %esi
+;;       movl    $0, %edx
+;;       movl    $0x15, %ecx
+;;       movl    $0x1d, %r8d
+;;       movl    $1, %r9d
+;;       callq   0x955
+;;       movq    8(%rsp), %r14
+;;       movq    %r14, %rdi
+;;       movl    $0, %esi
+;;       movl    $0, %edx
+;;       movl    $0x18, %ecx
+;;       movl    $0xa, %r8d
+;;       movl    $1, %r9d
+;;       callq   0x955
+;;       movq    8(%rsp), %r14
+;;       movq    %r14, %rdi
+;;       movl    $0, %esi
+;;       movl    $0, %edx
+;;       movl    $0xd, %ecx
+;;       movl    $0xb, %r8d
+;;       movl    $4, %r9d
+;;       callq   0x955
+;;       movq    8(%rsp), %r14
+;;       movq    %r14, %rdi
+;;       movl    $0, %esi
+;;       movl    $0, %edx
+;;       movl    $0x13, %ecx
+;;       movl    $0x14, %r8d
+;;       movl    $5, %r9d
+;;       callq   0x955
+;;       movq    8(%rsp), %r14
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;  2ad: ud2
+;;
+;; wasm[0]::function[11]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x30, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x395
+;;  2cb: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    0xc(%rsp), %r11d
+;;       subq    $4, %rsp
+;;       movl    %r11d, (%rsp)
+;;       movl    (%rsp), %ecx
+;;       addq    $4, %rsp
+;;       movq    %r14, %rdx
+;;       movl    0xd8(%rdx), %ebx
+;;       cmpl    %ebx, %ecx
+;;       jae     0x397
+;;  305: movl    %ecx, %r11d
+;;       imulq   $8, %r11, %r11
+;;       movq    0xd0(%rdx), %rdx
+;;       movq    %rdx, %rsi
+;;       addq    %r11, %rdx
+;;       cmpl    %ebx, %ecx
+;;       cmovaeq %rsi, %rdx
+;;       movq    (%rdx), %rax
+;;       testq   %rax, %rax
+;;       jne     0x359
+;;  32b: subq    $4, %rsp
+;;       movl    %ecx, (%rsp)
+;;       subq    $0xc, %rsp
+;;       movq    %r14, %rdi
+;;       movl    $0, %esi
+;;       movl    0xc(%rsp), %edx
+;;       callq   0x99e
+;;       addq    $0xc, %rsp
+;;       addq    $4, %rsp
+;;       movq    0x18(%rsp), %r14
+;;       jmp     0x35d
+;;  359: andq    $0xfffffffffffffffe, %rax
+;;       testq   %rax, %rax
+;;       je      0x399
+;;  366: movq    0x50(%r14), %r11
+;;       movl    (%r11), %ecx
+;;       movl    0x10(%rax), %edx
+;;       cmpl    %edx, %ecx
+;;       jne     0x39b
+;;  378: pushq   %rax
+;;       popq    %rcx
+;;       movq    0x18(%rcx), %rbx
+;;       movq    8(%rcx), %rdx
+;;       movq    %rbx, %rdi
+;;       movq    %r14, %rsi
+;;       callq   *%rdx
+;;       movq    0x18(%rsp), %r14
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;  395: ud2
+;;  397: ud2
+;;  399: ud2
+;;  39b: ud2
diff --git a/tests/disas/winch/x64/table/set.wat b/tests/disas/winch/x64/table/set.wat
new file mode 100644
index 000000000000..9c61a637a365
--- /dev/null
+++ b/tests/disas/winch/x64/table/set.wat
@@ -0,0 +1,138 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+
+(module
+  (table $t3 2 funcref)
+  (elem (table $t3) (i32.const 1) func $dummy)
+  (func $dummy)
+
+  (func (export "set-funcref") (param $i i32) (param $r funcref)
+    (table.set $t3 (local.get $i) (local.get $r))
+  )
+  (func (export "set-funcref-from") (param $i i32) (param $j i32)
+    (table.set $t3 (local.get $i) (table.get $t3 (local.get $j)))
+  )
+)
+
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0xae
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movq    %rcx, (%rsp)
+;;       movq    (%rsp), %rax
+;;       movl    0xc(%rsp), %ecx
+;;       movq    %r14, %rdx
+;;       movl    0x60(%rdx), %ebx
+;;       cmpl    %ebx, %ecx
+;;       jae     0xb0
+;;   8a: movl    %ecx, %r11d
+;;       imulq   $8, %r11, %r11
+;;       movq    0x58(%rdx), %rdx
+;;       movq    %rdx, %rsi
+;;       addq    %r11, %rdx
+;;       cmpl    %ebx, %ecx
+;;       cmovaeq %rsi, %rdx
+;;       orq     $1, %rax
+;;       movq    %rax, (%rdx)
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   ae: ud2
+;;   b0: ud2
+;;
+;; wasm[0]::function[2]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x30, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x1b1
+;;   db: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    0xc(%rsp), %r11d
+;;       subq    $4, %rsp
+;;       movl    %r11d, (%rsp)
+;;       movl    0xc(%rsp), %r11d
+;;       subq    $4, %rsp
+;;       movl    %r11d, (%rsp)
+;;       movl    (%rsp), %ecx
+;;       addq    $4, %rsp
+;;       movq    %r14, %rdx
+;;       movl    0x60(%rdx), %ebx
+;;       cmpl    %ebx, %ecx
+;;       jae     0x1b3
+;;  123: movl    %ecx, %r11d
+;;       imulq   $8, %r11, %r11
+;;       movq    0x58(%rdx), %rdx
+;;       movq    %rdx, %rsi
+;;       addq    %r11, %rdx
+;;       cmpl    %ebx, %ecx
+;;       cmovaeq %rsi, %rdx
+;;       movq    (%rdx), %rax
+;;       testq   %rax, %rax
+;;       jne     0x174
+;;  146: subq    $4, %rsp
+;;       movl    %ecx, (%rsp)
+;;       subq    $8, %rsp
+;;       movq    %r14, %rdi
+;;       movl    $0, %esi
+;;       movl    8(%rsp), %edx
+;;       callq   0x496
+;;       addq    $8, %rsp
+;;       addq    $4, %rsp
+;;       movq    0x1c(%rsp), %r14
+;;       jmp     0x178
+;;  174: andq    $0xfffffffffffffffe, %rax
+;;       movl    (%rsp), %ecx
+;;       addq    $4, %rsp
+;;       movq    %r14, %rdx
+;;       movl    0x60(%rdx), %ebx
+;;       cmpl    %ebx, %ecx
+;;       jae     0x1b5
+;;  18d: movl    %ecx, %r11d
+;;       imulq   $8, %r11, %r11
+;;       movq    0x58(%rdx), %rdx
+;;       movq    %rdx, %rsi
+;;       addq    %r11, %rdx
+;;       cmpl    %ebx, %ecx
+;;       cmovaeq %rsi, %rdx
+;;       orq     $1, %rax
+;;       movq    %rax, (%rdx)
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;  1b1: ud2
+;;  1b3: ud2
+;;  1b5: ud2
diff --git a/tests/disas/winch/x64/table/size.wat b/tests/disas/winch/x64/table/size.wat
new file mode 100644
index 000000000000..212ee6ce1144
--- /dev/null
+++ b/tests/disas/winch/x64/table/size.wat
@@ -0,0 +1,25 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (table $t1 0 funcref)
+  (func (export "size") (result i32)
+    (table.size $t1))
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x38
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %r11
+;;       movl    0x60(%r11), %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   38: ud2
diff --git a/tests/disas/winch/x64/unreachable/as_block_broke.wat b/tests/disas/winch/x64/unreachable/as_block_broke.wat
new file mode 100644
index 000000000000..39b70350438e
--- /dev/null
+++ b/tests/disas/winch/x64/unreachable/as_block_broke.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func $dummy)
+  (func (export "as-block-broke") (result i32)
+    (block (result i32) (call $dummy) (br 0 (i32.const 1)) (unreachable))
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x86
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       movl    $1, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   86: ud2
diff --git a/tests/disas/winch/x64/unreachable/as_block_first.wat b/tests/disas/winch/x64/unreachable/as_block_first.wat
new file mode 100644
index 000000000000..97a232f99e53
--- /dev/null
+++ b/tests/disas/winch/x64/unreachable/as_block_first.wat
@@ -0,0 +1,24 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func (export "as-block-first") (result i32)
+    (block (result i32) (unreachable) (i32.const 2))
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x33
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       ud2
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   33: ud2
diff --git a/tests/disas/winch/x64/unreachable/as_block_last.wat b/tests/disas/winch/x64/unreachable/as_block_last.wat
new file mode 100644
index 000000000000..ab32d0e0f0ac
--- /dev/null
+++ b/tests/disas/winch/x64/unreachable/as_block_last.wat
@@ -0,0 +1,46 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "as-block-last")
+    (block (nop) (call $dummy) (unreachable))
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x83
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       ud2
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   83: ud2
diff --git a/tests/disas/winch/x64/unreachable/as_block_mid.wat b/tests/disas/winch/x64/unreachable/as_block_mid.wat
new file mode 100644
index 000000000000..501df3a27dc5
--- /dev/null
+++ b/tests/disas/winch/x64/unreachable/as_block_mid.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module 
+  (func $dummy)
+  (func (export "as-block-mid") (result i32)
+    (block (result i32) (call $dummy) (unreachable) (i32.const 2))
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x83
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       ud2
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   83: ud2
diff --git a/tests/disas/winch/x64/unreachable/as_block_value.wat b/tests/disas/winch/x64/unreachable/as_block_value.wat
new file mode 100644
index 000000000000..cf5f8e2a44fb
--- /dev/null
+++ b/tests/disas/winch/x64/unreachable/as_block_value.wat
@@ -0,0 +1,46 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "as-block-value") (result i32)
+    (block (result i32) (nop) (call $dummy) (unreachable))
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x83
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       ud2
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   83: ud2
diff --git a/tests/disas/winch/x64/unreachable/as_br_if_cond.wat b/tests/disas/winch/x64/unreachable/as_br_if_cond.wat
new file mode 100644
index 000000000000..cf082023e127
--- /dev/null
+++ b/tests/disas/winch/x64/unreachable/as_br_if_cond.wat
@@ -0,0 +1,25 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (export "as-br_if-cond")
+    (block (br_if 0 (unreachable)))
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x33
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       ud2
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   33: ud2
diff --git a/tests/disas/winch/x64/unreachable/as_br_value.wat b/tests/disas/winch/x64/unreachable/as_br_value.wat
new file mode 100644
index 000000000000..2986585b777c
--- /dev/null
+++ b/tests/disas/winch/x64/unreachable/as_br_value.wat
@@ -0,0 +1,25 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (unreachable)))
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x33
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       ud2
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   33: ud2
diff --git a/tests/disas/winch/x64/unreachable/as_call_first.wat b/tests/disas/winch/x64/unreachable/as_call_first.wat
new file mode 100644
index 000000000000..b878ceb5a4af
--- /dev/null
+++ b/tests/disas/winch/x64/unreachable/as_call_first.wat
@@ -0,0 +1,46 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func $dummy3 (param i32 i32 i32))
+  (func (export "as-call-first")
+    (call $dummy3 (unreachable) (i32.const 2) (i32.const 3))
+  )
+)
+;; wasm[0]::function[0]::dummy3:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    %r8d, 4(%rsp)
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3f: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x83
+;;   6b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       ud2
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   83: ud2
diff --git a/tests/disas/winch/x64/unreachable/as_call_last.wat b/tests/disas/winch/x64/unreachable/as_call_last.wat
new file mode 100644
index 000000000000..5f43280618b5
--- /dev/null
+++ b/tests/disas/winch/x64/unreachable/as_call_last.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+
+(module
+  (func $dummy3 (param i32 i32 i32))
+  (func (export "as-call-last")
+    (call $dummy3 (i32.const 1) (i32.const 2) (unreachable))
+  )
+)
+;; wasm[0]::function[0]::dummy3:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    %r8d, 4(%rsp)
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3f: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x83
+;;   6b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       ud2
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   83: ud2
diff --git a/tests/disas/winch/x64/unreachable/as_call_mid.wat b/tests/disas/winch/x64/unreachable/as_call_mid.wat
new file mode 100644
index 000000000000..b6b2fc3934ba
--- /dev/null
+++ b/tests/disas/winch/x64/unreachable/as_call_mid.wat
@@ -0,0 +1,46 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func $dummy3 (param i32 i32 i32))
+  (func (export "as-call-mid")
+    (call $dummy3 (i32.const 1) (unreachable) (i32.const 3))
+  )
+)
+;; wasm[0]::function[0]::dummy3:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3f
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    %r8d, 4(%rsp)
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3f: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x83
+;;   6b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       ud2
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   83: ud2
diff --git a/tests/disas/winch/x64/unreachable/as_func_first.wat b/tests/disas/winch/x64/unreachable/as_func_first.wat
new file mode 100644
index 000000000000..c36754b7d199
--- /dev/null
+++ b/tests/disas/winch/x64/unreachable/as_func_first.wat
@@ -0,0 +1,42 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "as-func-first") (result i32)
+    (unreachable) (i32.const -1)
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x73
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       ud2
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   73: ud2
diff --git a/tests/disas/winch/x64/unreachable/as_func_last.wat b/tests/disas/winch/x64/unreachable/as_func_last.wat
new file mode 100644
index 000000000000..88ad788e070a
--- /dev/null
+++ b/tests/disas/winch/x64/unreachable/as_func_last.wat
@@ -0,0 +1,46 @@
+;;! target = "x86_64"
+;;! test = "winch"
+(module
+  (func $dummy)
+  (func (export "as-func-last")
+    (call $dummy) (unreachable)
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x83
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       ud2
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   83: ud2
diff --git a/tests/disas/winch/x64/unreachable/as_func_mid.wat b/tests/disas/winch/x64/unreachable/as_func_mid.wat
new file mode 100644
index 000000000000..9173c23d4408
--- /dev/null
+++ b/tests/disas/winch/x64/unreachable/as_func_mid.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func $dummy)
+  (func (export "as-func-mid") (result i32)
+    (call $dummy) (unreachable) (i32.const -1)
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x83
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       ud2
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   83: ud2
diff --git a/tests/disas/winch/x64/unreachable/as_func_value.wat b/tests/disas/winch/x64/unreachable/as_func_value.wat
new file mode 100644
index 000000000000..23b75ad14c94
--- /dev/null
+++ b/tests/disas/winch/x64/unreachable/as_func_value.wat
@@ -0,0 +1,47 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func $dummy)
+  (func (export "as-func-value") (result i32)
+    (call $dummy) (unreachable)
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x83
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       ud2
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   83: ud2
diff --git a/tests/disas/winch/x64/unreachable/as_if_cond.wat b/tests/disas/winch/x64/unreachable/as_if_cond.wat
new file mode 100644
index 000000000000..897dc101dadd
--- /dev/null
+++ b/tests/disas/winch/x64/unreachable/as_if_cond.wat
@@ -0,0 +1,25 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (export "as-if-cond") (result i32)
+    (if (result i32) (unreachable) (then (i32.const 0)) (else (i32.const 1)))
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x33
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       ud2
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   33: ud2
diff --git a/tests/disas/winch/x64/unreachable/as_if_else.wat b/tests/disas/winch/x64/unreachable/as_if_else.wat
new file mode 100644
index 000000000000..96ebfdd58d6c
--- /dev/null
+++ b/tests/disas/winch/x64/unreachable/as_if_else.wat
@@ -0,0 +1,33 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+
+(module
+  (func (export "as-if-else") (param i32 i32) (result i32)
+    (if (result i32) (local.get 0) (then (local.get 1)) (else (unreachable)))
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x51
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       testl   %eax, %eax
+;;       je      0x49
+;;   40: movl    8(%rsp), %eax
+;;       jmp     0x4b
+;;   49: ud2
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   51: ud2
diff --git a/tests/disas/winch/x64/unreachable/as_if_then.wat b/tests/disas/winch/x64/unreachable/as_if_then.wat
new file mode 100644
index 000000000000..6f29baef305a
--- /dev/null
+++ b/tests/disas/winch/x64/unreachable/as_if_then.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (export "as-if-then") (param i32 i32) (result i32)
+    (if (result i32) (local.get 0) (then (unreachable)) (else (local.get 1)))
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       testl   %eax, %eax
+;;       je      0x42
+;;   40: ud2
+;;       movl    8(%rsp), %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4c: ud2
diff --git a/tests/disas/winch/x64/unreachable/as_if_then_no_else.wat b/tests/disas/winch/x64/unreachable/as_if_then_no_else.wat
new file mode 100644
index 000000000000..93f47a70b134
--- /dev/null
+++ b/tests/disas/winch/x64/unreachable/as_if_then_no_else.wat
@@ -0,0 +1,31 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (export "as-if-then-no-else") (param i32 i32) (result i32)
+    (if (local.get 0) (then (unreachable))) (local.get 1)
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movl    %edx, 0xc(%rsp)
+;;       movl    %ecx, 8(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       testl   %eax, %eax
+;;       je      0x42
+;;   40: ud2
+;;       movl    8(%rsp), %eax
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4c: ud2
diff --git a/tests/disas/winch/x64/unreachable/as_loop_broke.wat b/tests/disas/winch/x64/unreachable/as_loop_broke.wat
new file mode 100644
index 000000000000..3d54604955bb
--- /dev/null
+++ b/tests/disas/winch/x64/unreachable/as_loop_broke.wat
@@ -0,0 +1,49 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func $dummy)
+  (func (export "as-loop-broke") (result i32)
+    (block (result i32)
+      (loop (result i32) (call $dummy) (br 1 (i32.const 1)) (unreachable))
+    )
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x86
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       movl    $1, %eax
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   86: ud2
diff --git a/tests/disas/winch/x64/unreachable/as_loop_first.wat b/tests/disas/winch/x64/unreachable/as_loop_first.wat
new file mode 100644
index 000000000000..f68f83d26d61
--- /dev/null
+++ b/tests/disas/winch/x64/unreachable/as_loop_first.wat
@@ -0,0 +1,26 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+
+(module
+  (func (export "as-loop-first") (result i32)
+    (loop (result i32) (unreachable) (i32.const 2))
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x33
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       ud2
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   33: ud2
diff --git a/tests/disas/winch/x64/unreachable/as_loop_last.wat b/tests/disas/winch/x64/unreachable/as_loop_last.wat
new file mode 100644
index 000000000000..e265bcd52ab4
--- /dev/null
+++ b/tests/disas/winch/x64/unreachable/as_loop_last.wat
@@ -0,0 +1,48 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+
+(module
+  (func $dummy)
+  (func (export "as-loop-last")
+    (loop (nop) (call $dummy) (unreachable))
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x83
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       ud2
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   83: ud2
diff --git a/tests/disas/winch/x64/unreachable/as_loop_mid.wat b/tests/disas/winch/x64/unreachable/as_loop_mid.wat
new file mode 100644
index 000000000000..77624e2a3c9f
--- /dev/null
+++ b/tests/disas/winch/x64/unreachable/as_loop_mid.wat
@@ -0,0 +1,48 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+
+(module
+  (func $dummy)
+  (func (export "as-loop-mid") (result i32)
+    (loop (result i32) (call $dummy) (unreachable) (i32.const 2))
+  )
+)
+;; wasm[0]::function[0]::dummy:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x31
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   31: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x83
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       ud2
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   83: ud2
diff --git a/tests/disas/winch/x64/unreachable/as_return_value.wat b/tests/disas/winch/x64/unreachable/as_return_value.wat
new file mode 100644
index 000000000000..053bae613392
--- /dev/null
+++ b/tests/disas/winch/x64/unreachable/as_return_value.wat
@@ -0,0 +1,25 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (export "as-return-value") (result i64)
+    (return (unreachable))
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x33
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       ud2
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   33: ud2
diff --git a/tests/disas/winch/x64/unreachable/type_i32.wat b/tests/disas/winch/x64/unreachable/type_i32.wat
new file mode 100644
index 000000000000..43b87fdf6159
--- /dev/null
+++ b/tests/disas/winch/x64/unreachable/type_i32.wat
@@ -0,0 +1,23 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (export "type-i32") (result i32) (unreachable))
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x33
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       ud2
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   33: ud2
diff --git a/tests/disas/winch/x64/unreachable/type_i64.wat b/tests/disas/winch/x64/unreachable/type_i64.wat
new file mode 100644
index 000000000000..89c951e1483d
--- /dev/null
+++ b/tests/disas/winch/x64/unreachable/type_i64.wat
@@ -0,0 +1,23 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (export "type-i64") (result i32) (unreachable))
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x33
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       ud2
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   33: ud2
diff --git a/tests/disas/winch/x64/unreachable/with_spilled_local.wat b/tests/disas/winch/x64/unreachable/with_spilled_local.wat
new file mode 100644
index 000000000000..378bb6870299
--- /dev/null
+++ b/tests/disas/winch/x64/unreachable/with_spilled_local.wat
@@ -0,0 +1,33 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (export "")
+    (local i32)
+    local.get 0
+    block
+    end
+    unreachable
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x24, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4a
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    0xc(%rsp), %r11d
+;;       subq    $4, %rsp
+;;       movl    %r11d, (%rsp)
+;;       ud2
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4a: ud2
diff --git a/tests/disas/winch/x64/unreachable/with_spilled_local_in_if.wat b/tests/disas/winch/x64/unreachable/with_spilled_local_in_if.wat
new file mode 100644
index 000000000000..16df9579292b
--- /dev/null
+++ b/tests/disas/winch/x64/unreachable/with_spilled_local_in_if.wat
@@ -0,0 +1,41 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (export "")
+    (local i32)
+    local.get 0
+    if
+      local.get 0
+      block
+      end
+      unreachable
+    else
+      nop
+    end
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x24, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x56
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    $0, 8(%rsp)
+;;       movl    0xc(%rsp), %eax
+;;       testl   %eax, %eax
+;;       je      0x50
+;;   41: movl    0xc(%rsp), %r11d
+;;       subq    $4, %rsp
+;;       movl    %r11d, (%rsp)
+;;       ud2
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   56: ud2
diff --git a/tests/disas/winch/x64/v128_const/call_id.wat b/tests/disas/winch/x64/v128_const/call_id.wat
new file mode 100644
index 000000000000..e0ecf57f2b08
--- /dev/null
+++ b/tests/disas/winch/x64/v128_const/call_id.wat
@@ -0,0 +1,60 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func $id-v128 (param v128) (result v128) (local.get 0))
+  (func (export "a")
+    (call $id-v128 (v128.const i64x2 1 2))
+    drop
+  )
+)
+;; wasm[0]::function[0]::id-v128:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movdqu  %xmm0, (%rsp)
+;;       movdqu  (%rsp), %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x10, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x89
+;;   5b: movq    %rdi, %r14
+;;       subq    $0x10, %rsp
+;;       movq    %rdi, 8(%rsp)
+;;       movq    %rsi, (%rsp)
+;;       movq    %r14, %rdi
+;;       movq    %r14, %rsi
+;;       movdqu  0x17(%rip), %xmm0
+;;       callq   0
+;;       movq    8(%rsp), %r14
+;;       addq    $0x10, %rsp
+;;       popq    %rbp
+;;       retq
+;;   89: ud2
+;;   8b: addb    %al, (%rax)
+;;   8d: addb    %al, (%rax)
+;;   8f: addb    %al, (%rcx)
+;;   91: addb    %al, (%rax)
+;;   93: addb    %al, (%rax)
+;;   95: addb    %al, (%rax)
+;;   97: addb    %al, (%rdx)
+;;   99: addb    %al, (%rax)
+;;   9b: addb    %al, (%rax)
+;;   9d: addb    %al, (%rax)
diff --git a/tests/disas/winch/x64/v128_const/id.wat b/tests/disas/winch/x64/v128_const/id.wat
new file mode 100644
index 000000000000..c8af72a4df8b
--- /dev/null
+++ b/tests/disas/winch/x64/v128_const/id.wat
@@ -0,0 +1,24 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (param v128) (result v128) (local.get 0))
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x20, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x3c
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movdqu  %xmm0, (%rsp)
+;;       movdqu  (%rsp), %xmm0
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   3c: ud2
diff --git a/tests/disas/winch/x64/v128_const/multivalue.wat b/tests/disas/winch/x64/v128_const/multivalue.wat
new file mode 100644
index 000000000000..87c0d3649b84
--- /dev/null
+++ b/tests/disas/winch/x64/v128_const/multivalue.wat
@@ -0,0 +1,45 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (result v128 v128)
+    v128.const i64x2 0 0
+    v128.const i64x2 0 0
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x30, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x67
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movq    %rdx, 8(%rsp)
+;;       movdqu  0x37(%rip), %xmm0
+;;       subq    $0x10, %rsp
+;;       movdqu  0x2a(%rip), %xmm15
+;;       movdqu  %xmm15, 0x30(%rsp)
+;;       movq    0x18(%rsp), %rax
+;;       movdqu  (%rsp), %xmm15
+;;       addq    $0x10, %rsp
+;;       movdqu  %xmm15, (%rax)
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   67: ud2
+;;   69: addb    %al, (%rax)
+;;   6b: addb    %al, (%rax)
+;;   6d: addb    %al, (%rax)
+;;   6f: addb    %al, (%rax)
+;;   71: addb    %al, (%rax)
+;;   73: addb    %al, (%rax)
+;;   75: addb    %al, (%rax)
+;;   77: addb    %al, (%rax)
+;;   79: addb    %al, (%rax)
+;;   7b: addb    %al, (%rax)
+;;   7d: addb    %al, (%rax)
diff --git a/tests/disas/winch/x64/v128_const/spilled.wat b/tests/disas/winch/x64/v128_const/spilled.wat
new file mode 100644
index 000000000000..88a2e9f7c565
--- /dev/null
+++ b/tests/disas/winch/x64/v128_const/spilled.wat
@@ -0,0 +1,32 @@
+;;! target = "x86_64"
+;;! test = "winch"
+
+(module
+  (func (export "a") (param v128)
+    local.get 0
+    block
+    end
+    drop
+  )
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movq    8(%rdi), %r11
+;;       movq    (%r11), %r11
+;;       addq    $0x30, %r11
+;;       cmpq    %rsp, %r11
+;;       ja      0x4b
+;;   1b: movq    %rdi, %r14
+;;       subq    $0x20, %rsp
+;;       movq    %rdi, 0x18(%rsp)
+;;       movq    %rsi, 0x10(%rsp)
+;;       movdqu  %xmm0, (%rsp)
+;;       movdqu  (%rsp), %xmm15
+;;       subq    $0x10, %rsp
+;;       movdqu  %xmm15, (%rsp)
+;;       addq    $0x10, %rsp
+;;       addq    $0x20, %rsp
+;;       popq    %rbp
+;;       retq
+;;   4b: ud2
diff --git a/tests/disas/x64-bmi1.wat b/tests/disas/x64-bmi1.wat
new file mode 100644
index 000000000000..552d7c354d30
--- /dev/null
+++ b/tests/disas/x64-bmi1.wat
@@ -0,0 +1,126 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = "-Ccranelift-has-bmi1 -Ccranelift-has-avx"
+
+(module
+  (func (export "blsi32") (param i32) (result i32)
+    (i32.and
+      (local.get 0)
+      (i32.sub (i32.const 0) (local.get 0))))
+
+  (func (export "blsi64") (param i64) (result i64)
+    (i64.and
+      (local.get 0)
+      (i64.sub (i64.const 0) (local.get 0))))
+
+  (func (export "blsr32") (param i32) (result i32)
+    (i32.and
+      (local.get 0)
+      (i32.add (local.get 0) (i32.const -1))))
+
+  (func (export "blsr64") (param i64) (result i64)
+    (i64.and
+      (local.get 0)
+      (i64.sub (local.get 0) (i64.const 1))))
+
+  (func (export "blsmsk32") (param i32) (result i32)
+    (i32.xor
+      (local.get 0)
+      (i32.sub (local.get 0) (i32.const 1))))
+
+  (func (export "blsmsk64") (param i64) (result i64)
+    (i64.xor
+      (local.get 0)
+      (i64.add (local.get 0) (i64.const -1))))
+
+  (func (export "tzcnt32") (param i32) (result i32)
+    (i32.ctz (local.get 0)))
+
+  (func (export "tzcnt64") (param i64) (result i64)
+    (i64.ctz (local.get 0)))
+
+  (func (export "andn32") (param i32 i32) (result i32)
+    (i32.and (local.get 0) (i32.xor (local.get 1) (i32.const -1))))
+
+  (func (export "andn64") (param i64 i64) (result i64)
+    (i64.and (local.get 0) (i64.xor (local.get 1) (i64.const -1))))
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       blsil   %edx, %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       blsiq   %rdx, %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[2]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       blsrl   %edx, %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[3]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       blsrq   %rdx, %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[4]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       blsmskl %edx, %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[5]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       blsmskq %rdx, %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[6]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       tzcntl  %edx, %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[7]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       tzcntq  %rdx, %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[8]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       andnl   %edx, %ecx, %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[9]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       andnq   %rdx, %rcx, %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/x64-bmi2.wat b/tests/disas/x64-bmi2.wat
new file mode 100644
index 000000000000..39de99f04e91
--- /dev/null
+++ b/tests/disas/x64-bmi2.wat
@@ -0,0 +1,125 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = "-Ccranelift-has-bmi2 -Ccranelift-has-avx"
+
+(module
+  (func (export "bzhi32") (param i32 i32) (result i32)
+    (i32.and
+      (local.get 0)
+      (i32.sub
+        (i32.shl
+          (i32.const 1)
+          (local.get 1))
+        (i32.const 1))))
+
+  (func (export "bzhi64") (param i64 i64) (result i64)
+    (i64.and
+      (local.get 0)
+      (i64.add
+        (i64.shl
+          (i64.const 1)
+          (local.get 1))
+        (i64.const -1))))
+
+  (func (export "rorx32") (param i32) (result i32)
+    (i32.rotr (local.get 0) (i32.const 8)))
+
+  (func (export "rorx64") (param i64) (result i64)
+    (i64.rotl (local.get 0) (i64.const 9)))
+
+  (func (export "shlx32") (param i32 i32) (result i32)
+    (i32.shl (local.get 0) (local.get 1)))
+  (func (export "shlx64") (param i64 i64) (result i64)
+    (i64.shl (local.get 0) (local.get 1)))
+
+  (func (export "shrx32") (param i32 i32) (result i32)
+    (i32.shr_u (local.get 0) (local.get 1)))
+  (func (export "shrx64") (param i64 i64) (result i64)
+    (i64.shr_u (local.get 0) (local.get 1)))
+
+  (func (export "sarx32") (param i32 i32) (result i32)
+    (i32.shr_s (local.get 0) (local.get 1)))
+  (func (export "sarx64") (param i64 i64) (result i64)
+    (i64.shr_s (local.get 0) (local.get 1)))
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       andl    $0x1f, %ecx
+;;       bzhil   %ecx, %edx, %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       andq    $0x3f, %rcx
+;;       bzhiq   %rcx, %rdx, %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[2]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       rorxl   $8, %edx, %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[3]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       rorxq   $0x37, %rdx, %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[4]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       shlxl   %ecx, %edx, %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[5]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       shlxq   %rcx, %rdx, %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[6]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       shrxl   %ecx, %edx, %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[7]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       shrxq   %rcx, %rdx, %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[8]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       sarxl   %ecx, %edx, %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[9]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       sarxq   %rcx, %rdx, %rax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/x64-pmin.wat b/tests/disas/x64-pmin.wat
new file mode 100644
index 000000000000..4aa0431c3987
--- /dev/null
+++ b/tests/disas/x64-pmin.wat
@@ -0,0 +1,96 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = "-Ccranelift-sse42 -Ccranelift-has-avx"
+
+(module
+  (func (export "f32.pmin") (param f32 f32) (result f32)
+    (select
+      (local.get 1) (local.get 0)
+      (f32.lt (local.get 1) (local.get 0))))
+  (func (export "f32.pmax") (param f32 f32) (result f32)
+    (select
+      (local.get 1) (local.get 0)
+      (f32.lt (local.get 0) (local.get 1))))
+
+  (func (export "f64.pmin") (param f64 f64) (result f64)
+    (select
+      (local.get 1) (local.get 0)
+      (f64.lt (local.get 1) (local.get 0))))
+  (func (export "f64.pmax") (param f64 f64) (result f64)
+    (select
+      (local.get 1) (local.get 0)
+      (f64.lt (local.get 0) (local.get 1))))
+
+  (func (export "f32x4.pmin") (param v128 v128) (result v128)
+    (f32x4.pmin (local.get 0) (local.get 1)))
+  (func (export "f32x4.pmax") (param v128 v128) (result v128)
+    (f32x4.pmax (local.get 0) (local.get 1)))
+
+  (func (export "f64x2.pmin") (param v128 v128) (result v128)
+    (f64x2.pmin (local.get 0) (local.get 1)))
+  (func (export "f64x2.pmax") (param v128 v128) (result v128)
+    (f64x2.pmax (local.get 0) (local.get 1)))
+)
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       vminss  %xmm0, %xmm1, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       vmaxss  %xmm0, %xmm1, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[2]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       vminsd  %xmm0, %xmm1, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[3]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       vmaxsd  %xmm0, %xmm1, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[4]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       vminps  %xmm0, %xmm1, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[5]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       vmaxps  %xmm0, %xmm1, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[6]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       vminpd  %xmm0, %xmm1, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[7]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       vmaxpd  %xmm0, %xmm1, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/x64-relaxed-simd-deterministic.wat b/tests/disas/x64-relaxed-simd-deterministic.wat
new file mode 100644
index 000000000000..241f8fb328a1
--- /dev/null
+++ b/tests/disas/x64-relaxed-simd-deterministic.wat
@@ -0,0 +1,152 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = "-Ccranelift-sse42 -Ccranelift-has-avx -Wrelaxed-simd-deterministic"
+
+(module
+  (func (param v128) (result v128)
+    local.get 0
+    i32x4.relaxed_trunc_f32x4_s
+  )
+
+  (func (param v128) (result v128)
+    local.get 0
+    i32x4.relaxed_trunc_f32x4_u
+  )
+
+  (func (param v128) (result v128)
+    local.get 0
+    i32x4.relaxed_trunc_f64x2_s_zero
+  )
+
+  (func (param v128) (result v128)
+    local.get 0
+    i32x4.relaxed_trunc_f64x2_u_zero
+  )
+
+  (func (param v128 v128) (result v128)
+    local.get 0
+    local.get 1
+    i16x8.relaxed_dot_i8x16_i7x16_s
+  )
+
+  (func (param v128 v128 v128) (result v128)
+    local.get 0
+    local.get 1
+    local.get 2
+    i32x4.relaxed_dot_i8x16_i7x16_add_s
+  )
+)
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       vcmpeqps %xmm0, %xmm0, %xmm3
+;;       vandps  %xmm3, %xmm0, %xmm5
+;;       vpxor   %xmm5, %xmm3, %xmm7
+;;       vcvttps2dq %xmm5, %xmm1
+;;       vpand   %xmm7, %xmm1, %xmm3
+;;       vpsrad  $0x1f, %xmm3, %xmm5
+;;       vpxor   %xmm1, %xmm5, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       vxorps  %xmm3, %xmm3, %xmm5
+;;       vmaxps  %xmm5, %xmm0, %xmm0
+;;       vpcmpeqd %xmm5, %xmm5, %xmm1
+;;       vpsrld  $1, %xmm1, %xmm3
+;;       vcvtdq2ps %xmm3, %xmm5
+;;       vcvttps2dq %xmm0, %xmm7
+;;       vsubps  %xmm5, %xmm0, %xmm1
+;;       vcmpleps %xmm1, %xmm5, %xmm3
+;;       vcvttps2dq %xmm1, %xmm5
+;;       vpxor   %xmm3, %xmm5, %xmm0
+;;       vpxor   %xmm1, %xmm1, %xmm3
+;;       vpmaxsd %xmm3, %xmm0, %xmm5
+;;       vpaddd  %xmm7, %xmm5, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[2]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       vcmpeqpd %xmm0, %xmm0, %xmm3
+;;       vandps  0xf(%rip), %xmm3, %xmm5
+;;       vminpd  %xmm5, %xmm0, %xmm7
+;;       vcvttpd2dq %xmm7, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   9e: addb    %al, (%rax)
+;;   a0: addb    %al, (%rax)
+;;   a2: sarb    $0xff, %bh
+;;
+;; wasm[0]::function[3]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       vxorpd  %xmm3, %xmm3, %xmm5
+;;       vmaxpd  %xmm5, %xmm0, %xmm7
+;;       vminpd  0x1c(%rip), %xmm7, %xmm1
+;;       vroundpd $3, %xmm1, %xmm3
+;;       vaddpd  0x1e(%rip), %xmm3, %xmm6
+;;       vshufps $0x88, %xmm5, %xmm6, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   ec: addb    %al, (%rax)
+;;   ee: addb    %al, (%rax)
+;;   f0: addb    %al, (%rax)
+;;   f2: loopne  0xf3
+;;
+;; wasm[0]::function[4]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       vpmovsxbw %xmm0, %xmm4
+;;       vpmovsxbw %xmm1, %xmm5
+;;       vpmullw %xmm5, %xmm4, %xmm4
+;;       vpalignr $8, %xmm0, %xmm0, %xmm3
+;;       vpmovsxbw %xmm3, %xmm5
+;;       vpalignr $8, %xmm1, %xmm1, %xmm3
+;;       vpmovsxbw %xmm3, %xmm6
+;;       vpmullw %xmm6, %xmm5, %xmm5
+;;       vphaddw %xmm5, %xmm4, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[5]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       vpmovsxbw %xmm0, %xmm7
+;;       vpmovsxbw %xmm1, %xmm3
+;;       vpmullw %xmm3, %xmm7, %xmm7
+;;       vpalignr $8, %xmm0, %xmm0, %xmm6
+;;       vpmovsxbw %xmm6, %xmm0
+;;       vpalignr $8, %xmm1, %xmm1, %xmm6
+;;       vpmovsxbw %xmm6, %xmm1
+;;       vpmullw %xmm1, %xmm0, %xmm0
+;;       vphaddw %xmm0, %xmm7, %xmm7
+;;       vpmaddwd 0x17(%rip), %xmm7, %xmm7
+;;       vpaddd  %xmm2, %xmm7, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;  1a2: addb    %al, (%rax)
+;;  1a4: addb    %al, (%rax)
+;;  1a6: addb    %al, (%rax)
+;;  1a8: addb    %al, (%rax)
+;;  1aa: addb    %al, (%rax)
+;;  1ac: addb    %al, (%rax)
+;;  1ae: addb    %al, (%rax)
+;;  1b0: addl    %eax, (%rax)
+;;  1b2: addl    %eax, (%rax)
+;;  1b4: addl    %eax, (%rax)
+;;  1b6: addl    %eax, (%rax)
+;;  1b8: addl    %eax, (%rax)
+;;  1ba: addl    %eax, (%rax)
+;;  1bc: addl    %eax, (%rax)
+;;  1be: addl    %eax, (%rax)
diff --git a/tests/disas/x64-relaxed-simd.wat b/tests/disas/x64-relaxed-simd.wat
new file mode 100644
index 000000000000..291b12d0efaf
--- /dev/null
+++ b/tests/disas/x64-relaxed-simd.wat
@@ -0,0 +1,121 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = "-Ccranelift-sse41"
+
+(module
+  (func (param v128) (result v128)
+    local.get 0
+    i32x4.relaxed_trunc_f32x4_s
+  )
+
+  (func (param v128) (result v128)
+    local.get 0
+    i32x4.relaxed_trunc_f32x4_u
+  )
+
+  (func (param v128) (result v128)
+    local.get 0
+    i32x4.relaxed_trunc_f64x2_s_zero
+  )
+
+  (func (param v128) (result v128)
+    local.get 0
+    i32x4.relaxed_trunc_f64x2_u_zero
+  )
+
+  (func (param v128 v128) (result v128)
+    local.get 0
+    local.get 1
+    i16x8.relaxed_dot_i8x16_i7x16_s
+  )
+
+  (func (param v128 v128 v128) (result v128)
+    local.get 0
+    local.get 1
+    local.get 2
+    i32x4.relaxed_dot_i8x16_i7x16_add_s
+  )
+)
+
+;; wasm[0]::function[0]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       cvttps2dq %xmm0, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       xorps   %xmm7, %xmm7
+;;       maxps   %xmm7, %xmm0
+;;       pcmpeqd %xmm7, %xmm7
+;;       psrld   $1, %xmm7
+;;       cvtdq2ps %xmm7, %xmm1
+;;       cvttps2dq %xmm0, %xmm7
+;;       subps   %xmm1, %xmm0
+;;       cmpleps %xmm0, %xmm1
+;;       cvttps2dq %xmm0, %xmm0
+;;       pxor    %xmm1, %xmm0
+;;       pxor    %xmm2, %xmm2
+;;       pmaxsd  %xmm2, %xmm0
+;;       paddd   %xmm7, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[2]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       cvttpd2dq %xmm0, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[3]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       xorpd   %xmm4, %xmm4
+;;       maxpd   %xmm4, %xmm0
+;;       minpd   0x1c(%rip), %xmm0
+;;       roundpd $3, %xmm0, %xmm0
+;;       addpd   0x1e(%rip), %xmm0
+;;       shufps  $0x88, %xmm4, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;   ab: addb    %al, (%rax)
+;;   ad: addb    %al, (%rax)
+;;   af: addb    %al, (%rax)
+;;   b1: addb    %ah, %al
+;;
+;; wasm[0]::function[4]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movdqa  %xmm0, %xmm5
+;;       movdqa  %xmm1, %xmm0
+;;       pmaddubsw %xmm5, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[5]:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       pmaddubsw %xmm0, %xmm1
+;;       pmaddwd 0xf(%rip), %xmm1
+;;       movdqa  %xmm1, %xmm0
+;;       paddd   %xmm2, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;  11e: addb    %al, (%rax)
+;;  120: addl    %eax, (%rax)
+;;  122: addl    %eax, (%rax)
+;;  124: addl    %eax, (%rax)
+;;  126: addl    %eax, (%rax)
+;;  128: addl    %eax, (%rax)
+;;  12a: addl    %eax, (%rax)
+;;  12c: addl    %eax, (%rax)
+;;  12e: addl    %eax, (%rax)
diff --git a/tests/disas/x64-simd-test-and-branch.wat b/tests/disas/x64-simd-test-and-branch.wat
new file mode 100644
index 000000000000..1bbceb0f8d20
--- /dev/null
+++ b/tests/disas/x64-simd-test-and-branch.wat
@@ -0,0 +1,125 @@
+;;! target = "x86_64"
+;;! test = "compile"
+;;! flags = ["-Ccranelift-sse41"]
+
+(module
+  (func $i8x16.all_true (param v128) (result i32)
+    local.get 0
+    i8x16.all_true
+    if (result i32)
+      i32.const 100
+    else
+      i32.const 200
+    end
+  )
+
+  (func $i16x8.all_true (param v128) (result i32)
+    local.get 0
+    i16x8.all_true
+    if (result i32)
+      i32.const 100
+    else
+      i32.const 200
+    end
+  )
+
+  (func $i32x4.all_true (param v128) (result i32)
+    local.get 0
+    i32x4.all_true
+    if (result i32)
+      i32.const 100
+    else
+      i32.const 200
+    end
+  )
+
+  (func $i64x2.all_true (param v128) (result i32)
+    local.get 0
+    i64x2.all_true
+    if (result i32)
+      i32.const 100
+    else
+      i32.const 200
+    end
+  )
+
+  (func $v128.any_true (param v128) (result i32)
+    local.get 0
+    v128.any_true
+    if (result i32)
+      i32.const 100
+    else
+      i32.const 200
+    end
+  )
+)
+;; wasm[0]::function[0]::i8x16.all_true:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       pxor    %xmm7, %xmm7
+;;       pcmpeqb %xmm7, %xmm0
+;;       ptest   %xmm0, %xmm0
+;;       je      0x21
+;;   17: movl    $0xc8, %eax
+;;       jmp     0x26
+;;   21: movl    $0x64, %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]::i16x8.all_true:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       pxor    %xmm7, %xmm7
+;;       pcmpeqw %xmm7, %xmm0
+;;       ptest   %xmm0, %xmm0
+;;       je      0x61
+;;   57: movl    $0xc8, %eax
+;;       jmp     0x66
+;;   61: movl    $0x64, %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[2]::i32x4.all_true:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       pxor    %xmm7, %xmm7
+;;       pcmpeqd %xmm7, %xmm0
+;;       ptest   %xmm0, %xmm0
+;;       je      0xa1
+;;   97: movl    $0xc8, %eax
+;;       jmp     0xa6
+;;   a1: movl    $0x64, %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[3]::i64x2.all_true:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       pxor    %xmm7, %xmm7
+;;       pcmpeqq %xmm7, %xmm0
+;;       ptest   %xmm0, %xmm0
+;;       je      0xe2
+;;   d8: movl    $0xc8, %eax
+;;       jmp     0xe7
+;;   e2: movl    $0x64, %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[4]::v128.any_true:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       pxor    %xmm7, %xmm7
+;;       pcmpeqb %xmm7, %xmm0
+;;       pmovmskb %xmm0, %ecx
+;;       cmpl    $0xffff, %ecx
+;;       jne     0x126
+;;  11c: movl    $0xc8, %eax
+;;       jmp     0x12b
+;;  126: movl    $0x64, %eax
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/x64-store-imm.wat b/tests/disas/x64-store-imm.wat
new file mode 100644
index 000000000000..73ca4b9320bf
--- /dev/null
+++ b/tests/disas/x64-store-imm.wat
@@ -0,0 +1,27 @@
+;;! target = "x86_64"
+;;! test = "compile"
+
+(module
+  (global $g (mut i32) (i32.const 0))
+
+  (func $foo
+    (global.set $g (i32.const 0))
+    (global.set $g (i32.const 1))
+    (global.set $g (i32.const -1))
+    (global.set $g (i32.const -10))
+    (global.set $g (i32.const 100000))
+    (global.set $g (i32.const 0x8fff_ffff))
+  )
+)
+;; wasm[0]::function[0]::foo:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       movl    $0, 0x60(%rdi)
+;;       movl    $1, 0x60(%rdi)
+;;       movl    $0xffffffff, 0x60(%rdi)
+;;       movl    $0xfffffff6, 0x60(%rdi)
+;;       movl    $0x186a0, 0x60(%rdi)
+;;       movl    $0x8fffffff, 0x60(%rdi)
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/disas/x64-vector-patterns.wat b/tests/disas/x64-vector-patterns.wat
new file mode 100644
index 000000000000..e043427c3bb6
--- /dev/null
+++ b/tests/disas/x64-vector-patterns.wat
@@ -0,0 +1,22 @@
+;;! target = "x86_64"
+;;! test = "compile"
+
+(module
+  (func $zero (result v128) v128.const i64x2 0 0)
+  (func $ones (result v128) v128.const i64x2 -1 -1)
+)
+;; wasm[0]::function[0]::zero:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       pxor    %xmm0, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
+;;
+;; wasm[0]::function[1]::ones:
+;;       pushq   %rbp
+;;       movq    %rsp, %rbp
+;;       pcmpeqd %xmm0, %xmm0
+;;       movq    %rbp, %rsp
+;;       popq    %rbp
+;;       retq
diff --git a/tests/host_segfault.rs b/tests/host_segfault.rs
index 8c6112df3597..1880e103903b 100644
--- a/tests/host_segfault.rs
+++ b/tests/host_segfault.rs
@@ -9,6 +9,7 @@
 // then we also make sure that stderr is empty to confirm that no weird panics
 // happened or anything like that.
 
+use libtest_mimic::{Arguments, Trial};
 use std::env;
 use std::future::Future;
 use std::io::{self, Write};
@@ -22,7 +23,7 @@ const CONFIRM: &str = "well at least we ran up to the crash";
 
 fn segfault() -> ! {
     unsafe {
-        println!("{}", CONFIRM);
+        println!("{CONFIRM}");
         io::stdout().flush().unwrap();
         *(0x4 as *mut i32) = 3;
         unreachable!()
@@ -40,7 +41,7 @@ fn allocate_stack_space() -> ! {
 }
 
 fn overrun_the_stack() -> ! {
-    println!("{}", CONFIRM);
+    println!("{CONFIRM}");
     io::stdout().flush().unwrap();
     allocate_stack_space();
 }
@@ -124,7 +125,7 @@ fn main() {
                 let engine = Engine::default();
                 let mut store = Store::new(&engine, ());
                 let module = Module::new(&engine, r#"(import "" "" (func)) (start 0)"#).unwrap();
-                let segfault = Func::wrap(&mut store, || segfault());
+                let segfault = Func::wrap(&mut store, || -> () { segfault() });
                 Instance::new(&mut store, &module, &[segfault.into()]).unwrap();
                 unreachable!();
             },
@@ -137,9 +138,11 @@ fn main() {
                 config.async_support(true);
                 let engine = Engine::new(&config).unwrap();
                 let mut store = Store::new(&engine, ());
-                let f = Func::wrap0_async(&mut store, |_| {
+                let f = Func::wrap_async(&mut store, |_, _: ()| {
                     Box::new(async {
-                        overrun_the_stack();
+                        if true {
+                            overrun_the_stack();
+                        }
                     })
                 });
                 run_future(f.call_async(&mut store, &[], &mut [])).unwrap();
@@ -169,9 +172,11 @@ fn main() {
                 config.allocation_strategy(InstanceAllocationStrategy::pooling());
                 let engine = Engine::new(&config).unwrap();
                 let mut store = Store::new(&engine, ());
-                let f = Func::wrap0_async(&mut store, |_| {
+                let f = Func::wrap_async(&mut store, |_, _: ()| {
                     Box::new(async {
-                        overrun_the_stack();
+                        if true {
+                            overrun_the_stack();
+                        }
                     })
                 });
                 run_future(f.call_async(&mut store, &[], &mut [])).unwrap();
@@ -190,10 +195,14 @@ fn main() {
             test();
         }
         Err(_) => {
+            let mut trials = Vec::new();
             for (name, _test, stack_overflow) in tests {
-                println!("running {name}");
-                run_test(name, *stack_overflow);
+                trials.push(Trial::test(name.to_string(), || {
+                    run_test(name, *stack_overflow);
+                    Ok(())
+                }));
             }
+            libtest_mimic::run(&Arguments::from_args(), trials).exit()
         }
     }
 }
@@ -223,23 +232,19 @@ fn run_test(name: &str, stack_overflow: bool) {
         if is_stack_overflow(&output.status, &stderr) {
             assert!(
                 stdout.trim().ends_with(CONFIRM),
-                "failed to find confirmation in test `{}`\n{}",
-                name,
-                desc
+                "failed to find confirmation in test `{name}`\n{desc}"
             );
         } else {
-            panic!("\n\nexpected a stack overflow on `{}`\n{}\n\n", name, desc);
+            panic!("\n\nexpected a stack overflow on `{name}`\n{desc}\n\n");
         }
     } else {
         if is_segfault(&output.status) {
             assert!(
                 stdout.trim().ends_with(CONFIRM) && stderr.is_empty(),
-                "failed to find confirmation in test `{}`\n{}",
-                name,
-                desc
+                "failed to find confirmation in test `{name}`\n{desc}"
             );
         } else {
-            panic!("\n\nexpected a segfault on `{}`\n{}\n\n", name, desc);
+            panic!("\n\nexpected a segfault on `{name}`\n{desc}\n\n");
         }
     }
 }
diff --git a/tests/misc_testsuite/component-model/linking.wast b/tests/misc_testsuite/component-model/linking.wast
index 7cf4aad7d9dd..966926f0893e 100644
--- a/tests/misc_testsuite/component-model/linking.wast
+++ b/tests/misc_testsuite/component-model/linking.wast
@@ -2,7 +2,7 @@
   (component
     (import "undefined-name" (core module))
   )
-  "expected module found nothing")
+  "was not found")
 (component $i)
 (component
   (import "i" (instance))
@@ -12,7 +12,7 @@
   "expected module found instance")
 (assert_unlinkable
   (component (import "i" (func)))
-  "expected func found instance")
+  "expected function found instance")
 (assert_unlinkable
   (component (import "i" (instance (export "x" (func)))))
-  "expected func found nothing")
+  "was not found")
diff --git a/tests/misc_testsuite/component-model/modules.wast b/tests/misc_testsuite/component-model/modules.wast
index 80ea13d40f48..fc7869b2d519 100644
--- a/tests/misc_testsuite/component-model/modules.wast
+++ b/tests/misc_testsuite/component-model/modules.wast
@@ -91,7 +91,7 @@
       ))
     ))
   )
-  "expected func of type `(i32) -> ()`, found func of type `() -> ()`")
+  "expected type `(func (param i32))`, found type `(func)`")
 
 (assert_unlinkable
   (component
diff --git a/tests/misc_testsuite/component-model/resources.wast b/tests/misc_testsuite/component-model/resources.wast
index 89b97536aebc..c2868f838db6 100644
--- a/tests/misc_testsuite/component-model/resources.wast
+++ b/tests/misc_testsuite/component-model/resources.wast
@@ -14,7 +14,7 @@
        (local $r i32)
        (local.set $r (call $new (i32.const 100)))
 
-       (if (i32.ne (local.get $r) (i32.const 0)) (then (unreachable)))
+       (if (i32.ne (local.get $r) (i32.const 1)) (then (unreachable)))
        (if (i32.ne (call $rep (local.get $r)) (i32.const 100)) (then (unreachable)))
 
        (call $drop (local.get $r))
@@ -95,13 +95,13 @@
 
        ;; resources assigned sequentially
        (local.set $r1 (call $new (i32.const 100)))
-       (if (i32.ne (local.get $r1) (i32.const 0)) (then (unreachable)))
+       (if (i32.ne (local.get $r1) (i32.const 1)) (then (unreachable)))
 
        (local.set $r2 (call $new (i32.const 200)))
-       (if (i32.ne (local.get $r2) (i32.const 1)) (then (unreachable)))
+       (if (i32.ne (local.get $r2) (i32.const 2)) (then (unreachable)))
 
        (local.set $r3 (call $new (i32.const 300)))
-       (if (i32.ne (local.get $r3) (i32.const 2)) (then (unreachable)))
+       (if (i32.ne (local.get $r3) (i32.const 3)) (then (unreachable)))
 
        ;; representations all look good
        (if (i32.ne (call $rep (local.get $r1)) (i32.const 100)) (then (unreachable)))
@@ -113,7 +113,7 @@
        (local.set $r2 (call $new (i32.const 400)))
 
        ;; should have reused index 1
-       (if (i32.ne (local.get $r2) (i32.const 1)) (then (unreachable)))
+       (if (i32.ne (local.get $r2) (i32.const 2)) (then (unreachable)))
 
        ;; representations all look good
        (if (i32.ne (call $rep (local.get $r1)) (i32.const 100)) (then (unreachable)))
@@ -135,13 +135,13 @@
        (if (i32.ne (call $rep (local.get $r3)) (i32.const 700)) (then (unreachable)))
 
        ;; indices should be lifo
-       (if (i32.ne (local.get $r1) (i32.const 2)) (then (unreachable)))
-       (if (i32.ne (local.get $r2) (i32.const 1)) (then (unreachable)))
-       (if (i32.ne (local.get $r3) (i32.const 0)) (then (unreachable)))
+       (if (i32.ne (local.get $r1) (i32.const 3)) (then (unreachable)))
+       (if (i32.ne (local.get $r2) (i32.const 2)) (then (unreachable)))
+       (if (i32.ne (local.get $r3) (i32.const 1)) (then (unreachable)))
 
        ;; bump one more time
        (local.set $r4 (call $new (i32.const 800)))
-       (if (i32.ne (local.get $r4) (i32.const 3)) (then (unreachable)))
+       (if (i32.ne (local.get $r4) (i32.const 4)) (then (unreachable)))
 
        ;; deallocate everything
        (call $drop (local.get $r1))
@@ -167,7 +167,7 @@
       (export "missing" (type (sub resource)))
     ))
   )
-  "expected resource found nothing")
+  "was not found")
 (assert_unlinkable
   (component
     (import "host" (instance
@@ -241,13 +241,13 @@
        (local.set $r2 (call $ctor (i32.const 200)))
 
        ;; assert r1/r2 are sequential
-       (if (i32.ne (local.get $r1) (i32.const 0)) (then (unreachable)))
-       (if (i32.ne (local.get $r2) (i32.const 1)) (then (unreachable)))
+       (if (i32.ne (local.get $r1) (i32.const 1)) (then (unreachable)))
+       (if (i32.ne (local.get $r2) (i32.const 2)) (then (unreachable)))
 
        ;; reallocate r1 and it should be reassigned the same index
        (call $drop (local.get $r1))
        (local.set $r1 (call $ctor (i32.const 300)))
-       (if (i32.ne (local.get $r1) (i32.const 0)) (then (unreachable)))
+       (if (i32.ne (local.get $r1) (i32.const 1)) (then (unreachable)))
 
        ;; internal values should match
        (call $assert (local.get $r1) (i32.const 300))
@@ -443,7 +443,7 @@
       (import "" "ctor" (func $ctor (param i32) (result i32)))
 
       (func $start
-        (if (i32.ne (call $ctor (i32.const 100)) (i32.const 0)) (then (unreachable)))
+        (if (i32.ne (call $ctor (i32.const 100)) (i32.const 1)) (then (unreachable)))
       )
       (start $start)
     )
@@ -464,7 +464,7 @@
      (import "" "drop" (func $drop (param i32)))
 
      (func (export "f")
-        (call $drop (i32.const 0))
+        (call $drop (i32.const 1))
      )
   )
   (core instance $i (instantiate $m
@@ -492,10 +492,10 @@
       (import "" "drop" (func $drop (param i32)))
 
       (func (export "alloc")
-        (if (i32.ne (call $ctor (i32.const 100)) (i32.const 0)) (then (unreachable)))
+        (if (i32.ne (call $ctor (i32.const 100)) (i32.const 1)) (then (unreachable)))
       )
       (func (export "dealloc")
-        (call $drop (i32.const 0))
+        (call $drop (i32.const 1))
       )
     )
     (core instance $i (instantiate $m
@@ -552,10 +552,10 @@
       (import "" "drop" (func $drop (param i32)))
 
       (func (export "alloc")
-        (if (i32.ne (call $ctor (i32.const 100)) (i32.const 0)) (then (unreachable)))
+        (if (i32.ne (call $ctor (i32.const 100)) (i32.const 1)) (then (unreachable)))
       )
       (func (export "dealloc")
-        (call $drop (i32.const 0))
+        (call $drop (i32.const 1))
       )
     )
     (core instance $i (instantiate $m
@@ -617,12 +617,12 @@
       (call $drop2 (call $new2 (i32.const 104)))
 
       ;; should be referencing the same namespace
-      (if (i32.ne (call $new1 (i32.const 105)) (i32.const 0)) (then (unreachable)))
-      (if (i32.ne (call $new2 (i32.const 105)) (i32.const 1)) (then (unreachable)))
+      (if (i32.ne (call $new1 (i32.const 105)) (i32.const 1)) (then (unreachable)))
+      (if (i32.ne (call $new2 (i32.const 105)) (i32.const 2)) (then (unreachable)))
 
       ;; use different drops out of order
-      (call $drop2 (i32.const 0))
-      (call $drop1 (i32.const 1))
+      (call $drop2 (i32.const 1))
+      (call $drop1 (i32.const 2))
     )
 
     (start $start)
@@ -701,8 +701,8 @@
       (local.set $r2 (call $new2 (i32.const 200)))
 
       ;; both should be index 0
-      (if (i32.ne (local.get $r1) (i32.const 0)) (then (unreachable)))
-      (if (i32.ne (local.get $r2) (i32.const 0)) (then (unreachable)))
+      (if (i32.ne (local.get $r1) (i32.const 1)) (then (unreachable)))
+      (if (i32.ne (local.get $r2) (i32.const 1)) (then (unreachable)))
 
       ;; nothing should be dropped yet
       (if (i32.ne (call $drops) (i32.const 0)) (then (unreachable)))
@@ -866,7 +866,7 @@
 
       ;; table should be empty at this point, so a fresh allocation should get
       ;; index 0
-      (if (i32.ne (call $ctor (i32.const 600)) (i32.const 0)) (then (unreachable)))
+      (if (i32.ne (call $ctor (i32.const 600)) (i32.const 1)) (then (unreachable)))
     )
 
     (start $start)
@@ -1024,8 +1024,8 @@
         (local.set $r1 (call $ctor (i32.const 100)))
         (local.set $r2 (call $ctor (i32.const 200)))
 
-        (if (i32.ne (local.get $r1) (i32.const 0)) (then (unreachable)))
-        (if (i32.ne (local.get $r2) (i32.const 1)) (then (unreachable)))
+        (if (i32.ne (local.get $r1) (i32.const 1)) (then (unreachable)))
+        (if (i32.ne (local.get $r2) (i32.const 2)) (then (unreachable)))
 
         (call $assert-borrow (local.get $r2) (i32.const 200))
         (call $assert-borrow (local.get $r1) (i32.const 100))
diff --git a/tests/misc_testsuite/custom-page-sizes/custom-page-sizes-invalid.wast b/tests/misc_testsuite/custom-page-sizes/custom-page-sizes-invalid.wast
new file mode 100644
index 000000000000..80cbcff65812
--- /dev/null
+++ b/tests/misc_testsuite/custom-page-sizes/custom-page-sizes-invalid.wast
@@ -0,0 +1,110 @@
+;; Page size that is not a power of two.
+(assert_malformed
+  (module quote "(memory 0 (pagesize 3))")
+  "invalid custom page size"
+)
+
+;; Power-of-two page sizes that are not 1 or 64KiB.
+(assert_invalid
+  (module (memory 0 (pagesize 2)))
+  "invalid custom page size"
+)
+(assert_invalid
+  (module (memory 0 (pagesize 4)))
+  "invalid custom page size"
+)
+(assert_invalid
+  (module (memory 0 (pagesize 8)))
+  "invalid custom page size"
+)
+(assert_invalid
+  (module (memory 0 (pagesize 16)))
+  "invalid custom page size"
+)
+(assert_invalid
+  (module (memory 0 (pagesize 32)))
+  "invalid custom page size"
+)
+(assert_invalid
+  (module (memory 0 (pagesize 64)))
+  "invalid custom page size"
+)
+(assert_invalid
+  (module (memory 0 (pagesize 128)))
+  "invalid custom page size"
+)
+(assert_invalid
+  (module (memory 0 (pagesize 256)))
+  "invalid custom page size"
+)
+(assert_invalid
+  (module (memory 0 (pagesize 512)))
+  "invalid custom page size"
+)
+(assert_invalid
+  (module (memory 0 (pagesize 1024)))
+  "invalid custom page size"
+)
+(assert_invalid
+  (module (memory 0 (pagesize 2048)))
+  "invalid custom page size"
+)
+(assert_invalid
+  (module (memory 0 (pagesize 4096)))
+  "invalid custom page size"
+)
+(assert_invalid
+  (module (memory 0 (pagesize 8192)))
+  "invalid custom page size"
+)
+(assert_invalid
+  (module (memory 0 (pagesize 16384)))
+  "invalid custom page size"
+)
+(assert_invalid
+  (module (memory 0 (pagesize 32768)))
+  "invalid custom page size"
+)
+
+;; Power-of-two page size that is larger than 64KiB.
+(assert_invalid
+  (module (memory 0 (pagesize 0x20000)))
+  "invalid custom page size"
+)
+
+;; Power of two page size that cannot fit in a u64 to exercise checks against
+;; shift overflow.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\04\01"                ;; Memory section
+
+    ;; memory 0
+    "\08"                      ;; flags w/ custom page size
+    "\00"                      ;; minimum = 0
+    "\41"                      ;; pagesize = 2**65
+  )
+  "invalid custom page size"
+)
+
+;; Importing a memory with the wrong page size.
+
+(module $m
+  (memory (export "small-pages-memory") 0 (pagesize 1))
+  (memory (export "large-pages-memory") 0 (pagesize 65536))
+)
+(register "m" $m)
+
+(assert_unlinkable
+  (module
+    (memory (import "m" "small-pages-memory") 0 (pagesize 65536))
+  )
+  "memory types incompatible"
+)
+
+(assert_unlinkable
+  (module
+    (memory (import "m" "large-pages-memory") 0 (pagesize 1))
+  )
+  "memory types incompatible"
+)
diff --git a/tests/misc_testsuite/custom-page-sizes/custom-page-sizes.wast b/tests/misc_testsuite/custom-page-sizes/custom-page-sizes.wast
new file mode 100644
index 000000000000..b312f1f94390
--- /dev/null
+++ b/tests/misc_testsuite/custom-page-sizes/custom-page-sizes.wast
@@ -0,0 +1,108 @@
+;; Check all the valid custom page sizes.
+(module (memory 1 (pagesize 1)))
+(module (memory 1 (pagesize 65536)))
+
+;; Check them all again with maximums specified.
+(module (memory 1 2 (pagesize 1)))
+(module (memory 1 2 (pagesize 65536)))
+
+;; Check the behavior of memories with page size 1.
+(module
+  (memory 0 (pagesize 1))
+  (func (export "size") (result i32)
+    memory.size
+  )
+  (func (export "grow") (param i32) (result i32)
+    (memory.grow (local.get 0))
+  )
+  (func (export "load") (param i32) (result i32)
+    (i32.load8_u (local.get 0))
+  )
+  (func (export "store") (param i32 i32)
+    (i32.store8 (local.get 0) (local.get 1))
+  )
+)
+
+(assert_return (invoke "size") (i32.const 0))
+(assert_trap (invoke "load" (i32.const 0)) "out of bounds memory access")
+
+(assert_return (invoke "grow" (i32.const 65536)) (i32.const 0))
+(assert_return (invoke "size") (i32.const 65536))
+(assert_return (invoke "load" (i32.const 65535)) (i32.const 0))
+(assert_return (invoke "store" (i32.const 65535) (i32.const 1)))
+(assert_return (invoke "load" (i32.const 65535)) (i32.const 1))
+(assert_trap (invoke "load" (i32.const 65536)) "out of bounds memory access")
+
+(assert_return (invoke "grow" (i32.const 65536)) (i32.const 65536))
+(assert_return (invoke "size") (i32.const 131072))
+(assert_return (invoke "load" (i32.const 131071)) (i32.const 0))
+(assert_return (invoke "store" (i32.const 131071) (i32.const 1)))
+(assert_return (invoke "load" (i32.const 131071)) (i32.const 1))
+(assert_trap (invoke "load" (i32.const 131072)) "out of bounds memory access")
+
+;; Although smaller page sizes let us get to memories larger than 2**16 pages,
+;; we can't do that with the default page size, even if we explicitly state it
+;; as a custom page size.
+(module
+  (memory 0 (pagesize 65536))
+  (func (export "size") (result i32)
+    memory.size
+  )
+  (func (export "grow") (param i32) (result i32)
+    (memory.grow (local.get 0))
+  )
+)
+(assert_return (invoke "size") (i32.const 0))
+(assert_return (invoke "grow" (i32.const 65537)) (i32.const -1))
+(assert_return (invoke "size") (i32.const 0))
+
+;; Can copy between memories of different page sizes.
+(module
+  (memory $small 10 (pagesize 1))
+  (memory $large 1 (pagesize 65536))
+
+  (data (memory $small) (i32.const 0) "\11\22\33\44")
+  (data (memory $large) (i32.const 0) "\55\66\77\88")
+
+  (func (export "copy-small-to-large") (param i32 i32 i32)
+    (memory.copy $large $small (local.get 0) (local.get 1) (local.get 2))
+  )
+
+  (func (export "copy-large-to-small") (param i32 i32 i32)
+    (memory.copy $small $large (local.get 0) (local.get 1) (local.get 2))
+  )
+
+  (func (export "load8-small") (param i32) (result i32)
+    (i32.load8_u $small (local.get 0))
+  )
+
+  (func (export "load8-large") (param i32) (result i32)
+    (i32.load8_u $large (local.get 0))
+  )
+)
+
+(assert_return (invoke "copy-small-to-large" (i32.const 6) (i32.const 0) (i32.const 2)))
+(assert_return (invoke "load8-large" (i32.const 6)) (i32.const 0x11))
+(assert_return (invoke "load8-large" (i32.const 7)) (i32.const 0x22))
+
+(assert_return (invoke "copy-large-to-small" (i32.const 4) (i32.const 1) (i32.const 3)))
+(assert_return (invoke "load8-small" (i32.const 4)) (i32.const 0x66))
+(assert_return (invoke "load8-small" (i32.const 5)) (i32.const 0x77))
+(assert_return (invoke "load8-small" (i32.const 6)) (i32.const 0x88))
+
+;; Can link together modules that export and import memories with custom page
+;; sizes.
+
+(module $m
+  (memory (export "small-pages-memory") 0 (pagesize 1))
+  (memory (export "large-pages-memory") 0 (pagesize 65536))
+)
+(register "m" $m)
+
+(module
+  (memory (import "m" "small-pages-memory") 0 (pagesize 1))
+)
+
+(module
+  (memory (import "m" "large-pages-memory") 0 (pagesize 65536))
+)
diff --git a/tests/misc_testsuite/embenchen_fannkuch.wast b/tests/misc_testsuite/embenchen_fannkuch.wast
new file mode 100644
index 000000000000..3f91957d2165
--- /dev/null
+++ b/tests/misc_testsuite/embenchen_fannkuch.wast
@@ -0,0 +1,12206 @@
+;; copied from a historical cranelift-wasm test and provided here as proof that
+;; this still compiles on various platforms and such
+
+(module $env
+  (memory (export "memory") 2 2)
+  (table (export "table") 8 8 funcref)
+  (global (export "DYNAMICTOP_PTR") i32 i32.const 0)
+  (global (export "STACKTOP") i32 i32.const 0)
+  (global (export "STACK_MAX") i32 i32.const 0)
+  (global (export "memoryBase") i32 i32.const 0)
+  (global (export "tableBase") i32 i32.const 0)
+  (func (export "abort") (param i32))
+  (func (export "enlargeMemory") (result i32) unreachable)
+  (func (export "getTotalMemory") (result i32) unreachable)
+  (func (export "abortOnCannotGrowMemory") (result i32) unreachable)
+  (func (export "_pthread_cleanup_pop") (param i32))
+  (func (export "___syscall6") (param i32 i32) (result i32) unreachable)
+  (func (export "_pthread_cleanup_push") (param i32 i32))
+  (func (export "_abort"))
+  (func (export "___setErrNo") (param i32))
+  (func (export "_emscripten_memcpy_big") (param i32 i32 i32) (result i32) unreachable)
+  (func (export "___syscall54") (param i32 i32) (result i32) unreachable)
+  (func (export "___syscall140") (param i32 i32) (result i32) unreachable)
+  (func (export "___syscall146") (param i32 i32) (result i32) unreachable)
+)
+
+(module
+  (type $0 (;0;) (func (param i32 i32 i32) (result i32)))
+  (type $1 (;1;) (func (param i32) (result i32)))
+  (type $2 (;2;) (func (param i32)))
+  (type $3 (;3;) (func (result i32)))
+  (type $4 (;4;) (func (param i32 i32) (result i32)))
+  (type $5 (;5;) (func (param i32 i32)))
+  (type $6 (;6;) (func))
+  (type $7 (;7;) (func (param i32 i32 i32 i32 i32) (result i32)))
+  (type $8 (;8;) (func (param i32 i32 i32)))
+  (type $9 (;9;) (func (param i64 i32) (result i32)))
+  (type $10 (;10;) (func (param i32 i32 i32 i32 i32)))
+  (type $11 (;11;) (func (param f64 i32) (result f64)))
+  (type $12 (;12;) (func (param i32 i32 i32 i32) (result i32)))
+  (import "env" "memory" (memory $16 (;0;) 2 2))
+  (import "env" "table" (table $timport$17 (;0;) 8 8 funcref))
+  (import "env" "DYNAMICTOP_PTR" (global $gimport$0 (;0;) i32))
+  (import "env" "STACKTOP" (global $gimport$1 (;1;) i32))
+  (import "env" "STACK_MAX" (global $gimport$2 (;2;) i32))
+  (import "env" "memoryBase" (global $gimport$18 (;3;) i32))
+  (import "env" "tableBase" (global $gimport$19 (;4;) i32))
+  (import "env" "abort" (func $fimport$3 (;0;) (type $2)))
+  (import "env" "enlargeMemory" (func $fimport$4 (;1;) (type $3)))
+  (import "env" "getTotalMemory" (func $fimport$5 (;2;) (type $3)))
+  (import "env" "abortOnCannotGrowMemory" (func $fimport$6 (;3;) (type $3)))
+  (import "env" "_pthread_cleanup_pop" (func $fimport$7 (;4;) (type $2)))
+  (import "env" "___syscall6" (func $fimport$8 (;5;) (type $4)))
+  (import "env" "_pthread_cleanup_push" (func $fimport$9 (;6;) (type $5)))
+  (import "env" "_abort" (func $fimport$10 (;7;) (type $6)))
+  (import "env" "___setErrNo" (func $fimport$11 (;8;) (type $2)))
+  (import "env" "_emscripten_memcpy_big" (func $fimport$12 (;9;) (type $0)))
+  (import "env" "___syscall54" (func $fimport$13 (;10;) (type $4)))
+  (import "env" "___syscall140" (func $fimport$14 (;11;) (type $4)))
+  (import "env" "___syscall146" (func $fimport$15 (;12;) (type $4)))
+  (func $0 (;13;) (type $1) (param $0 i32) (result i32)
+    (local $1 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $1
+      global.get $global$1
+      local.get $0
+      i32.add
+      global.set $global$1
+      global.get $global$1
+      i32.const 15
+      i32.add
+      i32.const -16
+      i32.and
+      global.set $global$1
+      local.get $1
+    end
+  )
+  (func $1 (;14;) (type $3) (result i32)
+    global.get $global$1
+  )
+  (func $2 (;15;) (type $2) (param $0 i32)
+    local.get $0
+    global.set $global$1
+  )
+  (func $3 (;16;) (type $5) (param $0 i32) (param $1 i32)
+    block $label$1 ;; label = @1
+      local.get $0
+      global.set $global$1
+      local.get $1
+      global.set $global$2
+    end
+  )
+  (func $4 (;17;) (type $5) (param $0 i32) (param $1 i32)
+    global.get $global$3
+    i32.eqz
+    if ;; label = @1
+      block ;; label = @2
+        local.get $0
+        global.set $global$3
+        local.get $1
+        global.set $global$4
+      end
+    end
+  )
+  (func $5 (;18;) (type $2) (param $0 i32)
+    local.get $0
+    global.set $global$5
+  )
+  (func $6 (;19;) (type $3) (result i32)
+    global.get $global$5
+  )
+  (func $7 (;20;) (type $1) (param $0 i32) (result i32)
+    (local $1 i32) (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32) (local $15 i32) (local $16 i32) (local $17 i32)
+    block $label$1 (result i32) ;; label = @1
+      local.get $0
+      i32.load offset=4
+      local.tee $4
+      i32.const 2
+      i32.shl
+      local.tee $15
+      call $35
+      local.set $3
+      local.get $15
+      call $35
+      local.set $6
+      local.get $15
+      call $35
+      local.set $10
+      local.get $4
+      i32.const 0
+      i32.gt_s
+      local.tee $2
+      if ;; label = @2
+        block ;; label = @3
+          i32.const 0
+          local.set $1
+          loop $label$3 ;; label = @4
+            local.get $3
+            local.get $1
+            i32.const 2
+            i32.shl
+            i32.add
+            local.get $1
+            i32.store
+            local.get $1
+            i32.const 1
+            i32.add
+            local.tee $1
+            local.get $4
+            i32.ne
+            br_if 0 (;@4;)
+          end
+          local.get $3
+          local.get $0
+          i32.load
+          local.tee $0
+          i32.const 2
+          i32.shl
+          i32.add
+          local.get $4
+          i32.const -1
+          i32.add
+          local.tee $11
+          i32.store
+          local.get $3
+          local.get $11
+          i32.const 2
+          i32.shl
+          i32.add
+          local.tee $14
+          local.get $0
+          i32.store
+          local.get $2
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 0
+              local.set $0
+              local.get $4
+              local.set $1
+              loop $label$5 ;; label = @6
+                block $label$6 ;; label = @7
+                  local.get $1
+                  i32.const 1
+                  i32.gt_s
+                  if ;; label = @8
+                    loop $label$8 ;; label = @9
+                      local.get $10
+                      local.get $1
+                      i32.const -1
+                      i32.add
+                      local.tee $2
+                      i32.const 2
+                      i32.shl
+                      i32.add
+                      local.get $1
+                      i32.store
+                      local.get $2
+                      i32.const 1
+                      i32.gt_s
+                      if ;; label = @10
+                        block ;; label = @11
+                          local.get $2
+                          local.set $1
+                          br 2 (;@9;)
+                        end
+                      else
+                        i32.const 1
+                        local.set $2
+                      end
+                    end
+                  else
+                    local.get $1
+                    local.set $2
+                  end
+                  local.get $3
+                  i32.load
+                  local.tee $7
+                  if ;; label = @8
+                    local.get $14
+                    i32.load
+                    local.get $11
+                    i32.ne
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $6
+                        local.get $3
+                        local.get $15
+                        call $40
+                        drop
+                        i32.const 0
+                        local.set $8
+                        local.get $6
+                        i32.load
+                        local.set $9
+                        loop $label$14 ;; label = @11
+                          local.get $9
+                          i32.const -1
+                          i32.add
+                          local.tee $1
+                          i32.const 1
+                          i32.gt_s
+                          if ;; label = @12
+                            block ;; label = @13
+                              i32.const 1
+                              local.set $5
+                              loop $label$16 ;; label = @14
+                                local.get $6
+                                local.get $5
+                                i32.const 2
+                                i32.shl
+                                i32.add
+                                local.tee $12
+                                i32.load
+                                local.set $17
+                                local.get $12
+                                local.get $6
+                                local.get $1
+                                i32.const 2
+                                i32.shl
+                                i32.add
+                                local.tee $12
+                                i32.load
+                                i32.store
+                                local.get $12
+                                local.get $17
+                                i32.store
+                                local.get $5
+                                i32.const 1
+                                i32.add
+                                local.tee $5
+                                local.get $1
+                                i32.const -1
+                                i32.add
+                                local.tee $1
+                                i32.lt_s
+                                br_if 0 (;@14;)
+                              end
+                            end
+                          end
+                          local.get $8
+                          i32.const 1
+                          i32.add
+                          local.set $5
+                          local.get $6
+                          local.get $9
+                          i32.const 2
+                          i32.shl
+                          i32.add
+                          local.tee $12
+                          i32.load
+                          local.set $1
+                          local.get $12
+                          local.get $9
+                          i32.store
+                          local.get $1
+                          if ;; label = @12
+                            block ;; label = @13
+                              local.get $5
+                              local.set $8
+                              local.get $1
+                              local.set $9
+                              br 2 (;@11;)
+                            end
+                          end
+                        end
+                        local.get $0
+                        local.get $8
+                        i32.le_s
+                        if ;; label = @11
+                          local.get $5
+                          local.set $0
+                        end
+                      end
+                    end
+                  end
+                  local.get $2
+                  local.get $11
+                  i32.lt_s
+                  if ;; label = @8
+                    local.get $2
+                    local.set $1
+                  else
+                    block ;; label = @9
+                      i32.const 31
+                      local.set $1
+                      br 2 (;@7;)
+                    end
+                  end
+                  loop $label$21 ;; label = @8
+                    local.get $1
+                    i32.const 0
+                    i32.gt_s
+                    if ;; label = @9
+                      block ;; label = @10
+                        i32.const 0
+                        local.set $2
+                        loop $label$23 ;; label = @11
+                          local.get $3
+                          local.get $2
+                          i32.const 2
+                          i32.shl
+                          i32.add
+                          local.get $3
+                          local.get $2
+                          i32.const 1
+                          i32.add
+                          local.tee $2
+                          i32.const 2
+                          i32.shl
+                          i32.add
+                          i32.load
+                          i32.store
+                          local.get $2
+                          local.get $1
+                          i32.lt_s
+                          br_if 0 (;@11;)
+                          local.get $1
+                          local.set $2
+                        end
+                      end
+                    else
+                      i32.const 0
+                      local.set $2
+                    end
+                    local.get $3
+                    local.get $2
+                    i32.const 2
+                    i32.shl
+                    i32.add
+                    local.get $7
+                    i32.store
+                    local.get $10
+                    local.get $1
+                    i32.const 2
+                    i32.shl
+                    i32.add
+                    local.tee $2
+                    i32.load
+                    local.set $5
+                    local.get $2
+                    local.get $5
+                    i32.const -1
+                    i32.add
+                    i32.store
+                    local.get $5
+                    i32.const 1
+                    i32.gt_s
+                    br_if 2 (;@6;)
+                    local.get $1
+                    i32.const 1
+                    i32.add
+                    local.tee $1
+                    local.get $11
+                    i32.lt_s
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $3
+                        i32.load
+                        local.set $7
+                        br 2 (;@8;)
+                      end
+                    else
+                      block ;; label = @10
+                        i32.const 31
+                        local.set $1
+                        br 3 (;@7;)
+                      end
+                    end
+                  end
+                end
+              end
+              local.get $1
+              i32.const 31
+              i32.eq
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $3
+                  call $36
+                  local.get $6
+                  call $36
+                  local.get $10
+                  call $36
+                  local.get $0
+                  return
+                end
+              end
+            end
+          else
+            block ;; label = @5
+              local.get $14
+              local.set $16
+              local.get $11
+              local.set $13
+            end
+          end
+        end
+      else
+        block ;; label = @3
+          local.get $3
+          local.get $0
+          i32.load
+          local.tee $0
+          i32.const 2
+          i32.shl
+          i32.add
+          local.get $4
+          i32.const -1
+          i32.add
+          local.tee $13
+          i32.store
+          local.get $3
+          local.get $13
+          i32.const 2
+          i32.shl
+          i32.add
+          local.tee $16
+          local.get $0
+          i32.store
+        end
+      end
+      i32.const 0
+      local.set $0
+      local.get $4
+      local.set $1
+      loop $label$30 ;; label = @2
+        block $label$31 ;; label = @3
+          local.get $1
+          i32.const 1
+          i32.gt_s
+          if ;; label = @4
+            loop $label$33 ;; label = @5
+              local.get $10
+              local.get $1
+              i32.const -1
+              i32.add
+              local.tee $2
+              i32.const 2
+              i32.shl
+              i32.add
+              local.get $1
+              i32.store
+              local.get $2
+              i32.const 1
+              i32.gt_s
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $2
+                  local.set $1
+                  br 2 (;@5;)
+                end
+              else
+                i32.const 1
+                local.set $2
+              end
+            end
+          else
+            local.get $1
+            local.set $2
+          end
+          local.get $3
+          i32.load
+          local.tee $9
+          if ;; label = @4
+            local.get $16
+            i32.load
+            local.get $13
+            i32.ne
+            if ;; label = @5
+              block ;; label = @6
+                i32.const 0
+                local.set $5
+                local.get $6
+                i32.load
+                local.set $8
+                loop $label$39 ;; label = @7
+                  local.get $8
+                  i32.const -1
+                  i32.add
+                  local.tee $1
+                  i32.const 1
+                  i32.gt_s
+                  if ;; label = @8
+                    block ;; label = @9
+                      i32.const 1
+                      local.set $4
+                      loop $label$41 ;; label = @10
+                        local.get $6
+                        local.get $4
+                        i32.const 2
+                        i32.shl
+                        i32.add
+                        local.tee $7
+                        i32.load
+                        local.set $14
+                        local.get $7
+                        local.get $6
+                        local.get $1
+                        i32.const 2
+                        i32.shl
+                        i32.add
+                        local.tee $7
+                        i32.load
+                        i32.store
+                        local.get $7
+                        local.get $14
+                        i32.store
+                        local.get $4
+                        i32.const 1
+                        i32.add
+                        local.tee $4
+                        local.get $1
+                        i32.const -1
+                        i32.add
+                        local.tee $1
+                        i32.lt_s
+                        br_if 0 (;@10;)
+                      end
+                    end
+                  end
+                  local.get $5
+                  i32.const 1
+                  i32.add
+                  local.set $4
+                  local.get $6
+                  local.get $8
+                  i32.const 2
+                  i32.shl
+                  i32.add
+                  local.tee $7
+                  i32.load
+                  local.set $1
+                  local.get $7
+                  local.get $8
+                  i32.store
+                  local.get $1
+                  if ;; label = @8
+                    block ;; label = @9
+                      local.get $4
+                      local.set $5
+                      local.get $1
+                      local.set $8
+                      br 2 (;@7;)
+                    end
+                  end
+                end
+                local.get $0
+                local.get $5
+                i32.le_s
+                if ;; label = @7
+                  local.get $4
+                  local.set $0
+                end
+              end
+            end
+          end
+          local.get $2
+          local.get $13
+          i32.lt_s
+          if ;; label = @4
+            local.get $2
+            local.set $1
+          else
+            block ;; label = @5
+              i32.const 31
+              local.set $1
+              br 2 (;@3;)
+            end
+          end
+          loop $label$46 ;; label = @4
+            local.get $1
+            i32.const 0
+            i32.gt_s
+            if ;; label = @5
+              block ;; label = @6
+                i32.const 0
+                local.set $2
+                loop $label$48 ;; label = @7
+                  local.get $3
+                  local.get $2
+                  i32.const 2
+                  i32.shl
+                  i32.add
+                  local.get $3
+                  local.get $2
+                  i32.const 1
+                  i32.add
+                  local.tee $2
+                  i32.const 2
+                  i32.shl
+                  i32.add
+                  i32.load
+                  i32.store
+                  local.get $2
+                  local.get $1
+                  i32.lt_s
+                  br_if 0 (;@7;)
+                  local.get $1
+                  local.set $2
+                end
+              end
+            else
+              i32.const 0
+              local.set $2
+            end
+            local.get $3
+            local.get $2
+            i32.const 2
+            i32.shl
+            i32.add
+            local.get $9
+            i32.store
+            local.get $10
+            local.get $1
+            i32.const 2
+            i32.shl
+            i32.add
+            local.tee $2
+            i32.load
+            local.set $4
+            local.get $2
+            local.get $4
+            i32.const -1
+            i32.add
+            i32.store
+            local.get $4
+            i32.const 1
+            i32.gt_s
+            br_if 2 (;@2;)
+            local.get $1
+            i32.const 1
+            i32.add
+            local.tee $1
+            local.get $13
+            i32.lt_s
+            if ;; label = @5
+              block ;; label = @6
+                local.get $3
+                i32.load
+                local.set $9
+                br 2 (;@4;)
+              end
+            else
+              block ;; label = @6
+                i32.const 31
+                local.set $1
+                br 3 (;@3;)
+              end
+            end
+          end
+        end
+      end
+      local.get $1
+      i32.const 31
+      i32.eq
+      if ;; label = @2
+        block ;; label = @3
+          local.get $3
+          call $36
+          local.get $6
+          call $36
+          local.get $10
+          call $36
+          local.get $0
+          return
+        end
+      end
+      i32.const 0
+    end
+  )
+  (func $8 (;21;) (type $4) (param $0 i32) (param $1 i32) (result i32)
+    (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $5
+      global.get $global$1
+      i32.const 32
+      i32.add
+      global.set $global$1
+      local.get $5
+      i32.const 16
+      i32.add
+      local.set $7
+      local.get $5
+      i32.const 8
+      i32.add
+      local.set $10
+      local.get $5
+      local.set $2
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          local.get $0
+          i32.const 1
+          i32.le_s
+          br_if 0 (;@3;)
+          block $label$4 ;; label = @4
+            block $label$5 ;; label = @5
+              block $label$6 ;; label = @6
+                block $label$7 ;; label = @7
+                  block $label$8 ;; label = @8
+                    block $label$9 ;; label = @9
+                      block $label$10 ;; label = @10
+                        local.get $1
+                        i32.load offset=4
+                        i32.load8_s
+                        local.tee $0
+                        i32.const 48
+                        i32.sub
+                        br_table 5 (;@5;) 0 (;@10;) 2 (;@8;) 1 (;@9;) 3 (;@7;) 4 (;@6;) 6 (;@4;)
+                      end
+                      i32.const 9
+                      local.set $3
+                      br 7 (;@2;)
+                    end
+                    br 5 (;@3;)
+                  end
+                  i32.const 10
+                  local.set $3
+                  br 5 (;@2;)
+                end
+                i32.const 11
+                local.set $3
+                br 4 (;@2;)
+              end
+              i32.const 12
+              local.set $3
+              br 3 (;@2;)
+            end
+            local.get $5
+            global.set $global$1
+            i32.const 0
+            return
+          end
+          local.get $2
+          local.get $0
+          i32.const -48
+          i32.add
+          i32.store
+          i32.const 1140
+          local.get $2
+          call $33
+          drop
+          local.get $5
+          global.set $global$1
+          i32.const -1
+          return
+        end
+        i32.const 11
+        local.set $3
+      end
+      local.get $3
+      i32.const -1
+      i32.add
+      local.set $6
+      i32.const 0
+      local.set $2
+      i32.const 0
+      local.set $0
+      loop $label$11 ;; label = @2
+        i32.const 12
+        call $35
+        local.tee $1
+        local.get $0
+        i32.store
+        local.get $1
+        local.get $3
+        i32.store offset=4
+        local.get $1
+        local.get $2
+        i32.store offset=8
+        local.get $0
+        i32.const 1
+        i32.add
+        local.tee $0
+        local.get $6
+        i32.ne
+        if ;; label = @3
+          block ;; label = @4
+            local.get $1
+            local.set $2
+            br 2 (;@2;)
+          end
+        end
+      end
+      local.get $3
+      i32.const 2
+      i32.shl
+      local.tee $0
+      call $35
+      local.set $4
+      local.get $0
+      call $35
+      local.set $8
+      i32.const 0
+      local.set $0
+      loop $label$13 ;; label = @2
+        local.get $4
+        local.get $0
+        i32.const 2
+        i32.shl
+        i32.add
+        local.get $0
+        i32.store
+        local.get $0
+        i32.const 1
+        i32.add
+        local.tee $0
+        local.get $3
+        i32.ne
+        br_if 0 (;@2;)
+      end
+      local.get $3
+      local.set $0
+      i32.const 30
+      local.set $6
+      loop $label$14 ;; label = @2
+        block $label$15 ;; label = @3
+          i32.const 0
+          local.set $2
+          loop $label$16 ;; label = @4
+            local.get $10
+            local.get $4
+            local.get $2
+            i32.const 2
+            i32.shl
+            i32.add
+            i32.load
+            i32.const 1
+            i32.add
+            i32.store
+            i32.const 1174
+            local.get $10
+            call $33
+            drop
+            local.get $2
+            i32.const 1
+            i32.add
+            local.tee $2
+            local.get $3
+            i32.ne
+            br_if 0 (;@4;)
+          end
+          i32.const 10
+          call $34
+          drop
+          local.get $0
+          i32.const 1
+          i32.gt_s
+          if ;; label = @4
+            loop $label$18 ;; label = @5
+              local.get $8
+              local.get $0
+              i32.const -1
+              i32.add
+              local.tee $2
+              i32.const 2
+              i32.shl
+              i32.add
+              local.get $0
+              i32.store
+              local.get $2
+              i32.const 1
+              i32.gt_s
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $2
+                  local.set $0
+                  br 2 (;@5;)
+                end
+              else
+                i32.const 1
+                local.set $0
+              end
+            end
+          else
+            local.get $0
+            local.get $3
+            i32.eq
+            br_if 1 (;@3;)
+          end
+          local.get $6
+          i32.const -1
+          i32.add
+          local.set $6
+          loop $label$22 ;; label = @4
+            block $label$23 ;; label = @5
+              local.get $4
+              i32.load
+              local.set $9
+              local.get $0
+              i32.const 0
+              i32.gt_s
+              if ;; label = @6
+                block ;; label = @7
+                  i32.const 0
+                  local.set $2
+                  loop $label$25 ;; label = @8
+                    local.get $4
+                    local.get $2
+                    i32.const 2
+                    i32.shl
+                    i32.add
+                    local.get $4
+                    local.get $2
+                    i32.const 1
+                    i32.add
+                    local.tee $2
+                    i32.const 2
+                    i32.shl
+                    i32.add
+                    i32.load
+                    i32.store
+                    local.get $2
+                    local.get $0
+                    i32.lt_s
+                    br_if 0 (;@8;)
+                    local.get $0
+                    local.set $2
+                  end
+                end
+              else
+                i32.const 0
+                local.set $2
+              end
+              local.get $4
+              local.get $2
+              i32.const 2
+              i32.shl
+              i32.add
+              local.get $9
+              i32.store
+              local.get $8
+              local.get $0
+              i32.const 2
+              i32.shl
+              i32.add
+              local.tee $9
+              i32.load
+              local.set $2
+              local.get $9
+              local.get $2
+              i32.const -1
+              i32.add
+              i32.store
+              local.get $2
+              i32.const 1
+              i32.gt_s
+              br_if 0 (;@5;)
+              local.get $0
+              i32.const 1
+              i32.add
+              local.tee $0
+              local.get $3
+              i32.ne
+              br_if 1 (;@4;)
+              br 2 (;@3;)
+            end
+          end
+          local.get $6
+          br_if 1 (;@2;)
+        end
+      end
+      local.get $4
+      call $36
+      local.get $8
+      call $36
+      local.get $1
+      if ;; label = @2
+        block ;; label = @3
+          i32.const 0
+          local.set $0
+          loop $label$28 ;; label = @4
+            local.get $0
+            local.get $1
+            call $7
+            local.tee $2
+            i32.lt_s
+            if ;; label = @5
+              local.get $2
+              local.set $0
+            end
+            local.get $1
+            i32.load offset=8
+            local.set $2
+            local.get $1
+            call $36
+            local.get $2
+            if ;; label = @5
+              block ;; label = @6
+                local.get $2
+                local.set $1
+                br 2 (;@4;)
+              end
+            end
+          end
+        end
+      else
+        i32.const 0
+        local.set $0
+      end
+      local.get $7
+      local.get $3
+      i32.store
+      local.get $7
+      local.get $0
+      i32.store offset=4
+      i32.const 1151
+      local.get $7
+      call $33
+      drop
+      local.get $5
+      global.set $global$1
+      i32.const 0
+    end
+  )
+  (func $9 (;22;) (type $1) (param $0 i32) (result i32)
+    (local $1 i32) (local $2 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $1
+      global.get $global$1
+      i32.const 16
+      i32.add
+      global.set $global$1
+      local.get $1
+      local.tee $2
+      local.get $0
+      i32.load offset=60
+      i32.store
+      i32.const 6
+      local.get $2
+      call $fimport$8
+      call $11
+      local.set $0
+      local.get $1
+      global.set $global$1
+      local.get $0
+    end
+  )
+  (func $10 (;23;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32) (local $4 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $4
+      global.get $global$1
+      i32.const 32
+      i32.add
+      global.set $global$1
+      local.get $4
+      local.tee $3
+      local.get $0
+      i32.load offset=60
+      i32.store
+      local.get $3
+      i32.const 0
+      i32.store offset=4
+      local.get $3
+      local.get $1
+      i32.store offset=8
+      local.get $3
+      local.get $4
+      i32.const 20
+      i32.add
+      local.tee $0
+      i32.store offset=12
+      local.get $3
+      local.get $2
+      i32.store offset=16
+      i32.const 140
+      local.get $3
+      call $fimport$14
+      call $11
+      i32.const 0
+      i32.lt_s
+      if (result i32) ;; label = @2
+        block (result i32) ;; label = @3
+          local.get $0
+          i32.const -1
+          i32.store
+          i32.const -1
+        end
+      else
+        local.get $0
+        i32.load
+      end
+      local.set $0
+      local.get $4
+      global.set $global$1
+      local.get $0
+    end
+  )
+  (func $11 (;24;) (type $1) (param $0 i32) (result i32)
+    local.get $0
+    i32.const -4096
+    i32.gt_u
+    if (result i32) ;; label = @1
+      block (result i32) ;; label = @2
+        call $12
+        i32.const 0
+        local.get $0
+        i32.sub
+        i32.store
+        i32.const -1
+      end
+    else
+      local.get $0
+    end
+  )
+  (func $12 (;25;) (type $3) (result i32)
+    i32.const 3648
+  )
+  (func $13 (;26;) (type $2) (param $0 i32)
+    nop
+  )
+  (func $14 (;27;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32) (local $4 i32) (local $5 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $4
+      global.get $global$1
+      i32.const 80
+      i32.add
+      global.set $global$1
+      local.get $4
+      local.set $3
+      local.get $4
+      i32.const 12
+      i32.add
+      local.set $5
+      local.get $0
+      i32.const 3
+      i32.store offset=36
+      local.get $0
+      i32.load
+      i32.const 64
+      i32.and
+      i32.eqz
+      if ;; label = @2
+        block ;; label = @3
+          local.get $3
+          local.get $0
+          i32.load offset=60
+          i32.store
+          local.get $3
+          i32.const 21505
+          i32.store offset=4
+          local.get $3
+          local.get $5
+          i32.store offset=8
+          i32.const 54
+          local.get $3
+          call $fimport$13
+          if ;; label = @4
+            local.get $0
+            i32.const -1
+            i32.store8 offset=75
+          end
+        end
+      end
+      local.get $0
+      local.get $1
+      local.get $2
+      call $15
+      local.set $0
+      local.get $4
+      global.set $global$1
+      local.get $0
+    end
+  )
+  (func $15 (;28;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $8
+      global.get $global$1
+      i32.const 48
+      i32.add
+      global.set $global$1
+      local.get $8
+      i32.const 16
+      i32.add
+      local.set $9
+      local.get $8
+      local.set $10
+      local.get $8
+      i32.const 32
+      i32.add
+      local.tee $3
+      local.get $0
+      i32.const 28
+      i32.add
+      local.tee $6
+      i32.load
+      local.tee $4
+      i32.store
+      local.get $3
+      local.get $0
+      i32.const 20
+      i32.add
+      local.tee $11
+      i32.load
+      local.get $4
+      i32.sub
+      local.tee $5
+      i32.store offset=4
+      local.get $3
+      local.get $1
+      i32.store offset=8
+      local.get $3
+      local.get $2
+      i32.store offset=12
+      local.get $0
+      i32.const 60
+      i32.add
+      local.set $13
+      local.get $0
+      i32.const 44
+      i32.add
+      local.set $14
+      local.get $3
+      local.set $1
+      i32.const 2
+      local.set $4
+      local.get $5
+      local.get $2
+      i32.add
+      local.set $12
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          block $label$4 ;; label = @4
+            loop $label$5 ;; label = @5
+              i32.const 3604
+              i32.load
+              if ;; label = @6
+                block ;; label = @7
+                  i32.const 1
+                  local.get $0
+                  call $fimport$9
+                  local.get $10
+                  local.get $13
+                  i32.load
+                  i32.store
+                  local.get $10
+                  local.get $1
+                  i32.store offset=4
+                  local.get $10
+                  local.get $4
+                  i32.store offset=8
+                  i32.const 146
+                  local.get $10
+                  call $fimport$15
+                  call $11
+                  local.set $3
+                  i32.const 0
+                  call $fimport$7
+                end
+              else
+                block ;; label = @7
+                  local.get $9
+                  local.get $13
+                  i32.load
+                  i32.store
+                  local.get $9
+                  local.get $1
+                  i32.store offset=4
+                  local.get $9
+                  local.get $4
+                  i32.store offset=8
+                  i32.const 146
+                  local.get $9
+                  call $fimport$15
+                  call $11
+                  local.set $3
+                end
+              end
+              local.get $12
+              local.get $3
+              i32.eq
+              br_if 1 (;@4;)
+              local.get $3
+              i32.const 0
+              i32.lt_s
+              br_if 2 (;@3;)
+              local.get $3
+              local.get $1
+              i32.load offset=4
+              local.tee $5
+              i32.gt_u
+              if (result i32) ;; label = @6
+                block (result i32) ;; label = @7
+                  local.get $6
+                  local.get $14
+                  i32.load
+                  local.tee $7
+                  i32.store
+                  local.get $11
+                  local.get $7
+                  i32.store
+                  local.get $1
+                  i32.load offset=12
+                  local.set $7
+                  local.get $1
+                  i32.const 8
+                  i32.add
+                  local.set $1
+                  local.get $4
+                  i32.const -1
+                  i32.add
+                  local.set $4
+                  local.get $3
+                  local.get $5
+                  i32.sub
+                end
+              else
+                local.get $4
+                i32.const 2
+                i32.eq
+                if (result i32) ;; label = @7
+                  block (result i32) ;; label = @8
+                    local.get $6
+                    local.get $6
+                    i32.load
+                    local.get $3
+                    i32.add
+                    i32.store
+                    local.get $5
+                    local.set $7
+                    i32.const 2
+                    local.set $4
+                    local.get $3
+                  end
+                else
+                  block (result i32) ;; label = @8
+                    local.get $5
+                    local.set $7
+                    local.get $3
+                  end
+                end
+              end
+              local.set $5
+              local.get $1
+              local.get $1
+              i32.load
+              local.get $5
+              i32.add
+              i32.store
+              local.get $1
+              local.get $7
+              local.get $5
+              i32.sub
+              i32.store offset=4
+              local.get $12
+              local.get $3
+              i32.sub
+              local.set $12
+              br 0 (;@5;)
+            end
+          end
+          local.get $0
+          local.get $14
+          i32.load
+          local.tee $1
+          local.get $0
+          i32.load offset=48
+          i32.add
+          i32.store offset=16
+          local.get $6
+          local.get $1
+          i32.store
+          local.get $11
+          local.get $1
+          i32.store
+          br 1 (;@2;)
+        end
+        local.get $0
+        i32.const 0
+        i32.store offset=16
+        local.get $6
+        i32.const 0
+        i32.store
+        local.get $11
+        i32.const 0
+        i32.store
+        local.get $0
+        local.get $0
+        i32.load
+        i32.const 32
+        i32.or
+        i32.store
+        local.get $4
+        i32.const 2
+        i32.eq
+        if (result i32) ;; label = @3
+          i32.const 0
+        else
+          local.get $2
+          local.get $1
+          i32.load offset=4
+          i32.sub
+        end
+        local.set $2
+      end
+      local.get $8
+      global.set $global$1
+      local.get $2
+    end
+  )
+  (func $16 (;29;) (type $2) (param $0 i32)
+    local.get $0
+    i32.load offset=68
+    i32.eqz
+    if ;; label = @1
+      local.get $0
+      call $13
+    end
+  )
+  (func $17 (;30;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32) (local $4 i32) (local $5 i32)
+    block $label$1 (result i32) ;; label = @1
+      local.get $1
+      i32.const 255
+      i32.and
+      local.set $5
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          block $label$4 ;; label = @4
+            local.get $2
+            i32.const 0
+            i32.ne
+            local.tee $4
+            local.get $0
+            i32.const 3
+            i32.and
+            i32.const 0
+            i32.ne
+            i32.and
+            if ;; label = @5
+              block ;; label = @6
+                local.get $1
+                i32.const 255
+                i32.and
+                local.set $4
+                local.get $2
+                local.set $3
+                local.get $0
+                local.set $2
+                loop $label$6 ;; label = @7
+                  local.get $2
+                  i32.load8_s
+                  local.get $4
+                  i32.const 24
+                  i32.shl
+                  i32.const 24
+                  i32.shr_s
+                  i32.eq
+                  if ;; label = @8
+                    block ;; label = @9
+                      local.get $3
+                      local.set $0
+                      br 6 (;@3;)
+                    end
+                  end
+                  local.get $3
+                  i32.const -1
+                  i32.add
+                  local.tee $3
+                  i32.const 0
+                  i32.ne
+                  local.tee $0
+                  local.get $2
+                  i32.const 1
+                  i32.add
+                  local.tee $2
+                  i32.const 3
+                  i32.and
+                  i32.const 0
+                  i32.ne
+                  i32.and
+                  br_if 0 (;@7;)
+                  br 3 (;@4;)
+                end
+              end
+            else
+              block ;; label = @6
+                local.get $2
+                local.set $3
+                local.get $0
+                local.set $2
+                local.get $4
+                local.set $0
+              end
+            end
+          end
+          local.get $0
+          if ;; label = @4
+            block ;; label = @5
+              local.get $3
+              local.set $0
+              br 2 (;@3;)
+            end
+          else
+            i32.const 0
+            local.set $0
+          end
+          br 1 (;@2;)
+        end
+        local.get $2
+        i32.load8_s
+        local.get $1
+        i32.const 255
+        i32.and
+        local.tee $1
+        i32.const 24
+        i32.shl
+        i32.const 24
+        i32.shr_s
+        i32.ne
+        if ;; label = @3
+          block ;; label = @4
+            local.get $5
+            i32.const 16843009
+            i32.mul
+            local.set $3
+            block $label$12 ;; label = @5
+              block $label$13 ;; label = @6
+                local.get $0
+                i32.const 3
+                i32.le_u
+                br_if 0 (;@6;)
+                loop $label$14 ;; label = @7
+                  local.get $2
+                  i32.load
+                  local.get $3
+                  i32.xor
+                  local.tee $4
+                  i32.const -2139062144
+                  i32.and
+                  i32.const -2139062144
+                  i32.xor
+                  local.get $4
+                  i32.const -16843009
+                  i32.add
+                  i32.and
+                  i32.eqz
+                  if ;; label = @8
+                    block ;; label = @9
+                      local.get $2
+                      i32.const 4
+                      i32.add
+                      local.set $2
+                      local.get $0
+                      i32.const -4
+                      i32.add
+                      local.tee $0
+                      i32.const 3
+                      i32.gt_u
+                      br_if 2 (;@7;)
+                      br 3 (;@6;)
+                    end
+                  end
+                end
+                br 1 (;@5;)
+              end
+              local.get $0
+              i32.eqz
+              if ;; label = @6
+                block ;; label = @7
+                  i32.const 0
+                  local.set $0
+                  br 5 (;@2;)
+                end
+              end
+            end
+            loop $label$17 ;; label = @5
+              local.get $2
+              i32.load8_s
+              local.get $1
+              i32.const 24
+              i32.shl
+              i32.const 24
+              i32.shr_s
+              i32.eq
+              br_if 3 (;@2;)
+              local.get $2
+              i32.const 1
+              i32.add
+              local.set $2
+              local.get $0
+              i32.const -1
+              i32.add
+              local.tee $0
+              br_if 0 (;@5;)
+              i32.const 0
+              local.set $0
+            end
+          end
+        end
+      end
+      local.get $0
+      if (result i32) ;; label = @2
+        local.get $2
+      else
+        i32.const 0
+      end
+    end
+  )
+  (func $18 (;31;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $4
+      global.get $global$1
+      i32.const 224
+      i32.add
+      global.set $global$1
+      local.get $4
+      i32.const 136
+      i32.add
+      local.set $5
+      local.get $4
+      i32.const 80
+      i32.add
+      local.tee $3
+      i64.const 0
+      i64.store align=4
+      local.get $3
+      i64.const 0
+      i64.store offset=8 align=4
+      local.get $3
+      i64.const 0
+      i64.store offset=16 align=4
+      local.get $3
+      i64.const 0
+      i64.store offset=24 align=4
+      local.get $3
+      i64.const 0
+      i64.store offset=32 align=4
+      local.get $4
+      i32.const 120
+      i32.add
+      local.tee $6
+      local.get $2
+      i32.load
+      i32.store
+      i32.const 0
+      local.get $1
+      local.get $6
+      local.get $4
+      local.tee $2
+      local.get $3
+      call $19
+      i32.const 0
+      i32.lt_s
+      if ;; label = @2
+        i32.const -1
+        local.set $1
+      else
+        block ;; label = @3
+          local.get $0
+          i32.load offset=76
+          i32.const -1
+          i32.gt_s
+          if (result i32) ;; label = @4
+            local.get $0
+            call $20
+          else
+            i32.const 0
+          end
+          local.set $12
+          local.get $0
+          i32.load
+          local.set $7
+          local.get $0
+          i32.load8_s offset=74
+          i32.const 1
+          i32.lt_s
+          if ;; label = @4
+            local.get $0
+            local.get $7
+            i32.const -33
+            i32.and
+            i32.store
+          end
+          local.get $0
+          i32.const 48
+          i32.add
+          local.tee $8
+          i32.load
+          if ;; label = @4
+            local.get $0
+            local.get $1
+            local.get $6
+            local.get $2
+            local.get $3
+            call $19
+            local.set $1
+          else
+            block ;; label = @5
+              local.get $0
+              i32.const 44
+              i32.add
+              local.tee $9
+              i32.load
+              local.set $10
+              local.get $9
+              local.get $5
+              i32.store
+              local.get $0
+              i32.const 28
+              i32.add
+              local.tee $13
+              local.get $5
+              i32.store
+              local.get $0
+              i32.const 20
+              i32.add
+              local.tee $11
+              local.get $5
+              i32.store
+              local.get $8
+              i32.const 80
+              i32.store
+              local.get $0
+              i32.const 16
+              i32.add
+              local.tee $14
+              local.get $5
+              i32.const 80
+              i32.add
+              i32.store
+              local.get $0
+              local.get $1
+              local.get $6
+              local.get $2
+              local.get $3
+              call $19
+              local.set $1
+              local.get $10
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $0
+                  i32.const 0
+                  i32.const 0
+                  local.get $0
+                  i32.load offset=36
+                  i32.const 3
+                  i32.and
+                  i32.const 2
+                  i32.add
+                  call_indirect (type $0)
+                  drop
+                  local.get $11
+                  i32.load
+                  i32.eqz
+                  if ;; label = @8
+                    i32.const -1
+                    local.set $1
+                  end
+                  local.get $9
+                  local.get $10
+                  i32.store
+                  local.get $8
+                  i32.const 0
+                  i32.store
+                  local.get $14
+                  i32.const 0
+                  i32.store
+                  local.get $13
+                  i32.const 0
+                  i32.store
+                  local.get $11
+                  i32.const 0
+                  i32.store
+                end
+              end
+            end
+          end
+          local.get $0
+          local.get $0
+          i32.load
+          local.tee $2
+          local.get $7
+          i32.const 32
+          i32.and
+          i32.or
+          i32.store
+          local.get $12
+          if ;; label = @4
+            local.get $0
+            call $13
+          end
+          local.get $2
+          i32.const 32
+          i32.and
+          if ;; label = @4
+            i32.const -1
+            local.set $1
+          end
+        end
+      end
+      local.get $4
+      global.set $global$1
+      local.get $1
+    end
+  )
+  (func $19 (;32;) (type $7) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32) (result i32)
+    (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32) (local $15 i32) (local $16 i32) (local $17 i32) (local $18 i32) (local $19 i32) (local $20 i32) (local $21 i32) (local $22 i32) (local $23 i32) (local $24 i32) (local $25 i32) (local $26 i32) (local $27 i32) (local $28 i32) (local $29 i32) (local $30 i32) (local $31 i32) (local $32 i32) (local $33 i32) (local $34 i32) (local $35 i32) (local $36 i32) (local $37 i32) (local $38 i32) (local $39 i32) (local $40 i32) (local $41 i32) (local $42 i32) (local $43 i32) (local $44 i32) (local $45 i32) (local $46 i32) (local $47 i32) (local $48 i32) (local $49 i32) (local $50 i64) (local $51 i64) (local $52 f64) (local $53 f64)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $23
+      global.get $global$1
+      i32.const 624
+      i32.add
+      global.set $global$1
+      local.get $23
+      i32.const 16
+      i32.add
+      local.set $20
+      local.get $23
+      local.set $16
+      local.get $23
+      i32.const 528
+      i32.add
+      local.set $36
+      local.get $0
+      i32.const 0
+      i32.ne
+      local.set $30
+      local.get $23
+      i32.const 536
+      i32.add
+      local.tee $17
+      i32.const 40
+      i32.add
+      local.tee $21
+      local.set $38
+      local.get $17
+      i32.const 39
+      i32.add
+      local.set $39
+      local.get $23
+      i32.const 8
+      i32.add
+      local.tee $37
+      i32.const 4
+      i32.add
+      local.set $42
+      i32.const 0
+      local.get $23
+      i32.const 588
+      i32.add
+      local.tee $19
+      local.tee $27
+      i32.sub
+      local.set $43
+      local.get $23
+      i32.const 576
+      i32.add
+      local.tee $17
+      i32.const 12
+      i32.add
+      local.set $33
+      local.get $17
+      i32.const 11
+      i32.add
+      local.set $40
+      local.get $33
+      local.tee $28
+      local.get $27
+      i32.sub
+      local.set $44
+      i32.const -2
+      local.get $27
+      i32.sub
+      local.set $45
+      local.get $28
+      i32.const 2
+      i32.add
+      local.set $46
+      local.get $23
+      i32.const 24
+      i32.add
+      local.tee $47
+      i32.const 288
+      i32.add
+      local.set $48
+      local.get $19
+      i32.const 9
+      i32.add
+      local.tee $31
+      local.set $41
+      local.get $19
+      i32.const 8
+      i32.add
+      local.set $34
+      i32.const 0
+      local.set $15
+      i32.const 0
+      local.set $10
+      i32.const 0
+      local.set $17
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          loop $label$4 ;; label = @4
+            block $label$5 ;; label = @5
+              local.get $15
+              i32.const -1
+              i32.gt_s
+              if ;; label = @6
+                local.get $10
+                i32.const 2147483647
+                local.get $15
+                i32.sub
+                i32.gt_s
+                if (result i32) ;; label = @7
+                  block (result i32) ;; label = @8
+                    call $12
+                    i32.const 75
+                    i32.store
+                    i32.const -1
+                  end
+                else
+                  local.get $10
+                  local.get $15
+                  i32.add
+                end
+                local.set $15
+              end
+              local.get $1
+              i32.load8_s
+              local.tee $5
+              i32.const 24
+              i32.shl
+              i32.const 24
+              i32.shr_s
+              i32.eqz
+              br_if 2 (;@3;)
+              local.get $1
+              local.set $11
+              block $label$9 ;; label = @6
+                block $label$10 ;; label = @7
+                  loop $label$11 ;; label = @8
+                    block $label$12 ;; label = @9
+                      block $label$13 ;; label = @10
+                        block $label$14 ;; label = @11
+                          block $label$15 ;; label = @12
+                            local.get $5
+                            i32.const 24
+                            i32.shl
+                            i32.const 24
+                            i32.shr_s
+                            i32.const 0
+                            i32.sub
+                            br_table 1 (;@11;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 0 (;@12;) 2 (;@10;)
+                          end
+                          local.get $11
+                          local.set $5
+                          br 4 (;@7;)
+                        end
+                        local.get $11
+                        local.set $5
+                        br 1 (;@9;)
+                      end
+                      local.get $11
+                      i32.const 1
+                      i32.add
+                      local.tee $11
+                      i32.load8_s
+                      local.set $5
+                      br 1 (;@8;)
+                    end
+                  end
+                  br 1 (;@6;)
+                end
+                loop $label$16 ;; label = @7
+                  local.get $5
+                  i32.load8_s offset=1
+                  i32.const 37
+                  i32.ne
+                  br_if 1 (;@6;)
+                  local.get $11
+                  i32.const 1
+                  i32.add
+                  local.set $11
+                  local.get $5
+                  i32.const 2
+                  i32.add
+                  local.tee $5
+                  i32.load8_s
+                  i32.const 37
+                  i32.eq
+                  br_if 0 (;@7;)
+                end
+              end
+              local.get $11
+              local.get $1
+              i32.sub
+              local.set $10
+              local.get $30
+              if ;; label = @6
+                local.get $0
+                i32.load
+                i32.const 32
+                i32.and
+                i32.eqz
+                if ;; label = @7
+                  local.get $1
+                  local.get $10
+                  local.get $0
+                  call $21
+                  drop
+                end
+              end
+              local.get $10
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $5
+                  local.set $1
+                  br 3 (;@4;)
+                end
+              end
+              local.get $5
+              i32.const 1
+              i32.add
+              local.tee $11
+              i32.load8_s
+              local.tee $10
+              i32.const 24
+              i32.shl
+              i32.const 24
+              i32.shr_s
+              i32.const -48
+              i32.add
+              local.tee $9
+              i32.const 10
+              i32.lt_u
+              if (result i32) ;; label = @6
+                block (result i32) ;; label = @7
+                  local.get $5
+                  i32.const 3
+                  i32.add
+                  local.set $10
+                  local.get $5
+                  i32.load8_s offset=2
+                  i32.const 36
+                  i32.eq
+                  local.tee $12
+                  if ;; label = @8
+                    local.get $10
+                    local.set $11
+                  end
+                  local.get $12
+                  if ;; label = @8
+                    i32.const 1
+                    local.set $17
+                  end
+                  local.get $11
+                  i32.load8_s
+                  local.set $5
+                  local.get $12
+                  i32.eqz
+                  if ;; label = @8
+                    i32.const -1
+                    local.set $9
+                  end
+                  local.get $17
+                end
+              else
+                block (result i32) ;; label = @7
+                  local.get $10
+                  local.set $5
+                  i32.const -1
+                  local.set $9
+                  local.get $17
+                end
+              end
+              local.set $10
+              block $label$25 ;; label = @6
+                local.get $5
+                i32.const 24
+                i32.shl
+                i32.const 24
+                i32.shr_s
+                i32.const -32
+                i32.add
+                local.tee $12
+                i32.const 32
+                i32.lt_u
+                if ;; label = @7
+                  block ;; label = @8
+                    i32.const 0
+                    local.set $17
+                    loop $label$27 ;; label = @9
+                      i32.const 1
+                      local.get $12
+                      i32.shl
+                      i32.const 75913
+                      i32.and
+                      i32.eqz
+                      br_if 3 (;@6;)
+                      i32.const 1
+                      local.get $5
+                      i32.const 24
+                      i32.shl
+                      i32.const 24
+                      i32.shr_s
+                      i32.const -32
+                      i32.add
+                      i32.shl
+                      local.get $17
+                      i32.or
+                      local.set $17
+                      local.get $11
+                      i32.const 1
+                      i32.add
+                      local.tee $11
+                      i32.load8_s
+                      local.tee $5
+                      i32.const 24
+                      i32.shl
+                      i32.const 24
+                      i32.shr_s
+                      i32.const -32
+                      i32.add
+                      local.tee $12
+                      i32.const 32
+                      i32.lt_u
+                      br_if 0 (;@9;)
+                    end
+                  end
+                else
+                  i32.const 0
+                  local.set $17
+                end
+              end
+              block $label$29 ;; label = @6
+                local.get $5
+                i32.const 24
+                i32.shl
+                i32.const 24
+                i32.shr_s
+                i32.const 42
+                i32.eq
+                if ;; label = @7
+                  block ;; label = @8
+                    block $label$31 (result i32) ;; label = @9
+                      block $label$32 ;; label = @10
+                        local.get $11
+                        i32.const 1
+                        i32.add
+                        local.tee $7
+                        i32.load8_s
+                        local.tee $5
+                        i32.const 24
+                        i32.shl
+                        i32.const 24
+                        i32.shr_s
+                        i32.const -48
+                        i32.add
+                        local.tee $12
+                        i32.const 10
+                        i32.ge_u
+                        br_if 0 (;@10;)
+                        local.get $11
+                        i32.load8_s offset=2
+                        i32.const 36
+                        i32.ne
+                        br_if 0 (;@10;)
+                        local.get $4
+                        local.get $12
+                        i32.const 2
+                        i32.shl
+                        i32.add
+                        i32.const 10
+                        i32.store
+                        i32.const 1
+                        local.set $8
+                        local.get $3
+                        local.get $7
+                        i32.load8_s
+                        i32.const -48
+                        i32.add
+                        i32.const 3
+                        i32.shl
+                        i32.add
+                        i64.load
+                        i32.wrap_i64
+                        local.set $10
+                        local.get $11
+                        i32.const 3
+                        i32.add
+                        br 1 (;@9;)
+                      end
+                      local.get $10
+                      if ;; label = @10
+                        block ;; label = @11
+                          i32.const -1
+                          local.set $15
+                          br 6 (;@5;)
+                        end
+                      end
+                      local.get $30
+                      i32.eqz
+                      if ;; label = @10
+                        block ;; label = @11
+                          local.get $17
+                          local.set $12
+                          i32.const 0
+                          local.set $17
+                          local.get $7
+                          local.set $11
+                          i32.const 0
+                          local.set $10
+                          br 5 (;@6;)
+                        end
+                      end
+                      local.get $2
+                      i32.load
+                      i32.const 3
+                      i32.add
+                      i32.const -4
+                      i32.and
+                      local.tee $11
+                      i32.load
+                      local.set $10
+                      local.get $2
+                      local.get $11
+                      i32.const 4
+                      i32.add
+                      i32.store
+                      i32.const 0
+                      local.set $8
+                      local.get $7
+                    end
+                    local.set $11
+                    local.get $17
+                    i32.const 8192
+                    i32.or
+                    local.set $12
+                    i32.const 0
+                    local.get $10
+                    i32.sub
+                    local.set $7
+                    local.get $11
+                    i32.load8_s
+                    local.set $5
+                    local.get $10
+                    i32.const 0
+                    i32.lt_s
+                    local.tee $6
+                    i32.eqz
+                    if ;; label = @9
+                      local.get $17
+                      local.set $12
+                    end
+                    local.get $8
+                    local.set $17
+                    local.get $6
+                    if ;; label = @9
+                      local.get $7
+                      local.set $10
+                    end
+                  end
+                else
+                  local.get $5
+                  i32.const 24
+                  i32.shl
+                  i32.const 24
+                  i32.shr_s
+                  i32.const -48
+                  i32.add
+                  local.tee $12
+                  i32.const 10
+                  i32.lt_u
+                  if ;; label = @8
+                    block ;; label = @9
+                      i32.const 0
+                      local.set $7
+                      local.get $12
+                      local.set $5
+                      loop $label$39 ;; label = @10
+                        local.get $7
+                        i32.const 10
+                        i32.mul
+                        local.get $5
+                        i32.add
+                        local.set $7
+                        local.get $11
+                        i32.const 1
+                        i32.add
+                        local.tee $11
+                        i32.load8_s
+                        local.tee $12
+                        i32.const 24
+                        i32.shl
+                        i32.const 24
+                        i32.shr_s
+                        i32.const -48
+                        i32.add
+                        local.tee $5
+                        i32.const 10
+                        i32.lt_u
+                        br_if 0 (;@10;)
+                      end
+                      local.get $7
+                      i32.const 0
+                      i32.lt_s
+                      if ;; label = @10
+                        block ;; label = @11
+                          i32.const -1
+                          local.set $15
+                          br 6 (;@5;)
+                        end
+                      else
+                        block ;; label = @11
+                          local.get $12
+                          local.set $5
+                          local.get $17
+                          local.set $12
+                          local.get $10
+                          local.set $17
+                          local.get $7
+                          local.set $10
+                        end
+                      end
+                    end
+                  else
+                    block ;; label = @9
+                      local.get $17
+                      local.set $12
+                      local.get $10
+                      local.set $17
+                      i32.const 0
+                      local.set $10
+                    end
+                  end
+                end
+              end
+              block $label$43 ;; label = @6
+                local.get $5
+                i32.const 24
+                i32.shl
+                i32.const 24
+                i32.shr_s
+                i32.const 46
+                i32.eq
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $11
+                    i32.const 1
+                    i32.add
+                    local.tee $7
+                    i32.load8_s
+                    local.tee $5
+                    i32.const 24
+                    i32.shl
+                    i32.const 24
+                    i32.shr_s
+                    i32.const 42
+                    i32.ne
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $5
+                        i32.const 24
+                        i32.shl
+                        i32.const 24
+                        i32.shr_s
+                        i32.const -48
+                        i32.add
+                        local.tee $5
+                        i32.const 10
+                        i32.lt_u
+                        if ;; label = @11
+                          block ;; label = @12
+                            local.get $7
+                            local.set $11
+                            i32.const 0
+                            local.set $7
+                          end
+                        else
+                          block ;; label = @12
+                            i32.const 0
+                            local.set $5
+                            local.get $7
+                            local.set $11
+                            br 6 (;@6;)
+                          end
+                        end
+                        loop $label$48 ;; label = @11
+                          local.get $7
+                          i32.const 10
+                          i32.mul
+                          local.get $5
+                          i32.add
+                          local.set $5
+                          local.get $11
+                          i32.const 1
+                          i32.add
+                          local.tee $11
+                          i32.load8_s
+                          i32.const -48
+                          i32.add
+                          local.tee $8
+                          i32.const 10
+                          i32.ge_u
+                          br_if 5 (;@6;)
+                          local.get $5
+                          local.set $7
+                          local.get $8
+                          local.set $5
+                          br 0 (;@11;)
+                        end
+                      end
+                    end
+                    local.get $11
+                    i32.const 2
+                    i32.add
+                    local.tee $7
+                    i32.load8_s
+                    i32.const -48
+                    i32.add
+                    local.tee $5
+                    i32.const 10
+                    i32.lt_u
+                    if ;; label = @9
+                      local.get $11
+                      i32.load8_s offset=3
+                      i32.const 36
+                      i32.eq
+                      if ;; label = @10
+                        block ;; label = @11
+                          local.get $4
+                          local.get $5
+                          i32.const 2
+                          i32.shl
+                          i32.add
+                          i32.const 10
+                          i32.store
+                          local.get $3
+                          local.get $7
+                          i32.load8_s
+                          i32.const -48
+                          i32.add
+                          i32.const 3
+                          i32.shl
+                          i32.add
+                          i64.load
+                          i32.wrap_i64
+                          local.set $5
+                          local.get $11
+                          i32.const 4
+                          i32.add
+                          local.set $11
+                          br 5 (;@6;)
+                        end
+                      end
+                    end
+                    local.get $17
+                    if ;; label = @9
+                      block ;; label = @10
+                        i32.const -1
+                        local.set $15
+                        br 5 (;@5;)
+                      end
+                    end
+                    local.get $30
+                    if (result i32) ;; label = @9
+                      block (result i32) ;; label = @10
+                        local.get $2
+                        i32.load
+                        i32.const 3
+                        i32.add
+                        i32.const -4
+                        i32.and
+                        local.tee $11
+                        i32.load
+                        local.set $5
+                        local.get $2
+                        local.get $11
+                        i32.const 4
+                        i32.add
+                        i32.store
+                        local.get $7
+                      end
+                    else
+                      block (result i32) ;; label = @10
+                        i32.const 0
+                        local.set $5
+                        local.get $7
+                      end
+                    end
+                    local.set $11
+                  end
+                else
+                  i32.const -1
+                  local.set $5
+                end
+              end
+              local.get $11
+              local.set $7
+              i32.const 0
+              local.set $8
+              loop $label$55 ;; label = @6
+                local.get $7
+                i32.load8_s
+                i32.const -65
+                i32.add
+                local.tee $6
+                i32.const 57
+                i32.gt_u
+                if ;; label = @7
+                  block ;; label = @8
+                    i32.const -1
+                    local.set $15
+                    br 3 (;@5;)
+                  end
+                end
+                local.get $7
+                i32.const 1
+                i32.add
+                local.set $11
+                local.get $8
+                i32.const 58
+                i32.mul
+                i32.const 1177
+                i32.add
+                local.get $6
+                i32.add
+                i32.load8_s
+                local.tee $13
+                i32.const 255
+                i32.and
+                local.tee $6
+                i32.const -1
+                i32.add
+                i32.const 8
+                i32.lt_u
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $11
+                    local.set $7
+                    local.get $6
+                    local.set $8
+                    br 2 (;@6;)
+                  end
+                end
+              end
+              local.get $13
+              i32.const 24
+              i32.shl
+              i32.const 24
+              i32.shr_s
+              i32.eqz
+              if ;; label = @6
+                block ;; label = @7
+                  i32.const -1
+                  local.set $15
+                  br 2 (;@5;)
+                end
+              end
+              local.get $9
+              i32.const -1
+              i32.gt_s
+              local.set $14
+              block $label$59 ;; label = @6
+                block $label$60 ;; label = @7
+                  local.get $13
+                  i32.const 24
+                  i32.shl
+                  i32.const 24
+                  i32.shr_s
+                  i32.const 19
+                  i32.eq
+                  if ;; label = @8
+                    local.get $14
+                    if ;; label = @9
+                      block ;; label = @10
+                        i32.const -1
+                        local.set $15
+                        br 5 (;@5;)
+                      end
+                    else
+                      br 2 (;@7;)
+                    end
+                  else
+                    block ;; label = @9
+                      local.get $14
+                      if ;; label = @10
+                        block ;; label = @11
+                          local.get $4
+                          local.get $9
+                          i32.const 2
+                          i32.shl
+                          i32.add
+                          local.get $6
+                          i32.store
+                          local.get $16
+                          local.get $3
+                          local.get $9
+                          i32.const 3
+                          i32.shl
+                          i32.add
+                          i64.load
+                          i64.store
+                          br 4 (;@7;)
+                        end
+                      end
+                      local.get $30
+                      i32.eqz
+                      if ;; label = @10
+                        block ;; label = @11
+                          i32.const 0
+                          local.set $15
+                          br 6 (;@5;)
+                        end
+                      end
+                      local.get $16
+                      local.get $6
+                      local.get $2
+                      call $22
+                    end
+                  end
+                  br 1 (;@6;)
+                end
+                local.get $30
+                i32.eqz
+                if ;; label = @7
+                  block ;; label = @8
+                    i32.const 0
+                    local.set $10
+                    local.get $11
+                    local.set $1
+                    br 4 (;@4;)
+                  end
+                end
+              end
+              local.get $7
+              i32.load8_s
+              local.tee $7
+              i32.const -33
+              i32.and
+              local.set $9
+              local.get $8
+              i32.const 0
+              i32.ne
+              local.get $7
+              i32.const 15
+              i32.and
+              i32.const 3
+              i32.eq
+              i32.and
+              i32.eqz
+              if ;; label = @6
+                local.get $7
+                local.set $9
+              end
+              local.get $12
+              i32.const -65537
+              i32.and
+              local.set $7
+              local.get $12
+              i32.const 8192
+              i32.and
+              if ;; label = @6
+                local.get $7
+                local.set $12
+              end
+              block $label$70 ;; label = @6
+                block $label$71 ;; label = @7
+                  block $label$72 ;; label = @8
+                    block $label$73 ;; label = @9
+                      block $label$74 ;; label = @10
+                        block $label$75 ;; label = @11
+                          block $label$76 ;; label = @12
+                            block $label$77 ;; label = @13
+                              block $label$78 ;; label = @14
+                                block $label$79 ;; label = @15
+                                  block $label$80 ;; label = @16
+                                    block $label$81 ;; label = @17
+                                      block $label$82 ;; label = @18
+                                        block $label$83 ;; label = @19
+                                          block $label$84 ;; label = @20
+                                            block $label$85 ;; label = @21
+                                              block $label$86 ;; label = @22
+                                                block $label$87 ;; label = @23
+                                                  block $label$88 ;; label = @24
+                                                    block $label$89 ;; label = @25
+                                                      local.get $9
+                                                      i32.const 65
+                                                      i32.sub
+                                                      br_table 11 (;@14;) 12 (;@13;) 9 (;@16;) 12 (;@13;) 11 (;@14;) 11 (;@14;) 11 (;@14;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 10 (;@15;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 2 (;@23;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 11 (;@14;) 12 (;@13;) 6 (;@19;) 4 (;@21;) 11 (;@14;) 11 (;@14;) 11 (;@14;) 12 (;@13;) 4 (;@21;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 7 (;@18;) 0 (;@25;) 3 (;@22;) 1 (;@24;) 12 (;@13;) 12 (;@13;) 8 (;@17;) 12 (;@13;) 5 (;@20;) 12 (;@13;) 12 (;@13;) 2 (;@23;) 12 (;@13;)
+                                                    end
+                                                    block $label$90 ;; label = @25
+                                                      block $label$91 ;; label = @26
+                                                        block $label$92 ;; label = @27
+                                                          block $label$93 ;; label = @28
+                                                            block $label$94 ;; label = @29
+                                                              block $label$95 ;; label = @30
+                                                                block $label$96 ;; label = @31
+                                                                  block $label$97 ;; label = @32
+                                                                    local.get $8
+                                                                    i32.const 255
+                                                                    i32.and
+                                                                    i32.const 24
+                                                                    i32.shl
+                                                                    i32.const 24
+                                                                    i32.shr_s
+                                                                    i32.const 0
+                                                                    i32.sub
+                                                                    br_table 0 (;@32;) 1 (;@31;) 2 (;@30;) 3 (;@29;) 4 (;@28;) 7 (;@25;) 5 (;@27;) 6 (;@26;) 7 (;@25;)
+                                                                  end
+                                                                  local.get $16
+                                                                  i32.load
+                                                                  local.get $15
+                                                                  i32.store
+                                                                  i32.const 0
+                                                                  local.set $10
+                                                                  local.get $11
+                                                                  local.set $1
+                                                                  br 27 (;@4;)
+                                                                end
+                                                                local.get $16
+                                                                i32.load
+                                                                local.get $15
+                                                                i32.store
+                                                                i32.const 0
+                                                                local.set $10
+                                                                local.get $11
+                                                                local.set $1
+                                                                br 26 (;@4;)
+                                                              end
+                                                              local.get $16
+                                                              i32.load
+                                                              local.get $15
+                                                              i64.extend_i32_s
+                                                              i64.store
+                                                              i32.const 0
+                                                              local.set $10
+                                                              local.get $11
+                                                              local.set $1
+                                                              br 25 (;@4;)
+                                                            end
+                                                            local.get $16
+                                                            i32.load
+                                                            local.get $15
+                                                            i32.store16
+                                                            i32.const 0
+                                                            local.set $10
+                                                            local.get $11
+                                                            local.set $1
+                                                            br 24 (;@4;)
+                                                          end
+                                                          local.get $16
+                                                          i32.load
+                                                          local.get $15
+                                                          i32.store8
+                                                          i32.const 0
+                                                          local.set $10
+                                                          local.get $11
+                                                          local.set $1
+                                                          br 23 (;@4;)
+                                                        end
+                                                        local.get $16
+                                                        i32.load
+                                                        local.get $15
+                                                        i32.store
+                                                        i32.const 0
+                                                        local.set $10
+                                                        local.get $11
+                                                        local.set $1
+                                                        br 22 (;@4;)
+                                                      end
+                                                      local.get $16
+                                                      i32.load
+                                                      local.get $15
+                                                      i64.extend_i32_s
+                                                      i64.store
+                                                      i32.const 0
+                                                      local.set $10
+                                                      local.get $11
+                                                      local.set $1
+                                                      br 21 (;@4;)
+                                                    end
+                                                    i32.const 0
+                                                    local.set $10
+                                                    local.get $11
+                                                    local.set $1
+                                                    br 20 (;@4;)
+                                                  end
+                                                  local.get $12
+                                                  i32.const 8
+                                                  i32.or
+                                                  local.set $12
+                                                  local.get $5
+                                                  i32.const 8
+                                                  i32.le_u
+                                                  if ;; label = @24
+                                                    i32.const 8
+                                                    local.set $5
+                                                  end
+                                                  i32.const 120
+                                                  local.set $9
+                                                  br 11 (;@12;)
+                                                end
+                                                br 10 (;@12;)
+                                              end
+                                              local.get $16
+                                              i64.load
+                                              local.tee $50
+                                              i64.const 0
+                                              i64.eq
+                                              if ;; label = @22
+                                                local.get $21
+                                                local.set $7
+                                              else
+                                                block ;; label = @23
+                                                  local.get $21
+                                                  local.set $1
+                                                  loop $label$101 ;; label = @24
+                                                    local.get $1
+                                                    i32.const -1
+                                                    i32.add
+                                                    local.tee $1
+                                                    local.get $50
+                                                    i64.const 7
+                                                    i64.and
+                                                    i64.const 48
+                                                    i64.or
+                                                    i64.store8
+                                                    local.get $50
+                                                    i64.const 3
+                                                    i64.shr_u
+                                                    local.tee $50
+                                                    i64.const 0
+                                                    i64.ne
+                                                    br_if 0 (;@24;)
+                                                    local.get $1
+                                                    local.set $7
+                                                  end
+                                                end
+                                              end
+                                              local.get $12
+                                              i32.const 8
+                                              i32.and
+                                              if ;; label = @22
+                                                block ;; label = @23
+                                                  local.get $38
+                                                  local.get $7
+                                                  i32.sub
+                                                  local.tee $1
+                                                  i32.const 1
+                                                  i32.add
+                                                  local.set $8
+                                                  local.get $5
+                                                  local.get $1
+                                                  i32.le_s
+                                                  if ;; label = @24
+                                                    local.get $8
+                                                    local.set $5
+                                                  end
+                                                  i32.const 0
+                                                  local.set $6
+                                                  i32.const 1657
+                                                  local.set $8
+                                                  br 16 (;@7;)
+                                                end
+                                              else
+                                                block ;; label = @23
+                                                  i32.const 0
+                                                  local.set $6
+                                                  i32.const 1657
+                                                  local.set $8
+                                                  br 16 (;@7;)
+                                                end
+                                              end
+                                            end
+                                            local.get $16
+                                            i64.load
+                                            local.tee $50
+                                            i64.const 0
+                                            i64.lt_s
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                local.get $16
+                                                i64.const 0
+                                                local.get $50
+                                                i64.sub
+                                                local.tee $50
+                                                i64.store
+                                                i32.const 1
+                                                local.set $6
+                                                i32.const 1657
+                                                local.set $8
+                                                br 11 (;@11;)
+                                              end
+                                            end
+                                            local.get $12
+                                            i32.const 2048
+                                            i32.and
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                i32.const 1
+                                                local.set $6
+                                                i32.const 1658
+                                                local.set $8
+                                                br 11 (;@11;)
+                                              end
+                                            else
+                                              block ;; label = @22
+                                                local.get $12
+                                                i32.const 1
+                                                i32.and
+                                                local.tee $1
+                                                local.set $6
+                                                local.get $1
+                                                if (result i32) ;; label = @23
+                                                  i32.const 1659
+                                                else
+                                                  i32.const 1657
+                                                end
+                                                local.set $8
+                                                br 11 (;@11;)
+                                              end
+                                            end
+                                          end
+                                          local.get $16
+                                          i64.load
+                                          local.set $50
+                                          i32.const 0
+                                          local.set $6
+                                          i32.const 1657
+                                          local.set $8
+                                          br 8 (;@11;)
+                                        end
+                                        local.get $39
+                                        local.get $16
+                                        i64.load
+                                        i64.store8
+                                        local.get $39
+                                        local.set $1
+                                        local.get $7
+                                        local.set $12
+                                        i32.const 1
+                                        local.set $7
+                                        i32.const 0
+                                        local.set $6
+                                        i32.const 1657
+                                        local.set $8
+                                        local.get $21
+                                        local.set $5
+                                        br 12 (;@6;)
+                                      end
+                                      call $12
+                                      i32.load
+                                      call $24
+                                      local.set $1
+                                      br 7 (;@10;)
+                                    end
+                                    local.get $16
+                                    i32.load
+                                    local.tee $1
+                                    i32.eqz
+                                    if ;; label = @17
+                                      i32.const 1667
+                                      local.set $1
+                                    end
+                                    br 6 (;@10;)
+                                  end
+                                  local.get $37
+                                  local.get $16
+                                  i64.load
+                                  i64.store32
+                                  local.get $42
+                                  i32.const 0
+                                  i32.store
+                                  local.get $16
+                                  local.get $37
+                                  i32.store
+                                  local.get $37
+                                  local.set $7
+                                  i32.const -1
+                                  local.set $6
+                                  br 6 (;@9;)
+                                end
+                                local.get $16
+                                i32.load
+                                local.set $7
+                                local.get $5
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $5
+                                    local.set $6
+                                    br 7 (;@9;)
+                                  end
+                                else
+                                  block ;; label = @16
+                                    local.get $0
+                                    i32.const 32
+                                    local.get $10
+                                    i32.const 0
+                                    local.get $12
+                                    call $25
+                                    i32.const 0
+                                    local.set $1
+                                    br 8 (;@8;)
+                                  end
+                                end
+                              end
+                              local.get $16
+                              f64.load
+                              local.set $52
+                              local.get $20
+                              i32.const 0
+                              i32.store
+                              local.get $52
+                              i64.reinterpret_f64
+                              i64.const 0
+                              i64.lt_s
+                              if (result i32) ;; label = @14
+                                block (result i32) ;; label = @15
+                                  i32.const 1
+                                  local.set $24
+                                  local.get $52
+                                  f64.neg
+                                  local.set $52
+                                  i32.const 1674
+                                end
+                              else
+                                block (result i32) ;; label = @15
+                                  local.get $12
+                                  i32.const 1
+                                  i32.and
+                                  local.set $1
+                                  local.get $12
+                                  i32.const 2048
+                                  i32.and
+                                  if (result i32) ;; label = @16
+                                    block (result i32) ;; label = @17
+                                      i32.const 1
+                                      local.set $24
+                                      i32.const 1677
+                                    end
+                                  else
+                                    block (result i32) ;; label = @17
+                                      local.get $1
+                                      local.set $24
+                                      local.get $1
+                                      if (result i32) ;; label = @18
+                                        i32.const 1680
+                                      else
+                                        i32.const 1675
+                                      end
+                                    end
+                                  end
+                                end
+                              end
+                              local.set $26
+                              block $label$119 ;; label = @14
+                                local.get $52
+                                i64.reinterpret_f64
+                                i64.const 9218868437227405312
+                                i64.and
+                                i64.const 9218868437227405312
+                                i64.lt_u
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $52
+                                    local.get $20
+                                    call $27
+                                    f64.const 0x1p+1 (;=2;)
+                                    f64.mul
+                                    local.tee $52
+                                    f64.const 0x0p+0 (;=0;)
+                                    f64.ne
+                                    local.tee $1
+                                    if ;; label = @17
+                                      local.get $20
+                                      local.get $20
+                                      i32.load
+                                      i32.const -1
+                                      i32.add
+                                      i32.store
+                                    end
+                                    local.get $9
+                                    i32.const 32
+                                    i32.or
+                                    local.tee $22
+                                    i32.const 97
+                                    i32.eq
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        local.get $26
+                                        i32.const 9
+                                        i32.add
+                                        local.set $1
+                                        local.get $9
+                                        i32.const 32
+                                        i32.and
+                                        local.tee $6
+                                        if ;; label = @19
+                                          local.get $1
+                                          local.set $26
+                                        end
+                                        local.get $5
+                                        i32.const 11
+                                        i32.gt_u
+                                        i32.const 12
+                                        local.get $5
+                                        i32.sub
+                                        local.tee $1
+                                        i32.eqz
+                                        i32.or
+                                        i32.eqz
+                                        if ;; label = @19
+                                          block ;; label = @20
+                                            f64.const 0x1p+3 (;=8;)
+                                            local.set $53
+                                            loop $label$125 ;; label = @21
+                                              local.get $53
+                                              f64.const 0x1p+4 (;=16;)
+                                              f64.mul
+                                              local.set $53
+                                              local.get $1
+                                              i32.const -1
+                                              i32.add
+                                              local.tee $1
+                                              br_if 0 (;@21;)
+                                            end
+                                            local.get $26
+                                            i32.load8_s
+                                            i32.const 45
+                                            i32.eq
+                                            if (result f64) ;; label = @21
+                                              local.get $53
+                                              local.get $52
+                                              f64.neg
+                                              local.get $53
+                                              f64.sub
+                                              f64.add
+                                              f64.neg
+                                            else
+                                              local.get $52
+                                              local.get $53
+                                              f64.add
+                                              local.get $53
+                                              f64.sub
+                                            end
+                                            local.set $52
+                                          end
+                                        end
+                                        i32.const 0
+                                        local.get $20
+                                        i32.load
+                                        local.tee $7
+                                        i32.sub
+                                        local.set $1
+                                        local.get $7
+                                        i32.const 0
+                                        i32.lt_s
+                                        if (result i32) ;; label = @19
+                                          local.get $1
+                                        else
+                                          local.get $7
+                                        end
+                                        i64.extend_i32_s
+                                        local.get $33
+                                        call $23
+                                        local.tee $1
+                                        local.get $33
+                                        i32.eq
+                                        if ;; label = @19
+                                          block ;; label = @20
+                                            local.get $40
+                                            i32.const 48
+                                            i32.store8
+                                            local.get $40
+                                            local.set $1
+                                          end
+                                        end
+                                        local.get $24
+                                        i32.const 2
+                                        i32.or
+                                        local.set $13
+                                        local.get $1
+                                        i32.const -1
+                                        i32.add
+                                        local.get $7
+                                        i32.const 31
+                                        i32.shr_s
+                                        i32.const 2
+                                        i32.and
+                                        i32.const 43
+                                        i32.add
+                                        i32.store8
+                                        local.get $1
+                                        i32.const -2
+                                        i32.add
+                                        local.tee $8
+                                        local.get $9
+                                        i32.const 15
+                                        i32.add
+                                        i32.store8
+                                        local.get $5
+                                        i32.const 1
+                                        i32.lt_s
+                                        local.set $9
+                                        local.get $12
+                                        i32.const 8
+                                        i32.and
+                                        i32.eqz
+                                        local.set $14
+                                        local.get $19
+                                        local.set $1
+                                        loop $label$131 ;; label = @19
+                                          local.get $1
+                                          local.get $52
+                                          i32.trunc_f64_s
+                                          local.tee $7
+                                          i32.const 1641
+                                          i32.add
+                                          i32.load8_u
+                                          local.get $6
+                                          i32.or
+                                          i32.store8
+                                          local.get $52
+                                          local.get $7
+                                          f64.convert_i32_s
+                                          f64.sub
+                                          f64.const 0x1p+4 (;=16;)
+                                          f64.mul
+                                          local.set $52
+                                          block $label$132 (result i32) ;; label = @20
+                                            local.get $1
+                                            i32.const 1
+                                            i32.add
+                                            local.tee $7
+                                            local.get $27
+                                            i32.sub
+                                            i32.const 1
+                                            i32.eq
+                                            if (result i32) ;; label = @21
+                                              block (result i32) ;; label = @22
+                                                local.get $7
+                                                local.get $14
+                                                local.get $9
+                                                local.get $52
+                                                f64.const 0x0p+0 (;=0;)
+                                                f64.eq
+                                                i32.and
+                                                i32.and
+                                                br_if 2 (;@20;)
+                                                drop
+                                                local.get $7
+                                                i32.const 46
+                                                i32.store8
+                                                local.get $1
+                                                i32.const 2
+                                                i32.add
+                                              end
+                                            else
+                                              local.get $7
+                                            end
+                                          end
+                                          local.set $1
+                                          local.get $52
+                                          f64.const 0x0p+0 (;=0;)
+                                          f64.ne
+                                          br_if 0 (;@19;)
+                                        end
+                                        local.get $46
+                                        local.get $5
+                                        i32.add
+                                        local.get $8
+                                        local.tee $7
+                                        i32.sub
+                                        local.set $6
+                                        local.get $44
+                                        local.get $7
+                                        i32.sub
+                                        local.get $1
+                                        i32.add
+                                        local.set $9
+                                        local.get $0
+                                        i32.const 32
+                                        local.get $10
+                                        local.get $5
+                                        i32.const 0
+                                        i32.ne
+                                        local.get $45
+                                        local.get $1
+                                        i32.add
+                                        local.get $5
+                                        i32.lt_s
+                                        i32.and
+                                        if (result i32) ;; label = @19
+                                          local.get $6
+                                        else
+                                          local.get $9
+                                          local.tee $6
+                                        end
+                                        local.get $13
+                                        i32.add
+                                        local.tee $5
+                                        local.get $12
+                                        call $25
+                                        local.get $0
+                                        i32.load
+                                        i32.const 32
+                                        i32.and
+                                        i32.eqz
+                                        if ;; label = @19
+                                          local.get $26
+                                          local.get $13
+                                          local.get $0
+                                          call $21
+                                          drop
+                                        end
+                                        local.get $0
+                                        i32.const 48
+                                        local.get $10
+                                        local.get $5
+                                        local.get $12
+                                        i32.const 65536
+                                        i32.xor
+                                        call $25
+                                        local.get $1
+                                        local.get $27
+                                        i32.sub
+                                        local.set $1
+                                        local.get $0
+                                        i32.load
+                                        i32.const 32
+                                        i32.and
+                                        i32.eqz
+                                        if ;; label = @19
+                                          local.get $19
+                                          local.get $1
+                                          local.get $0
+                                          call $21
+                                          drop
+                                        end
+                                        local.get $0
+                                        i32.const 48
+                                        local.get $6
+                                        local.get $1
+                                        local.get $28
+                                        local.get $7
+                                        i32.sub
+                                        local.tee $1
+                                        i32.add
+                                        i32.sub
+                                        i32.const 0
+                                        i32.const 0
+                                        call $25
+                                        local.get $0
+                                        i32.load
+                                        i32.const 32
+                                        i32.and
+                                        i32.eqz
+                                        if ;; label = @19
+                                          local.get $8
+                                          local.get $1
+                                          local.get $0
+                                          call $21
+                                          drop
+                                        end
+                                        local.get $0
+                                        i32.const 32
+                                        local.get $10
+                                        local.get $5
+                                        local.get $12
+                                        i32.const 8192
+                                        i32.xor
+                                        call $25
+                                        local.get $5
+                                        local.get $10
+                                        i32.ge_s
+                                        if ;; label = @19
+                                          local.get $5
+                                          local.set $10
+                                        end
+                                        br 4 (;@14;)
+                                      end
+                                    end
+                                    local.get $1
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        local.get $20
+                                        local.get $20
+                                        i32.load
+                                        i32.const -28
+                                        i32.add
+                                        local.tee $6
+                                        i32.store
+                                        local.get $52
+                                        f64.const 0x1p+28 (;=268435456;)
+                                        f64.mul
+                                        local.set $52
+                                      end
+                                    else
+                                      local.get $20
+                                      i32.load
+                                      local.set $6
+                                    end
+                                    local.get $6
+                                    i32.const 0
+                                    i32.lt_s
+                                    if (result i32) ;; label = @17
+                                      local.get $47
+                                    else
+                                      local.get $48
+                                    end
+                                    local.tee $7
+                                    local.set $8
+                                    loop $label$145 ;; label = @17
+                                      local.get $8
+                                      local.get $52
+                                      i32.trunc_f64_s
+                                      local.tee $1
+                                      i32.store
+                                      local.get $8
+                                      i32.const 4
+                                      i32.add
+                                      local.set $8
+                                      local.get $52
+                                      local.get $1
+                                      f64.convert_i32_u
+                                      f64.sub
+                                      f64.const 0x1.dcd65p+29 (;=1000000000;)
+                                      f64.mul
+                                      local.tee $52
+                                      f64.const 0x0p+0 (;=0;)
+                                      f64.ne
+                                      br_if 0 (;@17;)
+                                    end
+                                    local.get $6
+                                    i32.const 0
+                                    i32.gt_s
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        local.get $7
+                                        local.set $1
+                                        loop $label$147 ;; label = @19
+                                          local.get $6
+                                          i32.const 29
+                                          i32.gt_s
+                                          if (result i32) ;; label = @20
+                                            i32.const 29
+                                          else
+                                            local.get $6
+                                          end
+                                          local.set $14
+                                          block $label$150 ;; label = @20
+                                            local.get $8
+                                            i32.const -4
+                                            i32.add
+                                            local.tee $6
+                                            local.get $1
+                                            i32.ge_u
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                local.get $14
+                                                i64.extend_i32_u
+                                                local.set $50
+                                                i32.const 0
+                                                local.set $13
+                                                loop $label$152 ;; label = @23
+                                                  local.get $6
+                                                  local.get $6
+                                                  i32.load
+                                                  i64.extend_i32_u
+                                                  local.get $50
+                                                  i64.shl
+                                                  local.get $13
+                                                  i64.extend_i32_u
+                                                  i64.add
+                                                  local.tee $51
+                                                  i64.const 1000000000
+                                                  i64.rem_u
+                                                  i64.store32
+                                                  local.get $51
+                                                  i64.const 1000000000
+                                                  i64.div_u
+                                                  i32.wrap_i64
+                                                  local.set $13
+                                                  local.get $6
+                                                  i32.const -4
+                                                  i32.add
+                                                  local.tee $6
+                                                  local.get $1
+                                                  i32.ge_u
+                                                  br_if 0 (;@23;)
+                                                end
+                                                local.get $13
+                                                i32.eqz
+                                                br_if 2 (;@20;)
+                                                local.get $1
+                                                i32.const -4
+                                                i32.add
+                                                local.tee $1
+                                                local.get $13
+                                                i32.store
+                                              end
+                                            end
+                                          end
+                                          loop $label$153 ;; label = @20
+                                            local.get $8
+                                            local.get $1
+                                            i32.gt_u
+                                            if ;; label = @21
+                                              local.get $8
+                                              i32.const -4
+                                              i32.add
+                                              local.tee $6
+                                              i32.load
+                                              i32.eqz
+                                              if ;; label = @22
+                                                block ;; label = @23
+                                                  local.get $6
+                                                  local.set $8
+                                                  br 3 (;@20;)
+                                                end
+                                              end
+                                            end
+                                          end
+                                          local.get $20
+                                          local.get $20
+                                          i32.load
+                                          local.get $14
+                                          i32.sub
+                                          local.tee $6
+                                          i32.store
+                                          local.get $6
+                                          i32.const 0
+                                          i32.gt_s
+                                          br_if 0 (;@19;)
+                                        end
+                                      end
+                                    else
+                                      local.get $7
+                                      local.set $1
+                                    end
+                                    local.get $5
+                                    i32.const 0
+                                    i32.lt_s
+                                    if (result i32) ;; label = @17
+                                      i32.const 6
+                                    else
+                                      local.get $5
+                                    end
+                                    local.set $18
+                                    local.get $6
+                                    i32.const 0
+                                    i32.lt_s
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        local.get $18
+                                        i32.const 25
+                                        i32.add
+                                        i32.const 9
+                                        i32.div_s
+                                        i32.const 1
+                                        i32.add
+                                        local.set $14
+                                        local.get $22
+                                        i32.const 102
+                                        i32.eq
+                                        local.set $25
+                                        local.get $8
+                                        local.set $5
+                                        loop $label$160 ;; label = @19
+                                          i32.const 0
+                                          local.get $6
+                                          i32.sub
+                                          local.tee $13
+                                          i32.const 9
+                                          i32.gt_s
+                                          if ;; label = @20
+                                            i32.const 9
+                                            local.set $13
+                                          end
+                                          block $label$162 ;; label = @20
+                                            local.get $1
+                                            local.get $5
+                                            i32.lt_u
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                i32.const 1
+                                                local.get $13
+                                                i32.shl
+                                                i32.const -1
+                                                i32.add
+                                                local.set $29
+                                                i32.const 1000000000
+                                                local.get $13
+                                                i32.shr_u
+                                                local.set $35
+                                                i32.const 0
+                                                local.set $6
+                                                local.get $1
+                                                local.set $8
+                                                loop $label$164 ;; label = @23
+                                                  local.get $8
+                                                  local.get $8
+                                                  i32.load
+                                                  local.tee $32
+                                                  local.get $13
+                                                  i32.shr_u
+                                                  local.get $6
+                                                  i32.add
+                                                  i32.store
+                                                  local.get $32
+                                                  local.get $29
+                                                  i32.and
+                                                  local.get $35
+                                                  i32.mul
+                                                  local.set $6
+                                                  local.get $8
+                                                  i32.const 4
+                                                  i32.add
+                                                  local.tee $8
+                                                  local.get $5
+                                                  i32.lt_u
+                                                  br_if 0 (;@23;)
+                                                end
+                                                local.get $1
+                                                i32.const 4
+                                                i32.add
+                                                local.set $8
+                                                local.get $1
+                                                i32.load
+                                                i32.eqz
+                                                if ;; label = @23
+                                                  local.get $8
+                                                  local.set $1
+                                                end
+                                                local.get $6
+                                                i32.eqz
+                                                br_if 2 (;@20;)
+                                                local.get $5
+                                                local.get $6
+                                                i32.store
+                                                local.get $5
+                                                i32.const 4
+                                                i32.add
+                                                local.set $5
+                                              end
+                                            else
+                                              block ;; label = @22
+                                                local.get $1
+                                                i32.const 4
+                                                i32.add
+                                                local.set $8
+                                                local.get $1
+                                                i32.load
+                                                i32.eqz
+                                                if ;; label = @23
+                                                  local.get $8
+                                                  local.set $1
+                                                end
+                                              end
+                                            end
+                                          end
+                                          local.get $25
+                                          if (result i32) ;; label = @20
+                                            local.get $7
+                                          else
+                                            local.get $1
+                                          end
+                                          local.tee $8
+                                          local.get $14
+                                          i32.const 2
+                                          i32.shl
+                                          i32.add
+                                          local.set $6
+                                          local.get $5
+                                          local.get $8
+                                          i32.sub
+                                          i32.const 2
+                                          i32.shr_s
+                                          local.get $14
+                                          i32.gt_s
+                                          if ;; label = @20
+                                            local.get $6
+                                            local.set $5
+                                          end
+                                          local.get $20
+                                          local.get $20
+                                          i32.load
+                                          local.get $13
+                                          i32.add
+                                          local.tee $6
+                                          i32.store
+                                          local.get $6
+                                          i32.const 0
+                                          i32.lt_s
+                                          br_if 0 (;@19;)
+                                          local.get $5
+                                          local.set $13
+                                        end
+                                      end
+                                    else
+                                      local.get $8
+                                      local.set $13
+                                    end
+                                    local.get $7
+                                    local.set $25
+                                    block $label$172 ;; label = @17
+                                      local.get $1
+                                      local.get $13
+                                      i32.lt_u
+                                      if ;; label = @18
+                                        block ;; label = @19
+                                          local.get $25
+                                          local.get $1
+                                          i32.sub
+                                          i32.const 2
+                                          i32.shr_s
+                                          i32.const 9
+                                          i32.mul
+                                          local.set $5
+                                          local.get $1
+                                          i32.load
+                                          local.tee $6
+                                          i32.const 10
+                                          i32.lt_u
+                                          br_if 2 (;@17;)
+                                          i32.const 10
+                                          local.set $8
+                                          loop $label$174 ;; label = @20
+                                            local.get $5
+                                            i32.const 1
+                                            i32.add
+                                            local.set $5
+                                            local.get $6
+                                            local.get $8
+                                            i32.const 10
+                                            i32.mul
+                                            local.tee $8
+                                            i32.ge_u
+                                            br_if 0 (;@20;)
+                                          end
+                                        end
+                                      else
+                                        i32.const 0
+                                        local.set $5
+                                      end
+                                    end
+                                    local.get $22
+                                    i32.const 103
+                                    i32.eq
+                                    local.set $29
+                                    local.get $18
+                                    i32.const 0
+                                    i32.ne
+                                    local.set $35
+                                    local.get $18
+                                    local.get $22
+                                    i32.const 102
+                                    i32.ne
+                                    if (result i32) ;; label = @17
+                                      local.get $5
+                                    else
+                                      i32.const 0
+                                    end
+                                    i32.sub
+                                    local.get $35
+                                    local.get $29
+                                    i32.and
+                                    i32.const 31
+                                    i32.shl
+                                    i32.const 31
+                                    i32.shr_s
+                                    i32.add
+                                    local.tee $8
+                                    local.get $13
+                                    local.get $25
+                                    i32.sub
+                                    i32.const 2
+                                    i32.shr_s
+                                    i32.const 9
+                                    i32.mul
+                                    i32.const -9
+                                    i32.add
+                                    i32.lt_s
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        local.get $8
+                                        i32.const 9216
+                                        i32.add
+                                        local.tee $14
+                                        i32.const 9
+                                        i32.rem_s
+                                        i32.const 1
+                                        i32.add
+                                        local.tee $8
+                                        i32.const 9
+                                        i32.lt_s
+                                        if ;; label = @19
+                                          block ;; label = @20
+                                            i32.const 10
+                                            local.set $6
+                                            loop $label$180 ;; label = @21
+                                              local.get $6
+                                              i32.const 10
+                                              i32.mul
+                                              local.set $6
+                                              local.get $8
+                                              i32.const 1
+                                              i32.add
+                                              local.tee $8
+                                              i32.const 9
+                                              i32.ne
+                                              br_if 0 (;@21;)
+                                            end
+                                          end
+                                        else
+                                          i32.const 10
+                                          local.set $6
+                                        end
+                                        local.get $7
+                                        i32.const 4
+                                        i32.add
+                                        local.get $14
+                                        i32.const 9
+                                        i32.div_s
+                                        i32.const -1024
+                                        i32.add
+                                        i32.const 2
+                                        i32.shl
+                                        i32.add
+                                        local.tee $8
+                                        i32.load
+                                        local.tee $22
+                                        local.get $6
+                                        i32.rem_u
+                                        local.set $14
+                                        block $label$182 ;; label = @19
+                                          local.get $8
+                                          i32.const 4
+                                          i32.add
+                                          local.get $13
+                                          i32.eq
+                                          local.tee $32
+                                          local.get $14
+                                          i32.eqz
+                                          i32.and
+                                          i32.eqz
+                                          if ;; label = @20
+                                            block ;; label = @21
+                                              local.get $14
+                                              local.get $6
+                                              i32.const 2
+                                              i32.div_s
+                                              local.tee $49
+                                              i32.lt_u
+                                              if (result f64) ;; label = @22
+                                                f64.const 0x1p-1 (;=0.5;)
+                                              else
+                                                local.get $32
+                                                local.get $14
+                                                local.get $49
+                                                i32.eq
+                                                i32.and
+                                                if (result f64) ;; label = @23
+                                                  f64.const 0x1p+0 (;=1;)
+                                                else
+                                                  f64.const 0x1.8p+0 (;=1.5;)
+                                                end
+                                              end
+                                              local.set $52
+                                              local.get $22
+                                              local.get $6
+                                              i32.div_u
+                                              i32.const 1
+                                              i32.and
+                                              if (result f64) ;; label = @22
+                                                f64.const 0x1.0000000000001p+53 (;=9007199254740994;)
+                                              else
+                                                f64.const 0x1p+53 (;=9007199254740992;)
+                                              end
+                                              local.set $53
+                                              block $label$190 ;; label = @22
+                                                local.get $24
+                                                if ;; label = @23
+                                                  block ;; label = @24
+                                                    local.get $26
+                                                    i32.load8_s
+                                                    i32.const 45
+                                                    i32.ne
+                                                    br_if 2 (;@22;)
+                                                    local.get $53
+                                                    f64.neg
+                                                    local.set $53
+                                                    local.get $52
+                                                    f64.neg
+                                                    local.set $52
+                                                  end
+                                                end
+                                              end
+                                              local.get $8
+                                              local.get $22
+                                              local.get $14
+                                              i32.sub
+                                              local.tee $14
+                                              i32.store
+                                              local.get $53
+                                              local.get $52
+                                              f64.add
+                                              local.get $53
+                                              f64.eq
+                                              br_if 2 (;@19;)
+                                              local.get $8
+                                              local.get $14
+                                              local.get $6
+                                              i32.add
+                                              local.tee $5
+                                              i32.store
+                                              local.get $5
+                                              i32.const 999999999
+                                              i32.gt_u
+                                              if ;; label = @22
+                                                loop $label$193 ;; label = @23
+                                                  local.get $8
+                                                  i32.const 0
+                                                  i32.store
+                                                  local.get $8
+                                                  i32.const -4
+                                                  i32.add
+                                                  local.tee $8
+                                                  local.get $1
+                                                  i32.lt_u
+                                                  if ;; label = @24
+                                                    local.get $1
+                                                    i32.const -4
+                                                    i32.add
+                                                    local.tee $1
+                                                    i32.const 0
+                                                    i32.store
+                                                  end
+                                                  local.get $8
+                                                  local.get $8
+                                                  i32.load
+                                                  i32.const 1
+                                                  i32.add
+                                                  local.tee $5
+                                                  i32.store
+                                                  local.get $5
+                                                  i32.const 999999999
+                                                  i32.gt_u
+                                                  br_if 0 (;@23;)
+                                                end
+                                              end
+                                              local.get $25
+                                              local.get $1
+                                              i32.sub
+                                              i32.const 2
+                                              i32.shr_s
+                                              i32.const 9
+                                              i32.mul
+                                              local.set $5
+                                              local.get $1
+                                              i32.load
+                                              local.tee $14
+                                              i32.const 10
+                                              i32.lt_u
+                                              br_if 2 (;@19;)
+                                              i32.const 10
+                                              local.set $6
+                                              loop $label$195 ;; label = @22
+                                                local.get $5
+                                                i32.const 1
+                                                i32.add
+                                                local.set $5
+                                                local.get $14
+                                                local.get $6
+                                                i32.const 10
+                                                i32.mul
+                                                local.tee $6
+                                                i32.ge_u
+                                                br_if 0 (;@22;)
+                                              end
+                                            end
+                                          end
+                                        end
+                                        local.get $1
+                                        local.set $14
+                                        local.get $5
+                                        local.set $6
+                                        local.get $13
+                                        local.get $8
+                                        i32.const 4
+                                        i32.add
+                                        local.tee $8
+                                        i32.le_u
+                                        if ;; label = @19
+                                          local.get $13
+                                          local.set $8
+                                        end
+                                      end
+                                    else
+                                      block ;; label = @18
+                                        local.get $1
+                                        local.set $14
+                                        local.get $5
+                                        local.set $6
+                                        local.get $13
+                                        local.set $8
+                                      end
+                                    end
+                                    i32.const 0
+                                    local.get $6
+                                    i32.sub
+                                    local.set $32
+                                    loop $label$198 ;; label = @17
+                                      block $label$199 ;; label = @18
+                                        local.get $8
+                                        local.get $14
+                                        i32.le_u
+                                        if ;; label = @19
+                                          block ;; label = @20
+                                            i32.const 0
+                                            local.set $22
+                                            br 2 (;@18;)
+                                          end
+                                        end
+                                        local.get $8
+                                        i32.const -4
+                                        i32.add
+                                        local.tee $1
+                                        i32.load
+                                        if ;; label = @19
+                                          i32.const 1
+                                          local.set $22
+                                        else
+                                          block ;; label = @20
+                                            local.get $1
+                                            local.set $8
+                                            br 3 (;@17;)
+                                          end
+                                        end
+                                      end
+                                    end
+                                    block $label$203 ;; label = @17
+                                      local.get $29
+                                      if ;; label = @18
+                                        block ;; label = @19
+                                          local.get $35
+                                          i32.const 1
+                                          i32.and
+                                          i32.const 1
+                                          i32.xor
+                                          local.get $18
+                                          i32.add
+                                          local.tee $1
+                                          local.get $6
+                                          i32.gt_s
+                                          local.get $6
+                                          i32.const -5
+                                          i32.gt_s
+                                          i32.and
+                                          if (result i32) ;; label = @20
+                                            block (result i32) ;; label = @21
+                                              local.get $9
+                                              i32.const -1
+                                              i32.add
+                                              local.set $5
+                                              local.get $1
+                                              i32.const -1
+                                              i32.add
+                                              local.get $6
+                                              i32.sub
+                                            end
+                                          else
+                                            block (result i32) ;; label = @21
+                                              local.get $9
+                                              i32.const -2
+                                              i32.add
+                                              local.set $5
+                                              local.get $1
+                                              i32.const -1
+                                              i32.add
+                                            end
+                                          end
+                                          local.set $1
+                                          local.get $12
+                                          i32.const 8
+                                          i32.and
+                                          local.tee $13
+                                          br_if 2 (;@17;)
+                                          block $label$207 ;; label = @20
+                                            local.get $22
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                local.get $8
+                                                i32.const -4
+                                                i32.add
+                                                i32.load
+                                                local.tee $18
+                                                i32.eqz
+                                                if ;; label = @23
+                                                  block ;; label = @24
+                                                    i32.const 9
+                                                    local.set $9
+                                                    br 4 (;@20;)
+                                                  end
+                                                end
+                                                local.get $18
+                                                i32.const 10
+                                                i32.rem_u
+                                                if ;; label = @23
+                                                  block ;; label = @24
+                                                    i32.const 0
+                                                    local.set $9
+                                                    br 4 (;@20;)
+                                                  end
+                                                else
+                                                  block ;; label = @24
+                                                    i32.const 10
+                                                    local.set $13
+                                                    i32.const 0
+                                                    local.set $9
+                                                  end
+                                                end
+                                                loop $label$212 ;; label = @23
+                                                  local.get $9
+                                                  i32.const 1
+                                                  i32.add
+                                                  local.set $9
+                                                  local.get $18
+                                                  local.get $13
+                                                  i32.const 10
+                                                  i32.mul
+                                                  local.tee $13
+                                                  i32.rem_u
+                                                  i32.eqz
+                                                  br_if 0 (;@23;)
+                                                end
+                                              end
+                                            else
+                                              i32.const 9
+                                              local.set $9
+                                            end
+                                          end
+                                          local.get $8
+                                          local.get $25
+                                          i32.sub
+                                          i32.const 2
+                                          i32.shr_s
+                                          i32.const 9
+                                          i32.mul
+                                          i32.const -9
+                                          i32.add
+                                          local.set $18
+                                          local.get $5
+                                          i32.const 32
+                                          i32.or
+                                          i32.const 102
+                                          i32.eq
+                                          if ;; label = @20
+                                            block ;; label = @21
+                                              i32.const 0
+                                              local.set $13
+                                              local.get $1
+                                              local.get $18
+                                              local.get $9
+                                              i32.sub
+                                              local.tee $9
+                                              i32.const 0
+                                              i32.lt_s
+                                              if (result i32) ;; label = @22
+                                                i32.const 0
+                                                local.tee $9
+                                              else
+                                                local.get $9
+                                              end
+                                              i32.ge_s
+                                              if ;; label = @22
+                                                local.get $9
+                                                local.set $1
+                                              end
+                                            end
+                                          else
+                                            block ;; label = @21
+                                              i32.const 0
+                                              local.set $13
+                                              local.get $1
+                                              local.get $18
+                                              local.get $6
+                                              i32.add
+                                              local.get $9
+                                              i32.sub
+                                              local.tee $9
+                                              i32.const 0
+                                              i32.lt_s
+                                              if (result i32) ;; label = @22
+                                                i32.const 0
+                                                local.tee $9
+                                              else
+                                                local.get $9
+                                              end
+                                              i32.ge_s
+                                              if ;; label = @22
+                                                local.get $9
+                                                local.set $1
+                                              end
+                                            end
+                                          end
+                                        end
+                                      else
+                                        block ;; label = @19
+                                          local.get $12
+                                          i32.const 8
+                                          i32.and
+                                          local.set $13
+                                          local.get $18
+                                          local.set $1
+                                          local.get $9
+                                          local.set $5
+                                        end
+                                      end
+                                    end
+                                    local.get $5
+                                    i32.const 32
+                                    i32.or
+                                    i32.const 102
+                                    i32.eq
+                                    local.tee $25
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        i32.const 0
+                                        local.set $9
+                                        local.get $6
+                                        i32.const 0
+                                        i32.le_s
+                                        if ;; label = @19
+                                          i32.const 0
+                                          local.set $6
+                                        end
+                                      end
+                                    else
+                                      block ;; label = @18
+                                        local.get $28
+                                        local.get $6
+                                        i32.const 0
+                                        i32.lt_s
+                                        if (result i32) ;; label = @19
+                                          local.get $32
+                                        else
+                                          local.get $6
+                                        end
+                                        i64.extend_i32_s
+                                        local.get $33
+                                        call $23
+                                        local.tee $9
+                                        i32.sub
+                                        i32.const 2
+                                        i32.lt_s
+                                        if ;; label = @19
+                                          loop $label$229 ;; label = @20
+                                            local.get $9
+                                            i32.const -1
+                                            i32.add
+                                            local.tee $9
+                                            i32.const 48
+                                            i32.store8
+                                            local.get $28
+                                            local.get $9
+                                            i32.sub
+                                            i32.const 2
+                                            i32.lt_s
+                                            br_if 0 (;@20;)
+                                          end
+                                        end
+                                        local.get $9
+                                        i32.const -1
+                                        i32.add
+                                        local.get $6
+                                        i32.const 31
+                                        i32.shr_s
+                                        i32.const 2
+                                        i32.and
+                                        i32.const 43
+                                        i32.add
+                                        i32.store8
+                                        local.get $9
+                                        i32.const -2
+                                        i32.add
+                                        local.tee $6
+                                        local.get $5
+                                        i32.store8
+                                        local.get $6
+                                        local.set $9
+                                        local.get $28
+                                        local.get $6
+                                        i32.sub
+                                        local.set $6
+                                      end
+                                    end
+                                    local.get $0
+                                    i32.const 32
+                                    local.get $10
+                                    local.get $24
+                                    i32.const 1
+                                    i32.add
+                                    local.get $1
+                                    i32.add
+                                    local.get $1
+                                    local.get $13
+                                    i32.or
+                                    local.tee $29
+                                    i32.const 0
+                                    i32.ne
+                                    i32.add
+                                    local.get $6
+                                    i32.add
+                                    local.tee $18
+                                    local.get $12
+                                    call $25
+                                    local.get $0
+                                    i32.load
+                                    i32.const 32
+                                    i32.and
+                                    i32.eqz
+                                    if ;; label = @17
+                                      local.get $26
+                                      local.get $24
+                                      local.get $0
+                                      call $21
+                                      drop
+                                    end
+                                    local.get $0
+                                    i32.const 48
+                                    local.get $10
+                                    local.get $18
+                                    local.get $12
+                                    i32.const 65536
+                                    i32.xor
+                                    call $25
+                                    block $label$231 ;; label = @17
+                                      local.get $25
+                                      if ;; label = @18
+                                        block ;; label = @19
+                                          local.get $14
+                                          local.get $7
+                                          i32.gt_u
+                                          if (result i32) ;; label = @20
+                                            local.get $7
+                                          else
+                                            local.get $14
+                                          end
+                                          local.tee $9
+                                          local.set $6
+                                          loop $label$235 ;; label = @20
+                                            local.get $6
+                                            i32.load
+                                            i64.extend_i32_u
+                                            local.get $31
+                                            call $23
+                                            local.set $5
+                                            block $label$236 ;; label = @21
+                                              local.get $6
+                                              local.get $9
+                                              i32.eq
+                                              if ;; label = @22
+                                                block ;; label = @23
+                                                  local.get $5
+                                                  local.get $31
+                                                  i32.ne
+                                                  br_if 2 (;@21;)
+                                                  local.get $34
+                                                  i32.const 48
+                                                  i32.store8
+                                                  local.get $34
+                                                  local.set $5
+                                                end
+                                              else
+                                                block ;; label = @23
+                                                  local.get $5
+                                                  local.get $19
+                                                  i32.le_u
+                                                  br_if 2 (;@21;)
+                                                  local.get $19
+                                                  i32.const 48
+                                                  local.get $5
+                                                  local.get $27
+                                                  i32.sub
+                                                  call $39
+                                                  drop
+                                                  loop $label$239 ;; label = @24
+                                                    local.get $5
+                                                    i32.const -1
+                                                    i32.add
+                                                    local.tee $5
+                                                    local.get $19
+                                                    i32.gt_u
+                                                    br_if 0 (;@24;)
+                                                  end
+                                                end
+                                              end
+                                            end
+                                            local.get $0
+                                            i32.load
+                                            i32.const 32
+                                            i32.and
+                                            i32.eqz
+                                            if ;; label = @21
+                                              local.get $5
+                                              local.get $41
+                                              local.get $5
+                                              i32.sub
+                                              local.get $0
+                                              call $21
+                                              drop
+                                            end
+                                            local.get $6
+                                            i32.const 4
+                                            i32.add
+                                            local.tee $5
+                                            local.get $7
+                                            i32.le_u
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                local.get $5
+                                                local.set $6
+                                                br 2 (;@20;)
+                                              end
+                                            end
+                                          end
+                                          block $label$242 ;; label = @20
+                                            local.get $29
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                local.get $0
+                                                i32.load
+                                                i32.const 32
+                                                i32.and
+                                                br_if 2 (;@20;)
+                                                i32.const 1709
+                                                i32.const 1
+                                                local.get $0
+                                                call $21
+                                                drop
+                                              end
+                                            end
+                                          end
+                                          local.get $1
+                                          i32.const 0
+                                          i32.gt_s
+                                          local.get $5
+                                          local.get $8
+                                          i32.lt_u
+                                          i32.and
+                                          if ;; label = @20
+                                            loop $label$245 ;; label = @21
+                                              local.get $5
+                                              i32.load
+                                              i64.extend_i32_u
+                                              local.get $31
+                                              call $23
+                                              local.tee $7
+                                              local.get $19
+                                              i32.gt_u
+                                              if ;; label = @22
+                                                block ;; label = @23
+                                                  local.get $19
+                                                  i32.const 48
+                                                  local.get $7
+                                                  local.get $27
+                                                  i32.sub
+                                                  call $39
+                                                  drop
+                                                  loop $label$247 ;; label = @24
+                                                    local.get $7
+                                                    i32.const -1
+                                                    i32.add
+                                                    local.tee $7
+                                                    local.get $19
+                                                    i32.gt_u
+                                                    br_if 0 (;@24;)
+                                                  end
+                                                end
+                                              end
+                                              local.get $0
+                                              i32.load
+                                              i32.const 32
+                                              i32.and
+                                              i32.eqz
+                                              if ;; label = @22
+                                                local.get $7
+                                                local.get $1
+                                                i32.const 9
+                                                i32.gt_s
+                                                if (result i32) ;; label = @23
+                                                  i32.const 9
+                                                else
+                                                  local.get $1
+                                                end
+                                                local.get $0
+                                                call $21
+                                                drop
+                                              end
+                                              local.get $1
+                                              i32.const -9
+                                              i32.add
+                                              local.set $7
+                                              local.get $1
+                                              i32.const 9
+                                              i32.gt_s
+                                              local.get $5
+                                              i32.const 4
+                                              i32.add
+                                              local.tee $5
+                                              local.get $8
+                                              i32.lt_u
+                                              i32.and
+                                              if ;; label = @22
+                                                block ;; label = @23
+                                                  local.get $7
+                                                  local.set $1
+                                                  br 2 (;@21;)
+                                                end
+                                              else
+                                                local.get $7
+                                                local.set $1
+                                              end
+                                            end
+                                          end
+                                          local.get $0
+                                          i32.const 48
+                                          local.get $1
+                                          i32.const 9
+                                          i32.add
+                                          i32.const 9
+                                          i32.const 0
+                                          call $25
+                                        end
+                                      else
+                                        block ;; label = @19
+                                          local.get $14
+                                          i32.const 4
+                                          i32.add
+                                          local.set $5
+                                          local.get $22
+                                          i32.eqz
+                                          if ;; label = @20
+                                            local.get $5
+                                            local.set $8
+                                          end
+                                          local.get $1
+                                          i32.const -1
+                                          i32.gt_s
+                                          if ;; label = @20
+                                            block ;; label = @21
+                                              local.get $13
+                                              i32.eqz
+                                              local.set $13
+                                              local.get $14
+                                              local.set $7
+                                              local.get $1
+                                              local.set $5
+                                              loop $label$256 ;; label = @22
+                                                local.get $7
+                                                i32.load
+                                                i64.extend_i32_u
+                                                local.get $31
+                                                call $23
+                                                local.tee $1
+                                                local.get $31
+                                                i32.eq
+                                                if ;; label = @23
+                                                  block ;; label = @24
+                                                    local.get $34
+                                                    i32.const 48
+                                                    i32.store8
+                                                    local.get $34
+                                                    local.set $1
+                                                  end
+                                                end
+                                                block $label$258 ;; label = @23
+                                                  local.get $7
+                                                  local.get $14
+                                                  i32.eq
+                                                  if ;; label = @24
+                                                    block ;; label = @25
+                                                      local.get $0
+                                                      i32.load
+                                                      i32.const 32
+                                                      i32.and
+                                                      i32.eqz
+                                                      if ;; label = @26
+                                                        local.get $1
+                                                        i32.const 1
+                                                        local.get $0
+                                                        call $21
+                                                        drop
+                                                      end
+                                                      local.get $1
+                                                      i32.const 1
+                                                      i32.add
+                                                      local.set $1
+                                                      local.get $13
+                                                      local.get $5
+                                                      i32.const 1
+                                                      i32.lt_s
+                                                      i32.and
+                                                      br_if 2 (;@23;)
+                                                      local.get $0
+                                                      i32.load
+                                                      i32.const 32
+                                                      i32.and
+                                                      br_if 2 (;@23;)
+                                                      i32.const 1709
+                                                      i32.const 1
+                                                      local.get $0
+                                                      call $21
+                                                      drop
+                                                    end
+                                                  else
+                                                    block ;; label = @25
+                                                      local.get $1
+                                                      local.get $19
+                                                      i32.le_u
+                                                      br_if 2 (;@23;)
+                                                      local.get $19
+                                                      i32.const 48
+                                                      local.get $1
+                                                      local.get $43
+                                                      i32.add
+                                                      call $39
+                                                      drop
+                                                      loop $label$262 ;; label = @26
+                                                        local.get $1
+                                                        i32.const -1
+                                                        i32.add
+                                                        local.tee $1
+                                                        local.get $19
+                                                        i32.gt_u
+                                                        br_if 0 (;@26;)
+                                                      end
+                                                    end
+                                                  end
+                                                end
+                                                local.get $41
+                                                local.get $1
+                                                i32.sub
+                                                local.set $6
+                                                local.get $0
+                                                i32.load
+                                                i32.const 32
+                                                i32.and
+                                                i32.eqz
+                                                if ;; label = @23
+                                                  local.get $1
+                                                  local.get $5
+                                                  local.get $6
+                                                  i32.gt_s
+                                                  if (result i32) ;; label = @24
+                                                    local.get $6
+                                                  else
+                                                    local.get $5
+                                                  end
+                                                  local.get $0
+                                                  call $21
+                                                  drop
+                                                end
+                                                local.get $7
+                                                i32.const 4
+                                                i32.add
+                                                local.tee $7
+                                                local.get $8
+                                                i32.lt_u
+                                                local.get $5
+                                                local.get $6
+                                                i32.sub
+                                                local.tee $5
+                                                i32.const -1
+                                                i32.gt_s
+                                                i32.and
+                                                br_if 0 (;@22;)
+                                                local.get $5
+                                                local.set $1
+                                              end
+                                            end
+                                          end
+                                          local.get $0
+                                          i32.const 48
+                                          local.get $1
+                                          i32.const 18
+                                          i32.add
+                                          i32.const 18
+                                          i32.const 0
+                                          call $25
+                                          local.get $0
+                                          i32.load
+                                          i32.const 32
+                                          i32.and
+                                          br_if 2 (;@17;)
+                                          local.get $9
+                                          local.get $28
+                                          local.get $9
+                                          i32.sub
+                                          local.get $0
+                                          call $21
+                                          drop
+                                        end
+                                      end
+                                    end
+                                    local.get $0
+                                    i32.const 32
+                                    local.get $10
+                                    local.get $18
+                                    local.get $12
+                                    i32.const 8192
+                                    i32.xor
+                                    call $25
+                                    local.get $18
+                                    local.get $10
+                                    i32.ge_s
+                                    if ;; label = @17
+                                      local.get $18
+                                      local.set $10
+                                    end
+                                  end
+                                else
+                                  block ;; label = @16
+                                    local.get $0
+                                    i32.const 32
+                                    local.get $10
+                                    local.get $52
+                                    local.get $52
+                                    f64.ne
+                                    i32.const 0
+                                    i32.or
+                                    local.tee $6
+                                    if (result i32) ;; label = @17
+                                      i32.const 0
+                                      local.tee $24
+                                    else
+                                      local.get $24
+                                    end
+                                    i32.const 3
+                                    i32.add
+                                    local.tee $8
+                                    local.get $7
+                                    call $25
+                                    local.get $0
+                                    i32.load
+                                    local.tee $1
+                                    i32.const 32
+                                    i32.and
+                                    i32.eqz
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        local.get $26
+                                        local.get $24
+                                        local.get $0
+                                        call $21
+                                        drop
+                                        local.get $0
+                                        i32.load
+                                        local.set $1
+                                      end
+                                    end
+                                    local.get $9
+                                    i32.const 32
+                                    i32.and
+                                    i32.const 0
+                                    i32.ne
+                                    local.tee $5
+                                    if (result i32) ;; label = @17
+                                      i32.const 1693
+                                    else
+                                      i32.const 1697
+                                    end
+                                    local.set $7
+                                    local.get $5
+                                    if (result i32) ;; label = @17
+                                      i32.const 1701
+                                    else
+                                      i32.const 1705
+                                    end
+                                    local.set $5
+                                    local.get $6
+                                    i32.eqz
+                                    if ;; label = @17
+                                      local.get $7
+                                      local.set $5
+                                    end
+                                    local.get $1
+                                    i32.const 32
+                                    i32.and
+                                    i32.eqz
+                                    if ;; label = @17
+                                      local.get $5
+                                      i32.const 3
+                                      local.get $0
+                                      call $21
+                                      drop
+                                    end
+                                    local.get $0
+                                    i32.const 32
+                                    local.get $10
+                                    local.get $8
+                                    local.get $12
+                                    i32.const 8192
+                                    i32.xor
+                                    call $25
+                                    local.get $8
+                                    local.get $10
+                                    i32.ge_s
+                                    if ;; label = @17
+                                      local.get $8
+                                      local.set $10
+                                    end
+                                  end
+                                end
+                              end
+                              local.get $11
+                              local.set $1
+                              br 9 (;@4;)
+                            end
+                            local.get $5
+                            local.set $7
+                            i32.const 0
+                            local.set $6
+                            i32.const 1657
+                            local.set $8
+                            local.get $21
+                            local.set $5
+                            br 6 (;@6;)
+                          end
+                          local.get $9
+                          i32.const 32
+                          i32.and
+                          local.set $7
+                          local.get $16
+                          i64.load
+                          local.tee $50
+                          i64.const 0
+                          i64.eq
+                          if (result i32) ;; label = @12
+                            block (result i32) ;; label = @13
+                              i64.const 0
+                              local.set $50
+                              local.get $21
+                            end
+                          else
+                            block (result i32) ;; label = @13
+                              local.get $21
+                              local.set $1
+                              loop $label$280 ;; label = @14
+                                local.get $1
+                                i32.const -1
+                                i32.add
+                                local.tee $1
+                                local.get $50
+                                i32.wrap_i64
+                                i32.const 15
+                                i32.and
+                                i32.const 1641
+                                i32.add
+                                i32.load8_u
+                                local.get $7
+                                i32.or
+                                i32.store8
+                                local.get $50
+                                i64.const 4
+                                i64.shr_u
+                                local.tee $50
+                                i64.const 0
+                                i64.ne
+                                br_if 0 (;@14;)
+                              end
+                              local.get $16
+                              i64.load
+                              local.set $50
+                              local.get $1
+                            end
+                          end
+                          local.set $7
+                          local.get $9
+                          i32.const 4
+                          i32.shr_s
+                          i32.const 1657
+                          i32.add
+                          local.set $8
+                          local.get $12
+                          i32.const 8
+                          i32.and
+                          i32.eqz
+                          local.get $50
+                          i64.const 0
+                          i64.eq
+                          i32.or
+                          local.tee $1
+                          if ;; label = @12
+                            i32.const 1657
+                            local.set $8
+                          end
+                          local.get $1
+                          if (result i32) ;; label = @12
+                            i32.const 0
+                          else
+                            i32.const 2
+                          end
+                          local.set $6
+                          br 4 (;@7;)
+                        end
+                        local.get $50
+                        local.get $21
+                        call $23
+                        local.set $7
+                        br 3 (;@7;)
+                      end
+                      local.get $1
+                      i32.const 0
+                      local.get $5
+                      call $17
+                      local.tee $13
+                      i32.eqz
+                      local.set $14
+                      local.get $13
+                      local.get $1
+                      i32.sub
+                      local.set $8
+                      local.get $1
+                      local.get $5
+                      i32.add
+                      local.set $9
+                      local.get $7
+                      local.set $12
+                      local.get $14
+                      if (result i32) ;; label = @10
+                        local.get $5
+                      else
+                        local.get $8
+                      end
+                      local.set $7
+                      i32.const 0
+                      local.set $6
+                      i32.const 1657
+                      local.set $8
+                      local.get $14
+                      if (result i32) ;; label = @10
+                        local.get $9
+                      else
+                        local.get $13
+                      end
+                      local.set $5
+                      br 3 (;@6;)
+                    end
+                    i32.const 0
+                    local.set $1
+                    i32.const 0
+                    local.set $5
+                    local.get $7
+                    local.set $8
+                    loop $label$288 ;; label = @9
+                      block $label$289 ;; label = @10
+                        local.get $8
+                        i32.load
+                        local.tee $9
+                        i32.eqz
+                        br_if 0 (;@10;)
+                        local.get $36
+                        local.get $9
+                        call $26
+                        local.tee $5
+                        i32.const 0
+                        i32.lt_s
+                        local.get $5
+                        local.get $6
+                        local.get $1
+                        i32.sub
+                        i32.gt_u
+                        i32.or
+                        br_if 0 (;@10;)
+                        local.get $8
+                        i32.const 4
+                        i32.add
+                        local.set $8
+                        local.get $6
+                        local.get $5
+                        local.get $1
+                        i32.add
+                        local.tee $1
+                        i32.gt_u
+                        br_if 1 (;@9;)
+                      end
+                    end
+                    local.get $5
+                    i32.const 0
+                    i32.lt_s
+                    if ;; label = @9
+                      block ;; label = @10
+                        i32.const -1
+                        local.set $15
+                        br 5 (;@5;)
+                      end
+                    end
+                    local.get $0
+                    i32.const 32
+                    local.get $10
+                    local.get $1
+                    local.get $12
+                    call $25
+                    local.get $1
+                    if ;; label = @9
+                      block ;; label = @10
+                        i32.const 0
+                        local.set $5
+                        loop $label$292 ;; label = @11
+                          local.get $7
+                          i32.load
+                          local.tee $8
+                          i32.eqz
+                          br_if 3 (;@8;)
+                          local.get $36
+                          local.get $8
+                          call $26
+                          local.tee $8
+                          local.get $5
+                          i32.add
+                          local.tee $5
+                          local.get $1
+                          i32.gt_s
+                          br_if 3 (;@8;)
+                          local.get $0
+                          i32.load
+                          i32.const 32
+                          i32.and
+                          i32.eqz
+                          if ;; label = @12
+                            local.get $36
+                            local.get $8
+                            local.get $0
+                            call $21
+                            drop
+                          end
+                          local.get $7
+                          i32.const 4
+                          i32.add
+                          local.set $7
+                          local.get $5
+                          local.get $1
+                          i32.lt_u
+                          br_if 0 (;@11;)
+                          br 3 (;@8;)
+                        end
+                      end
+                    else
+                      block ;; label = @10
+                        i32.const 0
+                        local.set $1
+                        br 2 (;@8;)
+                      end
+                    end
+                  end
+                  local.get $0
+                  i32.const 32
+                  local.get $10
+                  local.get $1
+                  local.get $12
+                  i32.const 8192
+                  i32.xor
+                  call $25
+                  local.get $10
+                  local.get $1
+                  i32.le_s
+                  if ;; label = @8
+                    local.get $1
+                    local.set $10
+                  end
+                  local.get $11
+                  local.set $1
+                  br 3 (;@4;)
+                end
+                local.get $12
+                i32.const -65537
+                i32.and
+                local.set $1
+                local.get $5
+                i32.const -1
+                i32.gt_s
+                if ;; label = @7
+                  local.get $1
+                  local.set $12
+                end
+                local.get $5
+                local.get $16
+                i64.load
+                i64.const 0
+                i64.ne
+                local.tee $9
+                i32.or
+                if (result i32) ;; label = @7
+                  block (result i32) ;; label = @8
+                    local.get $7
+                    local.set $1
+                    local.get $5
+                    local.get $9
+                    i32.const 1
+                    i32.and
+                    i32.const 1
+                    i32.xor
+                    local.get $38
+                    local.get $7
+                    i32.sub
+                    i32.add
+                    local.tee $7
+                    i32.gt_s
+                    if ;; label = @9
+                      local.get $5
+                      local.set $7
+                    end
+                    local.get $21
+                  end
+                else
+                  block (result i32) ;; label = @8
+                    local.get $21
+                    local.set $1
+                    i32.const 0
+                    local.set $7
+                    local.get $21
+                  end
+                end
+                local.set $5
+              end
+              local.get $0
+              i32.const 32
+              local.get $10
+              local.get $7
+              local.get $5
+              local.get $1
+              i32.sub
+              local.tee $9
+              i32.lt_s
+              if (result i32) ;; label = @6
+                local.get $9
+                local.tee $7
+              else
+                local.get $7
+              end
+              local.get $6
+              i32.add
+              local.tee $5
+              i32.lt_s
+              if (result i32) ;; label = @6
+                local.get $5
+                local.tee $10
+              else
+                local.get $10
+              end
+              local.get $5
+              local.get $12
+              call $25
+              local.get $0
+              i32.load
+              i32.const 32
+              i32.and
+              i32.eqz
+              if ;; label = @6
+                local.get $8
+                local.get $6
+                local.get $0
+                call $21
+                drop
+              end
+              local.get $0
+              i32.const 48
+              local.get $10
+              local.get $5
+              local.get $12
+              i32.const 65536
+              i32.xor
+              call $25
+              local.get $0
+              i32.const 48
+              local.get $7
+              local.get $9
+              i32.const 0
+              call $25
+              local.get $0
+              i32.load
+              i32.const 32
+              i32.and
+              i32.eqz
+              if ;; label = @6
+                local.get $1
+                local.get $9
+                local.get $0
+                call $21
+                drop
+              end
+              local.get $0
+              i32.const 32
+              local.get $10
+              local.get $5
+              local.get $12
+              i32.const 8192
+              i32.xor
+              call $25
+              local.get $11
+              local.set $1
+              br 1 (;@4;)
+            end
+          end
+          br 1 (;@2;)
+        end
+        local.get $0
+        i32.eqz
+        if ;; label = @3
+          local.get $17
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 1
+              local.set $0
+              loop $label$308 ;; label = @6
+                local.get $4
+                local.get $0
+                i32.const 2
+                i32.shl
+                i32.add
+                i32.load
+                local.tee $1
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $3
+                    local.get $0
+                    i32.const 3
+                    i32.shl
+                    i32.add
+                    local.get $1
+                    local.get $2
+                    call $22
+                    local.get $0
+                    i32.const 1
+                    i32.add
+                    local.tee $0
+                    i32.const 10
+                    i32.lt_s
+                    br_if 2 (;@6;)
+                    i32.const 1
+                    local.set $15
+                    br 6 (;@2;)
+                  end
+                end
+              end
+              loop $label$310 ;; label = @6
+                local.get $4
+                local.get $0
+                i32.const 2
+                i32.shl
+                i32.add
+                i32.load
+                if ;; label = @7
+                  block ;; label = @8
+                    i32.const -1
+                    local.set $15
+                    br 6 (;@2;)
+                  end
+                end
+                local.get $0
+                i32.const 1
+                i32.add
+                local.tee $0
+                i32.const 10
+                i32.lt_s
+                br_if 0 (;@6;)
+                i32.const 1
+                local.set $15
+              end
+            end
+          else
+            i32.const 0
+            local.set $15
+          end
+        end
+      end
+      local.get $23
+      global.set $global$1
+      local.get $15
+    end
+  )
+  (func $20 (;33;) (type $1) (param $0 i32) (result i32)
+    i32.const 0
+  )
+  (func $21 (;34;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32)
+    block $label$1 (result i32) ;; label = @1
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          local.get $2
+          i32.const 16
+          i32.add
+          local.tee $4
+          i32.load
+          local.tee $3
+          br_if 0 (;@3;)
+          local.get $2
+          call $30
+          if ;; label = @4
+            i32.const 0
+            local.set $3
+          else
+            block ;; label = @5
+              local.get $4
+              i32.load
+              local.set $3
+              br 2 (;@3;)
+            end
+          end
+          br 1 (;@2;)
+        end
+        local.get $3
+        local.get $2
+        i32.const 20
+        i32.add
+        local.tee $5
+        i32.load
+        local.tee $4
+        i32.sub
+        local.get $1
+        i32.lt_u
+        if ;; label = @3
+          block ;; label = @4
+            local.get $2
+            local.get $0
+            local.get $1
+            local.get $2
+            i32.load offset=36
+            i32.const 3
+            i32.and
+            i32.const 2
+            i32.add
+            call_indirect (type $0)
+            local.set $3
+            br 2 (;@2;)
+          end
+        end
+        block $label$7 (result i32) ;; label = @3
+          local.get $2
+          i32.load8_s offset=75
+          i32.const -1
+          i32.gt_s
+          if (result i32) ;; label = @4
+            block (result i32) ;; label = @5
+              local.get $1
+              local.set $3
+              loop $label$9 ;; label = @6
+                i32.const 0
+                local.get $3
+                i32.eqz
+                br_if 3 (;@3;)
+                drop
+                local.get $0
+                local.get $3
+                i32.const -1
+                i32.add
+                local.tee $6
+                i32.add
+                i32.load8_s
+                i32.const 10
+                i32.ne
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $6
+                    local.set $3
+                    br 2 (;@6;)
+                  end
+                end
+              end
+              local.get $2
+              local.get $0
+              local.get $3
+              local.get $2
+              i32.load offset=36
+              i32.const 3
+              i32.and
+              i32.const 2
+              i32.add
+              call_indirect (type $0)
+              local.get $3
+              i32.lt_u
+              br_if 3 (;@2;)
+              local.get $5
+              i32.load
+              local.set $4
+              local.get $1
+              local.get $3
+              i32.sub
+              local.set $1
+              local.get $0
+              local.get $3
+              i32.add
+              local.set $0
+              local.get $3
+            end
+          else
+            i32.const 0
+          end
+        end
+        local.set $2
+        local.get $4
+        local.get $0
+        local.get $1
+        call $40
+        drop
+        local.get $5
+        local.get $5
+        i32.load
+        local.get $1
+        i32.add
+        i32.store
+        local.get $2
+        local.get $1
+        i32.add
+        local.set $3
+      end
+      local.get $3
+    end
+  )
+  (func $22 (;35;) (type $8) (param $0 i32) (param $1 i32) (param $2 i32)
+    (local $3 i32) (local $4 i64) (local $5 f64)
+    block $label$1 ;; label = @1
+      local.get $1
+      i32.const 20
+      i32.le_u
+      if ;; label = @2
+        block $label$3 ;; label = @3
+          block $label$4 ;; label = @4
+            block $label$5 ;; label = @5
+              block $label$6 ;; label = @6
+                block $label$7 ;; label = @7
+                  block $label$8 ;; label = @8
+                    block $label$9 ;; label = @9
+                      block $label$10 ;; label = @10
+                        block $label$11 ;; label = @11
+                          block $label$12 ;; label = @12
+                            block $label$13 ;; label = @13
+                              local.get $1
+                              i32.const 9
+                              i32.sub
+                              br_table 0 (;@13;) 1 (;@12;) 2 (;@11;) 3 (;@10;) 4 (;@9;) 5 (;@8;) 6 (;@7;) 7 (;@6;) 8 (;@5;) 9 (;@4;) 10 (;@3;)
+                            end
+                            local.get $2
+                            i32.load
+                            i32.const 3
+                            i32.add
+                            i32.const -4
+                            i32.and
+                            local.tee $1
+                            i32.load
+                            local.set $3
+                            local.get $2
+                            local.get $1
+                            i32.const 4
+                            i32.add
+                            i32.store
+                            local.get $0
+                            local.get $3
+                            i32.store
+                            br 11 (;@1;)
+                          end
+                          local.get $2
+                          i32.load
+                          i32.const 3
+                          i32.add
+                          i32.const -4
+                          i32.and
+                          local.tee $1
+                          i32.load
+                          local.set $3
+                          local.get $2
+                          local.get $1
+                          i32.const 4
+                          i32.add
+                          i32.store
+                          local.get $0
+                          local.get $3
+                          i64.extend_i32_s
+                          i64.store
+                          br 10 (;@1;)
+                        end
+                        local.get $2
+                        i32.load
+                        i32.const 3
+                        i32.add
+                        i32.const -4
+                        i32.and
+                        local.tee $1
+                        i32.load
+                        local.set $3
+                        local.get $2
+                        local.get $1
+                        i32.const 4
+                        i32.add
+                        i32.store
+                        local.get $0
+                        local.get $3
+                        i64.extend_i32_u
+                        i64.store
+                        br 9 (;@1;)
+                      end
+                      local.get $2
+                      i32.load
+                      i32.const 7
+                      i32.add
+                      i32.const -8
+                      i32.and
+                      local.tee $1
+                      i64.load
+                      local.set $4
+                      local.get $2
+                      local.get $1
+                      i32.const 8
+                      i32.add
+                      i32.store
+                      local.get $0
+                      local.get $4
+                      i64.store
+                      br 8 (;@1;)
+                    end
+                    local.get $2
+                    i32.load
+                    i32.const 3
+                    i32.add
+                    i32.const -4
+                    i32.and
+                    local.tee $1
+                    i32.load
+                    local.set $3
+                    local.get $2
+                    local.get $1
+                    i32.const 4
+                    i32.add
+                    i32.store
+                    local.get $0
+                    local.get $3
+                    i32.const 65535
+                    i32.and
+                    i32.const 16
+                    i32.shl
+                    i32.const 16
+                    i32.shr_s
+                    i64.extend_i32_s
+                    i64.store
+                    br 7 (;@1;)
+                  end
+                  local.get $2
+                  i32.load
+                  i32.const 3
+                  i32.add
+                  i32.const -4
+                  i32.and
+                  local.tee $1
+                  i32.load
+                  local.set $3
+                  local.get $2
+                  local.get $1
+                  i32.const 4
+                  i32.add
+                  i32.store
+                  local.get $0
+                  local.get $3
+                  i32.const 65535
+                  i32.and
+                  i64.extend_i32_u
+                  i64.store
+                  br 6 (;@1;)
+                end
+                local.get $2
+                i32.load
+                i32.const 3
+                i32.add
+                i32.const -4
+                i32.and
+                local.tee $1
+                i32.load
+                local.set $3
+                local.get $2
+                local.get $1
+                i32.const 4
+                i32.add
+                i32.store
+                local.get $0
+                local.get $3
+                i32.const 255
+                i32.and
+                i32.const 24
+                i32.shl
+                i32.const 24
+                i32.shr_s
+                i64.extend_i32_s
+                i64.store
+                br 5 (;@1;)
+              end
+              local.get $2
+              i32.load
+              i32.const 3
+              i32.add
+              i32.const -4
+              i32.and
+              local.tee $1
+              i32.load
+              local.set $3
+              local.get $2
+              local.get $1
+              i32.const 4
+              i32.add
+              i32.store
+              local.get $0
+              local.get $3
+              i32.const 255
+              i32.and
+              i64.extend_i32_u
+              i64.store
+              br 4 (;@1;)
+            end
+            local.get $2
+            i32.load
+            i32.const 7
+            i32.add
+            i32.const -8
+            i32.and
+            local.tee $1
+            f64.load
+            local.set $5
+            local.get $2
+            local.get $1
+            i32.const 8
+            i32.add
+            i32.store
+            local.get $0
+            local.get $5
+            f64.store
+            br 3 (;@1;)
+          end
+          local.get $2
+          i32.load
+          i32.const 7
+          i32.add
+          i32.const -8
+          i32.and
+          local.tee $1
+          f64.load
+          local.set $5
+          local.get $2
+          local.get $1
+          i32.const 8
+          i32.add
+          i32.store
+          local.get $0
+          local.get $5
+          f64.store
+        end
+      end
+    end
+  )
+  (func $23 (;36;) (type $9) (param $0 i64) (param $1 i32) (result i32)
+    (local $2 i32) (local $3 i32) (local $4 i64)
+    block $label$1 (result i32) ;; label = @1
+      local.get $0
+      i32.wrap_i64
+      local.set $2
+      local.get $0
+      i64.const 4294967295
+      i64.gt_u
+      if ;; label = @2
+        block ;; label = @3
+          loop $label$3 ;; label = @4
+            local.get $1
+            i32.const -1
+            i32.add
+            local.tee $1
+            local.get $0
+            i64.const 10
+            i64.rem_u
+            i64.const 48
+            i64.or
+            i64.store8
+            local.get $0
+            i64.const 10
+            i64.div_u
+            local.set $4
+            local.get $0
+            i64.const 42949672959
+            i64.gt_u
+            if ;; label = @5
+              block ;; label = @6
+                local.get $4
+                local.set $0
+                br 2 (;@4;)
+              end
+            end
+          end
+          local.get $4
+          i32.wrap_i64
+          local.set $2
+        end
+      end
+      local.get $2
+      if ;; label = @2
+        loop $label$6 ;; label = @3
+          local.get $1
+          i32.const -1
+          i32.add
+          local.tee $1
+          local.get $2
+          i32.const 10
+          i32.rem_u
+          i32.const 48
+          i32.or
+          i32.store8
+          local.get $2
+          i32.const 10
+          i32.div_u
+          local.set $3
+          local.get $2
+          i32.const 10
+          i32.ge_u
+          if ;; label = @4
+            block ;; label = @5
+              local.get $3
+              local.set $2
+              br 2 (;@3;)
+            end
+          end
+        end
+      end
+      local.get $1
+    end
+  )
+  (func $24 (;37;) (type $1) (param $0 i32) (result i32)
+    (local $1 i32) (local $2 i32)
+    block $label$1 (result i32) ;; label = @1
+      i32.const 0
+      local.set $1
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          block $label$4 ;; label = @4
+            loop $label$5 ;; label = @5
+              local.get $1
+              i32.const 1711
+              i32.add
+              i32.load8_u
+              local.get $0
+              i32.eq
+              br_if 1 (;@4;)
+              local.get $1
+              i32.const 1
+              i32.add
+              local.tee $1
+              i32.const 87
+              i32.ne
+              br_if 0 (;@5;)
+              i32.const 87
+              local.set $1
+              i32.const 1799
+              local.set $0
+              br 2 (;@3;)
+            end
+          end
+          local.get $1
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 1799
+              local.set $0
+              br 2 (;@3;)
+            end
+          else
+            i32.const 1799
+            local.set $0
+          end
+          br 1 (;@2;)
+        end
+        loop $label$8 ;; label = @3
+          local.get $0
+          local.set $2
+          loop $label$9 ;; label = @4
+            local.get $2
+            i32.const 1
+            i32.add
+            local.set $0
+            local.get $2
+            i32.load8_s
+            if ;; label = @5
+              block ;; label = @6
+                local.get $0
+                local.set $2
+                br 2 (;@4;)
+              end
+            end
+          end
+          local.get $1
+          i32.const -1
+          i32.add
+          local.tee $1
+          br_if 0 (;@3;)
+        end
+      end
+      local.get $0
+    end
+  )
+  (func $25 (;38;) (type $10) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32)
+    (local $5 i32) (local $6 i32) (local $7 i32)
+    block $label$1 ;; label = @1
+      global.get $global$1
+      local.set $7
+      global.get $global$1
+      i32.const 256
+      i32.add
+      global.set $global$1
+      local.get $7
+      local.set $6
+      block $label$2 ;; label = @2
+        local.get $2
+        local.get $3
+        i32.gt_s
+        local.get $4
+        i32.const 73728
+        i32.and
+        i32.eqz
+        i32.and
+        if ;; label = @3
+          block ;; label = @4
+            local.get $6
+            local.get $1
+            local.get $2
+            local.get $3
+            i32.sub
+            local.tee $5
+            i32.const 256
+            i32.gt_u
+            if (result i32) ;; label = @5
+              i32.const 256
+            else
+              local.get $5
+            end
+            call $39
+            drop
+            local.get $0
+            i32.load
+            local.tee $1
+            i32.const 32
+            i32.and
+            i32.eqz
+            local.set $4
+            local.get $5
+            i32.const 255
+            i32.gt_u
+            if ;; label = @5
+              block ;; label = @6
+                loop $label$7 ;; label = @7
+                  local.get $4
+                  if ;; label = @8
+                    block ;; label = @9
+                      local.get $6
+                      i32.const 256
+                      local.get $0
+                      call $21
+                      drop
+                      local.get $0
+                      i32.load
+                      local.set $1
+                    end
+                  end
+                  local.get $1
+                  i32.const 32
+                  i32.and
+                  i32.eqz
+                  local.set $4
+                  local.get $5
+                  i32.const -256
+                  i32.add
+                  local.tee $5
+                  i32.const 255
+                  i32.gt_u
+                  br_if 0 (;@7;)
+                end
+                local.get $4
+                i32.eqz
+                br_if 4 (;@2;)
+                local.get $2
+                local.get $3
+                i32.sub
+                i32.const 255
+                i32.and
+                local.set $5
+              end
+            else
+              local.get $4
+              i32.eqz
+              br_if 3 (;@2;)
+            end
+            local.get $6
+            local.get $5
+            local.get $0
+            call $21
+            drop
+          end
+        end
+      end
+      local.get $7
+      global.set $global$1
+    end
+  )
+  (func $26 (;39;) (type $4) (param $0 i32) (param $1 i32) (result i32)
+    local.get $0
+    if (result i32) ;; label = @1
+      local.get $0
+      local.get $1
+      i32.const 0
+      call $29
+    else
+      i32.const 0
+    end
+  )
+  (func $27 (;40;) (type $11) (param $0 f64) (param $1 i32) (result f64)
+    local.get $0
+    local.get $1
+    call $28
+  )
+  (func $28 (;41;) (type $11) (param $0 f64) (param $1 i32) (result f64)
+    (local $2 i64) (local $3 i64)
+    block $label$1 (result f64) ;; label = @1
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          block $label$4 ;; label = @4
+            block $label$5 ;; label = @5
+              local.get $0
+              i64.reinterpret_f64
+              local.tee $2
+              i64.const 52
+              i64.shr_u
+              local.tee $3
+              i32.wrap_i64
+              i32.const 65535
+              i32.and
+              i32.const 2047
+              i32.and
+              i32.const 16
+              i32.shl
+              i32.const 16
+              i32.shr_s
+              i32.const 0
+              i32.sub
+              br_table 0 (;@5;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 1 (;@4;) 2 (;@3;)
+            end
+            local.get $1
+            local.get $0
+            f64.const 0x0p+0 (;=0;)
+            f64.ne
+            if (result i32) ;; label = @5
+              block (result i32) ;; label = @6
+                local.get $0
+                f64.const 0x1p+64 (;=18446744073709552000;)
+                f64.mul
+                local.get $1
+                call $28
+                local.set $0
+                local.get $1
+                i32.load
+                i32.const -64
+                i32.add
+              end
+            else
+              i32.const 0
+            end
+            i32.store
+            br 2 (;@2;)
+          end
+          br 1 (;@2;)
+        end
+        local.get $1
+        local.get $3
+        i32.wrap_i64
+        i32.const 2047
+        i32.and
+        i32.const -1022
+        i32.add
+        i32.store
+        local.get $2
+        i64.const -9218868437227405313
+        i64.and
+        i64.const 4602678819172646912
+        i64.or
+        f64.reinterpret_i64
+        local.set $0
+      end
+      local.get $0
+    end
+  )
+  (func $29 (;42;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    block $label$1 (result i32) ;; label = @1
+      local.get $0
+      if (result i32) ;; label = @2
+        block (result i32) ;; label = @3
+          local.get $1
+          i32.const 128
+          i32.lt_u
+          if ;; label = @4
+            block ;; label = @5
+              local.get $0
+              local.get $1
+              i32.store8
+              i32.const 1
+              br 4 (;@1;)
+            end
+          end
+          local.get $1
+          i32.const 2048
+          i32.lt_u
+          if ;; label = @4
+            block ;; label = @5
+              local.get $0
+              local.get $1
+              i32.const 6
+              i32.shr_u
+              i32.const 192
+              i32.or
+              i32.store8
+              local.get $0
+              local.get $1
+              i32.const 63
+              i32.and
+              i32.const 128
+              i32.or
+              i32.store8 offset=1
+              i32.const 2
+              br 4 (;@1;)
+            end
+          end
+          local.get $1
+          i32.const 55296
+          i32.lt_u
+          local.get $1
+          i32.const -8192
+          i32.and
+          i32.const 57344
+          i32.eq
+          i32.or
+          if ;; label = @4
+            block ;; label = @5
+              local.get $0
+              local.get $1
+              i32.const 12
+              i32.shr_u
+              i32.const 224
+              i32.or
+              i32.store8
+              local.get $0
+              local.get $1
+              i32.const 6
+              i32.shr_u
+              i32.const 63
+              i32.and
+              i32.const 128
+              i32.or
+              i32.store8 offset=1
+              local.get $0
+              local.get $1
+              i32.const 63
+              i32.and
+              i32.const 128
+              i32.or
+              i32.store8 offset=2
+              i32.const 3
+              br 4 (;@1;)
+            end
+          end
+          local.get $1
+          i32.const -65536
+          i32.add
+          i32.const 1048576
+          i32.lt_u
+          if (result i32) ;; label = @4
+            block (result i32) ;; label = @5
+              local.get $0
+              local.get $1
+              i32.const 18
+              i32.shr_u
+              i32.const 240
+              i32.or
+              i32.store8
+              local.get $0
+              local.get $1
+              i32.const 12
+              i32.shr_u
+              i32.const 63
+              i32.and
+              i32.const 128
+              i32.or
+              i32.store8 offset=1
+              local.get $0
+              local.get $1
+              i32.const 6
+              i32.shr_u
+              i32.const 63
+              i32.and
+              i32.const 128
+              i32.or
+              i32.store8 offset=2
+              local.get $0
+              local.get $1
+              i32.const 63
+              i32.and
+              i32.const 128
+              i32.or
+              i32.store8 offset=3
+              i32.const 4
+            end
+          else
+            block (result i32) ;; label = @5
+              call $12
+              i32.const 84
+              i32.store
+              i32.const -1
+            end
+          end
+        end
+      else
+        i32.const 1
+      end
+    end
+  )
+  (func $30 (;43;) (type $1) (param $0 i32) (result i32)
+    (local $1 i32) (local $2 i32)
+    block $label$1 (result i32) ;; label = @1
+      local.get $0
+      i32.const 74
+      i32.add
+      local.tee $2
+      i32.load8_s
+      local.set $1
+      local.get $2
+      local.get $1
+      i32.const 255
+      i32.add
+      local.get $1
+      i32.or
+      i32.store8
+      local.get $0
+      i32.load
+      local.tee $1
+      i32.const 8
+      i32.and
+      if (result i32) ;; label = @2
+        block (result i32) ;; label = @3
+          local.get $0
+          local.get $1
+          i32.const 32
+          i32.or
+          i32.store
+          i32.const -1
+        end
+      else
+        block (result i32) ;; label = @3
+          local.get $0
+          i32.const 0
+          i32.store offset=8
+          local.get $0
+          i32.const 0
+          i32.store offset=4
+          local.get $0
+          local.get $0
+          i32.load offset=44
+          local.tee $1
+          i32.store offset=28
+          local.get $0
+          local.get $1
+          i32.store offset=20
+          local.get $0
+          local.get $1
+          local.get $0
+          i32.load offset=48
+          i32.add
+          i32.store offset=16
+          i32.const 0
+        end
+      end
+      local.tee $0
+    end
+  )
+  (func $31 (;44;) (type $4) (param $0 i32) (param $1 i32) (result i32)
+    (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $3
+      global.get $global$1
+      i32.const 16
+      i32.add
+      global.set $global$1
+      local.get $3
+      local.tee $4
+      local.get $1
+      i32.const 255
+      i32.and
+      local.tee $7
+      i32.store8
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          local.get $0
+          i32.const 16
+          i32.add
+          local.tee $2
+          i32.load
+          local.tee $5
+          br_if 0 (;@3;)
+          local.get $0
+          call $30
+          if ;; label = @4
+            i32.const -1
+            local.set $1
+          else
+            block ;; label = @5
+              local.get $2
+              i32.load
+              local.set $5
+              br 2 (;@3;)
+            end
+          end
+          br 1 (;@2;)
+        end
+        local.get $0
+        i32.const 20
+        i32.add
+        local.tee $2
+        i32.load
+        local.tee $6
+        local.get $5
+        i32.lt_u
+        if ;; label = @3
+          local.get $1
+          i32.const 255
+          i32.and
+          local.tee $1
+          local.get $0
+          i32.load8_s offset=75
+          i32.ne
+          if ;; label = @4
+            block ;; label = @5
+              local.get $2
+              local.get $6
+              i32.const 1
+              i32.add
+              i32.store
+              local.get $6
+              local.get $7
+              i32.store8
+              br 3 (;@2;)
+            end
+          end
+        end
+        local.get $0
+        local.get $4
+        i32.const 1
+        local.get $0
+        i32.load offset=36
+        i32.const 3
+        i32.and
+        i32.const 2
+        i32.add
+        call_indirect (type $0)
+        i32.const 1
+        i32.eq
+        if (result i32) ;; label = @3
+          local.get $4
+          i32.load8_u
+        else
+          i32.const -1
+        end
+        local.set $1
+      end
+      local.get $3
+      global.set $global$1
+      local.get $1
+    end
+  )
+  (func $32 (;45;) (type $4) (param $0 i32) (param $1 i32) (result i32)
+    (local $2 i32) (local $3 i32)
+    block $label$1 (result i32) ;; label = @1
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          local.get $1
+          i32.load offset=76
+          i32.const 0
+          i32.lt_s
+          br_if 0 (;@3;)
+          local.get $1
+          call $20
+          i32.eqz
+          br_if 0 (;@3;)
+          block $label$4 (result i32) ;; label = @4
+            block $label$5 ;; label = @5
+              local.get $1
+              i32.load8_s offset=75
+              local.get $0
+              i32.eq
+              br_if 0 (;@5;)
+              local.get $1
+              i32.const 20
+              i32.add
+              local.tee $3
+              i32.load
+              local.tee $2
+              local.get $1
+              i32.load offset=16
+              i32.ge_u
+              br_if 0 (;@5;)
+              local.get $3
+              local.get $2
+              i32.const 1
+              i32.add
+              i32.store
+              local.get $2
+              local.get $0
+              i32.store8
+              local.get $0
+              i32.const 255
+              i32.and
+              br 1 (;@4;)
+            end
+            local.get $1
+            local.get $0
+            call $31
+          end
+          local.set $0
+          local.get $1
+          call $13
+          br 1 (;@2;)
+        end
+        local.get $1
+        i32.load8_s offset=75
+        local.get $0
+        i32.ne
+        if ;; label = @3
+          local.get $1
+          i32.const 20
+          i32.add
+          local.tee $3
+          i32.load
+          local.tee $2
+          local.get $1
+          i32.load offset=16
+          i32.lt_u
+          if ;; label = @4
+            block ;; label = @5
+              local.get $3
+              local.get $2
+              i32.const 1
+              i32.add
+              i32.store
+              local.get $2
+              local.get $0
+              i32.store8
+              local.get $0
+              i32.const 255
+              i32.and
+              local.set $0
+              br 3 (;@2;)
+            end
+          end
+        end
+        local.get $1
+        local.get $0
+        call $31
+        local.set $0
+      end
+      local.get $0
+    end
+  )
+  (func $33 (;46;) (type $4) (param $0 i32) (param $1 i32) (result i32)
+    (local $2 i32) (local $3 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $2
+      global.get $global$1
+      i32.const 16
+      i32.add
+      global.set $global$1
+      local.get $2
+      local.tee $3
+      local.get $1
+      i32.store
+      i32.const 1024
+      i32.load
+      local.get $0
+      local.get $3
+      call $18
+      local.set $0
+      local.get $2
+      global.set $global$1
+      local.get $0
+    end
+  )
+  (func $34 (;47;) (type $1) (param $0 i32) (result i32)
+    local.get $0
+    i32.const 1024
+    i32.load
+    call $32
+  )
+  (func $35 (;48;) (type $1) (param $0 i32) (result i32)
+    (local $1 i32) (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32) (local $15 i32) (local $16 i32) (local $17 i32) (local $18 i32) (local $19 i32) (local $20 i32) (local $21 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $14
+      global.get $global$1
+      i32.const 16
+      i32.add
+      global.set $global$1
+      local.get $14
+      local.set $18
+      block $label$2 ;; label = @2
+        local.get $0
+        i32.const 245
+        i32.lt_u
+        if ;; label = @3
+          block ;; label = @4
+            local.get $0
+            i32.const 11
+            i32.add
+            i32.const -8
+            i32.and
+            local.set $3
+            i32.const 3652
+            i32.load
+            local.tee $8
+            local.get $0
+            i32.const 11
+            i32.lt_u
+            if (result i32) ;; label = @5
+              i32.const 16
+              local.tee $3
+            else
+              local.get $3
+            end
+            i32.const 3
+            i32.shr_u
+            local.tee $2
+            i32.shr_u
+            local.tee $0
+            i32.const 3
+            i32.and
+            if ;; label = @5
+              block ;; label = @6
+                local.get $0
+                i32.const 1
+                i32.and
+                i32.const 1
+                i32.xor
+                local.get $2
+                i32.add
+                local.tee $5
+                i32.const 1
+                i32.shl
+                i32.const 2
+                i32.shl
+                i32.const 3692
+                i32.add
+                local.tee $2
+                i32.const 8
+                i32.add
+                local.tee $3
+                i32.load
+                local.tee $7
+                i32.const 8
+                i32.add
+                local.tee $1
+                i32.load
+                local.set $4
+                local.get $2
+                local.get $4
+                i32.eq
+                if ;; label = @7
+                  i32.const 3652
+                  local.get $8
+                  i32.const 1
+                  local.get $5
+                  i32.shl
+                  i32.const -1
+                  i32.xor
+                  i32.and
+                  i32.store
+                else
+                  block ;; label = @8
+                    local.get $4
+                    i32.const 3668
+                    i32.load
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                    local.get $4
+                    i32.const 12
+                    i32.add
+                    local.tee $0
+                    i32.load
+                    local.get $7
+                    i32.eq
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $0
+                        local.get $2
+                        i32.store
+                        local.get $3
+                        local.get $4
+                        i32.store
+                      end
+                    else
+                      call $fimport$10
+                    end
+                  end
+                end
+                local.get $7
+                local.get $5
+                i32.const 3
+                i32.shl
+                local.tee $0
+                i32.const 3
+                i32.or
+                i32.store offset=4
+                local.get $7
+                local.get $0
+                i32.add
+                i32.const 4
+                i32.add
+                local.tee $0
+                local.get $0
+                i32.load
+                i32.const 1
+                i32.or
+                i32.store
+                local.get $14
+                global.set $global$1
+                local.get $1
+                return
+              end
+            end
+            local.get $3
+            i32.const 3660
+            i32.load
+            local.tee $16
+            i32.gt_u
+            if ;; label = @5
+              block ;; label = @6
+                local.get $0
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $0
+                    local.get $2
+                    i32.shl
+                    i32.const 2
+                    local.get $2
+                    i32.shl
+                    local.tee $0
+                    i32.const 0
+                    local.get $0
+                    i32.sub
+                    i32.or
+                    i32.and
+                    local.tee $0
+                    i32.const 0
+                    local.get $0
+                    i32.sub
+                    i32.and
+                    i32.const -1
+                    i32.add
+                    local.tee $0
+                    i32.const 12
+                    i32.shr_u
+                    i32.const 16
+                    i32.and
+                    local.set $5
+                    local.get $0
+                    local.get $5
+                    i32.shr_u
+                    local.tee $2
+                    i32.const 5
+                    i32.shr_u
+                    i32.const 8
+                    i32.and
+                    local.tee $0
+                    local.get $5
+                    i32.or
+                    local.get $2
+                    local.get $0
+                    i32.shr_u
+                    local.tee $2
+                    i32.const 2
+                    i32.shr_u
+                    i32.const 4
+                    i32.and
+                    local.tee $0
+                    i32.or
+                    local.get $2
+                    local.get $0
+                    i32.shr_u
+                    local.tee $2
+                    i32.const 1
+                    i32.shr_u
+                    i32.const 2
+                    i32.and
+                    local.tee $0
+                    i32.or
+                    local.get $2
+                    local.get $0
+                    i32.shr_u
+                    local.tee $2
+                    i32.const 1
+                    i32.shr_u
+                    i32.const 1
+                    i32.and
+                    local.tee $0
+                    i32.or
+                    local.get $2
+                    local.get $0
+                    i32.shr_u
+                    i32.add
+                    local.tee $11
+                    i32.const 1
+                    i32.shl
+                    i32.const 2
+                    i32.shl
+                    i32.const 3692
+                    i32.add
+                    local.tee $4
+                    i32.const 8
+                    i32.add
+                    local.tee $2
+                    i32.load
+                    local.tee $9
+                    i32.const 8
+                    i32.add
+                    local.tee $5
+                    i32.load
+                    local.set $12
+                    local.get $4
+                    local.get $12
+                    i32.eq
+                    if ;; label = @9
+                      i32.const 3652
+                      local.get $8
+                      i32.const 1
+                      local.get $11
+                      i32.shl
+                      i32.const -1
+                      i32.xor
+                      i32.and
+                      local.tee $7
+                      i32.store
+                    else
+                      block ;; label = @10
+                        local.get $12
+                        i32.const 3668
+                        i32.load
+                        i32.lt_u
+                        if ;; label = @11
+                          call $fimport$10
+                        end
+                        local.get $12
+                        i32.const 12
+                        i32.add
+                        local.tee $0
+                        i32.load
+                        local.get $9
+                        i32.eq
+                        if ;; label = @11
+                          block ;; label = @12
+                            local.get $0
+                            local.get $4
+                            i32.store
+                            local.get $2
+                            local.get $12
+                            i32.store
+                            local.get $8
+                            local.set $7
+                          end
+                        else
+                          call $fimport$10
+                        end
+                      end
+                    end
+                    local.get $9
+                    local.get $3
+                    i32.const 3
+                    i32.or
+                    i32.store offset=4
+                    local.get $9
+                    local.get $3
+                    i32.add
+                    local.tee $4
+                    local.get $11
+                    i32.const 3
+                    i32.shl
+                    local.get $3
+                    i32.sub
+                    local.tee $11
+                    i32.const 1
+                    i32.or
+                    i32.store offset=4
+                    local.get $4
+                    local.get $11
+                    i32.add
+                    local.get $11
+                    i32.store
+                    local.get $16
+                    if ;; label = @9
+                      block ;; label = @10
+                        i32.const 3672
+                        i32.load
+                        local.set $9
+                        local.get $16
+                        i32.const 3
+                        i32.shr_u
+                        local.tee $0
+                        i32.const 1
+                        i32.shl
+                        i32.const 2
+                        i32.shl
+                        i32.const 3692
+                        i32.add
+                        local.set $2
+                        local.get $7
+                        i32.const 1
+                        local.get $0
+                        i32.shl
+                        local.tee $0
+                        i32.and
+                        if ;; label = @11
+                          local.get $2
+                          i32.const 8
+                          i32.add
+                          local.tee $3
+                          i32.load
+                          local.tee $0
+                          i32.const 3668
+                          i32.load
+                          i32.lt_u
+                          if ;; label = @12
+                            call $fimport$10
+                          else
+                            block ;; label = @13
+                              local.get $3
+                              local.set $6
+                              local.get $0
+                              local.set $1
+                            end
+                          end
+                        else
+                          block ;; label = @12
+                            i32.const 3652
+                            local.get $7
+                            local.get $0
+                            i32.or
+                            i32.store
+                            local.get $2
+                            i32.const 8
+                            i32.add
+                            local.set $6
+                            local.get $2
+                            local.set $1
+                          end
+                        end
+                        local.get $6
+                        local.get $9
+                        i32.store
+                        local.get $1
+                        local.get $9
+                        i32.store offset=12
+                        local.get $9
+                        local.get $1
+                        i32.store offset=8
+                        local.get $9
+                        local.get $2
+                        i32.store offset=12
+                      end
+                    end
+                    i32.const 3660
+                    local.get $11
+                    i32.store
+                    i32.const 3672
+                    local.get $4
+                    i32.store
+                    local.get $14
+                    global.set $global$1
+                    local.get $5
+                    return
+                  end
+                end
+                i32.const 3656
+                i32.load
+                local.tee $6
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $6
+                    i32.const 0
+                    local.get $6
+                    i32.sub
+                    i32.and
+                    i32.const -1
+                    i32.add
+                    local.tee $0
+                    i32.const 12
+                    i32.shr_u
+                    i32.const 16
+                    i32.and
+                    local.set $2
+                    local.get $0
+                    local.get $2
+                    i32.shr_u
+                    local.tee $1
+                    i32.const 5
+                    i32.shr_u
+                    i32.const 8
+                    i32.and
+                    local.tee $0
+                    local.get $2
+                    i32.or
+                    local.get $1
+                    local.get $0
+                    i32.shr_u
+                    local.tee $1
+                    i32.const 2
+                    i32.shr_u
+                    i32.const 4
+                    i32.and
+                    local.tee $0
+                    i32.or
+                    local.get $1
+                    local.get $0
+                    i32.shr_u
+                    local.tee $1
+                    i32.const 1
+                    i32.shr_u
+                    i32.const 2
+                    i32.and
+                    local.tee $0
+                    i32.or
+                    local.get $1
+                    local.get $0
+                    i32.shr_u
+                    local.tee $1
+                    i32.const 1
+                    i32.shr_u
+                    i32.const 1
+                    i32.and
+                    local.tee $0
+                    i32.or
+                    local.get $1
+                    local.get $0
+                    i32.shr_u
+                    i32.add
+                    i32.const 2
+                    i32.shl
+                    i32.const 3956
+                    i32.add
+                    i32.load
+                    local.tee $2
+                    i32.load offset=4
+                    i32.const -8
+                    i32.and
+                    local.get $3
+                    i32.sub
+                    local.set $9
+                    local.get $2
+                    local.set $1
+                    loop $label$25 ;; label = @9
+                      block $label$26 ;; label = @10
+                        local.get $1
+                        i32.load offset=16
+                        local.tee $0
+                        i32.eqz
+                        if ;; label = @11
+                          local.get $1
+                          i32.load offset=20
+                          local.tee $0
+                          i32.eqz
+                          br_if 1 (;@10;)
+                        end
+                        local.get $0
+                        i32.load offset=4
+                        i32.const -8
+                        i32.and
+                        local.get $3
+                        i32.sub
+                        local.tee $1
+                        local.get $9
+                        i32.lt_u
+                        local.tee $7
+                        if ;; label = @11
+                          local.get $1
+                          local.set $9
+                        end
+                        local.get $0
+                        local.set $1
+                        local.get $7
+                        if ;; label = @11
+                          local.get $0
+                          local.set $2
+                        end
+                        br 1 (;@9;)
+                      end
+                    end
+                    local.get $2
+                    i32.const 3668
+                    i32.load
+                    local.tee $12
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                    local.get $2
+                    local.get $2
+                    local.get $3
+                    i32.add
+                    local.tee $13
+                    i32.ge_u
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                    local.get $2
+                    i32.load offset=24
+                    local.set $15
+                    block $label$32 ;; label = @9
+                      local.get $2
+                      i32.load offset=12
+                      local.tee $0
+                      local.get $2
+                      i32.eq
+                      if ;; label = @10
+                        block ;; label = @11
+                          local.get $2
+                          i32.const 20
+                          i32.add
+                          local.tee $1
+                          i32.load
+                          local.tee $0
+                          i32.eqz
+                          if ;; label = @12
+                            local.get $2
+                            i32.const 16
+                            i32.add
+                            local.tee $1
+                            i32.load
+                            local.tee $0
+                            i32.eqz
+                            if ;; label = @13
+                              block ;; label = @14
+                                i32.const 0
+                                local.set $4
+                                br 5 (;@9;)
+                              end
+                            end
+                          end
+                          loop $label$36 ;; label = @12
+                            local.get $0
+                            i32.const 20
+                            i32.add
+                            local.tee $11
+                            i32.load
+                            local.tee $7
+                            if ;; label = @13
+                              block ;; label = @14
+                                local.get $7
+                                local.set $0
+                                local.get $11
+                                local.set $1
+                                br 2 (;@12;)
+                              end
+                            end
+                            local.get $0
+                            i32.const 16
+                            i32.add
+                            local.tee $11
+                            i32.load
+                            local.tee $7
+                            if ;; label = @13
+                              block ;; label = @14
+                                local.get $7
+                                local.set $0
+                                local.get $11
+                                local.set $1
+                                br 2 (;@12;)
+                              end
+                            end
+                          end
+                          local.get $1
+                          local.get $12
+                          i32.lt_u
+                          if ;; label = @12
+                            call $fimport$10
+                          else
+                            block ;; label = @13
+                              local.get $1
+                              i32.const 0
+                              i32.store
+                              local.get $0
+                              local.set $4
+                            end
+                          end
+                        end
+                      else
+                        block ;; label = @11
+                          local.get $2
+                          i32.load offset=8
+                          local.tee $11
+                          local.get $12
+                          i32.lt_u
+                          if ;; label = @12
+                            call $fimport$10
+                          end
+                          local.get $11
+                          i32.const 12
+                          i32.add
+                          local.tee $7
+                          i32.load
+                          local.get $2
+                          i32.ne
+                          if ;; label = @12
+                            call $fimport$10
+                          end
+                          local.get $0
+                          i32.const 8
+                          i32.add
+                          local.tee $1
+                          i32.load
+                          local.get $2
+                          i32.eq
+                          if ;; label = @12
+                            block ;; label = @13
+                              local.get $7
+                              local.get $0
+                              i32.store
+                              local.get $1
+                              local.get $11
+                              i32.store
+                              local.get $0
+                              local.set $4
+                            end
+                          else
+                            call $fimport$10
+                          end
+                        end
+                      end
+                    end
+                    block $label$46 ;; label = @9
+                      local.get $15
+                      if ;; label = @10
+                        block ;; label = @11
+                          local.get $2
+                          local.get $2
+                          i32.load offset=28
+                          local.tee $1
+                          i32.const 2
+                          i32.shl
+                          i32.const 3956
+                          i32.add
+                          local.tee $0
+                          i32.load
+                          i32.eq
+                          if ;; label = @12
+                            block ;; label = @13
+                              local.get $0
+                              local.get $4
+                              i32.store
+                              local.get $4
+                              i32.eqz
+                              if ;; label = @14
+                                block ;; label = @15
+                                  i32.const 3656
+                                  local.get $6
+                                  i32.const 1
+                                  local.get $1
+                                  i32.shl
+                                  i32.const -1
+                                  i32.xor
+                                  i32.and
+                                  i32.store
+                                  br 6 (;@9;)
+                                end
+                              end
+                            end
+                          else
+                            block ;; label = @13
+                              local.get $15
+                              i32.const 3668
+                              i32.load
+                              i32.lt_u
+                              if ;; label = @14
+                                call $fimport$10
+                              end
+                              local.get $15
+                              i32.const 16
+                              i32.add
+                              local.tee $0
+                              i32.load
+                              local.get $2
+                              i32.eq
+                              if ;; label = @14
+                                local.get $0
+                                local.get $4
+                                i32.store
+                              else
+                                local.get $15
+                                local.get $4
+                                i32.store offset=20
+                              end
+                              local.get $4
+                              i32.eqz
+                              br_if 4 (;@9;)
+                            end
+                          end
+                          local.get $4
+                          i32.const 3668
+                          i32.load
+                          local.tee $0
+                          i32.lt_u
+                          if ;; label = @12
+                            call $fimport$10
+                          end
+                          local.get $4
+                          local.get $15
+                          i32.store offset=24
+                          local.get $2
+                          i32.load offset=16
+                          local.tee $1
+                          if ;; label = @12
+                            local.get $1
+                            local.get $0
+                            i32.lt_u
+                            if ;; label = @13
+                              call $fimport$10
+                            else
+                              block ;; label = @14
+                                local.get $4
+                                local.get $1
+                                i32.store offset=16
+                                local.get $1
+                                local.get $4
+                                i32.store offset=24
+                              end
+                            end
+                          end
+                          local.get $2
+                          i32.load offset=20
+                          local.tee $0
+                          if ;; label = @12
+                            local.get $0
+                            i32.const 3668
+                            i32.load
+                            i32.lt_u
+                            if ;; label = @13
+                              call $fimport$10
+                            else
+                              block ;; label = @14
+                                local.get $4
+                                local.get $0
+                                i32.store offset=20
+                                local.get $0
+                                local.get $4
+                                i32.store offset=24
+                              end
+                            end
+                          end
+                        end
+                      end
+                    end
+                    local.get $9
+                    i32.const 16
+                    i32.lt_u
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $2
+                        local.get $9
+                        local.get $3
+                        i32.add
+                        local.tee $0
+                        i32.const 3
+                        i32.or
+                        i32.store offset=4
+                        local.get $2
+                        local.get $0
+                        i32.add
+                        i32.const 4
+                        i32.add
+                        local.tee $0
+                        local.get $0
+                        i32.load
+                        i32.const 1
+                        i32.or
+                        i32.store
+                      end
+                    else
+                      block ;; label = @10
+                        local.get $2
+                        local.get $3
+                        i32.const 3
+                        i32.or
+                        i32.store offset=4
+                        local.get $13
+                        local.get $9
+                        i32.const 1
+                        i32.or
+                        i32.store offset=4
+                        local.get $13
+                        local.get $9
+                        i32.add
+                        local.get $9
+                        i32.store
+                        local.get $16
+                        if ;; label = @11
+                          block ;; label = @12
+                            i32.const 3672
+                            i32.load
+                            local.set $7
+                            local.get $16
+                            i32.const 3
+                            i32.shr_u
+                            local.tee $0
+                            i32.const 1
+                            i32.shl
+                            i32.const 2
+                            i32.shl
+                            i32.const 3692
+                            i32.add
+                            local.set $3
+                            local.get $8
+                            i32.const 1
+                            local.get $0
+                            i32.shl
+                            local.tee $0
+                            i32.and
+                            if ;; label = @13
+                              local.get $3
+                              i32.const 8
+                              i32.add
+                              local.tee $1
+                              i32.load
+                              local.tee $0
+                              i32.const 3668
+                              i32.load
+                              i32.lt_u
+                              if ;; label = @14
+                                call $fimport$10
+                              else
+                                block ;; label = @15
+                                  local.get $1
+                                  local.set $10
+                                  local.get $0
+                                  local.set $5
+                                end
+                              end
+                            else
+                              block ;; label = @14
+                                i32.const 3652
+                                local.get $8
+                                local.get $0
+                                i32.or
+                                i32.store
+                                local.get $3
+                                i32.const 8
+                                i32.add
+                                local.set $10
+                                local.get $3
+                                local.set $5
+                              end
+                            end
+                            local.get $10
+                            local.get $7
+                            i32.store
+                            local.get $5
+                            local.get $7
+                            i32.store offset=12
+                            local.get $7
+                            local.get $5
+                            i32.store offset=8
+                            local.get $7
+                            local.get $3
+                            i32.store offset=12
+                          end
+                        end
+                        i32.const 3660
+                        local.get $9
+                        i32.store
+                        i32.const 3672
+                        local.get $13
+                        i32.store
+                      end
+                    end
+                    local.get $14
+                    global.set $global$1
+                    local.get $2
+                    i32.const 8
+                    i32.add
+                    return
+                  end
+                else
+                  local.get $3
+                  local.set $0
+                end
+              end
+            else
+              local.get $3
+              local.set $0
+            end
+          end
+        else
+          local.get $0
+          i32.const -65
+          i32.gt_u
+          if ;; label = @4
+            i32.const -1
+            local.set $0
+          else
+            block ;; label = @5
+              local.get $0
+              i32.const 11
+              i32.add
+              local.tee $0
+              i32.const -8
+              i32.and
+              local.set $7
+              i32.const 3656
+              i32.load
+              local.tee $5
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $0
+                  i32.const 8
+                  i32.shr_u
+                  local.tee $0
+                  if (result i32) ;; label = @8
+                    local.get $7
+                    i32.const 16777215
+                    i32.gt_u
+                    if (result i32) ;; label = @9
+                      i32.const 31
+                    else
+                      local.get $7
+                      i32.const 14
+                      local.get $0
+                      local.get $0
+                      i32.const 1048320
+                      i32.add
+                      i32.const 16
+                      i32.shr_u
+                      i32.const 8
+                      i32.and
+                      local.tee $3
+                      i32.shl
+                      local.tee $1
+                      i32.const 520192
+                      i32.add
+                      i32.const 16
+                      i32.shr_u
+                      i32.const 4
+                      i32.and
+                      local.tee $0
+                      local.get $3
+                      i32.or
+                      local.get $1
+                      local.get $0
+                      i32.shl
+                      local.tee $1
+                      i32.const 245760
+                      i32.add
+                      i32.const 16
+                      i32.shr_u
+                      i32.const 2
+                      i32.and
+                      local.tee $0
+                      i32.or
+                      i32.sub
+                      local.get $1
+                      local.get $0
+                      i32.shl
+                      i32.const 15
+                      i32.shr_u
+                      i32.add
+                      local.tee $0
+                      i32.const 7
+                      i32.add
+                      i32.shr_u
+                      i32.const 1
+                      i32.and
+                      local.get $0
+                      i32.const 1
+                      i32.shl
+                      i32.or
+                    end
+                  else
+                    i32.const 0
+                  end
+                  local.set $17
+                  i32.const 0
+                  local.get $7
+                  i32.sub
+                  local.set $3
+                  block $label$78 ;; label = @8
+                    block $label$79 ;; label = @9
+                      block $label$80 ;; label = @10
+                        local.get $17
+                        i32.const 2
+                        i32.shl
+                        i32.const 3956
+                        i32.add
+                        i32.load
+                        local.tee $1
+                        if ;; label = @11
+                          block ;; label = @12
+                            i32.const 25
+                            local.get $17
+                            i32.const 1
+                            i32.shr_u
+                            i32.sub
+                            local.set $0
+                            i32.const 0
+                            local.set $4
+                            local.get $7
+                            local.get $17
+                            i32.const 31
+                            i32.eq
+                            if (result i32) ;; label = @13
+                              i32.const 0
+                            else
+                              local.get $0
+                            end
+                            i32.shl
+                            local.set $10
+                            i32.const 0
+                            local.set $0
+                            loop $label$84 ;; label = @13
+                              local.get $1
+                              i32.load offset=4
+                              i32.const -8
+                              i32.and
+                              local.get $7
+                              i32.sub
+                              local.tee $6
+                              local.get $3
+                              i32.lt_u
+                              if ;; label = @14
+                                local.get $6
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $6
+                                    local.set $3
+                                    local.get $1
+                                    local.set $0
+                                  end
+                                else
+                                  block ;; label = @16
+                                    i32.const 0
+                                    local.set $3
+                                    local.get $1
+                                    local.set $0
+                                    br 7 (;@9;)
+                                  end
+                                end
+                              end
+                              local.get $1
+                              i32.load offset=20
+                              local.tee $19
+                              i32.eqz
+                              local.get $19
+                              local.get $1
+                              i32.const 16
+                              i32.add
+                              local.get $10
+                              i32.const 31
+                              i32.shr_u
+                              i32.const 2
+                              i32.shl
+                              i32.add
+                              i32.load
+                              local.tee $6
+                              i32.eq
+                              i32.or
+                              if (result i32) ;; label = @14
+                                local.get $4
+                              else
+                                local.get $19
+                              end
+                              local.set $1
+                              local.get $10
+                              local.get $6
+                              i32.eqz
+                              local.tee $4
+                              i32.const 1
+                              i32.and
+                              i32.const 1
+                              i32.xor
+                              i32.shl
+                              local.set $10
+                              local.get $4
+                              if ;; label = @14
+                                block ;; label = @15
+                                  local.get $1
+                                  local.set $4
+                                  local.get $0
+                                  local.set $1
+                                  br 5 (;@10;)
+                                end
+                              else
+                                block ;; label = @15
+                                  local.get $1
+                                  local.set $4
+                                  local.get $6
+                                  local.set $1
+                                  br 2 (;@13;)
+                                end
+                              end
+                            end
+                          end
+                        else
+                          block ;; label = @12
+                            i32.const 0
+                            local.set $4
+                            i32.const 0
+                            local.set $1
+                          end
+                        end
+                      end
+                      local.get $4
+                      i32.eqz
+                      local.get $1
+                      i32.eqz
+                      i32.and
+                      if (result i32) ;; label = @10
+                        block (result i32) ;; label = @11
+                          local.get $5
+                          i32.const 2
+                          local.get $17
+                          i32.shl
+                          local.tee $0
+                          i32.const 0
+                          local.get $0
+                          i32.sub
+                          i32.or
+                          i32.and
+                          local.tee $0
+                          i32.eqz
+                          if ;; label = @12
+                            block ;; label = @13
+                              local.get $7
+                              local.set $0
+                              br 11 (;@2;)
+                            end
+                          end
+                          local.get $0
+                          i32.const 0
+                          local.get $0
+                          i32.sub
+                          i32.and
+                          i32.const -1
+                          i32.add
+                          local.tee $0
+                          i32.const 12
+                          i32.shr_u
+                          i32.const 16
+                          i32.and
+                          local.set $10
+                          local.get $0
+                          local.get $10
+                          i32.shr_u
+                          local.tee $4
+                          i32.const 5
+                          i32.shr_u
+                          i32.const 8
+                          i32.and
+                          local.tee $0
+                          local.get $10
+                          i32.or
+                          local.get $4
+                          local.get $0
+                          i32.shr_u
+                          local.tee $4
+                          i32.const 2
+                          i32.shr_u
+                          i32.const 4
+                          i32.and
+                          local.tee $0
+                          i32.or
+                          local.get $4
+                          local.get $0
+                          i32.shr_u
+                          local.tee $4
+                          i32.const 1
+                          i32.shr_u
+                          i32.const 2
+                          i32.and
+                          local.tee $0
+                          i32.or
+                          local.get $4
+                          local.get $0
+                          i32.shr_u
+                          local.tee $4
+                          i32.const 1
+                          i32.shr_u
+                          i32.const 1
+                          i32.and
+                          local.tee $0
+                          i32.or
+                          local.get $4
+                          local.get $0
+                          i32.shr_u
+                          i32.add
+                          i32.const 2
+                          i32.shl
+                          i32.const 3956
+                          i32.add
+                          i32.load
+                        end
+                      else
+                        local.get $4
+                      end
+                      local.tee $0
+                      br_if 0 (;@9;)
+                      local.get $1
+                      local.set $4
+                      br 1 (;@8;)
+                    end
+                    loop $label$96 ;; label = @9
+                      local.get $0
+                      i32.load offset=4
+                      i32.const -8
+                      i32.and
+                      local.get $7
+                      i32.sub
+                      local.tee $4
+                      local.get $3
+                      i32.lt_u
+                      local.tee $10
+                      if ;; label = @10
+                        local.get $4
+                        local.set $3
+                      end
+                      local.get $10
+                      if ;; label = @10
+                        local.get $0
+                        local.set $1
+                      end
+                      local.get $0
+                      i32.load offset=16
+                      local.tee $4
+                      if ;; label = @10
+                        block ;; label = @11
+                          local.get $4
+                          local.set $0
+                          br 2 (;@9;)
+                        end
+                      end
+                      local.get $0
+                      i32.load offset=20
+                      local.tee $0
+                      br_if 0 (;@9;)
+                      local.get $1
+                      local.set $4
+                    end
+                  end
+                  local.get $4
+                  if ;; label = @8
+                    local.get $3
+                    i32.const 3660
+                    i32.load
+                    local.get $7
+                    i32.sub
+                    i32.lt_u
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $4
+                        i32.const 3668
+                        i32.load
+                        local.tee $12
+                        i32.lt_u
+                        if ;; label = @11
+                          call $fimport$10
+                        end
+                        local.get $4
+                        local.get $4
+                        local.get $7
+                        i32.add
+                        local.tee $6
+                        i32.ge_u
+                        if ;; label = @11
+                          call $fimport$10
+                        end
+                        local.get $4
+                        i32.load offset=24
+                        local.set $10
+                        block $label$104 ;; label = @11
+                          local.get $4
+                          i32.load offset=12
+                          local.tee $0
+                          local.get $4
+                          i32.eq
+                          if ;; label = @12
+                            block ;; label = @13
+                              local.get $4
+                              i32.const 20
+                              i32.add
+                              local.tee $1
+                              i32.load
+                              local.tee $0
+                              i32.eqz
+                              if ;; label = @14
+                                local.get $4
+                                i32.const 16
+                                i32.add
+                                local.tee $1
+                                i32.load
+                                local.tee $0
+                                i32.eqz
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    i32.const 0
+                                    local.set $13
+                                    br 5 (;@11;)
+                                  end
+                                end
+                              end
+                              loop $label$108 ;; label = @14
+                                local.get $0
+                                i32.const 20
+                                i32.add
+                                local.tee $9
+                                i32.load
+                                local.tee $11
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $11
+                                    local.set $0
+                                    local.get $9
+                                    local.set $1
+                                    br 2 (;@14;)
+                                  end
+                                end
+                                local.get $0
+                                i32.const 16
+                                i32.add
+                                local.tee $9
+                                i32.load
+                                local.tee $11
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $11
+                                    local.set $0
+                                    local.get $9
+                                    local.set $1
+                                    br 2 (;@14;)
+                                  end
+                                end
+                              end
+                              local.get $1
+                              local.get $12
+                              i32.lt_u
+                              if ;; label = @14
+                                call $fimport$10
+                              else
+                                block ;; label = @15
+                                  local.get $1
+                                  i32.const 0
+                                  i32.store
+                                  local.get $0
+                                  local.set $13
+                                end
+                              end
+                            end
+                          else
+                            block ;; label = @13
+                              local.get $4
+                              i32.load offset=8
+                              local.tee $9
+                              local.get $12
+                              i32.lt_u
+                              if ;; label = @14
+                                call $fimport$10
+                              end
+                              local.get $9
+                              i32.const 12
+                              i32.add
+                              local.tee $11
+                              i32.load
+                              local.get $4
+                              i32.ne
+                              if ;; label = @14
+                                call $fimport$10
+                              end
+                              local.get $0
+                              i32.const 8
+                              i32.add
+                              local.tee $1
+                              i32.load
+                              local.get $4
+                              i32.eq
+                              if ;; label = @14
+                                block ;; label = @15
+                                  local.get $11
+                                  local.get $0
+                                  i32.store
+                                  local.get $1
+                                  local.get $9
+                                  i32.store
+                                  local.get $0
+                                  local.set $13
+                                end
+                              else
+                                call $fimport$10
+                              end
+                            end
+                          end
+                        end
+                        block $label$118 ;; label = @11
+                          local.get $10
+                          if ;; label = @12
+                            block ;; label = @13
+                              local.get $4
+                              local.get $4
+                              i32.load offset=28
+                              local.tee $1
+                              i32.const 2
+                              i32.shl
+                              i32.const 3956
+                              i32.add
+                              local.tee $0
+                              i32.load
+                              i32.eq
+                              if ;; label = @14
+                                block ;; label = @15
+                                  local.get $0
+                                  local.get $13
+                                  i32.store
+                                  local.get $13
+                                  i32.eqz
+                                  if ;; label = @16
+                                    block ;; label = @17
+                                      i32.const 3656
+                                      local.get $5
+                                      i32.const 1
+                                      local.get $1
+                                      i32.shl
+                                      i32.const -1
+                                      i32.xor
+                                      i32.and
+                                      local.tee $2
+                                      i32.store
+                                      br 6 (;@11;)
+                                    end
+                                  end
+                                end
+                              else
+                                block ;; label = @15
+                                  local.get $10
+                                  i32.const 3668
+                                  i32.load
+                                  i32.lt_u
+                                  if ;; label = @16
+                                    call $fimport$10
+                                  end
+                                  local.get $10
+                                  i32.const 16
+                                  i32.add
+                                  local.tee $0
+                                  i32.load
+                                  local.get $4
+                                  i32.eq
+                                  if ;; label = @16
+                                    local.get $0
+                                    local.get $13
+                                    i32.store
+                                  else
+                                    local.get $10
+                                    local.get $13
+                                    i32.store offset=20
+                                  end
+                                  local.get $13
+                                  i32.eqz
+                                  if ;; label = @16
+                                    block ;; label = @17
+                                      local.get $5
+                                      local.set $2
+                                      br 6 (;@11;)
+                                    end
+                                  end
+                                end
+                              end
+                              local.get $13
+                              i32.const 3668
+                              i32.load
+                              local.tee $0
+                              i32.lt_u
+                              if ;; label = @14
+                                call $fimport$10
+                              end
+                              local.get $13
+                              local.get $10
+                              i32.store offset=24
+                              local.get $4
+                              i32.load offset=16
+                              local.tee $1
+                              if ;; label = @14
+                                local.get $1
+                                local.get $0
+                                i32.lt_u
+                                if ;; label = @15
+                                  call $fimport$10
+                                else
+                                  block ;; label = @16
+                                    local.get $13
+                                    local.get $1
+                                    i32.store offset=16
+                                    local.get $1
+                                    local.get $13
+                                    i32.store offset=24
+                                  end
+                                end
+                              end
+                              local.get $4
+                              i32.load offset=20
+                              local.tee $0
+                              if ;; label = @14
+                                local.get $0
+                                i32.const 3668
+                                i32.load
+                                i32.lt_u
+                                if ;; label = @15
+                                  call $fimport$10
+                                else
+                                  block ;; label = @16
+                                    local.get $13
+                                    local.get $0
+                                    i32.store offset=20
+                                    local.get $0
+                                    local.get $13
+                                    i32.store offset=24
+                                    local.get $5
+                                    local.set $2
+                                  end
+                                end
+                              else
+                                local.get $5
+                                local.set $2
+                              end
+                            end
+                          else
+                            local.get $5
+                            local.set $2
+                          end
+                        end
+                        block $label$136 ;; label = @11
+                          local.get $3
+                          i32.const 16
+                          i32.lt_u
+                          if ;; label = @12
+                            block ;; label = @13
+                              local.get $4
+                              local.get $3
+                              local.get $7
+                              i32.add
+                              local.tee $0
+                              i32.const 3
+                              i32.or
+                              i32.store offset=4
+                              local.get $4
+                              local.get $0
+                              i32.add
+                              i32.const 4
+                              i32.add
+                              local.tee $0
+                              local.get $0
+                              i32.load
+                              i32.const 1
+                              i32.or
+                              i32.store
+                            end
+                          else
+                            block ;; label = @13
+                              local.get $4
+                              local.get $7
+                              i32.const 3
+                              i32.or
+                              i32.store offset=4
+                              local.get $6
+                              local.get $3
+                              i32.const 1
+                              i32.or
+                              i32.store offset=4
+                              local.get $6
+                              local.get $3
+                              i32.add
+                              local.get $3
+                              i32.store
+                              local.get $3
+                              i32.const 3
+                              i32.shr_u
+                              local.set $0
+                              local.get $3
+                              i32.const 256
+                              i32.lt_u
+                              if ;; label = @14
+                                block ;; label = @15
+                                  local.get $0
+                                  i32.const 1
+                                  i32.shl
+                                  i32.const 2
+                                  i32.shl
+                                  i32.const 3692
+                                  i32.add
+                                  local.set $3
+                                  i32.const 3652
+                                  i32.load
+                                  local.tee $1
+                                  i32.const 1
+                                  local.get $0
+                                  i32.shl
+                                  local.tee $0
+                                  i32.and
+                                  if ;; label = @16
+                                    local.get $3
+                                    i32.const 8
+                                    i32.add
+                                    local.tee $1
+                                    i32.load
+                                    local.tee $0
+                                    i32.const 3668
+                                    i32.load
+                                    i32.lt_u
+                                    if ;; label = @17
+                                      call $fimport$10
+                                    else
+                                      block ;; label = @18
+                                        local.get $1
+                                        local.set $16
+                                        local.get $0
+                                        local.set $8
+                                      end
+                                    end
+                                  else
+                                    block ;; label = @17
+                                      i32.const 3652
+                                      local.get $1
+                                      local.get $0
+                                      i32.or
+                                      i32.store
+                                      local.get $3
+                                      i32.const 8
+                                      i32.add
+                                      local.set $16
+                                      local.get $3
+                                      local.set $8
+                                    end
+                                  end
+                                  local.get $16
+                                  local.get $6
+                                  i32.store
+                                  local.get $8
+                                  local.get $6
+                                  i32.store offset=12
+                                  local.get $6
+                                  local.get $8
+                                  i32.store offset=8
+                                  local.get $6
+                                  local.get $3
+                                  i32.store offset=12
+                                  br 4 (;@11;)
+                                end
+                              end
+                              local.get $3
+                              i32.const 8
+                              i32.shr_u
+                              local.tee $0
+                              if (result i32) ;; label = @14
+                                local.get $3
+                                i32.const 16777215
+                                i32.gt_u
+                                if (result i32) ;; label = @15
+                                  i32.const 31
+                                else
+                                  local.get $3
+                                  i32.const 14
+                                  local.get $0
+                                  local.get $0
+                                  i32.const 1048320
+                                  i32.add
+                                  i32.const 16
+                                  i32.shr_u
+                                  i32.const 8
+                                  i32.and
+                                  local.tee $5
+                                  i32.shl
+                                  local.tee $1
+                                  i32.const 520192
+                                  i32.add
+                                  i32.const 16
+                                  i32.shr_u
+                                  i32.const 4
+                                  i32.and
+                                  local.tee $0
+                                  local.get $5
+                                  i32.or
+                                  local.get $1
+                                  local.get $0
+                                  i32.shl
+                                  local.tee $1
+                                  i32.const 245760
+                                  i32.add
+                                  i32.const 16
+                                  i32.shr_u
+                                  i32.const 2
+                                  i32.and
+                                  local.tee $0
+                                  i32.or
+                                  i32.sub
+                                  local.get $1
+                                  local.get $0
+                                  i32.shl
+                                  i32.const 15
+                                  i32.shr_u
+                                  i32.add
+                                  local.tee $0
+                                  i32.const 7
+                                  i32.add
+                                  i32.shr_u
+                                  i32.const 1
+                                  i32.and
+                                  local.get $0
+                                  i32.const 1
+                                  i32.shl
+                                  i32.or
+                                end
+                              else
+                                i32.const 0
+                              end
+                              local.tee $5
+                              i32.const 2
+                              i32.shl
+                              i32.const 3956
+                              i32.add
+                              local.set $1
+                              local.get $6
+                              local.get $5
+                              i32.store offset=28
+                              local.get $6
+                              i32.const 16
+                              i32.add
+                              local.tee $0
+                              i32.const 0
+                              i32.store offset=4
+                              local.get $0
+                              i32.const 0
+                              i32.store
+                              local.get $2
+                              i32.const 1
+                              local.get $5
+                              i32.shl
+                              local.tee $0
+                              i32.and
+                              i32.eqz
+                              if ;; label = @14
+                                block ;; label = @15
+                                  i32.const 3656
+                                  local.get $2
+                                  local.get $0
+                                  i32.or
+                                  i32.store
+                                  local.get $1
+                                  local.get $6
+                                  i32.store
+                                  local.get $6
+                                  local.get $1
+                                  i32.store offset=24
+                                  local.get $6
+                                  local.get $6
+                                  i32.store offset=12
+                                  local.get $6
+                                  local.get $6
+                                  i32.store offset=8
+                                  br 4 (;@11;)
+                                end
+                              end
+                              local.get $1
+                              i32.load
+                              local.set $0
+                              i32.const 25
+                              local.get $5
+                              i32.const 1
+                              i32.shr_u
+                              i32.sub
+                              local.set $1
+                              local.get $3
+                              local.get $5
+                              i32.const 31
+                              i32.eq
+                              if (result i32) ;; label = @14
+                                i32.const 0
+                              else
+                                local.get $1
+                              end
+                              i32.shl
+                              local.set $5
+                              block $label$151 ;; label = @14
+                                block $label$152 ;; label = @15
+                                  block $label$153 ;; label = @16
+                                    loop $label$154 ;; label = @17
+                                      local.get $0
+                                      i32.load offset=4
+                                      i32.const -8
+                                      i32.and
+                                      local.get $3
+                                      i32.eq
+                                      br_if 2 (;@15;)
+                                      local.get $5
+                                      i32.const 1
+                                      i32.shl
+                                      local.set $2
+                                      local.get $0
+                                      i32.const 16
+                                      i32.add
+                                      local.get $5
+                                      i32.const 31
+                                      i32.shr_u
+                                      i32.const 2
+                                      i32.shl
+                                      i32.add
+                                      local.tee $5
+                                      i32.load
+                                      local.tee $1
+                                      i32.eqz
+                                      br_if 1 (;@16;)
+                                      local.get $2
+                                      local.set $5
+                                      local.get $1
+                                      local.set $0
+                                      br 0 (;@17;)
+                                    end
+                                  end
+                                  local.get $5
+                                  i32.const 3668
+                                  i32.load
+                                  i32.lt_u
+                                  if ;; label = @16
+                                    call $fimport$10
+                                  else
+                                    block ;; label = @17
+                                      local.get $5
+                                      local.get $6
+                                      i32.store
+                                      local.get $6
+                                      local.get $0
+                                      i32.store offset=24
+                                      local.get $6
+                                      local.get $6
+                                      i32.store offset=12
+                                      local.get $6
+                                      local.get $6
+                                      i32.store offset=8
+                                      br 6 (;@11;)
+                                    end
+                                  end
+                                  br 1 (;@14;)
+                                end
+                                local.get $0
+                                i32.const 8
+                                i32.add
+                                local.tee $3
+                                i32.load
+                                local.tee $2
+                                i32.const 3668
+                                i32.load
+                                local.tee $1
+                                i32.ge_u
+                                local.get $0
+                                local.get $1
+                                i32.ge_u
+                                i32.and
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $2
+                                    local.get $6
+                                    i32.store offset=12
+                                    local.get $3
+                                    local.get $6
+                                    i32.store
+                                    local.get $6
+                                    local.get $2
+                                    i32.store offset=8
+                                    local.get $6
+                                    local.get $0
+                                    i32.store offset=12
+                                    local.get $6
+                                    i32.const 0
+                                    i32.store offset=24
+                                  end
+                                else
+                                  call $fimport$10
+                                end
+                              end
+                            end
+                          end
+                        end
+                        local.get $14
+                        global.set $global$1
+                        local.get $4
+                        i32.const 8
+                        i32.add
+                        return
+                      end
+                    else
+                      local.get $7
+                      local.set $0
+                    end
+                  else
+                    local.get $7
+                    local.set $0
+                  end
+                end
+              else
+                local.get $7
+                local.set $0
+              end
+            end
+          end
+        end
+      end
+      i32.const 3660
+      i32.load
+      local.tee $1
+      local.get $0
+      i32.ge_u
+      if ;; label = @2
+        block ;; label = @3
+          i32.const 3672
+          i32.load
+          local.set $2
+          local.get $1
+          local.get $0
+          i32.sub
+          local.tee $3
+          i32.const 15
+          i32.gt_u
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 3672
+              local.get $2
+              local.get $0
+              i32.add
+              local.tee $1
+              i32.store
+              i32.const 3660
+              local.get $3
+              i32.store
+              local.get $1
+              local.get $3
+              i32.const 1
+              i32.or
+              i32.store offset=4
+              local.get $1
+              local.get $3
+              i32.add
+              local.get $3
+              i32.store
+              local.get $2
+              local.get $0
+              i32.const 3
+              i32.or
+              i32.store offset=4
+            end
+          else
+            block ;; label = @5
+              i32.const 3660
+              i32.const 0
+              i32.store
+              i32.const 3672
+              i32.const 0
+              i32.store
+              local.get $2
+              local.get $1
+              i32.const 3
+              i32.or
+              i32.store offset=4
+              local.get $2
+              local.get $1
+              i32.add
+              i32.const 4
+              i32.add
+              local.tee $0
+              local.get $0
+              i32.load
+              i32.const 1
+              i32.or
+              i32.store
+            end
+          end
+          local.get $14
+          global.set $global$1
+          local.get $2
+          i32.const 8
+          i32.add
+          return
+        end
+      end
+      i32.const 3664
+      i32.load
+      local.tee $10
+      local.get $0
+      i32.gt_u
+      if ;; label = @2
+        block ;; label = @3
+          i32.const 3664
+          local.get $10
+          local.get $0
+          i32.sub
+          local.tee $3
+          i32.store
+          i32.const 3676
+          i32.const 3676
+          i32.load
+          local.tee $2
+          local.get $0
+          i32.add
+          local.tee $1
+          i32.store
+          local.get $1
+          local.get $3
+          i32.const 1
+          i32.or
+          i32.store offset=4
+          local.get $2
+          local.get $0
+          i32.const 3
+          i32.or
+          i32.store offset=4
+          local.get $14
+          global.set $global$1
+          local.get $2
+          i32.const 8
+          i32.add
+          return
+        end
+      end
+      i32.const 4124
+      i32.load
+      if (result i32) ;; label = @2
+        i32.const 4132
+        i32.load
+      else
+        block (result i32) ;; label = @3
+          i32.const 4132
+          i32.const 4096
+          i32.store
+          i32.const 4128
+          i32.const 4096
+          i32.store
+          i32.const 4136
+          i32.const -1
+          i32.store
+          i32.const 4140
+          i32.const -1
+          i32.store
+          i32.const 4144
+          i32.const 0
+          i32.store
+          i32.const 4096
+          i32.const 0
+          i32.store
+          local.get $18
+          local.get $18
+          i32.const -16
+          i32.and
+          i32.const 1431655768
+          i32.xor
+          local.tee $1
+          i32.store
+          i32.const 4124
+          local.get $1
+          i32.store
+          i32.const 4096
+        end
+      end
+      local.tee $1
+      local.get $0
+      i32.const 47
+      i32.add
+      local.tee $13
+      i32.add
+      local.tee $8
+      i32.const 0
+      local.get $1
+      i32.sub
+      local.tee $4
+      i32.and
+      local.tee $6
+      local.get $0
+      i32.le_u
+      if ;; label = @2
+        block ;; label = @3
+          local.get $14
+          global.set $global$1
+          i32.const 0
+          return
+        end
+      end
+      i32.const 4092
+      i32.load
+      local.tee $2
+      if ;; label = @2
+        i32.const 4084
+        i32.load
+        local.tee $3
+        local.get $6
+        i32.add
+        local.tee $1
+        local.get $3
+        i32.le_u
+        local.get $1
+        local.get $2
+        i32.gt_u
+        i32.or
+        if ;; label = @3
+          block ;; label = @4
+            local.get $14
+            global.set $global$1
+            i32.const 0
+            return
+          end
+        end
+      end
+      local.get $0
+      i32.const 48
+      i32.add
+      local.set $7
+      block $label$171 ;; label = @2
+        block $label$172 ;; label = @3
+          i32.const 4096
+          i32.load
+          i32.const 4
+          i32.and
+          i32.eqz
+          if ;; label = @4
+            block ;; label = @5
+              block $label$174 ;; label = @6
+                block $label$175 ;; label = @7
+                  block $label$176 ;; label = @8
+                    i32.const 3676
+                    i32.load
+                    local.tee $3
+                    i32.eqz
+                    br_if 0 (;@8;)
+                    i32.const 4100
+                    local.set $2
+                    loop $label$177 ;; label = @9
+                      block $label$178 ;; label = @10
+                        local.get $2
+                        i32.load
+                        local.tee $1
+                        local.get $3
+                        i32.le_u
+                        if ;; label = @11
+                          local.get $1
+                          local.get $2
+                          i32.const 4
+                          i32.add
+                          local.tee $5
+                          i32.load
+                          i32.add
+                          local.get $3
+                          i32.gt_u
+                          br_if 1 (;@10;)
+                        end
+                        local.get $2
+                        i32.load offset=8
+                        local.tee $1
+                        i32.eqz
+                        br_if 2 (;@8;)
+                        local.get $1
+                        local.set $2
+                        br 1 (;@9;)
+                      end
+                    end
+                    local.get $8
+                    local.get $10
+                    i32.sub
+                    local.get $4
+                    i32.and
+                    local.tee $3
+                    i32.const 2147483647
+                    i32.lt_u
+                    if ;; label = @9
+                      local.get $3
+                      call $38
+                      local.tee $1
+                      local.get $2
+                      i32.load
+                      local.get $5
+                      i32.load
+                      i32.add
+                      i32.eq
+                      if ;; label = @10
+                        local.get $1
+                        i32.const -1
+                        i32.ne
+                        br_if 7 (;@3;)
+                      else
+                        block ;; label = @11
+                          local.get $1
+                          local.set $2
+                          local.get $3
+                          local.set $1
+                          br 4 (;@7;)
+                        end
+                      end
+                    end
+                    br 2 (;@6;)
+                  end
+                  i32.const 0
+                  call $38
+                  local.tee $1
+                  i32.const -1
+                  i32.ne
+                  if ;; label = @8
+                    block ;; label = @9
+                      i32.const 4128
+                      i32.load
+                      local.tee $2
+                      i32.const -1
+                      i32.add
+                      local.tee $5
+                      local.get $1
+                      local.tee $3
+                      i32.add
+                      i32.const 0
+                      local.get $2
+                      i32.sub
+                      i32.and
+                      local.get $3
+                      i32.sub
+                      local.set $2
+                      local.get $5
+                      local.get $3
+                      i32.and
+                      if (result i32) ;; label = @10
+                        local.get $2
+                      else
+                        i32.const 0
+                      end
+                      local.get $6
+                      i32.add
+                      local.tee $3
+                      i32.const 4084
+                      i32.load
+                      local.tee $5
+                      i32.add
+                      local.set $4
+                      local.get $3
+                      local.get $0
+                      i32.gt_u
+                      local.get $3
+                      i32.const 2147483647
+                      i32.lt_u
+                      i32.and
+                      if ;; label = @10
+                        block ;; label = @11
+                          i32.const 4092
+                          i32.load
+                          local.tee $2
+                          if ;; label = @12
+                            local.get $4
+                            local.get $5
+                            i32.le_u
+                            local.get $4
+                            local.get $2
+                            i32.gt_u
+                            i32.or
+                            br_if 6 (;@6;)
+                          end
+                          local.get $3
+                          call $38
+                          local.tee $2
+                          local.get $1
+                          i32.eq
+                          br_if 8 (;@3;)
+                          local.get $3
+                          local.set $1
+                          br 4 (;@7;)
+                        end
+                      end
+                    end
+                  end
+                  br 1 (;@6;)
+                end
+                i32.const 0
+                local.get $1
+                i32.sub
+                local.set $5
+                local.get $7
+                local.get $1
+                i32.gt_u
+                local.get $1
+                i32.const 2147483647
+                i32.lt_u
+                local.get $2
+                i32.const -1
+                i32.ne
+                i32.and
+                i32.and
+                if ;; label = @7
+                  local.get $13
+                  local.get $1
+                  i32.sub
+                  i32.const 4132
+                  i32.load
+                  local.tee $3
+                  i32.add
+                  i32.const 0
+                  local.get $3
+                  i32.sub
+                  i32.and
+                  local.tee $3
+                  i32.const 2147483647
+                  i32.lt_u
+                  if ;; label = @8
+                    local.get $3
+                    call $38
+                    i32.const -1
+                    i32.eq
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $5
+                        call $38
+                        drop
+                        br 4 (;@6;)
+                      end
+                    else
+                      local.get $3
+                      local.get $1
+                      i32.add
+                      local.set $3
+                    end
+                  else
+                    local.get $1
+                    local.set $3
+                  end
+                else
+                  local.get $1
+                  local.set $3
+                end
+                local.get $2
+                i32.const -1
+                i32.ne
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $2
+                    local.set $1
+                    br 5 (;@3;)
+                  end
+                end
+              end
+              i32.const 4096
+              i32.const 4096
+              i32.load
+              i32.const 4
+              i32.or
+              i32.store
+            end
+          end
+          local.get $6
+          i32.const 2147483647
+          i32.lt_u
+          if ;; label = @4
+            local.get $6
+            call $38
+            local.tee $1
+            i32.const 0
+            call $38
+            local.tee $3
+            i32.lt_u
+            local.get $1
+            i32.const -1
+            i32.ne
+            local.get $3
+            i32.const -1
+            i32.ne
+            i32.and
+            i32.and
+            if ;; label = @5
+              local.get $3
+              local.get $1
+              i32.sub
+              local.tee $3
+              local.get $0
+              i32.const 40
+              i32.add
+              i32.gt_u
+              br_if 2 (;@3;)
+            end
+          end
+          br 1 (;@2;)
+        end
+        i32.const 4084
+        i32.const 4084
+        i32.load
+        local.get $3
+        i32.add
+        local.tee $2
+        i32.store
+        local.get $2
+        i32.const 4088
+        i32.load
+        i32.gt_u
+        if ;; label = @3
+          i32.const 4088
+          local.get $2
+          i32.store
+        end
+        block $label$198 ;; label = @3
+          i32.const 3676
+          i32.load
+          local.tee $8
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 4100
+              local.set $2
+              block $label$200 ;; label = @6
+                block $label$201 ;; label = @7
+                  loop $label$202 ;; label = @8
+                    local.get $1
+                    local.get $2
+                    i32.load
+                    local.tee $4
+                    local.get $2
+                    i32.const 4
+                    i32.add
+                    local.tee $7
+                    i32.load
+                    local.tee $5
+                    i32.add
+                    i32.eq
+                    br_if 1 (;@7;)
+                    local.get $2
+                    i32.load offset=8
+                    local.tee $2
+                    br_if 0 (;@8;)
+                  end
+                  br 1 (;@6;)
+                end
+                local.get $2
+                i32.load offset=12
+                i32.const 8
+                i32.and
+                i32.eqz
+                if ;; label = @7
+                  local.get $8
+                  local.get $1
+                  i32.lt_u
+                  local.get $8
+                  local.get $4
+                  i32.ge_u
+                  i32.and
+                  if ;; label = @8
+                    block ;; label = @9
+                      local.get $7
+                      local.get $5
+                      local.get $3
+                      i32.add
+                      i32.store
+                      i32.const 3664
+                      i32.load
+                      local.set $5
+                      i32.const 0
+                      local.get $8
+                      i32.const 8
+                      i32.add
+                      local.tee $2
+                      i32.sub
+                      i32.const 7
+                      i32.and
+                      local.set $1
+                      i32.const 3676
+                      local.get $8
+                      local.get $2
+                      i32.const 7
+                      i32.and
+                      if (result i32) ;; label = @10
+                        local.get $1
+                      else
+                        i32.const 0
+                        local.tee $1
+                      end
+                      i32.add
+                      local.tee $2
+                      i32.store
+                      i32.const 3664
+                      local.get $3
+                      local.get $1
+                      i32.sub
+                      local.get $5
+                      i32.add
+                      local.tee $1
+                      i32.store
+                      local.get $2
+                      local.get $1
+                      i32.const 1
+                      i32.or
+                      i32.store offset=4
+                      local.get $2
+                      local.get $1
+                      i32.add
+                      i32.const 40
+                      i32.store offset=4
+                      i32.const 3680
+                      i32.const 4140
+                      i32.load
+                      i32.store
+                      br 6 (;@3;)
+                    end
+                  end
+                end
+              end
+              local.get $1
+              i32.const 3668
+              i32.load
+              local.tee $2
+              i32.lt_u
+              if ;; label = @6
+                block ;; label = @7
+                  i32.const 3668
+                  local.get $1
+                  i32.store
+                  local.get $1
+                  local.set $2
+                end
+              end
+              local.get $1
+              local.get $3
+              i32.add
+              local.set $10
+              i32.const 4100
+              local.set $5
+              block $label$208 ;; label = @6
+                block $label$209 ;; label = @7
+                  loop $label$210 ;; label = @8
+                    local.get $5
+                    i32.load
+                    local.get $10
+                    i32.eq
+                    br_if 1 (;@7;)
+                    local.get $5
+                    i32.load offset=8
+                    local.tee $5
+                    br_if 0 (;@8;)
+                    i32.const 4100
+                    local.set $5
+                  end
+                  br 1 (;@6;)
+                end
+                local.get $5
+                i32.load offset=12
+                i32.const 8
+                i32.and
+                if ;; label = @7
+                  i32.const 4100
+                  local.set $5
+                else
+                  block ;; label = @8
+                    local.get $5
+                    local.get $1
+                    i32.store
+                    local.get $5
+                    i32.const 4
+                    i32.add
+                    local.tee $5
+                    local.get $5
+                    i32.load
+                    local.get $3
+                    i32.add
+                    i32.store
+                    i32.const 0
+                    local.get $1
+                    i32.const 8
+                    i32.add
+                    local.tee $4
+                    i32.sub
+                    i32.const 7
+                    i32.and
+                    local.set $7
+                    i32.const 0
+                    local.get $10
+                    i32.const 8
+                    i32.add
+                    local.tee $5
+                    i32.sub
+                    i32.const 7
+                    i32.and
+                    local.set $3
+                    local.get $1
+                    local.get $4
+                    i32.const 7
+                    i32.and
+                    if (result i32) ;; label = @9
+                      local.get $7
+                    else
+                      i32.const 0
+                    end
+                    i32.add
+                    local.tee $13
+                    local.get $0
+                    i32.add
+                    local.set $6
+                    local.get $10
+                    local.get $5
+                    i32.const 7
+                    i32.and
+                    if (result i32) ;; label = @9
+                      local.get $3
+                    else
+                      i32.const 0
+                    end
+                    i32.add
+                    local.tee $4
+                    local.get $13
+                    i32.sub
+                    local.get $0
+                    i32.sub
+                    local.set $7
+                    local.get $13
+                    local.get $0
+                    i32.const 3
+                    i32.or
+                    i32.store offset=4
+                    block $label$217 ;; label = @9
+                      local.get $4
+                      local.get $8
+                      i32.eq
+                      if ;; label = @10
+                        block ;; label = @11
+                          i32.const 3664
+                          i32.const 3664
+                          i32.load
+                          local.get $7
+                          i32.add
+                          local.tee $0
+                          i32.store
+                          i32.const 3676
+                          local.get $6
+                          i32.store
+                          local.get $6
+                          local.get $0
+                          i32.const 1
+                          i32.or
+                          i32.store offset=4
+                        end
+                      else
+                        block ;; label = @11
+                          local.get $4
+                          i32.const 3672
+                          i32.load
+                          i32.eq
+                          if ;; label = @12
+                            block ;; label = @13
+                              i32.const 3660
+                              i32.const 3660
+                              i32.load
+                              local.get $7
+                              i32.add
+                              local.tee $0
+                              i32.store
+                              i32.const 3672
+                              local.get $6
+                              i32.store
+                              local.get $6
+                              local.get $0
+                              i32.const 1
+                              i32.or
+                              i32.store offset=4
+                              local.get $6
+                              local.get $0
+                              i32.add
+                              local.get $0
+                              i32.store
+                              br 4 (;@9;)
+                            end
+                          end
+                          local.get $4
+                          i32.load offset=4
+                          local.tee $0
+                          i32.const 3
+                          i32.and
+                          i32.const 1
+                          i32.eq
+                          if (result i32) ;; label = @12
+                            block (result i32) ;; label = @13
+                              local.get $0
+                              i32.const -8
+                              i32.and
+                              local.set $11
+                              local.get $0
+                              i32.const 3
+                              i32.shr_u
+                              local.set $1
+                              block $label$222 ;; label = @14
+                                local.get $0
+                                i32.const 256
+                                i32.lt_u
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $4
+                                    i32.load offset=12
+                                    local.set $5
+                                    block $label$224 ;; label = @17
+                                      local.get $4
+                                      i32.load offset=8
+                                      local.tee $3
+                                      local.get $1
+                                      i32.const 1
+                                      i32.shl
+                                      i32.const 2
+                                      i32.shl
+                                      i32.const 3692
+                                      i32.add
+                                      local.tee $0
+                                      i32.ne
+                                      if ;; label = @18
+                                        block ;; label = @19
+                                          local.get $3
+                                          local.get $2
+                                          i32.lt_u
+                                          if ;; label = @20
+                                            call $fimport$10
+                                          end
+                                          local.get $3
+                                          i32.load offset=12
+                                          local.get $4
+                                          i32.eq
+                                          br_if 2 (;@17;)
+                                          call $fimport$10
+                                        end
+                                      end
+                                    end
+                                    local.get $5
+                                    local.get $3
+                                    i32.eq
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        i32.const 3652
+                                        i32.const 3652
+                                        i32.load
+                                        i32.const 1
+                                        local.get $1
+                                        i32.shl
+                                        i32.const -1
+                                        i32.xor
+                                        i32.and
+                                        i32.store
+                                        br 4 (;@14;)
+                                      end
+                                    end
+                                    block $label$228 ;; label = @17
+                                      local.get $5
+                                      local.get $0
+                                      i32.eq
+                                      if ;; label = @18
+                                        local.get $5
+                                        i32.const 8
+                                        i32.add
+                                        local.set $20
+                                      else
+                                        block ;; label = @19
+                                          local.get $5
+                                          local.get $2
+                                          i32.lt_u
+                                          if ;; label = @20
+                                            call $fimport$10
+                                          end
+                                          local.get $5
+                                          i32.const 8
+                                          i32.add
+                                          local.tee $0
+                                          i32.load
+                                          local.get $4
+                                          i32.eq
+                                          if ;; label = @20
+                                            block ;; label = @21
+                                              local.get $0
+                                              local.set $20
+                                              br 4 (;@17;)
+                                            end
+                                          end
+                                          call $fimport$10
+                                        end
+                                      end
+                                    end
+                                    local.get $3
+                                    local.get $5
+                                    i32.store offset=12
+                                    local.get $20
+                                    local.get $3
+                                    i32.store
+                                  end
+                                else
+                                  block ;; label = @16
+                                    local.get $4
+                                    i32.load offset=24
+                                    local.set $8
+                                    block $label$234 ;; label = @17
+                                      local.get $4
+                                      i32.load offset=12
+                                      local.tee $0
+                                      local.get $4
+                                      i32.eq
+                                      if ;; label = @18
+                                        block ;; label = @19
+                                          local.get $4
+                                          i32.const 16
+                                          i32.add
+                                          local.tee $3
+                                          i32.const 4
+                                          i32.add
+                                          local.tee $1
+                                          i32.load
+                                          local.tee $0
+                                          i32.eqz
+                                          if ;; label = @20
+                                            local.get $3
+                                            i32.load
+                                            local.tee $0
+                                            if ;; label = @21
+                                              local.get $3
+                                              local.set $1
+                                            else
+                                              block ;; label = @22
+                                                i32.const 0
+                                                local.set $12
+                                                br 5 (;@17;)
+                                              end
+                                            end
+                                          end
+                                          loop $label$239 ;; label = @20
+                                            local.get $0
+                                            i32.const 20
+                                            i32.add
+                                            local.tee $5
+                                            i32.load
+                                            local.tee $3
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                local.get $3
+                                                local.set $0
+                                                local.get $5
+                                                local.set $1
+                                                br 2 (;@20;)
+                                              end
+                                            end
+                                            local.get $0
+                                            i32.const 16
+                                            i32.add
+                                            local.tee $5
+                                            i32.load
+                                            local.tee $3
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                local.get $3
+                                                local.set $0
+                                                local.get $5
+                                                local.set $1
+                                                br 2 (;@20;)
+                                              end
+                                            end
+                                          end
+                                          local.get $1
+                                          local.get $2
+                                          i32.lt_u
+                                          if ;; label = @20
+                                            call $fimport$10
+                                          else
+                                            block ;; label = @21
+                                              local.get $1
+                                              i32.const 0
+                                              i32.store
+                                              local.get $0
+                                              local.set $12
+                                            end
+                                          end
+                                        end
+                                      else
+                                        block ;; label = @19
+                                          local.get $4
+                                          i32.load offset=8
+                                          local.tee $5
+                                          local.get $2
+                                          i32.lt_u
+                                          if ;; label = @20
+                                            call $fimport$10
+                                          end
+                                          local.get $5
+                                          i32.const 12
+                                          i32.add
+                                          local.tee $3
+                                          i32.load
+                                          local.get $4
+                                          i32.ne
+                                          if ;; label = @20
+                                            call $fimport$10
+                                          end
+                                          local.get $0
+                                          i32.const 8
+                                          i32.add
+                                          local.tee $1
+                                          i32.load
+                                          local.get $4
+                                          i32.eq
+                                          if ;; label = @20
+                                            block ;; label = @21
+                                              local.get $3
+                                              local.get $0
+                                              i32.store
+                                              local.get $1
+                                              local.get $5
+                                              i32.store
+                                              local.get $0
+                                              local.set $12
+                                            end
+                                          else
+                                            call $fimport$10
+                                          end
+                                        end
+                                      end
+                                    end
+                                    local.get $8
+                                    i32.eqz
+                                    br_if 2 (;@14;)
+                                    block $label$249 ;; label = @17
+                                      local.get $4
+                                      local.get $4
+                                      i32.load offset=28
+                                      local.tee $1
+                                      i32.const 2
+                                      i32.shl
+                                      i32.const 3956
+                                      i32.add
+                                      local.tee $0
+                                      i32.load
+                                      i32.eq
+                                      if ;; label = @18
+                                        block ;; label = @19
+                                          local.get $0
+                                          local.get $12
+                                          i32.store
+                                          local.get $12
+                                          br_if 2 (;@17;)
+                                          i32.const 3656
+                                          i32.const 3656
+                                          i32.load
+                                          i32.const 1
+                                          local.get $1
+                                          i32.shl
+                                          i32.const -1
+                                          i32.xor
+                                          i32.and
+                                          i32.store
+                                          br 5 (;@14;)
+                                        end
+                                      else
+                                        block ;; label = @19
+                                          local.get $8
+                                          i32.const 3668
+                                          i32.load
+                                          i32.lt_u
+                                          if ;; label = @20
+                                            call $fimport$10
+                                          end
+                                          local.get $8
+                                          i32.const 16
+                                          i32.add
+                                          local.tee $0
+                                          i32.load
+                                          local.get $4
+                                          i32.eq
+                                          if ;; label = @20
+                                            local.get $0
+                                            local.get $12
+                                            i32.store
+                                          else
+                                            local.get $8
+                                            local.get $12
+                                            i32.store offset=20
+                                          end
+                                          local.get $12
+                                          i32.eqz
+                                          br_if 5 (;@14;)
+                                        end
+                                      end
+                                    end
+                                    local.get $12
+                                    i32.const 3668
+                                    i32.load
+                                    local.tee $1
+                                    i32.lt_u
+                                    if ;; label = @17
+                                      call $fimport$10
+                                    end
+                                    local.get $12
+                                    local.get $8
+                                    i32.store offset=24
+                                    local.get $4
+                                    i32.const 16
+                                    i32.add
+                                    local.tee $0
+                                    i32.load
+                                    local.tee $3
+                                    if ;; label = @17
+                                      local.get $3
+                                      local.get $1
+                                      i32.lt_u
+                                      if ;; label = @18
+                                        call $fimport$10
+                                      else
+                                        block ;; label = @19
+                                          local.get $12
+                                          local.get $3
+                                          i32.store offset=16
+                                          local.get $3
+                                          local.get $12
+                                          i32.store offset=24
+                                        end
+                                      end
+                                    end
+                                    local.get $0
+                                    i32.load offset=4
+                                    local.tee $0
+                                    i32.eqz
+                                    br_if 2 (;@14;)
+                                    local.get $0
+                                    i32.const 3668
+                                    i32.load
+                                    i32.lt_u
+                                    if ;; label = @17
+                                      call $fimport$10
+                                    else
+                                      block ;; label = @18
+                                        local.get $12
+                                        local.get $0
+                                        i32.store offset=20
+                                        local.get $0
+                                        local.get $12
+                                        i32.store offset=24
+                                      end
+                                    end
+                                  end
+                                end
+                              end
+                              local.get $11
+                              local.get $7
+                              i32.add
+                              local.set $7
+                              local.get $4
+                              local.get $11
+                              i32.add
+                            end
+                          else
+                            local.get $4
+                          end
+                          local.tee $0
+                          i32.const 4
+                          i32.add
+                          local.tee $0
+                          local.get $0
+                          i32.load
+                          i32.const -2
+                          i32.and
+                          i32.store
+                          local.get $6
+                          local.get $7
+                          i32.const 1
+                          i32.or
+                          i32.store offset=4
+                          local.get $6
+                          local.get $7
+                          i32.add
+                          local.get $7
+                          i32.store
+                          local.get $7
+                          i32.const 3
+                          i32.shr_u
+                          local.set $0
+                          local.get $7
+                          i32.const 256
+                          i32.lt_u
+                          if ;; label = @12
+                            block ;; label = @13
+                              local.get $0
+                              i32.const 1
+                              i32.shl
+                              i32.const 2
+                              i32.shl
+                              i32.const 3692
+                              i32.add
+                              local.set $3
+                              block $label$263 ;; label = @14
+                                i32.const 3652
+                                i32.load
+                                local.tee $1
+                                i32.const 1
+                                local.get $0
+                                i32.shl
+                                local.tee $0
+                                i32.and
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $3
+                                    i32.const 8
+                                    i32.add
+                                    local.tee $1
+                                    i32.load
+                                    local.tee $0
+                                    i32.const 3668
+                                    i32.load
+                                    i32.ge_u
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        local.get $1
+                                        local.set $21
+                                        local.get $0
+                                        local.set $9
+                                        br 4 (;@14;)
+                                      end
+                                    end
+                                    call $fimport$10
+                                  end
+                                else
+                                  block ;; label = @16
+                                    i32.const 3652
+                                    local.get $1
+                                    local.get $0
+                                    i32.or
+                                    i32.store
+                                    local.get $3
+                                    i32.const 8
+                                    i32.add
+                                    local.set $21
+                                    local.get $3
+                                    local.set $9
+                                  end
+                                end
+                              end
+                              local.get $21
+                              local.get $6
+                              i32.store
+                              local.get $9
+                              local.get $6
+                              i32.store offset=12
+                              local.get $6
+                              local.get $9
+                              i32.store offset=8
+                              local.get $6
+                              local.get $3
+                              i32.store offset=12
+                              br 4 (;@9;)
+                            end
+                          end
+                          block $label$267 (result i32) ;; label = @12
+                            local.get $7
+                            i32.const 8
+                            i32.shr_u
+                            local.tee $0
+                            if (result i32) ;; label = @13
+                              block (result i32) ;; label = @14
+                                i32.const 31
+                                local.get $7
+                                i32.const 16777215
+                                i32.gt_u
+                                br_if 2 (;@12;)
+                                drop
+                                local.get $7
+                                i32.const 14
+                                local.get $0
+                                local.get $0
+                                i32.const 1048320
+                                i32.add
+                                i32.const 16
+                                i32.shr_u
+                                i32.const 8
+                                i32.and
+                                local.tee $3
+                                i32.shl
+                                local.tee $1
+                                i32.const 520192
+                                i32.add
+                                i32.const 16
+                                i32.shr_u
+                                i32.const 4
+                                i32.and
+                                local.tee $0
+                                local.get $3
+                                i32.or
+                                local.get $1
+                                local.get $0
+                                i32.shl
+                                local.tee $1
+                                i32.const 245760
+                                i32.add
+                                i32.const 16
+                                i32.shr_u
+                                i32.const 2
+                                i32.and
+                                local.tee $0
+                                i32.or
+                                i32.sub
+                                local.get $1
+                                local.get $0
+                                i32.shl
+                                i32.const 15
+                                i32.shr_u
+                                i32.add
+                                local.tee $0
+                                i32.const 7
+                                i32.add
+                                i32.shr_u
+                                i32.const 1
+                                i32.and
+                                local.get $0
+                                i32.const 1
+                                i32.shl
+                                i32.or
+                              end
+                            else
+                              i32.const 0
+                            end
+                          end
+                          local.tee $2
+                          i32.const 2
+                          i32.shl
+                          i32.const 3956
+                          i32.add
+                          local.set $3
+                          local.get $6
+                          local.get $2
+                          i32.store offset=28
+                          local.get $6
+                          i32.const 16
+                          i32.add
+                          local.tee $0
+                          i32.const 0
+                          i32.store offset=4
+                          local.get $0
+                          i32.const 0
+                          i32.store
+                          i32.const 3656
+                          i32.load
+                          local.tee $1
+                          i32.const 1
+                          local.get $2
+                          i32.shl
+                          local.tee $0
+                          i32.and
+                          i32.eqz
+                          if ;; label = @12
+                            block ;; label = @13
+                              i32.const 3656
+                              local.get $1
+                              local.get $0
+                              i32.or
+                              i32.store
+                              local.get $3
+                              local.get $6
+                              i32.store
+                              local.get $6
+                              local.get $3
+                              i32.store offset=24
+                              local.get $6
+                              local.get $6
+                              i32.store offset=12
+                              local.get $6
+                              local.get $6
+                              i32.store offset=8
+                              br 4 (;@9;)
+                            end
+                          end
+                          local.get $3
+                          i32.load
+                          local.set $0
+                          i32.const 25
+                          local.get $2
+                          i32.const 1
+                          i32.shr_u
+                          i32.sub
+                          local.set $1
+                          local.get $7
+                          local.get $2
+                          i32.const 31
+                          i32.eq
+                          if (result i32) ;; label = @12
+                            i32.const 0
+                          else
+                            local.get $1
+                          end
+                          i32.shl
+                          local.set $2
+                          block $label$273 ;; label = @12
+                            block $label$274 ;; label = @13
+                              block $label$275 ;; label = @14
+                                loop $label$276 ;; label = @15
+                                  local.get $0
+                                  i32.load offset=4
+                                  i32.const -8
+                                  i32.and
+                                  local.get $7
+                                  i32.eq
+                                  br_if 2 (;@13;)
+                                  local.get $2
+                                  i32.const 1
+                                  i32.shl
+                                  local.set $3
+                                  local.get $0
+                                  i32.const 16
+                                  i32.add
+                                  local.get $2
+                                  i32.const 31
+                                  i32.shr_u
+                                  i32.const 2
+                                  i32.shl
+                                  i32.add
+                                  local.tee $2
+                                  i32.load
+                                  local.tee $1
+                                  i32.eqz
+                                  br_if 1 (;@14;)
+                                  local.get $3
+                                  local.set $2
+                                  local.get $1
+                                  local.set $0
+                                  br 0 (;@15;)
+                                end
+                              end
+                              local.get $2
+                              i32.const 3668
+                              i32.load
+                              i32.lt_u
+                              if ;; label = @14
+                                call $fimport$10
+                              else
+                                block ;; label = @15
+                                  local.get $2
+                                  local.get $6
+                                  i32.store
+                                  local.get $6
+                                  local.get $0
+                                  i32.store offset=24
+                                  local.get $6
+                                  local.get $6
+                                  i32.store offset=12
+                                  local.get $6
+                                  local.get $6
+                                  i32.store offset=8
+                                  br 6 (;@9;)
+                                end
+                              end
+                              br 1 (;@12;)
+                            end
+                            local.get $0
+                            i32.const 8
+                            i32.add
+                            local.tee $3
+                            i32.load
+                            local.tee $2
+                            i32.const 3668
+                            i32.load
+                            local.tee $1
+                            i32.ge_u
+                            local.get $0
+                            local.get $1
+                            i32.ge_u
+                            i32.and
+                            if ;; label = @13
+                              block ;; label = @14
+                                local.get $2
+                                local.get $6
+                                i32.store offset=12
+                                local.get $3
+                                local.get $6
+                                i32.store
+                                local.get $6
+                                local.get $2
+                                i32.store offset=8
+                                local.get $6
+                                local.get $0
+                                i32.store offset=12
+                                local.get $6
+                                i32.const 0
+                                i32.store offset=24
+                              end
+                            else
+                              call $fimport$10
+                            end
+                          end
+                        end
+                      end
+                    end
+                    local.get $14
+                    global.set $global$1
+                    local.get $13
+                    i32.const 8
+                    i32.add
+                    return
+                  end
+                end
+              end
+              loop $label$281 ;; label = @6
+                block $label$282 ;; label = @7
+                  local.get $5
+                  i32.load
+                  local.tee $2
+                  local.get $8
+                  i32.le_u
+                  if ;; label = @8
+                    local.get $2
+                    local.get $5
+                    i32.load offset=4
+                    i32.add
+                    local.tee $13
+                    local.get $8
+                    i32.gt_u
+                    br_if 1 (;@7;)
+                  end
+                  local.get $5
+                  i32.load offset=8
+                  local.set $5
+                  br 1 (;@6;)
+                end
+              end
+              i32.const 0
+              local.get $13
+              i32.const -47
+              i32.add
+              local.tee $7
+              i32.const 8
+              i32.add
+              local.tee $5
+              i32.sub
+              i32.const 7
+              i32.and
+              local.set $2
+              local.get $7
+              local.get $5
+              i32.const 7
+              i32.and
+              if (result i32) ;; label = @6
+                local.get $2
+              else
+                i32.const 0
+              end
+              i32.add
+              local.tee $2
+              local.get $8
+              i32.const 16
+              i32.add
+              local.tee $12
+              i32.lt_u
+              if (result i32) ;; label = @6
+                local.get $8
+              else
+                local.get $2
+              end
+              local.tee $7
+              i32.const 8
+              i32.add
+              local.set $10
+              local.get $7
+              i32.const 24
+              i32.add
+              local.set $5
+              local.get $3
+              i32.const -40
+              i32.add
+              local.set $9
+              i32.const 0
+              local.get $1
+              i32.const 8
+              i32.add
+              local.tee $4
+              i32.sub
+              i32.const 7
+              i32.and
+              local.set $2
+              i32.const 3676
+              local.get $1
+              local.get $4
+              i32.const 7
+              i32.and
+              if (result i32) ;; label = @6
+                local.get $2
+              else
+                i32.const 0
+                local.tee $2
+              end
+              i32.add
+              local.tee $4
+              i32.store
+              i32.const 3664
+              local.get $9
+              local.get $2
+              i32.sub
+              local.tee $2
+              i32.store
+              local.get $4
+              local.get $2
+              i32.const 1
+              i32.or
+              i32.store offset=4
+              local.get $4
+              local.get $2
+              i32.add
+              i32.const 40
+              i32.store offset=4
+              i32.const 3680
+              i32.const 4140
+              i32.load
+              i32.store
+              local.get $7
+              i32.const 4
+              i32.add
+              local.tee $2
+              i32.const 27
+              i32.store
+              local.get $10
+              i32.const 4100
+              i64.load align=4
+              i64.store align=4
+              local.get $10
+              i32.const 4108
+              i64.load align=4
+              i64.store offset=8 align=4
+              i32.const 4100
+              local.get $1
+              i32.store
+              i32.const 4104
+              local.get $3
+              i32.store
+              i32.const 4112
+              i32.const 0
+              i32.store
+              i32.const 4108
+              local.get $10
+              i32.store
+              local.get $5
+              local.set $1
+              loop $label$290 ;; label = @6
+                local.get $1
+                i32.const 4
+                i32.add
+                local.tee $1
+                i32.const 7
+                i32.store
+                local.get $1
+                i32.const 4
+                i32.add
+                local.get $13
+                i32.lt_u
+                br_if 0 (;@6;)
+              end
+              local.get $7
+              local.get $8
+              i32.ne
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $2
+                  local.get $2
+                  i32.load
+                  i32.const -2
+                  i32.and
+                  i32.store
+                  local.get $8
+                  local.get $7
+                  local.get $8
+                  i32.sub
+                  local.tee $4
+                  i32.const 1
+                  i32.or
+                  i32.store offset=4
+                  local.get $7
+                  local.get $4
+                  i32.store
+                  local.get $4
+                  i32.const 3
+                  i32.shr_u
+                  local.set $1
+                  local.get $4
+                  i32.const 256
+                  i32.lt_u
+                  if ;; label = @8
+                    block ;; label = @9
+                      local.get $1
+                      i32.const 1
+                      i32.shl
+                      i32.const 2
+                      i32.shl
+                      i32.const 3692
+                      i32.add
+                      local.set $2
+                      i32.const 3652
+                      i32.load
+                      local.tee $3
+                      i32.const 1
+                      local.get $1
+                      i32.shl
+                      local.tee $1
+                      i32.and
+                      if ;; label = @10
+                        local.get $2
+                        i32.const 8
+                        i32.add
+                        local.tee $3
+                        i32.load
+                        local.tee $1
+                        i32.const 3668
+                        i32.load
+                        i32.lt_u
+                        if ;; label = @11
+                          call $fimport$10
+                        else
+                          block ;; label = @12
+                            local.get $3
+                            local.set $15
+                            local.get $1
+                            local.set $11
+                          end
+                        end
+                      else
+                        block ;; label = @11
+                          i32.const 3652
+                          local.get $3
+                          local.get $1
+                          i32.or
+                          i32.store
+                          local.get $2
+                          i32.const 8
+                          i32.add
+                          local.set $15
+                          local.get $2
+                          local.set $11
+                        end
+                      end
+                      local.get $15
+                      local.get $8
+                      i32.store
+                      local.get $11
+                      local.get $8
+                      i32.store offset=12
+                      local.get $8
+                      local.get $11
+                      i32.store offset=8
+                      local.get $8
+                      local.get $2
+                      i32.store offset=12
+                      br 6 (;@3;)
+                    end
+                  end
+                  local.get $4
+                  i32.const 8
+                  i32.shr_u
+                  local.tee $1
+                  if (result i32) ;; label = @8
+                    local.get $4
+                    i32.const 16777215
+                    i32.gt_u
+                    if (result i32) ;; label = @9
+                      i32.const 31
+                    else
+                      local.get $4
+                      i32.const 14
+                      local.get $1
+                      local.get $1
+                      i32.const 1048320
+                      i32.add
+                      i32.const 16
+                      i32.shr_u
+                      i32.const 8
+                      i32.and
+                      local.tee $2
+                      i32.shl
+                      local.tee $3
+                      i32.const 520192
+                      i32.add
+                      i32.const 16
+                      i32.shr_u
+                      i32.const 4
+                      i32.and
+                      local.tee $1
+                      local.get $2
+                      i32.or
+                      local.get $3
+                      local.get $1
+                      i32.shl
+                      local.tee $3
+                      i32.const 245760
+                      i32.add
+                      i32.const 16
+                      i32.shr_u
+                      i32.const 2
+                      i32.and
+                      local.tee $1
+                      i32.or
+                      i32.sub
+                      local.get $3
+                      local.get $1
+                      i32.shl
+                      i32.const 15
+                      i32.shr_u
+                      i32.add
+                      local.tee $1
+                      i32.const 7
+                      i32.add
+                      i32.shr_u
+                      i32.const 1
+                      i32.and
+                      local.get $1
+                      i32.const 1
+                      i32.shl
+                      i32.or
+                    end
+                  else
+                    i32.const 0
+                  end
+                  local.tee $5
+                  i32.const 2
+                  i32.shl
+                  i32.const 3956
+                  i32.add
+                  local.set $2
+                  local.get $8
+                  local.get $5
+                  i32.store offset=28
+                  local.get $8
+                  i32.const 0
+                  i32.store offset=20
+                  local.get $12
+                  i32.const 0
+                  i32.store
+                  i32.const 3656
+                  i32.load
+                  local.tee $3
+                  i32.const 1
+                  local.get $5
+                  i32.shl
+                  local.tee $1
+                  i32.and
+                  i32.eqz
+                  if ;; label = @8
+                    block ;; label = @9
+                      i32.const 3656
+                      local.get $3
+                      local.get $1
+                      i32.or
+                      i32.store
+                      local.get $2
+                      local.get $8
+                      i32.store
+                      local.get $8
+                      local.get $2
+                      i32.store offset=24
+                      local.get $8
+                      local.get $8
+                      i32.store offset=12
+                      local.get $8
+                      local.get $8
+                      i32.store offset=8
+                      br 6 (;@3;)
+                    end
+                  end
+                  local.get $2
+                  i32.load
+                  local.set $1
+                  i32.const 25
+                  local.get $5
+                  i32.const 1
+                  i32.shr_u
+                  i32.sub
+                  local.set $3
+                  local.get $4
+                  local.get $5
+                  i32.const 31
+                  i32.eq
+                  if (result i32) ;; label = @8
+                    i32.const 0
+                  else
+                    local.get $3
+                  end
+                  i32.shl
+                  local.set $5
+                  block $label$304 ;; label = @8
+                    block $label$305 ;; label = @9
+                      block $label$306 ;; label = @10
+                        loop $label$307 ;; label = @11
+                          local.get $1
+                          i32.load offset=4
+                          i32.const -8
+                          i32.and
+                          local.get $4
+                          i32.eq
+                          br_if 2 (;@9;)
+                          local.get $5
+                          i32.const 1
+                          i32.shl
+                          local.set $2
+                          local.get $1
+                          i32.const 16
+                          i32.add
+                          local.get $5
+                          i32.const 31
+                          i32.shr_u
+                          i32.const 2
+                          i32.shl
+                          i32.add
+                          local.tee $5
+                          i32.load
+                          local.tee $3
+                          i32.eqz
+                          br_if 1 (;@10;)
+                          local.get $2
+                          local.set $5
+                          local.get $3
+                          local.set $1
+                          br 0 (;@11;)
+                        end
+                      end
+                      local.get $5
+                      i32.const 3668
+                      i32.load
+                      i32.lt_u
+                      if ;; label = @10
+                        call $fimport$10
+                      else
+                        block ;; label = @11
+                          local.get $5
+                          local.get $8
+                          i32.store
+                          local.get $8
+                          local.get $1
+                          i32.store offset=24
+                          local.get $8
+                          local.get $8
+                          i32.store offset=12
+                          local.get $8
+                          local.get $8
+                          i32.store offset=8
+                          br 8 (;@3;)
+                        end
+                      end
+                      br 1 (;@8;)
+                    end
+                    local.get $1
+                    i32.const 8
+                    i32.add
+                    local.tee $2
+                    i32.load
+                    local.tee $5
+                    i32.const 3668
+                    i32.load
+                    local.tee $3
+                    i32.ge_u
+                    local.get $1
+                    local.get $3
+                    i32.ge_u
+                    i32.and
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $5
+                        local.get $8
+                        i32.store offset=12
+                        local.get $2
+                        local.get $8
+                        i32.store
+                        local.get $8
+                        local.get $5
+                        i32.store offset=8
+                        local.get $8
+                        local.get $1
+                        i32.store offset=12
+                        local.get $8
+                        i32.const 0
+                        i32.store offset=24
+                      end
+                    else
+                      call $fimport$10
+                    end
+                  end
+                end
+              end
+            end
+          else
+            block ;; label = @5
+              i32.const 3668
+              i32.load
+              local.tee $2
+              i32.eqz
+              local.get $1
+              local.get $2
+              i32.lt_u
+              i32.or
+              if ;; label = @6
+                i32.const 3668
+                local.get $1
+                i32.store
+              end
+              i32.const 4100
+              local.get $1
+              i32.store
+              i32.const 4104
+              local.get $3
+              i32.store
+              i32.const 4112
+              i32.const 0
+              i32.store
+              i32.const 3688
+              i32.const 4124
+              i32.load
+              i32.store
+              i32.const 3684
+              i32.const -1
+              i32.store
+              i32.const 0
+              local.set $2
+              loop $label$314 ;; label = @6
+                local.get $2
+                i32.const 1
+                i32.shl
+                i32.const 2
+                i32.shl
+                i32.const 3692
+                i32.add
+                local.tee $5
+                local.get $5
+                i32.store offset=12
+                local.get $5
+                local.get $5
+                i32.store offset=8
+                local.get $2
+                i32.const 1
+                i32.add
+                local.tee $2
+                i32.const 32
+                i32.ne
+                br_if 0 (;@6;)
+              end
+              local.get $3
+              i32.const -40
+              i32.add
+              local.set $5
+              i32.const 0
+              local.get $1
+              i32.const 8
+              i32.add
+              local.tee $2
+              i32.sub
+              i32.const 7
+              i32.and
+              local.set $3
+              i32.const 3676
+              local.get $1
+              local.get $2
+              i32.const 7
+              i32.and
+              if (result i32) ;; label = @6
+                local.get $3
+              else
+                i32.const 0
+              end
+              local.tee $1
+              i32.add
+              local.tee $3
+              i32.store
+              i32.const 3664
+              local.get $5
+              local.get $1
+              i32.sub
+              local.tee $1
+              i32.store
+              local.get $3
+              local.get $1
+              i32.const 1
+              i32.or
+              i32.store offset=4
+              local.get $3
+              local.get $1
+              i32.add
+              i32.const 40
+              i32.store offset=4
+              i32.const 3680
+              i32.const 4140
+              i32.load
+              i32.store
+            end
+          end
+        end
+        i32.const 3664
+        i32.load
+        local.tee $1
+        local.get $0
+        i32.gt_u
+        if ;; label = @3
+          block ;; label = @4
+            i32.const 3664
+            local.get $1
+            local.get $0
+            i32.sub
+            local.tee $3
+            i32.store
+            i32.const 3676
+            i32.const 3676
+            i32.load
+            local.tee $2
+            local.get $0
+            i32.add
+            local.tee $1
+            i32.store
+            local.get $1
+            local.get $3
+            i32.const 1
+            i32.or
+            i32.store offset=4
+            local.get $2
+            local.get $0
+            i32.const 3
+            i32.or
+            i32.store offset=4
+            local.get $14
+            global.set $global$1
+            local.get $2
+            i32.const 8
+            i32.add
+            return
+          end
+        end
+      end
+      call $12
+      i32.const 12
+      i32.store
+      local.get $14
+      global.set $global$1
+      i32.const 0
+    end
+  )
+  (func $36 (;49;) (type $2) (param $0 i32)
+    (local $1 i32) (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32) (local $15 i32)
+    block $label$1 ;; label = @1
+      local.get $0
+      i32.eqz
+      if ;; label = @2
+        return
+      end
+      local.get $0
+      i32.const -8
+      i32.add
+      local.tee $1
+      i32.const 3668
+      i32.load
+      local.tee $11
+      i32.lt_u
+      if ;; label = @2
+        call $fimport$10
+      end
+      local.get $0
+      i32.const -4
+      i32.add
+      i32.load
+      local.tee $0
+      i32.const 3
+      i32.and
+      local.tee $8
+      i32.const 1
+      i32.eq
+      if ;; label = @2
+        call $fimport$10
+      end
+      local.get $1
+      local.get $0
+      i32.const -8
+      i32.and
+      local.tee $4
+      i32.add
+      local.set $6
+      block $label$5 ;; label = @2
+        local.get $0
+        i32.const 1
+        i32.and
+        if ;; label = @3
+          block ;; label = @4
+            local.get $1
+            local.set $3
+            local.get $4
+            local.set $2
+          end
+        else
+          block ;; label = @4
+            local.get $8
+            i32.eqz
+            if ;; label = @5
+              return
+            end
+            local.get $1
+            i32.const 0
+            local.get $1
+            i32.load
+            local.tee $8
+            i32.sub
+            i32.add
+            local.tee $0
+            local.get $11
+            i32.lt_u
+            if ;; label = @5
+              call $fimport$10
+            end
+            local.get $8
+            local.get $4
+            i32.add
+            local.set $1
+            local.get $0
+            i32.const 3672
+            i32.load
+            i32.eq
+            if ;; label = @5
+              block ;; label = @6
+                local.get $6
+                i32.const 4
+                i32.add
+                local.tee $2
+                i32.load
+                local.tee $3
+                i32.const 3
+                i32.and
+                i32.const 3
+                i32.ne
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $0
+                    local.set $3
+                    local.get $1
+                    local.set $2
+                    br 6 (;@2;)
+                  end
+                end
+                i32.const 3660
+                local.get $1
+                i32.store
+                local.get $2
+                local.get $3
+                i32.const -2
+                i32.and
+                i32.store
+                local.get $0
+                local.get $1
+                i32.const 1
+                i32.or
+                i32.store offset=4
+                local.get $0
+                local.get $1
+                i32.add
+                local.get $1
+                i32.store
+                return
+              end
+            end
+            local.get $8
+            i32.const 3
+            i32.shr_u
+            local.set $10
+            local.get $8
+            i32.const 256
+            i32.lt_u
+            if ;; label = @5
+              block ;; label = @6
+                local.get $0
+                i32.load offset=12
+                local.set $3
+                local.get $0
+                i32.load offset=8
+                local.tee $4
+                local.get $10
+                i32.const 1
+                i32.shl
+                i32.const 2
+                i32.shl
+                i32.const 3692
+                i32.add
+                local.tee $2
+                i32.ne
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $4
+                    local.get $11
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                    local.get $4
+                    i32.load offset=12
+                    local.get $0
+                    i32.ne
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                  end
+                end
+                local.get $3
+                local.get $4
+                i32.eq
+                if ;; label = @7
+                  block ;; label = @8
+                    i32.const 3652
+                    i32.const 3652
+                    i32.load
+                    i32.const 1
+                    local.get $10
+                    i32.shl
+                    i32.const -1
+                    i32.xor
+                    i32.and
+                    i32.store
+                    local.get $0
+                    local.set $3
+                    local.get $1
+                    local.set $2
+                    br 6 (;@2;)
+                  end
+                end
+                local.get $3
+                local.get $2
+                i32.eq
+                if ;; label = @7
+                  local.get $3
+                  i32.const 8
+                  i32.add
+                  local.set $5
+                else
+                  block ;; label = @8
+                    local.get $3
+                    local.get $11
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                    local.get $3
+                    i32.const 8
+                    i32.add
+                    local.tee $2
+                    i32.load
+                    local.get $0
+                    i32.eq
+                    if ;; label = @9
+                      local.get $2
+                      local.set $5
+                    else
+                      call $fimport$10
+                    end
+                  end
+                end
+                local.get $4
+                local.get $3
+                i32.store offset=12
+                local.get $5
+                local.get $4
+                i32.store
+                local.get $0
+                local.set $3
+                local.get $1
+                local.set $2
+                br 4 (;@2;)
+              end
+            end
+            local.get $0
+            i32.load offset=24
+            local.set $12
+            block $label$22 ;; label = @5
+              local.get $0
+              i32.load offset=12
+              local.tee $4
+              local.get $0
+              i32.eq
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $0
+                  i32.const 16
+                  i32.add
+                  local.tee $5
+                  i32.const 4
+                  i32.add
+                  local.tee $8
+                  i32.load
+                  local.tee $4
+                  if ;; label = @8
+                    local.get $8
+                    local.set $5
+                  else
+                    local.get $5
+                    i32.load
+                    local.tee $4
+                    i32.eqz
+                    if ;; label = @9
+                      block ;; label = @10
+                        i32.const 0
+                        local.set $7
+                        br 5 (;@5;)
+                      end
+                    end
+                  end
+                  loop $label$27 ;; label = @8
+                    local.get $4
+                    i32.const 20
+                    i32.add
+                    local.tee $8
+                    i32.load
+                    local.tee $10
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $10
+                        local.set $4
+                        local.get $8
+                        local.set $5
+                        br 2 (;@8;)
+                      end
+                    end
+                    local.get $4
+                    i32.const 16
+                    i32.add
+                    local.tee $8
+                    i32.load
+                    local.tee $10
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $10
+                        local.set $4
+                        local.get $8
+                        local.set $5
+                        br 2 (;@8;)
+                      end
+                    end
+                  end
+                  local.get $5
+                  local.get $11
+                  i32.lt_u
+                  if ;; label = @8
+                    call $fimport$10
+                  else
+                    block ;; label = @9
+                      local.get $5
+                      i32.const 0
+                      i32.store
+                      local.get $4
+                      local.set $7
+                    end
+                  end
+                end
+              else
+                block ;; label = @7
+                  local.get $0
+                  i32.load offset=8
+                  local.tee $5
+                  local.get $11
+                  i32.lt_u
+                  if ;; label = @8
+                    call $fimport$10
+                  end
+                  local.get $5
+                  i32.const 12
+                  i32.add
+                  local.tee $8
+                  i32.load
+                  local.get $0
+                  i32.ne
+                  if ;; label = @8
+                    call $fimport$10
+                  end
+                  local.get $4
+                  i32.const 8
+                  i32.add
+                  local.tee $10
+                  i32.load
+                  local.get $0
+                  i32.eq
+                  if ;; label = @8
+                    block ;; label = @9
+                      local.get $8
+                      local.get $4
+                      i32.store
+                      local.get $10
+                      local.get $5
+                      i32.store
+                      local.get $4
+                      local.set $7
+                    end
+                  else
+                    call $fimport$10
+                  end
+                end
+              end
+            end
+            local.get $12
+            if ;; label = @5
+              block ;; label = @6
+                local.get $0
+                local.get $0
+                i32.load offset=28
+                local.tee $4
+                i32.const 2
+                i32.shl
+                i32.const 3956
+                i32.add
+                local.tee $5
+                i32.load
+                i32.eq
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $5
+                    local.get $7
+                    i32.store
+                    local.get $7
+                    i32.eqz
+                    if ;; label = @9
+                      block ;; label = @10
+                        i32.const 3656
+                        i32.const 3656
+                        i32.load
+                        i32.const 1
+                        local.get $4
+                        i32.shl
+                        i32.const -1
+                        i32.xor
+                        i32.and
+                        i32.store
+                        local.get $0
+                        local.set $3
+                        local.get $1
+                        local.set $2
+                        br 8 (;@2;)
+                      end
+                    end
+                  end
+                else
+                  block ;; label = @8
+                    local.get $12
+                    i32.const 3668
+                    i32.load
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                    local.get $12
+                    i32.const 16
+                    i32.add
+                    local.tee $4
+                    i32.load
+                    local.get $0
+                    i32.eq
+                    if ;; label = @9
+                      local.get $4
+                      local.get $7
+                      i32.store
+                    else
+                      local.get $12
+                      local.get $7
+                      i32.store offset=20
+                    end
+                    local.get $7
+                    i32.eqz
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $0
+                        local.set $3
+                        local.get $1
+                        local.set $2
+                        br 8 (;@2;)
+                      end
+                    end
+                  end
+                end
+                local.get $7
+                i32.const 3668
+                i32.load
+                local.tee $5
+                i32.lt_u
+                if ;; label = @7
+                  call $fimport$10
+                end
+                local.get $7
+                local.get $12
+                i32.store offset=24
+                local.get $0
+                i32.const 16
+                i32.add
+                local.tee $8
+                i32.load
+                local.tee $4
+                if ;; label = @7
+                  local.get $4
+                  local.get $5
+                  i32.lt_u
+                  if ;; label = @8
+                    call $fimport$10
+                  else
+                    block ;; label = @9
+                      local.get $7
+                      local.get $4
+                      i32.store offset=16
+                      local.get $4
+                      local.get $7
+                      i32.store offset=24
+                    end
+                  end
+                end
+                local.get $8
+                i32.load offset=4
+                local.tee $4
+                if ;; label = @7
+                  local.get $4
+                  i32.const 3668
+                  i32.load
+                  i32.lt_u
+                  if ;; label = @8
+                    call $fimport$10
+                  else
+                    block ;; label = @9
+                      local.get $7
+                      local.get $4
+                      i32.store offset=20
+                      local.get $4
+                      local.get $7
+                      i32.store offset=24
+                      local.get $0
+                      local.set $3
+                      local.get $1
+                      local.set $2
+                    end
+                  end
+                else
+                  block ;; label = @8
+                    local.get $0
+                    local.set $3
+                    local.get $1
+                    local.set $2
+                  end
+                end
+              end
+            else
+              block ;; label = @6
+                local.get $0
+                local.set $3
+                local.get $1
+                local.set $2
+              end
+            end
+          end
+        end
+      end
+      local.get $3
+      local.get $6
+      i32.ge_u
+      if ;; label = @2
+        call $fimport$10
+      end
+      local.get $6
+      i32.const 4
+      i32.add
+      local.tee $1
+      i32.load
+      local.tee $0
+      i32.const 1
+      i32.and
+      i32.eqz
+      if ;; label = @2
+        call $fimport$10
+      end
+      local.get $0
+      i32.const 2
+      i32.and
+      if ;; label = @2
+        block ;; label = @3
+          local.get $1
+          local.get $0
+          i32.const -2
+          i32.and
+          i32.store
+          local.get $3
+          local.get $2
+          i32.const 1
+          i32.or
+          i32.store offset=4
+          local.get $3
+          local.get $2
+          i32.add
+          local.get $2
+          i32.store
+        end
+      else
+        block ;; label = @3
+          local.get $6
+          i32.const 3676
+          i32.load
+          i32.eq
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 3664
+              i32.const 3664
+              i32.load
+              local.get $2
+              i32.add
+              local.tee $0
+              i32.store
+              i32.const 3676
+              local.get $3
+              i32.store
+              local.get $3
+              local.get $0
+              i32.const 1
+              i32.or
+              i32.store offset=4
+              local.get $3
+              i32.const 3672
+              i32.load
+              i32.ne
+              if ;; label = @6
+                return
+              end
+              i32.const 3672
+              i32.const 0
+              i32.store
+              i32.const 3660
+              i32.const 0
+              i32.store
+              return
+            end
+          end
+          local.get $6
+          i32.const 3672
+          i32.load
+          i32.eq
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 3660
+              i32.const 3660
+              i32.load
+              local.get $2
+              i32.add
+              local.tee $0
+              i32.store
+              i32.const 3672
+              local.get $3
+              i32.store
+              local.get $3
+              local.get $0
+              i32.const 1
+              i32.or
+              i32.store offset=4
+              local.get $3
+              local.get $0
+              i32.add
+              local.get $0
+              i32.store
+              return
+            end
+          end
+          local.get $0
+          i32.const -8
+          i32.and
+          local.get $2
+          i32.add
+          local.set $5
+          local.get $0
+          i32.const 3
+          i32.shr_u
+          local.set $4
+          block $label$61 ;; label = @4
+            local.get $0
+            i32.const 256
+            i32.lt_u
+            if ;; label = @5
+              block ;; label = @6
+                local.get $6
+                i32.load offset=12
+                local.set $2
+                local.get $6
+                i32.load offset=8
+                local.tee $1
+                local.get $4
+                i32.const 1
+                i32.shl
+                i32.const 2
+                i32.shl
+                i32.const 3692
+                i32.add
+                local.tee $0
+                i32.ne
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $1
+                    i32.const 3668
+                    i32.load
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                    local.get $1
+                    i32.load offset=12
+                    local.get $6
+                    i32.ne
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                  end
+                end
+                local.get $2
+                local.get $1
+                i32.eq
+                if ;; label = @7
+                  block ;; label = @8
+                    i32.const 3652
+                    i32.const 3652
+                    i32.load
+                    i32.const 1
+                    local.get $4
+                    i32.shl
+                    i32.const -1
+                    i32.xor
+                    i32.and
+                    i32.store
+                    br 4 (;@4;)
+                  end
+                end
+                local.get $2
+                local.get $0
+                i32.eq
+                if ;; label = @7
+                  local.get $2
+                  i32.const 8
+                  i32.add
+                  local.set $14
+                else
+                  block ;; label = @8
+                    local.get $2
+                    i32.const 3668
+                    i32.load
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                    local.get $2
+                    i32.const 8
+                    i32.add
+                    local.tee $0
+                    i32.load
+                    local.get $6
+                    i32.eq
+                    if ;; label = @9
+                      local.get $0
+                      local.set $14
+                    else
+                      call $fimport$10
+                    end
+                  end
+                end
+                local.get $1
+                local.get $2
+                i32.store offset=12
+                local.get $14
+                local.get $1
+                i32.store
+              end
+            else
+              block ;; label = @6
+                local.get $6
+                i32.load offset=24
+                local.set $7
+                block $label$73 ;; label = @7
+                  local.get $6
+                  i32.load offset=12
+                  local.tee $0
+                  local.get $6
+                  i32.eq
+                  if ;; label = @8
+                    block ;; label = @9
+                      local.get $6
+                      i32.const 16
+                      i32.add
+                      local.tee $2
+                      i32.const 4
+                      i32.add
+                      local.tee $1
+                      i32.load
+                      local.tee $0
+                      if ;; label = @10
+                        local.get $1
+                        local.set $2
+                      else
+                        local.get $2
+                        i32.load
+                        local.tee $0
+                        i32.eqz
+                        if ;; label = @11
+                          block ;; label = @12
+                            i32.const 0
+                            local.set $9
+                            br 5 (;@7;)
+                          end
+                        end
+                      end
+                      loop $label$78 ;; label = @10
+                        local.get $0
+                        i32.const 20
+                        i32.add
+                        local.tee $1
+                        i32.load
+                        local.tee $4
+                        if ;; label = @11
+                          block ;; label = @12
+                            local.get $4
+                            local.set $0
+                            local.get $1
+                            local.set $2
+                            br 2 (;@10;)
+                          end
+                        end
+                        local.get $0
+                        i32.const 16
+                        i32.add
+                        local.tee $1
+                        i32.load
+                        local.tee $4
+                        if ;; label = @11
+                          block ;; label = @12
+                            local.get $4
+                            local.set $0
+                            local.get $1
+                            local.set $2
+                            br 2 (;@10;)
+                          end
+                        end
+                      end
+                      local.get $2
+                      i32.const 3668
+                      i32.load
+                      i32.lt_u
+                      if ;; label = @10
+                        call $fimport$10
+                      else
+                        block ;; label = @11
+                          local.get $2
+                          i32.const 0
+                          i32.store
+                          local.get $0
+                          local.set $9
+                        end
+                      end
+                    end
+                  else
+                    block ;; label = @9
+                      local.get $6
+                      i32.load offset=8
+                      local.tee $2
+                      i32.const 3668
+                      i32.load
+                      i32.lt_u
+                      if ;; label = @10
+                        call $fimport$10
+                      end
+                      local.get $2
+                      i32.const 12
+                      i32.add
+                      local.tee $1
+                      i32.load
+                      local.get $6
+                      i32.ne
+                      if ;; label = @10
+                        call $fimport$10
+                      end
+                      local.get $0
+                      i32.const 8
+                      i32.add
+                      local.tee $4
+                      i32.load
+                      local.get $6
+                      i32.eq
+                      if ;; label = @10
+                        block ;; label = @11
+                          local.get $1
+                          local.get $0
+                          i32.store
+                          local.get $4
+                          local.get $2
+                          i32.store
+                          local.get $0
+                          local.set $9
+                        end
+                      else
+                        call $fimport$10
+                      end
+                    end
+                  end
+                end
+                local.get $7
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $6
+                    local.get $6
+                    i32.load offset=28
+                    local.tee $0
+                    i32.const 2
+                    i32.shl
+                    i32.const 3956
+                    i32.add
+                    local.tee $2
+                    i32.load
+                    i32.eq
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $2
+                        local.get $9
+                        i32.store
+                        local.get $9
+                        i32.eqz
+                        if ;; label = @11
+                          block ;; label = @12
+                            i32.const 3656
+                            i32.const 3656
+                            i32.load
+                            i32.const 1
+                            local.get $0
+                            i32.shl
+                            i32.const -1
+                            i32.xor
+                            i32.and
+                            i32.store
+                            br 8 (;@4;)
+                          end
+                        end
+                      end
+                    else
+                      block ;; label = @10
+                        local.get $7
+                        i32.const 3668
+                        i32.load
+                        i32.lt_u
+                        if ;; label = @11
+                          call $fimport$10
+                        end
+                        local.get $7
+                        i32.const 16
+                        i32.add
+                        local.tee $0
+                        i32.load
+                        local.get $6
+                        i32.eq
+                        if ;; label = @11
+                          local.get $0
+                          local.get $9
+                          i32.store
+                        else
+                          local.get $7
+                          local.get $9
+                          i32.store offset=20
+                        end
+                        local.get $9
+                        i32.eqz
+                        br_if 6 (;@4;)
+                      end
+                    end
+                    local.get $9
+                    i32.const 3668
+                    i32.load
+                    local.tee $2
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                    local.get $9
+                    local.get $7
+                    i32.store offset=24
+                    local.get $6
+                    i32.const 16
+                    i32.add
+                    local.tee $1
+                    i32.load
+                    local.tee $0
+                    if ;; label = @9
+                      local.get $0
+                      local.get $2
+                      i32.lt_u
+                      if ;; label = @10
+                        call $fimport$10
+                      else
+                        block ;; label = @11
+                          local.get $9
+                          local.get $0
+                          i32.store offset=16
+                          local.get $0
+                          local.get $9
+                          i32.store offset=24
+                        end
+                      end
+                    end
+                    local.get $1
+                    i32.load offset=4
+                    local.tee $0
+                    if ;; label = @9
+                      local.get $0
+                      i32.const 3668
+                      i32.load
+                      i32.lt_u
+                      if ;; label = @10
+                        call $fimport$10
+                      else
+                        block ;; label = @11
+                          local.get $9
+                          local.get $0
+                          i32.store offset=20
+                          local.get $0
+                          local.get $9
+                          i32.store offset=24
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+          local.get $3
+          local.get $5
+          i32.const 1
+          i32.or
+          i32.store offset=4
+          local.get $3
+          local.get $5
+          i32.add
+          local.get $5
+          i32.store
+          local.get $3
+          i32.const 3672
+          i32.load
+          i32.eq
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 3660
+              local.get $5
+              i32.store
+              return
+            end
+          else
+            local.get $5
+            local.set $2
+          end
+        end
+      end
+      local.get $2
+      i32.const 3
+      i32.shr_u
+      local.set $1
+      local.get $2
+      i32.const 256
+      i32.lt_u
+      if ;; label = @2
+        block ;; label = @3
+          local.get $1
+          i32.const 1
+          i32.shl
+          i32.const 2
+          i32.shl
+          i32.const 3692
+          i32.add
+          local.set $0
+          i32.const 3652
+          i32.load
+          local.tee $2
+          i32.const 1
+          local.get $1
+          i32.shl
+          local.tee $1
+          i32.and
+          if ;; label = @4
+            local.get $0
+            i32.const 8
+            i32.add
+            local.tee $2
+            i32.load
+            local.tee $1
+            i32.const 3668
+            i32.load
+            i32.lt_u
+            if ;; label = @5
+              call $fimport$10
+            else
+              block ;; label = @6
+                local.get $2
+                local.set $15
+                local.get $1
+                local.set $13
+              end
+            end
+          else
+            block ;; label = @5
+              i32.const 3652
+              local.get $2
+              local.get $1
+              i32.or
+              i32.store
+              local.get $0
+              i32.const 8
+              i32.add
+              local.set $15
+              local.get $0
+              local.set $13
+            end
+          end
+          local.get $15
+          local.get $3
+          i32.store
+          local.get $13
+          local.get $3
+          i32.store offset=12
+          local.get $3
+          local.get $13
+          i32.store offset=8
+          local.get $3
+          local.get $0
+          i32.store offset=12
+          return
+        end
+      end
+      local.get $2
+      i32.const 8
+      i32.shr_u
+      local.tee $0
+      if (result i32) ;; label = @2
+        local.get $2
+        i32.const 16777215
+        i32.gt_u
+        if (result i32) ;; label = @3
+          i32.const 31
+        else
+          local.get $2
+          i32.const 14
+          local.get $0
+          local.get $0
+          i32.const 1048320
+          i32.add
+          i32.const 16
+          i32.shr_u
+          i32.const 8
+          i32.and
+          local.tee $0
+          i32.shl
+          local.tee $1
+          i32.const 520192
+          i32.add
+          i32.const 16
+          i32.shr_u
+          i32.const 4
+          i32.and
+          local.tee $4
+          local.get $0
+          i32.or
+          local.get $1
+          local.get $4
+          i32.shl
+          local.tee $0
+          i32.const 245760
+          i32.add
+          i32.const 16
+          i32.shr_u
+          i32.const 2
+          i32.and
+          local.tee $1
+          i32.or
+          i32.sub
+          local.get $0
+          local.get $1
+          i32.shl
+          i32.const 15
+          i32.shr_u
+          i32.add
+          local.tee $0
+          i32.const 7
+          i32.add
+          i32.shr_u
+          i32.const 1
+          i32.and
+          local.get $0
+          i32.const 1
+          i32.shl
+          i32.or
+        end
+      else
+        i32.const 0
+      end
+      local.tee $1
+      i32.const 2
+      i32.shl
+      i32.const 3956
+      i32.add
+      local.set $0
+      local.get $3
+      local.get $1
+      i32.store offset=28
+      local.get $3
+      i32.const 0
+      i32.store offset=20
+      local.get $3
+      i32.const 0
+      i32.store offset=16
+      block $label$113 ;; label = @2
+        i32.const 3656
+        i32.load
+        local.tee $4
+        i32.const 1
+        local.get $1
+        i32.shl
+        local.tee $5
+        i32.and
+        if ;; label = @3
+          block ;; label = @4
+            local.get $0
+            i32.load
+            local.set $0
+            i32.const 25
+            local.get $1
+            i32.const 1
+            i32.shr_u
+            i32.sub
+            local.set $4
+            local.get $2
+            local.get $1
+            i32.const 31
+            i32.eq
+            if (result i32) ;; label = @5
+              i32.const 0
+            else
+              local.get $4
+            end
+            i32.shl
+            local.set $1
+            block $label$117 ;; label = @5
+              block $label$118 ;; label = @6
+                block $label$119 ;; label = @7
+                  loop $label$120 ;; label = @8
+                    local.get $0
+                    i32.load offset=4
+                    i32.const -8
+                    i32.and
+                    local.get $2
+                    i32.eq
+                    br_if 2 (;@6;)
+                    local.get $1
+                    i32.const 1
+                    i32.shl
+                    local.set $4
+                    local.get $0
+                    i32.const 16
+                    i32.add
+                    local.get $1
+                    i32.const 31
+                    i32.shr_u
+                    i32.const 2
+                    i32.shl
+                    i32.add
+                    local.tee $1
+                    i32.load
+                    local.tee $5
+                    i32.eqz
+                    br_if 1 (;@7;)
+                    local.get $4
+                    local.set $1
+                    local.get $5
+                    local.set $0
+                    br 0 (;@8;)
+                  end
+                end
+                local.get $1
+                i32.const 3668
+                i32.load
+                i32.lt_u
+                if ;; label = @7
+                  call $fimport$10
+                else
+                  block ;; label = @8
+                    local.get $1
+                    local.get $3
+                    i32.store
+                    local.get $3
+                    local.get $0
+                    i32.store offset=24
+                    local.get $3
+                    local.get $3
+                    i32.store offset=12
+                    local.get $3
+                    local.get $3
+                    i32.store offset=8
+                    br 6 (;@2;)
+                  end
+                end
+                br 1 (;@5;)
+              end
+              local.get $0
+              i32.const 8
+              i32.add
+              local.tee $1
+              i32.load
+              local.tee $2
+              i32.const 3668
+              i32.load
+              local.tee $4
+              i32.ge_u
+              local.get $0
+              local.get $4
+              i32.ge_u
+              i32.and
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $2
+                  local.get $3
+                  i32.store offset=12
+                  local.get $1
+                  local.get $3
+                  i32.store
+                  local.get $3
+                  local.get $2
+                  i32.store offset=8
+                  local.get $3
+                  local.get $0
+                  i32.store offset=12
+                  local.get $3
+                  i32.const 0
+                  i32.store offset=24
+                end
+              else
+                call $fimport$10
+              end
+            end
+          end
+        else
+          block ;; label = @4
+            i32.const 3656
+            local.get $4
+            local.get $5
+            i32.or
+            i32.store
+            local.get $0
+            local.get $3
+            i32.store
+            local.get $3
+            local.get $0
+            i32.store offset=24
+            local.get $3
+            local.get $3
+            i32.store offset=12
+            local.get $3
+            local.get $3
+            i32.store offset=8
+          end
+        end
+      end
+      i32.const 3684
+      i32.const 3684
+      i32.load
+      i32.const -1
+      i32.add
+      local.tee $0
+      i32.store
+      local.get $0
+      if ;; label = @2
+        return
+      else
+        i32.const 4108
+        local.set $0
+      end
+      loop $label$128 ;; label = @2
+        local.get $0
+        i32.load
+        local.tee $2
+        i32.const 8
+        i32.add
+        local.set $0
+        local.get $2
+        br_if 0 (;@2;)
+      end
+      i32.const 3684
+      i32.const -1
+      i32.store
+    end
+  )
+  (func $37 (;50;) (type $6)
+    nop
+  )
+  (func $38 (;51;) (type $1) (param $0 i32) (result i32)
+    (local $1 i32) (local $2 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$0
+      i32.load
+      local.tee $2
+      local.get $0
+      i32.const 15
+      i32.add
+      i32.const -16
+      i32.and
+      local.tee $0
+      i32.add
+      local.set $1
+      local.get $0
+      i32.const 0
+      i32.gt_s
+      local.get $1
+      local.get $2
+      i32.lt_s
+      i32.and
+      local.get $1
+      i32.const 0
+      i32.lt_s
+      i32.or
+      if ;; label = @2
+        block ;; label = @3
+          call $fimport$6
+          drop
+          i32.const 12
+          call $fimport$11
+          i32.const -1
+          return
+        end
+      end
+      global.get $global$0
+      local.get $1
+      i32.store
+      local.get $1
+      call $fimport$5
+      i32.gt_s
+      if ;; label = @2
+        call $fimport$4
+        i32.eqz
+        if ;; label = @3
+          block ;; label = @4
+            i32.const 12
+            call $fimport$11
+            global.get $global$0
+            local.get $2
+            i32.store
+            i32.const -1
+            return
+          end
+        end
+      end
+      local.get $2
+    end
+  )
+  (func $39 (;52;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32) (local $4 i32) (local $5 i32)
+    block $label$1 (result i32) ;; label = @1
+      local.get $0
+      local.get $2
+      i32.add
+      local.set $4
+      local.get $2
+      i32.const 20
+      i32.ge_s
+      if ;; label = @2
+        block ;; label = @3
+          local.get $1
+          i32.const 255
+          i32.and
+          local.set $1
+          local.get $0
+          i32.const 3
+          i32.and
+          local.tee $3
+          if ;; label = @4
+            block ;; label = @5
+              local.get $0
+              i32.const 4
+              i32.add
+              local.get $3
+              i32.sub
+              local.set $3
+              loop $label$4 ;; label = @6
+                local.get $0
+                local.get $3
+                i32.lt_s
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $0
+                    local.get $1
+                    i32.store8
+                    local.get $0
+                    i32.const 1
+                    i32.add
+                    local.set $0
+                    br 2 (;@6;)
+                  end
+                end
+              end
+            end
+          end
+          local.get $1
+          local.get $1
+          i32.const 8
+          i32.shl
+          i32.or
+          local.get $1
+          i32.const 16
+          i32.shl
+          i32.or
+          local.get $1
+          i32.const 24
+          i32.shl
+          i32.or
+          local.set $3
+          local.get $4
+          i32.const -4
+          i32.and
+          local.set $5
+          loop $label$6 ;; label = @4
+            local.get $0
+            local.get $5
+            i32.lt_s
+            if ;; label = @5
+              block ;; label = @6
+                local.get $0
+                local.get $3
+                i32.store
+                local.get $0
+                i32.const 4
+                i32.add
+                local.set $0
+                br 2 (;@4;)
+              end
+            end
+          end
+        end
+      end
+      loop $label$8 ;; label = @2
+        local.get $0
+        local.get $4
+        i32.lt_s
+        if ;; label = @3
+          block ;; label = @4
+            local.get $0
+            local.get $1
+            i32.store8
+            local.get $0
+            i32.const 1
+            i32.add
+            local.set $0
+            br 2 (;@2;)
+          end
+        end
+      end
+      local.get $0
+      local.get $2
+      i32.sub
+    end
+  )
+  (func $40 (;53;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32)
+    block $label$1 (result i32) ;; label = @1
+      local.get $2
+      i32.const 4096
+      i32.ge_s
+      if ;; label = @2
+        local.get $0
+        local.get $1
+        local.get $2
+        call $fimport$12
+        return
+      end
+      local.get $0
+      local.set $3
+      local.get $0
+      i32.const 3
+      i32.and
+      local.get $1
+      i32.const 3
+      i32.and
+      i32.eq
+      if ;; label = @2
+        block ;; label = @3
+          loop $label$4 ;; label = @4
+            local.get $0
+            i32.const 3
+            i32.and
+            if ;; label = @5
+              block ;; label = @6
+                local.get $2
+                i32.eqz
+                if ;; label = @7
+                  local.get $3
+                  return
+                end
+                local.get $0
+                local.get $1
+                i32.load8_s
+                i32.store8
+                local.get $0
+                i32.const 1
+                i32.add
+                local.set $0
+                local.get $1
+                i32.const 1
+                i32.add
+                local.set $1
+                local.get $2
+                i32.const 1
+                i32.sub
+                local.set $2
+                br 2 (;@4;)
+              end
+            end
+          end
+          loop $label$7 ;; label = @4
+            local.get $2
+            i32.const 4
+            i32.ge_s
+            if ;; label = @5
+              block ;; label = @6
+                local.get $0
+                local.get $1
+                i32.load
+                i32.store
+                local.get $0
+                i32.const 4
+                i32.add
+                local.set $0
+                local.get $1
+                i32.const 4
+                i32.add
+                local.set $1
+                local.get $2
+                i32.const 4
+                i32.sub
+                local.set $2
+                br 2 (;@4;)
+              end
+            end
+          end
+        end
+      end
+      loop $label$9 ;; label = @2
+        local.get $2
+        i32.const 0
+        i32.gt_s
+        if ;; label = @3
+          block ;; label = @4
+            local.get $0
+            local.get $1
+            i32.load8_s
+            i32.store8
+            local.get $0
+            i32.const 1
+            i32.add
+            local.set $0
+            local.get $1
+            i32.const 1
+            i32.add
+            local.set $1
+            local.get $2
+            i32.const 1
+            i32.sub
+            local.set $2
+            br 2 (;@2;)
+          end
+        end
+      end
+      local.get $3
+    end
+  )
+  (func $41 (;54;) (type $3) (result i32)
+    i32.const 0
+  )
+  (func $42 (;55;) (type $4) (param $0 i32) (param $1 i32) (result i32)
+    local.get $1
+    local.get $0
+    i32.const 1
+    i32.and
+    i32.const 0
+    i32.add
+    call_indirect (type $1)
+  )
+  (func $43 (;56;) (type $12) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32)
+    local.get $1
+    local.get $2
+    local.get $3
+    local.get $0
+    i32.const 3
+    i32.and
+    i32.const 2
+    i32.add
+    call_indirect (type $0)
+  )
+  (func $44 (;57;) (type $5) (param $0 i32) (param $1 i32)
+    local.get $1
+    local.get $0
+    i32.const 1
+    i32.and
+    i32.const 6
+    i32.add
+    call_indirect (type $2)
+  )
+  (func $45 (;58;) (type $1) (param $0 i32) (result i32)
+    block $label$1 (result i32) ;; label = @1
+      i32.const 0
+      call $fimport$3
+      i32.const 0
+    end
+  )
+  (func $46 (;59;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    block $label$1 (result i32) ;; label = @1
+      i32.const 1
+      call $fimport$3
+      i32.const 0
+    end
+  )
+  (func $47 (;60;) (type $2) (param $0 i32)
+    i32.const 2
+    call $fimport$3
+  )
+  (global $global$0 (;5;) (mut i32) global.get $gimport$0)
+  (global $global$1 (;6;) (mut i32) global.get $gimport$1)
+  (global $global$2 (;7;) (mut i32) global.get $gimport$2)
+  (global $global$3 (;8;) (mut i32) i32.const 0)
+  (global $global$4 (;9;) (mut i32) i32.const 0)
+  (global $global$5 (;10;) (mut i32) i32.const 0)
+  (export "_sbrk" (func $38))
+  (export "_free" (func $36))
+  (export "_main" (func $8))
+  (export "_pthread_self" (func $41))
+  (export "_memset" (func $39))
+  (export "_malloc" (func $35))
+  (export "_memcpy" (func $40))
+  (export "___errno_location" (func $12))
+  (export "runPostSets" (func $37))
+  (export "stackAlloc" (func $0))
+  (export "stackSave" (func $1))
+  (export "stackRestore" (func $2))
+  (export "establishStackSpace" (func $3))
+  (export "setThrew" (func $4))
+  (export "setTempRet0" (func $5))
+  (export "getTempRet0" (func $6))
+  (export "dynCall_ii" (func $42))
+  (export "dynCall_iiii" (func $43))
+  (export "dynCall_vi" (func $44))
+  (elem (;0;) (global.get $gimport$19) func $45 $9 $46 $14 $10 $15 $47 $16)
+  (data (;0;) (i32.const 1024) "\04\04\00\00\05")
+  (data (;1;) (i32.const 1040) "\01")
+  (data (;2;) (i32.const 1064) "\01\00\00\00\02\00\00\00<\10\00\00\00\04")
+  (data (;3;) (i32.const 1088) "\01")
+  (data (;4;) (i32.const 1103) "\0a\ff\ff\ff\ff")
+  (data (;5;) (i32.const 1140) "error: %d\0a\00Pfannkuchen(%d) = %d.\0a\00%d\00\11\00\0a\00\11\11\11\00\00\00\00\05\00\00\00\00\00\00\09\00\00\00\00\0b")
+  (data (;6;) (i32.const 1209) "\11\00\0f\0a\11\11\11\03\0a\07\00\01\13\09\0b\0b\00\00\09\06\0b\00\00\0b\00\06\11\00\00\00\11\11\11")
+  (data (;7;) (i32.const 1258) "\0b")
+  (data (;8;) (i32.const 1267) "\11\00\0a\0a\11\11\11\00\0a\00\00\02\00\09\0b\00\00\00\09\00\0b\00\00\0b")
+  (data (;9;) (i32.const 1316) "\0c")
+  (data (;10;) (i32.const 1328) "\0c\00\00\00\00\0c\00\00\00\00\09\0c\00\00\00\00\00\0c\00\00\0c")
+  (data (;11;) (i32.const 1374) "\0e")
+  (data (;12;) (i32.const 1386) "\0d\00\00\00\04\0d\00\00\00\00\09\0e\00\00\00\00\00\0e\00\00\0e")
+  (data (;13;) (i32.const 1432) "\10")
+  (data (;14;) (i32.const 1444) "\0f\00\00\00\00\0f\00\00\00\00\09\10\00\00\00\00\00\10\00\00\10\00\00\12\00\00\00\12\12\12")
+  (data (;15;) (i32.const 1499) "\12\00\00\00\12\12\12\00\00\00\00\00\00\09")
+  (data (;16;) (i32.const 1548) "\0b")
+  (data (;17;) (i32.const 1560) "\0a\00\00\00\00\0a\00\00\00\00\09\0b\00\00\00\00\00\0b\00\00\0b")
+  (data (;18;) (i32.const 1606) "\0c")
+  (data (;19;) (i32.const 1618) "\0c\00\00\00\00\0c\00\00\00\00\09\0c\00\00\00\00\00\0c\00\00\0c\00\000123456789ABCDEF-+   0X0x\00(null)\00-0X+0X 0X-0x+0x 0x\00inf\00INF\00nan\00NAN\00.\00T!\22\19\0d\01\02\03\11K\1c\0c\10\04\0b\1d\12\1e'hnopqb \05\06\0f\13\14\15\1a\08\16\07($\17\18\09\0a\0e\1b\1f%#\83\82}&*+<=>?CGJMXYZ[\5c]^_`acdefgijklrstyz{|\00Illegal byte sequence\00Domain error\00Result not representable\00Not a tty\00Permission denied\00Operation not permitted\00No such file or directory\00No such process\00File exists\00Value too large for data type\00No space left on device\00Out of memory\00Resource busy\00Interrupted system call\00Resource temporarily unavailable\00Invalid seek\00Cross-device link\00Read-only file system\00Directory not empty\00Connection reset by peer\00Operation timed out\00Connection refused\00Host is down\00Host is unreachable\00Address in use\00Broken pipe\00I/O error\00No such device or address\00Block device required\00No such device\00Not a directory\00Is a directory\00Text file busy\00Exec format error\00Invalid argument\00Argument list too long\00Symbolic link loop\00Filename too long\00Too many open files in system\00No file descriptors available\00Bad file descriptor\00No child process\00Bad address\00File too large\00Too many links\00No locks available\00Resource deadlock would occur\00State not recoverable\00Previous owner died\00Operation canceled\00Function not implemented\00No message of desired type\00Identifier removed\00Device not a stream\00No data available\00Device timeout\00Out of streams resources\00Link has been severed\00Protocol error\00Bad message\00File descriptor in bad state\00Not a socket\00Destination address required\00Message too large\00Protocol wrong type for socket\00Protocol not available\00Protocol not supported\00Socket type not supported\00Not supported\00Protocol family not supported\00Address family not supported by protocol\00Address not available\00Network is down\00Network unreachable\00Connection reset by network\00Connection aborted\00No buffer space available\00Socket is connected\00Socket not connected\00Cannot send after socket shutdown\00Operation already in progress\00Operation in progress\00Stale file handle\00Remote I/O error\00Quota exceeded\00No medium found\00Wrong medium type\00No error information")
+)
diff --git a/tests/misc_testsuite/embenchen_fasta.wast b/tests/misc_testsuite/embenchen_fasta.wast
new file mode 100644
index 000000000000..fd38750fd1d0
--- /dev/null
+++ b/tests/misc_testsuite/embenchen_fasta.wast
@@ -0,0 +1,12082 @@
+;; copied from a historical cranelift-wasm test and provided here as proof that
+;; this still compiles on various platforms and such
+
+(module $env
+  (memory (export "memory") 2 2)
+  (table (export "table") 9 9 funcref)
+  (global (export "DYNAMICTOP_PTR") i32 i32.const 0)
+  (global (export "STACKTOP") i32 i32.const 0)
+  (global (export "STACK_MAX") i32 i32.const 0)
+  (global (export "memoryBase") i32 i32.const 0)
+  (global (export "tableBase") i32 i32.const 0)
+  (func (export "abort") (param i32))
+  (func (export "enlargeMemory") (result i32) unreachable)
+  (func (export "getTotalMemory") (result i32) unreachable)
+  (func (export "abortOnCannotGrowMemory") (result i32) unreachable)
+  (func (export "_pthread_cleanup_pop") (param i32))
+  (func (export "___syscall6") (param i32 i32) (result i32) unreachable)
+  (func (export "_pthread_cleanup_push") (param i32 i32))
+  (func (export "_abort"))
+  (func (export "___setErrNo") (param i32))
+  (func (export "_emscripten_memcpy_big") (param i32 i32 i32) (result i32) unreachable)
+  (func (export "___syscall54") (param i32 i32) (result i32) unreachable)
+  (func (export "___syscall140") (param i32 i32) (result i32) unreachable)
+  (func (export "___syscall146") (param i32 i32) (result i32) unreachable)
+)
+
+(module
+  (type $0 (;0;) (func (param i32 i32 i32) (result i32)))
+  (type $1 (;1;) (func))
+  (type $2 (;2;) (func (param i32) (result i32)))
+  (type $3 (;3;) (func (param i32)))
+  (type $4 (;4;) (func (result i32)))
+  (type $5 (;5;) (func (param i32 i32)))
+  (type $6 (;6;) (func (param i32 i32) (result i32)))
+  (type $7 (;7;) (func (param i32 i32 i32 i32 i32) (result i32)))
+  (type $8 (;8;) (func (param i32 i32 i32)))
+  (type $9 (;9;) (func (param i64 i32) (result i32)))
+  (type $10 (;10;) (func (param i32 i32 i32 i32 i32)))
+  (type $11 (;11;) (func (param f64 i32) (result f64)))
+  (type $12 (;12;) (func (param i32 i32 i32 i32) (result i32)))
+  (import "env" "memory" (memory $16 (;0;) 2 2))
+  (import "env" "table" (table $timport$17 (;0;) 9 9 funcref))
+  (import "env" "DYNAMICTOP_PTR" (global $gimport$0 (;0;) i32))
+  (import "env" "STACKTOP" (global $gimport$1 (;1;) i32))
+  (import "env" "STACK_MAX" (global $gimport$2 (;2;) i32))
+  (import "env" "memoryBase" (global $gimport$18 (;3;) i32))
+  (import "env" "tableBase" (global $gimport$19 (;4;) i32))
+  (import "env" "abort" (func $fimport$3 (;0;) (type $3)))
+  (import "env" "enlargeMemory" (func $fimport$4 (;1;) (type $4)))
+  (import "env" "getTotalMemory" (func $fimport$5 (;2;) (type $4)))
+  (import "env" "abortOnCannotGrowMemory" (func $fimport$6 (;3;) (type $4)))
+  (import "env" "_pthread_cleanup_pop" (func $fimport$7 (;4;) (type $3)))
+  (import "env" "_abort" (func $fimport$8 (;5;) (type $1)))
+  (import "env" "_pthread_cleanup_push" (func $fimport$9 (;6;) (type $5)))
+  (import "env" "___syscall6" (func $fimport$10 (;7;) (type $6)))
+  (import "env" "___setErrNo" (func $fimport$11 (;8;) (type $3)))
+  (import "env" "_emscripten_memcpy_big" (func $fimport$12 (;9;) (type $0)))
+  (import "env" "___syscall54" (func $fimport$13 (;10;) (type $6)))
+  (import "env" "___syscall140" (func $fimport$14 (;11;) (type $6)))
+  (import "env" "___syscall146" (func $fimport$15 (;12;) (type $6)))
+  (func $0 (;13;) (type $2) (param $0 i32) (result i32)
+    (local $1 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $1
+      global.get $global$1
+      local.get $0
+      i32.add
+      global.set $global$1
+      global.get $global$1
+      i32.const 15
+      i32.add
+      i32.const -16
+      i32.and
+      global.set $global$1
+      local.get $1
+    end
+  )
+  (func $1 (;14;) (type $4) (result i32)
+    global.get $global$1
+  )
+  (func $2 (;15;) (type $3) (param $0 i32)
+    local.get $0
+    global.set $global$1
+  )
+  (func $3 (;16;) (type $5) (param $0 i32) (param $1 i32)
+    block $label$1 ;; label = @1
+      local.get $0
+      global.set $global$1
+      local.get $1
+      global.set $global$2
+    end
+  )
+  (func $4 (;17;) (type $5) (param $0 i32) (param $1 i32)
+    global.get $global$3
+    i32.eqz
+    if ;; label = @1
+      block ;; label = @2
+        local.get $0
+        global.set $global$3
+        local.get $1
+        global.set $global$4
+      end
+    end
+  )
+  (func $5 (;18;) (type $3) (param $0 i32)
+    local.get $0
+    global.set $global$5
+  )
+  (func $6 (;19;) (type $4) (result i32)
+    global.get $global$5
+  )
+  (func $7 (;20;) (type $6) (param $0 i32) (param $1 i32) (result i32)
+    (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 f32) (local $12 f32) (local $13 f64)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $5
+      global.get $global$1
+      i32.const 4256
+      i32.add
+      global.set $global$1
+      local.get $5
+      local.set $3
+      local.get $5
+      i32.const 2128
+      i32.add
+      local.set $6
+      local.get $5
+      i32.const 8
+      i32.add
+      local.set $7
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          local.get $0
+          i32.const 1
+          i32.le_s
+          br_if 0 (;@3;)
+          block $label$4 ;; label = @4
+            block $label$5 ;; label = @5
+              block $label$6 ;; label = @6
+                block $label$7 ;; label = @7
+                  block $label$8 ;; label = @8
+                    block $label$9 ;; label = @9
+                      block $label$10 ;; label = @10
+                        local.get $1
+                        i32.load offset=4
+                        i32.load8_s
+                        local.tee $0
+                        i32.const 48
+                        i32.sub
+                        br_table 5 (;@5;) 0 (;@10;) 2 (;@8;) 1 (;@9;) 3 (;@7;) 4 (;@6;) 6 (;@4;)
+                      end
+                      i32.const 950000
+                      local.set $4
+                      br 7 (;@2;)
+                    end
+                    br 5 (;@3;)
+                  end
+                  i32.const 9500000
+                  local.set $4
+                  br 5 (;@2;)
+                end
+                i32.const 95000000
+                local.set $4
+                br 4 (;@2;)
+              end
+              i32.const 190000000
+              local.set $4
+              br 3 (;@2;)
+            end
+            local.get $5
+            global.set $global$1
+            i32.const 0
+            return
+          end
+          local.get $3
+          local.get $0
+          i32.const -48
+          i32.add
+          i32.store
+          i32.const 1400
+          local.get $3
+          call $34
+          drop
+          local.get $5
+          global.set $global$1
+          i32.const -1
+          return
+        end
+        i32.const 19000000
+        local.set $4
+      end
+      i32.const 347
+      call $40
+      local.tee $8
+      i32.const 1411
+      i32.const 287
+      call $47
+      drop
+      local.get $8
+      i32.const 287
+      i32.add
+      local.tee $0
+      i32.const 1411
+      i64.load align=1
+      i64.store align=1
+      local.get $0
+      i32.const 1419
+      i64.load align=1
+      i64.store offset=8 align=1
+      local.get $0
+      i32.const 1427
+      i64.load align=1
+      i64.store offset=16 align=1
+      local.get $0
+      i32.const 1435
+      i64.load align=1
+      i64.store offset=24 align=1
+      local.get $0
+      i32.const 1443
+      i64.load align=1
+      i64.store offset=32 align=1
+      local.get $0
+      i32.const 1451
+      i64.load align=1
+      i64.store offset=40 align=1
+      local.get $0
+      i32.const 1459
+      i64.load align=1
+      i64.store offset=48 align=1
+      local.get $0
+      i32.const 1467
+      i32.load align=1
+      i32.store offset=56 align=1
+      local.get $4
+      i32.const 1
+      i32.shl
+      local.set $0
+      i32.const 0
+      local.set $1
+      loop $label$11 ;; label = @2
+        local.get $0
+        i32.const 60
+        i32.lt_u
+        if (result i32) ;; label = @3
+          local.get $0
+        else
+          i32.const 60
+        end
+        local.tee $3
+        i32.const 2
+        i32.add
+        call $40
+        local.tee $2
+        local.get $8
+        local.get $1
+        i32.add
+        local.get $3
+        call $47
+        drop
+        local.get $2
+        local.get $3
+        i32.add
+        i32.const 0
+        i32.store8
+        local.get $2
+        call $31
+        local.tee $10
+        i32.const 1024
+        i32.load
+        local.tee $9
+        i32.gt_s
+        if ;; label = @3
+          local.get $9
+          i32.const 0
+          i32.gt_s
+          if ;; label = @4
+            block ;; label = @5
+              local.get $2
+              local.get $9
+              i32.add
+              i32.const 0
+              i32.store8
+              local.get $2
+              call $35
+              drop
+              i32.const 1024
+              i32.const 0
+              i32.store
+            end
+          end
+        else
+          block ;; label = @4
+            local.get $2
+            call $35
+            drop
+            i32.const 1024
+            i32.const 1024
+            i32.load
+            local.get $10
+            i32.sub
+            i32.store
+          end
+        end
+        local.get $2
+        call $41
+        local.get $3
+        local.get $1
+        i32.add
+        local.tee $2
+        i32.const -287
+        i32.add
+        local.set $1
+        local.get $2
+        i32.const 287
+        i32.le_u
+        if ;; label = @3
+          local.get $2
+          local.set $1
+        end
+        local.get $0
+        local.get $3
+        i32.sub
+        local.tee $0
+        br_if 0 (;@2;)
+      end
+      local.get $8
+      call $42
+      i32.const 1028
+      i32.load
+      if ;; label = @2
+        block ;; label = @3
+          i32.const 1028
+          local.set $0
+          f32.const 0x0p+0 (;=0;)
+          local.set $11
+          loop $label$19 ;; label = @4
+            local.get $11
+            local.get $0
+            i32.const 4
+            i32.add
+            local.tee $1
+            f32.load
+            f32.add
+            local.tee $11
+            f64.promote_f32
+            local.tee $13
+            f64.const 0x1p+0 (;=1;)
+            f64.lt
+            if (result f64) ;; label = @5
+              local.get $13
+            else
+              f64.const 0x1p+0 (;=1;)
+            end
+            f32.demote_f64
+            local.set $12
+            local.get $1
+            local.get $12
+            f32.store
+            local.get $0
+            local.get $12
+            f32.const 0x1p+9 (;=512;)
+            f32.mul
+            i32.trunc_f32_s
+            i32.store offset=8
+            local.get $0
+            i32.const 12
+            i32.add
+            local.tee $0
+            i32.load
+            br_if 0 (;@4;)
+            i32.const 0
+            local.set $1
+            i32.const 1028
+            local.set $0
+          end
+        end
+      else
+        block ;; label = @3
+          i32.const 0
+          local.set $1
+          i32.const 1028
+          local.set $0
+        end
+      end
+      loop $label$23 ;; label = @2
+        loop $label$24 ;; label = @3
+          local.get $0
+          i32.const 12
+          i32.add
+          local.set $3
+          local.get $1
+          local.get $0
+          i32.load offset=8
+          local.tee $2
+          i32.gt_u
+          local.get $2
+          i32.const 0
+          i32.ne
+          i32.and
+          if ;; label = @4
+            block ;; label = @5
+              local.get $3
+              local.set $0
+              br 2 (;@3;)
+            end
+          end
+        end
+        local.get $6
+        local.get $1
+        i32.const 2
+        i32.shl
+        i32.add
+        local.get $0
+        i32.store
+        local.get $1
+        i32.const 1
+        i32.add
+        local.tee $1
+        i32.const 513
+        i32.ne
+        br_if 0 (;@2;)
+      end
+      local.get $6
+      i32.const 2116
+      i32.add
+      i32.const 0
+      i32.store
+      local.get $4
+      i32.const 3
+      i32.mul
+      local.set $0
+      loop $label$26 ;; label = @2
+        local.get $6
+        local.get $0
+        i32.const 60
+        i32.lt_u
+        if (result i32) ;; label = @3
+          local.get $0
+        else
+          i32.const 60
+        end
+        local.tee $1
+        call $8
+        local.get $0
+        local.get $1
+        i32.sub
+        local.tee $0
+        br_if 0 (;@2;)
+      end
+      i32.const 1220
+      i32.load
+      if ;; label = @2
+        block ;; label = @3
+          i32.const 1220
+          local.set $0
+          f32.const 0x0p+0 (;=0;)
+          local.set $11
+          loop $label$30 ;; label = @4
+            local.get $11
+            local.get $0
+            i32.const 4
+            i32.add
+            local.tee $1
+            f32.load
+            f32.add
+            local.tee $11
+            f64.promote_f32
+            local.tee $13
+            f64.const 0x1p+0 (;=1;)
+            f64.lt
+            if (result f64) ;; label = @5
+              local.get $13
+            else
+              f64.const 0x1p+0 (;=1;)
+            end
+            f32.demote_f64
+            local.set $12
+            local.get $1
+            local.get $12
+            f32.store
+            local.get $0
+            local.get $12
+            f32.const 0x1p+9 (;=512;)
+            f32.mul
+            i32.trunc_f32_s
+            i32.store offset=8
+            local.get $0
+            i32.const 12
+            i32.add
+            local.tee $0
+            i32.load
+            br_if 0 (;@4;)
+            i32.const 0
+            local.set $1
+            i32.const 1220
+            local.set $0
+          end
+        end
+      else
+        block ;; label = @3
+          i32.const 0
+          local.set $1
+          i32.const 1220
+          local.set $0
+        end
+      end
+      loop $label$34 ;; label = @2
+        loop $label$35 ;; label = @3
+          local.get $0
+          i32.const 12
+          i32.add
+          local.set $3
+          local.get $1
+          local.get $0
+          i32.load offset=8
+          local.tee $2
+          i32.gt_u
+          local.get $2
+          i32.const 0
+          i32.ne
+          i32.and
+          if ;; label = @4
+            block ;; label = @5
+              local.get $3
+              local.set $0
+              br 2 (;@3;)
+            end
+          end
+        end
+        local.get $7
+        local.get $1
+        i32.const 2
+        i32.shl
+        i32.add
+        local.get $0
+        i32.store
+        local.get $1
+        i32.const 1
+        i32.add
+        local.tee $1
+        i32.const 513
+        i32.ne
+        br_if 0 (;@2;)
+      end
+      local.get $7
+      i32.const 2116
+      i32.add
+      i32.const 0
+      i32.store
+      local.get $4
+      i32.const 5
+      i32.mul
+      local.set $0
+      loop $label$37 ;; label = @2
+        local.get $7
+        local.get $0
+        i32.const 60
+        i32.lt_u
+        if (result i32) ;; label = @3
+          local.get $0
+        else
+          i32.const 60
+        end
+        local.tee $1
+        call $8
+        local.get $0
+        local.get $1
+        i32.sub
+        local.tee $0
+        br_if 0 (;@2;)
+        i32.const 0
+        local.set $0
+      end
+      local.get $5
+      global.set $global$1
+      local.get $0
+    end
+  )
+  (func $8 (;21;) (type $5) (param $0 i32) (param $1 i32)
+    (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 f32)
+    block $label$1 ;; label = @1
+      local.get $1
+      if ;; label = @2
+        block ;; label = @3
+          i32.const 0
+          local.set $3
+          i32.const 1396
+          i32.load
+          local.set $2
+          loop $label$3 ;; label = @4
+            local.get $0
+            local.get $2
+            i32.const 3877
+            i32.mul
+            i32.const 29573
+            i32.add
+            i32.const 139968
+            i32.rem_u
+            local.tee $4
+            f32.convert_i32_u
+            f32.const 0x1.116p+17 (;=139968;)
+            f32.div
+            local.tee $6
+            f32.const 0x1p+9 (;=512;)
+            f32.mul
+            i32.trunc_f32_s
+            i32.const 2
+            i32.shl
+            i32.add
+            i32.load
+            local.set $2
+            loop $label$4 ;; label = @5
+              local.get $2
+              i32.const 12
+              i32.add
+              local.set $5
+              local.get $2
+              f32.load offset=4
+              local.get $6
+              f32.lt
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $5
+                  local.set $2
+                  br 2 (;@5;)
+                end
+              end
+            end
+            local.get $0
+            i32.const 2052
+            i32.add
+            local.get $3
+            i32.add
+            local.get $2
+            i32.load
+            i32.store8
+            local.get $3
+            i32.const 1
+            i32.add
+            local.tee $3
+            local.get $1
+            i32.ne
+            if ;; label = @5
+              block ;; label = @6
+                local.get $4
+                local.set $2
+                br 2 (;@4;)
+              end
+            end
+          end
+          i32.const 1396
+          local.get $4
+          i32.store
+        end
+      end
+      local.get $0
+      i32.const 2052
+      i32.add
+      local.get $1
+      i32.add
+      i32.const 10
+      i32.store8
+      local.get $0
+      i32.const 2052
+      i32.add
+      local.get $1
+      i32.const 1
+      i32.add
+      local.tee $1
+      i32.add
+      i32.const 0
+      i32.store8
+      local.get $0
+      i32.const 2116
+      i32.add
+      local.get $1
+      i32.store
+      local.get $0
+      i32.const 2052
+      i32.add
+      local.tee $1
+      call $31
+      local.tee $3
+      i32.const 1024
+      i32.load
+      local.tee $2
+      i32.le_s
+      if ;; label = @2
+        block ;; label = @3
+          local.get $1
+          call $35
+          drop
+          i32.const 1024
+          i32.const 1024
+          i32.load
+          local.get $3
+          i32.sub
+          i32.store
+          return
+        end
+      end
+      local.get $2
+      i32.const 0
+      i32.le_s
+      if ;; label = @2
+        return
+      end
+      local.get $0
+      i32.const 2052
+      i32.add
+      local.get $2
+      i32.add
+      i32.const 0
+      i32.store8
+      local.get $1
+      call $35
+      drop
+      local.get $0
+      i32.const 2052
+      i32.add
+      i32.const 1024
+      i32.load
+      i32.add
+      i32.const 122
+      i32.store8
+      i32.const 1024
+      i32.const 0
+      i32.store
+    end
+  )
+  (func $9 (;22;) (type $2) (param $0 i32) (result i32)
+    (local $1 i32) (local $2 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $1
+      global.get $global$1
+      i32.const 16
+      i32.add
+      global.set $global$1
+      local.get $1
+      local.tee $2
+      local.get $0
+      i32.load offset=60
+      i32.store
+      i32.const 6
+      local.get $2
+      call $fimport$10
+      call $11
+      local.set $0
+      local.get $1
+      global.set $global$1
+      local.get $0
+    end
+  )
+  (func $10 (;23;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32) (local $4 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $4
+      global.get $global$1
+      i32.const 32
+      i32.add
+      global.set $global$1
+      local.get $4
+      local.tee $3
+      local.get $0
+      i32.load offset=60
+      i32.store
+      local.get $3
+      i32.const 0
+      i32.store offset=4
+      local.get $3
+      local.get $1
+      i32.store offset=8
+      local.get $3
+      local.get $4
+      i32.const 20
+      i32.add
+      local.tee $0
+      i32.store offset=12
+      local.get $3
+      local.get $2
+      i32.store offset=16
+      i32.const 140
+      local.get $3
+      call $fimport$14
+      call $11
+      i32.const 0
+      i32.lt_s
+      if (result i32) ;; label = @2
+        block (result i32) ;; label = @3
+          local.get $0
+          i32.const -1
+          i32.store
+          i32.const -1
+        end
+      else
+        local.get $0
+        i32.load
+      end
+      local.set $0
+      local.get $4
+      global.set $global$1
+      local.get $0
+    end
+  )
+  (func $11 (;24;) (type $2) (param $0 i32) (result i32)
+    local.get $0
+    i32.const -4096
+    i32.gt_u
+    if (result i32) ;; label = @1
+      block (result i32) ;; label = @2
+        call $12
+        i32.const 0
+        local.get $0
+        i32.sub
+        i32.store
+        i32.const -1
+      end
+    else
+      local.get $0
+    end
+  )
+  (func $12 (;25;) (type $4) (result i32)
+    i32.const 4172
+  )
+  (func $13 (;26;) (type $3) (param $0 i32)
+    nop
+  )
+  (func $14 (;27;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32) (local $4 i32) (local $5 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $4
+      global.get $global$1
+      i32.const 80
+      i32.add
+      global.set $global$1
+      local.get $4
+      local.set $3
+      local.get $4
+      i32.const 12
+      i32.add
+      local.set $5
+      local.get $0
+      i32.const 3
+      i32.store offset=36
+      local.get $0
+      i32.load
+      i32.const 64
+      i32.and
+      i32.eqz
+      if ;; label = @2
+        block ;; label = @3
+          local.get $3
+          local.get $0
+          i32.load offset=60
+          i32.store
+          local.get $3
+          i32.const 21505
+          i32.store offset=4
+          local.get $3
+          local.get $5
+          i32.store offset=8
+          i32.const 54
+          local.get $3
+          call $fimport$13
+          if ;; label = @4
+            local.get $0
+            i32.const -1
+            i32.store8 offset=75
+          end
+        end
+      end
+      local.get $0
+      local.get $1
+      local.get $2
+      call $15
+      local.set $0
+      local.get $4
+      global.set $global$1
+      local.get $0
+    end
+  )
+  (func $15 (;28;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $8
+      global.get $global$1
+      i32.const 48
+      i32.add
+      global.set $global$1
+      local.get $8
+      i32.const 16
+      i32.add
+      local.set $9
+      local.get $8
+      local.set $10
+      local.get $8
+      i32.const 32
+      i32.add
+      local.tee $3
+      local.get $0
+      i32.const 28
+      i32.add
+      local.tee $6
+      i32.load
+      local.tee $4
+      i32.store
+      local.get $3
+      local.get $0
+      i32.const 20
+      i32.add
+      local.tee $11
+      i32.load
+      local.get $4
+      i32.sub
+      local.tee $5
+      i32.store offset=4
+      local.get $3
+      local.get $1
+      i32.store offset=8
+      local.get $3
+      local.get $2
+      i32.store offset=12
+      local.get $0
+      i32.const 60
+      i32.add
+      local.set $13
+      local.get $0
+      i32.const 44
+      i32.add
+      local.set $14
+      local.get $3
+      local.set $1
+      i32.const 2
+      local.set $4
+      local.get $5
+      local.get $2
+      i32.add
+      local.set $12
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          block $label$4 ;; label = @4
+            loop $label$5 ;; label = @5
+              i32.const 4128
+              i32.load
+              if ;; label = @6
+                block ;; label = @7
+                  i32.const 1
+                  local.get $0
+                  call $fimport$9
+                  local.get $10
+                  local.get $13
+                  i32.load
+                  i32.store
+                  local.get $10
+                  local.get $1
+                  i32.store offset=4
+                  local.get $10
+                  local.get $4
+                  i32.store offset=8
+                  i32.const 146
+                  local.get $10
+                  call $fimport$15
+                  call $11
+                  local.set $3
+                  i32.const 0
+                  call $fimport$7
+                end
+              else
+                block ;; label = @7
+                  local.get $9
+                  local.get $13
+                  i32.load
+                  i32.store
+                  local.get $9
+                  local.get $1
+                  i32.store offset=4
+                  local.get $9
+                  local.get $4
+                  i32.store offset=8
+                  i32.const 146
+                  local.get $9
+                  call $fimport$15
+                  call $11
+                  local.set $3
+                end
+              end
+              local.get $12
+              local.get $3
+              i32.eq
+              br_if 1 (;@4;)
+              local.get $3
+              i32.const 0
+              i32.lt_s
+              br_if 2 (;@3;)
+              local.get $3
+              local.get $1
+              i32.load offset=4
+              local.tee $5
+              i32.gt_u
+              if (result i32) ;; label = @6
+                block (result i32) ;; label = @7
+                  local.get $6
+                  local.get $14
+                  i32.load
+                  local.tee $7
+                  i32.store
+                  local.get $11
+                  local.get $7
+                  i32.store
+                  local.get $1
+                  i32.load offset=12
+                  local.set $7
+                  local.get $1
+                  i32.const 8
+                  i32.add
+                  local.set $1
+                  local.get $4
+                  i32.const -1
+                  i32.add
+                  local.set $4
+                  local.get $3
+                  local.get $5
+                  i32.sub
+                end
+              else
+                local.get $4
+                i32.const 2
+                i32.eq
+                if (result i32) ;; label = @7
+                  block (result i32) ;; label = @8
+                    local.get $6
+                    local.get $6
+                    i32.load
+                    local.get $3
+                    i32.add
+                    i32.store
+                    local.get $5
+                    local.set $7
+                    i32.const 2
+                    local.set $4
+                    local.get $3
+                  end
+                else
+                  block (result i32) ;; label = @8
+                    local.get $5
+                    local.set $7
+                    local.get $3
+                  end
+                end
+              end
+              local.set $5
+              local.get $1
+              local.get $1
+              i32.load
+              local.get $5
+              i32.add
+              i32.store
+              local.get $1
+              local.get $7
+              local.get $5
+              i32.sub
+              i32.store offset=4
+              local.get $12
+              local.get $3
+              i32.sub
+              local.set $12
+              br 0 (;@5;)
+            end
+          end
+          local.get $0
+          local.get $14
+          i32.load
+          local.tee $1
+          local.get $0
+          i32.load offset=48
+          i32.add
+          i32.store offset=16
+          local.get $6
+          local.get $1
+          i32.store
+          local.get $11
+          local.get $1
+          i32.store
+          br 1 (;@2;)
+        end
+        local.get $0
+        i32.const 0
+        i32.store offset=16
+        local.get $6
+        i32.const 0
+        i32.store
+        local.get $11
+        i32.const 0
+        i32.store
+        local.get $0
+        local.get $0
+        i32.load
+        i32.const 32
+        i32.or
+        i32.store
+        local.get $4
+        i32.const 2
+        i32.eq
+        if (result i32) ;; label = @3
+          i32.const 0
+        else
+          local.get $2
+          local.get $1
+          i32.load offset=4
+          i32.sub
+        end
+        local.set $2
+      end
+      local.get $8
+      global.set $global$1
+      local.get $2
+    end
+  )
+  (func $16 (;29;) (type $3) (param $0 i32)
+    local.get $0
+    i32.load offset=68
+    i32.eqz
+    if ;; label = @1
+      local.get $0
+      call $13
+    end
+  )
+  (func $17 (;30;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32) (local $4 i32) (local $5 i32)
+    block $label$1 (result i32) ;; label = @1
+      local.get $1
+      i32.const 255
+      i32.and
+      local.set $5
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          block $label$4 ;; label = @4
+            local.get $2
+            i32.const 0
+            i32.ne
+            local.tee $4
+            local.get $0
+            i32.const 3
+            i32.and
+            i32.const 0
+            i32.ne
+            i32.and
+            if ;; label = @5
+              block ;; label = @6
+                local.get $1
+                i32.const 255
+                i32.and
+                local.set $4
+                local.get $2
+                local.set $3
+                local.get $0
+                local.set $2
+                loop $label$6 ;; label = @7
+                  local.get $2
+                  i32.load8_s
+                  local.get $4
+                  i32.const 24
+                  i32.shl
+                  i32.const 24
+                  i32.shr_s
+                  i32.eq
+                  if ;; label = @8
+                    block ;; label = @9
+                      local.get $3
+                      local.set $0
+                      br 6 (;@3;)
+                    end
+                  end
+                  local.get $3
+                  i32.const -1
+                  i32.add
+                  local.tee $3
+                  i32.const 0
+                  i32.ne
+                  local.tee $0
+                  local.get $2
+                  i32.const 1
+                  i32.add
+                  local.tee $2
+                  i32.const 3
+                  i32.and
+                  i32.const 0
+                  i32.ne
+                  i32.and
+                  br_if 0 (;@7;)
+                  br 3 (;@4;)
+                end
+              end
+            else
+              block ;; label = @6
+                local.get $2
+                local.set $3
+                local.get $0
+                local.set $2
+                local.get $4
+                local.set $0
+              end
+            end
+          end
+          local.get $0
+          if ;; label = @4
+            block ;; label = @5
+              local.get $3
+              local.set $0
+              br 2 (;@3;)
+            end
+          else
+            i32.const 0
+            local.set $0
+          end
+          br 1 (;@2;)
+        end
+        local.get $2
+        i32.load8_s
+        local.get $1
+        i32.const 255
+        i32.and
+        local.tee $1
+        i32.const 24
+        i32.shl
+        i32.const 24
+        i32.shr_s
+        i32.ne
+        if ;; label = @3
+          block ;; label = @4
+            local.get $5
+            i32.const 16843009
+            i32.mul
+            local.set $3
+            block $label$12 ;; label = @5
+              block $label$13 ;; label = @6
+                local.get $0
+                i32.const 3
+                i32.le_u
+                br_if 0 (;@6;)
+                loop $label$14 ;; label = @7
+                  local.get $2
+                  i32.load
+                  local.get $3
+                  i32.xor
+                  local.tee $4
+                  i32.const -2139062144
+                  i32.and
+                  i32.const -2139062144
+                  i32.xor
+                  local.get $4
+                  i32.const -16843009
+                  i32.add
+                  i32.and
+                  i32.eqz
+                  if ;; label = @8
+                    block ;; label = @9
+                      local.get $2
+                      i32.const 4
+                      i32.add
+                      local.set $2
+                      local.get $0
+                      i32.const -4
+                      i32.add
+                      local.tee $0
+                      i32.const 3
+                      i32.gt_u
+                      br_if 2 (;@7;)
+                      br 3 (;@6;)
+                    end
+                  end
+                end
+                br 1 (;@5;)
+              end
+              local.get $0
+              i32.eqz
+              if ;; label = @6
+                block ;; label = @7
+                  i32.const 0
+                  local.set $0
+                  br 5 (;@2;)
+                end
+              end
+            end
+            loop $label$17 ;; label = @5
+              local.get $2
+              i32.load8_s
+              local.get $1
+              i32.const 24
+              i32.shl
+              i32.const 24
+              i32.shr_s
+              i32.eq
+              br_if 3 (;@2;)
+              local.get $2
+              i32.const 1
+              i32.add
+              local.set $2
+              local.get $0
+              i32.const -1
+              i32.add
+              local.tee $0
+              br_if 0 (;@5;)
+              i32.const 0
+              local.set $0
+            end
+          end
+        end
+      end
+      local.get $0
+      if (result i32) ;; label = @2
+        local.get $2
+      else
+        i32.const 0
+      end
+    end
+  )
+  (func $18 (;31;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $4
+      global.get $global$1
+      i32.const 224
+      i32.add
+      global.set $global$1
+      local.get $4
+      i32.const 136
+      i32.add
+      local.set $5
+      local.get $4
+      i32.const 80
+      i32.add
+      local.tee $3
+      i64.const 0
+      i64.store align=4
+      local.get $3
+      i64.const 0
+      i64.store offset=8 align=4
+      local.get $3
+      i64.const 0
+      i64.store offset=16 align=4
+      local.get $3
+      i64.const 0
+      i64.store offset=24 align=4
+      local.get $3
+      i64.const 0
+      i64.store offset=32 align=4
+      local.get $4
+      i32.const 120
+      i32.add
+      local.tee $6
+      local.get $2
+      i32.load
+      i32.store
+      i32.const 0
+      local.get $1
+      local.get $6
+      local.get $4
+      local.tee $2
+      local.get $3
+      call $19
+      i32.const 0
+      i32.lt_s
+      if ;; label = @2
+        i32.const -1
+        local.set $1
+      else
+        block ;; label = @3
+          local.get $0
+          i32.load offset=76
+          i32.const -1
+          i32.gt_s
+          if (result i32) ;; label = @4
+            local.get $0
+            call $20
+          else
+            i32.const 0
+          end
+          local.set $12
+          local.get $0
+          i32.load
+          local.set $7
+          local.get $0
+          i32.load8_s offset=74
+          i32.const 1
+          i32.lt_s
+          if ;; label = @4
+            local.get $0
+            local.get $7
+            i32.const -33
+            i32.and
+            i32.store
+          end
+          local.get $0
+          i32.const 48
+          i32.add
+          local.tee $8
+          i32.load
+          if ;; label = @4
+            local.get $0
+            local.get $1
+            local.get $6
+            local.get $2
+            local.get $3
+            call $19
+            local.set $1
+          else
+            block ;; label = @5
+              local.get $0
+              i32.const 44
+              i32.add
+              local.tee $9
+              i32.load
+              local.set $10
+              local.get $9
+              local.get $5
+              i32.store
+              local.get $0
+              i32.const 28
+              i32.add
+              local.tee $13
+              local.get $5
+              i32.store
+              local.get $0
+              i32.const 20
+              i32.add
+              local.tee $11
+              local.get $5
+              i32.store
+              local.get $8
+              i32.const 80
+              i32.store
+              local.get $0
+              i32.const 16
+              i32.add
+              local.tee $14
+              local.get $5
+              i32.const 80
+              i32.add
+              i32.store
+              local.get $0
+              local.get $1
+              local.get $6
+              local.get $2
+              local.get $3
+              call $19
+              local.set $1
+              local.get $10
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $0
+                  i32.const 0
+                  i32.const 0
+                  local.get $0
+                  i32.load offset=36
+                  i32.const 3
+                  i32.and
+                  i32.const 2
+                  i32.add
+                  call_indirect (type $0)
+                  drop
+                  local.get $11
+                  i32.load
+                  i32.eqz
+                  if ;; label = @8
+                    i32.const -1
+                    local.set $1
+                  end
+                  local.get $9
+                  local.get $10
+                  i32.store
+                  local.get $8
+                  i32.const 0
+                  i32.store
+                  local.get $14
+                  i32.const 0
+                  i32.store
+                  local.get $13
+                  i32.const 0
+                  i32.store
+                  local.get $11
+                  i32.const 0
+                  i32.store
+                end
+              end
+            end
+          end
+          local.get $0
+          local.get $0
+          i32.load
+          local.tee $2
+          local.get $7
+          i32.const 32
+          i32.and
+          i32.or
+          i32.store
+          local.get $12
+          if ;; label = @4
+            local.get $0
+            call $13
+          end
+          local.get $2
+          i32.const 32
+          i32.and
+          if ;; label = @4
+            i32.const -1
+            local.set $1
+          end
+        end
+      end
+      local.get $4
+      global.set $global$1
+      local.get $1
+    end
+  )
+  (func $19 (;32;) (type $7) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32) (result i32)
+    (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32) (local $15 i32) (local $16 i32) (local $17 i32) (local $18 i32) (local $19 i32) (local $20 i32) (local $21 i32) (local $22 i32) (local $23 i32) (local $24 i32) (local $25 i32) (local $26 i32) (local $27 i32) (local $28 i32) (local $29 i32) (local $30 i32) (local $31 i32) (local $32 i32) (local $33 i32) (local $34 i32) (local $35 i32) (local $36 i32) (local $37 i32) (local $38 i32) (local $39 i32) (local $40 i32) (local $41 i32) (local $42 i32) (local $43 i32) (local $44 i32) (local $45 i32) (local $46 i32) (local $47 i32) (local $48 i32) (local $49 i32) (local $50 i64) (local $51 i64) (local $52 f64) (local $53 f64)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $23
+      global.get $global$1
+      i32.const 624
+      i32.add
+      global.set $global$1
+      local.get $23
+      i32.const 16
+      i32.add
+      local.set $20
+      local.get $23
+      local.set $16
+      local.get $23
+      i32.const 528
+      i32.add
+      local.set $36
+      local.get $0
+      i32.const 0
+      i32.ne
+      local.set $30
+      local.get $23
+      i32.const 536
+      i32.add
+      local.tee $17
+      i32.const 40
+      i32.add
+      local.tee $21
+      local.set $38
+      local.get $17
+      i32.const 39
+      i32.add
+      local.set $39
+      local.get $23
+      i32.const 8
+      i32.add
+      local.tee $37
+      i32.const 4
+      i32.add
+      local.set $42
+      i32.const 0
+      local.get $23
+      i32.const 588
+      i32.add
+      local.tee $19
+      local.tee $27
+      i32.sub
+      local.set $43
+      local.get $23
+      i32.const 576
+      i32.add
+      local.tee $17
+      i32.const 12
+      i32.add
+      local.set $33
+      local.get $17
+      i32.const 11
+      i32.add
+      local.set $40
+      local.get $33
+      local.tee $28
+      local.get $27
+      i32.sub
+      local.set $44
+      i32.const -2
+      local.get $27
+      i32.sub
+      local.set $45
+      local.get $28
+      i32.const 2
+      i32.add
+      local.set $46
+      local.get $23
+      i32.const 24
+      i32.add
+      local.tee $47
+      i32.const 288
+      i32.add
+      local.set $48
+      local.get $19
+      i32.const 9
+      i32.add
+      local.tee $31
+      local.set $41
+      local.get $19
+      i32.const 8
+      i32.add
+      local.set $34
+      i32.const 0
+      local.set $15
+      i32.const 0
+      local.set $10
+      i32.const 0
+      local.set $17
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          loop $label$4 ;; label = @4
+            block $label$5 ;; label = @5
+              local.get $15
+              i32.const -1
+              i32.gt_s
+              if ;; label = @6
+                local.get $10
+                i32.const 2147483647
+                local.get $15
+                i32.sub
+                i32.gt_s
+                if (result i32) ;; label = @7
+                  block (result i32) ;; label = @8
+                    call $12
+                    i32.const 75
+                    i32.store
+                    i32.const -1
+                  end
+                else
+                  local.get $10
+                  local.get $15
+                  i32.add
+                end
+                local.set $15
+              end
+              local.get $1
+              i32.load8_s
+              local.tee $5
+              i32.const 24
+              i32.shl
+              i32.const 24
+              i32.shr_s
+              i32.eqz
+              br_if 2 (;@3;)
+              local.get $1
+              local.set $11
+              block $label$9 ;; label = @6
+                block $label$10 ;; label = @7
+                  loop $label$11 ;; label = @8
+                    block $label$12 ;; label = @9
+                      block $label$13 ;; label = @10
+                        block $label$14 ;; label = @11
+                          block $label$15 ;; label = @12
+                            local.get $5
+                            i32.const 24
+                            i32.shl
+                            i32.const 24
+                            i32.shr_s
+                            i32.const 0
+                            i32.sub
+                            br_table 1 (;@11;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 0 (;@12;) 2 (;@10;)
+                          end
+                          local.get $11
+                          local.set $5
+                          br 4 (;@7;)
+                        end
+                        local.get $11
+                        local.set $5
+                        br 1 (;@9;)
+                      end
+                      local.get $11
+                      i32.const 1
+                      i32.add
+                      local.tee $11
+                      i32.load8_s
+                      local.set $5
+                      br 1 (;@8;)
+                    end
+                  end
+                  br 1 (;@6;)
+                end
+                loop $label$16 ;; label = @7
+                  local.get $5
+                  i32.load8_s offset=1
+                  i32.const 37
+                  i32.ne
+                  br_if 1 (;@6;)
+                  local.get $11
+                  i32.const 1
+                  i32.add
+                  local.set $11
+                  local.get $5
+                  i32.const 2
+                  i32.add
+                  local.tee $5
+                  i32.load8_s
+                  i32.const 37
+                  i32.eq
+                  br_if 0 (;@7;)
+                end
+              end
+              local.get $11
+              local.get $1
+              i32.sub
+              local.set $10
+              local.get $30
+              if ;; label = @6
+                local.get $0
+                i32.load
+                i32.const 32
+                i32.and
+                i32.eqz
+                if ;; label = @7
+                  local.get $1
+                  local.get $10
+                  local.get $0
+                  call $21
+                  drop
+                end
+              end
+              local.get $10
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $5
+                  local.set $1
+                  br 3 (;@4;)
+                end
+              end
+              local.get $5
+              i32.const 1
+              i32.add
+              local.tee $11
+              i32.load8_s
+              local.tee $10
+              i32.const 24
+              i32.shl
+              i32.const 24
+              i32.shr_s
+              i32.const -48
+              i32.add
+              local.tee $9
+              i32.const 10
+              i32.lt_u
+              if (result i32) ;; label = @6
+                block (result i32) ;; label = @7
+                  local.get $5
+                  i32.const 3
+                  i32.add
+                  local.set $10
+                  local.get $5
+                  i32.load8_s offset=2
+                  i32.const 36
+                  i32.eq
+                  local.tee $12
+                  if ;; label = @8
+                    local.get $10
+                    local.set $11
+                  end
+                  local.get $12
+                  if ;; label = @8
+                    i32.const 1
+                    local.set $17
+                  end
+                  local.get $11
+                  i32.load8_s
+                  local.set $5
+                  local.get $12
+                  i32.eqz
+                  if ;; label = @8
+                    i32.const -1
+                    local.set $9
+                  end
+                  local.get $17
+                end
+              else
+                block (result i32) ;; label = @7
+                  local.get $10
+                  local.set $5
+                  i32.const -1
+                  local.set $9
+                  local.get $17
+                end
+              end
+              local.set $10
+              block $label$25 ;; label = @6
+                local.get $5
+                i32.const 24
+                i32.shl
+                i32.const 24
+                i32.shr_s
+                i32.const -32
+                i32.add
+                local.tee $12
+                i32.const 32
+                i32.lt_u
+                if ;; label = @7
+                  block ;; label = @8
+                    i32.const 0
+                    local.set $17
+                    loop $label$27 ;; label = @9
+                      i32.const 1
+                      local.get $12
+                      i32.shl
+                      i32.const 75913
+                      i32.and
+                      i32.eqz
+                      br_if 3 (;@6;)
+                      i32.const 1
+                      local.get $5
+                      i32.const 24
+                      i32.shl
+                      i32.const 24
+                      i32.shr_s
+                      i32.const -32
+                      i32.add
+                      i32.shl
+                      local.get $17
+                      i32.or
+                      local.set $17
+                      local.get $11
+                      i32.const 1
+                      i32.add
+                      local.tee $11
+                      i32.load8_s
+                      local.tee $5
+                      i32.const 24
+                      i32.shl
+                      i32.const 24
+                      i32.shr_s
+                      i32.const -32
+                      i32.add
+                      local.tee $12
+                      i32.const 32
+                      i32.lt_u
+                      br_if 0 (;@9;)
+                    end
+                  end
+                else
+                  i32.const 0
+                  local.set $17
+                end
+              end
+              block $label$29 ;; label = @6
+                local.get $5
+                i32.const 24
+                i32.shl
+                i32.const 24
+                i32.shr_s
+                i32.const 42
+                i32.eq
+                if ;; label = @7
+                  block ;; label = @8
+                    block $label$31 (result i32) ;; label = @9
+                      block $label$32 ;; label = @10
+                        local.get $11
+                        i32.const 1
+                        i32.add
+                        local.tee $7
+                        i32.load8_s
+                        local.tee $5
+                        i32.const 24
+                        i32.shl
+                        i32.const 24
+                        i32.shr_s
+                        i32.const -48
+                        i32.add
+                        local.tee $12
+                        i32.const 10
+                        i32.ge_u
+                        br_if 0 (;@10;)
+                        local.get $11
+                        i32.load8_s offset=2
+                        i32.const 36
+                        i32.ne
+                        br_if 0 (;@10;)
+                        local.get $4
+                        local.get $12
+                        i32.const 2
+                        i32.shl
+                        i32.add
+                        i32.const 10
+                        i32.store
+                        i32.const 1
+                        local.set $8
+                        local.get $3
+                        local.get $7
+                        i32.load8_s
+                        i32.const -48
+                        i32.add
+                        i32.const 3
+                        i32.shl
+                        i32.add
+                        i64.load
+                        i32.wrap_i64
+                        local.set $10
+                        local.get $11
+                        i32.const 3
+                        i32.add
+                        br 1 (;@9;)
+                      end
+                      local.get $10
+                      if ;; label = @10
+                        block ;; label = @11
+                          i32.const -1
+                          local.set $15
+                          br 6 (;@5;)
+                        end
+                      end
+                      local.get $30
+                      i32.eqz
+                      if ;; label = @10
+                        block ;; label = @11
+                          local.get $17
+                          local.set $12
+                          i32.const 0
+                          local.set $17
+                          local.get $7
+                          local.set $11
+                          i32.const 0
+                          local.set $10
+                          br 5 (;@6;)
+                        end
+                      end
+                      local.get $2
+                      i32.load
+                      i32.const 3
+                      i32.add
+                      i32.const -4
+                      i32.and
+                      local.tee $11
+                      i32.load
+                      local.set $10
+                      local.get $2
+                      local.get $11
+                      i32.const 4
+                      i32.add
+                      i32.store
+                      i32.const 0
+                      local.set $8
+                      local.get $7
+                    end
+                    local.set $11
+                    local.get $17
+                    i32.const 8192
+                    i32.or
+                    local.set $12
+                    i32.const 0
+                    local.get $10
+                    i32.sub
+                    local.set $7
+                    local.get $11
+                    i32.load8_s
+                    local.set $5
+                    local.get $10
+                    i32.const 0
+                    i32.lt_s
+                    local.tee $6
+                    i32.eqz
+                    if ;; label = @9
+                      local.get $17
+                      local.set $12
+                    end
+                    local.get $8
+                    local.set $17
+                    local.get $6
+                    if ;; label = @9
+                      local.get $7
+                      local.set $10
+                    end
+                  end
+                else
+                  local.get $5
+                  i32.const 24
+                  i32.shl
+                  i32.const 24
+                  i32.shr_s
+                  i32.const -48
+                  i32.add
+                  local.tee $12
+                  i32.const 10
+                  i32.lt_u
+                  if ;; label = @8
+                    block ;; label = @9
+                      i32.const 0
+                      local.set $7
+                      local.get $12
+                      local.set $5
+                      loop $label$39 ;; label = @10
+                        local.get $7
+                        i32.const 10
+                        i32.mul
+                        local.get $5
+                        i32.add
+                        local.set $7
+                        local.get $11
+                        i32.const 1
+                        i32.add
+                        local.tee $11
+                        i32.load8_s
+                        local.tee $12
+                        i32.const 24
+                        i32.shl
+                        i32.const 24
+                        i32.shr_s
+                        i32.const -48
+                        i32.add
+                        local.tee $5
+                        i32.const 10
+                        i32.lt_u
+                        br_if 0 (;@10;)
+                      end
+                      local.get $7
+                      i32.const 0
+                      i32.lt_s
+                      if ;; label = @10
+                        block ;; label = @11
+                          i32.const -1
+                          local.set $15
+                          br 6 (;@5;)
+                        end
+                      else
+                        block ;; label = @11
+                          local.get $12
+                          local.set $5
+                          local.get $17
+                          local.set $12
+                          local.get $10
+                          local.set $17
+                          local.get $7
+                          local.set $10
+                        end
+                      end
+                    end
+                  else
+                    block ;; label = @9
+                      local.get $17
+                      local.set $12
+                      local.get $10
+                      local.set $17
+                      i32.const 0
+                      local.set $10
+                    end
+                  end
+                end
+              end
+              block $label$43 ;; label = @6
+                local.get $5
+                i32.const 24
+                i32.shl
+                i32.const 24
+                i32.shr_s
+                i32.const 46
+                i32.eq
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $11
+                    i32.const 1
+                    i32.add
+                    local.tee $7
+                    i32.load8_s
+                    local.tee $5
+                    i32.const 24
+                    i32.shl
+                    i32.const 24
+                    i32.shr_s
+                    i32.const 42
+                    i32.ne
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $5
+                        i32.const 24
+                        i32.shl
+                        i32.const 24
+                        i32.shr_s
+                        i32.const -48
+                        i32.add
+                        local.tee $5
+                        i32.const 10
+                        i32.lt_u
+                        if ;; label = @11
+                          block ;; label = @12
+                            local.get $7
+                            local.set $11
+                            i32.const 0
+                            local.set $7
+                          end
+                        else
+                          block ;; label = @12
+                            i32.const 0
+                            local.set $5
+                            local.get $7
+                            local.set $11
+                            br 6 (;@6;)
+                          end
+                        end
+                        loop $label$48 ;; label = @11
+                          local.get $7
+                          i32.const 10
+                          i32.mul
+                          local.get $5
+                          i32.add
+                          local.set $5
+                          local.get $11
+                          i32.const 1
+                          i32.add
+                          local.tee $11
+                          i32.load8_s
+                          i32.const -48
+                          i32.add
+                          local.tee $8
+                          i32.const 10
+                          i32.ge_u
+                          br_if 5 (;@6;)
+                          local.get $5
+                          local.set $7
+                          local.get $8
+                          local.set $5
+                          br 0 (;@11;)
+                        end
+                      end
+                    end
+                    local.get $11
+                    i32.const 2
+                    i32.add
+                    local.tee $7
+                    i32.load8_s
+                    i32.const -48
+                    i32.add
+                    local.tee $5
+                    i32.const 10
+                    i32.lt_u
+                    if ;; label = @9
+                      local.get $11
+                      i32.load8_s offset=3
+                      i32.const 36
+                      i32.eq
+                      if ;; label = @10
+                        block ;; label = @11
+                          local.get $4
+                          local.get $5
+                          i32.const 2
+                          i32.shl
+                          i32.add
+                          i32.const 10
+                          i32.store
+                          local.get $3
+                          local.get $7
+                          i32.load8_s
+                          i32.const -48
+                          i32.add
+                          i32.const 3
+                          i32.shl
+                          i32.add
+                          i64.load
+                          i32.wrap_i64
+                          local.set $5
+                          local.get $11
+                          i32.const 4
+                          i32.add
+                          local.set $11
+                          br 5 (;@6;)
+                        end
+                      end
+                    end
+                    local.get $17
+                    if ;; label = @9
+                      block ;; label = @10
+                        i32.const -1
+                        local.set $15
+                        br 5 (;@5;)
+                      end
+                    end
+                    local.get $30
+                    if (result i32) ;; label = @9
+                      block (result i32) ;; label = @10
+                        local.get $2
+                        i32.load
+                        i32.const 3
+                        i32.add
+                        i32.const -4
+                        i32.and
+                        local.tee $11
+                        i32.load
+                        local.set $5
+                        local.get $2
+                        local.get $11
+                        i32.const 4
+                        i32.add
+                        i32.store
+                        local.get $7
+                      end
+                    else
+                      block (result i32) ;; label = @10
+                        i32.const 0
+                        local.set $5
+                        local.get $7
+                      end
+                    end
+                    local.set $11
+                  end
+                else
+                  i32.const -1
+                  local.set $5
+                end
+              end
+              local.get $11
+              local.set $7
+              i32.const 0
+              local.set $8
+              loop $label$55 ;; label = @6
+                local.get $7
+                i32.load8_s
+                i32.const -65
+                i32.add
+                local.tee $6
+                i32.const 57
+                i32.gt_u
+                if ;; label = @7
+                  block ;; label = @8
+                    i32.const -1
+                    local.set $15
+                    br 3 (;@5;)
+                  end
+                end
+                local.get $7
+                i32.const 1
+                i32.add
+                local.set $11
+                local.get $8
+                i32.const 58
+                i32.mul
+                i32.const 1699
+                i32.add
+                local.get $6
+                i32.add
+                i32.load8_s
+                local.tee $13
+                i32.const 255
+                i32.and
+                local.tee $6
+                i32.const -1
+                i32.add
+                i32.const 8
+                i32.lt_u
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $11
+                    local.set $7
+                    local.get $6
+                    local.set $8
+                    br 2 (;@6;)
+                  end
+                end
+              end
+              local.get $13
+              i32.const 24
+              i32.shl
+              i32.const 24
+              i32.shr_s
+              i32.eqz
+              if ;; label = @6
+                block ;; label = @7
+                  i32.const -1
+                  local.set $15
+                  br 2 (;@5;)
+                end
+              end
+              local.get $9
+              i32.const -1
+              i32.gt_s
+              local.set $14
+              block $label$59 ;; label = @6
+                block $label$60 ;; label = @7
+                  local.get $13
+                  i32.const 24
+                  i32.shl
+                  i32.const 24
+                  i32.shr_s
+                  i32.const 19
+                  i32.eq
+                  if ;; label = @8
+                    local.get $14
+                    if ;; label = @9
+                      block ;; label = @10
+                        i32.const -1
+                        local.set $15
+                        br 5 (;@5;)
+                      end
+                    else
+                      br 2 (;@7;)
+                    end
+                  else
+                    block ;; label = @9
+                      local.get $14
+                      if ;; label = @10
+                        block ;; label = @11
+                          local.get $4
+                          local.get $9
+                          i32.const 2
+                          i32.shl
+                          i32.add
+                          local.get $6
+                          i32.store
+                          local.get $16
+                          local.get $3
+                          local.get $9
+                          i32.const 3
+                          i32.shl
+                          i32.add
+                          i64.load
+                          i64.store
+                          br 4 (;@7;)
+                        end
+                      end
+                      local.get $30
+                      i32.eqz
+                      if ;; label = @10
+                        block ;; label = @11
+                          i32.const 0
+                          local.set $15
+                          br 6 (;@5;)
+                        end
+                      end
+                      local.get $16
+                      local.get $6
+                      local.get $2
+                      call $22
+                    end
+                  end
+                  br 1 (;@6;)
+                end
+                local.get $30
+                i32.eqz
+                if ;; label = @7
+                  block ;; label = @8
+                    i32.const 0
+                    local.set $10
+                    local.get $11
+                    local.set $1
+                    br 4 (;@4;)
+                  end
+                end
+              end
+              local.get $7
+              i32.load8_s
+              local.tee $7
+              i32.const -33
+              i32.and
+              local.set $9
+              local.get $8
+              i32.const 0
+              i32.ne
+              local.get $7
+              i32.const 15
+              i32.and
+              i32.const 3
+              i32.eq
+              i32.and
+              i32.eqz
+              if ;; label = @6
+                local.get $7
+                local.set $9
+              end
+              local.get $12
+              i32.const -65537
+              i32.and
+              local.set $7
+              local.get $12
+              i32.const 8192
+              i32.and
+              if ;; label = @6
+                local.get $7
+                local.set $12
+              end
+              block $label$70 ;; label = @6
+                block $label$71 ;; label = @7
+                  block $label$72 ;; label = @8
+                    block $label$73 ;; label = @9
+                      block $label$74 ;; label = @10
+                        block $label$75 ;; label = @11
+                          block $label$76 ;; label = @12
+                            block $label$77 ;; label = @13
+                              block $label$78 ;; label = @14
+                                block $label$79 ;; label = @15
+                                  block $label$80 ;; label = @16
+                                    block $label$81 ;; label = @17
+                                      block $label$82 ;; label = @18
+                                        block $label$83 ;; label = @19
+                                          block $label$84 ;; label = @20
+                                            block $label$85 ;; label = @21
+                                              block $label$86 ;; label = @22
+                                                block $label$87 ;; label = @23
+                                                  block $label$88 ;; label = @24
+                                                    block $label$89 ;; label = @25
+                                                      local.get $9
+                                                      i32.const 65
+                                                      i32.sub
+                                                      br_table 11 (;@14;) 12 (;@13;) 9 (;@16;) 12 (;@13;) 11 (;@14;) 11 (;@14;) 11 (;@14;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 10 (;@15;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 2 (;@23;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 11 (;@14;) 12 (;@13;) 6 (;@19;) 4 (;@21;) 11 (;@14;) 11 (;@14;) 11 (;@14;) 12 (;@13;) 4 (;@21;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 7 (;@18;) 0 (;@25;) 3 (;@22;) 1 (;@24;) 12 (;@13;) 12 (;@13;) 8 (;@17;) 12 (;@13;) 5 (;@20;) 12 (;@13;) 12 (;@13;) 2 (;@23;) 12 (;@13;)
+                                                    end
+                                                    block $label$90 ;; label = @25
+                                                      block $label$91 ;; label = @26
+                                                        block $label$92 ;; label = @27
+                                                          block $label$93 ;; label = @28
+                                                            block $label$94 ;; label = @29
+                                                              block $label$95 ;; label = @30
+                                                                block $label$96 ;; label = @31
+                                                                  block $label$97 ;; label = @32
+                                                                    local.get $8
+                                                                    i32.const 255
+                                                                    i32.and
+                                                                    i32.const 24
+                                                                    i32.shl
+                                                                    i32.const 24
+                                                                    i32.shr_s
+                                                                    i32.const 0
+                                                                    i32.sub
+                                                                    br_table 0 (;@32;) 1 (;@31;) 2 (;@30;) 3 (;@29;) 4 (;@28;) 7 (;@25;) 5 (;@27;) 6 (;@26;) 7 (;@25;)
+                                                                  end
+                                                                  local.get $16
+                                                                  i32.load
+                                                                  local.get $15
+                                                                  i32.store
+                                                                  i32.const 0
+                                                                  local.set $10
+                                                                  local.get $11
+                                                                  local.set $1
+                                                                  br 27 (;@4;)
+                                                                end
+                                                                local.get $16
+                                                                i32.load
+                                                                local.get $15
+                                                                i32.store
+                                                                i32.const 0
+                                                                local.set $10
+                                                                local.get $11
+                                                                local.set $1
+                                                                br 26 (;@4;)
+                                                              end
+                                                              local.get $16
+                                                              i32.load
+                                                              local.get $15
+                                                              i64.extend_i32_s
+                                                              i64.store
+                                                              i32.const 0
+                                                              local.set $10
+                                                              local.get $11
+                                                              local.set $1
+                                                              br 25 (;@4;)
+                                                            end
+                                                            local.get $16
+                                                            i32.load
+                                                            local.get $15
+                                                            i32.store16
+                                                            i32.const 0
+                                                            local.set $10
+                                                            local.get $11
+                                                            local.set $1
+                                                            br 24 (;@4;)
+                                                          end
+                                                          local.get $16
+                                                          i32.load
+                                                          local.get $15
+                                                          i32.store8
+                                                          i32.const 0
+                                                          local.set $10
+                                                          local.get $11
+                                                          local.set $1
+                                                          br 23 (;@4;)
+                                                        end
+                                                        local.get $16
+                                                        i32.load
+                                                        local.get $15
+                                                        i32.store
+                                                        i32.const 0
+                                                        local.set $10
+                                                        local.get $11
+                                                        local.set $1
+                                                        br 22 (;@4;)
+                                                      end
+                                                      local.get $16
+                                                      i32.load
+                                                      local.get $15
+                                                      i64.extend_i32_s
+                                                      i64.store
+                                                      i32.const 0
+                                                      local.set $10
+                                                      local.get $11
+                                                      local.set $1
+                                                      br 21 (;@4;)
+                                                    end
+                                                    i32.const 0
+                                                    local.set $10
+                                                    local.get $11
+                                                    local.set $1
+                                                    br 20 (;@4;)
+                                                  end
+                                                  local.get $12
+                                                  i32.const 8
+                                                  i32.or
+                                                  local.set $12
+                                                  local.get $5
+                                                  i32.const 8
+                                                  i32.le_u
+                                                  if ;; label = @24
+                                                    i32.const 8
+                                                    local.set $5
+                                                  end
+                                                  i32.const 120
+                                                  local.set $9
+                                                  br 11 (;@12;)
+                                                end
+                                                br 10 (;@12;)
+                                              end
+                                              local.get $16
+                                              i64.load
+                                              local.tee $50
+                                              i64.const 0
+                                              i64.eq
+                                              if ;; label = @22
+                                                local.get $21
+                                                local.set $7
+                                              else
+                                                block ;; label = @23
+                                                  local.get $21
+                                                  local.set $1
+                                                  loop $label$101 ;; label = @24
+                                                    local.get $1
+                                                    i32.const -1
+                                                    i32.add
+                                                    local.tee $1
+                                                    local.get $50
+                                                    i64.const 7
+                                                    i64.and
+                                                    i64.const 48
+                                                    i64.or
+                                                    i64.store8
+                                                    local.get $50
+                                                    i64.const 3
+                                                    i64.shr_u
+                                                    local.tee $50
+                                                    i64.const 0
+                                                    i64.ne
+                                                    br_if 0 (;@24;)
+                                                    local.get $1
+                                                    local.set $7
+                                                  end
+                                                end
+                                              end
+                                              local.get $12
+                                              i32.const 8
+                                              i32.and
+                                              if ;; label = @22
+                                                block ;; label = @23
+                                                  local.get $38
+                                                  local.get $7
+                                                  i32.sub
+                                                  local.tee $1
+                                                  i32.const 1
+                                                  i32.add
+                                                  local.set $8
+                                                  local.get $5
+                                                  local.get $1
+                                                  i32.le_s
+                                                  if ;; label = @24
+                                                    local.get $8
+                                                    local.set $5
+                                                  end
+                                                  i32.const 0
+                                                  local.set $6
+                                                  i32.const 2179
+                                                  local.set $8
+                                                  br 16 (;@7;)
+                                                end
+                                              else
+                                                block ;; label = @23
+                                                  i32.const 0
+                                                  local.set $6
+                                                  i32.const 2179
+                                                  local.set $8
+                                                  br 16 (;@7;)
+                                                end
+                                              end
+                                            end
+                                            local.get $16
+                                            i64.load
+                                            local.tee $50
+                                            i64.const 0
+                                            i64.lt_s
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                local.get $16
+                                                i64.const 0
+                                                local.get $50
+                                                i64.sub
+                                                local.tee $50
+                                                i64.store
+                                                i32.const 1
+                                                local.set $6
+                                                i32.const 2179
+                                                local.set $8
+                                                br 11 (;@11;)
+                                              end
+                                            end
+                                            local.get $12
+                                            i32.const 2048
+                                            i32.and
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                i32.const 1
+                                                local.set $6
+                                                i32.const 2180
+                                                local.set $8
+                                                br 11 (;@11;)
+                                              end
+                                            else
+                                              block ;; label = @22
+                                                local.get $12
+                                                i32.const 1
+                                                i32.and
+                                                local.tee $1
+                                                local.set $6
+                                                local.get $1
+                                                if (result i32) ;; label = @23
+                                                  i32.const 2181
+                                                else
+                                                  i32.const 2179
+                                                end
+                                                local.set $8
+                                                br 11 (;@11;)
+                                              end
+                                            end
+                                          end
+                                          local.get $16
+                                          i64.load
+                                          local.set $50
+                                          i32.const 0
+                                          local.set $6
+                                          i32.const 2179
+                                          local.set $8
+                                          br 8 (;@11;)
+                                        end
+                                        local.get $39
+                                        local.get $16
+                                        i64.load
+                                        i64.store8
+                                        local.get $39
+                                        local.set $1
+                                        local.get $7
+                                        local.set $12
+                                        i32.const 1
+                                        local.set $7
+                                        i32.const 0
+                                        local.set $6
+                                        i32.const 2179
+                                        local.set $8
+                                        local.get $21
+                                        local.set $5
+                                        br 12 (;@6;)
+                                      end
+                                      call $12
+                                      i32.load
+                                      call $24
+                                      local.set $1
+                                      br 7 (;@10;)
+                                    end
+                                    local.get $16
+                                    i32.load
+                                    local.tee $1
+                                    i32.eqz
+                                    if ;; label = @17
+                                      i32.const 2189
+                                      local.set $1
+                                    end
+                                    br 6 (;@10;)
+                                  end
+                                  local.get $37
+                                  local.get $16
+                                  i64.load
+                                  i64.store32
+                                  local.get $42
+                                  i32.const 0
+                                  i32.store
+                                  local.get $16
+                                  local.get $37
+                                  i32.store
+                                  local.get $37
+                                  local.set $7
+                                  i32.const -1
+                                  local.set $6
+                                  br 6 (;@9;)
+                                end
+                                local.get $16
+                                i32.load
+                                local.set $7
+                                local.get $5
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $5
+                                    local.set $6
+                                    br 7 (;@9;)
+                                  end
+                                else
+                                  block ;; label = @16
+                                    local.get $0
+                                    i32.const 32
+                                    local.get $10
+                                    i32.const 0
+                                    local.get $12
+                                    call $25
+                                    i32.const 0
+                                    local.set $1
+                                    br 8 (;@8;)
+                                  end
+                                end
+                              end
+                              local.get $16
+                              f64.load
+                              local.set $52
+                              local.get $20
+                              i32.const 0
+                              i32.store
+                              local.get $52
+                              i64.reinterpret_f64
+                              i64.const 0
+                              i64.lt_s
+                              if (result i32) ;; label = @14
+                                block (result i32) ;; label = @15
+                                  i32.const 1
+                                  local.set $24
+                                  local.get $52
+                                  f64.neg
+                                  local.set $52
+                                  i32.const 2196
+                                end
+                              else
+                                block (result i32) ;; label = @15
+                                  local.get $12
+                                  i32.const 1
+                                  i32.and
+                                  local.set $1
+                                  local.get $12
+                                  i32.const 2048
+                                  i32.and
+                                  if (result i32) ;; label = @16
+                                    block (result i32) ;; label = @17
+                                      i32.const 1
+                                      local.set $24
+                                      i32.const 2199
+                                    end
+                                  else
+                                    block (result i32) ;; label = @17
+                                      local.get $1
+                                      local.set $24
+                                      local.get $1
+                                      if (result i32) ;; label = @18
+                                        i32.const 2202
+                                      else
+                                        i32.const 2197
+                                      end
+                                    end
+                                  end
+                                end
+                              end
+                              local.set $26
+                              block $label$119 ;; label = @14
+                                local.get $52
+                                i64.reinterpret_f64
+                                i64.const 9218868437227405312
+                                i64.and
+                                i64.const 9218868437227405312
+                                i64.lt_u
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $52
+                                    local.get $20
+                                    call $27
+                                    f64.const 0x1p+1 (;=2;)
+                                    f64.mul
+                                    local.tee $52
+                                    f64.const 0x0p+0 (;=0;)
+                                    f64.ne
+                                    local.tee $1
+                                    if ;; label = @17
+                                      local.get $20
+                                      local.get $20
+                                      i32.load
+                                      i32.const -1
+                                      i32.add
+                                      i32.store
+                                    end
+                                    local.get $9
+                                    i32.const 32
+                                    i32.or
+                                    local.tee $22
+                                    i32.const 97
+                                    i32.eq
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        local.get $26
+                                        i32.const 9
+                                        i32.add
+                                        local.set $1
+                                        local.get $9
+                                        i32.const 32
+                                        i32.and
+                                        local.tee $6
+                                        if ;; label = @19
+                                          local.get $1
+                                          local.set $26
+                                        end
+                                        local.get $5
+                                        i32.const 11
+                                        i32.gt_u
+                                        i32.const 12
+                                        local.get $5
+                                        i32.sub
+                                        local.tee $1
+                                        i32.eqz
+                                        i32.or
+                                        i32.eqz
+                                        if ;; label = @19
+                                          block ;; label = @20
+                                            f64.const 0x1p+3 (;=8;)
+                                            local.set $53
+                                            loop $label$125 ;; label = @21
+                                              local.get $53
+                                              f64.const 0x1p+4 (;=16;)
+                                              f64.mul
+                                              local.set $53
+                                              local.get $1
+                                              i32.const -1
+                                              i32.add
+                                              local.tee $1
+                                              br_if 0 (;@21;)
+                                            end
+                                            local.get $26
+                                            i32.load8_s
+                                            i32.const 45
+                                            i32.eq
+                                            if (result f64) ;; label = @21
+                                              local.get $53
+                                              local.get $52
+                                              f64.neg
+                                              local.get $53
+                                              f64.sub
+                                              f64.add
+                                              f64.neg
+                                            else
+                                              local.get $52
+                                              local.get $53
+                                              f64.add
+                                              local.get $53
+                                              f64.sub
+                                            end
+                                            local.set $52
+                                          end
+                                        end
+                                        i32.const 0
+                                        local.get $20
+                                        i32.load
+                                        local.tee $7
+                                        i32.sub
+                                        local.set $1
+                                        local.get $7
+                                        i32.const 0
+                                        i32.lt_s
+                                        if (result i32) ;; label = @19
+                                          local.get $1
+                                        else
+                                          local.get $7
+                                        end
+                                        i64.extend_i32_s
+                                        local.get $33
+                                        call $23
+                                        local.tee $1
+                                        local.get $33
+                                        i32.eq
+                                        if ;; label = @19
+                                          block ;; label = @20
+                                            local.get $40
+                                            i32.const 48
+                                            i32.store8
+                                            local.get $40
+                                            local.set $1
+                                          end
+                                        end
+                                        local.get $24
+                                        i32.const 2
+                                        i32.or
+                                        local.set $13
+                                        local.get $1
+                                        i32.const -1
+                                        i32.add
+                                        local.get $7
+                                        i32.const 31
+                                        i32.shr_s
+                                        i32.const 2
+                                        i32.and
+                                        i32.const 43
+                                        i32.add
+                                        i32.store8
+                                        local.get $1
+                                        i32.const -2
+                                        i32.add
+                                        local.tee $8
+                                        local.get $9
+                                        i32.const 15
+                                        i32.add
+                                        i32.store8
+                                        local.get $5
+                                        i32.const 1
+                                        i32.lt_s
+                                        local.set $9
+                                        local.get $12
+                                        i32.const 8
+                                        i32.and
+                                        i32.eqz
+                                        local.set $14
+                                        local.get $19
+                                        local.set $1
+                                        loop $label$131 ;; label = @19
+                                          local.get $1
+                                          local.get $52
+                                          i32.trunc_f64_s
+                                          local.tee $7
+                                          i32.const 2163
+                                          i32.add
+                                          i32.load8_u
+                                          local.get $6
+                                          i32.or
+                                          i32.store8
+                                          local.get $52
+                                          local.get $7
+                                          f64.convert_i32_s
+                                          f64.sub
+                                          f64.const 0x1p+4 (;=16;)
+                                          f64.mul
+                                          local.set $52
+                                          block $label$132 (result i32) ;; label = @20
+                                            local.get $1
+                                            i32.const 1
+                                            i32.add
+                                            local.tee $7
+                                            local.get $27
+                                            i32.sub
+                                            i32.const 1
+                                            i32.eq
+                                            if (result i32) ;; label = @21
+                                              block (result i32) ;; label = @22
+                                                local.get $7
+                                                local.get $14
+                                                local.get $9
+                                                local.get $52
+                                                f64.const 0x0p+0 (;=0;)
+                                                f64.eq
+                                                i32.and
+                                                i32.and
+                                                br_if 2 (;@20;)
+                                                drop
+                                                local.get $7
+                                                i32.const 46
+                                                i32.store8
+                                                local.get $1
+                                                i32.const 2
+                                                i32.add
+                                              end
+                                            else
+                                              local.get $7
+                                            end
+                                          end
+                                          local.set $1
+                                          local.get $52
+                                          f64.const 0x0p+0 (;=0;)
+                                          f64.ne
+                                          br_if 0 (;@19;)
+                                        end
+                                        local.get $46
+                                        local.get $5
+                                        i32.add
+                                        local.get $8
+                                        local.tee $7
+                                        i32.sub
+                                        local.set $6
+                                        local.get $44
+                                        local.get $7
+                                        i32.sub
+                                        local.get $1
+                                        i32.add
+                                        local.set $9
+                                        local.get $0
+                                        i32.const 32
+                                        local.get $10
+                                        local.get $5
+                                        i32.const 0
+                                        i32.ne
+                                        local.get $45
+                                        local.get $1
+                                        i32.add
+                                        local.get $5
+                                        i32.lt_s
+                                        i32.and
+                                        if (result i32) ;; label = @19
+                                          local.get $6
+                                        else
+                                          local.get $9
+                                          local.tee $6
+                                        end
+                                        local.get $13
+                                        i32.add
+                                        local.tee $5
+                                        local.get $12
+                                        call $25
+                                        local.get $0
+                                        i32.load
+                                        i32.const 32
+                                        i32.and
+                                        i32.eqz
+                                        if ;; label = @19
+                                          local.get $26
+                                          local.get $13
+                                          local.get $0
+                                          call $21
+                                          drop
+                                        end
+                                        local.get $0
+                                        i32.const 48
+                                        local.get $10
+                                        local.get $5
+                                        local.get $12
+                                        i32.const 65536
+                                        i32.xor
+                                        call $25
+                                        local.get $1
+                                        local.get $27
+                                        i32.sub
+                                        local.set $1
+                                        local.get $0
+                                        i32.load
+                                        i32.const 32
+                                        i32.and
+                                        i32.eqz
+                                        if ;; label = @19
+                                          local.get $19
+                                          local.get $1
+                                          local.get $0
+                                          call $21
+                                          drop
+                                        end
+                                        local.get $0
+                                        i32.const 48
+                                        local.get $6
+                                        local.get $1
+                                        local.get $28
+                                        local.get $7
+                                        i32.sub
+                                        local.tee $1
+                                        i32.add
+                                        i32.sub
+                                        i32.const 0
+                                        i32.const 0
+                                        call $25
+                                        local.get $0
+                                        i32.load
+                                        i32.const 32
+                                        i32.and
+                                        i32.eqz
+                                        if ;; label = @19
+                                          local.get $8
+                                          local.get $1
+                                          local.get $0
+                                          call $21
+                                          drop
+                                        end
+                                        local.get $0
+                                        i32.const 32
+                                        local.get $10
+                                        local.get $5
+                                        local.get $12
+                                        i32.const 8192
+                                        i32.xor
+                                        call $25
+                                        local.get $5
+                                        local.get $10
+                                        i32.ge_s
+                                        if ;; label = @19
+                                          local.get $5
+                                          local.set $10
+                                        end
+                                        br 4 (;@14;)
+                                      end
+                                    end
+                                    local.get $1
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        local.get $20
+                                        local.get $20
+                                        i32.load
+                                        i32.const -28
+                                        i32.add
+                                        local.tee $6
+                                        i32.store
+                                        local.get $52
+                                        f64.const 0x1p+28 (;=268435456;)
+                                        f64.mul
+                                        local.set $52
+                                      end
+                                    else
+                                      local.get $20
+                                      i32.load
+                                      local.set $6
+                                    end
+                                    local.get $6
+                                    i32.const 0
+                                    i32.lt_s
+                                    if (result i32) ;; label = @17
+                                      local.get $47
+                                    else
+                                      local.get $48
+                                    end
+                                    local.tee $7
+                                    local.set $8
+                                    loop $label$145 ;; label = @17
+                                      local.get $8
+                                      local.get $52
+                                      i32.trunc_f64_s
+                                      local.tee $1
+                                      i32.store
+                                      local.get $8
+                                      i32.const 4
+                                      i32.add
+                                      local.set $8
+                                      local.get $52
+                                      local.get $1
+                                      f64.convert_i32_u
+                                      f64.sub
+                                      f64.const 0x1.dcd65p+29 (;=1000000000;)
+                                      f64.mul
+                                      local.tee $52
+                                      f64.const 0x0p+0 (;=0;)
+                                      f64.ne
+                                      br_if 0 (;@17;)
+                                    end
+                                    local.get $6
+                                    i32.const 0
+                                    i32.gt_s
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        local.get $7
+                                        local.set $1
+                                        loop $label$147 ;; label = @19
+                                          local.get $6
+                                          i32.const 29
+                                          i32.gt_s
+                                          if (result i32) ;; label = @20
+                                            i32.const 29
+                                          else
+                                            local.get $6
+                                          end
+                                          local.set $14
+                                          block $label$150 ;; label = @20
+                                            local.get $8
+                                            i32.const -4
+                                            i32.add
+                                            local.tee $6
+                                            local.get $1
+                                            i32.ge_u
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                local.get $14
+                                                i64.extend_i32_u
+                                                local.set $50
+                                                i32.const 0
+                                                local.set $13
+                                                loop $label$152 ;; label = @23
+                                                  local.get $6
+                                                  local.get $6
+                                                  i32.load
+                                                  i64.extend_i32_u
+                                                  local.get $50
+                                                  i64.shl
+                                                  local.get $13
+                                                  i64.extend_i32_u
+                                                  i64.add
+                                                  local.tee $51
+                                                  i64.const 1000000000
+                                                  i64.rem_u
+                                                  i64.store32
+                                                  local.get $51
+                                                  i64.const 1000000000
+                                                  i64.div_u
+                                                  i32.wrap_i64
+                                                  local.set $13
+                                                  local.get $6
+                                                  i32.const -4
+                                                  i32.add
+                                                  local.tee $6
+                                                  local.get $1
+                                                  i32.ge_u
+                                                  br_if 0 (;@23;)
+                                                end
+                                                local.get $13
+                                                i32.eqz
+                                                br_if 2 (;@20;)
+                                                local.get $1
+                                                i32.const -4
+                                                i32.add
+                                                local.tee $1
+                                                local.get $13
+                                                i32.store
+                                              end
+                                            end
+                                          end
+                                          loop $label$153 ;; label = @20
+                                            local.get $8
+                                            local.get $1
+                                            i32.gt_u
+                                            if ;; label = @21
+                                              local.get $8
+                                              i32.const -4
+                                              i32.add
+                                              local.tee $6
+                                              i32.load
+                                              i32.eqz
+                                              if ;; label = @22
+                                                block ;; label = @23
+                                                  local.get $6
+                                                  local.set $8
+                                                  br 3 (;@20;)
+                                                end
+                                              end
+                                            end
+                                          end
+                                          local.get $20
+                                          local.get $20
+                                          i32.load
+                                          local.get $14
+                                          i32.sub
+                                          local.tee $6
+                                          i32.store
+                                          local.get $6
+                                          i32.const 0
+                                          i32.gt_s
+                                          br_if 0 (;@19;)
+                                        end
+                                      end
+                                    else
+                                      local.get $7
+                                      local.set $1
+                                    end
+                                    local.get $5
+                                    i32.const 0
+                                    i32.lt_s
+                                    if (result i32) ;; label = @17
+                                      i32.const 6
+                                    else
+                                      local.get $5
+                                    end
+                                    local.set $18
+                                    local.get $6
+                                    i32.const 0
+                                    i32.lt_s
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        local.get $18
+                                        i32.const 25
+                                        i32.add
+                                        i32.const 9
+                                        i32.div_s
+                                        i32.const 1
+                                        i32.add
+                                        local.set $14
+                                        local.get $22
+                                        i32.const 102
+                                        i32.eq
+                                        local.set $25
+                                        local.get $8
+                                        local.set $5
+                                        loop $label$160 ;; label = @19
+                                          i32.const 0
+                                          local.get $6
+                                          i32.sub
+                                          local.tee $13
+                                          i32.const 9
+                                          i32.gt_s
+                                          if ;; label = @20
+                                            i32.const 9
+                                            local.set $13
+                                          end
+                                          block $label$162 ;; label = @20
+                                            local.get $1
+                                            local.get $5
+                                            i32.lt_u
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                i32.const 1
+                                                local.get $13
+                                                i32.shl
+                                                i32.const -1
+                                                i32.add
+                                                local.set $29
+                                                i32.const 1000000000
+                                                local.get $13
+                                                i32.shr_u
+                                                local.set $35
+                                                i32.const 0
+                                                local.set $6
+                                                local.get $1
+                                                local.set $8
+                                                loop $label$164 ;; label = @23
+                                                  local.get $8
+                                                  local.get $8
+                                                  i32.load
+                                                  local.tee $32
+                                                  local.get $13
+                                                  i32.shr_u
+                                                  local.get $6
+                                                  i32.add
+                                                  i32.store
+                                                  local.get $32
+                                                  local.get $29
+                                                  i32.and
+                                                  local.get $35
+                                                  i32.mul
+                                                  local.set $6
+                                                  local.get $8
+                                                  i32.const 4
+                                                  i32.add
+                                                  local.tee $8
+                                                  local.get $5
+                                                  i32.lt_u
+                                                  br_if 0 (;@23;)
+                                                end
+                                                local.get $1
+                                                i32.const 4
+                                                i32.add
+                                                local.set $8
+                                                local.get $1
+                                                i32.load
+                                                i32.eqz
+                                                if ;; label = @23
+                                                  local.get $8
+                                                  local.set $1
+                                                end
+                                                local.get $6
+                                                i32.eqz
+                                                br_if 2 (;@20;)
+                                                local.get $5
+                                                local.get $6
+                                                i32.store
+                                                local.get $5
+                                                i32.const 4
+                                                i32.add
+                                                local.set $5
+                                              end
+                                            else
+                                              block ;; label = @22
+                                                local.get $1
+                                                i32.const 4
+                                                i32.add
+                                                local.set $8
+                                                local.get $1
+                                                i32.load
+                                                i32.eqz
+                                                if ;; label = @23
+                                                  local.get $8
+                                                  local.set $1
+                                                end
+                                              end
+                                            end
+                                          end
+                                          local.get $25
+                                          if (result i32) ;; label = @20
+                                            local.get $7
+                                          else
+                                            local.get $1
+                                          end
+                                          local.tee $8
+                                          local.get $14
+                                          i32.const 2
+                                          i32.shl
+                                          i32.add
+                                          local.set $6
+                                          local.get $5
+                                          local.get $8
+                                          i32.sub
+                                          i32.const 2
+                                          i32.shr_s
+                                          local.get $14
+                                          i32.gt_s
+                                          if ;; label = @20
+                                            local.get $6
+                                            local.set $5
+                                          end
+                                          local.get $20
+                                          local.get $20
+                                          i32.load
+                                          local.get $13
+                                          i32.add
+                                          local.tee $6
+                                          i32.store
+                                          local.get $6
+                                          i32.const 0
+                                          i32.lt_s
+                                          br_if 0 (;@19;)
+                                          local.get $5
+                                          local.set $13
+                                        end
+                                      end
+                                    else
+                                      local.get $8
+                                      local.set $13
+                                    end
+                                    local.get $7
+                                    local.set $25
+                                    block $label$172 ;; label = @17
+                                      local.get $1
+                                      local.get $13
+                                      i32.lt_u
+                                      if ;; label = @18
+                                        block ;; label = @19
+                                          local.get $25
+                                          local.get $1
+                                          i32.sub
+                                          i32.const 2
+                                          i32.shr_s
+                                          i32.const 9
+                                          i32.mul
+                                          local.set $5
+                                          local.get $1
+                                          i32.load
+                                          local.tee $6
+                                          i32.const 10
+                                          i32.lt_u
+                                          br_if 2 (;@17;)
+                                          i32.const 10
+                                          local.set $8
+                                          loop $label$174 ;; label = @20
+                                            local.get $5
+                                            i32.const 1
+                                            i32.add
+                                            local.set $5
+                                            local.get $6
+                                            local.get $8
+                                            i32.const 10
+                                            i32.mul
+                                            local.tee $8
+                                            i32.ge_u
+                                            br_if 0 (;@20;)
+                                          end
+                                        end
+                                      else
+                                        i32.const 0
+                                        local.set $5
+                                      end
+                                    end
+                                    local.get $22
+                                    i32.const 103
+                                    i32.eq
+                                    local.set $29
+                                    local.get $18
+                                    i32.const 0
+                                    i32.ne
+                                    local.set $35
+                                    local.get $18
+                                    local.get $22
+                                    i32.const 102
+                                    i32.ne
+                                    if (result i32) ;; label = @17
+                                      local.get $5
+                                    else
+                                      i32.const 0
+                                    end
+                                    i32.sub
+                                    local.get $35
+                                    local.get $29
+                                    i32.and
+                                    i32.const 31
+                                    i32.shl
+                                    i32.const 31
+                                    i32.shr_s
+                                    i32.add
+                                    local.tee $8
+                                    local.get $13
+                                    local.get $25
+                                    i32.sub
+                                    i32.const 2
+                                    i32.shr_s
+                                    i32.const 9
+                                    i32.mul
+                                    i32.const -9
+                                    i32.add
+                                    i32.lt_s
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        local.get $8
+                                        i32.const 9216
+                                        i32.add
+                                        local.tee $14
+                                        i32.const 9
+                                        i32.rem_s
+                                        i32.const 1
+                                        i32.add
+                                        local.tee $8
+                                        i32.const 9
+                                        i32.lt_s
+                                        if ;; label = @19
+                                          block ;; label = @20
+                                            i32.const 10
+                                            local.set $6
+                                            loop $label$180 ;; label = @21
+                                              local.get $6
+                                              i32.const 10
+                                              i32.mul
+                                              local.set $6
+                                              local.get $8
+                                              i32.const 1
+                                              i32.add
+                                              local.tee $8
+                                              i32.const 9
+                                              i32.ne
+                                              br_if 0 (;@21;)
+                                            end
+                                          end
+                                        else
+                                          i32.const 10
+                                          local.set $6
+                                        end
+                                        local.get $7
+                                        i32.const 4
+                                        i32.add
+                                        local.get $14
+                                        i32.const 9
+                                        i32.div_s
+                                        i32.const -1024
+                                        i32.add
+                                        i32.const 2
+                                        i32.shl
+                                        i32.add
+                                        local.tee $8
+                                        i32.load
+                                        local.tee $22
+                                        local.get $6
+                                        i32.rem_u
+                                        local.set $14
+                                        block $label$182 ;; label = @19
+                                          local.get $8
+                                          i32.const 4
+                                          i32.add
+                                          local.get $13
+                                          i32.eq
+                                          local.tee $32
+                                          local.get $14
+                                          i32.eqz
+                                          i32.and
+                                          i32.eqz
+                                          if ;; label = @20
+                                            block ;; label = @21
+                                              local.get $14
+                                              local.get $6
+                                              i32.const 2
+                                              i32.div_s
+                                              local.tee $49
+                                              i32.lt_u
+                                              if (result f64) ;; label = @22
+                                                f64.const 0x1p-1 (;=0.5;)
+                                              else
+                                                local.get $32
+                                                local.get $14
+                                                local.get $49
+                                                i32.eq
+                                                i32.and
+                                                if (result f64) ;; label = @23
+                                                  f64.const 0x1p+0 (;=1;)
+                                                else
+                                                  f64.const 0x1.8p+0 (;=1.5;)
+                                                end
+                                              end
+                                              local.set $52
+                                              local.get $22
+                                              local.get $6
+                                              i32.div_u
+                                              i32.const 1
+                                              i32.and
+                                              if (result f64) ;; label = @22
+                                                f64.const 0x1.0000000000001p+53 (;=9007199254740994;)
+                                              else
+                                                f64.const 0x1p+53 (;=9007199254740992;)
+                                              end
+                                              local.set $53
+                                              block $label$190 ;; label = @22
+                                                local.get $24
+                                                if ;; label = @23
+                                                  block ;; label = @24
+                                                    local.get $26
+                                                    i32.load8_s
+                                                    i32.const 45
+                                                    i32.ne
+                                                    br_if 2 (;@22;)
+                                                    local.get $53
+                                                    f64.neg
+                                                    local.set $53
+                                                    local.get $52
+                                                    f64.neg
+                                                    local.set $52
+                                                  end
+                                                end
+                                              end
+                                              local.get $8
+                                              local.get $22
+                                              local.get $14
+                                              i32.sub
+                                              local.tee $14
+                                              i32.store
+                                              local.get $53
+                                              local.get $52
+                                              f64.add
+                                              local.get $53
+                                              f64.eq
+                                              br_if 2 (;@19;)
+                                              local.get $8
+                                              local.get $14
+                                              local.get $6
+                                              i32.add
+                                              local.tee $5
+                                              i32.store
+                                              local.get $5
+                                              i32.const 999999999
+                                              i32.gt_u
+                                              if ;; label = @22
+                                                loop $label$193 ;; label = @23
+                                                  local.get $8
+                                                  i32.const 0
+                                                  i32.store
+                                                  local.get $8
+                                                  i32.const -4
+                                                  i32.add
+                                                  local.tee $8
+                                                  local.get $1
+                                                  i32.lt_u
+                                                  if ;; label = @24
+                                                    local.get $1
+                                                    i32.const -4
+                                                    i32.add
+                                                    local.tee $1
+                                                    i32.const 0
+                                                    i32.store
+                                                  end
+                                                  local.get $8
+                                                  local.get $8
+                                                  i32.load
+                                                  i32.const 1
+                                                  i32.add
+                                                  local.tee $5
+                                                  i32.store
+                                                  local.get $5
+                                                  i32.const 999999999
+                                                  i32.gt_u
+                                                  br_if 0 (;@23;)
+                                                end
+                                              end
+                                              local.get $25
+                                              local.get $1
+                                              i32.sub
+                                              i32.const 2
+                                              i32.shr_s
+                                              i32.const 9
+                                              i32.mul
+                                              local.set $5
+                                              local.get $1
+                                              i32.load
+                                              local.tee $14
+                                              i32.const 10
+                                              i32.lt_u
+                                              br_if 2 (;@19;)
+                                              i32.const 10
+                                              local.set $6
+                                              loop $label$195 ;; label = @22
+                                                local.get $5
+                                                i32.const 1
+                                                i32.add
+                                                local.set $5
+                                                local.get $14
+                                                local.get $6
+                                                i32.const 10
+                                                i32.mul
+                                                local.tee $6
+                                                i32.ge_u
+                                                br_if 0 (;@22;)
+                                              end
+                                            end
+                                          end
+                                        end
+                                        local.get $1
+                                        local.set $14
+                                        local.get $5
+                                        local.set $6
+                                        local.get $13
+                                        local.get $8
+                                        i32.const 4
+                                        i32.add
+                                        local.tee $8
+                                        i32.le_u
+                                        if ;; label = @19
+                                          local.get $13
+                                          local.set $8
+                                        end
+                                      end
+                                    else
+                                      block ;; label = @18
+                                        local.get $1
+                                        local.set $14
+                                        local.get $5
+                                        local.set $6
+                                        local.get $13
+                                        local.set $8
+                                      end
+                                    end
+                                    i32.const 0
+                                    local.get $6
+                                    i32.sub
+                                    local.set $32
+                                    loop $label$198 ;; label = @17
+                                      block $label$199 ;; label = @18
+                                        local.get $8
+                                        local.get $14
+                                        i32.le_u
+                                        if ;; label = @19
+                                          block ;; label = @20
+                                            i32.const 0
+                                            local.set $22
+                                            br 2 (;@18;)
+                                          end
+                                        end
+                                        local.get $8
+                                        i32.const -4
+                                        i32.add
+                                        local.tee $1
+                                        i32.load
+                                        if ;; label = @19
+                                          i32.const 1
+                                          local.set $22
+                                        else
+                                          block ;; label = @20
+                                            local.get $1
+                                            local.set $8
+                                            br 3 (;@17;)
+                                          end
+                                        end
+                                      end
+                                    end
+                                    block $label$203 ;; label = @17
+                                      local.get $29
+                                      if ;; label = @18
+                                        block ;; label = @19
+                                          local.get $35
+                                          i32.const 1
+                                          i32.and
+                                          i32.const 1
+                                          i32.xor
+                                          local.get $18
+                                          i32.add
+                                          local.tee $1
+                                          local.get $6
+                                          i32.gt_s
+                                          local.get $6
+                                          i32.const -5
+                                          i32.gt_s
+                                          i32.and
+                                          if (result i32) ;; label = @20
+                                            block (result i32) ;; label = @21
+                                              local.get $9
+                                              i32.const -1
+                                              i32.add
+                                              local.set $5
+                                              local.get $1
+                                              i32.const -1
+                                              i32.add
+                                              local.get $6
+                                              i32.sub
+                                            end
+                                          else
+                                            block (result i32) ;; label = @21
+                                              local.get $9
+                                              i32.const -2
+                                              i32.add
+                                              local.set $5
+                                              local.get $1
+                                              i32.const -1
+                                              i32.add
+                                            end
+                                          end
+                                          local.set $1
+                                          local.get $12
+                                          i32.const 8
+                                          i32.and
+                                          local.tee $13
+                                          br_if 2 (;@17;)
+                                          block $label$207 ;; label = @20
+                                            local.get $22
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                local.get $8
+                                                i32.const -4
+                                                i32.add
+                                                i32.load
+                                                local.tee $18
+                                                i32.eqz
+                                                if ;; label = @23
+                                                  block ;; label = @24
+                                                    i32.const 9
+                                                    local.set $9
+                                                    br 4 (;@20;)
+                                                  end
+                                                end
+                                                local.get $18
+                                                i32.const 10
+                                                i32.rem_u
+                                                if ;; label = @23
+                                                  block ;; label = @24
+                                                    i32.const 0
+                                                    local.set $9
+                                                    br 4 (;@20;)
+                                                  end
+                                                else
+                                                  block ;; label = @24
+                                                    i32.const 10
+                                                    local.set $13
+                                                    i32.const 0
+                                                    local.set $9
+                                                  end
+                                                end
+                                                loop $label$212 ;; label = @23
+                                                  local.get $9
+                                                  i32.const 1
+                                                  i32.add
+                                                  local.set $9
+                                                  local.get $18
+                                                  local.get $13
+                                                  i32.const 10
+                                                  i32.mul
+                                                  local.tee $13
+                                                  i32.rem_u
+                                                  i32.eqz
+                                                  br_if 0 (;@23;)
+                                                end
+                                              end
+                                            else
+                                              i32.const 9
+                                              local.set $9
+                                            end
+                                          end
+                                          local.get $8
+                                          local.get $25
+                                          i32.sub
+                                          i32.const 2
+                                          i32.shr_s
+                                          i32.const 9
+                                          i32.mul
+                                          i32.const -9
+                                          i32.add
+                                          local.set $18
+                                          local.get $5
+                                          i32.const 32
+                                          i32.or
+                                          i32.const 102
+                                          i32.eq
+                                          if ;; label = @20
+                                            block ;; label = @21
+                                              i32.const 0
+                                              local.set $13
+                                              local.get $1
+                                              local.get $18
+                                              local.get $9
+                                              i32.sub
+                                              local.tee $9
+                                              i32.const 0
+                                              i32.lt_s
+                                              if (result i32) ;; label = @22
+                                                i32.const 0
+                                                local.tee $9
+                                              else
+                                                local.get $9
+                                              end
+                                              i32.ge_s
+                                              if ;; label = @22
+                                                local.get $9
+                                                local.set $1
+                                              end
+                                            end
+                                          else
+                                            block ;; label = @21
+                                              i32.const 0
+                                              local.set $13
+                                              local.get $1
+                                              local.get $18
+                                              local.get $6
+                                              i32.add
+                                              local.get $9
+                                              i32.sub
+                                              local.tee $9
+                                              i32.const 0
+                                              i32.lt_s
+                                              if (result i32) ;; label = @22
+                                                i32.const 0
+                                                local.tee $9
+                                              else
+                                                local.get $9
+                                              end
+                                              i32.ge_s
+                                              if ;; label = @22
+                                                local.get $9
+                                                local.set $1
+                                              end
+                                            end
+                                          end
+                                        end
+                                      else
+                                        block ;; label = @19
+                                          local.get $12
+                                          i32.const 8
+                                          i32.and
+                                          local.set $13
+                                          local.get $18
+                                          local.set $1
+                                          local.get $9
+                                          local.set $5
+                                        end
+                                      end
+                                    end
+                                    local.get $5
+                                    i32.const 32
+                                    i32.or
+                                    i32.const 102
+                                    i32.eq
+                                    local.tee $25
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        i32.const 0
+                                        local.set $9
+                                        local.get $6
+                                        i32.const 0
+                                        i32.le_s
+                                        if ;; label = @19
+                                          i32.const 0
+                                          local.set $6
+                                        end
+                                      end
+                                    else
+                                      block ;; label = @18
+                                        local.get $28
+                                        local.get $6
+                                        i32.const 0
+                                        i32.lt_s
+                                        if (result i32) ;; label = @19
+                                          local.get $32
+                                        else
+                                          local.get $6
+                                        end
+                                        i64.extend_i32_s
+                                        local.get $33
+                                        call $23
+                                        local.tee $9
+                                        i32.sub
+                                        i32.const 2
+                                        i32.lt_s
+                                        if ;; label = @19
+                                          loop $label$229 ;; label = @20
+                                            local.get $9
+                                            i32.const -1
+                                            i32.add
+                                            local.tee $9
+                                            i32.const 48
+                                            i32.store8
+                                            local.get $28
+                                            local.get $9
+                                            i32.sub
+                                            i32.const 2
+                                            i32.lt_s
+                                            br_if 0 (;@20;)
+                                          end
+                                        end
+                                        local.get $9
+                                        i32.const -1
+                                        i32.add
+                                        local.get $6
+                                        i32.const 31
+                                        i32.shr_s
+                                        i32.const 2
+                                        i32.and
+                                        i32.const 43
+                                        i32.add
+                                        i32.store8
+                                        local.get $9
+                                        i32.const -2
+                                        i32.add
+                                        local.tee $6
+                                        local.get $5
+                                        i32.store8
+                                        local.get $6
+                                        local.set $9
+                                        local.get $28
+                                        local.get $6
+                                        i32.sub
+                                        local.set $6
+                                      end
+                                    end
+                                    local.get $0
+                                    i32.const 32
+                                    local.get $10
+                                    local.get $24
+                                    i32.const 1
+                                    i32.add
+                                    local.get $1
+                                    i32.add
+                                    local.get $1
+                                    local.get $13
+                                    i32.or
+                                    local.tee $29
+                                    i32.const 0
+                                    i32.ne
+                                    i32.add
+                                    local.get $6
+                                    i32.add
+                                    local.tee $18
+                                    local.get $12
+                                    call $25
+                                    local.get $0
+                                    i32.load
+                                    i32.const 32
+                                    i32.and
+                                    i32.eqz
+                                    if ;; label = @17
+                                      local.get $26
+                                      local.get $24
+                                      local.get $0
+                                      call $21
+                                      drop
+                                    end
+                                    local.get $0
+                                    i32.const 48
+                                    local.get $10
+                                    local.get $18
+                                    local.get $12
+                                    i32.const 65536
+                                    i32.xor
+                                    call $25
+                                    block $label$231 ;; label = @17
+                                      local.get $25
+                                      if ;; label = @18
+                                        block ;; label = @19
+                                          local.get $14
+                                          local.get $7
+                                          i32.gt_u
+                                          if (result i32) ;; label = @20
+                                            local.get $7
+                                          else
+                                            local.get $14
+                                          end
+                                          local.tee $9
+                                          local.set $6
+                                          loop $label$235 ;; label = @20
+                                            local.get $6
+                                            i32.load
+                                            i64.extend_i32_u
+                                            local.get $31
+                                            call $23
+                                            local.set $5
+                                            block $label$236 ;; label = @21
+                                              local.get $6
+                                              local.get $9
+                                              i32.eq
+                                              if ;; label = @22
+                                                block ;; label = @23
+                                                  local.get $5
+                                                  local.get $31
+                                                  i32.ne
+                                                  br_if 2 (;@21;)
+                                                  local.get $34
+                                                  i32.const 48
+                                                  i32.store8
+                                                  local.get $34
+                                                  local.set $5
+                                                end
+                                              else
+                                                block ;; label = @23
+                                                  local.get $5
+                                                  local.get $19
+                                                  i32.le_u
+                                                  br_if 2 (;@21;)
+                                                  local.get $19
+                                                  i32.const 48
+                                                  local.get $5
+                                                  local.get $27
+                                                  i32.sub
+                                                  call $46
+                                                  drop
+                                                  loop $label$239 ;; label = @24
+                                                    local.get $5
+                                                    i32.const -1
+                                                    i32.add
+                                                    local.tee $5
+                                                    local.get $19
+                                                    i32.gt_u
+                                                    br_if 0 (;@24;)
+                                                  end
+                                                end
+                                              end
+                                            end
+                                            local.get $0
+                                            i32.load
+                                            i32.const 32
+                                            i32.and
+                                            i32.eqz
+                                            if ;; label = @21
+                                              local.get $5
+                                              local.get $41
+                                              local.get $5
+                                              i32.sub
+                                              local.get $0
+                                              call $21
+                                              drop
+                                            end
+                                            local.get $6
+                                            i32.const 4
+                                            i32.add
+                                            local.tee $5
+                                            local.get $7
+                                            i32.le_u
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                local.get $5
+                                                local.set $6
+                                                br 2 (;@20;)
+                                              end
+                                            end
+                                          end
+                                          block $label$242 ;; label = @20
+                                            local.get $29
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                local.get $0
+                                                i32.load
+                                                i32.const 32
+                                                i32.and
+                                                br_if 2 (;@20;)
+                                                i32.const 2231
+                                                i32.const 1
+                                                local.get $0
+                                                call $21
+                                                drop
+                                              end
+                                            end
+                                          end
+                                          local.get $1
+                                          i32.const 0
+                                          i32.gt_s
+                                          local.get $5
+                                          local.get $8
+                                          i32.lt_u
+                                          i32.and
+                                          if ;; label = @20
+                                            loop $label$245 ;; label = @21
+                                              local.get $5
+                                              i32.load
+                                              i64.extend_i32_u
+                                              local.get $31
+                                              call $23
+                                              local.tee $7
+                                              local.get $19
+                                              i32.gt_u
+                                              if ;; label = @22
+                                                block ;; label = @23
+                                                  local.get $19
+                                                  i32.const 48
+                                                  local.get $7
+                                                  local.get $27
+                                                  i32.sub
+                                                  call $46
+                                                  drop
+                                                  loop $label$247 ;; label = @24
+                                                    local.get $7
+                                                    i32.const -1
+                                                    i32.add
+                                                    local.tee $7
+                                                    local.get $19
+                                                    i32.gt_u
+                                                    br_if 0 (;@24;)
+                                                  end
+                                                end
+                                              end
+                                              local.get $0
+                                              i32.load
+                                              i32.const 32
+                                              i32.and
+                                              i32.eqz
+                                              if ;; label = @22
+                                                local.get $7
+                                                local.get $1
+                                                i32.const 9
+                                                i32.gt_s
+                                                if (result i32) ;; label = @23
+                                                  i32.const 9
+                                                else
+                                                  local.get $1
+                                                end
+                                                local.get $0
+                                                call $21
+                                                drop
+                                              end
+                                              local.get $1
+                                              i32.const -9
+                                              i32.add
+                                              local.set $7
+                                              local.get $1
+                                              i32.const 9
+                                              i32.gt_s
+                                              local.get $5
+                                              i32.const 4
+                                              i32.add
+                                              local.tee $5
+                                              local.get $8
+                                              i32.lt_u
+                                              i32.and
+                                              if ;; label = @22
+                                                block ;; label = @23
+                                                  local.get $7
+                                                  local.set $1
+                                                  br 2 (;@21;)
+                                                end
+                                              else
+                                                local.get $7
+                                                local.set $1
+                                              end
+                                            end
+                                          end
+                                          local.get $0
+                                          i32.const 48
+                                          local.get $1
+                                          i32.const 9
+                                          i32.add
+                                          i32.const 9
+                                          i32.const 0
+                                          call $25
+                                        end
+                                      else
+                                        block ;; label = @19
+                                          local.get $14
+                                          i32.const 4
+                                          i32.add
+                                          local.set $5
+                                          local.get $22
+                                          i32.eqz
+                                          if ;; label = @20
+                                            local.get $5
+                                            local.set $8
+                                          end
+                                          local.get $1
+                                          i32.const -1
+                                          i32.gt_s
+                                          if ;; label = @20
+                                            block ;; label = @21
+                                              local.get $13
+                                              i32.eqz
+                                              local.set $13
+                                              local.get $14
+                                              local.set $7
+                                              local.get $1
+                                              local.set $5
+                                              loop $label$256 ;; label = @22
+                                                local.get $7
+                                                i32.load
+                                                i64.extend_i32_u
+                                                local.get $31
+                                                call $23
+                                                local.tee $1
+                                                local.get $31
+                                                i32.eq
+                                                if ;; label = @23
+                                                  block ;; label = @24
+                                                    local.get $34
+                                                    i32.const 48
+                                                    i32.store8
+                                                    local.get $34
+                                                    local.set $1
+                                                  end
+                                                end
+                                                block $label$258 ;; label = @23
+                                                  local.get $7
+                                                  local.get $14
+                                                  i32.eq
+                                                  if ;; label = @24
+                                                    block ;; label = @25
+                                                      local.get $0
+                                                      i32.load
+                                                      i32.const 32
+                                                      i32.and
+                                                      i32.eqz
+                                                      if ;; label = @26
+                                                        local.get $1
+                                                        i32.const 1
+                                                        local.get $0
+                                                        call $21
+                                                        drop
+                                                      end
+                                                      local.get $1
+                                                      i32.const 1
+                                                      i32.add
+                                                      local.set $1
+                                                      local.get $13
+                                                      local.get $5
+                                                      i32.const 1
+                                                      i32.lt_s
+                                                      i32.and
+                                                      br_if 2 (;@23;)
+                                                      local.get $0
+                                                      i32.load
+                                                      i32.const 32
+                                                      i32.and
+                                                      br_if 2 (;@23;)
+                                                      i32.const 2231
+                                                      i32.const 1
+                                                      local.get $0
+                                                      call $21
+                                                      drop
+                                                    end
+                                                  else
+                                                    block ;; label = @25
+                                                      local.get $1
+                                                      local.get $19
+                                                      i32.le_u
+                                                      br_if 2 (;@23;)
+                                                      local.get $19
+                                                      i32.const 48
+                                                      local.get $1
+                                                      local.get $43
+                                                      i32.add
+                                                      call $46
+                                                      drop
+                                                      loop $label$262 ;; label = @26
+                                                        local.get $1
+                                                        i32.const -1
+                                                        i32.add
+                                                        local.tee $1
+                                                        local.get $19
+                                                        i32.gt_u
+                                                        br_if 0 (;@26;)
+                                                      end
+                                                    end
+                                                  end
+                                                end
+                                                local.get $41
+                                                local.get $1
+                                                i32.sub
+                                                local.set $6
+                                                local.get $0
+                                                i32.load
+                                                i32.const 32
+                                                i32.and
+                                                i32.eqz
+                                                if ;; label = @23
+                                                  local.get $1
+                                                  local.get $5
+                                                  local.get $6
+                                                  i32.gt_s
+                                                  if (result i32) ;; label = @24
+                                                    local.get $6
+                                                  else
+                                                    local.get $5
+                                                  end
+                                                  local.get $0
+                                                  call $21
+                                                  drop
+                                                end
+                                                local.get $7
+                                                i32.const 4
+                                                i32.add
+                                                local.tee $7
+                                                local.get $8
+                                                i32.lt_u
+                                                local.get $5
+                                                local.get $6
+                                                i32.sub
+                                                local.tee $5
+                                                i32.const -1
+                                                i32.gt_s
+                                                i32.and
+                                                br_if 0 (;@22;)
+                                                local.get $5
+                                                local.set $1
+                                              end
+                                            end
+                                          end
+                                          local.get $0
+                                          i32.const 48
+                                          local.get $1
+                                          i32.const 18
+                                          i32.add
+                                          i32.const 18
+                                          i32.const 0
+                                          call $25
+                                          local.get $0
+                                          i32.load
+                                          i32.const 32
+                                          i32.and
+                                          br_if 2 (;@17;)
+                                          local.get $9
+                                          local.get $28
+                                          local.get $9
+                                          i32.sub
+                                          local.get $0
+                                          call $21
+                                          drop
+                                        end
+                                      end
+                                    end
+                                    local.get $0
+                                    i32.const 32
+                                    local.get $10
+                                    local.get $18
+                                    local.get $12
+                                    i32.const 8192
+                                    i32.xor
+                                    call $25
+                                    local.get $18
+                                    local.get $10
+                                    i32.ge_s
+                                    if ;; label = @17
+                                      local.get $18
+                                      local.set $10
+                                    end
+                                  end
+                                else
+                                  block ;; label = @16
+                                    local.get $0
+                                    i32.const 32
+                                    local.get $10
+                                    local.get $52
+                                    local.get $52
+                                    f64.ne
+                                    i32.const 0
+                                    i32.or
+                                    local.tee $6
+                                    if (result i32) ;; label = @17
+                                      i32.const 0
+                                      local.tee $24
+                                    else
+                                      local.get $24
+                                    end
+                                    i32.const 3
+                                    i32.add
+                                    local.tee $8
+                                    local.get $7
+                                    call $25
+                                    local.get $0
+                                    i32.load
+                                    local.tee $1
+                                    i32.const 32
+                                    i32.and
+                                    i32.eqz
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        local.get $26
+                                        local.get $24
+                                        local.get $0
+                                        call $21
+                                        drop
+                                        local.get $0
+                                        i32.load
+                                        local.set $1
+                                      end
+                                    end
+                                    local.get $9
+                                    i32.const 32
+                                    i32.and
+                                    i32.const 0
+                                    i32.ne
+                                    local.tee $5
+                                    if (result i32) ;; label = @17
+                                      i32.const 2215
+                                    else
+                                      i32.const 2219
+                                    end
+                                    local.set $7
+                                    local.get $5
+                                    if (result i32) ;; label = @17
+                                      i32.const 2223
+                                    else
+                                      i32.const 2227
+                                    end
+                                    local.set $5
+                                    local.get $6
+                                    i32.eqz
+                                    if ;; label = @17
+                                      local.get $7
+                                      local.set $5
+                                    end
+                                    local.get $1
+                                    i32.const 32
+                                    i32.and
+                                    i32.eqz
+                                    if ;; label = @17
+                                      local.get $5
+                                      i32.const 3
+                                      local.get $0
+                                      call $21
+                                      drop
+                                    end
+                                    local.get $0
+                                    i32.const 32
+                                    local.get $10
+                                    local.get $8
+                                    local.get $12
+                                    i32.const 8192
+                                    i32.xor
+                                    call $25
+                                    local.get $8
+                                    local.get $10
+                                    i32.ge_s
+                                    if ;; label = @17
+                                      local.get $8
+                                      local.set $10
+                                    end
+                                  end
+                                end
+                              end
+                              local.get $11
+                              local.set $1
+                              br 9 (;@4;)
+                            end
+                            local.get $5
+                            local.set $7
+                            i32.const 0
+                            local.set $6
+                            i32.const 2179
+                            local.set $8
+                            local.get $21
+                            local.set $5
+                            br 6 (;@6;)
+                          end
+                          local.get $9
+                          i32.const 32
+                          i32.and
+                          local.set $7
+                          local.get $16
+                          i64.load
+                          local.tee $50
+                          i64.const 0
+                          i64.eq
+                          if (result i32) ;; label = @12
+                            block (result i32) ;; label = @13
+                              i64.const 0
+                              local.set $50
+                              local.get $21
+                            end
+                          else
+                            block (result i32) ;; label = @13
+                              local.get $21
+                              local.set $1
+                              loop $label$280 ;; label = @14
+                                local.get $1
+                                i32.const -1
+                                i32.add
+                                local.tee $1
+                                local.get $50
+                                i32.wrap_i64
+                                i32.const 15
+                                i32.and
+                                i32.const 2163
+                                i32.add
+                                i32.load8_u
+                                local.get $7
+                                i32.or
+                                i32.store8
+                                local.get $50
+                                i64.const 4
+                                i64.shr_u
+                                local.tee $50
+                                i64.const 0
+                                i64.ne
+                                br_if 0 (;@14;)
+                              end
+                              local.get $16
+                              i64.load
+                              local.set $50
+                              local.get $1
+                            end
+                          end
+                          local.set $7
+                          local.get $9
+                          i32.const 4
+                          i32.shr_s
+                          i32.const 2179
+                          i32.add
+                          local.set $8
+                          local.get $12
+                          i32.const 8
+                          i32.and
+                          i32.eqz
+                          local.get $50
+                          i64.const 0
+                          i64.eq
+                          i32.or
+                          local.tee $1
+                          if ;; label = @12
+                            i32.const 2179
+                            local.set $8
+                          end
+                          local.get $1
+                          if (result i32) ;; label = @12
+                            i32.const 0
+                          else
+                            i32.const 2
+                          end
+                          local.set $6
+                          br 4 (;@7;)
+                        end
+                        local.get $50
+                        local.get $21
+                        call $23
+                        local.set $7
+                        br 3 (;@7;)
+                      end
+                      local.get $1
+                      i32.const 0
+                      local.get $5
+                      call $17
+                      local.tee $13
+                      i32.eqz
+                      local.set $14
+                      local.get $13
+                      local.get $1
+                      i32.sub
+                      local.set $8
+                      local.get $1
+                      local.get $5
+                      i32.add
+                      local.set $9
+                      local.get $7
+                      local.set $12
+                      local.get $14
+                      if (result i32) ;; label = @10
+                        local.get $5
+                      else
+                        local.get $8
+                      end
+                      local.set $7
+                      i32.const 0
+                      local.set $6
+                      i32.const 2179
+                      local.set $8
+                      local.get $14
+                      if (result i32) ;; label = @10
+                        local.get $9
+                      else
+                        local.get $13
+                      end
+                      local.set $5
+                      br 3 (;@6;)
+                    end
+                    i32.const 0
+                    local.set $1
+                    i32.const 0
+                    local.set $5
+                    local.get $7
+                    local.set $8
+                    loop $label$288 ;; label = @9
+                      block $label$289 ;; label = @10
+                        local.get $8
+                        i32.load
+                        local.tee $9
+                        i32.eqz
+                        br_if 0 (;@10;)
+                        local.get $36
+                        local.get $9
+                        call $26
+                        local.tee $5
+                        i32.const 0
+                        i32.lt_s
+                        local.get $5
+                        local.get $6
+                        local.get $1
+                        i32.sub
+                        i32.gt_u
+                        i32.or
+                        br_if 0 (;@10;)
+                        local.get $8
+                        i32.const 4
+                        i32.add
+                        local.set $8
+                        local.get $6
+                        local.get $5
+                        local.get $1
+                        i32.add
+                        local.tee $1
+                        i32.gt_u
+                        br_if 1 (;@9;)
+                      end
+                    end
+                    local.get $5
+                    i32.const 0
+                    i32.lt_s
+                    if ;; label = @9
+                      block ;; label = @10
+                        i32.const -1
+                        local.set $15
+                        br 5 (;@5;)
+                      end
+                    end
+                    local.get $0
+                    i32.const 32
+                    local.get $10
+                    local.get $1
+                    local.get $12
+                    call $25
+                    local.get $1
+                    if ;; label = @9
+                      block ;; label = @10
+                        i32.const 0
+                        local.set $5
+                        loop $label$292 ;; label = @11
+                          local.get $7
+                          i32.load
+                          local.tee $8
+                          i32.eqz
+                          br_if 3 (;@8;)
+                          local.get $36
+                          local.get $8
+                          call $26
+                          local.tee $8
+                          local.get $5
+                          i32.add
+                          local.tee $5
+                          local.get $1
+                          i32.gt_s
+                          br_if 3 (;@8;)
+                          local.get $0
+                          i32.load
+                          i32.const 32
+                          i32.and
+                          i32.eqz
+                          if ;; label = @12
+                            local.get $36
+                            local.get $8
+                            local.get $0
+                            call $21
+                            drop
+                          end
+                          local.get $7
+                          i32.const 4
+                          i32.add
+                          local.set $7
+                          local.get $5
+                          local.get $1
+                          i32.lt_u
+                          br_if 0 (;@11;)
+                          br 3 (;@8;)
+                        end
+                      end
+                    else
+                      block ;; label = @10
+                        i32.const 0
+                        local.set $1
+                        br 2 (;@8;)
+                      end
+                    end
+                  end
+                  local.get $0
+                  i32.const 32
+                  local.get $10
+                  local.get $1
+                  local.get $12
+                  i32.const 8192
+                  i32.xor
+                  call $25
+                  local.get $10
+                  local.get $1
+                  i32.le_s
+                  if ;; label = @8
+                    local.get $1
+                    local.set $10
+                  end
+                  local.get $11
+                  local.set $1
+                  br 3 (;@4;)
+                end
+                local.get $12
+                i32.const -65537
+                i32.and
+                local.set $1
+                local.get $5
+                i32.const -1
+                i32.gt_s
+                if ;; label = @7
+                  local.get $1
+                  local.set $12
+                end
+                local.get $5
+                local.get $16
+                i64.load
+                i64.const 0
+                i64.ne
+                local.tee $9
+                i32.or
+                if (result i32) ;; label = @7
+                  block (result i32) ;; label = @8
+                    local.get $7
+                    local.set $1
+                    local.get $5
+                    local.get $9
+                    i32.const 1
+                    i32.and
+                    i32.const 1
+                    i32.xor
+                    local.get $38
+                    local.get $7
+                    i32.sub
+                    i32.add
+                    local.tee $7
+                    i32.gt_s
+                    if ;; label = @9
+                      local.get $5
+                      local.set $7
+                    end
+                    local.get $21
+                  end
+                else
+                  block (result i32) ;; label = @8
+                    local.get $21
+                    local.set $1
+                    i32.const 0
+                    local.set $7
+                    local.get $21
+                  end
+                end
+                local.set $5
+              end
+              local.get $0
+              i32.const 32
+              local.get $10
+              local.get $7
+              local.get $5
+              local.get $1
+              i32.sub
+              local.tee $9
+              i32.lt_s
+              if (result i32) ;; label = @6
+                local.get $9
+                local.tee $7
+              else
+                local.get $7
+              end
+              local.get $6
+              i32.add
+              local.tee $5
+              i32.lt_s
+              if (result i32) ;; label = @6
+                local.get $5
+                local.tee $10
+              else
+                local.get $10
+              end
+              local.get $5
+              local.get $12
+              call $25
+              local.get $0
+              i32.load
+              i32.const 32
+              i32.and
+              i32.eqz
+              if ;; label = @6
+                local.get $8
+                local.get $6
+                local.get $0
+                call $21
+                drop
+              end
+              local.get $0
+              i32.const 48
+              local.get $10
+              local.get $5
+              local.get $12
+              i32.const 65536
+              i32.xor
+              call $25
+              local.get $0
+              i32.const 48
+              local.get $7
+              local.get $9
+              i32.const 0
+              call $25
+              local.get $0
+              i32.load
+              i32.const 32
+              i32.and
+              i32.eqz
+              if ;; label = @6
+                local.get $1
+                local.get $9
+                local.get $0
+                call $21
+                drop
+              end
+              local.get $0
+              i32.const 32
+              local.get $10
+              local.get $5
+              local.get $12
+              i32.const 8192
+              i32.xor
+              call $25
+              local.get $11
+              local.set $1
+              br 1 (;@4;)
+            end
+          end
+          br 1 (;@2;)
+        end
+        local.get $0
+        i32.eqz
+        if ;; label = @3
+          local.get $17
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 1
+              local.set $0
+              loop $label$308 ;; label = @6
+                local.get $4
+                local.get $0
+                i32.const 2
+                i32.shl
+                i32.add
+                i32.load
+                local.tee $1
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $3
+                    local.get $0
+                    i32.const 3
+                    i32.shl
+                    i32.add
+                    local.get $1
+                    local.get $2
+                    call $22
+                    local.get $0
+                    i32.const 1
+                    i32.add
+                    local.tee $0
+                    i32.const 10
+                    i32.lt_s
+                    br_if 2 (;@6;)
+                    i32.const 1
+                    local.set $15
+                    br 6 (;@2;)
+                  end
+                end
+              end
+              loop $label$310 ;; label = @6
+                local.get $4
+                local.get $0
+                i32.const 2
+                i32.shl
+                i32.add
+                i32.load
+                if ;; label = @7
+                  block ;; label = @8
+                    i32.const -1
+                    local.set $15
+                    br 6 (;@2;)
+                  end
+                end
+                local.get $0
+                i32.const 1
+                i32.add
+                local.tee $0
+                i32.const 10
+                i32.lt_s
+                br_if 0 (;@6;)
+                i32.const 1
+                local.set $15
+              end
+            end
+          else
+            i32.const 0
+            local.set $15
+          end
+        end
+      end
+      local.get $23
+      global.set $global$1
+      local.get $15
+    end
+  )
+  (func $20 (;33;) (type $2) (param $0 i32) (result i32)
+    i32.const 0
+  )
+  (func $21 (;34;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32)
+    block $label$1 (result i32) ;; label = @1
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          local.get $2
+          i32.const 16
+          i32.add
+          local.tee $4
+          i32.load
+          local.tee $3
+          br_if 0 (;@3;)
+          local.get $2
+          call $30
+          if ;; label = @4
+            i32.const 0
+            local.set $3
+          else
+            block ;; label = @5
+              local.get $4
+              i32.load
+              local.set $3
+              br 2 (;@3;)
+            end
+          end
+          br 1 (;@2;)
+        end
+        local.get $3
+        local.get $2
+        i32.const 20
+        i32.add
+        local.tee $5
+        i32.load
+        local.tee $4
+        i32.sub
+        local.get $1
+        i32.lt_u
+        if ;; label = @3
+          block ;; label = @4
+            local.get $2
+            local.get $0
+            local.get $1
+            local.get $2
+            i32.load offset=36
+            i32.const 3
+            i32.and
+            i32.const 2
+            i32.add
+            call_indirect (type $0)
+            local.set $3
+            br 2 (;@2;)
+          end
+        end
+        block $label$7 (result i32) ;; label = @3
+          local.get $2
+          i32.load8_s offset=75
+          i32.const -1
+          i32.gt_s
+          if (result i32) ;; label = @4
+            block (result i32) ;; label = @5
+              local.get $1
+              local.set $3
+              loop $label$9 ;; label = @6
+                i32.const 0
+                local.get $3
+                i32.eqz
+                br_if 3 (;@3;)
+                drop
+                local.get $0
+                local.get $3
+                i32.const -1
+                i32.add
+                local.tee $6
+                i32.add
+                i32.load8_s
+                i32.const 10
+                i32.ne
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $6
+                    local.set $3
+                    br 2 (;@6;)
+                  end
+                end
+              end
+              local.get $2
+              local.get $0
+              local.get $3
+              local.get $2
+              i32.load offset=36
+              i32.const 3
+              i32.and
+              i32.const 2
+              i32.add
+              call_indirect (type $0)
+              local.get $3
+              i32.lt_u
+              br_if 3 (;@2;)
+              local.get $5
+              i32.load
+              local.set $4
+              local.get $1
+              local.get $3
+              i32.sub
+              local.set $1
+              local.get $0
+              local.get $3
+              i32.add
+              local.set $0
+              local.get $3
+            end
+          else
+            i32.const 0
+          end
+        end
+        local.set $2
+        local.get $4
+        local.get $0
+        local.get $1
+        call $47
+        drop
+        local.get $5
+        local.get $5
+        i32.load
+        local.get $1
+        i32.add
+        i32.store
+        local.get $2
+        local.get $1
+        i32.add
+        local.set $3
+      end
+      local.get $3
+    end
+  )
+  (func $22 (;35;) (type $8) (param $0 i32) (param $1 i32) (param $2 i32)
+    (local $3 i32) (local $4 i64) (local $5 f64)
+    block $label$1 ;; label = @1
+      local.get $1
+      i32.const 20
+      i32.le_u
+      if ;; label = @2
+        block $label$3 ;; label = @3
+          block $label$4 ;; label = @4
+            block $label$5 ;; label = @5
+              block $label$6 ;; label = @6
+                block $label$7 ;; label = @7
+                  block $label$8 ;; label = @8
+                    block $label$9 ;; label = @9
+                      block $label$10 ;; label = @10
+                        block $label$11 ;; label = @11
+                          block $label$12 ;; label = @12
+                            block $label$13 ;; label = @13
+                              local.get $1
+                              i32.const 9
+                              i32.sub
+                              br_table 0 (;@13;) 1 (;@12;) 2 (;@11;) 3 (;@10;) 4 (;@9;) 5 (;@8;) 6 (;@7;) 7 (;@6;) 8 (;@5;) 9 (;@4;) 10 (;@3;)
+                            end
+                            local.get $2
+                            i32.load
+                            i32.const 3
+                            i32.add
+                            i32.const -4
+                            i32.and
+                            local.tee $1
+                            i32.load
+                            local.set $3
+                            local.get $2
+                            local.get $1
+                            i32.const 4
+                            i32.add
+                            i32.store
+                            local.get $0
+                            local.get $3
+                            i32.store
+                            br 11 (;@1;)
+                          end
+                          local.get $2
+                          i32.load
+                          i32.const 3
+                          i32.add
+                          i32.const -4
+                          i32.and
+                          local.tee $1
+                          i32.load
+                          local.set $3
+                          local.get $2
+                          local.get $1
+                          i32.const 4
+                          i32.add
+                          i32.store
+                          local.get $0
+                          local.get $3
+                          i64.extend_i32_s
+                          i64.store
+                          br 10 (;@1;)
+                        end
+                        local.get $2
+                        i32.load
+                        i32.const 3
+                        i32.add
+                        i32.const -4
+                        i32.and
+                        local.tee $1
+                        i32.load
+                        local.set $3
+                        local.get $2
+                        local.get $1
+                        i32.const 4
+                        i32.add
+                        i32.store
+                        local.get $0
+                        local.get $3
+                        i64.extend_i32_u
+                        i64.store
+                        br 9 (;@1;)
+                      end
+                      local.get $2
+                      i32.load
+                      i32.const 7
+                      i32.add
+                      i32.const -8
+                      i32.and
+                      local.tee $1
+                      i64.load
+                      local.set $4
+                      local.get $2
+                      local.get $1
+                      i32.const 8
+                      i32.add
+                      i32.store
+                      local.get $0
+                      local.get $4
+                      i64.store
+                      br 8 (;@1;)
+                    end
+                    local.get $2
+                    i32.load
+                    i32.const 3
+                    i32.add
+                    i32.const -4
+                    i32.and
+                    local.tee $1
+                    i32.load
+                    local.set $3
+                    local.get $2
+                    local.get $1
+                    i32.const 4
+                    i32.add
+                    i32.store
+                    local.get $0
+                    local.get $3
+                    i32.const 65535
+                    i32.and
+                    i32.const 16
+                    i32.shl
+                    i32.const 16
+                    i32.shr_s
+                    i64.extend_i32_s
+                    i64.store
+                    br 7 (;@1;)
+                  end
+                  local.get $2
+                  i32.load
+                  i32.const 3
+                  i32.add
+                  i32.const -4
+                  i32.and
+                  local.tee $1
+                  i32.load
+                  local.set $3
+                  local.get $2
+                  local.get $1
+                  i32.const 4
+                  i32.add
+                  i32.store
+                  local.get $0
+                  local.get $3
+                  i32.const 65535
+                  i32.and
+                  i64.extend_i32_u
+                  i64.store
+                  br 6 (;@1;)
+                end
+                local.get $2
+                i32.load
+                i32.const 3
+                i32.add
+                i32.const -4
+                i32.and
+                local.tee $1
+                i32.load
+                local.set $3
+                local.get $2
+                local.get $1
+                i32.const 4
+                i32.add
+                i32.store
+                local.get $0
+                local.get $3
+                i32.const 255
+                i32.and
+                i32.const 24
+                i32.shl
+                i32.const 24
+                i32.shr_s
+                i64.extend_i32_s
+                i64.store
+                br 5 (;@1;)
+              end
+              local.get $2
+              i32.load
+              i32.const 3
+              i32.add
+              i32.const -4
+              i32.and
+              local.tee $1
+              i32.load
+              local.set $3
+              local.get $2
+              local.get $1
+              i32.const 4
+              i32.add
+              i32.store
+              local.get $0
+              local.get $3
+              i32.const 255
+              i32.and
+              i64.extend_i32_u
+              i64.store
+              br 4 (;@1;)
+            end
+            local.get $2
+            i32.load
+            i32.const 7
+            i32.add
+            i32.const -8
+            i32.and
+            local.tee $1
+            f64.load
+            local.set $5
+            local.get $2
+            local.get $1
+            i32.const 8
+            i32.add
+            i32.store
+            local.get $0
+            local.get $5
+            f64.store
+            br 3 (;@1;)
+          end
+          local.get $2
+          i32.load
+          i32.const 7
+          i32.add
+          i32.const -8
+          i32.and
+          local.tee $1
+          f64.load
+          local.set $5
+          local.get $2
+          local.get $1
+          i32.const 8
+          i32.add
+          i32.store
+          local.get $0
+          local.get $5
+          f64.store
+        end
+      end
+    end
+  )
+  (func $23 (;36;) (type $9) (param $0 i64) (param $1 i32) (result i32)
+    (local $2 i32) (local $3 i32) (local $4 i64)
+    block $label$1 (result i32) ;; label = @1
+      local.get $0
+      i32.wrap_i64
+      local.set $2
+      local.get $0
+      i64.const 4294967295
+      i64.gt_u
+      if ;; label = @2
+        block ;; label = @3
+          loop $label$3 ;; label = @4
+            local.get $1
+            i32.const -1
+            i32.add
+            local.tee $1
+            local.get $0
+            i64.const 10
+            i64.rem_u
+            i64.const 48
+            i64.or
+            i64.store8
+            local.get $0
+            i64.const 10
+            i64.div_u
+            local.set $4
+            local.get $0
+            i64.const 42949672959
+            i64.gt_u
+            if ;; label = @5
+              block ;; label = @6
+                local.get $4
+                local.set $0
+                br 2 (;@4;)
+              end
+            end
+          end
+          local.get $4
+          i32.wrap_i64
+          local.set $2
+        end
+      end
+      local.get $2
+      if ;; label = @2
+        loop $label$6 ;; label = @3
+          local.get $1
+          i32.const -1
+          i32.add
+          local.tee $1
+          local.get $2
+          i32.const 10
+          i32.rem_u
+          i32.const 48
+          i32.or
+          i32.store8
+          local.get $2
+          i32.const 10
+          i32.div_u
+          local.set $3
+          local.get $2
+          i32.const 10
+          i32.ge_u
+          if ;; label = @4
+            block ;; label = @5
+              local.get $3
+              local.set $2
+              br 2 (;@3;)
+            end
+          end
+        end
+      end
+      local.get $1
+    end
+  )
+  (func $24 (;37;) (type $2) (param $0 i32) (result i32)
+    (local $1 i32) (local $2 i32)
+    block $label$1 (result i32) ;; label = @1
+      i32.const 0
+      local.set $1
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          block $label$4 ;; label = @4
+            loop $label$5 ;; label = @5
+              local.get $1
+              i32.const 2233
+              i32.add
+              i32.load8_u
+              local.get $0
+              i32.eq
+              br_if 1 (;@4;)
+              local.get $1
+              i32.const 1
+              i32.add
+              local.tee $1
+              i32.const 87
+              i32.ne
+              br_if 0 (;@5;)
+              i32.const 87
+              local.set $1
+              i32.const 2321
+              local.set $0
+              br 2 (;@3;)
+            end
+          end
+          local.get $1
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 2321
+              local.set $0
+              br 2 (;@3;)
+            end
+          else
+            i32.const 2321
+            local.set $0
+          end
+          br 1 (;@2;)
+        end
+        loop $label$8 ;; label = @3
+          local.get $0
+          local.set $2
+          loop $label$9 ;; label = @4
+            local.get $2
+            i32.const 1
+            i32.add
+            local.set $0
+            local.get $2
+            i32.load8_s
+            if ;; label = @5
+              block ;; label = @6
+                local.get $0
+                local.set $2
+                br 2 (;@4;)
+              end
+            end
+          end
+          local.get $1
+          i32.const -1
+          i32.add
+          local.tee $1
+          br_if 0 (;@3;)
+        end
+      end
+      local.get $0
+    end
+  )
+  (func $25 (;38;) (type $10) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32)
+    (local $5 i32) (local $6 i32) (local $7 i32)
+    block $label$1 ;; label = @1
+      global.get $global$1
+      local.set $7
+      global.get $global$1
+      i32.const 256
+      i32.add
+      global.set $global$1
+      local.get $7
+      local.set $6
+      block $label$2 ;; label = @2
+        local.get $2
+        local.get $3
+        i32.gt_s
+        local.get $4
+        i32.const 73728
+        i32.and
+        i32.eqz
+        i32.and
+        if ;; label = @3
+          block ;; label = @4
+            local.get $6
+            local.get $1
+            local.get $2
+            local.get $3
+            i32.sub
+            local.tee $5
+            i32.const 256
+            i32.gt_u
+            if (result i32) ;; label = @5
+              i32.const 256
+            else
+              local.get $5
+            end
+            call $46
+            drop
+            local.get $0
+            i32.load
+            local.tee $1
+            i32.const 32
+            i32.and
+            i32.eqz
+            local.set $4
+            local.get $5
+            i32.const 255
+            i32.gt_u
+            if ;; label = @5
+              block ;; label = @6
+                loop $label$7 ;; label = @7
+                  local.get $4
+                  if ;; label = @8
+                    block ;; label = @9
+                      local.get $6
+                      i32.const 256
+                      local.get $0
+                      call $21
+                      drop
+                      local.get $0
+                      i32.load
+                      local.set $1
+                    end
+                  end
+                  local.get $1
+                  i32.const 32
+                  i32.and
+                  i32.eqz
+                  local.set $4
+                  local.get $5
+                  i32.const -256
+                  i32.add
+                  local.tee $5
+                  i32.const 255
+                  i32.gt_u
+                  br_if 0 (;@7;)
+                end
+                local.get $4
+                i32.eqz
+                br_if 4 (;@2;)
+                local.get $2
+                local.get $3
+                i32.sub
+                i32.const 255
+                i32.and
+                local.set $5
+              end
+            else
+              local.get $4
+              i32.eqz
+              br_if 3 (;@2;)
+            end
+            local.get $6
+            local.get $5
+            local.get $0
+            call $21
+            drop
+          end
+        end
+      end
+      local.get $7
+      global.set $global$1
+    end
+  )
+  (func $26 (;39;) (type $6) (param $0 i32) (param $1 i32) (result i32)
+    local.get $0
+    if (result i32) ;; label = @1
+      local.get $0
+      local.get $1
+      i32.const 0
+      call $29
+    else
+      i32.const 0
+    end
+  )
+  (func $27 (;40;) (type $11) (param $0 f64) (param $1 i32) (result f64)
+    local.get $0
+    local.get $1
+    call $28
+  )
+  (func $28 (;41;) (type $11) (param $0 f64) (param $1 i32) (result f64)
+    (local $2 i64) (local $3 i64)
+    block $label$1 (result f64) ;; label = @1
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          block $label$4 ;; label = @4
+            block $label$5 ;; label = @5
+              local.get $0
+              i64.reinterpret_f64
+              local.tee $2
+              i64.const 52
+              i64.shr_u
+              local.tee $3
+              i32.wrap_i64
+              i32.const 65535
+              i32.and
+              i32.const 2047
+              i32.and
+              i32.const 16
+              i32.shl
+              i32.const 16
+              i32.shr_s
+              i32.const 0
+              i32.sub
+              br_table 0 (;@5;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 1 (;@4;) 2 (;@3;)
+            end
+            local.get $1
+            local.get $0
+            f64.const 0x0p+0 (;=0;)
+            f64.ne
+            if (result i32) ;; label = @5
+              block (result i32) ;; label = @6
+                local.get $0
+                f64.const 0x1p+64 (;=18446744073709552000;)
+                f64.mul
+                local.get $1
+                call $28
+                local.set $0
+                local.get $1
+                i32.load
+                i32.const -64
+                i32.add
+              end
+            else
+              i32.const 0
+            end
+            i32.store
+            br 2 (;@2;)
+          end
+          br 1 (;@2;)
+        end
+        local.get $1
+        local.get $3
+        i32.wrap_i64
+        i32.const 2047
+        i32.and
+        i32.const -1022
+        i32.add
+        i32.store
+        local.get $2
+        i64.const -9218868437227405313
+        i64.and
+        i64.const 4602678819172646912
+        i64.or
+        f64.reinterpret_i64
+        local.set $0
+      end
+      local.get $0
+    end
+  )
+  (func $29 (;42;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    block $label$1 (result i32) ;; label = @1
+      local.get $0
+      if (result i32) ;; label = @2
+        block (result i32) ;; label = @3
+          local.get $1
+          i32.const 128
+          i32.lt_u
+          if ;; label = @4
+            block ;; label = @5
+              local.get $0
+              local.get $1
+              i32.store8
+              i32.const 1
+              br 4 (;@1;)
+            end
+          end
+          local.get $1
+          i32.const 2048
+          i32.lt_u
+          if ;; label = @4
+            block ;; label = @5
+              local.get $0
+              local.get $1
+              i32.const 6
+              i32.shr_u
+              i32.const 192
+              i32.or
+              i32.store8
+              local.get $0
+              local.get $1
+              i32.const 63
+              i32.and
+              i32.const 128
+              i32.or
+              i32.store8 offset=1
+              i32.const 2
+              br 4 (;@1;)
+            end
+          end
+          local.get $1
+          i32.const 55296
+          i32.lt_u
+          local.get $1
+          i32.const -8192
+          i32.and
+          i32.const 57344
+          i32.eq
+          i32.or
+          if ;; label = @4
+            block ;; label = @5
+              local.get $0
+              local.get $1
+              i32.const 12
+              i32.shr_u
+              i32.const 224
+              i32.or
+              i32.store8
+              local.get $0
+              local.get $1
+              i32.const 6
+              i32.shr_u
+              i32.const 63
+              i32.and
+              i32.const 128
+              i32.or
+              i32.store8 offset=1
+              local.get $0
+              local.get $1
+              i32.const 63
+              i32.and
+              i32.const 128
+              i32.or
+              i32.store8 offset=2
+              i32.const 3
+              br 4 (;@1;)
+            end
+          end
+          local.get $1
+          i32.const -65536
+          i32.add
+          i32.const 1048576
+          i32.lt_u
+          if (result i32) ;; label = @4
+            block (result i32) ;; label = @5
+              local.get $0
+              local.get $1
+              i32.const 18
+              i32.shr_u
+              i32.const 240
+              i32.or
+              i32.store8
+              local.get $0
+              local.get $1
+              i32.const 12
+              i32.shr_u
+              i32.const 63
+              i32.and
+              i32.const 128
+              i32.or
+              i32.store8 offset=1
+              local.get $0
+              local.get $1
+              i32.const 6
+              i32.shr_u
+              i32.const 63
+              i32.and
+              i32.const 128
+              i32.or
+              i32.store8 offset=2
+              local.get $0
+              local.get $1
+              i32.const 63
+              i32.and
+              i32.const 128
+              i32.or
+              i32.store8 offset=3
+              i32.const 4
+            end
+          else
+            block (result i32) ;; label = @5
+              call $12
+              i32.const 84
+              i32.store
+              i32.const -1
+            end
+          end
+        end
+      else
+        i32.const 1
+      end
+    end
+  )
+  (func $30 (;43;) (type $2) (param $0 i32) (result i32)
+    (local $1 i32) (local $2 i32)
+    block $label$1 (result i32) ;; label = @1
+      local.get $0
+      i32.const 74
+      i32.add
+      local.tee $2
+      i32.load8_s
+      local.set $1
+      local.get $2
+      local.get $1
+      i32.const 255
+      i32.add
+      local.get $1
+      i32.or
+      i32.store8
+      local.get $0
+      i32.load
+      local.tee $1
+      i32.const 8
+      i32.and
+      if (result i32) ;; label = @2
+        block (result i32) ;; label = @3
+          local.get $0
+          local.get $1
+          i32.const 32
+          i32.or
+          i32.store
+          i32.const -1
+        end
+      else
+        block (result i32) ;; label = @3
+          local.get $0
+          i32.const 0
+          i32.store offset=8
+          local.get $0
+          i32.const 0
+          i32.store offset=4
+          local.get $0
+          local.get $0
+          i32.load offset=44
+          local.tee $1
+          i32.store offset=28
+          local.get $0
+          local.get $1
+          i32.store offset=20
+          local.get $0
+          local.get $1
+          local.get $0
+          i32.load offset=48
+          i32.add
+          i32.store offset=16
+          i32.const 0
+        end
+      end
+      local.tee $0
+    end
+  )
+  (func $31 (;44;) (type $2) (param $0 i32) (result i32)
+    (local $1 i32) (local $2 i32) (local $3 i32)
+    block $label$1 (result i32) ;; label = @1
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          local.get $0
+          local.tee $2
+          i32.const 3
+          i32.and
+          i32.eqz
+          br_if 0 (;@3;)
+          local.get $2
+          local.set $1
+          loop $label$4 ;; label = @4
+            local.get $0
+            i32.load8_s
+            i32.eqz
+            if ;; label = @5
+              block ;; label = @6
+                local.get $1
+                local.set $0
+                br 4 (;@2;)
+              end
+            end
+            local.get $0
+            i32.const 1
+            i32.add
+            local.tee $0
+            local.tee $1
+            i32.const 3
+            i32.and
+            br_if 0 (;@4;)
+            br 1 (;@3;)
+          end
+        end
+        loop $label$6 ;; label = @3
+          local.get $0
+          i32.const 4
+          i32.add
+          local.set $1
+          local.get $0
+          i32.load
+          local.tee $3
+          i32.const -2139062144
+          i32.and
+          i32.const -2139062144
+          i32.xor
+          local.get $3
+          i32.const -16843009
+          i32.add
+          i32.and
+          i32.eqz
+          if ;; label = @4
+            block ;; label = @5
+              local.get $1
+              local.set $0
+              br 2 (;@3;)
+            end
+          end
+        end
+        local.get $3
+        i32.const 255
+        i32.and
+        i32.const 24
+        i32.shl
+        i32.const 24
+        i32.shr_s
+        if ;; label = @3
+          loop $label$9 ;; label = @4
+            local.get $0
+            i32.const 1
+            i32.add
+            local.tee $0
+            i32.load8_s
+            br_if 0 (;@4;)
+          end
+        end
+      end
+      local.get $0
+      local.get $2
+      i32.sub
+    end
+  )
+  (func $32 (;45;) (type $6) (param $0 i32) (param $1 i32) (result i32)
+    (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $3
+      global.get $global$1
+      i32.const 16
+      i32.add
+      global.set $global$1
+      local.get $3
+      local.tee $4
+      local.get $1
+      i32.const 255
+      i32.and
+      local.tee $7
+      i32.store8
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          local.get $0
+          i32.const 16
+          i32.add
+          local.tee $2
+          i32.load
+          local.tee $5
+          br_if 0 (;@3;)
+          local.get $0
+          call $30
+          if ;; label = @4
+            i32.const -1
+            local.set $1
+          else
+            block ;; label = @5
+              local.get $2
+              i32.load
+              local.set $5
+              br 2 (;@3;)
+            end
+          end
+          br 1 (;@2;)
+        end
+        local.get $0
+        i32.const 20
+        i32.add
+        local.tee $2
+        i32.load
+        local.tee $6
+        local.get $5
+        i32.lt_u
+        if ;; label = @3
+          local.get $1
+          i32.const 255
+          i32.and
+          local.tee $1
+          local.get $0
+          i32.load8_s offset=75
+          i32.ne
+          if ;; label = @4
+            block ;; label = @5
+              local.get $2
+              local.get $6
+              i32.const 1
+              i32.add
+              i32.store
+              local.get $6
+              local.get $7
+              i32.store8
+              br 3 (;@2;)
+            end
+          end
+        end
+        local.get $0
+        local.get $4
+        i32.const 1
+        local.get $0
+        i32.load offset=36
+        i32.const 3
+        i32.and
+        i32.const 2
+        i32.add
+        call_indirect (type $0)
+        i32.const 1
+        i32.eq
+        if (result i32) ;; label = @3
+          local.get $4
+          i32.load8_u
+        else
+          i32.const -1
+        end
+        local.set $1
+      end
+      local.get $3
+      global.set $global$1
+      local.get $1
+    end
+  )
+  (func $33 (;46;) (type $12) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32)
+    (local $4 i32) (local $5 i32)
+    block $label$1 (result i32) ;; label = @1
+      local.get $2
+      local.get $1
+      i32.mul
+      local.set $4
+      local.get $3
+      i32.load offset=76
+      i32.const -1
+      i32.gt_s
+      if ;; label = @2
+        block ;; label = @3
+          local.get $3
+          call $20
+          i32.eqz
+          local.set $5
+          local.get $0
+          local.get $4
+          local.get $3
+          call $21
+          local.set $0
+          local.get $5
+          i32.eqz
+          if ;; label = @4
+            local.get $3
+            call $13
+          end
+        end
+      else
+        local.get $0
+        local.get $4
+        local.get $3
+        call $21
+        local.set $0
+      end
+      local.get $0
+      local.get $4
+      i32.ne
+      if ;; label = @2
+        local.get $0
+        local.get $1
+        i32.div_u
+        local.set $2
+      end
+      local.get $2
+    end
+  )
+  (func $34 (;47;) (type $6) (param $0 i32) (param $1 i32) (result i32)
+    (local $2 i32) (local $3 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $2
+      global.get $global$1
+      i32.const 16
+      i32.add
+      global.set $global$1
+      local.get $2
+      local.tee $3
+      local.get $1
+      i32.store
+      i32.const 1280
+      i32.load
+      local.get $0
+      local.get $3
+      call $18
+      local.set $0
+      local.get $2
+      global.set $global$1
+      local.get $0
+    end
+  )
+  (func $35 (;48;) (type $2) (param $0 i32) (result i32)
+    (local $1 i32) (local $2 i32) (local $3 i32)
+    block $label$1 (result i32) ;; label = @1
+      i32.const 1280
+      i32.load
+      local.tee $1
+      i32.load offset=76
+      i32.const -1
+      i32.gt_s
+      if (result i32) ;; label = @2
+        local.get $1
+        call $20
+      else
+        i32.const 0
+      end
+      local.set $2
+      block $label$4 (result i32) ;; label = @2
+        local.get $0
+        local.get $1
+        call $36
+        i32.const 0
+        i32.lt_s
+        if (result i32) ;; label = @3
+          i32.const 1
+        else
+          block (result i32) ;; label = @4
+            local.get $1
+            i32.load8_s offset=75
+            i32.const 10
+            i32.ne
+            if ;; label = @5
+              local.get $1
+              i32.const 20
+              i32.add
+              local.tee $3
+              i32.load
+              local.tee $0
+              local.get $1
+              i32.load offset=16
+              i32.lt_u
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $3
+                  local.get $0
+                  i32.const 1
+                  i32.add
+                  i32.store
+                  local.get $0
+                  i32.const 10
+                  i32.store8
+                  i32.const 0
+                  br 5 (;@2;)
+                end
+              end
+            end
+            local.get $1
+            i32.const 10
+            call $32
+            i32.const 0
+            i32.lt_s
+          end
+        end
+      end
+      local.set $0
+      local.get $2
+      if ;; label = @2
+        local.get $1
+        call $13
+      end
+      local.get $0
+      i32.const 31
+      i32.shl
+      i32.const 31
+      i32.shr_s
+    end
+  )
+  (func $36 (;49;) (type $6) (param $0 i32) (param $1 i32) (result i32)
+    local.get $0
+    local.get $0
+    call $31
+    i32.const 1
+    local.get $1
+    call $33
+    i32.const -1
+    i32.add
+  )
+  (func $37 (;50;) (type $2) (param $0 i32) (result i32)
+    (local $1 i32) (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32) (local $15 i32) (local $16 i32) (local $17 i32) (local $18 i32) (local $19 i32) (local $20 i32) (local $21 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $14
+      global.get $global$1
+      i32.const 16
+      i32.add
+      global.set $global$1
+      local.get $14
+      local.set $18
+      block $label$2 ;; label = @2
+        local.get $0
+        i32.const 245
+        i32.lt_u
+        if ;; label = @3
+          block ;; label = @4
+            local.get $0
+            i32.const 11
+            i32.add
+            i32.const -8
+            i32.and
+            local.set $3
+            i32.const 4176
+            i32.load
+            local.tee $8
+            local.get $0
+            i32.const 11
+            i32.lt_u
+            if (result i32) ;; label = @5
+              i32.const 16
+              local.tee $3
+            else
+              local.get $3
+            end
+            i32.const 3
+            i32.shr_u
+            local.tee $2
+            i32.shr_u
+            local.tee $0
+            i32.const 3
+            i32.and
+            if ;; label = @5
+              block ;; label = @6
+                local.get $0
+                i32.const 1
+                i32.and
+                i32.const 1
+                i32.xor
+                local.get $2
+                i32.add
+                local.tee $5
+                i32.const 1
+                i32.shl
+                i32.const 2
+                i32.shl
+                i32.const 4216
+                i32.add
+                local.tee $2
+                i32.const 8
+                i32.add
+                local.tee $3
+                i32.load
+                local.tee $7
+                i32.const 8
+                i32.add
+                local.tee $1
+                i32.load
+                local.set $4
+                local.get $2
+                local.get $4
+                i32.eq
+                if ;; label = @7
+                  i32.const 4176
+                  local.get $8
+                  i32.const 1
+                  local.get $5
+                  i32.shl
+                  i32.const -1
+                  i32.xor
+                  i32.and
+                  i32.store
+                else
+                  block ;; label = @8
+                    local.get $4
+                    i32.const 4192
+                    i32.load
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$8
+                    end
+                    local.get $4
+                    i32.const 12
+                    i32.add
+                    local.tee $0
+                    i32.load
+                    local.get $7
+                    i32.eq
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $0
+                        local.get $2
+                        i32.store
+                        local.get $3
+                        local.get $4
+                        i32.store
+                      end
+                    else
+                      call $fimport$8
+                    end
+                  end
+                end
+                local.get $7
+                local.get $5
+                i32.const 3
+                i32.shl
+                local.tee $0
+                i32.const 3
+                i32.or
+                i32.store offset=4
+                local.get $7
+                local.get $0
+                i32.add
+                i32.const 4
+                i32.add
+                local.tee $0
+                local.get $0
+                i32.load
+                i32.const 1
+                i32.or
+                i32.store
+                local.get $14
+                global.set $global$1
+                local.get $1
+                return
+              end
+            end
+            local.get $3
+            i32.const 4184
+            i32.load
+            local.tee $16
+            i32.gt_u
+            if ;; label = @5
+              block ;; label = @6
+                local.get $0
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $0
+                    local.get $2
+                    i32.shl
+                    i32.const 2
+                    local.get $2
+                    i32.shl
+                    local.tee $0
+                    i32.const 0
+                    local.get $0
+                    i32.sub
+                    i32.or
+                    i32.and
+                    local.tee $0
+                    i32.const 0
+                    local.get $0
+                    i32.sub
+                    i32.and
+                    i32.const -1
+                    i32.add
+                    local.tee $0
+                    i32.const 12
+                    i32.shr_u
+                    i32.const 16
+                    i32.and
+                    local.set $5
+                    local.get $0
+                    local.get $5
+                    i32.shr_u
+                    local.tee $2
+                    i32.const 5
+                    i32.shr_u
+                    i32.const 8
+                    i32.and
+                    local.tee $0
+                    local.get $5
+                    i32.or
+                    local.get $2
+                    local.get $0
+                    i32.shr_u
+                    local.tee $2
+                    i32.const 2
+                    i32.shr_u
+                    i32.const 4
+                    i32.and
+                    local.tee $0
+                    i32.or
+                    local.get $2
+                    local.get $0
+                    i32.shr_u
+                    local.tee $2
+                    i32.const 1
+                    i32.shr_u
+                    i32.const 2
+                    i32.and
+                    local.tee $0
+                    i32.or
+                    local.get $2
+                    local.get $0
+                    i32.shr_u
+                    local.tee $2
+                    i32.const 1
+                    i32.shr_u
+                    i32.const 1
+                    i32.and
+                    local.tee $0
+                    i32.or
+                    local.get $2
+                    local.get $0
+                    i32.shr_u
+                    i32.add
+                    local.tee $11
+                    i32.const 1
+                    i32.shl
+                    i32.const 2
+                    i32.shl
+                    i32.const 4216
+                    i32.add
+                    local.tee $4
+                    i32.const 8
+                    i32.add
+                    local.tee $2
+                    i32.load
+                    local.tee $9
+                    i32.const 8
+                    i32.add
+                    local.tee $5
+                    i32.load
+                    local.set $12
+                    local.get $4
+                    local.get $12
+                    i32.eq
+                    if ;; label = @9
+                      i32.const 4176
+                      local.get $8
+                      i32.const 1
+                      local.get $11
+                      i32.shl
+                      i32.const -1
+                      i32.xor
+                      i32.and
+                      local.tee $7
+                      i32.store
+                    else
+                      block ;; label = @10
+                        local.get $12
+                        i32.const 4192
+                        i32.load
+                        i32.lt_u
+                        if ;; label = @11
+                          call $fimport$8
+                        end
+                        local.get $12
+                        i32.const 12
+                        i32.add
+                        local.tee $0
+                        i32.load
+                        local.get $9
+                        i32.eq
+                        if ;; label = @11
+                          block ;; label = @12
+                            local.get $0
+                            local.get $4
+                            i32.store
+                            local.get $2
+                            local.get $12
+                            i32.store
+                            local.get $8
+                            local.set $7
+                          end
+                        else
+                          call $fimport$8
+                        end
+                      end
+                    end
+                    local.get $9
+                    local.get $3
+                    i32.const 3
+                    i32.or
+                    i32.store offset=4
+                    local.get $9
+                    local.get $3
+                    i32.add
+                    local.tee $4
+                    local.get $11
+                    i32.const 3
+                    i32.shl
+                    local.get $3
+                    i32.sub
+                    local.tee $11
+                    i32.const 1
+                    i32.or
+                    i32.store offset=4
+                    local.get $4
+                    local.get $11
+                    i32.add
+                    local.get $11
+                    i32.store
+                    local.get $16
+                    if ;; label = @9
+                      block ;; label = @10
+                        i32.const 4196
+                        i32.load
+                        local.set $9
+                        local.get $16
+                        i32.const 3
+                        i32.shr_u
+                        local.tee $0
+                        i32.const 1
+                        i32.shl
+                        i32.const 2
+                        i32.shl
+                        i32.const 4216
+                        i32.add
+                        local.set $2
+                        local.get $7
+                        i32.const 1
+                        local.get $0
+                        i32.shl
+                        local.tee $0
+                        i32.and
+                        if ;; label = @11
+                          local.get $2
+                          i32.const 8
+                          i32.add
+                          local.tee $3
+                          i32.load
+                          local.tee $0
+                          i32.const 4192
+                          i32.load
+                          i32.lt_u
+                          if ;; label = @12
+                            call $fimport$8
+                          else
+                            block ;; label = @13
+                              local.get $3
+                              local.set $6
+                              local.get $0
+                              local.set $1
+                            end
+                          end
+                        else
+                          block ;; label = @12
+                            i32.const 4176
+                            local.get $7
+                            local.get $0
+                            i32.or
+                            i32.store
+                            local.get $2
+                            i32.const 8
+                            i32.add
+                            local.set $6
+                            local.get $2
+                            local.set $1
+                          end
+                        end
+                        local.get $6
+                        local.get $9
+                        i32.store
+                        local.get $1
+                        local.get $9
+                        i32.store offset=12
+                        local.get $9
+                        local.get $1
+                        i32.store offset=8
+                        local.get $9
+                        local.get $2
+                        i32.store offset=12
+                      end
+                    end
+                    i32.const 4184
+                    local.get $11
+                    i32.store
+                    i32.const 4196
+                    local.get $4
+                    i32.store
+                    local.get $14
+                    global.set $global$1
+                    local.get $5
+                    return
+                  end
+                end
+                i32.const 4180
+                i32.load
+                local.tee $6
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $6
+                    i32.const 0
+                    local.get $6
+                    i32.sub
+                    i32.and
+                    i32.const -1
+                    i32.add
+                    local.tee $0
+                    i32.const 12
+                    i32.shr_u
+                    i32.const 16
+                    i32.and
+                    local.set $2
+                    local.get $0
+                    local.get $2
+                    i32.shr_u
+                    local.tee $1
+                    i32.const 5
+                    i32.shr_u
+                    i32.const 8
+                    i32.and
+                    local.tee $0
+                    local.get $2
+                    i32.or
+                    local.get $1
+                    local.get $0
+                    i32.shr_u
+                    local.tee $1
+                    i32.const 2
+                    i32.shr_u
+                    i32.const 4
+                    i32.and
+                    local.tee $0
+                    i32.or
+                    local.get $1
+                    local.get $0
+                    i32.shr_u
+                    local.tee $1
+                    i32.const 1
+                    i32.shr_u
+                    i32.const 2
+                    i32.and
+                    local.tee $0
+                    i32.or
+                    local.get $1
+                    local.get $0
+                    i32.shr_u
+                    local.tee $1
+                    i32.const 1
+                    i32.shr_u
+                    i32.const 1
+                    i32.and
+                    local.tee $0
+                    i32.or
+                    local.get $1
+                    local.get $0
+                    i32.shr_u
+                    i32.add
+                    i32.const 2
+                    i32.shl
+                    i32.const 4480
+                    i32.add
+                    i32.load
+                    local.tee $2
+                    i32.load offset=4
+                    i32.const -8
+                    i32.and
+                    local.get $3
+                    i32.sub
+                    local.set $9
+                    local.get $2
+                    local.set $1
+                    loop $label$25 ;; label = @9
+                      block $label$26 ;; label = @10
+                        local.get $1
+                        i32.load offset=16
+                        local.tee $0
+                        i32.eqz
+                        if ;; label = @11
+                          local.get $1
+                          i32.load offset=20
+                          local.tee $0
+                          i32.eqz
+                          br_if 1 (;@10;)
+                        end
+                        local.get $0
+                        i32.load offset=4
+                        i32.const -8
+                        i32.and
+                        local.get $3
+                        i32.sub
+                        local.tee $1
+                        local.get $9
+                        i32.lt_u
+                        local.tee $7
+                        if ;; label = @11
+                          local.get $1
+                          local.set $9
+                        end
+                        local.get $0
+                        local.set $1
+                        local.get $7
+                        if ;; label = @11
+                          local.get $0
+                          local.set $2
+                        end
+                        br 1 (;@9;)
+                      end
+                    end
+                    local.get $2
+                    i32.const 4192
+                    i32.load
+                    local.tee $12
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$8
+                    end
+                    local.get $2
+                    local.get $2
+                    local.get $3
+                    i32.add
+                    local.tee $13
+                    i32.ge_u
+                    if ;; label = @9
+                      call $fimport$8
+                    end
+                    local.get $2
+                    i32.load offset=24
+                    local.set $15
+                    block $label$32 ;; label = @9
+                      local.get $2
+                      i32.load offset=12
+                      local.tee $0
+                      local.get $2
+                      i32.eq
+                      if ;; label = @10
+                        block ;; label = @11
+                          local.get $2
+                          i32.const 20
+                          i32.add
+                          local.tee $1
+                          i32.load
+                          local.tee $0
+                          i32.eqz
+                          if ;; label = @12
+                            local.get $2
+                            i32.const 16
+                            i32.add
+                            local.tee $1
+                            i32.load
+                            local.tee $0
+                            i32.eqz
+                            if ;; label = @13
+                              block ;; label = @14
+                                i32.const 0
+                                local.set $4
+                                br 5 (;@9;)
+                              end
+                            end
+                          end
+                          loop $label$36 ;; label = @12
+                            local.get $0
+                            i32.const 20
+                            i32.add
+                            local.tee $11
+                            i32.load
+                            local.tee $7
+                            if ;; label = @13
+                              block ;; label = @14
+                                local.get $7
+                                local.set $0
+                                local.get $11
+                                local.set $1
+                                br 2 (;@12;)
+                              end
+                            end
+                            local.get $0
+                            i32.const 16
+                            i32.add
+                            local.tee $11
+                            i32.load
+                            local.tee $7
+                            if ;; label = @13
+                              block ;; label = @14
+                                local.get $7
+                                local.set $0
+                                local.get $11
+                                local.set $1
+                                br 2 (;@12;)
+                              end
+                            end
+                          end
+                          local.get $1
+                          local.get $12
+                          i32.lt_u
+                          if ;; label = @12
+                            call $fimport$8
+                          else
+                            block ;; label = @13
+                              local.get $1
+                              i32.const 0
+                              i32.store
+                              local.get $0
+                              local.set $4
+                            end
+                          end
+                        end
+                      else
+                        block ;; label = @11
+                          local.get $2
+                          i32.load offset=8
+                          local.tee $11
+                          local.get $12
+                          i32.lt_u
+                          if ;; label = @12
+                            call $fimport$8
+                          end
+                          local.get $11
+                          i32.const 12
+                          i32.add
+                          local.tee $7
+                          i32.load
+                          local.get $2
+                          i32.ne
+                          if ;; label = @12
+                            call $fimport$8
+                          end
+                          local.get $0
+                          i32.const 8
+                          i32.add
+                          local.tee $1
+                          i32.load
+                          local.get $2
+                          i32.eq
+                          if ;; label = @12
+                            block ;; label = @13
+                              local.get $7
+                              local.get $0
+                              i32.store
+                              local.get $1
+                              local.get $11
+                              i32.store
+                              local.get $0
+                              local.set $4
+                            end
+                          else
+                            call $fimport$8
+                          end
+                        end
+                      end
+                    end
+                    block $label$46 ;; label = @9
+                      local.get $15
+                      if ;; label = @10
+                        block ;; label = @11
+                          local.get $2
+                          local.get $2
+                          i32.load offset=28
+                          local.tee $1
+                          i32.const 2
+                          i32.shl
+                          i32.const 4480
+                          i32.add
+                          local.tee $0
+                          i32.load
+                          i32.eq
+                          if ;; label = @12
+                            block ;; label = @13
+                              local.get $0
+                              local.get $4
+                              i32.store
+                              local.get $4
+                              i32.eqz
+                              if ;; label = @14
+                                block ;; label = @15
+                                  i32.const 4180
+                                  local.get $6
+                                  i32.const 1
+                                  local.get $1
+                                  i32.shl
+                                  i32.const -1
+                                  i32.xor
+                                  i32.and
+                                  i32.store
+                                  br 6 (;@9;)
+                                end
+                              end
+                            end
+                          else
+                            block ;; label = @13
+                              local.get $15
+                              i32.const 4192
+                              i32.load
+                              i32.lt_u
+                              if ;; label = @14
+                                call $fimport$8
+                              end
+                              local.get $15
+                              i32.const 16
+                              i32.add
+                              local.tee $0
+                              i32.load
+                              local.get $2
+                              i32.eq
+                              if ;; label = @14
+                                local.get $0
+                                local.get $4
+                                i32.store
+                              else
+                                local.get $15
+                                local.get $4
+                                i32.store offset=20
+                              end
+                              local.get $4
+                              i32.eqz
+                              br_if 4 (;@9;)
+                            end
+                          end
+                          local.get $4
+                          i32.const 4192
+                          i32.load
+                          local.tee $0
+                          i32.lt_u
+                          if ;; label = @12
+                            call $fimport$8
+                          end
+                          local.get $4
+                          local.get $15
+                          i32.store offset=24
+                          local.get $2
+                          i32.load offset=16
+                          local.tee $1
+                          if ;; label = @12
+                            local.get $1
+                            local.get $0
+                            i32.lt_u
+                            if ;; label = @13
+                              call $fimport$8
+                            else
+                              block ;; label = @14
+                                local.get $4
+                                local.get $1
+                                i32.store offset=16
+                                local.get $1
+                                local.get $4
+                                i32.store offset=24
+                              end
+                            end
+                          end
+                          local.get $2
+                          i32.load offset=20
+                          local.tee $0
+                          if ;; label = @12
+                            local.get $0
+                            i32.const 4192
+                            i32.load
+                            i32.lt_u
+                            if ;; label = @13
+                              call $fimport$8
+                            else
+                              block ;; label = @14
+                                local.get $4
+                                local.get $0
+                                i32.store offset=20
+                                local.get $0
+                                local.get $4
+                                i32.store offset=24
+                              end
+                            end
+                          end
+                        end
+                      end
+                    end
+                    local.get $9
+                    i32.const 16
+                    i32.lt_u
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $2
+                        local.get $9
+                        local.get $3
+                        i32.add
+                        local.tee $0
+                        i32.const 3
+                        i32.or
+                        i32.store offset=4
+                        local.get $2
+                        local.get $0
+                        i32.add
+                        i32.const 4
+                        i32.add
+                        local.tee $0
+                        local.get $0
+                        i32.load
+                        i32.const 1
+                        i32.or
+                        i32.store
+                      end
+                    else
+                      block ;; label = @10
+                        local.get $2
+                        local.get $3
+                        i32.const 3
+                        i32.or
+                        i32.store offset=4
+                        local.get $13
+                        local.get $9
+                        i32.const 1
+                        i32.or
+                        i32.store offset=4
+                        local.get $13
+                        local.get $9
+                        i32.add
+                        local.get $9
+                        i32.store
+                        local.get $16
+                        if ;; label = @11
+                          block ;; label = @12
+                            i32.const 4196
+                            i32.load
+                            local.set $7
+                            local.get $16
+                            i32.const 3
+                            i32.shr_u
+                            local.tee $0
+                            i32.const 1
+                            i32.shl
+                            i32.const 2
+                            i32.shl
+                            i32.const 4216
+                            i32.add
+                            local.set $3
+                            local.get $8
+                            i32.const 1
+                            local.get $0
+                            i32.shl
+                            local.tee $0
+                            i32.and
+                            if ;; label = @13
+                              local.get $3
+                              i32.const 8
+                              i32.add
+                              local.tee $1
+                              i32.load
+                              local.tee $0
+                              i32.const 4192
+                              i32.load
+                              i32.lt_u
+                              if ;; label = @14
+                                call $fimport$8
+                              else
+                                block ;; label = @15
+                                  local.get $1
+                                  local.set $10
+                                  local.get $0
+                                  local.set $5
+                                end
+                              end
+                            else
+                              block ;; label = @14
+                                i32.const 4176
+                                local.get $8
+                                local.get $0
+                                i32.or
+                                i32.store
+                                local.get $3
+                                i32.const 8
+                                i32.add
+                                local.set $10
+                                local.get $3
+                                local.set $5
+                              end
+                            end
+                            local.get $10
+                            local.get $7
+                            i32.store
+                            local.get $5
+                            local.get $7
+                            i32.store offset=12
+                            local.get $7
+                            local.get $5
+                            i32.store offset=8
+                            local.get $7
+                            local.get $3
+                            i32.store offset=12
+                          end
+                        end
+                        i32.const 4184
+                        local.get $9
+                        i32.store
+                        i32.const 4196
+                        local.get $13
+                        i32.store
+                      end
+                    end
+                    local.get $14
+                    global.set $global$1
+                    local.get $2
+                    i32.const 8
+                    i32.add
+                    return
+                  end
+                else
+                  local.get $3
+                  local.set $0
+                end
+              end
+            else
+              local.get $3
+              local.set $0
+            end
+          end
+        else
+          local.get $0
+          i32.const -65
+          i32.gt_u
+          if ;; label = @4
+            i32.const -1
+            local.set $0
+          else
+            block ;; label = @5
+              local.get $0
+              i32.const 11
+              i32.add
+              local.tee $0
+              i32.const -8
+              i32.and
+              local.set $7
+              i32.const 4180
+              i32.load
+              local.tee $5
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $0
+                  i32.const 8
+                  i32.shr_u
+                  local.tee $0
+                  if (result i32) ;; label = @8
+                    local.get $7
+                    i32.const 16777215
+                    i32.gt_u
+                    if (result i32) ;; label = @9
+                      i32.const 31
+                    else
+                      local.get $7
+                      i32.const 14
+                      local.get $0
+                      local.get $0
+                      i32.const 1048320
+                      i32.add
+                      i32.const 16
+                      i32.shr_u
+                      i32.const 8
+                      i32.and
+                      local.tee $3
+                      i32.shl
+                      local.tee $1
+                      i32.const 520192
+                      i32.add
+                      i32.const 16
+                      i32.shr_u
+                      i32.const 4
+                      i32.and
+                      local.tee $0
+                      local.get $3
+                      i32.or
+                      local.get $1
+                      local.get $0
+                      i32.shl
+                      local.tee $1
+                      i32.const 245760
+                      i32.add
+                      i32.const 16
+                      i32.shr_u
+                      i32.const 2
+                      i32.and
+                      local.tee $0
+                      i32.or
+                      i32.sub
+                      local.get $1
+                      local.get $0
+                      i32.shl
+                      i32.const 15
+                      i32.shr_u
+                      i32.add
+                      local.tee $0
+                      i32.const 7
+                      i32.add
+                      i32.shr_u
+                      i32.const 1
+                      i32.and
+                      local.get $0
+                      i32.const 1
+                      i32.shl
+                      i32.or
+                    end
+                  else
+                    i32.const 0
+                  end
+                  local.set $17
+                  i32.const 0
+                  local.get $7
+                  i32.sub
+                  local.set $3
+                  block $label$78 ;; label = @8
+                    block $label$79 ;; label = @9
+                      block $label$80 ;; label = @10
+                        local.get $17
+                        i32.const 2
+                        i32.shl
+                        i32.const 4480
+                        i32.add
+                        i32.load
+                        local.tee $1
+                        if ;; label = @11
+                          block ;; label = @12
+                            i32.const 25
+                            local.get $17
+                            i32.const 1
+                            i32.shr_u
+                            i32.sub
+                            local.set $0
+                            i32.const 0
+                            local.set $4
+                            local.get $7
+                            local.get $17
+                            i32.const 31
+                            i32.eq
+                            if (result i32) ;; label = @13
+                              i32.const 0
+                            else
+                              local.get $0
+                            end
+                            i32.shl
+                            local.set $10
+                            i32.const 0
+                            local.set $0
+                            loop $label$84 ;; label = @13
+                              local.get $1
+                              i32.load offset=4
+                              i32.const -8
+                              i32.and
+                              local.get $7
+                              i32.sub
+                              local.tee $6
+                              local.get $3
+                              i32.lt_u
+                              if ;; label = @14
+                                local.get $6
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $6
+                                    local.set $3
+                                    local.get $1
+                                    local.set $0
+                                  end
+                                else
+                                  block ;; label = @16
+                                    i32.const 0
+                                    local.set $3
+                                    local.get $1
+                                    local.set $0
+                                    br 7 (;@9;)
+                                  end
+                                end
+                              end
+                              local.get $1
+                              i32.load offset=20
+                              local.tee $19
+                              i32.eqz
+                              local.get $19
+                              local.get $1
+                              i32.const 16
+                              i32.add
+                              local.get $10
+                              i32.const 31
+                              i32.shr_u
+                              i32.const 2
+                              i32.shl
+                              i32.add
+                              i32.load
+                              local.tee $6
+                              i32.eq
+                              i32.or
+                              if (result i32) ;; label = @14
+                                local.get $4
+                              else
+                                local.get $19
+                              end
+                              local.set $1
+                              local.get $10
+                              local.get $6
+                              i32.eqz
+                              local.tee $4
+                              i32.const 1
+                              i32.and
+                              i32.const 1
+                              i32.xor
+                              i32.shl
+                              local.set $10
+                              local.get $4
+                              if ;; label = @14
+                                block ;; label = @15
+                                  local.get $1
+                                  local.set $4
+                                  local.get $0
+                                  local.set $1
+                                  br 5 (;@10;)
+                                end
+                              else
+                                block ;; label = @15
+                                  local.get $1
+                                  local.set $4
+                                  local.get $6
+                                  local.set $1
+                                  br 2 (;@13;)
+                                end
+                              end
+                            end
+                          end
+                        else
+                          block ;; label = @12
+                            i32.const 0
+                            local.set $4
+                            i32.const 0
+                            local.set $1
+                          end
+                        end
+                      end
+                      local.get $4
+                      i32.eqz
+                      local.get $1
+                      i32.eqz
+                      i32.and
+                      if (result i32) ;; label = @10
+                        block (result i32) ;; label = @11
+                          local.get $5
+                          i32.const 2
+                          local.get $17
+                          i32.shl
+                          local.tee $0
+                          i32.const 0
+                          local.get $0
+                          i32.sub
+                          i32.or
+                          i32.and
+                          local.tee $0
+                          i32.eqz
+                          if ;; label = @12
+                            block ;; label = @13
+                              local.get $7
+                              local.set $0
+                              br 11 (;@2;)
+                            end
+                          end
+                          local.get $0
+                          i32.const 0
+                          local.get $0
+                          i32.sub
+                          i32.and
+                          i32.const -1
+                          i32.add
+                          local.tee $0
+                          i32.const 12
+                          i32.shr_u
+                          i32.const 16
+                          i32.and
+                          local.set $10
+                          local.get $0
+                          local.get $10
+                          i32.shr_u
+                          local.tee $4
+                          i32.const 5
+                          i32.shr_u
+                          i32.const 8
+                          i32.and
+                          local.tee $0
+                          local.get $10
+                          i32.or
+                          local.get $4
+                          local.get $0
+                          i32.shr_u
+                          local.tee $4
+                          i32.const 2
+                          i32.shr_u
+                          i32.const 4
+                          i32.and
+                          local.tee $0
+                          i32.or
+                          local.get $4
+                          local.get $0
+                          i32.shr_u
+                          local.tee $4
+                          i32.const 1
+                          i32.shr_u
+                          i32.const 2
+                          i32.and
+                          local.tee $0
+                          i32.or
+                          local.get $4
+                          local.get $0
+                          i32.shr_u
+                          local.tee $4
+                          i32.const 1
+                          i32.shr_u
+                          i32.const 1
+                          i32.and
+                          local.tee $0
+                          i32.or
+                          local.get $4
+                          local.get $0
+                          i32.shr_u
+                          i32.add
+                          i32.const 2
+                          i32.shl
+                          i32.const 4480
+                          i32.add
+                          i32.load
+                        end
+                      else
+                        local.get $4
+                      end
+                      local.tee $0
+                      br_if 0 (;@9;)
+                      local.get $1
+                      local.set $4
+                      br 1 (;@8;)
+                    end
+                    loop $label$96 ;; label = @9
+                      local.get $0
+                      i32.load offset=4
+                      i32.const -8
+                      i32.and
+                      local.get $7
+                      i32.sub
+                      local.tee $4
+                      local.get $3
+                      i32.lt_u
+                      local.tee $10
+                      if ;; label = @10
+                        local.get $4
+                        local.set $3
+                      end
+                      local.get $10
+                      if ;; label = @10
+                        local.get $0
+                        local.set $1
+                      end
+                      local.get $0
+                      i32.load offset=16
+                      local.tee $4
+                      if ;; label = @10
+                        block ;; label = @11
+                          local.get $4
+                          local.set $0
+                          br 2 (;@9;)
+                        end
+                      end
+                      local.get $0
+                      i32.load offset=20
+                      local.tee $0
+                      br_if 0 (;@9;)
+                      local.get $1
+                      local.set $4
+                    end
+                  end
+                  local.get $4
+                  if ;; label = @8
+                    local.get $3
+                    i32.const 4184
+                    i32.load
+                    local.get $7
+                    i32.sub
+                    i32.lt_u
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $4
+                        i32.const 4192
+                        i32.load
+                        local.tee $12
+                        i32.lt_u
+                        if ;; label = @11
+                          call $fimport$8
+                        end
+                        local.get $4
+                        local.get $4
+                        local.get $7
+                        i32.add
+                        local.tee $6
+                        i32.ge_u
+                        if ;; label = @11
+                          call $fimport$8
+                        end
+                        local.get $4
+                        i32.load offset=24
+                        local.set $10
+                        block $label$104 ;; label = @11
+                          local.get $4
+                          i32.load offset=12
+                          local.tee $0
+                          local.get $4
+                          i32.eq
+                          if ;; label = @12
+                            block ;; label = @13
+                              local.get $4
+                              i32.const 20
+                              i32.add
+                              local.tee $1
+                              i32.load
+                              local.tee $0
+                              i32.eqz
+                              if ;; label = @14
+                                local.get $4
+                                i32.const 16
+                                i32.add
+                                local.tee $1
+                                i32.load
+                                local.tee $0
+                                i32.eqz
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    i32.const 0
+                                    local.set $13
+                                    br 5 (;@11;)
+                                  end
+                                end
+                              end
+                              loop $label$108 ;; label = @14
+                                local.get $0
+                                i32.const 20
+                                i32.add
+                                local.tee $9
+                                i32.load
+                                local.tee $11
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $11
+                                    local.set $0
+                                    local.get $9
+                                    local.set $1
+                                    br 2 (;@14;)
+                                  end
+                                end
+                                local.get $0
+                                i32.const 16
+                                i32.add
+                                local.tee $9
+                                i32.load
+                                local.tee $11
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $11
+                                    local.set $0
+                                    local.get $9
+                                    local.set $1
+                                    br 2 (;@14;)
+                                  end
+                                end
+                              end
+                              local.get $1
+                              local.get $12
+                              i32.lt_u
+                              if ;; label = @14
+                                call $fimport$8
+                              else
+                                block ;; label = @15
+                                  local.get $1
+                                  i32.const 0
+                                  i32.store
+                                  local.get $0
+                                  local.set $13
+                                end
+                              end
+                            end
+                          else
+                            block ;; label = @13
+                              local.get $4
+                              i32.load offset=8
+                              local.tee $9
+                              local.get $12
+                              i32.lt_u
+                              if ;; label = @14
+                                call $fimport$8
+                              end
+                              local.get $9
+                              i32.const 12
+                              i32.add
+                              local.tee $11
+                              i32.load
+                              local.get $4
+                              i32.ne
+                              if ;; label = @14
+                                call $fimport$8
+                              end
+                              local.get $0
+                              i32.const 8
+                              i32.add
+                              local.tee $1
+                              i32.load
+                              local.get $4
+                              i32.eq
+                              if ;; label = @14
+                                block ;; label = @15
+                                  local.get $11
+                                  local.get $0
+                                  i32.store
+                                  local.get $1
+                                  local.get $9
+                                  i32.store
+                                  local.get $0
+                                  local.set $13
+                                end
+                              else
+                                call $fimport$8
+                              end
+                            end
+                          end
+                        end
+                        block $label$118 ;; label = @11
+                          local.get $10
+                          if ;; label = @12
+                            block ;; label = @13
+                              local.get $4
+                              local.get $4
+                              i32.load offset=28
+                              local.tee $1
+                              i32.const 2
+                              i32.shl
+                              i32.const 4480
+                              i32.add
+                              local.tee $0
+                              i32.load
+                              i32.eq
+                              if ;; label = @14
+                                block ;; label = @15
+                                  local.get $0
+                                  local.get $13
+                                  i32.store
+                                  local.get $13
+                                  i32.eqz
+                                  if ;; label = @16
+                                    block ;; label = @17
+                                      i32.const 4180
+                                      local.get $5
+                                      i32.const 1
+                                      local.get $1
+                                      i32.shl
+                                      i32.const -1
+                                      i32.xor
+                                      i32.and
+                                      local.tee $2
+                                      i32.store
+                                      br 6 (;@11;)
+                                    end
+                                  end
+                                end
+                              else
+                                block ;; label = @15
+                                  local.get $10
+                                  i32.const 4192
+                                  i32.load
+                                  i32.lt_u
+                                  if ;; label = @16
+                                    call $fimport$8
+                                  end
+                                  local.get $10
+                                  i32.const 16
+                                  i32.add
+                                  local.tee $0
+                                  i32.load
+                                  local.get $4
+                                  i32.eq
+                                  if ;; label = @16
+                                    local.get $0
+                                    local.get $13
+                                    i32.store
+                                  else
+                                    local.get $10
+                                    local.get $13
+                                    i32.store offset=20
+                                  end
+                                  local.get $13
+                                  i32.eqz
+                                  if ;; label = @16
+                                    block ;; label = @17
+                                      local.get $5
+                                      local.set $2
+                                      br 6 (;@11;)
+                                    end
+                                  end
+                                end
+                              end
+                              local.get $13
+                              i32.const 4192
+                              i32.load
+                              local.tee $0
+                              i32.lt_u
+                              if ;; label = @14
+                                call $fimport$8
+                              end
+                              local.get $13
+                              local.get $10
+                              i32.store offset=24
+                              local.get $4
+                              i32.load offset=16
+                              local.tee $1
+                              if ;; label = @14
+                                local.get $1
+                                local.get $0
+                                i32.lt_u
+                                if ;; label = @15
+                                  call $fimport$8
+                                else
+                                  block ;; label = @16
+                                    local.get $13
+                                    local.get $1
+                                    i32.store offset=16
+                                    local.get $1
+                                    local.get $13
+                                    i32.store offset=24
+                                  end
+                                end
+                              end
+                              local.get $4
+                              i32.load offset=20
+                              local.tee $0
+                              if ;; label = @14
+                                local.get $0
+                                i32.const 4192
+                                i32.load
+                                i32.lt_u
+                                if ;; label = @15
+                                  call $fimport$8
+                                else
+                                  block ;; label = @16
+                                    local.get $13
+                                    local.get $0
+                                    i32.store offset=20
+                                    local.get $0
+                                    local.get $13
+                                    i32.store offset=24
+                                    local.get $5
+                                    local.set $2
+                                  end
+                                end
+                              else
+                                local.get $5
+                                local.set $2
+                              end
+                            end
+                          else
+                            local.get $5
+                            local.set $2
+                          end
+                        end
+                        block $label$136 ;; label = @11
+                          local.get $3
+                          i32.const 16
+                          i32.lt_u
+                          if ;; label = @12
+                            block ;; label = @13
+                              local.get $4
+                              local.get $3
+                              local.get $7
+                              i32.add
+                              local.tee $0
+                              i32.const 3
+                              i32.or
+                              i32.store offset=4
+                              local.get $4
+                              local.get $0
+                              i32.add
+                              i32.const 4
+                              i32.add
+                              local.tee $0
+                              local.get $0
+                              i32.load
+                              i32.const 1
+                              i32.or
+                              i32.store
+                            end
+                          else
+                            block ;; label = @13
+                              local.get $4
+                              local.get $7
+                              i32.const 3
+                              i32.or
+                              i32.store offset=4
+                              local.get $6
+                              local.get $3
+                              i32.const 1
+                              i32.or
+                              i32.store offset=4
+                              local.get $6
+                              local.get $3
+                              i32.add
+                              local.get $3
+                              i32.store
+                              local.get $3
+                              i32.const 3
+                              i32.shr_u
+                              local.set $0
+                              local.get $3
+                              i32.const 256
+                              i32.lt_u
+                              if ;; label = @14
+                                block ;; label = @15
+                                  local.get $0
+                                  i32.const 1
+                                  i32.shl
+                                  i32.const 2
+                                  i32.shl
+                                  i32.const 4216
+                                  i32.add
+                                  local.set $3
+                                  i32.const 4176
+                                  i32.load
+                                  local.tee $1
+                                  i32.const 1
+                                  local.get $0
+                                  i32.shl
+                                  local.tee $0
+                                  i32.and
+                                  if ;; label = @16
+                                    local.get $3
+                                    i32.const 8
+                                    i32.add
+                                    local.tee $1
+                                    i32.load
+                                    local.tee $0
+                                    i32.const 4192
+                                    i32.load
+                                    i32.lt_u
+                                    if ;; label = @17
+                                      call $fimport$8
+                                    else
+                                      block ;; label = @18
+                                        local.get $1
+                                        local.set $16
+                                        local.get $0
+                                        local.set $8
+                                      end
+                                    end
+                                  else
+                                    block ;; label = @17
+                                      i32.const 4176
+                                      local.get $1
+                                      local.get $0
+                                      i32.or
+                                      i32.store
+                                      local.get $3
+                                      i32.const 8
+                                      i32.add
+                                      local.set $16
+                                      local.get $3
+                                      local.set $8
+                                    end
+                                  end
+                                  local.get $16
+                                  local.get $6
+                                  i32.store
+                                  local.get $8
+                                  local.get $6
+                                  i32.store offset=12
+                                  local.get $6
+                                  local.get $8
+                                  i32.store offset=8
+                                  local.get $6
+                                  local.get $3
+                                  i32.store offset=12
+                                  br 4 (;@11;)
+                                end
+                              end
+                              local.get $3
+                              i32.const 8
+                              i32.shr_u
+                              local.tee $0
+                              if (result i32) ;; label = @14
+                                local.get $3
+                                i32.const 16777215
+                                i32.gt_u
+                                if (result i32) ;; label = @15
+                                  i32.const 31
+                                else
+                                  local.get $3
+                                  i32.const 14
+                                  local.get $0
+                                  local.get $0
+                                  i32.const 1048320
+                                  i32.add
+                                  i32.const 16
+                                  i32.shr_u
+                                  i32.const 8
+                                  i32.and
+                                  local.tee $5
+                                  i32.shl
+                                  local.tee $1
+                                  i32.const 520192
+                                  i32.add
+                                  i32.const 16
+                                  i32.shr_u
+                                  i32.const 4
+                                  i32.and
+                                  local.tee $0
+                                  local.get $5
+                                  i32.or
+                                  local.get $1
+                                  local.get $0
+                                  i32.shl
+                                  local.tee $1
+                                  i32.const 245760
+                                  i32.add
+                                  i32.const 16
+                                  i32.shr_u
+                                  i32.const 2
+                                  i32.and
+                                  local.tee $0
+                                  i32.or
+                                  i32.sub
+                                  local.get $1
+                                  local.get $0
+                                  i32.shl
+                                  i32.const 15
+                                  i32.shr_u
+                                  i32.add
+                                  local.tee $0
+                                  i32.const 7
+                                  i32.add
+                                  i32.shr_u
+                                  i32.const 1
+                                  i32.and
+                                  local.get $0
+                                  i32.const 1
+                                  i32.shl
+                                  i32.or
+                                end
+                              else
+                                i32.const 0
+                              end
+                              local.tee $5
+                              i32.const 2
+                              i32.shl
+                              i32.const 4480
+                              i32.add
+                              local.set $1
+                              local.get $6
+                              local.get $5
+                              i32.store offset=28
+                              local.get $6
+                              i32.const 16
+                              i32.add
+                              local.tee $0
+                              i32.const 0
+                              i32.store offset=4
+                              local.get $0
+                              i32.const 0
+                              i32.store
+                              local.get $2
+                              i32.const 1
+                              local.get $5
+                              i32.shl
+                              local.tee $0
+                              i32.and
+                              i32.eqz
+                              if ;; label = @14
+                                block ;; label = @15
+                                  i32.const 4180
+                                  local.get $2
+                                  local.get $0
+                                  i32.or
+                                  i32.store
+                                  local.get $1
+                                  local.get $6
+                                  i32.store
+                                  local.get $6
+                                  local.get $1
+                                  i32.store offset=24
+                                  local.get $6
+                                  local.get $6
+                                  i32.store offset=12
+                                  local.get $6
+                                  local.get $6
+                                  i32.store offset=8
+                                  br 4 (;@11;)
+                                end
+                              end
+                              local.get $1
+                              i32.load
+                              local.set $0
+                              i32.const 25
+                              local.get $5
+                              i32.const 1
+                              i32.shr_u
+                              i32.sub
+                              local.set $1
+                              local.get $3
+                              local.get $5
+                              i32.const 31
+                              i32.eq
+                              if (result i32) ;; label = @14
+                                i32.const 0
+                              else
+                                local.get $1
+                              end
+                              i32.shl
+                              local.set $5
+                              block $label$151 ;; label = @14
+                                block $label$152 ;; label = @15
+                                  block $label$153 ;; label = @16
+                                    loop $label$154 ;; label = @17
+                                      local.get $0
+                                      i32.load offset=4
+                                      i32.const -8
+                                      i32.and
+                                      local.get $3
+                                      i32.eq
+                                      br_if 2 (;@15;)
+                                      local.get $5
+                                      i32.const 1
+                                      i32.shl
+                                      local.set $2
+                                      local.get $0
+                                      i32.const 16
+                                      i32.add
+                                      local.get $5
+                                      i32.const 31
+                                      i32.shr_u
+                                      i32.const 2
+                                      i32.shl
+                                      i32.add
+                                      local.tee $5
+                                      i32.load
+                                      local.tee $1
+                                      i32.eqz
+                                      br_if 1 (;@16;)
+                                      local.get $2
+                                      local.set $5
+                                      local.get $1
+                                      local.set $0
+                                      br 0 (;@17;)
+                                    end
+                                  end
+                                  local.get $5
+                                  i32.const 4192
+                                  i32.load
+                                  i32.lt_u
+                                  if ;; label = @16
+                                    call $fimport$8
+                                  else
+                                    block ;; label = @17
+                                      local.get $5
+                                      local.get $6
+                                      i32.store
+                                      local.get $6
+                                      local.get $0
+                                      i32.store offset=24
+                                      local.get $6
+                                      local.get $6
+                                      i32.store offset=12
+                                      local.get $6
+                                      local.get $6
+                                      i32.store offset=8
+                                      br 6 (;@11;)
+                                    end
+                                  end
+                                  br 1 (;@14;)
+                                end
+                                local.get $0
+                                i32.const 8
+                                i32.add
+                                local.tee $3
+                                i32.load
+                                local.tee $2
+                                i32.const 4192
+                                i32.load
+                                local.tee $1
+                                i32.ge_u
+                                local.get $0
+                                local.get $1
+                                i32.ge_u
+                                i32.and
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $2
+                                    local.get $6
+                                    i32.store offset=12
+                                    local.get $3
+                                    local.get $6
+                                    i32.store
+                                    local.get $6
+                                    local.get $2
+                                    i32.store offset=8
+                                    local.get $6
+                                    local.get $0
+                                    i32.store offset=12
+                                    local.get $6
+                                    i32.const 0
+                                    i32.store offset=24
+                                  end
+                                else
+                                  call $fimport$8
+                                end
+                              end
+                            end
+                          end
+                        end
+                        local.get $14
+                        global.set $global$1
+                        local.get $4
+                        i32.const 8
+                        i32.add
+                        return
+                      end
+                    else
+                      local.get $7
+                      local.set $0
+                    end
+                  else
+                    local.get $7
+                    local.set $0
+                  end
+                end
+              else
+                local.get $7
+                local.set $0
+              end
+            end
+          end
+        end
+      end
+      i32.const 4184
+      i32.load
+      local.tee $1
+      local.get $0
+      i32.ge_u
+      if ;; label = @2
+        block ;; label = @3
+          i32.const 4196
+          i32.load
+          local.set $2
+          local.get $1
+          local.get $0
+          i32.sub
+          local.tee $3
+          i32.const 15
+          i32.gt_u
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 4196
+              local.get $2
+              local.get $0
+              i32.add
+              local.tee $1
+              i32.store
+              i32.const 4184
+              local.get $3
+              i32.store
+              local.get $1
+              local.get $3
+              i32.const 1
+              i32.or
+              i32.store offset=4
+              local.get $1
+              local.get $3
+              i32.add
+              local.get $3
+              i32.store
+              local.get $2
+              local.get $0
+              i32.const 3
+              i32.or
+              i32.store offset=4
+            end
+          else
+            block ;; label = @5
+              i32.const 4184
+              i32.const 0
+              i32.store
+              i32.const 4196
+              i32.const 0
+              i32.store
+              local.get $2
+              local.get $1
+              i32.const 3
+              i32.or
+              i32.store offset=4
+              local.get $2
+              local.get $1
+              i32.add
+              i32.const 4
+              i32.add
+              local.tee $0
+              local.get $0
+              i32.load
+              i32.const 1
+              i32.or
+              i32.store
+            end
+          end
+          local.get $14
+          global.set $global$1
+          local.get $2
+          i32.const 8
+          i32.add
+          return
+        end
+      end
+      i32.const 4188
+      i32.load
+      local.tee $10
+      local.get $0
+      i32.gt_u
+      if ;; label = @2
+        block ;; label = @3
+          i32.const 4188
+          local.get $10
+          local.get $0
+          i32.sub
+          local.tee $3
+          i32.store
+          i32.const 4200
+          i32.const 4200
+          i32.load
+          local.tee $2
+          local.get $0
+          i32.add
+          local.tee $1
+          i32.store
+          local.get $1
+          local.get $3
+          i32.const 1
+          i32.or
+          i32.store offset=4
+          local.get $2
+          local.get $0
+          i32.const 3
+          i32.or
+          i32.store offset=4
+          local.get $14
+          global.set $global$1
+          local.get $2
+          i32.const 8
+          i32.add
+          return
+        end
+      end
+      i32.const 4648
+      i32.load
+      if (result i32) ;; label = @2
+        i32.const 4656
+        i32.load
+      else
+        block (result i32) ;; label = @3
+          i32.const 4656
+          i32.const 4096
+          i32.store
+          i32.const 4652
+          i32.const 4096
+          i32.store
+          i32.const 4660
+          i32.const -1
+          i32.store
+          i32.const 4664
+          i32.const -1
+          i32.store
+          i32.const 4668
+          i32.const 0
+          i32.store
+          i32.const 4620
+          i32.const 0
+          i32.store
+          local.get $18
+          local.get $18
+          i32.const -16
+          i32.and
+          i32.const 1431655768
+          i32.xor
+          local.tee $1
+          i32.store
+          i32.const 4648
+          local.get $1
+          i32.store
+          i32.const 4096
+        end
+      end
+      local.tee $1
+      local.get $0
+      i32.const 47
+      i32.add
+      local.tee $13
+      i32.add
+      local.tee $8
+      i32.const 0
+      local.get $1
+      i32.sub
+      local.tee $4
+      i32.and
+      local.tee $6
+      local.get $0
+      i32.le_u
+      if ;; label = @2
+        block ;; label = @3
+          local.get $14
+          global.set $global$1
+          i32.const 0
+          return
+        end
+      end
+      i32.const 4616
+      i32.load
+      local.tee $2
+      if ;; label = @2
+        i32.const 4608
+        i32.load
+        local.tee $3
+        local.get $6
+        i32.add
+        local.tee $1
+        local.get $3
+        i32.le_u
+        local.get $1
+        local.get $2
+        i32.gt_u
+        i32.or
+        if ;; label = @3
+          block ;; label = @4
+            local.get $14
+            global.set $global$1
+            i32.const 0
+            return
+          end
+        end
+      end
+      local.get $0
+      i32.const 48
+      i32.add
+      local.set $7
+      block $label$171 ;; label = @2
+        block $label$172 ;; label = @3
+          i32.const 4620
+          i32.load
+          i32.const 4
+          i32.and
+          i32.eqz
+          if ;; label = @4
+            block ;; label = @5
+              block $label$174 ;; label = @6
+                block $label$175 ;; label = @7
+                  block $label$176 ;; label = @8
+                    i32.const 4200
+                    i32.load
+                    local.tee $3
+                    i32.eqz
+                    br_if 0 (;@8;)
+                    i32.const 4624
+                    local.set $2
+                    loop $label$177 ;; label = @9
+                      block $label$178 ;; label = @10
+                        local.get $2
+                        i32.load
+                        local.tee $1
+                        local.get $3
+                        i32.le_u
+                        if ;; label = @11
+                          local.get $1
+                          local.get $2
+                          i32.const 4
+                          i32.add
+                          local.tee $5
+                          i32.load
+                          i32.add
+                          local.get $3
+                          i32.gt_u
+                          br_if 1 (;@10;)
+                        end
+                        local.get $2
+                        i32.load offset=8
+                        local.tee $1
+                        i32.eqz
+                        br_if 2 (;@8;)
+                        local.get $1
+                        local.set $2
+                        br 1 (;@9;)
+                      end
+                    end
+                    local.get $8
+                    local.get $10
+                    i32.sub
+                    local.get $4
+                    i32.and
+                    local.tee $3
+                    i32.const 2147483647
+                    i32.lt_u
+                    if ;; label = @9
+                      local.get $3
+                      call $45
+                      local.tee $1
+                      local.get $2
+                      i32.load
+                      local.get $5
+                      i32.load
+                      i32.add
+                      i32.eq
+                      if ;; label = @10
+                        local.get $1
+                        i32.const -1
+                        i32.ne
+                        br_if 7 (;@3;)
+                      else
+                        block ;; label = @11
+                          local.get $1
+                          local.set $2
+                          local.get $3
+                          local.set $1
+                          br 4 (;@7;)
+                        end
+                      end
+                    end
+                    br 2 (;@6;)
+                  end
+                  i32.const 0
+                  call $45
+                  local.tee $1
+                  i32.const -1
+                  i32.ne
+                  if ;; label = @8
+                    block ;; label = @9
+                      i32.const 4652
+                      i32.load
+                      local.tee $2
+                      i32.const -1
+                      i32.add
+                      local.tee $5
+                      local.get $1
+                      local.tee $3
+                      i32.add
+                      i32.const 0
+                      local.get $2
+                      i32.sub
+                      i32.and
+                      local.get $3
+                      i32.sub
+                      local.set $2
+                      local.get $5
+                      local.get $3
+                      i32.and
+                      if (result i32) ;; label = @10
+                        local.get $2
+                      else
+                        i32.const 0
+                      end
+                      local.get $6
+                      i32.add
+                      local.tee $3
+                      i32.const 4608
+                      i32.load
+                      local.tee $5
+                      i32.add
+                      local.set $4
+                      local.get $3
+                      local.get $0
+                      i32.gt_u
+                      local.get $3
+                      i32.const 2147483647
+                      i32.lt_u
+                      i32.and
+                      if ;; label = @10
+                        block ;; label = @11
+                          i32.const 4616
+                          i32.load
+                          local.tee $2
+                          if ;; label = @12
+                            local.get $4
+                            local.get $5
+                            i32.le_u
+                            local.get $4
+                            local.get $2
+                            i32.gt_u
+                            i32.or
+                            br_if 6 (;@6;)
+                          end
+                          local.get $3
+                          call $45
+                          local.tee $2
+                          local.get $1
+                          i32.eq
+                          br_if 8 (;@3;)
+                          local.get $3
+                          local.set $1
+                          br 4 (;@7;)
+                        end
+                      end
+                    end
+                  end
+                  br 1 (;@6;)
+                end
+                i32.const 0
+                local.get $1
+                i32.sub
+                local.set $5
+                local.get $7
+                local.get $1
+                i32.gt_u
+                local.get $1
+                i32.const 2147483647
+                i32.lt_u
+                local.get $2
+                i32.const -1
+                i32.ne
+                i32.and
+                i32.and
+                if ;; label = @7
+                  local.get $13
+                  local.get $1
+                  i32.sub
+                  i32.const 4656
+                  i32.load
+                  local.tee $3
+                  i32.add
+                  i32.const 0
+                  local.get $3
+                  i32.sub
+                  i32.and
+                  local.tee $3
+                  i32.const 2147483647
+                  i32.lt_u
+                  if ;; label = @8
+                    local.get $3
+                    call $45
+                    i32.const -1
+                    i32.eq
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $5
+                        call $45
+                        drop
+                        br 4 (;@6;)
+                      end
+                    else
+                      local.get $3
+                      local.get $1
+                      i32.add
+                      local.set $3
+                    end
+                  else
+                    local.get $1
+                    local.set $3
+                  end
+                else
+                  local.get $1
+                  local.set $3
+                end
+                local.get $2
+                i32.const -1
+                i32.ne
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $2
+                    local.set $1
+                    br 5 (;@3;)
+                  end
+                end
+              end
+              i32.const 4620
+              i32.const 4620
+              i32.load
+              i32.const 4
+              i32.or
+              i32.store
+            end
+          end
+          local.get $6
+          i32.const 2147483647
+          i32.lt_u
+          if ;; label = @4
+            local.get $6
+            call $45
+            local.tee $1
+            i32.const 0
+            call $45
+            local.tee $3
+            i32.lt_u
+            local.get $1
+            i32.const -1
+            i32.ne
+            local.get $3
+            i32.const -1
+            i32.ne
+            i32.and
+            i32.and
+            if ;; label = @5
+              local.get $3
+              local.get $1
+              i32.sub
+              local.tee $3
+              local.get $0
+              i32.const 40
+              i32.add
+              i32.gt_u
+              br_if 2 (;@3;)
+            end
+          end
+          br 1 (;@2;)
+        end
+        i32.const 4608
+        i32.const 4608
+        i32.load
+        local.get $3
+        i32.add
+        local.tee $2
+        i32.store
+        local.get $2
+        i32.const 4612
+        i32.load
+        i32.gt_u
+        if ;; label = @3
+          i32.const 4612
+          local.get $2
+          i32.store
+        end
+        block $label$198 ;; label = @3
+          i32.const 4200
+          i32.load
+          local.tee $8
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 4624
+              local.set $2
+              block $label$200 ;; label = @6
+                block $label$201 ;; label = @7
+                  loop $label$202 ;; label = @8
+                    local.get $1
+                    local.get $2
+                    i32.load
+                    local.tee $4
+                    local.get $2
+                    i32.const 4
+                    i32.add
+                    local.tee $7
+                    i32.load
+                    local.tee $5
+                    i32.add
+                    i32.eq
+                    br_if 1 (;@7;)
+                    local.get $2
+                    i32.load offset=8
+                    local.tee $2
+                    br_if 0 (;@8;)
+                  end
+                  br 1 (;@6;)
+                end
+                local.get $2
+                i32.load offset=12
+                i32.const 8
+                i32.and
+                i32.eqz
+                if ;; label = @7
+                  local.get $8
+                  local.get $1
+                  i32.lt_u
+                  local.get $8
+                  local.get $4
+                  i32.ge_u
+                  i32.and
+                  if ;; label = @8
+                    block ;; label = @9
+                      local.get $7
+                      local.get $5
+                      local.get $3
+                      i32.add
+                      i32.store
+                      i32.const 4188
+                      i32.load
+                      local.set $5
+                      i32.const 0
+                      local.get $8
+                      i32.const 8
+                      i32.add
+                      local.tee $2
+                      i32.sub
+                      i32.const 7
+                      i32.and
+                      local.set $1
+                      i32.const 4200
+                      local.get $8
+                      local.get $2
+                      i32.const 7
+                      i32.and
+                      if (result i32) ;; label = @10
+                        local.get $1
+                      else
+                        i32.const 0
+                        local.tee $1
+                      end
+                      i32.add
+                      local.tee $2
+                      i32.store
+                      i32.const 4188
+                      local.get $3
+                      local.get $1
+                      i32.sub
+                      local.get $5
+                      i32.add
+                      local.tee $1
+                      i32.store
+                      local.get $2
+                      local.get $1
+                      i32.const 1
+                      i32.or
+                      i32.store offset=4
+                      local.get $2
+                      local.get $1
+                      i32.add
+                      i32.const 40
+                      i32.store offset=4
+                      i32.const 4204
+                      i32.const 4664
+                      i32.load
+                      i32.store
+                      br 6 (;@3;)
+                    end
+                  end
+                end
+              end
+              local.get $1
+              i32.const 4192
+              i32.load
+              local.tee $2
+              i32.lt_u
+              if ;; label = @6
+                block ;; label = @7
+                  i32.const 4192
+                  local.get $1
+                  i32.store
+                  local.get $1
+                  local.set $2
+                end
+              end
+              local.get $1
+              local.get $3
+              i32.add
+              local.set $10
+              i32.const 4624
+              local.set $5
+              block $label$208 ;; label = @6
+                block $label$209 ;; label = @7
+                  loop $label$210 ;; label = @8
+                    local.get $5
+                    i32.load
+                    local.get $10
+                    i32.eq
+                    br_if 1 (;@7;)
+                    local.get $5
+                    i32.load offset=8
+                    local.tee $5
+                    br_if 0 (;@8;)
+                    i32.const 4624
+                    local.set $5
+                  end
+                  br 1 (;@6;)
+                end
+                local.get $5
+                i32.load offset=12
+                i32.const 8
+                i32.and
+                if ;; label = @7
+                  i32.const 4624
+                  local.set $5
+                else
+                  block ;; label = @8
+                    local.get $5
+                    local.get $1
+                    i32.store
+                    local.get $5
+                    i32.const 4
+                    i32.add
+                    local.tee $5
+                    local.get $5
+                    i32.load
+                    local.get $3
+                    i32.add
+                    i32.store
+                    i32.const 0
+                    local.get $1
+                    i32.const 8
+                    i32.add
+                    local.tee $4
+                    i32.sub
+                    i32.const 7
+                    i32.and
+                    local.set $7
+                    i32.const 0
+                    local.get $10
+                    i32.const 8
+                    i32.add
+                    local.tee $5
+                    i32.sub
+                    i32.const 7
+                    i32.and
+                    local.set $3
+                    local.get $1
+                    local.get $4
+                    i32.const 7
+                    i32.and
+                    if (result i32) ;; label = @9
+                      local.get $7
+                    else
+                      i32.const 0
+                    end
+                    i32.add
+                    local.tee $13
+                    local.get $0
+                    i32.add
+                    local.set $6
+                    local.get $10
+                    local.get $5
+                    i32.const 7
+                    i32.and
+                    if (result i32) ;; label = @9
+                      local.get $3
+                    else
+                      i32.const 0
+                    end
+                    i32.add
+                    local.tee $4
+                    local.get $13
+                    i32.sub
+                    local.get $0
+                    i32.sub
+                    local.set $7
+                    local.get $13
+                    local.get $0
+                    i32.const 3
+                    i32.or
+                    i32.store offset=4
+                    block $label$217 ;; label = @9
+                      local.get $4
+                      local.get $8
+                      i32.eq
+                      if ;; label = @10
+                        block ;; label = @11
+                          i32.const 4188
+                          i32.const 4188
+                          i32.load
+                          local.get $7
+                          i32.add
+                          local.tee $0
+                          i32.store
+                          i32.const 4200
+                          local.get $6
+                          i32.store
+                          local.get $6
+                          local.get $0
+                          i32.const 1
+                          i32.or
+                          i32.store offset=4
+                        end
+                      else
+                        block ;; label = @11
+                          local.get $4
+                          i32.const 4196
+                          i32.load
+                          i32.eq
+                          if ;; label = @12
+                            block ;; label = @13
+                              i32.const 4184
+                              i32.const 4184
+                              i32.load
+                              local.get $7
+                              i32.add
+                              local.tee $0
+                              i32.store
+                              i32.const 4196
+                              local.get $6
+                              i32.store
+                              local.get $6
+                              local.get $0
+                              i32.const 1
+                              i32.or
+                              i32.store offset=4
+                              local.get $6
+                              local.get $0
+                              i32.add
+                              local.get $0
+                              i32.store
+                              br 4 (;@9;)
+                            end
+                          end
+                          local.get $4
+                          i32.load offset=4
+                          local.tee $0
+                          i32.const 3
+                          i32.and
+                          i32.const 1
+                          i32.eq
+                          if (result i32) ;; label = @12
+                            block (result i32) ;; label = @13
+                              local.get $0
+                              i32.const -8
+                              i32.and
+                              local.set $11
+                              local.get $0
+                              i32.const 3
+                              i32.shr_u
+                              local.set $1
+                              block $label$222 ;; label = @14
+                                local.get $0
+                                i32.const 256
+                                i32.lt_u
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $4
+                                    i32.load offset=12
+                                    local.set $5
+                                    block $label$224 ;; label = @17
+                                      local.get $4
+                                      i32.load offset=8
+                                      local.tee $3
+                                      local.get $1
+                                      i32.const 1
+                                      i32.shl
+                                      i32.const 2
+                                      i32.shl
+                                      i32.const 4216
+                                      i32.add
+                                      local.tee $0
+                                      i32.ne
+                                      if ;; label = @18
+                                        block ;; label = @19
+                                          local.get $3
+                                          local.get $2
+                                          i32.lt_u
+                                          if ;; label = @20
+                                            call $fimport$8
+                                          end
+                                          local.get $3
+                                          i32.load offset=12
+                                          local.get $4
+                                          i32.eq
+                                          br_if 2 (;@17;)
+                                          call $fimport$8
+                                        end
+                                      end
+                                    end
+                                    local.get $5
+                                    local.get $3
+                                    i32.eq
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        i32.const 4176
+                                        i32.const 4176
+                                        i32.load
+                                        i32.const 1
+                                        local.get $1
+                                        i32.shl
+                                        i32.const -1
+                                        i32.xor
+                                        i32.and
+                                        i32.store
+                                        br 4 (;@14;)
+                                      end
+                                    end
+                                    block $label$228 ;; label = @17
+                                      local.get $5
+                                      local.get $0
+                                      i32.eq
+                                      if ;; label = @18
+                                        local.get $5
+                                        i32.const 8
+                                        i32.add
+                                        local.set $20
+                                      else
+                                        block ;; label = @19
+                                          local.get $5
+                                          local.get $2
+                                          i32.lt_u
+                                          if ;; label = @20
+                                            call $fimport$8
+                                          end
+                                          local.get $5
+                                          i32.const 8
+                                          i32.add
+                                          local.tee $0
+                                          i32.load
+                                          local.get $4
+                                          i32.eq
+                                          if ;; label = @20
+                                            block ;; label = @21
+                                              local.get $0
+                                              local.set $20
+                                              br 4 (;@17;)
+                                            end
+                                          end
+                                          call $fimport$8
+                                        end
+                                      end
+                                    end
+                                    local.get $3
+                                    local.get $5
+                                    i32.store offset=12
+                                    local.get $20
+                                    local.get $3
+                                    i32.store
+                                  end
+                                else
+                                  block ;; label = @16
+                                    local.get $4
+                                    i32.load offset=24
+                                    local.set $8
+                                    block $label$234 ;; label = @17
+                                      local.get $4
+                                      i32.load offset=12
+                                      local.tee $0
+                                      local.get $4
+                                      i32.eq
+                                      if ;; label = @18
+                                        block ;; label = @19
+                                          local.get $4
+                                          i32.const 16
+                                          i32.add
+                                          local.tee $3
+                                          i32.const 4
+                                          i32.add
+                                          local.tee $1
+                                          i32.load
+                                          local.tee $0
+                                          i32.eqz
+                                          if ;; label = @20
+                                            local.get $3
+                                            i32.load
+                                            local.tee $0
+                                            if ;; label = @21
+                                              local.get $3
+                                              local.set $1
+                                            else
+                                              block ;; label = @22
+                                                i32.const 0
+                                                local.set $12
+                                                br 5 (;@17;)
+                                              end
+                                            end
+                                          end
+                                          loop $label$239 ;; label = @20
+                                            local.get $0
+                                            i32.const 20
+                                            i32.add
+                                            local.tee $5
+                                            i32.load
+                                            local.tee $3
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                local.get $3
+                                                local.set $0
+                                                local.get $5
+                                                local.set $1
+                                                br 2 (;@20;)
+                                              end
+                                            end
+                                            local.get $0
+                                            i32.const 16
+                                            i32.add
+                                            local.tee $5
+                                            i32.load
+                                            local.tee $3
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                local.get $3
+                                                local.set $0
+                                                local.get $5
+                                                local.set $1
+                                                br 2 (;@20;)
+                                              end
+                                            end
+                                          end
+                                          local.get $1
+                                          local.get $2
+                                          i32.lt_u
+                                          if ;; label = @20
+                                            call $fimport$8
+                                          else
+                                            block ;; label = @21
+                                              local.get $1
+                                              i32.const 0
+                                              i32.store
+                                              local.get $0
+                                              local.set $12
+                                            end
+                                          end
+                                        end
+                                      else
+                                        block ;; label = @19
+                                          local.get $4
+                                          i32.load offset=8
+                                          local.tee $5
+                                          local.get $2
+                                          i32.lt_u
+                                          if ;; label = @20
+                                            call $fimport$8
+                                          end
+                                          local.get $5
+                                          i32.const 12
+                                          i32.add
+                                          local.tee $3
+                                          i32.load
+                                          local.get $4
+                                          i32.ne
+                                          if ;; label = @20
+                                            call $fimport$8
+                                          end
+                                          local.get $0
+                                          i32.const 8
+                                          i32.add
+                                          local.tee $1
+                                          i32.load
+                                          local.get $4
+                                          i32.eq
+                                          if ;; label = @20
+                                            block ;; label = @21
+                                              local.get $3
+                                              local.get $0
+                                              i32.store
+                                              local.get $1
+                                              local.get $5
+                                              i32.store
+                                              local.get $0
+                                              local.set $12
+                                            end
+                                          else
+                                            call $fimport$8
+                                          end
+                                        end
+                                      end
+                                    end
+                                    local.get $8
+                                    i32.eqz
+                                    br_if 2 (;@14;)
+                                    block $label$249 ;; label = @17
+                                      local.get $4
+                                      local.get $4
+                                      i32.load offset=28
+                                      local.tee $1
+                                      i32.const 2
+                                      i32.shl
+                                      i32.const 4480
+                                      i32.add
+                                      local.tee $0
+                                      i32.load
+                                      i32.eq
+                                      if ;; label = @18
+                                        block ;; label = @19
+                                          local.get $0
+                                          local.get $12
+                                          i32.store
+                                          local.get $12
+                                          br_if 2 (;@17;)
+                                          i32.const 4180
+                                          i32.const 4180
+                                          i32.load
+                                          i32.const 1
+                                          local.get $1
+                                          i32.shl
+                                          i32.const -1
+                                          i32.xor
+                                          i32.and
+                                          i32.store
+                                          br 5 (;@14;)
+                                        end
+                                      else
+                                        block ;; label = @19
+                                          local.get $8
+                                          i32.const 4192
+                                          i32.load
+                                          i32.lt_u
+                                          if ;; label = @20
+                                            call $fimport$8
+                                          end
+                                          local.get $8
+                                          i32.const 16
+                                          i32.add
+                                          local.tee $0
+                                          i32.load
+                                          local.get $4
+                                          i32.eq
+                                          if ;; label = @20
+                                            local.get $0
+                                            local.get $12
+                                            i32.store
+                                          else
+                                            local.get $8
+                                            local.get $12
+                                            i32.store offset=20
+                                          end
+                                          local.get $12
+                                          i32.eqz
+                                          br_if 5 (;@14;)
+                                        end
+                                      end
+                                    end
+                                    local.get $12
+                                    i32.const 4192
+                                    i32.load
+                                    local.tee $1
+                                    i32.lt_u
+                                    if ;; label = @17
+                                      call $fimport$8
+                                    end
+                                    local.get $12
+                                    local.get $8
+                                    i32.store offset=24
+                                    local.get $4
+                                    i32.const 16
+                                    i32.add
+                                    local.tee $0
+                                    i32.load
+                                    local.tee $3
+                                    if ;; label = @17
+                                      local.get $3
+                                      local.get $1
+                                      i32.lt_u
+                                      if ;; label = @18
+                                        call $fimport$8
+                                      else
+                                        block ;; label = @19
+                                          local.get $12
+                                          local.get $3
+                                          i32.store offset=16
+                                          local.get $3
+                                          local.get $12
+                                          i32.store offset=24
+                                        end
+                                      end
+                                    end
+                                    local.get $0
+                                    i32.load offset=4
+                                    local.tee $0
+                                    i32.eqz
+                                    br_if 2 (;@14;)
+                                    local.get $0
+                                    i32.const 4192
+                                    i32.load
+                                    i32.lt_u
+                                    if ;; label = @17
+                                      call $fimport$8
+                                    else
+                                      block ;; label = @18
+                                        local.get $12
+                                        local.get $0
+                                        i32.store offset=20
+                                        local.get $0
+                                        local.get $12
+                                        i32.store offset=24
+                                      end
+                                    end
+                                  end
+                                end
+                              end
+                              local.get $11
+                              local.get $7
+                              i32.add
+                              local.set $7
+                              local.get $4
+                              local.get $11
+                              i32.add
+                            end
+                          else
+                            local.get $4
+                          end
+                          local.tee $0
+                          i32.const 4
+                          i32.add
+                          local.tee $0
+                          local.get $0
+                          i32.load
+                          i32.const -2
+                          i32.and
+                          i32.store
+                          local.get $6
+                          local.get $7
+                          i32.const 1
+                          i32.or
+                          i32.store offset=4
+                          local.get $6
+                          local.get $7
+                          i32.add
+                          local.get $7
+                          i32.store
+                          local.get $7
+                          i32.const 3
+                          i32.shr_u
+                          local.set $0
+                          local.get $7
+                          i32.const 256
+                          i32.lt_u
+                          if ;; label = @12
+                            block ;; label = @13
+                              local.get $0
+                              i32.const 1
+                              i32.shl
+                              i32.const 2
+                              i32.shl
+                              i32.const 4216
+                              i32.add
+                              local.set $3
+                              block $label$263 ;; label = @14
+                                i32.const 4176
+                                i32.load
+                                local.tee $1
+                                i32.const 1
+                                local.get $0
+                                i32.shl
+                                local.tee $0
+                                i32.and
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $3
+                                    i32.const 8
+                                    i32.add
+                                    local.tee $1
+                                    i32.load
+                                    local.tee $0
+                                    i32.const 4192
+                                    i32.load
+                                    i32.ge_u
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        local.get $1
+                                        local.set $21
+                                        local.get $0
+                                        local.set $9
+                                        br 4 (;@14;)
+                                      end
+                                    end
+                                    call $fimport$8
+                                  end
+                                else
+                                  block ;; label = @16
+                                    i32.const 4176
+                                    local.get $1
+                                    local.get $0
+                                    i32.or
+                                    i32.store
+                                    local.get $3
+                                    i32.const 8
+                                    i32.add
+                                    local.set $21
+                                    local.get $3
+                                    local.set $9
+                                  end
+                                end
+                              end
+                              local.get $21
+                              local.get $6
+                              i32.store
+                              local.get $9
+                              local.get $6
+                              i32.store offset=12
+                              local.get $6
+                              local.get $9
+                              i32.store offset=8
+                              local.get $6
+                              local.get $3
+                              i32.store offset=12
+                              br 4 (;@9;)
+                            end
+                          end
+                          block $label$267 (result i32) ;; label = @12
+                            local.get $7
+                            i32.const 8
+                            i32.shr_u
+                            local.tee $0
+                            if (result i32) ;; label = @13
+                              block (result i32) ;; label = @14
+                                i32.const 31
+                                local.get $7
+                                i32.const 16777215
+                                i32.gt_u
+                                br_if 2 (;@12;)
+                                drop
+                                local.get $7
+                                i32.const 14
+                                local.get $0
+                                local.get $0
+                                i32.const 1048320
+                                i32.add
+                                i32.const 16
+                                i32.shr_u
+                                i32.const 8
+                                i32.and
+                                local.tee $3
+                                i32.shl
+                                local.tee $1
+                                i32.const 520192
+                                i32.add
+                                i32.const 16
+                                i32.shr_u
+                                i32.const 4
+                                i32.and
+                                local.tee $0
+                                local.get $3
+                                i32.or
+                                local.get $1
+                                local.get $0
+                                i32.shl
+                                local.tee $1
+                                i32.const 245760
+                                i32.add
+                                i32.const 16
+                                i32.shr_u
+                                i32.const 2
+                                i32.and
+                                local.tee $0
+                                i32.or
+                                i32.sub
+                                local.get $1
+                                local.get $0
+                                i32.shl
+                                i32.const 15
+                                i32.shr_u
+                                i32.add
+                                local.tee $0
+                                i32.const 7
+                                i32.add
+                                i32.shr_u
+                                i32.const 1
+                                i32.and
+                                local.get $0
+                                i32.const 1
+                                i32.shl
+                                i32.or
+                              end
+                            else
+                              i32.const 0
+                            end
+                          end
+                          local.tee $2
+                          i32.const 2
+                          i32.shl
+                          i32.const 4480
+                          i32.add
+                          local.set $3
+                          local.get $6
+                          local.get $2
+                          i32.store offset=28
+                          local.get $6
+                          i32.const 16
+                          i32.add
+                          local.tee $0
+                          i32.const 0
+                          i32.store offset=4
+                          local.get $0
+                          i32.const 0
+                          i32.store
+                          i32.const 4180
+                          i32.load
+                          local.tee $1
+                          i32.const 1
+                          local.get $2
+                          i32.shl
+                          local.tee $0
+                          i32.and
+                          i32.eqz
+                          if ;; label = @12
+                            block ;; label = @13
+                              i32.const 4180
+                              local.get $1
+                              local.get $0
+                              i32.or
+                              i32.store
+                              local.get $3
+                              local.get $6
+                              i32.store
+                              local.get $6
+                              local.get $3
+                              i32.store offset=24
+                              local.get $6
+                              local.get $6
+                              i32.store offset=12
+                              local.get $6
+                              local.get $6
+                              i32.store offset=8
+                              br 4 (;@9;)
+                            end
+                          end
+                          local.get $3
+                          i32.load
+                          local.set $0
+                          i32.const 25
+                          local.get $2
+                          i32.const 1
+                          i32.shr_u
+                          i32.sub
+                          local.set $1
+                          local.get $7
+                          local.get $2
+                          i32.const 31
+                          i32.eq
+                          if (result i32) ;; label = @12
+                            i32.const 0
+                          else
+                            local.get $1
+                          end
+                          i32.shl
+                          local.set $2
+                          block $label$273 ;; label = @12
+                            block $label$274 ;; label = @13
+                              block $label$275 ;; label = @14
+                                loop $label$276 ;; label = @15
+                                  local.get $0
+                                  i32.load offset=4
+                                  i32.const -8
+                                  i32.and
+                                  local.get $7
+                                  i32.eq
+                                  br_if 2 (;@13;)
+                                  local.get $2
+                                  i32.const 1
+                                  i32.shl
+                                  local.set $3
+                                  local.get $0
+                                  i32.const 16
+                                  i32.add
+                                  local.get $2
+                                  i32.const 31
+                                  i32.shr_u
+                                  i32.const 2
+                                  i32.shl
+                                  i32.add
+                                  local.tee $2
+                                  i32.load
+                                  local.tee $1
+                                  i32.eqz
+                                  br_if 1 (;@14;)
+                                  local.get $3
+                                  local.set $2
+                                  local.get $1
+                                  local.set $0
+                                  br 0 (;@15;)
+                                end
+                              end
+                              local.get $2
+                              i32.const 4192
+                              i32.load
+                              i32.lt_u
+                              if ;; label = @14
+                                call $fimport$8
+                              else
+                                block ;; label = @15
+                                  local.get $2
+                                  local.get $6
+                                  i32.store
+                                  local.get $6
+                                  local.get $0
+                                  i32.store offset=24
+                                  local.get $6
+                                  local.get $6
+                                  i32.store offset=12
+                                  local.get $6
+                                  local.get $6
+                                  i32.store offset=8
+                                  br 6 (;@9;)
+                                end
+                              end
+                              br 1 (;@12;)
+                            end
+                            local.get $0
+                            i32.const 8
+                            i32.add
+                            local.tee $3
+                            i32.load
+                            local.tee $2
+                            i32.const 4192
+                            i32.load
+                            local.tee $1
+                            i32.ge_u
+                            local.get $0
+                            local.get $1
+                            i32.ge_u
+                            i32.and
+                            if ;; label = @13
+                              block ;; label = @14
+                                local.get $2
+                                local.get $6
+                                i32.store offset=12
+                                local.get $3
+                                local.get $6
+                                i32.store
+                                local.get $6
+                                local.get $2
+                                i32.store offset=8
+                                local.get $6
+                                local.get $0
+                                i32.store offset=12
+                                local.get $6
+                                i32.const 0
+                                i32.store offset=24
+                              end
+                            else
+                              call $fimport$8
+                            end
+                          end
+                        end
+                      end
+                    end
+                    local.get $14
+                    global.set $global$1
+                    local.get $13
+                    i32.const 8
+                    i32.add
+                    return
+                  end
+                end
+              end
+              loop $label$281 ;; label = @6
+                block $label$282 ;; label = @7
+                  local.get $5
+                  i32.load
+                  local.tee $2
+                  local.get $8
+                  i32.le_u
+                  if ;; label = @8
+                    local.get $2
+                    local.get $5
+                    i32.load offset=4
+                    i32.add
+                    local.tee $13
+                    local.get $8
+                    i32.gt_u
+                    br_if 1 (;@7;)
+                  end
+                  local.get $5
+                  i32.load offset=8
+                  local.set $5
+                  br 1 (;@6;)
+                end
+              end
+              i32.const 0
+              local.get $13
+              i32.const -47
+              i32.add
+              local.tee $7
+              i32.const 8
+              i32.add
+              local.tee $5
+              i32.sub
+              i32.const 7
+              i32.and
+              local.set $2
+              local.get $7
+              local.get $5
+              i32.const 7
+              i32.and
+              if (result i32) ;; label = @6
+                local.get $2
+              else
+                i32.const 0
+              end
+              i32.add
+              local.tee $2
+              local.get $8
+              i32.const 16
+              i32.add
+              local.tee $12
+              i32.lt_u
+              if (result i32) ;; label = @6
+                local.get $8
+              else
+                local.get $2
+              end
+              local.tee $7
+              i32.const 8
+              i32.add
+              local.set $10
+              local.get $7
+              i32.const 24
+              i32.add
+              local.set $5
+              local.get $3
+              i32.const -40
+              i32.add
+              local.set $9
+              i32.const 0
+              local.get $1
+              i32.const 8
+              i32.add
+              local.tee $4
+              i32.sub
+              i32.const 7
+              i32.and
+              local.set $2
+              i32.const 4200
+              local.get $1
+              local.get $4
+              i32.const 7
+              i32.and
+              if (result i32) ;; label = @6
+                local.get $2
+              else
+                i32.const 0
+                local.tee $2
+              end
+              i32.add
+              local.tee $4
+              i32.store
+              i32.const 4188
+              local.get $9
+              local.get $2
+              i32.sub
+              local.tee $2
+              i32.store
+              local.get $4
+              local.get $2
+              i32.const 1
+              i32.or
+              i32.store offset=4
+              local.get $4
+              local.get $2
+              i32.add
+              i32.const 40
+              i32.store offset=4
+              i32.const 4204
+              i32.const 4664
+              i32.load
+              i32.store
+              local.get $7
+              i32.const 4
+              i32.add
+              local.tee $2
+              i32.const 27
+              i32.store
+              local.get $10
+              i32.const 4624
+              i64.load align=4
+              i64.store align=4
+              local.get $10
+              i32.const 4632
+              i64.load align=4
+              i64.store offset=8 align=4
+              i32.const 4624
+              local.get $1
+              i32.store
+              i32.const 4628
+              local.get $3
+              i32.store
+              i32.const 4636
+              i32.const 0
+              i32.store
+              i32.const 4632
+              local.get $10
+              i32.store
+              local.get $5
+              local.set $1
+              loop $label$290 ;; label = @6
+                local.get $1
+                i32.const 4
+                i32.add
+                local.tee $1
+                i32.const 7
+                i32.store
+                local.get $1
+                i32.const 4
+                i32.add
+                local.get $13
+                i32.lt_u
+                br_if 0 (;@6;)
+              end
+              local.get $7
+              local.get $8
+              i32.ne
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $2
+                  local.get $2
+                  i32.load
+                  i32.const -2
+                  i32.and
+                  i32.store
+                  local.get $8
+                  local.get $7
+                  local.get $8
+                  i32.sub
+                  local.tee $4
+                  i32.const 1
+                  i32.or
+                  i32.store offset=4
+                  local.get $7
+                  local.get $4
+                  i32.store
+                  local.get $4
+                  i32.const 3
+                  i32.shr_u
+                  local.set $1
+                  local.get $4
+                  i32.const 256
+                  i32.lt_u
+                  if ;; label = @8
+                    block ;; label = @9
+                      local.get $1
+                      i32.const 1
+                      i32.shl
+                      i32.const 2
+                      i32.shl
+                      i32.const 4216
+                      i32.add
+                      local.set $2
+                      i32.const 4176
+                      i32.load
+                      local.tee $3
+                      i32.const 1
+                      local.get $1
+                      i32.shl
+                      local.tee $1
+                      i32.and
+                      if ;; label = @10
+                        local.get $2
+                        i32.const 8
+                        i32.add
+                        local.tee $3
+                        i32.load
+                        local.tee $1
+                        i32.const 4192
+                        i32.load
+                        i32.lt_u
+                        if ;; label = @11
+                          call $fimport$8
+                        else
+                          block ;; label = @12
+                            local.get $3
+                            local.set $15
+                            local.get $1
+                            local.set $11
+                          end
+                        end
+                      else
+                        block ;; label = @11
+                          i32.const 4176
+                          local.get $3
+                          local.get $1
+                          i32.or
+                          i32.store
+                          local.get $2
+                          i32.const 8
+                          i32.add
+                          local.set $15
+                          local.get $2
+                          local.set $11
+                        end
+                      end
+                      local.get $15
+                      local.get $8
+                      i32.store
+                      local.get $11
+                      local.get $8
+                      i32.store offset=12
+                      local.get $8
+                      local.get $11
+                      i32.store offset=8
+                      local.get $8
+                      local.get $2
+                      i32.store offset=12
+                      br 6 (;@3;)
+                    end
+                  end
+                  local.get $4
+                  i32.const 8
+                  i32.shr_u
+                  local.tee $1
+                  if (result i32) ;; label = @8
+                    local.get $4
+                    i32.const 16777215
+                    i32.gt_u
+                    if (result i32) ;; label = @9
+                      i32.const 31
+                    else
+                      local.get $4
+                      i32.const 14
+                      local.get $1
+                      local.get $1
+                      i32.const 1048320
+                      i32.add
+                      i32.const 16
+                      i32.shr_u
+                      i32.const 8
+                      i32.and
+                      local.tee $2
+                      i32.shl
+                      local.tee $3
+                      i32.const 520192
+                      i32.add
+                      i32.const 16
+                      i32.shr_u
+                      i32.const 4
+                      i32.and
+                      local.tee $1
+                      local.get $2
+                      i32.or
+                      local.get $3
+                      local.get $1
+                      i32.shl
+                      local.tee $3
+                      i32.const 245760
+                      i32.add
+                      i32.const 16
+                      i32.shr_u
+                      i32.const 2
+                      i32.and
+                      local.tee $1
+                      i32.or
+                      i32.sub
+                      local.get $3
+                      local.get $1
+                      i32.shl
+                      i32.const 15
+                      i32.shr_u
+                      i32.add
+                      local.tee $1
+                      i32.const 7
+                      i32.add
+                      i32.shr_u
+                      i32.const 1
+                      i32.and
+                      local.get $1
+                      i32.const 1
+                      i32.shl
+                      i32.or
+                    end
+                  else
+                    i32.const 0
+                  end
+                  local.tee $5
+                  i32.const 2
+                  i32.shl
+                  i32.const 4480
+                  i32.add
+                  local.set $2
+                  local.get $8
+                  local.get $5
+                  i32.store offset=28
+                  local.get $8
+                  i32.const 0
+                  i32.store offset=20
+                  local.get $12
+                  i32.const 0
+                  i32.store
+                  i32.const 4180
+                  i32.load
+                  local.tee $3
+                  i32.const 1
+                  local.get $5
+                  i32.shl
+                  local.tee $1
+                  i32.and
+                  i32.eqz
+                  if ;; label = @8
+                    block ;; label = @9
+                      i32.const 4180
+                      local.get $3
+                      local.get $1
+                      i32.or
+                      i32.store
+                      local.get $2
+                      local.get $8
+                      i32.store
+                      local.get $8
+                      local.get $2
+                      i32.store offset=24
+                      local.get $8
+                      local.get $8
+                      i32.store offset=12
+                      local.get $8
+                      local.get $8
+                      i32.store offset=8
+                      br 6 (;@3;)
+                    end
+                  end
+                  local.get $2
+                  i32.load
+                  local.set $1
+                  i32.const 25
+                  local.get $5
+                  i32.const 1
+                  i32.shr_u
+                  i32.sub
+                  local.set $3
+                  local.get $4
+                  local.get $5
+                  i32.const 31
+                  i32.eq
+                  if (result i32) ;; label = @8
+                    i32.const 0
+                  else
+                    local.get $3
+                  end
+                  i32.shl
+                  local.set $5
+                  block $label$304 ;; label = @8
+                    block $label$305 ;; label = @9
+                      block $label$306 ;; label = @10
+                        loop $label$307 ;; label = @11
+                          local.get $1
+                          i32.load offset=4
+                          i32.const -8
+                          i32.and
+                          local.get $4
+                          i32.eq
+                          br_if 2 (;@9;)
+                          local.get $5
+                          i32.const 1
+                          i32.shl
+                          local.set $2
+                          local.get $1
+                          i32.const 16
+                          i32.add
+                          local.get $5
+                          i32.const 31
+                          i32.shr_u
+                          i32.const 2
+                          i32.shl
+                          i32.add
+                          local.tee $5
+                          i32.load
+                          local.tee $3
+                          i32.eqz
+                          br_if 1 (;@10;)
+                          local.get $2
+                          local.set $5
+                          local.get $3
+                          local.set $1
+                          br 0 (;@11;)
+                        end
+                      end
+                      local.get $5
+                      i32.const 4192
+                      i32.load
+                      i32.lt_u
+                      if ;; label = @10
+                        call $fimport$8
+                      else
+                        block ;; label = @11
+                          local.get $5
+                          local.get $8
+                          i32.store
+                          local.get $8
+                          local.get $1
+                          i32.store offset=24
+                          local.get $8
+                          local.get $8
+                          i32.store offset=12
+                          local.get $8
+                          local.get $8
+                          i32.store offset=8
+                          br 8 (;@3;)
+                        end
+                      end
+                      br 1 (;@8;)
+                    end
+                    local.get $1
+                    i32.const 8
+                    i32.add
+                    local.tee $2
+                    i32.load
+                    local.tee $5
+                    i32.const 4192
+                    i32.load
+                    local.tee $3
+                    i32.ge_u
+                    local.get $1
+                    local.get $3
+                    i32.ge_u
+                    i32.and
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $5
+                        local.get $8
+                        i32.store offset=12
+                        local.get $2
+                        local.get $8
+                        i32.store
+                        local.get $8
+                        local.get $5
+                        i32.store offset=8
+                        local.get $8
+                        local.get $1
+                        i32.store offset=12
+                        local.get $8
+                        i32.const 0
+                        i32.store offset=24
+                      end
+                    else
+                      call $fimport$8
+                    end
+                  end
+                end
+              end
+            end
+          else
+            block ;; label = @5
+              i32.const 4192
+              i32.load
+              local.tee $2
+              i32.eqz
+              local.get $1
+              local.get $2
+              i32.lt_u
+              i32.or
+              if ;; label = @6
+                i32.const 4192
+                local.get $1
+                i32.store
+              end
+              i32.const 4624
+              local.get $1
+              i32.store
+              i32.const 4628
+              local.get $3
+              i32.store
+              i32.const 4636
+              i32.const 0
+              i32.store
+              i32.const 4212
+              i32.const 4648
+              i32.load
+              i32.store
+              i32.const 4208
+              i32.const -1
+              i32.store
+              i32.const 0
+              local.set $2
+              loop $label$314 ;; label = @6
+                local.get $2
+                i32.const 1
+                i32.shl
+                i32.const 2
+                i32.shl
+                i32.const 4216
+                i32.add
+                local.tee $5
+                local.get $5
+                i32.store offset=12
+                local.get $5
+                local.get $5
+                i32.store offset=8
+                local.get $2
+                i32.const 1
+                i32.add
+                local.tee $2
+                i32.const 32
+                i32.ne
+                br_if 0 (;@6;)
+              end
+              local.get $3
+              i32.const -40
+              i32.add
+              local.set $5
+              i32.const 0
+              local.get $1
+              i32.const 8
+              i32.add
+              local.tee $2
+              i32.sub
+              i32.const 7
+              i32.and
+              local.set $3
+              i32.const 4200
+              local.get $1
+              local.get $2
+              i32.const 7
+              i32.and
+              if (result i32) ;; label = @6
+                local.get $3
+              else
+                i32.const 0
+              end
+              local.tee $1
+              i32.add
+              local.tee $3
+              i32.store
+              i32.const 4188
+              local.get $5
+              local.get $1
+              i32.sub
+              local.tee $1
+              i32.store
+              local.get $3
+              local.get $1
+              i32.const 1
+              i32.or
+              i32.store offset=4
+              local.get $3
+              local.get $1
+              i32.add
+              i32.const 40
+              i32.store offset=4
+              i32.const 4204
+              i32.const 4664
+              i32.load
+              i32.store
+            end
+          end
+        end
+        i32.const 4188
+        i32.load
+        local.tee $1
+        local.get $0
+        i32.gt_u
+        if ;; label = @3
+          block ;; label = @4
+            i32.const 4188
+            local.get $1
+            local.get $0
+            i32.sub
+            local.tee $3
+            i32.store
+            i32.const 4200
+            i32.const 4200
+            i32.load
+            local.tee $2
+            local.get $0
+            i32.add
+            local.tee $1
+            i32.store
+            local.get $1
+            local.get $3
+            i32.const 1
+            i32.or
+            i32.store offset=4
+            local.get $2
+            local.get $0
+            i32.const 3
+            i32.or
+            i32.store offset=4
+            local.get $14
+            global.set $global$1
+            local.get $2
+            i32.const 8
+            i32.add
+            return
+          end
+        end
+      end
+      call $12
+      i32.const 12
+      i32.store
+      local.get $14
+      global.set $global$1
+      i32.const 0
+    end
+  )
+  (func $38 (;51;) (type $3) (param $0 i32)
+    (local $1 i32) (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32) (local $15 i32)
+    block $label$1 ;; label = @1
+      local.get $0
+      i32.eqz
+      if ;; label = @2
+        return
+      end
+      local.get $0
+      i32.const -8
+      i32.add
+      local.tee $1
+      i32.const 4192
+      i32.load
+      local.tee $11
+      i32.lt_u
+      if ;; label = @2
+        call $fimport$8
+      end
+      local.get $0
+      i32.const -4
+      i32.add
+      i32.load
+      local.tee $0
+      i32.const 3
+      i32.and
+      local.tee $8
+      i32.const 1
+      i32.eq
+      if ;; label = @2
+        call $fimport$8
+      end
+      local.get $1
+      local.get $0
+      i32.const -8
+      i32.and
+      local.tee $4
+      i32.add
+      local.set $6
+      block $label$5 ;; label = @2
+        local.get $0
+        i32.const 1
+        i32.and
+        if ;; label = @3
+          block ;; label = @4
+            local.get $1
+            local.set $3
+            local.get $4
+            local.set $2
+          end
+        else
+          block ;; label = @4
+            local.get $8
+            i32.eqz
+            if ;; label = @5
+              return
+            end
+            local.get $1
+            i32.const 0
+            local.get $1
+            i32.load
+            local.tee $8
+            i32.sub
+            i32.add
+            local.tee $0
+            local.get $11
+            i32.lt_u
+            if ;; label = @5
+              call $fimport$8
+            end
+            local.get $8
+            local.get $4
+            i32.add
+            local.set $1
+            local.get $0
+            i32.const 4196
+            i32.load
+            i32.eq
+            if ;; label = @5
+              block ;; label = @6
+                local.get $6
+                i32.const 4
+                i32.add
+                local.tee $2
+                i32.load
+                local.tee $3
+                i32.const 3
+                i32.and
+                i32.const 3
+                i32.ne
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $0
+                    local.set $3
+                    local.get $1
+                    local.set $2
+                    br 6 (;@2;)
+                  end
+                end
+                i32.const 4184
+                local.get $1
+                i32.store
+                local.get $2
+                local.get $3
+                i32.const -2
+                i32.and
+                i32.store
+                local.get $0
+                local.get $1
+                i32.const 1
+                i32.or
+                i32.store offset=4
+                local.get $0
+                local.get $1
+                i32.add
+                local.get $1
+                i32.store
+                return
+              end
+            end
+            local.get $8
+            i32.const 3
+            i32.shr_u
+            local.set $10
+            local.get $8
+            i32.const 256
+            i32.lt_u
+            if ;; label = @5
+              block ;; label = @6
+                local.get $0
+                i32.load offset=12
+                local.set $3
+                local.get $0
+                i32.load offset=8
+                local.tee $4
+                local.get $10
+                i32.const 1
+                i32.shl
+                i32.const 2
+                i32.shl
+                i32.const 4216
+                i32.add
+                local.tee $2
+                i32.ne
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $4
+                    local.get $11
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$8
+                    end
+                    local.get $4
+                    i32.load offset=12
+                    local.get $0
+                    i32.ne
+                    if ;; label = @9
+                      call $fimport$8
+                    end
+                  end
+                end
+                local.get $3
+                local.get $4
+                i32.eq
+                if ;; label = @7
+                  block ;; label = @8
+                    i32.const 4176
+                    i32.const 4176
+                    i32.load
+                    i32.const 1
+                    local.get $10
+                    i32.shl
+                    i32.const -1
+                    i32.xor
+                    i32.and
+                    i32.store
+                    local.get $0
+                    local.set $3
+                    local.get $1
+                    local.set $2
+                    br 6 (;@2;)
+                  end
+                end
+                local.get $3
+                local.get $2
+                i32.eq
+                if ;; label = @7
+                  local.get $3
+                  i32.const 8
+                  i32.add
+                  local.set $5
+                else
+                  block ;; label = @8
+                    local.get $3
+                    local.get $11
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$8
+                    end
+                    local.get $3
+                    i32.const 8
+                    i32.add
+                    local.tee $2
+                    i32.load
+                    local.get $0
+                    i32.eq
+                    if ;; label = @9
+                      local.get $2
+                      local.set $5
+                    else
+                      call $fimport$8
+                    end
+                  end
+                end
+                local.get $4
+                local.get $3
+                i32.store offset=12
+                local.get $5
+                local.get $4
+                i32.store
+                local.get $0
+                local.set $3
+                local.get $1
+                local.set $2
+                br 4 (;@2;)
+              end
+            end
+            local.get $0
+            i32.load offset=24
+            local.set $12
+            block $label$22 ;; label = @5
+              local.get $0
+              i32.load offset=12
+              local.tee $4
+              local.get $0
+              i32.eq
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $0
+                  i32.const 16
+                  i32.add
+                  local.tee $5
+                  i32.const 4
+                  i32.add
+                  local.tee $8
+                  i32.load
+                  local.tee $4
+                  if ;; label = @8
+                    local.get $8
+                    local.set $5
+                  else
+                    local.get $5
+                    i32.load
+                    local.tee $4
+                    i32.eqz
+                    if ;; label = @9
+                      block ;; label = @10
+                        i32.const 0
+                        local.set $7
+                        br 5 (;@5;)
+                      end
+                    end
+                  end
+                  loop $label$27 ;; label = @8
+                    local.get $4
+                    i32.const 20
+                    i32.add
+                    local.tee $8
+                    i32.load
+                    local.tee $10
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $10
+                        local.set $4
+                        local.get $8
+                        local.set $5
+                        br 2 (;@8;)
+                      end
+                    end
+                    local.get $4
+                    i32.const 16
+                    i32.add
+                    local.tee $8
+                    i32.load
+                    local.tee $10
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $10
+                        local.set $4
+                        local.get $8
+                        local.set $5
+                        br 2 (;@8;)
+                      end
+                    end
+                  end
+                  local.get $5
+                  local.get $11
+                  i32.lt_u
+                  if ;; label = @8
+                    call $fimport$8
+                  else
+                    block ;; label = @9
+                      local.get $5
+                      i32.const 0
+                      i32.store
+                      local.get $4
+                      local.set $7
+                    end
+                  end
+                end
+              else
+                block ;; label = @7
+                  local.get $0
+                  i32.load offset=8
+                  local.tee $5
+                  local.get $11
+                  i32.lt_u
+                  if ;; label = @8
+                    call $fimport$8
+                  end
+                  local.get $5
+                  i32.const 12
+                  i32.add
+                  local.tee $8
+                  i32.load
+                  local.get $0
+                  i32.ne
+                  if ;; label = @8
+                    call $fimport$8
+                  end
+                  local.get $4
+                  i32.const 8
+                  i32.add
+                  local.tee $10
+                  i32.load
+                  local.get $0
+                  i32.eq
+                  if ;; label = @8
+                    block ;; label = @9
+                      local.get $8
+                      local.get $4
+                      i32.store
+                      local.get $10
+                      local.get $5
+                      i32.store
+                      local.get $4
+                      local.set $7
+                    end
+                  else
+                    call $fimport$8
+                  end
+                end
+              end
+            end
+            local.get $12
+            if ;; label = @5
+              block ;; label = @6
+                local.get $0
+                local.get $0
+                i32.load offset=28
+                local.tee $4
+                i32.const 2
+                i32.shl
+                i32.const 4480
+                i32.add
+                local.tee $5
+                i32.load
+                i32.eq
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $5
+                    local.get $7
+                    i32.store
+                    local.get $7
+                    i32.eqz
+                    if ;; label = @9
+                      block ;; label = @10
+                        i32.const 4180
+                        i32.const 4180
+                        i32.load
+                        i32.const 1
+                        local.get $4
+                        i32.shl
+                        i32.const -1
+                        i32.xor
+                        i32.and
+                        i32.store
+                        local.get $0
+                        local.set $3
+                        local.get $1
+                        local.set $2
+                        br 8 (;@2;)
+                      end
+                    end
+                  end
+                else
+                  block ;; label = @8
+                    local.get $12
+                    i32.const 4192
+                    i32.load
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$8
+                    end
+                    local.get $12
+                    i32.const 16
+                    i32.add
+                    local.tee $4
+                    i32.load
+                    local.get $0
+                    i32.eq
+                    if ;; label = @9
+                      local.get $4
+                      local.get $7
+                      i32.store
+                    else
+                      local.get $12
+                      local.get $7
+                      i32.store offset=20
+                    end
+                    local.get $7
+                    i32.eqz
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $0
+                        local.set $3
+                        local.get $1
+                        local.set $2
+                        br 8 (;@2;)
+                      end
+                    end
+                  end
+                end
+                local.get $7
+                i32.const 4192
+                i32.load
+                local.tee $5
+                i32.lt_u
+                if ;; label = @7
+                  call $fimport$8
+                end
+                local.get $7
+                local.get $12
+                i32.store offset=24
+                local.get $0
+                i32.const 16
+                i32.add
+                local.tee $8
+                i32.load
+                local.tee $4
+                if ;; label = @7
+                  local.get $4
+                  local.get $5
+                  i32.lt_u
+                  if ;; label = @8
+                    call $fimport$8
+                  else
+                    block ;; label = @9
+                      local.get $7
+                      local.get $4
+                      i32.store offset=16
+                      local.get $4
+                      local.get $7
+                      i32.store offset=24
+                    end
+                  end
+                end
+                local.get $8
+                i32.load offset=4
+                local.tee $4
+                if ;; label = @7
+                  local.get $4
+                  i32.const 4192
+                  i32.load
+                  i32.lt_u
+                  if ;; label = @8
+                    call $fimport$8
+                  else
+                    block ;; label = @9
+                      local.get $7
+                      local.get $4
+                      i32.store offset=20
+                      local.get $4
+                      local.get $7
+                      i32.store offset=24
+                      local.get $0
+                      local.set $3
+                      local.get $1
+                      local.set $2
+                    end
+                  end
+                else
+                  block ;; label = @8
+                    local.get $0
+                    local.set $3
+                    local.get $1
+                    local.set $2
+                  end
+                end
+              end
+            else
+              block ;; label = @6
+                local.get $0
+                local.set $3
+                local.get $1
+                local.set $2
+              end
+            end
+          end
+        end
+      end
+      local.get $3
+      local.get $6
+      i32.ge_u
+      if ;; label = @2
+        call $fimport$8
+      end
+      local.get $6
+      i32.const 4
+      i32.add
+      local.tee $1
+      i32.load
+      local.tee $0
+      i32.const 1
+      i32.and
+      i32.eqz
+      if ;; label = @2
+        call $fimport$8
+      end
+      local.get $0
+      i32.const 2
+      i32.and
+      if ;; label = @2
+        block ;; label = @3
+          local.get $1
+          local.get $0
+          i32.const -2
+          i32.and
+          i32.store
+          local.get $3
+          local.get $2
+          i32.const 1
+          i32.or
+          i32.store offset=4
+          local.get $3
+          local.get $2
+          i32.add
+          local.get $2
+          i32.store
+        end
+      else
+        block ;; label = @3
+          local.get $6
+          i32.const 4200
+          i32.load
+          i32.eq
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 4188
+              i32.const 4188
+              i32.load
+              local.get $2
+              i32.add
+              local.tee $0
+              i32.store
+              i32.const 4200
+              local.get $3
+              i32.store
+              local.get $3
+              local.get $0
+              i32.const 1
+              i32.or
+              i32.store offset=4
+              local.get $3
+              i32.const 4196
+              i32.load
+              i32.ne
+              if ;; label = @6
+                return
+              end
+              i32.const 4196
+              i32.const 0
+              i32.store
+              i32.const 4184
+              i32.const 0
+              i32.store
+              return
+            end
+          end
+          local.get $6
+          i32.const 4196
+          i32.load
+          i32.eq
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 4184
+              i32.const 4184
+              i32.load
+              local.get $2
+              i32.add
+              local.tee $0
+              i32.store
+              i32.const 4196
+              local.get $3
+              i32.store
+              local.get $3
+              local.get $0
+              i32.const 1
+              i32.or
+              i32.store offset=4
+              local.get $3
+              local.get $0
+              i32.add
+              local.get $0
+              i32.store
+              return
+            end
+          end
+          local.get $0
+          i32.const -8
+          i32.and
+          local.get $2
+          i32.add
+          local.set $5
+          local.get $0
+          i32.const 3
+          i32.shr_u
+          local.set $4
+          block $label$61 ;; label = @4
+            local.get $0
+            i32.const 256
+            i32.lt_u
+            if ;; label = @5
+              block ;; label = @6
+                local.get $6
+                i32.load offset=12
+                local.set $2
+                local.get $6
+                i32.load offset=8
+                local.tee $1
+                local.get $4
+                i32.const 1
+                i32.shl
+                i32.const 2
+                i32.shl
+                i32.const 4216
+                i32.add
+                local.tee $0
+                i32.ne
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $1
+                    i32.const 4192
+                    i32.load
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$8
+                    end
+                    local.get $1
+                    i32.load offset=12
+                    local.get $6
+                    i32.ne
+                    if ;; label = @9
+                      call $fimport$8
+                    end
+                  end
+                end
+                local.get $2
+                local.get $1
+                i32.eq
+                if ;; label = @7
+                  block ;; label = @8
+                    i32.const 4176
+                    i32.const 4176
+                    i32.load
+                    i32.const 1
+                    local.get $4
+                    i32.shl
+                    i32.const -1
+                    i32.xor
+                    i32.and
+                    i32.store
+                    br 4 (;@4;)
+                  end
+                end
+                local.get $2
+                local.get $0
+                i32.eq
+                if ;; label = @7
+                  local.get $2
+                  i32.const 8
+                  i32.add
+                  local.set $14
+                else
+                  block ;; label = @8
+                    local.get $2
+                    i32.const 4192
+                    i32.load
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$8
+                    end
+                    local.get $2
+                    i32.const 8
+                    i32.add
+                    local.tee $0
+                    i32.load
+                    local.get $6
+                    i32.eq
+                    if ;; label = @9
+                      local.get $0
+                      local.set $14
+                    else
+                      call $fimport$8
+                    end
+                  end
+                end
+                local.get $1
+                local.get $2
+                i32.store offset=12
+                local.get $14
+                local.get $1
+                i32.store
+              end
+            else
+              block ;; label = @6
+                local.get $6
+                i32.load offset=24
+                local.set $7
+                block $label$73 ;; label = @7
+                  local.get $6
+                  i32.load offset=12
+                  local.tee $0
+                  local.get $6
+                  i32.eq
+                  if ;; label = @8
+                    block ;; label = @9
+                      local.get $6
+                      i32.const 16
+                      i32.add
+                      local.tee $2
+                      i32.const 4
+                      i32.add
+                      local.tee $1
+                      i32.load
+                      local.tee $0
+                      if ;; label = @10
+                        local.get $1
+                        local.set $2
+                      else
+                        local.get $2
+                        i32.load
+                        local.tee $0
+                        i32.eqz
+                        if ;; label = @11
+                          block ;; label = @12
+                            i32.const 0
+                            local.set $9
+                            br 5 (;@7;)
+                          end
+                        end
+                      end
+                      loop $label$78 ;; label = @10
+                        local.get $0
+                        i32.const 20
+                        i32.add
+                        local.tee $1
+                        i32.load
+                        local.tee $4
+                        if ;; label = @11
+                          block ;; label = @12
+                            local.get $4
+                            local.set $0
+                            local.get $1
+                            local.set $2
+                            br 2 (;@10;)
+                          end
+                        end
+                        local.get $0
+                        i32.const 16
+                        i32.add
+                        local.tee $1
+                        i32.load
+                        local.tee $4
+                        if ;; label = @11
+                          block ;; label = @12
+                            local.get $4
+                            local.set $0
+                            local.get $1
+                            local.set $2
+                            br 2 (;@10;)
+                          end
+                        end
+                      end
+                      local.get $2
+                      i32.const 4192
+                      i32.load
+                      i32.lt_u
+                      if ;; label = @10
+                        call $fimport$8
+                      else
+                        block ;; label = @11
+                          local.get $2
+                          i32.const 0
+                          i32.store
+                          local.get $0
+                          local.set $9
+                        end
+                      end
+                    end
+                  else
+                    block ;; label = @9
+                      local.get $6
+                      i32.load offset=8
+                      local.tee $2
+                      i32.const 4192
+                      i32.load
+                      i32.lt_u
+                      if ;; label = @10
+                        call $fimport$8
+                      end
+                      local.get $2
+                      i32.const 12
+                      i32.add
+                      local.tee $1
+                      i32.load
+                      local.get $6
+                      i32.ne
+                      if ;; label = @10
+                        call $fimport$8
+                      end
+                      local.get $0
+                      i32.const 8
+                      i32.add
+                      local.tee $4
+                      i32.load
+                      local.get $6
+                      i32.eq
+                      if ;; label = @10
+                        block ;; label = @11
+                          local.get $1
+                          local.get $0
+                          i32.store
+                          local.get $4
+                          local.get $2
+                          i32.store
+                          local.get $0
+                          local.set $9
+                        end
+                      else
+                        call $fimport$8
+                      end
+                    end
+                  end
+                end
+                local.get $7
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $6
+                    local.get $6
+                    i32.load offset=28
+                    local.tee $0
+                    i32.const 2
+                    i32.shl
+                    i32.const 4480
+                    i32.add
+                    local.tee $2
+                    i32.load
+                    i32.eq
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $2
+                        local.get $9
+                        i32.store
+                        local.get $9
+                        i32.eqz
+                        if ;; label = @11
+                          block ;; label = @12
+                            i32.const 4180
+                            i32.const 4180
+                            i32.load
+                            i32.const 1
+                            local.get $0
+                            i32.shl
+                            i32.const -1
+                            i32.xor
+                            i32.and
+                            i32.store
+                            br 8 (;@4;)
+                          end
+                        end
+                      end
+                    else
+                      block ;; label = @10
+                        local.get $7
+                        i32.const 4192
+                        i32.load
+                        i32.lt_u
+                        if ;; label = @11
+                          call $fimport$8
+                        end
+                        local.get $7
+                        i32.const 16
+                        i32.add
+                        local.tee $0
+                        i32.load
+                        local.get $6
+                        i32.eq
+                        if ;; label = @11
+                          local.get $0
+                          local.get $9
+                          i32.store
+                        else
+                          local.get $7
+                          local.get $9
+                          i32.store offset=20
+                        end
+                        local.get $9
+                        i32.eqz
+                        br_if 6 (;@4;)
+                      end
+                    end
+                    local.get $9
+                    i32.const 4192
+                    i32.load
+                    local.tee $2
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$8
+                    end
+                    local.get $9
+                    local.get $7
+                    i32.store offset=24
+                    local.get $6
+                    i32.const 16
+                    i32.add
+                    local.tee $1
+                    i32.load
+                    local.tee $0
+                    if ;; label = @9
+                      local.get $0
+                      local.get $2
+                      i32.lt_u
+                      if ;; label = @10
+                        call $fimport$8
+                      else
+                        block ;; label = @11
+                          local.get $9
+                          local.get $0
+                          i32.store offset=16
+                          local.get $0
+                          local.get $9
+                          i32.store offset=24
+                        end
+                      end
+                    end
+                    local.get $1
+                    i32.load offset=4
+                    local.tee $0
+                    if ;; label = @9
+                      local.get $0
+                      i32.const 4192
+                      i32.load
+                      i32.lt_u
+                      if ;; label = @10
+                        call $fimport$8
+                      else
+                        block ;; label = @11
+                          local.get $9
+                          local.get $0
+                          i32.store offset=20
+                          local.get $0
+                          local.get $9
+                          i32.store offset=24
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+          local.get $3
+          local.get $5
+          i32.const 1
+          i32.or
+          i32.store offset=4
+          local.get $3
+          local.get $5
+          i32.add
+          local.get $5
+          i32.store
+          local.get $3
+          i32.const 4196
+          i32.load
+          i32.eq
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 4184
+              local.get $5
+              i32.store
+              return
+            end
+          else
+            local.get $5
+            local.set $2
+          end
+        end
+      end
+      local.get $2
+      i32.const 3
+      i32.shr_u
+      local.set $1
+      local.get $2
+      i32.const 256
+      i32.lt_u
+      if ;; label = @2
+        block ;; label = @3
+          local.get $1
+          i32.const 1
+          i32.shl
+          i32.const 2
+          i32.shl
+          i32.const 4216
+          i32.add
+          local.set $0
+          i32.const 4176
+          i32.load
+          local.tee $2
+          i32.const 1
+          local.get $1
+          i32.shl
+          local.tee $1
+          i32.and
+          if ;; label = @4
+            local.get $0
+            i32.const 8
+            i32.add
+            local.tee $2
+            i32.load
+            local.tee $1
+            i32.const 4192
+            i32.load
+            i32.lt_u
+            if ;; label = @5
+              call $fimport$8
+            else
+              block ;; label = @6
+                local.get $2
+                local.set $15
+                local.get $1
+                local.set $13
+              end
+            end
+          else
+            block ;; label = @5
+              i32.const 4176
+              local.get $2
+              local.get $1
+              i32.or
+              i32.store
+              local.get $0
+              i32.const 8
+              i32.add
+              local.set $15
+              local.get $0
+              local.set $13
+            end
+          end
+          local.get $15
+          local.get $3
+          i32.store
+          local.get $13
+          local.get $3
+          i32.store offset=12
+          local.get $3
+          local.get $13
+          i32.store offset=8
+          local.get $3
+          local.get $0
+          i32.store offset=12
+          return
+        end
+      end
+      local.get $2
+      i32.const 8
+      i32.shr_u
+      local.tee $0
+      if (result i32) ;; label = @2
+        local.get $2
+        i32.const 16777215
+        i32.gt_u
+        if (result i32) ;; label = @3
+          i32.const 31
+        else
+          local.get $2
+          i32.const 14
+          local.get $0
+          local.get $0
+          i32.const 1048320
+          i32.add
+          i32.const 16
+          i32.shr_u
+          i32.const 8
+          i32.and
+          local.tee $0
+          i32.shl
+          local.tee $1
+          i32.const 520192
+          i32.add
+          i32.const 16
+          i32.shr_u
+          i32.const 4
+          i32.and
+          local.tee $4
+          local.get $0
+          i32.or
+          local.get $1
+          local.get $4
+          i32.shl
+          local.tee $0
+          i32.const 245760
+          i32.add
+          i32.const 16
+          i32.shr_u
+          i32.const 2
+          i32.and
+          local.tee $1
+          i32.or
+          i32.sub
+          local.get $0
+          local.get $1
+          i32.shl
+          i32.const 15
+          i32.shr_u
+          i32.add
+          local.tee $0
+          i32.const 7
+          i32.add
+          i32.shr_u
+          i32.const 1
+          i32.and
+          local.get $0
+          i32.const 1
+          i32.shl
+          i32.or
+        end
+      else
+        i32.const 0
+      end
+      local.tee $1
+      i32.const 2
+      i32.shl
+      i32.const 4480
+      i32.add
+      local.set $0
+      local.get $3
+      local.get $1
+      i32.store offset=28
+      local.get $3
+      i32.const 0
+      i32.store offset=20
+      local.get $3
+      i32.const 0
+      i32.store offset=16
+      block $label$113 ;; label = @2
+        i32.const 4180
+        i32.load
+        local.tee $4
+        i32.const 1
+        local.get $1
+        i32.shl
+        local.tee $5
+        i32.and
+        if ;; label = @3
+          block ;; label = @4
+            local.get $0
+            i32.load
+            local.set $0
+            i32.const 25
+            local.get $1
+            i32.const 1
+            i32.shr_u
+            i32.sub
+            local.set $4
+            local.get $2
+            local.get $1
+            i32.const 31
+            i32.eq
+            if (result i32) ;; label = @5
+              i32.const 0
+            else
+              local.get $4
+            end
+            i32.shl
+            local.set $1
+            block $label$117 ;; label = @5
+              block $label$118 ;; label = @6
+                block $label$119 ;; label = @7
+                  loop $label$120 ;; label = @8
+                    local.get $0
+                    i32.load offset=4
+                    i32.const -8
+                    i32.and
+                    local.get $2
+                    i32.eq
+                    br_if 2 (;@6;)
+                    local.get $1
+                    i32.const 1
+                    i32.shl
+                    local.set $4
+                    local.get $0
+                    i32.const 16
+                    i32.add
+                    local.get $1
+                    i32.const 31
+                    i32.shr_u
+                    i32.const 2
+                    i32.shl
+                    i32.add
+                    local.tee $1
+                    i32.load
+                    local.tee $5
+                    i32.eqz
+                    br_if 1 (;@7;)
+                    local.get $4
+                    local.set $1
+                    local.get $5
+                    local.set $0
+                    br 0 (;@8;)
+                  end
+                end
+                local.get $1
+                i32.const 4192
+                i32.load
+                i32.lt_u
+                if ;; label = @7
+                  call $fimport$8
+                else
+                  block ;; label = @8
+                    local.get $1
+                    local.get $3
+                    i32.store
+                    local.get $3
+                    local.get $0
+                    i32.store offset=24
+                    local.get $3
+                    local.get $3
+                    i32.store offset=12
+                    local.get $3
+                    local.get $3
+                    i32.store offset=8
+                    br 6 (;@2;)
+                  end
+                end
+                br 1 (;@5;)
+              end
+              local.get $0
+              i32.const 8
+              i32.add
+              local.tee $1
+              i32.load
+              local.tee $2
+              i32.const 4192
+              i32.load
+              local.tee $4
+              i32.ge_u
+              local.get $0
+              local.get $4
+              i32.ge_u
+              i32.and
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $2
+                  local.get $3
+                  i32.store offset=12
+                  local.get $1
+                  local.get $3
+                  i32.store
+                  local.get $3
+                  local.get $2
+                  i32.store offset=8
+                  local.get $3
+                  local.get $0
+                  i32.store offset=12
+                  local.get $3
+                  i32.const 0
+                  i32.store offset=24
+                end
+              else
+                call $fimport$8
+              end
+            end
+          end
+        else
+          block ;; label = @4
+            i32.const 4180
+            local.get $4
+            local.get $5
+            i32.or
+            i32.store
+            local.get $0
+            local.get $3
+            i32.store
+            local.get $3
+            local.get $0
+            i32.store offset=24
+            local.get $3
+            local.get $3
+            i32.store offset=12
+            local.get $3
+            local.get $3
+            i32.store offset=8
+          end
+        end
+      end
+      i32.const 4208
+      i32.const 4208
+      i32.load
+      i32.const -1
+      i32.add
+      local.tee $0
+      i32.store
+      local.get $0
+      if ;; label = @2
+        return
+      else
+        i32.const 4632
+        local.set $0
+      end
+      loop $label$128 ;; label = @2
+        local.get $0
+        i32.load
+        local.tee $2
+        i32.const 8
+        i32.add
+        local.set $0
+        local.get $2
+        br_if 0 (;@2;)
+      end
+      i32.const 4208
+      i32.const -1
+      i32.store
+    end
+  )
+  (func $39 (;52;) (type $2) (param $0 i32) (result i32)
+    (local $1 i32)
+    block $label$1 (result i32) ;; label = @1
+      local.get $0
+      i32.eqz
+      if ;; label = @2
+        i32.const 1
+        local.set $0
+      end
+      loop $label$3 ;; label = @2
+        block $label$4 ;; label = @3
+          local.get $0
+          call $37
+          local.tee $1
+          if ;; label = @4
+            block ;; label = @5
+              local.get $1
+              local.set $0
+              br 2 (;@3;)
+            end
+          end
+          call $43
+          local.tee $1
+          if ;; label = @4
+            block ;; label = @5
+              local.get $1
+              i32.const 0
+              i32.and
+              i32.const 8
+              i32.add
+              call_indirect (type $1)
+              br 3 (;@2;)
+            end
+          else
+            i32.const 0
+            local.set $0
+          end
+        end
+      end
+      local.get $0
+    end
+  )
+  (func $40 (;53;) (type $2) (param $0 i32) (result i32)
+    local.get $0
+    call $39
+  )
+  (func $41 (;54;) (type $3) (param $0 i32)
+    local.get $0
+    call $38
+  )
+  (func $42 (;55;) (type $3) (param $0 i32)
+    local.get $0
+    call $41
+  )
+  (func $43 (;56;) (type $4) (result i32)
+    (local $0 i32)
+    block $label$1 (result i32) ;; label = @1
+      i32.const 4672
+      i32.const 4672
+      i32.load
+      local.tee $0
+      i32.const 0
+      i32.add
+      i32.store
+      local.get $0
+    end
+  )
+  (func $44 (;57;) (type $1)
+    nop
+  )
+  (func $45 (;58;) (type $2) (param $0 i32) (result i32)
+    (local $1 i32) (local $2 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$0
+      i32.load
+      local.tee $2
+      local.get $0
+      i32.const 15
+      i32.add
+      i32.const -16
+      i32.and
+      local.tee $0
+      i32.add
+      local.set $1
+      local.get $0
+      i32.const 0
+      i32.gt_s
+      local.get $1
+      local.get $2
+      i32.lt_s
+      i32.and
+      local.get $1
+      i32.const 0
+      i32.lt_s
+      i32.or
+      if ;; label = @2
+        block ;; label = @3
+          call $fimport$6
+          drop
+          i32.const 12
+          call $fimport$11
+          i32.const -1
+          return
+        end
+      end
+      global.get $global$0
+      local.get $1
+      i32.store
+      local.get $1
+      call $fimport$5
+      i32.gt_s
+      if ;; label = @2
+        call $fimport$4
+        i32.eqz
+        if ;; label = @3
+          block ;; label = @4
+            i32.const 12
+            call $fimport$11
+            global.get $global$0
+            local.get $2
+            i32.store
+            i32.const -1
+            return
+          end
+        end
+      end
+      local.get $2
+    end
+  )
+  (func $46 (;59;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32) (local $4 i32) (local $5 i32)
+    block $label$1 (result i32) ;; label = @1
+      local.get $0
+      local.get $2
+      i32.add
+      local.set $4
+      local.get $2
+      i32.const 20
+      i32.ge_s
+      if ;; label = @2
+        block ;; label = @3
+          local.get $1
+          i32.const 255
+          i32.and
+          local.set $1
+          local.get $0
+          i32.const 3
+          i32.and
+          local.tee $3
+          if ;; label = @4
+            block ;; label = @5
+              local.get $0
+              i32.const 4
+              i32.add
+              local.get $3
+              i32.sub
+              local.set $3
+              loop $label$4 ;; label = @6
+                local.get $0
+                local.get $3
+                i32.lt_s
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $0
+                    local.get $1
+                    i32.store8
+                    local.get $0
+                    i32.const 1
+                    i32.add
+                    local.set $0
+                    br 2 (;@6;)
+                  end
+                end
+              end
+            end
+          end
+          local.get $1
+          local.get $1
+          i32.const 8
+          i32.shl
+          i32.or
+          local.get $1
+          i32.const 16
+          i32.shl
+          i32.or
+          local.get $1
+          i32.const 24
+          i32.shl
+          i32.or
+          local.set $3
+          local.get $4
+          i32.const -4
+          i32.and
+          local.set $5
+          loop $label$6 ;; label = @4
+            local.get $0
+            local.get $5
+            i32.lt_s
+            if ;; label = @5
+              block ;; label = @6
+                local.get $0
+                local.get $3
+                i32.store
+                local.get $0
+                i32.const 4
+                i32.add
+                local.set $0
+                br 2 (;@4;)
+              end
+            end
+          end
+        end
+      end
+      loop $label$8 ;; label = @2
+        local.get $0
+        local.get $4
+        i32.lt_s
+        if ;; label = @3
+          block ;; label = @4
+            local.get $0
+            local.get $1
+            i32.store8
+            local.get $0
+            i32.const 1
+            i32.add
+            local.set $0
+            br 2 (;@2;)
+          end
+        end
+      end
+      local.get $0
+      local.get $2
+      i32.sub
+    end
+  )
+  (func $47 (;60;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32)
+    block $label$1 (result i32) ;; label = @1
+      local.get $2
+      i32.const 4096
+      i32.ge_s
+      if ;; label = @2
+        local.get $0
+        local.get $1
+        local.get $2
+        call $fimport$12
+        return
+      end
+      local.get $0
+      local.set $3
+      local.get $0
+      i32.const 3
+      i32.and
+      local.get $1
+      i32.const 3
+      i32.and
+      i32.eq
+      if ;; label = @2
+        block ;; label = @3
+          loop $label$4 ;; label = @4
+            local.get $0
+            i32.const 3
+            i32.and
+            if ;; label = @5
+              block ;; label = @6
+                local.get $2
+                i32.eqz
+                if ;; label = @7
+                  local.get $3
+                  return
+                end
+                local.get $0
+                local.get $1
+                i32.load8_s
+                i32.store8
+                local.get $0
+                i32.const 1
+                i32.add
+                local.set $0
+                local.get $1
+                i32.const 1
+                i32.add
+                local.set $1
+                local.get $2
+                i32.const 1
+                i32.sub
+                local.set $2
+                br 2 (;@4;)
+              end
+            end
+          end
+          loop $label$7 ;; label = @4
+            local.get $2
+            i32.const 4
+            i32.ge_s
+            if ;; label = @5
+              block ;; label = @6
+                local.get $0
+                local.get $1
+                i32.load
+                i32.store
+                local.get $0
+                i32.const 4
+                i32.add
+                local.set $0
+                local.get $1
+                i32.const 4
+                i32.add
+                local.set $1
+                local.get $2
+                i32.const 4
+                i32.sub
+                local.set $2
+                br 2 (;@4;)
+              end
+            end
+          end
+        end
+      end
+      loop $label$9 ;; label = @2
+        local.get $2
+        i32.const 0
+        i32.gt_s
+        if ;; label = @3
+          block ;; label = @4
+            local.get $0
+            local.get $1
+            i32.load8_s
+            i32.store8
+            local.get $0
+            i32.const 1
+            i32.add
+            local.set $0
+            local.get $1
+            i32.const 1
+            i32.add
+            local.set $1
+            local.get $2
+            i32.const 1
+            i32.sub
+            local.set $2
+            br 2 (;@2;)
+          end
+        end
+      end
+      local.get $3
+    end
+  )
+  (func $48 (;61;) (type $4) (result i32)
+    i32.const 0
+  )
+  (func $49 (;62;) (type $6) (param $0 i32) (param $1 i32) (result i32)
+    local.get $1
+    local.get $0
+    i32.const 1
+    i32.and
+    i32.const 0
+    i32.add
+    call_indirect (type $2)
+  )
+  (func $50 (;63;) (type $12) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32)
+    local.get $1
+    local.get $2
+    local.get $3
+    local.get $0
+    i32.const 3
+    i32.and
+    i32.const 2
+    i32.add
+    call_indirect (type $0)
+  )
+  (func $51 (;64;) (type $5) (param $0 i32) (param $1 i32)
+    local.get $1
+    local.get $0
+    i32.const 1
+    i32.and
+    i32.const 6
+    i32.add
+    call_indirect (type $3)
+  )
+  (func $52 (;65;) (type $3) (param $0 i32)
+    local.get $0
+    i32.const 0
+    i32.and
+    i32.const 8
+    i32.add
+    call_indirect (type $1)
+  )
+  (func $53 (;66;) (type $2) (param $0 i32) (result i32)
+    block $label$1 (result i32) ;; label = @1
+      i32.const 0
+      call $fimport$3
+      i32.const 0
+    end
+  )
+  (func $54 (;67;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    block $label$1 (result i32) ;; label = @1
+      i32.const 1
+      call $fimport$3
+      i32.const 0
+    end
+  )
+  (func $55 (;68;) (type $3) (param $0 i32)
+    i32.const 2
+    call $fimport$3
+  )
+  (func $56 (;69;) (type $1)
+    i32.const 3
+    call $fimport$3
+  )
+  (global $global$0 (;5;) (mut i32) global.get $gimport$0)
+  (global $global$1 (;6;) (mut i32) global.get $gimport$1)
+  (global $global$2 (;7;) (mut i32) global.get $gimport$2)
+  (global $global$3 (;8;) (mut i32) i32.const 0)
+  (global $global$4 (;9;) (mut i32) i32.const 0)
+  (global $global$5 (;10;) (mut i32) i32.const 0)
+  (export "_sbrk" (func $45))
+  (export "_free" (func $38))
+  (export "_main" (func $7))
+  (export "_pthread_self" (func $48))
+  (export "_memset" (func $46))
+  (export "_malloc" (func $37))
+  (export "_memcpy" (func $47))
+  (export "___errno_location" (func $12))
+  (export "runPostSets" (func $44))
+  (export "stackAlloc" (func $0))
+  (export "stackSave" (func $1))
+  (export "stackRestore" (func $2))
+  (export "establishStackSpace" (func $3))
+  (export "setThrew" (func $4))
+  (export "setTempRet0" (func $5))
+  (export "getTempRet0" (func $6))
+  (export "dynCall_ii" (func $49))
+  (export "dynCall_iiii" (func $50))
+  (export "dynCall_vi" (func $51))
+  (export "dynCall_v" (func $52))
+  (elem (;0;) (global.get $gimport$19) func $53 $9 $54 $14 $10 $15 $55 $16 $56)
+  (data (;0;) (i32.const 1024) "&\02\00\00a\00\00\00q=\8a>\00\00\00\00c\00\00\00\8f\c2\f5=\00\00\00\00g\00\00\00\8f\c2\f5=\00\00\00\00t\00\00\00q=\8a>\00\00\00\00B\00\00\00\0a\d7\a3<\00\00\00\00D\00\00\00\0a\d7\a3<\00\00\00\00H\00\00\00\0a\d7\a3<\00\00\00\00K\00\00\00\0a\d7\a3<\00\00\00\00M\00\00\00\0a\d7\a3<\00\00\00\00N\00\00\00\0a\d7\a3<\00\00\00\00R\00\00\00\0a\d7\a3<\00\00\00\00S\00\00\00\0a\d7\a3<\00\00\00\00V\00\00\00\0a\d7\a3<\00\00\00\00W\00\00\00\0a\d7\a3<\00\00\00\00Y\00\00\00\0a\d7\a3<")
+  (data (;1;) (i32.const 1220) "a\00\00\00\e9\1c\9b>\00\00\00\00c\00\00\00r\bdJ>\00\00\00\00g\00\00\00\d7IJ>\00\00\00\00t\00\00\00r_\9a>")
+  (data (;2;) (i32.const 1280) "\04\05\00\00\05")
+  (data (;3;) (i32.const 1296) "\01")
+  (data (;4;) (i32.const 1320) "\01\00\00\00\02\00\00\00L\12\00\00\00\04")
+  (data (;5;) (i32.const 1344) "\01")
+  (data (;6;) (i32.const 1359) "\0a\ff\ff\ff\ff")
+  (data (;7;) (i32.const 1396) "*\00\00\00error: %d\0a\00GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA\00\11\00\0a\00\11\11\11\00\00\00\00\05\00\00\00\00\00\00\09\00\00\00\00\0b")
+  (data (;8;) (i32.const 1731) "\11\00\0f\0a\11\11\11\03\0a\07\00\01\13\09\0b\0b\00\00\09\06\0b\00\00\0b\00\06\11\00\00\00\11\11\11")
+  (data (;9;) (i32.const 1780) "\0b")
+  (data (;10;) (i32.const 1789) "\11\00\0a\0a\11\11\11\00\0a\00\00\02\00\09\0b\00\00\00\09\00\0b\00\00\0b")
+  (data (;11;) (i32.const 1838) "\0c")
+  (data (;12;) (i32.const 1850) "\0c\00\00\00\00\0c\00\00\00\00\09\0c\00\00\00\00\00\0c\00\00\0c")
+  (data (;13;) (i32.const 1896) "\0e")
+  (data (;14;) (i32.const 1908) "\0d\00\00\00\04\0d\00\00\00\00\09\0e\00\00\00\00\00\0e\00\00\0e")
+  (data (;15;) (i32.const 1954) "\10")
+  (data (;16;) (i32.const 1966) "\0f\00\00\00\00\0f\00\00\00\00\09\10\00\00\00\00\00\10\00\00\10\00\00\12\00\00\00\12\12\12")
+  (data (;17;) (i32.const 2021) "\12\00\00\00\12\12\12\00\00\00\00\00\00\09")
+  (data (;18;) (i32.const 2070) "\0b")
+  (data (;19;) (i32.const 2082) "\0a\00\00\00\00\0a\00\00\00\00\09\0b\00\00\00\00\00\0b\00\00\0b")
+  (data (;20;) (i32.const 2128) "\0c")
+  (data (;21;) (i32.const 2140) "\0c\00\00\00\00\0c\00\00\00\00\09\0c\00\00\00\00\00\0c\00\00\0c\00\000123456789ABCDEF-+   0X0x\00(null)\00-0X+0X 0X-0x+0x 0x\00inf\00INF\00nan\00NAN\00.\00T!\22\19\0d\01\02\03\11K\1c\0c\10\04\0b\1d\12\1e'hnopqb \05\06\0f\13\14\15\1a\08\16\07($\17\18\09\0a\0e\1b\1f%#\83\82}&*+<=>?CGJMXYZ[\5c]^_`acdefgijklrstyz{|\00Illegal byte sequence\00Domain error\00Result not representable\00Not a tty\00Permission denied\00Operation not permitted\00No such file or directory\00No such process\00File exists\00Value too large for data type\00No space left on device\00Out of memory\00Resource busy\00Interrupted system call\00Resource temporarily unavailable\00Invalid seek\00Cross-device link\00Read-only file system\00Directory not empty\00Connection reset by peer\00Operation timed out\00Connection refused\00Host is down\00Host is unreachable\00Address in use\00Broken pipe\00I/O error\00No such device or address\00Block device required\00No such device\00Not a directory\00Is a directory\00Text file busy\00Exec format error\00Invalid argument\00Argument list too long\00Symbolic link loop\00Filename too long\00Too many open files in system\00No file descriptors available\00Bad file descriptor\00No child process\00Bad address\00File too large\00Too many links\00No locks available\00Resource deadlock would occur\00State not recoverable\00Previous owner died\00Operation canceled\00Function not implemented\00No message of desired type\00Identifier removed\00Device not a stream\00No data available\00Device timeout\00Out of streams resources\00Link has been severed\00Protocol error\00Bad message\00File descriptor in bad state\00Not a socket\00Destination address required\00Message too large\00Protocol wrong type for socket\00Protocol not available\00Protocol not supported\00Socket type not supported\00Not supported\00Protocol family not supported\00Address family not supported by protocol\00Address not available\00Network is down\00Network unreachable\00Connection reset by network\00Connection aborted\00No buffer space available\00Socket is connected\00Socket not connected\00Cannot send after socket shutdown\00Operation already in progress\00Operation in progress\00Stale file handle\00Remote I/O error\00Quota exceeded\00No medium found\00Wrong medium type\00No error information")
+)
diff --git a/tests/misc_testsuite/embenchen_ifs.wast b/tests/misc_testsuite/embenchen_ifs.wast
new file mode 100644
index 000000000000..eacad870e894
--- /dev/null
+++ b/tests/misc_testsuite/embenchen_ifs.wast
@@ -0,0 +1,11531 @@
+;; copied from a historical cranelift-wasm test and provided here as proof that
+;; this still compiles on various platforms and such
+
+(module $env
+  (memory (export "memory") 2 2)
+  (table (export "table") 8 8 funcref)
+  (global (export "DYNAMICTOP_PTR") i32 i32.const 0)
+  (global (export "STACKTOP") i32 i32.const 0)
+  (global (export "STACK_MAX") i32 i32.const 0)
+  (global (export "memoryBase") i32 i32.const 0)
+  (global (export "tableBase") i32 i32.const 0)
+  (func (export "abort") (param i32))
+  (func (export "enlargeMemory") (result i32) unreachable)
+  (func (export "getTotalMemory") (result i32) unreachable)
+  (func (export "abortOnCannotGrowMemory") (result i32) unreachable)
+  (func (export "_pthread_cleanup_pop") (param i32))
+  (func (export "___syscall6") (param i32 i32) (result i32) unreachable)
+  (func (export "_pthread_cleanup_push") (param i32 i32))
+  (func (export "_abort"))
+  (func (export "___setErrNo") (param i32))
+  (func (export "_emscripten_memcpy_big") (param i32 i32 i32) (result i32) unreachable)
+  (func (export "___syscall54") (param i32 i32) (result i32) unreachable)
+  (func (export "___syscall140") (param i32 i32) (result i32) unreachable)
+  (func (export "___syscall146") (param i32 i32) (result i32) unreachable)
+)
+
+(module
+  (type $0 (;0;) (func (param i32 i32 i32) (result i32)))
+  (type $1 (;1;) (func (param i32) (result i32)))
+  (type $2 (;2;) (func (param i32)))
+  (type $3 (;3;) (func (result i32)))
+  (type $4 (;4;) (func (param i32 i32) (result i32)))
+  (type $5 (;5;) (func (param i32 i32)))
+  (type $6 (;6;) (func))
+  (type $7 (;7;) (func (param i32 i32 i32 i32 i32) (result i32)))
+  (type $8 (;8;) (func (param i32 i32 i32)))
+  (type $9 (;9;) (func (param i64 i32) (result i32)))
+  (type $10 (;10;) (func (param i32 i32 i32 i32 i32)))
+  (type $11 (;11;) (func (param f64 i32) (result f64)))
+  (type $12 (;12;) (func (param i32 i32 i32 i32) (result i32)))
+  (import "env" "memory" (memory $16 (;0;) 2 2))
+  (import "env" "table" (table $timport$17 (;0;) 8 8 funcref))
+  (import "env" "DYNAMICTOP_PTR" (global $gimport$0 (;0;) i32))
+  (import "env" "STACKTOP" (global $gimport$1 (;1;) i32))
+  (import "env" "STACK_MAX" (global $gimport$2 (;2;) i32))
+  (import "env" "memoryBase" (global $gimport$18 (;3;) i32))
+  (import "env" "tableBase" (global $gimport$19 (;4;) i32))
+  (import "env" "abort" (func $fimport$3 (;0;) (type $2)))
+  (import "env" "enlargeMemory" (func $fimport$4 (;1;) (type $3)))
+  (import "env" "getTotalMemory" (func $fimport$5 (;2;) (type $3)))
+  (import "env" "abortOnCannotGrowMemory" (func $fimport$6 (;3;) (type $3)))
+  (import "env" "_pthread_cleanup_pop" (func $fimport$7 (;4;) (type $2)))
+  (import "env" "___syscall6" (func $fimport$8 (;5;) (type $4)))
+  (import "env" "_pthread_cleanup_push" (func $fimport$9 (;6;) (type $5)))
+  (import "env" "_abort" (func $fimport$10 (;7;) (type $6)))
+  (import "env" "___setErrNo" (func $fimport$11 (;8;) (type $2)))
+  (import "env" "_emscripten_memcpy_big" (func $fimport$12 (;9;) (type $0)))
+  (import "env" "___syscall54" (func $fimport$13 (;10;) (type $4)))
+  (import "env" "___syscall140" (func $fimport$14 (;11;) (type $4)))
+  (import "env" "___syscall146" (func $fimport$15 (;12;) (type $4)))
+  (func $0 (;13;) (type $1) (param $0 i32) (result i32)
+    (local $1 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $1
+      global.get $global$1
+      local.get $0
+      i32.add
+      global.set $global$1
+      global.get $global$1
+      i32.const 15
+      i32.add
+      i32.const -16
+      i32.and
+      global.set $global$1
+      local.get $1
+    end
+  )
+  (func $1 (;14;) (type $3) (result i32)
+    global.get $global$1
+  )
+  (func $2 (;15;) (type $2) (param $0 i32)
+    local.get $0
+    global.set $global$1
+  )
+  (func $3 (;16;) (type $5) (param $0 i32) (param $1 i32)
+    block $label$1 ;; label = @1
+      local.get $0
+      global.set $global$1
+      local.get $1
+      global.set $global$2
+    end
+  )
+  (func $4 (;17;) (type $5) (param $0 i32) (param $1 i32)
+    global.get $global$3
+    i32.eqz
+    if ;; label = @1
+      block ;; label = @2
+        local.get $0
+        global.set $global$3
+        local.get $1
+        global.set $global$4
+      end
+    end
+  )
+  (func $5 (;18;) (type $2) (param $0 i32)
+    local.get $0
+    global.set $global$5
+  )
+  (func $6 (;19;) (type $3) (result i32)
+    global.get $global$5
+  )
+  (func $7 (;20;) (type $3) (result i32)
+    (local $0 i32)
+    block $label$1 (result i32) ;; label = @1
+      i32.const 3584
+      i32.const 3584
+      i32.load
+      local.tee $0
+      i32.const 1
+      i32.add
+      i32.store
+      local.get $0
+      i32.const 16384
+      i32.and
+    end
+  )
+  (func $8 (;21;) (type $4) (param $0 i32) (param $1 i32) (result i32)
+    (local $2 i32) (local $3 i32) (local $4 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $4
+      global.get $global$1
+      i32.const 16
+      i32.add
+      global.set $global$1
+      local.get $4
+      local.set $2
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          local.get $0
+          i32.const 1
+          i32.le_s
+          br_if 0 (;@3;)
+          block $label$4 ;; label = @4
+            block $label$5 ;; label = @5
+              block $label$6 ;; label = @6
+                block $label$7 ;; label = @7
+                  block $label$8 ;; label = @8
+                    block $label$9 ;; label = @9
+                      block $label$10 ;; label = @10
+                        local.get $1
+                        i32.load offset=4
+                        i32.load8_s
+                        local.tee $0
+                        i32.const 48
+                        i32.sub
+                        br_table 5 (;@5;) 0 (;@10;) 2 (;@8;) 1 (;@9;) 3 (;@7;) 4 (;@6;) 6 (;@4;)
+                      end
+                      i32.const 75
+                      local.set $3
+                      br 7 (;@2;)
+                    end
+                    br 5 (;@3;)
+                  end
+                  i32.const 625
+                  local.set $3
+                  br 5 (;@2;)
+                end
+                i32.const 6250
+                local.set $3
+                br 4 (;@2;)
+              end
+              i32.const 12500
+              local.set $3
+              br 3 (;@2;)
+            end
+            local.get $4
+            global.set $global$1
+            i32.const 0
+            return
+          end
+          local.get $2
+          local.get $0
+          i32.const -48
+          i32.add
+          i32.store
+          i32.const 1140
+          local.get $2
+          call $34
+          drop
+          local.get $4
+          global.set $global$1
+          i32.const -1
+          return
+        end
+        i32.const 1250
+        local.set $3
+      end
+      i32.const 0
+      local.set $1
+      i32.const 0
+      local.set $0
+      loop $label$11 ;; label = @2
+        i32.const 0
+        local.set $2
+        loop $label$12 ;; label = @3
+          block $label$13 (result i32) ;; label = @4
+            block $label$14 ;; label = @5
+              call $7
+              i32.eqz
+              br_if 0 (;@5;)
+              call $7
+              i32.eqz
+              br_if 0 (;@5;)
+              local.get $0
+              i32.const 17
+              i32.add
+              br 1 (;@4;)
+            end
+            local.get $0
+            i32.const 19
+            i32.add
+          end
+          local.set $0
+          block $label$15 ;; label = @4
+            block $label$16 ;; label = @5
+              call $7
+              br_if 0 (;@5;)
+              call $7
+              br_if 0 (;@5;)
+              br 1 (;@4;)
+            end
+            local.get $0
+            i32.const 23
+            i32.add
+            local.set $0
+          end
+          local.get $2
+          i32.const 1
+          i32.add
+          local.tee $2
+          local.get $3
+          i32.lt_s
+          br_if 0 (;@3;)
+        end
+        local.get $1
+        i32.const 1
+        i32.add
+        local.tee $1
+        i32.const 27000
+        i32.ne
+        br_if 0 (;@2;)
+      end
+      i32.const 1152
+      call $35
+      drop
+      local.get $4
+      global.set $global$1
+      local.get $0
+    end
+  )
+  (func $9 (;22;) (type $1) (param $0 i32) (result i32)
+    (local $1 i32) (local $2 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $1
+      global.get $global$1
+      i32.const 16
+      i32.add
+      global.set $global$1
+      local.get $1
+      local.tee $2
+      local.get $0
+      i32.load offset=60
+      i32.store
+      i32.const 6
+      local.get $2
+      call $fimport$8
+      call $11
+      local.set $0
+      local.get $1
+      global.set $global$1
+      local.get $0
+    end
+  )
+  (func $10 (;23;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32) (local $4 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $4
+      global.get $global$1
+      i32.const 32
+      i32.add
+      global.set $global$1
+      local.get $4
+      local.tee $3
+      local.get $0
+      i32.load offset=60
+      i32.store
+      local.get $3
+      i32.const 0
+      i32.store offset=4
+      local.get $3
+      local.get $1
+      i32.store offset=8
+      local.get $3
+      local.get $4
+      i32.const 20
+      i32.add
+      local.tee $0
+      i32.store offset=12
+      local.get $3
+      local.get $2
+      i32.store offset=16
+      i32.const 140
+      local.get $3
+      call $fimport$14
+      call $11
+      i32.const 0
+      i32.lt_s
+      if (result i32) ;; label = @2
+        block (result i32) ;; label = @3
+          local.get $0
+          i32.const -1
+          i32.store
+          i32.const -1
+        end
+      else
+        local.get $0
+        i32.load
+      end
+      local.set $0
+      local.get $4
+      global.set $global$1
+      local.get $0
+    end
+  )
+  (func $11 (;24;) (type $1) (param $0 i32) (result i32)
+    local.get $0
+    i32.const -4096
+    i32.gt_u
+    if (result i32) ;; label = @1
+      block (result i32) ;; label = @2
+        call $12
+        i32.const 0
+        local.get $0
+        i32.sub
+        i32.store
+        i32.const -1
+      end
+    else
+      local.get $0
+    end
+  )
+  (func $12 (;25;) (type $3) (result i32)
+    i32.const 3632
+  )
+  (func $13 (;26;) (type $2) (param $0 i32)
+    nop
+  )
+  (func $14 (;27;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32) (local $4 i32) (local $5 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $4
+      global.get $global$1
+      i32.const 80
+      i32.add
+      global.set $global$1
+      local.get $4
+      local.set $3
+      local.get $4
+      i32.const 12
+      i32.add
+      local.set $5
+      local.get $0
+      i32.const 3
+      i32.store offset=36
+      local.get $0
+      i32.load
+      i32.const 64
+      i32.and
+      i32.eqz
+      if ;; label = @2
+        block ;; label = @3
+          local.get $3
+          local.get $0
+          i32.load offset=60
+          i32.store
+          local.get $3
+          i32.const 21505
+          i32.store offset=4
+          local.get $3
+          local.get $5
+          i32.store offset=8
+          i32.const 54
+          local.get $3
+          call $fimport$13
+          if ;; label = @4
+            local.get $0
+            i32.const -1
+            i32.store8 offset=75
+          end
+        end
+      end
+      local.get $0
+      local.get $1
+      local.get $2
+      call $15
+      local.set $0
+      local.get $4
+      global.set $global$1
+      local.get $0
+    end
+  )
+  (func $15 (;28;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $8
+      global.get $global$1
+      i32.const 48
+      i32.add
+      global.set $global$1
+      local.get $8
+      i32.const 16
+      i32.add
+      local.set $9
+      local.get $8
+      local.set $10
+      local.get $8
+      i32.const 32
+      i32.add
+      local.tee $3
+      local.get $0
+      i32.const 28
+      i32.add
+      local.tee $6
+      i32.load
+      local.tee $4
+      i32.store
+      local.get $3
+      local.get $0
+      i32.const 20
+      i32.add
+      local.tee $11
+      i32.load
+      local.get $4
+      i32.sub
+      local.tee $5
+      i32.store offset=4
+      local.get $3
+      local.get $1
+      i32.store offset=8
+      local.get $3
+      local.get $2
+      i32.store offset=12
+      local.get $0
+      i32.const 60
+      i32.add
+      local.set $13
+      local.get $0
+      i32.const 44
+      i32.add
+      local.set $14
+      local.get $3
+      local.set $1
+      i32.const 2
+      local.set $4
+      local.get $5
+      local.get $2
+      i32.add
+      local.set $12
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          block $label$4 ;; label = @4
+            loop $label$5 ;; label = @5
+              i32.const 3588
+              i32.load
+              if ;; label = @6
+                block ;; label = @7
+                  i32.const 1
+                  local.get $0
+                  call $fimport$9
+                  local.get $10
+                  local.get $13
+                  i32.load
+                  i32.store
+                  local.get $10
+                  local.get $1
+                  i32.store offset=4
+                  local.get $10
+                  local.get $4
+                  i32.store offset=8
+                  i32.const 146
+                  local.get $10
+                  call $fimport$15
+                  call $11
+                  local.set $3
+                  i32.const 0
+                  call $fimport$7
+                end
+              else
+                block ;; label = @7
+                  local.get $9
+                  local.get $13
+                  i32.load
+                  i32.store
+                  local.get $9
+                  local.get $1
+                  i32.store offset=4
+                  local.get $9
+                  local.get $4
+                  i32.store offset=8
+                  i32.const 146
+                  local.get $9
+                  call $fimport$15
+                  call $11
+                  local.set $3
+                end
+              end
+              local.get $12
+              local.get $3
+              i32.eq
+              br_if 1 (;@4;)
+              local.get $3
+              i32.const 0
+              i32.lt_s
+              br_if 2 (;@3;)
+              local.get $3
+              local.get $1
+              i32.load offset=4
+              local.tee $5
+              i32.gt_u
+              if (result i32) ;; label = @6
+                block (result i32) ;; label = @7
+                  local.get $6
+                  local.get $14
+                  i32.load
+                  local.tee $7
+                  i32.store
+                  local.get $11
+                  local.get $7
+                  i32.store
+                  local.get $1
+                  i32.load offset=12
+                  local.set $7
+                  local.get $1
+                  i32.const 8
+                  i32.add
+                  local.set $1
+                  local.get $4
+                  i32.const -1
+                  i32.add
+                  local.set $4
+                  local.get $3
+                  local.get $5
+                  i32.sub
+                end
+              else
+                local.get $4
+                i32.const 2
+                i32.eq
+                if (result i32) ;; label = @7
+                  block (result i32) ;; label = @8
+                    local.get $6
+                    local.get $6
+                    i32.load
+                    local.get $3
+                    i32.add
+                    i32.store
+                    local.get $5
+                    local.set $7
+                    i32.const 2
+                    local.set $4
+                    local.get $3
+                  end
+                else
+                  block (result i32) ;; label = @8
+                    local.get $5
+                    local.set $7
+                    local.get $3
+                  end
+                end
+              end
+              local.set $5
+              local.get $1
+              local.get $1
+              i32.load
+              local.get $5
+              i32.add
+              i32.store
+              local.get $1
+              local.get $7
+              local.get $5
+              i32.sub
+              i32.store offset=4
+              local.get $12
+              local.get $3
+              i32.sub
+              local.set $12
+              br 0 (;@5;)
+            end
+          end
+          local.get $0
+          local.get $14
+          i32.load
+          local.tee $1
+          local.get $0
+          i32.load offset=48
+          i32.add
+          i32.store offset=16
+          local.get $6
+          local.get $1
+          i32.store
+          local.get $11
+          local.get $1
+          i32.store
+          br 1 (;@2;)
+        end
+        local.get $0
+        i32.const 0
+        i32.store offset=16
+        local.get $6
+        i32.const 0
+        i32.store
+        local.get $11
+        i32.const 0
+        i32.store
+        local.get $0
+        local.get $0
+        i32.load
+        i32.const 32
+        i32.or
+        i32.store
+        local.get $4
+        i32.const 2
+        i32.eq
+        if (result i32) ;; label = @3
+          i32.const 0
+        else
+          local.get $2
+          local.get $1
+          i32.load offset=4
+          i32.sub
+        end
+        local.set $2
+      end
+      local.get $8
+      global.set $global$1
+      local.get $2
+    end
+  )
+  (func $16 (;29;) (type $2) (param $0 i32)
+    local.get $0
+    i32.load offset=68
+    i32.eqz
+    if ;; label = @1
+      local.get $0
+      call $13
+    end
+  )
+  (func $17 (;30;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32) (local $4 i32) (local $5 i32)
+    block $label$1 (result i32) ;; label = @1
+      local.get $1
+      i32.const 255
+      i32.and
+      local.set $5
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          block $label$4 ;; label = @4
+            local.get $2
+            i32.const 0
+            i32.ne
+            local.tee $4
+            local.get $0
+            i32.const 3
+            i32.and
+            i32.const 0
+            i32.ne
+            i32.and
+            if ;; label = @5
+              block ;; label = @6
+                local.get $1
+                i32.const 255
+                i32.and
+                local.set $4
+                local.get $2
+                local.set $3
+                local.get $0
+                local.set $2
+                loop $label$6 ;; label = @7
+                  local.get $2
+                  i32.load8_s
+                  local.get $4
+                  i32.const 24
+                  i32.shl
+                  i32.const 24
+                  i32.shr_s
+                  i32.eq
+                  if ;; label = @8
+                    block ;; label = @9
+                      local.get $3
+                      local.set $0
+                      br 6 (;@3;)
+                    end
+                  end
+                  local.get $3
+                  i32.const -1
+                  i32.add
+                  local.tee $3
+                  i32.const 0
+                  i32.ne
+                  local.tee $0
+                  local.get $2
+                  i32.const 1
+                  i32.add
+                  local.tee $2
+                  i32.const 3
+                  i32.and
+                  i32.const 0
+                  i32.ne
+                  i32.and
+                  br_if 0 (;@7;)
+                  br 3 (;@4;)
+                end
+              end
+            else
+              block ;; label = @6
+                local.get $2
+                local.set $3
+                local.get $0
+                local.set $2
+                local.get $4
+                local.set $0
+              end
+            end
+          end
+          local.get $0
+          if ;; label = @4
+            block ;; label = @5
+              local.get $3
+              local.set $0
+              br 2 (;@3;)
+            end
+          else
+            i32.const 0
+            local.set $0
+          end
+          br 1 (;@2;)
+        end
+        local.get $2
+        i32.load8_s
+        local.get $1
+        i32.const 255
+        i32.and
+        local.tee $1
+        i32.const 24
+        i32.shl
+        i32.const 24
+        i32.shr_s
+        i32.ne
+        if ;; label = @3
+          block ;; label = @4
+            local.get $5
+            i32.const 16843009
+            i32.mul
+            local.set $3
+            block $label$12 ;; label = @5
+              block $label$13 ;; label = @6
+                local.get $0
+                i32.const 3
+                i32.le_u
+                br_if 0 (;@6;)
+                loop $label$14 ;; label = @7
+                  local.get $2
+                  i32.load
+                  local.get $3
+                  i32.xor
+                  local.tee $4
+                  i32.const -2139062144
+                  i32.and
+                  i32.const -2139062144
+                  i32.xor
+                  local.get $4
+                  i32.const -16843009
+                  i32.add
+                  i32.and
+                  i32.eqz
+                  if ;; label = @8
+                    block ;; label = @9
+                      local.get $2
+                      i32.const 4
+                      i32.add
+                      local.set $2
+                      local.get $0
+                      i32.const -4
+                      i32.add
+                      local.tee $0
+                      i32.const 3
+                      i32.gt_u
+                      br_if 2 (;@7;)
+                      br 3 (;@6;)
+                    end
+                  end
+                end
+                br 1 (;@5;)
+              end
+              local.get $0
+              i32.eqz
+              if ;; label = @6
+                block ;; label = @7
+                  i32.const 0
+                  local.set $0
+                  br 5 (;@2;)
+                end
+              end
+            end
+            loop $label$17 ;; label = @5
+              local.get $2
+              i32.load8_s
+              local.get $1
+              i32.const 24
+              i32.shl
+              i32.const 24
+              i32.shr_s
+              i32.eq
+              br_if 3 (;@2;)
+              local.get $2
+              i32.const 1
+              i32.add
+              local.set $2
+              local.get $0
+              i32.const -1
+              i32.add
+              local.tee $0
+              br_if 0 (;@5;)
+              i32.const 0
+              local.set $0
+            end
+          end
+        end
+      end
+      local.get $0
+      if (result i32) ;; label = @2
+        local.get $2
+      else
+        i32.const 0
+      end
+    end
+  )
+  (func $18 (;31;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $4
+      global.get $global$1
+      i32.const 224
+      i32.add
+      global.set $global$1
+      local.get $4
+      i32.const 136
+      i32.add
+      local.set $5
+      local.get $4
+      i32.const 80
+      i32.add
+      local.tee $3
+      i64.const 0
+      i64.store align=4
+      local.get $3
+      i64.const 0
+      i64.store offset=8 align=4
+      local.get $3
+      i64.const 0
+      i64.store offset=16 align=4
+      local.get $3
+      i64.const 0
+      i64.store offset=24 align=4
+      local.get $3
+      i64.const 0
+      i64.store offset=32 align=4
+      local.get $4
+      i32.const 120
+      i32.add
+      local.tee $6
+      local.get $2
+      i32.load
+      i32.store
+      i32.const 0
+      local.get $1
+      local.get $6
+      local.get $4
+      local.tee $2
+      local.get $3
+      call $19
+      i32.const 0
+      i32.lt_s
+      if ;; label = @2
+        i32.const -1
+        local.set $1
+      else
+        block ;; label = @3
+          local.get $0
+          i32.load offset=76
+          i32.const -1
+          i32.gt_s
+          if (result i32) ;; label = @4
+            local.get $0
+            call $20
+          else
+            i32.const 0
+          end
+          local.set $12
+          local.get $0
+          i32.load
+          local.set $7
+          local.get $0
+          i32.load8_s offset=74
+          i32.const 1
+          i32.lt_s
+          if ;; label = @4
+            local.get $0
+            local.get $7
+            i32.const -33
+            i32.and
+            i32.store
+          end
+          local.get $0
+          i32.const 48
+          i32.add
+          local.tee $8
+          i32.load
+          if ;; label = @4
+            local.get $0
+            local.get $1
+            local.get $6
+            local.get $2
+            local.get $3
+            call $19
+            local.set $1
+          else
+            block ;; label = @5
+              local.get $0
+              i32.const 44
+              i32.add
+              local.tee $9
+              i32.load
+              local.set $10
+              local.get $9
+              local.get $5
+              i32.store
+              local.get $0
+              i32.const 28
+              i32.add
+              local.tee $13
+              local.get $5
+              i32.store
+              local.get $0
+              i32.const 20
+              i32.add
+              local.tee $11
+              local.get $5
+              i32.store
+              local.get $8
+              i32.const 80
+              i32.store
+              local.get $0
+              i32.const 16
+              i32.add
+              local.tee $14
+              local.get $5
+              i32.const 80
+              i32.add
+              i32.store
+              local.get $0
+              local.get $1
+              local.get $6
+              local.get $2
+              local.get $3
+              call $19
+              local.set $1
+              local.get $10
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $0
+                  i32.const 0
+                  i32.const 0
+                  local.get $0
+                  i32.load offset=36
+                  i32.const 3
+                  i32.and
+                  i32.const 2
+                  i32.add
+                  call_indirect (type $0)
+                  drop
+                  local.get $11
+                  i32.load
+                  i32.eqz
+                  if ;; label = @8
+                    i32.const -1
+                    local.set $1
+                  end
+                  local.get $9
+                  local.get $10
+                  i32.store
+                  local.get $8
+                  i32.const 0
+                  i32.store
+                  local.get $14
+                  i32.const 0
+                  i32.store
+                  local.get $13
+                  i32.const 0
+                  i32.store
+                  local.get $11
+                  i32.const 0
+                  i32.store
+                end
+              end
+            end
+          end
+          local.get $0
+          local.get $0
+          i32.load
+          local.tee $2
+          local.get $7
+          i32.const 32
+          i32.and
+          i32.or
+          i32.store
+          local.get $12
+          if ;; label = @4
+            local.get $0
+            call $13
+          end
+          local.get $2
+          i32.const 32
+          i32.and
+          if ;; label = @4
+            i32.const -1
+            local.set $1
+          end
+        end
+      end
+      local.get $4
+      global.set $global$1
+      local.get $1
+    end
+  )
+  (func $19 (;32;) (type $7) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32) (result i32)
+    (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32) (local $15 i32) (local $16 i32) (local $17 i32) (local $18 i32) (local $19 i32) (local $20 i32) (local $21 i32) (local $22 i32) (local $23 i32) (local $24 i32) (local $25 i32) (local $26 i32) (local $27 i32) (local $28 i32) (local $29 i32) (local $30 i32) (local $31 i32) (local $32 i32) (local $33 i32) (local $34 i32) (local $35 i32) (local $36 i32) (local $37 i32) (local $38 i32) (local $39 i32) (local $40 i32) (local $41 i32) (local $42 i32) (local $43 i32) (local $44 i32) (local $45 i32) (local $46 i32) (local $47 i32) (local $48 i32) (local $49 i32) (local $50 i64) (local $51 i64) (local $52 f64) (local $53 f64)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $23
+      global.get $global$1
+      i32.const 624
+      i32.add
+      global.set $global$1
+      local.get $23
+      i32.const 16
+      i32.add
+      local.set $20
+      local.get $23
+      local.set $16
+      local.get $23
+      i32.const 528
+      i32.add
+      local.set $36
+      local.get $0
+      i32.const 0
+      i32.ne
+      local.set $30
+      local.get $23
+      i32.const 536
+      i32.add
+      local.tee $17
+      i32.const 40
+      i32.add
+      local.tee $21
+      local.set $38
+      local.get $17
+      i32.const 39
+      i32.add
+      local.set $39
+      local.get $23
+      i32.const 8
+      i32.add
+      local.tee $37
+      i32.const 4
+      i32.add
+      local.set $42
+      i32.const 0
+      local.get $23
+      i32.const 588
+      i32.add
+      local.tee $19
+      local.tee $27
+      i32.sub
+      local.set $43
+      local.get $23
+      i32.const 576
+      i32.add
+      local.tee $17
+      i32.const 12
+      i32.add
+      local.set $33
+      local.get $17
+      i32.const 11
+      i32.add
+      local.set $40
+      local.get $33
+      local.tee $28
+      local.get $27
+      i32.sub
+      local.set $44
+      i32.const -2
+      local.get $27
+      i32.sub
+      local.set $45
+      local.get $28
+      i32.const 2
+      i32.add
+      local.set $46
+      local.get $23
+      i32.const 24
+      i32.add
+      local.tee $47
+      i32.const 288
+      i32.add
+      local.set $48
+      local.get $19
+      i32.const 9
+      i32.add
+      local.tee $31
+      local.set $41
+      local.get $19
+      i32.const 8
+      i32.add
+      local.set $34
+      i32.const 0
+      local.set $15
+      i32.const 0
+      local.set $10
+      i32.const 0
+      local.set $17
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          loop $label$4 ;; label = @4
+            block $label$5 ;; label = @5
+              local.get $15
+              i32.const -1
+              i32.gt_s
+              if ;; label = @6
+                local.get $10
+                i32.const 2147483647
+                local.get $15
+                i32.sub
+                i32.gt_s
+                if (result i32) ;; label = @7
+                  block (result i32) ;; label = @8
+                    call $12
+                    i32.const 75
+                    i32.store
+                    i32.const -1
+                  end
+                else
+                  local.get $10
+                  local.get $15
+                  i32.add
+                end
+                local.set $15
+              end
+              local.get $1
+              i32.load8_s
+              local.tee $5
+              i32.const 24
+              i32.shl
+              i32.const 24
+              i32.shr_s
+              i32.eqz
+              br_if 2 (;@3;)
+              local.get $1
+              local.set $11
+              block $label$9 ;; label = @6
+                block $label$10 ;; label = @7
+                  loop $label$11 ;; label = @8
+                    block $label$12 ;; label = @9
+                      block $label$13 ;; label = @10
+                        block $label$14 ;; label = @11
+                          block $label$15 ;; label = @12
+                            local.get $5
+                            i32.const 24
+                            i32.shl
+                            i32.const 24
+                            i32.shr_s
+                            i32.const 0
+                            i32.sub
+                            br_table 1 (;@11;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 0 (;@12;) 2 (;@10;)
+                          end
+                          local.get $11
+                          local.set $5
+                          br 4 (;@7;)
+                        end
+                        local.get $11
+                        local.set $5
+                        br 1 (;@9;)
+                      end
+                      local.get $11
+                      i32.const 1
+                      i32.add
+                      local.tee $11
+                      i32.load8_s
+                      local.set $5
+                      br 1 (;@8;)
+                    end
+                  end
+                  br 1 (;@6;)
+                end
+                loop $label$16 ;; label = @7
+                  local.get $5
+                  i32.load8_s offset=1
+                  i32.const 37
+                  i32.ne
+                  br_if 1 (;@6;)
+                  local.get $11
+                  i32.const 1
+                  i32.add
+                  local.set $11
+                  local.get $5
+                  i32.const 2
+                  i32.add
+                  local.tee $5
+                  i32.load8_s
+                  i32.const 37
+                  i32.eq
+                  br_if 0 (;@7;)
+                end
+              end
+              local.get $11
+              local.get $1
+              i32.sub
+              local.set $10
+              local.get $30
+              if ;; label = @6
+                local.get $0
+                i32.load
+                i32.const 32
+                i32.and
+                i32.eqz
+                if ;; label = @7
+                  local.get $1
+                  local.get $10
+                  local.get $0
+                  call $21
+                  drop
+                end
+              end
+              local.get $10
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $5
+                  local.set $1
+                  br 3 (;@4;)
+                end
+              end
+              local.get $5
+              i32.const 1
+              i32.add
+              local.tee $11
+              i32.load8_s
+              local.tee $10
+              i32.const 24
+              i32.shl
+              i32.const 24
+              i32.shr_s
+              i32.const -48
+              i32.add
+              local.tee $9
+              i32.const 10
+              i32.lt_u
+              if (result i32) ;; label = @6
+                block (result i32) ;; label = @7
+                  local.get $5
+                  i32.const 3
+                  i32.add
+                  local.set $10
+                  local.get $5
+                  i32.load8_s offset=2
+                  i32.const 36
+                  i32.eq
+                  local.tee $12
+                  if ;; label = @8
+                    local.get $10
+                    local.set $11
+                  end
+                  local.get $12
+                  if ;; label = @8
+                    i32.const 1
+                    local.set $17
+                  end
+                  local.get $11
+                  i32.load8_s
+                  local.set $5
+                  local.get $12
+                  i32.eqz
+                  if ;; label = @8
+                    i32.const -1
+                    local.set $9
+                  end
+                  local.get $17
+                end
+              else
+                block (result i32) ;; label = @7
+                  local.get $10
+                  local.set $5
+                  i32.const -1
+                  local.set $9
+                  local.get $17
+                end
+              end
+              local.set $10
+              block $label$25 ;; label = @6
+                local.get $5
+                i32.const 24
+                i32.shl
+                i32.const 24
+                i32.shr_s
+                i32.const -32
+                i32.add
+                local.tee $12
+                i32.const 32
+                i32.lt_u
+                if ;; label = @7
+                  block ;; label = @8
+                    i32.const 0
+                    local.set $17
+                    loop $label$27 ;; label = @9
+                      i32.const 1
+                      local.get $12
+                      i32.shl
+                      i32.const 75913
+                      i32.and
+                      i32.eqz
+                      br_if 3 (;@6;)
+                      i32.const 1
+                      local.get $5
+                      i32.const 24
+                      i32.shl
+                      i32.const 24
+                      i32.shr_s
+                      i32.const -32
+                      i32.add
+                      i32.shl
+                      local.get $17
+                      i32.or
+                      local.set $17
+                      local.get $11
+                      i32.const 1
+                      i32.add
+                      local.tee $11
+                      i32.load8_s
+                      local.tee $5
+                      i32.const 24
+                      i32.shl
+                      i32.const 24
+                      i32.shr_s
+                      i32.const -32
+                      i32.add
+                      local.tee $12
+                      i32.const 32
+                      i32.lt_u
+                      br_if 0 (;@9;)
+                    end
+                  end
+                else
+                  i32.const 0
+                  local.set $17
+                end
+              end
+              block $label$29 ;; label = @6
+                local.get $5
+                i32.const 24
+                i32.shl
+                i32.const 24
+                i32.shr_s
+                i32.const 42
+                i32.eq
+                if ;; label = @7
+                  block ;; label = @8
+                    block $label$31 (result i32) ;; label = @9
+                      block $label$32 ;; label = @10
+                        local.get $11
+                        i32.const 1
+                        i32.add
+                        local.tee $7
+                        i32.load8_s
+                        local.tee $5
+                        i32.const 24
+                        i32.shl
+                        i32.const 24
+                        i32.shr_s
+                        i32.const -48
+                        i32.add
+                        local.tee $12
+                        i32.const 10
+                        i32.ge_u
+                        br_if 0 (;@10;)
+                        local.get $11
+                        i32.load8_s offset=2
+                        i32.const 36
+                        i32.ne
+                        br_if 0 (;@10;)
+                        local.get $4
+                        local.get $12
+                        i32.const 2
+                        i32.shl
+                        i32.add
+                        i32.const 10
+                        i32.store
+                        i32.const 1
+                        local.set $8
+                        local.get $3
+                        local.get $7
+                        i32.load8_s
+                        i32.const -48
+                        i32.add
+                        i32.const 3
+                        i32.shl
+                        i32.add
+                        i64.load
+                        i32.wrap_i64
+                        local.set $10
+                        local.get $11
+                        i32.const 3
+                        i32.add
+                        br 1 (;@9;)
+                      end
+                      local.get $10
+                      if ;; label = @10
+                        block ;; label = @11
+                          i32.const -1
+                          local.set $15
+                          br 6 (;@5;)
+                        end
+                      end
+                      local.get $30
+                      i32.eqz
+                      if ;; label = @10
+                        block ;; label = @11
+                          local.get $17
+                          local.set $12
+                          i32.const 0
+                          local.set $17
+                          local.get $7
+                          local.set $11
+                          i32.const 0
+                          local.set $10
+                          br 5 (;@6;)
+                        end
+                      end
+                      local.get $2
+                      i32.load
+                      i32.const 3
+                      i32.add
+                      i32.const -4
+                      i32.and
+                      local.tee $11
+                      i32.load
+                      local.set $10
+                      local.get $2
+                      local.get $11
+                      i32.const 4
+                      i32.add
+                      i32.store
+                      i32.const 0
+                      local.set $8
+                      local.get $7
+                    end
+                    local.set $11
+                    local.get $17
+                    i32.const 8192
+                    i32.or
+                    local.set $12
+                    i32.const 0
+                    local.get $10
+                    i32.sub
+                    local.set $7
+                    local.get $11
+                    i32.load8_s
+                    local.set $5
+                    local.get $10
+                    i32.const 0
+                    i32.lt_s
+                    local.tee $6
+                    i32.eqz
+                    if ;; label = @9
+                      local.get $17
+                      local.set $12
+                    end
+                    local.get $8
+                    local.set $17
+                    local.get $6
+                    if ;; label = @9
+                      local.get $7
+                      local.set $10
+                    end
+                  end
+                else
+                  local.get $5
+                  i32.const 24
+                  i32.shl
+                  i32.const 24
+                  i32.shr_s
+                  i32.const -48
+                  i32.add
+                  local.tee $12
+                  i32.const 10
+                  i32.lt_u
+                  if ;; label = @8
+                    block ;; label = @9
+                      i32.const 0
+                      local.set $7
+                      local.get $12
+                      local.set $5
+                      loop $label$39 ;; label = @10
+                        local.get $7
+                        i32.const 10
+                        i32.mul
+                        local.get $5
+                        i32.add
+                        local.set $7
+                        local.get $11
+                        i32.const 1
+                        i32.add
+                        local.tee $11
+                        i32.load8_s
+                        local.tee $12
+                        i32.const 24
+                        i32.shl
+                        i32.const 24
+                        i32.shr_s
+                        i32.const -48
+                        i32.add
+                        local.tee $5
+                        i32.const 10
+                        i32.lt_u
+                        br_if 0 (;@10;)
+                      end
+                      local.get $7
+                      i32.const 0
+                      i32.lt_s
+                      if ;; label = @10
+                        block ;; label = @11
+                          i32.const -1
+                          local.set $15
+                          br 6 (;@5;)
+                        end
+                      else
+                        block ;; label = @11
+                          local.get $12
+                          local.set $5
+                          local.get $17
+                          local.set $12
+                          local.get $10
+                          local.set $17
+                          local.get $7
+                          local.set $10
+                        end
+                      end
+                    end
+                  else
+                    block ;; label = @9
+                      local.get $17
+                      local.set $12
+                      local.get $10
+                      local.set $17
+                      i32.const 0
+                      local.set $10
+                    end
+                  end
+                end
+              end
+              block $label$43 ;; label = @6
+                local.get $5
+                i32.const 24
+                i32.shl
+                i32.const 24
+                i32.shr_s
+                i32.const 46
+                i32.eq
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $11
+                    i32.const 1
+                    i32.add
+                    local.tee $7
+                    i32.load8_s
+                    local.tee $5
+                    i32.const 24
+                    i32.shl
+                    i32.const 24
+                    i32.shr_s
+                    i32.const 42
+                    i32.ne
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $5
+                        i32.const 24
+                        i32.shl
+                        i32.const 24
+                        i32.shr_s
+                        i32.const -48
+                        i32.add
+                        local.tee $5
+                        i32.const 10
+                        i32.lt_u
+                        if ;; label = @11
+                          block ;; label = @12
+                            local.get $7
+                            local.set $11
+                            i32.const 0
+                            local.set $7
+                          end
+                        else
+                          block ;; label = @12
+                            i32.const 0
+                            local.set $5
+                            local.get $7
+                            local.set $11
+                            br 6 (;@6;)
+                          end
+                        end
+                        loop $label$48 ;; label = @11
+                          local.get $7
+                          i32.const 10
+                          i32.mul
+                          local.get $5
+                          i32.add
+                          local.set $5
+                          local.get $11
+                          i32.const 1
+                          i32.add
+                          local.tee $11
+                          i32.load8_s
+                          i32.const -48
+                          i32.add
+                          local.tee $8
+                          i32.const 10
+                          i32.ge_u
+                          br_if 5 (;@6;)
+                          local.get $5
+                          local.set $7
+                          local.get $8
+                          local.set $5
+                          br 0 (;@11;)
+                        end
+                      end
+                    end
+                    local.get $11
+                    i32.const 2
+                    i32.add
+                    local.tee $7
+                    i32.load8_s
+                    i32.const -48
+                    i32.add
+                    local.tee $5
+                    i32.const 10
+                    i32.lt_u
+                    if ;; label = @9
+                      local.get $11
+                      i32.load8_s offset=3
+                      i32.const 36
+                      i32.eq
+                      if ;; label = @10
+                        block ;; label = @11
+                          local.get $4
+                          local.get $5
+                          i32.const 2
+                          i32.shl
+                          i32.add
+                          i32.const 10
+                          i32.store
+                          local.get $3
+                          local.get $7
+                          i32.load8_s
+                          i32.const -48
+                          i32.add
+                          i32.const 3
+                          i32.shl
+                          i32.add
+                          i64.load
+                          i32.wrap_i64
+                          local.set $5
+                          local.get $11
+                          i32.const 4
+                          i32.add
+                          local.set $11
+                          br 5 (;@6;)
+                        end
+                      end
+                    end
+                    local.get $17
+                    if ;; label = @9
+                      block ;; label = @10
+                        i32.const -1
+                        local.set $15
+                        br 5 (;@5;)
+                      end
+                    end
+                    local.get $30
+                    if (result i32) ;; label = @9
+                      block (result i32) ;; label = @10
+                        local.get $2
+                        i32.load
+                        i32.const 3
+                        i32.add
+                        i32.const -4
+                        i32.and
+                        local.tee $11
+                        i32.load
+                        local.set $5
+                        local.get $2
+                        local.get $11
+                        i32.const 4
+                        i32.add
+                        i32.store
+                        local.get $7
+                      end
+                    else
+                      block (result i32) ;; label = @10
+                        i32.const 0
+                        local.set $5
+                        local.get $7
+                      end
+                    end
+                    local.set $11
+                  end
+                else
+                  i32.const -1
+                  local.set $5
+                end
+              end
+              local.get $11
+              local.set $7
+              i32.const 0
+              local.set $8
+              loop $label$55 ;; label = @6
+                local.get $7
+                i32.load8_s
+                i32.const -65
+                i32.add
+                local.tee $6
+                i32.const 57
+                i32.gt_u
+                if ;; label = @7
+                  block ;; label = @8
+                    i32.const -1
+                    local.set $15
+                    br 3 (;@5;)
+                  end
+                end
+                local.get $7
+                i32.const 1
+                i32.add
+                local.set $11
+                local.get $8
+                i32.const 58
+                i32.mul
+                i32.const 1155
+                i32.add
+                local.get $6
+                i32.add
+                i32.load8_s
+                local.tee $13
+                i32.const 255
+                i32.and
+                local.tee $6
+                i32.const -1
+                i32.add
+                i32.const 8
+                i32.lt_u
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $11
+                    local.set $7
+                    local.get $6
+                    local.set $8
+                    br 2 (;@6;)
+                  end
+                end
+              end
+              local.get $13
+              i32.const 24
+              i32.shl
+              i32.const 24
+              i32.shr_s
+              i32.eqz
+              if ;; label = @6
+                block ;; label = @7
+                  i32.const -1
+                  local.set $15
+                  br 2 (;@5;)
+                end
+              end
+              local.get $9
+              i32.const -1
+              i32.gt_s
+              local.set $14
+              block $label$59 ;; label = @6
+                block $label$60 ;; label = @7
+                  local.get $13
+                  i32.const 24
+                  i32.shl
+                  i32.const 24
+                  i32.shr_s
+                  i32.const 19
+                  i32.eq
+                  if ;; label = @8
+                    local.get $14
+                    if ;; label = @9
+                      block ;; label = @10
+                        i32.const -1
+                        local.set $15
+                        br 5 (;@5;)
+                      end
+                    else
+                      br 2 (;@7;)
+                    end
+                  else
+                    block ;; label = @9
+                      local.get $14
+                      if ;; label = @10
+                        block ;; label = @11
+                          local.get $4
+                          local.get $9
+                          i32.const 2
+                          i32.shl
+                          i32.add
+                          local.get $6
+                          i32.store
+                          local.get $16
+                          local.get $3
+                          local.get $9
+                          i32.const 3
+                          i32.shl
+                          i32.add
+                          i64.load
+                          i64.store
+                          br 4 (;@7;)
+                        end
+                      end
+                      local.get $30
+                      i32.eqz
+                      if ;; label = @10
+                        block ;; label = @11
+                          i32.const 0
+                          local.set $15
+                          br 6 (;@5;)
+                        end
+                      end
+                      local.get $16
+                      local.get $6
+                      local.get $2
+                      call $22
+                    end
+                  end
+                  br 1 (;@6;)
+                end
+                local.get $30
+                i32.eqz
+                if ;; label = @7
+                  block ;; label = @8
+                    i32.const 0
+                    local.set $10
+                    local.get $11
+                    local.set $1
+                    br 4 (;@4;)
+                  end
+                end
+              end
+              local.get $7
+              i32.load8_s
+              local.tee $7
+              i32.const -33
+              i32.and
+              local.set $9
+              local.get $8
+              i32.const 0
+              i32.ne
+              local.get $7
+              i32.const 15
+              i32.and
+              i32.const 3
+              i32.eq
+              i32.and
+              i32.eqz
+              if ;; label = @6
+                local.get $7
+                local.set $9
+              end
+              local.get $12
+              i32.const -65537
+              i32.and
+              local.set $7
+              local.get $12
+              i32.const 8192
+              i32.and
+              if ;; label = @6
+                local.get $7
+                local.set $12
+              end
+              block $label$70 ;; label = @6
+                block $label$71 ;; label = @7
+                  block $label$72 ;; label = @8
+                    block $label$73 ;; label = @9
+                      block $label$74 ;; label = @10
+                        block $label$75 ;; label = @11
+                          block $label$76 ;; label = @12
+                            block $label$77 ;; label = @13
+                              block $label$78 ;; label = @14
+                                block $label$79 ;; label = @15
+                                  block $label$80 ;; label = @16
+                                    block $label$81 ;; label = @17
+                                      block $label$82 ;; label = @18
+                                        block $label$83 ;; label = @19
+                                          block $label$84 ;; label = @20
+                                            block $label$85 ;; label = @21
+                                              block $label$86 ;; label = @22
+                                                block $label$87 ;; label = @23
+                                                  block $label$88 ;; label = @24
+                                                    block $label$89 ;; label = @25
+                                                      local.get $9
+                                                      i32.const 65
+                                                      i32.sub
+                                                      br_table 11 (;@14;) 12 (;@13;) 9 (;@16;) 12 (;@13;) 11 (;@14;) 11 (;@14;) 11 (;@14;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 10 (;@15;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 2 (;@23;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 11 (;@14;) 12 (;@13;) 6 (;@19;) 4 (;@21;) 11 (;@14;) 11 (;@14;) 11 (;@14;) 12 (;@13;) 4 (;@21;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 7 (;@18;) 0 (;@25;) 3 (;@22;) 1 (;@24;) 12 (;@13;) 12 (;@13;) 8 (;@17;) 12 (;@13;) 5 (;@20;) 12 (;@13;) 12 (;@13;) 2 (;@23;) 12 (;@13;)
+                                                    end
+                                                    block $label$90 ;; label = @25
+                                                      block $label$91 ;; label = @26
+                                                        block $label$92 ;; label = @27
+                                                          block $label$93 ;; label = @28
+                                                            block $label$94 ;; label = @29
+                                                              block $label$95 ;; label = @30
+                                                                block $label$96 ;; label = @31
+                                                                  block $label$97 ;; label = @32
+                                                                    local.get $8
+                                                                    i32.const 255
+                                                                    i32.and
+                                                                    i32.const 24
+                                                                    i32.shl
+                                                                    i32.const 24
+                                                                    i32.shr_s
+                                                                    i32.const 0
+                                                                    i32.sub
+                                                                    br_table 0 (;@32;) 1 (;@31;) 2 (;@30;) 3 (;@29;) 4 (;@28;) 7 (;@25;) 5 (;@27;) 6 (;@26;) 7 (;@25;)
+                                                                  end
+                                                                  local.get $16
+                                                                  i32.load
+                                                                  local.get $15
+                                                                  i32.store
+                                                                  i32.const 0
+                                                                  local.set $10
+                                                                  local.get $11
+                                                                  local.set $1
+                                                                  br 27 (;@4;)
+                                                                end
+                                                                local.get $16
+                                                                i32.load
+                                                                local.get $15
+                                                                i32.store
+                                                                i32.const 0
+                                                                local.set $10
+                                                                local.get $11
+                                                                local.set $1
+                                                                br 26 (;@4;)
+                                                              end
+                                                              local.get $16
+                                                              i32.load
+                                                              local.get $15
+                                                              i64.extend_i32_s
+                                                              i64.store
+                                                              i32.const 0
+                                                              local.set $10
+                                                              local.get $11
+                                                              local.set $1
+                                                              br 25 (;@4;)
+                                                            end
+                                                            local.get $16
+                                                            i32.load
+                                                            local.get $15
+                                                            i32.store16
+                                                            i32.const 0
+                                                            local.set $10
+                                                            local.get $11
+                                                            local.set $1
+                                                            br 24 (;@4;)
+                                                          end
+                                                          local.get $16
+                                                          i32.load
+                                                          local.get $15
+                                                          i32.store8
+                                                          i32.const 0
+                                                          local.set $10
+                                                          local.get $11
+                                                          local.set $1
+                                                          br 23 (;@4;)
+                                                        end
+                                                        local.get $16
+                                                        i32.load
+                                                        local.get $15
+                                                        i32.store
+                                                        i32.const 0
+                                                        local.set $10
+                                                        local.get $11
+                                                        local.set $1
+                                                        br 22 (;@4;)
+                                                      end
+                                                      local.get $16
+                                                      i32.load
+                                                      local.get $15
+                                                      i64.extend_i32_s
+                                                      i64.store
+                                                      i32.const 0
+                                                      local.set $10
+                                                      local.get $11
+                                                      local.set $1
+                                                      br 21 (;@4;)
+                                                    end
+                                                    i32.const 0
+                                                    local.set $10
+                                                    local.get $11
+                                                    local.set $1
+                                                    br 20 (;@4;)
+                                                  end
+                                                  local.get $12
+                                                  i32.const 8
+                                                  i32.or
+                                                  local.set $12
+                                                  local.get $5
+                                                  i32.const 8
+                                                  i32.le_u
+                                                  if ;; label = @24
+                                                    i32.const 8
+                                                    local.set $5
+                                                  end
+                                                  i32.const 120
+                                                  local.set $9
+                                                  br 11 (;@12;)
+                                                end
+                                                br 10 (;@12;)
+                                              end
+                                              local.get $16
+                                              i64.load
+                                              local.tee $50
+                                              i64.const 0
+                                              i64.eq
+                                              if ;; label = @22
+                                                local.get $21
+                                                local.set $7
+                                              else
+                                                block ;; label = @23
+                                                  local.get $21
+                                                  local.set $1
+                                                  loop $label$101 ;; label = @24
+                                                    local.get $1
+                                                    i32.const -1
+                                                    i32.add
+                                                    local.tee $1
+                                                    local.get $50
+                                                    i64.const 7
+                                                    i64.and
+                                                    i64.const 48
+                                                    i64.or
+                                                    i64.store8
+                                                    local.get $50
+                                                    i64.const 3
+                                                    i64.shr_u
+                                                    local.tee $50
+                                                    i64.const 0
+                                                    i64.ne
+                                                    br_if 0 (;@24;)
+                                                    local.get $1
+                                                    local.set $7
+                                                  end
+                                                end
+                                              end
+                                              local.get $12
+                                              i32.const 8
+                                              i32.and
+                                              if ;; label = @22
+                                                block ;; label = @23
+                                                  local.get $38
+                                                  local.get $7
+                                                  i32.sub
+                                                  local.tee $1
+                                                  i32.const 1
+                                                  i32.add
+                                                  local.set $8
+                                                  local.get $5
+                                                  local.get $1
+                                                  i32.le_s
+                                                  if ;; label = @24
+                                                    local.get $8
+                                                    local.set $5
+                                                  end
+                                                  i32.const 0
+                                                  local.set $6
+                                                  i32.const 1635
+                                                  local.set $8
+                                                  br 16 (;@7;)
+                                                end
+                                              else
+                                                block ;; label = @23
+                                                  i32.const 0
+                                                  local.set $6
+                                                  i32.const 1635
+                                                  local.set $8
+                                                  br 16 (;@7;)
+                                                end
+                                              end
+                                            end
+                                            local.get $16
+                                            i64.load
+                                            local.tee $50
+                                            i64.const 0
+                                            i64.lt_s
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                local.get $16
+                                                i64.const 0
+                                                local.get $50
+                                                i64.sub
+                                                local.tee $50
+                                                i64.store
+                                                i32.const 1
+                                                local.set $6
+                                                i32.const 1635
+                                                local.set $8
+                                                br 11 (;@11;)
+                                              end
+                                            end
+                                            local.get $12
+                                            i32.const 2048
+                                            i32.and
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                i32.const 1
+                                                local.set $6
+                                                i32.const 1636
+                                                local.set $8
+                                                br 11 (;@11;)
+                                              end
+                                            else
+                                              block ;; label = @22
+                                                local.get $12
+                                                i32.const 1
+                                                i32.and
+                                                local.tee $1
+                                                local.set $6
+                                                local.get $1
+                                                if (result i32) ;; label = @23
+                                                  i32.const 1637
+                                                else
+                                                  i32.const 1635
+                                                end
+                                                local.set $8
+                                                br 11 (;@11;)
+                                              end
+                                            end
+                                          end
+                                          local.get $16
+                                          i64.load
+                                          local.set $50
+                                          i32.const 0
+                                          local.set $6
+                                          i32.const 1635
+                                          local.set $8
+                                          br 8 (;@11;)
+                                        end
+                                        local.get $39
+                                        local.get $16
+                                        i64.load
+                                        i64.store8
+                                        local.get $39
+                                        local.set $1
+                                        local.get $7
+                                        local.set $12
+                                        i32.const 1
+                                        local.set $7
+                                        i32.const 0
+                                        local.set $6
+                                        i32.const 1635
+                                        local.set $8
+                                        local.get $21
+                                        local.set $5
+                                        br 12 (;@6;)
+                                      end
+                                      call $12
+                                      i32.load
+                                      call $24
+                                      local.set $1
+                                      br 7 (;@10;)
+                                    end
+                                    local.get $16
+                                    i32.load
+                                    local.tee $1
+                                    i32.eqz
+                                    if ;; label = @17
+                                      i32.const 1645
+                                      local.set $1
+                                    end
+                                    br 6 (;@10;)
+                                  end
+                                  local.get $37
+                                  local.get $16
+                                  i64.load
+                                  i64.store32
+                                  local.get $42
+                                  i32.const 0
+                                  i32.store
+                                  local.get $16
+                                  local.get $37
+                                  i32.store
+                                  local.get $37
+                                  local.set $7
+                                  i32.const -1
+                                  local.set $6
+                                  br 6 (;@9;)
+                                end
+                                local.get $16
+                                i32.load
+                                local.set $7
+                                local.get $5
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $5
+                                    local.set $6
+                                    br 7 (;@9;)
+                                  end
+                                else
+                                  block ;; label = @16
+                                    local.get $0
+                                    i32.const 32
+                                    local.get $10
+                                    i32.const 0
+                                    local.get $12
+                                    call $25
+                                    i32.const 0
+                                    local.set $1
+                                    br 8 (;@8;)
+                                  end
+                                end
+                              end
+                              local.get $16
+                              f64.load
+                              local.set $52
+                              local.get $20
+                              i32.const 0
+                              i32.store
+                              local.get $52
+                              i64.reinterpret_f64
+                              i64.const 0
+                              i64.lt_s
+                              if (result i32) ;; label = @14
+                                block (result i32) ;; label = @15
+                                  i32.const 1
+                                  local.set $24
+                                  local.get $52
+                                  f64.neg
+                                  local.set $52
+                                  i32.const 1652
+                                end
+                              else
+                                block (result i32) ;; label = @15
+                                  local.get $12
+                                  i32.const 1
+                                  i32.and
+                                  local.set $1
+                                  local.get $12
+                                  i32.const 2048
+                                  i32.and
+                                  if (result i32) ;; label = @16
+                                    block (result i32) ;; label = @17
+                                      i32.const 1
+                                      local.set $24
+                                      i32.const 1655
+                                    end
+                                  else
+                                    block (result i32) ;; label = @17
+                                      local.get $1
+                                      local.set $24
+                                      local.get $1
+                                      if (result i32) ;; label = @18
+                                        i32.const 1658
+                                      else
+                                        i32.const 1653
+                                      end
+                                    end
+                                  end
+                                end
+                              end
+                              local.set $26
+                              block $label$119 ;; label = @14
+                                local.get $52
+                                i64.reinterpret_f64
+                                i64.const 9218868437227405312
+                                i64.and
+                                i64.const 9218868437227405312
+                                i64.lt_u
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $52
+                                    local.get $20
+                                    call $27
+                                    f64.const 0x1p+1 (;=2;)
+                                    f64.mul
+                                    local.tee $52
+                                    f64.const 0x0p+0 (;=0;)
+                                    f64.ne
+                                    local.tee $1
+                                    if ;; label = @17
+                                      local.get $20
+                                      local.get $20
+                                      i32.load
+                                      i32.const -1
+                                      i32.add
+                                      i32.store
+                                    end
+                                    local.get $9
+                                    i32.const 32
+                                    i32.or
+                                    local.tee $22
+                                    i32.const 97
+                                    i32.eq
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        local.get $26
+                                        i32.const 9
+                                        i32.add
+                                        local.set $1
+                                        local.get $9
+                                        i32.const 32
+                                        i32.and
+                                        local.tee $6
+                                        if ;; label = @19
+                                          local.get $1
+                                          local.set $26
+                                        end
+                                        local.get $5
+                                        i32.const 11
+                                        i32.gt_u
+                                        i32.const 12
+                                        local.get $5
+                                        i32.sub
+                                        local.tee $1
+                                        i32.eqz
+                                        i32.or
+                                        i32.eqz
+                                        if ;; label = @19
+                                          block ;; label = @20
+                                            f64.const 0x1p+3 (;=8;)
+                                            local.set $53
+                                            loop $label$125 ;; label = @21
+                                              local.get $53
+                                              f64.const 0x1p+4 (;=16;)
+                                              f64.mul
+                                              local.set $53
+                                              local.get $1
+                                              i32.const -1
+                                              i32.add
+                                              local.tee $1
+                                              br_if 0 (;@21;)
+                                            end
+                                            local.get $26
+                                            i32.load8_s
+                                            i32.const 45
+                                            i32.eq
+                                            if (result f64) ;; label = @21
+                                              local.get $53
+                                              local.get $52
+                                              f64.neg
+                                              local.get $53
+                                              f64.sub
+                                              f64.add
+                                              f64.neg
+                                            else
+                                              local.get $52
+                                              local.get $53
+                                              f64.add
+                                              local.get $53
+                                              f64.sub
+                                            end
+                                            local.set $52
+                                          end
+                                        end
+                                        i32.const 0
+                                        local.get $20
+                                        i32.load
+                                        local.tee $7
+                                        i32.sub
+                                        local.set $1
+                                        local.get $7
+                                        i32.const 0
+                                        i32.lt_s
+                                        if (result i32) ;; label = @19
+                                          local.get $1
+                                        else
+                                          local.get $7
+                                        end
+                                        i64.extend_i32_s
+                                        local.get $33
+                                        call $23
+                                        local.tee $1
+                                        local.get $33
+                                        i32.eq
+                                        if ;; label = @19
+                                          block ;; label = @20
+                                            local.get $40
+                                            i32.const 48
+                                            i32.store8
+                                            local.get $40
+                                            local.set $1
+                                          end
+                                        end
+                                        local.get $24
+                                        i32.const 2
+                                        i32.or
+                                        local.set $13
+                                        local.get $1
+                                        i32.const -1
+                                        i32.add
+                                        local.get $7
+                                        i32.const 31
+                                        i32.shr_s
+                                        i32.const 2
+                                        i32.and
+                                        i32.const 43
+                                        i32.add
+                                        i32.store8
+                                        local.get $1
+                                        i32.const -2
+                                        i32.add
+                                        local.tee $8
+                                        local.get $9
+                                        i32.const 15
+                                        i32.add
+                                        i32.store8
+                                        local.get $5
+                                        i32.const 1
+                                        i32.lt_s
+                                        local.set $9
+                                        local.get $12
+                                        i32.const 8
+                                        i32.and
+                                        i32.eqz
+                                        local.set $14
+                                        local.get $19
+                                        local.set $1
+                                        loop $label$131 ;; label = @19
+                                          local.get $1
+                                          local.get $52
+                                          i32.trunc_f64_s
+                                          local.tee $7
+                                          i32.const 1619
+                                          i32.add
+                                          i32.load8_u
+                                          local.get $6
+                                          i32.or
+                                          i32.store8
+                                          local.get $52
+                                          local.get $7
+                                          f64.convert_i32_s
+                                          f64.sub
+                                          f64.const 0x1p+4 (;=16;)
+                                          f64.mul
+                                          local.set $52
+                                          block $label$132 (result i32) ;; label = @20
+                                            local.get $1
+                                            i32.const 1
+                                            i32.add
+                                            local.tee $7
+                                            local.get $27
+                                            i32.sub
+                                            i32.const 1
+                                            i32.eq
+                                            if (result i32) ;; label = @21
+                                              block (result i32) ;; label = @22
+                                                local.get $7
+                                                local.get $14
+                                                local.get $9
+                                                local.get $52
+                                                f64.const 0x0p+0 (;=0;)
+                                                f64.eq
+                                                i32.and
+                                                i32.and
+                                                br_if 2 (;@20;)
+                                                drop
+                                                local.get $7
+                                                i32.const 46
+                                                i32.store8
+                                                local.get $1
+                                                i32.const 2
+                                                i32.add
+                                              end
+                                            else
+                                              local.get $7
+                                            end
+                                          end
+                                          local.set $1
+                                          local.get $52
+                                          f64.const 0x0p+0 (;=0;)
+                                          f64.ne
+                                          br_if 0 (;@19;)
+                                        end
+                                        local.get $46
+                                        local.get $5
+                                        i32.add
+                                        local.get $8
+                                        local.tee $7
+                                        i32.sub
+                                        local.set $6
+                                        local.get $44
+                                        local.get $7
+                                        i32.sub
+                                        local.get $1
+                                        i32.add
+                                        local.set $9
+                                        local.get $0
+                                        i32.const 32
+                                        local.get $10
+                                        local.get $5
+                                        i32.const 0
+                                        i32.ne
+                                        local.get $45
+                                        local.get $1
+                                        i32.add
+                                        local.get $5
+                                        i32.lt_s
+                                        i32.and
+                                        if (result i32) ;; label = @19
+                                          local.get $6
+                                        else
+                                          local.get $9
+                                          local.tee $6
+                                        end
+                                        local.get $13
+                                        i32.add
+                                        local.tee $5
+                                        local.get $12
+                                        call $25
+                                        local.get $0
+                                        i32.load
+                                        i32.const 32
+                                        i32.and
+                                        i32.eqz
+                                        if ;; label = @19
+                                          local.get $26
+                                          local.get $13
+                                          local.get $0
+                                          call $21
+                                          drop
+                                        end
+                                        local.get $0
+                                        i32.const 48
+                                        local.get $10
+                                        local.get $5
+                                        local.get $12
+                                        i32.const 65536
+                                        i32.xor
+                                        call $25
+                                        local.get $1
+                                        local.get $27
+                                        i32.sub
+                                        local.set $1
+                                        local.get $0
+                                        i32.load
+                                        i32.const 32
+                                        i32.and
+                                        i32.eqz
+                                        if ;; label = @19
+                                          local.get $19
+                                          local.get $1
+                                          local.get $0
+                                          call $21
+                                          drop
+                                        end
+                                        local.get $0
+                                        i32.const 48
+                                        local.get $6
+                                        local.get $1
+                                        local.get $28
+                                        local.get $7
+                                        i32.sub
+                                        local.tee $1
+                                        i32.add
+                                        i32.sub
+                                        i32.const 0
+                                        i32.const 0
+                                        call $25
+                                        local.get $0
+                                        i32.load
+                                        i32.const 32
+                                        i32.and
+                                        i32.eqz
+                                        if ;; label = @19
+                                          local.get $8
+                                          local.get $1
+                                          local.get $0
+                                          call $21
+                                          drop
+                                        end
+                                        local.get $0
+                                        i32.const 32
+                                        local.get $10
+                                        local.get $5
+                                        local.get $12
+                                        i32.const 8192
+                                        i32.xor
+                                        call $25
+                                        local.get $5
+                                        local.get $10
+                                        i32.ge_s
+                                        if ;; label = @19
+                                          local.get $5
+                                          local.set $10
+                                        end
+                                        br 4 (;@14;)
+                                      end
+                                    end
+                                    local.get $1
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        local.get $20
+                                        local.get $20
+                                        i32.load
+                                        i32.const -28
+                                        i32.add
+                                        local.tee $6
+                                        i32.store
+                                        local.get $52
+                                        f64.const 0x1p+28 (;=268435456;)
+                                        f64.mul
+                                        local.set $52
+                                      end
+                                    else
+                                      local.get $20
+                                      i32.load
+                                      local.set $6
+                                    end
+                                    local.get $6
+                                    i32.const 0
+                                    i32.lt_s
+                                    if (result i32) ;; label = @17
+                                      local.get $47
+                                    else
+                                      local.get $48
+                                    end
+                                    local.tee $7
+                                    local.set $8
+                                    loop $label$145 ;; label = @17
+                                      local.get $8
+                                      local.get $52
+                                      i32.trunc_f64_s
+                                      local.tee $1
+                                      i32.store
+                                      local.get $8
+                                      i32.const 4
+                                      i32.add
+                                      local.set $8
+                                      local.get $52
+                                      local.get $1
+                                      f64.convert_i32_u
+                                      f64.sub
+                                      f64.const 0x1.dcd65p+29 (;=1000000000;)
+                                      f64.mul
+                                      local.tee $52
+                                      f64.const 0x0p+0 (;=0;)
+                                      f64.ne
+                                      br_if 0 (;@17;)
+                                    end
+                                    local.get $6
+                                    i32.const 0
+                                    i32.gt_s
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        local.get $7
+                                        local.set $1
+                                        loop $label$147 ;; label = @19
+                                          local.get $6
+                                          i32.const 29
+                                          i32.gt_s
+                                          if (result i32) ;; label = @20
+                                            i32.const 29
+                                          else
+                                            local.get $6
+                                          end
+                                          local.set $14
+                                          block $label$150 ;; label = @20
+                                            local.get $8
+                                            i32.const -4
+                                            i32.add
+                                            local.tee $6
+                                            local.get $1
+                                            i32.ge_u
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                local.get $14
+                                                i64.extend_i32_u
+                                                local.set $50
+                                                i32.const 0
+                                                local.set $13
+                                                loop $label$152 ;; label = @23
+                                                  local.get $6
+                                                  local.get $6
+                                                  i32.load
+                                                  i64.extend_i32_u
+                                                  local.get $50
+                                                  i64.shl
+                                                  local.get $13
+                                                  i64.extend_i32_u
+                                                  i64.add
+                                                  local.tee $51
+                                                  i64.const 1000000000
+                                                  i64.rem_u
+                                                  i64.store32
+                                                  local.get $51
+                                                  i64.const 1000000000
+                                                  i64.div_u
+                                                  i32.wrap_i64
+                                                  local.set $13
+                                                  local.get $6
+                                                  i32.const -4
+                                                  i32.add
+                                                  local.tee $6
+                                                  local.get $1
+                                                  i32.ge_u
+                                                  br_if 0 (;@23;)
+                                                end
+                                                local.get $13
+                                                i32.eqz
+                                                br_if 2 (;@20;)
+                                                local.get $1
+                                                i32.const -4
+                                                i32.add
+                                                local.tee $1
+                                                local.get $13
+                                                i32.store
+                                              end
+                                            end
+                                          end
+                                          loop $label$153 ;; label = @20
+                                            local.get $8
+                                            local.get $1
+                                            i32.gt_u
+                                            if ;; label = @21
+                                              local.get $8
+                                              i32.const -4
+                                              i32.add
+                                              local.tee $6
+                                              i32.load
+                                              i32.eqz
+                                              if ;; label = @22
+                                                block ;; label = @23
+                                                  local.get $6
+                                                  local.set $8
+                                                  br 3 (;@20;)
+                                                end
+                                              end
+                                            end
+                                          end
+                                          local.get $20
+                                          local.get $20
+                                          i32.load
+                                          local.get $14
+                                          i32.sub
+                                          local.tee $6
+                                          i32.store
+                                          local.get $6
+                                          i32.const 0
+                                          i32.gt_s
+                                          br_if 0 (;@19;)
+                                        end
+                                      end
+                                    else
+                                      local.get $7
+                                      local.set $1
+                                    end
+                                    local.get $5
+                                    i32.const 0
+                                    i32.lt_s
+                                    if (result i32) ;; label = @17
+                                      i32.const 6
+                                    else
+                                      local.get $5
+                                    end
+                                    local.set $18
+                                    local.get $6
+                                    i32.const 0
+                                    i32.lt_s
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        local.get $18
+                                        i32.const 25
+                                        i32.add
+                                        i32.const 9
+                                        i32.div_s
+                                        i32.const 1
+                                        i32.add
+                                        local.set $14
+                                        local.get $22
+                                        i32.const 102
+                                        i32.eq
+                                        local.set $25
+                                        local.get $8
+                                        local.set $5
+                                        loop $label$160 ;; label = @19
+                                          i32.const 0
+                                          local.get $6
+                                          i32.sub
+                                          local.tee $13
+                                          i32.const 9
+                                          i32.gt_s
+                                          if ;; label = @20
+                                            i32.const 9
+                                            local.set $13
+                                          end
+                                          block $label$162 ;; label = @20
+                                            local.get $1
+                                            local.get $5
+                                            i32.lt_u
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                i32.const 1
+                                                local.get $13
+                                                i32.shl
+                                                i32.const -1
+                                                i32.add
+                                                local.set $29
+                                                i32.const 1000000000
+                                                local.get $13
+                                                i32.shr_u
+                                                local.set $35
+                                                i32.const 0
+                                                local.set $6
+                                                local.get $1
+                                                local.set $8
+                                                loop $label$164 ;; label = @23
+                                                  local.get $8
+                                                  local.get $8
+                                                  i32.load
+                                                  local.tee $32
+                                                  local.get $13
+                                                  i32.shr_u
+                                                  local.get $6
+                                                  i32.add
+                                                  i32.store
+                                                  local.get $32
+                                                  local.get $29
+                                                  i32.and
+                                                  local.get $35
+                                                  i32.mul
+                                                  local.set $6
+                                                  local.get $8
+                                                  i32.const 4
+                                                  i32.add
+                                                  local.tee $8
+                                                  local.get $5
+                                                  i32.lt_u
+                                                  br_if 0 (;@23;)
+                                                end
+                                                local.get $1
+                                                i32.const 4
+                                                i32.add
+                                                local.set $8
+                                                local.get $1
+                                                i32.load
+                                                i32.eqz
+                                                if ;; label = @23
+                                                  local.get $8
+                                                  local.set $1
+                                                end
+                                                local.get $6
+                                                i32.eqz
+                                                br_if 2 (;@20;)
+                                                local.get $5
+                                                local.get $6
+                                                i32.store
+                                                local.get $5
+                                                i32.const 4
+                                                i32.add
+                                                local.set $5
+                                              end
+                                            else
+                                              block ;; label = @22
+                                                local.get $1
+                                                i32.const 4
+                                                i32.add
+                                                local.set $8
+                                                local.get $1
+                                                i32.load
+                                                i32.eqz
+                                                if ;; label = @23
+                                                  local.get $8
+                                                  local.set $1
+                                                end
+                                              end
+                                            end
+                                          end
+                                          local.get $25
+                                          if (result i32) ;; label = @20
+                                            local.get $7
+                                          else
+                                            local.get $1
+                                          end
+                                          local.tee $8
+                                          local.get $14
+                                          i32.const 2
+                                          i32.shl
+                                          i32.add
+                                          local.set $6
+                                          local.get $5
+                                          local.get $8
+                                          i32.sub
+                                          i32.const 2
+                                          i32.shr_s
+                                          local.get $14
+                                          i32.gt_s
+                                          if ;; label = @20
+                                            local.get $6
+                                            local.set $5
+                                          end
+                                          local.get $20
+                                          local.get $20
+                                          i32.load
+                                          local.get $13
+                                          i32.add
+                                          local.tee $6
+                                          i32.store
+                                          local.get $6
+                                          i32.const 0
+                                          i32.lt_s
+                                          br_if 0 (;@19;)
+                                          local.get $5
+                                          local.set $13
+                                        end
+                                      end
+                                    else
+                                      local.get $8
+                                      local.set $13
+                                    end
+                                    local.get $7
+                                    local.set $25
+                                    block $label$172 ;; label = @17
+                                      local.get $1
+                                      local.get $13
+                                      i32.lt_u
+                                      if ;; label = @18
+                                        block ;; label = @19
+                                          local.get $25
+                                          local.get $1
+                                          i32.sub
+                                          i32.const 2
+                                          i32.shr_s
+                                          i32.const 9
+                                          i32.mul
+                                          local.set $5
+                                          local.get $1
+                                          i32.load
+                                          local.tee $6
+                                          i32.const 10
+                                          i32.lt_u
+                                          br_if 2 (;@17;)
+                                          i32.const 10
+                                          local.set $8
+                                          loop $label$174 ;; label = @20
+                                            local.get $5
+                                            i32.const 1
+                                            i32.add
+                                            local.set $5
+                                            local.get $6
+                                            local.get $8
+                                            i32.const 10
+                                            i32.mul
+                                            local.tee $8
+                                            i32.ge_u
+                                            br_if 0 (;@20;)
+                                          end
+                                        end
+                                      else
+                                        i32.const 0
+                                        local.set $5
+                                      end
+                                    end
+                                    local.get $22
+                                    i32.const 103
+                                    i32.eq
+                                    local.set $29
+                                    local.get $18
+                                    i32.const 0
+                                    i32.ne
+                                    local.set $35
+                                    local.get $18
+                                    local.get $22
+                                    i32.const 102
+                                    i32.ne
+                                    if (result i32) ;; label = @17
+                                      local.get $5
+                                    else
+                                      i32.const 0
+                                    end
+                                    i32.sub
+                                    local.get $35
+                                    local.get $29
+                                    i32.and
+                                    i32.const 31
+                                    i32.shl
+                                    i32.const 31
+                                    i32.shr_s
+                                    i32.add
+                                    local.tee $8
+                                    local.get $13
+                                    local.get $25
+                                    i32.sub
+                                    i32.const 2
+                                    i32.shr_s
+                                    i32.const 9
+                                    i32.mul
+                                    i32.const -9
+                                    i32.add
+                                    i32.lt_s
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        local.get $8
+                                        i32.const 9216
+                                        i32.add
+                                        local.tee $14
+                                        i32.const 9
+                                        i32.rem_s
+                                        i32.const 1
+                                        i32.add
+                                        local.tee $8
+                                        i32.const 9
+                                        i32.lt_s
+                                        if ;; label = @19
+                                          block ;; label = @20
+                                            i32.const 10
+                                            local.set $6
+                                            loop $label$180 ;; label = @21
+                                              local.get $6
+                                              i32.const 10
+                                              i32.mul
+                                              local.set $6
+                                              local.get $8
+                                              i32.const 1
+                                              i32.add
+                                              local.tee $8
+                                              i32.const 9
+                                              i32.ne
+                                              br_if 0 (;@21;)
+                                            end
+                                          end
+                                        else
+                                          i32.const 10
+                                          local.set $6
+                                        end
+                                        local.get $7
+                                        i32.const 4
+                                        i32.add
+                                        local.get $14
+                                        i32.const 9
+                                        i32.div_s
+                                        i32.const -1024
+                                        i32.add
+                                        i32.const 2
+                                        i32.shl
+                                        i32.add
+                                        local.tee $8
+                                        i32.load
+                                        local.tee $22
+                                        local.get $6
+                                        i32.rem_u
+                                        local.set $14
+                                        block $label$182 ;; label = @19
+                                          local.get $8
+                                          i32.const 4
+                                          i32.add
+                                          local.get $13
+                                          i32.eq
+                                          local.tee $32
+                                          local.get $14
+                                          i32.eqz
+                                          i32.and
+                                          i32.eqz
+                                          if ;; label = @20
+                                            block ;; label = @21
+                                              local.get $14
+                                              local.get $6
+                                              i32.const 2
+                                              i32.div_s
+                                              local.tee $49
+                                              i32.lt_u
+                                              if (result f64) ;; label = @22
+                                                f64.const 0x1p-1 (;=0.5;)
+                                              else
+                                                local.get $32
+                                                local.get $14
+                                                local.get $49
+                                                i32.eq
+                                                i32.and
+                                                if (result f64) ;; label = @23
+                                                  f64.const 0x1p+0 (;=1;)
+                                                else
+                                                  f64.const 0x1.8p+0 (;=1.5;)
+                                                end
+                                              end
+                                              local.set $52
+                                              local.get $22
+                                              local.get $6
+                                              i32.div_u
+                                              i32.const 1
+                                              i32.and
+                                              if (result f64) ;; label = @22
+                                                f64.const 0x1.0000000000001p+53 (;=9007199254740994;)
+                                              else
+                                                f64.const 0x1p+53 (;=9007199254740992;)
+                                              end
+                                              local.set $53
+                                              block $label$190 ;; label = @22
+                                                local.get $24
+                                                if ;; label = @23
+                                                  block ;; label = @24
+                                                    local.get $26
+                                                    i32.load8_s
+                                                    i32.const 45
+                                                    i32.ne
+                                                    br_if 2 (;@22;)
+                                                    local.get $53
+                                                    f64.neg
+                                                    local.set $53
+                                                    local.get $52
+                                                    f64.neg
+                                                    local.set $52
+                                                  end
+                                                end
+                                              end
+                                              local.get $8
+                                              local.get $22
+                                              local.get $14
+                                              i32.sub
+                                              local.tee $14
+                                              i32.store
+                                              local.get $53
+                                              local.get $52
+                                              f64.add
+                                              local.get $53
+                                              f64.eq
+                                              br_if 2 (;@19;)
+                                              local.get $8
+                                              local.get $14
+                                              local.get $6
+                                              i32.add
+                                              local.tee $5
+                                              i32.store
+                                              local.get $5
+                                              i32.const 999999999
+                                              i32.gt_u
+                                              if ;; label = @22
+                                                loop $label$193 ;; label = @23
+                                                  local.get $8
+                                                  i32.const 0
+                                                  i32.store
+                                                  local.get $8
+                                                  i32.const -4
+                                                  i32.add
+                                                  local.tee $8
+                                                  local.get $1
+                                                  i32.lt_u
+                                                  if ;; label = @24
+                                                    local.get $1
+                                                    i32.const -4
+                                                    i32.add
+                                                    local.tee $1
+                                                    i32.const 0
+                                                    i32.store
+                                                  end
+                                                  local.get $8
+                                                  local.get $8
+                                                  i32.load
+                                                  i32.const 1
+                                                  i32.add
+                                                  local.tee $5
+                                                  i32.store
+                                                  local.get $5
+                                                  i32.const 999999999
+                                                  i32.gt_u
+                                                  br_if 0 (;@23;)
+                                                end
+                                              end
+                                              local.get $25
+                                              local.get $1
+                                              i32.sub
+                                              i32.const 2
+                                              i32.shr_s
+                                              i32.const 9
+                                              i32.mul
+                                              local.set $5
+                                              local.get $1
+                                              i32.load
+                                              local.tee $14
+                                              i32.const 10
+                                              i32.lt_u
+                                              br_if 2 (;@19;)
+                                              i32.const 10
+                                              local.set $6
+                                              loop $label$195 ;; label = @22
+                                                local.get $5
+                                                i32.const 1
+                                                i32.add
+                                                local.set $5
+                                                local.get $14
+                                                local.get $6
+                                                i32.const 10
+                                                i32.mul
+                                                local.tee $6
+                                                i32.ge_u
+                                                br_if 0 (;@22;)
+                                              end
+                                            end
+                                          end
+                                        end
+                                        local.get $1
+                                        local.set $14
+                                        local.get $5
+                                        local.set $6
+                                        local.get $13
+                                        local.get $8
+                                        i32.const 4
+                                        i32.add
+                                        local.tee $8
+                                        i32.le_u
+                                        if ;; label = @19
+                                          local.get $13
+                                          local.set $8
+                                        end
+                                      end
+                                    else
+                                      block ;; label = @18
+                                        local.get $1
+                                        local.set $14
+                                        local.get $5
+                                        local.set $6
+                                        local.get $13
+                                        local.set $8
+                                      end
+                                    end
+                                    i32.const 0
+                                    local.get $6
+                                    i32.sub
+                                    local.set $32
+                                    loop $label$198 ;; label = @17
+                                      block $label$199 ;; label = @18
+                                        local.get $8
+                                        local.get $14
+                                        i32.le_u
+                                        if ;; label = @19
+                                          block ;; label = @20
+                                            i32.const 0
+                                            local.set $22
+                                            br 2 (;@18;)
+                                          end
+                                        end
+                                        local.get $8
+                                        i32.const -4
+                                        i32.add
+                                        local.tee $1
+                                        i32.load
+                                        if ;; label = @19
+                                          i32.const 1
+                                          local.set $22
+                                        else
+                                          block ;; label = @20
+                                            local.get $1
+                                            local.set $8
+                                            br 3 (;@17;)
+                                          end
+                                        end
+                                      end
+                                    end
+                                    block $label$203 ;; label = @17
+                                      local.get $29
+                                      if ;; label = @18
+                                        block ;; label = @19
+                                          local.get $35
+                                          i32.const 1
+                                          i32.and
+                                          i32.const 1
+                                          i32.xor
+                                          local.get $18
+                                          i32.add
+                                          local.tee $1
+                                          local.get $6
+                                          i32.gt_s
+                                          local.get $6
+                                          i32.const -5
+                                          i32.gt_s
+                                          i32.and
+                                          if (result i32) ;; label = @20
+                                            block (result i32) ;; label = @21
+                                              local.get $9
+                                              i32.const -1
+                                              i32.add
+                                              local.set $5
+                                              local.get $1
+                                              i32.const -1
+                                              i32.add
+                                              local.get $6
+                                              i32.sub
+                                            end
+                                          else
+                                            block (result i32) ;; label = @21
+                                              local.get $9
+                                              i32.const -2
+                                              i32.add
+                                              local.set $5
+                                              local.get $1
+                                              i32.const -1
+                                              i32.add
+                                            end
+                                          end
+                                          local.set $1
+                                          local.get $12
+                                          i32.const 8
+                                          i32.and
+                                          local.tee $13
+                                          br_if 2 (;@17;)
+                                          block $label$207 ;; label = @20
+                                            local.get $22
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                local.get $8
+                                                i32.const -4
+                                                i32.add
+                                                i32.load
+                                                local.tee $18
+                                                i32.eqz
+                                                if ;; label = @23
+                                                  block ;; label = @24
+                                                    i32.const 9
+                                                    local.set $9
+                                                    br 4 (;@20;)
+                                                  end
+                                                end
+                                                local.get $18
+                                                i32.const 10
+                                                i32.rem_u
+                                                if ;; label = @23
+                                                  block ;; label = @24
+                                                    i32.const 0
+                                                    local.set $9
+                                                    br 4 (;@20;)
+                                                  end
+                                                else
+                                                  block ;; label = @24
+                                                    i32.const 10
+                                                    local.set $13
+                                                    i32.const 0
+                                                    local.set $9
+                                                  end
+                                                end
+                                                loop $label$212 ;; label = @23
+                                                  local.get $9
+                                                  i32.const 1
+                                                  i32.add
+                                                  local.set $9
+                                                  local.get $18
+                                                  local.get $13
+                                                  i32.const 10
+                                                  i32.mul
+                                                  local.tee $13
+                                                  i32.rem_u
+                                                  i32.eqz
+                                                  br_if 0 (;@23;)
+                                                end
+                                              end
+                                            else
+                                              i32.const 9
+                                              local.set $9
+                                            end
+                                          end
+                                          local.get $8
+                                          local.get $25
+                                          i32.sub
+                                          i32.const 2
+                                          i32.shr_s
+                                          i32.const 9
+                                          i32.mul
+                                          i32.const -9
+                                          i32.add
+                                          local.set $18
+                                          local.get $5
+                                          i32.const 32
+                                          i32.or
+                                          i32.const 102
+                                          i32.eq
+                                          if ;; label = @20
+                                            block ;; label = @21
+                                              i32.const 0
+                                              local.set $13
+                                              local.get $1
+                                              local.get $18
+                                              local.get $9
+                                              i32.sub
+                                              local.tee $9
+                                              i32.const 0
+                                              i32.lt_s
+                                              if (result i32) ;; label = @22
+                                                i32.const 0
+                                                local.tee $9
+                                              else
+                                                local.get $9
+                                              end
+                                              i32.ge_s
+                                              if ;; label = @22
+                                                local.get $9
+                                                local.set $1
+                                              end
+                                            end
+                                          else
+                                            block ;; label = @21
+                                              i32.const 0
+                                              local.set $13
+                                              local.get $1
+                                              local.get $18
+                                              local.get $6
+                                              i32.add
+                                              local.get $9
+                                              i32.sub
+                                              local.tee $9
+                                              i32.const 0
+                                              i32.lt_s
+                                              if (result i32) ;; label = @22
+                                                i32.const 0
+                                                local.tee $9
+                                              else
+                                                local.get $9
+                                              end
+                                              i32.ge_s
+                                              if ;; label = @22
+                                                local.get $9
+                                                local.set $1
+                                              end
+                                            end
+                                          end
+                                        end
+                                      else
+                                        block ;; label = @19
+                                          local.get $12
+                                          i32.const 8
+                                          i32.and
+                                          local.set $13
+                                          local.get $18
+                                          local.set $1
+                                          local.get $9
+                                          local.set $5
+                                        end
+                                      end
+                                    end
+                                    local.get $5
+                                    i32.const 32
+                                    i32.or
+                                    i32.const 102
+                                    i32.eq
+                                    local.tee $25
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        i32.const 0
+                                        local.set $9
+                                        local.get $6
+                                        i32.const 0
+                                        i32.le_s
+                                        if ;; label = @19
+                                          i32.const 0
+                                          local.set $6
+                                        end
+                                      end
+                                    else
+                                      block ;; label = @18
+                                        local.get $28
+                                        local.get $6
+                                        i32.const 0
+                                        i32.lt_s
+                                        if (result i32) ;; label = @19
+                                          local.get $32
+                                        else
+                                          local.get $6
+                                        end
+                                        i64.extend_i32_s
+                                        local.get $33
+                                        call $23
+                                        local.tee $9
+                                        i32.sub
+                                        i32.const 2
+                                        i32.lt_s
+                                        if ;; label = @19
+                                          loop $label$229 ;; label = @20
+                                            local.get $9
+                                            i32.const -1
+                                            i32.add
+                                            local.tee $9
+                                            i32.const 48
+                                            i32.store8
+                                            local.get $28
+                                            local.get $9
+                                            i32.sub
+                                            i32.const 2
+                                            i32.lt_s
+                                            br_if 0 (;@20;)
+                                          end
+                                        end
+                                        local.get $9
+                                        i32.const -1
+                                        i32.add
+                                        local.get $6
+                                        i32.const 31
+                                        i32.shr_s
+                                        i32.const 2
+                                        i32.and
+                                        i32.const 43
+                                        i32.add
+                                        i32.store8
+                                        local.get $9
+                                        i32.const -2
+                                        i32.add
+                                        local.tee $6
+                                        local.get $5
+                                        i32.store8
+                                        local.get $6
+                                        local.set $9
+                                        local.get $28
+                                        local.get $6
+                                        i32.sub
+                                        local.set $6
+                                      end
+                                    end
+                                    local.get $0
+                                    i32.const 32
+                                    local.get $10
+                                    local.get $24
+                                    i32.const 1
+                                    i32.add
+                                    local.get $1
+                                    i32.add
+                                    local.get $1
+                                    local.get $13
+                                    i32.or
+                                    local.tee $29
+                                    i32.const 0
+                                    i32.ne
+                                    i32.add
+                                    local.get $6
+                                    i32.add
+                                    local.tee $18
+                                    local.get $12
+                                    call $25
+                                    local.get $0
+                                    i32.load
+                                    i32.const 32
+                                    i32.and
+                                    i32.eqz
+                                    if ;; label = @17
+                                      local.get $26
+                                      local.get $24
+                                      local.get $0
+                                      call $21
+                                      drop
+                                    end
+                                    local.get $0
+                                    i32.const 48
+                                    local.get $10
+                                    local.get $18
+                                    local.get $12
+                                    i32.const 65536
+                                    i32.xor
+                                    call $25
+                                    block $label$231 ;; label = @17
+                                      local.get $25
+                                      if ;; label = @18
+                                        block ;; label = @19
+                                          local.get $14
+                                          local.get $7
+                                          i32.gt_u
+                                          if (result i32) ;; label = @20
+                                            local.get $7
+                                          else
+                                            local.get $14
+                                          end
+                                          local.tee $9
+                                          local.set $6
+                                          loop $label$235 ;; label = @20
+                                            local.get $6
+                                            i32.load
+                                            i64.extend_i32_u
+                                            local.get $31
+                                            call $23
+                                            local.set $5
+                                            block $label$236 ;; label = @21
+                                              local.get $6
+                                              local.get $9
+                                              i32.eq
+                                              if ;; label = @22
+                                                block ;; label = @23
+                                                  local.get $5
+                                                  local.get $31
+                                                  i32.ne
+                                                  br_if 2 (;@21;)
+                                                  local.get $34
+                                                  i32.const 48
+                                                  i32.store8
+                                                  local.get $34
+                                                  local.set $5
+                                                end
+                                              else
+                                                block ;; label = @23
+                                                  local.get $5
+                                                  local.get $19
+                                                  i32.le_u
+                                                  br_if 2 (;@21;)
+                                                  local.get $19
+                                                  i32.const 48
+                                                  local.get $5
+                                                  local.get $27
+                                                  i32.sub
+                                                  call $41
+                                                  drop
+                                                  loop $label$239 ;; label = @24
+                                                    local.get $5
+                                                    i32.const -1
+                                                    i32.add
+                                                    local.tee $5
+                                                    local.get $19
+                                                    i32.gt_u
+                                                    br_if 0 (;@24;)
+                                                  end
+                                                end
+                                              end
+                                            end
+                                            local.get $0
+                                            i32.load
+                                            i32.const 32
+                                            i32.and
+                                            i32.eqz
+                                            if ;; label = @21
+                                              local.get $5
+                                              local.get $41
+                                              local.get $5
+                                              i32.sub
+                                              local.get $0
+                                              call $21
+                                              drop
+                                            end
+                                            local.get $6
+                                            i32.const 4
+                                            i32.add
+                                            local.tee $5
+                                            local.get $7
+                                            i32.le_u
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                local.get $5
+                                                local.set $6
+                                                br 2 (;@20;)
+                                              end
+                                            end
+                                          end
+                                          block $label$242 ;; label = @20
+                                            local.get $29
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                local.get $0
+                                                i32.load
+                                                i32.const 32
+                                                i32.and
+                                                br_if 2 (;@20;)
+                                                i32.const 1687
+                                                i32.const 1
+                                                local.get $0
+                                                call $21
+                                                drop
+                                              end
+                                            end
+                                          end
+                                          local.get $1
+                                          i32.const 0
+                                          i32.gt_s
+                                          local.get $5
+                                          local.get $8
+                                          i32.lt_u
+                                          i32.and
+                                          if ;; label = @20
+                                            loop $label$245 ;; label = @21
+                                              local.get $5
+                                              i32.load
+                                              i64.extend_i32_u
+                                              local.get $31
+                                              call $23
+                                              local.tee $7
+                                              local.get $19
+                                              i32.gt_u
+                                              if ;; label = @22
+                                                block ;; label = @23
+                                                  local.get $19
+                                                  i32.const 48
+                                                  local.get $7
+                                                  local.get $27
+                                                  i32.sub
+                                                  call $41
+                                                  drop
+                                                  loop $label$247 ;; label = @24
+                                                    local.get $7
+                                                    i32.const -1
+                                                    i32.add
+                                                    local.tee $7
+                                                    local.get $19
+                                                    i32.gt_u
+                                                    br_if 0 (;@24;)
+                                                  end
+                                                end
+                                              end
+                                              local.get $0
+                                              i32.load
+                                              i32.const 32
+                                              i32.and
+                                              i32.eqz
+                                              if ;; label = @22
+                                                local.get $7
+                                                local.get $1
+                                                i32.const 9
+                                                i32.gt_s
+                                                if (result i32) ;; label = @23
+                                                  i32.const 9
+                                                else
+                                                  local.get $1
+                                                end
+                                                local.get $0
+                                                call $21
+                                                drop
+                                              end
+                                              local.get $1
+                                              i32.const -9
+                                              i32.add
+                                              local.set $7
+                                              local.get $1
+                                              i32.const 9
+                                              i32.gt_s
+                                              local.get $5
+                                              i32.const 4
+                                              i32.add
+                                              local.tee $5
+                                              local.get $8
+                                              i32.lt_u
+                                              i32.and
+                                              if ;; label = @22
+                                                block ;; label = @23
+                                                  local.get $7
+                                                  local.set $1
+                                                  br 2 (;@21;)
+                                                end
+                                              else
+                                                local.get $7
+                                                local.set $1
+                                              end
+                                            end
+                                          end
+                                          local.get $0
+                                          i32.const 48
+                                          local.get $1
+                                          i32.const 9
+                                          i32.add
+                                          i32.const 9
+                                          i32.const 0
+                                          call $25
+                                        end
+                                      else
+                                        block ;; label = @19
+                                          local.get $14
+                                          i32.const 4
+                                          i32.add
+                                          local.set $5
+                                          local.get $22
+                                          i32.eqz
+                                          if ;; label = @20
+                                            local.get $5
+                                            local.set $8
+                                          end
+                                          local.get $1
+                                          i32.const -1
+                                          i32.gt_s
+                                          if ;; label = @20
+                                            block ;; label = @21
+                                              local.get $13
+                                              i32.eqz
+                                              local.set $13
+                                              local.get $14
+                                              local.set $7
+                                              local.get $1
+                                              local.set $5
+                                              loop $label$256 ;; label = @22
+                                                local.get $7
+                                                i32.load
+                                                i64.extend_i32_u
+                                                local.get $31
+                                                call $23
+                                                local.tee $1
+                                                local.get $31
+                                                i32.eq
+                                                if ;; label = @23
+                                                  block ;; label = @24
+                                                    local.get $34
+                                                    i32.const 48
+                                                    i32.store8
+                                                    local.get $34
+                                                    local.set $1
+                                                  end
+                                                end
+                                                block $label$258 ;; label = @23
+                                                  local.get $7
+                                                  local.get $14
+                                                  i32.eq
+                                                  if ;; label = @24
+                                                    block ;; label = @25
+                                                      local.get $0
+                                                      i32.load
+                                                      i32.const 32
+                                                      i32.and
+                                                      i32.eqz
+                                                      if ;; label = @26
+                                                        local.get $1
+                                                        i32.const 1
+                                                        local.get $0
+                                                        call $21
+                                                        drop
+                                                      end
+                                                      local.get $1
+                                                      i32.const 1
+                                                      i32.add
+                                                      local.set $1
+                                                      local.get $13
+                                                      local.get $5
+                                                      i32.const 1
+                                                      i32.lt_s
+                                                      i32.and
+                                                      br_if 2 (;@23;)
+                                                      local.get $0
+                                                      i32.load
+                                                      i32.const 32
+                                                      i32.and
+                                                      br_if 2 (;@23;)
+                                                      i32.const 1687
+                                                      i32.const 1
+                                                      local.get $0
+                                                      call $21
+                                                      drop
+                                                    end
+                                                  else
+                                                    block ;; label = @25
+                                                      local.get $1
+                                                      local.get $19
+                                                      i32.le_u
+                                                      br_if 2 (;@23;)
+                                                      local.get $19
+                                                      i32.const 48
+                                                      local.get $1
+                                                      local.get $43
+                                                      i32.add
+                                                      call $41
+                                                      drop
+                                                      loop $label$262 ;; label = @26
+                                                        local.get $1
+                                                        i32.const -1
+                                                        i32.add
+                                                        local.tee $1
+                                                        local.get $19
+                                                        i32.gt_u
+                                                        br_if 0 (;@26;)
+                                                      end
+                                                    end
+                                                  end
+                                                end
+                                                local.get $41
+                                                local.get $1
+                                                i32.sub
+                                                local.set $6
+                                                local.get $0
+                                                i32.load
+                                                i32.const 32
+                                                i32.and
+                                                i32.eqz
+                                                if ;; label = @23
+                                                  local.get $1
+                                                  local.get $5
+                                                  local.get $6
+                                                  i32.gt_s
+                                                  if (result i32) ;; label = @24
+                                                    local.get $6
+                                                  else
+                                                    local.get $5
+                                                  end
+                                                  local.get $0
+                                                  call $21
+                                                  drop
+                                                end
+                                                local.get $7
+                                                i32.const 4
+                                                i32.add
+                                                local.tee $7
+                                                local.get $8
+                                                i32.lt_u
+                                                local.get $5
+                                                local.get $6
+                                                i32.sub
+                                                local.tee $5
+                                                i32.const -1
+                                                i32.gt_s
+                                                i32.and
+                                                br_if 0 (;@22;)
+                                                local.get $5
+                                                local.set $1
+                                              end
+                                            end
+                                          end
+                                          local.get $0
+                                          i32.const 48
+                                          local.get $1
+                                          i32.const 18
+                                          i32.add
+                                          i32.const 18
+                                          i32.const 0
+                                          call $25
+                                          local.get $0
+                                          i32.load
+                                          i32.const 32
+                                          i32.and
+                                          br_if 2 (;@17;)
+                                          local.get $9
+                                          local.get $28
+                                          local.get $9
+                                          i32.sub
+                                          local.get $0
+                                          call $21
+                                          drop
+                                        end
+                                      end
+                                    end
+                                    local.get $0
+                                    i32.const 32
+                                    local.get $10
+                                    local.get $18
+                                    local.get $12
+                                    i32.const 8192
+                                    i32.xor
+                                    call $25
+                                    local.get $18
+                                    local.get $10
+                                    i32.ge_s
+                                    if ;; label = @17
+                                      local.get $18
+                                      local.set $10
+                                    end
+                                  end
+                                else
+                                  block ;; label = @16
+                                    local.get $0
+                                    i32.const 32
+                                    local.get $10
+                                    local.get $52
+                                    local.get $52
+                                    f64.ne
+                                    i32.const 0
+                                    i32.or
+                                    local.tee $6
+                                    if (result i32) ;; label = @17
+                                      i32.const 0
+                                      local.tee $24
+                                    else
+                                      local.get $24
+                                    end
+                                    i32.const 3
+                                    i32.add
+                                    local.tee $8
+                                    local.get $7
+                                    call $25
+                                    local.get $0
+                                    i32.load
+                                    local.tee $1
+                                    i32.const 32
+                                    i32.and
+                                    i32.eqz
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        local.get $26
+                                        local.get $24
+                                        local.get $0
+                                        call $21
+                                        drop
+                                        local.get $0
+                                        i32.load
+                                        local.set $1
+                                      end
+                                    end
+                                    local.get $9
+                                    i32.const 32
+                                    i32.and
+                                    i32.const 0
+                                    i32.ne
+                                    local.tee $5
+                                    if (result i32) ;; label = @17
+                                      i32.const 1671
+                                    else
+                                      i32.const 1675
+                                    end
+                                    local.set $7
+                                    local.get $5
+                                    if (result i32) ;; label = @17
+                                      i32.const 1679
+                                    else
+                                      i32.const 1683
+                                    end
+                                    local.set $5
+                                    local.get $6
+                                    i32.eqz
+                                    if ;; label = @17
+                                      local.get $7
+                                      local.set $5
+                                    end
+                                    local.get $1
+                                    i32.const 32
+                                    i32.and
+                                    i32.eqz
+                                    if ;; label = @17
+                                      local.get $5
+                                      i32.const 3
+                                      local.get $0
+                                      call $21
+                                      drop
+                                    end
+                                    local.get $0
+                                    i32.const 32
+                                    local.get $10
+                                    local.get $8
+                                    local.get $12
+                                    i32.const 8192
+                                    i32.xor
+                                    call $25
+                                    local.get $8
+                                    local.get $10
+                                    i32.ge_s
+                                    if ;; label = @17
+                                      local.get $8
+                                      local.set $10
+                                    end
+                                  end
+                                end
+                              end
+                              local.get $11
+                              local.set $1
+                              br 9 (;@4;)
+                            end
+                            local.get $5
+                            local.set $7
+                            i32.const 0
+                            local.set $6
+                            i32.const 1635
+                            local.set $8
+                            local.get $21
+                            local.set $5
+                            br 6 (;@6;)
+                          end
+                          local.get $9
+                          i32.const 32
+                          i32.and
+                          local.set $7
+                          local.get $16
+                          i64.load
+                          local.tee $50
+                          i64.const 0
+                          i64.eq
+                          if (result i32) ;; label = @12
+                            block (result i32) ;; label = @13
+                              i64.const 0
+                              local.set $50
+                              local.get $21
+                            end
+                          else
+                            block (result i32) ;; label = @13
+                              local.get $21
+                              local.set $1
+                              loop $label$280 ;; label = @14
+                                local.get $1
+                                i32.const -1
+                                i32.add
+                                local.tee $1
+                                local.get $50
+                                i32.wrap_i64
+                                i32.const 15
+                                i32.and
+                                i32.const 1619
+                                i32.add
+                                i32.load8_u
+                                local.get $7
+                                i32.or
+                                i32.store8
+                                local.get $50
+                                i64.const 4
+                                i64.shr_u
+                                local.tee $50
+                                i64.const 0
+                                i64.ne
+                                br_if 0 (;@14;)
+                              end
+                              local.get $16
+                              i64.load
+                              local.set $50
+                              local.get $1
+                            end
+                          end
+                          local.set $7
+                          local.get $9
+                          i32.const 4
+                          i32.shr_s
+                          i32.const 1635
+                          i32.add
+                          local.set $8
+                          local.get $12
+                          i32.const 8
+                          i32.and
+                          i32.eqz
+                          local.get $50
+                          i64.const 0
+                          i64.eq
+                          i32.or
+                          local.tee $1
+                          if ;; label = @12
+                            i32.const 1635
+                            local.set $8
+                          end
+                          local.get $1
+                          if (result i32) ;; label = @12
+                            i32.const 0
+                          else
+                            i32.const 2
+                          end
+                          local.set $6
+                          br 4 (;@7;)
+                        end
+                        local.get $50
+                        local.get $21
+                        call $23
+                        local.set $7
+                        br 3 (;@7;)
+                      end
+                      local.get $1
+                      i32.const 0
+                      local.get $5
+                      call $17
+                      local.tee $13
+                      i32.eqz
+                      local.set $14
+                      local.get $13
+                      local.get $1
+                      i32.sub
+                      local.set $8
+                      local.get $1
+                      local.get $5
+                      i32.add
+                      local.set $9
+                      local.get $7
+                      local.set $12
+                      local.get $14
+                      if (result i32) ;; label = @10
+                        local.get $5
+                      else
+                        local.get $8
+                      end
+                      local.set $7
+                      i32.const 0
+                      local.set $6
+                      i32.const 1635
+                      local.set $8
+                      local.get $14
+                      if (result i32) ;; label = @10
+                        local.get $9
+                      else
+                        local.get $13
+                      end
+                      local.set $5
+                      br 3 (;@6;)
+                    end
+                    i32.const 0
+                    local.set $1
+                    i32.const 0
+                    local.set $5
+                    local.get $7
+                    local.set $8
+                    loop $label$288 ;; label = @9
+                      block $label$289 ;; label = @10
+                        local.get $8
+                        i32.load
+                        local.tee $9
+                        i32.eqz
+                        br_if 0 (;@10;)
+                        local.get $36
+                        local.get $9
+                        call $26
+                        local.tee $5
+                        i32.const 0
+                        i32.lt_s
+                        local.get $5
+                        local.get $6
+                        local.get $1
+                        i32.sub
+                        i32.gt_u
+                        i32.or
+                        br_if 0 (;@10;)
+                        local.get $8
+                        i32.const 4
+                        i32.add
+                        local.set $8
+                        local.get $6
+                        local.get $5
+                        local.get $1
+                        i32.add
+                        local.tee $1
+                        i32.gt_u
+                        br_if 1 (;@9;)
+                      end
+                    end
+                    local.get $5
+                    i32.const 0
+                    i32.lt_s
+                    if ;; label = @9
+                      block ;; label = @10
+                        i32.const -1
+                        local.set $15
+                        br 5 (;@5;)
+                      end
+                    end
+                    local.get $0
+                    i32.const 32
+                    local.get $10
+                    local.get $1
+                    local.get $12
+                    call $25
+                    local.get $1
+                    if ;; label = @9
+                      block ;; label = @10
+                        i32.const 0
+                        local.set $5
+                        loop $label$292 ;; label = @11
+                          local.get $7
+                          i32.load
+                          local.tee $8
+                          i32.eqz
+                          br_if 3 (;@8;)
+                          local.get $36
+                          local.get $8
+                          call $26
+                          local.tee $8
+                          local.get $5
+                          i32.add
+                          local.tee $5
+                          local.get $1
+                          i32.gt_s
+                          br_if 3 (;@8;)
+                          local.get $0
+                          i32.load
+                          i32.const 32
+                          i32.and
+                          i32.eqz
+                          if ;; label = @12
+                            local.get $36
+                            local.get $8
+                            local.get $0
+                            call $21
+                            drop
+                          end
+                          local.get $7
+                          i32.const 4
+                          i32.add
+                          local.set $7
+                          local.get $5
+                          local.get $1
+                          i32.lt_u
+                          br_if 0 (;@11;)
+                          br 3 (;@8;)
+                        end
+                      end
+                    else
+                      block ;; label = @10
+                        i32.const 0
+                        local.set $1
+                        br 2 (;@8;)
+                      end
+                    end
+                  end
+                  local.get $0
+                  i32.const 32
+                  local.get $10
+                  local.get $1
+                  local.get $12
+                  i32.const 8192
+                  i32.xor
+                  call $25
+                  local.get $10
+                  local.get $1
+                  i32.le_s
+                  if ;; label = @8
+                    local.get $1
+                    local.set $10
+                  end
+                  local.get $11
+                  local.set $1
+                  br 3 (;@4;)
+                end
+                local.get $12
+                i32.const -65537
+                i32.and
+                local.set $1
+                local.get $5
+                i32.const -1
+                i32.gt_s
+                if ;; label = @7
+                  local.get $1
+                  local.set $12
+                end
+                local.get $5
+                local.get $16
+                i64.load
+                i64.const 0
+                i64.ne
+                local.tee $9
+                i32.or
+                if (result i32) ;; label = @7
+                  block (result i32) ;; label = @8
+                    local.get $7
+                    local.set $1
+                    local.get $5
+                    local.get $9
+                    i32.const 1
+                    i32.and
+                    i32.const 1
+                    i32.xor
+                    local.get $38
+                    local.get $7
+                    i32.sub
+                    i32.add
+                    local.tee $7
+                    i32.gt_s
+                    if ;; label = @9
+                      local.get $5
+                      local.set $7
+                    end
+                    local.get $21
+                  end
+                else
+                  block (result i32) ;; label = @8
+                    local.get $21
+                    local.set $1
+                    i32.const 0
+                    local.set $7
+                    local.get $21
+                  end
+                end
+                local.set $5
+              end
+              local.get $0
+              i32.const 32
+              local.get $10
+              local.get $7
+              local.get $5
+              local.get $1
+              i32.sub
+              local.tee $9
+              i32.lt_s
+              if (result i32) ;; label = @6
+                local.get $9
+                local.tee $7
+              else
+                local.get $7
+              end
+              local.get $6
+              i32.add
+              local.tee $5
+              i32.lt_s
+              if (result i32) ;; label = @6
+                local.get $5
+                local.tee $10
+              else
+                local.get $10
+              end
+              local.get $5
+              local.get $12
+              call $25
+              local.get $0
+              i32.load
+              i32.const 32
+              i32.and
+              i32.eqz
+              if ;; label = @6
+                local.get $8
+                local.get $6
+                local.get $0
+                call $21
+                drop
+              end
+              local.get $0
+              i32.const 48
+              local.get $10
+              local.get $5
+              local.get $12
+              i32.const 65536
+              i32.xor
+              call $25
+              local.get $0
+              i32.const 48
+              local.get $7
+              local.get $9
+              i32.const 0
+              call $25
+              local.get $0
+              i32.load
+              i32.const 32
+              i32.and
+              i32.eqz
+              if ;; label = @6
+                local.get $1
+                local.get $9
+                local.get $0
+                call $21
+                drop
+              end
+              local.get $0
+              i32.const 32
+              local.get $10
+              local.get $5
+              local.get $12
+              i32.const 8192
+              i32.xor
+              call $25
+              local.get $11
+              local.set $1
+              br 1 (;@4;)
+            end
+          end
+          br 1 (;@2;)
+        end
+        local.get $0
+        i32.eqz
+        if ;; label = @3
+          local.get $17
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 1
+              local.set $0
+              loop $label$308 ;; label = @6
+                local.get $4
+                local.get $0
+                i32.const 2
+                i32.shl
+                i32.add
+                i32.load
+                local.tee $1
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $3
+                    local.get $0
+                    i32.const 3
+                    i32.shl
+                    i32.add
+                    local.get $1
+                    local.get $2
+                    call $22
+                    local.get $0
+                    i32.const 1
+                    i32.add
+                    local.tee $0
+                    i32.const 10
+                    i32.lt_s
+                    br_if 2 (;@6;)
+                    i32.const 1
+                    local.set $15
+                    br 6 (;@2;)
+                  end
+                end
+              end
+              loop $label$310 ;; label = @6
+                local.get $4
+                local.get $0
+                i32.const 2
+                i32.shl
+                i32.add
+                i32.load
+                if ;; label = @7
+                  block ;; label = @8
+                    i32.const -1
+                    local.set $15
+                    br 6 (;@2;)
+                  end
+                end
+                local.get $0
+                i32.const 1
+                i32.add
+                local.tee $0
+                i32.const 10
+                i32.lt_s
+                br_if 0 (;@6;)
+                i32.const 1
+                local.set $15
+              end
+            end
+          else
+            i32.const 0
+            local.set $15
+          end
+        end
+      end
+      local.get $23
+      global.set $global$1
+      local.get $15
+    end
+  )
+  (func $20 (;33;) (type $1) (param $0 i32) (result i32)
+    i32.const 0
+  )
+  (func $21 (;34;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32)
+    block $label$1 (result i32) ;; label = @1
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          local.get $2
+          i32.const 16
+          i32.add
+          local.tee $4
+          i32.load
+          local.tee $3
+          br_if 0 (;@3;)
+          local.get $2
+          call $30
+          if ;; label = @4
+            i32.const 0
+            local.set $3
+          else
+            block ;; label = @5
+              local.get $4
+              i32.load
+              local.set $3
+              br 2 (;@3;)
+            end
+          end
+          br 1 (;@2;)
+        end
+        local.get $3
+        local.get $2
+        i32.const 20
+        i32.add
+        local.tee $5
+        i32.load
+        local.tee $4
+        i32.sub
+        local.get $1
+        i32.lt_u
+        if ;; label = @3
+          block ;; label = @4
+            local.get $2
+            local.get $0
+            local.get $1
+            local.get $2
+            i32.load offset=36
+            i32.const 3
+            i32.and
+            i32.const 2
+            i32.add
+            call_indirect (type $0)
+            local.set $3
+            br 2 (;@2;)
+          end
+        end
+        block $label$7 (result i32) ;; label = @3
+          local.get $2
+          i32.load8_s offset=75
+          i32.const -1
+          i32.gt_s
+          if (result i32) ;; label = @4
+            block (result i32) ;; label = @5
+              local.get $1
+              local.set $3
+              loop $label$9 ;; label = @6
+                i32.const 0
+                local.get $3
+                i32.eqz
+                br_if 3 (;@3;)
+                drop
+                local.get $0
+                local.get $3
+                i32.const -1
+                i32.add
+                local.tee $6
+                i32.add
+                i32.load8_s
+                i32.const 10
+                i32.ne
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $6
+                    local.set $3
+                    br 2 (;@6;)
+                  end
+                end
+              end
+              local.get $2
+              local.get $0
+              local.get $3
+              local.get $2
+              i32.load offset=36
+              i32.const 3
+              i32.and
+              i32.const 2
+              i32.add
+              call_indirect (type $0)
+              local.get $3
+              i32.lt_u
+              br_if 3 (;@2;)
+              local.get $5
+              i32.load
+              local.set $4
+              local.get $1
+              local.get $3
+              i32.sub
+              local.set $1
+              local.get $0
+              local.get $3
+              i32.add
+              local.set $0
+              local.get $3
+            end
+          else
+            i32.const 0
+          end
+        end
+        local.set $2
+        local.get $4
+        local.get $0
+        local.get $1
+        call $42
+        drop
+        local.get $5
+        local.get $5
+        i32.load
+        local.get $1
+        i32.add
+        i32.store
+        local.get $2
+        local.get $1
+        i32.add
+        local.set $3
+      end
+      local.get $3
+    end
+  )
+  (func $22 (;35;) (type $8) (param $0 i32) (param $1 i32) (param $2 i32)
+    (local $3 i32) (local $4 i64) (local $5 f64)
+    block $label$1 ;; label = @1
+      local.get $1
+      i32.const 20
+      i32.le_u
+      if ;; label = @2
+        block $label$3 ;; label = @3
+          block $label$4 ;; label = @4
+            block $label$5 ;; label = @5
+              block $label$6 ;; label = @6
+                block $label$7 ;; label = @7
+                  block $label$8 ;; label = @8
+                    block $label$9 ;; label = @9
+                      block $label$10 ;; label = @10
+                        block $label$11 ;; label = @11
+                          block $label$12 ;; label = @12
+                            block $label$13 ;; label = @13
+                              local.get $1
+                              i32.const 9
+                              i32.sub
+                              br_table 0 (;@13;) 1 (;@12;) 2 (;@11;) 3 (;@10;) 4 (;@9;) 5 (;@8;) 6 (;@7;) 7 (;@6;) 8 (;@5;) 9 (;@4;) 10 (;@3;)
+                            end
+                            local.get $2
+                            i32.load
+                            i32.const 3
+                            i32.add
+                            i32.const -4
+                            i32.and
+                            local.tee $1
+                            i32.load
+                            local.set $3
+                            local.get $2
+                            local.get $1
+                            i32.const 4
+                            i32.add
+                            i32.store
+                            local.get $0
+                            local.get $3
+                            i32.store
+                            br 11 (;@1;)
+                          end
+                          local.get $2
+                          i32.load
+                          i32.const 3
+                          i32.add
+                          i32.const -4
+                          i32.and
+                          local.tee $1
+                          i32.load
+                          local.set $3
+                          local.get $2
+                          local.get $1
+                          i32.const 4
+                          i32.add
+                          i32.store
+                          local.get $0
+                          local.get $3
+                          i64.extend_i32_s
+                          i64.store
+                          br 10 (;@1;)
+                        end
+                        local.get $2
+                        i32.load
+                        i32.const 3
+                        i32.add
+                        i32.const -4
+                        i32.and
+                        local.tee $1
+                        i32.load
+                        local.set $3
+                        local.get $2
+                        local.get $1
+                        i32.const 4
+                        i32.add
+                        i32.store
+                        local.get $0
+                        local.get $3
+                        i64.extend_i32_u
+                        i64.store
+                        br 9 (;@1;)
+                      end
+                      local.get $2
+                      i32.load
+                      i32.const 7
+                      i32.add
+                      i32.const -8
+                      i32.and
+                      local.tee $1
+                      i64.load
+                      local.set $4
+                      local.get $2
+                      local.get $1
+                      i32.const 8
+                      i32.add
+                      i32.store
+                      local.get $0
+                      local.get $4
+                      i64.store
+                      br 8 (;@1;)
+                    end
+                    local.get $2
+                    i32.load
+                    i32.const 3
+                    i32.add
+                    i32.const -4
+                    i32.and
+                    local.tee $1
+                    i32.load
+                    local.set $3
+                    local.get $2
+                    local.get $1
+                    i32.const 4
+                    i32.add
+                    i32.store
+                    local.get $0
+                    local.get $3
+                    i32.const 65535
+                    i32.and
+                    i32.const 16
+                    i32.shl
+                    i32.const 16
+                    i32.shr_s
+                    i64.extend_i32_s
+                    i64.store
+                    br 7 (;@1;)
+                  end
+                  local.get $2
+                  i32.load
+                  i32.const 3
+                  i32.add
+                  i32.const -4
+                  i32.and
+                  local.tee $1
+                  i32.load
+                  local.set $3
+                  local.get $2
+                  local.get $1
+                  i32.const 4
+                  i32.add
+                  i32.store
+                  local.get $0
+                  local.get $3
+                  i32.const 65535
+                  i32.and
+                  i64.extend_i32_u
+                  i64.store
+                  br 6 (;@1;)
+                end
+                local.get $2
+                i32.load
+                i32.const 3
+                i32.add
+                i32.const -4
+                i32.and
+                local.tee $1
+                i32.load
+                local.set $3
+                local.get $2
+                local.get $1
+                i32.const 4
+                i32.add
+                i32.store
+                local.get $0
+                local.get $3
+                i32.const 255
+                i32.and
+                i32.const 24
+                i32.shl
+                i32.const 24
+                i32.shr_s
+                i64.extend_i32_s
+                i64.store
+                br 5 (;@1;)
+              end
+              local.get $2
+              i32.load
+              i32.const 3
+              i32.add
+              i32.const -4
+              i32.and
+              local.tee $1
+              i32.load
+              local.set $3
+              local.get $2
+              local.get $1
+              i32.const 4
+              i32.add
+              i32.store
+              local.get $0
+              local.get $3
+              i32.const 255
+              i32.and
+              i64.extend_i32_u
+              i64.store
+              br 4 (;@1;)
+            end
+            local.get $2
+            i32.load
+            i32.const 7
+            i32.add
+            i32.const -8
+            i32.and
+            local.tee $1
+            f64.load
+            local.set $5
+            local.get $2
+            local.get $1
+            i32.const 8
+            i32.add
+            i32.store
+            local.get $0
+            local.get $5
+            f64.store
+            br 3 (;@1;)
+          end
+          local.get $2
+          i32.load
+          i32.const 7
+          i32.add
+          i32.const -8
+          i32.and
+          local.tee $1
+          f64.load
+          local.set $5
+          local.get $2
+          local.get $1
+          i32.const 8
+          i32.add
+          i32.store
+          local.get $0
+          local.get $5
+          f64.store
+        end
+      end
+    end
+  )
+  (func $23 (;36;) (type $9) (param $0 i64) (param $1 i32) (result i32)
+    (local $2 i32) (local $3 i32) (local $4 i64)
+    block $label$1 (result i32) ;; label = @1
+      local.get $0
+      i32.wrap_i64
+      local.set $2
+      local.get $0
+      i64.const 4294967295
+      i64.gt_u
+      if ;; label = @2
+        block ;; label = @3
+          loop $label$3 ;; label = @4
+            local.get $1
+            i32.const -1
+            i32.add
+            local.tee $1
+            local.get $0
+            i64.const 10
+            i64.rem_u
+            i64.const 48
+            i64.or
+            i64.store8
+            local.get $0
+            i64.const 10
+            i64.div_u
+            local.set $4
+            local.get $0
+            i64.const 42949672959
+            i64.gt_u
+            if ;; label = @5
+              block ;; label = @6
+                local.get $4
+                local.set $0
+                br 2 (;@4;)
+              end
+            end
+          end
+          local.get $4
+          i32.wrap_i64
+          local.set $2
+        end
+      end
+      local.get $2
+      if ;; label = @2
+        loop $label$6 ;; label = @3
+          local.get $1
+          i32.const -1
+          i32.add
+          local.tee $1
+          local.get $2
+          i32.const 10
+          i32.rem_u
+          i32.const 48
+          i32.or
+          i32.store8
+          local.get $2
+          i32.const 10
+          i32.div_u
+          local.set $3
+          local.get $2
+          i32.const 10
+          i32.ge_u
+          if ;; label = @4
+            block ;; label = @5
+              local.get $3
+              local.set $2
+              br 2 (;@3;)
+            end
+          end
+        end
+      end
+      local.get $1
+    end
+  )
+  (func $24 (;37;) (type $1) (param $0 i32) (result i32)
+    (local $1 i32) (local $2 i32)
+    block $label$1 (result i32) ;; label = @1
+      i32.const 0
+      local.set $1
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          block $label$4 ;; label = @4
+            loop $label$5 ;; label = @5
+              local.get $1
+              i32.const 1689
+              i32.add
+              i32.load8_u
+              local.get $0
+              i32.eq
+              br_if 1 (;@4;)
+              local.get $1
+              i32.const 1
+              i32.add
+              local.tee $1
+              i32.const 87
+              i32.ne
+              br_if 0 (;@5;)
+              i32.const 87
+              local.set $1
+              i32.const 1777
+              local.set $0
+              br 2 (;@3;)
+            end
+          end
+          local.get $1
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 1777
+              local.set $0
+              br 2 (;@3;)
+            end
+          else
+            i32.const 1777
+            local.set $0
+          end
+          br 1 (;@2;)
+        end
+        loop $label$8 ;; label = @3
+          local.get $0
+          local.set $2
+          loop $label$9 ;; label = @4
+            local.get $2
+            i32.const 1
+            i32.add
+            local.set $0
+            local.get $2
+            i32.load8_s
+            if ;; label = @5
+              block ;; label = @6
+                local.get $0
+                local.set $2
+                br 2 (;@4;)
+              end
+            end
+          end
+          local.get $1
+          i32.const -1
+          i32.add
+          local.tee $1
+          br_if 0 (;@3;)
+        end
+      end
+      local.get $0
+    end
+  )
+  (func $25 (;38;) (type $10) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32)
+    (local $5 i32) (local $6 i32) (local $7 i32)
+    block $label$1 ;; label = @1
+      global.get $global$1
+      local.set $7
+      global.get $global$1
+      i32.const 256
+      i32.add
+      global.set $global$1
+      local.get $7
+      local.set $6
+      block $label$2 ;; label = @2
+        local.get $2
+        local.get $3
+        i32.gt_s
+        local.get $4
+        i32.const 73728
+        i32.and
+        i32.eqz
+        i32.and
+        if ;; label = @3
+          block ;; label = @4
+            local.get $6
+            local.get $1
+            local.get $2
+            local.get $3
+            i32.sub
+            local.tee $5
+            i32.const 256
+            i32.gt_u
+            if (result i32) ;; label = @5
+              i32.const 256
+            else
+              local.get $5
+            end
+            call $41
+            drop
+            local.get $0
+            i32.load
+            local.tee $1
+            i32.const 32
+            i32.and
+            i32.eqz
+            local.set $4
+            local.get $5
+            i32.const 255
+            i32.gt_u
+            if ;; label = @5
+              block ;; label = @6
+                loop $label$7 ;; label = @7
+                  local.get $4
+                  if ;; label = @8
+                    block ;; label = @9
+                      local.get $6
+                      i32.const 256
+                      local.get $0
+                      call $21
+                      drop
+                      local.get $0
+                      i32.load
+                      local.set $1
+                    end
+                  end
+                  local.get $1
+                  i32.const 32
+                  i32.and
+                  i32.eqz
+                  local.set $4
+                  local.get $5
+                  i32.const -256
+                  i32.add
+                  local.tee $5
+                  i32.const 255
+                  i32.gt_u
+                  br_if 0 (;@7;)
+                end
+                local.get $4
+                i32.eqz
+                br_if 4 (;@2;)
+                local.get $2
+                local.get $3
+                i32.sub
+                i32.const 255
+                i32.and
+                local.set $5
+              end
+            else
+              local.get $4
+              i32.eqz
+              br_if 3 (;@2;)
+            end
+            local.get $6
+            local.get $5
+            local.get $0
+            call $21
+            drop
+          end
+        end
+      end
+      local.get $7
+      global.set $global$1
+    end
+  )
+  (func $26 (;39;) (type $4) (param $0 i32) (param $1 i32) (result i32)
+    local.get $0
+    if (result i32) ;; label = @1
+      local.get $0
+      local.get $1
+      i32.const 0
+      call $29
+    else
+      i32.const 0
+    end
+  )
+  (func $27 (;40;) (type $11) (param $0 f64) (param $1 i32) (result f64)
+    local.get $0
+    local.get $1
+    call $28
+  )
+  (func $28 (;41;) (type $11) (param $0 f64) (param $1 i32) (result f64)
+    (local $2 i64) (local $3 i64)
+    block $label$1 (result f64) ;; label = @1
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          block $label$4 ;; label = @4
+            block $label$5 ;; label = @5
+              local.get $0
+              i64.reinterpret_f64
+              local.tee $2
+              i64.const 52
+              i64.shr_u
+              local.tee $3
+              i32.wrap_i64
+              i32.const 65535
+              i32.and
+              i32.const 2047
+              i32.and
+              i32.const 16
+              i32.shl
+              i32.const 16
+              i32.shr_s
+              i32.const 0
+              i32.sub
+              br_table 0 (;@5;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 1 (;@4;) 2 (;@3;)
+            end
+            local.get $1
+            local.get $0
+            f64.const 0x0p+0 (;=0;)
+            f64.ne
+            if (result i32) ;; label = @5
+              block (result i32) ;; label = @6
+                local.get $0
+                f64.const 0x1p+64 (;=18446744073709552000;)
+                f64.mul
+                local.get $1
+                call $28
+                local.set $0
+                local.get $1
+                i32.load
+                i32.const -64
+                i32.add
+              end
+            else
+              i32.const 0
+            end
+            i32.store
+            br 2 (;@2;)
+          end
+          br 1 (;@2;)
+        end
+        local.get $1
+        local.get $3
+        i32.wrap_i64
+        i32.const 2047
+        i32.and
+        i32.const -1022
+        i32.add
+        i32.store
+        local.get $2
+        i64.const -9218868437227405313
+        i64.and
+        i64.const 4602678819172646912
+        i64.or
+        f64.reinterpret_i64
+        local.set $0
+      end
+      local.get $0
+    end
+  )
+  (func $29 (;42;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    block $label$1 (result i32) ;; label = @1
+      local.get $0
+      if (result i32) ;; label = @2
+        block (result i32) ;; label = @3
+          local.get $1
+          i32.const 128
+          i32.lt_u
+          if ;; label = @4
+            block ;; label = @5
+              local.get $0
+              local.get $1
+              i32.store8
+              i32.const 1
+              br 4 (;@1;)
+            end
+          end
+          local.get $1
+          i32.const 2048
+          i32.lt_u
+          if ;; label = @4
+            block ;; label = @5
+              local.get $0
+              local.get $1
+              i32.const 6
+              i32.shr_u
+              i32.const 192
+              i32.or
+              i32.store8
+              local.get $0
+              local.get $1
+              i32.const 63
+              i32.and
+              i32.const 128
+              i32.or
+              i32.store8 offset=1
+              i32.const 2
+              br 4 (;@1;)
+            end
+          end
+          local.get $1
+          i32.const 55296
+          i32.lt_u
+          local.get $1
+          i32.const -8192
+          i32.and
+          i32.const 57344
+          i32.eq
+          i32.or
+          if ;; label = @4
+            block ;; label = @5
+              local.get $0
+              local.get $1
+              i32.const 12
+              i32.shr_u
+              i32.const 224
+              i32.or
+              i32.store8
+              local.get $0
+              local.get $1
+              i32.const 6
+              i32.shr_u
+              i32.const 63
+              i32.and
+              i32.const 128
+              i32.or
+              i32.store8 offset=1
+              local.get $0
+              local.get $1
+              i32.const 63
+              i32.and
+              i32.const 128
+              i32.or
+              i32.store8 offset=2
+              i32.const 3
+              br 4 (;@1;)
+            end
+          end
+          local.get $1
+          i32.const -65536
+          i32.add
+          i32.const 1048576
+          i32.lt_u
+          if (result i32) ;; label = @4
+            block (result i32) ;; label = @5
+              local.get $0
+              local.get $1
+              i32.const 18
+              i32.shr_u
+              i32.const 240
+              i32.or
+              i32.store8
+              local.get $0
+              local.get $1
+              i32.const 12
+              i32.shr_u
+              i32.const 63
+              i32.and
+              i32.const 128
+              i32.or
+              i32.store8 offset=1
+              local.get $0
+              local.get $1
+              i32.const 6
+              i32.shr_u
+              i32.const 63
+              i32.and
+              i32.const 128
+              i32.or
+              i32.store8 offset=2
+              local.get $0
+              local.get $1
+              i32.const 63
+              i32.and
+              i32.const 128
+              i32.or
+              i32.store8 offset=3
+              i32.const 4
+            end
+          else
+            block (result i32) ;; label = @5
+              call $12
+              i32.const 84
+              i32.store
+              i32.const -1
+            end
+          end
+        end
+      else
+        i32.const 1
+      end
+    end
+  )
+  (func $30 (;43;) (type $1) (param $0 i32) (result i32)
+    (local $1 i32) (local $2 i32)
+    block $label$1 (result i32) ;; label = @1
+      local.get $0
+      i32.const 74
+      i32.add
+      local.tee $2
+      i32.load8_s
+      local.set $1
+      local.get $2
+      local.get $1
+      i32.const 255
+      i32.add
+      local.get $1
+      i32.or
+      i32.store8
+      local.get $0
+      i32.load
+      local.tee $1
+      i32.const 8
+      i32.and
+      if (result i32) ;; label = @2
+        block (result i32) ;; label = @3
+          local.get $0
+          local.get $1
+          i32.const 32
+          i32.or
+          i32.store
+          i32.const -1
+        end
+      else
+        block (result i32) ;; label = @3
+          local.get $0
+          i32.const 0
+          i32.store offset=8
+          local.get $0
+          i32.const 0
+          i32.store offset=4
+          local.get $0
+          local.get $0
+          i32.load offset=44
+          local.tee $1
+          i32.store offset=28
+          local.get $0
+          local.get $1
+          i32.store offset=20
+          local.get $0
+          local.get $1
+          local.get $0
+          i32.load offset=48
+          i32.add
+          i32.store offset=16
+          i32.const 0
+        end
+      end
+      local.tee $0
+    end
+  )
+  (func $31 (;44;) (type $1) (param $0 i32) (result i32)
+    (local $1 i32) (local $2 i32) (local $3 i32)
+    block $label$1 (result i32) ;; label = @1
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          local.get $0
+          local.tee $2
+          i32.const 3
+          i32.and
+          i32.eqz
+          br_if 0 (;@3;)
+          local.get $2
+          local.set $1
+          loop $label$4 ;; label = @4
+            local.get $0
+            i32.load8_s
+            i32.eqz
+            if ;; label = @5
+              block ;; label = @6
+                local.get $1
+                local.set $0
+                br 4 (;@2;)
+              end
+            end
+            local.get $0
+            i32.const 1
+            i32.add
+            local.tee $0
+            local.tee $1
+            i32.const 3
+            i32.and
+            br_if 0 (;@4;)
+            br 1 (;@3;)
+          end
+        end
+        loop $label$6 ;; label = @3
+          local.get $0
+          i32.const 4
+          i32.add
+          local.set $1
+          local.get $0
+          i32.load
+          local.tee $3
+          i32.const -2139062144
+          i32.and
+          i32.const -2139062144
+          i32.xor
+          local.get $3
+          i32.const -16843009
+          i32.add
+          i32.and
+          i32.eqz
+          if ;; label = @4
+            block ;; label = @5
+              local.get $1
+              local.set $0
+              br 2 (;@3;)
+            end
+          end
+        end
+        local.get $3
+        i32.const 255
+        i32.and
+        i32.const 24
+        i32.shl
+        i32.const 24
+        i32.shr_s
+        if ;; label = @3
+          loop $label$9 ;; label = @4
+            local.get $0
+            i32.const 1
+            i32.add
+            local.tee $0
+            i32.load8_s
+            br_if 0 (;@4;)
+          end
+        end
+      end
+      local.get $0
+      local.get $2
+      i32.sub
+    end
+  )
+  (func $32 (;45;) (type $4) (param $0 i32) (param $1 i32) (result i32)
+    (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $3
+      global.get $global$1
+      i32.const 16
+      i32.add
+      global.set $global$1
+      local.get $3
+      local.tee $4
+      local.get $1
+      i32.const 255
+      i32.and
+      local.tee $7
+      i32.store8
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          local.get $0
+          i32.const 16
+          i32.add
+          local.tee $2
+          i32.load
+          local.tee $5
+          br_if 0 (;@3;)
+          local.get $0
+          call $30
+          if ;; label = @4
+            i32.const -1
+            local.set $1
+          else
+            block ;; label = @5
+              local.get $2
+              i32.load
+              local.set $5
+              br 2 (;@3;)
+            end
+          end
+          br 1 (;@2;)
+        end
+        local.get $0
+        i32.const 20
+        i32.add
+        local.tee $2
+        i32.load
+        local.tee $6
+        local.get $5
+        i32.lt_u
+        if ;; label = @3
+          local.get $1
+          i32.const 255
+          i32.and
+          local.tee $1
+          local.get $0
+          i32.load8_s offset=75
+          i32.ne
+          if ;; label = @4
+            block ;; label = @5
+              local.get $2
+              local.get $6
+              i32.const 1
+              i32.add
+              i32.store
+              local.get $6
+              local.get $7
+              i32.store8
+              br 3 (;@2;)
+            end
+          end
+        end
+        local.get $0
+        local.get $4
+        i32.const 1
+        local.get $0
+        i32.load offset=36
+        i32.const 3
+        i32.and
+        i32.const 2
+        i32.add
+        call_indirect (type $0)
+        i32.const 1
+        i32.eq
+        if (result i32) ;; label = @3
+          local.get $4
+          i32.load8_u
+        else
+          i32.const -1
+        end
+        local.set $1
+      end
+      local.get $3
+      global.set $global$1
+      local.get $1
+    end
+  )
+  (func $33 (;46;) (type $12) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32)
+    (local $4 i32) (local $5 i32)
+    block $label$1 (result i32) ;; label = @1
+      local.get $2
+      local.get $1
+      i32.mul
+      local.set $4
+      local.get $3
+      i32.load offset=76
+      i32.const -1
+      i32.gt_s
+      if ;; label = @2
+        block ;; label = @3
+          local.get $3
+          call $20
+          i32.eqz
+          local.set $5
+          local.get $0
+          local.get $4
+          local.get $3
+          call $21
+          local.set $0
+          local.get $5
+          i32.eqz
+          if ;; label = @4
+            local.get $3
+            call $13
+          end
+        end
+      else
+        local.get $0
+        local.get $4
+        local.get $3
+        call $21
+        local.set $0
+      end
+      local.get $0
+      local.get $4
+      i32.ne
+      if ;; label = @2
+        local.get $0
+        local.get $1
+        i32.div_u
+        local.set $2
+      end
+      local.get $2
+    end
+  )
+  (func $34 (;47;) (type $4) (param $0 i32) (param $1 i32) (result i32)
+    (local $2 i32) (local $3 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $2
+      global.get $global$1
+      i32.const 16
+      i32.add
+      global.set $global$1
+      local.get $2
+      local.tee $3
+      local.get $1
+      i32.store
+      i32.const 1024
+      i32.load
+      local.get $0
+      local.get $3
+      call $18
+      local.set $0
+      local.get $2
+      global.set $global$1
+      local.get $0
+    end
+  )
+  (func $35 (;48;) (type $1) (param $0 i32) (result i32)
+    (local $1 i32) (local $2 i32) (local $3 i32)
+    block $label$1 (result i32) ;; label = @1
+      i32.const 1024
+      i32.load
+      local.tee $1
+      i32.load offset=76
+      i32.const -1
+      i32.gt_s
+      if (result i32) ;; label = @2
+        local.get $1
+        call $20
+      else
+        i32.const 0
+      end
+      local.set $2
+      block $label$4 (result i32) ;; label = @2
+        local.get $0
+        local.get $1
+        call $36
+        i32.const 0
+        i32.lt_s
+        if (result i32) ;; label = @3
+          i32.const 1
+        else
+          block (result i32) ;; label = @4
+            local.get $1
+            i32.load8_s offset=75
+            i32.const 10
+            i32.ne
+            if ;; label = @5
+              local.get $1
+              i32.const 20
+              i32.add
+              local.tee $3
+              i32.load
+              local.tee $0
+              local.get $1
+              i32.load offset=16
+              i32.lt_u
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $3
+                  local.get $0
+                  i32.const 1
+                  i32.add
+                  i32.store
+                  local.get $0
+                  i32.const 10
+                  i32.store8
+                  i32.const 0
+                  br 5 (;@2;)
+                end
+              end
+            end
+            local.get $1
+            i32.const 10
+            call $32
+            i32.const 0
+            i32.lt_s
+          end
+        end
+      end
+      local.set $0
+      local.get $2
+      if ;; label = @2
+        local.get $1
+        call $13
+      end
+      local.get $0
+      i32.const 31
+      i32.shl
+      i32.const 31
+      i32.shr_s
+    end
+  )
+  (func $36 (;49;) (type $4) (param $0 i32) (param $1 i32) (result i32)
+    local.get $0
+    local.get $0
+    call $31
+    i32.const 1
+    local.get $1
+    call $33
+    i32.const -1
+    i32.add
+  )
+  (func $37 (;50;) (type $1) (param $0 i32) (result i32)
+    (local $1 i32) (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32) (local $15 i32) (local $16 i32) (local $17 i32) (local $18 i32) (local $19 i32) (local $20 i32) (local $21 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $14
+      global.get $global$1
+      i32.const 16
+      i32.add
+      global.set $global$1
+      local.get $14
+      local.set $18
+      block $label$2 ;; label = @2
+        local.get $0
+        i32.const 245
+        i32.lt_u
+        if ;; label = @3
+          block ;; label = @4
+            local.get $0
+            i32.const 11
+            i32.add
+            i32.const -8
+            i32.and
+            local.set $3
+            i32.const 3636
+            i32.load
+            local.tee $8
+            local.get $0
+            i32.const 11
+            i32.lt_u
+            if (result i32) ;; label = @5
+              i32.const 16
+              local.tee $3
+            else
+              local.get $3
+            end
+            i32.const 3
+            i32.shr_u
+            local.tee $2
+            i32.shr_u
+            local.tee $0
+            i32.const 3
+            i32.and
+            if ;; label = @5
+              block ;; label = @6
+                local.get $0
+                i32.const 1
+                i32.and
+                i32.const 1
+                i32.xor
+                local.get $2
+                i32.add
+                local.tee $5
+                i32.const 1
+                i32.shl
+                i32.const 2
+                i32.shl
+                i32.const 3676
+                i32.add
+                local.tee $2
+                i32.const 8
+                i32.add
+                local.tee $3
+                i32.load
+                local.tee $7
+                i32.const 8
+                i32.add
+                local.tee $1
+                i32.load
+                local.set $4
+                local.get $2
+                local.get $4
+                i32.eq
+                if ;; label = @7
+                  i32.const 3636
+                  local.get $8
+                  i32.const 1
+                  local.get $5
+                  i32.shl
+                  i32.const -1
+                  i32.xor
+                  i32.and
+                  i32.store
+                else
+                  block ;; label = @8
+                    local.get $4
+                    i32.const 3652
+                    i32.load
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                    local.get $4
+                    i32.const 12
+                    i32.add
+                    local.tee $0
+                    i32.load
+                    local.get $7
+                    i32.eq
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $0
+                        local.get $2
+                        i32.store
+                        local.get $3
+                        local.get $4
+                        i32.store
+                      end
+                    else
+                      call $fimport$10
+                    end
+                  end
+                end
+                local.get $7
+                local.get $5
+                i32.const 3
+                i32.shl
+                local.tee $0
+                i32.const 3
+                i32.or
+                i32.store offset=4
+                local.get $7
+                local.get $0
+                i32.add
+                i32.const 4
+                i32.add
+                local.tee $0
+                local.get $0
+                i32.load
+                i32.const 1
+                i32.or
+                i32.store
+                local.get $14
+                global.set $global$1
+                local.get $1
+                return
+              end
+            end
+            local.get $3
+            i32.const 3644
+            i32.load
+            local.tee $16
+            i32.gt_u
+            if ;; label = @5
+              block ;; label = @6
+                local.get $0
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $0
+                    local.get $2
+                    i32.shl
+                    i32.const 2
+                    local.get $2
+                    i32.shl
+                    local.tee $0
+                    i32.const 0
+                    local.get $0
+                    i32.sub
+                    i32.or
+                    i32.and
+                    local.tee $0
+                    i32.const 0
+                    local.get $0
+                    i32.sub
+                    i32.and
+                    i32.const -1
+                    i32.add
+                    local.tee $0
+                    i32.const 12
+                    i32.shr_u
+                    i32.const 16
+                    i32.and
+                    local.set $5
+                    local.get $0
+                    local.get $5
+                    i32.shr_u
+                    local.tee $2
+                    i32.const 5
+                    i32.shr_u
+                    i32.const 8
+                    i32.and
+                    local.tee $0
+                    local.get $5
+                    i32.or
+                    local.get $2
+                    local.get $0
+                    i32.shr_u
+                    local.tee $2
+                    i32.const 2
+                    i32.shr_u
+                    i32.const 4
+                    i32.and
+                    local.tee $0
+                    i32.or
+                    local.get $2
+                    local.get $0
+                    i32.shr_u
+                    local.tee $2
+                    i32.const 1
+                    i32.shr_u
+                    i32.const 2
+                    i32.and
+                    local.tee $0
+                    i32.or
+                    local.get $2
+                    local.get $0
+                    i32.shr_u
+                    local.tee $2
+                    i32.const 1
+                    i32.shr_u
+                    i32.const 1
+                    i32.and
+                    local.tee $0
+                    i32.or
+                    local.get $2
+                    local.get $0
+                    i32.shr_u
+                    i32.add
+                    local.tee $11
+                    i32.const 1
+                    i32.shl
+                    i32.const 2
+                    i32.shl
+                    i32.const 3676
+                    i32.add
+                    local.tee $4
+                    i32.const 8
+                    i32.add
+                    local.tee $2
+                    i32.load
+                    local.tee $9
+                    i32.const 8
+                    i32.add
+                    local.tee $5
+                    i32.load
+                    local.set $12
+                    local.get $4
+                    local.get $12
+                    i32.eq
+                    if ;; label = @9
+                      i32.const 3636
+                      local.get $8
+                      i32.const 1
+                      local.get $11
+                      i32.shl
+                      i32.const -1
+                      i32.xor
+                      i32.and
+                      local.tee $7
+                      i32.store
+                    else
+                      block ;; label = @10
+                        local.get $12
+                        i32.const 3652
+                        i32.load
+                        i32.lt_u
+                        if ;; label = @11
+                          call $fimport$10
+                        end
+                        local.get $12
+                        i32.const 12
+                        i32.add
+                        local.tee $0
+                        i32.load
+                        local.get $9
+                        i32.eq
+                        if ;; label = @11
+                          block ;; label = @12
+                            local.get $0
+                            local.get $4
+                            i32.store
+                            local.get $2
+                            local.get $12
+                            i32.store
+                            local.get $8
+                            local.set $7
+                          end
+                        else
+                          call $fimport$10
+                        end
+                      end
+                    end
+                    local.get $9
+                    local.get $3
+                    i32.const 3
+                    i32.or
+                    i32.store offset=4
+                    local.get $9
+                    local.get $3
+                    i32.add
+                    local.tee $4
+                    local.get $11
+                    i32.const 3
+                    i32.shl
+                    local.get $3
+                    i32.sub
+                    local.tee $11
+                    i32.const 1
+                    i32.or
+                    i32.store offset=4
+                    local.get $4
+                    local.get $11
+                    i32.add
+                    local.get $11
+                    i32.store
+                    local.get $16
+                    if ;; label = @9
+                      block ;; label = @10
+                        i32.const 3656
+                        i32.load
+                        local.set $9
+                        local.get $16
+                        i32.const 3
+                        i32.shr_u
+                        local.tee $0
+                        i32.const 1
+                        i32.shl
+                        i32.const 2
+                        i32.shl
+                        i32.const 3676
+                        i32.add
+                        local.set $2
+                        local.get $7
+                        i32.const 1
+                        local.get $0
+                        i32.shl
+                        local.tee $0
+                        i32.and
+                        if ;; label = @11
+                          local.get $2
+                          i32.const 8
+                          i32.add
+                          local.tee $3
+                          i32.load
+                          local.tee $0
+                          i32.const 3652
+                          i32.load
+                          i32.lt_u
+                          if ;; label = @12
+                            call $fimport$10
+                          else
+                            block ;; label = @13
+                              local.get $3
+                              local.set $6
+                              local.get $0
+                              local.set $1
+                            end
+                          end
+                        else
+                          block ;; label = @12
+                            i32.const 3636
+                            local.get $7
+                            local.get $0
+                            i32.or
+                            i32.store
+                            local.get $2
+                            i32.const 8
+                            i32.add
+                            local.set $6
+                            local.get $2
+                            local.set $1
+                          end
+                        end
+                        local.get $6
+                        local.get $9
+                        i32.store
+                        local.get $1
+                        local.get $9
+                        i32.store offset=12
+                        local.get $9
+                        local.get $1
+                        i32.store offset=8
+                        local.get $9
+                        local.get $2
+                        i32.store offset=12
+                      end
+                    end
+                    i32.const 3644
+                    local.get $11
+                    i32.store
+                    i32.const 3656
+                    local.get $4
+                    i32.store
+                    local.get $14
+                    global.set $global$1
+                    local.get $5
+                    return
+                  end
+                end
+                i32.const 3640
+                i32.load
+                local.tee $6
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $6
+                    i32.const 0
+                    local.get $6
+                    i32.sub
+                    i32.and
+                    i32.const -1
+                    i32.add
+                    local.tee $0
+                    i32.const 12
+                    i32.shr_u
+                    i32.const 16
+                    i32.and
+                    local.set $2
+                    local.get $0
+                    local.get $2
+                    i32.shr_u
+                    local.tee $1
+                    i32.const 5
+                    i32.shr_u
+                    i32.const 8
+                    i32.and
+                    local.tee $0
+                    local.get $2
+                    i32.or
+                    local.get $1
+                    local.get $0
+                    i32.shr_u
+                    local.tee $1
+                    i32.const 2
+                    i32.shr_u
+                    i32.const 4
+                    i32.and
+                    local.tee $0
+                    i32.or
+                    local.get $1
+                    local.get $0
+                    i32.shr_u
+                    local.tee $1
+                    i32.const 1
+                    i32.shr_u
+                    i32.const 2
+                    i32.and
+                    local.tee $0
+                    i32.or
+                    local.get $1
+                    local.get $0
+                    i32.shr_u
+                    local.tee $1
+                    i32.const 1
+                    i32.shr_u
+                    i32.const 1
+                    i32.and
+                    local.tee $0
+                    i32.or
+                    local.get $1
+                    local.get $0
+                    i32.shr_u
+                    i32.add
+                    i32.const 2
+                    i32.shl
+                    i32.const 3940
+                    i32.add
+                    i32.load
+                    local.tee $2
+                    i32.load offset=4
+                    i32.const -8
+                    i32.and
+                    local.get $3
+                    i32.sub
+                    local.set $9
+                    local.get $2
+                    local.set $1
+                    loop $label$25 ;; label = @9
+                      block $label$26 ;; label = @10
+                        local.get $1
+                        i32.load offset=16
+                        local.tee $0
+                        i32.eqz
+                        if ;; label = @11
+                          local.get $1
+                          i32.load offset=20
+                          local.tee $0
+                          i32.eqz
+                          br_if 1 (;@10;)
+                        end
+                        local.get $0
+                        i32.load offset=4
+                        i32.const -8
+                        i32.and
+                        local.get $3
+                        i32.sub
+                        local.tee $1
+                        local.get $9
+                        i32.lt_u
+                        local.tee $7
+                        if ;; label = @11
+                          local.get $1
+                          local.set $9
+                        end
+                        local.get $0
+                        local.set $1
+                        local.get $7
+                        if ;; label = @11
+                          local.get $0
+                          local.set $2
+                        end
+                        br 1 (;@9;)
+                      end
+                    end
+                    local.get $2
+                    i32.const 3652
+                    i32.load
+                    local.tee $12
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                    local.get $2
+                    local.get $2
+                    local.get $3
+                    i32.add
+                    local.tee $13
+                    i32.ge_u
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                    local.get $2
+                    i32.load offset=24
+                    local.set $15
+                    block $label$32 ;; label = @9
+                      local.get $2
+                      i32.load offset=12
+                      local.tee $0
+                      local.get $2
+                      i32.eq
+                      if ;; label = @10
+                        block ;; label = @11
+                          local.get $2
+                          i32.const 20
+                          i32.add
+                          local.tee $1
+                          i32.load
+                          local.tee $0
+                          i32.eqz
+                          if ;; label = @12
+                            local.get $2
+                            i32.const 16
+                            i32.add
+                            local.tee $1
+                            i32.load
+                            local.tee $0
+                            i32.eqz
+                            if ;; label = @13
+                              block ;; label = @14
+                                i32.const 0
+                                local.set $4
+                                br 5 (;@9;)
+                              end
+                            end
+                          end
+                          loop $label$36 ;; label = @12
+                            local.get $0
+                            i32.const 20
+                            i32.add
+                            local.tee $11
+                            i32.load
+                            local.tee $7
+                            if ;; label = @13
+                              block ;; label = @14
+                                local.get $7
+                                local.set $0
+                                local.get $11
+                                local.set $1
+                                br 2 (;@12;)
+                              end
+                            end
+                            local.get $0
+                            i32.const 16
+                            i32.add
+                            local.tee $11
+                            i32.load
+                            local.tee $7
+                            if ;; label = @13
+                              block ;; label = @14
+                                local.get $7
+                                local.set $0
+                                local.get $11
+                                local.set $1
+                                br 2 (;@12;)
+                              end
+                            end
+                          end
+                          local.get $1
+                          local.get $12
+                          i32.lt_u
+                          if ;; label = @12
+                            call $fimport$10
+                          else
+                            block ;; label = @13
+                              local.get $1
+                              i32.const 0
+                              i32.store
+                              local.get $0
+                              local.set $4
+                            end
+                          end
+                        end
+                      else
+                        block ;; label = @11
+                          local.get $2
+                          i32.load offset=8
+                          local.tee $11
+                          local.get $12
+                          i32.lt_u
+                          if ;; label = @12
+                            call $fimport$10
+                          end
+                          local.get $11
+                          i32.const 12
+                          i32.add
+                          local.tee $7
+                          i32.load
+                          local.get $2
+                          i32.ne
+                          if ;; label = @12
+                            call $fimport$10
+                          end
+                          local.get $0
+                          i32.const 8
+                          i32.add
+                          local.tee $1
+                          i32.load
+                          local.get $2
+                          i32.eq
+                          if ;; label = @12
+                            block ;; label = @13
+                              local.get $7
+                              local.get $0
+                              i32.store
+                              local.get $1
+                              local.get $11
+                              i32.store
+                              local.get $0
+                              local.set $4
+                            end
+                          else
+                            call $fimport$10
+                          end
+                        end
+                      end
+                    end
+                    block $label$46 ;; label = @9
+                      local.get $15
+                      if ;; label = @10
+                        block ;; label = @11
+                          local.get $2
+                          local.get $2
+                          i32.load offset=28
+                          local.tee $1
+                          i32.const 2
+                          i32.shl
+                          i32.const 3940
+                          i32.add
+                          local.tee $0
+                          i32.load
+                          i32.eq
+                          if ;; label = @12
+                            block ;; label = @13
+                              local.get $0
+                              local.get $4
+                              i32.store
+                              local.get $4
+                              i32.eqz
+                              if ;; label = @14
+                                block ;; label = @15
+                                  i32.const 3640
+                                  local.get $6
+                                  i32.const 1
+                                  local.get $1
+                                  i32.shl
+                                  i32.const -1
+                                  i32.xor
+                                  i32.and
+                                  i32.store
+                                  br 6 (;@9;)
+                                end
+                              end
+                            end
+                          else
+                            block ;; label = @13
+                              local.get $15
+                              i32.const 3652
+                              i32.load
+                              i32.lt_u
+                              if ;; label = @14
+                                call $fimport$10
+                              end
+                              local.get $15
+                              i32.const 16
+                              i32.add
+                              local.tee $0
+                              i32.load
+                              local.get $2
+                              i32.eq
+                              if ;; label = @14
+                                local.get $0
+                                local.get $4
+                                i32.store
+                              else
+                                local.get $15
+                                local.get $4
+                                i32.store offset=20
+                              end
+                              local.get $4
+                              i32.eqz
+                              br_if 4 (;@9;)
+                            end
+                          end
+                          local.get $4
+                          i32.const 3652
+                          i32.load
+                          local.tee $0
+                          i32.lt_u
+                          if ;; label = @12
+                            call $fimport$10
+                          end
+                          local.get $4
+                          local.get $15
+                          i32.store offset=24
+                          local.get $2
+                          i32.load offset=16
+                          local.tee $1
+                          if ;; label = @12
+                            local.get $1
+                            local.get $0
+                            i32.lt_u
+                            if ;; label = @13
+                              call $fimport$10
+                            else
+                              block ;; label = @14
+                                local.get $4
+                                local.get $1
+                                i32.store offset=16
+                                local.get $1
+                                local.get $4
+                                i32.store offset=24
+                              end
+                            end
+                          end
+                          local.get $2
+                          i32.load offset=20
+                          local.tee $0
+                          if ;; label = @12
+                            local.get $0
+                            i32.const 3652
+                            i32.load
+                            i32.lt_u
+                            if ;; label = @13
+                              call $fimport$10
+                            else
+                              block ;; label = @14
+                                local.get $4
+                                local.get $0
+                                i32.store offset=20
+                                local.get $0
+                                local.get $4
+                                i32.store offset=24
+                              end
+                            end
+                          end
+                        end
+                      end
+                    end
+                    local.get $9
+                    i32.const 16
+                    i32.lt_u
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $2
+                        local.get $9
+                        local.get $3
+                        i32.add
+                        local.tee $0
+                        i32.const 3
+                        i32.or
+                        i32.store offset=4
+                        local.get $2
+                        local.get $0
+                        i32.add
+                        i32.const 4
+                        i32.add
+                        local.tee $0
+                        local.get $0
+                        i32.load
+                        i32.const 1
+                        i32.or
+                        i32.store
+                      end
+                    else
+                      block ;; label = @10
+                        local.get $2
+                        local.get $3
+                        i32.const 3
+                        i32.or
+                        i32.store offset=4
+                        local.get $13
+                        local.get $9
+                        i32.const 1
+                        i32.or
+                        i32.store offset=4
+                        local.get $13
+                        local.get $9
+                        i32.add
+                        local.get $9
+                        i32.store
+                        local.get $16
+                        if ;; label = @11
+                          block ;; label = @12
+                            i32.const 3656
+                            i32.load
+                            local.set $7
+                            local.get $16
+                            i32.const 3
+                            i32.shr_u
+                            local.tee $0
+                            i32.const 1
+                            i32.shl
+                            i32.const 2
+                            i32.shl
+                            i32.const 3676
+                            i32.add
+                            local.set $3
+                            local.get $8
+                            i32.const 1
+                            local.get $0
+                            i32.shl
+                            local.tee $0
+                            i32.and
+                            if ;; label = @13
+                              local.get $3
+                              i32.const 8
+                              i32.add
+                              local.tee $1
+                              i32.load
+                              local.tee $0
+                              i32.const 3652
+                              i32.load
+                              i32.lt_u
+                              if ;; label = @14
+                                call $fimport$10
+                              else
+                                block ;; label = @15
+                                  local.get $1
+                                  local.set $10
+                                  local.get $0
+                                  local.set $5
+                                end
+                              end
+                            else
+                              block ;; label = @14
+                                i32.const 3636
+                                local.get $8
+                                local.get $0
+                                i32.or
+                                i32.store
+                                local.get $3
+                                i32.const 8
+                                i32.add
+                                local.set $10
+                                local.get $3
+                                local.set $5
+                              end
+                            end
+                            local.get $10
+                            local.get $7
+                            i32.store
+                            local.get $5
+                            local.get $7
+                            i32.store offset=12
+                            local.get $7
+                            local.get $5
+                            i32.store offset=8
+                            local.get $7
+                            local.get $3
+                            i32.store offset=12
+                          end
+                        end
+                        i32.const 3644
+                        local.get $9
+                        i32.store
+                        i32.const 3656
+                        local.get $13
+                        i32.store
+                      end
+                    end
+                    local.get $14
+                    global.set $global$1
+                    local.get $2
+                    i32.const 8
+                    i32.add
+                    return
+                  end
+                else
+                  local.get $3
+                  local.set $0
+                end
+              end
+            else
+              local.get $3
+              local.set $0
+            end
+          end
+        else
+          local.get $0
+          i32.const -65
+          i32.gt_u
+          if ;; label = @4
+            i32.const -1
+            local.set $0
+          else
+            block ;; label = @5
+              local.get $0
+              i32.const 11
+              i32.add
+              local.tee $0
+              i32.const -8
+              i32.and
+              local.set $7
+              i32.const 3640
+              i32.load
+              local.tee $5
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $0
+                  i32.const 8
+                  i32.shr_u
+                  local.tee $0
+                  if (result i32) ;; label = @8
+                    local.get $7
+                    i32.const 16777215
+                    i32.gt_u
+                    if (result i32) ;; label = @9
+                      i32.const 31
+                    else
+                      local.get $7
+                      i32.const 14
+                      local.get $0
+                      local.get $0
+                      i32.const 1048320
+                      i32.add
+                      i32.const 16
+                      i32.shr_u
+                      i32.const 8
+                      i32.and
+                      local.tee $3
+                      i32.shl
+                      local.tee $1
+                      i32.const 520192
+                      i32.add
+                      i32.const 16
+                      i32.shr_u
+                      i32.const 4
+                      i32.and
+                      local.tee $0
+                      local.get $3
+                      i32.or
+                      local.get $1
+                      local.get $0
+                      i32.shl
+                      local.tee $1
+                      i32.const 245760
+                      i32.add
+                      i32.const 16
+                      i32.shr_u
+                      i32.const 2
+                      i32.and
+                      local.tee $0
+                      i32.or
+                      i32.sub
+                      local.get $1
+                      local.get $0
+                      i32.shl
+                      i32.const 15
+                      i32.shr_u
+                      i32.add
+                      local.tee $0
+                      i32.const 7
+                      i32.add
+                      i32.shr_u
+                      i32.const 1
+                      i32.and
+                      local.get $0
+                      i32.const 1
+                      i32.shl
+                      i32.or
+                    end
+                  else
+                    i32.const 0
+                  end
+                  local.set $17
+                  i32.const 0
+                  local.get $7
+                  i32.sub
+                  local.set $3
+                  block $label$78 ;; label = @8
+                    block $label$79 ;; label = @9
+                      block $label$80 ;; label = @10
+                        local.get $17
+                        i32.const 2
+                        i32.shl
+                        i32.const 3940
+                        i32.add
+                        i32.load
+                        local.tee $1
+                        if ;; label = @11
+                          block ;; label = @12
+                            i32.const 25
+                            local.get $17
+                            i32.const 1
+                            i32.shr_u
+                            i32.sub
+                            local.set $0
+                            i32.const 0
+                            local.set $4
+                            local.get $7
+                            local.get $17
+                            i32.const 31
+                            i32.eq
+                            if (result i32) ;; label = @13
+                              i32.const 0
+                            else
+                              local.get $0
+                            end
+                            i32.shl
+                            local.set $10
+                            i32.const 0
+                            local.set $0
+                            loop $label$84 ;; label = @13
+                              local.get $1
+                              i32.load offset=4
+                              i32.const -8
+                              i32.and
+                              local.get $7
+                              i32.sub
+                              local.tee $6
+                              local.get $3
+                              i32.lt_u
+                              if ;; label = @14
+                                local.get $6
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $6
+                                    local.set $3
+                                    local.get $1
+                                    local.set $0
+                                  end
+                                else
+                                  block ;; label = @16
+                                    i32.const 0
+                                    local.set $3
+                                    local.get $1
+                                    local.set $0
+                                    br 7 (;@9;)
+                                  end
+                                end
+                              end
+                              local.get $1
+                              i32.load offset=20
+                              local.tee $19
+                              i32.eqz
+                              local.get $19
+                              local.get $1
+                              i32.const 16
+                              i32.add
+                              local.get $10
+                              i32.const 31
+                              i32.shr_u
+                              i32.const 2
+                              i32.shl
+                              i32.add
+                              i32.load
+                              local.tee $6
+                              i32.eq
+                              i32.or
+                              if (result i32) ;; label = @14
+                                local.get $4
+                              else
+                                local.get $19
+                              end
+                              local.set $1
+                              local.get $10
+                              local.get $6
+                              i32.eqz
+                              local.tee $4
+                              i32.const 1
+                              i32.and
+                              i32.const 1
+                              i32.xor
+                              i32.shl
+                              local.set $10
+                              local.get $4
+                              if ;; label = @14
+                                block ;; label = @15
+                                  local.get $1
+                                  local.set $4
+                                  local.get $0
+                                  local.set $1
+                                  br 5 (;@10;)
+                                end
+                              else
+                                block ;; label = @15
+                                  local.get $1
+                                  local.set $4
+                                  local.get $6
+                                  local.set $1
+                                  br 2 (;@13;)
+                                end
+                              end
+                            end
+                          end
+                        else
+                          block ;; label = @12
+                            i32.const 0
+                            local.set $4
+                            i32.const 0
+                            local.set $1
+                          end
+                        end
+                      end
+                      local.get $4
+                      i32.eqz
+                      local.get $1
+                      i32.eqz
+                      i32.and
+                      if (result i32) ;; label = @10
+                        block (result i32) ;; label = @11
+                          local.get $5
+                          i32.const 2
+                          local.get $17
+                          i32.shl
+                          local.tee $0
+                          i32.const 0
+                          local.get $0
+                          i32.sub
+                          i32.or
+                          i32.and
+                          local.tee $0
+                          i32.eqz
+                          if ;; label = @12
+                            block ;; label = @13
+                              local.get $7
+                              local.set $0
+                              br 11 (;@2;)
+                            end
+                          end
+                          local.get $0
+                          i32.const 0
+                          local.get $0
+                          i32.sub
+                          i32.and
+                          i32.const -1
+                          i32.add
+                          local.tee $0
+                          i32.const 12
+                          i32.shr_u
+                          i32.const 16
+                          i32.and
+                          local.set $10
+                          local.get $0
+                          local.get $10
+                          i32.shr_u
+                          local.tee $4
+                          i32.const 5
+                          i32.shr_u
+                          i32.const 8
+                          i32.and
+                          local.tee $0
+                          local.get $10
+                          i32.or
+                          local.get $4
+                          local.get $0
+                          i32.shr_u
+                          local.tee $4
+                          i32.const 2
+                          i32.shr_u
+                          i32.const 4
+                          i32.and
+                          local.tee $0
+                          i32.or
+                          local.get $4
+                          local.get $0
+                          i32.shr_u
+                          local.tee $4
+                          i32.const 1
+                          i32.shr_u
+                          i32.const 2
+                          i32.and
+                          local.tee $0
+                          i32.or
+                          local.get $4
+                          local.get $0
+                          i32.shr_u
+                          local.tee $4
+                          i32.const 1
+                          i32.shr_u
+                          i32.const 1
+                          i32.and
+                          local.tee $0
+                          i32.or
+                          local.get $4
+                          local.get $0
+                          i32.shr_u
+                          i32.add
+                          i32.const 2
+                          i32.shl
+                          i32.const 3940
+                          i32.add
+                          i32.load
+                        end
+                      else
+                        local.get $4
+                      end
+                      local.tee $0
+                      br_if 0 (;@9;)
+                      local.get $1
+                      local.set $4
+                      br 1 (;@8;)
+                    end
+                    loop $label$96 ;; label = @9
+                      local.get $0
+                      i32.load offset=4
+                      i32.const -8
+                      i32.and
+                      local.get $7
+                      i32.sub
+                      local.tee $4
+                      local.get $3
+                      i32.lt_u
+                      local.tee $10
+                      if ;; label = @10
+                        local.get $4
+                        local.set $3
+                      end
+                      local.get $10
+                      if ;; label = @10
+                        local.get $0
+                        local.set $1
+                      end
+                      local.get $0
+                      i32.load offset=16
+                      local.tee $4
+                      if ;; label = @10
+                        block ;; label = @11
+                          local.get $4
+                          local.set $0
+                          br 2 (;@9;)
+                        end
+                      end
+                      local.get $0
+                      i32.load offset=20
+                      local.tee $0
+                      br_if 0 (;@9;)
+                      local.get $1
+                      local.set $4
+                    end
+                  end
+                  local.get $4
+                  if ;; label = @8
+                    local.get $3
+                    i32.const 3644
+                    i32.load
+                    local.get $7
+                    i32.sub
+                    i32.lt_u
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $4
+                        i32.const 3652
+                        i32.load
+                        local.tee $12
+                        i32.lt_u
+                        if ;; label = @11
+                          call $fimport$10
+                        end
+                        local.get $4
+                        local.get $4
+                        local.get $7
+                        i32.add
+                        local.tee $6
+                        i32.ge_u
+                        if ;; label = @11
+                          call $fimport$10
+                        end
+                        local.get $4
+                        i32.load offset=24
+                        local.set $10
+                        block $label$104 ;; label = @11
+                          local.get $4
+                          i32.load offset=12
+                          local.tee $0
+                          local.get $4
+                          i32.eq
+                          if ;; label = @12
+                            block ;; label = @13
+                              local.get $4
+                              i32.const 20
+                              i32.add
+                              local.tee $1
+                              i32.load
+                              local.tee $0
+                              i32.eqz
+                              if ;; label = @14
+                                local.get $4
+                                i32.const 16
+                                i32.add
+                                local.tee $1
+                                i32.load
+                                local.tee $0
+                                i32.eqz
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    i32.const 0
+                                    local.set $13
+                                    br 5 (;@11;)
+                                  end
+                                end
+                              end
+                              loop $label$108 ;; label = @14
+                                local.get $0
+                                i32.const 20
+                                i32.add
+                                local.tee $9
+                                i32.load
+                                local.tee $11
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $11
+                                    local.set $0
+                                    local.get $9
+                                    local.set $1
+                                    br 2 (;@14;)
+                                  end
+                                end
+                                local.get $0
+                                i32.const 16
+                                i32.add
+                                local.tee $9
+                                i32.load
+                                local.tee $11
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $11
+                                    local.set $0
+                                    local.get $9
+                                    local.set $1
+                                    br 2 (;@14;)
+                                  end
+                                end
+                              end
+                              local.get $1
+                              local.get $12
+                              i32.lt_u
+                              if ;; label = @14
+                                call $fimport$10
+                              else
+                                block ;; label = @15
+                                  local.get $1
+                                  i32.const 0
+                                  i32.store
+                                  local.get $0
+                                  local.set $13
+                                end
+                              end
+                            end
+                          else
+                            block ;; label = @13
+                              local.get $4
+                              i32.load offset=8
+                              local.tee $9
+                              local.get $12
+                              i32.lt_u
+                              if ;; label = @14
+                                call $fimport$10
+                              end
+                              local.get $9
+                              i32.const 12
+                              i32.add
+                              local.tee $11
+                              i32.load
+                              local.get $4
+                              i32.ne
+                              if ;; label = @14
+                                call $fimport$10
+                              end
+                              local.get $0
+                              i32.const 8
+                              i32.add
+                              local.tee $1
+                              i32.load
+                              local.get $4
+                              i32.eq
+                              if ;; label = @14
+                                block ;; label = @15
+                                  local.get $11
+                                  local.get $0
+                                  i32.store
+                                  local.get $1
+                                  local.get $9
+                                  i32.store
+                                  local.get $0
+                                  local.set $13
+                                end
+                              else
+                                call $fimport$10
+                              end
+                            end
+                          end
+                        end
+                        block $label$118 ;; label = @11
+                          local.get $10
+                          if ;; label = @12
+                            block ;; label = @13
+                              local.get $4
+                              local.get $4
+                              i32.load offset=28
+                              local.tee $1
+                              i32.const 2
+                              i32.shl
+                              i32.const 3940
+                              i32.add
+                              local.tee $0
+                              i32.load
+                              i32.eq
+                              if ;; label = @14
+                                block ;; label = @15
+                                  local.get $0
+                                  local.get $13
+                                  i32.store
+                                  local.get $13
+                                  i32.eqz
+                                  if ;; label = @16
+                                    block ;; label = @17
+                                      i32.const 3640
+                                      local.get $5
+                                      i32.const 1
+                                      local.get $1
+                                      i32.shl
+                                      i32.const -1
+                                      i32.xor
+                                      i32.and
+                                      local.tee $2
+                                      i32.store
+                                      br 6 (;@11;)
+                                    end
+                                  end
+                                end
+                              else
+                                block ;; label = @15
+                                  local.get $10
+                                  i32.const 3652
+                                  i32.load
+                                  i32.lt_u
+                                  if ;; label = @16
+                                    call $fimport$10
+                                  end
+                                  local.get $10
+                                  i32.const 16
+                                  i32.add
+                                  local.tee $0
+                                  i32.load
+                                  local.get $4
+                                  i32.eq
+                                  if ;; label = @16
+                                    local.get $0
+                                    local.get $13
+                                    i32.store
+                                  else
+                                    local.get $10
+                                    local.get $13
+                                    i32.store offset=20
+                                  end
+                                  local.get $13
+                                  i32.eqz
+                                  if ;; label = @16
+                                    block ;; label = @17
+                                      local.get $5
+                                      local.set $2
+                                      br 6 (;@11;)
+                                    end
+                                  end
+                                end
+                              end
+                              local.get $13
+                              i32.const 3652
+                              i32.load
+                              local.tee $0
+                              i32.lt_u
+                              if ;; label = @14
+                                call $fimport$10
+                              end
+                              local.get $13
+                              local.get $10
+                              i32.store offset=24
+                              local.get $4
+                              i32.load offset=16
+                              local.tee $1
+                              if ;; label = @14
+                                local.get $1
+                                local.get $0
+                                i32.lt_u
+                                if ;; label = @15
+                                  call $fimport$10
+                                else
+                                  block ;; label = @16
+                                    local.get $13
+                                    local.get $1
+                                    i32.store offset=16
+                                    local.get $1
+                                    local.get $13
+                                    i32.store offset=24
+                                  end
+                                end
+                              end
+                              local.get $4
+                              i32.load offset=20
+                              local.tee $0
+                              if ;; label = @14
+                                local.get $0
+                                i32.const 3652
+                                i32.load
+                                i32.lt_u
+                                if ;; label = @15
+                                  call $fimport$10
+                                else
+                                  block ;; label = @16
+                                    local.get $13
+                                    local.get $0
+                                    i32.store offset=20
+                                    local.get $0
+                                    local.get $13
+                                    i32.store offset=24
+                                    local.get $5
+                                    local.set $2
+                                  end
+                                end
+                              else
+                                local.get $5
+                                local.set $2
+                              end
+                            end
+                          else
+                            local.get $5
+                            local.set $2
+                          end
+                        end
+                        block $label$136 ;; label = @11
+                          local.get $3
+                          i32.const 16
+                          i32.lt_u
+                          if ;; label = @12
+                            block ;; label = @13
+                              local.get $4
+                              local.get $3
+                              local.get $7
+                              i32.add
+                              local.tee $0
+                              i32.const 3
+                              i32.or
+                              i32.store offset=4
+                              local.get $4
+                              local.get $0
+                              i32.add
+                              i32.const 4
+                              i32.add
+                              local.tee $0
+                              local.get $0
+                              i32.load
+                              i32.const 1
+                              i32.or
+                              i32.store
+                            end
+                          else
+                            block ;; label = @13
+                              local.get $4
+                              local.get $7
+                              i32.const 3
+                              i32.or
+                              i32.store offset=4
+                              local.get $6
+                              local.get $3
+                              i32.const 1
+                              i32.or
+                              i32.store offset=4
+                              local.get $6
+                              local.get $3
+                              i32.add
+                              local.get $3
+                              i32.store
+                              local.get $3
+                              i32.const 3
+                              i32.shr_u
+                              local.set $0
+                              local.get $3
+                              i32.const 256
+                              i32.lt_u
+                              if ;; label = @14
+                                block ;; label = @15
+                                  local.get $0
+                                  i32.const 1
+                                  i32.shl
+                                  i32.const 2
+                                  i32.shl
+                                  i32.const 3676
+                                  i32.add
+                                  local.set $3
+                                  i32.const 3636
+                                  i32.load
+                                  local.tee $1
+                                  i32.const 1
+                                  local.get $0
+                                  i32.shl
+                                  local.tee $0
+                                  i32.and
+                                  if ;; label = @16
+                                    local.get $3
+                                    i32.const 8
+                                    i32.add
+                                    local.tee $1
+                                    i32.load
+                                    local.tee $0
+                                    i32.const 3652
+                                    i32.load
+                                    i32.lt_u
+                                    if ;; label = @17
+                                      call $fimport$10
+                                    else
+                                      block ;; label = @18
+                                        local.get $1
+                                        local.set $16
+                                        local.get $0
+                                        local.set $8
+                                      end
+                                    end
+                                  else
+                                    block ;; label = @17
+                                      i32.const 3636
+                                      local.get $1
+                                      local.get $0
+                                      i32.or
+                                      i32.store
+                                      local.get $3
+                                      i32.const 8
+                                      i32.add
+                                      local.set $16
+                                      local.get $3
+                                      local.set $8
+                                    end
+                                  end
+                                  local.get $16
+                                  local.get $6
+                                  i32.store
+                                  local.get $8
+                                  local.get $6
+                                  i32.store offset=12
+                                  local.get $6
+                                  local.get $8
+                                  i32.store offset=8
+                                  local.get $6
+                                  local.get $3
+                                  i32.store offset=12
+                                  br 4 (;@11;)
+                                end
+                              end
+                              local.get $3
+                              i32.const 8
+                              i32.shr_u
+                              local.tee $0
+                              if (result i32) ;; label = @14
+                                local.get $3
+                                i32.const 16777215
+                                i32.gt_u
+                                if (result i32) ;; label = @15
+                                  i32.const 31
+                                else
+                                  local.get $3
+                                  i32.const 14
+                                  local.get $0
+                                  local.get $0
+                                  i32.const 1048320
+                                  i32.add
+                                  i32.const 16
+                                  i32.shr_u
+                                  i32.const 8
+                                  i32.and
+                                  local.tee $5
+                                  i32.shl
+                                  local.tee $1
+                                  i32.const 520192
+                                  i32.add
+                                  i32.const 16
+                                  i32.shr_u
+                                  i32.const 4
+                                  i32.and
+                                  local.tee $0
+                                  local.get $5
+                                  i32.or
+                                  local.get $1
+                                  local.get $0
+                                  i32.shl
+                                  local.tee $1
+                                  i32.const 245760
+                                  i32.add
+                                  i32.const 16
+                                  i32.shr_u
+                                  i32.const 2
+                                  i32.and
+                                  local.tee $0
+                                  i32.or
+                                  i32.sub
+                                  local.get $1
+                                  local.get $0
+                                  i32.shl
+                                  i32.const 15
+                                  i32.shr_u
+                                  i32.add
+                                  local.tee $0
+                                  i32.const 7
+                                  i32.add
+                                  i32.shr_u
+                                  i32.const 1
+                                  i32.and
+                                  local.get $0
+                                  i32.const 1
+                                  i32.shl
+                                  i32.or
+                                end
+                              else
+                                i32.const 0
+                              end
+                              local.tee $5
+                              i32.const 2
+                              i32.shl
+                              i32.const 3940
+                              i32.add
+                              local.set $1
+                              local.get $6
+                              local.get $5
+                              i32.store offset=28
+                              local.get $6
+                              i32.const 16
+                              i32.add
+                              local.tee $0
+                              i32.const 0
+                              i32.store offset=4
+                              local.get $0
+                              i32.const 0
+                              i32.store
+                              local.get $2
+                              i32.const 1
+                              local.get $5
+                              i32.shl
+                              local.tee $0
+                              i32.and
+                              i32.eqz
+                              if ;; label = @14
+                                block ;; label = @15
+                                  i32.const 3640
+                                  local.get $2
+                                  local.get $0
+                                  i32.or
+                                  i32.store
+                                  local.get $1
+                                  local.get $6
+                                  i32.store
+                                  local.get $6
+                                  local.get $1
+                                  i32.store offset=24
+                                  local.get $6
+                                  local.get $6
+                                  i32.store offset=12
+                                  local.get $6
+                                  local.get $6
+                                  i32.store offset=8
+                                  br 4 (;@11;)
+                                end
+                              end
+                              local.get $1
+                              i32.load
+                              local.set $0
+                              i32.const 25
+                              local.get $5
+                              i32.const 1
+                              i32.shr_u
+                              i32.sub
+                              local.set $1
+                              local.get $3
+                              local.get $5
+                              i32.const 31
+                              i32.eq
+                              if (result i32) ;; label = @14
+                                i32.const 0
+                              else
+                                local.get $1
+                              end
+                              i32.shl
+                              local.set $5
+                              block $label$151 ;; label = @14
+                                block $label$152 ;; label = @15
+                                  block $label$153 ;; label = @16
+                                    loop $label$154 ;; label = @17
+                                      local.get $0
+                                      i32.load offset=4
+                                      i32.const -8
+                                      i32.and
+                                      local.get $3
+                                      i32.eq
+                                      br_if 2 (;@15;)
+                                      local.get $5
+                                      i32.const 1
+                                      i32.shl
+                                      local.set $2
+                                      local.get $0
+                                      i32.const 16
+                                      i32.add
+                                      local.get $5
+                                      i32.const 31
+                                      i32.shr_u
+                                      i32.const 2
+                                      i32.shl
+                                      i32.add
+                                      local.tee $5
+                                      i32.load
+                                      local.tee $1
+                                      i32.eqz
+                                      br_if 1 (;@16;)
+                                      local.get $2
+                                      local.set $5
+                                      local.get $1
+                                      local.set $0
+                                      br 0 (;@17;)
+                                    end
+                                  end
+                                  local.get $5
+                                  i32.const 3652
+                                  i32.load
+                                  i32.lt_u
+                                  if ;; label = @16
+                                    call $fimport$10
+                                  else
+                                    block ;; label = @17
+                                      local.get $5
+                                      local.get $6
+                                      i32.store
+                                      local.get $6
+                                      local.get $0
+                                      i32.store offset=24
+                                      local.get $6
+                                      local.get $6
+                                      i32.store offset=12
+                                      local.get $6
+                                      local.get $6
+                                      i32.store offset=8
+                                      br 6 (;@11;)
+                                    end
+                                  end
+                                  br 1 (;@14;)
+                                end
+                                local.get $0
+                                i32.const 8
+                                i32.add
+                                local.tee $3
+                                i32.load
+                                local.tee $2
+                                i32.const 3652
+                                i32.load
+                                local.tee $1
+                                i32.ge_u
+                                local.get $0
+                                local.get $1
+                                i32.ge_u
+                                i32.and
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $2
+                                    local.get $6
+                                    i32.store offset=12
+                                    local.get $3
+                                    local.get $6
+                                    i32.store
+                                    local.get $6
+                                    local.get $2
+                                    i32.store offset=8
+                                    local.get $6
+                                    local.get $0
+                                    i32.store offset=12
+                                    local.get $6
+                                    i32.const 0
+                                    i32.store offset=24
+                                  end
+                                else
+                                  call $fimport$10
+                                end
+                              end
+                            end
+                          end
+                        end
+                        local.get $14
+                        global.set $global$1
+                        local.get $4
+                        i32.const 8
+                        i32.add
+                        return
+                      end
+                    else
+                      local.get $7
+                      local.set $0
+                    end
+                  else
+                    local.get $7
+                    local.set $0
+                  end
+                end
+              else
+                local.get $7
+                local.set $0
+              end
+            end
+          end
+        end
+      end
+      i32.const 3644
+      i32.load
+      local.tee $1
+      local.get $0
+      i32.ge_u
+      if ;; label = @2
+        block ;; label = @3
+          i32.const 3656
+          i32.load
+          local.set $2
+          local.get $1
+          local.get $0
+          i32.sub
+          local.tee $3
+          i32.const 15
+          i32.gt_u
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 3656
+              local.get $2
+              local.get $0
+              i32.add
+              local.tee $1
+              i32.store
+              i32.const 3644
+              local.get $3
+              i32.store
+              local.get $1
+              local.get $3
+              i32.const 1
+              i32.or
+              i32.store offset=4
+              local.get $1
+              local.get $3
+              i32.add
+              local.get $3
+              i32.store
+              local.get $2
+              local.get $0
+              i32.const 3
+              i32.or
+              i32.store offset=4
+            end
+          else
+            block ;; label = @5
+              i32.const 3644
+              i32.const 0
+              i32.store
+              i32.const 3656
+              i32.const 0
+              i32.store
+              local.get $2
+              local.get $1
+              i32.const 3
+              i32.or
+              i32.store offset=4
+              local.get $2
+              local.get $1
+              i32.add
+              i32.const 4
+              i32.add
+              local.tee $0
+              local.get $0
+              i32.load
+              i32.const 1
+              i32.or
+              i32.store
+            end
+          end
+          local.get $14
+          global.set $global$1
+          local.get $2
+          i32.const 8
+          i32.add
+          return
+        end
+      end
+      i32.const 3648
+      i32.load
+      local.tee $10
+      local.get $0
+      i32.gt_u
+      if ;; label = @2
+        block ;; label = @3
+          i32.const 3648
+          local.get $10
+          local.get $0
+          i32.sub
+          local.tee $3
+          i32.store
+          i32.const 3660
+          i32.const 3660
+          i32.load
+          local.tee $2
+          local.get $0
+          i32.add
+          local.tee $1
+          i32.store
+          local.get $1
+          local.get $3
+          i32.const 1
+          i32.or
+          i32.store offset=4
+          local.get $2
+          local.get $0
+          i32.const 3
+          i32.or
+          i32.store offset=4
+          local.get $14
+          global.set $global$1
+          local.get $2
+          i32.const 8
+          i32.add
+          return
+        end
+      end
+      i32.const 4108
+      i32.load
+      if (result i32) ;; label = @2
+        i32.const 4116
+        i32.load
+      else
+        block (result i32) ;; label = @3
+          i32.const 4116
+          i32.const 4096
+          i32.store
+          i32.const 4112
+          i32.const 4096
+          i32.store
+          i32.const 4120
+          i32.const -1
+          i32.store
+          i32.const 4124
+          i32.const -1
+          i32.store
+          i32.const 4128
+          i32.const 0
+          i32.store
+          i32.const 4080
+          i32.const 0
+          i32.store
+          local.get $18
+          local.get $18
+          i32.const -16
+          i32.and
+          i32.const 1431655768
+          i32.xor
+          local.tee $1
+          i32.store
+          i32.const 4108
+          local.get $1
+          i32.store
+          i32.const 4096
+        end
+      end
+      local.tee $1
+      local.get $0
+      i32.const 47
+      i32.add
+      local.tee $13
+      i32.add
+      local.tee $8
+      i32.const 0
+      local.get $1
+      i32.sub
+      local.tee $4
+      i32.and
+      local.tee $6
+      local.get $0
+      i32.le_u
+      if ;; label = @2
+        block ;; label = @3
+          local.get $14
+          global.set $global$1
+          i32.const 0
+          return
+        end
+      end
+      i32.const 4076
+      i32.load
+      local.tee $2
+      if ;; label = @2
+        i32.const 4068
+        i32.load
+        local.tee $3
+        local.get $6
+        i32.add
+        local.tee $1
+        local.get $3
+        i32.le_u
+        local.get $1
+        local.get $2
+        i32.gt_u
+        i32.or
+        if ;; label = @3
+          block ;; label = @4
+            local.get $14
+            global.set $global$1
+            i32.const 0
+            return
+          end
+        end
+      end
+      local.get $0
+      i32.const 48
+      i32.add
+      local.set $7
+      block $label$171 ;; label = @2
+        block $label$172 ;; label = @3
+          i32.const 4080
+          i32.load
+          i32.const 4
+          i32.and
+          i32.eqz
+          if ;; label = @4
+            block ;; label = @5
+              block $label$174 ;; label = @6
+                block $label$175 ;; label = @7
+                  block $label$176 ;; label = @8
+                    i32.const 3660
+                    i32.load
+                    local.tee $3
+                    i32.eqz
+                    br_if 0 (;@8;)
+                    i32.const 4084
+                    local.set $2
+                    loop $label$177 ;; label = @9
+                      block $label$178 ;; label = @10
+                        local.get $2
+                        i32.load
+                        local.tee $1
+                        local.get $3
+                        i32.le_u
+                        if ;; label = @11
+                          local.get $1
+                          local.get $2
+                          i32.const 4
+                          i32.add
+                          local.tee $5
+                          i32.load
+                          i32.add
+                          local.get $3
+                          i32.gt_u
+                          br_if 1 (;@10;)
+                        end
+                        local.get $2
+                        i32.load offset=8
+                        local.tee $1
+                        i32.eqz
+                        br_if 2 (;@8;)
+                        local.get $1
+                        local.set $2
+                        br 1 (;@9;)
+                      end
+                    end
+                    local.get $8
+                    local.get $10
+                    i32.sub
+                    local.get $4
+                    i32.and
+                    local.tee $3
+                    i32.const 2147483647
+                    i32.lt_u
+                    if ;; label = @9
+                      local.get $3
+                      call $40
+                      local.tee $1
+                      local.get $2
+                      i32.load
+                      local.get $5
+                      i32.load
+                      i32.add
+                      i32.eq
+                      if ;; label = @10
+                        local.get $1
+                        i32.const -1
+                        i32.ne
+                        br_if 7 (;@3;)
+                      else
+                        block ;; label = @11
+                          local.get $1
+                          local.set $2
+                          local.get $3
+                          local.set $1
+                          br 4 (;@7;)
+                        end
+                      end
+                    end
+                    br 2 (;@6;)
+                  end
+                  i32.const 0
+                  call $40
+                  local.tee $1
+                  i32.const -1
+                  i32.ne
+                  if ;; label = @8
+                    block ;; label = @9
+                      i32.const 4112
+                      i32.load
+                      local.tee $2
+                      i32.const -1
+                      i32.add
+                      local.tee $5
+                      local.get $1
+                      local.tee $3
+                      i32.add
+                      i32.const 0
+                      local.get $2
+                      i32.sub
+                      i32.and
+                      local.get $3
+                      i32.sub
+                      local.set $2
+                      local.get $5
+                      local.get $3
+                      i32.and
+                      if (result i32) ;; label = @10
+                        local.get $2
+                      else
+                        i32.const 0
+                      end
+                      local.get $6
+                      i32.add
+                      local.tee $3
+                      i32.const 4068
+                      i32.load
+                      local.tee $5
+                      i32.add
+                      local.set $4
+                      local.get $3
+                      local.get $0
+                      i32.gt_u
+                      local.get $3
+                      i32.const 2147483647
+                      i32.lt_u
+                      i32.and
+                      if ;; label = @10
+                        block ;; label = @11
+                          i32.const 4076
+                          i32.load
+                          local.tee $2
+                          if ;; label = @12
+                            local.get $4
+                            local.get $5
+                            i32.le_u
+                            local.get $4
+                            local.get $2
+                            i32.gt_u
+                            i32.or
+                            br_if 6 (;@6;)
+                          end
+                          local.get $3
+                          call $40
+                          local.tee $2
+                          local.get $1
+                          i32.eq
+                          br_if 8 (;@3;)
+                          local.get $3
+                          local.set $1
+                          br 4 (;@7;)
+                        end
+                      end
+                    end
+                  end
+                  br 1 (;@6;)
+                end
+                i32.const 0
+                local.get $1
+                i32.sub
+                local.set $5
+                local.get $7
+                local.get $1
+                i32.gt_u
+                local.get $1
+                i32.const 2147483647
+                i32.lt_u
+                local.get $2
+                i32.const -1
+                i32.ne
+                i32.and
+                i32.and
+                if ;; label = @7
+                  local.get $13
+                  local.get $1
+                  i32.sub
+                  i32.const 4116
+                  i32.load
+                  local.tee $3
+                  i32.add
+                  i32.const 0
+                  local.get $3
+                  i32.sub
+                  i32.and
+                  local.tee $3
+                  i32.const 2147483647
+                  i32.lt_u
+                  if ;; label = @8
+                    local.get $3
+                    call $40
+                    i32.const -1
+                    i32.eq
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $5
+                        call $40
+                        drop
+                        br 4 (;@6;)
+                      end
+                    else
+                      local.get $3
+                      local.get $1
+                      i32.add
+                      local.set $3
+                    end
+                  else
+                    local.get $1
+                    local.set $3
+                  end
+                else
+                  local.get $1
+                  local.set $3
+                end
+                local.get $2
+                i32.const -1
+                i32.ne
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $2
+                    local.set $1
+                    br 5 (;@3;)
+                  end
+                end
+              end
+              i32.const 4080
+              i32.const 4080
+              i32.load
+              i32.const 4
+              i32.or
+              i32.store
+            end
+          end
+          local.get $6
+          i32.const 2147483647
+          i32.lt_u
+          if ;; label = @4
+            local.get $6
+            call $40
+            local.tee $1
+            i32.const 0
+            call $40
+            local.tee $3
+            i32.lt_u
+            local.get $1
+            i32.const -1
+            i32.ne
+            local.get $3
+            i32.const -1
+            i32.ne
+            i32.and
+            i32.and
+            if ;; label = @5
+              local.get $3
+              local.get $1
+              i32.sub
+              local.tee $3
+              local.get $0
+              i32.const 40
+              i32.add
+              i32.gt_u
+              br_if 2 (;@3;)
+            end
+          end
+          br 1 (;@2;)
+        end
+        i32.const 4068
+        i32.const 4068
+        i32.load
+        local.get $3
+        i32.add
+        local.tee $2
+        i32.store
+        local.get $2
+        i32.const 4072
+        i32.load
+        i32.gt_u
+        if ;; label = @3
+          i32.const 4072
+          local.get $2
+          i32.store
+        end
+        block $label$198 ;; label = @3
+          i32.const 3660
+          i32.load
+          local.tee $8
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 4084
+              local.set $2
+              block $label$200 ;; label = @6
+                block $label$201 ;; label = @7
+                  loop $label$202 ;; label = @8
+                    local.get $1
+                    local.get $2
+                    i32.load
+                    local.tee $4
+                    local.get $2
+                    i32.const 4
+                    i32.add
+                    local.tee $7
+                    i32.load
+                    local.tee $5
+                    i32.add
+                    i32.eq
+                    br_if 1 (;@7;)
+                    local.get $2
+                    i32.load offset=8
+                    local.tee $2
+                    br_if 0 (;@8;)
+                  end
+                  br 1 (;@6;)
+                end
+                local.get $2
+                i32.load offset=12
+                i32.const 8
+                i32.and
+                i32.eqz
+                if ;; label = @7
+                  local.get $8
+                  local.get $1
+                  i32.lt_u
+                  local.get $8
+                  local.get $4
+                  i32.ge_u
+                  i32.and
+                  if ;; label = @8
+                    block ;; label = @9
+                      local.get $7
+                      local.get $5
+                      local.get $3
+                      i32.add
+                      i32.store
+                      i32.const 3648
+                      i32.load
+                      local.set $5
+                      i32.const 0
+                      local.get $8
+                      i32.const 8
+                      i32.add
+                      local.tee $2
+                      i32.sub
+                      i32.const 7
+                      i32.and
+                      local.set $1
+                      i32.const 3660
+                      local.get $8
+                      local.get $2
+                      i32.const 7
+                      i32.and
+                      if (result i32) ;; label = @10
+                        local.get $1
+                      else
+                        i32.const 0
+                        local.tee $1
+                      end
+                      i32.add
+                      local.tee $2
+                      i32.store
+                      i32.const 3648
+                      local.get $3
+                      local.get $1
+                      i32.sub
+                      local.get $5
+                      i32.add
+                      local.tee $1
+                      i32.store
+                      local.get $2
+                      local.get $1
+                      i32.const 1
+                      i32.or
+                      i32.store offset=4
+                      local.get $2
+                      local.get $1
+                      i32.add
+                      i32.const 40
+                      i32.store offset=4
+                      i32.const 3664
+                      i32.const 4124
+                      i32.load
+                      i32.store
+                      br 6 (;@3;)
+                    end
+                  end
+                end
+              end
+              local.get $1
+              i32.const 3652
+              i32.load
+              local.tee $2
+              i32.lt_u
+              if ;; label = @6
+                block ;; label = @7
+                  i32.const 3652
+                  local.get $1
+                  i32.store
+                  local.get $1
+                  local.set $2
+                end
+              end
+              local.get $1
+              local.get $3
+              i32.add
+              local.set $10
+              i32.const 4084
+              local.set $5
+              block $label$208 ;; label = @6
+                block $label$209 ;; label = @7
+                  loop $label$210 ;; label = @8
+                    local.get $5
+                    i32.load
+                    local.get $10
+                    i32.eq
+                    br_if 1 (;@7;)
+                    local.get $5
+                    i32.load offset=8
+                    local.tee $5
+                    br_if 0 (;@8;)
+                    i32.const 4084
+                    local.set $5
+                  end
+                  br 1 (;@6;)
+                end
+                local.get $5
+                i32.load offset=12
+                i32.const 8
+                i32.and
+                if ;; label = @7
+                  i32.const 4084
+                  local.set $5
+                else
+                  block ;; label = @8
+                    local.get $5
+                    local.get $1
+                    i32.store
+                    local.get $5
+                    i32.const 4
+                    i32.add
+                    local.tee $5
+                    local.get $5
+                    i32.load
+                    local.get $3
+                    i32.add
+                    i32.store
+                    i32.const 0
+                    local.get $1
+                    i32.const 8
+                    i32.add
+                    local.tee $4
+                    i32.sub
+                    i32.const 7
+                    i32.and
+                    local.set $7
+                    i32.const 0
+                    local.get $10
+                    i32.const 8
+                    i32.add
+                    local.tee $5
+                    i32.sub
+                    i32.const 7
+                    i32.and
+                    local.set $3
+                    local.get $1
+                    local.get $4
+                    i32.const 7
+                    i32.and
+                    if (result i32) ;; label = @9
+                      local.get $7
+                    else
+                      i32.const 0
+                    end
+                    i32.add
+                    local.tee $13
+                    local.get $0
+                    i32.add
+                    local.set $6
+                    local.get $10
+                    local.get $5
+                    i32.const 7
+                    i32.and
+                    if (result i32) ;; label = @9
+                      local.get $3
+                    else
+                      i32.const 0
+                    end
+                    i32.add
+                    local.tee $4
+                    local.get $13
+                    i32.sub
+                    local.get $0
+                    i32.sub
+                    local.set $7
+                    local.get $13
+                    local.get $0
+                    i32.const 3
+                    i32.or
+                    i32.store offset=4
+                    block $label$217 ;; label = @9
+                      local.get $4
+                      local.get $8
+                      i32.eq
+                      if ;; label = @10
+                        block ;; label = @11
+                          i32.const 3648
+                          i32.const 3648
+                          i32.load
+                          local.get $7
+                          i32.add
+                          local.tee $0
+                          i32.store
+                          i32.const 3660
+                          local.get $6
+                          i32.store
+                          local.get $6
+                          local.get $0
+                          i32.const 1
+                          i32.or
+                          i32.store offset=4
+                        end
+                      else
+                        block ;; label = @11
+                          local.get $4
+                          i32.const 3656
+                          i32.load
+                          i32.eq
+                          if ;; label = @12
+                            block ;; label = @13
+                              i32.const 3644
+                              i32.const 3644
+                              i32.load
+                              local.get $7
+                              i32.add
+                              local.tee $0
+                              i32.store
+                              i32.const 3656
+                              local.get $6
+                              i32.store
+                              local.get $6
+                              local.get $0
+                              i32.const 1
+                              i32.or
+                              i32.store offset=4
+                              local.get $6
+                              local.get $0
+                              i32.add
+                              local.get $0
+                              i32.store
+                              br 4 (;@9;)
+                            end
+                          end
+                          local.get $4
+                          i32.load offset=4
+                          local.tee $0
+                          i32.const 3
+                          i32.and
+                          i32.const 1
+                          i32.eq
+                          if (result i32) ;; label = @12
+                            block (result i32) ;; label = @13
+                              local.get $0
+                              i32.const -8
+                              i32.and
+                              local.set $11
+                              local.get $0
+                              i32.const 3
+                              i32.shr_u
+                              local.set $1
+                              block $label$222 ;; label = @14
+                                local.get $0
+                                i32.const 256
+                                i32.lt_u
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $4
+                                    i32.load offset=12
+                                    local.set $5
+                                    block $label$224 ;; label = @17
+                                      local.get $4
+                                      i32.load offset=8
+                                      local.tee $3
+                                      local.get $1
+                                      i32.const 1
+                                      i32.shl
+                                      i32.const 2
+                                      i32.shl
+                                      i32.const 3676
+                                      i32.add
+                                      local.tee $0
+                                      i32.ne
+                                      if ;; label = @18
+                                        block ;; label = @19
+                                          local.get $3
+                                          local.get $2
+                                          i32.lt_u
+                                          if ;; label = @20
+                                            call $fimport$10
+                                          end
+                                          local.get $3
+                                          i32.load offset=12
+                                          local.get $4
+                                          i32.eq
+                                          br_if 2 (;@17;)
+                                          call $fimport$10
+                                        end
+                                      end
+                                    end
+                                    local.get $5
+                                    local.get $3
+                                    i32.eq
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        i32.const 3636
+                                        i32.const 3636
+                                        i32.load
+                                        i32.const 1
+                                        local.get $1
+                                        i32.shl
+                                        i32.const -1
+                                        i32.xor
+                                        i32.and
+                                        i32.store
+                                        br 4 (;@14;)
+                                      end
+                                    end
+                                    block $label$228 ;; label = @17
+                                      local.get $5
+                                      local.get $0
+                                      i32.eq
+                                      if ;; label = @18
+                                        local.get $5
+                                        i32.const 8
+                                        i32.add
+                                        local.set $20
+                                      else
+                                        block ;; label = @19
+                                          local.get $5
+                                          local.get $2
+                                          i32.lt_u
+                                          if ;; label = @20
+                                            call $fimport$10
+                                          end
+                                          local.get $5
+                                          i32.const 8
+                                          i32.add
+                                          local.tee $0
+                                          i32.load
+                                          local.get $4
+                                          i32.eq
+                                          if ;; label = @20
+                                            block ;; label = @21
+                                              local.get $0
+                                              local.set $20
+                                              br 4 (;@17;)
+                                            end
+                                          end
+                                          call $fimport$10
+                                        end
+                                      end
+                                    end
+                                    local.get $3
+                                    local.get $5
+                                    i32.store offset=12
+                                    local.get $20
+                                    local.get $3
+                                    i32.store
+                                  end
+                                else
+                                  block ;; label = @16
+                                    local.get $4
+                                    i32.load offset=24
+                                    local.set $8
+                                    block $label$234 ;; label = @17
+                                      local.get $4
+                                      i32.load offset=12
+                                      local.tee $0
+                                      local.get $4
+                                      i32.eq
+                                      if ;; label = @18
+                                        block ;; label = @19
+                                          local.get $4
+                                          i32.const 16
+                                          i32.add
+                                          local.tee $3
+                                          i32.const 4
+                                          i32.add
+                                          local.tee $1
+                                          i32.load
+                                          local.tee $0
+                                          i32.eqz
+                                          if ;; label = @20
+                                            local.get $3
+                                            i32.load
+                                            local.tee $0
+                                            if ;; label = @21
+                                              local.get $3
+                                              local.set $1
+                                            else
+                                              block ;; label = @22
+                                                i32.const 0
+                                                local.set $12
+                                                br 5 (;@17;)
+                                              end
+                                            end
+                                          end
+                                          loop $label$239 ;; label = @20
+                                            local.get $0
+                                            i32.const 20
+                                            i32.add
+                                            local.tee $5
+                                            i32.load
+                                            local.tee $3
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                local.get $3
+                                                local.set $0
+                                                local.get $5
+                                                local.set $1
+                                                br 2 (;@20;)
+                                              end
+                                            end
+                                            local.get $0
+                                            i32.const 16
+                                            i32.add
+                                            local.tee $5
+                                            i32.load
+                                            local.tee $3
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                local.get $3
+                                                local.set $0
+                                                local.get $5
+                                                local.set $1
+                                                br 2 (;@20;)
+                                              end
+                                            end
+                                          end
+                                          local.get $1
+                                          local.get $2
+                                          i32.lt_u
+                                          if ;; label = @20
+                                            call $fimport$10
+                                          else
+                                            block ;; label = @21
+                                              local.get $1
+                                              i32.const 0
+                                              i32.store
+                                              local.get $0
+                                              local.set $12
+                                            end
+                                          end
+                                        end
+                                      else
+                                        block ;; label = @19
+                                          local.get $4
+                                          i32.load offset=8
+                                          local.tee $5
+                                          local.get $2
+                                          i32.lt_u
+                                          if ;; label = @20
+                                            call $fimport$10
+                                          end
+                                          local.get $5
+                                          i32.const 12
+                                          i32.add
+                                          local.tee $3
+                                          i32.load
+                                          local.get $4
+                                          i32.ne
+                                          if ;; label = @20
+                                            call $fimport$10
+                                          end
+                                          local.get $0
+                                          i32.const 8
+                                          i32.add
+                                          local.tee $1
+                                          i32.load
+                                          local.get $4
+                                          i32.eq
+                                          if ;; label = @20
+                                            block ;; label = @21
+                                              local.get $3
+                                              local.get $0
+                                              i32.store
+                                              local.get $1
+                                              local.get $5
+                                              i32.store
+                                              local.get $0
+                                              local.set $12
+                                            end
+                                          else
+                                            call $fimport$10
+                                          end
+                                        end
+                                      end
+                                    end
+                                    local.get $8
+                                    i32.eqz
+                                    br_if 2 (;@14;)
+                                    block $label$249 ;; label = @17
+                                      local.get $4
+                                      local.get $4
+                                      i32.load offset=28
+                                      local.tee $1
+                                      i32.const 2
+                                      i32.shl
+                                      i32.const 3940
+                                      i32.add
+                                      local.tee $0
+                                      i32.load
+                                      i32.eq
+                                      if ;; label = @18
+                                        block ;; label = @19
+                                          local.get $0
+                                          local.get $12
+                                          i32.store
+                                          local.get $12
+                                          br_if 2 (;@17;)
+                                          i32.const 3640
+                                          i32.const 3640
+                                          i32.load
+                                          i32.const 1
+                                          local.get $1
+                                          i32.shl
+                                          i32.const -1
+                                          i32.xor
+                                          i32.and
+                                          i32.store
+                                          br 5 (;@14;)
+                                        end
+                                      else
+                                        block ;; label = @19
+                                          local.get $8
+                                          i32.const 3652
+                                          i32.load
+                                          i32.lt_u
+                                          if ;; label = @20
+                                            call $fimport$10
+                                          end
+                                          local.get $8
+                                          i32.const 16
+                                          i32.add
+                                          local.tee $0
+                                          i32.load
+                                          local.get $4
+                                          i32.eq
+                                          if ;; label = @20
+                                            local.get $0
+                                            local.get $12
+                                            i32.store
+                                          else
+                                            local.get $8
+                                            local.get $12
+                                            i32.store offset=20
+                                          end
+                                          local.get $12
+                                          i32.eqz
+                                          br_if 5 (;@14;)
+                                        end
+                                      end
+                                    end
+                                    local.get $12
+                                    i32.const 3652
+                                    i32.load
+                                    local.tee $1
+                                    i32.lt_u
+                                    if ;; label = @17
+                                      call $fimport$10
+                                    end
+                                    local.get $12
+                                    local.get $8
+                                    i32.store offset=24
+                                    local.get $4
+                                    i32.const 16
+                                    i32.add
+                                    local.tee $0
+                                    i32.load
+                                    local.tee $3
+                                    if ;; label = @17
+                                      local.get $3
+                                      local.get $1
+                                      i32.lt_u
+                                      if ;; label = @18
+                                        call $fimport$10
+                                      else
+                                        block ;; label = @19
+                                          local.get $12
+                                          local.get $3
+                                          i32.store offset=16
+                                          local.get $3
+                                          local.get $12
+                                          i32.store offset=24
+                                        end
+                                      end
+                                    end
+                                    local.get $0
+                                    i32.load offset=4
+                                    local.tee $0
+                                    i32.eqz
+                                    br_if 2 (;@14;)
+                                    local.get $0
+                                    i32.const 3652
+                                    i32.load
+                                    i32.lt_u
+                                    if ;; label = @17
+                                      call $fimport$10
+                                    else
+                                      block ;; label = @18
+                                        local.get $12
+                                        local.get $0
+                                        i32.store offset=20
+                                        local.get $0
+                                        local.get $12
+                                        i32.store offset=24
+                                      end
+                                    end
+                                  end
+                                end
+                              end
+                              local.get $11
+                              local.get $7
+                              i32.add
+                              local.set $7
+                              local.get $4
+                              local.get $11
+                              i32.add
+                            end
+                          else
+                            local.get $4
+                          end
+                          local.tee $0
+                          i32.const 4
+                          i32.add
+                          local.tee $0
+                          local.get $0
+                          i32.load
+                          i32.const -2
+                          i32.and
+                          i32.store
+                          local.get $6
+                          local.get $7
+                          i32.const 1
+                          i32.or
+                          i32.store offset=4
+                          local.get $6
+                          local.get $7
+                          i32.add
+                          local.get $7
+                          i32.store
+                          local.get $7
+                          i32.const 3
+                          i32.shr_u
+                          local.set $0
+                          local.get $7
+                          i32.const 256
+                          i32.lt_u
+                          if ;; label = @12
+                            block ;; label = @13
+                              local.get $0
+                              i32.const 1
+                              i32.shl
+                              i32.const 2
+                              i32.shl
+                              i32.const 3676
+                              i32.add
+                              local.set $3
+                              block $label$263 ;; label = @14
+                                i32.const 3636
+                                i32.load
+                                local.tee $1
+                                i32.const 1
+                                local.get $0
+                                i32.shl
+                                local.tee $0
+                                i32.and
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $3
+                                    i32.const 8
+                                    i32.add
+                                    local.tee $1
+                                    i32.load
+                                    local.tee $0
+                                    i32.const 3652
+                                    i32.load
+                                    i32.ge_u
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        local.get $1
+                                        local.set $21
+                                        local.get $0
+                                        local.set $9
+                                        br 4 (;@14;)
+                                      end
+                                    end
+                                    call $fimport$10
+                                  end
+                                else
+                                  block ;; label = @16
+                                    i32.const 3636
+                                    local.get $1
+                                    local.get $0
+                                    i32.or
+                                    i32.store
+                                    local.get $3
+                                    i32.const 8
+                                    i32.add
+                                    local.set $21
+                                    local.get $3
+                                    local.set $9
+                                  end
+                                end
+                              end
+                              local.get $21
+                              local.get $6
+                              i32.store
+                              local.get $9
+                              local.get $6
+                              i32.store offset=12
+                              local.get $6
+                              local.get $9
+                              i32.store offset=8
+                              local.get $6
+                              local.get $3
+                              i32.store offset=12
+                              br 4 (;@9;)
+                            end
+                          end
+                          block $label$267 (result i32) ;; label = @12
+                            local.get $7
+                            i32.const 8
+                            i32.shr_u
+                            local.tee $0
+                            if (result i32) ;; label = @13
+                              block (result i32) ;; label = @14
+                                i32.const 31
+                                local.get $7
+                                i32.const 16777215
+                                i32.gt_u
+                                br_if 2 (;@12;)
+                                drop
+                                local.get $7
+                                i32.const 14
+                                local.get $0
+                                local.get $0
+                                i32.const 1048320
+                                i32.add
+                                i32.const 16
+                                i32.shr_u
+                                i32.const 8
+                                i32.and
+                                local.tee $3
+                                i32.shl
+                                local.tee $1
+                                i32.const 520192
+                                i32.add
+                                i32.const 16
+                                i32.shr_u
+                                i32.const 4
+                                i32.and
+                                local.tee $0
+                                local.get $3
+                                i32.or
+                                local.get $1
+                                local.get $0
+                                i32.shl
+                                local.tee $1
+                                i32.const 245760
+                                i32.add
+                                i32.const 16
+                                i32.shr_u
+                                i32.const 2
+                                i32.and
+                                local.tee $0
+                                i32.or
+                                i32.sub
+                                local.get $1
+                                local.get $0
+                                i32.shl
+                                i32.const 15
+                                i32.shr_u
+                                i32.add
+                                local.tee $0
+                                i32.const 7
+                                i32.add
+                                i32.shr_u
+                                i32.const 1
+                                i32.and
+                                local.get $0
+                                i32.const 1
+                                i32.shl
+                                i32.or
+                              end
+                            else
+                              i32.const 0
+                            end
+                          end
+                          local.tee $2
+                          i32.const 2
+                          i32.shl
+                          i32.const 3940
+                          i32.add
+                          local.set $3
+                          local.get $6
+                          local.get $2
+                          i32.store offset=28
+                          local.get $6
+                          i32.const 16
+                          i32.add
+                          local.tee $0
+                          i32.const 0
+                          i32.store offset=4
+                          local.get $0
+                          i32.const 0
+                          i32.store
+                          i32.const 3640
+                          i32.load
+                          local.tee $1
+                          i32.const 1
+                          local.get $2
+                          i32.shl
+                          local.tee $0
+                          i32.and
+                          i32.eqz
+                          if ;; label = @12
+                            block ;; label = @13
+                              i32.const 3640
+                              local.get $1
+                              local.get $0
+                              i32.or
+                              i32.store
+                              local.get $3
+                              local.get $6
+                              i32.store
+                              local.get $6
+                              local.get $3
+                              i32.store offset=24
+                              local.get $6
+                              local.get $6
+                              i32.store offset=12
+                              local.get $6
+                              local.get $6
+                              i32.store offset=8
+                              br 4 (;@9;)
+                            end
+                          end
+                          local.get $3
+                          i32.load
+                          local.set $0
+                          i32.const 25
+                          local.get $2
+                          i32.const 1
+                          i32.shr_u
+                          i32.sub
+                          local.set $1
+                          local.get $7
+                          local.get $2
+                          i32.const 31
+                          i32.eq
+                          if (result i32) ;; label = @12
+                            i32.const 0
+                          else
+                            local.get $1
+                          end
+                          i32.shl
+                          local.set $2
+                          block $label$273 ;; label = @12
+                            block $label$274 ;; label = @13
+                              block $label$275 ;; label = @14
+                                loop $label$276 ;; label = @15
+                                  local.get $0
+                                  i32.load offset=4
+                                  i32.const -8
+                                  i32.and
+                                  local.get $7
+                                  i32.eq
+                                  br_if 2 (;@13;)
+                                  local.get $2
+                                  i32.const 1
+                                  i32.shl
+                                  local.set $3
+                                  local.get $0
+                                  i32.const 16
+                                  i32.add
+                                  local.get $2
+                                  i32.const 31
+                                  i32.shr_u
+                                  i32.const 2
+                                  i32.shl
+                                  i32.add
+                                  local.tee $2
+                                  i32.load
+                                  local.tee $1
+                                  i32.eqz
+                                  br_if 1 (;@14;)
+                                  local.get $3
+                                  local.set $2
+                                  local.get $1
+                                  local.set $0
+                                  br 0 (;@15;)
+                                end
+                              end
+                              local.get $2
+                              i32.const 3652
+                              i32.load
+                              i32.lt_u
+                              if ;; label = @14
+                                call $fimport$10
+                              else
+                                block ;; label = @15
+                                  local.get $2
+                                  local.get $6
+                                  i32.store
+                                  local.get $6
+                                  local.get $0
+                                  i32.store offset=24
+                                  local.get $6
+                                  local.get $6
+                                  i32.store offset=12
+                                  local.get $6
+                                  local.get $6
+                                  i32.store offset=8
+                                  br 6 (;@9;)
+                                end
+                              end
+                              br 1 (;@12;)
+                            end
+                            local.get $0
+                            i32.const 8
+                            i32.add
+                            local.tee $3
+                            i32.load
+                            local.tee $2
+                            i32.const 3652
+                            i32.load
+                            local.tee $1
+                            i32.ge_u
+                            local.get $0
+                            local.get $1
+                            i32.ge_u
+                            i32.and
+                            if ;; label = @13
+                              block ;; label = @14
+                                local.get $2
+                                local.get $6
+                                i32.store offset=12
+                                local.get $3
+                                local.get $6
+                                i32.store
+                                local.get $6
+                                local.get $2
+                                i32.store offset=8
+                                local.get $6
+                                local.get $0
+                                i32.store offset=12
+                                local.get $6
+                                i32.const 0
+                                i32.store offset=24
+                              end
+                            else
+                              call $fimport$10
+                            end
+                          end
+                        end
+                      end
+                    end
+                    local.get $14
+                    global.set $global$1
+                    local.get $13
+                    i32.const 8
+                    i32.add
+                    return
+                  end
+                end
+              end
+              loop $label$281 ;; label = @6
+                block $label$282 ;; label = @7
+                  local.get $5
+                  i32.load
+                  local.tee $2
+                  local.get $8
+                  i32.le_u
+                  if ;; label = @8
+                    local.get $2
+                    local.get $5
+                    i32.load offset=4
+                    i32.add
+                    local.tee $13
+                    local.get $8
+                    i32.gt_u
+                    br_if 1 (;@7;)
+                  end
+                  local.get $5
+                  i32.load offset=8
+                  local.set $5
+                  br 1 (;@6;)
+                end
+              end
+              i32.const 0
+              local.get $13
+              i32.const -47
+              i32.add
+              local.tee $7
+              i32.const 8
+              i32.add
+              local.tee $5
+              i32.sub
+              i32.const 7
+              i32.and
+              local.set $2
+              local.get $7
+              local.get $5
+              i32.const 7
+              i32.and
+              if (result i32) ;; label = @6
+                local.get $2
+              else
+                i32.const 0
+              end
+              i32.add
+              local.tee $2
+              local.get $8
+              i32.const 16
+              i32.add
+              local.tee $12
+              i32.lt_u
+              if (result i32) ;; label = @6
+                local.get $8
+              else
+                local.get $2
+              end
+              local.tee $7
+              i32.const 8
+              i32.add
+              local.set $10
+              local.get $7
+              i32.const 24
+              i32.add
+              local.set $5
+              local.get $3
+              i32.const -40
+              i32.add
+              local.set $9
+              i32.const 0
+              local.get $1
+              i32.const 8
+              i32.add
+              local.tee $4
+              i32.sub
+              i32.const 7
+              i32.and
+              local.set $2
+              i32.const 3660
+              local.get $1
+              local.get $4
+              i32.const 7
+              i32.and
+              if (result i32) ;; label = @6
+                local.get $2
+              else
+                i32.const 0
+                local.tee $2
+              end
+              i32.add
+              local.tee $4
+              i32.store
+              i32.const 3648
+              local.get $9
+              local.get $2
+              i32.sub
+              local.tee $2
+              i32.store
+              local.get $4
+              local.get $2
+              i32.const 1
+              i32.or
+              i32.store offset=4
+              local.get $4
+              local.get $2
+              i32.add
+              i32.const 40
+              i32.store offset=4
+              i32.const 3664
+              i32.const 4124
+              i32.load
+              i32.store
+              local.get $7
+              i32.const 4
+              i32.add
+              local.tee $2
+              i32.const 27
+              i32.store
+              local.get $10
+              i32.const 4084
+              i64.load align=4
+              i64.store align=4
+              local.get $10
+              i32.const 4092
+              i64.load align=4
+              i64.store offset=8 align=4
+              i32.const 4084
+              local.get $1
+              i32.store
+              i32.const 4088
+              local.get $3
+              i32.store
+              i32.const 4096
+              i32.const 0
+              i32.store
+              i32.const 4092
+              local.get $10
+              i32.store
+              local.get $5
+              local.set $1
+              loop $label$290 ;; label = @6
+                local.get $1
+                i32.const 4
+                i32.add
+                local.tee $1
+                i32.const 7
+                i32.store
+                local.get $1
+                i32.const 4
+                i32.add
+                local.get $13
+                i32.lt_u
+                br_if 0 (;@6;)
+              end
+              local.get $7
+              local.get $8
+              i32.ne
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $2
+                  local.get $2
+                  i32.load
+                  i32.const -2
+                  i32.and
+                  i32.store
+                  local.get $8
+                  local.get $7
+                  local.get $8
+                  i32.sub
+                  local.tee $4
+                  i32.const 1
+                  i32.or
+                  i32.store offset=4
+                  local.get $7
+                  local.get $4
+                  i32.store
+                  local.get $4
+                  i32.const 3
+                  i32.shr_u
+                  local.set $1
+                  local.get $4
+                  i32.const 256
+                  i32.lt_u
+                  if ;; label = @8
+                    block ;; label = @9
+                      local.get $1
+                      i32.const 1
+                      i32.shl
+                      i32.const 2
+                      i32.shl
+                      i32.const 3676
+                      i32.add
+                      local.set $2
+                      i32.const 3636
+                      i32.load
+                      local.tee $3
+                      i32.const 1
+                      local.get $1
+                      i32.shl
+                      local.tee $1
+                      i32.and
+                      if ;; label = @10
+                        local.get $2
+                        i32.const 8
+                        i32.add
+                        local.tee $3
+                        i32.load
+                        local.tee $1
+                        i32.const 3652
+                        i32.load
+                        i32.lt_u
+                        if ;; label = @11
+                          call $fimport$10
+                        else
+                          block ;; label = @12
+                            local.get $3
+                            local.set $15
+                            local.get $1
+                            local.set $11
+                          end
+                        end
+                      else
+                        block ;; label = @11
+                          i32.const 3636
+                          local.get $3
+                          local.get $1
+                          i32.or
+                          i32.store
+                          local.get $2
+                          i32.const 8
+                          i32.add
+                          local.set $15
+                          local.get $2
+                          local.set $11
+                        end
+                      end
+                      local.get $15
+                      local.get $8
+                      i32.store
+                      local.get $11
+                      local.get $8
+                      i32.store offset=12
+                      local.get $8
+                      local.get $11
+                      i32.store offset=8
+                      local.get $8
+                      local.get $2
+                      i32.store offset=12
+                      br 6 (;@3;)
+                    end
+                  end
+                  local.get $4
+                  i32.const 8
+                  i32.shr_u
+                  local.tee $1
+                  if (result i32) ;; label = @8
+                    local.get $4
+                    i32.const 16777215
+                    i32.gt_u
+                    if (result i32) ;; label = @9
+                      i32.const 31
+                    else
+                      local.get $4
+                      i32.const 14
+                      local.get $1
+                      local.get $1
+                      i32.const 1048320
+                      i32.add
+                      i32.const 16
+                      i32.shr_u
+                      i32.const 8
+                      i32.and
+                      local.tee $2
+                      i32.shl
+                      local.tee $3
+                      i32.const 520192
+                      i32.add
+                      i32.const 16
+                      i32.shr_u
+                      i32.const 4
+                      i32.and
+                      local.tee $1
+                      local.get $2
+                      i32.or
+                      local.get $3
+                      local.get $1
+                      i32.shl
+                      local.tee $3
+                      i32.const 245760
+                      i32.add
+                      i32.const 16
+                      i32.shr_u
+                      i32.const 2
+                      i32.and
+                      local.tee $1
+                      i32.or
+                      i32.sub
+                      local.get $3
+                      local.get $1
+                      i32.shl
+                      i32.const 15
+                      i32.shr_u
+                      i32.add
+                      local.tee $1
+                      i32.const 7
+                      i32.add
+                      i32.shr_u
+                      i32.const 1
+                      i32.and
+                      local.get $1
+                      i32.const 1
+                      i32.shl
+                      i32.or
+                    end
+                  else
+                    i32.const 0
+                  end
+                  local.tee $5
+                  i32.const 2
+                  i32.shl
+                  i32.const 3940
+                  i32.add
+                  local.set $2
+                  local.get $8
+                  local.get $5
+                  i32.store offset=28
+                  local.get $8
+                  i32.const 0
+                  i32.store offset=20
+                  local.get $12
+                  i32.const 0
+                  i32.store
+                  i32.const 3640
+                  i32.load
+                  local.tee $3
+                  i32.const 1
+                  local.get $5
+                  i32.shl
+                  local.tee $1
+                  i32.and
+                  i32.eqz
+                  if ;; label = @8
+                    block ;; label = @9
+                      i32.const 3640
+                      local.get $3
+                      local.get $1
+                      i32.or
+                      i32.store
+                      local.get $2
+                      local.get $8
+                      i32.store
+                      local.get $8
+                      local.get $2
+                      i32.store offset=24
+                      local.get $8
+                      local.get $8
+                      i32.store offset=12
+                      local.get $8
+                      local.get $8
+                      i32.store offset=8
+                      br 6 (;@3;)
+                    end
+                  end
+                  local.get $2
+                  i32.load
+                  local.set $1
+                  i32.const 25
+                  local.get $5
+                  i32.const 1
+                  i32.shr_u
+                  i32.sub
+                  local.set $3
+                  local.get $4
+                  local.get $5
+                  i32.const 31
+                  i32.eq
+                  if (result i32) ;; label = @8
+                    i32.const 0
+                  else
+                    local.get $3
+                  end
+                  i32.shl
+                  local.set $5
+                  block $label$304 ;; label = @8
+                    block $label$305 ;; label = @9
+                      block $label$306 ;; label = @10
+                        loop $label$307 ;; label = @11
+                          local.get $1
+                          i32.load offset=4
+                          i32.const -8
+                          i32.and
+                          local.get $4
+                          i32.eq
+                          br_if 2 (;@9;)
+                          local.get $5
+                          i32.const 1
+                          i32.shl
+                          local.set $2
+                          local.get $1
+                          i32.const 16
+                          i32.add
+                          local.get $5
+                          i32.const 31
+                          i32.shr_u
+                          i32.const 2
+                          i32.shl
+                          i32.add
+                          local.tee $5
+                          i32.load
+                          local.tee $3
+                          i32.eqz
+                          br_if 1 (;@10;)
+                          local.get $2
+                          local.set $5
+                          local.get $3
+                          local.set $1
+                          br 0 (;@11;)
+                        end
+                      end
+                      local.get $5
+                      i32.const 3652
+                      i32.load
+                      i32.lt_u
+                      if ;; label = @10
+                        call $fimport$10
+                      else
+                        block ;; label = @11
+                          local.get $5
+                          local.get $8
+                          i32.store
+                          local.get $8
+                          local.get $1
+                          i32.store offset=24
+                          local.get $8
+                          local.get $8
+                          i32.store offset=12
+                          local.get $8
+                          local.get $8
+                          i32.store offset=8
+                          br 8 (;@3;)
+                        end
+                      end
+                      br 1 (;@8;)
+                    end
+                    local.get $1
+                    i32.const 8
+                    i32.add
+                    local.tee $2
+                    i32.load
+                    local.tee $5
+                    i32.const 3652
+                    i32.load
+                    local.tee $3
+                    i32.ge_u
+                    local.get $1
+                    local.get $3
+                    i32.ge_u
+                    i32.and
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $5
+                        local.get $8
+                        i32.store offset=12
+                        local.get $2
+                        local.get $8
+                        i32.store
+                        local.get $8
+                        local.get $5
+                        i32.store offset=8
+                        local.get $8
+                        local.get $1
+                        i32.store offset=12
+                        local.get $8
+                        i32.const 0
+                        i32.store offset=24
+                      end
+                    else
+                      call $fimport$10
+                    end
+                  end
+                end
+              end
+            end
+          else
+            block ;; label = @5
+              i32.const 3652
+              i32.load
+              local.tee $2
+              i32.eqz
+              local.get $1
+              local.get $2
+              i32.lt_u
+              i32.or
+              if ;; label = @6
+                i32.const 3652
+                local.get $1
+                i32.store
+              end
+              i32.const 4084
+              local.get $1
+              i32.store
+              i32.const 4088
+              local.get $3
+              i32.store
+              i32.const 4096
+              i32.const 0
+              i32.store
+              i32.const 3672
+              i32.const 4108
+              i32.load
+              i32.store
+              i32.const 3668
+              i32.const -1
+              i32.store
+              i32.const 0
+              local.set $2
+              loop $label$314 ;; label = @6
+                local.get $2
+                i32.const 1
+                i32.shl
+                i32.const 2
+                i32.shl
+                i32.const 3676
+                i32.add
+                local.tee $5
+                local.get $5
+                i32.store offset=12
+                local.get $5
+                local.get $5
+                i32.store offset=8
+                local.get $2
+                i32.const 1
+                i32.add
+                local.tee $2
+                i32.const 32
+                i32.ne
+                br_if 0 (;@6;)
+              end
+              local.get $3
+              i32.const -40
+              i32.add
+              local.set $5
+              i32.const 0
+              local.get $1
+              i32.const 8
+              i32.add
+              local.tee $2
+              i32.sub
+              i32.const 7
+              i32.and
+              local.set $3
+              i32.const 3660
+              local.get $1
+              local.get $2
+              i32.const 7
+              i32.and
+              if (result i32) ;; label = @6
+                local.get $3
+              else
+                i32.const 0
+              end
+              local.tee $1
+              i32.add
+              local.tee $3
+              i32.store
+              i32.const 3648
+              local.get $5
+              local.get $1
+              i32.sub
+              local.tee $1
+              i32.store
+              local.get $3
+              local.get $1
+              i32.const 1
+              i32.or
+              i32.store offset=4
+              local.get $3
+              local.get $1
+              i32.add
+              i32.const 40
+              i32.store offset=4
+              i32.const 3664
+              i32.const 4124
+              i32.load
+              i32.store
+            end
+          end
+        end
+        i32.const 3648
+        i32.load
+        local.tee $1
+        local.get $0
+        i32.gt_u
+        if ;; label = @3
+          block ;; label = @4
+            i32.const 3648
+            local.get $1
+            local.get $0
+            i32.sub
+            local.tee $3
+            i32.store
+            i32.const 3660
+            i32.const 3660
+            i32.load
+            local.tee $2
+            local.get $0
+            i32.add
+            local.tee $1
+            i32.store
+            local.get $1
+            local.get $3
+            i32.const 1
+            i32.or
+            i32.store offset=4
+            local.get $2
+            local.get $0
+            i32.const 3
+            i32.or
+            i32.store offset=4
+            local.get $14
+            global.set $global$1
+            local.get $2
+            i32.const 8
+            i32.add
+            return
+          end
+        end
+      end
+      call $12
+      i32.const 12
+      i32.store
+      local.get $14
+      global.set $global$1
+      i32.const 0
+    end
+  )
+  (func $38 (;51;) (type $2) (param $0 i32)
+    (local $1 i32) (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32) (local $15 i32)
+    block $label$1 ;; label = @1
+      local.get $0
+      i32.eqz
+      if ;; label = @2
+        return
+      end
+      local.get $0
+      i32.const -8
+      i32.add
+      local.tee $1
+      i32.const 3652
+      i32.load
+      local.tee $11
+      i32.lt_u
+      if ;; label = @2
+        call $fimport$10
+      end
+      local.get $0
+      i32.const -4
+      i32.add
+      i32.load
+      local.tee $0
+      i32.const 3
+      i32.and
+      local.tee $8
+      i32.const 1
+      i32.eq
+      if ;; label = @2
+        call $fimport$10
+      end
+      local.get $1
+      local.get $0
+      i32.const -8
+      i32.and
+      local.tee $4
+      i32.add
+      local.set $6
+      block $label$5 ;; label = @2
+        local.get $0
+        i32.const 1
+        i32.and
+        if ;; label = @3
+          block ;; label = @4
+            local.get $1
+            local.set $3
+            local.get $4
+            local.set $2
+          end
+        else
+          block ;; label = @4
+            local.get $8
+            i32.eqz
+            if ;; label = @5
+              return
+            end
+            local.get $1
+            i32.const 0
+            local.get $1
+            i32.load
+            local.tee $8
+            i32.sub
+            i32.add
+            local.tee $0
+            local.get $11
+            i32.lt_u
+            if ;; label = @5
+              call $fimport$10
+            end
+            local.get $8
+            local.get $4
+            i32.add
+            local.set $1
+            local.get $0
+            i32.const 3656
+            i32.load
+            i32.eq
+            if ;; label = @5
+              block ;; label = @6
+                local.get $6
+                i32.const 4
+                i32.add
+                local.tee $2
+                i32.load
+                local.tee $3
+                i32.const 3
+                i32.and
+                i32.const 3
+                i32.ne
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $0
+                    local.set $3
+                    local.get $1
+                    local.set $2
+                    br 6 (;@2;)
+                  end
+                end
+                i32.const 3644
+                local.get $1
+                i32.store
+                local.get $2
+                local.get $3
+                i32.const -2
+                i32.and
+                i32.store
+                local.get $0
+                local.get $1
+                i32.const 1
+                i32.or
+                i32.store offset=4
+                local.get $0
+                local.get $1
+                i32.add
+                local.get $1
+                i32.store
+                return
+              end
+            end
+            local.get $8
+            i32.const 3
+            i32.shr_u
+            local.set $10
+            local.get $8
+            i32.const 256
+            i32.lt_u
+            if ;; label = @5
+              block ;; label = @6
+                local.get $0
+                i32.load offset=12
+                local.set $3
+                local.get $0
+                i32.load offset=8
+                local.tee $4
+                local.get $10
+                i32.const 1
+                i32.shl
+                i32.const 2
+                i32.shl
+                i32.const 3676
+                i32.add
+                local.tee $2
+                i32.ne
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $4
+                    local.get $11
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                    local.get $4
+                    i32.load offset=12
+                    local.get $0
+                    i32.ne
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                  end
+                end
+                local.get $3
+                local.get $4
+                i32.eq
+                if ;; label = @7
+                  block ;; label = @8
+                    i32.const 3636
+                    i32.const 3636
+                    i32.load
+                    i32.const 1
+                    local.get $10
+                    i32.shl
+                    i32.const -1
+                    i32.xor
+                    i32.and
+                    i32.store
+                    local.get $0
+                    local.set $3
+                    local.get $1
+                    local.set $2
+                    br 6 (;@2;)
+                  end
+                end
+                local.get $3
+                local.get $2
+                i32.eq
+                if ;; label = @7
+                  local.get $3
+                  i32.const 8
+                  i32.add
+                  local.set $5
+                else
+                  block ;; label = @8
+                    local.get $3
+                    local.get $11
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                    local.get $3
+                    i32.const 8
+                    i32.add
+                    local.tee $2
+                    i32.load
+                    local.get $0
+                    i32.eq
+                    if ;; label = @9
+                      local.get $2
+                      local.set $5
+                    else
+                      call $fimport$10
+                    end
+                  end
+                end
+                local.get $4
+                local.get $3
+                i32.store offset=12
+                local.get $5
+                local.get $4
+                i32.store
+                local.get $0
+                local.set $3
+                local.get $1
+                local.set $2
+                br 4 (;@2;)
+              end
+            end
+            local.get $0
+            i32.load offset=24
+            local.set $12
+            block $label$22 ;; label = @5
+              local.get $0
+              i32.load offset=12
+              local.tee $4
+              local.get $0
+              i32.eq
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $0
+                  i32.const 16
+                  i32.add
+                  local.tee $5
+                  i32.const 4
+                  i32.add
+                  local.tee $8
+                  i32.load
+                  local.tee $4
+                  if ;; label = @8
+                    local.get $8
+                    local.set $5
+                  else
+                    local.get $5
+                    i32.load
+                    local.tee $4
+                    i32.eqz
+                    if ;; label = @9
+                      block ;; label = @10
+                        i32.const 0
+                        local.set $7
+                        br 5 (;@5;)
+                      end
+                    end
+                  end
+                  loop $label$27 ;; label = @8
+                    local.get $4
+                    i32.const 20
+                    i32.add
+                    local.tee $8
+                    i32.load
+                    local.tee $10
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $10
+                        local.set $4
+                        local.get $8
+                        local.set $5
+                        br 2 (;@8;)
+                      end
+                    end
+                    local.get $4
+                    i32.const 16
+                    i32.add
+                    local.tee $8
+                    i32.load
+                    local.tee $10
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $10
+                        local.set $4
+                        local.get $8
+                        local.set $5
+                        br 2 (;@8;)
+                      end
+                    end
+                  end
+                  local.get $5
+                  local.get $11
+                  i32.lt_u
+                  if ;; label = @8
+                    call $fimport$10
+                  else
+                    block ;; label = @9
+                      local.get $5
+                      i32.const 0
+                      i32.store
+                      local.get $4
+                      local.set $7
+                    end
+                  end
+                end
+              else
+                block ;; label = @7
+                  local.get $0
+                  i32.load offset=8
+                  local.tee $5
+                  local.get $11
+                  i32.lt_u
+                  if ;; label = @8
+                    call $fimport$10
+                  end
+                  local.get $5
+                  i32.const 12
+                  i32.add
+                  local.tee $8
+                  i32.load
+                  local.get $0
+                  i32.ne
+                  if ;; label = @8
+                    call $fimport$10
+                  end
+                  local.get $4
+                  i32.const 8
+                  i32.add
+                  local.tee $10
+                  i32.load
+                  local.get $0
+                  i32.eq
+                  if ;; label = @8
+                    block ;; label = @9
+                      local.get $8
+                      local.get $4
+                      i32.store
+                      local.get $10
+                      local.get $5
+                      i32.store
+                      local.get $4
+                      local.set $7
+                    end
+                  else
+                    call $fimport$10
+                  end
+                end
+              end
+            end
+            local.get $12
+            if ;; label = @5
+              block ;; label = @6
+                local.get $0
+                local.get $0
+                i32.load offset=28
+                local.tee $4
+                i32.const 2
+                i32.shl
+                i32.const 3940
+                i32.add
+                local.tee $5
+                i32.load
+                i32.eq
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $5
+                    local.get $7
+                    i32.store
+                    local.get $7
+                    i32.eqz
+                    if ;; label = @9
+                      block ;; label = @10
+                        i32.const 3640
+                        i32.const 3640
+                        i32.load
+                        i32.const 1
+                        local.get $4
+                        i32.shl
+                        i32.const -1
+                        i32.xor
+                        i32.and
+                        i32.store
+                        local.get $0
+                        local.set $3
+                        local.get $1
+                        local.set $2
+                        br 8 (;@2;)
+                      end
+                    end
+                  end
+                else
+                  block ;; label = @8
+                    local.get $12
+                    i32.const 3652
+                    i32.load
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                    local.get $12
+                    i32.const 16
+                    i32.add
+                    local.tee $4
+                    i32.load
+                    local.get $0
+                    i32.eq
+                    if ;; label = @9
+                      local.get $4
+                      local.get $7
+                      i32.store
+                    else
+                      local.get $12
+                      local.get $7
+                      i32.store offset=20
+                    end
+                    local.get $7
+                    i32.eqz
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $0
+                        local.set $3
+                        local.get $1
+                        local.set $2
+                        br 8 (;@2;)
+                      end
+                    end
+                  end
+                end
+                local.get $7
+                i32.const 3652
+                i32.load
+                local.tee $5
+                i32.lt_u
+                if ;; label = @7
+                  call $fimport$10
+                end
+                local.get $7
+                local.get $12
+                i32.store offset=24
+                local.get $0
+                i32.const 16
+                i32.add
+                local.tee $8
+                i32.load
+                local.tee $4
+                if ;; label = @7
+                  local.get $4
+                  local.get $5
+                  i32.lt_u
+                  if ;; label = @8
+                    call $fimport$10
+                  else
+                    block ;; label = @9
+                      local.get $7
+                      local.get $4
+                      i32.store offset=16
+                      local.get $4
+                      local.get $7
+                      i32.store offset=24
+                    end
+                  end
+                end
+                local.get $8
+                i32.load offset=4
+                local.tee $4
+                if ;; label = @7
+                  local.get $4
+                  i32.const 3652
+                  i32.load
+                  i32.lt_u
+                  if ;; label = @8
+                    call $fimport$10
+                  else
+                    block ;; label = @9
+                      local.get $7
+                      local.get $4
+                      i32.store offset=20
+                      local.get $4
+                      local.get $7
+                      i32.store offset=24
+                      local.get $0
+                      local.set $3
+                      local.get $1
+                      local.set $2
+                    end
+                  end
+                else
+                  block ;; label = @8
+                    local.get $0
+                    local.set $3
+                    local.get $1
+                    local.set $2
+                  end
+                end
+              end
+            else
+              block ;; label = @6
+                local.get $0
+                local.set $3
+                local.get $1
+                local.set $2
+              end
+            end
+          end
+        end
+      end
+      local.get $3
+      local.get $6
+      i32.ge_u
+      if ;; label = @2
+        call $fimport$10
+      end
+      local.get $6
+      i32.const 4
+      i32.add
+      local.tee $1
+      i32.load
+      local.tee $0
+      i32.const 1
+      i32.and
+      i32.eqz
+      if ;; label = @2
+        call $fimport$10
+      end
+      local.get $0
+      i32.const 2
+      i32.and
+      if ;; label = @2
+        block ;; label = @3
+          local.get $1
+          local.get $0
+          i32.const -2
+          i32.and
+          i32.store
+          local.get $3
+          local.get $2
+          i32.const 1
+          i32.or
+          i32.store offset=4
+          local.get $3
+          local.get $2
+          i32.add
+          local.get $2
+          i32.store
+        end
+      else
+        block ;; label = @3
+          local.get $6
+          i32.const 3660
+          i32.load
+          i32.eq
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 3648
+              i32.const 3648
+              i32.load
+              local.get $2
+              i32.add
+              local.tee $0
+              i32.store
+              i32.const 3660
+              local.get $3
+              i32.store
+              local.get $3
+              local.get $0
+              i32.const 1
+              i32.or
+              i32.store offset=4
+              local.get $3
+              i32.const 3656
+              i32.load
+              i32.ne
+              if ;; label = @6
+                return
+              end
+              i32.const 3656
+              i32.const 0
+              i32.store
+              i32.const 3644
+              i32.const 0
+              i32.store
+              return
+            end
+          end
+          local.get $6
+          i32.const 3656
+          i32.load
+          i32.eq
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 3644
+              i32.const 3644
+              i32.load
+              local.get $2
+              i32.add
+              local.tee $0
+              i32.store
+              i32.const 3656
+              local.get $3
+              i32.store
+              local.get $3
+              local.get $0
+              i32.const 1
+              i32.or
+              i32.store offset=4
+              local.get $3
+              local.get $0
+              i32.add
+              local.get $0
+              i32.store
+              return
+            end
+          end
+          local.get $0
+          i32.const -8
+          i32.and
+          local.get $2
+          i32.add
+          local.set $5
+          local.get $0
+          i32.const 3
+          i32.shr_u
+          local.set $4
+          block $label$61 ;; label = @4
+            local.get $0
+            i32.const 256
+            i32.lt_u
+            if ;; label = @5
+              block ;; label = @6
+                local.get $6
+                i32.load offset=12
+                local.set $2
+                local.get $6
+                i32.load offset=8
+                local.tee $1
+                local.get $4
+                i32.const 1
+                i32.shl
+                i32.const 2
+                i32.shl
+                i32.const 3676
+                i32.add
+                local.tee $0
+                i32.ne
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $1
+                    i32.const 3652
+                    i32.load
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                    local.get $1
+                    i32.load offset=12
+                    local.get $6
+                    i32.ne
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                  end
+                end
+                local.get $2
+                local.get $1
+                i32.eq
+                if ;; label = @7
+                  block ;; label = @8
+                    i32.const 3636
+                    i32.const 3636
+                    i32.load
+                    i32.const 1
+                    local.get $4
+                    i32.shl
+                    i32.const -1
+                    i32.xor
+                    i32.and
+                    i32.store
+                    br 4 (;@4;)
+                  end
+                end
+                local.get $2
+                local.get $0
+                i32.eq
+                if ;; label = @7
+                  local.get $2
+                  i32.const 8
+                  i32.add
+                  local.set $14
+                else
+                  block ;; label = @8
+                    local.get $2
+                    i32.const 3652
+                    i32.load
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                    local.get $2
+                    i32.const 8
+                    i32.add
+                    local.tee $0
+                    i32.load
+                    local.get $6
+                    i32.eq
+                    if ;; label = @9
+                      local.get $0
+                      local.set $14
+                    else
+                      call $fimport$10
+                    end
+                  end
+                end
+                local.get $1
+                local.get $2
+                i32.store offset=12
+                local.get $14
+                local.get $1
+                i32.store
+              end
+            else
+              block ;; label = @6
+                local.get $6
+                i32.load offset=24
+                local.set $7
+                block $label$73 ;; label = @7
+                  local.get $6
+                  i32.load offset=12
+                  local.tee $0
+                  local.get $6
+                  i32.eq
+                  if ;; label = @8
+                    block ;; label = @9
+                      local.get $6
+                      i32.const 16
+                      i32.add
+                      local.tee $2
+                      i32.const 4
+                      i32.add
+                      local.tee $1
+                      i32.load
+                      local.tee $0
+                      if ;; label = @10
+                        local.get $1
+                        local.set $2
+                      else
+                        local.get $2
+                        i32.load
+                        local.tee $0
+                        i32.eqz
+                        if ;; label = @11
+                          block ;; label = @12
+                            i32.const 0
+                            local.set $9
+                            br 5 (;@7;)
+                          end
+                        end
+                      end
+                      loop $label$78 ;; label = @10
+                        local.get $0
+                        i32.const 20
+                        i32.add
+                        local.tee $1
+                        i32.load
+                        local.tee $4
+                        if ;; label = @11
+                          block ;; label = @12
+                            local.get $4
+                            local.set $0
+                            local.get $1
+                            local.set $2
+                            br 2 (;@10;)
+                          end
+                        end
+                        local.get $0
+                        i32.const 16
+                        i32.add
+                        local.tee $1
+                        i32.load
+                        local.tee $4
+                        if ;; label = @11
+                          block ;; label = @12
+                            local.get $4
+                            local.set $0
+                            local.get $1
+                            local.set $2
+                            br 2 (;@10;)
+                          end
+                        end
+                      end
+                      local.get $2
+                      i32.const 3652
+                      i32.load
+                      i32.lt_u
+                      if ;; label = @10
+                        call $fimport$10
+                      else
+                        block ;; label = @11
+                          local.get $2
+                          i32.const 0
+                          i32.store
+                          local.get $0
+                          local.set $9
+                        end
+                      end
+                    end
+                  else
+                    block ;; label = @9
+                      local.get $6
+                      i32.load offset=8
+                      local.tee $2
+                      i32.const 3652
+                      i32.load
+                      i32.lt_u
+                      if ;; label = @10
+                        call $fimport$10
+                      end
+                      local.get $2
+                      i32.const 12
+                      i32.add
+                      local.tee $1
+                      i32.load
+                      local.get $6
+                      i32.ne
+                      if ;; label = @10
+                        call $fimport$10
+                      end
+                      local.get $0
+                      i32.const 8
+                      i32.add
+                      local.tee $4
+                      i32.load
+                      local.get $6
+                      i32.eq
+                      if ;; label = @10
+                        block ;; label = @11
+                          local.get $1
+                          local.get $0
+                          i32.store
+                          local.get $4
+                          local.get $2
+                          i32.store
+                          local.get $0
+                          local.set $9
+                        end
+                      else
+                        call $fimport$10
+                      end
+                    end
+                  end
+                end
+                local.get $7
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $6
+                    local.get $6
+                    i32.load offset=28
+                    local.tee $0
+                    i32.const 2
+                    i32.shl
+                    i32.const 3940
+                    i32.add
+                    local.tee $2
+                    i32.load
+                    i32.eq
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $2
+                        local.get $9
+                        i32.store
+                        local.get $9
+                        i32.eqz
+                        if ;; label = @11
+                          block ;; label = @12
+                            i32.const 3640
+                            i32.const 3640
+                            i32.load
+                            i32.const 1
+                            local.get $0
+                            i32.shl
+                            i32.const -1
+                            i32.xor
+                            i32.and
+                            i32.store
+                            br 8 (;@4;)
+                          end
+                        end
+                      end
+                    else
+                      block ;; label = @10
+                        local.get $7
+                        i32.const 3652
+                        i32.load
+                        i32.lt_u
+                        if ;; label = @11
+                          call $fimport$10
+                        end
+                        local.get $7
+                        i32.const 16
+                        i32.add
+                        local.tee $0
+                        i32.load
+                        local.get $6
+                        i32.eq
+                        if ;; label = @11
+                          local.get $0
+                          local.get $9
+                          i32.store
+                        else
+                          local.get $7
+                          local.get $9
+                          i32.store offset=20
+                        end
+                        local.get $9
+                        i32.eqz
+                        br_if 6 (;@4;)
+                      end
+                    end
+                    local.get $9
+                    i32.const 3652
+                    i32.load
+                    local.tee $2
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                    local.get $9
+                    local.get $7
+                    i32.store offset=24
+                    local.get $6
+                    i32.const 16
+                    i32.add
+                    local.tee $1
+                    i32.load
+                    local.tee $0
+                    if ;; label = @9
+                      local.get $0
+                      local.get $2
+                      i32.lt_u
+                      if ;; label = @10
+                        call $fimport$10
+                      else
+                        block ;; label = @11
+                          local.get $9
+                          local.get $0
+                          i32.store offset=16
+                          local.get $0
+                          local.get $9
+                          i32.store offset=24
+                        end
+                      end
+                    end
+                    local.get $1
+                    i32.load offset=4
+                    local.tee $0
+                    if ;; label = @9
+                      local.get $0
+                      i32.const 3652
+                      i32.load
+                      i32.lt_u
+                      if ;; label = @10
+                        call $fimport$10
+                      else
+                        block ;; label = @11
+                          local.get $9
+                          local.get $0
+                          i32.store offset=20
+                          local.get $0
+                          local.get $9
+                          i32.store offset=24
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+          local.get $3
+          local.get $5
+          i32.const 1
+          i32.or
+          i32.store offset=4
+          local.get $3
+          local.get $5
+          i32.add
+          local.get $5
+          i32.store
+          local.get $3
+          i32.const 3656
+          i32.load
+          i32.eq
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 3644
+              local.get $5
+              i32.store
+              return
+            end
+          else
+            local.get $5
+            local.set $2
+          end
+        end
+      end
+      local.get $2
+      i32.const 3
+      i32.shr_u
+      local.set $1
+      local.get $2
+      i32.const 256
+      i32.lt_u
+      if ;; label = @2
+        block ;; label = @3
+          local.get $1
+          i32.const 1
+          i32.shl
+          i32.const 2
+          i32.shl
+          i32.const 3676
+          i32.add
+          local.set $0
+          i32.const 3636
+          i32.load
+          local.tee $2
+          i32.const 1
+          local.get $1
+          i32.shl
+          local.tee $1
+          i32.and
+          if ;; label = @4
+            local.get $0
+            i32.const 8
+            i32.add
+            local.tee $2
+            i32.load
+            local.tee $1
+            i32.const 3652
+            i32.load
+            i32.lt_u
+            if ;; label = @5
+              call $fimport$10
+            else
+              block ;; label = @6
+                local.get $2
+                local.set $15
+                local.get $1
+                local.set $13
+              end
+            end
+          else
+            block ;; label = @5
+              i32.const 3636
+              local.get $2
+              local.get $1
+              i32.or
+              i32.store
+              local.get $0
+              i32.const 8
+              i32.add
+              local.set $15
+              local.get $0
+              local.set $13
+            end
+          end
+          local.get $15
+          local.get $3
+          i32.store
+          local.get $13
+          local.get $3
+          i32.store offset=12
+          local.get $3
+          local.get $13
+          i32.store offset=8
+          local.get $3
+          local.get $0
+          i32.store offset=12
+          return
+        end
+      end
+      local.get $2
+      i32.const 8
+      i32.shr_u
+      local.tee $0
+      if (result i32) ;; label = @2
+        local.get $2
+        i32.const 16777215
+        i32.gt_u
+        if (result i32) ;; label = @3
+          i32.const 31
+        else
+          local.get $2
+          i32.const 14
+          local.get $0
+          local.get $0
+          i32.const 1048320
+          i32.add
+          i32.const 16
+          i32.shr_u
+          i32.const 8
+          i32.and
+          local.tee $0
+          i32.shl
+          local.tee $1
+          i32.const 520192
+          i32.add
+          i32.const 16
+          i32.shr_u
+          i32.const 4
+          i32.and
+          local.tee $4
+          local.get $0
+          i32.or
+          local.get $1
+          local.get $4
+          i32.shl
+          local.tee $0
+          i32.const 245760
+          i32.add
+          i32.const 16
+          i32.shr_u
+          i32.const 2
+          i32.and
+          local.tee $1
+          i32.or
+          i32.sub
+          local.get $0
+          local.get $1
+          i32.shl
+          i32.const 15
+          i32.shr_u
+          i32.add
+          local.tee $0
+          i32.const 7
+          i32.add
+          i32.shr_u
+          i32.const 1
+          i32.and
+          local.get $0
+          i32.const 1
+          i32.shl
+          i32.or
+        end
+      else
+        i32.const 0
+      end
+      local.tee $1
+      i32.const 2
+      i32.shl
+      i32.const 3940
+      i32.add
+      local.set $0
+      local.get $3
+      local.get $1
+      i32.store offset=28
+      local.get $3
+      i32.const 0
+      i32.store offset=20
+      local.get $3
+      i32.const 0
+      i32.store offset=16
+      block $label$113 ;; label = @2
+        i32.const 3640
+        i32.load
+        local.tee $4
+        i32.const 1
+        local.get $1
+        i32.shl
+        local.tee $5
+        i32.and
+        if ;; label = @3
+          block ;; label = @4
+            local.get $0
+            i32.load
+            local.set $0
+            i32.const 25
+            local.get $1
+            i32.const 1
+            i32.shr_u
+            i32.sub
+            local.set $4
+            local.get $2
+            local.get $1
+            i32.const 31
+            i32.eq
+            if (result i32) ;; label = @5
+              i32.const 0
+            else
+              local.get $4
+            end
+            i32.shl
+            local.set $1
+            block $label$117 ;; label = @5
+              block $label$118 ;; label = @6
+                block $label$119 ;; label = @7
+                  loop $label$120 ;; label = @8
+                    local.get $0
+                    i32.load offset=4
+                    i32.const -8
+                    i32.and
+                    local.get $2
+                    i32.eq
+                    br_if 2 (;@6;)
+                    local.get $1
+                    i32.const 1
+                    i32.shl
+                    local.set $4
+                    local.get $0
+                    i32.const 16
+                    i32.add
+                    local.get $1
+                    i32.const 31
+                    i32.shr_u
+                    i32.const 2
+                    i32.shl
+                    i32.add
+                    local.tee $1
+                    i32.load
+                    local.tee $5
+                    i32.eqz
+                    br_if 1 (;@7;)
+                    local.get $4
+                    local.set $1
+                    local.get $5
+                    local.set $0
+                    br 0 (;@8;)
+                  end
+                end
+                local.get $1
+                i32.const 3652
+                i32.load
+                i32.lt_u
+                if ;; label = @7
+                  call $fimport$10
+                else
+                  block ;; label = @8
+                    local.get $1
+                    local.get $3
+                    i32.store
+                    local.get $3
+                    local.get $0
+                    i32.store offset=24
+                    local.get $3
+                    local.get $3
+                    i32.store offset=12
+                    local.get $3
+                    local.get $3
+                    i32.store offset=8
+                    br 6 (;@2;)
+                  end
+                end
+                br 1 (;@5;)
+              end
+              local.get $0
+              i32.const 8
+              i32.add
+              local.tee $1
+              i32.load
+              local.tee $2
+              i32.const 3652
+              i32.load
+              local.tee $4
+              i32.ge_u
+              local.get $0
+              local.get $4
+              i32.ge_u
+              i32.and
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $2
+                  local.get $3
+                  i32.store offset=12
+                  local.get $1
+                  local.get $3
+                  i32.store
+                  local.get $3
+                  local.get $2
+                  i32.store offset=8
+                  local.get $3
+                  local.get $0
+                  i32.store offset=12
+                  local.get $3
+                  i32.const 0
+                  i32.store offset=24
+                end
+              else
+                call $fimport$10
+              end
+            end
+          end
+        else
+          block ;; label = @4
+            i32.const 3640
+            local.get $4
+            local.get $5
+            i32.or
+            i32.store
+            local.get $0
+            local.get $3
+            i32.store
+            local.get $3
+            local.get $0
+            i32.store offset=24
+            local.get $3
+            local.get $3
+            i32.store offset=12
+            local.get $3
+            local.get $3
+            i32.store offset=8
+          end
+        end
+      end
+      i32.const 3668
+      i32.const 3668
+      i32.load
+      i32.const -1
+      i32.add
+      local.tee $0
+      i32.store
+      local.get $0
+      if ;; label = @2
+        return
+      else
+        i32.const 4092
+        local.set $0
+      end
+      loop $label$128 ;; label = @2
+        local.get $0
+        i32.load
+        local.tee $2
+        i32.const 8
+        i32.add
+        local.set $0
+        local.get $2
+        br_if 0 (;@2;)
+      end
+      i32.const 3668
+      i32.const -1
+      i32.store
+    end
+  )
+  (func $39 (;52;) (type $6)
+    nop
+  )
+  (func $40 (;53;) (type $1) (param $0 i32) (result i32)
+    (local $1 i32) (local $2 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$0
+      i32.load
+      local.tee $2
+      local.get $0
+      i32.const 15
+      i32.add
+      i32.const -16
+      i32.and
+      local.tee $0
+      i32.add
+      local.set $1
+      local.get $0
+      i32.const 0
+      i32.gt_s
+      local.get $1
+      local.get $2
+      i32.lt_s
+      i32.and
+      local.get $1
+      i32.const 0
+      i32.lt_s
+      i32.or
+      if ;; label = @2
+        block ;; label = @3
+          call $fimport$6
+          drop
+          i32.const 12
+          call $fimport$11
+          i32.const -1
+          return
+        end
+      end
+      global.get $global$0
+      local.get $1
+      i32.store
+      local.get $1
+      call $fimport$5
+      i32.gt_s
+      if ;; label = @2
+        call $fimport$4
+        i32.eqz
+        if ;; label = @3
+          block ;; label = @4
+            i32.const 12
+            call $fimport$11
+            global.get $global$0
+            local.get $2
+            i32.store
+            i32.const -1
+            return
+          end
+        end
+      end
+      local.get $2
+    end
+  )
+  (func $41 (;54;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32) (local $4 i32) (local $5 i32)
+    block $label$1 (result i32) ;; label = @1
+      local.get $0
+      local.get $2
+      i32.add
+      local.set $4
+      local.get $2
+      i32.const 20
+      i32.ge_s
+      if ;; label = @2
+        block ;; label = @3
+          local.get $1
+          i32.const 255
+          i32.and
+          local.set $1
+          local.get $0
+          i32.const 3
+          i32.and
+          local.tee $3
+          if ;; label = @4
+            block ;; label = @5
+              local.get $0
+              i32.const 4
+              i32.add
+              local.get $3
+              i32.sub
+              local.set $3
+              loop $label$4 ;; label = @6
+                local.get $0
+                local.get $3
+                i32.lt_s
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $0
+                    local.get $1
+                    i32.store8
+                    local.get $0
+                    i32.const 1
+                    i32.add
+                    local.set $0
+                    br 2 (;@6;)
+                  end
+                end
+              end
+            end
+          end
+          local.get $1
+          local.get $1
+          i32.const 8
+          i32.shl
+          i32.or
+          local.get $1
+          i32.const 16
+          i32.shl
+          i32.or
+          local.get $1
+          i32.const 24
+          i32.shl
+          i32.or
+          local.set $3
+          local.get $4
+          i32.const -4
+          i32.and
+          local.set $5
+          loop $label$6 ;; label = @4
+            local.get $0
+            local.get $5
+            i32.lt_s
+            if ;; label = @5
+              block ;; label = @6
+                local.get $0
+                local.get $3
+                i32.store
+                local.get $0
+                i32.const 4
+                i32.add
+                local.set $0
+                br 2 (;@4;)
+              end
+            end
+          end
+        end
+      end
+      loop $label$8 ;; label = @2
+        local.get $0
+        local.get $4
+        i32.lt_s
+        if ;; label = @3
+          block ;; label = @4
+            local.get $0
+            local.get $1
+            i32.store8
+            local.get $0
+            i32.const 1
+            i32.add
+            local.set $0
+            br 2 (;@2;)
+          end
+        end
+      end
+      local.get $0
+      local.get $2
+      i32.sub
+    end
+  )
+  (func $42 (;55;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32)
+    block $label$1 (result i32) ;; label = @1
+      local.get $2
+      i32.const 4096
+      i32.ge_s
+      if ;; label = @2
+        local.get $0
+        local.get $1
+        local.get $2
+        call $fimport$12
+        return
+      end
+      local.get $0
+      local.set $3
+      local.get $0
+      i32.const 3
+      i32.and
+      local.get $1
+      i32.const 3
+      i32.and
+      i32.eq
+      if ;; label = @2
+        block ;; label = @3
+          loop $label$4 ;; label = @4
+            local.get $0
+            i32.const 3
+            i32.and
+            if ;; label = @5
+              block ;; label = @6
+                local.get $2
+                i32.eqz
+                if ;; label = @7
+                  local.get $3
+                  return
+                end
+                local.get $0
+                local.get $1
+                i32.load8_s
+                i32.store8
+                local.get $0
+                i32.const 1
+                i32.add
+                local.set $0
+                local.get $1
+                i32.const 1
+                i32.add
+                local.set $1
+                local.get $2
+                i32.const 1
+                i32.sub
+                local.set $2
+                br 2 (;@4;)
+              end
+            end
+          end
+          loop $label$7 ;; label = @4
+            local.get $2
+            i32.const 4
+            i32.ge_s
+            if ;; label = @5
+              block ;; label = @6
+                local.get $0
+                local.get $1
+                i32.load
+                i32.store
+                local.get $0
+                i32.const 4
+                i32.add
+                local.set $0
+                local.get $1
+                i32.const 4
+                i32.add
+                local.set $1
+                local.get $2
+                i32.const 4
+                i32.sub
+                local.set $2
+                br 2 (;@4;)
+              end
+            end
+          end
+        end
+      end
+      loop $label$9 ;; label = @2
+        local.get $2
+        i32.const 0
+        i32.gt_s
+        if ;; label = @3
+          block ;; label = @4
+            local.get $0
+            local.get $1
+            i32.load8_s
+            i32.store8
+            local.get $0
+            i32.const 1
+            i32.add
+            local.set $0
+            local.get $1
+            i32.const 1
+            i32.add
+            local.set $1
+            local.get $2
+            i32.const 1
+            i32.sub
+            local.set $2
+            br 2 (;@2;)
+          end
+        end
+      end
+      local.get $3
+    end
+  )
+  (func $43 (;56;) (type $3) (result i32)
+    i32.const 0
+  )
+  (func $44 (;57;) (type $4) (param $0 i32) (param $1 i32) (result i32)
+    local.get $1
+    local.get $0
+    i32.const 1
+    i32.and
+    i32.const 0
+    i32.add
+    call_indirect (type $1)
+  )
+  (func $45 (;58;) (type $12) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32)
+    local.get $1
+    local.get $2
+    local.get $3
+    local.get $0
+    i32.const 3
+    i32.and
+    i32.const 2
+    i32.add
+    call_indirect (type $0)
+  )
+  (func $46 (;59;) (type $5) (param $0 i32) (param $1 i32)
+    local.get $1
+    local.get $0
+    i32.const 1
+    i32.and
+    i32.const 6
+    i32.add
+    call_indirect (type $2)
+  )
+  (func $47 (;60;) (type $1) (param $0 i32) (result i32)
+    block $label$1 (result i32) ;; label = @1
+      i32.const 0
+      call $fimport$3
+      i32.const 0
+    end
+  )
+  (func $48 (;61;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    block $label$1 (result i32) ;; label = @1
+      i32.const 1
+      call $fimport$3
+      i32.const 0
+    end
+  )
+  (func $49 (;62;) (type $2) (param $0 i32)
+    i32.const 2
+    call $fimport$3
+  )
+  (global $global$0 (;5;) (mut i32) global.get $gimport$0)
+  (global $global$1 (;6;) (mut i32) global.get $gimport$1)
+  (global $global$2 (;7;) (mut i32) global.get $gimport$2)
+  (global $global$3 (;8;) (mut i32) i32.const 0)
+  (global $global$4 (;9;) (mut i32) i32.const 0)
+  (global $global$5 (;10;) (mut i32) i32.const 0)
+  (export "_sbrk" (func $40))
+  (export "_free" (func $38))
+  (export "_main" (func $8))
+  (export "_pthread_self" (func $43))
+  (export "_memset" (func $41))
+  (export "_malloc" (func $37))
+  (export "_memcpy" (func $42))
+  (export "___errno_location" (func $12))
+  (export "runPostSets" (func $39))
+  (export "stackAlloc" (func $0))
+  (export "stackSave" (func $1))
+  (export "stackRestore" (func $2))
+  (export "establishStackSpace" (func $3))
+  (export "setThrew" (func $4))
+  (export "setTempRet0" (func $5))
+  (export "getTempRet0" (func $6))
+  (export "dynCall_ii" (func $44))
+  (export "dynCall_iiii" (func $45))
+  (export "dynCall_vi" (func $46))
+  (elem (;0;) (global.get $gimport$19) func $47 $9 $48 $14 $10 $15 $49 $16)
+  (data (;0;) (i32.const 1024) "\04\04\00\00\05")
+  (data (;1;) (i32.const 1040) "\01")
+  (data (;2;) (i32.const 1064) "\01\00\00\00\02\00\00\00,\10\00\00\00\04")
+  (data (;3;) (i32.const 1088) "\01")
+  (data (;4;) (i32.const 1103) "\0a\ff\ff\ff\ff")
+  (data (;5;) (i32.const 1140) "error: %d\5cn\00ok\00\11\00\0a\00\11\11\11\00\00\00\00\05\00\00\00\00\00\00\09\00\00\00\00\0b")
+  (data (;6;) (i32.const 1187) "\11\00\0f\0a\11\11\11\03\0a\07\00\01\13\09\0b\0b\00\00\09\06\0b\00\00\0b\00\06\11\00\00\00\11\11\11")
+  (data (;7;) (i32.const 1236) "\0b")
+  (data (;8;) (i32.const 1245) "\11\00\0a\0a\11\11\11\00\0a\00\00\02\00\09\0b\00\00\00\09\00\0b\00\00\0b")
+  (data (;9;) (i32.const 1294) "\0c")
+  (data (;10;) (i32.const 1306) "\0c\00\00\00\00\0c\00\00\00\00\09\0c\00\00\00\00\00\0c\00\00\0c")
+  (data (;11;) (i32.const 1352) "\0e")
+  (data (;12;) (i32.const 1364) "\0d\00\00\00\04\0d\00\00\00\00\09\0e\00\00\00\00\00\0e\00\00\0e")
+  (data (;13;) (i32.const 1410) "\10")
+  (data (;14;) (i32.const 1422) "\0f\00\00\00\00\0f\00\00\00\00\09\10\00\00\00\00\00\10\00\00\10\00\00\12\00\00\00\12\12\12")
+  (data (;15;) (i32.const 1477) "\12\00\00\00\12\12\12\00\00\00\00\00\00\09")
+  (data (;16;) (i32.const 1526) "\0b")
+  (data (;17;) (i32.const 1538) "\0a\00\00\00\00\0a\00\00\00\00\09\0b\00\00\00\00\00\0b\00\00\0b")
+  (data (;18;) (i32.const 1584) "\0c")
+  (data (;19;) (i32.const 1596) "\0c\00\00\00\00\0c\00\00\00\00\09\0c\00\00\00\00\00\0c\00\00\0c\00\000123456789ABCDEF-+   0X0x\00(null)\00-0X+0X 0X-0x+0x 0x\00inf\00INF\00nan\00NAN\00.\00T!\22\19\0d\01\02\03\11K\1c\0c\10\04\0b\1d\12\1e'hnopqb \05\06\0f\13\14\15\1a\08\16\07($\17\18\09\0a\0e\1b\1f%#\83\82}&*+<=>?CGJMXYZ[\5c]^_`acdefgijklrstyz{|\00Illegal byte sequence\00Domain error\00Result not representable\00Not a tty\00Permission denied\00Operation not permitted\00No such file or directory\00No such process\00File exists\00Value too large for data type\00No space left on device\00Out of memory\00Resource busy\00Interrupted system call\00Resource temporarily unavailable\00Invalid seek\00Cross-device link\00Read-only file system\00Directory not empty\00Connection reset by peer\00Operation timed out\00Connection refused\00Host is down\00Host is unreachable\00Address in use\00Broken pipe\00I/O error\00No such device or address\00Block device required\00No such device\00Not a directory\00Is a directory\00Text file busy\00Exec format error\00Invalid argument\00Argument list too long\00Symbolic link loop\00Filename too long\00Too many open files in system\00No file descriptors available\00Bad file descriptor\00No child process\00Bad address\00File too large\00Too many links\00No locks available\00Resource deadlock would occur\00State not recoverable\00Previous owner died\00Operation canceled\00Function not implemented\00No message of desired type\00Identifier removed\00Device not a stream\00No data available\00Device timeout\00Out of streams resources\00Link has been severed\00Protocol error\00Bad message\00File descriptor in bad state\00Not a socket\00Destination address required\00Message too large\00Protocol wrong type for socket\00Protocol not available\00Protocol not supported\00Socket type not supported\00Not supported\00Protocol family not supported\00Address family not supported by protocol\00Address not available\00Network is down\00Network unreachable\00Connection reset by network\00Connection aborted\00No buffer space available\00Socket is connected\00Socket not connected\00Cannot send after socket shutdown\00Operation already in progress\00Operation in progress\00Stale file handle\00Remote I/O error\00Quota exceeded\00No medium found\00Wrong medium type\00No error information")
+)
diff --git a/tests/misc_testsuite/embenchen_primes.wast b/tests/misc_testsuite/embenchen_primes.wast
new file mode 100644
index 000000000000..dacdbe1f54bf
--- /dev/null
+++ b/tests/misc_testsuite/embenchen_primes.wast
@@ -0,0 +1,11211 @@
+;; copied from a historical cranelift-wasm test and provided here as proof that
+;; this still compiles on various platforms and such
+
+(module $env
+  (memory (export "memory") 2 2)
+  (table (export "table") 8 8 funcref)
+  (global (export "DYNAMICTOP_PTR") i32 i32.const 0)
+  (global (export "STACKTOP") i32 i32.const 0)
+  (global (export "STACK_MAX") i32 i32.const 0)
+  (global (export "memoryBase") i32 i32.const 0)
+  (global (export "tableBase") i32 i32.const 0)
+  (func (export "abort") (param i32))
+  (func (export "enlargeMemory") (result i32) unreachable)
+  (func (export "getTotalMemory") (result i32) unreachable)
+  (func (export "abortOnCannotGrowMemory") (result i32) unreachable)
+  (func (export "_pthread_cleanup_pop") (param i32))
+  (func (export "___syscall6") (param i32 i32) (result i32) unreachable)
+  (func (export "_pthread_cleanup_push") (param i32 i32))
+  (func (export "_abort"))
+  (func (export "___setErrNo") (param i32))
+  (func (export "_emscripten_memcpy_big") (param i32 i32 i32) (result i32) unreachable)
+  (func (export "___syscall54") (param i32 i32) (result i32) unreachable)
+  (func (export "___syscall140") (param i32 i32) (result i32) unreachable)
+  (func (export "___syscall146") (param i32 i32) (result i32) unreachable)
+)
+
+(module
+  (type $0 (;0;) (func (param i32 i32 i32) (result i32)))
+  (type $1 (;1;) (func (param i32) (result i32)))
+  (type $2 (;2;) (func (param i32)))
+  (type $3 (;3;) (func (result i32)))
+  (type $4 (;4;) (func (param i32 i32) (result i32)))
+  (type $5 (;5;) (func (param i32 i32)))
+  (type $6 (;6;) (func))
+  (type $7 (;7;) (func (param i32 i32 i32 i32 i32) (result i32)))
+  (type $8 (;8;) (func (param i32 i32 i32)))
+  (type $9 (;9;) (func (param i64 i32) (result i32)))
+  (type $10 (;10;) (func (param i32 i32 i32 i32 i32)))
+  (type $11 (;11;) (func (param f64 i32) (result f64)))
+  (type $12 (;12;) (func (param i32 i32 i32 i32) (result i32)))
+  (import "env" "memory" (memory $16 (;0;) 2 2))
+  (import "env" "table" (table $timport$17 (;0;) 8 8 funcref))
+  (import "env" "DYNAMICTOP_PTR" (global $gimport$0 (;0;) i32))
+  (import "env" "STACKTOP" (global $gimport$1 (;1;) i32))
+  (import "env" "STACK_MAX" (global $gimport$2 (;2;) i32))
+  (import "env" "memoryBase" (global $gimport$18 (;3;) i32))
+  (import "env" "tableBase" (global $gimport$19 (;4;) i32))
+  (import "env" "abort" (func $fimport$3 (;0;) (type $2)))
+  (import "env" "enlargeMemory" (func $fimport$4 (;1;) (type $3)))
+  (import "env" "getTotalMemory" (func $fimport$5 (;2;) (type $3)))
+  (import "env" "abortOnCannotGrowMemory" (func $fimport$6 (;3;) (type $3)))
+  (import "env" "_pthread_cleanup_pop" (func $fimport$7 (;4;) (type $2)))
+  (import "env" "___syscall6" (func $fimport$8 (;5;) (type $4)))
+  (import "env" "_pthread_cleanup_push" (func $fimport$9 (;6;) (type $5)))
+  (import "env" "_abort" (func $fimport$10 (;7;) (type $6)))
+  (import "env" "___setErrNo" (func $fimport$11 (;8;) (type $2)))
+  (import "env" "_emscripten_memcpy_big" (func $fimport$12 (;9;) (type $0)))
+  (import "env" "___syscall54" (func $fimport$13 (;10;) (type $4)))
+  (import "env" "___syscall140" (func $fimport$14 (;11;) (type $4)))
+  (import "env" "___syscall146" (func $fimport$15 (;12;) (type $4)))
+  (func $0 (;13;) (type $1) (param $0 i32) (result i32)
+    (local $1 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $1
+      global.get $global$1
+      local.get $0
+      i32.add
+      global.set $global$1
+      global.get $global$1
+      i32.const 15
+      i32.add
+      i32.const -16
+      i32.and
+      global.set $global$1
+      local.get $1
+    end
+  )
+  (func $1 (;14;) (type $3) (result i32)
+    global.get $global$1
+  )
+  (func $2 (;15;) (type $2) (param $0 i32)
+    local.get $0
+    global.set $global$1
+  )
+  (func $3 (;16;) (type $5) (param $0 i32) (param $1 i32)
+    block $label$1 ;; label = @1
+      local.get $0
+      global.set $global$1
+      local.get $1
+      global.set $global$2
+    end
+  )
+  (func $4 (;17;) (type $5) (param $0 i32) (param $1 i32)
+    global.get $global$3
+    i32.eqz
+    if ;; label = @1
+      block ;; label = @2
+        local.get $0
+        global.set $global$3
+        local.get $1
+        global.set $global$4
+      end
+    end
+  )
+  (func $5 (;18;) (type $2) (param $0 i32)
+    local.get $0
+    global.set $global$5
+  )
+  (func $6 (;19;) (type $3) (result i32)
+    global.get $global$5
+  )
+  (func $7 (;20;) (type $4) (param $0 i32) (param $1 i32) (result i32)
+    (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 f32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $3
+      global.get $global$1
+      i32.const 16
+      i32.add
+      global.set $global$1
+      local.get $3
+      i32.const 8
+      i32.add
+      local.set $5
+      local.get $3
+      local.set $2
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          local.get $0
+          i32.const 1
+          i32.le_s
+          br_if 0 (;@3;)
+          block $label$4 ;; label = @4
+            block $label$5 ;; label = @5
+              block $label$6 ;; label = @6
+                block $label$7 ;; label = @7
+                  block $label$8 ;; label = @8
+                    block $label$9 ;; label = @9
+                      block $label$10 ;; label = @10
+                        local.get $1
+                        i32.load offset=4
+                        i32.load8_s
+                        local.tee $0
+                        i32.const 48
+                        i32.sub
+                        br_table 5 (;@5;) 0 (;@10;) 2 (;@8;) 1 (;@9;) 3 (;@7;) 4 (;@6;) 6 (;@4;)
+                      end
+                      i32.const 33000
+                      local.set $4
+                      br 7 (;@2;)
+                    end
+                    br 5 (;@3;)
+                  end
+                  i32.const 130000
+                  local.set $4
+                  br 5 (;@2;)
+                end
+                i32.const 610000
+                local.set $4
+                br 4 (;@2;)
+              end
+              i32.const 1010000
+              local.set $4
+              br 3 (;@2;)
+            end
+            local.get $3
+            global.set $global$1
+            i32.const 0
+            return
+          end
+          local.get $2
+          local.get $0
+          i32.const -48
+          i32.add
+          i32.store
+          i32.const 1140
+          local.get $2
+          call $30
+          drop
+          local.get $3
+          global.set $global$1
+          i32.const -1
+          return
+        end
+        i32.const 220000
+        local.set $4
+      end
+      i32.const 2
+      local.set $1
+      i32.const 0
+      local.set $0
+      loop $label$11 ;; label = @2
+        block $label$12 ;; label = @3
+          block $label$13 ;; label = @4
+            local.get $1
+            f32.convert_i32_s
+            f32.sqrt
+            local.tee $6
+            f32.const 0x1p+1 (;=2;)
+            f32.gt
+            i32.eqz
+            br_if 0 (;@4;)
+            i32.const 2
+            local.set $2
+            loop $label$14 ;; label = @5
+              local.get $1
+              local.get $2
+              i32.rem_s
+              i32.eqz
+              br_if 2 (;@3;)
+              local.get $2
+              i32.const 1
+              i32.add
+              local.tee $2
+              f32.convert_i32_s
+              local.get $6
+              f32.lt
+              br_if 0 (;@5;)
+              br 1 (;@4;)
+            end
+          end
+          local.get $0
+          i32.const 1
+          i32.add
+          local.set $0
+        end
+        local.get $1
+        i32.const 1
+        i32.add
+        local.set $2
+        local.get $0
+        local.get $4
+        i32.lt_s
+        if ;; label = @3
+          block ;; label = @4
+            local.get $2
+            local.set $1
+            br 2 (;@2;)
+          end
+        end
+      end
+      local.get $5
+      local.get $1
+      i32.store
+      i32.const 1152
+      local.get $5
+      call $30
+      drop
+      local.get $3
+      global.set $global$1
+      i32.const 0
+    end
+  )
+  (func $8 (;21;) (type $1) (param $0 i32) (result i32)
+    (local $1 i32) (local $2 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $1
+      global.get $global$1
+      i32.const 16
+      i32.add
+      global.set $global$1
+      local.get $1
+      local.tee $2
+      local.get $0
+      i32.load offset=60
+      i32.store
+      i32.const 6
+      local.get $2
+      call $fimport$8
+      call $10
+      local.set $0
+      local.get $1
+      global.set $global$1
+      local.get $0
+    end
+  )
+  (func $9 (;22;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32) (local $4 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $4
+      global.get $global$1
+      i32.const 32
+      i32.add
+      global.set $global$1
+      local.get $4
+      local.tee $3
+      local.get $0
+      i32.load offset=60
+      i32.store
+      local.get $3
+      i32.const 0
+      i32.store offset=4
+      local.get $3
+      local.get $1
+      i32.store offset=8
+      local.get $3
+      local.get $4
+      i32.const 20
+      i32.add
+      local.tee $0
+      i32.store offset=12
+      local.get $3
+      local.get $2
+      i32.store offset=16
+      i32.const 140
+      local.get $3
+      call $fimport$14
+      call $10
+      i32.const 0
+      i32.lt_s
+      if (result i32) ;; label = @2
+        block (result i32) ;; label = @3
+          local.get $0
+          i32.const -1
+          i32.store
+          i32.const -1
+        end
+      else
+        local.get $0
+        i32.load
+      end
+      local.set $0
+      local.get $4
+      global.set $global$1
+      local.get $0
+    end
+  )
+  (func $10 (;23;) (type $1) (param $0 i32) (result i32)
+    local.get $0
+    i32.const -4096
+    i32.gt_u
+    if (result i32) ;; label = @1
+      block (result i32) ;; label = @2
+        call $11
+        i32.const 0
+        local.get $0
+        i32.sub
+        i32.store
+        i32.const -1
+      end
+    else
+      local.get $0
+    end
+  )
+  (func $11 (;24;) (type $3) (result i32)
+    i32.const 3640
+  )
+  (func $12 (;25;) (type $2) (param $0 i32)
+    nop
+  )
+  (func $13 (;26;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32) (local $4 i32) (local $5 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $4
+      global.get $global$1
+      i32.const 80
+      i32.add
+      global.set $global$1
+      local.get $4
+      local.set $3
+      local.get $4
+      i32.const 12
+      i32.add
+      local.set $5
+      local.get $0
+      i32.const 3
+      i32.store offset=36
+      local.get $0
+      i32.load
+      i32.const 64
+      i32.and
+      i32.eqz
+      if ;; label = @2
+        block ;; label = @3
+          local.get $3
+          local.get $0
+          i32.load offset=60
+          i32.store
+          local.get $3
+          i32.const 21505
+          i32.store offset=4
+          local.get $3
+          local.get $5
+          i32.store offset=8
+          i32.const 54
+          local.get $3
+          call $fimport$13
+          if ;; label = @4
+            local.get $0
+            i32.const -1
+            i32.store8 offset=75
+          end
+        end
+      end
+      local.get $0
+      local.get $1
+      local.get $2
+      call $14
+      local.set $0
+      local.get $4
+      global.set $global$1
+      local.get $0
+    end
+  )
+  (func $14 (;27;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $8
+      global.get $global$1
+      i32.const 48
+      i32.add
+      global.set $global$1
+      local.get $8
+      i32.const 16
+      i32.add
+      local.set $9
+      local.get $8
+      local.set $10
+      local.get $8
+      i32.const 32
+      i32.add
+      local.tee $3
+      local.get $0
+      i32.const 28
+      i32.add
+      local.tee $6
+      i32.load
+      local.tee $4
+      i32.store
+      local.get $3
+      local.get $0
+      i32.const 20
+      i32.add
+      local.tee $11
+      i32.load
+      local.get $4
+      i32.sub
+      local.tee $5
+      i32.store offset=4
+      local.get $3
+      local.get $1
+      i32.store offset=8
+      local.get $3
+      local.get $2
+      i32.store offset=12
+      local.get $0
+      i32.const 60
+      i32.add
+      local.set $13
+      local.get $0
+      i32.const 44
+      i32.add
+      local.set $14
+      local.get $3
+      local.set $1
+      i32.const 2
+      local.set $4
+      local.get $5
+      local.get $2
+      i32.add
+      local.set $12
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          block $label$4 ;; label = @4
+            loop $label$5 ;; label = @5
+              i32.const 3596
+              i32.load
+              if ;; label = @6
+                block ;; label = @7
+                  i32.const 1
+                  local.get $0
+                  call $fimport$9
+                  local.get $10
+                  local.get $13
+                  i32.load
+                  i32.store
+                  local.get $10
+                  local.get $1
+                  i32.store offset=4
+                  local.get $10
+                  local.get $4
+                  i32.store offset=8
+                  i32.const 146
+                  local.get $10
+                  call $fimport$15
+                  call $10
+                  local.set $3
+                  i32.const 0
+                  call $fimport$7
+                end
+              else
+                block ;; label = @7
+                  local.get $9
+                  local.get $13
+                  i32.load
+                  i32.store
+                  local.get $9
+                  local.get $1
+                  i32.store offset=4
+                  local.get $9
+                  local.get $4
+                  i32.store offset=8
+                  i32.const 146
+                  local.get $9
+                  call $fimport$15
+                  call $10
+                  local.set $3
+                end
+              end
+              local.get $12
+              local.get $3
+              i32.eq
+              br_if 1 (;@4;)
+              local.get $3
+              i32.const 0
+              i32.lt_s
+              br_if 2 (;@3;)
+              local.get $3
+              local.get $1
+              i32.load offset=4
+              local.tee $5
+              i32.gt_u
+              if (result i32) ;; label = @6
+                block (result i32) ;; label = @7
+                  local.get $6
+                  local.get $14
+                  i32.load
+                  local.tee $7
+                  i32.store
+                  local.get $11
+                  local.get $7
+                  i32.store
+                  local.get $1
+                  i32.load offset=12
+                  local.set $7
+                  local.get $1
+                  i32.const 8
+                  i32.add
+                  local.set $1
+                  local.get $4
+                  i32.const -1
+                  i32.add
+                  local.set $4
+                  local.get $3
+                  local.get $5
+                  i32.sub
+                end
+              else
+                local.get $4
+                i32.const 2
+                i32.eq
+                if (result i32) ;; label = @7
+                  block (result i32) ;; label = @8
+                    local.get $6
+                    local.get $6
+                    i32.load
+                    local.get $3
+                    i32.add
+                    i32.store
+                    local.get $5
+                    local.set $7
+                    i32.const 2
+                    local.set $4
+                    local.get $3
+                  end
+                else
+                  block (result i32) ;; label = @8
+                    local.get $5
+                    local.set $7
+                    local.get $3
+                  end
+                end
+              end
+              local.set $5
+              local.get $1
+              local.get $1
+              i32.load
+              local.get $5
+              i32.add
+              i32.store
+              local.get $1
+              local.get $7
+              local.get $5
+              i32.sub
+              i32.store offset=4
+              local.get $12
+              local.get $3
+              i32.sub
+              local.set $12
+              br 0 (;@5;)
+            end
+          end
+          local.get $0
+          local.get $14
+          i32.load
+          local.tee $1
+          local.get $0
+          i32.load offset=48
+          i32.add
+          i32.store offset=16
+          local.get $6
+          local.get $1
+          i32.store
+          local.get $11
+          local.get $1
+          i32.store
+          br 1 (;@2;)
+        end
+        local.get $0
+        i32.const 0
+        i32.store offset=16
+        local.get $6
+        i32.const 0
+        i32.store
+        local.get $11
+        i32.const 0
+        i32.store
+        local.get $0
+        local.get $0
+        i32.load
+        i32.const 32
+        i32.or
+        i32.store
+        local.get $4
+        i32.const 2
+        i32.eq
+        if (result i32) ;; label = @3
+          i32.const 0
+        else
+          local.get $2
+          local.get $1
+          i32.load offset=4
+          i32.sub
+        end
+        local.set $2
+      end
+      local.get $8
+      global.set $global$1
+      local.get $2
+    end
+  )
+  (func $15 (;28;) (type $2) (param $0 i32)
+    local.get $0
+    i32.load offset=68
+    i32.eqz
+    if ;; label = @1
+      local.get $0
+      call $12
+    end
+  )
+  (func $16 (;29;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32) (local $4 i32) (local $5 i32)
+    block $label$1 (result i32) ;; label = @1
+      local.get $1
+      i32.const 255
+      i32.and
+      local.set $5
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          block $label$4 ;; label = @4
+            local.get $2
+            i32.const 0
+            i32.ne
+            local.tee $4
+            local.get $0
+            i32.const 3
+            i32.and
+            i32.const 0
+            i32.ne
+            i32.and
+            if ;; label = @5
+              block ;; label = @6
+                local.get $1
+                i32.const 255
+                i32.and
+                local.set $4
+                local.get $2
+                local.set $3
+                local.get $0
+                local.set $2
+                loop $label$6 ;; label = @7
+                  local.get $2
+                  i32.load8_s
+                  local.get $4
+                  i32.const 24
+                  i32.shl
+                  i32.const 24
+                  i32.shr_s
+                  i32.eq
+                  if ;; label = @8
+                    block ;; label = @9
+                      local.get $3
+                      local.set $0
+                      br 6 (;@3;)
+                    end
+                  end
+                  local.get $3
+                  i32.const -1
+                  i32.add
+                  local.tee $3
+                  i32.const 0
+                  i32.ne
+                  local.tee $0
+                  local.get $2
+                  i32.const 1
+                  i32.add
+                  local.tee $2
+                  i32.const 3
+                  i32.and
+                  i32.const 0
+                  i32.ne
+                  i32.and
+                  br_if 0 (;@7;)
+                  br 3 (;@4;)
+                end
+              end
+            else
+              block ;; label = @6
+                local.get $2
+                local.set $3
+                local.get $0
+                local.set $2
+                local.get $4
+                local.set $0
+              end
+            end
+          end
+          local.get $0
+          if ;; label = @4
+            block ;; label = @5
+              local.get $3
+              local.set $0
+              br 2 (;@3;)
+            end
+          else
+            i32.const 0
+            local.set $0
+          end
+          br 1 (;@2;)
+        end
+        local.get $2
+        i32.load8_s
+        local.get $1
+        i32.const 255
+        i32.and
+        local.tee $1
+        i32.const 24
+        i32.shl
+        i32.const 24
+        i32.shr_s
+        i32.ne
+        if ;; label = @3
+          block ;; label = @4
+            local.get $5
+            i32.const 16843009
+            i32.mul
+            local.set $3
+            block $label$12 ;; label = @5
+              block $label$13 ;; label = @6
+                local.get $0
+                i32.const 3
+                i32.le_u
+                br_if 0 (;@6;)
+                loop $label$14 ;; label = @7
+                  local.get $2
+                  i32.load
+                  local.get $3
+                  i32.xor
+                  local.tee $4
+                  i32.const -2139062144
+                  i32.and
+                  i32.const -2139062144
+                  i32.xor
+                  local.get $4
+                  i32.const -16843009
+                  i32.add
+                  i32.and
+                  i32.eqz
+                  if ;; label = @8
+                    block ;; label = @9
+                      local.get $2
+                      i32.const 4
+                      i32.add
+                      local.set $2
+                      local.get $0
+                      i32.const -4
+                      i32.add
+                      local.tee $0
+                      i32.const 3
+                      i32.gt_u
+                      br_if 2 (;@7;)
+                      br 3 (;@6;)
+                    end
+                  end
+                end
+                br 1 (;@5;)
+              end
+              local.get $0
+              i32.eqz
+              if ;; label = @6
+                block ;; label = @7
+                  i32.const 0
+                  local.set $0
+                  br 5 (;@2;)
+                end
+              end
+            end
+            loop $label$17 ;; label = @5
+              local.get $2
+              i32.load8_s
+              local.get $1
+              i32.const 24
+              i32.shl
+              i32.const 24
+              i32.shr_s
+              i32.eq
+              br_if 3 (;@2;)
+              local.get $2
+              i32.const 1
+              i32.add
+              local.set $2
+              local.get $0
+              i32.const -1
+              i32.add
+              local.tee $0
+              br_if 0 (;@5;)
+              i32.const 0
+              local.set $0
+            end
+          end
+        end
+      end
+      local.get $0
+      if (result i32) ;; label = @2
+        local.get $2
+      else
+        i32.const 0
+      end
+    end
+  )
+  (func $17 (;30;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $4
+      global.get $global$1
+      i32.const 224
+      i32.add
+      global.set $global$1
+      local.get $4
+      i32.const 136
+      i32.add
+      local.set $5
+      local.get $4
+      i32.const 80
+      i32.add
+      local.tee $3
+      i64.const 0
+      i64.store align=4
+      local.get $3
+      i64.const 0
+      i64.store offset=8 align=4
+      local.get $3
+      i64.const 0
+      i64.store offset=16 align=4
+      local.get $3
+      i64.const 0
+      i64.store offset=24 align=4
+      local.get $3
+      i64.const 0
+      i64.store offset=32 align=4
+      local.get $4
+      i32.const 120
+      i32.add
+      local.tee $6
+      local.get $2
+      i32.load
+      i32.store
+      i32.const 0
+      local.get $1
+      local.get $6
+      local.get $4
+      local.tee $2
+      local.get $3
+      call $18
+      i32.const 0
+      i32.lt_s
+      if ;; label = @2
+        i32.const -1
+        local.set $1
+      else
+        block ;; label = @3
+          local.get $0
+          i32.load offset=76
+          i32.const -1
+          i32.gt_s
+          if (result i32) ;; label = @4
+            local.get $0
+            call $19
+          else
+            i32.const 0
+          end
+          local.set $12
+          local.get $0
+          i32.load
+          local.set $7
+          local.get $0
+          i32.load8_s offset=74
+          i32.const 1
+          i32.lt_s
+          if ;; label = @4
+            local.get $0
+            local.get $7
+            i32.const -33
+            i32.and
+            i32.store
+          end
+          local.get $0
+          i32.const 48
+          i32.add
+          local.tee $8
+          i32.load
+          if ;; label = @4
+            local.get $0
+            local.get $1
+            local.get $6
+            local.get $2
+            local.get $3
+            call $18
+            local.set $1
+          else
+            block ;; label = @5
+              local.get $0
+              i32.const 44
+              i32.add
+              local.tee $9
+              i32.load
+              local.set $10
+              local.get $9
+              local.get $5
+              i32.store
+              local.get $0
+              i32.const 28
+              i32.add
+              local.tee $13
+              local.get $5
+              i32.store
+              local.get $0
+              i32.const 20
+              i32.add
+              local.tee $11
+              local.get $5
+              i32.store
+              local.get $8
+              i32.const 80
+              i32.store
+              local.get $0
+              i32.const 16
+              i32.add
+              local.tee $14
+              local.get $5
+              i32.const 80
+              i32.add
+              i32.store
+              local.get $0
+              local.get $1
+              local.get $6
+              local.get $2
+              local.get $3
+              call $18
+              local.set $1
+              local.get $10
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $0
+                  i32.const 0
+                  i32.const 0
+                  local.get $0
+                  i32.load offset=36
+                  i32.const 3
+                  i32.and
+                  i32.const 2
+                  i32.add
+                  call_indirect (type $0)
+                  drop
+                  local.get $11
+                  i32.load
+                  i32.eqz
+                  if ;; label = @8
+                    i32.const -1
+                    local.set $1
+                  end
+                  local.get $9
+                  local.get $10
+                  i32.store
+                  local.get $8
+                  i32.const 0
+                  i32.store
+                  local.get $14
+                  i32.const 0
+                  i32.store
+                  local.get $13
+                  i32.const 0
+                  i32.store
+                  local.get $11
+                  i32.const 0
+                  i32.store
+                end
+              end
+            end
+          end
+          local.get $0
+          local.get $0
+          i32.load
+          local.tee $2
+          local.get $7
+          i32.const 32
+          i32.and
+          i32.or
+          i32.store
+          local.get $12
+          if ;; label = @4
+            local.get $0
+            call $12
+          end
+          local.get $2
+          i32.const 32
+          i32.and
+          if ;; label = @4
+            i32.const -1
+            local.set $1
+          end
+        end
+      end
+      local.get $4
+      global.set $global$1
+      local.get $1
+    end
+  )
+  (func $18 (;31;) (type $7) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32) (result i32)
+    (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32) (local $15 i32) (local $16 i32) (local $17 i32) (local $18 i32) (local $19 i32) (local $20 i32) (local $21 i32) (local $22 i32) (local $23 i32) (local $24 i32) (local $25 i32) (local $26 i32) (local $27 i32) (local $28 i32) (local $29 i32) (local $30 i32) (local $31 i32) (local $32 i32) (local $33 i32) (local $34 i32) (local $35 i32) (local $36 i32) (local $37 i32) (local $38 i32) (local $39 i32) (local $40 i32) (local $41 i32) (local $42 i32) (local $43 i32) (local $44 i32) (local $45 i32) (local $46 i32) (local $47 i32) (local $48 i32) (local $49 i32) (local $50 i64) (local $51 i64) (local $52 f64) (local $53 f64)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $23
+      global.get $global$1
+      i32.const 624
+      i32.add
+      global.set $global$1
+      local.get $23
+      i32.const 16
+      i32.add
+      local.set $20
+      local.get $23
+      local.set $16
+      local.get $23
+      i32.const 528
+      i32.add
+      local.set $36
+      local.get $0
+      i32.const 0
+      i32.ne
+      local.set $30
+      local.get $23
+      i32.const 536
+      i32.add
+      local.tee $17
+      i32.const 40
+      i32.add
+      local.tee $21
+      local.set $38
+      local.get $17
+      i32.const 39
+      i32.add
+      local.set $39
+      local.get $23
+      i32.const 8
+      i32.add
+      local.tee $37
+      i32.const 4
+      i32.add
+      local.set $42
+      i32.const 0
+      local.get $23
+      i32.const 588
+      i32.add
+      local.tee $19
+      local.tee $27
+      i32.sub
+      local.set $43
+      local.get $23
+      i32.const 576
+      i32.add
+      local.tee $17
+      i32.const 12
+      i32.add
+      local.set $33
+      local.get $17
+      i32.const 11
+      i32.add
+      local.set $40
+      local.get $33
+      local.tee $28
+      local.get $27
+      i32.sub
+      local.set $44
+      i32.const -2
+      local.get $27
+      i32.sub
+      local.set $45
+      local.get $28
+      i32.const 2
+      i32.add
+      local.set $46
+      local.get $23
+      i32.const 24
+      i32.add
+      local.tee $47
+      i32.const 288
+      i32.add
+      local.set $48
+      local.get $19
+      i32.const 9
+      i32.add
+      local.tee $31
+      local.set $41
+      local.get $19
+      i32.const 8
+      i32.add
+      local.set $34
+      i32.const 0
+      local.set $15
+      i32.const 0
+      local.set $10
+      i32.const 0
+      local.set $17
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          loop $label$4 ;; label = @4
+            block $label$5 ;; label = @5
+              local.get $15
+              i32.const -1
+              i32.gt_s
+              if ;; label = @6
+                local.get $10
+                i32.const 2147483647
+                local.get $15
+                i32.sub
+                i32.gt_s
+                if (result i32) ;; label = @7
+                  block (result i32) ;; label = @8
+                    call $11
+                    i32.const 75
+                    i32.store
+                    i32.const -1
+                  end
+                else
+                  local.get $10
+                  local.get $15
+                  i32.add
+                end
+                local.set $15
+              end
+              local.get $1
+              i32.load8_s
+              local.tee $5
+              i32.const 24
+              i32.shl
+              i32.const 24
+              i32.shr_s
+              i32.eqz
+              br_if 2 (;@3;)
+              local.get $1
+              local.set $11
+              block $label$9 ;; label = @6
+                block $label$10 ;; label = @7
+                  loop $label$11 ;; label = @8
+                    block $label$12 ;; label = @9
+                      block $label$13 ;; label = @10
+                        block $label$14 ;; label = @11
+                          block $label$15 ;; label = @12
+                            local.get $5
+                            i32.const 24
+                            i32.shl
+                            i32.const 24
+                            i32.shr_s
+                            i32.const 0
+                            i32.sub
+                            br_table 1 (;@11;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 2 (;@10;) 0 (;@12;) 2 (;@10;)
+                          end
+                          local.get $11
+                          local.set $5
+                          br 4 (;@7;)
+                        end
+                        local.get $11
+                        local.set $5
+                        br 1 (;@9;)
+                      end
+                      local.get $11
+                      i32.const 1
+                      i32.add
+                      local.tee $11
+                      i32.load8_s
+                      local.set $5
+                      br 1 (;@8;)
+                    end
+                  end
+                  br 1 (;@6;)
+                end
+                loop $label$16 ;; label = @7
+                  local.get $5
+                  i32.load8_s offset=1
+                  i32.const 37
+                  i32.ne
+                  br_if 1 (;@6;)
+                  local.get $11
+                  i32.const 1
+                  i32.add
+                  local.set $11
+                  local.get $5
+                  i32.const 2
+                  i32.add
+                  local.tee $5
+                  i32.load8_s
+                  i32.const 37
+                  i32.eq
+                  br_if 0 (;@7;)
+                end
+              end
+              local.get $11
+              local.get $1
+              i32.sub
+              local.set $10
+              local.get $30
+              if ;; label = @6
+                local.get $0
+                i32.load
+                i32.const 32
+                i32.and
+                i32.eqz
+                if ;; label = @7
+                  local.get $1
+                  local.get $10
+                  local.get $0
+                  call $20
+                  drop
+                end
+              end
+              local.get $10
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $5
+                  local.set $1
+                  br 3 (;@4;)
+                end
+              end
+              local.get $5
+              i32.const 1
+              i32.add
+              local.tee $11
+              i32.load8_s
+              local.tee $10
+              i32.const 24
+              i32.shl
+              i32.const 24
+              i32.shr_s
+              i32.const -48
+              i32.add
+              local.tee $9
+              i32.const 10
+              i32.lt_u
+              if (result i32) ;; label = @6
+                block (result i32) ;; label = @7
+                  local.get $5
+                  i32.const 3
+                  i32.add
+                  local.set $10
+                  local.get $5
+                  i32.load8_s offset=2
+                  i32.const 36
+                  i32.eq
+                  local.tee $12
+                  if ;; label = @8
+                    local.get $10
+                    local.set $11
+                  end
+                  local.get $12
+                  if ;; label = @8
+                    i32.const 1
+                    local.set $17
+                  end
+                  local.get $11
+                  i32.load8_s
+                  local.set $5
+                  local.get $12
+                  i32.eqz
+                  if ;; label = @8
+                    i32.const -1
+                    local.set $9
+                  end
+                  local.get $17
+                end
+              else
+                block (result i32) ;; label = @7
+                  local.get $10
+                  local.set $5
+                  i32.const -1
+                  local.set $9
+                  local.get $17
+                end
+              end
+              local.set $10
+              block $label$25 ;; label = @6
+                local.get $5
+                i32.const 24
+                i32.shl
+                i32.const 24
+                i32.shr_s
+                i32.const -32
+                i32.add
+                local.tee $12
+                i32.const 32
+                i32.lt_u
+                if ;; label = @7
+                  block ;; label = @8
+                    i32.const 0
+                    local.set $17
+                    loop $label$27 ;; label = @9
+                      i32.const 1
+                      local.get $12
+                      i32.shl
+                      i32.const 75913
+                      i32.and
+                      i32.eqz
+                      br_if 3 (;@6;)
+                      i32.const 1
+                      local.get $5
+                      i32.const 24
+                      i32.shl
+                      i32.const 24
+                      i32.shr_s
+                      i32.const -32
+                      i32.add
+                      i32.shl
+                      local.get $17
+                      i32.or
+                      local.set $17
+                      local.get $11
+                      i32.const 1
+                      i32.add
+                      local.tee $11
+                      i32.load8_s
+                      local.tee $5
+                      i32.const 24
+                      i32.shl
+                      i32.const 24
+                      i32.shr_s
+                      i32.const -32
+                      i32.add
+                      local.tee $12
+                      i32.const 32
+                      i32.lt_u
+                      br_if 0 (;@9;)
+                    end
+                  end
+                else
+                  i32.const 0
+                  local.set $17
+                end
+              end
+              block $label$29 ;; label = @6
+                local.get $5
+                i32.const 24
+                i32.shl
+                i32.const 24
+                i32.shr_s
+                i32.const 42
+                i32.eq
+                if ;; label = @7
+                  block ;; label = @8
+                    block $label$31 (result i32) ;; label = @9
+                      block $label$32 ;; label = @10
+                        local.get $11
+                        i32.const 1
+                        i32.add
+                        local.tee $7
+                        i32.load8_s
+                        local.tee $5
+                        i32.const 24
+                        i32.shl
+                        i32.const 24
+                        i32.shr_s
+                        i32.const -48
+                        i32.add
+                        local.tee $12
+                        i32.const 10
+                        i32.ge_u
+                        br_if 0 (;@10;)
+                        local.get $11
+                        i32.load8_s offset=2
+                        i32.const 36
+                        i32.ne
+                        br_if 0 (;@10;)
+                        local.get $4
+                        local.get $12
+                        i32.const 2
+                        i32.shl
+                        i32.add
+                        i32.const 10
+                        i32.store
+                        i32.const 1
+                        local.set $8
+                        local.get $3
+                        local.get $7
+                        i32.load8_s
+                        i32.const -48
+                        i32.add
+                        i32.const 3
+                        i32.shl
+                        i32.add
+                        i64.load
+                        i32.wrap_i64
+                        local.set $10
+                        local.get $11
+                        i32.const 3
+                        i32.add
+                        br 1 (;@9;)
+                      end
+                      local.get $10
+                      if ;; label = @10
+                        block ;; label = @11
+                          i32.const -1
+                          local.set $15
+                          br 6 (;@5;)
+                        end
+                      end
+                      local.get $30
+                      i32.eqz
+                      if ;; label = @10
+                        block ;; label = @11
+                          local.get $17
+                          local.set $12
+                          i32.const 0
+                          local.set $17
+                          local.get $7
+                          local.set $11
+                          i32.const 0
+                          local.set $10
+                          br 5 (;@6;)
+                        end
+                      end
+                      local.get $2
+                      i32.load
+                      i32.const 3
+                      i32.add
+                      i32.const -4
+                      i32.and
+                      local.tee $11
+                      i32.load
+                      local.set $10
+                      local.get $2
+                      local.get $11
+                      i32.const 4
+                      i32.add
+                      i32.store
+                      i32.const 0
+                      local.set $8
+                      local.get $7
+                    end
+                    local.set $11
+                    local.get $17
+                    i32.const 8192
+                    i32.or
+                    local.set $12
+                    i32.const 0
+                    local.get $10
+                    i32.sub
+                    local.set $7
+                    local.get $11
+                    i32.load8_s
+                    local.set $5
+                    local.get $10
+                    i32.const 0
+                    i32.lt_s
+                    local.tee $6
+                    i32.eqz
+                    if ;; label = @9
+                      local.get $17
+                      local.set $12
+                    end
+                    local.get $8
+                    local.set $17
+                    local.get $6
+                    if ;; label = @9
+                      local.get $7
+                      local.set $10
+                    end
+                  end
+                else
+                  local.get $5
+                  i32.const 24
+                  i32.shl
+                  i32.const 24
+                  i32.shr_s
+                  i32.const -48
+                  i32.add
+                  local.tee $12
+                  i32.const 10
+                  i32.lt_u
+                  if ;; label = @8
+                    block ;; label = @9
+                      i32.const 0
+                      local.set $7
+                      local.get $12
+                      local.set $5
+                      loop $label$39 ;; label = @10
+                        local.get $7
+                        i32.const 10
+                        i32.mul
+                        local.get $5
+                        i32.add
+                        local.set $7
+                        local.get $11
+                        i32.const 1
+                        i32.add
+                        local.tee $11
+                        i32.load8_s
+                        local.tee $12
+                        i32.const 24
+                        i32.shl
+                        i32.const 24
+                        i32.shr_s
+                        i32.const -48
+                        i32.add
+                        local.tee $5
+                        i32.const 10
+                        i32.lt_u
+                        br_if 0 (;@10;)
+                      end
+                      local.get $7
+                      i32.const 0
+                      i32.lt_s
+                      if ;; label = @10
+                        block ;; label = @11
+                          i32.const -1
+                          local.set $15
+                          br 6 (;@5;)
+                        end
+                      else
+                        block ;; label = @11
+                          local.get $12
+                          local.set $5
+                          local.get $17
+                          local.set $12
+                          local.get $10
+                          local.set $17
+                          local.get $7
+                          local.set $10
+                        end
+                      end
+                    end
+                  else
+                    block ;; label = @9
+                      local.get $17
+                      local.set $12
+                      local.get $10
+                      local.set $17
+                      i32.const 0
+                      local.set $10
+                    end
+                  end
+                end
+              end
+              block $label$43 ;; label = @6
+                local.get $5
+                i32.const 24
+                i32.shl
+                i32.const 24
+                i32.shr_s
+                i32.const 46
+                i32.eq
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $11
+                    i32.const 1
+                    i32.add
+                    local.tee $7
+                    i32.load8_s
+                    local.tee $5
+                    i32.const 24
+                    i32.shl
+                    i32.const 24
+                    i32.shr_s
+                    i32.const 42
+                    i32.ne
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $5
+                        i32.const 24
+                        i32.shl
+                        i32.const 24
+                        i32.shr_s
+                        i32.const -48
+                        i32.add
+                        local.tee $5
+                        i32.const 10
+                        i32.lt_u
+                        if ;; label = @11
+                          block ;; label = @12
+                            local.get $7
+                            local.set $11
+                            i32.const 0
+                            local.set $7
+                          end
+                        else
+                          block ;; label = @12
+                            i32.const 0
+                            local.set $5
+                            local.get $7
+                            local.set $11
+                            br 6 (;@6;)
+                          end
+                        end
+                        loop $label$48 ;; label = @11
+                          local.get $7
+                          i32.const 10
+                          i32.mul
+                          local.get $5
+                          i32.add
+                          local.set $5
+                          local.get $11
+                          i32.const 1
+                          i32.add
+                          local.tee $11
+                          i32.load8_s
+                          i32.const -48
+                          i32.add
+                          local.tee $8
+                          i32.const 10
+                          i32.ge_u
+                          br_if 5 (;@6;)
+                          local.get $5
+                          local.set $7
+                          local.get $8
+                          local.set $5
+                          br 0 (;@11;)
+                        end
+                      end
+                    end
+                    local.get $11
+                    i32.const 2
+                    i32.add
+                    local.tee $7
+                    i32.load8_s
+                    i32.const -48
+                    i32.add
+                    local.tee $5
+                    i32.const 10
+                    i32.lt_u
+                    if ;; label = @9
+                      local.get $11
+                      i32.load8_s offset=3
+                      i32.const 36
+                      i32.eq
+                      if ;; label = @10
+                        block ;; label = @11
+                          local.get $4
+                          local.get $5
+                          i32.const 2
+                          i32.shl
+                          i32.add
+                          i32.const 10
+                          i32.store
+                          local.get $3
+                          local.get $7
+                          i32.load8_s
+                          i32.const -48
+                          i32.add
+                          i32.const 3
+                          i32.shl
+                          i32.add
+                          i64.load
+                          i32.wrap_i64
+                          local.set $5
+                          local.get $11
+                          i32.const 4
+                          i32.add
+                          local.set $11
+                          br 5 (;@6;)
+                        end
+                      end
+                    end
+                    local.get $17
+                    if ;; label = @9
+                      block ;; label = @10
+                        i32.const -1
+                        local.set $15
+                        br 5 (;@5;)
+                      end
+                    end
+                    local.get $30
+                    if (result i32) ;; label = @9
+                      block (result i32) ;; label = @10
+                        local.get $2
+                        i32.load
+                        i32.const 3
+                        i32.add
+                        i32.const -4
+                        i32.and
+                        local.tee $11
+                        i32.load
+                        local.set $5
+                        local.get $2
+                        local.get $11
+                        i32.const 4
+                        i32.add
+                        i32.store
+                        local.get $7
+                      end
+                    else
+                      block (result i32) ;; label = @10
+                        i32.const 0
+                        local.set $5
+                        local.get $7
+                      end
+                    end
+                    local.set $11
+                  end
+                else
+                  i32.const -1
+                  local.set $5
+                end
+              end
+              local.get $11
+              local.set $7
+              i32.const 0
+              local.set $8
+              loop $label$55 ;; label = @6
+                local.get $7
+                i32.load8_s
+                i32.const -65
+                i32.add
+                local.tee $6
+                i32.const 57
+                i32.gt_u
+                if ;; label = @7
+                  block ;; label = @8
+                    i32.const -1
+                    local.set $15
+                    br 3 (;@5;)
+                  end
+                end
+                local.get $7
+                i32.const 1
+                i32.add
+                local.set $11
+                local.get $8
+                i32.const 58
+                i32.mul
+                i32.const 1168
+                i32.add
+                local.get $6
+                i32.add
+                i32.load8_s
+                local.tee $13
+                i32.const 255
+                i32.and
+                local.tee $6
+                i32.const -1
+                i32.add
+                i32.const 8
+                i32.lt_u
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $11
+                    local.set $7
+                    local.get $6
+                    local.set $8
+                    br 2 (;@6;)
+                  end
+                end
+              end
+              local.get $13
+              i32.const 24
+              i32.shl
+              i32.const 24
+              i32.shr_s
+              i32.eqz
+              if ;; label = @6
+                block ;; label = @7
+                  i32.const -1
+                  local.set $15
+                  br 2 (;@5;)
+                end
+              end
+              local.get $9
+              i32.const -1
+              i32.gt_s
+              local.set $14
+              block $label$59 ;; label = @6
+                block $label$60 ;; label = @7
+                  local.get $13
+                  i32.const 24
+                  i32.shl
+                  i32.const 24
+                  i32.shr_s
+                  i32.const 19
+                  i32.eq
+                  if ;; label = @8
+                    local.get $14
+                    if ;; label = @9
+                      block ;; label = @10
+                        i32.const -1
+                        local.set $15
+                        br 5 (;@5;)
+                      end
+                    else
+                      br 2 (;@7;)
+                    end
+                  else
+                    block ;; label = @9
+                      local.get $14
+                      if ;; label = @10
+                        block ;; label = @11
+                          local.get $4
+                          local.get $9
+                          i32.const 2
+                          i32.shl
+                          i32.add
+                          local.get $6
+                          i32.store
+                          local.get $16
+                          local.get $3
+                          local.get $9
+                          i32.const 3
+                          i32.shl
+                          i32.add
+                          i64.load
+                          i64.store
+                          br 4 (;@7;)
+                        end
+                      end
+                      local.get $30
+                      i32.eqz
+                      if ;; label = @10
+                        block ;; label = @11
+                          i32.const 0
+                          local.set $15
+                          br 6 (;@5;)
+                        end
+                      end
+                      local.get $16
+                      local.get $6
+                      local.get $2
+                      call $21
+                    end
+                  end
+                  br 1 (;@6;)
+                end
+                local.get $30
+                i32.eqz
+                if ;; label = @7
+                  block ;; label = @8
+                    i32.const 0
+                    local.set $10
+                    local.get $11
+                    local.set $1
+                    br 4 (;@4;)
+                  end
+                end
+              end
+              local.get $7
+              i32.load8_s
+              local.tee $7
+              i32.const -33
+              i32.and
+              local.set $9
+              local.get $8
+              i32.const 0
+              i32.ne
+              local.get $7
+              i32.const 15
+              i32.and
+              i32.const 3
+              i32.eq
+              i32.and
+              i32.eqz
+              if ;; label = @6
+                local.get $7
+                local.set $9
+              end
+              local.get $12
+              i32.const -65537
+              i32.and
+              local.set $7
+              local.get $12
+              i32.const 8192
+              i32.and
+              if ;; label = @6
+                local.get $7
+                local.set $12
+              end
+              block $label$70 ;; label = @6
+                block $label$71 ;; label = @7
+                  block $label$72 ;; label = @8
+                    block $label$73 ;; label = @9
+                      block $label$74 ;; label = @10
+                        block $label$75 ;; label = @11
+                          block $label$76 ;; label = @12
+                            block $label$77 ;; label = @13
+                              block $label$78 ;; label = @14
+                                block $label$79 ;; label = @15
+                                  block $label$80 ;; label = @16
+                                    block $label$81 ;; label = @17
+                                      block $label$82 ;; label = @18
+                                        block $label$83 ;; label = @19
+                                          block $label$84 ;; label = @20
+                                            block $label$85 ;; label = @21
+                                              block $label$86 ;; label = @22
+                                                block $label$87 ;; label = @23
+                                                  block $label$88 ;; label = @24
+                                                    block $label$89 ;; label = @25
+                                                      local.get $9
+                                                      i32.const 65
+                                                      i32.sub
+                                                      br_table 11 (;@14;) 12 (;@13;) 9 (;@16;) 12 (;@13;) 11 (;@14;) 11 (;@14;) 11 (;@14;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 10 (;@15;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 2 (;@23;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 11 (;@14;) 12 (;@13;) 6 (;@19;) 4 (;@21;) 11 (;@14;) 11 (;@14;) 11 (;@14;) 12 (;@13;) 4 (;@21;) 12 (;@13;) 12 (;@13;) 12 (;@13;) 7 (;@18;) 0 (;@25;) 3 (;@22;) 1 (;@24;) 12 (;@13;) 12 (;@13;) 8 (;@17;) 12 (;@13;) 5 (;@20;) 12 (;@13;) 12 (;@13;) 2 (;@23;) 12 (;@13;)
+                                                    end
+                                                    block $label$90 ;; label = @25
+                                                      block $label$91 ;; label = @26
+                                                        block $label$92 ;; label = @27
+                                                          block $label$93 ;; label = @28
+                                                            block $label$94 ;; label = @29
+                                                              block $label$95 ;; label = @30
+                                                                block $label$96 ;; label = @31
+                                                                  block $label$97 ;; label = @32
+                                                                    local.get $8
+                                                                    i32.const 255
+                                                                    i32.and
+                                                                    i32.const 24
+                                                                    i32.shl
+                                                                    i32.const 24
+                                                                    i32.shr_s
+                                                                    i32.const 0
+                                                                    i32.sub
+                                                                    br_table 0 (;@32;) 1 (;@31;) 2 (;@30;) 3 (;@29;) 4 (;@28;) 7 (;@25;) 5 (;@27;) 6 (;@26;) 7 (;@25;)
+                                                                  end
+                                                                  local.get $16
+                                                                  i32.load
+                                                                  local.get $15
+                                                                  i32.store
+                                                                  i32.const 0
+                                                                  local.set $10
+                                                                  local.get $11
+                                                                  local.set $1
+                                                                  br 27 (;@4;)
+                                                                end
+                                                                local.get $16
+                                                                i32.load
+                                                                local.get $15
+                                                                i32.store
+                                                                i32.const 0
+                                                                local.set $10
+                                                                local.get $11
+                                                                local.set $1
+                                                                br 26 (;@4;)
+                                                              end
+                                                              local.get $16
+                                                              i32.load
+                                                              local.get $15
+                                                              i64.extend_i32_s
+                                                              i64.store
+                                                              i32.const 0
+                                                              local.set $10
+                                                              local.get $11
+                                                              local.set $1
+                                                              br 25 (;@4;)
+                                                            end
+                                                            local.get $16
+                                                            i32.load
+                                                            local.get $15
+                                                            i32.store16
+                                                            i32.const 0
+                                                            local.set $10
+                                                            local.get $11
+                                                            local.set $1
+                                                            br 24 (;@4;)
+                                                          end
+                                                          local.get $16
+                                                          i32.load
+                                                          local.get $15
+                                                          i32.store8
+                                                          i32.const 0
+                                                          local.set $10
+                                                          local.get $11
+                                                          local.set $1
+                                                          br 23 (;@4;)
+                                                        end
+                                                        local.get $16
+                                                        i32.load
+                                                        local.get $15
+                                                        i32.store
+                                                        i32.const 0
+                                                        local.set $10
+                                                        local.get $11
+                                                        local.set $1
+                                                        br 22 (;@4;)
+                                                      end
+                                                      local.get $16
+                                                      i32.load
+                                                      local.get $15
+                                                      i64.extend_i32_s
+                                                      i64.store
+                                                      i32.const 0
+                                                      local.set $10
+                                                      local.get $11
+                                                      local.set $1
+                                                      br 21 (;@4;)
+                                                    end
+                                                    i32.const 0
+                                                    local.set $10
+                                                    local.get $11
+                                                    local.set $1
+                                                    br 20 (;@4;)
+                                                  end
+                                                  local.get $12
+                                                  i32.const 8
+                                                  i32.or
+                                                  local.set $12
+                                                  local.get $5
+                                                  i32.const 8
+                                                  i32.le_u
+                                                  if ;; label = @24
+                                                    i32.const 8
+                                                    local.set $5
+                                                  end
+                                                  i32.const 120
+                                                  local.set $9
+                                                  br 11 (;@12;)
+                                                end
+                                                br 10 (;@12;)
+                                              end
+                                              local.get $16
+                                              i64.load
+                                              local.tee $50
+                                              i64.const 0
+                                              i64.eq
+                                              if ;; label = @22
+                                                local.get $21
+                                                local.set $7
+                                              else
+                                                block ;; label = @23
+                                                  local.get $21
+                                                  local.set $1
+                                                  loop $label$101 ;; label = @24
+                                                    local.get $1
+                                                    i32.const -1
+                                                    i32.add
+                                                    local.tee $1
+                                                    local.get $50
+                                                    i64.const 7
+                                                    i64.and
+                                                    i64.const 48
+                                                    i64.or
+                                                    i64.store8
+                                                    local.get $50
+                                                    i64.const 3
+                                                    i64.shr_u
+                                                    local.tee $50
+                                                    i64.const 0
+                                                    i64.ne
+                                                    br_if 0 (;@24;)
+                                                    local.get $1
+                                                    local.set $7
+                                                  end
+                                                end
+                                              end
+                                              local.get $12
+                                              i32.const 8
+                                              i32.and
+                                              if ;; label = @22
+                                                block ;; label = @23
+                                                  local.get $38
+                                                  local.get $7
+                                                  i32.sub
+                                                  local.tee $1
+                                                  i32.const 1
+                                                  i32.add
+                                                  local.set $8
+                                                  local.get $5
+                                                  local.get $1
+                                                  i32.le_s
+                                                  if ;; label = @24
+                                                    local.get $8
+                                                    local.set $5
+                                                  end
+                                                  i32.const 0
+                                                  local.set $6
+                                                  i32.const 1648
+                                                  local.set $8
+                                                  br 16 (;@7;)
+                                                end
+                                              else
+                                                block ;; label = @23
+                                                  i32.const 0
+                                                  local.set $6
+                                                  i32.const 1648
+                                                  local.set $8
+                                                  br 16 (;@7;)
+                                                end
+                                              end
+                                            end
+                                            local.get $16
+                                            i64.load
+                                            local.tee $50
+                                            i64.const 0
+                                            i64.lt_s
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                local.get $16
+                                                i64.const 0
+                                                local.get $50
+                                                i64.sub
+                                                local.tee $50
+                                                i64.store
+                                                i32.const 1
+                                                local.set $6
+                                                i32.const 1648
+                                                local.set $8
+                                                br 11 (;@11;)
+                                              end
+                                            end
+                                            local.get $12
+                                            i32.const 2048
+                                            i32.and
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                i32.const 1
+                                                local.set $6
+                                                i32.const 1649
+                                                local.set $8
+                                                br 11 (;@11;)
+                                              end
+                                            else
+                                              block ;; label = @22
+                                                local.get $12
+                                                i32.const 1
+                                                i32.and
+                                                local.tee $1
+                                                local.set $6
+                                                local.get $1
+                                                if (result i32) ;; label = @23
+                                                  i32.const 1650
+                                                else
+                                                  i32.const 1648
+                                                end
+                                                local.set $8
+                                                br 11 (;@11;)
+                                              end
+                                            end
+                                          end
+                                          local.get $16
+                                          i64.load
+                                          local.set $50
+                                          i32.const 0
+                                          local.set $6
+                                          i32.const 1648
+                                          local.set $8
+                                          br 8 (;@11;)
+                                        end
+                                        local.get $39
+                                        local.get $16
+                                        i64.load
+                                        i64.store8
+                                        local.get $39
+                                        local.set $1
+                                        local.get $7
+                                        local.set $12
+                                        i32.const 1
+                                        local.set $7
+                                        i32.const 0
+                                        local.set $6
+                                        i32.const 1648
+                                        local.set $8
+                                        local.get $21
+                                        local.set $5
+                                        br 12 (;@6;)
+                                      end
+                                      call $11
+                                      i32.load
+                                      call $23
+                                      local.set $1
+                                      br 7 (;@10;)
+                                    end
+                                    local.get $16
+                                    i32.load
+                                    local.tee $1
+                                    i32.eqz
+                                    if ;; label = @17
+                                      i32.const 1658
+                                      local.set $1
+                                    end
+                                    br 6 (;@10;)
+                                  end
+                                  local.get $37
+                                  local.get $16
+                                  i64.load
+                                  i64.store32
+                                  local.get $42
+                                  i32.const 0
+                                  i32.store
+                                  local.get $16
+                                  local.get $37
+                                  i32.store
+                                  local.get $37
+                                  local.set $7
+                                  i32.const -1
+                                  local.set $6
+                                  br 6 (;@9;)
+                                end
+                                local.get $16
+                                i32.load
+                                local.set $7
+                                local.get $5
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $5
+                                    local.set $6
+                                    br 7 (;@9;)
+                                  end
+                                else
+                                  block ;; label = @16
+                                    local.get $0
+                                    i32.const 32
+                                    local.get $10
+                                    i32.const 0
+                                    local.get $12
+                                    call $24
+                                    i32.const 0
+                                    local.set $1
+                                    br 8 (;@8;)
+                                  end
+                                end
+                              end
+                              local.get $16
+                              f64.load
+                              local.set $52
+                              local.get $20
+                              i32.const 0
+                              i32.store
+                              local.get $52
+                              i64.reinterpret_f64
+                              i64.const 0
+                              i64.lt_s
+                              if (result i32) ;; label = @14
+                                block (result i32) ;; label = @15
+                                  i32.const 1
+                                  local.set $24
+                                  local.get $52
+                                  f64.neg
+                                  local.set $52
+                                  i32.const 1665
+                                end
+                              else
+                                block (result i32) ;; label = @15
+                                  local.get $12
+                                  i32.const 1
+                                  i32.and
+                                  local.set $1
+                                  local.get $12
+                                  i32.const 2048
+                                  i32.and
+                                  if (result i32) ;; label = @16
+                                    block (result i32) ;; label = @17
+                                      i32.const 1
+                                      local.set $24
+                                      i32.const 1668
+                                    end
+                                  else
+                                    block (result i32) ;; label = @17
+                                      local.get $1
+                                      local.set $24
+                                      local.get $1
+                                      if (result i32) ;; label = @18
+                                        i32.const 1671
+                                      else
+                                        i32.const 1666
+                                      end
+                                    end
+                                  end
+                                end
+                              end
+                              local.set $26
+                              block $label$119 ;; label = @14
+                                local.get $52
+                                i64.reinterpret_f64
+                                i64.const 9218868437227405312
+                                i64.and
+                                i64.const 9218868437227405312
+                                i64.lt_u
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $52
+                                    local.get $20
+                                    call $26
+                                    f64.const 0x1p+1 (;=2;)
+                                    f64.mul
+                                    local.tee $52
+                                    f64.const 0x0p+0 (;=0;)
+                                    f64.ne
+                                    local.tee $1
+                                    if ;; label = @17
+                                      local.get $20
+                                      local.get $20
+                                      i32.load
+                                      i32.const -1
+                                      i32.add
+                                      i32.store
+                                    end
+                                    local.get $9
+                                    i32.const 32
+                                    i32.or
+                                    local.tee $22
+                                    i32.const 97
+                                    i32.eq
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        local.get $26
+                                        i32.const 9
+                                        i32.add
+                                        local.set $1
+                                        local.get $9
+                                        i32.const 32
+                                        i32.and
+                                        local.tee $6
+                                        if ;; label = @19
+                                          local.get $1
+                                          local.set $26
+                                        end
+                                        local.get $5
+                                        i32.const 11
+                                        i32.gt_u
+                                        i32.const 12
+                                        local.get $5
+                                        i32.sub
+                                        local.tee $1
+                                        i32.eqz
+                                        i32.or
+                                        i32.eqz
+                                        if ;; label = @19
+                                          block ;; label = @20
+                                            f64.const 0x1p+3 (;=8;)
+                                            local.set $53
+                                            loop $label$125 ;; label = @21
+                                              local.get $53
+                                              f64.const 0x1p+4 (;=16;)
+                                              f64.mul
+                                              local.set $53
+                                              local.get $1
+                                              i32.const -1
+                                              i32.add
+                                              local.tee $1
+                                              br_if 0 (;@21;)
+                                            end
+                                            local.get $26
+                                            i32.load8_s
+                                            i32.const 45
+                                            i32.eq
+                                            if (result f64) ;; label = @21
+                                              local.get $53
+                                              local.get $52
+                                              f64.neg
+                                              local.get $53
+                                              f64.sub
+                                              f64.add
+                                              f64.neg
+                                            else
+                                              local.get $52
+                                              local.get $53
+                                              f64.add
+                                              local.get $53
+                                              f64.sub
+                                            end
+                                            local.set $52
+                                          end
+                                        end
+                                        i32.const 0
+                                        local.get $20
+                                        i32.load
+                                        local.tee $7
+                                        i32.sub
+                                        local.set $1
+                                        local.get $7
+                                        i32.const 0
+                                        i32.lt_s
+                                        if (result i32) ;; label = @19
+                                          local.get $1
+                                        else
+                                          local.get $7
+                                        end
+                                        i64.extend_i32_s
+                                        local.get $33
+                                        call $22
+                                        local.tee $1
+                                        local.get $33
+                                        i32.eq
+                                        if ;; label = @19
+                                          block ;; label = @20
+                                            local.get $40
+                                            i32.const 48
+                                            i32.store8
+                                            local.get $40
+                                            local.set $1
+                                          end
+                                        end
+                                        local.get $24
+                                        i32.const 2
+                                        i32.or
+                                        local.set $13
+                                        local.get $1
+                                        i32.const -1
+                                        i32.add
+                                        local.get $7
+                                        i32.const 31
+                                        i32.shr_s
+                                        i32.const 2
+                                        i32.and
+                                        i32.const 43
+                                        i32.add
+                                        i32.store8
+                                        local.get $1
+                                        i32.const -2
+                                        i32.add
+                                        local.tee $8
+                                        local.get $9
+                                        i32.const 15
+                                        i32.add
+                                        i32.store8
+                                        local.get $5
+                                        i32.const 1
+                                        i32.lt_s
+                                        local.set $9
+                                        local.get $12
+                                        i32.const 8
+                                        i32.and
+                                        i32.eqz
+                                        local.set $14
+                                        local.get $19
+                                        local.set $1
+                                        loop $label$131 ;; label = @19
+                                          local.get $1
+                                          local.get $52
+                                          i32.trunc_f64_s
+                                          local.tee $7
+                                          i32.const 1632
+                                          i32.add
+                                          i32.load8_u
+                                          local.get $6
+                                          i32.or
+                                          i32.store8
+                                          local.get $52
+                                          local.get $7
+                                          f64.convert_i32_s
+                                          f64.sub
+                                          f64.const 0x1p+4 (;=16;)
+                                          f64.mul
+                                          local.set $52
+                                          block $label$132 (result i32) ;; label = @20
+                                            local.get $1
+                                            i32.const 1
+                                            i32.add
+                                            local.tee $7
+                                            local.get $27
+                                            i32.sub
+                                            i32.const 1
+                                            i32.eq
+                                            if (result i32) ;; label = @21
+                                              block (result i32) ;; label = @22
+                                                local.get $7
+                                                local.get $14
+                                                local.get $9
+                                                local.get $52
+                                                f64.const 0x0p+0 (;=0;)
+                                                f64.eq
+                                                i32.and
+                                                i32.and
+                                                br_if 2 (;@20;)
+                                                drop
+                                                local.get $7
+                                                i32.const 46
+                                                i32.store8
+                                                local.get $1
+                                                i32.const 2
+                                                i32.add
+                                              end
+                                            else
+                                              local.get $7
+                                            end
+                                          end
+                                          local.set $1
+                                          local.get $52
+                                          f64.const 0x0p+0 (;=0;)
+                                          f64.ne
+                                          br_if 0 (;@19;)
+                                        end
+                                        local.get $46
+                                        local.get $5
+                                        i32.add
+                                        local.get $8
+                                        local.tee $7
+                                        i32.sub
+                                        local.set $6
+                                        local.get $44
+                                        local.get $7
+                                        i32.sub
+                                        local.get $1
+                                        i32.add
+                                        local.set $9
+                                        local.get $0
+                                        i32.const 32
+                                        local.get $10
+                                        local.get $5
+                                        i32.const 0
+                                        i32.ne
+                                        local.get $45
+                                        local.get $1
+                                        i32.add
+                                        local.get $5
+                                        i32.lt_s
+                                        i32.and
+                                        if (result i32) ;; label = @19
+                                          local.get $6
+                                        else
+                                          local.get $9
+                                          local.tee $6
+                                        end
+                                        local.get $13
+                                        i32.add
+                                        local.tee $5
+                                        local.get $12
+                                        call $24
+                                        local.get $0
+                                        i32.load
+                                        i32.const 32
+                                        i32.and
+                                        i32.eqz
+                                        if ;; label = @19
+                                          local.get $26
+                                          local.get $13
+                                          local.get $0
+                                          call $20
+                                          drop
+                                        end
+                                        local.get $0
+                                        i32.const 48
+                                        local.get $10
+                                        local.get $5
+                                        local.get $12
+                                        i32.const 65536
+                                        i32.xor
+                                        call $24
+                                        local.get $1
+                                        local.get $27
+                                        i32.sub
+                                        local.set $1
+                                        local.get $0
+                                        i32.load
+                                        i32.const 32
+                                        i32.and
+                                        i32.eqz
+                                        if ;; label = @19
+                                          local.get $19
+                                          local.get $1
+                                          local.get $0
+                                          call $20
+                                          drop
+                                        end
+                                        local.get $0
+                                        i32.const 48
+                                        local.get $6
+                                        local.get $1
+                                        local.get $28
+                                        local.get $7
+                                        i32.sub
+                                        local.tee $1
+                                        i32.add
+                                        i32.sub
+                                        i32.const 0
+                                        i32.const 0
+                                        call $24
+                                        local.get $0
+                                        i32.load
+                                        i32.const 32
+                                        i32.and
+                                        i32.eqz
+                                        if ;; label = @19
+                                          local.get $8
+                                          local.get $1
+                                          local.get $0
+                                          call $20
+                                          drop
+                                        end
+                                        local.get $0
+                                        i32.const 32
+                                        local.get $10
+                                        local.get $5
+                                        local.get $12
+                                        i32.const 8192
+                                        i32.xor
+                                        call $24
+                                        local.get $5
+                                        local.get $10
+                                        i32.ge_s
+                                        if ;; label = @19
+                                          local.get $5
+                                          local.set $10
+                                        end
+                                        br 4 (;@14;)
+                                      end
+                                    end
+                                    local.get $1
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        local.get $20
+                                        local.get $20
+                                        i32.load
+                                        i32.const -28
+                                        i32.add
+                                        local.tee $6
+                                        i32.store
+                                        local.get $52
+                                        f64.const 0x1p+28 (;=268435456;)
+                                        f64.mul
+                                        local.set $52
+                                      end
+                                    else
+                                      local.get $20
+                                      i32.load
+                                      local.set $6
+                                    end
+                                    local.get $6
+                                    i32.const 0
+                                    i32.lt_s
+                                    if (result i32) ;; label = @17
+                                      local.get $47
+                                    else
+                                      local.get $48
+                                    end
+                                    local.tee $7
+                                    local.set $8
+                                    loop $label$145 ;; label = @17
+                                      local.get $8
+                                      local.get $52
+                                      i32.trunc_f64_s
+                                      local.tee $1
+                                      i32.store
+                                      local.get $8
+                                      i32.const 4
+                                      i32.add
+                                      local.set $8
+                                      local.get $52
+                                      local.get $1
+                                      f64.convert_i32_u
+                                      f64.sub
+                                      f64.const 0x1.dcd65p+29 (;=1000000000;)
+                                      f64.mul
+                                      local.tee $52
+                                      f64.const 0x0p+0 (;=0;)
+                                      f64.ne
+                                      br_if 0 (;@17;)
+                                    end
+                                    local.get $6
+                                    i32.const 0
+                                    i32.gt_s
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        local.get $7
+                                        local.set $1
+                                        loop $label$147 ;; label = @19
+                                          local.get $6
+                                          i32.const 29
+                                          i32.gt_s
+                                          if (result i32) ;; label = @20
+                                            i32.const 29
+                                          else
+                                            local.get $6
+                                          end
+                                          local.set $14
+                                          block $label$150 ;; label = @20
+                                            local.get $8
+                                            i32.const -4
+                                            i32.add
+                                            local.tee $6
+                                            local.get $1
+                                            i32.ge_u
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                local.get $14
+                                                i64.extend_i32_u
+                                                local.set $50
+                                                i32.const 0
+                                                local.set $13
+                                                loop $label$152 ;; label = @23
+                                                  local.get $6
+                                                  local.get $6
+                                                  i32.load
+                                                  i64.extend_i32_u
+                                                  local.get $50
+                                                  i64.shl
+                                                  local.get $13
+                                                  i64.extend_i32_u
+                                                  i64.add
+                                                  local.tee $51
+                                                  i64.const 1000000000
+                                                  i64.rem_u
+                                                  i64.store32
+                                                  local.get $51
+                                                  i64.const 1000000000
+                                                  i64.div_u
+                                                  i32.wrap_i64
+                                                  local.set $13
+                                                  local.get $6
+                                                  i32.const -4
+                                                  i32.add
+                                                  local.tee $6
+                                                  local.get $1
+                                                  i32.ge_u
+                                                  br_if 0 (;@23;)
+                                                end
+                                                local.get $13
+                                                i32.eqz
+                                                br_if 2 (;@20;)
+                                                local.get $1
+                                                i32.const -4
+                                                i32.add
+                                                local.tee $1
+                                                local.get $13
+                                                i32.store
+                                              end
+                                            end
+                                          end
+                                          loop $label$153 ;; label = @20
+                                            local.get $8
+                                            local.get $1
+                                            i32.gt_u
+                                            if ;; label = @21
+                                              local.get $8
+                                              i32.const -4
+                                              i32.add
+                                              local.tee $6
+                                              i32.load
+                                              i32.eqz
+                                              if ;; label = @22
+                                                block ;; label = @23
+                                                  local.get $6
+                                                  local.set $8
+                                                  br 3 (;@20;)
+                                                end
+                                              end
+                                            end
+                                          end
+                                          local.get $20
+                                          local.get $20
+                                          i32.load
+                                          local.get $14
+                                          i32.sub
+                                          local.tee $6
+                                          i32.store
+                                          local.get $6
+                                          i32.const 0
+                                          i32.gt_s
+                                          br_if 0 (;@19;)
+                                        end
+                                      end
+                                    else
+                                      local.get $7
+                                      local.set $1
+                                    end
+                                    local.get $5
+                                    i32.const 0
+                                    i32.lt_s
+                                    if (result i32) ;; label = @17
+                                      i32.const 6
+                                    else
+                                      local.get $5
+                                    end
+                                    local.set $18
+                                    local.get $6
+                                    i32.const 0
+                                    i32.lt_s
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        local.get $18
+                                        i32.const 25
+                                        i32.add
+                                        i32.const 9
+                                        i32.div_s
+                                        i32.const 1
+                                        i32.add
+                                        local.set $14
+                                        local.get $22
+                                        i32.const 102
+                                        i32.eq
+                                        local.set $25
+                                        local.get $8
+                                        local.set $5
+                                        loop $label$160 ;; label = @19
+                                          i32.const 0
+                                          local.get $6
+                                          i32.sub
+                                          local.tee $13
+                                          i32.const 9
+                                          i32.gt_s
+                                          if ;; label = @20
+                                            i32.const 9
+                                            local.set $13
+                                          end
+                                          block $label$162 ;; label = @20
+                                            local.get $1
+                                            local.get $5
+                                            i32.lt_u
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                i32.const 1
+                                                local.get $13
+                                                i32.shl
+                                                i32.const -1
+                                                i32.add
+                                                local.set $29
+                                                i32.const 1000000000
+                                                local.get $13
+                                                i32.shr_u
+                                                local.set $35
+                                                i32.const 0
+                                                local.set $6
+                                                local.get $1
+                                                local.set $8
+                                                loop $label$164 ;; label = @23
+                                                  local.get $8
+                                                  local.get $8
+                                                  i32.load
+                                                  local.tee $32
+                                                  local.get $13
+                                                  i32.shr_u
+                                                  local.get $6
+                                                  i32.add
+                                                  i32.store
+                                                  local.get $32
+                                                  local.get $29
+                                                  i32.and
+                                                  local.get $35
+                                                  i32.mul
+                                                  local.set $6
+                                                  local.get $8
+                                                  i32.const 4
+                                                  i32.add
+                                                  local.tee $8
+                                                  local.get $5
+                                                  i32.lt_u
+                                                  br_if 0 (;@23;)
+                                                end
+                                                local.get $1
+                                                i32.const 4
+                                                i32.add
+                                                local.set $8
+                                                local.get $1
+                                                i32.load
+                                                i32.eqz
+                                                if ;; label = @23
+                                                  local.get $8
+                                                  local.set $1
+                                                end
+                                                local.get $6
+                                                i32.eqz
+                                                br_if 2 (;@20;)
+                                                local.get $5
+                                                local.get $6
+                                                i32.store
+                                                local.get $5
+                                                i32.const 4
+                                                i32.add
+                                                local.set $5
+                                              end
+                                            else
+                                              block ;; label = @22
+                                                local.get $1
+                                                i32.const 4
+                                                i32.add
+                                                local.set $8
+                                                local.get $1
+                                                i32.load
+                                                i32.eqz
+                                                if ;; label = @23
+                                                  local.get $8
+                                                  local.set $1
+                                                end
+                                              end
+                                            end
+                                          end
+                                          local.get $25
+                                          if (result i32) ;; label = @20
+                                            local.get $7
+                                          else
+                                            local.get $1
+                                          end
+                                          local.tee $8
+                                          local.get $14
+                                          i32.const 2
+                                          i32.shl
+                                          i32.add
+                                          local.set $6
+                                          local.get $5
+                                          local.get $8
+                                          i32.sub
+                                          i32.const 2
+                                          i32.shr_s
+                                          local.get $14
+                                          i32.gt_s
+                                          if ;; label = @20
+                                            local.get $6
+                                            local.set $5
+                                          end
+                                          local.get $20
+                                          local.get $20
+                                          i32.load
+                                          local.get $13
+                                          i32.add
+                                          local.tee $6
+                                          i32.store
+                                          local.get $6
+                                          i32.const 0
+                                          i32.lt_s
+                                          br_if 0 (;@19;)
+                                          local.get $5
+                                          local.set $13
+                                        end
+                                      end
+                                    else
+                                      local.get $8
+                                      local.set $13
+                                    end
+                                    local.get $7
+                                    local.set $25
+                                    block $label$172 ;; label = @17
+                                      local.get $1
+                                      local.get $13
+                                      i32.lt_u
+                                      if ;; label = @18
+                                        block ;; label = @19
+                                          local.get $25
+                                          local.get $1
+                                          i32.sub
+                                          i32.const 2
+                                          i32.shr_s
+                                          i32.const 9
+                                          i32.mul
+                                          local.set $5
+                                          local.get $1
+                                          i32.load
+                                          local.tee $6
+                                          i32.const 10
+                                          i32.lt_u
+                                          br_if 2 (;@17;)
+                                          i32.const 10
+                                          local.set $8
+                                          loop $label$174 ;; label = @20
+                                            local.get $5
+                                            i32.const 1
+                                            i32.add
+                                            local.set $5
+                                            local.get $6
+                                            local.get $8
+                                            i32.const 10
+                                            i32.mul
+                                            local.tee $8
+                                            i32.ge_u
+                                            br_if 0 (;@20;)
+                                          end
+                                        end
+                                      else
+                                        i32.const 0
+                                        local.set $5
+                                      end
+                                    end
+                                    local.get $22
+                                    i32.const 103
+                                    i32.eq
+                                    local.set $29
+                                    local.get $18
+                                    i32.const 0
+                                    i32.ne
+                                    local.set $35
+                                    local.get $18
+                                    local.get $22
+                                    i32.const 102
+                                    i32.ne
+                                    if (result i32) ;; label = @17
+                                      local.get $5
+                                    else
+                                      i32.const 0
+                                    end
+                                    i32.sub
+                                    local.get $35
+                                    local.get $29
+                                    i32.and
+                                    i32.const 31
+                                    i32.shl
+                                    i32.const 31
+                                    i32.shr_s
+                                    i32.add
+                                    local.tee $8
+                                    local.get $13
+                                    local.get $25
+                                    i32.sub
+                                    i32.const 2
+                                    i32.shr_s
+                                    i32.const 9
+                                    i32.mul
+                                    i32.const -9
+                                    i32.add
+                                    i32.lt_s
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        local.get $8
+                                        i32.const 9216
+                                        i32.add
+                                        local.tee $14
+                                        i32.const 9
+                                        i32.rem_s
+                                        i32.const 1
+                                        i32.add
+                                        local.tee $8
+                                        i32.const 9
+                                        i32.lt_s
+                                        if ;; label = @19
+                                          block ;; label = @20
+                                            i32.const 10
+                                            local.set $6
+                                            loop $label$180 ;; label = @21
+                                              local.get $6
+                                              i32.const 10
+                                              i32.mul
+                                              local.set $6
+                                              local.get $8
+                                              i32.const 1
+                                              i32.add
+                                              local.tee $8
+                                              i32.const 9
+                                              i32.ne
+                                              br_if 0 (;@21;)
+                                            end
+                                          end
+                                        else
+                                          i32.const 10
+                                          local.set $6
+                                        end
+                                        local.get $7
+                                        i32.const 4
+                                        i32.add
+                                        local.get $14
+                                        i32.const 9
+                                        i32.div_s
+                                        i32.const -1024
+                                        i32.add
+                                        i32.const 2
+                                        i32.shl
+                                        i32.add
+                                        local.tee $8
+                                        i32.load
+                                        local.tee $22
+                                        local.get $6
+                                        i32.rem_u
+                                        local.set $14
+                                        block $label$182 ;; label = @19
+                                          local.get $8
+                                          i32.const 4
+                                          i32.add
+                                          local.get $13
+                                          i32.eq
+                                          local.tee $32
+                                          local.get $14
+                                          i32.eqz
+                                          i32.and
+                                          i32.eqz
+                                          if ;; label = @20
+                                            block ;; label = @21
+                                              local.get $14
+                                              local.get $6
+                                              i32.const 2
+                                              i32.div_s
+                                              local.tee $49
+                                              i32.lt_u
+                                              if (result f64) ;; label = @22
+                                                f64.const 0x1p-1 (;=0.5;)
+                                              else
+                                                local.get $32
+                                                local.get $14
+                                                local.get $49
+                                                i32.eq
+                                                i32.and
+                                                if (result f64) ;; label = @23
+                                                  f64.const 0x1p+0 (;=1;)
+                                                else
+                                                  f64.const 0x1.8p+0 (;=1.5;)
+                                                end
+                                              end
+                                              local.set $52
+                                              local.get $22
+                                              local.get $6
+                                              i32.div_u
+                                              i32.const 1
+                                              i32.and
+                                              if (result f64) ;; label = @22
+                                                f64.const 0x1.0000000000001p+53 (;=9007199254740994;)
+                                              else
+                                                f64.const 0x1p+53 (;=9007199254740992;)
+                                              end
+                                              local.set $53
+                                              block $label$190 ;; label = @22
+                                                local.get $24
+                                                if ;; label = @23
+                                                  block ;; label = @24
+                                                    local.get $26
+                                                    i32.load8_s
+                                                    i32.const 45
+                                                    i32.ne
+                                                    br_if 2 (;@22;)
+                                                    local.get $53
+                                                    f64.neg
+                                                    local.set $53
+                                                    local.get $52
+                                                    f64.neg
+                                                    local.set $52
+                                                  end
+                                                end
+                                              end
+                                              local.get $8
+                                              local.get $22
+                                              local.get $14
+                                              i32.sub
+                                              local.tee $14
+                                              i32.store
+                                              local.get $53
+                                              local.get $52
+                                              f64.add
+                                              local.get $53
+                                              f64.eq
+                                              br_if 2 (;@19;)
+                                              local.get $8
+                                              local.get $14
+                                              local.get $6
+                                              i32.add
+                                              local.tee $5
+                                              i32.store
+                                              local.get $5
+                                              i32.const 999999999
+                                              i32.gt_u
+                                              if ;; label = @22
+                                                loop $label$193 ;; label = @23
+                                                  local.get $8
+                                                  i32.const 0
+                                                  i32.store
+                                                  local.get $8
+                                                  i32.const -4
+                                                  i32.add
+                                                  local.tee $8
+                                                  local.get $1
+                                                  i32.lt_u
+                                                  if ;; label = @24
+                                                    local.get $1
+                                                    i32.const -4
+                                                    i32.add
+                                                    local.tee $1
+                                                    i32.const 0
+                                                    i32.store
+                                                  end
+                                                  local.get $8
+                                                  local.get $8
+                                                  i32.load
+                                                  i32.const 1
+                                                  i32.add
+                                                  local.tee $5
+                                                  i32.store
+                                                  local.get $5
+                                                  i32.const 999999999
+                                                  i32.gt_u
+                                                  br_if 0 (;@23;)
+                                                end
+                                              end
+                                              local.get $25
+                                              local.get $1
+                                              i32.sub
+                                              i32.const 2
+                                              i32.shr_s
+                                              i32.const 9
+                                              i32.mul
+                                              local.set $5
+                                              local.get $1
+                                              i32.load
+                                              local.tee $14
+                                              i32.const 10
+                                              i32.lt_u
+                                              br_if 2 (;@19;)
+                                              i32.const 10
+                                              local.set $6
+                                              loop $label$195 ;; label = @22
+                                                local.get $5
+                                                i32.const 1
+                                                i32.add
+                                                local.set $5
+                                                local.get $14
+                                                local.get $6
+                                                i32.const 10
+                                                i32.mul
+                                                local.tee $6
+                                                i32.ge_u
+                                                br_if 0 (;@22;)
+                                              end
+                                            end
+                                          end
+                                        end
+                                        local.get $1
+                                        local.set $14
+                                        local.get $5
+                                        local.set $6
+                                        local.get $13
+                                        local.get $8
+                                        i32.const 4
+                                        i32.add
+                                        local.tee $8
+                                        i32.le_u
+                                        if ;; label = @19
+                                          local.get $13
+                                          local.set $8
+                                        end
+                                      end
+                                    else
+                                      block ;; label = @18
+                                        local.get $1
+                                        local.set $14
+                                        local.get $5
+                                        local.set $6
+                                        local.get $13
+                                        local.set $8
+                                      end
+                                    end
+                                    i32.const 0
+                                    local.get $6
+                                    i32.sub
+                                    local.set $32
+                                    loop $label$198 ;; label = @17
+                                      block $label$199 ;; label = @18
+                                        local.get $8
+                                        local.get $14
+                                        i32.le_u
+                                        if ;; label = @19
+                                          block ;; label = @20
+                                            i32.const 0
+                                            local.set $22
+                                            br 2 (;@18;)
+                                          end
+                                        end
+                                        local.get $8
+                                        i32.const -4
+                                        i32.add
+                                        local.tee $1
+                                        i32.load
+                                        if ;; label = @19
+                                          i32.const 1
+                                          local.set $22
+                                        else
+                                          block ;; label = @20
+                                            local.get $1
+                                            local.set $8
+                                            br 3 (;@17;)
+                                          end
+                                        end
+                                      end
+                                    end
+                                    block $label$203 ;; label = @17
+                                      local.get $29
+                                      if ;; label = @18
+                                        block ;; label = @19
+                                          local.get $35
+                                          i32.const 1
+                                          i32.and
+                                          i32.const 1
+                                          i32.xor
+                                          local.get $18
+                                          i32.add
+                                          local.tee $1
+                                          local.get $6
+                                          i32.gt_s
+                                          local.get $6
+                                          i32.const -5
+                                          i32.gt_s
+                                          i32.and
+                                          if (result i32) ;; label = @20
+                                            block (result i32) ;; label = @21
+                                              local.get $9
+                                              i32.const -1
+                                              i32.add
+                                              local.set $5
+                                              local.get $1
+                                              i32.const -1
+                                              i32.add
+                                              local.get $6
+                                              i32.sub
+                                            end
+                                          else
+                                            block (result i32) ;; label = @21
+                                              local.get $9
+                                              i32.const -2
+                                              i32.add
+                                              local.set $5
+                                              local.get $1
+                                              i32.const -1
+                                              i32.add
+                                            end
+                                          end
+                                          local.set $1
+                                          local.get $12
+                                          i32.const 8
+                                          i32.and
+                                          local.tee $13
+                                          br_if 2 (;@17;)
+                                          block $label$207 ;; label = @20
+                                            local.get $22
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                local.get $8
+                                                i32.const -4
+                                                i32.add
+                                                i32.load
+                                                local.tee $18
+                                                i32.eqz
+                                                if ;; label = @23
+                                                  block ;; label = @24
+                                                    i32.const 9
+                                                    local.set $9
+                                                    br 4 (;@20;)
+                                                  end
+                                                end
+                                                local.get $18
+                                                i32.const 10
+                                                i32.rem_u
+                                                if ;; label = @23
+                                                  block ;; label = @24
+                                                    i32.const 0
+                                                    local.set $9
+                                                    br 4 (;@20;)
+                                                  end
+                                                else
+                                                  block ;; label = @24
+                                                    i32.const 10
+                                                    local.set $13
+                                                    i32.const 0
+                                                    local.set $9
+                                                  end
+                                                end
+                                                loop $label$212 ;; label = @23
+                                                  local.get $9
+                                                  i32.const 1
+                                                  i32.add
+                                                  local.set $9
+                                                  local.get $18
+                                                  local.get $13
+                                                  i32.const 10
+                                                  i32.mul
+                                                  local.tee $13
+                                                  i32.rem_u
+                                                  i32.eqz
+                                                  br_if 0 (;@23;)
+                                                end
+                                              end
+                                            else
+                                              i32.const 9
+                                              local.set $9
+                                            end
+                                          end
+                                          local.get $8
+                                          local.get $25
+                                          i32.sub
+                                          i32.const 2
+                                          i32.shr_s
+                                          i32.const 9
+                                          i32.mul
+                                          i32.const -9
+                                          i32.add
+                                          local.set $18
+                                          local.get $5
+                                          i32.const 32
+                                          i32.or
+                                          i32.const 102
+                                          i32.eq
+                                          if ;; label = @20
+                                            block ;; label = @21
+                                              i32.const 0
+                                              local.set $13
+                                              local.get $1
+                                              local.get $18
+                                              local.get $9
+                                              i32.sub
+                                              local.tee $9
+                                              i32.const 0
+                                              i32.lt_s
+                                              if (result i32) ;; label = @22
+                                                i32.const 0
+                                                local.tee $9
+                                              else
+                                                local.get $9
+                                              end
+                                              i32.ge_s
+                                              if ;; label = @22
+                                                local.get $9
+                                                local.set $1
+                                              end
+                                            end
+                                          else
+                                            block ;; label = @21
+                                              i32.const 0
+                                              local.set $13
+                                              local.get $1
+                                              local.get $18
+                                              local.get $6
+                                              i32.add
+                                              local.get $9
+                                              i32.sub
+                                              local.tee $9
+                                              i32.const 0
+                                              i32.lt_s
+                                              if (result i32) ;; label = @22
+                                                i32.const 0
+                                                local.tee $9
+                                              else
+                                                local.get $9
+                                              end
+                                              i32.ge_s
+                                              if ;; label = @22
+                                                local.get $9
+                                                local.set $1
+                                              end
+                                            end
+                                          end
+                                        end
+                                      else
+                                        block ;; label = @19
+                                          local.get $12
+                                          i32.const 8
+                                          i32.and
+                                          local.set $13
+                                          local.get $18
+                                          local.set $1
+                                          local.get $9
+                                          local.set $5
+                                        end
+                                      end
+                                    end
+                                    local.get $5
+                                    i32.const 32
+                                    i32.or
+                                    i32.const 102
+                                    i32.eq
+                                    local.tee $25
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        i32.const 0
+                                        local.set $9
+                                        local.get $6
+                                        i32.const 0
+                                        i32.le_s
+                                        if ;; label = @19
+                                          i32.const 0
+                                          local.set $6
+                                        end
+                                      end
+                                    else
+                                      block ;; label = @18
+                                        local.get $28
+                                        local.get $6
+                                        i32.const 0
+                                        i32.lt_s
+                                        if (result i32) ;; label = @19
+                                          local.get $32
+                                        else
+                                          local.get $6
+                                        end
+                                        i64.extend_i32_s
+                                        local.get $33
+                                        call $22
+                                        local.tee $9
+                                        i32.sub
+                                        i32.const 2
+                                        i32.lt_s
+                                        if ;; label = @19
+                                          loop $label$229 ;; label = @20
+                                            local.get $9
+                                            i32.const -1
+                                            i32.add
+                                            local.tee $9
+                                            i32.const 48
+                                            i32.store8
+                                            local.get $28
+                                            local.get $9
+                                            i32.sub
+                                            i32.const 2
+                                            i32.lt_s
+                                            br_if 0 (;@20;)
+                                          end
+                                        end
+                                        local.get $9
+                                        i32.const -1
+                                        i32.add
+                                        local.get $6
+                                        i32.const 31
+                                        i32.shr_s
+                                        i32.const 2
+                                        i32.and
+                                        i32.const 43
+                                        i32.add
+                                        i32.store8
+                                        local.get $9
+                                        i32.const -2
+                                        i32.add
+                                        local.tee $6
+                                        local.get $5
+                                        i32.store8
+                                        local.get $6
+                                        local.set $9
+                                        local.get $28
+                                        local.get $6
+                                        i32.sub
+                                        local.set $6
+                                      end
+                                    end
+                                    local.get $0
+                                    i32.const 32
+                                    local.get $10
+                                    local.get $24
+                                    i32.const 1
+                                    i32.add
+                                    local.get $1
+                                    i32.add
+                                    local.get $1
+                                    local.get $13
+                                    i32.or
+                                    local.tee $29
+                                    i32.const 0
+                                    i32.ne
+                                    i32.add
+                                    local.get $6
+                                    i32.add
+                                    local.tee $18
+                                    local.get $12
+                                    call $24
+                                    local.get $0
+                                    i32.load
+                                    i32.const 32
+                                    i32.and
+                                    i32.eqz
+                                    if ;; label = @17
+                                      local.get $26
+                                      local.get $24
+                                      local.get $0
+                                      call $20
+                                      drop
+                                    end
+                                    local.get $0
+                                    i32.const 48
+                                    local.get $10
+                                    local.get $18
+                                    local.get $12
+                                    i32.const 65536
+                                    i32.xor
+                                    call $24
+                                    block $label$231 ;; label = @17
+                                      local.get $25
+                                      if ;; label = @18
+                                        block ;; label = @19
+                                          local.get $14
+                                          local.get $7
+                                          i32.gt_u
+                                          if (result i32) ;; label = @20
+                                            local.get $7
+                                          else
+                                            local.get $14
+                                          end
+                                          local.tee $9
+                                          local.set $6
+                                          loop $label$235 ;; label = @20
+                                            local.get $6
+                                            i32.load
+                                            i64.extend_i32_u
+                                            local.get $31
+                                            call $22
+                                            local.set $5
+                                            block $label$236 ;; label = @21
+                                              local.get $6
+                                              local.get $9
+                                              i32.eq
+                                              if ;; label = @22
+                                                block ;; label = @23
+                                                  local.get $5
+                                                  local.get $31
+                                                  i32.ne
+                                                  br_if 2 (;@21;)
+                                                  local.get $34
+                                                  i32.const 48
+                                                  i32.store8
+                                                  local.get $34
+                                                  local.set $5
+                                                end
+                                              else
+                                                block ;; label = @23
+                                                  local.get $5
+                                                  local.get $19
+                                                  i32.le_u
+                                                  br_if 2 (;@21;)
+                                                  local.get $19
+                                                  i32.const 48
+                                                  local.get $5
+                                                  local.get $27
+                                                  i32.sub
+                                                  call $35
+                                                  drop
+                                                  loop $label$239 ;; label = @24
+                                                    local.get $5
+                                                    i32.const -1
+                                                    i32.add
+                                                    local.tee $5
+                                                    local.get $19
+                                                    i32.gt_u
+                                                    br_if 0 (;@24;)
+                                                  end
+                                                end
+                                              end
+                                            end
+                                            local.get $0
+                                            i32.load
+                                            i32.const 32
+                                            i32.and
+                                            i32.eqz
+                                            if ;; label = @21
+                                              local.get $5
+                                              local.get $41
+                                              local.get $5
+                                              i32.sub
+                                              local.get $0
+                                              call $20
+                                              drop
+                                            end
+                                            local.get $6
+                                            i32.const 4
+                                            i32.add
+                                            local.tee $5
+                                            local.get $7
+                                            i32.le_u
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                local.get $5
+                                                local.set $6
+                                                br 2 (;@20;)
+                                              end
+                                            end
+                                          end
+                                          block $label$242 ;; label = @20
+                                            local.get $29
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                local.get $0
+                                                i32.load
+                                                i32.const 32
+                                                i32.and
+                                                br_if 2 (;@20;)
+                                                i32.const 1700
+                                                i32.const 1
+                                                local.get $0
+                                                call $20
+                                                drop
+                                              end
+                                            end
+                                          end
+                                          local.get $1
+                                          i32.const 0
+                                          i32.gt_s
+                                          local.get $5
+                                          local.get $8
+                                          i32.lt_u
+                                          i32.and
+                                          if ;; label = @20
+                                            loop $label$245 ;; label = @21
+                                              local.get $5
+                                              i32.load
+                                              i64.extend_i32_u
+                                              local.get $31
+                                              call $22
+                                              local.tee $7
+                                              local.get $19
+                                              i32.gt_u
+                                              if ;; label = @22
+                                                block ;; label = @23
+                                                  local.get $19
+                                                  i32.const 48
+                                                  local.get $7
+                                                  local.get $27
+                                                  i32.sub
+                                                  call $35
+                                                  drop
+                                                  loop $label$247 ;; label = @24
+                                                    local.get $7
+                                                    i32.const -1
+                                                    i32.add
+                                                    local.tee $7
+                                                    local.get $19
+                                                    i32.gt_u
+                                                    br_if 0 (;@24;)
+                                                  end
+                                                end
+                                              end
+                                              local.get $0
+                                              i32.load
+                                              i32.const 32
+                                              i32.and
+                                              i32.eqz
+                                              if ;; label = @22
+                                                local.get $7
+                                                local.get $1
+                                                i32.const 9
+                                                i32.gt_s
+                                                if (result i32) ;; label = @23
+                                                  i32.const 9
+                                                else
+                                                  local.get $1
+                                                end
+                                                local.get $0
+                                                call $20
+                                                drop
+                                              end
+                                              local.get $1
+                                              i32.const -9
+                                              i32.add
+                                              local.set $7
+                                              local.get $1
+                                              i32.const 9
+                                              i32.gt_s
+                                              local.get $5
+                                              i32.const 4
+                                              i32.add
+                                              local.tee $5
+                                              local.get $8
+                                              i32.lt_u
+                                              i32.and
+                                              if ;; label = @22
+                                                block ;; label = @23
+                                                  local.get $7
+                                                  local.set $1
+                                                  br 2 (;@21;)
+                                                end
+                                              else
+                                                local.get $7
+                                                local.set $1
+                                              end
+                                            end
+                                          end
+                                          local.get $0
+                                          i32.const 48
+                                          local.get $1
+                                          i32.const 9
+                                          i32.add
+                                          i32.const 9
+                                          i32.const 0
+                                          call $24
+                                        end
+                                      else
+                                        block ;; label = @19
+                                          local.get $14
+                                          i32.const 4
+                                          i32.add
+                                          local.set $5
+                                          local.get $22
+                                          i32.eqz
+                                          if ;; label = @20
+                                            local.get $5
+                                            local.set $8
+                                          end
+                                          local.get $1
+                                          i32.const -1
+                                          i32.gt_s
+                                          if ;; label = @20
+                                            block ;; label = @21
+                                              local.get $13
+                                              i32.eqz
+                                              local.set $13
+                                              local.get $14
+                                              local.set $7
+                                              local.get $1
+                                              local.set $5
+                                              loop $label$256 ;; label = @22
+                                                local.get $7
+                                                i32.load
+                                                i64.extend_i32_u
+                                                local.get $31
+                                                call $22
+                                                local.tee $1
+                                                local.get $31
+                                                i32.eq
+                                                if ;; label = @23
+                                                  block ;; label = @24
+                                                    local.get $34
+                                                    i32.const 48
+                                                    i32.store8
+                                                    local.get $34
+                                                    local.set $1
+                                                  end
+                                                end
+                                                block $label$258 ;; label = @23
+                                                  local.get $7
+                                                  local.get $14
+                                                  i32.eq
+                                                  if ;; label = @24
+                                                    block ;; label = @25
+                                                      local.get $0
+                                                      i32.load
+                                                      i32.const 32
+                                                      i32.and
+                                                      i32.eqz
+                                                      if ;; label = @26
+                                                        local.get $1
+                                                        i32.const 1
+                                                        local.get $0
+                                                        call $20
+                                                        drop
+                                                      end
+                                                      local.get $1
+                                                      i32.const 1
+                                                      i32.add
+                                                      local.set $1
+                                                      local.get $13
+                                                      local.get $5
+                                                      i32.const 1
+                                                      i32.lt_s
+                                                      i32.and
+                                                      br_if 2 (;@23;)
+                                                      local.get $0
+                                                      i32.load
+                                                      i32.const 32
+                                                      i32.and
+                                                      br_if 2 (;@23;)
+                                                      i32.const 1700
+                                                      i32.const 1
+                                                      local.get $0
+                                                      call $20
+                                                      drop
+                                                    end
+                                                  else
+                                                    block ;; label = @25
+                                                      local.get $1
+                                                      local.get $19
+                                                      i32.le_u
+                                                      br_if 2 (;@23;)
+                                                      local.get $19
+                                                      i32.const 48
+                                                      local.get $1
+                                                      local.get $43
+                                                      i32.add
+                                                      call $35
+                                                      drop
+                                                      loop $label$262 ;; label = @26
+                                                        local.get $1
+                                                        i32.const -1
+                                                        i32.add
+                                                        local.tee $1
+                                                        local.get $19
+                                                        i32.gt_u
+                                                        br_if 0 (;@26;)
+                                                      end
+                                                    end
+                                                  end
+                                                end
+                                                local.get $41
+                                                local.get $1
+                                                i32.sub
+                                                local.set $6
+                                                local.get $0
+                                                i32.load
+                                                i32.const 32
+                                                i32.and
+                                                i32.eqz
+                                                if ;; label = @23
+                                                  local.get $1
+                                                  local.get $5
+                                                  local.get $6
+                                                  i32.gt_s
+                                                  if (result i32) ;; label = @24
+                                                    local.get $6
+                                                  else
+                                                    local.get $5
+                                                  end
+                                                  local.get $0
+                                                  call $20
+                                                  drop
+                                                end
+                                                local.get $7
+                                                i32.const 4
+                                                i32.add
+                                                local.tee $7
+                                                local.get $8
+                                                i32.lt_u
+                                                local.get $5
+                                                local.get $6
+                                                i32.sub
+                                                local.tee $5
+                                                i32.const -1
+                                                i32.gt_s
+                                                i32.and
+                                                br_if 0 (;@22;)
+                                                local.get $5
+                                                local.set $1
+                                              end
+                                            end
+                                          end
+                                          local.get $0
+                                          i32.const 48
+                                          local.get $1
+                                          i32.const 18
+                                          i32.add
+                                          i32.const 18
+                                          i32.const 0
+                                          call $24
+                                          local.get $0
+                                          i32.load
+                                          i32.const 32
+                                          i32.and
+                                          br_if 2 (;@17;)
+                                          local.get $9
+                                          local.get $28
+                                          local.get $9
+                                          i32.sub
+                                          local.get $0
+                                          call $20
+                                          drop
+                                        end
+                                      end
+                                    end
+                                    local.get $0
+                                    i32.const 32
+                                    local.get $10
+                                    local.get $18
+                                    local.get $12
+                                    i32.const 8192
+                                    i32.xor
+                                    call $24
+                                    local.get $18
+                                    local.get $10
+                                    i32.ge_s
+                                    if ;; label = @17
+                                      local.get $18
+                                      local.set $10
+                                    end
+                                  end
+                                else
+                                  block ;; label = @16
+                                    local.get $0
+                                    i32.const 32
+                                    local.get $10
+                                    local.get $52
+                                    local.get $52
+                                    f64.ne
+                                    i32.const 0
+                                    i32.or
+                                    local.tee $6
+                                    if (result i32) ;; label = @17
+                                      i32.const 0
+                                      local.tee $24
+                                    else
+                                      local.get $24
+                                    end
+                                    i32.const 3
+                                    i32.add
+                                    local.tee $8
+                                    local.get $7
+                                    call $24
+                                    local.get $0
+                                    i32.load
+                                    local.tee $1
+                                    i32.const 32
+                                    i32.and
+                                    i32.eqz
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        local.get $26
+                                        local.get $24
+                                        local.get $0
+                                        call $20
+                                        drop
+                                        local.get $0
+                                        i32.load
+                                        local.set $1
+                                      end
+                                    end
+                                    local.get $9
+                                    i32.const 32
+                                    i32.and
+                                    i32.const 0
+                                    i32.ne
+                                    local.tee $5
+                                    if (result i32) ;; label = @17
+                                      i32.const 1684
+                                    else
+                                      i32.const 1688
+                                    end
+                                    local.set $7
+                                    local.get $5
+                                    if (result i32) ;; label = @17
+                                      i32.const 1692
+                                    else
+                                      i32.const 1696
+                                    end
+                                    local.set $5
+                                    local.get $6
+                                    i32.eqz
+                                    if ;; label = @17
+                                      local.get $7
+                                      local.set $5
+                                    end
+                                    local.get $1
+                                    i32.const 32
+                                    i32.and
+                                    i32.eqz
+                                    if ;; label = @17
+                                      local.get $5
+                                      i32.const 3
+                                      local.get $0
+                                      call $20
+                                      drop
+                                    end
+                                    local.get $0
+                                    i32.const 32
+                                    local.get $10
+                                    local.get $8
+                                    local.get $12
+                                    i32.const 8192
+                                    i32.xor
+                                    call $24
+                                    local.get $8
+                                    local.get $10
+                                    i32.ge_s
+                                    if ;; label = @17
+                                      local.get $8
+                                      local.set $10
+                                    end
+                                  end
+                                end
+                              end
+                              local.get $11
+                              local.set $1
+                              br 9 (;@4;)
+                            end
+                            local.get $5
+                            local.set $7
+                            i32.const 0
+                            local.set $6
+                            i32.const 1648
+                            local.set $8
+                            local.get $21
+                            local.set $5
+                            br 6 (;@6;)
+                          end
+                          local.get $9
+                          i32.const 32
+                          i32.and
+                          local.set $7
+                          local.get $16
+                          i64.load
+                          local.tee $50
+                          i64.const 0
+                          i64.eq
+                          if (result i32) ;; label = @12
+                            block (result i32) ;; label = @13
+                              i64.const 0
+                              local.set $50
+                              local.get $21
+                            end
+                          else
+                            block (result i32) ;; label = @13
+                              local.get $21
+                              local.set $1
+                              loop $label$280 ;; label = @14
+                                local.get $1
+                                i32.const -1
+                                i32.add
+                                local.tee $1
+                                local.get $50
+                                i32.wrap_i64
+                                i32.const 15
+                                i32.and
+                                i32.const 1632
+                                i32.add
+                                i32.load8_u
+                                local.get $7
+                                i32.or
+                                i32.store8
+                                local.get $50
+                                i64.const 4
+                                i64.shr_u
+                                local.tee $50
+                                i64.const 0
+                                i64.ne
+                                br_if 0 (;@14;)
+                              end
+                              local.get $16
+                              i64.load
+                              local.set $50
+                              local.get $1
+                            end
+                          end
+                          local.set $7
+                          local.get $9
+                          i32.const 4
+                          i32.shr_s
+                          i32.const 1648
+                          i32.add
+                          local.set $8
+                          local.get $12
+                          i32.const 8
+                          i32.and
+                          i32.eqz
+                          local.get $50
+                          i64.const 0
+                          i64.eq
+                          i32.or
+                          local.tee $1
+                          if ;; label = @12
+                            i32.const 1648
+                            local.set $8
+                          end
+                          local.get $1
+                          if (result i32) ;; label = @12
+                            i32.const 0
+                          else
+                            i32.const 2
+                          end
+                          local.set $6
+                          br 4 (;@7;)
+                        end
+                        local.get $50
+                        local.get $21
+                        call $22
+                        local.set $7
+                        br 3 (;@7;)
+                      end
+                      local.get $1
+                      i32.const 0
+                      local.get $5
+                      call $16
+                      local.tee $13
+                      i32.eqz
+                      local.set $14
+                      local.get $13
+                      local.get $1
+                      i32.sub
+                      local.set $8
+                      local.get $1
+                      local.get $5
+                      i32.add
+                      local.set $9
+                      local.get $7
+                      local.set $12
+                      local.get $14
+                      if (result i32) ;; label = @10
+                        local.get $5
+                      else
+                        local.get $8
+                      end
+                      local.set $7
+                      i32.const 0
+                      local.set $6
+                      i32.const 1648
+                      local.set $8
+                      local.get $14
+                      if (result i32) ;; label = @10
+                        local.get $9
+                      else
+                        local.get $13
+                      end
+                      local.set $5
+                      br 3 (;@6;)
+                    end
+                    i32.const 0
+                    local.set $1
+                    i32.const 0
+                    local.set $5
+                    local.get $7
+                    local.set $8
+                    loop $label$288 ;; label = @9
+                      block $label$289 ;; label = @10
+                        local.get $8
+                        i32.load
+                        local.tee $9
+                        i32.eqz
+                        br_if 0 (;@10;)
+                        local.get $36
+                        local.get $9
+                        call $25
+                        local.tee $5
+                        i32.const 0
+                        i32.lt_s
+                        local.get $5
+                        local.get $6
+                        local.get $1
+                        i32.sub
+                        i32.gt_u
+                        i32.or
+                        br_if 0 (;@10;)
+                        local.get $8
+                        i32.const 4
+                        i32.add
+                        local.set $8
+                        local.get $6
+                        local.get $5
+                        local.get $1
+                        i32.add
+                        local.tee $1
+                        i32.gt_u
+                        br_if 1 (;@9;)
+                      end
+                    end
+                    local.get $5
+                    i32.const 0
+                    i32.lt_s
+                    if ;; label = @9
+                      block ;; label = @10
+                        i32.const -1
+                        local.set $15
+                        br 5 (;@5;)
+                      end
+                    end
+                    local.get $0
+                    i32.const 32
+                    local.get $10
+                    local.get $1
+                    local.get $12
+                    call $24
+                    local.get $1
+                    if ;; label = @9
+                      block ;; label = @10
+                        i32.const 0
+                        local.set $5
+                        loop $label$292 ;; label = @11
+                          local.get $7
+                          i32.load
+                          local.tee $8
+                          i32.eqz
+                          br_if 3 (;@8;)
+                          local.get $36
+                          local.get $8
+                          call $25
+                          local.tee $8
+                          local.get $5
+                          i32.add
+                          local.tee $5
+                          local.get $1
+                          i32.gt_s
+                          br_if 3 (;@8;)
+                          local.get $0
+                          i32.load
+                          i32.const 32
+                          i32.and
+                          i32.eqz
+                          if ;; label = @12
+                            local.get $36
+                            local.get $8
+                            local.get $0
+                            call $20
+                            drop
+                          end
+                          local.get $7
+                          i32.const 4
+                          i32.add
+                          local.set $7
+                          local.get $5
+                          local.get $1
+                          i32.lt_u
+                          br_if 0 (;@11;)
+                          br 3 (;@8;)
+                        end
+                      end
+                    else
+                      block ;; label = @10
+                        i32.const 0
+                        local.set $1
+                        br 2 (;@8;)
+                      end
+                    end
+                  end
+                  local.get $0
+                  i32.const 32
+                  local.get $10
+                  local.get $1
+                  local.get $12
+                  i32.const 8192
+                  i32.xor
+                  call $24
+                  local.get $10
+                  local.get $1
+                  i32.le_s
+                  if ;; label = @8
+                    local.get $1
+                    local.set $10
+                  end
+                  local.get $11
+                  local.set $1
+                  br 3 (;@4;)
+                end
+                local.get $12
+                i32.const -65537
+                i32.and
+                local.set $1
+                local.get $5
+                i32.const -1
+                i32.gt_s
+                if ;; label = @7
+                  local.get $1
+                  local.set $12
+                end
+                local.get $5
+                local.get $16
+                i64.load
+                i64.const 0
+                i64.ne
+                local.tee $9
+                i32.or
+                if (result i32) ;; label = @7
+                  block (result i32) ;; label = @8
+                    local.get $7
+                    local.set $1
+                    local.get $5
+                    local.get $9
+                    i32.const 1
+                    i32.and
+                    i32.const 1
+                    i32.xor
+                    local.get $38
+                    local.get $7
+                    i32.sub
+                    i32.add
+                    local.tee $7
+                    i32.gt_s
+                    if ;; label = @9
+                      local.get $5
+                      local.set $7
+                    end
+                    local.get $21
+                  end
+                else
+                  block (result i32) ;; label = @8
+                    local.get $21
+                    local.set $1
+                    i32.const 0
+                    local.set $7
+                    local.get $21
+                  end
+                end
+                local.set $5
+              end
+              local.get $0
+              i32.const 32
+              local.get $10
+              local.get $7
+              local.get $5
+              local.get $1
+              i32.sub
+              local.tee $9
+              i32.lt_s
+              if (result i32) ;; label = @6
+                local.get $9
+                local.tee $7
+              else
+                local.get $7
+              end
+              local.get $6
+              i32.add
+              local.tee $5
+              i32.lt_s
+              if (result i32) ;; label = @6
+                local.get $5
+                local.tee $10
+              else
+                local.get $10
+              end
+              local.get $5
+              local.get $12
+              call $24
+              local.get $0
+              i32.load
+              i32.const 32
+              i32.and
+              i32.eqz
+              if ;; label = @6
+                local.get $8
+                local.get $6
+                local.get $0
+                call $20
+                drop
+              end
+              local.get $0
+              i32.const 48
+              local.get $10
+              local.get $5
+              local.get $12
+              i32.const 65536
+              i32.xor
+              call $24
+              local.get $0
+              i32.const 48
+              local.get $7
+              local.get $9
+              i32.const 0
+              call $24
+              local.get $0
+              i32.load
+              i32.const 32
+              i32.and
+              i32.eqz
+              if ;; label = @6
+                local.get $1
+                local.get $9
+                local.get $0
+                call $20
+                drop
+              end
+              local.get $0
+              i32.const 32
+              local.get $10
+              local.get $5
+              local.get $12
+              i32.const 8192
+              i32.xor
+              call $24
+              local.get $11
+              local.set $1
+              br 1 (;@4;)
+            end
+          end
+          br 1 (;@2;)
+        end
+        local.get $0
+        i32.eqz
+        if ;; label = @3
+          local.get $17
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 1
+              local.set $0
+              loop $label$308 ;; label = @6
+                local.get $4
+                local.get $0
+                i32.const 2
+                i32.shl
+                i32.add
+                i32.load
+                local.tee $1
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $3
+                    local.get $0
+                    i32.const 3
+                    i32.shl
+                    i32.add
+                    local.get $1
+                    local.get $2
+                    call $21
+                    local.get $0
+                    i32.const 1
+                    i32.add
+                    local.tee $0
+                    i32.const 10
+                    i32.lt_s
+                    br_if 2 (;@6;)
+                    i32.const 1
+                    local.set $15
+                    br 6 (;@2;)
+                  end
+                end
+              end
+              loop $label$310 ;; label = @6
+                local.get $4
+                local.get $0
+                i32.const 2
+                i32.shl
+                i32.add
+                i32.load
+                if ;; label = @7
+                  block ;; label = @8
+                    i32.const -1
+                    local.set $15
+                    br 6 (;@2;)
+                  end
+                end
+                local.get $0
+                i32.const 1
+                i32.add
+                local.tee $0
+                i32.const 10
+                i32.lt_s
+                br_if 0 (;@6;)
+                i32.const 1
+                local.set $15
+              end
+            end
+          else
+            i32.const 0
+            local.set $15
+          end
+        end
+      end
+      local.get $23
+      global.set $global$1
+      local.get $15
+    end
+  )
+  (func $19 (;32;) (type $1) (param $0 i32) (result i32)
+    i32.const 0
+  )
+  (func $20 (;33;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32)
+    block $label$1 (result i32) ;; label = @1
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          local.get $2
+          i32.const 16
+          i32.add
+          local.tee $4
+          i32.load
+          local.tee $3
+          br_if 0 (;@3;)
+          local.get $2
+          call $29
+          if ;; label = @4
+            i32.const 0
+            local.set $3
+          else
+            block ;; label = @5
+              local.get $4
+              i32.load
+              local.set $3
+              br 2 (;@3;)
+            end
+          end
+          br 1 (;@2;)
+        end
+        local.get $3
+        local.get $2
+        i32.const 20
+        i32.add
+        local.tee $5
+        i32.load
+        local.tee $4
+        i32.sub
+        local.get $1
+        i32.lt_u
+        if ;; label = @3
+          block ;; label = @4
+            local.get $2
+            local.get $0
+            local.get $1
+            local.get $2
+            i32.load offset=36
+            i32.const 3
+            i32.and
+            i32.const 2
+            i32.add
+            call_indirect (type $0)
+            local.set $3
+            br 2 (;@2;)
+          end
+        end
+        block $label$7 (result i32) ;; label = @3
+          local.get $2
+          i32.load8_s offset=75
+          i32.const -1
+          i32.gt_s
+          if (result i32) ;; label = @4
+            block (result i32) ;; label = @5
+              local.get $1
+              local.set $3
+              loop $label$9 ;; label = @6
+                i32.const 0
+                local.get $3
+                i32.eqz
+                br_if 3 (;@3;)
+                drop
+                local.get $0
+                local.get $3
+                i32.const -1
+                i32.add
+                local.tee $6
+                i32.add
+                i32.load8_s
+                i32.const 10
+                i32.ne
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $6
+                    local.set $3
+                    br 2 (;@6;)
+                  end
+                end
+              end
+              local.get $2
+              local.get $0
+              local.get $3
+              local.get $2
+              i32.load offset=36
+              i32.const 3
+              i32.and
+              i32.const 2
+              i32.add
+              call_indirect (type $0)
+              local.get $3
+              i32.lt_u
+              br_if 3 (;@2;)
+              local.get $5
+              i32.load
+              local.set $4
+              local.get $1
+              local.get $3
+              i32.sub
+              local.set $1
+              local.get $0
+              local.get $3
+              i32.add
+              local.set $0
+              local.get $3
+            end
+          else
+            i32.const 0
+          end
+        end
+        local.set $2
+        local.get $4
+        local.get $0
+        local.get $1
+        call $36
+        drop
+        local.get $5
+        local.get $5
+        i32.load
+        local.get $1
+        i32.add
+        i32.store
+        local.get $2
+        local.get $1
+        i32.add
+        local.set $3
+      end
+      local.get $3
+    end
+  )
+  (func $21 (;34;) (type $8) (param $0 i32) (param $1 i32) (param $2 i32)
+    (local $3 i32) (local $4 i64) (local $5 f64)
+    block $label$1 ;; label = @1
+      local.get $1
+      i32.const 20
+      i32.le_u
+      if ;; label = @2
+        block $label$3 ;; label = @3
+          block $label$4 ;; label = @4
+            block $label$5 ;; label = @5
+              block $label$6 ;; label = @6
+                block $label$7 ;; label = @7
+                  block $label$8 ;; label = @8
+                    block $label$9 ;; label = @9
+                      block $label$10 ;; label = @10
+                        block $label$11 ;; label = @11
+                          block $label$12 ;; label = @12
+                            block $label$13 ;; label = @13
+                              local.get $1
+                              i32.const 9
+                              i32.sub
+                              br_table 0 (;@13;) 1 (;@12;) 2 (;@11;) 3 (;@10;) 4 (;@9;) 5 (;@8;) 6 (;@7;) 7 (;@6;) 8 (;@5;) 9 (;@4;) 10 (;@3;)
+                            end
+                            local.get $2
+                            i32.load
+                            i32.const 3
+                            i32.add
+                            i32.const -4
+                            i32.and
+                            local.tee $1
+                            i32.load
+                            local.set $3
+                            local.get $2
+                            local.get $1
+                            i32.const 4
+                            i32.add
+                            i32.store
+                            local.get $0
+                            local.get $3
+                            i32.store
+                            br 11 (;@1;)
+                          end
+                          local.get $2
+                          i32.load
+                          i32.const 3
+                          i32.add
+                          i32.const -4
+                          i32.and
+                          local.tee $1
+                          i32.load
+                          local.set $3
+                          local.get $2
+                          local.get $1
+                          i32.const 4
+                          i32.add
+                          i32.store
+                          local.get $0
+                          local.get $3
+                          i64.extend_i32_s
+                          i64.store
+                          br 10 (;@1;)
+                        end
+                        local.get $2
+                        i32.load
+                        i32.const 3
+                        i32.add
+                        i32.const -4
+                        i32.and
+                        local.tee $1
+                        i32.load
+                        local.set $3
+                        local.get $2
+                        local.get $1
+                        i32.const 4
+                        i32.add
+                        i32.store
+                        local.get $0
+                        local.get $3
+                        i64.extend_i32_u
+                        i64.store
+                        br 9 (;@1;)
+                      end
+                      local.get $2
+                      i32.load
+                      i32.const 7
+                      i32.add
+                      i32.const -8
+                      i32.and
+                      local.tee $1
+                      i64.load
+                      local.set $4
+                      local.get $2
+                      local.get $1
+                      i32.const 8
+                      i32.add
+                      i32.store
+                      local.get $0
+                      local.get $4
+                      i64.store
+                      br 8 (;@1;)
+                    end
+                    local.get $2
+                    i32.load
+                    i32.const 3
+                    i32.add
+                    i32.const -4
+                    i32.and
+                    local.tee $1
+                    i32.load
+                    local.set $3
+                    local.get $2
+                    local.get $1
+                    i32.const 4
+                    i32.add
+                    i32.store
+                    local.get $0
+                    local.get $3
+                    i32.const 65535
+                    i32.and
+                    i32.const 16
+                    i32.shl
+                    i32.const 16
+                    i32.shr_s
+                    i64.extend_i32_s
+                    i64.store
+                    br 7 (;@1;)
+                  end
+                  local.get $2
+                  i32.load
+                  i32.const 3
+                  i32.add
+                  i32.const -4
+                  i32.and
+                  local.tee $1
+                  i32.load
+                  local.set $3
+                  local.get $2
+                  local.get $1
+                  i32.const 4
+                  i32.add
+                  i32.store
+                  local.get $0
+                  local.get $3
+                  i32.const 65535
+                  i32.and
+                  i64.extend_i32_u
+                  i64.store
+                  br 6 (;@1;)
+                end
+                local.get $2
+                i32.load
+                i32.const 3
+                i32.add
+                i32.const -4
+                i32.and
+                local.tee $1
+                i32.load
+                local.set $3
+                local.get $2
+                local.get $1
+                i32.const 4
+                i32.add
+                i32.store
+                local.get $0
+                local.get $3
+                i32.const 255
+                i32.and
+                i32.const 24
+                i32.shl
+                i32.const 24
+                i32.shr_s
+                i64.extend_i32_s
+                i64.store
+                br 5 (;@1;)
+              end
+              local.get $2
+              i32.load
+              i32.const 3
+              i32.add
+              i32.const -4
+              i32.and
+              local.tee $1
+              i32.load
+              local.set $3
+              local.get $2
+              local.get $1
+              i32.const 4
+              i32.add
+              i32.store
+              local.get $0
+              local.get $3
+              i32.const 255
+              i32.and
+              i64.extend_i32_u
+              i64.store
+              br 4 (;@1;)
+            end
+            local.get $2
+            i32.load
+            i32.const 7
+            i32.add
+            i32.const -8
+            i32.and
+            local.tee $1
+            f64.load
+            local.set $5
+            local.get $2
+            local.get $1
+            i32.const 8
+            i32.add
+            i32.store
+            local.get $0
+            local.get $5
+            f64.store
+            br 3 (;@1;)
+          end
+          local.get $2
+          i32.load
+          i32.const 7
+          i32.add
+          i32.const -8
+          i32.and
+          local.tee $1
+          f64.load
+          local.set $5
+          local.get $2
+          local.get $1
+          i32.const 8
+          i32.add
+          i32.store
+          local.get $0
+          local.get $5
+          f64.store
+        end
+      end
+    end
+  )
+  (func $22 (;35;) (type $9) (param $0 i64) (param $1 i32) (result i32)
+    (local $2 i32) (local $3 i32) (local $4 i64)
+    block $label$1 (result i32) ;; label = @1
+      local.get $0
+      i32.wrap_i64
+      local.set $2
+      local.get $0
+      i64.const 4294967295
+      i64.gt_u
+      if ;; label = @2
+        block ;; label = @3
+          loop $label$3 ;; label = @4
+            local.get $1
+            i32.const -1
+            i32.add
+            local.tee $1
+            local.get $0
+            i64.const 10
+            i64.rem_u
+            i64.const 48
+            i64.or
+            i64.store8
+            local.get $0
+            i64.const 10
+            i64.div_u
+            local.set $4
+            local.get $0
+            i64.const 42949672959
+            i64.gt_u
+            if ;; label = @5
+              block ;; label = @6
+                local.get $4
+                local.set $0
+                br 2 (;@4;)
+              end
+            end
+          end
+          local.get $4
+          i32.wrap_i64
+          local.set $2
+        end
+      end
+      local.get $2
+      if ;; label = @2
+        loop $label$6 ;; label = @3
+          local.get $1
+          i32.const -1
+          i32.add
+          local.tee $1
+          local.get $2
+          i32.const 10
+          i32.rem_u
+          i32.const 48
+          i32.or
+          i32.store8
+          local.get $2
+          i32.const 10
+          i32.div_u
+          local.set $3
+          local.get $2
+          i32.const 10
+          i32.ge_u
+          if ;; label = @4
+            block ;; label = @5
+              local.get $3
+              local.set $2
+              br 2 (;@3;)
+            end
+          end
+        end
+      end
+      local.get $1
+    end
+  )
+  (func $23 (;36;) (type $1) (param $0 i32) (result i32)
+    (local $1 i32) (local $2 i32)
+    block $label$1 (result i32) ;; label = @1
+      i32.const 0
+      local.set $1
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          block $label$4 ;; label = @4
+            loop $label$5 ;; label = @5
+              local.get $1
+              i32.const 1702
+              i32.add
+              i32.load8_u
+              local.get $0
+              i32.eq
+              br_if 1 (;@4;)
+              local.get $1
+              i32.const 1
+              i32.add
+              local.tee $1
+              i32.const 87
+              i32.ne
+              br_if 0 (;@5;)
+              i32.const 87
+              local.set $1
+              i32.const 1790
+              local.set $0
+              br 2 (;@3;)
+            end
+          end
+          local.get $1
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 1790
+              local.set $0
+              br 2 (;@3;)
+            end
+          else
+            i32.const 1790
+            local.set $0
+          end
+          br 1 (;@2;)
+        end
+        loop $label$8 ;; label = @3
+          local.get $0
+          local.set $2
+          loop $label$9 ;; label = @4
+            local.get $2
+            i32.const 1
+            i32.add
+            local.set $0
+            local.get $2
+            i32.load8_s
+            if ;; label = @5
+              block ;; label = @6
+                local.get $0
+                local.set $2
+                br 2 (;@4;)
+              end
+            end
+          end
+          local.get $1
+          i32.const -1
+          i32.add
+          local.tee $1
+          br_if 0 (;@3;)
+        end
+      end
+      local.get $0
+    end
+  )
+  (func $24 (;37;) (type $10) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (param $4 i32)
+    (local $5 i32) (local $6 i32) (local $7 i32)
+    block $label$1 ;; label = @1
+      global.get $global$1
+      local.set $7
+      global.get $global$1
+      i32.const 256
+      i32.add
+      global.set $global$1
+      local.get $7
+      local.set $6
+      block $label$2 ;; label = @2
+        local.get $2
+        local.get $3
+        i32.gt_s
+        local.get $4
+        i32.const 73728
+        i32.and
+        i32.eqz
+        i32.and
+        if ;; label = @3
+          block ;; label = @4
+            local.get $6
+            local.get $1
+            local.get $2
+            local.get $3
+            i32.sub
+            local.tee $5
+            i32.const 256
+            i32.gt_u
+            if (result i32) ;; label = @5
+              i32.const 256
+            else
+              local.get $5
+            end
+            call $35
+            drop
+            local.get $0
+            i32.load
+            local.tee $1
+            i32.const 32
+            i32.and
+            i32.eqz
+            local.set $4
+            local.get $5
+            i32.const 255
+            i32.gt_u
+            if ;; label = @5
+              block ;; label = @6
+                loop $label$7 ;; label = @7
+                  local.get $4
+                  if ;; label = @8
+                    block ;; label = @9
+                      local.get $6
+                      i32.const 256
+                      local.get $0
+                      call $20
+                      drop
+                      local.get $0
+                      i32.load
+                      local.set $1
+                    end
+                  end
+                  local.get $1
+                  i32.const 32
+                  i32.and
+                  i32.eqz
+                  local.set $4
+                  local.get $5
+                  i32.const -256
+                  i32.add
+                  local.tee $5
+                  i32.const 255
+                  i32.gt_u
+                  br_if 0 (;@7;)
+                end
+                local.get $4
+                i32.eqz
+                br_if 4 (;@2;)
+                local.get $2
+                local.get $3
+                i32.sub
+                i32.const 255
+                i32.and
+                local.set $5
+              end
+            else
+              local.get $4
+              i32.eqz
+              br_if 3 (;@2;)
+            end
+            local.get $6
+            local.get $5
+            local.get $0
+            call $20
+            drop
+          end
+        end
+      end
+      local.get $7
+      global.set $global$1
+    end
+  )
+  (func $25 (;38;) (type $4) (param $0 i32) (param $1 i32) (result i32)
+    local.get $0
+    if (result i32) ;; label = @1
+      local.get $0
+      local.get $1
+      i32.const 0
+      call $28
+    else
+      i32.const 0
+    end
+  )
+  (func $26 (;39;) (type $11) (param $0 f64) (param $1 i32) (result f64)
+    local.get $0
+    local.get $1
+    call $27
+  )
+  (func $27 (;40;) (type $11) (param $0 f64) (param $1 i32) (result f64)
+    (local $2 i64) (local $3 i64)
+    block $label$1 (result f64) ;; label = @1
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          block $label$4 ;; label = @4
+            block $label$5 ;; label = @5
+              local.get $0
+              i64.reinterpret_f64
+              local.tee $2
+              i64.const 52
+              i64.shr_u
+              local.tee $3
+              i32.wrap_i64
+              i32.const 65535
+              i32.and
+              i32.const 2047
+              i32.and
+              i32.const 16
+              i32.shl
+              i32.const 16
+              i32.shr_s
+              i32.const 0
+              i32.sub
+              br_table 0 (;@5;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 2 (;@3;) 1 (;@4;) 2 (;@3;)
+            end
+            local.get $1
+            local.get $0
+            f64.const 0x0p+0 (;=0;)
+            f64.ne
+            if (result i32) ;; label = @5
+              block (result i32) ;; label = @6
+                local.get $0
+                f64.const 0x1p+64 (;=18446744073709552000;)
+                f64.mul
+                local.get $1
+                call $27
+                local.set $0
+                local.get $1
+                i32.load
+                i32.const -64
+                i32.add
+              end
+            else
+              i32.const 0
+            end
+            i32.store
+            br 2 (;@2;)
+          end
+          br 1 (;@2;)
+        end
+        local.get $1
+        local.get $3
+        i32.wrap_i64
+        i32.const 2047
+        i32.and
+        i32.const -1022
+        i32.add
+        i32.store
+        local.get $2
+        i64.const -9218868437227405313
+        i64.and
+        i64.const 4602678819172646912
+        i64.or
+        f64.reinterpret_i64
+        local.set $0
+      end
+      local.get $0
+    end
+  )
+  (func $28 (;41;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    block $label$1 (result i32) ;; label = @1
+      local.get $0
+      if (result i32) ;; label = @2
+        block (result i32) ;; label = @3
+          local.get $1
+          i32.const 128
+          i32.lt_u
+          if ;; label = @4
+            block ;; label = @5
+              local.get $0
+              local.get $1
+              i32.store8
+              i32.const 1
+              br 4 (;@1;)
+            end
+          end
+          local.get $1
+          i32.const 2048
+          i32.lt_u
+          if ;; label = @4
+            block ;; label = @5
+              local.get $0
+              local.get $1
+              i32.const 6
+              i32.shr_u
+              i32.const 192
+              i32.or
+              i32.store8
+              local.get $0
+              local.get $1
+              i32.const 63
+              i32.and
+              i32.const 128
+              i32.or
+              i32.store8 offset=1
+              i32.const 2
+              br 4 (;@1;)
+            end
+          end
+          local.get $1
+          i32.const 55296
+          i32.lt_u
+          local.get $1
+          i32.const -8192
+          i32.and
+          i32.const 57344
+          i32.eq
+          i32.or
+          if ;; label = @4
+            block ;; label = @5
+              local.get $0
+              local.get $1
+              i32.const 12
+              i32.shr_u
+              i32.const 224
+              i32.or
+              i32.store8
+              local.get $0
+              local.get $1
+              i32.const 6
+              i32.shr_u
+              i32.const 63
+              i32.and
+              i32.const 128
+              i32.or
+              i32.store8 offset=1
+              local.get $0
+              local.get $1
+              i32.const 63
+              i32.and
+              i32.const 128
+              i32.or
+              i32.store8 offset=2
+              i32.const 3
+              br 4 (;@1;)
+            end
+          end
+          local.get $1
+          i32.const -65536
+          i32.add
+          i32.const 1048576
+          i32.lt_u
+          if (result i32) ;; label = @4
+            block (result i32) ;; label = @5
+              local.get $0
+              local.get $1
+              i32.const 18
+              i32.shr_u
+              i32.const 240
+              i32.or
+              i32.store8
+              local.get $0
+              local.get $1
+              i32.const 12
+              i32.shr_u
+              i32.const 63
+              i32.and
+              i32.const 128
+              i32.or
+              i32.store8 offset=1
+              local.get $0
+              local.get $1
+              i32.const 6
+              i32.shr_u
+              i32.const 63
+              i32.and
+              i32.const 128
+              i32.or
+              i32.store8 offset=2
+              local.get $0
+              local.get $1
+              i32.const 63
+              i32.and
+              i32.const 128
+              i32.or
+              i32.store8 offset=3
+              i32.const 4
+            end
+          else
+            block (result i32) ;; label = @5
+              call $11
+              i32.const 84
+              i32.store
+              i32.const -1
+            end
+          end
+        end
+      else
+        i32.const 1
+      end
+    end
+  )
+  (func $29 (;42;) (type $1) (param $0 i32) (result i32)
+    (local $1 i32) (local $2 i32)
+    block $label$1 (result i32) ;; label = @1
+      local.get $0
+      i32.const 74
+      i32.add
+      local.tee $2
+      i32.load8_s
+      local.set $1
+      local.get $2
+      local.get $1
+      i32.const 255
+      i32.add
+      local.get $1
+      i32.or
+      i32.store8
+      local.get $0
+      i32.load
+      local.tee $1
+      i32.const 8
+      i32.and
+      if (result i32) ;; label = @2
+        block (result i32) ;; label = @3
+          local.get $0
+          local.get $1
+          i32.const 32
+          i32.or
+          i32.store
+          i32.const -1
+        end
+      else
+        block (result i32) ;; label = @3
+          local.get $0
+          i32.const 0
+          i32.store offset=8
+          local.get $0
+          i32.const 0
+          i32.store offset=4
+          local.get $0
+          local.get $0
+          i32.load offset=44
+          local.tee $1
+          i32.store offset=28
+          local.get $0
+          local.get $1
+          i32.store offset=20
+          local.get $0
+          local.get $1
+          local.get $0
+          i32.load offset=48
+          i32.add
+          i32.store offset=16
+          i32.const 0
+        end
+      end
+      local.tee $0
+    end
+  )
+  (func $30 (;43;) (type $4) (param $0 i32) (param $1 i32) (result i32)
+    (local $2 i32) (local $3 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $2
+      global.get $global$1
+      i32.const 16
+      i32.add
+      global.set $global$1
+      local.get $2
+      local.tee $3
+      local.get $1
+      i32.store
+      i32.const 1024
+      i32.load
+      local.get $0
+      local.get $3
+      call $17
+      local.set $0
+      local.get $2
+      global.set $global$1
+      local.get $0
+    end
+  )
+  (func $31 (;44;) (type $1) (param $0 i32) (result i32)
+    (local $1 i32) (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32) (local $15 i32) (local $16 i32) (local $17 i32) (local $18 i32) (local $19 i32) (local $20 i32) (local $21 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$1
+      local.set $14
+      global.get $global$1
+      i32.const 16
+      i32.add
+      global.set $global$1
+      local.get $14
+      local.set $18
+      block $label$2 ;; label = @2
+        local.get $0
+        i32.const 245
+        i32.lt_u
+        if ;; label = @3
+          block ;; label = @4
+            local.get $0
+            i32.const 11
+            i32.add
+            i32.const -8
+            i32.and
+            local.set $3
+            i32.const 3644
+            i32.load
+            local.tee $8
+            local.get $0
+            i32.const 11
+            i32.lt_u
+            if (result i32) ;; label = @5
+              i32.const 16
+              local.tee $3
+            else
+              local.get $3
+            end
+            i32.const 3
+            i32.shr_u
+            local.tee $2
+            i32.shr_u
+            local.tee $0
+            i32.const 3
+            i32.and
+            if ;; label = @5
+              block ;; label = @6
+                local.get $0
+                i32.const 1
+                i32.and
+                i32.const 1
+                i32.xor
+                local.get $2
+                i32.add
+                local.tee $5
+                i32.const 1
+                i32.shl
+                i32.const 2
+                i32.shl
+                i32.const 3684
+                i32.add
+                local.tee $2
+                i32.const 8
+                i32.add
+                local.tee $3
+                i32.load
+                local.tee $7
+                i32.const 8
+                i32.add
+                local.tee $1
+                i32.load
+                local.set $4
+                local.get $2
+                local.get $4
+                i32.eq
+                if ;; label = @7
+                  i32.const 3644
+                  local.get $8
+                  i32.const 1
+                  local.get $5
+                  i32.shl
+                  i32.const -1
+                  i32.xor
+                  i32.and
+                  i32.store
+                else
+                  block ;; label = @8
+                    local.get $4
+                    i32.const 3660
+                    i32.load
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                    local.get $4
+                    i32.const 12
+                    i32.add
+                    local.tee $0
+                    i32.load
+                    local.get $7
+                    i32.eq
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $0
+                        local.get $2
+                        i32.store
+                        local.get $3
+                        local.get $4
+                        i32.store
+                      end
+                    else
+                      call $fimport$10
+                    end
+                  end
+                end
+                local.get $7
+                local.get $5
+                i32.const 3
+                i32.shl
+                local.tee $0
+                i32.const 3
+                i32.or
+                i32.store offset=4
+                local.get $7
+                local.get $0
+                i32.add
+                i32.const 4
+                i32.add
+                local.tee $0
+                local.get $0
+                i32.load
+                i32.const 1
+                i32.or
+                i32.store
+                local.get $14
+                global.set $global$1
+                local.get $1
+                return
+              end
+            end
+            local.get $3
+            i32.const 3652
+            i32.load
+            local.tee $16
+            i32.gt_u
+            if ;; label = @5
+              block ;; label = @6
+                local.get $0
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $0
+                    local.get $2
+                    i32.shl
+                    i32.const 2
+                    local.get $2
+                    i32.shl
+                    local.tee $0
+                    i32.const 0
+                    local.get $0
+                    i32.sub
+                    i32.or
+                    i32.and
+                    local.tee $0
+                    i32.const 0
+                    local.get $0
+                    i32.sub
+                    i32.and
+                    i32.const -1
+                    i32.add
+                    local.tee $0
+                    i32.const 12
+                    i32.shr_u
+                    i32.const 16
+                    i32.and
+                    local.set $5
+                    local.get $0
+                    local.get $5
+                    i32.shr_u
+                    local.tee $2
+                    i32.const 5
+                    i32.shr_u
+                    i32.const 8
+                    i32.and
+                    local.tee $0
+                    local.get $5
+                    i32.or
+                    local.get $2
+                    local.get $0
+                    i32.shr_u
+                    local.tee $2
+                    i32.const 2
+                    i32.shr_u
+                    i32.const 4
+                    i32.and
+                    local.tee $0
+                    i32.or
+                    local.get $2
+                    local.get $0
+                    i32.shr_u
+                    local.tee $2
+                    i32.const 1
+                    i32.shr_u
+                    i32.const 2
+                    i32.and
+                    local.tee $0
+                    i32.or
+                    local.get $2
+                    local.get $0
+                    i32.shr_u
+                    local.tee $2
+                    i32.const 1
+                    i32.shr_u
+                    i32.const 1
+                    i32.and
+                    local.tee $0
+                    i32.or
+                    local.get $2
+                    local.get $0
+                    i32.shr_u
+                    i32.add
+                    local.tee $11
+                    i32.const 1
+                    i32.shl
+                    i32.const 2
+                    i32.shl
+                    i32.const 3684
+                    i32.add
+                    local.tee $4
+                    i32.const 8
+                    i32.add
+                    local.tee $2
+                    i32.load
+                    local.tee $9
+                    i32.const 8
+                    i32.add
+                    local.tee $5
+                    i32.load
+                    local.set $12
+                    local.get $4
+                    local.get $12
+                    i32.eq
+                    if ;; label = @9
+                      i32.const 3644
+                      local.get $8
+                      i32.const 1
+                      local.get $11
+                      i32.shl
+                      i32.const -1
+                      i32.xor
+                      i32.and
+                      local.tee $7
+                      i32.store
+                    else
+                      block ;; label = @10
+                        local.get $12
+                        i32.const 3660
+                        i32.load
+                        i32.lt_u
+                        if ;; label = @11
+                          call $fimport$10
+                        end
+                        local.get $12
+                        i32.const 12
+                        i32.add
+                        local.tee $0
+                        i32.load
+                        local.get $9
+                        i32.eq
+                        if ;; label = @11
+                          block ;; label = @12
+                            local.get $0
+                            local.get $4
+                            i32.store
+                            local.get $2
+                            local.get $12
+                            i32.store
+                            local.get $8
+                            local.set $7
+                          end
+                        else
+                          call $fimport$10
+                        end
+                      end
+                    end
+                    local.get $9
+                    local.get $3
+                    i32.const 3
+                    i32.or
+                    i32.store offset=4
+                    local.get $9
+                    local.get $3
+                    i32.add
+                    local.tee $4
+                    local.get $11
+                    i32.const 3
+                    i32.shl
+                    local.get $3
+                    i32.sub
+                    local.tee $11
+                    i32.const 1
+                    i32.or
+                    i32.store offset=4
+                    local.get $4
+                    local.get $11
+                    i32.add
+                    local.get $11
+                    i32.store
+                    local.get $16
+                    if ;; label = @9
+                      block ;; label = @10
+                        i32.const 3664
+                        i32.load
+                        local.set $9
+                        local.get $16
+                        i32.const 3
+                        i32.shr_u
+                        local.tee $0
+                        i32.const 1
+                        i32.shl
+                        i32.const 2
+                        i32.shl
+                        i32.const 3684
+                        i32.add
+                        local.set $2
+                        local.get $7
+                        i32.const 1
+                        local.get $0
+                        i32.shl
+                        local.tee $0
+                        i32.and
+                        if ;; label = @11
+                          local.get $2
+                          i32.const 8
+                          i32.add
+                          local.tee $3
+                          i32.load
+                          local.tee $0
+                          i32.const 3660
+                          i32.load
+                          i32.lt_u
+                          if ;; label = @12
+                            call $fimport$10
+                          else
+                            block ;; label = @13
+                              local.get $3
+                              local.set $6
+                              local.get $0
+                              local.set $1
+                            end
+                          end
+                        else
+                          block ;; label = @12
+                            i32.const 3644
+                            local.get $7
+                            local.get $0
+                            i32.or
+                            i32.store
+                            local.get $2
+                            i32.const 8
+                            i32.add
+                            local.set $6
+                            local.get $2
+                            local.set $1
+                          end
+                        end
+                        local.get $6
+                        local.get $9
+                        i32.store
+                        local.get $1
+                        local.get $9
+                        i32.store offset=12
+                        local.get $9
+                        local.get $1
+                        i32.store offset=8
+                        local.get $9
+                        local.get $2
+                        i32.store offset=12
+                      end
+                    end
+                    i32.const 3652
+                    local.get $11
+                    i32.store
+                    i32.const 3664
+                    local.get $4
+                    i32.store
+                    local.get $14
+                    global.set $global$1
+                    local.get $5
+                    return
+                  end
+                end
+                i32.const 3648
+                i32.load
+                local.tee $6
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $6
+                    i32.const 0
+                    local.get $6
+                    i32.sub
+                    i32.and
+                    i32.const -1
+                    i32.add
+                    local.tee $0
+                    i32.const 12
+                    i32.shr_u
+                    i32.const 16
+                    i32.and
+                    local.set $2
+                    local.get $0
+                    local.get $2
+                    i32.shr_u
+                    local.tee $1
+                    i32.const 5
+                    i32.shr_u
+                    i32.const 8
+                    i32.and
+                    local.tee $0
+                    local.get $2
+                    i32.or
+                    local.get $1
+                    local.get $0
+                    i32.shr_u
+                    local.tee $1
+                    i32.const 2
+                    i32.shr_u
+                    i32.const 4
+                    i32.and
+                    local.tee $0
+                    i32.or
+                    local.get $1
+                    local.get $0
+                    i32.shr_u
+                    local.tee $1
+                    i32.const 1
+                    i32.shr_u
+                    i32.const 2
+                    i32.and
+                    local.tee $0
+                    i32.or
+                    local.get $1
+                    local.get $0
+                    i32.shr_u
+                    local.tee $1
+                    i32.const 1
+                    i32.shr_u
+                    i32.const 1
+                    i32.and
+                    local.tee $0
+                    i32.or
+                    local.get $1
+                    local.get $0
+                    i32.shr_u
+                    i32.add
+                    i32.const 2
+                    i32.shl
+                    i32.const 3948
+                    i32.add
+                    i32.load
+                    local.tee $2
+                    i32.load offset=4
+                    i32.const -8
+                    i32.and
+                    local.get $3
+                    i32.sub
+                    local.set $9
+                    local.get $2
+                    local.set $1
+                    loop $label$25 ;; label = @9
+                      block $label$26 ;; label = @10
+                        local.get $1
+                        i32.load offset=16
+                        local.tee $0
+                        i32.eqz
+                        if ;; label = @11
+                          local.get $1
+                          i32.load offset=20
+                          local.tee $0
+                          i32.eqz
+                          br_if 1 (;@10;)
+                        end
+                        local.get $0
+                        i32.load offset=4
+                        i32.const -8
+                        i32.and
+                        local.get $3
+                        i32.sub
+                        local.tee $1
+                        local.get $9
+                        i32.lt_u
+                        local.tee $7
+                        if ;; label = @11
+                          local.get $1
+                          local.set $9
+                        end
+                        local.get $0
+                        local.set $1
+                        local.get $7
+                        if ;; label = @11
+                          local.get $0
+                          local.set $2
+                        end
+                        br 1 (;@9;)
+                      end
+                    end
+                    local.get $2
+                    i32.const 3660
+                    i32.load
+                    local.tee $12
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                    local.get $2
+                    local.get $2
+                    local.get $3
+                    i32.add
+                    local.tee $13
+                    i32.ge_u
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                    local.get $2
+                    i32.load offset=24
+                    local.set $15
+                    block $label$32 ;; label = @9
+                      local.get $2
+                      i32.load offset=12
+                      local.tee $0
+                      local.get $2
+                      i32.eq
+                      if ;; label = @10
+                        block ;; label = @11
+                          local.get $2
+                          i32.const 20
+                          i32.add
+                          local.tee $1
+                          i32.load
+                          local.tee $0
+                          i32.eqz
+                          if ;; label = @12
+                            local.get $2
+                            i32.const 16
+                            i32.add
+                            local.tee $1
+                            i32.load
+                            local.tee $0
+                            i32.eqz
+                            if ;; label = @13
+                              block ;; label = @14
+                                i32.const 0
+                                local.set $4
+                                br 5 (;@9;)
+                              end
+                            end
+                          end
+                          loop $label$36 ;; label = @12
+                            local.get $0
+                            i32.const 20
+                            i32.add
+                            local.tee $11
+                            i32.load
+                            local.tee $7
+                            if ;; label = @13
+                              block ;; label = @14
+                                local.get $7
+                                local.set $0
+                                local.get $11
+                                local.set $1
+                                br 2 (;@12;)
+                              end
+                            end
+                            local.get $0
+                            i32.const 16
+                            i32.add
+                            local.tee $11
+                            i32.load
+                            local.tee $7
+                            if ;; label = @13
+                              block ;; label = @14
+                                local.get $7
+                                local.set $0
+                                local.get $11
+                                local.set $1
+                                br 2 (;@12;)
+                              end
+                            end
+                          end
+                          local.get $1
+                          local.get $12
+                          i32.lt_u
+                          if ;; label = @12
+                            call $fimport$10
+                          else
+                            block ;; label = @13
+                              local.get $1
+                              i32.const 0
+                              i32.store
+                              local.get $0
+                              local.set $4
+                            end
+                          end
+                        end
+                      else
+                        block ;; label = @11
+                          local.get $2
+                          i32.load offset=8
+                          local.tee $11
+                          local.get $12
+                          i32.lt_u
+                          if ;; label = @12
+                            call $fimport$10
+                          end
+                          local.get $11
+                          i32.const 12
+                          i32.add
+                          local.tee $7
+                          i32.load
+                          local.get $2
+                          i32.ne
+                          if ;; label = @12
+                            call $fimport$10
+                          end
+                          local.get $0
+                          i32.const 8
+                          i32.add
+                          local.tee $1
+                          i32.load
+                          local.get $2
+                          i32.eq
+                          if ;; label = @12
+                            block ;; label = @13
+                              local.get $7
+                              local.get $0
+                              i32.store
+                              local.get $1
+                              local.get $11
+                              i32.store
+                              local.get $0
+                              local.set $4
+                            end
+                          else
+                            call $fimport$10
+                          end
+                        end
+                      end
+                    end
+                    block $label$46 ;; label = @9
+                      local.get $15
+                      if ;; label = @10
+                        block ;; label = @11
+                          local.get $2
+                          local.get $2
+                          i32.load offset=28
+                          local.tee $1
+                          i32.const 2
+                          i32.shl
+                          i32.const 3948
+                          i32.add
+                          local.tee $0
+                          i32.load
+                          i32.eq
+                          if ;; label = @12
+                            block ;; label = @13
+                              local.get $0
+                              local.get $4
+                              i32.store
+                              local.get $4
+                              i32.eqz
+                              if ;; label = @14
+                                block ;; label = @15
+                                  i32.const 3648
+                                  local.get $6
+                                  i32.const 1
+                                  local.get $1
+                                  i32.shl
+                                  i32.const -1
+                                  i32.xor
+                                  i32.and
+                                  i32.store
+                                  br 6 (;@9;)
+                                end
+                              end
+                            end
+                          else
+                            block ;; label = @13
+                              local.get $15
+                              i32.const 3660
+                              i32.load
+                              i32.lt_u
+                              if ;; label = @14
+                                call $fimport$10
+                              end
+                              local.get $15
+                              i32.const 16
+                              i32.add
+                              local.tee $0
+                              i32.load
+                              local.get $2
+                              i32.eq
+                              if ;; label = @14
+                                local.get $0
+                                local.get $4
+                                i32.store
+                              else
+                                local.get $15
+                                local.get $4
+                                i32.store offset=20
+                              end
+                              local.get $4
+                              i32.eqz
+                              br_if 4 (;@9;)
+                            end
+                          end
+                          local.get $4
+                          i32.const 3660
+                          i32.load
+                          local.tee $0
+                          i32.lt_u
+                          if ;; label = @12
+                            call $fimport$10
+                          end
+                          local.get $4
+                          local.get $15
+                          i32.store offset=24
+                          local.get $2
+                          i32.load offset=16
+                          local.tee $1
+                          if ;; label = @12
+                            local.get $1
+                            local.get $0
+                            i32.lt_u
+                            if ;; label = @13
+                              call $fimport$10
+                            else
+                              block ;; label = @14
+                                local.get $4
+                                local.get $1
+                                i32.store offset=16
+                                local.get $1
+                                local.get $4
+                                i32.store offset=24
+                              end
+                            end
+                          end
+                          local.get $2
+                          i32.load offset=20
+                          local.tee $0
+                          if ;; label = @12
+                            local.get $0
+                            i32.const 3660
+                            i32.load
+                            i32.lt_u
+                            if ;; label = @13
+                              call $fimport$10
+                            else
+                              block ;; label = @14
+                                local.get $4
+                                local.get $0
+                                i32.store offset=20
+                                local.get $0
+                                local.get $4
+                                i32.store offset=24
+                              end
+                            end
+                          end
+                        end
+                      end
+                    end
+                    local.get $9
+                    i32.const 16
+                    i32.lt_u
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $2
+                        local.get $9
+                        local.get $3
+                        i32.add
+                        local.tee $0
+                        i32.const 3
+                        i32.or
+                        i32.store offset=4
+                        local.get $2
+                        local.get $0
+                        i32.add
+                        i32.const 4
+                        i32.add
+                        local.tee $0
+                        local.get $0
+                        i32.load
+                        i32.const 1
+                        i32.or
+                        i32.store
+                      end
+                    else
+                      block ;; label = @10
+                        local.get $2
+                        local.get $3
+                        i32.const 3
+                        i32.or
+                        i32.store offset=4
+                        local.get $13
+                        local.get $9
+                        i32.const 1
+                        i32.or
+                        i32.store offset=4
+                        local.get $13
+                        local.get $9
+                        i32.add
+                        local.get $9
+                        i32.store
+                        local.get $16
+                        if ;; label = @11
+                          block ;; label = @12
+                            i32.const 3664
+                            i32.load
+                            local.set $7
+                            local.get $16
+                            i32.const 3
+                            i32.shr_u
+                            local.tee $0
+                            i32.const 1
+                            i32.shl
+                            i32.const 2
+                            i32.shl
+                            i32.const 3684
+                            i32.add
+                            local.set $3
+                            local.get $8
+                            i32.const 1
+                            local.get $0
+                            i32.shl
+                            local.tee $0
+                            i32.and
+                            if ;; label = @13
+                              local.get $3
+                              i32.const 8
+                              i32.add
+                              local.tee $1
+                              i32.load
+                              local.tee $0
+                              i32.const 3660
+                              i32.load
+                              i32.lt_u
+                              if ;; label = @14
+                                call $fimport$10
+                              else
+                                block ;; label = @15
+                                  local.get $1
+                                  local.set $10
+                                  local.get $0
+                                  local.set $5
+                                end
+                              end
+                            else
+                              block ;; label = @14
+                                i32.const 3644
+                                local.get $8
+                                local.get $0
+                                i32.or
+                                i32.store
+                                local.get $3
+                                i32.const 8
+                                i32.add
+                                local.set $10
+                                local.get $3
+                                local.set $5
+                              end
+                            end
+                            local.get $10
+                            local.get $7
+                            i32.store
+                            local.get $5
+                            local.get $7
+                            i32.store offset=12
+                            local.get $7
+                            local.get $5
+                            i32.store offset=8
+                            local.get $7
+                            local.get $3
+                            i32.store offset=12
+                          end
+                        end
+                        i32.const 3652
+                        local.get $9
+                        i32.store
+                        i32.const 3664
+                        local.get $13
+                        i32.store
+                      end
+                    end
+                    local.get $14
+                    global.set $global$1
+                    local.get $2
+                    i32.const 8
+                    i32.add
+                    return
+                  end
+                else
+                  local.get $3
+                  local.set $0
+                end
+              end
+            else
+              local.get $3
+              local.set $0
+            end
+          end
+        else
+          local.get $0
+          i32.const -65
+          i32.gt_u
+          if ;; label = @4
+            i32.const -1
+            local.set $0
+          else
+            block ;; label = @5
+              local.get $0
+              i32.const 11
+              i32.add
+              local.tee $0
+              i32.const -8
+              i32.and
+              local.set $7
+              i32.const 3648
+              i32.load
+              local.tee $5
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $0
+                  i32.const 8
+                  i32.shr_u
+                  local.tee $0
+                  if (result i32) ;; label = @8
+                    local.get $7
+                    i32.const 16777215
+                    i32.gt_u
+                    if (result i32) ;; label = @9
+                      i32.const 31
+                    else
+                      local.get $7
+                      i32.const 14
+                      local.get $0
+                      local.get $0
+                      i32.const 1048320
+                      i32.add
+                      i32.const 16
+                      i32.shr_u
+                      i32.const 8
+                      i32.and
+                      local.tee $3
+                      i32.shl
+                      local.tee $1
+                      i32.const 520192
+                      i32.add
+                      i32.const 16
+                      i32.shr_u
+                      i32.const 4
+                      i32.and
+                      local.tee $0
+                      local.get $3
+                      i32.or
+                      local.get $1
+                      local.get $0
+                      i32.shl
+                      local.tee $1
+                      i32.const 245760
+                      i32.add
+                      i32.const 16
+                      i32.shr_u
+                      i32.const 2
+                      i32.and
+                      local.tee $0
+                      i32.or
+                      i32.sub
+                      local.get $1
+                      local.get $0
+                      i32.shl
+                      i32.const 15
+                      i32.shr_u
+                      i32.add
+                      local.tee $0
+                      i32.const 7
+                      i32.add
+                      i32.shr_u
+                      i32.const 1
+                      i32.and
+                      local.get $0
+                      i32.const 1
+                      i32.shl
+                      i32.or
+                    end
+                  else
+                    i32.const 0
+                  end
+                  local.set $17
+                  i32.const 0
+                  local.get $7
+                  i32.sub
+                  local.set $3
+                  block $label$78 ;; label = @8
+                    block $label$79 ;; label = @9
+                      block $label$80 ;; label = @10
+                        local.get $17
+                        i32.const 2
+                        i32.shl
+                        i32.const 3948
+                        i32.add
+                        i32.load
+                        local.tee $1
+                        if ;; label = @11
+                          block ;; label = @12
+                            i32.const 25
+                            local.get $17
+                            i32.const 1
+                            i32.shr_u
+                            i32.sub
+                            local.set $0
+                            i32.const 0
+                            local.set $4
+                            local.get $7
+                            local.get $17
+                            i32.const 31
+                            i32.eq
+                            if (result i32) ;; label = @13
+                              i32.const 0
+                            else
+                              local.get $0
+                            end
+                            i32.shl
+                            local.set $10
+                            i32.const 0
+                            local.set $0
+                            loop $label$84 ;; label = @13
+                              local.get $1
+                              i32.load offset=4
+                              i32.const -8
+                              i32.and
+                              local.get $7
+                              i32.sub
+                              local.tee $6
+                              local.get $3
+                              i32.lt_u
+                              if ;; label = @14
+                                local.get $6
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $6
+                                    local.set $3
+                                    local.get $1
+                                    local.set $0
+                                  end
+                                else
+                                  block ;; label = @16
+                                    i32.const 0
+                                    local.set $3
+                                    local.get $1
+                                    local.set $0
+                                    br 7 (;@9;)
+                                  end
+                                end
+                              end
+                              local.get $1
+                              i32.load offset=20
+                              local.tee $19
+                              i32.eqz
+                              local.get $19
+                              local.get $1
+                              i32.const 16
+                              i32.add
+                              local.get $10
+                              i32.const 31
+                              i32.shr_u
+                              i32.const 2
+                              i32.shl
+                              i32.add
+                              i32.load
+                              local.tee $6
+                              i32.eq
+                              i32.or
+                              if (result i32) ;; label = @14
+                                local.get $4
+                              else
+                                local.get $19
+                              end
+                              local.set $1
+                              local.get $10
+                              local.get $6
+                              i32.eqz
+                              local.tee $4
+                              i32.const 1
+                              i32.and
+                              i32.const 1
+                              i32.xor
+                              i32.shl
+                              local.set $10
+                              local.get $4
+                              if ;; label = @14
+                                block ;; label = @15
+                                  local.get $1
+                                  local.set $4
+                                  local.get $0
+                                  local.set $1
+                                  br 5 (;@10;)
+                                end
+                              else
+                                block ;; label = @15
+                                  local.get $1
+                                  local.set $4
+                                  local.get $6
+                                  local.set $1
+                                  br 2 (;@13;)
+                                end
+                              end
+                            end
+                          end
+                        else
+                          block ;; label = @12
+                            i32.const 0
+                            local.set $4
+                            i32.const 0
+                            local.set $1
+                          end
+                        end
+                      end
+                      local.get $4
+                      i32.eqz
+                      local.get $1
+                      i32.eqz
+                      i32.and
+                      if (result i32) ;; label = @10
+                        block (result i32) ;; label = @11
+                          local.get $5
+                          i32.const 2
+                          local.get $17
+                          i32.shl
+                          local.tee $0
+                          i32.const 0
+                          local.get $0
+                          i32.sub
+                          i32.or
+                          i32.and
+                          local.tee $0
+                          i32.eqz
+                          if ;; label = @12
+                            block ;; label = @13
+                              local.get $7
+                              local.set $0
+                              br 11 (;@2;)
+                            end
+                          end
+                          local.get $0
+                          i32.const 0
+                          local.get $0
+                          i32.sub
+                          i32.and
+                          i32.const -1
+                          i32.add
+                          local.tee $0
+                          i32.const 12
+                          i32.shr_u
+                          i32.const 16
+                          i32.and
+                          local.set $10
+                          local.get $0
+                          local.get $10
+                          i32.shr_u
+                          local.tee $4
+                          i32.const 5
+                          i32.shr_u
+                          i32.const 8
+                          i32.and
+                          local.tee $0
+                          local.get $10
+                          i32.or
+                          local.get $4
+                          local.get $0
+                          i32.shr_u
+                          local.tee $4
+                          i32.const 2
+                          i32.shr_u
+                          i32.const 4
+                          i32.and
+                          local.tee $0
+                          i32.or
+                          local.get $4
+                          local.get $0
+                          i32.shr_u
+                          local.tee $4
+                          i32.const 1
+                          i32.shr_u
+                          i32.const 2
+                          i32.and
+                          local.tee $0
+                          i32.or
+                          local.get $4
+                          local.get $0
+                          i32.shr_u
+                          local.tee $4
+                          i32.const 1
+                          i32.shr_u
+                          i32.const 1
+                          i32.and
+                          local.tee $0
+                          i32.or
+                          local.get $4
+                          local.get $0
+                          i32.shr_u
+                          i32.add
+                          i32.const 2
+                          i32.shl
+                          i32.const 3948
+                          i32.add
+                          i32.load
+                        end
+                      else
+                        local.get $4
+                      end
+                      local.tee $0
+                      br_if 0 (;@9;)
+                      local.get $1
+                      local.set $4
+                      br 1 (;@8;)
+                    end
+                    loop $label$96 ;; label = @9
+                      local.get $0
+                      i32.load offset=4
+                      i32.const -8
+                      i32.and
+                      local.get $7
+                      i32.sub
+                      local.tee $4
+                      local.get $3
+                      i32.lt_u
+                      local.tee $10
+                      if ;; label = @10
+                        local.get $4
+                        local.set $3
+                      end
+                      local.get $10
+                      if ;; label = @10
+                        local.get $0
+                        local.set $1
+                      end
+                      local.get $0
+                      i32.load offset=16
+                      local.tee $4
+                      if ;; label = @10
+                        block ;; label = @11
+                          local.get $4
+                          local.set $0
+                          br 2 (;@9;)
+                        end
+                      end
+                      local.get $0
+                      i32.load offset=20
+                      local.tee $0
+                      br_if 0 (;@9;)
+                      local.get $1
+                      local.set $4
+                    end
+                  end
+                  local.get $4
+                  if ;; label = @8
+                    local.get $3
+                    i32.const 3652
+                    i32.load
+                    local.get $7
+                    i32.sub
+                    i32.lt_u
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $4
+                        i32.const 3660
+                        i32.load
+                        local.tee $12
+                        i32.lt_u
+                        if ;; label = @11
+                          call $fimport$10
+                        end
+                        local.get $4
+                        local.get $4
+                        local.get $7
+                        i32.add
+                        local.tee $6
+                        i32.ge_u
+                        if ;; label = @11
+                          call $fimport$10
+                        end
+                        local.get $4
+                        i32.load offset=24
+                        local.set $10
+                        block $label$104 ;; label = @11
+                          local.get $4
+                          i32.load offset=12
+                          local.tee $0
+                          local.get $4
+                          i32.eq
+                          if ;; label = @12
+                            block ;; label = @13
+                              local.get $4
+                              i32.const 20
+                              i32.add
+                              local.tee $1
+                              i32.load
+                              local.tee $0
+                              i32.eqz
+                              if ;; label = @14
+                                local.get $4
+                                i32.const 16
+                                i32.add
+                                local.tee $1
+                                i32.load
+                                local.tee $0
+                                i32.eqz
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    i32.const 0
+                                    local.set $13
+                                    br 5 (;@11;)
+                                  end
+                                end
+                              end
+                              loop $label$108 ;; label = @14
+                                local.get $0
+                                i32.const 20
+                                i32.add
+                                local.tee $9
+                                i32.load
+                                local.tee $11
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $11
+                                    local.set $0
+                                    local.get $9
+                                    local.set $1
+                                    br 2 (;@14;)
+                                  end
+                                end
+                                local.get $0
+                                i32.const 16
+                                i32.add
+                                local.tee $9
+                                i32.load
+                                local.tee $11
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $11
+                                    local.set $0
+                                    local.get $9
+                                    local.set $1
+                                    br 2 (;@14;)
+                                  end
+                                end
+                              end
+                              local.get $1
+                              local.get $12
+                              i32.lt_u
+                              if ;; label = @14
+                                call $fimport$10
+                              else
+                                block ;; label = @15
+                                  local.get $1
+                                  i32.const 0
+                                  i32.store
+                                  local.get $0
+                                  local.set $13
+                                end
+                              end
+                            end
+                          else
+                            block ;; label = @13
+                              local.get $4
+                              i32.load offset=8
+                              local.tee $9
+                              local.get $12
+                              i32.lt_u
+                              if ;; label = @14
+                                call $fimport$10
+                              end
+                              local.get $9
+                              i32.const 12
+                              i32.add
+                              local.tee $11
+                              i32.load
+                              local.get $4
+                              i32.ne
+                              if ;; label = @14
+                                call $fimport$10
+                              end
+                              local.get $0
+                              i32.const 8
+                              i32.add
+                              local.tee $1
+                              i32.load
+                              local.get $4
+                              i32.eq
+                              if ;; label = @14
+                                block ;; label = @15
+                                  local.get $11
+                                  local.get $0
+                                  i32.store
+                                  local.get $1
+                                  local.get $9
+                                  i32.store
+                                  local.get $0
+                                  local.set $13
+                                end
+                              else
+                                call $fimport$10
+                              end
+                            end
+                          end
+                        end
+                        block $label$118 ;; label = @11
+                          local.get $10
+                          if ;; label = @12
+                            block ;; label = @13
+                              local.get $4
+                              local.get $4
+                              i32.load offset=28
+                              local.tee $1
+                              i32.const 2
+                              i32.shl
+                              i32.const 3948
+                              i32.add
+                              local.tee $0
+                              i32.load
+                              i32.eq
+                              if ;; label = @14
+                                block ;; label = @15
+                                  local.get $0
+                                  local.get $13
+                                  i32.store
+                                  local.get $13
+                                  i32.eqz
+                                  if ;; label = @16
+                                    block ;; label = @17
+                                      i32.const 3648
+                                      local.get $5
+                                      i32.const 1
+                                      local.get $1
+                                      i32.shl
+                                      i32.const -1
+                                      i32.xor
+                                      i32.and
+                                      local.tee $2
+                                      i32.store
+                                      br 6 (;@11;)
+                                    end
+                                  end
+                                end
+                              else
+                                block ;; label = @15
+                                  local.get $10
+                                  i32.const 3660
+                                  i32.load
+                                  i32.lt_u
+                                  if ;; label = @16
+                                    call $fimport$10
+                                  end
+                                  local.get $10
+                                  i32.const 16
+                                  i32.add
+                                  local.tee $0
+                                  i32.load
+                                  local.get $4
+                                  i32.eq
+                                  if ;; label = @16
+                                    local.get $0
+                                    local.get $13
+                                    i32.store
+                                  else
+                                    local.get $10
+                                    local.get $13
+                                    i32.store offset=20
+                                  end
+                                  local.get $13
+                                  i32.eqz
+                                  if ;; label = @16
+                                    block ;; label = @17
+                                      local.get $5
+                                      local.set $2
+                                      br 6 (;@11;)
+                                    end
+                                  end
+                                end
+                              end
+                              local.get $13
+                              i32.const 3660
+                              i32.load
+                              local.tee $0
+                              i32.lt_u
+                              if ;; label = @14
+                                call $fimport$10
+                              end
+                              local.get $13
+                              local.get $10
+                              i32.store offset=24
+                              local.get $4
+                              i32.load offset=16
+                              local.tee $1
+                              if ;; label = @14
+                                local.get $1
+                                local.get $0
+                                i32.lt_u
+                                if ;; label = @15
+                                  call $fimport$10
+                                else
+                                  block ;; label = @16
+                                    local.get $13
+                                    local.get $1
+                                    i32.store offset=16
+                                    local.get $1
+                                    local.get $13
+                                    i32.store offset=24
+                                  end
+                                end
+                              end
+                              local.get $4
+                              i32.load offset=20
+                              local.tee $0
+                              if ;; label = @14
+                                local.get $0
+                                i32.const 3660
+                                i32.load
+                                i32.lt_u
+                                if ;; label = @15
+                                  call $fimport$10
+                                else
+                                  block ;; label = @16
+                                    local.get $13
+                                    local.get $0
+                                    i32.store offset=20
+                                    local.get $0
+                                    local.get $13
+                                    i32.store offset=24
+                                    local.get $5
+                                    local.set $2
+                                  end
+                                end
+                              else
+                                local.get $5
+                                local.set $2
+                              end
+                            end
+                          else
+                            local.get $5
+                            local.set $2
+                          end
+                        end
+                        block $label$136 ;; label = @11
+                          local.get $3
+                          i32.const 16
+                          i32.lt_u
+                          if ;; label = @12
+                            block ;; label = @13
+                              local.get $4
+                              local.get $3
+                              local.get $7
+                              i32.add
+                              local.tee $0
+                              i32.const 3
+                              i32.or
+                              i32.store offset=4
+                              local.get $4
+                              local.get $0
+                              i32.add
+                              i32.const 4
+                              i32.add
+                              local.tee $0
+                              local.get $0
+                              i32.load
+                              i32.const 1
+                              i32.or
+                              i32.store
+                            end
+                          else
+                            block ;; label = @13
+                              local.get $4
+                              local.get $7
+                              i32.const 3
+                              i32.or
+                              i32.store offset=4
+                              local.get $6
+                              local.get $3
+                              i32.const 1
+                              i32.or
+                              i32.store offset=4
+                              local.get $6
+                              local.get $3
+                              i32.add
+                              local.get $3
+                              i32.store
+                              local.get $3
+                              i32.const 3
+                              i32.shr_u
+                              local.set $0
+                              local.get $3
+                              i32.const 256
+                              i32.lt_u
+                              if ;; label = @14
+                                block ;; label = @15
+                                  local.get $0
+                                  i32.const 1
+                                  i32.shl
+                                  i32.const 2
+                                  i32.shl
+                                  i32.const 3684
+                                  i32.add
+                                  local.set $3
+                                  i32.const 3644
+                                  i32.load
+                                  local.tee $1
+                                  i32.const 1
+                                  local.get $0
+                                  i32.shl
+                                  local.tee $0
+                                  i32.and
+                                  if ;; label = @16
+                                    local.get $3
+                                    i32.const 8
+                                    i32.add
+                                    local.tee $1
+                                    i32.load
+                                    local.tee $0
+                                    i32.const 3660
+                                    i32.load
+                                    i32.lt_u
+                                    if ;; label = @17
+                                      call $fimport$10
+                                    else
+                                      block ;; label = @18
+                                        local.get $1
+                                        local.set $16
+                                        local.get $0
+                                        local.set $8
+                                      end
+                                    end
+                                  else
+                                    block ;; label = @17
+                                      i32.const 3644
+                                      local.get $1
+                                      local.get $0
+                                      i32.or
+                                      i32.store
+                                      local.get $3
+                                      i32.const 8
+                                      i32.add
+                                      local.set $16
+                                      local.get $3
+                                      local.set $8
+                                    end
+                                  end
+                                  local.get $16
+                                  local.get $6
+                                  i32.store
+                                  local.get $8
+                                  local.get $6
+                                  i32.store offset=12
+                                  local.get $6
+                                  local.get $8
+                                  i32.store offset=8
+                                  local.get $6
+                                  local.get $3
+                                  i32.store offset=12
+                                  br 4 (;@11;)
+                                end
+                              end
+                              local.get $3
+                              i32.const 8
+                              i32.shr_u
+                              local.tee $0
+                              if (result i32) ;; label = @14
+                                local.get $3
+                                i32.const 16777215
+                                i32.gt_u
+                                if (result i32) ;; label = @15
+                                  i32.const 31
+                                else
+                                  local.get $3
+                                  i32.const 14
+                                  local.get $0
+                                  local.get $0
+                                  i32.const 1048320
+                                  i32.add
+                                  i32.const 16
+                                  i32.shr_u
+                                  i32.const 8
+                                  i32.and
+                                  local.tee $5
+                                  i32.shl
+                                  local.tee $1
+                                  i32.const 520192
+                                  i32.add
+                                  i32.const 16
+                                  i32.shr_u
+                                  i32.const 4
+                                  i32.and
+                                  local.tee $0
+                                  local.get $5
+                                  i32.or
+                                  local.get $1
+                                  local.get $0
+                                  i32.shl
+                                  local.tee $1
+                                  i32.const 245760
+                                  i32.add
+                                  i32.const 16
+                                  i32.shr_u
+                                  i32.const 2
+                                  i32.and
+                                  local.tee $0
+                                  i32.or
+                                  i32.sub
+                                  local.get $1
+                                  local.get $0
+                                  i32.shl
+                                  i32.const 15
+                                  i32.shr_u
+                                  i32.add
+                                  local.tee $0
+                                  i32.const 7
+                                  i32.add
+                                  i32.shr_u
+                                  i32.const 1
+                                  i32.and
+                                  local.get $0
+                                  i32.const 1
+                                  i32.shl
+                                  i32.or
+                                end
+                              else
+                                i32.const 0
+                              end
+                              local.tee $5
+                              i32.const 2
+                              i32.shl
+                              i32.const 3948
+                              i32.add
+                              local.set $1
+                              local.get $6
+                              local.get $5
+                              i32.store offset=28
+                              local.get $6
+                              i32.const 16
+                              i32.add
+                              local.tee $0
+                              i32.const 0
+                              i32.store offset=4
+                              local.get $0
+                              i32.const 0
+                              i32.store
+                              local.get $2
+                              i32.const 1
+                              local.get $5
+                              i32.shl
+                              local.tee $0
+                              i32.and
+                              i32.eqz
+                              if ;; label = @14
+                                block ;; label = @15
+                                  i32.const 3648
+                                  local.get $2
+                                  local.get $0
+                                  i32.or
+                                  i32.store
+                                  local.get $1
+                                  local.get $6
+                                  i32.store
+                                  local.get $6
+                                  local.get $1
+                                  i32.store offset=24
+                                  local.get $6
+                                  local.get $6
+                                  i32.store offset=12
+                                  local.get $6
+                                  local.get $6
+                                  i32.store offset=8
+                                  br 4 (;@11;)
+                                end
+                              end
+                              local.get $1
+                              i32.load
+                              local.set $0
+                              i32.const 25
+                              local.get $5
+                              i32.const 1
+                              i32.shr_u
+                              i32.sub
+                              local.set $1
+                              local.get $3
+                              local.get $5
+                              i32.const 31
+                              i32.eq
+                              if (result i32) ;; label = @14
+                                i32.const 0
+                              else
+                                local.get $1
+                              end
+                              i32.shl
+                              local.set $5
+                              block $label$151 ;; label = @14
+                                block $label$152 ;; label = @15
+                                  block $label$153 ;; label = @16
+                                    loop $label$154 ;; label = @17
+                                      local.get $0
+                                      i32.load offset=4
+                                      i32.const -8
+                                      i32.and
+                                      local.get $3
+                                      i32.eq
+                                      br_if 2 (;@15;)
+                                      local.get $5
+                                      i32.const 1
+                                      i32.shl
+                                      local.set $2
+                                      local.get $0
+                                      i32.const 16
+                                      i32.add
+                                      local.get $5
+                                      i32.const 31
+                                      i32.shr_u
+                                      i32.const 2
+                                      i32.shl
+                                      i32.add
+                                      local.tee $5
+                                      i32.load
+                                      local.tee $1
+                                      i32.eqz
+                                      br_if 1 (;@16;)
+                                      local.get $2
+                                      local.set $5
+                                      local.get $1
+                                      local.set $0
+                                      br 0 (;@17;)
+                                    end
+                                  end
+                                  local.get $5
+                                  i32.const 3660
+                                  i32.load
+                                  i32.lt_u
+                                  if ;; label = @16
+                                    call $fimport$10
+                                  else
+                                    block ;; label = @17
+                                      local.get $5
+                                      local.get $6
+                                      i32.store
+                                      local.get $6
+                                      local.get $0
+                                      i32.store offset=24
+                                      local.get $6
+                                      local.get $6
+                                      i32.store offset=12
+                                      local.get $6
+                                      local.get $6
+                                      i32.store offset=8
+                                      br 6 (;@11;)
+                                    end
+                                  end
+                                  br 1 (;@14;)
+                                end
+                                local.get $0
+                                i32.const 8
+                                i32.add
+                                local.tee $3
+                                i32.load
+                                local.tee $2
+                                i32.const 3660
+                                i32.load
+                                local.tee $1
+                                i32.ge_u
+                                local.get $0
+                                local.get $1
+                                i32.ge_u
+                                i32.and
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $2
+                                    local.get $6
+                                    i32.store offset=12
+                                    local.get $3
+                                    local.get $6
+                                    i32.store
+                                    local.get $6
+                                    local.get $2
+                                    i32.store offset=8
+                                    local.get $6
+                                    local.get $0
+                                    i32.store offset=12
+                                    local.get $6
+                                    i32.const 0
+                                    i32.store offset=24
+                                  end
+                                else
+                                  call $fimport$10
+                                end
+                              end
+                            end
+                          end
+                        end
+                        local.get $14
+                        global.set $global$1
+                        local.get $4
+                        i32.const 8
+                        i32.add
+                        return
+                      end
+                    else
+                      local.get $7
+                      local.set $0
+                    end
+                  else
+                    local.get $7
+                    local.set $0
+                  end
+                end
+              else
+                local.get $7
+                local.set $0
+              end
+            end
+          end
+        end
+      end
+      i32.const 3652
+      i32.load
+      local.tee $1
+      local.get $0
+      i32.ge_u
+      if ;; label = @2
+        block ;; label = @3
+          i32.const 3664
+          i32.load
+          local.set $2
+          local.get $1
+          local.get $0
+          i32.sub
+          local.tee $3
+          i32.const 15
+          i32.gt_u
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 3664
+              local.get $2
+              local.get $0
+              i32.add
+              local.tee $1
+              i32.store
+              i32.const 3652
+              local.get $3
+              i32.store
+              local.get $1
+              local.get $3
+              i32.const 1
+              i32.or
+              i32.store offset=4
+              local.get $1
+              local.get $3
+              i32.add
+              local.get $3
+              i32.store
+              local.get $2
+              local.get $0
+              i32.const 3
+              i32.or
+              i32.store offset=4
+            end
+          else
+            block ;; label = @5
+              i32.const 3652
+              i32.const 0
+              i32.store
+              i32.const 3664
+              i32.const 0
+              i32.store
+              local.get $2
+              local.get $1
+              i32.const 3
+              i32.or
+              i32.store offset=4
+              local.get $2
+              local.get $1
+              i32.add
+              i32.const 4
+              i32.add
+              local.tee $0
+              local.get $0
+              i32.load
+              i32.const 1
+              i32.or
+              i32.store
+            end
+          end
+          local.get $14
+          global.set $global$1
+          local.get $2
+          i32.const 8
+          i32.add
+          return
+        end
+      end
+      i32.const 3656
+      i32.load
+      local.tee $10
+      local.get $0
+      i32.gt_u
+      if ;; label = @2
+        block ;; label = @3
+          i32.const 3656
+          local.get $10
+          local.get $0
+          i32.sub
+          local.tee $3
+          i32.store
+          i32.const 3668
+          i32.const 3668
+          i32.load
+          local.tee $2
+          local.get $0
+          i32.add
+          local.tee $1
+          i32.store
+          local.get $1
+          local.get $3
+          i32.const 1
+          i32.or
+          i32.store offset=4
+          local.get $2
+          local.get $0
+          i32.const 3
+          i32.or
+          i32.store offset=4
+          local.get $14
+          global.set $global$1
+          local.get $2
+          i32.const 8
+          i32.add
+          return
+        end
+      end
+      i32.const 4116
+      i32.load
+      if (result i32) ;; label = @2
+        i32.const 4124
+        i32.load
+      else
+        block (result i32) ;; label = @3
+          i32.const 4124
+          i32.const 4096
+          i32.store
+          i32.const 4120
+          i32.const 4096
+          i32.store
+          i32.const 4128
+          i32.const -1
+          i32.store
+          i32.const 4132
+          i32.const -1
+          i32.store
+          i32.const 4136
+          i32.const 0
+          i32.store
+          i32.const 4088
+          i32.const 0
+          i32.store
+          local.get $18
+          local.get $18
+          i32.const -16
+          i32.and
+          i32.const 1431655768
+          i32.xor
+          local.tee $1
+          i32.store
+          i32.const 4116
+          local.get $1
+          i32.store
+          i32.const 4096
+        end
+      end
+      local.tee $1
+      local.get $0
+      i32.const 47
+      i32.add
+      local.tee $13
+      i32.add
+      local.tee $8
+      i32.const 0
+      local.get $1
+      i32.sub
+      local.tee $4
+      i32.and
+      local.tee $6
+      local.get $0
+      i32.le_u
+      if ;; label = @2
+        block ;; label = @3
+          local.get $14
+          global.set $global$1
+          i32.const 0
+          return
+        end
+      end
+      i32.const 4084
+      i32.load
+      local.tee $2
+      if ;; label = @2
+        i32.const 4076
+        i32.load
+        local.tee $3
+        local.get $6
+        i32.add
+        local.tee $1
+        local.get $3
+        i32.le_u
+        local.get $1
+        local.get $2
+        i32.gt_u
+        i32.or
+        if ;; label = @3
+          block ;; label = @4
+            local.get $14
+            global.set $global$1
+            i32.const 0
+            return
+          end
+        end
+      end
+      local.get $0
+      i32.const 48
+      i32.add
+      local.set $7
+      block $label$171 ;; label = @2
+        block $label$172 ;; label = @3
+          i32.const 4088
+          i32.load
+          i32.const 4
+          i32.and
+          i32.eqz
+          if ;; label = @4
+            block ;; label = @5
+              block $label$174 ;; label = @6
+                block $label$175 ;; label = @7
+                  block $label$176 ;; label = @8
+                    i32.const 3668
+                    i32.load
+                    local.tee $3
+                    i32.eqz
+                    br_if 0 (;@8;)
+                    i32.const 4092
+                    local.set $2
+                    loop $label$177 ;; label = @9
+                      block $label$178 ;; label = @10
+                        local.get $2
+                        i32.load
+                        local.tee $1
+                        local.get $3
+                        i32.le_u
+                        if ;; label = @11
+                          local.get $1
+                          local.get $2
+                          i32.const 4
+                          i32.add
+                          local.tee $5
+                          i32.load
+                          i32.add
+                          local.get $3
+                          i32.gt_u
+                          br_if 1 (;@10;)
+                        end
+                        local.get $2
+                        i32.load offset=8
+                        local.tee $1
+                        i32.eqz
+                        br_if 2 (;@8;)
+                        local.get $1
+                        local.set $2
+                        br 1 (;@9;)
+                      end
+                    end
+                    local.get $8
+                    local.get $10
+                    i32.sub
+                    local.get $4
+                    i32.and
+                    local.tee $3
+                    i32.const 2147483647
+                    i32.lt_u
+                    if ;; label = @9
+                      local.get $3
+                      call $34
+                      local.tee $1
+                      local.get $2
+                      i32.load
+                      local.get $5
+                      i32.load
+                      i32.add
+                      i32.eq
+                      if ;; label = @10
+                        local.get $1
+                        i32.const -1
+                        i32.ne
+                        br_if 7 (;@3;)
+                      else
+                        block ;; label = @11
+                          local.get $1
+                          local.set $2
+                          local.get $3
+                          local.set $1
+                          br 4 (;@7;)
+                        end
+                      end
+                    end
+                    br 2 (;@6;)
+                  end
+                  i32.const 0
+                  call $34
+                  local.tee $1
+                  i32.const -1
+                  i32.ne
+                  if ;; label = @8
+                    block ;; label = @9
+                      i32.const 4120
+                      i32.load
+                      local.tee $2
+                      i32.const -1
+                      i32.add
+                      local.tee $5
+                      local.get $1
+                      local.tee $3
+                      i32.add
+                      i32.const 0
+                      local.get $2
+                      i32.sub
+                      i32.and
+                      local.get $3
+                      i32.sub
+                      local.set $2
+                      local.get $5
+                      local.get $3
+                      i32.and
+                      if (result i32) ;; label = @10
+                        local.get $2
+                      else
+                        i32.const 0
+                      end
+                      local.get $6
+                      i32.add
+                      local.tee $3
+                      i32.const 4076
+                      i32.load
+                      local.tee $5
+                      i32.add
+                      local.set $4
+                      local.get $3
+                      local.get $0
+                      i32.gt_u
+                      local.get $3
+                      i32.const 2147483647
+                      i32.lt_u
+                      i32.and
+                      if ;; label = @10
+                        block ;; label = @11
+                          i32.const 4084
+                          i32.load
+                          local.tee $2
+                          if ;; label = @12
+                            local.get $4
+                            local.get $5
+                            i32.le_u
+                            local.get $4
+                            local.get $2
+                            i32.gt_u
+                            i32.or
+                            br_if 6 (;@6;)
+                          end
+                          local.get $3
+                          call $34
+                          local.tee $2
+                          local.get $1
+                          i32.eq
+                          br_if 8 (;@3;)
+                          local.get $3
+                          local.set $1
+                          br 4 (;@7;)
+                        end
+                      end
+                    end
+                  end
+                  br 1 (;@6;)
+                end
+                i32.const 0
+                local.get $1
+                i32.sub
+                local.set $5
+                local.get $7
+                local.get $1
+                i32.gt_u
+                local.get $1
+                i32.const 2147483647
+                i32.lt_u
+                local.get $2
+                i32.const -1
+                i32.ne
+                i32.and
+                i32.and
+                if ;; label = @7
+                  local.get $13
+                  local.get $1
+                  i32.sub
+                  i32.const 4124
+                  i32.load
+                  local.tee $3
+                  i32.add
+                  i32.const 0
+                  local.get $3
+                  i32.sub
+                  i32.and
+                  local.tee $3
+                  i32.const 2147483647
+                  i32.lt_u
+                  if ;; label = @8
+                    local.get $3
+                    call $34
+                    i32.const -1
+                    i32.eq
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $5
+                        call $34
+                        drop
+                        br 4 (;@6;)
+                      end
+                    else
+                      local.get $3
+                      local.get $1
+                      i32.add
+                      local.set $3
+                    end
+                  else
+                    local.get $1
+                    local.set $3
+                  end
+                else
+                  local.get $1
+                  local.set $3
+                end
+                local.get $2
+                i32.const -1
+                i32.ne
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $2
+                    local.set $1
+                    br 5 (;@3;)
+                  end
+                end
+              end
+              i32.const 4088
+              i32.const 4088
+              i32.load
+              i32.const 4
+              i32.or
+              i32.store
+            end
+          end
+          local.get $6
+          i32.const 2147483647
+          i32.lt_u
+          if ;; label = @4
+            local.get $6
+            call $34
+            local.tee $1
+            i32.const 0
+            call $34
+            local.tee $3
+            i32.lt_u
+            local.get $1
+            i32.const -1
+            i32.ne
+            local.get $3
+            i32.const -1
+            i32.ne
+            i32.and
+            i32.and
+            if ;; label = @5
+              local.get $3
+              local.get $1
+              i32.sub
+              local.tee $3
+              local.get $0
+              i32.const 40
+              i32.add
+              i32.gt_u
+              br_if 2 (;@3;)
+            end
+          end
+          br 1 (;@2;)
+        end
+        i32.const 4076
+        i32.const 4076
+        i32.load
+        local.get $3
+        i32.add
+        local.tee $2
+        i32.store
+        local.get $2
+        i32.const 4080
+        i32.load
+        i32.gt_u
+        if ;; label = @3
+          i32.const 4080
+          local.get $2
+          i32.store
+        end
+        block $label$198 ;; label = @3
+          i32.const 3668
+          i32.load
+          local.tee $8
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 4092
+              local.set $2
+              block $label$200 ;; label = @6
+                block $label$201 ;; label = @7
+                  loop $label$202 ;; label = @8
+                    local.get $1
+                    local.get $2
+                    i32.load
+                    local.tee $4
+                    local.get $2
+                    i32.const 4
+                    i32.add
+                    local.tee $7
+                    i32.load
+                    local.tee $5
+                    i32.add
+                    i32.eq
+                    br_if 1 (;@7;)
+                    local.get $2
+                    i32.load offset=8
+                    local.tee $2
+                    br_if 0 (;@8;)
+                  end
+                  br 1 (;@6;)
+                end
+                local.get $2
+                i32.load offset=12
+                i32.const 8
+                i32.and
+                i32.eqz
+                if ;; label = @7
+                  local.get $8
+                  local.get $1
+                  i32.lt_u
+                  local.get $8
+                  local.get $4
+                  i32.ge_u
+                  i32.and
+                  if ;; label = @8
+                    block ;; label = @9
+                      local.get $7
+                      local.get $5
+                      local.get $3
+                      i32.add
+                      i32.store
+                      i32.const 3656
+                      i32.load
+                      local.set $5
+                      i32.const 0
+                      local.get $8
+                      i32.const 8
+                      i32.add
+                      local.tee $2
+                      i32.sub
+                      i32.const 7
+                      i32.and
+                      local.set $1
+                      i32.const 3668
+                      local.get $8
+                      local.get $2
+                      i32.const 7
+                      i32.and
+                      if (result i32) ;; label = @10
+                        local.get $1
+                      else
+                        i32.const 0
+                        local.tee $1
+                      end
+                      i32.add
+                      local.tee $2
+                      i32.store
+                      i32.const 3656
+                      local.get $3
+                      local.get $1
+                      i32.sub
+                      local.get $5
+                      i32.add
+                      local.tee $1
+                      i32.store
+                      local.get $2
+                      local.get $1
+                      i32.const 1
+                      i32.or
+                      i32.store offset=4
+                      local.get $2
+                      local.get $1
+                      i32.add
+                      i32.const 40
+                      i32.store offset=4
+                      i32.const 3672
+                      i32.const 4132
+                      i32.load
+                      i32.store
+                      br 6 (;@3;)
+                    end
+                  end
+                end
+              end
+              local.get $1
+              i32.const 3660
+              i32.load
+              local.tee $2
+              i32.lt_u
+              if ;; label = @6
+                block ;; label = @7
+                  i32.const 3660
+                  local.get $1
+                  i32.store
+                  local.get $1
+                  local.set $2
+                end
+              end
+              local.get $1
+              local.get $3
+              i32.add
+              local.set $10
+              i32.const 4092
+              local.set $5
+              block $label$208 ;; label = @6
+                block $label$209 ;; label = @7
+                  loop $label$210 ;; label = @8
+                    local.get $5
+                    i32.load
+                    local.get $10
+                    i32.eq
+                    br_if 1 (;@7;)
+                    local.get $5
+                    i32.load offset=8
+                    local.tee $5
+                    br_if 0 (;@8;)
+                    i32.const 4092
+                    local.set $5
+                  end
+                  br 1 (;@6;)
+                end
+                local.get $5
+                i32.load offset=12
+                i32.const 8
+                i32.and
+                if ;; label = @7
+                  i32.const 4092
+                  local.set $5
+                else
+                  block ;; label = @8
+                    local.get $5
+                    local.get $1
+                    i32.store
+                    local.get $5
+                    i32.const 4
+                    i32.add
+                    local.tee $5
+                    local.get $5
+                    i32.load
+                    local.get $3
+                    i32.add
+                    i32.store
+                    i32.const 0
+                    local.get $1
+                    i32.const 8
+                    i32.add
+                    local.tee $4
+                    i32.sub
+                    i32.const 7
+                    i32.and
+                    local.set $7
+                    i32.const 0
+                    local.get $10
+                    i32.const 8
+                    i32.add
+                    local.tee $5
+                    i32.sub
+                    i32.const 7
+                    i32.and
+                    local.set $3
+                    local.get $1
+                    local.get $4
+                    i32.const 7
+                    i32.and
+                    if (result i32) ;; label = @9
+                      local.get $7
+                    else
+                      i32.const 0
+                    end
+                    i32.add
+                    local.tee $13
+                    local.get $0
+                    i32.add
+                    local.set $6
+                    local.get $10
+                    local.get $5
+                    i32.const 7
+                    i32.and
+                    if (result i32) ;; label = @9
+                      local.get $3
+                    else
+                      i32.const 0
+                    end
+                    i32.add
+                    local.tee $4
+                    local.get $13
+                    i32.sub
+                    local.get $0
+                    i32.sub
+                    local.set $7
+                    local.get $13
+                    local.get $0
+                    i32.const 3
+                    i32.or
+                    i32.store offset=4
+                    block $label$217 ;; label = @9
+                      local.get $4
+                      local.get $8
+                      i32.eq
+                      if ;; label = @10
+                        block ;; label = @11
+                          i32.const 3656
+                          i32.const 3656
+                          i32.load
+                          local.get $7
+                          i32.add
+                          local.tee $0
+                          i32.store
+                          i32.const 3668
+                          local.get $6
+                          i32.store
+                          local.get $6
+                          local.get $0
+                          i32.const 1
+                          i32.or
+                          i32.store offset=4
+                        end
+                      else
+                        block ;; label = @11
+                          local.get $4
+                          i32.const 3664
+                          i32.load
+                          i32.eq
+                          if ;; label = @12
+                            block ;; label = @13
+                              i32.const 3652
+                              i32.const 3652
+                              i32.load
+                              local.get $7
+                              i32.add
+                              local.tee $0
+                              i32.store
+                              i32.const 3664
+                              local.get $6
+                              i32.store
+                              local.get $6
+                              local.get $0
+                              i32.const 1
+                              i32.or
+                              i32.store offset=4
+                              local.get $6
+                              local.get $0
+                              i32.add
+                              local.get $0
+                              i32.store
+                              br 4 (;@9;)
+                            end
+                          end
+                          local.get $4
+                          i32.load offset=4
+                          local.tee $0
+                          i32.const 3
+                          i32.and
+                          i32.const 1
+                          i32.eq
+                          if (result i32) ;; label = @12
+                            block (result i32) ;; label = @13
+                              local.get $0
+                              i32.const -8
+                              i32.and
+                              local.set $11
+                              local.get $0
+                              i32.const 3
+                              i32.shr_u
+                              local.set $1
+                              block $label$222 ;; label = @14
+                                local.get $0
+                                i32.const 256
+                                i32.lt_u
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $4
+                                    i32.load offset=12
+                                    local.set $5
+                                    block $label$224 ;; label = @17
+                                      local.get $4
+                                      i32.load offset=8
+                                      local.tee $3
+                                      local.get $1
+                                      i32.const 1
+                                      i32.shl
+                                      i32.const 2
+                                      i32.shl
+                                      i32.const 3684
+                                      i32.add
+                                      local.tee $0
+                                      i32.ne
+                                      if ;; label = @18
+                                        block ;; label = @19
+                                          local.get $3
+                                          local.get $2
+                                          i32.lt_u
+                                          if ;; label = @20
+                                            call $fimport$10
+                                          end
+                                          local.get $3
+                                          i32.load offset=12
+                                          local.get $4
+                                          i32.eq
+                                          br_if 2 (;@17;)
+                                          call $fimport$10
+                                        end
+                                      end
+                                    end
+                                    local.get $5
+                                    local.get $3
+                                    i32.eq
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        i32.const 3644
+                                        i32.const 3644
+                                        i32.load
+                                        i32.const 1
+                                        local.get $1
+                                        i32.shl
+                                        i32.const -1
+                                        i32.xor
+                                        i32.and
+                                        i32.store
+                                        br 4 (;@14;)
+                                      end
+                                    end
+                                    block $label$228 ;; label = @17
+                                      local.get $5
+                                      local.get $0
+                                      i32.eq
+                                      if ;; label = @18
+                                        local.get $5
+                                        i32.const 8
+                                        i32.add
+                                        local.set $20
+                                      else
+                                        block ;; label = @19
+                                          local.get $5
+                                          local.get $2
+                                          i32.lt_u
+                                          if ;; label = @20
+                                            call $fimport$10
+                                          end
+                                          local.get $5
+                                          i32.const 8
+                                          i32.add
+                                          local.tee $0
+                                          i32.load
+                                          local.get $4
+                                          i32.eq
+                                          if ;; label = @20
+                                            block ;; label = @21
+                                              local.get $0
+                                              local.set $20
+                                              br 4 (;@17;)
+                                            end
+                                          end
+                                          call $fimport$10
+                                        end
+                                      end
+                                    end
+                                    local.get $3
+                                    local.get $5
+                                    i32.store offset=12
+                                    local.get $20
+                                    local.get $3
+                                    i32.store
+                                  end
+                                else
+                                  block ;; label = @16
+                                    local.get $4
+                                    i32.load offset=24
+                                    local.set $8
+                                    block $label$234 ;; label = @17
+                                      local.get $4
+                                      i32.load offset=12
+                                      local.tee $0
+                                      local.get $4
+                                      i32.eq
+                                      if ;; label = @18
+                                        block ;; label = @19
+                                          local.get $4
+                                          i32.const 16
+                                          i32.add
+                                          local.tee $3
+                                          i32.const 4
+                                          i32.add
+                                          local.tee $1
+                                          i32.load
+                                          local.tee $0
+                                          i32.eqz
+                                          if ;; label = @20
+                                            local.get $3
+                                            i32.load
+                                            local.tee $0
+                                            if ;; label = @21
+                                              local.get $3
+                                              local.set $1
+                                            else
+                                              block ;; label = @22
+                                                i32.const 0
+                                                local.set $12
+                                                br 5 (;@17;)
+                                              end
+                                            end
+                                          end
+                                          loop $label$239 ;; label = @20
+                                            local.get $0
+                                            i32.const 20
+                                            i32.add
+                                            local.tee $5
+                                            i32.load
+                                            local.tee $3
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                local.get $3
+                                                local.set $0
+                                                local.get $5
+                                                local.set $1
+                                                br 2 (;@20;)
+                                              end
+                                            end
+                                            local.get $0
+                                            i32.const 16
+                                            i32.add
+                                            local.tee $5
+                                            i32.load
+                                            local.tee $3
+                                            if ;; label = @21
+                                              block ;; label = @22
+                                                local.get $3
+                                                local.set $0
+                                                local.get $5
+                                                local.set $1
+                                                br 2 (;@20;)
+                                              end
+                                            end
+                                          end
+                                          local.get $1
+                                          local.get $2
+                                          i32.lt_u
+                                          if ;; label = @20
+                                            call $fimport$10
+                                          else
+                                            block ;; label = @21
+                                              local.get $1
+                                              i32.const 0
+                                              i32.store
+                                              local.get $0
+                                              local.set $12
+                                            end
+                                          end
+                                        end
+                                      else
+                                        block ;; label = @19
+                                          local.get $4
+                                          i32.load offset=8
+                                          local.tee $5
+                                          local.get $2
+                                          i32.lt_u
+                                          if ;; label = @20
+                                            call $fimport$10
+                                          end
+                                          local.get $5
+                                          i32.const 12
+                                          i32.add
+                                          local.tee $3
+                                          i32.load
+                                          local.get $4
+                                          i32.ne
+                                          if ;; label = @20
+                                            call $fimport$10
+                                          end
+                                          local.get $0
+                                          i32.const 8
+                                          i32.add
+                                          local.tee $1
+                                          i32.load
+                                          local.get $4
+                                          i32.eq
+                                          if ;; label = @20
+                                            block ;; label = @21
+                                              local.get $3
+                                              local.get $0
+                                              i32.store
+                                              local.get $1
+                                              local.get $5
+                                              i32.store
+                                              local.get $0
+                                              local.set $12
+                                            end
+                                          else
+                                            call $fimport$10
+                                          end
+                                        end
+                                      end
+                                    end
+                                    local.get $8
+                                    i32.eqz
+                                    br_if 2 (;@14;)
+                                    block $label$249 ;; label = @17
+                                      local.get $4
+                                      local.get $4
+                                      i32.load offset=28
+                                      local.tee $1
+                                      i32.const 2
+                                      i32.shl
+                                      i32.const 3948
+                                      i32.add
+                                      local.tee $0
+                                      i32.load
+                                      i32.eq
+                                      if ;; label = @18
+                                        block ;; label = @19
+                                          local.get $0
+                                          local.get $12
+                                          i32.store
+                                          local.get $12
+                                          br_if 2 (;@17;)
+                                          i32.const 3648
+                                          i32.const 3648
+                                          i32.load
+                                          i32.const 1
+                                          local.get $1
+                                          i32.shl
+                                          i32.const -1
+                                          i32.xor
+                                          i32.and
+                                          i32.store
+                                          br 5 (;@14;)
+                                        end
+                                      else
+                                        block ;; label = @19
+                                          local.get $8
+                                          i32.const 3660
+                                          i32.load
+                                          i32.lt_u
+                                          if ;; label = @20
+                                            call $fimport$10
+                                          end
+                                          local.get $8
+                                          i32.const 16
+                                          i32.add
+                                          local.tee $0
+                                          i32.load
+                                          local.get $4
+                                          i32.eq
+                                          if ;; label = @20
+                                            local.get $0
+                                            local.get $12
+                                            i32.store
+                                          else
+                                            local.get $8
+                                            local.get $12
+                                            i32.store offset=20
+                                          end
+                                          local.get $12
+                                          i32.eqz
+                                          br_if 5 (;@14;)
+                                        end
+                                      end
+                                    end
+                                    local.get $12
+                                    i32.const 3660
+                                    i32.load
+                                    local.tee $1
+                                    i32.lt_u
+                                    if ;; label = @17
+                                      call $fimport$10
+                                    end
+                                    local.get $12
+                                    local.get $8
+                                    i32.store offset=24
+                                    local.get $4
+                                    i32.const 16
+                                    i32.add
+                                    local.tee $0
+                                    i32.load
+                                    local.tee $3
+                                    if ;; label = @17
+                                      local.get $3
+                                      local.get $1
+                                      i32.lt_u
+                                      if ;; label = @18
+                                        call $fimport$10
+                                      else
+                                        block ;; label = @19
+                                          local.get $12
+                                          local.get $3
+                                          i32.store offset=16
+                                          local.get $3
+                                          local.get $12
+                                          i32.store offset=24
+                                        end
+                                      end
+                                    end
+                                    local.get $0
+                                    i32.load offset=4
+                                    local.tee $0
+                                    i32.eqz
+                                    br_if 2 (;@14;)
+                                    local.get $0
+                                    i32.const 3660
+                                    i32.load
+                                    i32.lt_u
+                                    if ;; label = @17
+                                      call $fimport$10
+                                    else
+                                      block ;; label = @18
+                                        local.get $12
+                                        local.get $0
+                                        i32.store offset=20
+                                        local.get $0
+                                        local.get $12
+                                        i32.store offset=24
+                                      end
+                                    end
+                                  end
+                                end
+                              end
+                              local.get $11
+                              local.get $7
+                              i32.add
+                              local.set $7
+                              local.get $4
+                              local.get $11
+                              i32.add
+                            end
+                          else
+                            local.get $4
+                          end
+                          local.tee $0
+                          i32.const 4
+                          i32.add
+                          local.tee $0
+                          local.get $0
+                          i32.load
+                          i32.const -2
+                          i32.and
+                          i32.store
+                          local.get $6
+                          local.get $7
+                          i32.const 1
+                          i32.or
+                          i32.store offset=4
+                          local.get $6
+                          local.get $7
+                          i32.add
+                          local.get $7
+                          i32.store
+                          local.get $7
+                          i32.const 3
+                          i32.shr_u
+                          local.set $0
+                          local.get $7
+                          i32.const 256
+                          i32.lt_u
+                          if ;; label = @12
+                            block ;; label = @13
+                              local.get $0
+                              i32.const 1
+                              i32.shl
+                              i32.const 2
+                              i32.shl
+                              i32.const 3684
+                              i32.add
+                              local.set $3
+                              block $label$263 ;; label = @14
+                                i32.const 3644
+                                i32.load
+                                local.tee $1
+                                i32.const 1
+                                local.get $0
+                                i32.shl
+                                local.tee $0
+                                i32.and
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $3
+                                    i32.const 8
+                                    i32.add
+                                    local.tee $1
+                                    i32.load
+                                    local.tee $0
+                                    i32.const 3660
+                                    i32.load
+                                    i32.ge_u
+                                    if ;; label = @17
+                                      block ;; label = @18
+                                        local.get $1
+                                        local.set $21
+                                        local.get $0
+                                        local.set $9
+                                        br 4 (;@14;)
+                                      end
+                                    end
+                                    call $fimport$10
+                                  end
+                                else
+                                  block ;; label = @16
+                                    i32.const 3644
+                                    local.get $1
+                                    local.get $0
+                                    i32.or
+                                    i32.store
+                                    local.get $3
+                                    i32.const 8
+                                    i32.add
+                                    local.set $21
+                                    local.get $3
+                                    local.set $9
+                                  end
+                                end
+                              end
+                              local.get $21
+                              local.get $6
+                              i32.store
+                              local.get $9
+                              local.get $6
+                              i32.store offset=12
+                              local.get $6
+                              local.get $9
+                              i32.store offset=8
+                              local.get $6
+                              local.get $3
+                              i32.store offset=12
+                              br 4 (;@9;)
+                            end
+                          end
+                          block $label$267 (result i32) ;; label = @12
+                            local.get $7
+                            i32.const 8
+                            i32.shr_u
+                            local.tee $0
+                            if (result i32) ;; label = @13
+                              block (result i32) ;; label = @14
+                                i32.const 31
+                                local.get $7
+                                i32.const 16777215
+                                i32.gt_u
+                                br_if 2 (;@12;)
+                                drop
+                                local.get $7
+                                i32.const 14
+                                local.get $0
+                                local.get $0
+                                i32.const 1048320
+                                i32.add
+                                i32.const 16
+                                i32.shr_u
+                                i32.const 8
+                                i32.and
+                                local.tee $3
+                                i32.shl
+                                local.tee $1
+                                i32.const 520192
+                                i32.add
+                                i32.const 16
+                                i32.shr_u
+                                i32.const 4
+                                i32.and
+                                local.tee $0
+                                local.get $3
+                                i32.or
+                                local.get $1
+                                local.get $0
+                                i32.shl
+                                local.tee $1
+                                i32.const 245760
+                                i32.add
+                                i32.const 16
+                                i32.shr_u
+                                i32.const 2
+                                i32.and
+                                local.tee $0
+                                i32.or
+                                i32.sub
+                                local.get $1
+                                local.get $0
+                                i32.shl
+                                i32.const 15
+                                i32.shr_u
+                                i32.add
+                                local.tee $0
+                                i32.const 7
+                                i32.add
+                                i32.shr_u
+                                i32.const 1
+                                i32.and
+                                local.get $0
+                                i32.const 1
+                                i32.shl
+                                i32.or
+                              end
+                            else
+                              i32.const 0
+                            end
+                          end
+                          local.tee $2
+                          i32.const 2
+                          i32.shl
+                          i32.const 3948
+                          i32.add
+                          local.set $3
+                          local.get $6
+                          local.get $2
+                          i32.store offset=28
+                          local.get $6
+                          i32.const 16
+                          i32.add
+                          local.tee $0
+                          i32.const 0
+                          i32.store offset=4
+                          local.get $0
+                          i32.const 0
+                          i32.store
+                          i32.const 3648
+                          i32.load
+                          local.tee $1
+                          i32.const 1
+                          local.get $2
+                          i32.shl
+                          local.tee $0
+                          i32.and
+                          i32.eqz
+                          if ;; label = @12
+                            block ;; label = @13
+                              i32.const 3648
+                              local.get $1
+                              local.get $0
+                              i32.or
+                              i32.store
+                              local.get $3
+                              local.get $6
+                              i32.store
+                              local.get $6
+                              local.get $3
+                              i32.store offset=24
+                              local.get $6
+                              local.get $6
+                              i32.store offset=12
+                              local.get $6
+                              local.get $6
+                              i32.store offset=8
+                              br 4 (;@9;)
+                            end
+                          end
+                          local.get $3
+                          i32.load
+                          local.set $0
+                          i32.const 25
+                          local.get $2
+                          i32.const 1
+                          i32.shr_u
+                          i32.sub
+                          local.set $1
+                          local.get $7
+                          local.get $2
+                          i32.const 31
+                          i32.eq
+                          if (result i32) ;; label = @12
+                            i32.const 0
+                          else
+                            local.get $1
+                          end
+                          i32.shl
+                          local.set $2
+                          block $label$273 ;; label = @12
+                            block $label$274 ;; label = @13
+                              block $label$275 ;; label = @14
+                                loop $label$276 ;; label = @15
+                                  local.get $0
+                                  i32.load offset=4
+                                  i32.const -8
+                                  i32.and
+                                  local.get $7
+                                  i32.eq
+                                  br_if 2 (;@13;)
+                                  local.get $2
+                                  i32.const 1
+                                  i32.shl
+                                  local.set $3
+                                  local.get $0
+                                  i32.const 16
+                                  i32.add
+                                  local.get $2
+                                  i32.const 31
+                                  i32.shr_u
+                                  i32.const 2
+                                  i32.shl
+                                  i32.add
+                                  local.tee $2
+                                  i32.load
+                                  local.tee $1
+                                  i32.eqz
+                                  br_if 1 (;@14;)
+                                  local.get $3
+                                  local.set $2
+                                  local.get $1
+                                  local.set $0
+                                  br 0 (;@15;)
+                                end
+                              end
+                              local.get $2
+                              i32.const 3660
+                              i32.load
+                              i32.lt_u
+                              if ;; label = @14
+                                call $fimport$10
+                              else
+                                block ;; label = @15
+                                  local.get $2
+                                  local.get $6
+                                  i32.store
+                                  local.get $6
+                                  local.get $0
+                                  i32.store offset=24
+                                  local.get $6
+                                  local.get $6
+                                  i32.store offset=12
+                                  local.get $6
+                                  local.get $6
+                                  i32.store offset=8
+                                  br 6 (;@9;)
+                                end
+                              end
+                              br 1 (;@12;)
+                            end
+                            local.get $0
+                            i32.const 8
+                            i32.add
+                            local.tee $3
+                            i32.load
+                            local.tee $2
+                            i32.const 3660
+                            i32.load
+                            local.tee $1
+                            i32.ge_u
+                            local.get $0
+                            local.get $1
+                            i32.ge_u
+                            i32.and
+                            if ;; label = @13
+                              block ;; label = @14
+                                local.get $2
+                                local.get $6
+                                i32.store offset=12
+                                local.get $3
+                                local.get $6
+                                i32.store
+                                local.get $6
+                                local.get $2
+                                i32.store offset=8
+                                local.get $6
+                                local.get $0
+                                i32.store offset=12
+                                local.get $6
+                                i32.const 0
+                                i32.store offset=24
+                              end
+                            else
+                              call $fimport$10
+                            end
+                          end
+                        end
+                      end
+                    end
+                    local.get $14
+                    global.set $global$1
+                    local.get $13
+                    i32.const 8
+                    i32.add
+                    return
+                  end
+                end
+              end
+              loop $label$281 ;; label = @6
+                block $label$282 ;; label = @7
+                  local.get $5
+                  i32.load
+                  local.tee $2
+                  local.get $8
+                  i32.le_u
+                  if ;; label = @8
+                    local.get $2
+                    local.get $5
+                    i32.load offset=4
+                    i32.add
+                    local.tee $13
+                    local.get $8
+                    i32.gt_u
+                    br_if 1 (;@7;)
+                  end
+                  local.get $5
+                  i32.load offset=8
+                  local.set $5
+                  br 1 (;@6;)
+                end
+              end
+              i32.const 0
+              local.get $13
+              i32.const -47
+              i32.add
+              local.tee $7
+              i32.const 8
+              i32.add
+              local.tee $5
+              i32.sub
+              i32.const 7
+              i32.and
+              local.set $2
+              local.get $7
+              local.get $5
+              i32.const 7
+              i32.and
+              if (result i32) ;; label = @6
+                local.get $2
+              else
+                i32.const 0
+              end
+              i32.add
+              local.tee $2
+              local.get $8
+              i32.const 16
+              i32.add
+              local.tee $12
+              i32.lt_u
+              if (result i32) ;; label = @6
+                local.get $8
+              else
+                local.get $2
+              end
+              local.tee $7
+              i32.const 8
+              i32.add
+              local.set $10
+              local.get $7
+              i32.const 24
+              i32.add
+              local.set $5
+              local.get $3
+              i32.const -40
+              i32.add
+              local.set $9
+              i32.const 0
+              local.get $1
+              i32.const 8
+              i32.add
+              local.tee $4
+              i32.sub
+              i32.const 7
+              i32.and
+              local.set $2
+              i32.const 3668
+              local.get $1
+              local.get $4
+              i32.const 7
+              i32.and
+              if (result i32) ;; label = @6
+                local.get $2
+              else
+                i32.const 0
+                local.tee $2
+              end
+              i32.add
+              local.tee $4
+              i32.store
+              i32.const 3656
+              local.get $9
+              local.get $2
+              i32.sub
+              local.tee $2
+              i32.store
+              local.get $4
+              local.get $2
+              i32.const 1
+              i32.or
+              i32.store offset=4
+              local.get $4
+              local.get $2
+              i32.add
+              i32.const 40
+              i32.store offset=4
+              i32.const 3672
+              i32.const 4132
+              i32.load
+              i32.store
+              local.get $7
+              i32.const 4
+              i32.add
+              local.tee $2
+              i32.const 27
+              i32.store
+              local.get $10
+              i32.const 4092
+              i64.load align=4
+              i64.store align=4
+              local.get $10
+              i32.const 4100
+              i64.load align=4
+              i64.store offset=8 align=4
+              i32.const 4092
+              local.get $1
+              i32.store
+              i32.const 4096
+              local.get $3
+              i32.store
+              i32.const 4104
+              i32.const 0
+              i32.store
+              i32.const 4100
+              local.get $10
+              i32.store
+              local.get $5
+              local.set $1
+              loop $label$290 ;; label = @6
+                local.get $1
+                i32.const 4
+                i32.add
+                local.tee $1
+                i32.const 7
+                i32.store
+                local.get $1
+                i32.const 4
+                i32.add
+                local.get $13
+                i32.lt_u
+                br_if 0 (;@6;)
+              end
+              local.get $7
+              local.get $8
+              i32.ne
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $2
+                  local.get $2
+                  i32.load
+                  i32.const -2
+                  i32.and
+                  i32.store
+                  local.get $8
+                  local.get $7
+                  local.get $8
+                  i32.sub
+                  local.tee $4
+                  i32.const 1
+                  i32.or
+                  i32.store offset=4
+                  local.get $7
+                  local.get $4
+                  i32.store
+                  local.get $4
+                  i32.const 3
+                  i32.shr_u
+                  local.set $1
+                  local.get $4
+                  i32.const 256
+                  i32.lt_u
+                  if ;; label = @8
+                    block ;; label = @9
+                      local.get $1
+                      i32.const 1
+                      i32.shl
+                      i32.const 2
+                      i32.shl
+                      i32.const 3684
+                      i32.add
+                      local.set $2
+                      i32.const 3644
+                      i32.load
+                      local.tee $3
+                      i32.const 1
+                      local.get $1
+                      i32.shl
+                      local.tee $1
+                      i32.and
+                      if ;; label = @10
+                        local.get $2
+                        i32.const 8
+                        i32.add
+                        local.tee $3
+                        i32.load
+                        local.tee $1
+                        i32.const 3660
+                        i32.load
+                        i32.lt_u
+                        if ;; label = @11
+                          call $fimport$10
+                        else
+                          block ;; label = @12
+                            local.get $3
+                            local.set $15
+                            local.get $1
+                            local.set $11
+                          end
+                        end
+                      else
+                        block ;; label = @11
+                          i32.const 3644
+                          local.get $3
+                          local.get $1
+                          i32.or
+                          i32.store
+                          local.get $2
+                          i32.const 8
+                          i32.add
+                          local.set $15
+                          local.get $2
+                          local.set $11
+                        end
+                      end
+                      local.get $15
+                      local.get $8
+                      i32.store
+                      local.get $11
+                      local.get $8
+                      i32.store offset=12
+                      local.get $8
+                      local.get $11
+                      i32.store offset=8
+                      local.get $8
+                      local.get $2
+                      i32.store offset=12
+                      br 6 (;@3;)
+                    end
+                  end
+                  local.get $4
+                  i32.const 8
+                  i32.shr_u
+                  local.tee $1
+                  if (result i32) ;; label = @8
+                    local.get $4
+                    i32.const 16777215
+                    i32.gt_u
+                    if (result i32) ;; label = @9
+                      i32.const 31
+                    else
+                      local.get $4
+                      i32.const 14
+                      local.get $1
+                      local.get $1
+                      i32.const 1048320
+                      i32.add
+                      i32.const 16
+                      i32.shr_u
+                      i32.const 8
+                      i32.and
+                      local.tee $2
+                      i32.shl
+                      local.tee $3
+                      i32.const 520192
+                      i32.add
+                      i32.const 16
+                      i32.shr_u
+                      i32.const 4
+                      i32.and
+                      local.tee $1
+                      local.get $2
+                      i32.or
+                      local.get $3
+                      local.get $1
+                      i32.shl
+                      local.tee $3
+                      i32.const 245760
+                      i32.add
+                      i32.const 16
+                      i32.shr_u
+                      i32.const 2
+                      i32.and
+                      local.tee $1
+                      i32.or
+                      i32.sub
+                      local.get $3
+                      local.get $1
+                      i32.shl
+                      i32.const 15
+                      i32.shr_u
+                      i32.add
+                      local.tee $1
+                      i32.const 7
+                      i32.add
+                      i32.shr_u
+                      i32.const 1
+                      i32.and
+                      local.get $1
+                      i32.const 1
+                      i32.shl
+                      i32.or
+                    end
+                  else
+                    i32.const 0
+                  end
+                  local.tee $5
+                  i32.const 2
+                  i32.shl
+                  i32.const 3948
+                  i32.add
+                  local.set $2
+                  local.get $8
+                  local.get $5
+                  i32.store offset=28
+                  local.get $8
+                  i32.const 0
+                  i32.store offset=20
+                  local.get $12
+                  i32.const 0
+                  i32.store
+                  i32.const 3648
+                  i32.load
+                  local.tee $3
+                  i32.const 1
+                  local.get $5
+                  i32.shl
+                  local.tee $1
+                  i32.and
+                  i32.eqz
+                  if ;; label = @8
+                    block ;; label = @9
+                      i32.const 3648
+                      local.get $3
+                      local.get $1
+                      i32.or
+                      i32.store
+                      local.get $2
+                      local.get $8
+                      i32.store
+                      local.get $8
+                      local.get $2
+                      i32.store offset=24
+                      local.get $8
+                      local.get $8
+                      i32.store offset=12
+                      local.get $8
+                      local.get $8
+                      i32.store offset=8
+                      br 6 (;@3;)
+                    end
+                  end
+                  local.get $2
+                  i32.load
+                  local.set $1
+                  i32.const 25
+                  local.get $5
+                  i32.const 1
+                  i32.shr_u
+                  i32.sub
+                  local.set $3
+                  local.get $4
+                  local.get $5
+                  i32.const 31
+                  i32.eq
+                  if (result i32) ;; label = @8
+                    i32.const 0
+                  else
+                    local.get $3
+                  end
+                  i32.shl
+                  local.set $5
+                  block $label$304 ;; label = @8
+                    block $label$305 ;; label = @9
+                      block $label$306 ;; label = @10
+                        loop $label$307 ;; label = @11
+                          local.get $1
+                          i32.load offset=4
+                          i32.const -8
+                          i32.and
+                          local.get $4
+                          i32.eq
+                          br_if 2 (;@9;)
+                          local.get $5
+                          i32.const 1
+                          i32.shl
+                          local.set $2
+                          local.get $1
+                          i32.const 16
+                          i32.add
+                          local.get $5
+                          i32.const 31
+                          i32.shr_u
+                          i32.const 2
+                          i32.shl
+                          i32.add
+                          local.tee $5
+                          i32.load
+                          local.tee $3
+                          i32.eqz
+                          br_if 1 (;@10;)
+                          local.get $2
+                          local.set $5
+                          local.get $3
+                          local.set $1
+                          br 0 (;@11;)
+                        end
+                      end
+                      local.get $5
+                      i32.const 3660
+                      i32.load
+                      i32.lt_u
+                      if ;; label = @10
+                        call $fimport$10
+                      else
+                        block ;; label = @11
+                          local.get $5
+                          local.get $8
+                          i32.store
+                          local.get $8
+                          local.get $1
+                          i32.store offset=24
+                          local.get $8
+                          local.get $8
+                          i32.store offset=12
+                          local.get $8
+                          local.get $8
+                          i32.store offset=8
+                          br 8 (;@3;)
+                        end
+                      end
+                      br 1 (;@8;)
+                    end
+                    local.get $1
+                    i32.const 8
+                    i32.add
+                    local.tee $2
+                    i32.load
+                    local.tee $5
+                    i32.const 3660
+                    i32.load
+                    local.tee $3
+                    i32.ge_u
+                    local.get $1
+                    local.get $3
+                    i32.ge_u
+                    i32.and
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $5
+                        local.get $8
+                        i32.store offset=12
+                        local.get $2
+                        local.get $8
+                        i32.store
+                        local.get $8
+                        local.get $5
+                        i32.store offset=8
+                        local.get $8
+                        local.get $1
+                        i32.store offset=12
+                        local.get $8
+                        i32.const 0
+                        i32.store offset=24
+                      end
+                    else
+                      call $fimport$10
+                    end
+                  end
+                end
+              end
+            end
+          else
+            block ;; label = @5
+              i32.const 3660
+              i32.load
+              local.tee $2
+              i32.eqz
+              local.get $1
+              local.get $2
+              i32.lt_u
+              i32.or
+              if ;; label = @6
+                i32.const 3660
+                local.get $1
+                i32.store
+              end
+              i32.const 4092
+              local.get $1
+              i32.store
+              i32.const 4096
+              local.get $3
+              i32.store
+              i32.const 4104
+              i32.const 0
+              i32.store
+              i32.const 3680
+              i32.const 4116
+              i32.load
+              i32.store
+              i32.const 3676
+              i32.const -1
+              i32.store
+              i32.const 0
+              local.set $2
+              loop $label$314 ;; label = @6
+                local.get $2
+                i32.const 1
+                i32.shl
+                i32.const 2
+                i32.shl
+                i32.const 3684
+                i32.add
+                local.tee $5
+                local.get $5
+                i32.store offset=12
+                local.get $5
+                local.get $5
+                i32.store offset=8
+                local.get $2
+                i32.const 1
+                i32.add
+                local.tee $2
+                i32.const 32
+                i32.ne
+                br_if 0 (;@6;)
+              end
+              local.get $3
+              i32.const -40
+              i32.add
+              local.set $5
+              i32.const 0
+              local.get $1
+              i32.const 8
+              i32.add
+              local.tee $2
+              i32.sub
+              i32.const 7
+              i32.and
+              local.set $3
+              i32.const 3668
+              local.get $1
+              local.get $2
+              i32.const 7
+              i32.and
+              if (result i32) ;; label = @6
+                local.get $3
+              else
+                i32.const 0
+              end
+              local.tee $1
+              i32.add
+              local.tee $3
+              i32.store
+              i32.const 3656
+              local.get $5
+              local.get $1
+              i32.sub
+              local.tee $1
+              i32.store
+              local.get $3
+              local.get $1
+              i32.const 1
+              i32.or
+              i32.store offset=4
+              local.get $3
+              local.get $1
+              i32.add
+              i32.const 40
+              i32.store offset=4
+              i32.const 3672
+              i32.const 4132
+              i32.load
+              i32.store
+            end
+          end
+        end
+        i32.const 3656
+        i32.load
+        local.tee $1
+        local.get $0
+        i32.gt_u
+        if ;; label = @3
+          block ;; label = @4
+            i32.const 3656
+            local.get $1
+            local.get $0
+            i32.sub
+            local.tee $3
+            i32.store
+            i32.const 3668
+            i32.const 3668
+            i32.load
+            local.tee $2
+            local.get $0
+            i32.add
+            local.tee $1
+            i32.store
+            local.get $1
+            local.get $3
+            i32.const 1
+            i32.or
+            i32.store offset=4
+            local.get $2
+            local.get $0
+            i32.const 3
+            i32.or
+            i32.store offset=4
+            local.get $14
+            global.set $global$1
+            local.get $2
+            i32.const 8
+            i32.add
+            return
+          end
+        end
+      end
+      call $11
+      i32.const 12
+      i32.store
+      local.get $14
+      global.set $global$1
+      i32.const 0
+    end
+  )
+  (func $32 (;45;) (type $2) (param $0 i32)
+    (local $1 i32) (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32) (local $15 i32)
+    block $label$1 ;; label = @1
+      local.get $0
+      i32.eqz
+      if ;; label = @2
+        return
+      end
+      local.get $0
+      i32.const -8
+      i32.add
+      local.tee $1
+      i32.const 3660
+      i32.load
+      local.tee $11
+      i32.lt_u
+      if ;; label = @2
+        call $fimport$10
+      end
+      local.get $0
+      i32.const -4
+      i32.add
+      i32.load
+      local.tee $0
+      i32.const 3
+      i32.and
+      local.tee $8
+      i32.const 1
+      i32.eq
+      if ;; label = @2
+        call $fimport$10
+      end
+      local.get $1
+      local.get $0
+      i32.const -8
+      i32.and
+      local.tee $4
+      i32.add
+      local.set $6
+      block $label$5 ;; label = @2
+        local.get $0
+        i32.const 1
+        i32.and
+        if ;; label = @3
+          block ;; label = @4
+            local.get $1
+            local.set $3
+            local.get $4
+            local.set $2
+          end
+        else
+          block ;; label = @4
+            local.get $8
+            i32.eqz
+            if ;; label = @5
+              return
+            end
+            local.get $1
+            i32.const 0
+            local.get $1
+            i32.load
+            local.tee $8
+            i32.sub
+            i32.add
+            local.tee $0
+            local.get $11
+            i32.lt_u
+            if ;; label = @5
+              call $fimport$10
+            end
+            local.get $8
+            local.get $4
+            i32.add
+            local.set $1
+            local.get $0
+            i32.const 3664
+            i32.load
+            i32.eq
+            if ;; label = @5
+              block ;; label = @6
+                local.get $6
+                i32.const 4
+                i32.add
+                local.tee $2
+                i32.load
+                local.tee $3
+                i32.const 3
+                i32.and
+                i32.const 3
+                i32.ne
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $0
+                    local.set $3
+                    local.get $1
+                    local.set $2
+                    br 6 (;@2;)
+                  end
+                end
+                i32.const 3652
+                local.get $1
+                i32.store
+                local.get $2
+                local.get $3
+                i32.const -2
+                i32.and
+                i32.store
+                local.get $0
+                local.get $1
+                i32.const 1
+                i32.or
+                i32.store offset=4
+                local.get $0
+                local.get $1
+                i32.add
+                local.get $1
+                i32.store
+                return
+              end
+            end
+            local.get $8
+            i32.const 3
+            i32.shr_u
+            local.set $10
+            local.get $8
+            i32.const 256
+            i32.lt_u
+            if ;; label = @5
+              block ;; label = @6
+                local.get $0
+                i32.load offset=12
+                local.set $3
+                local.get $0
+                i32.load offset=8
+                local.tee $4
+                local.get $10
+                i32.const 1
+                i32.shl
+                i32.const 2
+                i32.shl
+                i32.const 3684
+                i32.add
+                local.tee $2
+                i32.ne
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $4
+                    local.get $11
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                    local.get $4
+                    i32.load offset=12
+                    local.get $0
+                    i32.ne
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                  end
+                end
+                local.get $3
+                local.get $4
+                i32.eq
+                if ;; label = @7
+                  block ;; label = @8
+                    i32.const 3644
+                    i32.const 3644
+                    i32.load
+                    i32.const 1
+                    local.get $10
+                    i32.shl
+                    i32.const -1
+                    i32.xor
+                    i32.and
+                    i32.store
+                    local.get $0
+                    local.set $3
+                    local.get $1
+                    local.set $2
+                    br 6 (;@2;)
+                  end
+                end
+                local.get $3
+                local.get $2
+                i32.eq
+                if ;; label = @7
+                  local.get $3
+                  i32.const 8
+                  i32.add
+                  local.set $5
+                else
+                  block ;; label = @8
+                    local.get $3
+                    local.get $11
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                    local.get $3
+                    i32.const 8
+                    i32.add
+                    local.tee $2
+                    i32.load
+                    local.get $0
+                    i32.eq
+                    if ;; label = @9
+                      local.get $2
+                      local.set $5
+                    else
+                      call $fimport$10
+                    end
+                  end
+                end
+                local.get $4
+                local.get $3
+                i32.store offset=12
+                local.get $5
+                local.get $4
+                i32.store
+                local.get $0
+                local.set $3
+                local.get $1
+                local.set $2
+                br 4 (;@2;)
+              end
+            end
+            local.get $0
+            i32.load offset=24
+            local.set $12
+            block $label$22 ;; label = @5
+              local.get $0
+              i32.load offset=12
+              local.tee $4
+              local.get $0
+              i32.eq
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $0
+                  i32.const 16
+                  i32.add
+                  local.tee $5
+                  i32.const 4
+                  i32.add
+                  local.tee $8
+                  i32.load
+                  local.tee $4
+                  if ;; label = @8
+                    local.get $8
+                    local.set $5
+                  else
+                    local.get $5
+                    i32.load
+                    local.tee $4
+                    i32.eqz
+                    if ;; label = @9
+                      block ;; label = @10
+                        i32.const 0
+                        local.set $7
+                        br 5 (;@5;)
+                      end
+                    end
+                  end
+                  loop $label$27 ;; label = @8
+                    local.get $4
+                    i32.const 20
+                    i32.add
+                    local.tee $8
+                    i32.load
+                    local.tee $10
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $10
+                        local.set $4
+                        local.get $8
+                        local.set $5
+                        br 2 (;@8;)
+                      end
+                    end
+                    local.get $4
+                    i32.const 16
+                    i32.add
+                    local.tee $8
+                    i32.load
+                    local.tee $10
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $10
+                        local.set $4
+                        local.get $8
+                        local.set $5
+                        br 2 (;@8;)
+                      end
+                    end
+                  end
+                  local.get $5
+                  local.get $11
+                  i32.lt_u
+                  if ;; label = @8
+                    call $fimport$10
+                  else
+                    block ;; label = @9
+                      local.get $5
+                      i32.const 0
+                      i32.store
+                      local.get $4
+                      local.set $7
+                    end
+                  end
+                end
+              else
+                block ;; label = @7
+                  local.get $0
+                  i32.load offset=8
+                  local.tee $5
+                  local.get $11
+                  i32.lt_u
+                  if ;; label = @8
+                    call $fimport$10
+                  end
+                  local.get $5
+                  i32.const 12
+                  i32.add
+                  local.tee $8
+                  i32.load
+                  local.get $0
+                  i32.ne
+                  if ;; label = @8
+                    call $fimport$10
+                  end
+                  local.get $4
+                  i32.const 8
+                  i32.add
+                  local.tee $10
+                  i32.load
+                  local.get $0
+                  i32.eq
+                  if ;; label = @8
+                    block ;; label = @9
+                      local.get $8
+                      local.get $4
+                      i32.store
+                      local.get $10
+                      local.get $5
+                      i32.store
+                      local.get $4
+                      local.set $7
+                    end
+                  else
+                    call $fimport$10
+                  end
+                end
+              end
+            end
+            local.get $12
+            if ;; label = @5
+              block ;; label = @6
+                local.get $0
+                local.get $0
+                i32.load offset=28
+                local.tee $4
+                i32.const 2
+                i32.shl
+                i32.const 3948
+                i32.add
+                local.tee $5
+                i32.load
+                i32.eq
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $5
+                    local.get $7
+                    i32.store
+                    local.get $7
+                    i32.eqz
+                    if ;; label = @9
+                      block ;; label = @10
+                        i32.const 3648
+                        i32.const 3648
+                        i32.load
+                        i32.const 1
+                        local.get $4
+                        i32.shl
+                        i32.const -1
+                        i32.xor
+                        i32.and
+                        i32.store
+                        local.get $0
+                        local.set $3
+                        local.get $1
+                        local.set $2
+                        br 8 (;@2;)
+                      end
+                    end
+                  end
+                else
+                  block ;; label = @8
+                    local.get $12
+                    i32.const 3660
+                    i32.load
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                    local.get $12
+                    i32.const 16
+                    i32.add
+                    local.tee $4
+                    i32.load
+                    local.get $0
+                    i32.eq
+                    if ;; label = @9
+                      local.get $4
+                      local.get $7
+                      i32.store
+                    else
+                      local.get $12
+                      local.get $7
+                      i32.store offset=20
+                    end
+                    local.get $7
+                    i32.eqz
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $0
+                        local.set $3
+                        local.get $1
+                        local.set $2
+                        br 8 (;@2;)
+                      end
+                    end
+                  end
+                end
+                local.get $7
+                i32.const 3660
+                i32.load
+                local.tee $5
+                i32.lt_u
+                if ;; label = @7
+                  call $fimport$10
+                end
+                local.get $7
+                local.get $12
+                i32.store offset=24
+                local.get $0
+                i32.const 16
+                i32.add
+                local.tee $8
+                i32.load
+                local.tee $4
+                if ;; label = @7
+                  local.get $4
+                  local.get $5
+                  i32.lt_u
+                  if ;; label = @8
+                    call $fimport$10
+                  else
+                    block ;; label = @9
+                      local.get $7
+                      local.get $4
+                      i32.store offset=16
+                      local.get $4
+                      local.get $7
+                      i32.store offset=24
+                    end
+                  end
+                end
+                local.get $8
+                i32.load offset=4
+                local.tee $4
+                if ;; label = @7
+                  local.get $4
+                  i32.const 3660
+                  i32.load
+                  i32.lt_u
+                  if ;; label = @8
+                    call $fimport$10
+                  else
+                    block ;; label = @9
+                      local.get $7
+                      local.get $4
+                      i32.store offset=20
+                      local.get $4
+                      local.get $7
+                      i32.store offset=24
+                      local.get $0
+                      local.set $3
+                      local.get $1
+                      local.set $2
+                    end
+                  end
+                else
+                  block ;; label = @8
+                    local.get $0
+                    local.set $3
+                    local.get $1
+                    local.set $2
+                  end
+                end
+              end
+            else
+              block ;; label = @6
+                local.get $0
+                local.set $3
+                local.get $1
+                local.set $2
+              end
+            end
+          end
+        end
+      end
+      local.get $3
+      local.get $6
+      i32.ge_u
+      if ;; label = @2
+        call $fimport$10
+      end
+      local.get $6
+      i32.const 4
+      i32.add
+      local.tee $1
+      i32.load
+      local.tee $0
+      i32.const 1
+      i32.and
+      i32.eqz
+      if ;; label = @2
+        call $fimport$10
+      end
+      local.get $0
+      i32.const 2
+      i32.and
+      if ;; label = @2
+        block ;; label = @3
+          local.get $1
+          local.get $0
+          i32.const -2
+          i32.and
+          i32.store
+          local.get $3
+          local.get $2
+          i32.const 1
+          i32.or
+          i32.store offset=4
+          local.get $3
+          local.get $2
+          i32.add
+          local.get $2
+          i32.store
+        end
+      else
+        block ;; label = @3
+          local.get $6
+          i32.const 3668
+          i32.load
+          i32.eq
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 3656
+              i32.const 3656
+              i32.load
+              local.get $2
+              i32.add
+              local.tee $0
+              i32.store
+              i32.const 3668
+              local.get $3
+              i32.store
+              local.get $3
+              local.get $0
+              i32.const 1
+              i32.or
+              i32.store offset=4
+              local.get $3
+              i32.const 3664
+              i32.load
+              i32.ne
+              if ;; label = @6
+                return
+              end
+              i32.const 3664
+              i32.const 0
+              i32.store
+              i32.const 3652
+              i32.const 0
+              i32.store
+              return
+            end
+          end
+          local.get $6
+          i32.const 3664
+          i32.load
+          i32.eq
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 3652
+              i32.const 3652
+              i32.load
+              local.get $2
+              i32.add
+              local.tee $0
+              i32.store
+              i32.const 3664
+              local.get $3
+              i32.store
+              local.get $3
+              local.get $0
+              i32.const 1
+              i32.or
+              i32.store offset=4
+              local.get $3
+              local.get $0
+              i32.add
+              local.get $0
+              i32.store
+              return
+            end
+          end
+          local.get $0
+          i32.const -8
+          i32.and
+          local.get $2
+          i32.add
+          local.set $5
+          local.get $0
+          i32.const 3
+          i32.shr_u
+          local.set $4
+          block $label$61 ;; label = @4
+            local.get $0
+            i32.const 256
+            i32.lt_u
+            if ;; label = @5
+              block ;; label = @6
+                local.get $6
+                i32.load offset=12
+                local.set $2
+                local.get $6
+                i32.load offset=8
+                local.tee $1
+                local.get $4
+                i32.const 1
+                i32.shl
+                i32.const 2
+                i32.shl
+                i32.const 3684
+                i32.add
+                local.tee $0
+                i32.ne
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $1
+                    i32.const 3660
+                    i32.load
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                    local.get $1
+                    i32.load offset=12
+                    local.get $6
+                    i32.ne
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                  end
+                end
+                local.get $2
+                local.get $1
+                i32.eq
+                if ;; label = @7
+                  block ;; label = @8
+                    i32.const 3644
+                    i32.const 3644
+                    i32.load
+                    i32.const 1
+                    local.get $4
+                    i32.shl
+                    i32.const -1
+                    i32.xor
+                    i32.and
+                    i32.store
+                    br 4 (;@4;)
+                  end
+                end
+                local.get $2
+                local.get $0
+                i32.eq
+                if ;; label = @7
+                  local.get $2
+                  i32.const 8
+                  i32.add
+                  local.set $14
+                else
+                  block ;; label = @8
+                    local.get $2
+                    i32.const 3660
+                    i32.load
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                    local.get $2
+                    i32.const 8
+                    i32.add
+                    local.tee $0
+                    i32.load
+                    local.get $6
+                    i32.eq
+                    if ;; label = @9
+                      local.get $0
+                      local.set $14
+                    else
+                      call $fimport$10
+                    end
+                  end
+                end
+                local.get $1
+                local.get $2
+                i32.store offset=12
+                local.get $14
+                local.get $1
+                i32.store
+              end
+            else
+              block ;; label = @6
+                local.get $6
+                i32.load offset=24
+                local.set $7
+                block $label$73 ;; label = @7
+                  local.get $6
+                  i32.load offset=12
+                  local.tee $0
+                  local.get $6
+                  i32.eq
+                  if ;; label = @8
+                    block ;; label = @9
+                      local.get $6
+                      i32.const 16
+                      i32.add
+                      local.tee $2
+                      i32.const 4
+                      i32.add
+                      local.tee $1
+                      i32.load
+                      local.tee $0
+                      if ;; label = @10
+                        local.get $1
+                        local.set $2
+                      else
+                        local.get $2
+                        i32.load
+                        local.tee $0
+                        i32.eqz
+                        if ;; label = @11
+                          block ;; label = @12
+                            i32.const 0
+                            local.set $9
+                            br 5 (;@7;)
+                          end
+                        end
+                      end
+                      loop $label$78 ;; label = @10
+                        local.get $0
+                        i32.const 20
+                        i32.add
+                        local.tee $1
+                        i32.load
+                        local.tee $4
+                        if ;; label = @11
+                          block ;; label = @12
+                            local.get $4
+                            local.set $0
+                            local.get $1
+                            local.set $2
+                            br 2 (;@10;)
+                          end
+                        end
+                        local.get $0
+                        i32.const 16
+                        i32.add
+                        local.tee $1
+                        i32.load
+                        local.tee $4
+                        if ;; label = @11
+                          block ;; label = @12
+                            local.get $4
+                            local.set $0
+                            local.get $1
+                            local.set $2
+                            br 2 (;@10;)
+                          end
+                        end
+                      end
+                      local.get $2
+                      i32.const 3660
+                      i32.load
+                      i32.lt_u
+                      if ;; label = @10
+                        call $fimport$10
+                      else
+                        block ;; label = @11
+                          local.get $2
+                          i32.const 0
+                          i32.store
+                          local.get $0
+                          local.set $9
+                        end
+                      end
+                    end
+                  else
+                    block ;; label = @9
+                      local.get $6
+                      i32.load offset=8
+                      local.tee $2
+                      i32.const 3660
+                      i32.load
+                      i32.lt_u
+                      if ;; label = @10
+                        call $fimport$10
+                      end
+                      local.get $2
+                      i32.const 12
+                      i32.add
+                      local.tee $1
+                      i32.load
+                      local.get $6
+                      i32.ne
+                      if ;; label = @10
+                        call $fimport$10
+                      end
+                      local.get $0
+                      i32.const 8
+                      i32.add
+                      local.tee $4
+                      i32.load
+                      local.get $6
+                      i32.eq
+                      if ;; label = @10
+                        block ;; label = @11
+                          local.get $1
+                          local.get $0
+                          i32.store
+                          local.get $4
+                          local.get $2
+                          i32.store
+                          local.get $0
+                          local.set $9
+                        end
+                      else
+                        call $fimport$10
+                      end
+                    end
+                  end
+                end
+                local.get $7
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $6
+                    local.get $6
+                    i32.load offset=28
+                    local.tee $0
+                    i32.const 2
+                    i32.shl
+                    i32.const 3948
+                    i32.add
+                    local.tee $2
+                    i32.load
+                    i32.eq
+                    if ;; label = @9
+                      block ;; label = @10
+                        local.get $2
+                        local.get $9
+                        i32.store
+                        local.get $9
+                        i32.eqz
+                        if ;; label = @11
+                          block ;; label = @12
+                            i32.const 3648
+                            i32.const 3648
+                            i32.load
+                            i32.const 1
+                            local.get $0
+                            i32.shl
+                            i32.const -1
+                            i32.xor
+                            i32.and
+                            i32.store
+                            br 8 (;@4;)
+                          end
+                        end
+                      end
+                    else
+                      block ;; label = @10
+                        local.get $7
+                        i32.const 3660
+                        i32.load
+                        i32.lt_u
+                        if ;; label = @11
+                          call $fimport$10
+                        end
+                        local.get $7
+                        i32.const 16
+                        i32.add
+                        local.tee $0
+                        i32.load
+                        local.get $6
+                        i32.eq
+                        if ;; label = @11
+                          local.get $0
+                          local.get $9
+                          i32.store
+                        else
+                          local.get $7
+                          local.get $9
+                          i32.store offset=20
+                        end
+                        local.get $9
+                        i32.eqz
+                        br_if 6 (;@4;)
+                      end
+                    end
+                    local.get $9
+                    i32.const 3660
+                    i32.load
+                    local.tee $2
+                    i32.lt_u
+                    if ;; label = @9
+                      call $fimport$10
+                    end
+                    local.get $9
+                    local.get $7
+                    i32.store offset=24
+                    local.get $6
+                    i32.const 16
+                    i32.add
+                    local.tee $1
+                    i32.load
+                    local.tee $0
+                    if ;; label = @9
+                      local.get $0
+                      local.get $2
+                      i32.lt_u
+                      if ;; label = @10
+                        call $fimport$10
+                      else
+                        block ;; label = @11
+                          local.get $9
+                          local.get $0
+                          i32.store offset=16
+                          local.get $0
+                          local.get $9
+                          i32.store offset=24
+                        end
+                      end
+                    end
+                    local.get $1
+                    i32.load offset=4
+                    local.tee $0
+                    if ;; label = @9
+                      local.get $0
+                      i32.const 3660
+                      i32.load
+                      i32.lt_u
+                      if ;; label = @10
+                        call $fimport$10
+                      else
+                        block ;; label = @11
+                          local.get $9
+                          local.get $0
+                          i32.store offset=20
+                          local.get $0
+                          local.get $9
+                          i32.store offset=24
+                        end
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+          local.get $3
+          local.get $5
+          i32.const 1
+          i32.or
+          i32.store offset=4
+          local.get $3
+          local.get $5
+          i32.add
+          local.get $5
+          i32.store
+          local.get $3
+          i32.const 3664
+          i32.load
+          i32.eq
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 3652
+              local.get $5
+              i32.store
+              return
+            end
+          else
+            local.get $5
+            local.set $2
+          end
+        end
+      end
+      local.get $2
+      i32.const 3
+      i32.shr_u
+      local.set $1
+      local.get $2
+      i32.const 256
+      i32.lt_u
+      if ;; label = @2
+        block ;; label = @3
+          local.get $1
+          i32.const 1
+          i32.shl
+          i32.const 2
+          i32.shl
+          i32.const 3684
+          i32.add
+          local.set $0
+          i32.const 3644
+          i32.load
+          local.tee $2
+          i32.const 1
+          local.get $1
+          i32.shl
+          local.tee $1
+          i32.and
+          if ;; label = @4
+            local.get $0
+            i32.const 8
+            i32.add
+            local.tee $2
+            i32.load
+            local.tee $1
+            i32.const 3660
+            i32.load
+            i32.lt_u
+            if ;; label = @5
+              call $fimport$10
+            else
+              block ;; label = @6
+                local.get $2
+                local.set $15
+                local.get $1
+                local.set $13
+              end
+            end
+          else
+            block ;; label = @5
+              i32.const 3644
+              local.get $2
+              local.get $1
+              i32.or
+              i32.store
+              local.get $0
+              i32.const 8
+              i32.add
+              local.set $15
+              local.get $0
+              local.set $13
+            end
+          end
+          local.get $15
+          local.get $3
+          i32.store
+          local.get $13
+          local.get $3
+          i32.store offset=12
+          local.get $3
+          local.get $13
+          i32.store offset=8
+          local.get $3
+          local.get $0
+          i32.store offset=12
+          return
+        end
+      end
+      local.get $2
+      i32.const 8
+      i32.shr_u
+      local.tee $0
+      if (result i32) ;; label = @2
+        local.get $2
+        i32.const 16777215
+        i32.gt_u
+        if (result i32) ;; label = @3
+          i32.const 31
+        else
+          local.get $2
+          i32.const 14
+          local.get $0
+          local.get $0
+          i32.const 1048320
+          i32.add
+          i32.const 16
+          i32.shr_u
+          i32.const 8
+          i32.and
+          local.tee $0
+          i32.shl
+          local.tee $1
+          i32.const 520192
+          i32.add
+          i32.const 16
+          i32.shr_u
+          i32.const 4
+          i32.and
+          local.tee $4
+          local.get $0
+          i32.or
+          local.get $1
+          local.get $4
+          i32.shl
+          local.tee $0
+          i32.const 245760
+          i32.add
+          i32.const 16
+          i32.shr_u
+          i32.const 2
+          i32.and
+          local.tee $1
+          i32.or
+          i32.sub
+          local.get $0
+          local.get $1
+          i32.shl
+          i32.const 15
+          i32.shr_u
+          i32.add
+          local.tee $0
+          i32.const 7
+          i32.add
+          i32.shr_u
+          i32.const 1
+          i32.and
+          local.get $0
+          i32.const 1
+          i32.shl
+          i32.or
+        end
+      else
+        i32.const 0
+      end
+      local.tee $1
+      i32.const 2
+      i32.shl
+      i32.const 3948
+      i32.add
+      local.set $0
+      local.get $3
+      local.get $1
+      i32.store offset=28
+      local.get $3
+      i32.const 0
+      i32.store offset=20
+      local.get $3
+      i32.const 0
+      i32.store offset=16
+      block $label$113 ;; label = @2
+        i32.const 3648
+        i32.load
+        local.tee $4
+        i32.const 1
+        local.get $1
+        i32.shl
+        local.tee $5
+        i32.and
+        if ;; label = @3
+          block ;; label = @4
+            local.get $0
+            i32.load
+            local.set $0
+            i32.const 25
+            local.get $1
+            i32.const 1
+            i32.shr_u
+            i32.sub
+            local.set $4
+            local.get $2
+            local.get $1
+            i32.const 31
+            i32.eq
+            if (result i32) ;; label = @5
+              i32.const 0
+            else
+              local.get $4
+            end
+            i32.shl
+            local.set $1
+            block $label$117 ;; label = @5
+              block $label$118 ;; label = @6
+                block $label$119 ;; label = @7
+                  loop $label$120 ;; label = @8
+                    local.get $0
+                    i32.load offset=4
+                    i32.const -8
+                    i32.and
+                    local.get $2
+                    i32.eq
+                    br_if 2 (;@6;)
+                    local.get $1
+                    i32.const 1
+                    i32.shl
+                    local.set $4
+                    local.get $0
+                    i32.const 16
+                    i32.add
+                    local.get $1
+                    i32.const 31
+                    i32.shr_u
+                    i32.const 2
+                    i32.shl
+                    i32.add
+                    local.tee $1
+                    i32.load
+                    local.tee $5
+                    i32.eqz
+                    br_if 1 (;@7;)
+                    local.get $4
+                    local.set $1
+                    local.get $5
+                    local.set $0
+                    br 0 (;@8;)
+                  end
+                end
+                local.get $1
+                i32.const 3660
+                i32.load
+                i32.lt_u
+                if ;; label = @7
+                  call $fimport$10
+                else
+                  block ;; label = @8
+                    local.get $1
+                    local.get $3
+                    i32.store
+                    local.get $3
+                    local.get $0
+                    i32.store offset=24
+                    local.get $3
+                    local.get $3
+                    i32.store offset=12
+                    local.get $3
+                    local.get $3
+                    i32.store offset=8
+                    br 6 (;@2;)
+                  end
+                end
+                br 1 (;@5;)
+              end
+              local.get $0
+              i32.const 8
+              i32.add
+              local.tee $1
+              i32.load
+              local.tee $2
+              i32.const 3660
+              i32.load
+              local.tee $4
+              i32.ge_u
+              local.get $0
+              local.get $4
+              i32.ge_u
+              i32.and
+              if ;; label = @6
+                block ;; label = @7
+                  local.get $2
+                  local.get $3
+                  i32.store offset=12
+                  local.get $1
+                  local.get $3
+                  i32.store
+                  local.get $3
+                  local.get $2
+                  i32.store offset=8
+                  local.get $3
+                  local.get $0
+                  i32.store offset=12
+                  local.get $3
+                  i32.const 0
+                  i32.store offset=24
+                end
+              else
+                call $fimport$10
+              end
+            end
+          end
+        else
+          block ;; label = @4
+            i32.const 3648
+            local.get $4
+            local.get $5
+            i32.or
+            i32.store
+            local.get $0
+            local.get $3
+            i32.store
+            local.get $3
+            local.get $0
+            i32.store offset=24
+            local.get $3
+            local.get $3
+            i32.store offset=12
+            local.get $3
+            local.get $3
+            i32.store offset=8
+          end
+        end
+      end
+      i32.const 3676
+      i32.const 3676
+      i32.load
+      i32.const -1
+      i32.add
+      local.tee $0
+      i32.store
+      local.get $0
+      if ;; label = @2
+        return
+      else
+        i32.const 4100
+        local.set $0
+      end
+      loop $label$128 ;; label = @2
+        local.get $0
+        i32.load
+        local.tee $2
+        i32.const 8
+        i32.add
+        local.set $0
+        local.get $2
+        br_if 0 (;@2;)
+      end
+      i32.const 3676
+      i32.const -1
+      i32.store
+    end
+  )
+  (func $33 (;46;) (type $6)
+    nop
+  )
+  (func $34 (;47;) (type $1) (param $0 i32) (result i32)
+    (local $1 i32) (local $2 i32)
+    block $label$1 (result i32) ;; label = @1
+      global.get $global$0
+      i32.load
+      local.tee $2
+      local.get $0
+      i32.const 15
+      i32.add
+      i32.const -16
+      i32.and
+      local.tee $0
+      i32.add
+      local.set $1
+      local.get $0
+      i32.const 0
+      i32.gt_s
+      local.get $1
+      local.get $2
+      i32.lt_s
+      i32.and
+      local.get $1
+      i32.const 0
+      i32.lt_s
+      i32.or
+      if ;; label = @2
+        block ;; label = @3
+          call $fimport$6
+          drop
+          i32.const 12
+          call $fimport$11
+          i32.const -1
+          return
+        end
+      end
+      global.get $global$0
+      local.get $1
+      i32.store
+      local.get $1
+      call $fimport$5
+      i32.gt_s
+      if ;; label = @2
+        call $fimport$4
+        i32.eqz
+        if ;; label = @3
+          block ;; label = @4
+            i32.const 12
+            call $fimport$11
+            global.get $global$0
+            local.get $2
+            i32.store
+            i32.const -1
+            return
+          end
+        end
+      end
+      local.get $2
+    end
+  )
+  (func $35 (;48;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32) (local $4 i32) (local $5 i32)
+    block $label$1 (result i32) ;; label = @1
+      local.get $0
+      local.get $2
+      i32.add
+      local.set $4
+      local.get $2
+      i32.const 20
+      i32.ge_s
+      if ;; label = @2
+        block ;; label = @3
+          local.get $1
+          i32.const 255
+          i32.and
+          local.set $1
+          local.get $0
+          i32.const 3
+          i32.and
+          local.tee $3
+          if ;; label = @4
+            block ;; label = @5
+              local.get $0
+              i32.const 4
+              i32.add
+              local.get $3
+              i32.sub
+              local.set $3
+              loop $label$4 ;; label = @6
+                local.get $0
+                local.get $3
+                i32.lt_s
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $0
+                    local.get $1
+                    i32.store8
+                    local.get $0
+                    i32.const 1
+                    i32.add
+                    local.set $0
+                    br 2 (;@6;)
+                  end
+                end
+              end
+            end
+          end
+          local.get $1
+          local.get $1
+          i32.const 8
+          i32.shl
+          i32.or
+          local.get $1
+          i32.const 16
+          i32.shl
+          i32.or
+          local.get $1
+          i32.const 24
+          i32.shl
+          i32.or
+          local.set $3
+          local.get $4
+          i32.const -4
+          i32.and
+          local.set $5
+          loop $label$6 ;; label = @4
+            local.get $0
+            local.get $5
+            i32.lt_s
+            if ;; label = @5
+              block ;; label = @6
+                local.get $0
+                local.get $3
+                i32.store
+                local.get $0
+                i32.const 4
+                i32.add
+                local.set $0
+                br 2 (;@4;)
+              end
+            end
+          end
+        end
+      end
+      loop $label$8 ;; label = @2
+        local.get $0
+        local.get $4
+        i32.lt_s
+        if ;; label = @3
+          block ;; label = @4
+            local.get $0
+            local.get $1
+            i32.store8
+            local.get $0
+            i32.const 1
+            i32.add
+            local.set $0
+            br 2 (;@2;)
+          end
+        end
+      end
+      local.get $0
+      local.get $2
+      i32.sub
+    end
+  )
+  (func $36 (;49;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    (local $3 i32)
+    block $label$1 (result i32) ;; label = @1
+      local.get $2
+      i32.const 4096
+      i32.ge_s
+      if ;; label = @2
+        local.get $0
+        local.get $1
+        local.get $2
+        call $fimport$12
+        return
+      end
+      local.get $0
+      local.set $3
+      local.get $0
+      i32.const 3
+      i32.and
+      local.get $1
+      i32.const 3
+      i32.and
+      i32.eq
+      if ;; label = @2
+        block ;; label = @3
+          loop $label$4 ;; label = @4
+            local.get $0
+            i32.const 3
+            i32.and
+            if ;; label = @5
+              block ;; label = @6
+                local.get $2
+                i32.eqz
+                if ;; label = @7
+                  local.get $3
+                  return
+                end
+                local.get $0
+                local.get $1
+                i32.load8_s
+                i32.store8
+                local.get $0
+                i32.const 1
+                i32.add
+                local.set $0
+                local.get $1
+                i32.const 1
+                i32.add
+                local.set $1
+                local.get $2
+                i32.const 1
+                i32.sub
+                local.set $2
+                br 2 (;@4;)
+              end
+            end
+          end
+          loop $label$7 ;; label = @4
+            local.get $2
+            i32.const 4
+            i32.ge_s
+            if ;; label = @5
+              block ;; label = @6
+                local.get $0
+                local.get $1
+                i32.load
+                i32.store
+                local.get $0
+                i32.const 4
+                i32.add
+                local.set $0
+                local.get $1
+                i32.const 4
+                i32.add
+                local.set $1
+                local.get $2
+                i32.const 4
+                i32.sub
+                local.set $2
+                br 2 (;@4;)
+              end
+            end
+          end
+        end
+      end
+      loop $label$9 ;; label = @2
+        local.get $2
+        i32.const 0
+        i32.gt_s
+        if ;; label = @3
+          block ;; label = @4
+            local.get $0
+            local.get $1
+            i32.load8_s
+            i32.store8
+            local.get $0
+            i32.const 1
+            i32.add
+            local.set $0
+            local.get $1
+            i32.const 1
+            i32.add
+            local.set $1
+            local.get $2
+            i32.const 1
+            i32.sub
+            local.set $2
+            br 2 (;@2;)
+          end
+        end
+      end
+      local.get $3
+    end
+  )
+  (func $37 (;50;) (type $3) (result i32)
+    i32.const 0
+  )
+  (func $38 (;51;) (type $4) (param $0 i32) (param $1 i32) (result i32)
+    local.get $1
+    local.get $0
+    i32.const 1
+    i32.and
+    i32.const 0
+    i32.add
+    call_indirect (type $1)
+  )
+  (func $39 (;52;) (type $12) (param $0 i32) (param $1 i32) (param $2 i32) (param $3 i32) (result i32)
+    local.get $1
+    local.get $2
+    local.get $3
+    local.get $0
+    i32.const 3
+    i32.and
+    i32.const 2
+    i32.add
+    call_indirect (type $0)
+  )
+  (func $40 (;53;) (type $5) (param $0 i32) (param $1 i32)
+    local.get $1
+    local.get $0
+    i32.const 1
+    i32.and
+    i32.const 6
+    i32.add
+    call_indirect (type $2)
+  )
+  (func $41 (;54;) (type $1) (param $0 i32) (result i32)
+    block $label$1 (result i32) ;; label = @1
+      i32.const 0
+      call $fimport$3
+      i32.const 0
+    end
+  )
+  (func $42 (;55;) (type $0) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    block $label$1 (result i32) ;; label = @1
+      i32.const 1
+      call $fimport$3
+      i32.const 0
+    end
+  )
+  (func $43 (;56;) (type $2) (param $0 i32)
+    i32.const 2
+    call $fimport$3
+  )
+  (global $global$0 (;5;) (mut i32) global.get $gimport$0)
+  (global $global$1 (;6;) (mut i32) global.get $gimport$1)
+  (global $global$2 (;7;) (mut i32) global.get $gimport$2)
+  (global $global$3 (;8;) (mut i32) i32.const 0)
+  (global $global$4 (;9;) (mut i32) i32.const 0)
+  (global $global$5 (;10;) (mut i32) i32.const 0)
+  (export "_sbrk" (func $34))
+  (export "_free" (func $32))
+  (export "_main" (func $7))
+  (export "_pthread_self" (func $37))
+  (export "_memset" (func $35))
+  (export "_malloc" (func $31))
+  (export "_memcpy" (func $36))
+  (export "___errno_location" (func $11))
+  (export "runPostSets" (func $33))
+  (export "stackAlloc" (func $0))
+  (export "stackSave" (func $1))
+  (export "stackRestore" (func $2))
+  (export "establishStackSpace" (func $3))
+  (export "setThrew" (func $4))
+  (export "setTempRet0" (func $5))
+  (export "getTempRet0" (func $6))
+  (export "dynCall_ii" (func $38))
+  (export "dynCall_iiii" (func $39))
+  (export "dynCall_vi" (func $40))
+  (elem (;0;) (global.get $gimport$19) func $41 $8 $42 $13 $9 $14 $43 $15)
+  (data (;0;) (i32.const 1024) "\04\04\00\00\05")
+  (data (;1;) (i32.const 1040) "\01")
+  (data (;2;) (i32.const 1064) "\01\00\00\00\02\00\00\004\10\00\00\00\04")
+  (data (;3;) (i32.const 1088) "\01")
+  (data (;4;) (i32.const 1103) "\0a\ff\ff\ff\ff")
+  (data (;5;) (i32.const 1140) "error: %d\5cn\00lastprime: %d.\0a\00\11\00\0a\00\11\11\11\00\00\00\00\05\00\00\00\00\00\00\09\00\00\00\00\0b")
+  (data (;6;) (i32.const 1200) "\11\00\0f\0a\11\11\11\03\0a\07\00\01\13\09\0b\0b\00\00\09\06\0b\00\00\0b\00\06\11\00\00\00\11\11\11")
+  (data (;7;) (i32.const 1249) "\0b")
+  (data (;8;) (i32.const 1258) "\11\00\0a\0a\11\11\11\00\0a\00\00\02\00\09\0b\00\00\00\09\00\0b\00\00\0b")
+  (data (;9;) (i32.const 1307) "\0c")
+  (data (;10;) (i32.const 1319) "\0c\00\00\00\00\0c\00\00\00\00\09\0c\00\00\00\00\00\0c\00\00\0c")
+  (data (;11;) (i32.const 1365) "\0e")
+  (data (;12;) (i32.const 1377) "\0d\00\00\00\04\0d\00\00\00\00\09\0e\00\00\00\00\00\0e\00\00\0e")
+  (data (;13;) (i32.const 1423) "\10")
+  (data (;14;) (i32.const 1435) "\0f\00\00\00\00\0f\00\00\00\00\09\10\00\00\00\00\00\10\00\00\10\00\00\12\00\00\00\12\12\12")
+  (data (;15;) (i32.const 1490) "\12\00\00\00\12\12\12\00\00\00\00\00\00\09")
+  (data (;16;) (i32.const 1539) "\0b")
+  (data (;17;) (i32.const 1551) "\0a\00\00\00\00\0a\00\00\00\00\09\0b\00\00\00\00\00\0b\00\00\0b")
+  (data (;18;) (i32.const 1597) "\0c")
+  (data (;19;) (i32.const 1609) "\0c\00\00\00\00\0c\00\00\00\00\09\0c\00\00\00\00\00\0c\00\00\0c\00\000123456789ABCDEF-+   0X0x\00(null)\00-0X+0X 0X-0x+0x 0x\00inf\00INF\00nan\00NAN\00.\00T!\22\19\0d\01\02\03\11K\1c\0c\10\04\0b\1d\12\1e'hnopqb \05\06\0f\13\14\15\1a\08\16\07($\17\18\09\0a\0e\1b\1f%#\83\82}&*+<=>?CGJMXYZ[\5c]^_`acdefgijklrstyz{|\00Illegal byte sequence\00Domain error\00Result not representable\00Not a tty\00Permission denied\00Operation not permitted\00No such file or directory\00No such process\00File exists\00Value too large for data type\00No space left on device\00Out of memory\00Resource busy\00Interrupted system call\00Resource temporarily unavailable\00Invalid seek\00Cross-device link\00Read-only file system\00Directory not empty\00Connection reset by peer\00Operation timed out\00Connection refused\00Host is down\00Host is unreachable\00Address in use\00Broken pipe\00I/O error\00No such device or address\00Block device required\00No such device\00Not a directory\00Is a directory\00Text file busy\00Exec format error\00Invalid argument\00Argument list too long\00Symbolic link loop\00Filename too long\00Too many open files in system\00No file descriptors available\00Bad file descriptor\00No child process\00Bad address\00File too large\00Too many links\00No locks available\00Resource deadlock would occur\00State not recoverable\00Previous owner died\00Operation canceled\00Function not implemented\00No message of desired type\00Identifier removed\00Device not a stream\00No data available\00Device timeout\00Out of streams resources\00Link has been severed\00Protocol error\00Bad message\00File descriptor in bad state\00Not a socket\00Destination address required\00Message too large\00Protocol wrong type for socket\00Protocol not available\00Protocol not supported\00Socket type not supported\00Not supported\00Protocol family not supported\00Address family not supported by protocol\00Address not available\00Network is down\00Network unreachable\00Connection reset by network\00Connection aborted\00No buffer space available\00Socket is connected\00Socket not connected\00Cannot send after socket shutdown\00Operation already in progress\00Operation in progress\00Stale file handle\00Remote I/O error\00Quota exceeded\00No medium found\00Wrong medium type\00No error information")
+)
diff --git a/tests/misc_testsuite/externref-table-dropped-segment-issue-8281.wast b/tests/misc_testsuite/externref-table-dropped-segment-issue-8281.wast
new file mode 100644
index 000000000000..723c03c801e3
--- /dev/null
+++ b/tests/misc_testsuite/externref-table-dropped-segment-issue-8281.wast
@@ -0,0 +1,39 @@
+(module
+  (table $t 0 0 externref)
+
+  (func (export "f1")
+    (i32.const 0)
+    (i32.const 0)
+    (i32.const 0)
+    (table.init $t $declared)
+  )
+
+  (func (export "f2")
+    (i32.const 0)
+    (i32.const 0)
+    (i32.const 0)
+    (table.init $t $passive)
+
+    (elem.drop $passive)
+
+    (i32.const 0)
+    (i32.const 0)
+    (i32.const 0)
+    (table.init $t $passive)
+  )
+
+  (func (export "f3")
+    (i32.const 0)
+    (i32.const 0)
+    (i32.const 0)
+    (table.init $t $active)
+  )
+
+  (elem $declared declare externref)
+  (elem $passive externref)
+  (elem $active (i32.const 0) externref)
+)
+
+(assert_return (invoke "f1"))
+(assert_return (invoke "f2"))
+(assert_return (invoke "f3"))
diff --git a/tests/misc_testsuite/float-round-doesnt-load-too-much.wast b/tests/misc_testsuite/float-round-doesnt-load-too-much.wast
new file mode 100644
index 000000000000..cecd84a85b16
--- /dev/null
+++ b/tests/misc_testsuite/float-round-doesnt-load-too-much.wast
@@ -0,0 +1,28 @@
+(module
+  (memory 1)
+  (func (export "ceil") (param i32) (result f64)
+    local.get 0
+    f64.load
+    f64.ceil
+    return)
+  (func (export "trunc") (param i32) (result f64)
+    local.get 0
+    f64.load
+    f64.trunc
+    return)
+  (func (export "floor") (param i32) (result f64)
+    local.get 0
+    f64.load
+    f64.floor
+    return)
+  (func (export "nearest") (param i32) (result f64)
+    local.get 0
+    f64.load
+    f64.nearest
+    return)
+)
+
+(assert_return (invoke "ceil" (i32.const 0xfff8)) (f64.const 0))
+(assert_return (invoke "trunc" (i32.const 0xfff8)) (f64.const 0))
+(assert_return (invoke "floor" (i32.const 0xfff8)) (f64.const 0))
+(assert_return (invoke "nearest" (i32.const 0xfff8)) (f64.const 0))
diff --git a/tests/misc_testsuite/function-references/call_indirect.wast b/tests/misc_testsuite/function-references/call_indirect.wast
new file mode 100644
index 000000000000..60fabf9c6204
--- /dev/null
+++ b/tests/misc_testsuite/function-references/call_indirect.wast
@@ -0,0 +1,54 @@
+(module
+  (table $t1 2 funcref)
+  (elem (table $t1) (i32.const 0) func $nop)
+  (func $nop)
+
+  (func (export "t1") (param i32)
+    local.get 0
+    call_indirect $t1)
+  (func (export "t1-wrong-type") (param i32)
+    i32.const 0
+    local.get 0
+    call_indirect $t1 (param i32))
+
+  (type $empty (func))
+  (table $t2 2 (ref null $empty))
+  (elem (table $t2) (i32.const 0) (ref null $empty) (ref.func $nop))
+
+  (func (export "t2") (param i32)
+    local.get 0
+    call_indirect $t2)
+  (func (export "t2-wrong-type") (param i32)
+    i32.const 0
+    local.get 0
+    call_indirect $t2 (param i32))
+
+  (table $t3 2 (ref $empty) (ref.func $nop))
+
+  (func (export "t3") (param i32)
+    local.get 0
+    call_indirect $t3)
+  (func (export "t3-wrong-type") (param i32)
+    i32.const 0
+    local.get 0
+    call_indirect $t3 (param i32))
+)
+
+(assert_return (invoke "t1" (i32.const 0)))
+(assert_trap (invoke "t1" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "t1" (i32.const 2)) "out of bounds")
+(assert_trap (invoke "t1-wrong-type" (i32.const 0)) "call type mismatch")
+(assert_trap (invoke "t1-wrong-type" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "t1-wrong-type" (i32.const 2)) "out of bounds")
+(assert_return (invoke "t2" (i32.const 0)))
+(assert_trap (invoke "t2" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "t2" (i32.const 2)) "out of bounds")
+(assert_trap (invoke "t2-wrong-type" (i32.const 0)) "call type mismatch")
+(assert_trap (invoke "t2-wrong-type" (i32.const 1)) "uninitialized element")
+(assert_trap (invoke "t2-wrong-type" (i32.const 2)) "out of bounds")
+(assert_return (invoke "t3" (i32.const 0)))
+(assert_return (invoke "t3" (i32.const 1)))
+(assert_trap (invoke "t3" (i32.const 2)) "out of bounds")
+(assert_trap (invoke "t3-wrong-type" (i32.const 0)) "call type mismatch")
+(assert_trap (invoke "t3-wrong-type" (i32.const 1)) "call type mismatch")
+(assert_trap (invoke "t3-wrong-type" (i32.const 2)) "out of bounds")
diff --git a/tests/misc_testsuite/gc/anyref_that_is_i31_barriers.wast b/tests/misc_testsuite/gc/anyref_that_is_i31_barriers.wast
new file mode 100644
index 000000000000..22d06191f5ca
--- /dev/null
+++ b/tests/misc_testsuite/gc/anyref_that_is_i31_barriers.wast
@@ -0,0 +1,54 @@
+;; Test that our inline GC barriers detect `i31`s and don't attempt to actually
+;; deref them or anything like that.
+
+;; Nullable GC references.
+(module
+  (table $table 1 1 anyref)
+
+  (func (export "get") (param i32) (result anyref)
+    local.get 0
+    table.get $table
+  )
+
+  (func $do_set (param i32 anyref)
+    local.get 0
+    local.get 1
+    table.set $table
+  )
+
+  (func (export "set") (param i32 i32)
+    local.get 0
+    (ref.i31 local.get 1)
+    call $do_set
+  )
+)
+
+(assert_return (invoke "get" (i32.const 0)) (ref.null any))
+(invoke "set" (i32.const 0) (i32.const 42))
+(assert_return (invoke "get" (i32.const 0)) (ref.i31))
+
+;; Non-nullable GC references.
+(module
+  (table $table 1 1 (ref any) (ref.i31 (i32.const 0)))
+
+  (func (export "get") (param i32) (result (ref any))
+    local.get 0
+    table.get $table
+  )
+
+  (func $do_set (param i32 (ref any))
+    local.get 0
+    local.get 1
+    table.set $table
+  )
+
+  (func (export "set") (param i32 i32)
+    local.get 0
+    (ref.i31 local.get 1)
+    call $do_set
+  )
+)
+
+(assert_return (invoke "get" (i32.const 0)) (ref.i31))
+(invoke "set" (i32.const 0) (i32.const 42))
+(assert_return (invoke "get" (i32.const 0)) (ref.i31))
diff --git a/tests/misc_testsuite/gc/array-types.wast b/tests/misc_testsuite/gc/array-types.wast
new file mode 100644
index 000000000000..83e5a244148c
--- /dev/null
+++ b/tests/misc_testsuite/gc/array-types.wast
@@ -0,0 +1,22 @@
+(module
+  (type (array i8))
+  (type (array i16))
+  (type (array i32))
+  (type (array i64))
+  (type (array f32))
+  (type (array f64))
+  (type (array anyref))
+  (type (array (ref struct)))
+  (type (array (ref 0)))
+  (type (array (ref null 1)))
+  (type (array (mut i8)))
+  (type (array (mut i16)))
+  (type (array (mut i32)))
+  (type (array (mut i64)))
+  (type (array (mut i32)))
+  (type (array (mut i64)))
+  (type (array (mut anyref)))
+  (type (array (mut (ref struct))))
+  (type (array (mut (ref 0))))
+  (type (array (mut (ref null i31))))
+)
diff --git a/tests/misc_testsuite/gc/i31ref-of-global-initializers.wast b/tests/misc_testsuite/gc/i31ref-of-global-initializers.wast
new file mode 100644
index 000000000000..76a6dbe2503b
--- /dev/null
+++ b/tests/misc_testsuite/gc/i31ref-of-global-initializers.wast
@@ -0,0 +1,31 @@
+(module $env
+  (global (export "g1") i32 (i32.const 42))
+  (global (export "g2") i32 (i32.const 99))
+)
+(register "env")
+
+(module $i31ref_of_global_const_expr_and_tables
+  (global $g1 (import "env" "g1") i32)
+  (global $g2 (import "env" "g2") i32)
+
+  (table $t 3 3 (ref i31) (ref.i31 (global.get $g1)))
+  (elem (table $t) (i32.const 2) (ref i31) (ref.i31 (global.get $g2)))
+
+  (func (export "get") (param i32) (result i32)
+    (i31.get_u (local.get 0) (table.get $t))
+  )
+)
+
+(assert_return (invoke "get" (i32.const 0)) (i32.const 42))
+(assert_return (invoke "get" (i32.const 1)) (i32.const 42))
+(assert_return (invoke "get" (i32.const 2)) (i32.const 99))
+
+(module $i31ref_of_global_const_expr_and_globals
+  (global $g1 (import "env" "g1") i32)
+  (global $g2 i31ref (ref.i31 (global.get $g1)))
+  (func (export "get") (result i32)
+    (i31.get_u (global.get $g2))
+  )
+)
+
+(assert_return (invoke "get") (i32.const 42))
diff --git a/tests/misc_testsuite/gc/i31ref-tables.wast b/tests/misc_testsuite/gc/i31ref-tables.wast
new file mode 100644
index 000000000000..d5f1595bd0a0
--- /dev/null
+++ b/tests/misc_testsuite/gc/i31ref-tables.wast
@@ -0,0 +1,61 @@
+(module $tables_of_i31ref
+  (table $table 3 10 i31ref)
+  (elem (table $table) (i32.const 0) i31ref (item (ref.i31 (i32.const 999)))
+                                            (item (ref.i31 (i32.const 888)))
+                                            (item (ref.i31 (i32.const 777))))
+
+  (func (export "size") (result i32)
+    table.size $table
+  )
+
+  (func (export "get") (param i32) (result i32)
+    (i31.get_u (table.get $table (local.get 0)))
+  )
+
+  (func (export "grow") (param i32 i32) (result i32)
+    (table.grow $table (ref.i31 (local.get 1)) (local.get 0))
+  )
+
+  (func (export "fill") (param i32 i32 i32)
+    (table.fill $table (local.get 0) (ref.i31 (local.get 1)) (local.get 2))
+  )
+
+  (func (export "copy") (param i32 i32 i32)
+    (table.copy $table $table (local.get 0) (local.get 1) (local.get 2))
+  )
+
+  (elem $elem i31ref (item (ref.i31 (i32.const 123)))
+                     (item (ref.i31 (i32.const 456)))
+                     (item (ref.i31 (i32.const 789))))
+  (func (export "init") (param i32 i32 i32)
+    (table.init $table $elem (local.get 0) (local.get 1) (local.get 2))
+  )
+)
+
+;; Initial state.
+(assert_return (invoke "size") (i32.const 3))
+(assert_return (invoke "get" (i32.const 0)) (i32.const 999))
+(assert_return (invoke "get" (i32.const 1)) (i32.const 888))
+(assert_return (invoke "get" (i32.const 2)) (i32.const 777))
+
+;; Grow from size 3 to size 5.
+(assert_return (invoke "grow" (i32.const 2) (i32.const 333)) (i32.const 3))
+(assert_return (invoke "size") (i32.const 5))
+(assert_return (invoke "get" (i32.const 3)) (i32.const 333))
+(assert_return (invoke "get" (i32.const 4)) (i32.const 333))
+
+;; Fill table[2..4] = 111.
+(invoke "fill" (i32.const 2) (i32.const 111) (i32.const 2))
+(assert_return (invoke "get" (i32.const 2)) (i32.const 111))
+(assert_return (invoke "get" (i32.const 3)) (i32.const 111))
+
+;; Copy from table[0..2] to table[3..5].
+(invoke "copy" (i32.const 3) (i32.const 0) (i32.const 2))
+(assert_return (invoke "get" (i32.const 3)) (i32.const 999))
+(assert_return (invoke "get" (i32.const 4)) (i32.const 888))
+
+;; Initialize the passive element at table[1..4].
+(invoke "init" (i32.const 1) (i32.const 0) (i32.const 3))
+(assert_return (invoke "get" (i32.const 1)) (i32.const 123))
+(assert_return (invoke "get" (i32.const 2)) (i32.const 456))
+(assert_return (invoke "get" (i32.const 3)) (i32.const 789))
diff --git a/tests/misc_testsuite/gc/null-i31ref.wast b/tests/misc_testsuite/gc/null-i31ref.wast
new file mode 100644
index 000000000000..ba7e5a8b39f0
--- /dev/null
+++ b/tests/misc_testsuite/gc/null-i31ref.wast
@@ -0,0 +1,11 @@
+(module
+  (func (export "get_u-null") (result i32)
+    (i31.get_u (ref.null i31))
+  )
+  (func (export "get_s-null") (result i32)
+    (i31.get_u (ref.null i31))
+  )
+)
+
+(assert_trap (invoke "get_u-null") "null i31 reference")
+(assert_trap (invoke "get_s-null") "null i31 reference")
diff --git a/tests/misc_testsuite/gc/rec-group-funcs.wast b/tests/misc_testsuite/gc/rec-group-funcs.wast
new file mode 100644
index 000000000000..3f8b27983c79
--- /dev/null
+++ b/tests/misc_testsuite/gc/rec-group-funcs.wast
@@ -0,0 +1,38 @@
+;; Test that we properly canonicalize function types across modules, at the
+;; engine level. We rely on this canonicalization to make cross-module imports
+;; work among other things.
+
+(module $m1
+  ;; A pair of recursive types.
+  (rec (type $type_a (sub final (func (result i32 (ref null $type_b)))))
+       (type $type_b (sub final (func (result i32 (ref null $type_a))))))
+
+  (func (export "func_a") (type $type_a)
+    i32.const 1234
+    ref.null $type_b
+  )
+
+  (func (export "func_b") (type $type_b)
+    i32.const 4321
+    ref.null $type_a
+  )
+)
+(register "m1")
+
+(module $m2
+  ;; The same pair of recursive types.
+  (rec (type $type_a (sub final (func (result i32 (ref null $type_b)))))
+       (type $type_b (sub final (func (result i32 (ref null $type_a))))))
+
+  (import "m1" "func_a" (func $func_a (type $type_a)))
+  (import "m1" "func_b" (func $func_b (type $type_b)))
+
+  (func (export "call") (result i32 i32)
+    call $func_a
+    drop
+    call $func_b
+    drop
+  )
+)
+
+(assert_return (invoke "call") (i32.const 1234) (i32.const 4321))
diff --git a/tests/misc_testsuite/gc/struct-types.wast b/tests/misc_testsuite/gc/struct-types.wast
new file mode 100644
index 000000000000..5b272e080926
--- /dev/null
+++ b/tests/misc_testsuite/gc/struct-types.wast
@@ -0,0 +1,10 @@
+(module
+  (type (struct))
+  (type (struct (field)))
+  (type (struct (field i8)))
+  (type (struct (field i8 i8 i8 i8)))
+  (type (struct (field $x1 i32) (field $y1 i32)))
+  (type (struct (field i8 i16 i32 i64 f32 f64 anyref funcref (ref 0) (ref null 1))))
+  (type (struct (field i32 i64 i8) (field) (field) (field (ref null i31) anyref structref arrayref)))
+  (type (struct (field $x2 i32) (field f32 f64) (field $y2 i32)))
+)
diff --git a/tests/misc_testsuite/int-to-float-splat.wast b/tests/misc_testsuite/int-to-float-splat.wast
new file mode 100644
index 000000000000..2a6110200293
--- /dev/null
+++ b/tests/misc_testsuite/int-to-float-splat.wast
@@ -0,0 +1,15 @@
+(module
+  (func (param i32) (result v128)
+    local.get 0
+    i32x4.splat
+    f64x2.convert_low_i32x4_u
+  )
+)
+
+(module
+  (func (result v128)
+    i32.const 0
+    i32x4.splat
+    f64x2.convert_low_i32x4_u
+  )
+)
diff --git a/tests/misc_testsuite/linking-errors.wast b/tests/misc_testsuite/linking-errors.wast
index 122c9a2b3505..a3a262c539fa 100644
--- a/tests/misc_testsuite/linking-errors.wast
+++ b/tests/misc_testsuite/linking-errors.wast
@@ -45,8 +45,8 @@
 ;; errors on functions
 (assert_unlinkable
   (module (import "m" "f" (func (param i32))))
-  "expected func of type `(i32) -> ()`, found func of type `() -> ()`")
+  "expected type `(func (param i32))`, found type `(func)`")
 
 (assert_unlinkable
   (module (import "m" "f p1r2" (func (param i32 i32) (result f64))))
-  "expected func of type `(i32, i32) -> (f64)`, found func of type `(f32) -> (i32, i64)`")
+  "expected type `(func (param i32 i32) (result f64))`, found type `(func (param f32) (result i32 i64))`")
diff --git a/tests/misc_testsuite/rs2wasm-add-func.wast b/tests/misc_testsuite/rs2wasm-add-func.wast
index 89af3ffc4dca..660cd87434dd 100644
--- a/tests/misc_testsuite/rs2wasm-add-func.wast
+++ b/tests/misc_testsuite/rs2wasm-add-func.wast
@@ -6,7 +6,7 @@
     local.get 0
     i32.add)
   (func $start (type 0))
-  (table (;0;) 1 1 anyfunc)
+  (table (;0;) 1 1 funcref)
   (memory (;0;) 17)
   (global (;0;) i32 (i32.const 1049114))
   (global (;1;) i32 (i32.const 1049114))
diff --git a/tests/misc_testsuite/rust_fannkuch.wast b/tests/misc_testsuite/rust_fannkuch.wast
new file mode 100644
index 000000000000..e4d65df0461c
--- /dev/null
+++ b/tests/misc_testsuite/rust_fannkuch.wast
@@ -0,0 +1,1726 @@
+;; copied from a historical cranelift-wasm test and provided here as proof that
+;; this still compiles on various platforms and such
+
+(module
+  (type $0 (;0;) (func (param i32 i32 i32) (result i32)))
+  (type $1 (;1;) (func (param i32 i32) (result i32)))
+  (type $2 (;2;) (func (param i32)))
+  (type $3 (;3;) (func (param i32) (result i32)))
+  (type $4 (;4;) (func (param i32 i32)))
+  (type $5 (;5;) (func (param i64 i32) (result i32)))
+  (type $6 (;6;) (func (param i32) (result i64)))
+  (type $7 (;7;) (func))
+  (type $8 (;8;) (func (param i32 i32)))
+  (type $9 (;9;) (func (param i32 i32 i32) (result i32)))
+  (func $0 (;0;) (type $7)
+    (local $0 i32) (local $1 i32)
+    i32.const 1
+    local.set $0
+    block $label$1 ;; label = @1
+      block $label$2 ;; label = @2
+        block $label$3 ;; label = @3
+          i32.const 1049232
+          i32.load
+          i32.const 1
+          i32.eq
+          if ;; label = @4
+            block ;; label = @5
+              i32.const 1049236
+              i32.const 1049236
+              i32.load
+              i32.const 1
+              i32.add
+              local.tee $0
+              i32.store
+              local.get $0
+              i32.const 3
+              i32.lt_u
+              br_if 2 (;@3;)
+              br 3 (;@2;)
+            end
+          end
+          i32.const 1049232
+          i64.const 4294967297
+          i64.store
+        end
+        i32.const 1049240
+        i32.load
+        local.tee $1
+        i32.const -1
+        i32.le_s
+        br_if 0 (;@2;)
+        i32.const 1049240
+        local.get $1
+        i32.store
+        local.get $0
+        i32.const 2
+        i32.lt_u
+        br_if 1 (;@1;)
+      end
+      unreachable
+    end
+    unreachable
+  )
+  (func $1 (;1;) (type $2) (param $0 i32)
+    (local $1 i32)
+    global.get $global$0
+    i32.const 16
+    i32.sub
+    local.tee $1
+    global.set $global$0
+    local.get $0
+    i32.load offset=8
+    i32.eqz
+    if ;; label = @1
+      block ;; label = @2
+        i32.const 1049172
+        call $2
+        unreachable
+      end
+    end
+    local.get $1
+    local.get $0
+    i32.const 20
+    i32.add
+    i64.load align=4
+    i64.store offset=8
+    local.get $1
+    local.get $0
+    i64.load offset=12 align=4
+    i64.store
+    call $0
+    unreachable
+  )
+  (func $2 (;2;) (type $2) (param $0 i32)
+    (local $1 i32) (local $2 i64) (local $3 i64) (local $4 i64)
+    global.get $global$0
+    i32.const 48
+    i32.sub
+    local.tee $1
+    global.set $global$0
+    local.get $0
+    i64.load offset=8 align=4
+    local.set $2
+    local.get $0
+    i64.load offset=16 align=4
+    local.set $3
+    local.get $0
+    i64.load align=4
+    local.set $4
+    local.get $1
+    i32.const 20
+    i32.add
+    i32.const 0
+    i32.store
+    local.get $1
+    local.get $4
+    i64.store offset=24
+    local.get $1
+    i32.const 1048656
+    i32.store offset=16
+    local.get $1
+    i64.const 1
+    i64.store offset=4 align=4
+    local.get $1
+    local.get $1
+    i32.const 24
+    i32.add
+    i32.store
+    local.get $1
+    local.get $3
+    i64.store offset=40
+    local.get $1
+    local.get $2
+    i64.store offset=32
+    local.get $1
+    local.get $1
+    i32.const 32
+    i32.add
+    call $5
+    unreachable
+  )
+  (func $3 (;3;) (type $8) (param $0 i32) (param $1 i32)
+    (local $2 i32)
+    global.get $global$0
+    i32.const 48
+    i32.sub
+    local.tee $2
+    global.set $global$0
+    local.get $2
+    i32.const 16
+    i32.store offset=4
+    local.get $2
+    local.get $1
+    i32.store
+    local.get $2
+    i32.const 44
+    i32.add
+    i32.const 1
+    i32.store
+    local.get $2
+    i32.const 28
+    i32.add
+    i32.const 2
+    i32.store
+    local.get $2
+    i32.const 1
+    i32.store offset=36
+    local.get $2
+    i64.const 2
+    i64.store offset=12 align=4
+    local.get $2
+    i32.const 1049140
+    i32.store offset=8
+    local.get $2
+    local.get $2
+    i32.store offset=40
+    local.get $2
+    local.get $2
+    i32.const 4
+    i32.add
+    i32.store offset=32
+    local.get $2
+    local.get $2
+    i32.const 32
+    i32.add
+    i32.store offset=24
+    local.get $2
+    i32.const 8
+    i32.add
+    local.get $0
+    call $5
+    unreachable
+  )
+  (func $4 (;4;) (type $1) (param $0 i32) (param $1 i32) (result i32)
+    local.get $0
+    i64.load32_u
+    local.get $1
+    call $6
+  )
+  (func $5 (;5;) (type $4) (param $0 i32) (param $1 i32)
+    (local $2 i32) (local $3 i64)
+    global.get $global$0
+    i32.const 32
+    i32.sub
+    local.tee $2
+    global.set $global$0
+    local.get $1
+    i64.load align=4
+    local.set $3
+    local.get $2
+    i32.const 20
+    i32.add
+    local.get $1
+    i64.load offset=8 align=4
+    i64.store align=4
+    local.get $2
+    local.get $3
+    i64.store offset=12 align=4
+    local.get $2
+    local.get $0
+    i32.store offset=8
+    local.get $2
+    i32.const 1049156
+    i32.store offset=4
+    local.get $2
+    i32.const 1048656
+    i32.store
+    local.get $2
+    call $1
+    unreachable
+  )
+  (func $6 (;6;) (type $5) (param $0 i64) (param $1 i32) (result i32)
+    (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i64) (local $14 i32) (local $15 i32)
+    global.get $global$0
+    i32.const 48
+    i32.sub
+    local.tee $6
+    global.set $global$0
+    i32.const 39
+    local.set $2
+    block $label$1 ;; label = @1
+      block $label$2 ;; label = @2
+        local.get $0
+        i64.const 10000
+        i64.ge_u
+        if ;; label = @3
+          block ;; label = @4
+            loop $label$4 ;; label = @5
+              local.get $6
+              i32.const 9
+              i32.add
+              local.get $2
+              i32.add
+              local.tee $3
+              i32.const -4
+              i32.add
+              local.get $0
+              local.get $0
+              i64.const 10000
+              i64.div_u
+              local.tee $13
+              i64.const -10000
+              i64.mul
+              i64.add
+              i32.wrap_i64
+              local.tee $4
+              i32.const 100
+              i32.div_u
+              local.tee $5
+              i32.const 1
+              i32.shl
+              i32.const 1048706
+              i32.add
+              i32.load16_u align=1
+              i32.store16 align=1
+              local.get $3
+              i32.const -2
+              i32.add
+              local.get $5
+              i32.const -100
+              i32.mul
+              local.get $4
+              i32.add
+              i32.const 1
+              i32.shl
+              i32.const 1048706
+              i32.add
+              i32.load16_u align=1
+              i32.store16 align=1
+              local.get $2
+              i32.const -4
+              i32.add
+              local.set $2
+              block (result i32) ;; label = @6
+                local.get $0
+                i64.const 99999999
+                i64.gt_u
+                local.set $14
+                local.get $13
+                local.set $0
+                local.get $14
+              end
+              br_if 0 (;@5;)
+            end
+            local.get $13
+            i32.wrap_i64
+            local.tee $3
+            i32.const 99
+            i32.le_s
+            br_if 3 (;@1;)
+            br 2 (;@2;)
+          end
+        end
+        local.get $0
+        local.tee $13
+        i32.wrap_i64
+        local.tee $3
+        i32.const 99
+        i32.le_s
+        br_if 1 (;@1;)
+      end
+      local.get $2
+      i32.const -2
+      i32.add
+      local.tee $2
+      local.get $6
+      i32.const 9
+      i32.add
+      i32.add
+      local.get $13
+      i32.wrap_i64
+      local.tee $4
+      i32.const 65535
+      i32.and
+      i32.const 100
+      i32.div_u
+      local.tee $3
+      i32.const -100
+      i32.mul
+      local.get $4
+      i32.add
+      i32.const 65535
+      i32.and
+      i32.const 1
+      i32.shl
+      i32.const 1048706
+      i32.add
+      i32.load16_u align=1
+      i32.store16 align=1
+    end
+    block $label$5 ;; label = @1
+      local.get $3
+      i32.const 9
+      i32.le_s
+      if ;; label = @2
+        block ;; label = @3
+          local.get $2
+          i32.const -1
+          i32.add
+          local.tee $2
+          local.get $6
+          i32.const 9
+          i32.add
+          i32.add
+          local.get $3
+          i32.const 48
+          i32.add
+          i32.store8
+          br 2 (;@1;)
+        end
+      end
+      local.get $2
+      i32.const -2
+      i32.add
+      local.tee $2
+      local.get $6
+      i32.const 9
+      i32.add
+      i32.add
+      local.get $3
+      i32.const 1
+      i32.shl
+      i32.const 1048706
+      i32.add
+      i32.load16_u align=1
+      i32.store16 align=1
+    end
+    i32.const 39
+    local.get $2
+    i32.sub
+    local.set $7
+    i32.const 1
+    local.set $3
+    i32.const 43
+    i32.const 1114112
+    local.get $1
+    i32.load
+    local.tee $4
+    i32.const 1
+    i32.and
+    local.tee $11
+    select
+    local.set $8
+    local.get $4
+    i32.const 29
+    i32.shl
+    i32.const 31
+    i32.shr_s
+    i32.const 1048656
+    i32.and
+    local.set $9
+    local.get $6
+    i32.const 9
+    i32.add
+    local.get $2
+    i32.add
+    local.set $10
+    block $label$7 ;; label = @1
+      block $label$8 ;; label = @2
+        block $label$9 ;; label = @3
+          block $label$10 ;; label = @4
+            block $label$11 ;; label = @5
+              block $label$12 ;; label = @6
+                block $label$13 ;; label = @7
+                  block $label$14 ;; label = @8
+                    block $label$15 (result i32) ;; label = @9
+                      block $label$16 ;; label = @10
+                        block $label$17 ;; label = @11
+                          block $label$18 ;; label = @12
+                            block $label$19 ;; label = @13
+                              local.get $1
+                              i32.load offset=8
+                              i32.const 1
+                              i32.eq
+                              if ;; label = @14
+                                block ;; label = @15
+                                  local.get $1
+                                  i32.const 12
+                                  i32.add
+                                  i32.load
+                                  local.tee $5
+                                  local.get $7
+                                  local.get $11
+                                  i32.add
+                                  local.tee $2
+                                  i32.le_u
+                                  br_if 2 (;@13;)
+                                  local.get $4
+                                  i32.const 8
+                                  i32.and
+                                  br_if 3 (;@12;)
+                                  local.get $5
+                                  local.get $2
+                                  i32.sub
+                                  local.set $4
+                                  i32.const 1
+                                  local.get $1
+                                  i32.load8_u offset=48
+                                  local.tee $3
+                                  local.get $3
+                                  i32.const 3
+                                  i32.eq
+                                  select
+                                  local.tee $3
+                                  i32.const 3
+                                  i32.and
+                                  i32.eqz
+                                  br_if 4 (;@11;)
+                                  local.get $3
+                                  i32.const 2
+                                  i32.eq
+                                  br_if 5 (;@10;)
+                                  i32.const 0
+                                  local.set $5
+                                  local.get $4
+                                  br 6 (;@9;)
+                                end
+                              end
+                              local.get $1
+                              local.get $8
+                              local.get $9
+                              call $9
+                              br_if 10 (;@3;)
+                              br 11 (;@2;)
+                            end
+                            local.get $1
+                            local.get $8
+                            local.get $9
+                            call $9
+                            br_if 9 (;@3;)
+                            br 10 (;@2;)
+                          end
+                          local.get $1
+                          i32.const 1
+                          i32.store8 offset=48
+                          local.get $1
+                          i32.const 48
+                          i32.store offset=4
+                          local.get $1
+                          local.get $8
+                          local.get $9
+                          call $9
+                          br_if 8 (;@3;)
+                          local.get $5
+                          local.get $2
+                          i32.sub
+                          local.set $3
+                          i32.const 1
+                          local.get $1
+                          i32.const 48
+                          i32.add
+                          i32.load8_u
+                          local.tee $4
+                          local.get $4
+                          i32.const 3
+                          i32.eq
+                          select
+                          local.tee $4
+                          i32.const 3
+                          i32.and
+                          i32.eqz
+                          br_if 3 (;@8;)
+                          local.get $4
+                          i32.const 2
+                          i32.eq
+                          br_if 4 (;@7;)
+                          i32.const 0
+                          local.set $4
+                          br 5 (;@6;)
+                        end
+                        local.get $4
+                        local.set $5
+                        i32.const 0
+                        br 1 (;@9;)
+                      end
+                      local.get $4
+                      i32.const 1
+                      i32.add
+                      i32.const 1
+                      i32.shr_u
+                      local.set $5
+                      local.get $4
+                      i32.const 1
+                      i32.shr_u
+                    end
+                    local.set $3
+                    i32.const -1
+                    local.set $2
+                    local.get $1
+                    i32.const 4
+                    i32.add
+                    local.set $4
+                    local.get $1
+                    i32.const 24
+                    i32.add
+                    local.set $11
+                    local.get $1
+                    i32.const 28
+                    i32.add
+                    local.set $12
+                    block $label$21 ;; label = @9
+                      loop $label$22 ;; label = @10
+                        local.get $2
+                        i32.const 1
+                        i32.add
+                        local.tee $2
+                        local.get $3
+                        i32.ge_u
+                        br_if 1 (;@9;)
+                        local.get $11
+                        i32.load
+                        local.get $4
+                        i32.load
+                        local.get $12
+                        i32.load
+                        i32.load offset=16
+                        call_indirect (type $1)
+                        i32.eqz
+                        br_if 0 (;@10;)
+                      end
+                      br 8 (;@1;)
+                    end
+                    local.get $1
+                    i32.const 4
+                    i32.add
+                    i32.load
+                    local.set $4
+                    i32.const 1
+                    local.set $3
+                    local.get $1
+                    local.get $8
+                    local.get $9
+                    call $9
+                    br_if 5 (;@3;)
+                    local.get $1
+                    i32.const 24
+                    i32.add
+                    local.tee $2
+                    i32.load
+                    local.get $10
+                    local.get $7
+                    local.get $1
+                    i32.const 28
+                    i32.add
+                    local.tee $1
+                    i32.load
+                    i32.load offset=12
+                    call_indirect (type $0)
+                    br_if 5 (;@3;)
+                    local.get $2
+                    i32.load
+                    local.set $7
+                    i32.const -1
+                    local.set $2
+                    local.get $1
+                    i32.load
+                    i32.const 16
+                    i32.add
+                    local.set $1
+                    loop $label$23 ;; label = @9
+                      local.get $2
+                      i32.const 1
+                      i32.add
+                      local.tee $2
+                      local.get $5
+                      i32.ge_u
+                      br_if 4 (;@5;)
+                      local.get $7
+                      local.get $4
+                      local.get $1
+                      i32.load
+                      call_indirect (type $1)
+                      i32.eqz
+                      br_if 0 (;@9;)
+                    end
+                    br 5 (;@3;)
+                  end
+                  local.get $3
+                  local.set $4
+                  i32.const 0
+                  local.set $3
+                  br 1 (;@6;)
+                end
+                local.get $3
+                i32.const 1
+                i32.add
+                i32.const 1
+                i32.shr_u
+                local.set $4
+                local.get $3
+                i32.const 1
+                i32.shr_u
+                local.set $3
+              end
+              i32.const -1
+              local.set $2
+              local.get $1
+              i32.const 4
+              i32.add
+              local.set $5
+              local.get $1
+              i32.const 24
+              i32.add
+              local.set $8
+              local.get $1
+              i32.const 28
+              i32.add
+              local.set $9
+              block $label$24 ;; label = @6
+                loop $label$25 ;; label = @7
+                  local.get $2
+                  i32.const 1
+                  i32.add
+                  local.tee $2
+                  local.get $3
+                  i32.ge_u
+                  br_if 1 (;@6;)
+                  local.get $8
+                  i32.load
+                  local.get $5
+                  i32.load
+                  local.get $9
+                  i32.load
+                  i32.load offset=16
+                  call_indirect (type $1)
+                  i32.eqz
+                  br_if 0 (;@7;)
+                end
+                br 5 (;@1;)
+              end
+              local.get $1
+              i32.const 4
+              i32.add
+              i32.load
+              local.set $5
+              i32.const 1
+              local.set $3
+              local.get $1
+              i32.const 24
+              i32.add
+              local.tee $2
+              i32.load
+              local.get $10
+              local.get $7
+              local.get $1
+              i32.const 28
+              i32.add
+              local.tee $1
+              i32.load
+              i32.load offset=12
+              call_indirect (type $0)
+              br_if 2 (;@3;)
+              local.get $2
+              i32.load
+              local.set $7
+              i32.const -1
+              local.set $2
+              local.get $1
+              i32.load
+              i32.const 16
+              i32.add
+              local.set $1
+              loop $label$26 ;; label = @6
+                local.get $2
+                i32.const 1
+                i32.add
+                local.tee $2
+                local.get $4
+                i32.ge_u
+                br_if 2 (;@4;)
+                local.get $7
+                local.get $5
+                local.get $1
+                i32.load
+                call_indirect (type $1)
+                i32.eqz
+                br_if 0 (;@6;)
+              end
+              br 2 (;@3;)
+            end
+            local.get $6
+            i32.const 48
+            i32.add
+            global.set $global$0
+            i32.const 0
+            return
+          end
+          i32.const 0
+          local.set $3
+        end
+        local.get $6
+        i32.const 48
+        i32.add
+        global.set $global$0
+        local.get $3
+        return
+      end
+      block (result i32) ;; label = @2
+        local.get $1
+        i32.load offset=24
+        local.get $10
+        local.get $7
+        local.get $1
+        i32.const 28
+        i32.add
+        i32.load
+        i32.load offset=12
+        call_indirect (type $0)
+        local.set $15
+        local.get $6
+        i32.const 48
+        i32.add
+        global.set $global$0
+        local.get $15
+      end
+      return
+    end
+    local.get $6
+    i32.const 48
+    i32.add
+    global.set $global$0
+    i32.const 1
+  )
+  (func $7 (;7;) (type $2) (param $0 i32)
+    nop
+  )
+  (func $8 (;8;) (type $6) (param $0 i32) (result i64)
+    i64.const -2357177763932378009
+  )
+  (func $9 (;9;) (type $9) (param $0 i32) (param $1 i32) (param $2 i32) (result i32)
+    block $label$1 ;; label = @1
+      block $label$2 (result i32) ;; label = @2
+        local.get $1
+        i32.const 1114112
+        i32.ne
+        if ;; label = @3
+          i32.const 1
+          local.get $0
+          i32.load offset=24
+          local.get $1
+          local.get $0
+          i32.const 28
+          i32.add
+          i32.load
+          i32.load offset=16
+          call_indirect (type $1)
+          br_if 1 (;@2;)
+          drop
+        end
+        local.get $2
+        i32.eqz
+        br_if 1 (;@1;)
+        local.get $0
+        i32.load offset=24
+        local.get $2
+        i32.const 0
+        local.get $0
+        i32.const 28
+        i32.add
+        i32.load
+        i32.load offset=12
+        call_indirect (type $0)
+      end
+      return
+    end
+    i32.const 0
+  )
+  (func $10 (;10;) (type $3) (param $0 i32) (result i32)
+    (local $1 i32) (local $2 i32) (local $3 i32) (local $4 i32) (local $5 i32) (local $6 i32) (local $7 i32) (local $8 i32) (local $9 i32) (local $10 i32) (local $11 i32) (local $12 i32) (local $13 i32) (local $14 i32) (local $15 i32) (local $16 i32) (local $17 i32) (local $18 i32) (local $19 i32) (local $20 i32) (local $21 i32) (local $22 i32) (local $23 i32) (local $24 i32) (local $25 i32) (local $26 i32) (local $27 i32) (local $28 i32) (local $29 i32) (local $30 i32) (local $31 i32) (local $32 i32) (local $33 i32) (local $34 i32) (local $35 i32) (local $36 i32) (local $37 i32) (local $38 i32) (local $39 i32) (local $40 i32) (local $41 i32) (local $42 i32) (local $43 i32) (local $44 i32) (local $45 i32) (local $46 i32)
+    global.get $global$0
+    i32.const 256
+    i32.sub
+    local.tee $1
+    global.set $global$0
+    local.get $1
+    i64.const 4294967297
+    i64.store offset=56 align=4
+    local.get $1
+    i64.const 4294967297
+    i64.store offset=48 align=4
+    local.get $1
+    i64.const 4294967297
+    i64.store offset=40 align=4
+    local.get $1
+    i64.const 4294967297
+    i64.store offset=32 align=4
+    local.get $1
+    i64.const 4294967297
+    i64.store offset=24 align=4
+    local.get $1
+    i64.const 4294967297
+    i64.store offset=16 align=4
+    local.get $1
+    i64.const 4294967297
+    i64.store offset=8 align=4
+    local.get $1
+    i64.const 4294967297
+    i64.store align=4
+    block $label$1 ;; label = @1
+      local.get $0
+      i32.const 1
+      i32.add
+      local.tee $11
+      i32.const 2
+      i32.ge_u
+      if ;; label = @2
+        block ;; label = @3
+          local.get $1
+          local.set $3
+          i32.const 1
+          local.set $2
+          loop $label$3 ;; label = @4
+            local.get $2
+            i32.const 16
+            i32.ge_u
+            br_if 3 (;@1;)
+            local.get $3
+            i32.const 4
+            i32.add
+            local.tee $4
+            local.get $3
+            i32.load
+            local.get $2
+            i32.mul
+            i32.store
+            local.get $4
+            local.set $3
+            local.get $2
+            i32.const 1
+            i32.add
+            local.tee $4
+            local.set $2
+            local.get $4
+            local.get $11
+            i32.lt_u
+            br_if 0 (;@4;)
+          end
+        end
+      end
+      local.get $0
+      i32.const 16
+      i32.lt_u
+      if ;; label = @2
+        block ;; label = @3
+          i32.const 1
+          local.set $20
+          local.get $1
+          local.get $0
+          i32.const 2
+          i32.shl
+          i32.add
+          i32.load
+          local.tee $9
+          local.set $21
+          local.get $9
+          i32.const 24
+          i32.ge_u
+          if ;; label = @4
+            i32.const 24
+            i32.const 25
+            local.get $9
+            local.get $9
+            i32.const 24
+            i32.div_u
+            local.tee $21
+            i32.const 24
+            i32.mul
+            i32.eq
+            select
+            local.set $20
+          end
+          i32.const 0
+          local.get $0
+          i32.sub
+          local.set $40
+          local.get $1
+          i32.const 196
+          i32.add
+          local.set $12
+          local.get $1
+          i32.const 132
+          i32.add
+          local.set $41
+          local.get $1
+          i32.const 124
+          i32.add
+          local.set $42
+          local.get $1
+          i32.const 68
+          i32.add
+          local.set $11
+          local.get $0
+          i32.const 2
+          i32.lt_u
+          local.set $43
+          loop $label$6 ;; label = @4
+            local.get $1
+            i32.const 120
+            i32.add
+            i64.const 0
+            i64.store
+            local.get $1
+            i32.const 112
+            i32.add
+            i64.const 0
+            i64.store
+            local.get $1
+            i32.const 104
+            i32.add
+            i64.const 0
+            i64.store
+            local.get $1
+            i32.const 96
+            i32.add
+            i64.const 0
+            i64.store
+            local.get $1
+            i32.const 88
+            i32.add
+            i64.const 0
+            i64.store
+            local.get $1
+            i32.const 80
+            i32.add
+            i64.const 0
+            i64.store
+            local.get $1
+            i32.const 72
+            i32.add
+            i64.const 0
+            i64.store
+            local.get $1
+            i64.const 0
+            i64.store offset=64
+            local.get $1
+            i32.const 184
+            i32.add
+            local.tee $26
+            i64.const 0
+            i64.store
+            local.get $1
+            i32.const 176
+            i32.add
+            local.tee $27
+            i64.const 0
+            i64.store
+            local.get $1
+            i32.const 168
+            i32.add
+            local.tee $28
+            i64.const 0
+            i64.store
+            local.get $1
+            i32.const 160
+            i32.add
+            local.tee $29
+            i64.const 0
+            i64.store
+            local.get $1
+            i32.const 152
+            i32.add
+            local.tee $30
+            i64.const 0
+            i64.store
+            local.get $1
+            i32.const 144
+            i32.add
+            local.tee $31
+            i64.const 0
+            i64.store
+            local.get $1
+            i32.const 136
+            i32.add
+            local.tee $32
+            i64.const 0
+            i64.store
+            local.get $1
+            i64.const 0
+            i64.store offset=128
+            local.get $1
+            i32.const 248
+            i32.add
+            local.tee $33
+            i64.const 64424509454
+            i64.store align=4
+            local.get $1
+            i32.const 240
+            i32.add
+            local.tee $34
+            i64.const 55834574860
+            i64.store align=4
+            local.get $1
+            i32.const 232
+            i32.add
+            local.tee $35
+            i64.const 47244640266
+            i64.store align=4
+            local.get $1
+            i32.const 224
+            i32.add
+            local.tee $36
+            i64.const 38654705672
+            i64.store align=4
+            local.get $1
+            i32.const 216
+            i32.add
+            local.tee $37
+            i64.const 30064771078
+            i64.store align=4
+            local.get $1
+            i32.const 208
+            i32.add
+            local.tee $38
+            i64.const 21474836484
+            i64.store align=4
+            local.get $1
+            i32.const 200
+            i32.add
+            local.tee $39
+            i64.const 12884901890
+            i64.store align=4
+            local.get $1
+            i64.const 4294967296
+            i64.store offset=192 align=4
+            local.get $13
+            local.get $21
+            i32.mul
+            local.set $7
+            block $label$7 (result i32) ;; label = @5
+              block $label$8 ;; label = @6
+                local.get $43
+                i32.eqz
+                if ;; label = @7
+                  block ;; label = @8
+                    local.get $40
+                    local.set $23
+                    local.get $7
+                    local.set $14
+                    local.get $0
+                    local.set $15
+                    i32.const 0
+                    local.set $5
+                    br 2 (;@6;)
+                  end
+                end
+                i32.const 0
+                br 1 (;@5;)
+              end
+              i32.const 1
+            end
+            local.set $2
+            loop $label$10 ;; label = @5
+              block $label$11 ;; label = @6
+                block $label$12 ;; label = @7
+                  block $label$13 (result i32) ;; label = @8
+                    block $label$14 ;; label = @9
+                      block $label$15 ;; label = @10
+                        block $label$16 ;; label = @11
+                          block $label$17 ;; label = @12
+                            block $label$18 ;; label = @13
+                              block $label$19 ;; label = @14
+                                local.get $2
+                                i32.eqz
+                                if ;; label = @15
+                                  block ;; label = @16
+                                    local.get $13
+                                    i32.const 1
+                                    i32.add
+                                    local.set $13
+                                    local.get $9
+                                    local.get $7
+                                    local.get $21
+                                    i32.add
+                                    local.tee $3
+                                    local.get $3
+                                    local.get $9
+                                    i32.gt_u
+                                    select
+                                    i32.const -1
+                                    i32.add
+                                    local.set $44
+                                    i32.const 0
+                                    local.set $24
+                                    local.get $1
+                                    i32.load offset=192
+                                    local.tee $6
+                                    i32.const 1
+                                    i32.ge_s
+                                    br_if 2 (;@14;)
+                                    br 3 (;@13;)
+                                  end
+                                end
+                                block $label$21 ;; label = @15
+                                  block $label$22 ;; label = @16
+                                    block $label$23 ;; label = @17
+                                      block $label$24 ;; label = @18
+                                        block $label$25 ;; label = @19
+                                          block $label$26 ;; label = @20
+                                            block $label$27 ;; label = @21
+                                              block $label$28 ;; label = @22
+                                                block $label$29 ;; label = @23
+                                                  block $label$30 ;; label = @24
+                                                    block $label$31 ;; label = @25
+                                                      local.get $5
+                                                      br_table 0 (;@25;) 1 (;@24;) 2 (;@23;)
+                                                    end
+                                                    local.get $15
+                                                    i32.const -1
+                                                    i32.add
+                                                    local.tee $4
+                                                    i32.const 16
+                                                    i32.ge_u
+                                                    br_if 6 (;@18;)
+                                                    local.get $1
+                                                    local.get $4
+                                                    i32.const 2
+                                                    i32.shl
+                                                    local.tee $2
+                                                    i32.add
+                                                    i32.load
+                                                    local.tee $3
+                                                    i32.eqz
+                                                    br_if 7 (;@17;)
+                                                    local.get $14
+                                                    i32.const -2147483648
+                                                    i32.eq
+                                                    if ;; label = @25
+                                                      local.get $3
+                                                      i32.const -1
+                                                      i32.eq
+                                                      br_if 9 (;@16;)
+                                                    end
+                                                    local.get $1
+                                                    i32.const -64
+                                                    i32.sub
+                                                    local.get $2
+                                                    i32.add
+                                                    local.get $14
+                                                    local.get $3
+                                                    i32.div_s
+                                                    local.tee $16
+                                                    i32.store
+                                                    local.get $32
+                                                    local.get $39
+                                                    i64.load align=4
+                                                    i64.store
+                                                    local.get $31
+                                                    local.get $38
+                                                    i64.load align=4
+                                                    i64.store
+                                                    local.get $30
+                                                    local.get $37
+                                                    i64.load align=4
+                                                    i64.store
+                                                    local.get $29
+                                                    local.get $36
+                                                    i64.load align=4
+                                                    i64.store
+                                                    local.get $28
+                                                    local.get $35
+                                                    i64.load align=4
+                                                    i64.store
+                                                    local.get $27
+                                                    local.get $34
+                                                    i64.load align=4
+                                                    i64.store
+                                                    local.get $26
+                                                    local.get $33
+                                                    i64.load align=4
+                                                    i64.store
+                                                    local.get $1
+                                                    local.get $1
+                                                    i64.load offset=192 align=4
+                                                    i64.store offset=128
+                                                    local.get $16
+                                                    local.get $23
+                                                    i32.add
+                                                    local.set $45
+                                                    local.get $14
+                                                    local.get $3
+                                                    local.get $16
+                                                    i32.mul
+                                                    i32.sub
+                                                    local.set $14
+                                                    i32.const 0
+                                                    local.set $2
+                                                    local.get $1
+                                                    i32.const 192
+                                                    i32.add
+                                                    local.set $8
+                                                    loop $label$33 ;; label = @25
+                                                      block $label$34 ;; label = @26
+                                                        local.get $2
+                                                        local.get $16
+                                                        i32.add
+                                                        local.tee $3
+                                                        local.get $4
+                                                        i32.gt_u
+                                                        if ;; label = @27
+                                                          block ;; label = @28
+                                                            local.get $2
+                                                            local.get $45
+                                                            i32.add
+                                                            local.tee $46
+                                                            i32.const 15
+                                                            i32.gt_u
+                                                            br_if 7 (;@21;)
+                                                            local.get $3
+                                                            local.get $15
+                                                            i32.sub
+                                                            local.set $3
+                                                            local.get $2
+                                                            i32.const 15
+                                                            i32.le_u
+                                                            br_if 2 (;@26;)
+                                                            br 6 (;@22;)
+                                                          end
+                                                        end
+                                                        local.get $3
+                                                        i32.const 16
+                                                        i32.ge_u
+                                                        br_if 6 (;@20;)
+                                                        local.get $2
+                                                        i32.const 15
+                                                        i32.gt_u
+                                                        br_if 4 (;@22;)
+                                                      end
+                                                      local.get $8
+                                                      local.get $1
+                                                      i32.const 128
+                                                      i32.add
+                                                      local.get $3
+                                                      i32.const 2
+                                                      i32.shl
+                                                      i32.add
+                                                      i32.load
+                                                      i32.store
+                                                      local.get $8
+                                                      i32.const 4
+                                                      i32.add
+                                                      local.set $8
+                                                      local.get $2
+                                                      i32.const 1
+                                                      i32.add
+                                                      local.tee $2
+                                                      local.get $15
+                                                      i32.lt_u
+                                                      br_if 0 (;@25;)
+                                                    end
+                                                    local.get $23
+                                                    i32.const 1
+                                                    i32.add
+                                                    local.set $23
+                                                    local.get $4
+                                                    local.tee $15
+                                                    i32.const 1
+                                                    i32.gt_u
+                                                    br_if 9 (;@15;)
+                                                    i32.const 0
+                                                    local.set $2
+                                                    br 19 (;@5;)
+                                                  end
+                                                  local.get $26
+                                                  local.get $33
+                                                  i64.load align=4
+                                                  i64.store
+                                                  local.get $27
+                                                  local.get $34
+                                                  i64.load align=4
+                                                  i64.store
+                                                  local.get $28
+                                                  local.get $35
+                                                  i64.load align=4
+                                                  i64.store
+                                                  local.get $29
+                                                  local.get $36
+                                                  i64.load align=4
+                                                  i64.store
+                                                  local.get $30
+                                                  local.get $37
+                                                  i64.load align=4
+                                                  i64.store
+                                                  local.get $31
+                                                  local.get $38
+                                                  i64.load align=4
+                                                  i64.store
+                                                  local.get $32
+                                                  local.get $39
+                                                  i64.load align=4
+                                                  i64.store
+                                                  local.get $1
+                                                  local.get $1
+                                                  i64.load offset=192 align=4
+                                                  i64.store offset=128
+                                                  local.get $6
+                                                  i32.const 15
+                                                  i32.gt_u
+                                                  br_if 4 (;@19;)
+                                                  i32.const 1
+                                                  local.set $17
+                                                  local.get $6
+                                                  local.set $10
+                                                  i32.const 0
+                                                  br 15 (;@8;)
+                                                end
+                                                local.get $7
+                                                local.get $44
+                                                i32.lt_u
+                                                if ;; label = @23
+                                                  block ;; label = @24
+                                                    local.get $12
+                                                    i32.load
+                                                    local.set $25
+                                                    local.get $12
+                                                    local.get $6
+                                                    i32.store
+                                                    local.get $1
+                                                    local.get $25
+                                                    i32.store offset=192
+                                                    local.get $11
+                                                    local.set $18
+                                                    local.get $1
+                                                    i32.load offset=68
+                                                    local.tee $2
+                                                    i32.const 1
+                                                    i32.lt_s
+                                                    br_if 18 (;@6;)
+                                                    i32.const 1
+                                                    local.set $19
+                                                    br 15 (;@9;)
+                                                  end
+                                                end
+                                                local.get $22
+                                                local.get $24
+                                                i32.add
+                                                local.set $22
+                                                local.get $13
+                                                local.get $20
+                                                i32.lt_u
+                                                br_if 18 (;@4;)
+                                                local.get $1
+                                                i32.const 256
+                                                i32.add
+                                                global.set $global$0
+                                                local.get $22
+                                                return
+                                              end
+                                              i32.const 1049076
+                                              local.get $2
+                                              call $3
+                                              unreachable
+                                            end
+                                            i32.const 1049060
+                                            local.get $46
+                                            call $3
+                                            unreachable
+                                          end
+                                          i32.const 1049044
+                                          local.get $2
+                                          local.get $16
+                                          i32.add
+                                          call $3
+                                          unreachable
+                                        end
+                                        local.get $6
+                                        local.set $10
+                                        br 11 (;@7;)
+                                      end
+                                      i32.const 1048980
+                                      local.get $4
+                                      call $3
+                                      unreachable
+                                    end
+                                    i32.const 1048996
+                                    call $2
+                                    unreachable
+                                  end
+                                  i32.const 1049020
+                                  call $2
+                                  unreachable
+                                end
+                                i32.const 0
+                                local.set $5
+                                br 2 (;@12;)
+                              end
+                              i32.const 1
+                              local.set $5
+                              br 2 (;@11;)
+                            end
+                            i32.const 2
+                            local.set $5
+                            br 2 (;@10;)
+                          end
+                          i32.const 1
+                          local.set $2
+                          br 6 (;@5;)
+                        end
+                        i32.const 1
+                        local.set $2
+                        br 5 (;@5;)
+                      end
+                      i32.const 1
+                      local.set $2
+                      br 4 (;@5;)
+                    end
+                    i32.const 1
+                  end
+                  local.set $2
+                  loop $label$37 ;; label = @8
+                    block $label$38 ;; label = @9
+                      block $label$39 ;; label = @10
+                        local.get $2
+                        i32.eqz
+                        if ;; label = @11
+                          block ;; label = @12
+                            local.get $10
+                            local.tee $3
+                            i32.const 2
+                            i32.shl
+                            local.tee $4
+                            local.get $1
+                            i32.const 128
+                            i32.add
+                            i32.add
+                            local.tee $5
+                            i32.load
+                            local.tee $10
+                            if ;; label = @13
+                              block ;; label = @14
+                                local.get $5
+                                local.get $3
+                                i32.store
+                                block $label$42 ;; label = @15
+                                  local.get $3
+                                  i32.const 3
+                                  i32.lt_u
+                                  br_if 0 (;@15;)
+                                  local.get $3
+                                  i32.const -1
+                                  i32.add
+                                  i32.const 1
+                                  i32.shr_u
+                                  local.tee $8
+                                  i32.eqz
+                                  br_if 0 (;@15;)
+                                  local.get $4
+                                  local.get $42
+                                  i32.add
+                                  local.set $2
+                                  local.get $41
+                                  local.set $3
+                                  loop $label$43 ;; label = @16
+                                    local.get $3
+                                    i32.load
+                                    local.set $4
+                                    local.get $3
+                                    local.get $2
+                                    i32.load
+                                    i32.store
+                                    local.get $2
+                                    local.get $4
+                                    i32.store
+                                    local.get $3
+                                    i32.const 4
+                                    i32.add
+                                    local.set $3
+                                    local.get $2
+                                    i32.const -4
+                                    i32.add
+                                    local.set $2
+                                    local.get $8
+                                    i32.const -1
+                                    i32.add
+                                    local.tee $8
+                                    br_if 0 (;@16;)
+                                  end
+                                end
+                                local.get $17
+                                i32.const 1
+                                i32.add
+                                local.set $17
+                                local.get $10
+                                i32.const 16
+                                i32.lt_u
+                                br_if 5 (;@9;)
+                                br 7 (;@7;)
+                              end
+                            end
+                            i32.const 0
+                            local.get $17
+                            i32.sub
+                            local.get $17
+                            local.get $7
+                            i32.const 1
+                            i32.and
+                            select
+                            local.get $24
+                            i32.add
+                            local.set $24
+                            i32.const 2
+                            local.set $5
+                            br 2 (;@10;)
+                          end
+                        end
+                        i32.const 0
+                        local.set $2
+                        local.get $18
+                        i32.const 0
+                        i32.store
+                        local.get $1
+                        local.get $6
+                        local.tee $4
+                        i32.store offset=192
+                        local.get $19
+                        i32.const 1
+                        i32.add
+                        local.set $5
+                        local.get $12
+                        local.set $3
+                        block $label$44 ;; label = @11
+                          block $label$45 ;; label = @12
+                            loop $label$46 ;; label = @13
+                              local.get $2
+                              i32.const 2
+                              i32.add
+                              i32.const 16
+                              i32.ge_u
+                              br_if 1 (;@12;)
+                              local.get $3
+                              local.get $3
+                              i32.const 4
+                              i32.add
+                              local.tee $3
+                              i32.load
+                              i32.store
+                              local.get $2
+                              i32.const 1
+                              i32.add
+                              local.tee $2
+                              local.get $19
+                              i32.lt_u
+                              br_if 0 (;@13;)
+                            end
+                            local.get $5
+                            i32.const 16
+                            i32.ge_u
+                            br_if 1 (;@11;)
+                            local.get $5
+                            i32.const 2
+                            i32.shl
+                            local.tee $3
+                            local.get $1
+                            i32.const 192
+                            i32.add
+                            i32.add
+                            local.get $25
+                            i32.store
+                            local.get $1
+                            i32.const -64
+                            i32.sub
+                            local.get $3
+                            i32.add
+                            local.tee $18
+                            i32.load
+                            local.tee $2
+                            local.get $19
+                            i32.le_s
+                            br_if 6 (;@6;)
+                            local.get $12
+                            i32.load
+                            local.set $6
+                            local.get $5
+                            local.set $19
+                            local.get $4
+                            local.set $25
+                            i32.const 1
+                            local.set $2
+                            br 4 (;@8;)
+                          end
+                          i32.const 1049108
+                          local.get $2
+                          i32.const 2
+                          i32.add
+                          call $3
+                          unreachable
+                        end
+                        i32.const 1049124
+                        local.get $5
+                        call $3
+                        unreachable
+                      end
+                      i32.const 1
+                      local.set $2
+                      br 4 (;@5;)
+                    end
+                    i32.const 0
+                    local.set $2
+                    br 0 (;@8;)
+                  end
+                end
+                i32.const 1049092
+                local.get $10
+                call $3
+                unreachable
+              end
+              local.get $7
+              i32.const 1
+              i32.add
+              local.set $7
+              local.get $18
+              local.get $2
+              i32.const 1
+              i32.add
+              i32.store
+              block $label$47 ;; label = @6
+                block $label$48 ;; label = @7
+                  local.get $1
+                  i32.load offset=192
+                  local.tee $6
+                  i32.const 1
+                  i32.ge_s
+                  if ;; label = @8
+                    block ;; label = @9
+                      i32.const 1
+                      local.set $5
+                      br 2 (;@7;)
+                    end
+                  end
+                  i32.const 2
+                  local.set $5
+                  br 1 (;@6;)
+                end
+                i32.const 1
+                local.set $2
+                br 1 (;@5;)
+              end
+              i32.const 1
+              local.set $2
+              br 0 (;@5;)
+            end
+          end
+        end
+      end
+      i32.const 1049212
+      local.get $0
+      call $3
+      unreachable
+    end
+    i32.const 1049196
+    local.get $2
+    call $3
+    unreachable
+  )
+  (table $0 (;0;) 4 4 funcref)
+  (memory $0 (;0;) 17)
+  (global $global$0 (;0;) (mut i32) i32.const 1048576)
+  (global $global$1 (;1;) i32 i32.const 1049244)
+  (global $global$2 (;2;) i32 i32.const 1049244)
+  (export "memory" (memory $0))
+  (export "__heap_base" (global $global$1))
+  (export "__data_end" (global $global$2))
+  (export "run_fannkuch" (func $10))
+  (elem (;0;) (i32.const 1) func $4 $7 $8)
+  (data (;0;) (i32.const 1048576) "src/lib.rs\00\00\00\00\00\00attempt to divide by zero\00\00\00\00\00\00\00attempt to divide with overflow\00index out of bounds: the len is  but the index is 00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899called `Option::unwrap()` on a `None` valuesrc/libcore/option.rssrc/lib.rs")
+  (data (;1;) (i32.const 1048982) "\10\00\0a\00\00\00%\00\00\00\1d\00\00\00\10\00\10\00\19\00\00\00\00\00\10\00\0a\00\00\00&\00\00\00\15\00\00\000\00\10\00\1f\00\00\00\00\00\10\00\0a\00\00\00&\00\00\00\15\00\00\00\00\00\10\00\0a\00\00\00.\00\00\00\15\00\00\00\00\00\10\00\0a\00\00\000\00\00\00\15\00\00\00\00\00\10\00\0a\00\00\00-\00\00\00\11\00\00\00\00\00\10\00\0a\00\00\00E\00\00\00\17\00\00\00\00\00\10\00\0a\00\00\00q\00\00\00\22\00\00\00\00\00\10\00\0a\00\00\00s\00\00\00\11\00\00\00P\00\10\00 \00\00\00p\00\10\00\12\00\00\00\02\00\00\00\00\00\00\00\01\00\00\00\03\00\00\00J\01\10\00+\00\00\00u\01\10\00\15\00\00\00Y\01\00\00\15\00\00\00\8a\01\10\00\0a\00\00\00\08\00\00\00\09\00\00\00\8a\01\10\00\0a\00\00\00\0a\00\00\00\14")
+)
diff --git a/tests/misc_testsuite/simd/canonicalize-nan.wast b/tests/misc_testsuite/simd/canonicalize-nan.wast
index 1e43ce25163b..8a0ae71d92ca 100644
--- a/tests/misc_testsuite/simd/canonicalize-nan.wast
+++ b/tests/misc_testsuite/simd/canonicalize-nan.wast
@@ -33,6 +33,38 @@
   (func (export "f64x2.ceil") (param v128) (result v128)
     local.get 0
     f64x2.ceil)
+
+  (func (export "reinterpret-and-demote") (param i64) (result i32)
+    local.get 0
+    f64.reinterpret_i64
+    f32.demote_f64
+    i32.reinterpret_f32)
+
+  (func (export "reinterpret-and-promote") (param i32) (result i64)
+    local.get 0
+    f32.reinterpret_i32
+    f64.promote_f32
+    i64.reinterpret_f64)
+
+  (func (export "copysign-and-demote") (param f64) (result f32)
+    local.get 0
+    f64.const -0x1
+    f64.copysign
+    f32.demote_f64)
+
+  (func (export "copysign-and-promote") (param f32) (result f64)
+    local.get 0
+    f32.const -0x1
+    f32.copysign
+    f64.promote_f32)
+
+  (func (export "f32x4.demote_f64x2_zero") (param v128) (result v128)
+    local.get 0
+    f32x4.demote_f64x2_zero)
+
+  (func (export "f64x2.promote_low_f32x4") (param v128) (result v128)
+    local.get 0
+    f64x2.promote_low_f32x4)
 )
 
 (assert_return (invoke "f32x4.floor" (v128.const f32x4 1 -2.2 3.4 nan))
@@ -56,3 +88,20 @@
                (v128.const f64x2 3 nan))
 (assert_return (invoke "f64x2.ceil" (v128.const f64x2 3.4 nan))
                (v128.const f64x2 4 nan))
+
+(assert_return (invoke "reinterpret-and-demote" (i64.const 0xfffefdfccccdcecf))
+               (i32.const 0x7fc00000))
+(assert_return (invoke "reinterpret-and-promote" (i32.const 0xfffefdfc))
+               (i64.const 0x7ff8000000000000))
+(assert_return (invoke "copysign-and-demote" (f64.const nan))
+               (f32.const nan:0x7fc00000))
+(assert_return (invoke "copysign-and-promote" (f32.const nan))
+               (f64.const nan:0x7ff8000000000000))
+
+(assert_return (invoke "f32x4.demote_f64x2_zero"
+               (v128.const i64x2 0xfffefdfccccdcecf 0xfffefdfccccdcecf))
+               (v128.const f32x4 nan:0x7fc00000 nan:0x7fc00000 0 0))
+
+(assert_return (invoke "f64x2.promote_low_f32x4"
+               (v128.const i32x4 0xfffefdfc 0xfffefdfc 0 0))
+               (v128.const f64x2 nan:0x7ff8000000000000 nan:0x7ff8000000000000))
diff --git a/tests/misc_testsuite/simd/issue_3327_bnot_lowering.wast b/tests/misc_testsuite/simd/issue_3327_bnot_lowering.wast
index 4563afe89f88..93faaf6df8c4 100644
--- a/tests/misc_testsuite/simd/issue_3327_bnot_lowering.wast
+++ b/tests/misc_testsuite/simd/issue_3327_bnot_lowering.wast
@@ -26,7 +26,10 @@
     v128.not
     i64x2.bitmask)
   (export "" (func 0)))
-(assert_return (invoke "") (i32.const 0))
+;; the f64x2.promote_low_f32x4 operation may or may not preserve the sign bit
+;; on the NaN in the first operation. This leads to one of two results depending
+;; on how platforms propagate NaN bits.
+(assert_return (invoke "") (either (i32.const 0) (i32.const 1)))
 
 ;; from #3327
 (module
diff --git a/tests/misc_testsuite/sink-float-but-dont-trap.wast b/tests/misc_testsuite/sink-float-but-dont-trap.wast
new file mode 100644
index 000000000000..395243fcc62e
--- /dev/null
+++ b/tests/misc_testsuite/sink-float-but-dont-trap.wast
@@ -0,0 +1,51 @@
+(module
+  (memory 1)
+
+  ;; make sure that the sunk load here doesn't try to load past the end of
+  ;; memory.
+  (func (export "select-with-sink") (param i32) (result f64)
+    local.get 0
+    f64.load
+    f64.const 1
+    local.get 0
+    select
+    return)
+
+  ;; same as above but with a slightly different codegen pattern.
+  (func (export "select-with-fcmp-and-sink") (param i32 f64 f64) (result f64)
+    local.get 0
+    f64.load
+    f64.const 1
+    local.get 1
+    local.get 2
+    f64.ne
+    select
+    return)
+
+  ;; Same as the above two but the order of operands to the `select` are
+  ;; swapped.
+  (func (export "select-with-sink-other-way") (param i32) (result f64)
+    f64.const 1
+    local.get 0
+    f64.load
+    local.get 0
+    select
+    return)
+  (func (export "select-with-fcmp-and-sink-other-way") (param i32 f64 f64) (result f64)
+    f64.const 1
+    local.get 0
+    f64.load
+    local.get 1
+    local.get 2
+    f64.ne
+    select
+    return)
+)
+
+(assert_return (invoke "select-with-sink" (i32.const 0xfff8)) (f64.const 0))
+(assert_return (invoke "select-with-fcmp-and-sink" (i32.const 0xfff8) (f64.const 0) (f64.const 0)) (f64.const 1))
+
+(assert_trap (invoke "select-with-sink" (i32.const 0xfff9)) "out of bounds")
+(assert_trap (invoke "select-with-fcmp-and-sink" (i32.const 0xfff9) (f64.const 0) (f64.const 0)) "out of bounds")
+(assert_trap (invoke "select-with-sink-other-way" (i32.const 0xfff9)) "out of bounds")
+(assert_trap (invoke "select-with-fcmp-and-sink-other-way" (i32.const 0xfff9) (f64.const 0) (f64.const 0)) "out of bounds")
diff --git a/tests/misc_testsuite/threads/LB.wast b/tests/misc_testsuite/threads/LB.wast
new file mode 100644
index 000000000000..b92eb4488030
--- /dev/null
+++ b/tests/misc_testsuite/threads/LB.wast
@@ -0,0 +1,62 @@
+(module $Mem
+  (memory (export "shared") 1 1 shared)
+)
+
+(thread $T1 (shared (module $Mem))
+  (register "mem" $Mem)
+  (module
+    (memory (import "mem" "shared") 1 10 shared)
+    (func (export "run")
+      (local i32)
+      (i32.load (i32.const 4))
+      (local.set 0)
+      (i32.store (i32.const 0) (i32.const 1))
+
+      ;; store results for checking
+      (i32.store (i32.const 24) (local.get 0))
+    )
+  )
+  (invoke "run")
+)
+
+(thread $T2 (shared (module $Mem))
+  (register "mem" $Mem)
+  (module
+    (memory (import "mem" "shared") 1 1 shared)
+    (func (export "run")
+      (local i32)
+      (i32.load (i32.const 0))
+      (local.set 0)
+      (i32.store (i32.const 4) (i32.const 1))
+
+      ;; store results for checking
+      (i32.store (i32.const 32) (local.get 0))
+    )
+  )
+
+  (invoke "run")
+)
+
+(wait $T1)
+(wait $T2)
+
+(module $Check
+  (memory (import "Mem" "shared") 1 1 shared)
+
+  (func (export "check") (result i32)
+    (local i32 i32)
+    (i32.load (i32.const 24))
+    (local.set 0)
+    (i32.load (i32.const 32))
+    (local.set 1)
+
+    ;; allowed results: (L_0 = 0 || L_0 = 1) && (L_1 = 0 || L_1 = 1)
+
+    (i32.or (i32.eq (local.get 0) (i32.const 1)) (i32.eq (local.get 0) (i32.const 0)))
+    (i32.or (i32.eq (local.get 1) (i32.const 1)) (i32.eq (local.get 1) (i32.const 0)))
+    (i32.and)
+    (return)
+  )
+)
+
+(assert_return (invoke $Check "check") (i32.const 1))
diff --git a/tests/misc_testsuite/threads/LB_atomic.wast b/tests/misc_testsuite/threads/LB_atomic.wast
new file mode 100644
index 000000000000..c13f948a12be
--- /dev/null
+++ b/tests/misc_testsuite/threads/LB_atomic.wast
@@ -0,0 +1,64 @@
+(module $Mem
+  (memory (export "shared") 1 1 shared)
+)
+
+(thread $T1 (shared (module $Mem))
+  (register "mem" $Mem)
+  (module
+    (memory (import "mem" "shared") 1 10 shared)
+    (func (export "run")
+      (local i32)
+      (i32.atomic.load (i32.const 4))
+      (local.set 0)
+      (i32.atomic.store (i32.const 0) (i32.const 1))
+
+      ;; store results for checking
+      (i32.store (i32.const 24) (local.get 0))
+    )
+  )
+  (invoke "run")
+)
+
+(thread $T2 (shared (module $Mem))
+  (register "mem" $Mem)
+  (module
+    (memory (import "mem" "shared") 1 1 shared)
+    (func (export "run")
+      (local i32)
+      (i32.atomic.load (i32.const 0))
+      (local.set 0)
+      (i32.atomic.store (i32.const 4) (i32.const 1))
+
+      ;; store results for checking
+      (i32.store (i32.const 32) (local.get 0))
+    )
+  )
+
+  (invoke "run")
+)
+
+(wait $T1)
+(wait $T2)
+
+(module $Check
+  (memory (import "Mem" "shared") 1 1 shared)
+
+  (func (export "check") (result i32)
+    (local i32 i32)
+    (i32.load (i32.const 24))
+    (local.set 0)
+    (i32.load (i32.const 32))
+    (local.set 1)
+
+    ;; allowed results: (L_0 = 0 && L_1 = 0) || (L_0 = 0 && L_1 = 1) || (L_0 = 1 && L_1 = 0)
+
+    (i32.and (i32.eq (local.get 0) (i32.const 0)) (i32.eq (local.get 1) (i32.const 0)))
+    (i32.and (i32.eq (local.get 0) (i32.const 0)) (i32.eq (local.get 1) (i32.const 1)))
+    (i32.and (i32.eq (local.get 0) (i32.const 1)) (i32.eq (local.get 1) (i32.const 0)))
+    (i32.or)
+    (i32.or)
+    (return)
+  )
+)
+
+(assert_return (invoke $Check "check") (i32.const 1))
diff --git a/tests/misc_testsuite/threads/MP.wast b/tests/misc_testsuite/threads/MP.wast
new file mode 100644
index 000000000000..8ae62a4c2597
--- /dev/null
+++ b/tests/misc_testsuite/threads/MP.wast
@@ -0,0 +1,59 @@
+(module $Mem
+  (memory (export "shared") 1 1 shared)
+)
+
+(thread $T1 (shared (module $Mem))
+  (register "mem" $Mem)
+  (module
+    (memory (import "mem" "shared") 1 10 shared)
+    (func (export "run")
+      (i32.store (i32.const 0) (i32.const 42))
+      (i32.store (i32.const 4) (i32.const 1))
+    )
+  )
+  (invoke "run")
+)
+
+(thread $T2 (shared (module $Mem))
+  (register "mem" $Mem)
+  (module
+    (memory (import "mem" "shared") 1 1 shared)
+    (func (export "run")
+      (local i32 i32)
+      (i32.load (i32.const 4))
+      (local.set 0)
+      (i32.load (i32.const 0))
+      (local.set 1)
+
+      ;; store results for checking
+      (i32.store (i32.const 24) (local.get 0))
+      (i32.store (i32.const 32) (local.get 1))
+    )
+  )
+
+  (invoke "run")
+)
+
+(wait $T1)
+(wait $T2)
+
+(module $Check
+  (memory (import "Mem" "shared") 1 1 shared)
+
+  (func (export "check") (result i32)
+    (local i32 i32)
+    (i32.load (i32.const 24))
+    (local.set 0)
+    (i32.load (i32.const 32))
+    (local.set 1)
+
+    ;; allowed results: (L_0 = 0 || L_0 = 1) && (L_1 = 0 || L_1 = 42)
+
+    (i32.or (i32.eq (local.get 0) (i32.const 1)) (i32.eq (local.get 0) (i32.const 0)))
+    (i32.or (i32.eq (local.get 1) (i32.const 42)) (i32.eq (local.get 1) (i32.const 0)))
+    (i32.and)
+    (return)
+  )
+)
+
+(assert_return (invoke $Check "check") (i32.const 1))
diff --git a/tests/misc_testsuite/threads/MP_atomic.wast b/tests/misc_testsuite/threads/MP_atomic.wast
new file mode 100644
index 000000000000..1af863441b91
--- /dev/null
+++ b/tests/misc_testsuite/threads/MP_atomic.wast
@@ -0,0 +1,61 @@
+(module $Mem
+  (memory (export "shared") 1 1 shared)
+)
+
+(thread $T1 (shared (module $Mem))
+  (register "mem" $Mem)
+  (module
+    (memory (import "mem" "shared") 1 10 shared)
+    (func (export "run")
+      (i32.atomic.store (i32.const 0) (i32.const 42))
+      (i32.atomic.store (i32.const 4) (i32.const 1))
+    )
+  )
+  (invoke "run")
+)
+
+(thread $T2 (shared (module $Mem))
+  (register "mem" $Mem)
+  (module
+    (memory (import "mem" "shared") 1 1 shared)
+    (func (export "run")
+      (local i32 i32)
+      (i32.atomic.load (i32.const 4))
+      (local.set 0)
+      (i32.atomic.load (i32.const 0))
+      (local.set 1)
+
+      ;; store results for checking
+      (i32.store (i32.const 24) (local.get 0))
+      (i32.store (i32.const 32) (local.get 1))
+    )
+  )
+
+  (invoke "run")
+)
+
+(wait $T1)
+(wait $T2)
+
+(module $Check
+  (memory (import "Mem" "shared") 1 1 shared)
+
+  (func (export "check") (result i32)
+    (local i32 i32)
+    (i32.load (i32.const 24))
+    (local.set 0)
+    (i32.load (i32.const 32))
+    (local.set 1)
+
+    ;; allowed results: (L_0 = 1 && L_1 = 42) || (L_0 = 0 && L_1 = 0) || (L_0 = 0 && L_1 = 42)
+
+    (i32.and (i32.eq (local.get 0) (i32.const 1)) (i32.eq (local.get 1) (i32.const 42)))
+    (i32.and (i32.eq (local.get 0) (i32.const 0)) (i32.eq (local.get 1) (i32.const 0)))
+    (i32.and (i32.eq (local.get 0) (i32.const 0)) (i32.eq (local.get 1) (i32.const 42)))
+    (i32.or)
+    (i32.or)
+    (return)
+  )
+)
+
+(assert_return (invoke $Check "check") (i32.const 1))
diff --git a/tests/misc_testsuite/threads/MP_wait.wast b/tests/misc_testsuite/threads/MP_wait.wast
new file mode 100644
index 000000000000..1af863441b91
--- /dev/null
+++ b/tests/misc_testsuite/threads/MP_wait.wast
@@ -0,0 +1,61 @@
+(module $Mem
+  (memory (export "shared") 1 1 shared)
+)
+
+(thread $T1 (shared (module $Mem))
+  (register "mem" $Mem)
+  (module
+    (memory (import "mem" "shared") 1 10 shared)
+    (func (export "run")
+      (i32.atomic.store (i32.const 0) (i32.const 42))
+      (i32.atomic.store (i32.const 4) (i32.const 1))
+    )
+  )
+  (invoke "run")
+)
+
+(thread $T2 (shared (module $Mem))
+  (register "mem" $Mem)
+  (module
+    (memory (import "mem" "shared") 1 1 shared)
+    (func (export "run")
+      (local i32 i32)
+      (i32.atomic.load (i32.const 4))
+      (local.set 0)
+      (i32.atomic.load (i32.const 0))
+      (local.set 1)
+
+      ;; store results for checking
+      (i32.store (i32.const 24) (local.get 0))
+      (i32.store (i32.const 32) (local.get 1))
+    )
+  )
+
+  (invoke "run")
+)
+
+(wait $T1)
+(wait $T2)
+
+(module $Check
+  (memory (import "Mem" "shared") 1 1 shared)
+
+  (func (export "check") (result i32)
+    (local i32 i32)
+    (i32.load (i32.const 24))
+    (local.set 0)
+    (i32.load (i32.const 32))
+    (local.set 1)
+
+    ;; allowed results: (L_0 = 1 && L_1 = 42) || (L_0 = 0 && L_1 = 0) || (L_0 = 0 && L_1 = 42)
+
+    (i32.and (i32.eq (local.get 0) (i32.const 1)) (i32.eq (local.get 1) (i32.const 42)))
+    (i32.and (i32.eq (local.get 0) (i32.const 0)) (i32.eq (local.get 1) (i32.const 0)))
+    (i32.and (i32.eq (local.get 0) (i32.const 0)) (i32.eq (local.get 1) (i32.const 42)))
+    (i32.or)
+    (i32.or)
+    (return)
+  )
+)
+
+(assert_return (invoke $Check "check") (i32.const 1))
diff --git a/tests/misc_testsuite/threads/SB.wast b/tests/misc_testsuite/threads/SB.wast
new file mode 100644
index 000000000000..f94abab035d8
--- /dev/null
+++ b/tests/misc_testsuite/threads/SB.wast
@@ -0,0 +1,62 @@
+(module $Mem
+  (memory (export "shared") 1 1 shared)
+)
+
+(thread $T1 (shared (module $Mem))
+  (register "mem" $Mem)
+  (module
+    (memory (import "mem" "shared") 1 10 shared)
+    (func (export "run")
+      (local i32)
+      (i32.store (i32.const 0) (i32.const 1))
+      (i32.load (i32.const 4))
+      (local.set 0)
+
+      ;; store results for checking
+      (i32.store (i32.const 24) (local.get 0))
+    )
+  )
+  (invoke "run")
+)
+
+(thread $T2 (shared (module $Mem))
+  (register "mem" $Mem)
+  (module
+    (memory (import "mem" "shared") 1 1 shared)
+    (func (export "run")
+      (local i32)
+      (i32.store (i32.const 4) (i32.const 1))
+      (i32.load (i32.const 0))
+      (local.set 0)
+
+      ;; store results for checking
+      (i32.store (i32.const 32) (local.get 0))
+    )
+  )
+
+  (invoke "run")
+)
+
+(wait $T1)
+(wait $T2)
+
+(module $Check
+  (memory (import "Mem" "shared") 1 1 shared)
+
+  (func (export "check") (result i32)
+    (local i32 i32)
+    (i32.load (i32.const 24))
+    (local.set 0)
+    (i32.load (i32.const 32))
+    (local.set 1)
+
+    ;; allowed results: (L_0 = 0 || L_0 = 1) && (L_1 = 0 || L_1 = 1)
+
+    (i32.or (i32.eq (local.get 0) (i32.const 1)) (i32.eq (local.get 0) (i32.const 0)))
+    (i32.or (i32.eq (local.get 1) (i32.const 1)) (i32.eq (local.get 1) (i32.const 0)))
+    (i32.and)
+    (return)
+  )
+)
+
+(assert_return (invoke $Check "check") (i32.const 1))
diff --git a/tests/misc_testsuite/threads/SB_atomic.wast b/tests/misc_testsuite/threads/SB_atomic.wast
new file mode 100644
index 000000000000..3cedaed55db5
--- /dev/null
+++ b/tests/misc_testsuite/threads/SB_atomic.wast
@@ -0,0 +1,64 @@
+(module $Mem
+  (memory (export "shared") 1 1 shared)
+)
+
+(thread $T1 (shared (module $Mem))
+  (register "mem" $Mem)
+  (module
+    (memory (import "mem" "shared") 1 10 shared)
+    (func (export "run")
+      (local i32)
+      (i32.atomic.store (i32.const 0) (i32.const 1))
+      (i32.atomic.load (i32.const 4))
+      (local.set 0)
+
+      ;; store results for checking
+      (i32.store (i32.const 24) (local.get 0))
+    )
+  )
+  (invoke "run")
+)
+
+(thread $T2 (shared (module $Mem))
+  (register "mem" $Mem)
+  (module
+    (memory (import "mem" "shared") 1 1 shared)
+    (func (export "run")
+      (local i32)
+      (i32.atomic.store (i32.const 4) (i32.const 1))
+      (i32.atomic.load (i32.const 0))
+      (local.set 0)
+
+      ;; store results for checking
+      (i32.store (i32.const 32) (local.get 0))
+    )
+  )
+
+  (invoke "run")
+)
+
+(wait $T1)
+(wait $T2)
+
+(module $Check
+  (memory (import "Mem" "shared") 1 1 shared)
+
+  (func (export "check") (result i32)
+    (local i32 i32)
+    (i32.load (i32.const 24))
+    (local.set 0)
+    (i32.load (i32.const 32))
+    (local.set 1)
+
+    ;; allowed results: (L_0 = 1 && L_1 = 1) || (L_0 = 0 && L_1 = 1) || (L_0 = 1 && L_1 = 0)
+
+    (i32.and (i32.eq (local.get 0) (i32.const 1)) (i32.eq (local.get 1) (i32.const 1)))
+    (i32.and (i32.eq (local.get 0) (i32.const 0)) (i32.eq (local.get 1) (i32.const 1)))
+    (i32.and (i32.eq (local.get 0) (i32.const 1)) (i32.eq (local.get 1) (i32.const 0)))
+    (i32.or)
+    (i32.or)
+    (return)
+  )
+)
+
+(assert_return (invoke $Check "check") (i32.const 1))
diff --git a/tests/misc_testsuite/threads/wait_notify.wast b/tests/misc_testsuite/threads/wait_notify.wast
new file mode 100644
index 000000000000..270509a92dae
--- /dev/null
+++ b/tests/misc_testsuite/threads/wait_notify.wast
@@ -0,0 +1,41 @@
+;; test that looping notify eventually unblocks a parallel waiting thread
+(module $Mem
+  (memory (export "shared") 1 1 shared)
+)
+
+(thread $T1 (shared (module $Mem))
+  (register "mem" $Mem)
+  (module
+    (memory (import "mem" "shared") 1 10 shared)
+    (func (export "run") (result i32)
+      (memory.atomic.wait32 (i32.const 0) (i32.const 0) (i64.const -1))
+    )
+  )
+  ;; test that this thread eventually gets unblocked
+  (assert_return (invoke "run") (i32.const 0))
+)
+
+(thread $T2 (shared (module $Mem))
+  (register "mem" $Mem)
+  (module
+    (memory (import "mem" "shared") 1 1 shared)
+    (func (export "notify-0") (result i32)
+      (memory.atomic.notify (i32.const 0) (i32.const 0))
+    )
+    (func (export "notify-1-while")
+      (loop
+        (i32.const 1)
+        (memory.atomic.notify (i32.const 0) (i32.const 1))
+        (i32.ne)
+        (br_if 0)
+      )
+    )
+  )
+  ;; notifying with a count of 0 will not unblock
+  (assert_return (invoke "notify-0") (i32.const 0))
+  ;; loop until something is notified
+  (assert_return (invoke "notify-1-while"))
+)
+
+(wait $T1)
+(wait $T2)
diff --git a/tests/misc_testsuite/winch/_simd_address.wast b/tests/misc_testsuite/winch/_simd_address.wast
new file mode 100644
index 000000000000..9e023008bba1
--- /dev/null
+++ b/tests/misc_testsuite/winch/_simd_address.wast
@@ -0,0 +1,157 @@
+;; Load/Store v128 data with different valid offset/alignment
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\10\11\12\13\14\15")
+  (data (offset (i32.const 65505)) "\16\17\18\19\20\21\22\23\24\25\26\27\28\29\30\31")
+
+  (func (export "load_data_1") (param $i i32) (result v128)
+    (v128.load offset=0 (local.get $i))                   ;; 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15
+  )
+  (func (export "load_data_2") (param $i i32) (result v128)
+    (v128.load align=1 (local.get $i))                    ;; 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15
+  )
+  (func (export "load_data_3") (param $i i32) (result v128)
+    (v128.load offset=1 align=1 (local.get $i))           ;; 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15 0x00
+  )
+  (func (export "load_data_4") (param $i i32) (result v128)
+    (v128.load offset=2 align=1 (local.get $i))           ;; 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15 0x00 0x00
+  )
+  (func (export "load_data_5") (param $i i32) (result v128)
+    (v128.load offset=15 align=1 (local.get $i))          ;; 0x15 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
+  )
+
+  (func (export "store_data_0") (result v128)
+    (v128.store offset=0 (i32.const 0) (v128.const f32x4 0 1 2 3))
+    (v128.load offset=0 (i32.const 0))
+  )
+  (func (export "store_data_1") (result v128)
+    (v128.store align=1 (i32.const 0) (v128.const i32x4 0 1 2 3))
+    (v128.load align=1 (i32.const 0))
+  )
+  (func (export "store_data_2") (result v128)
+    (v128.store offset=1 align=1 (i32.const 0) (v128.const i16x8 0 1 2 3 4 5 6 7))
+    (v128.load offset=1 align=1 (i32.const 0))
+  )
+  (func (export "store_data_3") (result v128)
+    (v128.store offset=2 align=1 (i32.const 0) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+    (v128.load offset=2 align=1 (i32.const 0))
+  )
+  (func (export "store_data_4") (result v128)
+    (v128.store offset=15 align=1 (i32.const 0) (v128.const i32x4 0 1 2 3))
+    (v128.load offset=15 (i32.const 0))
+  )
+  (func (export "store_data_5") (result v128)
+    (v128.store offset=65520 align=1 (i32.const 0) (v128.const i32x4 0 1 2 3))
+    (v128.load offset=65520 (i32.const 0))
+  )
+  (func (export "store_data_6") (param $i i32)
+    (v128.store offset=1 align=1 (local.get $i) (v128.const i32x4 0 1 2 3))
+  )
+)
+
+(assert_return (invoke "load_data_1" (i32.const 0)) (v128.const i32x4 0x03020100 0x07060504 0x11100908 0x15141312))
+(assert_return (invoke "load_data_2" (i32.const 0)) (v128.const i32x4 0x03020100 0x07060504 0x11100908 0x15141312))
+(assert_return (invoke "load_data_3" (i32.const 0)) (v128.const i32x4 0x04030201 0x08070605 0x12111009 0x00151413))
+(assert_return (invoke "load_data_4" (i32.const 0)) (v128.const i32x4 0x05040302 0x09080706 0x13121110 0x00001514))
+(assert_return (invoke "load_data_5" (i32.const 0)) (v128.const i32x4 0x00000015 0x00000000 0x00000000 0x00000000))
+
+(assert_return (invoke "load_data_1" (i32.const 0)) (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x1110 0x1312 0x1514))
+(assert_return (invoke "load_data_2" (i32.const 0)) (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x1110 0x1312 0x1514))
+(assert_return (invoke "load_data_3" (i32.const 0)) (v128.const i16x8 0x0201 0x0403 0x0605 0x0807 0x1009 0x1211 0x1413 0x0015))
+(assert_return (invoke "load_data_4" (i32.const 0)) (v128.const i16x8 0x0302 0x0504 0x0706 0x0908 0x1110 0x1312 0x1514 0x0000))
+(assert_return (invoke "load_data_5" (i32.const 0)) (v128.const i16x8 0x0015 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+
+(assert_return (invoke "load_data_1" (i32.const 0)) (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15))
+(assert_return (invoke "load_data_2" (i32.const 0)) (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15))
+(assert_return (invoke "load_data_3" (i32.const 0)) (v128.const i8x16 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15 0x00))
+(assert_return (invoke "load_data_4" (i32.const 0)) (v128.const i8x16 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x10 0x11 0x12 0x13 0x14 0x15 0x00 0x00))
+(assert_return (invoke "load_data_5" (i32.const 0)) (v128.const i8x16 0x15 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+
+(assert_return (invoke "load_data_1" (i32.const 65505)) (v128.const i32x4 0x19181716 0x23222120 0x27262524 0x31302928))
+(assert_return (invoke "load_data_2" (i32.const 65505)) (v128.const i32x4 0x19181716 0x23222120 0x27262524 0x31302928))
+(assert_return (invoke "load_data_3" (i32.const 65505)) (v128.const i32x4 0x20191817 0x24232221 0x28272625 0x00313029))
+(assert_return (invoke "load_data_4" (i32.const 65505)) (v128.const i32x4 0x21201918 0x25242322 0x29282726 0x00003130))
+(assert_return (invoke "load_data_5" (i32.const 65505)) (v128.const i32x4 0x00000031 0x00000000 0x00000000 0x00000000))
+
+(assert_return (invoke "load_data_1" (i32.const 65505)) (v128.const i16x8 0x1716 0x1918 0x2120 0x2322 0x2524 0x2726 0x2928 0x3130))
+(assert_return (invoke "load_data_2" (i32.const 65505)) (v128.const i16x8 0x1716 0x1918 0x2120 0x2322 0x2524 0x2726 0x2928 0x3130))
+(assert_return (invoke "load_data_3" (i32.const 65505)) (v128.const i16x8 0x1817 0x2019 0x2221 0x2423 0x2625 0x2827 0x3029 0x0031))
+(assert_return (invoke "load_data_4" (i32.const 65505)) (v128.const i16x8 0x1918 0x2120 0x2322 0x2524 0x2726 0x2928 0x3130 0x0000))
+(assert_return (invoke "load_data_5" (i32.const 65505)) (v128.const i16x8 0x0031 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000 0x0000))
+
+(assert_return (invoke "load_data_1" (i32.const 65505)) (v128.const i8x16 0x16 0x17 0x18 0x19 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x30 0x31))
+(assert_return (invoke "load_data_2" (i32.const 65505)) (v128.const i8x16 0x16 0x17 0x18 0x19 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x30 0x31))
+(assert_return (invoke "load_data_3" (i32.const 65505)) (v128.const i8x16 0x17 0x18 0x19 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x30 0x31 0x00))
+(assert_return (invoke "load_data_4" (i32.const 65505)) (v128.const i8x16 0x18 0x19 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x30 0x31 0x00 0x00))
+(assert_return (invoke "load_data_5" (i32.const 65505)) (v128.const i8x16 0x31 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00))
+
+(assert_trap (invoke "load_data_3" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "load_data_5" (i32.const 65506)) "out of bounds memory access")
+
+(assert_return (invoke "store_data_0") (v128.const f32x4 0 1 2 3))
+(assert_return (invoke "store_data_1") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "store_data_2") (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "store_data_3") (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+(assert_return (invoke "store_data_4") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "store_data_5") (v128.const i32x4 0 1 2 3))
+
+(assert_trap (invoke "store_data_6" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "store_data_6" (i32.const 65535)) "out of bounds memory access")
+
+;; Load/Store v128 data with invalid offset
+
+(module
+  (memory 1)
+  (func (export "v128.load_offset_65521")
+    (drop (v128.load offset=65521 (i32.const 0)))
+  )
+)
+(assert_trap (invoke "v128.load_offset_65521") "out of bounds memory access")
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func"
+    "  (drop (v128.load offset=-1 (i32.const 0)))"
+    ")"
+  )
+  "unknown operator"
+)
+
+(module
+  (memory 1)
+  (func (export "v128.store_offset_65521")
+    (v128.store offset=65521 (i32.const 0) (v128.const i32x4 0 0 0 0))
+  )
+)
+(assert_trap (invoke "v128.store_offset_65521") "out of bounds memory access")
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func"
+    "  (v128.store offset=-1 (i32.const 0) (v128.const i32x4 0 0 0 0))"
+    ")"
+  )
+  "unknown operator"
+)
+
+
+;; Offset constant out of range
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (drop (v128.load offset=4294967296 (i32.const 0))))"
+  )
+  "i32 constant"
+)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (v128.store offset=4294967296 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "i32 constant"
+)
diff --git a/tests/misc_testsuite/winch/_simd_const.wast b/tests/misc_testsuite/winch/_simd_const.wast
new file mode 100644
index 000000000000..35e00243372f
--- /dev/null
+++ b/tests/misc_testsuite/winch/_simd_const.wast
@@ -0,0 +1,1664 @@
+;; v128.const normal parameter (e.g. (i8x16, i16x8 i32x4, f32x4))
+
+(module (func (v128.const i8x16  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF) drop))
+(module (func (v128.const i8x16 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80) drop))
+(module (func (v128.const i8x16  255  255  255  255  255  255  255  255  255  255  255  255  255  255  255  255) drop))
+(module (func (v128.const i8x16 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128 -128) drop))
+(module (func (v128.const i16x8  0xFFFF  0xFFFF  0xFFFF  0xFFFF  0xFFFF  0xFFFF  0xFFFF  0xFFFF) drop))
+(module (func (v128.const i16x8 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000 -0x8000) drop))
+(module (func (v128.const i16x8  65535  65535  65535  65535  65535  65535  65535  65535) drop))
+(module (func (v128.const i16x8 -32768 -32768 -32768 -32768 -32768 -32768 -32768 -32768) drop))
+(module (func (v128.const i16x8  65_535  65_535  65_535  65_535  65_535  65_535  65_535  65_535) drop))
+(module (func (v128.const i16x8 -32_768 -32_768 -32_768 -32_768 -32_768 -32_768 -32_768 -32_768) drop))
+(module (func (v128.const i16x8  0_123_45 0_123_45 0_123_45 0_123_45 0_123_45 0_123_45 0_123_45 0_123_45) drop))
+(module (func (v128.const i16x8  0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234) drop))
+(module (func (v128.const i32x4  0xffffffff  0xffffffff  0xffffffff  0xffffffff) drop))
+(module (func (v128.const i32x4 -0x80000000 -0x80000000 -0x80000000 -0x80000000) drop))
+(module (func (v128.const i32x4  4294967295  4294967295  4294967295  4294967295) drop))
+(module (func (v128.const i32x4 -2147483648 -2147483648 -2147483648 -2147483648) drop))
+(module (func (v128.const i32x4  0xffff_ffff  0xffff_ffff  0xffff_ffff  0xffff_ffff) drop))
+(module (func (v128.const i32x4 -0x8000_0000 -0x8000_0000 -0x8000_0000 -0x8000_0000) drop))
+(module (func (v128.const i32x4 4_294_967_295  4_294_967_295  4_294_967_295  4_294_967_295) drop))
+(module (func (v128.const i32x4 -2_147_483_648 -2_147_483_648 -2_147_483_648 -2_147_483_648) drop))
+(module (func (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789) drop))
+(module (func (v128.const i32x4 0x0_9acf_fBDF 0x0_9acf_fBDF 0x0_9acf_fBDF 0x0_9acf_fBDF) drop))
+(module (func (v128.const i64x2  0xffffffffffffffff  0xffffffffffffffff) drop))
+(module (func (v128.const i64x2 -0x8000000000000000 -0x8000000000000000) drop))
+(module (func (v128.const i64x2  18446744073709551615 18446744073709551615) drop))
+(module (func (v128.const i64x2 -9223372036854775808 -9223372036854775808) drop))
+(module (func (v128.const i64x2  0xffff_ffff_ffff_ffff  0xffff_ffff_ffff_ffff) drop))
+(module (func (v128.const i64x2 -0x8000_0000_0000_0000 -0x8000_0000_0000_0000) drop))
+(module (func (v128.const i64x2  18_446_744_073_709_551_615 18_446_744_073_709_551_615) drop))
+(module (func (v128.const i64x2 -9_223_372_036_854_775_808 -9_223_372_036_854_775_808) drop))
+(module (func (v128.const i64x2  0_123_456_789 0_123_456_789) drop))
+(module (func (v128.const i64x2  0x0125_6789_ADEF_bcef 0x0125_6789_ADEF_bcef) drop))
+(module (func (v128.const f32x4  0x1p127  0x1p127  0x1p127  0x1p127) drop))
+(module (func (v128.const f32x4 -0x1p127 -0x1p127 -0x1p127 -0x1p127) drop))
+(module (func (v128.const f32x4  1e38  1e38  1e38  1e38) drop))
+(module (func (v128.const f32x4 -1e38 -1e38 -1e38 -1e38) drop))
+(module (func (v128.const f32x4  340282356779733623858607532500980858880 340282356779733623858607532500980858880
+                                 340282356779733623858607532500980858880 340282356779733623858607532500980858880) drop))
+(module (func (v128.const f32x4 -340282356779733623858607532500980858880 -340282356779733623858607532500980858880
+                                -340282356779733623858607532500980858880 -340282356779733623858607532500980858880) drop))
+(module (func (v128.const f32x4 nan:0x1 nan:0x1 nan:0x1 nan:0x1) drop))
+(module (func (v128.const f32x4 nan:0x7f_ffff nan:0x7f_ffff nan:0x7f_ffff nan:0x7f_ffff) drop))
+(module (func (v128.const f32x4 0123456789 0123456789 0123456789 0123456789) drop))
+(module (func (v128.const f32x4 0123456789e019 0123456789e019 0123456789e019 0123456789e019) drop))
+(module (func (v128.const f32x4 0123456789e+019 0123456789e+019 0123456789e+019 0123456789e+019) drop))
+(module (func (v128.const f32x4 0123456789e-019 0123456789e-019 0123456789e-019 0123456789e-019) drop))
+(module (func (v128.const f32x4 0123456789. 0123456789. 0123456789. 0123456789.) drop))
+(module (func (v128.const f32x4 0123456789.e019 0123456789.e019 0123456789.e019 0123456789.e019) drop))
+(module (func (v128.const f32x4 0123456789.e+019 0123456789.e+019 0123456789.e+019 0123456789.e+019) drop))
+(module (func (v128.const f32x4 0123456789.e-019 0123456789.e-019 0123456789.e-019 0123456789.e-019) drop))
+(module (func (v128.const f32x4 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789 0123456789.0123456789) drop))
+(module (func (v128.const f32x4 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019 0123456789.0123456789e019) drop))
+(module (func (v128.const f32x4 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019 0123456789.0123456789e+019) drop))
+(module (func (v128.const f32x4 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019 0123456789.0123456789e-019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF 0x0123456789ABCDEF) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019 0x0123456789ABCDEFp019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019 0x0123456789ABCDEFp+019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019 0x0123456789ABCDEFp-019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF. 0x0123456789ABCDEF.) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019 0x0123456789ABCDEF.p019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019 0x0123456789ABCDEF.p+019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019 0x0123456789ABCDEF.p-019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF 0x0123456789ABCDEF.019aF) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019 0x0123456789ABCDEF.019aFp019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019 0x0123456789ABCDEF.019aFp+019) drop))
+(module (func (v128.const f32x4 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019 0x0123456789ABCDEF.019aFp-019) drop))
+(module (func (v128.const f64x2  0x1p1023  0x1p1023) drop))
+(module (func (v128.const f64x2 -0x1p1023 -0x1p1023) drop))
+(module (func (v128.const f64x2  1e308  1e308) drop))
+(module (func (v128.const f64x2 -1e308 -1e308) drop))
+(module (func (v128.const f64x2  179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368
+                                 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368) drop))
+(module (func (v128.const f64x2 -179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368
+                                -179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368) drop))
+(module (func (v128.const f64x2 nan:0x1 nan:0x1) drop))
+(module (func (v128.const f64x2 nan:0xf_ffff_ffff_ffff nan:0xf_ffff_ffff_ffff) drop))
+(module (func (v128.const f64x2 0123456789 0123456789) drop))
+(module (func (v128.const f64x2 0123456789e019 0123456789e019) drop))
+(module (func (v128.const f64x2 0123456789e+019 0123456789e+019) drop))
+(module (func (v128.const f64x2 0123456789e-019 0123456789e-019) drop))
+(module (func (v128.const f64x2 0123456789. 0123456789.) drop))
+(module (func (v128.const f64x2 0123456789.e019 0123456789.e019) drop))
+(module (func (v128.const f64x2 0123456789.e+019 0123456789.e+019) drop))
+(module (func (v128.const f64x2 0123456789.e-019 0123456789.e-019) drop))
+(module (func (v128.const f64x2 0123456789.0123456789 0123456789.0123456789) drop))
+(module (func (v128.const f64x2 0123456789.0123456789e019 0123456789.0123456789e019) drop))
+(module (func (v128.const f64x2 0123456789.0123456789e+019 0123456789.0123456789e+019) drop))
+(module (func (v128.const f64x2 0123456789.0123456789e-019 0123456789.0123456789e-019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdefp019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdefp+019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdefp-019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef. 0x0123456789ABCDEFabcdef.) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.p019 0x0123456789ABCDEFabcdef.p019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.p+019 0x0123456789ABCDEFabcdef.p+019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.p-019 0x0123456789ABCDEFabcdef.p-019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdef) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp+019) drop))
+(module (func (v128.const f64x2 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019 0x0123456789ABCDEFabcdef.0123456789ABCDEFabcdefp-019) drop))
+
+;; Non-splat cases
+
+(module (func (v128.const i8x16  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF  0xFF
+                                -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80) drop))
+(module (func (v128.const i8x16  0xFF  0xFF  0xFF  0xFF   255   255   255   255
+                                -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80 -0x80) drop))
+(module (func (v128.const i8x16  0xFF  0xFF  0xFF  0xFF   255   255   255   255
+                                -0x80 -0x80 -0x80 -0x80  -128  -128  -128  -128) drop))
+(module (func (v128.const i16x8 0xFF 0xFF  0xFF  0xFF -0x8000 -0x8000 -0x8000 -0x8000) drop))
+(module (func (v128.const i16x8 0xFF 0xFF 65535 65535 -0x8000 -0x8000 -0x8000 -0x8000) drop))
+(module (func (v128.const i16x8 0xFF 0xFF 65535 65535 -0x8000 -0x8000  -32768  -32768) drop))
+(module (func (v128.const i32x4 0xffffffff 0xffffffff -0x80000000 -0x80000000) drop))
+(module (func (v128.const i32x4 0xffffffff 4294967295 -0x80000000 -0x80000000) drop))
+(module (func (v128.const i32x4 0xffffffff 4294967295 -0x80000000 -2147483648) drop))
+(module (func (v128.const f32x4 0x1p127 0x1p127 -0x1p127 -1e38) drop))
+(module (func (v128.const f32x4 0x1p127 340282356779733623858607532500980858880 -1e38 -340282356779733623858607532500980858880) drop))
+(module (func (v128.const f32x4 nan -nan inf -inf) drop))
+(module (func (v128.const i64x2 0xffffffffffffffff 0x8000000000000000) drop))
+(module (func (v128.const i64x2 0xffffffffffffffff -9223372036854775808) drop))
+(module (func (v128.const f64x2 0x1p1023 -1e308) drop))
+(module (func (v128.const f64x2 nan -inf) drop))
+
+;; Constant out of range (int literal is too large)
+
+(module (memory 1))
+(assert_malformed
+  (module quote "(func (v128.const i8x16 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100 0x100) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81 -0x81) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256 256) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129 -129) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 0x10000 0x10000 0x10000 0x10000 0x10000 0x10000 0x10000 0x10000) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 -0x8001 -0x8001 -0x8001 -0x8001 -0x8001 -0x8001 -0x8001 -0x8001) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 65536 65536 65536 65536 65536 65536 65536 65536) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 -32769 -32769 -32769 -32769 -32769 -32769 -32769 -32769) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4  0x100000000  0x100000000  0x100000000  0x100000000) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4 -0x80000001 -0x80000001 -0x80000001 -0x80000001) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4  4294967296  4294967296  4294967296  4294967296) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4 -2147483649 -2147483649 -2147483649 -2147483649) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4  0x1p128  0x1p128  0x1p128  0x1p128) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 -0x1p128 -0x1p128 -0x1p128 -0x1p128) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4  1e39  1e39  1e39  1e39) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 -1e39 -1e39 -1e39 -1e39) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4  340282356779733661637539395458142568448 340282356779733661637539395458142568448"
+                "                         340282356779733661637539395458142568448 340282356779733661637539395458142568448) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 -340282356779733661637539395458142568448 -340282356779733661637539395458142568448"
+                "                        -340282356779733661637539395458142568448 -340282356779733661637539395458142568448) drop)")
+  "constant out of range"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const f32x4 nan:0x80_0000 nan:0x80_0000 nan:0x80_0000 nan:0x80_0000) drop)")
+  "constant out of range"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const f64x2  269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552"
+                "                         269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 -269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552"
+                "                        -269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552) drop)")
+  "constant out of range"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const f64x2 nan:0x10_0000_0000_0000 nan:0x10_0000_0000_0000) drop)")
+  "constant out of range"
+)
+
+;; More malformed v128.const forms
+(assert_malformed
+  (module quote "(func (v128.const) drop)")
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const 0 0 0 0) drop)")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i8x16 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg) drop)")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const i16x8) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 0x 0x 0x 0x 0x 0x 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 1x 1x 1x 1x 1x 1x 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i16x8 0xg 0xg 0xg 0xg 0xg 0xg 0xg 0xg) drop)")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const i32x4) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4 0x 0x 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4 1x 1x 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const i32x4 0xg 0xg 0xg 0xg) drop)")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const i64x2) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const i64x2 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0xg 0xg) drop)")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const f32x4) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 .0 .0 .0 .0) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 .0e0 .0e0 .0e0 .0e0) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0e 0e 0e 0e) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0e+ 0e+ 0e+ 0e+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0.0e 0.0e 0.0e 0.0e) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0.0e- 0.0e- 0.0e- 0.0e-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x 0x 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 1x 1x 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0xg 0xg 0xg 0xg) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x. 0x. 0x. 0x.) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0.g 0x0.g 0x0.g 0x0.g) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0p 0x0p 0x0p 0x0p) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0p+ 0x0p+ 0x0p+ 0x0p+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0p- 0x0p- 0x0p- 0x0p-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0.0p 0x0.0p 0x0.0p 0x0.0p) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0.0p+ 0x0.0p+ 0x0.0p+ 0x0.0p+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0.0p- 0x0.0p- 0x0.0p- 0x0.0p-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 0x0pA 0x0pA 0x0pA 0x0pA) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 nan:1 nan:1 nan:1 nan:1) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f32x4 nan:0x0 nan:0x0 nan:0x0 nan:0x0) drop)")
+  "constant out of range"
+)
+
+(assert_malformed
+  (module quote "(func (v128.const f64x2) drop)")
+  "wrong number of lane literals"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 .0 .0) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 .0e0 .0e0) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0e 0e) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0e+ 0e+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0.0e+ 0.0e+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0.0e- 0.0e-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x 0x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 1x 1x) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0xg 0xg) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x. 0x.) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0.g 0x0.g) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0p 0x0p) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0p+ 0x0p+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0p- 0x0p-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0.0p 0x0.0p) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0.0p+ 0x0.0p+) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0.0p- 0x0.0p-) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 0x0pA 0x0pA) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 nan:1 nan:1) drop)")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func (v128.const f64x2 nan:0x0 nan:0x0) drop)")
+  "constant out of range"
+)
+
+;; too little arguments
+
+(assert_malformed
+  (module quote "(func (v128.const i32x4 0x10000000000000000 0x10000000000000000) drop)")
+  "wrong number of lane literals"
+)
+
+;; too many arguments
+(assert_malformed
+  (module quote "(func (v128.const i32x4 0x1 0x1 0x1 0x1 0x1) drop)")
+  "wrong number of lane literals"
+)
+
+;; Rounding behaviour
+
+;; f32x4, small exponent
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.00000100000000000p-50 +0x1.00000100000000000p-50 +0x1.00000100000000000p-50 +0x1.00000100000000000p-50)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.00000100000000000p-50 -0x1.00000100000000000p-50 -0x1.00000100000000000p-50 -0x1.00000100000000000p-50)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.00000500000000001p-50 +0x1.00000500000000001p-50 +0x1.00000500000000001p-50 +0x1.00000500000000001p-50)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000006p-50 +0x1.000006p-50 +0x1.000006p-50 +0x1.000006p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.00000500000000001p-50 -0x1.00000500000000001p-50 -0x1.00000500000000001p-50 -0x1.00000500000000001p-50)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000006p-50 -0x1.000006p-50 -0x1.000006p-50 -0x1.000006p-50))
+
+(module (func (export "f") (result v128) (v128.const f32x4 +0x4000.004000000p-64 +0x4000.004000000p-64 +0x4000.004000000p-64 +0x4000.004000000p-64)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x4000.004000000p-64 -0x4000.004000000p-64 -0x4000.004000000p-64 -0x4000.004000000p-64)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x4000.014000001p-64 +0x4000.014000001p-64 +0x4000.014000001p-64 +0x4000.014000001p-64)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000006p-50 +0x1.000006p-50 +0x1.000006p-50 +0x1.000006p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x4000.014000001p-64 -0x4000.014000001p-64 -0x4000.014000001p-64 -0x4000.014000001p-64)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000006p-50 -0x1.000006p-50 -0x1.000006p-50 -0x1.000006p-50))
+
+(module (func (export "f") (result v128) (v128.const f32x4 +8.8817847263968443573e-16 +8.8817847263968443573e-16 +8.8817847263968443573e-16 +8.8817847263968443573e-16)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50 +0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -8.8817847263968443573e-16 -8.8817847263968443573e-16 -8.8817847263968443573e-16 -8.8817847263968443573e-16)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50 -0x1.000000p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 +8.8817857851880284253e-16 +8.8817857851880284253e-16 +8.8817857851880284253e-16 +8.8817857851880284253e-16)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000004p-50 +0x1.000004p-50 +0x1.000004p-50 +0x1.000004p-50))
+(module (func (export "f") (result v128) (v128.const f32x4 -8.8817857851880284253e-16 -8.8817857851880284253e-16 -8.8817857851880284253e-16 -8.8817857851880284253e-16)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000004p-50 -0x1.000004p-50 -0x1.000004p-50 -0x1.000004p-50))
+
+;; f32x4, large exponent
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.00000100000000000p+50 +0x1.00000100000000000p+50 +0x1.00000100000000000p+50 +0x1.00000100000000000p+50)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.00000100000000000p+50 -0x1.00000100000000000p+50 -0x1.00000100000000000p+50 -0x1.00000100000000000p+50)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.00000500000000001p+50 +0x1.00000500000000001p+50 +0x1.00000500000000001p+50 +0x1.00000500000000001p+50)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000006p+50 +0x1.000006p+50 +0x1.000006p+50 +0x1.000006p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.00000500000000001p+50 -0x1.00000500000000001p+50 -0x1.00000500000000001p+50 -0x1.00000500000000001p+50)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000006p+50 -0x1.000006p+50 -0x1.000006p+50 -0x1.000006p+50))
+
+(module (func (export "f") (result v128) (v128.const f32x4 +0x4000004000000 +0x4000004000000 +0x4000004000000 +0x4000004000000)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x4000004000000 -0x4000004000000 -0x4000004000000 -0x4000004000000)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x400000c000000 +0x400000c000000 +0x400000c000000 +0x400000c000000)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000004p+50 +0x1.000004p+50 +0x1.000004p+50 +0x1.000004p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x400000c000000 -0x400000c000000 -0x400000c000000 -0x400000c000000)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000004p+50 -0x1.000004p+50 -0x1.000004p+50 -0x1.000004p+50))
+
+(module (func (export "f") (result v128) (v128.const f32x4 +1125899973951488 +1125899973951488 +1125899973951488 +1125899973951488)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50 +0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -1125899973951488 -1125899973951488 -1125899973951488 -1125899973951488)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50 -0x1.000000p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 +1125900108169216 +1125900108169216 +1125900108169216 +1125900108169216)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.000004p+50 +0x1.000004p+50 +0x1.000004p+50 +0x1.000004p+50))
+(module (func (export "f") (result v128) (v128.const f32x4 -1125900108169216 -1125900108169216 -1125900108169216 -1125900108169216)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.000004p+50 -0x1.000004p+50 -0x1.000004p+50 -0x1.000004p+50))
+
+;; f32x4, subnormal
+(module (func (export "f") (result v128) (v128.const f32x4 +0x0.00000100000000000p-126 +0x0.00000100000000000p-126 +0x0.00000100000000000p-126 +0x0.00000100000000000p-126)))
+(assert_return (invoke "f") (v128.const f32x4 +0x0.000000p-126 +0x0.000000p-126 +0x0.000000p-126 +0x0.000000p-126))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x0.00000100000000000p-126 -0x0.00000100000000000p-126 -0x0.00000100000000000p-126 -0x0.00000100000000000p-126)))
+(assert_return (invoke "f") (v128.const f32x4 -0x0.000000p-126 -0x0.000000p-126 -0x0.000000p-126 -0x0.000000p-126))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x0.00000500000000001p-126 +0x0.00000500000000001p-126 +0x0.00000500000000001p-126 +0x0.00000500000000001p-126)))
+(assert_return (invoke "f") (v128.const f32x4 +0x0.000006p-126 +0x0.000006p-126 +0x0.000006p-126 +0x0.000006p-126))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x0.00000500000000001p-126 -0x0.00000500000000001p-126 -0x0.00000500000000001p-126 -0x0.00000500000000001p-126)))
+(assert_return (invoke "f") (v128.const f32x4 -0x0.000006p-126 -0x0.000006p-126 -0x0.000006p-126 -0x0.000006p-126))
+
+;; f32x4, round down at limit to infinity
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.fffffe8p127 +0x1.fffffe8p127 +0x1.fffffe8p127 +0x1.fffffe8p127)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.fffffep127 +0x1.fffffep127 +0x1.fffffep127 +0x1.fffffep127))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.fffffe8p127 -0x1.fffffe8p127 -0x1.fffffe8p127 -0x1.fffffe8p127)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127))
+(module (func (export "f") (result v128) (v128.const f32x4 +0x1.fffffefffffffffffp127 +0x1.fffffefffffffffffp127 +0x1.fffffefffffffffffp127 +0x1.fffffefffffffffffp127)))
+(assert_return (invoke "f") (v128.const f32x4 +0x1.fffffep127 +0x1.fffffep127 +0x1.fffffep127 +0x1.fffffep127))
+(module (func (export "f") (result v128) (v128.const f32x4 -0x1.fffffefffffffffffp127 -0x1.fffffefffffffffffp127 -0x1.fffffefffffffffffp127 -0x1.fffffefffffffffffp127)))
+(assert_return (invoke "f") (v128.const f32x4 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127 -0x1.fffffep127))
+
+;; f64x2, small exponent
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000000p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000000p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000000p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000000p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.0000000000000fffffffffffp-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.0000000000000fffffffffffp-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000000p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000000p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.00000000000017ffffffffffp-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.00000000000017ffffffffffp-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000000p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000000p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.0000000000001fffffffffffp-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.0000000000001fffffffffffp-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000000p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000000p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.00000000000027ffffffffffp-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.00000000000027ffffffffffp-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x1.000000000000280000000001p-600)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000003p-600))
+(module (func (export "f") (result f64) (f64.const -0x1.000000000000280000000001p-600)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000003p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000400000000000p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000000p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000400000000000p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000000p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000400000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000400000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.0000007fffffffffffp-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.0000007fffffffffffp-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000800000000000p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000800000000000p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000800000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000800000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000bfffffffffffp-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000bfffffffffffp-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000c00000000000p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000c00000000000p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000c00000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000c00000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000000ffffffffffffp-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000000ffffffffffffp-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000001000000000000p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000001000000000000p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000001000000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000001000000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.0000013fffffffffffp-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.0000013fffffffffffp-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
+(module (func (export "f") (result f64) (f64.const +0x8000000.000001400000000001p-627)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000003p-600))
+(module (func (export "f") (result f64) (f64.const -0x8000000.000001400000000001p-627)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000003p-600))
+(module (func (export "f") (result f64) (f64.const +5.3575430359313371995e+300)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000000p+999))
+(module (func (export "f") (result f64) (f64.const -5.3575430359313371995e+300)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000000p+999))
+(module (func (export "f") (result f64) (f64.const +5.3575430359313371996e+300)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p+999))
+(module (func (export "f") (result f64) (f64.const -5.3575430359313371996e+300)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p+999))
+(module (func (export "f") (result f64) (f64.const +5.3575430359313383891e+300)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000001p+999))
+(module (func (export "f") (result f64) (f64.const -5.3575430359313383891e+300)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000001p+999))
+(module (func (export "f") (result f64) (f64.const +5.3575430359313383892e+300)))
+(assert_return (invoke "f") (f64.const +0x1.0000000000002p+999))
+(module (func (export "f") (result f64) (f64.const -5.3575430359313383892e+300)))
+(assert_return (invoke "f") (f64.const -0x1.0000000000002p+999))
+
+;; f64, large exponent
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000080000000000p+600 +0x1.000000000000080000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000000p+600 +0x1.0000000000000p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000080000000000p+600 -0x1.000000000000080000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000000p+600 -0x1.0000000000000p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000080000000001p+600 +0x1.000000000000080000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000080000000001p+600 -0x1.000000000000080000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.0000000000000fffffffffffp+600 +0x1.0000000000000fffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.0000000000000fffffffffffp+600 -0x1.0000000000000fffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000100000000000p+600 +0x1.000000000000100000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000100000000000p+600 -0x1.000000000000100000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000100000000001p+600 +0x1.000000000000100000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000100000000001p+600 -0x1.000000000000100000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.00000000000017ffffffffffp+600 +0x1.00000000000017ffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+600 +0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.00000000000017ffffffffffp+600 -0x1.00000000000017ffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+600 -0x1.0000000000001p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000180000000000p+600 +0x1.000000000000180000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000180000000000p+600 -0x1.000000000000180000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000180000000001p+600 +0x1.000000000000180000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000180000000001p+600 -0x1.000000000000180000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.0000000000001fffffffffffp+600 +0x1.0000000000001fffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.0000000000001fffffffffffp+600 -0x1.0000000000001fffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000200000000000p+600 +0x1.000000000000200000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000200000000000p+600 -0x1.000000000000200000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000200000000001p+600 +0x1.000000000000200000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000200000000001p+600 -0x1.000000000000200000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.00000000000027ffffffffffp+600 +0x1.00000000000027ffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.00000000000027ffffffffffp+600 -0x1.00000000000027ffffffffffp+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000280000000000p+600 +0x1.000000000000280000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+600 +0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000280000000000p+600 -0x1.000000000000280000000000p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+600 -0x1.0000000000002p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000280000000001p+600 +0x1.000000000000280000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000003p+600 +0x1.0000000000003p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000280000000001p+600 -0x1.000000000000280000000001p+600)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000003p+600 -0x1.0000000000003p+600))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000100000000000 +0x2000000000000100000000000)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000000p+97 +0x1.0000000000000p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000100000000000 -0x2000000000000100000000000)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000000p+97 -0x1.0000000000000p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000100000000001 +0x2000000000000100000000001)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000100000000001 -0x2000000000000100000000001)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x20000000000001fffffffffff +0x20000000000001fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x20000000000001fffffffffff -0x20000000000001fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000200000000000 +0x2000000000000200000000000)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000200000000000 -0x2000000000000200000000000)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000200000000001 +0x2000000000000200000000001)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000200000000001 -0x2000000000000200000000001)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x20000000000002fffffffffff +0x20000000000002fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+97 +0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x20000000000002fffffffffff -0x20000000000002fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+97 -0x1.0000000000001p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000300000000000 +0x2000000000000300000000000)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000300000000000 -0x2000000000000300000000000)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000300000000001 +0x2000000000000300000000001)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000300000000001 -0x2000000000000300000000001)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x20000000000003fffffffffff +0x20000000000003fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x20000000000003fffffffffff -0x20000000000003fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000400000000000 +0x2000000000000400000000000)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000400000000000 -0x2000000000000400000000000)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000400000000001 +0x2000000000000400000000001)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000400000000001 -0x2000000000000400000000001)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x20000000000004fffffffffff +0x20000000000004fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x20000000000004fffffffffff -0x20000000000004fffffffffff)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000500000000000 +0x2000000000000500000000000)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+97 +0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000500000000000 -0x2000000000000500000000000)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+97 -0x1.0000000000002p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x2000000000000500000000001 +0x2000000000000500000000001)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000003p+97 +0x1.0000000000003p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x2000000000000500000000001 -0x2000000000000500000000001)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000003p+97 -0x1.0000000000003p+97))
+(module (func (export "f") (result v128) (v128.const f64x2 +1152921504606847104 +1152921504606847104)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000000p+60 +0x1.0000000000000p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 -1152921504606847104 -1152921504606847104)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000000p+60 -0x1.0000000000000p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 +1152921504606847105 +1152921504606847105)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+60 +0x1.0000000000001p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 -1152921504606847105 -1152921504606847105)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+60 -0x1.0000000000001p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 +1152921504606847359 +1152921504606847359)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000001p+60 +0x1.0000000000001p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 -1152921504606847359 -1152921504606847359)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000001p+60 -0x1.0000000000001p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 +1152921504606847360 +1152921504606847360)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000002p+60 +0x1.0000000000002p+60))
+(module (func (export "f") (result v128) (v128.const f64x2 -1152921504606847360 -1152921504606847360)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000002p+60 -0x1.0000000000002p+60))
+
+;; f64x2, subnormal
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000080000000000p-1022 +0x0.000000000000080000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000000p-1022 +0x0.0000000000000p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000080000000000p-1022 -0x0.000000000000080000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000000p-1022 -0x0.0000000000000p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000080000000001p-1022 +0x0.000000000000080000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000080000000001p-1022 -0x0.000000000000080000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.0000000000000fffffffffffp-1022 +0x0.0000000000000fffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.0000000000000fffffffffffp-1022 -0x0.0000000000000fffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000100000000000p-1022 +0x0.000000000000100000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000100000000000p-1022 -0x0.000000000000100000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000100000000001p-1022 +0x0.000000000000100000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000100000000001p-1022 -0x0.000000000000100000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.00000000000017ffffffffffp-1022 +0x0.00000000000017ffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000001p-1022 +0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.00000000000017ffffffffffp-1022 -0x0.00000000000017ffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000001p-1022 -0x0.0000000000001p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000180000000000p-1022 +0x0.000000000000180000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000180000000000p-1022 -0x0.000000000000180000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000180000000001p-1022 +0x0.000000000000180000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000180000000001p-1022 -0x0.000000000000180000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.0000000000001fffffffffffp-1022 +0x0.0000000000001fffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.0000000000001fffffffffffp-1022 -0x0.0000000000001fffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000200000000000p-1022 +0x0.000000000000200000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000200000000000p-1022 -0x0.000000000000200000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000200000000001p-1022 +0x0.000000000000200000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000200000000001p-1022 -0x0.000000000000200000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.00000000000027ffffffffffp-1022 +0x0.00000000000027ffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.00000000000027ffffffffffp-1022 -0x0.00000000000027ffffffffffp-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x0.000000000000280000000000p-1022 +0x0.000000000000280000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x0.0000000000002p-1022 +0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x0.000000000000280000000000p-1022 -0x0.000000000000280000000000p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x0.0000000000002p-1022 -0x0.0000000000002p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.000000000000280000000001p-1022 +0x1.000000000000280000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.0000000000003p-1022 +0x1.0000000000003p-1022))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.000000000000280000000001p-1022 -0x1.000000000000280000000001p-1022)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.0000000000003p-1022 -0x1.0000000000003p-1022))
+
+;; f64x2, round down at limit to infinity
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.fffffffffffff4p1023 +0x1.fffffffffffff4p1023)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.fffffffffffffp1023 +0x1.fffffffffffffp1023))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.fffffffffffff4p1023 -0x1.fffffffffffff4p1023)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.fffffffffffffp1023 -0x1.fffffffffffffp1023))
+(module (func (export "f") (result v128) (v128.const f64x2 +0x1.fffffffffffff7ffffffp1023 +0x1.fffffffffffff7ffffffp1023)))
+(assert_return (invoke "f") (v128.const f64x2 +0x1.fffffffffffffp1023 +0x1.fffffffffffffp1023))
+(module (func (export "f") (result v128) (v128.const f64x2 -0x1.fffffffffffff7ffffffp1023 -0x1.fffffffffffff7ffffffp1023)))
+(assert_return (invoke "f") (v128.const f64x2 -0x1.fffffffffffffp1023 -0x1.fffffffffffffp1023))
+
+;; As parameters of control constructs
+
+(module (memory 1)
+  (func (export "as-br-retval") (result v128)
+    (block (result v128) (br 0 (v128.const i32x4 0x03020100 0x07060504 0x0b0a0908 0x0f0e0d0c)))
+  )
+  (func (export "as-br_if-retval") (result v128)
+    (block (result v128)
+      (br_if 0 (v128.const i32x4 0 1 2 3) (i32.const 1))
+    )
+  )
+  (func (export "as-return-retval") (result v128)
+    (return (v128.const i32x4 0 1 2 3))
+  )
+  (func (export "as-if-then-retval") (result v128)
+    (if (result v128) (i32.const 1)
+      (then (v128.const i32x4 0 1 2 3)) (else (v128.const i32x4 3 2 1 0))
+    )
+  )
+  (func (export "as-if-else-retval") (result v128)
+    (if (result v128) (i32.const 0)
+      (then (v128.const i32x4 0 1 2 3)) (else (v128.const i32x4 3 2 1 0))
+    )
+  )
+  (func $f (param v128 v128 v128) (result v128) (v128.const i32x4 0 1 2 3))
+  (func (export "as-call-param") (result v128)
+    (call $f (v128.const i32x4 0 1 2 3) (v128.const i32x4 0 1 2 3) (v128.const i32x4 0 1 2 3))
+  )
+  (func (export "as-block-retval") (result v128)
+    (block (result v128) (v128.const i32x4 0 1 2 3))
+  )
+  (func (export "as-loop-retval") (result v128)
+    (loop (result v128) (v128.const i32x4 0 1 2 3))
+  )
+  (func (export "as-drop-operand")
+    (drop (v128.const i32x4 0 1 2 3))
+  )
+
+  (func (export "as-br-retval2") (result v128)
+    (block (result v128) (br 0 (v128.const i64x2 0x0302010007060504 0x0b0a09080f0e0d0c)))
+  )
+  (func (export "as-br_if-retval2") (result v128)
+    (block (result v128)
+      (br_if 0 (v128.const i64x2 0 1) (i32.const 1))
+    )
+  )
+  (func (export "as-return-retval2") (result v128)
+    (return (v128.const i64x2 0 1))
+  )
+  (func (export "as-if-then-retval2") (result v128)
+    (if (result v128) (i32.const 1)
+      (then (v128.const i64x2 0 1)) (else (v128.const i64x2 1 0))
+    )
+  )
+  (func (export "as-if-else-retval2") (result v128)
+    (if (result v128) (i32.const 0)
+      (then (v128.const i64x2 0 1)) (else (v128.const i64x2 1 0))
+    )
+  )
+  (func $f2 (param v128 v128 v128) (result v128) (v128.const i64x2 0 1))
+  (func (export "as-call-param2") (result v128)
+    (call $f2 (v128.const i64x2 0 1) (v128.const i64x2 0 1) (v128.const i64x2 0 1))
+  )
+
+  (type $sig (func (param v128 v128 v128) (result v128)))
+  (table funcref (elem $f $f2))
+  (func (export "as-call_indirect-param") (result v128)
+    (call_indirect (type $sig)
+      (v128.const i32x4 0 1 2 3) (v128.const i32x4 0 1 2 3) (v128.const i32x4 0 1 2 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-param2") (result v128)
+    (call_indirect (type $sig)
+      (v128.const i64x2 0 1) (v128.const i64x2 0 1) (v128.const i64x2 0 1) (i32.const 1)
+    )
+  )
+  (func (export "as-block-retval2") (result v128)
+    (block (result v128) (v128.const i64x2 0 1))
+  )
+  (func (export "as-loop-retval2") (result v128)
+    (loop (result v128) (v128.const i64x2 0 1))
+  )
+  (func (export "as-drop-operand2")
+    (drop (v128.const i64x2 0 1))
+  )
+)
+
+(assert_return (invoke "as-br-retval") (v128.const i32x4 0x03020100 0x07060504 0x0b0a0908 0x0f0e0d0c))
+(assert_return (invoke "as-br_if-retval") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-return-retval") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-if-then-retval") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-if-else-retval") (v128.const i32x4 3 2 1 0))
+(assert_return (invoke "as-call-param") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-call_indirect-param") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-block-retval") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-loop-retval") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "as-drop-operand"))
+
+(assert_return (invoke "as-br-retval2") (v128.const i64x2 0x0302010007060504 0x0b0a09080f0e0d0c))
+(assert_return (invoke "as-br_if-retval2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-return-retval2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-if-then-retval2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-if-else-retval2") (v128.const i64x2 1 0))
+(assert_return (invoke "as-call-param2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-call_indirect-param2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-block-retval2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-loop-retval2") (v128.const i64x2 0 1))
+(assert_return (invoke "as-drop-operand2"))
+
+;; v128 locals
+
+(module (memory 1)
+  (func (export "as-local.set/get-value_0_0") (param $0 v128) (result v128)
+    (local v128 v128 v128 v128)
+    (local.set 0 (local.get $0))
+    (local.get 0)
+  )
+  (func (export "as-local.set/get-value_0_1") (param $0 v128) (result v128)
+    (local v128 v128 v128 v128)
+    (local.set 0 (local.get $0))
+    (local.set 1 (local.get 0))
+    (local.set 2 (local.get 1))
+    (local.set 3 (local.get 2))
+    (local.get 0)
+  )
+  (func (export "as-local.set/get-value_3_0") (param $0 v128) (result v128)
+    (local v128 v128 v128 v128)
+    (local.set 0 (local.get $0))
+    (local.set 1 (local.get 0))
+    (local.set 2 (local.get 1))
+    (local.set 3 (local.get 2))
+    (local.get 3)
+  )
+  (func (export "as-local.tee-value") (result v128)
+    (local v128)
+    (local.tee 0 (v128.const i32x4 0 1 2 3))
+  )
+)
+
+(assert_return (invoke "as-local.set/get-value_0_0" (v128.const i32x4 0 0 0 0)) (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "as-local.set/get-value_0_1" (v128.const i32x4 1 1 1 1)) (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "as-local.set/get-value_3_0" (v128.const i32x4 2 2 2 2)) (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "as-local.tee-value") (v128.const i32x4 0 1 2 3))
+
+
+;; v128 globals
+
+(module (memory 1)
+  (global $g0 (mut v128) (v128.const i32x4 0 1 2 3))
+  (global $g1 (mut v128) (v128.const i32x4 4 5 6 7))
+  (global $g2 (mut v128) (v128.const i32x4 8 9 10 11))
+  (global $g3 (mut v128) (v128.const i32x4 12 13 14 15))
+  (global $g4 (mut v128) (v128.const i32x4 16 17 18 19))
+
+  (func $set_g0 (export "as-global.set_value_$g0") (param $0 v128)
+    (global.set $g0 (local.get $0))
+  )
+  (func $set_g1_g2 (export "as-global.set_value_$g1_$g2") (param $0 v128) (param $1 v128)
+    (global.set $g1 (local.get $0))
+    (global.set $g2 (local.get $1))
+  )
+  (func $set_g0_g1_g2_g3 (export "as-global.set_value_$g0_$g1_$g2_$g3") (param $0 v128) (param $1 v128) (param $2 v128) (param $3 v128)
+    (call $set_g0 (local.get $0))
+    (call $set_g1_g2 (local.get $1) (local.get $2))
+    (global.set $g3 (local.get $3))
+  )
+  (func (export "global.get_g0") (result v128)
+    (global.get $g0)
+  )
+  (func (export "global.get_g1") (result v128)
+    (global.get $g1)
+  )
+  (func (export "global.get_g2") (result v128)
+    (global.get $g2)
+  )
+  (func (export "global.get_g3") (result v128)
+    (global.get $g3)
+  )
+)
+
+(assert_return (invoke "as-global.set_value_$g0_$g1_$g2_$g3" (v128.const i32x4 1 1 1 1)
+                                                             (v128.const i32x4 2 2 2 2)
+                                                             (v128.const i32x4 3 3 3 3)
+                                                             (v128.const i32x4 4 4 4 4)))
+(assert_return (invoke "global.get_g0") (v128.const i32x4 1 1 1 1))
+(assert_return (invoke "global.get_g1") (v128.const i32x4 2 2 2 2))
+(assert_return (invoke "global.get_g2") (v128.const i32x4 3 3 3 3))
+(assert_return (invoke "global.get_g3") (v128.const i32x4 4 4 4 4))
+
+
+;; Test integer literal parsing.
+
+(module
+  (func (export "i32x4.test") (result v128) (return (v128.const i32x4 0x0bAdD00D 0x0bAdD00D 0x0bAdD00D 0x0bAdD00D)))
+  (func (export "i32x4.smax") (result v128) (return (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)))
+  (func (export "i32x4.neg_smax") (result v128) (return (v128.const i32x4 -0x7fffffff -0x7fffffff -0x7fffffff -0x7fffffff)))
+  ;; (func (export "i32x4.inc_smin") (result v128) (return (i32x4.add (v128.const i32x4 -0x80000000 -0x80000000 -0x80000000 -0x80000000) (v128.const i32x4 1 1 1 1))))
+  (func (export "i32x4.neg_zero") (result v128) (return (v128.const i32x4 -0x0 -0x0 -0x0 -0x0)))
+  (func (export "i32x4.not_octal") (result v128) (return (v128.const i32x4 010 010 010 010)))
+  (func (export "i32x4.plus_sign") (result v128) (return (v128.const i32x4 +42 +42 +42 +42)))
+
+  (func (export "i32x4-dec-sep1") (result v128) (v128.const i32x4 1_000_000 1_000_000 1_000_000 1_000_000))
+  (func (export "i32x4-dec-sep2") (result v128) (v128.const i32x4 1_0_0_0 1_0_0_0 1_0_0_0 1_0_0_0))
+  (func (export "i32x4-hex-sep1") (result v128) (v128.const i32x4 0xa_0f_00_99 0xa_0f_00_99 0xa_0f_00_99 0xa_0f_00_99))
+  (func (export "i32x4-hex-sep2") (result v128) (v128.const i32x4 0x1_a_A_0_f 0x1_a_A_0_f 0x1_a_A_0_f 0x1_a_A_0_f))
+
+  (func (export "i64x2.test") (result v128) (return (v128.const i64x2 0x0bAdD00D0bAdD00D 0x0bAdD00D0bAdD00D)))
+  (func (export "i64x2.smax") (result v128) (return (v128.const i64x2 0x7fffffffffffffff 0x7fffffffffffffff)))
+  (func (export "i64x2.neg_smax") (result v128) (return (v128.const i64x2 -0x7fffffffffffffff -0x7fffffffffffffff)))
+  ;; (func (export "i64x2.inc_smin") (result v128) (return (i64x2.add (v128.const i64x2 -0x8000000000000000 -0x8000000000000000) (v128.const i64x2 1 1))))
+  (func (export "i64x2.neg_zero") (result v128) (return (v128.const i64x2 -0x0 -0x0)))
+  (func (export "i64x2.not_octal") (result v128) (return (v128.const i64x2 010010 010010)))
+  (func (export "i64x2.plus_sign") (result v128) (return (v128.const i64x2 +42 +42)))
+
+  (func (export "i64x2-dec-sep1") (result v128) (v128.const i64x2 10_000_000_000_000 10_000_000_000_000))
+  (func (export "i64x2-dec-sep2") (result v128) (v128.const i64x2 1_0_0_0_0_0_0_0 1_0_0_0_0_0_0_0))
+  (func (export "i64x2-hex-sep1") (result v128) (v128.const i64x2 0xa_0f_00_99_0a_0f_00_99 0xa_0f_00_99_0a_0f_00_99))
+  (func (export "i64x2-hex-sep2") (result v128) (v128.const i64x2 0x1_a_A_0_f_1_a_A_0_f 0x1_a_A_0_f_1_a_A_0_f))
+)
+
+(assert_return (invoke "i32x4.test") (v128.const i32x4 195940365 195940365 195940365 195940365))
+(assert_return (invoke "i32x4.smax") (v128.const i32x4 2147483647 2147483647 2147483647 2147483647))
+(assert_return (invoke "i32x4.neg_smax") (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+;; (assert_return (invoke "i32x4.inc_smin") (v128.const i32x4 -2147483647 -2147483647 -2147483647 -2147483647))
+(assert_return (invoke "i32x4.neg_zero") (v128.const i32x4 0 0 0 0))
+(assert_return (invoke "i32x4.not_octal") (v128.const i32x4 10 10 10 10))
+(assert_return (invoke "i32x4.plus_sign") (v128.const i32x4 42 42 42 42))
+
+(assert_return (invoke "i32x4-dec-sep1") (v128.const i32x4 1000000 1000000 1000000 1000000))
+(assert_return (invoke "i32x4-dec-sep2") (v128.const i32x4 1000 1000 1000 1000))
+(assert_return (invoke "i32x4-hex-sep1") (v128.const i32x4 0xa0f0099 0xa0f0099 0xa0f0099 0xa0f0099))
+(assert_return (invoke "i32x4-hex-sep2") (v128.const i32x4 0x1aa0f 0x1aa0f 0x1aa0f 0x1aa0f))
+
+(assert_return (invoke "i64x2.test") (v128.const i64x2 841557459837243405 841557459837243405))
+(assert_return (invoke "i64x2.smax") (v128.const i64x2 9223372036854775807 9223372036854775807))
+(assert_return (invoke "i64x2.neg_smax") (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+;; (assert_return (invoke "i64x2.inc_smin") (v128.const i64x2 -9223372036854775807 -9223372036854775807))
+(assert_return (invoke "i64x2.neg_zero") (v128.const i64x2 0 0))
+(assert_return (invoke "i64x2.not_octal") (v128.const i64x2 10010 10010))
+(assert_return (invoke "i64x2.plus_sign") (v128.const i64x2 42 42))
+
+(assert_return (invoke "i64x2-dec-sep1") (v128.const i64x2 10000000000000 10000000000000))
+(assert_return (invoke "i64x2-dec-sep2") (v128.const i64x2 10000000 10000000))
+(assert_return (invoke "i64x2-hex-sep1") (v128.const i64x2 0xa0f00990a0f0099 0xa0f00990a0f0099))
+(assert_return (invoke "i64x2-hex-sep2") (v128.const i64x2 0x1aa0f1aa0f 0x1aa0f1aa0f))
+
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 _100 _100 _100 _100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 +_100 +_100 +_100 +_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 -_100 -_100 -_100 -_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 99_ 99_ 99_ 99_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 1__000 1__000 1__000 1__000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 _0x100 _0x100 _0x100 _0x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 0_x100 0_x100 0_x100 0_x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 0x_100 0x_100 0x_100 0x_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 0x00_ 0x00_ 0x00_ 0x00_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i32x4 0xff__ffff 0xff__ffff 0xff__ffff 0xff__ffff))")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 _100_100 _100_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 +_100_100 +_100_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 -_100_100 -_100_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 99_99_ 99_99_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 1__000_000 1__000_000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 _0x100000 _0x100000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 0_x100000 0_x100000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 0x_100000 0x_100000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 0x00_ 0x00_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const i64x2 0xff__ffff_ffff_ffff 0xff__ffff_ffff_ffff))")
+  "unknown operator"
+)
+
+;; Test floating-point literal parsing.
+
+(module
+  (func (export "f32-dec-sep1") (result v128) (v128.const f32x4 1_000_000 1_000_000 1_000_000 1_000_000))
+  (func (export "f32-dec-sep2") (result v128) (v128.const f32x4 1_0_0_0 1_0_0_0 1_0_0_0 1_0_0_0))
+  (func (export "f32-dec-sep3") (result v128) (v128.const f32x4 100_3.141_592 100_3.141_592 100_3.141_592 100_3.141_592))
+  (func (export "f32-dec-sep4") (result v128) (v128.const f32x4 99e+1_3 99e+1_3 99e+1_3 99e+1_3))
+  (func (export "f32-dec-sep5") (result v128) (v128.const f32x4 122_000.11_3_54E0_2_3 122_000.11_3_54E0_2_3 122_000.11_3_54E0_2_3 122_000.11_3_54E0_2_3))
+  (func (export "f32-hex-sep1") (result v128) (v128.const f32x4 0xa_0f_00_99 0xa_0f_00_99 0xa_0f_00_99 0xa_0f_00_99))
+  (func (export "f32-hex-sep2") (result v128) (v128.const f32x4 0x1_a_A_0_f 0x1_a_A_0_f 0x1_a_A_0_f 0x1_a_A_0_f))
+  (func (export "f32-hex-sep3") (result v128) (v128.const f32x4 0xa0_ff.f141_a59a 0xa0_ff.f141_a59a 0xa0_ff.f141_a59a 0xa0_ff.f141_a59a))
+  (func (export "f32-hex-sep4") (result v128) (v128.const f32x4 0xf0P+1_3 0xf0P+1_3 0xf0P+1_3 0xf0P+1_3))
+  (func (export "f32-hex-sep5") (result v128) (v128.const f32x4 0x2a_f00a.1f_3_eep2_3 0x2a_f00a.1f_3_eep2_3 0x2a_f00a.1f_3_eep2_3 0x2a_f00a.1f_3_eep2_3))
+  (func (export "f64-dec-sep1") (result v128) (v128.const f64x2 1_000_000 1_000_000))
+  (func (export "f64-dec-sep2") (result v128) (v128.const f64x2 1_0_0_0 1_0_0_0))
+  (func (export "f64-dec-sep3") (result v128) (v128.const f64x2 100_3.141_592 100_3.141_592))
+  (func (export "f64-dec-sep4") (result v128) (v128.const f64x2 99e+1_3 99e+1_3))
+  (func (export "f64-dec-sep5") (result v128) (v128.const f64x2 122_000.11_3_54E0_2_3 122_000.11_3_54E0_2_3))
+  (func (export "f64-hex-sep1") (result v128) (v128.const f64x2 0xa_0f_00_99 0xa_0f_00_99))
+  (func (export "f64-hex-sep2") (result v128) (v128.const f64x2 0x1_a_A_0_f 0x1_a_A_0_f))
+  (func (export "f64-hex-sep3") (result v128) (v128.const f64x2 0xa0_ff.f141_a59a 0xa0_ff.f141_a59a))
+  (func (export "f64-hex-sep4") (result v128) (v128.const f64x2 0xf0P+1_3 0xf0P+1_3))
+  (func (export "f64-hex-sep5") (result v128) (v128.const f64x2 0x2a_f00a.1f_3_eep2_3 0x2a_f00a.1f_3_eep2_3))
+)
+
+(assert_return (invoke "f32-dec-sep1") (v128.const f32x4 1000000 1000000 1000000 1000000))
+(assert_return (invoke "f32-dec-sep2") (v128.const f32x4 1000 1000 1000 1000))
+(assert_return (invoke "f32-dec-sep3") (v128.const f32x4 1003.141592 1003.141592 1003.141592 1003.141592))
+(assert_return (invoke "f32-dec-sep4") (v128.const f32x4 99e+13 99e+13 99e+13 99e+13))
+(assert_return (invoke "f32-dec-sep5") (v128.const f32x4 122000.11354e23 122000.11354e23 122000.11354e23 122000.11354e23))
+(assert_return (invoke "f32-hex-sep1") (v128.const f32x4 0xa0f0099 0xa0f0099 0xa0f0099 0xa0f0099))
+(assert_return (invoke "f32-hex-sep2") (v128.const f32x4 0x1aa0f 0x1aa0f 0x1aa0f 0x1aa0f))
+(assert_return (invoke "f32-hex-sep3") (v128.const f32x4 0xa0ff.f141a59a 0xa0ff.f141a59a 0xa0ff.f141a59a 0xa0ff.f141a59a))
+(assert_return (invoke "f32-hex-sep4") (v128.const f32x4 0xf0P+13 0xf0P+13 0xf0P+13 0xf0P+13))
+(assert_return (invoke "f32-hex-sep5") (v128.const f32x4 0x2af00a.1f3eep23 0x2af00a.1f3eep23 0x2af00a.1f3eep23 0x2af00a.1f3eep23))
+(assert_return (invoke "f64-dec-sep1") (v128.const f64x2 1000000 1000000))
+(assert_return (invoke "f64-dec-sep2") (v128.const f64x2 1000 1000))
+(assert_return (invoke "f64-dec-sep3") (v128.const f64x2 1003.141592 1003.141592))
+(assert_return (invoke "f64-dec-sep4") (v128.const f64x2 99e+13 99e+13))
+(assert_return (invoke "f64-dec-sep5") (v128.const f64x2 122000.11354e23 122000.11354e23))
+(assert_return (invoke "f64-hex-sep1") (v128.const f64x2 0xa0f0099 0xa0f0099))
+(assert_return (invoke "f64-hex-sep2") (v128.const f64x2 0x1aa0f 0x1aa0f))
+(assert_return (invoke "f64-hex-sep3") (v128.const f64x2 0xa0ff.f141a59a 0xa0ff.f141a59a))
+(assert_return (invoke "f64-hex-sep4") (v128.const f64x2 0xf0P+13 0xf0P+13))
+(assert_return (invoke "f64-hex-sep5") (v128.const f64x2 0x2af00a.1f3eep23 0x2af00a.1f3eep23))
+
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 _100 _100 _100 _100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 +_100 +_100 +_100 +_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 -_100 -_100 -_100 -_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 99_ 99_ 99_ 99_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1__000 1__000 1__000 1__000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 _1.0 _1.0 _1.0 _1.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0_ 1.0_ 1.0_ 1.0_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1_.0 1_.0 1_.0 1_.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1._0 1._0 1._0 1._0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 _1e1 _1e1 _1e1 _1e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1e1_ 1e1_ 1e1_ 1e1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1_e1 1_e1 1_e1 1_e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1e_1 1e_1 1e_1 1e_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 _1.0e1 _1.0e1 _1.0e1 _1.0e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0e1_ 1.0e1_ 1.0e1_ 1.0e1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0_e1 1.0_e1 1.0_e1 1.0_e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0e_1 1.0e_1 1.0e_1 1.0e_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0e+_1 1.0e+_1 1.0e+_1 1.0e+_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 1.0e_+1 1.0e_+1 1.0e_+1 1.0e_+1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 _0x100 _0x100 _0x100 _0x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0_x100 0_x100 0_x100 0_x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x_100 0x_100 0x_100 0x_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x00_ 0x00_ 0x00_ 0x00_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0xff__ffff 0xff__ffff 0xff__ffff 0xff__ffff))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x_1.0 0x_1.0 0x_1.0 0x_1.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0_ 0x1.0_ 0x1.0_ 0x1.0_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1_.0 0x1_.0 0x1_.0 0x1_.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1._0 0x1._0 0x1._0 0x1._0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x_1p1 0x_1p1 0x_1p1 0x_1p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1p1_ 0x1p1_ 0x1p1_ 0x1p1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1_p1 0x1_p1 0x1_p1 0x1_p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1p_1 0x1p_1 0x1p_1 0x1p_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x_1.0p1 0x_1.0p1 0x_1.0p1 0x_1.0p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0p1_ 0x1.0p1_ 0x1.0p1_ 0x1.0p1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0_p1 0x1.0_p1 0x1.0_p1 0x1.0_p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0p_1 0x1.0p_1 0x1.0p_1 0x1.0p_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0p+_1 0x1.0p+_1 0x1.0p+_1 0x1.0p+_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f32x4 0x1.0p_+1 0x1.0p_+1 0x1.0p_+1 0x1.0p_+1))")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 _100 _100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 +_100 +_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 -_100 -_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 99_ 99_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1__000 1__000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 _1.0 _1.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0_ 1.0_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1_.0 1_.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1._0 1._0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 _1e1 _1e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1e1_ 1e1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1_e1 1_e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1e_1 1e_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 _1.0e1 _1.0e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0e1_ 1.0e1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0_e1 1.0_e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0e_1 1.0e_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0e+_1 1.0e+_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 1.0e_+1 1.0e_+1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 _0x100 _0x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0_x100 0_x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x_100 0x_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x00_ 0x00_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0xff__ffff 0xff__ffff))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x_1.0 0x_1.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0_ 0x1.0_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1_.0 0x1_.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1._0 0x1._0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x_1p1 0x_1p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1p1_ 0x1p1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1_p1 0x1_p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1p_1 0x1p_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x_1.0p1 0x_1.0p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0p1_ 0x1.0p1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0_p1 0x1.0_p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0p_1 0x1.0p_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0p+_1 0x1.0p+_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global v128 (v128.const f64x2 0x1.0p_+1 0x1.0p_+1))")
+  "unknown operator"
+)
+
+;; Test parsing an integer from binary
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\69\38\78\31\36\00\00"  ;; export name (parse_i8x16)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\00\00\00\00"                             ;; data lane 0~3   (0,    0,    0,    0)
+  "\80\80\80\80"                             ;; data lane 4~7   (-128, -128, -128, -128)
+  "\ff\ff\ff\ff"                             ;; data lane 8~11  (0xff, 0xff, 0xff, 0xff)
+  "\ff\ff\ff\ff"                             ;; data lane 12~15 (255,  255,  255,  255)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_i8x16") (v128.const i8x16 0 0 0 0 -128 -128 -128 -128 0xff 0xff 0xff 0xff 255 255 255 255))
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\69\31\36\78\38\00\00"  ;; export name (parse_i16x8)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\00\00\00\00"                             ;; data lane 0, 1 (0,      0)
+  "\00\80\00\80"                             ;; data lane 2, 3 (-32768, -32768)
+  "\ff\ff\ff\ff"                             ;; data lane 4, 5 (65535,  65535)
+  "\ff\ff\ff\ff"                             ;; data lane 6, 7 (0xffff, 0xffff)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_i16x8") (v128.const i16x8 0 0 -32768 -32768 65535 65535 0xffff 0xffff))
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\69\33\32\78\34\00\00"  ;; export name (parse_i32x4)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\d1\ff\ff\ff"                             ;; data lane 0 (4294967249)
+  "\d1\ff\ff\ff"                             ;; data lane 1 (4294967249)
+  "\d1\ff\ff\ff"                             ;; data lane 2 (4294967249)
+  "\d1\ff\ff\ff"                             ;; data lane 3 (4294967249)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_i32x4") (v128.const i32x4 4294967249 4294967249 4294967249 4294967249))
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\69\36\34\78\32\00\00"  ;; export name (parse_i64x2)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\ff\ff\ff\ff\ff\ff\ff\7f"                 ;; data lane 0 (9223372036854775807)
+  "\ff\ff\ff\ff\ff\ff\ff\7f"                 ;; data lane 1 (9223372036854775807)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_i64x2") (v128.const i64x2 9223372036854775807 9223372036854775807))
+
+;; Test parsing a float from binary
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\66\33\32\78\34\00\00"  ;; export name (parse_f32x4)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\00\00\80\4f"                             ;; data lane 0 (4294967249)
+  "\00\00\80\4f"                             ;; data lane 1 (4294967249)
+  "\00\00\80\4f"                             ;; data lane 2 (4294967249)
+  "\00\00\80\4f"                             ;; data lane 3 (4294967249)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_f32x4") (v128.const f32x4 4294967249 4294967249 4294967249 4294967249))
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\01\05\01"                                ;; type   section
+  "\60\00\01\7b"                             ;; type 0 (func)
+  "\03\02\01\00"                             ;; func   section
+  "\07\0f\01\0b"                             ;; export section
+  "\70\61\72\73\65\5f\66\36\34\78\32\00\00"  ;; export name (parse_f64x2)
+  "\0a\16\01"                                ;; code   section
+  "\14\00\fd\0c"                             ;; func body
+  "\ff\ff\ff\ff\ff\ff\ef\7f"                 ;; data lane 0 (0x1.fffffffffffffp+1023)
+  "\ff\ff\ff\ff\ff\ff\ef\7f"                 ;; data lane 1 (0x1.fffffffffffffp+1023)
+  "\0b"                                      ;; end
+)
+(assert_return (invoke "parse_f64x2") (v128.const f64x2 0x1.fffffffffffffp+1023 0x1.fffffffffffffp+1023))
diff --git a/tests/misc_testsuite/winch/_simd_linking.wast b/tests/misc_testsuite/winch/_simd_linking.wast
new file mode 100644
index 000000000000..1a1d16355e9a
--- /dev/null
+++ b/tests/misc_testsuite/winch/_simd_linking.wast
@@ -0,0 +1,12 @@
+(module
+  (global (export "g-v128") v128 (v128.const i64x2 0 0))
+  (global (export "mg-v128") (mut v128) (v128.const i64x2 0 0))
+)
+(register "Mv128")
+
+(module
+  ;; TODO: Reactivate once the fix for https://bugs.chromium.org/p/v8/issues/detail?id=13732
+  ;; has made it to the downstream node.js that we use on CI.
+  ;; (import "Mv128" "g-v128" (global v128))
+  (import "Mv128" "mg-v128" (global (mut v128)))
+)
diff --git a/tests/misc_testsuite/winch/_simd_load.wast b/tests/misc_testsuite/winch/_simd_load.wast
new file mode 100644
index 000000000000..907b7cc2eaf3
--- /dev/null
+++ b/tests/misc_testsuite/winch/_simd_load.wast
@@ -0,0 +1,188 @@
+;; v128.load operater with normal argument (e.g. (i8x16, i16x8 i32x4))
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+  (func (export "v128.load") (result v128)
+    (v128.load (i32.const 0))
+  )
+)
+
+(assert_return (invoke "v128.load") (v128.const i8x16 0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f))
+(assert_return (invoke "v128.load") (v128.const i16x8 0x0100 0x0302 0x0504 0x0706 0x0908 0x0b0a 0x0d0c 0x0f0e))
+(assert_return (invoke "v128.load") (v128.const i32x4 0x03020100 0x07060504 0x0b0a0908 0x0f0e0d0c))
+
+
+;; v128.load operater as the argument of other SIMD instructions
+
+;; (module (memory 1)
+;;   (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+;;   (func (export "as-i8x16_extract_lane_s-value/0") (result i32)
+;;     (i8x16.extract_lane_s 0 (v128.load (i32.const 0)))
+;;   )
+;; )
+;; (assert_return (invoke "as-i8x16_extract_lane_s-value/0") (i32.const 0x00))
+
+;; (module (memory 1)
+;;   (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+;;   (func (export "as-i8x16.eq-operand") (result v128)
+;;     (i8x16.eq (v128.load offset=0 (i32.const 0)) (v128.load offset=16 (i32.const 0)))
+;;   )
+;; )
+;; (assert_return (invoke "as-i8x16.eq-operand") (v128.const i32x4 0xffffffff 0x00000000 0x00000000 0x00000000))
+
+;; (module (memory 1)
+;;   (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+;;   (func (export "as-v128.not-operand") (result v128)
+;;     (v128.not (v128.load (i32.const 0)))
+;;   )
+;;   (func (export "as-i8x16.all_true-operand") (result i32)
+;;     (i8x16.all_true (v128.load (i32.const 0)))
+;;   )
+;; )
+;; (assert_return (invoke "as-v128.not-operand") (v128.const i32x4 0xfcfdfeff 0xf8f9fafb 0xf4f5f6f7 0xf0f1f2f3))
+;; (assert_return (invoke "as-i8x16.all_true-operand") (i32.const 0))
+
+;; (module (memory 1)
+;;   (data (offset (i32.const 0))  "\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA")
+;;   (data (offset (i32.const 16)) "\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB\BB")
+;;   (data (offset (i32.const 32)) "\F0\F0\F0\F0\FF\FF\FF\FF\00\00\00\00\FF\00\FF\00")
+;;   (func (export "as-v128.bitselect-operand") (result v128)
+;;     (v128.bitselect (v128.load (i32.const 0)) (v128.load (i32.const 16)) (v128.load (i32.const 32)))
+;;   )
+;; )
+;; (assert_return (invoke "as-v128.bitselect-operand") (v128.const i32x4 0xabababab 0xaaaaaaaa 0xbbbbbbbb 0xbbaabbaa))
+
+;; (module (memory 1)
+;;   (data (offset (i32.const 0)) "\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA")
+;;   (func (export "as-i8x16.shl-operand") (result v128)
+;;     (i8x16.shl (v128.load (i32.const 0)) (i32.const 1))
+;;   )
+;; )
+;; (assert_return (invoke "as-i8x16.shl-operand") (v128.const i32x4 0x54545454 0x54545454 0x54545454 0x54545454)) ;; 1010 1000 << 1010 1010
+
+;; (module (memory 1)
+;;   (data (offset (i32.const 0))  "\02\00\00\00\02\00\00\00\02\00\00\00\02\00\00\00")
+;;   (data (offset (i32.const 16)) "\03\00\00\00\03\00\00\00\03\00\00\00\03\00\00\00")
+;;   (func (export "as-add/sub-operand") (result v128)
+;;     ;; 2 2 2 2 + 3 3 3 3 = 5 5 5 5
+;;     ;; 5 5 5 5 - 3 3 3 3 = 2 2 2 2
+;;     (i8x16.sub
+;;       (i8x16.add (v128.load (i32.const 0)) (v128.load (i32.const 16)))
+;;       (v128.load (i32.const 16))
+;;     )
+;;   )
+;; )
+;; (assert_return (invoke "as-add/sub-operand") (v128.const i32x4 2 2 2 2))
+
+;; (module (memory 1)
+;;   (data (offset (i32.const 0))  "\00\00\00\43\00\00\80\3f\66\66\e6\3f\00\00\80\bf")  ;; 128 1.0 1.8 -1
+;;   (data (offset (i32.const 16)) "\00\00\00\40\00\00\00\40\00\00\00\40\00\00\00\40")  ;; 2.0 2.0 2.0 2.0
+;;   (func (export "as-f32x4.mul-operand") (result v128)
+;;     (f32x4.mul (v128.load (i32.const 0)) (v128.load (i32.const 16)))
+;;   )
+;; )
+;; (assert_return (invoke "as-f32x4.mul-operand") (v128.const f32x4 256 2 3.6 -2))
+
+;; (module (memory 1)
+;;   (data (offset (i32.const 0)) "\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff")  ;; 1111 ...
+;;   (func (export "as-f32x4.abs-operand") (result v128)
+;;     (f32x4.abs (v128.load (i32.const 0)))
+;;   )
+;; )
+;; (assert_return (invoke "as-f32x4.abs-operand") (v128.const i32x4 0x7fffffff 0x7fffffff 0x7fffffff 0x7fffffff)) ;; 1111 -> 0111
+
+;; (module (memory 1)
+;;   (data (offset (i32.const 0)) "\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA\AA")
+;;   (data (offset (i32.const 16)) "\02\00\00\00\02\00\00\00\02\00\00\00\02\00\00\00")
+;;   (func (export "as-f32x4.min-operand") (result v128)
+;;     (f32x4.min (v128.load (i32.const 0)) (v128.load offset=16 (i32.const 1)))
+;;   )
+;; )
+;; (assert_return (invoke "as-f32x4.min-operand") (v128.const i32x4 0xaaaaaaaa 0xaaaaaaaa 0xaaaaaaaa 0xaaaaaaaa)) ;; signed 1010 < 0010
+
+;; (module (memory 1)
+;;   (data (offset (i32.const 0))  "\00\00\00\43\00\00\80\3f\66\66\e6\3f\00\00\80\bf")  ;; 128 1.0 1.8 -1
+;;   (func (export "as-i32x4.trunc_sat_f32x4_s-operand") (result v128)
+;;     (i32x4.trunc_sat_f32x4_s (v128.load (i32.const 0)))
+;;   )
+;; )
+;; (assert_return (invoke "as-i32x4.trunc_sat_f32x4_s-operand") (v128.const i32x4 128 1 1 -1)) ;; 128 1.0 1.8 -1 -> 128 1 1 -1
+
+;; (module (memory 1)
+;;   (data (offset (i32.const 0)) "\02\00\00\00\02\00\00\00\02\00\00\00\02\00\00\00")
+;;   (func (export "as-f32x4.convert_i32x4_u-operand") (result v128)
+;;     (f32x4.convert_i32x4_u (v128.load (i32.const 0)))
+;;   )
+;; )
+;; (assert_return (invoke "as-f32x4.convert_i32x4_u-operand") (v128.const f32x4 2 2 2 2))
+
+;; (module (memory 1)
+;;   (data (offset (i32.const 0)) "\64\65\66\67\68\69\6a\6b\6c\6d\6e\6f\70\71\72\73")  ;; 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115
+;;   (data (offset (i32.const 16)) "\0f\0e\0d\0c\0b\0a\09\08\07\06\05\04\03\02\01\00")  ;;  15  14  13  12  11  10  09  08  07  06  05  04  03  02  01  00
+;;   (func (export "as-i8x16.swizzle-operand") (result v128)
+;;     (i8x16.swizzle (v128.load (i32.const 0)) (v128.load offset=15 (i32.const 1)))
+;;   )
+;; )
+;; (assert_return(invoke "as-i8x16.swizzle-operand") (v128.const i8x16 115 114 113 112 111 110 109 108 107 106 105 104 103 102 101 100))
+
+(module (memory 1)
+  (data (i32.const 0) "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f\00\01\02\03")
+  (func (export "as-br-value") (result v128)
+    (block (result v128) (br 0 (v128.load (i32.const 0))))
+  )
+)
+(assert_return (invoke "as-br-value") (v128.const i32x4 0x03020100 0x07060504 0x0b0a0908 0x0f0e0d0c))
+
+
+;; Unknown operator(e.g. v128.load8, v128.load16, v128.load32)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (local v128) (drop (v128.load8 (i32.const 0))))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (local v128) (drop (v128.load16 (i32.const 0))))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (local v128) (drop (v128.load32 (i32.const 0))))"
+  )
+  "unknown operator"
+)
+
+
+;; Type mismatched (e.g. v128.load(f32.const 0), type address empty)
+
+(assert_invalid
+  (module (memory 1) (func (local v128) (drop (v128.load (f32.const 0)))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (local v128) (block (br_if 0 (v128.load (i32.const 0))))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (local v128) (v128.load (i32.const 0))))
+  "type mismatch"
+)
+
+
+;; Type address empty
+
+(assert_invalid
+  (module (memory 1) (func (drop (v128.load (local.get 2)))))
+  "unknown local 2"
+)
+(assert_invalid
+  (module (memory 1) (func (drop (v128.load))))
+  "type mismatch"
+)
\ No newline at end of file
diff --git a/tests/misc_testsuite/winch/_simd_multivalue.wast b/tests/misc_testsuite/winch/_simd_multivalue.wast
new file mode 100644
index 000000000000..c4f70f2318e8
--- /dev/null
+++ b/tests/misc_testsuite/winch/_simd_multivalue.wast
@@ -0,0 +1,3 @@
+;; test that swapping the parameters results in swapped return values
+(module (func (export "f") (param v128) (param v128) (result v128) (result v128) (local.get 1) (local.get 0)))
+(assert_return (invoke "f" (v128.const i64x2 2 1) (v128.const i64x2 1 2)) (v128.const i64x2 1 2) (v128.const i64x2 2 1))
\ No newline at end of file
diff --git a/tests/misc_testsuite/winch/_simd_store.wast b/tests/misc_testsuite/winch/_simd_store.wast
new file mode 100644
index 000000000000..50349c41bd82
--- /dev/null
+++ b/tests/misc_testsuite/winch/_simd_store.wast
@@ -0,0 +1,166 @@
+;; v128.store operater with normal argument (e.g. (i8x16, i16x8, i32x4, f32x4))
+
+(module
+  (memory 1)
+  (func (export "v128.store_i8x16") (result v128)
+    (v128.store (i32.const 0) (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i16x8") (result v128)
+    (v128.store (i32.const 0) (v128.const i16x8 0 1 2 3 4 5 6 7))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i16x8_2") (result v128)
+    (v128.store (i32.const 0) (v128.const i16x8 012_345 012_345 012_345 012_345 012_345 012_345 012_345 012_345))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i16x8_3") (result v128)
+    (v128.store (i32.const 0) (v128.const i16x8 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234 0x0_1234))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i32x4") (result v128)
+    (v128.store (i32.const 0) (v128.const i32x4 0 1 2 3))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i32x4_2") (result v128)
+    (v128.store (i32.const 0) (v128.const i32x4 0_123_456_789 0_123_456_789 0_123_456_789 0_123_456_789))
+    (v128.load (i32.const 0))
+  )
+  (func (export "v128.store_i32x4_3") (result v128)
+    (v128.store (i32.const 0) (v128.const i32x4 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678 0x0_1234_5678))
+    (v128.load (i32.const 0))
+  )
+
+  (func (export "v128.store_f32x4") (result v128)
+    (v128.store (i32.const 0) (v128.const f32x4 0 1 2 3))
+    (v128.load (i32.const 0))
+  )
+)
+
+(assert_return (invoke "v128.store_i8x16") (v128.const i8x16 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15))
+(assert_return (invoke "v128.store_i16x8") (v128.const i16x8 0 1 2 3 4 5 6 7))
+(assert_return (invoke "v128.store_i16x8_2") (v128.const i16x8 12345 12345 12345 12345 12345 12345 12345 12345))
+(assert_return (invoke "v128.store_i16x8_3") (v128.const i16x8 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234 0x1234))
+(assert_return (invoke "v128.store_i32x4") (v128.const i32x4 0 1 2 3))
+(assert_return (invoke "v128.store_i32x4_2") (v128.const i32x4 123456789 123456789 123456789 123456789))
+(assert_return (invoke "v128.store_i32x4_3") (v128.const i32x4 0x12345678 0x12345678 0x12345678 0x12345678))
+(assert_return (invoke "v128.store_f32x4") (v128.const f32x4 0 1 2 3))
+
+
+;; v128.store operator as the argument of control constructs and instructions
+
+(module
+  (memory 1)
+  (func (export "as-block-value")
+    (block (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)))
+  )
+  (func (export "as-loop-value")
+    (loop (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)))
+  )
+  (func (export "as-br-value")
+    (block (br 0 (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0))))
+  )
+  (func (export "as-br_if-value")
+    (block
+      (br_if 0 (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)) (i32.const 1))
+    )
+  )
+  (func (export "as-br_if-value-cond")
+    (block
+      (br_if 0 (i32.const 6) (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)))
+    )
+  )
+  (func (export "as-br_table-value")
+    (block
+      (br_table 0 (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)) (i32.const 1))
+    )
+  )
+  (func (export "as-return-value")
+    (return (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0)))
+  )
+  (func (export "as-if-then")
+    (if (i32.const 1) (then (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0))))
+  )
+  (func (export "as-if-else")
+    (if (i32.const 0) (then) (else (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0))))
+  )
+)
+
+(assert_return (invoke "as-block-value"))
+(assert_return (invoke "as-loop-value"))
+(assert_return (invoke "as-br-value"))
+(assert_return (invoke "as-br_if-value"))
+(assert_return (invoke "as-br_if-value-cond"))
+(assert_return (invoke "as-br_table-value"))
+(assert_return (invoke "as-return-value"))
+(assert_return (invoke "as-if-then"))
+(assert_return (invoke "as-if-else"))
+
+
+;; Unknown operator(e.g. v128.store8, v128.store16, v128.store32)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (v128.store8 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (v128.store16 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (v128.store32 (i32.const 0) (v128.const i32x4 0 0 0 0)))"
+  )
+  "unknown operator"
+)
+
+
+;; Type mismatched (e.g. v128.load(f32.const 0), type address empty)
+
+(assert_invalid
+  (module (memory 1) (func (v128.store (f32.const 0) (v128.const i32x4 0 0 0 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (local v128) (block (br_if 0 (v128.store)))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (result v128) (v128.store (i32.const 0) (v128.const i32x4 0 0 0 0))))
+  "type mismatch"
+)
+
+
+;; Test operation with empty argument
+
+(assert_invalid
+  (module (memory 0)
+    (func $v128.store-1st-arg-empty
+      (v128.store (v128.const i32x4 0 0 0 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.store-2nd-arg-empty
+      (v128.store (i32.const 0))
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 0)
+    (func $v128.store-arg-empty
+      (v128.store)
+    )
+  )
+  "type mismatch"
+)
diff --git a/tests/misc_testsuite/winch/block.wast b/tests/misc_testsuite/winch/block.wast
deleted file mode 100644
index 6a1a9c65e0da..000000000000
--- a/tests/misc_testsuite/winch/block.wast
+++ /dev/null
@@ -1,198 +0,0 @@
-;; Test `block` operator
-
-(module
-  ;; Auxiliary definition
-  (memory 1)
-
-  (func $dummy)
-
-  (func (export "empty")
-    (block)
-    (block $l)
-  )
-
-  (func (export "singular") (result i32)
-    (block (nop))
-    (block (result i32) (i32.const 7))
-  )
-
-  (func (export "nested") (result i32)
-    (block (result i32)
-      (block (call $dummy) (block) (nop))
-      (block (result i32) (call $dummy) (i32.const 9))
-    )
-  )
-
-  (func (export "as-br_table-first") (result i32)
-    (block (result i32) (block (result i32) (i32.const 1)) (i32.const 2) (br_table 0 0))
-  )
-  (func (export "as-br_table-last") (result i32)
-    (block (result i32) (i32.const 2) (block (result i32) (i32.const 1)) (br_table 0 0))
-  )
-
-  (func (export "break-bare") (result i32)
-    (block (br 0) (unreachable))
-    (block (br_if 0 (i32.const 1)) (unreachable))
-    (block (br_table 0 (i32.const 0)) (unreachable))
-    (block (br_table 0 0 0 (i32.const 1)) (unreachable))
-    (i32.const 19)
-  )
-
-  (func (export "break-repeated") (result i32)
-    (block (result i32)
-      (br 0 (i32.const 18))
-      (br 0 (i32.const 19))
-      (drop (br_if 0 (i32.const 20) (i32.const 0)))
-      (drop (br_if 0 (i32.const 20) (i32.const 1)))
-      (br 0 (i32.const 21))
-      (br_table 0 (i32.const 22) (i32.const 4))
-      (br_table 0 0 0 (i32.const 23) (i32.const 1))
-      (i32.const 21)
-    )
-  )
-
-  (func (export "deep") (result i32)
-    (block (result i32) (block (result i32)
-      (block (result i32) (block (result i32)
-        (block (result i32) (block (result i32)
-          (block (result i32) (block (result i32)
-            (block (result i32) (block (result i32)
-              (block (result i32) (block (result i32)
-                (block (result i32) (block (result i32)
-                  (block (result i32) (block (result i32)
-                    (block (result i32) (block (result i32)
-                      (block (result i32) (block (result i32)
-                        (block (result i32) (block (result i32)
-                          (block (result i32) (block (result i32)
-                            (block (result i32) (block (result i32)
-                              (block (result i32) (block (result i32)
-                                (block (result i32) (block (result i32)
-                                  (block (result i32) (block (result i32)
-                                    (block (result i32) (block (result i32)
-                                      (block (result i32) (block (result i32)
-                                        (block (result i32) (block (result i32)
-                                          (call $dummy) (i32.const 150)
-                                        ))
-                                      ))
-                                    ))
-                                  ))
-                                ))
-                              ))
-                            ))
-                          ))
-                        ))
-                      ))
-                    ))
-                  ))
-                ))
-              ))
-            ))
-          ))
-        ))
-      ))
-    ))
-  )
-
-  (func (export "as-if-condition")
-    (block (result i32) (i32.const 1)) (if (then (call $dummy)))
-  )
-  (func (export "as-if-then") (result i32)
-    (if (result i32) (i32.const 1) (then (block (result i32) (i32.const 1))) (else (i32.const 2)))
-  )
-  (func (export "as-if-else") (result i32)
-    (if (result i32) (i32.const 1) (then (i32.const 2)) (else (block (result i32) (i32.const 1))))
-  )
-
-  (func (export "as-br_if-first") (result i32)
-    (block (result i32) (br_if 0 (block (result i32) (i32.const 1)) (i32.const 2)))
-  )
-  (func (export "as-br_if-last") (result i32)
-    (block (result i32) (br_if 0 (i32.const 2) (block (result i32) (i32.const 1))))
-  )
-
-
-  (func $f (param i32) (result i32) (local.get 0))
-
-  (func (export "as-call-value") (result i32)
-    (call $f (block (result i32) (i32.const 1)))
-  )
-  (func (export "as-return-value") (result i32)
-    (block (result i32) (i32.const 1)) (return)
-  )
-  (func (export "as-drop-operand")
-    (drop (block (result i32) (i32.const 1)))
-  )
-  (func (export "as-br-value") (result i32)
-    (block (result i32) (br 0 (block (result i32) (i32.const 1))))
-  )
-  (func (export "as-local.set-value") (result i32)
-    (local i32) (local.set 0 (block (result i32) (i32.const 1))) (local.get 0)
-  )
-
-  (func (export "as-unary-operand") (result i32)
-    (i32.ctz (block (result i32) (call $dummy) (i32.const 13)))
-  )
-  (func (export "as-binary-operand") (result i32)
-    (i32.mul
-      (block (result i32) (call $dummy) (i32.const 3))
-      (block (result i32) (call $dummy) (i32.const 4))
-    )
-  )
-  (func (export "as-test-operand") (result i32)
-    (i32.eqz (block (result i32) (call $dummy) (i32.const 13)))
-  )
-  (func (export "break-value") (result i32)
-    (block (result i32) (br 0 (i32.const 18)) (i32.const 19))
-  )
-  (func (export "break-inner") (result i32)
-    (local i32)
-    (local.set 0 (i32.const 0))
-    (local.set 0 (i32.add (local.get 0) (block (result i32) (block (result i32) (br 1 (i32.const 0x1))))))
-    (local.set 0 (i32.add (local.get 0) (block (result i32) (block (br 0)) (i32.const 0x2))))
-    (local.set 0
-      (i32.add (local.get 0) (block (result i32) (i32.ctz (br 0 (i32.const 0x4)))))
-    )
-    (local.set 0
-      (i32.add (local.get 0) (block (result i32) (i32.ctz (block (result i32) (br 1 (i32.const 0x8))))))
-    )
-    (local.get 0)
-  )
-
-  (func (export "effects") (result i32)
-    (local i32)
-    (block
-      (local.set 0 (i32.const 1))
-      (local.set 0 (i32.mul (local.get 0) (i32.const 3)))
-      (local.set 0 (i32.sub (local.get 0) (i32.const 5)))
-      (local.set 0 (i32.mul (local.get 0) (i32.const 7)))
-      (br 0)
-      (local.set 0 (i32.mul (local.get 0) (i32.const 100)))
-    )
-    (i32.eq (local.get 0) (i32.const -14))
-  )
-)
-
-(assert_return (invoke "empty"))
-(assert_return (invoke "singular") (i32.const 7))
-(assert_return (invoke "nested") (i32.const 9))
-(assert_return (invoke "deep") (i32.const 150))
-(assert_return (invoke "as-if-condition"))
-(assert_return (invoke "as-if-then") (i32.const 1))
-(assert_return (invoke "as-if-else") (i32.const 2))
-(assert_return (invoke "as-br_if-first") (i32.const 1))
-(assert_return (invoke "as-br_if-last") (i32.const 2))
-(assert_return (invoke "as-call-value") (i32.const 1))
-(assert_return (invoke "as-return-value") (i32.const 1))
-(assert_return (invoke "as-drop-operand"))
-(assert_return (invoke "as-br-value") (i32.const 1))
-(assert_return (invoke "as-local.set-value") (i32.const 1))
-(assert_return (invoke "as-unary-operand") (i32.const 0))
-(assert_return (invoke "as-binary-operand") (i32.const 12))
-(assert_return (invoke "as-test-operand") (i32.const 0))
-(assert_return (invoke "break-inner") (i32.const 0xf))
-(assert_return (invoke "effects") (i32.const 1))
-
-(assert_return (invoke "as-br_table-first") (i32.const 1))
-(assert_return (invoke "as-br_table-last") (i32.const 2))
-(assert_return (invoke "break-bare") (i32.const 19))
-(assert_return (invoke "break-repeated") (i32.const 18))
diff --git a/tests/misc_testsuite/winch/br.wast b/tests/misc_testsuite/winch/br.wast
deleted file mode 100644
index 012c203a4e4a..000000000000
--- a/tests/misc_testsuite/winch/br.wast
+++ /dev/null
@@ -1,262 +0,0 @@
-;; Test `br` operator
-
-(module
-  ;; Auxiliary definition
-  (func $dummy)
-
-  (func (export "type-i32-value") (result i32)
-    (block (result i32) (i32.ctz (br 0 (i32.const 1))))
-  )
-  (func (export "type-i64-value") (result i64)
-    (block (result i64) (i64.ctz (br 0 (i64.const 2))))
-  )
-
-  (func (export "as-block-first")
-    (block (br 0) (call $dummy))
-  )
-  (func (export "as-block-mid")
-    (block (call $dummy) (br 0) (call $dummy))
-  )
-  (func (export "as-block-last")
-    (block (nop) (call $dummy) (br 0))
-  )
-  (func (export "as-block-value") (result i32)
-    (block (result i32) (nop) (call $dummy) (br 0 (i32.const 2)))
-  )
-
-  (func (export "as-loop-first") (result i32)
-    (block (result i32) (loop (result i32) (br 1 (i32.const 3)) (i32.const 2)))
-  )
-  (func (export "as-loop-mid") (result i32)
-    (block (result i32)
-      (loop (result i32) (call $dummy) (br 1 (i32.const 4)) (i32.const 2))
-    )
-  )
-  (func (export "as-loop-last") (result i32)
-    (block (result i32)
-      (loop (result i32) (nop) (call $dummy) (br 1 (i32.const 5)))
-    )
-  )
-
-  (func (export "as-br-value") (result i32)
-    (block (result i32) (br 0 (br 0 (i32.const 9))))
-  )
-
-  (func (export "as-br_if-cond")
-    (block (br_if 0 (br 0)))
-  )
-
-  (func (export "as-br_if-value") (result i32)
-    (block (result i32)
-      (drop (br_if 0 (br 0 (i32.const 8)) (i32.const 1))) (i32.const 7)
-    )
-  )
-  (func (export "as-br_if-value-cond") (result i32)
-    (block (result i32)
-      (drop (br_if 0 (i32.const 6) (br 0 (i32.const 9)))) (i32.const 7)
-    )
-  )
-
-  (func (export "as-return-value") (result i64)
-    (block (result i64) (return (br 0 (i64.const 7))))
-  )
-
-  (func (export "as-if-cond") (result i32)
-    (block (result i32)
-      (if (result i32) (br 0 (i32.const 2))
-        (then (i32.const 0))
-        (else (i32.const 1))
-      )
-    )
-  )
-  (func (export "as-if-then") (param i32 i32) (result i32)
-    (block (result i32)
-      (if (result i32) (local.get 0)
-        (then (br 1 (i32.const 3)))
-        (else (local.get 1))
-      )
-    )
-  )
-  (func (export "as-if-else") (param i32 i32) (result i32)
-    (block (result i32)
-      (if (result i32) (local.get 0)
-        (then (local.get 1))
-        (else (br 1 (i32.const 4)))
-      )
-    )
-  )
-
-
-  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
-  (func (export "as-call-first") (result i32)
-    (block (result i32)
-      (call $f (br 0 (i32.const 12)) (i32.const 2) (i32.const 3))
-    )
-  )
-  (func (export "as-call-mid") (result i32)
-    (block (result i32)
-      (call $f (i32.const 1) (br 0 (i32.const 13)) (i32.const 3))
-    )
-  )
-  (func (export "as-call-last") (result i32)
-    (block (result i32)
-      (call $f (i32.const 1) (i32.const 2) (br 0 (i32.const 14)))
-    )
-  )
-  (func (export "as-call-all") (result i32)
-    (block (result i32) (call $f (br 0 (i32.const 15))))
-  )
-
-  (func (export "as-binary-left") (result i32)
-    (block (result i32) (i32.add (br 0 (i32.const 3)) (i32.const 10)))
-  )
-  (func (export "as-binary-right") (result i64)
-    (block (result i64) (i64.sub (i64.const 10) (br 0 (i64.const 45))))
-  )
-  (func (export "as-binary-both") (result i32)
-    (block (result i32) (i32.add (br 0 (i32.const 46))))
-  )
-
-  (func (export "as-test-operand") (result i32)
-    (block (result i32) (i32.eqz (br 0 (i32.const 44))))
-  )
-
-  (func (export "nested-block-value") (result i32)
-    (i32.add
-      (i32.const 1)
-      (block (result i32)
-        (call $dummy)
-        (i32.add (i32.const 4) (br 0 (i32.const 8)))
-      )
-    )
-  )
-
-  (func (export "nested-br-value") (result i32)
-    (i32.add
-      (i32.const 1)
-      (block (result i32)
-        (drop (i32.const 2))
-        (drop
-          (block (result i32)
-            (drop (i32.const 4))
-            (br 0 (br 1 (i32.const 8)))
-          )
-        )
-        (i32.const 16)
-      )
-    )
-  )
-
-  (func (export "nested-br_if-value") (result i32)
-    (i32.add
-      (i32.const 1)
-      (block (result i32)
-        (drop (i32.const 2))
-        (drop
-          (block (result i32)
-            (drop (i32.const 4))
-            (drop (br_if 0 (br 1 (i32.const 8)) (i32.const 1)))
-            (i32.const 32)
-          )
-        )
-        (i32.const 16)
-      )
-    )
-  )
-
-  (func (export "nested-br_if-value-cond") (result i32)
-    (i32.add
-      (i32.const 1)
-      (block (result i32)
-        (drop (i32.const 2))
-        (drop (br_if 0 (i32.const 4) (br 0 (i32.const 8))))
-        (i32.const 16)
-      )
-    )
-  )
-
-  (func (export "as-br_table-index")
-    (block (br_table 0 0 0 (br 0)))
-  )
-  (func (export "as-br_table-value") (result i32)
-    (block (result i32)
-      (br_table 0 0 0 (br 0 (i32.const 10)) (i32.const 1)) (i32.const 7)
-    )
-  )
-  (func (export "as-br_table-value-index") (result i32)
-    (block (result i32)
-      (br_table 0 0 (i32.const 6) (br 0 (i32.const 11))) (i32.const 7)
-    )
-  )
-
-  (func (export "nested-br_table-value") (result i32)
-    (i32.add
-      (i32.const 1)
-      (block (result i32)
-        (drop (i32.const 2))
-        (drop
-          (block (result i32)
-            (drop (i32.const 4))
-            (br_table 0 (br 1 (i32.const 8)) (i32.const 1))
-          )
-        )
-        (i32.const 16)
-      )
-    )
-  )
-
-  (func (export "nested-br_table-value-index") (result i32)
-    (i32.add
-      (i32.const 1)
-      (block (result i32)
-        (drop (i32.const 2))
-        (br_table 0 (i32.const 4) (br 0 (i32.const 8)))
-        (i32.const 16)
-      )
-    )
-  )
-)
-
-(assert_return (invoke "type-i32-value") (i32.const 1))
-(assert_return (invoke "type-i64-value") (i64.const 2))
-(assert_return (invoke "as-block-first"))
-(assert_return (invoke "as-block-mid"))
-(assert_return (invoke "as-block-last"))
-(assert_return (invoke "as-block-value") (i32.const 2))
-(assert_return (invoke "as-loop-first") (i32.const 3))
-(assert_return (invoke "as-loop-mid") (i32.const 4))
-(assert_return (invoke "as-loop-last") (i32.const 5))
-(assert_return (invoke "as-br-value") (i32.const 9))
-(assert_return (invoke "as-br_if-cond"))
-(assert_return (invoke "as-br_if-value") (i32.const 8))
-(assert_return (invoke "as-br_if-value-cond") (i32.const 9))
-(assert_return (invoke "as-return-value") (i64.const 7))
-
-(assert_return (invoke "as-if-cond") (i32.const 2))
-(assert_return (invoke "as-if-then" (i32.const 1) (i32.const 6)) (i32.const 3))
-(assert_return (invoke "as-if-then" (i32.const 0) (i32.const 6)) (i32.const 6))
-(assert_return (invoke "as-if-else" (i32.const 0) (i32.const 6)) (i32.const 4))
-(assert_return (invoke "as-if-else" (i32.const 1) (i32.const 6)) (i32.const 6))
-
-(assert_return (invoke "as-call-first") (i32.const 12))
-(assert_return (invoke "as-call-mid") (i32.const 13))
-(assert_return (invoke "as-call-last") (i32.const 14))
-(assert_return (invoke "as-call-all") (i32.const 15))
-
-
-(assert_return (invoke "as-binary-left") (i32.const 3))
-(assert_return (invoke "as-binary-right") (i64.const 45))
-(assert_return (invoke "as-binary-both") (i32.const 46))
-
-(assert_return (invoke "as-test-operand") (i32.const 44))
-
-(assert_return (invoke "nested-block-value") (i32.const 9))
-(assert_return (invoke "nested-br-value") (i32.const 9))
-(assert_return (invoke "nested-br_if-value") (i32.const 9))
-(assert_return (invoke "nested-br_if-value-cond") (i32.const 9))
-
-(assert_return (invoke "as-br_table-index"))
-(assert_return (invoke "as-br_table-value") (i32.const 10))
-(assert_return (invoke "as-br_table-value-index") (i32.const 11))
-(assert_return (invoke "nested-br_table-value") (i32.const 9))
-(assert_return (invoke "nested-br_table-value-index") (i32.const 9))
diff --git a/tests/misc_testsuite/winch/br_if.wast b/tests/misc_testsuite/winch/br_if.wast
deleted file mode 100644
index b2957525f9fb..000000000000
--- a/tests/misc_testsuite/winch/br_if.wast
+++ /dev/null
@@ -1,317 +0,0 @@
-;; Test `br_if` operator
-
-(module
-  (func $dummy)
-
-  (func (export "type-i32-value") (result i32)
-    (block (result i32) (i32.ctz (br_if 0 (i32.const 1) (i32.const 1))))
-  )
-  (func (export "type-i64-value") (result i64)
-    (block (result i64) (i64.ctz (br_if 0 (i64.const 2) (i32.const 1))))
-  )
-
-  (func (export "as-block-first") (param i32) (result i32)
-    (block (br_if 0 (local.get 0)) (return (i32.const 2))) (i32.const 3)
-  )
-  (func (export "as-block-mid") (param i32) (result i32)
-    (block (call $dummy) (br_if 0 (local.get 0)) (return (i32.const 2)))
-    (i32.const 3)
-  )
-  (func (export "as-block-last") (param i32)
-    (block (call $dummy) (call $dummy) (br_if 0 (local.get 0)))
-  )
-  (func (export "as-block-first-value") (param i32) (result i32)
-    (block (result i32)
-      (drop (br_if 0 (i32.const 10) (local.get 0))) (return (i32.const 11))
-    )
-  )
-  (func (export "as-block-mid-value") (param i32) (result i32)
-    (block (result i32)
-      (call $dummy)
-      (drop (br_if 0 (i32.const 20) (local.get 0)))
-      (return (i32.const 21))
-    )
-  )
-  (func (export "as-block-last-value") (param i32) (result i32)
-    (block (result i32)
-      (call $dummy) (call $dummy) (br_if 0 (i32.const 11) (local.get 0))
-    )
-  )
-
-  (func (export "as-loop-first") (param i32) (result i32)
-    (block (loop (br_if 1 (local.get 0)) (return (i32.const 2)))) (i32.const 3)
-  )
-  (func (export "as-loop-mid") (param i32) (result i32)
-    (block (loop (call $dummy) (br_if 1 (local.get 0)) (return (i32.const 2))))
-    (i32.const 4)
-  )
-  (func (export "as-loop-last") (param i32)
-    (loop (call $dummy) (br_if 1 (local.get 0)))
-  )
-
-  (func (export "as-br-value") (result i32)
-    (block (result i32) (br 0 (br_if 0 (i32.const 1) (i32.const 2))))
-  )
-
-  (func (export "as-br_if-value") (result i32)
-    (block (result i32)
-      (drop (br_if 0 (br_if 0 (i32.const 1) (i32.const 2)) (i32.const 3)))
-      (i32.const 4)
-    )
-  )
-  (func (export "as-br_if-value-cond") (param i32) (result i32)
-    (block (result i32)
-      (drop (br_if 0 (i32.const 2) (br_if 0 (i32.const 1) (local.get 0))))
-      (i32.const 4)
-    )
-  )
-
-  (func (export "as-br_if-cond")
-    (block (br_if 0 (br_if 0 (i32.const 1) (i32.const 1))))
-  )
-
-  (func (export "as-return-value") (result i64)
-    (block (result i64) (return (br_if 0 (i64.const 1) (i32.const 2))))
-  )
-
-  (func (export "as-if-cond") (param i32) (result i32)
-    (block (result i32)
-      (if (result i32)
-        (br_if 0 (i32.const 1) (local.get 0))
-        (then (i32.const 2))
-        (else (i32.const 3))
-      )
-    )
-  )
-  (func (export "as-if-then") (param i32 i32)
-    (block
-      (if (local.get 0) (then (br_if 1 (local.get 1))) (else (call $dummy)))
-    )
-  )
-  (func (export "as-if-else") (param i32 i32)
-    (block
-      (if (local.get 0) (then (call $dummy)) (else (br_if 1 (local.get 1))))
-    )
-  )
-
- (func $f (param i32 i32 i32) (result i32) (i32.const -1))
- (func (export "as-call-first") (result i32)
-    (block (result i32)
-      (call $f
-        (br_if 0 (i32.const 12) (i32.const 1)) (i32.const 2) (i32.const 3)
-      )
-    )
-  )
-  (func (export "as-call-mid") (result i32)
-    (block (result i32)
-      (call $f
-        (i32.const 1) (br_if 0 (i32.const 13) (i32.const 1)) (i32.const 3)
-      )
-    )
-  )
-  (func (export "as-call-last") (result i32)
-    (block (result i32)
-      (call $f
-        (i32.const 1) (i32.const 2) (br_if 0 (i32.const 14) (i32.const 1))
-      )
-    )
-  )
-
-  (func (export "as-local.set-value") (param i32) (result i32)
-    (local i32)
-    (block (result i32)
-      (local.set 0 (br_if 0 (i32.const 17) (local.get 0)))
-      (i32.const -1)
-    )
-  )
-
-  (func (export "as-binary-left") (result i32)
-    (block (result i32) (i32.add (br_if 0 (i32.const 1) (i32.const 1)) (i32.const 10)))
-  )
-  (func (export "as-binary-right") (result i32)
-    (block (result i32) (i32.sub (i32.const 10) (br_if 0 (i32.const 1) (i32.const 1))))
-  )
-  (func (export "as-test-operand") (result i32)
-    (block (result i32) (i32.eqz (br_if 0 (i32.const 0) (i32.const 1))))
-  )
-  (func (export "as-compare-left") (result i32)
-    (block (result i32) (i32.le_u (br_if 0 (i32.const 1) (i32.const 1)) (i32.const 10)))
-  )
-  (func (export "as-compare-right") (result i32)
-    (block (result i32) (i32.ne (i32.const 10) (br_if 0 (i32.const 1) (i32.const 42))))
-  )
-
-  (func (export "nested-block-value") (param i32) (result i32)
-    (i32.add
-      (i32.const 1)
-      (block (result i32)
-        (drop (i32.const 2))
-        (i32.add
-          (i32.const 4)
-          (block (result i32)
-            (drop (br_if 1 (i32.const 8) (local.get 0)))
-            (i32.const 16)
-          )
-        )
-      )
-    )
-  )
-
-  (func (export "nested-br-value") (param i32) (result i32)
-    (i32.add
-      (i32.const 1)
-      (block (result i32)
-        (drop (i32.const 2))
-        (br 0
-          (block (result i32)
-            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 4)
-          )
-        )
-        (i32.const 16)
-      )
-    )
-  )
-
-  (func (export "nested-br_if-value") (param i32) (result i32)
-    (i32.add
-      (i32.const 1)
-      (block (result i32)
-        (drop (i32.const 2))
-        (drop (br_if 0
-          (block (result i32)
-            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 4)
-          )
-          (i32.const 1)
-        ))
-        (i32.const 16)
-      )
-    )
-  )
-
-  (func (export "nested-br_if-value-cond") (param i32) (result i32)
-    (i32.add
-      (i32.const 1)
-      (block (result i32)
-        (drop (i32.const 2))
-        (drop (br_if 0
-          (i32.const 4)
-          (block (result i32)
-            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 1)
-          )
-        ))
-        (i32.const 16)
-      )
-    )
-  )
-
-  (func (export "as-br_table-index")
-    (block (br_table 0 0 0 (br_if 0 (i32.const 1) (i32.const 2))))
-  )
-  (func (export "as-br_table-value") (result i32)
-    (block (result i32)
-      (br_table 0 0 0 (br_if 0 (i32.const 1) (i32.const 2)) (i32.const 3)) (i32.const 4)
-    )
-  )
-  (func (export "as-br_table-value-index") (result i32)
-    (block (result i32)
-      (br_table 0 0 (i32.const 2) (br_if 0 (i32.const 1) (i32.const 3))) (i32.const 4)
-    )
-  )
-
-  (func (export "nested-br_table-value") (param i32) (result i32)
-    (i32.add
-      (i32.const 1)
-      (block (result i32)
-        (drop (i32.const 2))
-        (br_table 0
-          (block (result i32)
-            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 4)
-          )
-          (i32.const 1)
-        )
-        (i32.const 16)
-      )
-    )
-  )
-
-  (func (export "nested-br_table-value-index") (param i32) (result i32)
-    (i32.add
-      (i32.const 1)
-      (block (result i32)
-        (drop (i32.const 2))
-        (br_table 0
-          (i32.const 4)
-          (block (result i32)
-            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 1)
-          )
-        )
-        (i32.const 16)
-      )
-    )
-  )
-)
-
-
-(assert_return (invoke "type-i32-value") (i32.const 1))
-(assert_return (invoke "type-i64-value") (i64.const 2))
-(assert_return (invoke "as-block-first" (i32.const 0)) (i32.const 2))
-(assert_return (invoke "as-block-first" (i32.const 1)) (i32.const 3))
-(assert_return (invoke "as-block-mid" (i32.const 0)) (i32.const 2))
-(assert_return (invoke "as-block-mid" (i32.const 1)) (i32.const 3))
-(assert_return (invoke "as-block-last" (i32.const 0)))
-(assert_return (invoke "as-block-last" (i32.const 1)))
-(assert_return (invoke "as-block-first-value" (i32.const 0)) (i32.const 11))
-(assert_return (invoke "as-block-first-value" (i32.const 1)) (i32.const 10))
-(assert_return (invoke "as-block-mid-value" (i32.const 0)) (i32.const 21))
-(assert_return (invoke "as-block-mid-value" (i32.const 1)) (i32.const 20))
-(assert_return (invoke "as-block-last-value" (i32.const 0)) (i32.const 11))
-(assert_return (invoke "as-block-last-value" (i32.const 1)) (i32.const 11))
-(assert_return (invoke "as-loop-first" (i32.const 0)) (i32.const 2))
-(assert_return (invoke "as-loop-first" (i32.const 1)) (i32.const 3))
-(assert_return (invoke "as-loop-mid" (i32.const 0)) (i32.const 2))
-(assert_return (invoke "as-loop-mid" (i32.const 1)) (i32.const 4))
-(assert_return (invoke "as-loop-last" (i32.const 0)))
-(assert_return (invoke "as-loop-last" (i32.const 1)))
-(assert_return (invoke "as-br-value") (i32.const 1))
-(assert_return (invoke "as-br_if-cond"))
-(assert_return (invoke "as-return-value") (i64.const 1))
-(assert_return (invoke "as-if-cond" (i32.const 0)) (i32.const 2))
-(assert_return (invoke "as-if-cond" (i32.const 1)) (i32.const 1))
-(assert_return (invoke "as-if-then" (i32.const 0) (i32.const 0)))
-(assert_return (invoke "as-if-then" (i32.const 4) (i32.const 0)))
-(assert_return (invoke "as-if-then" (i32.const 0) (i32.const 1)))
-(assert_return (invoke "as-if-then" (i32.const 4) (i32.const 1)))
-(assert_return (invoke "as-if-else" (i32.const 0) (i32.const 0)))
-(assert_return (invoke "as-if-else" (i32.const 3) (i32.const 0)))
-(assert_return (invoke "as-if-else" (i32.const 0) (i32.const 1)))
-(assert_return (invoke "as-if-else" (i32.const 3) (i32.const 1)))
-(assert_return (invoke "as-call-first") (i32.const 12))
-(assert_return (invoke "as-call-mid") (i32.const 13))
-(assert_return (invoke "as-call-last") (i32.const 14))
-(assert_return (invoke "as-local.set-value" (i32.const 0)) (i32.const -1))
-(assert_return (invoke "as-local.set-value" (i32.const 1)) (i32.const 17))
-(assert_return (invoke "as-binary-left") (i32.const 1))
-(assert_return (invoke "as-binary-right") (i32.const 1))
-(assert_return (invoke "as-test-operand") (i32.const 0))
-(assert_return (invoke "as-compare-left") (i32.const 1))
-(assert_return (invoke "as-compare-right") (i32.const 1))
-(assert_return (invoke "as-br_if-value") (i32.const 1))
-(assert_return (invoke "as-br_if-value-cond" (i32.const 0)) (i32.const 2))
-(assert_return (invoke "as-br_if-value-cond" (i32.const 1)) (i32.const 1))
-(assert_return (invoke "nested-block-value" (i32.const 0)) (i32.const 21))
-(assert_return (invoke "nested-block-value" (i32.const 1)) (i32.const 9))
-(assert_return (invoke "nested-br-value" (i32.const 0)) (i32.const 5))
-(assert_return (invoke "nested-br-value" (i32.const 1)) (i32.const 9))
-(assert_return (invoke "nested-br_if-value" (i32.const 0)) (i32.const 5))
-(assert_return (invoke "nested-br_if-value" (i32.const 1)) (i32.const 9))
-(assert_return (invoke "nested-br_if-value-cond" (i32.const 0)) (i32.const 5))
-(assert_return (invoke "nested-br_if-value-cond" (i32.const 1)) (i32.const 9))
-
-(assert_return (invoke "as-br_table-index"))
-(assert_return (invoke "as-br_table-value") (i32.const 1))
-(assert_return (invoke "as-br_table-value-index") (i32.const 1))
-
-(assert_return (invoke "nested-br_table-value" (i32.const 0)) (i32.const 5))
-(assert_return (invoke "nested-br_table-value" (i32.const 1)) (i32.const 9))
-(assert_return (invoke "nested-br_table-value-index" (i32.const 0)) (i32.const 5))
-(assert_return (invoke "nested-br_table-value-index" (i32.const 1)) (i32.const 9))
diff --git a/tests/misc_testsuite/winch/br_table.wast b/tests/misc_testsuite/winch/br_table.wast
index 54784e13d00b..87e462b0e8c6 100644
--- a/tests/misc_testsuite/winch/br_table.wast
+++ b/tests/misc_testsuite/winch/br_table.wast
@@ -10,6 +10,25 @@
   (func (export "type-i64")
     (block (drop (i64.ctz (br_table 0 0 (i32.const 0)))))
   )
+  (func (export "type-f32")
+    (block (drop (f32.neg (br_table 0 0 (i32.const 0)))))
+  )
+  (func (export "type-f64")
+    (block (drop (f64.neg (br_table 0 0 (i32.const 0)))))
+  )
+
+  (func (export "type-i32-value") (result i32)
+    (block (result i32) (i32.ctz (br_table 0 0 (i32.const 1) (i32.const 0))))
+  )
+  (func (export "type-i64-value") (result i64)
+    (block (result i64) (i64.ctz (br_table 0 0 (i64.const 2) (i32.const 0))))
+  )
+  (func (export "type-f32-value") (result f32)
+    (block (result f32) (f32.neg (br_table 0 0 (f32.const 3) (i32.const 0))))
+  )
+  (func (export "type-f64-value") (result f64)
+    (block (result f64) (f64.neg (br_table 0 0 (f64.const 4) (i32.const 0))))
+  )
 
   (func (export "empty") (param i32) (result i32)
     (block (br_table 0 (local.get 0)) (return (i32.const 21)))
@@ -1119,10 +1138,50 @@
       (i32.const 3)
     )
   )
+
+  (memory 1)
+  (func (export "as-load-address") (result f32)
+    (block (result f32) (f32.load (br_table 0 (f32.const 1.7) (i32.const 1))))
+  )
+  (func (export "as-loadN-address") (result i64)
+    (block (result i64) (i64.load8_s (br_table 0 (i64.const 30) (i32.const 1))))
+  )
+
+  (func (export "as-store-address") (result i32)
+    (block (result i32)
+      (f64.store (br_table 0 (i32.const 30) (i32.const 1)) (f64.const 7))
+      (i32.const -1)
+    )
+  )
+  (func (export "as-store-value") (result i32)
+    (block (result i32)
+      (i64.store (i32.const 2) (br_table 0 (i32.const 31) (i32.const 1)))
+      (i32.const -1)
+     )
+  )
+
+  (func (export "as-storeN-address") (result i32)
+    (block (result i32)
+      (i32.store8 (br_table 0 (i32.const 32) (i32.const 0)) (i32.const 7))
+      (i32.const -1)
+    )
+  )
+  (func (export "as-storeN-value") (result i32)
+    (block (result i32)
+      (i64.store16 (i32.const 2) (br_table 0 (i32.const 33) (i32.const 0)))
+      (i32.const -1)
+    )
+  )
 )
 
 (assert_return (invoke "type-i32"))
 (assert_return (invoke "type-i64"))
+(assert_return (invoke "type-f32"))
+(assert_return (invoke "type-f64"))
+(assert_return (invoke "type-i32-value") (i32.const 1))
+(assert_return (invoke "type-i64-value") (i64.const 2))
+(assert_return (invoke "type-f32-value") (f32.const 3))
+(assert_return (invoke "type-f64-value") (f64.const 4))
 
 (assert_return (invoke "empty" (i32.const 0)) (i32.const 22))
 (assert_return (invoke "empty" (i32.const 1)) (i32.const 22))
@@ -1265,3 +1324,11 @@
 (assert_return (invoke "nested-br_table-value-index" (i32.const 9423975)) (i32.const 9))
 
 (assert_return (invoke "nested-br_table-loop-block" (i32.const 1)) (i32.const 3))
+
+(assert_return (invoke "as-load-address") (f32.const 1.7))
+(assert_return (invoke "as-loadN-address") (i64.const 30))
+
+(assert_return (invoke "as-store-address") (i32.const 30))
+(assert_return (invoke "as-store-value") (i32.const 31))
+(assert_return (invoke "as-storeN-address") (i32.const 32))
+(assert_return (invoke "as-storeN-value") (i32.const 33))
diff --git a/tests/misc_testsuite/winch/call.wast b/tests/misc_testsuite/winch/call.wast
deleted file mode 100644
index 84e92519a5e3..000000000000
--- a/tests/misc_testsuite/winch/call.wast
+++ /dev/null
@@ -1,195 +0,0 @@
-;; Test `call` operator
-
-
-(module
-  ;; Auxiliary definitions
-  (func $const-i32 (result i32) (i32.const 0x132))
-  (func $const-i64 (result i64) (i64.const 0x164))
-
-  (func $id-i32 (param i32) (result i32) (local.get 0))
-  (func $id-i64 (param i64) (result i64) (local.get 0))
-
-  (func $i32-i64 (param i32 i64) (result i64) (local.get 1))
-
-  ;; Typing
-
-  (func (export "type-i32") (result i32) (call $const-i32))
-  (func (export "type-i64") (result i64) (call $const-i64))
-
-  (func (export "type-first-i32") (result i32) (call $id-i32 (i32.const 32)))
-  (func (export "type-first-i64") (result i64) (call $id-i64 (i64.const 64)))
-
-  (func (export "type-second-i64") (result i64)
-    (call $i32-i64 (i32.const 32) (i64.const 64))
-  )
-
-  ;; Recursion
-
-  (func $fac (export "fac") (param i64) (result i64)
-    (if (result i64) (i64.eqz (local.get 0))
-      (then (i64.const 1))
-      (else
-        (i64.mul
-          (local.get 0)
-          (call $fac (i64.sub (local.get 0) (i64.const 1)))
-        )
-      )
-    )
-  )
-
-  (func $fac-acc (export "fac-acc") (param i64 i64) (result i64)
-    (if (result i64) (i64.eqz (local.get 0))
-      (then (local.get 1))
-      (else
-        (call $fac-acc
-          (i64.sub (local.get 0) (i64.const 1))
-          (i64.mul (local.get 0) (local.get 1))
-        )
-      )
-    )
-  )
-
-  (func $fib (export "fib") (param i64) (result i64)
-    (if (result i64) (i64.le_u (local.get 0) (i64.const 1))
-      (then (i64.const 1))
-      (else
-        (i64.add
-          (call $fib (i64.sub (local.get 0) (i64.const 2)))
-          (call $fib (i64.sub (local.get 0) (i64.const 1)))
-        )
-      )
-    )
-  )
-
-  (func $even (export "even") (param i64) (result i32)
-    (if (result i32) (i64.eqz (local.get 0))
-      (then (i32.const 44))
-      (else (call $odd (i64.sub (local.get 0) (i64.const 1))))
-    )
-  )
-  (func $odd (export "odd") (param i64) (result i32)
-    (if (result i32) (i64.eqz (local.get 0))
-      (then (i32.const 99))
-      (else (call $even (i64.sub (local.get 0) (i64.const 1))))
-    )
-  )
-
-  ;; Stack exhaustion
-
-  ;; Implementations are required to have every call consume some abstract
-  ;; resource towards exhausting some abstract finite limit, such that
-  ;; infinitely recursive test cases reliably trap in finite time. This is
-  ;; because otherwise applications could come to depend on it on those
-  ;; implementations and be incompatible with implementations that don't do
-  ;; it (or don't do it under the same circumstances).
-
-  (func $runaway (export "runaway") (call $runaway))
-
-  (func $mutual-runaway1 (export "mutual-runaway") (call $mutual-runaway2))
-  (func $mutual-runaway2 (call $mutual-runaway1))
-
-  ;; As parameter of control constructs and instructions
-
-  (memory 1)
-
-  (func (export "as-if-condition") (result i32)
-    (if (result i32) (call $const-i32) (then (i32.const 1)) (else (i32.const 2)))
-  )
-
-  (func (export "as-drop-operand")
-    (call $const-i32) (drop)
-  )
-
-  (func (export "as-br_if-first") (result i32)
-    (block (result i32) (br_if 0 (call $const-i32) (i32.const 2)))
-  )
-  (func (export "as-br_if-last") (result i32)
-    (block (result i32) (br_if 0 (i32.const 2) (call $const-i32)))
-  )
-
-
-  (func (export "as-return-value") (result i32)
-    (call $const-i32) (return)
-  )
-  (func (export "as-br-value") (result i32)
-    (block (result i32) (br 0 (call $const-i32)))
-  )
-  (func (export "as-local.set-value") (result i32)
-    (local i32) (local.set 0 (call $const-i32)) (local.get 0)
-  )
-  (func $dummy (param i32) (result i32) (local.get 0))
-
-  (func (export "as-binary-left") (result i32)
-    (block (result i32) (i32.add (call $dummy (i32.const 1)) (i32.const 10)))
-  )
-  (func (export "as-binary-right") (result i32)
-    (block (result i32) (i32.sub (i32.const 10) (call $dummy (i32.const 1))))
-  )
-
-  (func (export "as-test-operand") (result i32)
-    (block (result i32) (i32.eqz (call $dummy (i32.const 1))))
-  )
-
-  (func (export "as-compare-left") (result i32)
-    (block (result i32) (i32.le_u (call $dummy (i32.const 1)) (i32.const 10)))
-  )
-  (func (export "as-compare-right") (result i32)
-    (block (result i32) (i32.ne (i32.const 10) (call $dummy (i32.const 1))))
-  )
-
-  (func (export "as-br_table-first") (result i32)
-    (block (result i32) (call $const-i32) (i32.const 2) (br_table 0 0))
-  )
-  (func (export "as-br_table-last") (result i32)
-    (block (result i32) (i32.const 2) (call $const-i32) (br_table 0 0))
-  )
-
-)
-
-(assert_return (invoke "type-i32") (i32.const 0x132))
-(assert_return (invoke "type-i64") (i64.const 0x164))
-(assert_return (invoke "type-first-i32") (i32.const 32))
-(assert_return (invoke "type-first-i64") (i64.const 64))
-(assert_return (invoke "type-second-i64") (i64.const 64))
-
-(assert_return (invoke "fac" (i64.const 0)) (i64.const 1))
-(assert_return (invoke "fac" (i64.const 1)) (i64.const 1))
-(assert_return (invoke "fac" (i64.const 5)) (i64.const 120))
-(assert_return (invoke "fac" (i64.const 25)) (i64.const 7034535277573963776))
-(assert_return (invoke "fac-acc" (i64.const 0) (i64.const 1)) (i64.const 1))
-(assert_return (invoke "fac-acc" (i64.const 1) (i64.const 1)) (i64.const 1))
-(assert_return (invoke "fac-acc" (i64.const 5) (i64.const 1)) (i64.const 120))
-(assert_return
-  (invoke "fac-acc" (i64.const 25) (i64.const 1))
-  (i64.const 7034535277573963776)
-)
-
-(assert_return (invoke "fib" (i64.const 0)) (i64.const 1))
-(assert_return (invoke "fib" (i64.const 1)) (i64.const 1))
-(assert_return (invoke "fib" (i64.const 2)) (i64.const 2))
-(assert_return (invoke "fib" (i64.const 5)) (i64.const 8))
-(assert_return (invoke "fib" (i64.const 20)) (i64.const 10946))
-(assert_return (invoke "even" (i64.const 0)) (i32.const 44))
-(assert_return (invoke "even" (i64.const 1)) (i32.const 99))
-(assert_return (invoke "even" (i64.const 100)) (i32.const 44))
-(assert_return (invoke "even" (i64.const 77)) (i32.const 99))
-(assert_return (invoke "odd" (i64.const 0)) (i32.const 99))
-(assert_return (invoke "odd" (i64.const 1)) (i32.const 44))
-(assert_return (invoke "odd" (i64.const 200)) (i32.const 99))
-(assert_return (invoke "odd" (i64.const 77)) (i32.const 44))
-(assert_return (invoke "as-if-condition") (i32.const 1))
-(assert_return (invoke "as-br_if-first") (i32.const 0x132))
-(assert_return (invoke "as-br_if-last") (i32.const 2))
-(assert_return (invoke "as-return-value") (i32.const 0x132))
-(assert_return (invoke "as-br-value") (i32.const 0x132))
-(assert_return (invoke "as-local.set-value") (i32.const 0x132))
-
-(assert_return (invoke "as-binary-left") (i32.const 11))
-(assert_return (invoke "as-binary-right") (i32.const 9))
-(assert_return (invoke "as-test-operand") (i32.const 0))
-(assert_return (invoke "as-compare-left") (i32.const 1))
-(assert_return (invoke "as-compare-right") (i32.const 1))
-(assert_return (invoke "as-drop-operand"))
-
-(assert_return (invoke "as-br_table-first") (i32.const 0x132))
-(assert_return (invoke "as-br_table-last") (i32.const 2))
diff --git a/tests/misc_testsuite/winch/call_indirect.wast b/tests/misc_testsuite/winch/call_indirect.wast
deleted file mode 100644
index a432415aa6c6..000000000000
--- a/tests/misc_testsuite/winch/call_indirect.wast
+++ /dev/null
@@ -1,413 +0,0 @@
-;; Test `call_indirect` operator
-
-(module
-  ;; Auxiliary definitions
-  (type $proc (func))
-  (type $out-i32 (func (result i32)))
-  (type $out-i64 (func (result i64)))
-  (type $out-f32 (func (result f32)))
-  (type $out-f64 (func (result f64)))
-  (type $over-i32 (func (param i32) (result i32)))
-  (type $over-i64 (func (param i64) (result i64)))
-  (type $over-f32 (func (param f32) (result f32)))
-  (type $over-f64 (func (param f64) (result f64)))
-  (type $f32-i32 (func (param f32 i32) (result i32)))
-  (type $i32-i64 (func (param i32 i64) (result i64)))
-  (type $f64-f32 (func (param f64 f32) (result f32)))
-  (type $i64-f64 (func (param i64 f64) (result f64)))
-  (type $over-i32-duplicate (func (param i32) (result i32)))
-  (type $over-i64-duplicate (func (param i64) (result i64)))
-  (type $over-f32-duplicate (func (param f32) (result f32)))
-  (type $over-f64-duplicate (func (param f64) (result f64)))
-
-  (func $const-i32 (type $out-i32) (i32.const 0x132))
-  (func $const-i64 (type $out-i64) (i64.const 0x164))
-  (func $const-f32 (type $out-f32) (f32.const 0xf32))
-  (func $const-f64 (type $out-f64) (f64.const 0xf64))
-
-  (func $id-i32 (type $over-i32) (local.get 0))
-  (func $id-i64 (type $over-i64) (local.get 0))
-  (func $id-f32 (type $over-f32) (local.get 0))
-  (func $id-f64 (type $over-f64) (local.get 0))
-
-  (func $i32-i64 (type $i32-i64) (local.get 1))
-  (func $i64-f64 (type $i64-f64) (local.get 1))
-  (func $f32-i32 (type $f32-i32) (local.get 1))
-  (func $f64-f32 (type $f64-f32) (local.get 1))
-
-  (func $over-i32-duplicate (type $over-i32-duplicate) (local.get 0))
-  (func $over-i64-duplicate (type $over-i64-duplicate) (local.get 0))
-  (func $over-f32-duplicate (type $over-f32-duplicate) (local.get 0))
-  (func $over-f64-duplicate (type $over-f64-duplicate) (local.get 0))
-
-  (table funcref
-    (elem
-      $const-i32 $const-i64 $const-f32 $const-f64  ;; 0..3
-      $id-i32 $id-i64 $id-f32 $id-f64              ;; 4..7
-      $f32-i32 $i32-i64 $f64-f32 $i64-f64          ;; 8..11
-      $fac-i64 $fib-i64 $even $odd                 ;; 12..15
-      $over-i32-duplicate $over-i64-duplicate      ;; 16..17
-      $over-f32-duplicate $over-f64-duplicate      ;; 18..19
-      $fac-i32 $fib-i32                            ;; 20..21
-    )
-  )
-
-  ;; Typing
-
-  (func (export "type-i32") (result i32)
-    (call_indirect (type $out-i32) (i32.const 0))
-  )
-  (func (export "type-i64") (result i64)
-    (call_indirect (type $out-i64) (i32.const 1))
-  )
-  (func (export "type-f32") (result f32)
-    (call_indirect (type $out-f32) (i32.const 2))
-  )
-  (func (export "type-f64") (result f64)
-    (call_indirect (type $out-f64) (i32.const 3))
-  )
-
-  (func (export "type-index") (result i64)
-    (call_indirect (type $over-i64) (i64.const 100) (i32.const 5))
-  )
-
-  (func (export "type-first-i32") (result i32)
-    (call_indirect (type $over-i32) (i32.const 32) (i32.const 4))
-  )
-  (func (export "type-first-i64") (result i64)
-    (call_indirect (type $over-i64) (i64.const 64) (i32.const 5))
-  )
-  (func (export "type-first-f32") (result f32)
-    (call_indirect (type $over-f32) (f32.const 1.32) (i32.const 6))
-  )
-  (func (export "type-first-f64") (result f64)
-    (call_indirect (type $over-f64) (f64.const 1.64) (i32.const 7))
-  )
-
-  (func (export "type-second-i32") (result i32)
-    (call_indirect (type $f32-i32) (f32.const 32.1) (i32.const 32) (i32.const 8))
-  )
-  (func (export "type-second-i64") (result i64)
-    (call_indirect (type $i32-i64) (i32.const 32) (i64.const 64) (i32.const 9))
-  )
-  (func (export "type-second-f32") (result f32)
-    (call_indirect (type $f64-f32) (f64.const 64) (f32.const 32) (i32.const 10))
-  )
-  (func (export "type-second-f64") (result f64)
-    (call_indirect (type $i64-f64) (i64.const 64) (f64.const 64.1) (i32.const 11))
-  )
-
-  ;; Dispatch
-
-  (func (export "dispatch") (param i32 i64) (result i64)
-    (call_indirect (type $over-i64) (local.get 1) (local.get 0))
-  )
-
-  (func (export "dispatch-structural-i64") (param i32) (result i64)
-    (call_indirect (type $over-i64-duplicate) (i64.const 9) (local.get 0))
-  )
-  (func (export "dispatch-structural-i32") (param i32) (result i32)
-    (call_indirect (type $over-i32-duplicate) (i32.const 9) (local.get 0))
-  )
-  (func (export "dispatch-structural-f32") (param i32) (result f32)
-    (call_indirect (type $over-f32-duplicate) (f32.const 9.0) (local.get 0))
-  )
-  (func (export "dispatch-structural-f64") (param i32) (result f64)
-    (call_indirect (type $over-f64-duplicate) (f64.const 9.0) (local.get 0))
-  )
-
-  ;; Recursion
-
-  (func $fac-i64 (export "fac-i64") (type $over-i64)
-    (if (result i64) (i64.eqz (local.get 0))
-      (then (i64.const 1))
-      (else
-        (i64.mul
-          (local.get 0)
-          (call_indirect (type $over-i64)
-            (i64.sub (local.get 0) (i64.const 1))
-            (i32.const 12)
-          )
-        )
-      )
-    )
-  )
-
-  (func $fib-i64 (export "fib-i64") (type $over-i64)
-    (if (result i64) (i64.le_u (local.get 0) (i64.const 1))
-      (then (i64.const 1))
-      (else
-        (i64.add
-          (call_indirect (type $over-i64)
-            (i64.sub (local.get 0) (i64.const 2))
-            (i32.const 13)
-          )
-          (call_indirect (type $over-i64)
-            (i64.sub (local.get 0) (i64.const 1))
-            (i32.const 13)
-          )
-        )
-      )
-    )
-  )
-
-  (func $fac-i32 (export "fac-i32") (type $over-i32)
-    (if (result i32) (i32.eqz (local.get 0))
-      (then (i32.const 1))
-      (else
-        (i32.mul
-          (local.get 0)
-          (call_indirect (type $over-i32)
-            (i32.sub (local.get 0) (i32.const 1))
-            (i32.const 20)
-          )
-        )
-      )
-    )
-  )
-
-  (func $fib-i32 (export "fib-i32") (type $over-i32)
-    (if (result i32) (i32.le_u (local.get 0) (i32.const 1))
-      (then (i32.const 1))
-      (else
-        (i32.add
-          (call_indirect (type $over-i32)
-            (i32.sub (local.get 0) (i32.const 2))
-            (i32.const 21)
-          )
-          (call_indirect (type $over-i32)
-            (i32.sub (local.get 0) (i32.const 1))
-            (i32.const 21)
-          )
-        )
-      )
-    )
-  )
-
-  (func $even (export "even") (param i32) (result i32)
-    (if (result i32) (i32.eqz (local.get 0))
-      (then (i32.const 44))
-      (else
-        (call_indirect (type $over-i32)
-          (i32.sub (local.get 0) (i32.const 1))
-          (i32.const 15)
-        )
-      )
-    )
-  )
-  (func $odd (export "odd") (param i32) (result i32)
-    (if (result i32) (i32.eqz (local.get 0))
-      (then (i32.const 99))
-      (else
-        (call_indirect (type $over-i32)
-          (i32.sub (local.get 0) (i32.const 1))
-          (i32.const 14)
-        )
-      )
-    )
-  )
-
-  ;; As parameter of control constructs and instructions
-
-  (memory 1)
-
-  (func (export "as-select-first") (result i32)
-    (select (call_indirect (type $out-i32) (i32.const 0)) (i32.const 2) (i32.const 3))
-  )
-  (func (export "as-select-mid") (result i32)
-    (select (i32.const 2) (call_indirect (type $out-i32) (i32.const 0)) (i32.const 3))
-  )
-  (func (export "as-select-last") (result i32)
-    (select (i32.const 2) (i32.const 3) (call_indirect (type $out-i32) (i32.const 0)))
-  )
-
-  (func (export "as-if-condition") (result i32)
-    (if (result i32) (call_indirect (type $out-i32) (i32.const 0)) (then (i32.const 1)) (else (i32.const 2)))
-  )
-
-  (func (export "as-br_if-first") (result i64)
-    (block (result i64) (br_if 0 (call_indirect (type $out-i64) (i32.const 1)) (i32.const 2)))
-  )
-  (func (export "as-br_if-last") (result i32)
-    (block (result i32) (br_if 0 (i32.const 2) (call_indirect (type $out-i32) (i32.const 0))))
-  )
-
-  (func (export "as-br_table-first") (result f32)
-    (block (result f32) (call_indirect (type $out-f32) (i32.const 2)) (i32.const 2) (br_table 0 0))
-  )
-  (func (export "as-br_table-last") (result i32)
-    (block (result i32) (i32.const 2) (call_indirect (type $out-i32) (i32.const 0)) (br_table 0 0))
-  )
-
-  (func (export "as-return-value") (result i32)
-    (call_indirect (type $over-i32) (i32.const 1) (i32.const 4)) (return)
-  )
-  (func (export "as-drop-operand")
-    (call_indirect (type $over-i64) (i64.const 1) (i32.const 5)) (drop)
-  )
-  (func (export "as-br-value") (result f32)
-    (block (result f32) (br 0 (call_indirect (type $over-f32) (f32.const 1) (i32.const 6))))
-  )
-  (func (export "as-local.set-value") (result f64)
-    (local f64) (local.set 0 (call_indirect (type $over-f64) (f64.const 1) (i32.const 7))) (local.get 0)
-  )
-  (func (export "as-local.tee-value") (result f64)
-    (local f64) (local.tee 0 (call_indirect (type $over-f64) (f64.const 1) (i32.const 7)))
-  )
-  (global $a (mut f64) (f64.const 10.0))
-  (func (export "as-global.set-value") (result f64)
-    (global.set $a (call_indirect (type $over-f64) (f64.const 1.0) (i32.const 7)))
-    (global.get $a)
-  )
-
-  (func (export "as-binary-left") (result i32)
-    (block (result i32)
-      (i32.add
-        (call_indirect (type $over-i32) (i32.const 1) (i32.const 4))
-        (i32.const 10)
-      )
-    )
-  )
-  (func (export "as-binary-right") (result i32)
-    (block (result i32)
-      (i32.sub
-        (i32.const 10)
-        (call_indirect (type $over-i32) (i32.const 1) (i32.const 4))
-      )
-    )
-  )
-
-  (func (export "as-test-operand") (result i32)
-    (block (result i32)
-      (i32.eqz
-        (call_indirect (type $over-i32) (i32.const 1) (i32.const 4))
-      )
-    )
-  )
-
-  (func (export "as-compare-left") (result i32)
-    (block (result i32)
-      (i32.le_u
-        (call_indirect (type $over-i32) (i32.const 1) (i32.const 4))
-        (i32.const 10)
-      )
-    )
-  )
-  (func (export "as-compare-right") (result i32)
-    (block (result i32)
-      (i32.ne
-        (i32.const 10)
-        (call_indirect (type $over-i32) (i32.const 1) (i32.const 4))
-      )
-    )
-  )
-)
-
-(assert_return (invoke "type-i32") (i32.const 0x132))
-(assert_return (invoke "type-i64") (i64.const 0x164))
-(assert_return (invoke "type-f32") (f32.const 0xf32))
-(assert_return (invoke "type-f64") (f64.const 0xf64))
-
-(assert_return (invoke "type-index") (i64.const 100))
-
-(assert_return (invoke "type-first-i32") (i32.const 32))
-(assert_return (invoke "type-first-i64") (i64.const 64))
-(assert_return (invoke "type-first-f32") (f32.const 1.32))
-(assert_return (invoke "type-first-f64") (f64.const 1.64))
-
-(assert_return (invoke "type-second-i32") (i32.const 32))
-(assert_return (invoke "type-second-i64") (i64.const 64))
-(assert_return (invoke "type-second-f32") (f32.const 32))
-(assert_return (invoke "type-second-f64") (f64.const 64.1))
-
-(assert_return (invoke "dispatch" (i32.const 5) (i64.const 2)) (i64.const 2))
-(assert_return (invoke "dispatch" (i32.const 5) (i64.const 5)) (i64.const 5))
-(assert_return (invoke "dispatch" (i32.const 12) (i64.const 5)) (i64.const 120))
-(assert_return (invoke "dispatch" (i32.const 13) (i64.const 5)) (i64.const 8))
-(assert_return (invoke "dispatch" (i32.const 17) (i64.const 2)) (i64.const 2))
-(assert_trap (invoke "dispatch" (i32.const 0) (i64.const 2)) "indirect call type mismatch")
-(assert_trap (invoke "dispatch" (i32.const 15) (i64.const 2)) "indirect call type mismatch")
-(assert_trap (invoke "dispatch" (i32.const 32) (i64.const 2)) "undefined element")
-(assert_trap (invoke "dispatch" (i32.const -1) (i64.const 2)) "undefined element")
-(assert_trap (invoke "dispatch" (i32.const 1213432423) (i64.const 2)) "undefined element")
-
-(assert_return (invoke "dispatch-structural-i64" (i32.const 5)) (i64.const 9))
-(assert_return (invoke "dispatch-structural-i64" (i32.const 12)) (i64.const 362880))
-(assert_return (invoke "dispatch-structural-i64" (i32.const 13)) (i64.const 55))
-(assert_return (invoke "dispatch-structural-i64" (i32.const 17)) (i64.const 9))
-(assert_trap (invoke "dispatch-structural-i64" (i32.const 11)) "indirect call type mismatch")
-(assert_trap (invoke "dispatch-structural-i64" (i32.const 19)) "indirect call type mismatch")
-
-(assert_return (invoke "dispatch-structural-i32" (i32.const 4)) (i32.const 9))
-(assert_return (invoke "dispatch-structural-i32" (i32.const 20)) (i32.const 362880))
-(assert_return (invoke "dispatch-structural-i32" (i32.const 21)) (i32.const 55))
-(assert_return (invoke "dispatch-structural-i32" (i32.const 16)) (i32.const 9))
-(assert_trap (invoke "dispatch-structural-i32" (i32.const 8)) "indirect call type mismatch")
-(assert_trap (invoke "dispatch-structural-i32" (i32.const 18)) "indirect call type mismatch")
-
-(assert_return (invoke "dispatch-structural-f32" (i32.const 6)) (f32.const 9.0))
-(assert_return (invoke "dispatch-structural-f32" (i32.const 18)) (f32.const 9.0))
-(assert_trap (invoke "dispatch-structural-f32" (i32.const 8)) "indirect call type mismatch")
-(assert_trap (invoke "dispatch-structural-f32" (i32.const 19)) "indirect call type mismatch")
-
-(assert_return (invoke "dispatch-structural-f64" (i32.const 7)) (f64.const 9.0))
-(assert_return (invoke "dispatch-structural-f64" (i32.const 19)) (f64.const 9.0))
-(assert_trap (invoke "dispatch-structural-f64" (i32.const 10)) "indirect call type mismatch")
-(assert_trap (invoke "dispatch-structural-f64" (i32.const 18)) "indirect call type mismatch")
-
-(assert_return (invoke "fac-i64" (i64.const 0)) (i64.const 1))
-(assert_return (invoke "fac-i64" (i64.const 1)) (i64.const 1))
-(assert_return (invoke "fac-i64" (i64.const 5)) (i64.const 120))
-(assert_return (invoke "fac-i64" (i64.const 25)) (i64.const 7034535277573963776))
-
-(assert_return (invoke "fac-i32" (i32.const 0)) (i32.const 1))
-(assert_return (invoke "fac-i32" (i32.const 1)) (i32.const 1))
-(assert_return (invoke "fac-i32" (i32.const 5)) (i32.const 120))
-(assert_return (invoke "fac-i32" (i32.const 10)) (i32.const 3628800))
-
-(assert_return (invoke "fib-i64" (i64.const 0)) (i64.const 1))
-(assert_return (invoke "fib-i64" (i64.const 1)) (i64.const 1))
-(assert_return (invoke "fib-i64" (i64.const 2)) (i64.const 2))
-(assert_return (invoke "fib-i64" (i64.const 5)) (i64.const 8))
-(assert_return (invoke "fib-i64" (i64.const 20)) (i64.const 10946))
-
-(assert_return (invoke "fib-i32" (i32.const 0)) (i32.const 1))
-(assert_return (invoke "fib-i32" (i32.const 1)) (i32.const 1))
-(assert_return (invoke "fib-i32" (i32.const 2)) (i32.const 2))
-(assert_return (invoke "fib-i32" (i32.const 5)) (i32.const 8))
-(assert_return (invoke "fib-i32" (i32.const 20)) (i32.const 10946))
-
-(assert_return (invoke "even" (i32.const 0)) (i32.const 44))
-(assert_return (invoke "even" (i32.const 1)) (i32.const 99))
-(assert_return (invoke "even" (i32.const 100)) (i32.const 44))
-(assert_return (invoke "even" (i32.const 77)) (i32.const 99))
-(assert_return (invoke "odd" (i32.const 0)) (i32.const 99))
-(assert_return (invoke "odd" (i32.const 1)) (i32.const 44))
-(assert_return (invoke "odd" (i32.const 200)) (i32.const 99))
-(assert_return (invoke "odd" (i32.const 77)) (i32.const 44))
-
-(assert_return (invoke "as-select-first") (i32.const 0x132))
-(assert_return (invoke "as-select-mid") (i32.const 2))
-(assert_return (invoke "as-select-last") (i32.const 2))
-
-(assert_return (invoke "as-if-condition") (i32.const 1))
-
-(assert_return (invoke "as-br_if-first") (i64.const 0x164))
-(assert_return (invoke "as-br_if-last") (i32.const 2))
-
-(assert_return (invoke "as-br_table-first") (f32.const 0xf32))
-(assert_return (invoke "as-br_table-last") (i32.const 2))
-
-(assert_return (invoke "as-return-value") (i32.const 1))
-(assert_return (invoke "as-drop-operand"))
-(assert_return (invoke "as-br-value") (f32.const 1))
-(assert_return (invoke "as-local.set-value") (f64.const 1))
-(assert_return (invoke "as-local.tee-value") (f64.const 1))
-(assert_return (invoke "as-global.set-value") (f64.const 1.0))
-
-(assert_return (invoke "as-binary-left") (i32.const 11))
-(assert_return (invoke "as-binary-right") (i32.const 9))
-(assert_return (invoke "as-test-operand") (i32.const 0))
-(assert_return (invoke "as-compare-left") (i32.const 1))
-(assert_return (invoke "as-compare-right") (i32.const 1))
-
diff --git a/tests/misc_testsuite/winch/f32.wast b/tests/misc_testsuite/winch/f32.wast
deleted file mode 100644
index 5d8497461f4f..000000000000
--- a/tests/misc_testsuite/winch/f32.wast
+++ /dev/null
@@ -1,394 +0,0 @@
-(module (func (export "f") (result f32) (f32.const +0x1.00000100000000000p-50)))
-(assert_return (invoke "f") (f32.const +0x1.000000p-50))
-(module (func (export "f") (result f32) (f32.const -0x1.00000100000000000p-50)))
-(assert_return (invoke "f") (f32.const -0x1.000000p-50))
-(module (func (export "f") (result f32) (f32.const +0x1.00000100000000001p-50)))
-(assert_return (invoke "f") (f32.const +0x1.000002p-50))
-(module (func (export "f") (result f32) (f32.const -0x1.00000100000000001p-50)))
-(assert_return (invoke "f") (f32.const -0x1.000002p-50))
-(module (func (export "f") (result f32) (f32.const +0x1.000001fffffffffffp-50)))
-(assert_return (invoke "f") (f32.const +0x1.000002p-50))
-(module (func (export "f") (result f32) (f32.const -0x1.000001fffffffffffp-50)))
-(assert_return (invoke "f") (f32.const -0x1.000002p-50))
-(module (func (export "f") (result f32) (f32.const +0x1.00000200000000000p-50)))
-(assert_return (invoke "f") (f32.const +0x1.000002p-50))
-(module (func (export "f") (result f32) (f32.const -0x1.00000200000000000p-50)))
-(assert_return (invoke "f") (f32.const -0x1.000002p-50))
-(module (func (export "f") (result f32) (f32.const +0x1.00000200000000001p-50)))
-(assert_return (invoke "f") (f32.const +0x1.000002p-50))
-(module (func (export "f") (result f32) (f32.const -0x1.00000200000000001p-50)))
-(assert_return (invoke "f") (f32.const -0x1.000002p-50))
-(module (func (export "f") (result f32) (f32.const +0x1.000002fffffffffffp-50)))
-(assert_return (invoke "f") (f32.const +0x1.000002p-50))
-(module (func (export "f") (result f32) (f32.const -0x1.000002fffffffffffp-50)))
-(assert_return (invoke "f") (f32.const -0x1.000002p-50))
-(module (func (export "f") (result f32) (f32.const +0x1.00000300000000000p-50)))
-(assert_return (invoke "f") (f32.const +0x1.000004p-50))
-(module (func (export "f") (result f32) (f32.const -0x1.00000300000000000p-50)))
-(assert_return (invoke "f") (f32.const -0x1.000004p-50))
-(module (func (export "f") (result f32) (f32.const +0x1.00000300000000001p-50)))
-(assert_return (invoke "f") (f32.const +0x1.000004p-50))
-(module (func (export "f") (result f32) (f32.const -0x1.00000300000000001p-50)))
-(assert_return (invoke "f") (f32.const -0x1.000004p-50))
-(module (func (export "f") (result f32) (f32.const +0x1.000003fffffffffffp-50)))
-(assert_return (invoke "f") (f32.const +0x1.000004p-50))
-(module (func (export "f") (result f32) (f32.const -0x1.000003fffffffffffp-50)))
-(assert_return (invoke "f") (f32.const -0x1.000004p-50))
-(module (func (export "f") (result f32) (f32.const +0x1.00000400000000000p-50)))
-(assert_return (invoke "f") (f32.const +0x1.000004p-50))
-(module (func (export "f") (result f32) (f32.const -0x1.00000400000000000p-50)))
-(assert_return (invoke "f") (f32.const -0x1.000004p-50))
-(module (func (export "f") (result f32) (f32.const +0x1.00000400000000001p-50)))
-(assert_return (invoke "f") (f32.const +0x1.000004p-50))
-(module (func (export "f") (result f32) (f32.const -0x1.00000400000000001p-50)))
-(assert_return (invoke "f") (f32.const -0x1.000004p-50))
-(module (func (export "f") (result f32) (f32.const +0x1.000004fffffffffffp-50)))
-(assert_return (invoke "f") (f32.const +0x1.000004p-50))
-(module (func (export "f") (result f32) (f32.const -0x1.000004fffffffffffp-50)))
-(assert_return (invoke "f") (f32.const -0x1.000004p-50))
-(module (func (export "f") (result f32) (f32.const +0x1.00000500000000000p-50)))
-(assert_return (invoke "f") (f32.const +0x1.000004p-50))
-(module (func (export "f") (result f32) (f32.const -0x1.00000500000000000p-50)))
-(assert_return (invoke "f") (f32.const -0x1.000004p-50))
-(module (func (export "f") (result f32) (f32.const +0x1.00000500000000001p-50)))
-(assert_return (invoke "f") (f32.const +0x1.000006p-50))
-(module (func (export "f") (result f32) (f32.const -0x1.00000500000000001p-50)))
-(assert_return (invoke "f") (f32.const -0x1.000006p-50))
-
-(module (func (export "f") (result f32) (f32.const +0x4000.004000000p-64)))
-(assert_return (invoke "f") (f32.const +0x1.000000p-50))
-(module (func (export "f") (result f32) (f32.const -0x4000.004000000p-64)))
-(assert_return (invoke "f") (f32.const -0x1.000000p-50))
-(module (func (export "f") (result f32) (f32.const +0x4000.004000001p-64)))
-(assert_return (invoke "f") (f32.const +0x1.000002p-50))
-(module (func (export "f") (result f32) (f32.const -0x4000.004000001p-64)))
-(assert_return (invoke "f") (f32.const -0x1.000002p-50))
-(module (func (export "f") (result f32) (f32.const +0x4000.007ffffffp-64)))
-(assert_return (invoke "f") (f32.const +0x1.000002p-50))
-(module (func (export "f") (result f32) (f32.const -0x4000.007ffffffp-64)))
-(assert_return (invoke "f") (f32.const -0x1.000002p-50))
-(module (func (export "f") (result f32) (f32.const +0x4000.008000000p-64)))
-(assert_return (invoke "f") (f32.const +0x1.000002p-50))
-(module (func (export "f") (result f32) (f32.const -0x4000.008000000p-64)))
-(assert_return (invoke "f") (f32.const -0x1.000002p-50))
-(module (func (export "f") (result f32) (f32.const +0x4000.008000001p-64)))
-(assert_return (invoke "f") (f32.const +0x1.000002p-50))
-(module (func (export "f") (result f32) (f32.const -0x4000.008000001p-64)))
-(assert_return (invoke "f") (f32.const -0x1.000002p-50))
-(module (func (export "f") (result f32) (f32.const +0x4000.00bffffffp-64)))
-(assert_return (invoke "f") (f32.const +0x1.000002p-50))
-(module (func (export "f") (result f32) (f32.const -0x4000.00bffffffp-64)))
-(assert_return (invoke "f") (f32.const -0x1.000002p-50))
-(module (func (export "f") (result f32) (f32.const +0x4000.00c000000p-64)))
-(assert_return (invoke "f") (f32.const +0x1.000004p-50))
-(module (func (export "f") (result f32) (f32.const -0x4000.00c000000p-64)))
-(assert_return (invoke "f") (f32.const -0x1.000004p-50))
-(module (func (export "f") (result f32) (f32.const +0x4000.00c000001p-64)))
-(assert_return (invoke "f") (f32.const +0x1.000004p-50))
-(module (func (export "f") (result f32) (f32.const -0x4000.00c000001p-64)))
-(assert_return (invoke "f") (f32.const -0x1.000004p-50))
-(module (func (export "f") (result f32) (f32.const +0x4000.00fffffffp-64)))
-(assert_return (invoke "f") (f32.const +0x1.000004p-50))
-(module (func (export "f") (result f32) (f32.const -0x4000.00fffffffp-64)))
-(assert_return (invoke "f") (f32.const -0x1.000004p-50))
-(module (func (export "f") (result f32) (f32.const +0x4000.010000001p-64)))
-(assert_return (invoke "f") (f32.const +0x1.000004p-50))
-(module (func (export "f") (result f32) (f32.const -0x4000.010000001p-64)))
-(assert_return (invoke "f") (f32.const -0x1.000004p-50))
-(module (func (export "f") (result f32) (f32.const +0x4000.013ffffffp-64)))
-(assert_return (invoke "f") (f32.const +0x1.000004p-50))
-(module (func (export "f") (result f32) (f32.const -0x4000.013ffffffp-64)))
-(assert_return (invoke "f") (f32.const -0x1.000004p-50))
-(module (func (export "f") (result f32) (f32.const +0x4000.014000001p-64)))
-(assert_return (invoke "f") (f32.const +0x1.000006p-50))
-(module (func (export "f") (result f32) (f32.const -0x4000.014000001p-64)))
-(assert_return (invoke "f") (f32.const -0x1.000006p-50))
-
-(module (func (export "f") (result f32) (f32.const +8.8817847263968443573e-16)))
-(assert_return (invoke "f") (f32.const +0x1.000000p-50))
-(module (func (export "f") (result f32) (f32.const -8.8817847263968443573e-16)))
-(assert_return (invoke "f") (f32.const -0x1.000000p-50))
-(module (func (export "f") (result f32) (f32.const +8.8817847263968443574e-16)))
-(assert_return (invoke "f") (f32.const +0x1.000002p-50))
-(module (func (export "f") (result f32) (f32.const -8.8817847263968443574e-16)))
-(assert_return (invoke "f") (f32.const -0x1.000002p-50))
-(module (func (export "f") (result f32) (f32.const +8.8817857851880284252e-16)))
-(assert_return (invoke "f") (f32.const +0x1.000002p-50))
-(module (func (export "f") (result f32) (f32.const -8.8817857851880284252e-16)))
-(assert_return (invoke "f") (f32.const -0x1.000002p-50))
-(module (func (export "f") (result f32) (f32.const +8.8817857851880284253e-16)))
-(assert_return (invoke "f") (f32.const +0x1.000004p-50))
-(module (func (export "f") (result f32) (f32.const -8.8817857851880284253e-16)))
-(assert_return (invoke "f") (f32.const -0x1.000004p-50))
-
-;; f32, large exponent
-(module (func (export "f") (result f32) (f32.const +0x1.00000100000000000p+50)))
-(assert_return (invoke "f") (f32.const +0x1.000000p+50))
-(module (func (export "f") (result f32) (f32.const -0x1.00000100000000000p+50)))
-(assert_return (invoke "f") (f32.const -0x1.000000p+50))
-(module (func (export "f") (result f32) (f32.const +0x1.00000100000000001p+50)))
-(assert_return (invoke "f") (f32.const +0x1.000002p+50))
-(module (func (export "f") (result f32) (f32.const -0x1.00000100000000001p+50)))
-(assert_return (invoke "f") (f32.const -0x1.000002p+50))
-(module (func (export "f") (result f32) (f32.const +0x1.000001fffffffffffp+50)))
-(assert_return (invoke "f") (f32.const +0x1.000002p+50))
-(module (func (export "f") (result f32) (f32.const -0x1.000001fffffffffffp+50)))
-(assert_return (invoke "f") (f32.const -0x1.000002p+50))
-(module (func (export "f") (result f32) (f32.const +0x1.00000200000000000p+50)))
-(assert_return (invoke "f") (f32.const +0x1.000002p+50))
-(module (func (export "f") (result f32) (f32.const -0x1.00000200000000000p+50)))
-(assert_return (invoke "f") (f32.const -0x1.000002p+50))
-(module (func (export "f") (result f32) (f32.const +0x1.00000200000000001p+50)))
-(assert_return (invoke "f") (f32.const +0x1.000002p+50))
-(module (func (export "f") (result f32) (f32.const -0x1.00000200000000001p+50)))
-(assert_return (invoke "f") (f32.const -0x1.000002p+50))
-(module (func (export "f") (result f32) (f32.const +0x1.000002fffffffffffp+50)))
-(assert_return (invoke "f") (f32.const +0x1.000002p+50))
-(module (func (export "f") (result f32) (f32.const -0x1.000002fffffffffffp+50)))
-(assert_return (invoke "f") (f32.const -0x1.000002p+50))
-(module (func (export "f") (result f32) (f32.const +0x1.00000300000000000p+50)))
-(assert_return (invoke "f") (f32.const +0x1.000004p+50))
-(module (func (export "f") (result f32) (f32.const -0x1.00000300000000000p+50)))
-(assert_return (invoke "f") (f32.const -0x1.000004p+50))
-(module (func (export "f") (result f32) (f32.const +0x1.00000300000000001p+50)))
-(assert_return (invoke "f") (f32.const +0x1.000004p+50))
-(module (func (export "f") (result f32) (f32.const -0x1.00000300000000001p+50)))
-(assert_return (invoke "f") (f32.const -0x1.000004p+50))
-(module (func (export "f") (result f32) (f32.const +0x1.000003fffffffffffp+50)))
-(assert_return (invoke "f") (f32.const +0x1.000004p+50))
-(module (func (export "f") (result f32) (f32.const -0x1.000003fffffffffffp+50)))
-(assert_return (invoke "f") (f32.const -0x1.000004p+50))
-(module (func (export "f") (result f32) (f32.const +0x1.00000400000000000p+50)))
-(assert_return (invoke "f") (f32.const +0x1.000004p+50))
-(module (func (export "f") (result f32) (f32.const -0x1.00000400000000000p+50)))
-(assert_return (invoke "f") (f32.const -0x1.000004p+50))
-(module (func (export "f") (result f32) (f32.const +0x1.00000400000000001p+50)))
-(assert_return (invoke "f") (f32.const +0x1.000004p+50))
-(module (func (export "f") (result f32) (f32.const -0x1.00000400000000001p+50)))
-(assert_return (invoke "f") (f32.const -0x1.000004p+50))
-(module (func (export "f") (result f32) (f32.const +0x1.000004fffffffffffp+50)))
-(assert_return (invoke "f") (f32.const +0x1.000004p+50))
-(module (func (export "f") (result f32) (f32.const -0x1.000004fffffffffffp+50)))
-(assert_return (invoke "f") (f32.const -0x1.000004p+50))
-(module (func (export "f") (result f32) (f32.const +0x1.00000500000000000p+50)))
-(assert_return (invoke "f") (f32.const +0x1.000004p+50))
-(module (func (export "f") (result f32) (f32.const -0x1.00000500000000000p+50)))
-(assert_return (invoke "f") (f32.const -0x1.000004p+50))
-(module (func (export "f") (result f32) (f32.const +0x1.00000500000000001p+50)))
-(assert_return (invoke "f") (f32.const +0x1.000006p+50))
-(module (func (export "f") (result f32) (f32.const -0x1.00000500000000001p+50)))
-(assert_return (invoke "f") (f32.const -0x1.000006p+50))
-
-(module (func (export "f") (result f32) (f32.const +0x4000004000000)))
-(assert_return (invoke "f") (f32.const +0x1.000000p+50))
-(module (func (export "f") (result f32) (f32.const -0x4000004000000)))
-(assert_return (invoke "f") (f32.const -0x1.000000p+50))
-(module (func (export "f") (result f32) (f32.const +0x4000004000001)))
-(assert_return (invoke "f") (f32.const +0x1.000002p+50))
-(module (func (export "f") (result f32) (f32.const -0x4000004000001)))
-(assert_return (invoke "f") (f32.const -0x1.000002p+50))
-(module (func (export "f") (result f32) (f32.const +0x4000007ffffff)))
-(assert_return (invoke "f") (f32.const +0x1.000002p+50))
-(module (func (export "f") (result f32) (f32.const -0x4000007ffffff)))
-(assert_return (invoke "f") (f32.const -0x1.000002p+50))
-(module (func (export "f") (result f32) (f32.const +0x4000008000000)))
-(assert_return (invoke "f") (f32.const +0x1.000002p+50))
-(module (func (export "f") (result f32) (f32.const -0x4000008000000)))
-(assert_return (invoke "f") (f32.const -0x1.000002p+50))
-(module (func (export "f") (result f32) (f32.const +0x4000008000001)))
-(assert_return (invoke "f") (f32.const +0x1.000002p+50))
-(module (func (export "f") (result f32) (f32.const -0x4000008000001)))
-(assert_return (invoke "f") (f32.const -0x1.000002p+50))
-(module (func (export "f") (result f32) (f32.const +0x400000bffffff)))
-(assert_return (invoke "f") (f32.const +0x1.000002p+50))
-(module (func (export "f") (result f32) (f32.const -0x400000bffffff)))
-(assert_return (invoke "f") (f32.const -0x1.000002p+50))
-(module (func (export "f") (result f32) (f32.const +0x400000c000000)))
-(assert_return (invoke "f") (f32.const +0x1.000004p+50))
-(module (func (export "f") (result f32) (f32.const -0x400000c000000)))
-(assert_return (invoke "f") (f32.const -0x1.000004p+50))
-
-(module (func (export "f") (result f32) (f32.const +1125899973951488)))
-(assert_return (invoke "f") (f32.const +0x1.000000p+50))
-(module (func (export "f") (result f32) (f32.const -1125899973951488)))
-(assert_return (invoke "f") (f32.const -0x1.000000p+50))
-(module (func (export "f") (result f32) (f32.const +1125899973951489)))
-(assert_return (invoke "f") (f32.const +0x1.000002p+50))
-(module (func (export "f") (result f32) (f32.const -1125899973951489)))
-(assert_return (invoke "f") (f32.const -0x1.000002p+50))
-(module (func (export "f") (result f32) (f32.const +1125900108169215)))
-(assert_return (invoke "f") (f32.const +0x1.000002p+50))
-(module (func (export "f") (result f32) (f32.const -1125900108169215)))
-(assert_return (invoke "f") (f32.const -0x1.000002p+50))
-(module (func (export "f") (result f32) (f32.const +1125900108169216)))
-(assert_return (invoke "f") (f32.const +0x1.000004p+50))
-(module (func (export "f") (result f32) (f32.const -1125900108169216)))
-(assert_return (invoke "f") (f32.const -0x1.000004p+50))
-
-;; f32, subnormal
-(module (func (export "f") (result f32) (f32.const +0x0.00000100000000000p-126)))
-(assert_return (invoke "f") (f32.const +0x0.000000p-126))
-(module (func (export "f") (result f32) (f32.const -0x0.00000100000000000p-126)))
-(assert_return (invoke "f") (f32.const -0x0.000000p-126))
-(module (func (export "f") (result f32) (f32.const +0x0.00000100000000001p-126)))
-(assert_return (invoke "f") (f32.const +0x0.000002p-126))
-(module (func (export "f") (result f32) (f32.const -0x0.00000100000000001p-126)))
-(assert_return (invoke "f") (f32.const -0x0.000002p-126))
-(module (func (export "f") (result f32) (f32.const +0x0.000001fffffffffffp-126)))
-(assert_return (invoke "f") (f32.const +0x0.000002p-126))
-(module (func (export "f") (result f32) (f32.const -0x0.000001fffffffffffp-126)))
-(assert_return (invoke "f") (f32.const -0x0.000002p-126))
-(module (func (export "f") (result f32) (f32.const +0x0.00000200000000000p-126)))
-(assert_return (invoke "f") (f32.const +0x0.000002p-126))
-(module (func (export "f") (result f32) (f32.const -0x0.00000200000000000p-126)))
-(assert_return (invoke "f") (f32.const -0x0.000002p-126))
-(module (func (export "f") (result f32) (f32.const +0x0.00000200000000001p-126)))
-(assert_return (invoke "f") (f32.const +0x0.000002p-126))
-(module (func (export "f") (result f32) (f32.const -0x0.00000200000000001p-126)))
-(assert_return (invoke "f") (f32.const -0x0.000002p-126))
-(module (func (export "f") (result f32) (f32.const +0x0.000002fffffffffffp-126)))
-(assert_return (invoke "f") (f32.const +0x0.000002p-126))
-(module (func (export "f") (result f32) (f32.const -0x0.000002fffffffffffp-126)))
-(assert_return (invoke "f") (f32.const -0x0.000002p-126))
-(module (func (export "f") (result f32) (f32.const +0x0.00000300000000000p-126)))
-(assert_return (invoke "f") (f32.const +0x0.000004p-126))
-(module (func (export "f") (result f32) (f32.const -0x0.00000300000000000p-126)))
-(assert_return (invoke "f") (f32.const -0x0.000004p-126))
-(module (func (export "f") (result f32) (f32.const +0x0.00000300000000001p-126)))
-(assert_return (invoke "f") (f32.const +0x0.000004p-126))
-(module (func (export "f") (result f32) (f32.const -0x0.00000300000000001p-126)))
-(assert_return (invoke "f") (f32.const -0x0.000004p-126))
-(module (func (export "f") (result f32) (f32.const +0x0.000003fffffffffffp-126)))
-(assert_return (invoke "f") (f32.const +0x0.000004p-126))
-(module (func (export "f") (result f32) (f32.const -0x0.000003fffffffffffp-126)))
-(assert_return (invoke "f") (f32.const -0x0.000004p-126))
-(module (func (export "f") (result f32) (f32.const +0x0.00000400000000000p-126)))
-(assert_return (invoke "f") (f32.const +0x0.000004p-126))
-(module (func (export "f") (result f32) (f32.const -0x0.00000400000000000p-126)))
-(assert_return (invoke "f") (f32.const -0x0.000004p-126))
-(module (func (export "f") (result f32) (f32.const +0x0.00000400000000001p-126)))
-(assert_return (invoke "f") (f32.const +0x0.000004p-126))
-(module (func (export "f") (result f32) (f32.const -0x0.00000400000000001p-126)))
-(assert_return (invoke "f") (f32.const -0x0.000004p-126))
-(module (func (export "f") (result f32) (f32.const +0x0.000004fffffffffffp-126)))
-(assert_return (invoke "f") (f32.const +0x0.000004p-126))
-(module (func (export "f") (result f32) (f32.const -0x0.000004fffffffffffp-126)))
-(assert_return (invoke "f") (f32.const -0x0.000004p-126))
-(module (func (export "f") (result f32) (f32.const +0x0.00000500000000000p-126)))
-(assert_return (invoke "f") (f32.const +0x0.000004p-126))
-(module (func (export "f") (result f32) (f32.const -0x0.00000500000000000p-126)))
-(assert_return (invoke "f") (f32.const -0x0.000004p-126))
-(module (func (export "f") (result f32) (f32.const +0x0.00000500000000001p-126)))
-(assert_return (invoke "f") (f32.const +0x0.000006p-126))
-(module (func (export "f") (result f32) (f32.const -0x0.00000500000000001p-126)))
-(assert_return (invoke "f") (f32.const -0x0.000006p-126))
-
-;; f32, round down at limit to infinity
-(module (func (export "f") (result f32) (f32.const +0x1.fffffe8p127)))
-(assert_return (invoke "f") (f32.const +0x1.fffffep127))
-(module (func (export "f") (result f32) (f32.const -0x1.fffffe8p127)))
-(assert_return (invoke "f") (f32.const -0x1.fffffep127))
-(module (func (export "f") (result f32) (f32.const +0x1.fffffefffffff8p127)))
-(assert_return (invoke "f") (f32.const +0x1.fffffep127))
-(module (func (export "f") (result f32) (f32.const -0x1.fffffefffffff8p127)))
-(assert_return (invoke "f") (f32.const -0x1.fffffep127))
-(module (func (export "f") (result f32) (f32.const +0x1.fffffefffffffffffp127)))
-(assert_return (invoke "f") (f32.const +0x1.fffffep127))
-(module (func (export "f") (result f32) (f32.const -0x1.fffffefffffffffffp127)))
-(assert_return (invoke "f") (f32.const -0x1.fffffep127))
-
-
-(module
-  (func $id-f32 (param f32) (result f32) (local.get 0))
-  (func (export "type-first-f32") (result f32) (call $id-f32 (f32.const 1.32)))
-)
-(assert_return (invoke "type-first-f32") (f32.const 1.32))
-
-
-(module
-  (func (export "ceil") (param $x f32) (result f32) (f32.ceil (local.get $x)))
-  (func (export "floor") (param $x f32) (result f32) (f32.floor (local.get $x)))
-  (func (export "trunc") (param $x f32) (result f32) (f32.trunc (local.get $x)))
-  (func (export "nearest") (param $x f32) (result f32) (f32.nearest (local.get $x)))
-)
-
-(assert_return (invoke "floor" (f32.const -0x0p+0)) (f32.const -0x0p+0))
-(assert_return (invoke "floor" (f32.const 0x0p+0)) (f32.const 0x0p+0))
-(assert_return (invoke "floor" (f32.const -0x1p-149)) (f32.const -0x1p+0))
-(assert_return (invoke "floor" (f32.const 0x1p-149)) (f32.const 0x0p+0))
-(assert_return (invoke "floor" (f32.const -0x1p-126)) (f32.const -0x1p+0))
-(assert_return (invoke "floor" (f32.const 0x1p-126)) (f32.const 0x0p+0))
-(assert_return (invoke "floor" (f32.const -0x1p-1)) (f32.const -0x1p+0))
-(assert_return (invoke "floor" (f32.const 0x1p-1)) (f32.const 0x0p+0))
-(assert_return (invoke "floor" (f32.const -0x1p+0)) (f32.const -0x1p+0))
-(assert_return (invoke "floor" (f32.const 0x1p+0)) (f32.const 0x1p+0))
-(assert_return (invoke "floor" (f32.const -0x1.921fb6p+2)) (f32.const -0x1.cp+2))
-(assert_return (invoke "floor" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.8p+2))
-(assert_return (invoke "floor" (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "floor" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "floor" (f32.const -inf)) (f32.const -inf))
-(assert_return (invoke "floor" (f32.const inf)) (f32.const inf))
-(assert_return (invoke "floor" (f32.const -nan)) (f32.const nan:canonical))
-(assert_return (invoke "floor" (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
-(assert_return (invoke "floor" (f32.const nan)) (f32.const nan:canonical))
-(assert_return (invoke "floor" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
-(assert_return (invoke "ceil" (f32.const -0x0p+0)) (f32.const -0x0p+0))
-(assert_return (invoke "ceil" (f32.const 0x0p+0)) (f32.const 0x0p+0))
-(assert_return (invoke "ceil" (f32.const -0x1p-149)) (f32.const -0x0p+0))
-(assert_return (invoke "ceil" (f32.const 0x1p-149)) (f32.const 0x1p+0))
-(assert_return (invoke "ceil" (f32.const -0x1p-126)) (f32.const -0x0p+0))
-(assert_return (invoke "ceil" (f32.const 0x1p-126)) (f32.const 0x1p+0))
-(assert_return (invoke "ceil" (f32.const -0x1p-1)) (f32.const -0x0p+0))
-(assert_return (invoke "ceil" (f32.const 0x1p-1)) (f32.const 0x1p+0))
-(assert_return (invoke "ceil" (f32.const -0x1p+0)) (f32.const -0x1p+0))
-(assert_return (invoke "ceil" (f32.const 0x1p+0)) (f32.const 0x1p+0))
-(assert_return (invoke "ceil" (f32.const -0x1.921fb6p+2)) (f32.const -0x1.8p+2))
-(assert_return (invoke "ceil" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.cp+2))
-(assert_return (invoke "ceil" (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "ceil" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "ceil" (f32.const -inf)) (f32.const -inf))
-(assert_return (invoke "ceil" (f32.const inf)) (f32.const inf))
-(assert_return (invoke "ceil" (f32.const -nan)) (f32.const nan:canonical))
-(assert_return (invoke "ceil" (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
-(assert_return (invoke "ceil" (f32.const nan)) (f32.const nan:canonical))
-(assert_return (invoke "ceil" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
-(assert_return (invoke "trunc" (f32.const -0x0p+0)) (f32.const -0x0p+0))
-(assert_return (invoke "trunc" (f32.const 0x0p+0)) (f32.const 0x0p+0))
-(assert_return (invoke "trunc" (f32.const -0x1p-149)) (f32.const -0x0p+0))
-(assert_return (invoke "trunc" (f32.const 0x1p-149)) (f32.const 0x0p+0))
-(assert_return (invoke "trunc" (f32.const -0x1p-126)) (f32.const -0x0p+0))
-(assert_return (invoke "trunc" (f32.const 0x1p-126)) (f32.const 0x0p+0))
-(assert_return (invoke "trunc" (f32.const -0x1p-1)) (f32.const -0x0p+0))
-(assert_return (invoke "trunc" (f32.const 0x1p-1)) (f32.const 0x0p+0))
-(assert_return (invoke "trunc" (f32.const -0x1p+0)) (f32.const -0x1p+0))
-(assert_return (invoke "trunc" (f32.const 0x1p+0)) (f32.const 0x1p+0))
-(assert_return (invoke "trunc" (f32.const -0x1.921fb6p+2)) (f32.const -0x1.8p+2))
-(assert_return (invoke "trunc" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.8p+2))
-(assert_return (invoke "trunc" (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "trunc" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "trunc" (f32.const -inf)) (f32.const -inf))
-(assert_return (invoke "trunc" (f32.const inf)) (f32.const inf))
-(assert_return (invoke "trunc" (f32.const -nan)) (f32.const nan:canonical))
-(assert_return (invoke "trunc" (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
-(assert_return (invoke "trunc" (f32.const nan)) (f32.const nan:canonical))
-(assert_return (invoke "trunc" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
-(assert_return (invoke "nearest" (f32.const -0x0p+0)) (f32.const -0x0p+0))
-(assert_return (invoke "nearest" (f32.const 0x0p+0)) (f32.const 0x0p+0))
-(assert_return (invoke "nearest" (f32.const -0x1p-149)) (f32.const -0x0p+0))
-(assert_return (invoke "nearest" (f32.const 0x1p-149)) (f32.const 0x0p+0))
-(assert_return (invoke "nearest" (f32.const -0x1p-126)) (f32.const -0x0p+0))
-(assert_return (invoke "nearest" (f32.const 0x1p-126)) (f32.const 0x0p+0))
-(assert_return (invoke "nearest" (f32.const -0x1p-1)) (f32.const -0x0p+0))
-(assert_return (invoke "nearest" (f32.const 0x1p-1)) (f32.const 0x0p+0))
-(assert_return (invoke "nearest" (f32.const -0x1p+0)) (f32.const -0x1p+0))
-(assert_return (invoke "nearest" (f32.const 0x1p+0)) (f32.const 0x1p+0))
-(assert_return (invoke "nearest" (f32.const -0x1.921fb6p+2)) (f32.const -0x1.8p+2))
-(assert_return (invoke "nearest" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.8p+2))
-(assert_return (invoke "nearest" (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "nearest" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "nearest" (f32.const -inf)) (f32.const -inf))
-(assert_return (invoke "nearest" (f32.const inf)) (f32.const inf))
-(assert_return (invoke "nearest" (f32.const -nan)) (f32.const nan:canonical))
-(assert_return (invoke "nearest" (f32.const -nan:0x200000)) (f32.const nan:arithmetic))
-(assert_return (invoke "nearest" (f32.const nan)) (f32.const nan:canonical))
-(assert_return (invoke "nearest" (f32.const nan:0x200000)) (f32.const nan:arithmetic))
diff --git a/tests/misc_testsuite/winch/f32_bitwise.wast b/tests/misc_testsuite/winch/f32_bitwise.wast
deleted file mode 100644
index 4816fceb43ea..000000000000
--- a/tests/misc_testsuite/winch/f32_bitwise.wast
+++ /dev/null
@@ -1,50 +0,0 @@
-;; Test all the f32 bitwise operators on major boundary values and all special
-;; values.
-
-(module
-  (func (export "abs") (param $x f32) (result f32) (f32.abs (local.get $x)))
-  (func (export "neg") (param $x f32) (result f32) (f32.neg (local.get $x)))
-)
-
-(assert_return (invoke "abs" (f32.const -0x0p+0)) (f32.const 0x0p+0))
-(assert_return (invoke "abs" (f32.const 0x0p+0)) (f32.const 0x0p+0))
-(assert_return (invoke "abs" (f32.const -0x1p-149)) (f32.const 0x1p-149))
-(assert_return (invoke "abs" (f32.const 0x1p-149)) (f32.const 0x1p-149))
-(assert_return (invoke "abs" (f32.const -0x1p-126)) (f32.const 0x1p-126))
-(assert_return (invoke "abs" (f32.const 0x1p-126)) (f32.const 0x1p-126))
-(assert_return (invoke "abs" (f32.const -0x1p-1)) (f32.const 0x1p-1))
-(assert_return (invoke "abs" (f32.const 0x1p-1)) (f32.const 0x1p-1))
-(assert_return (invoke "abs" (f32.const -0x1p+0)) (f32.const 0x1p+0))
-(assert_return (invoke "abs" (f32.const 0x1p+0)) (f32.const 0x1p+0))
-(assert_return (invoke "abs" (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "abs" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "abs" (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "abs" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "abs" (f32.const -inf)) (f32.const inf))
-(assert_return (invoke "abs" (f32.const inf)) (f32.const inf))
-(assert_return (invoke "abs" (f32.const -nan)) (f32.const nan))
-(assert_return (invoke "abs" (f32.const nan)) (f32.const nan))
-(assert_return (invoke "neg" (f32.const -0x0p+0)) (f32.const 0x0p+0))
-(assert_return (invoke "neg" (f32.const 0x0p+0)) (f32.const -0x0p+0))
-(assert_return (invoke "neg" (f32.const -0x1p-149)) (f32.const 0x1p-149))
-(assert_return (invoke "neg" (f32.const 0x1p-149)) (f32.const -0x1p-149))
-(assert_return (invoke "neg" (f32.const -0x1p-126)) (f32.const 0x1p-126))
-(assert_return (invoke "neg" (f32.const 0x1p-126)) (f32.const -0x1p-126))
-(assert_return (invoke "neg" (f32.const -0x1p-1)) (f32.const 0x1p-1))
-(assert_return (invoke "neg" (f32.const 0x1p-1)) (f32.const -0x1p-1))
-(assert_return (invoke "neg" (f32.const -0x1p+0)) (f32.const 0x1p+0))
-(assert_return (invoke "neg" (f32.const 0x1p+0)) (f32.const -0x1p+0))
-(assert_return (invoke "neg" (f32.const -0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "neg" (f32.const 0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
-(assert_return (invoke "neg" (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "neg" (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "neg" (f32.const -inf)) (f32.const inf))
-(assert_return (invoke "neg" (f32.const inf)) (f32.const -inf))
-(assert_return (invoke "neg" (f32.const -nan)) (f32.const nan))
-(assert_return (invoke "neg" (f32.const nan)) (f32.const -nan))
-
-
-;; Type check
-
-(assert_invalid (module (func (result f32) (f32.abs (i64.const 0)))) "type mismatch")
-(assert_invalid (module (func (result f32) (f32.neg (i64.const 0)))) "type mismatch")
diff --git a/tests/misc_testsuite/winch/f64.wast b/tests/misc_testsuite/winch/f64.wast
deleted file mode 100644
index 7acb99be620c..000000000000
--- a/tests/misc_testsuite/winch/f64.wast
+++ /dev/null
@@ -1,417 +0,0 @@
-;; f64, small exponent
-(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000000p-600)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000000p-600))
-(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000000p-600)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000000p-600))
-(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000001p-600)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
-(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000001p-600)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
-(module (func (export "f") (result f64) (f64.const +0x1.0000000000000fffffffffffp-600)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
-(module (func (export "f") (result f64) (f64.const -0x1.0000000000000fffffffffffp-600)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
-(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000000p-600)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
-(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000000p-600)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
-(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000001p-600)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
-(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000001p-600)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
-(module (func (export "f") (result f64) (f64.const +0x1.00000000000017ffffffffffp-600)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
-(module (func (export "f") (result f64) (f64.const -0x1.00000000000017ffffffffffp-600)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
-(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000000p-600)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
-(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000000p-600)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
-(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000001p-600)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
-(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000001p-600)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
-(module (func (export "f") (result f64) (f64.const +0x1.0000000000001fffffffffffp-600)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
-(module (func (export "f") (result f64) (f64.const -0x1.0000000000001fffffffffffp-600)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
-(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000000p-600)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
-(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000000p-600)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
-(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000001p-600)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
-(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000001p-600)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
-(module (func (export "f") (result f64) (f64.const +0x1.00000000000027ffffffffffp-600)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
-(module (func (export "f") (result f64) (f64.const -0x1.00000000000027ffffffffffp-600)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
-(module (func (export "f") (result f64) (f64.const +0x1.000000000000280000000001p-600)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000003p-600))
-(module (func (export "f") (result f64) (f64.const -0x1.000000000000280000000001p-600)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000003p-600))
-
-(module (func (export "f") (result f64) (f64.const +0x8000000.000000400000000000p-627)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000000p-600))
-(module (func (export "f") (result f64) (f64.const -0x8000000.000000400000000000p-627)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000000p-600))
-(module (func (export "f") (result f64) (f64.const +0x8000000.000000400000000001p-627)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
-(module (func (export "f") (result f64) (f64.const -0x8000000.000000400000000001p-627)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
-(module (func (export "f") (result f64) (f64.const +0x8000000.0000007fffffffffffp-627)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
-(module (func (export "f") (result f64) (f64.const -0x8000000.0000007fffffffffffp-627)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
-(module (func (export "f") (result f64) (f64.const +0x8000000.000000800000000000p-627)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
-(module (func (export "f") (result f64) (f64.const -0x8000000.000000800000000000p-627)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
-(module (func (export "f") (result f64) (f64.const +0x8000000.000000800000000001p-627)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
-(module (func (export "f") (result f64) (f64.const -0x8000000.000000800000000001p-627)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
-(module (func (export "f") (result f64) (f64.const +0x8000000.000000bfffffffffffp-627)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000001p-600))
-(module (func (export "f") (result f64) (f64.const -0x8000000.000000bfffffffffffp-627)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000001p-600))
-(module (func (export "f") (result f64) (f64.const +0x8000000.000000c00000000000p-627)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
-(module (func (export "f") (result f64) (f64.const -0x8000000.000000c00000000000p-627)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
-(module (func (export "f") (result f64) (f64.const +0x8000000.000000c00000000001p-627)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
-(module (func (export "f") (result f64) (f64.const -0x8000000.000000c00000000001p-627)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
-(module (func (export "f") (result f64) (f64.const +0x8000000.000000ffffffffffffp-627)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
-(module (func (export "f") (result f64) (f64.const -0x8000000.000000ffffffffffffp-627)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
-(module (func (export "f") (result f64) (f64.const +0x8000000.000001000000000000p-627)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
-(module (func (export "f") (result f64) (f64.const -0x8000000.000001000000000000p-627)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
-(module (func (export "f") (result f64) (f64.const +0x8000000.000001000000000001p-627)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
-(module (func (export "f") (result f64) (f64.const -0x8000000.000001000000000001p-627)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
-(module (func (export "f") (result f64) (f64.const +0x8000000.0000013fffffffffffp-627)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000002p-600))
-(module (func (export "f") (result f64) (f64.const -0x8000000.0000013fffffffffffp-627)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000002p-600))
-(module (func (export "f") (result f64) (f64.const +0x8000000.000001400000000001p-627)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000003p-600))
-(module (func (export "f") (result f64) (f64.const -0x8000000.000001400000000001p-627)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000003p-600))
-
-(module (func (export "f") (result f64) (f64.const +5.3575430359313371995e+300)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000000p+999))
-(module (func (export "f") (result f64) (f64.const -5.3575430359313371995e+300)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000000p+999))
-(module (func (export "f") (result f64) (f64.const +5.3575430359313371996e+300)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000001p+999))
-(module (func (export "f") (result f64) (f64.const -5.3575430359313371996e+300)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000001p+999))
-(module (func (export "f") (result f64) (f64.const +5.3575430359313383891e+300)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000001p+999))
-(module (func (export "f") (result f64) (f64.const -5.3575430359313383891e+300)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000001p+999))
-(module (func (export "f") (result f64) (f64.const +5.3575430359313383892e+300)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000002p+999))
-(module (func (export "f") (result f64) (f64.const -5.3575430359313383892e+300)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000002p+999))
-
-;; f64, large exponent
-(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000000p+600)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000000p+600))
-(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000000p+600)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000000p+600))
-(module (func (export "f") (result f64) (f64.const +0x1.000000000000080000000001p+600)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000001p+600))
-(module (func (export "f") (result f64) (f64.const -0x1.000000000000080000000001p+600)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000001p+600))
-(module (func (export "f") (result f64) (f64.const +0x1.0000000000000fffffffffffp+600)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000001p+600))
-(module (func (export "f") (result f64) (f64.const -0x1.0000000000000fffffffffffp+600)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000001p+600))
-(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000000p+600)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000001p+600))
-(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000000p+600)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000001p+600))
-(module (func (export "f") (result f64) (f64.const +0x1.000000000000100000000001p+600)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000001p+600))
-(module (func (export "f") (result f64) (f64.const -0x1.000000000000100000000001p+600)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000001p+600))
-(module (func (export "f") (result f64) (f64.const +0x1.00000000000017ffffffffffp+600)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000001p+600))
-(module (func (export "f") (result f64) (f64.const -0x1.00000000000017ffffffffffp+600)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000001p+600))
-(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000000p+600)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000002p+600))
-(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000000p+600)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000002p+600))
-(module (func (export "f") (result f64) (f64.const +0x1.000000000000180000000001p+600)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000002p+600))
-(module (func (export "f") (result f64) (f64.const -0x1.000000000000180000000001p+600)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000002p+600))
-(module (func (export "f") (result f64) (f64.const +0x1.0000000000001fffffffffffp+600)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000002p+600))
-(module (func (export "f") (result f64) (f64.const -0x1.0000000000001fffffffffffp+600)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000002p+600))
-(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000000p+600)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000002p+600))
-(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000000p+600)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000002p+600))
-(module (func (export "f") (result f64) (f64.const +0x1.000000000000200000000001p+600)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000002p+600))
-(module (func (export "f") (result f64) (f64.const -0x1.000000000000200000000001p+600)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000002p+600))
-(module (func (export "f") (result f64) (f64.const +0x1.00000000000027ffffffffffp+600)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000002p+600))
-(module (func (export "f") (result f64) (f64.const -0x1.00000000000027ffffffffffp+600)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000002p+600))
-(module (func (export "f") (result f64) (f64.const +0x1.000000000000280000000000p+600)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000002p+600))
-(module (func (export "f") (result f64) (f64.const -0x1.000000000000280000000000p+600)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000002p+600))
-(module (func (export "f") (result f64) (f64.const +0x1.000000000000280000000001p+600)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000003p+600))
-(module (func (export "f") (result f64) (f64.const -0x1.000000000000280000000001p+600)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000003p+600))
-
-(module (func (export "f") (result f64) (f64.const +0x2000000000000100000000000)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000000p+97))
-(module (func (export "f") (result f64) (f64.const -0x2000000000000100000000000)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000000p+97))
-(module (func (export "f") (result f64) (f64.const +0x2000000000000100000000001)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000001p+97))
-(module (func (export "f") (result f64) (f64.const -0x2000000000000100000000001)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000001p+97))
-(module (func (export "f") (result f64) (f64.const +0x20000000000001fffffffffff)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000001p+97))
-(module (func (export "f") (result f64) (f64.const -0x20000000000001fffffffffff)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000001p+97))
-(module (func (export "f") (result f64) (f64.const +0x2000000000000200000000000)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000001p+97))
-(module (func (export "f") (result f64) (f64.const -0x2000000000000200000000000)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000001p+97))
-(module (func (export "f") (result f64) (f64.const +0x2000000000000200000000001)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000001p+97))
-(module (func (export "f") (result f64) (f64.const -0x2000000000000200000000001)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000001p+97))
-(module (func (export "f") (result f64) (f64.const +0x20000000000002fffffffffff)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000001p+97))
-(module (func (export "f") (result f64) (f64.const -0x20000000000002fffffffffff)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000001p+97))
-(module (func (export "f") (result f64) (f64.const +0x2000000000000300000000000)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000002p+97))
-(module (func (export "f") (result f64) (f64.const -0x2000000000000300000000000)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000002p+97))
-(module (func (export "f") (result f64) (f64.const +0x2000000000000300000000001)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000002p+97))
-(module (func (export "f") (result f64) (f64.const -0x2000000000000300000000001)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000002p+97))
-(module (func (export "f") (result f64) (f64.const +0x20000000000003fffffffffff)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000002p+97))
-(module (func (export "f") (result f64) (f64.const -0x20000000000003fffffffffff)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000002p+97))
-(module (func (export "f") (result f64) (f64.const +0x2000000000000400000000000)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000002p+97))
-(module (func (export "f") (result f64) (f64.const -0x2000000000000400000000000)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000002p+97))
-(module (func (export "f") (result f64) (f64.const +0x2000000000000400000000001)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000002p+97))
-(module (func (export "f") (result f64) (f64.const -0x2000000000000400000000001)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000002p+97))
-(module (func (export "f") (result f64) (f64.const +0x20000000000004fffffffffff)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000002p+97))
-(module (func (export "f") (result f64) (f64.const -0x20000000000004fffffffffff)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000002p+97))
-(module (func (export "f") (result f64) (f64.const +0x2000000000000500000000000)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000002p+97))
-(module (func (export "f") (result f64) (f64.const -0x2000000000000500000000000)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000002p+97))
-(module (func (export "f") (result f64) (f64.const +0x2000000000000500000000001)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000003p+97))
-(module (func (export "f") (result f64) (f64.const -0x2000000000000500000000001)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000003p+97))
-
-(module (func (export "f") (result f64) (f64.const +1152921504606847104)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000000p+60))
-(module (func (export "f") (result f64) (f64.const -1152921504606847104)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000000p+60))
-(module (func (export "f") (result f64) (f64.const +1152921504606847105)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000001p+60))
-(module (func (export "f") (result f64) (f64.const -1152921504606847105)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000001p+60))
-(module (func (export "f") (result f64) (f64.const +1152921504606847359)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000001p+60))
-(module (func (export "f") (result f64) (f64.const -1152921504606847359)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000001p+60))
-(module (func (export "f") (result f64) (f64.const +1152921504606847360)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000002p+60))
-(module (func (export "f") (result f64) (f64.const -1152921504606847360)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000002p+60))
-
-;; f64, subnormal
-(module (func (export "f") (result f64) (f64.const +0x0.000000000000080000000000p-1022)))
-(assert_return (invoke "f") (f64.const +0x0.0000000000000p-1022))
-(module (func (export "f") (result f64) (f64.const -0x0.000000000000080000000000p-1022)))
-(assert_return (invoke "f") (f64.const -0x0.0000000000000p-1022))
-(module (func (export "f") (result f64) (f64.const +0x0.000000000000080000000001p-1022)))
-(assert_return (invoke "f") (f64.const +0x0.0000000000001p-1022))
-(module (func (export "f") (result f64) (f64.const -0x0.000000000000080000000001p-1022)))
-(assert_return (invoke "f") (f64.const -0x0.0000000000001p-1022))
-(module (func (export "f") (result f64) (f64.const +0x0.0000000000000fffffffffffp-1022)))
-(assert_return (invoke "f") (f64.const +0x0.0000000000001p-1022))
-(module (func (export "f") (result f64) (f64.const -0x0.0000000000000fffffffffffp-1022)))
-(assert_return (invoke "f") (f64.const -0x0.0000000000001p-1022))
-(module (func (export "f") (result f64) (f64.const +0x0.000000000000100000000000p-1022)))
-(assert_return (invoke "f") (f64.const +0x0.0000000000001p-1022))
-(module (func (export "f") (result f64) (f64.const -0x0.000000000000100000000000p-1022)))
-(assert_return (invoke "f") (f64.const -0x0.0000000000001p-1022))
-(module (func (export "f") (result f64) (f64.const +0x0.000000000000100000000001p-1022)))
-(assert_return (invoke "f") (f64.const +0x0.0000000000001p-1022))
-(module (func (export "f") (result f64) (f64.const -0x0.000000000000100000000001p-1022)))
-(assert_return (invoke "f") (f64.const -0x0.0000000000001p-1022))
-(module (func (export "f") (result f64) (f64.const +0x0.00000000000017ffffffffffp-1022)))
-(assert_return (invoke "f") (f64.const +0x0.0000000000001p-1022))
-(module (func (export "f") (result f64) (f64.const -0x0.00000000000017ffffffffffp-1022)))
-(assert_return (invoke "f") (f64.const -0x0.0000000000001p-1022))
-(module (func (export "f") (result f64) (f64.const +0x0.000000000000180000000000p-1022)))
-(assert_return (invoke "f") (f64.const +0x0.0000000000002p-1022))
-(module (func (export "f") (result f64) (f64.const -0x0.000000000000180000000000p-1022)))
-(assert_return (invoke "f") (f64.const -0x0.0000000000002p-1022))
-(module (func (export "f") (result f64) (f64.const +0x0.000000000000180000000001p-1022)))
-(assert_return (invoke "f") (f64.const +0x0.0000000000002p-1022))
-(module (func (export "f") (result f64) (f64.const -0x0.000000000000180000000001p-1022)))
-(assert_return (invoke "f") (f64.const -0x0.0000000000002p-1022))
-(module (func (export "f") (result f64) (f64.const +0x0.0000000000001fffffffffffp-1022)))
-(assert_return (invoke "f") (f64.const +0x0.0000000000002p-1022))
-(module (func (export "f") (result f64) (f64.const -0x0.0000000000001fffffffffffp-1022)))
-(assert_return (invoke "f") (f64.const -0x0.0000000000002p-1022))
-(module (func (export "f") (result f64) (f64.const +0x0.000000000000200000000000p-1022)))
-(assert_return (invoke "f") (f64.const +0x0.0000000000002p-1022))
-(module (func (export "f") (result f64) (f64.const -0x0.000000000000200000000000p-1022)))
-(assert_return (invoke "f") (f64.const -0x0.0000000000002p-1022))
-(module (func (export "f") (result f64) (f64.const +0x0.000000000000200000000001p-1022)))
-(assert_return (invoke "f") (f64.const +0x0.0000000000002p-1022))
-(module (func (export "f") (result f64) (f64.const -0x0.000000000000200000000001p-1022)))
-(assert_return (invoke "f") (f64.const -0x0.0000000000002p-1022))
-(module (func (export "f") (result f64) (f64.const +0x0.00000000000027ffffffffffp-1022)))
-(assert_return (invoke "f") (f64.const +0x0.0000000000002p-1022))
-(module (func (export "f") (result f64) (f64.const -0x0.00000000000027ffffffffffp-1022)))
-(assert_return (invoke "f") (f64.const -0x0.0000000000002p-1022))
-(module (func (export "f") (result f64) (f64.const +0x0.000000000000280000000000p-1022)))
-(assert_return (invoke "f") (f64.const +0x0.0000000000002p-1022))
-(module (func (export "f") (result f64) (f64.const -0x0.000000000000280000000000p-1022)))
-(assert_return (invoke "f") (f64.const -0x0.0000000000002p-1022))
-(module (func (export "f") (result f64) (f64.const +0x1.000000000000280000000001p-1022)))
-(assert_return (invoke "f") (f64.const +0x1.0000000000003p-1022))
-(module (func (export "f") (result f64) (f64.const -0x1.000000000000280000000001p-1022)))
-(assert_return (invoke "f") (f64.const -0x1.0000000000003p-1022))
-
-;; f64, round down at limit to infinity
-(module (func (export "f") (result f64) (f64.const +0x1.fffffffffffff4p1023)))
-(assert_return (invoke "f") (f64.const +0x1.fffffffffffffp1023))
-(module (func (export "f") (result f64) (f64.const -0x1.fffffffffffff4p1023)))
-(assert_return (invoke "f") (f64.const -0x1.fffffffffffffp1023))
-(module (func (export "f") (result f64) (f64.const +0x1.fffffffffffff7ffffffp1023)))
-(assert_return (invoke "f") (f64.const +0x1.fffffffffffffp1023))
-(module (func (export "f") (result f64) (f64.const -0x1.fffffffffffff7ffffffp1023)))
-(assert_return (invoke "f") (f64.const -0x1.fffffffffffffp1023))
-
-(module
-  (func $id-f64 (param f64) (result f64) (local.get 0))
-  (func (export "type-first-f64") (result f64) (call $id-f64 (f64.const 1.64)))
-)
-(assert_return (invoke "type-first-f64") (f64.const 1.64))
-
-(module
-  (func (export "ceil") (param $x f64) (result f64) (f64.ceil (local.get $x)))
-  (func (export "floor") (param $x f64) (result f64) (f64.floor (local.get $x)))
-  (func (export "trunc") (param $x f64) (result f64) (f64.trunc (local.get $x)))
-  (func (export "nearest") (param $x f64) (result f64) (f64.nearest (local.get $x)))
-)
-
-(assert_return (invoke "floor" (f64.const -0x0p+0)) (f64.const -0x0p+0))
-(assert_return (invoke "floor" (f64.const 0x0p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "floor" (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+0))
-(assert_return (invoke "floor" (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "floor" (f64.const -0x1p-1022)) (f64.const -0x1p+0))
-(assert_return (invoke "floor" (f64.const 0x1p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "floor" (f64.const -0x1p-1)) (f64.const -0x1p+0))
-(assert_return (invoke "floor" (f64.const 0x1p-1)) (f64.const 0x0p+0))
-(assert_return (invoke "floor" (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "floor" (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "floor" (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.cp+2))
-(assert_return (invoke "floor" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.8p+2))
-(assert_return (invoke "floor" (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "floor" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "floor" (f64.const -inf)) (f64.const -inf))
-(assert_return (invoke "floor" (f64.const inf)) (f64.const inf))
-(assert_return (invoke "floor" (f64.const -nan)) (f64.const nan:canonical))
-(assert_return (invoke "floor" (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
-(assert_return (invoke "floor" (f64.const nan)) (f64.const nan:canonical))
-(assert_return (invoke "floor" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
-(assert_return (invoke "ceil" (f64.const -0x0p+0)) (f64.const -0x0p+0))
-(assert_return (invoke "ceil" (f64.const 0x0p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "ceil" (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "ceil" (f64.const 0x0.0000000000001p-1022)) (f64.const 0x1p+0))
-(assert_return (invoke "ceil" (f64.const -0x1p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "ceil" (f64.const 0x1p-1022)) (f64.const 0x1p+0))
-(assert_return (invoke "ceil" (f64.const -0x1p-1)) (f64.const -0x0p+0))
-(assert_return (invoke "ceil" (f64.const 0x1p-1)) (f64.const 0x1p+0))
-(assert_return (invoke "ceil" (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "ceil" (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "ceil" (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.8p+2))
-(assert_return (invoke "ceil" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.cp+2))
-(assert_return (invoke "ceil" (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "ceil" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "ceil" (f64.const -inf)) (f64.const -inf))
-(assert_return (invoke "ceil" (f64.const inf)) (f64.const inf))
-(assert_return (invoke "ceil" (f64.const -nan)) (f64.const nan:canonical))
-(assert_return (invoke "ceil" (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
-(assert_return (invoke "ceil" (f64.const nan)) (f64.const nan:canonical))
-(assert_return (invoke "ceil" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
-(assert_return (invoke "trunc" (f64.const -0x0p+0)) (f64.const -0x0p+0))
-(assert_return (invoke "trunc" (f64.const 0x0p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "trunc" (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "trunc" (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "trunc" (f64.const -0x1p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "trunc" (f64.const 0x1p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "trunc" (f64.const -0x1p-1)) (f64.const -0x0p+0))
-(assert_return (invoke "trunc" (f64.const 0x1p-1)) (f64.const 0x0p+0))
-(assert_return (invoke "trunc" (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "trunc" (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "trunc" (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.8p+2))
-(assert_return (invoke "trunc" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.8p+2))
-(assert_return (invoke "trunc" (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "trunc" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "trunc" (f64.const -inf)) (f64.const -inf))
-(assert_return (invoke "trunc" (f64.const inf)) (f64.const inf))
-(assert_return (invoke "trunc" (f64.const -nan)) (f64.const nan:canonical))
-(assert_return (invoke "trunc" (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
-(assert_return (invoke "trunc" (f64.const nan)) (f64.const nan:canonical))
-(assert_return (invoke "trunc" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
-(assert_return (invoke "nearest" (f64.const -0x0p+0)) (f64.const -0x0p+0))
-(assert_return (invoke "nearest" (f64.const 0x0p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "nearest" (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "nearest" (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "nearest" (f64.const -0x1p-1022)) (f64.const -0x0p+0))
-(assert_return (invoke "nearest" (f64.const 0x1p-1022)) (f64.const 0x0p+0))
-(assert_return (invoke "nearest" (f64.const -0x1p-1)) (f64.const -0x0p+0))
-(assert_return (invoke "nearest" (f64.const 0x1p-1)) (f64.const 0x0p+0))
-(assert_return (invoke "nearest" (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "nearest" (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "nearest" (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.8p+2))
-(assert_return (invoke "nearest" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.8p+2))
-(assert_return (invoke "nearest" (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "nearest" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "nearest" (f64.const -inf)) (f64.const -inf))
-(assert_return (invoke "nearest" (f64.const inf)) (f64.const inf))
-(assert_return (invoke "nearest" (f64.const -nan)) (f64.const nan:canonical))
-(assert_return (invoke "nearest" (f64.const -nan:0x4000000000000)) (f64.const nan:arithmetic))
-(assert_return (invoke "nearest" (f64.const nan)) (f64.const nan:canonical))
-(assert_return (invoke "nearest" (f64.const nan:0x4000000000000)) (f64.const nan:arithmetic))
diff --git a/tests/misc_testsuite/winch/f64_bitwise.wast b/tests/misc_testsuite/winch/f64_bitwise.wast
deleted file mode 100644
index d6b85d0fce84..000000000000
--- a/tests/misc_testsuite/winch/f64_bitwise.wast
+++ /dev/null
@@ -1,50 +0,0 @@
-;; Test all the f64 bitwise operators on major boundary values and all special
-;; values.
-
-(module
-  (func (export "abs") (param $x f64) (result f64) (f64.abs (local.get $x)))
-  (func (export "neg") (param $x f64) (result f64) (f64.neg (local.get $x)))
-)
-
-(assert_return (invoke "abs" (f64.const -0x0p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "abs" (f64.const 0x0p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "abs" (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "abs" (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "abs" (f64.const -0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "abs" (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "abs" (f64.const -0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "abs" (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "abs" (f64.const -0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "abs" (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "abs" (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "abs" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "abs" (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "abs" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "abs" (f64.const -inf)) (f64.const inf))
-(assert_return (invoke "abs" (f64.const inf)) (f64.const inf))
-(assert_return (invoke "abs" (f64.const -nan)) (f64.const nan))
-(assert_return (invoke "abs" (f64.const nan)) (f64.const nan))
-(assert_return (invoke "neg" (f64.const -0x0p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "neg" (f64.const 0x0p+0)) (f64.const -0x0p+0))
-(assert_return (invoke "neg" (f64.const -0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "neg" (f64.const 0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "neg" (f64.const -0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "neg" (f64.const 0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "neg" (f64.const -0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "neg" (f64.const 0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "neg" (f64.const -0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "neg" (f64.const 0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "neg" (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "neg" (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "neg" (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "neg" (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "neg" (f64.const -inf)) (f64.const inf))
-(assert_return (invoke "neg" (f64.const inf)) (f64.const -inf))
-(assert_return (invoke "neg" (f64.const -nan)) (f64.const nan))
-(assert_return (invoke "neg" (f64.const nan)) (f64.const -nan))
-
-
-;; Type check
-
-(assert_invalid (module (func (result f64) (f64.abs (i64.const 0)))) "type mismatch")
-(assert_invalid (module (func (result f64) (f64.neg (i64.const 0)))) "type mismatch")
diff --git a/tests/misc_testsuite/winch/float-comparison.wast b/tests/misc_testsuite/winch/float-comparison.wast
new file mode 100644
index 000000000000..2e730847a7d9
--- /dev/null
+++ b/tests/misc_testsuite/winch/float-comparison.wast
@@ -0,0 +1,13 @@
+(module
+  (func (result i32 i32 i32)
+    i32.const 1
+    i32.eqz
+    f64.const 0
+    f64.const 1
+    f64.ne
+    i32.const 1111
+  )
+  (export "d" (func 0))
+)
+
+(assert_return (invoke "d") (i32.const 0) (i32.const 1) (i32.const 1111))
diff --git a/tests/misc_testsuite/winch/global.wast b/tests/misc_testsuite/winch/global.wast
new file mode 100644
index 000000000000..7f7ad15fb895
--- /dev/null
+++ b/tests/misc_testsuite/winch/global.wast
@@ -0,0 +1,209 @@
+;; Test globals
+
+(module
+  (global (import "spectest" "global_i32") i32)
+  (global (import "spectest" "global_i64") i64)
+
+  (global $a i32 (i32.const -2))
+  (global $b i64 (i64.const -5))
+  (global $3 f32 (f32.const -3))
+  (global $4 f64 (f64.const -4))
+
+  (global $x (mut i32) (i32.const -12))
+  (global $y (mut i64) (i64.const -15))
+  (global $7 (mut f32) (f32.const -13))
+  (global $8 (mut f64) (f64.const -14))
+
+  (global $z1 i32 (global.get 0))
+  (global $z2 i64 (global.get 1))
+
+  (func (export "get-a") (result i32) (global.get $a))
+  (func (export "get-b") (result i64) (global.get $b))
+  (func (export "get-x") (result i32) (global.get $x))
+  (func (export "get-y") (result i64) (global.get $y))
+  (func (export "get-z1") (result i32) (global.get $z1))
+  (func (export "get-z2") (result i64) (global.get $z2))
+  (func (export "set-x") (param i32) (global.set $x (local.get 0)))
+  (func (export "set-y") (param i64) (global.set $y (local.get 0)))
+
+  (func (export "get-3") (result f32) (global.get $3))
+  (func (export "get-4") (result f64) (global.get $4))
+  (func (export "get-7") (result f32) (global.get $7))
+  (func (export "get-8") (result f64) (global.get $8))
+  (func (export "set-7") (param f32) (global.set $7 (local.get 0)))
+  (func (export "set-8") (param f64) (global.set $8 (local.get 0)))
+
+  ;; As the argument of control constructs and instructions
+
+  (memory 1)
+
+  (func $dummy)
+
+  (func (export "as-loop-first") (result i32)
+    (loop (result i32)
+      (global.get $x) (call $dummy) (call $dummy)
+    )
+  )
+  (func (export "as-loop-mid") (result i32)
+    (loop (result i32)
+      (call $dummy) (global.get $x) (call $dummy)
+    )
+  )
+  (func (export "as-loop-last") (result i32)
+    (loop (result i32)
+      (call $dummy) (call $dummy) (global.get $x)
+    )
+  )
+
+  (func (export "as-if-condition") (result i32)
+    (if (result i32) (global.get $x)
+      (then (call $dummy) (i32.const 2))
+      (else (call $dummy) (i32.const 3))
+    )
+  )
+  (func (export "as-if-then") (result i32)
+    (if (result i32) (i32.const 1)
+      (then (global.get $x)) (else (i32.const 2))
+    )
+  )
+  (func (export "as-if-else") (result i32)
+    (if (result i32) (i32.const 0)
+      (then (i32.const 2)) (else (global.get $x))
+    )
+  )
+
+  (func (export "as-br_if-first") (result i32)
+    (block (result i32)
+      (br_if 0 (global.get $x) (i32.const 2))
+      (return (i32.const 3))
+    )
+  )
+  (func (export "as-br_if-last") (result i32)
+    (block (result i32)
+      (br_if 0 (i32.const 2) (global.get $x))
+      (return (i32.const 3))
+    )
+  )
+
+  (func (export "as-br_table-first") (result i32)
+    (block (result i32)
+      (global.get $x) (i32.const 2) (br_table 0 0)
+    )
+  )
+  (func (export "as-br_table-last") (result i32)
+    (block (result i32)
+      (i32.const 2) (global.get $x) (br_table 0 0)
+    )
+  )
+
+  (func $f (param i32) (result i32) (local.get 0))
+  (func (export "as-call-value") (result i32)
+    (call $f (global.get $x))
+  )
+
+  (func (export "as-return-value") (result i32)
+    (global.get $x) (return)
+  )
+
+  (func (export "as-drop-operand")
+    (drop (global.get $x))
+  )
+
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (global.get $x)))
+  )
+
+  (func (export "as-local.set-value") (param i32) (result i32)
+    (local.set 0 (global.get $x))
+    (local.get 0)
+  )
+  (func (export "as-local.tee-value") (param i32) (result i32)
+    (local.tee 0 (global.get $x))
+  )
+  (func (export "as-global.set-value") (result i32)
+    (global.set $x (global.get $x))
+    (global.get $x)
+  )
+
+  (func (export "as-unary-operand") (result i32)
+    (i32.eqz (global.get $x))
+  )
+  (func (export "as-binary-operand") (result i32)
+    (i32.mul
+      (global.get $x) (global.get $x)
+    )
+  )
+  (func (export "as-compare-operand") (result i32)
+    (i32.gt_u
+      (global.get 0) (i32.const 1)
+    )
+  )
+
+  (func (export "as-store-first")
+    (global.get $x) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last")
+    (i32.const 0) (global.get $x) (i32.store)
+  )
+  (func (export "as-load-operand") (result i32)
+    (i32.load (global.get $x))
+  )
+)
+
+
+(assert_return (invoke "get-a") (i32.const -2))
+(assert_return (invoke "get-b") (i64.const -5))
+(assert_return (invoke "get-x") (i32.const -12))
+(assert_return (invoke "get-y") (i64.const -15))
+(assert_return (invoke "get-z1") (i32.const 666))
+(assert_return (invoke "get-z2") (i64.const 666))
+
+(assert_return (invoke "set-x" (i32.const 6)))
+(assert_return (invoke "set-y" (i64.const 7)))
+
+(assert_return (invoke "get-x") (i32.const 6))
+(assert_return (invoke "get-y") (i64.const 7))
+
+(assert_return (invoke "get-x") (i32.const 6))
+(assert_return (invoke "get-y") (i64.const 7))
+
+(assert_return (invoke "as-loop-first") (i32.const 6))
+(assert_return (invoke "as-loop-mid") (i32.const 6))
+(assert_return (invoke "as-loop-last") (i32.const 6))
+
+(assert_return (invoke "as-if-condition") (i32.const 2))
+(assert_return (invoke "as-if-then") (i32.const 6))
+(assert_return (invoke "as-if-else") (i32.const 6))
+
+(assert_return (invoke "as-br_if-first") (i32.const 6))
+(assert_return (invoke "as-br_if-last") (i32.const 2))
+
+(assert_return (invoke "as-call-value") (i32.const 6))
+
+(assert_return (invoke "as-return-value") (i32.const 6))
+(assert_return (invoke "as-br-value") (i32.const 6))
+
+(assert_return (invoke "as-local.set-value" (i32.const 1)) (i32.const 6))
+(assert_return (invoke "as-local.tee-value" (i32.const 1)) (i32.const 6))
+(assert_return (invoke "as-global.set-value") (i32.const 6))
+
+(assert_return (invoke "as-unary-operand") (i32.const 0))
+(assert_return (invoke "as-binary-operand") (i32.const 36))
+(assert_return (invoke "as-compare-operand") (i32.const 1))
+
+(assert_return (invoke "get-3") (f32.const -3))
+(assert_return (invoke "get-4") (f64.const -4))
+(assert_return (invoke "get-7") (f32.const -13))
+(assert_return (invoke "get-8") (f64.const -14))
+(assert_return (invoke "set-7" (f32.const 8)))
+(assert_return (invoke "set-8" (f64.const 9)))
+(assert_return (invoke "get-7") (f32.const 8))
+(assert_return (invoke "get-8") (f64.const 9))
+(assert_return (invoke "as-drop-operand"))
+
+(assert_return (invoke "as-br_table-first") (i32.const 6))
+(assert_return (invoke "as-br_table-last") (i32.const 2))
+
+(assert_return (invoke "as-store-first"))
+(assert_return (invoke "as-store-last"))
+(assert_return (invoke "as-load-operand") (i32.const 1))
diff --git a/tests/misc_testsuite/winch/globals.wast b/tests/misc_testsuite/winch/globals.wast
deleted file mode 100644
index 46131b526636..000000000000
--- a/tests/misc_testsuite/winch/globals.wast
+++ /dev/null
@@ -1,194 +0,0 @@
-;; Test globals
-
-(module
-  (global (import "spectest" "global_i32") i32)
-  (global (import "spectest" "global_i64") i64)
-
-  (global $a i32 (i32.const -2))
-  (global $b i64 (i64.const -5))
-  (global $3 f32 (f32.const -3))
-  (global $4 f64 (f64.const -4))
-
-  (global $x (mut i32) (i32.const -12))
-  (global $y (mut i64) (i64.const -15))
-  (global $7 (mut f32) (f32.const -13))
-  (global $8 (mut f64) (f64.const -14))
-
-  (global $z1 i32 (global.get 0))
-  (global $z2 i64 (global.get 1))
-
-  (func (export "get-a") (result i32) (global.get $a))
-  (func (export "get-b") (result i64) (global.get $b))
-  (func (export "get-x") (result i32) (global.get $x))
-  (func (export "get-y") (result i64) (global.get $y))
-  (func (export "get-z1") (result i32) (global.get $z1))
-  (func (export "get-z2") (result i64) (global.get $z2))
-  (func (export "set-x") (param i32) (global.set $x (local.get 0)))
-  (func (export "set-y") (param i64) (global.set $y (local.get 0)))
-
-  (func (export "get-3") (result f32) (global.get $3))
-  (func (export "get-4") (result f64) (global.get $4))
-  (func (export "get-7") (result f32) (global.get $7))
-  (func (export "get-8") (result f64) (global.get $8))
-  (func (export "set-7") (param f32) (global.set $7 (local.get 0)))
-  (func (export "set-8") (param f64) (global.set $8 (local.get 0)))
-
-  ;; As the argument of control constructs and instructions
-
-  (memory 1)
-
-  (func $dummy)
-
-  (func (export "as-loop-first") (result i32)
-    (loop (result i32)
-      (global.get $x) (call $dummy) (call $dummy)
-    )
-  )
-  (func (export "as-loop-mid") (result i32)
-    (loop (result i32)
-      (call $dummy) (global.get $x) (call $dummy)
-    )
-  )
-  (func (export "as-loop-last") (result i32)
-    (loop (result i32)
-      (call $dummy) (call $dummy) (global.get $x)
-    )
-  )
-
-  (func (export "as-if-condition") (result i32)
-    (if (result i32) (global.get $x)
-      (then (call $dummy) (i32.const 2))
-      (else (call $dummy) (i32.const 3))
-    )
-  )
-  (func (export "as-if-then") (result i32)
-    (if (result i32) (i32.const 1)
-      (then (global.get $x)) (else (i32.const 2))
-    )
-  )
-  (func (export "as-if-else") (result i32)
-    (if (result i32) (i32.const 0)
-      (then (i32.const 2)) (else (global.get $x))
-    )
-  )
-
-  (func (export "as-br_if-first") (result i32)
-    (block (result i32)
-      (br_if 0 (global.get $x) (i32.const 2))
-      (return (i32.const 3))
-    )
-  )
-  (func (export "as-br_if-last") (result i32)
-    (block (result i32)
-      (br_if 0 (i32.const 2) (global.get $x))
-      (return (i32.const 3))
-    )
-  )
-
-  (func (export "as-br_table-first") (result i32)
-    (block (result i32)
-      (global.get $x) (i32.const 2) (br_table 0 0)
-    )
-  )
-  (func (export "as-br_table-last") (result i32)
-    (block (result i32)
-      (i32.const 2) (global.get $x) (br_table 0 0)
-    )
-  )
-
-  (func $f (param i32) (result i32) (local.get 0))
-  (func (export "as-call-value") (result i32)
-    (call $f (global.get $x))
-  )
-
-  (func (export "as-return-value") (result i32)
-    (global.get $x) (return)
-  )
-
-  (func (export "as-drop-operand")
-    (drop (global.get $x))
-  )
-
-  (func (export "as-br-value") (result i32)
-    (block (result i32) (br 0 (global.get $x)))
-  )
-
-  (func (export "as-local.set-value") (param i32) (result i32)
-    (local.set 0 (global.get $x))
-    (local.get 0)
-  )
-  (func (export "as-local.tee-value") (param i32) (result i32)
-    (local.tee 0 (global.get $x))
-  )
-  (func (export "as-global.set-value") (result i32)
-    (global.set $x (global.get $x))
-    (global.get $x)
-  )
-
-  (func (export "as-unary-operand") (result i32)
-    (i32.eqz (global.get $x))
-  )
-  (func (export "as-binary-operand") (result i32)
-    (i32.mul
-      (global.get $x) (global.get $x)
-    )
-  )
-  (func (export "as-compare-operand") (result i32)
-    (i32.gt_u
-      (global.get 0) (i32.const 1)
-    )
-  )
-)
-
-(assert_return (invoke "get-a") (i32.const -2))
-(assert_return (invoke "get-b") (i64.const -5))
-(assert_return (invoke "get-x") (i32.const -12))
-(assert_return (invoke "get-y") (i64.const -15))
-(assert_return (invoke "get-z1") (i32.const 666))
-(assert_return (invoke "get-z2") (i64.const 666))
-
-(assert_return (invoke "set-x" (i32.const 6)))
-(assert_return (invoke "set-y" (i64.const 7)))
-
-(assert_return (invoke "get-x") (i32.const 6))
-(assert_return (invoke "get-y") (i64.const 7))
-
-(assert_return (invoke "get-x") (i32.const 6))
-(assert_return (invoke "get-y") (i64.const 7))
-
-(assert_return (invoke "as-loop-first") (i32.const 6))
-(assert_return (invoke "as-loop-mid") (i32.const 6))
-(assert_return (invoke "as-loop-last") (i32.const 6))
-
-(assert_return (invoke "as-if-condition") (i32.const 2))
-(assert_return (invoke "as-if-then") (i32.const 6))
-(assert_return (invoke "as-if-else") (i32.const 6))
-
-(assert_return (invoke "as-br_if-first") (i32.const 6))
-(assert_return (invoke "as-br_if-last") (i32.const 2))
-
-(assert_return (invoke "as-call-value") (i32.const 6))
-
-(assert_return (invoke "as-return-value") (i32.const 6))
-(assert_return (invoke "as-br-value") (i32.const 6))
-
-(assert_return (invoke "as-local.set-value" (i32.const 1)) (i32.const 6))
-(assert_return (invoke "as-local.tee-value" (i32.const 1)) (i32.const 6))
-(assert_return (invoke "as-global.set-value") (i32.const 6))
-
-(assert_return (invoke "as-unary-operand") (i32.const 0))
-(assert_return (invoke "as-binary-operand") (i32.const 36))
-(assert_return (invoke "as-compare-operand") (i32.const 1))
-
-(assert_return (invoke "get-3") (f32.const -3))
-(assert_return (invoke "get-4") (f64.const -4))
-(assert_return (invoke "get-7") (f32.const -13))
-(assert_return (invoke "get-8") (f64.const -14))
-(assert_return (invoke "set-7" (f32.const 8)))
-(assert_return (invoke "set-8" (f64.const 9)))
-(assert_return (invoke "get-7") (f32.const 8))
-(assert_return (invoke "get-8") (f64.const 9))
-(assert_return (invoke "as-drop-operand"))
-
-(assert_return (invoke "as-br_table-first") (i32.const 6))
-(assert_return (invoke "as-br_table-last") (i32.const 2))
diff --git a/tests/misc_testsuite/winch/i32.wast b/tests/misc_testsuite/winch/i32.wast
deleted file mode 100644
index 8a06d0914500..000000000000
--- a/tests/misc_testsuite/winch/i32.wast
+++ /dev/null
@@ -1,422 +0,0 @@
-;; i32 operations
-
-(module
-  (func (export "add") (param $x i32) (param $y i32) (result i32) (i32.add (local.get $x) (local.get $y)))
-  (func (export "sub") (param $x i32) (param $y i32) (result i32) (i32.sub (local.get $x) (local.get $y)))
-  (func (export "mul") (param $x i32) (param $y i32) (result i32) (i32.mul (local.get $x) (local.get $y)))
-  (func (export "div_s") (param $x i32) (param $y i32) (result i32) (i32.div_s (local.get $x) (local.get $y)))
-  (func (export "div_u") (param $x i32) (param $y i32) (result i32) (i32.div_u (local.get $x) (local.get $y)))
-  (func (export "rem_s") (param $x i32) (param $y i32) (result i32) (i32.rem_s (local.get $x) (local.get $y)))
-  (func (export "rem_u") (param $x i32) (param $y i32) (result i32) (i32.rem_u (local.get $x) (local.get $y)))
-  (func (export "and") (param $x i32) (param $y i32) (result i32) (i32.and (local.get $x) (local.get $y)))
-  (func (export "or") (param $x i32) (param $y i32) (result i32) (i32.or (local.get $x) (local.get $y)))
-  (func (export "xor") (param $x i32) (param $y i32) (result i32) (i32.xor (local.get $x) (local.get $y)))
-  (func (export "shl") (param $x i32) (param $y i32) (result i32) (i32.shl (local.get $x) (local.get $y)))
-  (func (export "shr_s") (param $x i32) (param $y i32) (result i32) (i32.shr_s (local.get $x) (local.get $y)))
-  (func (export "shr_u") (param $x i32) (param $y i32) (result i32) (i32.shr_u (local.get $x) (local.get $y)))
-  (func (export "rotl") (param $x i32) (param $y i32) (result i32) (i32.rotl (local.get $x) (local.get $y)))
-  (func (export "rotr") (param $x i32) (param $y i32) (result i32) (i32.rotr (local.get $x) (local.get $y)))
-  (func (export "clz") (param $x i32) (result i32) (i32.clz (local.get $x)))
-  (func (export "ctz") (param $x i32) (result i32) (i32.ctz (local.get $x)))
-  (func (export "popcnt") (param $x i32) (result i32) (i32.popcnt (local.get $x)))
-  (func (export "eqz") (param $x i32) (result i32) (i32.eqz (local.get $x)))
-  (func (export "eq") (param $x i32) (param $y i32) (result i32) (i32.eq (local.get $x) (local.get $y)))
-  (func (export "ne") (param $x i32) (param $y i32) (result i32) (i32.ne (local.get $x) (local.get $y)))
-  (func (export "lt_s") (param $x i32) (param $y i32) (result i32) (i32.lt_s (local.get $x) (local.get $y)))
-  (func (export "lt_u") (param $x i32) (param $y i32) (result i32) (i32.lt_u (local.get $x) (local.get $y)))
-  (func (export "le_s") (param $x i32) (param $y i32) (result i32) (i32.le_s (local.get $x) (local.get $y)))
-  (func (export "le_u") (param $x i32) (param $y i32) (result i32) (i32.le_u (local.get $x) (local.get $y)))
-  (func (export "gt_s") (param $x i32) (param $y i32) (result i32) (i32.gt_s (local.get $x) (local.get $y)))
-  (func (export "gt_u") (param $x i32) (param $y i32) (result i32) (i32.gt_u (local.get $x) (local.get $y)))
-  (func (export "ge_s") (param $x i32) (param $y i32) (result i32) (i32.ge_s (local.get $x) (local.get $y)))
-  (func (export "ge_u") (param $x i32) (param $y i32) (result i32) (i32.ge_u (local.get $x) (local.get $y)))
-)
-
-(assert_return (invoke "add" (i32.const 1) (i32.const 1)) (i32.const 2))
-(assert_return (invoke "add" (i32.const 1) (i32.const 0)) (i32.const 1))
-(assert_return (invoke "add" (i32.const -1) (i32.const -1)) (i32.const -2))
-(assert_return (invoke "add" (i32.const -1) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "add" (i32.const 0x7fffffff) (i32.const 1)) (i32.const 0x80000000))
-(assert_return (invoke "add" (i32.const 0x80000000) (i32.const -1)) (i32.const 0x7fffffff))
-(assert_return (invoke "add" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
-(assert_return (invoke "add" (i32.const 0x3fffffff) (i32.const 1)) (i32.const 0x40000000))
-
-(assert_return (invoke "sub" (i32.const 1) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "sub" (i32.const 1) (i32.const 0)) (i32.const 1))
-(assert_return (invoke "sub" (i32.const -1) (i32.const -1)) (i32.const 0))
-(assert_return (invoke "sub" (i32.const 0x7fffffff) (i32.const -1)) (i32.const 0x80000000))
-(assert_return (invoke "sub" (i32.const 0x80000000) (i32.const 1)) (i32.const 0x7fffffff))
-(assert_return (invoke "sub" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
-(assert_return (invoke "sub" (i32.const 0x3fffffff) (i32.const -1)) (i32.const 0x40000000))
-
-(assert_return (invoke "mul" (i32.const 1) (i32.const 1)) (i32.const 1))
-(assert_return (invoke "mul" (i32.const 1) (i32.const 0)) (i32.const 0))
-(assert_return (invoke "mul" (i32.const -1) (i32.const -1)) (i32.const 1))
-(assert_return (invoke "mul" (i32.const 0x10000000) (i32.const 4096)) (i32.const 0))
-(assert_return (invoke "mul" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
-(assert_return (invoke "mul" (i32.const 0x80000000) (i32.const -1)) (i32.const 0x80000000))
-(assert_return (invoke "mul" (i32.const 0x7fffffff) (i32.const -1)) (i32.const 0x80000001))
-(assert_return (invoke "mul" (i32.const 0x01234567) (i32.const 0x76543210)) (i32.const 0x358e7470))
-(assert_return (invoke "mul" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1))
-
-(assert_trap (invoke "div_s" (i32.const 1) (i32.const 0)) "integer divide by zero")
-(assert_trap (invoke "div_s" (i32.const 0) (i32.const 0)) "integer divide by zero")
-(assert_trap (invoke "div_s" (i32.const 0x80000000) (i32.const -1)) "integer overflow")
-(assert_trap (invoke "div_s" (i32.const 0x80000000) (i32.const 0)) "integer divide by zero")
-(assert_return (invoke "div_s" (i32.const 1) (i32.const 1)) (i32.const 1))
-(assert_return (invoke "div_s" (i32.const 0) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "div_s" (i32.const 0) (i32.const -1)) (i32.const 0))
-(assert_return (invoke "div_s" (i32.const -1) (i32.const -1)) (i32.const 1))
-(assert_return (invoke "div_s" (i32.const 0x80000000) (i32.const 2)) (i32.const 0xc0000000))
-(assert_return (invoke "div_s" (i32.const 0x80000001) (i32.const 1000)) (i32.const 0xffdf3b65))
-(assert_return (invoke "div_s" (i32.const 5) (i32.const 2)) (i32.const 2))
-(assert_return (invoke "div_s" (i32.const -5) (i32.const 2)) (i32.const -2))
-(assert_return (invoke "div_s" (i32.const 5) (i32.const -2)) (i32.const -2))
-(assert_return (invoke "div_s" (i32.const -5) (i32.const -2)) (i32.const 2))
-(assert_return (invoke "div_s" (i32.const 7) (i32.const 3)) (i32.const 2))
-(assert_return (invoke "div_s" (i32.const -7) (i32.const 3)) (i32.const -2))
-(assert_return (invoke "div_s" (i32.const 7) (i32.const -3)) (i32.const -2))
-(assert_return (invoke "div_s" (i32.const -7) (i32.const -3)) (i32.const 2))
-(assert_return (invoke "div_s" (i32.const 11) (i32.const 5)) (i32.const 2))
-(assert_return (invoke "div_s" (i32.const 17) (i32.const 7)) (i32.const 2))
-
-(assert_trap (invoke "div_u" (i32.const 1) (i32.const 0)) "integer divide by zero")
-(assert_trap (invoke "div_u" (i32.const 0) (i32.const 0)) "integer divide by zero")
-(assert_return (invoke "div_u" (i32.const 1) (i32.const 1)) (i32.const 1))
-(assert_return (invoke "div_u" (i32.const 0) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "div_u" (i32.const -1) (i32.const -1)) (i32.const 1))
-(assert_return (invoke "div_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
-(assert_return (invoke "div_u" (i32.const 0x80000000) (i32.const 2)) (i32.const 0x40000000))
-(assert_return (invoke "div_u" (i32.const 0x8ff00ff0) (i32.const 0x10001)) (i32.const 0x8fef))
-(assert_return (invoke "div_u" (i32.const 0x80000001) (i32.const 1000)) (i32.const 0x20c49b))
-(assert_return (invoke "div_u" (i32.const 5) (i32.const 2)) (i32.const 2))
-(assert_return (invoke "div_u" (i32.const -5) (i32.const 2)) (i32.const 0x7ffffffd))
-(assert_return (invoke "div_u" (i32.const 5) (i32.const -2)) (i32.const 0))
-(assert_return (invoke "div_u" (i32.const -5) (i32.const -2)) (i32.const 0))
-(assert_return (invoke "div_u" (i32.const 7) (i32.const 3)) (i32.const 2))
-(assert_return (invoke "div_u" (i32.const 11) (i32.const 5)) (i32.const 2))
-(assert_return (invoke "div_u" (i32.const 17) (i32.const 7)) (i32.const 2))
-
-(assert_trap (invoke "rem_s" (i32.const 1) (i32.const 0)) "integer divide by zero")
-(assert_trap (invoke "rem_s" (i32.const 0) (i32.const 0)) "integer divide by zero")
-(assert_return (invoke "rem_s" (i32.const 0x7fffffff) (i32.const -1)) (i32.const 0))
-(assert_return (invoke "rem_s" (i32.const 1) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "rem_s" (i32.const 0) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "rem_s" (i32.const 0) (i32.const -1)) (i32.const 0))
-(assert_return (invoke "rem_s" (i32.const -1) (i32.const -1)) (i32.const 0))
-(assert_return (invoke "rem_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
-(assert_return (invoke "rem_s" (i32.const 0x80000000) (i32.const 2)) (i32.const 0))
-(assert_return (invoke "rem_s" (i32.const 0x80000001) (i32.const 1000)) (i32.const -647))
-(assert_return (invoke "rem_s" (i32.const 5) (i32.const 2)) (i32.const 1))
-(assert_return (invoke "rem_s" (i32.const -5) (i32.const 2)) (i32.const -1))
-(assert_return (invoke "rem_s" (i32.const 5) (i32.const -2)) (i32.const 1))
-(assert_return (invoke "rem_s" (i32.const -5) (i32.const -2)) (i32.const -1))
-(assert_return (invoke "rem_s" (i32.const 7) (i32.const 3)) (i32.const 1))
-(assert_return (invoke "rem_s" (i32.const -7) (i32.const 3)) (i32.const -1))
-(assert_return (invoke "rem_s" (i32.const 7) (i32.const -3)) (i32.const 1))
-(assert_return (invoke "rem_s" (i32.const -7) (i32.const -3)) (i32.const -1))
-(assert_return (invoke "rem_s" (i32.const 11) (i32.const 5)) (i32.const 1))
-(assert_return (invoke "rem_s" (i32.const 17) (i32.const 7)) (i32.const 3))
-
-(assert_trap (invoke "rem_u" (i32.const 1) (i32.const 0)) "integer divide by zero")
-(assert_trap (invoke "rem_u" (i32.const 0) (i32.const 0)) "integer divide by zero")
-(assert_return (invoke "rem_u" (i32.const 1) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "rem_u" (i32.const 0) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "rem_u" (i32.const -1) (i32.const -1)) (i32.const 0))
-(assert_return (invoke "rem_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 0x80000000))
-(assert_return (invoke "rem_u" (i32.const 0x80000000) (i32.const 2)) (i32.const 0))
-(assert_return (invoke "rem_u" (i32.const 0x8ff00ff0) (i32.const 0x10001)) (i32.const 0x8001))
-(assert_return (invoke "rem_u" (i32.const 0x80000001) (i32.const 1000)) (i32.const 649))
-(assert_return (invoke "rem_u" (i32.const 5) (i32.const 2)) (i32.const 1))
-(assert_return (invoke "rem_u" (i32.const -5) (i32.const 2)) (i32.const 1))
-(assert_return (invoke "rem_u" (i32.const 5) (i32.const -2)) (i32.const 5))
-(assert_return (invoke "rem_u" (i32.const -5) (i32.const -2)) (i32.const -5))
-(assert_return (invoke "rem_u" (i32.const 7) (i32.const 3)) (i32.const 1))
-(assert_return (invoke "rem_u" (i32.const 11) (i32.const 5)) (i32.const 1))
-(assert_return (invoke "rem_u" (i32.const 17) (i32.const 7)) (i32.const 3))
-
-(assert_return (invoke "and" (i32.const 1) (i32.const 0)) (i32.const 0))
-(assert_return (invoke "and" (i32.const 0) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "and" (i32.const 1) (i32.const 1)) (i32.const 1))
-(assert_return (invoke "and" (i32.const 0) (i32.const 0)) (i32.const 0))
-(assert_return (invoke "and" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0))
-(assert_return (invoke "and" (i32.const 0x7fffffff) (i32.const -1)) (i32.const 0x7fffffff))
-(assert_return (invoke "and" (i32.const 0xf0f0ffff) (i32.const 0xfffff0f0)) (i32.const 0xf0f0f0f0))
-(assert_return (invoke "and" (i32.const 0xffffffff) (i32.const 0xffffffff)) (i32.const 0xffffffff))
-
-(assert_return (invoke "or" (i32.const 1) (i32.const 0)) (i32.const 1))
-(assert_return (invoke "or" (i32.const 0) (i32.const 1)) (i32.const 1))
-(assert_return (invoke "or" (i32.const 1) (i32.const 1)) (i32.const 1))
-(assert_return (invoke "or" (i32.const 0) (i32.const 0)) (i32.const 0))
-(assert_return (invoke "or" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const -1))
-(assert_return (invoke "or" (i32.const 0x80000000) (i32.const 0)) (i32.const 0x80000000))
-(assert_return (invoke "or" (i32.const 0xf0f0ffff) (i32.const 0xfffff0f0)) (i32.const 0xffffffff))
-(assert_return (invoke "or" (i32.const 0xffffffff) (i32.const 0xffffffff)) (i32.const 0xffffffff))
-
-(assert_return (invoke "xor" (i32.const 1) (i32.const 0)) (i32.const 1))
-(assert_return (invoke "xor" (i32.const 0) (i32.const 1)) (i32.const 1))
-(assert_return (invoke "xor" (i32.const 1) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "xor" (i32.const 0) (i32.const 0)) (i32.const 0))
-(assert_return (invoke "xor" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const -1))
-(assert_return (invoke "xor" (i32.const 0x80000000) (i32.const 0)) (i32.const 0x80000000))
-(assert_return (invoke "xor" (i32.const -1) (i32.const 0x80000000)) (i32.const 0x7fffffff))
-(assert_return (invoke "xor" (i32.const -1) (i32.const 0x7fffffff)) (i32.const 0x80000000))
-(assert_return (invoke "xor" (i32.const 0xf0f0ffff) (i32.const 0xfffff0f0)) (i32.const 0x0f0f0f0f))
-(assert_return (invoke "xor" (i32.const 0xffffffff) (i32.const 0xffffffff)) (i32.const 0))
-
-(assert_return (invoke "shl" (i32.const 1) (i32.const 1)) (i32.const 2))
-(assert_return (invoke "shl" (i32.const 1) (i32.const 0)) (i32.const 1))
-(assert_return (invoke "shl" (i32.const 0x7fffffff) (i32.const 1)) (i32.const 0xfffffffe))
-(assert_return (invoke "shl" (i32.const 0xffffffff) (i32.const 1)) (i32.const 0xfffffffe))
-(assert_return (invoke "shl" (i32.const 0x80000000) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "shl" (i32.const 0x40000000) (i32.const 1)) (i32.const 0x80000000))
-(assert_return (invoke "shl" (i32.const 1) (i32.const 31)) (i32.const 0x80000000))
-(assert_return (invoke "shl" (i32.const 1) (i32.const 32)) (i32.const 1))
-(assert_return (invoke "shl" (i32.const 1) (i32.const 33)) (i32.const 2))
-(assert_return (invoke "shl" (i32.const 1) (i32.const -1)) (i32.const 0x80000000))
-(assert_return (invoke "shl" (i32.const 1) (i32.const 0x7fffffff)) (i32.const 0x80000000))
-
-(assert_return (invoke "shr_s" (i32.const 1) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "shr_s" (i32.const 1) (i32.const 0)) (i32.const 1))
-(assert_return (invoke "shr_s" (i32.const -1) (i32.const 1)) (i32.const -1))
-(assert_return (invoke "shr_s" (i32.const 0x7fffffff) (i32.const 1)) (i32.const 0x3fffffff))
-(assert_return (invoke "shr_s" (i32.const 0x80000000) (i32.const 1)) (i32.const 0xc0000000))
-(assert_return (invoke "shr_s" (i32.const 0x40000000) (i32.const 1)) (i32.const 0x20000000))
-(assert_return (invoke "shr_s" (i32.const 1) (i32.const 32)) (i32.const 1))
-(assert_return (invoke "shr_s" (i32.const 1) (i32.const 33)) (i32.const 0))
-(assert_return (invoke "shr_s" (i32.const 1) (i32.const -1)) (i32.const 0))
-(assert_return (invoke "shr_s" (i32.const 1) (i32.const 0x7fffffff)) (i32.const 0))
-(assert_return (invoke "shr_s" (i32.const 1) (i32.const 0x80000000)) (i32.const 1))
-(assert_return (invoke "shr_s" (i32.const 0x80000000) (i32.const 31)) (i32.const -1))
-(assert_return (invoke "shr_s" (i32.const -1) (i32.const 32)) (i32.const -1))
-(assert_return (invoke "shr_s" (i32.const -1) (i32.const 33)) (i32.const -1))
-(assert_return (invoke "shr_s" (i32.const -1) (i32.const -1)) (i32.const -1))
-(assert_return (invoke "shr_s" (i32.const -1) (i32.const 0x7fffffff)) (i32.const -1))
-(assert_return (invoke "shr_s" (i32.const -1) (i32.const 0x80000000)) (i32.const -1))
-
-(assert_return (invoke "shr_u" (i32.const 1) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "shr_u" (i32.const 1) (i32.const 0)) (i32.const 1))
-(assert_return (invoke "shr_u" (i32.const -1) (i32.const 1)) (i32.const 0x7fffffff))
-(assert_return (invoke "shr_u" (i32.const 0x7fffffff) (i32.const 1)) (i32.const 0x3fffffff))
-(assert_return (invoke "shr_u" (i32.const 0x80000000) (i32.const 1)) (i32.const 0x40000000))
-(assert_return (invoke "shr_u" (i32.const 0x40000000) (i32.const 1)) (i32.const 0x20000000))
-(assert_return (invoke "shr_u" (i32.const 1) (i32.const 32)) (i32.const 1))
-(assert_return (invoke "shr_u" (i32.const 1) (i32.const 33)) (i32.const 0))
-(assert_return (invoke "shr_u" (i32.const 1) (i32.const -1)) (i32.const 0))
-(assert_return (invoke "shr_u" (i32.const 1) (i32.const 0x7fffffff)) (i32.const 0))
-(assert_return (invoke "shr_u" (i32.const 1) (i32.const 0x80000000)) (i32.const 1))
-(assert_return (invoke "shr_u" (i32.const 0x80000000) (i32.const 31)) (i32.const 1))
-(assert_return (invoke "shr_u" (i32.const -1) (i32.const 32)) (i32.const -1))
-(assert_return (invoke "shr_u" (i32.const -1) (i32.const 33)) (i32.const 0x7fffffff))
-(assert_return (invoke "shr_u" (i32.const -1) (i32.const -1)) (i32.const 1))
-(assert_return (invoke "shr_u" (i32.const -1) (i32.const 0x7fffffff)) (i32.const 1))
-(assert_return (invoke "shr_u" (i32.const -1) (i32.const 0x80000000)) (i32.const -1))
-
-(assert_return (invoke "rotl" (i32.const 1) (i32.const 1)) (i32.const 2))
-(assert_return (invoke "rotl" (i32.const 1) (i32.const 0)) (i32.const 1))
-(assert_return (invoke "rotl" (i32.const -1) (i32.const 1)) (i32.const -1))
-(assert_return (invoke "rotl" (i32.const 1) (i32.const 32)) (i32.const 1))
-(assert_return (invoke "rotl" (i32.const 0xabcd9876) (i32.const 1)) (i32.const 0x579b30ed))
-(assert_return (invoke "rotl" (i32.const 0xfe00dc00) (i32.const 4)) (i32.const 0xe00dc00f))
-(assert_return (invoke "rotl" (i32.const 0xb0c1d2e3) (i32.const 5)) (i32.const 0x183a5c76))
-(assert_return (invoke "rotl" (i32.const 0x00008000) (i32.const 37)) (i32.const 0x00100000))
-(assert_return (invoke "rotl" (i32.const 0xb0c1d2e3) (i32.const 0xff05)) (i32.const 0x183a5c76))
-(assert_return (invoke "rotl" (i32.const 0x769abcdf) (i32.const 0xffffffed)) (i32.const 0x579beed3))
-(assert_return (invoke "rotl" (i32.const 0x769abcdf) (i32.const 0x8000000d)) (i32.const 0x579beed3))
-(assert_return (invoke "rotl" (i32.const 1) (i32.const 31)) (i32.const 0x80000000))
-(assert_return (invoke "rotl" (i32.const 0x80000000) (i32.const 1)) (i32.const 1))
-
-(assert_return (invoke "rotr" (i32.const 1) (i32.const 1)) (i32.const 0x80000000))
-(assert_return (invoke "rotr" (i32.const 1) (i32.const 0)) (i32.const 1))
-(assert_return (invoke "rotr" (i32.const -1) (i32.const 1)) (i32.const -1))
-(assert_return (invoke "rotr" (i32.const 1) (i32.const 32)) (i32.const 1))
-(assert_return (invoke "rotr" (i32.const 0xff00cc00) (i32.const 1)) (i32.const 0x7f806600))
-(assert_return (invoke "rotr" (i32.const 0x00080000) (i32.const 4)) (i32.const 0x00008000))
-(assert_return (invoke "rotr" (i32.const 0xb0c1d2e3) (i32.const 5)) (i32.const 0x1d860e97))
-(assert_return (invoke "rotr" (i32.const 0x00008000) (i32.const 37)) (i32.const 0x00000400))
-(assert_return (invoke "rotr" (i32.const 0xb0c1d2e3) (i32.const 0xff05)) (i32.const 0x1d860e97))
-(assert_return (invoke "rotr" (i32.const 0x769abcdf) (i32.const 0xffffffed)) (i32.const 0xe6fbb4d5))
-(assert_return (invoke "rotr" (i32.const 0x769abcdf) (i32.const 0x8000000d)) (i32.const 0xe6fbb4d5))
-(assert_return (invoke "rotr" (i32.const 1) (i32.const 31)) (i32.const 2))
-(assert_return (invoke "rotr" (i32.const 0x80000000) (i32.const 31)) (i32.const 1))
-
-(assert_return (invoke "clz" (i32.const 0xffffffff)) (i32.const 0))
-(assert_return (invoke "clz" (i32.const 0)) (i32.const 32))
-(assert_return (invoke "clz" (i32.const 0x00008000)) (i32.const 16))
-(assert_return (invoke "clz" (i32.const 0xff)) (i32.const 24))
-(assert_return (invoke "clz" (i32.const 0x80000000)) (i32.const 0))
-(assert_return (invoke "clz" (i32.const 1)) (i32.const 31))
-(assert_return (invoke "clz" (i32.const 2)) (i32.const 30))
-(assert_return (invoke "clz" (i32.const 0x7fffffff)) (i32.const 1))
-
-(assert_return (invoke "ctz" (i32.const -1)) (i32.const 0))
-(assert_return (invoke "ctz" (i32.const 0)) (i32.const 32))
-(assert_return (invoke "ctz" (i32.const 0x00008000)) (i32.const 15))
-(assert_return (invoke "ctz" (i32.const 0x00010000)) (i32.const 16))
-(assert_return (invoke "ctz" (i32.const 0x80000000)) (i32.const 31))
-(assert_return (invoke "ctz" (i32.const 0x7fffffff)) (i32.const 0))
-
-(assert_return (invoke "popcnt" (i32.const -1)) (i32.const 32))
-(assert_return (invoke "popcnt" (i32.const 0)) (i32.const 0))
-(assert_return (invoke "popcnt" (i32.const 0x00008000)) (i32.const 1))
-(assert_return (invoke "popcnt" (i32.const 0x80008000)) (i32.const 2))
-(assert_return (invoke "popcnt" (i32.const 0x7fffffff)) (i32.const 31))
-(assert_return (invoke "popcnt" (i32.const 0xAAAAAAAA)) (i32.const 16))
-(assert_return (invoke "popcnt" (i32.const 0x55555555)) (i32.const 16))
-(assert_return (invoke "popcnt" (i32.const 0xDEADBEEF)) (i32.const 24))
-
-(assert_return (invoke "eqz" (i32.const 0)) (i32.const 1))
-(assert_return (invoke "eqz" (i32.const 1)) (i32.const 0))
-(assert_return (invoke "eqz" (i32.const 0x80000000)) (i32.const 0))
-(assert_return (invoke "eqz" (i32.const 0x7fffffff)) (i32.const 0))
-(assert_return (invoke "eqz" (i32.const 0xffffffff)) (i32.const 0))
-
-(assert_return (invoke "eq" (i32.const 0) (i32.const 0)) (i32.const 1))
-(assert_return (invoke "eq" (i32.const 1) (i32.const 1)) (i32.const 1))
-(assert_return (invoke "eq" (i32.const -1) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1))
-(assert_return (invoke "eq" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1))
-(assert_return (invoke "eq" (i32.const -1) (i32.const -1)) (i32.const 1))
-(assert_return (invoke "eq" (i32.const 1) (i32.const 0)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 0) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 0) (i32.const 0x80000000)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const -1) (i32.const 0x80000000)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0))
-(assert_return (invoke "eq" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0))
-
-(assert_return (invoke "ne" (i32.const 0) (i32.const 0)) (i32.const 0))
-(assert_return (invoke "ne" (i32.const 1) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "ne" (i32.const -1) (i32.const 1)) (i32.const 1))
-(assert_return (invoke "ne" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
-(assert_return (invoke "ne" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0))
-(assert_return (invoke "ne" (i32.const -1) (i32.const -1)) (i32.const 0))
-(assert_return (invoke "ne" (i32.const 1) (i32.const 0)) (i32.const 1))
-(assert_return (invoke "ne" (i32.const 0) (i32.const 1)) (i32.const 1))
-(assert_return (invoke "ne" (i32.const 0x80000000) (i32.const 0)) (i32.const 1))
-(assert_return (invoke "ne" (i32.const 0) (i32.const 0x80000000)) (i32.const 1))
-(assert_return (invoke "ne" (i32.const 0x80000000) (i32.const -1)) (i32.const 1))
-(assert_return (invoke "ne" (i32.const -1) (i32.const 0x80000000)) (i32.const 1))
-(assert_return (invoke "ne" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1))
-(assert_return (invoke "ne" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1))
-
-(assert_return (invoke "lt_s" (i32.const 0) (i32.const 0)) (i32.const 0))
-(assert_return (invoke "lt_s" (i32.const 1) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "lt_s" (i32.const -1) (i32.const 1)) (i32.const 1))
-(assert_return (invoke "lt_s" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
-(assert_return (invoke "lt_s" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0))
-(assert_return (invoke "lt_s" (i32.const -1) (i32.const -1)) (i32.const 0))
-(assert_return (invoke "lt_s" (i32.const 1) (i32.const 0)) (i32.const 0))
-(assert_return (invoke "lt_s" (i32.const 0) (i32.const 1)) (i32.const 1))
-(assert_return (invoke "lt_s" (i32.const 0x80000000) (i32.const 0)) (i32.const 1))
-(assert_return (invoke "lt_s" (i32.const 0) (i32.const 0x80000000)) (i32.const 0))
-(assert_return (invoke "lt_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 1))
-(assert_return (invoke "lt_s" (i32.const -1) (i32.const 0x80000000)) (i32.const 0))
-(assert_return (invoke "lt_s" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1))
-(assert_return (invoke "lt_s" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0))
-
-(assert_return (invoke "lt_u" (i32.const 0) (i32.const 0)) (i32.const 0))
-(assert_return (invoke "lt_u" (i32.const 1) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "lt_u" (i32.const -1) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "lt_u" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
-(assert_return (invoke "lt_u" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0))
-(assert_return (invoke "lt_u" (i32.const -1) (i32.const -1)) (i32.const 0))
-(assert_return (invoke "lt_u" (i32.const 1) (i32.const 0)) (i32.const 0))
-(assert_return (invoke "lt_u" (i32.const 0) (i32.const 1)) (i32.const 1))
-(assert_return (invoke "lt_u" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
-(assert_return (invoke "lt_u" (i32.const 0) (i32.const 0x80000000)) (i32.const 1))
-(assert_return (invoke "lt_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 1))
-(assert_return (invoke "lt_u" (i32.const -1) (i32.const 0x80000000)) (i32.const 0))
-(assert_return (invoke "lt_u" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0))
-(assert_return (invoke "lt_u" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1))
-
-(assert_return (invoke "le_s" (i32.const 0) (i32.const 0)) (i32.const 1))
-(assert_return (invoke "le_s" (i32.const 1) (i32.const 1)) (i32.const 1))
-(assert_return (invoke "le_s" (i32.const -1) (i32.const 1)) (i32.const 1))
-(assert_return (invoke "le_s" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1))
-(assert_return (invoke "le_s" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1))
-(assert_return (invoke "le_s" (i32.const -1) (i32.const -1)) (i32.const 1))
-(assert_return (invoke "le_s" (i32.const 1) (i32.const 0)) (i32.const 0))
-(assert_return (invoke "le_s" (i32.const 0) (i32.const 1)) (i32.const 1))
-(assert_return (invoke "le_s" (i32.const 0x80000000) (i32.const 0)) (i32.const 1))
-(assert_return (invoke "le_s" (i32.const 0) (i32.const 0x80000000)) (i32.const 0))
-(assert_return (invoke "le_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 1))
-(assert_return (invoke "le_s" (i32.const -1) (i32.const 0x80000000)) (i32.const 0))
-(assert_return (invoke "le_s" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1))
-(assert_return (invoke "le_s" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0))
-
-(assert_return (invoke "le_u" (i32.const 0) (i32.const 0)) (i32.const 1))
-(assert_return (invoke "le_u" (i32.const 1) (i32.const 1)) (i32.const 1))
-(assert_return (invoke "le_u" (i32.const -1) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "le_u" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1))
-(assert_return (invoke "le_u" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1))
-(assert_return (invoke "le_u" (i32.const -1) (i32.const -1)) (i32.const 1))
-(assert_return (invoke "le_u" (i32.const 1) (i32.const 0)) (i32.const 0))
-(assert_return (invoke "le_u" (i32.const 0) (i32.const 1)) (i32.const 1))
-(assert_return (invoke "le_u" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
-(assert_return (invoke "le_u" (i32.const 0) (i32.const 0x80000000)) (i32.const 1))
-(assert_return (invoke "le_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 1))
-(assert_return (invoke "le_u" (i32.const -1) (i32.const 0x80000000)) (i32.const 0))
-(assert_return (invoke "le_u" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0))
-(assert_return (invoke "le_u" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1))
-
-(assert_return (invoke "gt_s" (i32.const 0) (i32.const 0)) (i32.const 0))
-(assert_return (invoke "gt_s" (i32.const 1) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "gt_s" (i32.const -1) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "gt_s" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
-(assert_return (invoke "gt_s" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0))
-(assert_return (invoke "gt_s" (i32.const -1) (i32.const -1)) (i32.const 0))
-(assert_return (invoke "gt_s" (i32.const 1) (i32.const 0)) (i32.const 1))
-(assert_return (invoke "gt_s" (i32.const 0) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "gt_s" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
-(assert_return (invoke "gt_s" (i32.const 0) (i32.const 0x80000000)) (i32.const 1))
-(assert_return (invoke "gt_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
-(assert_return (invoke "gt_s" (i32.const -1) (i32.const 0x80000000)) (i32.const 1))
-(assert_return (invoke "gt_s" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0))
-(assert_return (invoke "gt_s" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1))
-
-(assert_return (invoke "gt_u" (i32.const 0) (i32.const 0)) (i32.const 0))
-(assert_return (invoke "gt_u" (i32.const 1) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "gt_u" (i32.const -1) (i32.const 1)) (i32.const 1))
-(assert_return (invoke "gt_u" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 0))
-(assert_return (invoke "gt_u" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 0))
-(assert_return (invoke "gt_u" (i32.const -1) (i32.const -1)) (i32.const 0))
-(assert_return (invoke "gt_u" (i32.const 1) (i32.const 0)) (i32.const 1))
-(assert_return (invoke "gt_u" (i32.const 0) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "gt_u" (i32.const 0x80000000) (i32.const 0)) (i32.const 1))
-(assert_return (invoke "gt_u" (i32.const 0) (i32.const 0x80000000)) (i32.const 0))
-(assert_return (invoke "gt_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
-(assert_return (invoke "gt_u" (i32.const -1) (i32.const 0x80000000)) (i32.const 1))
-(assert_return (invoke "gt_u" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1))
-(assert_return (invoke "gt_u" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0))
-
-(assert_return (invoke "ge_s" (i32.const 0) (i32.const 0)) (i32.const 1))
-(assert_return (invoke "ge_s" (i32.const 1) (i32.const 1)) (i32.const 1))
-(assert_return (invoke "ge_s" (i32.const -1) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "ge_s" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1))
-(assert_return (invoke "ge_s" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1))
-(assert_return (invoke "ge_s" (i32.const -1) (i32.const -1)) (i32.const 1))
-(assert_return (invoke "ge_s" (i32.const 1) (i32.const 0)) (i32.const 1))
-(assert_return (invoke "ge_s" (i32.const 0) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "ge_s" (i32.const 0x80000000) (i32.const 0)) (i32.const 0))
-(assert_return (invoke "ge_s" (i32.const 0) (i32.const 0x80000000)) (i32.const 1))
-(assert_return (invoke "ge_s" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
-(assert_return (invoke "ge_s" (i32.const -1) (i32.const 0x80000000)) (i32.const 1))
-(assert_return (invoke "ge_s" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 0))
-(assert_return (invoke "ge_s" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 1))
-
-(assert_return (invoke "ge_u" (i32.const 0) (i32.const 0)) (i32.const 1))
-(assert_return (invoke "ge_u" (i32.const 1) (i32.const 1)) (i32.const 1))
-(assert_return (invoke "ge_u" (i32.const -1) (i32.const 1)) (i32.const 1))
-(assert_return (invoke "ge_u" (i32.const 0x80000000) (i32.const 0x80000000)) (i32.const 1))
-(assert_return (invoke "ge_u" (i32.const 0x7fffffff) (i32.const 0x7fffffff)) (i32.const 1))
-(assert_return (invoke "ge_u" (i32.const -1) (i32.const -1)) (i32.const 1))
-(assert_return (invoke "ge_u" (i32.const 1) (i32.const 0)) (i32.const 1))
-(assert_return (invoke "ge_u" (i32.const 0) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "ge_u" (i32.const 0x80000000) (i32.const 0)) (i32.const 1))
-(assert_return (invoke "ge_u" (i32.const 0) (i32.const 0x80000000)) (i32.const 0))
-(assert_return (invoke "ge_u" (i32.const 0x80000000) (i32.const -1)) (i32.const 0))
-(assert_return (invoke "ge_u" (i32.const -1) (i32.const 0x80000000)) (i32.const 1))
-(assert_return (invoke "ge_u" (i32.const 0x80000000) (i32.const 0x7fffffff)) (i32.const 1))
-(assert_return (invoke "ge_u" (i32.const 0x7fffffff) (i32.const 0x80000000)) (i32.const 0))
diff --git a/tests/misc_testsuite/winch/i64.wast b/tests/misc_testsuite/winch/i64.wast
deleted file mode 100644
index 1783c61782d1..000000000000
--- a/tests/misc_testsuite/winch/i64.wast
+++ /dev/null
@@ -1,422 +0,0 @@
-;; i64 operations
-
-(module
-  (func (export "add") (param $x i64) (param $y i64) (result i64) (i64.add (local.get $x) (local.get $y)))
-  (func (export "sub") (param $x i64) (param $y i64) (result i64) (i64.sub (local.get $x) (local.get $y)))
-  (func (export "mul") (param $x i64) (param $y i64) (result i64) (i64.mul (local.get $x) (local.get $y)))
-  (func (export "div_s") (param $x i64) (param $y i64) (result i64) (i64.div_s (local.get $x) (local.get $y)))
-  (func (export "div_u") (param $x i64) (param $y i64) (result i64) (i64.div_u (local.get $x) (local.get $y)))
-  (func (export "rem_s") (param $x i64) (param $y i64) (result i64) (i64.rem_s (local.get $x) (local.get $y)))
-  (func (export "rem_u") (param $x i64) (param $y i64) (result i64) (i64.rem_u (local.get $x) (local.get $y)))
-  (func (export "and") (param $x i64) (param $y i64) (result i64) (i64.and (local.get $x) (local.get $y)))
-  (func (export "or") (param $x i64) (param $y i64) (result i64) (i64.or (local.get $x) (local.get $y)))
-  (func (export "xor") (param $x i64) (param $y i64) (result i64) (i64.xor (local.get $x) (local.get $y)))
-  (func (export "shl") (param $x i64) (param $y i64) (result i64) (i64.shl (local.get $x) (local.get $y)))
-  (func (export "shr_s") (param $x i64) (param $y i64) (result i64) (i64.shr_s (local.get $x) (local.get $y)))
-  (func (export "shr_u") (param $x i64) (param $y i64) (result i64) (i64.shr_u (local.get $x) (local.get $y)))
-  (func (export "rotl") (param $x i64) (param $y i64) (result i64) (i64.rotl (local.get $x) (local.get $y)))
-  (func (export "rotr") (param $x i64) (param $y i64) (result i64) (i64.rotr (local.get $x) (local.get $y)))
-  (func (export "clz") (param $x i64) (result i64) (i64.clz (local.get $x)))
-  (func (export "ctz") (param $x i64) (result i64) (i64.ctz (local.get $x)))
-  (func (export "popcnt") (param $x i64) (result i64) (i64.popcnt (local.get $x)))
-  (func (export "eqz") (param $x i64) (result i32) (i64.eqz (local.get $x)))
-  (func (export "eq") (param $x i64) (param $y i64) (result i32) (i64.eq (local.get $x) (local.get $y)))
-  (func (export "ne") (param $x i64) (param $y i64) (result i32) (i64.ne (local.get $x) (local.get $y)))
-  (func (export "lt_s") (param $x i64) (param $y i64) (result i32) (i64.lt_s (local.get $x) (local.get $y)))
-  (func (export "lt_u") (param $x i64) (param $y i64) (result i32) (i64.lt_u (local.get $x) (local.get $y)))
-  (func (export "le_s") (param $x i64) (param $y i64) (result i32) (i64.le_s (local.get $x) (local.get $y)))
-  (func (export "le_u") (param $x i64) (param $y i64) (result i32) (i64.le_u (local.get $x) (local.get $y)))
-  (func (export "gt_s") (param $x i64) (param $y i64) (result i32) (i64.gt_s (local.get $x) (local.get $y)))
-  (func (export "gt_u") (param $x i64) (param $y i64) (result i32) (i64.gt_u (local.get $x) (local.get $y)))
-  (func (export "ge_s") (param $x i64) (param $y i64) (result i32) (i64.ge_s (local.get $x) (local.get $y)))
-  (func (export "ge_u") (param $x i64) (param $y i64) (result i32) (i64.ge_u (local.get $x) (local.get $y)))
-)
-
-(assert_return (invoke "add" (i64.const 1) (i64.const 1)) (i64.const 2))
-(assert_return (invoke "add" (i64.const 1) (i64.const 0)) (i64.const 1))
-(assert_return (invoke "add" (i64.const -1) (i64.const -1)) (i64.const -2))
-(assert_return (invoke "add" (i64.const -1) (i64.const 1)) (i64.const 0))
-(assert_return (invoke "add" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0x8000000000000000))
-(assert_return (invoke "add" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0x7fffffffffffffff))
-(assert_return (invoke "add" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i64.const 0))
-(assert_return (invoke "add" (i64.const 0x3fffffff) (i64.const 1)) (i64.const 0x40000000))
-
-(assert_return (invoke "sub" (i64.const 1) (i64.const 1)) (i64.const 0))
-(assert_return (invoke "sub" (i64.const 1) (i64.const 0)) (i64.const 1))
-(assert_return (invoke "sub" (i64.const -1) (i64.const -1)) (i64.const 0))
-(assert_return (invoke "sub" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0x8000000000000000))
-(assert_return (invoke "sub" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0x7fffffffffffffff))
-(assert_return (invoke "sub" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i64.const 0))
-(assert_return (invoke "sub" (i64.const 0x3fffffff) (i64.const -1)) (i64.const 0x40000000))
-
-(assert_return (invoke "mul" (i64.const 1) (i64.const 1)) (i64.const 1))
-(assert_return (invoke "mul" (i64.const 1) (i64.const 0)) (i64.const 0))
-(assert_return (invoke "mul" (i64.const -1) (i64.const -1)) (i64.const 1))
-(assert_return (invoke "mul" (i64.const 0x1000000000000000) (i64.const 4096)) (i64.const 0))
-(assert_return (invoke "mul" (i64.const 0x8000000000000000) (i64.const 0)) (i64.const 0))
-(assert_return (invoke "mul" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0x8000000000000000))
-(assert_return (invoke "mul" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0x8000000000000001))
-(assert_return (invoke "mul" (i64.const 0x0123456789abcdef) (i64.const 0xfedcba9876543210)) (i64.const 0x2236d88fe5618cf0))
-(assert_return (invoke "mul" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i64.const 1))
-
-(assert_trap (invoke "div_s" (i64.const 1) (i64.const 0)) "integer divide by zero")
-(assert_trap (invoke "div_s" (i64.const 0) (i64.const 0)) "integer divide by zero")
-(assert_trap (invoke "div_s" (i64.const 0x8000000000000000) (i64.const -1)) "integer overflow")
-(assert_trap (invoke "div_s" (i64.const 0x8000000000000000) (i64.const 0)) "integer divide by zero")
-(assert_return (invoke "div_s" (i64.const 1) (i64.const 1)) (i64.const 1))
-(assert_return (invoke "div_s" (i64.const 0) (i64.const 1)) (i64.const 0))
-(assert_return (invoke "div_s" (i64.const 0) (i64.const -1)) (i64.const 0))
-(assert_return (invoke "div_s" (i64.const -1) (i64.const -1)) (i64.const 1))
-(assert_return (invoke "div_s" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0xc000000000000000))
-(assert_return (invoke "div_s" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const 0xffdf3b645a1cac09))
-(assert_return (invoke "div_s" (i64.const 5) (i64.const 2)) (i64.const 2))
-(assert_return (invoke "div_s" (i64.const -5) (i64.const 2)) (i64.const -2))
-(assert_return (invoke "div_s" (i64.const 5) (i64.const -2)) (i64.const -2))
-(assert_return (invoke "div_s" (i64.const -5) (i64.const -2)) (i64.const 2))
-(assert_return (invoke "div_s" (i64.const 7) (i64.const 3)) (i64.const 2))
-(assert_return (invoke "div_s" (i64.const -7) (i64.const 3)) (i64.const -2))
-(assert_return (invoke "div_s" (i64.const 7) (i64.const -3)) (i64.const -2))
-(assert_return (invoke "div_s" (i64.const -7) (i64.const -3)) (i64.const 2))
-(assert_return (invoke "div_s" (i64.const 11) (i64.const 5)) (i64.const 2))
-(assert_return (invoke "div_s" (i64.const 17) (i64.const 7)) (i64.const 2))
-
-(assert_trap (invoke "div_u" (i64.const 1) (i64.const 0)) "integer divide by zero")
-(assert_trap (invoke "div_u" (i64.const 0) (i64.const 0)) "integer divide by zero")
-(assert_return (invoke "div_u" (i64.const 1) (i64.const 1)) (i64.const 1))
-(assert_return (invoke "div_u" (i64.const 0) (i64.const 1)) (i64.const 0))
-(assert_return (invoke "div_u" (i64.const -1) (i64.const -1)) (i64.const 1))
-(assert_return (invoke "div_u" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0))
-(assert_return (invoke "div_u" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0x4000000000000000))
-(assert_return (invoke "div_u" (i64.const 0x8ff00ff00ff00ff0) (i64.const 0x100000001)) (i64.const 0x8ff00fef))
-(assert_return (invoke "div_u" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const 0x20c49ba5e353f7))
-(assert_return (invoke "div_u" (i64.const 5) (i64.const 2)) (i64.const 2))
-(assert_return (invoke "div_u" (i64.const -5) (i64.const 2)) (i64.const 0x7ffffffffffffffd))
-(assert_return (invoke "div_u" (i64.const 5) (i64.const -2)) (i64.const 0))
-(assert_return (invoke "div_u" (i64.const -5) (i64.const -2)) (i64.const 0))
-(assert_return (invoke "div_u" (i64.const 7) (i64.const 3)) (i64.const 2))
-(assert_return (invoke "div_u" (i64.const 11) (i64.const 5)) (i64.const 2))
-(assert_return (invoke "div_u" (i64.const 17) (i64.const 7)) (i64.const 2))
-
-(assert_trap (invoke "rem_s" (i64.const 1) (i64.const 0)) "integer divide by zero")
-(assert_trap (invoke "rem_s" (i64.const 0) (i64.const 0)) "integer divide by zero")
-(assert_return (invoke "rem_s" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0))
-(assert_return (invoke "rem_s" (i64.const 1) (i64.const 1)) (i64.const 0))
-(assert_return (invoke "rem_s" (i64.const 0) (i64.const 1)) (i64.const 0))
-(assert_return (invoke "rem_s" (i64.const 0) (i64.const -1)) (i64.const 0))
-(assert_return (invoke "rem_s" (i64.const -1) (i64.const -1)) (i64.const 0))
-(assert_return (invoke "rem_s" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0))
-(assert_return (invoke "rem_s" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0))
-(assert_return (invoke "rem_s" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const -807))
-(assert_return (invoke "rem_s" (i64.const 5) (i64.const 2)) (i64.const 1))
-(assert_return (invoke "rem_s" (i64.const -5) (i64.const 2)) (i64.const -1))
-(assert_return (invoke "rem_s" (i64.const 5) (i64.const -2)) (i64.const 1))
-(assert_return (invoke "rem_s" (i64.const -5) (i64.const -2)) (i64.const -1))
-(assert_return (invoke "rem_s" (i64.const 7) (i64.const 3)) (i64.const 1))
-(assert_return (invoke "rem_s" (i64.const -7) (i64.const 3)) (i64.const -1))
-(assert_return (invoke "rem_s" (i64.const 7) (i64.const -3)) (i64.const 1))
-(assert_return (invoke "rem_s" (i64.const -7) (i64.const -3)) (i64.const -1))
-(assert_return (invoke "rem_s" (i64.const 11) (i64.const 5)) (i64.const 1))
-(assert_return (invoke "rem_s" (i64.const 17) (i64.const 7)) (i64.const 3))
-
-(assert_trap (invoke "rem_u" (i64.const 1) (i64.const 0)) "integer divide by zero")
-(assert_trap (invoke "rem_u" (i64.const 0) (i64.const 0)) "integer divide by zero")
-(assert_return (invoke "rem_u" (i64.const 1) (i64.const 1)) (i64.const 0))
-(assert_return (invoke "rem_u" (i64.const 0) (i64.const 1)) (i64.const 0))
-(assert_return (invoke "rem_u" (i64.const -1) (i64.const -1)) (i64.const 0))
-(assert_return (invoke "rem_u" (i64.const 0x8000000000000000) (i64.const -1)) (i64.const 0x8000000000000000))
-(assert_return (invoke "rem_u" (i64.const 0x8000000000000000) (i64.const 2)) (i64.const 0))
-(assert_return (invoke "rem_u" (i64.const 0x8ff00ff00ff00ff0) (i64.const 0x100000001)) (i64.const 0x80000001))
-(assert_return (invoke "rem_u" (i64.const 0x8000000000000001) (i64.const 1000)) (i64.const 809))
-(assert_return (invoke "rem_u" (i64.const 5) (i64.const 2)) (i64.const 1))
-(assert_return (invoke "rem_u" (i64.const -5) (i64.const 2)) (i64.const 1))
-(assert_return (invoke "rem_u" (i64.const 5) (i64.const -2)) (i64.const 5))
-(assert_return (invoke "rem_u" (i64.const -5) (i64.const -2)) (i64.const -5))
-(assert_return (invoke "rem_u" (i64.const 7) (i64.const 3)) (i64.const 1))
-(assert_return (invoke "rem_u" (i64.const 11) (i64.const 5)) (i64.const 1))
-(assert_return (invoke "rem_u" (i64.const 17) (i64.const 7)) (i64.const 3))
-
-(assert_return (invoke "and" (i64.const 1) (i64.const 0)) (i64.const 0))
-(assert_return (invoke "and" (i64.const 0) (i64.const 1)) (i64.const 0))
-(assert_return (invoke "and" (i64.const 1) (i64.const 1)) (i64.const 1))
-(assert_return (invoke "and" (i64.const 0) (i64.const 0)) (i64.const 0))
-(assert_return (invoke "and" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i64.const 0))
-(assert_return (invoke "and" (i64.const 0x7fffffffffffffff) (i64.const -1)) (i64.const 0x7fffffffffffffff))
-(assert_return (invoke "and" (i64.const 0xf0f0ffff) (i64.const 0xfffff0f0)) (i64.const 0xf0f0f0f0))
-(assert_return (invoke "and" (i64.const 0xffffffffffffffff) (i64.const 0xffffffffffffffff)) (i64.const 0xffffffffffffffff))
-
-(assert_return (invoke "or" (i64.const 1) (i64.const 0)) (i64.const 1))
-(assert_return (invoke "or" (i64.const 0) (i64.const 1)) (i64.const 1))
-(assert_return (invoke "or" (i64.const 1) (i64.const 1)) (i64.const 1))
-(assert_return (invoke "or" (i64.const 0) (i64.const 0)) (i64.const 0))
-(assert_return (invoke "or" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i64.const -1))
-(assert_return (invoke "or" (i64.const 0x8000000000000000) (i64.const 0)) (i64.const 0x8000000000000000))
-(assert_return (invoke "or" (i64.const 0xf0f0ffff) (i64.const 0xfffff0f0)) (i64.const 0xffffffff))
-(assert_return (invoke "or" (i64.const 0xffffffffffffffff) (i64.const 0xffffffffffffffff)) (i64.const 0xffffffffffffffff))
-
-(assert_return (invoke "xor" (i64.const 1) (i64.const 0)) (i64.const 1))
-(assert_return (invoke "xor" (i64.const 0) (i64.const 1)) (i64.const 1))
-(assert_return (invoke "xor" (i64.const 1) (i64.const 1)) (i64.const 0))
-(assert_return (invoke "xor" (i64.const 0) (i64.const 0)) (i64.const 0))
-(assert_return (invoke "xor" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i64.const -1))
-(assert_return (invoke "xor" (i64.const 0x8000000000000000) (i64.const 0)) (i64.const 0x8000000000000000))
-(assert_return (invoke "xor" (i64.const -1) (i64.const 0x8000000000000000)) (i64.const 0x7fffffffffffffff))
-(assert_return (invoke "xor" (i64.const -1) (i64.const 0x7fffffffffffffff)) (i64.const 0x8000000000000000))
-(assert_return (invoke "xor" (i64.const 0xf0f0ffff) (i64.const 0xfffff0f0)) (i64.const 0x0f0f0f0f))
-(assert_return (invoke "xor" (i64.const 0xffffffffffffffff) (i64.const 0xffffffffffffffff)) (i64.const 0))
-
-(assert_return (invoke "shl" (i64.const 1) (i64.const 1)) (i64.const 2))
-(assert_return (invoke "shl" (i64.const 1) (i64.const 0)) (i64.const 1))
-(assert_return (invoke "shl" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0xfffffffffffffffe))
-(assert_return (invoke "shl" (i64.const 0xffffffffffffffff) (i64.const 1)) (i64.const 0xfffffffffffffffe))
-(assert_return (invoke "shl" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0))
-(assert_return (invoke "shl" (i64.const 0x4000000000000000) (i64.const 1)) (i64.const 0x8000000000000000))
-(assert_return (invoke "shl" (i64.const 1) (i64.const 63)) (i64.const 0x8000000000000000))
-(assert_return (invoke "shl" (i64.const 1) (i64.const 64)) (i64.const 1))
-(assert_return (invoke "shl" (i64.const 1) (i64.const 65)) (i64.const 2))
-(assert_return (invoke "shl" (i64.const 1) (i64.const -1)) (i64.const 0x8000000000000000))
-(assert_return (invoke "shl" (i64.const 1) (i64.const 0x7fffffffffffffff)) (i64.const 0x8000000000000000))
-
-(assert_return (invoke "shr_s" (i64.const 1) (i64.const 1)) (i64.const 0))
-(assert_return (invoke "shr_s" (i64.const 1) (i64.const 0)) (i64.const 1))
-(assert_return (invoke "shr_s" (i64.const -1) (i64.const 1)) (i64.const -1))
-(assert_return (invoke "shr_s" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0x3fffffffffffffff))
-(assert_return (invoke "shr_s" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0xc000000000000000))
-(assert_return (invoke "shr_s" (i64.const 0x4000000000000000) (i64.const 1)) (i64.const 0x2000000000000000))
-(assert_return (invoke "shr_s" (i64.const 1) (i64.const 64)) (i64.const 1))
-(assert_return (invoke "shr_s" (i64.const 1) (i64.const 65)) (i64.const 0))
-(assert_return (invoke "shr_s" (i64.const 1) (i64.const -1)) (i64.const 0))
-(assert_return (invoke "shr_s" (i64.const 1) (i64.const 0x7fffffffffffffff)) (i64.const 0))
-(assert_return (invoke "shr_s" (i64.const 1) (i64.const 0x8000000000000000)) (i64.const 1))
-(assert_return (invoke "shr_s" (i64.const 0x8000000000000000) (i64.const 63)) (i64.const -1))
-(assert_return (invoke "shr_s" (i64.const -1) (i64.const 64)) (i64.const -1))
-(assert_return (invoke "shr_s" (i64.const -1) (i64.const 65)) (i64.const -1))
-(assert_return (invoke "shr_s" (i64.const -1) (i64.const -1)) (i64.const -1))
-(assert_return (invoke "shr_s" (i64.const -1) (i64.const 0x7fffffffffffffff)) (i64.const -1))
-(assert_return (invoke "shr_s" (i64.const -1) (i64.const 0x8000000000000000)) (i64.const -1))
-
-(assert_return (invoke "shr_u" (i64.const 1) (i64.const 1)) (i64.const 0))
-(assert_return (invoke "shr_u" (i64.const 1) (i64.const 0)) (i64.const 1))
-(assert_return (invoke "shr_u" (i64.const -1) (i64.const 1)) (i64.const 0x7fffffffffffffff))
-(assert_return (invoke "shr_u" (i64.const 0x7fffffffffffffff) (i64.const 1)) (i64.const 0x3fffffffffffffff))
-(assert_return (invoke "shr_u" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 0x4000000000000000))
-(assert_return (invoke "shr_u" (i64.const 0x4000000000000000) (i64.const 1)) (i64.const 0x2000000000000000))
-(assert_return (invoke "shr_u" (i64.const 1) (i64.const 64)) (i64.const 1))
-(assert_return (invoke "shr_u" (i64.const 1) (i64.const 65)) (i64.const 0))
-(assert_return (invoke "shr_u" (i64.const 1) (i64.const -1)) (i64.const 0))
-(assert_return (invoke "shr_u" (i64.const 1) (i64.const 0x7fffffffffffffff)) (i64.const 0))
-(assert_return (invoke "shr_u" (i64.const 1) (i64.const 0x8000000000000000)) (i64.const 1))
-(assert_return (invoke "shr_u" (i64.const 0x8000000000000000) (i64.const 63)) (i64.const 1))
-(assert_return (invoke "shr_u" (i64.const -1) (i64.const 64)) (i64.const -1))
-(assert_return (invoke "shr_u" (i64.const -1) (i64.const 65)) (i64.const 0x7fffffffffffffff))
-(assert_return (invoke "shr_u" (i64.const -1) (i64.const -1)) (i64.const 1))
-(assert_return (invoke "shr_u" (i64.const -1) (i64.const 0x7fffffffffffffff)) (i64.const 1))
-(assert_return (invoke "shr_u" (i64.const -1) (i64.const 0x8000000000000000)) (i64.const -1))
-
-(assert_return (invoke "rotl" (i64.const 1) (i64.const 1)) (i64.const 2))
-(assert_return (invoke "rotl" (i64.const 1) (i64.const 0)) (i64.const 1))
-(assert_return (invoke "rotl" (i64.const -1) (i64.const 1)) (i64.const -1))
-(assert_return (invoke "rotl" (i64.const 1) (i64.const 64)) (i64.const 1))
-(assert_return (invoke "rotl" (i64.const 0xabcd987602468ace) (i64.const 1)) (i64.const 0x579b30ec048d159d))
-(assert_return (invoke "rotl" (i64.const 0xfe000000dc000000) (i64.const 4)) (i64.const 0xe000000dc000000f))
-(assert_return (invoke "rotl" (i64.const 0xabcd1234ef567809) (i64.const 53)) (i64.const 0x013579a2469deacf))
-(assert_return (invoke "rotl" (i64.const 0xabd1234ef567809c) (i64.const 63)) (i64.const 0x55e891a77ab3c04e))
-(assert_return (invoke "rotl" (i64.const 0xabcd1234ef567809) (i64.const 0xf5)) (i64.const 0x013579a2469deacf))
-(assert_return (invoke "rotl" (i64.const 0xabcd7294ef567809) (i64.const 0xffffffffffffffed)) (i64.const 0xcf013579ae529dea))
-(assert_return (invoke "rotl" (i64.const 0xabd1234ef567809c) (i64.const 0x800000000000003f)) (i64.const 0x55e891a77ab3c04e))
-(assert_return (invoke "rotl" (i64.const 1) (i64.const 63)) (i64.const 0x8000000000000000))
-(assert_return (invoke "rotl" (i64.const 0x8000000000000000) (i64.const 1)) (i64.const 1))
-
-(assert_return (invoke "rotr" (i64.const 1) (i64.const 1)) (i64.const 0x8000000000000000))
-(assert_return (invoke "rotr" (i64.const 1) (i64.const 0)) (i64.const 1))
-(assert_return (invoke "rotr" (i64.const -1) (i64.const 1)) (i64.const -1))
-(assert_return (invoke "rotr" (i64.const 1) (i64.const 64)) (i64.const 1))
-(assert_return (invoke "rotr" (i64.const 0xabcd987602468ace) (i64.const 1)) (i64.const 0x55e6cc3b01234567))
-(assert_return (invoke "rotr" (i64.const 0xfe000000dc000000) (i64.const 4)) (i64.const 0x0fe000000dc00000))
-(assert_return (invoke "rotr" (i64.const 0xabcd1234ef567809) (i64.const 53)) (i64.const 0x6891a77ab3c04d5e))
-(assert_return (invoke "rotr" (i64.const 0xabd1234ef567809c) (i64.const 63)) (i64.const 0x57a2469deacf0139))
-(assert_return (invoke "rotr" (i64.const 0xabcd1234ef567809) (i64.const 0xf5)) (i64.const 0x6891a77ab3c04d5e))
-(assert_return (invoke "rotr" (i64.const 0xabcd7294ef567809) (i64.const 0xffffffffffffffed)) (i64.const 0x94a77ab3c04d5e6b))
-(assert_return (invoke "rotr" (i64.const 0xabd1234ef567809c) (i64.const 0x800000000000003f)) (i64.const 0x57a2469deacf0139))
-(assert_return (invoke "rotr" (i64.const 1) (i64.const 63)) (i64.const 2))
-(assert_return (invoke "rotr" (i64.const 0x8000000000000000) (i64.const 63)) (i64.const 1))
-
-(assert_return (invoke "clz" (i64.const 0xffffffffffffffff)) (i64.const 0))
-(assert_return (invoke "clz" (i64.const 0)) (i64.const 64))
-(assert_return (invoke "clz" (i64.const 0x00008000)) (i64.const 48))
-(assert_return (invoke "clz" (i64.const 0xff)) (i64.const 56))
-(assert_return (invoke "clz" (i64.const 0x8000000000000000)) (i64.const 0))
-(assert_return (invoke "clz" (i64.const 1)) (i64.const 63))
-(assert_return (invoke "clz" (i64.const 2)) (i64.const 62))
-(assert_return (invoke "clz" (i64.const 0x7fffffffffffffff)) (i64.const 1))
-
-(assert_return (invoke "ctz" (i64.const -1)) (i64.const 0))
-(assert_return (invoke "ctz" (i64.const 0)) (i64.const 64))
-(assert_return (invoke "ctz" (i64.const 0x00008000)) (i64.const 15))
-(assert_return (invoke "ctz" (i64.const 0x00010000)) (i64.const 16))
-(assert_return (invoke "ctz" (i64.const 0x8000000000000000)) (i64.const 63))
-(assert_return (invoke "ctz" (i64.const 0x7fffffffffffffff)) (i64.const 0))
-
-(assert_return (invoke "popcnt" (i64.const -1)) (i64.const 64))
-(assert_return (invoke "popcnt" (i64.const 0)) (i64.const 0))
-(assert_return (invoke "popcnt" (i64.const 0x00008000)) (i64.const 1))
-(assert_return (invoke "popcnt" (i64.const 0x8000800080008000)) (i64.const 4))
-(assert_return (invoke "popcnt" (i64.const 0x7fffffffffffffff)) (i64.const 63))
-(assert_return (invoke "popcnt" (i64.const 0xAAAAAAAA55555555)) (i64.const 32))
-(assert_return (invoke "popcnt" (i64.const 0x99999999AAAAAAAA)) (i64.const 32))
-(assert_return (invoke "popcnt" (i64.const 0xDEADBEEFDEADBEEF)) (i64.const 48))
-
-(assert_return (invoke "eqz" (i64.const 0)) (i32.const 1))
-(assert_return (invoke "eqz" (i64.const 1)) (i32.const 0))
-(assert_return (invoke "eqz" (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "eqz" (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_return (invoke "eqz" (i64.const 0xffffffffffffffff)) (i32.const 0))
-
-(assert_return (invoke "eq" (i64.const 0) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "eq" (i64.const 1) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "eq" (i64.const -1) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "eq" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
-(assert_return (invoke "eq" (i64.const -1) (i64.const -1)) (i32.const 1))
-(assert_return (invoke "eq" (i64.const 1) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "eq" (i64.const 0) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "eq" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
-(assert_return (invoke "eq" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "eq" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_return (invoke "eq" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
-
-(assert_return (invoke "ne" (i64.const 0) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "ne" (i64.const 1) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "ne" (i64.const -1) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "ne" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_return (invoke "ne" (i64.const -1) (i64.const -1)) (i32.const 0))
-(assert_return (invoke "ne" (i64.const 1) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "ne" (i64.const 0) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "ne" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
-(assert_return (invoke "ne" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "ne" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
-(assert_return (invoke "ne" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
-
-(assert_return (invoke "lt_s" (i64.const 0) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "lt_s" (i64.const 1) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "lt_s" (i64.const -1) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "lt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_return (invoke "lt_s" (i64.const -1) (i64.const -1)) (i32.const 0))
-(assert_return (invoke "lt_s" (i64.const 1) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "lt_s" (i64.const 0) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "lt_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
-(assert_return (invoke "lt_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "lt_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
-(assert_return (invoke "lt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
-
-(assert_return (invoke "lt_u" (i64.const 0) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "lt_u" (i64.const 1) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "lt_u" (i64.const -1) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "lt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_return (invoke "lt_u" (i64.const -1) (i64.const -1)) (i32.const 0))
-(assert_return (invoke "lt_u" (i64.const 1) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "lt_u" (i64.const 0) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "lt_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
-(assert_return (invoke "lt_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "lt_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_return (invoke "lt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
-
-(assert_return (invoke "le_s" (i64.const 0) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "le_s" (i64.const 1) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "le_s" (i64.const -1) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "le_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
-(assert_return (invoke "le_s" (i64.const -1) (i64.const -1)) (i32.const 1))
-(assert_return (invoke "le_s" (i64.const 1) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "le_s" (i64.const 0) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "le_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
-(assert_return (invoke "le_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "le_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
-(assert_return (invoke "le_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
-
-(assert_return (invoke "le_u" (i64.const 0) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "le_u" (i64.const 1) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "le_u" (i64.const -1) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "le_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
-(assert_return (invoke "le_u" (i64.const -1) (i64.const -1)) (i32.const 1))
-(assert_return (invoke "le_u" (i64.const 1) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "le_u" (i64.const 0) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "le_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 1))
-(assert_return (invoke "le_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "le_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_return (invoke "le_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
-
-(assert_return (invoke "gt_s" (i64.const 0) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "gt_s" (i64.const 1) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "gt_s" (i64.const -1) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "gt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_return (invoke "gt_s" (i64.const -1) (i64.const -1)) (i32.const 0))
-(assert_return (invoke "gt_s" (i64.const 1) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "gt_s" (i64.const 0) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "gt_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
-(assert_return (invoke "gt_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "gt_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_return (invoke "gt_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
-
-(assert_return (invoke "gt_u" (i64.const 0) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "gt_u" (i64.const 1) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "gt_u" (i64.const -1) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "gt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_return (invoke "gt_u" (i64.const -1) (i64.const -1)) (i32.const 0))
-(assert_return (invoke "gt_u" (i64.const 1) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "gt_u" (i64.const 0) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "gt_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
-(assert_return (invoke "gt_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "gt_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
-(assert_return (invoke "gt_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
-
-(assert_return (invoke "ge_s" (i64.const 0) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "ge_s" (i64.const 1) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "ge_s" (i64.const -1) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "ge_s" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
-(assert_return (invoke "ge_s" (i64.const -1) (i64.const -1)) (i32.const 1))
-(assert_return (invoke "ge_s" (i64.const 1) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "ge_s" (i64.const 0) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 0))
-(assert_return (invoke "ge_s" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
-(assert_return (invoke "ge_s" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "ge_s" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 0))
-(assert_return (invoke "ge_s" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 1))
-
-(assert_return (invoke "ge_u" (i64.const 0) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "ge_u" (i64.const 1) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "ge_u" (i64.const -1) (i64.const 1)) (i32.const 1))
-(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "ge_u" (i64.const 0x7fffffffffffffff) (i64.const 0x7fffffffffffffff)) (i32.const 1))
-(assert_return (invoke "ge_u" (i64.const -1) (i64.const -1)) (i32.const 1))
-(assert_return (invoke "ge_u" (i64.const 1) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "ge_u" (i64.const 0) (i64.const 1)) (i32.const 0))
-(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const 0)) (i32.const 1))
-(assert_return (invoke "ge_u" (i64.const 0) (i64.const 0x8000000000000000)) (i32.const 0))
-(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const -1)) (i32.const 0))
-(assert_return (invoke "ge_u" (i64.const -1) (i64.const 0x8000000000000000)) (i32.const 1))
-(assert_return (invoke "ge_u" (i64.const 0x8000000000000000) (i64.const 0x7fffffffffffffff)) (i32.const 1))
-(assert_return (invoke "ge_u" (i64.const 0x7fffffffffffffff) (i64.const 0x8000000000000000)) (i32.const 0))
diff --git a/tests/misc_testsuite/winch/if.wast b/tests/misc_testsuite/winch/if.wast
deleted file mode 100644
index 8f67dd9b673e..000000000000
--- a/tests/misc_testsuite/winch/if.wast
+++ /dev/null
@@ -1,316 +0,0 @@
-;; Test `if` operator
-
-(module
-  ;; Auxiliary definition
-  (memory 1)
-
-  (func $dummy)
-
-  (func (export "empty") (param i32)
-    (if (local.get 0) (then))
-    (if (local.get 0) (then) (else))
-    (if $l (local.get 0) (then))
-    (if $l (local.get 0) (then) (else))
-  )
-
-  (func (export "singular") (param i32) (result i32)
-    (if (local.get 0) (then (nop)))
-    (if (local.get 0) (then (nop)) (else (nop)))
-    (if (result i32) (local.get 0) (then (i32.const 7)) (else (i32.const 8)))
-  )
-
-  (func (export "nested") (param i32 i32) (result i32)
-    (if (result i32) (local.get 0)
-      (then
-        (if (local.get 1) (then (call $dummy) (block) (nop)))
-        (if (local.get 1) (then) (else (call $dummy) (block) (nop)))
-        (if (result i32) (local.get 1)
-          (then (call $dummy) (i32.const 9))
-          (else (call $dummy) (i32.const 10))
-        )
-      )
-      (else
-        (if (local.get 1) (then (call $dummy) (block) (nop)))
-        (if (local.get 1) (then) (else (call $dummy) (block) (nop)))
-        (if (result i32) (local.get 1)
-          (then (call $dummy) (i32.const 10))
-          (else (call $dummy) (i32.const 11))
-        )
-      )
-    )
-  )
-
-  (func (export "as-loop-first") (param i32) (result i32)
-    (loop (result i32)
-      (if (result i32) (local.get 0)
-        (then (call $dummy) (i32.const 1))
-        (else (call $dummy) (i32.const 0))
-      )
-      (call $dummy) (call $dummy)
-    )
-  )
-  (func (export "as-loop-mid") (param i32) (result i32)
-    (loop (result i32)
-      (call $dummy)
-      (if (result i32) (local.get 0)
-        (then (call $dummy) (i32.const 1))
-        (else (call $dummy) (i32.const 0))
-      )
-      (call $dummy)
-    )
-  )
-  (func (export "as-loop-last") (param i32) (result i32)
-    (loop (result i32)
-      (call $dummy) (call $dummy)
-      (if (result i32) (local.get 0)
-        (then (call $dummy) (i32.const 1))
-        (else (call $dummy) (i32.const 0))
-      )
-    )
-  )
-
-  (func (export "as-if-condition") (param i32) (result i32)
-    (if (result i32)
-      (if (result i32) (local.get 0)
-        (then (i32.const 1)) (else (i32.const 0))
-      )
-      (then (call $dummy) (i32.const 2))
-      (else (call $dummy) (i32.const 3))
-    )
-  )
-
-  (func (export "as-br_if-first") (param i32) (result i32)
-    (block (result i32)
-      (br_if 0
-        (if (result i32) (local.get 0)
-          (then (call $dummy) (i32.const 1))
-          (else (call $dummy) (i32.const 0))
-        )
-        (i32.const 2)
-      )
-      (return (i32.const 3))
-    )
-  )
-  (func (export "as-br_if-last") (param i32) (result i32)
-    (block (result i32)
-      (br_if 0
-        (i32.const 2)
-        (if (result i32) (local.get 0)
-          (then (call $dummy) (i32.const 1))
-          (else (call $dummy) (i32.const 0))
-        )
-      )
-      (return (i32.const 3))
-    )
-  )
-
-  (func $f (param i32) (result i32) (local.get 0))
-
-  (func (export "as-call-value") (param i32) (result i32)
-    (call $f
-      (if (result i32) (local.get 0)
-        (then (i32.const 1))
-        (else (i32.const 0))
-      )
-    )
-  )
-  (func (export "as-return-value") (param i32) (result i32)
-    (if (result i32) (local.get 0)
-      (then (i32.const 1))
-      (else (i32.const 0)))
-    (return)
-  )
-  (func (export "as-drop-operand") (param i32)
-    (drop
-      (if (result i32) (local.get 0)
-        (then (i32.const 1))
-        (else (i32.const 0))
-      )
-    )
-  )
-  (func (export "as-br-value") (param i32) (result i32)
-    (block (result i32)
-      (br 0
-        (if (result i32) (local.get 0)
-          (then (i32.const 1))
-          (else (i32.const 0))
-        )
-      )
-    )
-  )
-  (func (export "as-local.set-value") (param i32) (result i32)
-    (local i32)
-    (local.set 0
-      (if (result i32) (local.get 0)
-        (then (i32.const 1))
-        (else (i32.const 0))
-      )
-    )
-    (local.get 0)
-  )
-  (func (export "as-unary-operand") (param i32) (result i32)
-    (i32.ctz
-      (if (result i32) (local.get 0)
-        (then (call $dummy) (i32.const 13))
-        (else (call $dummy) (i32.const -13))
-      )
-    )
-  )
-  (func (export "as-binary-operand") (param i32 i32) (result i32)
-    (i32.mul
-      (if (result i32) (local.get 0)
-        (then (call $dummy) (i32.const 3))
-        (else (call $dummy) (i32.const -3))
-      )
-      (if (result i32) (local.get 1)
-        (then (call $dummy) (i32.const 4))
-        (else (call $dummy) (i32.const -5))
-      )
-    )
-  )
-  (func (export "as-test-operand") (param i32) (result i32)
-    (i32.eqz
-      (if (result i32) (local.get 0)
-        (then (call $dummy) (i32.const 13))
-        (else (call $dummy) (i32.const 0))
-      )
-    )
-  )
-
-  (func (export "break-value") (param i32) (result i32)
-    (if (result i32) (local.get 0)
-      (then (br 0 (i32.const 18)) (i32.const 19))
-      (else (br 0 (i32.const 21)) (i32.const 20))
-    )
-  )
-
-  (func (export "effects") (param i32) (result i32)
-    (local i32)
-    (if
-      (block (result i32) (local.set 1 (i32.const 1)) (local.get 0))
-      (then
-        (local.set 1 (i32.mul (local.get 1) (i32.const 3)))
-        (local.set 1 (i32.sub (local.get 1) (i32.const 5)))
-        (local.set 1 (i32.mul (local.get 1) (i32.const 7)))
-        (br 0)
-        (local.set 1 (i32.mul (local.get 1) (i32.const 100)))
-      )
-      (else
-        (local.set 1 (i32.mul (local.get 1) (i32.const 5)))
-        (local.set 1 (i32.sub (local.get 1) (i32.const 7)))
-        (local.set 1 (i32.mul (local.get 1) (i32.const 3)))
-        (br 0)
-        (local.set 1 (i32.mul (local.get 1) (i32.const 1000)))
-      )
-    )
-    (local.get 1)
-  )
-
-  (func (export "as-br_table-first") (param i32) (result i32)
-    (block (result i32)
-      (if (result i32) (local.get 0)
-        (then (call $dummy) (i32.const 1))
-        (else (call $dummy) (i32.const 0))
-      )
-      (i32.const 2)
-      (br_table 0 0)
-    )
-  )
-  (func (export "as-br_table-last") (param i32) (result i32)
-    (block (result i32)
-      (i32.const 2)
-      (if (result i32) (local.get 0)
-        (then (call $dummy) (i32.const 1))
-        (else (call $dummy) (i32.const 0))
-      )
-      (br_table 0 0)
-    )
-  )
-
-  (func (export "break-bare") (result i32)
-    (if (i32.const 1) (then (br 0) (unreachable)))
-    (if (i32.const 1) (then (br 0) (unreachable)) (else (unreachable)))
-    (if (i32.const 0) (then (unreachable)) (else (br 0) (unreachable)))
-    (if (i32.const 1) (then (br_if 0 (i32.const 1)) (unreachable)))
-    (if (i32.const 1) (then (br_if 0 (i32.const 1)) (unreachable)) (else (unreachable)))
-    (if (i32.const 0) (then (unreachable)) (else (br_if 0 (i32.const 1)) (unreachable)))
-    (if (i32.const 1) (then (br_table 0 (i32.const 0)) (unreachable)))
-    (if (i32.const 1) (then (br_table 0 (i32.const 0)) (unreachable)) (else (unreachable)))
-    (if (i32.const 0) (then (unreachable)) (else (br_table 0 (i32.const 0)) (unreachable)))
-    (i32.const 19)
-  )
-)
-
-(assert_return (invoke "empty" (i32.const 0)))
-(assert_return (invoke "empty" (i32.const 1)))
-(assert_return (invoke "empty" (i32.const 100)))
-(assert_return (invoke "empty" (i32.const -2)))
-
-(assert_return (invoke "singular" (i32.const 0)) (i32.const 8))
-(assert_return (invoke "singular" (i32.const 1)) (i32.const 7))
-(assert_return (invoke "singular" (i32.const 10)) (i32.const 7))
-(assert_return (invoke "singular" (i32.const -10)) (i32.const 7))
-
-(assert_return (invoke "nested" (i32.const 0) (i32.const 0)) (i32.const 11))
-(assert_return (invoke "nested" (i32.const 1) (i32.const 0)) (i32.const 10))
-(assert_return (invoke "nested" (i32.const 0) (i32.const 1)) (i32.const 10))
-(assert_return (invoke "nested" (i32.const 3) (i32.const 2)) (i32.const 9))
-(assert_return (invoke "nested" (i32.const 0) (i32.const -100)) (i32.const 10))
-(assert_return (invoke "nested" (i32.const 10) (i32.const 10)) (i32.const 9))
-(assert_return (invoke "nested" (i32.const 0) (i32.const -1)) (i32.const 10))
-(assert_return (invoke "nested" (i32.const -111) (i32.const -2)) (i32.const 9))
-
-(assert_return (invoke "as-loop-first" (i32.const 0)) (i32.const 0))
-(assert_return (invoke "as-loop-first" (i32.const 1)) (i32.const 1))
-(assert_return (invoke "as-loop-mid" (i32.const 0)) (i32.const 0))
-(assert_return (invoke "as-loop-mid" (i32.const 1)) (i32.const 1))
-(assert_return (invoke "as-loop-last" (i32.const 0)) (i32.const 0))
-(assert_return (invoke "as-loop-last" (i32.const 1)) (i32.const 1))
-
-(assert_return (invoke "as-if-condition" (i32.const 0)) (i32.const 3))
-(assert_return (invoke "as-if-condition" (i32.const 1)) (i32.const 2))
-
-(assert_return (invoke "as-br_if-first" (i32.const 0)) (i32.const 0))
-(assert_return (invoke "as-br_if-first" (i32.const 1)) (i32.const 1))
-(assert_return (invoke "as-br_if-last" (i32.const 0)) (i32.const 3))
-(assert_return (invoke "as-br_if-last" (i32.const 1)) (i32.const 2))
-
-(assert_return (invoke "as-call-value" (i32.const 0)) (i32.const 0))
-(assert_return (invoke "as-call-value" (i32.const 1)) (i32.const 1))
-
-(assert_return (invoke "as-return-value" (i32.const 0)) (i32.const 0))
-(assert_return (invoke "as-return-value" (i32.const 1)) (i32.const 1))
-
-(assert_return (invoke "as-br-value" (i32.const 0)) (i32.const 0))
-(assert_return (invoke "as-br-value" (i32.const 1)) (i32.const 1))
-
-(assert_return (invoke "as-local.set-value" (i32.const 0)) (i32.const 0))
-(assert_return (invoke "as-local.set-value" (i32.const 1)) (i32.const 1))
-
-(assert_return (invoke "as-unary-operand" (i32.const 0)) (i32.const 0))
-(assert_return (invoke "as-unary-operand" (i32.const 1)) (i32.const 0))
-(assert_return (invoke "as-unary-operand" (i32.const -1)) (i32.const 0))
-
-(assert_return (invoke "as-binary-operand" (i32.const 0) (i32.const 0)) (i32.const 15))
-(assert_return (invoke "as-binary-operand" (i32.const 0) (i32.const 1)) (i32.const -12))
-(assert_return (invoke "as-binary-operand" (i32.const 1) (i32.const 0)) (i32.const -15))
-(assert_return (invoke "as-binary-operand" (i32.const 1) (i32.const 1)) (i32.const 12))
-
-(assert_return (invoke "as-test-operand" (i32.const 0)) (i32.const 1))
-(assert_return (invoke "as-test-operand" (i32.const 1)) (i32.const 0))
-
-(assert_return (invoke "break-value" (i32.const 1)) (i32.const 18))
-(assert_return (invoke "break-value" (i32.const 0)) (i32.const 21))
-
-(assert_return (invoke "effects" (i32.const 1)) (i32.const -14))
-(assert_return (invoke "effects" (i32.const 0)) (i32.const -6))
-
-(assert_return (invoke "as-drop-operand" (i32.const 0)))
-(assert_return (invoke "as-drop-operand" (i32.const 1)))
-
-(assert_return (invoke "as-br_table-first" (i32.const 0)) (i32.const 0))
-(assert_return (invoke "as-br_table-first" (i32.const 1)) (i32.const 1))
-(assert_return (invoke "as-br_table-last" (i32.const 0)) (i32.const 2))
-(assert_return (invoke "as-br_table-last" (i32.const 1)) (i32.const 2))
-
-(assert_return (invoke "break-bare") (i32.const 19))
diff --git a/tests/misc_testsuite/winch/local_tee.wast b/tests/misc_testsuite/winch/local_tee.wast
deleted file mode 100644
index 68c9d4194426..000000000000
--- a/tests/misc_testsuite/winch/local_tee.wast
+++ /dev/null
@@ -1,174 +0,0 @@
-;; Test `local.tee` operator
-
-(module
-  ;; Typing
-
-  (func (export "type-local-i32") (result i32) (local i32) (local.tee 0 (i32.const 0)))
-  (func (export "type-local-i64") (result i64) (local i64) (local.tee 0 (i64.const 0)))
-  (func (export "type-local-f32") (result f32) (local f32) (local.tee 0 (f32.const 0)))
-  (func (export "type-local-f64") (result f64) (local f64) (local.tee 0 (f64.const 0)))
-
-  (func (export "type-param-i32") (param i32) (result i32) (local.tee 0 (i32.const 10)))
-  (func (export "type-param-i64") (param i64) (result i64) (local.tee 0 (i64.const 11)))
-  (func (export "type-param-f32") (param f32) (result f32) (local.tee 0 (f32.const 11.1)))
-  (func (export "type-param-f64") (param f64) (result f64) (local.tee 0 (f64.const 12.2)))
-
-  (func $dummy)
-
-  (func (export "as-block-first") (param i32) (result i32)
-    (block (result i32) (local.tee 0 (i32.const 1)) (call $dummy))
-  )
-  (func (export "as-block-mid") (param i32) (result i32)
-    (block (result i32) (call $dummy) (local.tee 0 (i32.const 1)) (call $dummy))
-  )
-  (func (export "as-block-last") (param i32) (result i32)
-    (block (result i32) (call $dummy) (call $dummy) (local.tee 0 (i32.const 1)))
-  )
-
-  (func (export "as-loop-first") (param i32) (result i32)
-    (loop (result i32) (local.tee 0 (i32.const 3)) (call $dummy))
-  )
-  (func (export "as-loop-mid") (param i32) (result i32)
-    (loop (result i32) (call $dummy) (local.tee 0 (i32.const 4)) (call $dummy))
-  )
-  (func (export "as-loop-last") (param i32) (result i32)
-    (loop (result i32) (call $dummy) (call $dummy) (local.tee 0 (i32.const 5)))
-  )
-
-  (func (export "as-br-value") (param i32) (result i32)
-    (block (result i32) (br 0 (local.tee 0 (i32.const 9))))
-  )
-
-  (func (export "as-br_if-cond") (param i32)
-    (block (br_if 0 (local.tee 0 (i32.const 1))))
-  )
-
-  (func (export "as-br_if-value") (param i32) (result i32)
-    (block (result i32)
-      (drop (br_if 0 (local.tee 0 (i32.const 8)) (i32.const 1))) (i32.const 7)
-    )
-  )
-
-  (func (export "as-br_if-value-cond") (param i32) (result i32)
-    (block (result i32)
-      (drop (br_if 0 (i32.const 6) (local.tee 0 (i32.const 9)))) (i32.const 7)
-    )
-  )
-
-  (func (export "as-return-value") (param i32) (result i32)
-    (return (local.tee 0 (i32.const 7)))
-  )
-
-  (func (export "as-if-cond") (param i32) (result i32)
-    (if (result i32) (local.tee 0 (i32.const 2))
-      (then (i32.const 0)) (else (i32.const 1))
-    )
-  )
-  (func (export "as-if-then") (param i32) (result i32)
-    (if (result i32) (local.get 0)
-      (then (local.tee 0 (i32.const 3))) (else (local.get 0))
-    )
-  )
-  (func (export "as-if-else") (param i32) (result i32)
-    (if (result i32) (local.get 0)
-      (then (local.get 0)) (else (local.tee 0 (i32.const 4)))
-    )
-  )
-
-  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
-  (func (export "as-call-first") (param i32) (result i32)
-    (call $f (local.tee 0 (i32.const 12)) (i32.const 2) (i32.const 3))
-  )
-  (func (export "as-call-mid") (param i32) (result i32)
-    (call $f (i32.const 1) (local.tee 0 (i32.const 13)) (i32.const 3))
-  )
-  (func (export "as-call-last") (param i32) (result i32)
-    (call $f (i32.const 1) (i32.const 2) (local.tee 0 (i32.const 14)))
-  )
-
-  (func (export "as-local.set-value") (local i32)
-    (local.set 0 (local.tee 0 (i32.const 1)))
-  )
-  (func (export "as-local.tee-value") (param i32) (result i32)
-    (local.tee 0 (local.tee 0 (i32.const 1)))
-  )
-
-  (func (export "as-binary-left") (param i32) (result i32)
-    (i32.add (local.tee 0 (i32.const 3)) (i32.const 10))
-  )
-  (func (export "as-binary-right") (param i32) (result i32)
-    (i32.sub (i32.const 10) (local.tee 0 (i32.const 4)))
-  )
-
-  (func (export "as-test-operand") (param i32) (result i32)
-    (i32.eqz (local.tee 0 (i32.const 0)))
-  )
-
-  (func (export "as-compare-left") (param i32) (result i32)
-    (i32.le_s (local.tee 0 (i32.const 43)) (i32.const 10))
-  )
-  (func (export "as-compare-right") (param i32) (result i32)
-    (i32.ne (i32.const 10) (local.tee 0 (i32.const 42)))
-  )
-
-  (func (export "as-br_table-index") (param i32)
-    (block (br_table 0 0 0 (local.tee 0 (i32.const 0))))
-  )
-  (func (export "as-br_table-value") (param i32) (result i32)
-    (block (result i32)
-      (br_table 0 0 0 (local.tee 0 (i32.const 10)) (i32.const 1)) (i32.const 7)
-    )
-  )
-  (func (export "as-br_table-value-index") (param i32) (result i32)
-    (block (result i32)
-      (br_table 0 0 (i32.const 6) (local.tee 0 (i32.const 11))) (i32.const 7)
-    )
-  )
-)
-
-(assert_return (invoke "type-local-i32") (i32.const 0))
-(assert_return (invoke "type-local-i64") (i64.const 0))
-(assert_return (invoke "type-local-f32") (f32.const 0))
-(assert_return (invoke "type-local-f64") (f64.const 0))
-
-(assert_return (invoke "type-param-i32" (i32.const 2)) (i32.const 10))
-(assert_return (invoke "type-param-i64" (i64.const 3)) (i64.const 11))
-(assert_return (invoke "type-param-f32" (f32.const 4.4)) (f32.const 11.1))
-(assert_return (invoke "type-param-f64" (f64.const 5.5)) (f64.const 12.2))
-
-(assert_return (invoke "as-block-first" (i32.const 0)) (i32.const 1))
-(assert_return (invoke "as-block-mid" (i32.const 0)) (i32.const 1))
-(assert_return (invoke "as-block-last" (i32.const 0)) (i32.const 1))
-
-(assert_return (invoke "as-loop-first" (i32.const 0)) (i32.const 3))
-(assert_return (invoke "as-loop-mid" (i32.const 0)) (i32.const 4))
-(assert_return (invoke "as-loop-last" (i32.const 0)) (i32.const 5))
-
-(assert_return (invoke "as-br-value" (i32.const 0)) (i32.const 9))
-
-(assert_return (invoke "as-br_if-cond" (i32.const 0)))
-(assert_return (invoke "as-br_if-value" (i32.const 0)) (i32.const 8))
-(assert_return (invoke "as-br_if-value-cond" (i32.const 0)) (i32.const 6))
-
-(assert_return (invoke "as-return-value" (i32.const 0)) (i32.const 7))
-
-(assert_return (invoke "as-if-cond" (i32.const 0)) (i32.const 0))
-(assert_return (invoke "as-if-then" (i32.const 1)) (i32.const 3))
-(assert_return (invoke "as-if-else" (i32.const 0)) (i32.const 4))
-
-(assert_return (invoke "as-call-first" (i32.const 0)) (i32.const -1))
-(assert_return (invoke "as-call-mid" (i32.const 0)) (i32.const -1))
-(assert_return (invoke "as-call-last" (i32.const 0)) (i32.const -1))
-
-(assert_return (invoke "as-local.set-value"))
-(assert_return (invoke "as-local.tee-value" (i32.const 0)) (i32.const 1))
-
-(assert_return (invoke "as-binary-left" (i32.const 0)) (i32.const 13))
-(assert_return (invoke "as-binary-right" (i32.const 0)) (i32.const 6))
-(assert_return (invoke "as-test-operand" (i32.const 0)) (i32.const 1))
-(assert_return (invoke "as-compare-left" (i32.const 0)) (i32.const 0))
-(assert_return (invoke "as-compare-right" (i32.const 0)) (i32.const 1))
-
-(assert_return (invoke "as-br_table-index" (i32.const 0)))
-(assert_return (invoke "as-br_table-value" (i32.const 0)) (i32.const 10))
-(assert_return (invoke "as-br_table-value-index" (i32.const 0)) (i32.const 6))
diff --git a/tests/misc_testsuite/winch/loop.wast b/tests/misc_testsuite/winch/loop.wast
deleted file mode 100644
index 71cd6e752ee2..000000000000
--- a/tests/misc_testsuite/winch/loop.wast
+++ /dev/null
@@ -1,237 +0,0 @@
-;; Test `loop` opcode
-
-(module
-  (memory 1)
-
-  (func $dummy)
-
-  (func (export "empty")
-    (loop)
-    (loop $l)
-  )
-
-  (func (export "singular") (result i32)
-    (loop (nop))
-    (loop (result i32) (i32.const 7))
-  )
-
-
-  (func (export "nested") (result i32)
-    (loop (result i32)
-      (loop (call $dummy) (block) (nop))
-      (loop (result i32) (call $dummy) (i32.const 9))
-    )
-  )
-
-  (func (export "as-br_table-first") (result i32)
-    (block (result i32) (loop (result i32) (i32.const 1)) (i32.const 2) (br_table 0 0))
-  )
-  (func (export "as-br_table-last") (result i32)
-    (block (result i32) (i32.const 2) (loop (result i32) (i32.const 1)) (br_table 0 0))
-  )
-
-  (func (export "break-repeated") (result i32)
-    (block (result i32)
-      (loop (result i32)
-        (br 1 (i32.const 18))
-        (br 1 (i32.const 19))
-        (drop (br_if 1 (i32.const 20) (i32.const 0)))
-        (drop (br_if 1 (i32.const 20) (i32.const 1)))
-        (br 1 (i32.const 21))
-        (br_table 1 (i32.const 22) (i32.const 0))
-        (br_table 1 1 1 (i32.const 23) (i32.const 1))
-        (i32.const 21)
-      )
-    )
-  )
-
-  (func (export "break-bare") (result i32)
-    (block (loop (br 1) (br 0) (unreachable)))
-    (block (loop (br_if 1 (i32.const 1)) (unreachable)))
-    (block (loop (br_table 1 (i32.const 0)) (unreachable)))
-    (block (loop (br_table 1 1 1 (i32.const 1)) (unreachable)))
-    (i32.const 19)
-  )
-
-  (func (export "deep") (result i32)
-    (loop (result i32) (block (result i32)
-      (loop (result i32) (block (result i32)
-        (loop (result i32) (block (result i32)
-          (loop (result i32) (block (result i32)
-            (loop (result i32) (block (result i32)
-              (loop (result i32) (block (result i32)
-                (loop (result i32) (block (result i32)
-                  (loop (result i32) (block (result i32)
-                    (loop (result i32) (block (result i32)
-                      (loop (result i32) (block (result i32)
-                        (loop (result i32) (block (result i32)
-                          (loop (result i32) (block (result i32)
-                            (loop (result i32) (block (result i32)
-                              (loop (result i32) (block (result i32)
-                                (loop (result i32) (block (result i32)
-                                  (loop (result i32) (block (result i32)
-                                    (loop (result i32) (block (result i32)
-                                      (loop (result i32) (block (result i32)
-                                        (loop (result i32) (block (result i32)
-                                          (loop (result i32) (block (result i32)
-                                            (call $dummy) (i32.const 150)
-                                          ))
-                                        ))
-                                      ))
-                                    ))
-                                  ))
-                                ))
-                              ))
-                            ))
-                          ))
-                        ))
-                      ))
-                    ))
-                  ))
-                ))
-              ))
-            ))
-          ))
-        ))
-      ))
-    ))
-  )
-
-  (func (export "as-if-condition")
-    (loop (result i32) (i32.const 1)) (if (then (call $dummy)))
-  )
-  (func (export "as-if-then") (result i32)
-    (if (result i32) (i32.const 1) (then (loop (result i32) (i32.const 1))) (else (i32.const 2)))
-  )
-  (func (export "as-if-else") (result i32)
-    (if (result i32) (i32.const 1) (then (i32.const 2)) (else (loop (result i32) (i32.const 1))))
-  )
-
-  (func (export "as-br_if-first") (result i32)
-    (block (result i32) (br_if 0 (loop (result i32) (i32.const 1)) (i32.const 2)))
-  )
-  (func (export "as-br_if-last") (result i32)
-    (block (result i32) (br_if 0 (i32.const 2) (loop (result i32) (i32.const 1))))
-  )
-
-  (func $f (param i32) (result i32) (local.get 0))
-
-  (func (export "as-call-value") (result i32)
-    (call $f (loop (result i32) (i32.const 1)))
-  )
-  (func (export "as-return-value") (result i32)
-    (loop (result i32) (i32.const 1)) (return)
-  )
-  (func (export "as-drop-operand")
-    (drop (loop (result i32) (i32.const 1)))
-  )
-  (func (export "as-br-value") (result i32)
-    (block (result i32) (br 0 (loop (result i32) (i32.const 1))))
-  )
-  (func (export "as-local.set-value") (result i32)
-    (local i32) (local.set 0 (loop (result i32) (i32.const 1))) (local.get 0)
-  )
-
-  (func (export "as-unary-operand") (result i32)
-    (i32.ctz (loop (result i32) (call $dummy) (i32.const 13)))
-  )
-  (func (export "as-binary-operand") (result i32)
-    (i32.mul
-      (loop (result i32) (call $dummy) (i32.const 3))
-      (loop (result i32) (call $dummy) (i32.const 4))
-    )
-  )
-  (func (export "as-test-operand") (result i32)
-    (i32.eqz (loop (result i32) (call $dummy) (i32.const 13)))
-  )
-
-  (func (export "break-inner") (result i32)
-    (local i32)
-    (local.set 0 (i32.const 0))
-    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (block (result i32) (br 2 (i32.const 0x1)))))))
-    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (loop (result i32) (br 2 (i32.const 0x2)))))))
-    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (block (result i32) (loop (result i32) (br 1 (i32.const 0x4))))))))
-    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (i32.ctz (br 1 (i32.const 0x8)))))))
-    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (i32.ctz (loop (result i32) (br 2 (i32.const 0x10))))))))
-    (local.get 0)
-  )
-
-  (func $fx (export "effects") (result i32)
-    (local i32)
-    (block
-      (loop
-        (local.set 0 (i32.const 1))
-        (local.set 0 (i32.mul (local.get 0) (i32.const 3)))
-        (local.set 0 (i32.sub (local.get 0) (i32.const 5)))
-        (local.set 0 (i32.mul (local.get 0) (i32.const 7)))
-        (br 1)
-        (local.set 0 (i32.mul (local.get 0) (i32.const 100)))
-      )
-    )
-    (i32.eq (local.get 0) (i32.const -14))
-  )
-
-  (func (export "while") (param i64) (result i64)
-    (local i64)
-    (local.set 1 (i64.const 1))
-    (block
-      (loop
-        (br_if 1 (i64.eqz (local.get 0)))
-        (local.set 1 (i64.mul (local.get 0) (local.get 1)))
-        (local.set 0 (i64.sub (local.get 0) (i64.const 1)))
-        (br 0)
-      )
-    )
-    (local.get 1)
-  )
-
-  (func (export "for") (param i64) (result i64)
-    (local i64 i64)
-    (local.set 1 (i64.const 1))
-    (local.set 2 (i64.const 2))
-    (block
-      (loop
-        (br_if 1 (i64.gt_u (local.get 2) (local.get 0)))
-        (local.set 1 (i64.mul (local.get 1) (local.get 2)))
-        (local.set 2 (i64.add (local.get 2) (i64.const 1)))
-        (br 0)
-      )
-    )
-    (local.get 1)
-  )
-)
-
-(assert_return (invoke "empty"))
-(assert_return (invoke "singular") (i32.const 7))
-(assert_return (invoke "nested") (i32.const 9))
-(assert_return (invoke "deep") (i32.const 150))
-(assert_return (invoke "as-if-condition"))
-(assert_return (invoke "as-if-then") (i32.const 1))
-(assert_return (invoke "as-if-else") (i32.const 2))
-(assert_return (invoke "as-br_if-first") (i32.const 1))
-(assert_return (invoke "as-br_if-last") (i32.const 2))
-(assert_return (invoke "as-call-value") (i32.const 1))
-(assert_return (invoke "as-drop-operand"))
-(assert_return (invoke "as-return-value") (i32.const 1))
-(assert_return (invoke "as-br-value") (i32.const 1))
-(assert_return (invoke "as-local.set-value") (i32.const 1))
-(assert_return (invoke "as-unary-operand") (i32.const 0))
-(assert_return (invoke "as-binary-operand") (i32.const 12))
-(assert_return (invoke "as-test-operand") (i32.const 0))
-(assert_return (invoke "break-inner") (i32.const 0x1f))
-(assert_return (invoke "effects") (i32.const 1))
-(assert_return (invoke "while" (i64.const 0)) (i64.const 1))
-(assert_return (invoke "while" (i64.const 1)) (i64.const 1))
-(assert_return (invoke "while" (i64.const 2)) (i64.const 2))
-(assert_return (invoke "while" (i64.const 3)) (i64.const 6))
-(assert_return (invoke "while" (i64.const 5)) (i64.const 120))
-(assert_return (invoke "while" (i64.const 20)) (i64.const 2432902008176640000))
-(assert_return (invoke "for" (i64.const 0)) (i64.const 1))
-(assert_return (invoke "for" (i64.const 1)) (i64.const 1))
-(assert_return (invoke "for" (i64.const 2)) (i64.const 2))
-(assert_return (invoke "for" (i64.const 3)) (i64.const 6))
-(assert_return (invoke "for" (i64.const 5)) (i64.const 120))
-(assert_return (invoke "for" (i64.const 20)) (i64.const 2432902008176640000))
-
-(assert_return (invoke "break-bare") (i32.const 19))
-(assert_return (invoke "break-repeated") (i32.const 18))
diff --git a/tests/misc_testsuite/winch/misc.wast b/tests/misc_testsuite/winch/misc.wast
new file mode 100644
index 000000000000..31f5098d4c98
--- /dev/null
+++ b/tests/misc_testsuite/winch/misc.wast
@@ -0,0 +1,14 @@
+;; Additional run tests for Winch not covered in the official spec test suite.
+
+(module
+  (func (export "br-table-ensure-sp") (result i32)
+    (block (result i32)
+       (i32.const 0)
+    )
+    (i32.const 0)
+    (i32.const 0)
+    (br_table 0)
+  )
+)
+
+(assert_return (invoke "br-table-ensure-sp") (i32.const 0))
diff --git a/tests/misc_testsuite/winch/oob.wast b/tests/misc_testsuite/winch/oob.wast
new file mode 100644
index 000000000000..c16344d64dab
--- /dev/null
+++ b/tests/misc_testsuite/winch/oob.wast
@@ -0,0 +1,10 @@
+(module
+  (memory 1)
+  (func (export "foo") (param $i i32)
+    i32.const 0
+    (local.get $i)
+    i32.store8 offset=4294967295
+  )
+)
+
+(assert_trap (invoke "foo" (i32.const 0)) "out of bounds") 
diff --git a/tests/misc_testsuite/winch/select.wast b/tests/misc_testsuite/winch/select.wast
index 4b52094f358e..2abc9a43ac47 100644
--- a/tests/misc_testsuite/winch/select.wast
+++ b/tests/misc_testsuite/winch/select.wast
@@ -112,6 +112,15 @@
       (i32.ne (i32.const 1) (select (i32.const 0) (i32.const 1) (local.get 0)))
     )
   )
+  (func (export "as-load-operand") (param i32) (result i32)
+    (i32.load (select (i32.const 0) (i32.const 4) (local.get 0)))
+  )
+  (func (export "as-store-first") (param i32)
+    (select (i32.const 0) (i32.const 4) (local.get 0)) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last") (param i32)
+    (i32.const 8) (select (i32.const 1) (i32.const 2) (local.get 0)) (i32.store)
+  )
 )
 
 (assert_return (invoke "select-i32" (i32.const 1) (i32.const 2) (i32.const 1)) (i32.const 1))
@@ -198,3 +207,11 @@
 (assert_return (invoke "as-br_table-first" (i32.const 1)) (i32.const 2))
 (assert_return (invoke "as-br_table-last" (i32.const 0)) (i32.const 2))
 (assert_return (invoke "as-br_table-last" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-store-first" (i32.const 0)))
+(assert_return (invoke "as-store-first" (i32.const 1)))
+(assert_return (invoke "as-store-last" (i32.const 0)))
+(assert_return (invoke "as-store-last" (i32.const 1)))
+(assert_return (invoke "as-load-operand" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-load-operand" (i32.const 1)) (i32.const 1))
+
diff --git a/tests/misc_testsuite/winch/table_fill.wast b/tests/misc_testsuite/winch/table_fill.wast
new file mode 100644
index 000000000000..56a98c164eb6
--- /dev/null
+++ b/tests/misc_testsuite/winch/table_fill.wast
@@ -0,0 +1,65 @@
+(module
+  (type $t0 (func))
+  (func $f1 (type $t0))
+  (func $f2 (type $t0))
+  (func $f3 (type $t0))
+
+  ;; Define two tables of funcref
+  (table $t1 3 funcref)
+  (table $t2 10 funcref)
+
+  ;; Initialize table $t1 with functions $f1, $f2, $f3
+  (elem (i32.const 0) $f1 $f2 $f3)
+
+  ;; Function to fill table $t1 using a function reference from table $t2
+  (func (export "fill") (param $i i32) (param $r i32) (param $n i32)
+    (local $ref funcref)
+    (local.set $ref (table.get $t1 (local.get $r)))
+    (table.fill $t2 (local.get $i) (local.get $ref) (local.get $n))
+  )
+
+  (func (export "get") (param $i i32) (result funcref)
+    (table.get $t2 (local.get $i))
+  )
+)
+
+(assert_return (invoke "get" (i32.const 1)) (ref.null func))
+(assert_return (invoke "get" (i32.const 2)) (ref.null func))
+(assert_return (invoke "get" (i32.const 3)) (ref.null func))
+(assert_return (invoke "get" (i32.const 4)) (ref.null func))
+(assert_return (invoke "get" (i32.const 5)) (ref.null func))
+
+(assert_return (invoke "fill" (i32.const 2) (i32.const 0) (i32.const 3)))
+(assert_return (invoke "get" (i32.const 1)) (ref.null func))
+(assert_return (invoke "get" (i32.const 2)) (ref.func 0))
+(assert_return (invoke "get" (i32.const 3)) (ref.func 0))
+(assert_return (invoke "get" (i32.const 4)) (ref.func 0))
+(assert_return (invoke "get" (i32.const 5)) (ref.null func))
+
+(assert_return (invoke "fill" (i32.const 4) (i32.const 1) (i32.const 2)))
+(assert_return (invoke "get" (i32.const 3)) (ref.func 0))
+(assert_return (invoke "get" (i32.const 4)) (ref.func 1))
+(assert_return (invoke "get" (i32.const 5)) (ref.func 1))
+(assert_return (invoke "get" (i32.const 6)) (ref.null func))
+
+(assert_return (invoke "fill" (i32.const 4) (i32.const 2) (i32.const 0)))
+(assert_return (invoke "get" (i32.const 3)) (ref.func 0))
+(assert_return (invoke "get" (i32.const 4)) (ref.func 1))
+(assert_return (invoke "get" (i32.const 5)) (ref.func 1))
+
+(assert_return (invoke "fill" (i32.const 8) (i32.const 0) (i32.const 2)))
+(assert_return (invoke "get" (i32.const 7)) (ref.null func))
+(assert_return (invoke "get" (i32.const 8)) (ref.func 0))
+(assert_return (invoke "get" (i32.const 9)) (ref.func 0))
+
+(assert_return (invoke "fill" (i32.const 9) (i32.const 2) (i32.const 1)))
+(assert_return (invoke "get" (i32.const 8)) (ref.func 0))
+(assert_return (invoke "get" (i32.const 9)) (ref.func 2))
+
+(assert_return (invoke "fill" (i32.const 10) (i32.const 1) (i32.const 0)))
+(assert_return (invoke "get" (i32.const 9)) (ref.func 2))
+
+(assert_trap
+  (invoke "fill" (i32.const 8) (i32.const 0) (i32.const 3))
+  "out of bounds table access"
+)
diff --git a/tests/misc_testsuite/winch/table_get.wast b/tests/misc_testsuite/winch/table_get.wast
new file mode 100644
index 000000000000..09f57cace9f3
--- /dev/null
+++ b/tests/misc_testsuite/winch/table_get.wast
@@ -0,0 +1,13 @@
+(module
+  (table $t3 3 funcref)
+  (elem (table $t3) (i32.const 1) func $dummy)
+  (func $dummy)
+  (func $f3 (export "get-funcref") (param $i i32) (result funcref)
+    (table.get $t3 (local.get $i))
+  )
+)
+
+(assert_return (invoke "get-funcref" (i32.const 0)) (ref.null func))
+(assert_trap (invoke "get-funcref" (i32.const 3)) "out of bounds table access")
+(assert_trap (invoke "get-funcref" (i32.const -1)) "out of bounds table access")
+
diff --git a/tests/misc_testsuite/winch/table_grow.wast b/tests/misc_testsuite/winch/table_grow.wast
new file mode 100644
index 000000000000..be293cb79469
--- /dev/null
+++ b/tests/misc_testsuite/winch/table_grow.wast
@@ -0,0 +1,26 @@
+(module
+  (table $t1 0 funcref)
+
+  (func (export "grow-by-10") (param $r funcref) (result i32)
+    (table.grow $t1 (local.get $r) (i32.const 10))
+  )
+  (func (export "grow-over") (param $r funcref) (result i32)
+    (table.grow $t1 (local.get $r) (i32.const 0xffff_fff0))
+  )
+
+  (func (export "size") (result i32)
+    (table.size $t1))
+)
+
+(assert_return (invoke "size") (i32.const 0))
+(assert_return (invoke "grow-by-10" (ref.null func)) (i32.const 0))
+(assert_return (invoke "size") (i32.const 10))
+
+(module
+  (table $t 0x10 funcref)
+  (func $f (export "grow") (param $r funcref) (result i32)
+    (table.grow $t (local.get $r) (i32.const 0xffff_fff0))
+  )
+)
+
+(assert_return (invoke "grow" (ref.null func)) (i32.const -1))
diff --git a/tests/misc_testsuite/winch/table_set.wast b/tests/misc_testsuite/winch/table_set.wast
new file mode 100644
index 000000000000..fb1f783883f2
--- /dev/null
+++ b/tests/misc_testsuite/winch/table_set.wast
@@ -0,0 +1,27 @@
+(module
+  (table $t3 2 funcref)
+  (elem (table $t3) (i32.const 1) func $dummy)
+  (func $dummy)
+
+  (func $f3 (export "get-funcref") (param $i i32) (result funcref)
+    (table.get $t3 (local.get $i))
+  )
+
+  (func (export "set-funcref") (param $i i32) (param $r funcref)
+    (table.set $t3 (local.get $i) (local.get $r))
+  )
+  (func (export "set-funcref-from") (param $i i32) (param $j i32)
+    (table.set $t3 (local.get $i) (table.get $t3 (local.get $j)))
+  )
+)
+
+(assert_return (invoke "get-funcref" (i32.const 0)) (ref.null func))
+(assert_return (invoke "set-funcref-from" (i32.const 0) (i32.const 1)))
+(assert_return (invoke "set-funcref" (i32.const 0) (ref.null func)))
+(assert_return (invoke "get-funcref" (i32.const 0)) (ref.null func))
+
+(assert_trap (invoke "set-funcref" (i32.const 3) (ref.null func)) "out of bounds table access")
+(assert_trap (invoke "set-funcref" (i32.const -1) (ref.null func)) "out of bounds table access")
+
+(assert_trap (invoke "set-funcref-from" (i32.const 3) (i32.const 1)) "out of bounds table access")
+(assert_trap (invoke "set-funcref-from" (i32.const -1) (i32.const 1)) "out of bounds table access")
diff --git a/tests/pcc_memory.rs b/tests/pcc_memory.rs
new file mode 100644
index 000000000000..dd54cf02b34a
--- /dev/null
+++ b/tests/pcc_memory.rs
@@ -0,0 +1,112 @@
+//! Tests for proof-carrying-code-based validation of memory accesses
+//! in Wasmtime/Cranelift-compiled Wasm, with various combinations of
+//! memory settings.
+
+#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
+mod pcc_memory_tests {
+    use wasmtime::*;
+
+    const TESTS: &'static [&'static str] = &[
+        r#"
+  local.get 0
+  i32.load8_u
+  drop
+    "#,
+        r#"
+  local.get 0
+  i32.load8_u offset=0x10000
+  drop
+    "#,
+        r#"
+  local.get 0
+  i32.load16_u
+  drop
+    "#,
+        r#"
+  local.get 0
+  i32.load16_u offset=0x10000
+  drop
+    "#,
+        r#"
+  local.get 0
+  i32.load
+  drop
+    "#,
+        r#"
+  local.get 0
+  i32.load offset=0x10000
+  drop
+    "#,
+        r#"
+  local.get 0
+  i64.load
+  drop
+    "#,
+        r#"
+  local.get 0
+  i64.load offset=0x10000
+  drop
+    "#,
+    ];
+
+    #[test]
+    #[cfg_attr(miri, ignore)]
+    fn test_build() {
+        let _ = env_logger::try_init();
+        const KIB: u64 = 1024;
+        const MIB: u64 = 1024 * KIB;
+        const GIB: u64 = 1024 * MIB;
+
+        let mut bodies = vec![];
+        for (mem_min, mem_max) in [(1, 1), (10, 20)] {
+            for &snippet in TESTS {
+                bodies.push(format!(
+                    "(module (memory {mem_min} {mem_max}) (func (param i32) {snippet}))"
+                ));
+            }
+            let all_snippets = TESTS
+                .iter()
+                .map(|s| s.to_owned())
+                .collect::<Vec<_>>()
+                .join("\n");
+            bodies.push(format!(
+                "(module (memory {mem_min} {mem_max}) (func (param i32) {all_snippets}))"
+            ));
+        }
+
+        for test in &bodies {
+            for static_memory_maximum_size in [4 * GIB] {
+                for guard_size in [2 * GIB] {
+                    for enable_spectre in [true /* not yet supported by PCC: false */] {
+                        for _memory_bits in [32 /* not yet supported by PCC: 64 */] {
+                            log::trace!("test:\n{}\n", test);
+                            log::trace!(
+                                "static {:x} guard {:x}",
+                                static_memory_maximum_size,
+                                guard_size
+                            );
+                            let mut cfg = Config::new();
+                            cfg.static_memory_maximum_size(static_memory_maximum_size);
+                            cfg.static_memory_guard_size(guard_size);
+                            cfg.dynamic_memory_guard_size(guard_size);
+                            cfg.cranelift_pcc(true);
+                            unsafe {
+                                cfg.cranelift_flag_set(
+                                    "enable_heap_access_spectre_mitigation",
+                                    &enable_spectre.to_string(),
+                                );
+                            }
+                            // TODO: substitute memory32/memory64 into
+                            // test module.
+
+                            let engine = Engine::new(&cfg).unwrap();
+
+                            let _module = Module::new(&engine, test)
+                                .expect("compilation with PCC should succeed");
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/tests/rlimited-memory.rs b/tests/rlimited-memory.rs
index 4a63e51f6be1..1fe77f6a521b 100644
--- a/tests/rlimited-memory.rs
+++ b/tests/rlimited-memory.rs
@@ -2,7 +2,6 @@
 // but the original author did not have a machine available to test it.
 #![cfg(target_os = "linux")]
 
-use anyhow::Result;
 use wasmtime::*;
 
 #[derive(Default)]
@@ -46,7 +45,9 @@ fn custom_limiter_detect_os_oom_failure() -> Result<()> {
 
     // Default behavior of on-demand memory allocation so that a
     // memory grow will hit Linux for a larger mmap.
-    let engine = Engine::default();
+    let mut config = Config::new();
+    config.wasm_reference_types(false);
+    let engine = Engine::new(&config)?;
     let linker = Linker::new(&engine);
     let module = Module::new(&engine, r#"(module (memory (export "m") 0))"#).unwrap();
 
@@ -59,7 +60,7 @@ fn custom_limiter_detect_os_oom_failure() -> Result<()> {
             rlim_max: process_max_memory as u64,
         };
         let res = libc::setrlimit(libc::RLIMIT_DATA, &rlimit);
-        assert_eq!(res, 0, "setrlimit failed: {}", res);
+        assert_eq!(res, 0, "setrlimit failed: {res}");
     };
 
     let context = MemoryGrowFailureDetector::default();
@@ -84,8 +85,7 @@ fn custom_limiter_detect_os_oom_failure() -> Result<()> {
         .to_string();
     assert!(
         err_msg.starts_with("failed to grow memory"),
-        "unexpected error: {}",
-        err_msg
+        "unexpected error: {err_msg}"
     );
 
     assert_eq!(store.data().current, 10 * 64 * 1024);
@@ -97,8 +97,7 @@ fn custom_limiter_detect_os_oom_failure() -> Result<()> {
     let err_msg = store.data().error.as_ref().unwrap();
     assert!(
         err_msg.starts_with("Cannot allocate memory"),
-        "unexpected error: {}",
-        err_msg
+        "unexpected error: {err_msg}"
     );
     Ok(())
 }
diff --git a/tests/spec_testsuite b/tests/spec_testsuite
index 7ef86ddeed81..ae5a66933070 160000
--- a/tests/spec_testsuite
+++ b/tests/spec_testsuite
@@ -1 +1 @@
-Subproject commit 7ef86ddeed81458f9031a49a40b3a3f99c1c6a8a
+Subproject commit ae5a66933070b705dde56c2a71bf3fbc33282864
diff --git a/tests/unload-engine.rs b/tests/unload-engine.rs
new file mode 100644
index 000000000000..c59af4f9ad31
--- /dev/null
+++ b/tests/unload-engine.rs
@@ -0,0 +1,29 @@
+//! A single-test executable which only tests `Engine::unload_process_handlers`
+//! is possible.
+//!
+//! It's not safe for this binary to contain any other tests.
+
+use wasmtime::*;
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn test_unload_engine() {
+    for _ in 0..3 {
+        std::thread::spawn(|| {
+            let engine = Engine::default();
+            {
+                let module =
+                    Module::new(&engine, r#"(module (func (export "x") unreachable))"#).unwrap();
+                let mut store = Store::new(&engine, ());
+                let instance = Instance::new(&mut store, &module, &[]).unwrap();
+                let func = instance.get_typed_func::<(), ()>(&mut store, "x").unwrap();
+                assert!(func.call(&mut store, ()).unwrap_err().is::<Trap>());
+            }
+            unsafe {
+                engine.unload_process_handlers();
+            }
+        })
+        .join()
+        .unwrap();
+    }
+}
diff --git a/tests/wasi_testsuite/wasi-common b/tests/wasi_testsuite/wasi-common
index 09517e50cc47..2fec29ea6de1 160000
--- a/tests/wasi_testsuite/wasi-common
+++ b/tests/wasi_testsuite/wasi-common
@@ -1 +1 @@
-Subproject commit 09517e50cc47179208f9c681772a6eba617fbddd
+Subproject commit 2fec29ea6de1244c124f7fe3bfe9f2946113f66e
diff --git a/tests/wast.rs b/tests/wast.rs
new file mode 100644
index 000000000000..fbac487cae86
--- /dev/null
+++ b/tests/wast.rs
@@ -0,0 +1,516 @@
+use anyhow::{bail, Context};
+use bstr::ByteSlice;
+use libtest_mimic::{Arguments, FormatSetting, Trial};
+use once_cell::sync::Lazy;
+use std::path::Path;
+use std::sync::{Condvar, Mutex};
+use wasmtime::{
+    Config, Engine, InstanceAllocationStrategy, MpkEnabled, PoolingAllocationConfig, Store,
+    Strategy,
+};
+use wasmtime_environ::Memory;
+use wasmtime_wast::{SpectestConfig, WastContext};
+
+fn main() {
+    env_logger::init();
+
+    let mut trials = Vec::new();
+    if !cfg!(miri) {
+        add_tests(&mut trials, "tests/spec_testsuite".as_ref());
+        add_tests(&mut trials, "tests/misc_testsuite".as_ref());
+    }
+
+    // There's a lot of tests so print only a `.` to keep the output a
+    // bit more terse by default.
+    let mut args = Arguments::from_args();
+    if args.format.is_none() {
+        args.format = Some(FormatSetting::Terse);
+    }
+    libtest_mimic::run(&args, trials).exit()
+}
+
+fn add_tests(trials: &mut Vec<Trial>, path: &Path) {
+    for entry in path.read_dir().unwrap() {
+        let entry = entry.unwrap();
+        let path = entry.path();
+        if entry.file_type().unwrap().is_dir() {
+            add_tests(trials, &path);
+            continue;
+        }
+
+        if path.extension().and_then(|s| s.to_str()) != Some("wast") {
+            continue;
+        }
+
+        for strategy in [Strategy::Cranelift, Strategy::Winch] {
+            for pooling in [true, false] {
+                let trial = Trial::test(
+                    format!(
+                        "{strategy:?}/{}{}",
+                        if pooling { "pooling/" } else { "" },
+                        path.to_str().unwrap()
+                    ),
+                    {
+                        let path = path.clone();
+                        move || {
+                            run_wast(&path, strategy, pooling).map_err(|e| format!("{e:?}").into())
+                        }
+                    },
+                );
+                trials.push(trial);
+            }
+        }
+    }
+}
+
+fn should_fail(test: &Path, strategy: Strategy) -> bool {
+    // Winch only supports x86_64 at this time.
+    if strategy == Strategy::Winch && !cfg!(target_arch = "x86_64") {
+        return true;
+    }
+
+    // Disable spec tests for proposals that Winch does not implement yet.
+    if strategy == Strategy::Winch {
+        let unsupported = [
+            // externref/reference-types related
+            "component-model/modules.wast",
+            "extended-const/elem.wast",
+            "extended-const/global.wast",
+            "memory64/threads.wast",
+            "misc_testsuite/externref-id-function.wast",
+            "misc_testsuite/externref-segment.wast",
+            "misc_testsuite/externref-segments.wast",
+            "misc_testsuite/externref-table-dropped-segment-issue-8281.wast",
+            "misc_testsuite/linking-errors.wast",
+            "misc_testsuite/many_table_gets_lead_to_gc.wast",
+            "misc_testsuite/mutable_externref_globals.wast",
+            "misc_testsuite/no-mixup-stack-maps.wast",
+            "misc_testsuite/no-panic.wast",
+            "misc_testsuite/simple_ref_is_null.wast",
+            "misc_testsuite/table_grow_with_funcref.wast",
+            "spec_testsuite/br_table.wast",
+            "spec_testsuite/data-invalid.wast",
+            "spec_testsuite/elem.wast",
+            "spec_testsuite/global.wast",
+            "spec_testsuite/linking.wast",
+            "spec_testsuite/ref_func.wast",
+            "spec_testsuite/ref_is_null.wast",
+            "spec_testsuite/ref_null.wast",
+            "spec_testsuite/select.wast",
+            "spec_testsuite/table-sub.wast",
+            "spec_testsuite/table_fill.wast",
+            "spec_testsuite/table_get.wast",
+            "spec_testsuite/table_grow.wast",
+            "spec_testsuite/table_set.wast",
+            "spec_testsuite/table_size.wast",
+            "spec_testsuite/unreached-invalid.wast",
+            // simd-related failures
+            "annotations/simd_lane.wast",
+            "memory64/simd.wast",
+            "misc_testsuite/int-to-float-splat.wast",
+            "misc_testsuite/issue6562.wast",
+            "misc_testsuite/simd/almost-extmul.wast",
+            "misc_testsuite/simd/canonicalize-nan.wast",
+            "misc_testsuite/simd/cvt-from-uint.wast",
+            "misc_testsuite/simd/issue4807.wast",
+            "misc_testsuite/simd/issue6725-no-egraph-panic.wast",
+            "misc_testsuite/simd/issue_3327_bnot_lowering.wast",
+            "misc_testsuite/simd/load_splat_out_of_bounds.wast",
+            "misc_testsuite/simd/replace-lane-preserve.wast",
+            "misc_testsuite/simd/spillslot-size-fuzzbug.wast",
+            "misc_testsuite/simd/unaligned-load.wast",
+            "multi-memory/simd_memory-multi.wast",
+            "spec_testsuite/simd_align.wast",
+            "spec_testsuite/simd_bit_shift.wast",
+            "spec_testsuite/simd_bitwise.wast",
+            "spec_testsuite/simd_boolean.wast",
+            "spec_testsuite/simd_const.wast",
+            "spec_testsuite/simd_conversions.wast",
+            "spec_testsuite/simd_f32x4.wast",
+            "spec_testsuite/simd_f32x4_arith.wast",
+            "spec_testsuite/simd_f32x4_cmp.wast",
+            "spec_testsuite/simd_f32x4_pmin_pmax.wast",
+            "spec_testsuite/simd_f32x4_rounding.wast",
+            "spec_testsuite/simd_f64x2.wast",
+            "spec_testsuite/simd_f64x2_arith.wast",
+            "spec_testsuite/simd_f64x2_cmp.wast",
+            "spec_testsuite/simd_f64x2_pmin_pmax.wast",
+            "spec_testsuite/simd_f64x2_rounding.wast",
+            "spec_testsuite/simd_i16x8_arith.wast",
+            "spec_testsuite/simd_i16x8_arith2.wast",
+            "spec_testsuite/simd_i16x8_cmp.wast",
+            "spec_testsuite/simd_i16x8_extadd_pairwise_i8x16.wast",
+            "spec_testsuite/simd_i16x8_extmul_i8x16.wast",
+            "spec_testsuite/simd_i16x8_q15mulr_sat_s.wast",
+            "spec_testsuite/simd_i16x8_sat_arith.wast",
+            "spec_testsuite/simd_i32x4_arith.wast",
+            "spec_testsuite/simd_i32x4_arith2.wast",
+            "spec_testsuite/simd_i32x4_cmp.wast",
+            "spec_testsuite/simd_i32x4_dot_i16x8.wast",
+            "spec_testsuite/simd_i32x4_extadd_pairwise_i16x8.wast",
+            "spec_testsuite/simd_i32x4_extmul_i16x8.wast",
+            "spec_testsuite/simd_i32x4_trunc_sat_f32x4.wast",
+            "spec_testsuite/simd_i32x4_trunc_sat_f64x2.wast",
+            "spec_testsuite/simd_i64x2_arith.wast",
+            "spec_testsuite/simd_i64x2_arith2.wast",
+            "spec_testsuite/simd_i64x2_cmp.wast",
+            "spec_testsuite/simd_i64x2_extmul_i32x4.wast",
+            "spec_testsuite/simd_i8x16_arith.wast",
+            "spec_testsuite/simd_i8x16_arith2.wast",
+            "spec_testsuite/simd_i8x16_cmp.wast",
+            "spec_testsuite/simd_i8x16_sat_arith.wast",
+            "spec_testsuite/simd_int_to_int_extend.wast",
+            "spec_testsuite/simd_lane.wast",
+            "spec_testsuite/simd_load.wast",
+            "spec_testsuite/simd_load16_lane.wast",
+            "spec_testsuite/simd_load32_lane.wast",
+            "spec_testsuite/simd_load64_lane.wast",
+            "spec_testsuite/simd_load8_lane.wast",
+            "spec_testsuite/simd_load_extend.wast",
+            "spec_testsuite/simd_load_splat.wast",
+            "spec_testsuite/simd_load_zero.wast",
+            "spec_testsuite/simd_splat.wast",
+            "spec_testsuite/simd_store16_lane.wast",
+            "spec_testsuite/simd_store32_lane.wast",
+            "spec_testsuite/simd_store64_lane.wast",
+            "spec_testsuite/simd_store8_lane.wast",
+        ];
+
+        if unsupported.iter().any(|part| test.ends_with(part)) {
+            return true;
+        }
+
+        // A few proposals that winch has no support for.
+        let unsupported_proposals = [
+            "function-references",
+            "gc",
+            "tail-call",
+            "relaxed-simd",
+            "threads",
+            // Winch technically supports memory64 but the upstream tests have
+            // gc/function-references/exceptions/etc all merged in now so Winch
+            // can no longer run those tests without panicking.
+            "memory64",
+        ];
+        if let Some(parent) = test.parent() {
+            if unsupported_proposals
+                .iter()
+                .any(|part| parent.ends_with(part))
+            {
+                return true;
+            }
+        }
+    }
+    let unsupported_gc_tests = [
+        "array_copy.wast",
+        "array_fill.wast",
+        "array_init_data.wast",
+        "array_init_elem.wast",
+        "array.wast",
+        "binary_gc.wast",
+        "br_on_cast_fail.wast",
+        "br_on_cast.wast",
+        "extern.wast",
+        "ref_cast.wast",
+        "ref_eq.wast",
+        "ref_test.wast",
+        "return_call_indirect.wast",
+        "return_call.wast",
+        "struct.wast",
+        "table_sub.wast",
+        "type_canon.wast",
+        "type_equivalence.wast",
+        "type-rec.wast",
+        "type-subtyping.wast",
+        "unreached_valid.wast",
+        "i31.wast",
+    ];
+
+    for part in test.iter() {
+        // Not implemented in Wasmtime yet
+        if part == "exception-handling" {
+            return !test.ends_with("binary.wast");
+        }
+
+        if part == "memory64" {
+            if [
+                // Wasmtime doesn't implement the table64 extension yet.
+                "call_indirect.wast",
+                "table_copy.wast",
+                "table_get.wast",
+                "table_set.wast",
+                "table_fill.wast",
+                "table.wast",
+                "table_init.wast",
+                "table_copy_mixed.wast",
+                "table_grow.wast",
+                "table_size.wast",
+                // wasmtime doesn't implement exceptions yet
+                "imports.wast",
+                "ref_null.wast",
+                "exports.wast",
+                "throw.wast",
+                "throw_ref.wast",
+                "try_table.wast",
+                "tag.wast",
+            ]
+            .iter()
+            .any(|i| test.ends_with(i))
+            {
+                return true;
+            }
+            if unsupported_gc_tests.iter().any(|i| test.ends_with(i)) {
+                return true;
+            }
+        }
+
+        // Implementation of the GC proposal is a work-in-progress, this is
+        // a list of all currently known-to-fail tests.
+        if part == "gc" {
+            return unsupported_gc_tests.iter().any(|i| test.ends_with(i));
+        }
+    }
+
+    false
+}
+
+// Each of the tests included from `wast_testsuite_tests` will call this
+// function which actually executes the `wast` test suite given the `strategy`
+// to compile it.
+fn run_wast(wast: &Path, strategy: Strategy, pooling: bool) -> anyhow::Result<()> {
+    let should_fail = should_fail(wast, strategy);
+    let wast_bytes =
+        std::fs::read(wast).with_context(|| format!("failed to read `{}`", wast.display()))?;
+
+    let wast = Path::new(wast);
+
+    let memory64 = feature_found(wast, "memory64");
+    let custom_page_sizes = feature_found(wast, "custom-page-sizes");
+    let multi_memory = feature_found(wast, "multi-memory")
+        || feature_found(wast, "component-model")
+        || custom_page_sizes
+        || memory64;
+    let threads = feature_found(wast, "threads");
+    let gc = feature_found(wast, "gc") || memory64;
+    let function_references = gc || memory64 || feature_found(wast, "function-references");
+    let reference_types = !(threads && feature_found(wast, "proposals"));
+    let relaxed_simd = feature_found(wast, "relaxed-simd");
+    let tail_call = feature_found(wast, "tail-call") || feature_found(wast, "function-references");
+    let use_shared_memory = feature_found_src(&wast_bytes, "shared_memory")
+        || feature_found_src(&wast_bytes, "shared)");
+    let extended_const = feature_found(wast, "extended-const") || memory64;
+
+    if pooling && use_shared_memory {
+        log::warn!("skipping pooling test with shared memory");
+        return Ok(());
+    }
+
+    let is_cranelift = match strategy {
+        Strategy::Cranelift => true,
+        _ => false,
+    };
+
+    let mut cfg = Config::new();
+    cfg.wasm_multi_memory(multi_memory)
+        .wasm_threads(threads)
+        .wasm_memory64(memory64)
+        .wasm_function_references(function_references)
+        .wasm_gc(gc)
+        .wasm_reference_types(reference_types)
+        .wasm_relaxed_simd(relaxed_simd)
+        .wasm_tail_call(tail_call)
+        .wasm_custom_page_sizes(custom_page_sizes)
+        .wasm_extended_const(extended_const)
+        .strategy(strategy);
+
+    if is_cranelift {
+        cfg.cranelift_debug_verifier(true);
+    }
+
+    let component_model = feature_found(wast, "component-model");
+    cfg.wasm_component_model(component_model)
+        .wasm_component_model_more_flags(component_model);
+
+    if feature_found(wast, "canonicalize-nan") && is_cranelift {
+        cfg.cranelift_nan_canonicalization(true);
+    }
+    let test_allocates_lots_of_memory = wast.ends_with("more-than-4gb.wast");
+
+    // By default we'll allocate huge chunks (6gb) of the address space for each
+    // linear memory. This is typically fine but when we emulate tests with QEMU
+    // it turns out that it causes memory usage to balloon massively. Leave a
+    // knob here so on CI we can cut down the memory usage of QEMU and avoid the
+    // OOM killer.
+    //
+    // Locally testing this out this drops QEMU's memory usage running this
+    // tests suite from 10GiB to 600MiB. Previously we saw that crossing the
+    // 10GiB threshold caused our processes to get OOM killed on CI.
+    if std::env::var("WASMTIME_TEST_NO_HOG_MEMORY").is_ok() {
+        // The pooling allocator hogs ~6TB of virtual address space for each
+        // store, so if we don't to hog memory then ignore pooling tests.
+        if pooling {
+            return Ok(());
+        }
+
+        // If the test allocates a lot of memory, that's considered "hogging"
+        // memory, so skip it.
+        if test_allocates_lots_of_memory {
+            return Ok(());
+        }
+
+        // Don't use 4gb address space reservations when not hogging memory, and
+        // also don't reserve lots of memory after dynamic memories for growth
+        // (makes growth slower).
+        if use_shared_memory {
+            cfg.static_memory_maximum_size(2 * u64::from(Memory::DEFAULT_PAGE_SIZE));
+        } else {
+            cfg.static_memory_maximum_size(0);
+        }
+        cfg.dynamic_memory_reserved_for_growth(0);
+
+        let small_guard = 64 * 1024;
+        cfg.static_memory_guard_size(small_guard);
+        cfg.dynamic_memory_guard_size(small_guard);
+    }
+
+    let _pooling_lock = if pooling {
+        // Some memory64 tests take more than 4gb of resident memory to test,
+        // but we don't want to configure the pooling allocator to allow that
+        // (that's a ton of memory to reserve), so we skip those tests.
+        if test_allocates_lots_of_memory {
+            return Ok(());
+        }
+
+        // Reduce the virtual memory required to run multi-memory-based tests.
+        //
+        // The configuration parameters below require that a bare minimum
+        // virtual address space reservation of 450*9*805*65536 == 200G be made
+        // to support each test. If 6G reservations are made for each linear
+        // memory then not that many tests can run concurrently with much else.
+        //
+        // When multiple memories are used and are configured in the pool then
+        // force the usage of static memories without guards to reduce the VM
+        // impact.
+        let max_memory_size = 805 << 16;
+        if multi_memory {
+            cfg.static_memory_maximum_size(max_memory_size as u64);
+            cfg.dynamic_memory_reserved_for_growth(0);
+            cfg.static_memory_guard_size(0);
+            cfg.dynamic_memory_guard_size(0);
+        }
+
+        // The limits here are crafted such that the wast tests should pass.
+        // However, these limits may become insufficient in the future as the
+        // wast tests change. If a wast test fails because of a limit being
+        // "exceeded" or if memory/table fails to grow, the values here will
+        // need to be adjusted.
+        let mut pool = PoolingAllocationConfig::default();
+        pool.total_memories(450 * 2)
+            .max_memory_protection_keys(2)
+            .max_memory_size(max_memory_size)
+            .max_memories_per_module(if multi_memory { 9 } else { 1 })
+            .max_tables_per_module(5);
+
+        // When testing, we may choose to start with MPK force-enabled to ensure
+        // we use that functionality.
+        if std::env::var("WASMTIME_TEST_FORCE_MPK").is_ok() {
+            pool.memory_protection_keys(MpkEnabled::Enable);
+        }
+
+        cfg.allocation_strategy(InstanceAllocationStrategy::Pooling(pool));
+        Some(lock_pooling())
+    } else {
+        None
+    };
+
+    let mut engines = vec![(Engine::new(&cfg), "default")];
+
+    // For tests that use relaxed-simd test both the default engine and the
+    // guaranteed-deterministic engine to ensure that both the 'native'
+    // semantics of the instructions plus the canonical semantics work.
+    if relaxed_simd {
+        engines.push((
+            Engine::new(cfg.relaxed_simd_deterministic(true)),
+            "deterministic",
+        ));
+    }
+
+    for (engine, desc) in engines {
+        let result = engine.and_then(|engine| {
+            let store = Store::new(&engine, ());
+            let mut wast_context = WastContext::new(store);
+            wast_context.register_spectest(&SpectestConfig {
+                use_shared_memory,
+                suppress_prints: true,
+            })?;
+            wast_context
+                .run_buffer(wast.to_str().unwrap(), &wast_bytes)
+                .with_context(|| format!("failed to run spec test with {desc} engine"))
+        });
+
+        if should_fail {
+            if result.is_ok() {
+                bail!("this test is flagged as should-fail but it succeeded")
+            }
+        } else {
+            result?;
+        }
+    }
+
+    Ok(())
+}
+
+fn feature_found(path: &Path, name: &str) -> bool {
+    path.iter().any(|part| match part.to_str() {
+        Some(s) => s.contains(name),
+        None => false,
+    })
+}
+
+fn feature_found_src(bytes: &[u8], name: &str) -> bool {
+    bytes.contains_str(name)
+}
+
+// The pooling tests make about 6TB of address space reservation which means
+// that we shouldn't let too many of them run concurrently at once. On
+// high-cpu-count systems (e.g. 80 threads) this leads to mmap failures because
+// presumably too much of the address space has been reserved with our limits
+// specified above. By keeping the number of active pooling-related tests to a
+// specified maximum we can put a cap on the virtual address space reservations
+// made.
+fn lock_pooling() -> impl Drop {
+    const MAX_CONCURRENT_POOLING: u32 = 4;
+
+    static ACTIVE: Lazy<MyState> = Lazy::new(MyState::default);
+
+    #[derive(Default)]
+    struct MyState {
+        lock: Mutex<u32>,
+        waiters: Condvar,
+    }
+
+    impl MyState {
+        fn lock(&self) -> impl Drop + '_ {
+            let state = self.lock.lock().unwrap();
+            let mut state = self
+                .waiters
+                .wait_while(state, |cnt| *cnt >= MAX_CONCURRENT_POOLING)
+                .unwrap();
+            *state += 1;
+            LockGuard { state: self }
+        }
+    }
+
+    struct LockGuard<'a> {
+        state: &'a MyState,
+    }
+
+    impl Drop for LockGuard<'_> {
+        fn drop(&mut self) {
+            *self.state.lock.lock().unwrap() -= 1;
+            self.state.waiters.notify_one();
+        }
+    }
+
+    ACTIVE.lock()
+}
diff --git a/winch/Cargo.toml b/winch/Cargo.toml
deleted file mode 100644
index d86a0b22a2a4..000000000000
--- a/winch/Cargo.toml
+++ /dev/null
@@ -1,33 +0,0 @@
-[package]
-name = "winch-tools"
-version = "0.0.0"
-description = "Binaries for testing Winch"
-license = "Apache-2.0 WITH LLVM-exception"
-repository = "https://github.com/bytecodealliance/wasmtime"
-publish = false
-edition.workspace = true
-
-[[bin]]
-name = "winch-tools"
-path = "src/main.rs"
-
-[dependencies]
-winch-codegen = { workspace = true }
-winch-filetests = { workspace = true }
-winch-test-macros = { workspace = true }
-wasmtime-environ = { workspace = true }
-target-lexicon = { workspace = true }
-anyhow = { workspace = true }
-wasmparser = { workspace = true }
-clap = { workspace = true }
-wat = { workspace = true }
-cranelift-codegen = { workspace = true }
-capstone = { workspace = true }
-similar = { workspace = true }
-toml = { workspace = true }
-serde = { workspace = true }
-glob = { workspace = true }
-
-[features]
-default = ["all-arch"]
-all-arch = ["winch-codegen/all-arch"]
diff --git a/winch/codegen/Cargo.toml b/winch/codegen/Cargo.toml
index 63f186fe71d7..b5f0f2709f77 100644
--- a/winch/codegen/Cargo.toml
+++ b/winch/codegen/Cargo.toml
@@ -4,8 +4,12 @@ name = "winch-codegen"
 description = "Winch code generation library"
 license = "Apache-2.0 WITH LLVM-exception"
 repository = "https://github.com/bytecodealliance/wasmtime"
-version = "0.12.0"
+version = "0.23.0"
 edition.workspace = true
+rust-version.workspace = true
+
+[lints]
+workspace = true
 
 [dependencies]
 wasmparser = { workspace = true }
@@ -16,10 +20,11 @@ target-lexicon = { workspace = true, features = ["std"] }
 # mostly to have access to `PReg`s and the calling convention.
 # In the next iteration we'll factor out the common bits so that they can be consumed
 # by Cranelift and Winch.
-cranelift-codegen = { workspace = true }
+cranelift-codegen = { workspace = true, features = ["unwind"] }
 regalloc2 = { workspace = true }
 gimli = { workspace = true }
 wasmtime-environ = { workspace = true }
+wasmtime-cranelift = { workspace = true }
 
 [features]
 x64 = ["cranelift-codegen/x86"]
diff --git a/winch/codegen/src/abi/local.rs b/winch/codegen/src/abi/local.rs
index d0aaa347ce8b..dcca52d69860 100644
--- a/winch/codegen/src/abi/local.rs
+++ b/winch/codegen/src/abi/local.rs
@@ -1,11 +1,11 @@
-use wasmtime_environ::WasmType;
+use wasmtime_environ::WasmValType;
 
 /// Base register used to address the local slot.
 ///
 /// Slots for stack arguments are addressed from the frame pointer.
 /// Slots for function-defined locals and for registers are addressed
 /// from the stack pointer.
-#[derive(Clone, Eq, PartialEq)]
+#[derive(Clone, Eq, PartialEq, Copy, Debug)]
 enum Base {
     FP,
     SP,
@@ -15,12 +15,24 @@ enum Base {
 ///
 /// Represents the type, location and addressing mode of a local
 /// in the stack's local and argument area.
-#[derive(Clone)]
+/// LocalSlots are well known slots in the machine stack, and are generally
+/// reference by the stack pointer register (SP) or the base pointer register (FP).
+/// * Local slots that are referenced by the stack pointer register are the
+///   function defined locals and the param locals.
+/// * Local slots that represent arguments in the stack, are referenced through the
+///   base pointer register.
+///
+/// A [crate::masm::StackSlot] is a generalized form of a [LocalSlot]: they
+/// represent dynamic chunks of memory that get created throughout the function
+/// compilation lifetime when spilling values (register and locals) into the
+/// machine stack. A [LocalSlot] on the other hand gets created at the beginning
+/// of a function compilation and gets cleaned up at the end.
+#[derive(Clone, Copy, Debug)]
 pub(crate) struct LocalSlot {
     /// The offset of the local slot.
     pub offset: u32,
     /// The type contained by this local slot.
-    pub ty: WasmType,
+    pub ty: WasmValType,
     /// Base register associated to this local slot.
     base: Base,
 }
@@ -28,7 +40,7 @@ pub(crate) struct LocalSlot {
 impl LocalSlot {
     /// Creates a local slot for a function defined local or
     /// for a spilled argument register.
-    pub fn new(ty: WasmType, offset: u32) -> Self {
+    pub fn new(ty: WasmValType, offset: u32) -> Self {
         Self {
             ty,
             offset,
@@ -39,7 +51,7 @@ impl LocalSlot {
     /// Int32 shortcut for `new`.
     pub fn i32(offset: u32) -> Self {
         Self {
-            ty: WasmType::I32,
+            ty: WasmValType::I32,
             offset,
             base: Base::SP,
         }
@@ -48,14 +60,14 @@ impl LocalSlot {
     /// Int64 shortcut for `new`.
     pub fn i64(offset: u32) -> Self {
         Self {
-            ty: WasmType::I64,
+            ty: WasmValType::I64,
             offset,
             base: Base::SP,
         }
     }
 
     /// Creates a local slot for a stack function argument.
-    pub fn stack_arg(ty: WasmType, offset: u32) -> Self {
+    pub fn stack_arg(ty: WasmValType, offset: u32) -> Self {
         Self {
             ty,
             offset,
diff --git a/winch/codegen/src/abi/mod.rs b/winch/codegen/src/abi/mod.rs
index 5362a81cfc78..e615a473801b 100644
--- a/winch/codegen/src/abi/mod.rs
+++ b/winch/codegen/src/abi/mod.rs
@@ -1,21 +1,23 @@
-//! This module provides all the necessary building blocks for
-//! implementing ISA specific ABIs.
 //!
-//! # Default ABI
+//! The Default ABI
 //!
-//! Winch uses a default internal ABI, for all internal functions.
-//! This allows us to push the complexity of system ABI compliance to
-//! the trampolines (not yet implemented).  The default ABI treats all
-//! allocatable registers as caller saved, which means that (i) all
-//! register values in the Wasm value stack (which are normally
-//! referred to as "live"), must be saved onto the machine stack (ii)
-//! function prologues and epilogues don't store/restore other
-//! registers more than the non-allocatable ones (e.g. rsp/rbp in
-//! x86_64).
+//! Winch uses a default ABI, for all internal functions. This allows
+//! us to push the complexity of system ABI compliance to the trampolines.  The
+//! default ABI treats all allocatable registers as caller saved, which means
+//! that (i) all register values in the Wasm value stack (which are normally
+//! referred to as "live"), must be saved onto the machine stack (ii) function
+//! prologues and epilogues don't store/restore other registers more than the
+//! non-allocatable ones (e.g. rsp/rbp in x86_64).
+//!
+//! The calling convention in the default ABI, uses registers to a certain fixed
+//! count for arguments and return values, and then the stack is used for all
+//! additional arguments and return values. Aside from the parameters declared
+//! in each WebAssembly function, Winch's ABI declares two extra parameters, to
+//! hold the callee and caller `VMContext` pointers. A well-known `LocalSlot` is
+//! reserved for the callee VMContext pointer and also a particular pinned
+//! register is used to hold the value of the callee `VMContext`, which is
+//! available throughout the lifetime of the function.
 //!
-//! The calling convention in the default ABI, uses registers to a
-//! certain fixed count for arguments and return values, and then the
-//! stack is used for all additional arguments.
 //!
 //! Generally the stack layout looks like:
 //! +-------------------------------+
@@ -30,10 +32,10 @@
 //! |            SP                 |
 //! +-------------------------------+----> SP @ Function prologue
 //! |                               |
+//! +-------------------------------+----> VMContext slot
 //! |                               |
 //! |                               |
 //! |        Stack slots            |
-//! |        + `VMContext` slot     |
 //! |        + dynamic space        |
 //! |                               |
 //! |                               |
@@ -43,15 +45,61 @@
 //! |        + arguments            |
 //! |                               | ----> Space allocated for calls
 //! |                               |
+use crate::codegen::ptr_type_from_ptr_size;
 use crate::isa::{reg::Reg, CallingConvention};
-use crate::masm::OperandSize;
+use crate::masm::SPOffset;
 use smallvec::SmallVec;
+use std::collections::HashSet;
 use std::ops::{Add, BitAnd, Not, Sub};
-use wasmtime_environ::{WasmFuncType, WasmType};
+use wasmtime_environ::{WasmFuncType, WasmValType};
 
 pub(crate) mod local;
 pub(crate) use local::*;
 
+/// Internal classification for params or returns,
+/// mainly used for params and return register assignment.
+#[derive(Clone, Copy, Eq, PartialEq, Debug)]
+pub(super) enum ParamsOrReturns {
+    Params,
+    Returns,
+}
+
+/// Macro to get the pinned register holding the [VMContext].
+macro_rules! vmctx {
+    ($m:ident) => {
+        <$m::ABI as $crate::abi::ABI>::vmctx_reg()
+    };
+}
+
+/// Macro to get the designated general purpose scratch register or the
+/// designated scratch register for the given type.
+macro_rules! scratch {
+    ($m:ident) => {
+        <$m::ABI as $crate::abi::ABI>::scratch_for(&wasmtime_environ::WasmValType::I64)
+    };
+    ($m:ident, $wasm_type:expr) => {
+        <$m::ABI as $crate::abi::ABI>::scratch_for($wasm_type)
+    };
+}
+
+pub(crate) use scratch;
+pub(crate) use vmctx;
+
+/// Constructs an [ABISig] using Winch's ABI.
+pub(crate) fn wasm_sig<A: ABI>(ty: &WasmFuncType) -> ABISig {
+    // 6 is used semi-arbitrarily here, we can modify as we see fit.
+    let mut params: SmallVec<[WasmValType; 6]> = SmallVec::new();
+    params.extend_from_slice(&vmctx_types::<A>());
+    params.extend_from_slice(ty.params());
+
+    A::sig_from(&params, ty.returns(), &CallingConvention::Default)
+}
+
+/// Returns the callee and caller [VMContext] types.
+pub(crate) fn vmctx_types<A: ABI>() -> [WasmValType; 2] {
+    [A::ptr_type(), A::ptr_type()]
+}
+
 /// Trait implemented by a specific ISA and used to provide
 /// information about alignment, parameter passing, usage of
 /// specific registers, etc.
@@ -65,209 +113,533 @@ pub(crate) trait ABI {
     /// The offset to the argument base, relative to the frame pointer.
     fn arg_base_offset() -> u8;
 
-    /// The offset to the return address, relative to the frame pointer.
-    fn ret_addr_offset() -> u8;
-
     /// Construct the ABI-specific signature from a WebAssembly
     /// function type.
-    fn sig(wasm_sig: &WasmFuncType, call_conv: &CallingConvention) -> ABISig;
+    #[cfg(test)]
+    fn sig(wasm_sig: &WasmFuncType, call_conv: &CallingConvention) -> ABISig {
+        Self::sig_from(wasm_sig.params(), wasm_sig.returns(), call_conv)
+    }
 
     /// Construct an ABI signature from WasmType params and returns.
-    fn sig_from(params: &[WasmType], returns: &[WasmType], call_conv: &CallingConvention)
-        -> ABISig;
+    fn sig_from(
+        params: &[WasmValType],
+        returns: &[WasmValType],
+        call_conv: &CallingConvention,
+    ) -> ABISig;
 
-    /// Construct the ABI-specific result from a slice of
-    /// [`wasmtime_environ::WasmtType`].
-    fn result(returns: &[WasmType], call_conv: &CallingConvention) -> ABIResult;
+    /// Construct [`ABIResults`] from a slice of [`WasmType`].
+    fn abi_results(returns: &[WasmValType], call_conv: &CallingConvention) -> ABIResults;
 
     /// Returns the number of bits in a word.
-    fn word_bits() -> u32;
+    fn word_bits() -> u8;
 
     /// Returns the number of bytes in a word.
-    fn word_bytes() -> u32 {
+    fn word_bytes() -> u8 {
         Self::word_bits() / 8
     }
 
-    /// Returns the designated scratch register.
-    fn scratch_reg() -> Reg;
-
-    /// Returns the frame pointer register.
-    fn fp_reg() -> Reg;
-
-    /// Returns the stack pointer register.
-    fn sp_reg() -> Reg;
+    /// Returns the designated scratch register for the given [WasmType].
+    fn scratch_for(ty: &WasmValType) -> Reg;
 
     /// Returns the pinned register used to hold
     /// the `VMContext`.
     fn vmctx_reg() -> Reg;
 
-    /// Returns the callee-saved registers for the given
-    /// calling convention.
-    fn callee_saved_regs(call_conv: &CallingConvention) -> SmallVec<[(Reg, OperandSize); 18]>;
+    /// The size, in bytes, of each stack slot used for stack parameter passing.
+    fn stack_slot_size() -> u8;
+
+    /// Returns the size in bytes of the given [`WasmType`].
+    fn sizeof(ty: &WasmValType) -> u8;
 
-    /// Returns the size of each argument stack slot per argument type.
-    fn stack_arg_slot_size_for_type(ty: WasmType) -> u32;
+    /// The target pointer size represented as [WasmValType].
+    fn ptr_type() -> WasmValType {
+        // Defaulting to 64, since we currently only support 64-bit
+        // architectures.
+        WasmValType::I64
+    }
 }
 
-/// ABI-specific representation of a function argument.
-#[derive(Debug)]
-pub enum ABIArg {
-    /// A register argument.
+/// ABI-specific representation of function argument or result.
+#[derive(Clone, Debug)]
+pub enum ABIOperand {
+    /// A register [`ABIOperand`].
     Reg {
-        /// Type of the argument.
-        ty: WasmType,
-        /// Register holding the argument.
+        /// The type of the [`ABIOperand`].
+        ty: WasmValType,
+        /// Register holding the [`ABIOperand`].
         reg: Reg,
+        /// The size of the [`ABIOperand`], in bytes.
+        size: u32,
     },
-    /// A stack argument.
+    /// A stack [`ABIOperand`].
     Stack {
-        /// The type of the argument.
-        ty: WasmType,
-        /// Offset of the argument relative to the frame pointer.
+        /// The type of the [`ABIOperand`].
+        ty: WasmValType,
+        /// Offset of the operand referenced through FP by the callee and
+        /// through SP by the caller.
         offset: u32,
+        /// The size of the [`ABIOperand`], in bytes.
+        size: u32,
     },
 }
 
-impl ABIArg {
-    /// Allocate a new register abi arg.
-    pub fn reg(reg: Reg, ty: WasmType) -> Self {
-        Self::Reg { reg, ty }
+impl ABIOperand {
+    /// Allocate a new register [`ABIOperand`].
+    pub fn reg(reg: Reg, ty: WasmValType, size: u32) -> Self {
+        Self::Reg { reg, ty, size }
     }
 
-    /// Allocate a new stack abi arg.
-    pub fn stack_offset(offset: u32, ty: WasmType) -> Self {
-        Self::Stack { ty, offset }
+    /// Allocate a new stack [`ABIOperand`].
+    pub fn stack_offset(offset: u32, ty: WasmValType, size: u32) -> Self {
+        Self::Stack { ty, offset, size }
     }
 
-    /// Is this abi arg in a register.
+    /// Is this [`ABIOperand`] in a register.
     pub fn is_reg(&self) -> bool {
         match *self {
-            ABIArg::Reg { .. } => true,
+            ABIOperand::Reg { .. } => true,
             _ => false,
         }
     }
 
-    /// Get the register associated to this arg.
+    /// Unwraps the underlying register if it is one.
+    ///
+    /// # Panics
+    /// This function panics if the [`ABIOperand`] is not a register.
+    pub fn unwrap_reg(&self) -> Reg {
+        match self {
+            ABIOperand::Reg { reg, .. } => *reg,
+            _ => unreachable!(),
+        }
+    }
+
+    /// Get the register associated to this [`ABIOperand`].
     pub fn get_reg(&self) -> Option<Reg> {
         match *self {
-            ABIArg::Reg { reg, .. } => Some(reg),
+            ABIOperand::Reg { reg, .. } => Some(reg),
             _ => None,
         }
     }
 
-    /// Get the type associated to this arg.
-    pub fn ty(&self) -> WasmType {
+    /// Get the type associated to this [`ABIOperand`].
+    pub fn ty(&self) -> WasmValType {
         match *self {
-            ABIArg::Reg { ty, .. } | ABIArg::Stack { ty, .. } => ty,
+            ABIOperand::Reg { ty, .. } | ABIOperand::Stack { ty, .. } => ty,
         }
     }
 }
 
-/// ABI-specific representation of the function result.
-#[derive(Copy, Clone, Debug)]
-pub(crate) enum ABIResult {
-    Void,
-    Reg {
-        /// Type of the result.
-        ty: WasmType,
-        /// Register to hold the result.
-        reg: Reg,
-    },
+/// Information about the [`ABIOperand`] information used in [`ABISig`].
+#[derive(Clone, Debug)]
+pub(crate) struct ABIOperands {
+    /// All the operands.
+    pub inner: SmallVec<[ABIOperand; 6]>,
+    /// All the registers used as operands.
+    pub regs: HashSet<Reg>,
+    /// Stack bytes used by the operands.
+    pub bytes: u32,
 }
 
-impl Default for ABIResult {
+impl Default for ABIOperands {
     fn default() -> Self {
-        Self::Void
+        Self {
+            inner: Default::default(),
+            regs: HashSet::with_capacity(0),
+            bytes: 0,
+        }
+    }
+}
+
+/// Machine stack location of the stack results.
+#[derive(Debug, Copy, Clone)]
+pub(crate) enum RetArea {
+    /// Addressed from the stack pointer at the given offset.
+    SP(SPOffset),
+    /// The address of the results base is stored at a particular,
+    /// well known [LocalSlot].
+    Slot(LocalSlot),
+    /// The return area cannot be fully resolved ahead-of-time.
+    /// If there are results on the stack, this is the default state to which
+    /// all return areas get initialized to until they can be fully resolved to
+    /// either a [RetArea::SP] or [RetArea::Slot].
+    ///
+    /// This allows a more explicit differentiation between the existence of
+    /// a return area versus no return area at all.
+    Uninit,
+}
+
+impl Default for RetArea {
+    fn default() -> Self {
+        Self::Uninit
     }
 }
 
-impl ABIResult {
-    /// Create a register ABI result.
-    pub fn reg(ty: WasmType, reg: Reg) -> Self {
-        Self::Reg { ty, reg }
+impl RetArea {
+    /// Create a [RetArea] addressed from SP at the given offset.
+    pub fn sp(offs: SPOffset) -> Self {
+        Self::SP(offs)
     }
 
-    /// Createa void ABI result.
-    pub fn void() -> Self {
-        Self::Void
+    /// Create a [RetArea] addressed stored at the given [LocalSlot].
+    pub fn slot(local: LocalSlot) -> Self {
+        Self::Slot(local)
     }
 
-    /// Get the result reg.
-    pub fn result_reg(&self) -> Option<Reg> {
+    /// Returns the [SPOffset] used as the base of the return area.
+    ///
+    /// # Panics
+    /// This function panics if the return area doesn't hold a [SPOffset].
+    pub fn unwrap_sp(&self) -> SPOffset {
         match self {
-            Self::Reg { reg, .. } => Some(*reg),
-            _ => None,
+            Self::SP(offs) => *offs,
+            _ => unreachable!(),
         }
     }
 
-    /// Checks if the result is void.
-    pub fn is_void(&self) -> bool {
+    /// Returns true if the return area is addressed via the stack pointer.
+    pub fn is_sp(&self) -> bool {
         match self {
-            Self::Void => true,
+            Self::SP(_) => true,
             _ => false,
         }
     }
 
+    /// Returns true if the return area is uninitialized.
+    pub fn is_uninit(&self) -> bool {
+        match self {
+            Self::Uninit => true,
+            _ => false,
+        }
+    }
+}
+
+/// ABI-specific representation of an [`ABISig`].
+#[derive(Clone, Debug, Default)]
+pub(crate) struct ABIResults {
+    /// The result operands.
+    operands: ABIOperands,
+    /// The return area, if there are results on the stack.
+    ret_area: Option<RetArea>,
+}
+
+impl ABIResults {
+    /// Creates [`ABIResults`] from a slice of `WasmType`.
+    /// This function maps the given return types to their ABI specific
+    /// representation. It does so, by iterating over them and applying the
+    /// given `map` closure. The map closure takes a [WasmValType], maps its ABI
+    /// representation, according to the calling convention. In the case of
+    /// results, one result is stored in registers and the rest at particular
+    /// offsets in the stack.
+    pub fn from<F>(returns: &[WasmValType], call_conv: &CallingConvention, mut map: F) -> Self
+    where
+        F: FnMut(&WasmValType, u32) -> (ABIOperand, u32),
+    {
+        if returns.len() == 0 {
+            return Self::default();
+        }
+
+        type FoldTuple = (SmallVec<[ABIOperand; 6]>, HashSet<Reg>, u32);
+
+        let fold_impl = |(mut operands, mut regs, stack_bytes): FoldTuple, arg| {
+            let (operand, bytes) = map(arg, stack_bytes);
+            if operand.is_reg() {
+                regs.insert(operand.unwrap_reg());
+            }
+            operands.push(operand);
+            (operands, regs, bytes)
+        };
+
+        // When dealing with multiple results, Winch's calling convention stores the
+        // last return value in a register rather than the first one. In that
+        // sense, Winch's return values in the ABI signature are "reversed" in
+        // terms of storage. This technique is particularly helpful to ensure that
+        // the following invariants are maintained:
+        // * Spilled memory values always precede register values
+        // * Spilled values are stored from oldest to newest, matching their
+        //   respective locations on the machine stack.
+        let (mut operands, regs, bytes): FoldTuple = if call_conv.is_default() {
+            returns
+                .iter()
+                .rev()
+                .fold((SmallVec::new(), HashSet::with_capacity(1), 0), fold_impl)
+        } else {
+            returns
+                .iter()
+                .fold((SmallVec::new(), HashSet::with_capacity(1), 0), fold_impl)
+        };
+
+        // Similar to above, we reverse the result of the operands calculation
+        // to ensure that they match the declared order.
+        if call_conv.is_default() {
+            operands.reverse();
+        }
+
+        Self::new(ABIOperands {
+            inner: operands,
+            regs,
+            bytes,
+        })
+    }
+
+    /// Create a new [`ABIResults`] from [`ABIOperands`].
+    pub fn new(operands: ABIOperands) -> Self {
+        let ret_area = (operands.bytes > 0).then(|| RetArea::default());
+        Self { operands, ret_area }
+    }
+
+    /// Returns a reference to a [HashSet<Reg>], which includes
+    /// all the registers used to hold function results.
+    pub fn regs(&self) -> &HashSet<Reg> {
+        &self.operands.regs
+    }
+
+    /// Get a slice over all the result [`ABIOperand`]s.
+    pub fn operands(&self) -> &[ABIOperand] {
+        &self.operands.inner
+    }
+
     /// Returns the length of the result.
     pub fn len(&self) -> usize {
-        if self.is_void() {
-            0
+        self.operands.inner.len()
+    }
+
+    /// Returns the length of results on the stack.
+    pub fn stack_operands_len(&self) -> usize {
+        self.operands().len() - self.regs().len()
+    }
+
+    /// Get the [`ABIOperand`] result in the nth position.
+    #[cfg(test)]
+    pub fn get(&self, n: usize) -> Option<&ABIOperand> {
+        self.operands.inner.get(n)
+    }
+
+    /// Returns the first [`ABIOperand`].
+    /// Useful in situations where the function signature is known to
+    /// have a single return.
+    ///
+    /// # Panics
+    /// This function panics if the function signature contains more
+    pub fn unwrap_singleton(&self) -> &ABIOperand {
+        debug_assert_eq!(self.len(), 1);
+        &self.operands.inner[0]
+    }
+
+    /// Returns the size, in bytes of all the [`ABIOperand`]s in the stack.
+    pub fn size(&self) -> u32 {
+        self.operands.bytes
+    }
+
+    /// Returns true if the [`ABIResults`] require space on the machine stack
+    /// for results.
+    pub fn on_stack(&self) -> bool {
+        self.operands.bytes > 0
+    }
+
+    /// Set the return area of the signature.
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if trying to set a return area if there are
+    /// no results on the stack or if trying to set an uninitialize return area.
+    /// This method must only be used when the return area can be fully
+    /// materialized.
+    pub fn set_ret_area(&mut self, area: RetArea) {
+        debug_assert!(self.on_stack());
+        debug_assert!(!area.is_uninit());
+        self.ret_area = Some(area);
+    }
+
+    /// Returns a reference to the return area, if any.
+    pub fn ret_area(&self) -> Option<&RetArea> {
+        self.ret_area.as_ref()
+    }
+}
+
+/// ABI-specific representation of an [`ABISig`].
+#[derive(Debug, Clone, Default)]
+pub(crate) struct ABIParams {
+    /// The param operands.
+    operands: ABIOperands,
+    /// Whether [`ABIParams`] contains an extra parameter for the stack
+    /// result area.
+    has_retptr: bool,
+}
+
+impl ABIParams {
+    /// Creates [`ABIParams`] from a slice of `WasmType`.
+    /// This function maps the given param types to their ABI specific
+    /// representation. It does so, by iterating over them and applying the
+    /// given `map` closure. The map closure takes a [WasmType], maps its ABI
+    /// representation, according to the calling convention. In the case of
+    /// params, multiple params may be passed in registers and the rest on the
+    /// stack depending on the calling convention.
+    pub fn from<F, A: ABI>(
+        params: &[WasmValType],
+        initial_bytes: u32,
+        needs_stack_results: bool,
+        mut map: F,
+    ) -> Self
+    where
+        F: FnMut(&WasmValType, u32) -> (ABIOperand, u32),
+    {
+        if params.len() == 0 && !needs_stack_results {
+            return Self::with_bytes(initial_bytes);
+        }
+
+        let register_capacity = params.len().min(6);
+        let (mut operands, mut regs, mut stack_bytes): (
+            SmallVec<[ABIOperand; 6]>,
+            HashSet<Reg>,
+            u32,
+        ) = params.iter().fold(
+            (
+                SmallVec::new(),
+                HashSet::with_capacity(register_capacity),
+                initial_bytes,
+            ),
+            |(mut operands, mut regs, stack_bytes), arg| {
+                let (operand, bytes) = map(arg, stack_bytes);
+                if operand.is_reg() {
+                    regs.insert(operand.unwrap_reg());
+                }
+                operands.push(operand);
+                (operands, regs, bytes)
+            },
+        );
+
+        let ptr_type = ptr_type_from_ptr_size(<A as ABI>::word_bytes());
+        // Handle stack results by specifying an extra, implicit last argument.
+        if needs_stack_results {
+            let (operand, bytes) = map(&ptr_type, stack_bytes);
+            if operand.is_reg() {
+                regs.insert(operand.unwrap_reg());
+            }
+            operands.push(operand);
+            stack_bytes = bytes;
+        }
+
+        Self {
+            operands: ABIOperands {
+                inner: operands,
+                regs,
+                bytes: stack_bytes,
+            },
+            has_retptr: needs_stack_results,
+        }
+    }
+
+    /// Creates new [`ABIParams`], with the specified amount of stack bytes.
+    pub fn with_bytes(bytes: u32) -> Self {
+        let mut params = Self::default();
+        params.operands.bytes = bytes;
+        params
+    }
+
+    /// Get the [`ABIOperand`] param in the nth position.
+    #[allow(unused)]
+    pub fn get(&self, n: usize) -> Option<&ABIOperand> {
+        self.operands.inner.get(n)
+    }
+
+    /// Get a slice over all the parameter [`ABIOperand`]s.
+    pub fn operands(&self) -> &[ABIOperand] {
+        &self.operands.inner
+    }
+
+    /// Returns the length of the params, including the return pointer,
+    /// if any.
+    pub fn len(&self) -> usize {
+        self.operands.inner.len()
+    }
+
+    /// Returns the length of the params, excluding the return pointer,
+    /// if any.
+    pub fn len_without_retptr(&self) -> usize {
+        if self.has_retptr {
+            self.len() - 1
         } else {
-            1
+            self.len()
         }
     }
 
-    /// Returns an iterator over the result registers.
+    /// Returns true if the [ABISig] has an extra parameter for stack results.
+    pub fn has_retptr(&self) -> bool {
+        self.has_retptr
+    }
+
+    /// Returns the last [ABIOperand] used as the pointer to the
+    /// stack results area.
     ///
-    /// NOTE: Currently only one or zero registers
-    /// will be returned until suport for multi-value is introduced.
-    pub fn regs(&self) -> impl Iterator<Item = Reg> + '_ {
-        std::iter::once(self.result_reg()).filter_map(|v| v)
+    /// # Panics
+    /// This function panics if the [ABIParams] doesn't have a stack results
+    /// parameter.
+    pub fn unwrap_results_area_operand(&self) -> &ABIOperand {
+        debug_assert!(self.has_retptr);
+        self.operands.inner.last().unwrap()
     }
 }
 
-pub(crate) type ABIParams = SmallVec<[ABIArg; 6]>;
-
 /// An ABI-specific representation of a function signature.
-#[derive(Debug)]
+#[derive(Debug, Clone, Default)]
 pub(crate) struct ABISig {
     /// Function parameters.
     pub params: ABIParams,
     /// Function result.
-    pub result: ABIResult,
-    /// Stack space needed for stack arguments.
-    pub stack_bytes: u32,
+    pub results: ABIResults,
+    /// A unique set of registers used in the entire [`ABISig`].
+    pub regs: HashSet<Reg>,
 }
 
 impl ABISig {
     /// Create a new ABI signature.
-    pub fn new(params: ABIParams, result: ABIResult, stack_bytes: u32) -> Self {
+    pub fn new(params: ABIParams, results: ABIResults) -> Self {
+        let regs = params
+            .operands
+            .regs
+            .union(&results.operands.regs)
+            .copied()
+            .collect();
         Self {
             params,
-            result,
-            stack_bytes,
+            results,
+            regs,
         }
     }
 
-    /// Returns an iterator over all the registers used as params.
-    pub fn param_regs(&self) -> impl Iterator<Item = Reg> + '_ {
-        self.params.iter().filter_map(|r| r.get_reg())
+    /// Returns an iterator over all the parameter operands.
+    pub fn params(&self) -> &[ABIOperand] {
+        self.params.operands()
     }
 
-    /// Returns an iterator over all the registers used in the signature.
-    pub fn regs(&self) -> impl Iterator<Item = Reg> + '_ {
-        let params_iter = self.param_regs();
-        let result_iter = self.result.regs();
-        params_iter.chain(result_iter)
+    /// Returns an iterator over all the result operands.
+    pub fn results(&self) -> &[ABIOperand] {
+        self.results.operands()
+    }
+
+    /// Returns a slice over the signature params, excluding the results
+    /// base parameter, if any.
+    pub fn params_without_retptr(&self) -> &[ABIOperand] {
+        if self.params.has_retptr() {
+            &self.params()[0..(self.params.len() - 1)]
+        } else {
+            self.params()
+        }
+    }
+
+    /// Returns the stack size, in bytes, needed for arguments on the stack.
+    pub fn params_stack_size(&self) -> u32 {
+        self.params.operands.bytes
+    }
+
+    /// Returns the stack size, in bytes, needed for results on the stack.
+    pub fn results_stack_size(&self) -> u32 {
+        self.results.operands.bytes
     }
-}
 
-/// Returns the size in bytes of a given WebAssembly type.
-pub(crate) fn ty_size(ty: &WasmType) -> u32 {
-    match *ty {
-        WasmType::I32 | WasmType::F32 => 4,
-        WasmType::I64 | WasmType::F64 => 8,
-        _ => panic!(),
+    /// Returns true if the signature has results on the stack.
+    pub fn has_stack_results(&self) -> bool {
+        self.results.on_stack()
     }
 }
 
diff --git a/winch/codegen/src/codegen/bounds.rs b/winch/codegen/src/codegen/bounds.rs
new file mode 100644
index 000000000000..5d5bf1ac15b2
--- /dev/null
+++ b/winch/codegen/src/codegen/bounds.rs
@@ -0,0 +1,220 @@
+//! Exposes heap bounds checks functionality for WebAssembly.
+//! Bounds checks in WebAssembly are critical for safety, so extreme caution is
+//! recommended when working on this area of Winch.
+use super::env::{HeapData, HeapStyle};
+use crate::{
+    abi::{scratch, vmctx},
+    codegen::CodeGenContext,
+    isa::reg::Reg,
+    masm::{IntCmpKind, MacroAssembler, OperandSize, RegImm, TrapCode},
+    stack::TypedReg,
+};
+
+/// A newtype to represent an immediate offset argument for a heap access.
+#[derive(Debug, Copy, Clone)]
+pub(crate) struct ImmOffset(u32);
+
+impl ImmOffset {
+    /// Construct an [ImmOffset] from a u32.
+    pub fn from_u32(raw: u32) -> Self {
+        Self(raw)
+    }
+
+    /// Return the underlying u32 value.
+    pub fn as_u32(&self) -> u32 {
+        self.0
+    }
+}
+
+/// An enum to represent the heap bounds.
+#[derive(Debug, Copy, Clone)]
+pub(crate) enum Bounds {
+    /// Static, known ahead-of-time.
+    Static(u64),
+    /// Dynamic. Loaded at runtime.
+    Dynamic(TypedReg),
+}
+
+impl Bounds {
+    /// Construct a [Bounds] from a [TypedReg].
+    pub fn from_typed_reg(tr: TypedReg) -> Self {
+        Self::Dynamic(tr)
+    }
+
+    /// Construct a [Bounds] from a u64.
+    pub fn from_u64(raw: u64) -> Self {
+        Self::Static(raw)
+    }
+
+    /// Return the underlying [TypedReg] value.
+    pub fn as_typed_reg(&self) -> TypedReg {
+        match self {
+            Self::Dynamic(tr) => *tr,
+            _ => panic!(),
+        }
+    }
+
+    /// Return the underlying u64 value.
+    pub fn as_u64(&self) -> u64 {
+        match self {
+            Self::Static(v) => *v,
+            _ => panic!(),
+        }
+    }
+}
+
+/// A newtype to represent a heap access index via a [TypedReg].
+#[derive(Debug, Copy, Clone)]
+pub(crate) struct Index(TypedReg);
+
+impl Index {
+    /// Construct an [Index] from a [TypedReg].
+    pub fn from_typed_reg(tr: TypedReg) -> Self {
+        Self(tr)
+    }
+
+    /// Return the underlying
+    pub fn as_typed_reg(&self) -> TypedReg {
+        self.0
+    }
+}
+
+/// Loads the bounds of the dynamic heap.
+pub(crate) fn load_dynamic_heap_bounds<M>(
+    context: &mut CodeGenContext,
+    masm: &mut M,
+    heap: &HeapData,
+    ptr_size: OperandSize,
+) -> Bounds
+where
+    M: MacroAssembler,
+{
+    let dst = context.any_gpr(masm);
+    match (heap.max_size, &heap.style) {
+        // Constant size, no need to perform a load.
+        (Some(max_size), HeapStyle::Dynamic) if heap.min_size == max_size => {
+            masm.mov(RegImm::i64(max_size as i64), dst, ptr_size)
+        }
+        (_, HeapStyle::Dynamic) => {
+            let scratch = scratch!(M);
+            let base = if let Some(offset) = heap.import_from {
+                let addr = masm.address_at_vmctx(offset);
+                masm.load_ptr(addr, scratch);
+                scratch
+            } else {
+                vmctx!(M)
+            };
+            let addr = masm.address_at_reg(base, heap.current_length_offset);
+            masm.load_ptr(addr, dst);
+        }
+        (_, HeapStyle::Static { .. }) => unreachable!("Loading dynamic bounds of a static heap"),
+    }
+
+    Bounds::from_typed_reg(TypedReg::new(heap.ty, dst))
+}
+
+/// This function ensures the following:
+/// * The immediate offset and memory access size fit in a single u64. Given:
+///   that the memory access size is a `u8`, we must guarantee that the immediate
+///   offset will fit in a `u32`, making the result of their addition fit in a u64
+///   and overflow safe.
+/// * Adjust the base index to account for the immediate offset via an unsigned
+///   addition and check for overflow in case the previous condition is not met.
+#[inline]
+pub(crate) fn ensure_index_and_offset<M: MacroAssembler>(
+    masm: &mut M,
+    index: Index,
+    offset: u64,
+    heap_ty_size: OperandSize,
+) -> ImmOffset {
+    match u32::try_from(offset) {
+        // If the immediate offset fits in a u32, then we simply return.
+        Ok(offs) => ImmOffset::from_u32(offs),
+        // Else we adjust the index to be index = index + offset, including an
+        // overflow check, and return 0 as the offset.
+        Err(_) => {
+            masm.checked_uadd(
+                index.as_typed_reg().into(),
+                index.as_typed_reg().into(),
+                RegImm::i64(offset as i64),
+                heap_ty_size,
+                TrapCode::HeapOutOfBounds,
+            );
+
+            ImmOffset::from_u32(0)
+        }
+    }
+}
+
+/// Performs the out-of-bounds check and returns the heap address if the access
+/// criteria is in bounds.
+pub(crate) fn load_heap_addr_checked<M, F>(
+    masm: &mut M,
+    context: &mut CodeGenContext,
+    ptr_size: OperandSize,
+    heap: &HeapData,
+    enable_spectre_mitigation: bool,
+    bounds: Bounds,
+    index: Index,
+    offset: ImmOffset,
+    mut emit_check_condition: F,
+) -> Reg
+where
+    M: MacroAssembler,
+    F: FnMut(&mut M, Bounds, Index) -> IntCmpKind,
+{
+    let cmp_kind = emit_check_condition(masm, bounds, index);
+
+    masm.trapif(cmp_kind, TrapCode::HeapOutOfBounds);
+    let addr = context.any_gpr(masm);
+
+    load_heap_addr_unchecked(masm, heap, index, offset, addr, ptr_size);
+    if !enable_spectre_mitigation {
+        addr
+    } else {
+        // Conditionally assign 0 to the register holding the base address if
+        // the comparison kind is met.
+        let tmp = context.any_gpr(masm);
+        masm.mov(RegImm::i64(0), tmp, ptr_size);
+        let cmp_kind = emit_check_condition(masm, bounds, index);
+        masm.cmov(tmp, addr, cmp_kind, ptr_size);
+        context.free_reg(tmp);
+        addr
+    }
+}
+
+/// Load the requested heap address into the specified destination register.
+/// This function doesn't perform any bounds checks and assumes the caller
+/// performed the right checks.
+pub(crate) fn load_heap_addr_unchecked<M>(
+    masm: &mut M,
+    heap: &HeapData,
+    index: Index,
+    offset: ImmOffset,
+    dst: Reg,
+    ptr_size: OperandSize,
+) where
+    M: MacroAssembler,
+{
+    let base = if let Some(offset) = heap.import_from {
+        // If the WebAssembly memory is imported, load the address into
+        // the scratch register.
+        let scratch = scratch!(M);
+        masm.load_ptr(masm.address_at_vmctx(offset), scratch);
+        scratch
+    } else {
+        // Else if the WebAssembly memory is defined in the current module,
+        // simply use the `VMContext` as the base for subsequent operations.
+        vmctx!(M)
+    };
+
+    // Load the base of the memory into the `addr` register.
+    masm.load_ptr(masm.address_at_reg(base, heap.offset), dst);
+    // Start by adding the index to the heap base addr.
+    let index_reg = index.as_typed_reg().reg;
+    masm.add(dst, dst, index_reg.into(), ptr_size);
+
+    if offset.as_u32() > 0 {
+        masm.add(dst, dst, RegImm::i64(offset.as_u32() as i64), ptr_size);
+    }
+}
diff --git a/winch/codegen/src/codegen/builtin.rs b/winch/codegen/src/codegen/builtin.rs
index 9a5fe34a34d3..eb0ad65a2899 100644
--- a/winch/codegen/src/codegen/builtin.rs
+++ b/winch/codegen/src/codegen/builtin.rs
@@ -5,16 +5,54 @@ use crate::{
     codegen::env::ptr_type_from_ptr_size,
     CallingConvention,
 };
-use wasmtime_environ::{BuiltinFunctionIndex, PtrSize, WasmType};
+use cranelift_codegen::ir::LibCall;
+use std::sync::Arc;
+use wasmtime_environ::{BuiltinFunctionIndex, PtrSize, VMOffsets, WasmValType};
+
+#[derive(Copy, Clone)]
+pub(crate) enum BuiltinType {
+    /// Dynamic built-in function, derived from the VMContext.
+    Builtin(BuiltinFunctionIndex),
+    /// A known libcall.
+    /// See [`cranelift_codegen::ir::LibCall`] for more details.
+    LibCall(LibCall),
+}
+
+impl BuiltinType {
+    /// Creates a new builtin from a Wasmtime-defined builtin function
+    /// enumerated with a [`BuiltinFunctionIndex`].
+    pub fn builtin(idx: BuiltinFunctionIndex) -> Self {
+        Self::Builtin(idx)
+    }
+
+    /// Creates a new builtin from a Compiler-defined [`LibCall`] typically used
+    /// late in lowering.
+    pub fn libcall(libcall: LibCall) -> Self {
+        Self::LibCall(libcall)
+    }
+}
+
+#[derive(Clone)]
+pub struct BuiltinFunction {
+    inner: Arc<BuiltinFunctionInner>,
+}
+
+impl BuiltinFunction {
+    pub(crate) fn sig(&self) -> &ABISig {
+        &self.inner.sig
+    }
+
+    pub(crate) fn ty(&self) -> BuiltinType {
+        self.inner.ty
+    }
+}
 
 /// Metadata about a builtin function.
-pub(crate) struct BuiltinFunction {
+pub struct BuiltinFunctionInner {
     /// The ABI specific signature of the function.
-    pub sig: ABISig,
-    /// The offset of the builtin function
-    pub offset: u32,
-    /// The builtin function base, relative to the VMContext.
-    pub base: u32,
+    sig: ABISig,
+    /// The built-in function type.
+    ty: BuiltinType,
 }
 
 macro_rules! declare_function_sig {
@@ -29,13 +67,26 @@ macro_rules! declare_function_sig {
         pub struct BuiltinFunctions {
             /// The target calling convention.
             call_conv: CallingConvention,
-            /// The target pointer size.
-            ptr_size: u8,
             /// The target pointer type, as a WebAssembly type.
-            ptr_type: WasmType,
-            /// The builtin functions base relative to the VMContext.
-            base: u32,
+            ptr_type: WasmValType,
+            /// F32 Ceil.
+            ceil_f32: Option<BuiltinFunction>,
+            /// F64 Ceil.
+            ceil_f64: Option<BuiltinFunction>,
+            /// F32 Floor.
+            floor_f32: Option<BuiltinFunction>,
+            /// F64 Floor.
+            floor_f64: Option<BuiltinFunction>,
+            /// F32 Trunc.
+            trunc_f32: Option<BuiltinFunction>,
+            /// F64 Trunc.
+            trunc_f64: Option<BuiltinFunction>,
+            /// F32 Nearest.
+            nearest_f32: Option<BuiltinFunction>,
+            /// F64 Nearest.
+            nearest_f64: Option<BuiltinFunction>,
             $(
+                $( #[ $attr ] )*
                 $name: Option<BuiltinFunction>,
             )*
         }
@@ -43,54 +94,166 @@ macro_rules! declare_function_sig {
         // Until all the builtin functions are used.
         #[allow(dead_code)]
         impl BuiltinFunctions {
-            pub fn new(ptr: impl PtrSize, call_conv: CallingConvention, base: u32) -> Self {
-                let size = ptr.size();
+            pub fn new<P: PtrSize>(vmoffsets: &VMOffsets<P>, call_conv: CallingConvention) -> Self {
+                let size = vmoffsets.ptr.size();
+                #[allow(unused_doc_comments)]
                 Self {
-                    ptr_size: size,
                     call_conv,
-                    base,
                     ptr_type: ptr_type_from_ptr_size(size),
+                    ceil_f32: None,
+                    ceil_f64: None,
+                    floor_f32: None,
+                    floor_f64: None,
+                    trunc_f32: None,
+                    trunc_f64: None,
+                    nearest_f32: None,
+                    nearest_f64: None,
                     $(
+                        $( #[ $attr ] )*
                         $name: None,
                     )*
                 }
             }
 
-            fn pointer(&self) -> WasmType {
+            fn pointer(&self) -> WasmValType {
                 self.ptr_type
             }
 
-            fn vmctx(&self) -> WasmType {
+            fn vmctx(&self) -> WasmValType {
                 self.pointer()
             }
 
-            fn i32(&self) -> WasmType {
-                WasmType::I32
+            fn i32(&self) -> WasmValType {
+                WasmValType::I32
+            }
+
+            fn f32(&self) -> WasmValType {
+                WasmValType::F32
+            }
+
+            fn f64(&self) -> WasmValType {
+                WasmValType::F64
             }
 
-            fn i64(&self) -> WasmType {
-                WasmType::I64
+            fn i64(&self) -> WasmValType {
+                WasmValType::I64
             }
 
-            fn reference(&self) -> WasmType {
+            fn reference(&self) -> WasmValType {
                 self.pointer()
             }
 
+            fn over_f64<A: ABI>(&self) -> ABISig {
+                A::sig_from(&[self.f64()], &[self.f64()], &self.call_conv)
+            }
+
+            fn over_f32<A: ABI>(&self) -> ABISig {
+                A::sig_from(&[self.f64()], &[self.f64()], &self.call_conv)
+            }
+
+            pub(crate) fn ceil_f32<A: ABI>(&mut self) -> BuiltinFunction {
+                if self.ceil_f32.is_none() {
+                    let sig = self.over_f32::<A>();
+                    let inner = Arc::new(BuiltinFunctionInner { sig, ty: BuiltinType::libcall(LibCall::CeilF32) });
+                    self.ceil_f32 = Some(BuiltinFunction {
+                        inner,
+                    });
+                }
+                self.ceil_f32.as_ref().unwrap().clone()
+            }
+
+            pub(crate) fn ceil_f64<A: ABI>(&mut self) -> BuiltinFunction {
+                if self.ceil_f64.is_none() {
+                    let sig = self.over_f64::<A>();
+                    let inner = Arc::new(BuiltinFunctionInner { sig, ty: BuiltinType::libcall(LibCall::CeilF64) });
+                    self.ceil_f64 = Some(BuiltinFunction {
+                        inner,
+                    });
+                }
+                self.ceil_f64.as_ref().unwrap().clone()
+            }
+
+            pub(crate) fn floor_f32<A: ABI>(&mut self) -> BuiltinFunction {
+                if self.floor_f32.is_none() {
+                    let sig = self.over_f32::<A>();
+                    let inner = Arc::new(BuiltinFunctionInner { sig, ty: BuiltinType::libcall(LibCall::FloorF32) });
+                    self.floor_f32 = Some(BuiltinFunction {
+                        inner,
+                    });
+                }
+                self.floor_f32.as_ref().unwrap().clone()
+            }
+
+            pub(crate) fn floor_f64<A: ABI>(&mut self) -> BuiltinFunction {
+                if self.floor_f64.is_none() {
+                    let sig = self.over_f64::<A>();
+                    let inner = Arc::new(BuiltinFunctionInner { sig, ty: BuiltinType::libcall(LibCall::FloorF64) });
+                    self.floor_f64 = Some(BuiltinFunction {
+                        inner,
+                    });
+                }
+                self.floor_f64.as_ref().unwrap().clone()
+            }
+
+            pub(crate) fn trunc_f32<A: ABI>(&mut self) -> BuiltinFunction {
+                if self.trunc_f32.is_none() {
+                    let sig = self.over_f32::<A>();
+                    let inner = Arc::new(BuiltinFunctionInner { sig, ty: BuiltinType::libcall(LibCall::TruncF32) });
+                    self.trunc_f32 = Some(BuiltinFunction {
+                        inner,
+                    });
+                }
+                self.trunc_f32.as_ref().unwrap().clone()
+            }
+
+            pub(crate) fn trunc_f64<A: ABI>(&mut self) -> BuiltinFunction {
+                if self.trunc_f64.is_none() {
+                    let sig = self.over_f64::<A>();
+                    let inner = Arc::new(BuiltinFunctionInner { sig, ty: BuiltinType::libcall(LibCall::TruncF64) });
+                    self.trunc_f64 = Some(BuiltinFunction {
+                        inner,
+                    });
+                }
+                self.trunc_f64.as_ref().unwrap().clone()
+            }
+
+            pub(crate) fn nearest_f32<A: ABI>(&mut self) -> BuiltinFunction {
+                if self.nearest_f32.is_none() {
+                    let sig = self.over_f32::<A>();
+                    let inner = Arc::new(BuiltinFunctionInner { sig, ty: BuiltinType::libcall(LibCall::NearestF32) });
+                    self.nearest_f32 = Some(BuiltinFunction {
+                        inner,
+                    });
+                }
+                self.nearest_f32.as_ref().unwrap().clone()
+            }
+
+            pub(crate) fn nearest_f64<A: ABI>(&mut self) -> BuiltinFunction {
+                if self.nearest_f64.is_none() {
+                    let sig = self.over_f64::<A>();
+                    let inner = Arc::new(BuiltinFunctionInner { sig, ty: BuiltinType::libcall(LibCall::NearestF64) });
+                    self.nearest_f64 = Some(BuiltinFunction {
+                        inner,
+                    });
+                }
+                self.nearest_f64.as_ref().unwrap().clone()
+            }
+
             $(
-                pub(crate) fn $name<A: ABI, P: PtrSize>(&mut self) -> &BuiltinFunction {
+                $( #[ $attr ] )*
+                pub(crate) fn $name<A: ABI, P: PtrSize>(&mut self) -> BuiltinFunction {
                     if self.$name.is_none() {
                         let params = vec![ $(self.$param() ),* ];
                         let result = vec![ $(self.$result() )?];
                         let sig = A::sig_from(&params, &result, &self.call_conv);
                         let index = BuiltinFunctionIndex::$name();
+                        let inner = Arc::new(BuiltinFunctionInner { sig, ty: BuiltinType::builtin(index) });
                         self.$name = Some(BuiltinFunction {
-                            sig,
-                            offset: index.index() * (self.ptr_size as u32),
-                            base: self.base,
+                            inner,
                         });
                     }
 
-                    self.$name.as_ref().unwrap()
+                    self.$name.as_ref().unwrap().clone()
                 }
              )*
         }
diff --git a/winch/codegen/src/codegen/call.rs b/winch/codegen/src/codegen/call.rs
index 6b311e94848b..50d501db9216 100644
--- a/winch/codegen/src/codegen/call.rs
+++ b/winch/codegen/src/codegen/call.rs
@@ -1,320 +1,413 @@
 //! Function call emission.  For more details around the ABI and
 //! calling convention, see [ABI].
+//!
+//! This module exposes a single function [`FnCall::emit`], which is responsible
+//! of orchestrating the emission of calls. In general such orchestration
+//! takes place in 6 steps:
+//!
+//! 1. [`Callee`] resolution.
+//! 2. Mapping of the [`Callee`] to the [`CalleeKind`].
+//! 3. Spilling the value stack.
+//! 4. Calculate the return area, for 1+ results.
+//! 5. Emission.
+//! 6. Stack space cleanup.
+//!
+//! The stack space consumed by the function call is the amount
+//! of space used by any memory entries in the value stack present
+//! at the callsite (after spilling the value stack), that will be
+//! used as arguments for the function call. Any memory values in the
+//! value stack that are needed as part of the function
+//! arguments will be consumed by the function call (either by
+//! assigning those values to a register or by storing those
+//! values in a memory location if the callee argument is on
+//! the stack).
+//! This could also be done when assigning arguments every time a
+//! memory entry needs to be assigned to a particular location,
+//! but doing so will emit more instructions (e.g. a pop per
+//! argument that needs to be assigned); it's more efficient to
+//! calculate the space used by those memory values and reclaim it
+//! at once when cleaning up the stack after the call has been
+//! emitted.
+//!
+//! The machine stack throughout the function call is as follows:
+//! ┌──────────────────────────────────────────────────┐
+//! │                                                  │
+//! │                  1                               │
+//! │  Stack space created by any previous spills      │
+//! │  from the value stack; and which memory values   │
+//! │  are used as function arguments.                 │
+//! │                                                  │
+//! ├──────────────────────────────────────────────────┤ ---> The Wasm value stack at this point in time would look like:
+//! │                                                  │      [ Mem(offset) | Mem(offset) | Local(index) | Local(index) ]
+//! │                   2                              │
+//! │   Stack space created by spilling locals and     |
+//! │   registers at the callsite.                     │
+//! │                                                  │
+//! │                                                  │
+//! ├─────────────────────────────────────────────────┬┤ ---> The Wasm value stack at this point in time would look like:
+//! │                                                  │      [ Mem(offset) | Mem(offset) | Mem(offset) | Mem(offset) ]
+//! │                                                  │      Assuming that the callee takes 4 arguments, we calculate
+//! │                                                  │      4 memory values; all of which will be used as arguments to
+//! │   Stack space allocated for                      │      the call via `assign_args`, thus the sum of the size of the
+//! │   the callee function arguments in the stack;    │      memory they represent is considered to be consumed by the call.
+//! │   represented by `arg_stack_space`               │
+//! │                                                  │
+//! │                                                  │
+//! │                                                  │
+//! └──────────────────────────────────────────────────┘ ------> Stack pointer when emitting the call
+
 use crate::{
-    abi::{ABIArg, ABISig, ABI},
-    codegen::{BuiltinFunction, CodeGenContext},
-    masm::{CalleeKind, MacroAssembler, OperandSize},
+    abi::{scratch, vmctx, ABIOperand, ABISig, RetArea},
+    codegen::{BuiltinFunction, BuiltinType, Callee, CodeGenContext},
+    masm::{
+        CalleeKind, ContextArgs, MacroAssembler, MemMoveDirection, OperandSize, SPOffset,
+        VMContextLoc,
+    },
     reg::Reg,
+    stack::Val,
+    FuncEnv,
 };
-use wasmtime_environ::FuncIndex;
+use wasmtime_environ::{FuncIndex, PtrSize, VMOffsets};
 
 /// All the information needed to emit a function call.
 #[derive(Copy, Clone)]
-pub(crate) struct FnCall<'a> {
-    /// The stack space consumed by the function call; that is,
-    /// the sum of:
-    ///
-    /// 1. The amount of stack space created by saving any live
-    ///    registers at the callsite.
-    /// 2. The amount of space used by any memory entries in the value
-    ///    stack present at the callsite, that will be used as
-    ///    arguments for the function call. Any memory values in the
-    ///    value stack that are needed as part of the function
-    ///    arguments, will be consumed by the function call (either by
-    ///    assigning those values to a register or by storing those
-    ///    values to a memory location if the callee argument is on
-    ///    the stack), so we track that stack space to reclaim it once
-    ///    the function call has ended. This could also be done in
-    ///    `assign_args` everytime a memory entry needs to be assigned
-    ///    to a particular location, but doing so, will incur in more
-    ///    instructions (e.g. a pop per argument that needs to be
-    ///    assigned); it's more efficient to track the space needed by
-    ///    those memory values and reclaim it at once.
-    ///
-    /// The machine stack throghout the function call is as follows:
-    /// ┌──────────────────────────────────────────────────┐
-    /// │                                                  │
-    /// │                  1                               │
-    /// │  Stack space created by any previous spills      │
-    /// │  from the value stack; and which memory values   │
-    /// │  are used as function arguments.                 │
-    /// │                                                  │
-    /// ├──────────────────────────────────────────────────┤ ---> The Wasm value stack at this point in time would look like:
-    /// │                                                  │      [ Reg | Reg | Mem(offset) | Mem(offset) ]
-    /// │                   2                              │
-    /// │   Stack space created by saving                  │
-    /// │   any live registers at the callsite.            │
-    /// │                                                  │
-    /// │                                                  │
-    /// ├─────────────────────────────────────────────────┬┤ ---> The Wasm value stack at this point in time would look like:
-    /// │                                                  │      [ Mem(offset) | Mem(offset) | Mem(offset) | Mem(offset) ]
-    /// │                                                  │      Assuming that the callee takes 4 arguments, we calculate
-    /// │                                                  │      2 spilled registers + 2 memory values; all of which will be used
-    /// │   Stack space allocated for                      │      as arguments to the call via `assign_args`, thus the memory they represent is
-    /// │   the callee function arguments in the stack;    │      is considered to be consumed by the call.
-    /// │   represented by `arg_stack_space`               │
-    /// │                                                  │
-    /// │                                                  │
-    /// │                                                  │
-    /// └──────────────────────────────────────────────────┘ ------> Stack pointer when emitting the call
-    ///
-    call_stack_space: Option<u32>,
-    /// The total stack space needed for the callee arguments on the
-    /// stack, including any adjustments to the function's frame and
-    /// aligned to to the required ABI alignment.
-    arg_stack_space: u32,
-    /// The ABI-specific signature of the callee.
-    pub abi_sig: &'a ABISig,
-}
+pub(crate) struct FnCall {}
 
-impl<'a> FnCall<'a> {
-    /// Creates a new [`FnCall`] from the callee's [`ABISig`].
-    pub fn new(callee_sig: &'a ABISig) -> Self {
-        Self {
-            abi_sig: &callee_sig,
-            arg_stack_space: callee_sig.stack_bytes,
-            call_stack_space: None,
-        }
+impl FnCall {
+    /// Orchestrates the emission of a function call:
+    /// 1. Resolves the [`Callee`] through the given callback.
+    /// 2. Lowers the resolved [`Callee`] to a ([`CalleeKind`], [ContextArgs])
+    /// 3. Spills the value stack.
+    /// 4. Creates the stack space needed for the return area.
+    /// 5. Emits the call.
+    /// 6. Cleans up the stack space.
+    pub fn emit<M: MacroAssembler>(
+        env: &mut FuncEnv<M::Ptr>,
+        masm: &mut M,
+        context: &mut CodeGenContext,
+        callee: Callee,
+    ) {
+        let (kind, callee_context) = Self::lower(env, context.vmoffsets, &callee, context, masm);
+
+        let sig = env.callee_sig::<M::ABI>(&callee);
+        context.spill(masm);
+        let ret_area = Self::make_ret_area(&sig, masm);
+        let arg_stack_space = sig.params_stack_size();
+        let reserved_stack = masm.call(arg_stack_space, |masm| {
+            Self::assign(sig, &callee_context, ret_area.as_ref(), context, masm);
+            kind
+        });
+
+        Self::cleanup(
+            sig,
+            &callee_context,
+            &kind,
+            reserved_stack,
+            ret_area,
+            masm,
+            context,
+        );
+    }
+
+    /// Calculates the return area for the callee, if any.
+    fn make_ret_area<M: MacroAssembler>(callee_sig: &ABISig, masm: &mut M) -> Option<RetArea> {
+        callee_sig.has_stack_results().then(|| {
+            let base = masm.sp_offset().as_u32();
+            let end = base + callee_sig.results_stack_size();
+            if end > base {
+                masm.reserve_stack(end - base);
+            }
+            RetArea::sp(SPOffset::from_u32(end))
+        })
     }
 
-    /// Saves any live registers and records the stack space that will be
-    /// consumed by the function call. The stack space consumed by the call must
-    /// be known before emitting the call via any of the emission variants:
-    /// [`FnCall::direct`], [`FnCall::indirect`] or [`FnCall::addr`], which
-    /// means that the call stack space must be calculated either by invoking
-    /// [`FnCall::save_live_registers`] or
-    /// [`FnCall::calculate_call_stack_space`] before invoking any of
-    /// the emission variants.
-    pub fn save_live_registers<M: MacroAssembler>(
-        &mut self,
+    /// Lowers the high-level [`Callee`] to a [`CalleeKind`] and
+    /// [ContextArgs] pair which contains all the metadata needed for
+    /// emission.
+    fn lower<M: MacroAssembler>(
+        env: &mut FuncEnv<M::Ptr>,
+        vmoffsets: &VMOffsets<u8>,
+        callee: &Callee,
         context: &mut CodeGenContext,
         masm: &mut M,
-    ) -> &mut Self {
-        // Invariant: ensure that `call_stack_space` is only set once: either by
-        // [`FnCall::save_live_registers`] or
-        // [`FnCall::calculate_call_stack_space`]
-        debug_assert!(self.call_stack_space.is_none());
-        let callee_params = &self.abi_sig.params;
-        let stack = &context.stack;
-        let call_stack_space = match callee_params.len() {
-            0 => {
-                let _ = context.save_live_registers_and_calculate_sizeof(masm, ..);
-                0u32
+    ) -> (CalleeKind, ContextArgs) {
+        let ptr = vmoffsets.ptr.size();
+        match callee {
+            Callee::Builtin(b) => Self::lower_builtin(env, b),
+            Callee::FuncRef(_) => {
+                Self::lower_funcref(env.callee_sig::<M::ABI>(callee), ptr, context, masm)
             }
-            _ => {
-                // Here we perform a "spill" of the register entries
-                // in the Wasm value stack, we also count any memory
-                // values that will be used used as part of the callee
-                // arguments.  Saving the live registers is done by
-                // emitting push operations for every `Reg` entry in
-                // the Wasm value stack. We do this to be compliant
-                // with Winch's internal ABI, in which all registers
-                // are treated as caller-saved. For more details, see
-                // [ABI].
-                //
-                // The next few lines, partition the value stack into
-                // two sections:
-                // +------------------+--+--- (Stack top)
-                // |                  |  |
-                // |                  |  | 1. The top `n` elements, which are used for
-                // |                  |  |    function arguments; for which we save any
-                // |                  |  |    live registers, keeping track of the amount of registers
-                // +------------------+  |    saved plus the amount of memory values consumed by the function call;
-                // |                  |  |    with this information we can later reclaim the space used by the function call.
-                // |                  |  |
-                // +------------------+--+---
-                // |                  |  | 2. The rest of the items in the stack, for which
-                // |                  |  |    we only save any live registers.
-                // |                  |  |
-                // +------------------+  |
-                assert!(stack.len() >= callee_params.len());
-                let partition = stack.len() - callee_params.len();
-                let _ = context.save_live_registers_and_calculate_sizeof(masm, 0..partition);
-                context.save_live_registers_and_calculate_sizeof(masm, partition..)
+            Callee::Local(i) => Self::lower_local(env, *i),
+            Callee::Import(i) => {
+                let sig = env.callee_sig::<M::ABI>(callee);
+                Self::lower_import(*i, sig, context, masm, vmoffsets)
             }
-        };
+        }
+    }
 
-        self.call_stack_space = Some(call_stack_space);
-        self
+    /// Lowers a builtin function by loading its address to the next available
+    /// register.
+    fn lower_builtin<P: PtrSize>(
+        env: &mut FuncEnv<P>,
+        builtin: &BuiltinFunction,
+    ) -> (CalleeKind, ContextArgs) {
+        match builtin.ty() {
+            BuiltinType::Builtin(idx) => (
+                CalleeKind::direct(env.name_builtin(idx)),
+                ContextArgs::pinned_vmctx(),
+            ),
+            BuiltinType::LibCall(c) => (CalleeKind::libcall(c), ContextArgs::none()),
+        }
     }
 
-    /// Records the stack space that will be needeed by the function call by
-    /// scanning the value stack and returning the size of the all the memory
-    /// entries present in callee's argument length range.  The stack space
-    /// consumed by the call must be known before emitting the call via any of
-    /// the emission variants: [`FnCall::direct`], [`FnCall::indirect`] or
-    /// [`FnCall::addr`], which means that the call stack space must be
-    /// calculated either by invoking [`FnCall::save_live_registers`] or
-    /// [`FnCall::calculate_call_stack_space`] before invoking any of
-    /// the emission variants.
-    /// This function is particularly useful when there's no need to save any
-    /// live registers before emitting the function call. This could happen when
-    /// emitting calls to libcalls: [`FnCall::with_lib`] will eagerly save all
-    /// the live registers when invoked and will also ensure that any registers
-    /// allocated after are non argument registers, in which case if any of
-    /// those registers need to go on the value stack to be used as function
-    /// arguments, they don't need to be saved.
-    pub fn calculate_call_stack_space(&mut self, context: &mut CodeGenContext) -> &mut Self {
-        // Invariant: ensure that `call_stack_space` is only set once: either by
-        // [`FnCall::save_live_registers`] or
-        // [`FnCall::calculate_call_stack_space`]
-        debug_assert!(self.call_stack_space.is_none());
-        let params_len = self.abi_sig.params.len();
-        assert!(context.stack.len() >= params_len);
-
-        let stack_len = context.stack.len();
-        let call_stack_space = if params_len == 0 {
-            0
-        } else {
-            context.stack.sizeof((stack_len - params_len)..)
-        };
-        self.call_stack_space = Some(call_stack_space);
-        self
+    /// Lower  a local function to a [`CalleeKind`] and [ContextArgs] pair.
+    fn lower_local<P: PtrSize>(
+        env: &mut FuncEnv<P>,
+        index: FuncIndex,
+    ) -> (CalleeKind, ContextArgs) {
+        (
+            CalleeKind::direct(env.name_wasm(index)),
+            ContextArgs::pinned_callee_and_caller_vmctx(),
+        )
     }
 
-    /// Emit a direct function call, to a locally defined function.
-    pub fn direct<M: MacroAssembler>(
-        self,
-        masm: &mut M,
+    /// Lowers a function import by loading its address to the next available
+    /// register.
+    fn lower_import<M: MacroAssembler, P: PtrSize>(
+        index: FuncIndex,
+        sig: &ABISig,
         context: &mut CodeGenContext,
-        callee: FuncIndex,
-    ) {
-        // Invariant: `call_stack_space` must be known.
-        debug_assert!(self.call_stack_space.is_some());
-        let reserved_stack = masm.call(self.arg_stack_space, |masm| {
-            self.assign_args(context, masm, <M::ABI as ABI>::scratch_reg());
-            CalleeKind::direct(callee.as_u32())
-        });
-        self.post_call::<M>(masm, context, reserved_stack);
-    }
+        masm: &mut M,
+        vmoffsets: &VMOffsets<P>,
+    ) -> (CalleeKind, ContextArgs) {
+        let (callee, callee_vmctx) =
+            context.without::<(Reg, Reg), M, _>(&sig.regs, masm, |context, masm| {
+                (context.any_gpr(masm), context.any_gpr(masm))
+            });
+        let callee_vmctx_offset = vmoffsets.vmctx_vmfunction_import_vmctx(index);
+        let callee_vmctx_addr = masm.address_at_vmctx(callee_vmctx_offset);
+        masm.load_ptr(callee_vmctx_addr, callee_vmctx);
 
-    /// Emit an indirect function call, using a register.
-    pub fn reg<M: MacroAssembler>(self, masm: &mut M, context: &mut CodeGenContext, reg: Reg) {
-        // Invariant: `call_stack_space` must be known.
-        debug_assert!(self.call_stack_space.is_some());
-        let reserved_stack = masm.call(self.arg_stack_space, |masm| {
-            let scratch = <M::ABI as ABI>::scratch_reg();
-            self.assign_args(context, masm, scratch);
-            CalleeKind::indirect(reg)
-        });
-        context.free_reg(reg);
-        self.post_call::<M>(masm, context, reserved_stack);
+        let callee_body_offset = vmoffsets.vmctx_vmfunction_import_wasm_call(index);
+        let callee_addr = masm.address_at_vmctx(callee_body_offset);
+        masm.load_ptr(callee_addr, callee);
+
+        (
+            CalleeKind::indirect(callee),
+            ContextArgs::with_callee_and_pinned_caller(callee_vmctx),
+        )
     }
 
-    /// Emit an indirect function call, using a an address.
-    /// This function will load the provided address into a unallocatable
-    /// scratch register.
-    pub fn addr<M: MacroAssembler>(
-        self,
-        masm: &mut M,
+    /// Lowers a function reference by loading its address into the next
+    /// available register.
+    fn lower_funcref<M: MacroAssembler>(
+        sig: &ABISig,
+        ptr: impl PtrSize,
         context: &mut CodeGenContext,
-        callee: M::Address,
-    ) {
-        // Invariant: `call_stack_space` must be known.
-        debug_assert!(self.call_stack_space.is_some());
-        let reserved_stack = masm.call(self.arg_stack_space, |masm| {
-            let scratch = <M::ABI as ABI>::scratch_reg();
-            self.assign_args(context, masm, scratch);
-            masm.load(callee, scratch, OperandSize::S64);
-            CalleeKind::indirect(scratch)
-        });
+        masm: &mut M,
+    ) -> (CalleeKind, ContextArgs) {
+        // Pop the funcref pointer to a register and allocate a register to hold the
+        // address of the funcref. Since the callee is not addressed from a global non
+        // allocatable register (like the vmctx in the case of an import), we load the
+        // funcref to a register ensuring that it doesn't get assigned to a register
+        // used in the callee's signature.
+        let (funcref_ptr, funcref, callee_vmctx) =
+            context.without::<_, M, _>(&sig.regs, masm, |cx, masm| {
+                (
+                    cx.pop_to_reg(masm, None).into(),
+                    cx.any_gpr(masm),
+                    cx.any_gpr(masm),
+                )
+            });
 
-        self.post_call::<M>(masm, context, reserved_stack);
-    }
+        // Load the callee VMContext, that will be passed as first argument to
+        // the function call.
+        masm.load_ptr(
+            masm.address_at_reg(funcref_ptr, ptr.vm_func_ref_vmctx().into()),
+            callee_vmctx,
+        );
 
-    /// Prepares the compiler to call a built-in function (libcall).
-    /// This fuction, saves all the live registers and loads the callee
-    /// address into a non-argument register which is then passed to the
-    /// caller through the provided callback.
-    ///
-    /// It is the caller's responsibility to finalize the function call
-    /// by calling `FnCall::reg` once all the information is known.
-    pub fn with_lib<M: MacroAssembler, F>(
-        &mut self,
-        masm: &mut M,
-        context: &mut CodeGenContext,
-        func: &BuiltinFunction,
-        mut f: F,
-    ) where
-        F: FnMut(&mut CodeGenContext, &mut M, &mut Self, Reg),
-    {
-        // When dealing with libcalls, we don't have all the information
-        // upfront (all necessary arguments in the stack) in order to optimize
-        // saving the live registers, so we save all the values available in
-        // the value stack.
-        context.spill(masm);
-        let vmctx = <M::ABI as ABI>::vmctx_reg();
-        let scratch = <M::ABI as ABI>::scratch_reg();
-
-        let builtins_base = masm.address_at_reg(vmctx, func.base);
-        masm.load(builtins_base, scratch, OperandSize::S64);
-        let builtin_func_addr = masm.address_at_reg(scratch, func.offset);
-        context.without::<(), M, _>(
-            // Do not free the result registers if any as the function call will
-            // push them onto the stack as a result of the call.
-            self.abi_sig.regs(),
-            self.abi_sig.param_regs(),
-            masm,
-            |cx, masm| {
-                let callee = cx.any_gpr(masm);
-                masm.load_ptr(builtin_func_addr, callee);
-                f(cx, masm, self, callee);
-                cx.free_reg(callee);
-            },
+        // Load the function pointer to be called.
+        masm.load_ptr(
+            masm.address_at_reg(funcref_ptr, ptr.vm_func_ref_wasm_call().into()),
+            funcref,
         );
+        context.free_reg(funcref_ptr);
+
+        (
+            CalleeKind::indirect(funcref),
+            ContextArgs::with_callee_and_pinned_caller(callee_vmctx),
+        )
     }
 
-    fn post_call<M: MacroAssembler>(&self, masm: &mut M, context: &mut CodeGenContext, size: u32) {
-        masm.free_stack(self.call_stack_space.unwrap() + size);
-        // Only account for registers given that any memory entries
-        // consumed by the call (assigned to a register or to a stack
-        // slot) were freed by the previous call to
-        // `masm.free_stack`, so we only care about dropping them
-        // here.
-        //
-        // NOTE / TODO there's probably a path to getting rid of
-        // `save_live_registers_and_calculate_sizeof` and
-        // `call_stack_space`, making it a bit more obvious what's
-        // happening here. We could:
-        //
-        // * Modify the `spill` implementation so that it takes a
-        // filtering callback, to control which values the caller is
-        // interested in saving (e.g. save all if no function is provided)
-        // * Rely on the new implementation of `drop_last` to calcuate
-        // the stack memory entries consumed by the call and then free
-        // the calculated stack space.
-        context.drop_last(self.abi_sig.params.len(), |regalloc, v| {
-            if v.is_reg() {
-                regalloc.free(v.get_reg().into());
+    /// Materializes any [ContextArgs] as a function argument.
+    fn assign_context_args<M: MacroAssembler>(sig: &ABISig, context: &ContextArgs, masm: &mut M) {
+        debug_assert!(sig.params().len() >= context.len());
+        for (context_arg, operand) in context
+            .as_slice()
+            .iter()
+            .zip(sig.params_without_retptr().iter().take(context.len()))
+        {
+            match (context_arg, operand) {
+                (VMContextLoc::Pinned, ABIOperand::Reg { ty, reg, .. }) => {
+                    masm.mov(vmctx!(M).into(), *reg, (*ty).into());
+                }
+                (VMContextLoc::Pinned, ABIOperand::Stack { ty, offset, .. }) => {
+                    let addr = masm.address_at_sp(SPOffset::from_u32(*offset));
+                    masm.store(vmctx!(M).into(), addr, (*ty).into());
+                }
+
+                (VMContextLoc::Reg(src), ABIOperand::Reg { ty, reg, .. }) => {
+                    masm.mov((*src).into(), *reg, (*ty).into());
+                }
+
+                (VMContextLoc::Reg(src), ABIOperand::Stack { ty, offset, .. }) => {
+                    let addr = masm.address_at_sp(SPOffset::from_u32(*offset));
+                    masm.store((*src).into(), addr, (*ty).into());
+                }
             }
-        });
-        context.push_abi_results(&self.abi_sig.result, masm);
+        }
     }
 
-    fn assign_args<M: MacroAssembler>(
-        &self,
+    /// Assign arguments for the function call.
+    fn assign<M: MacroAssembler>(
+        sig: &ABISig,
+        callee_context: &ContextArgs,
+        ret_area: Option<&RetArea>,
         context: &mut CodeGenContext,
         masm: &mut M,
-        scratch: Reg,
     ) {
-        let arg_count = self.abi_sig.params.len();
+        let arg_count = sig.params.len_without_retptr();
+        debug_assert!(arg_count >= callee_context.len());
         let stack = &context.stack;
-        let mut stack_values = stack.peekn(arg_count);
-        for arg in &self.abi_sig.params {
-            let val = stack_values
-                .next()
-                .unwrap_or_else(|| panic!("expected stack value for function argument"));
-            match &arg {
-                &ABIArg::Reg { ty: _, reg } => {
-                    context.move_val_to_reg(&val, *reg, masm);
+        let stack_values = stack.peekn(arg_count - callee_context.len());
+
+        if callee_context.len() > 0 {
+            Self::assign_context_args(&sig, &callee_context, masm);
+        }
+
+        for (arg, val) in sig
+            .params_without_retptr()
+            .iter()
+            .skip(callee_context.len())
+            .zip(stack_values)
+        {
+            match arg {
+                &ABIOperand::Reg { reg, .. } => {
+                    context.move_val_to_reg(&val, reg, masm);
                 }
-                &ABIArg::Stack { ty, offset } => {
-                    let addr = masm.address_at_sp(*offset);
-                    let size: OperandSize = (*ty).into();
+                &ABIOperand::Stack { ty, offset, .. } => {
+                    let addr = masm.address_at_sp(SPOffset::from_u32(offset));
+                    let size: OperandSize = ty.into();
+                    let scratch = scratch!(M, &ty);
                     context.move_val_to_reg(val, scratch, masm);
                     masm.store(scratch.into(), addr, size);
                 }
             }
         }
+
+        if sig.has_stack_results() {
+            let operand = sig.params.unwrap_results_area_operand();
+            let base = ret_area.unwrap().unwrap_sp();
+            let addr = masm.address_from_sp(base);
+
+            match operand {
+                &ABIOperand::Reg { ty, reg, .. } => {
+                    masm.load_addr(addr, reg, ty.into());
+                }
+                &ABIOperand::Stack { ty, offset, .. } => {
+                    let slot = masm.address_at_sp(SPOffset::from_u32(offset));
+                    // Don't rely on `ABI::scratch_for` as we always use
+                    // an int register as the return pointer.
+                    let scratch = scratch!(M);
+                    masm.load_addr(addr, scratch, ty.into());
+                    masm.store(scratch.into(), slot, ty.into());
+                }
+            }
+        }
+    }
+
+    /// Cleanup stack space, handle multiple results, and free registers after
+    /// emitting the call.
+    fn cleanup<M: MacroAssembler>(
+        sig: &ABISig,
+        callee_context: &ContextArgs,
+        callee_kind: &CalleeKind,
+        reserved_space: u32,
+        ret_area: Option<RetArea>,
+        masm: &mut M,
+        context: &mut CodeGenContext,
+    ) {
+        // Free any registers holding any function references.
+        match callee_kind {
+            CalleeKind::Indirect(r) => context.free_reg(*r),
+            _ => {}
+        }
+
+        // Free any registers used as part of the [ContextArgs].
+        for loc in callee_context.as_slice() {
+            match loc {
+                VMContextLoc::Reg(r) => context.free_reg(*r),
+                _ => {}
+            }
+        }
+        // Deallocate the reserved space for stack arguments and for alignment,
+        // which was allocated last.
+        masm.free_stack(reserved_space);
+
+        debug_assert!(sig.params.len_without_retptr() >= callee_context.len());
+
+        // Drop params from value stack and calculate amount of machine stack
+        // space they consumed.
+        let mut stack_consumed = 0;
+        context.drop_last(
+            sig.params.len_without_retptr() - callee_context.len(),
+            |_regalloc, v| {
+                debug_assert!(v.is_mem() || v.is_const());
+                if let Val::Memory(mem) = v {
+                    stack_consumed += mem.slot.size;
+                }
+            },
+        );
+
+        if let Some(ret_area) = ret_area {
+            if stack_consumed > 0 {
+                // Perform a memory move, by shuffling the result area to
+                // higher addresses. This is needed because the result area
+                // is located after any memory addresses located on the stack,
+                // and after spilled values consumed by the call.
+                let sp = ret_area.unwrap_sp();
+                let result_bytes = sig.results_stack_size();
+                debug_assert!(sp.as_u32() >= stack_consumed + result_bytes);
+                let dst = SPOffset::from_u32(sp.as_u32() - stack_consumed);
+                masm.memmove(sp, dst, result_bytes, MemMoveDirection::LowToHigh);
+            }
+        };
+
+        // Free the bytes consumed by the call.
+        masm.free_stack(stack_consumed);
+
+        let ret_area = ret_area.map(|area| {
+            if stack_consumed > 0 {
+                // If there's a return area and stack space was consumed by the
+                // call, adjust the return area to be to the current stack
+                // pointer offset.
+                RetArea::sp(masm.sp_offset())
+            } else {
+                // Else if no stack space was consumed by the call, simply use
+                // the previously calculated area.
+                debug_assert_eq!(area.unwrap_sp(), masm.sp_offset());
+                area
+            }
+        });
+
+        // In the case of [Callee], there's no need to set the [RetArea] of the
+        // signature, as it's only used here to push abi results.
+        context.push_abi_results(&sig.results, masm, |_, _, _| ret_area);
+        // Reload the [VMContext] pointer into the corresponding pinned
+        // register. Winch currently doesn't have any callee-saved registers in
+        // the default ABI. So the callee might clobber the designated pinned
+        // register.
+        context.load_vmctx(masm);
     }
 }
diff --git a/winch/codegen/src/codegen/context.rs b/winch/codegen/src/codegen/context.rs
index 1f7658611911..f61b7749a0ef 100644
--- a/winch/codegen/src/codegen/context.rs
+++ b/winch/codegen/src/codegen/context.rs
@@ -1,16 +1,15 @@
-use wasmtime_environ::WasmType;
+use wasmtime_environ::{VMOffsets, WasmHeapType, WasmValType};
 
 use super::ControlStackFrame;
 use crate::{
-    abi::{ABIResult, ABI},
+    abi::{scratch, vmctx, ABIOperand, ABIResults, RetArea},
     frame::Frame,
     isa::reg::RegClass,
-    masm::{MacroAssembler, OperandSize, RegImm},
+    masm::{MacroAssembler, OperandSize, RegImm, SPOffset, ShiftKind, StackSlot},
     reg::Reg,
     regalloc::RegAlloc,
     stack::{Stack, TypedReg, Val},
 };
-use std::ops::RangeBounds;
 
 /// The code generation context.
 /// The code generation context is made up of three
@@ -33,19 +32,27 @@ pub(crate) struct CodeGenContext<'a> {
     /// The value stack.
     pub stack: Stack,
     /// The current function's frame.
-    pub frame: &'a Frame,
+    pub frame: Frame,
     /// Reachability state.
     pub reachable: bool,
+    /// A reference to the VMOffsets.
+    pub vmoffsets: &'a VMOffsets<u8>,
 }
 
 impl<'a> CodeGenContext<'a> {
     /// Create a new code generation context.
-    pub fn new(regalloc: RegAlloc, stack: Stack, frame: &'a Frame) -> Self {
+    pub fn new(
+        regalloc: RegAlloc,
+        stack: Stack,
+        frame: Frame,
+        vmoffsets: &'a VMOffsets<u8>,
+    ) -> Self {
         Self {
             regalloc,
             stack,
             frame,
             reachable: true,
+            vmoffsets,
         }
     }
 
@@ -58,12 +65,19 @@ impl<'a> CodeGenContext<'a> {
     }
 
     /// Allocate a register for the given WebAssembly type.
-    pub fn reg_for_type<M: MacroAssembler>(&mut self, ty: WasmType, masm: &mut M) -> Reg {
-        use WasmType::*;
+    pub fn reg_for_type<M: MacroAssembler>(&mut self, ty: WasmValType, masm: &mut M) -> Reg {
+        use WasmValType::*;
         match ty {
             I32 | I64 => self.reg_for_class(RegClass::Int, masm),
             F32 | F64 => self.reg_for_class(RegClass::Float, masm),
-            t => panic!("unsupported type {:?}", t),
+            // All of our supported architectures use the float registers for vector operations.
+            V128 => self.reg_for_class(RegClass::Float, masm),
+            Ref(rt) => match rt.heap_type {
+                WasmHeapType::Func | WasmHeapType::Extern => {
+                    self.reg_for_class(RegClass::Int, masm)
+                }
+                ht => unimplemented!("Support for WasmHeapType: {ht}"),
+            },
         }
     }
 
@@ -81,15 +95,18 @@ impl<'a> CodeGenContext<'a> {
         self.reg_for_class(RegClass::Int, masm)
     }
 
+    /// Convenience wrapper around `CodeGenContext::reg_for_class`, to
+    /// request the next available floating point register.
+    pub fn any_fpr<M: MacroAssembler>(&mut self, masm: &mut M) -> Reg {
+        self.reg_for_class(RegClass::Float, masm)
+    }
+
     /// Executes the provided function, guaranteeing that the specified set of
     /// registers, if any, remain unallocatable throughout the function's
-    /// execution. Only the registers in the `free` iterator will be freed. The
-    /// caller must guarantee that in case the iterators are different, the free
-    /// iterator must be a subset of the alloc iterator.
-    pub fn without<T, M, F>(
+    /// execution.
+    pub fn without<'r, T, M, F>(
         &mut self,
-        alloc: impl Iterator<Item = Reg>,
-        free: impl Iterator<Item = Reg>,
+        regs: impl IntoIterator<Item = &'r Reg> + Copy,
         masm: &mut M,
         mut f: F,
     ) -> T
@@ -97,16 +114,14 @@ impl<'a> CodeGenContext<'a> {
         M: MacroAssembler,
         F: FnMut(&mut Self, &mut M) -> T,
     {
-        debug_assert!(free.size_hint().0 <= alloc.size_hint().0);
-
-        for r in alloc {
-            self.reg(r, masm);
+        for r in regs {
+            self.reg(*r, masm);
         }
 
         let result = f(self, masm);
 
-        for r in free {
-            self.free_reg(r);
+        for r in regs {
+            self.free_reg(*r);
         }
 
         result
@@ -144,18 +159,50 @@ impl<'a> CodeGenContext<'a> {
         };
 
         if val.is_mem() {
+            let mem = val.unwrap_mem();
+            debug_assert_eq!(mem.slot.offset.as_u32(), masm.sp_offset().as_u32());
             masm.pop(reg, val.ty().into());
         } else {
             self.move_val_to_reg(&val, reg, masm);
             // Free the source value if it is a register.
             if val.is_reg() {
-                self.free_reg(val.get_reg());
+                self.free_reg(val.unwrap_reg());
             }
         }
 
         TypedReg::new(val.ty(), reg)
     }
 
+    /// Pops the value stack top and stores it at the specified address.
+    pub fn pop_to_addr<M: MacroAssembler>(&mut self, masm: &mut M, addr: M::Address) {
+        let val = self.stack.pop().expect("a value at stack top");
+        let ty = val.ty();
+        let size: OperandSize = ty.into();
+        match val {
+            Val::Reg(tr) => {
+                masm.store(tr.reg.into(), addr, size);
+                self.free_reg(tr.reg);
+            }
+            Val::I32(v) => masm.store(RegImm::i32(v), addr, size),
+            Val::I64(v) => masm.store(RegImm::i64(v), addr, size),
+            Val::F32(v) => masm.store(RegImm::f32(v.bits()), addr, size),
+            Val::F64(v) => masm.store(RegImm::f64(v.bits()), addr, size),
+            Val::V128(v) => masm.store(RegImm::v128(v), addr, size),
+            Val::Local(local) => {
+                let slot = self.frame.get_wasm_local(local.index);
+                let scratch = scratch!(M);
+                let local_addr = masm.local_address(&slot);
+                masm.load(local_addr, scratch, size);
+                masm.store(scratch.into(), addr, size);
+            }
+            Val::Memory(_) => {
+                let scratch = scratch!(M, &ty);
+                masm.pop(scratch, size);
+                masm.store(scratch.into(), addr, size);
+            }
+        }
+    }
+
     /// Move a stack value to the given register.
     pub fn move_val_to_reg<M: MacroAssembler>(&self, src: &Val, dst: Reg, masm: &mut M) {
         let size: OperandSize = src.ty().into();
@@ -165,13 +212,11 @@ impl<'a> CodeGenContext<'a> {
             Val::I64(imm) => masm.mov(RegImm::i64(*imm), dst, size),
             Val::F32(imm) => masm.mov(RegImm::f32(imm.bits()), dst, size),
             Val::F64(imm) => masm.mov(RegImm::f64(imm.bits()), dst, size),
+            Val::V128(imm) => masm.mov(RegImm::v128(*imm), dst, size),
             Val::Local(local) => {
-                let slot = self
-                    .frame
-                    .get_local(local.index)
-                    .unwrap_or_else(|| panic!("valid local at index = {}", local.index));
+                let slot = self.frame.get_wasm_local(local.index);
                 let addr = masm.local_address(&slot);
-                masm.load(addr, dst, slot.ty.into());
+                masm.load(addr, dst, size);
             }
             Val::Memory(mem) => {
                 let addr = masm.address_from_sp(mem.slot.offset);
@@ -181,20 +226,62 @@ impl<'a> CodeGenContext<'a> {
     }
 
     /// Prepares arguments for emitting a unary operation.
+    ///
+    /// The `emit` function returns the `TypedReg` to put on the value stack.
     pub fn unop<F, M>(&mut self, masm: &mut M, size: OperandSize, emit: &mut F)
     where
-        F: FnMut(&mut M, Reg, OperandSize),
+        F: FnMut(&mut M, Reg, OperandSize) -> TypedReg,
         M: MacroAssembler,
     {
         let typed_reg = self.pop_to_reg(masm, None);
-        emit(masm, typed_reg.reg, size);
-        self.stack.push(typed_reg.into());
+        let dst = emit(masm, typed_reg.reg, size);
+        self.stack.push(dst.into());
+    }
+
+    /// Prepares arguments for emitting a binary operation.
+    ///
+    /// The `emit` function returns the `TypedReg` to put on the value stack.
+    pub fn binop<F, M>(&mut self, masm: &mut M, size: OperandSize, mut emit: F)
+    where
+        F: FnMut(&mut M, Reg, Reg, OperandSize) -> TypedReg,
+        M: MacroAssembler,
+    {
+        let src = self.pop_to_reg(masm, None);
+        let dst = self.pop_to_reg(masm, None);
+        let dst = emit(masm, dst.reg, src.reg.into(), size);
+        self.free_reg(src);
+        self.stack.push(dst.into());
+    }
+
+    /// Prepares arguments for emitting an f32 or f64 comparison operation.
+    pub fn float_cmp_op<F, M>(&mut self, masm: &mut M, size: OperandSize, mut emit: F)
+    where
+        F: FnMut(&mut M, Reg, Reg, Reg, OperandSize),
+        M: MacroAssembler,
+    {
+        let src2 = self.pop_to_reg(masm, None);
+        let src1 = self.pop_to_reg(masm, None);
+        let dst = self.any_gpr(masm);
+        emit(masm, dst, src1.reg, src2.reg, size);
+        self.free_reg(src1);
+        self.free_reg(src2);
+
+        let dst = match size {
+            // Float comparison operators are defined as
+            // [f64 f64] -> i32
+            // https://webassembly.github.io/spec/core/appendix/index-instructions.html
+            OperandSize::S32 | OperandSize::S64 => TypedReg::i32(dst),
+            OperandSize::S8 | OperandSize::S16 | OperandSize::S128 => unreachable!(),
+        };
+        self.stack.push(dst.into());
     }
 
     /// Prepares arguments for emitting an i32 binary operation.
+    ///
+    /// The `emit` function returns the `TypedReg` to put on the value stack.
     pub fn i32_binop<F, M>(&mut self, masm: &mut M, mut emit: F)
     where
-        F: FnMut(&mut M, Reg, RegImm, OperandSize),
+        F: FnMut(&mut M, Reg, RegImm, OperandSize) -> TypedReg,
         M: MacroAssembler,
     {
         let top = self.stack.peek().expect("value at stack top");
@@ -205,21 +292,21 @@ impl<'a> CodeGenContext<'a> {
                 .pop_i32_const()
                 .expect("i32 const value at stack top");
             let typed_reg = self.pop_to_reg(masm, None);
-            emit(masm, typed_reg.reg, RegImm::i32(val), OperandSize::S32);
-            self.stack.push(typed_reg.into());
-        } else {
-            let src = self.pop_to_reg(masm, None);
-            let dst = self.pop_to_reg(masm, None);
-            emit(masm, dst.reg, src.reg.into(), OperandSize::S32);
-            self.free_reg(src);
+            let dst = emit(masm, typed_reg.reg, RegImm::i32(val), OperandSize::S32);
             self.stack.push(dst.into());
+        } else {
+            self.binop(masm, OperandSize::S32, |masm, dst, src, size| {
+                emit(masm, dst, src.into(), size)
+            });
         }
     }
 
     /// Prepares arguments for emitting an i64 binary operation.
+    ///
+    /// The `emit` function returns the `TypedReg` to put on the value stack.
     pub fn i64_binop<F, M>(&mut self, masm: &mut M, mut emit: F)
     where
-        F: FnMut(&mut M, Reg, RegImm, OperandSize),
+        F: FnMut(&mut M, Reg, RegImm, OperandSize) -> TypedReg,
         M: MacroAssembler,
     {
         let top = self.stack.peek().expect("value at stack top");
@@ -229,61 +316,127 @@ impl<'a> CodeGenContext<'a> {
                 .pop_i64_const()
                 .expect("i64 const value at stack top");
             let typed_reg = self.pop_to_reg(masm, None);
-            emit(masm, typed_reg.reg, RegImm::i64(val), OperandSize::S64);
+            let dst = emit(masm, typed_reg.reg, RegImm::i64(val), OperandSize::S64);
+            self.stack.push(dst.into());
+        } else {
+            self.binop(masm, OperandSize::S64, |masm, dst, src, size| {
+                emit(masm, dst, src.into(), size)
+            });
+        };
+    }
+
+    /// Prepares arguments for emitting an i32 shift operation.
+    pub fn i32_shift<M>(&mut self, masm: &mut M, kind: ShiftKind)
+    where
+        M: MacroAssembler,
+    {
+        let top = self.stack.peek().expect("value at stack top");
+
+        if top.is_i32_const() {
+            let val = self
+                .stack
+                .pop_i32_const()
+                .expect("i32 const value at stack top");
+            let typed_reg = self.pop_to_reg(masm, None);
+            masm.shift_ir(
+                typed_reg.reg,
+                val as u64,
+                typed_reg.reg,
+                kind,
+                OperandSize::S32,
+            );
             self.stack.push(typed_reg.into());
         } else {
-            let src = self.pop_to_reg(masm, None);
-            let dst = self.pop_to_reg(masm, None);
-            emit(masm, dst.reg, src.reg.into(), OperandSize::S64);
-            self.free_reg(src);
-            self.stack.push(dst.into());
+            masm.shift(self, kind, OperandSize::S32);
         }
     }
 
-    /// Saves any live registers in the value stack in a particular
-    /// range defined by the caller.  This is a specialization of the
-    /// spill function; made available for cases in which spilling
-    /// locals is not required, like for example for function calls in
-    /// which locals are not reachable by the callee.  
-    ///
-    /// Returns the size in bytes of the specified range.
-    pub fn save_live_registers_and_calculate_sizeof<M, R>(&mut self, masm: &mut M, range: R) -> u32
+    /// Prepares arguments for emitting an i64 binary operation.
+    pub fn i64_shift<M>(&mut self, masm: &mut M, kind: ShiftKind)
     where
-        R: RangeBounds<usize>,
         M: MacroAssembler,
     {
-        let mut size = 0u32;
-        for v in self.stack.inner_mut().range_mut(range) {
-            match v {
-                Val::Reg(TypedReg { reg, ty }) => {
-                    let slot = masm.push(*reg, (*ty).into());
-                    self.regalloc.free(*reg);
-                    *v = Val::mem(*ty, slot);
-                    size += slot.size
-                }
-                Val::Memory(mem) => size += mem.slot.size,
-                _ => {}
-            }
-        }
+        let top = self.stack.peek().expect("value at stack top");
+        if top.is_i64_const() {
+            let val = self
+                .stack
+                .pop_i64_const()
+                .expect("i64 const value at stack top");
+            let typed_reg = self.pop_to_reg(masm, None);
+            masm.shift_ir(
+                typed_reg.reg,
+                val as u64,
+                typed_reg.reg,
+                kind,
+                OperandSize::S64,
+            );
+            self.stack.push(typed_reg.into());
+        } else {
+            masm.shift(self, kind, OperandSize::S64);
+        };
+    }
+
+    /// Prepares arguments for emitting a convert operation.
+    pub fn convert_op<F, M>(&mut self, masm: &mut M, dst_ty: WasmValType, mut emit: F)
+    where
+        F: FnMut(&mut M, Reg, Reg, OperandSize),
+        M: MacroAssembler,
+    {
+        let src = self.pop_to_reg(masm, None);
+        let dst = self.reg_for_type(dst_ty, masm);
+        let dst_size = match dst_ty {
+            WasmValType::I32 => OperandSize::S32,
+            WasmValType::I64 => OperandSize::S64,
+            WasmValType::F32 => OperandSize::S32,
+            WasmValType::F64 => OperandSize::S64,
+            WasmValType::V128 => unreachable!(),
+            WasmValType::Ref(_) => unreachable!(),
+        };
+
+        emit(masm, dst, src.into(), dst_size);
 
-        size
+        self.free_reg(src);
+        self.stack.push(TypedReg::new(dst_ty, dst).into());
+    }
+
+    /// Prepares arguments for emitting a convert operation with a temporary
+    /// register.
+    pub fn convert_op_with_tmp_reg<F, M>(
+        &mut self,
+        masm: &mut M,
+        dst_ty: WasmValType,
+        tmp_reg_class: RegClass,
+        mut emit: F,
+    ) where
+        F: FnMut(&mut M, Reg, Reg, Reg, OperandSize),
+        M: MacroAssembler,
+    {
+        let tmp_gpr = self.reg_for_class(tmp_reg_class, masm);
+        self.convert_op(masm, dst_ty, |masm, dst, src, dst_size| {
+            emit(masm, dst, src, tmp_gpr, dst_size);
+        });
+        self.free_reg(tmp_gpr);
     }
 
     /// Drops the last `n` elements of the stack, calling the provided
     /// function for each `n` stack value.
+    /// The values are dropped in top-to-bottom order.
     pub fn drop_last<F>(&mut self, last: usize, mut f: F)
     where
         F: FnMut(&mut RegAlloc, &Val),
     {
-        let len = self.stack.len();
-        assert!(last <= len);
-        let truncate = self.stack.len() - last;
-        let stack_mut = &mut self.stack.inner_mut();
-
-        for v in stack_mut.range(truncate..) {
-            f(&mut self.regalloc, v)
+        if last > 0 {
+            let len = self.stack.len();
+            assert!(last <= len);
+            let truncate = self.stack.len() - last;
+            let stack_mut = self.stack.inner_mut();
+
+            // Invoke the callback in top-to-bottom order.
+            for v in stack_mut[truncate..].into_iter().rev() {
+                f(&mut self.regalloc, v)
+            }
+            stack_mut.truncate(truncate);
         }
-        stack_mut.truncate(truncate);
     }
 
     /// Convenience wrapper around [`Self::spill_callback`].
@@ -294,10 +447,11 @@ impl<'a> CodeGenContext<'a> {
         Self::spill_impl(&mut self.stack, &mut self.regalloc, &mut self.frame, masm);
     }
 
-    /// Prepares the compiler to emit an uncoditional jump to the
-    /// given destination branch.  This process involves:
-    /// * Balancing the machine stack pointer by popping it to
-    ///   match the destination branch.
+    /// Prepares the compiler to emit an uncoditional jump to the given
+    /// destination branch.  This process involves:
+    /// * Balancing the machine
+    ///   stack pointer and value stack by popping it to match the destination
+    ///   branch.
     /// * Updating the reachability state.
     /// * Marking the destination frame as a destination target.
     pub fn unconditional_jump<M, F>(&mut self, dest: &mut ControlStackFrame, masm: &mut M, mut f: F)
@@ -305,99 +459,114 @@ impl<'a> CodeGenContext<'a> {
         M: MacroAssembler,
         F: FnMut(&mut M, &mut Self, &mut ControlStackFrame),
     {
-        let (_, target_sp) = dest.original_stack_len_and_sp_offset();
+        let state = dest.stack_state();
+        let target_offset = state.target_offset;
+        let base_offset = state.base_offset;
         // Invariant: The SP, must be greater or equal to the target
         // SP, given that we haven't popped any results by this point
         // yet. But it may happen in the callback.
-        assert!(masm.sp_offset() >= target_sp);
+        assert!(masm.sp_offset().as_u32() >= base_offset.as_u32());
         f(masm, self, dest);
 
-        // The following snippet, pops the stack pointer to ensure
-        // that it is correctly placed according to the expectations
-        // of the destination branch.
+        // The following snippet, pops the stack pointer to ensure that it
+        // is correctly placed according to the expectations of the destination
+        // branch.
         //
-        // This is done in the context of unconditional jumps, as the
-        // machine stack might be left unbalanced at the jump site,
-        // due to register spills. In this context unbalanced refers
-        // to possible extra space created at the jump site, which
-        // might cause invalid memory accesses. Note that in some cases
-        // the stack pointer offset might be already less than or
-        // equal to the original stack pointer offset registered when
-        // entering the destination control stack frame, which
-        // effectively means that when reaching the jump site no extra
-        // space was allocated similar to what would happen in a fall
-        // through in which we assume that the program has allocated
-        // and deallocated the right amount of stack space.
+        // This is done in the context of unconditional jumps, as the machine
+        // stack might be left unbalanced at the jump site, due to register
+        // spills. Note that in some cases the stack pointer offset might be
+        // already less than or equal to the original stack pointer offset
+        // registered when entering the destination control stack frame, which
+        // effectively means that when reaching the jump site no extra space was
+        // allocated similar to what would happen in a fall through in which we
+        // assume that the program has allocated and deallocated the right
+        // amount of stack space.
         //
-        // More generally speaking the current stack pointer will be
-        // less than the original stack pointer offset in cases in
-        // which the top value in the value stack is a memory entry
-        // which needs to be popped into the return location according
-        // to the ABI (a register for single value returns and a
-        // memory slot for 1+ returns). This could happen in the
+        // More generally speaking the current stack pointer will be less than
+        // the original stack pointer offset in cases in which the top value in
+        // the value stack is a memory entry which needs to be popped into the
+        // return location according to the ABI (a register for single value
+        // returns and a memory slot for 1+ returns). This could happen in the
         // callback invocation above if the callback invokes
-        // `CodeGenContext::pop_abi_results` (e.g. `br` instruction).
-        let current_sp = masm.sp_offset();
-        if current_sp > target_sp {
-            masm.free_stack(current_sp - target_sp);
-        }
-
+        // `ControlStackFrame::pop_abi_results` (e.g. `br` instruction).
+        //
+        // After an unconditional jump, the compiler will enter in an
+        // unreachable state; instead of immediately truncating the value stack
+        // to the expected length of the destination branch, we let the
+        // reachability analysis code decide what should happen with the length
+        // of the value stack once reachability is actually restored. At that
+        // point, the right stack pointer offset will also be restored, which
+        // should match the contents of the value stack.
+        masm.ensure_sp_for_jump(target_offset);
         dest.set_as_target();
         masm.jmp(*dest.label());
         self.reachable = false;
     }
 
-    /// Handles the emission of the ABI result. This function is used at the end
-    /// of a block or function to pop the results from the value stack into the
-    /// corresponding ABI result representation.
-    pub fn pop_abi_results<M: MacroAssembler>(&mut self, result: &ABIResult, masm: &mut M) {
-        match result {
-            ABIResult::Void => {}
-            ABIResult::Reg { reg, .. } => {
-                let TypedReg { reg, ty: _ } = self.pop_to_reg(masm, Some(*reg));
-                self.free_reg(reg);
+    /// Push the ABI representation of the results stack.
+    pub fn push_abi_results<M, F>(
+        &mut self,
+        results: &ABIResults,
+        masm: &mut M,
+        mut calculate_ret_area: F,
+    ) where
+        M: MacroAssembler,
+        F: FnMut(&ABIResults, &mut CodeGenContext, &mut M) -> Option<RetArea>,
+    {
+        let area = results
+            .on_stack()
+            .then(|| calculate_ret_area(&results, self, masm).unwrap());
+
+        for operand in results.operands().iter() {
+            match operand {
+                ABIOperand::Reg { reg, ty, .. } => {
+                    assert!(self.regalloc.reg_available(*reg));
+                    let typed_reg = TypedReg::new(*ty, self.reg(*reg, masm));
+                    self.stack.push(typed_reg.into());
+                }
+                ABIOperand::Stack { ty, offset, size } => match area.unwrap() {
+                    RetArea::SP(sp_offset) => {
+                        let slot =
+                            StackSlot::new(SPOffset::from_u32(sp_offset.as_u32() - offset), *size);
+                        self.stack.push(Val::mem(*ty, slot));
+                    }
+                    // This function is only expected to be called when dealing
+                    // with control flow and when calling functions; as a
+                    // callee, only [Self::pop_abi_results] is needed when
+                    // finalizing the function compilation.
+                    _ => unreachable!(),
+                },
             }
         }
     }
 
-    /// Push ABI results in to the value stack. This function is used at the end
-    /// of a block or after a function call to push the corresponding ABI
-    /// results into the value stack.
-    pub fn push_abi_results<M: MacroAssembler>(&mut self, result: &ABIResult, masm: &mut M) {
-        match result {
-            ABIResult::Void => {}
-            ABIResult::Reg { ty, reg } => {
-                assert!(self.regalloc.reg_available(*reg));
-                let typed_reg = TypedReg::new(*ty, self.reg(*reg, masm));
-                self.stack.push(typed_reg.into());
-            }
+    /// Truncates the value stack to the specified target.
+    /// This function is intended to only be used when restoring the code
+    /// generation's reachability state, when handling an unreachable end or
+    /// else.
+    pub fn truncate_stack_to(&mut self, target: usize) {
+        if self.stack.len() > target {
+            self.drop_last(self.stack.len() - target, |regalloc, val| match val {
+                Val::Reg(tr) => regalloc.free(tr.reg),
+                _ => {}
+            });
         }
     }
 
-    /// Pops the value at the stack top and assigns it to the local at
-    /// the given index, returning the typed register holding the
-    /// source value.
-    pub fn set_local<M: MacroAssembler>(&mut self, masm: &mut M, index: u32) -> TypedReg {
-        let slot = self
-            .frame
-            .get_local(index)
-            .unwrap_or_else(|| panic!("invalid local slot = {}", index));
-        let size: OperandSize = slot.ty.into();
-        let src = self.pop_to_reg(masm, None);
-        let addr = masm.local_address(&slot);
-        masm.store(RegImm::reg(src.reg), addr, size);
-
-        src
+    /// Load the [VMContext] pointer into the designated pinned register.
+    pub fn load_vmctx<M>(&mut self, masm: &mut M)
+    where
+        M: MacroAssembler,
+    {
+        let addr = masm.local_address(&self.frame.vmctx_slot);
+        masm.load_ptr(addr, vmctx!(M));
     }
 
     /// Spill locals and registers to memory.
-    // TODO optimize the spill range;
-    //
-    // At any point in the program, the stack
-    // might already contain Memory entries;
-    // we could effectively ignore that range;
-    // only focusing on the range that contains
-    // spillable values.
+    // TODO: optimize the spill range;
+    // At any point in the program, the stack might already contain memory
+    // entries; we could effectively ignore that range; only focusing on the
+    // range that contains spillable values.
     fn spill_impl<M: MacroAssembler>(
         stack: &mut Stack,
         regalloc: &mut RegAlloc,
@@ -411,9 +580,9 @@ impl<'a> CodeGenContext<'a> {
                 *v = Val::mem(r.ty, slot);
             }
             Val::Local(local) => {
-                let slot = frame.get_local(local.index).expect("valid local at slot");
+                let slot = frame.get_wasm_local(local.index);
                 let addr = masm.local_address(&slot);
-                let scratch = <M::ABI as ABI>::scratch_reg();
+                let scratch = scratch!(M, &slot.ty);
                 masm.load(addr, scratch, slot.ty.into());
                 let stack_slot = masm.push(scratch, slot.ty.into());
                 *v = Val::mem(slot.ty, stack_slot);
diff --git a/winch/codegen/src/codegen/control.rs b/winch/codegen/src/codegen/control.rs
index a726cff1d157..1d6d10ed9ded 100644
--- a/winch/codegen/src/codegen/control.rs
+++ b/winch/codegen/src/codegen/control.rs
@@ -1,43 +1,198 @@
 //! Data structures for control flow emission.
 //!
-//! As of the current implementation, Winch doesn't offer support for the
-//! multi-value proposal, which in the context of control flow constructs it
-//! means that blocks don't take any params and produce 0 or 1 return. The
-//! intention is to implement support for multi-value across the compiler, when
-//! that time comes, here are some general changes that will be needed for
-//! control flow:
-//!
-//! * Consider having a copy of the block params on the side, and push them when
-//! encountering an else or duplicate the block params upfront. If no else is
-//! present, clean the extra copies from the stack.
-//!
-//! * Eagerly load the block params. Params can flow "downward" as the block
-//! results in the case of an empty then or else block:
-//!   (module
-//!     (func (export "params") (param i32) (result i32)
-//!       (i32.const 2)
-//!       (if (param i32) (result i32) (local.get 0)
-//!       (then))
-//!     (i32.const 3)
-//!     (i32.add)
-//!   )
-//!
-//! As a future optimization, we could perform a look ahead to the next
-//! instruction when reaching any of the comparison instructions. If the next
-//! instruction is a control instruction, we could avoid emitting
+//! Winch currently doesn't apply any sort of optimizations to control flow, but
+//! as a future optimization, for starters, we could perform a look ahead to the
+//! next instruction when reaching any of the comparison instructions. If the
+//! next instruction is a control instruction, we could avoid emitting
 //! a [`crate::masm::MacroAssembler::cmp_with_set`] and instead emit
 //! a conditional jump inline when emitting the control flow instruction.
-
-use super::{CodeGenContext, MacroAssembler, OperandSize};
+use super::{CodeGenContext, OperandSize, Reg, TypedReg};
 use crate::{
-    abi::{ABIResult, ABI},
-    masm::CmpKind,
+    abi::{ABIOperand, ABIResults, ABISig, RetArea, ABI},
+    masm::{IntCmpKind, MacroAssembler, MemMoveDirection, RegImm, SPOffset},
+    stack::Val,
     CallingConvention,
 };
 use cranelift_codegen::MachLabel;
-use wasmtime_environ::WasmType;
+use wasmtime_environ::{WasmFuncType, WasmValType};
+
+/// Categorization of the type of the block.
+#[derive(Debug, Clone)]
+pub(crate) enum BlockType {
+    /// Doesn't produce or consume any values.
+    Void,
+    /// Produces a single value.
+    Single(WasmValType),
+    /// Consumes multiple values and produces multiple values.
+    Func(WasmFuncType),
+    /// An already resolved ABI signature.
+    ABISig(ABISig),
+}
+
+/// Holds all the information about the signature of the block.
+#[derive(Debug, Clone)]
+pub(crate) struct BlockSig {
+    /// The type of the block.
+    pub ty: BlockType,
+    /// ABI representation of the results of the block.
+    results: Option<ABIResults>,
+    /// ABI representation of the params of the block interpreted as results.
+    params: Option<ABIResults>,
+}
+
+impl BlockSig {
+    /// Create a new [BlockSig].
+    pub fn new(ty: BlockType) -> Self {
+        Self {
+            ty,
+            results: None,
+            params: None,
+        }
+    }
+
+    /// Create a new [BlockSig] from an [ABISig].
+    pub fn from_sig(sig: ABISig) -> Self {
+        Self {
+            ty: BlockType::sig(sig),
+            results: None,
+            params: None,
+        }
+    }
+
+    /// Return the ABI representation of the results of the block.
+    /// This method will lazily initialize the results if not present.
+    pub fn results<M>(&mut self) -> &mut ABIResults
+    where
+        M: MacroAssembler,
+    {
+        if self.ty.is_sig() {
+            return match &mut self.ty {
+                BlockType::ABISig(sig) => &mut sig.results,
+                _ => unreachable!(),
+            };
+        }
+
+        if self.results.is_some() {
+            return self.results.as_mut().unwrap();
+        }
+
+        let results = match &self.ty {
+            BlockType::Void => <M::ABI as ABI>::abi_results(&[], &CallingConvention::Default),
+            BlockType::Single(ty) => {
+                <M::ABI as ABI>::abi_results(&[*ty], &CallingConvention::Default)
+            }
+            BlockType::Func(f) => {
+                <M::ABI as ABI>::abi_results(f.returns(), &CallingConvention::Default)
+            }
+            BlockType::ABISig(_) => unreachable!(),
+        };
+
+        self.results = Some(results);
+        self.results.as_mut().unwrap()
+    }
+
+    /// Construct an ABI result representation of the params of the block.
+    /// This is needed for loops and for handling cases in which params flow as
+    /// the block's results, i.e. in the presence of an empty then or else.
+    pub fn params<M>(&mut self) -> &mut ABIResults
+    where
+        M: MacroAssembler,
+    {
+        if self.params.is_some() {
+            return self.params.as_mut().unwrap();
+        }
+
+        let params_as_results = match &self.ty {
+            BlockType::Void | BlockType::Single(_) => {
+                <M::ABI as ABI>::abi_results(&[], &CallingConvention::Default)
+            }
+            BlockType::Func(f) => {
+                <M::ABI as ABI>::abi_results(f.params(), &CallingConvention::Default)
+            }
+            // Once we have created a block type from a known signature, we
+            // can't modify its meaning. This should only be used for the
+            // function body block, in which case there's no need for treating
+            // params as results.
+            BlockType::ABISig(_) => unreachable!(),
+        };
+
+        self.params = Some(params_as_results);
+        self.params.as_mut().unwrap()
+    }
+
+    /// Returns the signature param count.
+    pub fn param_count(&self) -> usize {
+        match &self.ty {
+            BlockType::Void | BlockType::Single(_) => 0,
+            BlockType::Func(f) => f.params().len(),
+            BlockType::ABISig(sig) => sig.params_without_retptr().len(),
+        }
+    }
+
+    /// Returns the signature return count.
+    pub fn return_count(&self) -> usize {
+        match &self.ty {
+            BlockType::Void => 0,
+            BlockType::Single(_) => 1,
+            BlockType::Func(f) => f.returns().len(),
+            BlockType::ABISig(sig) => sig.results().len(),
+        }
+    }
+}
+
+impl BlockType {
+    /// Create a [BlockType::Void].
+    pub fn void() -> Self {
+        Self::Void
+    }
+
+    /// Create a [BlockType::Single] from the given [WasmType].
+    pub fn single(ty: WasmValType) -> Self {
+        Self::Single(ty)
+    }
+
+    /// Create a [BlockType::Func] from the given [WasmFuncType].
+    pub fn func(ty: WasmFuncType) -> Self {
+        Self::Func(ty)
+    }
+
+    /// Create a [BlockType::ABISig].
+    pub fn sig(sig: ABISig) -> Self {
+        Self::ABISig(sig)
+    }
+
+    /// Returns true if the type of the block is [BlockType::ABISig].
+    pub fn is_sig(&self) -> bool {
+        match self {
+            Self::ABISig(_) => true,
+            _ => false,
+        }
+    }
+}
 
-/// Holds the necessary metdata to support the emission
+/// The expected value and machine stack state when entering and exiting the block.
+#[derive(Debug, Default, Copy, Clone)]
+pub(crate) struct StackState {
+    /// The base stack pointer offset.
+    /// This offset is set when entering the block, after saving any live
+    /// registers and locals.
+    /// It is calculated by subtracting the size, in bytes, of any block params
+    /// to the current stack pointer offset.
+    pub base_offset: SPOffset,
+    /// The target stack pointer offset.
+    /// This offset is calculated by adding the size of the stack results
+    /// to the base stack pointer offset.
+    pub target_offset: SPOffset,
+    /// The base length of the value stack when entering the block.
+    /// Which is the current length of the value stack minus any block parameters.
+    pub base_len: usize,
+    /// The target length of the value stack when exiting the block.
+    /// Calculate by adding the number of results to the base value stack
+    /// length.
+    pub target_len: usize,
+}
+
+/// Holds the all the metadata to support the emission
 /// of control flow instructions.
 #[derive(Debug)]
 pub(crate) enum ControlStackFrame {
@@ -46,105 +201,77 @@ pub(crate) enum ControlStackFrame {
         cont: MachLabel,
         /// The exit label of the block.
         exit: MachLabel,
-        /// The return values of the block.
-        result: ABIResult,
-        /// The size of the value stack at the beginning of the If.
-        original_stack_len: usize,
-        /// The stack pointer offset at the beginning of the If.
-        original_sp_offset: u32,
+        /// The signature of the block.
+        sig: BlockSig,
+        /// The stack state of the block.
+        stack_state: StackState,
         /// Local reachability state when entering the block.
         reachable: bool,
     },
     Else {
         /// The exit label of the block.
         exit: MachLabel,
-        /// The return values of the block.
-        result: ABIResult,
-        /// The size of the value stack at the beginning of the Else.
-        original_stack_len: usize,
-        /// The stack pointer offset at the beginning of the Else.
-        original_sp_offset: u32,
+        /// The signature of the block.
+        sig: BlockSig,
+        /// The stack state of the block.
+        stack_state: StackState,
         /// Local reachability state when entering the block.
         reachable: bool,
     },
     Block {
         /// The block exit label.
         exit: MachLabel,
-        /// The size of the value stack at the beginning of the block.
-        original_stack_len: usize,
-        /// The return values of the block.
-        result: ABIResult,
-        /// The stack pointer offset at the beginning of the Block.
-        original_sp_offset: u32,
+        /// The signature of the block.
+        sig: BlockSig,
+        /// The stack state of the block.
+        stack_state: StackState,
         /// Exit state of the block.
         ///
-        /// This flag is used to dertermine if a block is a branch
+        /// This flag is used to determine if a block is a branch
         /// target. By default, this is false, and it's updated when
         /// emitting a `br` or `br_if`.
         is_branch_target: bool,
     },
     Loop {
-        /// The start of the loop.
+        /// The start of the Loop.
         head: MachLabel,
-        /// The size of the value stack at the beginning of the block.
-        original_stack_len: usize,
-        /// The stack pointer offset at the beginning of the Block.
-        original_sp_offset: u32,
-        /// The return values of the block.
-        result: ABIResult,
+        /// The stack state of the block.
+        stack_state: StackState,
+        /// The signature of the block.
+        sig: BlockSig,
     },
 }
 
 impl ControlStackFrame {
     /// Returns [`ControlStackFrame`] for an if.
-    pub fn if_<M: MacroAssembler>(
-        returns: &[WasmType],
+    pub fn r#if<M: MacroAssembler>(
+        sig: BlockSig,
         masm: &mut M,
         context: &mut CodeGenContext,
     ) -> Self {
-        let result = <M::ABI as ABI>::result(&returns, &CallingConvention::Default);
         let mut control = Self::If {
             cont: masm.get_label(),
             exit: masm.get_label(),
-            result,
+            sig,
             reachable: context.reachable,
-            original_stack_len: 0,
-            original_sp_offset: 0,
+            stack_state: Default::default(),
         };
 
         control.emit(masm, context);
         control
     }
 
-    /// Creates a block that represents the base
-    /// block for the function body.
-    pub fn function_body_block<M: MacroAssembler>(
-        result: ABIResult,
-        masm: &mut M,
-        context: &mut CodeGenContext,
-    ) -> Self {
-        Self::Block {
-            original_stack_len: context.stack.len(),
-            result,
-            is_branch_target: false,
-            exit: masm.get_label(),
-            original_sp_offset: masm.sp_offset(),
-        }
-    }
-
     /// Returns [`ControlStackFrame`] for a block.
     pub fn block<M: MacroAssembler>(
-        returns: &[WasmType],
+        sig: BlockSig,
         masm: &mut M,
         context: &mut CodeGenContext,
     ) -> Self {
-        let result = <M::ABI as ABI>::result(&returns, &CallingConvention::Default);
         let mut control = Self::Block {
-            original_stack_len: 0,
-            result,
+            sig,
             is_branch_target: false,
             exit: masm.get_label(),
-            original_sp_offset: 0,
+            stack_state: Default::default(),
         };
 
         control.emit(masm, context);
@@ -152,23 +279,142 @@ impl ControlStackFrame {
     }
 
     /// Returns [`ControlStackFrame`] for a loop.
-    pub fn loop_<M: MacroAssembler>(
-        returns: &[WasmType],
+    pub fn r#loop<M: MacroAssembler>(
+        sig: BlockSig,
         masm: &mut M,
         context: &mut CodeGenContext,
     ) -> Self {
-        let result = <M::ABI as ABI>::result(&returns, &CallingConvention::Default);
         let mut control = Self::Loop {
-            original_stack_len: 0,
-            result,
+            stack_state: Default::default(),
+            sig,
             head: masm.get_label(),
-            original_sp_offset: 0,
         };
 
         control.emit(masm, context);
         control
     }
 
+    fn init<M: MacroAssembler>(&mut self, masm: &mut M, context: &mut CodeGenContext) {
+        self.calculate_stack_state(context, masm);
+        // If the block has stack results, immediately resolve the return area
+        // base.
+        if self.results::<M>().on_stack() {
+            let results_base = self.stack_state().target_offset;
+            self.results::<M>().set_ret_area(RetArea::sp(results_base));
+        }
+
+        if self.is_if() || self.is_loop() {
+            // Preemptively handle block params as results so that the params
+            // are correctly placed in memory. This is especially
+            // important for control flow joins with empty blocks:
+            //
+            //(module
+            //  (func (export "params") (param i32) (result i32)
+            //       (i32.const 2)
+            //       (if (param i32) (result i32) (local.get 0)
+            //       (then))
+            //     (i32.const 3)
+            //     (i32.add)
+            //   )
+            //)
+            let base_offset = self.stack_state().base_offset;
+            if self.params::<M>().on_stack() {
+                let offset = base_offset.as_u32() + self.params::<M>().size();
+                self.params::<M>()
+                    .set_ret_area(RetArea::sp(SPOffset::from_u32(offset)));
+            }
+            Self::top_abi_results_impl(
+                self.params::<M>(),
+                context,
+                masm,
+                |params: &ABIResults, _, _| params.ret_area().copied(),
+            );
+        }
+    }
+
+    /// Calculates the [StackState] of the block.
+    fn calculate_stack_state<M: MacroAssembler>(
+        &mut self,
+        context: &mut CodeGenContext,
+        masm: &mut M,
+    ) {
+        use ControlStackFrame::*;
+        let sig = self.sig();
+        // If the block type contains a full [ABISig], do not take into account
+        // the params, since these are the params of the function that is
+        // currently being compiled and the value stack doesn't currently
+        // contain any values anyway.
+        let param_count = if sig.ty.is_sig() {
+            0
+        } else {
+            sig.param_count()
+        };
+        let return_count = sig.return_count();
+        debug_assert!(context.stack.len() >= param_count);
+        let results_size = self.results::<M>().size();
+
+        // Save any live registers and locals.
+        context.spill(masm);
+
+        let base_len = context.stack.len() - param_count;
+        let stack_consumed = context.stack.sizeof(param_count);
+        let current_sp = masm.sp_offset();
+        let base_offset = SPOffset::from_u32(current_sp.as_u32() - stack_consumed);
+
+        match self {
+            If { stack_state, .. } | Block { stack_state, .. } | Loop { stack_state, .. } => {
+                stack_state.base_offset = base_offset;
+                stack_state.base_len = base_len;
+                stack_state.target_offset = SPOffset::from_u32(base_offset.as_u32() + results_size);
+                stack_state.target_len = base_len + return_count;
+            }
+            _ => {}
+        }
+    }
+
+    /// This function ensures that the state of the -- machine and value --
+    /// stack  is the right one when reaching a control frame branch in which
+    /// reachability is restored or when reaching the end of a function in an
+    /// unreachable state. This function is intended to be called when handling
+    /// an unreachable else or end.
+    //
+    /// This function will truncate the value stack to the base length of
+    /// the control frame and will also set the stack pointer offset to reflect
+    /// the offset expected by the target branch.
+    ///
+    // NB: This method is assumed to be called *before* pushing any block
+    // results to the value stack, so that any excess values are cleaned up.
+    pub fn ensure_stack_state<M: MacroAssembler>(
+        &mut self,
+        masm: &mut M,
+        context: &mut CodeGenContext,
+    ) {
+        let state = self.stack_state();
+        // This assumes that at jump sites, the machine stack pointer will be
+        // adjusted to match the expectations of the target branch (e.g.
+        // `target_offset`); after performing the jump, the MacroAssembler
+        // implementation will soft-reset the stack pointer offset to its
+        // original offset, ensure that other parts of the program have access
+        // to the right offset, this is especially important in conditional
+        // branches.
+        // When restoring reachability we ensure that the MacroAssembler offset
+        // is set to match the expectations of the target branch, similar to how
+        // the machine stack pointer was adjusted at jump sites.
+        masm.reset_stack_pointer(state.target_offset);
+        // We use the base length, because this function is assumed to be called
+        // *before* pushing any results to the value stack. This way, any excess
+        // values will be discarded.
+        context.truncate_stack_to(state.base_len);
+    }
+
+    /// Return the type information of the block.
+    pub fn sig(&self) -> &BlockSig {
+        use ControlStackFrame::*;
+        match self {
+            If { sig, .. } | Else { sig, .. } | Loop { sig, .. } | Block { sig, .. } => sig,
+        }
+    }
+
     fn emit<M: MacroAssembler>(&mut self, masm: &mut M, context: &mut CodeGenContext) {
         use ControlStackFrame::*;
 
@@ -177,53 +423,30 @@ impl ControlStackFrame {
             return;
         }
 
-        match self {
-            If {
-                cont,
-                original_stack_len,
-                original_sp_offset,
-                ..
-            } => {
+        match *self {
+            If { cont, .. } => {
                 // Pop the condition value.
-                let top = context.pop_to_reg(masm, None);
-
-                // Unconditionall spill before emitting control flow.
-                context.spill(masm);
-
-                *original_stack_len = context.stack.len();
-                *original_sp_offset = masm.sp_offset();
+                // Because in the case of Self::If, Self::init, will top the
+                // branch params, we exclude any result registers from being
+                // used as the branch test.
+                let top =
+                    context.without::<_, _, _>(self.params::<M>().regs(), masm, |cx, masm| {
+                        cx.pop_to_reg(masm, None)
+                    });
+                self.init(masm, context);
                 masm.branch(
-                    CmpKind::Eq,
+                    IntCmpKind::Eq,
                     top.reg.into(),
                     top.reg.into(),
-                    *cont,
+                    cont,
                     OperandSize::S32,
                 );
                 context.free_reg(top);
             }
-            Block {
-                original_stack_len,
-                original_sp_offset,
-                ..
-            } => {
-                // Unconditional spill before entering the block.
-                // We assume that there are no live registers when
-                // exiting the block.
-                context.spill(masm);
-                *original_stack_len = context.stack.len();
-                *original_sp_offset = masm.sp_offset();
-            }
-            Loop {
-                original_stack_len,
-                original_sp_offset,
-                head,
-                ..
-            } => {
-                // Unconditional spill before entering the loop block.
-                context.spill(masm);
-                *original_stack_len = context.stack.len();
-                *original_sp_offset = masm.sp_offset();
-                masm.bind(*head);
+            Block { .. } => self.init(masm, context),
+            Loop { head, .. } => {
+                self.init(masm, context);
+                masm.bind(head);
             }
             _ => unreachable!(),
         }
@@ -232,51 +455,53 @@ impl ControlStackFrame {
     /// Handles the else branch if the current control stack frame is
     /// [`ControlStackFrame::If`].
     pub fn emit_else<M: MacroAssembler>(&mut self, masm: &mut M, context: &mut CodeGenContext) {
-        use ControlStackFrame::*;
-        match self {
-            If {
-                result,
-                original_stack_len,
-                exit,
-                ..
-            } => {
-                assert!((*original_stack_len + result.len()) == context.stack.len());
-                // Before emitting an unconditional jump to the exit branch,
-                // we handle the result of the if-then block.
-                context.pop_abi_results(&result, masm);
-                // Before binding the else branch, we emit the jump to the end
-                // label.
-                masm.jmp(*exit);
-                // Bind the else branch.
-                self.bind_else(masm, context.reachable);
-            }
-            _ => unreachable!(),
-        }
+        debug_assert!(self.is_if());
+        let state = self.stack_state();
+
+        debug_assert_eq!(state.target_len, context.stack.len());
+        self.pop_abi_results(context, masm, |results, _, _| results.ret_area().copied());
+        masm.jmp(*self.exit_label().unwrap());
+        self.bind_else(masm, context);
     }
 
     /// Binds the else branch label and converts `self` to
     /// [`ControlStackFrame::Else`].
-    pub fn bind_else<M: MacroAssembler>(&mut self, masm: &mut M, reachable: bool) {
+    pub fn bind_else<M: MacroAssembler>(&mut self, masm: &mut M, context: &mut CodeGenContext) {
         use ControlStackFrame::*;
         match self {
             If {
                 cont,
-                result,
-                original_stack_len,
-                original_sp_offset,
+                sig,
+                stack_state,
                 exit,
                 ..
             } => {
                 // Bind the else branch.
                 masm.bind(*cont);
 
+                // Push the abi results to the value stack, so that they are
+                // used as params for the else branch. At the beginning of the
+                // if block, any params are preemptively resolved as results;
+                // when reaching the else all params are already materialized as
+                // stack results. As part of ensuring the right state when
+                // entering the else branch, the following snippet also soft
+                // resets the stack pointer so that it matches the expectations
+                // of the else branch: the stack pointer is expected to be at
+                // the base stack pointer, plus the params stack size in bytes.
+                let params_size = sig.params::<M>().size();
+                context.push_abi_results::<M, _>(sig.params::<M>(), masm, |params, _, _| {
+                    params.ret_area().copied()
+                });
+                masm.reset_stack_pointer(SPOffset::from_u32(
+                    stack_state.base_offset.as_u32() + params_size,
+                ));
+
                 // Update the stack control frame with an else control frame.
                 *self = ControlStackFrame::Else {
                     exit: *exit,
-                    original_stack_len: *original_stack_len,
-                    result: *result,
-                    reachable,
-                    original_sp_offset: *original_sp_offset,
+                    stack_state: *stack_state,
+                    reachable: context.reachable,
+                    sig: sig.clone(),
                 };
             }
             _ => unreachable!(),
@@ -287,45 +512,22 @@ impl ControlStackFrame {
     pub fn emit_end<M: MacroAssembler>(&mut self, masm: &mut M, context: &mut CodeGenContext) {
         use ControlStackFrame::*;
         match self {
-            If {
-                result,
-                original_stack_len,
-                ..
-            }
-            | Else {
-                result,
-                original_stack_len,
-                ..
-            } => {
-                assert!((*original_stack_len + result.len()) == context.stack.len());
+            If { stack_state, .. } | Else { stack_state, .. } | Block { stack_state, .. } => {
+                debug_assert_eq!(stack_state.target_len, context.stack.len());
                 // Before binding the exit label, we handle the block results.
-                context.pop_abi_results(&result, masm);
+                self.pop_abi_results(context, masm, |results, _, _| results.ret_area().copied());
                 self.bind_end(masm, context);
             }
-            Block {
-                original_stack_len,
-                result,
-                ..
-            } => {
-                assert!((*original_stack_len + result.len()) == context.stack.len());
-                context.pop_abi_results(&result, masm);
-                self.bind_end(masm, context);
-            }
-            Loop {
-                result,
-                original_stack_len,
-                ..
-            } => {
-                assert!((*original_stack_len + result.len()) == context.stack.len());
+            Loop { stack_state, .. } => {
+                debug_assert_eq!(stack_state.target_len, context.stack.len());
             }
         }
     }
 
     /// Binds the exit label of the current control stack frame and pushes the
     /// ABI results to the value stack.
-    pub fn bind_end<M: MacroAssembler>(&self, masm: &mut M, context: &mut CodeGenContext) {
-        // Push the results to the value stack.
-        context.push_abi_results(self.result(), masm);
+    pub fn bind_end<M: MacroAssembler>(&mut self, masm: &mut M, context: &mut CodeGenContext) {
+        self.push_abi_results(context, masm);
         self.bind_exit_label(masm);
     }
 
@@ -379,17 +581,349 @@ impl ControlStackFrame {
         }
     }
 
-    /// Returns [`crate::abi::ABIResult`] of the control stack frame
+    /// Returns [`crate::abi::ABIResults`] of the control stack frame
     /// block.
-    pub fn result(&self) -> &ABIResult {
+    pub fn results<M>(&mut self) -> &mut ABIResults
+    where
+        M: MacroAssembler,
+    {
         use ControlStackFrame::*;
 
         match self {
-            If { result, .. }
-            | Else { result, .. }
-            | Block { result, .. }
-            | Loop { result, .. } => result,
+            If { sig, .. } | Else { sig, .. } | Block { sig, .. } => sig.results::<M>(),
+            Loop { sig, .. } => sig.params::<M>(),
+        }
+    }
+
+    /// Returns the block params interpreted as [crate::abi::ABIResults].
+    pub fn params<M>(&mut self) -> &mut ABIResults
+    where
+        M: MacroAssembler,
+    {
+        use ControlStackFrame::*;
+        match self {
+            If { sig, .. } | Else { sig, .. } | Block { sig, .. } | Loop { sig, .. } => {
+                sig.params::<M>()
+            }
+        }
+    }
+
+    /// Orchestrates how block results are handled.
+    /// Results are handled in reverse order, starting from register results
+    /// continuing to memory values. This guarantees that the stack ordering
+    /// invariant is maintained. See [ABIResults] for more details.
+    ///
+    /// This function will iterate through each result and invoke the provided
+    /// callback if there are results on the stack.
+    ///
+    /// Calculating the return area involves ensuring that there's enough stack
+    /// space to store the block's results. To make the process of handling
+    /// multiple results easier, this function will save all live registers and
+    /// locals right after handling any register results. This will ensure that
+    /// the top `n` values in the value stack are correctly placed in the memory
+    /// locations corresponding to multiple stack results. Once the iteration
+    /// over all the results is done, the stack result area of the block will be
+    /// updated.
+    pub fn pop_abi_results<M, F>(
+        &mut self,
+        context: &mut CodeGenContext,
+        masm: &mut M,
+        calculate_ret_area: F,
+    ) where
+        M: MacroAssembler,
+        F: FnMut(&ABIResults, &mut CodeGenContext, &mut M) -> Option<RetArea>,
+    {
+        Self::pop_abi_results_impl(self.results::<M>(), context, masm, calculate_ret_area)
+    }
+
+    /// Shared implementation for poppping the ABI results.
+    /// This is needed because, in some cases, params must be interpreted and
+    /// used as the results of the block. When emitting code at control flow
+    /// joins, the block params are interpreted as results, to ensure that they
+    /// can correctly "flow" as the results of the block. This is especially
+    /// important in the presence of empty then, else and loop blocks. This
+    /// interpretation is an internal detail of the control module, and having
+    /// a shared implementation allows the caller to decide how the
+    /// results should be interpreted.
+    pub fn pop_abi_results_impl<M, F>(
+        results: &mut ABIResults,
+        context: &mut CodeGenContext,
+        masm: &mut M,
+        mut calculate_ret_area: F,
+    ) where
+        M: MacroAssembler,
+        F: FnMut(&ABIResults, &mut CodeGenContext, &mut M) -> Option<RetArea>,
+    {
+        let mut iter = results.operands().iter().rev().peekable();
+
+        while let Some(ABIOperand::Reg { reg, .. }) = iter.peek() {
+            let TypedReg { reg, .. } = context.pop_to_reg(masm, Some(*reg));
+            context.free_reg(reg);
+            iter.next().unwrap();
+        }
+
+        let ret_area = calculate_ret_area(results, context, masm);
+
+        let retptr = Self::maybe_load_retptr(ret_area.as_ref(), &results, context, masm);
+        if let Some(area) = ret_area {
+            if area.is_sp() {
+                Self::ensure_ret_area(&area, context, masm);
+            }
+        }
+
+        if let Some(retptr) = retptr {
+            while let Some(ABIOperand::Stack { offset, .. }) = iter.peek() {
+                let addr = masm.address_at_reg(retptr, *offset);
+                context.pop_to_addr(masm, addr);
+                iter.next().unwrap();
+            }
+            context.free_reg(retptr);
+        }
+
+        if let Some(area) = ret_area {
+            if area.is_sp() {
+                Self::adjust_stack_results(area, results, context, masm);
+            }
+        }
+    }
+
+    /// Convenience wrapper around [CodeGenContext::push_abi_results] using the
+    /// results of the current frame.
+    fn push_abi_results<M>(&mut self, context: &mut CodeGenContext, masm: &mut M)
+    where
+        M: MacroAssembler,
+    {
+        context.push_abi_results(self.results::<M>(), masm, |results, _, _| {
+            results.ret_area().copied()
+        })
+    }
+
+    /// Preemptively handles the ABI results of the current frame.
+    /// This function is meant to be used when emitting control flow with joins,
+    /// in which it's not possible to know at compile time which branch will be
+    /// taken.
+    pub fn top_abi_results<M, F>(
+        &mut self,
+        context: &mut CodeGenContext,
+        masm: &mut M,
+        calculate_ret_area: F,
+    ) where
+        M: MacroAssembler,
+        F: FnMut(&ABIResults, &mut CodeGenContext, &mut M) -> Option<RetArea>,
+    {
+        Self::top_abi_results_impl::<M, _>(self.results::<M>(), context, masm, calculate_ret_area)
+    }
+
+    /// Internal implementation of [Self::top_abi_results].
+    /// See [Self::pop_abi_results_impl] on why an internal implementation is
+    /// needed.
+    fn top_abi_results_impl<M, F>(
+        results: &mut ABIResults,
+        context: &mut CodeGenContext,
+        masm: &mut M,
+        mut calculate_ret_area: F,
+    ) where
+        M: MacroAssembler,
+        F: FnMut(&ABIResults, &mut CodeGenContext, &mut M) -> Option<RetArea>,
+    {
+        let mut area = None;
+        Self::pop_abi_results_impl::<M, _>(results, context, masm, |r, context, masm| {
+            area = calculate_ret_area(r, context, masm);
+            area
+        });
+        // Use the previously calculated area to ensure that the ret area is
+        // kept in sync between both operations.
+        context.push_abi_results::<M, _>(results, masm, |_, _, _| area);
+    }
+
+    // If the results on the stack are handled via the stack pointer, ensure
+    // that the stack results are correctly located. In general, since values in
+    // the value stack are spilled when exiting the block, the top `n` entries
+    // in the value stack, representing the `n` stack results of the block are
+    // almost correctly located. However, since constants are not
+    // spilled, their presence complicate block exits. For this reason, the
+    // last step for finalizing multiple block results involves:
+    // * Scanning the value stack from oldest to newest memory values and
+    // calculating the source and destination of each value, if the source
+    // is closer to the stack pointer (greater) than the destination,
+    // perform a memory move of the bytes to its destination, else stop,
+    // because the memory values are in place.
+    // * Scanning the value stack from newest to oldest and calculating the
+    // source and destination of each value, if the source is closer to the
+    // frame pointer (less) than the destination, perform a memory move of
+    // the bytes to its destination, else stop, because the memory values
+    // are in place.
+    // * Lastly, iterate over the top `n` elements of the value stack,
+    // and spill any constant values, placing them in their respective
+    // memory location.
+    //
+    // The implementation in Winch is inspired by how this is handled in
+    // SpiderMonkey's WebAssembly Baseline Compiler:
+    // https://wingolog.org/archives/2020/04/03/multi-value-webassembly-in-firefox-from-1-to-n
+    fn adjust_stack_results<M>(
+        ret_area: RetArea,
+        results: &ABIResults,
+        context: &mut CodeGenContext,
+        masm: &mut M,
+    ) where
+        M: MacroAssembler,
+    {
+        debug_assert!(ret_area.is_sp());
+        let results_offset = ret_area.unwrap_sp();
+
+        // Start iterating from memory values that are closer to the
+        // frame pointer (oldest entries first).
+        for (i, operand) in results.operands().iter().enumerate() {
+            if operand.is_reg() {
+                break;
+            }
+
+            let value_index = (context.stack.len() - results.stack_operands_len()) + i;
+            let val = context.stack.inner()[value_index];
+
+            match (val, operand) {
+                (Val::Memory(mem), ABIOperand::Stack { offset, size, .. }) => {
+                    let dst = results_offset.as_u32() - *offset;
+                    let src = mem.slot.offset;
+
+                    // Values are moved from lower (SP) to higher (FP)
+                    // addresses.
+                    if src.as_u32() <= dst {
+                        break;
+                    }
+
+                    masm.memmove(
+                        src,
+                        SPOffset::from_u32(dst),
+                        *size,
+                        MemMoveDirection::LowToHigh,
+                    );
+                }
+                _ => {}
+            }
+        }
+
+        // Start iterating from memory values that are closer to the
+        // stack pointer (newest entries first).
+        for (i, operand) in results
+            .operands()
+            .iter()
+            .rev()
+            // Skip any register results.
+            .skip(results.regs().len())
+            .enumerate()
+        {
+            let value_index = context.stack.len() - i - 1;
+            let val = context.stack.inner()[value_index];
+            match (val, operand) {
+                (Val::Memory(mem), ABIOperand::Stack { offset, size, .. }) => {
+                    let dst = results_offset.as_u32() - *offset;
+                    let src = mem.slot.offset;
+
+                    // Values are moved from higher (FP) to lower (SP)
+                    // addresses.
+                    if src.as_u32() >= dst {
+                        break;
+                    }
+
+                    masm.memmove(
+                        src,
+                        SPOffset::from_u32(dst),
+                        *size,
+                        MemMoveDirection::HighToLow,
+                    );
+                }
+                _ => {}
+            }
         }
+
+        // Finally store any constants in the value stack in their respective
+        // locations.
+        for operand in results
+            .operands()
+            .iter()
+            .take(results.stack_operands_len())
+            .rev()
+        {
+            // If we want to do this, we should start from newest, essentially from top to
+            // bottom in the iteration of the operands.
+            match (operand, context.stack.peek().unwrap()) {
+                (ABIOperand::Stack { ty, offset, .. }, Val::I32(v)) => {
+                    let addr =
+                        masm.address_from_sp(SPOffset::from_u32(results_offset.as_u32() - *offset));
+                    masm.store(RegImm::i32(*v), addr, (*ty).into());
+                }
+                (ABIOperand::Stack { ty, offset, .. }, Val::I64(v)) => {
+                    let addr =
+                        masm.address_from_sp(SPOffset::from_u32(results_offset.as_u32() - *offset));
+                    masm.store(RegImm::i64(*v), addr, (*ty).into());
+                }
+                (ABIOperand::Stack { ty, offset, .. }, Val::F32(v)) => {
+                    let addr =
+                        masm.address_from_sp(SPOffset::from_u32(results_offset.as_u32() - *offset));
+                    masm.store(RegImm::f32(v.bits()), addr, (*ty).into());
+                }
+                (ABIOperand::Stack { ty, offset, .. }, Val::F64(v)) => {
+                    let addr =
+                        masm.address_from_sp(SPOffset::from_u32(results_offset.as_u32() - *offset));
+                    masm.store(RegImm::f64(v.bits()), addr, (*ty).into());
+                }
+                (ABIOperand::Stack { ty, offset, .. }, Val::V128(v)) => {
+                    let addr =
+                        masm.address_at_sp(SPOffset::from_u32(results_offset.as_u32() - *offset));
+                    masm.store(RegImm::v128(*v), addr, (*ty).into())
+                }
+                (_, v) => debug_assert!(v.is_mem()),
+            }
+
+            let _ = context.stack.pop().unwrap();
+        }
+
+        // Adjust any excess stack space: the stack space after handling the
+        // block's results should be the exact amount needed by the return area.
+        debug_assert!(masm.sp_offset().as_u32() >= results_offset.as_u32());
+        masm.free_stack(masm.sp_offset().as_u32() - results_offset.as_u32());
+    }
+
+    /// Ensures that there is enough space for return values on the stack.
+    /// This function is called at the end of all blocks and when branching from
+    /// within blocks.
+    fn ensure_ret_area<M>(ret_area: &RetArea, context: &mut CodeGenContext, masm: &mut M)
+    where
+        M: MacroAssembler,
+    {
+        debug_assert!(ret_area.is_sp());
+        // Save any live registers and locals when exiting the block to ensure
+        // that the respective values are correctly located in memory.
+        // See [Self::adjust_stack_results] for more details.
+        context.spill(masm);
+        if ret_area.unwrap_sp() > masm.sp_offset() {
+            masm.reserve_stack(ret_area.unwrap_sp().as_u32() - masm.sp_offset().as_u32())
+        }
+    }
+
+    /// Loads the return pointer, if it exists, into the next available register.
+    fn maybe_load_retptr<M>(
+        ret_area: Option<&RetArea>,
+        results: &ABIResults,
+        context: &mut CodeGenContext,
+        masm: &mut M,
+    ) -> Option<Reg>
+    where
+        M: MacroAssembler,
+    {
+        ret_area
+            .map(|area| match area {
+                RetArea::Slot(slot) => {
+                    let base = context
+                        .without::<_, M, _>(results.regs(), masm, |cx, masm| cx.any_gpr(masm));
+                    let local_addr = masm.local_address(&slot);
+                    masm.load_ptr(local_addr, base);
+                    Some(base)
+                }
+                _ => None,
+            })
+            .flatten()
     }
 
     /// This function is used at the end of unreachable code handling
@@ -414,43 +948,30 @@ impl ControlStackFrame {
         }
     }
 
-    /// Returns the value stack length and stack pointer offset of the
-    /// control frame registered at entry.
-    pub fn original_stack_len_and_sp_offset(&self) -> (usize, u32) {
+    /// Returns a reference to the [StackState] of the block.
+    pub fn stack_state(&self) -> &StackState {
         use ControlStackFrame::*;
         match self {
-            If {
-                original_stack_len,
-                original_sp_offset,
-                ..
-            }
-            | Else {
-                original_stack_len,
-                original_sp_offset,
-                ..
-            }
-            | Block {
-                original_stack_len,
-                original_sp_offset,
-                ..
-            }
-            | Loop {
-                original_stack_len,
-                original_sp_offset,
-                ..
-            } => (*original_stack_len, *original_sp_offset),
+            If { stack_state, .. }
+            | Else { stack_state, .. }
+            | Block { stack_state, .. }
+            | Loop { stack_state, .. } => stack_state,
         }
     }
 
-    /// Resolves how to handle results when the current frame is a
-    /// jump target Notably in the case of loops we don't take into
-    /// account the frame's results, just the params (void until
-    /// multi-value is supported).
-    pub fn as_target_result(&self) -> ABIResult {
-        use ControlStackFrame::*;
+    /// Returns true if the current frame is [ControlStackFrame::If].
+    pub fn is_if(&self) -> bool {
+        match self {
+            Self::If { .. } => true,
+            _ => false,
+        }
+    }
+
+    /// Returns true if the current frame is [ControlStackFrame::Loop].
+    pub fn is_loop(&self) -> bool {
         match self {
-            Loop { .. } => ABIResult::void(),
-            f => *f.result(),
+            Self::Loop { .. } => true,
+            _ => false,
         }
     }
 }
diff --git a/winch/codegen/src/codegen/env.rs b/winch/codegen/src/codegen/env.rs
index 8e2d36c05f3f..772aff519080 100644
--- a/winch/codegen/src/codegen/env.rs
+++ b/winch/codegen/src/codegen/env.rs
@@ -1,167 +1,449 @@
-use crate::{codegen::BuiltinFunctions, CallingConvention};
-use smallvec::{smallvec, SmallVec};
+use crate::{
+    abi::{wasm_sig, ABISig, ABI},
+    codegen::{control, BlockSig, BuiltinFunction, BuiltinFunctions, OperandSize},
+    isa::TargetIsa,
+};
+use cranelift_codegen::ir::{UserExternalName, UserExternalNameRef};
+use std::collections::{
+    hash_map::Entry::{Occupied, Vacant},
+    HashMap,
+};
+use std::mem;
 use wasmparser::BlockType;
 use wasmtime_environ::{
-    FuncIndex, GlobalIndex, ModuleTranslation, ModuleTypes, PtrSize, TableIndex, TypeConvert,
-    TypeIndex, VMOffsets, WasmFuncType, WasmType,
+    BuiltinFunctionIndex, FuncIndex, GlobalIndex, MemoryIndex, MemoryPlan, MemoryStyle,
+    ModuleTranslation, ModuleTypesBuilder, PrimaryMap, PtrSize, TableIndex, TablePlan, TypeConvert,
+    TypeIndex, VMOffsets, WasmHeapType, WasmValType,
 };
 
+#[derive(Debug, Clone, Copy)]
+pub struct GlobalData {
+    /// The offset of the global.
+    pub offset: u32,
+    /// True if the global is imported.
+    pub imported: bool,
+    /// The WebAssembly type of the global.
+    pub ty: WasmValType,
+}
+
 /// Table metadata.
+#[derive(Debug, Copy, Clone)]
 pub struct TableData {
     /// The offset to the base of the table.
     pub offset: u32,
     /// The offset to the current elements field.
     pub current_elems_offset: u32,
-    /// If the table is imported, return the base
-    /// offset of the `from` field in `VMTableImport`.
-    pub base: Option<u32>,
-    /// The size of the table elements, in bytes.
-    pub element_size: u8,
+    /// If the table is imported, this field contains the offset to locate the
+    /// base of the table data.
+    pub import_from: Option<u32>,
+    /// The size of the table elements.
+    pub(crate) element_size: OperandSize,
+    /// The size of the current elements field.
+    pub(crate) current_elements_size: OperandSize,
+}
+
+/// Style of the heap.
+#[derive(Debug, Copy, Clone)]
+pub enum HeapStyle {
+    /// Static heap, which has a fixed address.
+    Static {
+        /// The heap bound in bytes, not including the bytes for the offset
+        /// guard pages.
+        bound: u64,
+    },
+    /// Dynamic heap, which can be relocated to a different address when grown.
+    /// The bounds are calculated at runtime on every access.
+    Dynamic,
+}
+
+/// Heap metadata.
+///
+/// Heaps represent a WebAssembly linear memory.
+#[derive(Debug, Copy, Clone)]
+pub struct HeapData {
+    /// The offset to the base of the heap.
+    /// Relative to the VMContext pointer if the WebAssembly memory is locally
+    /// defined. Else this is relative to the location of the imported WebAssembly
+    /// memory location.
+    pub offset: u32,
+    /// The offset to the current length field.
+    pub current_length_offset: u32,
+    /// If the WebAssembly memory is imported, this field contains the offset to locate the
+    /// base of the heap.
+    pub import_from: Option<u32>,
+    /// The memory type (32 or 64).
+    pub ty: WasmValType,
+    /// The style of the heap.
+    pub style: HeapStyle,
+    /// The guaranteed minimum size, in bytes.
+    pub min_size: u64,
+    /// The maximum heap size in bytes.
+    pub max_size: Option<u64>,
+    /// The log2 of this memory's page size, in bytes.
+    ///
+    /// By default the page size is 64KiB (0x10000; 2**16; 1<<16; 65536) but the
+    /// custom-page-sizes proposal allows opting into a page size of `1`.
+    pub page_size_log2: u8,
+    /// Size in bytes of the offset guard pages, located after the heap bounds.
+    pub offset_guard_size: u64,
 }
 
 /// A function callee.
 /// It categorizes how the callee should be treated
 /// when performing the call.
-pub enum Callee {
+#[derive(Clone)]
+pub(crate) enum Callee {
     /// Locally defined function.
-    Local(CalleeInfo),
+    Local(FuncIndex),
     /// Imported function.
-    Import(CalleeInfo),
+    Import(FuncIndex),
     /// Function reference.
-    FuncRef(WasmFuncType),
-}
-
-/// Metadata about a function callee. Used by the code generation to
-/// emit function calls to local or imported functions.
-pub struct CalleeInfo {
-    /// The function type.
-    pub ty: WasmFuncType,
-    /// The callee index in the WebAssembly function index space.
-    pub index: FuncIndex,
+    FuncRef(TypeIndex),
+    /// A built-in function.
+    Builtin(BuiltinFunction),
 }
 
 /// The function environment.
 ///
 /// Contains all information about the module and runtime that is accessible to
 /// to a particular function during code generation.
-pub struct FuncEnv<'a, P: PtrSize> {
+pub struct FuncEnv<'a, 'translation: 'a, 'data: 'translation, P: PtrSize> {
     /// Offsets to the fields within the `VMContext` ptr.
-    pub vmoffsets: VMOffsets<P>,
+    pub vmoffsets: &'a VMOffsets<P>,
     /// Metadata about the translation process of a WebAssembly module.
-    pub translation: &'a ModuleTranslation<'a>,
-    /// Metadata about the builtin functions.
-    pub builtins: BuiltinFunctions,
+    pub translation: &'translation ModuleTranslation<'data>,
     /// The module's function types.
-    pub types: &'a ModuleTypes,
+    pub types: &'translation ModuleTypesBuilder,
+    /// The built-in functions available to the JIT code.
+    pub builtins: &'translation mut BuiltinFunctions,
+    /// Track resolved table information.
+    resolved_tables: HashMap<TableIndex, TableData>,
+    /// Track resolved heap information.
+    resolved_heaps: HashMap<MemoryIndex, HeapData>,
+    /// A map from [FunctionIndex] to [ABISig], to keep track of the resolved
+    /// function callees.
+    resolved_callees: HashMap<FuncIndex, ABISig>,
+    /// A map from [TypeIndex] to [ABISig], to keep track of the resolved
+    /// indirect function signatures.
+    resolved_sigs: HashMap<TypeIndex, ABISig>,
+    /// A map from [GlobalIndex] to [GlobalData].
+    resolved_globals: HashMap<GlobalIndex, GlobalData>,
+    /// Pointer size represented as a WebAssembly type.
+    ptr_type: WasmValType,
+    /// Whether or not to enable Spectre mitigation on heap bounds checks.
+    heap_access_spectre_mitigation: bool,
+    /// Whether or not to enable Spectre mitigation on table element accesses.
+    table_access_spectre_mitigation: bool,
+    name_map: PrimaryMap<UserExternalNameRef, UserExternalName>,
+    name_intern: HashMap<UserExternalName, UserExternalNameRef>,
 }
 
-pub fn ptr_type_from_ptr_size(size: u8) -> WasmType {
+pub fn ptr_type_from_ptr_size(size: u8) -> WasmValType {
     (size == 8)
-        .then(|| WasmType::I64)
+        .then(|| WasmValType::I64)
         .unwrap_or_else(|| unimplemented!("Support for non-64-bit architectures"))
 }
 
-impl<'a, P: PtrSize> FuncEnv<'a, P> {
+impl<'a, 'translation, 'data, P: PtrSize> FuncEnv<'a, 'translation, 'data, P> {
     /// Create a new function environment.
     pub fn new(
-        ptr: P,
-        translation: &'a ModuleTranslation,
-        types: &'a ModuleTypes,
-        call_conv: CallingConvention,
+        vmoffsets: &'a VMOffsets<P>,
+        translation: &'translation ModuleTranslation<'data>,
+        types: &'translation ModuleTypesBuilder,
+        builtins: &'translation mut BuiltinFunctions,
+        isa: &dyn TargetIsa,
+        ptr_type: WasmValType,
     ) -> Self {
-        let vmoffsets = VMOffsets::new(ptr, &translation.module);
-        let size = vmoffsets.ptr.size();
-        let builtins_base = vmoffsets.vmctx_builtin_functions();
         Self {
             vmoffsets,
             translation,
-            builtins: BuiltinFunctions::new(size, call_conv, builtins_base),
             types,
+            resolved_tables: HashMap::new(),
+            resolved_heaps: HashMap::new(),
+            resolved_callees: HashMap::new(),
+            resolved_sigs: HashMap::new(),
+            resolved_globals: HashMap::new(),
+            ptr_type,
+            heap_access_spectre_mitigation: isa.flags().enable_heap_access_spectre_mitigation(),
+            table_access_spectre_mitigation: isa.flags().enable_table_access_spectre_mitigation(),
+            builtins,
+            name_map: Default::default(),
+            name_intern: Default::default(),
         }
     }
 
-    /// Returns a slice of types representing the caller and callee VMContext types.
-    pub(crate) fn vmctx_args_type(&self) -> [WasmType; 2] {
-        let ty = self.ptr_type();
-        [ty, ty]
-    }
-
     /// Derive the [`WasmType`] from the pointer size.
-    pub(crate) fn ptr_type(&self) -> WasmType {
-        ptr_type_from_ptr_size(self.ptr_size())
-    }
-
-    /// Returns the pointer size for the target ISA.
-    fn ptr_size(&self) -> u8 {
-        self.vmoffsets.ptr.size()
+    pub(crate) fn ptr_type(&self) -> WasmValType {
+        self.ptr_type
     }
 
     /// Resolves a [`Callee::FuncRef`] from a type index.
-    pub fn funcref(&self, idx: TypeIndex) -> Callee {
-        let sig_index = self.translation.module.types[idx].unwrap_function();
-        let ty = self.types[sig_index].clone();
-        Callee::FuncRef(ty)
+    pub(crate) fn funcref(&mut self, idx: TypeIndex) -> Callee {
+        Callee::FuncRef(idx)
     }
 
     /// Resolves a function [`Callee`] from an index.
-    pub fn callee_from_index(&self, idx: FuncIndex) -> Callee {
-        let types = &self.translation.get_types();
-        let ty = types[types.function_at(idx.as_u32())].unwrap_func();
-        let ty = self.translation.module.convert_func_type(ty);
+    pub(crate) fn callee_from_index(&mut self, idx: FuncIndex) -> Callee {
         let import = self.translation.module.is_imported_function(idx);
-
-        let info = CalleeInfo { ty, index: idx };
-
         if import {
-            Callee::Import(info)
+            Callee::Import(idx)
         } else {
-            Callee::Local(info)
+            Callee::Local(idx)
         }
     }
 
-    /// Resolves the type of the block in terms of [`wasmtime_environ::WasmType`].
-    pub fn resolve_block_type(&self, blockty: BlockType) -> SmallVec<[WasmType; 1]> {
+    /// Converts a [wasmparser::BlockType] into a [BlockSig].
+    pub(crate) fn resolve_block_sig(&self, ty: BlockType) -> BlockSig {
         use BlockType::*;
-        match blockty {
-            Empty => smallvec![],
-            Type(ty) => smallvec![self.translation.module.convert_valtype(ty)],
-            _ => unimplemented!("multi-value"),
+        match ty {
+            Empty => BlockSig::new(control::BlockType::void()),
+            Type(ty) => {
+                let ty = TypeConverter::new(self.translation, self.types).convert_valtype(ty);
+                BlockSig::new(control::BlockType::single(ty))
+            }
+            FuncType(idx) => {
+                let sig_index = self.translation.module.types[TypeIndex::from_u32(idx)];
+                let sig = self.types[sig_index].unwrap_func();
+                BlockSig::new(control::BlockType::func(sig.clone()))
+            }
         }
     }
 
-    /// Resolves the type and offset of a global at the given index.
-    pub fn resolve_global_type_and_offset(&self, index: GlobalIndex) -> (WasmType, u32) {
+    /// Resolves `GlobalData` of a global at the given index.
+    pub fn resolve_global(&mut self, index: GlobalIndex) -> GlobalData {
         let ty = self.translation.module.globals[index].wasm_ty;
-        let offset = match self.translation.module.defined_global_index(index) {
-            Some(defined_index) => self.vmoffsets.vmctx_vmglobal_definition(defined_index),
-            None => self.vmoffsets.vmctx_vmglobal_import_from(index),
+        let val = || match self.translation.module.defined_global_index(index) {
+            Some(defined_index) => GlobalData {
+                offset: self.vmoffsets.vmctx_vmglobal_definition(defined_index),
+                imported: false,
+                ty,
+            },
+            None => GlobalData {
+                offset: self.vmoffsets.vmctx_vmglobal_import_from(index),
+                imported: true,
+                ty,
+            },
         };
 
-        (ty, offset)
+        *self.resolved_globals.entry(index).or_insert_with(val)
     }
 
     /// Returns the table information for the given table index.
-    pub fn resolve_table_data(&self, index: TableIndex) -> TableData {
-        let (from_offset, base_offset, current_elems_offset) =
-            match self.translation.module.defined_table_index(index) {
-                Some(defined) => (
-                    None,
-                    self.vmoffsets.vmctx_vmtable_definition_base(defined),
-                    self.vmoffsets
-                        .vmctx_vmtable_definition_current_elements(defined),
-                ),
-                None => (
-                    Some(self.vmoffsets.vmctx_vmtable_import_from(index)),
-                    self.vmoffsets.vmtable_definition_base().into(),
-                    self.vmoffsets.vmtable_definition_current_elements().into(),
-                ),
-            };
-
-        TableData {
-            base: from_offset,
-            offset: base_offset,
-            current_elems_offset,
-            element_size: self.vmoffsets.ptr.size(),
+    pub fn resolve_table_data(&mut self, index: TableIndex) -> TableData {
+        match self.resolved_tables.entry(index) {
+            Occupied(entry) => *entry.get(),
+            Vacant(entry) => {
+                let (from_offset, base_offset, current_elems_offset) =
+                    match self.translation.module.defined_table_index(index) {
+                        Some(defined) => (
+                            None,
+                            self.vmoffsets.vmctx_vmtable_definition_base(defined),
+                            self.vmoffsets
+                                .vmctx_vmtable_definition_current_elements(defined),
+                        ),
+                        None => (
+                            Some(self.vmoffsets.vmctx_vmtable_import_from(index)),
+                            self.vmoffsets.vmtable_definition_base().into(),
+                            self.vmoffsets.vmtable_definition_current_elements().into(),
+                        ),
+                    };
+
+                *entry.insert(TableData {
+                    import_from: from_offset,
+                    offset: base_offset,
+                    current_elems_offset,
+                    element_size: OperandSize::from_bytes(self.vmoffsets.ptr.size()),
+                    current_elements_size: OperandSize::from_bytes(
+                        self.vmoffsets.size_of_vmtable_definition_current_elements(),
+                    ),
+                })
+            }
+        }
+    }
+
+    /// Resolve a `HeapData` from a [MemoryIndex].
+    // TODO: (@saulecabrera)
+    // Handle shared memories when implementing support for Wasm Threads.
+    pub fn resolve_heap(&mut self, index: MemoryIndex) -> HeapData {
+        match self.resolved_heaps.entry(index) {
+            Occupied(entry) => *entry.get(),
+            Vacant(entry) => {
+                let (import_from, base_offset, current_length_offset) =
+                    match self.translation.module.defined_memory_index(index) {
+                        Some(defined) => {
+                            let owned = self.translation.module.owned_memory_index(defined);
+                            (
+                                None,
+                                self.vmoffsets.vmctx_vmmemory_definition_base(owned),
+                                self.vmoffsets
+                                    .vmctx_vmmemory_definition_current_length(owned),
+                            )
+                        }
+                        None => (
+                            Some(self.vmoffsets.vmctx_vmmemory_import_from(index)),
+                            self.vmoffsets.ptr.vmmemory_definition_base().into(),
+                            self.vmoffsets
+                                .ptr
+                                .vmmemory_definition_current_length()
+                                .into(),
+                        ),
+                    };
+
+                let plan = &self.translation.module.memory_plans[index];
+                let (min_size, max_size) = heap_limits(&plan);
+                let (style, offset_guard_size) = heap_style_and_offset_guard_size(&plan);
+
+                *entry.insert(HeapData {
+                    offset: base_offset,
+                    import_from,
+                    current_length_offset,
+                    style,
+                    ty: if plan.memory.memory64 {
+                        WasmValType::I64
+                    } else {
+                        WasmValType::I32
+                    },
+                    min_size,
+                    max_size,
+                    page_size_log2: plan.memory.page_size_log2,
+                    offset_guard_size,
+                })
+            }
+        }
+    }
+
+    /// Get a [`TablePlan`] from a [`TableIndex`].
+    pub fn table_plan(&mut self, index: TableIndex) -> &TablePlan {
+        &self.translation.module.table_plans[index]
+    }
+
+    /// Returns true if Spectre mitigations are enabled for heap bounds check.
+    pub fn heap_access_spectre_mitigation(&self) -> bool {
+        self.heap_access_spectre_mitigation
+    }
+
+    /// Returns true if Spectre mitigations are enabled for table element
+    /// accesses.
+    pub fn table_access_spectre_mitigation(&self) -> bool {
+        self.table_access_spectre_mitigation
+    }
+
+    pub(crate) fn callee_sig<'b, A>(&'b mut self, callee: &'b Callee) -> &'b ABISig
+    where
+        A: ABI,
+    {
+        match callee {
+            Callee::Local(idx) | Callee::Import(idx) => {
+                let types = self.translation.get_types();
+                let ty = types[types.core_function_at(idx.as_u32())].unwrap_func();
+                let val = || {
+                    let converter = TypeConverter::new(self.translation, self.types);
+                    let ty = converter.convert_func_type(&ty);
+                    wasm_sig::<A>(&ty)
+                };
+                self.resolved_callees.entry(*idx).or_insert_with(val)
+            }
+            Callee::FuncRef(idx) => {
+                let val = || {
+                    let sig_index = self.translation.module.types[*idx];
+                    let ty = self.types[sig_index].unwrap_func();
+                    let sig = wasm_sig::<A>(ty);
+                    sig
+                };
+                self.resolved_sigs.entry(*idx).or_insert_with(val)
+            }
+            Callee::Builtin(b) => b.sig(),
         }
     }
+
+    /// Creates a name to reference the `builtin` provided.
+    pub fn name_builtin(&mut self, builtin: BuiltinFunctionIndex) -> UserExternalNameRef {
+        self.intern_name(UserExternalName {
+            namespace: wasmtime_cranelift::NS_WASMTIME_BUILTIN,
+            index: builtin.index(),
+        })
+    }
+
+    /// Creates a name to reference the wasm function `index` provided.
+    pub fn name_wasm(&mut self, index: FuncIndex) -> UserExternalNameRef {
+        self.intern_name(UserExternalName {
+            namespace: wasmtime_cranelift::NS_WASM_FUNC,
+            index: index.as_u32(),
+        })
+    }
+
+    /// Interns `name` into a `UserExternalNameRef` and ensures that duplicate
+    /// instances of `name` are given a unique name ref index.
+    fn intern_name(&mut self, name: UserExternalName) -> UserExternalNameRef {
+        *self
+            .name_intern
+            .entry(name.clone())
+            .or_insert_with(|| self.name_map.push(name))
+    }
+
+    /// Extracts the name map that was created while translating this function.
+    pub fn take_name_map(&mut self) -> PrimaryMap<UserExternalNameRef, UserExternalName> {
+        self.name_intern.clear();
+        mem::take(&mut self.name_map)
+    }
+}
+
+/// A wrapper struct over a reference to a [ModuleTranslation] and
+/// [ModuleTypesBuilder].
+pub(crate) struct TypeConverter<'a, 'data: 'a> {
+    translation: &'a ModuleTranslation<'data>,
+    types: &'a ModuleTypesBuilder,
+}
+
+impl TypeConvert for TypeConverter<'_, '_> {
+    fn lookup_heap_type(&self, idx: wasmparser::UnpackedIndex) -> WasmHeapType {
+        wasmtime_environ::WasmparserTypeConverter::new(self.types, &self.translation.module)
+            .lookup_heap_type(idx)
+    }
+
+    fn lookup_type_index(
+        &self,
+        index: wasmparser::UnpackedIndex,
+    ) -> wasmtime_environ::EngineOrModuleTypeIndex {
+        wasmtime_environ::WasmparserTypeConverter::new(self.types, &self.translation.module)
+            .lookup_type_index(index)
+    }
+}
+
+impl<'a, 'data> TypeConverter<'a, 'data> {
+    pub fn new(translation: &'a ModuleTranslation<'data>, types: &'a ModuleTypesBuilder) -> Self {
+        Self { translation, types }
+    }
+}
+
+fn heap_style_and_offset_guard_size(plan: &MemoryPlan) -> (HeapStyle, u64) {
+    match plan {
+        MemoryPlan {
+            style: MemoryStyle::Static { byte_reservation },
+            offset_guard_size,
+            ..
+        } => (
+            HeapStyle::Static {
+                bound: *byte_reservation,
+            },
+            *offset_guard_size,
+        ),
+
+        MemoryPlan {
+            style: MemoryStyle::Dynamic { .. },
+            offset_guard_size,
+            ..
+        } => (HeapStyle::Dynamic, *offset_guard_size),
+    }
+}
+
+fn heap_limits(plan: &MemoryPlan) -> (u64, Option<u64>) {
+    (
+        plan.memory.minimum_byte_size().unwrap_or_else(|_| {
+            // 2^64 as a minimum doesn't fin in a 64 bit integer.
+            // So in this case, the minimum is clamped to u64::MAX.
+            u64::MAX
+        }),
+        plan.memory.maximum_byte_size().ok(),
+    )
 }
diff --git a/winch/codegen/src/codegen/mod.rs b/winch/codegen/src/codegen/mod.rs
index 6771e15ea668..0edcd7fc417c 100644
--- a/winch/codegen/src/codegen/mod.rs
+++ b/winch/codegen/src/codegen/mod.rs
@@ -1,14 +1,26 @@
 use crate::{
-    abi::{ABISig, ABI},
+    abi::{scratch, vmctx, ABIOperand, ABISig, RetArea},
+    codegen::BlockSig,
     isa::reg::Reg,
-    masm::{CmpKind, MacroAssembler, OperandSize, TrapCode},
-    stack::{TypedReg, Val},
-    CallingConvention,
+    masm::{
+        ExtendKind, IntCmpKind, MacroAssembler, OperandSize, RegImm, SPOffset, ShiftKind, TrapCode,
+    },
+    stack::TypedReg,
 };
 use anyhow::Result;
 use smallvec::SmallVec;
-use wasmparser::{BinaryReader, FuncValidator, Operator, ValidatorResources, VisitOperator};
-use wasmtime_environ::{PtrSize, TypeIndex, WasmFuncType, WasmType};
+use wasmparser::{
+    BinaryReader, FuncValidator, MemArg, Operator, ValidatorResources, VisitOperator,
+};
+use wasmtime_environ::{
+    GlobalIndex, MemoryIndex, PtrSize, TableIndex, TypeIndex, WasmHeapType, WasmValType,
+    FUNCREF_MASK,
+};
+
+use cranelift_codegen::{
+    binemit::CodeOffset,
+    ir::{RelSourceLoc, SourceLoc},
+};
 
 mod context;
 pub(crate) use context::*;
@@ -19,21 +31,36 @@ pub(crate) use call::*;
 mod control;
 pub(crate) use control::*;
 mod builtin;
-pub(crate) use builtin::*;
+pub use builtin::*;
+pub(crate) mod bounds;
+
+use bounds::{Bounds, ImmOffset, Index};
+
+/// Holds metadata about the source code location and the machine code emission.
+/// The fields of this struct are opaque and are not interpreted in any way.
+/// They serve as a mapping between source code and machine code.
+#[derive(Default)]
+pub(crate) struct SourceLocation {
+    /// The base source location.
+    pub base: Option<SourceLoc>,
+    /// The current relative source code location along with its associated
+    /// machine code offset.
+    pub current: (CodeOffset, RelSourceLoc),
+}
 
 /// The code generation abstraction.
-pub(crate) struct CodeGen<'a, M>
+pub(crate) struct CodeGen<'a, 'translation: 'a, 'data: 'translation, M>
 where
     M: MacroAssembler,
 {
     /// The ABI-specific representation of the function signature, excluding results.
-    sig: ABISig,
+    pub sig: ABISig,
 
     /// The code generation context.
     pub context: CodeGenContext<'a>,
 
     /// A reference to the function compilation environment.
-    pub env: FuncEnv<'a, M::Ptr>,
+    pub env: FuncEnv<'a, 'translation, 'data, M::Ptr>,
 
     /// The MacroAssembler.
     pub masm: &'a mut M,
@@ -42,16 +69,23 @@ where
     // NB The 64 is set arbitrarily, we can adjust it as
     // we see fit.
     pub control_frames: SmallVec<[ControlStackFrame; 64]>,
+
+    /// Information about the source code location.
+    pub source_location: SourceLocation,
+
+    /// Flag indicating whether during translation an unsupported instruction
+    /// was found.
+    pub found_unsupported_instruction: Option<&'static str>,
 }
 
-impl<'a, M> CodeGen<'a, M>
+impl<'a, 'translation, 'data, M> CodeGen<'a, 'translation, 'data, M>
 where
     M: MacroAssembler,
 {
     pub fn new(
         masm: &'a mut M,
         context: CodeGenContext<'a>,
-        env: FuncEnv<'a, M::Ptr>,
+        env: FuncEnv<'a, 'translation, 'data, M::Ptr>,
         sig: ABISig,
     ) -> Self {
         Self {
@@ -59,7 +93,9 @@ where
             context,
             masm,
             env,
+            source_location: Default::default(),
             control_frames: Default::default(),
+            found_unsupported_instruction: None,
         }
     }
 
@@ -76,19 +112,53 @@ where
         Ok(())
     }
 
-    // TODO stack checks
+    /// Derives a [RelSourceLoc] from a [SourceLoc].
+    pub fn source_loc_from(&mut self, loc: SourceLoc) -> RelSourceLoc {
+        if self.source_location.base.is_none() && !loc.is_default() {
+            self.source_location.base = Some(loc);
+        }
+
+        RelSourceLoc::from_base_offset(self.source_location.base.unwrap_or_default(), loc)
+    }
+
     fn emit_start(&mut self) -> Result<()> {
-        self.masm.prologue();
+        let vmctx = self
+            .sig
+            .params()
+            .first()
+            .expect("VMContext argument")
+            .unwrap_reg()
+            .into();
+
+        self.masm.start_source_loc(Default::default());
+        // We need to use the vmctx parameter before pinning it for stack checking.
+        self.masm.prologue(vmctx);
+        // Pin the `VMContext` pointer.
+        self.masm
+            .mov(vmctx.into(), vmctx!(M), self.env.ptr_type().into());
+
         self.masm.reserve_stack(self.context.frame.locals_size);
 
+        self.masm.end_source_loc();
+
         // Once we have emitted the epilogue and reserved stack space for the locals, we push the
         // base control flow block.
-        self.control_frames
-            .push(ControlStackFrame::function_body_block(
-                self.sig.result,
-                self.masm,
-                &mut self.context,
-            ));
+        self.control_frames.push(ControlStackFrame::block(
+            BlockSig::from_sig(self.sig.clone()),
+            self.masm,
+            &mut self.context,
+        ));
+
+        // Set the return area of the results *after* initializing the block. In
+        // the function body block case, we'll treat the results as any other
+        // case, addressed from the stack pointer, and when ending the function
+        // the return area will be set to the return pointer.
+        if self.sig.params.has_retptr() {
+            self.sig
+                .results
+                .set_ret_area(RetArea::slot(self.context.frame.results_base_slot.unwrap()));
+        }
+
         Ok(())
     }
 
@@ -101,74 +171,35 @@ where
     /// are not visited.
     pub fn handle_unreachable_else(&mut self) {
         let frame = self.control_frames.last_mut().unwrap();
-        match frame {
-            ControlStackFrame::If {
-                reachable,
-                original_stack_len,
-                ..
-            } => {
-                if *reachable {
-                    // We entered an unreachable state when compiling the
-                    // if-then branch, but if the `if` was reachable at
-                    // entry, the if-else branch will be reachable.
-                    self.context.reachable = true;
-                    // Reset the stack to the original length and offset.
-                    Self::reset_stack(&mut self.context, *original_stack_len);
-                    frame.bind_else(self.masm, self.context.reachable);
-                }
-            }
-            _ => unreachable!(),
+        debug_assert!(frame.is_if());
+        if frame.is_next_sequence_reachable() {
+            // We entered an unreachable state when compiling the
+            // if-then branch, but if the `if` was reachable at
+            // entry, the if-else branch will be reachable.
+            self.context.reachable = true;
+            frame.ensure_stack_state(self.masm, &mut self.context);
+            frame.bind_else(self.masm, &mut self.context);
         }
     }
 
     pub fn handle_unreachable_end(&mut self) {
-        let frame = self.control_frames.pop().unwrap();
+        let mut frame = self.control_frames.pop().unwrap();
         // We just popped the outermost block.
         let is_outermost = self.control_frames.len() == 0;
+
         if frame.is_next_sequence_reachable() {
             self.context.reachable = true;
-
-            let (value_stack_len, _) = frame.original_stack_len_and_sp_offset();
-            // Reset the stack to the original length and offset.
-            Self::reset_stack(&mut self.context, value_stack_len);
-            // If the current frame is the outermost frame, which corresponds to the
-            // current function's body, only bind the exit label as we don't need to
-            // push any more values to the value stack, else perform the entire `bind_end`
-            // process, which involves pushing results to the value stack.
-            if is_outermost {
-                frame.bind_exit_label(self.masm);
-            } else {
-                frame.bind_end(self.masm, &mut self.context);
-            }
+            frame.ensure_stack_state(self.masm, &mut self.context);
+            frame.bind_end(self.masm, &mut self.context);
         } else if is_outermost {
             // If we reach the end of the function in an unreachable
             // state, perform the necessary cleanup to leave the stack
             // and SP in the expected state.  The compiler can enter
             // in this state through an infinite loop.
-            let (value_stack_len, target_sp) = frame.original_stack_len_and_sp_offset();
-            Self::reset_stack(&mut self.context, value_stack_len);
-            if self.masm.sp_offset() > target_sp {
-                self.masm.free_stack(self.masm.sp_offset() - target_sp);
-            }
+            frame.ensure_stack_state(self.masm, &mut self.context);
         }
     }
 
-    /// Helper function to reset value and stack pointer to the given length and stack pointer
-    /// offset respectively. This function is only used when restoring the code generation's
-    /// reachabiliy state when handling an unreachable `end` or `else`.
-    pub fn reset_stack(context: &mut CodeGenContext, target_stack_len: usize) {
-        // `CodeGenContext::reset_stack` only gets called when
-        // handling unreachable end or unreachable else, so we only
-        // care about freeing any registers in the provided range.
-        context.drop_last(
-            context.stack.len() - target_stack_len,
-            |regalloc, val| match val {
-                Val::Reg(tr) => regalloc.free(tr.reg),
-                _ => {}
-            },
-        );
-    }
-
     fn emit_body(
         &mut self,
         body: &mut BinaryReader<'a>,
@@ -178,23 +209,37 @@ where
         let defined_locals_range = &self.context.frame.defined_locals_range;
         self.masm.zero_mem_range(defined_locals_range.as_range());
 
-        // Save the vmctx pointer to its local slot in case we need to reload it
-        // at any point.
-        let vmctx_addr = self.masm.local_address(&self.context.frame.vmctx_slot);
-        self.masm.store(
-            <M::ABI as ABI>::vmctx_reg().into(),
-            vmctx_addr,
-            OperandSize::S64,
-        );
+        // Save the results base parameter register into its slot.
+        self.sig.params.has_retptr().then(|| {
+            match self.sig.params.unwrap_results_area_operand() {
+                ABIOperand::Reg { ty, reg, .. } => {
+                    let results_base_slot = self.context.frame.results_base_slot.as_ref().unwrap();
+                    debug_assert!(results_base_slot.addressed_from_sp());
+                    let addr = self.masm.local_address(results_base_slot);
+                    self.masm.store((*reg).into(), addr, (*ty).into());
+                }
+                // The result base parameter is a stack parameter, addressed
+                // from FP.
+                _ => {}
+            }
+        });
 
         while !body.eof() {
             let offset = body.original_position();
-            body.visit_operator(&mut ValidateThenVisit(validator.visitor(offset), self))??;
+            body.visit_operator(&mut ValidateThenVisit(
+                validator.visitor(offset),
+                self,
+                offset,
+            ))??;
+
+            if let Some(insn) = self.found_unsupported_instruction {
+                anyhow::bail!("unsupported instruction in Winch: {insn}")
+            }
         }
         validator.finish(body.original_position())?;
         return Ok(());
 
-        struct ValidateThenVisit<'a, T, U>(T, &'a mut U);
+        struct ValidateThenVisit<'a, T, U>(T, &'a mut U, usize);
 
         macro_rules! validate_then_visit {
             ($( @$proposal:ident $op:ident $({ $($arg:ident: $argty:ty),* })? => $visit:ident)*) => {
@@ -202,13 +247,17 @@ where
                     fn $visit(&mut self $($(,$arg: $argty)*)?) -> Self::Output {
                         self.0.$visit($($($arg.clone()),*)?)?;
                         // Only visit operators if the compiler is in a reachable code state. If
-                        // the compiler is in an unrechable code state, most of the operators are
+                        // the compiler is in an unreachable code state, most of the operators are
                         // ignored except for If, Block, Loop, Else and End. These operators need
                         // to be observed in order to keep the control stack frames balanced and to
                         // determine if reachability should be restored.
                         let visit_when_unreachable = visit_op_when_unreachable(Operator::$op $({ $($arg: $arg.clone()),* })?);
                         if self.1.is_reachable() || visit_when_unreachable  {
-                            Ok(self.1.$visit($($($arg),*)?))
+                            let location = SourceLoc::new(self.2 as u32);
+                            self.1.start(location);
+                            let res = Ok(self.1.$visit($($($arg),*)?));
+                            self.1.end();
+                            res
                         } else {
                             Ok(U::Output::default())
                         }
@@ -231,16 +280,45 @@ where
             fn is_reachable(&self) -> bool;
         }
 
-        impl<'a, M: MacroAssembler> ReachableState for CodeGen<'a, M> {
+        /// Trait to map source locations to machine code.
+        trait SourceLocator {
+            fn start(&mut self, loc: SourceLoc);
+            fn end(&mut self);
+        }
+
+        impl<'a, 'translation, 'data, M: MacroAssembler> ReachableState
+            for CodeGen<'a, 'translation, 'data, M>
+        {
             fn is_reachable(&self) -> bool {
                 self.context.reachable
             }
         }
 
+        impl<'a, 'translation, 'data, M: MacroAssembler> SourceLocator
+            for CodeGen<'a, 'translation, 'data, M>
+        {
+            fn start(&mut self, loc: SourceLoc) {
+                let rel = self.source_loc_from(loc);
+                self.source_location.current = self.masm.start_source_loc(rel);
+            }
+
+            fn end(&mut self) {
+                // Because in Winch binary emission is done in a single pass
+                // and because the MachBuffer performs optimizations during
+                // emission, we have to be careful when calling
+                // [MacroAssembler::end_source_location] to avoid breaking the
+                // invariant that checks that the end [CodeOffset] must be equal
+                // or greater than the start [CodeOffset].
+                if self.masm.current_code_offset() >= self.source_location.current.0 {
+                    self.masm.end_source_loc();
+                }
+            }
+        }
+
         impl<'a, T, U> VisitOperator<'a> for ValidateThenVisit<'_, T, U>
         where
             T: VisitOperator<'a, Output = wasmparser::Result<()>>,
-            U: VisitOperator<'a> + ReachableState,
+            U: VisitOperator<'a> + ReachableState + SourceLocator,
             U::Output: Default,
         {
             type Output = Result<U::Output>;
@@ -249,106 +327,23 @@ where
         }
     }
 
-    /// Emit a function call to:
-    /// * A locally defined function.
-    /// * A function import.
-    /// * A funcref.
-    pub fn emit_call(&mut self, callee: Callee) {
-        match callee {
-            Callee::Import(callee) => {
-                let mut params = Vec::with_capacity(callee.ty.params().len() + 2);
-                params.extend_from_slice(&self.env.vmctx_args_type());
-                params.extend_from_slice(callee.ty.params());
-                let sig = WasmFuncType::new(params.into(), callee.ty.returns().into());
-
-                let caller_vmctx = <M::ABI as ABI>::vmctx_reg();
-                let callee_vmctx = self.context.any_gpr(self.masm);
-                let callee_vmctx_offset = self
-                    .env
-                    .vmoffsets
-                    .vmctx_vmfunction_import_vmctx(callee.index);
-                let callee_vmctx_addr = self.masm.address_at_vmctx(callee_vmctx_offset);
-                // FIXME Remove harcoded operand size, this will be needed
-                // once 32-bit architectures are supported.
-                self.masm
-                    .load(callee_vmctx_addr, callee_vmctx, OperandSize::S64);
-
-                let callee_body_offset = self
-                    .env
-                    .vmoffsets
-                    .vmctx_vmfunction_import_wasm_call(callee.index);
-                let callee_addr = self.masm.address_at_vmctx(callee_body_offset);
-
-                // Put the callee / caller vmctx at the start of the
-                // range of the stack so that they are used as first
-                // and second arguments.
-                let stack = &mut self.context.stack;
-                let location = stack.len() - (sig.params().len() - 2);
-                stack.insert(location as usize, TypedReg::i64(caller_vmctx).into());
-                stack.insert(location as usize, TypedReg::i64(callee_vmctx).into());
-
-                let abi_sig = <M::ABI as ABI>::sig(&sig, &CallingConvention::Default);
-                FnCall::new(&abi_sig)
-                    .save_live_registers(&mut self.context, self.masm)
-                    .addr(self.masm, &mut self.context, callee_addr);
-            }
-
-            Callee::Local(callee) => {
-                let abi_sig = <M::ABI as ABI>::sig(&callee.ty, &CallingConvention::Default);
-                FnCall::new(&abi_sig)
-                    .save_live_registers(&mut self.context, self.masm)
-                    .direct(self.masm, &mut self.context, callee.index);
-            }
-
-            Callee::FuncRef(ty) => {
-                // Get type for the caller and callee VMContext.
-                let ptr_type = self.env.ptr_type();
-                let abi_sig = <M::ABI as ABI>::sig(&ty, &CallingConvention::Default);
-                // Pop the funcref pointer to a register and allocate a register to hold the
-                // address of the funcref. Since the callee is not addressed from a global non
-                // allocatable register (like the vmctx in the case of an import), we load the
-                // funcref to a register ensuring that it doesn't get assigned to a non-arg
-                // register.
-                let (funcref_ptr, funcref) = self.context.without::<_, M, _>(
-                    abi_sig.param_regs(),
-                    abi_sig.param_regs(),
-                    self.masm,
-                    |cx, masm| (cx.pop_to_reg(masm, None).into(), cx.any_gpr(masm)),
-                );
-                self.masm.load(
-                    self.masm.address_at_reg(
-                        funcref_ptr,
-                        self.env.vmoffsets.ptr.vm_func_ref_wasm_call().into(),
-                    ),
-                    funcref,
-                    ptr_type.into(),
-                );
-                self.context.free_reg(funcref_ptr);
-
-                FnCall::new(&abi_sig)
-                    .save_live_registers(&mut self.context, self.masm)
-                    .reg(self.masm, &mut self.context, funcref);
-            }
-        };
-    }
-
     /// Emits a a series of instructions that will type check a function reference call.
     pub fn emit_typecheck_funcref(&mut self, funcref_ptr: Reg, type_index: TypeIndex) {
         let ptr_size: OperandSize = self.env.ptr_type().into();
-        let sig_index_bytes = self.env.vmoffsets.size_of_vmshared_signature_index();
+        let sig_index_bytes = self.env.vmoffsets.size_of_vmshared_type_index();
         let sig_size = OperandSize::from_bytes(sig_index_bytes);
-        let sig_index = self.env.translation.module.types[type_index].unwrap_function();
+        let sig_index = self.env.translation.module.types[type_index];
         let sig_offset = sig_index
             .as_u32()
             .checked_mul(sig_index_bytes.into())
             .unwrap();
-        let signatures_base_offset = self.env.vmoffsets.vmctx_signature_ids_array();
-        let scratch = <M::ABI as ABI>::scratch_reg();
+        let signatures_base_offset = self.env.vmoffsets.ptr.vmctx_type_ids_array();
+        let scratch = scratch!(M);
         let funcref_sig_offset = self.env.vmoffsets.ptr.vm_func_ref_type_index();
 
         // Load the signatures address into the scratch register.
         self.masm.load(
-            self.masm.address_at_vmctx(signatures_base_offset),
+            self.masm.address_at_vmctx(signatures_base_offset.into()),
             scratch,
             ptr_size,
         );
@@ -370,44 +365,535 @@ where
         );
 
         // Typecheck.
-        self.masm.cmp(callee_id.into(), caller_id, OperandSize::S32);
-        self.masm.trapif(CmpKind::Ne, TrapCode::BadSignature);
+        self.masm.cmp(caller_id, callee_id.into(), OperandSize::S32);
+        self.masm.trapif(IntCmpKind::Ne, TrapCode::BadSignature);
         self.context.free_reg(callee_id);
         self.context.free_reg(caller_id);
     }
 
     /// Emit the usual function end instruction sequence.
     fn emit_end(&mut self) -> Result<()> {
-        assert!(self.context.stack.len() == 0);
-        self.masm.epilogue(self.context.frame.locals_size);
+        // The implicit body block is treated a normal block (it pushes results
+        // to the stack); so when reaching the end, we pop them taking as
+        // reference the current function's signature.
+        let base = SPOffset::from_u32(self.context.frame.locals_size);
+        self.masm.start_source_loc(Default::default());
+        if self.context.reachable {
+            ControlStackFrame::pop_abi_results_impl(
+                &mut self.sig.results,
+                &mut self.context,
+                self.masm,
+                |results, _, _| results.ret_area().copied(),
+            );
+        } else {
+            // If we reach the end of the function in an unreachable code state,
+            // simply truncate to the expected values.
+            // The compiler could enter this state through an infinite loop.
+            self.context.truncate_stack_to(0);
+            self.masm.reset_stack_pointer(base);
+        }
+        debug_assert_eq!(self.context.stack.len(), 0);
+        self.masm.free_stack(self.context.frame.locals_size);
+        self.masm.epilogue();
+        self.masm.end_source_loc();
         Ok(())
     }
 
     fn spill_register_arguments(&mut self) {
-        use WasmType::*;
+        use WasmValType::*;
         self.sig
-            .params
+            // Skip the results base param if any; [Self::emit_body],
+            // will handle spilling the results base param if it's in a register.
+            .params_without_retptr()
             .iter()
             .enumerate()
             .filter(|(_, a)| a.is_reg())
             .for_each(|(index, arg)| {
                 let ty = arg.ty();
-                let local = self
-                    .context
-                    .frame
-                    .get_local(index as u32)
-                    .expect("valid local slot at location");
+                let local = self.context.frame.get_frame_local(index);
                 let addr = self.masm.local_address(local);
                 let src = arg
                     .get_reg()
                     .expect("arg should be associated to a register");
 
                 match &ty {
-                    I32 | I64 | F32 | F64 => self.masm.store(src.into(), addr, ty.into()),
-                    _ => panic!("Unsupported type {:?}", ty),
+                    I32 | I64 | F32 | F64 | V128 => self.masm.store(src.into(), addr, ty.into()),
+                    Ref(rt) => match rt.heap_type {
+                        WasmHeapType::Func | WasmHeapType::Extern => {
+                            self.masm.store_ptr(src.into(), addr)
+                        }
+                        ht => unimplemented!("Support for WasmHeapType: {ht}"),
+                    },
                 }
             });
     }
+
+    /// Pops the value at the stack top and assigns it to the local at
+    /// the given index, returning the typed register holding the
+    /// source value.
+    pub fn emit_set_local(&mut self, index: u32) -> TypedReg {
+        // Materialize any references to the same local index that are in the
+        // value stack by spilling.
+        if self.context.stack.contains_latent_local(index) {
+            self.context.spill(self.masm);
+        }
+        let src = self.context.pop_to_reg(self.masm, None);
+        // Need to get address of local after `pop_to_reg` since `pop_to_reg`
+        // will pop the machine stack causing an incorrect address to be
+        // calculated.
+        let (ty, addr) = self.context.frame.get_local_address(index, self.masm);
+        self.masm.store(RegImm::reg(src.reg), addr, ty.into());
+
+        src
+    }
+
+    /// Loads the address of the given global.
+    pub fn emit_get_global_addr(&mut self, index: GlobalIndex) -> (WasmValType, M::Address) {
+        let data = self.env.resolve_global(index);
+
+        let addr = if data.imported {
+            let global_base = self.masm.address_at_reg(vmctx!(M), data.offset);
+            let scratch = scratch!(M);
+            self.masm.load_ptr(global_base, scratch);
+            self.masm.address_at_reg(scratch, 0)
+        } else {
+            self.masm.address_at_reg(vmctx!(M), data.offset)
+        };
+
+        (data.ty, addr)
+    }
+
+    pub fn emit_lazy_init_funcref(&mut self, table_index: TableIndex) {
+        let table_data = self.env.resolve_table_data(table_index);
+        let ptr_type = self.env.ptr_type();
+        let builtin = self
+            .env
+            .builtins
+            .table_get_lazy_init_func_ref::<M::ABI, M::Ptr>();
+
+        // Request the builtin's  result register and use it to hold the table
+        // element value. We preemptively spill and request this register to
+        // avoid conflict at the control flow merge below. Requesting the result
+        // register is safe since we know ahead-of-time the builtin's signature.
+        self.context.spill(self.masm);
+        let elem_value: Reg = self
+            .context
+            .reg(
+                builtin.sig().results.unwrap_singleton().unwrap_reg(),
+                self.masm,
+            )
+            .into();
+
+        let index = self.context.pop_to_reg(self.masm, None);
+        let base = self.context.any_gpr(self.masm);
+
+        let elem_addr = self.emit_compute_table_elem_addr(index.into(), base, &table_data);
+        self.masm.load_ptr(elem_addr, elem_value);
+        // Free the register used as base, once we have loaded the element
+        // address into the element value register.
+        self.context.free_reg(base);
+
+        let (defined, cont) = (self.masm.get_label(), self.masm.get_label());
+
+        // Push the built-in arguments to the stack.
+        self.context
+            .stack
+            .extend([table_index.as_u32().try_into().unwrap(), index.into()]);
+
+        self.masm.branch(
+            IntCmpKind::Ne,
+            elem_value,
+            elem_value.into(),
+            defined,
+            ptr_type.into(),
+        );
+        // Free the element value register.
+        // This is safe since the FnCall::emit call below, will ensure
+        // that the result register is placed on the value stack.
+        self.context.free_reg(elem_value);
+        FnCall::emit::<M>(
+            &mut self.env,
+            self.masm,
+            &mut self.context,
+            Callee::Builtin(builtin.clone()),
+        );
+
+        // We know the signature of the libcall in this case, so we assert that there's
+        // one element in the stack and that it's  the ABI signature's result register.
+        let top = self.context.stack.peek().unwrap();
+        let top = top.unwrap_reg();
+        debug_assert!(top.reg == elem_value);
+        self.masm.jmp(cont);
+
+        // In the defined case, mask the funcref address in place, by peeking into the
+        // last element of the value stack, which was pushed by the `indirect` function
+        // call above.
+        self.masm.bind(defined);
+        let imm = RegImm::i64(FUNCREF_MASK as i64);
+        let dst = top.into();
+        self.masm.and(dst, dst, imm, top.ty.into());
+
+        self.masm.bind(cont);
+    }
+
+    /// Emits a series of instructions to bounds check and calculate the address
+    /// of the given WebAssembly memory.
+    /// This function returns a register containing the requested address.
+    ///
+    /// In essence, when computing the heap address for a WebAssembly load or
+    /// store instruction the objective is to ensure that such access is safe,
+    /// but also to perform the least amount of checks, and rely on the system to
+    /// detect illegal memory accesses where applicable.
+    ///
+    /// Winch follows almost the same principles as Cranelift when it comes to
+    /// bounds checks, for a more detailed explanation refer to
+    /// [cranelift_wasm::code_translator::prepare_addr].
+    ///
+    /// Winch implementation differs in that, it defaults to the general case
+    /// for dynamic heaps rather than optimizing for doing the least amount of
+    /// work possible at runtime, this is done to align with Winch's principle
+    /// of doing the least amount of work possible at compile time. For static
+    /// heaps, Winch does a bit more of work, given that some of the cases that
+    /// are checked against, can benefit compilation times, like for example,
+    /// detecting an out of bounds access at compile time.
+    pub fn emit_compute_heap_address(
+        &mut self,
+        memarg: &MemArg,
+        access_size: OperandSize,
+    ) -> Option<Reg> {
+        let ptr_size: OperandSize = self.env.ptr_type().into();
+        let enable_spectre_mitigation = self.env.heap_access_spectre_mitigation();
+        let add_offset_and_access_size = |offset: ImmOffset, access_size: OperandSize| {
+            (access_size.bytes() as u64) + (offset.as_u32() as u64)
+        };
+
+        let memory_index = MemoryIndex::from_u32(memarg.memory);
+        let heap = self.env.resolve_heap(memory_index);
+        let index = Index::from_typed_reg(self.context.pop_to_reg(self.masm, None));
+        let offset =
+            bounds::ensure_index_and_offset(self.masm, index, memarg.offset, heap.ty.into());
+        let offset_with_access_size = add_offset_and_access_size(offset, access_size);
+
+        let addr = match heap.style {
+            // == Dynamic Heaps ==
+
+            // Account for the general case for dynamic memories. The access is
+            // out of bounds if:
+            // * index + offset + access_size overflows
+            //   OR
+            // * index + offset + access_size > bound
+            HeapStyle::Dynamic => {
+                let bounds =
+                    bounds::load_dynamic_heap_bounds(&mut self.context, self.masm, &heap, ptr_size);
+
+                let index_reg = index.as_typed_reg().reg;
+                // Allocate a temporary register to hold
+                //      index + offset + access_size
+                //  which will serve as the check condition.
+                let index_offset_and_access_size = self.context.any_gpr(self.masm);
+
+                // Move the value of the index to the
+                // index_offset_and_access_size register to perform the overflow
+                // check to avoid clobbering the initial index value.
+                //
+                // We derive size of the operation from the heap type since:
+                //
+                // * This is the first assignment to the
+                // `index_offset_and_access_size` register
+                //
+                // * The memory64 proposal specifies that the index is bound to
+                // the heap type instead of hardcoding it to 32-bits (i32).
+                self.masm.mov(
+                    index_reg.into(),
+                    index_offset_and_access_size,
+                    heap.ty.into(),
+                );
+                // Perform
+                // index = index + offset + access_size, trapping if the
+                // addition overflows.
+                //
+                // We use the target's pointer size rather than depending on the heap
+                // type since we want to check for overflow; even though the
+                // offset and access size are guaranteed to be bounded by the heap
+                // type, when added, if used with the wrong operand size, their
+                // result could be clamped, resulting in an erroneus overflow
+                // check.
+                self.masm.checked_uadd(
+                    index_offset_and_access_size,
+                    index_offset_and_access_size,
+                    RegImm::i64(offset_with_access_size as i64),
+                    ptr_size,
+                    TrapCode::HeapOutOfBounds,
+                );
+
+                let addr = bounds::load_heap_addr_checked(
+                    self.masm,
+                    &mut self.context,
+                    ptr_size,
+                    &heap,
+                    enable_spectre_mitigation,
+                    bounds,
+                    index,
+                    offset,
+                    |masm, bounds, _| {
+                        let bounds_reg = bounds.as_typed_reg().reg;
+                        masm.cmp(
+                            index_offset_and_access_size.into(),
+                            bounds_reg.into(),
+                            // We use the pointer size to keep the bounds
+                            // comparison consistent with the result of the
+                            // overflow check above.
+                            ptr_size,
+                        );
+                        IntCmpKind::GtU
+                    },
+                );
+                self.context.free_reg(bounds.as_typed_reg().reg);
+                self.context.free_reg(index_offset_and_access_size);
+                Some(addr)
+            }
+
+            // == Static Heaps ==
+
+            // Detect at compile time if the access is out of bounds.
+            // Doing so will put the compiler in an unreachable code state,
+            // optimizing the work that the compiler has to do until the
+            // reachability is restored or when reaching the end of the
+            // function.
+            HeapStyle::Static { bound } if offset_with_access_size > bound => {
+                self.masm.trap(TrapCode::HeapOutOfBounds);
+                self.context.reachable = false;
+                None
+            }
+
+            // Account for the case in which we can completely elide the bounds
+            // checks.
+            //
+            // This case, makes use of the fact that if a memory access uses
+            // a 32-bit index, then we be certain that
+            //
+            //      index <= u32::MAX
+            //
+            // Therefore if any 32-bit index access occurs in the region
+            // represented by
+            //
+            //      bound + guard_size - (offset + access_size)
+            //
+            // We are certain that it's in bounds or that the underlying virtual
+            // memory subsystem will report an illegal access at runtime.
+            //
+            // Note:
+            //
+            // * bound - (offset + access_size) cannot wrap, because it's checked
+            // in the condition above.
+            // * bound + heap.offset_guard_size is guaranteed to not overflow if
+            // the heap configuration is correct, given that it's address must
+            // fit in 64-bits.
+            // * If the heap type is 32-bits, the offset is at most u32::MAX, so
+            // no  adjustment is needed as part of
+            // [bounds::ensure_index_and_offset].
+            HeapStyle::Static { bound }
+                if heap.ty == WasmValType::I32
+                    && u64::from(u32::MAX)
+                        <= u64::from(bound) + u64::from(heap.offset_guard_size)
+                            - offset_with_access_size =>
+            {
+                let addr = self.context.any_gpr(self.masm);
+                bounds::load_heap_addr_unchecked(self.masm, &heap, index, offset, addr, ptr_size);
+                Some(addr)
+            }
+
+            // Account for the general case of static memories. The access is out
+            // of bounds if:
+            //
+            // index > bound - (offset + access_size)
+            //
+            // bound - (offset + access_size) cannot wrap, because we already
+            // checked that (offset + access_size) > bound, above.
+            HeapStyle::Static { bound } => {
+                let bounds = Bounds::from_u64(bound);
+                let addr = bounds::load_heap_addr_checked(
+                    self.masm,
+                    &mut self.context,
+                    ptr_size,
+                    &heap,
+                    enable_spectre_mitigation,
+                    bounds,
+                    index,
+                    offset,
+                    |masm, bounds, index| {
+                        let adjusted_bounds = bounds.as_u64() - offset_with_access_size;
+                        let index_reg = index.as_typed_reg().reg;
+                        masm.cmp(
+                            index_reg,
+                            RegImm::i64(adjusted_bounds as i64),
+                            // Similar to the dynamic heap case, even though the
+                            // offset and access size are bound through the heap
+                            // type, when added they can overflow, resulting in
+                            // an erroneus comparison, therfore we rely on the
+                            // target pointer size.
+                            ptr_size,
+                        );
+                        IntCmpKind::GtU
+                    },
+                );
+                Some(addr)
+            }
+        };
+
+        self.context.free_reg(index.as_typed_reg().reg);
+        addr
+    }
+
+    /// Emit a WebAssembly load.
+    pub fn emit_wasm_load(
+        &mut self,
+        arg: &MemArg,
+        ty: WasmValType,
+        size: OperandSize,
+        sextend: Option<ExtendKind>,
+    ) {
+        if let Some(addr) = self.emit_compute_heap_address(&arg, size) {
+            let dst = match ty {
+                WasmValType::I32 | WasmValType::I64 => self.context.any_gpr(self.masm),
+                WasmValType::F32 | WasmValType::F64 => self.context.any_fpr(self.masm),
+                WasmValType::V128 => self.context.reg_for_type(ty, self.masm),
+                _ => unreachable!(),
+            };
+
+            let src = self.masm.address_at_reg(addr, 0);
+            self.masm.wasm_load(src, dst, size, sextend);
+            self.context.stack.push(TypedReg::new(ty, dst).into());
+            self.context.free_reg(addr);
+        }
+    }
+
+    /// Emit a WebAssembly store.
+    pub fn emit_wasm_store(&mut self, arg: &MemArg, size: OperandSize) {
+        let src = self.context.pop_to_reg(self.masm, None);
+        if let Some(addr) = self.emit_compute_heap_address(&arg, size) {
+            self.masm
+                .wasm_store(src.reg.into(), self.masm.address_at_reg(addr, 0), size);
+
+            self.context.free_reg(addr);
+        }
+        self.context.free_reg(src);
+    }
+
+    /// Loads the address of the table element at a given index. Returns the
+    /// address of the table element using the provided register as base.
+    pub fn emit_compute_table_elem_addr(
+        &mut self,
+        index: Reg,
+        base: Reg,
+        table_data: &TableData,
+    ) -> M::Address {
+        let scratch = scratch!(M);
+        let bound = self.context.any_gpr(self.masm);
+        let tmp = self.context.any_gpr(self.masm);
+        let ptr_size: OperandSize = self.env.ptr_type().into();
+
+        if let Some(offset) = table_data.import_from {
+            // If the table data declares a particular offset base,
+            // load the address into a register to further use it as
+            // the table address.
+            self.masm.load_ptr(self.masm.address_at_vmctx(offset), base);
+        } else {
+            // Else, simply move the vmctx register into the addr register as
+            // the base to calculate the table address.
+            self.masm.mov(vmctx!(M).into(), base, ptr_size);
+        };
+
+        // OOB check.
+        let bound_addr = self
+            .masm
+            .address_at_reg(base, table_data.current_elems_offset);
+        let bound_size = table_data.current_elements_size;
+        self.masm.load(bound_addr, bound, bound_size.into());
+        self.masm.cmp(index, bound.into(), bound_size);
+        self.masm
+            .trapif(IntCmpKind::GeU, TrapCode::TableOutOfBounds);
+
+        // Move the index into the scratch register to calculate the table
+        // element address.
+        // Moving the value of the index register to the scratch register
+        // also avoids overwriting the context of the index register.
+        self.masm.mov(index.into(), scratch, bound_size);
+        self.masm.mul(
+            scratch,
+            scratch,
+            RegImm::i32(table_data.element_size.bytes() as i32),
+            table_data.element_size,
+        );
+        self.masm
+            .load_ptr(self.masm.address_at_reg(base, table_data.offset), base);
+        // Copy the value of the table base into a temporary register
+        // so that we can use it later in case of a misspeculation.
+        self.masm.mov(base.into(), tmp, ptr_size);
+        // Calculate the address of the table element.
+        self.masm.add(base, base, scratch.into(), ptr_size);
+        if self.env.table_access_spectre_mitigation() {
+            // Perform a bounds check and override the value of the
+            // table element address in case the index is out of bounds.
+            self.masm.cmp(index, bound.into(), OperandSize::S32);
+            self.masm.cmov(tmp, base, IntCmpKind::GeU, ptr_size);
+        }
+        self.context.free_reg(bound);
+        self.context.free_reg(tmp);
+        self.masm.address_at_reg(base, 0)
+    }
+
+    /// Retrieves the size of the table, pushing the result to the value stack.
+    pub fn emit_compute_table_size(&mut self, table_data: &TableData) {
+        let scratch = scratch!(M);
+        let size = self.context.any_gpr(self.masm);
+        let ptr_size: OperandSize = self.env.ptr_type().into();
+
+        if let Some(offset) = table_data.import_from {
+            self.masm
+                .load_ptr(self.masm.address_at_vmctx(offset), scratch);
+        } else {
+            self.masm.mov(vmctx!(M).into(), scratch, ptr_size);
+        };
+
+        let size_addr = self
+            .masm
+            .address_at_reg(scratch, table_data.current_elems_offset);
+        self.masm
+            .load(size_addr, size, table_data.current_elements_size.into());
+
+        self.context.stack.push(TypedReg::i32(size).into());
+    }
+
+    /// Retrieves the size of the memory, pushing the result to the value stack.
+    pub fn emit_compute_memory_size(&mut self, heap_data: &HeapData) {
+        let size_reg = self.context.any_gpr(self.masm);
+        let scratch = scratch!(M);
+
+        let base = if let Some(offset) = heap_data.import_from {
+            self.masm
+                .load_ptr(self.masm.address_at_vmctx(offset), scratch);
+            scratch
+        } else {
+            vmctx!(M)
+        };
+
+        let size_addr = self
+            .masm
+            .address_at_reg(base, heap_data.current_length_offset);
+        self.masm.load_ptr(size_addr, size_reg);
+        // Emit a shift to get the size in pages rather than in bytes.
+        let dst = TypedReg::new(heap_data.ty, size_reg);
+        let pow = heap_data.page_size_log2;
+        self.masm.shift_ir(
+            dst.reg,
+            pow as u64,
+            dst.into(),
+            ShiftKind::ShrU,
+            heap_data.ty.into(),
+        );
+        self.context.stack.push(dst.into());
+    }
 }
 
 /// Returns the index of the [`ControlStackFrame`] for the given
@@ -415,5 +901,5 @@ where
 pub fn control_index(depth: u32, control_length: usize) -> usize {
     (control_length - 1)
         .checked_sub(depth as usize)
-        .unwrap_or_else(|| panic!("expected valid control stack frame at index: {}", depth))
+        .unwrap_or_else(|| panic!("expected valid control stack frame at index: {depth}"))
 }
diff --git a/winch/codegen/src/frame/mod.rs b/winch/codegen/src/frame/mod.rs
index 2979162648e9..1ebdace8daf3 100644
--- a/winch/codegen/src/frame/mod.rs
+++ b/winch/codegen/src/frame/mod.rs
@@ -1,9 +1,12 @@
-use crate::abi::{align_to, ty_size, ABIArg, ABISig, LocalSlot, ABI};
+use crate::{
+    abi::{align_to, ABIOperand, ABISig, LocalSlot, ABI},
+    masm::MacroAssembler,
+};
 use anyhow::Result;
 use smallvec::SmallVec;
 use std::ops::Range;
 use wasmparser::{BinaryReader, FuncValidator, ValidatorResources};
-use wasmtime_environ::{ModuleTranslation, TypeConvert};
+use wasmtime_environ::{TypeConvert, WasmValType};
 
 // TODO:
 // SpiderMonkey's implementation uses 16;
@@ -32,12 +35,12 @@ pub(crate) struct DefinedLocals {
 
 impl DefinedLocals {
     /// Compute the local slots for a Wasm function.
-    pub fn new(
-        translation: &ModuleTranslation<'_>,
+    pub fn new<A: ABI>(
+        types: &impl TypeConvert,
         reader: &mut BinaryReader<'_>,
         validator: &mut FuncValidator<ValidatorResources>,
     ) -> Result<Self> {
-        let mut next_stack = 0;
+        let mut next_stack: u32 = 0;
         // The first 32 bits of a Wasm binary function describe the number of locals.
         let local_count = reader.read_var_u32()?;
         let mut slots: Locals = Default::default();
@@ -48,10 +51,10 @@ impl DefinedLocals {
             let ty = reader.read()?;
             validator.define_locals(position, count, ty)?;
 
-            let ty = translation.module.convert_valtype(ty);
+            let ty = types.convert_valtype(ty);
             for _ in 0..count {
-                let ty_size = ty_size(&ty);
-                next_stack = align_to(next_stack, ty_size) + ty_size;
+                let ty_size = <A as ABI>::sizeof(&ty);
+                next_stack = align_to(next_stack, ty_size as u32) + (ty_size as u32);
                 slots.push(LocalSlot::new(ty, next_stack));
             }
         }
@@ -75,14 +78,17 @@ pub(crate) struct Frame {
     ///
     /// Locals get calculated when allocating a frame and are readonly
     /// through the function compilation lifetime.
-    pub locals: Locals,
+    locals: Locals,
 
     /// The offset to the slot containing the `VMContext`.
     pub vmctx_slot: LocalSlot,
+
+    /// The slot holding the address of the results area.
+    pub results_base_slot: Option<LocalSlot>,
 }
 
 impl Frame {
-    /// Allocate a new Frame.
+    /// Allocate a new [`Frame`].
     pub fn new<A: ABI>(sig: &ABISig, defined_locals: &DefinedLocals) -> Result<Self> {
         let (mut locals, defined_locals_start) = Self::compute_arg_slots::<A>(sig)?;
 
@@ -95,24 +101,100 @@ impl Frame {
                 .map(|l| LocalSlot::new(l.ty, l.offset + defined_locals_start)),
         );
 
-        let vmctx_slots_size = <A as ABI>::word_bytes();
-        let vmctx_offset = defined_locals_start + defined_locals.stack_size + vmctx_slots_size;
+        let stack_align = <A as ABI>::stack_align();
+        let defined_locals_end = align_to(
+            defined_locals_start + defined_locals.stack_size,
+            stack_align as u32,
+        );
 
-        let locals_size = align_to(vmctx_offset, <A as ABI>::stack_align().into());
+        // Handle the results base slot for multi value returns.
+        let (results_base_slot, locals_size) = if sig.params.has_retptr() {
+            match sig.params.unwrap_results_area_operand() {
+                // If the results operand is a stack argument, ensure the
+                // offset is correctly calculated, that is, that it includes the
+                // argument base offset.
+                // In this case, the locals size, remains untouched as we don't
+                // need to create an extra slot for it.
+                ABIOperand::Stack { ty, offset, .. } => (
+                    Some(LocalSlot::stack_arg(
+                        *ty,
+                        *offset + (<A as ABI>::arg_base_offset() as u32),
+                    )),
+                    defined_locals_end,
+                ),
+                // If the results operand is a register, we give this register
+                // the same treatment as all the other argument registers and
+                // spill it, therefore, we need to increase the locals size by
+                // one slot.
+                ABIOperand::Reg { ty, size, .. } => {
+                    let offs = align_to(defined_locals_end, *size) + *size;
+                    (
+                        Some(LocalSlot::new(*ty, offs)),
+                        align_to(offs, <A as ABI>::stack_align().into()),
+                    )
+                }
+            }
+        } else {
+            (None, defined_locals_end)
+        };
 
+        let vmctx_slot = *locals.get(0).expect("LocalSlot for VMContext");
         Ok(Self {
             locals,
             locals_size,
-            vmctx_slot: LocalSlot::i64(vmctx_offset),
+            vmctx_slot,
             defined_locals_range: DefinedLocalsRange(
-                defined_locals_start..defined_locals.stack_size,
+                defined_locals_start..(defined_locals_start + defined_locals.stack_size),
             ),
+            results_base_slot,
         })
     }
 
-    /// Get a local slot.
-    pub fn get_local(&self, index: u32) -> Option<&LocalSlot> {
-        self.locals.get(index as usize)
+    // Winch's ABI uses two extra parameters to store the callee and caller
+    // VMContext pointers.
+    // These arguments are spilled and treated as frame locals, but not
+    // WebAssembly locals.
+    const WASM_LOCALS_OFFSET: usize = 2;
+
+    /// Get the [LocalSlot] for a WebAssembly local.
+    /// This method assumes that the index is bound to u32::MAX, representing
+    /// the index space for WebAssembly locals.
+    ///
+    /// # Panics
+    /// This method panics if the index is not associated to a valid WebAssembly
+    /// local.
+    pub fn get_wasm_local(&self, index: u32) -> &LocalSlot {
+        let local_index = Self::WASM_LOCALS_OFFSET + index as usize;
+        self.locals
+            .get(local_index)
+            .unwrap_or_else(|| panic!(" Expected WebAssembly local at slot: {index}"))
+    }
+
+    /// Get the [LocalSlot] for a frame local.
+    /// This method doesn't make any asumptions about the local index passed in,
+    /// and simply delegates the [LocalSlot] retrieval to the underlying locals
+    /// vector.
+    ///
+    /// # Panics
+    /// This method panics if the index is not associated to a valid WebAssembly
+    /// local.
+    pub fn get_frame_local(&self, index: usize) -> &LocalSlot {
+        self.locals
+            .get(index)
+            .unwrap_or_else(|| panic!(" Expected Frame local at slot: {index}"))
+    }
+
+    /// Returns the address of the local at the given index.
+    ///
+    /// # Panics
+    /// This function panics if the index is not associated to a local.
+    pub fn get_local_address<M: MacroAssembler>(
+        &self,
+        index: u32,
+        masm: &mut M,
+    ) -> (WasmValType, M::Address) {
+        let slot = self.get_wasm_local(index);
+        (slot.ty, masm.local_address(&slot))
     }
 
     fn compute_arg_slots<A: ABI>(sig: &ABISig) -> Result<(Locals, u32)> {
@@ -122,7 +204,7 @@ impl Frame {
         //  for each parameter p; when p
         //
         //  Stack =>
-        //      The slot offset is calculated from the ABIArg offset
+        //      The slot offset is calculated from the ABIOperand offset
         //      relative the to the frame pointer (and its inclusions, e.g.
         //      return address).
         //
@@ -146,27 +228,31 @@ impl Frame {
 
         let arg_base_offset = <A as ABI>::arg_base_offset().into();
         let mut next_stack = 0u32;
+
+        // Skip the results base param; if present, the [Frame] will create
+        // a dedicated slot for it.
         let slots: Locals = sig
-            .params
-            .iter()
+            .params_without_retptr()
+            .into_iter()
             .map(|arg| Self::abi_arg_slot(&arg, &mut next_stack, arg_base_offset))
             .collect();
 
         Ok((slots, next_stack))
     }
 
-    fn abi_arg_slot(arg: &ABIArg, next_stack: &mut u32, arg_base_offset: u32) -> LocalSlot {
+    fn abi_arg_slot(arg: &ABIOperand, next_stack: &mut u32, arg_base_offset: u32) -> LocalSlot {
         match arg {
             // Create a local slot, for input register spilling,
             // with type-size aligned access.
-            ABIArg::Reg { ty, reg: _ } => {
-                let ty_size = ty_size(&ty);
-                *next_stack = align_to(*next_stack, ty_size) + ty_size;
+            ABIOperand::Reg { ty, size, .. } => {
+                *next_stack = align_to(*next_stack, *size) + *size;
                 LocalSlot::new(*ty, *next_stack)
             }
             // Create a local slot, with an offset from the arguments base in
             // the stack; which is the frame pointer + return address.
-            ABIArg::Stack { ty, offset } => LocalSlot::stack_arg(*ty, offset + arg_base_offset),
+            ABIOperand::Stack { ty, offset, .. } => {
+                LocalSlot::stack_arg(*ty, offset + arg_base_offset)
+            }
         }
     }
 }
diff --git a/winch/codegen/src/isa/aarch64/abi.rs b/winch/codegen/src/isa/aarch64/abi.rs
index 8a38a2918d18..e142b036bd96 100644
--- a/winch/codegen/src/isa/aarch64/abi.rs
+++ b/winch/codegen/src/isa/aarch64/abi.rs
@@ -1,47 +1,12 @@
 use super::regs;
-use crate::abi::{ABIArg, ABIResult, ABISig, ABI};
+use crate::abi::{align_to, ABIOperand, ABIParams, ABIResults, ABISig, ParamsOrReturns, ABI};
 use crate::isa::{reg::Reg, CallingConvention};
-use crate::masm::OperandSize;
-use smallvec::SmallVec;
-use wasmtime_environ::{WasmFuncType, WasmType};
+use crate::RegIndexEnv;
+use wasmtime_environ::{WasmHeapType, WasmRefType, WasmValType};
 
 #[derive(Default)]
 pub(crate) struct Aarch64ABI;
 
-/// Helper environment to track argument-register
-/// assignment in aarch64.
-///
-/// The first element tracks the general purpose register index, capped at 7 (x0-x7).
-/// The second element tracks the floating point register index, capped at 7 (v0-v7).
-// Follows
-// https://github.com/ARM-software/abi-aa/blob/2021Q1/aapcs64/aapcs64.rst#64parameter-passing
-#[derive(Default)]
-struct RegIndexEnv(u8, u8);
-
-impl RegIndexEnv {
-    fn next_xreg(&mut self) -> Option<u8> {
-        if self.0 < 8 {
-            return Some(Self::increment(&mut self.0));
-        }
-
-        None
-    }
-
-    fn next_vreg(&mut self) -> Option<u8> {
-        if self.1 < 8 {
-            return Some(Self::increment(&mut self.1));
-        }
-
-        None
-    }
-
-    fn increment(index: &mut u8) -> u8 {
-        let current = *index;
-        *index += 1;
-        current
-    }
-}
-
 impl ABI for Aarch64ABI {
     // TODO change to 16 once SIMD is supported
     fn stack_align() -> u8 {
@@ -56,132 +21,141 @@ impl ABI for Aarch64ABI {
         16
     }
 
-    fn ret_addr_offset() -> u8 {
-        8
-    }
-
-    fn word_bits() -> u32 {
+    fn word_bits() -> u8 {
         64
     }
 
-    fn sig(wasm_sig: &WasmFuncType, call_conv: &CallingConvention) -> ABISig {
-        Self::sig_from(wasm_sig.params(), wasm_sig.returns(), call_conv)
-    }
-
     fn sig_from(
-        params: &[WasmType],
-        returns: &[WasmType],
+        params: &[WasmValType],
+        returns: &[WasmValType],
         call_conv: &CallingConvention,
     ) -> ABISig {
         assert!(call_conv.is_apple_aarch64() || call_conv.is_default());
-
-        if returns.len() > 1 {
-            panic!("multi-value not supported");
-        }
-
-        let mut stack_offset = 0;
-        let mut index_env = RegIndexEnv::default();
-
-        let params: SmallVec<[ABIArg; 6]> = params
-            .iter()
-            .map(|arg| Self::to_abi_arg(arg, &mut stack_offset, &mut index_env))
-            .collect();
-
-        let result = Self::result(returns, call_conv);
-        ABISig::new(params, result, stack_offset)
+        // The first element tracks the general purpose register index, capped at 7 (x0-x7).
+        // The second element tracks the floating point register index, capped at 7 (v0-v7).
+        // Follows
+        // https://github.com/ARM-software/abi-aa/blob/2021Q1/aapcs64/aapcs64.rst#64parameter-passing
+        let mut params_index_env = RegIndexEnv::with_limits_per_class(8, 8);
+        let results = Self::abi_results(returns, call_conv);
+        let params =
+            ABIParams::from::<_, Self>(params, 0, results.on_stack(), |ty, stack_offset| {
+                Self::to_abi_operand(
+                    ty,
+                    stack_offset,
+                    &mut params_index_env,
+                    ParamsOrReturns::Params,
+                )
+            });
+
+        ABISig::new(params, results)
     }
 
-    fn result(returns: &[WasmType], _call_conv: &CallingConvention) -> ABIResult {
-        // This invariant will be lifted once support for multi-value is added.
-        assert!(returns.len() <= 1, "multi-value not supported");
-
-        let ty = returns.get(0).copied();
-        ty.map(|ty| {
-            let reg = match ty {
-                WasmType::I32 | WasmType::I64 => regs::xreg(0),
-                WasmType::F32 | WasmType::F64 => regs::vreg(0),
-                t => panic!("Unsupported return type {:?}", t),
-            };
-            ABIResult::reg(ty, reg)
+    fn abi_results(returns: &[WasmValType], call_conv: &CallingConvention) -> ABIResults {
+        assert!(call_conv.is_apple_aarch64() || call_conv.is_default());
+        // Use absolute count for results given that for Winch's
+        // default CallingConvention only one register is used for results
+        // independent of the register class.
+        // In the case of 2+ results, the rest are passed in the stack,
+        // similar to how Wasmtime handles multi-value returns.
+        let mut returns_index_env = RegIndexEnv::with_absolute_limit(1);
+
+        ABIResults::from(returns, call_conv, |ty, stack_offset| {
+            Self::to_abi_operand(
+                ty,
+                stack_offset,
+                &mut returns_index_env,
+                ParamsOrReturns::Returns,
+            )
         })
-        .unwrap_or_else(|| ABIResult::void())
     }
 
-    fn scratch_reg() -> Reg {
-        regs::scratch()
-    }
-
-    fn sp_reg() -> Reg {
-        todo!()
-    }
-
-    fn fp_reg() -> Reg {
-        regs::fp()
+    fn scratch_for(ty: &WasmValType) -> Reg {
+        match ty {
+            WasmValType::I32
+            | WasmValType::I64
+            | WasmValType::Ref(WasmRefType {
+                heap_type: WasmHeapType::Func,
+                ..
+            }) => regs::scratch(),
+            WasmValType::F32 | WasmValType::F64 | WasmValType::V128 => regs::float_scratch(),
+            _ => unimplemented!(),
+        }
     }
 
     fn vmctx_reg() -> Reg {
         regs::xreg(9)
     }
 
-    fn callee_saved_regs(_call_conv: &CallingConvention) -> SmallVec<[(Reg, OperandSize); 18]> {
-        regs::callee_saved()
+    fn stack_slot_size() -> u8 {
+        Self::word_bytes()
     }
 
-    fn stack_arg_slot_size_for_type(_ty: WasmType) -> u32 {
-        todo!()
+    fn sizeof(ty: &WasmValType) -> u8 {
+        match ty {
+            WasmValType::Ref(rt) => match rt.heap_type {
+                WasmHeapType::Func => Self::word_bytes(),
+                ht => unimplemented!("Support for WasmHeapType: {ht}"),
+            },
+            WasmValType::F64 | WasmValType::I64 => Self::word_bytes(),
+            WasmValType::F32 | WasmValType::I32 => Self::word_bytes() / 2,
+            ty => unimplemented!("Support for WasmType: {ty}"),
+        }
     }
 }
 
 impl Aarch64ABI {
-    fn to_abi_arg(
-        wasm_arg: &WasmType,
-        stack_offset: &mut u32,
+    fn to_abi_operand(
+        wasm_arg: &WasmValType,
+        stack_offset: u32,
         index_env: &mut RegIndexEnv,
-    ) -> ABIArg {
+        params_or_returns: ParamsOrReturns,
+    ) -> (ABIOperand, u32) {
         let (reg, ty) = match wasm_arg {
-            ty @ (WasmType::I32 | WasmType::I64) => (index_env.next_xreg().map(regs::xreg), ty),
+            ty @ (WasmValType::I32 | WasmValType::I64) => {
+                (index_env.next_gpr().map(regs::xreg), ty)
+            }
 
-            ty @ (WasmType::F32 | WasmType::F64) => (index_env.next_vreg().map(regs::vreg), ty),
+            ty @ (WasmValType::F32 | WasmValType::F64) => {
+                (index_env.next_fpr().map(regs::vreg), ty)
+            }
 
             ty => unreachable!("Unsupported argument type {:?}", ty),
         };
 
-        let ty = *ty;
+        let ty_size = <Self as ABI>::sizeof(wasm_arg);
         let default = || {
-            let size = Self::word_bytes();
-            let arg = ABIArg::stack_offset(*stack_offset, ty);
-            *stack_offset += size;
-            arg
+            let arg = ABIOperand::stack_offset(stack_offset, *ty, ty_size as u32);
+            let slot_size = Self::stack_slot_size();
+            // Stack slots for parameters are aligned to a fixed slot size,
+            // in the case of Aarch64, 8 bytes.
+            // Stack slots for returns are type-size aligned.
+            let next_stack = if params_or_returns == ParamsOrReturns::Params {
+                align_to(stack_offset, slot_size as u32) + (slot_size as u32)
+            } else {
+                align_to(stack_offset, ty_size as u32) + (ty_size as u32)
+            };
+            (arg, next_stack)
         };
-        reg.map_or_else(default, |reg| ABIArg::Reg { ty, reg })
+        reg.map_or_else(default, |reg| {
+            (ABIOperand::reg(reg, *ty, ty_size as u32), stack_offset)
+        })
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use super::{Aarch64ABI, RegIndexEnv};
+    use super::Aarch64ABI;
     use crate::{
-        abi::{ABIArg, ABI},
+        abi::{ABIOperand, ABI},
         isa::aarch64::regs,
         isa::reg::Reg,
         isa::CallingConvention,
     };
     use wasmtime_environ::{
         WasmFuncType,
-        WasmType::{self, *},
+        WasmValType::{self, *},
     };
 
-    #[test]
-    fn test_get_next_reg_index() {
-        let mut index_env = RegIndexEnv::default();
-        assert_eq!(index_env.next_xreg(), Some(0));
-        assert_eq!(index_env.next_vreg(), Some(0));
-        assert_eq!(index_env.next_xreg(), Some(1));
-        assert_eq!(index_env.next_vreg(), Some(1));
-        assert_eq!(index_env.next_xreg(), Some(2));
-        assert_eq!(index_env.next_vreg(), Some(2));
-    }
-
     #[test]
     fn xreg_abi_sig() {
         let wasm_sig = WasmFuncType::new(
@@ -245,23 +219,70 @@ mod tests {
         match_reg_arg(params.get(8).unwrap(), F64, regs::vreg(5));
     }
 
-    fn match_reg_arg(abi_arg: &ABIArg, expected_ty: WasmType, expected_reg: Reg) {
+    #[test]
+    fn int_abi_sig_multi_returns() {
+        let wasm_sig = WasmFuncType::new(
+            [I32, I64, I32, I64, I32, I32].into(),
+            [I32, I32, I32].into(),
+        );
+
+        let sig = Aarch64ABI::sig(&wasm_sig, &CallingConvention::Default);
+        let params = sig.params;
+        let results = sig.results;
+
+        match_reg_arg(params.get(0).unwrap(), I32, regs::xreg(0));
+        match_reg_arg(params.get(1).unwrap(), I64, regs::xreg(1));
+        match_reg_arg(params.get(2).unwrap(), I32, regs::xreg(2));
+        match_reg_arg(params.get(3).unwrap(), I64, regs::xreg(3));
+        match_reg_arg(params.get(4).unwrap(), I32, regs::xreg(4));
+        match_reg_arg(params.get(5).unwrap(), I32, regs::xreg(5));
+
+        match_stack_arg(results.get(0).unwrap(), I32, 4);
+        match_stack_arg(results.get(1).unwrap(), I32, 0);
+        match_reg_arg(results.get(2).unwrap(), I32, regs::xreg(0));
+    }
+
+    #[test]
+    fn mixed_abi_sig_multi_returns() {
+        let wasm_sig = WasmFuncType::new(
+            [F32, I32, I64, F64, I32].into(),
+            [I32, F32, I32, F32, I64].into(),
+        );
+
+        let sig = Aarch64ABI::sig(&wasm_sig, &CallingConvention::Default);
+        let params = sig.params;
+        let results = sig.results;
+
+        match_reg_arg(params.get(0).unwrap(), F32, regs::vreg(0));
+        match_reg_arg(params.get(1).unwrap(), I32, regs::xreg(0));
+        match_reg_arg(params.get(2).unwrap(), I64, regs::xreg(1));
+        match_reg_arg(params.get(3).unwrap(), F64, regs::vreg(1));
+        match_reg_arg(params.get(4).unwrap(), I32, regs::xreg(2));
+
+        match_stack_arg(results.get(0).unwrap(), I32, 12);
+        match_stack_arg(results.get(1).unwrap(), F32, 8);
+        match_stack_arg(results.get(2).unwrap(), I32, 4);
+        match_stack_arg(results.get(3).unwrap(), F32, 0);
+        match_reg_arg(results.get(4).unwrap(), I64, regs::xreg(0));
+    }
+
+    fn match_reg_arg(abi_arg: &ABIOperand, expected_ty: WasmValType, expected_reg: Reg) {
         match abi_arg {
-            &ABIArg::Reg { reg, ty } => {
+            &ABIOperand::Reg { reg, ty, .. } => {
                 assert_eq!(reg, expected_reg);
                 assert_eq!(ty, expected_ty);
             }
-            stack => panic!("Expected reg argument, got {:?}", stack),
+            stack => panic!("Expected reg argument, got {stack:?}"),
         }
     }
 
-    fn match_stack_arg(abi_arg: &ABIArg, expected_ty: WasmType, expected_offset: u32) {
+    fn match_stack_arg(abi_arg: &ABIOperand, expected_ty: WasmValType, expected_offset: u32) {
         match abi_arg {
-            &ABIArg::Stack { offset, ty } => {
+            &ABIOperand::Stack { offset, ty, .. } => {
                 assert_eq!(offset, expected_offset);
                 assert_eq!(ty, expected_ty);
             }
-            stack => panic!("Expected stack argument, got {:?}", stack),
+            reg => panic!("Expected stack argument, got {reg:?}"),
         }
     }
 }
diff --git a/winch/codegen/src/isa/aarch64/address.rs b/winch/codegen/src/isa/aarch64/address.rs
index 11521e5ce516..9e888f9898e7 100644
--- a/winch/codegen/src/isa/aarch64/address.rs
+++ b/winch/codegen/src/isa/aarch64/address.rs
@@ -98,7 +98,7 @@ impl TryFrom<Address> for PairAMode {
         match addr {
             IndexedSPOffset { offset, indexing } => {
                 let simm7 = SImm7Scaled::maybe_from_i64(offset, types::I64).with_context(|| {
-                    format!("Failed to convert {} to signed scaled 7 bit offset", offset)
+                    format!("Failed to convert {offset} to signed scaled 7 bit offset")
                 })?;
 
                 if indexing == Pre {
@@ -137,7 +137,6 @@ impl TryFrom<Address> for AMode {
             Offset { base, offset } => Ok(AMode::RegOffset {
                 rn: base.into(),
                 off: offset,
-                ty: types::I64,
             }),
         }
     }
diff --git a/winch/codegen/src/isa/aarch64/asm.rs b/winch/codegen/src/isa/aarch64/asm.rs
index a82f431622c3..d8b1ba085776 100644
--- a/winch/codegen/src/isa/aarch64/asm.rs
+++ b/winch/codegen/src/isa/aarch64/asm.rs
@@ -1,16 +1,22 @@
 //! Assembler library implementation for Aarch64.
 
 use super::{address::Address, regs};
+use crate::masm::{ExtendKind, FloatCmpKind, IntCmpKind, RoundingMode, ShiftKind};
 use crate::{masm::OperandSize, reg::Reg};
+use cranelift_codegen::isa::aarch64::inst::{
+    BitOp, BranchTarget, Cond, CondBrKind, FPULeftShiftImm, FPUOp1, FPUOp2,
+    FPUOpRI::{self, UShr32, UShr64},
+    FPUOpRIMod, FPURightShiftImm, FpuRoundMode, ImmLogic, ImmShift, ScalarSize,
+};
 use cranelift_codegen::{
-    ir::MemFlags,
+    ir::{MemFlags, SourceLoc},
     isa::aarch64::inst::{
         self,
         emit::{EmitInfo, EmitState},
-        ALUOp, ALUOp3, AMode, ExtendOp, Imm12, Inst, PairAMode,
+        ALUOp, ALUOp3, AMode, ExtendOp, Imm12, Inst, PairAMode, VecLanesOp, VecMisc2, VectorSize,
     },
-    settings, Final, MachBuffer, MachBufferFinalized, MachInstEmit, MachInstEmitState, MachLabel,
-    Writable,
+    settings, Final, MachBuffer, MachBufferFinalized, MachInst, MachInstEmit, MachInstEmitState,
+    MachLabel, Writable,
 };
 
 impl From<OperandSize> for inst::OperandSize {
@@ -18,7 +24,49 @@ impl From<OperandSize> for inst::OperandSize {
         match size {
             OperandSize::S32 => Self::Size32,
             OperandSize::S64 => Self::Size64,
-            s => panic!("Invalid operand size {:?}", s),
+            s => panic!("Invalid operand size {s:?}"),
+        }
+    }
+}
+
+impl From<IntCmpKind> for Cond {
+    fn from(value: IntCmpKind) -> Self {
+        match value {
+            IntCmpKind::Eq => Cond::Eq,
+            IntCmpKind::Ne => Cond::Ne,
+            IntCmpKind::LtS => Cond::Lt,
+            IntCmpKind::LtU => Cond::Lo,
+            IntCmpKind::GtS => Cond::Gt,
+            IntCmpKind::GtU => Cond::Hi,
+            IntCmpKind::LeS => Cond::Le,
+            IntCmpKind::LeU => Cond::Ls,
+            IntCmpKind::GeS => Cond::Ge,
+            IntCmpKind::GeU => Cond::Hs,
+        }
+    }
+}
+
+impl From<FloatCmpKind> for Cond {
+    fn from(value: FloatCmpKind) -> Self {
+        match value {
+            FloatCmpKind::Eq => Cond::Eq,
+            FloatCmpKind::Ne => Cond::Ne,
+            FloatCmpKind::Lt => Cond::Mi,
+            FloatCmpKind::Gt => Cond::Gt,
+            FloatCmpKind::Le => Cond::Ls,
+            FloatCmpKind::Ge => Cond::Ge,
+        }
+    }
+}
+
+impl Into<ScalarSize> for OperandSize {
+    fn into(self) -> ScalarSize {
+        match self {
+            OperandSize::S8 => ScalarSize::Size8,
+            OperandSize::S16 => ScalarSize::Size16,
+            OperandSize::S32 => ScalarSize::Size32,
+            OperandSize::S64 => ScalarSize::Size64,
+            OperandSize::S128 => ScalarSize::Size128,
         }
     }
 }
@@ -46,16 +94,31 @@ impl Assembler {
 
 impl Assembler {
     /// Return the emitted code.
-    pub fn finalize(mut self) -> MachBufferFinalized<Final> {
+    pub fn finalize(mut self, loc: Option<SourceLoc>) -> MachBufferFinalized<Final> {
         let constants = Default::default();
         let stencil = self
             .buffer
             .finish(&constants, self.emit_state.ctrl_plane_mut());
-        stencil.apply_base_srcloc(Default::default())
+        stencil.apply_base_srcloc(loc.unwrap_or_default())
     }
 
     fn emit(&mut self, inst: Inst) {
-        inst.emit(&[], &mut self.buffer, &self.emit_info, &mut self.emit_state);
+        self.emit_with_island(inst, Inst::worst_case_size());
+    }
+
+    fn emit_with_island(&mut self, inst: Inst, needed_space: u32) {
+        if self.buffer.island_needed(needed_space) {
+            let label = self.buffer.get_label();
+            let jmp = Inst::Jump {
+                dest: BranchTarget::Label(label),
+            };
+            jmp.emit(&mut self.buffer, &mut self.emit_info, &mut self.emit_state);
+            self.buffer
+                .emit_island(needed_space, self.emit_state.ctrl_plane_mut());
+            self.buffer
+                .bind_label(label, self.emit_state.ctrl_plane_mut());
+        }
+        inst.emit(&mut self.buffer, &self.emit_info, &mut self.emit_state);
     }
 
     /// Load a constant into a register.
@@ -83,43 +146,115 @@ impl Assembler {
         let flags = MemFlags::trusted();
 
         use OperandSize::*;
-        let inst = match size {
-            S64 => Inst::Store64 {
+        let inst = match (reg.is_int(), size) {
+            (_, S8) => Inst::Store8 {
                 rd: reg.into(),
                 mem,
                 flags,
             },
-            S32 => Inst::Store32 {
+            (_, S16) => Inst::Store16 {
+                rd: reg.into(),
+                mem,
+                flags,
+            },
+            (true, S32) => Inst::Store32 {
+                rd: reg.into(),
+                mem,
+                flags,
+            },
+            (false, S32) => Inst::FpuStore32 {
+                rd: reg.into(),
+                mem,
+                flags,
+            },
+            (true, S64) => Inst::Store64 {
+                rd: reg.into(),
+                mem,
+                flags,
+            },
+            (false, S64) => Inst::FpuStore64 {
+                rd: reg.into(),
+                mem,
+                flags,
+            },
+            (_, S128) => Inst::FpuStore128 {
                 rd: reg.into(),
                 mem,
                 flags,
             },
-
-            _ => unreachable!(),
         };
 
         self.emit(inst);
     }
 
+    /// Load a signed register.
+    pub fn sload(&mut self, addr: Address, rd: Reg, size: OperandSize) {
+        self.ldr(addr, rd, size, true);
+    }
+
+    /// Load an unsigned register.
+    pub fn uload(&mut self, addr: Address, rd: Reg, size: OperandSize) {
+        self.ldr(addr, rd, size, false);
+    }
+
     /// Load a register.
-    pub fn ldr(&mut self, addr: Address, rd: Reg, size: OperandSize) {
+    fn ldr(&mut self, addr: Address, rd: Reg, size: OperandSize, signed: bool) {
         use OperandSize::*;
         let writable_reg = Writable::from_reg(rd.into());
         let mem: AMode = addr.try_into().unwrap();
         let flags = MemFlags::trusted();
 
-        let inst = match size {
-            S64 => Inst::ULoad64 {
+        let inst = match (rd.is_int(), signed, size) {
+            (_, false, S8) => Inst::ULoad8 {
                 rd: writable_reg,
                 mem,
                 flags,
             },
-            S32 => Inst::ULoad32 {
+            (_, true, S8) => Inst::SLoad8 {
+                rd: writable_reg,
+                mem,
+                flags,
+            },
+            (_, false, S16) => Inst::ULoad16 {
+                rd: writable_reg,
+                mem,
+                flags,
+            },
+            (_, true, S16) => Inst::SLoad16 {
+                rd: writable_reg,
+                mem,
+                flags,
+            },
+            (true, false, S32) => Inst::ULoad32 {
+                rd: writable_reg,
+                mem,
+                flags,
+            },
+            (false, _, S32) => Inst::FpuLoad32 {
+                rd: writable_reg,
+                mem,
+                flags,
+            },
+            (true, true, S32) => Inst::SLoad32 {
+                rd: writable_reg,
+                mem,
+                flags,
+            },
+            (true, _, S64) => Inst::ULoad64 {
+                rd: writable_reg,
+                mem,
+                flags,
+            },
+            (false, _, S64) => Inst::FpuLoad64 {
+                rd: writable_reg,
+                mem,
+                flags,
+            },
+            (_, _, S128) => Inst::FpuLoad128 {
                 rd: writable_reg,
                 mem,
                 flags,
             },
-            _ => unreachable!(),
         };
 
         self.emit(inst);
@@ -149,6 +284,42 @@ impl Assembler {
         });
     }
 
+    /// Floating point register to register move.
+    pub fn fmov_rr(&mut self, rn: Reg, rd: Reg, size: OperandSize) {
+        let writable = Writable::from_reg(rd.into());
+        let inst = match size {
+            OperandSize::S32 => Inst::FpuMove32 {
+                rd: writable,
+                rn: rn.into(),
+            },
+            OperandSize::S64 => Inst::FpuMove64 {
+                rd: writable,
+                rn: rn.into(),
+            },
+            _ => unreachable!(),
+        };
+
+        self.emit(inst);
+    }
+
+    pub fn mov_to_fpu(&mut self, rn: Reg, rd: Reg, size: OperandSize) {
+        let writable_rd = Writable::from_reg(rd.into());
+        self.emit(Inst::MovToFpu {
+            size: size.into(),
+            rd: writable_rd,
+            rn: rn.into(),
+        });
+    }
+
+    pub fn mov_from_vec(&mut self, rn: Reg, rd: Reg, idx: u8, size: OperandSize) {
+        self.emit(Inst::MovFromVec {
+            rd: Writable::from_reg(rd.into()),
+            rn: rn.into(),
+            idx,
+            size: size.into(),
+        });
+    }
+
     /// Add with three registers.
     pub fn add_rrr(&mut self, rm: Reg, rn: Reg, rd: Reg, size: OperandSize) {
         self.emit_alu_rrr_extend(ALUOp::Add, rm, rn, rd, size);
@@ -166,7 +337,17 @@ impl Assembler {
         }
     }
 
-    /// Substract with three registers.
+    /// Add across Vector.
+    pub fn addv(&mut self, rn: Reg, rd: Reg, size: VectorSize) {
+        self.emit(Inst::VecLanes {
+            op: VecLanesOp::Addv,
+            rd: Writable::from_reg(rd.into()),
+            rn: rn.into(),
+            size,
+        });
+    }
+
+    /// Subtract with three registers.
     pub fn sub_rrr(&mut self, rm: Reg, rn: Reg, rd: Reg, size: OperandSize) {
         self.emit_alu_rrr_extend(ALUOp::Sub, rm, rn, rd, size);
     }
@@ -183,6 +364,23 @@ impl Assembler {
         }
     }
 
+    /// Subtract with three registers, setting flags.
+    pub fn subs_rrr(&mut self, rm: Reg, rn: Reg, size: OperandSize) {
+        self.emit_alu_rrr_extend(ALUOp::SubS, rm, rn, regs::zero(), size);
+    }
+
+    /// Subtract immediate and register, setting flags.
+    pub fn subs_ir(&mut self, imm: u64, rn: Reg, size: OperandSize) {
+        let alu_op = ALUOp::SubS;
+        if let Some(imm) = Imm12::maybe_from_u64(imm) {
+            self.emit_alu_rri(alu_op, imm, rn, regs::zero(), size);
+        } else {
+            let scratch = regs::scratch();
+            self.load_constant(imm, scratch);
+            self.emit_alu_rrr_extend(alu_op, scratch, rn, regs::zero(), size);
+        }
+    }
+
     /// Multiply with three registers.
     pub fn mul_rrr(&mut self, rm: Reg, rn: Reg, rd: Reg, size: OperandSize) {
         self.emit_alu_rrrr(ALUOp3::MAdd, rm, rn, rd, regs::zero(), size);
@@ -195,11 +393,288 @@ impl Assembler {
         self.emit_alu_rrrr(ALUOp3::MAdd, scratch, rn, rd, regs::zero(), size);
     }
 
+    /// And with three registers.
+    pub fn and_rrr(&mut self, rm: Reg, rn: Reg, rd: Reg, size: OperandSize) {
+        self.emit_alu_rrr(ALUOp::And, rm, rn, rd, size);
+    }
+
+    /// And immediate and register.
+    pub fn and_ir(&mut self, imm: u64, rn: Reg, rd: Reg, size: OperandSize) {
+        let alu_op = ALUOp::And;
+        let cl_size: inst::OperandSize = size.into();
+        if let Some(imm) = ImmLogic::maybe_from_u64(imm, cl_size.to_ty()) {
+            self.emit_alu_rri_logic(alu_op, imm, rn, rd, size);
+        } else {
+            let scratch = regs::scratch();
+            self.load_constant(imm, scratch);
+            self.emit_alu_rrr(alu_op, scratch, rn, rd, size);
+        }
+    }
+
+    /// Or with three registers.
+    pub fn or_rrr(&mut self, rm: Reg, rn: Reg, rd: Reg, size: OperandSize) {
+        self.emit_alu_rrr(ALUOp::Orr, rm, rn, rd, size);
+    }
+
+    /// Or immediate and register.
+    pub fn or_ir(&mut self, imm: u64, rn: Reg, rd: Reg, size: OperandSize) {
+        let alu_op = ALUOp::Orr;
+        let cl_size: inst::OperandSize = size.into();
+        if let Some(imm) = ImmLogic::maybe_from_u64(imm, cl_size.to_ty()) {
+            self.emit_alu_rri_logic(alu_op, imm, rn, rd, size);
+        } else {
+            let scratch = regs::scratch();
+            self.load_constant(imm, scratch);
+            self.emit_alu_rrr(alu_op, scratch, rn, rd, size);
+        }
+    }
+
+    /// Xor with three registers.
+    pub fn xor_rrr(&mut self, rm: Reg, rn: Reg, rd: Reg, size: OperandSize) {
+        self.emit_alu_rrr(ALUOp::Eor, rm, rn, rd, size);
+    }
+
+    /// Xor immediate and register.
+    pub fn xor_ir(&mut self, imm: u64, rn: Reg, rd: Reg, size: OperandSize) {
+        let alu_op = ALUOp::Eor;
+        let cl_size: inst::OperandSize = size.into();
+        if let Some(imm) = ImmLogic::maybe_from_u64(imm, cl_size.to_ty()) {
+            self.emit_alu_rri_logic(alu_op, imm, rn, rd, size);
+        } else {
+            let scratch = regs::scratch();
+            self.load_constant(imm, scratch);
+            self.emit_alu_rrr(alu_op, scratch, rn, rd, size);
+        }
+    }
+
+    /// Shift with three registers.
+    pub fn shift_rrr(&mut self, rm: Reg, rn: Reg, rd: Reg, kind: ShiftKind, size: OperandSize) {
+        let shift_op = self.shift_kind_to_alu_op(kind, rm, size);
+        self.emit_alu_rrr(shift_op, rm, rn, rd, size);
+    }
+
+    /// Shift immediate and register.
+    pub fn shift_ir(&mut self, imm: u64, rn: Reg, rd: Reg, kind: ShiftKind, size: OperandSize) {
+        let shift_op = self.shift_kind_to_alu_op(kind, rn, size);
+
+        if let Some(imm) = ImmShift::maybe_from_u64(imm) {
+            self.emit_alu_rri_shift(shift_op, imm, rn, rd, size);
+        } else {
+            let scratch = regs::scratch();
+            self.load_constant(imm, scratch);
+            self.emit_alu_rrr(shift_op, scratch, rn, rd, size);
+        }
+    }
+
+    /// Count Leading Zeros.
+    pub fn clz(&mut self, rn: Reg, rd: Reg, size: OperandSize) {
+        self.emit_bit_rr(BitOp::Clz, rn, rd, size);
+    }
+
+    /// Reverse Bits reverses the bit order in a register.
+    pub fn rbit(&mut self, rn: Reg, rd: Reg, size: OperandSize) {
+        self.emit_bit_rr(BitOp::RBit, rn, rd, size);
+    }
+
+    /// Float add with three registers.
+    pub fn fadd_rrr(&mut self, rm: Reg, rn: Reg, rd: Reg, size: OperandSize) {
+        self.emit_fpu_rrr(FPUOp2::Add, rm, rn, rd, size);
+    }
+
+    /// Float sub with three registers.
+    pub fn fsub_rrr(&mut self, rm: Reg, rn: Reg, rd: Reg, size: OperandSize) {
+        self.emit_fpu_rrr(FPUOp2::Sub, rm, rn, rd, size);
+    }
+
+    /// Float multiply with three registers.
+    pub fn fmul_rrr(&mut self, rm: Reg, rn: Reg, rd: Reg, size: OperandSize) {
+        self.emit_fpu_rrr(FPUOp2::Mul, rm, rn, rd, size);
+    }
+
+    /// Float division with three registers.
+    pub fn fdiv_rrr(&mut self, rm: Reg, rn: Reg, rd: Reg, size: OperandSize) {
+        self.emit_fpu_rrr(FPUOp2::Div, rm, rn, rd, size);
+    }
+
+    /// Float max with three registers.
+    pub fn fmax_rrr(&mut self, rm: Reg, rn: Reg, rd: Reg, size: OperandSize) {
+        self.emit_fpu_rrr(FPUOp2::Max, rm, rn, rd, size);
+    }
+
+    /// Float min with three registers.
+    pub fn fmin_rrr(&mut self, rm: Reg, rn: Reg, rd: Reg, size: OperandSize) {
+        self.emit_fpu_rrr(FPUOp2::Min, rm, rn, rd, size);
+    }
+
+    /// Float neg with two registers.
+    pub fn fneg_rr(&mut self, rn: Reg, rd: Reg, size: OperandSize) {
+        self.emit_fpu_rr(FPUOp1::Neg, rn, rd, size);
+    }
+
+    /// Float abs with two registers.
+    pub fn fabs_rr(&mut self, rn: Reg, rd: Reg, size: OperandSize) {
+        self.emit_fpu_rr(FPUOp1::Abs, rn, rd, size);
+    }
+
+    /// Float sqrt with two registers.
+    pub fn fsqrt_rr(&mut self, rn: Reg, rd: Reg, size: OperandSize) {
+        self.emit_fpu_rr(FPUOp1::Sqrt, rn, rd, size);
+    }
+
+    /// Float round (ceil, trunc, floor) with two registers.
+    pub fn fround_rr(&mut self, rn: Reg, rd: Reg, mode: RoundingMode, size: OperandSize) {
+        let fpu_mode = match (mode, size) {
+            (RoundingMode::Nearest, OperandSize::S32) => FpuRoundMode::Nearest32,
+            (RoundingMode::Up, OperandSize::S32) => FpuRoundMode::Plus32,
+            (RoundingMode::Down, OperandSize::S32) => FpuRoundMode::Minus32,
+            (RoundingMode::Zero, OperandSize::S32) => FpuRoundMode::Zero32,
+            (RoundingMode::Nearest, OperandSize::S64) => FpuRoundMode::Nearest64,
+            (RoundingMode::Up, OperandSize::S64) => FpuRoundMode::Plus64,
+            (RoundingMode::Down, OperandSize::S64) => FpuRoundMode::Minus64,
+            (RoundingMode::Zero, OperandSize::S64) => FpuRoundMode::Zero64,
+            (m, o) => panic!("Invalid rounding mode or operand size {m:?}, {o:?}"),
+        };
+        self.emit_fpu_round(fpu_mode, rn, rd)
+    }
+
+    /// Float unsigned shift right with two registers and an immediate.
+    pub fn fushr_rri(&mut self, rn: Reg, rd: Reg, amount: u8, size: OperandSize) {
+        let imm = FPURightShiftImm {
+            amount: amount,
+            lane_size_in_bits: size.num_bits(),
+        };
+        let ushr = match size {
+            OperandSize::S32 => UShr32(imm),
+            OperandSize::S64 => UShr64(imm),
+            _ => unreachable!(),
+        };
+        self.emit_fpu_rri(ushr, rn, rd)
+    }
+
+    /// Float unsigned shift left and insert with three registers
+    /// and an immediate.
+    pub fn fsli_rri_mod(&mut self, ri: Reg, rn: Reg, rd: Reg, amount: u8, size: OperandSize) {
+        let imm = FPULeftShiftImm {
+            amount: amount,
+            lane_size_in_bits: size.num_bits(),
+        };
+        let sli = match size {
+            OperandSize::S32 => FPUOpRIMod::Sli32(imm),
+            OperandSize::S64 => FPUOpRIMod::Sli64(imm),
+            _ => unreachable!(),
+        };
+        self.emit_fpu_rri_mod(sli, ri, rn, rd)
+    }
+
+    /// Float compare.
+    pub fn fcmp(&mut self, rm: Reg, rn: Reg, size: OperandSize) {
+        self.emit(Inst::FpuCmp {
+            size: size.into(),
+            rn: rn.into(),
+            rm: rm.into(),
+        })
+    }
+
+    /// Change precision of float.
+    pub fn cvt_float_to_float(
+        &mut self,
+        rn: Reg,
+        rd: Reg,
+        src_size: OperandSize,
+        dst_size: OperandSize,
+    ) {
+        let (fpu_op, size) = match (src_size, dst_size) {
+            (OperandSize::S32, OperandSize::S64) => (FPUOp1::Cvt32To64, ScalarSize::Size32),
+            (OperandSize::S64, OperandSize::S32) => (FPUOp1::Cvt64To32, ScalarSize::Size64),
+            _ => unimplemented!(),
+        };
+        self.emit(Inst::FpuRR {
+            fpu_op,
+            size,
+            rd: Writable::from_reg(rd.into()),
+            rn: rn.into(),
+        });
+    }
+
     /// Return instruction.
     pub fn ret(&mut self) {
         self.emit(Inst::Ret {});
     }
 
+    /// An unconditional branch.
+    pub fn jmp(&mut self, target: MachLabel) {
+        self.emit(Inst::Jump {
+            dest: BranchTarget::Label(target),
+        });
+    }
+
+    /// A conditional branch.
+    pub fn jmp_if(&mut self, kind: Cond, taken: MachLabel) {
+        self.emit(Inst::CondBr {
+            taken: BranchTarget::Label(taken),
+            not_taken: BranchTarget::ResolvedOffset(4),
+            kind: CondBrKind::Cond(kind),
+        });
+    }
+
+    /// Emits a jump table sequence.
+    pub fn jmp_table(
+        &mut self,
+        targets: &[MachLabel],
+        default: MachLabel,
+        index: Reg,
+        tmp1: Reg,
+        tmp2: Reg,
+    ) {
+        self.emit_with_island(
+            Inst::JTSequence {
+                default,
+                targets: Box::new(targets.to_vec()),
+                ridx: index.into(),
+                rtmp1: Writable::from_reg(tmp1.into()),
+                rtmp2: Writable::from_reg(tmp2.into()),
+            },
+            // number of bytes needed for the jumptable sequence:
+            // 4 bytes per instruction, with 8 instructions base + the size of
+            // the jumptable more.
+            (4 * (8 + targets.len())).try_into().unwrap(),
+        );
+    }
+
+    /// Conditional Set sets the destination register to 1 if the condition
+    /// is true, and otherwise sets it to 0.
+    pub fn cset(&mut self, rd: Reg, cond: Cond) {
+        self.emit(Inst::CSet {
+            rd: Writable::from_reg(rd.into()),
+            cond,
+        });
+    }
+
+    // Population Count per byte.
+    pub fn cnt(&mut self, rd: Reg) {
+        self.emit(Inst::VecMisc {
+            op: VecMisc2::Cnt,
+            rd: Writable::from_reg(rd.into()),
+            rn: rd.into(),
+            size: VectorSize::Size8x8,
+        });
+    }
+
+    pub fn extend(&mut self, rn: Reg, rd: Reg, kind: ExtendKind) {
+        self.emit(Inst::Extend {
+            rd: Writable::from_reg(rd.into()),
+            rn: rn.into(),
+            signed: kind.signed(),
+            from_bits: kind.from_bits(),
+            to_bits: kind.to_bits(),
+        })
+    }
+
+    /// Bitwise AND (shifted register), setting flags.
+    pub fn ands_rr(&mut self, rn: Reg, rm: Reg, size: OperandSize) {
+        self.emit_alu_rrr(ALUOp::AndS, rm, rn, regs::zero(), size);
+    }
+
     // Helpers for ALU operations.
 
     fn emit_alu_rri(&mut self, op: ALUOp, imm: Imm12, rn: Reg, rd: Reg, size: OperandSize) {
@@ -212,6 +687,50 @@ impl Assembler {
         });
     }
 
+    fn emit_alu_rri_logic(
+        &mut self,
+        op: ALUOp,
+        imm: ImmLogic,
+        rn: Reg,
+        rd: Reg,
+        size: OperandSize,
+    ) {
+        self.emit(Inst::AluRRImmLogic {
+            alu_op: op,
+            size: size.into(),
+            rd: Writable::from_reg(rd.into()),
+            rn: rn.into(),
+            imml: imm,
+        });
+    }
+
+    fn emit_alu_rri_shift(
+        &mut self,
+        op: ALUOp,
+        imm: ImmShift,
+        rn: Reg,
+        rd: Reg,
+        size: OperandSize,
+    ) {
+        self.emit(Inst::AluRRImmShift {
+            alu_op: op,
+            size: size.into(),
+            rd: Writable::from_reg(rd.into()),
+            rn: rn.into(),
+            immshift: imm,
+        });
+    }
+
+    fn emit_alu_rrr(&mut self, op: ALUOp, rm: Reg, rn: Reg, rd: Reg, size: OperandSize) {
+        self.emit(Inst::AluRRR {
+            alu_op: op,
+            size: size.into(),
+            rd: Writable::from_reg(rd.into()),
+            rn: rn.into(),
+            rm: rm.into(),
+        });
+    }
+
     fn emit_alu_rrr_extend(&mut self, op: ALUOp, rm: Reg, rn: Reg, rd: Reg, size: OperandSize) {
         self.emit(Inst::AluRRRExtend {
             alu_op: op,
@@ -234,6 +753,75 @@ impl Assembler {
         });
     }
 
+    fn emit_fpu_rrr(&mut self, op: FPUOp2, rm: Reg, rn: Reg, rd: Reg, size: OperandSize) {
+        self.emit(Inst::FpuRRR {
+            fpu_op: op,
+            size: size.into(),
+            rd: Writable::from_reg(rd.into()),
+            rn: rn.into(),
+            rm: rm.into(),
+        });
+    }
+
+    fn emit_fpu_rri(&mut self, op: FPUOpRI, rn: Reg, rd: Reg) {
+        self.emit(Inst::FpuRRI {
+            fpu_op: op,
+            rd: Writable::from_reg(rd.into()),
+            rn: rn.into(),
+        });
+    }
+
+    fn emit_fpu_rri_mod(&mut self, op: FPUOpRIMod, ri: Reg, rn: Reg, rd: Reg) {
+        self.emit(Inst::FpuRRIMod {
+            fpu_op: op,
+            rd: Writable::from_reg(rd.into()),
+            ri: ri.into(),
+            rn: rn.into(),
+        });
+    }
+
+    fn emit_fpu_rr(&mut self, op: FPUOp1, rn: Reg, rd: Reg, size: OperandSize) {
+        self.emit(Inst::FpuRR {
+            fpu_op: op,
+            size: size.into(),
+            rd: Writable::from_reg(rd.into()),
+            rn: rn.into(),
+        });
+    }
+
+    fn emit_fpu_round(&mut self, op: FpuRoundMode, rn: Reg, rd: Reg) {
+        self.emit(Inst::FpuRound {
+            op: op,
+            rd: Writable::from_reg(rd.into()),
+            rn: rn.into(),
+        });
+    }
+
+    fn emit_bit_rr(&mut self, op: BitOp, rn: Reg, rd: Reg, size: OperandSize) {
+        self.emit(Inst::BitRR {
+            op,
+            size: size.into(),
+            rd: Writable::from_reg(rd.into()),
+            rn: rn.into(),
+        });
+    }
+
+    // Convert ShiftKind to ALUOp. If kind == Rotl, then emulate it by emitting
+    // the negation of the given reg r, and returns ALUOp::RotR.
+    fn shift_kind_to_alu_op(&mut self, kind: ShiftKind, r: Reg, size: OperandSize) -> ALUOp {
+        match kind {
+            ShiftKind::Shl => ALUOp::Lsl,
+            ShiftKind::ShrS => ALUOp::Asr,
+            ShiftKind::ShrU => ALUOp::Lsr,
+            ShiftKind::Rotr => ALUOp::RotR,
+            ShiftKind::Rotl => {
+                // neg(r) is sub(zero, r).
+                self.emit_alu_rrr(ALUOp::Sub, regs::zero(), r, r, size);
+                ALUOp::RotR
+            }
+        }
+    }
+
     /// Get a label from the underlying machine code buffer.
     pub fn get_label(&mut self) -> MachLabel {
         self.buffer.get_label()
@@ -244,4 +832,9 @@ impl Assembler {
     pub fn buffer_mut(&mut self) -> &mut MachBuffer<Inst> {
         &mut self.buffer
     }
+
+    /// Get a reference to the underlying machine buffer.
+    pub fn buffer(&self) -> &MachBuffer<Inst> {
+        &self.buffer
+    }
 }
diff --git a/winch/codegen/src/isa/aarch64/masm.rs b/winch/codegen/src/isa/aarch64/masm.rs
index 880357d60587..aa519f6df99c 100644
--- a/winch/codegen/src/isa/aarch64/masm.rs
+++ b/winch/codegen/src/isa/aarch64/masm.rs
@@ -1,14 +1,22 @@
 use super::{abi::Aarch64ABI, address::Address, asm::Assembler, regs};
 use crate::{
     abi::{self, local::LocalSlot},
-    codegen::{CodeGenContext, TableData},
+    codegen::{ptr_type_from_ptr_size, CodeGenContext, FuncEnv},
     isa::reg::Reg,
     masm::{
-        CalleeKind, CmpKind, DivKind, Imm as I, MacroAssembler as Masm, OperandSize, RegImm,
-        RemKind, RoundingMode, ShiftKind, StackSlot, TrapCode,
+        CalleeKind, DivKind, ExtendKind, FloatCmpKind, Imm as I, IntCmpKind,
+        MacroAssembler as Masm, OperandSize, RegImm, RemKind, RoundingMode, SPOffset, ShiftKind,
+        StackSlot, TrapCode, TruncKind,
     },
 };
-use cranelift_codegen::{settings, Final, MachBufferFinalized, MachLabel};
+use cranelift_codegen::{
+    binemit::CodeOffset,
+    ir::{RelSourceLoc, SourceLoc},
+    isa::aarch64::inst::VectorSize,
+    settings, Final, MachBufferFinalized, MachLabel,
+};
+use regalloc2::RegClass;
+use wasmtime_environ::PtrSize;
 
 /// Aarch64 MacroAssembler.
 pub(crate) struct MacroAssembler {
@@ -16,14 +24,17 @@ pub(crate) struct MacroAssembler {
     asm: Assembler,
     /// Stack pointer offset.
     sp_offset: u32,
+    /// The target pointer size.
+    ptr_size: OperandSize,
 }
 
 impl MacroAssembler {
     /// Create an Aarch64 MacroAssembler.
-    pub fn new(shared_flags: settings::Flags) -> Self {
+    pub fn new(ptr_size: impl PtrSize, shared_flags: settings::Flags) -> Self {
         Self {
             asm: Assembler::new(shared_flags),
             sp_offset: 0u32,
+            ptr_size: ptr_type_from_ptr_size(ptr_size.size()).into(),
         }
     }
 }
@@ -33,7 +44,7 @@ impl Masm for MacroAssembler {
     type Ptr = u8;
     type ABI = Aarch64ABI;
 
-    fn prologue(&mut self) {
+    fn frame_setup(&mut self) {
         let lr = regs::lr();
         let fp = regs::fp();
         let sp = regs::sp();
@@ -44,15 +55,12 @@ impl Masm for MacroAssembler {
         self.move_sp_to_shadow_sp();
     }
 
-    fn epilogue(&mut self, locals_size: u32) {
-        assert!(self.sp_offset == locals_size);
+    fn check_stack(&mut self, _vmctx: Reg) {
+        // TODO: Implement when we have more complete assembler support.
+    }
 
-        let sp = regs::sp();
-        if locals_size > 0 {
-            self.asm
-                .add_ir(locals_size as u64, sp, sp, OperandSize::S64);
-            self.move_sp_to_shadow_sp();
-        }
+    fn frame_restore(&mut self) {
+        assert_eq!(self.sp_offset, 0);
 
         let lr = regs::lr();
         let fp = regs::fp();
@@ -74,12 +82,20 @@ impl Masm for MacroAssembler {
         self.increment_sp(bytes);
     }
 
-    fn free_stack(&mut self, _bytes: u32) {
-        todo!()
+    fn free_stack(&mut self, bytes: u32) {
+        if bytes == 0 {
+            return;
+        }
+
+        let sp = regs::sp();
+        self.asm.add_ir(bytes as u64, sp, sp, OperandSize::S64);
+        self.move_sp_to_shadow_sp();
+
+        self.decrement_sp(bytes);
     }
 
-    fn reset_stack_pointer(&mut self, offset: u32) {
-        self.sp_offset = offset;
+    fn reset_stack_pointer(&mut self, offset: SPOffset) {
+        self.sp_offset = offset.as_u32();
     }
 
     fn local_address(&mut self, local: &LocalSlot) -> Address {
@@ -97,26 +113,20 @@ impl Masm for MacroAssembler {
         Address::offset(reg, offset as i64)
     }
 
-    fn table_elem_address(
-        &mut self,
-        _index: Reg,
-        _size: OperandSize,
-        _table_data: &TableData,
-        _context: &mut CodeGenContext,
-    ) -> Reg {
+    fn address_from_sp(&self, _offset: SPOffset) -> Self::Address {
         todo!()
     }
 
-    fn address_from_sp(&self, _offset: u32) -> Self::Address {
+    fn address_at_sp(&self, _offset: SPOffset) -> Self::Address {
         todo!()
     }
 
-    fn address_at_sp(&self, _offset: u32) -> Self::Address {
+    fn address_at_vmctx(&self, _offset: u32) -> Self::Address {
         todo!()
     }
 
-    fn address_at_vmctx(&self, _offset: u32) -> Self::Address {
-        todo!()
+    fn store_ptr(&mut self, src: Reg, dst: Self::Address) {
+        self.store(src.into(), dst, self.ptr_size);
     }
 
     fn store(&mut self, src: RegImm, dst: Address, size: OperandSize) {
@@ -137,6 +147,10 @@ impl Masm for MacroAssembler {
         self.asm.str(src, dst, size);
     }
 
+    fn wasm_store(&mut self, src: Reg, dst: Self::Address, size: OperandSize) {
+        self.asm.str(src, dst, size);
+    }
+
     fn call(
         &mut self,
         _stack_args_size: u32,
@@ -146,10 +160,30 @@ impl Masm for MacroAssembler {
     }
 
     fn load(&mut self, src: Address, dst: Reg, size: OperandSize) {
-        self.asm.ldr(src, dst, size);
+        self.asm.uload(src, dst, size);
+    }
+
+    fn load_ptr(&mut self, src: Self::Address, dst: Reg) {
+        self.load(src, dst, self.ptr_size);
     }
 
-    fn load_ptr(&mut self, _src: Self::Address, _dst: Reg) {
+    fn wasm_load(
+        &mut self,
+        src: Self::Address,
+        dst: Reg,
+        size: OperandSize,
+        kind: Option<ExtendKind>,
+    ) {
+        // kind is some if the value is signed
+        // unlike x64, unused bits are set to zero so we don't need to extend
+        if kind.is_some() {
+            self.asm.sload(src, dst, size);
+        } else {
+            self.asm.uload(src, dst, size);
+        }
+    }
+
+    fn load_addr(&mut self, _src: Self::Address, _dst: Reg, _size: OperandSize) {
         todo!()
     }
 
@@ -157,12 +191,12 @@ impl Masm for MacroAssembler {
         todo!()
     }
 
-    fn sp_offset(&self) -> u32 {
-        self.sp_offset
+    fn sp_offset(&self) -> SPOffset {
+        SPOffset::from_u32(self.sp_offset)
     }
 
-    fn finalize(self) -> MachBufferFinalized<Final> {
-        self.asm.finalize()
+    fn finalize(self, base: Option<SourceLoc>) -> MachBufferFinalized<Final> {
+        self.asm.finalize(base)
     }
 
     fn mov(&mut self, src: RegImm, dst: Reg, size: OperandSize) {
@@ -171,20 +205,29 @@ impl Masm for MacroAssembler {
                 let imm = match v {
                     I::I32(v) => v as u64,
                     I::I64(v) => v,
-                    _ => panic!(),
+                    I::F32(v) => v as u64,
+                    I::F64(v) => v,
+                    I::V128(_) => todo!(),
                 };
 
                 let scratch = regs::scratch();
-                self.asm.load_constant(imm as u64, scratch);
-                self.asm.mov_rr(scratch, rd, size);
-            }
-            (RegImm::Reg(rs), rd) => {
-                self.asm.mov_rr(rs, rd, size);
+                self.asm.load_constant(imm, scratch);
+                match rd.class() {
+                    RegClass::Int => self.asm.mov_rr(scratch, rd, size),
+                    RegClass::Float => self.asm.mov_to_fpu(scratch, rd, size),
+                    _ => todo!(),
+                }
             }
+            (RegImm::Reg(rs), rd) => match (rs.class(), rd.class()) {
+                (RegClass::Int, RegClass::Int) => self.asm.mov_rr(rs, rd, size),
+                (RegClass::Float, RegClass::Float) => self.asm.fmov_rr(rs, rd, size),
+                (RegClass::Int, RegClass::Float) => self.asm.mov_to_fpu(rs, rd, size),
+                _ => todo!(),
+            },
         }
     }
 
-    fn cmov(&mut self, _src: Reg, _dst: Reg, _cc: CmpKind, _size: OperandSize) {
+    fn cmov(&mut self, _src: Reg, _dst: Reg, _cc: IntCmpKind, _size: OperandSize) {
         todo!()
     }
 
@@ -206,6 +249,17 @@ impl Masm for MacroAssembler {
         }
     }
 
+    fn checked_uadd(
+        &mut self,
+        _dst: Reg,
+        _lhs: Reg,
+        _rhs: RegImm,
+        _size: OperandSize,
+        _trap: TrapCode,
+    ) {
+        todo!()
+    }
+
     fn sub(&mut self, dst: Reg, lhs: Reg, rhs: RegImm, size: OperandSize) {
         match (rhs, lhs, dst) {
             (RegImm::Imm(v), rn, rd) => {
@@ -242,59 +296,227 @@ impl Masm for MacroAssembler {
         }
     }
 
-    fn float_neg(&mut self, _dst: Reg, _size: OperandSize) {
+    fn float_add(&mut self, dst: Reg, lhs: Reg, rhs: Reg, size: OperandSize) {
+        self.asm.fadd_rrr(rhs, lhs, dst, size);
+    }
+
+    fn float_sub(&mut self, dst: Reg, lhs: Reg, rhs: Reg, size: OperandSize) {
+        self.asm.fsub_rrr(rhs, lhs, dst, size);
+    }
+
+    fn float_mul(&mut self, dst: Reg, lhs: Reg, rhs: Reg, size: OperandSize) {
+        self.asm.fmul_rrr(rhs, lhs, dst, size);
+    }
+
+    fn float_div(&mut self, dst: Reg, lhs: Reg, rhs: Reg, size: OperandSize) {
+        self.asm.fdiv_rrr(rhs, lhs, dst, size);
+    }
+
+    fn float_min(&mut self, dst: Reg, lhs: Reg, rhs: Reg, size: OperandSize) {
+        self.asm.fmin_rrr(rhs, lhs, dst, size);
+    }
+
+    fn float_max(&mut self, dst: Reg, lhs: Reg, rhs: Reg, size: OperandSize) {
+        self.asm.fmax_rrr(rhs, lhs, dst, size);
+    }
+
+    fn float_copysign(&mut self, dst: Reg, lhs: Reg, rhs: Reg, size: OperandSize) {
+        let max_shift = match size {
+            OperandSize::S32 => 0x1f,
+            OperandSize::S64 => 0x3f,
+            _ => unreachable!(),
+        };
+        self.asm.fushr_rri(rhs, rhs, max_shift, size);
+        self.asm.fsli_rri_mod(lhs, rhs, dst, max_shift, size);
+    }
+
+    fn float_neg(&mut self, dst: Reg, size: OperandSize) {
+        self.asm.fneg_rr(dst, dst, size);
+    }
+
+    fn float_abs(&mut self, dst: Reg, size: OperandSize) {
+        self.asm.fabs_rr(dst, dst, size);
+    }
+
+    fn float_round<F: FnMut(&mut FuncEnv<Self::Ptr>, &mut CodeGenContext, &mut Self)>(
+        &mut self,
+        mode: RoundingMode,
+        _env: &mut FuncEnv<Self::Ptr>,
+        context: &mut CodeGenContext,
+        size: OperandSize,
+        _fallback: F,
+    ) {
+        let src = context.pop_to_reg(self, None);
+        self.asm.fround_rr(src.into(), src.into(), mode, size);
+        context.stack.push(src.into());
+    }
+
+    fn float_sqrt(&mut self, dst: Reg, src: Reg, size: OperandSize) {
+        self.asm.fsqrt_rr(src, dst, size);
+    }
+
+    fn and(&mut self, dst: Reg, lhs: Reg, rhs: RegImm, size: OperandSize) {
+        match (rhs, lhs, dst) {
+            (RegImm::Imm(v), rn, rd) => {
+                let imm = match v {
+                    I::I32(v) => v as u64,
+                    I::I64(v) => v,
+                    _ => unreachable!(),
+                };
+
+                self.asm.and_ir(imm, rn, rd, size);
+            }
+
+            (RegImm::Reg(rm), rn, rd) => {
+                self.asm.and_rrr(rm, rn, rd, size);
+            }
+        }
+    }
+
+    fn or(&mut self, dst: Reg, lhs: Reg, rhs: RegImm, size: OperandSize) {
+        match (rhs, lhs, dst) {
+            (RegImm::Imm(v), rn, rd) => {
+                let imm = match v {
+                    I::I32(v) => v as u64,
+                    I::I64(v) => v,
+                    _ => unreachable!(),
+                };
+
+                self.asm.or_ir(imm, rn, rd, size);
+            }
+
+            (RegImm::Reg(rm), rn, rd) => {
+                self.asm.or_rrr(rm, rn, rd, size);
+            }
+        }
+    }
+
+    fn xor(&mut self, dst: Reg, lhs: Reg, rhs: RegImm, size: OperandSize) {
+        match (rhs, lhs, dst) {
+            (RegImm::Imm(v), rn, rd) => {
+                let imm = match v {
+                    I::I32(v) => v as u64,
+                    I::I64(v) => v,
+                    _ => unreachable!(),
+                };
+
+                self.asm.xor_ir(imm, rn, rd, size);
+            }
+
+            (RegImm::Reg(rm), rn, rd) => {
+                self.asm.xor_rrr(rm, rn, rd, size);
+            }
+        }
+    }
+
+    fn shift_ir(&mut self, dst: Reg, imm: u64, lhs: Reg, kind: ShiftKind, size: OperandSize) {
+        self.asm.shift_ir(imm, lhs, dst, kind, size)
+    }
+
+    fn shift(&mut self, context: &mut CodeGenContext, kind: ShiftKind, size: OperandSize) {
+        let src = context.pop_to_reg(self, None);
+        let dst = context.pop_to_reg(self, None);
+
+        self.asm
+            .shift_rrr(src.into(), dst.into(), dst.into(), kind, size);
+
+        context.free_reg(src);
+        context.stack.push(dst.into());
+    }
+
+    fn div(&mut self, _context: &mut CodeGenContext, _kind: DivKind, _size: OperandSize) {
         todo!()
     }
 
-    fn float_abs(&mut self, _dst: Reg, _size: OperandSize) {
+    fn rem(&mut self, _context: &mut CodeGenContext, _kind: RemKind, _size: OperandSize) {
         todo!()
     }
 
-    fn float_round(&mut self, _mode: RoundingMode, _dst: Reg, _src: RegImm, _size: OperandSize) {
-        todo!();
+    fn zero(&mut self, reg: Reg) {
+        self.asm.load_constant(0, reg);
+    }
+
+    fn popcnt(&mut self, context: &mut CodeGenContext, size: OperandSize) {
+        let src = context.pop_to_reg(self, None);
+        let tmp = regs::float_scratch();
+        self.asm.mov_to_fpu(src.into(), tmp, size);
+        self.asm.cnt(tmp);
+        self.asm.addv(tmp, tmp, VectorSize::Size8x8);
+        self.asm.mov_from_vec(tmp, src.into(), 0, OperandSize::S8);
+        context.stack.push(src.into());
     }
 
-    fn and(&mut self, _dst: Reg, _lhs: Reg, _rhs: RegImm, _size: OperandSize) {
+    fn signed_truncate(
+        &mut self,
+        _src: Reg,
+        _dst: Reg,
+        _src_size: OperandSize,
+        _dst_size: OperandSize,
+        _kind: TruncKind,
+    ) {
         todo!()
     }
 
-    fn or(&mut self, _dst: Reg, _lhs: Reg, _rhs: RegImm, _size: OperandSize) {
+    fn unsigned_truncate(
+        &mut self,
+        _src: Reg,
+        _dst: Reg,
+        _tmp_fpr: Reg,
+        _src_size: OperandSize,
+        _dst_size: OperandSize,
+        _kind: TruncKind,
+    ) {
         todo!()
     }
 
-    fn xor(&mut self, _dst: Reg, _lhs: Reg, _rhs: RegImm, _size: OperandSize) {
+    fn signed_convert(
+        &mut self,
+        _src: Reg,
+        _dst: Reg,
+        _src_size: OperandSize,
+        _dst_size: OperandSize,
+    ) {
         todo!()
     }
 
-    fn shift(&mut self, _context: &mut CodeGenContext, _kind: ShiftKind, _size: OperandSize) {
+    fn unsigned_convert(
+        &mut self,
+        _src: Reg,
+        _dst: Reg,
+        _tmp_gpr: Reg,
+        _src_size: OperandSize,
+        _dst_size: OperandSize,
+    ) {
         todo!()
     }
 
-    fn div(&mut self, _context: &mut CodeGenContext, _kind: DivKind, _size: OperandSize) {
+    fn reinterpret_float_as_int(&mut self, _src: Reg, _dst: Reg, _size: OperandSize) {
         todo!()
     }
 
-    fn rem(&mut self, _context: &mut CodeGenContext, _kind: RemKind, _size: OperandSize) {
+    fn reinterpret_int_as_float(&mut self, _src: Reg, _dst: Reg, _size: OperandSize) {
         todo!()
     }
 
-    fn zero(&mut self, reg: Reg) {
-        self.asm.load_constant(0, reg);
+    fn demote(&mut self, src: Reg, dst: Reg) {
+        self.asm
+            .cvt_float_to_float(src.into(), dst.into(), OperandSize::S64, OperandSize::S32);
     }
 
-    fn popcnt(&mut self, _context: &mut CodeGenContext, _size: OperandSize) {
-        todo!()
+    fn promote(&mut self, src: Reg, dst: Reg) {
+        self.asm
+            .cvt_float_to_float(src.into(), dst.into(), OperandSize::S32, OperandSize::S64);
     }
 
     fn push(&mut self, reg: Reg, _size: OperandSize) -> StackSlot {
         let size = <Self::ABI as abi::ABI>::word_bytes();
-        self.reserve_stack(size);
+        self.reserve_stack(size as u32);
         let address = Address::from_shadow_sp(size as i64);
         self.asm.str(reg, address, OperandSize::S64);
 
         StackSlot {
-            offset: self.sp_offset,
-            size,
+            offset: SPOffset::from_u32(self.sp_offset),
+            size: size as u32,
         }
     }
 
@@ -302,20 +524,55 @@ impl Masm for MacroAssembler {
         Address::offset(reg, offset as i64)
     }
 
-    fn cmp_with_set(&mut self, _src: RegImm, _dst: Reg, _kind: CmpKind, _size: OperandSize) {
-        todo!()
+    fn cmp_with_set(&mut self, src: RegImm, dst: Reg, kind: IntCmpKind, size: OperandSize) {
+        self.cmp(dst, src, size);
+        self.asm.cset(dst, kind.into());
     }
 
-    fn cmp(&mut self, _src: RegImm, _dest: Reg, _size: OperandSize) {
-        todo!()
+    fn cmp(&mut self, src1: Reg, src2: RegImm, size: OperandSize) {
+        match src2 {
+            RegImm::Reg(src2) => {
+                self.asm.subs_rrr(src2, src1, size);
+            }
+            RegImm::Imm(v) => {
+                let imm = match v {
+                    I::I32(v) => v as u64,
+                    I::I64(v) => v,
+                    _ => unreachable!(),
+                };
+                self.asm.subs_ir(imm, src1, size);
+            }
+        }
     }
 
-    fn clz(&mut self, _src: Reg, _dst: Reg, _size: OperandSize) {
-        todo!()
+    fn float_cmp_with_set(
+        &mut self,
+        src1: Reg,
+        src2: Reg,
+        dst: Reg,
+        kind: FloatCmpKind,
+        size: OperandSize,
+    ) {
+        self.asm.fcmp(src1, src2, size);
+        self.asm.cset(dst, kind.into());
     }
 
-    fn ctz(&mut self, _src: Reg, _dst: Reg, _size: OperandSize) {
-        todo!()
+    fn clz(&mut self, src: Reg, dst: Reg, size: OperandSize) {
+        self.asm.clz(src, dst, size);
+    }
+
+    fn ctz(&mut self, src: Reg, dst: Reg, size: OperandSize) {
+        let scratch = regs::scratch();
+        self.asm.rbit(src, scratch, size);
+        self.asm.clz(scratch, dst, size);
+    }
+
+    fn wrap(&mut self, src: Reg, dst: Reg) {
+        self.asm.mov_rr(src, dst, OperandSize::S32);
+    }
+
+    fn extend(&mut self, src: Reg, dst: Reg, kind: ExtendKind) {
+        self.asm.extend(src, dst, kind);
     }
 
     fn get_label(&mut self) -> MachLabel {
@@ -329,30 +586,73 @@ impl Masm for MacroAssembler {
 
     fn branch(
         &mut self,
-        _kind: CmpKind,
-        _lhs: RegImm,
-        _rhs: Reg,
-        _taken: MachLabel,
-        _size: OperandSize,
+        kind: IntCmpKind,
+        lhs: Reg,
+        rhs: RegImm,
+        taken: MachLabel,
+        size: OperandSize,
     ) {
-        todo!()
+        use IntCmpKind::*;
+
+        match &(lhs, rhs) {
+            (rlhs, RegImm::Reg(rrhs)) => {
+                // If the comparison kind is zero or not zero and both operands
+                // are the same register, emit a ands instruction. Else we emit
+                // a normal comparison.
+                if (kind == Eq || kind == Ne) && (rlhs == rrhs) {
+                    self.asm.ands_rr(*rlhs, *rrhs, size);
+                } else {
+                    self.cmp(lhs, rhs, size);
+                }
+            }
+            _ => self.cmp(lhs, rhs, size),
+        }
+        self.asm.jmp_if(kind.into(), taken);
     }
 
-    fn jmp(&mut self, _target: MachLabel) {
-        todo!()
+    fn jmp(&mut self, target: MachLabel) {
+        self.asm.jmp(target);
     }
 
     fn unreachable(&mut self) {
         todo!()
     }
 
-    fn jmp_table(&mut self, _targets: &[MachLabel], _index: Reg, _tmp: Reg) {
+    fn jmp_table(&mut self, targets: &[MachLabel], index: Reg, tmp: Reg) {
+        // At least one default target.
+        assert!(targets.len() >= 1);
+        let max = targets.len() as u64 - 1;
+        self.asm.subs_ir(max, index, OperandSize::S64);
+        let default_index = max as usize;
+        let default = targets[default_index];
+        let rest = &targets[..default_index];
+        let tmp1 = regs::scratch();
+        self.asm.jmp_table(rest, default, index, tmp1, tmp);
+    }
+
+    fn trap(&mut self, _code: TrapCode) {
         todo!()
     }
 
-    fn trapif(&mut self, _cc: CmpKind, _code: TrapCode) {
+    fn trapz(&mut self, _src: Reg, _code: TrapCode) {
         todo!()
     }
+
+    fn trapif(&mut self, _cc: IntCmpKind, _code: TrapCode) {
+        todo!()
+    }
+
+    fn start_source_loc(&mut self, loc: RelSourceLoc) -> (CodeOffset, RelSourceLoc) {
+        self.asm.buffer_mut().start_srcloc(loc)
+    }
+
+    fn end_source_loc(&mut self) {
+        self.asm.buffer_mut().end_srcloc();
+    }
+
+    fn current_code_offset(&self) -> CodeOffset {
+        self.asm.buffer().cur_offset()
+    }
 }
 
 impl MacroAssembler {
@@ -360,6 +660,10 @@ impl MacroAssembler {
         self.sp_offset += bytes;
     }
 
+    fn decrement_sp(&mut self, bytes: u32) {
+        self.sp_offset -= bytes;
+    }
+
     // Copies the value of the stack pointer to the shadow stack
     // pointer: mov x28, sp
 
diff --git a/winch/codegen/src/isa/aarch64/mod.rs b/winch/codegen/src/isa/aarch64/mod.rs
index 70c61ab9ca31..e955460add58 100644
--- a/winch/codegen/src/isa/aarch64/mod.rs
+++ b/winch/codegen/src/isa/aarch64/mod.rs
@@ -1,14 +1,15 @@
 use self::regs::{ALL_GPR, MAX_FPR, MAX_GPR, NON_ALLOCATABLE_GPR};
+use crate::isa::aarch64::regs::{ALL_FPR, NON_ALLOCATABLE_FPR};
 use crate::{
-    abi::ABI,
-    codegen::{CodeGen, CodeGenContext, FuncEnv},
+    abi::{wasm_sig, ABI},
+    codegen::{CodeGen, CodeGenContext, FuncEnv, TypeConverter},
     frame::{DefinedLocals, Frame},
-    isa::{Builder, CallingConvention, TargetIsa},
+    isa::{Builder, TargetIsa},
     masm::MacroAssembler,
     regalloc::RegAlloc,
     regset::RegBitSet,
     stack::Stack,
-    TrampolineKind,
+    BuiltinFunctions,
 };
 use anyhow::Result;
 use cranelift_codegen::settings::{self, Flags};
@@ -17,7 +18,8 @@ use cranelift_codegen::{MachTextSectionBuilder, TextSectionBuilder};
 use masm::MacroAssembler as Aarch64Masm;
 use target_lexicon::Triple;
 use wasmparser::{FuncValidator, FunctionBody, ValidatorResources};
-use wasmtime_environ::{ModuleTranslation, ModuleTypes, WasmFuncType};
+use wasmtime_cranelift::CompiledFunction;
+use wasmtime_environ::{ModuleTranslation, ModuleTypesBuilder, VMOffsets, WasmFuncType};
 
 mod abi;
 mod address;
@@ -85,37 +87,53 @@ impl TargetIsa for Aarch64 {
     fn compile_function(
         &self,
         sig: &WasmFuncType,
-        types: &ModuleTypes,
         body: &FunctionBody,
         translation: &ModuleTranslation,
+        types: &ModuleTypesBuilder,
+        builtins: &mut BuiltinFunctions,
         validator: &mut FuncValidator<ValidatorResources>,
-    ) -> Result<MachBufferFinalized<Final>> {
+    ) -> Result<CompiledFunction> {
+        let pointer_bytes = self.pointer_bytes();
+        let vmoffsets = VMOffsets::new(pointer_bytes, &translation.module);
         let mut body = body.get_binary_reader();
-        let mut masm = Aarch64Masm::new(self.shared_flags.clone());
+        let mut masm = Aarch64Masm::new(pointer_bytes, self.shared_flags.clone());
         let stack = Stack::new();
-        let abi_sig = abi::Aarch64ABI::sig(sig, &CallingConvention::Default);
+        let abi_sig = wasm_sig::<abi::Aarch64ABI>(sig);
 
-        let defined_locals = DefinedLocals::new(translation, &mut body, validator)?;
+        let env = FuncEnv::new(
+            &vmoffsets,
+            translation,
+            types,
+            builtins,
+            self,
+            abi::Aarch64ABI::ptr_type(),
+        );
+        let type_converter = TypeConverter::new(env.translation, env.types);
+        let defined_locals =
+            DefinedLocals::new::<abi::Aarch64ABI>(&type_converter, &mut body, validator)?;
         let frame = Frame::new::<abi::Aarch64ABI>(&abi_sig, &defined_locals)?;
         let gpr = RegBitSet::int(
             ALL_GPR.into(),
             NON_ALLOCATABLE_GPR.into(),
             usize::try_from(MAX_GPR).unwrap(),
         );
-        // TODO: Add floating point bitmask
-        let fpr = RegBitSet::float(0, 0, usize::try_from(MAX_FPR).unwrap());
-        let regalloc = RegAlloc::from(gpr, fpr);
-        let codegen_context = CodeGenContext::new(regalloc, stack, &frame);
-        let env = FuncEnv::new(
-            self.pointer_bytes(),
-            translation,
-            types,
-            self.wasmtime_call_conv(),
+        let fpr = RegBitSet::float(
+            ALL_FPR.into(),
+            NON_ALLOCATABLE_FPR.into(),
+            usize::try_from(MAX_FPR).unwrap(),
         );
+        let regalloc = RegAlloc::from(gpr, fpr);
+        let codegen_context = CodeGenContext::new(regalloc, stack, frame, &vmoffsets);
         let mut codegen = CodeGen::new(&mut masm, codegen_context, env, abi_sig);
 
         codegen.emit(&mut body, validator)?;
-        Ok(masm.finalize())
+        let names = codegen.env.take_name_map();
+        let base = codegen.source_location.base;
+        Ok(CompiledFunction::new(
+            masm.finalize(base),
+            names,
+            self.function_alignment(),
+        ))
     }
 
     fn text_section_builder(&self, num_funcs: usize) -> Box<dyn TextSectionBuilder> {
@@ -129,11 +147,12 @@ impl TargetIsa for Aarch64 {
         32
     }
 
-    fn compile_trampoline(
+    fn emit_unwind_info(
         &self,
-        _ty: &WasmFuncType,
-        _kind: TrampolineKind,
-    ) -> Result<MachBufferFinalized<Final>> {
-        todo!()
+        _result: &MachBufferFinalized<Final>,
+        _kind: cranelift_codegen::isa::unwind::UnwindInfoKind,
+    ) -> Result<Option<cranelift_codegen::isa::unwind::UnwindInfo>> {
+        // TODO: should fill this in with an actual implementation
+        Ok(None)
     }
 }
diff --git a/winch/codegen/src/isa/aarch64/regs.rs b/winch/codegen/src/isa/aarch64/regs.rs
index ec540b43fe10..8789c6515253 100644
--- a/winch/codegen/src/isa/aarch64/regs.rs
+++ b/winch/codegen/src/isa/aarch64/regs.rs
@@ -1,8 +1,7 @@
 //! AArch64 register definition.
 
-use crate::{isa::reg::Reg, masm::OperandSize};
+use crate::isa::reg::Reg;
 use regalloc2::{PReg, RegClass};
-use smallvec::{smallvec, SmallVec};
 
 /// FPR index bound.
 pub(crate) const MAX_FPR: u32 = 32;
@@ -32,6 +31,11 @@ pub(crate) const fn scratch() -> Reg {
     ip0()
 }
 
+// Alias to register v31.
+pub(crate) const fn float_scratch() -> Reg {
+    vreg(31)
+}
+
 /// Scratch register.
 /// Intra-procedure-call corruptible register.
 pub(crate) const fn ip1() -> Reg {
@@ -93,7 +97,7 @@ pub(crate) const fn sp() -> Reg {
 /// [MacroAssembler::move_sp_to_shadow_sp] function.
 ///
 /// This approach, requires copying the real stack pointer value into
-/// x28 everytime the real stack pointer moves, which involves
+/// x28 every time the real stack pointer moves, which involves
 /// emitting one more instruction. For example, this is generally how
 /// the real stack pointer and x28 will look like during a function:
 ///
@@ -136,7 +140,7 @@ pub(crate) const fn shadow_sp() -> Reg {
     xreg(28)
 }
 
-/// Bitmask for non-allocatble GPR.
+/// Bitmask for non-allocatable GPR.
 pub(crate) const NON_ALLOCATABLE_GPR: u32 = (1 << ip0().hw_enc())
     | (1 << ip1().hw_enc())
     | (1 << platform().hw_enc())
@@ -149,35 +153,9 @@ pub(crate) const NON_ALLOCATABLE_GPR: u32 = (1 << ip0().hw_enc())
 /// Bitmask to represent the available general purpose registers.
 pub(crate) const ALL_GPR: u32 = u32::MAX & !NON_ALLOCATABLE_GPR;
 
-/// Returns the callee-saved registers.
-///
-/// This function will return the set of registers that need to be saved
-/// according to the system ABI and that are known not to be saved during the
-/// prologue emission.
-pub(crate) fn callee_saved() -> SmallVec<[(Reg, OperandSize); 18]> {
-    use OperandSize::*;
-    let regs: SmallVec<[_; 18]> = smallvec![
-        xreg(19),
-        xreg(20),
-        xreg(21),
-        xreg(22),
-        xreg(23),
-        xreg(24),
-        xreg(25),
-        xreg(26),
-        xreg(27),
-        xreg(28),
-        vreg(8),
-        vreg(9),
-        vreg(10),
-        vreg(11),
-        vreg(12),
-        vreg(13),
-        vreg(14),
-        vreg(15),
-    ];
-    // Aarch64's calling convention states that for VReg's only
-    // the lower 64 bits are callee-saved (D8-D15).  See
-    // https://developer.arm.com/documentation/102374/0101/Procedure-Call-Standard
-    regs.into_iter().map(|reg| (reg, S64)).collect()
-}
+/// Bitmask for non-allocatable FPR.
+/// All FPRs are allocatable, v0..=v7 are generally used for params and results.
+pub(crate) const NON_ALLOCATABLE_FPR: u32 = 1 << float_scratch().hw_enc();
+
+/// Bitmask to represent the available floating point registers.
+pub(crate) const ALL_FPR: u32 = u32::MAX & !NON_ALLOCATABLE_FPR;
diff --git a/winch/codegen/src/isa/mod.rs b/winch/codegen/src/isa/mod.rs
index 771fc556f9ac..b54999e025d8 100644
--- a/winch/codegen/src/isa/mod.rs
+++ b/winch/codegen/src/isa/mod.rs
@@ -1,6 +1,7 @@
-use crate::TrampolineKind;
+use crate::BuiltinFunctions;
 use anyhow::{anyhow, Result};
 use core::fmt::Formatter;
+use cranelift_codegen::isa::unwind::{UnwindInfo, UnwindInfoKind};
 use cranelift_codegen::isa::{CallConv, IsaBuilder};
 use cranelift_codegen::settings;
 use cranelift_codegen::{Final, MachBufferFinalized, TextSectionBuilder};
@@ -10,7 +11,8 @@ use std::{
 };
 use target_lexicon::{Architecture, Triple};
 use wasmparser::{FuncValidator, FunctionBody, ValidatorResources};
-use wasmtime_environ::{ModuleTranslation, ModuleTypes, WasmFuncType};
+use wasmtime_cranelift::CompiledFunction;
+use wasmtime_environ::{ModuleTranslation, ModuleTypesBuilder, WasmFuncType};
 
 #[cfg(feature = "x64")]
 pub(crate) mod x64;
@@ -70,24 +72,31 @@ pub(crate) enum LookupError {
     SupportDisabled,
 }
 
-/// Calling conventions supported by Winch. Winch supports the `Wasmtime*`
-/// variations of the system's ABI calling conventions and an internal default
+/// Calling conventions supported by Winch. Winch supports a variation of
+/// the calling conventions defined in this enum plus an internal default
 /// calling convention.
 ///
 /// This enum is a reduced subset of the calling conventions defined in
 /// [cranelift_codegen::isa::CallConv]. Introducing this enum makes it easier
 /// to enforce the invariant of all the calling conventions supported by Winch.
-#[derive(Copy, Clone)]
+///
+/// The main difference between the system calling conventions defined in
+/// this enum and their native counterparts is how multiple returns are handled.
+/// Given that Winch is not meant to be a standalone code generator, the code
+/// it generates is tightly coupled to how Wasmtime expects multiple returns
+/// to be handled: the first return in a register, dictated by the calling
+/// convention and the rest, if any, via a return pointer.
+#[derive(Copy, Clone, Debug)]
 pub enum CallingConvention {
     /// See [cranelift_codegen::isa::CallConv::WasmtimeSystemV]
-    WasmtimeSystemV,
+    SystemV,
     /// See [cranelift_codegen::isa::CallConv::WindowsFastcall]
     WindowsFastcall,
     /// See [cranelift_codegen::isa::CallConv::AppleAarch64]
     AppleAarch64,
     /// The default calling convention for Winch. It largely follows SystemV
     /// for parameter and result handling. This calling convention is part of
-    /// Winch's default ABI [crate::abi::ABI].
+    /// Winch's default ABI `crate::abi::ABI`.
     Default,
 }
 
@@ -103,7 +112,7 @@ impl CallingConvention {
     /// Returns true if the current calling convention is `WasmtimeSystemV`.
     fn is_systemv(&self) -> bool {
         match &self {
-            CallingConvention::WasmtimeSystemV => true,
+            CallingConvention::SystemV => true,
             _ => false,
         }
     }
@@ -117,7 +126,7 @@ impl CallingConvention {
     }
 
     /// Returns true if the current calling convention is `Default`.
-    fn is_default(&self) -> bool {
+    pub fn is_default(&self) -> bool {
         match &self {
             CallingConvention::Default => true,
             _ => false,
@@ -149,11 +158,12 @@ pub trait TargetIsa: Send + Sync {
     fn compile_function(
         &self,
         sig: &WasmFuncType,
-        types: &ModuleTypes,
         body: &FunctionBody,
         translation: &ModuleTranslation,
+        types: &ModuleTypesBuilder,
+        builtins: &mut BuiltinFunctions,
         validator: &mut FuncValidator<ValidatorResources>,
-    ) -> Result<MachBufferFinalized<Final>>;
+    ) -> Result<CompiledFunction>;
 
     /// Get the default calling convention of the underlying target triple.
     fn default_call_conv(&self) -> CallConv {
@@ -165,17 +175,23 @@ pub trait TargetIsa: Send + Sync {
     fn wasmtime_call_conv(&self) -> CallingConvention {
         match self.default_call_conv() {
             CallConv::AppleAarch64 => CallingConvention::AppleAarch64,
-            CallConv::SystemV => CallingConvention::WasmtimeSystemV,
+            CallConv::SystemV => CallingConvention::SystemV,
             CallConv::WindowsFastcall => CallingConvention::WindowsFastcall,
             cc => unimplemented!("calling convention: {:?}", cc),
         }
     }
 
-    /// Get the endianess of the underlying target triple.
+    /// Get the endianness of the underlying target triple.
     fn endianness(&self) -> target_lexicon::Endianness {
         self.triple().endianness().unwrap()
     }
 
+    fn emit_unwind_info(
+        &self,
+        _result: &MachBufferFinalized<Final>,
+        _kind: UnwindInfoKind,
+    ) -> Result<Option<UnwindInfo>>;
+
     /// See `cranelift_codegen::isa::TargetIsa::create_systemv_cie`.
     fn create_systemv_cie(&self) -> Option<gimli::write::CommonInformationEntry> {
         // By default, an ISA cannot create a System V CIE.
@@ -188,16 +204,6 @@ pub trait TargetIsa: Send + Sync {
     /// See `cranelift_codegen::isa::TargetIsa::function_alignment`.
     fn function_alignment(&self) -> u32;
 
-    /// Compile a trampoline kind.
-    ///
-    /// This function, internally dispatches to the right trampoline to emit
-    /// depending on the `kind` paramter.
-    fn compile_trampoline(
-        &self,
-        ty: &WasmFuncType,
-        kind: TrampolineKind,
-    ) -> Result<MachBufferFinalized<Final>>;
-
     /// Returns the pointer width of the ISA in bytes.
     fn pointer_bytes(&self) -> u8 {
         let width = self.triple().pointer_width().unwrap();
@@ -215,3 +221,100 @@ impl Debug for &dyn TargetIsa {
         )
     }
 }
+
+/// Per-class register environment.
+pub(crate) struct RegClassEnv {
+    /// Float register class limit.
+    limit: u8,
+    /// Float register class index.
+    index: u8,
+}
+
+/// Helper environment to track register assignment for Winch's default calling
+/// convention.
+pub(crate) struct RegIndexEnv {
+    /// Int register environment.
+    int: RegClassEnv,
+    /// Float register environment.
+    float: Option<RegClassEnv>,
+}
+
+impl RegIndexEnv {
+    fn with_limits_per_class(int: u8, float: u8) -> Self {
+        let int = RegClassEnv {
+            limit: int,
+            index: 0,
+        };
+
+        let float = RegClassEnv {
+            limit: float,
+            index: 0,
+        };
+
+        Self {
+            int,
+            float: Some(float),
+        }
+    }
+
+    fn with_absolute_limit(limit: u8) -> Self {
+        let int = RegClassEnv { limit, index: 0 };
+
+        Self { int, float: None }
+    }
+}
+
+impl RegIndexEnv {
+    fn next_gpr(&mut self) -> Option<u8> {
+        (self.int.index < self.int.limit)
+            .then(|| Self::increment(&mut self.int.index))
+            .flatten()
+    }
+
+    fn next_fpr(&mut self) -> Option<u8> {
+        if let Some(f) = self.float.as_mut() {
+            (f.index < f.limit)
+                .then(|| Self::increment(&mut f.index))
+                .flatten()
+        } else {
+            // If a single `RegClassEnv` is used, it means that the count is
+            // absolute, so we default to calling `next_gpr`.
+            self.next_gpr()
+        }
+    }
+
+    fn increment(index: &mut u8) -> Option<u8> {
+        let current = *index;
+        match index.checked_add(1) {
+            Some(next) => {
+                *index = next;
+                Some(current)
+            }
+            None => None,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::RegIndexEnv;
+    #[test]
+    fn test_get_next_reg_index() {
+        let mut index_env = RegIndexEnv::with_limits_per_class(3, 3);
+        assert_eq!(index_env.next_fpr(), Some(0));
+        assert_eq!(index_env.next_gpr(), Some(0));
+        assert_eq!(index_env.next_fpr(), Some(1));
+        assert_eq!(index_env.next_gpr(), Some(1));
+        assert_eq!(index_env.next_fpr(), Some(2));
+        assert_eq!(index_env.next_gpr(), Some(2));
+    }
+
+    #[test]
+    fn test_reg_index_env_absolute_count() {
+        let mut e = RegIndexEnv::with_absolute_limit(4);
+        assert!(e.next_gpr() == Some(0));
+        assert!(e.next_fpr() == Some(1));
+        assert!(e.next_gpr() == Some(2));
+        assert!(e.next_fpr() == Some(3));
+    }
+}
diff --git a/winch/codegen/src/isa/x64/abi.rs b/winch/codegen/src/isa/x64/abi.rs
index be52fe9fb455..de5d12be7a1b 100644
--- a/winch/codegen/src/isa/x64/abi.rs
+++ b/winch/codegen/src/isa/x64/abi.rs
@@ -1,67 +1,17 @@
 use super::regs;
 use crate::{
-    abi::{ABIArg, ABIResult, ABISig, ABI},
+    abi::{align_to, ABIOperand, ABIParams, ABIResults, ABISig, ParamsOrReturns, ABI},
     isa::{reg::Reg, CallingConvention},
-    masm::OperandSize,
+    RegIndexEnv,
 };
-use smallvec::SmallVec;
-use wasmtime_environ::{WasmFuncType, WasmType};
-
-/// Helper environment to track argument-register
-/// assignment in x64.
-///
-/// The first element tracks the general purpose register index.
-/// The second element tracks the floating point register index.
-#[derive(Default)]
-struct RegIndexEnv {
-    /// General purpose register index or the field used for absolute
-    /// counts.
-    gpr_or_absolute_count: u8,
-    /// Floating point register index.
-    fpr: u8,
-    /// Whether the count should be absolute rather than per register class.
-    /// When this field is true, only the `gpr_or_absolute_count` field is
-    /// incremented.
-    absolute_count: bool,
-}
-
-impl RegIndexEnv {
-    fn with_absolute_count() -> Self {
-        Self {
-            gpr_or_absolute_count: 0,
-            fpr: 0,
-            absolute_count: true,
-        }
-    }
-}
-
-impl RegIndexEnv {
-    fn next_gpr(&mut self) -> u8 {
-        Self::increment(&mut self.gpr_or_absolute_count)
-    }
-
-    fn next_fpr(&mut self) -> u8 {
-        if self.absolute_count {
-            Self::increment(&mut self.gpr_or_absolute_count)
-        } else {
-            Self::increment(&mut self.fpr)
-        }
-    }
-
-    fn increment(index: &mut u8) -> u8 {
-        let current = *index;
-        *index += 1;
-        current
-    }
-}
+use wasmtime_environ::{WasmHeapType, WasmRefType, WasmValType};
 
 #[derive(Default)]
 pub(crate) struct X64ABI;
 
 impl ABI for X64ABI {
-    // TODO: change to 16 once SIMD is supported
     fn stack_align() -> u8 {
-        8
+        16
     }
 
     fn call_stack_align() -> u8 {
@@ -81,208 +31,288 @@ impl ABI for X64ABI {
         16
     }
 
-    fn ret_addr_offset() -> u8 {
-        // 1 8-byte slot.
-        // ┌──────────┬
-        // │   Ret    │
-        // │   Addr   │
-        // ├──────────┼ * offset
-        // │          │
-        // │   FP     │
-        // └──────────┴
-        8
-    }
-
-    fn word_bits() -> u32 {
+    fn word_bits() -> u8 {
         64
     }
 
     fn sig_from(
-        params: &[WasmType],
-        returns: &[WasmType],
+        params: &[WasmValType],
+        returns: &[WasmValType],
         call_conv: &CallingConvention,
     ) -> ABISig {
         assert!(call_conv.is_fastcall() || call_conv.is_systemv() || call_conv.is_default());
-
-        if returns.len() > 1 {
-            panic!("multi-value not supported");
-        }
-
         let is_fastcall = call_conv.is_fastcall();
         // In the fastcall calling convention, the callee gets a contiguous
         // stack area of 32 bytes (4 register arguments) just before its frame.
         // See
         // https://learn.microsoft.com/en-us/cpp/build/stack-usage?view=msvc-170#stack-allocation
-        let (mut stack_offset, mut index_env) = if is_fastcall {
-            (32, RegIndexEnv::with_absolute_count())
+        let (params_stack_offset, mut params_index_env) = if is_fastcall {
+            (32, RegIndexEnv::with_absolute_limit(4))
         } else {
-            (0, RegIndexEnv::default())
+            (0, RegIndexEnv::with_limits_per_class(6, 8))
         };
 
-        let params: SmallVec<[ABIArg; 6]> = params
-            .iter()
-            .map(|arg| Self::to_abi_arg(arg, &mut stack_offset, &mut index_env, is_fastcall))
-            .collect();
-
-        let result = Self::result(returns, call_conv);
-        ABISig::new(params, result, stack_offset)
-    }
+        let results = Self::abi_results(returns, call_conv);
+        let params = ABIParams::from::<_, Self>(
+            params,
+            params_stack_offset,
+            results.on_stack(),
+            |ty, stack_offset| {
+                Self::to_abi_operand(
+                    ty,
+                    stack_offset,
+                    &mut params_index_env,
+                    call_conv,
+                    ParamsOrReturns::Params,
+                )
+            },
+        );
 
-    fn sig(wasm_sig: &WasmFuncType, call_conv: &CallingConvention) -> ABISig {
-        Self::sig_from(wasm_sig.params(), wasm_sig.returns(), call_conv)
+        ABISig::new(params, results)
     }
 
-    fn result(returns: &[WasmType], _call_conv: &CallingConvention) -> ABIResult {
-        // This invariant will be lifted once support for multi-value is added.
-        assert!(returns.len() <= 1, "multi-value not supported");
-        let ty = returns.get(0).copied();
-        ty.map(|ty| {
-            let reg = match ty {
-                // The `Default`, `WasmtimeFastcall` and `WasmtimeSystemV use `rax` and `xmm0`.
-                // NOTE This should be updated when supporting multi-value.
-                WasmType::I32 | WasmType::I64 => regs::rax(),
-                WasmType::F32 | WasmType::F64 => regs::xmm0(),
-                t => panic!("Unsupported return type {:?}", t),
-            };
-            ABIResult::reg(ty, reg)
+    fn abi_results(returns: &[WasmValType], call_conv: &CallingConvention) -> ABIResults {
+        assert!(call_conv.is_default() || call_conv.is_fastcall() || call_conv.is_systemv());
+        // Use absolute count for results given that for Winch's
+        // default CallingConvention only one register is used for results
+        // independent of the register class.
+        // In the case of 2+ results, the rest are passed in the stack,
+        // similar to how Wasmtime handles multi-value returns.
+        let mut results_index_env = RegIndexEnv::with_absolute_limit(1);
+        ABIResults::from(returns, call_conv, |ty, offset| {
+            Self::to_abi_operand(
+                ty,
+                offset,
+                &mut results_index_env,
+                call_conv,
+                ParamsOrReturns::Returns,
+            )
         })
-        .unwrap_or_else(|| ABIResult::void())
     }
 
-    fn scratch_reg() -> Reg {
-        regs::scratch()
-    }
-
-    fn fp_reg() -> Reg {
-        regs::rbp()
-    }
-
-    fn sp_reg() -> Reg {
-        regs::rsp()
+    fn scratch_for(ty: &WasmValType) -> Reg {
+        match ty {
+            WasmValType::I32
+            | WasmValType::I64
+            | WasmValType::Ref(WasmRefType {
+                heap_type: WasmHeapType::Func,
+                ..
+            }) => regs::scratch(),
+            WasmValType::F32 | WasmValType::F64 | WasmValType::V128 => regs::scratch_xmm(),
+            _ => unimplemented!(),
+        }
     }
 
     fn vmctx_reg() -> Reg {
         regs::vmctx()
     }
 
-    fn callee_saved_regs(call_conv: &CallingConvention) -> SmallVec<[(Reg, OperandSize); 18]> {
-        regs::callee_saved(call_conv)
+    fn stack_slot_size() -> u8 {
+        // Winch default calling convention follows SysV calling convention so
+        // we use one 8 byte slot for values that are smaller or equal to 8
+        // bytes in size and 2 8 byte slots for values that are 128 bits.
+        // See Section 3.2.3 in
+        // https://refspecs.linuxbase.org/elf/x86_64-abi-0.99.pdf for further
+        // details.
+        Self::word_bytes()
     }
 
-    fn stack_arg_slot_size_for_type(ty: WasmType) -> u32 {
+    fn sizeof(ty: &WasmValType) -> u8 {
         match ty {
-            WasmType::F64 | WasmType::I32 | WasmType::I64 => Self::word_bytes(),
-            WasmType::F32 => Self::word_bytes() / 2,
-            _ => unreachable!(),
+            WasmValType::Ref(rt) => match rt.heap_type {
+                WasmHeapType::Func | WasmHeapType::Extern => Self::word_bytes(),
+                ht => unimplemented!("Support for WasmHeapType: {ht}"),
+            },
+            WasmValType::F64 | WasmValType::I64 => Self::word_bytes(),
+            WasmValType::F32 | WasmValType::I32 => Self::word_bytes() / 2,
+            WasmValType::V128 => Self::word_bytes() * 2,
         }
     }
 }
 
 impl X64ABI {
-    fn to_abi_arg(
-        wasm_arg: &WasmType,
-        stack_offset: &mut u32,
+    fn to_abi_operand(
+        wasm_arg: &WasmValType,
+        stack_offset: u32,
         index_env: &mut RegIndexEnv,
-        fastcall: bool,
-    ) -> ABIArg {
+        call_conv: &CallingConvention,
+        params_or_returns: ParamsOrReturns,
+    ) -> (ABIOperand, u32) {
         let (reg, ty) = match wasm_arg {
-            ty @ (WasmType::I32 | WasmType::I64) => {
-                (Self::int_reg_for(index_env.next_gpr(), fastcall), ty)
-            }
-
-            ty @ (WasmType::F32 | WasmType::F64) => {
-                (Self::float_reg_for(index_env.next_fpr(), fastcall), ty)
-            }
-
-            ty => unreachable!("Unsupported argument type {:?}", ty),
+            ty @ WasmValType::Ref(rt) => match rt.heap_type {
+                WasmHeapType::Func | WasmHeapType::Extern => (
+                    Self::int_reg_for(index_env.next_gpr(), call_conv, params_or_returns),
+                    ty,
+                ),
+                ht => unimplemented!("Support for WasmHeapType: {ht}"),
+            },
+
+            ty @ (WasmValType::I32 | WasmValType::I64) => (
+                Self::int_reg_for(index_env.next_gpr(), call_conv, params_or_returns),
+                ty,
+            ),
+
+            // v128 also uses an XMM register (that is, an fpr).
+            ty @ (WasmValType::F32 | WasmValType::F64 | WasmValType::V128) => (
+                Self::float_reg_for(index_env.next_fpr(), call_conv, params_or_returns),
+                ty,
+            ),
         };
 
+        let ty_size = <Self as ABI>::sizeof(wasm_arg);
         let default = || {
-            let arg = ABIArg::stack_offset(*stack_offset, *ty);
-            let size = Self::stack_arg_slot_size_for_type(*ty);
-            *stack_offset += size;
-            arg
+            let arg = ABIOperand::stack_offset(stack_offset, *ty, ty_size as u32);
+            let slot_size = Self::stack_slot_size();
+            // Stack slots for parameters are aligned to a fixed slot size,
+            // in the case of x64, 8 bytes. Except if they are v128 values,
+            // in which case they use 16 bytes.
+            // Stack slots for returns are type-size aligned.
+            let next_stack = if params_or_returns == ParamsOrReturns::Params {
+                let alignment = if *ty == WasmValType::V128 {
+                    ty_size
+                } else {
+                    slot_size
+                };
+                align_to(stack_offset, alignment as u32) + (alignment as u32)
+            } else {
+                // For the default calling convention, we don't type-size align,
+                // given that results on the stack must match spills generated
+                // from within the compiler, which are not type-size aligned.
+                if call_conv.is_default() {
+                    stack_offset + (ty_size as u32)
+                } else {
+                    align_to(stack_offset, ty_size as u32) + (ty_size as u32)
+                }
+            };
+            (arg, next_stack)
         };
 
-        reg.map_or_else(default, |reg| ABIArg::reg(reg, *ty))
+        reg.map_or_else(default, |reg| {
+            (ABIOperand::reg(reg, *ty, ty_size as u32), stack_offset)
+        })
     }
 
-    fn int_reg_for(index: u8, fastcall: bool) -> Option<Reg> {
-        match (fastcall, index) {
-            (false, 0) => Some(regs::rdi()),
-            (false, 1) => Some(regs::rsi()),
-            (false, 2) => Some(regs::rdx()),
-            (false, 3) => Some(regs::rcx()),
-            (false, 4) => Some(regs::r8()),
-            (false, 5) => Some(regs::r9()),
-            (true, 0) => Some(regs::rcx()),
-            (true, 1) => Some(regs::rdx()),
-            (true, 2) => Some(regs::r8()),
-            (true, 3) => Some(regs::r9()),
-            _ => None,
+    fn int_reg_for(
+        index: Option<u8>,
+        call_conv: &CallingConvention,
+        params_or_returns: ParamsOrReturns,
+    ) -> Option<Reg> {
+        use ParamsOrReturns::*;
+
+        let index = match index {
+            None => return None,
+            Some(index) => index,
+        };
+
+        if call_conv.is_fastcall() {
+            return match (index, params_or_returns) {
+                (0, Params) => Some(regs::rcx()),
+                (1, Params) => Some(regs::rdx()),
+                (2, Params) => Some(regs::r8()),
+                (3, Params) => Some(regs::r9()),
+                (0, Returns) => Some(regs::rax()),
+                _ => None,
+            };
         }
+
+        if call_conv.is_systemv() || call_conv.is_default() {
+            return match (index, params_or_returns) {
+                (0, Params) => Some(regs::rdi()),
+                (1, Params) => Some(regs::rsi()),
+                (2, Params) => Some(regs::rdx()),
+                (3, Params) => Some(regs::rcx()),
+                (4, Params) => Some(regs::r8()),
+                (5, Params) => Some(regs::r9()),
+                (0, Returns) => Some(regs::rax()),
+                _ => None,
+            };
+        }
+
+        None
     }
 
-    fn float_reg_for(index: u8, fastcall: bool) -> Option<Reg> {
-        match (fastcall, index) {
-            (false, 0) => Some(regs::xmm0()),
-            (false, 1) => Some(regs::xmm1()),
-            (false, 2) => Some(regs::xmm2()),
-            (false, 3) => Some(regs::xmm3()),
-            (false, 4) => Some(regs::xmm4()),
-            (false, 5) => Some(regs::xmm5()),
-            (false, 6) => Some(regs::xmm6()),
-            (false, 7) => Some(regs::xmm7()),
-            (true, 0) => Some(regs::xmm0()),
-            (true, 1) => Some(regs::xmm1()),
-            (true, 2) => Some(regs::xmm2()),
-            (true, 3) => Some(regs::xmm3()),
-            _ => None,
+    fn float_reg_for(
+        index: Option<u8>,
+        call_conv: &CallingConvention,
+        params_or_returns: ParamsOrReturns,
+    ) -> Option<Reg> {
+        use ParamsOrReturns::*;
+
+        let index = match index {
+            None => return None,
+            Some(index) => index,
+        };
+
+        if call_conv.is_fastcall() {
+            return match (index, params_or_returns) {
+                (0, Params) => Some(regs::xmm0()),
+                (1, Params) => Some(regs::xmm1()),
+                (2, Params) => Some(regs::xmm2()),
+                (3, Params) => Some(regs::xmm3()),
+                (0, Returns) => Some(regs::xmm0()),
+                _ => None,
+            };
         }
+
+        if call_conv.is_systemv() || call_conv.is_default() {
+            return match (index, params_or_returns) {
+                (0, Params) => Some(regs::xmm0()),
+                (1, Params) => Some(regs::xmm1()),
+                (2, Params) => Some(regs::xmm2()),
+                (3, Params) => Some(regs::xmm3()),
+                (4, Params) => Some(regs::xmm4()),
+                (5, Params) => Some(regs::xmm5()),
+                (6, Params) => Some(regs::xmm6()),
+                (7, Params) => Some(regs::xmm7()),
+                (0, Returns) => Some(regs::xmm0()),
+                _ => None,
+            };
+        }
+
+        None
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use super::{RegIndexEnv, X64ABI};
+    use super::X64ABI;
     use crate::{
-        abi::{ABIArg, ABI},
-        isa::reg::Reg,
-        isa::x64::regs,
-        isa::CallingConvention,
+        abi::{ABIOperand, ABI},
+        isa::{reg::Reg, x64::regs, CallingConvention},
     };
     use wasmtime_environ::{
         WasmFuncType,
-        WasmType::{self, *},
+        WasmValType::{self, *},
     };
 
     #[test]
-    fn test_get_next_reg_index() {
-        let mut index_env = RegIndexEnv::default();
-        assert_eq!(index_env.next_fpr(), 0);
-        assert_eq!(index_env.next_gpr(), 0);
-        assert_eq!(index_env.next_fpr(), 1);
-        assert_eq!(index_env.next_gpr(), 1);
-        assert_eq!(index_env.next_fpr(), 2);
-        assert_eq!(index_env.next_gpr(), 2);
-    }
+    fn int_abi_sig() {
+        let wasm_sig =
+            WasmFuncType::new([I32, I64, I32, I64, I32, I32, I64, I32].into(), [].into());
 
-    #[test]
-    fn test_reg_index_env_absolute_count() {
-        let mut e = RegIndexEnv::with_absolute_count();
-        assert!(e.next_gpr() == 0);
-        assert!(e.next_fpr() == 1);
-        assert!(e.next_gpr() == 2);
-        assert!(e.next_fpr() == 3);
+        let sig = X64ABI::sig(&wasm_sig, &CallingConvention::Default);
+        let params = sig.params;
+
+        match_reg_arg(params.get(0).unwrap(), I32, regs::rdi());
+        match_reg_arg(params.get(1).unwrap(), I64, regs::rsi());
+        match_reg_arg(params.get(2).unwrap(), I32, regs::rdx());
+        match_reg_arg(params.get(3).unwrap(), I64, regs::rcx());
+        match_reg_arg(params.get(4).unwrap(), I32, regs::r8());
+        match_reg_arg(params.get(5).unwrap(), I32, regs::r9());
+        match_stack_arg(params.get(6).unwrap(), I64, 0);
+        match_stack_arg(params.get(7).unwrap(), I32, 8);
     }
 
     #[test]
-    fn int_abi_sig() {
-        let wasm_sig =
-            WasmFuncType::new([I32, I64, I32, I64, I32, I32, I64, I32].into(), [].into());
+    fn int_abi_sig_multi_returns() {
+        let wasm_sig = WasmFuncType::new(
+            [I32, I64, I32, I64, I32, I32, I64, I32].into(),
+            [I32, I32, I32].into(),
+        );
 
         let sig = X64ABI::sig(&wasm_sig, &CallingConvention::Default);
         let params = sig.params;
+        let results = sig.results;
 
         match_reg_arg(params.get(0).unwrap(), I32, regs::rdi());
         match_reg_arg(params.get(1).unwrap(), I64, regs::rsi());
@@ -292,6 +322,10 @@ mod tests {
         match_reg_arg(params.get(5).unwrap(), I32, regs::r9());
         match_stack_arg(params.get(6).unwrap(), I64, 0);
         match_stack_arg(params.get(7).unwrap(), I32, 8);
+
+        match_stack_arg(results.get(0).unwrap(), I32, 4);
+        match_stack_arg(results.get(1).unwrap(), I32, 0);
+        match_reg_arg(results.get(2).unwrap(), I32, regs::rax());
     }
 
     #[test]
@@ -315,6 +349,40 @@ mod tests {
         match_stack_arg(params.get(8).unwrap(), F64, 0);
     }
 
+    #[test]
+    fn vector_abi_sig() {
+        let wasm_sig = WasmFuncType::new(
+            [V128, V128, V128, V128, V128, V128, V128, V128, V128, V128].into(),
+            [].into(),
+        );
+
+        let sig = X64ABI::sig(&wasm_sig, &CallingConvention::Default);
+        let params = sig.params;
+
+        match_reg_arg(params.get(0).unwrap(), V128, regs::xmm0());
+        match_reg_arg(params.get(1).unwrap(), V128, regs::xmm1());
+        match_reg_arg(params.get(2).unwrap(), V128, regs::xmm2());
+        match_reg_arg(params.get(3).unwrap(), V128, regs::xmm3());
+        match_reg_arg(params.get(4).unwrap(), V128, regs::xmm4());
+        match_reg_arg(params.get(5).unwrap(), V128, regs::xmm5());
+        match_reg_arg(params.get(6).unwrap(), V128, regs::xmm6());
+        match_reg_arg(params.get(7).unwrap(), V128, regs::xmm7());
+        match_stack_arg(params.get(8).unwrap(), V128, 0);
+        match_stack_arg(params.get(9).unwrap(), V128, 16);
+    }
+
+    #[test]
+    fn vector_abi_sig_multi_returns() {
+        let wasm_sig = WasmFuncType::new([].into(), [V128, V128, V128].into());
+
+        let sig = X64ABI::sig(&wasm_sig, &CallingConvention::Default);
+        let results = sig.results;
+
+        match_stack_arg(results.get(0).unwrap(), V128, 16);
+        match_stack_arg(results.get(1).unwrap(), V128, 0);
+        match_reg_arg(results.get(2).unwrap(), V128, regs::xmm0());
+    }
+
     #[test]
     fn mixed_abi_sig() {
         let wasm_sig = WasmFuncType::new(
@@ -343,7 +411,7 @@ mod tests {
             [].into(),
         );
 
-        let sig = X64ABI::sig(&wasm_sig, &CallingConvention::WasmtimeSystemV);
+        let sig = X64ABI::sig(&wasm_sig, &CallingConvention::SystemV);
         let params = sig.params;
 
         match_reg_arg(params.get(0).unwrap(), F32, regs::xmm0());
@@ -375,23 +443,52 @@ mod tests {
         match_stack_arg(params.get(5).unwrap(), F32, 40);
     }
 
-    fn match_reg_arg(abi_arg: &ABIArg, expected_ty: WasmType, expected_reg: Reg) {
+    #[test]
+    fn fastcall_call_conv_multi_returns() {
+        let wasm_sig = WasmFuncType::new(
+            [F32, I32, I64, F64, I32, F32, F64, F32, F64].into(),
+            [I32, F32, I32, F32, I64].into(),
+        );
+
+        let sig = X64ABI::sig(&wasm_sig, &CallingConvention::WindowsFastcall);
+        let params = sig.params;
+        let results = sig.results;
+
+        match_reg_arg(params.get(0).unwrap(), F32, regs::xmm0());
+        match_reg_arg(params.get(1).unwrap(), I32, regs::rdx());
+        match_reg_arg(params.get(2).unwrap(), I64, regs::r8());
+        match_reg_arg(params.get(3).unwrap(), F64, regs::xmm3());
+        // Each argument stack slot is 8 bytes.
+        match_stack_arg(params.get(4).unwrap(), I32, 32);
+        match_stack_arg(params.get(5).unwrap(), F32, 40);
+
+        match_reg_arg(results.get(0).unwrap(), I32, regs::rax());
+
+        match_stack_arg(results.get(1).unwrap(), F32, 0);
+        match_stack_arg(results.get(2).unwrap(), I32, 4);
+        match_stack_arg(results.get(3).unwrap(), F32, 8);
+        match_stack_arg(results.get(4).unwrap(), I64, 12);
+    }
+
+    #[cfg(test)]
+    fn match_reg_arg(abi_arg: &ABIOperand, expected_ty: WasmValType, expected_reg: Reg) {
         match abi_arg {
-            &ABIArg::Reg { reg, ty } => {
+            &ABIOperand::Reg { reg, ty, .. } => {
                 assert_eq!(reg, expected_reg);
                 assert_eq!(ty, expected_ty);
             }
-            stack => panic!("Expected reg argument, got {:?}", stack),
+            stack => panic!("Expected reg argument, got {stack:?}"),
         }
     }
 
-    fn match_stack_arg(abi_arg: &ABIArg, expected_ty: WasmType, expected_offset: u32) {
+    #[cfg(test)]
+    fn match_stack_arg(abi_arg: &ABIOperand, expected_ty: WasmValType, expected_offset: u32) {
         match abi_arg {
-            &ABIArg::Stack { offset, ty } => {
+            &ABIOperand::Stack { offset, ty, .. } => {
                 assert_eq!(offset, expected_offset);
                 assert_eq!(ty, expected_ty);
             }
-            stack => panic!("Expected stack argument, got {:?}", stack),
+            reg => panic!("Expected stack argument, got {reg:?}"),
         }
     }
 }
diff --git a/winch/codegen/src/isa/x64/asm.rs b/winch/codegen/src/isa/x64/asm.rs
index 6b94c5ad73c5..79eab2a8078b 100644
--- a/winch/codegen/src/isa/x64/asm.rs
+++ b/winch/codegen/src/isa/x64/asm.rs
@@ -1,13 +1,16 @@
 //! Assembler library implementation for x64.
 
 use crate::{
-    isa::reg::{Reg, RegClass},
-    masm::{CmpKind, DivKind, OperandSize, RemKind, RoundingMode, ShiftKind},
+    isa::reg::Reg,
+    masm::{DivKind, ExtendKind, IntCmpKind, OperandSize, RemKind, RoundingMode, ShiftKind},
 };
 use cranelift_codegen::{
-    entity::EntityRef,
-    ir::{types, ConstantPool, ExternalName, Opcode, TrapCode, UserExternalNameRef},
+    ir::{
+        types, ConstantPool, ExternalName, LibCall, MemFlags, SourceLoc, TrapCode,
+        UserExternalNameRef,
+    },
     isa::{
+        unwind::UnwindInst,
         x64::{
             args::{
                 self, AluRmiROpcode, Amode, CmpOpcode, DivSignedness, ExtMode, FromWritableReg,
@@ -15,16 +18,16 @@ use cranelift_codegen::{
                 ShiftKind as CraneliftShiftKind, SseOpcode, SyntheticAmode, WritableGpr,
                 WritableXmm, Xmm, XmmMem, XmmMemAligned, CC,
             },
-            settings as x64_settings, CallInfo, EmitInfo, EmitState, Inst,
+            encoding::rex::{encode_modrm, RexFlags},
+            settings as x64_settings, EmitInfo, EmitState, Inst,
         },
-        CallConv,
     },
     settings, Final, MachBuffer, MachBufferFinalized, MachInstEmit, MachInstEmitState, MachLabel,
-    VCodeConstantData, VCodeConstants, Writable,
+    PatchRegion, RelocDistance, VCodeConstantData, VCodeConstants, Writable,
 };
 
 use super::address::Address;
-use smallvec::{smallvec, SmallVec};
+use smallvec::SmallVec;
 
 // Conversions between winch-codegen x64 types and cranelift-codegen x64 types.
 
@@ -56,40 +59,42 @@ impl From<Reg> for WritableXmm {
 
 impl From<Reg> for Gpr {
     fn from(reg: Reg) -> Self {
-        Gpr::new(reg.into()).expect("valid gpr")
+        Gpr::unwrap_new(reg.into())
     }
 }
 
 impl From<Reg> for GprMem {
     fn from(value: Reg) -> Self {
-        GprMem::new(value.into()).expect("valid gpr")
+        GprMem::unwrap_new(value.into())
     }
 }
 
 impl From<Reg> for GprMemImm {
     fn from(reg: Reg) -> Self {
-        GprMemImm::new(reg.into()).expect("valid gpr")
+        GprMemImm::unwrap_new(reg.into())
     }
 }
 
 impl From<Reg> for Imm8Gpr {
     fn from(value: Reg) -> Self {
-        Imm8Gpr::new(Imm8Reg::Reg { reg: value.into() }).expect("valid Imm8Gpr")
+        Imm8Gpr::unwrap_new(Imm8Reg::Reg { reg: value.into() })
     }
 }
 
 impl From<Reg> for Xmm {
     fn from(reg: Reg) -> Self {
-        Xmm::new(reg.into()).expect("valid Xmm register")
+        Xmm::unwrap_new(reg.into())
     }
 }
 
 impl From<OperandSize> for args::OperandSize {
     fn from(size: OperandSize) -> Self {
         match size {
+            OperandSize::S8 => Self::Size8,
+            OperandSize::S16 => Self::Size16,
             OperandSize::S32 => Self::Size32,
             OperandSize::S64 => Self::Size64,
-            s => panic!("Invalid operand size {:?}", s),
+            s => panic!("Invalid operand size {s:?}"),
         }
     }
 }
@@ -103,19 +108,19 @@ impl From<DivKind> for DivSignedness {
     }
 }
 
-impl From<CmpKind> for CC {
-    fn from(value: CmpKind) -> Self {
+impl From<IntCmpKind> for CC {
+    fn from(value: IntCmpKind) -> Self {
         match value {
-            CmpKind::Eq => CC::Z,
-            CmpKind::Ne => CC::NZ,
-            CmpKind::LtS => CC::L,
-            CmpKind::LtU => CC::B,
-            CmpKind::GtS => CC::NLE,
-            CmpKind::GtU => CC::NBE,
-            CmpKind::LeS => CC::LE,
-            CmpKind::LeU => CC::BE,
-            CmpKind::GeS => CC::NL,
-            CmpKind::GeU => CC::NB,
+            IntCmpKind::Eq => CC::Z,
+            IntCmpKind::Ne => CC::NZ,
+            IntCmpKind::LtS => CC::L,
+            IntCmpKind::LtU => CC::B,
+            IntCmpKind::GtS => CC::NLE,
+            IntCmpKind::GtU => CC::NBE,
+            IntCmpKind::LeS => CC::LE,
+            IntCmpKind::LeU => CC::BE,
+            IntCmpKind::GeS => CC::NL,
+            IntCmpKind::GeU => CC::NB,
         }
     }
 }
@@ -132,6 +137,34 @@ impl From<ShiftKind> for CraneliftShiftKind {
     }
 }
 
+impl From<ExtendKind> for ExtMode {
+    fn from(value: ExtendKind) -> Self {
+        match value {
+            ExtendKind::I64ExtendI32S | ExtendKind::I64ExtendI32U | ExtendKind::I64Extend32S => {
+                ExtMode::LQ
+            }
+            ExtendKind::I32Extend8S => ExtMode::BL,
+            ExtendKind::I32Extend16S => ExtMode::WL,
+            ExtendKind::I64Extend8S => ExtMode::BQ,
+            ExtendKind::I64Extend16S => ExtMode::WQ,
+        }
+    }
+}
+
+impl From<OperandSize> for Option<ExtMode> {
+    // Helper for cases in which it's known that the widening must be
+    // to quadword.
+    fn from(value: OperandSize) -> Self {
+        use OperandSize::*;
+        match value {
+            S128 | S64 => None,
+            S8 => Some(ExtMode::BQ),
+            S16 => Some(ExtMode::WQ),
+            S32 => Some(ExtMode::LQ),
+        }
+    }
+}
+
 /// Low level assembler implementation for x64.
 pub(crate) struct Assembler {
     /// The machine instruction buffer.
@@ -167,6 +200,11 @@ impl Assembler {
         &mut self.buffer
     }
 
+    /// Get a reference to the underlying machine buffer.
+    pub fn buffer(&self) -> &MachBuffer<Inst> {
+        &self.buffer
+    }
+
     /// Adds a constant to the constant pool and returns its address.
     pub fn add_constant(&mut self, constant: &[u8]) -> Address {
         let handle = self.pool.insert(constant.into());
@@ -174,15 +212,15 @@ impl Assembler {
     }
 
     /// Return the emitted code.
-    pub fn finalize(mut self) -> MachBufferFinalized<Final> {
+    pub fn finalize(mut self, loc: Option<SourceLoc>) -> MachBufferFinalized<Final> {
         let stencil = self
             .buffer
             .finish(&self.constants, self.emit_state.ctrl_plane_mut());
-        stencil.apply_base_srcloc(Default::default())
+        stencil.apply_base_srcloc(loc.unwrap_or_default())
     }
 
     fn emit(&mut self, inst: Inst) {
-        inst.emit(&[], &mut self.buffer, &self.emit_info, &mut self.emit_state);
+        inst.emit(&mut self.buffer, &self.emit_info, &mut self.emit_state);
     }
 
     fn to_synthetic_amode(
@@ -190,25 +228,38 @@ impl Assembler {
         pool: &mut ConstantPool,
         constants: &mut VCodeConstants,
         buffer: &mut MachBuffer<Inst>,
+        memflags: MemFlags,
     ) -> SyntheticAmode {
         match addr {
             Address::Offset { base, offset } => {
-                SyntheticAmode::real(Amode::imm_reg(*offset as i32, (*base).into()))
+                let amode = Amode::imm_reg(*offset as i32, (*base).into()).with_flags(memflags);
+                SyntheticAmode::real(amode)
             }
             Address::Const(c) => {
                 // Defer the creation of the
                 // `SyntheticAmode::ConstantOffset` addressing mode
                 // until the address is referenced by an actual
-                // instrunction.
+                // instruction.
                 let constant_data = pool.get(*c);
                 let data = VCodeConstantData::Pool(*c, constant_data.clone());
+                // If the constant data is not marked as used, it will be
+                // inserted, therefore, it needs to be registered.
+                let needs_registration = !constants.pool_uses(&data);
                 let constant = constants.insert(VCodeConstantData::Pool(*c, constant_data.clone()));
-                buffer.register_constant(&constant, &data);
+
+                if needs_registration {
+                    buffer.register_constant(&constant, &data);
+                }
                 SyntheticAmode::ConstantOffset(constant)
             }
         }
     }
 
+    /// Emit an unwind instruction.
+    pub fn emit_unwind_inst(&mut self, inst: UnwindInst) {
+        self.emit(Inst::Unwind { inst })
+    }
+
     /// Push register.
     pub fn push_r(&mut self, reg: Reg) {
         self.emit(Inst::Push64 { src: reg.into() });
@@ -238,10 +289,15 @@ impl Assembler {
     }
 
     /// Register-to-memory move.
-    pub fn mov_rm(&mut self, src: Reg, addr: &Address, size: OperandSize) {
+    pub fn mov_rm(&mut self, src: Reg, addr: &Address, size: OperandSize, flags: MemFlags) {
         assert!(addr.is_offset());
-        let dst =
-            Self::to_synthetic_amode(addr, &mut self.pool, &mut self.constants, &mut self.buffer);
+        let dst = Self::to_synthetic_amode(
+            addr,
+            &mut self.pool,
+            &mut self.constants,
+            &mut self.buffer,
+            flags,
+        );
         self.emit(Inst::MovRM {
             size: size.into(),
             src: src.into(),
@@ -250,10 +306,15 @@ impl Assembler {
     }
 
     /// Immediate-to-memory move.
-    pub fn mov_im(&mut self, src: i32, addr: &Address, size: OperandSize) {
+    pub fn mov_im(&mut self, src: i32, addr: &Address, size: OperandSize, flags: MemFlags) {
         assert!(addr.is_offset());
-        let dst =
-            Self::to_synthetic_amode(addr, &mut self.pool, &mut self.constants, &mut self.buffer);
+        let dst = Self::to_synthetic_amode(
+            addr,
+            &mut self.pool,
+            &mut self.constants,
+            &mut self.buffer,
+            flags,
+        );
         self.emit(Inst::MovImmM {
             size: size.into(),
             simm32: src,
@@ -273,30 +334,75 @@ impl Assembler {
         });
     }
 
-    /// Memory-to-register load.
-    pub fn mov_mr(&mut self, addr: &Address, dst: Reg, size: OperandSize) {
-        use OperandSize::S64;
-
-        let src =
-            Self::to_synthetic_amode(addr, &mut self.pool, &mut self.constants, &mut self.buffer);
+    /// Zero-extend memory-to-register load.
+    pub fn movzx_mr(&mut self, addr: &Address, dst: Reg, ext: Option<ExtMode>, memflags: MemFlags) {
+        let src = Self::to_synthetic_amode(
+            addr,
+            &mut self.pool,
+            &mut self.constants,
+            &mut self.buffer,
+            memflags,
+        );
 
-        if size == S64 {
-            self.emit(Inst::Mov64MR {
-                src,
+        if let Some(ext) = ext {
+            let reg_mem = RegMem::mem(src);
+            self.emit(Inst::MovzxRmR {
+                ext_mode: ext,
+                src: GprMem::unwrap_new(reg_mem),
                 dst: dst.into(),
             });
         } else {
-            let reg_mem = RegMem::mem(src);
-            self.emit(Inst::MovzxRmR {
-                ext_mode: ExtMode::LQ,
-                src: GprMem::new(reg_mem).expect("valid memory address"),
+            self.emit(Inst::Mov64MR {
+                src,
                 dst: dst.into(),
             });
         }
     }
 
+    // Sign-extend memory-to-register load.
+    pub fn movsx_mr(
+        &mut self,
+        addr: &Address,
+        dst: Reg,
+        ext: impl Into<ExtMode>,
+        memflags: MemFlags,
+    ) {
+        let src = Self::to_synthetic_amode(
+            addr,
+            &mut self.pool,
+            &mut self.constants,
+            &mut self.buffer,
+            memflags,
+        );
+
+        let reg_mem = RegMem::mem(src);
+        self.emit(Inst::MovsxRmR {
+            ext_mode: ext.into(),
+            src: GprMem::unwrap_new(reg_mem),
+            dst: dst.into(),
+        })
+    }
+
+    /// Register-to-register move with zero extension.
+    pub fn movzx_rr(&mut self, src: Reg, dst: Reg, kind: ExtendKind) {
+        self.emit(Inst::MovzxRmR {
+            ext_mode: kind.into(),
+            src: src.into(),
+            dst: dst.into(),
+        })
+    }
+
+    /// Register-to-register move with sign extension.
+    pub fn movsx_rr(&mut self, src: Reg, dst: Reg, kind: ExtendKind) {
+        self.emit(Inst::MovsxRmR {
+            ext_mode: kind.into(),
+            src: src.into(),
+            dst: dst.into(),
+        });
+    }
+
     /// Integer register conditional move.
-    pub fn cmov(&mut self, src: Reg, dst: Reg, cc: CmpKind, size: OperandSize) {
+    pub fn cmov(&mut self, src: Reg, dst: Reg, cc: IntCmpKind, size: OperandSize) {
         self.emit(Inst::Cmove {
             size: size.into(),
             cc: cc.into(),
@@ -315,17 +421,18 @@ impl Assembler {
             S32 => SseOpcode::Movaps,
             S64 => SseOpcode::Movapd,
             S128 => SseOpcode::Movdqa,
+            S8 | S16 => unreachable!(),
         };
 
         self.emit(Inst::XmmUnaryRmRUnaligned {
             op,
-            src: XmmMem::new(src.into()).expect("valid xmm unaligned"),
+            src: XmmMem::unwrap_new(src.into()),
             dst: dst.into(),
         });
     }
 
     /// Single and double precision floating point load.
-    pub fn xmm_mov_mr(&mut self, src: &Address, dst: Reg, size: OperandSize) {
+    pub fn xmm_mov_mr(&mut self, src: &Address, dst: Reg, size: OperandSize, flags: MemFlags) {
         use OperandSize::*;
 
         assert!(dst.is_float());
@@ -333,19 +440,25 @@ impl Assembler {
             S32 => SseOpcode::Movss,
             S64 => SseOpcode::Movsd,
             S128 => SseOpcode::Movdqu,
+            S16 | S8 => unreachable!(),
         };
 
-        let src =
-            Self::to_synthetic_amode(src, &mut self.pool, &mut self.constants, &mut self.buffer);
+        let src = Self::to_synthetic_amode(
+            src,
+            &mut self.pool,
+            &mut self.constants,
+            &mut self.buffer,
+            flags,
+        );
         self.emit(Inst::XmmUnaryRmRUnaligned {
             op,
-            src: XmmMem::new(RegMem::mem(src)).expect("valid xmm unaligned"),
+            src: XmmMem::unwrap_new(RegMem::mem(src)),
             dst: dst.into(),
         });
     }
 
     /// Single and double precision floating point store.
-    pub fn xmm_mov_rm(&mut self, src: Reg, dst: &Address, size: OperandSize) {
+    pub fn xmm_mov_rm(&mut self, src: Reg, dst: &Address, size: OperandSize, flags: MemFlags) {
         use OperandSize::*;
 
         assert!(src.is_float());
@@ -354,10 +467,16 @@ impl Assembler {
             S32 => SseOpcode::Movss,
             S64 => SseOpcode::Movsd,
             S128 => SseOpcode::Movdqu,
+            S16 | S8 => unreachable!(),
         };
 
-        let dst =
-            Self::to_synthetic_amode(dst, &mut self.pool, &mut self.constants, &mut self.buffer);
+        let dst = Self::to_synthetic_amode(
+            dst,
+            &mut self.pool,
+            &mut self.constants,
+            &mut self.buffer,
+            flags,
+        );
         self.emit(Inst::XmmMovRM {
             op,
             src: src.into(),
@@ -366,18 +485,19 @@ impl Assembler {
     }
 
     /// Floating point register conditional move.
-    pub fn xmm_cmov(&mut self, src: Reg, dst: Reg, cc: CmpKind, size: OperandSize) {
+    pub fn xmm_cmov(&mut self, src: Reg, dst: Reg, cc: IntCmpKind, size: OperandSize) {
         let ty = match size {
             OperandSize::S32 => types::F32,
             OperandSize::S64 => types::F64,
             // Move the entire 128 bits via movdqa.
-            OperandSize::S128 => types::I128,
+            OperandSize::S128 => types::I32X4,
+            OperandSize::S8 | OperandSize::S16 => unreachable!(),
         };
 
         self.emit(Inst::XmmCmove {
             ty,
             cc: cc.into(),
-            consequent: XmmMemAligned::new(src.into()).expect("valid XmmMemAligned"),
+            consequent: Xmm::unwrap_new(src.into()),
             alternative: dst.into(),
             dst: dst.into(),
         })
@@ -402,39 +522,20 @@ impl Assembler {
             size: size.into(),
             op: AluRmiROpcode::Sub,
             src1: dst.into(),
-            src2: GprMemImm::new(imm).expect("valid immediate"),
+            src2: GprMemImm::unwrap_new(imm),
             dst: dst.into(),
         });
     }
 
     /// "and" two registers.
     pub fn and_rr(&mut self, src: Reg, dst: Reg, size: OperandSize) {
-        match dst.class() {
-            RegClass::Int => {
-                self.emit(Inst::AluRmiR {
-                    size: size.into(),
-                    op: AluRmiROpcode::And,
-                    src1: dst.into(),
-                    src2: src.into(),
-                    dst: dst.into(),
-                });
-            }
-            RegClass::Float => {
-                let op = match size {
-                    OperandSize::S32 => SseOpcode::Andps,
-                    OperandSize::S64 => SseOpcode::Andpd,
-                    OperandSize::S128 => unreachable!(),
-                };
-
-                self.emit(Inst::XmmRmR {
-                    op,
-                    src1: dst.into(),
-                    src2: XmmMemAligned::from(Xmm::from(src)),
-                    dst: dst.into(),
-                });
-            }
-            RegClass::Vector => unreachable!(),
-        }
+        self.emit(Inst::AluRmiR {
+            size: size.into(),
+            op: AluRmiROpcode::And,
+            src1: dst.into(),
+            src2: src.into(),
+            dst: dst.into(),
+        });
     }
 
     pub fn and_ir(&mut self, imm: i32, dst: Reg, size: OperandSize) {
@@ -443,7 +544,39 @@ impl Assembler {
             size: size.into(),
             op: AluRmiROpcode::And,
             src1: dst.into(),
-            src2: GprMemImm::new(imm).expect("valid immediate"),
+            src2: GprMemImm::unwrap_new(imm),
+            dst: dst.into(),
+        });
+    }
+
+    /// "and" two float registers.
+    pub fn xmm_and_rr(&mut self, src: Reg, dst: Reg, size: OperandSize) {
+        let op = match size {
+            OperandSize::S32 => SseOpcode::Andps,
+            OperandSize::S64 => SseOpcode::Andpd,
+            OperandSize::S8 | OperandSize::S16 | OperandSize::S128 => unreachable!(),
+        };
+
+        self.emit(Inst::XmmRmR {
+            op,
+            src1: dst.into(),
+            src2: XmmMemAligned::from(Xmm::from(src)),
+            dst: dst.into(),
+        });
+    }
+
+    /// "and not" two float registers.
+    pub fn xmm_andn_rr(&mut self, src: Reg, dst: Reg, size: OperandSize) {
+        let op = match size {
+            OperandSize::S32 => SseOpcode::Andnps,
+            OperandSize::S64 => SseOpcode::Andnpd,
+            OperandSize::S8 | OperandSize::S16 | OperandSize::S128 => unreachable!(),
+        };
+
+        self.emit(Inst::XmmRmR {
+            op,
+            src1: dst.into(),
+            src2: Xmm::from(src).into(),
             dst: dst.into(),
         });
     }
@@ -452,7 +585,7 @@ impl Assembler {
         let op = match size {
             OperandSize::S32 => SseOpcode::Movd,
             OperandSize::S64 => SseOpcode::Movq,
-            OperandSize::S128 => unreachable!(),
+            OperandSize::S8 | OperandSize::S16 | OperandSize::S128 => unreachable!(),
         };
 
         self.emit(Inst::GprToXmm {
@@ -463,6 +596,129 @@ impl Assembler {
         })
     }
 
+    pub fn xmm_to_gpr(&mut self, src: Reg, dst: Reg, size: OperandSize) {
+        let op = match size {
+            OperandSize::S32 => SseOpcode::Movd,
+            OperandSize::S64 => SseOpcode::Movq,
+            OperandSize::S8 | OperandSize::S16 | OperandSize::S128 => unreachable!(),
+        };
+
+        self.emit(Inst::XmmToGpr {
+            op,
+            src: src.into(),
+            dst: dst.into(),
+            dst_size: size.into(),
+        });
+    }
+
+    /// Convert float to signed int.
+    pub fn cvt_float_to_sint_seq(
+        &mut self,
+        src: Reg,
+        dst: Reg,
+        tmp_gpr: Reg,
+        tmp_xmm: Reg,
+        src_size: OperandSize,
+        dst_size: OperandSize,
+        saturating: bool,
+    ) {
+        self.emit(Inst::CvtFloatToSintSeq {
+            dst_size: dst_size.into(),
+            src_size: src_size.into(),
+            is_saturating: saturating,
+            src: src.into(),
+            dst: dst.into(),
+            tmp_gpr: tmp_gpr.into(),
+            tmp_xmm: tmp_xmm.into(),
+        });
+    }
+
+    /// Convert float to unsigned int.
+    pub fn cvt_float_to_uint_seq(
+        &mut self,
+        src: Reg,
+        dst: Reg,
+        tmp_gpr: Reg,
+        tmp_xmm: Reg,
+        tmp_xmm2: Reg,
+        src_size: OperandSize,
+        dst_size: OperandSize,
+        saturating: bool,
+    ) {
+        self.emit(Inst::CvtFloatToUintSeq {
+            dst_size: dst_size.into(),
+            src_size: src_size.into(),
+            is_saturating: saturating,
+            src: src.into(),
+            dst: dst.into(),
+            tmp_gpr: tmp_gpr.into(),
+            tmp_xmm: tmp_xmm.into(),
+            tmp_xmm2: tmp_xmm2.into(),
+        });
+    }
+
+    /// Convert signed int to float.
+    pub fn cvt_sint_to_float(
+        &mut self,
+        src: Reg,
+        dst: Reg,
+        src_size: OperandSize,
+        dst_size: OperandSize,
+    ) {
+        let op = match dst_size {
+            OperandSize::S32 => SseOpcode::Cvtsi2ss,
+            OperandSize::S64 => SseOpcode::Cvtsi2sd,
+            OperandSize::S16 | OperandSize::S8 | OperandSize::S128 => unreachable!(),
+        };
+        self.emit(Inst::CvtIntToFloat {
+            op,
+            src1: dst.into(),
+            src2: src.into(),
+            dst: dst.into(),
+            src2_size: src_size.into(),
+        });
+    }
+
+    /// Convert unsigned 64-bit int to float.
+    pub fn cvt_uint64_to_float_seq(
+        &mut self,
+        src: Reg,
+        dst: Reg,
+        tmp_gpr1: Reg,
+        tmp_gpr2: Reg,
+        dst_size: OperandSize,
+    ) {
+        self.emit(Inst::CvtUint64ToFloatSeq {
+            dst_size: dst_size.into(),
+            src: src.into(),
+            dst: dst.into(),
+            tmp_gpr1: tmp_gpr1.into(),
+            tmp_gpr2: tmp_gpr2.into(),
+        });
+    }
+
+    /// Change precision of float.
+    pub fn cvt_float_to_float(
+        &mut self,
+        src: Reg,
+        dst: Reg,
+        src_size: OperandSize,
+        dst_size: OperandSize,
+    ) {
+        let op = match (src_size, dst_size) {
+            (OperandSize::S32, OperandSize::S64) => SseOpcode::Cvtss2sd,
+            (OperandSize::S64, OperandSize::S32) => SseOpcode::Cvtsd2ss,
+            _ => unimplemented!(),
+        };
+
+        self.emit(Inst::XmmRmRUnaligned {
+            op,
+            src2: Xmm::unwrap_new(src.into()).into(),
+            src1: dst.into(),
+            dst: dst.into(),
+        });
+    }
+
     pub fn or_rr(&mut self, src: Reg, dst: Reg, size: OperandSize) {
         self.emit(Inst::AluRmiR {
             size: size.into(),
@@ -480,39 +736,35 @@ impl Assembler {
             size: size.into(),
             op: AluRmiROpcode::Or,
             src1: dst.into(),
-            src2: GprMemImm::new(imm).expect("valid immediate"),
+            src2: GprMemImm::unwrap_new(imm),
+            dst: dst.into(),
+        });
+    }
+
+    pub fn xmm_or_rr(&mut self, src: Reg, dst: Reg, size: OperandSize) {
+        let op = match size {
+            OperandSize::S32 => SseOpcode::Orps,
+            OperandSize::S64 => SseOpcode::Orpd,
+            OperandSize::S8 | OperandSize::S16 | OperandSize::S128 => unreachable!(),
+        };
+
+        self.emit(Inst::XmmRmR {
+            op,
+            src1: dst.into(),
+            src2: XmmMemAligned::from(Xmm::from(src)),
             dst: dst.into(),
         });
     }
 
     /// Logical exclusive or with registers.
     pub fn xor_rr(&mut self, src: Reg, dst: Reg, size: OperandSize) {
-        match dst.class() {
-            RegClass::Int => {
-                self.emit(Inst::AluRmiR {
-                    size: size.into(),
-                    op: AluRmiROpcode::Xor,
-                    src1: dst.into(),
-                    src2: src.into(),
-                    dst: dst.into(),
-                });
-            }
-            RegClass::Float => {
-                let op = match size {
-                    OperandSize::S32 => SseOpcode::Xorps,
-                    OperandSize::S64 => SseOpcode::Xorpd,
-                    OperandSize::S128 => unreachable!(),
-                };
-
-                self.emit(Inst::XmmRmR {
-                    op,
-                    src1: dst.into(),
-                    src2: XmmMemAligned::from(Xmm::from(src)),
-                    dst: dst.into(),
-                });
-            }
-            RegClass::Vector => todo!(),
-        }
+        self.emit(Inst::AluRmiR {
+            size: size.into(),
+            op: AluRmiROpcode::Xor,
+            src1: dst.into(),
+            src2: src.into(),
+            dst: dst.into(),
+        });
     }
 
     pub fn xor_ir(&mut self, imm: i32, dst: Reg, size: OperandSize) {
@@ -522,7 +774,23 @@ impl Assembler {
             size: size.into(),
             op: AluRmiROpcode::Xor,
             src1: dst.into(),
-            src2: GprMemImm::new(imm).expect("valid immediate"),
+            src2: GprMemImm::unwrap_new(imm),
+            dst: dst.into(),
+        });
+    }
+
+    /// Logical exclusive or with float registers.
+    pub fn xmm_xor_rr(&mut self, src: Reg, dst: Reg, size: OperandSize) {
+        let op = match size {
+            OperandSize::S32 => SseOpcode::Xorps,
+            OperandSize::S64 => SseOpcode::Xorpd,
+            OperandSize::S8 | OperandSize::S16 | OperandSize::S128 => unreachable!(),
+        };
+
+        self.emit(Inst::XmmRmR {
+            op,
+            src1: dst.into(),
+            src2: XmmMemAligned::from(Xmm::from(src)),
             dst: dst.into(),
         });
     }
@@ -546,7 +814,7 @@ impl Assembler {
             size: size.into(),
             kind: kind.into(),
             src: dst.into(),
-            num_bits: Imm8Gpr::new(imm).expect("valid immediate"),
+            num_bits: Imm8Gpr::unwrap_new(imm),
             dst: dst.into(),
         });
     }
@@ -567,8 +835,8 @@ impl Assembler {
             DivKind::Signed => {
                 self.emit(Inst::CmpRmiR {
                     size: size.into(),
-                    src: GprMemImm::new(RegMemImm::imm(0)).unwrap(),
-                    dst: divisor.into(),
+                    src1: divisor.into(),
+                    src2: GprMemImm::unwrap_new(RegMemImm::imm(0)),
                     opcode: CmpOpcode::Cmp,
                 });
                 self.emit(Inst::TrapIf {
@@ -603,7 +871,7 @@ impl Assembler {
             sign: kind.into(),
             size: size.into(),
             trap,
-            divisor: GprMem::new(RegMem::reg(divisor.into())).unwrap(),
+            divisor: GprMem::unwrap_new(RegMem::reg(divisor.into())),
             dividend_lo: dst.0.into(),
             dividend_hi: dst.1.into(),
             dst_quotient: dst.0.into(),
@@ -653,7 +921,7 @@ impl Assembler {
                     sign: DivSignedness::Unsigned,
                     trap: TrapCode::IntegerDivisionByZero,
                     size: size.into(),
-                    divisor: GprMem::new(RegMem::reg(divisor.into())).unwrap(),
+                    divisor: GprMem::unwrap_new(RegMem::reg(divisor.into())),
                     dividend_lo: dst.0.into(),
                     dividend_hi: dst.1.into(),
                     dst_quotient: dst.0.into(),
@@ -665,22 +933,18 @@ impl Assembler {
 
     /// Multiply immediate and register.
     pub fn mul_ir(&mut self, imm: i32, dst: Reg, size: OperandSize) {
-        let imm = RegMemImm::imm(imm as u32);
-
-        self.emit(Inst::AluRmiR {
+        self.emit(Inst::IMulImm {
             size: size.into(),
-            op: AluRmiROpcode::Mul,
             src1: dst.into(),
-            src2: GprMemImm::new(imm).expect("valid immediate"),
+            src2: imm,
             dst: dst.into(),
         });
     }
 
     /// Multiply register and register.
     pub fn mul_rr(&mut self, src: Reg, dst: Reg, size: OperandSize) {
-        self.emit(Inst::AluRmiR {
+        self.emit(Inst::IMul {
             size: size.into(),
-            op: AluRmiROpcode::Mul,
             src1: dst.into(),
             src2: src.into(),
             dst: dst.into(),
@@ -695,7 +959,7 @@ impl Assembler {
             size: size.into(),
             op: AluRmiROpcode::Add,
             src1: dst.into(),
-            src2: GprMemImm::new(imm).expect("valid immediate"),
+            src2: GprMemImm::unwrap_new(imm),
             dst: dst.into(),
         });
     }
@@ -711,28 +975,47 @@ impl Assembler {
         });
     }
 
-    pub fn cmp_ir(&mut self, imm: i32, dst: Reg, size: OperandSize) {
+    pub fn cmp_ir(&mut self, src1: Reg, imm: i32, size: OperandSize) {
         let imm = RegMemImm::imm(imm as u32);
 
         self.emit(Inst::CmpRmiR {
             size: size.into(),
             opcode: CmpOpcode::Cmp,
-            src: GprMemImm::new(imm).expect("valid immediate"),
-            dst: dst.into(),
+            src1: src1.into(),
+            src2: GprMemImm::unwrap_new(imm),
         });
     }
 
-    pub fn cmp_rr(&mut self, src: Reg, dst: Reg, size: OperandSize) {
+    pub fn cmp_rr(&mut self, src1: Reg, src2: Reg, size: OperandSize) {
         self.emit(Inst::CmpRmiR {
             size: size.into(),
             opcode: CmpOpcode::Cmp,
-            src: src.into(),
-            dst: dst.into(),
+            src1: src1.into(),
+            src2: src2.into(),
+        });
+    }
+
+    /// Compares values in src1 and src2 and sets ZF, PF, and CF flags in EFLAGS
+    /// register.
+    pub fn ucomis(&mut self, src1: Reg, src2: Reg, size: OperandSize) {
+        let op = match size {
+            OperandSize::S32 => SseOpcode::Ucomiss,
+            OperandSize::S64 => SseOpcode::Ucomisd,
+            OperandSize::S8 | OperandSize::S16 | OperandSize::S128 => unreachable!(),
+        };
+
+        self.emit(Inst::XmmCmpRmR {
+            op,
+            src1: src1.into(),
+            src2: Xmm::from(src2).into(),
         });
     }
 
     pub fn popcnt(&mut self, src: Reg, size: OperandSize) {
-        assert!(self.isa_flags.has_popcnt(), "Requires has_popcnt flag");
+        assert!(
+            self.isa_flags.has_popcnt() && self.isa_flags.has_sse42(),
+            "Requires has_popcnt and has_sse42 flags"
+        );
         self.emit(Inst::UnaryRmR {
             size: size.into(),
             op: args::UnaryRmROpcode::Popcnt,
@@ -742,18 +1025,34 @@ impl Assembler {
     }
 
     /// Emit a test instruction with two register operands.
-    pub fn test_rr(&mut self, src: Reg, dst: Reg, size: OperandSize) {
+    pub fn test_rr(&mut self, src1: Reg, src2: Reg, size: OperandSize) {
         self.emit(Inst::CmpRmiR {
             size: size.into(),
             opcode: CmpOpcode::Test,
-            src: src.into(),
-            dst: dst.into(),
+            src1: src1.into(),
+            src2: src2.into(),
         })
     }
 
     /// Set value in dst to `0` or `1` based on flags in status register and
     /// [`CmpKind`].
-    pub fn setcc(&mut self, kind: CmpKind, dst: Reg) {
+    pub fn setcc(&mut self, kind: IntCmpKind, dst: Reg) {
+        self.setcc_impl(kind.into(), dst);
+    }
+
+    /// Set value in dst to `1` if parity flag in status register is set, `0`
+    /// otherwise.
+    pub fn setp(&mut self, dst: Reg) {
+        self.setcc_impl(CC::P, dst);
+    }
+
+    /// Set value in dst to `1` if parity flag in status register is not set,
+    /// `0` otherwise.
+    pub fn setnp(&mut self, dst: Reg) {
+        self.setcc_impl(CC::NP, dst);
+    }
+
+    fn setcc_impl(&mut self, cc: CC, dst: Reg) {
         // Clear the dst register or bits 1 to 31 may be incorrectly set.
         // Don't use xor since it updates the status register.
         self.emit(Inst::Imm {
@@ -763,7 +1062,7 @@ impl Assembler {
         });
         // Copy correct bit from status register into dst register.
         self.emit(Inst::Setcc {
-            cc: kind.into(),
+            cc,
             dst: dst.into(),
         });
     }
@@ -823,11 +1122,99 @@ impl Assembler {
         });
     }
 
-    pub fn rounds(&mut self, src: Reg, dst: Reg, mode: RoundingMode, size: OperandSize) {
+    /// Performs float addition on src and dst and places result in dst.
+    pub fn xmm_add_rr(&mut self, src: Reg, dst: Reg, size: OperandSize) {
+        let op = match size {
+            OperandSize::S32 => SseOpcode::Addss,
+            OperandSize::S64 => SseOpcode::Addsd,
+            OperandSize::S8 | OperandSize::S16 | OperandSize::S128 => unreachable!(),
+        };
+
+        self.emit(Inst::XmmRmRUnaligned {
+            op,
+            src1: Xmm::from(dst).into(),
+            src2: Xmm::from(src).into(),
+            dst: dst.into(),
+        });
+    }
+
+    /// Performs float subtraction on src and dst and places result in dst.
+    pub fn xmm_sub_rr(&mut self, src: Reg, dst: Reg, size: OperandSize) {
+        let op = match size {
+            OperandSize::S32 => SseOpcode::Subss,
+            OperandSize::S64 => SseOpcode::Subsd,
+            OperandSize::S8 | OperandSize::S16 | OperandSize::S128 => unreachable!(),
+        };
+
+        self.emit(Inst::XmmRmRUnaligned {
+            op,
+            src1: Xmm::from(dst).into(),
+            src2: Xmm::from(src).into(),
+            dst: dst.into(),
+        });
+    }
+
+    /// Performs float multiplication on src and dst and places result in dst.
+    pub fn xmm_mul_rr(&mut self, src: Reg, dst: Reg, size: OperandSize) {
+        let op = match size {
+            OperandSize::S32 => SseOpcode::Mulss,
+            OperandSize::S64 => SseOpcode::Mulsd,
+            OperandSize::S8 | OperandSize::S16 | OperandSize::S128 => unreachable!(),
+        };
+
+        self.emit(Inst::XmmRmRUnaligned {
+            op,
+            src1: Xmm::from(dst).into(),
+            src2: Xmm::from(src).into(),
+            dst: dst.into(),
+        });
+    }
+
+    /// Performs float division on src and dst and places result in dst.
+    pub fn xmm_div_rr(&mut self, src: Reg, dst: Reg, size: OperandSize) {
+        let op = match size {
+            OperandSize::S32 => SseOpcode::Divss,
+            OperandSize::S64 => SseOpcode::Divsd,
+            OperandSize::S8 | OperandSize::S16 | OperandSize::S128 => unreachable!(),
+        };
+
+        self.emit(Inst::XmmRmRUnaligned {
+            op,
+            src1: Xmm::from(dst).into(),
+            src2: Xmm::from(src).into(),
+            dst: dst.into(),
+        });
+    }
+
+    /// Minimum for src and dst XMM registers with results put in dst.
+    pub fn xmm_min_seq(&mut self, src: Reg, dst: Reg, size: OperandSize) {
+        self.emit(Inst::XmmMinMaxSeq {
+            size: size.into(),
+            is_min: true,
+            lhs: src.into(),
+            rhs: dst.into(),
+            dst: dst.into(),
+        });
+    }
+
+    /// Maximum for src and dst XMM registers with results put in dst.
+    pub fn xmm_max_seq(&mut self, src: Reg, dst: Reg, size: OperandSize) {
+        self.emit(Inst::XmmMinMaxSeq {
+            size: size.into(),
+            is_min: false,
+            lhs: src.into(),
+            rhs: dst.into(),
+            dst: dst.into(),
+        });
+    }
+
+    /// Perform rounding operation on float register src and place results in
+    /// float register dst.
+    pub fn xmm_rounds_rr(&mut self, src: Reg, dst: Reg, mode: RoundingMode, size: OperandSize) {
         let op = match size {
             OperandSize::S32 => SseOpcode::Roundss,
             OperandSize::S64 => SseOpcode::Roundsd,
-            OperandSize::S128 => unreachable!(),
+            OperandSize::S8 | OperandSize::S16 | OperandSize::S128 => unreachable!(),
         };
 
         let imm: u8 = match mode {
@@ -845,35 +1232,53 @@ impl Assembler {
         })
     }
 
+    pub fn sqrt(&mut self, src: Reg, dst: Reg, size: OperandSize) {
+        let op = match size {
+            OperandSize::S32 => SseOpcode::Sqrtss,
+            OperandSize::S64 => SseOpcode::Sqrtsd,
+            OperandSize::S8 | OperandSize::S16 | OperandSize::S128 => unreachable!(),
+        };
+
+        self.emit(Inst::XmmRmR {
+            op,
+            src2: Xmm::from(src).into(),
+            src1: dst.into(),
+            dst: dst.into(),
+        })
+    }
+
     /// Emit a call to an unknown location through a register.
     pub fn call_with_reg(&mut self, callee: Reg) {
         self.emit(Inst::CallUnknown {
             dest: RegMem::reg(callee.into()),
-            info: Box::new(CallInfo {
-                uses: smallvec![],
-                defs: smallvec![],
-                clobbers: Default::default(),
-                opcode: Opcode::Call,
-                callee_pop_size: 0,
-                callee_conv: CallConv::SystemV,
-            }),
+            info: None,
         });
     }
 
     /// Emit a call to a locally defined function through an index.
-    pub fn call_with_index(&mut self, index: u32) {
-        let dest = ExternalName::user(UserExternalNameRef::new(index as usize));
-        self.emit(Inst::CallKnown {
-            dest,
-            info: Box::new(CallInfo {
-                uses: smallvec![],
-                defs: smallvec![],
-                clobbers: Default::default(),
-                opcode: Opcode::Call,
-                callee_pop_size: 0,
-                callee_conv: CallConv::SystemV,
-            }),
+    pub fn call_with_name(&mut self, name: UserExternalNameRef) {
+        let dest = ExternalName::user(name);
+        self.emit(Inst::CallKnown { dest, info: None });
+    }
+
+    /// Emit a call to a well-known libcall.
+    pub fn call_with_lib(&mut self, lib: LibCall, dst: Reg) {
+        let dest = ExternalName::LibCall(lib);
+
+        // `use_colocated_libcalls` is never `true` from within Wasmtime,
+        // so always require loading the libcall to a register and use
+        // a `Far` relocation distance to ensure the right relocation when
+        // emitting to binary.
+        //
+        // See [wasmtime::engine::Engine::check_compatible_with_shared_flag] and
+        // [wasmtime_cranelift::obj::ModuleTextBuilder::append_func]
+        self.emit(Inst::LoadExtName {
+            dst: Writable::from_reg(dst.into()),
+            name: Box::new(dest),
+            offset: 0,
+            distance: RelocDistance::Far,
         });
+        self.call_with_reg(dst);
     }
 
     /// Emits a conditional jump to the given label.
@@ -913,10 +1318,101 @@ impl Assembler {
     }
 
     /// Conditional trap.
-    pub fn trapif(&mut self, cc: CmpKind, trap_code: TrapCode) {
+    pub fn trapif(&mut self, cc: impl Into<CC>, trap_code: TrapCode) {
         self.emit(Inst::TrapIf {
             cc: cc.into(),
             trap_code,
         });
     }
+
+    /// Load effective address.
+    pub fn lea(&mut self, addr: &Address, dst: Reg, size: OperandSize) {
+        let addr = Self::to_synthetic_amode(
+            addr,
+            &mut self.pool,
+            &mut self.constants,
+            &mut self.buffer,
+            MemFlags::trusted(),
+        );
+        self.emit(Inst::LoadEffectiveAddress {
+            addr,
+            dst: dst.into(),
+            size: size.into(),
+        });
+    }
+}
+
+/// Captures the region in a MachBuffer where an add-with-immediate instruction would be emitted,
+/// but the immediate is not yet known. Currently, this implementation expects a 32-bit immediate,
+/// so 8 and 16 bit operand sizes are not supported.
+pub(crate) struct PatchableAddToReg {
+    /// The region to be patched in the [`MachBuffer`]. It must contain a valid add instruction
+    /// sequence, accepting a 32-bit immediate.
+    region: PatchRegion,
+
+    /// The offset into the patchable region where the patchable constant begins.
+    constant_offset: usize,
+}
+
+impl PatchableAddToReg {
+    /// Create a new [`PatchableAddToReg`] by capturing a region in the output buffer where the
+    /// add-with-immediate occurs. The [`MachBuffer`] will have and add-with-immediate instruction
+    /// present in that region, though it will add `0` until the `::finalize` method is called.
+    ///
+    /// Currently this implementation expects to be able to patch a 32-bit immediate, which means
+    /// that 8 and 16-bit addition cannot be supported.
+    pub(crate) fn new(reg: Reg, size: OperandSize, buf: &mut MachBuffer<Inst>) -> Self {
+        let open = buf.start_patchable();
+
+        // Emit the opcode and register use for the add instruction.
+        let start = buf.cur_offset();
+        Self::add_inst_bytes(reg, size, buf);
+        let constant_offset = usize::try_from(buf.cur_offset() - start).unwrap();
+
+        // Emit a placeholder for the 32-bit immediate.
+        buf.put4(0);
+
+        let region = buf.end_patchable(open);
+
+        Self {
+            region,
+            constant_offset,
+        }
+    }
+
+    /// Generate the prefix of the add instruction (rex byte (depending on register use), opcode,
+    /// and register reference).
+    fn add_inst_bytes(reg: Reg, size: OperandSize, buf: &mut MachBuffer<Inst>) {
+        match size {
+            OperandSize::S32 | OperandSize::S64 => {}
+            _ => {
+                panic!(
+                    "{}-bit addition is not supported, please see the comment on PatchableAddToReg::new",
+                    size.num_bits(),
+                )
+            }
+        }
+
+        let enc_g = 0;
+
+        debug_assert!(reg.is_int());
+        let enc_e = u8::try_from(reg.hw_enc()).unwrap();
+
+        RexFlags::from(args::OperandSize::from(size)).emit_two_op(buf, enc_g, enc_e);
+
+        // the opcode for an add
+        buf.put1(0x81);
+
+        // the modrm byte
+        buf.put1(encode_modrm(0b11, enc_g & 7, enc_e & 7));
+    }
+
+    /// Patch the [`MachBuffer`] with the known constant to be added to the register. The final
+    /// value is passed in as an i32, but the instruction encoding is fixed when
+    /// [`PatchableAddToReg::new`] is called.
+    pub(crate) fn finalize(self, val: i32, buffer: &mut MachBuffer<Inst>) {
+        let slice = self.region.patch(buffer);
+        debug_assert_eq!(slice.len(), self.constant_offset + 4);
+        slice[self.constant_offset..].copy_from_slice(val.to_le_bytes().as_slice());
+    }
 }
diff --git a/winch/codegen/src/isa/x64/masm.rs b/winch/codegen/src/isa/x64/masm.rs
index 8d89bd435c79..e1fb67a5f1f4 100644
--- a/winch/codegen/src/isa/x64/masm.rs
+++ b/winch/codegen/src/isa/x64/masm.rs
@@ -1,34 +1,51 @@
 use super::{
     abi::X64ABI,
     address::Address,
-    asm::Assembler,
+    asm::{Assembler, PatchableAddToReg},
     regs::{self, rbp, rsp},
 };
 
 use crate::masm::{
-    CmpKind, DivKind, Imm as I, MacroAssembler as Masm, OperandSize, RegImm, RemKind, RoundingMode,
-    ShiftKind, TrapCode,
+    DivKind, ExtendKind, FloatCmpKind, Imm as I, IntCmpKind, MacroAssembler as Masm, OperandSize,
+    RegImm, RemKind, RoundingMode, ShiftKind, TrapCode, TruncKind, TRUSTED_FLAGS, UNTRUSTED_FLAGS,
 };
-use crate::{abi::ABI, masm::StackSlot};
 use crate::{
     abi::{self, align_to, calculate_frame_adjustment, LocalSlot},
-    codegen::{ptr_type_from_ptr_size, CodeGenContext, TableData},
+    codegen::{ptr_type_from_ptr_size, CodeGenContext, FuncEnv},
     stack::Val,
 };
+use crate::{
+    abi::{vmctx, ABI},
+    masm::{SPOffset, StackSlot},
+};
 use crate::{
     isa::reg::{Reg, RegClass},
     masm::CalleeKind,
 };
 use cranelift_codegen::{
-    isa::x64::settings as x64_settings, settings, Final, MachBufferFinalized, MachLabel,
+    binemit::CodeOffset,
+    ir::{MemFlags, RelSourceLoc, SourceLoc},
+    isa::unwind::UnwindInst,
+    isa::x64::{
+        args::{ExtMode, CC},
+        settings as x64_settings,
+    },
+    settings, Final, MachBufferFinalized, MachLabel,
 };
 
-use wasmtime_environ::PtrSize;
+use wasmtime_environ::{PtrSize, WasmValType};
 
 /// x64 MacroAssembler.
 pub(crate) struct MacroAssembler {
     /// Stack pointer offset.
     sp_offset: u32,
+    /// This value represents the maximum stack size seen while compiling the function. While the
+    /// function is still being compiled its value will not be valid (the stack will grow and
+    /// shrink as space is reserved and freed during compilation), but once all instructions have
+    /// been seen this value will be the maximum stack usage seen.
+    sp_max: u32,
+    /// Add instructions that are used to add the constant stack max to a register.
+    stack_max_use_add: Option<PatchableAddToReg>,
     /// Low level assembler.
     asm: Assembler,
     /// ISA flags.
@@ -44,31 +61,82 @@ impl Masm for MacroAssembler {
     type Ptr = u8;
     type ABI = X64ABI;
 
-    fn prologue(&mut self) {
+    fn frame_setup(&mut self) {
         let frame_pointer = rbp();
         let stack_pointer = rsp();
 
         self.asm.push_r(frame_pointer);
+
+        if self.shared_flags.unwind_info() {
+            self.asm.emit_unwind_inst(UnwindInst::PushFrameRegs {
+                offset_upward_to_caller_sp: Self::ABI::arg_base_offset().try_into().unwrap(),
+            })
+        }
+
         self.asm
             .mov_rr(stack_pointer, frame_pointer, OperandSize::S64);
     }
 
+    fn check_stack(&mut self, vmctx: Reg) {
+        let ptr_size: u8 = self.ptr_size.bytes().try_into().unwrap();
+        let scratch = regs::scratch();
+
+        self.load_ptr(
+            self.address_at_reg(vmctx, ptr_size.vmcontext_runtime_limits().into()),
+            scratch,
+        );
+
+        self.load_ptr(
+            Address::offset(scratch, ptr_size.vmruntime_limits_stack_limit().into()),
+            scratch,
+        );
+
+        self.add_stack_max(scratch);
+
+        self.asm.cmp_rr(scratch, regs::rsp(), self.ptr_size);
+        self.asm.trapif(IntCmpKind::GtU, TrapCode::StackOverflow);
+
+        // Emit unwind info.
+        if self.shared_flags.unwind_info() {
+            self.asm.emit_unwind_inst(UnwindInst::DefineNewFrame {
+                offset_upward_to_caller_sp: Self::ABI::arg_base_offset().try_into().unwrap(),
+
+                // The Winch calling convention has no callee-save registers, so nothing will be
+                // clobbered.
+                offset_downward_to_clobbers: 0,
+            })
+        }
+    }
+
     fn push(&mut self, reg: Reg, size: OperandSize) -> StackSlot {
-        let bytes = if reg.is_int() {
-            self.asm.push_r(reg);
-            let increment = <Self::ABI as ABI>::word_bytes();
-            self.increment_sp(increment);
-            increment
-        } else {
-            let bytes = size.bytes();
-            self.reserve_stack(bytes);
-            self.asm
-                .xmm_mov_rm(reg, &self.address_from_sp(self.sp_offset), size);
-            bytes
+        let bytes = match (reg.class(), size) {
+            (RegClass::Int, OperandSize::S64) => {
+                let word_bytes = <Self::ABI as ABI>::word_bytes() as u32;
+                self.asm.push_r(reg);
+                self.increment_sp(word_bytes);
+                word_bytes
+            }
+            (RegClass::Int, OperandSize::S32) => {
+                let bytes = size.bytes();
+                self.reserve_stack(bytes);
+                let sp_offset = SPOffset::from_u32(self.sp_offset);
+                self.asm
+                    .mov_rm(reg, &self.address_from_sp(sp_offset), size, TRUSTED_FLAGS);
+                bytes
+            }
+            (RegClass::Float, _) => {
+                let bytes = size.bytes();
+                self.reserve_stack(bytes);
+                let sp_offset = SPOffset::from_u32(self.sp_offset);
+                self.asm
+                    .xmm_mov_rm(reg, &self.address_from_sp(sp_offset), size, TRUSTED_FLAGS);
+                bytes
+            }
+            _ => unreachable!(),
         };
 
         StackSlot {
-            offset: self.sp_offset,
+            offset: SPOffset::from_u32(self.sp_offset),
             size: bytes,
         }
     }
@@ -90,18 +158,20 @@ impl Masm for MacroAssembler {
         self.decrement_sp(bytes);
     }
 
-    fn reset_stack_pointer(&mut self, offset: u32) {
-        self.sp_offset = offset;
+    fn reset_stack_pointer(&mut self, offset: SPOffset) {
+        self.sp_offset = offset.as_u32();
     }
 
     fn local_address(&mut self, local: &LocalSlot) -> Address {
         let (reg, offset) = local
             .addressed_from_sp()
             .then(|| {
-                let offset = self.sp_offset.checked_sub(local.offset).expect(&format!(
-                    "Invalid local offset = {}; sp offset = {}",
-                    local.offset, self.sp_offset
-                ));
+                let offset = self.sp_offset.checked_sub(local.offset).unwrap_or_else(|| {
+                    panic!(
+                        "Invalid local offset = {}; sp offset = {}",
+                        local.offset, self.sp_offset
+                    )
+                });
                 (rsp(), offset)
             })
             .unwrap_or((rbp(), local.offset));
@@ -109,112 +179,48 @@ impl Masm for MacroAssembler {
         Address::offset(reg, offset)
     }
 
-    fn table_elem_address(
-        &mut self,
-        index: Reg,
-        size: OperandSize,
-        table_data: &TableData,
-        context: &mut CodeGenContext,
-    ) -> Reg {
-        let vmctx = <Self::ABI as ABI>::vmctx_reg();
-        let scratch = regs::scratch();
-        let bound = context.any_gpr(self);
-        let ptr_base = context.any_gpr(self);
-        let tmp = context.any_gpr(self);
-
-        if let Some(offset) = table_data.base {
-            // If the table data declares a particular offset base,
-            // load the address into a register to further use it as
-            // the table address.
-            self.asm
-                .mov_mr(&Address::offset(vmctx, offset), ptr_base, OperandSize::S64);
-        } else {
-            // Else, simply move the vmctx register into the addr register as
-            // the base to calculate the table address.
-            self.asm.mov_rr(vmctx, ptr_base, OperandSize::S64);
-        };
-
-        // OOB check.
-        let bound_addr = Address::offset(ptr_base, table_data.current_elems_offset);
-        self.asm.mov_mr(&bound_addr, bound, OperandSize::S64);
-        self.asm.cmp_rr(bound, index, size);
-        self.asm.trapif(CmpKind::GeU, TrapCode::TableOutOfBounds);
-
-        // Move the index into the scratch register to calcualte the table
-        // element address.
-        // Moving the value of the index register to the scratch register
-        // also avoids overwriting the context of the index register.
-        self.asm.mov_rr(index, scratch, OperandSize::S32);
-        self.asm
-            .mul_ir(table_data.element_size as i32, scratch, OperandSize::S64);
-        self.asm.mov_mr(
-            &Address::offset(ptr_base, table_data.offset),
-            ptr_base,
-            OperandSize::S64,
-        );
-        // Copy the value of the table base into a temporary register
-        // so that we can use it later in case of a misspeculation.
-        self.asm.mov_rr(ptr_base, tmp, OperandSize::S64);
-        // Calculate the address of the table element.
-        self.asm.add_rr(scratch, ptr_base, OperandSize::S64);
-        if self.shared_flags.enable_table_access_spectre_mitigation() {
-            // Perform a bounds check and override the value of the
-            // table element address in case the index is out of bounds.
-            self.asm.cmp_rr(bound, index, OperandSize::S32);
-            self.asm.cmov(tmp, ptr_base, CmpKind::GeU, OperandSize::S64);
-        }
-        self.asm
-            .mov_mr(&Address::offset(ptr_base, 0), ptr_base, OperandSize::S64);
-        context.free_reg(bound);
-        context.free_reg(tmp);
-        ptr_base
+    fn address_from_sp(&self, offset: SPOffset) -> Self::Address {
+        Address::offset(regs::rsp(), self.sp_offset - offset.as_u32())
     }
 
-    fn address_from_sp(&self, offset: u32) -> Self::Address {
-        Address::offset(regs::rsp(), self.sp_offset - offset)
+    fn address_at_sp(&self, offset: SPOffset) -> Self::Address {
+        Address::offset(regs::rsp(), offset.as_u32())
     }
 
-    fn address_at_sp(&self, offset: u32) -> Self::Address {
-        Address::offset(regs::rsp(), offset)
+    fn address_at_vmctx(&self, offset: u32) -> Self::Address {
+        Address::offset(vmctx!(Self), offset)
     }
 
-    fn address_at_vmctx(&self, offset: u32) -> Self::Address {
-        Address::offset(<Self::ABI as ABI>::vmctx_reg(), offset)
+    fn store_ptr(&mut self, src: Reg, dst: Self::Address) {
+        self.store(src.into(), dst, self.ptr_size);
     }
 
     fn store(&mut self, src: RegImm, dst: Address, size: OperandSize) {
-        match src {
-            RegImm::Imm(imm) => match imm {
-                I::I32(v) => self.asm.mov_im(v as i32, &dst, size),
-                I::I64(v) => match v.try_into() {
-                    Ok(v) => self.asm.mov_im(v, &dst, size),
-                    Err(_) => {
-                        panic!("Immediate-to-memory moves require immediate operand to sign-extend to 64 bits.");
-                    }
-                },
-                // Immediate to memory moves are currently only used
-                // to zero a memory range, which only involves
-                // ints. See [`MacroAssembler::zero_mem_range`].
-                i => panic!("Cannot store immediate {:?}", i),
-            },
-            RegImm::Reg(reg) => {
-                if reg.is_int() {
-                    self.asm.mov_rm(reg, &dst, size);
-                } else {
-                    self.asm.xmm_mov_rm(reg, &dst, size);
-                }
-            }
-        }
+        self.store_impl(src, dst, size, TRUSTED_FLAGS);
+    }
+
+    fn wasm_store(&mut self, src: Reg, dst: Self::Address, size: OperandSize) {
+        self.store_impl(src.into(), dst, size, UNTRUSTED_FLAGS);
     }
 
     fn pop(&mut self, dst: Reg, size: OperandSize) {
-        if dst.is_int() {
-            self.asm.pop_r(dst);
-            self.decrement_sp(<Self::ABI as abi::ABI>::word_bytes());
-        } else {
-            let addr = self.address_from_sp(self.sp_offset);
-            self.asm.xmm_mov_mr(&addr, dst, size);
-            self.free_stack(size.bytes());
+        let current_sp = SPOffset::from_u32(self.sp_offset);
+        match (dst.class(), size) {
+            (RegClass::Int, OperandSize::S32) => {
+                let addr = self.address_from_sp(current_sp);
+                self.asm.movzx_mr(&addr, dst, size.into(), TRUSTED_FLAGS);
+                self.free_stack(size.bytes());
+            }
+            (RegClass::Int, OperandSize::S64) => {
+                self.asm.pop_r(dst);
+                self.decrement_sp(<Self::ABI as ABI>::word_bytes() as u32);
+            }
+            (RegClass::Float, _) | (RegClass::Vector, _) => {
+                let addr = self.address_from_sp(current_sp);
+                self.asm.xmm_mov_mr(&addr, dst, size, TRUSTED_FLAGS);
+                self.free_stack(size.bytes());
+            }
+            _ => unreachable!(),
         }
     }
 
@@ -225,14 +231,15 @@ impl Masm for MacroAssembler {
     ) -> u32 {
         let alignment: u32 = <Self::ABI as abi::ABI>::call_stack_align().into();
         let addend: u32 = <Self::ABI as abi::ABI>::arg_base_offset().into();
-        let delta = calculate_frame_adjustment(self.sp_offset(), addend, alignment);
+        let delta = calculate_frame_adjustment(self.sp_offset().as_u32(), addend, alignment);
         let aligned_args_size = align_to(stack_args_size, alignment);
         let total_stack = delta + aligned_args_size;
         self.reserve_stack(total_stack);
         let callee = load_callee(self);
         match callee {
             CalleeKind::Indirect(reg) => self.asm.call_with_reg(reg),
-            CalleeKind::Direct(idx) => self.asm.call_with_index(idx),
+            CalleeKind::Direct(idx) => self.asm.call_with_name(idx),
+            CalleeKind::LibCall(lib) => self.asm.call_with_lib(lib, regs::scratch()),
         };
         total_stack
     }
@@ -241,16 +248,30 @@ impl Masm for MacroAssembler {
         self.load(src, dst, self.ptr_size);
     }
 
+    fn load_addr(&mut self, src: Self::Address, dst: Reg, size: OperandSize) {
+        self.asm.lea(&src, dst, size);
+    }
+
     fn load(&mut self, src: Address, dst: Reg, size: OperandSize) {
-        if dst.is_int() {
-            self.asm.mov_mr(&src, dst, size);
+        self.load_impl::<Self>(src, dst, size, TRUSTED_FLAGS);
+    }
+
+    fn wasm_load(
+        &mut self,
+        src: Self::Address,
+        dst: Reg,
+        size: OperandSize,
+        kind: Option<ExtendKind>,
+    ) {
+        if let Some(ext) = kind {
+            self.asm.movsx_mr(&src, dst, ext, UNTRUSTED_FLAGS);
         } else {
-            self.asm.xmm_mov_mr(&src, dst, size);
+            self.load_impl::<Self>(src, dst, size, UNTRUSTED_FLAGS)
         }
     }
 
-    fn sp_offset(&self) -> u32 {
-        self.sp_offset
+    fn sp_offset(&self) -> SPOffset {
+        SPOffset::from_u32(self.sp_offset)
     }
 
     fn zero(&mut self, reg: Reg) {
@@ -266,20 +287,24 @@ impl Masm for MacroAssembler {
             },
             (RegImm::Imm(imm), dst) => match imm {
                 I::I32(v) => self.asm.mov_ir(v as u64, dst, size),
-                I::I64(v) => self.asm.mov_ir(v as u64, dst, size),
+                I::I64(v) => self.asm.mov_ir(v, dst, size),
                 I::F32(v) => {
                     let addr = self.asm.add_constant(v.to_le_bytes().as_slice());
-                    self.asm.xmm_mov_mr(&addr, dst, size);
+                    self.asm.xmm_mov_mr(&addr, dst, size, TRUSTED_FLAGS);
                 }
                 I::F64(v) => {
                     let addr = self.asm.add_constant(v.to_le_bytes().as_slice());
-                    self.asm.xmm_mov_mr(&addr, dst, size);
+                    self.asm.xmm_mov_mr(&addr, dst, size, TRUSTED_FLAGS);
+                }
+                I::V128(v) => {
+                    let addr = self.asm.add_constant(v.to_le_bytes().as_slice());
+                    self.asm.xmm_mov_mr(&addr, dst, size, TRUSTED_FLAGS);
                 }
             },
         }
     }
 
-    fn cmov(&mut self, src: Reg, dst: Reg, cc: CmpKind, size: OperandSize) {
+    fn cmov(&mut self, src: Reg, dst: Reg, cc: IntCmpKind, size: OperandSize) {
         match (src.class(), dst.class()) {
             (RegClass::Int, RegClass::Int) => self.asm.cmov(src, dst, cc, size),
             (RegClass::Float, RegClass::Float) => self.asm.xmm_cmov(src, dst, cc, size),
@@ -306,6 +331,11 @@ impl Masm for MacroAssembler {
         }
     }
 
+    fn checked_uadd(&mut self, dst: Reg, lhs: Reg, rhs: RegImm, size: OperandSize, trap: TrapCode) {
+        self.add(dst, lhs, rhs, size);
+        self.asm.trapif(CC::B, trap);
+    }
+
     fn sub(&mut self, dst: Reg, lhs: Reg, rhs: RegImm, size: OperandSize) {
         Self::ensure_two_argument_form(&dst, &lhs);
         match (rhs, dst) {
@@ -344,18 +374,72 @@ impl Masm for MacroAssembler {
         }
     }
 
+    fn float_add(&mut self, dst: Reg, lhs: Reg, rhs: Reg, size: OperandSize) {
+        Self::ensure_two_argument_form(&dst, &lhs);
+        self.asm.xmm_add_rr(rhs, dst, size);
+    }
+
+    fn float_sub(&mut self, dst: Reg, lhs: Reg, rhs: Reg, size: OperandSize) {
+        Self::ensure_two_argument_form(&dst, &lhs);
+        self.asm.xmm_sub_rr(rhs, dst, size);
+    }
+
+    fn float_mul(&mut self, dst: Reg, lhs: Reg, rhs: Reg, size: OperandSize) {
+        Self::ensure_two_argument_form(&dst, &lhs);
+        self.asm.xmm_mul_rr(rhs, dst, size);
+    }
+
+    fn float_div(&mut self, dst: Reg, lhs: Reg, rhs: Reg, size: OperandSize) {
+        Self::ensure_two_argument_form(&dst, &lhs);
+        self.asm.xmm_div_rr(rhs, dst, size);
+    }
+
+    fn float_min(&mut self, dst: Reg, lhs: Reg, rhs: Reg, size: OperandSize) {
+        Self::ensure_two_argument_form(&dst, &lhs);
+        self.asm.xmm_min_seq(rhs, dst, size);
+    }
+
+    fn float_max(&mut self, dst: Reg, lhs: Reg, rhs: Reg, size: OperandSize) {
+        Self::ensure_two_argument_form(&dst, &lhs);
+        self.asm.xmm_max_seq(rhs, dst, size);
+    }
+
+    fn float_copysign(&mut self, dst: Reg, lhs: Reg, rhs: Reg, size: OperandSize) {
+        Self::ensure_two_argument_form(&dst, &lhs);
+        let scratch_gpr = regs::scratch();
+        let scratch_xmm = regs::scratch_xmm();
+        let sign_mask = match size {
+            OperandSize::S32 => I::I32(0x80000000),
+            OperandSize::S64 => I::I64(0x8000000000000000),
+            OperandSize::S8 | OperandSize::S16 | OperandSize::S128 => unreachable!(),
+        };
+        self.load_constant(&sign_mask, scratch_gpr, size);
+        self.asm.gpr_to_xmm(scratch_gpr, scratch_xmm, size);
+
+        // Clear everything except sign bit in src.
+        self.asm.xmm_and_rr(scratch_xmm, rhs, size);
+
+        // Clear sign bit in dst using scratch to store result. Then copy the
+        // result back to dst.
+        self.asm.xmm_andn_rr(dst, scratch_xmm, size);
+        self.asm.xmm_mov_rr(scratch_xmm, dst, size);
+
+        // Copy sign bit from src to dst.
+        self.asm.xmm_or_rr(rhs, dst, size);
+    }
+
     fn float_neg(&mut self, dst: Reg, size: OperandSize) {
         assert_eq!(dst.class(), RegClass::Float);
         let mask = match size {
             OperandSize::S32 => I::I32(0x80000000),
             OperandSize::S64 => I::I64(0x8000000000000000),
-            OperandSize::S128 => unreachable!(),
+            OperandSize::S8 | OperandSize::S16 | OperandSize::S128 => unreachable!(),
         };
         let scratch_gpr = regs::scratch();
         self.load_constant(&mask, scratch_gpr, size);
         let scratch_xmm = regs::scratch_xmm();
         self.asm.gpr_to_xmm(scratch_gpr, scratch_xmm, size);
-        self.asm.xor_rr(scratch_xmm, dst, size);
+        self.asm.xmm_xor_rr(scratch_xmm, dst, size);
     }
 
     fn float_abs(&mut self, dst: Reg, size: OperandSize) {
@@ -363,23 +447,36 @@ impl Masm for MacroAssembler {
         let mask = match size {
             OperandSize::S32 => I::I32(0x7fffffff),
             OperandSize::S64 => I::I64(0x7fffffffffffffff),
-            OperandSize::S128 => unreachable!(),
+            OperandSize::S128 | OperandSize::S16 | OperandSize::S8 => unreachable!(),
         };
         let scratch_gpr = regs::scratch();
         self.load_constant(&mask, scratch_gpr, size);
         let scratch_xmm = regs::scratch_xmm();
         self.asm.gpr_to_xmm(scratch_gpr, scratch_xmm, size);
-        self.asm.and_rr(scratch_xmm, dst, size);
+        self.asm.xmm_and_rr(scratch_xmm, dst, size);
     }
 
-    fn float_round(&mut self, mode: RoundingMode, dst: Reg, src: RegImm, size: OperandSize) {
+    fn float_round<F: FnMut(&mut FuncEnv<Self::Ptr>, &mut CodeGenContext, &mut Self)>(
+        &mut self,
+        mode: RoundingMode,
+        env: &mut FuncEnv<Self::Ptr>,
+        context: &mut CodeGenContext,
+        size: OperandSize,
+        mut fallback: F,
+    ) {
         if self.flags.has_sse41() {
-            self.asm.rounds(src.get_reg().unwrap(), dst, mode, size);
+            let src = context.pop_to_reg(self, None);
+            self.asm.xmm_rounds_rr(src.into(), src.into(), mode, size);
+            context.stack.push(src.into());
         } else {
-            todo!("libcall fallback for rounding is not implemented")
+            fallback(env, context, self);
         }
     }
 
+    fn float_sqrt(&mut self, dst: Reg, src: Reg, size: OperandSize) {
+        self.asm.sqrt(src, dst, size);
+    }
+
     fn and(&mut self, dst: Reg, lhs: Reg, rhs: RegImm, size: OperandSize) {
         Self::ensure_two_argument_form(&dst, &lhs);
         match (rhs, dst) {
@@ -437,39 +534,20 @@ impl Masm for MacroAssembler {
         }
     }
 
-    fn shift(&mut self, context: &mut CodeGenContext, kind: ShiftKind, size: OperandSize) {
-        let top = context.stack.peek().expect("value at stack top");
-
-        if size == OperandSize::S32 && top.is_i32_const() {
-            let val = context
-                .stack
-                .pop_i32_const()
-                .expect("i32 const value at stack top");
-            let typed_reg = context.pop_to_reg(self, None);
-
-            self.asm.shift_ir(val as u8, typed_reg.into(), kind, size);
-
-            context.stack.push(typed_reg.into());
-        } else if size == OperandSize::S64 && top.is_i64_const() {
-            let val = context
-                .stack
-                .pop_i64_const()
-                .expect("i64 const value at stack top");
-            let typed_reg = context.pop_to_reg(self, None);
-
-            self.asm.shift_ir(val as u8, typed_reg.into(), kind, size);
+    fn shift_ir(&mut self, dst: Reg, imm: u64, lhs: Reg, kind: ShiftKind, size: OperandSize) {
+        Self::ensure_two_argument_form(&dst, &lhs);
+        self.asm.shift_ir(imm as u8, dst, kind, size)
+    }
 
-            context.stack.push(typed_reg.into());
-        } else {
-            // Number of bits to shift must be in the CL register.
-            let src = context.pop_to_reg(self, Some(regs::rcx()));
-            let dst = context.pop_to_reg(self, None);
+    fn shift(&mut self, context: &mut CodeGenContext, kind: ShiftKind, size: OperandSize) {
+        // Number of bits to shift must be in the CL register.
+        let src = context.pop_to_reg(self, Some(regs::rcx()));
+        let dst = context.pop_to_reg(self, None);
 
-            self.asm.shift_rr(src.into(), dst.into(), kind, size);
+        self.asm.shift_rr(src.into(), dst.into(), kind, size);
 
-            context.free_reg(src);
-            context.stack.push(dst.into());
-        }
+        context.free_reg(src);
+        context.stack.push(dst.into());
     }
 
     fn div(&mut self, context: &mut CodeGenContext, kind: DivKind, size: OperandSize) {
@@ -516,47 +594,95 @@ impl Masm for MacroAssembler {
         context.stack.push(Val::reg(rdx, divisor.ty));
     }
 
-    fn epilogue(&mut self, locals_size: u32) {
-        assert!(self.sp_offset == locals_size);
-
-        let rsp = rsp();
-        if locals_size > 0 {
-            self.asm.add_ir(locals_size as i32, rsp, OperandSize::S64);
-        }
+    fn frame_restore(&mut self) {
+        assert_eq!(self.sp_offset, 0);
         self.asm.pop_r(rbp());
         self.asm.ret();
     }
 
-    fn finalize(self) -> MachBufferFinalized<Final> {
-        self.asm.finalize()
+    fn finalize(mut self, base: Option<SourceLoc>) -> MachBufferFinalized<Final> {
+        if let Some(patch) = self.stack_max_use_add {
+            patch.finalize(i32::try_from(self.sp_max).unwrap(), self.asm.buffer_mut());
+        }
+
+        self.asm.finalize(base)
     }
 
     fn address_at_reg(&self, reg: Reg, offset: u32) -> Self::Address {
         Address::offset(reg, offset)
     }
 
-    fn cmp(&mut self, src: RegImm, dst: Reg, size: OperandSize) {
-        match src {
+    fn cmp(&mut self, src1: Reg, src2: RegImm, size: OperandSize) {
+        match src2 {
             RegImm::Imm(imm) => {
                 if let Some(v) = imm.to_i32() {
-                    self.asm.cmp_ir(v, dst, size);
+                    self.asm.cmp_ir(src1, v, size);
                 } else {
                     let scratch = regs::scratch();
                     self.load_constant(&imm, scratch, size);
-                    self.asm.cmp_rr(scratch, dst, size);
+                    self.asm.cmp_rr(src1, scratch, size);
                 }
             }
-            RegImm::Reg(src) => {
-                self.asm.cmp_rr(src, dst, size);
+            RegImm::Reg(src2) => {
+                self.asm.cmp_rr(src1, src2, size);
             }
         }
     }
 
-    fn cmp_with_set(&mut self, src: RegImm, dst: Reg, kind: CmpKind, size: OperandSize) {
-        self.cmp(src, dst, size);
+    fn cmp_with_set(&mut self, src: RegImm, dst: Reg, kind: IntCmpKind, size: OperandSize) {
+        self.cmp(dst, src, size);
         self.asm.setcc(kind, dst);
     }
 
+    fn float_cmp_with_set(
+        &mut self,
+        src1: Reg,
+        src2: Reg,
+        dst: Reg,
+        kind: FloatCmpKind,
+        size: OperandSize,
+    ) {
+        // Float comparisons needs to be ordered (that is, comparing with a NaN
+        // should return 0) except for not equal which needs to be unordered.
+        // We use ucomis{s, d} because comis{s, d} has an undefined result if
+        // either operand is NaN. Since ucomis{s, d} is unordered, we need to
+        // compensate to make the comparison ordered.  Ucomis{s, d} sets the
+        // ZF, PF, and CF flags if there is an unordered result.
+        let (src1, src2, set_kind) = match kind {
+            FloatCmpKind::Eq => (src1, src2, IntCmpKind::Eq),
+            FloatCmpKind::Ne => (src1, src2, IntCmpKind::Ne),
+            FloatCmpKind::Gt => (src1, src2, IntCmpKind::GtU),
+            FloatCmpKind::Ge => (src1, src2, IntCmpKind::GeU),
+            // Reversing the operands and using the complementary comparison
+            // avoids needing to perform an additional SETNP and AND
+            // instruction.
+            // SETNB and SETNBE check if the carry flag is unset (i.e., not
+            // less than and not unordered) so we get the intended result
+            // without having to look at the parity flag.
+            FloatCmpKind::Lt => (src2, src1, IntCmpKind::GtU),
+            FloatCmpKind::Le => (src2, src1, IntCmpKind::GeU),
+        };
+        self.asm.ucomis(src1, src2, size);
+        self.asm.setcc(set_kind, dst);
+        match kind {
+            FloatCmpKind::Eq | FloatCmpKind::Gt | FloatCmpKind::Ge => {
+                // Return false if either operand is NaN by ensuring PF is
+                // unset.
+                let scratch = regs::scratch();
+                self.asm.setnp(scratch);
+                self.asm.and_rr(scratch, dst, size);
+            }
+            FloatCmpKind::Ne => {
+                // Return true if either operand is NaN by checking if PF is
+                // set.
+                let scratch = regs::scratch();
+                self.asm.setp(scratch);
+                self.asm.or_rr(scratch, dst, size);
+            }
+            FloatCmpKind::Lt | FloatCmpKind::Le => (),
+        }
+    }
+
     fn clz(&mut self, src: Reg, dst: Reg, size: OperandSize) {
         if self.flags.has_lzcnt() {
             self.asm.lzcnt(src, dst, size);
@@ -567,9 +693,9 @@ impl Masm for MacroAssembler {
             // dst = size.num_bits() - bsr(src) - is_not_zero
             //     = size.num.bits() + -bsr(src) - is_not_zero.
             self.asm.bsr(src.into(), dst.into(), size);
-            self.asm.setcc(CmpKind::Ne, scratch.into());
+            self.asm.setcc(IntCmpKind::Ne, scratch.into());
             self.asm.neg(dst, dst, size);
-            self.asm.add_ir(size.num_bits(), dst, size);
+            self.asm.add_ir(size.num_bits() as i32, dst, size);
             self.asm.sub_rr(scratch, dst, size);
         }
     }
@@ -587,7 +713,7 @@ impl Masm for MacroAssembler {
             // When the value is 0, BSF outputs 0, correct output for ctz is
             // the number of bits.
             self.asm.bsf(src.into(), dst.into(), size);
-            self.asm.setcc(CmpKind::Eq, scratch.into());
+            self.asm.setcc(IntCmpKind::Eq, scratch.into());
             self.asm
                 .shift_ir(size.log2(), scratch, ShiftKind::Shl, size);
             self.asm.add_rr(scratch, dst, size);
@@ -606,21 +732,21 @@ impl Masm for MacroAssembler {
 
     fn branch(
         &mut self,
-        kind: CmpKind,
-        lhs: RegImm,
-        rhs: Reg,
+        kind: IntCmpKind,
+        lhs: Reg,
+        rhs: RegImm,
         taken: MachLabel,
         size: OperandSize,
     ) {
-        use CmpKind::*;
+        use IntCmpKind::*;
 
         match &(lhs, rhs) {
-            (RegImm::Reg(rlhs), rrhs) => {
-                // If the comparision kind is zero or not zero and both operands
+            (rlhs, RegImm::Reg(rrhs)) => {
+                // If the comparison kind is zero or not zero and both operands
                 // are the same register, emit a test instruction. Else we emit
                 // a normal comparison.
                 if (kind == Eq || kind == Ne) && (rlhs == rrhs) {
-                    self.asm.test_rr(*rrhs, *rlhs, size);
+                    self.asm.test_rr(*rlhs, *rrhs, size);
                 } else {
                     self.cmp(lhs, rhs, size);
                 }
@@ -636,7 +762,7 @@ impl Masm for MacroAssembler {
 
     fn popcnt(&mut self, context: &mut CodeGenContext, size: OperandSize) {
         let src = context.pop_to_reg(self, None);
-        if self.flags.has_popcnt() {
+        if self.flags.has_popcnt() && self.flags.has_sse42() {
             self.asm.popcnt(src.into(), size);
             context.stack.push(src.into());
         } else {
@@ -700,14 +826,114 @@ impl Masm for MacroAssembler {
         }
     }
 
+    fn wrap(&mut self, src: Reg, dst: Reg) {
+        self.asm.mov_rr(src.into(), dst.into(), OperandSize::S32);
+    }
+
+    fn extend(&mut self, src: Reg, dst: Reg, kind: ExtendKind) {
+        if let ExtendKind::I64ExtendI32U = kind {
+            self.asm.movzx_rr(src, dst, kind);
+        } else {
+            self.asm.movsx_rr(src, dst, kind);
+        }
+    }
+
+    fn signed_truncate(
+        &mut self,
+        src: Reg,
+        dst: Reg,
+        src_size: OperandSize,
+        dst_size: OperandSize,
+        kind: TruncKind,
+    ) {
+        self.asm.cvt_float_to_sint_seq(
+            src,
+            dst,
+            regs::scratch(),
+            regs::scratch_xmm(),
+            src_size,
+            dst_size,
+            kind.is_checked(),
+        );
+    }
+
+    fn unsigned_truncate(
+        &mut self,
+        src: Reg,
+        dst: Reg,
+        tmp_fpr: Reg,
+        src_size: OperandSize,
+        dst_size: OperandSize,
+        kind: TruncKind,
+    ) {
+        self.asm.cvt_float_to_uint_seq(
+            src,
+            dst,
+            regs::scratch(),
+            regs::scratch_xmm(),
+            tmp_fpr,
+            src_size,
+            dst_size,
+            kind.is_checked(),
+        );
+    }
+
+    fn signed_convert(&mut self, src: Reg, dst: Reg, src_size: OperandSize, dst_size: OperandSize) {
+        self.asm.cvt_sint_to_float(src, dst, src_size, dst_size);
+    }
+
+    fn unsigned_convert(
+        &mut self,
+        src: Reg,
+        dst: Reg,
+        tmp_gpr: Reg,
+        src_size: OperandSize,
+        dst_size: OperandSize,
+    ) {
+        // Need to convert unsigned uint32 to uint64 for conversion instruction sequence.
+        if let OperandSize::S32 = src_size {
+            self.extend(src, src, ExtendKind::I64ExtendI32U);
+        }
+
+        self.asm
+            .cvt_uint64_to_float_seq(src, dst, regs::scratch(), tmp_gpr, dst_size);
+    }
+
+    fn reinterpret_float_as_int(&mut self, src: Reg, dst: Reg, size: OperandSize) {
+        self.asm.xmm_to_gpr(src, dst, size);
+    }
+
+    fn reinterpret_int_as_float(&mut self, src: Reg, dst: Reg, size: OperandSize) {
+        self.asm.gpr_to_xmm(src.into(), dst, size);
+    }
+
+    fn demote(&mut self, src: Reg, dst: Reg) {
+        self.asm
+            .cvt_float_to_float(src.into(), dst.into(), OperandSize::S64, OperandSize::S32);
+    }
+
+    fn promote(&mut self, src: Reg, dst: Reg) {
+        self.asm
+            .cvt_float_to_float(src.into(), dst.into(), OperandSize::S32, OperandSize::S64);
+    }
+
     fn unreachable(&mut self) {
         self.asm.trap(TrapCode::UnreachableCodeReached)
     }
 
-    fn trapif(&mut self, cc: CmpKind, code: TrapCode) {
+    fn trap(&mut self, code: TrapCode) {
+        self.asm.trap(code);
+    }
+
+    fn trapif(&mut self, cc: IntCmpKind, code: TrapCode) {
         self.asm.trapif(cc, code);
     }
 
+    fn trapz(&mut self, src: Reg, code: TrapCode) {
+        self.asm.test_rr(src, src, self.ptr_size);
+        self.asm.trapif(IntCmpKind::Eq, code);
+    }
+
     fn jmp_table(&mut self, targets: &[MachLabel], index: Reg, tmp: Reg) {
         // At least one default target.
         assert!(targets.len() >= 1);
@@ -718,14 +944,26 @@ impl Masm for MacroAssembler {
         let max = default_index;
         let size = OperandSize::S32;
         self.asm.mov_ir(max as u64, tmp, size);
-        self.asm.cmp_rr(index, tmp, size);
-        self.asm.cmov(tmp, index, CmpKind::LtU, size);
+        self.asm.cmp_rr(tmp, index, size);
+        self.asm.cmov(tmp, index, IntCmpKind::LtU, size);
 
         let default = targets[default_index];
         let rest = &targets[0..default_index];
         let tmp1 = regs::scratch();
         self.asm.jmp_table(rest.into(), default, index, tmp1, tmp);
     }
+
+    fn start_source_loc(&mut self, loc: RelSourceLoc) -> (CodeOffset, RelSourceLoc) {
+        self.asm.buffer_mut().start_srcloc(loc)
+    }
+
+    fn end_source_loc(&mut self) {
+        self.asm.buffer_mut().end_srcloc();
+    }
+
+    fn current_code_offset(&self) -> CodeOffset {
+        self.asm.buffer().cur_offset()
+    }
 }
 
 impl MacroAssembler {
@@ -735,17 +973,35 @@ impl MacroAssembler {
         shared_flags: settings::Flags,
         isa_flags: x64_settings::Flags,
     ) -> Self {
+        let ptr_type: WasmValType = ptr_type_from_ptr_size(ptr_size.size()).into();
+
         Self {
             sp_offset: 0,
+            sp_max: 0,
+            stack_max_use_add: None,
             asm: Assembler::new(shared_flags.clone(), isa_flags.clone()),
             flags: isa_flags,
             shared_flags,
-            ptr_size: ptr_type_from_ptr_size(ptr_size.size()).into(),
+            ptr_size: ptr_type.into(),
         }
     }
 
+    /// Add the maximum stack used to a register, recording an obligation to update the
+    /// add-with-immediate instruction emitted to use the real stack max when the masm is being
+    /// finalized.
+    fn add_stack_max(&mut self, reg: Reg) {
+        assert!(self.stack_max_use_add.is_none());
+        let patch = PatchableAddToReg::new(reg, OperandSize::S64, self.asm.buffer_mut());
+        self.stack_max_use_add.replace(patch);
+    }
+
     fn increment_sp(&mut self, bytes: u32) {
         self.sp_offset += bytes;
+
+        // NOTE: we use `max` here to track the largest stack allocation in `sp_max`. Once we have
+        // seen the entire function, this value will represent the maximum size for the stack
+        // frame.
+        self.sp_max = self.sp_max.max(self.sp_offset);
     }
 
     fn decrement_sp(&mut self, bytes: u32) {
@@ -766,6 +1022,80 @@ impl MacroAssembler {
         }
     }
 
+    /// A common implementation for zero-extend stack loads.
+    fn load_impl<M>(&mut self, src: Address, dst: Reg, size: OperandSize, flags: MemFlags)
+    where
+        M: Masm,
+    {
+        if dst.is_int() {
+            let access_bits = size.num_bits() as u16;
+
+            let ext_mode = match access_bits {
+                8 => Some(ExtMode::BQ),
+                16 => Some(ExtMode::WQ),
+                32 => Some(ExtMode::LQ),
+                _ => None,
+            };
+
+            self.asm.movzx_mr(&src, dst, ext_mode, flags);
+        } else {
+            self.asm.xmm_mov_mr(&src, dst, size, flags);
+        }
+    }
+
+    /// A common implementation for stack stores.
+    fn store_impl(&mut self, src: RegImm, dst: Address, size: OperandSize, flags: MemFlags) {
+        match src {
+            RegImm::Imm(imm) => match imm {
+                I::I32(v) => self.asm.mov_im(v as i32, &dst, size, flags),
+                I::I64(v) => match v.try_into() {
+                    Ok(v) => self.asm.mov_im(v, &dst, size, flags),
+                    Err(_) => {
+                        // If the immediate doesn't sign extend, use a scratch
+                        // register.
+                        let scratch = regs::scratch();
+                        self.asm.mov_ir(v, scratch, size);
+                        self.asm.mov_rm(scratch, &dst, size, flags);
+                    }
+                },
+                I::F32(v) => {
+                    let addr = self.asm.add_constant(v.to_le_bytes().as_slice());
+                    let float_scratch = regs::scratch_xmm();
+                    // Always trusted, since we are loading the constant from
+                    // the constant pool.
+                    self.asm
+                        .xmm_mov_mr(&addr, float_scratch, size, MemFlags::trusted());
+                    self.asm.xmm_mov_rm(float_scratch, &dst, size, flags);
+                }
+                I::F64(v) => {
+                    let addr = self.asm.add_constant(v.to_le_bytes().as_slice());
+                    let float_scratch = regs::scratch_xmm();
+                    // Similar to above, always trusted since we are loading the
+                    // constant from the constant pool.
+                    self.asm
+                        .xmm_mov_mr(&addr, float_scratch, size, MemFlags::trusted());
+                    self.asm.xmm_mov_rm(float_scratch, &dst, size, flags);
+                }
+                I::V128(v) => {
+                    let addr = self.asm.add_constant(v.to_le_bytes().as_slice());
+                    let vector_scratch = regs::scratch_xmm();
+                    // Always trusted, since we are loading the constant from
+                    // the constant pool.
+                    self.asm
+                        .xmm_mov_mr(&addr, vector_scratch, size, MemFlags::trusted());
+                    self.asm.xmm_mov_rm(vector_scratch, &dst, size, flags);
+                }
+            },
+            RegImm::Reg(reg) => {
+                if reg.is_int() {
+                    self.asm.mov_rm(reg, &dst, size, flags);
+                } else {
+                    self.asm.xmm_mov_rm(reg, &dst, size, flags);
+                }
+            }
+        }
+    }
+
     fn handle_invalid_operand_combination<T>(src: impl Into<RegImm>, dst: impl Into<RegImm>) -> T {
         panic!(
             "Invalid operand combination; src={:?}, dst={:?}",
@@ -777,9 +1107,7 @@ impl MacroAssembler {
     fn ensure_two_argument_form(dst: &Reg, lhs: &Reg) {
         assert!(
             dst == lhs,
-            "the destination and first source argument must be the same, dst={:?}, lhs={:?}",
-            dst,
-            lhs
+            "the destination and first source argument must be the same, dst={dst:?}, lhs={lhs:?}"
         );
     }
 }
diff --git a/winch/codegen/src/isa/x64/mod.rs b/winch/codegen/src/isa/x64/mod.rs
index 4703f7f20edb..68f91c76dfb8 100644
--- a/winch/codegen/src/isa/x64/mod.rs
+++ b/winch/codegen/src/isa/x64/mod.rs
@@ -1,14 +1,13 @@
 use crate::{
-    abi::ABI,
-    codegen::{CodeGen, CodeGenContext, FuncEnv},
+    abi::{wasm_sig, ABI},
+    codegen::{BuiltinFunctions, CodeGen, CodeGenContext, FuncEnv, TypeConverter},
 };
 
 use crate::frame::{DefinedLocals, Frame};
-use crate::isa::{x64::masm::MacroAssembler as X64Masm, CallingConvention};
+use crate::isa::x64::masm::MacroAssembler as X64Masm;
 use crate::masm::MacroAssembler;
 use crate::regalloc::RegAlloc;
 use crate::stack::Stack;
-use crate::trampoline::{Trampoline, TrampolineKind};
 use crate::{
     isa::{Builder, TargetIsa},
     regset::RegBitSet,
@@ -19,7 +18,8 @@ use cranelift_codegen::{isa::x64::settings as x64_settings, Final, MachBufferFin
 use cranelift_codegen::{MachTextSectionBuilder, TextSectionBuilder};
 use target_lexicon::Triple;
 use wasmparser::{FuncValidator, FunctionBody, ValidatorResources};
-use wasmtime_environ::{ModuleTranslation, ModuleTypes, WasmFuncType};
+use wasmtime_cranelift::CompiledFunction;
+use wasmtime_environ::{ModuleTranslation, ModuleTypesBuilder, VMOffsets, WasmFuncType};
 
 use self::regs::{ALL_FPR, ALL_GPR, MAX_FPR, MAX_GPR, NON_ALLOCATABLE_FPR, NON_ALLOCATABLE_GPR};
 
@@ -89,12 +89,15 @@ impl TargetIsa for X64 {
     fn compile_function(
         &self,
         sig: &WasmFuncType,
-        types: &ModuleTypes,
         body: &FunctionBody,
         translation: &ModuleTranslation,
+        types: &ModuleTypesBuilder,
+        builtins: &mut BuiltinFunctions,
         validator: &mut FuncValidator<ValidatorResources>,
-    ) -> Result<MachBufferFinalized<Final>> {
+    ) -> Result<CompiledFunction> {
         let pointer_bytes = self.pointer_bytes();
+        let vmoffsets = VMOffsets::new(pointer_bytes, &translation.module);
+
         let mut body = body.get_binary_reader();
         let mut masm = X64Masm::new(
             pointer_bytes,
@@ -102,9 +105,20 @@ impl TargetIsa for X64 {
             self.isa_flags.clone(),
         );
         let stack = Stack::new();
-        let abi_sig = abi::X64ABI::sig(sig, &CallingConvention::Default);
 
-        let defined_locals = DefinedLocals::new(translation, &mut body, validator)?;
+        let abi_sig = wasm_sig::<abi::X64ABI>(sig);
+
+        let env = FuncEnv::new(
+            &vmoffsets,
+            translation,
+            types,
+            builtins,
+            self,
+            abi::X64ABI::ptr_type(),
+        );
+        let type_converter = TypeConverter::new(env.translation, env.types);
+        let defined_locals =
+            DefinedLocals::new::<abi::X64ABI>(&type_converter, &mut body, validator)?;
         let frame = Frame::new::<abi::X64ABI>(&abi_sig, &defined_locals)?;
         let gpr = RegBitSet::int(
             ALL_GPR.into(),
@@ -118,13 +132,18 @@ impl TargetIsa for X64 {
         );
 
         let regalloc = RegAlloc::from(gpr, fpr);
-        let codegen_context = CodeGenContext::new(regalloc, stack, &frame);
-        let env = FuncEnv::new(pointer_bytes, translation, types, self.wasmtime_call_conv());
+        let codegen_context = CodeGenContext::new(regalloc, stack, frame, &vmoffsets);
         let mut codegen = CodeGen::new(&mut masm, codegen_context, env, abi_sig);
 
         codegen.emit(&mut body, validator)?;
-
-        Ok(masm.finalize())
+        let base = codegen.source_location.base;
+
+        let names = codegen.env.take_name_map();
+        Ok(CompiledFunction::new(
+            masm.finalize(base),
+            names,
+            self.function_alignment(),
+        ))
     }
 
     fn text_section_builder(&self, num_funcs: usize) -> Box<dyn TextSectionBuilder> {
@@ -136,34 +155,15 @@ impl TargetIsa for X64 {
         16
     }
 
-    fn compile_trampoline(
+    fn emit_unwind_info(
         &self,
-        ty: &WasmFuncType,
-        kind: TrampolineKind,
-    ) -> Result<MachBufferFinalized<Final>> {
-        use TrampolineKind::*;
-
-        let mut masm = X64Masm::new(
-            self.pointer_bytes(),
-            self.shared_flags.clone(),
-            self.isa_flags.clone(),
-        );
-        let call_conv = self.wasmtime_call_conv();
-
-        let mut trampoline = Trampoline::new(
-            &mut masm,
-            regs::scratch(),
-            regs::argv(),
-            &call_conv,
-            self.pointer_bytes(),
-        );
-
-        match kind {
-            ArrayToWasm(idx) => trampoline.emit_array_to_wasm(ty, idx)?,
-            NativeToWasm(idx) => trampoline.emit_native_to_wasm(ty, idx)?,
-            WasmToNative => trampoline.emit_wasm_to_native(ty)?,
-        }
+        buffer: &MachBufferFinalized<Final>,
+        kind: cranelift_codegen::isa::unwind::UnwindInfoKind,
+    ) -> Result<Option<cranelift_codegen::isa::unwind::UnwindInfo>> {
+        Ok(cranelift_codegen::isa::x64::emit_unwind_info(buffer, kind)?)
+    }
 
-        Ok(masm.finalize())
+    fn create_systemv_cie(&self) -> Option<gimli::write::CommonInformationEntry> {
+        Some(cranelift_codegen::isa::x64::create_cie())
     }
 }
diff --git a/winch/codegen/src/isa/x64/regs.rs b/winch/codegen/src/isa/x64/regs.rs
index 238423dac896..0118f8b97d18 100644
--- a/winch/codegen/src/isa/x64/regs.rs
+++ b/winch/codegen/src/isa/x64/regs.rs
@@ -99,18 +99,6 @@ pub(crate) fn scratch() -> Reg {
     r11()
 }
 
-/// This register is used as a scratch register, in the context of trampolines only,
-/// where we assume that callee-saved registers are given the correct handling
-/// according to the system ABI. r12 is chosen given that it's a callee-saved,
-/// non-argument register.
-///
-/// In the context of all other internal functions, this register is not excluded
-/// from register allocation, so no extra assumptions should be made regarding
-/// its availability.
-pub(crate) fn argv() -> Reg {
-    r12()
-}
-
 fn fpr(enc: u8) -> Reg {
     Reg::new(PReg::new(enc as usize, RegClass::Float))
 }
@@ -205,7 +193,7 @@ pub(crate) fn callee_saved(call_conv: &CallingConvention) -> SmallVec<[(Reg, Ope
     use CallingConvention::*;
     use OperandSize::*;
     let regs: SmallVec<[_; 18]> = match call_conv {
-        WasmtimeSystemV => {
+        SystemV => {
             smallvec![rbx(), r12(), r13(), r14(), r15(),]
         }
         WindowsFastcall => {
diff --git a/winch/codegen/src/lib.rs b/winch/codegen/src/lib.rs
index f68aa5ab3a2a..30158a082a91 100644
--- a/winch/codegen/src/lib.rs
+++ b/winch/codegen/src/lib.rs
@@ -7,7 +7,7 @@
 #![cfg_attr(not(feature = "all-arch"), allow(dead_code))]
 
 mod abi;
-pub use codegen::FuncEnv;
+pub use codegen::{BuiltinFunctions, FuncEnv};
 mod codegen;
 mod frame;
 pub mod isa;
@@ -16,6 +16,4 @@ mod masm;
 mod regalloc;
 mod regset;
 mod stack;
-mod trampoline;
-pub use trampoline::TrampolineKind;
 mod visitor;
diff --git a/winch/codegen/src/masm.rs b/winch/codegen/src/masm.rs
index ec258b7b39af..98d75b3be658 100644
--- a/winch/codegen/src/masm.rs
+++ b/winch/codegen/src/masm.rs
@@ -1,7 +1,11 @@
-use crate::abi::{self, align_to, LocalSlot};
-use crate::codegen::{CodeGenContext, TableData};
+use crate::abi::{self, align_to, scratch, LocalSlot};
+use crate::codegen::{CodeGenContext, FuncEnv};
 use crate::isa::reg::Reg;
-use cranelift_codegen::{Final, MachBufferFinalized, MachLabel};
+use cranelift_codegen::{
+    binemit::CodeOffset,
+    ir::{Endianness, LibCall, MemFlags, RelSourceLoc, SourceLoc, UserExternalNameRef},
+    Final, MachBufferFinalized, MachLabel,
+};
 use std::{fmt::Debug, ops::Range};
 use wasmtime_environ::PtrSize;
 
@@ -23,20 +27,72 @@ pub(crate) enum RemKind {
     Unsigned,
 }
 
+/// The direction to perform the memory move.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub(crate) enum MemMoveDirection {
+    /// From high memory addresses to low memory addresses.
+    /// Invariant: the source location is closer to the FP than the destination
+    /// location, which will be closer to the SP.
+    HighToLow,
+    /// From low memory addresses to high memory addresses.
+    /// Invariant: the source location is closer to the SP than the destination
+    /// location, which will be closer to the FP.
+    LowToHigh,
+}
+
+/// Classifies how to treat float-to-int conversions.
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub(crate) enum TruncKind {
+    /// Saturating conversion. If the source value is greater than the maximum
+    /// value of the destination type, the result is clamped to the
+    /// destination maximum value.
+    Checked,
+    /// An exception is raised if the source value is greater than the maximum
+    /// value of the destination type.
+    Unchecked,
+}
+
+impl TruncKind {
+    /// Returns true if the truncation kind is checked.
+    pub(crate) fn is_checked(&self) -> bool {
+        *self == TruncKind::Checked
+    }
+}
+
+/// Representation of the stack pointer offset.
+#[derive(Copy, Clone, Eq, PartialEq, Debug, PartialOrd, Ord, Default)]
+pub struct SPOffset(u32);
+
+impl SPOffset {
+    pub fn from_u32(offs: u32) -> Self {
+        Self(offs)
+    }
+
+    pub fn as_u32(&self) -> u32 {
+        self.0
+    }
+}
+
 /// A stack slot.
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct StackSlot {
     /// The location of the slot, relative to the stack pointer.
-    pub offset: u32,
+    pub offset: SPOffset,
     /// The size of the slot, in bytes.
     pub size: u32,
 }
 
-/// Kinds of binary comparison in WebAssembly. The [`masm`] implementation for
-/// each ISA is responsible for emitting the correct sequence of instructions
-/// when lowering to machine code.
+impl StackSlot {
+    pub fn new(offs: SPOffset, size: u32) -> Self {
+        Self { offset: offs, size }
+    }
+}
+
+/// Kinds of integer binary comparison in WebAssembly. The [`MacroAssembler`]
+/// implementation for each ISA is responsible for emitting the correct
+/// sequence of instructions when lowering to machine code.
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
-pub(crate) enum CmpKind {
+pub(crate) enum IntCmpKind {
     /// Equal.
     Eq,
     /// Not equal.
@@ -59,9 +115,29 @@ pub(crate) enum CmpKind {
     GeU,
 }
 
+/// Kinds of float binary comparison in WebAssembly. The [`MacroAssembler`]
+/// implementation for each ISA is responsible for emitting the correct
+/// sequence of instructions when lowering code.
+#[derive(Debug)]
+pub(crate) enum FloatCmpKind {
+    /// Equal.
+    Eq,
+    /// Not equal.
+    Ne,
+    /// Less than.
+    Lt,
+    /// Greater than.
+    Gt,
+    /// Less than or equal.
+    Le,
+    /// Greater than or equal.
+    Ge,
+}
+
 /// Kinds of shifts in WebAssembly.The [`masm`] implementation for each ISA is
 /// responsible for emitting the correct sequence of instructions when
 /// lowering to machine code.
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub(crate) enum ShiftKind {
     /// Left shift.
     Shl,
@@ -75,9 +151,62 @@ pub(crate) enum ShiftKind {
     Rotr,
 }
 
+/// Kinds of extends in WebAssembly. Each MacroAssembler implementation
+/// is responsible for emitting the correct sequence of instructions when
+/// lowering to machine code.
+pub(crate) enum ExtendKind {
+    /// Sign extends i32 to i64.
+    I64ExtendI32S,
+    /// Zero extends i32 to i64.
+    I64ExtendI32U,
+    // Sign extends the 8 least significant bits to 32 bits.
+    I32Extend8S,
+    // Sign extends the 16 least significant bits to 32 bits.
+    I32Extend16S,
+    /// Sign extends the 8 least significant bits to 64 bits.
+    I64Extend8S,
+    /// Sign extends the 16 least significant bits to 64 bits.
+    I64Extend16S,
+    /// Sign extends the 32 least significant bits to 64 bits.
+    I64Extend32S,
+}
+
+impl ExtendKind {
+    pub fn signed(&self) -> bool {
+        if let Self::I64ExtendI32U = self {
+            false
+        } else {
+            true
+        }
+    }
+
+    pub fn from_bits(&self) -> u8 {
+        match self {
+            Self::I64ExtendI32S | Self::I64ExtendI32U | Self::I64Extend32S => 32,
+            Self::I32Extend8S | Self::I64Extend8S => 8,
+            Self::I32Extend16S | Self::I64Extend16S => 16,
+        }
+    }
+
+    pub fn to_bits(&self) -> u8 {
+        match self {
+            Self::I64ExtendI32S
+            | Self::I64ExtendI32U
+            | Self::I64Extend8S
+            | Self::I64Extend16S
+            | Self::I64Extend32S => 64,
+            Self::I32Extend8S | Self::I32Extend16S => 32,
+        }
+    }
+}
+
 /// Operand size, in bits.
 #[derive(Copy, Debug, Clone, Eq, PartialEq)]
 pub(crate) enum OperandSize {
+    /// 8 bits.
+    S8,
+    /// 16 bits.
+    S16,
     /// 32 bits.
     S32,
     /// 64 bits.
@@ -88,8 +217,10 @@ pub(crate) enum OperandSize {
 
 impl OperandSize {
     /// The number of bits in the operand.
-    pub fn num_bits(&self) -> i32 {
+    pub fn num_bits(&self) -> u8 {
         match self {
+            OperandSize::S8 => 8,
+            OperandSize::S16 => 16,
             OperandSize::S32 => 32,
             OperandSize::S64 => 64,
             OperandSize::S128 => 128,
@@ -99,6 +230,8 @@ impl OperandSize {
     /// The number of bytes in the operand.
     pub fn bytes(&self) -> u32 {
         match self {
+            Self::S8 => 1,
+            Self::S16 => 2,
             Self::S32 => 4,
             Self::S64 => 8,
             Self::S128 => 16,
@@ -108,6 +241,8 @@ impl OperandSize {
     /// The binary logarithm of the number of bits in the operand.
     pub fn log2(&self) -> u8 {
         match self {
+            OperandSize::S8 => 3,
+            OperandSize::S16 => 4,
             OperandSize::S32 => 5,
             OperandSize::S64 => 6,
             OperandSize::S128 => 7,
@@ -121,7 +256,7 @@ impl OperandSize {
             4 => S32,
             8 => S64,
             16 => S128,
-            _ => panic!("Invalid bytes {} for OperandSize", bytes),
+            _ => panic!("Invalid bytes {bytes} for OperandSize"),
         }
     }
 }
@@ -146,6 +281,8 @@ pub(crate) enum Imm {
     F32(u32),
     /// F64 immediate.
     F64(u64),
+    /// V128 immediate.
+    V128(i128),
 }
 
 impl Imm {
@@ -160,19 +297,20 @@ impl Imm {
     }
 
     /// Create a new F32 immediate.
-    // Temporary until support for f32.const is added.
-    #[allow(dead_code)]
     pub fn f32(bits: u32) -> Self {
         Self::F32(bits)
     }
 
     /// Create a new F64 immediate.
-    // Temporary until support for f64.const is added.
-    #[allow(dead_code)]
     pub fn f64(bits: u64) -> Self {
         Self::F64(bits)
     }
 
+    /// Create a new V128 immediate.
+    pub fn v128(bits: i128) -> Self {
+        Self::V128(bits)
+    }
+
     /// Convert the immediate to i32, if possible.
     pub fn to_i32(&self) -> Option<i32> {
         match self {
@@ -183,12 +321,91 @@ impl Imm {
     }
 }
 
-#[derive(Clone)]
+/// The location of the [VMcontext] used for function calls.
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub(crate) enum VMContextLoc {
+    /// Dynamic, stored in the given register.
+    Reg(Reg),
+    /// The pinned [VMContext] register.
+    Pinned,
+}
+
+/// The maximum number of context arguments currently used across the compiler.
+pub(crate) const MAX_CONTEXT_ARGS: usize = 2;
+
+/// Out-of-band special purpose arguments used for function call emission.
+///
+/// We cannot rely on the value stack for these values given that inserting
+/// register or memory values at arbitrary locations of the value stack has the
+/// potential to break the stack ordering principle, which states that older
+/// values must always precede newer values, effectively simulating the order of
+/// values in the machine stack.
+/// The [ContextArgs] are meant to be resolved at every callsite; in some cases
+/// it might be possible to construct it early on, but given that it might
+/// contain allocatable registers, it's preferred to construct it in
+/// [FnCall::emit].
+#[derive(Clone, Debug)]
+pub(crate) enum ContextArgs {
+    /// No context arguments required. This is used for libcalls that don't
+    /// require any special context arguments. For example builtin functions
+    /// that perform float calculations.
+    None,
+    /// A single context argument is required; the current pinned [VMcontext]
+    /// register must be passed as the first argument of the function call.
+    VMContext([VMContextLoc; 1]),
+    /// The callee and caller context arguments are required. In this case, the
+    /// callee context argument is usually stored into an allocatable register
+    /// and the caller is always the current pinned [VMContext] pointer.
+    CalleeAndCallerVMContext([VMContextLoc; MAX_CONTEXT_ARGS]),
+}
+
+impl ContextArgs {
+    /// Construct an empty [ContextArgs].
+    pub fn none() -> Self {
+        Self::None
+    }
+
+    /// Construct a [ContextArgs] declaring the usage of the pinned [VMContext]
+    /// register as both the caller and callee context arguments.
+    pub fn pinned_callee_and_caller_vmctx() -> Self {
+        Self::CalleeAndCallerVMContext([VMContextLoc::Pinned, VMContextLoc::Pinned])
+    }
+
+    /// Construct a [ContextArgs] that declares the usage of the pinned
+    /// [VMContext] register as the only context argument.
+    pub fn pinned_vmctx() -> Self {
+        Self::VMContext([VMContextLoc::Pinned])
+    }
+
+    /// Construct a [ContextArgs] that declares a dynamic callee context and the
+    /// pinned [VMContext] register as the context arguments.
+    pub fn with_callee_and_pinned_caller(callee_vmctx: Reg) -> Self {
+        Self::CalleeAndCallerVMContext([VMContextLoc::Reg(callee_vmctx), VMContextLoc::Pinned])
+    }
+
+    /// Get the length of the [ContextArgs].
+    pub fn len(&self) -> usize {
+        self.as_slice().len()
+    }
+
+    /// Get a slice of the context arguments.
+    pub fn as_slice(&self) -> &[VMContextLoc] {
+        match self {
+            Self::None => &[],
+            Self::VMContext(a) => a.as_slice(),
+            Self::CalleeAndCallerVMContext(a) => a.as_slice(),
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
 pub(crate) enum CalleeKind {
     /// A function call to a raw address.
     Indirect(Reg),
     /// A function call to a local function.
-    Direct(u32),
+    Direct(UserExternalNameRef),
+    /// Call to a well known LibCall.
+    LibCall(LibCall),
 }
 
 impl CalleeKind {
@@ -197,9 +414,14 @@ impl CalleeKind {
         Self::Indirect(reg)
     }
 
-    /// Creates a direct callee kind from a function index.
-    pub fn direct(index: u32) -> Self {
-        Self::Direct(index)
+    /// Creates a direct callee kind from a function name.
+    pub fn direct(name: UserExternalNameRef) -> Self {
+        Self::Direct(name)
+    }
+
+    /// Creates a known callee kind from a libcall.
+    pub fn libcall(call: LibCall) -> Self {
+        Self::LibCall(call)
     }
 }
 
@@ -233,13 +455,9 @@ impl RegImm {
         RegImm::Imm(Imm::f64(bits))
     }
 
-    /// Get the underlying register of the operand,
-    /// if it is one.
-    pub fn get_reg(&self) -> Option<Reg> {
-        match self {
-            Self::Reg(r) => Some(*r),
-            _ => None,
-        }
+    /// V128 immediate.
+    pub fn v128(bits: i128) -> Self {
+        RegImm::Imm(Imm::v128(bits))
     }
 }
 
@@ -249,6 +467,7 @@ impl From<Reg> for RegImm {
     }
 }
 
+#[derive(Debug)]
 pub enum RoundingMode {
     Nearest,
     Up,
@@ -256,6 +475,14 @@ pub enum RoundingMode {
     Zero,
 }
 
+/// Memory flags for trusted loads/stores.
+pub const TRUSTED_FLAGS: MemFlags = MemFlags::trusted();
+
+/// Flags used for WebAssembly loads / stores.
+/// Untrusted by default so we don't set `no_trap`.
+/// We also ensure that the endianness is the right one for WebAssembly.
+pub const UNTRUSTED_FLAGS: MemFlags = MemFlags::new().with_endianness(Endianness::Little);
+
 /// Generic MacroAssembler interface used by the code generation.
 ///
 /// The MacroAssembler trait aims to expose an interface, high-level enough,
@@ -275,7 +502,7 @@ pub enum RoundingMode {
 
 pub(crate) trait MacroAssembler {
     /// The addressing mode.
-    type Address: Copy;
+    type Address: Copy + Debug;
 
     /// The pointer representation of the target ISA,
     /// used to access information from [`VMOffsets`].
@@ -285,10 +512,24 @@ pub(crate) trait MacroAssembler {
     type ABI: abi::ABI;
 
     /// Emit the function prologue.
-    fn prologue(&mut self);
+    fn prologue(&mut self, vmctx: Reg) {
+        self.frame_setup();
+        self.check_stack(vmctx);
+    }
+
+    /// Generate the frame setup sequence.
+    fn frame_setup(&mut self);
+
+    /// Generate the frame restore sequence.
+    fn frame_restore(&mut self);
+
+    /// Emit a stack check.
+    fn check_stack(&mut self, vmctx: Reg);
 
     /// Emit the function epilogue.
-    fn epilogue(&mut self, locals_size: u32);
+    fn epilogue(&mut self) {
+        self.frame_restore();
+    }
 
     /// Reserve stack space.
     fn reserve_stack(&mut self, bytes: u32);
@@ -300,29 +541,19 @@ pub(crate) trait MacroAssembler {
     ///
     /// Used to reset the stack pointer to a given offset
     /// when dealing with unreachable code.
-    fn reset_stack_pointer(&mut self, offset: u32);
+    fn reset_stack_pointer(&mut self, offset: SPOffset);
 
     /// Get the address of a local slot.
     fn local_address(&mut self, local: &LocalSlot) -> Self::Address;
 
-    /// Loads the address of the table element at a given index.
-    /// Returns a register that contains address of the table element.
-    fn table_elem_address(
-        &mut self,
-        index: Reg,
-        size: OperandSize,
-        table_data: &TableData,
-        context: &mut CodeGenContext,
-    ) -> Reg;
-
     /// Constructs an address with an offset that is relative to the
     /// current position of the stack pointer (e.g. [sp + (sp_offset -
     /// offset)].
-    fn address_from_sp(&self, offset: u32) -> Self::Address;
+    fn address_from_sp(&self, offset: SPOffset) -> Self::Address;
 
     /// Constructs an address with an offset that is absolute to the
     /// current position of the stack pointer (e.g. [sp + offset].
-    fn address_at_sp(&self, offset: u32) -> Self::Address;
+    fn address_at_sp(&self, offset: SPOffset) -> Self::Address;
 
     /// Alias for [`Self::address_at_reg`] using the VMContext register as
     /// a base. The VMContext register is derived from the ABI type that is
@@ -337,18 +568,51 @@ pub(crate) trait MacroAssembler {
     fn call(&mut self, stack_args_size: u32, f: impl FnMut(&mut Self) -> CalleeKind) -> u32;
 
     /// Get stack pointer offset.
-    fn sp_offset(&self) -> u32;
+    fn sp_offset(&self) -> SPOffset;
 
     /// Perform a stack store.
     fn store(&mut self, src: RegImm, dst: Self::Address, size: OperandSize);
 
-    /// Perform a stack load.
+    /// Alias for `MacroAssembler::store` with the operand size corresponding
+    /// to the pointer size of the target.
+    fn store_ptr(&mut self, src: Reg, dst: Self::Address);
+
+    /// Perform a WebAssembly store.
+    /// A WebAssembly store introduces several additional invariants compared to
+    /// [Self::store], more precisely, it can implicitly trap, in certain
+    /// circumstances, even if explicit bounds checks are elided, in that sense,
+    /// we consider this type of load as untrusted. It can also differ with
+    /// regards to the endianness depending on the target ISA. For this reason,
+    /// [Self::wasm_store], should be explicitly used when emitting WebAssembly
+    /// stores.
+    fn wasm_store(&mut self, src: Reg, dst: Self::Address, size: OperandSize);
+
+    /// Perform a zero-extended stack load.
     fn load(&mut self, src: Self::Address, dst: Reg, size: OperandSize);
 
+    /// Perform a WebAssembly load.
+    /// A WebAssembly load introduces several additional invariants compared to
+    /// [Self::load], more precisely, it can implicitly trap, in certain
+    /// circumstances, even if explicit bounds checks are elided, in that sense,
+    /// we consider this type of load as untrusted. It can also differ with
+    /// regards to the endianness depending on the target ISA. For this reason,
+    /// [Self::wasm_load], should be explicitly used when emitting WebAssembly
+    /// loads.
+    fn wasm_load(
+        &mut self,
+        src: Self::Address,
+        dst: Reg,
+        size: OperandSize,
+        kind: Option<ExtendKind>,
+    );
+
     /// Alias for `MacroAssembler::load` with the operand size corresponding
     /// to the pointer size of the target.
     fn load_ptr(&mut self, src: Self::Address, dst: Reg);
 
+    /// Loads the effective address into destination.
+    fn load_addr(&mut self, _src: Self::Address, _dst: Reg, _size: OperandSize);
+
     /// Pop a value from the machine stack into the given register.
     fn pop(&mut self, dst: Reg, size: OperandSize);
 
@@ -356,17 +620,94 @@ pub(crate) trait MacroAssembler {
     fn mov(&mut self, src: RegImm, dst: Reg, size: OperandSize);
 
     /// Perform a conditional move.
-    fn cmov(&mut self, src: Reg, dst: Reg, cc: CmpKind, size: OperandSize);
+    fn cmov(&mut self, src: Reg, dst: Reg, cc: IntCmpKind, size: OperandSize);
+
+    /// Performs a memory move of bytes from src to dest.
+    /// Bytes are moved in blocks of 8 bytes, where possible.
+    fn memmove(&mut self, src: SPOffset, dst: SPOffset, bytes: u32, direction: MemMoveDirection) {
+        match direction {
+            MemMoveDirection::LowToHigh => debug_assert!(dst.as_u32() < src.as_u32()),
+            MemMoveDirection::HighToLow => debug_assert!(dst.as_u32() > src.as_u32()),
+        }
+        // At least 4 byte aligned.
+        debug_assert!(bytes % 4 == 0);
+        let mut remaining = bytes;
+        let word_bytes = <Self::ABI as abi::ABI>::word_bytes();
+        let scratch = scratch!(Self);
+
+        let mut dst_offs = dst.as_u32() - bytes;
+        let mut src_offs = src.as_u32() - bytes;
+
+        let word_bytes = word_bytes as u32;
+        while remaining >= word_bytes {
+            remaining -= word_bytes;
+            dst_offs += word_bytes;
+            src_offs += word_bytes;
+
+            self.load_ptr(self.address_from_sp(SPOffset::from_u32(src_offs)), scratch);
+            self.store_ptr(
+                scratch.into(),
+                self.address_from_sp(SPOffset::from_u32(dst_offs)),
+            );
+        }
+
+        if remaining > 0 {
+            let half_word = word_bytes / 2;
+            let ptr_size = OperandSize::from_bytes(half_word as u8);
+            debug_assert!(remaining == half_word);
+            dst_offs += half_word;
+            src_offs += half_word;
+
+            self.load(
+                self.address_from_sp(SPOffset::from_u32(src_offs)),
+                scratch,
+                ptr_size,
+            );
+            self.store(
+                scratch.into(),
+                self.address_from_sp(SPOffset::from_u32(dst_offs)),
+                ptr_size,
+            );
+        }
+    }
 
     /// Perform add operation.
     fn add(&mut self, dst: Reg, lhs: Reg, rhs: RegImm, size: OperandSize);
 
+    /// Perform a checked unsigned integer addition, emitting the provided trap
+    /// if the addition overflows.
+    fn checked_uadd(&mut self, dst: Reg, lhs: Reg, rhs: RegImm, size: OperandSize, trap: TrapCode);
+
     /// Perform subtraction operation.
     fn sub(&mut self, dst: Reg, lhs: Reg, rhs: RegImm, size: OperandSize);
 
     /// Perform multiplication operation.
     fn mul(&mut self, dst: Reg, lhs: Reg, rhs: RegImm, size: OperandSize);
 
+    /// Perform a floating point add operation.
+    fn float_add(&mut self, dst: Reg, lhs: Reg, rhs: Reg, size: OperandSize);
+
+    /// Perform a floating point subtraction operation.
+    fn float_sub(&mut self, dst: Reg, lhs: Reg, rhs: Reg, size: OperandSize);
+
+    /// Perform a floating point multiply operation.
+    fn float_mul(&mut self, dst: Reg, lhs: Reg, rhs: Reg, size: OperandSize);
+
+    /// Perform a floating point divide operation.
+    fn float_div(&mut self, dst: Reg, lhs: Reg, rhs: Reg, size: OperandSize);
+
+    /// Perform a floating point minimum operation. In x86, this will emit
+    /// multiple instructions.
+    fn float_min(&mut self, dst: Reg, lhs: Reg, rhs: Reg, size: OperandSize);
+
+    /// Perform a floating point maximum operation. In x86, this will emit
+    /// multiple instructions.
+    fn float_max(&mut self, dst: Reg, lhs: Reg, rhs: Reg, size: OperandSize);
+
+    /// Perform a floating point copysign operation. In x86, this will emit
+    /// multiple instructions.
+    fn float_copysign(&mut self, dst: Reg, lhs: Reg, rhs: Reg, size: OperandSize);
+
     /// Perform a floating point abs operation.
     fn float_abs(&mut self, dst: Reg, size: OperandSize);
 
@@ -374,7 +715,17 @@ pub(crate) trait MacroAssembler {
     fn float_neg(&mut self, dst: Reg, size: OperandSize);
 
     /// Perform a floating point floor operation.
-    fn float_round(&mut self, mode: RoundingMode, dst: Reg, src: RegImm, size: OperandSize);
+    fn float_round<F: FnMut(&mut FuncEnv<Self::Ptr>, &mut CodeGenContext, &mut Self)>(
+        &mut self,
+        mode: RoundingMode,
+        env: &mut FuncEnv<Self::Ptr>,
+        context: &mut CodeGenContext,
+        size: OperandSize,
+        fallback: F,
+    );
+
+    /// Perform a floating point square root operation.
+    fn float_sqrt(&mut self, dst: Reg, src: Reg, size: OperandSize);
 
     /// Perform logical and operation.
     fn and(&mut self, dst: Reg, lhs: Reg, rhs: RegImm, size: OperandSize);
@@ -385,8 +736,11 @@ pub(crate) trait MacroAssembler {
     /// Perform logical exclusive or operation.
     fn xor(&mut self, dst: Reg, lhs: Reg, rhs: RegImm, size: OperandSize);
 
-    /// Perform a shift operation.
-    /// Shift is special in that some architectures have specific expectations
+    /// Perform a shift operation between a register and an immediate.
+    fn shift_ir(&mut self, dst: Reg, imm: u64, lhs: Reg, kind: ShiftKind, size: OperandSize);
+
+    /// Perform a shift operation between two registers.
+    /// This case is special in that some architectures have specific expectations
     /// regarding the location of the instruction arguments. To free the
     /// caller from having to deal with the architecture specific constraints
     /// we give this function access to the code generation context, allowing
@@ -398,7 +752,7 @@ pub(crate) trait MacroAssembler {
     /// expectations regarding the location of the instruction
     /// arguments and regarding the location of the quotient /
     /// remainder. To free the caller from having to deal with the
-    /// architecure specific contraints we give this function access
+    /// architecture specific constraints we give this function access
     /// to the code generation context, allowing each implementation
     /// to decide the lowering path.  For cases in which division is a
     /// unconstrained binary operation, the caller can decide to use
@@ -409,19 +763,39 @@ pub(crate) trait MacroAssembler {
     /// Calculate remainder.
     fn rem(&mut self, context: &mut CodeGenContext, kind: RemKind, size: OperandSize);
 
-    /// Compare src and dst and put the result in dst.
-    fn cmp(&mut self, src: RegImm, dest: Reg, size: OperandSize);
+    /// Compares `src1` against `src2` for the side effect of setting processor
+    /// flags.
+    ///
+    /// Note that `src1` is the left-hand-side of the comparison and `src2` is
+    /// the right-hand-side, so if testing `a < b` then `src1 == a` and
+    /// `src2 == b`
+    fn cmp(&mut self, src1: Reg, src2: RegImm, size: OperandSize);
 
     /// Compare src and dst and put the result in dst.
     /// This function will potentially emit a series of instructions.
-    fn cmp_with_set(&mut self, src: RegImm, dst: Reg, kind: CmpKind, size: OperandSize);
+    ///
+    /// The initial value in `dst` is the left-hand-side of the comparison and
+    /// the initial value in `src` is the right-hand-side of the comparison.
+    /// That means for `a < b` then `dst == a` and `src == b`.
+    fn cmp_with_set(&mut self, src: RegImm, dst: Reg, kind: IntCmpKind, size: OperandSize);
+
+    /// Compare floats in src1 and src2 and put the result in dst.
+    /// In x86, this will emit multiple instructions.
+    fn float_cmp_with_set(
+        &mut self,
+        src1: Reg,
+        src2: Reg,
+        dst: Reg,
+        kind: FloatCmpKind,
+        size: OperandSize,
+    );
 
     /// Count the number of leading zeroes in src and put the result in dst.
     /// In x64, this will emit multiple instructions if the `has_lzcnt` flag is
     /// false.
     fn clz(&mut self, src: Reg, dst: Reg, size: OperandSize);
 
-    /// Count the number of trailing zeroes in src and put the result in dst.
+    /// Count the number of trailing zeroes in src and put the result in dst.masm
     /// In x64, this will emit multiple instructions if the `has_tzcnt` flag is
     /// false.
     fn ctz(&mut self, src: Reg, dst: Reg, size: OperandSize);
@@ -435,7 +809,7 @@ pub(crate) trait MacroAssembler {
     fn push(&mut self, src: Reg, size: OperandSize) -> StackSlot;
 
     /// Finalize the assembly and return the result.
-    fn finalize(self) -> MachBufferFinalized<Final>;
+    fn finalize(self, base: Option<SourceLoc>) -> MachBufferFinalized<Final>;
 
     /// Zero a particular register.
     fn zero(&mut self, reg: Reg);
@@ -444,13 +818,69 @@ pub(crate) trait MacroAssembler {
     /// this will emit multiple instructions if the `has_popcnt` flag is false.
     fn popcnt(&mut self, context: &mut CodeGenContext, size: OperandSize);
 
+    /// Converts an i64 to an i32 by discarding the high 32 bits.
+    fn wrap(&mut self, src: Reg, dst: Reg);
+
+    /// Extends an integer of a given size to a larger size.
+    fn extend(&mut self, src: Reg, dst: Reg, kind: ExtendKind);
+
+    /// Emits one or more instructions to perform a signed truncation of a
+    /// float into an integer.
+    fn signed_truncate(
+        &mut self,
+        src: Reg,
+        dst: Reg,
+        src_size: OperandSize,
+        dst_size: OperandSize,
+        kind: TruncKind,
+    );
+
+    /// Emits one or more instructions to perform an unsigned truncation of a
+    /// float into an integer.
+    fn unsigned_truncate(
+        &mut self,
+        src: Reg,
+        dst: Reg,
+        tmp_fpr: Reg,
+        src_size: OperandSize,
+        dst_size: OperandSize,
+        kind: TruncKind,
+    );
+
+    /// Emits one or more instructions to perform a signed convert of an
+    /// integer into a float.
+    fn signed_convert(&mut self, src: Reg, dst: Reg, src_size: OperandSize, dst_size: OperandSize);
+
+    /// Emits one or more instructions to perform an unsigned convert of an
+    /// integer into a float.
+    fn unsigned_convert(
+        &mut self,
+        src: Reg,
+        dst: Reg,
+        tmp_gpr: Reg,
+        src_size: OperandSize,
+        dst_size: OperandSize,
+    );
+
+    /// Reinterpret a float as an integer.
+    fn reinterpret_float_as_int(&mut self, src: Reg, dst: Reg, size: OperandSize);
+
+    /// Reinterpret an integer as a float.
+    fn reinterpret_int_as_float(&mut self, src: Reg, dst: Reg, size: OperandSize);
+
+    /// Demote an f64 to an f32.
+    fn demote(&mut self, src: Reg, dst: Reg);
+
+    /// Promote an f32 to an f64.
+    fn promote(&mut self, src: Reg, dst: Reg);
+
     /// Zero a given memory range.
     ///
     /// The default implementation divides the given memory range
     /// into word-sized slots. Then it unrolls a series of store
     /// instructions, effectively assigning zero to each slot.
     fn zero_mem_range(&mut self, mem: &Range<u32>) {
-        let word_size = <Self::ABI as abi::ABI>::word_bytes();
+        let word_size = <Self::ABI as abi::ABI>::word_bytes() as u32;
         if mem.is_empty() {
             return;
         }
@@ -480,7 +910,7 @@ pub(crate) trait MacroAssembler {
             // Add an upper bound to this generation;
             // given a considerably large amount of slots
             // this will be inefficient.
-            let zero = <Self::ABI as abi::ABI>::scratch_reg();
+            let zero = scratch!(Self);
             self.zero(zero);
             let zero = RegImm::reg(zero);
 
@@ -503,7 +933,14 @@ pub(crate) trait MacroAssembler {
     /// Performs a comparison between the two operands,
     /// and immediately after emits a jump to the given
     /// label destination if the condition is met.
-    fn branch(&mut self, kind: CmpKind, lhs: RegImm, rhs: Reg, taken: MachLabel, size: OperandSize);
+    fn branch(
+        &mut self,
+        kind: IntCmpKind,
+        lhs: Reg,
+        rhs: RegImm,
+        taken: MachLabel,
+        size: OperandSize,
+    );
 
     /// Emits and unconditional jump to the given label.
     fn jmp(&mut self, target: MachLabel);
@@ -515,6 +952,35 @@ pub(crate) trait MacroAssembler {
     /// Emit an unreachable code trap.
     fn unreachable(&mut self);
 
+    /// Emit an unconditional trap.
+    fn trap(&mut self, code: TrapCode);
+
     /// Traps if the condition code is met.
-    fn trapif(&mut self, cc: CmpKind, code: TrapCode);
+    fn trapif(&mut self, cc: IntCmpKind, code: TrapCode);
+
+    /// Trap if the source register is zero.
+    fn trapz(&mut self, src: Reg, code: TrapCode);
+
+    /// Ensures that the stack pointer is correctly positioned before an unconditional
+    /// jump according to the requirements of the destination target.
+    fn ensure_sp_for_jump(&mut self, target: SPOffset) {
+        let bytes = self
+            .sp_offset()
+            .as_u32()
+            .checked_sub(target.as_u32())
+            .unwrap_or(0);
+        if bytes > 0 {
+            self.free_stack(bytes);
+        }
+    }
+
+    /// Mark the start of a source location returning the machine code offset
+    /// and the relative source code location.
+    fn start_source_loc(&mut self, loc: RelSourceLoc) -> (CodeOffset, RelSourceLoc);
+
+    /// Mark the end of a source location.
+    fn end_source_loc(&mut self);
+
+    /// The current offset, in bytes from the beginning of the function.
+    fn current_code_offset(&self) -> CodeOffset;
 }
diff --git a/winch/codegen/src/regalloc.rs b/winch/codegen/src/regalloc.rs
index 2bcb8db3063a..c91a01abcb57 100644
--- a/winch/codegen/src/regalloc.rs
+++ b/winch/codegen/src/regalloc.rs
@@ -12,7 +12,7 @@ use crate::{
 /// If a particular register is not available upon request
 /// the register allocation will perform a "spill", essentially
 /// moving Local and Register values in the stack to memory.
-/// This processs ensures that whenever a register is requested,
+/// This process ensures that whenever a register is requested,
 /// it is going to be available.
 pub(crate) struct RegAlloc {
     /// The register set.
@@ -34,9 +34,9 @@ impl RegAlloc {
     {
         self.regset.reg_for_class(class).unwrap_or_else(|| {
             spill(self);
-            self.regset.reg_for_class(class).unwrap_or_else(|| {
-                panic!("expected register for class {:?}, to be avilable", class)
-            })
+            self.regset
+                .reg_for_class(class)
+                .unwrap_or_else(|| panic!("expected register for class {class:?}, to be available"))
         })
     }
 
@@ -54,7 +54,7 @@ impl RegAlloc {
             spill(self);
             self.regset
                 .reg(named)
-                .expect(&format!("register {:?} to be available", named))
+                .unwrap_or_else(|| panic!("Expected register {named:?} to be available"))
         })
     }
 
diff --git a/winch/codegen/src/regset.rs b/winch/codegen/src/regset.rs
index 0f51dc2babed..0e39d010fad1 100644
--- a/winch/codegen/src/regset.rs
+++ b/winch/codegen/src/regset.rs
@@ -1,6 +1,6 @@
 use crate::isa::reg::{Reg, RegClass};
 
-/// A bit set to track regiter availability.
+/// A bit set to track register availability.
 pub(crate) struct RegSet {
     /// Bitset to track general purpose register availability.
     gpr: RegBitSet,
diff --git a/winch/codegen/src/stack.rs b/winch/codegen/src/stack.rs
index 203eeab01742..4148b73e00c0 100644
--- a/winch/codegen/src/stack.rs
+++ b/winch/codegen/src/stack.rs
@@ -1,8 +1,7 @@
 use crate::{isa::reg::Reg, masm::StackSlot};
-use std::collections::VecDeque;
-use std::ops::RangeBounds;
+use smallvec::SmallVec;
 use wasmparser::{Ieee32, Ieee64};
-use wasmtime_environ::WasmType;
+use wasmtime_environ::WasmValType;
 
 /// A typed register value used to track register values in the value
 /// stack.
@@ -11,19 +10,43 @@ pub struct TypedReg {
     /// The physical register.
     pub reg: Reg,
     /// The type associated to the physical register.
-    pub ty: WasmType,
+    pub ty: WasmValType,
 }
 
 impl TypedReg {
     /// Create a new [`TypedReg`].
-    pub fn new(ty: WasmType, reg: Reg) -> Self {
+    pub fn new(ty: WasmValType, reg: Reg) -> Self {
         Self { ty, reg }
     }
 
     /// Create an i64 [`TypedReg`].
     pub fn i64(reg: Reg) -> Self {
         Self {
-            ty: WasmType::I64,
+            ty: WasmValType::I64,
+            reg,
+        }
+    }
+
+    /// Create an i32 [`TypedReg`].
+    pub fn i32(reg: Reg) -> Self {
+        Self {
+            ty: WasmValType::I32,
+            reg,
+        }
+    }
+
+    /// Create an f64 [`TypedReg`].
+    pub fn f64(reg: Reg) -> Self {
+        Self {
+            ty: WasmValType::F64,
+            reg,
+        }
+    }
+
+    /// Create an f32 [`TypedReg`].
+    pub fn f32(reg: Reg) -> Self {
+        Self {
+            ty: WasmValType::F32,
             reg,
         }
     }
@@ -41,14 +64,14 @@ pub struct Local {
     /// The index of the local.
     pub index: u32,
     /// The type of the local.
-    pub ty: WasmType,
+    pub ty: WasmValType,
 }
 
 /// A memory value.
 #[derive(Debug, Eq, PartialEq, Copy, Clone)]
 pub struct Memory {
     /// The type associated with the memory offset.
-    pub ty: WasmType,
+    pub ty: WasmValType,
     /// The stack slot corresponding to the memory value.
     pub slot: StackSlot,
 }
@@ -64,6 +87,8 @@ pub(crate) enum Val {
     F32(Ieee32),
     /// F64 Constant.
     F64(Ieee64),
+    /// V128 Constant.
+    V128(i128),
     /// A register value.
     Reg(TypedReg),
     /// A local slot.
@@ -117,18 +142,23 @@ impl Val {
         Self::F64(v)
     }
 
+    /// Create a new V128 constant value.
+    pub fn v128(v: i128) -> Self {
+        Self::V128(v)
+    }
+
     /// Create a new Reg value.
-    pub fn reg(reg: Reg, ty: WasmType) -> Self {
+    pub fn reg(reg: Reg, ty: WasmValType) -> Self {
         Self::Reg(TypedReg { reg, ty })
     }
 
     /// Create a new Local value.
-    pub fn local(index: u32, ty: WasmType) -> Self {
+    pub fn local(index: u32, ty: WasmValType) -> Self {
         Self::Local(Local { index, ty })
     }
 
     /// Create a Memory value.
-    pub fn mem(ty: WasmType, slot: StackSlot) -> Self {
+    pub fn mem(ty: WasmValType, slot: StackSlot) -> Self {
         Self::Memory(Memory { ty, slot })
     }
 
@@ -140,7 +170,7 @@ impl Val {
         }
     }
 
-    /// Check wheter the value is a memory offset.
+    /// Check whether the value is a memory offset.
     pub fn is_mem(&self) -> bool {
         match *self {
             Self::Memory(_) => true,
@@ -148,14 +178,30 @@ impl Val {
         }
     }
 
+    /// Check whether the value is a constant.
+    pub fn is_const(&self) -> bool {
+        match *self {
+            Val::I32(_) | Val::I64(_) | Val::F32(_) | Val::F64(_) | Val::V128(_) => true,
+            _ => false,
+        }
+    }
+
+    /// Check whether the value is local with a particular index.
+    pub fn is_local_at_index(&self, index: u32) -> bool {
+        match *self {
+            Self::Local(Local { index: i, .. }) if i == index => true,
+            _ => false,
+        }
+    }
+
     /// Get the register representation of the value.
     ///
     /// # Panics
     /// This method will panic if the value is not a register.
-    pub fn get_reg(&self) -> TypedReg {
+    pub fn unwrap_reg(&self) -> TypedReg {
         match self {
             Self::Reg(tr) => *tr,
-            v => panic!("expected value {:?} to be a register", v),
+            v => panic!("expected value {v:?} to be a register"),
         }
     }
 
@@ -163,10 +209,10 @@ impl Val {
     ///
     /// # Panics
     /// This method will panic if the value is not an i32.
-    pub fn get_i32(&self) -> i32 {
+    pub fn unwrap_i32(&self) -> i32 {
         match self {
             Self::I32(v) => *v,
-            v => panic!("expected value {:?} to be i32", v),
+            v => panic!("expected value {v:?} to be i32"),
         }
     }
 
@@ -174,10 +220,18 @@ impl Val {
     ///
     /// # Panics
     /// This method will panic if the value is not an i64.
-    pub fn get_i64(&self) -> i64 {
+    pub fn unwrap_i64(&self) -> i64 {
         match self {
             Self::I64(v) => *v,
-            v => panic!("expected value {:?} to be i64", v),
+            v => panic!("expected value {v:?} to be i64"),
+        }
+    }
+
+    /// Returns the underlying memory value if it is one, panics otherwise.
+    pub fn unwrap_mem(&self) -> Memory {
+        match self {
+            Self::Memory(m) => *m,
+            v => panic!("expected value {v:?} to be a Memory"),
         }
     }
 
@@ -198,12 +252,13 @@ impl Val {
     }
 
     /// Get the type of the value.
-    pub fn ty(&self) -> WasmType {
+    pub fn ty(&self) -> WasmValType {
         match self {
-            Val::I32(_) => WasmType::I32,
-            Val::I64(_) => WasmType::I64,
-            Val::F32(_) => WasmType::F32,
-            Val::F64(_) => WasmType::F64,
+            Val::I32(_) => WasmValType::I32,
+            Val::I64(_) => WasmValType::I64,
+            Val::F32(_) => WasmValType::F32,
+            Val::F64(_) => WasmValType::F64,
+            Val::V128(_) => WasmValType::V128,
             Val::Reg(r) => r.ty,
             Val::Memory(m) => m.ty,
             Val::Local(l) => l.ty,
@@ -214,7 +269,8 @@ impl Val {
 /// The shadow stack used for compilation.
 #[derive(Default, Debug)]
 pub(crate) struct Stack {
-    inner: VecDeque<Val>,
+    // NB: The 64 is chosen arbitrarily. We can adjust as we see fit.
+    inner: SmallVec<[Val; 64]>,
 }
 
 impl Stack {
@@ -225,9 +281,37 @@ impl Stack {
         }
     }
 
-    /// Insert a new value at the specified index.
-    pub fn insert(&mut self, at: usize, val: Val) {
-        self.inner.insert(at, val);
+    /// Returns true if the stack contains a local with the provided index
+    /// except if the only time the local appears is the top element.
+    pub fn contains_latent_local(&self, index: u32) -> bool {
+        self.inner
+            .iter()
+            // Iterate top-to-bottom so we can skip the top element and stop
+            // when we see a memory element.
+            .rev()
+            // The local is not latent if it's the top element because the top
+            // element will be popped next which materializes the local.
+            .skip(1)
+            // Stop when we see a memory element because that marks where we
+            // spilled up to so there will not be any locals past this point.
+            .take_while(|v| !v.is_mem())
+            .any(|v| v.is_local_at_index(index))
+    }
+
+    /// Extend the stack with the given elements.
+    pub fn extend(&mut self, values: impl IntoIterator<Item = Val>) {
+        self.inner.extend(values);
+    }
+
+    /// Inserts many values at the given index.
+    pub fn insert_many(&mut self, at: usize, values: &[Val]) {
+        debug_assert!(at <= self.len());
+
+        if at == self.len() {
+            self.inner.extend_from_slice(values);
+        } else {
+            self.inner.insert_from_slice(at, values);
+        }
     }
 
     /// Get the length of the stack.
@@ -237,12 +321,12 @@ impl Stack {
 
     /// Push a value to the stack.
     pub fn push(&mut self, val: Val) {
-        self.inner.push_back(val);
+        self.inner.push(val);
     }
 
     /// Peek into the top in the stack.
     pub fn peek(&self) -> Option<&Val> {
-        self.inner.back()
+        self.inner.last()
     }
 
     /// Returns an iterator referencing the last n items of the stack,
@@ -252,19 +336,19 @@ impl Stack {
         assert!(n <= len);
 
         let partition = len - n;
-        self.inner.range(partition..)
+        self.inner[partition..].into_iter()
     }
 
     /// Pops the top element of the stack, if any.
     pub fn pop(&mut self) -> Option<Val> {
-        self.inner.pop_back()
+        self.inner.pop()
     }
 
     /// Pops the element at the top of the stack if it is an i32 const;
     /// returns `None` otherwise.
     pub fn pop_i32_const(&mut self) -> Option<i32> {
         match self.peek() {
-            Some(v) => v.is_i32_const().then(|| self.pop().unwrap().get_i32()),
+            Some(v) => v.is_i32_const().then(|| self.pop().unwrap().unwrap_i32()),
             _ => None,
         }
     }
@@ -273,7 +357,7 @@ impl Stack {
     /// returns `None` otherwise.
     pub fn pop_i64_const(&mut self) -> Option<i64> {
         match self.peek() {
-            Some(v) => v.is_i64_const().then(|| self.pop().unwrap().get_i64()),
+            Some(v) => v.is_i64_const().then(|| self.pop().unwrap().unwrap_i64()),
             _ => None,
         }
     }
@@ -282,7 +366,7 @@ impl Stack {
     /// returns `None` otherwise.
     pub fn pop_reg(&mut self) -> Option<TypedReg> {
         match self.peek() {
-            Some(v) => v.is_reg().then(|| self.pop().unwrap().get_reg()),
+            Some(v) => v.is_reg().then(|| self.pop().unwrap().unwrap_reg()),
             _ => None,
         }
     }
@@ -292,26 +376,31 @@ impl Stack {
     pub fn pop_named_reg(&mut self, reg: Reg) -> Option<TypedReg> {
         match self.peek() {
             Some(v) => {
-                (v.is_reg() && v.get_reg().reg == reg).then(|| self.pop().unwrap().get_reg())
+                (v.is_reg() && v.unwrap_reg().reg == reg).then(|| self.pop().unwrap().unwrap_reg())
             }
             _ => None,
         }
     }
 
     /// Get a mutable reference to the inner stack representation.
-    pub fn inner_mut(&mut self) -> &mut VecDeque<Val> {
+    pub fn inner_mut(&mut self) -> &mut SmallVec<[Val; 64]> {
         &mut self.inner
     }
 
-    /// Calculates size in bytes of memory entries within the specified range of
-    /// the stack.
-    pub fn sizeof<R>(&self, range: R) -> u32
-    where
-        R: RangeBounds<usize>,
-    {
-        self.inner.range(range).fold(0, |acc, v| match v {
-            Val::Memory(m) => acc + m.slot.size,
-            _ => acc,
+    /// Get a reference to the inner stack representation.
+    pub fn inner(&self) -> &SmallVec<[Val; 64]> {
+        &self.inner
+    }
+
+    /// Calculates the size of, in bytes, of the top n [Memory] entries
+    /// in the value stack.
+    pub fn sizeof(&self, top: usize) -> u32 {
+        self.peekn(top).fold(0, |acc, v| {
+            if v.is_mem() {
+                acc + v.unwrap_mem().slot.size
+            } else {
+                acc
+            }
         })
     }
 }
@@ -320,7 +409,7 @@ impl Stack {
 mod tests {
     use super::{Stack, Val};
     use crate::isa::reg::Reg;
-    use wasmtime_environ::WasmType;
+    use wasmtime_environ::WasmValType;
 
     #[test]
     fn test_pop_i32_const() {
@@ -328,7 +417,7 @@ mod tests {
         stack.push(Val::i32(33i32));
         assert_eq!(33, stack.pop_i32_const().unwrap());
 
-        stack.push(Val::local(10, WasmType::I32));
+        stack.push(Val::local(10, WasmValType::I32));
         assert!(stack.pop_i32_const().is_none());
     }
 
@@ -336,7 +425,7 @@ mod tests {
     fn test_pop_reg() {
         let mut stack = Stack::new();
         let reg = Reg::int(2usize);
-        stack.push(Val::reg(reg, WasmType::I32));
+        stack.push(Val::reg(reg, WasmValType::I32));
         stack.push(Val::i32(4));
 
         assert_eq!(None, stack.pop_reg());
@@ -348,8 +437,8 @@ mod tests {
     fn test_pop_named_reg() {
         let mut stack = Stack::new();
         let reg = Reg::int(2usize);
-        stack.push(Val::reg(reg, WasmType::I32));
-        stack.push(Val::reg(Reg::int(4), WasmType::I32));
+        stack.push(Val::reg(reg, WasmValType::I32));
+        stack.push(Val::reg(Reg::int(4), WasmValType::I32));
 
         assert_eq!(None, stack.pop_named_reg(reg));
         let _ = stack.pop().unwrap();
diff --git a/winch/codegen/src/trampoline.rs b/winch/codegen/src/trampoline.rs
deleted file mode 100644
index 96b52de020f2..000000000000
--- a/winch/codegen/src/trampoline.rs
+++ /dev/null
@@ -1,489 +0,0 @@
-//! Trampoline implementation for Winch.
-//!
-//! This module contains all the necessary pieces to emit the various
-//! trampolines required by Wasmtime to call JIT code.
-//
-// TODO
-//
-// * Remove the usage of hardcoded operand sizes (`OperandSize::S64`) when
-// loading/storing the VM context pointer. The real value of the operand size
-// and VM context type should be derived from the ABI's pointer size. This is
-// going to be relevant once 32-bit architectures are supported.
-use crate::{
-    abi::{ABIArg, ABIParams, ABIResult, ABISig, ABI},
-    isa::CallingConvention,
-    masm::{CalleeKind, MacroAssembler, OperandSize, RegImm},
-    reg::Reg,
-};
-use anyhow::{anyhow, Result};
-use smallvec::SmallVec;
-use std::mem;
-use wasmtime_environ::{FuncIndex, PtrSize, WasmFuncType, WasmType};
-
-/// The supported trampoline kinds.
-/// See <https://github.com/bytecodealliance/rfcs/blob/main/accepted/tail-calls.md#new-trampolines-and-vmcallercheckedanyfunc-changes>
-/// for more details.
-pub enum TrampolineKind {
-    /// Calling from native to Wasm, using the array calling convention.
-    ArrayToWasm(FuncIndex),
-    /// Calling from native to Wasm.
-    NativeToWasm(FuncIndex),
-    /// Calling from Wasm to native.
-    WasmToNative,
-}
-
-/// The main trampoline abstraction.
-pub(crate) struct Trampoline<'a, M>
-where
-    M: MacroAssembler,
-{
-    /// The macro assembler.
-    masm: &'a mut M,
-    /// The main scratch register for the current architecture. It is
-    /// not allocatable for the callee.
-    scratch_reg: Reg,
-    /// A second scratch register. This will be allocatable for the
-    /// callee, so it can only be used after the callee-saved
-    /// registers are on the stack.
-    alloc_scratch_reg: Reg,
-    /// Registers to be saved as part of the trampoline's prologue
-    /// and to be restored as part of the trampoline's epilogue.
-    callee_saved_regs: SmallVec<[(Reg, OperandSize); 18]>,
-    /// The calling convention used by the trampoline,
-    /// which is the Wasmtime variant of the system ABI's
-    /// calling convention.
-    call_conv: &'a CallingConvention,
-    /// The pointer size of the current ISA.
-    pointer_size: M::Ptr,
-}
-
-impl<'a, M> Trampoline<'a, M>
-where
-    M: MacroAssembler,
-{
-    /// Create a new trampoline.
-    pub fn new(
-        masm: &'a mut M,
-        scratch_reg: Reg,
-        alloc_scratch_reg: Reg,
-        call_conv: &'a CallingConvention,
-        pointer_size: M::Ptr,
-    ) -> Self {
-        Self {
-            masm,
-            scratch_reg,
-            alloc_scratch_reg,
-            callee_saved_regs: <M::ABI as ABI>::callee_saved_regs(call_conv),
-            call_conv,
-            pointer_size,
-        }
-    }
-
-    /// Emit an array-to-wasm trampoline.
-    pub fn emit_array_to_wasm(&mut self, ty: &WasmFuncType, callee_index: FuncIndex) -> Result<()> {
-        let native_ty = WasmFuncType::new(
-            [WasmType::I64, WasmType::I64, WasmType::I64, WasmType::I64].into(),
-            [].into(),
-        );
-
-        let native_sig = self.native_sig(&native_ty);
-        let wasm_sig = self.wasm_sig(ty);
-
-        let val_ptr = &native_sig.params[2]
-            .get_reg()
-            .map(RegImm::reg)
-            .ok_or_else(|| anyhow!("Expected value pointer to be in a register"))?;
-
-        self.prologue_with_callee_saved();
-
-        // Get the VM context pointer and move it to the designated pinned
-        // register.
-        let (vmctx, caller_vmctx) = Self::callee_and_caller_vmctx(&native_sig.params)?;
-
-        self.masm.mov(
-            vmctx.into(),
-            <M::ABI as ABI>::vmctx_reg().into(),
-            OperandSize::S64,
-        );
-
-        let vmctx_runtime_limits_addr = self.vmctx_runtime_limits_addr(caller_vmctx);
-        let (offsets, spill_size) = self.spill(&native_sig.params);
-
-        let val_ptr_offset = offsets[2];
-
-        // Call the function that was passed into the trampoline.
-        let allocated_stack = self.masm.call(wasm_sig.stack_bytes, |masm| {
-            // Save the SP when entering Wasm.
-            // TODO: Once Winch supports comparison operators,
-            // check that the caller VM context is what we expect.
-            // See [`wasmtime_environ::MAGIC`].
-            Self::save_last_wasm_entry_sp(
-                masm,
-                vmctx_runtime_limits_addr,
-                self.scratch_reg,
-                &self.pointer_size,
-            );
-
-            // Move the values register to the scratch
-            // register for argument assignment.
-            masm.mov(*val_ptr, self.scratch_reg.into(), OperandSize::S64);
-            Self::assign_args_from_array(masm, &wasm_sig, self.scratch_reg, self.alloc_scratch_reg);
-            CalleeKind::Direct(callee_index.as_u32())
-        });
-
-        self.masm.free_stack(allocated_stack);
-
-        // Move the val ptr back into the scratch register so we can
-        // load the return values.
-        self.masm.load(
-            self.masm.address_from_sp(val_ptr_offset),
-            self.scratch_reg,
-            OperandSize::S64,
-        );
-
-        // Move the return values into the value ptr.  We are only
-        // supporting a single return value at this time.
-        match wasm_sig.result {
-            ABIResult::Reg { ty, reg } => self.masm.store(
-                RegImm::reg(reg),
-                self.masm.address_at_reg(self.scratch_reg, 0),
-                ty.into(),
-            ),
-            ABIResult::Void => {}
-        }
-
-        self.epilogue_with_callee_saved_restore(spill_size);
-        Ok(())
-    }
-
-    /// Emit a native-to-wasm trampoline.
-    pub fn emit_native_to_wasm(
-        &mut self,
-        ty: &WasmFuncType,
-        callee_index: FuncIndex,
-    ) -> Result<()> {
-        let native_sig = self.native_sig(&ty);
-        let wasm_sig = self.wasm_sig(&ty);
-        let (vmctx, caller_vmctx) = Self::callee_and_caller_vmctx(&native_sig.params)?;
-
-        self.prologue_with_callee_saved();
-        // Move the VM context pointer to the designated pinned register.
-        self.masm.mov(
-            vmctx.into(),
-            <M::ABI as ABI>::vmctx_reg().into(),
-            OperandSize::S64,
-        );
-
-        let vmctx_runtime_limits_addr = self.vmctx_runtime_limits_addr(caller_vmctx);
-        let (offsets, spill_size) = self.spill(&native_sig.params);
-
-        let reserved_stack = self.masm.call(wasm_sig.stack_bytes, |masm| {
-            // Save the SP when entering Wasm.
-            // TODO: Once Winch supports comparison operators,
-            // check that the caller VM context is what we expect.
-            // See [`wasmtime_environ::MAGIC`].
-            Self::save_last_wasm_entry_sp(
-                masm,
-                vmctx_runtime_limits_addr,
-                self.scratch_reg,
-                &self.pointer_size,
-            );
-            Self::assign_args(
-                masm,
-                &wasm_sig.params,
-                &native_sig.params[2..],
-                &offsets[2..],
-                self.scratch_reg,
-                <M::ABI as ABI>::arg_base_offset().into(),
-            );
-            CalleeKind::Direct(callee_index.as_u32())
-        });
-
-        self.masm.free_stack(reserved_stack);
-        self.epilogue_with_callee_saved_restore(spill_size);
-
-        Ok(())
-    }
-
-    /// Emit a wasm-to-native trampoline.
-    pub fn emit_wasm_to_native(&mut self, ty: &WasmFuncType) -> Result<()> {
-        let mut params = Self::callee_and_caller_vmctx_types();
-        params.extend_from_slice(ty.params());
-
-        let func_ty = WasmFuncType::new(params.into(), ty.returns().into());
-        let wasm_sig = self.wasm_sig(&func_ty);
-        let native_sig = self.native_sig(ty);
-
-        let (vmctx, caller_vmctx) = Self::callee_and_caller_vmctx(&wasm_sig.params).unwrap();
-        let vmctx_runtime_limits_addr = self.vmctx_runtime_limits_addr(caller_vmctx);
-
-        self.prologue();
-
-        // Save the FP and return address when exiting Wasm.
-        // TODO: Once Winch supports comparison operators,
-        // check that the caller VM context is what we expect.
-        // See [`wasmtime_environ::MAGIC`].
-        Self::save_last_wasm_exit_fp_and_pc(
-            self.masm,
-            vmctx_runtime_limits_addr,
-            self.scratch_reg,
-            self.alloc_scratch_reg,
-            &self.pointer_size,
-        );
-
-        let (offsets, spill_size) = self.spill(&wasm_sig.params);
-
-        let reserved_stack = self.masm.call(native_sig.stack_bytes, |masm| {
-            // Move the VM context into one of the scratch registers.
-            masm.mov(
-                vmctx.into(),
-                self.alloc_scratch_reg.into(),
-                OperandSize::S64,
-            );
-
-            Self::assign_args(
-                masm,
-                &native_sig.params,
-                &wasm_sig.params,
-                &offsets,
-                self.scratch_reg,
-                <M::ABI as ABI>::arg_base_offset().into(),
-            );
-
-            let body_offset = self.pointer_size.vmnative_call_host_func_context_func_ref()
-                + self.pointer_size.vm_func_ref_native_call();
-            let callee_addr = masm.address_at_reg(self.alloc_scratch_reg, body_offset.into());
-            masm.load(callee_addr, self.scratch_reg, OperandSize::S64);
-
-            CalleeKind::Indirect(self.scratch_reg)
-        });
-
-        self.masm.free_stack(reserved_stack);
-        self.epilogue(spill_size);
-
-        Ok(())
-    }
-
-    /// Perfom argument assignment, translating between
-    /// caller and callee calling conventions.
-    fn assign_args(
-        masm: &mut M,
-        callee_params: &[ABIArg],
-        caller_params: &[ABIArg],
-        caller_stack_offsets: &[u32],
-        scratch: Reg,
-        arg_base_offset: u32,
-    ) {
-        assert!(callee_params.len() == caller_params.len());
-        let fp = <M::ABI as ABI>::fp_reg();
-        let mut offset_index = 0;
-
-        callee_params
-            .iter()
-            .zip(caller_params)
-            .for_each(
-                |(callee_param, caller_param)| match (callee_param, caller_param) {
-                    (ABIArg::Reg { ty, reg: dst }, ABIArg::Reg { .. }) => {
-                        let offset = caller_stack_offsets[offset_index];
-                        let addr = masm.address_from_sp(offset);
-                        masm.load(addr, *dst, (*ty).into());
-                        offset_index += 1;
-                    }
-
-                    (ABIArg::Stack { ty, offset }, ABIArg::Reg { .. }) => {
-                        let spill_offset = caller_stack_offsets[offset_index];
-                        let addr = masm.address_from_sp(spill_offset);
-                        masm.load(addr, scratch, (*ty).into());
-
-                        let arg_addr = masm.address_at_sp(*offset);
-                        masm.store(scratch.into(), arg_addr, (*ty).into());
-                        offset_index += 1;
-                    }
-
-                    (ABIArg::Reg { ty, reg: dst }, ABIArg::Stack { ty: _, offset }) => {
-                        let addr = masm.address_at_reg(fp, arg_base_offset + offset);
-                        masm.load(addr, *dst, (*ty).into());
-                    }
-
-                    (
-                        ABIArg::Stack {
-                            ty,
-                            offset: callee_offset,
-                        },
-                        ABIArg::Stack {
-                            offset: caller_offset,
-                            ..
-                        },
-                    ) => {
-                        let addr = masm.address_at_reg(fp, arg_base_offset + caller_offset);
-                        masm.load(addr, scratch, (*ty).into());
-
-                        let arg_addr = masm.address_at_sp(*callee_offset);
-                        masm.store(scratch.into(), arg_addr, (*ty).into());
-                    }
-                },
-            )
-    }
-
-    /// Get the type of the caller and callee VM contexts.
-    fn callee_and_caller_vmctx_types() -> Vec<WasmType> {
-        vec![WasmType::I64, WasmType::I64]
-    }
-
-    /// Returns a signature using the system's calling convention.
-    fn native_sig(&self, ty: &WasmFuncType) -> ABISig {
-        let mut params = Self::callee_and_caller_vmctx_types();
-        params.extend_from_slice(ty.params());
-        let native_type = WasmFuncType::new(params.into(), ty.returns().into());
-
-        <M::ABI as ABI>::sig(&native_type, self.call_conv)
-    }
-
-    /// Returns a signature using the Winch's default calling convention.
-    fn wasm_sig(&self, ty: &WasmFuncType) -> ABISig {
-        <M::ABI as ABI>::sig(ty, &CallingConvention::Default)
-    }
-
-    /// Returns the register pair containing the callee and caller VM context pointers.
-    fn callee_and_caller_vmctx(params: &ABIParams) -> Result<(Reg, Reg)> {
-        let vmctx = params[0]
-            .get_reg()
-            .ok_or_else(|| anyhow!("Expected vm context pointer to be in a register"))?;
-
-        let caller_vmctx = params[1]
-            .get_reg()
-            .ok_or_else(|| anyhow!("Expected caller vm context pointer to be in a register"))?;
-
-        Ok((vmctx, caller_vmctx))
-    }
-
-    /// Returns the address of the VM context runtime limits
-    /// field.
-    fn vmctx_runtime_limits_addr(&mut self, caller_vmctx: Reg) -> M::Address {
-        self.masm.address_at_reg(
-            caller_vmctx,
-            self.pointer_size.vmcontext_runtime_limits().into(),
-        )
-    }
-
-    /// Performs a spill of the register params.
-    fn spill(&mut self, params: &ABIParams) -> (SmallVec<[u32; 6]>, u32) {
-        let mut offsets = SmallVec::new();
-        let mut spill_size = 0;
-        params.iter().for_each(|param| {
-            if let Some(reg) = param.get_reg() {
-                let slot = self.masm.push(reg, param.ty().into());
-                offsets.push(slot.offset);
-                spill_size += slot.size;
-            }
-        });
-
-        (offsets, spill_size)
-    }
-
-    /// Assigns arguments for the callee, loading them from a register.
-    fn assign_args_from_array(masm: &mut M, callee_sig: &ABISig, values_reg: Reg, scratch: Reg) {
-        // The max size a value can be when reading from the params
-        // memory location.
-        let value_size = mem::size_of::<u128>();
-        callee_sig.params.iter().enumerate().for_each(|(i, param)| {
-            let value_offset = (i * value_size) as u32;
-
-            match param {
-                ABIArg::Reg { reg, ty } => masm.load(
-                    masm.address_at_reg(values_reg, value_offset),
-                    *reg,
-                    (*ty).into(),
-                ),
-                ABIArg::Stack { offset, ty } => {
-                    masm.load(
-                        masm.address_at_reg(values_reg, value_offset),
-                        scratch,
-                        (*ty).into(),
-                    );
-                    masm.store(
-                        RegImm::reg(scratch),
-                        masm.address_at_sp(*offset),
-                        (*ty).into(),
-                    );
-                }
-            }
-        });
-    }
-
-    fn save_last_wasm_entry_sp(
-        masm: &mut M,
-        vm_runtime_limits_addr: M::Address,
-        scratch: Reg,
-        ptr: &impl PtrSize,
-    ) {
-        let sp = <M::ABI as ABI>::sp_reg();
-        masm.load(vm_runtime_limits_addr, scratch, OperandSize::S64);
-        let addr = masm.address_at_reg(scratch, ptr.vmruntime_limits_last_wasm_entry_sp().into());
-        masm.store(sp.into(), addr, OperandSize::S64);
-    }
-
-    fn save_last_wasm_exit_fp_and_pc(
-        masm: &mut M,
-        vm_runtime_limits_addr: M::Address,
-        scratch: Reg,
-        alloc_scratch: Reg,
-        ptr: &impl PtrSize,
-    ) {
-        masm.load(vm_runtime_limits_addr, alloc_scratch, OperandSize::S64);
-        let last_wasm_exit_fp_addr = masm.address_at_reg(
-            alloc_scratch,
-            ptr.vmruntime_limits_last_wasm_exit_fp().into(),
-        );
-        let last_wasm_exit_pc_addr = masm.address_at_reg(
-            alloc_scratch,
-            ptr.vmruntime_limits_last_wasm_exit_pc().into(),
-        );
-
-        // Handle the frame pointer.
-        let fp = <M::ABI as ABI>::fp_reg();
-        let fp_addr = masm.address_at_reg(fp, 0);
-        masm.load(fp_addr, scratch, OperandSize::S64);
-        masm.store(scratch.into(), last_wasm_exit_fp_addr, OperandSize::S64);
-
-        // Handle the return address.
-        let ret_addr_offset = <M::ABI as ABI>::ret_addr_offset();
-        let ret_addr = masm.address_at_reg(fp, ret_addr_offset.into());
-        masm.load(ret_addr, scratch, OperandSize::S64);
-        masm.store(scratch.into(), last_wasm_exit_pc_addr, OperandSize::S64);
-    }
-
-    /// The trampoline's prologue.
-    fn prologue(&mut self) {
-        self.masm.prologue();
-    }
-
-    /// Similar to [Trampoline::prologue], but saves
-    /// callee-saved registers.
-    fn prologue_with_callee_saved(&mut self) {
-        self.masm.prologue();
-        // Save any callee-saved registers.
-        for (r, s) in &self.callee_saved_regs {
-            self.masm.push(*r, *s);
-        }
-    }
-
-    /// Similar to [Trampoline::epilogue], but restores
-    /// callee-saved registers.
-    fn epilogue_with_callee_saved_restore(&mut self, arg_size: u32) {
-        // Free the stack space allocated by pushing the trampoline arguments.
-        self.masm.free_stack(arg_size);
-        // Restore the callee-saved registers.
-        for (r, s) in self.callee_saved_regs.iter().rev() {
-            self.masm.pop(*r, *s);
-        }
-        self.masm.epilogue(0);
-    }
-
-    /// The trampoline's epilogue.
-    fn epilogue(&mut self, arg_size: u32) {
-        // Free the stack space allocated by pushing the trampoline arguments.
-        self.masm.free_stack(arg_size);
-        self.masm.epilogue(0);
-    }
-}
diff --git a/winch/codegen/src/visitor.rs b/winch/codegen/src/visitor.rs
index fc96b7d00d72..e313300af127 100644
--- a/winch/codegen/src/visitor.rs
+++ b/winch/codegen/src/visitor.rs
@@ -4,17 +4,21 @@
 //! which validates and dispatches to the corresponding
 //! machine code emitter.
 
-use crate::abi::ABI;
-use crate::codegen::{control_index, CodeGen, ControlStackFrame, FnCall};
+use crate::abi::RetArea;
+use crate::codegen::{control_index, Callee, CodeGen, ControlStackFrame, FnCall};
 use crate::masm::{
-    CmpKind, DivKind, MacroAssembler, OperandSize, RegImm, RemKind, RoundingMode, ShiftKind,
+    DivKind, ExtendKind, FloatCmpKind, IntCmpKind, MacroAssembler, MemMoveDirection, OperandSize,
+    RegImm, RemKind, RoundingMode, SPOffset, ShiftKind, TruncKind,
 };
+use crate::reg::Reg;
 use crate::stack::{TypedReg, Val};
+use cranelift_codegen::ir::TrapCode;
+use regalloc2::RegClass;
 use smallvec::SmallVec;
-use wasmparser::BrTable;
-use wasmparser::{BlockType, Ieee32, Ieee64, VisitOperator};
+use wasmparser::{BlockType, BrTable, Ieee32, Ieee64, MemArg, VisitOperator, V128};
 use wasmtime_environ::{
-    FuncIndex, GlobalIndex, TableIndex, TableStyle, TypeIndex, WasmType, FUNCREF_MASK,
+    FuncIndex, GlobalIndex, MemoryIndex, TableIndex, TableStyle, TypeIndex, WasmHeapType,
+    WasmValType, FUNCREF_INIT_BIT,
 };
 
 /// A macro to define unsupported WebAssembly operators.
@@ -22,7 +26,7 @@ use wasmtime_environ::{
 /// This macro calls itself recursively;
 /// 1. It no-ops when matching a supported operator.
 /// 2. Defines the visitor function and panics when
-/// matching an unsupported operator.
+///    matching an unsupported operator.
 macro_rules! def_unsupported {
     ($( @$proposal:ident $op:ident $({ $($arg:ident: $argty:ty),* })? => $visit:ident)*) => {
         $(
@@ -32,7 +36,8 @@ macro_rules! def_unsupported {
 
                 fn $visit(&mut self $($(,$arg: $argty)*)?) -> Self::Output {
                     $($(let _ = $arg;)*)?
-                        todo!(stringify!($op))
+
+                    self.found_unsupported_instruction = Some(stringify!($op));
                 }
             );
         )*
@@ -42,6 +47,21 @@ macro_rules! def_unsupported {
     (emit I64Const $($rest:tt)*) => {};
     (emit F32Const $($rest:tt)*) => {};
     (emit F64Const $($rest:tt)*) => {};
+    (emit V128Const $($rest:tt)*) => {};
+    (emit F32Add $($rest:tt)*) => {};
+    (emit F64Add $($rest:tt)*) => {};
+    (emit F32Sub $($rest:tt)*) => {};
+    (emit F64Sub $($rest:tt)*) => {};
+    (emit F32Mul $($rest:tt)*) => {};
+    (emit F64Mul $($rest:tt)*) => {};
+    (emit F32Div $($rest:tt)*) => {};
+    (emit F64Div $($rest:tt)*) => {};
+    (emit F32Min $($rest:tt)*) => {};
+    (emit F64Min $($rest:tt)*) => {};
+    (emit F32Max $($rest:tt)*) => {};
+    (emit F64Max $($rest:tt)*) => {};
+    (emit F32Copysign $($rest:tt)*) => {};
+    (emit F64Copysign $($rest:tt)*) => {};
     (emit F32Abs $($rest:tt)*) => {};
     (emit F64Abs $($rest:tt)*) => {};
     (emit F32Neg $($rest:tt)*) => {};
@@ -54,6 +74,32 @@ macro_rules! def_unsupported {
     (emit F64Nearest $($rest:tt)*) => {};
     (emit F32Trunc $($rest:tt)*) => {};
     (emit F64Trunc $($rest:tt)*) => {};
+    (emit F32Sqrt $($rest:tt)*) => {};
+    (emit F64Sqrt $($rest:tt)*) => {};
+    (emit F32Eq $($rest:tt)*) => {};
+    (emit F64Eq $($rest:tt)*) => {};
+    (emit F32Ne $($rest:tt)*) => {};
+    (emit F64Ne $($rest:tt)*) => {};
+    (emit F32Lt $($rest:tt)*) => {};
+    (emit F64Lt $($rest:tt)*) => {};
+    (emit F32Gt $($rest:tt)*) => {};
+    (emit F64Gt $($rest:tt)*) => {};
+    (emit F32Le $($rest:tt)*) => {};
+    (emit F64Le $($rest:tt)*) => {};
+    (emit F32Ge $($rest:tt)*) => {};
+    (emit F64Ge $($rest:tt)*) => {};
+    (emit F32ConvertI32S $($rest:tt)*) => {};
+    (emit F32ConvertI32U $($rest:tt)*) => {};
+    (emit F32ConvertI64S $($rest:tt)*) => {};
+    (emit F32ConvertI64U $($rest:tt)*) => {};
+    (emit F64ConvertI32S $($rest:tt)*) => {};
+    (emit F64ConvertI32U $($rest:tt)*) => {};
+    (emit F64ConvertI64S $($rest:tt)*) => {};
+    (emit F64ConvertI64U $($rest:tt)*) => {};
+    (emit F32ReinterpretI32 $($rest:tt)*) => {};
+    (emit F64ReinterpretI64 $($rest:tt)*) => {};
+    (emit F32DemoteF64 $($rest:tt)*) => {};
+    (emit F64PromoteF32 $($rest:tt)*) => {};
     (emit I32Add $($rest:tt)*) => {};
     (emit I64Add $($rest:tt)*) => {};
     (emit I32Sub $($rest:tt)*) => {};
@@ -112,6 +158,24 @@ macro_rules! def_unsupported {
     (emit I64Ctz $($rest:tt)*) => {};
     (emit I32Popcnt $($rest:tt)*) => {};
     (emit I64Popcnt $($rest:tt)*) => {};
+    (emit I32WrapI64 $($rest:tt)*) => {};
+    (emit I64ExtendI32S $($rest:tt)*) => {};
+    (emit I64ExtendI32U $($rest:tt)*) => {};
+    (emit I32Extend8S $($rest:tt)*) => {};
+    (emit I32Extend16S $($rest:tt)*) => {};
+    (emit I64Extend8S $($rest:tt)*) => {};
+    (emit I64Extend16S $($rest:tt)*) => {};
+    (emit I64Extend32S $($rest:tt)*) => {};
+    (emit I32TruncF32S $($rest:tt)*) => {};
+    (emit I32TruncF32U $($rest:tt)*) => {};
+    (emit I32TruncF64S $($rest:tt)*) => {};
+    (emit I32TruncF64U $($rest:tt)*) => {};
+    (emit I64TruncF32S $($rest:tt)*) => {};
+    (emit I64TruncF32U $($rest:tt)*) => {};
+    (emit I64TruncF64S $($rest:tt)*) => {};
+    (emit I64TruncF64U $($rest:tt)*) => {};
+    (emit I32ReinterpretF32 $($rest:tt)*) => {};
+    (emit I64ReinterpretF64 $($rest:tt)*) => {};
     (emit LocalGet $($rest:tt)*) => {};
     (emit LocalSet $($rest:tt)*) => {};
     (emit Call $($rest:tt)*) => {};
@@ -132,12 +196,59 @@ macro_rules! def_unsupported {
     (emit Drop $($rest:tt)*) => {};
     (emit BrTable $($rest:tt)*) => {};
     (emit CallIndirect $($rest:tt)*) => {};
-
+    (emit TableInit $($rest:tt)*) => {};
+    (emit TableCopy $($rest:tt)*) => {};
+    (emit TableGet $($rest:tt)*) => {};
+    (emit TableSet $($rest:tt)*) => {};
+    (emit TableGrow $($rest:tt)*) => {};
+    (emit TableSize $($rest:tt)*) => {};
+    (emit TableFill $($rest:tt)*) => {};
+    (emit ElemDrop $($rest:tt)*) => {};
+    (emit MemoryInit $($rest:tt)*) => {};
+    (emit MemoryCopy $($rest:tt)*) => {};
+    (emit DataDrop $($rest:tt)*) => {};
+    (emit MemoryFill $($rest:tt)*) => {};
+    (emit MemorySize $($rest:tt)*) => {};
+    (emit MemoryGrow $($rest:tt)*) => {};
+    (emit I32Load $($rest:tt)*) => {};
+    (emit I32Load8S $($rest:tt)*) => {};
+    (emit I32Load8U $($rest:tt)*) => {};
+    (emit I32Load16S $($rest:tt)*) => {};
+    (emit I32Load16U $($rest:tt)*) => {};
+    (emit I64Load8S $($rest:tt)*) => {};
+    (emit I64Load8U $($rest:tt)*) => {};
+    (emit I64Load16S $($rest:tt)*) => {};
+    (emit I64Load16U $($rest:tt)*) => {};
+    (emit I64Load32S $($rest:tt)*) => {};
+    (emit I64Load32U $($rest:tt)*) => {};
+    (emit I64Load $($rest:tt)*) => {};
+    (emit I32Store $($rest:tt)*) => {};
+    (emit I32Store $($rest:tt)*) => {};
+    (emit I32Store8 $($rest:tt)*) => {};
+    (emit I32Store16 $($rest:tt)*) => {};
+    (emit I64Store $($rest:tt)*) => {};
+    (emit I64Store8 $($rest:tt)*) => {};
+    (emit I64Store16 $($rest:tt)*) => {};
+    (emit I64Store32 $($rest:tt)*) => {};
+    (emit F32Load $($rest:tt)*) => {};
+    (emit F32Store $($rest:tt)*) => {};
+    (emit F64Load $($rest:tt)*) => {};
+    (emit F64Store $($rest:tt)*) => {};
+    (emit I32TruncSatF32S $($rest:tt)*) => {};
+    (emit I32TruncSatF32U $($rest:tt)*) => {};
+    (emit I32TruncSatF64S $($rest:tt)*) => {};
+    (emit I32TruncSatF64U $($rest:tt)*) => {};
+    (emit I64TruncSatF32S $($rest:tt)*) => {};
+    (emit I64TruncSatF32U $($rest:tt)*) => {};
+    (emit I64TruncSatF64S $($rest:tt)*) => {};
+    (emit I64TruncSatF64U $($rest:tt)*) => {};
+    (emit V128Load $($rest:tt)*) => {};
+    (emit V128Store $($rest:tt)*) => {};
 
     (emit $unsupported:tt $($rest:tt)*) => {$($rest)*};
 }
 
-impl<'a, M> VisitOperator<'a> for CodeGen<'a, M>
+impl<'a, 'translation, 'data, M> VisitOperator<'a> for CodeGen<'a, 'translation, 'data, M>
 where
     M: MacroAssembler,
 {
@@ -159,10 +270,169 @@ where
         self.context.stack.push(Val::f64(val));
     }
 
+    fn visit_v128_const(&mut self, val: V128) {
+        self.context.stack.push(Val::v128(val.i128()))
+    }
+
+    fn visit_f32_add(&mut self) {
+        self.context.binop(
+            self.masm,
+            OperandSize::S32,
+            &mut |masm: &mut M, dst, src, size| {
+                masm.float_add(dst, dst, src, size);
+                TypedReg::f32(dst)
+            },
+        );
+    }
+
+    fn visit_f64_add(&mut self) {
+        self.context.binop(
+            self.masm,
+            OperandSize::S64,
+            &mut |masm: &mut M, dst, src, size| {
+                masm.float_add(dst, dst, src, size);
+                TypedReg::f64(dst)
+            },
+        );
+    }
+
+    fn visit_f32_sub(&mut self) {
+        self.context.binop(
+            self.masm,
+            OperandSize::S32,
+            &mut |masm: &mut M, dst, src, size| {
+                masm.float_sub(dst, dst, src, size);
+                TypedReg::f32(dst)
+            },
+        );
+    }
+
+    fn visit_f64_sub(&mut self) {
+        self.context.binop(
+            self.masm,
+            OperandSize::S64,
+            &mut |masm: &mut M, dst, src, size| {
+                masm.float_sub(dst, dst, src, size);
+                TypedReg::f64(dst)
+            },
+        );
+    }
+
+    fn visit_f32_mul(&mut self) {
+        self.context.binop(
+            self.masm,
+            OperandSize::S32,
+            &mut |masm: &mut M, dst, src, size| {
+                masm.float_mul(dst, dst, src, size);
+                TypedReg::f32(dst)
+            },
+        );
+    }
+
+    fn visit_f64_mul(&mut self) {
+        self.context.binop(
+            self.masm,
+            OperandSize::S64,
+            &mut |masm: &mut M, dst, src, size| {
+                masm.float_mul(dst, dst, src, size);
+                TypedReg::f64(dst)
+            },
+        );
+    }
+
+    fn visit_f32_div(&mut self) {
+        self.context.binop(
+            self.masm,
+            OperandSize::S32,
+            &mut |masm: &mut M, dst, src, size| {
+                masm.float_div(dst, dst, src, size);
+                TypedReg::f32(dst)
+            },
+        );
+    }
+
+    fn visit_f64_div(&mut self) {
+        self.context.binop(
+            self.masm,
+            OperandSize::S64,
+            &mut |masm: &mut M, dst, src, size| {
+                masm.float_div(dst, dst, src, size);
+                TypedReg::f64(dst)
+            },
+        );
+    }
+
+    fn visit_f32_min(&mut self) {
+        self.context.binop(
+            self.masm,
+            OperandSize::S32,
+            &mut |masm: &mut M, dst, src, size| {
+                masm.float_min(dst, dst, src, size);
+                TypedReg::f32(dst)
+            },
+        );
+    }
+
+    fn visit_f64_min(&mut self) {
+        self.context.binop(
+            self.masm,
+            OperandSize::S64,
+            &mut |masm: &mut M, dst, src, size| {
+                masm.float_min(dst, dst, src, size);
+                TypedReg::f64(dst)
+            },
+        );
+    }
+
+    fn visit_f32_max(&mut self) {
+        self.context.binop(
+            self.masm,
+            OperandSize::S32,
+            &mut |masm: &mut M, dst, src, size| {
+                masm.float_max(dst, dst, src, size);
+                TypedReg::f32(dst)
+            },
+        );
+    }
+
+    fn visit_f64_max(&mut self) {
+        self.context.binop(
+            self.masm,
+            OperandSize::S64,
+            &mut |masm: &mut M, dst, src, size| {
+                masm.float_max(dst, dst, src, size);
+                TypedReg::f64(dst)
+            },
+        );
+    }
+
+    fn visit_f32_copysign(&mut self) {
+        self.context.binop(
+            self.masm,
+            OperandSize::S32,
+            &mut |masm: &mut M, dst, src, size| {
+                masm.float_copysign(dst, dst, src, size);
+                TypedReg::f32(dst)
+            },
+        );
+    }
+
+    fn visit_f64_copysign(&mut self) {
+        self.context.binop(
+            self.masm,
+            OperandSize::S64,
+            &mut |masm: &mut M, dst, src, size| {
+                masm.float_copysign(dst, dst, src, size);
+                TypedReg::f64(dst)
+            },
+        );
+    }
+
     fn visit_f32_abs(&mut self) {
         self.context
             .unop(self.masm, OperandSize::S32, &mut |masm, reg, size| {
                 masm.float_abs(reg, size);
+                TypedReg::f32(reg)
             });
     }
 
@@ -170,6 +440,7 @@ where
         self.context
             .unop(self.masm, OperandSize::S64, &mut |masm, reg, size| {
                 masm.float_abs(reg, size);
+                TypedReg::f64(reg)
             });
     }
 
@@ -177,6 +448,7 @@ where
         self.context
             .unop(self.masm, OperandSize::S32, &mut |masm, reg, size| {
                 masm.float_neg(reg, size);
+                TypedReg::f32(reg)
             });
     }
 
@@ -184,98 +456,391 @@ where
         self.context
             .unop(self.masm, OperandSize::S64, &mut |masm, reg, size| {
                 masm.float_neg(reg, size);
+                TypedReg::f64(reg)
             });
     }
 
     fn visit_f32_floor(&mut self) {
+        self.masm.float_round(
+            RoundingMode::Down,
+            &mut self.env,
+            &mut self.context,
+            OperandSize::S32,
+            |env, cx, masm| {
+                let builtin = env.builtins.floor_f32::<M::ABI>();
+                FnCall::emit::<M>(env, masm, cx, Callee::Builtin(builtin));
+            },
+        );
+    }
+
+    fn visit_f64_floor(&mut self) {
+        self.masm.float_round(
+            RoundingMode::Down,
+            &mut self.env,
+            &mut self.context,
+            OperandSize::S64,
+            |env, cx, masm| {
+                let builtin = env.builtins.floor_f64::<M::ABI>();
+                FnCall::emit::<M>(env, masm, cx, Callee::Builtin(builtin));
+            },
+        );
+    }
+
+    fn visit_f32_ceil(&mut self) {
+        self.masm.float_round(
+            RoundingMode::Up,
+            &mut self.env,
+            &mut self.context,
+            OperandSize::S32,
+            |env, cx, masm| {
+                let builtin = env.builtins.ceil_f32::<M::ABI>();
+                FnCall::emit::<M>(env, masm, cx, Callee::Builtin(builtin));
+            },
+        );
+    }
+
+    fn visit_f64_ceil(&mut self) {
+        self.masm.float_round(
+            RoundingMode::Up,
+            &mut self.env,
+            &mut self.context,
+            OperandSize::S64,
+            |env, cx, masm| {
+                let builtin = env.builtins.ceil_f64::<M::ABI>();
+                FnCall::emit::<M>(env, masm, cx, Callee::Builtin(builtin));
+            },
+        );
+    }
+
+    fn visit_f32_nearest(&mut self) {
+        self.masm.float_round(
+            RoundingMode::Nearest,
+            &mut self.env,
+            &mut self.context,
+            OperandSize::S32,
+            |env, cx, masm| {
+                let builtin = env.builtins.nearest_f32::<M::ABI>();
+                FnCall::emit::<M>(env, masm, cx, Callee::Builtin(builtin))
+            },
+        );
+    }
+
+    fn visit_f64_nearest(&mut self) {
+        self.masm.float_round(
+            RoundingMode::Nearest,
+            &mut self.env,
+            &mut self.context,
+            OperandSize::S64,
+            |env, cx, masm| {
+                let builtin = env.builtins.nearest_f64::<M::ABI>();
+                FnCall::emit::<M>(env, masm, cx, Callee::Builtin(builtin));
+            },
+        );
+    }
+
+    fn visit_f32_trunc(&mut self) {
+        self.masm.float_round(
+            RoundingMode::Zero,
+            &mut self.env,
+            &mut self.context,
+            OperandSize::S32,
+            |env, cx, masm| {
+                let builtin = env.builtins.trunc_f32::<M::ABI>();
+                FnCall::emit::<M>(env, masm, cx, Callee::Builtin(builtin));
+            },
+        );
+    }
+
+    fn visit_f64_trunc(&mut self) {
+        self.masm.float_round(
+            RoundingMode::Zero,
+            &mut self.env,
+            &mut self.context,
+            OperandSize::S64,
+            |env, cx, masm| {
+                let builtin = env.builtins.trunc_f64::<M::ABI>();
+                FnCall::emit::<M>(env, masm, cx, Callee::Builtin(builtin));
+            },
+        );
+    }
+
+    fn visit_f32_sqrt(&mut self) {
         self.context
             .unop(self.masm, OperandSize::S32, &mut |masm, reg, size| {
-                masm.float_round(RoundingMode::Down, reg, RegImm::Reg(reg), size);
+                masm.float_sqrt(reg, reg, size);
+                TypedReg::f32(reg)
             });
     }
 
-    fn visit_f64_floor(&mut self) {
+    fn visit_f64_sqrt(&mut self) {
         self.context
             .unop(self.masm, OperandSize::S64, &mut |masm, reg, size| {
-                masm.float_round(RoundingMode::Down, reg, RegImm::Reg(reg), size);
+                masm.float_sqrt(reg, reg, size);
+                TypedReg::f64(reg)
             });
     }
 
-    fn visit_f32_ceil(&mut self) {
+    fn visit_f32_eq(&mut self) {
+        self.context.float_cmp_op(
+            self.masm,
+            OperandSize::S32,
+            &mut |masm: &mut M, dst, src1, src2, size| {
+                masm.float_cmp_with_set(src1, src2, dst, FloatCmpKind::Eq, size);
+            },
+        );
+    }
+
+    fn visit_f64_eq(&mut self) {
+        self.context.float_cmp_op(
+            self.masm,
+            OperandSize::S64,
+            &mut |masm: &mut M, dst, src1, src2, size| {
+                masm.float_cmp_with_set(src1, src2, dst, FloatCmpKind::Eq, size);
+            },
+        );
+    }
+
+    fn visit_f32_ne(&mut self) {
+        self.context.float_cmp_op(
+            self.masm,
+            OperandSize::S32,
+            &mut |masm: &mut M, dst, src1, src2, size| {
+                masm.float_cmp_with_set(src1, src2, dst, FloatCmpKind::Ne, size);
+            },
+        );
+    }
+
+    fn visit_f64_ne(&mut self) {
+        self.context.float_cmp_op(
+            self.masm,
+            OperandSize::S64,
+            &mut |masm: &mut M, dst, src1, src2, size| {
+                masm.float_cmp_with_set(src1, src2, dst, FloatCmpKind::Ne, size);
+            },
+        );
+    }
+
+    fn visit_f32_lt(&mut self) {
+        self.context.float_cmp_op(
+            self.masm,
+            OperandSize::S32,
+            &mut |masm: &mut M, dst, src1, src2, size| {
+                masm.float_cmp_with_set(src1, src2, dst, FloatCmpKind::Lt, size);
+            },
+        );
+    }
+
+    fn visit_f64_lt(&mut self) {
+        self.context.float_cmp_op(
+            self.masm,
+            OperandSize::S64,
+            &mut |masm: &mut M, dst, src1, src2, size| {
+                masm.float_cmp_with_set(src1, src2, dst, FloatCmpKind::Lt, size);
+            },
+        );
+    }
+
+    fn visit_f32_gt(&mut self) {
+        self.context.float_cmp_op(
+            self.masm,
+            OperandSize::S32,
+            &mut |masm: &mut M, dst, src1, src2, size| {
+                masm.float_cmp_with_set(src1, src2, dst, FloatCmpKind::Gt, size);
+            },
+        );
+    }
+
+    fn visit_f64_gt(&mut self) {
+        self.context.float_cmp_op(
+            self.masm,
+            OperandSize::S64,
+            &mut |masm: &mut M, dst, src1, src2, size| {
+                masm.float_cmp_with_set(src1, src2, dst, FloatCmpKind::Gt, size);
+            },
+        );
+    }
+
+    fn visit_f32_le(&mut self) {
+        self.context.float_cmp_op(
+            self.masm,
+            OperandSize::S32,
+            &mut |masm: &mut M, dst, src1, src2, size| {
+                masm.float_cmp_with_set(src1, src2, dst, FloatCmpKind::Le, size);
+            },
+        );
+    }
+
+    fn visit_f64_le(&mut self) {
+        self.context.float_cmp_op(
+            self.masm,
+            OperandSize::S64,
+            &mut |masm: &mut M, dst, src1, src2, size| {
+                masm.float_cmp_with_set(src1, src2, dst, FloatCmpKind::Le, size);
+            },
+        );
+    }
+
+    fn visit_f32_ge(&mut self) {
+        self.context.float_cmp_op(
+            self.masm,
+            OperandSize::S32,
+            &mut |masm: &mut M, dst, src1, src2, size| {
+                masm.float_cmp_with_set(src1, src2, dst, FloatCmpKind::Ge, size);
+            },
+        );
+    }
+
+    fn visit_f64_ge(&mut self) {
+        self.context.float_cmp_op(
+            self.masm,
+            OperandSize::S64,
+            &mut |masm: &mut M, dst, src1, src2, size| {
+                masm.float_cmp_with_set(src1, src2, dst, FloatCmpKind::Ge, size);
+            },
+        );
+    }
+
+    fn visit_f32_convert_i32_s(&mut self) {
         self.context
-            .unop(self.masm, OperandSize::S32, &mut |masm, reg, size| {
-                masm.float_round(RoundingMode::Up, reg, RegImm::Reg(reg), size);
+            .convert_op(self.masm, WasmValType::F32, |masm, dst, src, dst_size| {
+                masm.signed_convert(src, dst, OperandSize::S32, dst_size);
             });
     }
 
-    fn visit_f64_ceil(&mut self) {
+    fn visit_f32_convert_i32_u(&mut self) {
+        self.context.convert_op_with_tmp_reg(
+            self.masm,
+            WasmValType::F32,
+            RegClass::Int,
+            |masm, dst, src, tmp_gpr, dst_size| {
+                masm.unsigned_convert(src, dst, tmp_gpr, OperandSize::S32, dst_size);
+            },
+        );
+    }
+
+    fn visit_f32_convert_i64_s(&mut self) {
         self.context
-            .unop(self.masm, OperandSize::S64, &mut |masm, reg, size| {
-                masm.float_round(RoundingMode::Up, reg, RegImm::Reg(reg), size);
+            .convert_op(self.masm, WasmValType::F32, |masm, dst, src, dst_size| {
+                masm.signed_convert(src, dst, OperandSize::S64, dst_size);
             });
     }
 
-    fn visit_f32_nearest(&mut self) {
+    fn visit_f32_convert_i64_u(&mut self) {
+        self.context.convert_op_with_tmp_reg(
+            self.masm,
+            WasmValType::F32,
+            RegClass::Int,
+            |masm, dst, src, tmp_gpr, dst_size| {
+                masm.unsigned_convert(src, dst, tmp_gpr, OperandSize::S64, dst_size);
+            },
+        );
+    }
+
+    fn visit_f64_convert_i32_s(&mut self) {
         self.context
-            .unop(self.masm, OperandSize::S32, &mut |masm, reg, size| {
-                masm.float_round(RoundingMode::Nearest, reg, RegImm::Reg(reg), size);
+            .convert_op(self.masm, WasmValType::F64, |masm, dst, src, dst_size| {
+                masm.signed_convert(src, dst, OperandSize::S32, dst_size);
             });
     }
 
-    fn visit_f64_nearest(&mut self) {
+    fn visit_f64_convert_i32_u(&mut self) {
+        self.context.convert_op_with_tmp_reg(
+            self.masm,
+            WasmValType::F64,
+            RegClass::Int,
+            |masm, dst, src, tmp_gpr, dst_size| {
+                masm.unsigned_convert(src, dst, tmp_gpr, OperandSize::S32, dst_size);
+            },
+        );
+    }
+
+    fn visit_f64_convert_i64_s(&mut self) {
         self.context
-            .unop(self.masm, OperandSize::S64, &mut |masm, reg, size| {
-                masm.float_round(RoundingMode::Nearest, reg, RegImm::Reg(reg), size);
+            .convert_op(self.masm, WasmValType::F64, |masm, dst, src, dst_size| {
+                masm.signed_convert(src, dst, OperandSize::S64, dst_size);
             });
     }
 
-    fn visit_f32_trunc(&mut self) {
+    fn visit_f64_convert_i64_u(&mut self) {
+        self.context.convert_op_with_tmp_reg(
+            self.masm,
+            WasmValType::F64,
+            RegClass::Int,
+            |masm, dst, src, tmp_gpr, dst_size| {
+                masm.unsigned_convert(src, dst, tmp_gpr, OperandSize::S64, dst_size);
+            },
+        );
+    }
+
+    fn visit_f32_reinterpret_i32(&mut self) {
         self.context
-            .unop(self.masm, OperandSize::S32, &mut |masm, reg, size| {
-                masm.float_round(RoundingMode::Zero, reg, RegImm::Reg(reg), size);
+            .convert_op(self.masm, WasmValType::F32, |masm, dst, src, size| {
+                masm.reinterpret_int_as_float(src.into(), dst, size);
             });
     }
 
-    fn visit_f64_trunc(&mut self) {
+    fn visit_f64_reinterpret_i64(&mut self) {
         self.context
-            .unop(self.masm, OperandSize::S64, &mut |masm, reg, size| {
-                masm.float_round(RoundingMode::Zero, reg, RegImm::Reg(reg), size);
+            .convert_op(self.masm, WasmValType::F64, |masm, dst, src, size| {
+                masm.reinterpret_int_as_float(src.into(), dst, size);
+            });
+    }
+
+    fn visit_f32_demote_f64(&mut self) {
+        self.context
+            .unop(self.masm, OperandSize::S64, &mut |masm, reg, _size| {
+                masm.demote(reg, reg);
+                TypedReg::f32(reg)
+            });
+    }
+
+    fn visit_f64_promote_f32(&mut self) {
+        self.context
+            .unop(self.masm, OperandSize::S32, &mut |masm, reg, _size| {
+                masm.promote(reg, reg);
+                TypedReg::f64(reg)
             });
     }
 
     fn visit_i32_add(&mut self) {
         self.context.i32_binop(self.masm, |masm, dst, src, size| {
             masm.add(dst, dst, src, size);
+            TypedReg::i32(dst)
         });
     }
 
     fn visit_i64_add(&mut self) {
         self.context.i64_binop(self.masm, |masm, dst, src, size| {
             masm.add(dst, dst, src, size);
+            TypedReg::i64(dst)
         });
     }
 
     fn visit_i32_sub(&mut self) {
         self.context.i32_binop(self.masm, |masm, dst, src, size| {
             masm.sub(dst, dst, src, size);
+            TypedReg::i32(dst)
         });
     }
 
     fn visit_i64_sub(&mut self) {
         self.context.i64_binop(self.masm, |masm, dst, src, size| {
             masm.sub(dst, dst, src, size);
+            TypedReg::i64(dst)
         });
     }
 
     fn visit_i32_mul(&mut self) {
         self.context.i32_binop(self.masm, |masm, dst, src, size| {
             masm.mul(dst, dst, src, size);
+            TypedReg::i32(dst)
         });
     }
 
     fn visit_i64_mul(&mut self) {
         self.context.i64_binop(self.masm, |masm, dst, src, size| {
             masm.mul(dst, dst, src, size);
+            TypedReg::i64(dst)
         });
     }
 
@@ -336,90 +901,91 @@ where
     }
 
     fn visit_i32_eq(&mut self) {
-        self.cmp_i32s(CmpKind::Eq);
+        self.cmp_i32s(IntCmpKind::Eq);
     }
 
     fn visit_i64_eq(&mut self) {
-        self.cmp_i64s(CmpKind::Eq);
+        self.cmp_i64s(IntCmpKind::Eq);
     }
 
     fn visit_i32_ne(&mut self) {
-        self.cmp_i32s(CmpKind::Ne);
+        self.cmp_i32s(IntCmpKind::Ne);
     }
 
     fn visit_i64_ne(&mut self) {
-        self.cmp_i64s(CmpKind::Ne);
+        self.cmp_i64s(IntCmpKind::Ne);
     }
 
     fn visit_i32_lt_s(&mut self) {
-        self.cmp_i32s(CmpKind::LtS);
+        self.cmp_i32s(IntCmpKind::LtS);
     }
 
     fn visit_i64_lt_s(&mut self) {
-        self.cmp_i64s(CmpKind::LtS);
+        self.cmp_i64s(IntCmpKind::LtS);
     }
 
     fn visit_i32_lt_u(&mut self) {
-        self.cmp_i32s(CmpKind::LtU);
+        self.cmp_i32s(IntCmpKind::LtU);
     }
 
     fn visit_i64_lt_u(&mut self) {
-        self.cmp_i64s(CmpKind::LtU);
+        self.cmp_i64s(IntCmpKind::LtU);
     }
 
     fn visit_i32_le_s(&mut self) {
-        self.cmp_i32s(CmpKind::LeS);
+        self.cmp_i32s(IntCmpKind::LeS);
     }
 
     fn visit_i64_le_s(&mut self) {
-        self.cmp_i64s(CmpKind::LeS);
+        self.cmp_i64s(IntCmpKind::LeS);
     }
 
     fn visit_i32_le_u(&mut self) {
-        self.cmp_i32s(CmpKind::LeU);
+        self.cmp_i32s(IntCmpKind::LeU);
     }
 
     fn visit_i64_le_u(&mut self) {
-        self.cmp_i64s(CmpKind::LeU);
+        self.cmp_i64s(IntCmpKind::LeU);
     }
 
     fn visit_i32_gt_s(&mut self) {
-        self.cmp_i32s(CmpKind::GtS);
+        self.cmp_i32s(IntCmpKind::GtS);
     }
 
     fn visit_i64_gt_s(&mut self) {
-        self.cmp_i64s(CmpKind::GtS);
+        self.cmp_i64s(IntCmpKind::GtS);
     }
 
     fn visit_i32_gt_u(&mut self) {
-        self.cmp_i32s(CmpKind::GtU);
+        self.cmp_i32s(IntCmpKind::GtU);
     }
 
     fn visit_i64_gt_u(&mut self) {
-        self.cmp_i64s(CmpKind::GtU);
+        self.cmp_i64s(IntCmpKind::GtU);
     }
 
     fn visit_i32_ge_s(&mut self) {
-        self.cmp_i32s(CmpKind::GeS);
+        self.cmp_i32s(IntCmpKind::GeS);
     }
 
     fn visit_i64_ge_s(&mut self) {
-        self.cmp_i64s(CmpKind::GeS);
+        self.cmp_i64s(IntCmpKind::GeS);
     }
 
     fn visit_i32_ge_u(&mut self) {
-        self.cmp_i32s(CmpKind::GeU);
+        self.cmp_i32s(IntCmpKind::GeU);
     }
 
     fn visit_i64_ge_u(&mut self) {
-        self.cmp_i64s(CmpKind::GeU);
+        self.cmp_i64s(IntCmpKind::GeU);
     }
 
     fn visit_i32_eqz(&mut self) {
         use OperandSize::*;
 
         self.context.unop(self.masm, S32, &mut |masm, reg, size| {
-            masm.cmp_with_set(RegImm::i32(0), reg.into(), CmpKind::Eq, size);
+            masm.cmp_with_set(RegImm::i32(0), reg.into(), IntCmpKind::Eq, size);
+            TypedReg::i32(reg)
         });
     }
 
@@ -427,7 +993,8 @@ where
         use OperandSize::*;
 
         self.context.unop(self.masm, S64, &mut |masm, reg, size| {
-            masm.cmp_with_set(RegImm::i64(0), reg.into(), CmpKind::Eq, size);
+            masm.cmp_with_set(RegImm::i64(0), reg.into(), IntCmpKind::Eq, size);
+            TypedReg::i32(reg) // Return value for `i64.eqz` is an `i32`.
         });
     }
 
@@ -436,6 +1003,7 @@ where
 
         self.context.unop(self.masm, S32, &mut |masm, reg, size| {
             masm.clz(reg, reg, size);
+            TypedReg::i32(reg)
         });
     }
 
@@ -444,6 +1012,7 @@ where
 
         self.context.unop(self.masm, S64, &mut |masm, reg, size| {
             masm.clz(reg, reg, size);
+            TypedReg::i64(reg)
         });
     }
 
@@ -452,6 +1021,7 @@ where
 
         self.context.unop(self.masm, S32, &mut |masm, reg, size| {
             masm.ctz(reg, reg, size);
+            TypedReg::i32(reg)
         });
     }
 
@@ -460,113 +1030,110 @@ where
 
         self.context.unop(self.masm, S64, &mut |masm, reg, size| {
             masm.ctz(reg, reg, size);
+            TypedReg::i64(reg)
         });
     }
 
     fn visit_i32_and(&mut self) {
         self.context.i32_binop(self.masm, |masm, dst, src, size| {
             masm.and(dst, dst, src, size);
+            TypedReg::i32(dst)
         });
     }
 
     fn visit_i64_and(&mut self) {
         self.context.i64_binop(self.masm, |masm, dst, src, size| {
             masm.and(dst, dst, src, size);
+            TypedReg::i64(dst)
         });
     }
 
     fn visit_i32_or(&mut self) {
         self.context.i32_binop(self.masm, |masm, dst, src, size| {
             masm.or(dst, dst, src, size);
+            TypedReg::i32(dst)
         });
     }
 
     fn visit_i64_or(&mut self) {
         self.context.i64_binop(self.masm, |masm, dst, src, size| {
             masm.or(dst, dst, src, size);
+            TypedReg::i64(dst)
         });
     }
 
     fn visit_i32_xor(&mut self) {
         self.context.i32_binop(self.masm, |masm, dst, src, size| {
             masm.xor(dst, dst, src, size);
+            TypedReg::i32(dst)
         });
     }
 
     fn visit_i64_xor(&mut self) {
         self.context.i64_binop(self.masm, |masm, dst, src, size| {
             masm.xor(dst, dst, src, size);
+            TypedReg::i64(dst)
         });
     }
 
     fn visit_i32_shl(&mut self) {
-        use OperandSize::*;
         use ShiftKind::*;
 
-        self.masm.shift(&mut self.context, Shl, S32);
+        self.context.i32_shift(self.masm, Shl);
     }
 
     fn visit_i64_shl(&mut self) {
-        use OperandSize::*;
         use ShiftKind::*;
 
-        self.masm.shift(&mut self.context, Shl, S64);
+        self.context.i64_shift(self.masm, Shl);
     }
 
     fn visit_i32_shr_s(&mut self) {
-        use OperandSize::*;
         use ShiftKind::*;
 
-        self.masm.shift(&mut self.context, ShrS, S32);
+        self.context.i32_shift(self.masm, ShrS);
     }
 
     fn visit_i64_shr_s(&mut self) {
-        use OperandSize::*;
         use ShiftKind::*;
 
-        self.masm.shift(&mut self.context, ShrS, S64);
+        self.context.i64_shift(self.masm, ShrS);
     }
 
     fn visit_i32_shr_u(&mut self) {
-        use OperandSize::*;
         use ShiftKind::*;
 
-        self.masm.shift(&mut self.context, ShrU, S32);
+        self.context.i32_shift(self.masm, ShrU);
     }
 
     fn visit_i64_shr_u(&mut self) {
-        use OperandSize::*;
         use ShiftKind::*;
 
-        self.masm.shift(&mut self.context, ShrU, S64);
+        self.context.i64_shift(self.masm, ShrU);
     }
 
     fn visit_i32_rotl(&mut self) {
-        use OperandSize::*;
         use ShiftKind::*;
 
-        self.masm.shift(&mut self.context, Rotl, S32);
+        self.context.i32_shift(self.masm, Rotl);
     }
 
     fn visit_i64_rotl(&mut self) {
-        use OperandSize::*;
         use ShiftKind::*;
 
-        self.masm.shift(&mut self.context, Rotl, S64);
+        self.context.i64_shift(self.masm, Rotl);
     }
 
     fn visit_i32_rotr(&mut self) {
-        use OperandSize::*;
         use ShiftKind::*;
 
-        self.masm.shift(&mut self.context, Rotr, S32);
+        self.context.i32_shift(self.masm, Rotr);
     }
 
     fn visit_i64_rotr(&mut self) {
-        use OperandSize::*;
         use ShiftKind::*;
 
-        self.masm.shift(&mut self.context, Rotr, S64);
+        self.context.i64_shift(self.masm, Rotr);
     }
 
     fn visit_end(&mut self) {
@@ -574,17 +1141,7 @@ where
             self.handle_unreachable_end();
         } else {
             let mut control = self.control_frames.pop().unwrap();
-            let is_outermost = self.control_frames.len() == 0;
-            // If it's not the outermost control stack frame, emit the the full "end" sequence,
-            // which involves, popping results from the value stack, pushing results back to the
-            // value stack and binding the exit label.
-            // Else, pop values from the value stack and bind the exit label.
-            if !is_outermost {
-                control.emit_end(self.masm, &mut self.context);
-            } else {
-                self.context.pop_abi_results(control.result(), self.masm);
-                control.bind_exit_label(self.masm);
-            }
+            control.emit_end(self.masm, &mut self.context);
         }
     }
 
@@ -599,117 +1156,513 @@ where
         self.masm.popcnt(&mut self.context, S64);
     }
 
-    fn visit_local_get(&mut self, index: u32) {
-        use WasmType::*;
-        let context = &mut self.context;
-        let slot = context
-            .frame
-            .get_local(index)
-            .unwrap_or_else(|| panic!("valid local at slot = {}", index));
-        match slot.ty {
-            I32 | I64 | F32 | F64 => context.stack.push(Val::local(index, slot.ty)),
-            _ => panic!("Unsupported type {:?} for local", slot.ty),
-        }
-    }
+    fn visit_i32_wrap_i64(&mut self) {
+        use OperandSize::*;
+
+        self.context.unop(self.masm, S64, &mut |masm, reg, _size| {
+            masm.wrap(reg, reg);
+            TypedReg::i32(reg)
+        });
+    }
+
+    fn visit_i64_extend_i32_s(&mut self) {
+        use OperandSize::*;
+
+        self.context.unop(self.masm, S32, &mut |masm, reg, _size| {
+            masm.extend(reg, reg, ExtendKind::I64ExtendI32S);
+            TypedReg::i64(reg)
+        });
+    }
+
+    fn visit_i64_extend_i32_u(&mut self) {
+        use OperandSize::*;
+
+        self.context.unop(self.masm, S32, &mut |masm, reg, _size| {
+            masm.extend(reg, reg, ExtendKind::I64ExtendI32U);
+            TypedReg::i64(reg)
+        });
+    }
+
+    fn visit_i32_extend8_s(&mut self) {
+        use OperandSize::*;
+
+        self.context.unop(self.masm, S32, &mut |masm, reg, _size| {
+            masm.extend(reg, reg, ExtendKind::I32Extend8S);
+            TypedReg::i32(reg)
+        });
+    }
+
+    fn visit_i32_extend16_s(&mut self) {
+        use OperandSize::*;
+
+        self.context.unop(self.masm, S32, &mut |masm, reg, _size| {
+            masm.extend(reg, reg, ExtendKind::I32Extend16S);
+            TypedReg::i32(reg)
+        });
+    }
+
+    fn visit_i64_extend8_s(&mut self) {
+        use OperandSize::*;
+
+        self.context.unop(self.masm, S64, &mut |masm, reg, _size| {
+            masm.extend(reg, reg, ExtendKind::I64Extend8S);
+            TypedReg::i64(reg)
+        });
+    }
+
+    fn visit_i64_extend16_s(&mut self) {
+        use OperandSize::*;
+
+        self.context.unop(self.masm, S64, &mut |masm, reg, _size| {
+            masm.extend(reg, reg, ExtendKind::I64Extend16S);
+            TypedReg::i64(reg)
+        });
+    }
+
+    fn visit_i64_extend32_s(&mut self) {
+        use OperandSize::*;
+
+        self.context.unop(self.masm, S64, &mut |masm, reg, _size| {
+            masm.extend(reg, reg, ExtendKind::I64Extend32S);
+            TypedReg::i64(reg)
+        });
+    }
+
+    fn visit_i32_trunc_f32_s(&mut self) {
+        use OperandSize::*;
+
+        self.context
+            .convert_op(self.masm, WasmValType::I32, |masm, dst, src, dst_size| {
+                masm.signed_truncate(src, dst, S32, dst_size, TruncKind::Unchecked);
+            });
+    }
+
+    fn visit_i32_trunc_f32_u(&mut self) {
+        use OperandSize::*;
+
+        self.context.convert_op_with_tmp_reg(
+            self.masm,
+            WasmValType::I32,
+            RegClass::Float,
+            |masm, dst, src, tmp_fpr, dst_size| {
+                masm.unsigned_truncate(src, dst, tmp_fpr, S32, dst_size, TruncKind::Unchecked);
+            },
+        );
+    }
+
+    fn visit_i32_trunc_f64_s(&mut self) {
+        use OperandSize::*;
+
+        self.context
+            .convert_op(self.masm, WasmValType::I32, |masm, dst, src, dst_size| {
+                masm.signed_truncate(src, dst, S64, dst_size, TruncKind::Unchecked);
+            });
+    }
+
+    fn visit_i32_trunc_f64_u(&mut self) {
+        use OperandSize::*;
+
+        self.context.convert_op_with_tmp_reg(
+            self.masm,
+            WasmValType::I32,
+            RegClass::Float,
+            |masm, dst, src, tmp_fpr, dst_size| {
+                masm.unsigned_truncate(src, dst, tmp_fpr, S64, dst_size, TruncKind::Unchecked);
+            },
+        );
+    }
+
+    fn visit_i64_trunc_f32_s(&mut self) {
+        use OperandSize::*;
+
+        self.context
+            .convert_op(self.masm, WasmValType::I64, |masm, dst, src, dst_size| {
+                masm.signed_truncate(src, dst, S32, dst_size, TruncKind::Unchecked);
+            });
+    }
+
+    fn visit_i64_trunc_f32_u(&mut self) {
+        use OperandSize::*;
+
+        self.context.convert_op_with_tmp_reg(
+            self.masm,
+            WasmValType::I64,
+            RegClass::Float,
+            |masm, dst, src, tmp_fpr, dst_size| {
+                masm.unsigned_truncate(src, dst, tmp_fpr, S32, dst_size, TruncKind::Unchecked);
+            },
+        );
+    }
+
+    fn visit_i64_trunc_f64_s(&mut self) {
+        use OperandSize::*;
+
+        self.context
+            .convert_op(self.masm, WasmValType::I64, |masm, dst, src, dst_size| {
+                masm.signed_truncate(src, dst, S64, dst_size, TruncKind::Unchecked);
+            });
+    }
+
+    fn visit_i64_trunc_f64_u(&mut self) {
+        use OperandSize::*;
+
+        self.context.convert_op_with_tmp_reg(
+            self.masm,
+            WasmValType::I64,
+            RegClass::Float,
+            |masm, dst, src, tmp_fpr, dst_size| {
+                masm.unsigned_truncate(src, dst, tmp_fpr, S64, dst_size, TruncKind::Unchecked);
+            },
+        );
+    }
+
+    fn visit_i32_reinterpret_f32(&mut self) {
+        self.context
+            .convert_op(self.masm, WasmValType::I32, |masm, dst, src, size| {
+                masm.reinterpret_float_as_int(src.into(), dst, size);
+            });
+    }
+
+    fn visit_i64_reinterpret_f64(&mut self) {
+        self.context
+            .convert_op(self.masm, WasmValType::I64, |masm, dst, src, size| {
+                masm.reinterpret_float_as_int(src.into(), dst, size);
+            });
+    }
+
+    fn visit_local_get(&mut self, index: u32) {
+        use WasmValType::*;
+        let context = &mut self.context;
+        let slot = context.frame.get_wasm_local(index);
+        match slot.ty {
+            I32 | I64 | F32 | F64 | V128 => context.stack.push(Val::local(index, slot.ty)),
+            Ref(rt) => match rt.heap_type {
+                WasmHeapType::Func => context.stack.push(Val::local(index, slot.ty)),
+                WasmHeapType::Extern => {
+                    self.found_unsupported_instruction =
+                        Some("unsupported local.get of externref local");
+                }
+                ht => unimplemented!("Support for WasmHeapType: {ht}"),
+            },
+        }
+    }
 
-    // TODO: verify the case where the target local is on the stack.
     fn visit_local_set(&mut self, index: u32) {
-        let src = self.context.set_local(self.masm, index);
+        let src = self.emit_set_local(index);
         self.context.free_reg(src);
     }
 
     fn visit_call(&mut self, index: u32) {
         let callee = self.env.callee_from_index(FuncIndex::from_u32(index));
-        self.emit_call(callee);
+        FnCall::emit::<M>(&mut self.env, self.masm, &mut self.context, callee)
     }
 
-    fn visit_call_indirect(&mut self, type_index: u32, table_index: u32, _: u8) {
+    fn visit_call_indirect(&mut self, type_index: u32, table_index: u32) {
+        // Spill now because `emit_lazy_init_funcref` and the `FnCall::emit`
+        // invocations will both trigger spills since they both call functions.
+        // However, the machine instructions for the spill emitted by
+        // `emit_lazy_funcref` will be jumped over if the funcref was previously
+        // initialized which may result in the machine stack becoming
+        // unbalanced.
+        self.context.spill(self.masm);
+
         let type_index = TypeIndex::from_u32(type_index);
         let table_index = TableIndex::from_u32(table_index);
+
+        self.emit_lazy_init_funcref(table_index);
+
+        // Perform the indirect call.
+        // This code assumes that [`Self::emit_lazy_init_funcref`] will
+        // push the funcref to the value stack.
+        match self.env.translation.module.table_plans[table_index].style {
+            TableStyle::CallerChecksSignature { lazy_init: true } => {
+                let funcref_ptr = self.context.stack.peek().map(|v| v.unwrap_reg()).unwrap();
+                self.masm
+                    .trapz(funcref_ptr.into(), TrapCode::IndirectCallToNull);
+                self.emit_typecheck_funcref(funcref_ptr.into(), type_index);
+            }
+            _ => unimplemented!("Support for eager table init"),
+        }
+
+        let callee = self.env.funcref(type_index);
+        FnCall::emit::<M>(&mut self.env, self.masm, &mut self.context, callee)
+    }
+
+    fn visit_table_init(&mut self, elem: u32, table: u32) {
+        debug_assert!(self.context.stack.len() >= 3);
+        let at = self.context.stack.len() - 3;
+
+        self.context
+            .stack
+            .insert_many(at, &[table.try_into().unwrap(), elem.try_into().unwrap()]);
+
+        let builtin = self.env.builtins.table_init::<M::ABI, M::Ptr>();
+        FnCall::emit::<M>(
+            &mut self.env,
+            self.masm,
+            &mut self.context,
+            Callee::Builtin(builtin.clone()),
+        )
+    }
+
+    fn visit_table_copy(&mut self, dst: u32, src: u32) {
+        debug_assert!(self.context.stack.len() >= 3);
+        let at = self.context.stack.len() - 3;
+        self.context
+            .stack
+            .insert_many(at, &[dst.try_into().unwrap(), src.try_into().unwrap()]);
+
+        let builtin = self.env.builtins.table_copy::<M::ABI, M::Ptr>();
+        FnCall::emit::<M>(
+            &mut self.env,
+            self.masm,
+            &mut self.context,
+            Callee::Builtin(builtin),
+        )
+    }
+
+    fn visit_table_get(&mut self, table: u32) {
+        let table_index = TableIndex::from_u32(table);
+        let plan = self.env.table_plan(table_index);
+        let heap_type = plan.table.wasm_ty.heap_type;
+        let style = &plan.style;
+
+        match heap_type {
+            WasmHeapType::Func => match style {
+                TableStyle::CallerChecksSignature { lazy_init: true } => {
+                    self.emit_lazy_init_funcref(table_index)
+                }
+                _ => unimplemented!("Support for eager table init"),
+            },
+            WasmHeapType::Extern => {
+                self.found_unsupported_instruction =
+                    Some("unsupported table.get of externref table");
+            }
+            t => {
+                unimplemented!("Support for WasmHeapType: {t}")
+            }
+        }
+    }
+
+    fn visit_table_grow(&mut self, table: u32) {
+        let table_index = TableIndex::from_u32(table);
+        let table_plan = self.env.table_plan(table_index);
+        let builtin = match table_plan.table.wasm_ty.heap_type {
+            WasmHeapType::Func => self.env.builtins.table_grow_func_ref::<M::ABI, M::Ptr>(),
+            ty => unimplemented!("Support for HeapType: {ty}"),
+        };
+
+        let len = self.context.stack.len();
+        // table.grow` requires at least 2 elements on the value stack.
+        debug_assert!(len >= 2);
+        let at = len - 2;
+
+        // The table_grow builtin expects the parameters in a different
+        // order.
+        // The value stack at this point should contain:
+        // [ init_value | delta ] (stack top)
+        // but the builtin function expects the init value as the last
+        // argument.
+        self.context.stack.inner_mut().swap(len - 1, len - 2);
+        self.context
+            .stack
+            .insert_many(at, &[table.try_into().unwrap()]);
+
+        FnCall::emit::<M>(
+            &mut self.env,
+            self.masm,
+            &mut self.context,
+            Callee::Builtin(builtin.clone()),
+        )
+    }
+
+    fn visit_table_size(&mut self, table: u32) {
+        let table_index = TableIndex::from_u32(table);
         let table_data = self.env.resolve_table_data(table_index);
-        let ptr_type = self.env.ptr_type();
+        self.emit_compute_table_size(&table_data);
+    }
 
-        let builtin = self
-            .env
-            .builtins
-            .table_get_lazy_init_func_ref::<M::ABI, M::Ptr>();
+    fn visit_table_fill(&mut self, table: u32) {
+        let table_index = TableIndex::from_u32(table);
+        let table_plan = self.env.table_plan(table_index);
+        let builtin = match table_plan.table.wasm_ty.heap_type {
+            WasmHeapType::Func => self.env.builtins.table_fill_func_ref::<M::ABI, M::Ptr>(),
+            ty => unimplemented!("Support for heap type: {ty}"),
+        };
 
-        FnCall::new(&builtin.sig).with_lib(
+        let len = self.context.stack.len();
+        debug_assert!(len >= 3);
+        let at = len - 3;
+        self.context
+            .stack
+            .insert_many(at, &[table.try_into().unwrap()]);
+        FnCall::emit::<M>(
+            &mut self.env,
             self.masm,
             &mut self.context,
-            &builtin,
-            |cx, masm, call, callee| {
-                // Calculate the table element address.
-                let index = cx.pop_to_reg(masm, None);
-                let elem_addr =
-                    masm.table_elem_address(index.into(), index.ty.into(), &table_data, cx);
-
-                let defined = masm.get_label();
-                let cont = masm.get_label();
-
-                // Preemptively move the table element address to the
-                // result register, to avoid conflicts at the control flow merge.
-                let result = call.abi_sig.result.result_reg().unwrap();
-                masm.mov(elem_addr.into(), result, ptr_type.into());
-                cx.free_reg(result);
-
-                // Push the builtin function arguments to the stack.
-                cx.stack
-                    .push(TypedReg::new(ptr_type, <M::ABI as ABI>::vmctx_reg()).into());
-                cx.stack.push(table_index.as_u32().try_into().unwrap());
-                cx.stack.push(index.into());
-
-                masm.branch(
-                    CmpKind::Ne,
-                    elem_addr.into(),
-                    elem_addr,
-                    defined,
-                    ptr_type.into(),
-                );
-
-                call.calculate_call_stack_space(cx).reg(masm, cx, callee);
-                // We know the signature of the libcall in this case, so we assert that there's
-                // one element in the stack and that it's  the ABI signature's result register.
-                let top = cx.stack.peek().unwrap();
-                let top = top.get_reg();
-                debug_assert!(top.reg == result);
-                masm.jmp(cont);
-
-                // In the defined case, mask the funcref address in place, by peeking into the
-                // last element of the value stack, which was pushed by the `indirect` function
-                // call above.
-                masm.bind(defined);
-                let imm = RegImm::i64(FUNCREF_MASK as i64);
-                let dst = top.into();
-                masm.and(dst, dst, imm, top.ty.into());
-
-                masm.bind(cont);
-                // The indirect call above, will take care of freeing the registers used as
-                // params.
-                // So we only free the params used to lazily initialize the func ref.
-                cx.free_reg(elem_addr);
+            Callee::Builtin(builtin.clone()),
+        )
+    }
+
+    fn visit_table_set(&mut self, table: u32) {
+        let ptr_type = self.env.ptr_type();
+        let table_index = TableIndex::from_u32(table);
+        let table_data = self.env.resolve_table_data(table_index);
+        let plan = self.env.table_plan(table_index);
+        match plan.table.wasm_ty.heap_type {
+            WasmHeapType::Func => match plan.style {
+                TableStyle::CallerChecksSignature { lazy_init: true } => {
+                    let value = self.context.pop_to_reg(self.masm, None);
+                    let index = self.context.pop_to_reg(self.masm, None);
+                    let base = self.context.any_gpr(self.masm);
+                    let elem_addr =
+                        self.emit_compute_table_elem_addr(index.into(), base, &table_data);
+                    // Set the initialized bit.
+                    self.masm.or(
+                        value.into(),
+                        value.into(),
+                        RegImm::i64(FUNCREF_INIT_BIT as i64),
+                        ptr_type.into(),
+                    );
+
+                    self.masm.store_ptr(value.into(), elem_addr);
+
+                    self.context.free_reg(value);
+                    self.context.free_reg(index);
+                    self.context.free_reg(base);
+                }
+                _ => unimplemented!("Support for eager table init"),
             },
+            ty => unimplemented!("Support for WasmHeapType: {ty}"),
+        };
+    }
+
+    fn visit_elem_drop(&mut self, index: u32) {
+        let elem_drop = self.env.builtins.elem_drop::<M::ABI, M::Ptr>();
+        self.context.stack.extend([index.try_into().unwrap()]);
+        FnCall::emit::<M>(
+            &mut self.env,
+            self.masm,
+            &mut self.context,
+            Callee::Builtin(elem_drop),
+        )
+    }
+
+    fn visit_memory_init(&mut self, data_index: u32, mem: u32) {
+        debug_assert!(self.context.stack.len() >= 3);
+        let at = self.context.stack.len() - 3;
+        self.context.stack.insert_many(
+            at,
+            &[mem.try_into().unwrap(), data_index.try_into().unwrap()],
+        );
+        let builtin = self.env.builtins.memory_init::<M::ABI, M::Ptr>();
+        FnCall::emit::<M>(
+            &mut self.env,
+            self.masm,
+            &mut self.context,
+            Callee::Builtin(builtin),
+        )
+    }
+
+    fn visit_memory_copy(&mut self, dst_mem: u32, src_mem: u32) {
+        // At this point, the stack is expected to contain:
+        //     [ dst_offset, src_offset, len ]
+        // The following code inserts the missing params, so that stack contains:
+        //     [ vmctx, dst_mem, dst_offset, src_mem, src_offset, len ]
+        // Which is the order expected by the builtin function.
+        debug_assert!(self.context.stack.len() >= 3);
+        let at = self.context.stack.len() - 2;
+        self.context
+            .stack
+            .insert_many(at, &[src_mem.try_into().unwrap()]);
+
+        // One element was inserted above, so instead of 3, we use 4.
+        let at = self.context.stack.len() - 4;
+        self.context
+            .stack
+            .insert_many(at, &[dst_mem.try_into().unwrap()]);
+
+        let builtin = self.env.builtins.memory_copy::<M::ABI, M::Ptr>();
+
+        FnCall::emit::<M>(
+            &mut self.env,
+            self.masm,
+            &mut self.context,
+            Callee::Builtin(builtin),
+        )
+    }
+
+    fn visit_memory_fill(&mut self, mem: u32) {
+        debug_assert!(self.context.stack.len() >= 3);
+        let at = self.context.stack.len() - 3;
+
+        self.context
+            .stack
+            .insert_many(at, &[mem.try_into().unwrap()]);
+
+        let builtin = self.env.builtins.memory_fill::<M::ABI, M::Ptr>();
+        FnCall::emit::<M>(
+            &mut self.env,
+            self.masm,
+            &mut self.context,
+            Callee::Builtin(builtin),
+        )
+    }
+
+    fn visit_memory_size(&mut self, mem: u32) {
+        let heap = self.env.resolve_heap(MemoryIndex::from_u32(mem));
+        self.emit_compute_memory_size(&heap);
+    }
+
+    fn visit_memory_grow(&mut self, mem: u32) {
+        debug_assert!(self.context.stack.len() >= 1);
+        // The stack at this point contains: [ delta ]
+        // The desired state is
+        //   [ vmctx, delta, index ]
+        self.context.stack.extend([mem.try_into().unwrap()]);
+
+        let heap = self.env.resolve_heap(MemoryIndex::from_u32(mem));
+        let builtin = self.env.builtins.memory32_grow::<M::ABI, M::Ptr>();
+        FnCall::emit::<M>(
+            &mut self.env,
+            self.masm,
+            &mut self.context,
+            Callee::Builtin(builtin),
         );
 
-        // Perform the indirect call.
-        match self.env.translation.module.table_plans[table_index].style {
-            TableStyle::CallerChecksSignature => {
-                let funcref_ptr = self.context.stack.peek().map(|v| v.get_reg()).unwrap();
-                self.emit_typecheck_funcref(funcref_ptr.into(), type_index);
+        // The memory32_grow builtin returns a pointer type, therefore we must
+        // ensure that the return type is representative of the address space of
+        // the heap type.
+        match (self.env.ptr_type(), heap.ty) {
+            (WasmValType::I64, WasmValType::I64) => {}
+            // When the heap type is smaller than the pointer type, we adjust
+            // the result of the memory32_grow builtin.
+            (WasmValType::I64, WasmValType::I32) => {
+                let top: Reg = self.context.pop_to_reg(self.masm, None).into();
+                self.masm.wrap(top.into(), top.into());
+                self.context.stack.push(TypedReg::i32(top).into());
             }
+            _ => unimplemented!("Support for 32-bit platforms"),
         }
+    }
+
+    fn visit_data_drop(&mut self, data_index: u32) {
+        self.context.stack.extend([data_index.try_into().unwrap()]);
 
-        // Perform call indirect.
-        // `emit_call` expects the callee to be on the stack. Delaying the
-        // computation of the callee address reduces register pressure.
-        self.emit_call(self.env.funcref(type_index));
+        let builtin = self.env.builtins.data_drop::<M::ABI, M::Ptr>();
+        FnCall::emit::<M>(
+            &mut self.env,
+            self.masm,
+            &mut self.context,
+            Callee::Builtin(builtin),
+        )
     }
 
     fn visit_nop(&mut self) {}
 
     fn visit_if(&mut self, blockty: BlockType) {
-        self.control_frames.push(ControlStackFrame::if_(
-            &self.env.resolve_block_type(blockty),
+        self.control_frames.push(ControlStackFrame::r#if(
+            self.env.resolve_block_sig(blockty),
             self.masm,
             &mut self.context,
         ));
@@ -729,15 +1682,15 @@ where
 
     fn visit_block(&mut self, blockty: BlockType) {
         self.control_frames.push(ControlStackFrame::block(
-            &self.env.resolve_block_type(blockty),
+            self.env.resolve_block_sig(blockty),
             self.masm,
             &mut self.context,
         ));
     }
 
     fn visit_loop(&mut self, blockty: BlockType) {
-        self.control_frames.push(ControlStackFrame::loop_(
-            &self.env.resolve_block_type(blockty),
+        self.control_frames.push(ControlStackFrame::r#loop(
+            self.env.resolve_block_sig(blockty),
             self.masm,
             &mut self.context,
         ));
@@ -748,7 +1701,8 @@ where
         let frame = &mut self.control_frames[index];
         self.context
             .unconditional_jump(frame, self.masm, |masm, cx, frame| {
-                cx.pop_abi_results(&frame.as_target_result(), masm);
+                frame
+                    .pop_abi_results::<M, _>(cx, masm, |results, _, _| results.ret_area().copied());
             });
     }
 
@@ -756,23 +1710,71 @@ where
         let index = control_index(depth, self.control_frames.len());
         let frame = &mut self.control_frames[index];
         frame.set_as_target();
-        let result = frame.as_target_result();
-        let top = self.context.without::<TypedReg, M, _>(
-            result.regs(),
-            result.regs(),
-            self.masm,
-            |ctx, masm| ctx.pop_to_reg(masm, None),
-        );
-        self.context.pop_abi_results(&result, self.masm);
-        self.context.push_abi_results(&result, self.masm);
-        self.masm.branch(
-            CmpKind::Ne,
-            top.reg.into(),
-            top.reg.into(),
-            *frame.label(),
-            OperandSize::S32,
-        );
+
+        let top = {
+            let top = self.context.without::<TypedReg, M, _>(
+                frame.results::<M>().regs(),
+                self.masm,
+                |ctx, masm| ctx.pop_to_reg(masm, None),
+            );
+            // Explicitly save any live registers and locals before setting up
+            // the branch state.
+            // In some cases, calculating the `top` value above, will result in
+            // a spill, thus the following one will result in a no-op.
+            self.context.spill(self.masm);
+            frame.top_abi_results::<M, _>(
+                &mut self.context,
+                self.masm,
+                |results, context, masm| {
+                    // In the case of `br_if` there's a possibility that we'll
+                    // exit early from the block or fallthrough, for
+                    // a fallthrough, we cannot rely on the pre-computed return area;
+                    // it must be recalculated so that any values that are
+                    // generated are correctly placed near the current stack
+                    // pointer.
+                    results.on_stack().then(|| {
+                        let stack_consumed = context.stack.sizeof(results.stack_operands_len());
+                        let base = masm.sp_offset().as_u32() - stack_consumed;
+                        let offs = base + results.size();
+                        RetArea::sp(SPOffset::from_u32(offs))
+                    })
+                },
+            );
+            top
+        };
+
+        // Emit instructions to balance the machine stack if the frame has
+        // a different offset.
+        let current_sp_offset = self.masm.sp_offset();
+        let results_size = frame.results::<M>().size();
+        let state = frame.stack_state();
+        let (label, cmp, needs_cleanup) = if current_sp_offset > state.target_offset {
+            (self.masm.get_label(), IntCmpKind::Eq, true)
+        } else {
+            (*frame.label(), IntCmpKind::Ne, false)
+        };
+
+        self.masm
+            .branch(cmp, top.reg.into(), top.reg.into(), label, OperandSize::S32);
         self.context.free_reg(top);
+
+        if needs_cleanup {
+            // Emit instructions to balance the stack and jump if not falling
+            // through.
+            self.masm.memmove(
+                current_sp_offset,
+                state.target_offset,
+                results_size,
+                MemMoveDirection::LowToHigh,
+            );
+            self.masm.ensure_sp_for_jump(state.target_offset);
+            self.masm.jmp(*frame.label());
+
+            // Restore sp_offset to what it was for falling through and emit
+            // fallthrough label.
+            self.masm.reset_stack_pointer(current_sp_offset);
+            self.masm.bind(label);
+        }
     }
 
     fn visit_br_table(&mut self, targets: BrTable<'a>) {
@@ -784,17 +1786,30 @@ where
         let labels: SmallVec<[_; 5]> = (0..len).map(|_| self.masm.get_label()).collect();
 
         let default_index = control_index(targets.default(), self.control_frames.len());
-        let default_result = self.control_frames[default_index].as_target_result();
-        let (index, tmp) = self.context.without::<(TypedReg, _), M, _>(
-            default_result.regs(),
-            default_result.regs(),
-            self.masm,
-            |cx, masm| (cx.pop_to_reg(masm, None), cx.any_gpr(masm)),
-        );
+        let default_frame = &mut self.control_frames[default_index];
+        let default_result = default_frame.results::<M>();
+
+        let (index, tmp) = {
+            let index_and_tmp = self.context.without::<(TypedReg, _), M, _>(
+                default_result.regs(),
+                self.masm,
+                |cx, masm| (cx.pop_to_reg(masm, None), cx.any_gpr(masm)),
+            );
+
+            // Materialize any constants or locals into their result representation,
+            // so that when reachability is restored, they are correctly located.
+            default_frame.top_abi_results::<M, _>(&mut self.context, self.masm, |results, _, _| {
+                results.ret_area().copied()
+            });
+            index_and_tmp
+        };
 
-        self.context.pop_abi_results(&default_result, self.masm);
-        self.context.push_abi_results(&default_result, self.masm);
         self.masm.jmp_table(&labels, index.into(), tmp);
+        // Save the original stack pointer offset; we will reset the stack
+        // pointer to this offset after jumping to each of the targets. Each
+        // jump might adjust the stack according to the base offset of the
+        // target.
+        let current_sp = self.masm.sp_offset();
 
         for (t, l) in targets
             .targets()
@@ -803,18 +1818,28 @@ where
             .zip(labels.iter())
         {
             let control_index = control_index(t.unwrap(), self.control_frames.len());
-
+            let frame = &mut self.control_frames[control_index];
+            // Reset the stack pointer to its original offset. This is needed
+            // because each jump will potentially adjust the stack pointer
+            // according to the base offset of the target.
+            self.masm.reset_stack_pointer(current_sp);
+
+            // NB: We don't perform any result handling as it was
+            // already taken care of above before jumping to the
+            // jump table.
             self.masm.bind(*l);
-            self.context.unconditional_jump(
-                &mut self.control_frames[control_index],
-                self.masm,
-                // NB: We don't perform any result handling as it was
-                // already taken care of above before jumping to the
-                // jump table above. The call to `unconditional_jump`,
-                // will stil take care of the proper stack alignment.
-                |_, _, _| {},
-            )
+            // Ensure that the stack pointer is correctly positioned before
+            // jumping to the jump table code.
+            let state = frame.stack_state();
+            self.masm.ensure_sp_for_jump(state.target_offset);
+            self.masm.jmp(*frame.label());
+            frame.set_as_target();
         }
+        // Finally reset the stack pointer to the original location.
+        // The reachability analysis, will ensure it's correctly located
+        // once reachability is restored.
+        self.masm.reset_stack_pointer(current_sp);
+        self.context.reachable = false;
         self.context.free_reg(index.reg);
         self.context.free_reg(tmp);
     }
@@ -827,7 +1852,8 @@ where
         let outermost = &mut self.control_frames[0];
         self.context
             .unconditional_jump(outermost, self.masm, |masm, cx, frame| {
-                cx.pop_abi_results(&frame.as_target_result(), masm);
+                frame
+                    .pop_abi_results::<M, _>(cx, masm, |results, _, _| results.ret_area().copied());
             });
     }
 
@@ -841,16 +1867,13 @@ where
     }
 
     fn visit_local_tee(&mut self, index: u32) {
-        let typed_reg = self.context.set_local(self.masm, index);
+        let typed_reg = self.emit_set_local(index);
         self.context.stack.push(typed_reg.into());
     }
 
     fn visit_global_get(&mut self, global_index: u32) {
         let index = GlobalIndex::from_u32(global_index);
-        let (ty, offset) = self.env.resolve_global_type_and_offset(index);
-        let addr = self
-            .masm
-            .address_at_reg(<M::ABI as ABI>::vmctx_reg(), offset);
+        let (ty, addr) = self.emit_get_global_addr(index);
         let dst = self.context.reg_for_type(ty, self.masm);
         self.masm.load(addr, dst, ty.into());
         self.context.stack.push(Val::reg(dst, ty));
@@ -858,10 +1881,8 @@ where
 
     fn visit_global_set(&mut self, global_index: u32) {
         let index = GlobalIndex::from_u32(global_index);
-        let (ty, offset) = self.env.resolve_global_type_and_offset(index);
-        let addr = self
-            .masm
-            .address_at_reg(<M::ABI as ABI>::vmctx_reg(), offset);
+        let (ty, addr) = self.emit_get_global_addr(index);
+
         let typed_reg = self.context.pop_to_reg(self.masm, None);
         self.context.free_reg(typed_reg.reg);
         self.masm.store(typed_reg.reg.into(), addr, ty.into());
@@ -880,43 +1901,269 @@ where
         let val2 = self.context.pop_to_reg(self.masm, None);
         let val1 = self.context.pop_to_reg(self.masm, None);
         self.masm
-            .cmp(RegImm::i32(0), cond.reg.into(), OperandSize::S32);
-        // Conditionally move val1 to val2 if the the comparision is
+            .cmp(cond.reg.into(), RegImm::i32(0), OperandSize::S32);
+        // Conditionally move val1 to val2 if the comparison is
         // not zero.
         self.masm
-            .cmov(val1.into(), val2.into(), CmpKind::Ne, val1.ty.into());
+            .cmov(val1.into(), val2.into(), IntCmpKind::Ne, val1.ty.into());
         self.context.stack.push(val2.into());
         self.context.free_reg(val1.reg);
         self.context.free_reg(cond);
     }
 
+    fn visit_i32_load(&mut self, memarg: MemArg) {
+        self.emit_wasm_load(&memarg, WasmValType::I32, OperandSize::S32, None);
+    }
+
+    fn visit_i32_load8_s(&mut self, memarg: MemArg) {
+        self.emit_wasm_load(
+            &memarg,
+            WasmValType::I32,
+            OperandSize::S8,
+            Some(ExtendKind::I32Extend8S),
+        );
+    }
+
+    fn visit_i32_load8_u(&mut self, memarg: MemArg) {
+        self.emit_wasm_load(&memarg, WasmValType::I32, OperandSize::S8, None);
+    }
+
+    fn visit_i32_load16_s(&mut self, memarg: MemArg) {
+        self.emit_wasm_load(
+            &memarg,
+            WasmValType::I32,
+            OperandSize::S16,
+            Some(ExtendKind::I32Extend16S),
+        )
+    }
+
+    fn visit_i32_load16_u(&mut self, memarg: MemArg) {
+        self.emit_wasm_load(&memarg, WasmValType::I32, OperandSize::S16, None)
+    }
+
+    fn visit_i32_store(&mut self, memarg: MemArg) {
+        self.emit_wasm_store(&memarg, OperandSize::S32);
+    }
+
+    fn visit_i32_store8(&mut self, memarg: MemArg) {
+        self.emit_wasm_store(&memarg, OperandSize::S8)
+    }
+
+    fn visit_i32_store16(&mut self, memarg: MemArg) {
+        self.emit_wasm_store(&memarg, OperandSize::S16)
+    }
+
+    fn visit_i64_load8_s(&mut self, memarg: MemArg) {
+        self.emit_wasm_load(
+            &memarg,
+            WasmValType::I64,
+            OperandSize::S8,
+            Some(ExtendKind::I64Extend8S),
+        )
+    }
+
+    fn visit_i64_load8_u(&mut self, memarg: MemArg) {
+        self.emit_wasm_load(&memarg, WasmValType::I64, OperandSize::S8, None)
+    }
+
+    fn visit_i64_load16_u(&mut self, memarg: MemArg) {
+        self.emit_wasm_load(&memarg, WasmValType::I64, OperandSize::S16, None)
+    }
+
+    fn visit_i64_load16_s(&mut self, memarg: MemArg) {
+        self.emit_wasm_load(
+            &memarg,
+            WasmValType::I64,
+            OperandSize::S16,
+            Some(ExtendKind::I64Extend16S),
+        )
+    }
+
+    fn visit_i64_load32_u(&mut self, memarg: MemArg) {
+        self.emit_wasm_load(&memarg, WasmValType::I64, OperandSize::S32, None)
+    }
+
+    fn visit_i64_load32_s(&mut self, memarg: MemArg) {
+        self.emit_wasm_load(
+            &memarg,
+            WasmValType::I64,
+            OperandSize::S32,
+            Some(ExtendKind::I64Extend32S),
+        )
+    }
+
+    fn visit_i64_load(&mut self, memarg: MemArg) {
+        self.emit_wasm_load(&memarg, WasmValType::I64, OperandSize::S64, None)
+    }
+
+    fn visit_i64_store(&mut self, memarg: MemArg) -> Self::Output {
+        self.emit_wasm_store(&memarg, OperandSize::S64)
+    }
+
+    fn visit_i64_store8(&mut self, memarg: MemArg) -> Self::Output {
+        self.emit_wasm_store(&memarg, OperandSize::S8)
+    }
+
+    fn visit_i64_store16(&mut self, memarg: MemArg) -> Self::Output {
+        self.emit_wasm_store(&memarg, OperandSize::S16)
+    }
+
+    fn visit_i64_store32(&mut self, memarg: MemArg) -> Self::Output {
+        self.emit_wasm_store(&memarg, OperandSize::S32)
+    }
+
+    fn visit_f32_load(&mut self, memarg: MemArg) {
+        self.emit_wasm_load(&memarg, WasmValType::F32, OperandSize::S32, None)
+    }
+
+    fn visit_f32_store(&mut self, memarg: MemArg) {
+        self.emit_wasm_store(&memarg, OperandSize::S32)
+    }
+
+    fn visit_f64_load(&mut self, memarg: MemArg) {
+        self.emit_wasm_load(&memarg, WasmValType::F64, OperandSize::S64, None)
+    }
+
+    fn visit_f64_store(&mut self, memarg: MemArg) {
+        self.emit_wasm_store(&memarg, OperandSize::S64)
+    }
+
+    fn visit_v128_load(&mut self, memarg: MemArg) {
+        self.emit_wasm_load(&memarg, WasmValType::V128, OperandSize::S128, None)
+    }
+
+    fn visit_v128_store(&mut self, memarg: MemArg) {
+        self.emit_wasm_store(&memarg, OperandSize::S128)
+    }
+
+    fn visit_i32_trunc_sat_f32_s(&mut self) {
+        use OperandSize::*;
+
+        self.context
+            .convert_op(self.masm, WasmValType::I32, |masm, dst, src, dst_size| {
+                masm.signed_truncate(src, dst, S32, dst_size, TruncKind::Checked);
+            });
+    }
+
+    fn visit_i32_trunc_sat_f32_u(&mut self) {
+        use OperandSize::*;
+
+        self.context.convert_op_with_tmp_reg(
+            self.masm,
+            WasmValType::I32,
+            RegClass::Float,
+            |masm, dst, src, tmp_fpr, dst_size| {
+                masm.unsigned_truncate(src, dst, tmp_fpr, S32, dst_size, TruncKind::Checked);
+            },
+        );
+    }
+
+    fn visit_i32_trunc_sat_f64_s(&mut self) {
+        use OperandSize::*;
+
+        self.context
+            .convert_op(self.masm, WasmValType::I32, |masm, dst, src, dst_size| {
+                masm.signed_truncate(src, dst, S64, dst_size, TruncKind::Checked);
+            });
+    }
+
+    fn visit_i32_trunc_sat_f64_u(&mut self) {
+        use OperandSize::*;
+
+        self.context.convert_op_with_tmp_reg(
+            self.masm,
+            WasmValType::I32,
+            RegClass::Float,
+            |masm, dst, src, tmp_fpr, dst_size| {
+                masm.unsigned_truncate(src, dst, tmp_fpr, S64, dst_size, TruncKind::Checked);
+            },
+        );
+    }
+
+    fn visit_i64_trunc_sat_f32_s(&mut self) {
+        use OperandSize::*;
+
+        self.context
+            .convert_op(self.masm, WasmValType::I64, |masm, dst, src, dst_size| {
+                masm.signed_truncate(src, dst, S32, dst_size, TruncKind::Checked);
+            });
+    }
+
+    fn visit_i64_trunc_sat_f32_u(&mut self) {
+        use OperandSize::*;
+
+        self.context.convert_op_with_tmp_reg(
+            self.masm,
+            WasmValType::I64,
+            RegClass::Float,
+            |masm, dst, src, tmp_fpr, dst_size| {
+                masm.unsigned_truncate(src, dst, tmp_fpr, S32, dst_size, TruncKind::Checked);
+            },
+        );
+    }
+
+    fn visit_i64_trunc_sat_f64_s(&mut self) {
+        use OperandSize::*;
+
+        self.context
+            .convert_op(self.masm, WasmValType::I64, |masm, dst, src, dst_size| {
+                masm.signed_truncate(src, dst, S64, dst_size, TruncKind::Checked);
+            });
+    }
+
+    fn visit_i64_trunc_sat_f64_u(&mut self) {
+        use OperandSize::*;
+
+        self.context.convert_op_with_tmp_reg(
+            self.masm,
+            WasmValType::I64,
+            RegClass::Float,
+            |masm, dst, src, tmp_fpr, dst_size| {
+                masm.unsigned_truncate(src, dst, tmp_fpr, S64, dst_size, TruncKind::Checked);
+            },
+        );
+    }
+
     wasmparser::for_each_operator!(def_unsupported);
 }
 
-impl<'a, M> CodeGen<'a, M>
+impl<'a, 'translation, 'data, M> CodeGen<'a, 'translation, 'data, M>
 where
     M: MacroAssembler,
 {
-    fn cmp_i32s(&mut self, kind: CmpKind) {
+    fn cmp_i32s(&mut self, kind: IntCmpKind) {
         self.context.i32_binop(self.masm, |masm, dst, src, size| {
             masm.cmp_with_set(src, dst, kind, size);
+            TypedReg::i32(dst)
         });
     }
 
-    fn cmp_i64s(&mut self, kind: CmpKind) {
+    fn cmp_i64s(&mut self, kind: IntCmpKind) {
         self.context
             .i64_binop(self.masm, move |masm, dst, src, size| {
                 masm.cmp_with_set(src, dst, kind, size);
+                TypedReg::i32(dst) // Return value for comparisons is an `i32`.
             });
     }
 }
 
-impl From<WasmType> for OperandSize {
-    fn from(ty: WasmType) -> OperandSize {
+impl From<WasmValType> for OperandSize {
+    fn from(ty: WasmValType) -> OperandSize {
         match ty {
-            WasmType::I32 | WasmType::F32 => OperandSize::S32,
-            WasmType::I64 | WasmType::F64 => OperandSize::S64,
-            ty => todo!("unsupported type {:?}", ty),
+            WasmValType::I32 | WasmValType::F32 => OperandSize::S32,
+            WasmValType::I64 | WasmValType::F64 => OperandSize::S64,
+            WasmValType::V128 => OperandSize::S128,
+            WasmValType::Ref(rt) => {
+                match rt.heap_type {
+                    // TODO: Hardcoded size, assuming 64-bit support only. Once
+                    // Wasmtime supports 32-bit architectures, this will need
+                    // to be updated in such a way that the calculation of the
+                    // OperandSize will depend on the target's  pointer size.
+                    WasmHeapType::Func => OperandSize::S64,
+                    WasmHeapType::Extern => OperandSize::S64,
+                    t => unimplemented!("Support for WasmHeapType: {t}"),
+                }
+            }
         }
     }
 }
diff --git a/winch/docs/testing.md b/winch/docs/testing.md
deleted file mode 100644
index 859db45b73ef..000000000000
--- a/winch/docs/testing.md
+++ /dev/null
@@ -1,63 +0,0 @@
-# Testing Winch
-
-Winch is tested through integration testing using the `winch-filetests` crate
-and manual exploratory testing. A CLI is available to run these tests
-conveniently. To add the `winch-tools` binary to your `PATH`, run `cargo install
---path winch` from the root of `wasmtime`. The CLI provides two commands: `test`
-and `compile`. To see the help text for each command, run `winch-tools test
---help` or `winch-tools compile --help`.
-
-## Integration Testing (`winch-tools test`)
-
-The `test` command will run a suite of tests that validates Winch output for a
-WebAssembly module is consistent with our expectations.
-
-### Running `test`
-
-Running `winch-tools test` will run all integration tests in the
-`winch-filetests` crate. All arguments following two dashes (`--`) will be
-passed directly to `cargo test -p winch-filetests`. This will allow you to
-configure the tests to run based on your requirements. All tests in the
-`winch-filetests` crate get named in the following convention:
-`winch_filetests_${filepath}`. This makes it possible to filter if you don't
-want to run the entire suite.
-
-If the output of Winch changes for a test in a run due to code updates, the test
-will fail and the difference between the two outputs will be shown. If the new
-output is expected, the tests can be re-run with an `WINCH_TEST_BLESS`
-environment variable set to `1`.
-
-### Adding a test
-
-To add new tests, create a `.wat` file in the `winch/filetests/filetests` folder
-in the following format:
-
-```wat
-;;! target = "x86_64"
-(module
-  (func (result i32)
-    (i32.const 42)
-  )
-)
-```
-
-It is encouraged to use folders to organize tests. For example, tests targeting
-the x86_64 architecture can be placed in the `winch/filetests/filetests/x64`.
-
-The first block of comments are a TOML compatible configuration passed to Winch
-during compilation with a `!` at the start of each line. The body of the file
-will be the subject of the test. A final block of comments is reserved for the
-output of the compilation, and it will be used to compare the output of the
-current run with the output of previous runs.
-
-## Manual Exploratory Tests (`winch-tools compile`)
-
-The `compile` command will run Winch for particular architecture against
-provided input file, and print the disassembled output to the console. Only
-`.wat` files are supported.
-
-### Running `compile`
-
-```bash
-winch-tools compile $wat_file --target $target_triple
-```
diff --git a/winch/filetests/Cargo.toml b/winch/filetests/Cargo.toml
deleted file mode 100644
index 94e51b866e8b..000000000000
--- a/winch/filetests/Cargo.toml
+++ /dev/null
@@ -1,23 +0,0 @@
-[package]
-authors = ["The Winch Project Developers"]
-name = "winch-filetests"
-description = "Tests for the Winch compiler based on a set of known valid files"
-license = "Apache-2.0 WITH LLVM-exception"
-repository = "https://github.com/bytecodealliance/wasmtime"
-version = "0.0.0"
-publish = false
-edition.workspace = true
-
-[dependencies]
-winch-test-macros = {workspace = true}
-target-lexicon = { workspace = true }
-winch-codegen = { workspace = true, features = ['all-arch'] }
-wasmtime-environ = { workspace = true }
-anyhow = { workspace = true }
-wat = { workspace = true }
-similar = { workspace = true }
-toml = { workspace = true }
-serde = { workspace = true }
-serde_derive = { workspace = true }
-cranelift-codegen = { workspace = true }
-capstone = { workspace = true }
diff --git a/winch/filetests/build.rs b/winch/filetests/build.rs
deleted file mode 100644
index bd0f62b29d17..000000000000
--- a/winch/filetests/build.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-fn main() {
-    // Ensure that new files in the filetests directory cause a rebuild.
-    println!("cargo:rerun-if-changed=filetests");
-}
diff --git a/winch/filetests/filetests/aarch64/i32_add/const.wat b/winch/filetests/filetests/aarch64/i32_add/const.wat
deleted file mode 100644
index 0d6b402a1684..000000000000
--- a/winch/filetests/filetests/aarch64/i32_add/const.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i32)
-	(i32.const 10)
-	(i32.const 20)
-	(i32.add)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 500180d2             	mov	x16, #0xa
-;;   1c:	 e003102a             	mov	w0, w16
-;;   20:	 00500011             	add	w0, w0, #0x14
-;;   24:	 ff230091             	add	sp, sp, #8
-;;   28:	 fc030091             	mov	x28, sp
-;;   2c:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   30:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i32_add/locals.wat b/winch/filetests/filetests/aarch64/i32_add/locals.wat
deleted file mode 100644
index 26d69e246acb..000000000000
--- a/winch/filetests/filetests/aarch64/i32_add/locals.wat
+++ /dev/null
@@ -1,40 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i32)
-        (local $foo i32)  
-        (local $bar i32)
-
-        (i32.const 10)
-        (local.set $foo)
-
-        (i32.const 20)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        i32.add
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff4300d1             	sub	sp, sp, #0x10
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 100080d2             	mov	x16, #0
-;;   18:	 908300f8             	stur	x16, [x28, #8]
-;;   1c:	 890300f8             	stur	x9, [x28]
-;;   20:	 500180d2             	mov	x16, #0xa
-;;   24:	 e003102a             	mov	w0, w16
-;;   28:	 80c300b8             	stur	w0, [x28, #0xc]
-;;   2c:	 900280d2             	mov	x16, #0x14
-;;   30:	 e003102a             	mov	w0, w16
-;;   34:	 808300b8             	stur	w0, [x28, #8]
-;;   38:	 808340b8             	ldur	w0, [x28, #8]
-;;   3c:	 81c340b8             	ldur	w1, [x28, #0xc]
-;;   40:	 2160200b             	add	w1, w1, w0, uxtx
-;;   44:	 e003012a             	mov	w0, w1
-;;   48:	 ff430091             	add	sp, sp, #0x10
-;;   4c:	 fc030091             	mov	x28, sp
-;;   50:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   54:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i32_add/max.wat b/winch/filetests/filetests/aarch64/i32_add/max.wat
deleted file mode 100644
index aa28ee1c4eff..000000000000
--- a/winch/filetests/filetests/aarch64/i32_add/max.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "aarch64"
-(module
-    (func (result i32)
-	(i32.const 0x7fffffff)
-	(i32.const 1)
-	(i32.add)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 f07b40b2             	orr	x16, xzr, #0x7fffffff
-;;   1c:	 e003102a             	mov	w0, w16
-;;   20:	 00040011             	add	w0, w0, #1
-;;   24:	 ff230091             	add	sp, sp, #8
-;;   28:	 fc030091             	mov	x28, sp
-;;   2c:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   30:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i32_add/max_one.wat b/winch/filetests/filetests/aarch64/i32_add/max_one.wat
deleted file mode 100644
index 2ac6afbcab92..000000000000
--- a/winch/filetests/filetests/aarch64/i32_add/max_one.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i32)
-	(i32.const 0x80000000)
-	(i32.const -1)
-	(i32.add)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 1000b0d2             	mov	x16, #0x80000000
-;;   1c:	 e003102a             	mov	w0, w16
-;;   20:	 f07f40b2             	orr	x16, xzr, #0xffffffff
-;;   24:	 0060300b             	add	w0, w0, w16, uxtx
-;;   28:	 ff230091             	add	sp, sp, #8
-;;   2c:	 fc030091             	mov	x28, sp
-;;   30:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   34:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i32_add/mixed.wat b/winch/filetests/filetests/aarch64/i32_add/mixed.wat
deleted file mode 100644
index e9819e450df9..000000000000
--- a/winch/filetests/filetests/aarch64/i32_add/mixed.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i32)
-        (i32.const -1)
-	(i32.const 1)
-	(i32.add)
-     )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 f07f40b2             	orr	x16, xzr, #0xffffffff
-;;   1c:	 e003102a             	mov	w0, w16
-;;   20:	 00040011             	add	w0, w0, #1
-;;   24:	 ff230091             	add	sp, sp, #8
-;;   28:	 fc030091             	mov	x28, sp
-;;   2c:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   30:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i32_add/params.wat b/winch/filetests/filetests/aarch64/i32_add/params.wat
deleted file mode 100644
index 00b010b76829..000000000000
--- a/winch/filetests/filetests/aarch64/i32_add/params.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (param i32) (param i32) (result i32)
-	(local.get 0)
-	(local.get 1)
-	(i32.add)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff4300d1             	sub	sp, sp, #0x10
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 80c300b8             	stur	w0, [x28, #0xc]
-;;   18:	 818300b8             	stur	w1, [x28, #8]
-;;   1c:	 890300f8             	stur	x9, [x28]
-;;   20:	 808340b8             	ldur	w0, [x28, #8]
-;;   24:	 81c340b8             	ldur	w1, [x28, #0xc]
-;;   28:	 2160200b             	add	w1, w1, w0, uxtx
-;;   2c:	 e003012a             	mov	w0, w1
-;;   30:	 ff430091             	add	sp, sp, #0x10
-;;   34:	 fc030091             	mov	x28, sp
-;;   38:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   3c:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i32_add/signed.wat b/winch/filetests/filetests/aarch64/i32_add/signed.wat
deleted file mode 100644
index 3f92531adca8..000000000000
--- a/winch/filetests/filetests/aarch64/i32_add/signed.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i32)
-        (i32.const -1)
-	(i32.const -1)
-	(i32.add)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 f07f40b2             	orr	x16, xzr, #0xffffffff
-;;   1c:	 e003102a             	mov	w0, w16
-;;   20:	 f07f40b2             	orr	x16, xzr, #0xffffffff
-;;   24:	 0060300b             	add	w0, w0, w16, uxtx
-;;   28:	 ff230091             	add	sp, sp, #8
-;;   2c:	 fc030091             	mov	x28, sp
-;;   30:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   34:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i32_add/unsigned_with_zero.wat b/winch/filetests/filetests/aarch64/i32_add/unsigned_with_zero.wat
deleted file mode 100644
index 21bbc5eb2c32..000000000000
--- a/winch/filetests/filetests/aarch64/i32_add/unsigned_with_zero.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i32)
-        (i32.const 1)
-     	(i32.const 0)
-    	(i32.add)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 300080d2             	mov	x16, #1
-;;   1c:	 e003102a             	mov	w0, w16
-;;   20:	 00000011             	add	w0, w0, #0
-;;   24:	 ff230091             	add	sp, sp, #8
-;;   28:	 fc030091             	mov	x28, sp
-;;   2c:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   30:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i32_mul/const.wat b/winch/filetests/filetests/aarch64/i32_mul/const.wat
deleted file mode 100644
index 7081ddaf4486..000000000000
--- a/winch/filetests/filetests/aarch64/i32_mul/const.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i32)
-	(i32.const 10)
-	(i32.const 20)
-	(i32.mul)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 500180d2             	mov	x16, #0xa
-;;   1c:	 e003102a             	mov	w0, w16
-;;   20:	 900280d2             	mov	x16, #0x14
-;;   24:	 007c101b             	mul	w0, w0, w16
-;;   28:	 ff230091             	add	sp, sp, #8
-;;   2c:	 fc030091             	mov	x28, sp
-;;   30:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   34:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i32_mul/locals.wat b/winch/filetests/filetests/aarch64/i32_mul/locals.wat
deleted file mode 100644
index 2b21c1413ab1..000000000000
--- a/winch/filetests/filetests/aarch64/i32_mul/locals.wat
+++ /dev/null
@@ -1,40 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i32)
-        (local $foo i32)  
-        (local $bar i32)
-
-        (i32.const 10)
-        (local.set $foo)
-
-        (i32.const 20)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        i32.mul
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff4300d1             	sub	sp, sp, #0x10
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 100080d2             	mov	x16, #0
-;;   18:	 908300f8             	stur	x16, [x28, #8]
-;;   1c:	 890300f8             	stur	x9, [x28]
-;;   20:	 500180d2             	mov	x16, #0xa
-;;   24:	 e003102a             	mov	w0, w16
-;;   28:	 80c300b8             	stur	w0, [x28, #0xc]
-;;   2c:	 900280d2             	mov	x16, #0x14
-;;   30:	 e003102a             	mov	w0, w16
-;;   34:	 808300b8             	stur	w0, [x28, #8]
-;;   38:	 808340b8             	ldur	w0, [x28, #8]
-;;   3c:	 81c340b8             	ldur	w1, [x28, #0xc]
-;;   40:	 217c001b             	mul	w1, w1, w0
-;;   44:	 e003012a             	mov	w0, w1
-;;   48:	 ff430091             	add	sp, sp, #0x10
-;;   4c:	 fc030091             	mov	x28, sp
-;;   50:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   54:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i32_mul/max.wat b/winch/filetests/filetests/aarch64/i32_mul/max.wat
deleted file mode 100644
index 28243041d81e..000000000000
--- a/winch/filetests/filetests/aarch64/i32_mul/max.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i32)
-	(i32.const 0x7fffffff)
-	(i32.const -1)
-	(i32.mul)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 f07b40b2             	orr	x16, xzr, #0x7fffffff
-;;   1c:	 e003102a             	mov	w0, w16
-;;   20:	 f07f40b2             	orr	x16, xzr, #0xffffffff
-;;   24:	 007c101b             	mul	w0, w0, w16
-;;   28:	 ff230091             	add	sp, sp, #8
-;;   2c:	 fc030091             	mov	x28, sp
-;;   30:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   34:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i32_mul/max_one.wat b/winch/filetests/filetests/aarch64/i32_mul/max_one.wat
deleted file mode 100644
index e8c9316183bd..000000000000
--- a/winch/filetests/filetests/aarch64/i32_mul/max_one.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i32)
-	(i32.const 0x80000000)
-	(i32.const -1)
-	(i32.mul)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 1000b0d2             	mov	x16, #0x80000000
-;;   1c:	 e003102a             	mov	w0, w16
-;;   20:	 f07f40b2             	orr	x16, xzr, #0xffffffff
-;;   24:	 007c101b             	mul	w0, w0, w16
-;;   28:	 ff230091             	add	sp, sp, #8
-;;   2c:	 fc030091             	mov	x28, sp
-;;   30:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   34:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i32_mul/mixed.wat b/winch/filetests/filetests/aarch64/i32_mul/mixed.wat
deleted file mode 100644
index dc6c1ea4a887..000000000000
--- a/winch/filetests/filetests/aarch64/i32_mul/mixed.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i32)
-        (i32.const -1)
-	(i32.const 1)
-	(i32.mul)
-     )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 f07f40b2             	orr	x16, xzr, #0xffffffff
-;;   1c:	 e003102a             	mov	w0, w16
-;;   20:	 300080d2             	mov	x16, #1
-;;   24:	 007c101b             	mul	w0, w0, w16
-;;   28:	 ff230091             	add	sp, sp, #8
-;;   2c:	 fc030091             	mov	x28, sp
-;;   30:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   34:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i32_mul/params.wat b/winch/filetests/filetests/aarch64/i32_mul/params.wat
deleted file mode 100644
index d9dff7ede1cc..000000000000
--- a/winch/filetests/filetests/aarch64/i32_mul/params.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (param i32) (param i32) (result i32)
-	(local.get 0)
-	(local.get 1)
-	(i32.mul)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff4300d1             	sub	sp, sp, #0x10
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 80c300b8             	stur	w0, [x28, #0xc]
-;;   18:	 818300b8             	stur	w1, [x28, #8]
-;;   1c:	 890300f8             	stur	x9, [x28]
-;;   20:	 808340b8             	ldur	w0, [x28, #8]
-;;   24:	 81c340b8             	ldur	w1, [x28, #0xc]
-;;   28:	 217c001b             	mul	w1, w1, w0
-;;   2c:	 e003012a             	mov	w0, w1
-;;   30:	 ff430091             	add	sp, sp, #0x10
-;;   34:	 fc030091             	mov	x28, sp
-;;   38:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   3c:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i32_mul/signed.wat b/winch/filetests/filetests/aarch64/i32_mul/signed.wat
deleted file mode 100644
index 1f1e1cff663b..000000000000
--- a/winch/filetests/filetests/aarch64/i32_mul/signed.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i32)
-        (i32.const -1)
-	(i32.const -1)
-	(i32.mul)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 f07f40b2             	orr	x16, xzr, #0xffffffff
-;;   1c:	 e003102a             	mov	w0, w16
-;;   20:	 f07f40b2             	orr	x16, xzr, #0xffffffff
-;;   24:	 007c101b             	mul	w0, w0, w16
-;;   28:	 ff230091             	add	sp, sp, #8
-;;   2c:	 fc030091             	mov	x28, sp
-;;   30:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   34:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i32_mul/unsigned_with_zero.wat b/winch/filetests/filetests/aarch64/i32_mul/unsigned_with_zero.wat
deleted file mode 100644
index dd4aabe6d231..000000000000
--- a/winch/filetests/filetests/aarch64/i32_mul/unsigned_with_zero.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i32)
-        (i32.const 1)
-     	(i32.const 0)
-    	(i32.mul)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 300080d2             	mov	x16, #1
-;;   1c:	 e003102a             	mov	w0, w16
-;;   20:	 100080d2             	mov	x16, #0
-;;   24:	 007c101b             	mul	w0, w0, w16
-;;   28:	 ff230091             	add	sp, sp, #8
-;;   2c:	 fc030091             	mov	x28, sp
-;;   30:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   34:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i32_sub/const.wat b/winch/filetests/filetests/aarch64/i32_sub/const.wat
deleted file mode 100644
index 38c1aefe208a..000000000000
--- a/winch/filetests/filetests/aarch64/i32_sub/const.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i32)
-	(i32.const 10)
-	(i32.const 20)
-	(i32.sub)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 500180d2             	mov	x16, #0xa
-;;   1c:	 e003102a             	mov	w0, w16
-;;   20:	 00500051             	sub	w0, w0, #0x14
-;;   24:	 ff230091             	add	sp, sp, #8
-;;   28:	 fc030091             	mov	x28, sp
-;;   2c:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   30:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i32_sub/locals.wat b/winch/filetests/filetests/aarch64/i32_sub/locals.wat
deleted file mode 100644
index 1af753fc4b53..000000000000
--- a/winch/filetests/filetests/aarch64/i32_sub/locals.wat
+++ /dev/null
@@ -1,40 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i32)
-        (local $foo i32)  
-        (local $bar i32)
-
-        (i32.const 10)
-        (local.set $foo)
-
-        (i32.const 20)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        i32.sub
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff4300d1             	sub	sp, sp, #0x10
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 100080d2             	mov	x16, #0
-;;   18:	 908300f8             	stur	x16, [x28, #8]
-;;   1c:	 890300f8             	stur	x9, [x28]
-;;   20:	 500180d2             	mov	x16, #0xa
-;;   24:	 e003102a             	mov	w0, w16
-;;   28:	 80c300b8             	stur	w0, [x28, #0xc]
-;;   2c:	 900280d2             	mov	x16, #0x14
-;;   30:	 e003102a             	mov	w0, w16
-;;   34:	 808300b8             	stur	w0, [x28, #8]
-;;   38:	 808340b8             	ldur	w0, [x28, #8]
-;;   3c:	 81c340b8             	ldur	w1, [x28, #0xc]
-;;   40:	 2160204b             	sub	w1, w1, w0, uxtx
-;;   44:	 e003012a             	mov	w0, w1
-;;   48:	 ff430091             	add	sp, sp, #0x10
-;;   4c:	 fc030091             	mov	x28, sp
-;;   50:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   54:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i32_sub/max.wat b/winch/filetests/filetests/aarch64/i32_sub/max.wat
deleted file mode 100644
index 75e061ff5124..000000000000
--- a/winch/filetests/filetests/aarch64/i32_sub/max.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "aarch64"
-(module
-    (func (result i32)
-	(i32.const 0x7fffffff)
-	(i32.const -1)
-	(i32.sub)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 f07b40b2             	orr	x16, xzr, #0x7fffffff
-;;   1c:	 e003102a             	mov	w0, w16
-;;   20:	 f07f40b2             	orr	x16, xzr, #0xffffffff
-;;   24:	 0060304b             	sub	w0, w0, w16, uxtx
-;;   28:	 ff230091             	add	sp, sp, #8
-;;   2c:	 fc030091             	mov	x28, sp
-;;   30:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   34:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i32_sub/max_one.wat b/winch/filetests/filetests/aarch64/i32_sub/max_one.wat
deleted file mode 100644
index fe9a1440c121..000000000000
--- a/winch/filetests/filetests/aarch64/i32_sub/max_one.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i32)
-	(i32.const 0x80000000)
-	(i32.const 1)
-	(i32.sub)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 1000b0d2             	mov	x16, #0x80000000
-;;   1c:	 e003102a             	mov	w0, w16
-;;   20:	 00040051             	sub	w0, w0, #1
-;;   24:	 ff230091             	add	sp, sp, #8
-;;   28:	 fc030091             	mov	x28, sp
-;;   2c:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   30:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i32_sub/mixed.wat b/winch/filetests/filetests/aarch64/i32_sub/mixed.wat
deleted file mode 100644
index 68f42a2ca013..000000000000
--- a/winch/filetests/filetests/aarch64/i32_sub/mixed.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i32)
-        (i32.const -1)
-	(i32.const 1)
-	(i32.sub)
-     )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 f07f40b2             	orr	x16, xzr, #0xffffffff
-;;   1c:	 e003102a             	mov	w0, w16
-;;   20:	 00040051             	sub	w0, w0, #1
-;;   24:	 ff230091             	add	sp, sp, #8
-;;   28:	 fc030091             	mov	x28, sp
-;;   2c:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   30:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i32_sub/params.wat b/winch/filetests/filetests/aarch64/i32_sub/params.wat
deleted file mode 100644
index ebe91ea52d95..000000000000
--- a/winch/filetests/filetests/aarch64/i32_sub/params.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (param i32) (param i32) (result i32)
-	(local.get 0)
-	(local.get 1)
-	(i32.sub)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff4300d1             	sub	sp, sp, #0x10
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 80c300b8             	stur	w0, [x28, #0xc]
-;;   18:	 818300b8             	stur	w1, [x28, #8]
-;;   1c:	 890300f8             	stur	x9, [x28]
-;;   20:	 808340b8             	ldur	w0, [x28, #8]
-;;   24:	 81c340b8             	ldur	w1, [x28, #0xc]
-;;   28:	 2160204b             	sub	w1, w1, w0, uxtx
-;;   2c:	 e003012a             	mov	w0, w1
-;;   30:	 ff430091             	add	sp, sp, #0x10
-;;   34:	 fc030091             	mov	x28, sp
-;;   38:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   3c:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i32_sub/signed.wat b/winch/filetests/filetests/aarch64/i32_sub/signed.wat
deleted file mode 100644
index d54e87a526e8..000000000000
--- a/winch/filetests/filetests/aarch64/i32_sub/signed.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i32)
-        (i32.const -1)
-	(i32.const -1)
-	(i32.sub)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 f07f40b2             	orr	x16, xzr, #0xffffffff
-;;   1c:	 e003102a             	mov	w0, w16
-;;   20:	 f07f40b2             	orr	x16, xzr, #0xffffffff
-;;   24:	 0060304b             	sub	w0, w0, w16, uxtx
-;;   28:	 ff230091             	add	sp, sp, #8
-;;   2c:	 fc030091             	mov	x28, sp
-;;   30:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   34:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i32_sub/unsigned_with_zero.wat b/winch/filetests/filetests/aarch64/i32_sub/unsigned_with_zero.wat
deleted file mode 100644
index 2a06f9089ae5..000000000000
--- a/winch/filetests/filetests/aarch64/i32_sub/unsigned_with_zero.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i32)
-        (i32.const 1)
-     	(i32.const 0)
-    	(i32.sub)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 300080d2             	mov	x16, #1
-;;   1c:	 e003102a             	mov	w0, w16
-;;   20:	 00000051             	sub	w0, w0, #0
-;;   24:	 ff230091             	add	sp, sp, #8
-;;   28:	 fc030091             	mov	x28, sp
-;;   2c:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   30:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i64_add/const.wat b/winch/filetests/filetests/aarch64/i64_add/const.wat
deleted file mode 100644
index 8e48719b4021..000000000000
--- a/winch/filetests/filetests/aarch64/i64_add/const.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i64)
-	(i64.const 10)
-	(i64.const 20)
-	(i64.add)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 500180d2             	mov	x16, #0xa
-;;   1c:	 e00310aa             	mov	x0, x16
-;;   20:	 00500091             	add	x0, x0, #0x14
-;;   24:	 ff230091             	add	sp, sp, #8
-;;   28:	 fc030091             	mov	x28, sp
-;;   2c:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   30:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i64_add/locals.wat b/winch/filetests/filetests/aarch64/i64_add/locals.wat
deleted file mode 100644
index c972bf80b47b..000000000000
--- a/winch/filetests/filetests/aarch64/i64_add/locals.wat
+++ /dev/null
@@ -1,41 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i64)
-        (local $foo i64)  
-        (local $bar i64)
-
-        (i64.const 10)
-        (local.set $foo)
-
-        (i64.const 20)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        i64.add
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff6300d1             	sub	sp, sp, #0x18
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 100080d2             	mov	x16, #0
-;;   18:	 900301f8             	stur	x16, [x28, #0x10]
-;;   1c:	 908300f8             	stur	x16, [x28, #8]
-;;   20:	 890300f8             	stur	x9, [x28]
-;;   24:	 500180d2             	mov	x16, #0xa
-;;   28:	 e00310aa             	mov	x0, x16
-;;   2c:	 800301f8             	stur	x0, [x28, #0x10]
-;;   30:	 900280d2             	mov	x16, #0x14
-;;   34:	 e00310aa             	mov	x0, x16
-;;   38:	 808300f8             	stur	x0, [x28, #8]
-;;   3c:	 808340f8             	ldur	x0, [x28, #8]
-;;   40:	 810341f8             	ldur	x1, [x28, #0x10]
-;;   44:	 2160208b             	add	x1, x1, x0, uxtx
-;;   48:	 e00301aa             	mov	x0, x1
-;;   4c:	 ff630091             	add	sp, sp, #0x18
-;;   50:	 fc030091             	mov	x28, sp
-;;   54:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   58:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i64_add/max.wat b/winch/filetests/filetests/aarch64/i64_add/max.wat
deleted file mode 100644
index 0050d305b44d..000000000000
--- a/winch/filetests/filetests/aarch64/i64_add/max.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "aarch64"
-(module
-    (func (result i64)
-	(i64.const 1)
-	(i64.const 0x7fffffffffffffff)
-	(i64.add)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 300080d2             	mov	x16, #1
-;;   1c:	 e00310aa             	mov	x0, x16
-;;   20:	 1000f092             	mov	x16, #0x7fffffffffffffff
-;;   24:	 0060308b             	add	x0, x0, x16, uxtx
-;;   28:	 ff230091             	add	sp, sp, #8
-;;   2c:	 fc030091             	mov	x28, sp
-;;   30:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   34:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i64_add/max_one.wat b/winch/filetests/filetests/aarch64/i64_add/max_one.wat
deleted file mode 100644
index d96f87f1da82..000000000000
--- a/winch/filetests/filetests/aarch64/i64_add/max_one.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i64)
-	(i64.const 0x8000000000000000)
-	(i64.const -1)
-	(i64.add)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 1000f0d2             	mov	x16, #-0x8000000000000000
-;;   1c:	 e00310aa             	mov	x0, x16
-;;   20:	 10008092             	mov	x16, #-1
-;;   24:	 0060308b             	add	x0, x0, x16, uxtx
-;;   28:	 ff230091             	add	sp, sp, #8
-;;   2c:	 fc030091             	mov	x28, sp
-;;   30:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   34:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i64_add/mixed.wat b/winch/filetests/filetests/aarch64/i64_add/mixed.wat
deleted file mode 100644
index 630527270b61..000000000000
--- a/winch/filetests/filetests/aarch64/i64_add/mixed.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i64)
-        (i64.const -1)
-	(i64.const 1)
-	(i64.add)
-     )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 10008092             	mov	x16, #-1
-;;   1c:	 e00310aa             	mov	x0, x16
-;;   20:	 00040091             	add	x0, x0, #1
-;;   24:	 ff230091             	add	sp, sp, #8
-;;   28:	 fc030091             	mov	x28, sp
-;;   2c:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   30:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i64_add/params.wat b/winch/filetests/filetests/aarch64/i64_add/params.wat
deleted file mode 100644
index f12c204ee55d..000000000000
--- a/winch/filetests/filetests/aarch64/i64_add/params.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (param i64) (param i64) (result i64)
-	(local.get 0)
-	(local.get 1)
-	(i64.add)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff6300d1             	sub	sp, sp, #0x18
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 800301f8             	stur	x0, [x28, #0x10]
-;;   18:	 818300f8             	stur	x1, [x28, #8]
-;;   1c:	 890300f8             	stur	x9, [x28]
-;;   20:	 808340f8             	ldur	x0, [x28, #8]
-;;   24:	 810341f8             	ldur	x1, [x28, #0x10]
-;;   28:	 2160208b             	add	x1, x1, x0, uxtx
-;;   2c:	 e00301aa             	mov	x0, x1
-;;   30:	 ff630091             	add	sp, sp, #0x18
-;;   34:	 fc030091             	mov	x28, sp
-;;   38:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   3c:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i64_add/signed.wat b/winch/filetests/filetests/aarch64/i64_add/signed.wat
deleted file mode 100644
index 6e3dae7fa6dc..000000000000
--- a/winch/filetests/filetests/aarch64/i64_add/signed.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i64)
-        (i64.const -1)
-	(i64.const -1)
-	(i64.add)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 10008092             	mov	x16, #-1
-;;   1c:	 e00310aa             	mov	x0, x16
-;;   20:	 10008092             	mov	x16, #-1
-;;   24:	 0060308b             	add	x0, x0, x16, uxtx
-;;   28:	 ff230091             	add	sp, sp, #8
-;;   2c:	 fc030091             	mov	x28, sp
-;;   30:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   34:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i64_add/unsigned_with_zero.wat b/winch/filetests/filetests/aarch64/i64_add/unsigned_with_zero.wat
deleted file mode 100644
index 2e3bcfee1987..000000000000
--- a/winch/filetests/filetests/aarch64/i64_add/unsigned_with_zero.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i64)
-        (i64.const 1)
-     	(i64.const 0)
-    	(i64.add)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 300080d2             	mov	x16, #1
-;;   1c:	 e00310aa             	mov	x0, x16
-;;   20:	 00000091             	add	x0, x0, #0
-;;   24:	 ff230091             	add	sp, sp, #8
-;;   28:	 fc030091             	mov	x28, sp
-;;   2c:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   30:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i64_mul/const.wat b/winch/filetests/filetests/aarch64/i64_mul/const.wat
deleted file mode 100644
index 9ac1b0c24f0d..000000000000
--- a/winch/filetests/filetests/aarch64/i64_mul/const.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i64)
-	(i64.const 10)
-	(i64.const 20)
-	(i64.mul)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 500180d2             	mov	x16, #0xa
-;;   1c:	 e00310aa             	mov	x0, x16
-;;   20:	 900280d2             	mov	x16, #0x14
-;;   24:	 007c109b             	mul	x0, x0, x16
-;;   28:	 ff230091             	add	sp, sp, #8
-;;   2c:	 fc030091             	mov	x28, sp
-;;   30:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   34:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i64_mul/locals.wat b/winch/filetests/filetests/aarch64/i64_mul/locals.wat
deleted file mode 100644
index 1e9d5b36580f..000000000000
--- a/winch/filetests/filetests/aarch64/i64_mul/locals.wat
+++ /dev/null
@@ -1,41 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i64)
-        (local $foo i64)  
-        (local $bar i64)
-
-        (i64.const 10)
-        (local.set $foo)
-
-        (i64.const 20)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        i64.mul
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff6300d1             	sub	sp, sp, #0x18
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 100080d2             	mov	x16, #0
-;;   18:	 900301f8             	stur	x16, [x28, #0x10]
-;;   1c:	 908300f8             	stur	x16, [x28, #8]
-;;   20:	 890300f8             	stur	x9, [x28]
-;;   24:	 500180d2             	mov	x16, #0xa
-;;   28:	 e00310aa             	mov	x0, x16
-;;   2c:	 800301f8             	stur	x0, [x28, #0x10]
-;;   30:	 900280d2             	mov	x16, #0x14
-;;   34:	 e00310aa             	mov	x0, x16
-;;   38:	 808300f8             	stur	x0, [x28, #8]
-;;   3c:	 808340f8             	ldur	x0, [x28, #8]
-;;   40:	 810341f8             	ldur	x1, [x28, #0x10]
-;;   44:	 217c009b             	mul	x1, x1, x0
-;;   48:	 e00301aa             	mov	x0, x1
-;;   4c:	 ff630091             	add	sp, sp, #0x18
-;;   50:	 fc030091             	mov	x28, sp
-;;   54:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   58:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i64_mul/max.wat b/winch/filetests/filetests/aarch64/i64_mul/max.wat
deleted file mode 100644
index 4d654f0b683f..000000000000
--- a/winch/filetests/filetests/aarch64/i64_mul/max.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "aarch64"
-(module
-    (func (result i64)
-	(i64.const 0x7fffffffffffffff)
-	(i64.const -1)
-	(i64.mul)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 1000f092             	mov	x16, #0x7fffffffffffffff
-;;   1c:	 e00310aa             	mov	x0, x16
-;;   20:	 10008092             	mov	x16, #-1
-;;   24:	 007c109b             	mul	x0, x0, x16
-;;   28:	 ff230091             	add	sp, sp, #8
-;;   2c:	 fc030091             	mov	x28, sp
-;;   30:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   34:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i64_mul/max_one.wat b/winch/filetests/filetests/aarch64/i64_mul/max_one.wat
deleted file mode 100644
index df0221f80ea3..000000000000
--- a/winch/filetests/filetests/aarch64/i64_mul/max_one.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i64)
-	(i64.const 0x8000000000000000)
-	(i64.const -1)
-	(i64.mul)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 1000f0d2             	mov	x16, #-0x8000000000000000
-;;   1c:	 e00310aa             	mov	x0, x16
-;;   20:	 10008092             	mov	x16, #-1
-;;   24:	 007c109b             	mul	x0, x0, x16
-;;   28:	 ff230091             	add	sp, sp, #8
-;;   2c:	 fc030091             	mov	x28, sp
-;;   30:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   34:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i64_mul/mixed.wat b/winch/filetests/filetests/aarch64/i64_mul/mixed.wat
deleted file mode 100644
index d3499b42ae87..000000000000
--- a/winch/filetests/filetests/aarch64/i64_mul/mixed.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i64)
-        (i64.const -1)
-	(i64.const 1)
-	(i64.mul)
-     )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 10008092             	mov	x16, #-1
-;;   1c:	 e00310aa             	mov	x0, x16
-;;   20:	 300080d2             	mov	x16, #1
-;;   24:	 007c109b             	mul	x0, x0, x16
-;;   28:	 ff230091             	add	sp, sp, #8
-;;   2c:	 fc030091             	mov	x28, sp
-;;   30:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   34:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i64_mul/params.wat b/winch/filetests/filetests/aarch64/i64_mul/params.wat
deleted file mode 100644
index f64707afcd8e..000000000000
--- a/winch/filetests/filetests/aarch64/i64_mul/params.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (param i64) (param i64) (result i64)
-	(local.get 0)
-	(local.get 1)
-	(i64.mul)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff6300d1             	sub	sp, sp, #0x18
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 800301f8             	stur	x0, [x28, #0x10]
-;;   18:	 818300f8             	stur	x1, [x28, #8]
-;;   1c:	 890300f8             	stur	x9, [x28]
-;;   20:	 808340f8             	ldur	x0, [x28, #8]
-;;   24:	 810341f8             	ldur	x1, [x28, #0x10]
-;;   28:	 217c009b             	mul	x1, x1, x0
-;;   2c:	 e00301aa             	mov	x0, x1
-;;   30:	 ff630091             	add	sp, sp, #0x18
-;;   34:	 fc030091             	mov	x28, sp
-;;   38:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   3c:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i64_mul/signed.wat b/winch/filetests/filetests/aarch64/i64_mul/signed.wat
deleted file mode 100644
index 000c56863c4f..000000000000
--- a/winch/filetests/filetests/aarch64/i64_mul/signed.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i64)
-        (i64.const -1)
-	(i64.const -1)
-	(i64.mul)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 10008092             	mov	x16, #-1
-;;   1c:	 e00310aa             	mov	x0, x16
-;;   20:	 10008092             	mov	x16, #-1
-;;   24:	 007c109b             	mul	x0, x0, x16
-;;   28:	 ff230091             	add	sp, sp, #8
-;;   2c:	 fc030091             	mov	x28, sp
-;;   30:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   34:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i64_mul/unsigned_with_zero.wat b/winch/filetests/filetests/aarch64/i64_mul/unsigned_with_zero.wat
deleted file mode 100644
index 887db36f08f9..000000000000
--- a/winch/filetests/filetests/aarch64/i64_mul/unsigned_with_zero.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i64)
-        (i64.const 1)
-     	(i64.const 0)
-    	(i64.mul)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 300080d2             	mov	x16, #1
-;;   1c:	 e00310aa             	mov	x0, x16
-;;   20:	 100080d2             	mov	x16, #0
-;;   24:	 007c109b             	mul	x0, x0, x16
-;;   28:	 ff230091             	add	sp, sp, #8
-;;   2c:	 fc030091             	mov	x28, sp
-;;   30:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   34:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i64_sub/const.wat b/winch/filetests/filetests/aarch64/i64_sub/const.wat
deleted file mode 100644
index 8921be4f66a6..000000000000
--- a/winch/filetests/filetests/aarch64/i64_sub/const.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i64)
-	(i64.const 10)
-	(i64.const 20)
-	(i64.sub)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 500180d2             	mov	x16, #0xa
-;;   1c:	 e00310aa             	mov	x0, x16
-;;   20:	 005000d1             	sub	x0, x0, #0x14
-;;   24:	 ff230091             	add	sp, sp, #8
-;;   28:	 fc030091             	mov	x28, sp
-;;   2c:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   30:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i64_sub/locals.wat b/winch/filetests/filetests/aarch64/i64_sub/locals.wat
deleted file mode 100644
index b9093cd61e5c..000000000000
--- a/winch/filetests/filetests/aarch64/i64_sub/locals.wat
+++ /dev/null
@@ -1,41 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i64)
-        (local $foo i64)  
-        (local $bar i64)
-
-        (i64.const 10)
-        (local.set $foo)
-
-        (i64.const 20)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        i64.sub
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff6300d1             	sub	sp, sp, #0x18
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 100080d2             	mov	x16, #0
-;;   18:	 900301f8             	stur	x16, [x28, #0x10]
-;;   1c:	 908300f8             	stur	x16, [x28, #8]
-;;   20:	 890300f8             	stur	x9, [x28]
-;;   24:	 500180d2             	mov	x16, #0xa
-;;   28:	 e00310aa             	mov	x0, x16
-;;   2c:	 800301f8             	stur	x0, [x28, #0x10]
-;;   30:	 900280d2             	mov	x16, #0x14
-;;   34:	 e00310aa             	mov	x0, x16
-;;   38:	 808300f8             	stur	x0, [x28, #8]
-;;   3c:	 808340f8             	ldur	x0, [x28, #8]
-;;   40:	 810341f8             	ldur	x1, [x28, #0x10]
-;;   44:	 216020cb             	sub	x1, x1, x0, uxtx
-;;   48:	 e00301aa             	mov	x0, x1
-;;   4c:	 ff630091             	add	sp, sp, #0x18
-;;   50:	 fc030091             	mov	x28, sp
-;;   54:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   58:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i64_sub/max.wat b/winch/filetests/filetests/aarch64/i64_sub/max.wat
deleted file mode 100644
index 21aaa8b3ffb5..000000000000
--- a/winch/filetests/filetests/aarch64/i64_sub/max.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "aarch64"
-(module
-    (func (result i64)
-	(i64.const 0x7fffffffffffffff)
-	(i64.const -1)
-	(i64.sub)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 1000f092             	mov	x16, #0x7fffffffffffffff
-;;   1c:	 e00310aa             	mov	x0, x16
-;;   20:	 10008092             	mov	x16, #-1
-;;   24:	 006030cb             	sub	x0, x0, x16, uxtx
-;;   28:	 ff230091             	add	sp, sp, #8
-;;   2c:	 fc030091             	mov	x28, sp
-;;   30:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   34:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i64_sub/max_one.wat b/winch/filetests/filetests/aarch64/i64_sub/max_one.wat
deleted file mode 100644
index ec4e23e2b257..000000000000
--- a/winch/filetests/filetests/aarch64/i64_sub/max_one.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i64)
-	(i64.const 0x8000000000000000)
-	(i64.const 1)
-	(i64.sub)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 1000f0d2             	mov	x16, #-0x8000000000000000
-;;   1c:	 e00310aa             	mov	x0, x16
-;;   20:	 000400d1             	sub	x0, x0, #1
-;;   24:	 ff230091             	add	sp, sp, #8
-;;   28:	 fc030091             	mov	x28, sp
-;;   2c:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   30:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i64_sub/mixed.wat b/winch/filetests/filetests/aarch64/i64_sub/mixed.wat
deleted file mode 100644
index de223c78b870..000000000000
--- a/winch/filetests/filetests/aarch64/i64_sub/mixed.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i64)
-        (i64.const -1)
-	(i64.const 1)
-	(i64.sub)
-     )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 10008092             	mov	x16, #-1
-;;   1c:	 e00310aa             	mov	x0, x16
-;;   20:	 000400d1             	sub	x0, x0, #1
-;;   24:	 ff230091             	add	sp, sp, #8
-;;   28:	 fc030091             	mov	x28, sp
-;;   2c:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   30:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i64_sub/params.wat b/winch/filetests/filetests/aarch64/i64_sub/params.wat
deleted file mode 100644
index df3509b0b82b..000000000000
--- a/winch/filetests/filetests/aarch64/i64_sub/params.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (param i64) (param i64) (result i64)
-	(local.get 0)
-	(local.get 1)
-	(i64.sub)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff6300d1             	sub	sp, sp, #0x18
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 800301f8             	stur	x0, [x28, #0x10]
-;;   18:	 818300f8             	stur	x1, [x28, #8]
-;;   1c:	 890300f8             	stur	x9, [x28]
-;;   20:	 808340f8             	ldur	x0, [x28, #8]
-;;   24:	 810341f8             	ldur	x1, [x28, #0x10]
-;;   28:	 216020cb             	sub	x1, x1, x0, uxtx
-;;   2c:	 e00301aa             	mov	x0, x1
-;;   30:	 ff630091             	add	sp, sp, #0x18
-;;   34:	 fc030091             	mov	x28, sp
-;;   38:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   3c:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i64_sub/signed.wat b/winch/filetests/filetests/aarch64/i64_sub/signed.wat
deleted file mode 100644
index 65ffc66c3082..000000000000
--- a/winch/filetests/filetests/aarch64/i64_sub/signed.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i64)
-        (i64.const -1)
-	(i64.const -1)
-	(i64.sub)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 10008092             	mov	x16, #-1
-;;   1c:	 e00310aa             	mov	x0, x16
-;;   20:	 10008092             	mov	x16, #-1
-;;   24:	 006030cb             	sub	x0, x0, x16, uxtx
-;;   28:	 ff230091             	add	sp, sp, #8
-;;   2c:	 fc030091             	mov	x28, sp
-;;   30:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   34:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/i64_sub/unsigned_with_zero.wat b/winch/filetests/filetests/aarch64/i64_sub/unsigned_with_zero.wat
deleted file mode 100644
index 35d2acf1427b..000000000000
--- a/winch/filetests/filetests/aarch64/i64_sub/unsigned_with_zero.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func (result i64)
-        (i64.const 1)
-     	(i64.const 0)
-    	(i64.sub)
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 300080d2             	mov	x16, #1
-;;   1c:	 e00310aa             	mov	x0, x16
-;;   20:	 000000d1             	sub	x0, x0, #0
-;;   24:	 ff230091             	add	sp, sp, #8
-;;   28:	 fc030091             	mov	x28, sp
-;;   2c:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   30:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/aarch64/nop/nop.wat b/winch/filetests/filetests/aarch64/nop/nop.wat
deleted file mode 100644
index c1f0d0755511..000000000000
--- a/winch/filetests/filetests/aarch64/nop/nop.wat
+++ /dev/null
@@ -1,17 +0,0 @@
-;;! target = "aarch64"
-
-(module
-    (func
-        nop
-    )
-)
-;;    0:	 fd7bbfa9             	stp	x29, x30, [sp, #-0x10]!
-;;    4:	 fd030091             	mov	x29, sp
-;;    8:	 fc030091             	mov	x28, sp
-;;    c:	 ff2300d1             	sub	sp, sp, #8
-;;   10:	 fc030091             	mov	x28, sp
-;;   14:	 890300f8             	stur	x9, [x28]
-;;   18:	 ff230091             	add	sp, sp, #8
-;;   1c:	 fc030091             	mov	x28, sp
-;;   20:	 fd7bc1a8             	ldp	x29, x30, [sp], #0x10
-;;   24:	 c0035fd6             	ret	
diff --git a/winch/filetests/filetests/x64/block/as_if_cond.wat b/winch/filetests/filetests/x64/block/as_if_cond.wat
deleted file mode 100644
index e53df8ed817f..000000000000
--- a/winch/filetests/filetests/x64/block/as_if_cond.wat
+++ /dev/null
@@ -1,30 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func $dummy)
-  (func (export "as-if-condition")
-   (block (result i32) (i32.const 1)) (if (then (call $dummy)))
-  )
-)
-  
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 85c0                 	test	eax, eax
-;;   13:	 0f840d000000         	je	0x26
-;;   19:	 4883ec08             	sub	rsp, 8
-;;   1d:	 e800000000           	call	0x22
-;;   22:	 4883c408             	add	rsp, 8
-;;   26:	 4883c408             	add	rsp, 8
-;;   2a:	 5d                   	pop	rbp
-;;   2b:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/block/as_if_else.wat b/winch/filetests/filetests/x64/block/as_if_else.wat
deleted file mode 100644
index e1d85ab4ee6d..000000000000
--- a/winch/filetests/filetests/x64/block/as_if_else.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func (export "as-if-else") (result i32)
-      (if (result i32) (i32.const 1) (then (i32.const 2)) (else (block (result i32) (i32.const 1))))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 85c0                 	test	eax, eax
-;;   13:	 0f840a000000         	je	0x23
-;;   19:	 b802000000           	mov	eax, 2
-;;   1e:	 e905000000           	jmp	0x28
-;;   23:	 b801000000           	mov	eax, 1
-;;   28:	 4883c408             	add	rsp, 8
-;;   2c:	 5d                   	pop	rbp
-;;   2d:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/block/as_if_then.wat b/winch/filetests/filetests/x64/block/as_if_then.wat
deleted file mode 100644
index 065f37f2bc3d..000000000000
--- a/winch/filetests/filetests/x64/block/as_if_then.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-;;! target = "x86_64"
- (module
-   (func (export "as-if-then") (result i32)
-      (if (result i32) (i32.const 1) (then (block (result i32) (i32.const 1))) (else (i32.const 2)))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 85c0                 	test	eax, eax
-;;   13:	 0f840a000000         	je	0x23
-;;   19:	 b801000000           	mov	eax, 1
-;;   1e:	 e905000000           	jmp	0x28
-;;   23:	 b802000000           	mov	eax, 2
-;;   28:	 4883c408             	add	rsp, 8
-;;   2c:	 5d                   	pop	rbp
-;;   2d:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/block/deep.wat b/winch/filetests/filetests/x64/block/deep.wat
deleted file mode 100644
index 50f596d0d6ab..000000000000
--- a/winch/filetests/filetests/x64/block/deep.wat
+++ /dev/null
@@ -1,65 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func $dummy)
-  (func (export "deep") (result i32)
-    (block (result i32) (block (result i32)
-      (block (result i32) (block (result i32)
-        (block (result i32) (block (result i32)
-          (block (result i32) (block (result i32)
-            (block (result i32) (block (result i32)
-              (block (result i32) (block (result i32)
-                (block (result i32) (block (result i32)
-                  (block (result i32) (block (result i32)
-                    (block (result i32) (block (result i32)
-                      (block (result i32) (block (result i32)
-                        (block (result i32) (block (result i32)
-                          (block (result i32) (block (result i32)
-                            (block (result i32) (block (result i32)
-                              (block (result i32) (block (result i32)
-                                (block (result i32) (block (result i32)
-                                  (block (result i32) (block (result i32)
-                                    (block (result i32) (block (result i32)
-                                      (block (result i32) (block (result i32)
-                                        (block (result i32) (block (result i32)
-                                          (call $dummy) (i32.const 150)
-                                        ))
-                                      ))
-                                    ))
-                                  ))
-                                ))
-                              ))
-                            ))
-                          ))
-                        ))
-                      ))
-                    ))
-                  ))
-                ))
-              ))
-            ))
-          ))
-        ))
-      ))
-    ))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 b896000000           	mov	eax, 0x96
-;;   1e:	 4883c408             	add	rsp, 8
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/block/empty.wat b/winch/filetests/filetests/x64/block/empty.wat
deleted file mode 100644
index 685dcf14d87b..000000000000
--- a/winch/filetests/filetests/x64/block/empty.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func $dummy)
-
-  (func (export "empty")
-    (block)
-    (block $l)
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/block/nested.wat b/winch/filetests/filetests/x64/block/nested.wat
deleted file mode 100644
index 9007dd2898e0..000000000000
--- a/winch/filetests/filetests/x64/block/nested.wat
+++ /dev/null
@@ -1,33 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-
-  (func (export "nested") (result i32)
-    (block (result i32)
-      (block (call $dummy) (block) (nop))
-      (block (result i32) (call $dummy) (i32.const 9))
-    )
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 4883ec08             	sub	rsp, 8
-;;   1d:	 e800000000           	call	0x22
-;;   22:	 4883c408             	add	rsp, 8
-;;   26:	 b809000000           	mov	eax, 9
-;;   2b:	 4883c408             	add	rsp, 8
-;;   2f:	 5d                   	pop	rbp
-;;   30:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/block/singular.wat b/winch/filetests/filetests/x64/block/singular.wat
deleted file mode 100644
index a9c271ce957c..000000000000
--- a/winch/filetests/filetests/x64/block/singular.wat
+++ /dev/null
@@ -1,16 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func (export "singular") (result i32)
-    (block (nop))
-    (block (result i32) (i32.const 7))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b807000000           	mov	eax, 7
-;;   11:	 4883c408             	add	rsp, 8
-;;   15:	 5d                   	pop	rbp
-;;   16:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br/as_block_first.wat b/winch/filetests/filetests/x64/br/as_block_first.wat
deleted file mode 100644
index 155ddd3ce040..000000000000
--- a/winch/filetests/filetests/x64/br/as_block_first.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func $dummy)
-  (func (export "as-block-first")
-    (block (br 0) (call $dummy))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br/as_block_last.wat b/winch/filetests/filetests/x64/br/as_block_last.wat
deleted file mode 100644
index 98c097184c11..000000000000
--- a/winch/filetests/filetests/x64/br/as_block_last.wat
+++ /dev/null
@@ -1,26 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func $dummy)
-  (func (export "as-block-last")
-    (block (nop) (call $dummy) (br 0))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 4883c408             	add	rsp, 8
-;;   1d:	 5d                   	pop	rbp
-;;   1e:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br/as_block_mid.wat b/winch/filetests/filetests/x64/br/as_block_mid.wat
deleted file mode 100644
index 9bd4043cfd7f..000000000000
--- a/winch/filetests/filetests/x64/br/as_block_mid.wat
+++ /dev/null
@@ -1,26 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func $dummy)
-  (func (export "as-block-mid")
-    (block (call $dummy) (br 0) (call $dummy))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 4883c408             	add	rsp, 8
-;;   1d:	 5d                   	pop	rbp
-;;   1e:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br/as_block_value.wat b/winch/filetests/filetests/x64/br/as_block_value.wat
deleted file mode 100644
index aeecd54c2682..000000000000
--- a/winch/filetests/filetests/x64/br/as_block_value.wat
+++ /dev/null
@@ -1,27 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func $dummy)
-  (func (export "as-block-value") (result i32)
-    (block (result i32) (nop) (call $dummy) (br 0 (i32.const 2)))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 b802000000           	mov	eax, 2
-;;   1e:	 4883c408             	add	rsp, 8
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br/as_br_if_cond.wat b/winch/filetests/filetests/x64/br/as_br_if_cond.wat
deleted file mode 100644
index 532cfb1dfbc8..000000000000
--- a/winch/filetests/filetests/x64/br/as_br_if_cond.wat
+++ /dev/null
@@ -1,13 +0,0 @@
-;;! target = "x86_64"
-(module
-    (func (export "as-br_if-cond")
-    (block (br_if 0 (br 0)))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br/as_br_value.wat b/winch/filetests/filetests/x64/br/as_br_value.wat
deleted file mode 100644
index 31023d82c1d3..000000000000
--- a/winch/filetests/filetests/x64/br/as_br_value.wat
+++ /dev/null
@@ -1,14 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func (export "as-br-value") (result i32)
-    (block (result i32) (br 0 (br 0 (i32.const 9))))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b809000000           	mov	eax, 9
-;;   11:	 4883c408             	add	rsp, 8
-;;   15:	 5d                   	pop	rbp
-;;   16:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br/as_call_all.wat b/winch/filetests/filetests/x64/br/as_call_all.wat
deleted file mode 100644
index e48be38b5749..000000000000
--- a/winch/filetests/filetests/x64/br/as_call_all.wat
+++ /dev/null
@@ -1,27 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
-  (func (export "as-call-all") (result i32)
-    (block (result i32) (call $f (br 0 (i32.const 15))))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 897c2414             	mov	dword ptr [rsp + 0x14], edi
-;;    c:	 89742410             	mov	dword ptr [rsp + 0x10], esi
-;;   10:	 8954240c             	mov	dword ptr [rsp + 0xc], edx
-;;   14:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   19:	 b8ffffffff           	mov	eax, 0xffffffff
-;;   1e:	 4883c418             	add	rsp, 0x18
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b80f000000           	mov	eax, 0xf
-;;   11:	 4883c408             	add	rsp, 8
-;;   15:	 5d                   	pop	rbp
-;;   16:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br/as_call_first.wat b/winch/filetests/filetests/x64/br/as_call_first.wat
deleted file mode 100644
index 8c48d367a093..000000000000
--- a/winch/filetests/filetests/x64/br/as_call_first.wat
+++ /dev/null
@@ -1,30 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
-  (func (export "as-call-first") (result i32)
-    (block (result i32)
-      (call $f (br 0 (i32.const 12)) (i32.const 2) (i32.const 3))
-    )
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 897c2414             	mov	dword ptr [rsp + 0x14], edi
-;;    c:	 89742410             	mov	dword ptr [rsp + 0x10], esi
-;;   10:	 8954240c             	mov	dword ptr [rsp + 0xc], edx
-;;   14:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   19:	 b8ffffffff           	mov	eax, 0xffffffff
-;;   1e:	 4883c418             	add	rsp, 0x18
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b80c000000           	mov	eax, 0xc
-;;   11:	 4883c408             	add	rsp, 8
-;;   15:	 5d                   	pop	rbp
-;;   16:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br/as_call_last.wat b/winch/filetests/filetests/x64/br/as_call_last.wat
deleted file mode 100644
index 5d2a168638d7..000000000000
--- a/winch/filetests/filetests/x64/br/as_call_last.wat
+++ /dev/null
@@ -1,29 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
-  (func (export "as-call-last") (result i32)
-    (block (result i32)
-      (call $f (i32.const 1) (i32.const 2) (br 0 (i32.const 14)))
-    )
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 897c2414             	mov	dword ptr [rsp + 0x14], edi
-;;    c:	 89742410             	mov	dword ptr [rsp + 0x10], esi
-;;   10:	 8954240c             	mov	dword ptr [rsp + 0xc], edx
-;;   14:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   19:	 b8ffffffff           	mov	eax, 0xffffffff
-;;   1e:	 4883c418             	add	rsp, 0x18
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b80e000000           	mov	eax, 0xe
-;;   11:	 4883c408             	add	rsp, 8
-;;   15:	 5d                   	pop	rbp
-;;   16:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br/as_call_mid.wat b/winch/filetests/filetests/x64/br/as_call_mid.wat
deleted file mode 100644
index c7c9d721a163..000000000000
--- a/winch/filetests/filetests/x64/br/as_call_mid.wat
+++ /dev/null
@@ -1,30 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
-  (func (export "as-call-mid") (result i32)
-    (block (result i32)
-      (call $f (i32.const 1) (br 0 (i32.const 13)) (i32.const 3))
-    )
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 897c2414             	mov	dword ptr [rsp + 0x14], edi
-;;    c:	 89742410             	mov	dword ptr [rsp + 0x10], esi
-;;   10:	 8954240c             	mov	dword ptr [rsp + 0xc], edx
-;;   14:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   19:	 b8ffffffff           	mov	eax, 0xffffffff
-;;   1e:	 4883c418             	add	rsp, 0x18
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b80d000000           	mov	eax, 0xd
-;;   11:	 4883c408             	add	rsp, 8
-;;   15:	 5d                   	pop	rbp
-;;   16:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br/as_if_cond.wat b/winch/filetests/filetests/x64/br/as_if_cond.wat
deleted file mode 100644
index 6d069439fc8d..000000000000
--- a/winch/filetests/filetests/x64/br/as_if_cond.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func (export "as-if-cond") (result i32)
-    (block (result i32)
-      (if (result i32) (br 0 (i32.const 2))
-        (then (i32.const 0))
-        (else (i32.const 1))
-      )
-    )
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b802000000           	mov	eax, 2
-;;   11:	 4883c408             	add	rsp, 8
-;;   15:	 5d                   	pop	rbp
-;;   16:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br/as_if_else.wat b/winch/filetests/filetests/x64/br/as_if_else.wat
deleted file mode 100644
index 691b945da2ed..000000000000
--- a/winch/filetests/filetests/x64/br/as_if_else.wat
+++ /dev/null
@@ -1,26 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func (export "as-if-else") (param i32 i32) (result i32)
-    (block (result i32)
-      (if (result i32) (local.get 0)
-        (then (local.get 1))
-        (else (br 1 (i32.const 4)))
-      )
-    )
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   18:	 85c0                 	test	eax, eax
-;;   1a:	 0f8409000000         	je	0x29
-;;   20:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   24:	 e905000000           	jmp	0x2e
-;;   29:	 b804000000           	mov	eax, 4
-;;   2e:	 4883c410             	add	rsp, 0x10
-;;   32:	 5d                   	pop	rbp
-;;   33:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br/as_if_then.wat b/winch/filetests/filetests/x64/br/as_if_then.wat
deleted file mode 100644
index 81199c52569f..000000000000
--- a/winch/filetests/filetests/x64/br/as_if_then.wat
+++ /dev/null
@@ -1,26 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func (export "as-if-then") (param i32 i32) (result i32)
-    (block (result i32)
-      (if (result i32) (local.get 0)
-        (then (br 1 (i32.const 3)))
-        (else (local.get 1))
-      )
-    )
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   18:	 85c0                 	test	eax, eax
-;;   1a:	 0f840a000000         	je	0x2a
-;;   20:	 b803000000           	mov	eax, 3
-;;   25:	 e904000000           	jmp	0x2e
-;;   2a:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   2e:	 4883c410             	add	rsp, 0x10
-;;   32:	 5d                   	pop	rbp
-;;   33:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br/as_loop_first.wat b/winch/filetests/filetests/x64/br/as_loop_first.wat
deleted file mode 100644
index 8ddad54267fd..000000000000
--- a/winch/filetests/filetests/x64/br/as_loop_first.wat
+++ /dev/null
@@ -1,15 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func (export "as-loop-first") (result i32)
-    (block (result i32) (loop (result i32) (br 1 (i32.const 3)) (i32.const 2)))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b803000000           	mov	eax, 3
-;;   11:	 4883c408             	add	rsp, 8
-;;   15:	 5d                   	pop	rbp
-;;   16:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br/as_loop_last.wat b/winch/filetests/filetests/x64/br/as_loop_last.wat
deleted file mode 100644
index 6e1eaa990445..000000000000
--- a/winch/filetests/filetests/x64/br/as_loop_last.wat
+++ /dev/null
@@ -1,28 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "as-loop-last") (result i32)
-    (block (result i32)
-      (loop (result i32) (nop) (call $dummy) (br 1 (i32.const 5)))
-    )
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 b805000000           	mov	eax, 5
-;;   1e:	 4883c408             	add	rsp, 8
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br/as_loop_mid.wat b/winch/filetests/filetests/x64/br/as_loop_mid.wat
deleted file mode 100644
index 90c011c9cba1..000000000000
--- a/winch/filetests/filetests/x64/br/as_loop_mid.wat
+++ /dev/null
@@ -1,29 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func $dummy)
-  (func (export "as-loop-mid") (result i32)
-    (block (result i32)
-      (loop (result i32) (call $dummy) (br 1 (i32.const 4)) (i32.const 2))
-    )
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 b804000000           	mov	eax, 4
-;;   1e:	 4883c408             	add	rsp, 8
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br_if/as_block_last.wat b/winch/filetests/filetests/x64/br_if/as_block_last.wat
deleted file mode 100644
index d986155ea5c5..000000000000
--- a/winch/filetests/filetests/x64/br_if/as_block_last.wat
+++ /dev/null
@@ -1,28 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "as-block-last") (param i32)
-    (block (call $dummy) (call $dummy) (br_if 0 (local.get 0)))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   11:	 e800000000           	call	0x16
-;;   16:	 e800000000           	call	0x1b
-;;   1b:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   1f:	 85c0                 	test	eax, eax
-;;   21:	 0f8500000000         	jne	0x27
-;;   27:	 4883c410             	add	rsp, 0x10
-;;   2b:	 5d                   	pop	rbp
-;;   2c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br_if/as_block_last_value.wat b/winch/filetests/filetests/x64/br_if/as_block_last_value.wat
deleted file mode 100644
index a88883adf448..000000000000
--- a/winch/filetests/filetests/x64/br_if/as_block_last_value.wat
+++ /dev/null
@@ -1,31 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "as-block-last-value") (param i32) (result i32)
-    (block (result i32)
-      (call $dummy) (call $dummy) (br_if 0 (i32.const 11) (local.get 0))
-    )
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   11:	 e800000000           	call	0x16
-;;   16:	 e800000000           	call	0x1b
-;;   1b:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   1f:	 b80b000000           	mov	eax, 0xb
-;;   24:	 85c9                 	test	ecx, ecx
-;;   26:	 0f8500000000         	jne	0x2c
-;;   2c:	 4883c410             	add	rsp, 0x10
-;;   30:	 5d                   	pop	rbp
-;;   31:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br_if/as_br_if_cond.wat b/winch/filetests/filetests/x64/br_if/as_br_if_cond.wat
deleted file mode 100644
index 1447cdaa6c43..000000000000
--- a/winch/filetests/filetests/x64/br_if/as_br_if_cond.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func (export "as-br-if-cond")
-    (block (br_if 0 (br_if 0 (i32.const 1) (i32.const 1))))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 85c0                 	test	eax, eax
-;;   13:	 0f850d000000         	jne	0x26
-;;   19:	 b801000000           	mov	eax, 1
-;;   1e:	 85c0                 	test	eax, eax
-;;   20:	 0f8500000000         	jne	0x26
-;;   26:	 4883c408             	add	rsp, 8
-;;   2a:	 5d                   	pop	rbp
-;;   2b:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br_if/as_br_value.wat b/winch/filetests/filetests/x64/br_if/as_br_value.wat
deleted file mode 100644
index a1ae40f4fd0e..000000000000
--- a/winch/filetests/filetests/x64/br_if/as_br_value.wat
+++ /dev/null
@@ -1,17 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func (export "as-br-value") (result i32)
-    (block (result i32) (br 0 (br_if 0 (i32.const 1) (i32.const 2))))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b902000000           	mov	ecx, 2
-;;   11:	 b801000000           	mov	eax, 1
-;;   16:	 85c9                 	test	ecx, ecx
-;;   18:	 0f8500000000         	jne	0x1e
-;;   1e:	 4883c408             	add	rsp, 8
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br_if/as_call_first.wat b/winch/filetests/filetests/x64/br_if/as_call_first.wat
deleted file mode 100644
index 271d34f9128f..000000000000
--- a/winch/filetests/filetests/x64/br_if/as_call_first.wat
+++ /dev/null
@@ -1,40 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
-  (func (export "as-call-first") (result i32)
-    (block (result i32)
-      (call $f
-        (br_if 0 (i32.const 12) (i32.const 1)) (i32.const 2) (i32.const 3)
-      )
-    )
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 897c2414             	mov	dword ptr [rsp + 0x14], edi
-;;    c:	 89742410             	mov	dword ptr [rsp + 0x10], esi
-;;   10:	 8954240c             	mov	dword ptr [rsp + 0xc], edx
-;;   14:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   19:	 b8ffffffff           	mov	eax, 0xffffffff
-;;   1e:	 4883c418             	add	rsp, 0x18
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b901000000           	mov	ecx, 1
-;;   11:	 b80c000000           	mov	eax, 0xc
-;;   16:	 85c9                 	test	ecx, ecx
-;;   18:	 0f8517000000         	jne	0x35
-;;   1e:	 50                   	push	rax
-;;   1f:	 8b3c24               	mov	edi, dword ptr [rsp]
-;;   22:	 be02000000           	mov	esi, 2
-;;   27:	 ba03000000           	mov	edx, 3
-;;   2c:	 e800000000           	call	0x31
-;;   31:	 4883c408             	add	rsp, 8
-;;   35:	 4883c408             	add	rsp, 8
-;;   39:	 5d                   	pop	rbp
-;;   3a:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br_if/as_call_last.wat b/winch/filetests/filetests/x64/br_if/as_call_last.wat
deleted file mode 100644
index 790d43ac60d1..000000000000
--- a/winch/filetests/filetests/x64/br_if/as_call_last.wat
+++ /dev/null
@@ -1,40 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
-  (func (export "as-call-last") (result i32)
-    (block (result i32)
-      (call $f
-        (i32.const 1) (i32.const 2) (br_if 0 (i32.const 14) (i32.const 1))
-      )
-    )
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 897c2414             	mov	dword ptr [rsp + 0x14], edi
-;;    c:	 89742410             	mov	dword ptr [rsp + 0x10], esi
-;;   10:	 8954240c             	mov	dword ptr [rsp + 0xc], edx
-;;   14:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   19:	 b8ffffffff           	mov	eax, 0xffffffff
-;;   1e:	 4883c418             	add	rsp, 0x18
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b901000000           	mov	ecx, 1
-;;   11:	 b80e000000           	mov	eax, 0xe
-;;   16:	 85c9                 	test	ecx, ecx
-;;   18:	 0f8517000000         	jne	0x35
-;;   1e:	 50                   	push	rax
-;;   1f:	 bf01000000           	mov	edi, 1
-;;   24:	 be02000000           	mov	esi, 2
-;;   29:	 8b1424               	mov	edx, dword ptr [rsp]
-;;   2c:	 e800000000           	call	0x31
-;;   31:	 4883c408             	add	rsp, 8
-;;   35:	 4883c408             	add	rsp, 8
-;;   39:	 5d                   	pop	rbp
-;;   3a:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br_if/as_call_mid.wat b/winch/filetests/filetests/x64/br_if/as_call_mid.wat
deleted file mode 100644
index f9f1240d6784..000000000000
--- a/winch/filetests/filetests/x64/br_if/as_call_mid.wat
+++ /dev/null
@@ -1,40 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $f (param i32 i32 i32) (result i32) (i32.const -1)) 
-  (func (export "as-call-mid") (result i32)
-    (block (result i32)
-      (call $f
-        (i32.const 1) (br_if 0 (i32.const 13) (i32.const 1)) (i32.const 3)
-      )
-    )
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 897c2414             	mov	dword ptr [rsp + 0x14], edi
-;;    c:	 89742410             	mov	dword ptr [rsp + 0x10], esi
-;;   10:	 8954240c             	mov	dword ptr [rsp + 0xc], edx
-;;   14:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   19:	 b8ffffffff           	mov	eax, 0xffffffff
-;;   1e:	 4883c418             	add	rsp, 0x18
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b901000000           	mov	ecx, 1
-;;   11:	 b80d000000           	mov	eax, 0xd
-;;   16:	 85c9                 	test	ecx, ecx
-;;   18:	 0f8517000000         	jne	0x35
-;;   1e:	 50                   	push	rax
-;;   1f:	 bf01000000           	mov	edi, 1
-;;   24:	 8b3424               	mov	esi, dword ptr [rsp]
-;;   27:	 ba03000000           	mov	edx, 3
-;;   2c:	 e800000000           	call	0x31
-;;   31:	 4883c408             	add	rsp, 8
-;;   35:	 4883c408             	add	rsp, 8
-;;   39:	 5d                   	pop	rbp
-;;   3a:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br_if/as_if_cond.wat b/winch/filetests/filetests/x64/br_if/as_if_cond.wat
deleted file mode 100644
index 6f2a7b985231..000000000000
--- a/winch/filetests/filetests/x64/br_if/as_if_cond.wat
+++ /dev/null
@@ -1,29 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func (export "as-if-cond") (param i32) (result i32)
-    (block (result i32)
-      (if (result i32)
-        (br_if 0 (i32.const 1) (local.get 0))
-        (then (i32.const 2))
-        (else (i32.const 3))
-      )
-    )
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   11:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   15:	 b801000000           	mov	eax, 1
-;;   1a:	 85c9                 	test	ecx, ecx
-;;   1c:	 0f8517000000         	jne	0x39
-;;   22:	 85c0                 	test	eax, eax
-;;   24:	 0f840a000000         	je	0x34
-;;   2a:	 b802000000           	mov	eax, 2
-;;   2f:	 e905000000           	jmp	0x39
-;;   34:	 b803000000           	mov	eax, 3
-;;   39:	 4883c410             	add	rsp, 0x10
-;;   3d:	 5d                   	pop	rbp
-;;   3e:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br_if/as_if_else.wat b/winch/filetests/filetests/x64/br_if/as_if_else.wat
deleted file mode 100644
index 4af03a69b8c5..000000000000
--- a/winch/filetests/filetests/x64/br_if/as_if_else.wat
+++ /dev/null
@@ -1,35 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "as-if-else") (param i32 i32)
-    (block
-      (if (local.get 0) (then (call $dummy)) (else (br_if 1 (local.get 1))))
-    )
-  )
-)
-
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   18:	 85c0                 	test	eax, eax
-;;   1a:	 0f840a000000         	je	0x2a
-;;   20:	 e800000000           	call	0x25
-;;   25:	 e90c000000           	jmp	0x36
-;;   2a:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   2e:	 85c0                 	test	eax, eax
-;;   30:	 0f8500000000         	jne	0x36
-;;   36:	 4883c410             	add	rsp, 0x10
-;;   3a:	 5d                   	pop	rbp
-;;   3b:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br_if/as_if_then.wat b/winch/filetests/filetests/x64/br_if/as_if_then.wat
deleted file mode 100644
index f8be63c17702..000000000000
--- a/winch/filetests/filetests/x64/br_if/as_if_then.wat
+++ /dev/null
@@ -1,34 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "as-if-then") (param i32 i32)
-    (block
-      (if (local.get 0) (then (br_if 1 (local.get 1))) (else (call $dummy)))
-    )
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   18:	 85c0                 	test	eax, eax
-;;   1a:	 0f8411000000         	je	0x31
-;;   20:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   24:	 85c0                 	test	eax, eax
-;;   26:	 0f850a000000         	jne	0x36
-;;   2c:	 e905000000           	jmp	0x36
-;;   31:	 e800000000           	call	0x36
-;;   36:	 4883c410             	add	rsp, 0x10
-;;   3a:	 5d                   	pop	rbp
-;;   3b:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br_if/as_local_set_value.wat b/winch/filetests/filetests/x64/br_if/as_local_set_value.wat
deleted file mode 100644
index 054e6a8b38e9..000000000000
--- a/winch/filetests/filetests/x64/br_if/as_local_set_value.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func (export "as-local-set-value") (param i32) (result i32)
-    (local i32)
-    (block (result i32)
-      (local.set 0 (br_if 0 (i32.const 17) (local.get 0)))
-      (i32.const -1)
-    )
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 4c893424             	mov	qword ptr [rsp], r14
-;;   10:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   14:	 b811000000           	mov	eax, 0x11
-;;   19:	 85c9                 	test	ecx, ecx
-;;   1b:	 0f8509000000         	jne	0x2a
-;;   21:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   25:	 b8ffffffff           	mov	eax, 0xffffffff
-;;   2a:	 4883c410             	add	rsp, 0x10
-;;   2e:	 5d                   	pop	rbp
-;;   2f:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br_if/as_loop_last.wat b/winch/filetests/filetests/x64/br_if/as_loop_last.wat
deleted file mode 100644
index 06bc6d3ccd90..000000000000
--- a/winch/filetests/filetests/x64/br_if/as_loop_last.wat
+++ /dev/null
@@ -1,27 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "as-loop-last") (param i32)
-    (loop (call $dummy) (br_if 1 (local.get 0)))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   11:	 e800000000           	call	0x16
-;;   16:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   1a:	 85c0                 	test	eax, eax
-;;   1c:	 0f8500000000         	jne	0x22
-;;   22:	 4883c410             	add	rsp, 0x10
-;;   26:	 5d                   	pop	rbp
-;;   27:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br_table/large.wat b/winch/filetests/filetests/x64/br_table/large.wat
deleted file mode 100644
index 9de8c4f9fba5..000000000000
--- a/winch/filetests/filetests/x64/br_table/large.wat
+++ /dev/null
@@ -1,31528 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func (export "large") (param i32) (result i32)
-    (block
-      (block
-        (br_table
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          (local.get 0)
-        )
-        (return (i32.const -1))
-      )
-      (return (i32.const 0))
-    )
-    (return (i32.const 1))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   11:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   15:	 b927600000           	mov	ecx, 0x6027
-;;   1a:	 39c1                 	cmp	ecx, eax
-;;   1c:	 0f42c1               	cmovb	eax, ecx
-;;   1f:	 4c8d1d0a000000       	lea	r11, [rip + 0xa]
-;;   26:	 49630c83             	movsxd	rcx, dword ptr [r11 + rax*4]
-;;   2a:	 4901cb               	add	r11, rcx
-;;   2d:	 41ffe3               	jmp	r11
-;;   30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;   39:	 800100               	add	byte ptr [rcx], 0
-;;   3c:	 aa                   	stosb	byte ptr [rdi], al
-;;   3d:	 800100               	add	byte ptr [rcx], 0
-;;   40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;   49:	 800100               	add	byte ptr [rcx], 0
-;;   4c:	 aa                   	stosb	byte ptr [rdi], al
-;;   4d:	 800100               	add	byte ptr [rcx], 0
-;;   50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;   59:	 800100               	add	byte ptr [rcx], 0
-;;   5c:	 aa                   	stosb	byte ptr [rdi], al
-;;   5d:	 800100               	add	byte ptr [rcx], 0
-;;   60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;   69:	 800100               	add	byte ptr [rcx], 0
-;;   6c:	 aa                   	stosb	byte ptr [rdi], al
-;;   6d:	 800100               	add	byte ptr [rcx], 0
-;;   70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;   79:	 800100               	add	byte ptr [rcx], 0
-;;   7c:	 aa                   	stosb	byte ptr [rdi], al
-;;   7d:	 800100               	add	byte ptr [rcx], 0
-;;   80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;   89:	 800100               	add	byte ptr [rcx], 0
-;;   8c:	 aa                   	stosb	byte ptr [rdi], al
-;;   8d:	 800100               	add	byte ptr [rcx], 0
-;;   90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;   99:	 800100               	add	byte ptr [rcx], 0
-;;   9c:	 aa                   	stosb	byte ptr [rdi], al
-;;   9d:	 800100               	add	byte ptr [rcx], 0
-;;   a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;   a9:	 800100               	add	byte ptr [rcx], 0
-;;   ac:	 aa                   	stosb	byte ptr [rdi], al
-;;   ad:	 800100               	add	byte ptr [rcx], 0
-;;   b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;   b9:	 800100               	add	byte ptr [rcx], 0
-;;   bc:	 aa                   	stosb	byte ptr [rdi], al
-;;   bd:	 800100               	add	byte ptr [rcx], 0
-;;   c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;   c9:	 800100               	add	byte ptr [rcx], 0
-;;   cc:	 aa                   	stosb	byte ptr [rdi], al
-;;   cd:	 800100               	add	byte ptr [rcx], 0
-;;   d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;   d9:	 800100               	add	byte ptr [rcx], 0
-;;   dc:	 aa                   	stosb	byte ptr [rdi], al
-;;   dd:	 800100               	add	byte ptr [rcx], 0
-;;   e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;   e9:	 800100               	add	byte ptr [rcx], 0
-;;   ec:	 aa                   	stosb	byte ptr [rdi], al
-;;   ed:	 800100               	add	byte ptr [rcx], 0
-;;   f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;   f9:	 800100               	add	byte ptr [rcx], 0
-;;   fc:	 aa                   	stosb	byte ptr [rdi], al
-;;   fd:	 800100               	add	byte ptr [rcx], 0
-;;  100:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  109:	 800100               	add	byte ptr [rcx], 0
-;;  10c:	 aa                   	stosb	byte ptr [rdi], al
-;;  10d:	 800100               	add	byte ptr [rcx], 0
-;;  110:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  119:	 800100               	add	byte ptr [rcx], 0
-;;  11c:	 aa                   	stosb	byte ptr [rdi], al
-;;  11d:	 800100               	add	byte ptr [rcx], 0
-;;  120:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  129:	 800100               	add	byte ptr [rcx], 0
-;;  12c:	 aa                   	stosb	byte ptr [rdi], al
-;;  12d:	 800100               	add	byte ptr [rcx], 0
-;;  130:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  139:	 800100               	add	byte ptr [rcx], 0
-;;  13c:	 aa                   	stosb	byte ptr [rdi], al
-;;  13d:	 800100               	add	byte ptr [rcx], 0
-;;  140:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  149:	 800100               	add	byte ptr [rcx], 0
-;;  14c:	 aa                   	stosb	byte ptr [rdi], al
-;;  14d:	 800100               	add	byte ptr [rcx], 0
-;;  150:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  159:	 800100               	add	byte ptr [rcx], 0
-;;  15c:	 aa                   	stosb	byte ptr [rdi], al
-;;  15d:	 800100               	add	byte ptr [rcx], 0
-;;  160:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  169:	 800100               	add	byte ptr [rcx], 0
-;;  16c:	 aa                   	stosb	byte ptr [rdi], al
-;;  16d:	 800100               	add	byte ptr [rcx], 0
-;;  170:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  179:	 800100               	add	byte ptr [rcx], 0
-;;  17c:	 aa                   	stosb	byte ptr [rdi], al
-;;  17d:	 800100               	add	byte ptr [rcx], 0
-;;  180:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  189:	 800100               	add	byte ptr [rcx], 0
-;;  18c:	 aa                   	stosb	byte ptr [rdi], al
-;;  18d:	 800100               	add	byte ptr [rcx], 0
-;;  190:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  199:	 800100               	add	byte ptr [rcx], 0
-;;  19c:	 aa                   	stosb	byte ptr [rdi], al
-;;  19d:	 800100               	add	byte ptr [rcx], 0
-;;  1a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  1a9:	 800100               	add	byte ptr [rcx], 0
-;;  1ac:	 aa                   	stosb	byte ptr [rdi], al
-;;  1ad:	 800100               	add	byte ptr [rcx], 0
-;;  1b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  1b9:	 800100               	add	byte ptr [rcx], 0
-;;  1bc:	 aa                   	stosb	byte ptr [rdi], al
-;;  1bd:	 800100               	add	byte ptr [rcx], 0
-;;  1c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  1c9:	 800100               	add	byte ptr [rcx], 0
-;;  1cc:	 aa                   	stosb	byte ptr [rdi], al
-;;  1cd:	 800100               	add	byte ptr [rcx], 0
-;;  1d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  1d9:	 800100               	add	byte ptr [rcx], 0
-;;  1dc:	 aa                   	stosb	byte ptr [rdi], al
-;;  1dd:	 800100               	add	byte ptr [rcx], 0
-;;  1e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  1e9:	 800100               	add	byte ptr [rcx], 0
-;;  1ec:	 aa                   	stosb	byte ptr [rdi], al
-;;  1ed:	 800100               	add	byte ptr [rcx], 0
-;;  1f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  1f9:	 800100               	add	byte ptr [rcx], 0
-;;  1fc:	 aa                   	stosb	byte ptr [rdi], al
-;;  1fd:	 800100               	add	byte ptr [rcx], 0
-;;  200:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  209:	 800100               	add	byte ptr [rcx], 0
-;;  20c:	 aa                   	stosb	byte ptr [rdi], al
-;;  20d:	 800100               	add	byte ptr [rcx], 0
-;;  210:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  219:	 800100               	add	byte ptr [rcx], 0
-;;  21c:	 aa                   	stosb	byte ptr [rdi], al
-;;  21d:	 800100               	add	byte ptr [rcx], 0
-;;  220:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  229:	 800100               	add	byte ptr [rcx], 0
-;;  22c:	 aa                   	stosb	byte ptr [rdi], al
-;;  22d:	 800100               	add	byte ptr [rcx], 0
-;;  230:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  239:	 800100               	add	byte ptr [rcx], 0
-;;  23c:	 aa                   	stosb	byte ptr [rdi], al
-;;  23d:	 800100               	add	byte ptr [rcx], 0
-;;  240:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  249:	 800100               	add	byte ptr [rcx], 0
-;;  24c:	 aa                   	stosb	byte ptr [rdi], al
-;;  24d:	 800100               	add	byte ptr [rcx], 0
-;;  250:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  259:	 800100               	add	byte ptr [rcx], 0
-;;  25c:	 aa                   	stosb	byte ptr [rdi], al
-;;  25d:	 800100               	add	byte ptr [rcx], 0
-;;  260:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  269:	 800100               	add	byte ptr [rcx], 0
-;;  26c:	 aa                   	stosb	byte ptr [rdi], al
-;;  26d:	 800100               	add	byte ptr [rcx], 0
-;;  270:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  279:	 800100               	add	byte ptr [rcx], 0
-;;  27c:	 aa                   	stosb	byte ptr [rdi], al
-;;  27d:	 800100               	add	byte ptr [rcx], 0
-;;  280:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  289:	 800100               	add	byte ptr [rcx], 0
-;;  28c:	 aa                   	stosb	byte ptr [rdi], al
-;;  28d:	 800100               	add	byte ptr [rcx], 0
-;;  290:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  299:	 800100               	add	byte ptr [rcx], 0
-;;  29c:	 aa                   	stosb	byte ptr [rdi], al
-;;  29d:	 800100               	add	byte ptr [rcx], 0
-;;  2a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  2a9:	 800100               	add	byte ptr [rcx], 0
-;;  2ac:	 aa                   	stosb	byte ptr [rdi], al
-;;  2ad:	 800100               	add	byte ptr [rcx], 0
-;;  2b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  2b9:	 800100               	add	byte ptr [rcx], 0
-;;  2bc:	 aa                   	stosb	byte ptr [rdi], al
-;;  2bd:	 800100               	add	byte ptr [rcx], 0
-;;  2c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  2c9:	 800100               	add	byte ptr [rcx], 0
-;;  2cc:	 aa                   	stosb	byte ptr [rdi], al
-;;  2cd:	 800100               	add	byte ptr [rcx], 0
-;;  2d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  2d9:	 800100               	add	byte ptr [rcx], 0
-;;  2dc:	 aa                   	stosb	byte ptr [rdi], al
-;;  2dd:	 800100               	add	byte ptr [rcx], 0
-;;  2e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  2e9:	 800100               	add	byte ptr [rcx], 0
-;;  2ec:	 aa                   	stosb	byte ptr [rdi], al
-;;  2ed:	 800100               	add	byte ptr [rcx], 0
-;;  2f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  2f9:	 800100               	add	byte ptr [rcx], 0
-;;  2fc:	 aa                   	stosb	byte ptr [rdi], al
-;;  2fd:	 800100               	add	byte ptr [rcx], 0
-;;  300:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  309:	 800100               	add	byte ptr [rcx], 0
-;;  30c:	 aa                   	stosb	byte ptr [rdi], al
-;;  30d:	 800100               	add	byte ptr [rcx], 0
-;;  310:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  319:	 800100               	add	byte ptr [rcx], 0
-;;  31c:	 aa                   	stosb	byte ptr [rdi], al
-;;  31d:	 800100               	add	byte ptr [rcx], 0
-;;  320:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  329:	 800100               	add	byte ptr [rcx], 0
-;;  32c:	 aa                   	stosb	byte ptr [rdi], al
-;;  32d:	 800100               	add	byte ptr [rcx], 0
-;;  330:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  339:	 800100               	add	byte ptr [rcx], 0
-;;  33c:	 aa                   	stosb	byte ptr [rdi], al
-;;  33d:	 800100               	add	byte ptr [rcx], 0
-;;  340:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  349:	 800100               	add	byte ptr [rcx], 0
-;;  34c:	 aa                   	stosb	byte ptr [rdi], al
-;;  34d:	 800100               	add	byte ptr [rcx], 0
-;;  350:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  359:	 800100               	add	byte ptr [rcx], 0
-;;  35c:	 aa                   	stosb	byte ptr [rdi], al
-;;  35d:	 800100               	add	byte ptr [rcx], 0
-;;  360:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  369:	 800100               	add	byte ptr [rcx], 0
-;;  36c:	 aa                   	stosb	byte ptr [rdi], al
-;;  36d:	 800100               	add	byte ptr [rcx], 0
-;;  370:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  379:	 800100               	add	byte ptr [rcx], 0
-;;  37c:	 aa                   	stosb	byte ptr [rdi], al
-;;  37d:	 800100               	add	byte ptr [rcx], 0
-;;  380:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  389:	 800100               	add	byte ptr [rcx], 0
-;;  38c:	 aa                   	stosb	byte ptr [rdi], al
-;;  38d:	 800100               	add	byte ptr [rcx], 0
-;;  390:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  399:	 800100               	add	byte ptr [rcx], 0
-;;  39c:	 aa                   	stosb	byte ptr [rdi], al
-;;  39d:	 800100               	add	byte ptr [rcx], 0
-;;  3a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  3a9:	 800100               	add	byte ptr [rcx], 0
-;;  3ac:	 aa                   	stosb	byte ptr [rdi], al
-;;  3ad:	 800100               	add	byte ptr [rcx], 0
-;;  3b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  3b9:	 800100               	add	byte ptr [rcx], 0
-;;  3bc:	 aa                   	stosb	byte ptr [rdi], al
-;;  3bd:	 800100               	add	byte ptr [rcx], 0
-;;  3c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  3c9:	 800100               	add	byte ptr [rcx], 0
-;;  3cc:	 aa                   	stosb	byte ptr [rdi], al
-;;  3cd:	 800100               	add	byte ptr [rcx], 0
-;;  3d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  3d9:	 800100               	add	byte ptr [rcx], 0
-;;  3dc:	 aa                   	stosb	byte ptr [rdi], al
-;;  3dd:	 800100               	add	byte ptr [rcx], 0
-;;  3e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  3e9:	 800100               	add	byte ptr [rcx], 0
-;;  3ec:	 aa                   	stosb	byte ptr [rdi], al
-;;  3ed:	 800100               	add	byte ptr [rcx], 0
-;;  3f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  3f9:	 800100               	add	byte ptr [rcx], 0
-;;  3fc:	 aa                   	stosb	byte ptr [rdi], al
-;;  3fd:	 800100               	add	byte ptr [rcx], 0
-;;  400:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  409:	 800100               	add	byte ptr [rcx], 0
-;;  40c:	 aa                   	stosb	byte ptr [rdi], al
-;;  40d:	 800100               	add	byte ptr [rcx], 0
-;;  410:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  419:	 800100               	add	byte ptr [rcx], 0
-;;  41c:	 aa                   	stosb	byte ptr [rdi], al
-;;  41d:	 800100               	add	byte ptr [rcx], 0
-;;  420:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  429:	 800100               	add	byte ptr [rcx], 0
-;;  42c:	 aa                   	stosb	byte ptr [rdi], al
-;;  42d:	 800100               	add	byte ptr [rcx], 0
-;;  430:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  439:	 800100               	add	byte ptr [rcx], 0
-;;  43c:	 aa                   	stosb	byte ptr [rdi], al
-;;  43d:	 800100               	add	byte ptr [rcx], 0
-;;  440:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  449:	 800100               	add	byte ptr [rcx], 0
-;;  44c:	 aa                   	stosb	byte ptr [rdi], al
-;;  44d:	 800100               	add	byte ptr [rcx], 0
-;;  450:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  459:	 800100               	add	byte ptr [rcx], 0
-;;  45c:	 aa                   	stosb	byte ptr [rdi], al
-;;  45d:	 800100               	add	byte ptr [rcx], 0
-;;  460:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  469:	 800100               	add	byte ptr [rcx], 0
-;;  46c:	 aa                   	stosb	byte ptr [rdi], al
-;;  46d:	 800100               	add	byte ptr [rcx], 0
-;;  470:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  479:	 800100               	add	byte ptr [rcx], 0
-;;  47c:	 aa                   	stosb	byte ptr [rdi], al
-;;  47d:	 800100               	add	byte ptr [rcx], 0
-;;  480:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  489:	 800100               	add	byte ptr [rcx], 0
-;;  48c:	 aa                   	stosb	byte ptr [rdi], al
-;;  48d:	 800100               	add	byte ptr [rcx], 0
-;;  490:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  499:	 800100               	add	byte ptr [rcx], 0
-;;  49c:	 aa                   	stosb	byte ptr [rdi], al
-;;  49d:	 800100               	add	byte ptr [rcx], 0
-;;  4a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  4a9:	 800100               	add	byte ptr [rcx], 0
-;;  4ac:	 aa                   	stosb	byte ptr [rdi], al
-;;  4ad:	 800100               	add	byte ptr [rcx], 0
-;;  4b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  4b9:	 800100               	add	byte ptr [rcx], 0
-;;  4bc:	 aa                   	stosb	byte ptr [rdi], al
-;;  4bd:	 800100               	add	byte ptr [rcx], 0
-;;  4c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  4c9:	 800100               	add	byte ptr [rcx], 0
-;;  4cc:	 aa                   	stosb	byte ptr [rdi], al
-;;  4cd:	 800100               	add	byte ptr [rcx], 0
-;;  4d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  4d9:	 800100               	add	byte ptr [rcx], 0
-;;  4dc:	 aa                   	stosb	byte ptr [rdi], al
-;;  4dd:	 800100               	add	byte ptr [rcx], 0
-;;  4e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  4e9:	 800100               	add	byte ptr [rcx], 0
-;;  4ec:	 aa                   	stosb	byte ptr [rdi], al
-;;  4ed:	 800100               	add	byte ptr [rcx], 0
-;;  4f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  4f9:	 800100               	add	byte ptr [rcx], 0
-;;  4fc:	 aa                   	stosb	byte ptr [rdi], al
-;;  4fd:	 800100               	add	byte ptr [rcx], 0
-;;  500:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  509:	 800100               	add	byte ptr [rcx], 0
-;;  50c:	 aa                   	stosb	byte ptr [rdi], al
-;;  50d:	 800100               	add	byte ptr [rcx], 0
-;;  510:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  519:	 800100               	add	byte ptr [rcx], 0
-;;  51c:	 aa                   	stosb	byte ptr [rdi], al
-;;  51d:	 800100               	add	byte ptr [rcx], 0
-;;  520:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  529:	 800100               	add	byte ptr [rcx], 0
-;;  52c:	 aa                   	stosb	byte ptr [rdi], al
-;;  52d:	 800100               	add	byte ptr [rcx], 0
-;;  530:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  539:	 800100               	add	byte ptr [rcx], 0
-;;  53c:	 aa                   	stosb	byte ptr [rdi], al
-;;  53d:	 800100               	add	byte ptr [rcx], 0
-;;  540:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  549:	 800100               	add	byte ptr [rcx], 0
-;;  54c:	 aa                   	stosb	byte ptr [rdi], al
-;;  54d:	 800100               	add	byte ptr [rcx], 0
-;;  550:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  559:	 800100               	add	byte ptr [rcx], 0
-;;  55c:	 aa                   	stosb	byte ptr [rdi], al
-;;  55d:	 800100               	add	byte ptr [rcx], 0
-;;  560:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  569:	 800100               	add	byte ptr [rcx], 0
-;;  56c:	 aa                   	stosb	byte ptr [rdi], al
-;;  56d:	 800100               	add	byte ptr [rcx], 0
-;;  570:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  579:	 800100               	add	byte ptr [rcx], 0
-;;  57c:	 aa                   	stosb	byte ptr [rdi], al
-;;  57d:	 800100               	add	byte ptr [rcx], 0
-;;  580:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  589:	 800100               	add	byte ptr [rcx], 0
-;;  58c:	 aa                   	stosb	byte ptr [rdi], al
-;;  58d:	 800100               	add	byte ptr [rcx], 0
-;;  590:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  599:	 800100               	add	byte ptr [rcx], 0
-;;  59c:	 aa                   	stosb	byte ptr [rdi], al
-;;  59d:	 800100               	add	byte ptr [rcx], 0
-;;  5a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  5a9:	 800100               	add	byte ptr [rcx], 0
-;;  5ac:	 aa                   	stosb	byte ptr [rdi], al
-;;  5ad:	 800100               	add	byte ptr [rcx], 0
-;;  5b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  5b9:	 800100               	add	byte ptr [rcx], 0
-;;  5bc:	 aa                   	stosb	byte ptr [rdi], al
-;;  5bd:	 800100               	add	byte ptr [rcx], 0
-;;  5c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  5c9:	 800100               	add	byte ptr [rcx], 0
-;;  5cc:	 aa                   	stosb	byte ptr [rdi], al
-;;  5cd:	 800100               	add	byte ptr [rcx], 0
-;;  5d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  5d9:	 800100               	add	byte ptr [rcx], 0
-;;  5dc:	 aa                   	stosb	byte ptr [rdi], al
-;;  5dd:	 800100               	add	byte ptr [rcx], 0
-;;  5e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  5e9:	 800100               	add	byte ptr [rcx], 0
-;;  5ec:	 aa                   	stosb	byte ptr [rdi], al
-;;  5ed:	 800100               	add	byte ptr [rcx], 0
-;;  5f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  5f9:	 800100               	add	byte ptr [rcx], 0
-;;  5fc:	 aa                   	stosb	byte ptr [rdi], al
-;;  5fd:	 800100               	add	byte ptr [rcx], 0
-;;  600:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  609:	 800100               	add	byte ptr [rcx], 0
-;;  60c:	 aa                   	stosb	byte ptr [rdi], al
-;;  60d:	 800100               	add	byte ptr [rcx], 0
-;;  610:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  619:	 800100               	add	byte ptr [rcx], 0
-;;  61c:	 aa                   	stosb	byte ptr [rdi], al
-;;  61d:	 800100               	add	byte ptr [rcx], 0
-;;  620:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  629:	 800100               	add	byte ptr [rcx], 0
-;;  62c:	 aa                   	stosb	byte ptr [rdi], al
-;;  62d:	 800100               	add	byte ptr [rcx], 0
-;;  630:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  639:	 800100               	add	byte ptr [rcx], 0
-;;  63c:	 aa                   	stosb	byte ptr [rdi], al
-;;  63d:	 800100               	add	byte ptr [rcx], 0
-;;  640:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  649:	 800100               	add	byte ptr [rcx], 0
-;;  64c:	 aa                   	stosb	byte ptr [rdi], al
-;;  64d:	 800100               	add	byte ptr [rcx], 0
-;;  650:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  659:	 800100               	add	byte ptr [rcx], 0
-;;  65c:	 aa                   	stosb	byte ptr [rdi], al
-;;  65d:	 800100               	add	byte ptr [rcx], 0
-;;  660:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  669:	 800100               	add	byte ptr [rcx], 0
-;;  66c:	 aa                   	stosb	byte ptr [rdi], al
-;;  66d:	 800100               	add	byte ptr [rcx], 0
-;;  670:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  679:	 800100               	add	byte ptr [rcx], 0
-;;  67c:	 aa                   	stosb	byte ptr [rdi], al
-;;  67d:	 800100               	add	byte ptr [rcx], 0
-;;  680:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  689:	 800100               	add	byte ptr [rcx], 0
-;;  68c:	 aa                   	stosb	byte ptr [rdi], al
-;;  68d:	 800100               	add	byte ptr [rcx], 0
-;;  690:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  699:	 800100               	add	byte ptr [rcx], 0
-;;  69c:	 aa                   	stosb	byte ptr [rdi], al
-;;  69d:	 800100               	add	byte ptr [rcx], 0
-;;  6a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  6a9:	 800100               	add	byte ptr [rcx], 0
-;;  6ac:	 aa                   	stosb	byte ptr [rdi], al
-;;  6ad:	 800100               	add	byte ptr [rcx], 0
-;;  6b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  6b9:	 800100               	add	byte ptr [rcx], 0
-;;  6bc:	 aa                   	stosb	byte ptr [rdi], al
-;;  6bd:	 800100               	add	byte ptr [rcx], 0
-;;  6c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  6c9:	 800100               	add	byte ptr [rcx], 0
-;;  6cc:	 aa                   	stosb	byte ptr [rdi], al
-;;  6cd:	 800100               	add	byte ptr [rcx], 0
-;;  6d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  6d9:	 800100               	add	byte ptr [rcx], 0
-;;  6dc:	 aa                   	stosb	byte ptr [rdi], al
-;;  6dd:	 800100               	add	byte ptr [rcx], 0
-;;  6e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  6e9:	 800100               	add	byte ptr [rcx], 0
-;;  6ec:	 aa                   	stosb	byte ptr [rdi], al
-;;  6ed:	 800100               	add	byte ptr [rcx], 0
-;;  6f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  6f9:	 800100               	add	byte ptr [rcx], 0
-;;  6fc:	 aa                   	stosb	byte ptr [rdi], al
-;;  6fd:	 800100               	add	byte ptr [rcx], 0
-;;  700:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  709:	 800100               	add	byte ptr [rcx], 0
-;;  70c:	 aa                   	stosb	byte ptr [rdi], al
-;;  70d:	 800100               	add	byte ptr [rcx], 0
-;;  710:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  719:	 800100               	add	byte ptr [rcx], 0
-;;  71c:	 aa                   	stosb	byte ptr [rdi], al
-;;  71d:	 800100               	add	byte ptr [rcx], 0
-;;  720:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  729:	 800100               	add	byte ptr [rcx], 0
-;;  72c:	 aa                   	stosb	byte ptr [rdi], al
-;;  72d:	 800100               	add	byte ptr [rcx], 0
-;;  730:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  739:	 800100               	add	byte ptr [rcx], 0
-;;  73c:	 aa                   	stosb	byte ptr [rdi], al
-;;  73d:	 800100               	add	byte ptr [rcx], 0
-;;  740:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  749:	 800100               	add	byte ptr [rcx], 0
-;;  74c:	 aa                   	stosb	byte ptr [rdi], al
-;;  74d:	 800100               	add	byte ptr [rcx], 0
-;;  750:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  759:	 800100               	add	byte ptr [rcx], 0
-;;  75c:	 aa                   	stosb	byte ptr [rdi], al
-;;  75d:	 800100               	add	byte ptr [rcx], 0
-;;  760:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  769:	 800100               	add	byte ptr [rcx], 0
-;;  76c:	 aa                   	stosb	byte ptr [rdi], al
-;;  76d:	 800100               	add	byte ptr [rcx], 0
-;;  770:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  779:	 800100               	add	byte ptr [rcx], 0
-;;  77c:	 aa                   	stosb	byte ptr [rdi], al
-;;  77d:	 800100               	add	byte ptr [rcx], 0
-;;  780:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  789:	 800100               	add	byte ptr [rcx], 0
-;;  78c:	 aa                   	stosb	byte ptr [rdi], al
-;;  78d:	 800100               	add	byte ptr [rcx], 0
-;;  790:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  799:	 800100               	add	byte ptr [rcx], 0
-;;  79c:	 aa                   	stosb	byte ptr [rdi], al
-;;  79d:	 800100               	add	byte ptr [rcx], 0
-;;  7a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  7a9:	 800100               	add	byte ptr [rcx], 0
-;;  7ac:	 aa                   	stosb	byte ptr [rdi], al
-;;  7ad:	 800100               	add	byte ptr [rcx], 0
-;;  7b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  7b9:	 800100               	add	byte ptr [rcx], 0
-;;  7bc:	 aa                   	stosb	byte ptr [rdi], al
-;;  7bd:	 800100               	add	byte ptr [rcx], 0
-;;  7c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  7c9:	 800100               	add	byte ptr [rcx], 0
-;;  7cc:	 aa                   	stosb	byte ptr [rdi], al
-;;  7cd:	 800100               	add	byte ptr [rcx], 0
-;;  7d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  7d9:	 800100               	add	byte ptr [rcx], 0
-;;  7dc:	 aa                   	stosb	byte ptr [rdi], al
-;;  7dd:	 800100               	add	byte ptr [rcx], 0
-;;  7e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  7e9:	 800100               	add	byte ptr [rcx], 0
-;;  7ec:	 aa                   	stosb	byte ptr [rdi], al
-;;  7ed:	 800100               	add	byte ptr [rcx], 0
-;;  7f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  7f9:	 800100               	add	byte ptr [rcx], 0
-;;  7fc:	 aa                   	stosb	byte ptr [rdi], al
-;;  7fd:	 800100               	add	byte ptr [rcx], 0
-;;  800:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  809:	 800100               	add	byte ptr [rcx], 0
-;;  80c:	 aa                   	stosb	byte ptr [rdi], al
-;;  80d:	 800100               	add	byte ptr [rcx], 0
-;;  810:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  819:	 800100               	add	byte ptr [rcx], 0
-;;  81c:	 aa                   	stosb	byte ptr [rdi], al
-;;  81d:	 800100               	add	byte ptr [rcx], 0
-;;  820:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  829:	 800100               	add	byte ptr [rcx], 0
-;;  82c:	 aa                   	stosb	byte ptr [rdi], al
-;;  82d:	 800100               	add	byte ptr [rcx], 0
-;;  830:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  839:	 800100               	add	byte ptr [rcx], 0
-;;  83c:	 aa                   	stosb	byte ptr [rdi], al
-;;  83d:	 800100               	add	byte ptr [rcx], 0
-;;  840:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  849:	 800100               	add	byte ptr [rcx], 0
-;;  84c:	 aa                   	stosb	byte ptr [rdi], al
-;;  84d:	 800100               	add	byte ptr [rcx], 0
-;;  850:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  859:	 800100               	add	byte ptr [rcx], 0
-;;  85c:	 aa                   	stosb	byte ptr [rdi], al
-;;  85d:	 800100               	add	byte ptr [rcx], 0
-;;  860:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  869:	 800100               	add	byte ptr [rcx], 0
-;;  86c:	 aa                   	stosb	byte ptr [rdi], al
-;;  86d:	 800100               	add	byte ptr [rcx], 0
-;;  870:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  879:	 800100               	add	byte ptr [rcx], 0
-;;  87c:	 aa                   	stosb	byte ptr [rdi], al
-;;  87d:	 800100               	add	byte ptr [rcx], 0
-;;  880:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  889:	 800100               	add	byte ptr [rcx], 0
-;;  88c:	 aa                   	stosb	byte ptr [rdi], al
-;;  88d:	 800100               	add	byte ptr [rcx], 0
-;;  890:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  899:	 800100               	add	byte ptr [rcx], 0
-;;  89c:	 aa                   	stosb	byte ptr [rdi], al
-;;  89d:	 800100               	add	byte ptr [rcx], 0
-;;  8a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  8a9:	 800100               	add	byte ptr [rcx], 0
-;;  8ac:	 aa                   	stosb	byte ptr [rdi], al
-;;  8ad:	 800100               	add	byte ptr [rcx], 0
-;;  8b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  8b9:	 800100               	add	byte ptr [rcx], 0
-;;  8bc:	 aa                   	stosb	byte ptr [rdi], al
-;;  8bd:	 800100               	add	byte ptr [rcx], 0
-;;  8c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  8c9:	 800100               	add	byte ptr [rcx], 0
-;;  8cc:	 aa                   	stosb	byte ptr [rdi], al
-;;  8cd:	 800100               	add	byte ptr [rcx], 0
-;;  8d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  8d9:	 800100               	add	byte ptr [rcx], 0
-;;  8dc:	 aa                   	stosb	byte ptr [rdi], al
-;;  8dd:	 800100               	add	byte ptr [rcx], 0
-;;  8e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  8e9:	 800100               	add	byte ptr [rcx], 0
-;;  8ec:	 aa                   	stosb	byte ptr [rdi], al
-;;  8ed:	 800100               	add	byte ptr [rcx], 0
-;;  8f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  8f9:	 800100               	add	byte ptr [rcx], 0
-;;  8fc:	 aa                   	stosb	byte ptr [rdi], al
-;;  8fd:	 800100               	add	byte ptr [rcx], 0
-;;  900:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  909:	 800100               	add	byte ptr [rcx], 0
-;;  90c:	 aa                   	stosb	byte ptr [rdi], al
-;;  90d:	 800100               	add	byte ptr [rcx], 0
-;;  910:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  919:	 800100               	add	byte ptr [rcx], 0
-;;  91c:	 aa                   	stosb	byte ptr [rdi], al
-;;  91d:	 800100               	add	byte ptr [rcx], 0
-;;  920:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  929:	 800100               	add	byte ptr [rcx], 0
-;;  92c:	 aa                   	stosb	byte ptr [rdi], al
-;;  92d:	 800100               	add	byte ptr [rcx], 0
-;;  930:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  939:	 800100               	add	byte ptr [rcx], 0
-;;  93c:	 aa                   	stosb	byte ptr [rdi], al
-;;  93d:	 800100               	add	byte ptr [rcx], 0
-;;  940:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  949:	 800100               	add	byte ptr [rcx], 0
-;;  94c:	 aa                   	stosb	byte ptr [rdi], al
-;;  94d:	 800100               	add	byte ptr [rcx], 0
-;;  950:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  959:	 800100               	add	byte ptr [rcx], 0
-;;  95c:	 aa                   	stosb	byte ptr [rdi], al
-;;  95d:	 800100               	add	byte ptr [rcx], 0
-;;  960:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  969:	 800100               	add	byte ptr [rcx], 0
-;;  96c:	 aa                   	stosb	byte ptr [rdi], al
-;;  96d:	 800100               	add	byte ptr [rcx], 0
-;;  970:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  979:	 800100               	add	byte ptr [rcx], 0
-;;  97c:	 aa                   	stosb	byte ptr [rdi], al
-;;  97d:	 800100               	add	byte ptr [rcx], 0
-;;  980:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  989:	 800100               	add	byte ptr [rcx], 0
-;;  98c:	 aa                   	stosb	byte ptr [rdi], al
-;;  98d:	 800100               	add	byte ptr [rcx], 0
-;;  990:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  999:	 800100               	add	byte ptr [rcx], 0
-;;  99c:	 aa                   	stosb	byte ptr [rdi], al
-;;  99d:	 800100               	add	byte ptr [rcx], 0
-;;  9a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  9a9:	 800100               	add	byte ptr [rcx], 0
-;;  9ac:	 aa                   	stosb	byte ptr [rdi], al
-;;  9ad:	 800100               	add	byte ptr [rcx], 0
-;;  9b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  9b9:	 800100               	add	byte ptr [rcx], 0
-;;  9bc:	 aa                   	stosb	byte ptr [rdi], al
-;;  9bd:	 800100               	add	byte ptr [rcx], 0
-;;  9c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  9c9:	 800100               	add	byte ptr [rcx], 0
-;;  9cc:	 aa                   	stosb	byte ptr [rdi], al
-;;  9cd:	 800100               	add	byte ptr [rcx], 0
-;;  9d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  9d9:	 800100               	add	byte ptr [rcx], 0
-;;  9dc:	 aa                   	stosb	byte ptr [rdi], al
-;;  9dd:	 800100               	add	byte ptr [rcx], 0
-;;  9e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  9e9:	 800100               	add	byte ptr [rcx], 0
-;;  9ec:	 aa                   	stosb	byte ptr [rdi], al
-;;  9ed:	 800100               	add	byte ptr [rcx], 0
-;;  9f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  9f9:	 800100               	add	byte ptr [rcx], 0
-;;  9fc:	 aa                   	stosb	byte ptr [rdi], al
-;;  9fd:	 800100               	add	byte ptr [rcx], 0
-;;  a00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  a09:	 800100               	add	byte ptr [rcx], 0
-;;  a0c:	 aa                   	stosb	byte ptr [rdi], al
-;;  a0d:	 800100               	add	byte ptr [rcx], 0
-;;  a10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  a19:	 800100               	add	byte ptr [rcx], 0
-;;  a1c:	 aa                   	stosb	byte ptr [rdi], al
-;;  a1d:	 800100               	add	byte ptr [rcx], 0
-;;  a20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  a29:	 800100               	add	byte ptr [rcx], 0
-;;  a2c:	 aa                   	stosb	byte ptr [rdi], al
-;;  a2d:	 800100               	add	byte ptr [rcx], 0
-;;  a30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  a39:	 800100               	add	byte ptr [rcx], 0
-;;  a3c:	 aa                   	stosb	byte ptr [rdi], al
-;;  a3d:	 800100               	add	byte ptr [rcx], 0
-;;  a40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  a49:	 800100               	add	byte ptr [rcx], 0
-;;  a4c:	 aa                   	stosb	byte ptr [rdi], al
-;;  a4d:	 800100               	add	byte ptr [rcx], 0
-;;  a50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  a59:	 800100               	add	byte ptr [rcx], 0
-;;  a5c:	 aa                   	stosb	byte ptr [rdi], al
-;;  a5d:	 800100               	add	byte ptr [rcx], 0
-;;  a60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  a69:	 800100               	add	byte ptr [rcx], 0
-;;  a6c:	 aa                   	stosb	byte ptr [rdi], al
-;;  a6d:	 800100               	add	byte ptr [rcx], 0
-;;  a70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  a79:	 800100               	add	byte ptr [rcx], 0
-;;  a7c:	 aa                   	stosb	byte ptr [rdi], al
-;;  a7d:	 800100               	add	byte ptr [rcx], 0
-;;  a80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  a89:	 800100               	add	byte ptr [rcx], 0
-;;  a8c:	 aa                   	stosb	byte ptr [rdi], al
-;;  a8d:	 800100               	add	byte ptr [rcx], 0
-;;  a90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  a99:	 800100               	add	byte ptr [rcx], 0
-;;  a9c:	 aa                   	stosb	byte ptr [rdi], al
-;;  a9d:	 800100               	add	byte ptr [rcx], 0
-;;  aa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  aa9:	 800100               	add	byte ptr [rcx], 0
-;;  aac:	 aa                   	stosb	byte ptr [rdi], al
-;;  aad:	 800100               	add	byte ptr [rcx], 0
-;;  ab0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  ab9:	 800100               	add	byte ptr [rcx], 0
-;;  abc:	 aa                   	stosb	byte ptr [rdi], al
-;;  abd:	 800100               	add	byte ptr [rcx], 0
-;;  ac0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  ac9:	 800100               	add	byte ptr [rcx], 0
-;;  acc:	 aa                   	stosb	byte ptr [rdi], al
-;;  acd:	 800100               	add	byte ptr [rcx], 0
-;;  ad0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  ad9:	 800100               	add	byte ptr [rcx], 0
-;;  adc:	 aa                   	stosb	byte ptr [rdi], al
-;;  add:	 800100               	add	byte ptr [rcx], 0
-;;  ae0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  ae9:	 800100               	add	byte ptr [rcx], 0
-;;  aec:	 aa                   	stosb	byte ptr [rdi], al
-;;  aed:	 800100               	add	byte ptr [rcx], 0
-;;  af0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  af9:	 800100               	add	byte ptr [rcx], 0
-;;  afc:	 aa                   	stosb	byte ptr [rdi], al
-;;  afd:	 800100               	add	byte ptr [rcx], 0
-;;  b00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  b09:	 800100               	add	byte ptr [rcx], 0
-;;  b0c:	 aa                   	stosb	byte ptr [rdi], al
-;;  b0d:	 800100               	add	byte ptr [rcx], 0
-;;  b10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  b19:	 800100               	add	byte ptr [rcx], 0
-;;  b1c:	 aa                   	stosb	byte ptr [rdi], al
-;;  b1d:	 800100               	add	byte ptr [rcx], 0
-;;  b20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  b29:	 800100               	add	byte ptr [rcx], 0
-;;  b2c:	 aa                   	stosb	byte ptr [rdi], al
-;;  b2d:	 800100               	add	byte ptr [rcx], 0
-;;  b30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  b39:	 800100               	add	byte ptr [rcx], 0
-;;  b3c:	 aa                   	stosb	byte ptr [rdi], al
-;;  b3d:	 800100               	add	byte ptr [rcx], 0
-;;  b40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  b49:	 800100               	add	byte ptr [rcx], 0
-;;  b4c:	 aa                   	stosb	byte ptr [rdi], al
-;;  b4d:	 800100               	add	byte ptr [rcx], 0
-;;  b50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  b59:	 800100               	add	byte ptr [rcx], 0
-;;  b5c:	 aa                   	stosb	byte ptr [rdi], al
-;;  b5d:	 800100               	add	byte ptr [rcx], 0
-;;  b60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  b69:	 800100               	add	byte ptr [rcx], 0
-;;  b6c:	 aa                   	stosb	byte ptr [rdi], al
-;;  b6d:	 800100               	add	byte ptr [rcx], 0
-;;  b70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  b79:	 800100               	add	byte ptr [rcx], 0
-;;  b7c:	 aa                   	stosb	byte ptr [rdi], al
-;;  b7d:	 800100               	add	byte ptr [rcx], 0
-;;  b80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  b89:	 800100               	add	byte ptr [rcx], 0
-;;  b8c:	 aa                   	stosb	byte ptr [rdi], al
-;;  b8d:	 800100               	add	byte ptr [rcx], 0
-;;  b90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  b99:	 800100               	add	byte ptr [rcx], 0
-;;  b9c:	 aa                   	stosb	byte ptr [rdi], al
-;;  b9d:	 800100               	add	byte ptr [rcx], 0
-;;  ba0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  ba9:	 800100               	add	byte ptr [rcx], 0
-;;  bac:	 aa                   	stosb	byte ptr [rdi], al
-;;  bad:	 800100               	add	byte ptr [rcx], 0
-;;  bb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  bb9:	 800100               	add	byte ptr [rcx], 0
-;;  bbc:	 aa                   	stosb	byte ptr [rdi], al
-;;  bbd:	 800100               	add	byte ptr [rcx], 0
-;;  bc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  bc9:	 800100               	add	byte ptr [rcx], 0
-;;  bcc:	 aa                   	stosb	byte ptr [rdi], al
-;;  bcd:	 800100               	add	byte ptr [rcx], 0
-;;  bd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  bd9:	 800100               	add	byte ptr [rcx], 0
-;;  bdc:	 aa                   	stosb	byte ptr [rdi], al
-;;  bdd:	 800100               	add	byte ptr [rcx], 0
-;;  be0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  be9:	 800100               	add	byte ptr [rcx], 0
-;;  bec:	 aa                   	stosb	byte ptr [rdi], al
-;;  bed:	 800100               	add	byte ptr [rcx], 0
-;;  bf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  bf9:	 800100               	add	byte ptr [rcx], 0
-;;  bfc:	 aa                   	stosb	byte ptr [rdi], al
-;;  bfd:	 800100               	add	byte ptr [rcx], 0
-;;  c00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  c09:	 800100               	add	byte ptr [rcx], 0
-;;  c0c:	 aa                   	stosb	byte ptr [rdi], al
-;;  c0d:	 800100               	add	byte ptr [rcx], 0
-;;  c10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  c19:	 800100               	add	byte ptr [rcx], 0
-;;  c1c:	 aa                   	stosb	byte ptr [rdi], al
-;;  c1d:	 800100               	add	byte ptr [rcx], 0
-;;  c20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  c29:	 800100               	add	byte ptr [rcx], 0
-;;  c2c:	 aa                   	stosb	byte ptr [rdi], al
-;;  c2d:	 800100               	add	byte ptr [rcx], 0
-;;  c30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  c39:	 800100               	add	byte ptr [rcx], 0
-;;  c3c:	 aa                   	stosb	byte ptr [rdi], al
-;;  c3d:	 800100               	add	byte ptr [rcx], 0
-;;  c40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  c49:	 800100               	add	byte ptr [rcx], 0
-;;  c4c:	 aa                   	stosb	byte ptr [rdi], al
-;;  c4d:	 800100               	add	byte ptr [rcx], 0
-;;  c50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  c59:	 800100               	add	byte ptr [rcx], 0
-;;  c5c:	 aa                   	stosb	byte ptr [rdi], al
-;;  c5d:	 800100               	add	byte ptr [rcx], 0
-;;  c60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  c69:	 800100               	add	byte ptr [rcx], 0
-;;  c6c:	 aa                   	stosb	byte ptr [rdi], al
-;;  c6d:	 800100               	add	byte ptr [rcx], 0
-;;  c70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  c79:	 800100               	add	byte ptr [rcx], 0
-;;  c7c:	 aa                   	stosb	byte ptr [rdi], al
-;;  c7d:	 800100               	add	byte ptr [rcx], 0
-;;  c80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  c89:	 800100               	add	byte ptr [rcx], 0
-;;  c8c:	 aa                   	stosb	byte ptr [rdi], al
-;;  c8d:	 800100               	add	byte ptr [rcx], 0
-;;  c90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  c99:	 800100               	add	byte ptr [rcx], 0
-;;  c9c:	 aa                   	stosb	byte ptr [rdi], al
-;;  c9d:	 800100               	add	byte ptr [rcx], 0
-;;  ca0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  ca9:	 800100               	add	byte ptr [rcx], 0
-;;  cac:	 aa                   	stosb	byte ptr [rdi], al
-;;  cad:	 800100               	add	byte ptr [rcx], 0
-;;  cb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  cb9:	 800100               	add	byte ptr [rcx], 0
-;;  cbc:	 aa                   	stosb	byte ptr [rdi], al
-;;  cbd:	 800100               	add	byte ptr [rcx], 0
-;;  cc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  cc9:	 800100               	add	byte ptr [rcx], 0
-;;  ccc:	 aa                   	stosb	byte ptr [rdi], al
-;;  ccd:	 800100               	add	byte ptr [rcx], 0
-;;  cd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  cd9:	 800100               	add	byte ptr [rcx], 0
-;;  cdc:	 aa                   	stosb	byte ptr [rdi], al
-;;  cdd:	 800100               	add	byte ptr [rcx], 0
-;;  ce0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  ce9:	 800100               	add	byte ptr [rcx], 0
-;;  cec:	 aa                   	stosb	byte ptr [rdi], al
-;;  ced:	 800100               	add	byte ptr [rcx], 0
-;;  cf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  cf9:	 800100               	add	byte ptr [rcx], 0
-;;  cfc:	 aa                   	stosb	byte ptr [rdi], al
-;;  cfd:	 800100               	add	byte ptr [rcx], 0
-;;  d00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  d09:	 800100               	add	byte ptr [rcx], 0
-;;  d0c:	 aa                   	stosb	byte ptr [rdi], al
-;;  d0d:	 800100               	add	byte ptr [rcx], 0
-;;  d10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  d19:	 800100               	add	byte ptr [rcx], 0
-;;  d1c:	 aa                   	stosb	byte ptr [rdi], al
-;;  d1d:	 800100               	add	byte ptr [rcx], 0
-;;  d20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  d29:	 800100               	add	byte ptr [rcx], 0
-;;  d2c:	 aa                   	stosb	byte ptr [rdi], al
-;;  d2d:	 800100               	add	byte ptr [rcx], 0
-;;  d30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  d39:	 800100               	add	byte ptr [rcx], 0
-;;  d3c:	 aa                   	stosb	byte ptr [rdi], al
-;;  d3d:	 800100               	add	byte ptr [rcx], 0
-;;  d40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  d49:	 800100               	add	byte ptr [rcx], 0
-;;  d4c:	 aa                   	stosb	byte ptr [rdi], al
-;;  d4d:	 800100               	add	byte ptr [rcx], 0
-;;  d50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  d59:	 800100               	add	byte ptr [rcx], 0
-;;  d5c:	 aa                   	stosb	byte ptr [rdi], al
-;;  d5d:	 800100               	add	byte ptr [rcx], 0
-;;  d60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  d69:	 800100               	add	byte ptr [rcx], 0
-;;  d6c:	 aa                   	stosb	byte ptr [rdi], al
-;;  d6d:	 800100               	add	byte ptr [rcx], 0
-;;  d70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  d79:	 800100               	add	byte ptr [rcx], 0
-;;  d7c:	 aa                   	stosb	byte ptr [rdi], al
-;;  d7d:	 800100               	add	byte ptr [rcx], 0
-;;  d80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  d89:	 800100               	add	byte ptr [rcx], 0
-;;  d8c:	 aa                   	stosb	byte ptr [rdi], al
-;;  d8d:	 800100               	add	byte ptr [rcx], 0
-;;  d90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  d99:	 800100               	add	byte ptr [rcx], 0
-;;  d9c:	 aa                   	stosb	byte ptr [rdi], al
-;;  d9d:	 800100               	add	byte ptr [rcx], 0
-;;  da0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  da9:	 800100               	add	byte ptr [rcx], 0
-;;  dac:	 aa                   	stosb	byte ptr [rdi], al
-;;  dad:	 800100               	add	byte ptr [rcx], 0
-;;  db0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  db9:	 800100               	add	byte ptr [rcx], 0
-;;  dbc:	 aa                   	stosb	byte ptr [rdi], al
-;;  dbd:	 800100               	add	byte ptr [rcx], 0
-;;  dc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  dc9:	 800100               	add	byte ptr [rcx], 0
-;;  dcc:	 aa                   	stosb	byte ptr [rdi], al
-;;  dcd:	 800100               	add	byte ptr [rcx], 0
-;;  dd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  dd9:	 800100               	add	byte ptr [rcx], 0
-;;  ddc:	 aa                   	stosb	byte ptr [rdi], al
-;;  ddd:	 800100               	add	byte ptr [rcx], 0
-;;  de0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  de9:	 800100               	add	byte ptr [rcx], 0
-;;  dec:	 aa                   	stosb	byte ptr [rdi], al
-;;  ded:	 800100               	add	byte ptr [rcx], 0
-;;  df0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  df9:	 800100               	add	byte ptr [rcx], 0
-;;  dfc:	 aa                   	stosb	byte ptr [rdi], al
-;;  dfd:	 800100               	add	byte ptr [rcx], 0
-;;  e00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  e09:	 800100               	add	byte ptr [rcx], 0
-;;  e0c:	 aa                   	stosb	byte ptr [rdi], al
-;;  e0d:	 800100               	add	byte ptr [rcx], 0
-;;  e10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  e19:	 800100               	add	byte ptr [rcx], 0
-;;  e1c:	 aa                   	stosb	byte ptr [rdi], al
-;;  e1d:	 800100               	add	byte ptr [rcx], 0
-;;  e20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  e29:	 800100               	add	byte ptr [rcx], 0
-;;  e2c:	 aa                   	stosb	byte ptr [rdi], al
-;;  e2d:	 800100               	add	byte ptr [rcx], 0
-;;  e30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  e39:	 800100               	add	byte ptr [rcx], 0
-;;  e3c:	 aa                   	stosb	byte ptr [rdi], al
-;;  e3d:	 800100               	add	byte ptr [rcx], 0
-;;  e40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  e49:	 800100               	add	byte ptr [rcx], 0
-;;  e4c:	 aa                   	stosb	byte ptr [rdi], al
-;;  e4d:	 800100               	add	byte ptr [rcx], 0
-;;  e50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  e59:	 800100               	add	byte ptr [rcx], 0
-;;  e5c:	 aa                   	stosb	byte ptr [rdi], al
-;;  e5d:	 800100               	add	byte ptr [rcx], 0
-;;  e60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  e69:	 800100               	add	byte ptr [rcx], 0
-;;  e6c:	 aa                   	stosb	byte ptr [rdi], al
-;;  e6d:	 800100               	add	byte ptr [rcx], 0
-;;  e70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  e79:	 800100               	add	byte ptr [rcx], 0
-;;  e7c:	 aa                   	stosb	byte ptr [rdi], al
-;;  e7d:	 800100               	add	byte ptr [rcx], 0
-;;  e80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  e89:	 800100               	add	byte ptr [rcx], 0
-;;  e8c:	 aa                   	stosb	byte ptr [rdi], al
-;;  e8d:	 800100               	add	byte ptr [rcx], 0
-;;  e90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  e99:	 800100               	add	byte ptr [rcx], 0
-;;  e9c:	 aa                   	stosb	byte ptr [rdi], al
-;;  e9d:	 800100               	add	byte ptr [rcx], 0
-;;  ea0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  ea9:	 800100               	add	byte ptr [rcx], 0
-;;  eac:	 aa                   	stosb	byte ptr [rdi], al
-;;  ead:	 800100               	add	byte ptr [rcx], 0
-;;  eb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  eb9:	 800100               	add	byte ptr [rcx], 0
-;;  ebc:	 aa                   	stosb	byte ptr [rdi], al
-;;  ebd:	 800100               	add	byte ptr [rcx], 0
-;;  ec0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  ec9:	 800100               	add	byte ptr [rcx], 0
-;;  ecc:	 aa                   	stosb	byte ptr [rdi], al
-;;  ecd:	 800100               	add	byte ptr [rcx], 0
-;;  ed0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  ed9:	 800100               	add	byte ptr [rcx], 0
-;;  edc:	 aa                   	stosb	byte ptr [rdi], al
-;;  edd:	 800100               	add	byte ptr [rcx], 0
-;;  ee0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  ee9:	 800100               	add	byte ptr [rcx], 0
-;;  eec:	 aa                   	stosb	byte ptr [rdi], al
-;;  eed:	 800100               	add	byte ptr [rcx], 0
-;;  ef0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  ef9:	 800100               	add	byte ptr [rcx], 0
-;;  efc:	 aa                   	stosb	byte ptr [rdi], al
-;;  efd:	 800100               	add	byte ptr [rcx], 0
-;;  f00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  f09:	 800100               	add	byte ptr [rcx], 0
-;;  f0c:	 aa                   	stosb	byte ptr [rdi], al
-;;  f0d:	 800100               	add	byte ptr [rcx], 0
-;;  f10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  f19:	 800100               	add	byte ptr [rcx], 0
-;;  f1c:	 aa                   	stosb	byte ptr [rdi], al
-;;  f1d:	 800100               	add	byte ptr [rcx], 0
-;;  f20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  f29:	 800100               	add	byte ptr [rcx], 0
-;;  f2c:	 aa                   	stosb	byte ptr [rdi], al
-;;  f2d:	 800100               	add	byte ptr [rcx], 0
-;;  f30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  f39:	 800100               	add	byte ptr [rcx], 0
-;;  f3c:	 aa                   	stosb	byte ptr [rdi], al
-;;  f3d:	 800100               	add	byte ptr [rcx], 0
-;;  f40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  f49:	 800100               	add	byte ptr [rcx], 0
-;;  f4c:	 aa                   	stosb	byte ptr [rdi], al
-;;  f4d:	 800100               	add	byte ptr [rcx], 0
-;;  f50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  f59:	 800100               	add	byte ptr [rcx], 0
-;;  f5c:	 aa                   	stosb	byte ptr [rdi], al
-;;  f5d:	 800100               	add	byte ptr [rcx], 0
-;;  f60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  f69:	 800100               	add	byte ptr [rcx], 0
-;;  f6c:	 aa                   	stosb	byte ptr [rdi], al
-;;  f6d:	 800100               	add	byte ptr [rcx], 0
-;;  f70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  f79:	 800100               	add	byte ptr [rcx], 0
-;;  f7c:	 aa                   	stosb	byte ptr [rdi], al
-;;  f7d:	 800100               	add	byte ptr [rcx], 0
-;;  f80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  f89:	 800100               	add	byte ptr [rcx], 0
-;;  f8c:	 aa                   	stosb	byte ptr [rdi], al
-;;  f8d:	 800100               	add	byte ptr [rcx], 0
-;;  f90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  f99:	 800100               	add	byte ptr [rcx], 0
-;;  f9c:	 aa                   	stosb	byte ptr [rdi], al
-;;  f9d:	 800100               	add	byte ptr [rcx], 0
-;;  fa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  fa9:	 800100               	add	byte ptr [rcx], 0
-;;  fac:	 aa                   	stosb	byte ptr [rdi], al
-;;  fad:	 800100               	add	byte ptr [rcx], 0
-;;  fb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  fb9:	 800100               	add	byte ptr [rcx], 0
-;;  fbc:	 aa                   	stosb	byte ptr [rdi], al
-;;  fbd:	 800100               	add	byte ptr [rcx], 0
-;;  fc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  fc9:	 800100               	add	byte ptr [rcx], 0
-;;  fcc:	 aa                   	stosb	byte ptr [rdi], al
-;;  fcd:	 800100               	add	byte ptr [rcx], 0
-;;  fd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  fd9:	 800100               	add	byte ptr [rcx], 0
-;;  fdc:	 aa                   	stosb	byte ptr [rdi], al
-;;  fdd:	 800100               	add	byte ptr [rcx], 0
-;;  fe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  fe9:	 800100               	add	byte ptr [rcx], 0
-;;  fec:	 aa                   	stosb	byte ptr [rdi], al
-;;  fed:	 800100               	add	byte ptr [rcx], 0
-;;  ff0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;;  ff9:	 800100               	add	byte ptr [rcx], 0
-;;  ffc:	 aa                   	stosb	byte ptr [rdi], al
-;;  ffd:	 800100               	add	byte ptr [rcx], 0
-;; 1000:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1009:	 800100               	add	byte ptr [rcx], 0
-;; 100c:	 aa                   	stosb	byte ptr [rdi], al
-;; 100d:	 800100               	add	byte ptr [rcx], 0
-;; 1010:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1019:	 800100               	add	byte ptr [rcx], 0
-;; 101c:	 aa                   	stosb	byte ptr [rdi], al
-;; 101d:	 800100               	add	byte ptr [rcx], 0
-;; 1020:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1029:	 800100               	add	byte ptr [rcx], 0
-;; 102c:	 aa                   	stosb	byte ptr [rdi], al
-;; 102d:	 800100               	add	byte ptr [rcx], 0
-;; 1030:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1039:	 800100               	add	byte ptr [rcx], 0
-;; 103c:	 aa                   	stosb	byte ptr [rdi], al
-;; 103d:	 800100               	add	byte ptr [rcx], 0
-;; 1040:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1049:	 800100               	add	byte ptr [rcx], 0
-;; 104c:	 aa                   	stosb	byte ptr [rdi], al
-;; 104d:	 800100               	add	byte ptr [rcx], 0
-;; 1050:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1059:	 800100               	add	byte ptr [rcx], 0
-;; 105c:	 aa                   	stosb	byte ptr [rdi], al
-;; 105d:	 800100               	add	byte ptr [rcx], 0
-;; 1060:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1069:	 800100               	add	byte ptr [rcx], 0
-;; 106c:	 aa                   	stosb	byte ptr [rdi], al
-;; 106d:	 800100               	add	byte ptr [rcx], 0
-;; 1070:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1079:	 800100               	add	byte ptr [rcx], 0
-;; 107c:	 aa                   	stosb	byte ptr [rdi], al
-;; 107d:	 800100               	add	byte ptr [rcx], 0
-;; 1080:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1089:	 800100               	add	byte ptr [rcx], 0
-;; 108c:	 aa                   	stosb	byte ptr [rdi], al
-;; 108d:	 800100               	add	byte ptr [rcx], 0
-;; 1090:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1099:	 800100               	add	byte ptr [rcx], 0
-;; 109c:	 aa                   	stosb	byte ptr [rdi], al
-;; 109d:	 800100               	add	byte ptr [rcx], 0
-;; 10a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10a9:	 800100               	add	byte ptr [rcx], 0
-;; 10ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 10ad:	 800100               	add	byte ptr [rcx], 0
-;; 10b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10b9:	 800100               	add	byte ptr [rcx], 0
-;; 10bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 10bd:	 800100               	add	byte ptr [rcx], 0
-;; 10c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10c9:	 800100               	add	byte ptr [rcx], 0
-;; 10cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 10cd:	 800100               	add	byte ptr [rcx], 0
-;; 10d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10d9:	 800100               	add	byte ptr [rcx], 0
-;; 10dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 10dd:	 800100               	add	byte ptr [rcx], 0
-;; 10e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10e9:	 800100               	add	byte ptr [rcx], 0
-;; 10ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 10ed:	 800100               	add	byte ptr [rcx], 0
-;; 10f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10f9:	 800100               	add	byte ptr [rcx], 0
-;; 10fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 10fd:	 800100               	add	byte ptr [rcx], 0
-;; 1100:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1109:	 800100               	add	byte ptr [rcx], 0
-;; 110c:	 aa                   	stosb	byte ptr [rdi], al
-;; 110d:	 800100               	add	byte ptr [rcx], 0
-;; 1110:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1119:	 800100               	add	byte ptr [rcx], 0
-;; 111c:	 aa                   	stosb	byte ptr [rdi], al
-;; 111d:	 800100               	add	byte ptr [rcx], 0
-;; 1120:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1129:	 800100               	add	byte ptr [rcx], 0
-;; 112c:	 aa                   	stosb	byte ptr [rdi], al
-;; 112d:	 800100               	add	byte ptr [rcx], 0
-;; 1130:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1139:	 800100               	add	byte ptr [rcx], 0
-;; 113c:	 aa                   	stosb	byte ptr [rdi], al
-;; 113d:	 800100               	add	byte ptr [rcx], 0
-;; 1140:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1149:	 800100               	add	byte ptr [rcx], 0
-;; 114c:	 aa                   	stosb	byte ptr [rdi], al
-;; 114d:	 800100               	add	byte ptr [rcx], 0
-;; 1150:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1159:	 800100               	add	byte ptr [rcx], 0
-;; 115c:	 aa                   	stosb	byte ptr [rdi], al
-;; 115d:	 800100               	add	byte ptr [rcx], 0
-;; 1160:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1169:	 800100               	add	byte ptr [rcx], 0
-;; 116c:	 aa                   	stosb	byte ptr [rdi], al
-;; 116d:	 800100               	add	byte ptr [rcx], 0
-;; 1170:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1179:	 800100               	add	byte ptr [rcx], 0
-;; 117c:	 aa                   	stosb	byte ptr [rdi], al
-;; 117d:	 800100               	add	byte ptr [rcx], 0
-;; 1180:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1189:	 800100               	add	byte ptr [rcx], 0
-;; 118c:	 aa                   	stosb	byte ptr [rdi], al
-;; 118d:	 800100               	add	byte ptr [rcx], 0
-;; 1190:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1199:	 800100               	add	byte ptr [rcx], 0
-;; 119c:	 aa                   	stosb	byte ptr [rdi], al
-;; 119d:	 800100               	add	byte ptr [rcx], 0
-;; 11a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11a9:	 800100               	add	byte ptr [rcx], 0
-;; 11ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 11ad:	 800100               	add	byte ptr [rcx], 0
-;; 11b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11b9:	 800100               	add	byte ptr [rcx], 0
-;; 11bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 11bd:	 800100               	add	byte ptr [rcx], 0
-;; 11c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11c9:	 800100               	add	byte ptr [rcx], 0
-;; 11cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 11cd:	 800100               	add	byte ptr [rcx], 0
-;; 11d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11d9:	 800100               	add	byte ptr [rcx], 0
-;; 11dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 11dd:	 800100               	add	byte ptr [rcx], 0
-;; 11e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11e9:	 800100               	add	byte ptr [rcx], 0
-;; 11ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 11ed:	 800100               	add	byte ptr [rcx], 0
-;; 11f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11f9:	 800100               	add	byte ptr [rcx], 0
-;; 11fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 11fd:	 800100               	add	byte ptr [rcx], 0
-;; 1200:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1209:	 800100               	add	byte ptr [rcx], 0
-;; 120c:	 aa                   	stosb	byte ptr [rdi], al
-;; 120d:	 800100               	add	byte ptr [rcx], 0
-;; 1210:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1219:	 800100               	add	byte ptr [rcx], 0
-;; 121c:	 aa                   	stosb	byte ptr [rdi], al
-;; 121d:	 800100               	add	byte ptr [rcx], 0
-;; 1220:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1229:	 800100               	add	byte ptr [rcx], 0
-;; 122c:	 aa                   	stosb	byte ptr [rdi], al
-;; 122d:	 800100               	add	byte ptr [rcx], 0
-;; 1230:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1239:	 800100               	add	byte ptr [rcx], 0
-;; 123c:	 aa                   	stosb	byte ptr [rdi], al
-;; 123d:	 800100               	add	byte ptr [rcx], 0
-;; 1240:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1249:	 800100               	add	byte ptr [rcx], 0
-;; 124c:	 aa                   	stosb	byte ptr [rdi], al
-;; 124d:	 800100               	add	byte ptr [rcx], 0
-;; 1250:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1259:	 800100               	add	byte ptr [rcx], 0
-;; 125c:	 aa                   	stosb	byte ptr [rdi], al
-;; 125d:	 800100               	add	byte ptr [rcx], 0
-;; 1260:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1269:	 800100               	add	byte ptr [rcx], 0
-;; 126c:	 aa                   	stosb	byte ptr [rdi], al
-;; 126d:	 800100               	add	byte ptr [rcx], 0
-;; 1270:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1279:	 800100               	add	byte ptr [rcx], 0
-;; 127c:	 aa                   	stosb	byte ptr [rdi], al
-;; 127d:	 800100               	add	byte ptr [rcx], 0
-;; 1280:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1289:	 800100               	add	byte ptr [rcx], 0
-;; 128c:	 aa                   	stosb	byte ptr [rdi], al
-;; 128d:	 800100               	add	byte ptr [rcx], 0
-;; 1290:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1299:	 800100               	add	byte ptr [rcx], 0
-;; 129c:	 aa                   	stosb	byte ptr [rdi], al
-;; 129d:	 800100               	add	byte ptr [rcx], 0
-;; 12a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12a9:	 800100               	add	byte ptr [rcx], 0
-;; 12ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 12ad:	 800100               	add	byte ptr [rcx], 0
-;; 12b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12b9:	 800100               	add	byte ptr [rcx], 0
-;; 12bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 12bd:	 800100               	add	byte ptr [rcx], 0
-;; 12c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12c9:	 800100               	add	byte ptr [rcx], 0
-;; 12cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 12cd:	 800100               	add	byte ptr [rcx], 0
-;; 12d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12d9:	 800100               	add	byte ptr [rcx], 0
-;; 12dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 12dd:	 800100               	add	byte ptr [rcx], 0
-;; 12e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12e9:	 800100               	add	byte ptr [rcx], 0
-;; 12ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 12ed:	 800100               	add	byte ptr [rcx], 0
-;; 12f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12f9:	 800100               	add	byte ptr [rcx], 0
-;; 12fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 12fd:	 800100               	add	byte ptr [rcx], 0
-;; 1300:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1309:	 800100               	add	byte ptr [rcx], 0
-;; 130c:	 aa                   	stosb	byte ptr [rdi], al
-;; 130d:	 800100               	add	byte ptr [rcx], 0
-;; 1310:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1319:	 800100               	add	byte ptr [rcx], 0
-;; 131c:	 aa                   	stosb	byte ptr [rdi], al
-;; 131d:	 800100               	add	byte ptr [rcx], 0
-;; 1320:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1329:	 800100               	add	byte ptr [rcx], 0
-;; 132c:	 aa                   	stosb	byte ptr [rdi], al
-;; 132d:	 800100               	add	byte ptr [rcx], 0
-;; 1330:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1339:	 800100               	add	byte ptr [rcx], 0
-;; 133c:	 aa                   	stosb	byte ptr [rdi], al
-;; 133d:	 800100               	add	byte ptr [rcx], 0
-;; 1340:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1349:	 800100               	add	byte ptr [rcx], 0
-;; 134c:	 aa                   	stosb	byte ptr [rdi], al
-;; 134d:	 800100               	add	byte ptr [rcx], 0
-;; 1350:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1359:	 800100               	add	byte ptr [rcx], 0
-;; 135c:	 aa                   	stosb	byte ptr [rdi], al
-;; 135d:	 800100               	add	byte ptr [rcx], 0
-;; 1360:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1369:	 800100               	add	byte ptr [rcx], 0
-;; 136c:	 aa                   	stosb	byte ptr [rdi], al
-;; 136d:	 800100               	add	byte ptr [rcx], 0
-;; 1370:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1379:	 800100               	add	byte ptr [rcx], 0
-;; 137c:	 aa                   	stosb	byte ptr [rdi], al
-;; 137d:	 800100               	add	byte ptr [rcx], 0
-;; 1380:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1389:	 800100               	add	byte ptr [rcx], 0
-;; 138c:	 aa                   	stosb	byte ptr [rdi], al
-;; 138d:	 800100               	add	byte ptr [rcx], 0
-;; 1390:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1399:	 800100               	add	byte ptr [rcx], 0
-;; 139c:	 aa                   	stosb	byte ptr [rdi], al
-;; 139d:	 800100               	add	byte ptr [rcx], 0
-;; 13a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13a9:	 800100               	add	byte ptr [rcx], 0
-;; 13ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 13ad:	 800100               	add	byte ptr [rcx], 0
-;; 13b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13b9:	 800100               	add	byte ptr [rcx], 0
-;; 13bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 13bd:	 800100               	add	byte ptr [rcx], 0
-;; 13c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13c9:	 800100               	add	byte ptr [rcx], 0
-;; 13cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 13cd:	 800100               	add	byte ptr [rcx], 0
-;; 13d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13d9:	 800100               	add	byte ptr [rcx], 0
-;; 13dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 13dd:	 800100               	add	byte ptr [rcx], 0
-;; 13e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13e9:	 800100               	add	byte ptr [rcx], 0
-;; 13ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 13ed:	 800100               	add	byte ptr [rcx], 0
-;; 13f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13f9:	 800100               	add	byte ptr [rcx], 0
-;; 13fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 13fd:	 800100               	add	byte ptr [rcx], 0
-;; 1400:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1409:	 800100               	add	byte ptr [rcx], 0
-;; 140c:	 aa                   	stosb	byte ptr [rdi], al
-;; 140d:	 800100               	add	byte ptr [rcx], 0
-;; 1410:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1419:	 800100               	add	byte ptr [rcx], 0
-;; 141c:	 aa                   	stosb	byte ptr [rdi], al
-;; 141d:	 800100               	add	byte ptr [rcx], 0
-;; 1420:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1429:	 800100               	add	byte ptr [rcx], 0
-;; 142c:	 aa                   	stosb	byte ptr [rdi], al
-;; 142d:	 800100               	add	byte ptr [rcx], 0
-;; 1430:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1439:	 800100               	add	byte ptr [rcx], 0
-;; 143c:	 aa                   	stosb	byte ptr [rdi], al
-;; 143d:	 800100               	add	byte ptr [rcx], 0
-;; 1440:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1449:	 800100               	add	byte ptr [rcx], 0
-;; 144c:	 aa                   	stosb	byte ptr [rdi], al
-;; 144d:	 800100               	add	byte ptr [rcx], 0
-;; 1450:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1459:	 800100               	add	byte ptr [rcx], 0
-;; 145c:	 aa                   	stosb	byte ptr [rdi], al
-;; 145d:	 800100               	add	byte ptr [rcx], 0
-;; 1460:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1469:	 800100               	add	byte ptr [rcx], 0
-;; 146c:	 aa                   	stosb	byte ptr [rdi], al
-;; 146d:	 800100               	add	byte ptr [rcx], 0
-;; 1470:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1479:	 800100               	add	byte ptr [rcx], 0
-;; 147c:	 aa                   	stosb	byte ptr [rdi], al
-;; 147d:	 800100               	add	byte ptr [rcx], 0
-;; 1480:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1489:	 800100               	add	byte ptr [rcx], 0
-;; 148c:	 aa                   	stosb	byte ptr [rdi], al
-;; 148d:	 800100               	add	byte ptr [rcx], 0
-;; 1490:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1499:	 800100               	add	byte ptr [rcx], 0
-;; 149c:	 aa                   	stosb	byte ptr [rdi], al
-;; 149d:	 800100               	add	byte ptr [rcx], 0
-;; 14a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14a9:	 800100               	add	byte ptr [rcx], 0
-;; 14ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 14ad:	 800100               	add	byte ptr [rcx], 0
-;; 14b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14b9:	 800100               	add	byte ptr [rcx], 0
-;; 14bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 14bd:	 800100               	add	byte ptr [rcx], 0
-;; 14c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14c9:	 800100               	add	byte ptr [rcx], 0
-;; 14cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 14cd:	 800100               	add	byte ptr [rcx], 0
-;; 14d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14d9:	 800100               	add	byte ptr [rcx], 0
-;; 14dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 14dd:	 800100               	add	byte ptr [rcx], 0
-;; 14e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14e9:	 800100               	add	byte ptr [rcx], 0
-;; 14ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 14ed:	 800100               	add	byte ptr [rcx], 0
-;; 14f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14f9:	 800100               	add	byte ptr [rcx], 0
-;; 14fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 14fd:	 800100               	add	byte ptr [rcx], 0
-;; 1500:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1509:	 800100               	add	byte ptr [rcx], 0
-;; 150c:	 aa                   	stosb	byte ptr [rdi], al
-;; 150d:	 800100               	add	byte ptr [rcx], 0
-;; 1510:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1519:	 800100               	add	byte ptr [rcx], 0
-;; 151c:	 aa                   	stosb	byte ptr [rdi], al
-;; 151d:	 800100               	add	byte ptr [rcx], 0
-;; 1520:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1529:	 800100               	add	byte ptr [rcx], 0
-;; 152c:	 aa                   	stosb	byte ptr [rdi], al
-;; 152d:	 800100               	add	byte ptr [rcx], 0
-;; 1530:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1539:	 800100               	add	byte ptr [rcx], 0
-;; 153c:	 aa                   	stosb	byte ptr [rdi], al
-;; 153d:	 800100               	add	byte ptr [rcx], 0
-;; 1540:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1549:	 800100               	add	byte ptr [rcx], 0
-;; 154c:	 aa                   	stosb	byte ptr [rdi], al
-;; 154d:	 800100               	add	byte ptr [rcx], 0
-;; 1550:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1559:	 800100               	add	byte ptr [rcx], 0
-;; 155c:	 aa                   	stosb	byte ptr [rdi], al
-;; 155d:	 800100               	add	byte ptr [rcx], 0
-;; 1560:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1569:	 800100               	add	byte ptr [rcx], 0
-;; 156c:	 aa                   	stosb	byte ptr [rdi], al
-;; 156d:	 800100               	add	byte ptr [rcx], 0
-;; 1570:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1579:	 800100               	add	byte ptr [rcx], 0
-;; 157c:	 aa                   	stosb	byte ptr [rdi], al
-;; 157d:	 800100               	add	byte ptr [rcx], 0
-;; 1580:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1589:	 800100               	add	byte ptr [rcx], 0
-;; 158c:	 aa                   	stosb	byte ptr [rdi], al
-;; 158d:	 800100               	add	byte ptr [rcx], 0
-;; 1590:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1599:	 800100               	add	byte ptr [rcx], 0
-;; 159c:	 aa                   	stosb	byte ptr [rdi], al
-;; 159d:	 800100               	add	byte ptr [rcx], 0
-;; 15a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15a9:	 800100               	add	byte ptr [rcx], 0
-;; 15ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 15ad:	 800100               	add	byte ptr [rcx], 0
-;; 15b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15b9:	 800100               	add	byte ptr [rcx], 0
-;; 15bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 15bd:	 800100               	add	byte ptr [rcx], 0
-;; 15c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15c9:	 800100               	add	byte ptr [rcx], 0
-;; 15cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 15cd:	 800100               	add	byte ptr [rcx], 0
-;; 15d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15d9:	 800100               	add	byte ptr [rcx], 0
-;; 15dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 15dd:	 800100               	add	byte ptr [rcx], 0
-;; 15e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15e9:	 800100               	add	byte ptr [rcx], 0
-;; 15ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 15ed:	 800100               	add	byte ptr [rcx], 0
-;; 15f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15f9:	 800100               	add	byte ptr [rcx], 0
-;; 15fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 15fd:	 800100               	add	byte ptr [rcx], 0
-;; 1600:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1609:	 800100               	add	byte ptr [rcx], 0
-;; 160c:	 aa                   	stosb	byte ptr [rdi], al
-;; 160d:	 800100               	add	byte ptr [rcx], 0
-;; 1610:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1619:	 800100               	add	byte ptr [rcx], 0
-;; 161c:	 aa                   	stosb	byte ptr [rdi], al
-;; 161d:	 800100               	add	byte ptr [rcx], 0
-;; 1620:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1629:	 800100               	add	byte ptr [rcx], 0
-;; 162c:	 aa                   	stosb	byte ptr [rdi], al
-;; 162d:	 800100               	add	byte ptr [rcx], 0
-;; 1630:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1639:	 800100               	add	byte ptr [rcx], 0
-;; 163c:	 aa                   	stosb	byte ptr [rdi], al
-;; 163d:	 800100               	add	byte ptr [rcx], 0
-;; 1640:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1649:	 800100               	add	byte ptr [rcx], 0
-;; 164c:	 aa                   	stosb	byte ptr [rdi], al
-;; 164d:	 800100               	add	byte ptr [rcx], 0
-;; 1650:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1659:	 800100               	add	byte ptr [rcx], 0
-;; 165c:	 aa                   	stosb	byte ptr [rdi], al
-;; 165d:	 800100               	add	byte ptr [rcx], 0
-;; 1660:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1669:	 800100               	add	byte ptr [rcx], 0
-;; 166c:	 aa                   	stosb	byte ptr [rdi], al
-;; 166d:	 800100               	add	byte ptr [rcx], 0
-;; 1670:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1679:	 800100               	add	byte ptr [rcx], 0
-;; 167c:	 aa                   	stosb	byte ptr [rdi], al
-;; 167d:	 800100               	add	byte ptr [rcx], 0
-;; 1680:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1689:	 800100               	add	byte ptr [rcx], 0
-;; 168c:	 aa                   	stosb	byte ptr [rdi], al
-;; 168d:	 800100               	add	byte ptr [rcx], 0
-;; 1690:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1699:	 800100               	add	byte ptr [rcx], 0
-;; 169c:	 aa                   	stosb	byte ptr [rdi], al
-;; 169d:	 800100               	add	byte ptr [rcx], 0
-;; 16a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16a9:	 800100               	add	byte ptr [rcx], 0
-;; 16ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 16ad:	 800100               	add	byte ptr [rcx], 0
-;; 16b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16b9:	 800100               	add	byte ptr [rcx], 0
-;; 16bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 16bd:	 800100               	add	byte ptr [rcx], 0
-;; 16c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16c9:	 800100               	add	byte ptr [rcx], 0
-;; 16cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 16cd:	 800100               	add	byte ptr [rcx], 0
-;; 16d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16d9:	 800100               	add	byte ptr [rcx], 0
-;; 16dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 16dd:	 800100               	add	byte ptr [rcx], 0
-;; 16e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16e9:	 800100               	add	byte ptr [rcx], 0
-;; 16ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 16ed:	 800100               	add	byte ptr [rcx], 0
-;; 16f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16f9:	 800100               	add	byte ptr [rcx], 0
-;; 16fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 16fd:	 800100               	add	byte ptr [rcx], 0
-;; 1700:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1709:	 800100               	add	byte ptr [rcx], 0
-;; 170c:	 aa                   	stosb	byte ptr [rdi], al
-;; 170d:	 800100               	add	byte ptr [rcx], 0
-;; 1710:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1719:	 800100               	add	byte ptr [rcx], 0
-;; 171c:	 aa                   	stosb	byte ptr [rdi], al
-;; 171d:	 800100               	add	byte ptr [rcx], 0
-;; 1720:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1729:	 800100               	add	byte ptr [rcx], 0
-;; 172c:	 aa                   	stosb	byte ptr [rdi], al
-;; 172d:	 800100               	add	byte ptr [rcx], 0
-;; 1730:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1739:	 800100               	add	byte ptr [rcx], 0
-;; 173c:	 aa                   	stosb	byte ptr [rdi], al
-;; 173d:	 800100               	add	byte ptr [rcx], 0
-;; 1740:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1749:	 800100               	add	byte ptr [rcx], 0
-;; 174c:	 aa                   	stosb	byte ptr [rdi], al
-;; 174d:	 800100               	add	byte ptr [rcx], 0
-;; 1750:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1759:	 800100               	add	byte ptr [rcx], 0
-;; 175c:	 aa                   	stosb	byte ptr [rdi], al
-;; 175d:	 800100               	add	byte ptr [rcx], 0
-;; 1760:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1769:	 800100               	add	byte ptr [rcx], 0
-;; 176c:	 aa                   	stosb	byte ptr [rdi], al
-;; 176d:	 800100               	add	byte ptr [rcx], 0
-;; 1770:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1779:	 800100               	add	byte ptr [rcx], 0
-;; 177c:	 aa                   	stosb	byte ptr [rdi], al
-;; 177d:	 800100               	add	byte ptr [rcx], 0
-;; 1780:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1789:	 800100               	add	byte ptr [rcx], 0
-;; 178c:	 aa                   	stosb	byte ptr [rdi], al
-;; 178d:	 800100               	add	byte ptr [rcx], 0
-;; 1790:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1799:	 800100               	add	byte ptr [rcx], 0
-;; 179c:	 aa                   	stosb	byte ptr [rdi], al
-;; 179d:	 800100               	add	byte ptr [rcx], 0
-;; 17a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17a9:	 800100               	add	byte ptr [rcx], 0
-;; 17ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 17ad:	 800100               	add	byte ptr [rcx], 0
-;; 17b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17b9:	 800100               	add	byte ptr [rcx], 0
-;; 17bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 17bd:	 800100               	add	byte ptr [rcx], 0
-;; 17c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17c9:	 800100               	add	byte ptr [rcx], 0
-;; 17cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 17cd:	 800100               	add	byte ptr [rcx], 0
-;; 17d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17d9:	 800100               	add	byte ptr [rcx], 0
-;; 17dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 17dd:	 800100               	add	byte ptr [rcx], 0
-;; 17e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17e9:	 800100               	add	byte ptr [rcx], 0
-;; 17ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 17ed:	 800100               	add	byte ptr [rcx], 0
-;; 17f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17f9:	 800100               	add	byte ptr [rcx], 0
-;; 17fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 17fd:	 800100               	add	byte ptr [rcx], 0
-;; 1800:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1809:	 800100               	add	byte ptr [rcx], 0
-;; 180c:	 aa                   	stosb	byte ptr [rdi], al
-;; 180d:	 800100               	add	byte ptr [rcx], 0
-;; 1810:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1819:	 800100               	add	byte ptr [rcx], 0
-;; 181c:	 aa                   	stosb	byte ptr [rdi], al
-;; 181d:	 800100               	add	byte ptr [rcx], 0
-;; 1820:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1829:	 800100               	add	byte ptr [rcx], 0
-;; 182c:	 aa                   	stosb	byte ptr [rdi], al
-;; 182d:	 800100               	add	byte ptr [rcx], 0
-;; 1830:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1839:	 800100               	add	byte ptr [rcx], 0
-;; 183c:	 aa                   	stosb	byte ptr [rdi], al
-;; 183d:	 800100               	add	byte ptr [rcx], 0
-;; 1840:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1849:	 800100               	add	byte ptr [rcx], 0
-;; 184c:	 aa                   	stosb	byte ptr [rdi], al
-;; 184d:	 800100               	add	byte ptr [rcx], 0
-;; 1850:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1859:	 800100               	add	byte ptr [rcx], 0
-;; 185c:	 aa                   	stosb	byte ptr [rdi], al
-;; 185d:	 800100               	add	byte ptr [rcx], 0
-;; 1860:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1869:	 800100               	add	byte ptr [rcx], 0
-;; 186c:	 aa                   	stosb	byte ptr [rdi], al
-;; 186d:	 800100               	add	byte ptr [rcx], 0
-;; 1870:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1879:	 800100               	add	byte ptr [rcx], 0
-;; 187c:	 aa                   	stosb	byte ptr [rdi], al
-;; 187d:	 800100               	add	byte ptr [rcx], 0
-;; 1880:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1889:	 800100               	add	byte ptr [rcx], 0
-;; 188c:	 aa                   	stosb	byte ptr [rdi], al
-;; 188d:	 800100               	add	byte ptr [rcx], 0
-;; 1890:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1899:	 800100               	add	byte ptr [rcx], 0
-;; 189c:	 aa                   	stosb	byte ptr [rdi], al
-;; 189d:	 800100               	add	byte ptr [rcx], 0
-;; 18a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 18a9:	 800100               	add	byte ptr [rcx], 0
-;; 18ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 18ad:	 800100               	add	byte ptr [rcx], 0
-;; 18b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 18b9:	 800100               	add	byte ptr [rcx], 0
-;; 18bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 18bd:	 800100               	add	byte ptr [rcx], 0
-;; 18c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 18c9:	 800100               	add	byte ptr [rcx], 0
-;; 18cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 18cd:	 800100               	add	byte ptr [rcx], 0
-;; 18d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 18d9:	 800100               	add	byte ptr [rcx], 0
-;; 18dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 18dd:	 800100               	add	byte ptr [rcx], 0
-;; 18e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 18e9:	 800100               	add	byte ptr [rcx], 0
-;; 18ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 18ed:	 800100               	add	byte ptr [rcx], 0
-;; 18f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 18f9:	 800100               	add	byte ptr [rcx], 0
-;; 18fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 18fd:	 800100               	add	byte ptr [rcx], 0
-;; 1900:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1909:	 800100               	add	byte ptr [rcx], 0
-;; 190c:	 aa                   	stosb	byte ptr [rdi], al
-;; 190d:	 800100               	add	byte ptr [rcx], 0
-;; 1910:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1919:	 800100               	add	byte ptr [rcx], 0
-;; 191c:	 aa                   	stosb	byte ptr [rdi], al
-;; 191d:	 800100               	add	byte ptr [rcx], 0
-;; 1920:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1929:	 800100               	add	byte ptr [rcx], 0
-;; 192c:	 aa                   	stosb	byte ptr [rdi], al
-;; 192d:	 800100               	add	byte ptr [rcx], 0
-;; 1930:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1939:	 800100               	add	byte ptr [rcx], 0
-;; 193c:	 aa                   	stosb	byte ptr [rdi], al
-;; 193d:	 800100               	add	byte ptr [rcx], 0
-;; 1940:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1949:	 800100               	add	byte ptr [rcx], 0
-;; 194c:	 aa                   	stosb	byte ptr [rdi], al
-;; 194d:	 800100               	add	byte ptr [rcx], 0
-;; 1950:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1959:	 800100               	add	byte ptr [rcx], 0
-;; 195c:	 aa                   	stosb	byte ptr [rdi], al
-;; 195d:	 800100               	add	byte ptr [rcx], 0
-;; 1960:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1969:	 800100               	add	byte ptr [rcx], 0
-;; 196c:	 aa                   	stosb	byte ptr [rdi], al
-;; 196d:	 800100               	add	byte ptr [rcx], 0
-;; 1970:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1979:	 800100               	add	byte ptr [rcx], 0
-;; 197c:	 aa                   	stosb	byte ptr [rdi], al
-;; 197d:	 800100               	add	byte ptr [rcx], 0
-;; 1980:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1989:	 800100               	add	byte ptr [rcx], 0
-;; 198c:	 aa                   	stosb	byte ptr [rdi], al
-;; 198d:	 800100               	add	byte ptr [rcx], 0
-;; 1990:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1999:	 800100               	add	byte ptr [rcx], 0
-;; 199c:	 aa                   	stosb	byte ptr [rdi], al
-;; 199d:	 800100               	add	byte ptr [rcx], 0
-;; 19a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 19a9:	 800100               	add	byte ptr [rcx], 0
-;; 19ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 19ad:	 800100               	add	byte ptr [rcx], 0
-;; 19b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 19b9:	 800100               	add	byte ptr [rcx], 0
-;; 19bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 19bd:	 800100               	add	byte ptr [rcx], 0
-;; 19c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 19c9:	 800100               	add	byte ptr [rcx], 0
-;; 19cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 19cd:	 800100               	add	byte ptr [rcx], 0
-;; 19d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 19d9:	 800100               	add	byte ptr [rcx], 0
-;; 19dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 19dd:	 800100               	add	byte ptr [rcx], 0
-;; 19e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 19e9:	 800100               	add	byte ptr [rcx], 0
-;; 19ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 19ed:	 800100               	add	byte ptr [rcx], 0
-;; 19f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 19f9:	 800100               	add	byte ptr [rcx], 0
-;; 19fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 19fd:	 800100               	add	byte ptr [rcx], 0
-;; 1a00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1a09:	 800100               	add	byte ptr [rcx], 0
-;; 1a0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1a0d:	 800100               	add	byte ptr [rcx], 0
-;; 1a10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1a19:	 800100               	add	byte ptr [rcx], 0
-;; 1a1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1a1d:	 800100               	add	byte ptr [rcx], 0
-;; 1a20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1a29:	 800100               	add	byte ptr [rcx], 0
-;; 1a2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1a2d:	 800100               	add	byte ptr [rcx], 0
-;; 1a30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1a39:	 800100               	add	byte ptr [rcx], 0
-;; 1a3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1a3d:	 800100               	add	byte ptr [rcx], 0
-;; 1a40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1a49:	 800100               	add	byte ptr [rcx], 0
-;; 1a4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1a4d:	 800100               	add	byte ptr [rcx], 0
-;; 1a50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1a59:	 800100               	add	byte ptr [rcx], 0
-;; 1a5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1a5d:	 800100               	add	byte ptr [rcx], 0
-;; 1a60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1a69:	 800100               	add	byte ptr [rcx], 0
-;; 1a6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1a6d:	 800100               	add	byte ptr [rcx], 0
-;; 1a70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1a79:	 800100               	add	byte ptr [rcx], 0
-;; 1a7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1a7d:	 800100               	add	byte ptr [rcx], 0
-;; 1a80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1a89:	 800100               	add	byte ptr [rcx], 0
-;; 1a8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1a8d:	 800100               	add	byte ptr [rcx], 0
-;; 1a90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1a99:	 800100               	add	byte ptr [rcx], 0
-;; 1a9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1a9d:	 800100               	add	byte ptr [rcx], 0
-;; 1aa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1aa9:	 800100               	add	byte ptr [rcx], 0
-;; 1aac:	 aa                   	stosb	byte ptr [rdi], al
-;; 1aad:	 800100               	add	byte ptr [rcx], 0
-;; 1ab0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1ab9:	 800100               	add	byte ptr [rcx], 0
-;; 1abc:	 aa                   	stosb	byte ptr [rdi], al
-;; 1abd:	 800100               	add	byte ptr [rcx], 0
-;; 1ac0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1ac9:	 800100               	add	byte ptr [rcx], 0
-;; 1acc:	 aa                   	stosb	byte ptr [rdi], al
-;; 1acd:	 800100               	add	byte ptr [rcx], 0
-;; 1ad0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1ad9:	 800100               	add	byte ptr [rcx], 0
-;; 1adc:	 aa                   	stosb	byte ptr [rdi], al
-;; 1add:	 800100               	add	byte ptr [rcx], 0
-;; 1ae0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1ae9:	 800100               	add	byte ptr [rcx], 0
-;; 1aec:	 aa                   	stosb	byte ptr [rdi], al
-;; 1aed:	 800100               	add	byte ptr [rcx], 0
-;; 1af0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1af9:	 800100               	add	byte ptr [rcx], 0
-;; 1afc:	 aa                   	stosb	byte ptr [rdi], al
-;; 1afd:	 800100               	add	byte ptr [rcx], 0
-;; 1b00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1b09:	 800100               	add	byte ptr [rcx], 0
-;; 1b0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1b0d:	 800100               	add	byte ptr [rcx], 0
-;; 1b10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1b19:	 800100               	add	byte ptr [rcx], 0
-;; 1b1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1b1d:	 800100               	add	byte ptr [rcx], 0
-;; 1b20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1b29:	 800100               	add	byte ptr [rcx], 0
-;; 1b2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1b2d:	 800100               	add	byte ptr [rcx], 0
-;; 1b30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1b39:	 800100               	add	byte ptr [rcx], 0
-;; 1b3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1b3d:	 800100               	add	byte ptr [rcx], 0
-;; 1b40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1b49:	 800100               	add	byte ptr [rcx], 0
-;; 1b4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1b4d:	 800100               	add	byte ptr [rcx], 0
-;; 1b50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1b59:	 800100               	add	byte ptr [rcx], 0
-;; 1b5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1b5d:	 800100               	add	byte ptr [rcx], 0
-;; 1b60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1b69:	 800100               	add	byte ptr [rcx], 0
-;; 1b6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1b6d:	 800100               	add	byte ptr [rcx], 0
-;; 1b70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1b79:	 800100               	add	byte ptr [rcx], 0
-;; 1b7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1b7d:	 800100               	add	byte ptr [rcx], 0
-;; 1b80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1b89:	 800100               	add	byte ptr [rcx], 0
-;; 1b8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1b8d:	 800100               	add	byte ptr [rcx], 0
-;; 1b90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1b99:	 800100               	add	byte ptr [rcx], 0
-;; 1b9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1b9d:	 800100               	add	byte ptr [rcx], 0
-;; 1ba0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1ba9:	 800100               	add	byte ptr [rcx], 0
-;; 1bac:	 aa                   	stosb	byte ptr [rdi], al
-;; 1bad:	 800100               	add	byte ptr [rcx], 0
-;; 1bb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1bb9:	 800100               	add	byte ptr [rcx], 0
-;; 1bbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 1bbd:	 800100               	add	byte ptr [rcx], 0
-;; 1bc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1bc9:	 800100               	add	byte ptr [rcx], 0
-;; 1bcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 1bcd:	 800100               	add	byte ptr [rcx], 0
-;; 1bd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1bd9:	 800100               	add	byte ptr [rcx], 0
-;; 1bdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 1bdd:	 800100               	add	byte ptr [rcx], 0
-;; 1be0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1be9:	 800100               	add	byte ptr [rcx], 0
-;; 1bec:	 aa                   	stosb	byte ptr [rdi], al
-;; 1bed:	 800100               	add	byte ptr [rcx], 0
-;; 1bf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1bf9:	 800100               	add	byte ptr [rcx], 0
-;; 1bfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 1bfd:	 800100               	add	byte ptr [rcx], 0
-;; 1c00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1c09:	 800100               	add	byte ptr [rcx], 0
-;; 1c0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1c0d:	 800100               	add	byte ptr [rcx], 0
-;; 1c10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1c19:	 800100               	add	byte ptr [rcx], 0
-;; 1c1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1c1d:	 800100               	add	byte ptr [rcx], 0
-;; 1c20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1c29:	 800100               	add	byte ptr [rcx], 0
-;; 1c2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1c2d:	 800100               	add	byte ptr [rcx], 0
-;; 1c30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1c39:	 800100               	add	byte ptr [rcx], 0
-;; 1c3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1c3d:	 800100               	add	byte ptr [rcx], 0
-;; 1c40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1c49:	 800100               	add	byte ptr [rcx], 0
-;; 1c4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1c4d:	 800100               	add	byte ptr [rcx], 0
-;; 1c50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1c59:	 800100               	add	byte ptr [rcx], 0
-;; 1c5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1c5d:	 800100               	add	byte ptr [rcx], 0
-;; 1c60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1c69:	 800100               	add	byte ptr [rcx], 0
-;; 1c6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1c6d:	 800100               	add	byte ptr [rcx], 0
-;; 1c70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1c79:	 800100               	add	byte ptr [rcx], 0
-;; 1c7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1c7d:	 800100               	add	byte ptr [rcx], 0
-;; 1c80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1c89:	 800100               	add	byte ptr [rcx], 0
-;; 1c8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1c8d:	 800100               	add	byte ptr [rcx], 0
-;; 1c90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1c99:	 800100               	add	byte ptr [rcx], 0
-;; 1c9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1c9d:	 800100               	add	byte ptr [rcx], 0
-;; 1ca0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1ca9:	 800100               	add	byte ptr [rcx], 0
-;; 1cac:	 aa                   	stosb	byte ptr [rdi], al
-;; 1cad:	 800100               	add	byte ptr [rcx], 0
-;; 1cb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1cb9:	 800100               	add	byte ptr [rcx], 0
-;; 1cbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 1cbd:	 800100               	add	byte ptr [rcx], 0
-;; 1cc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1cc9:	 800100               	add	byte ptr [rcx], 0
-;; 1ccc:	 aa                   	stosb	byte ptr [rdi], al
-;; 1ccd:	 800100               	add	byte ptr [rcx], 0
-;; 1cd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1cd9:	 800100               	add	byte ptr [rcx], 0
-;; 1cdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 1cdd:	 800100               	add	byte ptr [rcx], 0
-;; 1ce0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1ce9:	 800100               	add	byte ptr [rcx], 0
-;; 1cec:	 aa                   	stosb	byte ptr [rdi], al
-;; 1ced:	 800100               	add	byte ptr [rcx], 0
-;; 1cf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1cf9:	 800100               	add	byte ptr [rcx], 0
-;; 1cfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 1cfd:	 800100               	add	byte ptr [rcx], 0
-;; 1d00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1d09:	 800100               	add	byte ptr [rcx], 0
-;; 1d0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1d0d:	 800100               	add	byte ptr [rcx], 0
-;; 1d10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1d19:	 800100               	add	byte ptr [rcx], 0
-;; 1d1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1d1d:	 800100               	add	byte ptr [rcx], 0
-;; 1d20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1d29:	 800100               	add	byte ptr [rcx], 0
-;; 1d2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1d2d:	 800100               	add	byte ptr [rcx], 0
-;; 1d30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1d39:	 800100               	add	byte ptr [rcx], 0
-;; 1d3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1d3d:	 800100               	add	byte ptr [rcx], 0
-;; 1d40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1d49:	 800100               	add	byte ptr [rcx], 0
-;; 1d4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1d4d:	 800100               	add	byte ptr [rcx], 0
-;; 1d50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1d59:	 800100               	add	byte ptr [rcx], 0
-;; 1d5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1d5d:	 800100               	add	byte ptr [rcx], 0
-;; 1d60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1d69:	 800100               	add	byte ptr [rcx], 0
-;; 1d6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1d6d:	 800100               	add	byte ptr [rcx], 0
-;; 1d70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1d79:	 800100               	add	byte ptr [rcx], 0
-;; 1d7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1d7d:	 800100               	add	byte ptr [rcx], 0
-;; 1d80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1d89:	 800100               	add	byte ptr [rcx], 0
-;; 1d8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1d8d:	 800100               	add	byte ptr [rcx], 0
-;; 1d90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1d99:	 800100               	add	byte ptr [rcx], 0
-;; 1d9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1d9d:	 800100               	add	byte ptr [rcx], 0
-;; 1da0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1da9:	 800100               	add	byte ptr [rcx], 0
-;; 1dac:	 aa                   	stosb	byte ptr [rdi], al
-;; 1dad:	 800100               	add	byte ptr [rcx], 0
-;; 1db0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1db9:	 800100               	add	byte ptr [rcx], 0
-;; 1dbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 1dbd:	 800100               	add	byte ptr [rcx], 0
-;; 1dc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1dc9:	 800100               	add	byte ptr [rcx], 0
-;; 1dcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 1dcd:	 800100               	add	byte ptr [rcx], 0
-;; 1dd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1dd9:	 800100               	add	byte ptr [rcx], 0
-;; 1ddc:	 aa                   	stosb	byte ptr [rdi], al
-;; 1ddd:	 800100               	add	byte ptr [rcx], 0
-;; 1de0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1de9:	 800100               	add	byte ptr [rcx], 0
-;; 1dec:	 aa                   	stosb	byte ptr [rdi], al
-;; 1ded:	 800100               	add	byte ptr [rcx], 0
-;; 1df0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1df9:	 800100               	add	byte ptr [rcx], 0
-;; 1dfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 1dfd:	 800100               	add	byte ptr [rcx], 0
-;; 1e00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1e09:	 800100               	add	byte ptr [rcx], 0
-;; 1e0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1e0d:	 800100               	add	byte ptr [rcx], 0
-;; 1e10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1e19:	 800100               	add	byte ptr [rcx], 0
-;; 1e1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1e1d:	 800100               	add	byte ptr [rcx], 0
-;; 1e20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1e29:	 800100               	add	byte ptr [rcx], 0
-;; 1e2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1e2d:	 800100               	add	byte ptr [rcx], 0
-;; 1e30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1e39:	 800100               	add	byte ptr [rcx], 0
-;; 1e3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1e3d:	 800100               	add	byte ptr [rcx], 0
-;; 1e40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1e49:	 800100               	add	byte ptr [rcx], 0
-;; 1e4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1e4d:	 800100               	add	byte ptr [rcx], 0
-;; 1e50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1e59:	 800100               	add	byte ptr [rcx], 0
-;; 1e5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1e5d:	 800100               	add	byte ptr [rcx], 0
-;; 1e60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1e69:	 800100               	add	byte ptr [rcx], 0
-;; 1e6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1e6d:	 800100               	add	byte ptr [rcx], 0
-;; 1e70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1e79:	 800100               	add	byte ptr [rcx], 0
-;; 1e7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1e7d:	 800100               	add	byte ptr [rcx], 0
-;; 1e80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1e89:	 800100               	add	byte ptr [rcx], 0
-;; 1e8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1e8d:	 800100               	add	byte ptr [rcx], 0
-;; 1e90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1e99:	 800100               	add	byte ptr [rcx], 0
-;; 1e9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1e9d:	 800100               	add	byte ptr [rcx], 0
-;; 1ea0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1ea9:	 800100               	add	byte ptr [rcx], 0
-;; 1eac:	 aa                   	stosb	byte ptr [rdi], al
-;; 1ead:	 800100               	add	byte ptr [rcx], 0
-;; 1eb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1eb9:	 800100               	add	byte ptr [rcx], 0
-;; 1ebc:	 aa                   	stosb	byte ptr [rdi], al
-;; 1ebd:	 800100               	add	byte ptr [rcx], 0
-;; 1ec0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1ec9:	 800100               	add	byte ptr [rcx], 0
-;; 1ecc:	 aa                   	stosb	byte ptr [rdi], al
-;; 1ecd:	 800100               	add	byte ptr [rcx], 0
-;; 1ed0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1ed9:	 800100               	add	byte ptr [rcx], 0
-;; 1edc:	 aa                   	stosb	byte ptr [rdi], al
-;; 1edd:	 800100               	add	byte ptr [rcx], 0
-;; 1ee0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1ee9:	 800100               	add	byte ptr [rcx], 0
-;; 1eec:	 aa                   	stosb	byte ptr [rdi], al
-;; 1eed:	 800100               	add	byte ptr [rcx], 0
-;; 1ef0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1ef9:	 800100               	add	byte ptr [rcx], 0
-;; 1efc:	 aa                   	stosb	byte ptr [rdi], al
-;; 1efd:	 800100               	add	byte ptr [rcx], 0
-;; 1f00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1f09:	 800100               	add	byte ptr [rcx], 0
-;; 1f0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1f0d:	 800100               	add	byte ptr [rcx], 0
-;; 1f10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1f19:	 800100               	add	byte ptr [rcx], 0
-;; 1f1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1f1d:	 800100               	add	byte ptr [rcx], 0
-;; 1f20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1f29:	 800100               	add	byte ptr [rcx], 0
-;; 1f2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1f2d:	 800100               	add	byte ptr [rcx], 0
-;; 1f30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1f39:	 800100               	add	byte ptr [rcx], 0
-;; 1f3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1f3d:	 800100               	add	byte ptr [rcx], 0
-;; 1f40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1f49:	 800100               	add	byte ptr [rcx], 0
-;; 1f4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1f4d:	 800100               	add	byte ptr [rcx], 0
-;; 1f50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1f59:	 800100               	add	byte ptr [rcx], 0
-;; 1f5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1f5d:	 800100               	add	byte ptr [rcx], 0
-;; 1f60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1f69:	 800100               	add	byte ptr [rcx], 0
-;; 1f6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1f6d:	 800100               	add	byte ptr [rcx], 0
-;; 1f70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1f79:	 800100               	add	byte ptr [rcx], 0
-;; 1f7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1f7d:	 800100               	add	byte ptr [rcx], 0
-;; 1f80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1f89:	 800100               	add	byte ptr [rcx], 0
-;; 1f8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1f8d:	 800100               	add	byte ptr [rcx], 0
-;; 1f90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1f99:	 800100               	add	byte ptr [rcx], 0
-;; 1f9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1f9d:	 800100               	add	byte ptr [rcx], 0
-;; 1fa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1fa9:	 800100               	add	byte ptr [rcx], 0
-;; 1fac:	 aa                   	stosb	byte ptr [rdi], al
-;; 1fad:	 800100               	add	byte ptr [rcx], 0
-;; 1fb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1fb9:	 800100               	add	byte ptr [rcx], 0
-;; 1fbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 1fbd:	 800100               	add	byte ptr [rcx], 0
-;; 1fc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1fc9:	 800100               	add	byte ptr [rcx], 0
-;; 1fcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 1fcd:	 800100               	add	byte ptr [rcx], 0
-;; 1fd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1fd9:	 800100               	add	byte ptr [rcx], 0
-;; 1fdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 1fdd:	 800100               	add	byte ptr [rcx], 0
-;; 1fe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1fe9:	 800100               	add	byte ptr [rcx], 0
-;; 1fec:	 aa                   	stosb	byte ptr [rdi], al
-;; 1fed:	 800100               	add	byte ptr [rcx], 0
-;; 1ff0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 1ff9:	 800100               	add	byte ptr [rcx], 0
-;; 1ffc:	 aa                   	stosb	byte ptr [rdi], al
-;; 1ffd:	 800100               	add	byte ptr [rcx], 0
-;; 2000:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2009:	 800100               	add	byte ptr [rcx], 0
-;; 200c:	 aa                   	stosb	byte ptr [rdi], al
-;; 200d:	 800100               	add	byte ptr [rcx], 0
-;; 2010:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2019:	 800100               	add	byte ptr [rcx], 0
-;; 201c:	 aa                   	stosb	byte ptr [rdi], al
-;; 201d:	 800100               	add	byte ptr [rcx], 0
-;; 2020:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2029:	 800100               	add	byte ptr [rcx], 0
-;; 202c:	 aa                   	stosb	byte ptr [rdi], al
-;; 202d:	 800100               	add	byte ptr [rcx], 0
-;; 2030:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2039:	 800100               	add	byte ptr [rcx], 0
-;; 203c:	 aa                   	stosb	byte ptr [rdi], al
-;; 203d:	 800100               	add	byte ptr [rcx], 0
-;; 2040:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2049:	 800100               	add	byte ptr [rcx], 0
-;; 204c:	 aa                   	stosb	byte ptr [rdi], al
-;; 204d:	 800100               	add	byte ptr [rcx], 0
-;; 2050:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2059:	 800100               	add	byte ptr [rcx], 0
-;; 205c:	 aa                   	stosb	byte ptr [rdi], al
-;; 205d:	 800100               	add	byte ptr [rcx], 0
-;; 2060:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2069:	 800100               	add	byte ptr [rcx], 0
-;; 206c:	 aa                   	stosb	byte ptr [rdi], al
-;; 206d:	 800100               	add	byte ptr [rcx], 0
-;; 2070:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2079:	 800100               	add	byte ptr [rcx], 0
-;; 207c:	 aa                   	stosb	byte ptr [rdi], al
-;; 207d:	 800100               	add	byte ptr [rcx], 0
-;; 2080:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2089:	 800100               	add	byte ptr [rcx], 0
-;; 208c:	 aa                   	stosb	byte ptr [rdi], al
-;; 208d:	 800100               	add	byte ptr [rcx], 0
-;; 2090:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2099:	 800100               	add	byte ptr [rcx], 0
-;; 209c:	 aa                   	stosb	byte ptr [rdi], al
-;; 209d:	 800100               	add	byte ptr [rcx], 0
-;; 20a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 20a9:	 800100               	add	byte ptr [rcx], 0
-;; 20ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 20ad:	 800100               	add	byte ptr [rcx], 0
-;; 20b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 20b9:	 800100               	add	byte ptr [rcx], 0
-;; 20bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 20bd:	 800100               	add	byte ptr [rcx], 0
-;; 20c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 20c9:	 800100               	add	byte ptr [rcx], 0
-;; 20cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 20cd:	 800100               	add	byte ptr [rcx], 0
-;; 20d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 20d9:	 800100               	add	byte ptr [rcx], 0
-;; 20dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 20dd:	 800100               	add	byte ptr [rcx], 0
-;; 20e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 20e9:	 800100               	add	byte ptr [rcx], 0
-;; 20ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 20ed:	 800100               	add	byte ptr [rcx], 0
-;; 20f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 20f9:	 800100               	add	byte ptr [rcx], 0
-;; 20fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 20fd:	 800100               	add	byte ptr [rcx], 0
-;; 2100:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2109:	 800100               	add	byte ptr [rcx], 0
-;; 210c:	 aa                   	stosb	byte ptr [rdi], al
-;; 210d:	 800100               	add	byte ptr [rcx], 0
-;; 2110:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2119:	 800100               	add	byte ptr [rcx], 0
-;; 211c:	 aa                   	stosb	byte ptr [rdi], al
-;; 211d:	 800100               	add	byte ptr [rcx], 0
-;; 2120:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2129:	 800100               	add	byte ptr [rcx], 0
-;; 212c:	 aa                   	stosb	byte ptr [rdi], al
-;; 212d:	 800100               	add	byte ptr [rcx], 0
-;; 2130:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2139:	 800100               	add	byte ptr [rcx], 0
-;; 213c:	 aa                   	stosb	byte ptr [rdi], al
-;; 213d:	 800100               	add	byte ptr [rcx], 0
-;; 2140:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2149:	 800100               	add	byte ptr [rcx], 0
-;; 214c:	 aa                   	stosb	byte ptr [rdi], al
-;; 214d:	 800100               	add	byte ptr [rcx], 0
-;; 2150:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2159:	 800100               	add	byte ptr [rcx], 0
-;; 215c:	 aa                   	stosb	byte ptr [rdi], al
-;; 215d:	 800100               	add	byte ptr [rcx], 0
-;; 2160:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2169:	 800100               	add	byte ptr [rcx], 0
-;; 216c:	 aa                   	stosb	byte ptr [rdi], al
-;; 216d:	 800100               	add	byte ptr [rcx], 0
-;; 2170:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2179:	 800100               	add	byte ptr [rcx], 0
-;; 217c:	 aa                   	stosb	byte ptr [rdi], al
-;; 217d:	 800100               	add	byte ptr [rcx], 0
-;; 2180:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2189:	 800100               	add	byte ptr [rcx], 0
-;; 218c:	 aa                   	stosb	byte ptr [rdi], al
-;; 218d:	 800100               	add	byte ptr [rcx], 0
-;; 2190:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2199:	 800100               	add	byte ptr [rcx], 0
-;; 219c:	 aa                   	stosb	byte ptr [rdi], al
-;; 219d:	 800100               	add	byte ptr [rcx], 0
-;; 21a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 21a9:	 800100               	add	byte ptr [rcx], 0
-;; 21ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 21ad:	 800100               	add	byte ptr [rcx], 0
-;; 21b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 21b9:	 800100               	add	byte ptr [rcx], 0
-;; 21bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 21bd:	 800100               	add	byte ptr [rcx], 0
-;; 21c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 21c9:	 800100               	add	byte ptr [rcx], 0
-;; 21cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 21cd:	 800100               	add	byte ptr [rcx], 0
-;; 21d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 21d9:	 800100               	add	byte ptr [rcx], 0
-;; 21dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 21dd:	 800100               	add	byte ptr [rcx], 0
-;; 21e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 21e9:	 800100               	add	byte ptr [rcx], 0
-;; 21ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 21ed:	 800100               	add	byte ptr [rcx], 0
-;; 21f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 21f9:	 800100               	add	byte ptr [rcx], 0
-;; 21fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 21fd:	 800100               	add	byte ptr [rcx], 0
-;; 2200:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2209:	 800100               	add	byte ptr [rcx], 0
-;; 220c:	 aa                   	stosb	byte ptr [rdi], al
-;; 220d:	 800100               	add	byte ptr [rcx], 0
-;; 2210:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2219:	 800100               	add	byte ptr [rcx], 0
-;; 221c:	 aa                   	stosb	byte ptr [rdi], al
-;; 221d:	 800100               	add	byte ptr [rcx], 0
-;; 2220:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2229:	 800100               	add	byte ptr [rcx], 0
-;; 222c:	 aa                   	stosb	byte ptr [rdi], al
-;; 222d:	 800100               	add	byte ptr [rcx], 0
-;; 2230:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2239:	 800100               	add	byte ptr [rcx], 0
-;; 223c:	 aa                   	stosb	byte ptr [rdi], al
-;; 223d:	 800100               	add	byte ptr [rcx], 0
-;; 2240:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2249:	 800100               	add	byte ptr [rcx], 0
-;; 224c:	 aa                   	stosb	byte ptr [rdi], al
-;; 224d:	 800100               	add	byte ptr [rcx], 0
-;; 2250:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2259:	 800100               	add	byte ptr [rcx], 0
-;; 225c:	 aa                   	stosb	byte ptr [rdi], al
-;; 225d:	 800100               	add	byte ptr [rcx], 0
-;; 2260:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2269:	 800100               	add	byte ptr [rcx], 0
-;; 226c:	 aa                   	stosb	byte ptr [rdi], al
-;; 226d:	 800100               	add	byte ptr [rcx], 0
-;; 2270:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2279:	 800100               	add	byte ptr [rcx], 0
-;; 227c:	 aa                   	stosb	byte ptr [rdi], al
-;; 227d:	 800100               	add	byte ptr [rcx], 0
-;; 2280:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2289:	 800100               	add	byte ptr [rcx], 0
-;; 228c:	 aa                   	stosb	byte ptr [rdi], al
-;; 228d:	 800100               	add	byte ptr [rcx], 0
-;; 2290:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2299:	 800100               	add	byte ptr [rcx], 0
-;; 229c:	 aa                   	stosb	byte ptr [rdi], al
-;; 229d:	 800100               	add	byte ptr [rcx], 0
-;; 22a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 22a9:	 800100               	add	byte ptr [rcx], 0
-;; 22ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 22ad:	 800100               	add	byte ptr [rcx], 0
-;; 22b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 22b9:	 800100               	add	byte ptr [rcx], 0
-;; 22bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 22bd:	 800100               	add	byte ptr [rcx], 0
-;; 22c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 22c9:	 800100               	add	byte ptr [rcx], 0
-;; 22cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 22cd:	 800100               	add	byte ptr [rcx], 0
-;; 22d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 22d9:	 800100               	add	byte ptr [rcx], 0
-;; 22dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 22dd:	 800100               	add	byte ptr [rcx], 0
-;; 22e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 22e9:	 800100               	add	byte ptr [rcx], 0
-;; 22ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 22ed:	 800100               	add	byte ptr [rcx], 0
-;; 22f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 22f9:	 800100               	add	byte ptr [rcx], 0
-;; 22fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 22fd:	 800100               	add	byte ptr [rcx], 0
-;; 2300:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2309:	 800100               	add	byte ptr [rcx], 0
-;; 230c:	 aa                   	stosb	byte ptr [rdi], al
-;; 230d:	 800100               	add	byte ptr [rcx], 0
-;; 2310:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2319:	 800100               	add	byte ptr [rcx], 0
-;; 231c:	 aa                   	stosb	byte ptr [rdi], al
-;; 231d:	 800100               	add	byte ptr [rcx], 0
-;; 2320:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2329:	 800100               	add	byte ptr [rcx], 0
-;; 232c:	 aa                   	stosb	byte ptr [rdi], al
-;; 232d:	 800100               	add	byte ptr [rcx], 0
-;; 2330:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2339:	 800100               	add	byte ptr [rcx], 0
-;; 233c:	 aa                   	stosb	byte ptr [rdi], al
-;; 233d:	 800100               	add	byte ptr [rcx], 0
-;; 2340:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2349:	 800100               	add	byte ptr [rcx], 0
-;; 234c:	 aa                   	stosb	byte ptr [rdi], al
-;; 234d:	 800100               	add	byte ptr [rcx], 0
-;; 2350:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2359:	 800100               	add	byte ptr [rcx], 0
-;; 235c:	 aa                   	stosb	byte ptr [rdi], al
-;; 235d:	 800100               	add	byte ptr [rcx], 0
-;; 2360:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2369:	 800100               	add	byte ptr [rcx], 0
-;; 236c:	 aa                   	stosb	byte ptr [rdi], al
-;; 236d:	 800100               	add	byte ptr [rcx], 0
-;; 2370:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2379:	 800100               	add	byte ptr [rcx], 0
-;; 237c:	 aa                   	stosb	byte ptr [rdi], al
-;; 237d:	 800100               	add	byte ptr [rcx], 0
-;; 2380:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2389:	 800100               	add	byte ptr [rcx], 0
-;; 238c:	 aa                   	stosb	byte ptr [rdi], al
-;; 238d:	 800100               	add	byte ptr [rcx], 0
-;; 2390:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2399:	 800100               	add	byte ptr [rcx], 0
-;; 239c:	 aa                   	stosb	byte ptr [rdi], al
-;; 239d:	 800100               	add	byte ptr [rcx], 0
-;; 23a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 23a9:	 800100               	add	byte ptr [rcx], 0
-;; 23ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 23ad:	 800100               	add	byte ptr [rcx], 0
-;; 23b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 23b9:	 800100               	add	byte ptr [rcx], 0
-;; 23bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 23bd:	 800100               	add	byte ptr [rcx], 0
-;; 23c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 23c9:	 800100               	add	byte ptr [rcx], 0
-;; 23cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 23cd:	 800100               	add	byte ptr [rcx], 0
-;; 23d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 23d9:	 800100               	add	byte ptr [rcx], 0
-;; 23dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 23dd:	 800100               	add	byte ptr [rcx], 0
-;; 23e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 23e9:	 800100               	add	byte ptr [rcx], 0
-;; 23ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 23ed:	 800100               	add	byte ptr [rcx], 0
-;; 23f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 23f9:	 800100               	add	byte ptr [rcx], 0
-;; 23fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 23fd:	 800100               	add	byte ptr [rcx], 0
-;; 2400:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2409:	 800100               	add	byte ptr [rcx], 0
-;; 240c:	 aa                   	stosb	byte ptr [rdi], al
-;; 240d:	 800100               	add	byte ptr [rcx], 0
-;; 2410:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2419:	 800100               	add	byte ptr [rcx], 0
-;; 241c:	 aa                   	stosb	byte ptr [rdi], al
-;; 241d:	 800100               	add	byte ptr [rcx], 0
-;; 2420:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2429:	 800100               	add	byte ptr [rcx], 0
-;; 242c:	 aa                   	stosb	byte ptr [rdi], al
-;; 242d:	 800100               	add	byte ptr [rcx], 0
-;; 2430:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2439:	 800100               	add	byte ptr [rcx], 0
-;; 243c:	 aa                   	stosb	byte ptr [rdi], al
-;; 243d:	 800100               	add	byte ptr [rcx], 0
-;; 2440:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2449:	 800100               	add	byte ptr [rcx], 0
-;; 244c:	 aa                   	stosb	byte ptr [rdi], al
-;; 244d:	 800100               	add	byte ptr [rcx], 0
-;; 2450:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2459:	 800100               	add	byte ptr [rcx], 0
-;; 245c:	 aa                   	stosb	byte ptr [rdi], al
-;; 245d:	 800100               	add	byte ptr [rcx], 0
-;; 2460:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2469:	 800100               	add	byte ptr [rcx], 0
-;; 246c:	 aa                   	stosb	byte ptr [rdi], al
-;; 246d:	 800100               	add	byte ptr [rcx], 0
-;; 2470:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2479:	 800100               	add	byte ptr [rcx], 0
-;; 247c:	 aa                   	stosb	byte ptr [rdi], al
-;; 247d:	 800100               	add	byte ptr [rcx], 0
-;; 2480:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2489:	 800100               	add	byte ptr [rcx], 0
-;; 248c:	 aa                   	stosb	byte ptr [rdi], al
-;; 248d:	 800100               	add	byte ptr [rcx], 0
-;; 2490:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2499:	 800100               	add	byte ptr [rcx], 0
-;; 249c:	 aa                   	stosb	byte ptr [rdi], al
-;; 249d:	 800100               	add	byte ptr [rcx], 0
-;; 24a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 24a9:	 800100               	add	byte ptr [rcx], 0
-;; 24ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 24ad:	 800100               	add	byte ptr [rcx], 0
-;; 24b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 24b9:	 800100               	add	byte ptr [rcx], 0
-;; 24bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 24bd:	 800100               	add	byte ptr [rcx], 0
-;; 24c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 24c9:	 800100               	add	byte ptr [rcx], 0
-;; 24cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 24cd:	 800100               	add	byte ptr [rcx], 0
-;; 24d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 24d9:	 800100               	add	byte ptr [rcx], 0
-;; 24dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 24dd:	 800100               	add	byte ptr [rcx], 0
-;; 24e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 24e9:	 800100               	add	byte ptr [rcx], 0
-;; 24ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 24ed:	 800100               	add	byte ptr [rcx], 0
-;; 24f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 24f9:	 800100               	add	byte ptr [rcx], 0
-;; 24fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 24fd:	 800100               	add	byte ptr [rcx], 0
-;; 2500:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2509:	 800100               	add	byte ptr [rcx], 0
-;; 250c:	 aa                   	stosb	byte ptr [rdi], al
-;; 250d:	 800100               	add	byte ptr [rcx], 0
-;; 2510:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2519:	 800100               	add	byte ptr [rcx], 0
-;; 251c:	 aa                   	stosb	byte ptr [rdi], al
-;; 251d:	 800100               	add	byte ptr [rcx], 0
-;; 2520:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2529:	 800100               	add	byte ptr [rcx], 0
-;; 252c:	 aa                   	stosb	byte ptr [rdi], al
-;; 252d:	 800100               	add	byte ptr [rcx], 0
-;; 2530:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2539:	 800100               	add	byte ptr [rcx], 0
-;; 253c:	 aa                   	stosb	byte ptr [rdi], al
-;; 253d:	 800100               	add	byte ptr [rcx], 0
-;; 2540:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2549:	 800100               	add	byte ptr [rcx], 0
-;; 254c:	 aa                   	stosb	byte ptr [rdi], al
-;; 254d:	 800100               	add	byte ptr [rcx], 0
-;; 2550:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2559:	 800100               	add	byte ptr [rcx], 0
-;; 255c:	 aa                   	stosb	byte ptr [rdi], al
-;; 255d:	 800100               	add	byte ptr [rcx], 0
-;; 2560:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2569:	 800100               	add	byte ptr [rcx], 0
-;; 256c:	 aa                   	stosb	byte ptr [rdi], al
-;; 256d:	 800100               	add	byte ptr [rcx], 0
-;; 2570:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2579:	 800100               	add	byte ptr [rcx], 0
-;; 257c:	 aa                   	stosb	byte ptr [rdi], al
-;; 257d:	 800100               	add	byte ptr [rcx], 0
-;; 2580:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2589:	 800100               	add	byte ptr [rcx], 0
-;; 258c:	 aa                   	stosb	byte ptr [rdi], al
-;; 258d:	 800100               	add	byte ptr [rcx], 0
-;; 2590:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2599:	 800100               	add	byte ptr [rcx], 0
-;; 259c:	 aa                   	stosb	byte ptr [rdi], al
-;; 259d:	 800100               	add	byte ptr [rcx], 0
-;; 25a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 25a9:	 800100               	add	byte ptr [rcx], 0
-;; 25ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 25ad:	 800100               	add	byte ptr [rcx], 0
-;; 25b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 25b9:	 800100               	add	byte ptr [rcx], 0
-;; 25bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 25bd:	 800100               	add	byte ptr [rcx], 0
-;; 25c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 25c9:	 800100               	add	byte ptr [rcx], 0
-;; 25cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 25cd:	 800100               	add	byte ptr [rcx], 0
-;; 25d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 25d9:	 800100               	add	byte ptr [rcx], 0
-;; 25dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 25dd:	 800100               	add	byte ptr [rcx], 0
-;; 25e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 25e9:	 800100               	add	byte ptr [rcx], 0
-;; 25ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 25ed:	 800100               	add	byte ptr [rcx], 0
-;; 25f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 25f9:	 800100               	add	byte ptr [rcx], 0
-;; 25fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 25fd:	 800100               	add	byte ptr [rcx], 0
-;; 2600:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2609:	 800100               	add	byte ptr [rcx], 0
-;; 260c:	 aa                   	stosb	byte ptr [rdi], al
-;; 260d:	 800100               	add	byte ptr [rcx], 0
-;; 2610:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2619:	 800100               	add	byte ptr [rcx], 0
-;; 261c:	 aa                   	stosb	byte ptr [rdi], al
-;; 261d:	 800100               	add	byte ptr [rcx], 0
-;; 2620:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2629:	 800100               	add	byte ptr [rcx], 0
-;; 262c:	 aa                   	stosb	byte ptr [rdi], al
-;; 262d:	 800100               	add	byte ptr [rcx], 0
-;; 2630:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2639:	 800100               	add	byte ptr [rcx], 0
-;; 263c:	 aa                   	stosb	byte ptr [rdi], al
-;; 263d:	 800100               	add	byte ptr [rcx], 0
-;; 2640:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2649:	 800100               	add	byte ptr [rcx], 0
-;; 264c:	 aa                   	stosb	byte ptr [rdi], al
-;; 264d:	 800100               	add	byte ptr [rcx], 0
-;; 2650:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2659:	 800100               	add	byte ptr [rcx], 0
-;; 265c:	 aa                   	stosb	byte ptr [rdi], al
-;; 265d:	 800100               	add	byte ptr [rcx], 0
-;; 2660:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2669:	 800100               	add	byte ptr [rcx], 0
-;; 266c:	 aa                   	stosb	byte ptr [rdi], al
-;; 266d:	 800100               	add	byte ptr [rcx], 0
-;; 2670:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2679:	 800100               	add	byte ptr [rcx], 0
-;; 267c:	 aa                   	stosb	byte ptr [rdi], al
-;; 267d:	 800100               	add	byte ptr [rcx], 0
-;; 2680:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2689:	 800100               	add	byte ptr [rcx], 0
-;; 268c:	 aa                   	stosb	byte ptr [rdi], al
-;; 268d:	 800100               	add	byte ptr [rcx], 0
-;; 2690:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2699:	 800100               	add	byte ptr [rcx], 0
-;; 269c:	 aa                   	stosb	byte ptr [rdi], al
-;; 269d:	 800100               	add	byte ptr [rcx], 0
-;; 26a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 26a9:	 800100               	add	byte ptr [rcx], 0
-;; 26ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 26ad:	 800100               	add	byte ptr [rcx], 0
-;; 26b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 26b9:	 800100               	add	byte ptr [rcx], 0
-;; 26bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 26bd:	 800100               	add	byte ptr [rcx], 0
-;; 26c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 26c9:	 800100               	add	byte ptr [rcx], 0
-;; 26cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 26cd:	 800100               	add	byte ptr [rcx], 0
-;; 26d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 26d9:	 800100               	add	byte ptr [rcx], 0
-;; 26dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 26dd:	 800100               	add	byte ptr [rcx], 0
-;; 26e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 26e9:	 800100               	add	byte ptr [rcx], 0
-;; 26ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 26ed:	 800100               	add	byte ptr [rcx], 0
-;; 26f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 26f9:	 800100               	add	byte ptr [rcx], 0
-;; 26fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 26fd:	 800100               	add	byte ptr [rcx], 0
-;; 2700:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2709:	 800100               	add	byte ptr [rcx], 0
-;; 270c:	 aa                   	stosb	byte ptr [rdi], al
-;; 270d:	 800100               	add	byte ptr [rcx], 0
-;; 2710:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2719:	 800100               	add	byte ptr [rcx], 0
-;; 271c:	 aa                   	stosb	byte ptr [rdi], al
-;; 271d:	 800100               	add	byte ptr [rcx], 0
-;; 2720:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2729:	 800100               	add	byte ptr [rcx], 0
-;; 272c:	 aa                   	stosb	byte ptr [rdi], al
-;; 272d:	 800100               	add	byte ptr [rcx], 0
-;; 2730:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2739:	 800100               	add	byte ptr [rcx], 0
-;; 273c:	 aa                   	stosb	byte ptr [rdi], al
-;; 273d:	 800100               	add	byte ptr [rcx], 0
-;; 2740:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2749:	 800100               	add	byte ptr [rcx], 0
-;; 274c:	 aa                   	stosb	byte ptr [rdi], al
-;; 274d:	 800100               	add	byte ptr [rcx], 0
-;; 2750:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2759:	 800100               	add	byte ptr [rcx], 0
-;; 275c:	 aa                   	stosb	byte ptr [rdi], al
-;; 275d:	 800100               	add	byte ptr [rcx], 0
-;; 2760:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2769:	 800100               	add	byte ptr [rcx], 0
-;; 276c:	 aa                   	stosb	byte ptr [rdi], al
-;; 276d:	 800100               	add	byte ptr [rcx], 0
-;; 2770:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2779:	 800100               	add	byte ptr [rcx], 0
-;; 277c:	 aa                   	stosb	byte ptr [rdi], al
-;; 277d:	 800100               	add	byte ptr [rcx], 0
-;; 2780:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2789:	 800100               	add	byte ptr [rcx], 0
-;; 278c:	 aa                   	stosb	byte ptr [rdi], al
-;; 278d:	 800100               	add	byte ptr [rcx], 0
-;; 2790:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2799:	 800100               	add	byte ptr [rcx], 0
-;; 279c:	 aa                   	stosb	byte ptr [rdi], al
-;; 279d:	 800100               	add	byte ptr [rcx], 0
-;; 27a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 27a9:	 800100               	add	byte ptr [rcx], 0
-;; 27ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 27ad:	 800100               	add	byte ptr [rcx], 0
-;; 27b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 27b9:	 800100               	add	byte ptr [rcx], 0
-;; 27bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 27bd:	 800100               	add	byte ptr [rcx], 0
-;; 27c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 27c9:	 800100               	add	byte ptr [rcx], 0
-;; 27cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 27cd:	 800100               	add	byte ptr [rcx], 0
-;; 27d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 27d9:	 800100               	add	byte ptr [rcx], 0
-;; 27dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 27dd:	 800100               	add	byte ptr [rcx], 0
-;; 27e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 27e9:	 800100               	add	byte ptr [rcx], 0
-;; 27ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 27ed:	 800100               	add	byte ptr [rcx], 0
-;; 27f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 27f9:	 800100               	add	byte ptr [rcx], 0
-;; 27fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 27fd:	 800100               	add	byte ptr [rcx], 0
-;; 2800:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2809:	 800100               	add	byte ptr [rcx], 0
-;; 280c:	 aa                   	stosb	byte ptr [rdi], al
-;; 280d:	 800100               	add	byte ptr [rcx], 0
-;; 2810:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2819:	 800100               	add	byte ptr [rcx], 0
-;; 281c:	 aa                   	stosb	byte ptr [rdi], al
-;; 281d:	 800100               	add	byte ptr [rcx], 0
-;; 2820:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2829:	 800100               	add	byte ptr [rcx], 0
-;; 282c:	 aa                   	stosb	byte ptr [rdi], al
-;; 282d:	 800100               	add	byte ptr [rcx], 0
-;; 2830:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2839:	 800100               	add	byte ptr [rcx], 0
-;; 283c:	 aa                   	stosb	byte ptr [rdi], al
-;; 283d:	 800100               	add	byte ptr [rcx], 0
-;; 2840:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2849:	 800100               	add	byte ptr [rcx], 0
-;; 284c:	 aa                   	stosb	byte ptr [rdi], al
-;; 284d:	 800100               	add	byte ptr [rcx], 0
-;; 2850:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2859:	 800100               	add	byte ptr [rcx], 0
-;; 285c:	 aa                   	stosb	byte ptr [rdi], al
-;; 285d:	 800100               	add	byte ptr [rcx], 0
-;; 2860:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2869:	 800100               	add	byte ptr [rcx], 0
-;; 286c:	 aa                   	stosb	byte ptr [rdi], al
-;; 286d:	 800100               	add	byte ptr [rcx], 0
-;; 2870:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2879:	 800100               	add	byte ptr [rcx], 0
-;; 287c:	 aa                   	stosb	byte ptr [rdi], al
-;; 287d:	 800100               	add	byte ptr [rcx], 0
-;; 2880:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2889:	 800100               	add	byte ptr [rcx], 0
-;; 288c:	 aa                   	stosb	byte ptr [rdi], al
-;; 288d:	 800100               	add	byte ptr [rcx], 0
-;; 2890:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2899:	 800100               	add	byte ptr [rcx], 0
-;; 289c:	 aa                   	stosb	byte ptr [rdi], al
-;; 289d:	 800100               	add	byte ptr [rcx], 0
-;; 28a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 28a9:	 800100               	add	byte ptr [rcx], 0
-;; 28ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 28ad:	 800100               	add	byte ptr [rcx], 0
-;; 28b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 28b9:	 800100               	add	byte ptr [rcx], 0
-;; 28bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 28bd:	 800100               	add	byte ptr [rcx], 0
-;; 28c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 28c9:	 800100               	add	byte ptr [rcx], 0
-;; 28cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 28cd:	 800100               	add	byte ptr [rcx], 0
-;; 28d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 28d9:	 800100               	add	byte ptr [rcx], 0
-;; 28dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 28dd:	 800100               	add	byte ptr [rcx], 0
-;; 28e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 28e9:	 800100               	add	byte ptr [rcx], 0
-;; 28ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 28ed:	 800100               	add	byte ptr [rcx], 0
-;; 28f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 28f9:	 800100               	add	byte ptr [rcx], 0
-;; 28fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 28fd:	 800100               	add	byte ptr [rcx], 0
-;; 2900:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2909:	 800100               	add	byte ptr [rcx], 0
-;; 290c:	 aa                   	stosb	byte ptr [rdi], al
-;; 290d:	 800100               	add	byte ptr [rcx], 0
-;; 2910:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2919:	 800100               	add	byte ptr [rcx], 0
-;; 291c:	 aa                   	stosb	byte ptr [rdi], al
-;; 291d:	 800100               	add	byte ptr [rcx], 0
-;; 2920:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2929:	 800100               	add	byte ptr [rcx], 0
-;; 292c:	 aa                   	stosb	byte ptr [rdi], al
-;; 292d:	 800100               	add	byte ptr [rcx], 0
-;; 2930:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2939:	 800100               	add	byte ptr [rcx], 0
-;; 293c:	 aa                   	stosb	byte ptr [rdi], al
-;; 293d:	 800100               	add	byte ptr [rcx], 0
-;; 2940:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2949:	 800100               	add	byte ptr [rcx], 0
-;; 294c:	 aa                   	stosb	byte ptr [rdi], al
-;; 294d:	 800100               	add	byte ptr [rcx], 0
-;; 2950:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2959:	 800100               	add	byte ptr [rcx], 0
-;; 295c:	 aa                   	stosb	byte ptr [rdi], al
-;; 295d:	 800100               	add	byte ptr [rcx], 0
-;; 2960:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2969:	 800100               	add	byte ptr [rcx], 0
-;; 296c:	 aa                   	stosb	byte ptr [rdi], al
-;; 296d:	 800100               	add	byte ptr [rcx], 0
-;; 2970:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2979:	 800100               	add	byte ptr [rcx], 0
-;; 297c:	 aa                   	stosb	byte ptr [rdi], al
-;; 297d:	 800100               	add	byte ptr [rcx], 0
-;; 2980:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2989:	 800100               	add	byte ptr [rcx], 0
-;; 298c:	 aa                   	stosb	byte ptr [rdi], al
-;; 298d:	 800100               	add	byte ptr [rcx], 0
-;; 2990:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2999:	 800100               	add	byte ptr [rcx], 0
-;; 299c:	 aa                   	stosb	byte ptr [rdi], al
-;; 299d:	 800100               	add	byte ptr [rcx], 0
-;; 29a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 29a9:	 800100               	add	byte ptr [rcx], 0
-;; 29ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 29ad:	 800100               	add	byte ptr [rcx], 0
-;; 29b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 29b9:	 800100               	add	byte ptr [rcx], 0
-;; 29bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 29bd:	 800100               	add	byte ptr [rcx], 0
-;; 29c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 29c9:	 800100               	add	byte ptr [rcx], 0
-;; 29cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 29cd:	 800100               	add	byte ptr [rcx], 0
-;; 29d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 29d9:	 800100               	add	byte ptr [rcx], 0
-;; 29dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 29dd:	 800100               	add	byte ptr [rcx], 0
-;; 29e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 29e9:	 800100               	add	byte ptr [rcx], 0
-;; 29ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 29ed:	 800100               	add	byte ptr [rcx], 0
-;; 29f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 29f9:	 800100               	add	byte ptr [rcx], 0
-;; 29fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 29fd:	 800100               	add	byte ptr [rcx], 0
-;; 2a00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2a09:	 800100               	add	byte ptr [rcx], 0
-;; 2a0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2a0d:	 800100               	add	byte ptr [rcx], 0
-;; 2a10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2a19:	 800100               	add	byte ptr [rcx], 0
-;; 2a1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2a1d:	 800100               	add	byte ptr [rcx], 0
-;; 2a20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2a29:	 800100               	add	byte ptr [rcx], 0
-;; 2a2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2a2d:	 800100               	add	byte ptr [rcx], 0
-;; 2a30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2a39:	 800100               	add	byte ptr [rcx], 0
-;; 2a3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2a3d:	 800100               	add	byte ptr [rcx], 0
-;; 2a40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2a49:	 800100               	add	byte ptr [rcx], 0
-;; 2a4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2a4d:	 800100               	add	byte ptr [rcx], 0
-;; 2a50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2a59:	 800100               	add	byte ptr [rcx], 0
-;; 2a5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2a5d:	 800100               	add	byte ptr [rcx], 0
-;; 2a60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2a69:	 800100               	add	byte ptr [rcx], 0
-;; 2a6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2a6d:	 800100               	add	byte ptr [rcx], 0
-;; 2a70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2a79:	 800100               	add	byte ptr [rcx], 0
-;; 2a7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2a7d:	 800100               	add	byte ptr [rcx], 0
-;; 2a80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2a89:	 800100               	add	byte ptr [rcx], 0
-;; 2a8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2a8d:	 800100               	add	byte ptr [rcx], 0
-;; 2a90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2a99:	 800100               	add	byte ptr [rcx], 0
-;; 2a9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2a9d:	 800100               	add	byte ptr [rcx], 0
-;; 2aa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2aa9:	 800100               	add	byte ptr [rcx], 0
-;; 2aac:	 aa                   	stosb	byte ptr [rdi], al
-;; 2aad:	 800100               	add	byte ptr [rcx], 0
-;; 2ab0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2ab9:	 800100               	add	byte ptr [rcx], 0
-;; 2abc:	 aa                   	stosb	byte ptr [rdi], al
-;; 2abd:	 800100               	add	byte ptr [rcx], 0
-;; 2ac0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2ac9:	 800100               	add	byte ptr [rcx], 0
-;; 2acc:	 aa                   	stosb	byte ptr [rdi], al
-;; 2acd:	 800100               	add	byte ptr [rcx], 0
-;; 2ad0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2ad9:	 800100               	add	byte ptr [rcx], 0
-;; 2adc:	 aa                   	stosb	byte ptr [rdi], al
-;; 2add:	 800100               	add	byte ptr [rcx], 0
-;; 2ae0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2ae9:	 800100               	add	byte ptr [rcx], 0
-;; 2aec:	 aa                   	stosb	byte ptr [rdi], al
-;; 2aed:	 800100               	add	byte ptr [rcx], 0
-;; 2af0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2af9:	 800100               	add	byte ptr [rcx], 0
-;; 2afc:	 aa                   	stosb	byte ptr [rdi], al
-;; 2afd:	 800100               	add	byte ptr [rcx], 0
-;; 2b00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2b09:	 800100               	add	byte ptr [rcx], 0
-;; 2b0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2b0d:	 800100               	add	byte ptr [rcx], 0
-;; 2b10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2b19:	 800100               	add	byte ptr [rcx], 0
-;; 2b1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2b1d:	 800100               	add	byte ptr [rcx], 0
-;; 2b20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2b29:	 800100               	add	byte ptr [rcx], 0
-;; 2b2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2b2d:	 800100               	add	byte ptr [rcx], 0
-;; 2b30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2b39:	 800100               	add	byte ptr [rcx], 0
-;; 2b3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2b3d:	 800100               	add	byte ptr [rcx], 0
-;; 2b40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2b49:	 800100               	add	byte ptr [rcx], 0
-;; 2b4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2b4d:	 800100               	add	byte ptr [rcx], 0
-;; 2b50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2b59:	 800100               	add	byte ptr [rcx], 0
-;; 2b5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2b5d:	 800100               	add	byte ptr [rcx], 0
-;; 2b60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2b69:	 800100               	add	byte ptr [rcx], 0
-;; 2b6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2b6d:	 800100               	add	byte ptr [rcx], 0
-;; 2b70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2b79:	 800100               	add	byte ptr [rcx], 0
-;; 2b7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2b7d:	 800100               	add	byte ptr [rcx], 0
-;; 2b80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2b89:	 800100               	add	byte ptr [rcx], 0
-;; 2b8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2b8d:	 800100               	add	byte ptr [rcx], 0
-;; 2b90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2b99:	 800100               	add	byte ptr [rcx], 0
-;; 2b9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2b9d:	 800100               	add	byte ptr [rcx], 0
-;; 2ba0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2ba9:	 800100               	add	byte ptr [rcx], 0
-;; 2bac:	 aa                   	stosb	byte ptr [rdi], al
-;; 2bad:	 800100               	add	byte ptr [rcx], 0
-;; 2bb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2bb9:	 800100               	add	byte ptr [rcx], 0
-;; 2bbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 2bbd:	 800100               	add	byte ptr [rcx], 0
-;; 2bc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2bc9:	 800100               	add	byte ptr [rcx], 0
-;; 2bcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 2bcd:	 800100               	add	byte ptr [rcx], 0
-;; 2bd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2bd9:	 800100               	add	byte ptr [rcx], 0
-;; 2bdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 2bdd:	 800100               	add	byte ptr [rcx], 0
-;; 2be0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2be9:	 800100               	add	byte ptr [rcx], 0
-;; 2bec:	 aa                   	stosb	byte ptr [rdi], al
-;; 2bed:	 800100               	add	byte ptr [rcx], 0
-;; 2bf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2bf9:	 800100               	add	byte ptr [rcx], 0
-;; 2bfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 2bfd:	 800100               	add	byte ptr [rcx], 0
-;; 2c00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2c09:	 800100               	add	byte ptr [rcx], 0
-;; 2c0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2c0d:	 800100               	add	byte ptr [rcx], 0
-;; 2c10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2c19:	 800100               	add	byte ptr [rcx], 0
-;; 2c1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2c1d:	 800100               	add	byte ptr [rcx], 0
-;; 2c20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2c29:	 800100               	add	byte ptr [rcx], 0
-;; 2c2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2c2d:	 800100               	add	byte ptr [rcx], 0
-;; 2c30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2c39:	 800100               	add	byte ptr [rcx], 0
-;; 2c3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2c3d:	 800100               	add	byte ptr [rcx], 0
-;; 2c40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2c49:	 800100               	add	byte ptr [rcx], 0
-;; 2c4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2c4d:	 800100               	add	byte ptr [rcx], 0
-;; 2c50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2c59:	 800100               	add	byte ptr [rcx], 0
-;; 2c5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2c5d:	 800100               	add	byte ptr [rcx], 0
-;; 2c60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2c69:	 800100               	add	byte ptr [rcx], 0
-;; 2c6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2c6d:	 800100               	add	byte ptr [rcx], 0
-;; 2c70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2c79:	 800100               	add	byte ptr [rcx], 0
-;; 2c7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2c7d:	 800100               	add	byte ptr [rcx], 0
-;; 2c80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2c89:	 800100               	add	byte ptr [rcx], 0
-;; 2c8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2c8d:	 800100               	add	byte ptr [rcx], 0
-;; 2c90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2c99:	 800100               	add	byte ptr [rcx], 0
-;; 2c9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2c9d:	 800100               	add	byte ptr [rcx], 0
-;; 2ca0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2ca9:	 800100               	add	byte ptr [rcx], 0
-;; 2cac:	 aa                   	stosb	byte ptr [rdi], al
-;; 2cad:	 800100               	add	byte ptr [rcx], 0
-;; 2cb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2cb9:	 800100               	add	byte ptr [rcx], 0
-;; 2cbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 2cbd:	 800100               	add	byte ptr [rcx], 0
-;; 2cc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2cc9:	 800100               	add	byte ptr [rcx], 0
-;; 2ccc:	 aa                   	stosb	byte ptr [rdi], al
-;; 2ccd:	 800100               	add	byte ptr [rcx], 0
-;; 2cd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2cd9:	 800100               	add	byte ptr [rcx], 0
-;; 2cdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 2cdd:	 800100               	add	byte ptr [rcx], 0
-;; 2ce0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2ce9:	 800100               	add	byte ptr [rcx], 0
-;; 2cec:	 aa                   	stosb	byte ptr [rdi], al
-;; 2ced:	 800100               	add	byte ptr [rcx], 0
-;; 2cf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2cf9:	 800100               	add	byte ptr [rcx], 0
-;; 2cfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 2cfd:	 800100               	add	byte ptr [rcx], 0
-;; 2d00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2d09:	 800100               	add	byte ptr [rcx], 0
-;; 2d0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2d0d:	 800100               	add	byte ptr [rcx], 0
-;; 2d10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2d19:	 800100               	add	byte ptr [rcx], 0
-;; 2d1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2d1d:	 800100               	add	byte ptr [rcx], 0
-;; 2d20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2d29:	 800100               	add	byte ptr [rcx], 0
-;; 2d2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2d2d:	 800100               	add	byte ptr [rcx], 0
-;; 2d30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2d39:	 800100               	add	byte ptr [rcx], 0
-;; 2d3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2d3d:	 800100               	add	byte ptr [rcx], 0
-;; 2d40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2d49:	 800100               	add	byte ptr [rcx], 0
-;; 2d4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2d4d:	 800100               	add	byte ptr [rcx], 0
-;; 2d50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2d59:	 800100               	add	byte ptr [rcx], 0
-;; 2d5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2d5d:	 800100               	add	byte ptr [rcx], 0
-;; 2d60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2d69:	 800100               	add	byte ptr [rcx], 0
-;; 2d6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2d6d:	 800100               	add	byte ptr [rcx], 0
-;; 2d70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2d79:	 800100               	add	byte ptr [rcx], 0
-;; 2d7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2d7d:	 800100               	add	byte ptr [rcx], 0
-;; 2d80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2d89:	 800100               	add	byte ptr [rcx], 0
-;; 2d8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2d8d:	 800100               	add	byte ptr [rcx], 0
-;; 2d90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2d99:	 800100               	add	byte ptr [rcx], 0
-;; 2d9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2d9d:	 800100               	add	byte ptr [rcx], 0
-;; 2da0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2da9:	 800100               	add	byte ptr [rcx], 0
-;; 2dac:	 aa                   	stosb	byte ptr [rdi], al
-;; 2dad:	 800100               	add	byte ptr [rcx], 0
-;; 2db0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2db9:	 800100               	add	byte ptr [rcx], 0
-;; 2dbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 2dbd:	 800100               	add	byte ptr [rcx], 0
-;; 2dc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2dc9:	 800100               	add	byte ptr [rcx], 0
-;; 2dcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 2dcd:	 800100               	add	byte ptr [rcx], 0
-;; 2dd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2dd9:	 800100               	add	byte ptr [rcx], 0
-;; 2ddc:	 aa                   	stosb	byte ptr [rdi], al
-;; 2ddd:	 800100               	add	byte ptr [rcx], 0
-;; 2de0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2de9:	 800100               	add	byte ptr [rcx], 0
-;; 2dec:	 aa                   	stosb	byte ptr [rdi], al
-;; 2ded:	 800100               	add	byte ptr [rcx], 0
-;; 2df0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2df9:	 800100               	add	byte ptr [rcx], 0
-;; 2dfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 2dfd:	 800100               	add	byte ptr [rcx], 0
-;; 2e00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2e09:	 800100               	add	byte ptr [rcx], 0
-;; 2e0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2e0d:	 800100               	add	byte ptr [rcx], 0
-;; 2e10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2e19:	 800100               	add	byte ptr [rcx], 0
-;; 2e1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2e1d:	 800100               	add	byte ptr [rcx], 0
-;; 2e20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2e29:	 800100               	add	byte ptr [rcx], 0
-;; 2e2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2e2d:	 800100               	add	byte ptr [rcx], 0
-;; 2e30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2e39:	 800100               	add	byte ptr [rcx], 0
-;; 2e3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2e3d:	 800100               	add	byte ptr [rcx], 0
-;; 2e40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2e49:	 800100               	add	byte ptr [rcx], 0
-;; 2e4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2e4d:	 800100               	add	byte ptr [rcx], 0
-;; 2e50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2e59:	 800100               	add	byte ptr [rcx], 0
-;; 2e5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2e5d:	 800100               	add	byte ptr [rcx], 0
-;; 2e60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2e69:	 800100               	add	byte ptr [rcx], 0
-;; 2e6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2e6d:	 800100               	add	byte ptr [rcx], 0
-;; 2e70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2e79:	 800100               	add	byte ptr [rcx], 0
-;; 2e7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2e7d:	 800100               	add	byte ptr [rcx], 0
-;; 2e80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2e89:	 800100               	add	byte ptr [rcx], 0
-;; 2e8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2e8d:	 800100               	add	byte ptr [rcx], 0
-;; 2e90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2e99:	 800100               	add	byte ptr [rcx], 0
-;; 2e9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2e9d:	 800100               	add	byte ptr [rcx], 0
-;; 2ea0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2ea9:	 800100               	add	byte ptr [rcx], 0
-;; 2eac:	 aa                   	stosb	byte ptr [rdi], al
-;; 2ead:	 800100               	add	byte ptr [rcx], 0
-;; 2eb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2eb9:	 800100               	add	byte ptr [rcx], 0
-;; 2ebc:	 aa                   	stosb	byte ptr [rdi], al
-;; 2ebd:	 800100               	add	byte ptr [rcx], 0
-;; 2ec0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2ec9:	 800100               	add	byte ptr [rcx], 0
-;; 2ecc:	 aa                   	stosb	byte ptr [rdi], al
-;; 2ecd:	 800100               	add	byte ptr [rcx], 0
-;; 2ed0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2ed9:	 800100               	add	byte ptr [rcx], 0
-;; 2edc:	 aa                   	stosb	byte ptr [rdi], al
-;; 2edd:	 800100               	add	byte ptr [rcx], 0
-;; 2ee0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2ee9:	 800100               	add	byte ptr [rcx], 0
-;; 2eec:	 aa                   	stosb	byte ptr [rdi], al
-;; 2eed:	 800100               	add	byte ptr [rcx], 0
-;; 2ef0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2ef9:	 800100               	add	byte ptr [rcx], 0
-;; 2efc:	 aa                   	stosb	byte ptr [rdi], al
-;; 2efd:	 800100               	add	byte ptr [rcx], 0
-;; 2f00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2f09:	 800100               	add	byte ptr [rcx], 0
-;; 2f0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2f0d:	 800100               	add	byte ptr [rcx], 0
-;; 2f10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2f19:	 800100               	add	byte ptr [rcx], 0
-;; 2f1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2f1d:	 800100               	add	byte ptr [rcx], 0
-;; 2f20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2f29:	 800100               	add	byte ptr [rcx], 0
-;; 2f2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2f2d:	 800100               	add	byte ptr [rcx], 0
-;; 2f30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2f39:	 800100               	add	byte ptr [rcx], 0
-;; 2f3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2f3d:	 800100               	add	byte ptr [rcx], 0
-;; 2f40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2f49:	 800100               	add	byte ptr [rcx], 0
-;; 2f4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2f4d:	 800100               	add	byte ptr [rcx], 0
-;; 2f50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2f59:	 800100               	add	byte ptr [rcx], 0
-;; 2f5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2f5d:	 800100               	add	byte ptr [rcx], 0
-;; 2f60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2f69:	 800100               	add	byte ptr [rcx], 0
-;; 2f6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2f6d:	 800100               	add	byte ptr [rcx], 0
-;; 2f70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2f79:	 800100               	add	byte ptr [rcx], 0
-;; 2f7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2f7d:	 800100               	add	byte ptr [rcx], 0
-;; 2f80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2f89:	 800100               	add	byte ptr [rcx], 0
-;; 2f8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2f8d:	 800100               	add	byte ptr [rcx], 0
-;; 2f90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2f99:	 800100               	add	byte ptr [rcx], 0
-;; 2f9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 2f9d:	 800100               	add	byte ptr [rcx], 0
-;; 2fa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2fa9:	 800100               	add	byte ptr [rcx], 0
-;; 2fac:	 aa                   	stosb	byte ptr [rdi], al
-;; 2fad:	 800100               	add	byte ptr [rcx], 0
-;; 2fb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2fb9:	 800100               	add	byte ptr [rcx], 0
-;; 2fbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 2fbd:	 800100               	add	byte ptr [rcx], 0
-;; 2fc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2fc9:	 800100               	add	byte ptr [rcx], 0
-;; 2fcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 2fcd:	 800100               	add	byte ptr [rcx], 0
-;; 2fd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2fd9:	 800100               	add	byte ptr [rcx], 0
-;; 2fdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 2fdd:	 800100               	add	byte ptr [rcx], 0
-;; 2fe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2fe9:	 800100               	add	byte ptr [rcx], 0
-;; 2fec:	 aa                   	stosb	byte ptr [rdi], al
-;; 2fed:	 800100               	add	byte ptr [rcx], 0
-;; 2ff0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 2ff9:	 800100               	add	byte ptr [rcx], 0
-;; 2ffc:	 aa                   	stosb	byte ptr [rdi], al
-;; 2ffd:	 800100               	add	byte ptr [rcx], 0
-;; 3000:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3009:	 800100               	add	byte ptr [rcx], 0
-;; 300c:	 aa                   	stosb	byte ptr [rdi], al
-;; 300d:	 800100               	add	byte ptr [rcx], 0
-;; 3010:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3019:	 800100               	add	byte ptr [rcx], 0
-;; 301c:	 aa                   	stosb	byte ptr [rdi], al
-;; 301d:	 800100               	add	byte ptr [rcx], 0
-;; 3020:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3029:	 800100               	add	byte ptr [rcx], 0
-;; 302c:	 aa                   	stosb	byte ptr [rdi], al
-;; 302d:	 800100               	add	byte ptr [rcx], 0
-;; 3030:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3039:	 800100               	add	byte ptr [rcx], 0
-;; 303c:	 aa                   	stosb	byte ptr [rdi], al
-;; 303d:	 800100               	add	byte ptr [rcx], 0
-;; 3040:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3049:	 800100               	add	byte ptr [rcx], 0
-;; 304c:	 aa                   	stosb	byte ptr [rdi], al
-;; 304d:	 800100               	add	byte ptr [rcx], 0
-;; 3050:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3059:	 800100               	add	byte ptr [rcx], 0
-;; 305c:	 aa                   	stosb	byte ptr [rdi], al
-;; 305d:	 800100               	add	byte ptr [rcx], 0
-;; 3060:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3069:	 800100               	add	byte ptr [rcx], 0
-;; 306c:	 aa                   	stosb	byte ptr [rdi], al
-;; 306d:	 800100               	add	byte ptr [rcx], 0
-;; 3070:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3079:	 800100               	add	byte ptr [rcx], 0
-;; 307c:	 aa                   	stosb	byte ptr [rdi], al
-;; 307d:	 800100               	add	byte ptr [rcx], 0
-;; 3080:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3089:	 800100               	add	byte ptr [rcx], 0
-;; 308c:	 aa                   	stosb	byte ptr [rdi], al
-;; 308d:	 800100               	add	byte ptr [rcx], 0
-;; 3090:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3099:	 800100               	add	byte ptr [rcx], 0
-;; 309c:	 aa                   	stosb	byte ptr [rdi], al
-;; 309d:	 800100               	add	byte ptr [rcx], 0
-;; 30a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 30a9:	 800100               	add	byte ptr [rcx], 0
-;; 30ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 30ad:	 800100               	add	byte ptr [rcx], 0
-;; 30b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 30b9:	 800100               	add	byte ptr [rcx], 0
-;; 30bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 30bd:	 800100               	add	byte ptr [rcx], 0
-;; 30c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 30c9:	 800100               	add	byte ptr [rcx], 0
-;; 30cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 30cd:	 800100               	add	byte ptr [rcx], 0
-;; 30d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 30d9:	 800100               	add	byte ptr [rcx], 0
-;; 30dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 30dd:	 800100               	add	byte ptr [rcx], 0
-;; 30e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 30e9:	 800100               	add	byte ptr [rcx], 0
-;; 30ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 30ed:	 800100               	add	byte ptr [rcx], 0
-;; 30f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 30f9:	 800100               	add	byte ptr [rcx], 0
-;; 30fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 30fd:	 800100               	add	byte ptr [rcx], 0
-;; 3100:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3109:	 800100               	add	byte ptr [rcx], 0
-;; 310c:	 aa                   	stosb	byte ptr [rdi], al
-;; 310d:	 800100               	add	byte ptr [rcx], 0
-;; 3110:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3119:	 800100               	add	byte ptr [rcx], 0
-;; 311c:	 aa                   	stosb	byte ptr [rdi], al
-;; 311d:	 800100               	add	byte ptr [rcx], 0
-;; 3120:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3129:	 800100               	add	byte ptr [rcx], 0
-;; 312c:	 aa                   	stosb	byte ptr [rdi], al
-;; 312d:	 800100               	add	byte ptr [rcx], 0
-;; 3130:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3139:	 800100               	add	byte ptr [rcx], 0
-;; 313c:	 aa                   	stosb	byte ptr [rdi], al
-;; 313d:	 800100               	add	byte ptr [rcx], 0
-;; 3140:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3149:	 800100               	add	byte ptr [rcx], 0
-;; 314c:	 aa                   	stosb	byte ptr [rdi], al
-;; 314d:	 800100               	add	byte ptr [rcx], 0
-;; 3150:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3159:	 800100               	add	byte ptr [rcx], 0
-;; 315c:	 aa                   	stosb	byte ptr [rdi], al
-;; 315d:	 800100               	add	byte ptr [rcx], 0
-;; 3160:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3169:	 800100               	add	byte ptr [rcx], 0
-;; 316c:	 aa                   	stosb	byte ptr [rdi], al
-;; 316d:	 800100               	add	byte ptr [rcx], 0
-;; 3170:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3179:	 800100               	add	byte ptr [rcx], 0
-;; 317c:	 aa                   	stosb	byte ptr [rdi], al
-;; 317d:	 800100               	add	byte ptr [rcx], 0
-;; 3180:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3189:	 800100               	add	byte ptr [rcx], 0
-;; 318c:	 aa                   	stosb	byte ptr [rdi], al
-;; 318d:	 800100               	add	byte ptr [rcx], 0
-;; 3190:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3199:	 800100               	add	byte ptr [rcx], 0
-;; 319c:	 aa                   	stosb	byte ptr [rdi], al
-;; 319d:	 800100               	add	byte ptr [rcx], 0
-;; 31a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 31a9:	 800100               	add	byte ptr [rcx], 0
-;; 31ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 31ad:	 800100               	add	byte ptr [rcx], 0
-;; 31b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 31b9:	 800100               	add	byte ptr [rcx], 0
-;; 31bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 31bd:	 800100               	add	byte ptr [rcx], 0
-;; 31c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 31c9:	 800100               	add	byte ptr [rcx], 0
-;; 31cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 31cd:	 800100               	add	byte ptr [rcx], 0
-;; 31d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 31d9:	 800100               	add	byte ptr [rcx], 0
-;; 31dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 31dd:	 800100               	add	byte ptr [rcx], 0
-;; 31e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 31e9:	 800100               	add	byte ptr [rcx], 0
-;; 31ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 31ed:	 800100               	add	byte ptr [rcx], 0
-;; 31f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 31f9:	 800100               	add	byte ptr [rcx], 0
-;; 31fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 31fd:	 800100               	add	byte ptr [rcx], 0
-;; 3200:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3209:	 800100               	add	byte ptr [rcx], 0
-;; 320c:	 aa                   	stosb	byte ptr [rdi], al
-;; 320d:	 800100               	add	byte ptr [rcx], 0
-;; 3210:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3219:	 800100               	add	byte ptr [rcx], 0
-;; 321c:	 aa                   	stosb	byte ptr [rdi], al
-;; 321d:	 800100               	add	byte ptr [rcx], 0
-;; 3220:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3229:	 800100               	add	byte ptr [rcx], 0
-;; 322c:	 aa                   	stosb	byte ptr [rdi], al
-;; 322d:	 800100               	add	byte ptr [rcx], 0
-;; 3230:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3239:	 800100               	add	byte ptr [rcx], 0
-;; 323c:	 aa                   	stosb	byte ptr [rdi], al
-;; 323d:	 800100               	add	byte ptr [rcx], 0
-;; 3240:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3249:	 800100               	add	byte ptr [rcx], 0
-;; 324c:	 aa                   	stosb	byte ptr [rdi], al
-;; 324d:	 800100               	add	byte ptr [rcx], 0
-;; 3250:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3259:	 800100               	add	byte ptr [rcx], 0
-;; 325c:	 aa                   	stosb	byte ptr [rdi], al
-;; 325d:	 800100               	add	byte ptr [rcx], 0
-;; 3260:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3269:	 800100               	add	byte ptr [rcx], 0
-;; 326c:	 aa                   	stosb	byte ptr [rdi], al
-;; 326d:	 800100               	add	byte ptr [rcx], 0
-;; 3270:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3279:	 800100               	add	byte ptr [rcx], 0
-;; 327c:	 aa                   	stosb	byte ptr [rdi], al
-;; 327d:	 800100               	add	byte ptr [rcx], 0
-;; 3280:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3289:	 800100               	add	byte ptr [rcx], 0
-;; 328c:	 aa                   	stosb	byte ptr [rdi], al
-;; 328d:	 800100               	add	byte ptr [rcx], 0
-;; 3290:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3299:	 800100               	add	byte ptr [rcx], 0
-;; 329c:	 aa                   	stosb	byte ptr [rdi], al
-;; 329d:	 800100               	add	byte ptr [rcx], 0
-;; 32a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 32a9:	 800100               	add	byte ptr [rcx], 0
-;; 32ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 32ad:	 800100               	add	byte ptr [rcx], 0
-;; 32b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 32b9:	 800100               	add	byte ptr [rcx], 0
-;; 32bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 32bd:	 800100               	add	byte ptr [rcx], 0
-;; 32c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 32c9:	 800100               	add	byte ptr [rcx], 0
-;; 32cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 32cd:	 800100               	add	byte ptr [rcx], 0
-;; 32d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 32d9:	 800100               	add	byte ptr [rcx], 0
-;; 32dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 32dd:	 800100               	add	byte ptr [rcx], 0
-;; 32e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 32e9:	 800100               	add	byte ptr [rcx], 0
-;; 32ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 32ed:	 800100               	add	byte ptr [rcx], 0
-;; 32f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 32f9:	 800100               	add	byte ptr [rcx], 0
-;; 32fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 32fd:	 800100               	add	byte ptr [rcx], 0
-;; 3300:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3309:	 800100               	add	byte ptr [rcx], 0
-;; 330c:	 aa                   	stosb	byte ptr [rdi], al
-;; 330d:	 800100               	add	byte ptr [rcx], 0
-;; 3310:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3319:	 800100               	add	byte ptr [rcx], 0
-;; 331c:	 aa                   	stosb	byte ptr [rdi], al
-;; 331d:	 800100               	add	byte ptr [rcx], 0
-;; 3320:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3329:	 800100               	add	byte ptr [rcx], 0
-;; 332c:	 aa                   	stosb	byte ptr [rdi], al
-;; 332d:	 800100               	add	byte ptr [rcx], 0
-;; 3330:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3339:	 800100               	add	byte ptr [rcx], 0
-;; 333c:	 aa                   	stosb	byte ptr [rdi], al
-;; 333d:	 800100               	add	byte ptr [rcx], 0
-;; 3340:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3349:	 800100               	add	byte ptr [rcx], 0
-;; 334c:	 aa                   	stosb	byte ptr [rdi], al
-;; 334d:	 800100               	add	byte ptr [rcx], 0
-;; 3350:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3359:	 800100               	add	byte ptr [rcx], 0
-;; 335c:	 aa                   	stosb	byte ptr [rdi], al
-;; 335d:	 800100               	add	byte ptr [rcx], 0
-;; 3360:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3369:	 800100               	add	byte ptr [rcx], 0
-;; 336c:	 aa                   	stosb	byte ptr [rdi], al
-;; 336d:	 800100               	add	byte ptr [rcx], 0
-;; 3370:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3379:	 800100               	add	byte ptr [rcx], 0
-;; 337c:	 aa                   	stosb	byte ptr [rdi], al
-;; 337d:	 800100               	add	byte ptr [rcx], 0
-;; 3380:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3389:	 800100               	add	byte ptr [rcx], 0
-;; 338c:	 aa                   	stosb	byte ptr [rdi], al
-;; 338d:	 800100               	add	byte ptr [rcx], 0
-;; 3390:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3399:	 800100               	add	byte ptr [rcx], 0
-;; 339c:	 aa                   	stosb	byte ptr [rdi], al
-;; 339d:	 800100               	add	byte ptr [rcx], 0
-;; 33a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 33a9:	 800100               	add	byte ptr [rcx], 0
-;; 33ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 33ad:	 800100               	add	byte ptr [rcx], 0
-;; 33b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 33b9:	 800100               	add	byte ptr [rcx], 0
-;; 33bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 33bd:	 800100               	add	byte ptr [rcx], 0
-;; 33c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 33c9:	 800100               	add	byte ptr [rcx], 0
-;; 33cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 33cd:	 800100               	add	byte ptr [rcx], 0
-;; 33d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 33d9:	 800100               	add	byte ptr [rcx], 0
-;; 33dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 33dd:	 800100               	add	byte ptr [rcx], 0
-;; 33e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 33e9:	 800100               	add	byte ptr [rcx], 0
-;; 33ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 33ed:	 800100               	add	byte ptr [rcx], 0
-;; 33f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 33f9:	 800100               	add	byte ptr [rcx], 0
-;; 33fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 33fd:	 800100               	add	byte ptr [rcx], 0
-;; 3400:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3409:	 800100               	add	byte ptr [rcx], 0
-;; 340c:	 aa                   	stosb	byte ptr [rdi], al
-;; 340d:	 800100               	add	byte ptr [rcx], 0
-;; 3410:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3419:	 800100               	add	byte ptr [rcx], 0
-;; 341c:	 aa                   	stosb	byte ptr [rdi], al
-;; 341d:	 800100               	add	byte ptr [rcx], 0
-;; 3420:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3429:	 800100               	add	byte ptr [rcx], 0
-;; 342c:	 aa                   	stosb	byte ptr [rdi], al
-;; 342d:	 800100               	add	byte ptr [rcx], 0
-;; 3430:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3439:	 800100               	add	byte ptr [rcx], 0
-;; 343c:	 aa                   	stosb	byte ptr [rdi], al
-;; 343d:	 800100               	add	byte ptr [rcx], 0
-;; 3440:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3449:	 800100               	add	byte ptr [rcx], 0
-;; 344c:	 aa                   	stosb	byte ptr [rdi], al
-;; 344d:	 800100               	add	byte ptr [rcx], 0
-;; 3450:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3459:	 800100               	add	byte ptr [rcx], 0
-;; 345c:	 aa                   	stosb	byte ptr [rdi], al
-;; 345d:	 800100               	add	byte ptr [rcx], 0
-;; 3460:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3469:	 800100               	add	byte ptr [rcx], 0
-;; 346c:	 aa                   	stosb	byte ptr [rdi], al
-;; 346d:	 800100               	add	byte ptr [rcx], 0
-;; 3470:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3479:	 800100               	add	byte ptr [rcx], 0
-;; 347c:	 aa                   	stosb	byte ptr [rdi], al
-;; 347d:	 800100               	add	byte ptr [rcx], 0
-;; 3480:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3489:	 800100               	add	byte ptr [rcx], 0
-;; 348c:	 aa                   	stosb	byte ptr [rdi], al
-;; 348d:	 800100               	add	byte ptr [rcx], 0
-;; 3490:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3499:	 800100               	add	byte ptr [rcx], 0
-;; 349c:	 aa                   	stosb	byte ptr [rdi], al
-;; 349d:	 800100               	add	byte ptr [rcx], 0
-;; 34a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 34a9:	 800100               	add	byte ptr [rcx], 0
-;; 34ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 34ad:	 800100               	add	byte ptr [rcx], 0
-;; 34b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 34b9:	 800100               	add	byte ptr [rcx], 0
-;; 34bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 34bd:	 800100               	add	byte ptr [rcx], 0
-;; 34c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 34c9:	 800100               	add	byte ptr [rcx], 0
-;; 34cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 34cd:	 800100               	add	byte ptr [rcx], 0
-;; 34d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 34d9:	 800100               	add	byte ptr [rcx], 0
-;; 34dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 34dd:	 800100               	add	byte ptr [rcx], 0
-;; 34e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 34e9:	 800100               	add	byte ptr [rcx], 0
-;; 34ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 34ed:	 800100               	add	byte ptr [rcx], 0
-;; 34f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 34f9:	 800100               	add	byte ptr [rcx], 0
-;; 34fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 34fd:	 800100               	add	byte ptr [rcx], 0
-;; 3500:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3509:	 800100               	add	byte ptr [rcx], 0
-;; 350c:	 aa                   	stosb	byte ptr [rdi], al
-;; 350d:	 800100               	add	byte ptr [rcx], 0
-;; 3510:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3519:	 800100               	add	byte ptr [rcx], 0
-;; 351c:	 aa                   	stosb	byte ptr [rdi], al
-;; 351d:	 800100               	add	byte ptr [rcx], 0
-;; 3520:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3529:	 800100               	add	byte ptr [rcx], 0
-;; 352c:	 aa                   	stosb	byte ptr [rdi], al
-;; 352d:	 800100               	add	byte ptr [rcx], 0
-;; 3530:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3539:	 800100               	add	byte ptr [rcx], 0
-;; 353c:	 aa                   	stosb	byte ptr [rdi], al
-;; 353d:	 800100               	add	byte ptr [rcx], 0
-;; 3540:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3549:	 800100               	add	byte ptr [rcx], 0
-;; 354c:	 aa                   	stosb	byte ptr [rdi], al
-;; 354d:	 800100               	add	byte ptr [rcx], 0
-;; 3550:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3559:	 800100               	add	byte ptr [rcx], 0
-;; 355c:	 aa                   	stosb	byte ptr [rdi], al
-;; 355d:	 800100               	add	byte ptr [rcx], 0
-;; 3560:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3569:	 800100               	add	byte ptr [rcx], 0
-;; 356c:	 aa                   	stosb	byte ptr [rdi], al
-;; 356d:	 800100               	add	byte ptr [rcx], 0
-;; 3570:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3579:	 800100               	add	byte ptr [rcx], 0
-;; 357c:	 aa                   	stosb	byte ptr [rdi], al
-;; 357d:	 800100               	add	byte ptr [rcx], 0
-;; 3580:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3589:	 800100               	add	byte ptr [rcx], 0
-;; 358c:	 aa                   	stosb	byte ptr [rdi], al
-;; 358d:	 800100               	add	byte ptr [rcx], 0
-;; 3590:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3599:	 800100               	add	byte ptr [rcx], 0
-;; 359c:	 aa                   	stosb	byte ptr [rdi], al
-;; 359d:	 800100               	add	byte ptr [rcx], 0
-;; 35a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 35a9:	 800100               	add	byte ptr [rcx], 0
-;; 35ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 35ad:	 800100               	add	byte ptr [rcx], 0
-;; 35b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 35b9:	 800100               	add	byte ptr [rcx], 0
-;; 35bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 35bd:	 800100               	add	byte ptr [rcx], 0
-;; 35c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 35c9:	 800100               	add	byte ptr [rcx], 0
-;; 35cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 35cd:	 800100               	add	byte ptr [rcx], 0
-;; 35d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 35d9:	 800100               	add	byte ptr [rcx], 0
-;; 35dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 35dd:	 800100               	add	byte ptr [rcx], 0
-;; 35e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 35e9:	 800100               	add	byte ptr [rcx], 0
-;; 35ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 35ed:	 800100               	add	byte ptr [rcx], 0
-;; 35f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 35f9:	 800100               	add	byte ptr [rcx], 0
-;; 35fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 35fd:	 800100               	add	byte ptr [rcx], 0
-;; 3600:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3609:	 800100               	add	byte ptr [rcx], 0
-;; 360c:	 aa                   	stosb	byte ptr [rdi], al
-;; 360d:	 800100               	add	byte ptr [rcx], 0
-;; 3610:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3619:	 800100               	add	byte ptr [rcx], 0
-;; 361c:	 aa                   	stosb	byte ptr [rdi], al
-;; 361d:	 800100               	add	byte ptr [rcx], 0
-;; 3620:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3629:	 800100               	add	byte ptr [rcx], 0
-;; 362c:	 aa                   	stosb	byte ptr [rdi], al
-;; 362d:	 800100               	add	byte ptr [rcx], 0
-;; 3630:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3639:	 800100               	add	byte ptr [rcx], 0
-;; 363c:	 aa                   	stosb	byte ptr [rdi], al
-;; 363d:	 800100               	add	byte ptr [rcx], 0
-;; 3640:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3649:	 800100               	add	byte ptr [rcx], 0
-;; 364c:	 aa                   	stosb	byte ptr [rdi], al
-;; 364d:	 800100               	add	byte ptr [rcx], 0
-;; 3650:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3659:	 800100               	add	byte ptr [rcx], 0
-;; 365c:	 aa                   	stosb	byte ptr [rdi], al
-;; 365d:	 800100               	add	byte ptr [rcx], 0
-;; 3660:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3669:	 800100               	add	byte ptr [rcx], 0
-;; 366c:	 aa                   	stosb	byte ptr [rdi], al
-;; 366d:	 800100               	add	byte ptr [rcx], 0
-;; 3670:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3679:	 800100               	add	byte ptr [rcx], 0
-;; 367c:	 aa                   	stosb	byte ptr [rdi], al
-;; 367d:	 800100               	add	byte ptr [rcx], 0
-;; 3680:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3689:	 800100               	add	byte ptr [rcx], 0
-;; 368c:	 aa                   	stosb	byte ptr [rdi], al
-;; 368d:	 800100               	add	byte ptr [rcx], 0
-;; 3690:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3699:	 800100               	add	byte ptr [rcx], 0
-;; 369c:	 aa                   	stosb	byte ptr [rdi], al
-;; 369d:	 800100               	add	byte ptr [rcx], 0
-;; 36a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 36a9:	 800100               	add	byte ptr [rcx], 0
-;; 36ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 36ad:	 800100               	add	byte ptr [rcx], 0
-;; 36b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 36b9:	 800100               	add	byte ptr [rcx], 0
-;; 36bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 36bd:	 800100               	add	byte ptr [rcx], 0
-;; 36c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 36c9:	 800100               	add	byte ptr [rcx], 0
-;; 36cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 36cd:	 800100               	add	byte ptr [rcx], 0
-;; 36d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 36d9:	 800100               	add	byte ptr [rcx], 0
-;; 36dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 36dd:	 800100               	add	byte ptr [rcx], 0
-;; 36e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 36e9:	 800100               	add	byte ptr [rcx], 0
-;; 36ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 36ed:	 800100               	add	byte ptr [rcx], 0
-;; 36f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 36f9:	 800100               	add	byte ptr [rcx], 0
-;; 36fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 36fd:	 800100               	add	byte ptr [rcx], 0
-;; 3700:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3709:	 800100               	add	byte ptr [rcx], 0
-;; 370c:	 aa                   	stosb	byte ptr [rdi], al
-;; 370d:	 800100               	add	byte ptr [rcx], 0
-;; 3710:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3719:	 800100               	add	byte ptr [rcx], 0
-;; 371c:	 aa                   	stosb	byte ptr [rdi], al
-;; 371d:	 800100               	add	byte ptr [rcx], 0
-;; 3720:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3729:	 800100               	add	byte ptr [rcx], 0
-;; 372c:	 aa                   	stosb	byte ptr [rdi], al
-;; 372d:	 800100               	add	byte ptr [rcx], 0
-;; 3730:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3739:	 800100               	add	byte ptr [rcx], 0
-;; 373c:	 aa                   	stosb	byte ptr [rdi], al
-;; 373d:	 800100               	add	byte ptr [rcx], 0
-;; 3740:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3749:	 800100               	add	byte ptr [rcx], 0
-;; 374c:	 aa                   	stosb	byte ptr [rdi], al
-;; 374d:	 800100               	add	byte ptr [rcx], 0
-;; 3750:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3759:	 800100               	add	byte ptr [rcx], 0
-;; 375c:	 aa                   	stosb	byte ptr [rdi], al
-;; 375d:	 800100               	add	byte ptr [rcx], 0
-;; 3760:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3769:	 800100               	add	byte ptr [rcx], 0
-;; 376c:	 aa                   	stosb	byte ptr [rdi], al
-;; 376d:	 800100               	add	byte ptr [rcx], 0
-;; 3770:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3779:	 800100               	add	byte ptr [rcx], 0
-;; 377c:	 aa                   	stosb	byte ptr [rdi], al
-;; 377d:	 800100               	add	byte ptr [rcx], 0
-;; 3780:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3789:	 800100               	add	byte ptr [rcx], 0
-;; 378c:	 aa                   	stosb	byte ptr [rdi], al
-;; 378d:	 800100               	add	byte ptr [rcx], 0
-;; 3790:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3799:	 800100               	add	byte ptr [rcx], 0
-;; 379c:	 aa                   	stosb	byte ptr [rdi], al
-;; 379d:	 800100               	add	byte ptr [rcx], 0
-;; 37a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 37a9:	 800100               	add	byte ptr [rcx], 0
-;; 37ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 37ad:	 800100               	add	byte ptr [rcx], 0
-;; 37b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 37b9:	 800100               	add	byte ptr [rcx], 0
-;; 37bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 37bd:	 800100               	add	byte ptr [rcx], 0
-;; 37c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 37c9:	 800100               	add	byte ptr [rcx], 0
-;; 37cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 37cd:	 800100               	add	byte ptr [rcx], 0
-;; 37d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 37d9:	 800100               	add	byte ptr [rcx], 0
-;; 37dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 37dd:	 800100               	add	byte ptr [rcx], 0
-;; 37e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 37e9:	 800100               	add	byte ptr [rcx], 0
-;; 37ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 37ed:	 800100               	add	byte ptr [rcx], 0
-;; 37f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 37f9:	 800100               	add	byte ptr [rcx], 0
-;; 37fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 37fd:	 800100               	add	byte ptr [rcx], 0
-;; 3800:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3809:	 800100               	add	byte ptr [rcx], 0
-;; 380c:	 aa                   	stosb	byte ptr [rdi], al
-;; 380d:	 800100               	add	byte ptr [rcx], 0
-;; 3810:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3819:	 800100               	add	byte ptr [rcx], 0
-;; 381c:	 aa                   	stosb	byte ptr [rdi], al
-;; 381d:	 800100               	add	byte ptr [rcx], 0
-;; 3820:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3829:	 800100               	add	byte ptr [rcx], 0
-;; 382c:	 aa                   	stosb	byte ptr [rdi], al
-;; 382d:	 800100               	add	byte ptr [rcx], 0
-;; 3830:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3839:	 800100               	add	byte ptr [rcx], 0
-;; 383c:	 aa                   	stosb	byte ptr [rdi], al
-;; 383d:	 800100               	add	byte ptr [rcx], 0
-;; 3840:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3849:	 800100               	add	byte ptr [rcx], 0
-;; 384c:	 aa                   	stosb	byte ptr [rdi], al
-;; 384d:	 800100               	add	byte ptr [rcx], 0
-;; 3850:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3859:	 800100               	add	byte ptr [rcx], 0
-;; 385c:	 aa                   	stosb	byte ptr [rdi], al
-;; 385d:	 800100               	add	byte ptr [rcx], 0
-;; 3860:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3869:	 800100               	add	byte ptr [rcx], 0
-;; 386c:	 aa                   	stosb	byte ptr [rdi], al
-;; 386d:	 800100               	add	byte ptr [rcx], 0
-;; 3870:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3879:	 800100               	add	byte ptr [rcx], 0
-;; 387c:	 aa                   	stosb	byte ptr [rdi], al
-;; 387d:	 800100               	add	byte ptr [rcx], 0
-;; 3880:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3889:	 800100               	add	byte ptr [rcx], 0
-;; 388c:	 aa                   	stosb	byte ptr [rdi], al
-;; 388d:	 800100               	add	byte ptr [rcx], 0
-;; 3890:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3899:	 800100               	add	byte ptr [rcx], 0
-;; 389c:	 aa                   	stosb	byte ptr [rdi], al
-;; 389d:	 800100               	add	byte ptr [rcx], 0
-;; 38a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 38a9:	 800100               	add	byte ptr [rcx], 0
-;; 38ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 38ad:	 800100               	add	byte ptr [rcx], 0
-;; 38b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 38b9:	 800100               	add	byte ptr [rcx], 0
-;; 38bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 38bd:	 800100               	add	byte ptr [rcx], 0
-;; 38c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 38c9:	 800100               	add	byte ptr [rcx], 0
-;; 38cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 38cd:	 800100               	add	byte ptr [rcx], 0
-;; 38d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 38d9:	 800100               	add	byte ptr [rcx], 0
-;; 38dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 38dd:	 800100               	add	byte ptr [rcx], 0
-;; 38e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 38e9:	 800100               	add	byte ptr [rcx], 0
-;; 38ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 38ed:	 800100               	add	byte ptr [rcx], 0
-;; 38f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 38f9:	 800100               	add	byte ptr [rcx], 0
-;; 38fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 38fd:	 800100               	add	byte ptr [rcx], 0
-;; 3900:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3909:	 800100               	add	byte ptr [rcx], 0
-;; 390c:	 aa                   	stosb	byte ptr [rdi], al
-;; 390d:	 800100               	add	byte ptr [rcx], 0
-;; 3910:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3919:	 800100               	add	byte ptr [rcx], 0
-;; 391c:	 aa                   	stosb	byte ptr [rdi], al
-;; 391d:	 800100               	add	byte ptr [rcx], 0
-;; 3920:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3929:	 800100               	add	byte ptr [rcx], 0
-;; 392c:	 aa                   	stosb	byte ptr [rdi], al
-;; 392d:	 800100               	add	byte ptr [rcx], 0
-;; 3930:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3939:	 800100               	add	byte ptr [rcx], 0
-;; 393c:	 aa                   	stosb	byte ptr [rdi], al
-;; 393d:	 800100               	add	byte ptr [rcx], 0
-;; 3940:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3949:	 800100               	add	byte ptr [rcx], 0
-;; 394c:	 aa                   	stosb	byte ptr [rdi], al
-;; 394d:	 800100               	add	byte ptr [rcx], 0
-;; 3950:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3959:	 800100               	add	byte ptr [rcx], 0
-;; 395c:	 aa                   	stosb	byte ptr [rdi], al
-;; 395d:	 800100               	add	byte ptr [rcx], 0
-;; 3960:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3969:	 800100               	add	byte ptr [rcx], 0
-;; 396c:	 aa                   	stosb	byte ptr [rdi], al
-;; 396d:	 800100               	add	byte ptr [rcx], 0
-;; 3970:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3979:	 800100               	add	byte ptr [rcx], 0
-;; 397c:	 aa                   	stosb	byte ptr [rdi], al
-;; 397d:	 800100               	add	byte ptr [rcx], 0
-;; 3980:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3989:	 800100               	add	byte ptr [rcx], 0
-;; 398c:	 aa                   	stosb	byte ptr [rdi], al
-;; 398d:	 800100               	add	byte ptr [rcx], 0
-;; 3990:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3999:	 800100               	add	byte ptr [rcx], 0
-;; 399c:	 aa                   	stosb	byte ptr [rdi], al
-;; 399d:	 800100               	add	byte ptr [rcx], 0
-;; 39a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 39a9:	 800100               	add	byte ptr [rcx], 0
-;; 39ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 39ad:	 800100               	add	byte ptr [rcx], 0
-;; 39b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 39b9:	 800100               	add	byte ptr [rcx], 0
-;; 39bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 39bd:	 800100               	add	byte ptr [rcx], 0
-;; 39c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 39c9:	 800100               	add	byte ptr [rcx], 0
-;; 39cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 39cd:	 800100               	add	byte ptr [rcx], 0
-;; 39d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 39d9:	 800100               	add	byte ptr [rcx], 0
-;; 39dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 39dd:	 800100               	add	byte ptr [rcx], 0
-;; 39e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 39e9:	 800100               	add	byte ptr [rcx], 0
-;; 39ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 39ed:	 800100               	add	byte ptr [rcx], 0
-;; 39f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 39f9:	 800100               	add	byte ptr [rcx], 0
-;; 39fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 39fd:	 800100               	add	byte ptr [rcx], 0
-;; 3a00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3a09:	 800100               	add	byte ptr [rcx], 0
-;; 3a0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3a0d:	 800100               	add	byte ptr [rcx], 0
-;; 3a10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3a19:	 800100               	add	byte ptr [rcx], 0
-;; 3a1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3a1d:	 800100               	add	byte ptr [rcx], 0
-;; 3a20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3a29:	 800100               	add	byte ptr [rcx], 0
-;; 3a2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3a2d:	 800100               	add	byte ptr [rcx], 0
-;; 3a30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3a39:	 800100               	add	byte ptr [rcx], 0
-;; 3a3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3a3d:	 800100               	add	byte ptr [rcx], 0
-;; 3a40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3a49:	 800100               	add	byte ptr [rcx], 0
-;; 3a4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3a4d:	 800100               	add	byte ptr [rcx], 0
-;; 3a50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3a59:	 800100               	add	byte ptr [rcx], 0
-;; 3a5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3a5d:	 800100               	add	byte ptr [rcx], 0
-;; 3a60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3a69:	 800100               	add	byte ptr [rcx], 0
-;; 3a6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3a6d:	 800100               	add	byte ptr [rcx], 0
-;; 3a70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3a79:	 800100               	add	byte ptr [rcx], 0
-;; 3a7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3a7d:	 800100               	add	byte ptr [rcx], 0
-;; 3a80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3a89:	 800100               	add	byte ptr [rcx], 0
-;; 3a8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3a8d:	 800100               	add	byte ptr [rcx], 0
-;; 3a90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3a99:	 800100               	add	byte ptr [rcx], 0
-;; 3a9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3a9d:	 800100               	add	byte ptr [rcx], 0
-;; 3aa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3aa9:	 800100               	add	byte ptr [rcx], 0
-;; 3aac:	 aa                   	stosb	byte ptr [rdi], al
-;; 3aad:	 800100               	add	byte ptr [rcx], 0
-;; 3ab0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3ab9:	 800100               	add	byte ptr [rcx], 0
-;; 3abc:	 aa                   	stosb	byte ptr [rdi], al
-;; 3abd:	 800100               	add	byte ptr [rcx], 0
-;; 3ac0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3ac9:	 800100               	add	byte ptr [rcx], 0
-;; 3acc:	 aa                   	stosb	byte ptr [rdi], al
-;; 3acd:	 800100               	add	byte ptr [rcx], 0
-;; 3ad0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3ad9:	 800100               	add	byte ptr [rcx], 0
-;; 3adc:	 aa                   	stosb	byte ptr [rdi], al
-;; 3add:	 800100               	add	byte ptr [rcx], 0
-;; 3ae0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3ae9:	 800100               	add	byte ptr [rcx], 0
-;; 3aec:	 aa                   	stosb	byte ptr [rdi], al
-;; 3aed:	 800100               	add	byte ptr [rcx], 0
-;; 3af0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3af9:	 800100               	add	byte ptr [rcx], 0
-;; 3afc:	 aa                   	stosb	byte ptr [rdi], al
-;; 3afd:	 800100               	add	byte ptr [rcx], 0
-;; 3b00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3b09:	 800100               	add	byte ptr [rcx], 0
-;; 3b0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3b0d:	 800100               	add	byte ptr [rcx], 0
-;; 3b10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3b19:	 800100               	add	byte ptr [rcx], 0
-;; 3b1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3b1d:	 800100               	add	byte ptr [rcx], 0
-;; 3b20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3b29:	 800100               	add	byte ptr [rcx], 0
-;; 3b2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3b2d:	 800100               	add	byte ptr [rcx], 0
-;; 3b30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3b39:	 800100               	add	byte ptr [rcx], 0
-;; 3b3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3b3d:	 800100               	add	byte ptr [rcx], 0
-;; 3b40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3b49:	 800100               	add	byte ptr [rcx], 0
-;; 3b4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3b4d:	 800100               	add	byte ptr [rcx], 0
-;; 3b50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3b59:	 800100               	add	byte ptr [rcx], 0
-;; 3b5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3b5d:	 800100               	add	byte ptr [rcx], 0
-;; 3b60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3b69:	 800100               	add	byte ptr [rcx], 0
-;; 3b6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3b6d:	 800100               	add	byte ptr [rcx], 0
-;; 3b70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3b79:	 800100               	add	byte ptr [rcx], 0
-;; 3b7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3b7d:	 800100               	add	byte ptr [rcx], 0
-;; 3b80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3b89:	 800100               	add	byte ptr [rcx], 0
-;; 3b8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3b8d:	 800100               	add	byte ptr [rcx], 0
-;; 3b90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3b99:	 800100               	add	byte ptr [rcx], 0
-;; 3b9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3b9d:	 800100               	add	byte ptr [rcx], 0
-;; 3ba0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3ba9:	 800100               	add	byte ptr [rcx], 0
-;; 3bac:	 aa                   	stosb	byte ptr [rdi], al
-;; 3bad:	 800100               	add	byte ptr [rcx], 0
-;; 3bb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3bb9:	 800100               	add	byte ptr [rcx], 0
-;; 3bbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 3bbd:	 800100               	add	byte ptr [rcx], 0
-;; 3bc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3bc9:	 800100               	add	byte ptr [rcx], 0
-;; 3bcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 3bcd:	 800100               	add	byte ptr [rcx], 0
-;; 3bd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3bd9:	 800100               	add	byte ptr [rcx], 0
-;; 3bdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 3bdd:	 800100               	add	byte ptr [rcx], 0
-;; 3be0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3be9:	 800100               	add	byte ptr [rcx], 0
-;; 3bec:	 aa                   	stosb	byte ptr [rdi], al
-;; 3bed:	 800100               	add	byte ptr [rcx], 0
-;; 3bf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3bf9:	 800100               	add	byte ptr [rcx], 0
-;; 3bfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 3bfd:	 800100               	add	byte ptr [rcx], 0
-;; 3c00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3c09:	 800100               	add	byte ptr [rcx], 0
-;; 3c0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3c0d:	 800100               	add	byte ptr [rcx], 0
-;; 3c10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3c19:	 800100               	add	byte ptr [rcx], 0
-;; 3c1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3c1d:	 800100               	add	byte ptr [rcx], 0
-;; 3c20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3c29:	 800100               	add	byte ptr [rcx], 0
-;; 3c2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3c2d:	 800100               	add	byte ptr [rcx], 0
-;; 3c30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3c39:	 800100               	add	byte ptr [rcx], 0
-;; 3c3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3c3d:	 800100               	add	byte ptr [rcx], 0
-;; 3c40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3c49:	 800100               	add	byte ptr [rcx], 0
-;; 3c4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3c4d:	 800100               	add	byte ptr [rcx], 0
-;; 3c50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3c59:	 800100               	add	byte ptr [rcx], 0
-;; 3c5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3c5d:	 800100               	add	byte ptr [rcx], 0
-;; 3c60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3c69:	 800100               	add	byte ptr [rcx], 0
-;; 3c6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3c6d:	 800100               	add	byte ptr [rcx], 0
-;; 3c70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3c79:	 800100               	add	byte ptr [rcx], 0
-;; 3c7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3c7d:	 800100               	add	byte ptr [rcx], 0
-;; 3c80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3c89:	 800100               	add	byte ptr [rcx], 0
-;; 3c8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3c8d:	 800100               	add	byte ptr [rcx], 0
-;; 3c90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3c99:	 800100               	add	byte ptr [rcx], 0
-;; 3c9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3c9d:	 800100               	add	byte ptr [rcx], 0
-;; 3ca0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3ca9:	 800100               	add	byte ptr [rcx], 0
-;; 3cac:	 aa                   	stosb	byte ptr [rdi], al
-;; 3cad:	 800100               	add	byte ptr [rcx], 0
-;; 3cb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3cb9:	 800100               	add	byte ptr [rcx], 0
-;; 3cbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 3cbd:	 800100               	add	byte ptr [rcx], 0
-;; 3cc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3cc9:	 800100               	add	byte ptr [rcx], 0
-;; 3ccc:	 aa                   	stosb	byte ptr [rdi], al
-;; 3ccd:	 800100               	add	byte ptr [rcx], 0
-;; 3cd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3cd9:	 800100               	add	byte ptr [rcx], 0
-;; 3cdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 3cdd:	 800100               	add	byte ptr [rcx], 0
-;; 3ce0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3ce9:	 800100               	add	byte ptr [rcx], 0
-;; 3cec:	 aa                   	stosb	byte ptr [rdi], al
-;; 3ced:	 800100               	add	byte ptr [rcx], 0
-;; 3cf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3cf9:	 800100               	add	byte ptr [rcx], 0
-;; 3cfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 3cfd:	 800100               	add	byte ptr [rcx], 0
-;; 3d00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3d09:	 800100               	add	byte ptr [rcx], 0
-;; 3d0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3d0d:	 800100               	add	byte ptr [rcx], 0
-;; 3d10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3d19:	 800100               	add	byte ptr [rcx], 0
-;; 3d1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3d1d:	 800100               	add	byte ptr [rcx], 0
-;; 3d20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3d29:	 800100               	add	byte ptr [rcx], 0
-;; 3d2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3d2d:	 800100               	add	byte ptr [rcx], 0
-;; 3d30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3d39:	 800100               	add	byte ptr [rcx], 0
-;; 3d3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3d3d:	 800100               	add	byte ptr [rcx], 0
-;; 3d40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3d49:	 800100               	add	byte ptr [rcx], 0
-;; 3d4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3d4d:	 800100               	add	byte ptr [rcx], 0
-;; 3d50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3d59:	 800100               	add	byte ptr [rcx], 0
-;; 3d5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3d5d:	 800100               	add	byte ptr [rcx], 0
-;; 3d60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3d69:	 800100               	add	byte ptr [rcx], 0
-;; 3d6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3d6d:	 800100               	add	byte ptr [rcx], 0
-;; 3d70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3d79:	 800100               	add	byte ptr [rcx], 0
-;; 3d7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3d7d:	 800100               	add	byte ptr [rcx], 0
-;; 3d80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3d89:	 800100               	add	byte ptr [rcx], 0
-;; 3d8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3d8d:	 800100               	add	byte ptr [rcx], 0
-;; 3d90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3d99:	 800100               	add	byte ptr [rcx], 0
-;; 3d9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3d9d:	 800100               	add	byte ptr [rcx], 0
-;; 3da0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3da9:	 800100               	add	byte ptr [rcx], 0
-;; 3dac:	 aa                   	stosb	byte ptr [rdi], al
-;; 3dad:	 800100               	add	byte ptr [rcx], 0
-;; 3db0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3db9:	 800100               	add	byte ptr [rcx], 0
-;; 3dbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 3dbd:	 800100               	add	byte ptr [rcx], 0
-;; 3dc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3dc9:	 800100               	add	byte ptr [rcx], 0
-;; 3dcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 3dcd:	 800100               	add	byte ptr [rcx], 0
-;; 3dd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3dd9:	 800100               	add	byte ptr [rcx], 0
-;; 3ddc:	 aa                   	stosb	byte ptr [rdi], al
-;; 3ddd:	 800100               	add	byte ptr [rcx], 0
-;; 3de0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3de9:	 800100               	add	byte ptr [rcx], 0
-;; 3dec:	 aa                   	stosb	byte ptr [rdi], al
-;; 3ded:	 800100               	add	byte ptr [rcx], 0
-;; 3df0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3df9:	 800100               	add	byte ptr [rcx], 0
-;; 3dfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 3dfd:	 800100               	add	byte ptr [rcx], 0
-;; 3e00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3e09:	 800100               	add	byte ptr [rcx], 0
-;; 3e0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3e0d:	 800100               	add	byte ptr [rcx], 0
-;; 3e10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3e19:	 800100               	add	byte ptr [rcx], 0
-;; 3e1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3e1d:	 800100               	add	byte ptr [rcx], 0
-;; 3e20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3e29:	 800100               	add	byte ptr [rcx], 0
-;; 3e2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3e2d:	 800100               	add	byte ptr [rcx], 0
-;; 3e30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3e39:	 800100               	add	byte ptr [rcx], 0
-;; 3e3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3e3d:	 800100               	add	byte ptr [rcx], 0
-;; 3e40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3e49:	 800100               	add	byte ptr [rcx], 0
-;; 3e4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3e4d:	 800100               	add	byte ptr [rcx], 0
-;; 3e50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3e59:	 800100               	add	byte ptr [rcx], 0
-;; 3e5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3e5d:	 800100               	add	byte ptr [rcx], 0
-;; 3e60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3e69:	 800100               	add	byte ptr [rcx], 0
-;; 3e6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3e6d:	 800100               	add	byte ptr [rcx], 0
-;; 3e70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3e79:	 800100               	add	byte ptr [rcx], 0
-;; 3e7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3e7d:	 800100               	add	byte ptr [rcx], 0
-;; 3e80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3e89:	 800100               	add	byte ptr [rcx], 0
-;; 3e8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3e8d:	 800100               	add	byte ptr [rcx], 0
-;; 3e90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3e99:	 800100               	add	byte ptr [rcx], 0
-;; 3e9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3e9d:	 800100               	add	byte ptr [rcx], 0
-;; 3ea0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3ea9:	 800100               	add	byte ptr [rcx], 0
-;; 3eac:	 aa                   	stosb	byte ptr [rdi], al
-;; 3ead:	 800100               	add	byte ptr [rcx], 0
-;; 3eb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3eb9:	 800100               	add	byte ptr [rcx], 0
-;; 3ebc:	 aa                   	stosb	byte ptr [rdi], al
-;; 3ebd:	 800100               	add	byte ptr [rcx], 0
-;; 3ec0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3ec9:	 800100               	add	byte ptr [rcx], 0
-;; 3ecc:	 aa                   	stosb	byte ptr [rdi], al
-;; 3ecd:	 800100               	add	byte ptr [rcx], 0
-;; 3ed0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3ed9:	 800100               	add	byte ptr [rcx], 0
-;; 3edc:	 aa                   	stosb	byte ptr [rdi], al
-;; 3edd:	 800100               	add	byte ptr [rcx], 0
-;; 3ee0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3ee9:	 800100               	add	byte ptr [rcx], 0
-;; 3eec:	 aa                   	stosb	byte ptr [rdi], al
-;; 3eed:	 800100               	add	byte ptr [rcx], 0
-;; 3ef0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3ef9:	 800100               	add	byte ptr [rcx], 0
-;; 3efc:	 aa                   	stosb	byte ptr [rdi], al
-;; 3efd:	 800100               	add	byte ptr [rcx], 0
-;; 3f00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3f09:	 800100               	add	byte ptr [rcx], 0
-;; 3f0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3f0d:	 800100               	add	byte ptr [rcx], 0
-;; 3f10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3f19:	 800100               	add	byte ptr [rcx], 0
-;; 3f1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3f1d:	 800100               	add	byte ptr [rcx], 0
-;; 3f20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3f29:	 800100               	add	byte ptr [rcx], 0
-;; 3f2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3f2d:	 800100               	add	byte ptr [rcx], 0
-;; 3f30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3f39:	 800100               	add	byte ptr [rcx], 0
-;; 3f3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3f3d:	 800100               	add	byte ptr [rcx], 0
-;; 3f40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3f49:	 800100               	add	byte ptr [rcx], 0
-;; 3f4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3f4d:	 800100               	add	byte ptr [rcx], 0
-;; 3f50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3f59:	 800100               	add	byte ptr [rcx], 0
-;; 3f5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3f5d:	 800100               	add	byte ptr [rcx], 0
-;; 3f60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3f69:	 800100               	add	byte ptr [rcx], 0
-;; 3f6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3f6d:	 800100               	add	byte ptr [rcx], 0
-;; 3f70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3f79:	 800100               	add	byte ptr [rcx], 0
-;; 3f7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3f7d:	 800100               	add	byte ptr [rcx], 0
-;; 3f80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3f89:	 800100               	add	byte ptr [rcx], 0
-;; 3f8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3f8d:	 800100               	add	byte ptr [rcx], 0
-;; 3f90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3f99:	 800100               	add	byte ptr [rcx], 0
-;; 3f9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 3f9d:	 800100               	add	byte ptr [rcx], 0
-;; 3fa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3fa9:	 800100               	add	byte ptr [rcx], 0
-;; 3fac:	 aa                   	stosb	byte ptr [rdi], al
-;; 3fad:	 800100               	add	byte ptr [rcx], 0
-;; 3fb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3fb9:	 800100               	add	byte ptr [rcx], 0
-;; 3fbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 3fbd:	 800100               	add	byte ptr [rcx], 0
-;; 3fc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3fc9:	 800100               	add	byte ptr [rcx], 0
-;; 3fcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 3fcd:	 800100               	add	byte ptr [rcx], 0
-;; 3fd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3fd9:	 800100               	add	byte ptr [rcx], 0
-;; 3fdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 3fdd:	 800100               	add	byte ptr [rcx], 0
-;; 3fe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3fe9:	 800100               	add	byte ptr [rcx], 0
-;; 3fec:	 aa                   	stosb	byte ptr [rdi], al
-;; 3fed:	 800100               	add	byte ptr [rcx], 0
-;; 3ff0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 3ff9:	 800100               	add	byte ptr [rcx], 0
-;; 3ffc:	 aa                   	stosb	byte ptr [rdi], al
-;; 3ffd:	 800100               	add	byte ptr [rcx], 0
-;; 4000:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4009:	 800100               	add	byte ptr [rcx], 0
-;; 400c:	 aa                   	stosb	byte ptr [rdi], al
-;; 400d:	 800100               	add	byte ptr [rcx], 0
-;; 4010:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4019:	 800100               	add	byte ptr [rcx], 0
-;; 401c:	 aa                   	stosb	byte ptr [rdi], al
-;; 401d:	 800100               	add	byte ptr [rcx], 0
-;; 4020:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4029:	 800100               	add	byte ptr [rcx], 0
-;; 402c:	 aa                   	stosb	byte ptr [rdi], al
-;; 402d:	 800100               	add	byte ptr [rcx], 0
-;; 4030:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4039:	 800100               	add	byte ptr [rcx], 0
-;; 403c:	 aa                   	stosb	byte ptr [rdi], al
-;; 403d:	 800100               	add	byte ptr [rcx], 0
-;; 4040:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4049:	 800100               	add	byte ptr [rcx], 0
-;; 404c:	 aa                   	stosb	byte ptr [rdi], al
-;; 404d:	 800100               	add	byte ptr [rcx], 0
-;; 4050:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4059:	 800100               	add	byte ptr [rcx], 0
-;; 405c:	 aa                   	stosb	byte ptr [rdi], al
-;; 405d:	 800100               	add	byte ptr [rcx], 0
-;; 4060:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4069:	 800100               	add	byte ptr [rcx], 0
-;; 406c:	 aa                   	stosb	byte ptr [rdi], al
-;; 406d:	 800100               	add	byte ptr [rcx], 0
-;; 4070:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4079:	 800100               	add	byte ptr [rcx], 0
-;; 407c:	 aa                   	stosb	byte ptr [rdi], al
-;; 407d:	 800100               	add	byte ptr [rcx], 0
-;; 4080:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4089:	 800100               	add	byte ptr [rcx], 0
-;; 408c:	 aa                   	stosb	byte ptr [rdi], al
-;; 408d:	 800100               	add	byte ptr [rcx], 0
-;; 4090:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4099:	 800100               	add	byte ptr [rcx], 0
-;; 409c:	 aa                   	stosb	byte ptr [rdi], al
-;; 409d:	 800100               	add	byte ptr [rcx], 0
-;; 40a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 40a9:	 800100               	add	byte ptr [rcx], 0
-;; 40ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 40ad:	 800100               	add	byte ptr [rcx], 0
-;; 40b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 40b9:	 800100               	add	byte ptr [rcx], 0
-;; 40bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 40bd:	 800100               	add	byte ptr [rcx], 0
-;; 40c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 40c9:	 800100               	add	byte ptr [rcx], 0
-;; 40cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 40cd:	 800100               	add	byte ptr [rcx], 0
-;; 40d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 40d9:	 800100               	add	byte ptr [rcx], 0
-;; 40dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 40dd:	 800100               	add	byte ptr [rcx], 0
-;; 40e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 40e9:	 800100               	add	byte ptr [rcx], 0
-;; 40ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 40ed:	 800100               	add	byte ptr [rcx], 0
-;; 40f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 40f9:	 800100               	add	byte ptr [rcx], 0
-;; 40fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 40fd:	 800100               	add	byte ptr [rcx], 0
-;; 4100:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4109:	 800100               	add	byte ptr [rcx], 0
-;; 410c:	 aa                   	stosb	byte ptr [rdi], al
-;; 410d:	 800100               	add	byte ptr [rcx], 0
-;; 4110:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4119:	 800100               	add	byte ptr [rcx], 0
-;; 411c:	 aa                   	stosb	byte ptr [rdi], al
-;; 411d:	 800100               	add	byte ptr [rcx], 0
-;; 4120:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4129:	 800100               	add	byte ptr [rcx], 0
-;; 412c:	 aa                   	stosb	byte ptr [rdi], al
-;; 412d:	 800100               	add	byte ptr [rcx], 0
-;; 4130:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4139:	 800100               	add	byte ptr [rcx], 0
-;; 413c:	 aa                   	stosb	byte ptr [rdi], al
-;; 413d:	 800100               	add	byte ptr [rcx], 0
-;; 4140:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4149:	 800100               	add	byte ptr [rcx], 0
-;; 414c:	 aa                   	stosb	byte ptr [rdi], al
-;; 414d:	 800100               	add	byte ptr [rcx], 0
-;; 4150:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4159:	 800100               	add	byte ptr [rcx], 0
-;; 415c:	 aa                   	stosb	byte ptr [rdi], al
-;; 415d:	 800100               	add	byte ptr [rcx], 0
-;; 4160:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4169:	 800100               	add	byte ptr [rcx], 0
-;; 416c:	 aa                   	stosb	byte ptr [rdi], al
-;; 416d:	 800100               	add	byte ptr [rcx], 0
-;; 4170:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4179:	 800100               	add	byte ptr [rcx], 0
-;; 417c:	 aa                   	stosb	byte ptr [rdi], al
-;; 417d:	 800100               	add	byte ptr [rcx], 0
-;; 4180:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4189:	 800100               	add	byte ptr [rcx], 0
-;; 418c:	 aa                   	stosb	byte ptr [rdi], al
-;; 418d:	 800100               	add	byte ptr [rcx], 0
-;; 4190:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4199:	 800100               	add	byte ptr [rcx], 0
-;; 419c:	 aa                   	stosb	byte ptr [rdi], al
-;; 419d:	 800100               	add	byte ptr [rcx], 0
-;; 41a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 41a9:	 800100               	add	byte ptr [rcx], 0
-;; 41ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 41ad:	 800100               	add	byte ptr [rcx], 0
-;; 41b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 41b9:	 800100               	add	byte ptr [rcx], 0
-;; 41bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 41bd:	 800100               	add	byte ptr [rcx], 0
-;; 41c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 41c9:	 800100               	add	byte ptr [rcx], 0
-;; 41cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 41cd:	 800100               	add	byte ptr [rcx], 0
-;; 41d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 41d9:	 800100               	add	byte ptr [rcx], 0
-;; 41dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 41dd:	 800100               	add	byte ptr [rcx], 0
-;; 41e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 41e9:	 800100               	add	byte ptr [rcx], 0
-;; 41ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 41ed:	 800100               	add	byte ptr [rcx], 0
-;; 41f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 41f9:	 800100               	add	byte ptr [rcx], 0
-;; 41fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 41fd:	 800100               	add	byte ptr [rcx], 0
-;; 4200:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4209:	 800100               	add	byte ptr [rcx], 0
-;; 420c:	 aa                   	stosb	byte ptr [rdi], al
-;; 420d:	 800100               	add	byte ptr [rcx], 0
-;; 4210:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4219:	 800100               	add	byte ptr [rcx], 0
-;; 421c:	 aa                   	stosb	byte ptr [rdi], al
-;; 421d:	 800100               	add	byte ptr [rcx], 0
-;; 4220:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4229:	 800100               	add	byte ptr [rcx], 0
-;; 422c:	 aa                   	stosb	byte ptr [rdi], al
-;; 422d:	 800100               	add	byte ptr [rcx], 0
-;; 4230:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4239:	 800100               	add	byte ptr [rcx], 0
-;; 423c:	 aa                   	stosb	byte ptr [rdi], al
-;; 423d:	 800100               	add	byte ptr [rcx], 0
-;; 4240:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4249:	 800100               	add	byte ptr [rcx], 0
-;; 424c:	 aa                   	stosb	byte ptr [rdi], al
-;; 424d:	 800100               	add	byte ptr [rcx], 0
-;; 4250:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4259:	 800100               	add	byte ptr [rcx], 0
-;; 425c:	 aa                   	stosb	byte ptr [rdi], al
-;; 425d:	 800100               	add	byte ptr [rcx], 0
-;; 4260:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4269:	 800100               	add	byte ptr [rcx], 0
-;; 426c:	 aa                   	stosb	byte ptr [rdi], al
-;; 426d:	 800100               	add	byte ptr [rcx], 0
-;; 4270:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4279:	 800100               	add	byte ptr [rcx], 0
-;; 427c:	 aa                   	stosb	byte ptr [rdi], al
-;; 427d:	 800100               	add	byte ptr [rcx], 0
-;; 4280:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4289:	 800100               	add	byte ptr [rcx], 0
-;; 428c:	 aa                   	stosb	byte ptr [rdi], al
-;; 428d:	 800100               	add	byte ptr [rcx], 0
-;; 4290:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4299:	 800100               	add	byte ptr [rcx], 0
-;; 429c:	 aa                   	stosb	byte ptr [rdi], al
-;; 429d:	 800100               	add	byte ptr [rcx], 0
-;; 42a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 42a9:	 800100               	add	byte ptr [rcx], 0
-;; 42ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 42ad:	 800100               	add	byte ptr [rcx], 0
-;; 42b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 42b9:	 800100               	add	byte ptr [rcx], 0
-;; 42bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 42bd:	 800100               	add	byte ptr [rcx], 0
-;; 42c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 42c9:	 800100               	add	byte ptr [rcx], 0
-;; 42cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 42cd:	 800100               	add	byte ptr [rcx], 0
-;; 42d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 42d9:	 800100               	add	byte ptr [rcx], 0
-;; 42dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 42dd:	 800100               	add	byte ptr [rcx], 0
-;; 42e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 42e9:	 800100               	add	byte ptr [rcx], 0
-;; 42ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 42ed:	 800100               	add	byte ptr [rcx], 0
-;; 42f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 42f9:	 800100               	add	byte ptr [rcx], 0
-;; 42fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 42fd:	 800100               	add	byte ptr [rcx], 0
-;; 4300:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4309:	 800100               	add	byte ptr [rcx], 0
-;; 430c:	 aa                   	stosb	byte ptr [rdi], al
-;; 430d:	 800100               	add	byte ptr [rcx], 0
-;; 4310:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4319:	 800100               	add	byte ptr [rcx], 0
-;; 431c:	 aa                   	stosb	byte ptr [rdi], al
-;; 431d:	 800100               	add	byte ptr [rcx], 0
-;; 4320:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4329:	 800100               	add	byte ptr [rcx], 0
-;; 432c:	 aa                   	stosb	byte ptr [rdi], al
-;; 432d:	 800100               	add	byte ptr [rcx], 0
-;; 4330:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4339:	 800100               	add	byte ptr [rcx], 0
-;; 433c:	 aa                   	stosb	byte ptr [rdi], al
-;; 433d:	 800100               	add	byte ptr [rcx], 0
-;; 4340:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4349:	 800100               	add	byte ptr [rcx], 0
-;; 434c:	 aa                   	stosb	byte ptr [rdi], al
-;; 434d:	 800100               	add	byte ptr [rcx], 0
-;; 4350:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4359:	 800100               	add	byte ptr [rcx], 0
-;; 435c:	 aa                   	stosb	byte ptr [rdi], al
-;; 435d:	 800100               	add	byte ptr [rcx], 0
-;; 4360:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4369:	 800100               	add	byte ptr [rcx], 0
-;; 436c:	 aa                   	stosb	byte ptr [rdi], al
-;; 436d:	 800100               	add	byte ptr [rcx], 0
-;; 4370:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4379:	 800100               	add	byte ptr [rcx], 0
-;; 437c:	 aa                   	stosb	byte ptr [rdi], al
-;; 437d:	 800100               	add	byte ptr [rcx], 0
-;; 4380:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4389:	 800100               	add	byte ptr [rcx], 0
-;; 438c:	 aa                   	stosb	byte ptr [rdi], al
-;; 438d:	 800100               	add	byte ptr [rcx], 0
-;; 4390:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4399:	 800100               	add	byte ptr [rcx], 0
-;; 439c:	 aa                   	stosb	byte ptr [rdi], al
-;; 439d:	 800100               	add	byte ptr [rcx], 0
-;; 43a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 43a9:	 800100               	add	byte ptr [rcx], 0
-;; 43ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 43ad:	 800100               	add	byte ptr [rcx], 0
-;; 43b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 43b9:	 800100               	add	byte ptr [rcx], 0
-;; 43bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 43bd:	 800100               	add	byte ptr [rcx], 0
-;; 43c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 43c9:	 800100               	add	byte ptr [rcx], 0
-;; 43cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 43cd:	 800100               	add	byte ptr [rcx], 0
-;; 43d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 43d9:	 800100               	add	byte ptr [rcx], 0
-;; 43dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 43dd:	 800100               	add	byte ptr [rcx], 0
-;; 43e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 43e9:	 800100               	add	byte ptr [rcx], 0
-;; 43ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 43ed:	 800100               	add	byte ptr [rcx], 0
-;; 43f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 43f9:	 800100               	add	byte ptr [rcx], 0
-;; 43fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 43fd:	 800100               	add	byte ptr [rcx], 0
-;; 4400:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4409:	 800100               	add	byte ptr [rcx], 0
-;; 440c:	 aa                   	stosb	byte ptr [rdi], al
-;; 440d:	 800100               	add	byte ptr [rcx], 0
-;; 4410:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4419:	 800100               	add	byte ptr [rcx], 0
-;; 441c:	 aa                   	stosb	byte ptr [rdi], al
-;; 441d:	 800100               	add	byte ptr [rcx], 0
-;; 4420:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4429:	 800100               	add	byte ptr [rcx], 0
-;; 442c:	 aa                   	stosb	byte ptr [rdi], al
-;; 442d:	 800100               	add	byte ptr [rcx], 0
-;; 4430:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4439:	 800100               	add	byte ptr [rcx], 0
-;; 443c:	 aa                   	stosb	byte ptr [rdi], al
-;; 443d:	 800100               	add	byte ptr [rcx], 0
-;; 4440:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4449:	 800100               	add	byte ptr [rcx], 0
-;; 444c:	 aa                   	stosb	byte ptr [rdi], al
-;; 444d:	 800100               	add	byte ptr [rcx], 0
-;; 4450:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4459:	 800100               	add	byte ptr [rcx], 0
-;; 445c:	 aa                   	stosb	byte ptr [rdi], al
-;; 445d:	 800100               	add	byte ptr [rcx], 0
-;; 4460:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4469:	 800100               	add	byte ptr [rcx], 0
-;; 446c:	 aa                   	stosb	byte ptr [rdi], al
-;; 446d:	 800100               	add	byte ptr [rcx], 0
-;; 4470:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4479:	 800100               	add	byte ptr [rcx], 0
-;; 447c:	 aa                   	stosb	byte ptr [rdi], al
-;; 447d:	 800100               	add	byte ptr [rcx], 0
-;; 4480:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4489:	 800100               	add	byte ptr [rcx], 0
-;; 448c:	 aa                   	stosb	byte ptr [rdi], al
-;; 448d:	 800100               	add	byte ptr [rcx], 0
-;; 4490:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4499:	 800100               	add	byte ptr [rcx], 0
-;; 449c:	 aa                   	stosb	byte ptr [rdi], al
-;; 449d:	 800100               	add	byte ptr [rcx], 0
-;; 44a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 44a9:	 800100               	add	byte ptr [rcx], 0
-;; 44ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 44ad:	 800100               	add	byte ptr [rcx], 0
-;; 44b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 44b9:	 800100               	add	byte ptr [rcx], 0
-;; 44bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 44bd:	 800100               	add	byte ptr [rcx], 0
-;; 44c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 44c9:	 800100               	add	byte ptr [rcx], 0
-;; 44cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 44cd:	 800100               	add	byte ptr [rcx], 0
-;; 44d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 44d9:	 800100               	add	byte ptr [rcx], 0
-;; 44dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 44dd:	 800100               	add	byte ptr [rcx], 0
-;; 44e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 44e9:	 800100               	add	byte ptr [rcx], 0
-;; 44ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 44ed:	 800100               	add	byte ptr [rcx], 0
-;; 44f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 44f9:	 800100               	add	byte ptr [rcx], 0
-;; 44fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 44fd:	 800100               	add	byte ptr [rcx], 0
-;; 4500:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4509:	 800100               	add	byte ptr [rcx], 0
-;; 450c:	 aa                   	stosb	byte ptr [rdi], al
-;; 450d:	 800100               	add	byte ptr [rcx], 0
-;; 4510:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4519:	 800100               	add	byte ptr [rcx], 0
-;; 451c:	 aa                   	stosb	byte ptr [rdi], al
-;; 451d:	 800100               	add	byte ptr [rcx], 0
-;; 4520:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4529:	 800100               	add	byte ptr [rcx], 0
-;; 452c:	 aa                   	stosb	byte ptr [rdi], al
-;; 452d:	 800100               	add	byte ptr [rcx], 0
-;; 4530:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4539:	 800100               	add	byte ptr [rcx], 0
-;; 453c:	 aa                   	stosb	byte ptr [rdi], al
-;; 453d:	 800100               	add	byte ptr [rcx], 0
-;; 4540:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4549:	 800100               	add	byte ptr [rcx], 0
-;; 454c:	 aa                   	stosb	byte ptr [rdi], al
-;; 454d:	 800100               	add	byte ptr [rcx], 0
-;; 4550:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4559:	 800100               	add	byte ptr [rcx], 0
-;; 455c:	 aa                   	stosb	byte ptr [rdi], al
-;; 455d:	 800100               	add	byte ptr [rcx], 0
-;; 4560:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4569:	 800100               	add	byte ptr [rcx], 0
-;; 456c:	 aa                   	stosb	byte ptr [rdi], al
-;; 456d:	 800100               	add	byte ptr [rcx], 0
-;; 4570:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4579:	 800100               	add	byte ptr [rcx], 0
-;; 457c:	 aa                   	stosb	byte ptr [rdi], al
-;; 457d:	 800100               	add	byte ptr [rcx], 0
-;; 4580:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4589:	 800100               	add	byte ptr [rcx], 0
-;; 458c:	 aa                   	stosb	byte ptr [rdi], al
-;; 458d:	 800100               	add	byte ptr [rcx], 0
-;; 4590:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4599:	 800100               	add	byte ptr [rcx], 0
-;; 459c:	 aa                   	stosb	byte ptr [rdi], al
-;; 459d:	 800100               	add	byte ptr [rcx], 0
-;; 45a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 45a9:	 800100               	add	byte ptr [rcx], 0
-;; 45ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 45ad:	 800100               	add	byte ptr [rcx], 0
-;; 45b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 45b9:	 800100               	add	byte ptr [rcx], 0
-;; 45bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 45bd:	 800100               	add	byte ptr [rcx], 0
-;; 45c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 45c9:	 800100               	add	byte ptr [rcx], 0
-;; 45cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 45cd:	 800100               	add	byte ptr [rcx], 0
-;; 45d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 45d9:	 800100               	add	byte ptr [rcx], 0
-;; 45dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 45dd:	 800100               	add	byte ptr [rcx], 0
-;; 45e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 45e9:	 800100               	add	byte ptr [rcx], 0
-;; 45ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 45ed:	 800100               	add	byte ptr [rcx], 0
-;; 45f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 45f9:	 800100               	add	byte ptr [rcx], 0
-;; 45fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 45fd:	 800100               	add	byte ptr [rcx], 0
-;; 4600:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4609:	 800100               	add	byte ptr [rcx], 0
-;; 460c:	 aa                   	stosb	byte ptr [rdi], al
-;; 460d:	 800100               	add	byte ptr [rcx], 0
-;; 4610:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4619:	 800100               	add	byte ptr [rcx], 0
-;; 461c:	 aa                   	stosb	byte ptr [rdi], al
-;; 461d:	 800100               	add	byte ptr [rcx], 0
-;; 4620:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4629:	 800100               	add	byte ptr [rcx], 0
-;; 462c:	 aa                   	stosb	byte ptr [rdi], al
-;; 462d:	 800100               	add	byte ptr [rcx], 0
-;; 4630:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4639:	 800100               	add	byte ptr [rcx], 0
-;; 463c:	 aa                   	stosb	byte ptr [rdi], al
-;; 463d:	 800100               	add	byte ptr [rcx], 0
-;; 4640:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4649:	 800100               	add	byte ptr [rcx], 0
-;; 464c:	 aa                   	stosb	byte ptr [rdi], al
-;; 464d:	 800100               	add	byte ptr [rcx], 0
-;; 4650:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4659:	 800100               	add	byte ptr [rcx], 0
-;; 465c:	 aa                   	stosb	byte ptr [rdi], al
-;; 465d:	 800100               	add	byte ptr [rcx], 0
-;; 4660:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4669:	 800100               	add	byte ptr [rcx], 0
-;; 466c:	 aa                   	stosb	byte ptr [rdi], al
-;; 466d:	 800100               	add	byte ptr [rcx], 0
-;; 4670:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4679:	 800100               	add	byte ptr [rcx], 0
-;; 467c:	 aa                   	stosb	byte ptr [rdi], al
-;; 467d:	 800100               	add	byte ptr [rcx], 0
-;; 4680:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4689:	 800100               	add	byte ptr [rcx], 0
-;; 468c:	 aa                   	stosb	byte ptr [rdi], al
-;; 468d:	 800100               	add	byte ptr [rcx], 0
-;; 4690:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4699:	 800100               	add	byte ptr [rcx], 0
-;; 469c:	 aa                   	stosb	byte ptr [rdi], al
-;; 469d:	 800100               	add	byte ptr [rcx], 0
-;; 46a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 46a9:	 800100               	add	byte ptr [rcx], 0
-;; 46ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 46ad:	 800100               	add	byte ptr [rcx], 0
-;; 46b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 46b9:	 800100               	add	byte ptr [rcx], 0
-;; 46bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 46bd:	 800100               	add	byte ptr [rcx], 0
-;; 46c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 46c9:	 800100               	add	byte ptr [rcx], 0
-;; 46cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 46cd:	 800100               	add	byte ptr [rcx], 0
-;; 46d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 46d9:	 800100               	add	byte ptr [rcx], 0
-;; 46dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 46dd:	 800100               	add	byte ptr [rcx], 0
-;; 46e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 46e9:	 800100               	add	byte ptr [rcx], 0
-;; 46ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 46ed:	 800100               	add	byte ptr [rcx], 0
-;; 46f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 46f9:	 800100               	add	byte ptr [rcx], 0
-;; 46fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 46fd:	 800100               	add	byte ptr [rcx], 0
-;; 4700:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4709:	 800100               	add	byte ptr [rcx], 0
-;; 470c:	 aa                   	stosb	byte ptr [rdi], al
-;; 470d:	 800100               	add	byte ptr [rcx], 0
-;; 4710:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4719:	 800100               	add	byte ptr [rcx], 0
-;; 471c:	 aa                   	stosb	byte ptr [rdi], al
-;; 471d:	 800100               	add	byte ptr [rcx], 0
-;; 4720:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4729:	 800100               	add	byte ptr [rcx], 0
-;; 472c:	 aa                   	stosb	byte ptr [rdi], al
-;; 472d:	 800100               	add	byte ptr [rcx], 0
-;; 4730:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4739:	 800100               	add	byte ptr [rcx], 0
-;; 473c:	 aa                   	stosb	byte ptr [rdi], al
-;; 473d:	 800100               	add	byte ptr [rcx], 0
-;; 4740:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4749:	 800100               	add	byte ptr [rcx], 0
-;; 474c:	 aa                   	stosb	byte ptr [rdi], al
-;; 474d:	 800100               	add	byte ptr [rcx], 0
-;; 4750:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4759:	 800100               	add	byte ptr [rcx], 0
-;; 475c:	 aa                   	stosb	byte ptr [rdi], al
-;; 475d:	 800100               	add	byte ptr [rcx], 0
-;; 4760:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4769:	 800100               	add	byte ptr [rcx], 0
-;; 476c:	 aa                   	stosb	byte ptr [rdi], al
-;; 476d:	 800100               	add	byte ptr [rcx], 0
-;; 4770:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4779:	 800100               	add	byte ptr [rcx], 0
-;; 477c:	 aa                   	stosb	byte ptr [rdi], al
-;; 477d:	 800100               	add	byte ptr [rcx], 0
-;; 4780:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4789:	 800100               	add	byte ptr [rcx], 0
-;; 478c:	 aa                   	stosb	byte ptr [rdi], al
-;; 478d:	 800100               	add	byte ptr [rcx], 0
-;; 4790:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4799:	 800100               	add	byte ptr [rcx], 0
-;; 479c:	 aa                   	stosb	byte ptr [rdi], al
-;; 479d:	 800100               	add	byte ptr [rcx], 0
-;; 47a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 47a9:	 800100               	add	byte ptr [rcx], 0
-;; 47ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 47ad:	 800100               	add	byte ptr [rcx], 0
-;; 47b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 47b9:	 800100               	add	byte ptr [rcx], 0
-;; 47bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 47bd:	 800100               	add	byte ptr [rcx], 0
-;; 47c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 47c9:	 800100               	add	byte ptr [rcx], 0
-;; 47cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 47cd:	 800100               	add	byte ptr [rcx], 0
-;; 47d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 47d9:	 800100               	add	byte ptr [rcx], 0
-;; 47dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 47dd:	 800100               	add	byte ptr [rcx], 0
-;; 47e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 47e9:	 800100               	add	byte ptr [rcx], 0
-;; 47ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 47ed:	 800100               	add	byte ptr [rcx], 0
-;; 47f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 47f9:	 800100               	add	byte ptr [rcx], 0
-;; 47fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 47fd:	 800100               	add	byte ptr [rcx], 0
-;; 4800:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4809:	 800100               	add	byte ptr [rcx], 0
-;; 480c:	 aa                   	stosb	byte ptr [rdi], al
-;; 480d:	 800100               	add	byte ptr [rcx], 0
-;; 4810:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4819:	 800100               	add	byte ptr [rcx], 0
-;; 481c:	 aa                   	stosb	byte ptr [rdi], al
-;; 481d:	 800100               	add	byte ptr [rcx], 0
-;; 4820:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4829:	 800100               	add	byte ptr [rcx], 0
-;; 482c:	 aa                   	stosb	byte ptr [rdi], al
-;; 482d:	 800100               	add	byte ptr [rcx], 0
-;; 4830:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4839:	 800100               	add	byte ptr [rcx], 0
-;; 483c:	 aa                   	stosb	byte ptr [rdi], al
-;; 483d:	 800100               	add	byte ptr [rcx], 0
-;; 4840:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4849:	 800100               	add	byte ptr [rcx], 0
-;; 484c:	 aa                   	stosb	byte ptr [rdi], al
-;; 484d:	 800100               	add	byte ptr [rcx], 0
-;; 4850:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4859:	 800100               	add	byte ptr [rcx], 0
-;; 485c:	 aa                   	stosb	byte ptr [rdi], al
-;; 485d:	 800100               	add	byte ptr [rcx], 0
-;; 4860:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4869:	 800100               	add	byte ptr [rcx], 0
-;; 486c:	 aa                   	stosb	byte ptr [rdi], al
-;; 486d:	 800100               	add	byte ptr [rcx], 0
-;; 4870:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4879:	 800100               	add	byte ptr [rcx], 0
-;; 487c:	 aa                   	stosb	byte ptr [rdi], al
-;; 487d:	 800100               	add	byte ptr [rcx], 0
-;; 4880:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4889:	 800100               	add	byte ptr [rcx], 0
-;; 488c:	 aa                   	stosb	byte ptr [rdi], al
-;; 488d:	 800100               	add	byte ptr [rcx], 0
-;; 4890:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4899:	 800100               	add	byte ptr [rcx], 0
-;; 489c:	 aa                   	stosb	byte ptr [rdi], al
-;; 489d:	 800100               	add	byte ptr [rcx], 0
-;; 48a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 48a9:	 800100               	add	byte ptr [rcx], 0
-;; 48ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 48ad:	 800100               	add	byte ptr [rcx], 0
-;; 48b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 48b9:	 800100               	add	byte ptr [rcx], 0
-;; 48bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 48bd:	 800100               	add	byte ptr [rcx], 0
-;; 48c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 48c9:	 800100               	add	byte ptr [rcx], 0
-;; 48cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 48cd:	 800100               	add	byte ptr [rcx], 0
-;; 48d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 48d9:	 800100               	add	byte ptr [rcx], 0
-;; 48dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 48dd:	 800100               	add	byte ptr [rcx], 0
-;; 48e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 48e9:	 800100               	add	byte ptr [rcx], 0
-;; 48ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 48ed:	 800100               	add	byte ptr [rcx], 0
-;; 48f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 48f9:	 800100               	add	byte ptr [rcx], 0
-;; 48fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 48fd:	 800100               	add	byte ptr [rcx], 0
-;; 4900:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4909:	 800100               	add	byte ptr [rcx], 0
-;; 490c:	 aa                   	stosb	byte ptr [rdi], al
-;; 490d:	 800100               	add	byte ptr [rcx], 0
-;; 4910:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4919:	 800100               	add	byte ptr [rcx], 0
-;; 491c:	 aa                   	stosb	byte ptr [rdi], al
-;; 491d:	 800100               	add	byte ptr [rcx], 0
-;; 4920:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4929:	 800100               	add	byte ptr [rcx], 0
-;; 492c:	 aa                   	stosb	byte ptr [rdi], al
-;; 492d:	 800100               	add	byte ptr [rcx], 0
-;; 4930:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4939:	 800100               	add	byte ptr [rcx], 0
-;; 493c:	 aa                   	stosb	byte ptr [rdi], al
-;; 493d:	 800100               	add	byte ptr [rcx], 0
-;; 4940:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4949:	 800100               	add	byte ptr [rcx], 0
-;; 494c:	 aa                   	stosb	byte ptr [rdi], al
-;; 494d:	 800100               	add	byte ptr [rcx], 0
-;; 4950:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4959:	 800100               	add	byte ptr [rcx], 0
-;; 495c:	 aa                   	stosb	byte ptr [rdi], al
-;; 495d:	 800100               	add	byte ptr [rcx], 0
-;; 4960:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4969:	 800100               	add	byte ptr [rcx], 0
-;; 496c:	 aa                   	stosb	byte ptr [rdi], al
-;; 496d:	 800100               	add	byte ptr [rcx], 0
-;; 4970:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4979:	 800100               	add	byte ptr [rcx], 0
-;; 497c:	 aa                   	stosb	byte ptr [rdi], al
-;; 497d:	 800100               	add	byte ptr [rcx], 0
-;; 4980:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4989:	 800100               	add	byte ptr [rcx], 0
-;; 498c:	 aa                   	stosb	byte ptr [rdi], al
-;; 498d:	 800100               	add	byte ptr [rcx], 0
-;; 4990:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4999:	 800100               	add	byte ptr [rcx], 0
-;; 499c:	 aa                   	stosb	byte ptr [rdi], al
-;; 499d:	 800100               	add	byte ptr [rcx], 0
-;; 49a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 49a9:	 800100               	add	byte ptr [rcx], 0
-;; 49ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 49ad:	 800100               	add	byte ptr [rcx], 0
-;; 49b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 49b9:	 800100               	add	byte ptr [rcx], 0
-;; 49bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 49bd:	 800100               	add	byte ptr [rcx], 0
-;; 49c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 49c9:	 800100               	add	byte ptr [rcx], 0
-;; 49cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 49cd:	 800100               	add	byte ptr [rcx], 0
-;; 49d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 49d9:	 800100               	add	byte ptr [rcx], 0
-;; 49dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 49dd:	 800100               	add	byte ptr [rcx], 0
-;; 49e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 49e9:	 800100               	add	byte ptr [rcx], 0
-;; 49ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 49ed:	 800100               	add	byte ptr [rcx], 0
-;; 49f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 49f9:	 800100               	add	byte ptr [rcx], 0
-;; 49fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 49fd:	 800100               	add	byte ptr [rcx], 0
-;; 4a00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4a09:	 800100               	add	byte ptr [rcx], 0
-;; 4a0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4a0d:	 800100               	add	byte ptr [rcx], 0
-;; 4a10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4a19:	 800100               	add	byte ptr [rcx], 0
-;; 4a1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4a1d:	 800100               	add	byte ptr [rcx], 0
-;; 4a20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4a29:	 800100               	add	byte ptr [rcx], 0
-;; 4a2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4a2d:	 800100               	add	byte ptr [rcx], 0
-;; 4a30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4a39:	 800100               	add	byte ptr [rcx], 0
-;; 4a3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4a3d:	 800100               	add	byte ptr [rcx], 0
-;; 4a40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4a49:	 800100               	add	byte ptr [rcx], 0
-;; 4a4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4a4d:	 800100               	add	byte ptr [rcx], 0
-;; 4a50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4a59:	 800100               	add	byte ptr [rcx], 0
-;; 4a5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4a5d:	 800100               	add	byte ptr [rcx], 0
-;; 4a60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4a69:	 800100               	add	byte ptr [rcx], 0
-;; 4a6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4a6d:	 800100               	add	byte ptr [rcx], 0
-;; 4a70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4a79:	 800100               	add	byte ptr [rcx], 0
-;; 4a7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4a7d:	 800100               	add	byte ptr [rcx], 0
-;; 4a80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4a89:	 800100               	add	byte ptr [rcx], 0
-;; 4a8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4a8d:	 800100               	add	byte ptr [rcx], 0
-;; 4a90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4a99:	 800100               	add	byte ptr [rcx], 0
-;; 4a9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4a9d:	 800100               	add	byte ptr [rcx], 0
-;; 4aa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4aa9:	 800100               	add	byte ptr [rcx], 0
-;; 4aac:	 aa                   	stosb	byte ptr [rdi], al
-;; 4aad:	 800100               	add	byte ptr [rcx], 0
-;; 4ab0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4ab9:	 800100               	add	byte ptr [rcx], 0
-;; 4abc:	 aa                   	stosb	byte ptr [rdi], al
-;; 4abd:	 800100               	add	byte ptr [rcx], 0
-;; 4ac0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4ac9:	 800100               	add	byte ptr [rcx], 0
-;; 4acc:	 aa                   	stosb	byte ptr [rdi], al
-;; 4acd:	 800100               	add	byte ptr [rcx], 0
-;; 4ad0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4ad9:	 800100               	add	byte ptr [rcx], 0
-;; 4adc:	 aa                   	stosb	byte ptr [rdi], al
-;; 4add:	 800100               	add	byte ptr [rcx], 0
-;; 4ae0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4ae9:	 800100               	add	byte ptr [rcx], 0
-;; 4aec:	 aa                   	stosb	byte ptr [rdi], al
-;; 4aed:	 800100               	add	byte ptr [rcx], 0
-;; 4af0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4af9:	 800100               	add	byte ptr [rcx], 0
-;; 4afc:	 aa                   	stosb	byte ptr [rdi], al
-;; 4afd:	 800100               	add	byte ptr [rcx], 0
-;; 4b00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4b09:	 800100               	add	byte ptr [rcx], 0
-;; 4b0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4b0d:	 800100               	add	byte ptr [rcx], 0
-;; 4b10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4b19:	 800100               	add	byte ptr [rcx], 0
-;; 4b1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4b1d:	 800100               	add	byte ptr [rcx], 0
-;; 4b20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4b29:	 800100               	add	byte ptr [rcx], 0
-;; 4b2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4b2d:	 800100               	add	byte ptr [rcx], 0
-;; 4b30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4b39:	 800100               	add	byte ptr [rcx], 0
-;; 4b3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4b3d:	 800100               	add	byte ptr [rcx], 0
-;; 4b40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4b49:	 800100               	add	byte ptr [rcx], 0
-;; 4b4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4b4d:	 800100               	add	byte ptr [rcx], 0
-;; 4b50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4b59:	 800100               	add	byte ptr [rcx], 0
-;; 4b5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4b5d:	 800100               	add	byte ptr [rcx], 0
-;; 4b60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4b69:	 800100               	add	byte ptr [rcx], 0
-;; 4b6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4b6d:	 800100               	add	byte ptr [rcx], 0
-;; 4b70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4b79:	 800100               	add	byte ptr [rcx], 0
-;; 4b7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4b7d:	 800100               	add	byte ptr [rcx], 0
-;; 4b80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4b89:	 800100               	add	byte ptr [rcx], 0
-;; 4b8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4b8d:	 800100               	add	byte ptr [rcx], 0
-;; 4b90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4b99:	 800100               	add	byte ptr [rcx], 0
-;; 4b9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4b9d:	 800100               	add	byte ptr [rcx], 0
-;; 4ba0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4ba9:	 800100               	add	byte ptr [rcx], 0
-;; 4bac:	 aa                   	stosb	byte ptr [rdi], al
-;; 4bad:	 800100               	add	byte ptr [rcx], 0
-;; 4bb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4bb9:	 800100               	add	byte ptr [rcx], 0
-;; 4bbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 4bbd:	 800100               	add	byte ptr [rcx], 0
-;; 4bc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4bc9:	 800100               	add	byte ptr [rcx], 0
-;; 4bcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 4bcd:	 800100               	add	byte ptr [rcx], 0
-;; 4bd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4bd9:	 800100               	add	byte ptr [rcx], 0
-;; 4bdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 4bdd:	 800100               	add	byte ptr [rcx], 0
-;; 4be0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4be9:	 800100               	add	byte ptr [rcx], 0
-;; 4bec:	 aa                   	stosb	byte ptr [rdi], al
-;; 4bed:	 800100               	add	byte ptr [rcx], 0
-;; 4bf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4bf9:	 800100               	add	byte ptr [rcx], 0
-;; 4bfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 4bfd:	 800100               	add	byte ptr [rcx], 0
-;; 4c00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4c09:	 800100               	add	byte ptr [rcx], 0
-;; 4c0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4c0d:	 800100               	add	byte ptr [rcx], 0
-;; 4c10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4c19:	 800100               	add	byte ptr [rcx], 0
-;; 4c1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4c1d:	 800100               	add	byte ptr [rcx], 0
-;; 4c20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4c29:	 800100               	add	byte ptr [rcx], 0
-;; 4c2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4c2d:	 800100               	add	byte ptr [rcx], 0
-;; 4c30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4c39:	 800100               	add	byte ptr [rcx], 0
-;; 4c3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4c3d:	 800100               	add	byte ptr [rcx], 0
-;; 4c40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4c49:	 800100               	add	byte ptr [rcx], 0
-;; 4c4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4c4d:	 800100               	add	byte ptr [rcx], 0
-;; 4c50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4c59:	 800100               	add	byte ptr [rcx], 0
-;; 4c5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4c5d:	 800100               	add	byte ptr [rcx], 0
-;; 4c60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4c69:	 800100               	add	byte ptr [rcx], 0
-;; 4c6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4c6d:	 800100               	add	byte ptr [rcx], 0
-;; 4c70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4c79:	 800100               	add	byte ptr [rcx], 0
-;; 4c7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4c7d:	 800100               	add	byte ptr [rcx], 0
-;; 4c80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4c89:	 800100               	add	byte ptr [rcx], 0
-;; 4c8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4c8d:	 800100               	add	byte ptr [rcx], 0
-;; 4c90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4c99:	 800100               	add	byte ptr [rcx], 0
-;; 4c9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4c9d:	 800100               	add	byte ptr [rcx], 0
-;; 4ca0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4ca9:	 800100               	add	byte ptr [rcx], 0
-;; 4cac:	 aa                   	stosb	byte ptr [rdi], al
-;; 4cad:	 800100               	add	byte ptr [rcx], 0
-;; 4cb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4cb9:	 800100               	add	byte ptr [rcx], 0
-;; 4cbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 4cbd:	 800100               	add	byte ptr [rcx], 0
-;; 4cc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4cc9:	 800100               	add	byte ptr [rcx], 0
-;; 4ccc:	 aa                   	stosb	byte ptr [rdi], al
-;; 4ccd:	 800100               	add	byte ptr [rcx], 0
-;; 4cd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4cd9:	 800100               	add	byte ptr [rcx], 0
-;; 4cdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 4cdd:	 800100               	add	byte ptr [rcx], 0
-;; 4ce0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4ce9:	 800100               	add	byte ptr [rcx], 0
-;; 4cec:	 aa                   	stosb	byte ptr [rdi], al
-;; 4ced:	 800100               	add	byte ptr [rcx], 0
-;; 4cf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4cf9:	 800100               	add	byte ptr [rcx], 0
-;; 4cfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 4cfd:	 800100               	add	byte ptr [rcx], 0
-;; 4d00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4d09:	 800100               	add	byte ptr [rcx], 0
-;; 4d0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4d0d:	 800100               	add	byte ptr [rcx], 0
-;; 4d10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4d19:	 800100               	add	byte ptr [rcx], 0
-;; 4d1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4d1d:	 800100               	add	byte ptr [rcx], 0
-;; 4d20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4d29:	 800100               	add	byte ptr [rcx], 0
-;; 4d2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4d2d:	 800100               	add	byte ptr [rcx], 0
-;; 4d30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4d39:	 800100               	add	byte ptr [rcx], 0
-;; 4d3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4d3d:	 800100               	add	byte ptr [rcx], 0
-;; 4d40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4d49:	 800100               	add	byte ptr [rcx], 0
-;; 4d4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4d4d:	 800100               	add	byte ptr [rcx], 0
-;; 4d50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4d59:	 800100               	add	byte ptr [rcx], 0
-;; 4d5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4d5d:	 800100               	add	byte ptr [rcx], 0
-;; 4d60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4d69:	 800100               	add	byte ptr [rcx], 0
-;; 4d6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4d6d:	 800100               	add	byte ptr [rcx], 0
-;; 4d70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4d79:	 800100               	add	byte ptr [rcx], 0
-;; 4d7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4d7d:	 800100               	add	byte ptr [rcx], 0
-;; 4d80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4d89:	 800100               	add	byte ptr [rcx], 0
-;; 4d8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4d8d:	 800100               	add	byte ptr [rcx], 0
-;; 4d90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4d99:	 800100               	add	byte ptr [rcx], 0
-;; 4d9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4d9d:	 800100               	add	byte ptr [rcx], 0
-;; 4da0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4da9:	 800100               	add	byte ptr [rcx], 0
-;; 4dac:	 aa                   	stosb	byte ptr [rdi], al
-;; 4dad:	 800100               	add	byte ptr [rcx], 0
-;; 4db0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4db9:	 800100               	add	byte ptr [rcx], 0
-;; 4dbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 4dbd:	 800100               	add	byte ptr [rcx], 0
-;; 4dc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4dc9:	 800100               	add	byte ptr [rcx], 0
-;; 4dcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 4dcd:	 800100               	add	byte ptr [rcx], 0
-;; 4dd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4dd9:	 800100               	add	byte ptr [rcx], 0
-;; 4ddc:	 aa                   	stosb	byte ptr [rdi], al
-;; 4ddd:	 800100               	add	byte ptr [rcx], 0
-;; 4de0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4de9:	 800100               	add	byte ptr [rcx], 0
-;; 4dec:	 aa                   	stosb	byte ptr [rdi], al
-;; 4ded:	 800100               	add	byte ptr [rcx], 0
-;; 4df0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4df9:	 800100               	add	byte ptr [rcx], 0
-;; 4dfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 4dfd:	 800100               	add	byte ptr [rcx], 0
-;; 4e00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4e09:	 800100               	add	byte ptr [rcx], 0
-;; 4e0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4e0d:	 800100               	add	byte ptr [rcx], 0
-;; 4e10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4e19:	 800100               	add	byte ptr [rcx], 0
-;; 4e1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4e1d:	 800100               	add	byte ptr [rcx], 0
-;; 4e20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4e29:	 800100               	add	byte ptr [rcx], 0
-;; 4e2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4e2d:	 800100               	add	byte ptr [rcx], 0
-;; 4e30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4e39:	 800100               	add	byte ptr [rcx], 0
-;; 4e3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4e3d:	 800100               	add	byte ptr [rcx], 0
-;; 4e40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4e49:	 800100               	add	byte ptr [rcx], 0
-;; 4e4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4e4d:	 800100               	add	byte ptr [rcx], 0
-;; 4e50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4e59:	 800100               	add	byte ptr [rcx], 0
-;; 4e5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4e5d:	 800100               	add	byte ptr [rcx], 0
-;; 4e60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4e69:	 800100               	add	byte ptr [rcx], 0
-;; 4e6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4e6d:	 800100               	add	byte ptr [rcx], 0
-;; 4e70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4e79:	 800100               	add	byte ptr [rcx], 0
-;; 4e7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4e7d:	 800100               	add	byte ptr [rcx], 0
-;; 4e80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4e89:	 800100               	add	byte ptr [rcx], 0
-;; 4e8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4e8d:	 800100               	add	byte ptr [rcx], 0
-;; 4e90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4e99:	 800100               	add	byte ptr [rcx], 0
-;; 4e9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4e9d:	 800100               	add	byte ptr [rcx], 0
-;; 4ea0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4ea9:	 800100               	add	byte ptr [rcx], 0
-;; 4eac:	 aa                   	stosb	byte ptr [rdi], al
-;; 4ead:	 800100               	add	byte ptr [rcx], 0
-;; 4eb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4eb9:	 800100               	add	byte ptr [rcx], 0
-;; 4ebc:	 aa                   	stosb	byte ptr [rdi], al
-;; 4ebd:	 800100               	add	byte ptr [rcx], 0
-;; 4ec0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4ec9:	 800100               	add	byte ptr [rcx], 0
-;; 4ecc:	 aa                   	stosb	byte ptr [rdi], al
-;; 4ecd:	 800100               	add	byte ptr [rcx], 0
-;; 4ed0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4ed9:	 800100               	add	byte ptr [rcx], 0
-;; 4edc:	 aa                   	stosb	byte ptr [rdi], al
-;; 4edd:	 800100               	add	byte ptr [rcx], 0
-;; 4ee0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4ee9:	 800100               	add	byte ptr [rcx], 0
-;; 4eec:	 aa                   	stosb	byte ptr [rdi], al
-;; 4eed:	 800100               	add	byte ptr [rcx], 0
-;; 4ef0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4ef9:	 800100               	add	byte ptr [rcx], 0
-;; 4efc:	 aa                   	stosb	byte ptr [rdi], al
-;; 4efd:	 800100               	add	byte ptr [rcx], 0
-;; 4f00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4f09:	 800100               	add	byte ptr [rcx], 0
-;; 4f0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4f0d:	 800100               	add	byte ptr [rcx], 0
-;; 4f10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4f19:	 800100               	add	byte ptr [rcx], 0
-;; 4f1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4f1d:	 800100               	add	byte ptr [rcx], 0
-;; 4f20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4f29:	 800100               	add	byte ptr [rcx], 0
-;; 4f2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4f2d:	 800100               	add	byte ptr [rcx], 0
-;; 4f30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4f39:	 800100               	add	byte ptr [rcx], 0
-;; 4f3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4f3d:	 800100               	add	byte ptr [rcx], 0
-;; 4f40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4f49:	 800100               	add	byte ptr [rcx], 0
-;; 4f4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4f4d:	 800100               	add	byte ptr [rcx], 0
-;; 4f50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4f59:	 800100               	add	byte ptr [rcx], 0
-;; 4f5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4f5d:	 800100               	add	byte ptr [rcx], 0
-;; 4f60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4f69:	 800100               	add	byte ptr [rcx], 0
-;; 4f6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4f6d:	 800100               	add	byte ptr [rcx], 0
-;; 4f70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4f79:	 800100               	add	byte ptr [rcx], 0
-;; 4f7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4f7d:	 800100               	add	byte ptr [rcx], 0
-;; 4f80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4f89:	 800100               	add	byte ptr [rcx], 0
-;; 4f8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4f8d:	 800100               	add	byte ptr [rcx], 0
-;; 4f90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4f99:	 800100               	add	byte ptr [rcx], 0
-;; 4f9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 4f9d:	 800100               	add	byte ptr [rcx], 0
-;; 4fa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4fa9:	 800100               	add	byte ptr [rcx], 0
-;; 4fac:	 aa                   	stosb	byte ptr [rdi], al
-;; 4fad:	 800100               	add	byte ptr [rcx], 0
-;; 4fb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4fb9:	 800100               	add	byte ptr [rcx], 0
-;; 4fbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 4fbd:	 800100               	add	byte ptr [rcx], 0
-;; 4fc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4fc9:	 800100               	add	byte ptr [rcx], 0
-;; 4fcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 4fcd:	 800100               	add	byte ptr [rcx], 0
-;; 4fd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4fd9:	 800100               	add	byte ptr [rcx], 0
-;; 4fdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 4fdd:	 800100               	add	byte ptr [rcx], 0
-;; 4fe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4fe9:	 800100               	add	byte ptr [rcx], 0
-;; 4fec:	 aa                   	stosb	byte ptr [rdi], al
-;; 4fed:	 800100               	add	byte ptr [rcx], 0
-;; 4ff0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 4ff9:	 800100               	add	byte ptr [rcx], 0
-;; 4ffc:	 aa                   	stosb	byte ptr [rdi], al
-;; 4ffd:	 800100               	add	byte ptr [rcx], 0
-;; 5000:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5009:	 800100               	add	byte ptr [rcx], 0
-;; 500c:	 aa                   	stosb	byte ptr [rdi], al
-;; 500d:	 800100               	add	byte ptr [rcx], 0
-;; 5010:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5019:	 800100               	add	byte ptr [rcx], 0
-;; 501c:	 aa                   	stosb	byte ptr [rdi], al
-;; 501d:	 800100               	add	byte ptr [rcx], 0
-;; 5020:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5029:	 800100               	add	byte ptr [rcx], 0
-;; 502c:	 aa                   	stosb	byte ptr [rdi], al
-;; 502d:	 800100               	add	byte ptr [rcx], 0
-;; 5030:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5039:	 800100               	add	byte ptr [rcx], 0
-;; 503c:	 aa                   	stosb	byte ptr [rdi], al
-;; 503d:	 800100               	add	byte ptr [rcx], 0
-;; 5040:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5049:	 800100               	add	byte ptr [rcx], 0
-;; 504c:	 aa                   	stosb	byte ptr [rdi], al
-;; 504d:	 800100               	add	byte ptr [rcx], 0
-;; 5050:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5059:	 800100               	add	byte ptr [rcx], 0
-;; 505c:	 aa                   	stosb	byte ptr [rdi], al
-;; 505d:	 800100               	add	byte ptr [rcx], 0
-;; 5060:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5069:	 800100               	add	byte ptr [rcx], 0
-;; 506c:	 aa                   	stosb	byte ptr [rdi], al
-;; 506d:	 800100               	add	byte ptr [rcx], 0
-;; 5070:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5079:	 800100               	add	byte ptr [rcx], 0
-;; 507c:	 aa                   	stosb	byte ptr [rdi], al
-;; 507d:	 800100               	add	byte ptr [rcx], 0
-;; 5080:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5089:	 800100               	add	byte ptr [rcx], 0
-;; 508c:	 aa                   	stosb	byte ptr [rdi], al
-;; 508d:	 800100               	add	byte ptr [rcx], 0
-;; 5090:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5099:	 800100               	add	byte ptr [rcx], 0
-;; 509c:	 aa                   	stosb	byte ptr [rdi], al
-;; 509d:	 800100               	add	byte ptr [rcx], 0
-;; 50a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 50a9:	 800100               	add	byte ptr [rcx], 0
-;; 50ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 50ad:	 800100               	add	byte ptr [rcx], 0
-;; 50b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 50b9:	 800100               	add	byte ptr [rcx], 0
-;; 50bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 50bd:	 800100               	add	byte ptr [rcx], 0
-;; 50c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 50c9:	 800100               	add	byte ptr [rcx], 0
-;; 50cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 50cd:	 800100               	add	byte ptr [rcx], 0
-;; 50d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 50d9:	 800100               	add	byte ptr [rcx], 0
-;; 50dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 50dd:	 800100               	add	byte ptr [rcx], 0
-;; 50e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 50e9:	 800100               	add	byte ptr [rcx], 0
-;; 50ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 50ed:	 800100               	add	byte ptr [rcx], 0
-;; 50f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 50f9:	 800100               	add	byte ptr [rcx], 0
-;; 50fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 50fd:	 800100               	add	byte ptr [rcx], 0
-;; 5100:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5109:	 800100               	add	byte ptr [rcx], 0
-;; 510c:	 aa                   	stosb	byte ptr [rdi], al
-;; 510d:	 800100               	add	byte ptr [rcx], 0
-;; 5110:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5119:	 800100               	add	byte ptr [rcx], 0
-;; 511c:	 aa                   	stosb	byte ptr [rdi], al
-;; 511d:	 800100               	add	byte ptr [rcx], 0
-;; 5120:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5129:	 800100               	add	byte ptr [rcx], 0
-;; 512c:	 aa                   	stosb	byte ptr [rdi], al
-;; 512d:	 800100               	add	byte ptr [rcx], 0
-;; 5130:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5139:	 800100               	add	byte ptr [rcx], 0
-;; 513c:	 aa                   	stosb	byte ptr [rdi], al
-;; 513d:	 800100               	add	byte ptr [rcx], 0
-;; 5140:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5149:	 800100               	add	byte ptr [rcx], 0
-;; 514c:	 aa                   	stosb	byte ptr [rdi], al
-;; 514d:	 800100               	add	byte ptr [rcx], 0
-;; 5150:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5159:	 800100               	add	byte ptr [rcx], 0
-;; 515c:	 aa                   	stosb	byte ptr [rdi], al
-;; 515d:	 800100               	add	byte ptr [rcx], 0
-;; 5160:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5169:	 800100               	add	byte ptr [rcx], 0
-;; 516c:	 aa                   	stosb	byte ptr [rdi], al
-;; 516d:	 800100               	add	byte ptr [rcx], 0
-;; 5170:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5179:	 800100               	add	byte ptr [rcx], 0
-;; 517c:	 aa                   	stosb	byte ptr [rdi], al
-;; 517d:	 800100               	add	byte ptr [rcx], 0
-;; 5180:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5189:	 800100               	add	byte ptr [rcx], 0
-;; 518c:	 aa                   	stosb	byte ptr [rdi], al
-;; 518d:	 800100               	add	byte ptr [rcx], 0
-;; 5190:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5199:	 800100               	add	byte ptr [rcx], 0
-;; 519c:	 aa                   	stosb	byte ptr [rdi], al
-;; 519d:	 800100               	add	byte ptr [rcx], 0
-;; 51a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 51a9:	 800100               	add	byte ptr [rcx], 0
-;; 51ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 51ad:	 800100               	add	byte ptr [rcx], 0
-;; 51b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 51b9:	 800100               	add	byte ptr [rcx], 0
-;; 51bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 51bd:	 800100               	add	byte ptr [rcx], 0
-;; 51c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 51c9:	 800100               	add	byte ptr [rcx], 0
-;; 51cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 51cd:	 800100               	add	byte ptr [rcx], 0
-;; 51d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 51d9:	 800100               	add	byte ptr [rcx], 0
-;; 51dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 51dd:	 800100               	add	byte ptr [rcx], 0
-;; 51e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 51e9:	 800100               	add	byte ptr [rcx], 0
-;; 51ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 51ed:	 800100               	add	byte ptr [rcx], 0
-;; 51f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 51f9:	 800100               	add	byte ptr [rcx], 0
-;; 51fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 51fd:	 800100               	add	byte ptr [rcx], 0
-;; 5200:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5209:	 800100               	add	byte ptr [rcx], 0
-;; 520c:	 aa                   	stosb	byte ptr [rdi], al
-;; 520d:	 800100               	add	byte ptr [rcx], 0
-;; 5210:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5219:	 800100               	add	byte ptr [rcx], 0
-;; 521c:	 aa                   	stosb	byte ptr [rdi], al
-;; 521d:	 800100               	add	byte ptr [rcx], 0
-;; 5220:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5229:	 800100               	add	byte ptr [rcx], 0
-;; 522c:	 aa                   	stosb	byte ptr [rdi], al
-;; 522d:	 800100               	add	byte ptr [rcx], 0
-;; 5230:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5239:	 800100               	add	byte ptr [rcx], 0
-;; 523c:	 aa                   	stosb	byte ptr [rdi], al
-;; 523d:	 800100               	add	byte ptr [rcx], 0
-;; 5240:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5249:	 800100               	add	byte ptr [rcx], 0
-;; 524c:	 aa                   	stosb	byte ptr [rdi], al
-;; 524d:	 800100               	add	byte ptr [rcx], 0
-;; 5250:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5259:	 800100               	add	byte ptr [rcx], 0
-;; 525c:	 aa                   	stosb	byte ptr [rdi], al
-;; 525d:	 800100               	add	byte ptr [rcx], 0
-;; 5260:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5269:	 800100               	add	byte ptr [rcx], 0
-;; 526c:	 aa                   	stosb	byte ptr [rdi], al
-;; 526d:	 800100               	add	byte ptr [rcx], 0
-;; 5270:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5279:	 800100               	add	byte ptr [rcx], 0
-;; 527c:	 aa                   	stosb	byte ptr [rdi], al
-;; 527d:	 800100               	add	byte ptr [rcx], 0
-;; 5280:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5289:	 800100               	add	byte ptr [rcx], 0
-;; 528c:	 aa                   	stosb	byte ptr [rdi], al
-;; 528d:	 800100               	add	byte ptr [rcx], 0
-;; 5290:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5299:	 800100               	add	byte ptr [rcx], 0
-;; 529c:	 aa                   	stosb	byte ptr [rdi], al
-;; 529d:	 800100               	add	byte ptr [rcx], 0
-;; 52a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 52a9:	 800100               	add	byte ptr [rcx], 0
-;; 52ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 52ad:	 800100               	add	byte ptr [rcx], 0
-;; 52b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 52b9:	 800100               	add	byte ptr [rcx], 0
-;; 52bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 52bd:	 800100               	add	byte ptr [rcx], 0
-;; 52c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 52c9:	 800100               	add	byte ptr [rcx], 0
-;; 52cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 52cd:	 800100               	add	byte ptr [rcx], 0
-;; 52d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 52d9:	 800100               	add	byte ptr [rcx], 0
-;; 52dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 52dd:	 800100               	add	byte ptr [rcx], 0
-;; 52e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 52e9:	 800100               	add	byte ptr [rcx], 0
-;; 52ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 52ed:	 800100               	add	byte ptr [rcx], 0
-;; 52f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 52f9:	 800100               	add	byte ptr [rcx], 0
-;; 52fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 52fd:	 800100               	add	byte ptr [rcx], 0
-;; 5300:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5309:	 800100               	add	byte ptr [rcx], 0
-;; 530c:	 aa                   	stosb	byte ptr [rdi], al
-;; 530d:	 800100               	add	byte ptr [rcx], 0
-;; 5310:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5319:	 800100               	add	byte ptr [rcx], 0
-;; 531c:	 aa                   	stosb	byte ptr [rdi], al
-;; 531d:	 800100               	add	byte ptr [rcx], 0
-;; 5320:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5329:	 800100               	add	byte ptr [rcx], 0
-;; 532c:	 aa                   	stosb	byte ptr [rdi], al
-;; 532d:	 800100               	add	byte ptr [rcx], 0
-;; 5330:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5339:	 800100               	add	byte ptr [rcx], 0
-;; 533c:	 aa                   	stosb	byte ptr [rdi], al
-;; 533d:	 800100               	add	byte ptr [rcx], 0
-;; 5340:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5349:	 800100               	add	byte ptr [rcx], 0
-;; 534c:	 aa                   	stosb	byte ptr [rdi], al
-;; 534d:	 800100               	add	byte ptr [rcx], 0
-;; 5350:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5359:	 800100               	add	byte ptr [rcx], 0
-;; 535c:	 aa                   	stosb	byte ptr [rdi], al
-;; 535d:	 800100               	add	byte ptr [rcx], 0
-;; 5360:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5369:	 800100               	add	byte ptr [rcx], 0
-;; 536c:	 aa                   	stosb	byte ptr [rdi], al
-;; 536d:	 800100               	add	byte ptr [rcx], 0
-;; 5370:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5379:	 800100               	add	byte ptr [rcx], 0
-;; 537c:	 aa                   	stosb	byte ptr [rdi], al
-;; 537d:	 800100               	add	byte ptr [rcx], 0
-;; 5380:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5389:	 800100               	add	byte ptr [rcx], 0
-;; 538c:	 aa                   	stosb	byte ptr [rdi], al
-;; 538d:	 800100               	add	byte ptr [rcx], 0
-;; 5390:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5399:	 800100               	add	byte ptr [rcx], 0
-;; 539c:	 aa                   	stosb	byte ptr [rdi], al
-;; 539d:	 800100               	add	byte ptr [rcx], 0
-;; 53a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 53a9:	 800100               	add	byte ptr [rcx], 0
-;; 53ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 53ad:	 800100               	add	byte ptr [rcx], 0
-;; 53b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 53b9:	 800100               	add	byte ptr [rcx], 0
-;; 53bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 53bd:	 800100               	add	byte ptr [rcx], 0
-;; 53c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 53c9:	 800100               	add	byte ptr [rcx], 0
-;; 53cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 53cd:	 800100               	add	byte ptr [rcx], 0
-;; 53d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 53d9:	 800100               	add	byte ptr [rcx], 0
-;; 53dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 53dd:	 800100               	add	byte ptr [rcx], 0
-;; 53e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 53e9:	 800100               	add	byte ptr [rcx], 0
-;; 53ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 53ed:	 800100               	add	byte ptr [rcx], 0
-;; 53f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 53f9:	 800100               	add	byte ptr [rcx], 0
-;; 53fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 53fd:	 800100               	add	byte ptr [rcx], 0
-;; 5400:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5409:	 800100               	add	byte ptr [rcx], 0
-;; 540c:	 aa                   	stosb	byte ptr [rdi], al
-;; 540d:	 800100               	add	byte ptr [rcx], 0
-;; 5410:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5419:	 800100               	add	byte ptr [rcx], 0
-;; 541c:	 aa                   	stosb	byte ptr [rdi], al
-;; 541d:	 800100               	add	byte ptr [rcx], 0
-;; 5420:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5429:	 800100               	add	byte ptr [rcx], 0
-;; 542c:	 aa                   	stosb	byte ptr [rdi], al
-;; 542d:	 800100               	add	byte ptr [rcx], 0
-;; 5430:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5439:	 800100               	add	byte ptr [rcx], 0
-;; 543c:	 aa                   	stosb	byte ptr [rdi], al
-;; 543d:	 800100               	add	byte ptr [rcx], 0
-;; 5440:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5449:	 800100               	add	byte ptr [rcx], 0
-;; 544c:	 aa                   	stosb	byte ptr [rdi], al
-;; 544d:	 800100               	add	byte ptr [rcx], 0
-;; 5450:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5459:	 800100               	add	byte ptr [rcx], 0
-;; 545c:	 aa                   	stosb	byte ptr [rdi], al
-;; 545d:	 800100               	add	byte ptr [rcx], 0
-;; 5460:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5469:	 800100               	add	byte ptr [rcx], 0
-;; 546c:	 aa                   	stosb	byte ptr [rdi], al
-;; 546d:	 800100               	add	byte ptr [rcx], 0
-;; 5470:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5479:	 800100               	add	byte ptr [rcx], 0
-;; 547c:	 aa                   	stosb	byte ptr [rdi], al
-;; 547d:	 800100               	add	byte ptr [rcx], 0
-;; 5480:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5489:	 800100               	add	byte ptr [rcx], 0
-;; 548c:	 aa                   	stosb	byte ptr [rdi], al
-;; 548d:	 800100               	add	byte ptr [rcx], 0
-;; 5490:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5499:	 800100               	add	byte ptr [rcx], 0
-;; 549c:	 aa                   	stosb	byte ptr [rdi], al
-;; 549d:	 800100               	add	byte ptr [rcx], 0
-;; 54a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 54a9:	 800100               	add	byte ptr [rcx], 0
-;; 54ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 54ad:	 800100               	add	byte ptr [rcx], 0
-;; 54b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 54b9:	 800100               	add	byte ptr [rcx], 0
-;; 54bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 54bd:	 800100               	add	byte ptr [rcx], 0
-;; 54c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 54c9:	 800100               	add	byte ptr [rcx], 0
-;; 54cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 54cd:	 800100               	add	byte ptr [rcx], 0
-;; 54d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 54d9:	 800100               	add	byte ptr [rcx], 0
-;; 54dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 54dd:	 800100               	add	byte ptr [rcx], 0
-;; 54e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 54e9:	 800100               	add	byte ptr [rcx], 0
-;; 54ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 54ed:	 800100               	add	byte ptr [rcx], 0
-;; 54f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 54f9:	 800100               	add	byte ptr [rcx], 0
-;; 54fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 54fd:	 800100               	add	byte ptr [rcx], 0
-;; 5500:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5509:	 800100               	add	byte ptr [rcx], 0
-;; 550c:	 aa                   	stosb	byte ptr [rdi], al
-;; 550d:	 800100               	add	byte ptr [rcx], 0
-;; 5510:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5519:	 800100               	add	byte ptr [rcx], 0
-;; 551c:	 aa                   	stosb	byte ptr [rdi], al
-;; 551d:	 800100               	add	byte ptr [rcx], 0
-;; 5520:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5529:	 800100               	add	byte ptr [rcx], 0
-;; 552c:	 aa                   	stosb	byte ptr [rdi], al
-;; 552d:	 800100               	add	byte ptr [rcx], 0
-;; 5530:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5539:	 800100               	add	byte ptr [rcx], 0
-;; 553c:	 aa                   	stosb	byte ptr [rdi], al
-;; 553d:	 800100               	add	byte ptr [rcx], 0
-;; 5540:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5549:	 800100               	add	byte ptr [rcx], 0
-;; 554c:	 aa                   	stosb	byte ptr [rdi], al
-;; 554d:	 800100               	add	byte ptr [rcx], 0
-;; 5550:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5559:	 800100               	add	byte ptr [rcx], 0
-;; 555c:	 aa                   	stosb	byte ptr [rdi], al
-;; 555d:	 800100               	add	byte ptr [rcx], 0
-;; 5560:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5569:	 800100               	add	byte ptr [rcx], 0
-;; 556c:	 aa                   	stosb	byte ptr [rdi], al
-;; 556d:	 800100               	add	byte ptr [rcx], 0
-;; 5570:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5579:	 800100               	add	byte ptr [rcx], 0
-;; 557c:	 aa                   	stosb	byte ptr [rdi], al
-;; 557d:	 800100               	add	byte ptr [rcx], 0
-;; 5580:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5589:	 800100               	add	byte ptr [rcx], 0
-;; 558c:	 aa                   	stosb	byte ptr [rdi], al
-;; 558d:	 800100               	add	byte ptr [rcx], 0
-;; 5590:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5599:	 800100               	add	byte ptr [rcx], 0
-;; 559c:	 aa                   	stosb	byte ptr [rdi], al
-;; 559d:	 800100               	add	byte ptr [rcx], 0
-;; 55a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 55a9:	 800100               	add	byte ptr [rcx], 0
-;; 55ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 55ad:	 800100               	add	byte ptr [rcx], 0
-;; 55b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 55b9:	 800100               	add	byte ptr [rcx], 0
-;; 55bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 55bd:	 800100               	add	byte ptr [rcx], 0
-;; 55c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 55c9:	 800100               	add	byte ptr [rcx], 0
-;; 55cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 55cd:	 800100               	add	byte ptr [rcx], 0
-;; 55d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 55d9:	 800100               	add	byte ptr [rcx], 0
-;; 55dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 55dd:	 800100               	add	byte ptr [rcx], 0
-;; 55e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 55e9:	 800100               	add	byte ptr [rcx], 0
-;; 55ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 55ed:	 800100               	add	byte ptr [rcx], 0
-;; 55f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 55f9:	 800100               	add	byte ptr [rcx], 0
-;; 55fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 55fd:	 800100               	add	byte ptr [rcx], 0
-;; 5600:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5609:	 800100               	add	byte ptr [rcx], 0
-;; 560c:	 aa                   	stosb	byte ptr [rdi], al
-;; 560d:	 800100               	add	byte ptr [rcx], 0
-;; 5610:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5619:	 800100               	add	byte ptr [rcx], 0
-;; 561c:	 aa                   	stosb	byte ptr [rdi], al
-;; 561d:	 800100               	add	byte ptr [rcx], 0
-;; 5620:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5629:	 800100               	add	byte ptr [rcx], 0
-;; 562c:	 aa                   	stosb	byte ptr [rdi], al
-;; 562d:	 800100               	add	byte ptr [rcx], 0
-;; 5630:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5639:	 800100               	add	byte ptr [rcx], 0
-;; 563c:	 aa                   	stosb	byte ptr [rdi], al
-;; 563d:	 800100               	add	byte ptr [rcx], 0
-;; 5640:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5649:	 800100               	add	byte ptr [rcx], 0
-;; 564c:	 aa                   	stosb	byte ptr [rdi], al
-;; 564d:	 800100               	add	byte ptr [rcx], 0
-;; 5650:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5659:	 800100               	add	byte ptr [rcx], 0
-;; 565c:	 aa                   	stosb	byte ptr [rdi], al
-;; 565d:	 800100               	add	byte ptr [rcx], 0
-;; 5660:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5669:	 800100               	add	byte ptr [rcx], 0
-;; 566c:	 aa                   	stosb	byte ptr [rdi], al
-;; 566d:	 800100               	add	byte ptr [rcx], 0
-;; 5670:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5679:	 800100               	add	byte ptr [rcx], 0
-;; 567c:	 aa                   	stosb	byte ptr [rdi], al
-;; 567d:	 800100               	add	byte ptr [rcx], 0
-;; 5680:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5689:	 800100               	add	byte ptr [rcx], 0
-;; 568c:	 aa                   	stosb	byte ptr [rdi], al
-;; 568d:	 800100               	add	byte ptr [rcx], 0
-;; 5690:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5699:	 800100               	add	byte ptr [rcx], 0
-;; 569c:	 aa                   	stosb	byte ptr [rdi], al
-;; 569d:	 800100               	add	byte ptr [rcx], 0
-;; 56a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 56a9:	 800100               	add	byte ptr [rcx], 0
-;; 56ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 56ad:	 800100               	add	byte ptr [rcx], 0
-;; 56b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 56b9:	 800100               	add	byte ptr [rcx], 0
-;; 56bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 56bd:	 800100               	add	byte ptr [rcx], 0
-;; 56c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 56c9:	 800100               	add	byte ptr [rcx], 0
-;; 56cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 56cd:	 800100               	add	byte ptr [rcx], 0
-;; 56d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 56d9:	 800100               	add	byte ptr [rcx], 0
-;; 56dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 56dd:	 800100               	add	byte ptr [rcx], 0
-;; 56e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 56e9:	 800100               	add	byte ptr [rcx], 0
-;; 56ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 56ed:	 800100               	add	byte ptr [rcx], 0
-;; 56f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 56f9:	 800100               	add	byte ptr [rcx], 0
-;; 56fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 56fd:	 800100               	add	byte ptr [rcx], 0
-;; 5700:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5709:	 800100               	add	byte ptr [rcx], 0
-;; 570c:	 aa                   	stosb	byte ptr [rdi], al
-;; 570d:	 800100               	add	byte ptr [rcx], 0
-;; 5710:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5719:	 800100               	add	byte ptr [rcx], 0
-;; 571c:	 aa                   	stosb	byte ptr [rdi], al
-;; 571d:	 800100               	add	byte ptr [rcx], 0
-;; 5720:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5729:	 800100               	add	byte ptr [rcx], 0
-;; 572c:	 aa                   	stosb	byte ptr [rdi], al
-;; 572d:	 800100               	add	byte ptr [rcx], 0
-;; 5730:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5739:	 800100               	add	byte ptr [rcx], 0
-;; 573c:	 aa                   	stosb	byte ptr [rdi], al
-;; 573d:	 800100               	add	byte ptr [rcx], 0
-;; 5740:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5749:	 800100               	add	byte ptr [rcx], 0
-;; 574c:	 aa                   	stosb	byte ptr [rdi], al
-;; 574d:	 800100               	add	byte ptr [rcx], 0
-;; 5750:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5759:	 800100               	add	byte ptr [rcx], 0
-;; 575c:	 aa                   	stosb	byte ptr [rdi], al
-;; 575d:	 800100               	add	byte ptr [rcx], 0
-;; 5760:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5769:	 800100               	add	byte ptr [rcx], 0
-;; 576c:	 aa                   	stosb	byte ptr [rdi], al
-;; 576d:	 800100               	add	byte ptr [rcx], 0
-;; 5770:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5779:	 800100               	add	byte ptr [rcx], 0
-;; 577c:	 aa                   	stosb	byte ptr [rdi], al
-;; 577d:	 800100               	add	byte ptr [rcx], 0
-;; 5780:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5789:	 800100               	add	byte ptr [rcx], 0
-;; 578c:	 aa                   	stosb	byte ptr [rdi], al
-;; 578d:	 800100               	add	byte ptr [rcx], 0
-;; 5790:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5799:	 800100               	add	byte ptr [rcx], 0
-;; 579c:	 aa                   	stosb	byte ptr [rdi], al
-;; 579d:	 800100               	add	byte ptr [rcx], 0
-;; 57a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 57a9:	 800100               	add	byte ptr [rcx], 0
-;; 57ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 57ad:	 800100               	add	byte ptr [rcx], 0
-;; 57b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 57b9:	 800100               	add	byte ptr [rcx], 0
-;; 57bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 57bd:	 800100               	add	byte ptr [rcx], 0
-;; 57c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 57c9:	 800100               	add	byte ptr [rcx], 0
-;; 57cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 57cd:	 800100               	add	byte ptr [rcx], 0
-;; 57d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 57d9:	 800100               	add	byte ptr [rcx], 0
-;; 57dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 57dd:	 800100               	add	byte ptr [rcx], 0
-;; 57e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 57e9:	 800100               	add	byte ptr [rcx], 0
-;; 57ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 57ed:	 800100               	add	byte ptr [rcx], 0
-;; 57f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 57f9:	 800100               	add	byte ptr [rcx], 0
-;; 57fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 57fd:	 800100               	add	byte ptr [rcx], 0
-;; 5800:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5809:	 800100               	add	byte ptr [rcx], 0
-;; 580c:	 aa                   	stosb	byte ptr [rdi], al
-;; 580d:	 800100               	add	byte ptr [rcx], 0
-;; 5810:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5819:	 800100               	add	byte ptr [rcx], 0
-;; 581c:	 aa                   	stosb	byte ptr [rdi], al
-;; 581d:	 800100               	add	byte ptr [rcx], 0
-;; 5820:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5829:	 800100               	add	byte ptr [rcx], 0
-;; 582c:	 aa                   	stosb	byte ptr [rdi], al
-;; 582d:	 800100               	add	byte ptr [rcx], 0
-;; 5830:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5839:	 800100               	add	byte ptr [rcx], 0
-;; 583c:	 aa                   	stosb	byte ptr [rdi], al
-;; 583d:	 800100               	add	byte ptr [rcx], 0
-;; 5840:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5849:	 800100               	add	byte ptr [rcx], 0
-;; 584c:	 aa                   	stosb	byte ptr [rdi], al
-;; 584d:	 800100               	add	byte ptr [rcx], 0
-;; 5850:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5859:	 800100               	add	byte ptr [rcx], 0
-;; 585c:	 aa                   	stosb	byte ptr [rdi], al
-;; 585d:	 800100               	add	byte ptr [rcx], 0
-;; 5860:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5869:	 800100               	add	byte ptr [rcx], 0
-;; 586c:	 aa                   	stosb	byte ptr [rdi], al
-;; 586d:	 800100               	add	byte ptr [rcx], 0
-;; 5870:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5879:	 800100               	add	byte ptr [rcx], 0
-;; 587c:	 aa                   	stosb	byte ptr [rdi], al
-;; 587d:	 800100               	add	byte ptr [rcx], 0
-;; 5880:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5889:	 800100               	add	byte ptr [rcx], 0
-;; 588c:	 aa                   	stosb	byte ptr [rdi], al
-;; 588d:	 800100               	add	byte ptr [rcx], 0
-;; 5890:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5899:	 800100               	add	byte ptr [rcx], 0
-;; 589c:	 aa                   	stosb	byte ptr [rdi], al
-;; 589d:	 800100               	add	byte ptr [rcx], 0
-;; 58a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 58a9:	 800100               	add	byte ptr [rcx], 0
-;; 58ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 58ad:	 800100               	add	byte ptr [rcx], 0
-;; 58b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 58b9:	 800100               	add	byte ptr [rcx], 0
-;; 58bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 58bd:	 800100               	add	byte ptr [rcx], 0
-;; 58c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 58c9:	 800100               	add	byte ptr [rcx], 0
-;; 58cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 58cd:	 800100               	add	byte ptr [rcx], 0
-;; 58d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 58d9:	 800100               	add	byte ptr [rcx], 0
-;; 58dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 58dd:	 800100               	add	byte ptr [rcx], 0
-;; 58e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 58e9:	 800100               	add	byte ptr [rcx], 0
-;; 58ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 58ed:	 800100               	add	byte ptr [rcx], 0
-;; 58f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 58f9:	 800100               	add	byte ptr [rcx], 0
-;; 58fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 58fd:	 800100               	add	byte ptr [rcx], 0
-;; 5900:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5909:	 800100               	add	byte ptr [rcx], 0
-;; 590c:	 aa                   	stosb	byte ptr [rdi], al
-;; 590d:	 800100               	add	byte ptr [rcx], 0
-;; 5910:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5919:	 800100               	add	byte ptr [rcx], 0
-;; 591c:	 aa                   	stosb	byte ptr [rdi], al
-;; 591d:	 800100               	add	byte ptr [rcx], 0
-;; 5920:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5929:	 800100               	add	byte ptr [rcx], 0
-;; 592c:	 aa                   	stosb	byte ptr [rdi], al
-;; 592d:	 800100               	add	byte ptr [rcx], 0
-;; 5930:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5939:	 800100               	add	byte ptr [rcx], 0
-;; 593c:	 aa                   	stosb	byte ptr [rdi], al
-;; 593d:	 800100               	add	byte ptr [rcx], 0
-;; 5940:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5949:	 800100               	add	byte ptr [rcx], 0
-;; 594c:	 aa                   	stosb	byte ptr [rdi], al
-;; 594d:	 800100               	add	byte ptr [rcx], 0
-;; 5950:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5959:	 800100               	add	byte ptr [rcx], 0
-;; 595c:	 aa                   	stosb	byte ptr [rdi], al
-;; 595d:	 800100               	add	byte ptr [rcx], 0
-;; 5960:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5969:	 800100               	add	byte ptr [rcx], 0
-;; 596c:	 aa                   	stosb	byte ptr [rdi], al
-;; 596d:	 800100               	add	byte ptr [rcx], 0
-;; 5970:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5979:	 800100               	add	byte ptr [rcx], 0
-;; 597c:	 aa                   	stosb	byte ptr [rdi], al
-;; 597d:	 800100               	add	byte ptr [rcx], 0
-;; 5980:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5989:	 800100               	add	byte ptr [rcx], 0
-;; 598c:	 aa                   	stosb	byte ptr [rdi], al
-;; 598d:	 800100               	add	byte ptr [rcx], 0
-;; 5990:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5999:	 800100               	add	byte ptr [rcx], 0
-;; 599c:	 aa                   	stosb	byte ptr [rdi], al
-;; 599d:	 800100               	add	byte ptr [rcx], 0
-;; 59a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 59a9:	 800100               	add	byte ptr [rcx], 0
-;; 59ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 59ad:	 800100               	add	byte ptr [rcx], 0
-;; 59b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 59b9:	 800100               	add	byte ptr [rcx], 0
-;; 59bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 59bd:	 800100               	add	byte ptr [rcx], 0
-;; 59c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 59c9:	 800100               	add	byte ptr [rcx], 0
-;; 59cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 59cd:	 800100               	add	byte ptr [rcx], 0
-;; 59d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 59d9:	 800100               	add	byte ptr [rcx], 0
-;; 59dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 59dd:	 800100               	add	byte ptr [rcx], 0
-;; 59e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 59e9:	 800100               	add	byte ptr [rcx], 0
-;; 59ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 59ed:	 800100               	add	byte ptr [rcx], 0
-;; 59f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 59f9:	 800100               	add	byte ptr [rcx], 0
-;; 59fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 59fd:	 800100               	add	byte ptr [rcx], 0
-;; 5a00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5a09:	 800100               	add	byte ptr [rcx], 0
-;; 5a0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5a0d:	 800100               	add	byte ptr [rcx], 0
-;; 5a10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5a19:	 800100               	add	byte ptr [rcx], 0
-;; 5a1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5a1d:	 800100               	add	byte ptr [rcx], 0
-;; 5a20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5a29:	 800100               	add	byte ptr [rcx], 0
-;; 5a2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5a2d:	 800100               	add	byte ptr [rcx], 0
-;; 5a30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5a39:	 800100               	add	byte ptr [rcx], 0
-;; 5a3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5a3d:	 800100               	add	byte ptr [rcx], 0
-;; 5a40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5a49:	 800100               	add	byte ptr [rcx], 0
-;; 5a4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5a4d:	 800100               	add	byte ptr [rcx], 0
-;; 5a50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5a59:	 800100               	add	byte ptr [rcx], 0
-;; 5a5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5a5d:	 800100               	add	byte ptr [rcx], 0
-;; 5a60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5a69:	 800100               	add	byte ptr [rcx], 0
-;; 5a6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5a6d:	 800100               	add	byte ptr [rcx], 0
-;; 5a70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5a79:	 800100               	add	byte ptr [rcx], 0
-;; 5a7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5a7d:	 800100               	add	byte ptr [rcx], 0
-;; 5a80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5a89:	 800100               	add	byte ptr [rcx], 0
-;; 5a8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5a8d:	 800100               	add	byte ptr [rcx], 0
-;; 5a90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5a99:	 800100               	add	byte ptr [rcx], 0
-;; 5a9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5a9d:	 800100               	add	byte ptr [rcx], 0
-;; 5aa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5aa9:	 800100               	add	byte ptr [rcx], 0
-;; 5aac:	 aa                   	stosb	byte ptr [rdi], al
-;; 5aad:	 800100               	add	byte ptr [rcx], 0
-;; 5ab0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5ab9:	 800100               	add	byte ptr [rcx], 0
-;; 5abc:	 aa                   	stosb	byte ptr [rdi], al
-;; 5abd:	 800100               	add	byte ptr [rcx], 0
-;; 5ac0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5ac9:	 800100               	add	byte ptr [rcx], 0
-;; 5acc:	 aa                   	stosb	byte ptr [rdi], al
-;; 5acd:	 800100               	add	byte ptr [rcx], 0
-;; 5ad0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5ad9:	 800100               	add	byte ptr [rcx], 0
-;; 5adc:	 aa                   	stosb	byte ptr [rdi], al
-;; 5add:	 800100               	add	byte ptr [rcx], 0
-;; 5ae0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5ae9:	 800100               	add	byte ptr [rcx], 0
-;; 5aec:	 aa                   	stosb	byte ptr [rdi], al
-;; 5aed:	 800100               	add	byte ptr [rcx], 0
-;; 5af0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5af9:	 800100               	add	byte ptr [rcx], 0
-;; 5afc:	 aa                   	stosb	byte ptr [rdi], al
-;; 5afd:	 800100               	add	byte ptr [rcx], 0
-;; 5b00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5b09:	 800100               	add	byte ptr [rcx], 0
-;; 5b0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5b0d:	 800100               	add	byte ptr [rcx], 0
-;; 5b10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5b19:	 800100               	add	byte ptr [rcx], 0
-;; 5b1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5b1d:	 800100               	add	byte ptr [rcx], 0
-;; 5b20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5b29:	 800100               	add	byte ptr [rcx], 0
-;; 5b2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5b2d:	 800100               	add	byte ptr [rcx], 0
-;; 5b30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5b39:	 800100               	add	byte ptr [rcx], 0
-;; 5b3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5b3d:	 800100               	add	byte ptr [rcx], 0
-;; 5b40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5b49:	 800100               	add	byte ptr [rcx], 0
-;; 5b4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5b4d:	 800100               	add	byte ptr [rcx], 0
-;; 5b50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5b59:	 800100               	add	byte ptr [rcx], 0
-;; 5b5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5b5d:	 800100               	add	byte ptr [rcx], 0
-;; 5b60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5b69:	 800100               	add	byte ptr [rcx], 0
-;; 5b6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5b6d:	 800100               	add	byte ptr [rcx], 0
-;; 5b70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5b79:	 800100               	add	byte ptr [rcx], 0
-;; 5b7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5b7d:	 800100               	add	byte ptr [rcx], 0
-;; 5b80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5b89:	 800100               	add	byte ptr [rcx], 0
-;; 5b8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5b8d:	 800100               	add	byte ptr [rcx], 0
-;; 5b90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5b99:	 800100               	add	byte ptr [rcx], 0
-;; 5b9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5b9d:	 800100               	add	byte ptr [rcx], 0
-;; 5ba0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5ba9:	 800100               	add	byte ptr [rcx], 0
-;; 5bac:	 aa                   	stosb	byte ptr [rdi], al
-;; 5bad:	 800100               	add	byte ptr [rcx], 0
-;; 5bb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5bb9:	 800100               	add	byte ptr [rcx], 0
-;; 5bbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 5bbd:	 800100               	add	byte ptr [rcx], 0
-;; 5bc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5bc9:	 800100               	add	byte ptr [rcx], 0
-;; 5bcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 5bcd:	 800100               	add	byte ptr [rcx], 0
-;; 5bd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5bd9:	 800100               	add	byte ptr [rcx], 0
-;; 5bdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 5bdd:	 800100               	add	byte ptr [rcx], 0
-;; 5be0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5be9:	 800100               	add	byte ptr [rcx], 0
-;; 5bec:	 aa                   	stosb	byte ptr [rdi], al
-;; 5bed:	 800100               	add	byte ptr [rcx], 0
-;; 5bf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5bf9:	 800100               	add	byte ptr [rcx], 0
-;; 5bfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 5bfd:	 800100               	add	byte ptr [rcx], 0
-;; 5c00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5c09:	 800100               	add	byte ptr [rcx], 0
-;; 5c0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5c0d:	 800100               	add	byte ptr [rcx], 0
-;; 5c10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5c19:	 800100               	add	byte ptr [rcx], 0
-;; 5c1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5c1d:	 800100               	add	byte ptr [rcx], 0
-;; 5c20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5c29:	 800100               	add	byte ptr [rcx], 0
-;; 5c2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5c2d:	 800100               	add	byte ptr [rcx], 0
-;; 5c30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5c39:	 800100               	add	byte ptr [rcx], 0
-;; 5c3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5c3d:	 800100               	add	byte ptr [rcx], 0
-;; 5c40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5c49:	 800100               	add	byte ptr [rcx], 0
-;; 5c4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5c4d:	 800100               	add	byte ptr [rcx], 0
-;; 5c50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5c59:	 800100               	add	byte ptr [rcx], 0
-;; 5c5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5c5d:	 800100               	add	byte ptr [rcx], 0
-;; 5c60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5c69:	 800100               	add	byte ptr [rcx], 0
-;; 5c6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5c6d:	 800100               	add	byte ptr [rcx], 0
-;; 5c70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5c79:	 800100               	add	byte ptr [rcx], 0
-;; 5c7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5c7d:	 800100               	add	byte ptr [rcx], 0
-;; 5c80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5c89:	 800100               	add	byte ptr [rcx], 0
-;; 5c8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5c8d:	 800100               	add	byte ptr [rcx], 0
-;; 5c90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5c99:	 800100               	add	byte ptr [rcx], 0
-;; 5c9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5c9d:	 800100               	add	byte ptr [rcx], 0
-;; 5ca0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5ca9:	 800100               	add	byte ptr [rcx], 0
-;; 5cac:	 aa                   	stosb	byte ptr [rdi], al
-;; 5cad:	 800100               	add	byte ptr [rcx], 0
-;; 5cb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5cb9:	 800100               	add	byte ptr [rcx], 0
-;; 5cbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 5cbd:	 800100               	add	byte ptr [rcx], 0
-;; 5cc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5cc9:	 800100               	add	byte ptr [rcx], 0
-;; 5ccc:	 aa                   	stosb	byte ptr [rdi], al
-;; 5ccd:	 800100               	add	byte ptr [rcx], 0
-;; 5cd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5cd9:	 800100               	add	byte ptr [rcx], 0
-;; 5cdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 5cdd:	 800100               	add	byte ptr [rcx], 0
-;; 5ce0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5ce9:	 800100               	add	byte ptr [rcx], 0
-;; 5cec:	 aa                   	stosb	byte ptr [rdi], al
-;; 5ced:	 800100               	add	byte ptr [rcx], 0
-;; 5cf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5cf9:	 800100               	add	byte ptr [rcx], 0
-;; 5cfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 5cfd:	 800100               	add	byte ptr [rcx], 0
-;; 5d00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5d09:	 800100               	add	byte ptr [rcx], 0
-;; 5d0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5d0d:	 800100               	add	byte ptr [rcx], 0
-;; 5d10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5d19:	 800100               	add	byte ptr [rcx], 0
-;; 5d1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5d1d:	 800100               	add	byte ptr [rcx], 0
-;; 5d20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5d29:	 800100               	add	byte ptr [rcx], 0
-;; 5d2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5d2d:	 800100               	add	byte ptr [rcx], 0
-;; 5d30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5d39:	 800100               	add	byte ptr [rcx], 0
-;; 5d3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5d3d:	 800100               	add	byte ptr [rcx], 0
-;; 5d40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5d49:	 800100               	add	byte ptr [rcx], 0
-;; 5d4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5d4d:	 800100               	add	byte ptr [rcx], 0
-;; 5d50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5d59:	 800100               	add	byte ptr [rcx], 0
-;; 5d5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5d5d:	 800100               	add	byte ptr [rcx], 0
-;; 5d60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5d69:	 800100               	add	byte ptr [rcx], 0
-;; 5d6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5d6d:	 800100               	add	byte ptr [rcx], 0
-;; 5d70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5d79:	 800100               	add	byte ptr [rcx], 0
-;; 5d7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5d7d:	 800100               	add	byte ptr [rcx], 0
-;; 5d80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5d89:	 800100               	add	byte ptr [rcx], 0
-;; 5d8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5d8d:	 800100               	add	byte ptr [rcx], 0
-;; 5d90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5d99:	 800100               	add	byte ptr [rcx], 0
-;; 5d9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5d9d:	 800100               	add	byte ptr [rcx], 0
-;; 5da0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5da9:	 800100               	add	byte ptr [rcx], 0
-;; 5dac:	 aa                   	stosb	byte ptr [rdi], al
-;; 5dad:	 800100               	add	byte ptr [rcx], 0
-;; 5db0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5db9:	 800100               	add	byte ptr [rcx], 0
-;; 5dbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 5dbd:	 800100               	add	byte ptr [rcx], 0
-;; 5dc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5dc9:	 800100               	add	byte ptr [rcx], 0
-;; 5dcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 5dcd:	 800100               	add	byte ptr [rcx], 0
-;; 5dd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5dd9:	 800100               	add	byte ptr [rcx], 0
-;; 5ddc:	 aa                   	stosb	byte ptr [rdi], al
-;; 5ddd:	 800100               	add	byte ptr [rcx], 0
-;; 5de0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5de9:	 800100               	add	byte ptr [rcx], 0
-;; 5dec:	 aa                   	stosb	byte ptr [rdi], al
-;; 5ded:	 800100               	add	byte ptr [rcx], 0
-;; 5df0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5df9:	 800100               	add	byte ptr [rcx], 0
-;; 5dfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 5dfd:	 800100               	add	byte ptr [rcx], 0
-;; 5e00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5e09:	 800100               	add	byte ptr [rcx], 0
-;; 5e0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5e0d:	 800100               	add	byte ptr [rcx], 0
-;; 5e10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5e19:	 800100               	add	byte ptr [rcx], 0
-;; 5e1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5e1d:	 800100               	add	byte ptr [rcx], 0
-;; 5e20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5e29:	 800100               	add	byte ptr [rcx], 0
-;; 5e2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5e2d:	 800100               	add	byte ptr [rcx], 0
-;; 5e30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5e39:	 800100               	add	byte ptr [rcx], 0
-;; 5e3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5e3d:	 800100               	add	byte ptr [rcx], 0
-;; 5e40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5e49:	 800100               	add	byte ptr [rcx], 0
-;; 5e4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5e4d:	 800100               	add	byte ptr [rcx], 0
-;; 5e50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5e59:	 800100               	add	byte ptr [rcx], 0
-;; 5e5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5e5d:	 800100               	add	byte ptr [rcx], 0
-;; 5e60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5e69:	 800100               	add	byte ptr [rcx], 0
-;; 5e6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5e6d:	 800100               	add	byte ptr [rcx], 0
-;; 5e70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5e79:	 800100               	add	byte ptr [rcx], 0
-;; 5e7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5e7d:	 800100               	add	byte ptr [rcx], 0
-;; 5e80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5e89:	 800100               	add	byte ptr [rcx], 0
-;; 5e8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5e8d:	 800100               	add	byte ptr [rcx], 0
-;; 5e90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5e99:	 800100               	add	byte ptr [rcx], 0
-;; 5e9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5e9d:	 800100               	add	byte ptr [rcx], 0
-;; 5ea0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5ea9:	 800100               	add	byte ptr [rcx], 0
-;; 5eac:	 aa                   	stosb	byte ptr [rdi], al
-;; 5ead:	 800100               	add	byte ptr [rcx], 0
-;; 5eb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5eb9:	 800100               	add	byte ptr [rcx], 0
-;; 5ebc:	 aa                   	stosb	byte ptr [rdi], al
-;; 5ebd:	 800100               	add	byte ptr [rcx], 0
-;; 5ec0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5ec9:	 800100               	add	byte ptr [rcx], 0
-;; 5ecc:	 aa                   	stosb	byte ptr [rdi], al
-;; 5ecd:	 800100               	add	byte ptr [rcx], 0
-;; 5ed0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5ed9:	 800100               	add	byte ptr [rcx], 0
-;; 5edc:	 aa                   	stosb	byte ptr [rdi], al
-;; 5edd:	 800100               	add	byte ptr [rcx], 0
-;; 5ee0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5ee9:	 800100               	add	byte ptr [rcx], 0
-;; 5eec:	 aa                   	stosb	byte ptr [rdi], al
-;; 5eed:	 800100               	add	byte ptr [rcx], 0
-;; 5ef0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5ef9:	 800100               	add	byte ptr [rcx], 0
-;; 5efc:	 aa                   	stosb	byte ptr [rdi], al
-;; 5efd:	 800100               	add	byte ptr [rcx], 0
-;; 5f00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5f09:	 800100               	add	byte ptr [rcx], 0
-;; 5f0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5f0d:	 800100               	add	byte ptr [rcx], 0
-;; 5f10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5f19:	 800100               	add	byte ptr [rcx], 0
-;; 5f1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5f1d:	 800100               	add	byte ptr [rcx], 0
-;; 5f20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5f29:	 800100               	add	byte ptr [rcx], 0
-;; 5f2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5f2d:	 800100               	add	byte ptr [rcx], 0
-;; 5f30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5f39:	 800100               	add	byte ptr [rcx], 0
-;; 5f3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5f3d:	 800100               	add	byte ptr [rcx], 0
-;; 5f40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5f49:	 800100               	add	byte ptr [rcx], 0
-;; 5f4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5f4d:	 800100               	add	byte ptr [rcx], 0
-;; 5f50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5f59:	 800100               	add	byte ptr [rcx], 0
-;; 5f5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5f5d:	 800100               	add	byte ptr [rcx], 0
-;; 5f60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5f69:	 800100               	add	byte ptr [rcx], 0
-;; 5f6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5f6d:	 800100               	add	byte ptr [rcx], 0
-;; 5f70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5f79:	 800100               	add	byte ptr [rcx], 0
-;; 5f7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5f7d:	 800100               	add	byte ptr [rcx], 0
-;; 5f80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5f89:	 800100               	add	byte ptr [rcx], 0
-;; 5f8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5f8d:	 800100               	add	byte ptr [rcx], 0
-;; 5f90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5f99:	 800100               	add	byte ptr [rcx], 0
-;; 5f9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 5f9d:	 800100               	add	byte ptr [rcx], 0
-;; 5fa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5fa9:	 800100               	add	byte ptr [rcx], 0
-;; 5fac:	 aa                   	stosb	byte ptr [rdi], al
-;; 5fad:	 800100               	add	byte ptr [rcx], 0
-;; 5fb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5fb9:	 800100               	add	byte ptr [rcx], 0
-;; 5fbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 5fbd:	 800100               	add	byte ptr [rcx], 0
-;; 5fc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5fc9:	 800100               	add	byte ptr [rcx], 0
-;; 5fcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 5fcd:	 800100               	add	byte ptr [rcx], 0
-;; 5fd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5fd9:	 800100               	add	byte ptr [rcx], 0
-;; 5fdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 5fdd:	 800100               	add	byte ptr [rcx], 0
-;; 5fe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5fe9:	 800100               	add	byte ptr [rcx], 0
-;; 5fec:	 aa                   	stosb	byte ptr [rdi], al
-;; 5fed:	 800100               	add	byte ptr [rcx], 0
-;; 5ff0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 5ff9:	 800100               	add	byte ptr [rcx], 0
-;; 5ffc:	 aa                   	stosb	byte ptr [rdi], al
-;; 5ffd:	 800100               	add	byte ptr [rcx], 0
-;; 6000:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6009:	 800100               	add	byte ptr [rcx], 0
-;; 600c:	 aa                   	stosb	byte ptr [rdi], al
-;; 600d:	 800100               	add	byte ptr [rcx], 0
-;; 6010:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6019:	 800100               	add	byte ptr [rcx], 0
-;; 601c:	 aa                   	stosb	byte ptr [rdi], al
-;; 601d:	 800100               	add	byte ptr [rcx], 0
-;; 6020:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6029:	 800100               	add	byte ptr [rcx], 0
-;; 602c:	 aa                   	stosb	byte ptr [rdi], al
-;; 602d:	 800100               	add	byte ptr [rcx], 0
-;; 6030:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6039:	 800100               	add	byte ptr [rcx], 0
-;; 603c:	 aa                   	stosb	byte ptr [rdi], al
-;; 603d:	 800100               	add	byte ptr [rcx], 0
-;; 6040:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6049:	 800100               	add	byte ptr [rcx], 0
-;; 604c:	 aa                   	stosb	byte ptr [rdi], al
-;; 604d:	 800100               	add	byte ptr [rcx], 0
-;; 6050:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6059:	 800100               	add	byte ptr [rcx], 0
-;; 605c:	 aa                   	stosb	byte ptr [rdi], al
-;; 605d:	 800100               	add	byte ptr [rcx], 0
-;; 6060:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6069:	 800100               	add	byte ptr [rcx], 0
-;; 606c:	 aa                   	stosb	byte ptr [rdi], al
-;; 606d:	 800100               	add	byte ptr [rcx], 0
-;; 6070:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6079:	 800100               	add	byte ptr [rcx], 0
-;; 607c:	 aa                   	stosb	byte ptr [rdi], al
-;; 607d:	 800100               	add	byte ptr [rcx], 0
-;; 6080:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6089:	 800100               	add	byte ptr [rcx], 0
-;; 608c:	 aa                   	stosb	byte ptr [rdi], al
-;; 608d:	 800100               	add	byte ptr [rcx], 0
-;; 6090:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6099:	 800100               	add	byte ptr [rcx], 0
-;; 609c:	 aa                   	stosb	byte ptr [rdi], al
-;; 609d:	 800100               	add	byte ptr [rcx], 0
-;; 60a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 60a9:	 800100               	add	byte ptr [rcx], 0
-;; 60ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 60ad:	 800100               	add	byte ptr [rcx], 0
-;; 60b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 60b9:	 800100               	add	byte ptr [rcx], 0
-;; 60bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 60bd:	 800100               	add	byte ptr [rcx], 0
-;; 60c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 60c9:	 800100               	add	byte ptr [rcx], 0
-;; 60cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 60cd:	 800100               	add	byte ptr [rcx], 0
-;; 60d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 60d9:	 800100               	add	byte ptr [rcx], 0
-;; 60dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 60dd:	 800100               	add	byte ptr [rcx], 0
-;; 60e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 60e9:	 800100               	add	byte ptr [rcx], 0
-;; 60ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 60ed:	 800100               	add	byte ptr [rcx], 0
-;; 60f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 60f9:	 800100               	add	byte ptr [rcx], 0
-;; 60fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 60fd:	 800100               	add	byte ptr [rcx], 0
-;; 6100:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6109:	 800100               	add	byte ptr [rcx], 0
-;; 610c:	 aa                   	stosb	byte ptr [rdi], al
-;; 610d:	 800100               	add	byte ptr [rcx], 0
-;; 6110:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6119:	 800100               	add	byte ptr [rcx], 0
-;; 611c:	 aa                   	stosb	byte ptr [rdi], al
-;; 611d:	 800100               	add	byte ptr [rcx], 0
-;; 6120:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6129:	 800100               	add	byte ptr [rcx], 0
-;; 612c:	 aa                   	stosb	byte ptr [rdi], al
-;; 612d:	 800100               	add	byte ptr [rcx], 0
-;; 6130:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6139:	 800100               	add	byte ptr [rcx], 0
-;; 613c:	 aa                   	stosb	byte ptr [rdi], al
-;; 613d:	 800100               	add	byte ptr [rcx], 0
-;; 6140:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6149:	 800100               	add	byte ptr [rcx], 0
-;; 614c:	 aa                   	stosb	byte ptr [rdi], al
-;; 614d:	 800100               	add	byte ptr [rcx], 0
-;; 6150:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6159:	 800100               	add	byte ptr [rcx], 0
-;; 615c:	 aa                   	stosb	byte ptr [rdi], al
-;; 615d:	 800100               	add	byte ptr [rcx], 0
-;; 6160:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6169:	 800100               	add	byte ptr [rcx], 0
-;; 616c:	 aa                   	stosb	byte ptr [rdi], al
-;; 616d:	 800100               	add	byte ptr [rcx], 0
-;; 6170:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6179:	 800100               	add	byte ptr [rcx], 0
-;; 617c:	 aa                   	stosb	byte ptr [rdi], al
-;; 617d:	 800100               	add	byte ptr [rcx], 0
-;; 6180:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6189:	 800100               	add	byte ptr [rcx], 0
-;; 618c:	 aa                   	stosb	byte ptr [rdi], al
-;; 618d:	 800100               	add	byte ptr [rcx], 0
-;; 6190:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6199:	 800100               	add	byte ptr [rcx], 0
-;; 619c:	 aa                   	stosb	byte ptr [rdi], al
-;; 619d:	 800100               	add	byte ptr [rcx], 0
-;; 61a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 61a9:	 800100               	add	byte ptr [rcx], 0
-;; 61ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 61ad:	 800100               	add	byte ptr [rcx], 0
-;; 61b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 61b9:	 800100               	add	byte ptr [rcx], 0
-;; 61bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 61bd:	 800100               	add	byte ptr [rcx], 0
-;; 61c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 61c9:	 800100               	add	byte ptr [rcx], 0
-;; 61cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 61cd:	 800100               	add	byte ptr [rcx], 0
-;; 61d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 61d9:	 800100               	add	byte ptr [rcx], 0
-;; 61dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 61dd:	 800100               	add	byte ptr [rcx], 0
-;; 61e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 61e9:	 800100               	add	byte ptr [rcx], 0
-;; 61ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 61ed:	 800100               	add	byte ptr [rcx], 0
-;; 61f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 61f9:	 800100               	add	byte ptr [rcx], 0
-;; 61fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 61fd:	 800100               	add	byte ptr [rcx], 0
-;; 6200:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6209:	 800100               	add	byte ptr [rcx], 0
-;; 620c:	 aa                   	stosb	byte ptr [rdi], al
-;; 620d:	 800100               	add	byte ptr [rcx], 0
-;; 6210:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6219:	 800100               	add	byte ptr [rcx], 0
-;; 621c:	 aa                   	stosb	byte ptr [rdi], al
-;; 621d:	 800100               	add	byte ptr [rcx], 0
-;; 6220:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6229:	 800100               	add	byte ptr [rcx], 0
-;; 622c:	 aa                   	stosb	byte ptr [rdi], al
-;; 622d:	 800100               	add	byte ptr [rcx], 0
-;; 6230:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6239:	 800100               	add	byte ptr [rcx], 0
-;; 623c:	 aa                   	stosb	byte ptr [rdi], al
-;; 623d:	 800100               	add	byte ptr [rcx], 0
-;; 6240:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6249:	 800100               	add	byte ptr [rcx], 0
-;; 624c:	 aa                   	stosb	byte ptr [rdi], al
-;; 624d:	 800100               	add	byte ptr [rcx], 0
-;; 6250:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6259:	 800100               	add	byte ptr [rcx], 0
-;; 625c:	 aa                   	stosb	byte ptr [rdi], al
-;; 625d:	 800100               	add	byte ptr [rcx], 0
-;; 6260:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6269:	 800100               	add	byte ptr [rcx], 0
-;; 626c:	 aa                   	stosb	byte ptr [rdi], al
-;; 626d:	 800100               	add	byte ptr [rcx], 0
-;; 6270:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6279:	 800100               	add	byte ptr [rcx], 0
-;; 627c:	 aa                   	stosb	byte ptr [rdi], al
-;; 627d:	 800100               	add	byte ptr [rcx], 0
-;; 6280:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6289:	 800100               	add	byte ptr [rcx], 0
-;; 628c:	 aa                   	stosb	byte ptr [rdi], al
-;; 628d:	 800100               	add	byte ptr [rcx], 0
-;; 6290:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6299:	 800100               	add	byte ptr [rcx], 0
-;; 629c:	 aa                   	stosb	byte ptr [rdi], al
-;; 629d:	 800100               	add	byte ptr [rcx], 0
-;; 62a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 62a9:	 800100               	add	byte ptr [rcx], 0
-;; 62ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 62ad:	 800100               	add	byte ptr [rcx], 0
-;; 62b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 62b9:	 800100               	add	byte ptr [rcx], 0
-;; 62bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 62bd:	 800100               	add	byte ptr [rcx], 0
-;; 62c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 62c9:	 800100               	add	byte ptr [rcx], 0
-;; 62cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 62cd:	 800100               	add	byte ptr [rcx], 0
-;; 62d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 62d9:	 800100               	add	byte ptr [rcx], 0
-;; 62dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 62dd:	 800100               	add	byte ptr [rcx], 0
-;; 62e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 62e9:	 800100               	add	byte ptr [rcx], 0
-;; 62ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 62ed:	 800100               	add	byte ptr [rcx], 0
-;; 62f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 62f9:	 800100               	add	byte ptr [rcx], 0
-;; 62fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 62fd:	 800100               	add	byte ptr [rcx], 0
-;; 6300:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6309:	 800100               	add	byte ptr [rcx], 0
-;; 630c:	 aa                   	stosb	byte ptr [rdi], al
-;; 630d:	 800100               	add	byte ptr [rcx], 0
-;; 6310:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6319:	 800100               	add	byte ptr [rcx], 0
-;; 631c:	 aa                   	stosb	byte ptr [rdi], al
-;; 631d:	 800100               	add	byte ptr [rcx], 0
-;; 6320:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6329:	 800100               	add	byte ptr [rcx], 0
-;; 632c:	 aa                   	stosb	byte ptr [rdi], al
-;; 632d:	 800100               	add	byte ptr [rcx], 0
-;; 6330:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6339:	 800100               	add	byte ptr [rcx], 0
-;; 633c:	 aa                   	stosb	byte ptr [rdi], al
-;; 633d:	 800100               	add	byte ptr [rcx], 0
-;; 6340:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6349:	 800100               	add	byte ptr [rcx], 0
-;; 634c:	 aa                   	stosb	byte ptr [rdi], al
-;; 634d:	 800100               	add	byte ptr [rcx], 0
-;; 6350:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6359:	 800100               	add	byte ptr [rcx], 0
-;; 635c:	 aa                   	stosb	byte ptr [rdi], al
-;; 635d:	 800100               	add	byte ptr [rcx], 0
-;; 6360:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6369:	 800100               	add	byte ptr [rcx], 0
-;; 636c:	 aa                   	stosb	byte ptr [rdi], al
-;; 636d:	 800100               	add	byte ptr [rcx], 0
-;; 6370:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6379:	 800100               	add	byte ptr [rcx], 0
-;; 637c:	 aa                   	stosb	byte ptr [rdi], al
-;; 637d:	 800100               	add	byte ptr [rcx], 0
-;; 6380:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6389:	 800100               	add	byte ptr [rcx], 0
-;; 638c:	 aa                   	stosb	byte ptr [rdi], al
-;; 638d:	 800100               	add	byte ptr [rcx], 0
-;; 6390:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6399:	 800100               	add	byte ptr [rcx], 0
-;; 639c:	 aa                   	stosb	byte ptr [rdi], al
-;; 639d:	 800100               	add	byte ptr [rcx], 0
-;; 63a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 63a9:	 800100               	add	byte ptr [rcx], 0
-;; 63ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 63ad:	 800100               	add	byte ptr [rcx], 0
-;; 63b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 63b9:	 800100               	add	byte ptr [rcx], 0
-;; 63bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 63bd:	 800100               	add	byte ptr [rcx], 0
-;; 63c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 63c9:	 800100               	add	byte ptr [rcx], 0
-;; 63cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 63cd:	 800100               	add	byte ptr [rcx], 0
-;; 63d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 63d9:	 800100               	add	byte ptr [rcx], 0
-;; 63dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 63dd:	 800100               	add	byte ptr [rcx], 0
-;; 63e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 63e9:	 800100               	add	byte ptr [rcx], 0
-;; 63ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 63ed:	 800100               	add	byte ptr [rcx], 0
-;; 63f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 63f9:	 800100               	add	byte ptr [rcx], 0
-;; 63fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 63fd:	 800100               	add	byte ptr [rcx], 0
-;; 6400:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6409:	 800100               	add	byte ptr [rcx], 0
-;; 640c:	 aa                   	stosb	byte ptr [rdi], al
-;; 640d:	 800100               	add	byte ptr [rcx], 0
-;; 6410:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6419:	 800100               	add	byte ptr [rcx], 0
-;; 641c:	 aa                   	stosb	byte ptr [rdi], al
-;; 641d:	 800100               	add	byte ptr [rcx], 0
-;; 6420:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6429:	 800100               	add	byte ptr [rcx], 0
-;; 642c:	 aa                   	stosb	byte ptr [rdi], al
-;; 642d:	 800100               	add	byte ptr [rcx], 0
-;; 6430:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6439:	 800100               	add	byte ptr [rcx], 0
-;; 643c:	 aa                   	stosb	byte ptr [rdi], al
-;; 643d:	 800100               	add	byte ptr [rcx], 0
-;; 6440:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6449:	 800100               	add	byte ptr [rcx], 0
-;; 644c:	 aa                   	stosb	byte ptr [rdi], al
-;; 644d:	 800100               	add	byte ptr [rcx], 0
-;; 6450:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6459:	 800100               	add	byte ptr [rcx], 0
-;; 645c:	 aa                   	stosb	byte ptr [rdi], al
-;; 645d:	 800100               	add	byte ptr [rcx], 0
-;; 6460:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6469:	 800100               	add	byte ptr [rcx], 0
-;; 646c:	 aa                   	stosb	byte ptr [rdi], al
-;; 646d:	 800100               	add	byte ptr [rcx], 0
-;; 6470:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6479:	 800100               	add	byte ptr [rcx], 0
-;; 647c:	 aa                   	stosb	byte ptr [rdi], al
-;; 647d:	 800100               	add	byte ptr [rcx], 0
-;; 6480:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6489:	 800100               	add	byte ptr [rcx], 0
-;; 648c:	 aa                   	stosb	byte ptr [rdi], al
-;; 648d:	 800100               	add	byte ptr [rcx], 0
-;; 6490:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6499:	 800100               	add	byte ptr [rcx], 0
-;; 649c:	 aa                   	stosb	byte ptr [rdi], al
-;; 649d:	 800100               	add	byte ptr [rcx], 0
-;; 64a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 64a9:	 800100               	add	byte ptr [rcx], 0
-;; 64ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 64ad:	 800100               	add	byte ptr [rcx], 0
-;; 64b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 64b9:	 800100               	add	byte ptr [rcx], 0
-;; 64bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 64bd:	 800100               	add	byte ptr [rcx], 0
-;; 64c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 64c9:	 800100               	add	byte ptr [rcx], 0
-;; 64cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 64cd:	 800100               	add	byte ptr [rcx], 0
-;; 64d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 64d9:	 800100               	add	byte ptr [rcx], 0
-;; 64dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 64dd:	 800100               	add	byte ptr [rcx], 0
-;; 64e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 64e9:	 800100               	add	byte ptr [rcx], 0
-;; 64ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 64ed:	 800100               	add	byte ptr [rcx], 0
-;; 64f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 64f9:	 800100               	add	byte ptr [rcx], 0
-;; 64fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 64fd:	 800100               	add	byte ptr [rcx], 0
-;; 6500:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6509:	 800100               	add	byte ptr [rcx], 0
-;; 650c:	 aa                   	stosb	byte ptr [rdi], al
-;; 650d:	 800100               	add	byte ptr [rcx], 0
-;; 6510:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6519:	 800100               	add	byte ptr [rcx], 0
-;; 651c:	 aa                   	stosb	byte ptr [rdi], al
-;; 651d:	 800100               	add	byte ptr [rcx], 0
-;; 6520:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6529:	 800100               	add	byte ptr [rcx], 0
-;; 652c:	 aa                   	stosb	byte ptr [rdi], al
-;; 652d:	 800100               	add	byte ptr [rcx], 0
-;; 6530:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6539:	 800100               	add	byte ptr [rcx], 0
-;; 653c:	 aa                   	stosb	byte ptr [rdi], al
-;; 653d:	 800100               	add	byte ptr [rcx], 0
-;; 6540:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6549:	 800100               	add	byte ptr [rcx], 0
-;; 654c:	 aa                   	stosb	byte ptr [rdi], al
-;; 654d:	 800100               	add	byte ptr [rcx], 0
-;; 6550:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6559:	 800100               	add	byte ptr [rcx], 0
-;; 655c:	 aa                   	stosb	byte ptr [rdi], al
-;; 655d:	 800100               	add	byte ptr [rcx], 0
-;; 6560:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6569:	 800100               	add	byte ptr [rcx], 0
-;; 656c:	 aa                   	stosb	byte ptr [rdi], al
-;; 656d:	 800100               	add	byte ptr [rcx], 0
-;; 6570:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6579:	 800100               	add	byte ptr [rcx], 0
-;; 657c:	 aa                   	stosb	byte ptr [rdi], al
-;; 657d:	 800100               	add	byte ptr [rcx], 0
-;; 6580:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6589:	 800100               	add	byte ptr [rcx], 0
-;; 658c:	 aa                   	stosb	byte ptr [rdi], al
-;; 658d:	 800100               	add	byte ptr [rcx], 0
-;; 6590:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6599:	 800100               	add	byte ptr [rcx], 0
-;; 659c:	 aa                   	stosb	byte ptr [rdi], al
-;; 659d:	 800100               	add	byte ptr [rcx], 0
-;; 65a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 65a9:	 800100               	add	byte ptr [rcx], 0
-;; 65ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 65ad:	 800100               	add	byte ptr [rcx], 0
-;; 65b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 65b9:	 800100               	add	byte ptr [rcx], 0
-;; 65bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 65bd:	 800100               	add	byte ptr [rcx], 0
-;; 65c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 65c9:	 800100               	add	byte ptr [rcx], 0
-;; 65cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 65cd:	 800100               	add	byte ptr [rcx], 0
-;; 65d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 65d9:	 800100               	add	byte ptr [rcx], 0
-;; 65dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 65dd:	 800100               	add	byte ptr [rcx], 0
-;; 65e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 65e9:	 800100               	add	byte ptr [rcx], 0
-;; 65ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 65ed:	 800100               	add	byte ptr [rcx], 0
-;; 65f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 65f9:	 800100               	add	byte ptr [rcx], 0
-;; 65fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 65fd:	 800100               	add	byte ptr [rcx], 0
-;; 6600:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6609:	 800100               	add	byte ptr [rcx], 0
-;; 660c:	 aa                   	stosb	byte ptr [rdi], al
-;; 660d:	 800100               	add	byte ptr [rcx], 0
-;; 6610:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6619:	 800100               	add	byte ptr [rcx], 0
-;; 661c:	 aa                   	stosb	byte ptr [rdi], al
-;; 661d:	 800100               	add	byte ptr [rcx], 0
-;; 6620:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6629:	 800100               	add	byte ptr [rcx], 0
-;; 662c:	 aa                   	stosb	byte ptr [rdi], al
-;; 662d:	 800100               	add	byte ptr [rcx], 0
-;; 6630:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6639:	 800100               	add	byte ptr [rcx], 0
-;; 663c:	 aa                   	stosb	byte ptr [rdi], al
-;; 663d:	 800100               	add	byte ptr [rcx], 0
-;; 6640:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6649:	 800100               	add	byte ptr [rcx], 0
-;; 664c:	 aa                   	stosb	byte ptr [rdi], al
-;; 664d:	 800100               	add	byte ptr [rcx], 0
-;; 6650:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6659:	 800100               	add	byte ptr [rcx], 0
-;; 665c:	 aa                   	stosb	byte ptr [rdi], al
-;; 665d:	 800100               	add	byte ptr [rcx], 0
-;; 6660:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6669:	 800100               	add	byte ptr [rcx], 0
-;; 666c:	 aa                   	stosb	byte ptr [rdi], al
-;; 666d:	 800100               	add	byte ptr [rcx], 0
-;; 6670:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6679:	 800100               	add	byte ptr [rcx], 0
-;; 667c:	 aa                   	stosb	byte ptr [rdi], al
-;; 667d:	 800100               	add	byte ptr [rcx], 0
-;; 6680:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6689:	 800100               	add	byte ptr [rcx], 0
-;; 668c:	 aa                   	stosb	byte ptr [rdi], al
-;; 668d:	 800100               	add	byte ptr [rcx], 0
-;; 6690:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6699:	 800100               	add	byte ptr [rcx], 0
-;; 669c:	 aa                   	stosb	byte ptr [rdi], al
-;; 669d:	 800100               	add	byte ptr [rcx], 0
-;; 66a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 66a9:	 800100               	add	byte ptr [rcx], 0
-;; 66ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 66ad:	 800100               	add	byte ptr [rcx], 0
-;; 66b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 66b9:	 800100               	add	byte ptr [rcx], 0
-;; 66bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 66bd:	 800100               	add	byte ptr [rcx], 0
-;; 66c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 66c9:	 800100               	add	byte ptr [rcx], 0
-;; 66cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 66cd:	 800100               	add	byte ptr [rcx], 0
-;; 66d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 66d9:	 800100               	add	byte ptr [rcx], 0
-;; 66dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 66dd:	 800100               	add	byte ptr [rcx], 0
-;; 66e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 66e9:	 800100               	add	byte ptr [rcx], 0
-;; 66ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 66ed:	 800100               	add	byte ptr [rcx], 0
-;; 66f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 66f9:	 800100               	add	byte ptr [rcx], 0
-;; 66fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 66fd:	 800100               	add	byte ptr [rcx], 0
-;; 6700:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6709:	 800100               	add	byte ptr [rcx], 0
-;; 670c:	 aa                   	stosb	byte ptr [rdi], al
-;; 670d:	 800100               	add	byte ptr [rcx], 0
-;; 6710:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6719:	 800100               	add	byte ptr [rcx], 0
-;; 671c:	 aa                   	stosb	byte ptr [rdi], al
-;; 671d:	 800100               	add	byte ptr [rcx], 0
-;; 6720:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6729:	 800100               	add	byte ptr [rcx], 0
-;; 672c:	 aa                   	stosb	byte ptr [rdi], al
-;; 672d:	 800100               	add	byte ptr [rcx], 0
-;; 6730:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6739:	 800100               	add	byte ptr [rcx], 0
-;; 673c:	 aa                   	stosb	byte ptr [rdi], al
-;; 673d:	 800100               	add	byte ptr [rcx], 0
-;; 6740:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6749:	 800100               	add	byte ptr [rcx], 0
-;; 674c:	 aa                   	stosb	byte ptr [rdi], al
-;; 674d:	 800100               	add	byte ptr [rcx], 0
-;; 6750:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6759:	 800100               	add	byte ptr [rcx], 0
-;; 675c:	 aa                   	stosb	byte ptr [rdi], al
-;; 675d:	 800100               	add	byte ptr [rcx], 0
-;; 6760:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6769:	 800100               	add	byte ptr [rcx], 0
-;; 676c:	 aa                   	stosb	byte ptr [rdi], al
-;; 676d:	 800100               	add	byte ptr [rcx], 0
-;; 6770:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6779:	 800100               	add	byte ptr [rcx], 0
-;; 677c:	 aa                   	stosb	byte ptr [rdi], al
-;; 677d:	 800100               	add	byte ptr [rcx], 0
-;; 6780:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6789:	 800100               	add	byte ptr [rcx], 0
-;; 678c:	 aa                   	stosb	byte ptr [rdi], al
-;; 678d:	 800100               	add	byte ptr [rcx], 0
-;; 6790:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6799:	 800100               	add	byte ptr [rcx], 0
-;; 679c:	 aa                   	stosb	byte ptr [rdi], al
-;; 679d:	 800100               	add	byte ptr [rcx], 0
-;; 67a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 67a9:	 800100               	add	byte ptr [rcx], 0
-;; 67ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 67ad:	 800100               	add	byte ptr [rcx], 0
-;; 67b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 67b9:	 800100               	add	byte ptr [rcx], 0
-;; 67bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 67bd:	 800100               	add	byte ptr [rcx], 0
-;; 67c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 67c9:	 800100               	add	byte ptr [rcx], 0
-;; 67cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 67cd:	 800100               	add	byte ptr [rcx], 0
-;; 67d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 67d9:	 800100               	add	byte ptr [rcx], 0
-;; 67dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 67dd:	 800100               	add	byte ptr [rcx], 0
-;; 67e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 67e9:	 800100               	add	byte ptr [rcx], 0
-;; 67ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 67ed:	 800100               	add	byte ptr [rcx], 0
-;; 67f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 67f9:	 800100               	add	byte ptr [rcx], 0
-;; 67fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 67fd:	 800100               	add	byte ptr [rcx], 0
-;; 6800:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6809:	 800100               	add	byte ptr [rcx], 0
-;; 680c:	 aa                   	stosb	byte ptr [rdi], al
-;; 680d:	 800100               	add	byte ptr [rcx], 0
-;; 6810:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6819:	 800100               	add	byte ptr [rcx], 0
-;; 681c:	 aa                   	stosb	byte ptr [rdi], al
-;; 681d:	 800100               	add	byte ptr [rcx], 0
-;; 6820:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6829:	 800100               	add	byte ptr [rcx], 0
-;; 682c:	 aa                   	stosb	byte ptr [rdi], al
-;; 682d:	 800100               	add	byte ptr [rcx], 0
-;; 6830:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6839:	 800100               	add	byte ptr [rcx], 0
-;; 683c:	 aa                   	stosb	byte ptr [rdi], al
-;; 683d:	 800100               	add	byte ptr [rcx], 0
-;; 6840:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6849:	 800100               	add	byte ptr [rcx], 0
-;; 684c:	 aa                   	stosb	byte ptr [rdi], al
-;; 684d:	 800100               	add	byte ptr [rcx], 0
-;; 6850:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6859:	 800100               	add	byte ptr [rcx], 0
-;; 685c:	 aa                   	stosb	byte ptr [rdi], al
-;; 685d:	 800100               	add	byte ptr [rcx], 0
-;; 6860:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6869:	 800100               	add	byte ptr [rcx], 0
-;; 686c:	 aa                   	stosb	byte ptr [rdi], al
-;; 686d:	 800100               	add	byte ptr [rcx], 0
-;; 6870:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6879:	 800100               	add	byte ptr [rcx], 0
-;; 687c:	 aa                   	stosb	byte ptr [rdi], al
-;; 687d:	 800100               	add	byte ptr [rcx], 0
-;; 6880:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6889:	 800100               	add	byte ptr [rcx], 0
-;; 688c:	 aa                   	stosb	byte ptr [rdi], al
-;; 688d:	 800100               	add	byte ptr [rcx], 0
-;; 6890:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6899:	 800100               	add	byte ptr [rcx], 0
-;; 689c:	 aa                   	stosb	byte ptr [rdi], al
-;; 689d:	 800100               	add	byte ptr [rcx], 0
-;; 68a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 68a9:	 800100               	add	byte ptr [rcx], 0
-;; 68ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 68ad:	 800100               	add	byte ptr [rcx], 0
-;; 68b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 68b9:	 800100               	add	byte ptr [rcx], 0
-;; 68bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 68bd:	 800100               	add	byte ptr [rcx], 0
-;; 68c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 68c9:	 800100               	add	byte ptr [rcx], 0
-;; 68cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 68cd:	 800100               	add	byte ptr [rcx], 0
-;; 68d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 68d9:	 800100               	add	byte ptr [rcx], 0
-;; 68dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 68dd:	 800100               	add	byte ptr [rcx], 0
-;; 68e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 68e9:	 800100               	add	byte ptr [rcx], 0
-;; 68ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 68ed:	 800100               	add	byte ptr [rcx], 0
-;; 68f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 68f9:	 800100               	add	byte ptr [rcx], 0
-;; 68fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 68fd:	 800100               	add	byte ptr [rcx], 0
-;; 6900:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6909:	 800100               	add	byte ptr [rcx], 0
-;; 690c:	 aa                   	stosb	byte ptr [rdi], al
-;; 690d:	 800100               	add	byte ptr [rcx], 0
-;; 6910:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6919:	 800100               	add	byte ptr [rcx], 0
-;; 691c:	 aa                   	stosb	byte ptr [rdi], al
-;; 691d:	 800100               	add	byte ptr [rcx], 0
-;; 6920:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6929:	 800100               	add	byte ptr [rcx], 0
-;; 692c:	 aa                   	stosb	byte ptr [rdi], al
-;; 692d:	 800100               	add	byte ptr [rcx], 0
-;; 6930:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6939:	 800100               	add	byte ptr [rcx], 0
-;; 693c:	 aa                   	stosb	byte ptr [rdi], al
-;; 693d:	 800100               	add	byte ptr [rcx], 0
-;; 6940:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6949:	 800100               	add	byte ptr [rcx], 0
-;; 694c:	 aa                   	stosb	byte ptr [rdi], al
-;; 694d:	 800100               	add	byte ptr [rcx], 0
-;; 6950:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6959:	 800100               	add	byte ptr [rcx], 0
-;; 695c:	 aa                   	stosb	byte ptr [rdi], al
-;; 695d:	 800100               	add	byte ptr [rcx], 0
-;; 6960:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6969:	 800100               	add	byte ptr [rcx], 0
-;; 696c:	 aa                   	stosb	byte ptr [rdi], al
-;; 696d:	 800100               	add	byte ptr [rcx], 0
-;; 6970:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6979:	 800100               	add	byte ptr [rcx], 0
-;; 697c:	 aa                   	stosb	byte ptr [rdi], al
-;; 697d:	 800100               	add	byte ptr [rcx], 0
-;; 6980:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6989:	 800100               	add	byte ptr [rcx], 0
-;; 698c:	 aa                   	stosb	byte ptr [rdi], al
-;; 698d:	 800100               	add	byte ptr [rcx], 0
-;; 6990:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6999:	 800100               	add	byte ptr [rcx], 0
-;; 699c:	 aa                   	stosb	byte ptr [rdi], al
-;; 699d:	 800100               	add	byte ptr [rcx], 0
-;; 69a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 69a9:	 800100               	add	byte ptr [rcx], 0
-;; 69ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 69ad:	 800100               	add	byte ptr [rcx], 0
-;; 69b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 69b9:	 800100               	add	byte ptr [rcx], 0
-;; 69bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 69bd:	 800100               	add	byte ptr [rcx], 0
-;; 69c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 69c9:	 800100               	add	byte ptr [rcx], 0
-;; 69cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 69cd:	 800100               	add	byte ptr [rcx], 0
-;; 69d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 69d9:	 800100               	add	byte ptr [rcx], 0
-;; 69dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 69dd:	 800100               	add	byte ptr [rcx], 0
-;; 69e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 69e9:	 800100               	add	byte ptr [rcx], 0
-;; 69ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 69ed:	 800100               	add	byte ptr [rcx], 0
-;; 69f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 69f9:	 800100               	add	byte ptr [rcx], 0
-;; 69fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 69fd:	 800100               	add	byte ptr [rcx], 0
-;; 6a00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6a09:	 800100               	add	byte ptr [rcx], 0
-;; 6a0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6a0d:	 800100               	add	byte ptr [rcx], 0
-;; 6a10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6a19:	 800100               	add	byte ptr [rcx], 0
-;; 6a1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6a1d:	 800100               	add	byte ptr [rcx], 0
-;; 6a20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6a29:	 800100               	add	byte ptr [rcx], 0
-;; 6a2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6a2d:	 800100               	add	byte ptr [rcx], 0
-;; 6a30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6a39:	 800100               	add	byte ptr [rcx], 0
-;; 6a3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6a3d:	 800100               	add	byte ptr [rcx], 0
-;; 6a40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6a49:	 800100               	add	byte ptr [rcx], 0
-;; 6a4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6a4d:	 800100               	add	byte ptr [rcx], 0
-;; 6a50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6a59:	 800100               	add	byte ptr [rcx], 0
-;; 6a5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6a5d:	 800100               	add	byte ptr [rcx], 0
-;; 6a60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6a69:	 800100               	add	byte ptr [rcx], 0
-;; 6a6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6a6d:	 800100               	add	byte ptr [rcx], 0
-;; 6a70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6a79:	 800100               	add	byte ptr [rcx], 0
-;; 6a7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6a7d:	 800100               	add	byte ptr [rcx], 0
-;; 6a80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6a89:	 800100               	add	byte ptr [rcx], 0
-;; 6a8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6a8d:	 800100               	add	byte ptr [rcx], 0
-;; 6a90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6a99:	 800100               	add	byte ptr [rcx], 0
-;; 6a9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6a9d:	 800100               	add	byte ptr [rcx], 0
-;; 6aa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6aa9:	 800100               	add	byte ptr [rcx], 0
-;; 6aac:	 aa                   	stosb	byte ptr [rdi], al
-;; 6aad:	 800100               	add	byte ptr [rcx], 0
-;; 6ab0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6ab9:	 800100               	add	byte ptr [rcx], 0
-;; 6abc:	 aa                   	stosb	byte ptr [rdi], al
-;; 6abd:	 800100               	add	byte ptr [rcx], 0
-;; 6ac0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6ac9:	 800100               	add	byte ptr [rcx], 0
-;; 6acc:	 aa                   	stosb	byte ptr [rdi], al
-;; 6acd:	 800100               	add	byte ptr [rcx], 0
-;; 6ad0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6ad9:	 800100               	add	byte ptr [rcx], 0
-;; 6adc:	 aa                   	stosb	byte ptr [rdi], al
-;; 6add:	 800100               	add	byte ptr [rcx], 0
-;; 6ae0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6ae9:	 800100               	add	byte ptr [rcx], 0
-;; 6aec:	 aa                   	stosb	byte ptr [rdi], al
-;; 6aed:	 800100               	add	byte ptr [rcx], 0
-;; 6af0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6af9:	 800100               	add	byte ptr [rcx], 0
-;; 6afc:	 aa                   	stosb	byte ptr [rdi], al
-;; 6afd:	 800100               	add	byte ptr [rcx], 0
-;; 6b00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6b09:	 800100               	add	byte ptr [rcx], 0
-;; 6b0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6b0d:	 800100               	add	byte ptr [rcx], 0
-;; 6b10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6b19:	 800100               	add	byte ptr [rcx], 0
-;; 6b1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6b1d:	 800100               	add	byte ptr [rcx], 0
-;; 6b20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6b29:	 800100               	add	byte ptr [rcx], 0
-;; 6b2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6b2d:	 800100               	add	byte ptr [rcx], 0
-;; 6b30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6b39:	 800100               	add	byte ptr [rcx], 0
-;; 6b3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6b3d:	 800100               	add	byte ptr [rcx], 0
-;; 6b40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6b49:	 800100               	add	byte ptr [rcx], 0
-;; 6b4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6b4d:	 800100               	add	byte ptr [rcx], 0
-;; 6b50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6b59:	 800100               	add	byte ptr [rcx], 0
-;; 6b5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6b5d:	 800100               	add	byte ptr [rcx], 0
-;; 6b60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6b69:	 800100               	add	byte ptr [rcx], 0
-;; 6b6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6b6d:	 800100               	add	byte ptr [rcx], 0
-;; 6b70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6b79:	 800100               	add	byte ptr [rcx], 0
-;; 6b7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6b7d:	 800100               	add	byte ptr [rcx], 0
-;; 6b80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6b89:	 800100               	add	byte ptr [rcx], 0
-;; 6b8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6b8d:	 800100               	add	byte ptr [rcx], 0
-;; 6b90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6b99:	 800100               	add	byte ptr [rcx], 0
-;; 6b9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6b9d:	 800100               	add	byte ptr [rcx], 0
-;; 6ba0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6ba9:	 800100               	add	byte ptr [rcx], 0
-;; 6bac:	 aa                   	stosb	byte ptr [rdi], al
-;; 6bad:	 800100               	add	byte ptr [rcx], 0
-;; 6bb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6bb9:	 800100               	add	byte ptr [rcx], 0
-;; 6bbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 6bbd:	 800100               	add	byte ptr [rcx], 0
-;; 6bc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6bc9:	 800100               	add	byte ptr [rcx], 0
-;; 6bcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 6bcd:	 800100               	add	byte ptr [rcx], 0
-;; 6bd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6bd9:	 800100               	add	byte ptr [rcx], 0
-;; 6bdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 6bdd:	 800100               	add	byte ptr [rcx], 0
-;; 6be0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6be9:	 800100               	add	byte ptr [rcx], 0
-;; 6bec:	 aa                   	stosb	byte ptr [rdi], al
-;; 6bed:	 800100               	add	byte ptr [rcx], 0
-;; 6bf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6bf9:	 800100               	add	byte ptr [rcx], 0
-;; 6bfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 6bfd:	 800100               	add	byte ptr [rcx], 0
-;; 6c00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6c09:	 800100               	add	byte ptr [rcx], 0
-;; 6c0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6c0d:	 800100               	add	byte ptr [rcx], 0
-;; 6c10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6c19:	 800100               	add	byte ptr [rcx], 0
-;; 6c1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6c1d:	 800100               	add	byte ptr [rcx], 0
-;; 6c20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6c29:	 800100               	add	byte ptr [rcx], 0
-;; 6c2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6c2d:	 800100               	add	byte ptr [rcx], 0
-;; 6c30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6c39:	 800100               	add	byte ptr [rcx], 0
-;; 6c3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6c3d:	 800100               	add	byte ptr [rcx], 0
-;; 6c40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6c49:	 800100               	add	byte ptr [rcx], 0
-;; 6c4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6c4d:	 800100               	add	byte ptr [rcx], 0
-;; 6c50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6c59:	 800100               	add	byte ptr [rcx], 0
-;; 6c5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6c5d:	 800100               	add	byte ptr [rcx], 0
-;; 6c60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6c69:	 800100               	add	byte ptr [rcx], 0
-;; 6c6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6c6d:	 800100               	add	byte ptr [rcx], 0
-;; 6c70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6c79:	 800100               	add	byte ptr [rcx], 0
-;; 6c7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6c7d:	 800100               	add	byte ptr [rcx], 0
-;; 6c80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6c89:	 800100               	add	byte ptr [rcx], 0
-;; 6c8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6c8d:	 800100               	add	byte ptr [rcx], 0
-;; 6c90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6c99:	 800100               	add	byte ptr [rcx], 0
-;; 6c9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6c9d:	 800100               	add	byte ptr [rcx], 0
-;; 6ca0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6ca9:	 800100               	add	byte ptr [rcx], 0
-;; 6cac:	 aa                   	stosb	byte ptr [rdi], al
-;; 6cad:	 800100               	add	byte ptr [rcx], 0
-;; 6cb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6cb9:	 800100               	add	byte ptr [rcx], 0
-;; 6cbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 6cbd:	 800100               	add	byte ptr [rcx], 0
-;; 6cc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6cc9:	 800100               	add	byte ptr [rcx], 0
-;; 6ccc:	 aa                   	stosb	byte ptr [rdi], al
-;; 6ccd:	 800100               	add	byte ptr [rcx], 0
-;; 6cd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6cd9:	 800100               	add	byte ptr [rcx], 0
-;; 6cdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 6cdd:	 800100               	add	byte ptr [rcx], 0
-;; 6ce0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6ce9:	 800100               	add	byte ptr [rcx], 0
-;; 6cec:	 aa                   	stosb	byte ptr [rdi], al
-;; 6ced:	 800100               	add	byte ptr [rcx], 0
-;; 6cf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6cf9:	 800100               	add	byte ptr [rcx], 0
-;; 6cfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 6cfd:	 800100               	add	byte ptr [rcx], 0
-;; 6d00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6d09:	 800100               	add	byte ptr [rcx], 0
-;; 6d0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6d0d:	 800100               	add	byte ptr [rcx], 0
-;; 6d10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6d19:	 800100               	add	byte ptr [rcx], 0
-;; 6d1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6d1d:	 800100               	add	byte ptr [rcx], 0
-;; 6d20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6d29:	 800100               	add	byte ptr [rcx], 0
-;; 6d2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6d2d:	 800100               	add	byte ptr [rcx], 0
-;; 6d30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6d39:	 800100               	add	byte ptr [rcx], 0
-;; 6d3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6d3d:	 800100               	add	byte ptr [rcx], 0
-;; 6d40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6d49:	 800100               	add	byte ptr [rcx], 0
-;; 6d4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6d4d:	 800100               	add	byte ptr [rcx], 0
-;; 6d50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6d59:	 800100               	add	byte ptr [rcx], 0
-;; 6d5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6d5d:	 800100               	add	byte ptr [rcx], 0
-;; 6d60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6d69:	 800100               	add	byte ptr [rcx], 0
-;; 6d6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6d6d:	 800100               	add	byte ptr [rcx], 0
-;; 6d70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6d79:	 800100               	add	byte ptr [rcx], 0
-;; 6d7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6d7d:	 800100               	add	byte ptr [rcx], 0
-;; 6d80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6d89:	 800100               	add	byte ptr [rcx], 0
-;; 6d8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6d8d:	 800100               	add	byte ptr [rcx], 0
-;; 6d90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6d99:	 800100               	add	byte ptr [rcx], 0
-;; 6d9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6d9d:	 800100               	add	byte ptr [rcx], 0
-;; 6da0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6da9:	 800100               	add	byte ptr [rcx], 0
-;; 6dac:	 aa                   	stosb	byte ptr [rdi], al
-;; 6dad:	 800100               	add	byte ptr [rcx], 0
-;; 6db0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6db9:	 800100               	add	byte ptr [rcx], 0
-;; 6dbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 6dbd:	 800100               	add	byte ptr [rcx], 0
-;; 6dc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6dc9:	 800100               	add	byte ptr [rcx], 0
-;; 6dcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 6dcd:	 800100               	add	byte ptr [rcx], 0
-;; 6dd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6dd9:	 800100               	add	byte ptr [rcx], 0
-;; 6ddc:	 aa                   	stosb	byte ptr [rdi], al
-;; 6ddd:	 800100               	add	byte ptr [rcx], 0
-;; 6de0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6de9:	 800100               	add	byte ptr [rcx], 0
-;; 6dec:	 aa                   	stosb	byte ptr [rdi], al
-;; 6ded:	 800100               	add	byte ptr [rcx], 0
-;; 6df0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6df9:	 800100               	add	byte ptr [rcx], 0
-;; 6dfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 6dfd:	 800100               	add	byte ptr [rcx], 0
-;; 6e00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6e09:	 800100               	add	byte ptr [rcx], 0
-;; 6e0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6e0d:	 800100               	add	byte ptr [rcx], 0
-;; 6e10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6e19:	 800100               	add	byte ptr [rcx], 0
-;; 6e1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6e1d:	 800100               	add	byte ptr [rcx], 0
-;; 6e20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6e29:	 800100               	add	byte ptr [rcx], 0
-;; 6e2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6e2d:	 800100               	add	byte ptr [rcx], 0
-;; 6e30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6e39:	 800100               	add	byte ptr [rcx], 0
-;; 6e3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6e3d:	 800100               	add	byte ptr [rcx], 0
-;; 6e40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6e49:	 800100               	add	byte ptr [rcx], 0
-;; 6e4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6e4d:	 800100               	add	byte ptr [rcx], 0
-;; 6e50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6e59:	 800100               	add	byte ptr [rcx], 0
-;; 6e5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6e5d:	 800100               	add	byte ptr [rcx], 0
-;; 6e60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6e69:	 800100               	add	byte ptr [rcx], 0
-;; 6e6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6e6d:	 800100               	add	byte ptr [rcx], 0
-;; 6e70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6e79:	 800100               	add	byte ptr [rcx], 0
-;; 6e7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6e7d:	 800100               	add	byte ptr [rcx], 0
-;; 6e80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6e89:	 800100               	add	byte ptr [rcx], 0
-;; 6e8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6e8d:	 800100               	add	byte ptr [rcx], 0
-;; 6e90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6e99:	 800100               	add	byte ptr [rcx], 0
-;; 6e9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6e9d:	 800100               	add	byte ptr [rcx], 0
-;; 6ea0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6ea9:	 800100               	add	byte ptr [rcx], 0
-;; 6eac:	 aa                   	stosb	byte ptr [rdi], al
-;; 6ead:	 800100               	add	byte ptr [rcx], 0
-;; 6eb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6eb9:	 800100               	add	byte ptr [rcx], 0
-;; 6ebc:	 aa                   	stosb	byte ptr [rdi], al
-;; 6ebd:	 800100               	add	byte ptr [rcx], 0
-;; 6ec0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6ec9:	 800100               	add	byte ptr [rcx], 0
-;; 6ecc:	 aa                   	stosb	byte ptr [rdi], al
-;; 6ecd:	 800100               	add	byte ptr [rcx], 0
-;; 6ed0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6ed9:	 800100               	add	byte ptr [rcx], 0
-;; 6edc:	 aa                   	stosb	byte ptr [rdi], al
-;; 6edd:	 800100               	add	byte ptr [rcx], 0
-;; 6ee0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6ee9:	 800100               	add	byte ptr [rcx], 0
-;; 6eec:	 aa                   	stosb	byte ptr [rdi], al
-;; 6eed:	 800100               	add	byte ptr [rcx], 0
-;; 6ef0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6ef9:	 800100               	add	byte ptr [rcx], 0
-;; 6efc:	 aa                   	stosb	byte ptr [rdi], al
-;; 6efd:	 800100               	add	byte ptr [rcx], 0
-;; 6f00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6f09:	 800100               	add	byte ptr [rcx], 0
-;; 6f0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6f0d:	 800100               	add	byte ptr [rcx], 0
-;; 6f10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6f19:	 800100               	add	byte ptr [rcx], 0
-;; 6f1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6f1d:	 800100               	add	byte ptr [rcx], 0
-;; 6f20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6f29:	 800100               	add	byte ptr [rcx], 0
-;; 6f2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6f2d:	 800100               	add	byte ptr [rcx], 0
-;; 6f30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6f39:	 800100               	add	byte ptr [rcx], 0
-;; 6f3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6f3d:	 800100               	add	byte ptr [rcx], 0
-;; 6f40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6f49:	 800100               	add	byte ptr [rcx], 0
-;; 6f4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6f4d:	 800100               	add	byte ptr [rcx], 0
-;; 6f50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6f59:	 800100               	add	byte ptr [rcx], 0
-;; 6f5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6f5d:	 800100               	add	byte ptr [rcx], 0
-;; 6f60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6f69:	 800100               	add	byte ptr [rcx], 0
-;; 6f6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6f6d:	 800100               	add	byte ptr [rcx], 0
-;; 6f70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6f79:	 800100               	add	byte ptr [rcx], 0
-;; 6f7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6f7d:	 800100               	add	byte ptr [rcx], 0
-;; 6f80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6f89:	 800100               	add	byte ptr [rcx], 0
-;; 6f8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6f8d:	 800100               	add	byte ptr [rcx], 0
-;; 6f90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6f99:	 800100               	add	byte ptr [rcx], 0
-;; 6f9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 6f9d:	 800100               	add	byte ptr [rcx], 0
-;; 6fa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6fa9:	 800100               	add	byte ptr [rcx], 0
-;; 6fac:	 aa                   	stosb	byte ptr [rdi], al
-;; 6fad:	 800100               	add	byte ptr [rcx], 0
-;; 6fb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6fb9:	 800100               	add	byte ptr [rcx], 0
-;; 6fbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 6fbd:	 800100               	add	byte ptr [rcx], 0
-;; 6fc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6fc9:	 800100               	add	byte ptr [rcx], 0
-;; 6fcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 6fcd:	 800100               	add	byte ptr [rcx], 0
-;; 6fd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6fd9:	 800100               	add	byte ptr [rcx], 0
-;; 6fdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 6fdd:	 800100               	add	byte ptr [rcx], 0
-;; 6fe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6fe9:	 800100               	add	byte ptr [rcx], 0
-;; 6fec:	 aa                   	stosb	byte ptr [rdi], al
-;; 6fed:	 800100               	add	byte ptr [rcx], 0
-;; 6ff0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 6ff9:	 800100               	add	byte ptr [rcx], 0
-;; 6ffc:	 aa                   	stosb	byte ptr [rdi], al
-;; 6ffd:	 800100               	add	byte ptr [rcx], 0
-;; 7000:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7009:	 800100               	add	byte ptr [rcx], 0
-;; 700c:	 aa                   	stosb	byte ptr [rdi], al
-;; 700d:	 800100               	add	byte ptr [rcx], 0
-;; 7010:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7019:	 800100               	add	byte ptr [rcx], 0
-;; 701c:	 aa                   	stosb	byte ptr [rdi], al
-;; 701d:	 800100               	add	byte ptr [rcx], 0
-;; 7020:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7029:	 800100               	add	byte ptr [rcx], 0
-;; 702c:	 aa                   	stosb	byte ptr [rdi], al
-;; 702d:	 800100               	add	byte ptr [rcx], 0
-;; 7030:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7039:	 800100               	add	byte ptr [rcx], 0
-;; 703c:	 aa                   	stosb	byte ptr [rdi], al
-;; 703d:	 800100               	add	byte ptr [rcx], 0
-;; 7040:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7049:	 800100               	add	byte ptr [rcx], 0
-;; 704c:	 aa                   	stosb	byte ptr [rdi], al
-;; 704d:	 800100               	add	byte ptr [rcx], 0
-;; 7050:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7059:	 800100               	add	byte ptr [rcx], 0
-;; 705c:	 aa                   	stosb	byte ptr [rdi], al
-;; 705d:	 800100               	add	byte ptr [rcx], 0
-;; 7060:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7069:	 800100               	add	byte ptr [rcx], 0
-;; 706c:	 aa                   	stosb	byte ptr [rdi], al
-;; 706d:	 800100               	add	byte ptr [rcx], 0
-;; 7070:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7079:	 800100               	add	byte ptr [rcx], 0
-;; 707c:	 aa                   	stosb	byte ptr [rdi], al
-;; 707d:	 800100               	add	byte ptr [rcx], 0
-;; 7080:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7089:	 800100               	add	byte ptr [rcx], 0
-;; 708c:	 aa                   	stosb	byte ptr [rdi], al
-;; 708d:	 800100               	add	byte ptr [rcx], 0
-;; 7090:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7099:	 800100               	add	byte ptr [rcx], 0
-;; 709c:	 aa                   	stosb	byte ptr [rdi], al
-;; 709d:	 800100               	add	byte ptr [rcx], 0
-;; 70a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 70a9:	 800100               	add	byte ptr [rcx], 0
-;; 70ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 70ad:	 800100               	add	byte ptr [rcx], 0
-;; 70b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 70b9:	 800100               	add	byte ptr [rcx], 0
-;; 70bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 70bd:	 800100               	add	byte ptr [rcx], 0
-;; 70c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 70c9:	 800100               	add	byte ptr [rcx], 0
-;; 70cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 70cd:	 800100               	add	byte ptr [rcx], 0
-;; 70d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 70d9:	 800100               	add	byte ptr [rcx], 0
-;; 70dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 70dd:	 800100               	add	byte ptr [rcx], 0
-;; 70e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 70e9:	 800100               	add	byte ptr [rcx], 0
-;; 70ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 70ed:	 800100               	add	byte ptr [rcx], 0
-;; 70f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 70f9:	 800100               	add	byte ptr [rcx], 0
-;; 70fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 70fd:	 800100               	add	byte ptr [rcx], 0
-;; 7100:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7109:	 800100               	add	byte ptr [rcx], 0
-;; 710c:	 aa                   	stosb	byte ptr [rdi], al
-;; 710d:	 800100               	add	byte ptr [rcx], 0
-;; 7110:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7119:	 800100               	add	byte ptr [rcx], 0
-;; 711c:	 aa                   	stosb	byte ptr [rdi], al
-;; 711d:	 800100               	add	byte ptr [rcx], 0
-;; 7120:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7129:	 800100               	add	byte ptr [rcx], 0
-;; 712c:	 aa                   	stosb	byte ptr [rdi], al
-;; 712d:	 800100               	add	byte ptr [rcx], 0
-;; 7130:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7139:	 800100               	add	byte ptr [rcx], 0
-;; 713c:	 aa                   	stosb	byte ptr [rdi], al
-;; 713d:	 800100               	add	byte ptr [rcx], 0
-;; 7140:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7149:	 800100               	add	byte ptr [rcx], 0
-;; 714c:	 aa                   	stosb	byte ptr [rdi], al
-;; 714d:	 800100               	add	byte ptr [rcx], 0
-;; 7150:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7159:	 800100               	add	byte ptr [rcx], 0
-;; 715c:	 aa                   	stosb	byte ptr [rdi], al
-;; 715d:	 800100               	add	byte ptr [rcx], 0
-;; 7160:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7169:	 800100               	add	byte ptr [rcx], 0
-;; 716c:	 aa                   	stosb	byte ptr [rdi], al
-;; 716d:	 800100               	add	byte ptr [rcx], 0
-;; 7170:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7179:	 800100               	add	byte ptr [rcx], 0
-;; 717c:	 aa                   	stosb	byte ptr [rdi], al
-;; 717d:	 800100               	add	byte ptr [rcx], 0
-;; 7180:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7189:	 800100               	add	byte ptr [rcx], 0
-;; 718c:	 aa                   	stosb	byte ptr [rdi], al
-;; 718d:	 800100               	add	byte ptr [rcx], 0
-;; 7190:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7199:	 800100               	add	byte ptr [rcx], 0
-;; 719c:	 aa                   	stosb	byte ptr [rdi], al
-;; 719d:	 800100               	add	byte ptr [rcx], 0
-;; 71a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 71a9:	 800100               	add	byte ptr [rcx], 0
-;; 71ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 71ad:	 800100               	add	byte ptr [rcx], 0
-;; 71b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 71b9:	 800100               	add	byte ptr [rcx], 0
-;; 71bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 71bd:	 800100               	add	byte ptr [rcx], 0
-;; 71c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 71c9:	 800100               	add	byte ptr [rcx], 0
-;; 71cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 71cd:	 800100               	add	byte ptr [rcx], 0
-;; 71d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 71d9:	 800100               	add	byte ptr [rcx], 0
-;; 71dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 71dd:	 800100               	add	byte ptr [rcx], 0
-;; 71e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 71e9:	 800100               	add	byte ptr [rcx], 0
-;; 71ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 71ed:	 800100               	add	byte ptr [rcx], 0
-;; 71f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 71f9:	 800100               	add	byte ptr [rcx], 0
-;; 71fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 71fd:	 800100               	add	byte ptr [rcx], 0
-;; 7200:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7209:	 800100               	add	byte ptr [rcx], 0
-;; 720c:	 aa                   	stosb	byte ptr [rdi], al
-;; 720d:	 800100               	add	byte ptr [rcx], 0
-;; 7210:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7219:	 800100               	add	byte ptr [rcx], 0
-;; 721c:	 aa                   	stosb	byte ptr [rdi], al
-;; 721d:	 800100               	add	byte ptr [rcx], 0
-;; 7220:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7229:	 800100               	add	byte ptr [rcx], 0
-;; 722c:	 aa                   	stosb	byte ptr [rdi], al
-;; 722d:	 800100               	add	byte ptr [rcx], 0
-;; 7230:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7239:	 800100               	add	byte ptr [rcx], 0
-;; 723c:	 aa                   	stosb	byte ptr [rdi], al
-;; 723d:	 800100               	add	byte ptr [rcx], 0
-;; 7240:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7249:	 800100               	add	byte ptr [rcx], 0
-;; 724c:	 aa                   	stosb	byte ptr [rdi], al
-;; 724d:	 800100               	add	byte ptr [rcx], 0
-;; 7250:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7259:	 800100               	add	byte ptr [rcx], 0
-;; 725c:	 aa                   	stosb	byte ptr [rdi], al
-;; 725d:	 800100               	add	byte ptr [rcx], 0
-;; 7260:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7269:	 800100               	add	byte ptr [rcx], 0
-;; 726c:	 aa                   	stosb	byte ptr [rdi], al
-;; 726d:	 800100               	add	byte ptr [rcx], 0
-;; 7270:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7279:	 800100               	add	byte ptr [rcx], 0
-;; 727c:	 aa                   	stosb	byte ptr [rdi], al
-;; 727d:	 800100               	add	byte ptr [rcx], 0
-;; 7280:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7289:	 800100               	add	byte ptr [rcx], 0
-;; 728c:	 aa                   	stosb	byte ptr [rdi], al
-;; 728d:	 800100               	add	byte ptr [rcx], 0
-;; 7290:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7299:	 800100               	add	byte ptr [rcx], 0
-;; 729c:	 aa                   	stosb	byte ptr [rdi], al
-;; 729d:	 800100               	add	byte ptr [rcx], 0
-;; 72a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 72a9:	 800100               	add	byte ptr [rcx], 0
-;; 72ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 72ad:	 800100               	add	byte ptr [rcx], 0
-;; 72b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 72b9:	 800100               	add	byte ptr [rcx], 0
-;; 72bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 72bd:	 800100               	add	byte ptr [rcx], 0
-;; 72c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 72c9:	 800100               	add	byte ptr [rcx], 0
-;; 72cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 72cd:	 800100               	add	byte ptr [rcx], 0
-;; 72d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 72d9:	 800100               	add	byte ptr [rcx], 0
-;; 72dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 72dd:	 800100               	add	byte ptr [rcx], 0
-;; 72e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 72e9:	 800100               	add	byte ptr [rcx], 0
-;; 72ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 72ed:	 800100               	add	byte ptr [rcx], 0
-;; 72f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 72f9:	 800100               	add	byte ptr [rcx], 0
-;; 72fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 72fd:	 800100               	add	byte ptr [rcx], 0
-;; 7300:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7309:	 800100               	add	byte ptr [rcx], 0
-;; 730c:	 aa                   	stosb	byte ptr [rdi], al
-;; 730d:	 800100               	add	byte ptr [rcx], 0
-;; 7310:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7319:	 800100               	add	byte ptr [rcx], 0
-;; 731c:	 aa                   	stosb	byte ptr [rdi], al
-;; 731d:	 800100               	add	byte ptr [rcx], 0
-;; 7320:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7329:	 800100               	add	byte ptr [rcx], 0
-;; 732c:	 aa                   	stosb	byte ptr [rdi], al
-;; 732d:	 800100               	add	byte ptr [rcx], 0
-;; 7330:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7339:	 800100               	add	byte ptr [rcx], 0
-;; 733c:	 aa                   	stosb	byte ptr [rdi], al
-;; 733d:	 800100               	add	byte ptr [rcx], 0
-;; 7340:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7349:	 800100               	add	byte ptr [rcx], 0
-;; 734c:	 aa                   	stosb	byte ptr [rdi], al
-;; 734d:	 800100               	add	byte ptr [rcx], 0
-;; 7350:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7359:	 800100               	add	byte ptr [rcx], 0
-;; 735c:	 aa                   	stosb	byte ptr [rdi], al
-;; 735d:	 800100               	add	byte ptr [rcx], 0
-;; 7360:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7369:	 800100               	add	byte ptr [rcx], 0
-;; 736c:	 aa                   	stosb	byte ptr [rdi], al
-;; 736d:	 800100               	add	byte ptr [rcx], 0
-;; 7370:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7379:	 800100               	add	byte ptr [rcx], 0
-;; 737c:	 aa                   	stosb	byte ptr [rdi], al
-;; 737d:	 800100               	add	byte ptr [rcx], 0
-;; 7380:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7389:	 800100               	add	byte ptr [rcx], 0
-;; 738c:	 aa                   	stosb	byte ptr [rdi], al
-;; 738d:	 800100               	add	byte ptr [rcx], 0
-;; 7390:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7399:	 800100               	add	byte ptr [rcx], 0
-;; 739c:	 aa                   	stosb	byte ptr [rdi], al
-;; 739d:	 800100               	add	byte ptr [rcx], 0
-;; 73a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 73a9:	 800100               	add	byte ptr [rcx], 0
-;; 73ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 73ad:	 800100               	add	byte ptr [rcx], 0
-;; 73b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 73b9:	 800100               	add	byte ptr [rcx], 0
-;; 73bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 73bd:	 800100               	add	byte ptr [rcx], 0
-;; 73c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 73c9:	 800100               	add	byte ptr [rcx], 0
-;; 73cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 73cd:	 800100               	add	byte ptr [rcx], 0
-;; 73d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 73d9:	 800100               	add	byte ptr [rcx], 0
-;; 73dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 73dd:	 800100               	add	byte ptr [rcx], 0
-;; 73e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 73e9:	 800100               	add	byte ptr [rcx], 0
-;; 73ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 73ed:	 800100               	add	byte ptr [rcx], 0
-;; 73f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 73f9:	 800100               	add	byte ptr [rcx], 0
-;; 73fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 73fd:	 800100               	add	byte ptr [rcx], 0
-;; 7400:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7409:	 800100               	add	byte ptr [rcx], 0
-;; 740c:	 aa                   	stosb	byte ptr [rdi], al
-;; 740d:	 800100               	add	byte ptr [rcx], 0
-;; 7410:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7419:	 800100               	add	byte ptr [rcx], 0
-;; 741c:	 aa                   	stosb	byte ptr [rdi], al
-;; 741d:	 800100               	add	byte ptr [rcx], 0
-;; 7420:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7429:	 800100               	add	byte ptr [rcx], 0
-;; 742c:	 aa                   	stosb	byte ptr [rdi], al
-;; 742d:	 800100               	add	byte ptr [rcx], 0
-;; 7430:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7439:	 800100               	add	byte ptr [rcx], 0
-;; 743c:	 aa                   	stosb	byte ptr [rdi], al
-;; 743d:	 800100               	add	byte ptr [rcx], 0
-;; 7440:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7449:	 800100               	add	byte ptr [rcx], 0
-;; 744c:	 aa                   	stosb	byte ptr [rdi], al
-;; 744d:	 800100               	add	byte ptr [rcx], 0
-;; 7450:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7459:	 800100               	add	byte ptr [rcx], 0
-;; 745c:	 aa                   	stosb	byte ptr [rdi], al
-;; 745d:	 800100               	add	byte ptr [rcx], 0
-;; 7460:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7469:	 800100               	add	byte ptr [rcx], 0
-;; 746c:	 aa                   	stosb	byte ptr [rdi], al
-;; 746d:	 800100               	add	byte ptr [rcx], 0
-;; 7470:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7479:	 800100               	add	byte ptr [rcx], 0
-;; 747c:	 aa                   	stosb	byte ptr [rdi], al
-;; 747d:	 800100               	add	byte ptr [rcx], 0
-;; 7480:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7489:	 800100               	add	byte ptr [rcx], 0
-;; 748c:	 aa                   	stosb	byte ptr [rdi], al
-;; 748d:	 800100               	add	byte ptr [rcx], 0
-;; 7490:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7499:	 800100               	add	byte ptr [rcx], 0
-;; 749c:	 aa                   	stosb	byte ptr [rdi], al
-;; 749d:	 800100               	add	byte ptr [rcx], 0
-;; 74a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 74a9:	 800100               	add	byte ptr [rcx], 0
-;; 74ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 74ad:	 800100               	add	byte ptr [rcx], 0
-;; 74b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 74b9:	 800100               	add	byte ptr [rcx], 0
-;; 74bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 74bd:	 800100               	add	byte ptr [rcx], 0
-;; 74c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 74c9:	 800100               	add	byte ptr [rcx], 0
-;; 74cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 74cd:	 800100               	add	byte ptr [rcx], 0
-;; 74d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 74d9:	 800100               	add	byte ptr [rcx], 0
-;; 74dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 74dd:	 800100               	add	byte ptr [rcx], 0
-;; 74e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 74e9:	 800100               	add	byte ptr [rcx], 0
-;; 74ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 74ed:	 800100               	add	byte ptr [rcx], 0
-;; 74f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 74f9:	 800100               	add	byte ptr [rcx], 0
-;; 74fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 74fd:	 800100               	add	byte ptr [rcx], 0
-;; 7500:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7509:	 800100               	add	byte ptr [rcx], 0
-;; 750c:	 aa                   	stosb	byte ptr [rdi], al
-;; 750d:	 800100               	add	byte ptr [rcx], 0
-;; 7510:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7519:	 800100               	add	byte ptr [rcx], 0
-;; 751c:	 aa                   	stosb	byte ptr [rdi], al
-;; 751d:	 800100               	add	byte ptr [rcx], 0
-;; 7520:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7529:	 800100               	add	byte ptr [rcx], 0
-;; 752c:	 aa                   	stosb	byte ptr [rdi], al
-;; 752d:	 800100               	add	byte ptr [rcx], 0
-;; 7530:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7539:	 800100               	add	byte ptr [rcx], 0
-;; 753c:	 aa                   	stosb	byte ptr [rdi], al
-;; 753d:	 800100               	add	byte ptr [rcx], 0
-;; 7540:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7549:	 800100               	add	byte ptr [rcx], 0
-;; 754c:	 aa                   	stosb	byte ptr [rdi], al
-;; 754d:	 800100               	add	byte ptr [rcx], 0
-;; 7550:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7559:	 800100               	add	byte ptr [rcx], 0
-;; 755c:	 aa                   	stosb	byte ptr [rdi], al
-;; 755d:	 800100               	add	byte ptr [rcx], 0
-;; 7560:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7569:	 800100               	add	byte ptr [rcx], 0
-;; 756c:	 aa                   	stosb	byte ptr [rdi], al
-;; 756d:	 800100               	add	byte ptr [rcx], 0
-;; 7570:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7579:	 800100               	add	byte ptr [rcx], 0
-;; 757c:	 aa                   	stosb	byte ptr [rdi], al
-;; 757d:	 800100               	add	byte ptr [rcx], 0
-;; 7580:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7589:	 800100               	add	byte ptr [rcx], 0
-;; 758c:	 aa                   	stosb	byte ptr [rdi], al
-;; 758d:	 800100               	add	byte ptr [rcx], 0
-;; 7590:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7599:	 800100               	add	byte ptr [rcx], 0
-;; 759c:	 aa                   	stosb	byte ptr [rdi], al
-;; 759d:	 800100               	add	byte ptr [rcx], 0
-;; 75a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 75a9:	 800100               	add	byte ptr [rcx], 0
-;; 75ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 75ad:	 800100               	add	byte ptr [rcx], 0
-;; 75b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 75b9:	 800100               	add	byte ptr [rcx], 0
-;; 75bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 75bd:	 800100               	add	byte ptr [rcx], 0
-;; 75c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 75c9:	 800100               	add	byte ptr [rcx], 0
-;; 75cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 75cd:	 800100               	add	byte ptr [rcx], 0
-;; 75d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 75d9:	 800100               	add	byte ptr [rcx], 0
-;; 75dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 75dd:	 800100               	add	byte ptr [rcx], 0
-;; 75e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 75e9:	 800100               	add	byte ptr [rcx], 0
-;; 75ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 75ed:	 800100               	add	byte ptr [rcx], 0
-;; 75f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 75f9:	 800100               	add	byte ptr [rcx], 0
-;; 75fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 75fd:	 800100               	add	byte ptr [rcx], 0
-;; 7600:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7609:	 800100               	add	byte ptr [rcx], 0
-;; 760c:	 aa                   	stosb	byte ptr [rdi], al
-;; 760d:	 800100               	add	byte ptr [rcx], 0
-;; 7610:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7619:	 800100               	add	byte ptr [rcx], 0
-;; 761c:	 aa                   	stosb	byte ptr [rdi], al
-;; 761d:	 800100               	add	byte ptr [rcx], 0
-;; 7620:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7629:	 800100               	add	byte ptr [rcx], 0
-;; 762c:	 aa                   	stosb	byte ptr [rdi], al
-;; 762d:	 800100               	add	byte ptr [rcx], 0
-;; 7630:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7639:	 800100               	add	byte ptr [rcx], 0
-;; 763c:	 aa                   	stosb	byte ptr [rdi], al
-;; 763d:	 800100               	add	byte ptr [rcx], 0
-;; 7640:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7649:	 800100               	add	byte ptr [rcx], 0
-;; 764c:	 aa                   	stosb	byte ptr [rdi], al
-;; 764d:	 800100               	add	byte ptr [rcx], 0
-;; 7650:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7659:	 800100               	add	byte ptr [rcx], 0
-;; 765c:	 aa                   	stosb	byte ptr [rdi], al
-;; 765d:	 800100               	add	byte ptr [rcx], 0
-;; 7660:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7669:	 800100               	add	byte ptr [rcx], 0
-;; 766c:	 aa                   	stosb	byte ptr [rdi], al
-;; 766d:	 800100               	add	byte ptr [rcx], 0
-;; 7670:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7679:	 800100               	add	byte ptr [rcx], 0
-;; 767c:	 aa                   	stosb	byte ptr [rdi], al
-;; 767d:	 800100               	add	byte ptr [rcx], 0
-;; 7680:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7689:	 800100               	add	byte ptr [rcx], 0
-;; 768c:	 aa                   	stosb	byte ptr [rdi], al
-;; 768d:	 800100               	add	byte ptr [rcx], 0
-;; 7690:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7699:	 800100               	add	byte ptr [rcx], 0
-;; 769c:	 aa                   	stosb	byte ptr [rdi], al
-;; 769d:	 800100               	add	byte ptr [rcx], 0
-;; 76a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 76a9:	 800100               	add	byte ptr [rcx], 0
-;; 76ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 76ad:	 800100               	add	byte ptr [rcx], 0
-;; 76b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 76b9:	 800100               	add	byte ptr [rcx], 0
-;; 76bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 76bd:	 800100               	add	byte ptr [rcx], 0
-;; 76c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 76c9:	 800100               	add	byte ptr [rcx], 0
-;; 76cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 76cd:	 800100               	add	byte ptr [rcx], 0
-;; 76d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 76d9:	 800100               	add	byte ptr [rcx], 0
-;; 76dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 76dd:	 800100               	add	byte ptr [rcx], 0
-;; 76e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 76e9:	 800100               	add	byte ptr [rcx], 0
-;; 76ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 76ed:	 800100               	add	byte ptr [rcx], 0
-;; 76f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 76f9:	 800100               	add	byte ptr [rcx], 0
-;; 76fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 76fd:	 800100               	add	byte ptr [rcx], 0
-;; 7700:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7709:	 800100               	add	byte ptr [rcx], 0
-;; 770c:	 aa                   	stosb	byte ptr [rdi], al
-;; 770d:	 800100               	add	byte ptr [rcx], 0
-;; 7710:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7719:	 800100               	add	byte ptr [rcx], 0
-;; 771c:	 aa                   	stosb	byte ptr [rdi], al
-;; 771d:	 800100               	add	byte ptr [rcx], 0
-;; 7720:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7729:	 800100               	add	byte ptr [rcx], 0
-;; 772c:	 aa                   	stosb	byte ptr [rdi], al
-;; 772d:	 800100               	add	byte ptr [rcx], 0
-;; 7730:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7739:	 800100               	add	byte ptr [rcx], 0
-;; 773c:	 aa                   	stosb	byte ptr [rdi], al
-;; 773d:	 800100               	add	byte ptr [rcx], 0
-;; 7740:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7749:	 800100               	add	byte ptr [rcx], 0
-;; 774c:	 aa                   	stosb	byte ptr [rdi], al
-;; 774d:	 800100               	add	byte ptr [rcx], 0
-;; 7750:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7759:	 800100               	add	byte ptr [rcx], 0
-;; 775c:	 aa                   	stosb	byte ptr [rdi], al
-;; 775d:	 800100               	add	byte ptr [rcx], 0
-;; 7760:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7769:	 800100               	add	byte ptr [rcx], 0
-;; 776c:	 aa                   	stosb	byte ptr [rdi], al
-;; 776d:	 800100               	add	byte ptr [rcx], 0
-;; 7770:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7779:	 800100               	add	byte ptr [rcx], 0
-;; 777c:	 aa                   	stosb	byte ptr [rdi], al
-;; 777d:	 800100               	add	byte ptr [rcx], 0
-;; 7780:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7789:	 800100               	add	byte ptr [rcx], 0
-;; 778c:	 aa                   	stosb	byte ptr [rdi], al
-;; 778d:	 800100               	add	byte ptr [rcx], 0
-;; 7790:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7799:	 800100               	add	byte ptr [rcx], 0
-;; 779c:	 aa                   	stosb	byte ptr [rdi], al
-;; 779d:	 800100               	add	byte ptr [rcx], 0
-;; 77a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 77a9:	 800100               	add	byte ptr [rcx], 0
-;; 77ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 77ad:	 800100               	add	byte ptr [rcx], 0
-;; 77b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 77b9:	 800100               	add	byte ptr [rcx], 0
-;; 77bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 77bd:	 800100               	add	byte ptr [rcx], 0
-;; 77c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 77c9:	 800100               	add	byte ptr [rcx], 0
-;; 77cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 77cd:	 800100               	add	byte ptr [rcx], 0
-;; 77d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 77d9:	 800100               	add	byte ptr [rcx], 0
-;; 77dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 77dd:	 800100               	add	byte ptr [rcx], 0
-;; 77e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 77e9:	 800100               	add	byte ptr [rcx], 0
-;; 77ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 77ed:	 800100               	add	byte ptr [rcx], 0
-;; 77f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 77f9:	 800100               	add	byte ptr [rcx], 0
-;; 77fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 77fd:	 800100               	add	byte ptr [rcx], 0
-;; 7800:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7809:	 800100               	add	byte ptr [rcx], 0
-;; 780c:	 aa                   	stosb	byte ptr [rdi], al
-;; 780d:	 800100               	add	byte ptr [rcx], 0
-;; 7810:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7819:	 800100               	add	byte ptr [rcx], 0
-;; 781c:	 aa                   	stosb	byte ptr [rdi], al
-;; 781d:	 800100               	add	byte ptr [rcx], 0
-;; 7820:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7829:	 800100               	add	byte ptr [rcx], 0
-;; 782c:	 aa                   	stosb	byte ptr [rdi], al
-;; 782d:	 800100               	add	byte ptr [rcx], 0
-;; 7830:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7839:	 800100               	add	byte ptr [rcx], 0
-;; 783c:	 aa                   	stosb	byte ptr [rdi], al
-;; 783d:	 800100               	add	byte ptr [rcx], 0
-;; 7840:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7849:	 800100               	add	byte ptr [rcx], 0
-;; 784c:	 aa                   	stosb	byte ptr [rdi], al
-;; 784d:	 800100               	add	byte ptr [rcx], 0
-;; 7850:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7859:	 800100               	add	byte ptr [rcx], 0
-;; 785c:	 aa                   	stosb	byte ptr [rdi], al
-;; 785d:	 800100               	add	byte ptr [rcx], 0
-;; 7860:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7869:	 800100               	add	byte ptr [rcx], 0
-;; 786c:	 aa                   	stosb	byte ptr [rdi], al
-;; 786d:	 800100               	add	byte ptr [rcx], 0
-;; 7870:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7879:	 800100               	add	byte ptr [rcx], 0
-;; 787c:	 aa                   	stosb	byte ptr [rdi], al
-;; 787d:	 800100               	add	byte ptr [rcx], 0
-;; 7880:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7889:	 800100               	add	byte ptr [rcx], 0
-;; 788c:	 aa                   	stosb	byte ptr [rdi], al
-;; 788d:	 800100               	add	byte ptr [rcx], 0
-;; 7890:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7899:	 800100               	add	byte ptr [rcx], 0
-;; 789c:	 aa                   	stosb	byte ptr [rdi], al
-;; 789d:	 800100               	add	byte ptr [rcx], 0
-;; 78a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 78a9:	 800100               	add	byte ptr [rcx], 0
-;; 78ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 78ad:	 800100               	add	byte ptr [rcx], 0
-;; 78b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 78b9:	 800100               	add	byte ptr [rcx], 0
-;; 78bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 78bd:	 800100               	add	byte ptr [rcx], 0
-;; 78c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 78c9:	 800100               	add	byte ptr [rcx], 0
-;; 78cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 78cd:	 800100               	add	byte ptr [rcx], 0
-;; 78d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 78d9:	 800100               	add	byte ptr [rcx], 0
-;; 78dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 78dd:	 800100               	add	byte ptr [rcx], 0
-;; 78e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 78e9:	 800100               	add	byte ptr [rcx], 0
-;; 78ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 78ed:	 800100               	add	byte ptr [rcx], 0
-;; 78f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 78f9:	 800100               	add	byte ptr [rcx], 0
-;; 78fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 78fd:	 800100               	add	byte ptr [rcx], 0
-;; 7900:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7909:	 800100               	add	byte ptr [rcx], 0
-;; 790c:	 aa                   	stosb	byte ptr [rdi], al
-;; 790d:	 800100               	add	byte ptr [rcx], 0
-;; 7910:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7919:	 800100               	add	byte ptr [rcx], 0
-;; 791c:	 aa                   	stosb	byte ptr [rdi], al
-;; 791d:	 800100               	add	byte ptr [rcx], 0
-;; 7920:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7929:	 800100               	add	byte ptr [rcx], 0
-;; 792c:	 aa                   	stosb	byte ptr [rdi], al
-;; 792d:	 800100               	add	byte ptr [rcx], 0
-;; 7930:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7939:	 800100               	add	byte ptr [rcx], 0
-;; 793c:	 aa                   	stosb	byte ptr [rdi], al
-;; 793d:	 800100               	add	byte ptr [rcx], 0
-;; 7940:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7949:	 800100               	add	byte ptr [rcx], 0
-;; 794c:	 aa                   	stosb	byte ptr [rdi], al
-;; 794d:	 800100               	add	byte ptr [rcx], 0
-;; 7950:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7959:	 800100               	add	byte ptr [rcx], 0
-;; 795c:	 aa                   	stosb	byte ptr [rdi], al
-;; 795d:	 800100               	add	byte ptr [rcx], 0
-;; 7960:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7969:	 800100               	add	byte ptr [rcx], 0
-;; 796c:	 aa                   	stosb	byte ptr [rdi], al
-;; 796d:	 800100               	add	byte ptr [rcx], 0
-;; 7970:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7979:	 800100               	add	byte ptr [rcx], 0
-;; 797c:	 aa                   	stosb	byte ptr [rdi], al
-;; 797d:	 800100               	add	byte ptr [rcx], 0
-;; 7980:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7989:	 800100               	add	byte ptr [rcx], 0
-;; 798c:	 aa                   	stosb	byte ptr [rdi], al
-;; 798d:	 800100               	add	byte ptr [rcx], 0
-;; 7990:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7999:	 800100               	add	byte ptr [rcx], 0
-;; 799c:	 aa                   	stosb	byte ptr [rdi], al
-;; 799d:	 800100               	add	byte ptr [rcx], 0
-;; 79a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 79a9:	 800100               	add	byte ptr [rcx], 0
-;; 79ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 79ad:	 800100               	add	byte ptr [rcx], 0
-;; 79b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 79b9:	 800100               	add	byte ptr [rcx], 0
-;; 79bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 79bd:	 800100               	add	byte ptr [rcx], 0
-;; 79c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 79c9:	 800100               	add	byte ptr [rcx], 0
-;; 79cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 79cd:	 800100               	add	byte ptr [rcx], 0
-;; 79d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 79d9:	 800100               	add	byte ptr [rcx], 0
-;; 79dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 79dd:	 800100               	add	byte ptr [rcx], 0
-;; 79e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 79e9:	 800100               	add	byte ptr [rcx], 0
-;; 79ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 79ed:	 800100               	add	byte ptr [rcx], 0
-;; 79f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 79f9:	 800100               	add	byte ptr [rcx], 0
-;; 79fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 79fd:	 800100               	add	byte ptr [rcx], 0
-;; 7a00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7a09:	 800100               	add	byte ptr [rcx], 0
-;; 7a0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7a0d:	 800100               	add	byte ptr [rcx], 0
-;; 7a10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7a19:	 800100               	add	byte ptr [rcx], 0
-;; 7a1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7a1d:	 800100               	add	byte ptr [rcx], 0
-;; 7a20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7a29:	 800100               	add	byte ptr [rcx], 0
-;; 7a2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7a2d:	 800100               	add	byte ptr [rcx], 0
-;; 7a30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7a39:	 800100               	add	byte ptr [rcx], 0
-;; 7a3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7a3d:	 800100               	add	byte ptr [rcx], 0
-;; 7a40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7a49:	 800100               	add	byte ptr [rcx], 0
-;; 7a4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7a4d:	 800100               	add	byte ptr [rcx], 0
-;; 7a50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7a59:	 800100               	add	byte ptr [rcx], 0
-;; 7a5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7a5d:	 800100               	add	byte ptr [rcx], 0
-;; 7a60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7a69:	 800100               	add	byte ptr [rcx], 0
-;; 7a6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7a6d:	 800100               	add	byte ptr [rcx], 0
-;; 7a70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7a79:	 800100               	add	byte ptr [rcx], 0
-;; 7a7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7a7d:	 800100               	add	byte ptr [rcx], 0
-;; 7a80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7a89:	 800100               	add	byte ptr [rcx], 0
-;; 7a8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7a8d:	 800100               	add	byte ptr [rcx], 0
-;; 7a90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7a99:	 800100               	add	byte ptr [rcx], 0
-;; 7a9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7a9d:	 800100               	add	byte ptr [rcx], 0
-;; 7aa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7aa9:	 800100               	add	byte ptr [rcx], 0
-;; 7aac:	 aa                   	stosb	byte ptr [rdi], al
-;; 7aad:	 800100               	add	byte ptr [rcx], 0
-;; 7ab0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7ab9:	 800100               	add	byte ptr [rcx], 0
-;; 7abc:	 aa                   	stosb	byte ptr [rdi], al
-;; 7abd:	 800100               	add	byte ptr [rcx], 0
-;; 7ac0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7ac9:	 800100               	add	byte ptr [rcx], 0
-;; 7acc:	 aa                   	stosb	byte ptr [rdi], al
-;; 7acd:	 800100               	add	byte ptr [rcx], 0
-;; 7ad0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7ad9:	 800100               	add	byte ptr [rcx], 0
-;; 7adc:	 aa                   	stosb	byte ptr [rdi], al
-;; 7add:	 800100               	add	byte ptr [rcx], 0
-;; 7ae0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7ae9:	 800100               	add	byte ptr [rcx], 0
-;; 7aec:	 aa                   	stosb	byte ptr [rdi], al
-;; 7aed:	 800100               	add	byte ptr [rcx], 0
-;; 7af0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7af9:	 800100               	add	byte ptr [rcx], 0
-;; 7afc:	 aa                   	stosb	byte ptr [rdi], al
-;; 7afd:	 800100               	add	byte ptr [rcx], 0
-;; 7b00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7b09:	 800100               	add	byte ptr [rcx], 0
-;; 7b0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7b0d:	 800100               	add	byte ptr [rcx], 0
-;; 7b10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7b19:	 800100               	add	byte ptr [rcx], 0
-;; 7b1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7b1d:	 800100               	add	byte ptr [rcx], 0
-;; 7b20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7b29:	 800100               	add	byte ptr [rcx], 0
-;; 7b2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7b2d:	 800100               	add	byte ptr [rcx], 0
-;; 7b30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7b39:	 800100               	add	byte ptr [rcx], 0
-;; 7b3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7b3d:	 800100               	add	byte ptr [rcx], 0
-;; 7b40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7b49:	 800100               	add	byte ptr [rcx], 0
-;; 7b4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7b4d:	 800100               	add	byte ptr [rcx], 0
-;; 7b50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7b59:	 800100               	add	byte ptr [rcx], 0
-;; 7b5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7b5d:	 800100               	add	byte ptr [rcx], 0
-;; 7b60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7b69:	 800100               	add	byte ptr [rcx], 0
-;; 7b6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7b6d:	 800100               	add	byte ptr [rcx], 0
-;; 7b70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7b79:	 800100               	add	byte ptr [rcx], 0
-;; 7b7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7b7d:	 800100               	add	byte ptr [rcx], 0
-;; 7b80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7b89:	 800100               	add	byte ptr [rcx], 0
-;; 7b8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7b8d:	 800100               	add	byte ptr [rcx], 0
-;; 7b90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7b99:	 800100               	add	byte ptr [rcx], 0
-;; 7b9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7b9d:	 800100               	add	byte ptr [rcx], 0
-;; 7ba0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7ba9:	 800100               	add	byte ptr [rcx], 0
-;; 7bac:	 aa                   	stosb	byte ptr [rdi], al
-;; 7bad:	 800100               	add	byte ptr [rcx], 0
-;; 7bb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7bb9:	 800100               	add	byte ptr [rcx], 0
-;; 7bbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 7bbd:	 800100               	add	byte ptr [rcx], 0
-;; 7bc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7bc9:	 800100               	add	byte ptr [rcx], 0
-;; 7bcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 7bcd:	 800100               	add	byte ptr [rcx], 0
-;; 7bd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7bd9:	 800100               	add	byte ptr [rcx], 0
-;; 7bdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 7bdd:	 800100               	add	byte ptr [rcx], 0
-;; 7be0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7be9:	 800100               	add	byte ptr [rcx], 0
-;; 7bec:	 aa                   	stosb	byte ptr [rdi], al
-;; 7bed:	 800100               	add	byte ptr [rcx], 0
-;; 7bf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7bf9:	 800100               	add	byte ptr [rcx], 0
-;; 7bfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 7bfd:	 800100               	add	byte ptr [rcx], 0
-;; 7c00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7c09:	 800100               	add	byte ptr [rcx], 0
-;; 7c0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7c0d:	 800100               	add	byte ptr [rcx], 0
-;; 7c10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7c19:	 800100               	add	byte ptr [rcx], 0
-;; 7c1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7c1d:	 800100               	add	byte ptr [rcx], 0
-;; 7c20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7c29:	 800100               	add	byte ptr [rcx], 0
-;; 7c2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7c2d:	 800100               	add	byte ptr [rcx], 0
-;; 7c30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7c39:	 800100               	add	byte ptr [rcx], 0
-;; 7c3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7c3d:	 800100               	add	byte ptr [rcx], 0
-;; 7c40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7c49:	 800100               	add	byte ptr [rcx], 0
-;; 7c4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7c4d:	 800100               	add	byte ptr [rcx], 0
-;; 7c50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7c59:	 800100               	add	byte ptr [rcx], 0
-;; 7c5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7c5d:	 800100               	add	byte ptr [rcx], 0
-;; 7c60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7c69:	 800100               	add	byte ptr [rcx], 0
-;; 7c6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7c6d:	 800100               	add	byte ptr [rcx], 0
-;; 7c70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7c79:	 800100               	add	byte ptr [rcx], 0
-;; 7c7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7c7d:	 800100               	add	byte ptr [rcx], 0
-;; 7c80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7c89:	 800100               	add	byte ptr [rcx], 0
-;; 7c8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7c8d:	 800100               	add	byte ptr [rcx], 0
-;; 7c90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7c99:	 800100               	add	byte ptr [rcx], 0
-;; 7c9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7c9d:	 800100               	add	byte ptr [rcx], 0
-;; 7ca0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7ca9:	 800100               	add	byte ptr [rcx], 0
-;; 7cac:	 aa                   	stosb	byte ptr [rdi], al
-;; 7cad:	 800100               	add	byte ptr [rcx], 0
-;; 7cb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7cb9:	 800100               	add	byte ptr [rcx], 0
-;; 7cbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 7cbd:	 800100               	add	byte ptr [rcx], 0
-;; 7cc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7cc9:	 800100               	add	byte ptr [rcx], 0
-;; 7ccc:	 aa                   	stosb	byte ptr [rdi], al
-;; 7ccd:	 800100               	add	byte ptr [rcx], 0
-;; 7cd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7cd9:	 800100               	add	byte ptr [rcx], 0
-;; 7cdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 7cdd:	 800100               	add	byte ptr [rcx], 0
-;; 7ce0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7ce9:	 800100               	add	byte ptr [rcx], 0
-;; 7cec:	 aa                   	stosb	byte ptr [rdi], al
-;; 7ced:	 800100               	add	byte ptr [rcx], 0
-;; 7cf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7cf9:	 800100               	add	byte ptr [rcx], 0
-;; 7cfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 7cfd:	 800100               	add	byte ptr [rcx], 0
-;; 7d00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7d09:	 800100               	add	byte ptr [rcx], 0
-;; 7d0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7d0d:	 800100               	add	byte ptr [rcx], 0
-;; 7d10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7d19:	 800100               	add	byte ptr [rcx], 0
-;; 7d1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7d1d:	 800100               	add	byte ptr [rcx], 0
-;; 7d20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7d29:	 800100               	add	byte ptr [rcx], 0
-;; 7d2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7d2d:	 800100               	add	byte ptr [rcx], 0
-;; 7d30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7d39:	 800100               	add	byte ptr [rcx], 0
-;; 7d3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7d3d:	 800100               	add	byte ptr [rcx], 0
-;; 7d40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7d49:	 800100               	add	byte ptr [rcx], 0
-;; 7d4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7d4d:	 800100               	add	byte ptr [rcx], 0
-;; 7d50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7d59:	 800100               	add	byte ptr [rcx], 0
-;; 7d5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7d5d:	 800100               	add	byte ptr [rcx], 0
-;; 7d60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7d69:	 800100               	add	byte ptr [rcx], 0
-;; 7d6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7d6d:	 800100               	add	byte ptr [rcx], 0
-;; 7d70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7d79:	 800100               	add	byte ptr [rcx], 0
-;; 7d7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7d7d:	 800100               	add	byte ptr [rcx], 0
-;; 7d80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7d89:	 800100               	add	byte ptr [rcx], 0
-;; 7d8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7d8d:	 800100               	add	byte ptr [rcx], 0
-;; 7d90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7d99:	 800100               	add	byte ptr [rcx], 0
-;; 7d9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7d9d:	 800100               	add	byte ptr [rcx], 0
-;; 7da0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7da9:	 800100               	add	byte ptr [rcx], 0
-;; 7dac:	 aa                   	stosb	byte ptr [rdi], al
-;; 7dad:	 800100               	add	byte ptr [rcx], 0
-;; 7db0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7db9:	 800100               	add	byte ptr [rcx], 0
-;; 7dbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 7dbd:	 800100               	add	byte ptr [rcx], 0
-;; 7dc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7dc9:	 800100               	add	byte ptr [rcx], 0
-;; 7dcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 7dcd:	 800100               	add	byte ptr [rcx], 0
-;; 7dd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7dd9:	 800100               	add	byte ptr [rcx], 0
-;; 7ddc:	 aa                   	stosb	byte ptr [rdi], al
-;; 7ddd:	 800100               	add	byte ptr [rcx], 0
-;; 7de0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7de9:	 800100               	add	byte ptr [rcx], 0
-;; 7dec:	 aa                   	stosb	byte ptr [rdi], al
-;; 7ded:	 800100               	add	byte ptr [rcx], 0
-;; 7df0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7df9:	 800100               	add	byte ptr [rcx], 0
-;; 7dfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 7dfd:	 800100               	add	byte ptr [rcx], 0
-;; 7e00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7e09:	 800100               	add	byte ptr [rcx], 0
-;; 7e0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7e0d:	 800100               	add	byte ptr [rcx], 0
-;; 7e10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7e19:	 800100               	add	byte ptr [rcx], 0
-;; 7e1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7e1d:	 800100               	add	byte ptr [rcx], 0
-;; 7e20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7e29:	 800100               	add	byte ptr [rcx], 0
-;; 7e2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7e2d:	 800100               	add	byte ptr [rcx], 0
-;; 7e30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7e39:	 800100               	add	byte ptr [rcx], 0
-;; 7e3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7e3d:	 800100               	add	byte ptr [rcx], 0
-;; 7e40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7e49:	 800100               	add	byte ptr [rcx], 0
-;; 7e4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7e4d:	 800100               	add	byte ptr [rcx], 0
-;; 7e50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7e59:	 800100               	add	byte ptr [rcx], 0
-;; 7e5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7e5d:	 800100               	add	byte ptr [rcx], 0
-;; 7e60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7e69:	 800100               	add	byte ptr [rcx], 0
-;; 7e6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7e6d:	 800100               	add	byte ptr [rcx], 0
-;; 7e70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7e79:	 800100               	add	byte ptr [rcx], 0
-;; 7e7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7e7d:	 800100               	add	byte ptr [rcx], 0
-;; 7e80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7e89:	 800100               	add	byte ptr [rcx], 0
-;; 7e8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7e8d:	 800100               	add	byte ptr [rcx], 0
-;; 7e90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7e99:	 800100               	add	byte ptr [rcx], 0
-;; 7e9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7e9d:	 800100               	add	byte ptr [rcx], 0
-;; 7ea0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7ea9:	 800100               	add	byte ptr [rcx], 0
-;; 7eac:	 aa                   	stosb	byte ptr [rdi], al
-;; 7ead:	 800100               	add	byte ptr [rcx], 0
-;; 7eb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7eb9:	 800100               	add	byte ptr [rcx], 0
-;; 7ebc:	 aa                   	stosb	byte ptr [rdi], al
-;; 7ebd:	 800100               	add	byte ptr [rcx], 0
-;; 7ec0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7ec9:	 800100               	add	byte ptr [rcx], 0
-;; 7ecc:	 aa                   	stosb	byte ptr [rdi], al
-;; 7ecd:	 800100               	add	byte ptr [rcx], 0
-;; 7ed0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7ed9:	 800100               	add	byte ptr [rcx], 0
-;; 7edc:	 aa                   	stosb	byte ptr [rdi], al
-;; 7edd:	 800100               	add	byte ptr [rcx], 0
-;; 7ee0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7ee9:	 800100               	add	byte ptr [rcx], 0
-;; 7eec:	 aa                   	stosb	byte ptr [rdi], al
-;; 7eed:	 800100               	add	byte ptr [rcx], 0
-;; 7ef0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7ef9:	 800100               	add	byte ptr [rcx], 0
-;; 7efc:	 aa                   	stosb	byte ptr [rdi], al
-;; 7efd:	 800100               	add	byte ptr [rcx], 0
-;; 7f00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7f09:	 800100               	add	byte ptr [rcx], 0
-;; 7f0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7f0d:	 800100               	add	byte ptr [rcx], 0
-;; 7f10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7f19:	 800100               	add	byte ptr [rcx], 0
-;; 7f1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7f1d:	 800100               	add	byte ptr [rcx], 0
-;; 7f20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7f29:	 800100               	add	byte ptr [rcx], 0
-;; 7f2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7f2d:	 800100               	add	byte ptr [rcx], 0
-;; 7f30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7f39:	 800100               	add	byte ptr [rcx], 0
-;; 7f3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7f3d:	 800100               	add	byte ptr [rcx], 0
-;; 7f40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7f49:	 800100               	add	byte ptr [rcx], 0
-;; 7f4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7f4d:	 800100               	add	byte ptr [rcx], 0
-;; 7f50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7f59:	 800100               	add	byte ptr [rcx], 0
-;; 7f5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7f5d:	 800100               	add	byte ptr [rcx], 0
-;; 7f60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7f69:	 800100               	add	byte ptr [rcx], 0
-;; 7f6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7f6d:	 800100               	add	byte ptr [rcx], 0
-;; 7f70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7f79:	 800100               	add	byte ptr [rcx], 0
-;; 7f7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7f7d:	 800100               	add	byte ptr [rcx], 0
-;; 7f80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7f89:	 800100               	add	byte ptr [rcx], 0
-;; 7f8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7f8d:	 800100               	add	byte ptr [rcx], 0
-;; 7f90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7f99:	 800100               	add	byte ptr [rcx], 0
-;; 7f9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 7f9d:	 800100               	add	byte ptr [rcx], 0
-;; 7fa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7fa9:	 800100               	add	byte ptr [rcx], 0
-;; 7fac:	 aa                   	stosb	byte ptr [rdi], al
-;; 7fad:	 800100               	add	byte ptr [rcx], 0
-;; 7fb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7fb9:	 800100               	add	byte ptr [rcx], 0
-;; 7fbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 7fbd:	 800100               	add	byte ptr [rcx], 0
-;; 7fc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7fc9:	 800100               	add	byte ptr [rcx], 0
-;; 7fcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 7fcd:	 800100               	add	byte ptr [rcx], 0
-;; 7fd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7fd9:	 800100               	add	byte ptr [rcx], 0
-;; 7fdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 7fdd:	 800100               	add	byte ptr [rcx], 0
-;; 7fe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7fe9:	 800100               	add	byte ptr [rcx], 0
-;; 7fec:	 aa                   	stosb	byte ptr [rdi], al
-;; 7fed:	 800100               	add	byte ptr [rcx], 0
-;; 7ff0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 7ff9:	 800100               	add	byte ptr [rcx], 0
-;; 7ffc:	 aa                   	stosb	byte ptr [rdi], al
-;; 7ffd:	 800100               	add	byte ptr [rcx], 0
-;; 8000:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8009:	 800100               	add	byte ptr [rcx], 0
-;; 800c:	 aa                   	stosb	byte ptr [rdi], al
-;; 800d:	 800100               	add	byte ptr [rcx], 0
-;; 8010:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8019:	 800100               	add	byte ptr [rcx], 0
-;; 801c:	 aa                   	stosb	byte ptr [rdi], al
-;; 801d:	 800100               	add	byte ptr [rcx], 0
-;; 8020:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8029:	 800100               	add	byte ptr [rcx], 0
-;; 802c:	 aa                   	stosb	byte ptr [rdi], al
-;; 802d:	 800100               	add	byte ptr [rcx], 0
-;; 8030:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8039:	 800100               	add	byte ptr [rcx], 0
-;; 803c:	 aa                   	stosb	byte ptr [rdi], al
-;; 803d:	 800100               	add	byte ptr [rcx], 0
-;; 8040:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8049:	 800100               	add	byte ptr [rcx], 0
-;; 804c:	 aa                   	stosb	byte ptr [rdi], al
-;; 804d:	 800100               	add	byte ptr [rcx], 0
-;; 8050:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8059:	 800100               	add	byte ptr [rcx], 0
-;; 805c:	 aa                   	stosb	byte ptr [rdi], al
-;; 805d:	 800100               	add	byte ptr [rcx], 0
-;; 8060:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8069:	 800100               	add	byte ptr [rcx], 0
-;; 806c:	 aa                   	stosb	byte ptr [rdi], al
-;; 806d:	 800100               	add	byte ptr [rcx], 0
-;; 8070:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8079:	 800100               	add	byte ptr [rcx], 0
-;; 807c:	 aa                   	stosb	byte ptr [rdi], al
-;; 807d:	 800100               	add	byte ptr [rcx], 0
-;; 8080:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8089:	 800100               	add	byte ptr [rcx], 0
-;; 808c:	 aa                   	stosb	byte ptr [rdi], al
-;; 808d:	 800100               	add	byte ptr [rcx], 0
-;; 8090:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8099:	 800100               	add	byte ptr [rcx], 0
-;; 809c:	 aa                   	stosb	byte ptr [rdi], al
-;; 809d:	 800100               	add	byte ptr [rcx], 0
-;; 80a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 80a9:	 800100               	add	byte ptr [rcx], 0
-;; 80ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 80ad:	 800100               	add	byte ptr [rcx], 0
-;; 80b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 80b9:	 800100               	add	byte ptr [rcx], 0
-;; 80bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 80bd:	 800100               	add	byte ptr [rcx], 0
-;; 80c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 80c9:	 800100               	add	byte ptr [rcx], 0
-;; 80cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 80cd:	 800100               	add	byte ptr [rcx], 0
-;; 80d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 80d9:	 800100               	add	byte ptr [rcx], 0
-;; 80dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 80dd:	 800100               	add	byte ptr [rcx], 0
-;; 80e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 80e9:	 800100               	add	byte ptr [rcx], 0
-;; 80ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 80ed:	 800100               	add	byte ptr [rcx], 0
-;; 80f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 80f9:	 800100               	add	byte ptr [rcx], 0
-;; 80fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 80fd:	 800100               	add	byte ptr [rcx], 0
-;; 8100:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8109:	 800100               	add	byte ptr [rcx], 0
-;; 810c:	 aa                   	stosb	byte ptr [rdi], al
-;; 810d:	 800100               	add	byte ptr [rcx], 0
-;; 8110:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8119:	 800100               	add	byte ptr [rcx], 0
-;; 811c:	 aa                   	stosb	byte ptr [rdi], al
-;; 811d:	 800100               	add	byte ptr [rcx], 0
-;; 8120:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8129:	 800100               	add	byte ptr [rcx], 0
-;; 812c:	 aa                   	stosb	byte ptr [rdi], al
-;; 812d:	 800100               	add	byte ptr [rcx], 0
-;; 8130:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8139:	 800100               	add	byte ptr [rcx], 0
-;; 813c:	 aa                   	stosb	byte ptr [rdi], al
-;; 813d:	 800100               	add	byte ptr [rcx], 0
-;; 8140:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8149:	 800100               	add	byte ptr [rcx], 0
-;; 814c:	 aa                   	stosb	byte ptr [rdi], al
-;; 814d:	 800100               	add	byte ptr [rcx], 0
-;; 8150:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8159:	 800100               	add	byte ptr [rcx], 0
-;; 815c:	 aa                   	stosb	byte ptr [rdi], al
-;; 815d:	 800100               	add	byte ptr [rcx], 0
-;; 8160:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8169:	 800100               	add	byte ptr [rcx], 0
-;; 816c:	 aa                   	stosb	byte ptr [rdi], al
-;; 816d:	 800100               	add	byte ptr [rcx], 0
-;; 8170:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8179:	 800100               	add	byte ptr [rcx], 0
-;; 817c:	 aa                   	stosb	byte ptr [rdi], al
-;; 817d:	 800100               	add	byte ptr [rcx], 0
-;; 8180:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8189:	 800100               	add	byte ptr [rcx], 0
-;; 818c:	 aa                   	stosb	byte ptr [rdi], al
-;; 818d:	 800100               	add	byte ptr [rcx], 0
-;; 8190:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8199:	 800100               	add	byte ptr [rcx], 0
-;; 819c:	 aa                   	stosb	byte ptr [rdi], al
-;; 819d:	 800100               	add	byte ptr [rcx], 0
-;; 81a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 81a9:	 800100               	add	byte ptr [rcx], 0
-;; 81ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 81ad:	 800100               	add	byte ptr [rcx], 0
-;; 81b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 81b9:	 800100               	add	byte ptr [rcx], 0
-;; 81bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 81bd:	 800100               	add	byte ptr [rcx], 0
-;; 81c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 81c9:	 800100               	add	byte ptr [rcx], 0
-;; 81cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 81cd:	 800100               	add	byte ptr [rcx], 0
-;; 81d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 81d9:	 800100               	add	byte ptr [rcx], 0
-;; 81dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 81dd:	 800100               	add	byte ptr [rcx], 0
-;; 81e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 81e9:	 800100               	add	byte ptr [rcx], 0
-;; 81ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 81ed:	 800100               	add	byte ptr [rcx], 0
-;; 81f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 81f9:	 800100               	add	byte ptr [rcx], 0
-;; 81fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 81fd:	 800100               	add	byte ptr [rcx], 0
-;; 8200:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8209:	 800100               	add	byte ptr [rcx], 0
-;; 820c:	 aa                   	stosb	byte ptr [rdi], al
-;; 820d:	 800100               	add	byte ptr [rcx], 0
-;; 8210:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8219:	 800100               	add	byte ptr [rcx], 0
-;; 821c:	 aa                   	stosb	byte ptr [rdi], al
-;; 821d:	 800100               	add	byte ptr [rcx], 0
-;; 8220:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8229:	 800100               	add	byte ptr [rcx], 0
-;; 822c:	 aa                   	stosb	byte ptr [rdi], al
-;; 822d:	 800100               	add	byte ptr [rcx], 0
-;; 8230:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8239:	 800100               	add	byte ptr [rcx], 0
-;; 823c:	 aa                   	stosb	byte ptr [rdi], al
-;; 823d:	 800100               	add	byte ptr [rcx], 0
-;; 8240:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8249:	 800100               	add	byte ptr [rcx], 0
-;; 824c:	 aa                   	stosb	byte ptr [rdi], al
-;; 824d:	 800100               	add	byte ptr [rcx], 0
-;; 8250:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8259:	 800100               	add	byte ptr [rcx], 0
-;; 825c:	 aa                   	stosb	byte ptr [rdi], al
-;; 825d:	 800100               	add	byte ptr [rcx], 0
-;; 8260:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8269:	 800100               	add	byte ptr [rcx], 0
-;; 826c:	 aa                   	stosb	byte ptr [rdi], al
-;; 826d:	 800100               	add	byte ptr [rcx], 0
-;; 8270:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8279:	 800100               	add	byte ptr [rcx], 0
-;; 827c:	 aa                   	stosb	byte ptr [rdi], al
-;; 827d:	 800100               	add	byte ptr [rcx], 0
-;; 8280:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8289:	 800100               	add	byte ptr [rcx], 0
-;; 828c:	 aa                   	stosb	byte ptr [rdi], al
-;; 828d:	 800100               	add	byte ptr [rcx], 0
-;; 8290:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8299:	 800100               	add	byte ptr [rcx], 0
-;; 829c:	 aa                   	stosb	byte ptr [rdi], al
-;; 829d:	 800100               	add	byte ptr [rcx], 0
-;; 82a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 82a9:	 800100               	add	byte ptr [rcx], 0
-;; 82ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 82ad:	 800100               	add	byte ptr [rcx], 0
-;; 82b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 82b9:	 800100               	add	byte ptr [rcx], 0
-;; 82bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 82bd:	 800100               	add	byte ptr [rcx], 0
-;; 82c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 82c9:	 800100               	add	byte ptr [rcx], 0
-;; 82cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 82cd:	 800100               	add	byte ptr [rcx], 0
-;; 82d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 82d9:	 800100               	add	byte ptr [rcx], 0
-;; 82dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 82dd:	 800100               	add	byte ptr [rcx], 0
-;; 82e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 82e9:	 800100               	add	byte ptr [rcx], 0
-;; 82ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 82ed:	 800100               	add	byte ptr [rcx], 0
-;; 82f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 82f9:	 800100               	add	byte ptr [rcx], 0
-;; 82fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 82fd:	 800100               	add	byte ptr [rcx], 0
-;; 8300:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8309:	 800100               	add	byte ptr [rcx], 0
-;; 830c:	 aa                   	stosb	byte ptr [rdi], al
-;; 830d:	 800100               	add	byte ptr [rcx], 0
-;; 8310:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8319:	 800100               	add	byte ptr [rcx], 0
-;; 831c:	 aa                   	stosb	byte ptr [rdi], al
-;; 831d:	 800100               	add	byte ptr [rcx], 0
-;; 8320:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8329:	 800100               	add	byte ptr [rcx], 0
-;; 832c:	 aa                   	stosb	byte ptr [rdi], al
-;; 832d:	 800100               	add	byte ptr [rcx], 0
-;; 8330:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8339:	 800100               	add	byte ptr [rcx], 0
-;; 833c:	 aa                   	stosb	byte ptr [rdi], al
-;; 833d:	 800100               	add	byte ptr [rcx], 0
-;; 8340:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8349:	 800100               	add	byte ptr [rcx], 0
-;; 834c:	 aa                   	stosb	byte ptr [rdi], al
-;; 834d:	 800100               	add	byte ptr [rcx], 0
-;; 8350:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8359:	 800100               	add	byte ptr [rcx], 0
-;; 835c:	 aa                   	stosb	byte ptr [rdi], al
-;; 835d:	 800100               	add	byte ptr [rcx], 0
-;; 8360:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8369:	 800100               	add	byte ptr [rcx], 0
-;; 836c:	 aa                   	stosb	byte ptr [rdi], al
-;; 836d:	 800100               	add	byte ptr [rcx], 0
-;; 8370:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8379:	 800100               	add	byte ptr [rcx], 0
-;; 837c:	 aa                   	stosb	byte ptr [rdi], al
-;; 837d:	 800100               	add	byte ptr [rcx], 0
-;; 8380:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8389:	 800100               	add	byte ptr [rcx], 0
-;; 838c:	 aa                   	stosb	byte ptr [rdi], al
-;; 838d:	 800100               	add	byte ptr [rcx], 0
-;; 8390:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8399:	 800100               	add	byte ptr [rcx], 0
-;; 839c:	 aa                   	stosb	byte ptr [rdi], al
-;; 839d:	 800100               	add	byte ptr [rcx], 0
-;; 83a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 83a9:	 800100               	add	byte ptr [rcx], 0
-;; 83ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 83ad:	 800100               	add	byte ptr [rcx], 0
-;; 83b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 83b9:	 800100               	add	byte ptr [rcx], 0
-;; 83bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 83bd:	 800100               	add	byte ptr [rcx], 0
-;; 83c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 83c9:	 800100               	add	byte ptr [rcx], 0
-;; 83cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 83cd:	 800100               	add	byte ptr [rcx], 0
-;; 83d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 83d9:	 800100               	add	byte ptr [rcx], 0
-;; 83dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 83dd:	 800100               	add	byte ptr [rcx], 0
-;; 83e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 83e9:	 800100               	add	byte ptr [rcx], 0
-;; 83ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 83ed:	 800100               	add	byte ptr [rcx], 0
-;; 83f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 83f9:	 800100               	add	byte ptr [rcx], 0
-;; 83fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 83fd:	 800100               	add	byte ptr [rcx], 0
-;; 8400:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8409:	 800100               	add	byte ptr [rcx], 0
-;; 840c:	 aa                   	stosb	byte ptr [rdi], al
-;; 840d:	 800100               	add	byte ptr [rcx], 0
-;; 8410:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8419:	 800100               	add	byte ptr [rcx], 0
-;; 841c:	 aa                   	stosb	byte ptr [rdi], al
-;; 841d:	 800100               	add	byte ptr [rcx], 0
-;; 8420:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8429:	 800100               	add	byte ptr [rcx], 0
-;; 842c:	 aa                   	stosb	byte ptr [rdi], al
-;; 842d:	 800100               	add	byte ptr [rcx], 0
-;; 8430:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8439:	 800100               	add	byte ptr [rcx], 0
-;; 843c:	 aa                   	stosb	byte ptr [rdi], al
-;; 843d:	 800100               	add	byte ptr [rcx], 0
-;; 8440:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8449:	 800100               	add	byte ptr [rcx], 0
-;; 844c:	 aa                   	stosb	byte ptr [rdi], al
-;; 844d:	 800100               	add	byte ptr [rcx], 0
-;; 8450:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8459:	 800100               	add	byte ptr [rcx], 0
-;; 845c:	 aa                   	stosb	byte ptr [rdi], al
-;; 845d:	 800100               	add	byte ptr [rcx], 0
-;; 8460:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8469:	 800100               	add	byte ptr [rcx], 0
-;; 846c:	 aa                   	stosb	byte ptr [rdi], al
-;; 846d:	 800100               	add	byte ptr [rcx], 0
-;; 8470:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8479:	 800100               	add	byte ptr [rcx], 0
-;; 847c:	 aa                   	stosb	byte ptr [rdi], al
-;; 847d:	 800100               	add	byte ptr [rcx], 0
-;; 8480:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8489:	 800100               	add	byte ptr [rcx], 0
-;; 848c:	 aa                   	stosb	byte ptr [rdi], al
-;; 848d:	 800100               	add	byte ptr [rcx], 0
-;; 8490:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8499:	 800100               	add	byte ptr [rcx], 0
-;; 849c:	 aa                   	stosb	byte ptr [rdi], al
-;; 849d:	 800100               	add	byte ptr [rcx], 0
-;; 84a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 84a9:	 800100               	add	byte ptr [rcx], 0
-;; 84ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 84ad:	 800100               	add	byte ptr [rcx], 0
-;; 84b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 84b9:	 800100               	add	byte ptr [rcx], 0
-;; 84bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 84bd:	 800100               	add	byte ptr [rcx], 0
-;; 84c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 84c9:	 800100               	add	byte ptr [rcx], 0
-;; 84cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 84cd:	 800100               	add	byte ptr [rcx], 0
-;; 84d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 84d9:	 800100               	add	byte ptr [rcx], 0
-;; 84dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 84dd:	 800100               	add	byte ptr [rcx], 0
-;; 84e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 84e9:	 800100               	add	byte ptr [rcx], 0
-;; 84ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 84ed:	 800100               	add	byte ptr [rcx], 0
-;; 84f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 84f9:	 800100               	add	byte ptr [rcx], 0
-;; 84fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 84fd:	 800100               	add	byte ptr [rcx], 0
-;; 8500:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8509:	 800100               	add	byte ptr [rcx], 0
-;; 850c:	 aa                   	stosb	byte ptr [rdi], al
-;; 850d:	 800100               	add	byte ptr [rcx], 0
-;; 8510:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8519:	 800100               	add	byte ptr [rcx], 0
-;; 851c:	 aa                   	stosb	byte ptr [rdi], al
-;; 851d:	 800100               	add	byte ptr [rcx], 0
-;; 8520:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8529:	 800100               	add	byte ptr [rcx], 0
-;; 852c:	 aa                   	stosb	byte ptr [rdi], al
-;; 852d:	 800100               	add	byte ptr [rcx], 0
-;; 8530:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8539:	 800100               	add	byte ptr [rcx], 0
-;; 853c:	 aa                   	stosb	byte ptr [rdi], al
-;; 853d:	 800100               	add	byte ptr [rcx], 0
-;; 8540:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8549:	 800100               	add	byte ptr [rcx], 0
-;; 854c:	 aa                   	stosb	byte ptr [rdi], al
-;; 854d:	 800100               	add	byte ptr [rcx], 0
-;; 8550:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8559:	 800100               	add	byte ptr [rcx], 0
-;; 855c:	 aa                   	stosb	byte ptr [rdi], al
-;; 855d:	 800100               	add	byte ptr [rcx], 0
-;; 8560:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8569:	 800100               	add	byte ptr [rcx], 0
-;; 856c:	 aa                   	stosb	byte ptr [rdi], al
-;; 856d:	 800100               	add	byte ptr [rcx], 0
-;; 8570:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8579:	 800100               	add	byte ptr [rcx], 0
-;; 857c:	 aa                   	stosb	byte ptr [rdi], al
-;; 857d:	 800100               	add	byte ptr [rcx], 0
-;; 8580:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8589:	 800100               	add	byte ptr [rcx], 0
-;; 858c:	 aa                   	stosb	byte ptr [rdi], al
-;; 858d:	 800100               	add	byte ptr [rcx], 0
-;; 8590:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8599:	 800100               	add	byte ptr [rcx], 0
-;; 859c:	 aa                   	stosb	byte ptr [rdi], al
-;; 859d:	 800100               	add	byte ptr [rcx], 0
-;; 85a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 85a9:	 800100               	add	byte ptr [rcx], 0
-;; 85ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 85ad:	 800100               	add	byte ptr [rcx], 0
-;; 85b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 85b9:	 800100               	add	byte ptr [rcx], 0
-;; 85bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 85bd:	 800100               	add	byte ptr [rcx], 0
-;; 85c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 85c9:	 800100               	add	byte ptr [rcx], 0
-;; 85cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 85cd:	 800100               	add	byte ptr [rcx], 0
-;; 85d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 85d9:	 800100               	add	byte ptr [rcx], 0
-;; 85dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 85dd:	 800100               	add	byte ptr [rcx], 0
-;; 85e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 85e9:	 800100               	add	byte ptr [rcx], 0
-;; 85ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 85ed:	 800100               	add	byte ptr [rcx], 0
-;; 85f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 85f9:	 800100               	add	byte ptr [rcx], 0
-;; 85fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 85fd:	 800100               	add	byte ptr [rcx], 0
-;; 8600:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8609:	 800100               	add	byte ptr [rcx], 0
-;; 860c:	 aa                   	stosb	byte ptr [rdi], al
-;; 860d:	 800100               	add	byte ptr [rcx], 0
-;; 8610:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8619:	 800100               	add	byte ptr [rcx], 0
-;; 861c:	 aa                   	stosb	byte ptr [rdi], al
-;; 861d:	 800100               	add	byte ptr [rcx], 0
-;; 8620:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8629:	 800100               	add	byte ptr [rcx], 0
-;; 862c:	 aa                   	stosb	byte ptr [rdi], al
-;; 862d:	 800100               	add	byte ptr [rcx], 0
-;; 8630:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8639:	 800100               	add	byte ptr [rcx], 0
-;; 863c:	 aa                   	stosb	byte ptr [rdi], al
-;; 863d:	 800100               	add	byte ptr [rcx], 0
-;; 8640:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8649:	 800100               	add	byte ptr [rcx], 0
-;; 864c:	 aa                   	stosb	byte ptr [rdi], al
-;; 864d:	 800100               	add	byte ptr [rcx], 0
-;; 8650:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8659:	 800100               	add	byte ptr [rcx], 0
-;; 865c:	 aa                   	stosb	byte ptr [rdi], al
-;; 865d:	 800100               	add	byte ptr [rcx], 0
-;; 8660:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8669:	 800100               	add	byte ptr [rcx], 0
-;; 866c:	 aa                   	stosb	byte ptr [rdi], al
-;; 866d:	 800100               	add	byte ptr [rcx], 0
-;; 8670:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8679:	 800100               	add	byte ptr [rcx], 0
-;; 867c:	 aa                   	stosb	byte ptr [rdi], al
-;; 867d:	 800100               	add	byte ptr [rcx], 0
-;; 8680:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8689:	 800100               	add	byte ptr [rcx], 0
-;; 868c:	 aa                   	stosb	byte ptr [rdi], al
-;; 868d:	 800100               	add	byte ptr [rcx], 0
-;; 8690:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8699:	 800100               	add	byte ptr [rcx], 0
-;; 869c:	 aa                   	stosb	byte ptr [rdi], al
-;; 869d:	 800100               	add	byte ptr [rcx], 0
-;; 86a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 86a9:	 800100               	add	byte ptr [rcx], 0
-;; 86ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 86ad:	 800100               	add	byte ptr [rcx], 0
-;; 86b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 86b9:	 800100               	add	byte ptr [rcx], 0
-;; 86bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 86bd:	 800100               	add	byte ptr [rcx], 0
-;; 86c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 86c9:	 800100               	add	byte ptr [rcx], 0
-;; 86cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 86cd:	 800100               	add	byte ptr [rcx], 0
-;; 86d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 86d9:	 800100               	add	byte ptr [rcx], 0
-;; 86dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 86dd:	 800100               	add	byte ptr [rcx], 0
-;; 86e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 86e9:	 800100               	add	byte ptr [rcx], 0
-;; 86ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 86ed:	 800100               	add	byte ptr [rcx], 0
-;; 86f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 86f9:	 800100               	add	byte ptr [rcx], 0
-;; 86fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 86fd:	 800100               	add	byte ptr [rcx], 0
-;; 8700:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8709:	 800100               	add	byte ptr [rcx], 0
-;; 870c:	 aa                   	stosb	byte ptr [rdi], al
-;; 870d:	 800100               	add	byte ptr [rcx], 0
-;; 8710:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8719:	 800100               	add	byte ptr [rcx], 0
-;; 871c:	 aa                   	stosb	byte ptr [rdi], al
-;; 871d:	 800100               	add	byte ptr [rcx], 0
-;; 8720:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8729:	 800100               	add	byte ptr [rcx], 0
-;; 872c:	 aa                   	stosb	byte ptr [rdi], al
-;; 872d:	 800100               	add	byte ptr [rcx], 0
-;; 8730:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8739:	 800100               	add	byte ptr [rcx], 0
-;; 873c:	 aa                   	stosb	byte ptr [rdi], al
-;; 873d:	 800100               	add	byte ptr [rcx], 0
-;; 8740:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8749:	 800100               	add	byte ptr [rcx], 0
-;; 874c:	 aa                   	stosb	byte ptr [rdi], al
-;; 874d:	 800100               	add	byte ptr [rcx], 0
-;; 8750:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8759:	 800100               	add	byte ptr [rcx], 0
-;; 875c:	 aa                   	stosb	byte ptr [rdi], al
-;; 875d:	 800100               	add	byte ptr [rcx], 0
-;; 8760:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8769:	 800100               	add	byte ptr [rcx], 0
-;; 876c:	 aa                   	stosb	byte ptr [rdi], al
-;; 876d:	 800100               	add	byte ptr [rcx], 0
-;; 8770:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8779:	 800100               	add	byte ptr [rcx], 0
-;; 877c:	 aa                   	stosb	byte ptr [rdi], al
-;; 877d:	 800100               	add	byte ptr [rcx], 0
-;; 8780:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8789:	 800100               	add	byte ptr [rcx], 0
-;; 878c:	 aa                   	stosb	byte ptr [rdi], al
-;; 878d:	 800100               	add	byte ptr [rcx], 0
-;; 8790:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8799:	 800100               	add	byte ptr [rcx], 0
-;; 879c:	 aa                   	stosb	byte ptr [rdi], al
-;; 879d:	 800100               	add	byte ptr [rcx], 0
-;; 87a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 87a9:	 800100               	add	byte ptr [rcx], 0
-;; 87ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 87ad:	 800100               	add	byte ptr [rcx], 0
-;; 87b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 87b9:	 800100               	add	byte ptr [rcx], 0
-;; 87bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 87bd:	 800100               	add	byte ptr [rcx], 0
-;; 87c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 87c9:	 800100               	add	byte ptr [rcx], 0
-;; 87cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 87cd:	 800100               	add	byte ptr [rcx], 0
-;; 87d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 87d9:	 800100               	add	byte ptr [rcx], 0
-;; 87dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 87dd:	 800100               	add	byte ptr [rcx], 0
-;; 87e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 87e9:	 800100               	add	byte ptr [rcx], 0
-;; 87ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 87ed:	 800100               	add	byte ptr [rcx], 0
-;; 87f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 87f9:	 800100               	add	byte ptr [rcx], 0
-;; 87fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 87fd:	 800100               	add	byte ptr [rcx], 0
-;; 8800:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8809:	 800100               	add	byte ptr [rcx], 0
-;; 880c:	 aa                   	stosb	byte ptr [rdi], al
-;; 880d:	 800100               	add	byte ptr [rcx], 0
-;; 8810:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8819:	 800100               	add	byte ptr [rcx], 0
-;; 881c:	 aa                   	stosb	byte ptr [rdi], al
-;; 881d:	 800100               	add	byte ptr [rcx], 0
-;; 8820:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8829:	 800100               	add	byte ptr [rcx], 0
-;; 882c:	 aa                   	stosb	byte ptr [rdi], al
-;; 882d:	 800100               	add	byte ptr [rcx], 0
-;; 8830:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8839:	 800100               	add	byte ptr [rcx], 0
-;; 883c:	 aa                   	stosb	byte ptr [rdi], al
-;; 883d:	 800100               	add	byte ptr [rcx], 0
-;; 8840:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8849:	 800100               	add	byte ptr [rcx], 0
-;; 884c:	 aa                   	stosb	byte ptr [rdi], al
-;; 884d:	 800100               	add	byte ptr [rcx], 0
-;; 8850:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8859:	 800100               	add	byte ptr [rcx], 0
-;; 885c:	 aa                   	stosb	byte ptr [rdi], al
-;; 885d:	 800100               	add	byte ptr [rcx], 0
-;; 8860:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8869:	 800100               	add	byte ptr [rcx], 0
-;; 886c:	 aa                   	stosb	byte ptr [rdi], al
-;; 886d:	 800100               	add	byte ptr [rcx], 0
-;; 8870:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8879:	 800100               	add	byte ptr [rcx], 0
-;; 887c:	 aa                   	stosb	byte ptr [rdi], al
-;; 887d:	 800100               	add	byte ptr [rcx], 0
-;; 8880:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8889:	 800100               	add	byte ptr [rcx], 0
-;; 888c:	 aa                   	stosb	byte ptr [rdi], al
-;; 888d:	 800100               	add	byte ptr [rcx], 0
-;; 8890:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8899:	 800100               	add	byte ptr [rcx], 0
-;; 889c:	 aa                   	stosb	byte ptr [rdi], al
-;; 889d:	 800100               	add	byte ptr [rcx], 0
-;; 88a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 88a9:	 800100               	add	byte ptr [rcx], 0
-;; 88ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 88ad:	 800100               	add	byte ptr [rcx], 0
-;; 88b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 88b9:	 800100               	add	byte ptr [rcx], 0
-;; 88bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 88bd:	 800100               	add	byte ptr [rcx], 0
-;; 88c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 88c9:	 800100               	add	byte ptr [rcx], 0
-;; 88cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 88cd:	 800100               	add	byte ptr [rcx], 0
-;; 88d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 88d9:	 800100               	add	byte ptr [rcx], 0
-;; 88dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 88dd:	 800100               	add	byte ptr [rcx], 0
-;; 88e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 88e9:	 800100               	add	byte ptr [rcx], 0
-;; 88ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 88ed:	 800100               	add	byte ptr [rcx], 0
-;; 88f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 88f9:	 800100               	add	byte ptr [rcx], 0
-;; 88fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 88fd:	 800100               	add	byte ptr [rcx], 0
-;; 8900:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8909:	 800100               	add	byte ptr [rcx], 0
-;; 890c:	 aa                   	stosb	byte ptr [rdi], al
-;; 890d:	 800100               	add	byte ptr [rcx], 0
-;; 8910:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8919:	 800100               	add	byte ptr [rcx], 0
-;; 891c:	 aa                   	stosb	byte ptr [rdi], al
-;; 891d:	 800100               	add	byte ptr [rcx], 0
-;; 8920:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8929:	 800100               	add	byte ptr [rcx], 0
-;; 892c:	 aa                   	stosb	byte ptr [rdi], al
-;; 892d:	 800100               	add	byte ptr [rcx], 0
-;; 8930:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8939:	 800100               	add	byte ptr [rcx], 0
-;; 893c:	 aa                   	stosb	byte ptr [rdi], al
-;; 893d:	 800100               	add	byte ptr [rcx], 0
-;; 8940:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8949:	 800100               	add	byte ptr [rcx], 0
-;; 894c:	 aa                   	stosb	byte ptr [rdi], al
-;; 894d:	 800100               	add	byte ptr [rcx], 0
-;; 8950:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8959:	 800100               	add	byte ptr [rcx], 0
-;; 895c:	 aa                   	stosb	byte ptr [rdi], al
-;; 895d:	 800100               	add	byte ptr [rcx], 0
-;; 8960:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8969:	 800100               	add	byte ptr [rcx], 0
-;; 896c:	 aa                   	stosb	byte ptr [rdi], al
-;; 896d:	 800100               	add	byte ptr [rcx], 0
-;; 8970:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8979:	 800100               	add	byte ptr [rcx], 0
-;; 897c:	 aa                   	stosb	byte ptr [rdi], al
-;; 897d:	 800100               	add	byte ptr [rcx], 0
-;; 8980:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8989:	 800100               	add	byte ptr [rcx], 0
-;; 898c:	 aa                   	stosb	byte ptr [rdi], al
-;; 898d:	 800100               	add	byte ptr [rcx], 0
-;; 8990:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8999:	 800100               	add	byte ptr [rcx], 0
-;; 899c:	 aa                   	stosb	byte ptr [rdi], al
-;; 899d:	 800100               	add	byte ptr [rcx], 0
-;; 89a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 89a9:	 800100               	add	byte ptr [rcx], 0
-;; 89ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 89ad:	 800100               	add	byte ptr [rcx], 0
-;; 89b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 89b9:	 800100               	add	byte ptr [rcx], 0
-;; 89bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 89bd:	 800100               	add	byte ptr [rcx], 0
-;; 89c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 89c9:	 800100               	add	byte ptr [rcx], 0
-;; 89cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 89cd:	 800100               	add	byte ptr [rcx], 0
-;; 89d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 89d9:	 800100               	add	byte ptr [rcx], 0
-;; 89dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 89dd:	 800100               	add	byte ptr [rcx], 0
-;; 89e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 89e9:	 800100               	add	byte ptr [rcx], 0
-;; 89ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 89ed:	 800100               	add	byte ptr [rcx], 0
-;; 89f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 89f9:	 800100               	add	byte ptr [rcx], 0
-;; 89fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 89fd:	 800100               	add	byte ptr [rcx], 0
-;; 8a00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8a09:	 800100               	add	byte ptr [rcx], 0
-;; 8a0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8a0d:	 800100               	add	byte ptr [rcx], 0
-;; 8a10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8a19:	 800100               	add	byte ptr [rcx], 0
-;; 8a1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8a1d:	 800100               	add	byte ptr [rcx], 0
-;; 8a20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8a29:	 800100               	add	byte ptr [rcx], 0
-;; 8a2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8a2d:	 800100               	add	byte ptr [rcx], 0
-;; 8a30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8a39:	 800100               	add	byte ptr [rcx], 0
-;; 8a3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8a3d:	 800100               	add	byte ptr [rcx], 0
-;; 8a40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8a49:	 800100               	add	byte ptr [rcx], 0
-;; 8a4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8a4d:	 800100               	add	byte ptr [rcx], 0
-;; 8a50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8a59:	 800100               	add	byte ptr [rcx], 0
-;; 8a5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8a5d:	 800100               	add	byte ptr [rcx], 0
-;; 8a60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8a69:	 800100               	add	byte ptr [rcx], 0
-;; 8a6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8a6d:	 800100               	add	byte ptr [rcx], 0
-;; 8a70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8a79:	 800100               	add	byte ptr [rcx], 0
-;; 8a7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8a7d:	 800100               	add	byte ptr [rcx], 0
-;; 8a80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8a89:	 800100               	add	byte ptr [rcx], 0
-;; 8a8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8a8d:	 800100               	add	byte ptr [rcx], 0
-;; 8a90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8a99:	 800100               	add	byte ptr [rcx], 0
-;; 8a9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8a9d:	 800100               	add	byte ptr [rcx], 0
-;; 8aa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8aa9:	 800100               	add	byte ptr [rcx], 0
-;; 8aac:	 aa                   	stosb	byte ptr [rdi], al
-;; 8aad:	 800100               	add	byte ptr [rcx], 0
-;; 8ab0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8ab9:	 800100               	add	byte ptr [rcx], 0
-;; 8abc:	 aa                   	stosb	byte ptr [rdi], al
-;; 8abd:	 800100               	add	byte ptr [rcx], 0
-;; 8ac0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8ac9:	 800100               	add	byte ptr [rcx], 0
-;; 8acc:	 aa                   	stosb	byte ptr [rdi], al
-;; 8acd:	 800100               	add	byte ptr [rcx], 0
-;; 8ad0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8ad9:	 800100               	add	byte ptr [rcx], 0
-;; 8adc:	 aa                   	stosb	byte ptr [rdi], al
-;; 8add:	 800100               	add	byte ptr [rcx], 0
-;; 8ae0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8ae9:	 800100               	add	byte ptr [rcx], 0
-;; 8aec:	 aa                   	stosb	byte ptr [rdi], al
-;; 8aed:	 800100               	add	byte ptr [rcx], 0
-;; 8af0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8af9:	 800100               	add	byte ptr [rcx], 0
-;; 8afc:	 aa                   	stosb	byte ptr [rdi], al
-;; 8afd:	 800100               	add	byte ptr [rcx], 0
-;; 8b00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8b09:	 800100               	add	byte ptr [rcx], 0
-;; 8b0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8b0d:	 800100               	add	byte ptr [rcx], 0
-;; 8b10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8b19:	 800100               	add	byte ptr [rcx], 0
-;; 8b1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8b1d:	 800100               	add	byte ptr [rcx], 0
-;; 8b20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8b29:	 800100               	add	byte ptr [rcx], 0
-;; 8b2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8b2d:	 800100               	add	byte ptr [rcx], 0
-;; 8b30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8b39:	 800100               	add	byte ptr [rcx], 0
-;; 8b3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8b3d:	 800100               	add	byte ptr [rcx], 0
-;; 8b40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8b49:	 800100               	add	byte ptr [rcx], 0
-;; 8b4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8b4d:	 800100               	add	byte ptr [rcx], 0
-;; 8b50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8b59:	 800100               	add	byte ptr [rcx], 0
-;; 8b5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8b5d:	 800100               	add	byte ptr [rcx], 0
-;; 8b60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8b69:	 800100               	add	byte ptr [rcx], 0
-;; 8b6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8b6d:	 800100               	add	byte ptr [rcx], 0
-;; 8b70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8b79:	 800100               	add	byte ptr [rcx], 0
-;; 8b7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8b7d:	 800100               	add	byte ptr [rcx], 0
-;; 8b80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8b89:	 800100               	add	byte ptr [rcx], 0
-;; 8b8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8b8d:	 800100               	add	byte ptr [rcx], 0
-;; 8b90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8b99:	 800100               	add	byte ptr [rcx], 0
-;; 8b9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8b9d:	 800100               	add	byte ptr [rcx], 0
-;; 8ba0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8ba9:	 800100               	add	byte ptr [rcx], 0
-;; 8bac:	 aa                   	stosb	byte ptr [rdi], al
-;; 8bad:	 800100               	add	byte ptr [rcx], 0
-;; 8bb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8bb9:	 800100               	add	byte ptr [rcx], 0
-;; 8bbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 8bbd:	 800100               	add	byte ptr [rcx], 0
-;; 8bc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8bc9:	 800100               	add	byte ptr [rcx], 0
-;; 8bcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 8bcd:	 800100               	add	byte ptr [rcx], 0
-;; 8bd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8bd9:	 800100               	add	byte ptr [rcx], 0
-;; 8bdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 8bdd:	 800100               	add	byte ptr [rcx], 0
-;; 8be0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8be9:	 800100               	add	byte ptr [rcx], 0
-;; 8bec:	 aa                   	stosb	byte ptr [rdi], al
-;; 8bed:	 800100               	add	byte ptr [rcx], 0
-;; 8bf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8bf9:	 800100               	add	byte ptr [rcx], 0
-;; 8bfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 8bfd:	 800100               	add	byte ptr [rcx], 0
-;; 8c00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8c09:	 800100               	add	byte ptr [rcx], 0
-;; 8c0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8c0d:	 800100               	add	byte ptr [rcx], 0
-;; 8c10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8c19:	 800100               	add	byte ptr [rcx], 0
-;; 8c1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8c1d:	 800100               	add	byte ptr [rcx], 0
-;; 8c20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8c29:	 800100               	add	byte ptr [rcx], 0
-;; 8c2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8c2d:	 800100               	add	byte ptr [rcx], 0
-;; 8c30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8c39:	 800100               	add	byte ptr [rcx], 0
-;; 8c3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8c3d:	 800100               	add	byte ptr [rcx], 0
-;; 8c40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8c49:	 800100               	add	byte ptr [rcx], 0
-;; 8c4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8c4d:	 800100               	add	byte ptr [rcx], 0
-;; 8c50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8c59:	 800100               	add	byte ptr [rcx], 0
-;; 8c5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8c5d:	 800100               	add	byte ptr [rcx], 0
-;; 8c60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8c69:	 800100               	add	byte ptr [rcx], 0
-;; 8c6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8c6d:	 800100               	add	byte ptr [rcx], 0
-;; 8c70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8c79:	 800100               	add	byte ptr [rcx], 0
-;; 8c7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8c7d:	 800100               	add	byte ptr [rcx], 0
-;; 8c80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8c89:	 800100               	add	byte ptr [rcx], 0
-;; 8c8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8c8d:	 800100               	add	byte ptr [rcx], 0
-;; 8c90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8c99:	 800100               	add	byte ptr [rcx], 0
-;; 8c9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8c9d:	 800100               	add	byte ptr [rcx], 0
-;; 8ca0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8ca9:	 800100               	add	byte ptr [rcx], 0
-;; 8cac:	 aa                   	stosb	byte ptr [rdi], al
-;; 8cad:	 800100               	add	byte ptr [rcx], 0
-;; 8cb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8cb9:	 800100               	add	byte ptr [rcx], 0
-;; 8cbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 8cbd:	 800100               	add	byte ptr [rcx], 0
-;; 8cc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8cc9:	 800100               	add	byte ptr [rcx], 0
-;; 8ccc:	 aa                   	stosb	byte ptr [rdi], al
-;; 8ccd:	 800100               	add	byte ptr [rcx], 0
-;; 8cd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8cd9:	 800100               	add	byte ptr [rcx], 0
-;; 8cdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 8cdd:	 800100               	add	byte ptr [rcx], 0
-;; 8ce0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8ce9:	 800100               	add	byte ptr [rcx], 0
-;; 8cec:	 aa                   	stosb	byte ptr [rdi], al
-;; 8ced:	 800100               	add	byte ptr [rcx], 0
-;; 8cf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8cf9:	 800100               	add	byte ptr [rcx], 0
-;; 8cfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 8cfd:	 800100               	add	byte ptr [rcx], 0
-;; 8d00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8d09:	 800100               	add	byte ptr [rcx], 0
-;; 8d0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8d0d:	 800100               	add	byte ptr [rcx], 0
-;; 8d10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8d19:	 800100               	add	byte ptr [rcx], 0
-;; 8d1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8d1d:	 800100               	add	byte ptr [rcx], 0
-;; 8d20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8d29:	 800100               	add	byte ptr [rcx], 0
-;; 8d2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8d2d:	 800100               	add	byte ptr [rcx], 0
-;; 8d30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8d39:	 800100               	add	byte ptr [rcx], 0
-;; 8d3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8d3d:	 800100               	add	byte ptr [rcx], 0
-;; 8d40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8d49:	 800100               	add	byte ptr [rcx], 0
-;; 8d4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8d4d:	 800100               	add	byte ptr [rcx], 0
-;; 8d50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8d59:	 800100               	add	byte ptr [rcx], 0
-;; 8d5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8d5d:	 800100               	add	byte ptr [rcx], 0
-;; 8d60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8d69:	 800100               	add	byte ptr [rcx], 0
-;; 8d6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8d6d:	 800100               	add	byte ptr [rcx], 0
-;; 8d70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8d79:	 800100               	add	byte ptr [rcx], 0
-;; 8d7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8d7d:	 800100               	add	byte ptr [rcx], 0
-;; 8d80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8d89:	 800100               	add	byte ptr [rcx], 0
-;; 8d8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8d8d:	 800100               	add	byte ptr [rcx], 0
-;; 8d90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8d99:	 800100               	add	byte ptr [rcx], 0
-;; 8d9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8d9d:	 800100               	add	byte ptr [rcx], 0
-;; 8da0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8da9:	 800100               	add	byte ptr [rcx], 0
-;; 8dac:	 aa                   	stosb	byte ptr [rdi], al
-;; 8dad:	 800100               	add	byte ptr [rcx], 0
-;; 8db0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8db9:	 800100               	add	byte ptr [rcx], 0
-;; 8dbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 8dbd:	 800100               	add	byte ptr [rcx], 0
-;; 8dc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8dc9:	 800100               	add	byte ptr [rcx], 0
-;; 8dcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 8dcd:	 800100               	add	byte ptr [rcx], 0
-;; 8dd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8dd9:	 800100               	add	byte ptr [rcx], 0
-;; 8ddc:	 aa                   	stosb	byte ptr [rdi], al
-;; 8ddd:	 800100               	add	byte ptr [rcx], 0
-;; 8de0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8de9:	 800100               	add	byte ptr [rcx], 0
-;; 8dec:	 aa                   	stosb	byte ptr [rdi], al
-;; 8ded:	 800100               	add	byte ptr [rcx], 0
-;; 8df0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8df9:	 800100               	add	byte ptr [rcx], 0
-;; 8dfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 8dfd:	 800100               	add	byte ptr [rcx], 0
-;; 8e00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8e09:	 800100               	add	byte ptr [rcx], 0
-;; 8e0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8e0d:	 800100               	add	byte ptr [rcx], 0
-;; 8e10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8e19:	 800100               	add	byte ptr [rcx], 0
-;; 8e1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8e1d:	 800100               	add	byte ptr [rcx], 0
-;; 8e20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8e29:	 800100               	add	byte ptr [rcx], 0
-;; 8e2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8e2d:	 800100               	add	byte ptr [rcx], 0
-;; 8e30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8e39:	 800100               	add	byte ptr [rcx], 0
-;; 8e3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8e3d:	 800100               	add	byte ptr [rcx], 0
-;; 8e40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8e49:	 800100               	add	byte ptr [rcx], 0
-;; 8e4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8e4d:	 800100               	add	byte ptr [rcx], 0
-;; 8e50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8e59:	 800100               	add	byte ptr [rcx], 0
-;; 8e5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8e5d:	 800100               	add	byte ptr [rcx], 0
-;; 8e60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8e69:	 800100               	add	byte ptr [rcx], 0
-;; 8e6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8e6d:	 800100               	add	byte ptr [rcx], 0
-;; 8e70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8e79:	 800100               	add	byte ptr [rcx], 0
-;; 8e7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8e7d:	 800100               	add	byte ptr [rcx], 0
-;; 8e80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8e89:	 800100               	add	byte ptr [rcx], 0
-;; 8e8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8e8d:	 800100               	add	byte ptr [rcx], 0
-;; 8e90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8e99:	 800100               	add	byte ptr [rcx], 0
-;; 8e9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8e9d:	 800100               	add	byte ptr [rcx], 0
-;; 8ea0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8ea9:	 800100               	add	byte ptr [rcx], 0
-;; 8eac:	 aa                   	stosb	byte ptr [rdi], al
-;; 8ead:	 800100               	add	byte ptr [rcx], 0
-;; 8eb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8eb9:	 800100               	add	byte ptr [rcx], 0
-;; 8ebc:	 aa                   	stosb	byte ptr [rdi], al
-;; 8ebd:	 800100               	add	byte ptr [rcx], 0
-;; 8ec0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8ec9:	 800100               	add	byte ptr [rcx], 0
-;; 8ecc:	 aa                   	stosb	byte ptr [rdi], al
-;; 8ecd:	 800100               	add	byte ptr [rcx], 0
-;; 8ed0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8ed9:	 800100               	add	byte ptr [rcx], 0
-;; 8edc:	 aa                   	stosb	byte ptr [rdi], al
-;; 8edd:	 800100               	add	byte ptr [rcx], 0
-;; 8ee0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8ee9:	 800100               	add	byte ptr [rcx], 0
-;; 8eec:	 aa                   	stosb	byte ptr [rdi], al
-;; 8eed:	 800100               	add	byte ptr [rcx], 0
-;; 8ef0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8ef9:	 800100               	add	byte ptr [rcx], 0
-;; 8efc:	 aa                   	stosb	byte ptr [rdi], al
-;; 8efd:	 800100               	add	byte ptr [rcx], 0
-;; 8f00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8f09:	 800100               	add	byte ptr [rcx], 0
-;; 8f0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8f0d:	 800100               	add	byte ptr [rcx], 0
-;; 8f10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8f19:	 800100               	add	byte ptr [rcx], 0
-;; 8f1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8f1d:	 800100               	add	byte ptr [rcx], 0
-;; 8f20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8f29:	 800100               	add	byte ptr [rcx], 0
-;; 8f2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8f2d:	 800100               	add	byte ptr [rcx], 0
-;; 8f30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8f39:	 800100               	add	byte ptr [rcx], 0
-;; 8f3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8f3d:	 800100               	add	byte ptr [rcx], 0
-;; 8f40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8f49:	 800100               	add	byte ptr [rcx], 0
-;; 8f4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8f4d:	 800100               	add	byte ptr [rcx], 0
-;; 8f50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8f59:	 800100               	add	byte ptr [rcx], 0
-;; 8f5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8f5d:	 800100               	add	byte ptr [rcx], 0
-;; 8f60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8f69:	 800100               	add	byte ptr [rcx], 0
-;; 8f6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8f6d:	 800100               	add	byte ptr [rcx], 0
-;; 8f70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8f79:	 800100               	add	byte ptr [rcx], 0
-;; 8f7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8f7d:	 800100               	add	byte ptr [rcx], 0
-;; 8f80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8f89:	 800100               	add	byte ptr [rcx], 0
-;; 8f8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8f8d:	 800100               	add	byte ptr [rcx], 0
-;; 8f90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8f99:	 800100               	add	byte ptr [rcx], 0
-;; 8f9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 8f9d:	 800100               	add	byte ptr [rcx], 0
-;; 8fa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8fa9:	 800100               	add	byte ptr [rcx], 0
-;; 8fac:	 aa                   	stosb	byte ptr [rdi], al
-;; 8fad:	 800100               	add	byte ptr [rcx], 0
-;; 8fb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8fb9:	 800100               	add	byte ptr [rcx], 0
-;; 8fbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 8fbd:	 800100               	add	byte ptr [rcx], 0
-;; 8fc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8fc9:	 800100               	add	byte ptr [rcx], 0
-;; 8fcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 8fcd:	 800100               	add	byte ptr [rcx], 0
-;; 8fd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8fd9:	 800100               	add	byte ptr [rcx], 0
-;; 8fdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 8fdd:	 800100               	add	byte ptr [rcx], 0
-;; 8fe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8fe9:	 800100               	add	byte ptr [rcx], 0
-;; 8fec:	 aa                   	stosb	byte ptr [rdi], al
-;; 8fed:	 800100               	add	byte ptr [rcx], 0
-;; 8ff0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 8ff9:	 800100               	add	byte ptr [rcx], 0
-;; 8ffc:	 aa                   	stosb	byte ptr [rdi], al
-;; 8ffd:	 800100               	add	byte ptr [rcx], 0
-;; 9000:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9009:	 800100               	add	byte ptr [rcx], 0
-;; 900c:	 aa                   	stosb	byte ptr [rdi], al
-;; 900d:	 800100               	add	byte ptr [rcx], 0
-;; 9010:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9019:	 800100               	add	byte ptr [rcx], 0
-;; 901c:	 aa                   	stosb	byte ptr [rdi], al
-;; 901d:	 800100               	add	byte ptr [rcx], 0
-;; 9020:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9029:	 800100               	add	byte ptr [rcx], 0
-;; 902c:	 aa                   	stosb	byte ptr [rdi], al
-;; 902d:	 800100               	add	byte ptr [rcx], 0
-;; 9030:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9039:	 800100               	add	byte ptr [rcx], 0
-;; 903c:	 aa                   	stosb	byte ptr [rdi], al
-;; 903d:	 800100               	add	byte ptr [rcx], 0
-;; 9040:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9049:	 800100               	add	byte ptr [rcx], 0
-;; 904c:	 aa                   	stosb	byte ptr [rdi], al
-;; 904d:	 800100               	add	byte ptr [rcx], 0
-;; 9050:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9059:	 800100               	add	byte ptr [rcx], 0
-;; 905c:	 aa                   	stosb	byte ptr [rdi], al
-;; 905d:	 800100               	add	byte ptr [rcx], 0
-;; 9060:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9069:	 800100               	add	byte ptr [rcx], 0
-;; 906c:	 aa                   	stosb	byte ptr [rdi], al
-;; 906d:	 800100               	add	byte ptr [rcx], 0
-;; 9070:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9079:	 800100               	add	byte ptr [rcx], 0
-;; 907c:	 aa                   	stosb	byte ptr [rdi], al
-;; 907d:	 800100               	add	byte ptr [rcx], 0
-;; 9080:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9089:	 800100               	add	byte ptr [rcx], 0
-;; 908c:	 aa                   	stosb	byte ptr [rdi], al
-;; 908d:	 800100               	add	byte ptr [rcx], 0
-;; 9090:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9099:	 800100               	add	byte ptr [rcx], 0
-;; 909c:	 aa                   	stosb	byte ptr [rdi], al
-;; 909d:	 800100               	add	byte ptr [rcx], 0
-;; 90a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 90a9:	 800100               	add	byte ptr [rcx], 0
-;; 90ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 90ad:	 800100               	add	byte ptr [rcx], 0
-;; 90b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 90b9:	 800100               	add	byte ptr [rcx], 0
-;; 90bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 90bd:	 800100               	add	byte ptr [rcx], 0
-;; 90c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 90c9:	 800100               	add	byte ptr [rcx], 0
-;; 90cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 90cd:	 800100               	add	byte ptr [rcx], 0
-;; 90d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 90d9:	 800100               	add	byte ptr [rcx], 0
-;; 90dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 90dd:	 800100               	add	byte ptr [rcx], 0
-;; 90e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 90e9:	 800100               	add	byte ptr [rcx], 0
-;; 90ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 90ed:	 800100               	add	byte ptr [rcx], 0
-;; 90f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 90f9:	 800100               	add	byte ptr [rcx], 0
-;; 90fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 90fd:	 800100               	add	byte ptr [rcx], 0
-;; 9100:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9109:	 800100               	add	byte ptr [rcx], 0
-;; 910c:	 aa                   	stosb	byte ptr [rdi], al
-;; 910d:	 800100               	add	byte ptr [rcx], 0
-;; 9110:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9119:	 800100               	add	byte ptr [rcx], 0
-;; 911c:	 aa                   	stosb	byte ptr [rdi], al
-;; 911d:	 800100               	add	byte ptr [rcx], 0
-;; 9120:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9129:	 800100               	add	byte ptr [rcx], 0
-;; 912c:	 aa                   	stosb	byte ptr [rdi], al
-;; 912d:	 800100               	add	byte ptr [rcx], 0
-;; 9130:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9139:	 800100               	add	byte ptr [rcx], 0
-;; 913c:	 aa                   	stosb	byte ptr [rdi], al
-;; 913d:	 800100               	add	byte ptr [rcx], 0
-;; 9140:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9149:	 800100               	add	byte ptr [rcx], 0
-;; 914c:	 aa                   	stosb	byte ptr [rdi], al
-;; 914d:	 800100               	add	byte ptr [rcx], 0
-;; 9150:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9159:	 800100               	add	byte ptr [rcx], 0
-;; 915c:	 aa                   	stosb	byte ptr [rdi], al
-;; 915d:	 800100               	add	byte ptr [rcx], 0
-;; 9160:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9169:	 800100               	add	byte ptr [rcx], 0
-;; 916c:	 aa                   	stosb	byte ptr [rdi], al
-;; 916d:	 800100               	add	byte ptr [rcx], 0
-;; 9170:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9179:	 800100               	add	byte ptr [rcx], 0
-;; 917c:	 aa                   	stosb	byte ptr [rdi], al
-;; 917d:	 800100               	add	byte ptr [rcx], 0
-;; 9180:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9189:	 800100               	add	byte ptr [rcx], 0
-;; 918c:	 aa                   	stosb	byte ptr [rdi], al
-;; 918d:	 800100               	add	byte ptr [rcx], 0
-;; 9190:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9199:	 800100               	add	byte ptr [rcx], 0
-;; 919c:	 aa                   	stosb	byte ptr [rdi], al
-;; 919d:	 800100               	add	byte ptr [rcx], 0
-;; 91a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 91a9:	 800100               	add	byte ptr [rcx], 0
-;; 91ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 91ad:	 800100               	add	byte ptr [rcx], 0
-;; 91b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 91b9:	 800100               	add	byte ptr [rcx], 0
-;; 91bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 91bd:	 800100               	add	byte ptr [rcx], 0
-;; 91c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 91c9:	 800100               	add	byte ptr [rcx], 0
-;; 91cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 91cd:	 800100               	add	byte ptr [rcx], 0
-;; 91d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 91d9:	 800100               	add	byte ptr [rcx], 0
-;; 91dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 91dd:	 800100               	add	byte ptr [rcx], 0
-;; 91e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 91e9:	 800100               	add	byte ptr [rcx], 0
-;; 91ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 91ed:	 800100               	add	byte ptr [rcx], 0
-;; 91f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 91f9:	 800100               	add	byte ptr [rcx], 0
-;; 91fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 91fd:	 800100               	add	byte ptr [rcx], 0
-;; 9200:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9209:	 800100               	add	byte ptr [rcx], 0
-;; 920c:	 aa                   	stosb	byte ptr [rdi], al
-;; 920d:	 800100               	add	byte ptr [rcx], 0
-;; 9210:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9219:	 800100               	add	byte ptr [rcx], 0
-;; 921c:	 aa                   	stosb	byte ptr [rdi], al
-;; 921d:	 800100               	add	byte ptr [rcx], 0
-;; 9220:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9229:	 800100               	add	byte ptr [rcx], 0
-;; 922c:	 aa                   	stosb	byte ptr [rdi], al
-;; 922d:	 800100               	add	byte ptr [rcx], 0
-;; 9230:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9239:	 800100               	add	byte ptr [rcx], 0
-;; 923c:	 aa                   	stosb	byte ptr [rdi], al
-;; 923d:	 800100               	add	byte ptr [rcx], 0
-;; 9240:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9249:	 800100               	add	byte ptr [rcx], 0
-;; 924c:	 aa                   	stosb	byte ptr [rdi], al
-;; 924d:	 800100               	add	byte ptr [rcx], 0
-;; 9250:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9259:	 800100               	add	byte ptr [rcx], 0
-;; 925c:	 aa                   	stosb	byte ptr [rdi], al
-;; 925d:	 800100               	add	byte ptr [rcx], 0
-;; 9260:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9269:	 800100               	add	byte ptr [rcx], 0
-;; 926c:	 aa                   	stosb	byte ptr [rdi], al
-;; 926d:	 800100               	add	byte ptr [rcx], 0
-;; 9270:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9279:	 800100               	add	byte ptr [rcx], 0
-;; 927c:	 aa                   	stosb	byte ptr [rdi], al
-;; 927d:	 800100               	add	byte ptr [rcx], 0
-;; 9280:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9289:	 800100               	add	byte ptr [rcx], 0
-;; 928c:	 aa                   	stosb	byte ptr [rdi], al
-;; 928d:	 800100               	add	byte ptr [rcx], 0
-;; 9290:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9299:	 800100               	add	byte ptr [rcx], 0
-;; 929c:	 aa                   	stosb	byte ptr [rdi], al
-;; 929d:	 800100               	add	byte ptr [rcx], 0
-;; 92a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 92a9:	 800100               	add	byte ptr [rcx], 0
-;; 92ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 92ad:	 800100               	add	byte ptr [rcx], 0
-;; 92b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 92b9:	 800100               	add	byte ptr [rcx], 0
-;; 92bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 92bd:	 800100               	add	byte ptr [rcx], 0
-;; 92c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 92c9:	 800100               	add	byte ptr [rcx], 0
-;; 92cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 92cd:	 800100               	add	byte ptr [rcx], 0
-;; 92d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 92d9:	 800100               	add	byte ptr [rcx], 0
-;; 92dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 92dd:	 800100               	add	byte ptr [rcx], 0
-;; 92e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 92e9:	 800100               	add	byte ptr [rcx], 0
-;; 92ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 92ed:	 800100               	add	byte ptr [rcx], 0
-;; 92f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 92f9:	 800100               	add	byte ptr [rcx], 0
-;; 92fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 92fd:	 800100               	add	byte ptr [rcx], 0
-;; 9300:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9309:	 800100               	add	byte ptr [rcx], 0
-;; 930c:	 aa                   	stosb	byte ptr [rdi], al
-;; 930d:	 800100               	add	byte ptr [rcx], 0
-;; 9310:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9319:	 800100               	add	byte ptr [rcx], 0
-;; 931c:	 aa                   	stosb	byte ptr [rdi], al
-;; 931d:	 800100               	add	byte ptr [rcx], 0
-;; 9320:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9329:	 800100               	add	byte ptr [rcx], 0
-;; 932c:	 aa                   	stosb	byte ptr [rdi], al
-;; 932d:	 800100               	add	byte ptr [rcx], 0
-;; 9330:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9339:	 800100               	add	byte ptr [rcx], 0
-;; 933c:	 aa                   	stosb	byte ptr [rdi], al
-;; 933d:	 800100               	add	byte ptr [rcx], 0
-;; 9340:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9349:	 800100               	add	byte ptr [rcx], 0
-;; 934c:	 aa                   	stosb	byte ptr [rdi], al
-;; 934d:	 800100               	add	byte ptr [rcx], 0
-;; 9350:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9359:	 800100               	add	byte ptr [rcx], 0
-;; 935c:	 aa                   	stosb	byte ptr [rdi], al
-;; 935d:	 800100               	add	byte ptr [rcx], 0
-;; 9360:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9369:	 800100               	add	byte ptr [rcx], 0
-;; 936c:	 aa                   	stosb	byte ptr [rdi], al
-;; 936d:	 800100               	add	byte ptr [rcx], 0
-;; 9370:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9379:	 800100               	add	byte ptr [rcx], 0
-;; 937c:	 aa                   	stosb	byte ptr [rdi], al
-;; 937d:	 800100               	add	byte ptr [rcx], 0
-;; 9380:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9389:	 800100               	add	byte ptr [rcx], 0
-;; 938c:	 aa                   	stosb	byte ptr [rdi], al
-;; 938d:	 800100               	add	byte ptr [rcx], 0
-;; 9390:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9399:	 800100               	add	byte ptr [rcx], 0
-;; 939c:	 aa                   	stosb	byte ptr [rdi], al
-;; 939d:	 800100               	add	byte ptr [rcx], 0
-;; 93a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 93a9:	 800100               	add	byte ptr [rcx], 0
-;; 93ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 93ad:	 800100               	add	byte ptr [rcx], 0
-;; 93b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 93b9:	 800100               	add	byte ptr [rcx], 0
-;; 93bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 93bd:	 800100               	add	byte ptr [rcx], 0
-;; 93c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 93c9:	 800100               	add	byte ptr [rcx], 0
-;; 93cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 93cd:	 800100               	add	byte ptr [rcx], 0
-;; 93d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 93d9:	 800100               	add	byte ptr [rcx], 0
-;; 93dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 93dd:	 800100               	add	byte ptr [rcx], 0
-;; 93e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 93e9:	 800100               	add	byte ptr [rcx], 0
-;; 93ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 93ed:	 800100               	add	byte ptr [rcx], 0
-;; 93f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 93f9:	 800100               	add	byte ptr [rcx], 0
-;; 93fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 93fd:	 800100               	add	byte ptr [rcx], 0
-;; 9400:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9409:	 800100               	add	byte ptr [rcx], 0
-;; 940c:	 aa                   	stosb	byte ptr [rdi], al
-;; 940d:	 800100               	add	byte ptr [rcx], 0
-;; 9410:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9419:	 800100               	add	byte ptr [rcx], 0
-;; 941c:	 aa                   	stosb	byte ptr [rdi], al
-;; 941d:	 800100               	add	byte ptr [rcx], 0
-;; 9420:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9429:	 800100               	add	byte ptr [rcx], 0
-;; 942c:	 aa                   	stosb	byte ptr [rdi], al
-;; 942d:	 800100               	add	byte ptr [rcx], 0
-;; 9430:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9439:	 800100               	add	byte ptr [rcx], 0
-;; 943c:	 aa                   	stosb	byte ptr [rdi], al
-;; 943d:	 800100               	add	byte ptr [rcx], 0
-;; 9440:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9449:	 800100               	add	byte ptr [rcx], 0
-;; 944c:	 aa                   	stosb	byte ptr [rdi], al
-;; 944d:	 800100               	add	byte ptr [rcx], 0
-;; 9450:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9459:	 800100               	add	byte ptr [rcx], 0
-;; 945c:	 aa                   	stosb	byte ptr [rdi], al
-;; 945d:	 800100               	add	byte ptr [rcx], 0
-;; 9460:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9469:	 800100               	add	byte ptr [rcx], 0
-;; 946c:	 aa                   	stosb	byte ptr [rdi], al
-;; 946d:	 800100               	add	byte ptr [rcx], 0
-;; 9470:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9479:	 800100               	add	byte ptr [rcx], 0
-;; 947c:	 aa                   	stosb	byte ptr [rdi], al
-;; 947d:	 800100               	add	byte ptr [rcx], 0
-;; 9480:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9489:	 800100               	add	byte ptr [rcx], 0
-;; 948c:	 aa                   	stosb	byte ptr [rdi], al
-;; 948d:	 800100               	add	byte ptr [rcx], 0
-;; 9490:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9499:	 800100               	add	byte ptr [rcx], 0
-;; 949c:	 aa                   	stosb	byte ptr [rdi], al
-;; 949d:	 800100               	add	byte ptr [rcx], 0
-;; 94a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 94a9:	 800100               	add	byte ptr [rcx], 0
-;; 94ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 94ad:	 800100               	add	byte ptr [rcx], 0
-;; 94b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 94b9:	 800100               	add	byte ptr [rcx], 0
-;; 94bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 94bd:	 800100               	add	byte ptr [rcx], 0
-;; 94c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 94c9:	 800100               	add	byte ptr [rcx], 0
-;; 94cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 94cd:	 800100               	add	byte ptr [rcx], 0
-;; 94d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 94d9:	 800100               	add	byte ptr [rcx], 0
-;; 94dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 94dd:	 800100               	add	byte ptr [rcx], 0
-;; 94e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 94e9:	 800100               	add	byte ptr [rcx], 0
-;; 94ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 94ed:	 800100               	add	byte ptr [rcx], 0
-;; 94f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 94f9:	 800100               	add	byte ptr [rcx], 0
-;; 94fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 94fd:	 800100               	add	byte ptr [rcx], 0
-;; 9500:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9509:	 800100               	add	byte ptr [rcx], 0
-;; 950c:	 aa                   	stosb	byte ptr [rdi], al
-;; 950d:	 800100               	add	byte ptr [rcx], 0
-;; 9510:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9519:	 800100               	add	byte ptr [rcx], 0
-;; 951c:	 aa                   	stosb	byte ptr [rdi], al
-;; 951d:	 800100               	add	byte ptr [rcx], 0
-;; 9520:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9529:	 800100               	add	byte ptr [rcx], 0
-;; 952c:	 aa                   	stosb	byte ptr [rdi], al
-;; 952d:	 800100               	add	byte ptr [rcx], 0
-;; 9530:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9539:	 800100               	add	byte ptr [rcx], 0
-;; 953c:	 aa                   	stosb	byte ptr [rdi], al
-;; 953d:	 800100               	add	byte ptr [rcx], 0
-;; 9540:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9549:	 800100               	add	byte ptr [rcx], 0
-;; 954c:	 aa                   	stosb	byte ptr [rdi], al
-;; 954d:	 800100               	add	byte ptr [rcx], 0
-;; 9550:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9559:	 800100               	add	byte ptr [rcx], 0
-;; 955c:	 aa                   	stosb	byte ptr [rdi], al
-;; 955d:	 800100               	add	byte ptr [rcx], 0
-;; 9560:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9569:	 800100               	add	byte ptr [rcx], 0
-;; 956c:	 aa                   	stosb	byte ptr [rdi], al
-;; 956d:	 800100               	add	byte ptr [rcx], 0
-;; 9570:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9579:	 800100               	add	byte ptr [rcx], 0
-;; 957c:	 aa                   	stosb	byte ptr [rdi], al
-;; 957d:	 800100               	add	byte ptr [rcx], 0
-;; 9580:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9589:	 800100               	add	byte ptr [rcx], 0
-;; 958c:	 aa                   	stosb	byte ptr [rdi], al
-;; 958d:	 800100               	add	byte ptr [rcx], 0
-;; 9590:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9599:	 800100               	add	byte ptr [rcx], 0
-;; 959c:	 aa                   	stosb	byte ptr [rdi], al
-;; 959d:	 800100               	add	byte ptr [rcx], 0
-;; 95a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 95a9:	 800100               	add	byte ptr [rcx], 0
-;; 95ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 95ad:	 800100               	add	byte ptr [rcx], 0
-;; 95b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 95b9:	 800100               	add	byte ptr [rcx], 0
-;; 95bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 95bd:	 800100               	add	byte ptr [rcx], 0
-;; 95c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 95c9:	 800100               	add	byte ptr [rcx], 0
-;; 95cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 95cd:	 800100               	add	byte ptr [rcx], 0
-;; 95d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 95d9:	 800100               	add	byte ptr [rcx], 0
-;; 95dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 95dd:	 800100               	add	byte ptr [rcx], 0
-;; 95e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 95e9:	 800100               	add	byte ptr [rcx], 0
-;; 95ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 95ed:	 800100               	add	byte ptr [rcx], 0
-;; 95f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 95f9:	 800100               	add	byte ptr [rcx], 0
-;; 95fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 95fd:	 800100               	add	byte ptr [rcx], 0
-;; 9600:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9609:	 800100               	add	byte ptr [rcx], 0
-;; 960c:	 aa                   	stosb	byte ptr [rdi], al
-;; 960d:	 800100               	add	byte ptr [rcx], 0
-;; 9610:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9619:	 800100               	add	byte ptr [rcx], 0
-;; 961c:	 aa                   	stosb	byte ptr [rdi], al
-;; 961d:	 800100               	add	byte ptr [rcx], 0
-;; 9620:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9629:	 800100               	add	byte ptr [rcx], 0
-;; 962c:	 aa                   	stosb	byte ptr [rdi], al
-;; 962d:	 800100               	add	byte ptr [rcx], 0
-;; 9630:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9639:	 800100               	add	byte ptr [rcx], 0
-;; 963c:	 aa                   	stosb	byte ptr [rdi], al
-;; 963d:	 800100               	add	byte ptr [rcx], 0
-;; 9640:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9649:	 800100               	add	byte ptr [rcx], 0
-;; 964c:	 aa                   	stosb	byte ptr [rdi], al
-;; 964d:	 800100               	add	byte ptr [rcx], 0
-;; 9650:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9659:	 800100               	add	byte ptr [rcx], 0
-;; 965c:	 aa                   	stosb	byte ptr [rdi], al
-;; 965d:	 800100               	add	byte ptr [rcx], 0
-;; 9660:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9669:	 800100               	add	byte ptr [rcx], 0
-;; 966c:	 aa                   	stosb	byte ptr [rdi], al
-;; 966d:	 800100               	add	byte ptr [rcx], 0
-;; 9670:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9679:	 800100               	add	byte ptr [rcx], 0
-;; 967c:	 aa                   	stosb	byte ptr [rdi], al
-;; 967d:	 800100               	add	byte ptr [rcx], 0
-;; 9680:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9689:	 800100               	add	byte ptr [rcx], 0
-;; 968c:	 aa                   	stosb	byte ptr [rdi], al
-;; 968d:	 800100               	add	byte ptr [rcx], 0
-;; 9690:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9699:	 800100               	add	byte ptr [rcx], 0
-;; 969c:	 aa                   	stosb	byte ptr [rdi], al
-;; 969d:	 800100               	add	byte ptr [rcx], 0
-;; 96a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 96a9:	 800100               	add	byte ptr [rcx], 0
-;; 96ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 96ad:	 800100               	add	byte ptr [rcx], 0
-;; 96b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 96b9:	 800100               	add	byte ptr [rcx], 0
-;; 96bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 96bd:	 800100               	add	byte ptr [rcx], 0
-;; 96c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 96c9:	 800100               	add	byte ptr [rcx], 0
-;; 96cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 96cd:	 800100               	add	byte ptr [rcx], 0
-;; 96d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 96d9:	 800100               	add	byte ptr [rcx], 0
-;; 96dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 96dd:	 800100               	add	byte ptr [rcx], 0
-;; 96e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 96e9:	 800100               	add	byte ptr [rcx], 0
-;; 96ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 96ed:	 800100               	add	byte ptr [rcx], 0
-;; 96f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 96f9:	 800100               	add	byte ptr [rcx], 0
-;; 96fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 96fd:	 800100               	add	byte ptr [rcx], 0
-;; 9700:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9709:	 800100               	add	byte ptr [rcx], 0
-;; 970c:	 aa                   	stosb	byte ptr [rdi], al
-;; 970d:	 800100               	add	byte ptr [rcx], 0
-;; 9710:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9719:	 800100               	add	byte ptr [rcx], 0
-;; 971c:	 aa                   	stosb	byte ptr [rdi], al
-;; 971d:	 800100               	add	byte ptr [rcx], 0
-;; 9720:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9729:	 800100               	add	byte ptr [rcx], 0
-;; 972c:	 aa                   	stosb	byte ptr [rdi], al
-;; 972d:	 800100               	add	byte ptr [rcx], 0
-;; 9730:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9739:	 800100               	add	byte ptr [rcx], 0
-;; 973c:	 aa                   	stosb	byte ptr [rdi], al
-;; 973d:	 800100               	add	byte ptr [rcx], 0
-;; 9740:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9749:	 800100               	add	byte ptr [rcx], 0
-;; 974c:	 aa                   	stosb	byte ptr [rdi], al
-;; 974d:	 800100               	add	byte ptr [rcx], 0
-;; 9750:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9759:	 800100               	add	byte ptr [rcx], 0
-;; 975c:	 aa                   	stosb	byte ptr [rdi], al
-;; 975d:	 800100               	add	byte ptr [rcx], 0
-;; 9760:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9769:	 800100               	add	byte ptr [rcx], 0
-;; 976c:	 aa                   	stosb	byte ptr [rdi], al
-;; 976d:	 800100               	add	byte ptr [rcx], 0
-;; 9770:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9779:	 800100               	add	byte ptr [rcx], 0
-;; 977c:	 aa                   	stosb	byte ptr [rdi], al
-;; 977d:	 800100               	add	byte ptr [rcx], 0
-;; 9780:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9789:	 800100               	add	byte ptr [rcx], 0
-;; 978c:	 aa                   	stosb	byte ptr [rdi], al
-;; 978d:	 800100               	add	byte ptr [rcx], 0
-;; 9790:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9799:	 800100               	add	byte ptr [rcx], 0
-;; 979c:	 aa                   	stosb	byte ptr [rdi], al
-;; 979d:	 800100               	add	byte ptr [rcx], 0
-;; 97a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 97a9:	 800100               	add	byte ptr [rcx], 0
-;; 97ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 97ad:	 800100               	add	byte ptr [rcx], 0
-;; 97b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 97b9:	 800100               	add	byte ptr [rcx], 0
-;; 97bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 97bd:	 800100               	add	byte ptr [rcx], 0
-;; 97c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 97c9:	 800100               	add	byte ptr [rcx], 0
-;; 97cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 97cd:	 800100               	add	byte ptr [rcx], 0
-;; 97d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 97d9:	 800100               	add	byte ptr [rcx], 0
-;; 97dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 97dd:	 800100               	add	byte ptr [rcx], 0
-;; 97e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 97e9:	 800100               	add	byte ptr [rcx], 0
-;; 97ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 97ed:	 800100               	add	byte ptr [rcx], 0
-;; 97f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 97f9:	 800100               	add	byte ptr [rcx], 0
-;; 97fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 97fd:	 800100               	add	byte ptr [rcx], 0
-;; 9800:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9809:	 800100               	add	byte ptr [rcx], 0
-;; 980c:	 aa                   	stosb	byte ptr [rdi], al
-;; 980d:	 800100               	add	byte ptr [rcx], 0
-;; 9810:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9819:	 800100               	add	byte ptr [rcx], 0
-;; 981c:	 aa                   	stosb	byte ptr [rdi], al
-;; 981d:	 800100               	add	byte ptr [rcx], 0
-;; 9820:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9829:	 800100               	add	byte ptr [rcx], 0
-;; 982c:	 aa                   	stosb	byte ptr [rdi], al
-;; 982d:	 800100               	add	byte ptr [rcx], 0
-;; 9830:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9839:	 800100               	add	byte ptr [rcx], 0
-;; 983c:	 aa                   	stosb	byte ptr [rdi], al
-;; 983d:	 800100               	add	byte ptr [rcx], 0
-;; 9840:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9849:	 800100               	add	byte ptr [rcx], 0
-;; 984c:	 aa                   	stosb	byte ptr [rdi], al
-;; 984d:	 800100               	add	byte ptr [rcx], 0
-;; 9850:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9859:	 800100               	add	byte ptr [rcx], 0
-;; 985c:	 aa                   	stosb	byte ptr [rdi], al
-;; 985d:	 800100               	add	byte ptr [rcx], 0
-;; 9860:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9869:	 800100               	add	byte ptr [rcx], 0
-;; 986c:	 aa                   	stosb	byte ptr [rdi], al
-;; 986d:	 800100               	add	byte ptr [rcx], 0
-;; 9870:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9879:	 800100               	add	byte ptr [rcx], 0
-;; 987c:	 aa                   	stosb	byte ptr [rdi], al
-;; 987d:	 800100               	add	byte ptr [rcx], 0
-;; 9880:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9889:	 800100               	add	byte ptr [rcx], 0
-;; 988c:	 aa                   	stosb	byte ptr [rdi], al
-;; 988d:	 800100               	add	byte ptr [rcx], 0
-;; 9890:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9899:	 800100               	add	byte ptr [rcx], 0
-;; 989c:	 aa                   	stosb	byte ptr [rdi], al
-;; 989d:	 800100               	add	byte ptr [rcx], 0
-;; 98a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 98a9:	 800100               	add	byte ptr [rcx], 0
-;; 98ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 98ad:	 800100               	add	byte ptr [rcx], 0
-;; 98b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 98b9:	 800100               	add	byte ptr [rcx], 0
-;; 98bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 98bd:	 800100               	add	byte ptr [rcx], 0
-;; 98c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 98c9:	 800100               	add	byte ptr [rcx], 0
-;; 98cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 98cd:	 800100               	add	byte ptr [rcx], 0
-;; 98d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 98d9:	 800100               	add	byte ptr [rcx], 0
-;; 98dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 98dd:	 800100               	add	byte ptr [rcx], 0
-;; 98e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 98e9:	 800100               	add	byte ptr [rcx], 0
-;; 98ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 98ed:	 800100               	add	byte ptr [rcx], 0
-;; 98f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 98f9:	 800100               	add	byte ptr [rcx], 0
-;; 98fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 98fd:	 800100               	add	byte ptr [rcx], 0
-;; 9900:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9909:	 800100               	add	byte ptr [rcx], 0
-;; 990c:	 aa                   	stosb	byte ptr [rdi], al
-;; 990d:	 800100               	add	byte ptr [rcx], 0
-;; 9910:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9919:	 800100               	add	byte ptr [rcx], 0
-;; 991c:	 aa                   	stosb	byte ptr [rdi], al
-;; 991d:	 800100               	add	byte ptr [rcx], 0
-;; 9920:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9929:	 800100               	add	byte ptr [rcx], 0
-;; 992c:	 aa                   	stosb	byte ptr [rdi], al
-;; 992d:	 800100               	add	byte ptr [rcx], 0
-;; 9930:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9939:	 800100               	add	byte ptr [rcx], 0
-;; 993c:	 aa                   	stosb	byte ptr [rdi], al
-;; 993d:	 800100               	add	byte ptr [rcx], 0
-;; 9940:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9949:	 800100               	add	byte ptr [rcx], 0
-;; 994c:	 aa                   	stosb	byte ptr [rdi], al
-;; 994d:	 800100               	add	byte ptr [rcx], 0
-;; 9950:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9959:	 800100               	add	byte ptr [rcx], 0
-;; 995c:	 aa                   	stosb	byte ptr [rdi], al
-;; 995d:	 800100               	add	byte ptr [rcx], 0
-;; 9960:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9969:	 800100               	add	byte ptr [rcx], 0
-;; 996c:	 aa                   	stosb	byte ptr [rdi], al
-;; 996d:	 800100               	add	byte ptr [rcx], 0
-;; 9970:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9979:	 800100               	add	byte ptr [rcx], 0
-;; 997c:	 aa                   	stosb	byte ptr [rdi], al
-;; 997d:	 800100               	add	byte ptr [rcx], 0
-;; 9980:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9989:	 800100               	add	byte ptr [rcx], 0
-;; 998c:	 aa                   	stosb	byte ptr [rdi], al
-;; 998d:	 800100               	add	byte ptr [rcx], 0
-;; 9990:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9999:	 800100               	add	byte ptr [rcx], 0
-;; 999c:	 aa                   	stosb	byte ptr [rdi], al
-;; 999d:	 800100               	add	byte ptr [rcx], 0
-;; 99a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 99a9:	 800100               	add	byte ptr [rcx], 0
-;; 99ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 99ad:	 800100               	add	byte ptr [rcx], 0
-;; 99b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 99b9:	 800100               	add	byte ptr [rcx], 0
-;; 99bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 99bd:	 800100               	add	byte ptr [rcx], 0
-;; 99c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 99c9:	 800100               	add	byte ptr [rcx], 0
-;; 99cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 99cd:	 800100               	add	byte ptr [rcx], 0
-;; 99d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 99d9:	 800100               	add	byte ptr [rcx], 0
-;; 99dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 99dd:	 800100               	add	byte ptr [rcx], 0
-;; 99e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 99e9:	 800100               	add	byte ptr [rcx], 0
-;; 99ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 99ed:	 800100               	add	byte ptr [rcx], 0
-;; 99f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 99f9:	 800100               	add	byte ptr [rcx], 0
-;; 99fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 99fd:	 800100               	add	byte ptr [rcx], 0
-;; 9a00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9a09:	 800100               	add	byte ptr [rcx], 0
-;; 9a0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9a0d:	 800100               	add	byte ptr [rcx], 0
-;; 9a10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9a19:	 800100               	add	byte ptr [rcx], 0
-;; 9a1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9a1d:	 800100               	add	byte ptr [rcx], 0
-;; 9a20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9a29:	 800100               	add	byte ptr [rcx], 0
-;; 9a2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9a2d:	 800100               	add	byte ptr [rcx], 0
-;; 9a30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9a39:	 800100               	add	byte ptr [rcx], 0
-;; 9a3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9a3d:	 800100               	add	byte ptr [rcx], 0
-;; 9a40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9a49:	 800100               	add	byte ptr [rcx], 0
-;; 9a4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9a4d:	 800100               	add	byte ptr [rcx], 0
-;; 9a50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9a59:	 800100               	add	byte ptr [rcx], 0
-;; 9a5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9a5d:	 800100               	add	byte ptr [rcx], 0
-;; 9a60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9a69:	 800100               	add	byte ptr [rcx], 0
-;; 9a6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9a6d:	 800100               	add	byte ptr [rcx], 0
-;; 9a70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9a79:	 800100               	add	byte ptr [rcx], 0
-;; 9a7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9a7d:	 800100               	add	byte ptr [rcx], 0
-;; 9a80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9a89:	 800100               	add	byte ptr [rcx], 0
-;; 9a8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9a8d:	 800100               	add	byte ptr [rcx], 0
-;; 9a90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9a99:	 800100               	add	byte ptr [rcx], 0
-;; 9a9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9a9d:	 800100               	add	byte ptr [rcx], 0
-;; 9aa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9aa9:	 800100               	add	byte ptr [rcx], 0
-;; 9aac:	 aa                   	stosb	byte ptr [rdi], al
-;; 9aad:	 800100               	add	byte ptr [rcx], 0
-;; 9ab0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9ab9:	 800100               	add	byte ptr [rcx], 0
-;; 9abc:	 aa                   	stosb	byte ptr [rdi], al
-;; 9abd:	 800100               	add	byte ptr [rcx], 0
-;; 9ac0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9ac9:	 800100               	add	byte ptr [rcx], 0
-;; 9acc:	 aa                   	stosb	byte ptr [rdi], al
-;; 9acd:	 800100               	add	byte ptr [rcx], 0
-;; 9ad0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9ad9:	 800100               	add	byte ptr [rcx], 0
-;; 9adc:	 aa                   	stosb	byte ptr [rdi], al
-;; 9add:	 800100               	add	byte ptr [rcx], 0
-;; 9ae0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9ae9:	 800100               	add	byte ptr [rcx], 0
-;; 9aec:	 aa                   	stosb	byte ptr [rdi], al
-;; 9aed:	 800100               	add	byte ptr [rcx], 0
-;; 9af0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9af9:	 800100               	add	byte ptr [rcx], 0
-;; 9afc:	 aa                   	stosb	byte ptr [rdi], al
-;; 9afd:	 800100               	add	byte ptr [rcx], 0
-;; 9b00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9b09:	 800100               	add	byte ptr [rcx], 0
-;; 9b0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9b0d:	 800100               	add	byte ptr [rcx], 0
-;; 9b10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9b19:	 800100               	add	byte ptr [rcx], 0
-;; 9b1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9b1d:	 800100               	add	byte ptr [rcx], 0
-;; 9b20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9b29:	 800100               	add	byte ptr [rcx], 0
-;; 9b2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9b2d:	 800100               	add	byte ptr [rcx], 0
-;; 9b30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9b39:	 800100               	add	byte ptr [rcx], 0
-;; 9b3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9b3d:	 800100               	add	byte ptr [rcx], 0
-;; 9b40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9b49:	 800100               	add	byte ptr [rcx], 0
-;; 9b4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9b4d:	 800100               	add	byte ptr [rcx], 0
-;; 9b50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9b59:	 800100               	add	byte ptr [rcx], 0
-;; 9b5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9b5d:	 800100               	add	byte ptr [rcx], 0
-;; 9b60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9b69:	 800100               	add	byte ptr [rcx], 0
-;; 9b6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9b6d:	 800100               	add	byte ptr [rcx], 0
-;; 9b70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9b79:	 800100               	add	byte ptr [rcx], 0
-;; 9b7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9b7d:	 800100               	add	byte ptr [rcx], 0
-;; 9b80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9b89:	 800100               	add	byte ptr [rcx], 0
-;; 9b8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9b8d:	 800100               	add	byte ptr [rcx], 0
-;; 9b90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9b99:	 800100               	add	byte ptr [rcx], 0
-;; 9b9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9b9d:	 800100               	add	byte ptr [rcx], 0
-;; 9ba0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9ba9:	 800100               	add	byte ptr [rcx], 0
-;; 9bac:	 aa                   	stosb	byte ptr [rdi], al
-;; 9bad:	 800100               	add	byte ptr [rcx], 0
-;; 9bb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9bb9:	 800100               	add	byte ptr [rcx], 0
-;; 9bbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 9bbd:	 800100               	add	byte ptr [rcx], 0
-;; 9bc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9bc9:	 800100               	add	byte ptr [rcx], 0
-;; 9bcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 9bcd:	 800100               	add	byte ptr [rcx], 0
-;; 9bd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9bd9:	 800100               	add	byte ptr [rcx], 0
-;; 9bdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 9bdd:	 800100               	add	byte ptr [rcx], 0
-;; 9be0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9be9:	 800100               	add	byte ptr [rcx], 0
-;; 9bec:	 aa                   	stosb	byte ptr [rdi], al
-;; 9bed:	 800100               	add	byte ptr [rcx], 0
-;; 9bf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9bf9:	 800100               	add	byte ptr [rcx], 0
-;; 9bfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 9bfd:	 800100               	add	byte ptr [rcx], 0
-;; 9c00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9c09:	 800100               	add	byte ptr [rcx], 0
-;; 9c0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9c0d:	 800100               	add	byte ptr [rcx], 0
-;; 9c10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9c19:	 800100               	add	byte ptr [rcx], 0
-;; 9c1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9c1d:	 800100               	add	byte ptr [rcx], 0
-;; 9c20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9c29:	 800100               	add	byte ptr [rcx], 0
-;; 9c2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9c2d:	 800100               	add	byte ptr [rcx], 0
-;; 9c30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9c39:	 800100               	add	byte ptr [rcx], 0
-;; 9c3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9c3d:	 800100               	add	byte ptr [rcx], 0
-;; 9c40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9c49:	 800100               	add	byte ptr [rcx], 0
-;; 9c4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9c4d:	 800100               	add	byte ptr [rcx], 0
-;; 9c50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9c59:	 800100               	add	byte ptr [rcx], 0
-;; 9c5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9c5d:	 800100               	add	byte ptr [rcx], 0
-;; 9c60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9c69:	 800100               	add	byte ptr [rcx], 0
-;; 9c6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9c6d:	 800100               	add	byte ptr [rcx], 0
-;; 9c70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9c79:	 800100               	add	byte ptr [rcx], 0
-;; 9c7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9c7d:	 800100               	add	byte ptr [rcx], 0
-;; 9c80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9c89:	 800100               	add	byte ptr [rcx], 0
-;; 9c8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9c8d:	 800100               	add	byte ptr [rcx], 0
-;; 9c90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9c99:	 800100               	add	byte ptr [rcx], 0
-;; 9c9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9c9d:	 800100               	add	byte ptr [rcx], 0
-;; 9ca0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9ca9:	 800100               	add	byte ptr [rcx], 0
-;; 9cac:	 aa                   	stosb	byte ptr [rdi], al
-;; 9cad:	 800100               	add	byte ptr [rcx], 0
-;; 9cb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9cb9:	 800100               	add	byte ptr [rcx], 0
-;; 9cbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 9cbd:	 800100               	add	byte ptr [rcx], 0
-;; 9cc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9cc9:	 800100               	add	byte ptr [rcx], 0
-;; 9ccc:	 aa                   	stosb	byte ptr [rdi], al
-;; 9ccd:	 800100               	add	byte ptr [rcx], 0
-;; 9cd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9cd9:	 800100               	add	byte ptr [rcx], 0
-;; 9cdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 9cdd:	 800100               	add	byte ptr [rcx], 0
-;; 9ce0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9ce9:	 800100               	add	byte ptr [rcx], 0
-;; 9cec:	 aa                   	stosb	byte ptr [rdi], al
-;; 9ced:	 800100               	add	byte ptr [rcx], 0
-;; 9cf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9cf9:	 800100               	add	byte ptr [rcx], 0
-;; 9cfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 9cfd:	 800100               	add	byte ptr [rcx], 0
-;; 9d00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9d09:	 800100               	add	byte ptr [rcx], 0
-;; 9d0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9d0d:	 800100               	add	byte ptr [rcx], 0
-;; 9d10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9d19:	 800100               	add	byte ptr [rcx], 0
-;; 9d1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9d1d:	 800100               	add	byte ptr [rcx], 0
-;; 9d20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9d29:	 800100               	add	byte ptr [rcx], 0
-;; 9d2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9d2d:	 800100               	add	byte ptr [rcx], 0
-;; 9d30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9d39:	 800100               	add	byte ptr [rcx], 0
-;; 9d3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9d3d:	 800100               	add	byte ptr [rcx], 0
-;; 9d40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9d49:	 800100               	add	byte ptr [rcx], 0
-;; 9d4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9d4d:	 800100               	add	byte ptr [rcx], 0
-;; 9d50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9d59:	 800100               	add	byte ptr [rcx], 0
-;; 9d5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9d5d:	 800100               	add	byte ptr [rcx], 0
-;; 9d60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9d69:	 800100               	add	byte ptr [rcx], 0
-;; 9d6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9d6d:	 800100               	add	byte ptr [rcx], 0
-;; 9d70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9d79:	 800100               	add	byte ptr [rcx], 0
-;; 9d7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9d7d:	 800100               	add	byte ptr [rcx], 0
-;; 9d80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9d89:	 800100               	add	byte ptr [rcx], 0
-;; 9d8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9d8d:	 800100               	add	byte ptr [rcx], 0
-;; 9d90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9d99:	 800100               	add	byte ptr [rcx], 0
-;; 9d9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9d9d:	 800100               	add	byte ptr [rcx], 0
-;; 9da0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9da9:	 800100               	add	byte ptr [rcx], 0
-;; 9dac:	 aa                   	stosb	byte ptr [rdi], al
-;; 9dad:	 800100               	add	byte ptr [rcx], 0
-;; 9db0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9db9:	 800100               	add	byte ptr [rcx], 0
-;; 9dbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 9dbd:	 800100               	add	byte ptr [rcx], 0
-;; 9dc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9dc9:	 800100               	add	byte ptr [rcx], 0
-;; 9dcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 9dcd:	 800100               	add	byte ptr [rcx], 0
-;; 9dd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9dd9:	 800100               	add	byte ptr [rcx], 0
-;; 9ddc:	 aa                   	stosb	byte ptr [rdi], al
-;; 9ddd:	 800100               	add	byte ptr [rcx], 0
-;; 9de0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9de9:	 800100               	add	byte ptr [rcx], 0
-;; 9dec:	 aa                   	stosb	byte ptr [rdi], al
-;; 9ded:	 800100               	add	byte ptr [rcx], 0
-;; 9df0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9df9:	 800100               	add	byte ptr [rcx], 0
-;; 9dfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 9dfd:	 800100               	add	byte ptr [rcx], 0
-;; 9e00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9e09:	 800100               	add	byte ptr [rcx], 0
-;; 9e0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9e0d:	 800100               	add	byte ptr [rcx], 0
-;; 9e10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9e19:	 800100               	add	byte ptr [rcx], 0
-;; 9e1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9e1d:	 800100               	add	byte ptr [rcx], 0
-;; 9e20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9e29:	 800100               	add	byte ptr [rcx], 0
-;; 9e2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9e2d:	 800100               	add	byte ptr [rcx], 0
-;; 9e30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9e39:	 800100               	add	byte ptr [rcx], 0
-;; 9e3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9e3d:	 800100               	add	byte ptr [rcx], 0
-;; 9e40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9e49:	 800100               	add	byte ptr [rcx], 0
-;; 9e4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9e4d:	 800100               	add	byte ptr [rcx], 0
-;; 9e50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9e59:	 800100               	add	byte ptr [rcx], 0
-;; 9e5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9e5d:	 800100               	add	byte ptr [rcx], 0
-;; 9e60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9e69:	 800100               	add	byte ptr [rcx], 0
-;; 9e6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9e6d:	 800100               	add	byte ptr [rcx], 0
-;; 9e70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9e79:	 800100               	add	byte ptr [rcx], 0
-;; 9e7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9e7d:	 800100               	add	byte ptr [rcx], 0
-;; 9e80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9e89:	 800100               	add	byte ptr [rcx], 0
-;; 9e8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9e8d:	 800100               	add	byte ptr [rcx], 0
-;; 9e90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9e99:	 800100               	add	byte ptr [rcx], 0
-;; 9e9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9e9d:	 800100               	add	byte ptr [rcx], 0
-;; 9ea0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9ea9:	 800100               	add	byte ptr [rcx], 0
-;; 9eac:	 aa                   	stosb	byte ptr [rdi], al
-;; 9ead:	 800100               	add	byte ptr [rcx], 0
-;; 9eb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9eb9:	 800100               	add	byte ptr [rcx], 0
-;; 9ebc:	 aa                   	stosb	byte ptr [rdi], al
-;; 9ebd:	 800100               	add	byte ptr [rcx], 0
-;; 9ec0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9ec9:	 800100               	add	byte ptr [rcx], 0
-;; 9ecc:	 aa                   	stosb	byte ptr [rdi], al
-;; 9ecd:	 800100               	add	byte ptr [rcx], 0
-;; 9ed0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9ed9:	 800100               	add	byte ptr [rcx], 0
-;; 9edc:	 aa                   	stosb	byte ptr [rdi], al
-;; 9edd:	 800100               	add	byte ptr [rcx], 0
-;; 9ee0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9ee9:	 800100               	add	byte ptr [rcx], 0
-;; 9eec:	 aa                   	stosb	byte ptr [rdi], al
-;; 9eed:	 800100               	add	byte ptr [rcx], 0
-;; 9ef0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9ef9:	 800100               	add	byte ptr [rcx], 0
-;; 9efc:	 aa                   	stosb	byte ptr [rdi], al
-;; 9efd:	 800100               	add	byte ptr [rcx], 0
-;; 9f00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9f09:	 800100               	add	byte ptr [rcx], 0
-;; 9f0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9f0d:	 800100               	add	byte ptr [rcx], 0
-;; 9f10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9f19:	 800100               	add	byte ptr [rcx], 0
-;; 9f1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9f1d:	 800100               	add	byte ptr [rcx], 0
-;; 9f20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9f29:	 800100               	add	byte ptr [rcx], 0
-;; 9f2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9f2d:	 800100               	add	byte ptr [rcx], 0
-;; 9f30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9f39:	 800100               	add	byte ptr [rcx], 0
-;; 9f3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9f3d:	 800100               	add	byte ptr [rcx], 0
-;; 9f40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9f49:	 800100               	add	byte ptr [rcx], 0
-;; 9f4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9f4d:	 800100               	add	byte ptr [rcx], 0
-;; 9f50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9f59:	 800100               	add	byte ptr [rcx], 0
-;; 9f5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9f5d:	 800100               	add	byte ptr [rcx], 0
-;; 9f60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9f69:	 800100               	add	byte ptr [rcx], 0
-;; 9f6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9f6d:	 800100               	add	byte ptr [rcx], 0
-;; 9f70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9f79:	 800100               	add	byte ptr [rcx], 0
-;; 9f7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9f7d:	 800100               	add	byte ptr [rcx], 0
-;; 9f80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9f89:	 800100               	add	byte ptr [rcx], 0
-;; 9f8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9f8d:	 800100               	add	byte ptr [rcx], 0
-;; 9f90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9f99:	 800100               	add	byte ptr [rcx], 0
-;; 9f9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 9f9d:	 800100               	add	byte ptr [rcx], 0
-;; 9fa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9fa9:	 800100               	add	byte ptr [rcx], 0
-;; 9fac:	 aa                   	stosb	byte ptr [rdi], al
-;; 9fad:	 800100               	add	byte ptr [rcx], 0
-;; 9fb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9fb9:	 800100               	add	byte ptr [rcx], 0
-;; 9fbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 9fbd:	 800100               	add	byte ptr [rcx], 0
-;; 9fc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9fc9:	 800100               	add	byte ptr [rcx], 0
-;; 9fcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 9fcd:	 800100               	add	byte ptr [rcx], 0
-;; 9fd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9fd9:	 800100               	add	byte ptr [rcx], 0
-;; 9fdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 9fdd:	 800100               	add	byte ptr [rcx], 0
-;; 9fe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9fe9:	 800100               	add	byte ptr [rcx], 0
-;; 9fec:	 aa                   	stosb	byte ptr [rdi], al
-;; 9fed:	 800100               	add	byte ptr [rcx], 0
-;; 9ff0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 9ff9:	 800100               	add	byte ptr [rcx], 0
-;; 9ffc:	 aa                   	stosb	byte ptr [rdi], al
-;; 9ffd:	 800100               	add	byte ptr [rcx], 0
-;; a000:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a009:	 800100               	add	byte ptr [rcx], 0
-;; a00c:	 aa                   	stosb	byte ptr [rdi], al
-;; a00d:	 800100               	add	byte ptr [rcx], 0
-;; a010:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a019:	 800100               	add	byte ptr [rcx], 0
-;; a01c:	 aa                   	stosb	byte ptr [rdi], al
-;; a01d:	 800100               	add	byte ptr [rcx], 0
-;; a020:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a029:	 800100               	add	byte ptr [rcx], 0
-;; a02c:	 aa                   	stosb	byte ptr [rdi], al
-;; a02d:	 800100               	add	byte ptr [rcx], 0
-;; a030:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a039:	 800100               	add	byte ptr [rcx], 0
-;; a03c:	 aa                   	stosb	byte ptr [rdi], al
-;; a03d:	 800100               	add	byte ptr [rcx], 0
-;; a040:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a049:	 800100               	add	byte ptr [rcx], 0
-;; a04c:	 aa                   	stosb	byte ptr [rdi], al
-;; a04d:	 800100               	add	byte ptr [rcx], 0
-;; a050:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a059:	 800100               	add	byte ptr [rcx], 0
-;; a05c:	 aa                   	stosb	byte ptr [rdi], al
-;; a05d:	 800100               	add	byte ptr [rcx], 0
-;; a060:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a069:	 800100               	add	byte ptr [rcx], 0
-;; a06c:	 aa                   	stosb	byte ptr [rdi], al
-;; a06d:	 800100               	add	byte ptr [rcx], 0
-;; a070:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a079:	 800100               	add	byte ptr [rcx], 0
-;; a07c:	 aa                   	stosb	byte ptr [rdi], al
-;; a07d:	 800100               	add	byte ptr [rcx], 0
-;; a080:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a089:	 800100               	add	byte ptr [rcx], 0
-;; a08c:	 aa                   	stosb	byte ptr [rdi], al
-;; a08d:	 800100               	add	byte ptr [rcx], 0
-;; a090:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a099:	 800100               	add	byte ptr [rcx], 0
-;; a09c:	 aa                   	stosb	byte ptr [rdi], al
-;; a09d:	 800100               	add	byte ptr [rcx], 0
-;; a0a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a0a9:	 800100               	add	byte ptr [rcx], 0
-;; a0ac:	 aa                   	stosb	byte ptr [rdi], al
-;; a0ad:	 800100               	add	byte ptr [rcx], 0
-;; a0b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a0b9:	 800100               	add	byte ptr [rcx], 0
-;; a0bc:	 aa                   	stosb	byte ptr [rdi], al
-;; a0bd:	 800100               	add	byte ptr [rcx], 0
-;; a0c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a0c9:	 800100               	add	byte ptr [rcx], 0
-;; a0cc:	 aa                   	stosb	byte ptr [rdi], al
-;; a0cd:	 800100               	add	byte ptr [rcx], 0
-;; a0d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a0d9:	 800100               	add	byte ptr [rcx], 0
-;; a0dc:	 aa                   	stosb	byte ptr [rdi], al
-;; a0dd:	 800100               	add	byte ptr [rcx], 0
-;; a0e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a0e9:	 800100               	add	byte ptr [rcx], 0
-;; a0ec:	 aa                   	stosb	byte ptr [rdi], al
-;; a0ed:	 800100               	add	byte ptr [rcx], 0
-;; a0f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a0f9:	 800100               	add	byte ptr [rcx], 0
-;; a0fc:	 aa                   	stosb	byte ptr [rdi], al
-;; a0fd:	 800100               	add	byte ptr [rcx], 0
-;; a100:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a109:	 800100               	add	byte ptr [rcx], 0
-;; a10c:	 aa                   	stosb	byte ptr [rdi], al
-;; a10d:	 800100               	add	byte ptr [rcx], 0
-;; a110:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a119:	 800100               	add	byte ptr [rcx], 0
-;; a11c:	 aa                   	stosb	byte ptr [rdi], al
-;; a11d:	 800100               	add	byte ptr [rcx], 0
-;; a120:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a129:	 800100               	add	byte ptr [rcx], 0
-;; a12c:	 aa                   	stosb	byte ptr [rdi], al
-;; a12d:	 800100               	add	byte ptr [rcx], 0
-;; a130:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a139:	 800100               	add	byte ptr [rcx], 0
-;; a13c:	 aa                   	stosb	byte ptr [rdi], al
-;; a13d:	 800100               	add	byte ptr [rcx], 0
-;; a140:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a149:	 800100               	add	byte ptr [rcx], 0
-;; a14c:	 aa                   	stosb	byte ptr [rdi], al
-;; a14d:	 800100               	add	byte ptr [rcx], 0
-;; a150:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a159:	 800100               	add	byte ptr [rcx], 0
-;; a15c:	 aa                   	stosb	byte ptr [rdi], al
-;; a15d:	 800100               	add	byte ptr [rcx], 0
-;; a160:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a169:	 800100               	add	byte ptr [rcx], 0
-;; a16c:	 aa                   	stosb	byte ptr [rdi], al
-;; a16d:	 800100               	add	byte ptr [rcx], 0
-;; a170:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a179:	 800100               	add	byte ptr [rcx], 0
-;; a17c:	 aa                   	stosb	byte ptr [rdi], al
-;; a17d:	 800100               	add	byte ptr [rcx], 0
-;; a180:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a189:	 800100               	add	byte ptr [rcx], 0
-;; a18c:	 aa                   	stosb	byte ptr [rdi], al
-;; a18d:	 800100               	add	byte ptr [rcx], 0
-;; a190:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a199:	 800100               	add	byte ptr [rcx], 0
-;; a19c:	 aa                   	stosb	byte ptr [rdi], al
-;; a19d:	 800100               	add	byte ptr [rcx], 0
-;; a1a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a1a9:	 800100               	add	byte ptr [rcx], 0
-;; a1ac:	 aa                   	stosb	byte ptr [rdi], al
-;; a1ad:	 800100               	add	byte ptr [rcx], 0
-;; a1b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a1b9:	 800100               	add	byte ptr [rcx], 0
-;; a1bc:	 aa                   	stosb	byte ptr [rdi], al
-;; a1bd:	 800100               	add	byte ptr [rcx], 0
-;; a1c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a1c9:	 800100               	add	byte ptr [rcx], 0
-;; a1cc:	 aa                   	stosb	byte ptr [rdi], al
-;; a1cd:	 800100               	add	byte ptr [rcx], 0
-;; a1d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a1d9:	 800100               	add	byte ptr [rcx], 0
-;; a1dc:	 aa                   	stosb	byte ptr [rdi], al
-;; a1dd:	 800100               	add	byte ptr [rcx], 0
-;; a1e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a1e9:	 800100               	add	byte ptr [rcx], 0
-;; a1ec:	 aa                   	stosb	byte ptr [rdi], al
-;; a1ed:	 800100               	add	byte ptr [rcx], 0
-;; a1f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a1f9:	 800100               	add	byte ptr [rcx], 0
-;; a1fc:	 aa                   	stosb	byte ptr [rdi], al
-;; a1fd:	 800100               	add	byte ptr [rcx], 0
-;; a200:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a209:	 800100               	add	byte ptr [rcx], 0
-;; a20c:	 aa                   	stosb	byte ptr [rdi], al
-;; a20d:	 800100               	add	byte ptr [rcx], 0
-;; a210:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a219:	 800100               	add	byte ptr [rcx], 0
-;; a21c:	 aa                   	stosb	byte ptr [rdi], al
-;; a21d:	 800100               	add	byte ptr [rcx], 0
-;; a220:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a229:	 800100               	add	byte ptr [rcx], 0
-;; a22c:	 aa                   	stosb	byte ptr [rdi], al
-;; a22d:	 800100               	add	byte ptr [rcx], 0
-;; a230:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a239:	 800100               	add	byte ptr [rcx], 0
-;; a23c:	 aa                   	stosb	byte ptr [rdi], al
-;; a23d:	 800100               	add	byte ptr [rcx], 0
-;; a240:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a249:	 800100               	add	byte ptr [rcx], 0
-;; a24c:	 aa                   	stosb	byte ptr [rdi], al
-;; a24d:	 800100               	add	byte ptr [rcx], 0
-;; a250:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a259:	 800100               	add	byte ptr [rcx], 0
-;; a25c:	 aa                   	stosb	byte ptr [rdi], al
-;; a25d:	 800100               	add	byte ptr [rcx], 0
-;; a260:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a269:	 800100               	add	byte ptr [rcx], 0
-;; a26c:	 aa                   	stosb	byte ptr [rdi], al
-;; a26d:	 800100               	add	byte ptr [rcx], 0
-;; a270:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a279:	 800100               	add	byte ptr [rcx], 0
-;; a27c:	 aa                   	stosb	byte ptr [rdi], al
-;; a27d:	 800100               	add	byte ptr [rcx], 0
-;; a280:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a289:	 800100               	add	byte ptr [rcx], 0
-;; a28c:	 aa                   	stosb	byte ptr [rdi], al
-;; a28d:	 800100               	add	byte ptr [rcx], 0
-;; a290:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a299:	 800100               	add	byte ptr [rcx], 0
-;; a29c:	 aa                   	stosb	byte ptr [rdi], al
-;; a29d:	 800100               	add	byte ptr [rcx], 0
-;; a2a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a2a9:	 800100               	add	byte ptr [rcx], 0
-;; a2ac:	 aa                   	stosb	byte ptr [rdi], al
-;; a2ad:	 800100               	add	byte ptr [rcx], 0
-;; a2b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a2b9:	 800100               	add	byte ptr [rcx], 0
-;; a2bc:	 aa                   	stosb	byte ptr [rdi], al
-;; a2bd:	 800100               	add	byte ptr [rcx], 0
-;; a2c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a2c9:	 800100               	add	byte ptr [rcx], 0
-;; a2cc:	 aa                   	stosb	byte ptr [rdi], al
-;; a2cd:	 800100               	add	byte ptr [rcx], 0
-;; a2d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a2d9:	 800100               	add	byte ptr [rcx], 0
-;; a2dc:	 aa                   	stosb	byte ptr [rdi], al
-;; a2dd:	 800100               	add	byte ptr [rcx], 0
-;; a2e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a2e9:	 800100               	add	byte ptr [rcx], 0
-;; a2ec:	 aa                   	stosb	byte ptr [rdi], al
-;; a2ed:	 800100               	add	byte ptr [rcx], 0
-;; a2f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a2f9:	 800100               	add	byte ptr [rcx], 0
-;; a2fc:	 aa                   	stosb	byte ptr [rdi], al
-;; a2fd:	 800100               	add	byte ptr [rcx], 0
-;; a300:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a309:	 800100               	add	byte ptr [rcx], 0
-;; a30c:	 aa                   	stosb	byte ptr [rdi], al
-;; a30d:	 800100               	add	byte ptr [rcx], 0
-;; a310:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a319:	 800100               	add	byte ptr [rcx], 0
-;; a31c:	 aa                   	stosb	byte ptr [rdi], al
-;; a31d:	 800100               	add	byte ptr [rcx], 0
-;; a320:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a329:	 800100               	add	byte ptr [rcx], 0
-;; a32c:	 aa                   	stosb	byte ptr [rdi], al
-;; a32d:	 800100               	add	byte ptr [rcx], 0
-;; a330:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a339:	 800100               	add	byte ptr [rcx], 0
-;; a33c:	 aa                   	stosb	byte ptr [rdi], al
-;; a33d:	 800100               	add	byte ptr [rcx], 0
-;; a340:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a349:	 800100               	add	byte ptr [rcx], 0
-;; a34c:	 aa                   	stosb	byte ptr [rdi], al
-;; a34d:	 800100               	add	byte ptr [rcx], 0
-;; a350:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a359:	 800100               	add	byte ptr [rcx], 0
-;; a35c:	 aa                   	stosb	byte ptr [rdi], al
-;; a35d:	 800100               	add	byte ptr [rcx], 0
-;; a360:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a369:	 800100               	add	byte ptr [rcx], 0
-;; a36c:	 aa                   	stosb	byte ptr [rdi], al
-;; a36d:	 800100               	add	byte ptr [rcx], 0
-;; a370:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a379:	 800100               	add	byte ptr [rcx], 0
-;; a37c:	 aa                   	stosb	byte ptr [rdi], al
-;; a37d:	 800100               	add	byte ptr [rcx], 0
-;; a380:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a389:	 800100               	add	byte ptr [rcx], 0
-;; a38c:	 aa                   	stosb	byte ptr [rdi], al
-;; a38d:	 800100               	add	byte ptr [rcx], 0
-;; a390:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a399:	 800100               	add	byte ptr [rcx], 0
-;; a39c:	 aa                   	stosb	byte ptr [rdi], al
-;; a39d:	 800100               	add	byte ptr [rcx], 0
-;; a3a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a3a9:	 800100               	add	byte ptr [rcx], 0
-;; a3ac:	 aa                   	stosb	byte ptr [rdi], al
-;; a3ad:	 800100               	add	byte ptr [rcx], 0
-;; a3b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a3b9:	 800100               	add	byte ptr [rcx], 0
-;; a3bc:	 aa                   	stosb	byte ptr [rdi], al
-;; a3bd:	 800100               	add	byte ptr [rcx], 0
-;; a3c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a3c9:	 800100               	add	byte ptr [rcx], 0
-;; a3cc:	 aa                   	stosb	byte ptr [rdi], al
-;; a3cd:	 800100               	add	byte ptr [rcx], 0
-;; a3d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a3d9:	 800100               	add	byte ptr [rcx], 0
-;; a3dc:	 aa                   	stosb	byte ptr [rdi], al
-;; a3dd:	 800100               	add	byte ptr [rcx], 0
-;; a3e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a3e9:	 800100               	add	byte ptr [rcx], 0
-;; a3ec:	 aa                   	stosb	byte ptr [rdi], al
-;; a3ed:	 800100               	add	byte ptr [rcx], 0
-;; a3f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a3f9:	 800100               	add	byte ptr [rcx], 0
-;; a3fc:	 aa                   	stosb	byte ptr [rdi], al
-;; a3fd:	 800100               	add	byte ptr [rcx], 0
-;; a400:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a409:	 800100               	add	byte ptr [rcx], 0
-;; a40c:	 aa                   	stosb	byte ptr [rdi], al
-;; a40d:	 800100               	add	byte ptr [rcx], 0
-;; a410:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a419:	 800100               	add	byte ptr [rcx], 0
-;; a41c:	 aa                   	stosb	byte ptr [rdi], al
-;; a41d:	 800100               	add	byte ptr [rcx], 0
-;; a420:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a429:	 800100               	add	byte ptr [rcx], 0
-;; a42c:	 aa                   	stosb	byte ptr [rdi], al
-;; a42d:	 800100               	add	byte ptr [rcx], 0
-;; a430:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a439:	 800100               	add	byte ptr [rcx], 0
-;; a43c:	 aa                   	stosb	byte ptr [rdi], al
-;; a43d:	 800100               	add	byte ptr [rcx], 0
-;; a440:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a449:	 800100               	add	byte ptr [rcx], 0
-;; a44c:	 aa                   	stosb	byte ptr [rdi], al
-;; a44d:	 800100               	add	byte ptr [rcx], 0
-;; a450:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a459:	 800100               	add	byte ptr [rcx], 0
-;; a45c:	 aa                   	stosb	byte ptr [rdi], al
-;; a45d:	 800100               	add	byte ptr [rcx], 0
-;; a460:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a469:	 800100               	add	byte ptr [rcx], 0
-;; a46c:	 aa                   	stosb	byte ptr [rdi], al
-;; a46d:	 800100               	add	byte ptr [rcx], 0
-;; a470:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a479:	 800100               	add	byte ptr [rcx], 0
-;; a47c:	 aa                   	stosb	byte ptr [rdi], al
-;; a47d:	 800100               	add	byte ptr [rcx], 0
-;; a480:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a489:	 800100               	add	byte ptr [rcx], 0
-;; a48c:	 aa                   	stosb	byte ptr [rdi], al
-;; a48d:	 800100               	add	byte ptr [rcx], 0
-;; a490:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a499:	 800100               	add	byte ptr [rcx], 0
-;; a49c:	 aa                   	stosb	byte ptr [rdi], al
-;; a49d:	 800100               	add	byte ptr [rcx], 0
-;; a4a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a4a9:	 800100               	add	byte ptr [rcx], 0
-;; a4ac:	 aa                   	stosb	byte ptr [rdi], al
-;; a4ad:	 800100               	add	byte ptr [rcx], 0
-;; a4b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a4b9:	 800100               	add	byte ptr [rcx], 0
-;; a4bc:	 aa                   	stosb	byte ptr [rdi], al
-;; a4bd:	 800100               	add	byte ptr [rcx], 0
-;; a4c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a4c9:	 800100               	add	byte ptr [rcx], 0
-;; a4cc:	 aa                   	stosb	byte ptr [rdi], al
-;; a4cd:	 800100               	add	byte ptr [rcx], 0
-;; a4d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a4d9:	 800100               	add	byte ptr [rcx], 0
-;; a4dc:	 aa                   	stosb	byte ptr [rdi], al
-;; a4dd:	 800100               	add	byte ptr [rcx], 0
-;; a4e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a4e9:	 800100               	add	byte ptr [rcx], 0
-;; a4ec:	 aa                   	stosb	byte ptr [rdi], al
-;; a4ed:	 800100               	add	byte ptr [rcx], 0
-;; a4f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a4f9:	 800100               	add	byte ptr [rcx], 0
-;; a4fc:	 aa                   	stosb	byte ptr [rdi], al
-;; a4fd:	 800100               	add	byte ptr [rcx], 0
-;; a500:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a509:	 800100               	add	byte ptr [rcx], 0
-;; a50c:	 aa                   	stosb	byte ptr [rdi], al
-;; a50d:	 800100               	add	byte ptr [rcx], 0
-;; a510:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a519:	 800100               	add	byte ptr [rcx], 0
-;; a51c:	 aa                   	stosb	byte ptr [rdi], al
-;; a51d:	 800100               	add	byte ptr [rcx], 0
-;; a520:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a529:	 800100               	add	byte ptr [rcx], 0
-;; a52c:	 aa                   	stosb	byte ptr [rdi], al
-;; a52d:	 800100               	add	byte ptr [rcx], 0
-;; a530:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a539:	 800100               	add	byte ptr [rcx], 0
-;; a53c:	 aa                   	stosb	byte ptr [rdi], al
-;; a53d:	 800100               	add	byte ptr [rcx], 0
-;; a540:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a549:	 800100               	add	byte ptr [rcx], 0
-;; a54c:	 aa                   	stosb	byte ptr [rdi], al
-;; a54d:	 800100               	add	byte ptr [rcx], 0
-;; a550:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a559:	 800100               	add	byte ptr [rcx], 0
-;; a55c:	 aa                   	stosb	byte ptr [rdi], al
-;; a55d:	 800100               	add	byte ptr [rcx], 0
-;; a560:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a569:	 800100               	add	byte ptr [rcx], 0
-;; a56c:	 aa                   	stosb	byte ptr [rdi], al
-;; a56d:	 800100               	add	byte ptr [rcx], 0
-;; a570:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a579:	 800100               	add	byte ptr [rcx], 0
-;; a57c:	 aa                   	stosb	byte ptr [rdi], al
-;; a57d:	 800100               	add	byte ptr [rcx], 0
-;; a580:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a589:	 800100               	add	byte ptr [rcx], 0
-;; a58c:	 aa                   	stosb	byte ptr [rdi], al
-;; a58d:	 800100               	add	byte ptr [rcx], 0
-;; a590:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a599:	 800100               	add	byte ptr [rcx], 0
-;; a59c:	 aa                   	stosb	byte ptr [rdi], al
-;; a59d:	 800100               	add	byte ptr [rcx], 0
-;; a5a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a5a9:	 800100               	add	byte ptr [rcx], 0
-;; a5ac:	 aa                   	stosb	byte ptr [rdi], al
-;; a5ad:	 800100               	add	byte ptr [rcx], 0
-;; a5b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a5b9:	 800100               	add	byte ptr [rcx], 0
-;; a5bc:	 aa                   	stosb	byte ptr [rdi], al
-;; a5bd:	 800100               	add	byte ptr [rcx], 0
-;; a5c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a5c9:	 800100               	add	byte ptr [rcx], 0
-;; a5cc:	 aa                   	stosb	byte ptr [rdi], al
-;; a5cd:	 800100               	add	byte ptr [rcx], 0
-;; a5d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a5d9:	 800100               	add	byte ptr [rcx], 0
-;; a5dc:	 aa                   	stosb	byte ptr [rdi], al
-;; a5dd:	 800100               	add	byte ptr [rcx], 0
-;; a5e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a5e9:	 800100               	add	byte ptr [rcx], 0
-;; a5ec:	 aa                   	stosb	byte ptr [rdi], al
-;; a5ed:	 800100               	add	byte ptr [rcx], 0
-;; a5f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a5f9:	 800100               	add	byte ptr [rcx], 0
-;; a5fc:	 aa                   	stosb	byte ptr [rdi], al
-;; a5fd:	 800100               	add	byte ptr [rcx], 0
-;; a600:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a609:	 800100               	add	byte ptr [rcx], 0
-;; a60c:	 aa                   	stosb	byte ptr [rdi], al
-;; a60d:	 800100               	add	byte ptr [rcx], 0
-;; a610:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a619:	 800100               	add	byte ptr [rcx], 0
-;; a61c:	 aa                   	stosb	byte ptr [rdi], al
-;; a61d:	 800100               	add	byte ptr [rcx], 0
-;; a620:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a629:	 800100               	add	byte ptr [rcx], 0
-;; a62c:	 aa                   	stosb	byte ptr [rdi], al
-;; a62d:	 800100               	add	byte ptr [rcx], 0
-;; a630:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a639:	 800100               	add	byte ptr [rcx], 0
-;; a63c:	 aa                   	stosb	byte ptr [rdi], al
-;; a63d:	 800100               	add	byte ptr [rcx], 0
-;; a640:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a649:	 800100               	add	byte ptr [rcx], 0
-;; a64c:	 aa                   	stosb	byte ptr [rdi], al
-;; a64d:	 800100               	add	byte ptr [rcx], 0
-;; a650:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a659:	 800100               	add	byte ptr [rcx], 0
-;; a65c:	 aa                   	stosb	byte ptr [rdi], al
-;; a65d:	 800100               	add	byte ptr [rcx], 0
-;; a660:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a669:	 800100               	add	byte ptr [rcx], 0
-;; a66c:	 aa                   	stosb	byte ptr [rdi], al
-;; a66d:	 800100               	add	byte ptr [rcx], 0
-;; a670:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a679:	 800100               	add	byte ptr [rcx], 0
-;; a67c:	 aa                   	stosb	byte ptr [rdi], al
-;; a67d:	 800100               	add	byte ptr [rcx], 0
-;; a680:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a689:	 800100               	add	byte ptr [rcx], 0
-;; a68c:	 aa                   	stosb	byte ptr [rdi], al
-;; a68d:	 800100               	add	byte ptr [rcx], 0
-;; a690:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a699:	 800100               	add	byte ptr [rcx], 0
-;; a69c:	 aa                   	stosb	byte ptr [rdi], al
-;; a69d:	 800100               	add	byte ptr [rcx], 0
-;; a6a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a6a9:	 800100               	add	byte ptr [rcx], 0
-;; a6ac:	 aa                   	stosb	byte ptr [rdi], al
-;; a6ad:	 800100               	add	byte ptr [rcx], 0
-;; a6b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a6b9:	 800100               	add	byte ptr [rcx], 0
-;; a6bc:	 aa                   	stosb	byte ptr [rdi], al
-;; a6bd:	 800100               	add	byte ptr [rcx], 0
-;; a6c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a6c9:	 800100               	add	byte ptr [rcx], 0
-;; a6cc:	 aa                   	stosb	byte ptr [rdi], al
-;; a6cd:	 800100               	add	byte ptr [rcx], 0
-;; a6d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a6d9:	 800100               	add	byte ptr [rcx], 0
-;; a6dc:	 aa                   	stosb	byte ptr [rdi], al
-;; a6dd:	 800100               	add	byte ptr [rcx], 0
-;; a6e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a6e9:	 800100               	add	byte ptr [rcx], 0
-;; a6ec:	 aa                   	stosb	byte ptr [rdi], al
-;; a6ed:	 800100               	add	byte ptr [rcx], 0
-;; a6f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a6f9:	 800100               	add	byte ptr [rcx], 0
-;; a6fc:	 aa                   	stosb	byte ptr [rdi], al
-;; a6fd:	 800100               	add	byte ptr [rcx], 0
-;; a700:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a709:	 800100               	add	byte ptr [rcx], 0
-;; a70c:	 aa                   	stosb	byte ptr [rdi], al
-;; a70d:	 800100               	add	byte ptr [rcx], 0
-;; a710:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a719:	 800100               	add	byte ptr [rcx], 0
-;; a71c:	 aa                   	stosb	byte ptr [rdi], al
-;; a71d:	 800100               	add	byte ptr [rcx], 0
-;; a720:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a729:	 800100               	add	byte ptr [rcx], 0
-;; a72c:	 aa                   	stosb	byte ptr [rdi], al
-;; a72d:	 800100               	add	byte ptr [rcx], 0
-;; a730:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a739:	 800100               	add	byte ptr [rcx], 0
-;; a73c:	 aa                   	stosb	byte ptr [rdi], al
-;; a73d:	 800100               	add	byte ptr [rcx], 0
-;; a740:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a749:	 800100               	add	byte ptr [rcx], 0
-;; a74c:	 aa                   	stosb	byte ptr [rdi], al
-;; a74d:	 800100               	add	byte ptr [rcx], 0
-;; a750:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a759:	 800100               	add	byte ptr [rcx], 0
-;; a75c:	 aa                   	stosb	byte ptr [rdi], al
-;; a75d:	 800100               	add	byte ptr [rcx], 0
-;; a760:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a769:	 800100               	add	byte ptr [rcx], 0
-;; a76c:	 aa                   	stosb	byte ptr [rdi], al
-;; a76d:	 800100               	add	byte ptr [rcx], 0
-;; a770:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a779:	 800100               	add	byte ptr [rcx], 0
-;; a77c:	 aa                   	stosb	byte ptr [rdi], al
-;; a77d:	 800100               	add	byte ptr [rcx], 0
-;; a780:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a789:	 800100               	add	byte ptr [rcx], 0
-;; a78c:	 aa                   	stosb	byte ptr [rdi], al
-;; a78d:	 800100               	add	byte ptr [rcx], 0
-;; a790:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a799:	 800100               	add	byte ptr [rcx], 0
-;; a79c:	 aa                   	stosb	byte ptr [rdi], al
-;; a79d:	 800100               	add	byte ptr [rcx], 0
-;; a7a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a7a9:	 800100               	add	byte ptr [rcx], 0
-;; a7ac:	 aa                   	stosb	byte ptr [rdi], al
-;; a7ad:	 800100               	add	byte ptr [rcx], 0
-;; a7b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a7b9:	 800100               	add	byte ptr [rcx], 0
-;; a7bc:	 aa                   	stosb	byte ptr [rdi], al
-;; a7bd:	 800100               	add	byte ptr [rcx], 0
-;; a7c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a7c9:	 800100               	add	byte ptr [rcx], 0
-;; a7cc:	 aa                   	stosb	byte ptr [rdi], al
-;; a7cd:	 800100               	add	byte ptr [rcx], 0
-;; a7d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a7d9:	 800100               	add	byte ptr [rcx], 0
-;; a7dc:	 aa                   	stosb	byte ptr [rdi], al
-;; a7dd:	 800100               	add	byte ptr [rcx], 0
-;; a7e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a7e9:	 800100               	add	byte ptr [rcx], 0
-;; a7ec:	 aa                   	stosb	byte ptr [rdi], al
-;; a7ed:	 800100               	add	byte ptr [rcx], 0
-;; a7f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a7f9:	 800100               	add	byte ptr [rcx], 0
-;; a7fc:	 aa                   	stosb	byte ptr [rdi], al
-;; a7fd:	 800100               	add	byte ptr [rcx], 0
-;; a800:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a809:	 800100               	add	byte ptr [rcx], 0
-;; a80c:	 aa                   	stosb	byte ptr [rdi], al
-;; a80d:	 800100               	add	byte ptr [rcx], 0
-;; a810:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a819:	 800100               	add	byte ptr [rcx], 0
-;; a81c:	 aa                   	stosb	byte ptr [rdi], al
-;; a81d:	 800100               	add	byte ptr [rcx], 0
-;; a820:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a829:	 800100               	add	byte ptr [rcx], 0
-;; a82c:	 aa                   	stosb	byte ptr [rdi], al
-;; a82d:	 800100               	add	byte ptr [rcx], 0
-;; a830:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a839:	 800100               	add	byte ptr [rcx], 0
-;; a83c:	 aa                   	stosb	byte ptr [rdi], al
-;; a83d:	 800100               	add	byte ptr [rcx], 0
-;; a840:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a849:	 800100               	add	byte ptr [rcx], 0
-;; a84c:	 aa                   	stosb	byte ptr [rdi], al
-;; a84d:	 800100               	add	byte ptr [rcx], 0
-;; a850:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a859:	 800100               	add	byte ptr [rcx], 0
-;; a85c:	 aa                   	stosb	byte ptr [rdi], al
-;; a85d:	 800100               	add	byte ptr [rcx], 0
-;; a860:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a869:	 800100               	add	byte ptr [rcx], 0
-;; a86c:	 aa                   	stosb	byte ptr [rdi], al
-;; a86d:	 800100               	add	byte ptr [rcx], 0
-;; a870:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a879:	 800100               	add	byte ptr [rcx], 0
-;; a87c:	 aa                   	stosb	byte ptr [rdi], al
-;; a87d:	 800100               	add	byte ptr [rcx], 0
-;; a880:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a889:	 800100               	add	byte ptr [rcx], 0
-;; a88c:	 aa                   	stosb	byte ptr [rdi], al
-;; a88d:	 800100               	add	byte ptr [rcx], 0
-;; a890:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a899:	 800100               	add	byte ptr [rcx], 0
-;; a89c:	 aa                   	stosb	byte ptr [rdi], al
-;; a89d:	 800100               	add	byte ptr [rcx], 0
-;; a8a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a8a9:	 800100               	add	byte ptr [rcx], 0
-;; a8ac:	 aa                   	stosb	byte ptr [rdi], al
-;; a8ad:	 800100               	add	byte ptr [rcx], 0
-;; a8b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a8b9:	 800100               	add	byte ptr [rcx], 0
-;; a8bc:	 aa                   	stosb	byte ptr [rdi], al
-;; a8bd:	 800100               	add	byte ptr [rcx], 0
-;; a8c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a8c9:	 800100               	add	byte ptr [rcx], 0
-;; a8cc:	 aa                   	stosb	byte ptr [rdi], al
-;; a8cd:	 800100               	add	byte ptr [rcx], 0
-;; a8d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a8d9:	 800100               	add	byte ptr [rcx], 0
-;; a8dc:	 aa                   	stosb	byte ptr [rdi], al
-;; a8dd:	 800100               	add	byte ptr [rcx], 0
-;; a8e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a8e9:	 800100               	add	byte ptr [rcx], 0
-;; a8ec:	 aa                   	stosb	byte ptr [rdi], al
-;; a8ed:	 800100               	add	byte ptr [rcx], 0
-;; a8f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a8f9:	 800100               	add	byte ptr [rcx], 0
-;; a8fc:	 aa                   	stosb	byte ptr [rdi], al
-;; a8fd:	 800100               	add	byte ptr [rcx], 0
-;; a900:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a909:	 800100               	add	byte ptr [rcx], 0
-;; a90c:	 aa                   	stosb	byte ptr [rdi], al
-;; a90d:	 800100               	add	byte ptr [rcx], 0
-;; a910:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a919:	 800100               	add	byte ptr [rcx], 0
-;; a91c:	 aa                   	stosb	byte ptr [rdi], al
-;; a91d:	 800100               	add	byte ptr [rcx], 0
-;; a920:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a929:	 800100               	add	byte ptr [rcx], 0
-;; a92c:	 aa                   	stosb	byte ptr [rdi], al
-;; a92d:	 800100               	add	byte ptr [rcx], 0
-;; a930:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a939:	 800100               	add	byte ptr [rcx], 0
-;; a93c:	 aa                   	stosb	byte ptr [rdi], al
-;; a93d:	 800100               	add	byte ptr [rcx], 0
-;; a940:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a949:	 800100               	add	byte ptr [rcx], 0
-;; a94c:	 aa                   	stosb	byte ptr [rdi], al
-;; a94d:	 800100               	add	byte ptr [rcx], 0
-;; a950:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a959:	 800100               	add	byte ptr [rcx], 0
-;; a95c:	 aa                   	stosb	byte ptr [rdi], al
-;; a95d:	 800100               	add	byte ptr [rcx], 0
-;; a960:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a969:	 800100               	add	byte ptr [rcx], 0
-;; a96c:	 aa                   	stosb	byte ptr [rdi], al
-;; a96d:	 800100               	add	byte ptr [rcx], 0
-;; a970:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a979:	 800100               	add	byte ptr [rcx], 0
-;; a97c:	 aa                   	stosb	byte ptr [rdi], al
-;; a97d:	 800100               	add	byte ptr [rcx], 0
-;; a980:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a989:	 800100               	add	byte ptr [rcx], 0
-;; a98c:	 aa                   	stosb	byte ptr [rdi], al
-;; a98d:	 800100               	add	byte ptr [rcx], 0
-;; a990:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a999:	 800100               	add	byte ptr [rcx], 0
-;; a99c:	 aa                   	stosb	byte ptr [rdi], al
-;; a99d:	 800100               	add	byte ptr [rcx], 0
-;; a9a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a9a9:	 800100               	add	byte ptr [rcx], 0
-;; a9ac:	 aa                   	stosb	byte ptr [rdi], al
-;; a9ad:	 800100               	add	byte ptr [rcx], 0
-;; a9b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a9b9:	 800100               	add	byte ptr [rcx], 0
-;; a9bc:	 aa                   	stosb	byte ptr [rdi], al
-;; a9bd:	 800100               	add	byte ptr [rcx], 0
-;; a9c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a9c9:	 800100               	add	byte ptr [rcx], 0
-;; a9cc:	 aa                   	stosb	byte ptr [rdi], al
-;; a9cd:	 800100               	add	byte ptr [rcx], 0
-;; a9d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a9d9:	 800100               	add	byte ptr [rcx], 0
-;; a9dc:	 aa                   	stosb	byte ptr [rdi], al
-;; a9dd:	 800100               	add	byte ptr [rcx], 0
-;; a9e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a9e9:	 800100               	add	byte ptr [rcx], 0
-;; a9ec:	 aa                   	stosb	byte ptr [rdi], al
-;; a9ed:	 800100               	add	byte ptr [rcx], 0
-;; a9f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; a9f9:	 800100               	add	byte ptr [rcx], 0
-;; a9fc:	 aa                   	stosb	byte ptr [rdi], al
-;; a9fd:	 800100               	add	byte ptr [rcx], 0
-;; aa00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; aa09:	 800100               	add	byte ptr [rcx], 0
-;; aa0c:	 aa                   	stosb	byte ptr [rdi], al
-;; aa0d:	 800100               	add	byte ptr [rcx], 0
-;; aa10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; aa19:	 800100               	add	byte ptr [rcx], 0
-;; aa1c:	 aa                   	stosb	byte ptr [rdi], al
-;; aa1d:	 800100               	add	byte ptr [rcx], 0
-;; aa20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; aa29:	 800100               	add	byte ptr [rcx], 0
-;; aa2c:	 aa                   	stosb	byte ptr [rdi], al
-;; aa2d:	 800100               	add	byte ptr [rcx], 0
-;; aa30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; aa39:	 800100               	add	byte ptr [rcx], 0
-;; aa3c:	 aa                   	stosb	byte ptr [rdi], al
-;; aa3d:	 800100               	add	byte ptr [rcx], 0
-;; aa40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; aa49:	 800100               	add	byte ptr [rcx], 0
-;; aa4c:	 aa                   	stosb	byte ptr [rdi], al
-;; aa4d:	 800100               	add	byte ptr [rcx], 0
-;; aa50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; aa59:	 800100               	add	byte ptr [rcx], 0
-;; aa5c:	 aa                   	stosb	byte ptr [rdi], al
-;; aa5d:	 800100               	add	byte ptr [rcx], 0
-;; aa60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; aa69:	 800100               	add	byte ptr [rcx], 0
-;; aa6c:	 aa                   	stosb	byte ptr [rdi], al
-;; aa6d:	 800100               	add	byte ptr [rcx], 0
-;; aa70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; aa79:	 800100               	add	byte ptr [rcx], 0
-;; aa7c:	 aa                   	stosb	byte ptr [rdi], al
-;; aa7d:	 800100               	add	byte ptr [rcx], 0
-;; aa80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; aa89:	 800100               	add	byte ptr [rcx], 0
-;; aa8c:	 aa                   	stosb	byte ptr [rdi], al
-;; aa8d:	 800100               	add	byte ptr [rcx], 0
-;; aa90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; aa99:	 800100               	add	byte ptr [rcx], 0
-;; aa9c:	 aa                   	stosb	byte ptr [rdi], al
-;; aa9d:	 800100               	add	byte ptr [rcx], 0
-;; aaa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; aaa9:	 800100               	add	byte ptr [rcx], 0
-;; aaac:	 aa                   	stosb	byte ptr [rdi], al
-;; aaad:	 800100               	add	byte ptr [rcx], 0
-;; aab0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; aab9:	 800100               	add	byte ptr [rcx], 0
-;; aabc:	 aa                   	stosb	byte ptr [rdi], al
-;; aabd:	 800100               	add	byte ptr [rcx], 0
-;; aac0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; aac9:	 800100               	add	byte ptr [rcx], 0
-;; aacc:	 aa                   	stosb	byte ptr [rdi], al
-;; aacd:	 800100               	add	byte ptr [rcx], 0
-;; aad0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; aad9:	 800100               	add	byte ptr [rcx], 0
-;; aadc:	 aa                   	stosb	byte ptr [rdi], al
-;; aadd:	 800100               	add	byte ptr [rcx], 0
-;; aae0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; aae9:	 800100               	add	byte ptr [rcx], 0
-;; aaec:	 aa                   	stosb	byte ptr [rdi], al
-;; aaed:	 800100               	add	byte ptr [rcx], 0
-;; aaf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; aaf9:	 800100               	add	byte ptr [rcx], 0
-;; aafc:	 aa                   	stosb	byte ptr [rdi], al
-;; aafd:	 800100               	add	byte ptr [rcx], 0
-;; ab00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ab09:	 800100               	add	byte ptr [rcx], 0
-;; ab0c:	 aa                   	stosb	byte ptr [rdi], al
-;; ab0d:	 800100               	add	byte ptr [rcx], 0
-;; ab10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ab19:	 800100               	add	byte ptr [rcx], 0
-;; ab1c:	 aa                   	stosb	byte ptr [rdi], al
-;; ab1d:	 800100               	add	byte ptr [rcx], 0
-;; ab20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ab29:	 800100               	add	byte ptr [rcx], 0
-;; ab2c:	 aa                   	stosb	byte ptr [rdi], al
-;; ab2d:	 800100               	add	byte ptr [rcx], 0
-;; ab30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ab39:	 800100               	add	byte ptr [rcx], 0
-;; ab3c:	 aa                   	stosb	byte ptr [rdi], al
-;; ab3d:	 800100               	add	byte ptr [rcx], 0
-;; ab40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ab49:	 800100               	add	byte ptr [rcx], 0
-;; ab4c:	 aa                   	stosb	byte ptr [rdi], al
-;; ab4d:	 800100               	add	byte ptr [rcx], 0
-;; ab50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ab59:	 800100               	add	byte ptr [rcx], 0
-;; ab5c:	 aa                   	stosb	byte ptr [rdi], al
-;; ab5d:	 800100               	add	byte ptr [rcx], 0
-;; ab60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ab69:	 800100               	add	byte ptr [rcx], 0
-;; ab6c:	 aa                   	stosb	byte ptr [rdi], al
-;; ab6d:	 800100               	add	byte ptr [rcx], 0
-;; ab70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ab79:	 800100               	add	byte ptr [rcx], 0
-;; ab7c:	 aa                   	stosb	byte ptr [rdi], al
-;; ab7d:	 800100               	add	byte ptr [rcx], 0
-;; ab80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ab89:	 800100               	add	byte ptr [rcx], 0
-;; ab8c:	 aa                   	stosb	byte ptr [rdi], al
-;; ab8d:	 800100               	add	byte ptr [rcx], 0
-;; ab90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ab99:	 800100               	add	byte ptr [rcx], 0
-;; ab9c:	 aa                   	stosb	byte ptr [rdi], al
-;; ab9d:	 800100               	add	byte ptr [rcx], 0
-;; aba0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; aba9:	 800100               	add	byte ptr [rcx], 0
-;; abac:	 aa                   	stosb	byte ptr [rdi], al
-;; abad:	 800100               	add	byte ptr [rcx], 0
-;; abb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; abb9:	 800100               	add	byte ptr [rcx], 0
-;; abbc:	 aa                   	stosb	byte ptr [rdi], al
-;; abbd:	 800100               	add	byte ptr [rcx], 0
-;; abc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; abc9:	 800100               	add	byte ptr [rcx], 0
-;; abcc:	 aa                   	stosb	byte ptr [rdi], al
-;; abcd:	 800100               	add	byte ptr [rcx], 0
-;; abd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; abd9:	 800100               	add	byte ptr [rcx], 0
-;; abdc:	 aa                   	stosb	byte ptr [rdi], al
-;; abdd:	 800100               	add	byte ptr [rcx], 0
-;; abe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; abe9:	 800100               	add	byte ptr [rcx], 0
-;; abec:	 aa                   	stosb	byte ptr [rdi], al
-;; abed:	 800100               	add	byte ptr [rcx], 0
-;; abf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; abf9:	 800100               	add	byte ptr [rcx], 0
-;; abfc:	 aa                   	stosb	byte ptr [rdi], al
-;; abfd:	 800100               	add	byte ptr [rcx], 0
-;; ac00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ac09:	 800100               	add	byte ptr [rcx], 0
-;; ac0c:	 aa                   	stosb	byte ptr [rdi], al
-;; ac0d:	 800100               	add	byte ptr [rcx], 0
-;; ac10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ac19:	 800100               	add	byte ptr [rcx], 0
-;; ac1c:	 aa                   	stosb	byte ptr [rdi], al
-;; ac1d:	 800100               	add	byte ptr [rcx], 0
-;; ac20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ac29:	 800100               	add	byte ptr [rcx], 0
-;; ac2c:	 aa                   	stosb	byte ptr [rdi], al
-;; ac2d:	 800100               	add	byte ptr [rcx], 0
-;; ac30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ac39:	 800100               	add	byte ptr [rcx], 0
-;; ac3c:	 aa                   	stosb	byte ptr [rdi], al
-;; ac3d:	 800100               	add	byte ptr [rcx], 0
-;; ac40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ac49:	 800100               	add	byte ptr [rcx], 0
-;; ac4c:	 aa                   	stosb	byte ptr [rdi], al
-;; ac4d:	 800100               	add	byte ptr [rcx], 0
-;; ac50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ac59:	 800100               	add	byte ptr [rcx], 0
-;; ac5c:	 aa                   	stosb	byte ptr [rdi], al
-;; ac5d:	 800100               	add	byte ptr [rcx], 0
-;; ac60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ac69:	 800100               	add	byte ptr [rcx], 0
-;; ac6c:	 aa                   	stosb	byte ptr [rdi], al
-;; ac6d:	 800100               	add	byte ptr [rcx], 0
-;; ac70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ac79:	 800100               	add	byte ptr [rcx], 0
-;; ac7c:	 aa                   	stosb	byte ptr [rdi], al
-;; ac7d:	 800100               	add	byte ptr [rcx], 0
-;; ac80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ac89:	 800100               	add	byte ptr [rcx], 0
-;; ac8c:	 aa                   	stosb	byte ptr [rdi], al
-;; ac8d:	 800100               	add	byte ptr [rcx], 0
-;; ac90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ac99:	 800100               	add	byte ptr [rcx], 0
-;; ac9c:	 aa                   	stosb	byte ptr [rdi], al
-;; ac9d:	 800100               	add	byte ptr [rcx], 0
-;; aca0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; aca9:	 800100               	add	byte ptr [rcx], 0
-;; acac:	 aa                   	stosb	byte ptr [rdi], al
-;; acad:	 800100               	add	byte ptr [rcx], 0
-;; acb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; acb9:	 800100               	add	byte ptr [rcx], 0
-;; acbc:	 aa                   	stosb	byte ptr [rdi], al
-;; acbd:	 800100               	add	byte ptr [rcx], 0
-;; acc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; acc9:	 800100               	add	byte ptr [rcx], 0
-;; accc:	 aa                   	stosb	byte ptr [rdi], al
-;; accd:	 800100               	add	byte ptr [rcx], 0
-;; acd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; acd9:	 800100               	add	byte ptr [rcx], 0
-;; acdc:	 aa                   	stosb	byte ptr [rdi], al
-;; acdd:	 800100               	add	byte ptr [rcx], 0
-;; ace0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ace9:	 800100               	add	byte ptr [rcx], 0
-;; acec:	 aa                   	stosb	byte ptr [rdi], al
-;; aced:	 800100               	add	byte ptr [rcx], 0
-;; acf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; acf9:	 800100               	add	byte ptr [rcx], 0
-;; acfc:	 aa                   	stosb	byte ptr [rdi], al
-;; acfd:	 800100               	add	byte ptr [rcx], 0
-;; ad00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ad09:	 800100               	add	byte ptr [rcx], 0
-;; ad0c:	 aa                   	stosb	byte ptr [rdi], al
-;; ad0d:	 800100               	add	byte ptr [rcx], 0
-;; ad10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ad19:	 800100               	add	byte ptr [rcx], 0
-;; ad1c:	 aa                   	stosb	byte ptr [rdi], al
-;; ad1d:	 800100               	add	byte ptr [rcx], 0
-;; ad20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ad29:	 800100               	add	byte ptr [rcx], 0
-;; ad2c:	 aa                   	stosb	byte ptr [rdi], al
-;; ad2d:	 800100               	add	byte ptr [rcx], 0
-;; ad30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ad39:	 800100               	add	byte ptr [rcx], 0
-;; ad3c:	 aa                   	stosb	byte ptr [rdi], al
-;; ad3d:	 800100               	add	byte ptr [rcx], 0
-;; ad40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ad49:	 800100               	add	byte ptr [rcx], 0
-;; ad4c:	 aa                   	stosb	byte ptr [rdi], al
-;; ad4d:	 800100               	add	byte ptr [rcx], 0
-;; ad50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ad59:	 800100               	add	byte ptr [rcx], 0
-;; ad5c:	 aa                   	stosb	byte ptr [rdi], al
-;; ad5d:	 800100               	add	byte ptr [rcx], 0
-;; ad60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ad69:	 800100               	add	byte ptr [rcx], 0
-;; ad6c:	 aa                   	stosb	byte ptr [rdi], al
-;; ad6d:	 800100               	add	byte ptr [rcx], 0
-;; ad70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ad79:	 800100               	add	byte ptr [rcx], 0
-;; ad7c:	 aa                   	stosb	byte ptr [rdi], al
-;; ad7d:	 800100               	add	byte ptr [rcx], 0
-;; ad80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ad89:	 800100               	add	byte ptr [rcx], 0
-;; ad8c:	 aa                   	stosb	byte ptr [rdi], al
-;; ad8d:	 800100               	add	byte ptr [rcx], 0
-;; ad90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ad99:	 800100               	add	byte ptr [rcx], 0
-;; ad9c:	 aa                   	stosb	byte ptr [rdi], al
-;; ad9d:	 800100               	add	byte ptr [rcx], 0
-;; ada0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ada9:	 800100               	add	byte ptr [rcx], 0
-;; adac:	 aa                   	stosb	byte ptr [rdi], al
-;; adad:	 800100               	add	byte ptr [rcx], 0
-;; adb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; adb9:	 800100               	add	byte ptr [rcx], 0
-;; adbc:	 aa                   	stosb	byte ptr [rdi], al
-;; adbd:	 800100               	add	byte ptr [rcx], 0
-;; adc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; adc9:	 800100               	add	byte ptr [rcx], 0
-;; adcc:	 aa                   	stosb	byte ptr [rdi], al
-;; adcd:	 800100               	add	byte ptr [rcx], 0
-;; add0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; add9:	 800100               	add	byte ptr [rcx], 0
-;; addc:	 aa                   	stosb	byte ptr [rdi], al
-;; addd:	 800100               	add	byte ptr [rcx], 0
-;; ade0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ade9:	 800100               	add	byte ptr [rcx], 0
-;; adec:	 aa                   	stosb	byte ptr [rdi], al
-;; aded:	 800100               	add	byte ptr [rcx], 0
-;; adf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; adf9:	 800100               	add	byte ptr [rcx], 0
-;; adfc:	 aa                   	stosb	byte ptr [rdi], al
-;; adfd:	 800100               	add	byte ptr [rcx], 0
-;; ae00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ae09:	 800100               	add	byte ptr [rcx], 0
-;; ae0c:	 aa                   	stosb	byte ptr [rdi], al
-;; ae0d:	 800100               	add	byte ptr [rcx], 0
-;; ae10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ae19:	 800100               	add	byte ptr [rcx], 0
-;; ae1c:	 aa                   	stosb	byte ptr [rdi], al
-;; ae1d:	 800100               	add	byte ptr [rcx], 0
-;; ae20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ae29:	 800100               	add	byte ptr [rcx], 0
-;; ae2c:	 aa                   	stosb	byte ptr [rdi], al
-;; ae2d:	 800100               	add	byte ptr [rcx], 0
-;; ae30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ae39:	 800100               	add	byte ptr [rcx], 0
-;; ae3c:	 aa                   	stosb	byte ptr [rdi], al
-;; ae3d:	 800100               	add	byte ptr [rcx], 0
-;; ae40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ae49:	 800100               	add	byte ptr [rcx], 0
-;; ae4c:	 aa                   	stosb	byte ptr [rdi], al
-;; ae4d:	 800100               	add	byte ptr [rcx], 0
-;; ae50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ae59:	 800100               	add	byte ptr [rcx], 0
-;; ae5c:	 aa                   	stosb	byte ptr [rdi], al
-;; ae5d:	 800100               	add	byte ptr [rcx], 0
-;; ae60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ae69:	 800100               	add	byte ptr [rcx], 0
-;; ae6c:	 aa                   	stosb	byte ptr [rdi], al
-;; ae6d:	 800100               	add	byte ptr [rcx], 0
-;; ae70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ae79:	 800100               	add	byte ptr [rcx], 0
-;; ae7c:	 aa                   	stosb	byte ptr [rdi], al
-;; ae7d:	 800100               	add	byte ptr [rcx], 0
-;; ae80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ae89:	 800100               	add	byte ptr [rcx], 0
-;; ae8c:	 aa                   	stosb	byte ptr [rdi], al
-;; ae8d:	 800100               	add	byte ptr [rcx], 0
-;; ae90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ae99:	 800100               	add	byte ptr [rcx], 0
-;; ae9c:	 aa                   	stosb	byte ptr [rdi], al
-;; ae9d:	 800100               	add	byte ptr [rcx], 0
-;; aea0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; aea9:	 800100               	add	byte ptr [rcx], 0
-;; aeac:	 aa                   	stosb	byte ptr [rdi], al
-;; aead:	 800100               	add	byte ptr [rcx], 0
-;; aeb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; aeb9:	 800100               	add	byte ptr [rcx], 0
-;; aebc:	 aa                   	stosb	byte ptr [rdi], al
-;; aebd:	 800100               	add	byte ptr [rcx], 0
-;; aec0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; aec9:	 800100               	add	byte ptr [rcx], 0
-;; aecc:	 aa                   	stosb	byte ptr [rdi], al
-;; aecd:	 800100               	add	byte ptr [rcx], 0
-;; aed0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; aed9:	 800100               	add	byte ptr [rcx], 0
-;; aedc:	 aa                   	stosb	byte ptr [rdi], al
-;; aedd:	 800100               	add	byte ptr [rcx], 0
-;; aee0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; aee9:	 800100               	add	byte ptr [rcx], 0
-;; aeec:	 aa                   	stosb	byte ptr [rdi], al
-;; aeed:	 800100               	add	byte ptr [rcx], 0
-;; aef0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; aef9:	 800100               	add	byte ptr [rcx], 0
-;; aefc:	 aa                   	stosb	byte ptr [rdi], al
-;; aefd:	 800100               	add	byte ptr [rcx], 0
-;; af00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; af09:	 800100               	add	byte ptr [rcx], 0
-;; af0c:	 aa                   	stosb	byte ptr [rdi], al
-;; af0d:	 800100               	add	byte ptr [rcx], 0
-;; af10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; af19:	 800100               	add	byte ptr [rcx], 0
-;; af1c:	 aa                   	stosb	byte ptr [rdi], al
-;; af1d:	 800100               	add	byte ptr [rcx], 0
-;; af20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; af29:	 800100               	add	byte ptr [rcx], 0
-;; af2c:	 aa                   	stosb	byte ptr [rdi], al
-;; af2d:	 800100               	add	byte ptr [rcx], 0
-;; af30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; af39:	 800100               	add	byte ptr [rcx], 0
-;; af3c:	 aa                   	stosb	byte ptr [rdi], al
-;; af3d:	 800100               	add	byte ptr [rcx], 0
-;; af40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; af49:	 800100               	add	byte ptr [rcx], 0
-;; af4c:	 aa                   	stosb	byte ptr [rdi], al
-;; af4d:	 800100               	add	byte ptr [rcx], 0
-;; af50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; af59:	 800100               	add	byte ptr [rcx], 0
-;; af5c:	 aa                   	stosb	byte ptr [rdi], al
-;; af5d:	 800100               	add	byte ptr [rcx], 0
-;; af60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; af69:	 800100               	add	byte ptr [rcx], 0
-;; af6c:	 aa                   	stosb	byte ptr [rdi], al
-;; af6d:	 800100               	add	byte ptr [rcx], 0
-;; af70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; af79:	 800100               	add	byte ptr [rcx], 0
-;; af7c:	 aa                   	stosb	byte ptr [rdi], al
-;; af7d:	 800100               	add	byte ptr [rcx], 0
-;; af80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; af89:	 800100               	add	byte ptr [rcx], 0
-;; af8c:	 aa                   	stosb	byte ptr [rdi], al
-;; af8d:	 800100               	add	byte ptr [rcx], 0
-;; af90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; af99:	 800100               	add	byte ptr [rcx], 0
-;; af9c:	 aa                   	stosb	byte ptr [rdi], al
-;; af9d:	 800100               	add	byte ptr [rcx], 0
-;; afa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; afa9:	 800100               	add	byte ptr [rcx], 0
-;; afac:	 aa                   	stosb	byte ptr [rdi], al
-;; afad:	 800100               	add	byte ptr [rcx], 0
-;; afb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; afb9:	 800100               	add	byte ptr [rcx], 0
-;; afbc:	 aa                   	stosb	byte ptr [rdi], al
-;; afbd:	 800100               	add	byte ptr [rcx], 0
-;; afc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; afc9:	 800100               	add	byte ptr [rcx], 0
-;; afcc:	 aa                   	stosb	byte ptr [rdi], al
-;; afcd:	 800100               	add	byte ptr [rcx], 0
-;; afd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; afd9:	 800100               	add	byte ptr [rcx], 0
-;; afdc:	 aa                   	stosb	byte ptr [rdi], al
-;; afdd:	 800100               	add	byte ptr [rcx], 0
-;; afe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; afe9:	 800100               	add	byte ptr [rcx], 0
-;; afec:	 aa                   	stosb	byte ptr [rdi], al
-;; afed:	 800100               	add	byte ptr [rcx], 0
-;; aff0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; aff9:	 800100               	add	byte ptr [rcx], 0
-;; affc:	 aa                   	stosb	byte ptr [rdi], al
-;; affd:	 800100               	add	byte ptr [rcx], 0
-;; b000:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b009:	 800100               	add	byte ptr [rcx], 0
-;; b00c:	 aa                   	stosb	byte ptr [rdi], al
-;; b00d:	 800100               	add	byte ptr [rcx], 0
-;; b010:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b019:	 800100               	add	byte ptr [rcx], 0
-;; b01c:	 aa                   	stosb	byte ptr [rdi], al
-;; b01d:	 800100               	add	byte ptr [rcx], 0
-;; b020:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b029:	 800100               	add	byte ptr [rcx], 0
-;; b02c:	 aa                   	stosb	byte ptr [rdi], al
-;; b02d:	 800100               	add	byte ptr [rcx], 0
-;; b030:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b039:	 800100               	add	byte ptr [rcx], 0
-;; b03c:	 aa                   	stosb	byte ptr [rdi], al
-;; b03d:	 800100               	add	byte ptr [rcx], 0
-;; b040:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b049:	 800100               	add	byte ptr [rcx], 0
-;; b04c:	 aa                   	stosb	byte ptr [rdi], al
-;; b04d:	 800100               	add	byte ptr [rcx], 0
-;; b050:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b059:	 800100               	add	byte ptr [rcx], 0
-;; b05c:	 aa                   	stosb	byte ptr [rdi], al
-;; b05d:	 800100               	add	byte ptr [rcx], 0
-;; b060:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b069:	 800100               	add	byte ptr [rcx], 0
-;; b06c:	 aa                   	stosb	byte ptr [rdi], al
-;; b06d:	 800100               	add	byte ptr [rcx], 0
-;; b070:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b079:	 800100               	add	byte ptr [rcx], 0
-;; b07c:	 aa                   	stosb	byte ptr [rdi], al
-;; b07d:	 800100               	add	byte ptr [rcx], 0
-;; b080:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b089:	 800100               	add	byte ptr [rcx], 0
-;; b08c:	 aa                   	stosb	byte ptr [rdi], al
-;; b08d:	 800100               	add	byte ptr [rcx], 0
-;; b090:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b099:	 800100               	add	byte ptr [rcx], 0
-;; b09c:	 aa                   	stosb	byte ptr [rdi], al
-;; b09d:	 800100               	add	byte ptr [rcx], 0
-;; b0a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b0a9:	 800100               	add	byte ptr [rcx], 0
-;; b0ac:	 aa                   	stosb	byte ptr [rdi], al
-;; b0ad:	 800100               	add	byte ptr [rcx], 0
-;; b0b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b0b9:	 800100               	add	byte ptr [rcx], 0
-;; b0bc:	 aa                   	stosb	byte ptr [rdi], al
-;; b0bd:	 800100               	add	byte ptr [rcx], 0
-;; b0c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b0c9:	 800100               	add	byte ptr [rcx], 0
-;; b0cc:	 aa                   	stosb	byte ptr [rdi], al
-;; b0cd:	 800100               	add	byte ptr [rcx], 0
-;; b0d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b0d9:	 800100               	add	byte ptr [rcx], 0
-;; b0dc:	 aa                   	stosb	byte ptr [rdi], al
-;; b0dd:	 800100               	add	byte ptr [rcx], 0
-;; b0e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b0e9:	 800100               	add	byte ptr [rcx], 0
-;; b0ec:	 aa                   	stosb	byte ptr [rdi], al
-;; b0ed:	 800100               	add	byte ptr [rcx], 0
-;; b0f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b0f9:	 800100               	add	byte ptr [rcx], 0
-;; b0fc:	 aa                   	stosb	byte ptr [rdi], al
-;; b0fd:	 800100               	add	byte ptr [rcx], 0
-;; b100:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b109:	 800100               	add	byte ptr [rcx], 0
-;; b10c:	 aa                   	stosb	byte ptr [rdi], al
-;; b10d:	 800100               	add	byte ptr [rcx], 0
-;; b110:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b119:	 800100               	add	byte ptr [rcx], 0
-;; b11c:	 aa                   	stosb	byte ptr [rdi], al
-;; b11d:	 800100               	add	byte ptr [rcx], 0
-;; b120:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b129:	 800100               	add	byte ptr [rcx], 0
-;; b12c:	 aa                   	stosb	byte ptr [rdi], al
-;; b12d:	 800100               	add	byte ptr [rcx], 0
-;; b130:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b139:	 800100               	add	byte ptr [rcx], 0
-;; b13c:	 aa                   	stosb	byte ptr [rdi], al
-;; b13d:	 800100               	add	byte ptr [rcx], 0
-;; b140:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b149:	 800100               	add	byte ptr [rcx], 0
-;; b14c:	 aa                   	stosb	byte ptr [rdi], al
-;; b14d:	 800100               	add	byte ptr [rcx], 0
-;; b150:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b159:	 800100               	add	byte ptr [rcx], 0
-;; b15c:	 aa                   	stosb	byte ptr [rdi], al
-;; b15d:	 800100               	add	byte ptr [rcx], 0
-;; b160:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b169:	 800100               	add	byte ptr [rcx], 0
-;; b16c:	 aa                   	stosb	byte ptr [rdi], al
-;; b16d:	 800100               	add	byte ptr [rcx], 0
-;; b170:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b179:	 800100               	add	byte ptr [rcx], 0
-;; b17c:	 aa                   	stosb	byte ptr [rdi], al
-;; b17d:	 800100               	add	byte ptr [rcx], 0
-;; b180:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b189:	 800100               	add	byte ptr [rcx], 0
-;; b18c:	 aa                   	stosb	byte ptr [rdi], al
-;; b18d:	 800100               	add	byte ptr [rcx], 0
-;; b190:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b199:	 800100               	add	byte ptr [rcx], 0
-;; b19c:	 aa                   	stosb	byte ptr [rdi], al
-;; b19d:	 800100               	add	byte ptr [rcx], 0
-;; b1a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b1a9:	 800100               	add	byte ptr [rcx], 0
-;; b1ac:	 aa                   	stosb	byte ptr [rdi], al
-;; b1ad:	 800100               	add	byte ptr [rcx], 0
-;; b1b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b1b9:	 800100               	add	byte ptr [rcx], 0
-;; b1bc:	 aa                   	stosb	byte ptr [rdi], al
-;; b1bd:	 800100               	add	byte ptr [rcx], 0
-;; b1c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b1c9:	 800100               	add	byte ptr [rcx], 0
-;; b1cc:	 aa                   	stosb	byte ptr [rdi], al
-;; b1cd:	 800100               	add	byte ptr [rcx], 0
-;; b1d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b1d9:	 800100               	add	byte ptr [rcx], 0
-;; b1dc:	 aa                   	stosb	byte ptr [rdi], al
-;; b1dd:	 800100               	add	byte ptr [rcx], 0
-;; b1e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b1e9:	 800100               	add	byte ptr [rcx], 0
-;; b1ec:	 aa                   	stosb	byte ptr [rdi], al
-;; b1ed:	 800100               	add	byte ptr [rcx], 0
-;; b1f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b1f9:	 800100               	add	byte ptr [rcx], 0
-;; b1fc:	 aa                   	stosb	byte ptr [rdi], al
-;; b1fd:	 800100               	add	byte ptr [rcx], 0
-;; b200:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b209:	 800100               	add	byte ptr [rcx], 0
-;; b20c:	 aa                   	stosb	byte ptr [rdi], al
-;; b20d:	 800100               	add	byte ptr [rcx], 0
-;; b210:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b219:	 800100               	add	byte ptr [rcx], 0
-;; b21c:	 aa                   	stosb	byte ptr [rdi], al
-;; b21d:	 800100               	add	byte ptr [rcx], 0
-;; b220:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b229:	 800100               	add	byte ptr [rcx], 0
-;; b22c:	 aa                   	stosb	byte ptr [rdi], al
-;; b22d:	 800100               	add	byte ptr [rcx], 0
-;; b230:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b239:	 800100               	add	byte ptr [rcx], 0
-;; b23c:	 aa                   	stosb	byte ptr [rdi], al
-;; b23d:	 800100               	add	byte ptr [rcx], 0
-;; b240:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b249:	 800100               	add	byte ptr [rcx], 0
-;; b24c:	 aa                   	stosb	byte ptr [rdi], al
-;; b24d:	 800100               	add	byte ptr [rcx], 0
-;; b250:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b259:	 800100               	add	byte ptr [rcx], 0
-;; b25c:	 aa                   	stosb	byte ptr [rdi], al
-;; b25d:	 800100               	add	byte ptr [rcx], 0
-;; b260:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b269:	 800100               	add	byte ptr [rcx], 0
-;; b26c:	 aa                   	stosb	byte ptr [rdi], al
-;; b26d:	 800100               	add	byte ptr [rcx], 0
-;; b270:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b279:	 800100               	add	byte ptr [rcx], 0
-;; b27c:	 aa                   	stosb	byte ptr [rdi], al
-;; b27d:	 800100               	add	byte ptr [rcx], 0
-;; b280:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b289:	 800100               	add	byte ptr [rcx], 0
-;; b28c:	 aa                   	stosb	byte ptr [rdi], al
-;; b28d:	 800100               	add	byte ptr [rcx], 0
-;; b290:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b299:	 800100               	add	byte ptr [rcx], 0
-;; b29c:	 aa                   	stosb	byte ptr [rdi], al
-;; b29d:	 800100               	add	byte ptr [rcx], 0
-;; b2a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b2a9:	 800100               	add	byte ptr [rcx], 0
-;; b2ac:	 aa                   	stosb	byte ptr [rdi], al
-;; b2ad:	 800100               	add	byte ptr [rcx], 0
-;; b2b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b2b9:	 800100               	add	byte ptr [rcx], 0
-;; b2bc:	 aa                   	stosb	byte ptr [rdi], al
-;; b2bd:	 800100               	add	byte ptr [rcx], 0
-;; b2c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b2c9:	 800100               	add	byte ptr [rcx], 0
-;; b2cc:	 aa                   	stosb	byte ptr [rdi], al
-;; b2cd:	 800100               	add	byte ptr [rcx], 0
-;; b2d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b2d9:	 800100               	add	byte ptr [rcx], 0
-;; b2dc:	 aa                   	stosb	byte ptr [rdi], al
-;; b2dd:	 800100               	add	byte ptr [rcx], 0
-;; b2e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b2e9:	 800100               	add	byte ptr [rcx], 0
-;; b2ec:	 aa                   	stosb	byte ptr [rdi], al
-;; b2ed:	 800100               	add	byte ptr [rcx], 0
-;; b2f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b2f9:	 800100               	add	byte ptr [rcx], 0
-;; b2fc:	 aa                   	stosb	byte ptr [rdi], al
-;; b2fd:	 800100               	add	byte ptr [rcx], 0
-;; b300:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b309:	 800100               	add	byte ptr [rcx], 0
-;; b30c:	 aa                   	stosb	byte ptr [rdi], al
-;; b30d:	 800100               	add	byte ptr [rcx], 0
-;; b310:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b319:	 800100               	add	byte ptr [rcx], 0
-;; b31c:	 aa                   	stosb	byte ptr [rdi], al
-;; b31d:	 800100               	add	byte ptr [rcx], 0
-;; b320:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b329:	 800100               	add	byte ptr [rcx], 0
-;; b32c:	 aa                   	stosb	byte ptr [rdi], al
-;; b32d:	 800100               	add	byte ptr [rcx], 0
-;; b330:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b339:	 800100               	add	byte ptr [rcx], 0
-;; b33c:	 aa                   	stosb	byte ptr [rdi], al
-;; b33d:	 800100               	add	byte ptr [rcx], 0
-;; b340:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b349:	 800100               	add	byte ptr [rcx], 0
-;; b34c:	 aa                   	stosb	byte ptr [rdi], al
-;; b34d:	 800100               	add	byte ptr [rcx], 0
-;; b350:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b359:	 800100               	add	byte ptr [rcx], 0
-;; b35c:	 aa                   	stosb	byte ptr [rdi], al
-;; b35d:	 800100               	add	byte ptr [rcx], 0
-;; b360:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b369:	 800100               	add	byte ptr [rcx], 0
-;; b36c:	 aa                   	stosb	byte ptr [rdi], al
-;; b36d:	 800100               	add	byte ptr [rcx], 0
-;; b370:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b379:	 800100               	add	byte ptr [rcx], 0
-;; b37c:	 aa                   	stosb	byte ptr [rdi], al
-;; b37d:	 800100               	add	byte ptr [rcx], 0
-;; b380:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b389:	 800100               	add	byte ptr [rcx], 0
-;; b38c:	 aa                   	stosb	byte ptr [rdi], al
-;; b38d:	 800100               	add	byte ptr [rcx], 0
-;; b390:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b399:	 800100               	add	byte ptr [rcx], 0
-;; b39c:	 aa                   	stosb	byte ptr [rdi], al
-;; b39d:	 800100               	add	byte ptr [rcx], 0
-;; b3a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b3a9:	 800100               	add	byte ptr [rcx], 0
-;; b3ac:	 aa                   	stosb	byte ptr [rdi], al
-;; b3ad:	 800100               	add	byte ptr [rcx], 0
-;; b3b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b3b9:	 800100               	add	byte ptr [rcx], 0
-;; b3bc:	 aa                   	stosb	byte ptr [rdi], al
-;; b3bd:	 800100               	add	byte ptr [rcx], 0
-;; b3c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b3c9:	 800100               	add	byte ptr [rcx], 0
-;; b3cc:	 aa                   	stosb	byte ptr [rdi], al
-;; b3cd:	 800100               	add	byte ptr [rcx], 0
-;; b3d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b3d9:	 800100               	add	byte ptr [rcx], 0
-;; b3dc:	 aa                   	stosb	byte ptr [rdi], al
-;; b3dd:	 800100               	add	byte ptr [rcx], 0
-;; b3e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b3e9:	 800100               	add	byte ptr [rcx], 0
-;; b3ec:	 aa                   	stosb	byte ptr [rdi], al
-;; b3ed:	 800100               	add	byte ptr [rcx], 0
-;; b3f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b3f9:	 800100               	add	byte ptr [rcx], 0
-;; b3fc:	 aa                   	stosb	byte ptr [rdi], al
-;; b3fd:	 800100               	add	byte ptr [rcx], 0
-;; b400:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b409:	 800100               	add	byte ptr [rcx], 0
-;; b40c:	 aa                   	stosb	byte ptr [rdi], al
-;; b40d:	 800100               	add	byte ptr [rcx], 0
-;; b410:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b419:	 800100               	add	byte ptr [rcx], 0
-;; b41c:	 aa                   	stosb	byte ptr [rdi], al
-;; b41d:	 800100               	add	byte ptr [rcx], 0
-;; b420:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b429:	 800100               	add	byte ptr [rcx], 0
-;; b42c:	 aa                   	stosb	byte ptr [rdi], al
-;; b42d:	 800100               	add	byte ptr [rcx], 0
-;; b430:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b439:	 800100               	add	byte ptr [rcx], 0
-;; b43c:	 aa                   	stosb	byte ptr [rdi], al
-;; b43d:	 800100               	add	byte ptr [rcx], 0
-;; b440:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b449:	 800100               	add	byte ptr [rcx], 0
-;; b44c:	 aa                   	stosb	byte ptr [rdi], al
-;; b44d:	 800100               	add	byte ptr [rcx], 0
-;; b450:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b459:	 800100               	add	byte ptr [rcx], 0
-;; b45c:	 aa                   	stosb	byte ptr [rdi], al
-;; b45d:	 800100               	add	byte ptr [rcx], 0
-;; b460:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b469:	 800100               	add	byte ptr [rcx], 0
-;; b46c:	 aa                   	stosb	byte ptr [rdi], al
-;; b46d:	 800100               	add	byte ptr [rcx], 0
-;; b470:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b479:	 800100               	add	byte ptr [rcx], 0
-;; b47c:	 aa                   	stosb	byte ptr [rdi], al
-;; b47d:	 800100               	add	byte ptr [rcx], 0
-;; b480:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b489:	 800100               	add	byte ptr [rcx], 0
-;; b48c:	 aa                   	stosb	byte ptr [rdi], al
-;; b48d:	 800100               	add	byte ptr [rcx], 0
-;; b490:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b499:	 800100               	add	byte ptr [rcx], 0
-;; b49c:	 aa                   	stosb	byte ptr [rdi], al
-;; b49d:	 800100               	add	byte ptr [rcx], 0
-;; b4a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b4a9:	 800100               	add	byte ptr [rcx], 0
-;; b4ac:	 aa                   	stosb	byte ptr [rdi], al
-;; b4ad:	 800100               	add	byte ptr [rcx], 0
-;; b4b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b4b9:	 800100               	add	byte ptr [rcx], 0
-;; b4bc:	 aa                   	stosb	byte ptr [rdi], al
-;; b4bd:	 800100               	add	byte ptr [rcx], 0
-;; b4c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b4c9:	 800100               	add	byte ptr [rcx], 0
-;; b4cc:	 aa                   	stosb	byte ptr [rdi], al
-;; b4cd:	 800100               	add	byte ptr [rcx], 0
-;; b4d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b4d9:	 800100               	add	byte ptr [rcx], 0
-;; b4dc:	 aa                   	stosb	byte ptr [rdi], al
-;; b4dd:	 800100               	add	byte ptr [rcx], 0
-;; b4e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b4e9:	 800100               	add	byte ptr [rcx], 0
-;; b4ec:	 aa                   	stosb	byte ptr [rdi], al
-;; b4ed:	 800100               	add	byte ptr [rcx], 0
-;; b4f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b4f9:	 800100               	add	byte ptr [rcx], 0
-;; b4fc:	 aa                   	stosb	byte ptr [rdi], al
-;; b4fd:	 800100               	add	byte ptr [rcx], 0
-;; b500:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b509:	 800100               	add	byte ptr [rcx], 0
-;; b50c:	 aa                   	stosb	byte ptr [rdi], al
-;; b50d:	 800100               	add	byte ptr [rcx], 0
-;; b510:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b519:	 800100               	add	byte ptr [rcx], 0
-;; b51c:	 aa                   	stosb	byte ptr [rdi], al
-;; b51d:	 800100               	add	byte ptr [rcx], 0
-;; b520:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b529:	 800100               	add	byte ptr [rcx], 0
-;; b52c:	 aa                   	stosb	byte ptr [rdi], al
-;; b52d:	 800100               	add	byte ptr [rcx], 0
-;; b530:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b539:	 800100               	add	byte ptr [rcx], 0
-;; b53c:	 aa                   	stosb	byte ptr [rdi], al
-;; b53d:	 800100               	add	byte ptr [rcx], 0
-;; b540:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b549:	 800100               	add	byte ptr [rcx], 0
-;; b54c:	 aa                   	stosb	byte ptr [rdi], al
-;; b54d:	 800100               	add	byte ptr [rcx], 0
-;; b550:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b559:	 800100               	add	byte ptr [rcx], 0
-;; b55c:	 aa                   	stosb	byte ptr [rdi], al
-;; b55d:	 800100               	add	byte ptr [rcx], 0
-;; b560:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b569:	 800100               	add	byte ptr [rcx], 0
-;; b56c:	 aa                   	stosb	byte ptr [rdi], al
-;; b56d:	 800100               	add	byte ptr [rcx], 0
-;; b570:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b579:	 800100               	add	byte ptr [rcx], 0
-;; b57c:	 aa                   	stosb	byte ptr [rdi], al
-;; b57d:	 800100               	add	byte ptr [rcx], 0
-;; b580:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b589:	 800100               	add	byte ptr [rcx], 0
-;; b58c:	 aa                   	stosb	byte ptr [rdi], al
-;; b58d:	 800100               	add	byte ptr [rcx], 0
-;; b590:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b599:	 800100               	add	byte ptr [rcx], 0
-;; b59c:	 aa                   	stosb	byte ptr [rdi], al
-;; b59d:	 800100               	add	byte ptr [rcx], 0
-;; b5a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b5a9:	 800100               	add	byte ptr [rcx], 0
-;; b5ac:	 aa                   	stosb	byte ptr [rdi], al
-;; b5ad:	 800100               	add	byte ptr [rcx], 0
-;; b5b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b5b9:	 800100               	add	byte ptr [rcx], 0
-;; b5bc:	 aa                   	stosb	byte ptr [rdi], al
-;; b5bd:	 800100               	add	byte ptr [rcx], 0
-;; b5c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b5c9:	 800100               	add	byte ptr [rcx], 0
-;; b5cc:	 aa                   	stosb	byte ptr [rdi], al
-;; b5cd:	 800100               	add	byte ptr [rcx], 0
-;; b5d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b5d9:	 800100               	add	byte ptr [rcx], 0
-;; b5dc:	 aa                   	stosb	byte ptr [rdi], al
-;; b5dd:	 800100               	add	byte ptr [rcx], 0
-;; b5e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b5e9:	 800100               	add	byte ptr [rcx], 0
-;; b5ec:	 aa                   	stosb	byte ptr [rdi], al
-;; b5ed:	 800100               	add	byte ptr [rcx], 0
-;; b5f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b5f9:	 800100               	add	byte ptr [rcx], 0
-;; b5fc:	 aa                   	stosb	byte ptr [rdi], al
-;; b5fd:	 800100               	add	byte ptr [rcx], 0
-;; b600:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b609:	 800100               	add	byte ptr [rcx], 0
-;; b60c:	 aa                   	stosb	byte ptr [rdi], al
-;; b60d:	 800100               	add	byte ptr [rcx], 0
-;; b610:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b619:	 800100               	add	byte ptr [rcx], 0
-;; b61c:	 aa                   	stosb	byte ptr [rdi], al
-;; b61d:	 800100               	add	byte ptr [rcx], 0
-;; b620:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b629:	 800100               	add	byte ptr [rcx], 0
-;; b62c:	 aa                   	stosb	byte ptr [rdi], al
-;; b62d:	 800100               	add	byte ptr [rcx], 0
-;; b630:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b639:	 800100               	add	byte ptr [rcx], 0
-;; b63c:	 aa                   	stosb	byte ptr [rdi], al
-;; b63d:	 800100               	add	byte ptr [rcx], 0
-;; b640:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b649:	 800100               	add	byte ptr [rcx], 0
-;; b64c:	 aa                   	stosb	byte ptr [rdi], al
-;; b64d:	 800100               	add	byte ptr [rcx], 0
-;; b650:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b659:	 800100               	add	byte ptr [rcx], 0
-;; b65c:	 aa                   	stosb	byte ptr [rdi], al
-;; b65d:	 800100               	add	byte ptr [rcx], 0
-;; b660:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b669:	 800100               	add	byte ptr [rcx], 0
-;; b66c:	 aa                   	stosb	byte ptr [rdi], al
-;; b66d:	 800100               	add	byte ptr [rcx], 0
-;; b670:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b679:	 800100               	add	byte ptr [rcx], 0
-;; b67c:	 aa                   	stosb	byte ptr [rdi], al
-;; b67d:	 800100               	add	byte ptr [rcx], 0
-;; b680:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b689:	 800100               	add	byte ptr [rcx], 0
-;; b68c:	 aa                   	stosb	byte ptr [rdi], al
-;; b68d:	 800100               	add	byte ptr [rcx], 0
-;; b690:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b699:	 800100               	add	byte ptr [rcx], 0
-;; b69c:	 aa                   	stosb	byte ptr [rdi], al
-;; b69d:	 800100               	add	byte ptr [rcx], 0
-;; b6a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b6a9:	 800100               	add	byte ptr [rcx], 0
-;; b6ac:	 aa                   	stosb	byte ptr [rdi], al
-;; b6ad:	 800100               	add	byte ptr [rcx], 0
-;; b6b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b6b9:	 800100               	add	byte ptr [rcx], 0
-;; b6bc:	 aa                   	stosb	byte ptr [rdi], al
-;; b6bd:	 800100               	add	byte ptr [rcx], 0
-;; b6c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b6c9:	 800100               	add	byte ptr [rcx], 0
-;; b6cc:	 aa                   	stosb	byte ptr [rdi], al
-;; b6cd:	 800100               	add	byte ptr [rcx], 0
-;; b6d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b6d9:	 800100               	add	byte ptr [rcx], 0
-;; b6dc:	 aa                   	stosb	byte ptr [rdi], al
-;; b6dd:	 800100               	add	byte ptr [rcx], 0
-;; b6e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b6e9:	 800100               	add	byte ptr [rcx], 0
-;; b6ec:	 aa                   	stosb	byte ptr [rdi], al
-;; b6ed:	 800100               	add	byte ptr [rcx], 0
-;; b6f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b6f9:	 800100               	add	byte ptr [rcx], 0
-;; b6fc:	 aa                   	stosb	byte ptr [rdi], al
-;; b6fd:	 800100               	add	byte ptr [rcx], 0
-;; b700:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b709:	 800100               	add	byte ptr [rcx], 0
-;; b70c:	 aa                   	stosb	byte ptr [rdi], al
-;; b70d:	 800100               	add	byte ptr [rcx], 0
-;; b710:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b719:	 800100               	add	byte ptr [rcx], 0
-;; b71c:	 aa                   	stosb	byte ptr [rdi], al
-;; b71d:	 800100               	add	byte ptr [rcx], 0
-;; b720:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b729:	 800100               	add	byte ptr [rcx], 0
-;; b72c:	 aa                   	stosb	byte ptr [rdi], al
-;; b72d:	 800100               	add	byte ptr [rcx], 0
-;; b730:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b739:	 800100               	add	byte ptr [rcx], 0
-;; b73c:	 aa                   	stosb	byte ptr [rdi], al
-;; b73d:	 800100               	add	byte ptr [rcx], 0
-;; b740:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b749:	 800100               	add	byte ptr [rcx], 0
-;; b74c:	 aa                   	stosb	byte ptr [rdi], al
-;; b74d:	 800100               	add	byte ptr [rcx], 0
-;; b750:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b759:	 800100               	add	byte ptr [rcx], 0
-;; b75c:	 aa                   	stosb	byte ptr [rdi], al
-;; b75d:	 800100               	add	byte ptr [rcx], 0
-;; b760:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b769:	 800100               	add	byte ptr [rcx], 0
-;; b76c:	 aa                   	stosb	byte ptr [rdi], al
-;; b76d:	 800100               	add	byte ptr [rcx], 0
-;; b770:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b779:	 800100               	add	byte ptr [rcx], 0
-;; b77c:	 aa                   	stosb	byte ptr [rdi], al
-;; b77d:	 800100               	add	byte ptr [rcx], 0
-;; b780:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b789:	 800100               	add	byte ptr [rcx], 0
-;; b78c:	 aa                   	stosb	byte ptr [rdi], al
-;; b78d:	 800100               	add	byte ptr [rcx], 0
-;; b790:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b799:	 800100               	add	byte ptr [rcx], 0
-;; b79c:	 aa                   	stosb	byte ptr [rdi], al
-;; b79d:	 800100               	add	byte ptr [rcx], 0
-;; b7a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b7a9:	 800100               	add	byte ptr [rcx], 0
-;; b7ac:	 aa                   	stosb	byte ptr [rdi], al
-;; b7ad:	 800100               	add	byte ptr [rcx], 0
-;; b7b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b7b9:	 800100               	add	byte ptr [rcx], 0
-;; b7bc:	 aa                   	stosb	byte ptr [rdi], al
-;; b7bd:	 800100               	add	byte ptr [rcx], 0
-;; b7c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b7c9:	 800100               	add	byte ptr [rcx], 0
-;; b7cc:	 aa                   	stosb	byte ptr [rdi], al
-;; b7cd:	 800100               	add	byte ptr [rcx], 0
-;; b7d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b7d9:	 800100               	add	byte ptr [rcx], 0
-;; b7dc:	 aa                   	stosb	byte ptr [rdi], al
-;; b7dd:	 800100               	add	byte ptr [rcx], 0
-;; b7e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b7e9:	 800100               	add	byte ptr [rcx], 0
-;; b7ec:	 aa                   	stosb	byte ptr [rdi], al
-;; b7ed:	 800100               	add	byte ptr [rcx], 0
-;; b7f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b7f9:	 800100               	add	byte ptr [rcx], 0
-;; b7fc:	 aa                   	stosb	byte ptr [rdi], al
-;; b7fd:	 800100               	add	byte ptr [rcx], 0
-;; b800:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b809:	 800100               	add	byte ptr [rcx], 0
-;; b80c:	 aa                   	stosb	byte ptr [rdi], al
-;; b80d:	 800100               	add	byte ptr [rcx], 0
-;; b810:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b819:	 800100               	add	byte ptr [rcx], 0
-;; b81c:	 aa                   	stosb	byte ptr [rdi], al
-;; b81d:	 800100               	add	byte ptr [rcx], 0
-;; b820:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b829:	 800100               	add	byte ptr [rcx], 0
-;; b82c:	 aa                   	stosb	byte ptr [rdi], al
-;; b82d:	 800100               	add	byte ptr [rcx], 0
-;; b830:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b839:	 800100               	add	byte ptr [rcx], 0
-;; b83c:	 aa                   	stosb	byte ptr [rdi], al
-;; b83d:	 800100               	add	byte ptr [rcx], 0
-;; b840:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b849:	 800100               	add	byte ptr [rcx], 0
-;; b84c:	 aa                   	stosb	byte ptr [rdi], al
-;; b84d:	 800100               	add	byte ptr [rcx], 0
-;; b850:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b859:	 800100               	add	byte ptr [rcx], 0
-;; b85c:	 aa                   	stosb	byte ptr [rdi], al
-;; b85d:	 800100               	add	byte ptr [rcx], 0
-;; b860:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b869:	 800100               	add	byte ptr [rcx], 0
-;; b86c:	 aa                   	stosb	byte ptr [rdi], al
-;; b86d:	 800100               	add	byte ptr [rcx], 0
-;; b870:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b879:	 800100               	add	byte ptr [rcx], 0
-;; b87c:	 aa                   	stosb	byte ptr [rdi], al
-;; b87d:	 800100               	add	byte ptr [rcx], 0
-;; b880:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b889:	 800100               	add	byte ptr [rcx], 0
-;; b88c:	 aa                   	stosb	byte ptr [rdi], al
-;; b88d:	 800100               	add	byte ptr [rcx], 0
-;; b890:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b899:	 800100               	add	byte ptr [rcx], 0
-;; b89c:	 aa                   	stosb	byte ptr [rdi], al
-;; b89d:	 800100               	add	byte ptr [rcx], 0
-;; b8a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b8a9:	 800100               	add	byte ptr [rcx], 0
-;; b8ac:	 aa                   	stosb	byte ptr [rdi], al
-;; b8ad:	 800100               	add	byte ptr [rcx], 0
-;; b8b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b8b9:	 800100               	add	byte ptr [rcx], 0
-;; b8bc:	 aa                   	stosb	byte ptr [rdi], al
-;; b8bd:	 800100               	add	byte ptr [rcx], 0
-;; b8c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b8c9:	 800100               	add	byte ptr [rcx], 0
-;; b8cc:	 aa                   	stosb	byte ptr [rdi], al
-;; b8cd:	 800100               	add	byte ptr [rcx], 0
-;; b8d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b8d9:	 800100               	add	byte ptr [rcx], 0
-;; b8dc:	 aa                   	stosb	byte ptr [rdi], al
-;; b8dd:	 800100               	add	byte ptr [rcx], 0
-;; b8e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b8e9:	 800100               	add	byte ptr [rcx], 0
-;; b8ec:	 aa                   	stosb	byte ptr [rdi], al
-;; b8ed:	 800100               	add	byte ptr [rcx], 0
-;; b8f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b8f9:	 800100               	add	byte ptr [rcx], 0
-;; b8fc:	 aa                   	stosb	byte ptr [rdi], al
-;; b8fd:	 800100               	add	byte ptr [rcx], 0
-;; b900:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b909:	 800100               	add	byte ptr [rcx], 0
-;; b90c:	 aa                   	stosb	byte ptr [rdi], al
-;; b90d:	 800100               	add	byte ptr [rcx], 0
-;; b910:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b919:	 800100               	add	byte ptr [rcx], 0
-;; b91c:	 aa                   	stosb	byte ptr [rdi], al
-;; b91d:	 800100               	add	byte ptr [rcx], 0
-;; b920:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b929:	 800100               	add	byte ptr [rcx], 0
-;; b92c:	 aa                   	stosb	byte ptr [rdi], al
-;; b92d:	 800100               	add	byte ptr [rcx], 0
-;; b930:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b939:	 800100               	add	byte ptr [rcx], 0
-;; b93c:	 aa                   	stosb	byte ptr [rdi], al
-;; b93d:	 800100               	add	byte ptr [rcx], 0
-;; b940:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b949:	 800100               	add	byte ptr [rcx], 0
-;; b94c:	 aa                   	stosb	byte ptr [rdi], al
-;; b94d:	 800100               	add	byte ptr [rcx], 0
-;; b950:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b959:	 800100               	add	byte ptr [rcx], 0
-;; b95c:	 aa                   	stosb	byte ptr [rdi], al
-;; b95d:	 800100               	add	byte ptr [rcx], 0
-;; b960:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b969:	 800100               	add	byte ptr [rcx], 0
-;; b96c:	 aa                   	stosb	byte ptr [rdi], al
-;; b96d:	 800100               	add	byte ptr [rcx], 0
-;; b970:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b979:	 800100               	add	byte ptr [rcx], 0
-;; b97c:	 aa                   	stosb	byte ptr [rdi], al
-;; b97d:	 800100               	add	byte ptr [rcx], 0
-;; b980:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b989:	 800100               	add	byte ptr [rcx], 0
-;; b98c:	 aa                   	stosb	byte ptr [rdi], al
-;; b98d:	 800100               	add	byte ptr [rcx], 0
-;; b990:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b999:	 800100               	add	byte ptr [rcx], 0
-;; b99c:	 aa                   	stosb	byte ptr [rdi], al
-;; b99d:	 800100               	add	byte ptr [rcx], 0
-;; b9a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b9a9:	 800100               	add	byte ptr [rcx], 0
-;; b9ac:	 aa                   	stosb	byte ptr [rdi], al
-;; b9ad:	 800100               	add	byte ptr [rcx], 0
-;; b9b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b9b9:	 800100               	add	byte ptr [rcx], 0
-;; b9bc:	 aa                   	stosb	byte ptr [rdi], al
-;; b9bd:	 800100               	add	byte ptr [rcx], 0
-;; b9c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b9c9:	 800100               	add	byte ptr [rcx], 0
-;; b9cc:	 aa                   	stosb	byte ptr [rdi], al
-;; b9cd:	 800100               	add	byte ptr [rcx], 0
-;; b9d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b9d9:	 800100               	add	byte ptr [rcx], 0
-;; b9dc:	 aa                   	stosb	byte ptr [rdi], al
-;; b9dd:	 800100               	add	byte ptr [rcx], 0
-;; b9e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b9e9:	 800100               	add	byte ptr [rcx], 0
-;; b9ec:	 aa                   	stosb	byte ptr [rdi], al
-;; b9ed:	 800100               	add	byte ptr [rcx], 0
-;; b9f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; b9f9:	 800100               	add	byte ptr [rcx], 0
-;; b9fc:	 aa                   	stosb	byte ptr [rdi], al
-;; b9fd:	 800100               	add	byte ptr [rcx], 0
-;; ba00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ba09:	 800100               	add	byte ptr [rcx], 0
-;; ba0c:	 aa                   	stosb	byte ptr [rdi], al
-;; ba0d:	 800100               	add	byte ptr [rcx], 0
-;; ba10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ba19:	 800100               	add	byte ptr [rcx], 0
-;; ba1c:	 aa                   	stosb	byte ptr [rdi], al
-;; ba1d:	 800100               	add	byte ptr [rcx], 0
-;; ba20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ba29:	 800100               	add	byte ptr [rcx], 0
-;; ba2c:	 aa                   	stosb	byte ptr [rdi], al
-;; ba2d:	 800100               	add	byte ptr [rcx], 0
-;; ba30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ba39:	 800100               	add	byte ptr [rcx], 0
-;; ba3c:	 aa                   	stosb	byte ptr [rdi], al
-;; ba3d:	 800100               	add	byte ptr [rcx], 0
-;; ba40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ba49:	 800100               	add	byte ptr [rcx], 0
-;; ba4c:	 aa                   	stosb	byte ptr [rdi], al
-;; ba4d:	 800100               	add	byte ptr [rcx], 0
-;; ba50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ba59:	 800100               	add	byte ptr [rcx], 0
-;; ba5c:	 aa                   	stosb	byte ptr [rdi], al
-;; ba5d:	 800100               	add	byte ptr [rcx], 0
-;; ba60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ba69:	 800100               	add	byte ptr [rcx], 0
-;; ba6c:	 aa                   	stosb	byte ptr [rdi], al
-;; ba6d:	 800100               	add	byte ptr [rcx], 0
-;; ba70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ba79:	 800100               	add	byte ptr [rcx], 0
-;; ba7c:	 aa                   	stosb	byte ptr [rdi], al
-;; ba7d:	 800100               	add	byte ptr [rcx], 0
-;; ba80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ba89:	 800100               	add	byte ptr [rcx], 0
-;; ba8c:	 aa                   	stosb	byte ptr [rdi], al
-;; ba8d:	 800100               	add	byte ptr [rcx], 0
-;; ba90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ba99:	 800100               	add	byte ptr [rcx], 0
-;; ba9c:	 aa                   	stosb	byte ptr [rdi], al
-;; ba9d:	 800100               	add	byte ptr [rcx], 0
-;; baa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; baa9:	 800100               	add	byte ptr [rcx], 0
-;; baac:	 aa                   	stosb	byte ptr [rdi], al
-;; baad:	 800100               	add	byte ptr [rcx], 0
-;; bab0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bab9:	 800100               	add	byte ptr [rcx], 0
-;; babc:	 aa                   	stosb	byte ptr [rdi], al
-;; babd:	 800100               	add	byte ptr [rcx], 0
-;; bac0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bac9:	 800100               	add	byte ptr [rcx], 0
-;; bacc:	 aa                   	stosb	byte ptr [rdi], al
-;; bacd:	 800100               	add	byte ptr [rcx], 0
-;; bad0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bad9:	 800100               	add	byte ptr [rcx], 0
-;; badc:	 aa                   	stosb	byte ptr [rdi], al
-;; badd:	 800100               	add	byte ptr [rcx], 0
-;; bae0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bae9:	 800100               	add	byte ptr [rcx], 0
-;; baec:	 aa                   	stosb	byte ptr [rdi], al
-;; baed:	 800100               	add	byte ptr [rcx], 0
-;; baf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; baf9:	 800100               	add	byte ptr [rcx], 0
-;; bafc:	 aa                   	stosb	byte ptr [rdi], al
-;; bafd:	 800100               	add	byte ptr [rcx], 0
-;; bb00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bb09:	 800100               	add	byte ptr [rcx], 0
-;; bb0c:	 aa                   	stosb	byte ptr [rdi], al
-;; bb0d:	 800100               	add	byte ptr [rcx], 0
-;; bb10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bb19:	 800100               	add	byte ptr [rcx], 0
-;; bb1c:	 aa                   	stosb	byte ptr [rdi], al
-;; bb1d:	 800100               	add	byte ptr [rcx], 0
-;; bb20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bb29:	 800100               	add	byte ptr [rcx], 0
-;; bb2c:	 aa                   	stosb	byte ptr [rdi], al
-;; bb2d:	 800100               	add	byte ptr [rcx], 0
-;; bb30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bb39:	 800100               	add	byte ptr [rcx], 0
-;; bb3c:	 aa                   	stosb	byte ptr [rdi], al
-;; bb3d:	 800100               	add	byte ptr [rcx], 0
-;; bb40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bb49:	 800100               	add	byte ptr [rcx], 0
-;; bb4c:	 aa                   	stosb	byte ptr [rdi], al
-;; bb4d:	 800100               	add	byte ptr [rcx], 0
-;; bb50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bb59:	 800100               	add	byte ptr [rcx], 0
-;; bb5c:	 aa                   	stosb	byte ptr [rdi], al
-;; bb5d:	 800100               	add	byte ptr [rcx], 0
-;; bb60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bb69:	 800100               	add	byte ptr [rcx], 0
-;; bb6c:	 aa                   	stosb	byte ptr [rdi], al
-;; bb6d:	 800100               	add	byte ptr [rcx], 0
-;; bb70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bb79:	 800100               	add	byte ptr [rcx], 0
-;; bb7c:	 aa                   	stosb	byte ptr [rdi], al
-;; bb7d:	 800100               	add	byte ptr [rcx], 0
-;; bb80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bb89:	 800100               	add	byte ptr [rcx], 0
-;; bb8c:	 aa                   	stosb	byte ptr [rdi], al
-;; bb8d:	 800100               	add	byte ptr [rcx], 0
-;; bb90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bb99:	 800100               	add	byte ptr [rcx], 0
-;; bb9c:	 aa                   	stosb	byte ptr [rdi], al
-;; bb9d:	 800100               	add	byte ptr [rcx], 0
-;; bba0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bba9:	 800100               	add	byte ptr [rcx], 0
-;; bbac:	 aa                   	stosb	byte ptr [rdi], al
-;; bbad:	 800100               	add	byte ptr [rcx], 0
-;; bbb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bbb9:	 800100               	add	byte ptr [rcx], 0
-;; bbbc:	 aa                   	stosb	byte ptr [rdi], al
-;; bbbd:	 800100               	add	byte ptr [rcx], 0
-;; bbc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bbc9:	 800100               	add	byte ptr [rcx], 0
-;; bbcc:	 aa                   	stosb	byte ptr [rdi], al
-;; bbcd:	 800100               	add	byte ptr [rcx], 0
-;; bbd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bbd9:	 800100               	add	byte ptr [rcx], 0
-;; bbdc:	 aa                   	stosb	byte ptr [rdi], al
-;; bbdd:	 800100               	add	byte ptr [rcx], 0
-;; bbe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bbe9:	 800100               	add	byte ptr [rcx], 0
-;; bbec:	 aa                   	stosb	byte ptr [rdi], al
-;; bbed:	 800100               	add	byte ptr [rcx], 0
-;; bbf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bbf9:	 800100               	add	byte ptr [rcx], 0
-;; bbfc:	 aa                   	stosb	byte ptr [rdi], al
-;; bbfd:	 800100               	add	byte ptr [rcx], 0
-;; bc00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bc09:	 800100               	add	byte ptr [rcx], 0
-;; bc0c:	 aa                   	stosb	byte ptr [rdi], al
-;; bc0d:	 800100               	add	byte ptr [rcx], 0
-;; bc10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bc19:	 800100               	add	byte ptr [rcx], 0
-;; bc1c:	 aa                   	stosb	byte ptr [rdi], al
-;; bc1d:	 800100               	add	byte ptr [rcx], 0
-;; bc20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bc29:	 800100               	add	byte ptr [rcx], 0
-;; bc2c:	 aa                   	stosb	byte ptr [rdi], al
-;; bc2d:	 800100               	add	byte ptr [rcx], 0
-;; bc30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bc39:	 800100               	add	byte ptr [rcx], 0
-;; bc3c:	 aa                   	stosb	byte ptr [rdi], al
-;; bc3d:	 800100               	add	byte ptr [rcx], 0
-;; bc40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bc49:	 800100               	add	byte ptr [rcx], 0
-;; bc4c:	 aa                   	stosb	byte ptr [rdi], al
-;; bc4d:	 800100               	add	byte ptr [rcx], 0
-;; bc50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bc59:	 800100               	add	byte ptr [rcx], 0
-;; bc5c:	 aa                   	stosb	byte ptr [rdi], al
-;; bc5d:	 800100               	add	byte ptr [rcx], 0
-;; bc60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bc69:	 800100               	add	byte ptr [rcx], 0
-;; bc6c:	 aa                   	stosb	byte ptr [rdi], al
-;; bc6d:	 800100               	add	byte ptr [rcx], 0
-;; bc70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bc79:	 800100               	add	byte ptr [rcx], 0
-;; bc7c:	 aa                   	stosb	byte ptr [rdi], al
-;; bc7d:	 800100               	add	byte ptr [rcx], 0
-;; bc80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bc89:	 800100               	add	byte ptr [rcx], 0
-;; bc8c:	 aa                   	stosb	byte ptr [rdi], al
-;; bc8d:	 800100               	add	byte ptr [rcx], 0
-;; bc90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bc99:	 800100               	add	byte ptr [rcx], 0
-;; bc9c:	 aa                   	stosb	byte ptr [rdi], al
-;; bc9d:	 800100               	add	byte ptr [rcx], 0
-;; bca0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bca9:	 800100               	add	byte ptr [rcx], 0
-;; bcac:	 aa                   	stosb	byte ptr [rdi], al
-;; bcad:	 800100               	add	byte ptr [rcx], 0
-;; bcb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bcb9:	 800100               	add	byte ptr [rcx], 0
-;; bcbc:	 aa                   	stosb	byte ptr [rdi], al
-;; bcbd:	 800100               	add	byte ptr [rcx], 0
-;; bcc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bcc9:	 800100               	add	byte ptr [rcx], 0
-;; bccc:	 aa                   	stosb	byte ptr [rdi], al
-;; bccd:	 800100               	add	byte ptr [rcx], 0
-;; bcd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bcd9:	 800100               	add	byte ptr [rcx], 0
-;; bcdc:	 aa                   	stosb	byte ptr [rdi], al
-;; bcdd:	 800100               	add	byte ptr [rcx], 0
-;; bce0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bce9:	 800100               	add	byte ptr [rcx], 0
-;; bcec:	 aa                   	stosb	byte ptr [rdi], al
-;; bced:	 800100               	add	byte ptr [rcx], 0
-;; bcf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bcf9:	 800100               	add	byte ptr [rcx], 0
-;; bcfc:	 aa                   	stosb	byte ptr [rdi], al
-;; bcfd:	 800100               	add	byte ptr [rcx], 0
-;; bd00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bd09:	 800100               	add	byte ptr [rcx], 0
-;; bd0c:	 aa                   	stosb	byte ptr [rdi], al
-;; bd0d:	 800100               	add	byte ptr [rcx], 0
-;; bd10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bd19:	 800100               	add	byte ptr [rcx], 0
-;; bd1c:	 aa                   	stosb	byte ptr [rdi], al
-;; bd1d:	 800100               	add	byte ptr [rcx], 0
-;; bd20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bd29:	 800100               	add	byte ptr [rcx], 0
-;; bd2c:	 aa                   	stosb	byte ptr [rdi], al
-;; bd2d:	 800100               	add	byte ptr [rcx], 0
-;; bd30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bd39:	 800100               	add	byte ptr [rcx], 0
-;; bd3c:	 aa                   	stosb	byte ptr [rdi], al
-;; bd3d:	 800100               	add	byte ptr [rcx], 0
-;; bd40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bd49:	 800100               	add	byte ptr [rcx], 0
-;; bd4c:	 aa                   	stosb	byte ptr [rdi], al
-;; bd4d:	 800100               	add	byte ptr [rcx], 0
-;; bd50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bd59:	 800100               	add	byte ptr [rcx], 0
-;; bd5c:	 aa                   	stosb	byte ptr [rdi], al
-;; bd5d:	 800100               	add	byte ptr [rcx], 0
-;; bd60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bd69:	 800100               	add	byte ptr [rcx], 0
-;; bd6c:	 aa                   	stosb	byte ptr [rdi], al
-;; bd6d:	 800100               	add	byte ptr [rcx], 0
-;; bd70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bd79:	 800100               	add	byte ptr [rcx], 0
-;; bd7c:	 aa                   	stosb	byte ptr [rdi], al
-;; bd7d:	 800100               	add	byte ptr [rcx], 0
-;; bd80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bd89:	 800100               	add	byte ptr [rcx], 0
-;; bd8c:	 aa                   	stosb	byte ptr [rdi], al
-;; bd8d:	 800100               	add	byte ptr [rcx], 0
-;; bd90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bd99:	 800100               	add	byte ptr [rcx], 0
-;; bd9c:	 aa                   	stosb	byte ptr [rdi], al
-;; bd9d:	 800100               	add	byte ptr [rcx], 0
-;; bda0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bda9:	 800100               	add	byte ptr [rcx], 0
-;; bdac:	 aa                   	stosb	byte ptr [rdi], al
-;; bdad:	 800100               	add	byte ptr [rcx], 0
-;; bdb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bdb9:	 800100               	add	byte ptr [rcx], 0
-;; bdbc:	 aa                   	stosb	byte ptr [rdi], al
-;; bdbd:	 800100               	add	byte ptr [rcx], 0
-;; bdc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bdc9:	 800100               	add	byte ptr [rcx], 0
-;; bdcc:	 aa                   	stosb	byte ptr [rdi], al
-;; bdcd:	 800100               	add	byte ptr [rcx], 0
-;; bdd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bdd9:	 800100               	add	byte ptr [rcx], 0
-;; bddc:	 aa                   	stosb	byte ptr [rdi], al
-;; bddd:	 800100               	add	byte ptr [rcx], 0
-;; bde0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bde9:	 800100               	add	byte ptr [rcx], 0
-;; bdec:	 aa                   	stosb	byte ptr [rdi], al
-;; bded:	 800100               	add	byte ptr [rcx], 0
-;; bdf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bdf9:	 800100               	add	byte ptr [rcx], 0
-;; bdfc:	 aa                   	stosb	byte ptr [rdi], al
-;; bdfd:	 800100               	add	byte ptr [rcx], 0
-;; be00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; be09:	 800100               	add	byte ptr [rcx], 0
-;; be0c:	 aa                   	stosb	byte ptr [rdi], al
-;; be0d:	 800100               	add	byte ptr [rcx], 0
-;; be10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; be19:	 800100               	add	byte ptr [rcx], 0
-;; be1c:	 aa                   	stosb	byte ptr [rdi], al
-;; be1d:	 800100               	add	byte ptr [rcx], 0
-;; be20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; be29:	 800100               	add	byte ptr [rcx], 0
-;; be2c:	 aa                   	stosb	byte ptr [rdi], al
-;; be2d:	 800100               	add	byte ptr [rcx], 0
-;; be30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; be39:	 800100               	add	byte ptr [rcx], 0
-;; be3c:	 aa                   	stosb	byte ptr [rdi], al
-;; be3d:	 800100               	add	byte ptr [rcx], 0
-;; be40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; be49:	 800100               	add	byte ptr [rcx], 0
-;; be4c:	 aa                   	stosb	byte ptr [rdi], al
-;; be4d:	 800100               	add	byte ptr [rcx], 0
-;; be50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; be59:	 800100               	add	byte ptr [rcx], 0
-;; be5c:	 aa                   	stosb	byte ptr [rdi], al
-;; be5d:	 800100               	add	byte ptr [rcx], 0
-;; be60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; be69:	 800100               	add	byte ptr [rcx], 0
-;; be6c:	 aa                   	stosb	byte ptr [rdi], al
-;; be6d:	 800100               	add	byte ptr [rcx], 0
-;; be70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; be79:	 800100               	add	byte ptr [rcx], 0
-;; be7c:	 aa                   	stosb	byte ptr [rdi], al
-;; be7d:	 800100               	add	byte ptr [rcx], 0
-;; be80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; be89:	 800100               	add	byte ptr [rcx], 0
-;; be8c:	 aa                   	stosb	byte ptr [rdi], al
-;; be8d:	 800100               	add	byte ptr [rcx], 0
-;; be90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; be99:	 800100               	add	byte ptr [rcx], 0
-;; be9c:	 aa                   	stosb	byte ptr [rdi], al
-;; be9d:	 800100               	add	byte ptr [rcx], 0
-;; bea0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bea9:	 800100               	add	byte ptr [rcx], 0
-;; beac:	 aa                   	stosb	byte ptr [rdi], al
-;; bead:	 800100               	add	byte ptr [rcx], 0
-;; beb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; beb9:	 800100               	add	byte ptr [rcx], 0
-;; bebc:	 aa                   	stosb	byte ptr [rdi], al
-;; bebd:	 800100               	add	byte ptr [rcx], 0
-;; bec0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bec9:	 800100               	add	byte ptr [rcx], 0
-;; becc:	 aa                   	stosb	byte ptr [rdi], al
-;; becd:	 800100               	add	byte ptr [rcx], 0
-;; bed0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bed9:	 800100               	add	byte ptr [rcx], 0
-;; bedc:	 aa                   	stosb	byte ptr [rdi], al
-;; bedd:	 800100               	add	byte ptr [rcx], 0
-;; bee0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bee9:	 800100               	add	byte ptr [rcx], 0
-;; beec:	 aa                   	stosb	byte ptr [rdi], al
-;; beed:	 800100               	add	byte ptr [rcx], 0
-;; bef0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bef9:	 800100               	add	byte ptr [rcx], 0
-;; befc:	 aa                   	stosb	byte ptr [rdi], al
-;; befd:	 800100               	add	byte ptr [rcx], 0
-;; bf00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bf09:	 800100               	add	byte ptr [rcx], 0
-;; bf0c:	 aa                   	stosb	byte ptr [rdi], al
-;; bf0d:	 800100               	add	byte ptr [rcx], 0
-;; bf10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bf19:	 800100               	add	byte ptr [rcx], 0
-;; bf1c:	 aa                   	stosb	byte ptr [rdi], al
-;; bf1d:	 800100               	add	byte ptr [rcx], 0
-;; bf20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bf29:	 800100               	add	byte ptr [rcx], 0
-;; bf2c:	 aa                   	stosb	byte ptr [rdi], al
-;; bf2d:	 800100               	add	byte ptr [rcx], 0
-;; bf30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bf39:	 800100               	add	byte ptr [rcx], 0
-;; bf3c:	 aa                   	stosb	byte ptr [rdi], al
-;; bf3d:	 800100               	add	byte ptr [rcx], 0
-;; bf40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bf49:	 800100               	add	byte ptr [rcx], 0
-;; bf4c:	 aa                   	stosb	byte ptr [rdi], al
-;; bf4d:	 800100               	add	byte ptr [rcx], 0
-;; bf50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bf59:	 800100               	add	byte ptr [rcx], 0
-;; bf5c:	 aa                   	stosb	byte ptr [rdi], al
-;; bf5d:	 800100               	add	byte ptr [rcx], 0
-;; bf60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bf69:	 800100               	add	byte ptr [rcx], 0
-;; bf6c:	 aa                   	stosb	byte ptr [rdi], al
-;; bf6d:	 800100               	add	byte ptr [rcx], 0
-;; bf70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bf79:	 800100               	add	byte ptr [rcx], 0
-;; bf7c:	 aa                   	stosb	byte ptr [rdi], al
-;; bf7d:	 800100               	add	byte ptr [rcx], 0
-;; bf80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bf89:	 800100               	add	byte ptr [rcx], 0
-;; bf8c:	 aa                   	stosb	byte ptr [rdi], al
-;; bf8d:	 800100               	add	byte ptr [rcx], 0
-;; bf90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bf99:	 800100               	add	byte ptr [rcx], 0
-;; bf9c:	 aa                   	stosb	byte ptr [rdi], al
-;; bf9d:	 800100               	add	byte ptr [rcx], 0
-;; bfa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bfa9:	 800100               	add	byte ptr [rcx], 0
-;; bfac:	 aa                   	stosb	byte ptr [rdi], al
-;; bfad:	 800100               	add	byte ptr [rcx], 0
-;; bfb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bfb9:	 800100               	add	byte ptr [rcx], 0
-;; bfbc:	 aa                   	stosb	byte ptr [rdi], al
-;; bfbd:	 800100               	add	byte ptr [rcx], 0
-;; bfc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bfc9:	 800100               	add	byte ptr [rcx], 0
-;; bfcc:	 aa                   	stosb	byte ptr [rdi], al
-;; bfcd:	 800100               	add	byte ptr [rcx], 0
-;; bfd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bfd9:	 800100               	add	byte ptr [rcx], 0
-;; bfdc:	 aa                   	stosb	byte ptr [rdi], al
-;; bfdd:	 800100               	add	byte ptr [rcx], 0
-;; bfe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bfe9:	 800100               	add	byte ptr [rcx], 0
-;; bfec:	 aa                   	stosb	byte ptr [rdi], al
-;; bfed:	 800100               	add	byte ptr [rcx], 0
-;; bff0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; bff9:	 800100               	add	byte ptr [rcx], 0
-;; bffc:	 aa                   	stosb	byte ptr [rdi], al
-;; bffd:	 800100               	add	byte ptr [rcx], 0
-;; c000:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c009:	 800100               	add	byte ptr [rcx], 0
-;; c00c:	 aa                   	stosb	byte ptr [rdi], al
-;; c00d:	 800100               	add	byte ptr [rcx], 0
-;; c010:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c019:	 800100               	add	byte ptr [rcx], 0
-;; c01c:	 aa                   	stosb	byte ptr [rdi], al
-;; c01d:	 800100               	add	byte ptr [rcx], 0
-;; c020:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c029:	 800100               	add	byte ptr [rcx], 0
-;; c02c:	 aa                   	stosb	byte ptr [rdi], al
-;; c02d:	 800100               	add	byte ptr [rcx], 0
-;; c030:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c039:	 800100               	add	byte ptr [rcx], 0
-;; c03c:	 aa                   	stosb	byte ptr [rdi], al
-;; c03d:	 800100               	add	byte ptr [rcx], 0
-;; c040:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c049:	 800100               	add	byte ptr [rcx], 0
-;; c04c:	 aa                   	stosb	byte ptr [rdi], al
-;; c04d:	 800100               	add	byte ptr [rcx], 0
-;; c050:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c059:	 800100               	add	byte ptr [rcx], 0
-;; c05c:	 aa                   	stosb	byte ptr [rdi], al
-;; c05d:	 800100               	add	byte ptr [rcx], 0
-;; c060:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c069:	 800100               	add	byte ptr [rcx], 0
-;; c06c:	 aa                   	stosb	byte ptr [rdi], al
-;; c06d:	 800100               	add	byte ptr [rcx], 0
-;; c070:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c079:	 800100               	add	byte ptr [rcx], 0
-;; c07c:	 aa                   	stosb	byte ptr [rdi], al
-;; c07d:	 800100               	add	byte ptr [rcx], 0
-;; c080:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c089:	 800100               	add	byte ptr [rcx], 0
-;; c08c:	 aa                   	stosb	byte ptr [rdi], al
-;; c08d:	 800100               	add	byte ptr [rcx], 0
-;; c090:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c099:	 800100               	add	byte ptr [rcx], 0
-;; c09c:	 aa                   	stosb	byte ptr [rdi], al
-;; c09d:	 800100               	add	byte ptr [rcx], 0
-;; c0a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c0a9:	 800100               	add	byte ptr [rcx], 0
-;; c0ac:	 aa                   	stosb	byte ptr [rdi], al
-;; c0ad:	 800100               	add	byte ptr [rcx], 0
-;; c0b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c0b9:	 800100               	add	byte ptr [rcx], 0
-;; c0bc:	 aa                   	stosb	byte ptr [rdi], al
-;; c0bd:	 800100               	add	byte ptr [rcx], 0
-;; c0c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c0c9:	 800100               	add	byte ptr [rcx], 0
-;; c0cc:	 aa                   	stosb	byte ptr [rdi], al
-;; c0cd:	 800100               	add	byte ptr [rcx], 0
-;; c0d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c0d9:	 800100               	add	byte ptr [rcx], 0
-;; c0dc:	 aa                   	stosb	byte ptr [rdi], al
-;; c0dd:	 800100               	add	byte ptr [rcx], 0
-;; c0e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c0e9:	 800100               	add	byte ptr [rcx], 0
-;; c0ec:	 aa                   	stosb	byte ptr [rdi], al
-;; c0ed:	 800100               	add	byte ptr [rcx], 0
-;; c0f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c0f9:	 800100               	add	byte ptr [rcx], 0
-;; c0fc:	 aa                   	stosb	byte ptr [rdi], al
-;; c0fd:	 800100               	add	byte ptr [rcx], 0
-;; c100:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c109:	 800100               	add	byte ptr [rcx], 0
-;; c10c:	 aa                   	stosb	byte ptr [rdi], al
-;; c10d:	 800100               	add	byte ptr [rcx], 0
-;; c110:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c119:	 800100               	add	byte ptr [rcx], 0
-;; c11c:	 aa                   	stosb	byte ptr [rdi], al
-;; c11d:	 800100               	add	byte ptr [rcx], 0
-;; c120:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c129:	 800100               	add	byte ptr [rcx], 0
-;; c12c:	 aa                   	stosb	byte ptr [rdi], al
-;; c12d:	 800100               	add	byte ptr [rcx], 0
-;; c130:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c139:	 800100               	add	byte ptr [rcx], 0
-;; c13c:	 aa                   	stosb	byte ptr [rdi], al
-;; c13d:	 800100               	add	byte ptr [rcx], 0
-;; c140:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c149:	 800100               	add	byte ptr [rcx], 0
-;; c14c:	 aa                   	stosb	byte ptr [rdi], al
-;; c14d:	 800100               	add	byte ptr [rcx], 0
-;; c150:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c159:	 800100               	add	byte ptr [rcx], 0
-;; c15c:	 aa                   	stosb	byte ptr [rdi], al
-;; c15d:	 800100               	add	byte ptr [rcx], 0
-;; c160:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c169:	 800100               	add	byte ptr [rcx], 0
-;; c16c:	 aa                   	stosb	byte ptr [rdi], al
-;; c16d:	 800100               	add	byte ptr [rcx], 0
-;; c170:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c179:	 800100               	add	byte ptr [rcx], 0
-;; c17c:	 aa                   	stosb	byte ptr [rdi], al
-;; c17d:	 800100               	add	byte ptr [rcx], 0
-;; c180:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c189:	 800100               	add	byte ptr [rcx], 0
-;; c18c:	 aa                   	stosb	byte ptr [rdi], al
-;; c18d:	 800100               	add	byte ptr [rcx], 0
-;; c190:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c199:	 800100               	add	byte ptr [rcx], 0
-;; c19c:	 aa                   	stosb	byte ptr [rdi], al
-;; c19d:	 800100               	add	byte ptr [rcx], 0
-;; c1a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c1a9:	 800100               	add	byte ptr [rcx], 0
-;; c1ac:	 aa                   	stosb	byte ptr [rdi], al
-;; c1ad:	 800100               	add	byte ptr [rcx], 0
-;; c1b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c1b9:	 800100               	add	byte ptr [rcx], 0
-;; c1bc:	 aa                   	stosb	byte ptr [rdi], al
-;; c1bd:	 800100               	add	byte ptr [rcx], 0
-;; c1c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c1c9:	 800100               	add	byte ptr [rcx], 0
-;; c1cc:	 aa                   	stosb	byte ptr [rdi], al
-;; c1cd:	 800100               	add	byte ptr [rcx], 0
-;; c1d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c1d9:	 800100               	add	byte ptr [rcx], 0
-;; c1dc:	 aa                   	stosb	byte ptr [rdi], al
-;; c1dd:	 800100               	add	byte ptr [rcx], 0
-;; c1e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c1e9:	 800100               	add	byte ptr [rcx], 0
-;; c1ec:	 aa                   	stosb	byte ptr [rdi], al
-;; c1ed:	 800100               	add	byte ptr [rcx], 0
-;; c1f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c1f9:	 800100               	add	byte ptr [rcx], 0
-;; c1fc:	 aa                   	stosb	byte ptr [rdi], al
-;; c1fd:	 800100               	add	byte ptr [rcx], 0
-;; c200:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c209:	 800100               	add	byte ptr [rcx], 0
-;; c20c:	 aa                   	stosb	byte ptr [rdi], al
-;; c20d:	 800100               	add	byte ptr [rcx], 0
-;; c210:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c219:	 800100               	add	byte ptr [rcx], 0
-;; c21c:	 aa                   	stosb	byte ptr [rdi], al
-;; c21d:	 800100               	add	byte ptr [rcx], 0
-;; c220:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c229:	 800100               	add	byte ptr [rcx], 0
-;; c22c:	 aa                   	stosb	byte ptr [rdi], al
-;; c22d:	 800100               	add	byte ptr [rcx], 0
-;; c230:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c239:	 800100               	add	byte ptr [rcx], 0
-;; c23c:	 aa                   	stosb	byte ptr [rdi], al
-;; c23d:	 800100               	add	byte ptr [rcx], 0
-;; c240:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c249:	 800100               	add	byte ptr [rcx], 0
-;; c24c:	 aa                   	stosb	byte ptr [rdi], al
-;; c24d:	 800100               	add	byte ptr [rcx], 0
-;; c250:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c259:	 800100               	add	byte ptr [rcx], 0
-;; c25c:	 aa                   	stosb	byte ptr [rdi], al
-;; c25d:	 800100               	add	byte ptr [rcx], 0
-;; c260:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c269:	 800100               	add	byte ptr [rcx], 0
-;; c26c:	 aa                   	stosb	byte ptr [rdi], al
-;; c26d:	 800100               	add	byte ptr [rcx], 0
-;; c270:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c279:	 800100               	add	byte ptr [rcx], 0
-;; c27c:	 aa                   	stosb	byte ptr [rdi], al
-;; c27d:	 800100               	add	byte ptr [rcx], 0
-;; c280:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c289:	 800100               	add	byte ptr [rcx], 0
-;; c28c:	 aa                   	stosb	byte ptr [rdi], al
-;; c28d:	 800100               	add	byte ptr [rcx], 0
-;; c290:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c299:	 800100               	add	byte ptr [rcx], 0
-;; c29c:	 aa                   	stosb	byte ptr [rdi], al
-;; c29d:	 800100               	add	byte ptr [rcx], 0
-;; c2a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c2a9:	 800100               	add	byte ptr [rcx], 0
-;; c2ac:	 aa                   	stosb	byte ptr [rdi], al
-;; c2ad:	 800100               	add	byte ptr [rcx], 0
-;; c2b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c2b9:	 800100               	add	byte ptr [rcx], 0
-;; c2bc:	 aa                   	stosb	byte ptr [rdi], al
-;; c2bd:	 800100               	add	byte ptr [rcx], 0
-;; c2c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c2c9:	 800100               	add	byte ptr [rcx], 0
-;; c2cc:	 aa                   	stosb	byte ptr [rdi], al
-;; c2cd:	 800100               	add	byte ptr [rcx], 0
-;; c2d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c2d9:	 800100               	add	byte ptr [rcx], 0
-;; c2dc:	 aa                   	stosb	byte ptr [rdi], al
-;; c2dd:	 800100               	add	byte ptr [rcx], 0
-;; c2e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c2e9:	 800100               	add	byte ptr [rcx], 0
-;; c2ec:	 aa                   	stosb	byte ptr [rdi], al
-;; c2ed:	 800100               	add	byte ptr [rcx], 0
-;; c2f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c2f9:	 800100               	add	byte ptr [rcx], 0
-;; c2fc:	 aa                   	stosb	byte ptr [rdi], al
-;; c2fd:	 800100               	add	byte ptr [rcx], 0
-;; c300:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c309:	 800100               	add	byte ptr [rcx], 0
-;; c30c:	 aa                   	stosb	byte ptr [rdi], al
-;; c30d:	 800100               	add	byte ptr [rcx], 0
-;; c310:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c319:	 800100               	add	byte ptr [rcx], 0
-;; c31c:	 aa                   	stosb	byte ptr [rdi], al
-;; c31d:	 800100               	add	byte ptr [rcx], 0
-;; c320:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c329:	 800100               	add	byte ptr [rcx], 0
-;; c32c:	 aa                   	stosb	byte ptr [rdi], al
-;; c32d:	 800100               	add	byte ptr [rcx], 0
-;; c330:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c339:	 800100               	add	byte ptr [rcx], 0
-;; c33c:	 aa                   	stosb	byte ptr [rdi], al
-;; c33d:	 800100               	add	byte ptr [rcx], 0
-;; c340:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c349:	 800100               	add	byte ptr [rcx], 0
-;; c34c:	 aa                   	stosb	byte ptr [rdi], al
-;; c34d:	 800100               	add	byte ptr [rcx], 0
-;; c350:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c359:	 800100               	add	byte ptr [rcx], 0
-;; c35c:	 aa                   	stosb	byte ptr [rdi], al
-;; c35d:	 800100               	add	byte ptr [rcx], 0
-;; c360:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c369:	 800100               	add	byte ptr [rcx], 0
-;; c36c:	 aa                   	stosb	byte ptr [rdi], al
-;; c36d:	 800100               	add	byte ptr [rcx], 0
-;; c370:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c379:	 800100               	add	byte ptr [rcx], 0
-;; c37c:	 aa                   	stosb	byte ptr [rdi], al
-;; c37d:	 800100               	add	byte ptr [rcx], 0
-;; c380:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c389:	 800100               	add	byte ptr [rcx], 0
-;; c38c:	 aa                   	stosb	byte ptr [rdi], al
-;; c38d:	 800100               	add	byte ptr [rcx], 0
-;; c390:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c399:	 800100               	add	byte ptr [rcx], 0
-;; c39c:	 aa                   	stosb	byte ptr [rdi], al
-;; c39d:	 800100               	add	byte ptr [rcx], 0
-;; c3a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c3a9:	 800100               	add	byte ptr [rcx], 0
-;; c3ac:	 aa                   	stosb	byte ptr [rdi], al
-;; c3ad:	 800100               	add	byte ptr [rcx], 0
-;; c3b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c3b9:	 800100               	add	byte ptr [rcx], 0
-;; c3bc:	 aa                   	stosb	byte ptr [rdi], al
-;; c3bd:	 800100               	add	byte ptr [rcx], 0
-;; c3c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c3c9:	 800100               	add	byte ptr [rcx], 0
-;; c3cc:	 aa                   	stosb	byte ptr [rdi], al
-;; c3cd:	 800100               	add	byte ptr [rcx], 0
-;; c3d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c3d9:	 800100               	add	byte ptr [rcx], 0
-;; c3dc:	 aa                   	stosb	byte ptr [rdi], al
-;; c3dd:	 800100               	add	byte ptr [rcx], 0
-;; c3e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c3e9:	 800100               	add	byte ptr [rcx], 0
-;; c3ec:	 aa                   	stosb	byte ptr [rdi], al
-;; c3ed:	 800100               	add	byte ptr [rcx], 0
-;; c3f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c3f9:	 800100               	add	byte ptr [rcx], 0
-;; c3fc:	 aa                   	stosb	byte ptr [rdi], al
-;; c3fd:	 800100               	add	byte ptr [rcx], 0
-;; c400:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c409:	 800100               	add	byte ptr [rcx], 0
-;; c40c:	 aa                   	stosb	byte ptr [rdi], al
-;; c40d:	 800100               	add	byte ptr [rcx], 0
-;; c410:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c419:	 800100               	add	byte ptr [rcx], 0
-;; c41c:	 aa                   	stosb	byte ptr [rdi], al
-;; c41d:	 800100               	add	byte ptr [rcx], 0
-;; c420:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c429:	 800100               	add	byte ptr [rcx], 0
-;; c42c:	 aa                   	stosb	byte ptr [rdi], al
-;; c42d:	 800100               	add	byte ptr [rcx], 0
-;; c430:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c439:	 800100               	add	byte ptr [rcx], 0
-;; c43c:	 aa                   	stosb	byte ptr [rdi], al
-;; c43d:	 800100               	add	byte ptr [rcx], 0
-;; c440:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c449:	 800100               	add	byte ptr [rcx], 0
-;; c44c:	 aa                   	stosb	byte ptr [rdi], al
-;; c44d:	 800100               	add	byte ptr [rcx], 0
-;; c450:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c459:	 800100               	add	byte ptr [rcx], 0
-;; c45c:	 aa                   	stosb	byte ptr [rdi], al
-;; c45d:	 800100               	add	byte ptr [rcx], 0
-;; c460:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c469:	 800100               	add	byte ptr [rcx], 0
-;; c46c:	 aa                   	stosb	byte ptr [rdi], al
-;; c46d:	 800100               	add	byte ptr [rcx], 0
-;; c470:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c479:	 800100               	add	byte ptr [rcx], 0
-;; c47c:	 aa                   	stosb	byte ptr [rdi], al
-;; c47d:	 800100               	add	byte ptr [rcx], 0
-;; c480:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c489:	 800100               	add	byte ptr [rcx], 0
-;; c48c:	 aa                   	stosb	byte ptr [rdi], al
-;; c48d:	 800100               	add	byte ptr [rcx], 0
-;; c490:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c499:	 800100               	add	byte ptr [rcx], 0
-;; c49c:	 aa                   	stosb	byte ptr [rdi], al
-;; c49d:	 800100               	add	byte ptr [rcx], 0
-;; c4a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c4a9:	 800100               	add	byte ptr [rcx], 0
-;; c4ac:	 aa                   	stosb	byte ptr [rdi], al
-;; c4ad:	 800100               	add	byte ptr [rcx], 0
-;; c4b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c4b9:	 800100               	add	byte ptr [rcx], 0
-;; c4bc:	 aa                   	stosb	byte ptr [rdi], al
-;; c4bd:	 800100               	add	byte ptr [rcx], 0
-;; c4c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c4c9:	 800100               	add	byte ptr [rcx], 0
-;; c4cc:	 aa                   	stosb	byte ptr [rdi], al
-;; c4cd:	 800100               	add	byte ptr [rcx], 0
-;; c4d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c4d9:	 800100               	add	byte ptr [rcx], 0
-;; c4dc:	 aa                   	stosb	byte ptr [rdi], al
-;; c4dd:	 800100               	add	byte ptr [rcx], 0
-;; c4e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c4e9:	 800100               	add	byte ptr [rcx], 0
-;; c4ec:	 aa                   	stosb	byte ptr [rdi], al
-;; c4ed:	 800100               	add	byte ptr [rcx], 0
-;; c4f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c4f9:	 800100               	add	byte ptr [rcx], 0
-;; c4fc:	 aa                   	stosb	byte ptr [rdi], al
-;; c4fd:	 800100               	add	byte ptr [rcx], 0
-;; c500:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c509:	 800100               	add	byte ptr [rcx], 0
-;; c50c:	 aa                   	stosb	byte ptr [rdi], al
-;; c50d:	 800100               	add	byte ptr [rcx], 0
-;; c510:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c519:	 800100               	add	byte ptr [rcx], 0
-;; c51c:	 aa                   	stosb	byte ptr [rdi], al
-;; c51d:	 800100               	add	byte ptr [rcx], 0
-;; c520:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c529:	 800100               	add	byte ptr [rcx], 0
-;; c52c:	 aa                   	stosb	byte ptr [rdi], al
-;; c52d:	 800100               	add	byte ptr [rcx], 0
-;; c530:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c539:	 800100               	add	byte ptr [rcx], 0
-;; c53c:	 aa                   	stosb	byte ptr [rdi], al
-;; c53d:	 800100               	add	byte ptr [rcx], 0
-;; c540:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c549:	 800100               	add	byte ptr [rcx], 0
-;; c54c:	 aa                   	stosb	byte ptr [rdi], al
-;; c54d:	 800100               	add	byte ptr [rcx], 0
-;; c550:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c559:	 800100               	add	byte ptr [rcx], 0
-;; c55c:	 aa                   	stosb	byte ptr [rdi], al
-;; c55d:	 800100               	add	byte ptr [rcx], 0
-;; c560:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c569:	 800100               	add	byte ptr [rcx], 0
-;; c56c:	 aa                   	stosb	byte ptr [rdi], al
-;; c56d:	 800100               	add	byte ptr [rcx], 0
-;; c570:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c579:	 800100               	add	byte ptr [rcx], 0
-;; c57c:	 aa                   	stosb	byte ptr [rdi], al
-;; c57d:	 800100               	add	byte ptr [rcx], 0
-;; c580:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c589:	 800100               	add	byte ptr [rcx], 0
-;; c58c:	 aa                   	stosb	byte ptr [rdi], al
-;; c58d:	 800100               	add	byte ptr [rcx], 0
-;; c590:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c599:	 800100               	add	byte ptr [rcx], 0
-;; c59c:	 aa                   	stosb	byte ptr [rdi], al
-;; c59d:	 800100               	add	byte ptr [rcx], 0
-;; c5a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c5a9:	 800100               	add	byte ptr [rcx], 0
-;; c5ac:	 aa                   	stosb	byte ptr [rdi], al
-;; c5ad:	 800100               	add	byte ptr [rcx], 0
-;; c5b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c5b9:	 800100               	add	byte ptr [rcx], 0
-;; c5bc:	 aa                   	stosb	byte ptr [rdi], al
-;; c5bd:	 800100               	add	byte ptr [rcx], 0
-;; c5c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c5c9:	 800100               	add	byte ptr [rcx], 0
-;; c5cc:	 aa                   	stosb	byte ptr [rdi], al
-;; c5cd:	 800100               	add	byte ptr [rcx], 0
-;; c5d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c5d9:	 800100               	add	byte ptr [rcx], 0
-;; c5dc:	 aa                   	stosb	byte ptr [rdi], al
-;; c5dd:	 800100               	add	byte ptr [rcx], 0
-;; c5e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c5e9:	 800100               	add	byte ptr [rcx], 0
-;; c5ec:	 aa                   	stosb	byte ptr [rdi], al
-;; c5ed:	 800100               	add	byte ptr [rcx], 0
-;; c5f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c5f9:	 800100               	add	byte ptr [rcx], 0
-;; c5fc:	 aa                   	stosb	byte ptr [rdi], al
-;; c5fd:	 800100               	add	byte ptr [rcx], 0
-;; c600:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c609:	 800100               	add	byte ptr [rcx], 0
-;; c60c:	 aa                   	stosb	byte ptr [rdi], al
-;; c60d:	 800100               	add	byte ptr [rcx], 0
-;; c610:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c619:	 800100               	add	byte ptr [rcx], 0
-;; c61c:	 aa                   	stosb	byte ptr [rdi], al
-;; c61d:	 800100               	add	byte ptr [rcx], 0
-;; c620:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c629:	 800100               	add	byte ptr [rcx], 0
-;; c62c:	 aa                   	stosb	byte ptr [rdi], al
-;; c62d:	 800100               	add	byte ptr [rcx], 0
-;; c630:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c639:	 800100               	add	byte ptr [rcx], 0
-;; c63c:	 aa                   	stosb	byte ptr [rdi], al
-;; c63d:	 800100               	add	byte ptr [rcx], 0
-;; c640:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c649:	 800100               	add	byte ptr [rcx], 0
-;; c64c:	 aa                   	stosb	byte ptr [rdi], al
-;; c64d:	 800100               	add	byte ptr [rcx], 0
-;; c650:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c659:	 800100               	add	byte ptr [rcx], 0
-;; c65c:	 aa                   	stosb	byte ptr [rdi], al
-;; c65d:	 800100               	add	byte ptr [rcx], 0
-;; c660:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c669:	 800100               	add	byte ptr [rcx], 0
-;; c66c:	 aa                   	stosb	byte ptr [rdi], al
-;; c66d:	 800100               	add	byte ptr [rcx], 0
-;; c670:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c679:	 800100               	add	byte ptr [rcx], 0
-;; c67c:	 aa                   	stosb	byte ptr [rdi], al
-;; c67d:	 800100               	add	byte ptr [rcx], 0
-;; c680:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c689:	 800100               	add	byte ptr [rcx], 0
-;; c68c:	 aa                   	stosb	byte ptr [rdi], al
-;; c68d:	 800100               	add	byte ptr [rcx], 0
-;; c690:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c699:	 800100               	add	byte ptr [rcx], 0
-;; c69c:	 aa                   	stosb	byte ptr [rdi], al
-;; c69d:	 800100               	add	byte ptr [rcx], 0
-;; c6a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c6a9:	 800100               	add	byte ptr [rcx], 0
-;; c6ac:	 aa                   	stosb	byte ptr [rdi], al
-;; c6ad:	 800100               	add	byte ptr [rcx], 0
-;; c6b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c6b9:	 800100               	add	byte ptr [rcx], 0
-;; c6bc:	 aa                   	stosb	byte ptr [rdi], al
-;; c6bd:	 800100               	add	byte ptr [rcx], 0
-;; c6c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c6c9:	 800100               	add	byte ptr [rcx], 0
-;; c6cc:	 aa                   	stosb	byte ptr [rdi], al
-;; c6cd:	 800100               	add	byte ptr [rcx], 0
-;; c6d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c6d9:	 800100               	add	byte ptr [rcx], 0
-;; c6dc:	 aa                   	stosb	byte ptr [rdi], al
-;; c6dd:	 800100               	add	byte ptr [rcx], 0
-;; c6e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c6e9:	 800100               	add	byte ptr [rcx], 0
-;; c6ec:	 aa                   	stosb	byte ptr [rdi], al
-;; c6ed:	 800100               	add	byte ptr [rcx], 0
-;; c6f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c6f9:	 800100               	add	byte ptr [rcx], 0
-;; c6fc:	 aa                   	stosb	byte ptr [rdi], al
-;; c6fd:	 800100               	add	byte ptr [rcx], 0
-;; c700:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c709:	 800100               	add	byte ptr [rcx], 0
-;; c70c:	 aa                   	stosb	byte ptr [rdi], al
-;; c70d:	 800100               	add	byte ptr [rcx], 0
-;; c710:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c719:	 800100               	add	byte ptr [rcx], 0
-;; c71c:	 aa                   	stosb	byte ptr [rdi], al
-;; c71d:	 800100               	add	byte ptr [rcx], 0
-;; c720:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c729:	 800100               	add	byte ptr [rcx], 0
-;; c72c:	 aa                   	stosb	byte ptr [rdi], al
-;; c72d:	 800100               	add	byte ptr [rcx], 0
-;; c730:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c739:	 800100               	add	byte ptr [rcx], 0
-;; c73c:	 aa                   	stosb	byte ptr [rdi], al
-;; c73d:	 800100               	add	byte ptr [rcx], 0
-;; c740:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c749:	 800100               	add	byte ptr [rcx], 0
-;; c74c:	 aa                   	stosb	byte ptr [rdi], al
-;; c74d:	 800100               	add	byte ptr [rcx], 0
-;; c750:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c759:	 800100               	add	byte ptr [rcx], 0
-;; c75c:	 aa                   	stosb	byte ptr [rdi], al
-;; c75d:	 800100               	add	byte ptr [rcx], 0
-;; c760:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c769:	 800100               	add	byte ptr [rcx], 0
-;; c76c:	 aa                   	stosb	byte ptr [rdi], al
-;; c76d:	 800100               	add	byte ptr [rcx], 0
-;; c770:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c779:	 800100               	add	byte ptr [rcx], 0
-;; c77c:	 aa                   	stosb	byte ptr [rdi], al
-;; c77d:	 800100               	add	byte ptr [rcx], 0
-;; c780:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c789:	 800100               	add	byte ptr [rcx], 0
-;; c78c:	 aa                   	stosb	byte ptr [rdi], al
-;; c78d:	 800100               	add	byte ptr [rcx], 0
-;; c790:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c799:	 800100               	add	byte ptr [rcx], 0
-;; c79c:	 aa                   	stosb	byte ptr [rdi], al
-;; c79d:	 800100               	add	byte ptr [rcx], 0
-;; c7a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c7a9:	 800100               	add	byte ptr [rcx], 0
-;; c7ac:	 aa                   	stosb	byte ptr [rdi], al
-;; c7ad:	 800100               	add	byte ptr [rcx], 0
-;; c7b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c7b9:	 800100               	add	byte ptr [rcx], 0
-;; c7bc:	 aa                   	stosb	byte ptr [rdi], al
-;; c7bd:	 800100               	add	byte ptr [rcx], 0
-;; c7c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c7c9:	 800100               	add	byte ptr [rcx], 0
-;; c7cc:	 aa                   	stosb	byte ptr [rdi], al
-;; c7cd:	 800100               	add	byte ptr [rcx], 0
-;; c7d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c7d9:	 800100               	add	byte ptr [rcx], 0
-;; c7dc:	 aa                   	stosb	byte ptr [rdi], al
-;; c7dd:	 800100               	add	byte ptr [rcx], 0
-;; c7e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c7e9:	 800100               	add	byte ptr [rcx], 0
-;; c7ec:	 aa                   	stosb	byte ptr [rdi], al
-;; c7ed:	 800100               	add	byte ptr [rcx], 0
-;; c7f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c7f9:	 800100               	add	byte ptr [rcx], 0
-;; c7fc:	 aa                   	stosb	byte ptr [rdi], al
-;; c7fd:	 800100               	add	byte ptr [rcx], 0
-;; c800:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c809:	 800100               	add	byte ptr [rcx], 0
-;; c80c:	 aa                   	stosb	byte ptr [rdi], al
-;; c80d:	 800100               	add	byte ptr [rcx], 0
-;; c810:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c819:	 800100               	add	byte ptr [rcx], 0
-;; c81c:	 aa                   	stosb	byte ptr [rdi], al
-;; c81d:	 800100               	add	byte ptr [rcx], 0
-;; c820:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c829:	 800100               	add	byte ptr [rcx], 0
-;; c82c:	 aa                   	stosb	byte ptr [rdi], al
-;; c82d:	 800100               	add	byte ptr [rcx], 0
-;; c830:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c839:	 800100               	add	byte ptr [rcx], 0
-;; c83c:	 aa                   	stosb	byte ptr [rdi], al
-;; c83d:	 800100               	add	byte ptr [rcx], 0
-;; c840:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c849:	 800100               	add	byte ptr [rcx], 0
-;; c84c:	 aa                   	stosb	byte ptr [rdi], al
-;; c84d:	 800100               	add	byte ptr [rcx], 0
-;; c850:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c859:	 800100               	add	byte ptr [rcx], 0
-;; c85c:	 aa                   	stosb	byte ptr [rdi], al
-;; c85d:	 800100               	add	byte ptr [rcx], 0
-;; c860:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c869:	 800100               	add	byte ptr [rcx], 0
-;; c86c:	 aa                   	stosb	byte ptr [rdi], al
-;; c86d:	 800100               	add	byte ptr [rcx], 0
-;; c870:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c879:	 800100               	add	byte ptr [rcx], 0
-;; c87c:	 aa                   	stosb	byte ptr [rdi], al
-;; c87d:	 800100               	add	byte ptr [rcx], 0
-;; c880:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c889:	 800100               	add	byte ptr [rcx], 0
-;; c88c:	 aa                   	stosb	byte ptr [rdi], al
-;; c88d:	 800100               	add	byte ptr [rcx], 0
-;; c890:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c899:	 800100               	add	byte ptr [rcx], 0
-;; c89c:	 aa                   	stosb	byte ptr [rdi], al
-;; c89d:	 800100               	add	byte ptr [rcx], 0
-;; c8a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c8a9:	 800100               	add	byte ptr [rcx], 0
-;; c8ac:	 aa                   	stosb	byte ptr [rdi], al
-;; c8ad:	 800100               	add	byte ptr [rcx], 0
-;; c8b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c8b9:	 800100               	add	byte ptr [rcx], 0
-;; c8bc:	 aa                   	stosb	byte ptr [rdi], al
-;; c8bd:	 800100               	add	byte ptr [rcx], 0
-;; c8c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c8c9:	 800100               	add	byte ptr [rcx], 0
-;; c8cc:	 aa                   	stosb	byte ptr [rdi], al
-;; c8cd:	 800100               	add	byte ptr [rcx], 0
-;; c8d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c8d9:	 800100               	add	byte ptr [rcx], 0
-;; c8dc:	 aa                   	stosb	byte ptr [rdi], al
-;; c8dd:	 800100               	add	byte ptr [rcx], 0
-;; c8e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c8e9:	 800100               	add	byte ptr [rcx], 0
-;; c8ec:	 aa                   	stosb	byte ptr [rdi], al
-;; c8ed:	 800100               	add	byte ptr [rcx], 0
-;; c8f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c8f9:	 800100               	add	byte ptr [rcx], 0
-;; c8fc:	 aa                   	stosb	byte ptr [rdi], al
-;; c8fd:	 800100               	add	byte ptr [rcx], 0
-;; c900:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c909:	 800100               	add	byte ptr [rcx], 0
-;; c90c:	 aa                   	stosb	byte ptr [rdi], al
-;; c90d:	 800100               	add	byte ptr [rcx], 0
-;; c910:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c919:	 800100               	add	byte ptr [rcx], 0
-;; c91c:	 aa                   	stosb	byte ptr [rdi], al
-;; c91d:	 800100               	add	byte ptr [rcx], 0
-;; c920:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c929:	 800100               	add	byte ptr [rcx], 0
-;; c92c:	 aa                   	stosb	byte ptr [rdi], al
-;; c92d:	 800100               	add	byte ptr [rcx], 0
-;; c930:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c939:	 800100               	add	byte ptr [rcx], 0
-;; c93c:	 aa                   	stosb	byte ptr [rdi], al
-;; c93d:	 800100               	add	byte ptr [rcx], 0
-;; c940:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c949:	 800100               	add	byte ptr [rcx], 0
-;; c94c:	 aa                   	stosb	byte ptr [rdi], al
-;; c94d:	 800100               	add	byte ptr [rcx], 0
-;; c950:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c959:	 800100               	add	byte ptr [rcx], 0
-;; c95c:	 aa                   	stosb	byte ptr [rdi], al
-;; c95d:	 800100               	add	byte ptr [rcx], 0
-;; c960:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c969:	 800100               	add	byte ptr [rcx], 0
-;; c96c:	 aa                   	stosb	byte ptr [rdi], al
-;; c96d:	 800100               	add	byte ptr [rcx], 0
-;; c970:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c979:	 800100               	add	byte ptr [rcx], 0
-;; c97c:	 aa                   	stosb	byte ptr [rdi], al
-;; c97d:	 800100               	add	byte ptr [rcx], 0
-;; c980:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c989:	 800100               	add	byte ptr [rcx], 0
-;; c98c:	 aa                   	stosb	byte ptr [rdi], al
-;; c98d:	 800100               	add	byte ptr [rcx], 0
-;; c990:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c999:	 800100               	add	byte ptr [rcx], 0
-;; c99c:	 aa                   	stosb	byte ptr [rdi], al
-;; c99d:	 800100               	add	byte ptr [rcx], 0
-;; c9a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c9a9:	 800100               	add	byte ptr [rcx], 0
-;; c9ac:	 aa                   	stosb	byte ptr [rdi], al
-;; c9ad:	 800100               	add	byte ptr [rcx], 0
-;; c9b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c9b9:	 800100               	add	byte ptr [rcx], 0
-;; c9bc:	 aa                   	stosb	byte ptr [rdi], al
-;; c9bd:	 800100               	add	byte ptr [rcx], 0
-;; c9c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c9c9:	 800100               	add	byte ptr [rcx], 0
-;; c9cc:	 aa                   	stosb	byte ptr [rdi], al
-;; c9cd:	 800100               	add	byte ptr [rcx], 0
-;; c9d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c9d9:	 800100               	add	byte ptr [rcx], 0
-;; c9dc:	 aa                   	stosb	byte ptr [rdi], al
-;; c9dd:	 800100               	add	byte ptr [rcx], 0
-;; c9e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c9e9:	 800100               	add	byte ptr [rcx], 0
-;; c9ec:	 aa                   	stosb	byte ptr [rdi], al
-;; c9ed:	 800100               	add	byte ptr [rcx], 0
-;; c9f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; c9f9:	 800100               	add	byte ptr [rcx], 0
-;; c9fc:	 aa                   	stosb	byte ptr [rdi], al
-;; c9fd:	 800100               	add	byte ptr [rcx], 0
-;; ca00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ca09:	 800100               	add	byte ptr [rcx], 0
-;; ca0c:	 aa                   	stosb	byte ptr [rdi], al
-;; ca0d:	 800100               	add	byte ptr [rcx], 0
-;; ca10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ca19:	 800100               	add	byte ptr [rcx], 0
-;; ca1c:	 aa                   	stosb	byte ptr [rdi], al
-;; ca1d:	 800100               	add	byte ptr [rcx], 0
-;; ca20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ca29:	 800100               	add	byte ptr [rcx], 0
-;; ca2c:	 aa                   	stosb	byte ptr [rdi], al
-;; ca2d:	 800100               	add	byte ptr [rcx], 0
-;; ca30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ca39:	 800100               	add	byte ptr [rcx], 0
-;; ca3c:	 aa                   	stosb	byte ptr [rdi], al
-;; ca3d:	 800100               	add	byte ptr [rcx], 0
-;; ca40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ca49:	 800100               	add	byte ptr [rcx], 0
-;; ca4c:	 aa                   	stosb	byte ptr [rdi], al
-;; ca4d:	 800100               	add	byte ptr [rcx], 0
-;; ca50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ca59:	 800100               	add	byte ptr [rcx], 0
-;; ca5c:	 aa                   	stosb	byte ptr [rdi], al
-;; ca5d:	 800100               	add	byte ptr [rcx], 0
-;; ca60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ca69:	 800100               	add	byte ptr [rcx], 0
-;; ca6c:	 aa                   	stosb	byte ptr [rdi], al
-;; ca6d:	 800100               	add	byte ptr [rcx], 0
-;; ca70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ca79:	 800100               	add	byte ptr [rcx], 0
-;; ca7c:	 aa                   	stosb	byte ptr [rdi], al
-;; ca7d:	 800100               	add	byte ptr [rcx], 0
-;; ca80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ca89:	 800100               	add	byte ptr [rcx], 0
-;; ca8c:	 aa                   	stosb	byte ptr [rdi], al
-;; ca8d:	 800100               	add	byte ptr [rcx], 0
-;; ca90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ca99:	 800100               	add	byte ptr [rcx], 0
-;; ca9c:	 aa                   	stosb	byte ptr [rdi], al
-;; ca9d:	 800100               	add	byte ptr [rcx], 0
-;; caa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; caa9:	 800100               	add	byte ptr [rcx], 0
-;; caac:	 aa                   	stosb	byte ptr [rdi], al
-;; caad:	 800100               	add	byte ptr [rcx], 0
-;; cab0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cab9:	 800100               	add	byte ptr [rcx], 0
-;; cabc:	 aa                   	stosb	byte ptr [rdi], al
-;; cabd:	 800100               	add	byte ptr [rcx], 0
-;; cac0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cac9:	 800100               	add	byte ptr [rcx], 0
-;; cacc:	 aa                   	stosb	byte ptr [rdi], al
-;; cacd:	 800100               	add	byte ptr [rcx], 0
-;; cad0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cad9:	 800100               	add	byte ptr [rcx], 0
-;; cadc:	 aa                   	stosb	byte ptr [rdi], al
-;; cadd:	 800100               	add	byte ptr [rcx], 0
-;; cae0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cae9:	 800100               	add	byte ptr [rcx], 0
-;; caec:	 aa                   	stosb	byte ptr [rdi], al
-;; caed:	 800100               	add	byte ptr [rcx], 0
-;; caf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; caf9:	 800100               	add	byte ptr [rcx], 0
-;; cafc:	 aa                   	stosb	byte ptr [rdi], al
-;; cafd:	 800100               	add	byte ptr [rcx], 0
-;; cb00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cb09:	 800100               	add	byte ptr [rcx], 0
-;; cb0c:	 aa                   	stosb	byte ptr [rdi], al
-;; cb0d:	 800100               	add	byte ptr [rcx], 0
-;; cb10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cb19:	 800100               	add	byte ptr [rcx], 0
-;; cb1c:	 aa                   	stosb	byte ptr [rdi], al
-;; cb1d:	 800100               	add	byte ptr [rcx], 0
-;; cb20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cb29:	 800100               	add	byte ptr [rcx], 0
-;; cb2c:	 aa                   	stosb	byte ptr [rdi], al
-;; cb2d:	 800100               	add	byte ptr [rcx], 0
-;; cb30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cb39:	 800100               	add	byte ptr [rcx], 0
-;; cb3c:	 aa                   	stosb	byte ptr [rdi], al
-;; cb3d:	 800100               	add	byte ptr [rcx], 0
-;; cb40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cb49:	 800100               	add	byte ptr [rcx], 0
-;; cb4c:	 aa                   	stosb	byte ptr [rdi], al
-;; cb4d:	 800100               	add	byte ptr [rcx], 0
-;; cb50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cb59:	 800100               	add	byte ptr [rcx], 0
-;; cb5c:	 aa                   	stosb	byte ptr [rdi], al
-;; cb5d:	 800100               	add	byte ptr [rcx], 0
-;; cb60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cb69:	 800100               	add	byte ptr [rcx], 0
-;; cb6c:	 aa                   	stosb	byte ptr [rdi], al
-;; cb6d:	 800100               	add	byte ptr [rcx], 0
-;; cb70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cb79:	 800100               	add	byte ptr [rcx], 0
-;; cb7c:	 aa                   	stosb	byte ptr [rdi], al
-;; cb7d:	 800100               	add	byte ptr [rcx], 0
-;; cb80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cb89:	 800100               	add	byte ptr [rcx], 0
-;; cb8c:	 aa                   	stosb	byte ptr [rdi], al
-;; cb8d:	 800100               	add	byte ptr [rcx], 0
-;; cb90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cb99:	 800100               	add	byte ptr [rcx], 0
-;; cb9c:	 aa                   	stosb	byte ptr [rdi], al
-;; cb9d:	 800100               	add	byte ptr [rcx], 0
-;; cba0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cba9:	 800100               	add	byte ptr [rcx], 0
-;; cbac:	 aa                   	stosb	byte ptr [rdi], al
-;; cbad:	 800100               	add	byte ptr [rcx], 0
-;; cbb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cbb9:	 800100               	add	byte ptr [rcx], 0
-;; cbbc:	 aa                   	stosb	byte ptr [rdi], al
-;; cbbd:	 800100               	add	byte ptr [rcx], 0
-;; cbc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cbc9:	 800100               	add	byte ptr [rcx], 0
-;; cbcc:	 aa                   	stosb	byte ptr [rdi], al
-;; cbcd:	 800100               	add	byte ptr [rcx], 0
-;; cbd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cbd9:	 800100               	add	byte ptr [rcx], 0
-;; cbdc:	 aa                   	stosb	byte ptr [rdi], al
-;; cbdd:	 800100               	add	byte ptr [rcx], 0
-;; cbe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cbe9:	 800100               	add	byte ptr [rcx], 0
-;; cbec:	 aa                   	stosb	byte ptr [rdi], al
-;; cbed:	 800100               	add	byte ptr [rcx], 0
-;; cbf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cbf9:	 800100               	add	byte ptr [rcx], 0
-;; cbfc:	 aa                   	stosb	byte ptr [rdi], al
-;; cbfd:	 800100               	add	byte ptr [rcx], 0
-;; cc00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cc09:	 800100               	add	byte ptr [rcx], 0
-;; cc0c:	 aa                   	stosb	byte ptr [rdi], al
-;; cc0d:	 800100               	add	byte ptr [rcx], 0
-;; cc10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cc19:	 800100               	add	byte ptr [rcx], 0
-;; cc1c:	 aa                   	stosb	byte ptr [rdi], al
-;; cc1d:	 800100               	add	byte ptr [rcx], 0
-;; cc20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cc29:	 800100               	add	byte ptr [rcx], 0
-;; cc2c:	 aa                   	stosb	byte ptr [rdi], al
-;; cc2d:	 800100               	add	byte ptr [rcx], 0
-;; cc30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cc39:	 800100               	add	byte ptr [rcx], 0
-;; cc3c:	 aa                   	stosb	byte ptr [rdi], al
-;; cc3d:	 800100               	add	byte ptr [rcx], 0
-;; cc40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cc49:	 800100               	add	byte ptr [rcx], 0
-;; cc4c:	 aa                   	stosb	byte ptr [rdi], al
-;; cc4d:	 800100               	add	byte ptr [rcx], 0
-;; cc50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cc59:	 800100               	add	byte ptr [rcx], 0
-;; cc5c:	 aa                   	stosb	byte ptr [rdi], al
-;; cc5d:	 800100               	add	byte ptr [rcx], 0
-;; cc60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cc69:	 800100               	add	byte ptr [rcx], 0
-;; cc6c:	 aa                   	stosb	byte ptr [rdi], al
-;; cc6d:	 800100               	add	byte ptr [rcx], 0
-;; cc70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cc79:	 800100               	add	byte ptr [rcx], 0
-;; cc7c:	 aa                   	stosb	byte ptr [rdi], al
-;; cc7d:	 800100               	add	byte ptr [rcx], 0
-;; cc80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cc89:	 800100               	add	byte ptr [rcx], 0
-;; cc8c:	 aa                   	stosb	byte ptr [rdi], al
-;; cc8d:	 800100               	add	byte ptr [rcx], 0
-;; cc90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cc99:	 800100               	add	byte ptr [rcx], 0
-;; cc9c:	 aa                   	stosb	byte ptr [rdi], al
-;; cc9d:	 800100               	add	byte ptr [rcx], 0
-;; cca0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cca9:	 800100               	add	byte ptr [rcx], 0
-;; ccac:	 aa                   	stosb	byte ptr [rdi], al
-;; ccad:	 800100               	add	byte ptr [rcx], 0
-;; ccb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ccb9:	 800100               	add	byte ptr [rcx], 0
-;; ccbc:	 aa                   	stosb	byte ptr [rdi], al
-;; ccbd:	 800100               	add	byte ptr [rcx], 0
-;; ccc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ccc9:	 800100               	add	byte ptr [rcx], 0
-;; cccc:	 aa                   	stosb	byte ptr [rdi], al
-;; cccd:	 800100               	add	byte ptr [rcx], 0
-;; ccd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ccd9:	 800100               	add	byte ptr [rcx], 0
-;; ccdc:	 aa                   	stosb	byte ptr [rdi], al
-;; ccdd:	 800100               	add	byte ptr [rcx], 0
-;; cce0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cce9:	 800100               	add	byte ptr [rcx], 0
-;; ccec:	 aa                   	stosb	byte ptr [rdi], al
-;; cced:	 800100               	add	byte ptr [rcx], 0
-;; ccf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ccf9:	 800100               	add	byte ptr [rcx], 0
-;; ccfc:	 aa                   	stosb	byte ptr [rdi], al
-;; ccfd:	 800100               	add	byte ptr [rcx], 0
-;; cd00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cd09:	 800100               	add	byte ptr [rcx], 0
-;; cd0c:	 aa                   	stosb	byte ptr [rdi], al
-;; cd0d:	 800100               	add	byte ptr [rcx], 0
-;; cd10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cd19:	 800100               	add	byte ptr [rcx], 0
-;; cd1c:	 aa                   	stosb	byte ptr [rdi], al
-;; cd1d:	 800100               	add	byte ptr [rcx], 0
-;; cd20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cd29:	 800100               	add	byte ptr [rcx], 0
-;; cd2c:	 aa                   	stosb	byte ptr [rdi], al
-;; cd2d:	 800100               	add	byte ptr [rcx], 0
-;; cd30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cd39:	 800100               	add	byte ptr [rcx], 0
-;; cd3c:	 aa                   	stosb	byte ptr [rdi], al
-;; cd3d:	 800100               	add	byte ptr [rcx], 0
-;; cd40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cd49:	 800100               	add	byte ptr [rcx], 0
-;; cd4c:	 aa                   	stosb	byte ptr [rdi], al
-;; cd4d:	 800100               	add	byte ptr [rcx], 0
-;; cd50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cd59:	 800100               	add	byte ptr [rcx], 0
-;; cd5c:	 aa                   	stosb	byte ptr [rdi], al
-;; cd5d:	 800100               	add	byte ptr [rcx], 0
-;; cd60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cd69:	 800100               	add	byte ptr [rcx], 0
-;; cd6c:	 aa                   	stosb	byte ptr [rdi], al
-;; cd6d:	 800100               	add	byte ptr [rcx], 0
-;; cd70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cd79:	 800100               	add	byte ptr [rcx], 0
-;; cd7c:	 aa                   	stosb	byte ptr [rdi], al
-;; cd7d:	 800100               	add	byte ptr [rcx], 0
-;; cd80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cd89:	 800100               	add	byte ptr [rcx], 0
-;; cd8c:	 aa                   	stosb	byte ptr [rdi], al
-;; cd8d:	 800100               	add	byte ptr [rcx], 0
-;; cd90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cd99:	 800100               	add	byte ptr [rcx], 0
-;; cd9c:	 aa                   	stosb	byte ptr [rdi], al
-;; cd9d:	 800100               	add	byte ptr [rcx], 0
-;; cda0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cda9:	 800100               	add	byte ptr [rcx], 0
-;; cdac:	 aa                   	stosb	byte ptr [rdi], al
-;; cdad:	 800100               	add	byte ptr [rcx], 0
-;; cdb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cdb9:	 800100               	add	byte ptr [rcx], 0
-;; cdbc:	 aa                   	stosb	byte ptr [rdi], al
-;; cdbd:	 800100               	add	byte ptr [rcx], 0
-;; cdc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cdc9:	 800100               	add	byte ptr [rcx], 0
-;; cdcc:	 aa                   	stosb	byte ptr [rdi], al
-;; cdcd:	 800100               	add	byte ptr [rcx], 0
-;; cdd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cdd9:	 800100               	add	byte ptr [rcx], 0
-;; cddc:	 aa                   	stosb	byte ptr [rdi], al
-;; cddd:	 800100               	add	byte ptr [rcx], 0
-;; cde0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cde9:	 800100               	add	byte ptr [rcx], 0
-;; cdec:	 aa                   	stosb	byte ptr [rdi], al
-;; cded:	 800100               	add	byte ptr [rcx], 0
-;; cdf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cdf9:	 800100               	add	byte ptr [rcx], 0
-;; cdfc:	 aa                   	stosb	byte ptr [rdi], al
-;; cdfd:	 800100               	add	byte ptr [rcx], 0
-;; ce00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ce09:	 800100               	add	byte ptr [rcx], 0
-;; ce0c:	 aa                   	stosb	byte ptr [rdi], al
-;; ce0d:	 800100               	add	byte ptr [rcx], 0
-;; ce10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ce19:	 800100               	add	byte ptr [rcx], 0
-;; ce1c:	 aa                   	stosb	byte ptr [rdi], al
-;; ce1d:	 800100               	add	byte ptr [rcx], 0
-;; ce20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ce29:	 800100               	add	byte ptr [rcx], 0
-;; ce2c:	 aa                   	stosb	byte ptr [rdi], al
-;; ce2d:	 800100               	add	byte ptr [rcx], 0
-;; ce30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ce39:	 800100               	add	byte ptr [rcx], 0
-;; ce3c:	 aa                   	stosb	byte ptr [rdi], al
-;; ce3d:	 800100               	add	byte ptr [rcx], 0
-;; ce40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ce49:	 800100               	add	byte ptr [rcx], 0
-;; ce4c:	 aa                   	stosb	byte ptr [rdi], al
-;; ce4d:	 800100               	add	byte ptr [rcx], 0
-;; ce50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ce59:	 800100               	add	byte ptr [rcx], 0
-;; ce5c:	 aa                   	stosb	byte ptr [rdi], al
-;; ce5d:	 800100               	add	byte ptr [rcx], 0
-;; ce60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ce69:	 800100               	add	byte ptr [rcx], 0
-;; ce6c:	 aa                   	stosb	byte ptr [rdi], al
-;; ce6d:	 800100               	add	byte ptr [rcx], 0
-;; ce70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ce79:	 800100               	add	byte ptr [rcx], 0
-;; ce7c:	 aa                   	stosb	byte ptr [rdi], al
-;; ce7d:	 800100               	add	byte ptr [rcx], 0
-;; ce80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ce89:	 800100               	add	byte ptr [rcx], 0
-;; ce8c:	 aa                   	stosb	byte ptr [rdi], al
-;; ce8d:	 800100               	add	byte ptr [rcx], 0
-;; ce90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ce99:	 800100               	add	byte ptr [rcx], 0
-;; ce9c:	 aa                   	stosb	byte ptr [rdi], al
-;; ce9d:	 800100               	add	byte ptr [rcx], 0
-;; cea0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cea9:	 800100               	add	byte ptr [rcx], 0
-;; ceac:	 aa                   	stosb	byte ptr [rdi], al
-;; cead:	 800100               	add	byte ptr [rcx], 0
-;; ceb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ceb9:	 800100               	add	byte ptr [rcx], 0
-;; cebc:	 aa                   	stosb	byte ptr [rdi], al
-;; cebd:	 800100               	add	byte ptr [rcx], 0
-;; cec0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cec9:	 800100               	add	byte ptr [rcx], 0
-;; cecc:	 aa                   	stosb	byte ptr [rdi], al
-;; cecd:	 800100               	add	byte ptr [rcx], 0
-;; ced0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ced9:	 800100               	add	byte ptr [rcx], 0
-;; cedc:	 aa                   	stosb	byte ptr [rdi], al
-;; cedd:	 800100               	add	byte ptr [rcx], 0
-;; cee0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cee9:	 800100               	add	byte ptr [rcx], 0
-;; ceec:	 aa                   	stosb	byte ptr [rdi], al
-;; ceed:	 800100               	add	byte ptr [rcx], 0
-;; cef0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cef9:	 800100               	add	byte ptr [rcx], 0
-;; cefc:	 aa                   	stosb	byte ptr [rdi], al
-;; cefd:	 800100               	add	byte ptr [rcx], 0
-;; cf00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cf09:	 800100               	add	byte ptr [rcx], 0
-;; cf0c:	 aa                   	stosb	byte ptr [rdi], al
-;; cf0d:	 800100               	add	byte ptr [rcx], 0
-;; cf10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cf19:	 800100               	add	byte ptr [rcx], 0
-;; cf1c:	 aa                   	stosb	byte ptr [rdi], al
-;; cf1d:	 800100               	add	byte ptr [rcx], 0
-;; cf20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cf29:	 800100               	add	byte ptr [rcx], 0
-;; cf2c:	 aa                   	stosb	byte ptr [rdi], al
-;; cf2d:	 800100               	add	byte ptr [rcx], 0
-;; cf30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cf39:	 800100               	add	byte ptr [rcx], 0
-;; cf3c:	 aa                   	stosb	byte ptr [rdi], al
-;; cf3d:	 800100               	add	byte ptr [rcx], 0
-;; cf40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cf49:	 800100               	add	byte ptr [rcx], 0
-;; cf4c:	 aa                   	stosb	byte ptr [rdi], al
-;; cf4d:	 800100               	add	byte ptr [rcx], 0
-;; cf50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cf59:	 800100               	add	byte ptr [rcx], 0
-;; cf5c:	 aa                   	stosb	byte ptr [rdi], al
-;; cf5d:	 800100               	add	byte ptr [rcx], 0
-;; cf60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cf69:	 800100               	add	byte ptr [rcx], 0
-;; cf6c:	 aa                   	stosb	byte ptr [rdi], al
-;; cf6d:	 800100               	add	byte ptr [rcx], 0
-;; cf70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cf79:	 800100               	add	byte ptr [rcx], 0
-;; cf7c:	 aa                   	stosb	byte ptr [rdi], al
-;; cf7d:	 800100               	add	byte ptr [rcx], 0
-;; cf80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cf89:	 800100               	add	byte ptr [rcx], 0
-;; cf8c:	 aa                   	stosb	byte ptr [rdi], al
-;; cf8d:	 800100               	add	byte ptr [rcx], 0
-;; cf90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cf99:	 800100               	add	byte ptr [rcx], 0
-;; cf9c:	 aa                   	stosb	byte ptr [rdi], al
-;; cf9d:	 800100               	add	byte ptr [rcx], 0
-;; cfa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cfa9:	 800100               	add	byte ptr [rcx], 0
-;; cfac:	 aa                   	stosb	byte ptr [rdi], al
-;; cfad:	 800100               	add	byte ptr [rcx], 0
-;; cfb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cfb9:	 800100               	add	byte ptr [rcx], 0
-;; cfbc:	 aa                   	stosb	byte ptr [rdi], al
-;; cfbd:	 800100               	add	byte ptr [rcx], 0
-;; cfc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cfc9:	 800100               	add	byte ptr [rcx], 0
-;; cfcc:	 aa                   	stosb	byte ptr [rdi], al
-;; cfcd:	 800100               	add	byte ptr [rcx], 0
-;; cfd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cfd9:	 800100               	add	byte ptr [rcx], 0
-;; cfdc:	 aa                   	stosb	byte ptr [rdi], al
-;; cfdd:	 800100               	add	byte ptr [rcx], 0
-;; cfe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cfe9:	 800100               	add	byte ptr [rcx], 0
-;; cfec:	 aa                   	stosb	byte ptr [rdi], al
-;; cfed:	 800100               	add	byte ptr [rcx], 0
-;; cff0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; cff9:	 800100               	add	byte ptr [rcx], 0
-;; cffc:	 aa                   	stosb	byte ptr [rdi], al
-;; cffd:	 800100               	add	byte ptr [rcx], 0
-;; d000:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d009:	 800100               	add	byte ptr [rcx], 0
-;; d00c:	 aa                   	stosb	byte ptr [rdi], al
-;; d00d:	 800100               	add	byte ptr [rcx], 0
-;; d010:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d019:	 800100               	add	byte ptr [rcx], 0
-;; d01c:	 aa                   	stosb	byte ptr [rdi], al
-;; d01d:	 800100               	add	byte ptr [rcx], 0
-;; d020:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d029:	 800100               	add	byte ptr [rcx], 0
-;; d02c:	 aa                   	stosb	byte ptr [rdi], al
-;; d02d:	 800100               	add	byte ptr [rcx], 0
-;; d030:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d039:	 800100               	add	byte ptr [rcx], 0
-;; d03c:	 aa                   	stosb	byte ptr [rdi], al
-;; d03d:	 800100               	add	byte ptr [rcx], 0
-;; d040:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d049:	 800100               	add	byte ptr [rcx], 0
-;; d04c:	 aa                   	stosb	byte ptr [rdi], al
-;; d04d:	 800100               	add	byte ptr [rcx], 0
-;; d050:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d059:	 800100               	add	byte ptr [rcx], 0
-;; d05c:	 aa                   	stosb	byte ptr [rdi], al
-;; d05d:	 800100               	add	byte ptr [rcx], 0
-;; d060:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d069:	 800100               	add	byte ptr [rcx], 0
-;; d06c:	 aa                   	stosb	byte ptr [rdi], al
-;; d06d:	 800100               	add	byte ptr [rcx], 0
-;; d070:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d079:	 800100               	add	byte ptr [rcx], 0
-;; d07c:	 aa                   	stosb	byte ptr [rdi], al
-;; d07d:	 800100               	add	byte ptr [rcx], 0
-;; d080:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d089:	 800100               	add	byte ptr [rcx], 0
-;; d08c:	 aa                   	stosb	byte ptr [rdi], al
-;; d08d:	 800100               	add	byte ptr [rcx], 0
-;; d090:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d099:	 800100               	add	byte ptr [rcx], 0
-;; d09c:	 aa                   	stosb	byte ptr [rdi], al
-;; d09d:	 800100               	add	byte ptr [rcx], 0
-;; d0a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d0a9:	 800100               	add	byte ptr [rcx], 0
-;; d0ac:	 aa                   	stosb	byte ptr [rdi], al
-;; d0ad:	 800100               	add	byte ptr [rcx], 0
-;; d0b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d0b9:	 800100               	add	byte ptr [rcx], 0
-;; d0bc:	 aa                   	stosb	byte ptr [rdi], al
-;; d0bd:	 800100               	add	byte ptr [rcx], 0
-;; d0c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d0c9:	 800100               	add	byte ptr [rcx], 0
-;; d0cc:	 aa                   	stosb	byte ptr [rdi], al
-;; d0cd:	 800100               	add	byte ptr [rcx], 0
-;; d0d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d0d9:	 800100               	add	byte ptr [rcx], 0
-;; d0dc:	 aa                   	stosb	byte ptr [rdi], al
-;; d0dd:	 800100               	add	byte ptr [rcx], 0
-;; d0e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d0e9:	 800100               	add	byte ptr [rcx], 0
-;; d0ec:	 aa                   	stosb	byte ptr [rdi], al
-;; d0ed:	 800100               	add	byte ptr [rcx], 0
-;; d0f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d0f9:	 800100               	add	byte ptr [rcx], 0
-;; d0fc:	 aa                   	stosb	byte ptr [rdi], al
-;; d0fd:	 800100               	add	byte ptr [rcx], 0
-;; d100:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d109:	 800100               	add	byte ptr [rcx], 0
-;; d10c:	 aa                   	stosb	byte ptr [rdi], al
-;; d10d:	 800100               	add	byte ptr [rcx], 0
-;; d110:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d119:	 800100               	add	byte ptr [rcx], 0
-;; d11c:	 aa                   	stosb	byte ptr [rdi], al
-;; d11d:	 800100               	add	byte ptr [rcx], 0
-;; d120:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d129:	 800100               	add	byte ptr [rcx], 0
-;; d12c:	 aa                   	stosb	byte ptr [rdi], al
-;; d12d:	 800100               	add	byte ptr [rcx], 0
-;; d130:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d139:	 800100               	add	byte ptr [rcx], 0
-;; d13c:	 aa                   	stosb	byte ptr [rdi], al
-;; d13d:	 800100               	add	byte ptr [rcx], 0
-;; d140:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d149:	 800100               	add	byte ptr [rcx], 0
-;; d14c:	 aa                   	stosb	byte ptr [rdi], al
-;; d14d:	 800100               	add	byte ptr [rcx], 0
-;; d150:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d159:	 800100               	add	byte ptr [rcx], 0
-;; d15c:	 aa                   	stosb	byte ptr [rdi], al
-;; d15d:	 800100               	add	byte ptr [rcx], 0
-;; d160:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d169:	 800100               	add	byte ptr [rcx], 0
-;; d16c:	 aa                   	stosb	byte ptr [rdi], al
-;; d16d:	 800100               	add	byte ptr [rcx], 0
-;; d170:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d179:	 800100               	add	byte ptr [rcx], 0
-;; d17c:	 aa                   	stosb	byte ptr [rdi], al
-;; d17d:	 800100               	add	byte ptr [rcx], 0
-;; d180:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d189:	 800100               	add	byte ptr [rcx], 0
-;; d18c:	 aa                   	stosb	byte ptr [rdi], al
-;; d18d:	 800100               	add	byte ptr [rcx], 0
-;; d190:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d199:	 800100               	add	byte ptr [rcx], 0
-;; d19c:	 aa                   	stosb	byte ptr [rdi], al
-;; d19d:	 800100               	add	byte ptr [rcx], 0
-;; d1a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d1a9:	 800100               	add	byte ptr [rcx], 0
-;; d1ac:	 aa                   	stosb	byte ptr [rdi], al
-;; d1ad:	 800100               	add	byte ptr [rcx], 0
-;; d1b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d1b9:	 800100               	add	byte ptr [rcx], 0
-;; d1bc:	 aa                   	stosb	byte ptr [rdi], al
-;; d1bd:	 800100               	add	byte ptr [rcx], 0
-;; d1c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d1c9:	 800100               	add	byte ptr [rcx], 0
-;; d1cc:	 aa                   	stosb	byte ptr [rdi], al
-;; d1cd:	 800100               	add	byte ptr [rcx], 0
-;; d1d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d1d9:	 800100               	add	byte ptr [rcx], 0
-;; d1dc:	 aa                   	stosb	byte ptr [rdi], al
-;; d1dd:	 800100               	add	byte ptr [rcx], 0
-;; d1e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d1e9:	 800100               	add	byte ptr [rcx], 0
-;; d1ec:	 aa                   	stosb	byte ptr [rdi], al
-;; d1ed:	 800100               	add	byte ptr [rcx], 0
-;; d1f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d1f9:	 800100               	add	byte ptr [rcx], 0
-;; d1fc:	 aa                   	stosb	byte ptr [rdi], al
-;; d1fd:	 800100               	add	byte ptr [rcx], 0
-;; d200:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d209:	 800100               	add	byte ptr [rcx], 0
-;; d20c:	 aa                   	stosb	byte ptr [rdi], al
-;; d20d:	 800100               	add	byte ptr [rcx], 0
-;; d210:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d219:	 800100               	add	byte ptr [rcx], 0
-;; d21c:	 aa                   	stosb	byte ptr [rdi], al
-;; d21d:	 800100               	add	byte ptr [rcx], 0
-;; d220:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d229:	 800100               	add	byte ptr [rcx], 0
-;; d22c:	 aa                   	stosb	byte ptr [rdi], al
-;; d22d:	 800100               	add	byte ptr [rcx], 0
-;; d230:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d239:	 800100               	add	byte ptr [rcx], 0
-;; d23c:	 aa                   	stosb	byte ptr [rdi], al
-;; d23d:	 800100               	add	byte ptr [rcx], 0
-;; d240:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d249:	 800100               	add	byte ptr [rcx], 0
-;; d24c:	 aa                   	stosb	byte ptr [rdi], al
-;; d24d:	 800100               	add	byte ptr [rcx], 0
-;; d250:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d259:	 800100               	add	byte ptr [rcx], 0
-;; d25c:	 aa                   	stosb	byte ptr [rdi], al
-;; d25d:	 800100               	add	byte ptr [rcx], 0
-;; d260:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d269:	 800100               	add	byte ptr [rcx], 0
-;; d26c:	 aa                   	stosb	byte ptr [rdi], al
-;; d26d:	 800100               	add	byte ptr [rcx], 0
-;; d270:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d279:	 800100               	add	byte ptr [rcx], 0
-;; d27c:	 aa                   	stosb	byte ptr [rdi], al
-;; d27d:	 800100               	add	byte ptr [rcx], 0
-;; d280:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d289:	 800100               	add	byte ptr [rcx], 0
-;; d28c:	 aa                   	stosb	byte ptr [rdi], al
-;; d28d:	 800100               	add	byte ptr [rcx], 0
-;; d290:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d299:	 800100               	add	byte ptr [rcx], 0
-;; d29c:	 aa                   	stosb	byte ptr [rdi], al
-;; d29d:	 800100               	add	byte ptr [rcx], 0
-;; d2a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d2a9:	 800100               	add	byte ptr [rcx], 0
-;; d2ac:	 aa                   	stosb	byte ptr [rdi], al
-;; d2ad:	 800100               	add	byte ptr [rcx], 0
-;; d2b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d2b9:	 800100               	add	byte ptr [rcx], 0
-;; d2bc:	 aa                   	stosb	byte ptr [rdi], al
-;; d2bd:	 800100               	add	byte ptr [rcx], 0
-;; d2c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d2c9:	 800100               	add	byte ptr [rcx], 0
-;; d2cc:	 aa                   	stosb	byte ptr [rdi], al
-;; d2cd:	 800100               	add	byte ptr [rcx], 0
-;; d2d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d2d9:	 800100               	add	byte ptr [rcx], 0
-;; d2dc:	 aa                   	stosb	byte ptr [rdi], al
-;; d2dd:	 800100               	add	byte ptr [rcx], 0
-;; d2e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d2e9:	 800100               	add	byte ptr [rcx], 0
-;; d2ec:	 aa                   	stosb	byte ptr [rdi], al
-;; d2ed:	 800100               	add	byte ptr [rcx], 0
-;; d2f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d2f9:	 800100               	add	byte ptr [rcx], 0
-;; d2fc:	 aa                   	stosb	byte ptr [rdi], al
-;; d2fd:	 800100               	add	byte ptr [rcx], 0
-;; d300:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d309:	 800100               	add	byte ptr [rcx], 0
-;; d30c:	 aa                   	stosb	byte ptr [rdi], al
-;; d30d:	 800100               	add	byte ptr [rcx], 0
-;; d310:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d319:	 800100               	add	byte ptr [rcx], 0
-;; d31c:	 aa                   	stosb	byte ptr [rdi], al
-;; d31d:	 800100               	add	byte ptr [rcx], 0
-;; d320:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d329:	 800100               	add	byte ptr [rcx], 0
-;; d32c:	 aa                   	stosb	byte ptr [rdi], al
-;; d32d:	 800100               	add	byte ptr [rcx], 0
-;; d330:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d339:	 800100               	add	byte ptr [rcx], 0
-;; d33c:	 aa                   	stosb	byte ptr [rdi], al
-;; d33d:	 800100               	add	byte ptr [rcx], 0
-;; d340:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d349:	 800100               	add	byte ptr [rcx], 0
-;; d34c:	 aa                   	stosb	byte ptr [rdi], al
-;; d34d:	 800100               	add	byte ptr [rcx], 0
-;; d350:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d359:	 800100               	add	byte ptr [rcx], 0
-;; d35c:	 aa                   	stosb	byte ptr [rdi], al
-;; d35d:	 800100               	add	byte ptr [rcx], 0
-;; d360:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d369:	 800100               	add	byte ptr [rcx], 0
-;; d36c:	 aa                   	stosb	byte ptr [rdi], al
-;; d36d:	 800100               	add	byte ptr [rcx], 0
-;; d370:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d379:	 800100               	add	byte ptr [rcx], 0
-;; d37c:	 aa                   	stosb	byte ptr [rdi], al
-;; d37d:	 800100               	add	byte ptr [rcx], 0
-;; d380:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d389:	 800100               	add	byte ptr [rcx], 0
-;; d38c:	 aa                   	stosb	byte ptr [rdi], al
-;; d38d:	 800100               	add	byte ptr [rcx], 0
-;; d390:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d399:	 800100               	add	byte ptr [rcx], 0
-;; d39c:	 aa                   	stosb	byte ptr [rdi], al
-;; d39d:	 800100               	add	byte ptr [rcx], 0
-;; d3a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d3a9:	 800100               	add	byte ptr [rcx], 0
-;; d3ac:	 aa                   	stosb	byte ptr [rdi], al
-;; d3ad:	 800100               	add	byte ptr [rcx], 0
-;; d3b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d3b9:	 800100               	add	byte ptr [rcx], 0
-;; d3bc:	 aa                   	stosb	byte ptr [rdi], al
-;; d3bd:	 800100               	add	byte ptr [rcx], 0
-;; d3c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d3c9:	 800100               	add	byte ptr [rcx], 0
-;; d3cc:	 aa                   	stosb	byte ptr [rdi], al
-;; d3cd:	 800100               	add	byte ptr [rcx], 0
-;; d3d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d3d9:	 800100               	add	byte ptr [rcx], 0
-;; d3dc:	 aa                   	stosb	byte ptr [rdi], al
-;; d3dd:	 800100               	add	byte ptr [rcx], 0
-;; d3e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d3e9:	 800100               	add	byte ptr [rcx], 0
-;; d3ec:	 aa                   	stosb	byte ptr [rdi], al
-;; d3ed:	 800100               	add	byte ptr [rcx], 0
-;; d3f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d3f9:	 800100               	add	byte ptr [rcx], 0
-;; d3fc:	 aa                   	stosb	byte ptr [rdi], al
-;; d3fd:	 800100               	add	byte ptr [rcx], 0
-;; d400:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d409:	 800100               	add	byte ptr [rcx], 0
-;; d40c:	 aa                   	stosb	byte ptr [rdi], al
-;; d40d:	 800100               	add	byte ptr [rcx], 0
-;; d410:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d419:	 800100               	add	byte ptr [rcx], 0
-;; d41c:	 aa                   	stosb	byte ptr [rdi], al
-;; d41d:	 800100               	add	byte ptr [rcx], 0
-;; d420:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d429:	 800100               	add	byte ptr [rcx], 0
-;; d42c:	 aa                   	stosb	byte ptr [rdi], al
-;; d42d:	 800100               	add	byte ptr [rcx], 0
-;; d430:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d439:	 800100               	add	byte ptr [rcx], 0
-;; d43c:	 aa                   	stosb	byte ptr [rdi], al
-;; d43d:	 800100               	add	byte ptr [rcx], 0
-;; d440:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d449:	 800100               	add	byte ptr [rcx], 0
-;; d44c:	 aa                   	stosb	byte ptr [rdi], al
-;; d44d:	 800100               	add	byte ptr [rcx], 0
-;; d450:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d459:	 800100               	add	byte ptr [rcx], 0
-;; d45c:	 aa                   	stosb	byte ptr [rdi], al
-;; d45d:	 800100               	add	byte ptr [rcx], 0
-;; d460:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d469:	 800100               	add	byte ptr [rcx], 0
-;; d46c:	 aa                   	stosb	byte ptr [rdi], al
-;; d46d:	 800100               	add	byte ptr [rcx], 0
-;; d470:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d479:	 800100               	add	byte ptr [rcx], 0
-;; d47c:	 aa                   	stosb	byte ptr [rdi], al
-;; d47d:	 800100               	add	byte ptr [rcx], 0
-;; d480:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d489:	 800100               	add	byte ptr [rcx], 0
-;; d48c:	 aa                   	stosb	byte ptr [rdi], al
-;; d48d:	 800100               	add	byte ptr [rcx], 0
-;; d490:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d499:	 800100               	add	byte ptr [rcx], 0
-;; d49c:	 aa                   	stosb	byte ptr [rdi], al
-;; d49d:	 800100               	add	byte ptr [rcx], 0
-;; d4a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d4a9:	 800100               	add	byte ptr [rcx], 0
-;; d4ac:	 aa                   	stosb	byte ptr [rdi], al
-;; d4ad:	 800100               	add	byte ptr [rcx], 0
-;; d4b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d4b9:	 800100               	add	byte ptr [rcx], 0
-;; d4bc:	 aa                   	stosb	byte ptr [rdi], al
-;; d4bd:	 800100               	add	byte ptr [rcx], 0
-;; d4c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d4c9:	 800100               	add	byte ptr [rcx], 0
-;; d4cc:	 aa                   	stosb	byte ptr [rdi], al
-;; d4cd:	 800100               	add	byte ptr [rcx], 0
-;; d4d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d4d9:	 800100               	add	byte ptr [rcx], 0
-;; d4dc:	 aa                   	stosb	byte ptr [rdi], al
-;; d4dd:	 800100               	add	byte ptr [rcx], 0
-;; d4e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d4e9:	 800100               	add	byte ptr [rcx], 0
-;; d4ec:	 aa                   	stosb	byte ptr [rdi], al
-;; d4ed:	 800100               	add	byte ptr [rcx], 0
-;; d4f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d4f9:	 800100               	add	byte ptr [rcx], 0
-;; d4fc:	 aa                   	stosb	byte ptr [rdi], al
-;; d4fd:	 800100               	add	byte ptr [rcx], 0
-;; d500:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d509:	 800100               	add	byte ptr [rcx], 0
-;; d50c:	 aa                   	stosb	byte ptr [rdi], al
-;; d50d:	 800100               	add	byte ptr [rcx], 0
-;; d510:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d519:	 800100               	add	byte ptr [rcx], 0
-;; d51c:	 aa                   	stosb	byte ptr [rdi], al
-;; d51d:	 800100               	add	byte ptr [rcx], 0
-;; d520:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d529:	 800100               	add	byte ptr [rcx], 0
-;; d52c:	 aa                   	stosb	byte ptr [rdi], al
-;; d52d:	 800100               	add	byte ptr [rcx], 0
-;; d530:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d539:	 800100               	add	byte ptr [rcx], 0
-;; d53c:	 aa                   	stosb	byte ptr [rdi], al
-;; d53d:	 800100               	add	byte ptr [rcx], 0
-;; d540:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d549:	 800100               	add	byte ptr [rcx], 0
-;; d54c:	 aa                   	stosb	byte ptr [rdi], al
-;; d54d:	 800100               	add	byte ptr [rcx], 0
-;; d550:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d559:	 800100               	add	byte ptr [rcx], 0
-;; d55c:	 aa                   	stosb	byte ptr [rdi], al
-;; d55d:	 800100               	add	byte ptr [rcx], 0
-;; d560:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d569:	 800100               	add	byte ptr [rcx], 0
-;; d56c:	 aa                   	stosb	byte ptr [rdi], al
-;; d56d:	 800100               	add	byte ptr [rcx], 0
-;; d570:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d579:	 800100               	add	byte ptr [rcx], 0
-;; d57c:	 aa                   	stosb	byte ptr [rdi], al
-;; d57d:	 800100               	add	byte ptr [rcx], 0
-;; d580:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d589:	 800100               	add	byte ptr [rcx], 0
-;; d58c:	 aa                   	stosb	byte ptr [rdi], al
-;; d58d:	 800100               	add	byte ptr [rcx], 0
-;; d590:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d599:	 800100               	add	byte ptr [rcx], 0
-;; d59c:	 aa                   	stosb	byte ptr [rdi], al
-;; d59d:	 800100               	add	byte ptr [rcx], 0
-;; d5a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d5a9:	 800100               	add	byte ptr [rcx], 0
-;; d5ac:	 aa                   	stosb	byte ptr [rdi], al
-;; d5ad:	 800100               	add	byte ptr [rcx], 0
-;; d5b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d5b9:	 800100               	add	byte ptr [rcx], 0
-;; d5bc:	 aa                   	stosb	byte ptr [rdi], al
-;; d5bd:	 800100               	add	byte ptr [rcx], 0
-;; d5c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d5c9:	 800100               	add	byte ptr [rcx], 0
-;; d5cc:	 aa                   	stosb	byte ptr [rdi], al
-;; d5cd:	 800100               	add	byte ptr [rcx], 0
-;; d5d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d5d9:	 800100               	add	byte ptr [rcx], 0
-;; d5dc:	 aa                   	stosb	byte ptr [rdi], al
-;; d5dd:	 800100               	add	byte ptr [rcx], 0
-;; d5e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d5e9:	 800100               	add	byte ptr [rcx], 0
-;; d5ec:	 aa                   	stosb	byte ptr [rdi], al
-;; d5ed:	 800100               	add	byte ptr [rcx], 0
-;; d5f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d5f9:	 800100               	add	byte ptr [rcx], 0
-;; d5fc:	 aa                   	stosb	byte ptr [rdi], al
-;; d5fd:	 800100               	add	byte ptr [rcx], 0
-;; d600:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d609:	 800100               	add	byte ptr [rcx], 0
-;; d60c:	 aa                   	stosb	byte ptr [rdi], al
-;; d60d:	 800100               	add	byte ptr [rcx], 0
-;; d610:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d619:	 800100               	add	byte ptr [rcx], 0
-;; d61c:	 aa                   	stosb	byte ptr [rdi], al
-;; d61d:	 800100               	add	byte ptr [rcx], 0
-;; d620:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d629:	 800100               	add	byte ptr [rcx], 0
-;; d62c:	 aa                   	stosb	byte ptr [rdi], al
-;; d62d:	 800100               	add	byte ptr [rcx], 0
-;; d630:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d639:	 800100               	add	byte ptr [rcx], 0
-;; d63c:	 aa                   	stosb	byte ptr [rdi], al
-;; d63d:	 800100               	add	byte ptr [rcx], 0
-;; d640:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d649:	 800100               	add	byte ptr [rcx], 0
-;; d64c:	 aa                   	stosb	byte ptr [rdi], al
-;; d64d:	 800100               	add	byte ptr [rcx], 0
-;; d650:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d659:	 800100               	add	byte ptr [rcx], 0
-;; d65c:	 aa                   	stosb	byte ptr [rdi], al
-;; d65d:	 800100               	add	byte ptr [rcx], 0
-;; d660:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d669:	 800100               	add	byte ptr [rcx], 0
-;; d66c:	 aa                   	stosb	byte ptr [rdi], al
-;; d66d:	 800100               	add	byte ptr [rcx], 0
-;; d670:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d679:	 800100               	add	byte ptr [rcx], 0
-;; d67c:	 aa                   	stosb	byte ptr [rdi], al
-;; d67d:	 800100               	add	byte ptr [rcx], 0
-;; d680:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d689:	 800100               	add	byte ptr [rcx], 0
-;; d68c:	 aa                   	stosb	byte ptr [rdi], al
-;; d68d:	 800100               	add	byte ptr [rcx], 0
-;; d690:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d699:	 800100               	add	byte ptr [rcx], 0
-;; d69c:	 aa                   	stosb	byte ptr [rdi], al
-;; d69d:	 800100               	add	byte ptr [rcx], 0
-;; d6a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d6a9:	 800100               	add	byte ptr [rcx], 0
-;; d6ac:	 aa                   	stosb	byte ptr [rdi], al
-;; d6ad:	 800100               	add	byte ptr [rcx], 0
-;; d6b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d6b9:	 800100               	add	byte ptr [rcx], 0
-;; d6bc:	 aa                   	stosb	byte ptr [rdi], al
-;; d6bd:	 800100               	add	byte ptr [rcx], 0
-;; d6c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d6c9:	 800100               	add	byte ptr [rcx], 0
-;; d6cc:	 aa                   	stosb	byte ptr [rdi], al
-;; d6cd:	 800100               	add	byte ptr [rcx], 0
-;; d6d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d6d9:	 800100               	add	byte ptr [rcx], 0
-;; d6dc:	 aa                   	stosb	byte ptr [rdi], al
-;; d6dd:	 800100               	add	byte ptr [rcx], 0
-;; d6e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d6e9:	 800100               	add	byte ptr [rcx], 0
-;; d6ec:	 aa                   	stosb	byte ptr [rdi], al
-;; d6ed:	 800100               	add	byte ptr [rcx], 0
-;; d6f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d6f9:	 800100               	add	byte ptr [rcx], 0
-;; d6fc:	 aa                   	stosb	byte ptr [rdi], al
-;; d6fd:	 800100               	add	byte ptr [rcx], 0
-;; d700:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d709:	 800100               	add	byte ptr [rcx], 0
-;; d70c:	 aa                   	stosb	byte ptr [rdi], al
-;; d70d:	 800100               	add	byte ptr [rcx], 0
-;; d710:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d719:	 800100               	add	byte ptr [rcx], 0
-;; d71c:	 aa                   	stosb	byte ptr [rdi], al
-;; d71d:	 800100               	add	byte ptr [rcx], 0
-;; d720:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d729:	 800100               	add	byte ptr [rcx], 0
-;; d72c:	 aa                   	stosb	byte ptr [rdi], al
-;; d72d:	 800100               	add	byte ptr [rcx], 0
-;; d730:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d739:	 800100               	add	byte ptr [rcx], 0
-;; d73c:	 aa                   	stosb	byte ptr [rdi], al
-;; d73d:	 800100               	add	byte ptr [rcx], 0
-;; d740:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d749:	 800100               	add	byte ptr [rcx], 0
-;; d74c:	 aa                   	stosb	byte ptr [rdi], al
-;; d74d:	 800100               	add	byte ptr [rcx], 0
-;; d750:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d759:	 800100               	add	byte ptr [rcx], 0
-;; d75c:	 aa                   	stosb	byte ptr [rdi], al
-;; d75d:	 800100               	add	byte ptr [rcx], 0
-;; d760:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d769:	 800100               	add	byte ptr [rcx], 0
-;; d76c:	 aa                   	stosb	byte ptr [rdi], al
-;; d76d:	 800100               	add	byte ptr [rcx], 0
-;; d770:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d779:	 800100               	add	byte ptr [rcx], 0
-;; d77c:	 aa                   	stosb	byte ptr [rdi], al
-;; d77d:	 800100               	add	byte ptr [rcx], 0
-;; d780:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d789:	 800100               	add	byte ptr [rcx], 0
-;; d78c:	 aa                   	stosb	byte ptr [rdi], al
-;; d78d:	 800100               	add	byte ptr [rcx], 0
-;; d790:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d799:	 800100               	add	byte ptr [rcx], 0
-;; d79c:	 aa                   	stosb	byte ptr [rdi], al
-;; d79d:	 800100               	add	byte ptr [rcx], 0
-;; d7a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d7a9:	 800100               	add	byte ptr [rcx], 0
-;; d7ac:	 aa                   	stosb	byte ptr [rdi], al
-;; d7ad:	 800100               	add	byte ptr [rcx], 0
-;; d7b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d7b9:	 800100               	add	byte ptr [rcx], 0
-;; d7bc:	 aa                   	stosb	byte ptr [rdi], al
-;; d7bd:	 800100               	add	byte ptr [rcx], 0
-;; d7c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d7c9:	 800100               	add	byte ptr [rcx], 0
-;; d7cc:	 aa                   	stosb	byte ptr [rdi], al
-;; d7cd:	 800100               	add	byte ptr [rcx], 0
-;; d7d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d7d9:	 800100               	add	byte ptr [rcx], 0
-;; d7dc:	 aa                   	stosb	byte ptr [rdi], al
-;; d7dd:	 800100               	add	byte ptr [rcx], 0
-;; d7e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d7e9:	 800100               	add	byte ptr [rcx], 0
-;; d7ec:	 aa                   	stosb	byte ptr [rdi], al
-;; d7ed:	 800100               	add	byte ptr [rcx], 0
-;; d7f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d7f9:	 800100               	add	byte ptr [rcx], 0
-;; d7fc:	 aa                   	stosb	byte ptr [rdi], al
-;; d7fd:	 800100               	add	byte ptr [rcx], 0
-;; d800:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d809:	 800100               	add	byte ptr [rcx], 0
-;; d80c:	 aa                   	stosb	byte ptr [rdi], al
-;; d80d:	 800100               	add	byte ptr [rcx], 0
-;; d810:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d819:	 800100               	add	byte ptr [rcx], 0
-;; d81c:	 aa                   	stosb	byte ptr [rdi], al
-;; d81d:	 800100               	add	byte ptr [rcx], 0
-;; d820:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d829:	 800100               	add	byte ptr [rcx], 0
-;; d82c:	 aa                   	stosb	byte ptr [rdi], al
-;; d82d:	 800100               	add	byte ptr [rcx], 0
-;; d830:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d839:	 800100               	add	byte ptr [rcx], 0
-;; d83c:	 aa                   	stosb	byte ptr [rdi], al
-;; d83d:	 800100               	add	byte ptr [rcx], 0
-;; d840:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d849:	 800100               	add	byte ptr [rcx], 0
-;; d84c:	 aa                   	stosb	byte ptr [rdi], al
-;; d84d:	 800100               	add	byte ptr [rcx], 0
-;; d850:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d859:	 800100               	add	byte ptr [rcx], 0
-;; d85c:	 aa                   	stosb	byte ptr [rdi], al
-;; d85d:	 800100               	add	byte ptr [rcx], 0
-;; d860:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d869:	 800100               	add	byte ptr [rcx], 0
-;; d86c:	 aa                   	stosb	byte ptr [rdi], al
-;; d86d:	 800100               	add	byte ptr [rcx], 0
-;; d870:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d879:	 800100               	add	byte ptr [rcx], 0
-;; d87c:	 aa                   	stosb	byte ptr [rdi], al
-;; d87d:	 800100               	add	byte ptr [rcx], 0
-;; d880:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d889:	 800100               	add	byte ptr [rcx], 0
-;; d88c:	 aa                   	stosb	byte ptr [rdi], al
-;; d88d:	 800100               	add	byte ptr [rcx], 0
-;; d890:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d899:	 800100               	add	byte ptr [rcx], 0
-;; d89c:	 aa                   	stosb	byte ptr [rdi], al
-;; d89d:	 800100               	add	byte ptr [rcx], 0
-;; d8a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d8a9:	 800100               	add	byte ptr [rcx], 0
-;; d8ac:	 aa                   	stosb	byte ptr [rdi], al
-;; d8ad:	 800100               	add	byte ptr [rcx], 0
-;; d8b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d8b9:	 800100               	add	byte ptr [rcx], 0
-;; d8bc:	 aa                   	stosb	byte ptr [rdi], al
-;; d8bd:	 800100               	add	byte ptr [rcx], 0
-;; d8c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d8c9:	 800100               	add	byte ptr [rcx], 0
-;; d8cc:	 aa                   	stosb	byte ptr [rdi], al
-;; d8cd:	 800100               	add	byte ptr [rcx], 0
-;; d8d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d8d9:	 800100               	add	byte ptr [rcx], 0
-;; d8dc:	 aa                   	stosb	byte ptr [rdi], al
-;; d8dd:	 800100               	add	byte ptr [rcx], 0
-;; d8e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d8e9:	 800100               	add	byte ptr [rcx], 0
-;; d8ec:	 aa                   	stosb	byte ptr [rdi], al
-;; d8ed:	 800100               	add	byte ptr [rcx], 0
-;; d8f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d8f9:	 800100               	add	byte ptr [rcx], 0
-;; d8fc:	 aa                   	stosb	byte ptr [rdi], al
-;; d8fd:	 800100               	add	byte ptr [rcx], 0
-;; d900:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d909:	 800100               	add	byte ptr [rcx], 0
-;; d90c:	 aa                   	stosb	byte ptr [rdi], al
-;; d90d:	 800100               	add	byte ptr [rcx], 0
-;; d910:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d919:	 800100               	add	byte ptr [rcx], 0
-;; d91c:	 aa                   	stosb	byte ptr [rdi], al
-;; d91d:	 800100               	add	byte ptr [rcx], 0
-;; d920:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d929:	 800100               	add	byte ptr [rcx], 0
-;; d92c:	 aa                   	stosb	byte ptr [rdi], al
-;; d92d:	 800100               	add	byte ptr [rcx], 0
-;; d930:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d939:	 800100               	add	byte ptr [rcx], 0
-;; d93c:	 aa                   	stosb	byte ptr [rdi], al
-;; d93d:	 800100               	add	byte ptr [rcx], 0
-;; d940:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d949:	 800100               	add	byte ptr [rcx], 0
-;; d94c:	 aa                   	stosb	byte ptr [rdi], al
-;; d94d:	 800100               	add	byte ptr [rcx], 0
-;; d950:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d959:	 800100               	add	byte ptr [rcx], 0
-;; d95c:	 aa                   	stosb	byte ptr [rdi], al
-;; d95d:	 800100               	add	byte ptr [rcx], 0
-;; d960:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d969:	 800100               	add	byte ptr [rcx], 0
-;; d96c:	 aa                   	stosb	byte ptr [rdi], al
-;; d96d:	 800100               	add	byte ptr [rcx], 0
-;; d970:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d979:	 800100               	add	byte ptr [rcx], 0
-;; d97c:	 aa                   	stosb	byte ptr [rdi], al
-;; d97d:	 800100               	add	byte ptr [rcx], 0
-;; d980:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d989:	 800100               	add	byte ptr [rcx], 0
-;; d98c:	 aa                   	stosb	byte ptr [rdi], al
-;; d98d:	 800100               	add	byte ptr [rcx], 0
-;; d990:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d999:	 800100               	add	byte ptr [rcx], 0
-;; d99c:	 aa                   	stosb	byte ptr [rdi], al
-;; d99d:	 800100               	add	byte ptr [rcx], 0
-;; d9a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d9a9:	 800100               	add	byte ptr [rcx], 0
-;; d9ac:	 aa                   	stosb	byte ptr [rdi], al
-;; d9ad:	 800100               	add	byte ptr [rcx], 0
-;; d9b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d9b9:	 800100               	add	byte ptr [rcx], 0
-;; d9bc:	 aa                   	stosb	byte ptr [rdi], al
-;; d9bd:	 800100               	add	byte ptr [rcx], 0
-;; d9c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d9c9:	 800100               	add	byte ptr [rcx], 0
-;; d9cc:	 aa                   	stosb	byte ptr [rdi], al
-;; d9cd:	 800100               	add	byte ptr [rcx], 0
-;; d9d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d9d9:	 800100               	add	byte ptr [rcx], 0
-;; d9dc:	 aa                   	stosb	byte ptr [rdi], al
-;; d9dd:	 800100               	add	byte ptr [rcx], 0
-;; d9e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d9e9:	 800100               	add	byte ptr [rcx], 0
-;; d9ec:	 aa                   	stosb	byte ptr [rdi], al
-;; d9ed:	 800100               	add	byte ptr [rcx], 0
-;; d9f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; d9f9:	 800100               	add	byte ptr [rcx], 0
-;; d9fc:	 aa                   	stosb	byte ptr [rdi], al
-;; d9fd:	 800100               	add	byte ptr [rcx], 0
-;; da00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; da09:	 800100               	add	byte ptr [rcx], 0
-;; da0c:	 aa                   	stosb	byte ptr [rdi], al
-;; da0d:	 800100               	add	byte ptr [rcx], 0
-;; da10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; da19:	 800100               	add	byte ptr [rcx], 0
-;; da1c:	 aa                   	stosb	byte ptr [rdi], al
-;; da1d:	 800100               	add	byte ptr [rcx], 0
-;; da20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; da29:	 800100               	add	byte ptr [rcx], 0
-;; da2c:	 aa                   	stosb	byte ptr [rdi], al
-;; da2d:	 800100               	add	byte ptr [rcx], 0
-;; da30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; da39:	 800100               	add	byte ptr [rcx], 0
-;; da3c:	 aa                   	stosb	byte ptr [rdi], al
-;; da3d:	 800100               	add	byte ptr [rcx], 0
-;; da40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; da49:	 800100               	add	byte ptr [rcx], 0
-;; da4c:	 aa                   	stosb	byte ptr [rdi], al
-;; da4d:	 800100               	add	byte ptr [rcx], 0
-;; da50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; da59:	 800100               	add	byte ptr [rcx], 0
-;; da5c:	 aa                   	stosb	byte ptr [rdi], al
-;; da5d:	 800100               	add	byte ptr [rcx], 0
-;; da60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; da69:	 800100               	add	byte ptr [rcx], 0
-;; da6c:	 aa                   	stosb	byte ptr [rdi], al
-;; da6d:	 800100               	add	byte ptr [rcx], 0
-;; da70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; da79:	 800100               	add	byte ptr [rcx], 0
-;; da7c:	 aa                   	stosb	byte ptr [rdi], al
-;; da7d:	 800100               	add	byte ptr [rcx], 0
-;; da80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; da89:	 800100               	add	byte ptr [rcx], 0
-;; da8c:	 aa                   	stosb	byte ptr [rdi], al
-;; da8d:	 800100               	add	byte ptr [rcx], 0
-;; da90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; da99:	 800100               	add	byte ptr [rcx], 0
-;; da9c:	 aa                   	stosb	byte ptr [rdi], al
-;; da9d:	 800100               	add	byte ptr [rcx], 0
-;; daa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; daa9:	 800100               	add	byte ptr [rcx], 0
-;; daac:	 aa                   	stosb	byte ptr [rdi], al
-;; daad:	 800100               	add	byte ptr [rcx], 0
-;; dab0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dab9:	 800100               	add	byte ptr [rcx], 0
-;; dabc:	 aa                   	stosb	byte ptr [rdi], al
-;; dabd:	 800100               	add	byte ptr [rcx], 0
-;; dac0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dac9:	 800100               	add	byte ptr [rcx], 0
-;; dacc:	 aa                   	stosb	byte ptr [rdi], al
-;; dacd:	 800100               	add	byte ptr [rcx], 0
-;; dad0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dad9:	 800100               	add	byte ptr [rcx], 0
-;; dadc:	 aa                   	stosb	byte ptr [rdi], al
-;; dadd:	 800100               	add	byte ptr [rcx], 0
-;; dae0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dae9:	 800100               	add	byte ptr [rcx], 0
-;; daec:	 aa                   	stosb	byte ptr [rdi], al
-;; daed:	 800100               	add	byte ptr [rcx], 0
-;; daf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; daf9:	 800100               	add	byte ptr [rcx], 0
-;; dafc:	 aa                   	stosb	byte ptr [rdi], al
-;; dafd:	 800100               	add	byte ptr [rcx], 0
-;; db00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; db09:	 800100               	add	byte ptr [rcx], 0
-;; db0c:	 aa                   	stosb	byte ptr [rdi], al
-;; db0d:	 800100               	add	byte ptr [rcx], 0
-;; db10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; db19:	 800100               	add	byte ptr [rcx], 0
-;; db1c:	 aa                   	stosb	byte ptr [rdi], al
-;; db1d:	 800100               	add	byte ptr [rcx], 0
-;; db20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; db29:	 800100               	add	byte ptr [rcx], 0
-;; db2c:	 aa                   	stosb	byte ptr [rdi], al
-;; db2d:	 800100               	add	byte ptr [rcx], 0
-;; db30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; db39:	 800100               	add	byte ptr [rcx], 0
-;; db3c:	 aa                   	stosb	byte ptr [rdi], al
-;; db3d:	 800100               	add	byte ptr [rcx], 0
-;; db40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; db49:	 800100               	add	byte ptr [rcx], 0
-;; db4c:	 aa                   	stosb	byte ptr [rdi], al
-;; db4d:	 800100               	add	byte ptr [rcx], 0
-;; db50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; db59:	 800100               	add	byte ptr [rcx], 0
-;; db5c:	 aa                   	stosb	byte ptr [rdi], al
-;; db5d:	 800100               	add	byte ptr [rcx], 0
-;; db60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; db69:	 800100               	add	byte ptr [rcx], 0
-;; db6c:	 aa                   	stosb	byte ptr [rdi], al
-;; db6d:	 800100               	add	byte ptr [rcx], 0
-;; db70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; db79:	 800100               	add	byte ptr [rcx], 0
-;; db7c:	 aa                   	stosb	byte ptr [rdi], al
-;; db7d:	 800100               	add	byte ptr [rcx], 0
-;; db80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; db89:	 800100               	add	byte ptr [rcx], 0
-;; db8c:	 aa                   	stosb	byte ptr [rdi], al
-;; db8d:	 800100               	add	byte ptr [rcx], 0
-;; db90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; db99:	 800100               	add	byte ptr [rcx], 0
-;; db9c:	 aa                   	stosb	byte ptr [rdi], al
-;; db9d:	 800100               	add	byte ptr [rcx], 0
-;; dba0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dba9:	 800100               	add	byte ptr [rcx], 0
-;; dbac:	 aa                   	stosb	byte ptr [rdi], al
-;; dbad:	 800100               	add	byte ptr [rcx], 0
-;; dbb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dbb9:	 800100               	add	byte ptr [rcx], 0
-;; dbbc:	 aa                   	stosb	byte ptr [rdi], al
-;; dbbd:	 800100               	add	byte ptr [rcx], 0
-;; dbc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dbc9:	 800100               	add	byte ptr [rcx], 0
-;; dbcc:	 aa                   	stosb	byte ptr [rdi], al
-;; dbcd:	 800100               	add	byte ptr [rcx], 0
-;; dbd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dbd9:	 800100               	add	byte ptr [rcx], 0
-;; dbdc:	 aa                   	stosb	byte ptr [rdi], al
-;; dbdd:	 800100               	add	byte ptr [rcx], 0
-;; dbe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dbe9:	 800100               	add	byte ptr [rcx], 0
-;; dbec:	 aa                   	stosb	byte ptr [rdi], al
-;; dbed:	 800100               	add	byte ptr [rcx], 0
-;; dbf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dbf9:	 800100               	add	byte ptr [rcx], 0
-;; dbfc:	 aa                   	stosb	byte ptr [rdi], al
-;; dbfd:	 800100               	add	byte ptr [rcx], 0
-;; dc00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dc09:	 800100               	add	byte ptr [rcx], 0
-;; dc0c:	 aa                   	stosb	byte ptr [rdi], al
-;; dc0d:	 800100               	add	byte ptr [rcx], 0
-;; dc10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dc19:	 800100               	add	byte ptr [rcx], 0
-;; dc1c:	 aa                   	stosb	byte ptr [rdi], al
-;; dc1d:	 800100               	add	byte ptr [rcx], 0
-;; dc20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dc29:	 800100               	add	byte ptr [rcx], 0
-;; dc2c:	 aa                   	stosb	byte ptr [rdi], al
-;; dc2d:	 800100               	add	byte ptr [rcx], 0
-;; dc30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dc39:	 800100               	add	byte ptr [rcx], 0
-;; dc3c:	 aa                   	stosb	byte ptr [rdi], al
-;; dc3d:	 800100               	add	byte ptr [rcx], 0
-;; dc40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dc49:	 800100               	add	byte ptr [rcx], 0
-;; dc4c:	 aa                   	stosb	byte ptr [rdi], al
-;; dc4d:	 800100               	add	byte ptr [rcx], 0
-;; dc50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dc59:	 800100               	add	byte ptr [rcx], 0
-;; dc5c:	 aa                   	stosb	byte ptr [rdi], al
-;; dc5d:	 800100               	add	byte ptr [rcx], 0
-;; dc60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dc69:	 800100               	add	byte ptr [rcx], 0
-;; dc6c:	 aa                   	stosb	byte ptr [rdi], al
-;; dc6d:	 800100               	add	byte ptr [rcx], 0
-;; dc70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dc79:	 800100               	add	byte ptr [rcx], 0
-;; dc7c:	 aa                   	stosb	byte ptr [rdi], al
-;; dc7d:	 800100               	add	byte ptr [rcx], 0
-;; dc80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dc89:	 800100               	add	byte ptr [rcx], 0
-;; dc8c:	 aa                   	stosb	byte ptr [rdi], al
-;; dc8d:	 800100               	add	byte ptr [rcx], 0
-;; dc90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dc99:	 800100               	add	byte ptr [rcx], 0
-;; dc9c:	 aa                   	stosb	byte ptr [rdi], al
-;; dc9d:	 800100               	add	byte ptr [rcx], 0
-;; dca0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dca9:	 800100               	add	byte ptr [rcx], 0
-;; dcac:	 aa                   	stosb	byte ptr [rdi], al
-;; dcad:	 800100               	add	byte ptr [rcx], 0
-;; dcb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dcb9:	 800100               	add	byte ptr [rcx], 0
-;; dcbc:	 aa                   	stosb	byte ptr [rdi], al
-;; dcbd:	 800100               	add	byte ptr [rcx], 0
-;; dcc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dcc9:	 800100               	add	byte ptr [rcx], 0
-;; dccc:	 aa                   	stosb	byte ptr [rdi], al
-;; dccd:	 800100               	add	byte ptr [rcx], 0
-;; dcd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dcd9:	 800100               	add	byte ptr [rcx], 0
-;; dcdc:	 aa                   	stosb	byte ptr [rdi], al
-;; dcdd:	 800100               	add	byte ptr [rcx], 0
-;; dce0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dce9:	 800100               	add	byte ptr [rcx], 0
-;; dcec:	 aa                   	stosb	byte ptr [rdi], al
-;; dced:	 800100               	add	byte ptr [rcx], 0
-;; dcf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dcf9:	 800100               	add	byte ptr [rcx], 0
-;; dcfc:	 aa                   	stosb	byte ptr [rdi], al
-;; dcfd:	 800100               	add	byte ptr [rcx], 0
-;; dd00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dd09:	 800100               	add	byte ptr [rcx], 0
-;; dd0c:	 aa                   	stosb	byte ptr [rdi], al
-;; dd0d:	 800100               	add	byte ptr [rcx], 0
-;; dd10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dd19:	 800100               	add	byte ptr [rcx], 0
-;; dd1c:	 aa                   	stosb	byte ptr [rdi], al
-;; dd1d:	 800100               	add	byte ptr [rcx], 0
-;; dd20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dd29:	 800100               	add	byte ptr [rcx], 0
-;; dd2c:	 aa                   	stosb	byte ptr [rdi], al
-;; dd2d:	 800100               	add	byte ptr [rcx], 0
-;; dd30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dd39:	 800100               	add	byte ptr [rcx], 0
-;; dd3c:	 aa                   	stosb	byte ptr [rdi], al
-;; dd3d:	 800100               	add	byte ptr [rcx], 0
-;; dd40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dd49:	 800100               	add	byte ptr [rcx], 0
-;; dd4c:	 aa                   	stosb	byte ptr [rdi], al
-;; dd4d:	 800100               	add	byte ptr [rcx], 0
-;; dd50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dd59:	 800100               	add	byte ptr [rcx], 0
-;; dd5c:	 aa                   	stosb	byte ptr [rdi], al
-;; dd5d:	 800100               	add	byte ptr [rcx], 0
-;; dd60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dd69:	 800100               	add	byte ptr [rcx], 0
-;; dd6c:	 aa                   	stosb	byte ptr [rdi], al
-;; dd6d:	 800100               	add	byte ptr [rcx], 0
-;; dd70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dd79:	 800100               	add	byte ptr [rcx], 0
-;; dd7c:	 aa                   	stosb	byte ptr [rdi], al
-;; dd7d:	 800100               	add	byte ptr [rcx], 0
-;; dd80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dd89:	 800100               	add	byte ptr [rcx], 0
-;; dd8c:	 aa                   	stosb	byte ptr [rdi], al
-;; dd8d:	 800100               	add	byte ptr [rcx], 0
-;; dd90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dd99:	 800100               	add	byte ptr [rcx], 0
-;; dd9c:	 aa                   	stosb	byte ptr [rdi], al
-;; dd9d:	 800100               	add	byte ptr [rcx], 0
-;; dda0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dda9:	 800100               	add	byte ptr [rcx], 0
-;; ddac:	 aa                   	stosb	byte ptr [rdi], al
-;; ddad:	 800100               	add	byte ptr [rcx], 0
-;; ddb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ddb9:	 800100               	add	byte ptr [rcx], 0
-;; ddbc:	 aa                   	stosb	byte ptr [rdi], al
-;; ddbd:	 800100               	add	byte ptr [rcx], 0
-;; ddc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ddc9:	 800100               	add	byte ptr [rcx], 0
-;; ddcc:	 aa                   	stosb	byte ptr [rdi], al
-;; ddcd:	 800100               	add	byte ptr [rcx], 0
-;; ddd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ddd9:	 800100               	add	byte ptr [rcx], 0
-;; dddc:	 aa                   	stosb	byte ptr [rdi], al
-;; dddd:	 800100               	add	byte ptr [rcx], 0
-;; dde0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dde9:	 800100               	add	byte ptr [rcx], 0
-;; ddec:	 aa                   	stosb	byte ptr [rdi], al
-;; dded:	 800100               	add	byte ptr [rcx], 0
-;; ddf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ddf9:	 800100               	add	byte ptr [rcx], 0
-;; ddfc:	 aa                   	stosb	byte ptr [rdi], al
-;; ddfd:	 800100               	add	byte ptr [rcx], 0
-;; de00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; de09:	 800100               	add	byte ptr [rcx], 0
-;; de0c:	 aa                   	stosb	byte ptr [rdi], al
-;; de0d:	 800100               	add	byte ptr [rcx], 0
-;; de10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; de19:	 800100               	add	byte ptr [rcx], 0
-;; de1c:	 aa                   	stosb	byte ptr [rdi], al
-;; de1d:	 800100               	add	byte ptr [rcx], 0
-;; de20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; de29:	 800100               	add	byte ptr [rcx], 0
-;; de2c:	 aa                   	stosb	byte ptr [rdi], al
-;; de2d:	 800100               	add	byte ptr [rcx], 0
-;; de30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; de39:	 800100               	add	byte ptr [rcx], 0
-;; de3c:	 aa                   	stosb	byte ptr [rdi], al
-;; de3d:	 800100               	add	byte ptr [rcx], 0
-;; de40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; de49:	 800100               	add	byte ptr [rcx], 0
-;; de4c:	 aa                   	stosb	byte ptr [rdi], al
-;; de4d:	 800100               	add	byte ptr [rcx], 0
-;; de50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; de59:	 800100               	add	byte ptr [rcx], 0
-;; de5c:	 aa                   	stosb	byte ptr [rdi], al
-;; de5d:	 800100               	add	byte ptr [rcx], 0
-;; de60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; de69:	 800100               	add	byte ptr [rcx], 0
-;; de6c:	 aa                   	stosb	byte ptr [rdi], al
-;; de6d:	 800100               	add	byte ptr [rcx], 0
-;; de70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; de79:	 800100               	add	byte ptr [rcx], 0
-;; de7c:	 aa                   	stosb	byte ptr [rdi], al
-;; de7d:	 800100               	add	byte ptr [rcx], 0
-;; de80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; de89:	 800100               	add	byte ptr [rcx], 0
-;; de8c:	 aa                   	stosb	byte ptr [rdi], al
-;; de8d:	 800100               	add	byte ptr [rcx], 0
-;; de90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; de99:	 800100               	add	byte ptr [rcx], 0
-;; de9c:	 aa                   	stosb	byte ptr [rdi], al
-;; de9d:	 800100               	add	byte ptr [rcx], 0
-;; dea0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dea9:	 800100               	add	byte ptr [rcx], 0
-;; deac:	 aa                   	stosb	byte ptr [rdi], al
-;; dead:	 800100               	add	byte ptr [rcx], 0
-;; deb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; deb9:	 800100               	add	byte ptr [rcx], 0
-;; debc:	 aa                   	stosb	byte ptr [rdi], al
-;; debd:	 800100               	add	byte ptr [rcx], 0
-;; dec0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dec9:	 800100               	add	byte ptr [rcx], 0
-;; decc:	 aa                   	stosb	byte ptr [rdi], al
-;; decd:	 800100               	add	byte ptr [rcx], 0
-;; ded0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ded9:	 800100               	add	byte ptr [rcx], 0
-;; dedc:	 aa                   	stosb	byte ptr [rdi], al
-;; dedd:	 800100               	add	byte ptr [rcx], 0
-;; dee0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dee9:	 800100               	add	byte ptr [rcx], 0
-;; deec:	 aa                   	stosb	byte ptr [rdi], al
-;; deed:	 800100               	add	byte ptr [rcx], 0
-;; def0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; def9:	 800100               	add	byte ptr [rcx], 0
-;; defc:	 aa                   	stosb	byte ptr [rdi], al
-;; defd:	 800100               	add	byte ptr [rcx], 0
-;; df00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; df09:	 800100               	add	byte ptr [rcx], 0
-;; df0c:	 aa                   	stosb	byte ptr [rdi], al
-;; df0d:	 800100               	add	byte ptr [rcx], 0
-;; df10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; df19:	 800100               	add	byte ptr [rcx], 0
-;; df1c:	 aa                   	stosb	byte ptr [rdi], al
-;; df1d:	 800100               	add	byte ptr [rcx], 0
-;; df20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; df29:	 800100               	add	byte ptr [rcx], 0
-;; df2c:	 aa                   	stosb	byte ptr [rdi], al
-;; df2d:	 800100               	add	byte ptr [rcx], 0
-;; df30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; df39:	 800100               	add	byte ptr [rcx], 0
-;; df3c:	 aa                   	stosb	byte ptr [rdi], al
-;; df3d:	 800100               	add	byte ptr [rcx], 0
-;; df40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; df49:	 800100               	add	byte ptr [rcx], 0
-;; df4c:	 aa                   	stosb	byte ptr [rdi], al
-;; df4d:	 800100               	add	byte ptr [rcx], 0
-;; df50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; df59:	 800100               	add	byte ptr [rcx], 0
-;; df5c:	 aa                   	stosb	byte ptr [rdi], al
-;; df5d:	 800100               	add	byte ptr [rcx], 0
-;; df60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; df69:	 800100               	add	byte ptr [rcx], 0
-;; df6c:	 aa                   	stosb	byte ptr [rdi], al
-;; df6d:	 800100               	add	byte ptr [rcx], 0
-;; df70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; df79:	 800100               	add	byte ptr [rcx], 0
-;; df7c:	 aa                   	stosb	byte ptr [rdi], al
-;; df7d:	 800100               	add	byte ptr [rcx], 0
-;; df80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; df89:	 800100               	add	byte ptr [rcx], 0
-;; df8c:	 aa                   	stosb	byte ptr [rdi], al
-;; df8d:	 800100               	add	byte ptr [rcx], 0
-;; df90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; df99:	 800100               	add	byte ptr [rcx], 0
-;; df9c:	 aa                   	stosb	byte ptr [rdi], al
-;; df9d:	 800100               	add	byte ptr [rcx], 0
-;; dfa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dfa9:	 800100               	add	byte ptr [rcx], 0
-;; dfac:	 aa                   	stosb	byte ptr [rdi], al
-;; dfad:	 800100               	add	byte ptr [rcx], 0
-;; dfb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dfb9:	 800100               	add	byte ptr [rcx], 0
-;; dfbc:	 aa                   	stosb	byte ptr [rdi], al
-;; dfbd:	 800100               	add	byte ptr [rcx], 0
-;; dfc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dfc9:	 800100               	add	byte ptr [rcx], 0
-;; dfcc:	 aa                   	stosb	byte ptr [rdi], al
-;; dfcd:	 800100               	add	byte ptr [rcx], 0
-;; dfd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dfd9:	 800100               	add	byte ptr [rcx], 0
-;; dfdc:	 aa                   	stosb	byte ptr [rdi], al
-;; dfdd:	 800100               	add	byte ptr [rcx], 0
-;; dfe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dfe9:	 800100               	add	byte ptr [rcx], 0
-;; dfec:	 aa                   	stosb	byte ptr [rdi], al
-;; dfed:	 800100               	add	byte ptr [rcx], 0
-;; dff0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; dff9:	 800100               	add	byte ptr [rcx], 0
-;; dffc:	 aa                   	stosb	byte ptr [rdi], al
-;; dffd:	 800100               	add	byte ptr [rcx], 0
-;; e000:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e009:	 800100               	add	byte ptr [rcx], 0
-;; e00c:	 aa                   	stosb	byte ptr [rdi], al
-;; e00d:	 800100               	add	byte ptr [rcx], 0
-;; e010:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e019:	 800100               	add	byte ptr [rcx], 0
-;; e01c:	 aa                   	stosb	byte ptr [rdi], al
-;; e01d:	 800100               	add	byte ptr [rcx], 0
-;; e020:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e029:	 800100               	add	byte ptr [rcx], 0
-;; e02c:	 aa                   	stosb	byte ptr [rdi], al
-;; e02d:	 800100               	add	byte ptr [rcx], 0
-;; e030:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e039:	 800100               	add	byte ptr [rcx], 0
-;; e03c:	 aa                   	stosb	byte ptr [rdi], al
-;; e03d:	 800100               	add	byte ptr [rcx], 0
-;; e040:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e049:	 800100               	add	byte ptr [rcx], 0
-;; e04c:	 aa                   	stosb	byte ptr [rdi], al
-;; e04d:	 800100               	add	byte ptr [rcx], 0
-;; e050:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e059:	 800100               	add	byte ptr [rcx], 0
-;; e05c:	 aa                   	stosb	byte ptr [rdi], al
-;; e05d:	 800100               	add	byte ptr [rcx], 0
-;; e060:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e069:	 800100               	add	byte ptr [rcx], 0
-;; e06c:	 aa                   	stosb	byte ptr [rdi], al
-;; e06d:	 800100               	add	byte ptr [rcx], 0
-;; e070:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e079:	 800100               	add	byte ptr [rcx], 0
-;; e07c:	 aa                   	stosb	byte ptr [rdi], al
-;; e07d:	 800100               	add	byte ptr [rcx], 0
-;; e080:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e089:	 800100               	add	byte ptr [rcx], 0
-;; e08c:	 aa                   	stosb	byte ptr [rdi], al
-;; e08d:	 800100               	add	byte ptr [rcx], 0
-;; e090:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e099:	 800100               	add	byte ptr [rcx], 0
-;; e09c:	 aa                   	stosb	byte ptr [rdi], al
-;; e09d:	 800100               	add	byte ptr [rcx], 0
-;; e0a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e0a9:	 800100               	add	byte ptr [rcx], 0
-;; e0ac:	 aa                   	stosb	byte ptr [rdi], al
-;; e0ad:	 800100               	add	byte ptr [rcx], 0
-;; e0b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e0b9:	 800100               	add	byte ptr [rcx], 0
-;; e0bc:	 aa                   	stosb	byte ptr [rdi], al
-;; e0bd:	 800100               	add	byte ptr [rcx], 0
-;; e0c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e0c9:	 800100               	add	byte ptr [rcx], 0
-;; e0cc:	 aa                   	stosb	byte ptr [rdi], al
-;; e0cd:	 800100               	add	byte ptr [rcx], 0
-;; e0d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e0d9:	 800100               	add	byte ptr [rcx], 0
-;; e0dc:	 aa                   	stosb	byte ptr [rdi], al
-;; e0dd:	 800100               	add	byte ptr [rcx], 0
-;; e0e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e0e9:	 800100               	add	byte ptr [rcx], 0
-;; e0ec:	 aa                   	stosb	byte ptr [rdi], al
-;; e0ed:	 800100               	add	byte ptr [rcx], 0
-;; e0f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e0f9:	 800100               	add	byte ptr [rcx], 0
-;; e0fc:	 aa                   	stosb	byte ptr [rdi], al
-;; e0fd:	 800100               	add	byte ptr [rcx], 0
-;; e100:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e109:	 800100               	add	byte ptr [rcx], 0
-;; e10c:	 aa                   	stosb	byte ptr [rdi], al
-;; e10d:	 800100               	add	byte ptr [rcx], 0
-;; e110:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e119:	 800100               	add	byte ptr [rcx], 0
-;; e11c:	 aa                   	stosb	byte ptr [rdi], al
-;; e11d:	 800100               	add	byte ptr [rcx], 0
-;; e120:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e129:	 800100               	add	byte ptr [rcx], 0
-;; e12c:	 aa                   	stosb	byte ptr [rdi], al
-;; e12d:	 800100               	add	byte ptr [rcx], 0
-;; e130:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e139:	 800100               	add	byte ptr [rcx], 0
-;; e13c:	 aa                   	stosb	byte ptr [rdi], al
-;; e13d:	 800100               	add	byte ptr [rcx], 0
-;; e140:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e149:	 800100               	add	byte ptr [rcx], 0
-;; e14c:	 aa                   	stosb	byte ptr [rdi], al
-;; e14d:	 800100               	add	byte ptr [rcx], 0
-;; e150:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e159:	 800100               	add	byte ptr [rcx], 0
-;; e15c:	 aa                   	stosb	byte ptr [rdi], al
-;; e15d:	 800100               	add	byte ptr [rcx], 0
-;; e160:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e169:	 800100               	add	byte ptr [rcx], 0
-;; e16c:	 aa                   	stosb	byte ptr [rdi], al
-;; e16d:	 800100               	add	byte ptr [rcx], 0
-;; e170:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e179:	 800100               	add	byte ptr [rcx], 0
-;; e17c:	 aa                   	stosb	byte ptr [rdi], al
-;; e17d:	 800100               	add	byte ptr [rcx], 0
-;; e180:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e189:	 800100               	add	byte ptr [rcx], 0
-;; e18c:	 aa                   	stosb	byte ptr [rdi], al
-;; e18d:	 800100               	add	byte ptr [rcx], 0
-;; e190:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e199:	 800100               	add	byte ptr [rcx], 0
-;; e19c:	 aa                   	stosb	byte ptr [rdi], al
-;; e19d:	 800100               	add	byte ptr [rcx], 0
-;; e1a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e1a9:	 800100               	add	byte ptr [rcx], 0
-;; e1ac:	 aa                   	stosb	byte ptr [rdi], al
-;; e1ad:	 800100               	add	byte ptr [rcx], 0
-;; e1b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e1b9:	 800100               	add	byte ptr [rcx], 0
-;; e1bc:	 aa                   	stosb	byte ptr [rdi], al
-;; e1bd:	 800100               	add	byte ptr [rcx], 0
-;; e1c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e1c9:	 800100               	add	byte ptr [rcx], 0
-;; e1cc:	 aa                   	stosb	byte ptr [rdi], al
-;; e1cd:	 800100               	add	byte ptr [rcx], 0
-;; e1d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e1d9:	 800100               	add	byte ptr [rcx], 0
-;; e1dc:	 aa                   	stosb	byte ptr [rdi], al
-;; e1dd:	 800100               	add	byte ptr [rcx], 0
-;; e1e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e1e9:	 800100               	add	byte ptr [rcx], 0
-;; e1ec:	 aa                   	stosb	byte ptr [rdi], al
-;; e1ed:	 800100               	add	byte ptr [rcx], 0
-;; e1f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e1f9:	 800100               	add	byte ptr [rcx], 0
-;; e1fc:	 aa                   	stosb	byte ptr [rdi], al
-;; e1fd:	 800100               	add	byte ptr [rcx], 0
-;; e200:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e209:	 800100               	add	byte ptr [rcx], 0
-;; e20c:	 aa                   	stosb	byte ptr [rdi], al
-;; e20d:	 800100               	add	byte ptr [rcx], 0
-;; e210:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e219:	 800100               	add	byte ptr [rcx], 0
-;; e21c:	 aa                   	stosb	byte ptr [rdi], al
-;; e21d:	 800100               	add	byte ptr [rcx], 0
-;; e220:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e229:	 800100               	add	byte ptr [rcx], 0
-;; e22c:	 aa                   	stosb	byte ptr [rdi], al
-;; e22d:	 800100               	add	byte ptr [rcx], 0
-;; e230:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e239:	 800100               	add	byte ptr [rcx], 0
-;; e23c:	 aa                   	stosb	byte ptr [rdi], al
-;; e23d:	 800100               	add	byte ptr [rcx], 0
-;; e240:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e249:	 800100               	add	byte ptr [rcx], 0
-;; e24c:	 aa                   	stosb	byte ptr [rdi], al
-;; e24d:	 800100               	add	byte ptr [rcx], 0
-;; e250:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e259:	 800100               	add	byte ptr [rcx], 0
-;; e25c:	 aa                   	stosb	byte ptr [rdi], al
-;; e25d:	 800100               	add	byte ptr [rcx], 0
-;; e260:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e269:	 800100               	add	byte ptr [rcx], 0
-;; e26c:	 aa                   	stosb	byte ptr [rdi], al
-;; e26d:	 800100               	add	byte ptr [rcx], 0
-;; e270:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e279:	 800100               	add	byte ptr [rcx], 0
-;; e27c:	 aa                   	stosb	byte ptr [rdi], al
-;; e27d:	 800100               	add	byte ptr [rcx], 0
-;; e280:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e289:	 800100               	add	byte ptr [rcx], 0
-;; e28c:	 aa                   	stosb	byte ptr [rdi], al
-;; e28d:	 800100               	add	byte ptr [rcx], 0
-;; e290:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e299:	 800100               	add	byte ptr [rcx], 0
-;; e29c:	 aa                   	stosb	byte ptr [rdi], al
-;; e29d:	 800100               	add	byte ptr [rcx], 0
-;; e2a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e2a9:	 800100               	add	byte ptr [rcx], 0
-;; e2ac:	 aa                   	stosb	byte ptr [rdi], al
-;; e2ad:	 800100               	add	byte ptr [rcx], 0
-;; e2b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e2b9:	 800100               	add	byte ptr [rcx], 0
-;; e2bc:	 aa                   	stosb	byte ptr [rdi], al
-;; e2bd:	 800100               	add	byte ptr [rcx], 0
-;; e2c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e2c9:	 800100               	add	byte ptr [rcx], 0
-;; e2cc:	 aa                   	stosb	byte ptr [rdi], al
-;; e2cd:	 800100               	add	byte ptr [rcx], 0
-;; e2d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e2d9:	 800100               	add	byte ptr [rcx], 0
-;; e2dc:	 aa                   	stosb	byte ptr [rdi], al
-;; e2dd:	 800100               	add	byte ptr [rcx], 0
-;; e2e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e2e9:	 800100               	add	byte ptr [rcx], 0
-;; e2ec:	 aa                   	stosb	byte ptr [rdi], al
-;; e2ed:	 800100               	add	byte ptr [rcx], 0
-;; e2f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e2f9:	 800100               	add	byte ptr [rcx], 0
-;; e2fc:	 aa                   	stosb	byte ptr [rdi], al
-;; e2fd:	 800100               	add	byte ptr [rcx], 0
-;; e300:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e309:	 800100               	add	byte ptr [rcx], 0
-;; e30c:	 aa                   	stosb	byte ptr [rdi], al
-;; e30d:	 800100               	add	byte ptr [rcx], 0
-;; e310:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e319:	 800100               	add	byte ptr [rcx], 0
-;; e31c:	 aa                   	stosb	byte ptr [rdi], al
-;; e31d:	 800100               	add	byte ptr [rcx], 0
-;; e320:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e329:	 800100               	add	byte ptr [rcx], 0
-;; e32c:	 aa                   	stosb	byte ptr [rdi], al
-;; e32d:	 800100               	add	byte ptr [rcx], 0
-;; e330:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e339:	 800100               	add	byte ptr [rcx], 0
-;; e33c:	 aa                   	stosb	byte ptr [rdi], al
-;; e33d:	 800100               	add	byte ptr [rcx], 0
-;; e340:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e349:	 800100               	add	byte ptr [rcx], 0
-;; e34c:	 aa                   	stosb	byte ptr [rdi], al
-;; e34d:	 800100               	add	byte ptr [rcx], 0
-;; e350:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e359:	 800100               	add	byte ptr [rcx], 0
-;; e35c:	 aa                   	stosb	byte ptr [rdi], al
-;; e35d:	 800100               	add	byte ptr [rcx], 0
-;; e360:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e369:	 800100               	add	byte ptr [rcx], 0
-;; e36c:	 aa                   	stosb	byte ptr [rdi], al
-;; e36d:	 800100               	add	byte ptr [rcx], 0
-;; e370:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e379:	 800100               	add	byte ptr [rcx], 0
-;; e37c:	 aa                   	stosb	byte ptr [rdi], al
-;; e37d:	 800100               	add	byte ptr [rcx], 0
-;; e380:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e389:	 800100               	add	byte ptr [rcx], 0
-;; e38c:	 aa                   	stosb	byte ptr [rdi], al
-;; e38d:	 800100               	add	byte ptr [rcx], 0
-;; e390:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e399:	 800100               	add	byte ptr [rcx], 0
-;; e39c:	 aa                   	stosb	byte ptr [rdi], al
-;; e39d:	 800100               	add	byte ptr [rcx], 0
-;; e3a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e3a9:	 800100               	add	byte ptr [rcx], 0
-;; e3ac:	 aa                   	stosb	byte ptr [rdi], al
-;; e3ad:	 800100               	add	byte ptr [rcx], 0
-;; e3b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e3b9:	 800100               	add	byte ptr [rcx], 0
-;; e3bc:	 aa                   	stosb	byte ptr [rdi], al
-;; e3bd:	 800100               	add	byte ptr [rcx], 0
-;; e3c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e3c9:	 800100               	add	byte ptr [rcx], 0
-;; e3cc:	 aa                   	stosb	byte ptr [rdi], al
-;; e3cd:	 800100               	add	byte ptr [rcx], 0
-;; e3d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e3d9:	 800100               	add	byte ptr [rcx], 0
-;; e3dc:	 aa                   	stosb	byte ptr [rdi], al
-;; e3dd:	 800100               	add	byte ptr [rcx], 0
-;; e3e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e3e9:	 800100               	add	byte ptr [rcx], 0
-;; e3ec:	 aa                   	stosb	byte ptr [rdi], al
-;; e3ed:	 800100               	add	byte ptr [rcx], 0
-;; e3f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e3f9:	 800100               	add	byte ptr [rcx], 0
-;; e3fc:	 aa                   	stosb	byte ptr [rdi], al
-;; e3fd:	 800100               	add	byte ptr [rcx], 0
-;; e400:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e409:	 800100               	add	byte ptr [rcx], 0
-;; e40c:	 aa                   	stosb	byte ptr [rdi], al
-;; e40d:	 800100               	add	byte ptr [rcx], 0
-;; e410:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e419:	 800100               	add	byte ptr [rcx], 0
-;; e41c:	 aa                   	stosb	byte ptr [rdi], al
-;; e41d:	 800100               	add	byte ptr [rcx], 0
-;; e420:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e429:	 800100               	add	byte ptr [rcx], 0
-;; e42c:	 aa                   	stosb	byte ptr [rdi], al
-;; e42d:	 800100               	add	byte ptr [rcx], 0
-;; e430:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e439:	 800100               	add	byte ptr [rcx], 0
-;; e43c:	 aa                   	stosb	byte ptr [rdi], al
-;; e43d:	 800100               	add	byte ptr [rcx], 0
-;; e440:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e449:	 800100               	add	byte ptr [rcx], 0
-;; e44c:	 aa                   	stosb	byte ptr [rdi], al
-;; e44d:	 800100               	add	byte ptr [rcx], 0
-;; e450:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e459:	 800100               	add	byte ptr [rcx], 0
-;; e45c:	 aa                   	stosb	byte ptr [rdi], al
-;; e45d:	 800100               	add	byte ptr [rcx], 0
-;; e460:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e469:	 800100               	add	byte ptr [rcx], 0
-;; e46c:	 aa                   	stosb	byte ptr [rdi], al
-;; e46d:	 800100               	add	byte ptr [rcx], 0
-;; e470:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e479:	 800100               	add	byte ptr [rcx], 0
-;; e47c:	 aa                   	stosb	byte ptr [rdi], al
-;; e47d:	 800100               	add	byte ptr [rcx], 0
-;; e480:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e489:	 800100               	add	byte ptr [rcx], 0
-;; e48c:	 aa                   	stosb	byte ptr [rdi], al
-;; e48d:	 800100               	add	byte ptr [rcx], 0
-;; e490:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e499:	 800100               	add	byte ptr [rcx], 0
-;; e49c:	 aa                   	stosb	byte ptr [rdi], al
-;; e49d:	 800100               	add	byte ptr [rcx], 0
-;; e4a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e4a9:	 800100               	add	byte ptr [rcx], 0
-;; e4ac:	 aa                   	stosb	byte ptr [rdi], al
-;; e4ad:	 800100               	add	byte ptr [rcx], 0
-;; e4b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e4b9:	 800100               	add	byte ptr [rcx], 0
-;; e4bc:	 aa                   	stosb	byte ptr [rdi], al
-;; e4bd:	 800100               	add	byte ptr [rcx], 0
-;; e4c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e4c9:	 800100               	add	byte ptr [rcx], 0
-;; e4cc:	 aa                   	stosb	byte ptr [rdi], al
-;; e4cd:	 800100               	add	byte ptr [rcx], 0
-;; e4d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e4d9:	 800100               	add	byte ptr [rcx], 0
-;; e4dc:	 aa                   	stosb	byte ptr [rdi], al
-;; e4dd:	 800100               	add	byte ptr [rcx], 0
-;; e4e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e4e9:	 800100               	add	byte ptr [rcx], 0
-;; e4ec:	 aa                   	stosb	byte ptr [rdi], al
-;; e4ed:	 800100               	add	byte ptr [rcx], 0
-;; e4f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e4f9:	 800100               	add	byte ptr [rcx], 0
-;; e4fc:	 aa                   	stosb	byte ptr [rdi], al
-;; e4fd:	 800100               	add	byte ptr [rcx], 0
-;; e500:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e509:	 800100               	add	byte ptr [rcx], 0
-;; e50c:	 aa                   	stosb	byte ptr [rdi], al
-;; e50d:	 800100               	add	byte ptr [rcx], 0
-;; e510:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e519:	 800100               	add	byte ptr [rcx], 0
-;; e51c:	 aa                   	stosb	byte ptr [rdi], al
-;; e51d:	 800100               	add	byte ptr [rcx], 0
-;; e520:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e529:	 800100               	add	byte ptr [rcx], 0
-;; e52c:	 aa                   	stosb	byte ptr [rdi], al
-;; e52d:	 800100               	add	byte ptr [rcx], 0
-;; e530:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e539:	 800100               	add	byte ptr [rcx], 0
-;; e53c:	 aa                   	stosb	byte ptr [rdi], al
-;; e53d:	 800100               	add	byte ptr [rcx], 0
-;; e540:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e549:	 800100               	add	byte ptr [rcx], 0
-;; e54c:	 aa                   	stosb	byte ptr [rdi], al
-;; e54d:	 800100               	add	byte ptr [rcx], 0
-;; e550:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e559:	 800100               	add	byte ptr [rcx], 0
-;; e55c:	 aa                   	stosb	byte ptr [rdi], al
-;; e55d:	 800100               	add	byte ptr [rcx], 0
-;; e560:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e569:	 800100               	add	byte ptr [rcx], 0
-;; e56c:	 aa                   	stosb	byte ptr [rdi], al
-;; e56d:	 800100               	add	byte ptr [rcx], 0
-;; e570:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e579:	 800100               	add	byte ptr [rcx], 0
-;; e57c:	 aa                   	stosb	byte ptr [rdi], al
-;; e57d:	 800100               	add	byte ptr [rcx], 0
-;; e580:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e589:	 800100               	add	byte ptr [rcx], 0
-;; e58c:	 aa                   	stosb	byte ptr [rdi], al
-;; e58d:	 800100               	add	byte ptr [rcx], 0
-;; e590:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e599:	 800100               	add	byte ptr [rcx], 0
-;; e59c:	 aa                   	stosb	byte ptr [rdi], al
-;; e59d:	 800100               	add	byte ptr [rcx], 0
-;; e5a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e5a9:	 800100               	add	byte ptr [rcx], 0
-;; e5ac:	 aa                   	stosb	byte ptr [rdi], al
-;; e5ad:	 800100               	add	byte ptr [rcx], 0
-;; e5b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e5b9:	 800100               	add	byte ptr [rcx], 0
-;; e5bc:	 aa                   	stosb	byte ptr [rdi], al
-;; e5bd:	 800100               	add	byte ptr [rcx], 0
-;; e5c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e5c9:	 800100               	add	byte ptr [rcx], 0
-;; e5cc:	 aa                   	stosb	byte ptr [rdi], al
-;; e5cd:	 800100               	add	byte ptr [rcx], 0
-;; e5d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e5d9:	 800100               	add	byte ptr [rcx], 0
-;; e5dc:	 aa                   	stosb	byte ptr [rdi], al
-;; e5dd:	 800100               	add	byte ptr [rcx], 0
-;; e5e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e5e9:	 800100               	add	byte ptr [rcx], 0
-;; e5ec:	 aa                   	stosb	byte ptr [rdi], al
-;; e5ed:	 800100               	add	byte ptr [rcx], 0
-;; e5f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e5f9:	 800100               	add	byte ptr [rcx], 0
-;; e5fc:	 aa                   	stosb	byte ptr [rdi], al
-;; e5fd:	 800100               	add	byte ptr [rcx], 0
-;; e600:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e609:	 800100               	add	byte ptr [rcx], 0
-;; e60c:	 aa                   	stosb	byte ptr [rdi], al
-;; e60d:	 800100               	add	byte ptr [rcx], 0
-;; e610:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e619:	 800100               	add	byte ptr [rcx], 0
-;; e61c:	 aa                   	stosb	byte ptr [rdi], al
-;; e61d:	 800100               	add	byte ptr [rcx], 0
-;; e620:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e629:	 800100               	add	byte ptr [rcx], 0
-;; e62c:	 aa                   	stosb	byte ptr [rdi], al
-;; e62d:	 800100               	add	byte ptr [rcx], 0
-;; e630:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e639:	 800100               	add	byte ptr [rcx], 0
-;; e63c:	 aa                   	stosb	byte ptr [rdi], al
-;; e63d:	 800100               	add	byte ptr [rcx], 0
-;; e640:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e649:	 800100               	add	byte ptr [rcx], 0
-;; e64c:	 aa                   	stosb	byte ptr [rdi], al
-;; e64d:	 800100               	add	byte ptr [rcx], 0
-;; e650:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e659:	 800100               	add	byte ptr [rcx], 0
-;; e65c:	 aa                   	stosb	byte ptr [rdi], al
-;; e65d:	 800100               	add	byte ptr [rcx], 0
-;; e660:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e669:	 800100               	add	byte ptr [rcx], 0
-;; e66c:	 aa                   	stosb	byte ptr [rdi], al
-;; e66d:	 800100               	add	byte ptr [rcx], 0
-;; e670:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e679:	 800100               	add	byte ptr [rcx], 0
-;; e67c:	 aa                   	stosb	byte ptr [rdi], al
-;; e67d:	 800100               	add	byte ptr [rcx], 0
-;; e680:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e689:	 800100               	add	byte ptr [rcx], 0
-;; e68c:	 aa                   	stosb	byte ptr [rdi], al
-;; e68d:	 800100               	add	byte ptr [rcx], 0
-;; e690:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e699:	 800100               	add	byte ptr [rcx], 0
-;; e69c:	 aa                   	stosb	byte ptr [rdi], al
-;; e69d:	 800100               	add	byte ptr [rcx], 0
-;; e6a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e6a9:	 800100               	add	byte ptr [rcx], 0
-;; e6ac:	 aa                   	stosb	byte ptr [rdi], al
-;; e6ad:	 800100               	add	byte ptr [rcx], 0
-;; e6b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e6b9:	 800100               	add	byte ptr [rcx], 0
-;; e6bc:	 aa                   	stosb	byte ptr [rdi], al
-;; e6bd:	 800100               	add	byte ptr [rcx], 0
-;; e6c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e6c9:	 800100               	add	byte ptr [rcx], 0
-;; e6cc:	 aa                   	stosb	byte ptr [rdi], al
-;; e6cd:	 800100               	add	byte ptr [rcx], 0
-;; e6d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e6d9:	 800100               	add	byte ptr [rcx], 0
-;; e6dc:	 aa                   	stosb	byte ptr [rdi], al
-;; e6dd:	 800100               	add	byte ptr [rcx], 0
-;; e6e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e6e9:	 800100               	add	byte ptr [rcx], 0
-;; e6ec:	 aa                   	stosb	byte ptr [rdi], al
-;; e6ed:	 800100               	add	byte ptr [rcx], 0
-;; e6f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e6f9:	 800100               	add	byte ptr [rcx], 0
-;; e6fc:	 aa                   	stosb	byte ptr [rdi], al
-;; e6fd:	 800100               	add	byte ptr [rcx], 0
-;; e700:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e709:	 800100               	add	byte ptr [rcx], 0
-;; e70c:	 aa                   	stosb	byte ptr [rdi], al
-;; e70d:	 800100               	add	byte ptr [rcx], 0
-;; e710:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e719:	 800100               	add	byte ptr [rcx], 0
-;; e71c:	 aa                   	stosb	byte ptr [rdi], al
-;; e71d:	 800100               	add	byte ptr [rcx], 0
-;; e720:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e729:	 800100               	add	byte ptr [rcx], 0
-;; e72c:	 aa                   	stosb	byte ptr [rdi], al
-;; e72d:	 800100               	add	byte ptr [rcx], 0
-;; e730:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e739:	 800100               	add	byte ptr [rcx], 0
-;; e73c:	 aa                   	stosb	byte ptr [rdi], al
-;; e73d:	 800100               	add	byte ptr [rcx], 0
-;; e740:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e749:	 800100               	add	byte ptr [rcx], 0
-;; e74c:	 aa                   	stosb	byte ptr [rdi], al
-;; e74d:	 800100               	add	byte ptr [rcx], 0
-;; e750:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e759:	 800100               	add	byte ptr [rcx], 0
-;; e75c:	 aa                   	stosb	byte ptr [rdi], al
-;; e75d:	 800100               	add	byte ptr [rcx], 0
-;; e760:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e769:	 800100               	add	byte ptr [rcx], 0
-;; e76c:	 aa                   	stosb	byte ptr [rdi], al
-;; e76d:	 800100               	add	byte ptr [rcx], 0
-;; e770:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e779:	 800100               	add	byte ptr [rcx], 0
-;; e77c:	 aa                   	stosb	byte ptr [rdi], al
-;; e77d:	 800100               	add	byte ptr [rcx], 0
-;; e780:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e789:	 800100               	add	byte ptr [rcx], 0
-;; e78c:	 aa                   	stosb	byte ptr [rdi], al
-;; e78d:	 800100               	add	byte ptr [rcx], 0
-;; e790:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e799:	 800100               	add	byte ptr [rcx], 0
-;; e79c:	 aa                   	stosb	byte ptr [rdi], al
-;; e79d:	 800100               	add	byte ptr [rcx], 0
-;; e7a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e7a9:	 800100               	add	byte ptr [rcx], 0
-;; e7ac:	 aa                   	stosb	byte ptr [rdi], al
-;; e7ad:	 800100               	add	byte ptr [rcx], 0
-;; e7b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e7b9:	 800100               	add	byte ptr [rcx], 0
-;; e7bc:	 aa                   	stosb	byte ptr [rdi], al
-;; e7bd:	 800100               	add	byte ptr [rcx], 0
-;; e7c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e7c9:	 800100               	add	byte ptr [rcx], 0
-;; e7cc:	 aa                   	stosb	byte ptr [rdi], al
-;; e7cd:	 800100               	add	byte ptr [rcx], 0
-;; e7d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e7d9:	 800100               	add	byte ptr [rcx], 0
-;; e7dc:	 aa                   	stosb	byte ptr [rdi], al
-;; e7dd:	 800100               	add	byte ptr [rcx], 0
-;; e7e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e7e9:	 800100               	add	byte ptr [rcx], 0
-;; e7ec:	 aa                   	stosb	byte ptr [rdi], al
-;; e7ed:	 800100               	add	byte ptr [rcx], 0
-;; e7f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e7f9:	 800100               	add	byte ptr [rcx], 0
-;; e7fc:	 aa                   	stosb	byte ptr [rdi], al
-;; e7fd:	 800100               	add	byte ptr [rcx], 0
-;; e800:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e809:	 800100               	add	byte ptr [rcx], 0
-;; e80c:	 aa                   	stosb	byte ptr [rdi], al
-;; e80d:	 800100               	add	byte ptr [rcx], 0
-;; e810:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e819:	 800100               	add	byte ptr [rcx], 0
-;; e81c:	 aa                   	stosb	byte ptr [rdi], al
-;; e81d:	 800100               	add	byte ptr [rcx], 0
-;; e820:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e829:	 800100               	add	byte ptr [rcx], 0
-;; e82c:	 aa                   	stosb	byte ptr [rdi], al
-;; e82d:	 800100               	add	byte ptr [rcx], 0
-;; e830:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e839:	 800100               	add	byte ptr [rcx], 0
-;; e83c:	 aa                   	stosb	byte ptr [rdi], al
-;; e83d:	 800100               	add	byte ptr [rcx], 0
-;; e840:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e849:	 800100               	add	byte ptr [rcx], 0
-;; e84c:	 aa                   	stosb	byte ptr [rdi], al
-;; e84d:	 800100               	add	byte ptr [rcx], 0
-;; e850:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e859:	 800100               	add	byte ptr [rcx], 0
-;; e85c:	 aa                   	stosb	byte ptr [rdi], al
-;; e85d:	 800100               	add	byte ptr [rcx], 0
-;; e860:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e869:	 800100               	add	byte ptr [rcx], 0
-;; e86c:	 aa                   	stosb	byte ptr [rdi], al
-;; e86d:	 800100               	add	byte ptr [rcx], 0
-;; e870:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e879:	 800100               	add	byte ptr [rcx], 0
-;; e87c:	 aa                   	stosb	byte ptr [rdi], al
-;; e87d:	 800100               	add	byte ptr [rcx], 0
-;; e880:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e889:	 800100               	add	byte ptr [rcx], 0
-;; e88c:	 aa                   	stosb	byte ptr [rdi], al
-;; e88d:	 800100               	add	byte ptr [rcx], 0
-;; e890:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e899:	 800100               	add	byte ptr [rcx], 0
-;; e89c:	 aa                   	stosb	byte ptr [rdi], al
-;; e89d:	 800100               	add	byte ptr [rcx], 0
-;; e8a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e8a9:	 800100               	add	byte ptr [rcx], 0
-;; e8ac:	 aa                   	stosb	byte ptr [rdi], al
-;; e8ad:	 800100               	add	byte ptr [rcx], 0
-;; e8b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e8b9:	 800100               	add	byte ptr [rcx], 0
-;; e8bc:	 aa                   	stosb	byte ptr [rdi], al
-;; e8bd:	 800100               	add	byte ptr [rcx], 0
-;; e8c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e8c9:	 800100               	add	byte ptr [rcx], 0
-;; e8cc:	 aa                   	stosb	byte ptr [rdi], al
-;; e8cd:	 800100               	add	byte ptr [rcx], 0
-;; e8d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e8d9:	 800100               	add	byte ptr [rcx], 0
-;; e8dc:	 aa                   	stosb	byte ptr [rdi], al
-;; e8dd:	 800100               	add	byte ptr [rcx], 0
-;; e8e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e8e9:	 800100               	add	byte ptr [rcx], 0
-;; e8ec:	 aa                   	stosb	byte ptr [rdi], al
-;; e8ed:	 800100               	add	byte ptr [rcx], 0
-;; e8f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e8f9:	 800100               	add	byte ptr [rcx], 0
-;; e8fc:	 aa                   	stosb	byte ptr [rdi], al
-;; e8fd:	 800100               	add	byte ptr [rcx], 0
-;; e900:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e909:	 800100               	add	byte ptr [rcx], 0
-;; e90c:	 aa                   	stosb	byte ptr [rdi], al
-;; e90d:	 800100               	add	byte ptr [rcx], 0
-;; e910:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e919:	 800100               	add	byte ptr [rcx], 0
-;; e91c:	 aa                   	stosb	byte ptr [rdi], al
-;; e91d:	 800100               	add	byte ptr [rcx], 0
-;; e920:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e929:	 800100               	add	byte ptr [rcx], 0
-;; e92c:	 aa                   	stosb	byte ptr [rdi], al
-;; e92d:	 800100               	add	byte ptr [rcx], 0
-;; e930:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e939:	 800100               	add	byte ptr [rcx], 0
-;; e93c:	 aa                   	stosb	byte ptr [rdi], al
-;; e93d:	 800100               	add	byte ptr [rcx], 0
-;; e940:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e949:	 800100               	add	byte ptr [rcx], 0
-;; e94c:	 aa                   	stosb	byte ptr [rdi], al
-;; e94d:	 800100               	add	byte ptr [rcx], 0
-;; e950:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e959:	 800100               	add	byte ptr [rcx], 0
-;; e95c:	 aa                   	stosb	byte ptr [rdi], al
-;; e95d:	 800100               	add	byte ptr [rcx], 0
-;; e960:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e969:	 800100               	add	byte ptr [rcx], 0
-;; e96c:	 aa                   	stosb	byte ptr [rdi], al
-;; e96d:	 800100               	add	byte ptr [rcx], 0
-;; e970:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e979:	 800100               	add	byte ptr [rcx], 0
-;; e97c:	 aa                   	stosb	byte ptr [rdi], al
-;; e97d:	 800100               	add	byte ptr [rcx], 0
-;; e980:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e989:	 800100               	add	byte ptr [rcx], 0
-;; e98c:	 aa                   	stosb	byte ptr [rdi], al
-;; e98d:	 800100               	add	byte ptr [rcx], 0
-;; e990:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e999:	 800100               	add	byte ptr [rcx], 0
-;; e99c:	 aa                   	stosb	byte ptr [rdi], al
-;; e99d:	 800100               	add	byte ptr [rcx], 0
-;; e9a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e9a9:	 800100               	add	byte ptr [rcx], 0
-;; e9ac:	 aa                   	stosb	byte ptr [rdi], al
-;; e9ad:	 800100               	add	byte ptr [rcx], 0
-;; e9b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e9b9:	 800100               	add	byte ptr [rcx], 0
-;; e9bc:	 aa                   	stosb	byte ptr [rdi], al
-;; e9bd:	 800100               	add	byte ptr [rcx], 0
-;; e9c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e9c9:	 800100               	add	byte ptr [rcx], 0
-;; e9cc:	 aa                   	stosb	byte ptr [rdi], al
-;; e9cd:	 800100               	add	byte ptr [rcx], 0
-;; e9d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e9d9:	 800100               	add	byte ptr [rcx], 0
-;; e9dc:	 aa                   	stosb	byte ptr [rdi], al
-;; e9dd:	 800100               	add	byte ptr [rcx], 0
-;; e9e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e9e9:	 800100               	add	byte ptr [rcx], 0
-;; e9ec:	 aa                   	stosb	byte ptr [rdi], al
-;; e9ed:	 800100               	add	byte ptr [rcx], 0
-;; e9f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; e9f9:	 800100               	add	byte ptr [rcx], 0
-;; e9fc:	 aa                   	stosb	byte ptr [rdi], al
-;; e9fd:	 800100               	add	byte ptr [rcx], 0
-;; ea00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ea09:	 800100               	add	byte ptr [rcx], 0
-;; ea0c:	 aa                   	stosb	byte ptr [rdi], al
-;; ea0d:	 800100               	add	byte ptr [rcx], 0
-;; ea10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ea19:	 800100               	add	byte ptr [rcx], 0
-;; ea1c:	 aa                   	stosb	byte ptr [rdi], al
-;; ea1d:	 800100               	add	byte ptr [rcx], 0
-;; ea20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ea29:	 800100               	add	byte ptr [rcx], 0
-;; ea2c:	 aa                   	stosb	byte ptr [rdi], al
-;; ea2d:	 800100               	add	byte ptr [rcx], 0
-;; ea30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ea39:	 800100               	add	byte ptr [rcx], 0
-;; ea3c:	 aa                   	stosb	byte ptr [rdi], al
-;; ea3d:	 800100               	add	byte ptr [rcx], 0
-;; ea40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ea49:	 800100               	add	byte ptr [rcx], 0
-;; ea4c:	 aa                   	stosb	byte ptr [rdi], al
-;; ea4d:	 800100               	add	byte ptr [rcx], 0
-;; ea50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ea59:	 800100               	add	byte ptr [rcx], 0
-;; ea5c:	 aa                   	stosb	byte ptr [rdi], al
-;; ea5d:	 800100               	add	byte ptr [rcx], 0
-;; ea60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ea69:	 800100               	add	byte ptr [rcx], 0
-;; ea6c:	 aa                   	stosb	byte ptr [rdi], al
-;; ea6d:	 800100               	add	byte ptr [rcx], 0
-;; ea70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ea79:	 800100               	add	byte ptr [rcx], 0
-;; ea7c:	 aa                   	stosb	byte ptr [rdi], al
-;; ea7d:	 800100               	add	byte ptr [rcx], 0
-;; ea80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ea89:	 800100               	add	byte ptr [rcx], 0
-;; ea8c:	 aa                   	stosb	byte ptr [rdi], al
-;; ea8d:	 800100               	add	byte ptr [rcx], 0
-;; ea90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ea99:	 800100               	add	byte ptr [rcx], 0
-;; ea9c:	 aa                   	stosb	byte ptr [rdi], al
-;; ea9d:	 800100               	add	byte ptr [rcx], 0
-;; eaa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; eaa9:	 800100               	add	byte ptr [rcx], 0
-;; eaac:	 aa                   	stosb	byte ptr [rdi], al
-;; eaad:	 800100               	add	byte ptr [rcx], 0
-;; eab0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; eab9:	 800100               	add	byte ptr [rcx], 0
-;; eabc:	 aa                   	stosb	byte ptr [rdi], al
-;; eabd:	 800100               	add	byte ptr [rcx], 0
-;; eac0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; eac9:	 800100               	add	byte ptr [rcx], 0
-;; eacc:	 aa                   	stosb	byte ptr [rdi], al
-;; eacd:	 800100               	add	byte ptr [rcx], 0
-;; ead0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ead9:	 800100               	add	byte ptr [rcx], 0
-;; eadc:	 aa                   	stosb	byte ptr [rdi], al
-;; eadd:	 800100               	add	byte ptr [rcx], 0
-;; eae0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; eae9:	 800100               	add	byte ptr [rcx], 0
-;; eaec:	 aa                   	stosb	byte ptr [rdi], al
-;; eaed:	 800100               	add	byte ptr [rcx], 0
-;; eaf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; eaf9:	 800100               	add	byte ptr [rcx], 0
-;; eafc:	 aa                   	stosb	byte ptr [rdi], al
-;; eafd:	 800100               	add	byte ptr [rcx], 0
-;; eb00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; eb09:	 800100               	add	byte ptr [rcx], 0
-;; eb0c:	 aa                   	stosb	byte ptr [rdi], al
-;; eb0d:	 800100               	add	byte ptr [rcx], 0
-;; eb10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; eb19:	 800100               	add	byte ptr [rcx], 0
-;; eb1c:	 aa                   	stosb	byte ptr [rdi], al
-;; eb1d:	 800100               	add	byte ptr [rcx], 0
-;; eb20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; eb29:	 800100               	add	byte ptr [rcx], 0
-;; eb2c:	 aa                   	stosb	byte ptr [rdi], al
-;; eb2d:	 800100               	add	byte ptr [rcx], 0
-;; eb30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; eb39:	 800100               	add	byte ptr [rcx], 0
-;; eb3c:	 aa                   	stosb	byte ptr [rdi], al
-;; eb3d:	 800100               	add	byte ptr [rcx], 0
-;; eb40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; eb49:	 800100               	add	byte ptr [rcx], 0
-;; eb4c:	 aa                   	stosb	byte ptr [rdi], al
-;; eb4d:	 800100               	add	byte ptr [rcx], 0
-;; eb50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; eb59:	 800100               	add	byte ptr [rcx], 0
-;; eb5c:	 aa                   	stosb	byte ptr [rdi], al
-;; eb5d:	 800100               	add	byte ptr [rcx], 0
-;; eb60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; eb69:	 800100               	add	byte ptr [rcx], 0
-;; eb6c:	 aa                   	stosb	byte ptr [rdi], al
-;; eb6d:	 800100               	add	byte ptr [rcx], 0
-;; eb70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; eb79:	 800100               	add	byte ptr [rcx], 0
-;; eb7c:	 aa                   	stosb	byte ptr [rdi], al
-;; eb7d:	 800100               	add	byte ptr [rcx], 0
-;; eb80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; eb89:	 800100               	add	byte ptr [rcx], 0
-;; eb8c:	 aa                   	stosb	byte ptr [rdi], al
-;; eb8d:	 800100               	add	byte ptr [rcx], 0
-;; eb90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; eb99:	 800100               	add	byte ptr [rcx], 0
-;; eb9c:	 aa                   	stosb	byte ptr [rdi], al
-;; eb9d:	 800100               	add	byte ptr [rcx], 0
-;; eba0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; eba9:	 800100               	add	byte ptr [rcx], 0
-;; ebac:	 aa                   	stosb	byte ptr [rdi], al
-;; ebad:	 800100               	add	byte ptr [rcx], 0
-;; ebb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ebb9:	 800100               	add	byte ptr [rcx], 0
-;; ebbc:	 aa                   	stosb	byte ptr [rdi], al
-;; ebbd:	 800100               	add	byte ptr [rcx], 0
-;; ebc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ebc9:	 800100               	add	byte ptr [rcx], 0
-;; ebcc:	 aa                   	stosb	byte ptr [rdi], al
-;; ebcd:	 800100               	add	byte ptr [rcx], 0
-;; ebd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ebd9:	 800100               	add	byte ptr [rcx], 0
-;; ebdc:	 aa                   	stosb	byte ptr [rdi], al
-;; ebdd:	 800100               	add	byte ptr [rcx], 0
-;; ebe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ebe9:	 800100               	add	byte ptr [rcx], 0
-;; ebec:	 aa                   	stosb	byte ptr [rdi], al
-;; ebed:	 800100               	add	byte ptr [rcx], 0
-;; ebf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ebf9:	 800100               	add	byte ptr [rcx], 0
-;; ebfc:	 aa                   	stosb	byte ptr [rdi], al
-;; ebfd:	 800100               	add	byte ptr [rcx], 0
-;; ec00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ec09:	 800100               	add	byte ptr [rcx], 0
-;; ec0c:	 aa                   	stosb	byte ptr [rdi], al
-;; ec0d:	 800100               	add	byte ptr [rcx], 0
-;; ec10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ec19:	 800100               	add	byte ptr [rcx], 0
-;; ec1c:	 aa                   	stosb	byte ptr [rdi], al
-;; ec1d:	 800100               	add	byte ptr [rcx], 0
-;; ec20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ec29:	 800100               	add	byte ptr [rcx], 0
-;; ec2c:	 aa                   	stosb	byte ptr [rdi], al
-;; ec2d:	 800100               	add	byte ptr [rcx], 0
-;; ec30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ec39:	 800100               	add	byte ptr [rcx], 0
-;; ec3c:	 aa                   	stosb	byte ptr [rdi], al
-;; ec3d:	 800100               	add	byte ptr [rcx], 0
-;; ec40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ec49:	 800100               	add	byte ptr [rcx], 0
-;; ec4c:	 aa                   	stosb	byte ptr [rdi], al
-;; ec4d:	 800100               	add	byte ptr [rcx], 0
-;; ec50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ec59:	 800100               	add	byte ptr [rcx], 0
-;; ec5c:	 aa                   	stosb	byte ptr [rdi], al
-;; ec5d:	 800100               	add	byte ptr [rcx], 0
-;; ec60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ec69:	 800100               	add	byte ptr [rcx], 0
-;; ec6c:	 aa                   	stosb	byte ptr [rdi], al
-;; ec6d:	 800100               	add	byte ptr [rcx], 0
-;; ec70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ec79:	 800100               	add	byte ptr [rcx], 0
-;; ec7c:	 aa                   	stosb	byte ptr [rdi], al
-;; ec7d:	 800100               	add	byte ptr [rcx], 0
-;; ec80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ec89:	 800100               	add	byte ptr [rcx], 0
-;; ec8c:	 aa                   	stosb	byte ptr [rdi], al
-;; ec8d:	 800100               	add	byte ptr [rcx], 0
-;; ec90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ec99:	 800100               	add	byte ptr [rcx], 0
-;; ec9c:	 aa                   	stosb	byte ptr [rdi], al
-;; ec9d:	 800100               	add	byte ptr [rcx], 0
-;; eca0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; eca9:	 800100               	add	byte ptr [rcx], 0
-;; ecac:	 aa                   	stosb	byte ptr [rdi], al
-;; ecad:	 800100               	add	byte ptr [rcx], 0
-;; ecb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ecb9:	 800100               	add	byte ptr [rcx], 0
-;; ecbc:	 aa                   	stosb	byte ptr [rdi], al
-;; ecbd:	 800100               	add	byte ptr [rcx], 0
-;; ecc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ecc9:	 800100               	add	byte ptr [rcx], 0
-;; eccc:	 aa                   	stosb	byte ptr [rdi], al
-;; eccd:	 800100               	add	byte ptr [rcx], 0
-;; ecd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ecd9:	 800100               	add	byte ptr [rcx], 0
-;; ecdc:	 aa                   	stosb	byte ptr [rdi], al
-;; ecdd:	 800100               	add	byte ptr [rcx], 0
-;; ece0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ece9:	 800100               	add	byte ptr [rcx], 0
-;; ecec:	 aa                   	stosb	byte ptr [rdi], al
-;; eced:	 800100               	add	byte ptr [rcx], 0
-;; ecf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ecf9:	 800100               	add	byte ptr [rcx], 0
-;; ecfc:	 aa                   	stosb	byte ptr [rdi], al
-;; ecfd:	 800100               	add	byte ptr [rcx], 0
-;; ed00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ed09:	 800100               	add	byte ptr [rcx], 0
-;; ed0c:	 aa                   	stosb	byte ptr [rdi], al
-;; ed0d:	 800100               	add	byte ptr [rcx], 0
-;; ed10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ed19:	 800100               	add	byte ptr [rcx], 0
-;; ed1c:	 aa                   	stosb	byte ptr [rdi], al
-;; ed1d:	 800100               	add	byte ptr [rcx], 0
-;; ed20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ed29:	 800100               	add	byte ptr [rcx], 0
-;; ed2c:	 aa                   	stosb	byte ptr [rdi], al
-;; ed2d:	 800100               	add	byte ptr [rcx], 0
-;; ed30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ed39:	 800100               	add	byte ptr [rcx], 0
-;; ed3c:	 aa                   	stosb	byte ptr [rdi], al
-;; ed3d:	 800100               	add	byte ptr [rcx], 0
-;; ed40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ed49:	 800100               	add	byte ptr [rcx], 0
-;; ed4c:	 aa                   	stosb	byte ptr [rdi], al
-;; ed4d:	 800100               	add	byte ptr [rcx], 0
-;; ed50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ed59:	 800100               	add	byte ptr [rcx], 0
-;; ed5c:	 aa                   	stosb	byte ptr [rdi], al
-;; ed5d:	 800100               	add	byte ptr [rcx], 0
-;; ed60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ed69:	 800100               	add	byte ptr [rcx], 0
-;; ed6c:	 aa                   	stosb	byte ptr [rdi], al
-;; ed6d:	 800100               	add	byte ptr [rcx], 0
-;; ed70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ed79:	 800100               	add	byte ptr [rcx], 0
-;; ed7c:	 aa                   	stosb	byte ptr [rdi], al
-;; ed7d:	 800100               	add	byte ptr [rcx], 0
-;; ed80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ed89:	 800100               	add	byte ptr [rcx], 0
-;; ed8c:	 aa                   	stosb	byte ptr [rdi], al
-;; ed8d:	 800100               	add	byte ptr [rcx], 0
-;; ed90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ed99:	 800100               	add	byte ptr [rcx], 0
-;; ed9c:	 aa                   	stosb	byte ptr [rdi], al
-;; ed9d:	 800100               	add	byte ptr [rcx], 0
-;; eda0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; eda9:	 800100               	add	byte ptr [rcx], 0
-;; edac:	 aa                   	stosb	byte ptr [rdi], al
-;; edad:	 800100               	add	byte ptr [rcx], 0
-;; edb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; edb9:	 800100               	add	byte ptr [rcx], 0
-;; edbc:	 aa                   	stosb	byte ptr [rdi], al
-;; edbd:	 800100               	add	byte ptr [rcx], 0
-;; edc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; edc9:	 800100               	add	byte ptr [rcx], 0
-;; edcc:	 aa                   	stosb	byte ptr [rdi], al
-;; edcd:	 800100               	add	byte ptr [rcx], 0
-;; edd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; edd9:	 800100               	add	byte ptr [rcx], 0
-;; eddc:	 aa                   	stosb	byte ptr [rdi], al
-;; eddd:	 800100               	add	byte ptr [rcx], 0
-;; ede0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ede9:	 800100               	add	byte ptr [rcx], 0
-;; edec:	 aa                   	stosb	byte ptr [rdi], al
-;; eded:	 800100               	add	byte ptr [rcx], 0
-;; edf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; edf9:	 800100               	add	byte ptr [rcx], 0
-;; edfc:	 aa                   	stosb	byte ptr [rdi], al
-;; edfd:	 800100               	add	byte ptr [rcx], 0
-;; ee00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ee09:	 800100               	add	byte ptr [rcx], 0
-;; ee0c:	 aa                   	stosb	byte ptr [rdi], al
-;; ee0d:	 800100               	add	byte ptr [rcx], 0
-;; ee10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ee19:	 800100               	add	byte ptr [rcx], 0
-;; ee1c:	 aa                   	stosb	byte ptr [rdi], al
-;; ee1d:	 800100               	add	byte ptr [rcx], 0
-;; ee20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ee29:	 800100               	add	byte ptr [rcx], 0
-;; ee2c:	 aa                   	stosb	byte ptr [rdi], al
-;; ee2d:	 800100               	add	byte ptr [rcx], 0
-;; ee30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ee39:	 800100               	add	byte ptr [rcx], 0
-;; ee3c:	 aa                   	stosb	byte ptr [rdi], al
-;; ee3d:	 800100               	add	byte ptr [rcx], 0
-;; ee40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ee49:	 800100               	add	byte ptr [rcx], 0
-;; ee4c:	 aa                   	stosb	byte ptr [rdi], al
-;; ee4d:	 800100               	add	byte ptr [rcx], 0
-;; ee50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ee59:	 800100               	add	byte ptr [rcx], 0
-;; ee5c:	 aa                   	stosb	byte ptr [rdi], al
-;; ee5d:	 800100               	add	byte ptr [rcx], 0
-;; ee60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ee69:	 800100               	add	byte ptr [rcx], 0
-;; ee6c:	 aa                   	stosb	byte ptr [rdi], al
-;; ee6d:	 800100               	add	byte ptr [rcx], 0
-;; ee70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ee79:	 800100               	add	byte ptr [rcx], 0
-;; ee7c:	 aa                   	stosb	byte ptr [rdi], al
-;; ee7d:	 800100               	add	byte ptr [rcx], 0
-;; ee80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ee89:	 800100               	add	byte ptr [rcx], 0
-;; ee8c:	 aa                   	stosb	byte ptr [rdi], al
-;; ee8d:	 800100               	add	byte ptr [rcx], 0
-;; ee90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ee99:	 800100               	add	byte ptr [rcx], 0
-;; ee9c:	 aa                   	stosb	byte ptr [rdi], al
-;; ee9d:	 800100               	add	byte ptr [rcx], 0
-;; eea0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; eea9:	 800100               	add	byte ptr [rcx], 0
-;; eeac:	 aa                   	stosb	byte ptr [rdi], al
-;; eead:	 800100               	add	byte ptr [rcx], 0
-;; eeb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; eeb9:	 800100               	add	byte ptr [rcx], 0
-;; eebc:	 aa                   	stosb	byte ptr [rdi], al
-;; eebd:	 800100               	add	byte ptr [rcx], 0
-;; eec0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; eec9:	 800100               	add	byte ptr [rcx], 0
-;; eecc:	 aa                   	stosb	byte ptr [rdi], al
-;; eecd:	 800100               	add	byte ptr [rcx], 0
-;; eed0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; eed9:	 800100               	add	byte ptr [rcx], 0
-;; eedc:	 aa                   	stosb	byte ptr [rdi], al
-;; eedd:	 800100               	add	byte ptr [rcx], 0
-;; eee0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; eee9:	 800100               	add	byte ptr [rcx], 0
-;; eeec:	 aa                   	stosb	byte ptr [rdi], al
-;; eeed:	 800100               	add	byte ptr [rcx], 0
-;; eef0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; eef9:	 800100               	add	byte ptr [rcx], 0
-;; eefc:	 aa                   	stosb	byte ptr [rdi], al
-;; eefd:	 800100               	add	byte ptr [rcx], 0
-;; ef00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ef09:	 800100               	add	byte ptr [rcx], 0
-;; ef0c:	 aa                   	stosb	byte ptr [rdi], al
-;; ef0d:	 800100               	add	byte ptr [rcx], 0
-;; ef10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ef19:	 800100               	add	byte ptr [rcx], 0
-;; ef1c:	 aa                   	stosb	byte ptr [rdi], al
-;; ef1d:	 800100               	add	byte ptr [rcx], 0
-;; ef20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ef29:	 800100               	add	byte ptr [rcx], 0
-;; ef2c:	 aa                   	stosb	byte ptr [rdi], al
-;; ef2d:	 800100               	add	byte ptr [rcx], 0
-;; ef30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ef39:	 800100               	add	byte ptr [rcx], 0
-;; ef3c:	 aa                   	stosb	byte ptr [rdi], al
-;; ef3d:	 800100               	add	byte ptr [rcx], 0
-;; ef40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ef49:	 800100               	add	byte ptr [rcx], 0
-;; ef4c:	 aa                   	stosb	byte ptr [rdi], al
-;; ef4d:	 800100               	add	byte ptr [rcx], 0
-;; ef50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ef59:	 800100               	add	byte ptr [rcx], 0
-;; ef5c:	 aa                   	stosb	byte ptr [rdi], al
-;; ef5d:	 800100               	add	byte ptr [rcx], 0
-;; ef60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ef69:	 800100               	add	byte ptr [rcx], 0
-;; ef6c:	 aa                   	stosb	byte ptr [rdi], al
-;; ef6d:	 800100               	add	byte ptr [rcx], 0
-;; ef70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ef79:	 800100               	add	byte ptr [rcx], 0
-;; ef7c:	 aa                   	stosb	byte ptr [rdi], al
-;; ef7d:	 800100               	add	byte ptr [rcx], 0
-;; ef80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ef89:	 800100               	add	byte ptr [rcx], 0
-;; ef8c:	 aa                   	stosb	byte ptr [rdi], al
-;; ef8d:	 800100               	add	byte ptr [rcx], 0
-;; ef90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ef99:	 800100               	add	byte ptr [rcx], 0
-;; ef9c:	 aa                   	stosb	byte ptr [rdi], al
-;; ef9d:	 800100               	add	byte ptr [rcx], 0
-;; efa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; efa9:	 800100               	add	byte ptr [rcx], 0
-;; efac:	 aa                   	stosb	byte ptr [rdi], al
-;; efad:	 800100               	add	byte ptr [rcx], 0
-;; efb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; efb9:	 800100               	add	byte ptr [rcx], 0
-;; efbc:	 aa                   	stosb	byte ptr [rdi], al
-;; efbd:	 800100               	add	byte ptr [rcx], 0
-;; efc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; efc9:	 800100               	add	byte ptr [rcx], 0
-;; efcc:	 aa                   	stosb	byte ptr [rdi], al
-;; efcd:	 800100               	add	byte ptr [rcx], 0
-;; efd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; efd9:	 800100               	add	byte ptr [rcx], 0
-;; efdc:	 aa                   	stosb	byte ptr [rdi], al
-;; efdd:	 800100               	add	byte ptr [rcx], 0
-;; efe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; efe9:	 800100               	add	byte ptr [rcx], 0
-;; efec:	 aa                   	stosb	byte ptr [rdi], al
-;; efed:	 800100               	add	byte ptr [rcx], 0
-;; eff0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; eff9:	 800100               	add	byte ptr [rcx], 0
-;; effc:	 aa                   	stosb	byte ptr [rdi], al
-;; effd:	 800100               	add	byte ptr [rcx], 0
-;; f000:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f009:	 800100               	add	byte ptr [rcx], 0
-;; f00c:	 aa                   	stosb	byte ptr [rdi], al
-;; f00d:	 800100               	add	byte ptr [rcx], 0
-;; f010:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f019:	 800100               	add	byte ptr [rcx], 0
-;; f01c:	 aa                   	stosb	byte ptr [rdi], al
-;; f01d:	 800100               	add	byte ptr [rcx], 0
-;; f020:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f029:	 800100               	add	byte ptr [rcx], 0
-;; f02c:	 aa                   	stosb	byte ptr [rdi], al
-;; f02d:	 800100               	add	byte ptr [rcx], 0
-;; f030:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f039:	 800100               	add	byte ptr [rcx], 0
-;; f03c:	 aa                   	stosb	byte ptr [rdi], al
-;; f03d:	 800100               	add	byte ptr [rcx], 0
-;; f040:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f049:	 800100               	add	byte ptr [rcx], 0
-;; f04c:	 aa                   	stosb	byte ptr [rdi], al
-;; f04d:	 800100               	add	byte ptr [rcx], 0
-;; f050:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f059:	 800100               	add	byte ptr [rcx], 0
-;; f05c:	 aa                   	stosb	byte ptr [rdi], al
-;; f05d:	 800100               	add	byte ptr [rcx], 0
-;; f060:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f069:	 800100               	add	byte ptr [rcx], 0
-;; f06c:	 aa                   	stosb	byte ptr [rdi], al
-;; f06d:	 800100               	add	byte ptr [rcx], 0
-;; f070:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f079:	 800100               	add	byte ptr [rcx], 0
-;; f07c:	 aa                   	stosb	byte ptr [rdi], al
-;; f07d:	 800100               	add	byte ptr [rcx], 0
-;; f080:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f089:	 800100               	add	byte ptr [rcx], 0
-;; f08c:	 aa                   	stosb	byte ptr [rdi], al
-;; f08d:	 800100               	add	byte ptr [rcx], 0
-;; f090:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f099:	 800100               	add	byte ptr [rcx], 0
-;; f09c:	 aa                   	stosb	byte ptr [rdi], al
-;; f09d:	 800100               	add	byte ptr [rcx], 0
-;; f0a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f0a9:	 800100               	add	byte ptr [rcx], 0
-;; f0ac:	 aa                   	stosb	byte ptr [rdi], al
-;; f0ad:	 800100               	add	byte ptr [rcx], 0
-;; f0b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f0b9:	 800100               	add	byte ptr [rcx], 0
-;; f0bc:	 aa                   	stosb	byte ptr [rdi], al
-;; f0bd:	 800100               	add	byte ptr [rcx], 0
-;; f0c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f0c9:	 800100               	add	byte ptr [rcx], 0
-;; f0cc:	 aa                   	stosb	byte ptr [rdi], al
-;; f0cd:	 800100               	add	byte ptr [rcx], 0
-;; f0d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f0d9:	 800100               	add	byte ptr [rcx], 0
-;; f0dc:	 aa                   	stosb	byte ptr [rdi], al
-;; f0dd:	 800100               	add	byte ptr [rcx], 0
-;; f0e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f0e9:	 800100               	add	byte ptr [rcx], 0
-;; f0ec:	 aa                   	stosb	byte ptr [rdi], al
-;; f0ed:	 800100               	add	byte ptr [rcx], 0
-;; f0f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f0f9:	 800100               	add	byte ptr [rcx], 0
-;; f0fc:	 aa                   	stosb	byte ptr [rdi], al
-;; f0fd:	 800100               	add	byte ptr [rcx], 0
-;; f100:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f109:	 800100               	add	byte ptr [rcx], 0
-;; f10c:	 aa                   	stosb	byte ptr [rdi], al
-;; f10d:	 800100               	add	byte ptr [rcx], 0
-;; f110:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f119:	 800100               	add	byte ptr [rcx], 0
-;; f11c:	 aa                   	stosb	byte ptr [rdi], al
-;; f11d:	 800100               	add	byte ptr [rcx], 0
-;; f120:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f129:	 800100               	add	byte ptr [rcx], 0
-;; f12c:	 aa                   	stosb	byte ptr [rdi], al
-;; f12d:	 800100               	add	byte ptr [rcx], 0
-;; f130:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f139:	 800100               	add	byte ptr [rcx], 0
-;; f13c:	 aa                   	stosb	byte ptr [rdi], al
-;; f13d:	 800100               	add	byte ptr [rcx], 0
-;; f140:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f149:	 800100               	add	byte ptr [rcx], 0
-;; f14c:	 aa                   	stosb	byte ptr [rdi], al
-;; f14d:	 800100               	add	byte ptr [rcx], 0
-;; f150:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f159:	 800100               	add	byte ptr [rcx], 0
-;; f15c:	 aa                   	stosb	byte ptr [rdi], al
-;; f15d:	 800100               	add	byte ptr [rcx], 0
-;; f160:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f169:	 800100               	add	byte ptr [rcx], 0
-;; f16c:	 aa                   	stosb	byte ptr [rdi], al
-;; f16d:	 800100               	add	byte ptr [rcx], 0
-;; f170:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f179:	 800100               	add	byte ptr [rcx], 0
-;; f17c:	 aa                   	stosb	byte ptr [rdi], al
-;; f17d:	 800100               	add	byte ptr [rcx], 0
-;; f180:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f189:	 800100               	add	byte ptr [rcx], 0
-;; f18c:	 aa                   	stosb	byte ptr [rdi], al
-;; f18d:	 800100               	add	byte ptr [rcx], 0
-;; f190:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f199:	 800100               	add	byte ptr [rcx], 0
-;; f19c:	 aa                   	stosb	byte ptr [rdi], al
-;; f19d:	 800100               	add	byte ptr [rcx], 0
-;; f1a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f1a9:	 800100               	add	byte ptr [rcx], 0
-;; f1ac:	 aa                   	stosb	byte ptr [rdi], al
-;; f1ad:	 800100               	add	byte ptr [rcx], 0
-;; f1b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f1b9:	 800100               	add	byte ptr [rcx], 0
-;; f1bc:	 aa                   	stosb	byte ptr [rdi], al
-;; f1bd:	 800100               	add	byte ptr [rcx], 0
-;; f1c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f1c9:	 800100               	add	byte ptr [rcx], 0
-;; f1cc:	 aa                   	stosb	byte ptr [rdi], al
-;; f1cd:	 800100               	add	byte ptr [rcx], 0
-;; f1d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f1d9:	 800100               	add	byte ptr [rcx], 0
-;; f1dc:	 aa                   	stosb	byte ptr [rdi], al
-;; f1dd:	 800100               	add	byte ptr [rcx], 0
-;; f1e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f1e9:	 800100               	add	byte ptr [rcx], 0
-;; f1ec:	 aa                   	stosb	byte ptr [rdi], al
-;; f1ed:	 800100               	add	byte ptr [rcx], 0
-;; f1f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f1f9:	 800100               	add	byte ptr [rcx], 0
-;; f1fc:	 aa                   	stosb	byte ptr [rdi], al
-;; f1fd:	 800100               	add	byte ptr [rcx], 0
-;; f200:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f209:	 800100               	add	byte ptr [rcx], 0
-;; f20c:	 aa                   	stosb	byte ptr [rdi], al
-;; f20d:	 800100               	add	byte ptr [rcx], 0
-;; f210:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f219:	 800100               	add	byte ptr [rcx], 0
-;; f21c:	 aa                   	stosb	byte ptr [rdi], al
-;; f21d:	 800100               	add	byte ptr [rcx], 0
-;; f220:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f229:	 800100               	add	byte ptr [rcx], 0
-;; f22c:	 aa                   	stosb	byte ptr [rdi], al
-;; f22d:	 800100               	add	byte ptr [rcx], 0
-;; f230:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f239:	 800100               	add	byte ptr [rcx], 0
-;; f23c:	 aa                   	stosb	byte ptr [rdi], al
-;; f23d:	 800100               	add	byte ptr [rcx], 0
-;; f240:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f249:	 800100               	add	byte ptr [rcx], 0
-;; f24c:	 aa                   	stosb	byte ptr [rdi], al
-;; f24d:	 800100               	add	byte ptr [rcx], 0
-;; f250:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f259:	 800100               	add	byte ptr [rcx], 0
-;; f25c:	 aa                   	stosb	byte ptr [rdi], al
-;; f25d:	 800100               	add	byte ptr [rcx], 0
-;; f260:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f269:	 800100               	add	byte ptr [rcx], 0
-;; f26c:	 aa                   	stosb	byte ptr [rdi], al
-;; f26d:	 800100               	add	byte ptr [rcx], 0
-;; f270:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f279:	 800100               	add	byte ptr [rcx], 0
-;; f27c:	 aa                   	stosb	byte ptr [rdi], al
-;; f27d:	 800100               	add	byte ptr [rcx], 0
-;; f280:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f289:	 800100               	add	byte ptr [rcx], 0
-;; f28c:	 aa                   	stosb	byte ptr [rdi], al
-;; f28d:	 800100               	add	byte ptr [rcx], 0
-;; f290:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f299:	 800100               	add	byte ptr [rcx], 0
-;; f29c:	 aa                   	stosb	byte ptr [rdi], al
-;; f29d:	 800100               	add	byte ptr [rcx], 0
-;; f2a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f2a9:	 800100               	add	byte ptr [rcx], 0
-;; f2ac:	 aa                   	stosb	byte ptr [rdi], al
-;; f2ad:	 800100               	add	byte ptr [rcx], 0
-;; f2b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f2b9:	 800100               	add	byte ptr [rcx], 0
-;; f2bc:	 aa                   	stosb	byte ptr [rdi], al
-;; f2bd:	 800100               	add	byte ptr [rcx], 0
-;; f2c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f2c9:	 800100               	add	byte ptr [rcx], 0
-;; f2cc:	 aa                   	stosb	byte ptr [rdi], al
-;; f2cd:	 800100               	add	byte ptr [rcx], 0
-;; f2d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f2d9:	 800100               	add	byte ptr [rcx], 0
-;; f2dc:	 aa                   	stosb	byte ptr [rdi], al
-;; f2dd:	 800100               	add	byte ptr [rcx], 0
-;; f2e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f2e9:	 800100               	add	byte ptr [rcx], 0
-;; f2ec:	 aa                   	stosb	byte ptr [rdi], al
-;; f2ed:	 800100               	add	byte ptr [rcx], 0
-;; f2f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f2f9:	 800100               	add	byte ptr [rcx], 0
-;; f2fc:	 aa                   	stosb	byte ptr [rdi], al
-;; f2fd:	 800100               	add	byte ptr [rcx], 0
-;; f300:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f309:	 800100               	add	byte ptr [rcx], 0
-;; f30c:	 aa                   	stosb	byte ptr [rdi], al
-;; f30d:	 800100               	add	byte ptr [rcx], 0
-;; f310:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f319:	 800100               	add	byte ptr [rcx], 0
-;; f31c:	 aa                   	stosb	byte ptr [rdi], al
-;; f31d:	 800100               	add	byte ptr [rcx], 0
-;; f320:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f329:	 800100               	add	byte ptr [rcx], 0
-;; f32c:	 aa                   	stosb	byte ptr [rdi], al
-;; f32d:	 800100               	add	byte ptr [rcx], 0
-;; f330:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f339:	 800100               	add	byte ptr [rcx], 0
-;; f33c:	 aa                   	stosb	byte ptr [rdi], al
-;; f33d:	 800100               	add	byte ptr [rcx], 0
-;; f340:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f349:	 800100               	add	byte ptr [rcx], 0
-;; f34c:	 aa                   	stosb	byte ptr [rdi], al
-;; f34d:	 800100               	add	byte ptr [rcx], 0
-;; f350:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f359:	 800100               	add	byte ptr [rcx], 0
-;; f35c:	 aa                   	stosb	byte ptr [rdi], al
-;; f35d:	 800100               	add	byte ptr [rcx], 0
-;; f360:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f369:	 800100               	add	byte ptr [rcx], 0
-;; f36c:	 aa                   	stosb	byte ptr [rdi], al
-;; f36d:	 800100               	add	byte ptr [rcx], 0
-;; f370:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f379:	 800100               	add	byte ptr [rcx], 0
-;; f37c:	 aa                   	stosb	byte ptr [rdi], al
-;; f37d:	 800100               	add	byte ptr [rcx], 0
-;; f380:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f389:	 800100               	add	byte ptr [rcx], 0
-;; f38c:	 aa                   	stosb	byte ptr [rdi], al
-;; f38d:	 800100               	add	byte ptr [rcx], 0
-;; f390:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f399:	 800100               	add	byte ptr [rcx], 0
-;; f39c:	 aa                   	stosb	byte ptr [rdi], al
-;; f39d:	 800100               	add	byte ptr [rcx], 0
-;; f3a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f3a9:	 800100               	add	byte ptr [rcx], 0
-;; f3ac:	 aa                   	stosb	byte ptr [rdi], al
-;; f3ad:	 800100               	add	byte ptr [rcx], 0
-;; f3b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f3b9:	 800100               	add	byte ptr [rcx], 0
-;; f3bc:	 aa                   	stosb	byte ptr [rdi], al
-;; f3bd:	 800100               	add	byte ptr [rcx], 0
-;; f3c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f3c9:	 800100               	add	byte ptr [rcx], 0
-;; f3cc:	 aa                   	stosb	byte ptr [rdi], al
-;; f3cd:	 800100               	add	byte ptr [rcx], 0
-;; f3d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f3d9:	 800100               	add	byte ptr [rcx], 0
-;; f3dc:	 aa                   	stosb	byte ptr [rdi], al
-;; f3dd:	 800100               	add	byte ptr [rcx], 0
-;; f3e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f3e9:	 800100               	add	byte ptr [rcx], 0
-;; f3ec:	 aa                   	stosb	byte ptr [rdi], al
-;; f3ed:	 800100               	add	byte ptr [rcx], 0
-;; f3f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f3f9:	 800100               	add	byte ptr [rcx], 0
-;; f3fc:	 aa                   	stosb	byte ptr [rdi], al
-;; f3fd:	 800100               	add	byte ptr [rcx], 0
-;; f400:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f409:	 800100               	add	byte ptr [rcx], 0
-;; f40c:	 aa                   	stosb	byte ptr [rdi], al
-;; f40d:	 800100               	add	byte ptr [rcx], 0
-;; f410:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f419:	 800100               	add	byte ptr [rcx], 0
-;; f41c:	 aa                   	stosb	byte ptr [rdi], al
-;; f41d:	 800100               	add	byte ptr [rcx], 0
-;; f420:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f429:	 800100               	add	byte ptr [rcx], 0
-;; f42c:	 aa                   	stosb	byte ptr [rdi], al
-;; f42d:	 800100               	add	byte ptr [rcx], 0
-;; f430:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f439:	 800100               	add	byte ptr [rcx], 0
-;; f43c:	 aa                   	stosb	byte ptr [rdi], al
-;; f43d:	 800100               	add	byte ptr [rcx], 0
-;; f440:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f449:	 800100               	add	byte ptr [rcx], 0
-;; f44c:	 aa                   	stosb	byte ptr [rdi], al
-;; f44d:	 800100               	add	byte ptr [rcx], 0
-;; f450:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f459:	 800100               	add	byte ptr [rcx], 0
-;; f45c:	 aa                   	stosb	byte ptr [rdi], al
-;; f45d:	 800100               	add	byte ptr [rcx], 0
-;; f460:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f469:	 800100               	add	byte ptr [rcx], 0
-;; f46c:	 aa                   	stosb	byte ptr [rdi], al
-;; f46d:	 800100               	add	byte ptr [rcx], 0
-;; f470:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f479:	 800100               	add	byte ptr [rcx], 0
-;; f47c:	 aa                   	stosb	byte ptr [rdi], al
-;; f47d:	 800100               	add	byte ptr [rcx], 0
-;; f480:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f489:	 800100               	add	byte ptr [rcx], 0
-;; f48c:	 aa                   	stosb	byte ptr [rdi], al
-;; f48d:	 800100               	add	byte ptr [rcx], 0
-;; f490:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f499:	 800100               	add	byte ptr [rcx], 0
-;; f49c:	 aa                   	stosb	byte ptr [rdi], al
-;; f49d:	 800100               	add	byte ptr [rcx], 0
-;; f4a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f4a9:	 800100               	add	byte ptr [rcx], 0
-;; f4ac:	 aa                   	stosb	byte ptr [rdi], al
-;; f4ad:	 800100               	add	byte ptr [rcx], 0
-;; f4b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f4b9:	 800100               	add	byte ptr [rcx], 0
-;; f4bc:	 aa                   	stosb	byte ptr [rdi], al
-;; f4bd:	 800100               	add	byte ptr [rcx], 0
-;; f4c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f4c9:	 800100               	add	byte ptr [rcx], 0
-;; f4cc:	 aa                   	stosb	byte ptr [rdi], al
-;; f4cd:	 800100               	add	byte ptr [rcx], 0
-;; f4d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f4d9:	 800100               	add	byte ptr [rcx], 0
-;; f4dc:	 aa                   	stosb	byte ptr [rdi], al
-;; f4dd:	 800100               	add	byte ptr [rcx], 0
-;; f4e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f4e9:	 800100               	add	byte ptr [rcx], 0
-;; f4ec:	 aa                   	stosb	byte ptr [rdi], al
-;; f4ed:	 800100               	add	byte ptr [rcx], 0
-;; f4f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f4f9:	 800100               	add	byte ptr [rcx], 0
-;; f4fc:	 aa                   	stosb	byte ptr [rdi], al
-;; f4fd:	 800100               	add	byte ptr [rcx], 0
-;; f500:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f509:	 800100               	add	byte ptr [rcx], 0
-;; f50c:	 aa                   	stosb	byte ptr [rdi], al
-;; f50d:	 800100               	add	byte ptr [rcx], 0
-;; f510:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f519:	 800100               	add	byte ptr [rcx], 0
-;; f51c:	 aa                   	stosb	byte ptr [rdi], al
-;; f51d:	 800100               	add	byte ptr [rcx], 0
-;; f520:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f529:	 800100               	add	byte ptr [rcx], 0
-;; f52c:	 aa                   	stosb	byte ptr [rdi], al
-;; f52d:	 800100               	add	byte ptr [rcx], 0
-;; f530:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f539:	 800100               	add	byte ptr [rcx], 0
-;; f53c:	 aa                   	stosb	byte ptr [rdi], al
-;; f53d:	 800100               	add	byte ptr [rcx], 0
-;; f540:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f549:	 800100               	add	byte ptr [rcx], 0
-;; f54c:	 aa                   	stosb	byte ptr [rdi], al
-;; f54d:	 800100               	add	byte ptr [rcx], 0
-;; f550:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f559:	 800100               	add	byte ptr [rcx], 0
-;; f55c:	 aa                   	stosb	byte ptr [rdi], al
-;; f55d:	 800100               	add	byte ptr [rcx], 0
-;; f560:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f569:	 800100               	add	byte ptr [rcx], 0
-;; f56c:	 aa                   	stosb	byte ptr [rdi], al
-;; f56d:	 800100               	add	byte ptr [rcx], 0
-;; f570:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f579:	 800100               	add	byte ptr [rcx], 0
-;; f57c:	 aa                   	stosb	byte ptr [rdi], al
-;; f57d:	 800100               	add	byte ptr [rcx], 0
-;; f580:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f589:	 800100               	add	byte ptr [rcx], 0
-;; f58c:	 aa                   	stosb	byte ptr [rdi], al
-;; f58d:	 800100               	add	byte ptr [rcx], 0
-;; f590:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f599:	 800100               	add	byte ptr [rcx], 0
-;; f59c:	 aa                   	stosb	byte ptr [rdi], al
-;; f59d:	 800100               	add	byte ptr [rcx], 0
-;; f5a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f5a9:	 800100               	add	byte ptr [rcx], 0
-;; f5ac:	 aa                   	stosb	byte ptr [rdi], al
-;; f5ad:	 800100               	add	byte ptr [rcx], 0
-;; f5b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f5b9:	 800100               	add	byte ptr [rcx], 0
-;; f5bc:	 aa                   	stosb	byte ptr [rdi], al
-;; f5bd:	 800100               	add	byte ptr [rcx], 0
-;; f5c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f5c9:	 800100               	add	byte ptr [rcx], 0
-;; f5cc:	 aa                   	stosb	byte ptr [rdi], al
-;; f5cd:	 800100               	add	byte ptr [rcx], 0
-;; f5d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f5d9:	 800100               	add	byte ptr [rcx], 0
-;; f5dc:	 aa                   	stosb	byte ptr [rdi], al
-;; f5dd:	 800100               	add	byte ptr [rcx], 0
-;; f5e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f5e9:	 800100               	add	byte ptr [rcx], 0
-;; f5ec:	 aa                   	stosb	byte ptr [rdi], al
-;; f5ed:	 800100               	add	byte ptr [rcx], 0
-;; f5f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f5f9:	 800100               	add	byte ptr [rcx], 0
-;; f5fc:	 aa                   	stosb	byte ptr [rdi], al
-;; f5fd:	 800100               	add	byte ptr [rcx], 0
-;; f600:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f609:	 800100               	add	byte ptr [rcx], 0
-;; f60c:	 aa                   	stosb	byte ptr [rdi], al
-;; f60d:	 800100               	add	byte ptr [rcx], 0
-;; f610:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f619:	 800100               	add	byte ptr [rcx], 0
-;; f61c:	 aa                   	stosb	byte ptr [rdi], al
-;; f61d:	 800100               	add	byte ptr [rcx], 0
-;; f620:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f629:	 800100               	add	byte ptr [rcx], 0
-;; f62c:	 aa                   	stosb	byte ptr [rdi], al
-;; f62d:	 800100               	add	byte ptr [rcx], 0
-;; f630:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f639:	 800100               	add	byte ptr [rcx], 0
-;; f63c:	 aa                   	stosb	byte ptr [rdi], al
-;; f63d:	 800100               	add	byte ptr [rcx], 0
-;; f640:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f649:	 800100               	add	byte ptr [rcx], 0
-;; f64c:	 aa                   	stosb	byte ptr [rdi], al
-;; f64d:	 800100               	add	byte ptr [rcx], 0
-;; f650:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f659:	 800100               	add	byte ptr [rcx], 0
-;; f65c:	 aa                   	stosb	byte ptr [rdi], al
-;; f65d:	 800100               	add	byte ptr [rcx], 0
-;; f660:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f669:	 800100               	add	byte ptr [rcx], 0
-;; f66c:	 aa                   	stosb	byte ptr [rdi], al
-;; f66d:	 800100               	add	byte ptr [rcx], 0
-;; f670:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f679:	 800100               	add	byte ptr [rcx], 0
-;; f67c:	 aa                   	stosb	byte ptr [rdi], al
-;; f67d:	 800100               	add	byte ptr [rcx], 0
-;; f680:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f689:	 800100               	add	byte ptr [rcx], 0
-;; f68c:	 aa                   	stosb	byte ptr [rdi], al
-;; f68d:	 800100               	add	byte ptr [rcx], 0
-;; f690:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f699:	 800100               	add	byte ptr [rcx], 0
-;; f69c:	 aa                   	stosb	byte ptr [rdi], al
-;; f69d:	 800100               	add	byte ptr [rcx], 0
-;; f6a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f6a9:	 800100               	add	byte ptr [rcx], 0
-;; f6ac:	 aa                   	stosb	byte ptr [rdi], al
-;; f6ad:	 800100               	add	byte ptr [rcx], 0
-;; f6b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f6b9:	 800100               	add	byte ptr [rcx], 0
-;; f6bc:	 aa                   	stosb	byte ptr [rdi], al
-;; f6bd:	 800100               	add	byte ptr [rcx], 0
-;; f6c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f6c9:	 800100               	add	byte ptr [rcx], 0
-;; f6cc:	 aa                   	stosb	byte ptr [rdi], al
-;; f6cd:	 800100               	add	byte ptr [rcx], 0
-;; f6d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f6d9:	 800100               	add	byte ptr [rcx], 0
-;; f6dc:	 aa                   	stosb	byte ptr [rdi], al
-;; f6dd:	 800100               	add	byte ptr [rcx], 0
-;; f6e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f6e9:	 800100               	add	byte ptr [rcx], 0
-;; f6ec:	 aa                   	stosb	byte ptr [rdi], al
-;; f6ed:	 800100               	add	byte ptr [rcx], 0
-;; f6f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f6f9:	 800100               	add	byte ptr [rcx], 0
-;; f6fc:	 aa                   	stosb	byte ptr [rdi], al
-;; f6fd:	 800100               	add	byte ptr [rcx], 0
-;; f700:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f709:	 800100               	add	byte ptr [rcx], 0
-;; f70c:	 aa                   	stosb	byte ptr [rdi], al
-;; f70d:	 800100               	add	byte ptr [rcx], 0
-;; f710:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f719:	 800100               	add	byte ptr [rcx], 0
-;; f71c:	 aa                   	stosb	byte ptr [rdi], al
-;; f71d:	 800100               	add	byte ptr [rcx], 0
-;; f720:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f729:	 800100               	add	byte ptr [rcx], 0
-;; f72c:	 aa                   	stosb	byte ptr [rdi], al
-;; f72d:	 800100               	add	byte ptr [rcx], 0
-;; f730:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f739:	 800100               	add	byte ptr [rcx], 0
-;; f73c:	 aa                   	stosb	byte ptr [rdi], al
-;; f73d:	 800100               	add	byte ptr [rcx], 0
-;; f740:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f749:	 800100               	add	byte ptr [rcx], 0
-;; f74c:	 aa                   	stosb	byte ptr [rdi], al
-;; f74d:	 800100               	add	byte ptr [rcx], 0
-;; f750:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f759:	 800100               	add	byte ptr [rcx], 0
-;; f75c:	 aa                   	stosb	byte ptr [rdi], al
-;; f75d:	 800100               	add	byte ptr [rcx], 0
-;; f760:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f769:	 800100               	add	byte ptr [rcx], 0
-;; f76c:	 aa                   	stosb	byte ptr [rdi], al
-;; f76d:	 800100               	add	byte ptr [rcx], 0
-;; f770:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f779:	 800100               	add	byte ptr [rcx], 0
-;; f77c:	 aa                   	stosb	byte ptr [rdi], al
-;; f77d:	 800100               	add	byte ptr [rcx], 0
-;; f780:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f789:	 800100               	add	byte ptr [rcx], 0
-;; f78c:	 aa                   	stosb	byte ptr [rdi], al
-;; f78d:	 800100               	add	byte ptr [rcx], 0
-;; f790:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f799:	 800100               	add	byte ptr [rcx], 0
-;; f79c:	 aa                   	stosb	byte ptr [rdi], al
-;; f79d:	 800100               	add	byte ptr [rcx], 0
-;; f7a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f7a9:	 800100               	add	byte ptr [rcx], 0
-;; f7ac:	 aa                   	stosb	byte ptr [rdi], al
-;; f7ad:	 800100               	add	byte ptr [rcx], 0
-;; f7b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f7b9:	 800100               	add	byte ptr [rcx], 0
-;; f7bc:	 aa                   	stosb	byte ptr [rdi], al
-;; f7bd:	 800100               	add	byte ptr [rcx], 0
-;; f7c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f7c9:	 800100               	add	byte ptr [rcx], 0
-;; f7cc:	 aa                   	stosb	byte ptr [rdi], al
-;; f7cd:	 800100               	add	byte ptr [rcx], 0
-;; f7d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f7d9:	 800100               	add	byte ptr [rcx], 0
-;; f7dc:	 aa                   	stosb	byte ptr [rdi], al
-;; f7dd:	 800100               	add	byte ptr [rcx], 0
-;; f7e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f7e9:	 800100               	add	byte ptr [rcx], 0
-;; f7ec:	 aa                   	stosb	byte ptr [rdi], al
-;; f7ed:	 800100               	add	byte ptr [rcx], 0
-;; f7f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f7f9:	 800100               	add	byte ptr [rcx], 0
-;; f7fc:	 aa                   	stosb	byte ptr [rdi], al
-;; f7fd:	 800100               	add	byte ptr [rcx], 0
-;; f800:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f809:	 800100               	add	byte ptr [rcx], 0
-;; f80c:	 aa                   	stosb	byte ptr [rdi], al
-;; f80d:	 800100               	add	byte ptr [rcx], 0
-;; f810:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f819:	 800100               	add	byte ptr [rcx], 0
-;; f81c:	 aa                   	stosb	byte ptr [rdi], al
-;; f81d:	 800100               	add	byte ptr [rcx], 0
-;; f820:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f829:	 800100               	add	byte ptr [rcx], 0
-;; f82c:	 aa                   	stosb	byte ptr [rdi], al
-;; f82d:	 800100               	add	byte ptr [rcx], 0
-;; f830:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f839:	 800100               	add	byte ptr [rcx], 0
-;; f83c:	 aa                   	stosb	byte ptr [rdi], al
-;; f83d:	 800100               	add	byte ptr [rcx], 0
-;; f840:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f849:	 800100               	add	byte ptr [rcx], 0
-;; f84c:	 aa                   	stosb	byte ptr [rdi], al
-;; f84d:	 800100               	add	byte ptr [rcx], 0
-;; f850:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f859:	 800100               	add	byte ptr [rcx], 0
-;; f85c:	 aa                   	stosb	byte ptr [rdi], al
-;; f85d:	 800100               	add	byte ptr [rcx], 0
-;; f860:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f869:	 800100               	add	byte ptr [rcx], 0
-;; f86c:	 aa                   	stosb	byte ptr [rdi], al
-;; f86d:	 800100               	add	byte ptr [rcx], 0
-;; f870:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f879:	 800100               	add	byte ptr [rcx], 0
-;; f87c:	 aa                   	stosb	byte ptr [rdi], al
-;; f87d:	 800100               	add	byte ptr [rcx], 0
-;; f880:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f889:	 800100               	add	byte ptr [rcx], 0
-;; f88c:	 aa                   	stosb	byte ptr [rdi], al
-;; f88d:	 800100               	add	byte ptr [rcx], 0
-;; f890:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f899:	 800100               	add	byte ptr [rcx], 0
-;; f89c:	 aa                   	stosb	byte ptr [rdi], al
-;; f89d:	 800100               	add	byte ptr [rcx], 0
-;; f8a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f8a9:	 800100               	add	byte ptr [rcx], 0
-;; f8ac:	 aa                   	stosb	byte ptr [rdi], al
-;; f8ad:	 800100               	add	byte ptr [rcx], 0
-;; f8b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f8b9:	 800100               	add	byte ptr [rcx], 0
-;; f8bc:	 aa                   	stosb	byte ptr [rdi], al
-;; f8bd:	 800100               	add	byte ptr [rcx], 0
-;; f8c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f8c9:	 800100               	add	byte ptr [rcx], 0
-;; f8cc:	 aa                   	stosb	byte ptr [rdi], al
-;; f8cd:	 800100               	add	byte ptr [rcx], 0
-;; f8d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f8d9:	 800100               	add	byte ptr [rcx], 0
-;; f8dc:	 aa                   	stosb	byte ptr [rdi], al
-;; f8dd:	 800100               	add	byte ptr [rcx], 0
-;; f8e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f8e9:	 800100               	add	byte ptr [rcx], 0
-;; f8ec:	 aa                   	stosb	byte ptr [rdi], al
-;; f8ed:	 800100               	add	byte ptr [rcx], 0
-;; f8f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f8f9:	 800100               	add	byte ptr [rcx], 0
-;; f8fc:	 aa                   	stosb	byte ptr [rdi], al
-;; f8fd:	 800100               	add	byte ptr [rcx], 0
-;; f900:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f909:	 800100               	add	byte ptr [rcx], 0
-;; f90c:	 aa                   	stosb	byte ptr [rdi], al
-;; f90d:	 800100               	add	byte ptr [rcx], 0
-;; f910:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f919:	 800100               	add	byte ptr [rcx], 0
-;; f91c:	 aa                   	stosb	byte ptr [rdi], al
-;; f91d:	 800100               	add	byte ptr [rcx], 0
-;; f920:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f929:	 800100               	add	byte ptr [rcx], 0
-;; f92c:	 aa                   	stosb	byte ptr [rdi], al
-;; f92d:	 800100               	add	byte ptr [rcx], 0
-;; f930:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f939:	 800100               	add	byte ptr [rcx], 0
-;; f93c:	 aa                   	stosb	byte ptr [rdi], al
-;; f93d:	 800100               	add	byte ptr [rcx], 0
-;; f940:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f949:	 800100               	add	byte ptr [rcx], 0
-;; f94c:	 aa                   	stosb	byte ptr [rdi], al
-;; f94d:	 800100               	add	byte ptr [rcx], 0
-;; f950:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f959:	 800100               	add	byte ptr [rcx], 0
-;; f95c:	 aa                   	stosb	byte ptr [rdi], al
-;; f95d:	 800100               	add	byte ptr [rcx], 0
-;; f960:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f969:	 800100               	add	byte ptr [rcx], 0
-;; f96c:	 aa                   	stosb	byte ptr [rdi], al
-;; f96d:	 800100               	add	byte ptr [rcx], 0
-;; f970:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f979:	 800100               	add	byte ptr [rcx], 0
-;; f97c:	 aa                   	stosb	byte ptr [rdi], al
-;; f97d:	 800100               	add	byte ptr [rcx], 0
-;; f980:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f989:	 800100               	add	byte ptr [rcx], 0
-;; f98c:	 aa                   	stosb	byte ptr [rdi], al
-;; f98d:	 800100               	add	byte ptr [rcx], 0
-;; f990:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f999:	 800100               	add	byte ptr [rcx], 0
-;; f99c:	 aa                   	stosb	byte ptr [rdi], al
-;; f99d:	 800100               	add	byte ptr [rcx], 0
-;; f9a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f9a9:	 800100               	add	byte ptr [rcx], 0
-;; f9ac:	 aa                   	stosb	byte ptr [rdi], al
-;; f9ad:	 800100               	add	byte ptr [rcx], 0
-;; f9b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f9b9:	 800100               	add	byte ptr [rcx], 0
-;; f9bc:	 aa                   	stosb	byte ptr [rdi], al
-;; f9bd:	 800100               	add	byte ptr [rcx], 0
-;; f9c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f9c9:	 800100               	add	byte ptr [rcx], 0
-;; f9cc:	 aa                   	stosb	byte ptr [rdi], al
-;; f9cd:	 800100               	add	byte ptr [rcx], 0
-;; f9d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f9d9:	 800100               	add	byte ptr [rcx], 0
-;; f9dc:	 aa                   	stosb	byte ptr [rdi], al
-;; f9dd:	 800100               	add	byte ptr [rcx], 0
-;; f9e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f9e9:	 800100               	add	byte ptr [rcx], 0
-;; f9ec:	 aa                   	stosb	byte ptr [rdi], al
-;; f9ed:	 800100               	add	byte ptr [rcx], 0
-;; f9f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; f9f9:	 800100               	add	byte ptr [rcx], 0
-;; f9fc:	 aa                   	stosb	byte ptr [rdi], al
-;; f9fd:	 800100               	add	byte ptr [rcx], 0
-;; fa00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fa09:	 800100               	add	byte ptr [rcx], 0
-;; fa0c:	 aa                   	stosb	byte ptr [rdi], al
-;; fa0d:	 800100               	add	byte ptr [rcx], 0
-;; fa10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fa19:	 800100               	add	byte ptr [rcx], 0
-;; fa1c:	 aa                   	stosb	byte ptr [rdi], al
-;; fa1d:	 800100               	add	byte ptr [rcx], 0
-;; fa20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fa29:	 800100               	add	byte ptr [rcx], 0
-;; fa2c:	 aa                   	stosb	byte ptr [rdi], al
-;; fa2d:	 800100               	add	byte ptr [rcx], 0
-;; fa30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fa39:	 800100               	add	byte ptr [rcx], 0
-;; fa3c:	 aa                   	stosb	byte ptr [rdi], al
-;; fa3d:	 800100               	add	byte ptr [rcx], 0
-;; fa40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fa49:	 800100               	add	byte ptr [rcx], 0
-;; fa4c:	 aa                   	stosb	byte ptr [rdi], al
-;; fa4d:	 800100               	add	byte ptr [rcx], 0
-;; fa50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fa59:	 800100               	add	byte ptr [rcx], 0
-;; fa5c:	 aa                   	stosb	byte ptr [rdi], al
-;; fa5d:	 800100               	add	byte ptr [rcx], 0
-;; fa60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fa69:	 800100               	add	byte ptr [rcx], 0
-;; fa6c:	 aa                   	stosb	byte ptr [rdi], al
-;; fa6d:	 800100               	add	byte ptr [rcx], 0
-;; fa70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fa79:	 800100               	add	byte ptr [rcx], 0
-;; fa7c:	 aa                   	stosb	byte ptr [rdi], al
-;; fa7d:	 800100               	add	byte ptr [rcx], 0
-;; fa80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fa89:	 800100               	add	byte ptr [rcx], 0
-;; fa8c:	 aa                   	stosb	byte ptr [rdi], al
-;; fa8d:	 800100               	add	byte ptr [rcx], 0
-;; fa90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fa99:	 800100               	add	byte ptr [rcx], 0
-;; fa9c:	 aa                   	stosb	byte ptr [rdi], al
-;; fa9d:	 800100               	add	byte ptr [rcx], 0
-;; faa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; faa9:	 800100               	add	byte ptr [rcx], 0
-;; faac:	 aa                   	stosb	byte ptr [rdi], al
-;; faad:	 800100               	add	byte ptr [rcx], 0
-;; fab0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fab9:	 800100               	add	byte ptr [rcx], 0
-;; fabc:	 aa                   	stosb	byte ptr [rdi], al
-;; fabd:	 800100               	add	byte ptr [rcx], 0
-;; fac0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fac9:	 800100               	add	byte ptr [rcx], 0
-;; facc:	 aa                   	stosb	byte ptr [rdi], al
-;; facd:	 800100               	add	byte ptr [rcx], 0
-;; fad0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fad9:	 800100               	add	byte ptr [rcx], 0
-;; fadc:	 aa                   	stosb	byte ptr [rdi], al
-;; fadd:	 800100               	add	byte ptr [rcx], 0
-;; fae0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fae9:	 800100               	add	byte ptr [rcx], 0
-;; faec:	 aa                   	stosb	byte ptr [rdi], al
-;; faed:	 800100               	add	byte ptr [rcx], 0
-;; faf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; faf9:	 800100               	add	byte ptr [rcx], 0
-;; fafc:	 aa                   	stosb	byte ptr [rdi], al
-;; fafd:	 800100               	add	byte ptr [rcx], 0
-;; fb00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fb09:	 800100               	add	byte ptr [rcx], 0
-;; fb0c:	 aa                   	stosb	byte ptr [rdi], al
-;; fb0d:	 800100               	add	byte ptr [rcx], 0
-;; fb10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fb19:	 800100               	add	byte ptr [rcx], 0
-;; fb1c:	 aa                   	stosb	byte ptr [rdi], al
-;; fb1d:	 800100               	add	byte ptr [rcx], 0
-;; fb20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fb29:	 800100               	add	byte ptr [rcx], 0
-;; fb2c:	 aa                   	stosb	byte ptr [rdi], al
-;; fb2d:	 800100               	add	byte ptr [rcx], 0
-;; fb30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fb39:	 800100               	add	byte ptr [rcx], 0
-;; fb3c:	 aa                   	stosb	byte ptr [rdi], al
-;; fb3d:	 800100               	add	byte ptr [rcx], 0
-;; fb40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fb49:	 800100               	add	byte ptr [rcx], 0
-;; fb4c:	 aa                   	stosb	byte ptr [rdi], al
-;; fb4d:	 800100               	add	byte ptr [rcx], 0
-;; fb50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fb59:	 800100               	add	byte ptr [rcx], 0
-;; fb5c:	 aa                   	stosb	byte ptr [rdi], al
-;; fb5d:	 800100               	add	byte ptr [rcx], 0
-;; fb60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fb69:	 800100               	add	byte ptr [rcx], 0
-;; fb6c:	 aa                   	stosb	byte ptr [rdi], al
-;; fb6d:	 800100               	add	byte ptr [rcx], 0
-;; fb70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fb79:	 800100               	add	byte ptr [rcx], 0
-;; fb7c:	 aa                   	stosb	byte ptr [rdi], al
-;; fb7d:	 800100               	add	byte ptr [rcx], 0
-;; fb80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fb89:	 800100               	add	byte ptr [rcx], 0
-;; fb8c:	 aa                   	stosb	byte ptr [rdi], al
-;; fb8d:	 800100               	add	byte ptr [rcx], 0
-;; fb90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fb99:	 800100               	add	byte ptr [rcx], 0
-;; fb9c:	 aa                   	stosb	byte ptr [rdi], al
-;; fb9d:	 800100               	add	byte ptr [rcx], 0
-;; fba0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fba9:	 800100               	add	byte ptr [rcx], 0
-;; fbac:	 aa                   	stosb	byte ptr [rdi], al
-;; fbad:	 800100               	add	byte ptr [rcx], 0
-;; fbb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fbb9:	 800100               	add	byte ptr [rcx], 0
-;; fbbc:	 aa                   	stosb	byte ptr [rdi], al
-;; fbbd:	 800100               	add	byte ptr [rcx], 0
-;; fbc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fbc9:	 800100               	add	byte ptr [rcx], 0
-;; fbcc:	 aa                   	stosb	byte ptr [rdi], al
-;; fbcd:	 800100               	add	byte ptr [rcx], 0
-;; fbd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fbd9:	 800100               	add	byte ptr [rcx], 0
-;; fbdc:	 aa                   	stosb	byte ptr [rdi], al
-;; fbdd:	 800100               	add	byte ptr [rcx], 0
-;; fbe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fbe9:	 800100               	add	byte ptr [rcx], 0
-;; fbec:	 aa                   	stosb	byte ptr [rdi], al
-;; fbed:	 800100               	add	byte ptr [rcx], 0
-;; fbf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fbf9:	 800100               	add	byte ptr [rcx], 0
-;; fbfc:	 aa                   	stosb	byte ptr [rdi], al
-;; fbfd:	 800100               	add	byte ptr [rcx], 0
-;; fc00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fc09:	 800100               	add	byte ptr [rcx], 0
-;; fc0c:	 aa                   	stosb	byte ptr [rdi], al
-;; fc0d:	 800100               	add	byte ptr [rcx], 0
-;; fc10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fc19:	 800100               	add	byte ptr [rcx], 0
-;; fc1c:	 aa                   	stosb	byte ptr [rdi], al
-;; fc1d:	 800100               	add	byte ptr [rcx], 0
-;; fc20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fc29:	 800100               	add	byte ptr [rcx], 0
-;; fc2c:	 aa                   	stosb	byte ptr [rdi], al
-;; fc2d:	 800100               	add	byte ptr [rcx], 0
-;; fc30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fc39:	 800100               	add	byte ptr [rcx], 0
-;; fc3c:	 aa                   	stosb	byte ptr [rdi], al
-;; fc3d:	 800100               	add	byte ptr [rcx], 0
-;; fc40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fc49:	 800100               	add	byte ptr [rcx], 0
-;; fc4c:	 aa                   	stosb	byte ptr [rdi], al
-;; fc4d:	 800100               	add	byte ptr [rcx], 0
-;; fc50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fc59:	 800100               	add	byte ptr [rcx], 0
-;; fc5c:	 aa                   	stosb	byte ptr [rdi], al
-;; fc5d:	 800100               	add	byte ptr [rcx], 0
-;; fc60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fc69:	 800100               	add	byte ptr [rcx], 0
-;; fc6c:	 aa                   	stosb	byte ptr [rdi], al
-;; fc6d:	 800100               	add	byte ptr [rcx], 0
-;; fc70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fc79:	 800100               	add	byte ptr [rcx], 0
-;; fc7c:	 aa                   	stosb	byte ptr [rdi], al
-;; fc7d:	 800100               	add	byte ptr [rcx], 0
-;; fc80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fc89:	 800100               	add	byte ptr [rcx], 0
-;; fc8c:	 aa                   	stosb	byte ptr [rdi], al
-;; fc8d:	 800100               	add	byte ptr [rcx], 0
-;; fc90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fc99:	 800100               	add	byte ptr [rcx], 0
-;; fc9c:	 aa                   	stosb	byte ptr [rdi], al
-;; fc9d:	 800100               	add	byte ptr [rcx], 0
-;; fca0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fca9:	 800100               	add	byte ptr [rcx], 0
-;; fcac:	 aa                   	stosb	byte ptr [rdi], al
-;; fcad:	 800100               	add	byte ptr [rcx], 0
-;; fcb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fcb9:	 800100               	add	byte ptr [rcx], 0
-;; fcbc:	 aa                   	stosb	byte ptr [rdi], al
-;; fcbd:	 800100               	add	byte ptr [rcx], 0
-;; fcc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fcc9:	 800100               	add	byte ptr [rcx], 0
-;; fccc:	 aa                   	stosb	byte ptr [rdi], al
-;; fccd:	 800100               	add	byte ptr [rcx], 0
-;; fcd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fcd9:	 800100               	add	byte ptr [rcx], 0
-;; fcdc:	 aa                   	stosb	byte ptr [rdi], al
-;; fcdd:	 800100               	add	byte ptr [rcx], 0
-;; fce0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fce9:	 800100               	add	byte ptr [rcx], 0
-;; fcec:	 aa                   	stosb	byte ptr [rdi], al
-;; fced:	 800100               	add	byte ptr [rcx], 0
-;; fcf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fcf9:	 800100               	add	byte ptr [rcx], 0
-;; fcfc:	 aa                   	stosb	byte ptr [rdi], al
-;; fcfd:	 800100               	add	byte ptr [rcx], 0
-;; fd00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fd09:	 800100               	add	byte ptr [rcx], 0
-;; fd0c:	 aa                   	stosb	byte ptr [rdi], al
-;; fd0d:	 800100               	add	byte ptr [rcx], 0
-;; fd10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fd19:	 800100               	add	byte ptr [rcx], 0
-;; fd1c:	 aa                   	stosb	byte ptr [rdi], al
-;; fd1d:	 800100               	add	byte ptr [rcx], 0
-;; fd20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fd29:	 800100               	add	byte ptr [rcx], 0
-;; fd2c:	 aa                   	stosb	byte ptr [rdi], al
-;; fd2d:	 800100               	add	byte ptr [rcx], 0
-;; fd30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fd39:	 800100               	add	byte ptr [rcx], 0
-;; fd3c:	 aa                   	stosb	byte ptr [rdi], al
-;; fd3d:	 800100               	add	byte ptr [rcx], 0
-;; fd40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fd49:	 800100               	add	byte ptr [rcx], 0
-;; fd4c:	 aa                   	stosb	byte ptr [rdi], al
-;; fd4d:	 800100               	add	byte ptr [rcx], 0
-;; fd50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fd59:	 800100               	add	byte ptr [rcx], 0
-;; fd5c:	 aa                   	stosb	byte ptr [rdi], al
-;; fd5d:	 800100               	add	byte ptr [rcx], 0
-;; fd60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fd69:	 800100               	add	byte ptr [rcx], 0
-;; fd6c:	 aa                   	stosb	byte ptr [rdi], al
-;; fd6d:	 800100               	add	byte ptr [rcx], 0
-;; fd70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fd79:	 800100               	add	byte ptr [rcx], 0
-;; fd7c:	 aa                   	stosb	byte ptr [rdi], al
-;; fd7d:	 800100               	add	byte ptr [rcx], 0
-;; fd80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fd89:	 800100               	add	byte ptr [rcx], 0
-;; fd8c:	 aa                   	stosb	byte ptr [rdi], al
-;; fd8d:	 800100               	add	byte ptr [rcx], 0
-;; fd90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fd99:	 800100               	add	byte ptr [rcx], 0
-;; fd9c:	 aa                   	stosb	byte ptr [rdi], al
-;; fd9d:	 800100               	add	byte ptr [rcx], 0
-;; fda0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fda9:	 800100               	add	byte ptr [rcx], 0
-;; fdac:	 aa                   	stosb	byte ptr [rdi], al
-;; fdad:	 800100               	add	byte ptr [rcx], 0
-;; fdb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fdb9:	 800100               	add	byte ptr [rcx], 0
-;; fdbc:	 aa                   	stosb	byte ptr [rdi], al
-;; fdbd:	 800100               	add	byte ptr [rcx], 0
-;; fdc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fdc9:	 800100               	add	byte ptr [rcx], 0
-;; fdcc:	 aa                   	stosb	byte ptr [rdi], al
-;; fdcd:	 800100               	add	byte ptr [rcx], 0
-;; fdd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fdd9:	 800100               	add	byte ptr [rcx], 0
-;; fddc:	 aa                   	stosb	byte ptr [rdi], al
-;; fddd:	 800100               	add	byte ptr [rcx], 0
-;; fde0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fde9:	 800100               	add	byte ptr [rcx], 0
-;; fdec:	 aa                   	stosb	byte ptr [rdi], al
-;; fded:	 800100               	add	byte ptr [rcx], 0
-;; fdf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fdf9:	 800100               	add	byte ptr [rcx], 0
-;; fdfc:	 aa                   	stosb	byte ptr [rdi], al
-;; fdfd:	 800100               	add	byte ptr [rcx], 0
-;; fe00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fe09:	 800100               	add	byte ptr [rcx], 0
-;; fe0c:	 aa                   	stosb	byte ptr [rdi], al
-;; fe0d:	 800100               	add	byte ptr [rcx], 0
-;; fe10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fe19:	 800100               	add	byte ptr [rcx], 0
-;; fe1c:	 aa                   	stosb	byte ptr [rdi], al
-;; fe1d:	 800100               	add	byte ptr [rcx], 0
-;; fe20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fe29:	 800100               	add	byte ptr [rcx], 0
-;; fe2c:	 aa                   	stosb	byte ptr [rdi], al
-;; fe2d:	 800100               	add	byte ptr [rcx], 0
-;; fe30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fe39:	 800100               	add	byte ptr [rcx], 0
-;; fe3c:	 aa                   	stosb	byte ptr [rdi], al
-;; fe3d:	 800100               	add	byte ptr [rcx], 0
-;; fe40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fe49:	 800100               	add	byte ptr [rcx], 0
-;; fe4c:	 aa                   	stosb	byte ptr [rdi], al
-;; fe4d:	 800100               	add	byte ptr [rcx], 0
-;; fe50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fe59:	 800100               	add	byte ptr [rcx], 0
-;; fe5c:	 aa                   	stosb	byte ptr [rdi], al
-;; fe5d:	 800100               	add	byte ptr [rcx], 0
-;; fe60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fe69:	 800100               	add	byte ptr [rcx], 0
-;; fe6c:	 aa                   	stosb	byte ptr [rdi], al
-;; fe6d:	 800100               	add	byte ptr [rcx], 0
-;; fe70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fe79:	 800100               	add	byte ptr [rcx], 0
-;; fe7c:	 aa                   	stosb	byte ptr [rdi], al
-;; fe7d:	 800100               	add	byte ptr [rcx], 0
-;; fe80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fe89:	 800100               	add	byte ptr [rcx], 0
-;; fe8c:	 aa                   	stosb	byte ptr [rdi], al
-;; fe8d:	 800100               	add	byte ptr [rcx], 0
-;; fe90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fe99:	 800100               	add	byte ptr [rcx], 0
-;; fe9c:	 aa                   	stosb	byte ptr [rdi], al
-;; fe9d:	 800100               	add	byte ptr [rcx], 0
-;; fea0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fea9:	 800100               	add	byte ptr [rcx], 0
-;; feac:	 aa                   	stosb	byte ptr [rdi], al
-;; fead:	 800100               	add	byte ptr [rcx], 0
-;; feb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; feb9:	 800100               	add	byte ptr [rcx], 0
-;; febc:	 aa                   	stosb	byte ptr [rdi], al
-;; febd:	 800100               	add	byte ptr [rcx], 0
-;; fec0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fec9:	 800100               	add	byte ptr [rcx], 0
-;; fecc:	 aa                   	stosb	byte ptr [rdi], al
-;; fecd:	 800100               	add	byte ptr [rcx], 0
-;; fed0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fed9:	 800100               	add	byte ptr [rcx], 0
-;; fedc:	 aa                   	stosb	byte ptr [rdi], al
-;; fedd:	 800100               	add	byte ptr [rcx], 0
-;; fee0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fee9:	 800100               	add	byte ptr [rcx], 0
-;; feec:	 aa                   	stosb	byte ptr [rdi], al
-;; feed:	 800100               	add	byte ptr [rcx], 0
-;; fef0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fef9:	 800100               	add	byte ptr [rcx], 0
-;; fefc:	 aa                   	stosb	byte ptr [rdi], al
-;; fefd:	 800100               	add	byte ptr [rcx], 0
-;; ff00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ff09:	 800100               	add	byte ptr [rcx], 0
-;; ff0c:	 aa                   	stosb	byte ptr [rdi], al
-;; ff0d:	 800100               	add	byte ptr [rcx], 0
-;; ff10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ff19:	 800100               	add	byte ptr [rcx], 0
-;; ff1c:	 aa                   	stosb	byte ptr [rdi], al
-;; ff1d:	 800100               	add	byte ptr [rcx], 0
-;; ff20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ff29:	 800100               	add	byte ptr [rcx], 0
-;; ff2c:	 aa                   	stosb	byte ptr [rdi], al
-;; ff2d:	 800100               	add	byte ptr [rcx], 0
-;; ff30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ff39:	 800100               	add	byte ptr [rcx], 0
-;; ff3c:	 aa                   	stosb	byte ptr [rdi], al
-;; ff3d:	 800100               	add	byte ptr [rcx], 0
-;; ff40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ff49:	 800100               	add	byte ptr [rcx], 0
-;; ff4c:	 aa                   	stosb	byte ptr [rdi], al
-;; ff4d:	 800100               	add	byte ptr [rcx], 0
-;; ff50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ff59:	 800100               	add	byte ptr [rcx], 0
-;; ff5c:	 aa                   	stosb	byte ptr [rdi], al
-;; ff5d:	 800100               	add	byte ptr [rcx], 0
-;; ff60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ff69:	 800100               	add	byte ptr [rcx], 0
-;; ff6c:	 aa                   	stosb	byte ptr [rdi], al
-;; ff6d:	 800100               	add	byte ptr [rcx], 0
-;; ff70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ff79:	 800100               	add	byte ptr [rcx], 0
-;; ff7c:	 aa                   	stosb	byte ptr [rdi], al
-;; ff7d:	 800100               	add	byte ptr [rcx], 0
-;; ff80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ff89:	 800100               	add	byte ptr [rcx], 0
-;; ff8c:	 aa                   	stosb	byte ptr [rdi], al
-;; ff8d:	 800100               	add	byte ptr [rcx], 0
-;; ff90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ff99:	 800100               	add	byte ptr [rcx], 0
-;; ff9c:	 aa                   	stosb	byte ptr [rdi], al
-;; ff9d:	 800100               	add	byte ptr [rcx], 0
-;; ffa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ffa9:	 800100               	add	byte ptr [rcx], 0
-;; ffac:	 aa                   	stosb	byte ptr [rdi], al
-;; ffad:	 800100               	add	byte ptr [rcx], 0
-;; ffb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ffb9:	 800100               	add	byte ptr [rcx], 0
-;; ffbc:	 aa                   	stosb	byte ptr [rdi], al
-;; ffbd:	 800100               	add	byte ptr [rcx], 0
-;; ffc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ffc9:	 800100               	add	byte ptr [rcx], 0
-;; ffcc:	 aa                   	stosb	byte ptr [rdi], al
-;; ffcd:	 800100               	add	byte ptr [rcx], 0
-;; ffd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ffd9:	 800100               	add	byte ptr [rcx], 0
-;; ffdc:	 aa                   	stosb	byte ptr [rdi], al
-;; ffdd:	 800100               	add	byte ptr [rcx], 0
-;; ffe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; ffe9:	 800100               	add	byte ptr [rcx], 0
-;; ffec:	 aa                   	stosb	byte ptr [rdi], al
-;; ffed:	 800100               	add	byte ptr [rcx], 0
-;; fff0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; fff9:	 800100               	add	byte ptr [rcx], 0
-;; fffc:	 aa                   	stosb	byte ptr [rdi], al
-;; fffd:	 800100               	add	byte ptr [rcx], 0
-;; 10000:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10009:	 800100               	add	byte ptr [rcx], 0
-;; 1000c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1000d:	 800100               	add	byte ptr [rcx], 0
-;; 10010:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10019:	 800100               	add	byte ptr [rcx], 0
-;; 1001c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1001d:	 800100               	add	byte ptr [rcx], 0
-;; 10020:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10029:	 800100               	add	byte ptr [rcx], 0
-;; 1002c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1002d:	 800100               	add	byte ptr [rcx], 0
-;; 10030:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10039:	 800100               	add	byte ptr [rcx], 0
-;; 1003c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1003d:	 800100               	add	byte ptr [rcx], 0
-;; 10040:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10049:	 800100               	add	byte ptr [rcx], 0
-;; 1004c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1004d:	 800100               	add	byte ptr [rcx], 0
-;; 10050:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10059:	 800100               	add	byte ptr [rcx], 0
-;; 1005c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1005d:	 800100               	add	byte ptr [rcx], 0
-;; 10060:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10069:	 800100               	add	byte ptr [rcx], 0
-;; 1006c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1006d:	 800100               	add	byte ptr [rcx], 0
-;; 10070:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10079:	 800100               	add	byte ptr [rcx], 0
-;; 1007c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1007d:	 800100               	add	byte ptr [rcx], 0
-;; 10080:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10089:	 800100               	add	byte ptr [rcx], 0
-;; 1008c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1008d:	 800100               	add	byte ptr [rcx], 0
-;; 10090:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10099:	 800100               	add	byte ptr [rcx], 0
-;; 1009c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1009d:	 800100               	add	byte ptr [rcx], 0
-;; 100a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 100a9:	 800100               	add	byte ptr [rcx], 0
-;; 100ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 100ad:	 800100               	add	byte ptr [rcx], 0
-;; 100b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 100b9:	 800100               	add	byte ptr [rcx], 0
-;; 100bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 100bd:	 800100               	add	byte ptr [rcx], 0
-;; 100c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 100c9:	 800100               	add	byte ptr [rcx], 0
-;; 100cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 100cd:	 800100               	add	byte ptr [rcx], 0
-;; 100d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 100d9:	 800100               	add	byte ptr [rcx], 0
-;; 100dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 100dd:	 800100               	add	byte ptr [rcx], 0
-;; 100e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 100e9:	 800100               	add	byte ptr [rcx], 0
-;; 100ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 100ed:	 800100               	add	byte ptr [rcx], 0
-;; 100f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 100f9:	 800100               	add	byte ptr [rcx], 0
-;; 100fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 100fd:	 800100               	add	byte ptr [rcx], 0
-;; 10100:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10109:	 800100               	add	byte ptr [rcx], 0
-;; 1010c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1010d:	 800100               	add	byte ptr [rcx], 0
-;; 10110:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10119:	 800100               	add	byte ptr [rcx], 0
-;; 1011c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1011d:	 800100               	add	byte ptr [rcx], 0
-;; 10120:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10129:	 800100               	add	byte ptr [rcx], 0
-;; 1012c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1012d:	 800100               	add	byte ptr [rcx], 0
-;; 10130:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10139:	 800100               	add	byte ptr [rcx], 0
-;; 1013c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1013d:	 800100               	add	byte ptr [rcx], 0
-;; 10140:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10149:	 800100               	add	byte ptr [rcx], 0
-;; 1014c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1014d:	 800100               	add	byte ptr [rcx], 0
-;; 10150:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10159:	 800100               	add	byte ptr [rcx], 0
-;; 1015c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1015d:	 800100               	add	byte ptr [rcx], 0
-;; 10160:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10169:	 800100               	add	byte ptr [rcx], 0
-;; 1016c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1016d:	 800100               	add	byte ptr [rcx], 0
-;; 10170:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10179:	 800100               	add	byte ptr [rcx], 0
-;; 1017c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1017d:	 800100               	add	byte ptr [rcx], 0
-;; 10180:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10189:	 800100               	add	byte ptr [rcx], 0
-;; 1018c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1018d:	 800100               	add	byte ptr [rcx], 0
-;; 10190:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10199:	 800100               	add	byte ptr [rcx], 0
-;; 1019c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1019d:	 800100               	add	byte ptr [rcx], 0
-;; 101a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 101a9:	 800100               	add	byte ptr [rcx], 0
-;; 101ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 101ad:	 800100               	add	byte ptr [rcx], 0
-;; 101b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 101b9:	 800100               	add	byte ptr [rcx], 0
-;; 101bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 101bd:	 800100               	add	byte ptr [rcx], 0
-;; 101c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 101c9:	 800100               	add	byte ptr [rcx], 0
-;; 101cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 101cd:	 800100               	add	byte ptr [rcx], 0
-;; 101d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 101d9:	 800100               	add	byte ptr [rcx], 0
-;; 101dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 101dd:	 800100               	add	byte ptr [rcx], 0
-;; 101e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 101e9:	 800100               	add	byte ptr [rcx], 0
-;; 101ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 101ed:	 800100               	add	byte ptr [rcx], 0
-;; 101f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 101f9:	 800100               	add	byte ptr [rcx], 0
-;; 101fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 101fd:	 800100               	add	byte ptr [rcx], 0
-;; 10200:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10209:	 800100               	add	byte ptr [rcx], 0
-;; 1020c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1020d:	 800100               	add	byte ptr [rcx], 0
-;; 10210:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10219:	 800100               	add	byte ptr [rcx], 0
-;; 1021c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1021d:	 800100               	add	byte ptr [rcx], 0
-;; 10220:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10229:	 800100               	add	byte ptr [rcx], 0
-;; 1022c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1022d:	 800100               	add	byte ptr [rcx], 0
-;; 10230:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10239:	 800100               	add	byte ptr [rcx], 0
-;; 1023c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1023d:	 800100               	add	byte ptr [rcx], 0
-;; 10240:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10249:	 800100               	add	byte ptr [rcx], 0
-;; 1024c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1024d:	 800100               	add	byte ptr [rcx], 0
-;; 10250:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10259:	 800100               	add	byte ptr [rcx], 0
-;; 1025c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1025d:	 800100               	add	byte ptr [rcx], 0
-;; 10260:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10269:	 800100               	add	byte ptr [rcx], 0
-;; 1026c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1026d:	 800100               	add	byte ptr [rcx], 0
-;; 10270:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10279:	 800100               	add	byte ptr [rcx], 0
-;; 1027c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1027d:	 800100               	add	byte ptr [rcx], 0
-;; 10280:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10289:	 800100               	add	byte ptr [rcx], 0
-;; 1028c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1028d:	 800100               	add	byte ptr [rcx], 0
-;; 10290:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10299:	 800100               	add	byte ptr [rcx], 0
-;; 1029c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1029d:	 800100               	add	byte ptr [rcx], 0
-;; 102a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 102a9:	 800100               	add	byte ptr [rcx], 0
-;; 102ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 102ad:	 800100               	add	byte ptr [rcx], 0
-;; 102b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 102b9:	 800100               	add	byte ptr [rcx], 0
-;; 102bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 102bd:	 800100               	add	byte ptr [rcx], 0
-;; 102c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 102c9:	 800100               	add	byte ptr [rcx], 0
-;; 102cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 102cd:	 800100               	add	byte ptr [rcx], 0
-;; 102d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 102d9:	 800100               	add	byte ptr [rcx], 0
-;; 102dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 102dd:	 800100               	add	byte ptr [rcx], 0
-;; 102e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 102e9:	 800100               	add	byte ptr [rcx], 0
-;; 102ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 102ed:	 800100               	add	byte ptr [rcx], 0
-;; 102f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 102f9:	 800100               	add	byte ptr [rcx], 0
-;; 102fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 102fd:	 800100               	add	byte ptr [rcx], 0
-;; 10300:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10309:	 800100               	add	byte ptr [rcx], 0
-;; 1030c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1030d:	 800100               	add	byte ptr [rcx], 0
-;; 10310:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10319:	 800100               	add	byte ptr [rcx], 0
-;; 1031c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1031d:	 800100               	add	byte ptr [rcx], 0
-;; 10320:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10329:	 800100               	add	byte ptr [rcx], 0
-;; 1032c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1032d:	 800100               	add	byte ptr [rcx], 0
-;; 10330:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10339:	 800100               	add	byte ptr [rcx], 0
-;; 1033c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1033d:	 800100               	add	byte ptr [rcx], 0
-;; 10340:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10349:	 800100               	add	byte ptr [rcx], 0
-;; 1034c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1034d:	 800100               	add	byte ptr [rcx], 0
-;; 10350:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10359:	 800100               	add	byte ptr [rcx], 0
-;; 1035c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1035d:	 800100               	add	byte ptr [rcx], 0
-;; 10360:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10369:	 800100               	add	byte ptr [rcx], 0
-;; 1036c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1036d:	 800100               	add	byte ptr [rcx], 0
-;; 10370:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10379:	 800100               	add	byte ptr [rcx], 0
-;; 1037c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1037d:	 800100               	add	byte ptr [rcx], 0
-;; 10380:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10389:	 800100               	add	byte ptr [rcx], 0
-;; 1038c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1038d:	 800100               	add	byte ptr [rcx], 0
-;; 10390:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10399:	 800100               	add	byte ptr [rcx], 0
-;; 1039c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1039d:	 800100               	add	byte ptr [rcx], 0
-;; 103a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 103a9:	 800100               	add	byte ptr [rcx], 0
-;; 103ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 103ad:	 800100               	add	byte ptr [rcx], 0
-;; 103b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 103b9:	 800100               	add	byte ptr [rcx], 0
-;; 103bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 103bd:	 800100               	add	byte ptr [rcx], 0
-;; 103c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 103c9:	 800100               	add	byte ptr [rcx], 0
-;; 103cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 103cd:	 800100               	add	byte ptr [rcx], 0
-;; 103d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 103d9:	 800100               	add	byte ptr [rcx], 0
-;; 103dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 103dd:	 800100               	add	byte ptr [rcx], 0
-;; 103e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 103e9:	 800100               	add	byte ptr [rcx], 0
-;; 103ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 103ed:	 800100               	add	byte ptr [rcx], 0
-;; 103f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 103f9:	 800100               	add	byte ptr [rcx], 0
-;; 103fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 103fd:	 800100               	add	byte ptr [rcx], 0
-;; 10400:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10409:	 800100               	add	byte ptr [rcx], 0
-;; 1040c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1040d:	 800100               	add	byte ptr [rcx], 0
-;; 10410:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10419:	 800100               	add	byte ptr [rcx], 0
-;; 1041c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1041d:	 800100               	add	byte ptr [rcx], 0
-;; 10420:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10429:	 800100               	add	byte ptr [rcx], 0
-;; 1042c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1042d:	 800100               	add	byte ptr [rcx], 0
-;; 10430:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10439:	 800100               	add	byte ptr [rcx], 0
-;; 1043c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1043d:	 800100               	add	byte ptr [rcx], 0
-;; 10440:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10449:	 800100               	add	byte ptr [rcx], 0
-;; 1044c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1044d:	 800100               	add	byte ptr [rcx], 0
-;; 10450:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10459:	 800100               	add	byte ptr [rcx], 0
-;; 1045c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1045d:	 800100               	add	byte ptr [rcx], 0
-;; 10460:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10469:	 800100               	add	byte ptr [rcx], 0
-;; 1046c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1046d:	 800100               	add	byte ptr [rcx], 0
-;; 10470:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10479:	 800100               	add	byte ptr [rcx], 0
-;; 1047c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1047d:	 800100               	add	byte ptr [rcx], 0
-;; 10480:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10489:	 800100               	add	byte ptr [rcx], 0
-;; 1048c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1048d:	 800100               	add	byte ptr [rcx], 0
-;; 10490:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10499:	 800100               	add	byte ptr [rcx], 0
-;; 1049c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1049d:	 800100               	add	byte ptr [rcx], 0
-;; 104a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 104a9:	 800100               	add	byte ptr [rcx], 0
-;; 104ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 104ad:	 800100               	add	byte ptr [rcx], 0
-;; 104b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 104b9:	 800100               	add	byte ptr [rcx], 0
-;; 104bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 104bd:	 800100               	add	byte ptr [rcx], 0
-;; 104c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 104c9:	 800100               	add	byte ptr [rcx], 0
-;; 104cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 104cd:	 800100               	add	byte ptr [rcx], 0
-;; 104d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 104d9:	 800100               	add	byte ptr [rcx], 0
-;; 104dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 104dd:	 800100               	add	byte ptr [rcx], 0
-;; 104e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 104e9:	 800100               	add	byte ptr [rcx], 0
-;; 104ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 104ed:	 800100               	add	byte ptr [rcx], 0
-;; 104f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 104f9:	 800100               	add	byte ptr [rcx], 0
-;; 104fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 104fd:	 800100               	add	byte ptr [rcx], 0
-;; 10500:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10509:	 800100               	add	byte ptr [rcx], 0
-;; 1050c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1050d:	 800100               	add	byte ptr [rcx], 0
-;; 10510:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10519:	 800100               	add	byte ptr [rcx], 0
-;; 1051c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1051d:	 800100               	add	byte ptr [rcx], 0
-;; 10520:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10529:	 800100               	add	byte ptr [rcx], 0
-;; 1052c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1052d:	 800100               	add	byte ptr [rcx], 0
-;; 10530:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10539:	 800100               	add	byte ptr [rcx], 0
-;; 1053c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1053d:	 800100               	add	byte ptr [rcx], 0
-;; 10540:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10549:	 800100               	add	byte ptr [rcx], 0
-;; 1054c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1054d:	 800100               	add	byte ptr [rcx], 0
-;; 10550:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10559:	 800100               	add	byte ptr [rcx], 0
-;; 1055c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1055d:	 800100               	add	byte ptr [rcx], 0
-;; 10560:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10569:	 800100               	add	byte ptr [rcx], 0
-;; 1056c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1056d:	 800100               	add	byte ptr [rcx], 0
-;; 10570:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10579:	 800100               	add	byte ptr [rcx], 0
-;; 1057c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1057d:	 800100               	add	byte ptr [rcx], 0
-;; 10580:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10589:	 800100               	add	byte ptr [rcx], 0
-;; 1058c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1058d:	 800100               	add	byte ptr [rcx], 0
-;; 10590:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10599:	 800100               	add	byte ptr [rcx], 0
-;; 1059c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1059d:	 800100               	add	byte ptr [rcx], 0
-;; 105a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 105a9:	 800100               	add	byte ptr [rcx], 0
-;; 105ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 105ad:	 800100               	add	byte ptr [rcx], 0
-;; 105b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 105b9:	 800100               	add	byte ptr [rcx], 0
-;; 105bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 105bd:	 800100               	add	byte ptr [rcx], 0
-;; 105c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 105c9:	 800100               	add	byte ptr [rcx], 0
-;; 105cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 105cd:	 800100               	add	byte ptr [rcx], 0
-;; 105d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 105d9:	 800100               	add	byte ptr [rcx], 0
-;; 105dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 105dd:	 800100               	add	byte ptr [rcx], 0
-;; 105e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 105e9:	 800100               	add	byte ptr [rcx], 0
-;; 105ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 105ed:	 800100               	add	byte ptr [rcx], 0
-;; 105f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 105f9:	 800100               	add	byte ptr [rcx], 0
-;; 105fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 105fd:	 800100               	add	byte ptr [rcx], 0
-;; 10600:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10609:	 800100               	add	byte ptr [rcx], 0
-;; 1060c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1060d:	 800100               	add	byte ptr [rcx], 0
-;; 10610:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10619:	 800100               	add	byte ptr [rcx], 0
-;; 1061c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1061d:	 800100               	add	byte ptr [rcx], 0
-;; 10620:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10629:	 800100               	add	byte ptr [rcx], 0
-;; 1062c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1062d:	 800100               	add	byte ptr [rcx], 0
-;; 10630:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10639:	 800100               	add	byte ptr [rcx], 0
-;; 1063c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1063d:	 800100               	add	byte ptr [rcx], 0
-;; 10640:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10649:	 800100               	add	byte ptr [rcx], 0
-;; 1064c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1064d:	 800100               	add	byte ptr [rcx], 0
-;; 10650:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10659:	 800100               	add	byte ptr [rcx], 0
-;; 1065c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1065d:	 800100               	add	byte ptr [rcx], 0
-;; 10660:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10669:	 800100               	add	byte ptr [rcx], 0
-;; 1066c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1066d:	 800100               	add	byte ptr [rcx], 0
-;; 10670:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10679:	 800100               	add	byte ptr [rcx], 0
-;; 1067c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1067d:	 800100               	add	byte ptr [rcx], 0
-;; 10680:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10689:	 800100               	add	byte ptr [rcx], 0
-;; 1068c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1068d:	 800100               	add	byte ptr [rcx], 0
-;; 10690:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10699:	 800100               	add	byte ptr [rcx], 0
-;; 1069c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1069d:	 800100               	add	byte ptr [rcx], 0
-;; 106a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 106a9:	 800100               	add	byte ptr [rcx], 0
-;; 106ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 106ad:	 800100               	add	byte ptr [rcx], 0
-;; 106b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 106b9:	 800100               	add	byte ptr [rcx], 0
-;; 106bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 106bd:	 800100               	add	byte ptr [rcx], 0
-;; 106c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 106c9:	 800100               	add	byte ptr [rcx], 0
-;; 106cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 106cd:	 800100               	add	byte ptr [rcx], 0
-;; 106d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 106d9:	 800100               	add	byte ptr [rcx], 0
-;; 106dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 106dd:	 800100               	add	byte ptr [rcx], 0
-;; 106e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 106e9:	 800100               	add	byte ptr [rcx], 0
-;; 106ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 106ed:	 800100               	add	byte ptr [rcx], 0
-;; 106f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 106f9:	 800100               	add	byte ptr [rcx], 0
-;; 106fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 106fd:	 800100               	add	byte ptr [rcx], 0
-;; 10700:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10709:	 800100               	add	byte ptr [rcx], 0
-;; 1070c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1070d:	 800100               	add	byte ptr [rcx], 0
-;; 10710:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10719:	 800100               	add	byte ptr [rcx], 0
-;; 1071c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1071d:	 800100               	add	byte ptr [rcx], 0
-;; 10720:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10729:	 800100               	add	byte ptr [rcx], 0
-;; 1072c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1072d:	 800100               	add	byte ptr [rcx], 0
-;; 10730:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10739:	 800100               	add	byte ptr [rcx], 0
-;; 1073c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1073d:	 800100               	add	byte ptr [rcx], 0
-;; 10740:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10749:	 800100               	add	byte ptr [rcx], 0
-;; 1074c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1074d:	 800100               	add	byte ptr [rcx], 0
-;; 10750:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10759:	 800100               	add	byte ptr [rcx], 0
-;; 1075c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1075d:	 800100               	add	byte ptr [rcx], 0
-;; 10760:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10769:	 800100               	add	byte ptr [rcx], 0
-;; 1076c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1076d:	 800100               	add	byte ptr [rcx], 0
-;; 10770:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10779:	 800100               	add	byte ptr [rcx], 0
-;; 1077c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1077d:	 800100               	add	byte ptr [rcx], 0
-;; 10780:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10789:	 800100               	add	byte ptr [rcx], 0
-;; 1078c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1078d:	 800100               	add	byte ptr [rcx], 0
-;; 10790:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10799:	 800100               	add	byte ptr [rcx], 0
-;; 1079c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1079d:	 800100               	add	byte ptr [rcx], 0
-;; 107a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 107a9:	 800100               	add	byte ptr [rcx], 0
-;; 107ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 107ad:	 800100               	add	byte ptr [rcx], 0
-;; 107b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 107b9:	 800100               	add	byte ptr [rcx], 0
-;; 107bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 107bd:	 800100               	add	byte ptr [rcx], 0
-;; 107c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 107c9:	 800100               	add	byte ptr [rcx], 0
-;; 107cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 107cd:	 800100               	add	byte ptr [rcx], 0
-;; 107d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 107d9:	 800100               	add	byte ptr [rcx], 0
-;; 107dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 107dd:	 800100               	add	byte ptr [rcx], 0
-;; 107e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 107e9:	 800100               	add	byte ptr [rcx], 0
-;; 107ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 107ed:	 800100               	add	byte ptr [rcx], 0
-;; 107f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 107f9:	 800100               	add	byte ptr [rcx], 0
-;; 107fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 107fd:	 800100               	add	byte ptr [rcx], 0
-;; 10800:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10809:	 800100               	add	byte ptr [rcx], 0
-;; 1080c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1080d:	 800100               	add	byte ptr [rcx], 0
-;; 10810:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10819:	 800100               	add	byte ptr [rcx], 0
-;; 1081c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1081d:	 800100               	add	byte ptr [rcx], 0
-;; 10820:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10829:	 800100               	add	byte ptr [rcx], 0
-;; 1082c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1082d:	 800100               	add	byte ptr [rcx], 0
-;; 10830:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10839:	 800100               	add	byte ptr [rcx], 0
-;; 1083c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1083d:	 800100               	add	byte ptr [rcx], 0
-;; 10840:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10849:	 800100               	add	byte ptr [rcx], 0
-;; 1084c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1084d:	 800100               	add	byte ptr [rcx], 0
-;; 10850:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10859:	 800100               	add	byte ptr [rcx], 0
-;; 1085c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1085d:	 800100               	add	byte ptr [rcx], 0
-;; 10860:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10869:	 800100               	add	byte ptr [rcx], 0
-;; 1086c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1086d:	 800100               	add	byte ptr [rcx], 0
-;; 10870:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10879:	 800100               	add	byte ptr [rcx], 0
-;; 1087c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1087d:	 800100               	add	byte ptr [rcx], 0
-;; 10880:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10889:	 800100               	add	byte ptr [rcx], 0
-;; 1088c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1088d:	 800100               	add	byte ptr [rcx], 0
-;; 10890:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10899:	 800100               	add	byte ptr [rcx], 0
-;; 1089c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1089d:	 800100               	add	byte ptr [rcx], 0
-;; 108a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 108a9:	 800100               	add	byte ptr [rcx], 0
-;; 108ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 108ad:	 800100               	add	byte ptr [rcx], 0
-;; 108b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 108b9:	 800100               	add	byte ptr [rcx], 0
-;; 108bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 108bd:	 800100               	add	byte ptr [rcx], 0
-;; 108c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 108c9:	 800100               	add	byte ptr [rcx], 0
-;; 108cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 108cd:	 800100               	add	byte ptr [rcx], 0
-;; 108d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 108d9:	 800100               	add	byte ptr [rcx], 0
-;; 108dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 108dd:	 800100               	add	byte ptr [rcx], 0
-;; 108e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 108e9:	 800100               	add	byte ptr [rcx], 0
-;; 108ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 108ed:	 800100               	add	byte ptr [rcx], 0
-;; 108f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 108f9:	 800100               	add	byte ptr [rcx], 0
-;; 108fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 108fd:	 800100               	add	byte ptr [rcx], 0
-;; 10900:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10909:	 800100               	add	byte ptr [rcx], 0
-;; 1090c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1090d:	 800100               	add	byte ptr [rcx], 0
-;; 10910:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10919:	 800100               	add	byte ptr [rcx], 0
-;; 1091c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1091d:	 800100               	add	byte ptr [rcx], 0
-;; 10920:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10929:	 800100               	add	byte ptr [rcx], 0
-;; 1092c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1092d:	 800100               	add	byte ptr [rcx], 0
-;; 10930:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10939:	 800100               	add	byte ptr [rcx], 0
-;; 1093c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1093d:	 800100               	add	byte ptr [rcx], 0
-;; 10940:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10949:	 800100               	add	byte ptr [rcx], 0
-;; 1094c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1094d:	 800100               	add	byte ptr [rcx], 0
-;; 10950:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10959:	 800100               	add	byte ptr [rcx], 0
-;; 1095c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1095d:	 800100               	add	byte ptr [rcx], 0
-;; 10960:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10969:	 800100               	add	byte ptr [rcx], 0
-;; 1096c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1096d:	 800100               	add	byte ptr [rcx], 0
-;; 10970:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10979:	 800100               	add	byte ptr [rcx], 0
-;; 1097c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1097d:	 800100               	add	byte ptr [rcx], 0
-;; 10980:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10989:	 800100               	add	byte ptr [rcx], 0
-;; 1098c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1098d:	 800100               	add	byte ptr [rcx], 0
-;; 10990:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10999:	 800100               	add	byte ptr [rcx], 0
-;; 1099c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1099d:	 800100               	add	byte ptr [rcx], 0
-;; 109a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 109a9:	 800100               	add	byte ptr [rcx], 0
-;; 109ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 109ad:	 800100               	add	byte ptr [rcx], 0
-;; 109b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 109b9:	 800100               	add	byte ptr [rcx], 0
-;; 109bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 109bd:	 800100               	add	byte ptr [rcx], 0
-;; 109c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 109c9:	 800100               	add	byte ptr [rcx], 0
-;; 109cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 109cd:	 800100               	add	byte ptr [rcx], 0
-;; 109d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 109d9:	 800100               	add	byte ptr [rcx], 0
-;; 109dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 109dd:	 800100               	add	byte ptr [rcx], 0
-;; 109e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 109e9:	 800100               	add	byte ptr [rcx], 0
-;; 109ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 109ed:	 800100               	add	byte ptr [rcx], 0
-;; 109f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 109f9:	 800100               	add	byte ptr [rcx], 0
-;; 109fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 109fd:	 800100               	add	byte ptr [rcx], 0
-;; 10a00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10a09:	 800100               	add	byte ptr [rcx], 0
-;; 10a0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10a0d:	 800100               	add	byte ptr [rcx], 0
-;; 10a10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10a19:	 800100               	add	byte ptr [rcx], 0
-;; 10a1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10a1d:	 800100               	add	byte ptr [rcx], 0
-;; 10a20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10a29:	 800100               	add	byte ptr [rcx], 0
-;; 10a2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10a2d:	 800100               	add	byte ptr [rcx], 0
-;; 10a30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10a39:	 800100               	add	byte ptr [rcx], 0
-;; 10a3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10a3d:	 800100               	add	byte ptr [rcx], 0
-;; 10a40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10a49:	 800100               	add	byte ptr [rcx], 0
-;; 10a4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10a4d:	 800100               	add	byte ptr [rcx], 0
-;; 10a50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10a59:	 800100               	add	byte ptr [rcx], 0
-;; 10a5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10a5d:	 800100               	add	byte ptr [rcx], 0
-;; 10a60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10a69:	 800100               	add	byte ptr [rcx], 0
-;; 10a6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10a6d:	 800100               	add	byte ptr [rcx], 0
-;; 10a70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10a79:	 800100               	add	byte ptr [rcx], 0
-;; 10a7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10a7d:	 800100               	add	byte ptr [rcx], 0
-;; 10a80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10a89:	 800100               	add	byte ptr [rcx], 0
-;; 10a8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10a8d:	 800100               	add	byte ptr [rcx], 0
-;; 10a90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10a99:	 800100               	add	byte ptr [rcx], 0
-;; 10a9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10a9d:	 800100               	add	byte ptr [rcx], 0
-;; 10aa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10aa9:	 800100               	add	byte ptr [rcx], 0
-;; 10aac:	 aa                   	stosb	byte ptr [rdi], al
-;; 10aad:	 800100               	add	byte ptr [rcx], 0
-;; 10ab0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10ab9:	 800100               	add	byte ptr [rcx], 0
-;; 10abc:	 aa                   	stosb	byte ptr [rdi], al
-;; 10abd:	 800100               	add	byte ptr [rcx], 0
-;; 10ac0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10ac9:	 800100               	add	byte ptr [rcx], 0
-;; 10acc:	 aa                   	stosb	byte ptr [rdi], al
-;; 10acd:	 800100               	add	byte ptr [rcx], 0
-;; 10ad0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10ad9:	 800100               	add	byte ptr [rcx], 0
-;; 10adc:	 aa                   	stosb	byte ptr [rdi], al
-;; 10add:	 800100               	add	byte ptr [rcx], 0
-;; 10ae0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10ae9:	 800100               	add	byte ptr [rcx], 0
-;; 10aec:	 aa                   	stosb	byte ptr [rdi], al
-;; 10aed:	 800100               	add	byte ptr [rcx], 0
-;; 10af0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10af9:	 800100               	add	byte ptr [rcx], 0
-;; 10afc:	 aa                   	stosb	byte ptr [rdi], al
-;; 10afd:	 800100               	add	byte ptr [rcx], 0
-;; 10b00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10b09:	 800100               	add	byte ptr [rcx], 0
-;; 10b0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10b0d:	 800100               	add	byte ptr [rcx], 0
-;; 10b10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10b19:	 800100               	add	byte ptr [rcx], 0
-;; 10b1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10b1d:	 800100               	add	byte ptr [rcx], 0
-;; 10b20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10b29:	 800100               	add	byte ptr [rcx], 0
-;; 10b2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10b2d:	 800100               	add	byte ptr [rcx], 0
-;; 10b30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10b39:	 800100               	add	byte ptr [rcx], 0
-;; 10b3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10b3d:	 800100               	add	byte ptr [rcx], 0
-;; 10b40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10b49:	 800100               	add	byte ptr [rcx], 0
-;; 10b4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10b4d:	 800100               	add	byte ptr [rcx], 0
-;; 10b50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10b59:	 800100               	add	byte ptr [rcx], 0
-;; 10b5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10b5d:	 800100               	add	byte ptr [rcx], 0
-;; 10b60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10b69:	 800100               	add	byte ptr [rcx], 0
-;; 10b6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10b6d:	 800100               	add	byte ptr [rcx], 0
-;; 10b70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10b79:	 800100               	add	byte ptr [rcx], 0
-;; 10b7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10b7d:	 800100               	add	byte ptr [rcx], 0
-;; 10b80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10b89:	 800100               	add	byte ptr [rcx], 0
-;; 10b8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10b8d:	 800100               	add	byte ptr [rcx], 0
-;; 10b90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10b99:	 800100               	add	byte ptr [rcx], 0
-;; 10b9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10b9d:	 800100               	add	byte ptr [rcx], 0
-;; 10ba0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10ba9:	 800100               	add	byte ptr [rcx], 0
-;; 10bac:	 aa                   	stosb	byte ptr [rdi], al
-;; 10bad:	 800100               	add	byte ptr [rcx], 0
-;; 10bb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10bb9:	 800100               	add	byte ptr [rcx], 0
-;; 10bbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 10bbd:	 800100               	add	byte ptr [rcx], 0
-;; 10bc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10bc9:	 800100               	add	byte ptr [rcx], 0
-;; 10bcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 10bcd:	 800100               	add	byte ptr [rcx], 0
-;; 10bd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10bd9:	 800100               	add	byte ptr [rcx], 0
-;; 10bdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 10bdd:	 800100               	add	byte ptr [rcx], 0
-;; 10be0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10be9:	 800100               	add	byte ptr [rcx], 0
-;; 10bec:	 aa                   	stosb	byte ptr [rdi], al
-;; 10bed:	 800100               	add	byte ptr [rcx], 0
-;; 10bf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10bf9:	 800100               	add	byte ptr [rcx], 0
-;; 10bfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 10bfd:	 800100               	add	byte ptr [rcx], 0
-;; 10c00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10c09:	 800100               	add	byte ptr [rcx], 0
-;; 10c0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10c0d:	 800100               	add	byte ptr [rcx], 0
-;; 10c10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10c19:	 800100               	add	byte ptr [rcx], 0
-;; 10c1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10c1d:	 800100               	add	byte ptr [rcx], 0
-;; 10c20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10c29:	 800100               	add	byte ptr [rcx], 0
-;; 10c2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10c2d:	 800100               	add	byte ptr [rcx], 0
-;; 10c30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10c39:	 800100               	add	byte ptr [rcx], 0
-;; 10c3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10c3d:	 800100               	add	byte ptr [rcx], 0
-;; 10c40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10c49:	 800100               	add	byte ptr [rcx], 0
-;; 10c4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10c4d:	 800100               	add	byte ptr [rcx], 0
-;; 10c50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10c59:	 800100               	add	byte ptr [rcx], 0
-;; 10c5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10c5d:	 800100               	add	byte ptr [rcx], 0
-;; 10c60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10c69:	 800100               	add	byte ptr [rcx], 0
-;; 10c6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10c6d:	 800100               	add	byte ptr [rcx], 0
-;; 10c70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10c79:	 800100               	add	byte ptr [rcx], 0
-;; 10c7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10c7d:	 800100               	add	byte ptr [rcx], 0
-;; 10c80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10c89:	 800100               	add	byte ptr [rcx], 0
-;; 10c8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10c8d:	 800100               	add	byte ptr [rcx], 0
-;; 10c90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10c99:	 800100               	add	byte ptr [rcx], 0
-;; 10c9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10c9d:	 800100               	add	byte ptr [rcx], 0
-;; 10ca0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10ca9:	 800100               	add	byte ptr [rcx], 0
-;; 10cac:	 aa                   	stosb	byte ptr [rdi], al
-;; 10cad:	 800100               	add	byte ptr [rcx], 0
-;; 10cb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10cb9:	 800100               	add	byte ptr [rcx], 0
-;; 10cbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 10cbd:	 800100               	add	byte ptr [rcx], 0
-;; 10cc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10cc9:	 800100               	add	byte ptr [rcx], 0
-;; 10ccc:	 aa                   	stosb	byte ptr [rdi], al
-;; 10ccd:	 800100               	add	byte ptr [rcx], 0
-;; 10cd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10cd9:	 800100               	add	byte ptr [rcx], 0
-;; 10cdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 10cdd:	 800100               	add	byte ptr [rcx], 0
-;; 10ce0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10ce9:	 800100               	add	byte ptr [rcx], 0
-;; 10cec:	 aa                   	stosb	byte ptr [rdi], al
-;; 10ced:	 800100               	add	byte ptr [rcx], 0
-;; 10cf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10cf9:	 800100               	add	byte ptr [rcx], 0
-;; 10cfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 10cfd:	 800100               	add	byte ptr [rcx], 0
-;; 10d00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10d09:	 800100               	add	byte ptr [rcx], 0
-;; 10d0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10d0d:	 800100               	add	byte ptr [rcx], 0
-;; 10d10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10d19:	 800100               	add	byte ptr [rcx], 0
-;; 10d1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10d1d:	 800100               	add	byte ptr [rcx], 0
-;; 10d20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10d29:	 800100               	add	byte ptr [rcx], 0
-;; 10d2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10d2d:	 800100               	add	byte ptr [rcx], 0
-;; 10d30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10d39:	 800100               	add	byte ptr [rcx], 0
-;; 10d3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10d3d:	 800100               	add	byte ptr [rcx], 0
-;; 10d40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10d49:	 800100               	add	byte ptr [rcx], 0
-;; 10d4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10d4d:	 800100               	add	byte ptr [rcx], 0
-;; 10d50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10d59:	 800100               	add	byte ptr [rcx], 0
-;; 10d5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10d5d:	 800100               	add	byte ptr [rcx], 0
-;; 10d60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10d69:	 800100               	add	byte ptr [rcx], 0
-;; 10d6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10d6d:	 800100               	add	byte ptr [rcx], 0
-;; 10d70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10d79:	 800100               	add	byte ptr [rcx], 0
-;; 10d7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10d7d:	 800100               	add	byte ptr [rcx], 0
-;; 10d80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10d89:	 800100               	add	byte ptr [rcx], 0
-;; 10d8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10d8d:	 800100               	add	byte ptr [rcx], 0
-;; 10d90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10d99:	 800100               	add	byte ptr [rcx], 0
-;; 10d9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10d9d:	 800100               	add	byte ptr [rcx], 0
-;; 10da0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10da9:	 800100               	add	byte ptr [rcx], 0
-;; 10dac:	 aa                   	stosb	byte ptr [rdi], al
-;; 10dad:	 800100               	add	byte ptr [rcx], 0
-;; 10db0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10db9:	 800100               	add	byte ptr [rcx], 0
-;; 10dbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 10dbd:	 800100               	add	byte ptr [rcx], 0
-;; 10dc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10dc9:	 800100               	add	byte ptr [rcx], 0
-;; 10dcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 10dcd:	 800100               	add	byte ptr [rcx], 0
-;; 10dd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10dd9:	 800100               	add	byte ptr [rcx], 0
-;; 10ddc:	 aa                   	stosb	byte ptr [rdi], al
-;; 10ddd:	 800100               	add	byte ptr [rcx], 0
-;; 10de0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10de9:	 800100               	add	byte ptr [rcx], 0
-;; 10dec:	 aa                   	stosb	byte ptr [rdi], al
-;; 10ded:	 800100               	add	byte ptr [rcx], 0
-;; 10df0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10df9:	 800100               	add	byte ptr [rcx], 0
-;; 10dfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 10dfd:	 800100               	add	byte ptr [rcx], 0
-;; 10e00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10e09:	 800100               	add	byte ptr [rcx], 0
-;; 10e0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10e0d:	 800100               	add	byte ptr [rcx], 0
-;; 10e10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10e19:	 800100               	add	byte ptr [rcx], 0
-;; 10e1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10e1d:	 800100               	add	byte ptr [rcx], 0
-;; 10e20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10e29:	 800100               	add	byte ptr [rcx], 0
-;; 10e2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10e2d:	 800100               	add	byte ptr [rcx], 0
-;; 10e30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10e39:	 800100               	add	byte ptr [rcx], 0
-;; 10e3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10e3d:	 800100               	add	byte ptr [rcx], 0
-;; 10e40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10e49:	 800100               	add	byte ptr [rcx], 0
-;; 10e4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10e4d:	 800100               	add	byte ptr [rcx], 0
-;; 10e50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10e59:	 800100               	add	byte ptr [rcx], 0
-;; 10e5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10e5d:	 800100               	add	byte ptr [rcx], 0
-;; 10e60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10e69:	 800100               	add	byte ptr [rcx], 0
-;; 10e6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10e6d:	 800100               	add	byte ptr [rcx], 0
-;; 10e70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10e79:	 800100               	add	byte ptr [rcx], 0
-;; 10e7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10e7d:	 800100               	add	byte ptr [rcx], 0
-;; 10e80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10e89:	 800100               	add	byte ptr [rcx], 0
-;; 10e8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10e8d:	 800100               	add	byte ptr [rcx], 0
-;; 10e90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10e99:	 800100               	add	byte ptr [rcx], 0
-;; 10e9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10e9d:	 800100               	add	byte ptr [rcx], 0
-;; 10ea0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10ea9:	 800100               	add	byte ptr [rcx], 0
-;; 10eac:	 aa                   	stosb	byte ptr [rdi], al
-;; 10ead:	 800100               	add	byte ptr [rcx], 0
-;; 10eb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10eb9:	 800100               	add	byte ptr [rcx], 0
-;; 10ebc:	 aa                   	stosb	byte ptr [rdi], al
-;; 10ebd:	 800100               	add	byte ptr [rcx], 0
-;; 10ec0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10ec9:	 800100               	add	byte ptr [rcx], 0
-;; 10ecc:	 aa                   	stosb	byte ptr [rdi], al
-;; 10ecd:	 800100               	add	byte ptr [rcx], 0
-;; 10ed0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10ed9:	 800100               	add	byte ptr [rcx], 0
-;; 10edc:	 aa                   	stosb	byte ptr [rdi], al
-;; 10edd:	 800100               	add	byte ptr [rcx], 0
-;; 10ee0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10ee9:	 800100               	add	byte ptr [rcx], 0
-;; 10eec:	 aa                   	stosb	byte ptr [rdi], al
-;; 10eed:	 800100               	add	byte ptr [rcx], 0
-;; 10ef0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10ef9:	 800100               	add	byte ptr [rcx], 0
-;; 10efc:	 aa                   	stosb	byte ptr [rdi], al
-;; 10efd:	 800100               	add	byte ptr [rcx], 0
-;; 10f00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10f09:	 800100               	add	byte ptr [rcx], 0
-;; 10f0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10f0d:	 800100               	add	byte ptr [rcx], 0
-;; 10f10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10f19:	 800100               	add	byte ptr [rcx], 0
-;; 10f1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10f1d:	 800100               	add	byte ptr [rcx], 0
-;; 10f20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10f29:	 800100               	add	byte ptr [rcx], 0
-;; 10f2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10f2d:	 800100               	add	byte ptr [rcx], 0
-;; 10f30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10f39:	 800100               	add	byte ptr [rcx], 0
-;; 10f3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10f3d:	 800100               	add	byte ptr [rcx], 0
-;; 10f40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10f49:	 800100               	add	byte ptr [rcx], 0
-;; 10f4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10f4d:	 800100               	add	byte ptr [rcx], 0
-;; 10f50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10f59:	 800100               	add	byte ptr [rcx], 0
-;; 10f5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10f5d:	 800100               	add	byte ptr [rcx], 0
-;; 10f60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10f69:	 800100               	add	byte ptr [rcx], 0
-;; 10f6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10f6d:	 800100               	add	byte ptr [rcx], 0
-;; 10f70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10f79:	 800100               	add	byte ptr [rcx], 0
-;; 10f7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10f7d:	 800100               	add	byte ptr [rcx], 0
-;; 10f80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10f89:	 800100               	add	byte ptr [rcx], 0
-;; 10f8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10f8d:	 800100               	add	byte ptr [rcx], 0
-;; 10f90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10f99:	 800100               	add	byte ptr [rcx], 0
-;; 10f9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 10f9d:	 800100               	add	byte ptr [rcx], 0
-;; 10fa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10fa9:	 800100               	add	byte ptr [rcx], 0
-;; 10fac:	 aa                   	stosb	byte ptr [rdi], al
-;; 10fad:	 800100               	add	byte ptr [rcx], 0
-;; 10fb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10fb9:	 800100               	add	byte ptr [rcx], 0
-;; 10fbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 10fbd:	 800100               	add	byte ptr [rcx], 0
-;; 10fc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10fc9:	 800100               	add	byte ptr [rcx], 0
-;; 10fcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 10fcd:	 800100               	add	byte ptr [rcx], 0
-;; 10fd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10fd9:	 800100               	add	byte ptr [rcx], 0
-;; 10fdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 10fdd:	 800100               	add	byte ptr [rcx], 0
-;; 10fe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10fe9:	 800100               	add	byte ptr [rcx], 0
-;; 10fec:	 aa                   	stosb	byte ptr [rdi], al
-;; 10fed:	 800100               	add	byte ptr [rcx], 0
-;; 10ff0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 10ff9:	 800100               	add	byte ptr [rcx], 0
-;; 10ffc:	 aa                   	stosb	byte ptr [rdi], al
-;; 10ffd:	 800100               	add	byte ptr [rcx], 0
-;; 11000:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11009:	 800100               	add	byte ptr [rcx], 0
-;; 1100c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1100d:	 800100               	add	byte ptr [rcx], 0
-;; 11010:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11019:	 800100               	add	byte ptr [rcx], 0
-;; 1101c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1101d:	 800100               	add	byte ptr [rcx], 0
-;; 11020:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11029:	 800100               	add	byte ptr [rcx], 0
-;; 1102c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1102d:	 800100               	add	byte ptr [rcx], 0
-;; 11030:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11039:	 800100               	add	byte ptr [rcx], 0
-;; 1103c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1103d:	 800100               	add	byte ptr [rcx], 0
-;; 11040:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11049:	 800100               	add	byte ptr [rcx], 0
-;; 1104c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1104d:	 800100               	add	byte ptr [rcx], 0
-;; 11050:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11059:	 800100               	add	byte ptr [rcx], 0
-;; 1105c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1105d:	 800100               	add	byte ptr [rcx], 0
-;; 11060:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11069:	 800100               	add	byte ptr [rcx], 0
-;; 1106c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1106d:	 800100               	add	byte ptr [rcx], 0
-;; 11070:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11079:	 800100               	add	byte ptr [rcx], 0
-;; 1107c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1107d:	 800100               	add	byte ptr [rcx], 0
-;; 11080:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11089:	 800100               	add	byte ptr [rcx], 0
-;; 1108c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1108d:	 800100               	add	byte ptr [rcx], 0
-;; 11090:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11099:	 800100               	add	byte ptr [rcx], 0
-;; 1109c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1109d:	 800100               	add	byte ptr [rcx], 0
-;; 110a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 110a9:	 800100               	add	byte ptr [rcx], 0
-;; 110ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 110ad:	 800100               	add	byte ptr [rcx], 0
-;; 110b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 110b9:	 800100               	add	byte ptr [rcx], 0
-;; 110bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 110bd:	 800100               	add	byte ptr [rcx], 0
-;; 110c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 110c9:	 800100               	add	byte ptr [rcx], 0
-;; 110cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 110cd:	 800100               	add	byte ptr [rcx], 0
-;; 110d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 110d9:	 800100               	add	byte ptr [rcx], 0
-;; 110dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 110dd:	 800100               	add	byte ptr [rcx], 0
-;; 110e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 110e9:	 800100               	add	byte ptr [rcx], 0
-;; 110ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 110ed:	 800100               	add	byte ptr [rcx], 0
-;; 110f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 110f9:	 800100               	add	byte ptr [rcx], 0
-;; 110fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 110fd:	 800100               	add	byte ptr [rcx], 0
-;; 11100:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11109:	 800100               	add	byte ptr [rcx], 0
-;; 1110c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1110d:	 800100               	add	byte ptr [rcx], 0
-;; 11110:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11119:	 800100               	add	byte ptr [rcx], 0
-;; 1111c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1111d:	 800100               	add	byte ptr [rcx], 0
-;; 11120:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11129:	 800100               	add	byte ptr [rcx], 0
-;; 1112c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1112d:	 800100               	add	byte ptr [rcx], 0
-;; 11130:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11139:	 800100               	add	byte ptr [rcx], 0
-;; 1113c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1113d:	 800100               	add	byte ptr [rcx], 0
-;; 11140:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11149:	 800100               	add	byte ptr [rcx], 0
-;; 1114c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1114d:	 800100               	add	byte ptr [rcx], 0
-;; 11150:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11159:	 800100               	add	byte ptr [rcx], 0
-;; 1115c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1115d:	 800100               	add	byte ptr [rcx], 0
-;; 11160:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11169:	 800100               	add	byte ptr [rcx], 0
-;; 1116c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1116d:	 800100               	add	byte ptr [rcx], 0
-;; 11170:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11179:	 800100               	add	byte ptr [rcx], 0
-;; 1117c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1117d:	 800100               	add	byte ptr [rcx], 0
-;; 11180:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11189:	 800100               	add	byte ptr [rcx], 0
-;; 1118c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1118d:	 800100               	add	byte ptr [rcx], 0
-;; 11190:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11199:	 800100               	add	byte ptr [rcx], 0
-;; 1119c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1119d:	 800100               	add	byte ptr [rcx], 0
-;; 111a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 111a9:	 800100               	add	byte ptr [rcx], 0
-;; 111ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 111ad:	 800100               	add	byte ptr [rcx], 0
-;; 111b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 111b9:	 800100               	add	byte ptr [rcx], 0
-;; 111bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 111bd:	 800100               	add	byte ptr [rcx], 0
-;; 111c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 111c9:	 800100               	add	byte ptr [rcx], 0
-;; 111cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 111cd:	 800100               	add	byte ptr [rcx], 0
-;; 111d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 111d9:	 800100               	add	byte ptr [rcx], 0
-;; 111dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 111dd:	 800100               	add	byte ptr [rcx], 0
-;; 111e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 111e9:	 800100               	add	byte ptr [rcx], 0
-;; 111ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 111ed:	 800100               	add	byte ptr [rcx], 0
-;; 111f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 111f9:	 800100               	add	byte ptr [rcx], 0
-;; 111fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 111fd:	 800100               	add	byte ptr [rcx], 0
-;; 11200:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11209:	 800100               	add	byte ptr [rcx], 0
-;; 1120c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1120d:	 800100               	add	byte ptr [rcx], 0
-;; 11210:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11219:	 800100               	add	byte ptr [rcx], 0
-;; 1121c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1121d:	 800100               	add	byte ptr [rcx], 0
-;; 11220:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11229:	 800100               	add	byte ptr [rcx], 0
-;; 1122c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1122d:	 800100               	add	byte ptr [rcx], 0
-;; 11230:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11239:	 800100               	add	byte ptr [rcx], 0
-;; 1123c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1123d:	 800100               	add	byte ptr [rcx], 0
-;; 11240:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11249:	 800100               	add	byte ptr [rcx], 0
-;; 1124c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1124d:	 800100               	add	byte ptr [rcx], 0
-;; 11250:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11259:	 800100               	add	byte ptr [rcx], 0
-;; 1125c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1125d:	 800100               	add	byte ptr [rcx], 0
-;; 11260:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11269:	 800100               	add	byte ptr [rcx], 0
-;; 1126c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1126d:	 800100               	add	byte ptr [rcx], 0
-;; 11270:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11279:	 800100               	add	byte ptr [rcx], 0
-;; 1127c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1127d:	 800100               	add	byte ptr [rcx], 0
-;; 11280:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11289:	 800100               	add	byte ptr [rcx], 0
-;; 1128c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1128d:	 800100               	add	byte ptr [rcx], 0
-;; 11290:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11299:	 800100               	add	byte ptr [rcx], 0
-;; 1129c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1129d:	 800100               	add	byte ptr [rcx], 0
-;; 112a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 112a9:	 800100               	add	byte ptr [rcx], 0
-;; 112ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 112ad:	 800100               	add	byte ptr [rcx], 0
-;; 112b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 112b9:	 800100               	add	byte ptr [rcx], 0
-;; 112bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 112bd:	 800100               	add	byte ptr [rcx], 0
-;; 112c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 112c9:	 800100               	add	byte ptr [rcx], 0
-;; 112cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 112cd:	 800100               	add	byte ptr [rcx], 0
-;; 112d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 112d9:	 800100               	add	byte ptr [rcx], 0
-;; 112dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 112dd:	 800100               	add	byte ptr [rcx], 0
-;; 112e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 112e9:	 800100               	add	byte ptr [rcx], 0
-;; 112ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 112ed:	 800100               	add	byte ptr [rcx], 0
-;; 112f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 112f9:	 800100               	add	byte ptr [rcx], 0
-;; 112fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 112fd:	 800100               	add	byte ptr [rcx], 0
-;; 11300:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11309:	 800100               	add	byte ptr [rcx], 0
-;; 1130c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1130d:	 800100               	add	byte ptr [rcx], 0
-;; 11310:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11319:	 800100               	add	byte ptr [rcx], 0
-;; 1131c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1131d:	 800100               	add	byte ptr [rcx], 0
-;; 11320:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11329:	 800100               	add	byte ptr [rcx], 0
-;; 1132c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1132d:	 800100               	add	byte ptr [rcx], 0
-;; 11330:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11339:	 800100               	add	byte ptr [rcx], 0
-;; 1133c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1133d:	 800100               	add	byte ptr [rcx], 0
-;; 11340:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11349:	 800100               	add	byte ptr [rcx], 0
-;; 1134c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1134d:	 800100               	add	byte ptr [rcx], 0
-;; 11350:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11359:	 800100               	add	byte ptr [rcx], 0
-;; 1135c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1135d:	 800100               	add	byte ptr [rcx], 0
-;; 11360:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11369:	 800100               	add	byte ptr [rcx], 0
-;; 1136c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1136d:	 800100               	add	byte ptr [rcx], 0
-;; 11370:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11379:	 800100               	add	byte ptr [rcx], 0
-;; 1137c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1137d:	 800100               	add	byte ptr [rcx], 0
-;; 11380:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11389:	 800100               	add	byte ptr [rcx], 0
-;; 1138c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1138d:	 800100               	add	byte ptr [rcx], 0
-;; 11390:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11399:	 800100               	add	byte ptr [rcx], 0
-;; 1139c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1139d:	 800100               	add	byte ptr [rcx], 0
-;; 113a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 113a9:	 800100               	add	byte ptr [rcx], 0
-;; 113ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 113ad:	 800100               	add	byte ptr [rcx], 0
-;; 113b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 113b9:	 800100               	add	byte ptr [rcx], 0
-;; 113bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 113bd:	 800100               	add	byte ptr [rcx], 0
-;; 113c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 113c9:	 800100               	add	byte ptr [rcx], 0
-;; 113cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 113cd:	 800100               	add	byte ptr [rcx], 0
-;; 113d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 113d9:	 800100               	add	byte ptr [rcx], 0
-;; 113dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 113dd:	 800100               	add	byte ptr [rcx], 0
-;; 113e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 113e9:	 800100               	add	byte ptr [rcx], 0
-;; 113ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 113ed:	 800100               	add	byte ptr [rcx], 0
-;; 113f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 113f9:	 800100               	add	byte ptr [rcx], 0
-;; 113fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 113fd:	 800100               	add	byte ptr [rcx], 0
-;; 11400:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11409:	 800100               	add	byte ptr [rcx], 0
-;; 1140c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1140d:	 800100               	add	byte ptr [rcx], 0
-;; 11410:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11419:	 800100               	add	byte ptr [rcx], 0
-;; 1141c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1141d:	 800100               	add	byte ptr [rcx], 0
-;; 11420:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11429:	 800100               	add	byte ptr [rcx], 0
-;; 1142c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1142d:	 800100               	add	byte ptr [rcx], 0
-;; 11430:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11439:	 800100               	add	byte ptr [rcx], 0
-;; 1143c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1143d:	 800100               	add	byte ptr [rcx], 0
-;; 11440:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11449:	 800100               	add	byte ptr [rcx], 0
-;; 1144c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1144d:	 800100               	add	byte ptr [rcx], 0
-;; 11450:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11459:	 800100               	add	byte ptr [rcx], 0
-;; 1145c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1145d:	 800100               	add	byte ptr [rcx], 0
-;; 11460:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11469:	 800100               	add	byte ptr [rcx], 0
-;; 1146c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1146d:	 800100               	add	byte ptr [rcx], 0
-;; 11470:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11479:	 800100               	add	byte ptr [rcx], 0
-;; 1147c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1147d:	 800100               	add	byte ptr [rcx], 0
-;; 11480:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11489:	 800100               	add	byte ptr [rcx], 0
-;; 1148c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1148d:	 800100               	add	byte ptr [rcx], 0
-;; 11490:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11499:	 800100               	add	byte ptr [rcx], 0
-;; 1149c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1149d:	 800100               	add	byte ptr [rcx], 0
-;; 114a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 114a9:	 800100               	add	byte ptr [rcx], 0
-;; 114ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 114ad:	 800100               	add	byte ptr [rcx], 0
-;; 114b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 114b9:	 800100               	add	byte ptr [rcx], 0
-;; 114bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 114bd:	 800100               	add	byte ptr [rcx], 0
-;; 114c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 114c9:	 800100               	add	byte ptr [rcx], 0
-;; 114cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 114cd:	 800100               	add	byte ptr [rcx], 0
-;; 114d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 114d9:	 800100               	add	byte ptr [rcx], 0
-;; 114dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 114dd:	 800100               	add	byte ptr [rcx], 0
-;; 114e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 114e9:	 800100               	add	byte ptr [rcx], 0
-;; 114ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 114ed:	 800100               	add	byte ptr [rcx], 0
-;; 114f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 114f9:	 800100               	add	byte ptr [rcx], 0
-;; 114fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 114fd:	 800100               	add	byte ptr [rcx], 0
-;; 11500:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11509:	 800100               	add	byte ptr [rcx], 0
-;; 1150c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1150d:	 800100               	add	byte ptr [rcx], 0
-;; 11510:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11519:	 800100               	add	byte ptr [rcx], 0
-;; 1151c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1151d:	 800100               	add	byte ptr [rcx], 0
-;; 11520:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11529:	 800100               	add	byte ptr [rcx], 0
-;; 1152c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1152d:	 800100               	add	byte ptr [rcx], 0
-;; 11530:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11539:	 800100               	add	byte ptr [rcx], 0
-;; 1153c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1153d:	 800100               	add	byte ptr [rcx], 0
-;; 11540:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11549:	 800100               	add	byte ptr [rcx], 0
-;; 1154c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1154d:	 800100               	add	byte ptr [rcx], 0
-;; 11550:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11559:	 800100               	add	byte ptr [rcx], 0
-;; 1155c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1155d:	 800100               	add	byte ptr [rcx], 0
-;; 11560:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11569:	 800100               	add	byte ptr [rcx], 0
-;; 1156c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1156d:	 800100               	add	byte ptr [rcx], 0
-;; 11570:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11579:	 800100               	add	byte ptr [rcx], 0
-;; 1157c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1157d:	 800100               	add	byte ptr [rcx], 0
-;; 11580:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11589:	 800100               	add	byte ptr [rcx], 0
-;; 1158c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1158d:	 800100               	add	byte ptr [rcx], 0
-;; 11590:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11599:	 800100               	add	byte ptr [rcx], 0
-;; 1159c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1159d:	 800100               	add	byte ptr [rcx], 0
-;; 115a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 115a9:	 800100               	add	byte ptr [rcx], 0
-;; 115ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 115ad:	 800100               	add	byte ptr [rcx], 0
-;; 115b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 115b9:	 800100               	add	byte ptr [rcx], 0
-;; 115bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 115bd:	 800100               	add	byte ptr [rcx], 0
-;; 115c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 115c9:	 800100               	add	byte ptr [rcx], 0
-;; 115cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 115cd:	 800100               	add	byte ptr [rcx], 0
-;; 115d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 115d9:	 800100               	add	byte ptr [rcx], 0
-;; 115dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 115dd:	 800100               	add	byte ptr [rcx], 0
-;; 115e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 115e9:	 800100               	add	byte ptr [rcx], 0
-;; 115ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 115ed:	 800100               	add	byte ptr [rcx], 0
-;; 115f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 115f9:	 800100               	add	byte ptr [rcx], 0
-;; 115fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 115fd:	 800100               	add	byte ptr [rcx], 0
-;; 11600:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11609:	 800100               	add	byte ptr [rcx], 0
-;; 1160c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1160d:	 800100               	add	byte ptr [rcx], 0
-;; 11610:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11619:	 800100               	add	byte ptr [rcx], 0
-;; 1161c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1161d:	 800100               	add	byte ptr [rcx], 0
-;; 11620:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11629:	 800100               	add	byte ptr [rcx], 0
-;; 1162c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1162d:	 800100               	add	byte ptr [rcx], 0
-;; 11630:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11639:	 800100               	add	byte ptr [rcx], 0
-;; 1163c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1163d:	 800100               	add	byte ptr [rcx], 0
-;; 11640:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11649:	 800100               	add	byte ptr [rcx], 0
-;; 1164c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1164d:	 800100               	add	byte ptr [rcx], 0
-;; 11650:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11659:	 800100               	add	byte ptr [rcx], 0
-;; 1165c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1165d:	 800100               	add	byte ptr [rcx], 0
-;; 11660:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11669:	 800100               	add	byte ptr [rcx], 0
-;; 1166c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1166d:	 800100               	add	byte ptr [rcx], 0
-;; 11670:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11679:	 800100               	add	byte ptr [rcx], 0
-;; 1167c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1167d:	 800100               	add	byte ptr [rcx], 0
-;; 11680:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11689:	 800100               	add	byte ptr [rcx], 0
-;; 1168c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1168d:	 800100               	add	byte ptr [rcx], 0
-;; 11690:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11699:	 800100               	add	byte ptr [rcx], 0
-;; 1169c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1169d:	 800100               	add	byte ptr [rcx], 0
-;; 116a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 116a9:	 800100               	add	byte ptr [rcx], 0
-;; 116ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 116ad:	 800100               	add	byte ptr [rcx], 0
-;; 116b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 116b9:	 800100               	add	byte ptr [rcx], 0
-;; 116bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 116bd:	 800100               	add	byte ptr [rcx], 0
-;; 116c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 116c9:	 800100               	add	byte ptr [rcx], 0
-;; 116cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 116cd:	 800100               	add	byte ptr [rcx], 0
-;; 116d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 116d9:	 800100               	add	byte ptr [rcx], 0
-;; 116dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 116dd:	 800100               	add	byte ptr [rcx], 0
-;; 116e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 116e9:	 800100               	add	byte ptr [rcx], 0
-;; 116ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 116ed:	 800100               	add	byte ptr [rcx], 0
-;; 116f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 116f9:	 800100               	add	byte ptr [rcx], 0
-;; 116fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 116fd:	 800100               	add	byte ptr [rcx], 0
-;; 11700:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11709:	 800100               	add	byte ptr [rcx], 0
-;; 1170c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1170d:	 800100               	add	byte ptr [rcx], 0
-;; 11710:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11719:	 800100               	add	byte ptr [rcx], 0
-;; 1171c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1171d:	 800100               	add	byte ptr [rcx], 0
-;; 11720:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11729:	 800100               	add	byte ptr [rcx], 0
-;; 1172c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1172d:	 800100               	add	byte ptr [rcx], 0
-;; 11730:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11739:	 800100               	add	byte ptr [rcx], 0
-;; 1173c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1173d:	 800100               	add	byte ptr [rcx], 0
-;; 11740:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11749:	 800100               	add	byte ptr [rcx], 0
-;; 1174c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1174d:	 800100               	add	byte ptr [rcx], 0
-;; 11750:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11759:	 800100               	add	byte ptr [rcx], 0
-;; 1175c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1175d:	 800100               	add	byte ptr [rcx], 0
-;; 11760:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11769:	 800100               	add	byte ptr [rcx], 0
-;; 1176c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1176d:	 800100               	add	byte ptr [rcx], 0
-;; 11770:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11779:	 800100               	add	byte ptr [rcx], 0
-;; 1177c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1177d:	 800100               	add	byte ptr [rcx], 0
-;; 11780:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11789:	 800100               	add	byte ptr [rcx], 0
-;; 1178c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1178d:	 800100               	add	byte ptr [rcx], 0
-;; 11790:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11799:	 800100               	add	byte ptr [rcx], 0
-;; 1179c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1179d:	 800100               	add	byte ptr [rcx], 0
-;; 117a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 117a9:	 800100               	add	byte ptr [rcx], 0
-;; 117ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 117ad:	 800100               	add	byte ptr [rcx], 0
-;; 117b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 117b9:	 800100               	add	byte ptr [rcx], 0
-;; 117bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 117bd:	 800100               	add	byte ptr [rcx], 0
-;; 117c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 117c9:	 800100               	add	byte ptr [rcx], 0
-;; 117cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 117cd:	 800100               	add	byte ptr [rcx], 0
-;; 117d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 117d9:	 800100               	add	byte ptr [rcx], 0
-;; 117dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 117dd:	 800100               	add	byte ptr [rcx], 0
-;; 117e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 117e9:	 800100               	add	byte ptr [rcx], 0
-;; 117ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 117ed:	 800100               	add	byte ptr [rcx], 0
-;; 117f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 117f9:	 800100               	add	byte ptr [rcx], 0
-;; 117fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 117fd:	 800100               	add	byte ptr [rcx], 0
-;; 11800:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11809:	 800100               	add	byte ptr [rcx], 0
-;; 1180c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1180d:	 800100               	add	byte ptr [rcx], 0
-;; 11810:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11819:	 800100               	add	byte ptr [rcx], 0
-;; 1181c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1181d:	 800100               	add	byte ptr [rcx], 0
-;; 11820:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11829:	 800100               	add	byte ptr [rcx], 0
-;; 1182c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1182d:	 800100               	add	byte ptr [rcx], 0
-;; 11830:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11839:	 800100               	add	byte ptr [rcx], 0
-;; 1183c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1183d:	 800100               	add	byte ptr [rcx], 0
-;; 11840:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11849:	 800100               	add	byte ptr [rcx], 0
-;; 1184c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1184d:	 800100               	add	byte ptr [rcx], 0
-;; 11850:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11859:	 800100               	add	byte ptr [rcx], 0
-;; 1185c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1185d:	 800100               	add	byte ptr [rcx], 0
-;; 11860:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11869:	 800100               	add	byte ptr [rcx], 0
-;; 1186c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1186d:	 800100               	add	byte ptr [rcx], 0
-;; 11870:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11879:	 800100               	add	byte ptr [rcx], 0
-;; 1187c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1187d:	 800100               	add	byte ptr [rcx], 0
-;; 11880:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11889:	 800100               	add	byte ptr [rcx], 0
-;; 1188c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1188d:	 800100               	add	byte ptr [rcx], 0
-;; 11890:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11899:	 800100               	add	byte ptr [rcx], 0
-;; 1189c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1189d:	 800100               	add	byte ptr [rcx], 0
-;; 118a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 118a9:	 800100               	add	byte ptr [rcx], 0
-;; 118ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 118ad:	 800100               	add	byte ptr [rcx], 0
-;; 118b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 118b9:	 800100               	add	byte ptr [rcx], 0
-;; 118bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 118bd:	 800100               	add	byte ptr [rcx], 0
-;; 118c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 118c9:	 800100               	add	byte ptr [rcx], 0
-;; 118cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 118cd:	 800100               	add	byte ptr [rcx], 0
-;; 118d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 118d9:	 800100               	add	byte ptr [rcx], 0
-;; 118dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 118dd:	 800100               	add	byte ptr [rcx], 0
-;; 118e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 118e9:	 800100               	add	byte ptr [rcx], 0
-;; 118ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 118ed:	 800100               	add	byte ptr [rcx], 0
-;; 118f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 118f9:	 800100               	add	byte ptr [rcx], 0
-;; 118fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 118fd:	 800100               	add	byte ptr [rcx], 0
-;; 11900:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11909:	 800100               	add	byte ptr [rcx], 0
-;; 1190c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1190d:	 800100               	add	byte ptr [rcx], 0
-;; 11910:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11919:	 800100               	add	byte ptr [rcx], 0
-;; 1191c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1191d:	 800100               	add	byte ptr [rcx], 0
-;; 11920:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11929:	 800100               	add	byte ptr [rcx], 0
-;; 1192c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1192d:	 800100               	add	byte ptr [rcx], 0
-;; 11930:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11939:	 800100               	add	byte ptr [rcx], 0
-;; 1193c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1193d:	 800100               	add	byte ptr [rcx], 0
-;; 11940:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11949:	 800100               	add	byte ptr [rcx], 0
-;; 1194c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1194d:	 800100               	add	byte ptr [rcx], 0
-;; 11950:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11959:	 800100               	add	byte ptr [rcx], 0
-;; 1195c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1195d:	 800100               	add	byte ptr [rcx], 0
-;; 11960:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11969:	 800100               	add	byte ptr [rcx], 0
-;; 1196c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1196d:	 800100               	add	byte ptr [rcx], 0
-;; 11970:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11979:	 800100               	add	byte ptr [rcx], 0
-;; 1197c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1197d:	 800100               	add	byte ptr [rcx], 0
-;; 11980:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11989:	 800100               	add	byte ptr [rcx], 0
-;; 1198c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1198d:	 800100               	add	byte ptr [rcx], 0
-;; 11990:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11999:	 800100               	add	byte ptr [rcx], 0
-;; 1199c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1199d:	 800100               	add	byte ptr [rcx], 0
-;; 119a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 119a9:	 800100               	add	byte ptr [rcx], 0
-;; 119ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 119ad:	 800100               	add	byte ptr [rcx], 0
-;; 119b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 119b9:	 800100               	add	byte ptr [rcx], 0
-;; 119bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 119bd:	 800100               	add	byte ptr [rcx], 0
-;; 119c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 119c9:	 800100               	add	byte ptr [rcx], 0
-;; 119cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 119cd:	 800100               	add	byte ptr [rcx], 0
-;; 119d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 119d9:	 800100               	add	byte ptr [rcx], 0
-;; 119dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 119dd:	 800100               	add	byte ptr [rcx], 0
-;; 119e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 119e9:	 800100               	add	byte ptr [rcx], 0
-;; 119ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 119ed:	 800100               	add	byte ptr [rcx], 0
-;; 119f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 119f9:	 800100               	add	byte ptr [rcx], 0
-;; 119fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 119fd:	 800100               	add	byte ptr [rcx], 0
-;; 11a00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11a09:	 800100               	add	byte ptr [rcx], 0
-;; 11a0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11a0d:	 800100               	add	byte ptr [rcx], 0
-;; 11a10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11a19:	 800100               	add	byte ptr [rcx], 0
-;; 11a1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11a1d:	 800100               	add	byte ptr [rcx], 0
-;; 11a20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11a29:	 800100               	add	byte ptr [rcx], 0
-;; 11a2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11a2d:	 800100               	add	byte ptr [rcx], 0
-;; 11a30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11a39:	 800100               	add	byte ptr [rcx], 0
-;; 11a3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11a3d:	 800100               	add	byte ptr [rcx], 0
-;; 11a40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11a49:	 800100               	add	byte ptr [rcx], 0
-;; 11a4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11a4d:	 800100               	add	byte ptr [rcx], 0
-;; 11a50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11a59:	 800100               	add	byte ptr [rcx], 0
-;; 11a5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11a5d:	 800100               	add	byte ptr [rcx], 0
-;; 11a60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11a69:	 800100               	add	byte ptr [rcx], 0
-;; 11a6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11a6d:	 800100               	add	byte ptr [rcx], 0
-;; 11a70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11a79:	 800100               	add	byte ptr [rcx], 0
-;; 11a7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11a7d:	 800100               	add	byte ptr [rcx], 0
-;; 11a80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11a89:	 800100               	add	byte ptr [rcx], 0
-;; 11a8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11a8d:	 800100               	add	byte ptr [rcx], 0
-;; 11a90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11a99:	 800100               	add	byte ptr [rcx], 0
-;; 11a9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11a9d:	 800100               	add	byte ptr [rcx], 0
-;; 11aa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11aa9:	 800100               	add	byte ptr [rcx], 0
-;; 11aac:	 aa                   	stosb	byte ptr [rdi], al
-;; 11aad:	 800100               	add	byte ptr [rcx], 0
-;; 11ab0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11ab9:	 800100               	add	byte ptr [rcx], 0
-;; 11abc:	 aa                   	stosb	byte ptr [rdi], al
-;; 11abd:	 800100               	add	byte ptr [rcx], 0
-;; 11ac0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11ac9:	 800100               	add	byte ptr [rcx], 0
-;; 11acc:	 aa                   	stosb	byte ptr [rdi], al
-;; 11acd:	 800100               	add	byte ptr [rcx], 0
-;; 11ad0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11ad9:	 800100               	add	byte ptr [rcx], 0
-;; 11adc:	 aa                   	stosb	byte ptr [rdi], al
-;; 11add:	 800100               	add	byte ptr [rcx], 0
-;; 11ae0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11ae9:	 800100               	add	byte ptr [rcx], 0
-;; 11aec:	 aa                   	stosb	byte ptr [rdi], al
-;; 11aed:	 800100               	add	byte ptr [rcx], 0
-;; 11af0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11af9:	 800100               	add	byte ptr [rcx], 0
-;; 11afc:	 aa                   	stosb	byte ptr [rdi], al
-;; 11afd:	 800100               	add	byte ptr [rcx], 0
-;; 11b00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11b09:	 800100               	add	byte ptr [rcx], 0
-;; 11b0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11b0d:	 800100               	add	byte ptr [rcx], 0
-;; 11b10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11b19:	 800100               	add	byte ptr [rcx], 0
-;; 11b1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11b1d:	 800100               	add	byte ptr [rcx], 0
-;; 11b20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11b29:	 800100               	add	byte ptr [rcx], 0
-;; 11b2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11b2d:	 800100               	add	byte ptr [rcx], 0
-;; 11b30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11b39:	 800100               	add	byte ptr [rcx], 0
-;; 11b3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11b3d:	 800100               	add	byte ptr [rcx], 0
-;; 11b40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11b49:	 800100               	add	byte ptr [rcx], 0
-;; 11b4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11b4d:	 800100               	add	byte ptr [rcx], 0
-;; 11b50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11b59:	 800100               	add	byte ptr [rcx], 0
-;; 11b5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11b5d:	 800100               	add	byte ptr [rcx], 0
-;; 11b60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11b69:	 800100               	add	byte ptr [rcx], 0
-;; 11b6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11b6d:	 800100               	add	byte ptr [rcx], 0
-;; 11b70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11b79:	 800100               	add	byte ptr [rcx], 0
-;; 11b7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11b7d:	 800100               	add	byte ptr [rcx], 0
-;; 11b80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11b89:	 800100               	add	byte ptr [rcx], 0
-;; 11b8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11b8d:	 800100               	add	byte ptr [rcx], 0
-;; 11b90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11b99:	 800100               	add	byte ptr [rcx], 0
-;; 11b9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11b9d:	 800100               	add	byte ptr [rcx], 0
-;; 11ba0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11ba9:	 800100               	add	byte ptr [rcx], 0
-;; 11bac:	 aa                   	stosb	byte ptr [rdi], al
-;; 11bad:	 800100               	add	byte ptr [rcx], 0
-;; 11bb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11bb9:	 800100               	add	byte ptr [rcx], 0
-;; 11bbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 11bbd:	 800100               	add	byte ptr [rcx], 0
-;; 11bc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11bc9:	 800100               	add	byte ptr [rcx], 0
-;; 11bcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 11bcd:	 800100               	add	byte ptr [rcx], 0
-;; 11bd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11bd9:	 800100               	add	byte ptr [rcx], 0
-;; 11bdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 11bdd:	 800100               	add	byte ptr [rcx], 0
-;; 11be0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11be9:	 800100               	add	byte ptr [rcx], 0
-;; 11bec:	 aa                   	stosb	byte ptr [rdi], al
-;; 11bed:	 800100               	add	byte ptr [rcx], 0
-;; 11bf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11bf9:	 800100               	add	byte ptr [rcx], 0
-;; 11bfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 11bfd:	 800100               	add	byte ptr [rcx], 0
-;; 11c00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11c09:	 800100               	add	byte ptr [rcx], 0
-;; 11c0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11c0d:	 800100               	add	byte ptr [rcx], 0
-;; 11c10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11c19:	 800100               	add	byte ptr [rcx], 0
-;; 11c1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11c1d:	 800100               	add	byte ptr [rcx], 0
-;; 11c20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11c29:	 800100               	add	byte ptr [rcx], 0
-;; 11c2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11c2d:	 800100               	add	byte ptr [rcx], 0
-;; 11c30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11c39:	 800100               	add	byte ptr [rcx], 0
-;; 11c3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11c3d:	 800100               	add	byte ptr [rcx], 0
-;; 11c40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11c49:	 800100               	add	byte ptr [rcx], 0
-;; 11c4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11c4d:	 800100               	add	byte ptr [rcx], 0
-;; 11c50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11c59:	 800100               	add	byte ptr [rcx], 0
-;; 11c5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11c5d:	 800100               	add	byte ptr [rcx], 0
-;; 11c60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11c69:	 800100               	add	byte ptr [rcx], 0
-;; 11c6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11c6d:	 800100               	add	byte ptr [rcx], 0
-;; 11c70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11c79:	 800100               	add	byte ptr [rcx], 0
-;; 11c7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11c7d:	 800100               	add	byte ptr [rcx], 0
-;; 11c80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11c89:	 800100               	add	byte ptr [rcx], 0
-;; 11c8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11c8d:	 800100               	add	byte ptr [rcx], 0
-;; 11c90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11c99:	 800100               	add	byte ptr [rcx], 0
-;; 11c9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11c9d:	 800100               	add	byte ptr [rcx], 0
-;; 11ca0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11ca9:	 800100               	add	byte ptr [rcx], 0
-;; 11cac:	 aa                   	stosb	byte ptr [rdi], al
-;; 11cad:	 800100               	add	byte ptr [rcx], 0
-;; 11cb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11cb9:	 800100               	add	byte ptr [rcx], 0
-;; 11cbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 11cbd:	 800100               	add	byte ptr [rcx], 0
-;; 11cc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11cc9:	 800100               	add	byte ptr [rcx], 0
-;; 11ccc:	 aa                   	stosb	byte ptr [rdi], al
-;; 11ccd:	 800100               	add	byte ptr [rcx], 0
-;; 11cd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11cd9:	 800100               	add	byte ptr [rcx], 0
-;; 11cdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 11cdd:	 800100               	add	byte ptr [rcx], 0
-;; 11ce0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11ce9:	 800100               	add	byte ptr [rcx], 0
-;; 11cec:	 aa                   	stosb	byte ptr [rdi], al
-;; 11ced:	 800100               	add	byte ptr [rcx], 0
-;; 11cf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11cf9:	 800100               	add	byte ptr [rcx], 0
-;; 11cfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 11cfd:	 800100               	add	byte ptr [rcx], 0
-;; 11d00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11d09:	 800100               	add	byte ptr [rcx], 0
-;; 11d0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11d0d:	 800100               	add	byte ptr [rcx], 0
-;; 11d10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11d19:	 800100               	add	byte ptr [rcx], 0
-;; 11d1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11d1d:	 800100               	add	byte ptr [rcx], 0
-;; 11d20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11d29:	 800100               	add	byte ptr [rcx], 0
-;; 11d2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11d2d:	 800100               	add	byte ptr [rcx], 0
-;; 11d30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11d39:	 800100               	add	byte ptr [rcx], 0
-;; 11d3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11d3d:	 800100               	add	byte ptr [rcx], 0
-;; 11d40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11d49:	 800100               	add	byte ptr [rcx], 0
-;; 11d4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11d4d:	 800100               	add	byte ptr [rcx], 0
-;; 11d50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11d59:	 800100               	add	byte ptr [rcx], 0
-;; 11d5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11d5d:	 800100               	add	byte ptr [rcx], 0
-;; 11d60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11d69:	 800100               	add	byte ptr [rcx], 0
-;; 11d6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11d6d:	 800100               	add	byte ptr [rcx], 0
-;; 11d70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11d79:	 800100               	add	byte ptr [rcx], 0
-;; 11d7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11d7d:	 800100               	add	byte ptr [rcx], 0
-;; 11d80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11d89:	 800100               	add	byte ptr [rcx], 0
-;; 11d8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11d8d:	 800100               	add	byte ptr [rcx], 0
-;; 11d90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11d99:	 800100               	add	byte ptr [rcx], 0
-;; 11d9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11d9d:	 800100               	add	byte ptr [rcx], 0
-;; 11da0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11da9:	 800100               	add	byte ptr [rcx], 0
-;; 11dac:	 aa                   	stosb	byte ptr [rdi], al
-;; 11dad:	 800100               	add	byte ptr [rcx], 0
-;; 11db0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11db9:	 800100               	add	byte ptr [rcx], 0
-;; 11dbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 11dbd:	 800100               	add	byte ptr [rcx], 0
-;; 11dc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11dc9:	 800100               	add	byte ptr [rcx], 0
-;; 11dcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 11dcd:	 800100               	add	byte ptr [rcx], 0
-;; 11dd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11dd9:	 800100               	add	byte ptr [rcx], 0
-;; 11ddc:	 aa                   	stosb	byte ptr [rdi], al
-;; 11ddd:	 800100               	add	byte ptr [rcx], 0
-;; 11de0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11de9:	 800100               	add	byte ptr [rcx], 0
-;; 11dec:	 aa                   	stosb	byte ptr [rdi], al
-;; 11ded:	 800100               	add	byte ptr [rcx], 0
-;; 11df0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11df9:	 800100               	add	byte ptr [rcx], 0
-;; 11dfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 11dfd:	 800100               	add	byte ptr [rcx], 0
-;; 11e00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11e09:	 800100               	add	byte ptr [rcx], 0
-;; 11e0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11e0d:	 800100               	add	byte ptr [rcx], 0
-;; 11e10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11e19:	 800100               	add	byte ptr [rcx], 0
-;; 11e1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11e1d:	 800100               	add	byte ptr [rcx], 0
-;; 11e20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11e29:	 800100               	add	byte ptr [rcx], 0
-;; 11e2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11e2d:	 800100               	add	byte ptr [rcx], 0
-;; 11e30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11e39:	 800100               	add	byte ptr [rcx], 0
-;; 11e3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11e3d:	 800100               	add	byte ptr [rcx], 0
-;; 11e40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11e49:	 800100               	add	byte ptr [rcx], 0
-;; 11e4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11e4d:	 800100               	add	byte ptr [rcx], 0
-;; 11e50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11e59:	 800100               	add	byte ptr [rcx], 0
-;; 11e5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11e5d:	 800100               	add	byte ptr [rcx], 0
-;; 11e60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11e69:	 800100               	add	byte ptr [rcx], 0
-;; 11e6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11e6d:	 800100               	add	byte ptr [rcx], 0
-;; 11e70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11e79:	 800100               	add	byte ptr [rcx], 0
-;; 11e7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11e7d:	 800100               	add	byte ptr [rcx], 0
-;; 11e80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11e89:	 800100               	add	byte ptr [rcx], 0
-;; 11e8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11e8d:	 800100               	add	byte ptr [rcx], 0
-;; 11e90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11e99:	 800100               	add	byte ptr [rcx], 0
-;; 11e9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11e9d:	 800100               	add	byte ptr [rcx], 0
-;; 11ea0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11ea9:	 800100               	add	byte ptr [rcx], 0
-;; 11eac:	 aa                   	stosb	byte ptr [rdi], al
-;; 11ead:	 800100               	add	byte ptr [rcx], 0
-;; 11eb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11eb9:	 800100               	add	byte ptr [rcx], 0
-;; 11ebc:	 aa                   	stosb	byte ptr [rdi], al
-;; 11ebd:	 800100               	add	byte ptr [rcx], 0
-;; 11ec0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11ec9:	 800100               	add	byte ptr [rcx], 0
-;; 11ecc:	 aa                   	stosb	byte ptr [rdi], al
-;; 11ecd:	 800100               	add	byte ptr [rcx], 0
-;; 11ed0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11ed9:	 800100               	add	byte ptr [rcx], 0
-;; 11edc:	 aa                   	stosb	byte ptr [rdi], al
-;; 11edd:	 800100               	add	byte ptr [rcx], 0
-;; 11ee0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11ee9:	 800100               	add	byte ptr [rcx], 0
-;; 11eec:	 aa                   	stosb	byte ptr [rdi], al
-;; 11eed:	 800100               	add	byte ptr [rcx], 0
-;; 11ef0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11ef9:	 800100               	add	byte ptr [rcx], 0
-;; 11efc:	 aa                   	stosb	byte ptr [rdi], al
-;; 11efd:	 800100               	add	byte ptr [rcx], 0
-;; 11f00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11f09:	 800100               	add	byte ptr [rcx], 0
-;; 11f0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11f0d:	 800100               	add	byte ptr [rcx], 0
-;; 11f10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11f19:	 800100               	add	byte ptr [rcx], 0
-;; 11f1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11f1d:	 800100               	add	byte ptr [rcx], 0
-;; 11f20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11f29:	 800100               	add	byte ptr [rcx], 0
-;; 11f2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11f2d:	 800100               	add	byte ptr [rcx], 0
-;; 11f30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11f39:	 800100               	add	byte ptr [rcx], 0
-;; 11f3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11f3d:	 800100               	add	byte ptr [rcx], 0
-;; 11f40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11f49:	 800100               	add	byte ptr [rcx], 0
-;; 11f4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11f4d:	 800100               	add	byte ptr [rcx], 0
-;; 11f50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11f59:	 800100               	add	byte ptr [rcx], 0
-;; 11f5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11f5d:	 800100               	add	byte ptr [rcx], 0
-;; 11f60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11f69:	 800100               	add	byte ptr [rcx], 0
-;; 11f6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11f6d:	 800100               	add	byte ptr [rcx], 0
-;; 11f70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11f79:	 800100               	add	byte ptr [rcx], 0
-;; 11f7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11f7d:	 800100               	add	byte ptr [rcx], 0
-;; 11f80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11f89:	 800100               	add	byte ptr [rcx], 0
-;; 11f8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11f8d:	 800100               	add	byte ptr [rcx], 0
-;; 11f90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11f99:	 800100               	add	byte ptr [rcx], 0
-;; 11f9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 11f9d:	 800100               	add	byte ptr [rcx], 0
-;; 11fa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11fa9:	 800100               	add	byte ptr [rcx], 0
-;; 11fac:	 aa                   	stosb	byte ptr [rdi], al
-;; 11fad:	 800100               	add	byte ptr [rcx], 0
-;; 11fb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11fb9:	 800100               	add	byte ptr [rcx], 0
-;; 11fbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 11fbd:	 800100               	add	byte ptr [rcx], 0
-;; 11fc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11fc9:	 800100               	add	byte ptr [rcx], 0
-;; 11fcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 11fcd:	 800100               	add	byte ptr [rcx], 0
-;; 11fd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11fd9:	 800100               	add	byte ptr [rcx], 0
-;; 11fdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 11fdd:	 800100               	add	byte ptr [rcx], 0
-;; 11fe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11fe9:	 800100               	add	byte ptr [rcx], 0
-;; 11fec:	 aa                   	stosb	byte ptr [rdi], al
-;; 11fed:	 800100               	add	byte ptr [rcx], 0
-;; 11ff0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 11ff9:	 800100               	add	byte ptr [rcx], 0
-;; 11ffc:	 aa                   	stosb	byte ptr [rdi], al
-;; 11ffd:	 800100               	add	byte ptr [rcx], 0
-;; 12000:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12009:	 800100               	add	byte ptr [rcx], 0
-;; 1200c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1200d:	 800100               	add	byte ptr [rcx], 0
-;; 12010:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12019:	 800100               	add	byte ptr [rcx], 0
-;; 1201c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1201d:	 800100               	add	byte ptr [rcx], 0
-;; 12020:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12029:	 800100               	add	byte ptr [rcx], 0
-;; 1202c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1202d:	 800100               	add	byte ptr [rcx], 0
-;; 12030:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12039:	 800100               	add	byte ptr [rcx], 0
-;; 1203c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1203d:	 800100               	add	byte ptr [rcx], 0
-;; 12040:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12049:	 800100               	add	byte ptr [rcx], 0
-;; 1204c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1204d:	 800100               	add	byte ptr [rcx], 0
-;; 12050:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12059:	 800100               	add	byte ptr [rcx], 0
-;; 1205c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1205d:	 800100               	add	byte ptr [rcx], 0
-;; 12060:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12069:	 800100               	add	byte ptr [rcx], 0
-;; 1206c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1206d:	 800100               	add	byte ptr [rcx], 0
-;; 12070:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12079:	 800100               	add	byte ptr [rcx], 0
-;; 1207c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1207d:	 800100               	add	byte ptr [rcx], 0
-;; 12080:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12089:	 800100               	add	byte ptr [rcx], 0
-;; 1208c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1208d:	 800100               	add	byte ptr [rcx], 0
-;; 12090:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12099:	 800100               	add	byte ptr [rcx], 0
-;; 1209c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1209d:	 800100               	add	byte ptr [rcx], 0
-;; 120a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 120a9:	 800100               	add	byte ptr [rcx], 0
-;; 120ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 120ad:	 800100               	add	byte ptr [rcx], 0
-;; 120b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 120b9:	 800100               	add	byte ptr [rcx], 0
-;; 120bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 120bd:	 800100               	add	byte ptr [rcx], 0
-;; 120c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 120c9:	 800100               	add	byte ptr [rcx], 0
-;; 120cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 120cd:	 800100               	add	byte ptr [rcx], 0
-;; 120d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 120d9:	 800100               	add	byte ptr [rcx], 0
-;; 120dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 120dd:	 800100               	add	byte ptr [rcx], 0
-;; 120e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 120e9:	 800100               	add	byte ptr [rcx], 0
-;; 120ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 120ed:	 800100               	add	byte ptr [rcx], 0
-;; 120f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 120f9:	 800100               	add	byte ptr [rcx], 0
-;; 120fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 120fd:	 800100               	add	byte ptr [rcx], 0
-;; 12100:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12109:	 800100               	add	byte ptr [rcx], 0
-;; 1210c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1210d:	 800100               	add	byte ptr [rcx], 0
-;; 12110:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12119:	 800100               	add	byte ptr [rcx], 0
-;; 1211c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1211d:	 800100               	add	byte ptr [rcx], 0
-;; 12120:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12129:	 800100               	add	byte ptr [rcx], 0
-;; 1212c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1212d:	 800100               	add	byte ptr [rcx], 0
-;; 12130:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12139:	 800100               	add	byte ptr [rcx], 0
-;; 1213c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1213d:	 800100               	add	byte ptr [rcx], 0
-;; 12140:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12149:	 800100               	add	byte ptr [rcx], 0
-;; 1214c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1214d:	 800100               	add	byte ptr [rcx], 0
-;; 12150:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12159:	 800100               	add	byte ptr [rcx], 0
-;; 1215c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1215d:	 800100               	add	byte ptr [rcx], 0
-;; 12160:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12169:	 800100               	add	byte ptr [rcx], 0
-;; 1216c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1216d:	 800100               	add	byte ptr [rcx], 0
-;; 12170:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12179:	 800100               	add	byte ptr [rcx], 0
-;; 1217c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1217d:	 800100               	add	byte ptr [rcx], 0
-;; 12180:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12189:	 800100               	add	byte ptr [rcx], 0
-;; 1218c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1218d:	 800100               	add	byte ptr [rcx], 0
-;; 12190:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12199:	 800100               	add	byte ptr [rcx], 0
-;; 1219c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1219d:	 800100               	add	byte ptr [rcx], 0
-;; 121a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 121a9:	 800100               	add	byte ptr [rcx], 0
-;; 121ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 121ad:	 800100               	add	byte ptr [rcx], 0
-;; 121b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 121b9:	 800100               	add	byte ptr [rcx], 0
-;; 121bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 121bd:	 800100               	add	byte ptr [rcx], 0
-;; 121c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 121c9:	 800100               	add	byte ptr [rcx], 0
-;; 121cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 121cd:	 800100               	add	byte ptr [rcx], 0
-;; 121d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 121d9:	 800100               	add	byte ptr [rcx], 0
-;; 121dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 121dd:	 800100               	add	byte ptr [rcx], 0
-;; 121e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 121e9:	 800100               	add	byte ptr [rcx], 0
-;; 121ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 121ed:	 800100               	add	byte ptr [rcx], 0
-;; 121f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 121f9:	 800100               	add	byte ptr [rcx], 0
-;; 121fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 121fd:	 800100               	add	byte ptr [rcx], 0
-;; 12200:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12209:	 800100               	add	byte ptr [rcx], 0
-;; 1220c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1220d:	 800100               	add	byte ptr [rcx], 0
-;; 12210:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12219:	 800100               	add	byte ptr [rcx], 0
-;; 1221c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1221d:	 800100               	add	byte ptr [rcx], 0
-;; 12220:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12229:	 800100               	add	byte ptr [rcx], 0
-;; 1222c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1222d:	 800100               	add	byte ptr [rcx], 0
-;; 12230:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12239:	 800100               	add	byte ptr [rcx], 0
-;; 1223c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1223d:	 800100               	add	byte ptr [rcx], 0
-;; 12240:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12249:	 800100               	add	byte ptr [rcx], 0
-;; 1224c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1224d:	 800100               	add	byte ptr [rcx], 0
-;; 12250:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12259:	 800100               	add	byte ptr [rcx], 0
-;; 1225c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1225d:	 800100               	add	byte ptr [rcx], 0
-;; 12260:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12269:	 800100               	add	byte ptr [rcx], 0
-;; 1226c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1226d:	 800100               	add	byte ptr [rcx], 0
-;; 12270:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12279:	 800100               	add	byte ptr [rcx], 0
-;; 1227c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1227d:	 800100               	add	byte ptr [rcx], 0
-;; 12280:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12289:	 800100               	add	byte ptr [rcx], 0
-;; 1228c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1228d:	 800100               	add	byte ptr [rcx], 0
-;; 12290:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12299:	 800100               	add	byte ptr [rcx], 0
-;; 1229c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1229d:	 800100               	add	byte ptr [rcx], 0
-;; 122a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 122a9:	 800100               	add	byte ptr [rcx], 0
-;; 122ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 122ad:	 800100               	add	byte ptr [rcx], 0
-;; 122b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 122b9:	 800100               	add	byte ptr [rcx], 0
-;; 122bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 122bd:	 800100               	add	byte ptr [rcx], 0
-;; 122c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 122c9:	 800100               	add	byte ptr [rcx], 0
-;; 122cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 122cd:	 800100               	add	byte ptr [rcx], 0
-;; 122d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 122d9:	 800100               	add	byte ptr [rcx], 0
-;; 122dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 122dd:	 800100               	add	byte ptr [rcx], 0
-;; 122e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 122e9:	 800100               	add	byte ptr [rcx], 0
-;; 122ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 122ed:	 800100               	add	byte ptr [rcx], 0
-;; 122f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 122f9:	 800100               	add	byte ptr [rcx], 0
-;; 122fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 122fd:	 800100               	add	byte ptr [rcx], 0
-;; 12300:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12309:	 800100               	add	byte ptr [rcx], 0
-;; 1230c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1230d:	 800100               	add	byte ptr [rcx], 0
-;; 12310:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12319:	 800100               	add	byte ptr [rcx], 0
-;; 1231c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1231d:	 800100               	add	byte ptr [rcx], 0
-;; 12320:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12329:	 800100               	add	byte ptr [rcx], 0
-;; 1232c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1232d:	 800100               	add	byte ptr [rcx], 0
-;; 12330:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12339:	 800100               	add	byte ptr [rcx], 0
-;; 1233c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1233d:	 800100               	add	byte ptr [rcx], 0
-;; 12340:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12349:	 800100               	add	byte ptr [rcx], 0
-;; 1234c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1234d:	 800100               	add	byte ptr [rcx], 0
-;; 12350:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12359:	 800100               	add	byte ptr [rcx], 0
-;; 1235c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1235d:	 800100               	add	byte ptr [rcx], 0
-;; 12360:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12369:	 800100               	add	byte ptr [rcx], 0
-;; 1236c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1236d:	 800100               	add	byte ptr [rcx], 0
-;; 12370:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12379:	 800100               	add	byte ptr [rcx], 0
-;; 1237c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1237d:	 800100               	add	byte ptr [rcx], 0
-;; 12380:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12389:	 800100               	add	byte ptr [rcx], 0
-;; 1238c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1238d:	 800100               	add	byte ptr [rcx], 0
-;; 12390:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12399:	 800100               	add	byte ptr [rcx], 0
-;; 1239c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1239d:	 800100               	add	byte ptr [rcx], 0
-;; 123a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 123a9:	 800100               	add	byte ptr [rcx], 0
-;; 123ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 123ad:	 800100               	add	byte ptr [rcx], 0
-;; 123b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 123b9:	 800100               	add	byte ptr [rcx], 0
-;; 123bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 123bd:	 800100               	add	byte ptr [rcx], 0
-;; 123c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 123c9:	 800100               	add	byte ptr [rcx], 0
-;; 123cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 123cd:	 800100               	add	byte ptr [rcx], 0
-;; 123d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 123d9:	 800100               	add	byte ptr [rcx], 0
-;; 123dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 123dd:	 800100               	add	byte ptr [rcx], 0
-;; 123e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 123e9:	 800100               	add	byte ptr [rcx], 0
-;; 123ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 123ed:	 800100               	add	byte ptr [rcx], 0
-;; 123f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 123f9:	 800100               	add	byte ptr [rcx], 0
-;; 123fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 123fd:	 800100               	add	byte ptr [rcx], 0
-;; 12400:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12409:	 800100               	add	byte ptr [rcx], 0
-;; 1240c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1240d:	 800100               	add	byte ptr [rcx], 0
-;; 12410:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12419:	 800100               	add	byte ptr [rcx], 0
-;; 1241c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1241d:	 800100               	add	byte ptr [rcx], 0
-;; 12420:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12429:	 800100               	add	byte ptr [rcx], 0
-;; 1242c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1242d:	 800100               	add	byte ptr [rcx], 0
-;; 12430:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12439:	 800100               	add	byte ptr [rcx], 0
-;; 1243c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1243d:	 800100               	add	byte ptr [rcx], 0
-;; 12440:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12449:	 800100               	add	byte ptr [rcx], 0
-;; 1244c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1244d:	 800100               	add	byte ptr [rcx], 0
-;; 12450:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12459:	 800100               	add	byte ptr [rcx], 0
-;; 1245c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1245d:	 800100               	add	byte ptr [rcx], 0
-;; 12460:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12469:	 800100               	add	byte ptr [rcx], 0
-;; 1246c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1246d:	 800100               	add	byte ptr [rcx], 0
-;; 12470:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12479:	 800100               	add	byte ptr [rcx], 0
-;; 1247c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1247d:	 800100               	add	byte ptr [rcx], 0
-;; 12480:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12489:	 800100               	add	byte ptr [rcx], 0
-;; 1248c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1248d:	 800100               	add	byte ptr [rcx], 0
-;; 12490:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12499:	 800100               	add	byte ptr [rcx], 0
-;; 1249c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1249d:	 800100               	add	byte ptr [rcx], 0
-;; 124a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 124a9:	 800100               	add	byte ptr [rcx], 0
-;; 124ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 124ad:	 800100               	add	byte ptr [rcx], 0
-;; 124b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 124b9:	 800100               	add	byte ptr [rcx], 0
-;; 124bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 124bd:	 800100               	add	byte ptr [rcx], 0
-;; 124c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 124c9:	 800100               	add	byte ptr [rcx], 0
-;; 124cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 124cd:	 800100               	add	byte ptr [rcx], 0
-;; 124d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 124d9:	 800100               	add	byte ptr [rcx], 0
-;; 124dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 124dd:	 800100               	add	byte ptr [rcx], 0
-;; 124e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 124e9:	 800100               	add	byte ptr [rcx], 0
-;; 124ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 124ed:	 800100               	add	byte ptr [rcx], 0
-;; 124f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 124f9:	 800100               	add	byte ptr [rcx], 0
-;; 124fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 124fd:	 800100               	add	byte ptr [rcx], 0
-;; 12500:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12509:	 800100               	add	byte ptr [rcx], 0
-;; 1250c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1250d:	 800100               	add	byte ptr [rcx], 0
-;; 12510:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12519:	 800100               	add	byte ptr [rcx], 0
-;; 1251c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1251d:	 800100               	add	byte ptr [rcx], 0
-;; 12520:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12529:	 800100               	add	byte ptr [rcx], 0
-;; 1252c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1252d:	 800100               	add	byte ptr [rcx], 0
-;; 12530:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12539:	 800100               	add	byte ptr [rcx], 0
-;; 1253c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1253d:	 800100               	add	byte ptr [rcx], 0
-;; 12540:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12549:	 800100               	add	byte ptr [rcx], 0
-;; 1254c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1254d:	 800100               	add	byte ptr [rcx], 0
-;; 12550:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12559:	 800100               	add	byte ptr [rcx], 0
-;; 1255c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1255d:	 800100               	add	byte ptr [rcx], 0
-;; 12560:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12569:	 800100               	add	byte ptr [rcx], 0
-;; 1256c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1256d:	 800100               	add	byte ptr [rcx], 0
-;; 12570:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12579:	 800100               	add	byte ptr [rcx], 0
-;; 1257c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1257d:	 800100               	add	byte ptr [rcx], 0
-;; 12580:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12589:	 800100               	add	byte ptr [rcx], 0
-;; 1258c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1258d:	 800100               	add	byte ptr [rcx], 0
-;; 12590:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12599:	 800100               	add	byte ptr [rcx], 0
-;; 1259c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1259d:	 800100               	add	byte ptr [rcx], 0
-;; 125a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 125a9:	 800100               	add	byte ptr [rcx], 0
-;; 125ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 125ad:	 800100               	add	byte ptr [rcx], 0
-;; 125b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 125b9:	 800100               	add	byte ptr [rcx], 0
-;; 125bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 125bd:	 800100               	add	byte ptr [rcx], 0
-;; 125c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 125c9:	 800100               	add	byte ptr [rcx], 0
-;; 125cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 125cd:	 800100               	add	byte ptr [rcx], 0
-;; 125d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 125d9:	 800100               	add	byte ptr [rcx], 0
-;; 125dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 125dd:	 800100               	add	byte ptr [rcx], 0
-;; 125e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 125e9:	 800100               	add	byte ptr [rcx], 0
-;; 125ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 125ed:	 800100               	add	byte ptr [rcx], 0
-;; 125f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 125f9:	 800100               	add	byte ptr [rcx], 0
-;; 125fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 125fd:	 800100               	add	byte ptr [rcx], 0
-;; 12600:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12609:	 800100               	add	byte ptr [rcx], 0
-;; 1260c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1260d:	 800100               	add	byte ptr [rcx], 0
-;; 12610:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12619:	 800100               	add	byte ptr [rcx], 0
-;; 1261c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1261d:	 800100               	add	byte ptr [rcx], 0
-;; 12620:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12629:	 800100               	add	byte ptr [rcx], 0
-;; 1262c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1262d:	 800100               	add	byte ptr [rcx], 0
-;; 12630:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12639:	 800100               	add	byte ptr [rcx], 0
-;; 1263c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1263d:	 800100               	add	byte ptr [rcx], 0
-;; 12640:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12649:	 800100               	add	byte ptr [rcx], 0
-;; 1264c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1264d:	 800100               	add	byte ptr [rcx], 0
-;; 12650:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12659:	 800100               	add	byte ptr [rcx], 0
-;; 1265c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1265d:	 800100               	add	byte ptr [rcx], 0
-;; 12660:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12669:	 800100               	add	byte ptr [rcx], 0
-;; 1266c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1266d:	 800100               	add	byte ptr [rcx], 0
-;; 12670:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12679:	 800100               	add	byte ptr [rcx], 0
-;; 1267c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1267d:	 800100               	add	byte ptr [rcx], 0
-;; 12680:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12689:	 800100               	add	byte ptr [rcx], 0
-;; 1268c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1268d:	 800100               	add	byte ptr [rcx], 0
-;; 12690:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12699:	 800100               	add	byte ptr [rcx], 0
-;; 1269c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1269d:	 800100               	add	byte ptr [rcx], 0
-;; 126a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 126a9:	 800100               	add	byte ptr [rcx], 0
-;; 126ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 126ad:	 800100               	add	byte ptr [rcx], 0
-;; 126b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 126b9:	 800100               	add	byte ptr [rcx], 0
-;; 126bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 126bd:	 800100               	add	byte ptr [rcx], 0
-;; 126c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 126c9:	 800100               	add	byte ptr [rcx], 0
-;; 126cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 126cd:	 800100               	add	byte ptr [rcx], 0
-;; 126d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 126d9:	 800100               	add	byte ptr [rcx], 0
-;; 126dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 126dd:	 800100               	add	byte ptr [rcx], 0
-;; 126e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 126e9:	 800100               	add	byte ptr [rcx], 0
-;; 126ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 126ed:	 800100               	add	byte ptr [rcx], 0
-;; 126f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 126f9:	 800100               	add	byte ptr [rcx], 0
-;; 126fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 126fd:	 800100               	add	byte ptr [rcx], 0
-;; 12700:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12709:	 800100               	add	byte ptr [rcx], 0
-;; 1270c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1270d:	 800100               	add	byte ptr [rcx], 0
-;; 12710:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12719:	 800100               	add	byte ptr [rcx], 0
-;; 1271c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1271d:	 800100               	add	byte ptr [rcx], 0
-;; 12720:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12729:	 800100               	add	byte ptr [rcx], 0
-;; 1272c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1272d:	 800100               	add	byte ptr [rcx], 0
-;; 12730:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12739:	 800100               	add	byte ptr [rcx], 0
-;; 1273c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1273d:	 800100               	add	byte ptr [rcx], 0
-;; 12740:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12749:	 800100               	add	byte ptr [rcx], 0
-;; 1274c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1274d:	 800100               	add	byte ptr [rcx], 0
-;; 12750:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12759:	 800100               	add	byte ptr [rcx], 0
-;; 1275c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1275d:	 800100               	add	byte ptr [rcx], 0
-;; 12760:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12769:	 800100               	add	byte ptr [rcx], 0
-;; 1276c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1276d:	 800100               	add	byte ptr [rcx], 0
-;; 12770:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12779:	 800100               	add	byte ptr [rcx], 0
-;; 1277c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1277d:	 800100               	add	byte ptr [rcx], 0
-;; 12780:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12789:	 800100               	add	byte ptr [rcx], 0
-;; 1278c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1278d:	 800100               	add	byte ptr [rcx], 0
-;; 12790:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12799:	 800100               	add	byte ptr [rcx], 0
-;; 1279c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1279d:	 800100               	add	byte ptr [rcx], 0
-;; 127a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 127a9:	 800100               	add	byte ptr [rcx], 0
-;; 127ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 127ad:	 800100               	add	byte ptr [rcx], 0
-;; 127b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 127b9:	 800100               	add	byte ptr [rcx], 0
-;; 127bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 127bd:	 800100               	add	byte ptr [rcx], 0
-;; 127c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 127c9:	 800100               	add	byte ptr [rcx], 0
-;; 127cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 127cd:	 800100               	add	byte ptr [rcx], 0
-;; 127d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 127d9:	 800100               	add	byte ptr [rcx], 0
-;; 127dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 127dd:	 800100               	add	byte ptr [rcx], 0
-;; 127e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 127e9:	 800100               	add	byte ptr [rcx], 0
-;; 127ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 127ed:	 800100               	add	byte ptr [rcx], 0
-;; 127f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 127f9:	 800100               	add	byte ptr [rcx], 0
-;; 127fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 127fd:	 800100               	add	byte ptr [rcx], 0
-;; 12800:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12809:	 800100               	add	byte ptr [rcx], 0
-;; 1280c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1280d:	 800100               	add	byte ptr [rcx], 0
-;; 12810:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12819:	 800100               	add	byte ptr [rcx], 0
-;; 1281c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1281d:	 800100               	add	byte ptr [rcx], 0
-;; 12820:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12829:	 800100               	add	byte ptr [rcx], 0
-;; 1282c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1282d:	 800100               	add	byte ptr [rcx], 0
-;; 12830:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12839:	 800100               	add	byte ptr [rcx], 0
-;; 1283c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1283d:	 800100               	add	byte ptr [rcx], 0
-;; 12840:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12849:	 800100               	add	byte ptr [rcx], 0
-;; 1284c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1284d:	 800100               	add	byte ptr [rcx], 0
-;; 12850:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12859:	 800100               	add	byte ptr [rcx], 0
-;; 1285c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1285d:	 800100               	add	byte ptr [rcx], 0
-;; 12860:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12869:	 800100               	add	byte ptr [rcx], 0
-;; 1286c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1286d:	 800100               	add	byte ptr [rcx], 0
-;; 12870:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12879:	 800100               	add	byte ptr [rcx], 0
-;; 1287c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1287d:	 800100               	add	byte ptr [rcx], 0
-;; 12880:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12889:	 800100               	add	byte ptr [rcx], 0
-;; 1288c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1288d:	 800100               	add	byte ptr [rcx], 0
-;; 12890:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12899:	 800100               	add	byte ptr [rcx], 0
-;; 1289c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1289d:	 800100               	add	byte ptr [rcx], 0
-;; 128a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 128a9:	 800100               	add	byte ptr [rcx], 0
-;; 128ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 128ad:	 800100               	add	byte ptr [rcx], 0
-;; 128b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 128b9:	 800100               	add	byte ptr [rcx], 0
-;; 128bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 128bd:	 800100               	add	byte ptr [rcx], 0
-;; 128c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 128c9:	 800100               	add	byte ptr [rcx], 0
-;; 128cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 128cd:	 800100               	add	byte ptr [rcx], 0
-;; 128d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 128d9:	 800100               	add	byte ptr [rcx], 0
-;; 128dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 128dd:	 800100               	add	byte ptr [rcx], 0
-;; 128e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 128e9:	 800100               	add	byte ptr [rcx], 0
-;; 128ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 128ed:	 800100               	add	byte ptr [rcx], 0
-;; 128f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 128f9:	 800100               	add	byte ptr [rcx], 0
-;; 128fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 128fd:	 800100               	add	byte ptr [rcx], 0
-;; 12900:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12909:	 800100               	add	byte ptr [rcx], 0
-;; 1290c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1290d:	 800100               	add	byte ptr [rcx], 0
-;; 12910:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12919:	 800100               	add	byte ptr [rcx], 0
-;; 1291c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1291d:	 800100               	add	byte ptr [rcx], 0
-;; 12920:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12929:	 800100               	add	byte ptr [rcx], 0
-;; 1292c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1292d:	 800100               	add	byte ptr [rcx], 0
-;; 12930:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12939:	 800100               	add	byte ptr [rcx], 0
-;; 1293c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1293d:	 800100               	add	byte ptr [rcx], 0
-;; 12940:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12949:	 800100               	add	byte ptr [rcx], 0
-;; 1294c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1294d:	 800100               	add	byte ptr [rcx], 0
-;; 12950:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12959:	 800100               	add	byte ptr [rcx], 0
-;; 1295c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1295d:	 800100               	add	byte ptr [rcx], 0
-;; 12960:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12969:	 800100               	add	byte ptr [rcx], 0
-;; 1296c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1296d:	 800100               	add	byte ptr [rcx], 0
-;; 12970:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12979:	 800100               	add	byte ptr [rcx], 0
-;; 1297c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1297d:	 800100               	add	byte ptr [rcx], 0
-;; 12980:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12989:	 800100               	add	byte ptr [rcx], 0
-;; 1298c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1298d:	 800100               	add	byte ptr [rcx], 0
-;; 12990:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12999:	 800100               	add	byte ptr [rcx], 0
-;; 1299c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1299d:	 800100               	add	byte ptr [rcx], 0
-;; 129a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 129a9:	 800100               	add	byte ptr [rcx], 0
-;; 129ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 129ad:	 800100               	add	byte ptr [rcx], 0
-;; 129b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 129b9:	 800100               	add	byte ptr [rcx], 0
-;; 129bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 129bd:	 800100               	add	byte ptr [rcx], 0
-;; 129c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 129c9:	 800100               	add	byte ptr [rcx], 0
-;; 129cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 129cd:	 800100               	add	byte ptr [rcx], 0
-;; 129d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 129d9:	 800100               	add	byte ptr [rcx], 0
-;; 129dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 129dd:	 800100               	add	byte ptr [rcx], 0
-;; 129e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 129e9:	 800100               	add	byte ptr [rcx], 0
-;; 129ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 129ed:	 800100               	add	byte ptr [rcx], 0
-;; 129f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 129f9:	 800100               	add	byte ptr [rcx], 0
-;; 129fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 129fd:	 800100               	add	byte ptr [rcx], 0
-;; 12a00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12a09:	 800100               	add	byte ptr [rcx], 0
-;; 12a0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12a0d:	 800100               	add	byte ptr [rcx], 0
-;; 12a10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12a19:	 800100               	add	byte ptr [rcx], 0
-;; 12a1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12a1d:	 800100               	add	byte ptr [rcx], 0
-;; 12a20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12a29:	 800100               	add	byte ptr [rcx], 0
-;; 12a2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12a2d:	 800100               	add	byte ptr [rcx], 0
-;; 12a30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12a39:	 800100               	add	byte ptr [rcx], 0
-;; 12a3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12a3d:	 800100               	add	byte ptr [rcx], 0
-;; 12a40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12a49:	 800100               	add	byte ptr [rcx], 0
-;; 12a4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12a4d:	 800100               	add	byte ptr [rcx], 0
-;; 12a50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12a59:	 800100               	add	byte ptr [rcx], 0
-;; 12a5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12a5d:	 800100               	add	byte ptr [rcx], 0
-;; 12a60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12a69:	 800100               	add	byte ptr [rcx], 0
-;; 12a6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12a6d:	 800100               	add	byte ptr [rcx], 0
-;; 12a70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12a79:	 800100               	add	byte ptr [rcx], 0
-;; 12a7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12a7d:	 800100               	add	byte ptr [rcx], 0
-;; 12a80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12a89:	 800100               	add	byte ptr [rcx], 0
-;; 12a8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12a8d:	 800100               	add	byte ptr [rcx], 0
-;; 12a90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12a99:	 800100               	add	byte ptr [rcx], 0
-;; 12a9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12a9d:	 800100               	add	byte ptr [rcx], 0
-;; 12aa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12aa9:	 800100               	add	byte ptr [rcx], 0
-;; 12aac:	 aa                   	stosb	byte ptr [rdi], al
-;; 12aad:	 800100               	add	byte ptr [rcx], 0
-;; 12ab0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12ab9:	 800100               	add	byte ptr [rcx], 0
-;; 12abc:	 aa                   	stosb	byte ptr [rdi], al
-;; 12abd:	 800100               	add	byte ptr [rcx], 0
-;; 12ac0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12ac9:	 800100               	add	byte ptr [rcx], 0
-;; 12acc:	 aa                   	stosb	byte ptr [rdi], al
-;; 12acd:	 800100               	add	byte ptr [rcx], 0
-;; 12ad0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12ad9:	 800100               	add	byte ptr [rcx], 0
-;; 12adc:	 aa                   	stosb	byte ptr [rdi], al
-;; 12add:	 800100               	add	byte ptr [rcx], 0
-;; 12ae0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12ae9:	 800100               	add	byte ptr [rcx], 0
-;; 12aec:	 aa                   	stosb	byte ptr [rdi], al
-;; 12aed:	 800100               	add	byte ptr [rcx], 0
-;; 12af0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12af9:	 800100               	add	byte ptr [rcx], 0
-;; 12afc:	 aa                   	stosb	byte ptr [rdi], al
-;; 12afd:	 800100               	add	byte ptr [rcx], 0
-;; 12b00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12b09:	 800100               	add	byte ptr [rcx], 0
-;; 12b0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12b0d:	 800100               	add	byte ptr [rcx], 0
-;; 12b10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12b19:	 800100               	add	byte ptr [rcx], 0
-;; 12b1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12b1d:	 800100               	add	byte ptr [rcx], 0
-;; 12b20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12b29:	 800100               	add	byte ptr [rcx], 0
-;; 12b2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12b2d:	 800100               	add	byte ptr [rcx], 0
-;; 12b30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12b39:	 800100               	add	byte ptr [rcx], 0
-;; 12b3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12b3d:	 800100               	add	byte ptr [rcx], 0
-;; 12b40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12b49:	 800100               	add	byte ptr [rcx], 0
-;; 12b4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12b4d:	 800100               	add	byte ptr [rcx], 0
-;; 12b50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12b59:	 800100               	add	byte ptr [rcx], 0
-;; 12b5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12b5d:	 800100               	add	byte ptr [rcx], 0
-;; 12b60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12b69:	 800100               	add	byte ptr [rcx], 0
-;; 12b6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12b6d:	 800100               	add	byte ptr [rcx], 0
-;; 12b70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12b79:	 800100               	add	byte ptr [rcx], 0
-;; 12b7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12b7d:	 800100               	add	byte ptr [rcx], 0
-;; 12b80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12b89:	 800100               	add	byte ptr [rcx], 0
-;; 12b8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12b8d:	 800100               	add	byte ptr [rcx], 0
-;; 12b90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12b99:	 800100               	add	byte ptr [rcx], 0
-;; 12b9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12b9d:	 800100               	add	byte ptr [rcx], 0
-;; 12ba0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12ba9:	 800100               	add	byte ptr [rcx], 0
-;; 12bac:	 aa                   	stosb	byte ptr [rdi], al
-;; 12bad:	 800100               	add	byte ptr [rcx], 0
-;; 12bb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12bb9:	 800100               	add	byte ptr [rcx], 0
-;; 12bbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 12bbd:	 800100               	add	byte ptr [rcx], 0
-;; 12bc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12bc9:	 800100               	add	byte ptr [rcx], 0
-;; 12bcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 12bcd:	 800100               	add	byte ptr [rcx], 0
-;; 12bd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12bd9:	 800100               	add	byte ptr [rcx], 0
-;; 12bdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 12bdd:	 800100               	add	byte ptr [rcx], 0
-;; 12be0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12be9:	 800100               	add	byte ptr [rcx], 0
-;; 12bec:	 aa                   	stosb	byte ptr [rdi], al
-;; 12bed:	 800100               	add	byte ptr [rcx], 0
-;; 12bf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12bf9:	 800100               	add	byte ptr [rcx], 0
-;; 12bfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 12bfd:	 800100               	add	byte ptr [rcx], 0
-;; 12c00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12c09:	 800100               	add	byte ptr [rcx], 0
-;; 12c0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12c0d:	 800100               	add	byte ptr [rcx], 0
-;; 12c10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12c19:	 800100               	add	byte ptr [rcx], 0
-;; 12c1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12c1d:	 800100               	add	byte ptr [rcx], 0
-;; 12c20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12c29:	 800100               	add	byte ptr [rcx], 0
-;; 12c2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12c2d:	 800100               	add	byte ptr [rcx], 0
-;; 12c30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12c39:	 800100               	add	byte ptr [rcx], 0
-;; 12c3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12c3d:	 800100               	add	byte ptr [rcx], 0
-;; 12c40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12c49:	 800100               	add	byte ptr [rcx], 0
-;; 12c4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12c4d:	 800100               	add	byte ptr [rcx], 0
-;; 12c50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12c59:	 800100               	add	byte ptr [rcx], 0
-;; 12c5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12c5d:	 800100               	add	byte ptr [rcx], 0
-;; 12c60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12c69:	 800100               	add	byte ptr [rcx], 0
-;; 12c6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12c6d:	 800100               	add	byte ptr [rcx], 0
-;; 12c70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12c79:	 800100               	add	byte ptr [rcx], 0
-;; 12c7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12c7d:	 800100               	add	byte ptr [rcx], 0
-;; 12c80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12c89:	 800100               	add	byte ptr [rcx], 0
-;; 12c8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12c8d:	 800100               	add	byte ptr [rcx], 0
-;; 12c90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12c99:	 800100               	add	byte ptr [rcx], 0
-;; 12c9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12c9d:	 800100               	add	byte ptr [rcx], 0
-;; 12ca0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12ca9:	 800100               	add	byte ptr [rcx], 0
-;; 12cac:	 aa                   	stosb	byte ptr [rdi], al
-;; 12cad:	 800100               	add	byte ptr [rcx], 0
-;; 12cb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12cb9:	 800100               	add	byte ptr [rcx], 0
-;; 12cbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 12cbd:	 800100               	add	byte ptr [rcx], 0
-;; 12cc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12cc9:	 800100               	add	byte ptr [rcx], 0
-;; 12ccc:	 aa                   	stosb	byte ptr [rdi], al
-;; 12ccd:	 800100               	add	byte ptr [rcx], 0
-;; 12cd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12cd9:	 800100               	add	byte ptr [rcx], 0
-;; 12cdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 12cdd:	 800100               	add	byte ptr [rcx], 0
-;; 12ce0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12ce9:	 800100               	add	byte ptr [rcx], 0
-;; 12cec:	 aa                   	stosb	byte ptr [rdi], al
-;; 12ced:	 800100               	add	byte ptr [rcx], 0
-;; 12cf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12cf9:	 800100               	add	byte ptr [rcx], 0
-;; 12cfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 12cfd:	 800100               	add	byte ptr [rcx], 0
-;; 12d00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12d09:	 800100               	add	byte ptr [rcx], 0
-;; 12d0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12d0d:	 800100               	add	byte ptr [rcx], 0
-;; 12d10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12d19:	 800100               	add	byte ptr [rcx], 0
-;; 12d1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12d1d:	 800100               	add	byte ptr [rcx], 0
-;; 12d20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12d29:	 800100               	add	byte ptr [rcx], 0
-;; 12d2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12d2d:	 800100               	add	byte ptr [rcx], 0
-;; 12d30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12d39:	 800100               	add	byte ptr [rcx], 0
-;; 12d3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12d3d:	 800100               	add	byte ptr [rcx], 0
-;; 12d40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12d49:	 800100               	add	byte ptr [rcx], 0
-;; 12d4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12d4d:	 800100               	add	byte ptr [rcx], 0
-;; 12d50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12d59:	 800100               	add	byte ptr [rcx], 0
-;; 12d5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12d5d:	 800100               	add	byte ptr [rcx], 0
-;; 12d60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12d69:	 800100               	add	byte ptr [rcx], 0
-;; 12d6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12d6d:	 800100               	add	byte ptr [rcx], 0
-;; 12d70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12d79:	 800100               	add	byte ptr [rcx], 0
-;; 12d7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12d7d:	 800100               	add	byte ptr [rcx], 0
-;; 12d80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12d89:	 800100               	add	byte ptr [rcx], 0
-;; 12d8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12d8d:	 800100               	add	byte ptr [rcx], 0
-;; 12d90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12d99:	 800100               	add	byte ptr [rcx], 0
-;; 12d9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12d9d:	 800100               	add	byte ptr [rcx], 0
-;; 12da0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12da9:	 800100               	add	byte ptr [rcx], 0
-;; 12dac:	 aa                   	stosb	byte ptr [rdi], al
-;; 12dad:	 800100               	add	byte ptr [rcx], 0
-;; 12db0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12db9:	 800100               	add	byte ptr [rcx], 0
-;; 12dbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 12dbd:	 800100               	add	byte ptr [rcx], 0
-;; 12dc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12dc9:	 800100               	add	byte ptr [rcx], 0
-;; 12dcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 12dcd:	 800100               	add	byte ptr [rcx], 0
-;; 12dd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12dd9:	 800100               	add	byte ptr [rcx], 0
-;; 12ddc:	 aa                   	stosb	byte ptr [rdi], al
-;; 12ddd:	 800100               	add	byte ptr [rcx], 0
-;; 12de0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12de9:	 800100               	add	byte ptr [rcx], 0
-;; 12dec:	 aa                   	stosb	byte ptr [rdi], al
-;; 12ded:	 800100               	add	byte ptr [rcx], 0
-;; 12df0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12df9:	 800100               	add	byte ptr [rcx], 0
-;; 12dfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 12dfd:	 800100               	add	byte ptr [rcx], 0
-;; 12e00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12e09:	 800100               	add	byte ptr [rcx], 0
-;; 12e0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12e0d:	 800100               	add	byte ptr [rcx], 0
-;; 12e10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12e19:	 800100               	add	byte ptr [rcx], 0
-;; 12e1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12e1d:	 800100               	add	byte ptr [rcx], 0
-;; 12e20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12e29:	 800100               	add	byte ptr [rcx], 0
-;; 12e2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12e2d:	 800100               	add	byte ptr [rcx], 0
-;; 12e30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12e39:	 800100               	add	byte ptr [rcx], 0
-;; 12e3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12e3d:	 800100               	add	byte ptr [rcx], 0
-;; 12e40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12e49:	 800100               	add	byte ptr [rcx], 0
-;; 12e4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12e4d:	 800100               	add	byte ptr [rcx], 0
-;; 12e50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12e59:	 800100               	add	byte ptr [rcx], 0
-;; 12e5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12e5d:	 800100               	add	byte ptr [rcx], 0
-;; 12e60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12e69:	 800100               	add	byte ptr [rcx], 0
-;; 12e6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12e6d:	 800100               	add	byte ptr [rcx], 0
-;; 12e70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12e79:	 800100               	add	byte ptr [rcx], 0
-;; 12e7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12e7d:	 800100               	add	byte ptr [rcx], 0
-;; 12e80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12e89:	 800100               	add	byte ptr [rcx], 0
-;; 12e8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12e8d:	 800100               	add	byte ptr [rcx], 0
-;; 12e90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12e99:	 800100               	add	byte ptr [rcx], 0
-;; 12e9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12e9d:	 800100               	add	byte ptr [rcx], 0
-;; 12ea0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12ea9:	 800100               	add	byte ptr [rcx], 0
-;; 12eac:	 aa                   	stosb	byte ptr [rdi], al
-;; 12ead:	 800100               	add	byte ptr [rcx], 0
-;; 12eb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12eb9:	 800100               	add	byte ptr [rcx], 0
-;; 12ebc:	 aa                   	stosb	byte ptr [rdi], al
-;; 12ebd:	 800100               	add	byte ptr [rcx], 0
-;; 12ec0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12ec9:	 800100               	add	byte ptr [rcx], 0
-;; 12ecc:	 aa                   	stosb	byte ptr [rdi], al
-;; 12ecd:	 800100               	add	byte ptr [rcx], 0
-;; 12ed0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12ed9:	 800100               	add	byte ptr [rcx], 0
-;; 12edc:	 aa                   	stosb	byte ptr [rdi], al
-;; 12edd:	 800100               	add	byte ptr [rcx], 0
-;; 12ee0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12ee9:	 800100               	add	byte ptr [rcx], 0
-;; 12eec:	 aa                   	stosb	byte ptr [rdi], al
-;; 12eed:	 800100               	add	byte ptr [rcx], 0
-;; 12ef0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12ef9:	 800100               	add	byte ptr [rcx], 0
-;; 12efc:	 aa                   	stosb	byte ptr [rdi], al
-;; 12efd:	 800100               	add	byte ptr [rcx], 0
-;; 12f00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12f09:	 800100               	add	byte ptr [rcx], 0
-;; 12f0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12f0d:	 800100               	add	byte ptr [rcx], 0
-;; 12f10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12f19:	 800100               	add	byte ptr [rcx], 0
-;; 12f1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12f1d:	 800100               	add	byte ptr [rcx], 0
-;; 12f20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12f29:	 800100               	add	byte ptr [rcx], 0
-;; 12f2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12f2d:	 800100               	add	byte ptr [rcx], 0
-;; 12f30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12f39:	 800100               	add	byte ptr [rcx], 0
-;; 12f3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12f3d:	 800100               	add	byte ptr [rcx], 0
-;; 12f40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12f49:	 800100               	add	byte ptr [rcx], 0
-;; 12f4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12f4d:	 800100               	add	byte ptr [rcx], 0
-;; 12f50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12f59:	 800100               	add	byte ptr [rcx], 0
-;; 12f5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12f5d:	 800100               	add	byte ptr [rcx], 0
-;; 12f60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12f69:	 800100               	add	byte ptr [rcx], 0
-;; 12f6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12f6d:	 800100               	add	byte ptr [rcx], 0
-;; 12f70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12f79:	 800100               	add	byte ptr [rcx], 0
-;; 12f7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12f7d:	 800100               	add	byte ptr [rcx], 0
-;; 12f80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12f89:	 800100               	add	byte ptr [rcx], 0
-;; 12f8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12f8d:	 800100               	add	byte ptr [rcx], 0
-;; 12f90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12f99:	 800100               	add	byte ptr [rcx], 0
-;; 12f9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 12f9d:	 800100               	add	byte ptr [rcx], 0
-;; 12fa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12fa9:	 800100               	add	byte ptr [rcx], 0
-;; 12fac:	 aa                   	stosb	byte ptr [rdi], al
-;; 12fad:	 800100               	add	byte ptr [rcx], 0
-;; 12fb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12fb9:	 800100               	add	byte ptr [rcx], 0
-;; 12fbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 12fbd:	 800100               	add	byte ptr [rcx], 0
-;; 12fc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12fc9:	 800100               	add	byte ptr [rcx], 0
-;; 12fcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 12fcd:	 800100               	add	byte ptr [rcx], 0
-;; 12fd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12fd9:	 800100               	add	byte ptr [rcx], 0
-;; 12fdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 12fdd:	 800100               	add	byte ptr [rcx], 0
-;; 12fe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12fe9:	 800100               	add	byte ptr [rcx], 0
-;; 12fec:	 aa                   	stosb	byte ptr [rdi], al
-;; 12fed:	 800100               	add	byte ptr [rcx], 0
-;; 12ff0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 12ff9:	 800100               	add	byte ptr [rcx], 0
-;; 12ffc:	 aa                   	stosb	byte ptr [rdi], al
-;; 12ffd:	 800100               	add	byte ptr [rcx], 0
-;; 13000:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13009:	 800100               	add	byte ptr [rcx], 0
-;; 1300c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1300d:	 800100               	add	byte ptr [rcx], 0
-;; 13010:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13019:	 800100               	add	byte ptr [rcx], 0
-;; 1301c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1301d:	 800100               	add	byte ptr [rcx], 0
-;; 13020:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13029:	 800100               	add	byte ptr [rcx], 0
-;; 1302c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1302d:	 800100               	add	byte ptr [rcx], 0
-;; 13030:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13039:	 800100               	add	byte ptr [rcx], 0
-;; 1303c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1303d:	 800100               	add	byte ptr [rcx], 0
-;; 13040:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13049:	 800100               	add	byte ptr [rcx], 0
-;; 1304c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1304d:	 800100               	add	byte ptr [rcx], 0
-;; 13050:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13059:	 800100               	add	byte ptr [rcx], 0
-;; 1305c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1305d:	 800100               	add	byte ptr [rcx], 0
-;; 13060:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13069:	 800100               	add	byte ptr [rcx], 0
-;; 1306c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1306d:	 800100               	add	byte ptr [rcx], 0
-;; 13070:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13079:	 800100               	add	byte ptr [rcx], 0
-;; 1307c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1307d:	 800100               	add	byte ptr [rcx], 0
-;; 13080:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13089:	 800100               	add	byte ptr [rcx], 0
-;; 1308c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1308d:	 800100               	add	byte ptr [rcx], 0
-;; 13090:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13099:	 800100               	add	byte ptr [rcx], 0
-;; 1309c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1309d:	 800100               	add	byte ptr [rcx], 0
-;; 130a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 130a9:	 800100               	add	byte ptr [rcx], 0
-;; 130ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 130ad:	 800100               	add	byte ptr [rcx], 0
-;; 130b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 130b9:	 800100               	add	byte ptr [rcx], 0
-;; 130bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 130bd:	 800100               	add	byte ptr [rcx], 0
-;; 130c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 130c9:	 800100               	add	byte ptr [rcx], 0
-;; 130cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 130cd:	 800100               	add	byte ptr [rcx], 0
-;; 130d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 130d9:	 800100               	add	byte ptr [rcx], 0
-;; 130dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 130dd:	 800100               	add	byte ptr [rcx], 0
-;; 130e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 130e9:	 800100               	add	byte ptr [rcx], 0
-;; 130ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 130ed:	 800100               	add	byte ptr [rcx], 0
-;; 130f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 130f9:	 800100               	add	byte ptr [rcx], 0
-;; 130fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 130fd:	 800100               	add	byte ptr [rcx], 0
-;; 13100:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13109:	 800100               	add	byte ptr [rcx], 0
-;; 1310c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1310d:	 800100               	add	byte ptr [rcx], 0
-;; 13110:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13119:	 800100               	add	byte ptr [rcx], 0
-;; 1311c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1311d:	 800100               	add	byte ptr [rcx], 0
-;; 13120:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13129:	 800100               	add	byte ptr [rcx], 0
-;; 1312c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1312d:	 800100               	add	byte ptr [rcx], 0
-;; 13130:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13139:	 800100               	add	byte ptr [rcx], 0
-;; 1313c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1313d:	 800100               	add	byte ptr [rcx], 0
-;; 13140:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13149:	 800100               	add	byte ptr [rcx], 0
-;; 1314c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1314d:	 800100               	add	byte ptr [rcx], 0
-;; 13150:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13159:	 800100               	add	byte ptr [rcx], 0
-;; 1315c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1315d:	 800100               	add	byte ptr [rcx], 0
-;; 13160:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13169:	 800100               	add	byte ptr [rcx], 0
-;; 1316c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1316d:	 800100               	add	byte ptr [rcx], 0
-;; 13170:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13179:	 800100               	add	byte ptr [rcx], 0
-;; 1317c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1317d:	 800100               	add	byte ptr [rcx], 0
-;; 13180:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13189:	 800100               	add	byte ptr [rcx], 0
-;; 1318c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1318d:	 800100               	add	byte ptr [rcx], 0
-;; 13190:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13199:	 800100               	add	byte ptr [rcx], 0
-;; 1319c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1319d:	 800100               	add	byte ptr [rcx], 0
-;; 131a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 131a9:	 800100               	add	byte ptr [rcx], 0
-;; 131ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 131ad:	 800100               	add	byte ptr [rcx], 0
-;; 131b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 131b9:	 800100               	add	byte ptr [rcx], 0
-;; 131bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 131bd:	 800100               	add	byte ptr [rcx], 0
-;; 131c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 131c9:	 800100               	add	byte ptr [rcx], 0
-;; 131cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 131cd:	 800100               	add	byte ptr [rcx], 0
-;; 131d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 131d9:	 800100               	add	byte ptr [rcx], 0
-;; 131dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 131dd:	 800100               	add	byte ptr [rcx], 0
-;; 131e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 131e9:	 800100               	add	byte ptr [rcx], 0
-;; 131ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 131ed:	 800100               	add	byte ptr [rcx], 0
-;; 131f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 131f9:	 800100               	add	byte ptr [rcx], 0
-;; 131fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 131fd:	 800100               	add	byte ptr [rcx], 0
-;; 13200:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13209:	 800100               	add	byte ptr [rcx], 0
-;; 1320c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1320d:	 800100               	add	byte ptr [rcx], 0
-;; 13210:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13219:	 800100               	add	byte ptr [rcx], 0
-;; 1321c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1321d:	 800100               	add	byte ptr [rcx], 0
-;; 13220:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13229:	 800100               	add	byte ptr [rcx], 0
-;; 1322c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1322d:	 800100               	add	byte ptr [rcx], 0
-;; 13230:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13239:	 800100               	add	byte ptr [rcx], 0
-;; 1323c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1323d:	 800100               	add	byte ptr [rcx], 0
-;; 13240:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13249:	 800100               	add	byte ptr [rcx], 0
-;; 1324c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1324d:	 800100               	add	byte ptr [rcx], 0
-;; 13250:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13259:	 800100               	add	byte ptr [rcx], 0
-;; 1325c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1325d:	 800100               	add	byte ptr [rcx], 0
-;; 13260:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13269:	 800100               	add	byte ptr [rcx], 0
-;; 1326c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1326d:	 800100               	add	byte ptr [rcx], 0
-;; 13270:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13279:	 800100               	add	byte ptr [rcx], 0
-;; 1327c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1327d:	 800100               	add	byte ptr [rcx], 0
-;; 13280:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13289:	 800100               	add	byte ptr [rcx], 0
-;; 1328c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1328d:	 800100               	add	byte ptr [rcx], 0
-;; 13290:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13299:	 800100               	add	byte ptr [rcx], 0
-;; 1329c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1329d:	 800100               	add	byte ptr [rcx], 0
-;; 132a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 132a9:	 800100               	add	byte ptr [rcx], 0
-;; 132ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 132ad:	 800100               	add	byte ptr [rcx], 0
-;; 132b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 132b9:	 800100               	add	byte ptr [rcx], 0
-;; 132bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 132bd:	 800100               	add	byte ptr [rcx], 0
-;; 132c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 132c9:	 800100               	add	byte ptr [rcx], 0
-;; 132cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 132cd:	 800100               	add	byte ptr [rcx], 0
-;; 132d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 132d9:	 800100               	add	byte ptr [rcx], 0
-;; 132dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 132dd:	 800100               	add	byte ptr [rcx], 0
-;; 132e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 132e9:	 800100               	add	byte ptr [rcx], 0
-;; 132ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 132ed:	 800100               	add	byte ptr [rcx], 0
-;; 132f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 132f9:	 800100               	add	byte ptr [rcx], 0
-;; 132fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 132fd:	 800100               	add	byte ptr [rcx], 0
-;; 13300:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13309:	 800100               	add	byte ptr [rcx], 0
-;; 1330c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1330d:	 800100               	add	byte ptr [rcx], 0
-;; 13310:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13319:	 800100               	add	byte ptr [rcx], 0
-;; 1331c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1331d:	 800100               	add	byte ptr [rcx], 0
-;; 13320:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13329:	 800100               	add	byte ptr [rcx], 0
-;; 1332c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1332d:	 800100               	add	byte ptr [rcx], 0
-;; 13330:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13339:	 800100               	add	byte ptr [rcx], 0
-;; 1333c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1333d:	 800100               	add	byte ptr [rcx], 0
-;; 13340:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13349:	 800100               	add	byte ptr [rcx], 0
-;; 1334c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1334d:	 800100               	add	byte ptr [rcx], 0
-;; 13350:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13359:	 800100               	add	byte ptr [rcx], 0
-;; 1335c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1335d:	 800100               	add	byte ptr [rcx], 0
-;; 13360:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13369:	 800100               	add	byte ptr [rcx], 0
-;; 1336c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1336d:	 800100               	add	byte ptr [rcx], 0
-;; 13370:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13379:	 800100               	add	byte ptr [rcx], 0
-;; 1337c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1337d:	 800100               	add	byte ptr [rcx], 0
-;; 13380:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13389:	 800100               	add	byte ptr [rcx], 0
-;; 1338c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1338d:	 800100               	add	byte ptr [rcx], 0
-;; 13390:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13399:	 800100               	add	byte ptr [rcx], 0
-;; 1339c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1339d:	 800100               	add	byte ptr [rcx], 0
-;; 133a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 133a9:	 800100               	add	byte ptr [rcx], 0
-;; 133ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 133ad:	 800100               	add	byte ptr [rcx], 0
-;; 133b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 133b9:	 800100               	add	byte ptr [rcx], 0
-;; 133bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 133bd:	 800100               	add	byte ptr [rcx], 0
-;; 133c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 133c9:	 800100               	add	byte ptr [rcx], 0
-;; 133cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 133cd:	 800100               	add	byte ptr [rcx], 0
-;; 133d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 133d9:	 800100               	add	byte ptr [rcx], 0
-;; 133dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 133dd:	 800100               	add	byte ptr [rcx], 0
-;; 133e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 133e9:	 800100               	add	byte ptr [rcx], 0
-;; 133ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 133ed:	 800100               	add	byte ptr [rcx], 0
-;; 133f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 133f9:	 800100               	add	byte ptr [rcx], 0
-;; 133fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 133fd:	 800100               	add	byte ptr [rcx], 0
-;; 13400:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13409:	 800100               	add	byte ptr [rcx], 0
-;; 1340c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1340d:	 800100               	add	byte ptr [rcx], 0
-;; 13410:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13419:	 800100               	add	byte ptr [rcx], 0
-;; 1341c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1341d:	 800100               	add	byte ptr [rcx], 0
-;; 13420:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13429:	 800100               	add	byte ptr [rcx], 0
-;; 1342c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1342d:	 800100               	add	byte ptr [rcx], 0
-;; 13430:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13439:	 800100               	add	byte ptr [rcx], 0
-;; 1343c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1343d:	 800100               	add	byte ptr [rcx], 0
-;; 13440:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13449:	 800100               	add	byte ptr [rcx], 0
-;; 1344c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1344d:	 800100               	add	byte ptr [rcx], 0
-;; 13450:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13459:	 800100               	add	byte ptr [rcx], 0
-;; 1345c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1345d:	 800100               	add	byte ptr [rcx], 0
-;; 13460:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13469:	 800100               	add	byte ptr [rcx], 0
-;; 1346c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1346d:	 800100               	add	byte ptr [rcx], 0
-;; 13470:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13479:	 800100               	add	byte ptr [rcx], 0
-;; 1347c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1347d:	 800100               	add	byte ptr [rcx], 0
-;; 13480:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13489:	 800100               	add	byte ptr [rcx], 0
-;; 1348c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1348d:	 800100               	add	byte ptr [rcx], 0
-;; 13490:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13499:	 800100               	add	byte ptr [rcx], 0
-;; 1349c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1349d:	 800100               	add	byte ptr [rcx], 0
-;; 134a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 134a9:	 800100               	add	byte ptr [rcx], 0
-;; 134ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 134ad:	 800100               	add	byte ptr [rcx], 0
-;; 134b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 134b9:	 800100               	add	byte ptr [rcx], 0
-;; 134bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 134bd:	 800100               	add	byte ptr [rcx], 0
-;; 134c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 134c9:	 800100               	add	byte ptr [rcx], 0
-;; 134cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 134cd:	 800100               	add	byte ptr [rcx], 0
-;; 134d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 134d9:	 800100               	add	byte ptr [rcx], 0
-;; 134dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 134dd:	 800100               	add	byte ptr [rcx], 0
-;; 134e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 134e9:	 800100               	add	byte ptr [rcx], 0
-;; 134ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 134ed:	 800100               	add	byte ptr [rcx], 0
-;; 134f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 134f9:	 800100               	add	byte ptr [rcx], 0
-;; 134fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 134fd:	 800100               	add	byte ptr [rcx], 0
-;; 13500:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13509:	 800100               	add	byte ptr [rcx], 0
-;; 1350c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1350d:	 800100               	add	byte ptr [rcx], 0
-;; 13510:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13519:	 800100               	add	byte ptr [rcx], 0
-;; 1351c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1351d:	 800100               	add	byte ptr [rcx], 0
-;; 13520:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13529:	 800100               	add	byte ptr [rcx], 0
-;; 1352c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1352d:	 800100               	add	byte ptr [rcx], 0
-;; 13530:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13539:	 800100               	add	byte ptr [rcx], 0
-;; 1353c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1353d:	 800100               	add	byte ptr [rcx], 0
-;; 13540:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13549:	 800100               	add	byte ptr [rcx], 0
-;; 1354c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1354d:	 800100               	add	byte ptr [rcx], 0
-;; 13550:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13559:	 800100               	add	byte ptr [rcx], 0
-;; 1355c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1355d:	 800100               	add	byte ptr [rcx], 0
-;; 13560:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13569:	 800100               	add	byte ptr [rcx], 0
-;; 1356c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1356d:	 800100               	add	byte ptr [rcx], 0
-;; 13570:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13579:	 800100               	add	byte ptr [rcx], 0
-;; 1357c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1357d:	 800100               	add	byte ptr [rcx], 0
-;; 13580:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13589:	 800100               	add	byte ptr [rcx], 0
-;; 1358c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1358d:	 800100               	add	byte ptr [rcx], 0
-;; 13590:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13599:	 800100               	add	byte ptr [rcx], 0
-;; 1359c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1359d:	 800100               	add	byte ptr [rcx], 0
-;; 135a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 135a9:	 800100               	add	byte ptr [rcx], 0
-;; 135ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 135ad:	 800100               	add	byte ptr [rcx], 0
-;; 135b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 135b9:	 800100               	add	byte ptr [rcx], 0
-;; 135bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 135bd:	 800100               	add	byte ptr [rcx], 0
-;; 135c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 135c9:	 800100               	add	byte ptr [rcx], 0
-;; 135cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 135cd:	 800100               	add	byte ptr [rcx], 0
-;; 135d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 135d9:	 800100               	add	byte ptr [rcx], 0
-;; 135dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 135dd:	 800100               	add	byte ptr [rcx], 0
-;; 135e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 135e9:	 800100               	add	byte ptr [rcx], 0
-;; 135ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 135ed:	 800100               	add	byte ptr [rcx], 0
-;; 135f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 135f9:	 800100               	add	byte ptr [rcx], 0
-;; 135fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 135fd:	 800100               	add	byte ptr [rcx], 0
-;; 13600:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13609:	 800100               	add	byte ptr [rcx], 0
-;; 1360c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1360d:	 800100               	add	byte ptr [rcx], 0
-;; 13610:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13619:	 800100               	add	byte ptr [rcx], 0
-;; 1361c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1361d:	 800100               	add	byte ptr [rcx], 0
-;; 13620:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13629:	 800100               	add	byte ptr [rcx], 0
-;; 1362c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1362d:	 800100               	add	byte ptr [rcx], 0
-;; 13630:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13639:	 800100               	add	byte ptr [rcx], 0
-;; 1363c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1363d:	 800100               	add	byte ptr [rcx], 0
-;; 13640:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13649:	 800100               	add	byte ptr [rcx], 0
-;; 1364c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1364d:	 800100               	add	byte ptr [rcx], 0
-;; 13650:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13659:	 800100               	add	byte ptr [rcx], 0
-;; 1365c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1365d:	 800100               	add	byte ptr [rcx], 0
-;; 13660:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13669:	 800100               	add	byte ptr [rcx], 0
-;; 1366c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1366d:	 800100               	add	byte ptr [rcx], 0
-;; 13670:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13679:	 800100               	add	byte ptr [rcx], 0
-;; 1367c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1367d:	 800100               	add	byte ptr [rcx], 0
-;; 13680:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13689:	 800100               	add	byte ptr [rcx], 0
-;; 1368c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1368d:	 800100               	add	byte ptr [rcx], 0
-;; 13690:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13699:	 800100               	add	byte ptr [rcx], 0
-;; 1369c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1369d:	 800100               	add	byte ptr [rcx], 0
-;; 136a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 136a9:	 800100               	add	byte ptr [rcx], 0
-;; 136ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 136ad:	 800100               	add	byte ptr [rcx], 0
-;; 136b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 136b9:	 800100               	add	byte ptr [rcx], 0
-;; 136bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 136bd:	 800100               	add	byte ptr [rcx], 0
-;; 136c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 136c9:	 800100               	add	byte ptr [rcx], 0
-;; 136cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 136cd:	 800100               	add	byte ptr [rcx], 0
-;; 136d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 136d9:	 800100               	add	byte ptr [rcx], 0
-;; 136dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 136dd:	 800100               	add	byte ptr [rcx], 0
-;; 136e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 136e9:	 800100               	add	byte ptr [rcx], 0
-;; 136ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 136ed:	 800100               	add	byte ptr [rcx], 0
-;; 136f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 136f9:	 800100               	add	byte ptr [rcx], 0
-;; 136fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 136fd:	 800100               	add	byte ptr [rcx], 0
-;; 13700:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13709:	 800100               	add	byte ptr [rcx], 0
-;; 1370c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1370d:	 800100               	add	byte ptr [rcx], 0
-;; 13710:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13719:	 800100               	add	byte ptr [rcx], 0
-;; 1371c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1371d:	 800100               	add	byte ptr [rcx], 0
-;; 13720:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13729:	 800100               	add	byte ptr [rcx], 0
-;; 1372c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1372d:	 800100               	add	byte ptr [rcx], 0
-;; 13730:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13739:	 800100               	add	byte ptr [rcx], 0
-;; 1373c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1373d:	 800100               	add	byte ptr [rcx], 0
-;; 13740:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13749:	 800100               	add	byte ptr [rcx], 0
-;; 1374c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1374d:	 800100               	add	byte ptr [rcx], 0
-;; 13750:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13759:	 800100               	add	byte ptr [rcx], 0
-;; 1375c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1375d:	 800100               	add	byte ptr [rcx], 0
-;; 13760:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13769:	 800100               	add	byte ptr [rcx], 0
-;; 1376c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1376d:	 800100               	add	byte ptr [rcx], 0
-;; 13770:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13779:	 800100               	add	byte ptr [rcx], 0
-;; 1377c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1377d:	 800100               	add	byte ptr [rcx], 0
-;; 13780:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13789:	 800100               	add	byte ptr [rcx], 0
-;; 1378c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1378d:	 800100               	add	byte ptr [rcx], 0
-;; 13790:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13799:	 800100               	add	byte ptr [rcx], 0
-;; 1379c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1379d:	 800100               	add	byte ptr [rcx], 0
-;; 137a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 137a9:	 800100               	add	byte ptr [rcx], 0
-;; 137ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 137ad:	 800100               	add	byte ptr [rcx], 0
-;; 137b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 137b9:	 800100               	add	byte ptr [rcx], 0
-;; 137bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 137bd:	 800100               	add	byte ptr [rcx], 0
-;; 137c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 137c9:	 800100               	add	byte ptr [rcx], 0
-;; 137cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 137cd:	 800100               	add	byte ptr [rcx], 0
-;; 137d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 137d9:	 800100               	add	byte ptr [rcx], 0
-;; 137dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 137dd:	 800100               	add	byte ptr [rcx], 0
-;; 137e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 137e9:	 800100               	add	byte ptr [rcx], 0
-;; 137ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 137ed:	 800100               	add	byte ptr [rcx], 0
-;; 137f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 137f9:	 800100               	add	byte ptr [rcx], 0
-;; 137fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 137fd:	 800100               	add	byte ptr [rcx], 0
-;; 13800:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13809:	 800100               	add	byte ptr [rcx], 0
-;; 1380c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1380d:	 800100               	add	byte ptr [rcx], 0
-;; 13810:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13819:	 800100               	add	byte ptr [rcx], 0
-;; 1381c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1381d:	 800100               	add	byte ptr [rcx], 0
-;; 13820:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13829:	 800100               	add	byte ptr [rcx], 0
-;; 1382c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1382d:	 800100               	add	byte ptr [rcx], 0
-;; 13830:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13839:	 800100               	add	byte ptr [rcx], 0
-;; 1383c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1383d:	 800100               	add	byte ptr [rcx], 0
-;; 13840:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13849:	 800100               	add	byte ptr [rcx], 0
-;; 1384c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1384d:	 800100               	add	byte ptr [rcx], 0
-;; 13850:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13859:	 800100               	add	byte ptr [rcx], 0
-;; 1385c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1385d:	 800100               	add	byte ptr [rcx], 0
-;; 13860:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13869:	 800100               	add	byte ptr [rcx], 0
-;; 1386c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1386d:	 800100               	add	byte ptr [rcx], 0
-;; 13870:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13879:	 800100               	add	byte ptr [rcx], 0
-;; 1387c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1387d:	 800100               	add	byte ptr [rcx], 0
-;; 13880:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13889:	 800100               	add	byte ptr [rcx], 0
-;; 1388c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1388d:	 800100               	add	byte ptr [rcx], 0
-;; 13890:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13899:	 800100               	add	byte ptr [rcx], 0
-;; 1389c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1389d:	 800100               	add	byte ptr [rcx], 0
-;; 138a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 138a9:	 800100               	add	byte ptr [rcx], 0
-;; 138ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 138ad:	 800100               	add	byte ptr [rcx], 0
-;; 138b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 138b9:	 800100               	add	byte ptr [rcx], 0
-;; 138bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 138bd:	 800100               	add	byte ptr [rcx], 0
-;; 138c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 138c9:	 800100               	add	byte ptr [rcx], 0
-;; 138cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 138cd:	 800100               	add	byte ptr [rcx], 0
-;; 138d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 138d9:	 800100               	add	byte ptr [rcx], 0
-;; 138dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 138dd:	 800100               	add	byte ptr [rcx], 0
-;; 138e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 138e9:	 800100               	add	byte ptr [rcx], 0
-;; 138ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 138ed:	 800100               	add	byte ptr [rcx], 0
-;; 138f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 138f9:	 800100               	add	byte ptr [rcx], 0
-;; 138fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 138fd:	 800100               	add	byte ptr [rcx], 0
-;; 13900:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13909:	 800100               	add	byte ptr [rcx], 0
-;; 1390c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1390d:	 800100               	add	byte ptr [rcx], 0
-;; 13910:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13919:	 800100               	add	byte ptr [rcx], 0
-;; 1391c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1391d:	 800100               	add	byte ptr [rcx], 0
-;; 13920:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13929:	 800100               	add	byte ptr [rcx], 0
-;; 1392c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1392d:	 800100               	add	byte ptr [rcx], 0
-;; 13930:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13939:	 800100               	add	byte ptr [rcx], 0
-;; 1393c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1393d:	 800100               	add	byte ptr [rcx], 0
-;; 13940:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13949:	 800100               	add	byte ptr [rcx], 0
-;; 1394c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1394d:	 800100               	add	byte ptr [rcx], 0
-;; 13950:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13959:	 800100               	add	byte ptr [rcx], 0
-;; 1395c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1395d:	 800100               	add	byte ptr [rcx], 0
-;; 13960:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13969:	 800100               	add	byte ptr [rcx], 0
-;; 1396c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1396d:	 800100               	add	byte ptr [rcx], 0
-;; 13970:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13979:	 800100               	add	byte ptr [rcx], 0
-;; 1397c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1397d:	 800100               	add	byte ptr [rcx], 0
-;; 13980:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13989:	 800100               	add	byte ptr [rcx], 0
-;; 1398c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1398d:	 800100               	add	byte ptr [rcx], 0
-;; 13990:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13999:	 800100               	add	byte ptr [rcx], 0
-;; 1399c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1399d:	 800100               	add	byte ptr [rcx], 0
-;; 139a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 139a9:	 800100               	add	byte ptr [rcx], 0
-;; 139ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 139ad:	 800100               	add	byte ptr [rcx], 0
-;; 139b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 139b9:	 800100               	add	byte ptr [rcx], 0
-;; 139bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 139bd:	 800100               	add	byte ptr [rcx], 0
-;; 139c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 139c9:	 800100               	add	byte ptr [rcx], 0
-;; 139cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 139cd:	 800100               	add	byte ptr [rcx], 0
-;; 139d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 139d9:	 800100               	add	byte ptr [rcx], 0
-;; 139dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 139dd:	 800100               	add	byte ptr [rcx], 0
-;; 139e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 139e9:	 800100               	add	byte ptr [rcx], 0
-;; 139ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 139ed:	 800100               	add	byte ptr [rcx], 0
-;; 139f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 139f9:	 800100               	add	byte ptr [rcx], 0
-;; 139fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 139fd:	 800100               	add	byte ptr [rcx], 0
-;; 13a00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13a09:	 800100               	add	byte ptr [rcx], 0
-;; 13a0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13a0d:	 800100               	add	byte ptr [rcx], 0
-;; 13a10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13a19:	 800100               	add	byte ptr [rcx], 0
-;; 13a1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13a1d:	 800100               	add	byte ptr [rcx], 0
-;; 13a20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13a29:	 800100               	add	byte ptr [rcx], 0
-;; 13a2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13a2d:	 800100               	add	byte ptr [rcx], 0
-;; 13a30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13a39:	 800100               	add	byte ptr [rcx], 0
-;; 13a3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13a3d:	 800100               	add	byte ptr [rcx], 0
-;; 13a40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13a49:	 800100               	add	byte ptr [rcx], 0
-;; 13a4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13a4d:	 800100               	add	byte ptr [rcx], 0
-;; 13a50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13a59:	 800100               	add	byte ptr [rcx], 0
-;; 13a5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13a5d:	 800100               	add	byte ptr [rcx], 0
-;; 13a60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13a69:	 800100               	add	byte ptr [rcx], 0
-;; 13a6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13a6d:	 800100               	add	byte ptr [rcx], 0
-;; 13a70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13a79:	 800100               	add	byte ptr [rcx], 0
-;; 13a7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13a7d:	 800100               	add	byte ptr [rcx], 0
-;; 13a80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13a89:	 800100               	add	byte ptr [rcx], 0
-;; 13a8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13a8d:	 800100               	add	byte ptr [rcx], 0
-;; 13a90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13a99:	 800100               	add	byte ptr [rcx], 0
-;; 13a9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13a9d:	 800100               	add	byte ptr [rcx], 0
-;; 13aa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13aa9:	 800100               	add	byte ptr [rcx], 0
-;; 13aac:	 aa                   	stosb	byte ptr [rdi], al
-;; 13aad:	 800100               	add	byte ptr [rcx], 0
-;; 13ab0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13ab9:	 800100               	add	byte ptr [rcx], 0
-;; 13abc:	 aa                   	stosb	byte ptr [rdi], al
-;; 13abd:	 800100               	add	byte ptr [rcx], 0
-;; 13ac0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13ac9:	 800100               	add	byte ptr [rcx], 0
-;; 13acc:	 aa                   	stosb	byte ptr [rdi], al
-;; 13acd:	 800100               	add	byte ptr [rcx], 0
-;; 13ad0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13ad9:	 800100               	add	byte ptr [rcx], 0
-;; 13adc:	 aa                   	stosb	byte ptr [rdi], al
-;; 13add:	 800100               	add	byte ptr [rcx], 0
-;; 13ae0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13ae9:	 800100               	add	byte ptr [rcx], 0
-;; 13aec:	 aa                   	stosb	byte ptr [rdi], al
-;; 13aed:	 800100               	add	byte ptr [rcx], 0
-;; 13af0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13af9:	 800100               	add	byte ptr [rcx], 0
-;; 13afc:	 aa                   	stosb	byte ptr [rdi], al
-;; 13afd:	 800100               	add	byte ptr [rcx], 0
-;; 13b00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13b09:	 800100               	add	byte ptr [rcx], 0
-;; 13b0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13b0d:	 800100               	add	byte ptr [rcx], 0
-;; 13b10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13b19:	 800100               	add	byte ptr [rcx], 0
-;; 13b1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13b1d:	 800100               	add	byte ptr [rcx], 0
-;; 13b20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13b29:	 800100               	add	byte ptr [rcx], 0
-;; 13b2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13b2d:	 800100               	add	byte ptr [rcx], 0
-;; 13b30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13b39:	 800100               	add	byte ptr [rcx], 0
-;; 13b3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13b3d:	 800100               	add	byte ptr [rcx], 0
-;; 13b40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13b49:	 800100               	add	byte ptr [rcx], 0
-;; 13b4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13b4d:	 800100               	add	byte ptr [rcx], 0
-;; 13b50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13b59:	 800100               	add	byte ptr [rcx], 0
-;; 13b5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13b5d:	 800100               	add	byte ptr [rcx], 0
-;; 13b60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13b69:	 800100               	add	byte ptr [rcx], 0
-;; 13b6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13b6d:	 800100               	add	byte ptr [rcx], 0
-;; 13b70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13b79:	 800100               	add	byte ptr [rcx], 0
-;; 13b7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13b7d:	 800100               	add	byte ptr [rcx], 0
-;; 13b80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13b89:	 800100               	add	byte ptr [rcx], 0
-;; 13b8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13b8d:	 800100               	add	byte ptr [rcx], 0
-;; 13b90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13b99:	 800100               	add	byte ptr [rcx], 0
-;; 13b9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13b9d:	 800100               	add	byte ptr [rcx], 0
-;; 13ba0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13ba9:	 800100               	add	byte ptr [rcx], 0
-;; 13bac:	 aa                   	stosb	byte ptr [rdi], al
-;; 13bad:	 800100               	add	byte ptr [rcx], 0
-;; 13bb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13bb9:	 800100               	add	byte ptr [rcx], 0
-;; 13bbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 13bbd:	 800100               	add	byte ptr [rcx], 0
-;; 13bc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13bc9:	 800100               	add	byte ptr [rcx], 0
-;; 13bcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 13bcd:	 800100               	add	byte ptr [rcx], 0
-;; 13bd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13bd9:	 800100               	add	byte ptr [rcx], 0
-;; 13bdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 13bdd:	 800100               	add	byte ptr [rcx], 0
-;; 13be0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13be9:	 800100               	add	byte ptr [rcx], 0
-;; 13bec:	 aa                   	stosb	byte ptr [rdi], al
-;; 13bed:	 800100               	add	byte ptr [rcx], 0
-;; 13bf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13bf9:	 800100               	add	byte ptr [rcx], 0
-;; 13bfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 13bfd:	 800100               	add	byte ptr [rcx], 0
-;; 13c00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13c09:	 800100               	add	byte ptr [rcx], 0
-;; 13c0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13c0d:	 800100               	add	byte ptr [rcx], 0
-;; 13c10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13c19:	 800100               	add	byte ptr [rcx], 0
-;; 13c1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13c1d:	 800100               	add	byte ptr [rcx], 0
-;; 13c20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13c29:	 800100               	add	byte ptr [rcx], 0
-;; 13c2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13c2d:	 800100               	add	byte ptr [rcx], 0
-;; 13c30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13c39:	 800100               	add	byte ptr [rcx], 0
-;; 13c3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13c3d:	 800100               	add	byte ptr [rcx], 0
-;; 13c40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13c49:	 800100               	add	byte ptr [rcx], 0
-;; 13c4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13c4d:	 800100               	add	byte ptr [rcx], 0
-;; 13c50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13c59:	 800100               	add	byte ptr [rcx], 0
-;; 13c5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13c5d:	 800100               	add	byte ptr [rcx], 0
-;; 13c60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13c69:	 800100               	add	byte ptr [rcx], 0
-;; 13c6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13c6d:	 800100               	add	byte ptr [rcx], 0
-;; 13c70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13c79:	 800100               	add	byte ptr [rcx], 0
-;; 13c7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13c7d:	 800100               	add	byte ptr [rcx], 0
-;; 13c80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13c89:	 800100               	add	byte ptr [rcx], 0
-;; 13c8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13c8d:	 800100               	add	byte ptr [rcx], 0
-;; 13c90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13c99:	 800100               	add	byte ptr [rcx], 0
-;; 13c9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13c9d:	 800100               	add	byte ptr [rcx], 0
-;; 13ca0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13ca9:	 800100               	add	byte ptr [rcx], 0
-;; 13cac:	 aa                   	stosb	byte ptr [rdi], al
-;; 13cad:	 800100               	add	byte ptr [rcx], 0
-;; 13cb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13cb9:	 800100               	add	byte ptr [rcx], 0
-;; 13cbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 13cbd:	 800100               	add	byte ptr [rcx], 0
-;; 13cc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13cc9:	 800100               	add	byte ptr [rcx], 0
-;; 13ccc:	 aa                   	stosb	byte ptr [rdi], al
-;; 13ccd:	 800100               	add	byte ptr [rcx], 0
-;; 13cd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13cd9:	 800100               	add	byte ptr [rcx], 0
-;; 13cdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 13cdd:	 800100               	add	byte ptr [rcx], 0
-;; 13ce0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13ce9:	 800100               	add	byte ptr [rcx], 0
-;; 13cec:	 aa                   	stosb	byte ptr [rdi], al
-;; 13ced:	 800100               	add	byte ptr [rcx], 0
-;; 13cf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13cf9:	 800100               	add	byte ptr [rcx], 0
-;; 13cfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 13cfd:	 800100               	add	byte ptr [rcx], 0
-;; 13d00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13d09:	 800100               	add	byte ptr [rcx], 0
-;; 13d0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13d0d:	 800100               	add	byte ptr [rcx], 0
-;; 13d10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13d19:	 800100               	add	byte ptr [rcx], 0
-;; 13d1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13d1d:	 800100               	add	byte ptr [rcx], 0
-;; 13d20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13d29:	 800100               	add	byte ptr [rcx], 0
-;; 13d2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13d2d:	 800100               	add	byte ptr [rcx], 0
-;; 13d30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13d39:	 800100               	add	byte ptr [rcx], 0
-;; 13d3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13d3d:	 800100               	add	byte ptr [rcx], 0
-;; 13d40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13d49:	 800100               	add	byte ptr [rcx], 0
-;; 13d4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13d4d:	 800100               	add	byte ptr [rcx], 0
-;; 13d50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13d59:	 800100               	add	byte ptr [rcx], 0
-;; 13d5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13d5d:	 800100               	add	byte ptr [rcx], 0
-;; 13d60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13d69:	 800100               	add	byte ptr [rcx], 0
-;; 13d6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13d6d:	 800100               	add	byte ptr [rcx], 0
-;; 13d70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13d79:	 800100               	add	byte ptr [rcx], 0
-;; 13d7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13d7d:	 800100               	add	byte ptr [rcx], 0
-;; 13d80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13d89:	 800100               	add	byte ptr [rcx], 0
-;; 13d8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13d8d:	 800100               	add	byte ptr [rcx], 0
-;; 13d90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13d99:	 800100               	add	byte ptr [rcx], 0
-;; 13d9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13d9d:	 800100               	add	byte ptr [rcx], 0
-;; 13da0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13da9:	 800100               	add	byte ptr [rcx], 0
-;; 13dac:	 aa                   	stosb	byte ptr [rdi], al
-;; 13dad:	 800100               	add	byte ptr [rcx], 0
-;; 13db0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13db9:	 800100               	add	byte ptr [rcx], 0
-;; 13dbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 13dbd:	 800100               	add	byte ptr [rcx], 0
-;; 13dc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13dc9:	 800100               	add	byte ptr [rcx], 0
-;; 13dcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 13dcd:	 800100               	add	byte ptr [rcx], 0
-;; 13dd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13dd9:	 800100               	add	byte ptr [rcx], 0
-;; 13ddc:	 aa                   	stosb	byte ptr [rdi], al
-;; 13ddd:	 800100               	add	byte ptr [rcx], 0
-;; 13de0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13de9:	 800100               	add	byte ptr [rcx], 0
-;; 13dec:	 aa                   	stosb	byte ptr [rdi], al
-;; 13ded:	 800100               	add	byte ptr [rcx], 0
-;; 13df0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13df9:	 800100               	add	byte ptr [rcx], 0
-;; 13dfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 13dfd:	 800100               	add	byte ptr [rcx], 0
-;; 13e00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13e09:	 800100               	add	byte ptr [rcx], 0
-;; 13e0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13e0d:	 800100               	add	byte ptr [rcx], 0
-;; 13e10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13e19:	 800100               	add	byte ptr [rcx], 0
-;; 13e1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13e1d:	 800100               	add	byte ptr [rcx], 0
-;; 13e20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13e29:	 800100               	add	byte ptr [rcx], 0
-;; 13e2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13e2d:	 800100               	add	byte ptr [rcx], 0
-;; 13e30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13e39:	 800100               	add	byte ptr [rcx], 0
-;; 13e3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13e3d:	 800100               	add	byte ptr [rcx], 0
-;; 13e40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13e49:	 800100               	add	byte ptr [rcx], 0
-;; 13e4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13e4d:	 800100               	add	byte ptr [rcx], 0
-;; 13e50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13e59:	 800100               	add	byte ptr [rcx], 0
-;; 13e5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13e5d:	 800100               	add	byte ptr [rcx], 0
-;; 13e60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13e69:	 800100               	add	byte ptr [rcx], 0
-;; 13e6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13e6d:	 800100               	add	byte ptr [rcx], 0
-;; 13e70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13e79:	 800100               	add	byte ptr [rcx], 0
-;; 13e7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13e7d:	 800100               	add	byte ptr [rcx], 0
-;; 13e80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13e89:	 800100               	add	byte ptr [rcx], 0
-;; 13e8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13e8d:	 800100               	add	byte ptr [rcx], 0
-;; 13e90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13e99:	 800100               	add	byte ptr [rcx], 0
-;; 13e9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13e9d:	 800100               	add	byte ptr [rcx], 0
-;; 13ea0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13ea9:	 800100               	add	byte ptr [rcx], 0
-;; 13eac:	 aa                   	stosb	byte ptr [rdi], al
-;; 13ead:	 800100               	add	byte ptr [rcx], 0
-;; 13eb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13eb9:	 800100               	add	byte ptr [rcx], 0
-;; 13ebc:	 aa                   	stosb	byte ptr [rdi], al
-;; 13ebd:	 800100               	add	byte ptr [rcx], 0
-;; 13ec0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13ec9:	 800100               	add	byte ptr [rcx], 0
-;; 13ecc:	 aa                   	stosb	byte ptr [rdi], al
-;; 13ecd:	 800100               	add	byte ptr [rcx], 0
-;; 13ed0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13ed9:	 800100               	add	byte ptr [rcx], 0
-;; 13edc:	 aa                   	stosb	byte ptr [rdi], al
-;; 13edd:	 800100               	add	byte ptr [rcx], 0
-;; 13ee0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13ee9:	 800100               	add	byte ptr [rcx], 0
-;; 13eec:	 aa                   	stosb	byte ptr [rdi], al
-;; 13eed:	 800100               	add	byte ptr [rcx], 0
-;; 13ef0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13ef9:	 800100               	add	byte ptr [rcx], 0
-;; 13efc:	 aa                   	stosb	byte ptr [rdi], al
-;; 13efd:	 800100               	add	byte ptr [rcx], 0
-;; 13f00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13f09:	 800100               	add	byte ptr [rcx], 0
-;; 13f0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13f0d:	 800100               	add	byte ptr [rcx], 0
-;; 13f10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13f19:	 800100               	add	byte ptr [rcx], 0
-;; 13f1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13f1d:	 800100               	add	byte ptr [rcx], 0
-;; 13f20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13f29:	 800100               	add	byte ptr [rcx], 0
-;; 13f2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13f2d:	 800100               	add	byte ptr [rcx], 0
-;; 13f30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13f39:	 800100               	add	byte ptr [rcx], 0
-;; 13f3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13f3d:	 800100               	add	byte ptr [rcx], 0
-;; 13f40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13f49:	 800100               	add	byte ptr [rcx], 0
-;; 13f4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13f4d:	 800100               	add	byte ptr [rcx], 0
-;; 13f50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13f59:	 800100               	add	byte ptr [rcx], 0
-;; 13f5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13f5d:	 800100               	add	byte ptr [rcx], 0
-;; 13f60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13f69:	 800100               	add	byte ptr [rcx], 0
-;; 13f6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13f6d:	 800100               	add	byte ptr [rcx], 0
-;; 13f70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13f79:	 800100               	add	byte ptr [rcx], 0
-;; 13f7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13f7d:	 800100               	add	byte ptr [rcx], 0
-;; 13f80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13f89:	 800100               	add	byte ptr [rcx], 0
-;; 13f8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13f8d:	 800100               	add	byte ptr [rcx], 0
-;; 13f90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13f99:	 800100               	add	byte ptr [rcx], 0
-;; 13f9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 13f9d:	 800100               	add	byte ptr [rcx], 0
-;; 13fa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13fa9:	 800100               	add	byte ptr [rcx], 0
-;; 13fac:	 aa                   	stosb	byte ptr [rdi], al
-;; 13fad:	 800100               	add	byte ptr [rcx], 0
-;; 13fb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13fb9:	 800100               	add	byte ptr [rcx], 0
-;; 13fbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 13fbd:	 800100               	add	byte ptr [rcx], 0
-;; 13fc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13fc9:	 800100               	add	byte ptr [rcx], 0
-;; 13fcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 13fcd:	 800100               	add	byte ptr [rcx], 0
-;; 13fd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13fd9:	 800100               	add	byte ptr [rcx], 0
-;; 13fdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 13fdd:	 800100               	add	byte ptr [rcx], 0
-;; 13fe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13fe9:	 800100               	add	byte ptr [rcx], 0
-;; 13fec:	 aa                   	stosb	byte ptr [rdi], al
-;; 13fed:	 800100               	add	byte ptr [rcx], 0
-;; 13ff0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 13ff9:	 800100               	add	byte ptr [rcx], 0
-;; 13ffc:	 aa                   	stosb	byte ptr [rdi], al
-;; 13ffd:	 800100               	add	byte ptr [rcx], 0
-;; 14000:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14009:	 800100               	add	byte ptr [rcx], 0
-;; 1400c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1400d:	 800100               	add	byte ptr [rcx], 0
-;; 14010:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14019:	 800100               	add	byte ptr [rcx], 0
-;; 1401c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1401d:	 800100               	add	byte ptr [rcx], 0
-;; 14020:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14029:	 800100               	add	byte ptr [rcx], 0
-;; 1402c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1402d:	 800100               	add	byte ptr [rcx], 0
-;; 14030:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14039:	 800100               	add	byte ptr [rcx], 0
-;; 1403c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1403d:	 800100               	add	byte ptr [rcx], 0
-;; 14040:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14049:	 800100               	add	byte ptr [rcx], 0
-;; 1404c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1404d:	 800100               	add	byte ptr [rcx], 0
-;; 14050:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14059:	 800100               	add	byte ptr [rcx], 0
-;; 1405c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1405d:	 800100               	add	byte ptr [rcx], 0
-;; 14060:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14069:	 800100               	add	byte ptr [rcx], 0
-;; 1406c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1406d:	 800100               	add	byte ptr [rcx], 0
-;; 14070:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14079:	 800100               	add	byte ptr [rcx], 0
-;; 1407c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1407d:	 800100               	add	byte ptr [rcx], 0
-;; 14080:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14089:	 800100               	add	byte ptr [rcx], 0
-;; 1408c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1408d:	 800100               	add	byte ptr [rcx], 0
-;; 14090:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14099:	 800100               	add	byte ptr [rcx], 0
-;; 1409c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1409d:	 800100               	add	byte ptr [rcx], 0
-;; 140a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 140a9:	 800100               	add	byte ptr [rcx], 0
-;; 140ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 140ad:	 800100               	add	byte ptr [rcx], 0
-;; 140b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 140b9:	 800100               	add	byte ptr [rcx], 0
-;; 140bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 140bd:	 800100               	add	byte ptr [rcx], 0
-;; 140c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 140c9:	 800100               	add	byte ptr [rcx], 0
-;; 140cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 140cd:	 800100               	add	byte ptr [rcx], 0
-;; 140d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 140d9:	 800100               	add	byte ptr [rcx], 0
-;; 140dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 140dd:	 800100               	add	byte ptr [rcx], 0
-;; 140e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 140e9:	 800100               	add	byte ptr [rcx], 0
-;; 140ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 140ed:	 800100               	add	byte ptr [rcx], 0
-;; 140f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 140f9:	 800100               	add	byte ptr [rcx], 0
-;; 140fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 140fd:	 800100               	add	byte ptr [rcx], 0
-;; 14100:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14109:	 800100               	add	byte ptr [rcx], 0
-;; 1410c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1410d:	 800100               	add	byte ptr [rcx], 0
-;; 14110:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14119:	 800100               	add	byte ptr [rcx], 0
-;; 1411c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1411d:	 800100               	add	byte ptr [rcx], 0
-;; 14120:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14129:	 800100               	add	byte ptr [rcx], 0
-;; 1412c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1412d:	 800100               	add	byte ptr [rcx], 0
-;; 14130:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14139:	 800100               	add	byte ptr [rcx], 0
-;; 1413c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1413d:	 800100               	add	byte ptr [rcx], 0
-;; 14140:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14149:	 800100               	add	byte ptr [rcx], 0
-;; 1414c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1414d:	 800100               	add	byte ptr [rcx], 0
-;; 14150:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14159:	 800100               	add	byte ptr [rcx], 0
-;; 1415c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1415d:	 800100               	add	byte ptr [rcx], 0
-;; 14160:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14169:	 800100               	add	byte ptr [rcx], 0
-;; 1416c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1416d:	 800100               	add	byte ptr [rcx], 0
-;; 14170:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14179:	 800100               	add	byte ptr [rcx], 0
-;; 1417c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1417d:	 800100               	add	byte ptr [rcx], 0
-;; 14180:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14189:	 800100               	add	byte ptr [rcx], 0
-;; 1418c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1418d:	 800100               	add	byte ptr [rcx], 0
-;; 14190:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14199:	 800100               	add	byte ptr [rcx], 0
-;; 1419c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1419d:	 800100               	add	byte ptr [rcx], 0
-;; 141a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 141a9:	 800100               	add	byte ptr [rcx], 0
-;; 141ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 141ad:	 800100               	add	byte ptr [rcx], 0
-;; 141b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 141b9:	 800100               	add	byte ptr [rcx], 0
-;; 141bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 141bd:	 800100               	add	byte ptr [rcx], 0
-;; 141c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 141c9:	 800100               	add	byte ptr [rcx], 0
-;; 141cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 141cd:	 800100               	add	byte ptr [rcx], 0
-;; 141d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 141d9:	 800100               	add	byte ptr [rcx], 0
-;; 141dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 141dd:	 800100               	add	byte ptr [rcx], 0
-;; 141e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 141e9:	 800100               	add	byte ptr [rcx], 0
-;; 141ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 141ed:	 800100               	add	byte ptr [rcx], 0
-;; 141f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 141f9:	 800100               	add	byte ptr [rcx], 0
-;; 141fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 141fd:	 800100               	add	byte ptr [rcx], 0
-;; 14200:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14209:	 800100               	add	byte ptr [rcx], 0
-;; 1420c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1420d:	 800100               	add	byte ptr [rcx], 0
-;; 14210:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14219:	 800100               	add	byte ptr [rcx], 0
-;; 1421c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1421d:	 800100               	add	byte ptr [rcx], 0
-;; 14220:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14229:	 800100               	add	byte ptr [rcx], 0
-;; 1422c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1422d:	 800100               	add	byte ptr [rcx], 0
-;; 14230:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14239:	 800100               	add	byte ptr [rcx], 0
-;; 1423c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1423d:	 800100               	add	byte ptr [rcx], 0
-;; 14240:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14249:	 800100               	add	byte ptr [rcx], 0
-;; 1424c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1424d:	 800100               	add	byte ptr [rcx], 0
-;; 14250:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14259:	 800100               	add	byte ptr [rcx], 0
-;; 1425c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1425d:	 800100               	add	byte ptr [rcx], 0
-;; 14260:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14269:	 800100               	add	byte ptr [rcx], 0
-;; 1426c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1426d:	 800100               	add	byte ptr [rcx], 0
-;; 14270:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14279:	 800100               	add	byte ptr [rcx], 0
-;; 1427c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1427d:	 800100               	add	byte ptr [rcx], 0
-;; 14280:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14289:	 800100               	add	byte ptr [rcx], 0
-;; 1428c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1428d:	 800100               	add	byte ptr [rcx], 0
-;; 14290:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14299:	 800100               	add	byte ptr [rcx], 0
-;; 1429c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1429d:	 800100               	add	byte ptr [rcx], 0
-;; 142a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 142a9:	 800100               	add	byte ptr [rcx], 0
-;; 142ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 142ad:	 800100               	add	byte ptr [rcx], 0
-;; 142b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 142b9:	 800100               	add	byte ptr [rcx], 0
-;; 142bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 142bd:	 800100               	add	byte ptr [rcx], 0
-;; 142c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 142c9:	 800100               	add	byte ptr [rcx], 0
-;; 142cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 142cd:	 800100               	add	byte ptr [rcx], 0
-;; 142d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 142d9:	 800100               	add	byte ptr [rcx], 0
-;; 142dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 142dd:	 800100               	add	byte ptr [rcx], 0
-;; 142e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 142e9:	 800100               	add	byte ptr [rcx], 0
-;; 142ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 142ed:	 800100               	add	byte ptr [rcx], 0
-;; 142f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 142f9:	 800100               	add	byte ptr [rcx], 0
-;; 142fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 142fd:	 800100               	add	byte ptr [rcx], 0
-;; 14300:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14309:	 800100               	add	byte ptr [rcx], 0
-;; 1430c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1430d:	 800100               	add	byte ptr [rcx], 0
-;; 14310:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14319:	 800100               	add	byte ptr [rcx], 0
-;; 1431c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1431d:	 800100               	add	byte ptr [rcx], 0
-;; 14320:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14329:	 800100               	add	byte ptr [rcx], 0
-;; 1432c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1432d:	 800100               	add	byte ptr [rcx], 0
-;; 14330:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14339:	 800100               	add	byte ptr [rcx], 0
-;; 1433c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1433d:	 800100               	add	byte ptr [rcx], 0
-;; 14340:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14349:	 800100               	add	byte ptr [rcx], 0
-;; 1434c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1434d:	 800100               	add	byte ptr [rcx], 0
-;; 14350:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14359:	 800100               	add	byte ptr [rcx], 0
-;; 1435c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1435d:	 800100               	add	byte ptr [rcx], 0
-;; 14360:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14369:	 800100               	add	byte ptr [rcx], 0
-;; 1436c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1436d:	 800100               	add	byte ptr [rcx], 0
-;; 14370:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14379:	 800100               	add	byte ptr [rcx], 0
-;; 1437c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1437d:	 800100               	add	byte ptr [rcx], 0
-;; 14380:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14389:	 800100               	add	byte ptr [rcx], 0
-;; 1438c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1438d:	 800100               	add	byte ptr [rcx], 0
-;; 14390:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14399:	 800100               	add	byte ptr [rcx], 0
-;; 1439c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1439d:	 800100               	add	byte ptr [rcx], 0
-;; 143a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 143a9:	 800100               	add	byte ptr [rcx], 0
-;; 143ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 143ad:	 800100               	add	byte ptr [rcx], 0
-;; 143b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 143b9:	 800100               	add	byte ptr [rcx], 0
-;; 143bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 143bd:	 800100               	add	byte ptr [rcx], 0
-;; 143c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 143c9:	 800100               	add	byte ptr [rcx], 0
-;; 143cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 143cd:	 800100               	add	byte ptr [rcx], 0
-;; 143d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 143d9:	 800100               	add	byte ptr [rcx], 0
-;; 143dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 143dd:	 800100               	add	byte ptr [rcx], 0
-;; 143e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 143e9:	 800100               	add	byte ptr [rcx], 0
-;; 143ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 143ed:	 800100               	add	byte ptr [rcx], 0
-;; 143f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 143f9:	 800100               	add	byte ptr [rcx], 0
-;; 143fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 143fd:	 800100               	add	byte ptr [rcx], 0
-;; 14400:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14409:	 800100               	add	byte ptr [rcx], 0
-;; 1440c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1440d:	 800100               	add	byte ptr [rcx], 0
-;; 14410:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14419:	 800100               	add	byte ptr [rcx], 0
-;; 1441c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1441d:	 800100               	add	byte ptr [rcx], 0
-;; 14420:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14429:	 800100               	add	byte ptr [rcx], 0
-;; 1442c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1442d:	 800100               	add	byte ptr [rcx], 0
-;; 14430:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14439:	 800100               	add	byte ptr [rcx], 0
-;; 1443c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1443d:	 800100               	add	byte ptr [rcx], 0
-;; 14440:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14449:	 800100               	add	byte ptr [rcx], 0
-;; 1444c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1444d:	 800100               	add	byte ptr [rcx], 0
-;; 14450:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14459:	 800100               	add	byte ptr [rcx], 0
-;; 1445c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1445d:	 800100               	add	byte ptr [rcx], 0
-;; 14460:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14469:	 800100               	add	byte ptr [rcx], 0
-;; 1446c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1446d:	 800100               	add	byte ptr [rcx], 0
-;; 14470:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14479:	 800100               	add	byte ptr [rcx], 0
-;; 1447c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1447d:	 800100               	add	byte ptr [rcx], 0
-;; 14480:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14489:	 800100               	add	byte ptr [rcx], 0
-;; 1448c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1448d:	 800100               	add	byte ptr [rcx], 0
-;; 14490:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14499:	 800100               	add	byte ptr [rcx], 0
-;; 1449c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1449d:	 800100               	add	byte ptr [rcx], 0
-;; 144a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 144a9:	 800100               	add	byte ptr [rcx], 0
-;; 144ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 144ad:	 800100               	add	byte ptr [rcx], 0
-;; 144b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 144b9:	 800100               	add	byte ptr [rcx], 0
-;; 144bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 144bd:	 800100               	add	byte ptr [rcx], 0
-;; 144c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 144c9:	 800100               	add	byte ptr [rcx], 0
-;; 144cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 144cd:	 800100               	add	byte ptr [rcx], 0
-;; 144d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 144d9:	 800100               	add	byte ptr [rcx], 0
-;; 144dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 144dd:	 800100               	add	byte ptr [rcx], 0
-;; 144e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 144e9:	 800100               	add	byte ptr [rcx], 0
-;; 144ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 144ed:	 800100               	add	byte ptr [rcx], 0
-;; 144f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 144f9:	 800100               	add	byte ptr [rcx], 0
-;; 144fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 144fd:	 800100               	add	byte ptr [rcx], 0
-;; 14500:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14509:	 800100               	add	byte ptr [rcx], 0
-;; 1450c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1450d:	 800100               	add	byte ptr [rcx], 0
-;; 14510:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14519:	 800100               	add	byte ptr [rcx], 0
-;; 1451c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1451d:	 800100               	add	byte ptr [rcx], 0
-;; 14520:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14529:	 800100               	add	byte ptr [rcx], 0
-;; 1452c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1452d:	 800100               	add	byte ptr [rcx], 0
-;; 14530:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14539:	 800100               	add	byte ptr [rcx], 0
-;; 1453c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1453d:	 800100               	add	byte ptr [rcx], 0
-;; 14540:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14549:	 800100               	add	byte ptr [rcx], 0
-;; 1454c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1454d:	 800100               	add	byte ptr [rcx], 0
-;; 14550:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14559:	 800100               	add	byte ptr [rcx], 0
-;; 1455c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1455d:	 800100               	add	byte ptr [rcx], 0
-;; 14560:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14569:	 800100               	add	byte ptr [rcx], 0
-;; 1456c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1456d:	 800100               	add	byte ptr [rcx], 0
-;; 14570:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14579:	 800100               	add	byte ptr [rcx], 0
-;; 1457c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1457d:	 800100               	add	byte ptr [rcx], 0
-;; 14580:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14589:	 800100               	add	byte ptr [rcx], 0
-;; 1458c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1458d:	 800100               	add	byte ptr [rcx], 0
-;; 14590:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14599:	 800100               	add	byte ptr [rcx], 0
-;; 1459c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1459d:	 800100               	add	byte ptr [rcx], 0
-;; 145a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 145a9:	 800100               	add	byte ptr [rcx], 0
-;; 145ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 145ad:	 800100               	add	byte ptr [rcx], 0
-;; 145b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 145b9:	 800100               	add	byte ptr [rcx], 0
-;; 145bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 145bd:	 800100               	add	byte ptr [rcx], 0
-;; 145c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 145c9:	 800100               	add	byte ptr [rcx], 0
-;; 145cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 145cd:	 800100               	add	byte ptr [rcx], 0
-;; 145d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 145d9:	 800100               	add	byte ptr [rcx], 0
-;; 145dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 145dd:	 800100               	add	byte ptr [rcx], 0
-;; 145e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 145e9:	 800100               	add	byte ptr [rcx], 0
-;; 145ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 145ed:	 800100               	add	byte ptr [rcx], 0
-;; 145f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 145f9:	 800100               	add	byte ptr [rcx], 0
-;; 145fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 145fd:	 800100               	add	byte ptr [rcx], 0
-;; 14600:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14609:	 800100               	add	byte ptr [rcx], 0
-;; 1460c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1460d:	 800100               	add	byte ptr [rcx], 0
-;; 14610:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14619:	 800100               	add	byte ptr [rcx], 0
-;; 1461c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1461d:	 800100               	add	byte ptr [rcx], 0
-;; 14620:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14629:	 800100               	add	byte ptr [rcx], 0
-;; 1462c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1462d:	 800100               	add	byte ptr [rcx], 0
-;; 14630:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14639:	 800100               	add	byte ptr [rcx], 0
-;; 1463c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1463d:	 800100               	add	byte ptr [rcx], 0
-;; 14640:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14649:	 800100               	add	byte ptr [rcx], 0
-;; 1464c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1464d:	 800100               	add	byte ptr [rcx], 0
-;; 14650:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14659:	 800100               	add	byte ptr [rcx], 0
-;; 1465c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1465d:	 800100               	add	byte ptr [rcx], 0
-;; 14660:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14669:	 800100               	add	byte ptr [rcx], 0
-;; 1466c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1466d:	 800100               	add	byte ptr [rcx], 0
-;; 14670:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14679:	 800100               	add	byte ptr [rcx], 0
-;; 1467c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1467d:	 800100               	add	byte ptr [rcx], 0
-;; 14680:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14689:	 800100               	add	byte ptr [rcx], 0
-;; 1468c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1468d:	 800100               	add	byte ptr [rcx], 0
-;; 14690:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14699:	 800100               	add	byte ptr [rcx], 0
-;; 1469c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1469d:	 800100               	add	byte ptr [rcx], 0
-;; 146a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 146a9:	 800100               	add	byte ptr [rcx], 0
-;; 146ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 146ad:	 800100               	add	byte ptr [rcx], 0
-;; 146b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 146b9:	 800100               	add	byte ptr [rcx], 0
-;; 146bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 146bd:	 800100               	add	byte ptr [rcx], 0
-;; 146c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 146c9:	 800100               	add	byte ptr [rcx], 0
-;; 146cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 146cd:	 800100               	add	byte ptr [rcx], 0
-;; 146d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 146d9:	 800100               	add	byte ptr [rcx], 0
-;; 146dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 146dd:	 800100               	add	byte ptr [rcx], 0
-;; 146e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 146e9:	 800100               	add	byte ptr [rcx], 0
-;; 146ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 146ed:	 800100               	add	byte ptr [rcx], 0
-;; 146f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 146f9:	 800100               	add	byte ptr [rcx], 0
-;; 146fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 146fd:	 800100               	add	byte ptr [rcx], 0
-;; 14700:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14709:	 800100               	add	byte ptr [rcx], 0
-;; 1470c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1470d:	 800100               	add	byte ptr [rcx], 0
-;; 14710:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14719:	 800100               	add	byte ptr [rcx], 0
-;; 1471c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1471d:	 800100               	add	byte ptr [rcx], 0
-;; 14720:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14729:	 800100               	add	byte ptr [rcx], 0
-;; 1472c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1472d:	 800100               	add	byte ptr [rcx], 0
-;; 14730:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14739:	 800100               	add	byte ptr [rcx], 0
-;; 1473c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1473d:	 800100               	add	byte ptr [rcx], 0
-;; 14740:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14749:	 800100               	add	byte ptr [rcx], 0
-;; 1474c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1474d:	 800100               	add	byte ptr [rcx], 0
-;; 14750:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14759:	 800100               	add	byte ptr [rcx], 0
-;; 1475c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1475d:	 800100               	add	byte ptr [rcx], 0
-;; 14760:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14769:	 800100               	add	byte ptr [rcx], 0
-;; 1476c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1476d:	 800100               	add	byte ptr [rcx], 0
-;; 14770:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14779:	 800100               	add	byte ptr [rcx], 0
-;; 1477c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1477d:	 800100               	add	byte ptr [rcx], 0
-;; 14780:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14789:	 800100               	add	byte ptr [rcx], 0
-;; 1478c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1478d:	 800100               	add	byte ptr [rcx], 0
-;; 14790:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14799:	 800100               	add	byte ptr [rcx], 0
-;; 1479c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1479d:	 800100               	add	byte ptr [rcx], 0
-;; 147a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 147a9:	 800100               	add	byte ptr [rcx], 0
-;; 147ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 147ad:	 800100               	add	byte ptr [rcx], 0
-;; 147b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 147b9:	 800100               	add	byte ptr [rcx], 0
-;; 147bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 147bd:	 800100               	add	byte ptr [rcx], 0
-;; 147c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 147c9:	 800100               	add	byte ptr [rcx], 0
-;; 147cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 147cd:	 800100               	add	byte ptr [rcx], 0
-;; 147d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 147d9:	 800100               	add	byte ptr [rcx], 0
-;; 147dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 147dd:	 800100               	add	byte ptr [rcx], 0
-;; 147e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 147e9:	 800100               	add	byte ptr [rcx], 0
-;; 147ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 147ed:	 800100               	add	byte ptr [rcx], 0
-;; 147f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 147f9:	 800100               	add	byte ptr [rcx], 0
-;; 147fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 147fd:	 800100               	add	byte ptr [rcx], 0
-;; 14800:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14809:	 800100               	add	byte ptr [rcx], 0
-;; 1480c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1480d:	 800100               	add	byte ptr [rcx], 0
-;; 14810:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14819:	 800100               	add	byte ptr [rcx], 0
-;; 1481c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1481d:	 800100               	add	byte ptr [rcx], 0
-;; 14820:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14829:	 800100               	add	byte ptr [rcx], 0
-;; 1482c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1482d:	 800100               	add	byte ptr [rcx], 0
-;; 14830:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14839:	 800100               	add	byte ptr [rcx], 0
-;; 1483c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1483d:	 800100               	add	byte ptr [rcx], 0
-;; 14840:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14849:	 800100               	add	byte ptr [rcx], 0
-;; 1484c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1484d:	 800100               	add	byte ptr [rcx], 0
-;; 14850:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14859:	 800100               	add	byte ptr [rcx], 0
-;; 1485c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1485d:	 800100               	add	byte ptr [rcx], 0
-;; 14860:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14869:	 800100               	add	byte ptr [rcx], 0
-;; 1486c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1486d:	 800100               	add	byte ptr [rcx], 0
-;; 14870:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14879:	 800100               	add	byte ptr [rcx], 0
-;; 1487c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1487d:	 800100               	add	byte ptr [rcx], 0
-;; 14880:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14889:	 800100               	add	byte ptr [rcx], 0
-;; 1488c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1488d:	 800100               	add	byte ptr [rcx], 0
-;; 14890:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14899:	 800100               	add	byte ptr [rcx], 0
-;; 1489c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1489d:	 800100               	add	byte ptr [rcx], 0
-;; 148a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 148a9:	 800100               	add	byte ptr [rcx], 0
-;; 148ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 148ad:	 800100               	add	byte ptr [rcx], 0
-;; 148b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 148b9:	 800100               	add	byte ptr [rcx], 0
-;; 148bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 148bd:	 800100               	add	byte ptr [rcx], 0
-;; 148c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 148c9:	 800100               	add	byte ptr [rcx], 0
-;; 148cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 148cd:	 800100               	add	byte ptr [rcx], 0
-;; 148d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 148d9:	 800100               	add	byte ptr [rcx], 0
-;; 148dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 148dd:	 800100               	add	byte ptr [rcx], 0
-;; 148e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 148e9:	 800100               	add	byte ptr [rcx], 0
-;; 148ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 148ed:	 800100               	add	byte ptr [rcx], 0
-;; 148f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 148f9:	 800100               	add	byte ptr [rcx], 0
-;; 148fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 148fd:	 800100               	add	byte ptr [rcx], 0
-;; 14900:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14909:	 800100               	add	byte ptr [rcx], 0
-;; 1490c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1490d:	 800100               	add	byte ptr [rcx], 0
-;; 14910:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14919:	 800100               	add	byte ptr [rcx], 0
-;; 1491c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1491d:	 800100               	add	byte ptr [rcx], 0
-;; 14920:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14929:	 800100               	add	byte ptr [rcx], 0
-;; 1492c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1492d:	 800100               	add	byte ptr [rcx], 0
-;; 14930:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14939:	 800100               	add	byte ptr [rcx], 0
-;; 1493c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1493d:	 800100               	add	byte ptr [rcx], 0
-;; 14940:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14949:	 800100               	add	byte ptr [rcx], 0
-;; 1494c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1494d:	 800100               	add	byte ptr [rcx], 0
-;; 14950:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14959:	 800100               	add	byte ptr [rcx], 0
-;; 1495c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1495d:	 800100               	add	byte ptr [rcx], 0
-;; 14960:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14969:	 800100               	add	byte ptr [rcx], 0
-;; 1496c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1496d:	 800100               	add	byte ptr [rcx], 0
-;; 14970:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14979:	 800100               	add	byte ptr [rcx], 0
-;; 1497c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1497d:	 800100               	add	byte ptr [rcx], 0
-;; 14980:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14989:	 800100               	add	byte ptr [rcx], 0
-;; 1498c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1498d:	 800100               	add	byte ptr [rcx], 0
-;; 14990:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14999:	 800100               	add	byte ptr [rcx], 0
-;; 1499c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1499d:	 800100               	add	byte ptr [rcx], 0
-;; 149a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 149a9:	 800100               	add	byte ptr [rcx], 0
-;; 149ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 149ad:	 800100               	add	byte ptr [rcx], 0
-;; 149b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 149b9:	 800100               	add	byte ptr [rcx], 0
-;; 149bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 149bd:	 800100               	add	byte ptr [rcx], 0
-;; 149c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 149c9:	 800100               	add	byte ptr [rcx], 0
-;; 149cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 149cd:	 800100               	add	byte ptr [rcx], 0
-;; 149d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 149d9:	 800100               	add	byte ptr [rcx], 0
-;; 149dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 149dd:	 800100               	add	byte ptr [rcx], 0
-;; 149e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 149e9:	 800100               	add	byte ptr [rcx], 0
-;; 149ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 149ed:	 800100               	add	byte ptr [rcx], 0
-;; 149f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 149f9:	 800100               	add	byte ptr [rcx], 0
-;; 149fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 149fd:	 800100               	add	byte ptr [rcx], 0
-;; 14a00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14a09:	 800100               	add	byte ptr [rcx], 0
-;; 14a0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14a0d:	 800100               	add	byte ptr [rcx], 0
-;; 14a10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14a19:	 800100               	add	byte ptr [rcx], 0
-;; 14a1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14a1d:	 800100               	add	byte ptr [rcx], 0
-;; 14a20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14a29:	 800100               	add	byte ptr [rcx], 0
-;; 14a2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14a2d:	 800100               	add	byte ptr [rcx], 0
-;; 14a30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14a39:	 800100               	add	byte ptr [rcx], 0
-;; 14a3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14a3d:	 800100               	add	byte ptr [rcx], 0
-;; 14a40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14a49:	 800100               	add	byte ptr [rcx], 0
-;; 14a4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14a4d:	 800100               	add	byte ptr [rcx], 0
-;; 14a50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14a59:	 800100               	add	byte ptr [rcx], 0
-;; 14a5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14a5d:	 800100               	add	byte ptr [rcx], 0
-;; 14a60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14a69:	 800100               	add	byte ptr [rcx], 0
-;; 14a6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14a6d:	 800100               	add	byte ptr [rcx], 0
-;; 14a70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14a79:	 800100               	add	byte ptr [rcx], 0
-;; 14a7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14a7d:	 800100               	add	byte ptr [rcx], 0
-;; 14a80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14a89:	 800100               	add	byte ptr [rcx], 0
-;; 14a8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14a8d:	 800100               	add	byte ptr [rcx], 0
-;; 14a90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14a99:	 800100               	add	byte ptr [rcx], 0
-;; 14a9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14a9d:	 800100               	add	byte ptr [rcx], 0
-;; 14aa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14aa9:	 800100               	add	byte ptr [rcx], 0
-;; 14aac:	 aa                   	stosb	byte ptr [rdi], al
-;; 14aad:	 800100               	add	byte ptr [rcx], 0
-;; 14ab0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14ab9:	 800100               	add	byte ptr [rcx], 0
-;; 14abc:	 aa                   	stosb	byte ptr [rdi], al
-;; 14abd:	 800100               	add	byte ptr [rcx], 0
-;; 14ac0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14ac9:	 800100               	add	byte ptr [rcx], 0
-;; 14acc:	 aa                   	stosb	byte ptr [rdi], al
-;; 14acd:	 800100               	add	byte ptr [rcx], 0
-;; 14ad0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14ad9:	 800100               	add	byte ptr [rcx], 0
-;; 14adc:	 aa                   	stosb	byte ptr [rdi], al
-;; 14add:	 800100               	add	byte ptr [rcx], 0
-;; 14ae0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14ae9:	 800100               	add	byte ptr [rcx], 0
-;; 14aec:	 aa                   	stosb	byte ptr [rdi], al
-;; 14aed:	 800100               	add	byte ptr [rcx], 0
-;; 14af0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14af9:	 800100               	add	byte ptr [rcx], 0
-;; 14afc:	 aa                   	stosb	byte ptr [rdi], al
-;; 14afd:	 800100               	add	byte ptr [rcx], 0
-;; 14b00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14b09:	 800100               	add	byte ptr [rcx], 0
-;; 14b0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14b0d:	 800100               	add	byte ptr [rcx], 0
-;; 14b10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14b19:	 800100               	add	byte ptr [rcx], 0
-;; 14b1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14b1d:	 800100               	add	byte ptr [rcx], 0
-;; 14b20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14b29:	 800100               	add	byte ptr [rcx], 0
-;; 14b2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14b2d:	 800100               	add	byte ptr [rcx], 0
-;; 14b30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14b39:	 800100               	add	byte ptr [rcx], 0
-;; 14b3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14b3d:	 800100               	add	byte ptr [rcx], 0
-;; 14b40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14b49:	 800100               	add	byte ptr [rcx], 0
-;; 14b4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14b4d:	 800100               	add	byte ptr [rcx], 0
-;; 14b50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14b59:	 800100               	add	byte ptr [rcx], 0
-;; 14b5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14b5d:	 800100               	add	byte ptr [rcx], 0
-;; 14b60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14b69:	 800100               	add	byte ptr [rcx], 0
-;; 14b6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14b6d:	 800100               	add	byte ptr [rcx], 0
-;; 14b70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14b79:	 800100               	add	byte ptr [rcx], 0
-;; 14b7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14b7d:	 800100               	add	byte ptr [rcx], 0
-;; 14b80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14b89:	 800100               	add	byte ptr [rcx], 0
-;; 14b8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14b8d:	 800100               	add	byte ptr [rcx], 0
-;; 14b90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14b99:	 800100               	add	byte ptr [rcx], 0
-;; 14b9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14b9d:	 800100               	add	byte ptr [rcx], 0
-;; 14ba0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14ba9:	 800100               	add	byte ptr [rcx], 0
-;; 14bac:	 aa                   	stosb	byte ptr [rdi], al
-;; 14bad:	 800100               	add	byte ptr [rcx], 0
-;; 14bb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14bb9:	 800100               	add	byte ptr [rcx], 0
-;; 14bbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 14bbd:	 800100               	add	byte ptr [rcx], 0
-;; 14bc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14bc9:	 800100               	add	byte ptr [rcx], 0
-;; 14bcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 14bcd:	 800100               	add	byte ptr [rcx], 0
-;; 14bd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14bd9:	 800100               	add	byte ptr [rcx], 0
-;; 14bdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 14bdd:	 800100               	add	byte ptr [rcx], 0
-;; 14be0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14be9:	 800100               	add	byte ptr [rcx], 0
-;; 14bec:	 aa                   	stosb	byte ptr [rdi], al
-;; 14bed:	 800100               	add	byte ptr [rcx], 0
-;; 14bf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14bf9:	 800100               	add	byte ptr [rcx], 0
-;; 14bfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 14bfd:	 800100               	add	byte ptr [rcx], 0
-;; 14c00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14c09:	 800100               	add	byte ptr [rcx], 0
-;; 14c0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14c0d:	 800100               	add	byte ptr [rcx], 0
-;; 14c10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14c19:	 800100               	add	byte ptr [rcx], 0
-;; 14c1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14c1d:	 800100               	add	byte ptr [rcx], 0
-;; 14c20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14c29:	 800100               	add	byte ptr [rcx], 0
-;; 14c2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14c2d:	 800100               	add	byte ptr [rcx], 0
-;; 14c30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14c39:	 800100               	add	byte ptr [rcx], 0
-;; 14c3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14c3d:	 800100               	add	byte ptr [rcx], 0
-;; 14c40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14c49:	 800100               	add	byte ptr [rcx], 0
-;; 14c4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14c4d:	 800100               	add	byte ptr [rcx], 0
-;; 14c50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14c59:	 800100               	add	byte ptr [rcx], 0
-;; 14c5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14c5d:	 800100               	add	byte ptr [rcx], 0
-;; 14c60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14c69:	 800100               	add	byte ptr [rcx], 0
-;; 14c6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14c6d:	 800100               	add	byte ptr [rcx], 0
-;; 14c70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14c79:	 800100               	add	byte ptr [rcx], 0
-;; 14c7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14c7d:	 800100               	add	byte ptr [rcx], 0
-;; 14c80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14c89:	 800100               	add	byte ptr [rcx], 0
-;; 14c8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14c8d:	 800100               	add	byte ptr [rcx], 0
-;; 14c90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14c99:	 800100               	add	byte ptr [rcx], 0
-;; 14c9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14c9d:	 800100               	add	byte ptr [rcx], 0
-;; 14ca0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14ca9:	 800100               	add	byte ptr [rcx], 0
-;; 14cac:	 aa                   	stosb	byte ptr [rdi], al
-;; 14cad:	 800100               	add	byte ptr [rcx], 0
-;; 14cb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14cb9:	 800100               	add	byte ptr [rcx], 0
-;; 14cbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 14cbd:	 800100               	add	byte ptr [rcx], 0
-;; 14cc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14cc9:	 800100               	add	byte ptr [rcx], 0
-;; 14ccc:	 aa                   	stosb	byte ptr [rdi], al
-;; 14ccd:	 800100               	add	byte ptr [rcx], 0
-;; 14cd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14cd9:	 800100               	add	byte ptr [rcx], 0
-;; 14cdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 14cdd:	 800100               	add	byte ptr [rcx], 0
-;; 14ce0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14ce9:	 800100               	add	byte ptr [rcx], 0
-;; 14cec:	 aa                   	stosb	byte ptr [rdi], al
-;; 14ced:	 800100               	add	byte ptr [rcx], 0
-;; 14cf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14cf9:	 800100               	add	byte ptr [rcx], 0
-;; 14cfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 14cfd:	 800100               	add	byte ptr [rcx], 0
-;; 14d00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14d09:	 800100               	add	byte ptr [rcx], 0
-;; 14d0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14d0d:	 800100               	add	byte ptr [rcx], 0
-;; 14d10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14d19:	 800100               	add	byte ptr [rcx], 0
-;; 14d1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14d1d:	 800100               	add	byte ptr [rcx], 0
-;; 14d20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14d29:	 800100               	add	byte ptr [rcx], 0
-;; 14d2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14d2d:	 800100               	add	byte ptr [rcx], 0
-;; 14d30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14d39:	 800100               	add	byte ptr [rcx], 0
-;; 14d3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14d3d:	 800100               	add	byte ptr [rcx], 0
-;; 14d40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14d49:	 800100               	add	byte ptr [rcx], 0
-;; 14d4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14d4d:	 800100               	add	byte ptr [rcx], 0
-;; 14d50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14d59:	 800100               	add	byte ptr [rcx], 0
-;; 14d5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14d5d:	 800100               	add	byte ptr [rcx], 0
-;; 14d60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14d69:	 800100               	add	byte ptr [rcx], 0
-;; 14d6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14d6d:	 800100               	add	byte ptr [rcx], 0
-;; 14d70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14d79:	 800100               	add	byte ptr [rcx], 0
-;; 14d7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14d7d:	 800100               	add	byte ptr [rcx], 0
-;; 14d80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14d89:	 800100               	add	byte ptr [rcx], 0
-;; 14d8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14d8d:	 800100               	add	byte ptr [rcx], 0
-;; 14d90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14d99:	 800100               	add	byte ptr [rcx], 0
-;; 14d9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14d9d:	 800100               	add	byte ptr [rcx], 0
-;; 14da0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14da9:	 800100               	add	byte ptr [rcx], 0
-;; 14dac:	 aa                   	stosb	byte ptr [rdi], al
-;; 14dad:	 800100               	add	byte ptr [rcx], 0
-;; 14db0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14db9:	 800100               	add	byte ptr [rcx], 0
-;; 14dbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 14dbd:	 800100               	add	byte ptr [rcx], 0
-;; 14dc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14dc9:	 800100               	add	byte ptr [rcx], 0
-;; 14dcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 14dcd:	 800100               	add	byte ptr [rcx], 0
-;; 14dd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14dd9:	 800100               	add	byte ptr [rcx], 0
-;; 14ddc:	 aa                   	stosb	byte ptr [rdi], al
-;; 14ddd:	 800100               	add	byte ptr [rcx], 0
-;; 14de0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14de9:	 800100               	add	byte ptr [rcx], 0
-;; 14dec:	 aa                   	stosb	byte ptr [rdi], al
-;; 14ded:	 800100               	add	byte ptr [rcx], 0
-;; 14df0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14df9:	 800100               	add	byte ptr [rcx], 0
-;; 14dfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 14dfd:	 800100               	add	byte ptr [rcx], 0
-;; 14e00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14e09:	 800100               	add	byte ptr [rcx], 0
-;; 14e0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14e0d:	 800100               	add	byte ptr [rcx], 0
-;; 14e10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14e19:	 800100               	add	byte ptr [rcx], 0
-;; 14e1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14e1d:	 800100               	add	byte ptr [rcx], 0
-;; 14e20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14e29:	 800100               	add	byte ptr [rcx], 0
-;; 14e2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14e2d:	 800100               	add	byte ptr [rcx], 0
-;; 14e30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14e39:	 800100               	add	byte ptr [rcx], 0
-;; 14e3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14e3d:	 800100               	add	byte ptr [rcx], 0
-;; 14e40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14e49:	 800100               	add	byte ptr [rcx], 0
-;; 14e4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14e4d:	 800100               	add	byte ptr [rcx], 0
-;; 14e50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14e59:	 800100               	add	byte ptr [rcx], 0
-;; 14e5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14e5d:	 800100               	add	byte ptr [rcx], 0
-;; 14e60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14e69:	 800100               	add	byte ptr [rcx], 0
-;; 14e6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14e6d:	 800100               	add	byte ptr [rcx], 0
-;; 14e70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14e79:	 800100               	add	byte ptr [rcx], 0
-;; 14e7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14e7d:	 800100               	add	byte ptr [rcx], 0
-;; 14e80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14e89:	 800100               	add	byte ptr [rcx], 0
-;; 14e8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14e8d:	 800100               	add	byte ptr [rcx], 0
-;; 14e90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14e99:	 800100               	add	byte ptr [rcx], 0
-;; 14e9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14e9d:	 800100               	add	byte ptr [rcx], 0
-;; 14ea0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14ea9:	 800100               	add	byte ptr [rcx], 0
-;; 14eac:	 aa                   	stosb	byte ptr [rdi], al
-;; 14ead:	 800100               	add	byte ptr [rcx], 0
-;; 14eb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14eb9:	 800100               	add	byte ptr [rcx], 0
-;; 14ebc:	 aa                   	stosb	byte ptr [rdi], al
-;; 14ebd:	 800100               	add	byte ptr [rcx], 0
-;; 14ec0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14ec9:	 800100               	add	byte ptr [rcx], 0
-;; 14ecc:	 aa                   	stosb	byte ptr [rdi], al
-;; 14ecd:	 800100               	add	byte ptr [rcx], 0
-;; 14ed0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14ed9:	 800100               	add	byte ptr [rcx], 0
-;; 14edc:	 aa                   	stosb	byte ptr [rdi], al
-;; 14edd:	 800100               	add	byte ptr [rcx], 0
-;; 14ee0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14ee9:	 800100               	add	byte ptr [rcx], 0
-;; 14eec:	 aa                   	stosb	byte ptr [rdi], al
-;; 14eed:	 800100               	add	byte ptr [rcx], 0
-;; 14ef0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14ef9:	 800100               	add	byte ptr [rcx], 0
-;; 14efc:	 aa                   	stosb	byte ptr [rdi], al
-;; 14efd:	 800100               	add	byte ptr [rcx], 0
-;; 14f00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14f09:	 800100               	add	byte ptr [rcx], 0
-;; 14f0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14f0d:	 800100               	add	byte ptr [rcx], 0
-;; 14f10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14f19:	 800100               	add	byte ptr [rcx], 0
-;; 14f1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14f1d:	 800100               	add	byte ptr [rcx], 0
-;; 14f20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14f29:	 800100               	add	byte ptr [rcx], 0
-;; 14f2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14f2d:	 800100               	add	byte ptr [rcx], 0
-;; 14f30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14f39:	 800100               	add	byte ptr [rcx], 0
-;; 14f3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14f3d:	 800100               	add	byte ptr [rcx], 0
-;; 14f40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14f49:	 800100               	add	byte ptr [rcx], 0
-;; 14f4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14f4d:	 800100               	add	byte ptr [rcx], 0
-;; 14f50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14f59:	 800100               	add	byte ptr [rcx], 0
-;; 14f5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14f5d:	 800100               	add	byte ptr [rcx], 0
-;; 14f60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14f69:	 800100               	add	byte ptr [rcx], 0
-;; 14f6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14f6d:	 800100               	add	byte ptr [rcx], 0
-;; 14f70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14f79:	 800100               	add	byte ptr [rcx], 0
-;; 14f7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14f7d:	 800100               	add	byte ptr [rcx], 0
-;; 14f80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14f89:	 800100               	add	byte ptr [rcx], 0
-;; 14f8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14f8d:	 800100               	add	byte ptr [rcx], 0
-;; 14f90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14f99:	 800100               	add	byte ptr [rcx], 0
-;; 14f9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 14f9d:	 800100               	add	byte ptr [rcx], 0
-;; 14fa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14fa9:	 800100               	add	byte ptr [rcx], 0
-;; 14fac:	 aa                   	stosb	byte ptr [rdi], al
-;; 14fad:	 800100               	add	byte ptr [rcx], 0
-;; 14fb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14fb9:	 800100               	add	byte ptr [rcx], 0
-;; 14fbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 14fbd:	 800100               	add	byte ptr [rcx], 0
-;; 14fc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14fc9:	 800100               	add	byte ptr [rcx], 0
-;; 14fcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 14fcd:	 800100               	add	byte ptr [rcx], 0
-;; 14fd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14fd9:	 800100               	add	byte ptr [rcx], 0
-;; 14fdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 14fdd:	 800100               	add	byte ptr [rcx], 0
-;; 14fe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14fe9:	 800100               	add	byte ptr [rcx], 0
-;; 14fec:	 aa                   	stosb	byte ptr [rdi], al
-;; 14fed:	 800100               	add	byte ptr [rcx], 0
-;; 14ff0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 14ff9:	 800100               	add	byte ptr [rcx], 0
-;; 14ffc:	 aa                   	stosb	byte ptr [rdi], al
-;; 14ffd:	 800100               	add	byte ptr [rcx], 0
-;; 15000:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15009:	 800100               	add	byte ptr [rcx], 0
-;; 1500c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1500d:	 800100               	add	byte ptr [rcx], 0
-;; 15010:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15019:	 800100               	add	byte ptr [rcx], 0
-;; 1501c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1501d:	 800100               	add	byte ptr [rcx], 0
-;; 15020:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15029:	 800100               	add	byte ptr [rcx], 0
-;; 1502c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1502d:	 800100               	add	byte ptr [rcx], 0
-;; 15030:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15039:	 800100               	add	byte ptr [rcx], 0
-;; 1503c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1503d:	 800100               	add	byte ptr [rcx], 0
-;; 15040:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15049:	 800100               	add	byte ptr [rcx], 0
-;; 1504c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1504d:	 800100               	add	byte ptr [rcx], 0
-;; 15050:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15059:	 800100               	add	byte ptr [rcx], 0
-;; 1505c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1505d:	 800100               	add	byte ptr [rcx], 0
-;; 15060:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15069:	 800100               	add	byte ptr [rcx], 0
-;; 1506c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1506d:	 800100               	add	byte ptr [rcx], 0
-;; 15070:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15079:	 800100               	add	byte ptr [rcx], 0
-;; 1507c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1507d:	 800100               	add	byte ptr [rcx], 0
-;; 15080:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15089:	 800100               	add	byte ptr [rcx], 0
-;; 1508c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1508d:	 800100               	add	byte ptr [rcx], 0
-;; 15090:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15099:	 800100               	add	byte ptr [rcx], 0
-;; 1509c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1509d:	 800100               	add	byte ptr [rcx], 0
-;; 150a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 150a9:	 800100               	add	byte ptr [rcx], 0
-;; 150ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 150ad:	 800100               	add	byte ptr [rcx], 0
-;; 150b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 150b9:	 800100               	add	byte ptr [rcx], 0
-;; 150bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 150bd:	 800100               	add	byte ptr [rcx], 0
-;; 150c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 150c9:	 800100               	add	byte ptr [rcx], 0
-;; 150cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 150cd:	 800100               	add	byte ptr [rcx], 0
-;; 150d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 150d9:	 800100               	add	byte ptr [rcx], 0
-;; 150dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 150dd:	 800100               	add	byte ptr [rcx], 0
-;; 150e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 150e9:	 800100               	add	byte ptr [rcx], 0
-;; 150ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 150ed:	 800100               	add	byte ptr [rcx], 0
-;; 150f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 150f9:	 800100               	add	byte ptr [rcx], 0
-;; 150fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 150fd:	 800100               	add	byte ptr [rcx], 0
-;; 15100:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15109:	 800100               	add	byte ptr [rcx], 0
-;; 1510c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1510d:	 800100               	add	byte ptr [rcx], 0
-;; 15110:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15119:	 800100               	add	byte ptr [rcx], 0
-;; 1511c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1511d:	 800100               	add	byte ptr [rcx], 0
-;; 15120:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15129:	 800100               	add	byte ptr [rcx], 0
-;; 1512c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1512d:	 800100               	add	byte ptr [rcx], 0
-;; 15130:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15139:	 800100               	add	byte ptr [rcx], 0
-;; 1513c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1513d:	 800100               	add	byte ptr [rcx], 0
-;; 15140:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15149:	 800100               	add	byte ptr [rcx], 0
-;; 1514c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1514d:	 800100               	add	byte ptr [rcx], 0
-;; 15150:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15159:	 800100               	add	byte ptr [rcx], 0
-;; 1515c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1515d:	 800100               	add	byte ptr [rcx], 0
-;; 15160:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15169:	 800100               	add	byte ptr [rcx], 0
-;; 1516c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1516d:	 800100               	add	byte ptr [rcx], 0
-;; 15170:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15179:	 800100               	add	byte ptr [rcx], 0
-;; 1517c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1517d:	 800100               	add	byte ptr [rcx], 0
-;; 15180:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15189:	 800100               	add	byte ptr [rcx], 0
-;; 1518c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1518d:	 800100               	add	byte ptr [rcx], 0
-;; 15190:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15199:	 800100               	add	byte ptr [rcx], 0
-;; 1519c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1519d:	 800100               	add	byte ptr [rcx], 0
-;; 151a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 151a9:	 800100               	add	byte ptr [rcx], 0
-;; 151ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 151ad:	 800100               	add	byte ptr [rcx], 0
-;; 151b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 151b9:	 800100               	add	byte ptr [rcx], 0
-;; 151bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 151bd:	 800100               	add	byte ptr [rcx], 0
-;; 151c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 151c9:	 800100               	add	byte ptr [rcx], 0
-;; 151cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 151cd:	 800100               	add	byte ptr [rcx], 0
-;; 151d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 151d9:	 800100               	add	byte ptr [rcx], 0
-;; 151dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 151dd:	 800100               	add	byte ptr [rcx], 0
-;; 151e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 151e9:	 800100               	add	byte ptr [rcx], 0
-;; 151ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 151ed:	 800100               	add	byte ptr [rcx], 0
-;; 151f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 151f9:	 800100               	add	byte ptr [rcx], 0
-;; 151fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 151fd:	 800100               	add	byte ptr [rcx], 0
-;; 15200:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15209:	 800100               	add	byte ptr [rcx], 0
-;; 1520c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1520d:	 800100               	add	byte ptr [rcx], 0
-;; 15210:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15219:	 800100               	add	byte ptr [rcx], 0
-;; 1521c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1521d:	 800100               	add	byte ptr [rcx], 0
-;; 15220:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15229:	 800100               	add	byte ptr [rcx], 0
-;; 1522c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1522d:	 800100               	add	byte ptr [rcx], 0
-;; 15230:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15239:	 800100               	add	byte ptr [rcx], 0
-;; 1523c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1523d:	 800100               	add	byte ptr [rcx], 0
-;; 15240:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15249:	 800100               	add	byte ptr [rcx], 0
-;; 1524c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1524d:	 800100               	add	byte ptr [rcx], 0
-;; 15250:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15259:	 800100               	add	byte ptr [rcx], 0
-;; 1525c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1525d:	 800100               	add	byte ptr [rcx], 0
-;; 15260:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15269:	 800100               	add	byte ptr [rcx], 0
-;; 1526c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1526d:	 800100               	add	byte ptr [rcx], 0
-;; 15270:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15279:	 800100               	add	byte ptr [rcx], 0
-;; 1527c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1527d:	 800100               	add	byte ptr [rcx], 0
-;; 15280:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15289:	 800100               	add	byte ptr [rcx], 0
-;; 1528c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1528d:	 800100               	add	byte ptr [rcx], 0
-;; 15290:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15299:	 800100               	add	byte ptr [rcx], 0
-;; 1529c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1529d:	 800100               	add	byte ptr [rcx], 0
-;; 152a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 152a9:	 800100               	add	byte ptr [rcx], 0
-;; 152ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 152ad:	 800100               	add	byte ptr [rcx], 0
-;; 152b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 152b9:	 800100               	add	byte ptr [rcx], 0
-;; 152bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 152bd:	 800100               	add	byte ptr [rcx], 0
-;; 152c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 152c9:	 800100               	add	byte ptr [rcx], 0
-;; 152cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 152cd:	 800100               	add	byte ptr [rcx], 0
-;; 152d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 152d9:	 800100               	add	byte ptr [rcx], 0
-;; 152dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 152dd:	 800100               	add	byte ptr [rcx], 0
-;; 152e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 152e9:	 800100               	add	byte ptr [rcx], 0
-;; 152ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 152ed:	 800100               	add	byte ptr [rcx], 0
-;; 152f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 152f9:	 800100               	add	byte ptr [rcx], 0
-;; 152fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 152fd:	 800100               	add	byte ptr [rcx], 0
-;; 15300:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15309:	 800100               	add	byte ptr [rcx], 0
-;; 1530c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1530d:	 800100               	add	byte ptr [rcx], 0
-;; 15310:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15319:	 800100               	add	byte ptr [rcx], 0
-;; 1531c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1531d:	 800100               	add	byte ptr [rcx], 0
-;; 15320:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15329:	 800100               	add	byte ptr [rcx], 0
-;; 1532c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1532d:	 800100               	add	byte ptr [rcx], 0
-;; 15330:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15339:	 800100               	add	byte ptr [rcx], 0
-;; 1533c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1533d:	 800100               	add	byte ptr [rcx], 0
-;; 15340:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15349:	 800100               	add	byte ptr [rcx], 0
-;; 1534c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1534d:	 800100               	add	byte ptr [rcx], 0
-;; 15350:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15359:	 800100               	add	byte ptr [rcx], 0
-;; 1535c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1535d:	 800100               	add	byte ptr [rcx], 0
-;; 15360:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15369:	 800100               	add	byte ptr [rcx], 0
-;; 1536c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1536d:	 800100               	add	byte ptr [rcx], 0
-;; 15370:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15379:	 800100               	add	byte ptr [rcx], 0
-;; 1537c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1537d:	 800100               	add	byte ptr [rcx], 0
-;; 15380:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15389:	 800100               	add	byte ptr [rcx], 0
-;; 1538c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1538d:	 800100               	add	byte ptr [rcx], 0
-;; 15390:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15399:	 800100               	add	byte ptr [rcx], 0
-;; 1539c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1539d:	 800100               	add	byte ptr [rcx], 0
-;; 153a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 153a9:	 800100               	add	byte ptr [rcx], 0
-;; 153ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 153ad:	 800100               	add	byte ptr [rcx], 0
-;; 153b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 153b9:	 800100               	add	byte ptr [rcx], 0
-;; 153bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 153bd:	 800100               	add	byte ptr [rcx], 0
-;; 153c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 153c9:	 800100               	add	byte ptr [rcx], 0
-;; 153cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 153cd:	 800100               	add	byte ptr [rcx], 0
-;; 153d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 153d9:	 800100               	add	byte ptr [rcx], 0
-;; 153dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 153dd:	 800100               	add	byte ptr [rcx], 0
-;; 153e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 153e9:	 800100               	add	byte ptr [rcx], 0
-;; 153ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 153ed:	 800100               	add	byte ptr [rcx], 0
-;; 153f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 153f9:	 800100               	add	byte ptr [rcx], 0
-;; 153fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 153fd:	 800100               	add	byte ptr [rcx], 0
-;; 15400:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15409:	 800100               	add	byte ptr [rcx], 0
-;; 1540c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1540d:	 800100               	add	byte ptr [rcx], 0
-;; 15410:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15419:	 800100               	add	byte ptr [rcx], 0
-;; 1541c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1541d:	 800100               	add	byte ptr [rcx], 0
-;; 15420:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15429:	 800100               	add	byte ptr [rcx], 0
-;; 1542c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1542d:	 800100               	add	byte ptr [rcx], 0
-;; 15430:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15439:	 800100               	add	byte ptr [rcx], 0
-;; 1543c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1543d:	 800100               	add	byte ptr [rcx], 0
-;; 15440:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15449:	 800100               	add	byte ptr [rcx], 0
-;; 1544c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1544d:	 800100               	add	byte ptr [rcx], 0
-;; 15450:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15459:	 800100               	add	byte ptr [rcx], 0
-;; 1545c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1545d:	 800100               	add	byte ptr [rcx], 0
-;; 15460:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15469:	 800100               	add	byte ptr [rcx], 0
-;; 1546c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1546d:	 800100               	add	byte ptr [rcx], 0
-;; 15470:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15479:	 800100               	add	byte ptr [rcx], 0
-;; 1547c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1547d:	 800100               	add	byte ptr [rcx], 0
-;; 15480:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15489:	 800100               	add	byte ptr [rcx], 0
-;; 1548c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1548d:	 800100               	add	byte ptr [rcx], 0
-;; 15490:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15499:	 800100               	add	byte ptr [rcx], 0
-;; 1549c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1549d:	 800100               	add	byte ptr [rcx], 0
-;; 154a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 154a9:	 800100               	add	byte ptr [rcx], 0
-;; 154ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 154ad:	 800100               	add	byte ptr [rcx], 0
-;; 154b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 154b9:	 800100               	add	byte ptr [rcx], 0
-;; 154bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 154bd:	 800100               	add	byte ptr [rcx], 0
-;; 154c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 154c9:	 800100               	add	byte ptr [rcx], 0
-;; 154cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 154cd:	 800100               	add	byte ptr [rcx], 0
-;; 154d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 154d9:	 800100               	add	byte ptr [rcx], 0
-;; 154dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 154dd:	 800100               	add	byte ptr [rcx], 0
-;; 154e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 154e9:	 800100               	add	byte ptr [rcx], 0
-;; 154ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 154ed:	 800100               	add	byte ptr [rcx], 0
-;; 154f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 154f9:	 800100               	add	byte ptr [rcx], 0
-;; 154fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 154fd:	 800100               	add	byte ptr [rcx], 0
-;; 15500:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15509:	 800100               	add	byte ptr [rcx], 0
-;; 1550c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1550d:	 800100               	add	byte ptr [rcx], 0
-;; 15510:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15519:	 800100               	add	byte ptr [rcx], 0
-;; 1551c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1551d:	 800100               	add	byte ptr [rcx], 0
-;; 15520:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15529:	 800100               	add	byte ptr [rcx], 0
-;; 1552c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1552d:	 800100               	add	byte ptr [rcx], 0
-;; 15530:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15539:	 800100               	add	byte ptr [rcx], 0
-;; 1553c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1553d:	 800100               	add	byte ptr [rcx], 0
-;; 15540:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15549:	 800100               	add	byte ptr [rcx], 0
-;; 1554c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1554d:	 800100               	add	byte ptr [rcx], 0
-;; 15550:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15559:	 800100               	add	byte ptr [rcx], 0
-;; 1555c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1555d:	 800100               	add	byte ptr [rcx], 0
-;; 15560:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15569:	 800100               	add	byte ptr [rcx], 0
-;; 1556c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1556d:	 800100               	add	byte ptr [rcx], 0
-;; 15570:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15579:	 800100               	add	byte ptr [rcx], 0
-;; 1557c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1557d:	 800100               	add	byte ptr [rcx], 0
-;; 15580:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15589:	 800100               	add	byte ptr [rcx], 0
-;; 1558c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1558d:	 800100               	add	byte ptr [rcx], 0
-;; 15590:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15599:	 800100               	add	byte ptr [rcx], 0
-;; 1559c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1559d:	 800100               	add	byte ptr [rcx], 0
-;; 155a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 155a9:	 800100               	add	byte ptr [rcx], 0
-;; 155ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 155ad:	 800100               	add	byte ptr [rcx], 0
-;; 155b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 155b9:	 800100               	add	byte ptr [rcx], 0
-;; 155bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 155bd:	 800100               	add	byte ptr [rcx], 0
-;; 155c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 155c9:	 800100               	add	byte ptr [rcx], 0
-;; 155cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 155cd:	 800100               	add	byte ptr [rcx], 0
-;; 155d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 155d9:	 800100               	add	byte ptr [rcx], 0
-;; 155dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 155dd:	 800100               	add	byte ptr [rcx], 0
-;; 155e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 155e9:	 800100               	add	byte ptr [rcx], 0
-;; 155ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 155ed:	 800100               	add	byte ptr [rcx], 0
-;; 155f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 155f9:	 800100               	add	byte ptr [rcx], 0
-;; 155fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 155fd:	 800100               	add	byte ptr [rcx], 0
-;; 15600:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15609:	 800100               	add	byte ptr [rcx], 0
-;; 1560c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1560d:	 800100               	add	byte ptr [rcx], 0
-;; 15610:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15619:	 800100               	add	byte ptr [rcx], 0
-;; 1561c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1561d:	 800100               	add	byte ptr [rcx], 0
-;; 15620:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15629:	 800100               	add	byte ptr [rcx], 0
-;; 1562c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1562d:	 800100               	add	byte ptr [rcx], 0
-;; 15630:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15639:	 800100               	add	byte ptr [rcx], 0
-;; 1563c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1563d:	 800100               	add	byte ptr [rcx], 0
-;; 15640:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15649:	 800100               	add	byte ptr [rcx], 0
-;; 1564c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1564d:	 800100               	add	byte ptr [rcx], 0
-;; 15650:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15659:	 800100               	add	byte ptr [rcx], 0
-;; 1565c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1565d:	 800100               	add	byte ptr [rcx], 0
-;; 15660:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15669:	 800100               	add	byte ptr [rcx], 0
-;; 1566c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1566d:	 800100               	add	byte ptr [rcx], 0
-;; 15670:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15679:	 800100               	add	byte ptr [rcx], 0
-;; 1567c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1567d:	 800100               	add	byte ptr [rcx], 0
-;; 15680:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15689:	 800100               	add	byte ptr [rcx], 0
-;; 1568c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1568d:	 800100               	add	byte ptr [rcx], 0
-;; 15690:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15699:	 800100               	add	byte ptr [rcx], 0
-;; 1569c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1569d:	 800100               	add	byte ptr [rcx], 0
-;; 156a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 156a9:	 800100               	add	byte ptr [rcx], 0
-;; 156ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 156ad:	 800100               	add	byte ptr [rcx], 0
-;; 156b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 156b9:	 800100               	add	byte ptr [rcx], 0
-;; 156bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 156bd:	 800100               	add	byte ptr [rcx], 0
-;; 156c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 156c9:	 800100               	add	byte ptr [rcx], 0
-;; 156cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 156cd:	 800100               	add	byte ptr [rcx], 0
-;; 156d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 156d9:	 800100               	add	byte ptr [rcx], 0
-;; 156dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 156dd:	 800100               	add	byte ptr [rcx], 0
-;; 156e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 156e9:	 800100               	add	byte ptr [rcx], 0
-;; 156ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 156ed:	 800100               	add	byte ptr [rcx], 0
-;; 156f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 156f9:	 800100               	add	byte ptr [rcx], 0
-;; 156fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 156fd:	 800100               	add	byte ptr [rcx], 0
-;; 15700:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15709:	 800100               	add	byte ptr [rcx], 0
-;; 1570c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1570d:	 800100               	add	byte ptr [rcx], 0
-;; 15710:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15719:	 800100               	add	byte ptr [rcx], 0
-;; 1571c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1571d:	 800100               	add	byte ptr [rcx], 0
-;; 15720:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15729:	 800100               	add	byte ptr [rcx], 0
-;; 1572c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1572d:	 800100               	add	byte ptr [rcx], 0
-;; 15730:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15739:	 800100               	add	byte ptr [rcx], 0
-;; 1573c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1573d:	 800100               	add	byte ptr [rcx], 0
-;; 15740:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15749:	 800100               	add	byte ptr [rcx], 0
-;; 1574c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1574d:	 800100               	add	byte ptr [rcx], 0
-;; 15750:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15759:	 800100               	add	byte ptr [rcx], 0
-;; 1575c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1575d:	 800100               	add	byte ptr [rcx], 0
-;; 15760:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15769:	 800100               	add	byte ptr [rcx], 0
-;; 1576c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1576d:	 800100               	add	byte ptr [rcx], 0
-;; 15770:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15779:	 800100               	add	byte ptr [rcx], 0
-;; 1577c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1577d:	 800100               	add	byte ptr [rcx], 0
-;; 15780:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15789:	 800100               	add	byte ptr [rcx], 0
-;; 1578c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1578d:	 800100               	add	byte ptr [rcx], 0
-;; 15790:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15799:	 800100               	add	byte ptr [rcx], 0
-;; 1579c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1579d:	 800100               	add	byte ptr [rcx], 0
-;; 157a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 157a9:	 800100               	add	byte ptr [rcx], 0
-;; 157ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 157ad:	 800100               	add	byte ptr [rcx], 0
-;; 157b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 157b9:	 800100               	add	byte ptr [rcx], 0
-;; 157bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 157bd:	 800100               	add	byte ptr [rcx], 0
-;; 157c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 157c9:	 800100               	add	byte ptr [rcx], 0
-;; 157cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 157cd:	 800100               	add	byte ptr [rcx], 0
-;; 157d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 157d9:	 800100               	add	byte ptr [rcx], 0
-;; 157dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 157dd:	 800100               	add	byte ptr [rcx], 0
-;; 157e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 157e9:	 800100               	add	byte ptr [rcx], 0
-;; 157ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 157ed:	 800100               	add	byte ptr [rcx], 0
-;; 157f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 157f9:	 800100               	add	byte ptr [rcx], 0
-;; 157fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 157fd:	 800100               	add	byte ptr [rcx], 0
-;; 15800:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15809:	 800100               	add	byte ptr [rcx], 0
-;; 1580c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1580d:	 800100               	add	byte ptr [rcx], 0
-;; 15810:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15819:	 800100               	add	byte ptr [rcx], 0
-;; 1581c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1581d:	 800100               	add	byte ptr [rcx], 0
-;; 15820:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15829:	 800100               	add	byte ptr [rcx], 0
-;; 1582c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1582d:	 800100               	add	byte ptr [rcx], 0
-;; 15830:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15839:	 800100               	add	byte ptr [rcx], 0
-;; 1583c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1583d:	 800100               	add	byte ptr [rcx], 0
-;; 15840:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15849:	 800100               	add	byte ptr [rcx], 0
-;; 1584c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1584d:	 800100               	add	byte ptr [rcx], 0
-;; 15850:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15859:	 800100               	add	byte ptr [rcx], 0
-;; 1585c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1585d:	 800100               	add	byte ptr [rcx], 0
-;; 15860:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15869:	 800100               	add	byte ptr [rcx], 0
-;; 1586c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1586d:	 800100               	add	byte ptr [rcx], 0
-;; 15870:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15879:	 800100               	add	byte ptr [rcx], 0
-;; 1587c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1587d:	 800100               	add	byte ptr [rcx], 0
-;; 15880:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15889:	 800100               	add	byte ptr [rcx], 0
-;; 1588c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1588d:	 800100               	add	byte ptr [rcx], 0
-;; 15890:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15899:	 800100               	add	byte ptr [rcx], 0
-;; 1589c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1589d:	 800100               	add	byte ptr [rcx], 0
-;; 158a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 158a9:	 800100               	add	byte ptr [rcx], 0
-;; 158ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 158ad:	 800100               	add	byte ptr [rcx], 0
-;; 158b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 158b9:	 800100               	add	byte ptr [rcx], 0
-;; 158bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 158bd:	 800100               	add	byte ptr [rcx], 0
-;; 158c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 158c9:	 800100               	add	byte ptr [rcx], 0
-;; 158cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 158cd:	 800100               	add	byte ptr [rcx], 0
-;; 158d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 158d9:	 800100               	add	byte ptr [rcx], 0
-;; 158dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 158dd:	 800100               	add	byte ptr [rcx], 0
-;; 158e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 158e9:	 800100               	add	byte ptr [rcx], 0
-;; 158ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 158ed:	 800100               	add	byte ptr [rcx], 0
-;; 158f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 158f9:	 800100               	add	byte ptr [rcx], 0
-;; 158fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 158fd:	 800100               	add	byte ptr [rcx], 0
-;; 15900:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15909:	 800100               	add	byte ptr [rcx], 0
-;; 1590c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1590d:	 800100               	add	byte ptr [rcx], 0
-;; 15910:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15919:	 800100               	add	byte ptr [rcx], 0
-;; 1591c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1591d:	 800100               	add	byte ptr [rcx], 0
-;; 15920:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15929:	 800100               	add	byte ptr [rcx], 0
-;; 1592c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1592d:	 800100               	add	byte ptr [rcx], 0
-;; 15930:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15939:	 800100               	add	byte ptr [rcx], 0
-;; 1593c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1593d:	 800100               	add	byte ptr [rcx], 0
-;; 15940:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15949:	 800100               	add	byte ptr [rcx], 0
-;; 1594c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1594d:	 800100               	add	byte ptr [rcx], 0
-;; 15950:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15959:	 800100               	add	byte ptr [rcx], 0
-;; 1595c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1595d:	 800100               	add	byte ptr [rcx], 0
-;; 15960:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15969:	 800100               	add	byte ptr [rcx], 0
-;; 1596c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1596d:	 800100               	add	byte ptr [rcx], 0
-;; 15970:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15979:	 800100               	add	byte ptr [rcx], 0
-;; 1597c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1597d:	 800100               	add	byte ptr [rcx], 0
-;; 15980:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15989:	 800100               	add	byte ptr [rcx], 0
-;; 1598c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1598d:	 800100               	add	byte ptr [rcx], 0
-;; 15990:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15999:	 800100               	add	byte ptr [rcx], 0
-;; 1599c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1599d:	 800100               	add	byte ptr [rcx], 0
-;; 159a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 159a9:	 800100               	add	byte ptr [rcx], 0
-;; 159ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 159ad:	 800100               	add	byte ptr [rcx], 0
-;; 159b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 159b9:	 800100               	add	byte ptr [rcx], 0
-;; 159bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 159bd:	 800100               	add	byte ptr [rcx], 0
-;; 159c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 159c9:	 800100               	add	byte ptr [rcx], 0
-;; 159cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 159cd:	 800100               	add	byte ptr [rcx], 0
-;; 159d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 159d9:	 800100               	add	byte ptr [rcx], 0
-;; 159dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 159dd:	 800100               	add	byte ptr [rcx], 0
-;; 159e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 159e9:	 800100               	add	byte ptr [rcx], 0
-;; 159ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 159ed:	 800100               	add	byte ptr [rcx], 0
-;; 159f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 159f9:	 800100               	add	byte ptr [rcx], 0
-;; 159fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 159fd:	 800100               	add	byte ptr [rcx], 0
-;; 15a00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15a09:	 800100               	add	byte ptr [rcx], 0
-;; 15a0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15a0d:	 800100               	add	byte ptr [rcx], 0
-;; 15a10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15a19:	 800100               	add	byte ptr [rcx], 0
-;; 15a1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15a1d:	 800100               	add	byte ptr [rcx], 0
-;; 15a20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15a29:	 800100               	add	byte ptr [rcx], 0
-;; 15a2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15a2d:	 800100               	add	byte ptr [rcx], 0
-;; 15a30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15a39:	 800100               	add	byte ptr [rcx], 0
-;; 15a3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15a3d:	 800100               	add	byte ptr [rcx], 0
-;; 15a40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15a49:	 800100               	add	byte ptr [rcx], 0
-;; 15a4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15a4d:	 800100               	add	byte ptr [rcx], 0
-;; 15a50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15a59:	 800100               	add	byte ptr [rcx], 0
-;; 15a5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15a5d:	 800100               	add	byte ptr [rcx], 0
-;; 15a60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15a69:	 800100               	add	byte ptr [rcx], 0
-;; 15a6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15a6d:	 800100               	add	byte ptr [rcx], 0
-;; 15a70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15a79:	 800100               	add	byte ptr [rcx], 0
-;; 15a7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15a7d:	 800100               	add	byte ptr [rcx], 0
-;; 15a80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15a89:	 800100               	add	byte ptr [rcx], 0
-;; 15a8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15a8d:	 800100               	add	byte ptr [rcx], 0
-;; 15a90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15a99:	 800100               	add	byte ptr [rcx], 0
-;; 15a9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15a9d:	 800100               	add	byte ptr [rcx], 0
-;; 15aa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15aa9:	 800100               	add	byte ptr [rcx], 0
-;; 15aac:	 aa                   	stosb	byte ptr [rdi], al
-;; 15aad:	 800100               	add	byte ptr [rcx], 0
-;; 15ab0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15ab9:	 800100               	add	byte ptr [rcx], 0
-;; 15abc:	 aa                   	stosb	byte ptr [rdi], al
-;; 15abd:	 800100               	add	byte ptr [rcx], 0
-;; 15ac0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15ac9:	 800100               	add	byte ptr [rcx], 0
-;; 15acc:	 aa                   	stosb	byte ptr [rdi], al
-;; 15acd:	 800100               	add	byte ptr [rcx], 0
-;; 15ad0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15ad9:	 800100               	add	byte ptr [rcx], 0
-;; 15adc:	 aa                   	stosb	byte ptr [rdi], al
-;; 15add:	 800100               	add	byte ptr [rcx], 0
-;; 15ae0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15ae9:	 800100               	add	byte ptr [rcx], 0
-;; 15aec:	 aa                   	stosb	byte ptr [rdi], al
-;; 15aed:	 800100               	add	byte ptr [rcx], 0
-;; 15af0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15af9:	 800100               	add	byte ptr [rcx], 0
-;; 15afc:	 aa                   	stosb	byte ptr [rdi], al
-;; 15afd:	 800100               	add	byte ptr [rcx], 0
-;; 15b00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15b09:	 800100               	add	byte ptr [rcx], 0
-;; 15b0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15b0d:	 800100               	add	byte ptr [rcx], 0
-;; 15b10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15b19:	 800100               	add	byte ptr [rcx], 0
-;; 15b1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15b1d:	 800100               	add	byte ptr [rcx], 0
-;; 15b20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15b29:	 800100               	add	byte ptr [rcx], 0
-;; 15b2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15b2d:	 800100               	add	byte ptr [rcx], 0
-;; 15b30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15b39:	 800100               	add	byte ptr [rcx], 0
-;; 15b3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15b3d:	 800100               	add	byte ptr [rcx], 0
-;; 15b40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15b49:	 800100               	add	byte ptr [rcx], 0
-;; 15b4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15b4d:	 800100               	add	byte ptr [rcx], 0
-;; 15b50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15b59:	 800100               	add	byte ptr [rcx], 0
-;; 15b5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15b5d:	 800100               	add	byte ptr [rcx], 0
-;; 15b60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15b69:	 800100               	add	byte ptr [rcx], 0
-;; 15b6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15b6d:	 800100               	add	byte ptr [rcx], 0
-;; 15b70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15b79:	 800100               	add	byte ptr [rcx], 0
-;; 15b7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15b7d:	 800100               	add	byte ptr [rcx], 0
-;; 15b80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15b89:	 800100               	add	byte ptr [rcx], 0
-;; 15b8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15b8d:	 800100               	add	byte ptr [rcx], 0
-;; 15b90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15b99:	 800100               	add	byte ptr [rcx], 0
-;; 15b9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15b9d:	 800100               	add	byte ptr [rcx], 0
-;; 15ba0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15ba9:	 800100               	add	byte ptr [rcx], 0
-;; 15bac:	 aa                   	stosb	byte ptr [rdi], al
-;; 15bad:	 800100               	add	byte ptr [rcx], 0
-;; 15bb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15bb9:	 800100               	add	byte ptr [rcx], 0
-;; 15bbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 15bbd:	 800100               	add	byte ptr [rcx], 0
-;; 15bc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15bc9:	 800100               	add	byte ptr [rcx], 0
-;; 15bcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 15bcd:	 800100               	add	byte ptr [rcx], 0
-;; 15bd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15bd9:	 800100               	add	byte ptr [rcx], 0
-;; 15bdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 15bdd:	 800100               	add	byte ptr [rcx], 0
-;; 15be0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15be9:	 800100               	add	byte ptr [rcx], 0
-;; 15bec:	 aa                   	stosb	byte ptr [rdi], al
-;; 15bed:	 800100               	add	byte ptr [rcx], 0
-;; 15bf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15bf9:	 800100               	add	byte ptr [rcx], 0
-;; 15bfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 15bfd:	 800100               	add	byte ptr [rcx], 0
-;; 15c00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15c09:	 800100               	add	byte ptr [rcx], 0
-;; 15c0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15c0d:	 800100               	add	byte ptr [rcx], 0
-;; 15c10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15c19:	 800100               	add	byte ptr [rcx], 0
-;; 15c1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15c1d:	 800100               	add	byte ptr [rcx], 0
-;; 15c20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15c29:	 800100               	add	byte ptr [rcx], 0
-;; 15c2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15c2d:	 800100               	add	byte ptr [rcx], 0
-;; 15c30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15c39:	 800100               	add	byte ptr [rcx], 0
-;; 15c3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15c3d:	 800100               	add	byte ptr [rcx], 0
-;; 15c40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15c49:	 800100               	add	byte ptr [rcx], 0
-;; 15c4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15c4d:	 800100               	add	byte ptr [rcx], 0
-;; 15c50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15c59:	 800100               	add	byte ptr [rcx], 0
-;; 15c5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15c5d:	 800100               	add	byte ptr [rcx], 0
-;; 15c60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15c69:	 800100               	add	byte ptr [rcx], 0
-;; 15c6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15c6d:	 800100               	add	byte ptr [rcx], 0
-;; 15c70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15c79:	 800100               	add	byte ptr [rcx], 0
-;; 15c7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15c7d:	 800100               	add	byte ptr [rcx], 0
-;; 15c80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15c89:	 800100               	add	byte ptr [rcx], 0
-;; 15c8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15c8d:	 800100               	add	byte ptr [rcx], 0
-;; 15c90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15c99:	 800100               	add	byte ptr [rcx], 0
-;; 15c9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15c9d:	 800100               	add	byte ptr [rcx], 0
-;; 15ca0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15ca9:	 800100               	add	byte ptr [rcx], 0
-;; 15cac:	 aa                   	stosb	byte ptr [rdi], al
-;; 15cad:	 800100               	add	byte ptr [rcx], 0
-;; 15cb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15cb9:	 800100               	add	byte ptr [rcx], 0
-;; 15cbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 15cbd:	 800100               	add	byte ptr [rcx], 0
-;; 15cc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15cc9:	 800100               	add	byte ptr [rcx], 0
-;; 15ccc:	 aa                   	stosb	byte ptr [rdi], al
-;; 15ccd:	 800100               	add	byte ptr [rcx], 0
-;; 15cd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15cd9:	 800100               	add	byte ptr [rcx], 0
-;; 15cdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 15cdd:	 800100               	add	byte ptr [rcx], 0
-;; 15ce0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15ce9:	 800100               	add	byte ptr [rcx], 0
-;; 15cec:	 aa                   	stosb	byte ptr [rdi], al
-;; 15ced:	 800100               	add	byte ptr [rcx], 0
-;; 15cf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15cf9:	 800100               	add	byte ptr [rcx], 0
-;; 15cfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 15cfd:	 800100               	add	byte ptr [rcx], 0
-;; 15d00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15d09:	 800100               	add	byte ptr [rcx], 0
-;; 15d0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15d0d:	 800100               	add	byte ptr [rcx], 0
-;; 15d10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15d19:	 800100               	add	byte ptr [rcx], 0
-;; 15d1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15d1d:	 800100               	add	byte ptr [rcx], 0
-;; 15d20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15d29:	 800100               	add	byte ptr [rcx], 0
-;; 15d2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15d2d:	 800100               	add	byte ptr [rcx], 0
-;; 15d30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15d39:	 800100               	add	byte ptr [rcx], 0
-;; 15d3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15d3d:	 800100               	add	byte ptr [rcx], 0
-;; 15d40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15d49:	 800100               	add	byte ptr [rcx], 0
-;; 15d4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15d4d:	 800100               	add	byte ptr [rcx], 0
-;; 15d50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15d59:	 800100               	add	byte ptr [rcx], 0
-;; 15d5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15d5d:	 800100               	add	byte ptr [rcx], 0
-;; 15d60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15d69:	 800100               	add	byte ptr [rcx], 0
-;; 15d6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15d6d:	 800100               	add	byte ptr [rcx], 0
-;; 15d70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15d79:	 800100               	add	byte ptr [rcx], 0
-;; 15d7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15d7d:	 800100               	add	byte ptr [rcx], 0
-;; 15d80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15d89:	 800100               	add	byte ptr [rcx], 0
-;; 15d8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15d8d:	 800100               	add	byte ptr [rcx], 0
-;; 15d90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15d99:	 800100               	add	byte ptr [rcx], 0
-;; 15d9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15d9d:	 800100               	add	byte ptr [rcx], 0
-;; 15da0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15da9:	 800100               	add	byte ptr [rcx], 0
-;; 15dac:	 aa                   	stosb	byte ptr [rdi], al
-;; 15dad:	 800100               	add	byte ptr [rcx], 0
-;; 15db0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15db9:	 800100               	add	byte ptr [rcx], 0
-;; 15dbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 15dbd:	 800100               	add	byte ptr [rcx], 0
-;; 15dc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15dc9:	 800100               	add	byte ptr [rcx], 0
-;; 15dcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 15dcd:	 800100               	add	byte ptr [rcx], 0
-;; 15dd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15dd9:	 800100               	add	byte ptr [rcx], 0
-;; 15ddc:	 aa                   	stosb	byte ptr [rdi], al
-;; 15ddd:	 800100               	add	byte ptr [rcx], 0
-;; 15de0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15de9:	 800100               	add	byte ptr [rcx], 0
-;; 15dec:	 aa                   	stosb	byte ptr [rdi], al
-;; 15ded:	 800100               	add	byte ptr [rcx], 0
-;; 15df0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15df9:	 800100               	add	byte ptr [rcx], 0
-;; 15dfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 15dfd:	 800100               	add	byte ptr [rcx], 0
-;; 15e00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15e09:	 800100               	add	byte ptr [rcx], 0
-;; 15e0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15e0d:	 800100               	add	byte ptr [rcx], 0
-;; 15e10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15e19:	 800100               	add	byte ptr [rcx], 0
-;; 15e1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15e1d:	 800100               	add	byte ptr [rcx], 0
-;; 15e20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15e29:	 800100               	add	byte ptr [rcx], 0
-;; 15e2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15e2d:	 800100               	add	byte ptr [rcx], 0
-;; 15e30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15e39:	 800100               	add	byte ptr [rcx], 0
-;; 15e3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15e3d:	 800100               	add	byte ptr [rcx], 0
-;; 15e40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15e49:	 800100               	add	byte ptr [rcx], 0
-;; 15e4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15e4d:	 800100               	add	byte ptr [rcx], 0
-;; 15e50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15e59:	 800100               	add	byte ptr [rcx], 0
-;; 15e5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15e5d:	 800100               	add	byte ptr [rcx], 0
-;; 15e60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15e69:	 800100               	add	byte ptr [rcx], 0
-;; 15e6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15e6d:	 800100               	add	byte ptr [rcx], 0
-;; 15e70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15e79:	 800100               	add	byte ptr [rcx], 0
-;; 15e7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15e7d:	 800100               	add	byte ptr [rcx], 0
-;; 15e80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15e89:	 800100               	add	byte ptr [rcx], 0
-;; 15e8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15e8d:	 800100               	add	byte ptr [rcx], 0
-;; 15e90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15e99:	 800100               	add	byte ptr [rcx], 0
-;; 15e9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15e9d:	 800100               	add	byte ptr [rcx], 0
-;; 15ea0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15ea9:	 800100               	add	byte ptr [rcx], 0
-;; 15eac:	 aa                   	stosb	byte ptr [rdi], al
-;; 15ead:	 800100               	add	byte ptr [rcx], 0
-;; 15eb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15eb9:	 800100               	add	byte ptr [rcx], 0
-;; 15ebc:	 aa                   	stosb	byte ptr [rdi], al
-;; 15ebd:	 800100               	add	byte ptr [rcx], 0
-;; 15ec0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15ec9:	 800100               	add	byte ptr [rcx], 0
-;; 15ecc:	 aa                   	stosb	byte ptr [rdi], al
-;; 15ecd:	 800100               	add	byte ptr [rcx], 0
-;; 15ed0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15ed9:	 800100               	add	byte ptr [rcx], 0
-;; 15edc:	 aa                   	stosb	byte ptr [rdi], al
-;; 15edd:	 800100               	add	byte ptr [rcx], 0
-;; 15ee0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15ee9:	 800100               	add	byte ptr [rcx], 0
-;; 15eec:	 aa                   	stosb	byte ptr [rdi], al
-;; 15eed:	 800100               	add	byte ptr [rcx], 0
-;; 15ef0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15ef9:	 800100               	add	byte ptr [rcx], 0
-;; 15efc:	 aa                   	stosb	byte ptr [rdi], al
-;; 15efd:	 800100               	add	byte ptr [rcx], 0
-;; 15f00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15f09:	 800100               	add	byte ptr [rcx], 0
-;; 15f0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15f0d:	 800100               	add	byte ptr [rcx], 0
-;; 15f10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15f19:	 800100               	add	byte ptr [rcx], 0
-;; 15f1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15f1d:	 800100               	add	byte ptr [rcx], 0
-;; 15f20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15f29:	 800100               	add	byte ptr [rcx], 0
-;; 15f2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15f2d:	 800100               	add	byte ptr [rcx], 0
-;; 15f30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15f39:	 800100               	add	byte ptr [rcx], 0
-;; 15f3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15f3d:	 800100               	add	byte ptr [rcx], 0
-;; 15f40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15f49:	 800100               	add	byte ptr [rcx], 0
-;; 15f4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15f4d:	 800100               	add	byte ptr [rcx], 0
-;; 15f50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15f59:	 800100               	add	byte ptr [rcx], 0
-;; 15f5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15f5d:	 800100               	add	byte ptr [rcx], 0
-;; 15f60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15f69:	 800100               	add	byte ptr [rcx], 0
-;; 15f6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15f6d:	 800100               	add	byte ptr [rcx], 0
-;; 15f70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15f79:	 800100               	add	byte ptr [rcx], 0
-;; 15f7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15f7d:	 800100               	add	byte ptr [rcx], 0
-;; 15f80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15f89:	 800100               	add	byte ptr [rcx], 0
-;; 15f8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15f8d:	 800100               	add	byte ptr [rcx], 0
-;; 15f90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15f99:	 800100               	add	byte ptr [rcx], 0
-;; 15f9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 15f9d:	 800100               	add	byte ptr [rcx], 0
-;; 15fa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15fa9:	 800100               	add	byte ptr [rcx], 0
-;; 15fac:	 aa                   	stosb	byte ptr [rdi], al
-;; 15fad:	 800100               	add	byte ptr [rcx], 0
-;; 15fb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15fb9:	 800100               	add	byte ptr [rcx], 0
-;; 15fbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 15fbd:	 800100               	add	byte ptr [rcx], 0
-;; 15fc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15fc9:	 800100               	add	byte ptr [rcx], 0
-;; 15fcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 15fcd:	 800100               	add	byte ptr [rcx], 0
-;; 15fd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15fd9:	 800100               	add	byte ptr [rcx], 0
-;; 15fdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 15fdd:	 800100               	add	byte ptr [rcx], 0
-;; 15fe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15fe9:	 800100               	add	byte ptr [rcx], 0
-;; 15fec:	 aa                   	stosb	byte ptr [rdi], al
-;; 15fed:	 800100               	add	byte ptr [rcx], 0
-;; 15ff0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 15ff9:	 800100               	add	byte ptr [rcx], 0
-;; 15ffc:	 aa                   	stosb	byte ptr [rdi], al
-;; 15ffd:	 800100               	add	byte ptr [rcx], 0
-;; 16000:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16009:	 800100               	add	byte ptr [rcx], 0
-;; 1600c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1600d:	 800100               	add	byte ptr [rcx], 0
-;; 16010:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16019:	 800100               	add	byte ptr [rcx], 0
-;; 1601c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1601d:	 800100               	add	byte ptr [rcx], 0
-;; 16020:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16029:	 800100               	add	byte ptr [rcx], 0
-;; 1602c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1602d:	 800100               	add	byte ptr [rcx], 0
-;; 16030:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16039:	 800100               	add	byte ptr [rcx], 0
-;; 1603c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1603d:	 800100               	add	byte ptr [rcx], 0
-;; 16040:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16049:	 800100               	add	byte ptr [rcx], 0
-;; 1604c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1604d:	 800100               	add	byte ptr [rcx], 0
-;; 16050:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16059:	 800100               	add	byte ptr [rcx], 0
-;; 1605c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1605d:	 800100               	add	byte ptr [rcx], 0
-;; 16060:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16069:	 800100               	add	byte ptr [rcx], 0
-;; 1606c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1606d:	 800100               	add	byte ptr [rcx], 0
-;; 16070:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16079:	 800100               	add	byte ptr [rcx], 0
-;; 1607c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1607d:	 800100               	add	byte ptr [rcx], 0
-;; 16080:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16089:	 800100               	add	byte ptr [rcx], 0
-;; 1608c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1608d:	 800100               	add	byte ptr [rcx], 0
-;; 16090:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16099:	 800100               	add	byte ptr [rcx], 0
-;; 1609c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1609d:	 800100               	add	byte ptr [rcx], 0
-;; 160a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 160a9:	 800100               	add	byte ptr [rcx], 0
-;; 160ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 160ad:	 800100               	add	byte ptr [rcx], 0
-;; 160b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 160b9:	 800100               	add	byte ptr [rcx], 0
-;; 160bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 160bd:	 800100               	add	byte ptr [rcx], 0
-;; 160c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 160c9:	 800100               	add	byte ptr [rcx], 0
-;; 160cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 160cd:	 800100               	add	byte ptr [rcx], 0
-;; 160d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 160d9:	 800100               	add	byte ptr [rcx], 0
-;; 160dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 160dd:	 800100               	add	byte ptr [rcx], 0
-;; 160e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 160e9:	 800100               	add	byte ptr [rcx], 0
-;; 160ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 160ed:	 800100               	add	byte ptr [rcx], 0
-;; 160f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 160f9:	 800100               	add	byte ptr [rcx], 0
-;; 160fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 160fd:	 800100               	add	byte ptr [rcx], 0
-;; 16100:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16109:	 800100               	add	byte ptr [rcx], 0
-;; 1610c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1610d:	 800100               	add	byte ptr [rcx], 0
-;; 16110:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16119:	 800100               	add	byte ptr [rcx], 0
-;; 1611c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1611d:	 800100               	add	byte ptr [rcx], 0
-;; 16120:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16129:	 800100               	add	byte ptr [rcx], 0
-;; 1612c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1612d:	 800100               	add	byte ptr [rcx], 0
-;; 16130:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16139:	 800100               	add	byte ptr [rcx], 0
-;; 1613c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1613d:	 800100               	add	byte ptr [rcx], 0
-;; 16140:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16149:	 800100               	add	byte ptr [rcx], 0
-;; 1614c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1614d:	 800100               	add	byte ptr [rcx], 0
-;; 16150:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16159:	 800100               	add	byte ptr [rcx], 0
-;; 1615c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1615d:	 800100               	add	byte ptr [rcx], 0
-;; 16160:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16169:	 800100               	add	byte ptr [rcx], 0
-;; 1616c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1616d:	 800100               	add	byte ptr [rcx], 0
-;; 16170:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16179:	 800100               	add	byte ptr [rcx], 0
-;; 1617c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1617d:	 800100               	add	byte ptr [rcx], 0
-;; 16180:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16189:	 800100               	add	byte ptr [rcx], 0
-;; 1618c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1618d:	 800100               	add	byte ptr [rcx], 0
-;; 16190:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16199:	 800100               	add	byte ptr [rcx], 0
-;; 1619c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1619d:	 800100               	add	byte ptr [rcx], 0
-;; 161a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 161a9:	 800100               	add	byte ptr [rcx], 0
-;; 161ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 161ad:	 800100               	add	byte ptr [rcx], 0
-;; 161b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 161b9:	 800100               	add	byte ptr [rcx], 0
-;; 161bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 161bd:	 800100               	add	byte ptr [rcx], 0
-;; 161c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 161c9:	 800100               	add	byte ptr [rcx], 0
-;; 161cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 161cd:	 800100               	add	byte ptr [rcx], 0
-;; 161d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 161d9:	 800100               	add	byte ptr [rcx], 0
-;; 161dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 161dd:	 800100               	add	byte ptr [rcx], 0
-;; 161e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 161e9:	 800100               	add	byte ptr [rcx], 0
-;; 161ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 161ed:	 800100               	add	byte ptr [rcx], 0
-;; 161f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 161f9:	 800100               	add	byte ptr [rcx], 0
-;; 161fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 161fd:	 800100               	add	byte ptr [rcx], 0
-;; 16200:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16209:	 800100               	add	byte ptr [rcx], 0
-;; 1620c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1620d:	 800100               	add	byte ptr [rcx], 0
-;; 16210:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16219:	 800100               	add	byte ptr [rcx], 0
-;; 1621c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1621d:	 800100               	add	byte ptr [rcx], 0
-;; 16220:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16229:	 800100               	add	byte ptr [rcx], 0
-;; 1622c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1622d:	 800100               	add	byte ptr [rcx], 0
-;; 16230:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16239:	 800100               	add	byte ptr [rcx], 0
-;; 1623c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1623d:	 800100               	add	byte ptr [rcx], 0
-;; 16240:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16249:	 800100               	add	byte ptr [rcx], 0
-;; 1624c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1624d:	 800100               	add	byte ptr [rcx], 0
-;; 16250:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16259:	 800100               	add	byte ptr [rcx], 0
-;; 1625c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1625d:	 800100               	add	byte ptr [rcx], 0
-;; 16260:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16269:	 800100               	add	byte ptr [rcx], 0
-;; 1626c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1626d:	 800100               	add	byte ptr [rcx], 0
-;; 16270:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16279:	 800100               	add	byte ptr [rcx], 0
-;; 1627c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1627d:	 800100               	add	byte ptr [rcx], 0
-;; 16280:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16289:	 800100               	add	byte ptr [rcx], 0
-;; 1628c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1628d:	 800100               	add	byte ptr [rcx], 0
-;; 16290:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16299:	 800100               	add	byte ptr [rcx], 0
-;; 1629c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1629d:	 800100               	add	byte ptr [rcx], 0
-;; 162a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 162a9:	 800100               	add	byte ptr [rcx], 0
-;; 162ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 162ad:	 800100               	add	byte ptr [rcx], 0
-;; 162b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 162b9:	 800100               	add	byte ptr [rcx], 0
-;; 162bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 162bd:	 800100               	add	byte ptr [rcx], 0
-;; 162c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 162c9:	 800100               	add	byte ptr [rcx], 0
-;; 162cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 162cd:	 800100               	add	byte ptr [rcx], 0
-;; 162d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 162d9:	 800100               	add	byte ptr [rcx], 0
-;; 162dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 162dd:	 800100               	add	byte ptr [rcx], 0
-;; 162e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 162e9:	 800100               	add	byte ptr [rcx], 0
-;; 162ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 162ed:	 800100               	add	byte ptr [rcx], 0
-;; 162f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 162f9:	 800100               	add	byte ptr [rcx], 0
-;; 162fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 162fd:	 800100               	add	byte ptr [rcx], 0
-;; 16300:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16309:	 800100               	add	byte ptr [rcx], 0
-;; 1630c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1630d:	 800100               	add	byte ptr [rcx], 0
-;; 16310:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16319:	 800100               	add	byte ptr [rcx], 0
-;; 1631c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1631d:	 800100               	add	byte ptr [rcx], 0
-;; 16320:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16329:	 800100               	add	byte ptr [rcx], 0
-;; 1632c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1632d:	 800100               	add	byte ptr [rcx], 0
-;; 16330:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16339:	 800100               	add	byte ptr [rcx], 0
-;; 1633c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1633d:	 800100               	add	byte ptr [rcx], 0
-;; 16340:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16349:	 800100               	add	byte ptr [rcx], 0
-;; 1634c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1634d:	 800100               	add	byte ptr [rcx], 0
-;; 16350:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16359:	 800100               	add	byte ptr [rcx], 0
-;; 1635c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1635d:	 800100               	add	byte ptr [rcx], 0
-;; 16360:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16369:	 800100               	add	byte ptr [rcx], 0
-;; 1636c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1636d:	 800100               	add	byte ptr [rcx], 0
-;; 16370:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16379:	 800100               	add	byte ptr [rcx], 0
-;; 1637c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1637d:	 800100               	add	byte ptr [rcx], 0
-;; 16380:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16389:	 800100               	add	byte ptr [rcx], 0
-;; 1638c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1638d:	 800100               	add	byte ptr [rcx], 0
-;; 16390:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16399:	 800100               	add	byte ptr [rcx], 0
-;; 1639c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1639d:	 800100               	add	byte ptr [rcx], 0
-;; 163a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 163a9:	 800100               	add	byte ptr [rcx], 0
-;; 163ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 163ad:	 800100               	add	byte ptr [rcx], 0
-;; 163b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 163b9:	 800100               	add	byte ptr [rcx], 0
-;; 163bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 163bd:	 800100               	add	byte ptr [rcx], 0
-;; 163c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 163c9:	 800100               	add	byte ptr [rcx], 0
-;; 163cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 163cd:	 800100               	add	byte ptr [rcx], 0
-;; 163d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 163d9:	 800100               	add	byte ptr [rcx], 0
-;; 163dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 163dd:	 800100               	add	byte ptr [rcx], 0
-;; 163e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 163e9:	 800100               	add	byte ptr [rcx], 0
-;; 163ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 163ed:	 800100               	add	byte ptr [rcx], 0
-;; 163f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 163f9:	 800100               	add	byte ptr [rcx], 0
-;; 163fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 163fd:	 800100               	add	byte ptr [rcx], 0
-;; 16400:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16409:	 800100               	add	byte ptr [rcx], 0
-;; 1640c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1640d:	 800100               	add	byte ptr [rcx], 0
-;; 16410:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16419:	 800100               	add	byte ptr [rcx], 0
-;; 1641c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1641d:	 800100               	add	byte ptr [rcx], 0
-;; 16420:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16429:	 800100               	add	byte ptr [rcx], 0
-;; 1642c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1642d:	 800100               	add	byte ptr [rcx], 0
-;; 16430:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16439:	 800100               	add	byte ptr [rcx], 0
-;; 1643c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1643d:	 800100               	add	byte ptr [rcx], 0
-;; 16440:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16449:	 800100               	add	byte ptr [rcx], 0
-;; 1644c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1644d:	 800100               	add	byte ptr [rcx], 0
-;; 16450:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16459:	 800100               	add	byte ptr [rcx], 0
-;; 1645c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1645d:	 800100               	add	byte ptr [rcx], 0
-;; 16460:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16469:	 800100               	add	byte ptr [rcx], 0
-;; 1646c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1646d:	 800100               	add	byte ptr [rcx], 0
-;; 16470:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16479:	 800100               	add	byte ptr [rcx], 0
-;; 1647c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1647d:	 800100               	add	byte ptr [rcx], 0
-;; 16480:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16489:	 800100               	add	byte ptr [rcx], 0
-;; 1648c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1648d:	 800100               	add	byte ptr [rcx], 0
-;; 16490:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16499:	 800100               	add	byte ptr [rcx], 0
-;; 1649c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1649d:	 800100               	add	byte ptr [rcx], 0
-;; 164a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 164a9:	 800100               	add	byte ptr [rcx], 0
-;; 164ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 164ad:	 800100               	add	byte ptr [rcx], 0
-;; 164b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 164b9:	 800100               	add	byte ptr [rcx], 0
-;; 164bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 164bd:	 800100               	add	byte ptr [rcx], 0
-;; 164c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 164c9:	 800100               	add	byte ptr [rcx], 0
-;; 164cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 164cd:	 800100               	add	byte ptr [rcx], 0
-;; 164d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 164d9:	 800100               	add	byte ptr [rcx], 0
-;; 164dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 164dd:	 800100               	add	byte ptr [rcx], 0
-;; 164e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 164e9:	 800100               	add	byte ptr [rcx], 0
-;; 164ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 164ed:	 800100               	add	byte ptr [rcx], 0
-;; 164f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 164f9:	 800100               	add	byte ptr [rcx], 0
-;; 164fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 164fd:	 800100               	add	byte ptr [rcx], 0
-;; 16500:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16509:	 800100               	add	byte ptr [rcx], 0
-;; 1650c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1650d:	 800100               	add	byte ptr [rcx], 0
-;; 16510:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16519:	 800100               	add	byte ptr [rcx], 0
-;; 1651c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1651d:	 800100               	add	byte ptr [rcx], 0
-;; 16520:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16529:	 800100               	add	byte ptr [rcx], 0
-;; 1652c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1652d:	 800100               	add	byte ptr [rcx], 0
-;; 16530:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16539:	 800100               	add	byte ptr [rcx], 0
-;; 1653c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1653d:	 800100               	add	byte ptr [rcx], 0
-;; 16540:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16549:	 800100               	add	byte ptr [rcx], 0
-;; 1654c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1654d:	 800100               	add	byte ptr [rcx], 0
-;; 16550:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16559:	 800100               	add	byte ptr [rcx], 0
-;; 1655c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1655d:	 800100               	add	byte ptr [rcx], 0
-;; 16560:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16569:	 800100               	add	byte ptr [rcx], 0
-;; 1656c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1656d:	 800100               	add	byte ptr [rcx], 0
-;; 16570:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16579:	 800100               	add	byte ptr [rcx], 0
-;; 1657c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1657d:	 800100               	add	byte ptr [rcx], 0
-;; 16580:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16589:	 800100               	add	byte ptr [rcx], 0
-;; 1658c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1658d:	 800100               	add	byte ptr [rcx], 0
-;; 16590:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16599:	 800100               	add	byte ptr [rcx], 0
-;; 1659c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1659d:	 800100               	add	byte ptr [rcx], 0
-;; 165a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 165a9:	 800100               	add	byte ptr [rcx], 0
-;; 165ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 165ad:	 800100               	add	byte ptr [rcx], 0
-;; 165b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 165b9:	 800100               	add	byte ptr [rcx], 0
-;; 165bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 165bd:	 800100               	add	byte ptr [rcx], 0
-;; 165c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 165c9:	 800100               	add	byte ptr [rcx], 0
-;; 165cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 165cd:	 800100               	add	byte ptr [rcx], 0
-;; 165d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 165d9:	 800100               	add	byte ptr [rcx], 0
-;; 165dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 165dd:	 800100               	add	byte ptr [rcx], 0
-;; 165e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 165e9:	 800100               	add	byte ptr [rcx], 0
-;; 165ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 165ed:	 800100               	add	byte ptr [rcx], 0
-;; 165f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 165f9:	 800100               	add	byte ptr [rcx], 0
-;; 165fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 165fd:	 800100               	add	byte ptr [rcx], 0
-;; 16600:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16609:	 800100               	add	byte ptr [rcx], 0
-;; 1660c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1660d:	 800100               	add	byte ptr [rcx], 0
-;; 16610:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16619:	 800100               	add	byte ptr [rcx], 0
-;; 1661c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1661d:	 800100               	add	byte ptr [rcx], 0
-;; 16620:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16629:	 800100               	add	byte ptr [rcx], 0
-;; 1662c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1662d:	 800100               	add	byte ptr [rcx], 0
-;; 16630:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16639:	 800100               	add	byte ptr [rcx], 0
-;; 1663c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1663d:	 800100               	add	byte ptr [rcx], 0
-;; 16640:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16649:	 800100               	add	byte ptr [rcx], 0
-;; 1664c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1664d:	 800100               	add	byte ptr [rcx], 0
-;; 16650:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16659:	 800100               	add	byte ptr [rcx], 0
-;; 1665c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1665d:	 800100               	add	byte ptr [rcx], 0
-;; 16660:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16669:	 800100               	add	byte ptr [rcx], 0
-;; 1666c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1666d:	 800100               	add	byte ptr [rcx], 0
-;; 16670:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16679:	 800100               	add	byte ptr [rcx], 0
-;; 1667c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1667d:	 800100               	add	byte ptr [rcx], 0
-;; 16680:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16689:	 800100               	add	byte ptr [rcx], 0
-;; 1668c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1668d:	 800100               	add	byte ptr [rcx], 0
-;; 16690:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16699:	 800100               	add	byte ptr [rcx], 0
-;; 1669c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1669d:	 800100               	add	byte ptr [rcx], 0
-;; 166a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 166a9:	 800100               	add	byte ptr [rcx], 0
-;; 166ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 166ad:	 800100               	add	byte ptr [rcx], 0
-;; 166b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 166b9:	 800100               	add	byte ptr [rcx], 0
-;; 166bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 166bd:	 800100               	add	byte ptr [rcx], 0
-;; 166c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 166c9:	 800100               	add	byte ptr [rcx], 0
-;; 166cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 166cd:	 800100               	add	byte ptr [rcx], 0
-;; 166d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 166d9:	 800100               	add	byte ptr [rcx], 0
-;; 166dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 166dd:	 800100               	add	byte ptr [rcx], 0
-;; 166e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 166e9:	 800100               	add	byte ptr [rcx], 0
-;; 166ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 166ed:	 800100               	add	byte ptr [rcx], 0
-;; 166f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 166f9:	 800100               	add	byte ptr [rcx], 0
-;; 166fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 166fd:	 800100               	add	byte ptr [rcx], 0
-;; 16700:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16709:	 800100               	add	byte ptr [rcx], 0
-;; 1670c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1670d:	 800100               	add	byte ptr [rcx], 0
-;; 16710:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16719:	 800100               	add	byte ptr [rcx], 0
-;; 1671c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1671d:	 800100               	add	byte ptr [rcx], 0
-;; 16720:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16729:	 800100               	add	byte ptr [rcx], 0
-;; 1672c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1672d:	 800100               	add	byte ptr [rcx], 0
-;; 16730:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16739:	 800100               	add	byte ptr [rcx], 0
-;; 1673c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1673d:	 800100               	add	byte ptr [rcx], 0
-;; 16740:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16749:	 800100               	add	byte ptr [rcx], 0
-;; 1674c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1674d:	 800100               	add	byte ptr [rcx], 0
-;; 16750:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16759:	 800100               	add	byte ptr [rcx], 0
-;; 1675c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1675d:	 800100               	add	byte ptr [rcx], 0
-;; 16760:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16769:	 800100               	add	byte ptr [rcx], 0
-;; 1676c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1676d:	 800100               	add	byte ptr [rcx], 0
-;; 16770:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16779:	 800100               	add	byte ptr [rcx], 0
-;; 1677c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1677d:	 800100               	add	byte ptr [rcx], 0
-;; 16780:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16789:	 800100               	add	byte ptr [rcx], 0
-;; 1678c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1678d:	 800100               	add	byte ptr [rcx], 0
-;; 16790:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16799:	 800100               	add	byte ptr [rcx], 0
-;; 1679c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1679d:	 800100               	add	byte ptr [rcx], 0
-;; 167a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 167a9:	 800100               	add	byte ptr [rcx], 0
-;; 167ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 167ad:	 800100               	add	byte ptr [rcx], 0
-;; 167b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 167b9:	 800100               	add	byte ptr [rcx], 0
-;; 167bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 167bd:	 800100               	add	byte ptr [rcx], 0
-;; 167c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 167c9:	 800100               	add	byte ptr [rcx], 0
-;; 167cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 167cd:	 800100               	add	byte ptr [rcx], 0
-;; 167d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 167d9:	 800100               	add	byte ptr [rcx], 0
-;; 167dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 167dd:	 800100               	add	byte ptr [rcx], 0
-;; 167e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 167e9:	 800100               	add	byte ptr [rcx], 0
-;; 167ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 167ed:	 800100               	add	byte ptr [rcx], 0
-;; 167f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 167f9:	 800100               	add	byte ptr [rcx], 0
-;; 167fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 167fd:	 800100               	add	byte ptr [rcx], 0
-;; 16800:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16809:	 800100               	add	byte ptr [rcx], 0
-;; 1680c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1680d:	 800100               	add	byte ptr [rcx], 0
-;; 16810:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16819:	 800100               	add	byte ptr [rcx], 0
-;; 1681c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1681d:	 800100               	add	byte ptr [rcx], 0
-;; 16820:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16829:	 800100               	add	byte ptr [rcx], 0
-;; 1682c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1682d:	 800100               	add	byte ptr [rcx], 0
-;; 16830:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16839:	 800100               	add	byte ptr [rcx], 0
-;; 1683c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1683d:	 800100               	add	byte ptr [rcx], 0
-;; 16840:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16849:	 800100               	add	byte ptr [rcx], 0
-;; 1684c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1684d:	 800100               	add	byte ptr [rcx], 0
-;; 16850:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16859:	 800100               	add	byte ptr [rcx], 0
-;; 1685c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1685d:	 800100               	add	byte ptr [rcx], 0
-;; 16860:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16869:	 800100               	add	byte ptr [rcx], 0
-;; 1686c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1686d:	 800100               	add	byte ptr [rcx], 0
-;; 16870:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16879:	 800100               	add	byte ptr [rcx], 0
-;; 1687c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1687d:	 800100               	add	byte ptr [rcx], 0
-;; 16880:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16889:	 800100               	add	byte ptr [rcx], 0
-;; 1688c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1688d:	 800100               	add	byte ptr [rcx], 0
-;; 16890:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16899:	 800100               	add	byte ptr [rcx], 0
-;; 1689c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1689d:	 800100               	add	byte ptr [rcx], 0
-;; 168a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 168a9:	 800100               	add	byte ptr [rcx], 0
-;; 168ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 168ad:	 800100               	add	byte ptr [rcx], 0
-;; 168b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 168b9:	 800100               	add	byte ptr [rcx], 0
-;; 168bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 168bd:	 800100               	add	byte ptr [rcx], 0
-;; 168c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 168c9:	 800100               	add	byte ptr [rcx], 0
-;; 168cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 168cd:	 800100               	add	byte ptr [rcx], 0
-;; 168d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 168d9:	 800100               	add	byte ptr [rcx], 0
-;; 168dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 168dd:	 800100               	add	byte ptr [rcx], 0
-;; 168e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 168e9:	 800100               	add	byte ptr [rcx], 0
-;; 168ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 168ed:	 800100               	add	byte ptr [rcx], 0
-;; 168f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 168f9:	 800100               	add	byte ptr [rcx], 0
-;; 168fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 168fd:	 800100               	add	byte ptr [rcx], 0
-;; 16900:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16909:	 800100               	add	byte ptr [rcx], 0
-;; 1690c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1690d:	 800100               	add	byte ptr [rcx], 0
-;; 16910:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16919:	 800100               	add	byte ptr [rcx], 0
-;; 1691c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1691d:	 800100               	add	byte ptr [rcx], 0
-;; 16920:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16929:	 800100               	add	byte ptr [rcx], 0
-;; 1692c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1692d:	 800100               	add	byte ptr [rcx], 0
-;; 16930:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16939:	 800100               	add	byte ptr [rcx], 0
-;; 1693c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1693d:	 800100               	add	byte ptr [rcx], 0
-;; 16940:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16949:	 800100               	add	byte ptr [rcx], 0
-;; 1694c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1694d:	 800100               	add	byte ptr [rcx], 0
-;; 16950:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16959:	 800100               	add	byte ptr [rcx], 0
-;; 1695c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1695d:	 800100               	add	byte ptr [rcx], 0
-;; 16960:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16969:	 800100               	add	byte ptr [rcx], 0
-;; 1696c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1696d:	 800100               	add	byte ptr [rcx], 0
-;; 16970:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16979:	 800100               	add	byte ptr [rcx], 0
-;; 1697c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1697d:	 800100               	add	byte ptr [rcx], 0
-;; 16980:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16989:	 800100               	add	byte ptr [rcx], 0
-;; 1698c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1698d:	 800100               	add	byte ptr [rcx], 0
-;; 16990:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16999:	 800100               	add	byte ptr [rcx], 0
-;; 1699c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1699d:	 800100               	add	byte ptr [rcx], 0
-;; 169a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 169a9:	 800100               	add	byte ptr [rcx], 0
-;; 169ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 169ad:	 800100               	add	byte ptr [rcx], 0
-;; 169b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 169b9:	 800100               	add	byte ptr [rcx], 0
-;; 169bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 169bd:	 800100               	add	byte ptr [rcx], 0
-;; 169c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 169c9:	 800100               	add	byte ptr [rcx], 0
-;; 169cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 169cd:	 800100               	add	byte ptr [rcx], 0
-;; 169d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 169d9:	 800100               	add	byte ptr [rcx], 0
-;; 169dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 169dd:	 800100               	add	byte ptr [rcx], 0
-;; 169e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 169e9:	 800100               	add	byte ptr [rcx], 0
-;; 169ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 169ed:	 800100               	add	byte ptr [rcx], 0
-;; 169f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 169f9:	 800100               	add	byte ptr [rcx], 0
-;; 169fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 169fd:	 800100               	add	byte ptr [rcx], 0
-;; 16a00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16a09:	 800100               	add	byte ptr [rcx], 0
-;; 16a0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16a0d:	 800100               	add	byte ptr [rcx], 0
-;; 16a10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16a19:	 800100               	add	byte ptr [rcx], 0
-;; 16a1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16a1d:	 800100               	add	byte ptr [rcx], 0
-;; 16a20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16a29:	 800100               	add	byte ptr [rcx], 0
-;; 16a2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16a2d:	 800100               	add	byte ptr [rcx], 0
-;; 16a30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16a39:	 800100               	add	byte ptr [rcx], 0
-;; 16a3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16a3d:	 800100               	add	byte ptr [rcx], 0
-;; 16a40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16a49:	 800100               	add	byte ptr [rcx], 0
-;; 16a4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16a4d:	 800100               	add	byte ptr [rcx], 0
-;; 16a50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16a59:	 800100               	add	byte ptr [rcx], 0
-;; 16a5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16a5d:	 800100               	add	byte ptr [rcx], 0
-;; 16a60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16a69:	 800100               	add	byte ptr [rcx], 0
-;; 16a6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16a6d:	 800100               	add	byte ptr [rcx], 0
-;; 16a70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16a79:	 800100               	add	byte ptr [rcx], 0
-;; 16a7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16a7d:	 800100               	add	byte ptr [rcx], 0
-;; 16a80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16a89:	 800100               	add	byte ptr [rcx], 0
-;; 16a8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16a8d:	 800100               	add	byte ptr [rcx], 0
-;; 16a90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16a99:	 800100               	add	byte ptr [rcx], 0
-;; 16a9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16a9d:	 800100               	add	byte ptr [rcx], 0
-;; 16aa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16aa9:	 800100               	add	byte ptr [rcx], 0
-;; 16aac:	 aa                   	stosb	byte ptr [rdi], al
-;; 16aad:	 800100               	add	byte ptr [rcx], 0
-;; 16ab0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16ab9:	 800100               	add	byte ptr [rcx], 0
-;; 16abc:	 aa                   	stosb	byte ptr [rdi], al
-;; 16abd:	 800100               	add	byte ptr [rcx], 0
-;; 16ac0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16ac9:	 800100               	add	byte ptr [rcx], 0
-;; 16acc:	 aa                   	stosb	byte ptr [rdi], al
-;; 16acd:	 800100               	add	byte ptr [rcx], 0
-;; 16ad0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16ad9:	 800100               	add	byte ptr [rcx], 0
-;; 16adc:	 aa                   	stosb	byte ptr [rdi], al
-;; 16add:	 800100               	add	byte ptr [rcx], 0
-;; 16ae0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16ae9:	 800100               	add	byte ptr [rcx], 0
-;; 16aec:	 aa                   	stosb	byte ptr [rdi], al
-;; 16aed:	 800100               	add	byte ptr [rcx], 0
-;; 16af0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16af9:	 800100               	add	byte ptr [rcx], 0
-;; 16afc:	 aa                   	stosb	byte ptr [rdi], al
-;; 16afd:	 800100               	add	byte ptr [rcx], 0
-;; 16b00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16b09:	 800100               	add	byte ptr [rcx], 0
-;; 16b0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16b0d:	 800100               	add	byte ptr [rcx], 0
-;; 16b10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16b19:	 800100               	add	byte ptr [rcx], 0
-;; 16b1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16b1d:	 800100               	add	byte ptr [rcx], 0
-;; 16b20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16b29:	 800100               	add	byte ptr [rcx], 0
-;; 16b2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16b2d:	 800100               	add	byte ptr [rcx], 0
-;; 16b30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16b39:	 800100               	add	byte ptr [rcx], 0
-;; 16b3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16b3d:	 800100               	add	byte ptr [rcx], 0
-;; 16b40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16b49:	 800100               	add	byte ptr [rcx], 0
-;; 16b4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16b4d:	 800100               	add	byte ptr [rcx], 0
-;; 16b50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16b59:	 800100               	add	byte ptr [rcx], 0
-;; 16b5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16b5d:	 800100               	add	byte ptr [rcx], 0
-;; 16b60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16b69:	 800100               	add	byte ptr [rcx], 0
-;; 16b6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16b6d:	 800100               	add	byte ptr [rcx], 0
-;; 16b70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16b79:	 800100               	add	byte ptr [rcx], 0
-;; 16b7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16b7d:	 800100               	add	byte ptr [rcx], 0
-;; 16b80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16b89:	 800100               	add	byte ptr [rcx], 0
-;; 16b8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16b8d:	 800100               	add	byte ptr [rcx], 0
-;; 16b90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16b99:	 800100               	add	byte ptr [rcx], 0
-;; 16b9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16b9d:	 800100               	add	byte ptr [rcx], 0
-;; 16ba0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16ba9:	 800100               	add	byte ptr [rcx], 0
-;; 16bac:	 aa                   	stosb	byte ptr [rdi], al
-;; 16bad:	 800100               	add	byte ptr [rcx], 0
-;; 16bb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16bb9:	 800100               	add	byte ptr [rcx], 0
-;; 16bbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 16bbd:	 800100               	add	byte ptr [rcx], 0
-;; 16bc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16bc9:	 800100               	add	byte ptr [rcx], 0
-;; 16bcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 16bcd:	 800100               	add	byte ptr [rcx], 0
-;; 16bd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16bd9:	 800100               	add	byte ptr [rcx], 0
-;; 16bdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 16bdd:	 800100               	add	byte ptr [rcx], 0
-;; 16be0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16be9:	 800100               	add	byte ptr [rcx], 0
-;; 16bec:	 aa                   	stosb	byte ptr [rdi], al
-;; 16bed:	 800100               	add	byte ptr [rcx], 0
-;; 16bf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16bf9:	 800100               	add	byte ptr [rcx], 0
-;; 16bfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 16bfd:	 800100               	add	byte ptr [rcx], 0
-;; 16c00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16c09:	 800100               	add	byte ptr [rcx], 0
-;; 16c0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16c0d:	 800100               	add	byte ptr [rcx], 0
-;; 16c10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16c19:	 800100               	add	byte ptr [rcx], 0
-;; 16c1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16c1d:	 800100               	add	byte ptr [rcx], 0
-;; 16c20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16c29:	 800100               	add	byte ptr [rcx], 0
-;; 16c2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16c2d:	 800100               	add	byte ptr [rcx], 0
-;; 16c30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16c39:	 800100               	add	byte ptr [rcx], 0
-;; 16c3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16c3d:	 800100               	add	byte ptr [rcx], 0
-;; 16c40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16c49:	 800100               	add	byte ptr [rcx], 0
-;; 16c4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16c4d:	 800100               	add	byte ptr [rcx], 0
-;; 16c50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16c59:	 800100               	add	byte ptr [rcx], 0
-;; 16c5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16c5d:	 800100               	add	byte ptr [rcx], 0
-;; 16c60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16c69:	 800100               	add	byte ptr [rcx], 0
-;; 16c6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16c6d:	 800100               	add	byte ptr [rcx], 0
-;; 16c70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16c79:	 800100               	add	byte ptr [rcx], 0
-;; 16c7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16c7d:	 800100               	add	byte ptr [rcx], 0
-;; 16c80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16c89:	 800100               	add	byte ptr [rcx], 0
-;; 16c8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16c8d:	 800100               	add	byte ptr [rcx], 0
-;; 16c90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16c99:	 800100               	add	byte ptr [rcx], 0
-;; 16c9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16c9d:	 800100               	add	byte ptr [rcx], 0
-;; 16ca0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16ca9:	 800100               	add	byte ptr [rcx], 0
-;; 16cac:	 aa                   	stosb	byte ptr [rdi], al
-;; 16cad:	 800100               	add	byte ptr [rcx], 0
-;; 16cb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16cb9:	 800100               	add	byte ptr [rcx], 0
-;; 16cbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 16cbd:	 800100               	add	byte ptr [rcx], 0
-;; 16cc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16cc9:	 800100               	add	byte ptr [rcx], 0
-;; 16ccc:	 aa                   	stosb	byte ptr [rdi], al
-;; 16ccd:	 800100               	add	byte ptr [rcx], 0
-;; 16cd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16cd9:	 800100               	add	byte ptr [rcx], 0
-;; 16cdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 16cdd:	 800100               	add	byte ptr [rcx], 0
-;; 16ce0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16ce9:	 800100               	add	byte ptr [rcx], 0
-;; 16cec:	 aa                   	stosb	byte ptr [rdi], al
-;; 16ced:	 800100               	add	byte ptr [rcx], 0
-;; 16cf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16cf9:	 800100               	add	byte ptr [rcx], 0
-;; 16cfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 16cfd:	 800100               	add	byte ptr [rcx], 0
-;; 16d00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16d09:	 800100               	add	byte ptr [rcx], 0
-;; 16d0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16d0d:	 800100               	add	byte ptr [rcx], 0
-;; 16d10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16d19:	 800100               	add	byte ptr [rcx], 0
-;; 16d1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16d1d:	 800100               	add	byte ptr [rcx], 0
-;; 16d20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16d29:	 800100               	add	byte ptr [rcx], 0
-;; 16d2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16d2d:	 800100               	add	byte ptr [rcx], 0
-;; 16d30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16d39:	 800100               	add	byte ptr [rcx], 0
-;; 16d3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16d3d:	 800100               	add	byte ptr [rcx], 0
-;; 16d40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16d49:	 800100               	add	byte ptr [rcx], 0
-;; 16d4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16d4d:	 800100               	add	byte ptr [rcx], 0
-;; 16d50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16d59:	 800100               	add	byte ptr [rcx], 0
-;; 16d5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16d5d:	 800100               	add	byte ptr [rcx], 0
-;; 16d60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16d69:	 800100               	add	byte ptr [rcx], 0
-;; 16d6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16d6d:	 800100               	add	byte ptr [rcx], 0
-;; 16d70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16d79:	 800100               	add	byte ptr [rcx], 0
-;; 16d7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16d7d:	 800100               	add	byte ptr [rcx], 0
-;; 16d80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16d89:	 800100               	add	byte ptr [rcx], 0
-;; 16d8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16d8d:	 800100               	add	byte ptr [rcx], 0
-;; 16d90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16d99:	 800100               	add	byte ptr [rcx], 0
-;; 16d9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16d9d:	 800100               	add	byte ptr [rcx], 0
-;; 16da0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16da9:	 800100               	add	byte ptr [rcx], 0
-;; 16dac:	 aa                   	stosb	byte ptr [rdi], al
-;; 16dad:	 800100               	add	byte ptr [rcx], 0
-;; 16db0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16db9:	 800100               	add	byte ptr [rcx], 0
-;; 16dbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 16dbd:	 800100               	add	byte ptr [rcx], 0
-;; 16dc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16dc9:	 800100               	add	byte ptr [rcx], 0
-;; 16dcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 16dcd:	 800100               	add	byte ptr [rcx], 0
-;; 16dd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16dd9:	 800100               	add	byte ptr [rcx], 0
-;; 16ddc:	 aa                   	stosb	byte ptr [rdi], al
-;; 16ddd:	 800100               	add	byte ptr [rcx], 0
-;; 16de0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16de9:	 800100               	add	byte ptr [rcx], 0
-;; 16dec:	 aa                   	stosb	byte ptr [rdi], al
-;; 16ded:	 800100               	add	byte ptr [rcx], 0
-;; 16df0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16df9:	 800100               	add	byte ptr [rcx], 0
-;; 16dfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 16dfd:	 800100               	add	byte ptr [rcx], 0
-;; 16e00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16e09:	 800100               	add	byte ptr [rcx], 0
-;; 16e0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16e0d:	 800100               	add	byte ptr [rcx], 0
-;; 16e10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16e19:	 800100               	add	byte ptr [rcx], 0
-;; 16e1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16e1d:	 800100               	add	byte ptr [rcx], 0
-;; 16e20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16e29:	 800100               	add	byte ptr [rcx], 0
-;; 16e2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16e2d:	 800100               	add	byte ptr [rcx], 0
-;; 16e30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16e39:	 800100               	add	byte ptr [rcx], 0
-;; 16e3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16e3d:	 800100               	add	byte ptr [rcx], 0
-;; 16e40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16e49:	 800100               	add	byte ptr [rcx], 0
-;; 16e4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16e4d:	 800100               	add	byte ptr [rcx], 0
-;; 16e50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16e59:	 800100               	add	byte ptr [rcx], 0
-;; 16e5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16e5d:	 800100               	add	byte ptr [rcx], 0
-;; 16e60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16e69:	 800100               	add	byte ptr [rcx], 0
-;; 16e6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16e6d:	 800100               	add	byte ptr [rcx], 0
-;; 16e70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16e79:	 800100               	add	byte ptr [rcx], 0
-;; 16e7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16e7d:	 800100               	add	byte ptr [rcx], 0
-;; 16e80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16e89:	 800100               	add	byte ptr [rcx], 0
-;; 16e8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16e8d:	 800100               	add	byte ptr [rcx], 0
-;; 16e90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16e99:	 800100               	add	byte ptr [rcx], 0
-;; 16e9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16e9d:	 800100               	add	byte ptr [rcx], 0
-;; 16ea0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16ea9:	 800100               	add	byte ptr [rcx], 0
-;; 16eac:	 aa                   	stosb	byte ptr [rdi], al
-;; 16ead:	 800100               	add	byte ptr [rcx], 0
-;; 16eb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16eb9:	 800100               	add	byte ptr [rcx], 0
-;; 16ebc:	 aa                   	stosb	byte ptr [rdi], al
-;; 16ebd:	 800100               	add	byte ptr [rcx], 0
-;; 16ec0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16ec9:	 800100               	add	byte ptr [rcx], 0
-;; 16ecc:	 aa                   	stosb	byte ptr [rdi], al
-;; 16ecd:	 800100               	add	byte ptr [rcx], 0
-;; 16ed0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16ed9:	 800100               	add	byte ptr [rcx], 0
-;; 16edc:	 aa                   	stosb	byte ptr [rdi], al
-;; 16edd:	 800100               	add	byte ptr [rcx], 0
-;; 16ee0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16ee9:	 800100               	add	byte ptr [rcx], 0
-;; 16eec:	 aa                   	stosb	byte ptr [rdi], al
-;; 16eed:	 800100               	add	byte ptr [rcx], 0
-;; 16ef0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16ef9:	 800100               	add	byte ptr [rcx], 0
-;; 16efc:	 aa                   	stosb	byte ptr [rdi], al
-;; 16efd:	 800100               	add	byte ptr [rcx], 0
-;; 16f00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16f09:	 800100               	add	byte ptr [rcx], 0
-;; 16f0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16f0d:	 800100               	add	byte ptr [rcx], 0
-;; 16f10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16f19:	 800100               	add	byte ptr [rcx], 0
-;; 16f1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16f1d:	 800100               	add	byte ptr [rcx], 0
-;; 16f20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16f29:	 800100               	add	byte ptr [rcx], 0
-;; 16f2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16f2d:	 800100               	add	byte ptr [rcx], 0
-;; 16f30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16f39:	 800100               	add	byte ptr [rcx], 0
-;; 16f3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16f3d:	 800100               	add	byte ptr [rcx], 0
-;; 16f40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16f49:	 800100               	add	byte ptr [rcx], 0
-;; 16f4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16f4d:	 800100               	add	byte ptr [rcx], 0
-;; 16f50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16f59:	 800100               	add	byte ptr [rcx], 0
-;; 16f5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16f5d:	 800100               	add	byte ptr [rcx], 0
-;; 16f60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16f69:	 800100               	add	byte ptr [rcx], 0
-;; 16f6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16f6d:	 800100               	add	byte ptr [rcx], 0
-;; 16f70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16f79:	 800100               	add	byte ptr [rcx], 0
-;; 16f7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16f7d:	 800100               	add	byte ptr [rcx], 0
-;; 16f80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16f89:	 800100               	add	byte ptr [rcx], 0
-;; 16f8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16f8d:	 800100               	add	byte ptr [rcx], 0
-;; 16f90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16f99:	 800100               	add	byte ptr [rcx], 0
-;; 16f9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 16f9d:	 800100               	add	byte ptr [rcx], 0
-;; 16fa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16fa9:	 800100               	add	byte ptr [rcx], 0
-;; 16fac:	 aa                   	stosb	byte ptr [rdi], al
-;; 16fad:	 800100               	add	byte ptr [rcx], 0
-;; 16fb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16fb9:	 800100               	add	byte ptr [rcx], 0
-;; 16fbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 16fbd:	 800100               	add	byte ptr [rcx], 0
-;; 16fc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16fc9:	 800100               	add	byte ptr [rcx], 0
-;; 16fcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 16fcd:	 800100               	add	byte ptr [rcx], 0
-;; 16fd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16fd9:	 800100               	add	byte ptr [rcx], 0
-;; 16fdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 16fdd:	 800100               	add	byte ptr [rcx], 0
-;; 16fe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16fe9:	 800100               	add	byte ptr [rcx], 0
-;; 16fec:	 aa                   	stosb	byte ptr [rdi], al
-;; 16fed:	 800100               	add	byte ptr [rcx], 0
-;; 16ff0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 16ff9:	 800100               	add	byte ptr [rcx], 0
-;; 16ffc:	 aa                   	stosb	byte ptr [rdi], al
-;; 16ffd:	 800100               	add	byte ptr [rcx], 0
-;; 17000:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17009:	 800100               	add	byte ptr [rcx], 0
-;; 1700c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1700d:	 800100               	add	byte ptr [rcx], 0
-;; 17010:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17019:	 800100               	add	byte ptr [rcx], 0
-;; 1701c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1701d:	 800100               	add	byte ptr [rcx], 0
-;; 17020:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17029:	 800100               	add	byte ptr [rcx], 0
-;; 1702c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1702d:	 800100               	add	byte ptr [rcx], 0
-;; 17030:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17039:	 800100               	add	byte ptr [rcx], 0
-;; 1703c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1703d:	 800100               	add	byte ptr [rcx], 0
-;; 17040:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17049:	 800100               	add	byte ptr [rcx], 0
-;; 1704c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1704d:	 800100               	add	byte ptr [rcx], 0
-;; 17050:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17059:	 800100               	add	byte ptr [rcx], 0
-;; 1705c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1705d:	 800100               	add	byte ptr [rcx], 0
-;; 17060:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17069:	 800100               	add	byte ptr [rcx], 0
-;; 1706c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1706d:	 800100               	add	byte ptr [rcx], 0
-;; 17070:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17079:	 800100               	add	byte ptr [rcx], 0
-;; 1707c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1707d:	 800100               	add	byte ptr [rcx], 0
-;; 17080:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17089:	 800100               	add	byte ptr [rcx], 0
-;; 1708c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1708d:	 800100               	add	byte ptr [rcx], 0
-;; 17090:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17099:	 800100               	add	byte ptr [rcx], 0
-;; 1709c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1709d:	 800100               	add	byte ptr [rcx], 0
-;; 170a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 170a9:	 800100               	add	byte ptr [rcx], 0
-;; 170ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 170ad:	 800100               	add	byte ptr [rcx], 0
-;; 170b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 170b9:	 800100               	add	byte ptr [rcx], 0
-;; 170bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 170bd:	 800100               	add	byte ptr [rcx], 0
-;; 170c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 170c9:	 800100               	add	byte ptr [rcx], 0
-;; 170cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 170cd:	 800100               	add	byte ptr [rcx], 0
-;; 170d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 170d9:	 800100               	add	byte ptr [rcx], 0
-;; 170dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 170dd:	 800100               	add	byte ptr [rcx], 0
-;; 170e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 170e9:	 800100               	add	byte ptr [rcx], 0
-;; 170ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 170ed:	 800100               	add	byte ptr [rcx], 0
-;; 170f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 170f9:	 800100               	add	byte ptr [rcx], 0
-;; 170fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 170fd:	 800100               	add	byte ptr [rcx], 0
-;; 17100:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17109:	 800100               	add	byte ptr [rcx], 0
-;; 1710c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1710d:	 800100               	add	byte ptr [rcx], 0
-;; 17110:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17119:	 800100               	add	byte ptr [rcx], 0
-;; 1711c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1711d:	 800100               	add	byte ptr [rcx], 0
-;; 17120:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17129:	 800100               	add	byte ptr [rcx], 0
-;; 1712c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1712d:	 800100               	add	byte ptr [rcx], 0
-;; 17130:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17139:	 800100               	add	byte ptr [rcx], 0
-;; 1713c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1713d:	 800100               	add	byte ptr [rcx], 0
-;; 17140:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17149:	 800100               	add	byte ptr [rcx], 0
-;; 1714c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1714d:	 800100               	add	byte ptr [rcx], 0
-;; 17150:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17159:	 800100               	add	byte ptr [rcx], 0
-;; 1715c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1715d:	 800100               	add	byte ptr [rcx], 0
-;; 17160:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17169:	 800100               	add	byte ptr [rcx], 0
-;; 1716c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1716d:	 800100               	add	byte ptr [rcx], 0
-;; 17170:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17179:	 800100               	add	byte ptr [rcx], 0
-;; 1717c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1717d:	 800100               	add	byte ptr [rcx], 0
-;; 17180:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17189:	 800100               	add	byte ptr [rcx], 0
-;; 1718c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1718d:	 800100               	add	byte ptr [rcx], 0
-;; 17190:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17199:	 800100               	add	byte ptr [rcx], 0
-;; 1719c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1719d:	 800100               	add	byte ptr [rcx], 0
-;; 171a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 171a9:	 800100               	add	byte ptr [rcx], 0
-;; 171ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 171ad:	 800100               	add	byte ptr [rcx], 0
-;; 171b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 171b9:	 800100               	add	byte ptr [rcx], 0
-;; 171bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 171bd:	 800100               	add	byte ptr [rcx], 0
-;; 171c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 171c9:	 800100               	add	byte ptr [rcx], 0
-;; 171cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 171cd:	 800100               	add	byte ptr [rcx], 0
-;; 171d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 171d9:	 800100               	add	byte ptr [rcx], 0
-;; 171dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 171dd:	 800100               	add	byte ptr [rcx], 0
-;; 171e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 171e9:	 800100               	add	byte ptr [rcx], 0
-;; 171ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 171ed:	 800100               	add	byte ptr [rcx], 0
-;; 171f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 171f9:	 800100               	add	byte ptr [rcx], 0
-;; 171fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 171fd:	 800100               	add	byte ptr [rcx], 0
-;; 17200:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17209:	 800100               	add	byte ptr [rcx], 0
-;; 1720c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1720d:	 800100               	add	byte ptr [rcx], 0
-;; 17210:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17219:	 800100               	add	byte ptr [rcx], 0
-;; 1721c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1721d:	 800100               	add	byte ptr [rcx], 0
-;; 17220:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17229:	 800100               	add	byte ptr [rcx], 0
-;; 1722c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1722d:	 800100               	add	byte ptr [rcx], 0
-;; 17230:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17239:	 800100               	add	byte ptr [rcx], 0
-;; 1723c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1723d:	 800100               	add	byte ptr [rcx], 0
-;; 17240:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17249:	 800100               	add	byte ptr [rcx], 0
-;; 1724c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1724d:	 800100               	add	byte ptr [rcx], 0
-;; 17250:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17259:	 800100               	add	byte ptr [rcx], 0
-;; 1725c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1725d:	 800100               	add	byte ptr [rcx], 0
-;; 17260:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17269:	 800100               	add	byte ptr [rcx], 0
-;; 1726c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1726d:	 800100               	add	byte ptr [rcx], 0
-;; 17270:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17279:	 800100               	add	byte ptr [rcx], 0
-;; 1727c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1727d:	 800100               	add	byte ptr [rcx], 0
-;; 17280:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17289:	 800100               	add	byte ptr [rcx], 0
-;; 1728c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1728d:	 800100               	add	byte ptr [rcx], 0
-;; 17290:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17299:	 800100               	add	byte ptr [rcx], 0
-;; 1729c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1729d:	 800100               	add	byte ptr [rcx], 0
-;; 172a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 172a9:	 800100               	add	byte ptr [rcx], 0
-;; 172ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 172ad:	 800100               	add	byte ptr [rcx], 0
-;; 172b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 172b9:	 800100               	add	byte ptr [rcx], 0
-;; 172bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 172bd:	 800100               	add	byte ptr [rcx], 0
-;; 172c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 172c9:	 800100               	add	byte ptr [rcx], 0
-;; 172cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 172cd:	 800100               	add	byte ptr [rcx], 0
-;; 172d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 172d9:	 800100               	add	byte ptr [rcx], 0
-;; 172dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 172dd:	 800100               	add	byte ptr [rcx], 0
-;; 172e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 172e9:	 800100               	add	byte ptr [rcx], 0
-;; 172ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 172ed:	 800100               	add	byte ptr [rcx], 0
-;; 172f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 172f9:	 800100               	add	byte ptr [rcx], 0
-;; 172fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 172fd:	 800100               	add	byte ptr [rcx], 0
-;; 17300:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17309:	 800100               	add	byte ptr [rcx], 0
-;; 1730c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1730d:	 800100               	add	byte ptr [rcx], 0
-;; 17310:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17319:	 800100               	add	byte ptr [rcx], 0
-;; 1731c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1731d:	 800100               	add	byte ptr [rcx], 0
-;; 17320:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17329:	 800100               	add	byte ptr [rcx], 0
-;; 1732c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1732d:	 800100               	add	byte ptr [rcx], 0
-;; 17330:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17339:	 800100               	add	byte ptr [rcx], 0
-;; 1733c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1733d:	 800100               	add	byte ptr [rcx], 0
-;; 17340:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17349:	 800100               	add	byte ptr [rcx], 0
-;; 1734c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1734d:	 800100               	add	byte ptr [rcx], 0
-;; 17350:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17359:	 800100               	add	byte ptr [rcx], 0
-;; 1735c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1735d:	 800100               	add	byte ptr [rcx], 0
-;; 17360:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17369:	 800100               	add	byte ptr [rcx], 0
-;; 1736c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1736d:	 800100               	add	byte ptr [rcx], 0
-;; 17370:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17379:	 800100               	add	byte ptr [rcx], 0
-;; 1737c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1737d:	 800100               	add	byte ptr [rcx], 0
-;; 17380:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17389:	 800100               	add	byte ptr [rcx], 0
-;; 1738c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1738d:	 800100               	add	byte ptr [rcx], 0
-;; 17390:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17399:	 800100               	add	byte ptr [rcx], 0
-;; 1739c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1739d:	 800100               	add	byte ptr [rcx], 0
-;; 173a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 173a9:	 800100               	add	byte ptr [rcx], 0
-;; 173ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 173ad:	 800100               	add	byte ptr [rcx], 0
-;; 173b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 173b9:	 800100               	add	byte ptr [rcx], 0
-;; 173bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 173bd:	 800100               	add	byte ptr [rcx], 0
-;; 173c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 173c9:	 800100               	add	byte ptr [rcx], 0
-;; 173cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 173cd:	 800100               	add	byte ptr [rcx], 0
-;; 173d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 173d9:	 800100               	add	byte ptr [rcx], 0
-;; 173dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 173dd:	 800100               	add	byte ptr [rcx], 0
-;; 173e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 173e9:	 800100               	add	byte ptr [rcx], 0
-;; 173ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 173ed:	 800100               	add	byte ptr [rcx], 0
-;; 173f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 173f9:	 800100               	add	byte ptr [rcx], 0
-;; 173fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 173fd:	 800100               	add	byte ptr [rcx], 0
-;; 17400:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17409:	 800100               	add	byte ptr [rcx], 0
-;; 1740c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1740d:	 800100               	add	byte ptr [rcx], 0
-;; 17410:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17419:	 800100               	add	byte ptr [rcx], 0
-;; 1741c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1741d:	 800100               	add	byte ptr [rcx], 0
-;; 17420:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17429:	 800100               	add	byte ptr [rcx], 0
-;; 1742c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1742d:	 800100               	add	byte ptr [rcx], 0
-;; 17430:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17439:	 800100               	add	byte ptr [rcx], 0
-;; 1743c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1743d:	 800100               	add	byte ptr [rcx], 0
-;; 17440:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17449:	 800100               	add	byte ptr [rcx], 0
-;; 1744c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1744d:	 800100               	add	byte ptr [rcx], 0
-;; 17450:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17459:	 800100               	add	byte ptr [rcx], 0
-;; 1745c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1745d:	 800100               	add	byte ptr [rcx], 0
-;; 17460:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17469:	 800100               	add	byte ptr [rcx], 0
-;; 1746c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1746d:	 800100               	add	byte ptr [rcx], 0
-;; 17470:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17479:	 800100               	add	byte ptr [rcx], 0
-;; 1747c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1747d:	 800100               	add	byte ptr [rcx], 0
-;; 17480:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17489:	 800100               	add	byte ptr [rcx], 0
-;; 1748c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1748d:	 800100               	add	byte ptr [rcx], 0
-;; 17490:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17499:	 800100               	add	byte ptr [rcx], 0
-;; 1749c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1749d:	 800100               	add	byte ptr [rcx], 0
-;; 174a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 174a9:	 800100               	add	byte ptr [rcx], 0
-;; 174ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 174ad:	 800100               	add	byte ptr [rcx], 0
-;; 174b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 174b9:	 800100               	add	byte ptr [rcx], 0
-;; 174bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 174bd:	 800100               	add	byte ptr [rcx], 0
-;; 174c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 174c9:	 800100               	add	byte ptr [rcx], 0
-;; 174cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 174cd:	 800100               	add	byte ptr [rcx], 0
-;; 174d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 174d9:	 800100               	add	byte ptr [rcx], 0
-;; 174dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 174dd:	 800100               	add	byte ptr [rcx], 0
-;; 174e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 174e9:	 800100               	add	byte ptr [rcx], 0
-;; 174ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 174ed:	 800100               	add	byte ptr [rcx], 0
-;; 174f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 174f9:	 800100               	add	byte ptr [rcx], 0
-;; 174fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 174fd:	 800100               	add	byte ptr [rcx], 0
-;; 17500:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17509:	 800100               	add	byte ptr [rcx], 0
-;; 1750c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1750d:	 800100               	add	byte ptr [rcx], 0
-;; 17510:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17519:	 800100               	add	byte ptr [rcx], 0
-;; 1751c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1751d:	 800100               	add	byte ptr [rcx], 0
-;; 17520:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17529:	 800100               	add	byte ptr [rcx], 0
-;; 1752c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1752d:	 800100               	add	byte ptr [rcx], 0
-;; 17530:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17539:	 800100               	add	byte ptr [rcx], 0
-;; 1753c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1753d:	 800100               	add	byte ptr [rcx], 0
-;; 17540:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17549:	 800100               	add	byte ptr [rcx], 0
-;; 1754c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1754d:	 800100               	add	byte ptr [rcx], 0
-;; 17550:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17559:	 800100               	add	byte ptr [rcx], 0
-;; 1755c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1755d:	 800100               	add	byte ptr [rcx], 0
-;; 17560:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17569:	 800100               	add	byte ptr [rcx], 0
-;; 1756c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1756d:	 800100               	add	byte ptr [rcx], 0
-;; 17570:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17579:	 800100               	add	byte ptr [rcx], 0
-;; 1757c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1757d:	 800100               	add	byte ptr [rcx], 0
-;; 17580:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17589:	 800100               	add	byte ptr [rcx], 0
-;; 1758c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1758d:	 800100               	add	byte ptr [rcx], 0
-;; 17590:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17599:	 800100               	add	byte ptr [rcx], 0
-;; 1759c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1759d:	 800100               	add	byte ptr [rcx], 0
-;; 175a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 175a9:	 800100               	add	byte ptr [rcx], 0
-;; 175ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 175ad:	 800100               	add	byte ptr [rcx], 0
-;; 175b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 175b9:	 800100               	add	byte ptr [rcx], 0
-;; 175bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 175bd:	 800100               	add	byte ptr [rcx], 0
-;; 175c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 175c9:	 800100               	add	byte ptr [rcx], 0
-;; 175cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 175cd:	 800100               	add	byte ptr [rcx], 0
-;; 175d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 175d9:	 800100               	add	byte ptr [rcx], 0
-;; 175dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 175dd:	 800100               	add	byte ptr [rcx], 0
-;; 175e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 175e9:	 800100               	add	byte ptr [rcx], 0
-;; 175ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 175ed:	 800100               	add	byte ptr [rcx], 0
-;; 175f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 175f9:	 800100               	add	byte ptr [rcx], 0
-;; 175fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 175fd:	 800100               	add	byte ptr [rcx], 0
-;; 17600:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17609:	 800100               	add	byte ptr [rcx], 0
-;; 1760c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1760d:	 800100               	add	byte ptr [rcx], 0
-;; 17610:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17619:	 800100               	add	byte ptr [rcx], 0
-;; 1761c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1761d:	 800100               	add	byte ptr [rcx], 0
-;; 17620:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17629:	 800100               	add	byte ptr [rcx], 0
-;; 1762c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1762d:	 800100               	add	byte ptr [rcx], 0
-;; 17630:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17639:	 800100               	add	byte ptr [rcx], 0
-;; 1763c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1763d:	 800100               	add	byte ptr [rcx], 0
-;; 17640:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17649:	 800100               	add	byte ptr [rcx], 0
-;; 1764c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1764d:	 800100               	add	byte ptr [rcx], 0
-;; 17650:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17659:	 800100               	add	byte ptr [rcx], 0
-;; 1765c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1765d:	 800100               	add	byte ptr [rcx], 0
-;; 17660:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17669:	 800100               	add	byte ptr [rcx], 0
-;; 1766c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1766d:	 800100               	add	byte ptr [rcx], 0
-;; 17670:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17679:	 800100               	add	byte ptr [rcx], 0
-;; 1767c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1767d:	 800100               	add	byte ptr [rcx], 0
-;; 17680:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17689:	 800100               	add	byte ptr [rcx], 0
-;; 1768c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1768d:	 800100               	add	byte ptr [rcx], 0
-;; 17690:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17699:	 800100               	add	byte ptr [rcx], 0
-;; 1769c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1769d:	 800100               	add	byte ptr [rcx], 0
-;; 176a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 176a9:	 800100               	add	byte ptr [rcx], 0
-;; 176ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 176ad:	 800100               	add	byte ptr [rcx], 0
-;; 176b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 176b9:	 800100               	add	byte ptr [rcx], 0
-;; 176bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 176bd:	 800100               	add	byte ptr [rcx], 0
-;; 176c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 176c9:	 800100               	add	byte ptr [rcx], 0
-;; 176cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 176cd:	 800100               	add	byte ptr [rcx], 0
-;; 176d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 176d9:	 800100               	add	byte ptr [rcx], 0
-;; 176dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 176dd:	 800100               	add	byte ptr [rcx], 0
-;; 176e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 176e9:	 800100               	add	byte ptr [rcx], 0
-;; 176ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 176ed:	 800100               	add	byte ptr [rcx], 0
-;; 176f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 176f9:	 800100               	add	byte ptr [rcx], 0
-;; 176fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 176fd:	 800100               	add	byte ptr [rcx], 0
-;; 17700:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17709:	 800100               	add	byte ptr [rcx], 0
-;; 1770c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1770d:	 800100               	add	byte ptr [rcx], 0
-;; 17710:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17719:	 800100               	add	byte ptr [rcx], 0
-;; 1771c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1771d:	 800100               	add	byte ptr [rcx], 0
-;; 17720:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17729:	 800100               	add	byte ptr [rcx], 0
-;; 1772c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1772d:	 800100               	add	byte ptr [rcx], 0
-;; 17730:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17739:	 800100               	add	byte ptr [rcx], 0
-;; 1773c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1773d:	 800100               	add	byte ptr [rcx], 0
-;; 17740:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17749:	 800100               	add	byte ptr [rcx], 0
-;; 1774c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1774d:	 800100               	add	byte ptr [rcx], 0
-;; 17750:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17759:	 800100               	add	byte ptr [rcx], 0
-;; 1775c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1775d:	 800100               	add	byte ptr [rcx], 0
-;; 17760:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17769:	 800100               	add	byte ptr [rcx], 0
-;; 1776c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1776d:	 800100               	add	byte ptr [rcx], 0
-;; 17770:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17779:	 800100               	add	byte ptr [rcx], 0
-;; 1777c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1777d:	 800100               	add	byte ptr [rcx], 0
-;; 17780:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17789:	 800100               	add	byte ptr [rcx], 0
-;; 1778c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1778d:	 800100               	add	byte ptr [rcx], 0
-;; 17790:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17799:	 800100               	add	byte ptr [rcx], 0
-;; 1779c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1779d:	 800100               	add	byte ptr [rcx], 0
-;; 177a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 177a9:	 800100               	add	byte ptr [rcx], 0
-;; 177ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 177ad:	 800100               	add	byte ptr [rcx], 0
-;; 177b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 177b9:	 800100               	add	byte ptr [rcx], 0
-;; 177bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 177bd:	 800100               	add	byte ptr [rcx], 0
-;; 177c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 177c9:	 800100               	add	byte ptr [rcx], 0
-;; 177cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 177cd:	 800100               	add	byte ptr [rcx], 0
-;; 177d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 177d9:	 800100               	add	byte ptr [rcx], 0
-;; 177dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 177dd:	 800100               	add	byte ptr [rcx], 0
-;; 177e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 177e9:	 800100               	add	byte ptr [rcx], 0
-;; 177ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 177ed:	 800100               	add	byte ptr [rcx], 0
-;; 177f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 177f9:	 800100               	add	byte ptr [rcx], 0
-;; 177fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 177fd:	 800100               	add	byte ptr [rcx], 0
-;; 17800:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17809:	 800100               	add	byte ptr [rcx], 0
-;; 1780c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1780d:	 800100               	add	byte ptr [rcx], 0
-;; 17810:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17819:	 800100               	add	byte ptr [rcx], 0
-;; 1781c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1781d:	 800100               	add	byte ptr [rcx], 0
-;; 17820:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17829:	 800100               	add	byte ptr [rcx], 0
-;; 1782c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1782d:	 800100               	add	byte ptr [rcx], 0
-;; 17830:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17839:	 800100               	add	byte ptr [rcx], 0
-;; 1783c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1783d:	 800100               	add	byte ptr [rcx], 0
-;; 17840:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17849:	 800100               	add	byte ptr [rcx], 0
-;; 1784c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1784d:	 800100               	add	byte ptr [rcx], 0
-;; 17850:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17859:	 800100               	add	byte ptr [rcx], 0
-;; 1785c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1785d:	 800100               	add	byte ptr [rcx], 0
-;; 17860:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17869:	 800100               	add	byte ptr [rcx], 0
-;; 1786c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1786d:	 800100               	add	byte ptr [rcx], 0
-;; 17870:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17879:	 800100               	add	byte ptr [rcx], 0
-;; 1787c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1787d:	 800100               	add	byte ptr [rcx], 0
-;; 17880:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17889:	 800100               	add	byte ptr [rcx], 0
-;; 1788c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1788d:	 800100               	add	byte ptr [rcx], 0
-;; 17890:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17899:	 800100               	add	byte ptr [rcx], 0
-;; 1789c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1789d:	 800100               	add	byte ptr [rcx], 0
-;; 178a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 178a9:	 800100               	add	byte ptr [rcx], 0
-;; 178ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 178ad:	 800100               	add	byte ptr [rcx], 0
-;; 178b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 178b9:	 800100               	add	byte ptr [rcx], 0
-;; 178bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 178bd:	 800100               	add	byte ptr [rcx], 0
-;; 178c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 178c9:	 800100               	add	byte ptr [rcx], 0
-;; 178cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 178cd:	 800100               	add	byte ptr [rcx], 0
-;; 178d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 178d9:	 800100               	add	byte ptr [rcx], 0
-;; 178dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 178dd:	 800100               	add	byte ptr [rcx], 0
-;; 178e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 178e9:	 800100               	add	byte ptr [rcx], 0
-;; 178ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 178ed:	 800100               	add	byte ptr [rcx], 0
-;; 178f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 178f9:	 800100               	add	byte ptr [rcx], 0
-;; 178fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 178fd:	 800100               	add	byte ptr [rcx], 0
-;; 17900:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17909:	 800100               	add	byte ptr [rcx], 0
-;; 1790c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1790d:	 800100               	add	byte ptr [rcx], 0
-;; 17910:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17919:	 800100               	add	byte ptr [rcx], 0
-;; 1791c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1791d:	 800100               	add	byte ptr [rcx], 0
-;; 17920:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17929:	 800100               	add	byte ptr [rcx], 0
-;; 1792c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1792d:	 800100               	add	byte ptr [rcx], 0
-;; 17930:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17939:	 800100               	add	byte ptr [rcx], 0
-;; 1793c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1793d:	 800100               	add	byte ptr [rcx], 0
-;; 17940:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17949:	 800100               	add	byte ptr [rcx], 0
-;; 1794c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1794d:	 800100               	add	byte ptr [rcx], 0
-;; 17950:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17959:	 800100               	add	byte ptr [rcx], 0
-;; 1795c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1795d:	 800100               	add	byte ptr [rcx], 0
-;; 17960:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17969:	 800100               	add	byte ptr [rcx], 0
-;; 1796c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1796d:	 800100               	add	byte ptr [rcx], 0
-;; 17970:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17979:	 800100               	add	byte ptr [rcx], 0
-;; 1797c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1797d:	 800100               	add	byte ptr [rcx], 0
-;; 17980:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17989:	 800100               	add	byte ptr [rcx], 0
-;; 1798c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1798d:	 800100               	add	byte ptr [rcx], 0
-;; 17990:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17999:	 800100               	add	byte ptr [rcx], 0
-;; 1799c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1799d:	 800100               	add	byte ptr [rcx], 0
-;; 179a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 179a9:	 800100               	add	byte ptr [rcx], 0
-;; 179ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 179ad:	 800100               	add	byte ptr [rcx], 0
-;; 179b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 179b9:	 800100               	add	byte ptr [rcx], 0
-;; 179bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 179bd:	 800100               	add	byte ptr [rcx], 0
-;; 179c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 179c9:	 800100               	add	byte ptr [rcx], 0
-;; 179cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 179cd:	 800100               	add	byte ptr [rcx], 0
-;; 179d0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 179d9:	 800100               	add	byte ptr [rcx], 0
-;; 179dc:	 aa                   	stosb	byte ptr [rdi], al
-;; 179dd:	 800100               	add	byte ptr [rcx], 0
-;; 179e0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 179e9:	 800100               	add	byte ptr [rcx], 0
-;; 179ec:	 aa                   	stosb	byte ptr [rdi], al
-;; 179ed:	 800100               	add	byte ptr [rcx], 0
-;; 179f0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 179f9:	 800100               	add	byte ptr [rcx], 0
-;; 179fc:	 aa                   	stosb	byte ptr [rdi], al
-;; 179fd:	 800100               	add	byte ptr [rcx], 0
-;; 17a00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17a09:	 800100               	add	byte ptr [rcx], 0
-;; 17a0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17a0d:	 800100               	add	byte ptr [rcx], 0
-;; 17a10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17a19:	 800100               	add	byte ptr [rcx], 0
-;; 17a1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17a1d:	 800100               	add	byte ptr [rcx], 0
-;; 17a20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17a29:	 800100               	add	byte ptr [rcx], 0
-;; 17a2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17a2d:	 800100               	add	byte ptr [rcx], 0
-;; 17a30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17a39:	 800100               	add	byte ptr [rcx], 0
-;; 17a3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17a3d:	 800100               	add	byte ptr [rcx], 0
-;; 17a40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17a49:	 800100               	add	byte ptr [rcx], 0
-;; 17a4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17a4d:	 800100               	add	byte ptr [rcx], 0
-;; 17a50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17a59:	 800100               	add	byte ptr [rcx], 0
-;; 17a5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17a5d:	 800100               	add	byte ptr [rcx], 0
-;; 17a60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17a69:	 800100               	add	byte ptr [rcx], 0
-;; 17a6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17a6d:	 800100               	add	byte ptr [rcx], 0
-;; 17a70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17a79:	 800100               	add	byte ptr [rcx], 0
-;; 17a7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17a7d:	 800100               	add	byte ptr [rcx], 0
-;; 17a80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17a89:	 800100               	add	byte ptr [rcx], 0
-;; 17a8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17a8d:	 800100               	add	byte ptr [rcx], 0
-;; 17a90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17a99:	 800100               	add	byte ptr [rcx], 0
-;; 17a9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17a9d:	 800100               	add	byte ptr [rcx], 0
-;; 17aa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17aa9:	 800100               	add	byte ptr [rcx], 0
-;; 17aac:	 aa                   	stosb	byte ptr [rdi], al
-;; 17aad:	 800100               	add	byte ptr [rcx], 0
-;; 17ab0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17ab9:	 800100               	add	byte ptr [rcx], 0
-;; 17abc:	 aa                   	stosb	byte ptr [rdi], al
-;; 17abd:	 800100               	add	byte ptr [rcx], 0
-;; 17ac0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17ac9:	 800100               	add	byte ptr [rcx], 0
-;; 17acc:	 aa                   	stosb	byte ptr [rdi], al
-;; 17acd:	 800100               	add	byte ptr [rcx], 0
-;; 17ad0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17ad9:	 800100               	add	byte ptr [rcx], 0
-;; 17adc:	 aa                   	stosb	byte ptr [rdi], al
-;; 17add:	 800100               	add	byte ptr [rcx], 0
-;; 17ae0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17ae9:	 800100               	add	byte ptr [rcx], 0
-;; 17aec:	 aa                   	stosb	byte ptr [rdi], al
-;; 17aed:	 800100               	add	byte ptr [rcx], 0
-;; 17af0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17af9:	 800100               	add	byte ptr [rcx], 0
-;; 17afc:	 aa                   	stosb	byte ptr [rdi], al
-;; 17afd:	 800100               	add	byte ptr [rcx], 0
-;; 17b00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17b09:	 800100               	add	byte ptr [rcx], 0
-;; 17b0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17b0d:	 800100               	add	byte ptr [rcx], 0
-;; 17b10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17b19:	 800100               	add	byte ptr [rcx], 0
-;; 17b1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17b1d:	 800100               	add	byte ptr [rcx], 0
-;; 17b20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17b29:	 800100               	add	byte ptr [rcx], 0
-;; 17b2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17b2d:	 800100               	add	byte ptr [rcx], 0
-;; 17b30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17b39:	 800100               	add	byte ptr [rcx], 0
-;; 17b3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17b3d:	 800100               	add	byte ptr [rcx], 0
-;; 17b40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17b49:	 800100               	add	byte ptr [rcx], 0
-;; 17b4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17b4d:	 800100               	add	byte ptr [rcx], 0
-;; 17b50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17b59:	 800100               	add	byte ptr [rcx], 0
-;; 17b5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17b5d:	 800100               	add	byte ptr [rcx], 0
-;; 17b60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17b69:	 800100               	add	byte ptr [rcx], 0
-;; 17b6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17b6d:	 800100               	add	byte ptr [rcx], 0
-;; 17b70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17b79:	 800100               	add	byte ptr [rcx], 0
-;; 17b7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17b7d:	 800100               	add	byte ptr [rcx], 0
-;; 17b80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17b89:	 800100               	add	byte ptr [rcx], 0
-;; 17b8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17b8d:	 800100               	add	byte ptr [rcx], 0
-;; 17b90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17b99:	 800100               	add	byte ptr [rcx], 0
-;; 17b9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17b9d:	 800100               	add	byte ptr [rcx], 0
-;; 17ba0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17ba9:	 800100               	add	byte ptr [rcx], 0
-;; 17bac:	 aa                   	stosb	byte ptr [rdi], al
-;; 17bad:	 800100               	add	byte ptr [rcx], 0
-;; 17bb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17bb9:	 800100               	add	byte ptr [rcx], 0
-;; 17bbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 17bbd:	 800100               	add	byte ptr [rcx], 0
-;; 17bc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17bc9:	 800100               	add	byte ptr [rcx], 0
-;; 17bcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 17bcd:	 800100               	add	byte ptr [rcx], 0
-;; 17bd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17bd9:	 800100               	add	byte ptr [rcx], 0
-;; 17bdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 17bdd:	 800100               	add	byte ptr [rcx], 0
-;; 17be0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17be9:	 800100               	add	byte ptr [rcx], 0
-;; 17bec:	 aa                   	stosb	byte ptr [rdi], al
-;; 17bed:	 800100               	add	byte ptr [rcx], 0
-;; 17bf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17bf9:	 800100               	add	byte ptr [rcx], 0
-;; 17bfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 17bfd:	 800100               	add	byte ptr [rcx], 0
-;; 17c00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17c09:	 800100               	add	byte ptr [rcx], 0
-;; 17c0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17c0d:	 800100               	add	byte ptr [rcx], 0
-;; 17c10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17c19:	 800100               	add	byte ptr [rcx], 0
-;; 17c1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17c1d:	 800100               	add	byte ptr [rcx], 0
-;; 17c20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17c29:	 800100               	add	byte ptr [rcx], 0
-;; 17c2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17c2d:	 800100               	add	byte ptr [rcx], 0
-;; 17c30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17c39:	 800100               	add	byte ptr [rcx], 0
-;; 17c3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17c3d:	 800100               	add	byte ptr [rcx], 0
-;; 17c40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17c49:	 800100               	add	byte ptr [rcx], 0
-;; 17c4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17c4d:	 800100               	add	byte ptr [rcx], 0
-;; 17c50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17c59:	 800100               	add	byte ptr [rcx], 0
-;; 17c5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17c5d:	 800100               	add	byte ptr [rcx], 0
-;; 17c60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17c69:	 800100               	add	byte ptr [rcx], 0
-;; 17c6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17c6d:	 800100               	add	byte ptr [rcx], 0
-;; 17c70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17c79:	 800100               	add	byte ptr [rcx], 0
-;; 17c7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17c7d:	 800100               	add	byte ptr [rcx], 0
-;; 17c80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17c89:	 800100               	add	byte ptr [rcx], 0
-;; 17c8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17c8d:	 800100               	add	byte ptr [rcx], 0
-;; 17c90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17c99:	 800100               	add	byte ptr [rcx], 0
-;; 17c9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17c9d:	 800100               	add	byte ptr [rcx], 0
-;; 17ca0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17ca9:	 800100               	add	byte ptr [rcx], 0
-;; 17cac:	 aa                   	stosb	byte ptr [rdi], al
-;; 17cad:	 800100               	add	byte ptr [rcx], 0
-;; 17cb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17cb9:	 800100               	add	byte ptr [rcx], 0
-;; 17cbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 17cbd:	 800100               	add	byte ptr [rcx], 0
-;; 17cc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17cc9:	 800100               	add	byte ptr [rcx], 0
-;; 17ccc:	 aa                   	stosb	byte ptr [rdi], al
-;; 17ccd:	 800100               	add	byte ptr [rcx], 0
-;; 17cd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17cd9:	 800100               	add	byte ptr [rcx], 0
-;; 17cdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 17cdd:	 800100               	add	byte ptr [rcx], 0
-;; 17ce0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17ce9:	 800100               	add	byte ptr [rcx], 0
-;; 17cec:	 aa                   	stosb	byte ptr [rdi], al
-;; 17ced:	 800100               	add	byte ptr [rcx], 0
-;; 17cf0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17cf9:	 800100               	add	byte ptr [rcx], 0
-;; 17cfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 17cfd:	 800100               	add	byte ptr [rcx], 0
-;; 17d00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17d09:	 800100               	add	byte ptr [rcx], 0
-;; 17d0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17d0d:	 800100               	add	byte ptr [rcx], 0
-;; 17d10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17d19:	 800100               	add	byte ptr [rcx], 0
-;; 17d1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17d1d:	 800100               	add	byte ptr [rcx], 0
-;; 17d20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17d29:	 800100               	add	byte ptr [rcx], 0
-;; 17d2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17d2d:	 800100               	add	byte ptr [rcx], 0
-;; 17d30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17d39:	 800100               	add	byte ptr [rcx], 0
-;; 17d3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17d3d:	 800100               	add	byte ptr [rcx], 0
-;; 17d40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17d49:	 800100               	add	byte ptr [rcx], 0
-;; 17d4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17d4d:	 800100               	add	byte ptr [rcx], 0
-;; 17d50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17d59:	 800100               	add	byte ptr [rcx], 0
-;; 17d5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17d5d:	 800100               	add	byte ptr [rcx], 0
-;; 17d60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17d69:	 800100               	add	byte ptr [rcx], 0
-;; 17d6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17d6d:	 800100               	add	byte ptr [rcx], 0
-;; 17d70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17d79:	 800100               	add	byte ptr [rcx], 0
-;; 17d7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17d7d:	 800100               	add	byte ptr [rcx], 0
-;; 17d80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17d89:	 800100               	add	byte ptr [rcx], 0
-;; 17d8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17d8d:	 800100               	add	byte ptr [rcx], 0
-;; 17d90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17d99:	 800100               	add	byte ptr [rcx], 0
-;; 17d9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17d9d:	 800100               	add	byte ptr [rcx], 0
-;; 17da0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17da9:	 800100               	add	byte ptr [rcx], 0
-;; 17dac:	 aa                   	stosb	byte ptr [rdi], al
-;; 17dad:	 800100               	add	byte ptr [rcx], 0
-;; 17db0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17db9:	 800100               	add	byte ptr [rcx], 0
-;; 17dbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 17dbd:	 800100               	add	byte ptr [rcx], 0
-;; 17dc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17dc9:	 800100               	add	byte ptr [rcx], 0
-;; 17dcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 17dcd:	 800100               	add	byte ptr [rcx], 0
-;; 17dd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17dd9:	 800100               	add	byte ptr [rcx], 0
-;; 17ddc:	 aa                   	stosb	byte ptr [rdi], al
-;; 17ddd:	 800100               	add	byte ptr [rcx], 0
-;; 17de0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17de9:	 800100               	add	byte ptr [rcx], 0
-;; 17dec:	 aa                   	stosb	byte ptr [rdi], al
-;; 17ded:	 800100               	add	byte ptr [rcx], 0
-;; 17df0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17df9:	 800100               	add	byte ptr [rcx], 0
-;; 17dfc:	 aa                   	stosb	byte ptr [rdi], al
-;; 17dfd:	 800100               	add	byte ptr [rcx], 0
-;; 17e00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17e09:	 800100               	add	byte ptr [rcx], 0
-;; 17e0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17e0d:	 800100               	add	byte ptr [rcx], 0
-;; 17e10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17e19:	 800100               	add	byte ptr [rcx], 0
-;; 17e1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17e1d:	 800100               	add	byte ptr [rcx], 0
-;; 17e20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17e29:	 800100               	add	byte ptr [rcx], 0
-;; 17e2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17e2d:	 800100               	add	byte ptr [rcx], 0
-;; 17e30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17e39:	 800100               	add	byte ptr [rcx], 0
-;; 17e3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17e3d:	 800100               	add	byte ptr [rcx], 0
-;; 17e40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17e49:	 800100               	add	byte ptr [rcx], 0
-;; 17e4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17e4d:	 800100               	add	byte ptr [rcx], 0
-;; 17e50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17e59:	 800100               	add	byte ptr [rcx], 0
-;; 17e5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17e5d:	 800100               	add	byte ptr [rcx], 0
-;; 17e60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17e69:	 800100               	add	byte ptr [rcx], 0
-;; 17e6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17e6d:	 800100               	add	byte ptr [rcx], 0
-;; 17e70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17e79:	 800100               	add	byte ptr [rcx], 0
-;; 17e7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17e7d:	 800100               	add	byte ptr [rcx], 0
-;; 17e80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17e89:	 800100               	add	byte ptr [rcx], 0
-;; 17e8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17e8d:	 800100               	add	byte ptr [rcx], 0
-;; 17e90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17e99:	 800100               	add	byte ptr [rcx], 0
-;; 17e9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17e9d:	 800100               	add	byte ptr [rcx], 0
-;; 17ea0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17ea9:	 800100               	add	byte ptr [rcx], 0
-;; 17eac:	 aa                   	stosb	byte ptr [rdi], al
-;; 17ead:	 800100               	add	byte ptr [rcx], 0
-;; 17eb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17eb9:	 800100               	add	byte ptr [rcx], 0
-;; 17ebc:	 aa                   	stosb	byte ptr [rdi], al
-;; 17ebd:	 800100               	add	byte ptr [rcx], 0
-;; 17ec0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17ec9:	 800100               	add	byte ptr [rcx], 0
-;; 17ecc:	 aa                   	stosb	byte ptr [rdi], al
-;; 17ecd:	 800100               	add	byte ptr [rcx], 0
-;; 17ed0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17ed9:	 800100               	add	byte ptr [rcx], 0
-;; 17edc:	 aa                   	stosb	byte ptr [rdi], al
-;; 17edd:	 800100               	add	byte ptr [rcx], 0
-;; 17ee0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17ee9:	 800100               	add	byte ptr [rcx], 0
-;; 17eec:	 aa                   	stosb	byte ptr [rdi], al
-;; 17eed:	 800100               	add	byte ptr [rcx], 0
-;; 17ef0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17ef9:	 800100               	add	byte ptr [rcx], 0
-;; 17efc:	 aa                   	stosb	byte ptr [rdi], al
-;; 17efd:	 800100               	add	byte ptr [rcx], 0
-;; 17f00:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17f09:	 800100               	add	byte ptr [rcx], 0
-;; 17f0c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17f0d:	 800100               	add	byte ptr [rcx], 0
-;; 17f10:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17f19:	 800100               	add	byte ptr [rcx], 0
-;; 17f1c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17f1d:	 800100               	add	byte ptr [rcx], 0
-;; 17f20:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17f29:	 800100               	add	byte ptr [rcx], 0
-;; 17f2c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17f2d:	 800100               	add	byte ptr [rcx], 0
-;; 17f30:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17f39:	 800100               	add	byte ptr [rcx], 0
-;; 17f3c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17f3d:	 800100               	add	byte ptr [rcx], 0
-;; 17f40:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17f49:	 800100               	add	byte ptr [rcx], 0
-;; 17f4c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17f4d:	 800100               	add	byte ptr [rcx], 0
-;; 17f50:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17f59:	 800100               	add	byte ptr [rcx], 0
-;; 17f5c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17f5d:	 800100               	add	byte ptr [rcx], 0
-;; 17f60:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17f69:	 800100               	add	byte ptr [rcx], 0
-;; 17f6c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17f6d:	 800100               	add	byte ptr [rcx], 0
-;; 17f70:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17f79:	 800100               	add	byte ptr [rcx], 0
-;; 17f7c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17f7d:	 800100               	add	byte ptr [rcx], 0
-;; 17f80:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17f89:	 800100               	add	byte ptr [rcx], 0
-;; 17f8c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17f8d:	 800100               	add	byte ptr [rcx], 0
-;; 17f90:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17f99:	 800100               	add	byte ptr [rcx], 0
-;; 17f9c:	 aa                   	stosb	byte ptr [rdi], al
-;; 17f9d:	 800100               	add	byte ptr [rcx], 0
-;; 17fa0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17fa9:	 800100               	add	byte ptr [rcx], 0
-;; 17fac:	 aa                   	stosb	byte ptr [rdi], al
-;; 17fad:	 800100               	add	byte ptr [rcx], 0
-;; 17fb0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17fb9:	 800100               	add	byte ptr [rcx], 0
-;; 17fbc:	 aa                   	stosb	byte ptr [rdi], al
-;; 17fbd:	 800100               	add	byte ptr [rcx], 0
-;; 17fc0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17fc9:	 800100               	add	byte ptr [rcx], 0
-;; 17fcc:	 aa                   	stosb	byte ptr [rdi], al
-;; 17fcd:	 800100               	add	byte ptr [rcx], 0
-;; 17fd0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17fd9:	 800100               	add	byte ptr [rcx], 0
-;; 17fdc:	 aa                   	stosb	byte ptr [rdi], al
-;; 17fdd:	 800100               	add	byte ptr [rcx], 0
-;; 17fe0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17fe9:	 800100               	add	byte ptr [rcx], 0
-;; 17fec:	 aa                   	stosb	byte ptr [rdi], al
-;; 17fed:	 800100               	add	byte ptr [rcx], 0
-;; 17ff0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 17ff9:	 800100               	add	byte ptr [rcx], 0
-;; 17ffc:	 aa                   	stosb	byte ptr [rdi], al
-;; 17ffd:	 800100               	add	byte ptr [rcx], 0
-;; 18000:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 18009:	 800100               	add	byte ptr [rcx], 0
-;; 1800c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1800d:	 800100               	add	byte ptr [rcx], 0
-;; 18010:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 18019:	 800100               	add	byte ptr [rcx], 0
-;; 1801c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1801d:	 800100               	add	byte ptr [rcx], 0
-;; 18020:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 18029:	 800100               	add	byte ptr [rcx], 0
-;; 1802c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1802d:	 800100               	add	byte ptr [rcx], 0
-;; 18030:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 18039:	 800100               	add	byte ptr [rcx], 0
-;; 1803c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1803d:	 800100               	add	byte ptr [rcx], 0
-;; 18040:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 18049:	 800100               	add	byte ptr [rcx], 0
-;; 1804c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1804d:	 800100               	add	byte ptr [rcx], 0
-;; 18050:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 18059:	 800100               	add	byte ptr [rcx], 0
-;; 1805c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1805d:	 800100               	add	byte ptr [rcx], 0
-;; 18060:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 18069:	 800100               	add	byte ptr [rcx], 0
-;; 1806c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1806d:	 800100               	add	byte ptr [rcx], 0
-;; 18070:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 18079:	 800100               	add	byte ptr [rcx], 0
-;; 1807c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1807d:	 800100               	add	byte ptr [rcx], 0
-;; 18080:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 18089:	 800100               	add	byte ptr [rcx], 0
-;; 1808c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1808d:	 800100               	add	byte ptr [rcx], 0
-;; 18090:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 18099:	 800100               	add	byte ptr [rcx], 0
-;; 1809c:	 aa                   	stosb	byte ptr [rdi], al
-;; 1809d:	 800100               	add	byte ptr [rcx], 0
-;; 180a0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 180a9:	 800100               	add	byte ptr [rcx], 0
-;; 180ac:	 aa                   	stosb	byte ptr [rdi], al
-;; 180ad:	 800100               	add	byte ptr [rcx], 0
-;; 180b0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 180b9:	 800100               	add	byte ptr [rcx], 0
-;; 180bc:	 aa                   	stosb	byte ptr [rdi], al
-;; 180bd:	 800100               	add	byte ptr [rcx], 0
-;; 180c0:	 a0800100aa800100a0   	
-;; 				movabs	al, byte ptr [0xa0000180aa000180]
-;; 180c9:	 800100               	add	byte ptr [rcx], 0
-;; 180cc:	 aa                   	stosb	byte ptr [rdi], al
-;; 180cd:	 800100               	add	byte ptr [rcx], 0
-;; 180d0:	 b800000000           	mov	eax, 0
-;; 180d5:	 e905000000           	jmp	0x180df
-;; 180da:	 b801000000           	mov	eax, 1
-;; 180df:	 4883c410             	add	rsp, 0x10
-;; 180e3:	 5d                   	pop	rbp
-;; 180e4:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/br_table/nested_br_table_loop_block.wat b/winch/filetests/filetests/x64/br_table/nested_br_table_loop_block.wat
deleted file mode 100644
index 155d8d664adc..000000000000
--- a/winch/filetests/filetests/x64/br_table/nested_br_table_loop_block.wat
+++ /dev/null
@@ -1,33 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func (export "nested-br_table-loop-block") (param i32) (result i32)
-    (local.set 0
-      (loop (result i32)
-        (block
-          (br_table 1 0 0 (local.get 0))
-        )
-        (i32.const 0)
-      )
-    )
-    (loop (result i32)
-      (block
-        (br_table 0 1 1 (local.get 0))
-      )
-      (i32.const 3)
-    )
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   11:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   15:	 b902000000           	mov	ecx, 2
-;;   1a:	 39c1                 	cmp	ecx, eax
-;;   1c:	 0f42c1               	cmovb	eax, ecx
-;;   1f:	 4c8d1d0a000000       	lea	r11, [rip + 0xa]
-;;   26:	 49630c83             	movsxd	rcx, dword ptr [r11 + rax*4]
-;;   2a:	 4901cb               	add	r11, rcx
-;;   2d:	 41ffe3               	jmp	r11
-;;   30:	 e1ff                 	loope	0x31
diff --git a/winch/filetests/filetests/x64/call/params.wat b/winch/filetests/filetests/x64/call/params.wat
deleted file mode 100644
index dc284497bffa..000000000000
--- a/winch/filetests/filetests/x64/call/params.wat
+++ /dev/null
@@ -1,123 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func (export "main") (param i32) (param i32) (result i32)
-    (local.get 1)
-    (local.get 0)
-    (i32.div_u)
-
-    (call $add (i32.const 1) (i32.const 2) (i32.const 3) (i32.const 4) (i32.const 5) (i32.const 6) (i32.const 7) (i32.const 8))
-
-    (local.get 1)
-    (local.get 0)
-    (i32.div_u)
-
-    (call $add (i32.const 2) (i32.const 3) (i32.const 4) (i32.const 5) (i32.const 6) (i32.const 7) (i32.const 8))
-  )
-
-  (func $add (param i32 i32 i32 i32 i32 i32 i32 i32 i32) (result i32)
-    (local.get 0)
-    (local.get 1)
-    (i32.add)
-    (local.get 2)
-    (i32.add)
-    (local.get 3)
-    (i32.add)
-    (local.get 4)
-    (i32.add)
-    (local.get 5)
-    (i32.add)
-    (local.get 6)
-    (i32.add)
-    (local.get 7)
-    (i32.add)
-    (local.get 8)
-    (i32.add)
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   18:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   1c:	 31d2                 	xor	edx, edx
-;;   1e:	 f7f1                 	div	ecx
-;;   20:	 50                   	push	rax
-;;   21:	 4883ec28             	sub	rsp, 0x28
-;;   25:	 8b7c2428             	mov	edi, dword ptr [rsp + 0x28]
-;;   29:	 be01000000           	mov	esi, 1
-;;   2e:	 ba02000000           	mov	edx, 2
-;;   33:	 b903000000           	mov	ecx, 3
-;;   38:	 41b804000000         	mov	r8d, 4
-;;   3e:	 41b905000000         	mov	r9d, 5
-;;   44:	 41bb06000000         	mov	r11d, 6
-;;   4a:	 44891c24             	mov	dword ptr [rsp], r11d
-;;   4e:	 41bb07000000         	mov	r11d, 7
-;;   54:	 44895c2408           	mov	dword ptr [rsp + 8], r11d
-;;   59:	 41bb08000000         	mov	r11d, 8
-;;   5f:	 44895c2410           	mov	dword ptr [rsp + 0x10], r11d
-;;   64:	 e800000000           	call	0x69
-;;   69:	 4883c430             	add	rsp, 0x30
-;;   6d:	 50                   	push	rax
-;;   6e:	 448b5c2410           	mov	r11d, dword ptr [rsp + 0x10]
-;;   73:	 4153                 	push	r11
-;;   75:	 448b5c241c           	mov	r11d, dword ptr [rsp + 0x1c]
-;;   7a:	 4153                 	push	r11
-;;   7c:	 59                   	pop	rcx
-;;   7d:	 58                   	pop	rax
-;;   7e:	 31d2                 	xor	edx, edx
-;;   80:	 f7f1                 	div	ecx
-;;   82:	 50                   	push	rax
-;;   83:	 4883ec20             	sub	rsp, 0x20
-;;   87:	 8b7c2428             	mov	edi, dword ptr [rsp + 0x28]
-;;   8b:	 8b742420             	mov	esi, dword ptr [rsp + 0x20]
-;;   8f:	 ba02000000           	mov	edx, 2
-;;   94:	 b903000000           	mov	ecx, 3
-;;   99:	 41b804000000         	mov	r8d, 4
-;;   9f:	 41b905000000         	mov	r9d, 5
-;;   a5:	 41bb06000000         	mov	r11d, 6
-;;   ab:	 44891c24             	mov	dword ptr [rsp], r11d
-;;   af:	 41bb07000000         	mov	r11d, 7
-;;   b5:	 44895c2408           	mov	dword ptr [rsp + 8], r11d
-;;   ba:	 41bb08000000         	mov	r11d, 8
-;;   c0:	 44895c2410           	mov	dword ptr [rsp + 0x10], r11d
-;;   c5:	 e800000000           	call	0xca
-;;   ca:	 4883c430             	add	rsp, 0x30
-;;   ce:	 4883c410             	add	rsp, 0x10
-;;   d2:	 5d                   	pop	rbp
-;;   d3:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec20             	sub	rsp, 0x20
-;;    8:	 897c241c             	mov	dword ptr [rsp + 0x1c], edi
-;;    c:	 89742418             	mov	dword ptr [rsp + 0x18], esi
-;;   10:	 89542414             	mov	dword ptr [rsp + 0x14], edx
-;;   14:	 894c2410             	mov	dword ptr [rsp + 0x10], ecx
-;;   18:	 448944240c           	mov	dword ptr [rsp + 0xc], r8d
-;;   1d:	 44894c2408           	mov	dword ptr [rsp + 8], r9d
-;;   22:	 4c893424             	mov	qword ptr [rsp], r14
-;;   26:	 8b442418             	mov	eax, dword ptr [rsp + 0x18]
-;;   2a:	 8b4c241c             	mov	ecx, dword ptr [rsp + 0x1c]
-;;   2e:	 01c1                 	add	ecx, eax
-;;   30:	 8b442414             	mov	eax, dword ptr [rsp + 0x14]
-;;   34:	 01c1                 	add	ecx, eax
-;;   36:	 8b442410             	mov	eax, dword ptr [rsp + 0x10]
-;;   3a:	 01c1                 	add	ecx, eax
-;;   3c:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   40:	 01c1                 	add	ecx, eax
-;;   42:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   46:	 01c1                 	add	ecx, eax
-;;   48:	 8b4510               	mov	eax, dword ptr [rbp + 0x10]
-;;   4b:	 01c1                 	add	ecx, eax
-;;   4d:	 8b4518               	mov	eax, dword ptr [rbp + 0x18]
-;;   50:	 01c1                 	add	ecx, eax
-;;   52:	 8b4520               	mov	eax, dword ptr [rbp + 0x20]
-;;   55:	 01c1                 	add	ecx, eax
-;;   57:	 89c8                 	mov	eax, ecx
-;;   59:	 4883c420             	add	rsp, 0x20
-;;   5d:	 5d                   	pop	rbp
-;;   5e:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/call/recursive.wat b/winch/filetests/filetests/x64/call/recursive.wat
deleted file mode 100644
index e430a9e7fc46..000000000000
--- a/winch/filetests/filetests/x64/call/recursive.wat
+++ /dev/null
@@ -1,57 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func $fibonacci8 (param $n i32) (result i32)
-    (if (result i32) (i32.le_s (local.get $n) (i32.const 1))
-      (then
-        ;; If n <= 1, return n (base case)
-        (local.get $n)
-      )
-      (else
-        ;; Else, return fibonacci(n - 1) + fibonacci(n - 2)
-        (i32.add
-          (call $fibonacci8
-            (i32.sub (local.get $n) (i32.const 1)) ;; Calculate n - 1
-          )
-          (call $fibonacci8
-            (i32.sub (local.get $n) (i32.const 2)) ;; Calculate n - 2
-          )
-        )
-      )
-    )
-  )
-  (export "fib" (func $fibonacci8))
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   11:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   15:	 83f801               	cmp	eax, 1
-;;   18:	 b800000000           	mov	eax, 0
-;;   1d:	 400f9ec0             	setle	al
-;;   21:	 85c0                 	test	eax, eax
-;;   23:	 0f8409000000         	je	0x32
-;;   29:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   2d:	 e933000000           	jmp	0x65
-;;   32:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   36:	 83e801               	sub	eax, 1
-;;   39:	 50                   	push	rax
-;;   3a:	 4883ec08             	sub	rsp, 8
-;;   3e:	 8b7c2408             	mov	edi, dword ptr [rsp + 8]
-;;   42:	 e800000000           	call	0x47
-;;   47:	 4883c410             	add	rsp, 0x10
-;;   4b:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   4f:	 83e902               	sub	ecx, 2
-;;   52:	 50                   	push	rax
-;;   53:	 51                   	push	rcx
-;;   54:	 8b3c24               	mov	edi, dword ptr [rsp]
-;;   57:	 e800000000           	call	0x5c
-;;   5c:	 4883c408             	add	rsp, 8
-;;   60:	 59                   	pop	rcx
-;;   61:	 01c1                 	add	ecx, eax
-;;   63:	 89c8                 	mov	eax, ecx
-;;   65:	 4883c410             	add	rsp, 0x10
-;;   69:	 5d                   	pop	rbp
-;;   6a:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/call/simple.wat b/winch/filetests/filetests/x64/call/simple.wat
deleted file mode 100644
index 2eff06872559..000000000000
--- a/winch/filetests/filetests/x64/call/simple.wat
+++ /dev/null
@@ -1,50 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func $main (result i32)
-    (local $var i32)
-    (call $product (i32.const 20) (i32.const 80))
-    (local.set $var (i32.const 2))
-    (local.get $var)
-    (i32.div_u))
-
-  (func $product (param i32 i32) (result i32)
-    (local.get 0)
-    (local.get 1)
-    (i32.mul))
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   16:	 bf14000000           	mov	edi, 0x14
-;;   1b:	 be50000000           	mov	esi, 0x50
-;;   20:	 e800000000           	call	0x25
-;;   25:	 b902000000           	mov	ecx, 2
-;;   2a:	 894c240c             	mov	dword ptr [rsp + 0xc], ecx
-;;   2e:	 50                   	push	rax
-;;   2f:	 448b5c2414           	mov	r11d, dword ptr [rsp + 0x14]
-;;   34:	 4153                 	push	r11
-;;   36:	 59                   	pop	rcx
-;;   37:	 58                   	pop	rax
-;;   38:	 31d2                 	xor	edx, edx
-;;   3a:	 f7f1                 	div	ecx
-;;   3c:	 4883c410             	add	rsp, 0x10
-;;   40:	 5d                   	pop	rbp
-;;   41:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   18:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   1c:	 0fafc8               	imul	ecx, eax
-;;   1f:	 89c8                 	mov	eax, ecx
-;;   21:	 4883c410             	add	rsp, 0x10
-;;   25:	 5d                   	pop	rbp
-;;   26:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/call_indirect/call_indirect.wat b/winch/filetests/filetests/x64/call_indirect/call_indirect.wat
deleted file mode 100644
index b2dd60224111..000000000000
--- a/winch/filetests/filetests/x64/call_indirect/call_indirect.wat
+++ /dev/null
@@ -1,130 +0,0 @@
-;;! target="x86_64"
-
-(module
-  (type $over-i32 (func (param i32) (result i32)))
-
-  (table funcref
-    (elem
-      $fib-i32
-    )
-  )
-  
-  (func $fib-i32 (export "fib-i32") (type $over-i32)
-    (if (result i32) (i32.le_u (local.get 0) (i32.const 1))
-      (then (i32.const 1))
-      (else
-        (i32.add
-          (call_indirect (type $over-i32)
-            (i32.sub (local.get 0) (i32.const 2))
-            (i32.const 0)
-          )
-          (call_indirect (type $over-i32)
-            (i32.sub (local.get 0) (i32.const 1))
-            (i32.const 0)
-          )
-        )
-      )
-    )
-  )
-)
-
-
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   11:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   15:	 83f801               	cmp	eax, 1
-;;   18:	 b800000000           	mov	eax, 0
-;;   1d:	 400f96c0             	setbe	al
-;;   21:	 85c0                 	test	eax, eax
-;;   23:	 0f840a000000         	je	0x33
-;;   29:	 b801000000           	mov	eax, 1
-;;   2e:	 e913010000           	jmp	0x146
-;;   33:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   37:	 83e802               	sub	eax, 2
-;;   3a:	 50                   	push	rax
-;;   3b:	 4d8b5e38             	mov	r11, qword ptr [r14 + 0x38]
-;;   3f:	 498b4b48             	mov	rcx, qword ptr [r11 + 0x48]
-;;   43:	 bb00000000           	mov	ebx, 0
-;;   48:	 4d89f1               	mov	r9, r14
-;;   4b:	 4d8b4150             	mov	r8, qword ptr [r9 + 0x50]
-;;   4f:	 4439c3               	cmp	ebx, r8d
-;;   52:	 0f83f4000000         	jae	0x14c
-;;   58:	 4189db               	mov	r11d, ebx
-;;   5b:	 4d6bdb08             	imul	r11, r11, 8
-;;   5f:	 4d8b4948             	mov	r9, qword ptr [r9 + 0x48]
-;;   63:	 4d89ca               	mov	r10, r9
-;;   66:	 4d01d9               	add	r9, r11
-;;   69:	 4439c3               	cmp	ebx, r8d
-;;   6c:	 4d0f43ca             	cmovae	r9, r10
-;;   70:	 4d8b09               	mov	r9, qword ptr [r9]
-;;   73:	 4c89c8               	mov	rax, r9
-;;   76:	 4d85c9               	test	r9, r9
-;;   79:	 0f8519000000         	jne	0x98
-;;   7f:	 4883ec08             	sub	rsp, 8
-;;   83:	 4c89f7               	mov	rdi, r14
-;;   86:	 be00000000           	mov	esi, 0
-;;   8b:	 89da                 	mov	edx, ebx
-;;   8d:	 ffd1                 	call	rcx
-;;   8f:	 4883c408             	add	rsp, 8
-;;   93:	 e904000000           	jmp	0x9c
-;;   98:	 4883e0fe             	and	rax, 0xfffffffffffffffe
-;;   9c:	 4d8b5e40             	mov	r11, qword ptr [r14 + 0x40]
-;;   a0:	 418b0b               	mov	ecx, dword ptr [r11]
-;;   a3:	 8b5018               	mov	edx, dword ptr [rax + 0x18]
-;;   a6:	 39d1                 	cmp	ecx, edx
-;;   a8:	 0f85a0000000         	jne	0x14e
-;;   ae:	 488b4810             	mov	rcx, qword ptr [rax + 0x10]
-;;   b2:	 4883ec08             	sub	rsp, 8
-;;   b6:	 8b7c2408             	mov	edi, dword ptr [rsp + 8]
-;;   ba:	 ffd1                 	call	rcx
-;;   bc:	 4883c410             	add	rsp, 0x10
-;;   c0:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   c4:	 83e901               	sub	ecx, 1
-;;   c7:	 50                   	push	rax
-;;   c8:	 51                   	push	rcx
-;;   c9:	 4d8b5e38             	mov	r11, qword ptr [r14 + 0x38]
-;;   cd:	 498b4b48             	mov	rcx, qword ptr [r11 + 0x48]
-;;   d1:	 bb00000000           	mov	ebx, 0
-;;   d6:	 4d89f1               	mov	r9, r14
-;;   d9:	 4d8b4150             	mov	r8, qword ptr [r9 + 0x50]
-;;   dd:	 4439c3               	cmp	ebx, r8d
-;;   e0:	 0f836a000000         	jae	0x150
-;;   e6:	 4189db               	mov	r11d, ebx
-;;   e9:	 4d6bdb08             	imul	r11, r11, 8
-;;   ed:	 4d8b4948             	mov	r9, qword ptr [r9 + 0x48]
-;;   f1:	 4d89ca               	mov	r10, r9
-;;   f4:	 4d01d9               	add	r9, r11
-;;   f7:	 4439c3               	cmp	ebx, r8d
-;;   fa:	 4d0f43ca             	cmovae	r9, r10
-;;   fe:	 4d8b09               	mov	r9, qword ptr [r9]
-;;  101:	 4c89c8               	mov	rax, r9
-;;  104:	 4d85c9               	test	r9, r9
-;;  107:	 0f8511000000         	jne	0x11e
-;;  10d:	 4c89f7               	mov	rdi, r14
-;;  110:	 be00000000           	mov	esi, 0
-;;  115:	 89da                 	mov	edx, ebx
-;;  117:	 ffd1                 	call	rcx
-;;  119:	 e904000000           	jmp	0x122
-;;  11e:	 4883e0fe             	and	rax, 0xfffffffffffffffe
-;;  122:	 4d8b5e40             	mov	r11, qword ptr [r14 + 0x40]
-;;  126:	 418b0b               	mov	ecx, dword ptr [r11]
-;;  129:	 8b5018               	mov	edx, dword ptr [rax + 0x18]
-;;  12c:	 39d1                 	cmp	ecx, edx
-;;  12e:	 0f851e000000         	jne	0x152
-;;  134:	 488b4810             	mov	rcx, qword ptr [rax + 0x10]
-;;  138:	 8b3c24               	mov	edi, dword ptr [rsp]
-;;  13b:	 ffd1                 	call	rcx
-;;  13d:	 4883c408             	add	rsp, 8
-;;  141:	 59                   	pop	rcx
-;;  142:	 01c1                 	add	ecx, eax
-;;  144:	 89c8                 	mov	eax, ecx
-;;  146:	 4883c410             	add	rsp, 0x10
-;;  14a:	 5d                   	pop	rbp
-;;  14b:	 c3                   	ret	
-;;  14c:	 0f0b                 	ud2	
-;;  14e:	 0f0b                 	ud2	
-;;  150:	 0f0b                 	ud2	
-;;  152:	 0f0b                 	ud2	
diff --git a/winch/filetests/filetests/x64/f32_abs/f32_abs_const.wat b/winch/filetests/filetests/x64/f32_abs/f32_abs_const.wat
deleted file mode 100644
index 7500e7a462b2..000000000000
--- a/winch/filetests/filetests/x64/f32_abs/f32_abs_const.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result f32)
-        (f32.const -1.32)
-        (f32.abs)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 f30f10051c000000     	movss	xmm0, dword ptr [rip + 0x1c]
-;;   14:	 41bbffffff7f         	mov	r11d, 0x7fffffff
-;;   1a:	 66450f6efb           	movd	xmm15, r11d
-;;   1f:	 410f54c7             	andps	xmm0, xmm15
-;;   23:	 4883c408             	add	rsp, 8
-;;   27:	 5d                   	pop	rbp
-;;   28:	 c3                   	ret	
-;;   29:	 0000                 	add	byte ptr [rax], al
-;;   2b:	 0000                 	add	byte ptr [rax], al
-;;   2d:	 0000                 	add	byte ptr [rax], al
-;;   2f:	 00c3                 	add	bl, al
-;;   31:	 f5                   	cmc	
-;;   32:	 a8bf                 	test	al, 0xbf
diff --git a/winch/filetests/filetests/x64/f32_abs/f32_abs_param.wat b/winch/filetests/filetests/x64/f32_abs/f32_abs_param.wat
deleted file mode 100644
index b2cc9206af77..000000000000
--- a/winch/filetests/filetests/x64/f32_abs/f32_abs_param.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param f32) (result f32)
-        (local.get 0)
-        (f32.abs)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 f30f1144240c         	movss	dword ptr [rsp + 0xc], xmm0
-;;    e:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   13:	 f30f1044240c         	movss	xmm0, dword ptr [rsp + 0xc]
-;;   19:	 41bbffffff7f         	mov	r11d, 0x7fffffff
-;;   1f:	 66450f6efb           	movd	xmm15, r11d
-;;   24:	 410f54c7             	andps	xmm0, xmm15
-;;   28:	 4883c410             	add	rsp, 0x10
-;;   2c:	 5d                   	pop	rbp
-;;   2d:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/f32_ceil/f32_ceil_const_sse41.wat b/winch/filetests/filetests/x64/f32_ceil/f32_ceil_const_sse41.wat
deleted file mode 100644
index 857140aee665..000000000000
--- a/winch/filetests/filetests/x64/f32_ceil/f32_ceil_const_sse41.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_sse41"]
-
-(module
-    (func (result f32)
-        (f32.const -1.32)
-        (f32.ceil)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 f30f10050c000000     	movss	xmm0, dword ptr [rip + 0xc]
-;;   14:	 660f3a0ac002         	roundss	xmm0, xmm0, 2
-;;   1a:	 4883c408             	add	rsp, 8
-;;   1e:	 5d                   	pop	rbp
-;;   1f:	 c3                   	ret	
-;;   20:	 c3                   	ret	
-;;   21:	 f5                   	cmc	
-;;   22:	 a8bf                 	test	al, 0xbf
diff --git a/winch/filetests/filetests/x64/f32_ceil/f32_ceil_param_sse41.wat b/winch/filetests/filetests/x64/f32_ceil/f32_ceil_param_sse41.wat
deleted file mode 100644
index 9ad6428f5be1..000000000000
--- a/winch/filetests/filetests/x64/f32_ceil/f32_ceil_param_sse41.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_sse41"]
-
-(module
-    (func (param f32) (result f32)
-        (local.get 0)
-        (f32.ceil)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 f30f1144240c         	movss	dword ptr [rsp + 0xc], xmm0
-;;    e:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   13:	 f30f1044240c         	movss	xmm0, dword ptr [rsp + 0xc]
-;;   19:	 660f3a0ac002         	roundss	xmm0, xmm0, 2
-;;   1f:	 4883c410             	add	rsp, 0x10
-;;   23:	 5d                   	pop	rbp
-;;   24:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/f32_const/call_id.wat b/winch/filetests/filetests/x64/f32_const/call_id.wat
deleted file mode 100644
index 13b3330abf7b..000000000000
--- a/winch/filetests/filetests/x64/f32_const/call_id.wat
+++ /dev/null
@@ -1,30 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func $id-f32 (param f32) (result f32) (local.get 0))
-  (func (export "type-first-f32") (result f32) (call $id-f32 (f32.const 1.32)))
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 f30f1144240c         	movss	dword ptr [rsp + 0xc], xmm0
-;;    e:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   13:	 f30f1044240c         	movss	xmm0, dword ptr [rsp + 0xc]
-;;   19:	 4883c410             	add	rsp, 0x10
-;;   1d:	 5d                   	pop	rbp
-;;   1e:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 f30f100510000000     	movss	xmm0, dword ptr [rip + 0x10]
-;;   18:	 e800000000           	call	0x1d
-;;   1d:	 4883c408             	add	rsp, 8
-;;   21:	 4883c408             	add	rsp, 8
-;;   25:	 5d                   	pop	rbp
-;;   26:	 c3                   	ret	
-;;   27:	 00c3                 	add	bl, al
-;;   29:	 f5                   	cmc	
-;;   2a:	 a83f                 	test	al, 0x3f
diff --git a/winch/filetests/filetests/x64/f32_const/id.wat b/winch/filetests/filetests/x64/f32_const/id.wat
deleted file mode 100644
index d91f7554dd50..000000000000
--- a/winch/filetests/filetests/x64/f32_const/id.wat
+++ /dev/null
@@ -1,14 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func (param f32) (result f32) (local.get 0))
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 f30f1144240c         	movss	dword ptr [rsp + 0xc], xmm0
-;;    e:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   13:	 f30f1044240c         	movss	xmm0, dword ptr [rsp + 0xc]
-;;   19:	 4883c410             	add	rsp, 0x10
-;;   1d:	 5d                   	pop	rbp
-;;   1e:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/f32_floor/f32_floor_const_sse41.wat b/winch/filetests/filetests/x64/f32_floor/f32_floor_const_sse41.wat
deleted file mode 100644
index 5681b1e43225..000000000000
--- a/winch/filetests/filetests/x64/f32_floor/f32_floor_const_sse41.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_sse41"]
-
-(module
-    (func (result f32)
-        (f32.const -1.32)
-        (f32.floor)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 f30f10050c000000     	movss	xmm0, dword ptr [rip + 0xc]
-;;   14:	 660f3a0ac001         	roundss	xmm0, xmm0, 1
-;;   1a:	 4883c408             	add	rsp, 8
-;;   1e:	 5d                   	pop	rbp
-;;   1f:	 c3                   	ret	
-;;   20:	 c3                   	ret	
-;;   21:	 f5                   	cmc	
-;;   22:	 a8bf                 	test	al, 0xbf
diff --git a/winch/filetests/filetests/x64/f32_floor/f32_floor_param_sse41.wat b/winch/filetests/filetests/x64/f32_floor/f32_floor_param_sse41.wat
deleted file mode 100644
index 040ee7cf70b3..000000000000
--- a/winch/filetests/filetests/x64/f32_floor/f32_floor_param_sse41.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_sse41"]
-
-(module
-    (func (param f32) (result f32)
-        (local.get 0)
-        (f32.floor)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 f30f1144240c         	movss	dword ptr [rsp + 0xc], xmm0
-;;    e:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   13:	 f30f1044240c         	movss	xmm0, dword ptr [rsp + 0xc]
-;;   19:	 660f3a0ac001         	roundss	xmm0, xmm0, 1
-;;   1f:	 4883c410             	add	rsp, 0x10
-;;   23:	 5d                   	pop	rbp
-;;   24:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/f32_nearest/f32_floor_const_sse41.wat b/winch/filetests/filetests/x64/f32_nearest/f32_floor_const_sse41.wat
deleted file mode 100644
index 45b51bb08c42..000000000000
--- a/winch/filetests/filetests/x64/f32_nearest/f32_floor_const_sse41.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_sse41"]
-
-(module
-    (func (result f32)
-        (f32.const -1.32)
-        (f32.nearest)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 f30f10050c000000     	movss	xmm0, dword ptr [rip + 0xc]
-;;   14:	 660f3a0ac000         	roundss	xmm0, xmm0, 0
-;;   1a:	 4883c408             	add	rsp, 8
-;;   1e:	 5d                   	pop	rbp
-;;   1f:	 c3                   	ret	
-;;   20:	 c3                   	ret	
-;;   21:	 f5                   	cmc	
-;;   22:	 a8bf                 	test	al, 0xbf
diff --git a/winch/filetests/filetests/x64/f32_nearest/f32_floor_param_sse41.wat b/winch/filetests/filetests/x64/f32_nearest/f32_floor_param_sse41.wat
deleted file mode 100644
index f6a62421fd1e..000000000000
--- a/winch/filetests/filetests/x64/f32_nearest/f32_floor_param_sse41.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_sse41"]
-
-(module
-    (func (param f32) (result f32)
-        (local.get 0)
-        (f32.nearest)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 f30f1144240c         	movss	dword ptr [rsp + 0xc], xmm0
-;;    e:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   13:	 f30f1044240c         	movss	xmm0, dword ptr [rsp + 0xc]
-;;   19:	 660f3a0ac000         	roundss	xmm0, xmm0, 0
-;;   1f:	 4883c410             	add	rsp, 0x10
-;;   23:	 5d                   	pop	rbp
-;;   24:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/f32_neg/f32_neg_const.wat b/winch/filetests/filetests/x64/f32_neg/f32_neg_const.wat
deleted file mode 100644
index 07d16db3a524..000000000000
--- a/winch/filetests/filetests/x64/f32_neg/f32_neg_const.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result f32)
-        (f32.const -1.32)
-        (f32.neg)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 f30f10051c000000     	movss	xmm0, dword ptr [rip + 0x1c]
-;;   14:	 41bb00000080         	mov	r11d, 0x80000000
-;;   1a:	 66450f6efb           	movd	xmm15, r11d
-;;   1f:	 410f57c7             	xorps	xmm0, xmm15
-;;   23:	 4883c408             	add	rsp, 8
-;;   27:	 5d                   	pop	rbp
-;;   28:	 c3                   	ret	
-;;   29:	 0000                 	add	byte ptr [rax], al
-;;   2b:	 0000                 	add	byte ptr [rax], al
-;;   2d:	 0000                 	add	byte ptr [rax], al
-;;   2f:	 00c3                 	add	bl, al
-;;   31:	 f5                   	cmc	
-;;   32:	 a8bf                 	test	al, 0xbf
diff --git a/winch/filetests/filetests/x64/f32_neg/f32_neg_param.wat b/winch/filetests/filetests/x64/f32_neg/f32_neg_param.wat
deleted file mode 100644
index 3f39aa88f8c1..000000000000
--- a/winch/filetests/filetests/x64/f32_neg/f32_neg_param.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param f32) (result f32)
-        (local.get 0)
-        (f32.neg)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 f30f1144240c         	movss	dword ptr [rsp + 0xc], xmm0
-;;    e:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   13:	 f30f1044240c         	movss	xmm0, dword ptr [rsp + 0xc]
-;;   19:	 41bb00000080         	mov	r11d, 0x80000000
-;;   1f:	 66450f6efb           	movd	xmm15, r11d
-;;   24:	 410f57c7             	xorps	xmm0, xmm15
-;;   28:	 4883c410             	add	rsp, 0x10
-;;   2c:	 5d                   	pop	rbp
-;;   2d:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/f32_trunc/f32_trunc_const_sse41.wat b/winch/filetests/filetests/x64/f32_trunc/f32_trunc_const_sse41.wat
deleted file mode 100644
index 5ce9541f055b..000000000000
--- a/winch/filetests/filetests/x64/f32_trunc/f32_trunc_const_sse41.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_sse41"]
-
-(module
-    (func (result f32)
-        (f32.const -1.32)
-        (f32.trunc)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 f30f10050c000000     	movss	xmm0, dword ptr [rip + 0xc]
-;;   14:	 660f3a0ac003         	roundss	xmm0, xmm0, 3
-;;   1a:	 4883c408             	add	rsp, 8
-;;   1e:	 5d                   	pop	rbp
-;;   1f:	 c3                   	ret	
-;;   20:	 c3                   	ret	
-;;   21:	 f5                   	cmc	
-;;   22:	 a8bf                 	test	al, 0xbf
diff --git a/winch/filetests/filetests/x64/f32_trunc/f32_trunc_param_sse41.wat b/winch/filetests/filetests/x64/f32_trunc/f32_trunc_param_sse41.wat
deleted file mode 100644
index 2a81b2a9acbc..000000000000
--- a/winch/filetests/filetests/x64/f32_trunc/f32_trunc_param_sse41.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_sse41"]
-
-(module
-    (func (param f32) (result f32)
-        (local.get 0)
-        (f32.trunc)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 f30f1144240c         	movss	dword ptr [rsp + 0xc], xmm0
-;;    e:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   13:	 f30f1044240c         	movss	xmm0, dword ptr [rsp + 0xc]
-;;   19:	 660f3a0ac003         	roundss	xmm0, xmm0, 3
-;;   1f:	 4883c410             	add	rsp, 0x10
-;;   23:	 5d                   	pop	rbp
-;;   24:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/f64_abs/f64_abs_const.wat b/winch/filetests/filetests/x64/f64_abs/f64_abs_const.wat
deleted file mode 100644
index 991651614d09..000000000000
--- a/winch/filetests/filetests/x64/f64_abs/f64_abs_const.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result f64)
-        (f64.const -1.32)
-        (f64.abs)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 f20f10051c000000     	movsd	xmm0, qword ptr [rip + 0x1c]
-;;   14:	 49bbffffffffffffff7f 	
-;; 				movabs	r11, 0x7fffffffffffffff
-;;   1e:	 664d0f6efb           	movq	xmm15, r11
-;;   23:	 66410f54c7           	andpd	xmm0, xmm15
-;;   28:	 4883c408             	add	rsp, 8
-;;   2c:	 5d                   	pop	rbp
-;;   2d:	 c3                   	ret	
-;;   2e:	 0000                 	add	byte ptr [rax], al
diff --git a/winch/filetests/filetests/x64/f64_abs/f64_abs_param.wat b/winch/filetests/filetests/x64/f64_abs/f64_abs_param.wat
deleted file mode 100644
index 117a045de256..000000000000
--- a/winch/filetests/filetests/x64/f64_abs/f64_abs_param.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param f64) (result f64)
-        (local.get 0)
-        (f64.abs)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 f20f11442408         	movsd	qword ptr [rsp + 8], xmm0
-;;    e:	 4c893424             	mov	qword ptr [rsp], r14
-;;   12:	 f20f10442408         	movsd	xmm0, qword ptr [rsp + 8]
-;;   18:	 49bbffffffffffffff7f 	
-;; 				movabs	r11, 0x7fffffffffffffff
-;;   22:	 664d0f6efb           	movq	xmm15, r11
-;;   27:	 66410f54c7           	andpd	xmm0, xmm15
-;;   2c:	 4883c410             	add	rsp, 0x10
-;;   30:	 5d                   	pop	rbp
-;;   31:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/f64_ceil/f64_ceil_const_sse41.wat b/winch/filetests/filetests/x64/f64_ceil/f64_ceil_const_sse41.wat
deleted file mode 100644
index b6f669c9c8ad..000000000000
--- a/winch/filetests/filetests/x64/f64_ceil/f64_ceil_const_sse41.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_sse41"]
-
-(module
-    (func (result f64)
-        (f64.const -1.32)
-        (f64.ceil)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 f20f10050c000000     	movsd	xmm0, qword ptr [rip + 0xc]
-;;   14:	 660f3a0bc002         	roundsd	xmm0, xmm0, 2
-;;   1a:	 4883c408             	add	rsp, 8
-;;   1e:	 5d                   	pop	rbp
-;;   1f:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/f64_ceil/f64_ceil_param_sse41.wat b/winch/filetests/filetests/x64/f64_ceil/f64_ceil_param_sse41.wat
deleted file mode 100644
index 4ff72595c57a..000000000000
--- a/winch/filetests/filetests/x64/f64_ceil/f64_ceil_param_sse41.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_sse41"]
-
-(module
-    (func (param f64) (result f64)
-        (local.get 0)
-        (f64.ceil)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 f20f11442408         	movsd	qword ptr [rsp + 8], xmm0
-;;    e:	 4c893424             	mov	qword ptr [rsp], r14
-;;   12:	 f20f10442408         	movsd	xmm0, qword ptr [rsp + 8]
-;;   18:	 660f3a0bc002         	roundsd	xmm0, xmm0, 2
-;;   1e:	 4883c410             	add	rsp, 0x10
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/f64_const/call_id.wat b/winch/filetests/filetests/x64/f64_const/call_id.wat
deleted file mode 100644
index 4b5bd51b8280..000000000000
--- a/winch/filetests/filetests/x64/f64_const/call_id.wat
+++ /dev/null
@@ -1,30 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func $id-f64 (param f64) (result f64) (local.get 0))
-  (func (export "type-first-f64") (result f64) (call $id-f64 (f64.const 1.32)))
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 f20f11442408         	movsd	qword ptr [rsp + 8], xmm0
-;;    e:	 4c893424             	mov	qword ptr [rsp], r14
-;;   12:	 f20f10442408         	movsd	xmm0, qword ptr [rsp + 8]
-;;   18:	 4883c410             	add	rsp, 0x10
-;;   1c:	 5d                   	pop	rbp
-;;   1d:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 f20f100510000000     	movsd	xmm0, qword ptr [rip + 0x10]
-;;   18:	 e800000000           	call	0x1d
-;;   1d:	 4883c408             	add	rsp, 8
-;;   21:	 4883c408             	add	rsp, 8
-;;   25:	 5d                   	pop	rbp
-;;   26:	 c3                   	ret	
-;;   27:	 001f                 	add	byte ptr [rdi], bl
-;;   29:	 85eb                 	test	ebx, ebp
-;;   2b:	 51                   	push	rcx
diff --git a/winch/filetests/filetests/x64/f64_const/id.wat b/winch/filetests/filetests/x64/f64_const/id.wat
deleted file mode 100644
index 191f88940cd3..000000000000
--- a/winch/filetests/filetests/x64/f64_const/id.wat
+++ /dev/null
@@ -1,14 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func (param f64) (result f64) (local.get 0))
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 f20f11442408         	movsd	qword ptr [rsp + 8], xmm0
-;;    e:	 4c893424             	mov	qword ptr [rsp], r14
-;;   12:	 f20f10442408         	movsd	xmm0, qword ptr [rsp + 8]
-;;   18:	 4883c410             	add	rsp, 0x10
-;;   1c:	 5d                   	pop	rbp
-;;   1d:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/f64_floor/f64_floor_const_sse41.wat b/winch/filetests/filetests/x64/f64_floor/f64_floor_const_sse41.wat
deleted file mode 100644
index d08b70469c1d..000000000000
--- a/winch/filetests/filetests/x64/f64_floor/f64_floor_const_sse41.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_sse41"]
-
-(module
-    (func (result f64)
-        (f64.const -1.32)
-        (f64.floor)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 f20f10050c000000     	movsd	xmm0, qword ptr [rip + 0xc]
-;;   14:	 660f3a0bc001         	roundsd	xmm0, xmm0, 1
-;;   1a:	 4883c408             	add	rsp, 8
-;;   1e:	 5d                   	pop	rbp
-;;   1f:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/f64_floor/f64_floor_param_sse41.wat b/winch/filetests/filetests/x64/f64_floor/f64_floor_param_sse41.wat
deleted file mode 100644
index 26a64cd9790f..000000000000
--- a/winch/filetests/filetests/x64/f64_floor/f64_floor_param_sse41.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_sse41"]
-
-(module
-    (func (param f64) (result f64)
-        (local.get 0)
-        (f64.floor)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 f20f11442408         	movsd	qword ptr [rsp + 8], xmm0
-;;    e:	 4c893424             	mov	qword ptr [rsp], r14
-;;   12:	 f20f10442408         	movsd	xmm0, qword ptr [rsp + 8]
-;;   18:	 660f3a0bc001         	roundsd	xmm0, xmm0, 1
-;;   1e:	 4883c410             	add	rsp, 0x10
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/f64_nearest/f64_nearest_const_sse41.wat b/winch/filetests/filetests/x64/f64_nearest/f64_nearest_const_sse41.wat
deleted file mode 100644
index 7c5b7ea4fd42..000000000000
--- a/winch/filetests/filetests/x64/f64_nearest/f64_nearest_const_sse41.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_sse41"]
-
-(module
-    (func (result f64)
-        (f64.const -1.32)
-        (f64.nearest)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 f20f10050c000000     	movsd	xmm0, qword ptr [rip + 0xc]
-;;   14:	 660f3a0bc000         	roundsd	xmm0, xmm0, 0
-;;   1a:	 4883c408             	add	rsp, 8
-;;   1e:	 5d                   	pop	rbp
-;;   1f:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/f64_nearest/f64_nearest_param_sse41.wat b/winch/filetests/filetests/x64/f64_nearest/f64_nearest_param_sse41.wat
deleted file mode 100644
index bd752b1d996b..000000000000
--- a/winch/filetests/filetests/x64/f64_nearest/f64_nearest_param_sse41.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_sse41"]
-
-(module
-    (func (param f64) (result f64)
-        (local.get 0)
-        (f64.nearest)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 f20f11442408         	movsd	qword ptr [rsp + 8], xmm0
-;;    e:	 4c893424             	mov	qword ptr [rsp], r14
-;;   12:	 f20f10442408         	movsd	xmm0, qword ptr [rsp + 8]
-;;   18:	 660f3a0bc000         	roundsd	xmm0, xmm0, 0
-;;   1e:	 4883c410             	add	rsp, 0x10
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/f64_neg/f64_neg_const.wat b/winch/filetests/filetests/x64/f64_neg/f64_neg_const.wat
deleted file mode 100644
index 41046ab377bc..000000000000
--- a/winch/filetests/filetests/x64/f64_neg/f64_neg_const.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result f64)
-        (f64.const -1.32)
-        (f64.neg)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 f20f10051c000000     	movsd	xmm0, qword ptr [rip + 0x1c]
-;;   14:	 49bb0000000000000080 	
-;; 				movabs	r11, 0x8000000000000000
-;;   1e:	 664d0f6efb           	movq	xmm15, r11
-;;   23:	 66410f57c7           	xorpd	xmm0, xmm15
-;;   28:	 4883c408             	add	rsp, 8
-;;   2c:	 5d                   	pop	rbp
-;;   2d:	 c3                   	ret	
-;;   2e:	 0000                 	add	byte ptr [rax], al
diff --git a/winch/filetests/filetests/x64/f64_neg/f64_neg_param.wat b/winch/filetests/filetests/x64/f64_neg/f64_neg_param.wat
deleted file mode 100644
index 96c9b0fdce85..000000000000
--- a/winch/filetests/filetests/x64/f64_neg/f64_neg_param.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param f64) (result f64)
-        (local.get 0)
-        (f64.neg)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 f20f11442408         	movsd	qword ptr [rsp + 8], xmm0
-;;    e:	 4c893424             	mov	qword ptr [rsp], r14
-;;   12:	 f20f10442408         	movsd	xmm0, qword ptr [rsp + 8]
-;;   18:	 49bb0000000000000080 	
-;; 				movabs	r11, 0x8000000000000000
-;;   22:	 664d0f6efb           	movq	xmm15, r11
-;;   27:	 66410f57c7           	xorpd	xmm0, xmm15
-;;   2c:	 4883c410             	add	rsp, 0x10
-;;   30:	 5d                   	pop	rbp
-;;   31:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/f64_trunc/f64_trunc_const_sse41.wat b/winch/filetests/filetests/x64/f64_trunc/f64_trunc_const_sse41.wat
deleted file mode 100644
index cc28e2c0523f..000000000000
--- a/winch/filetests/filetests/x64/f64_trunc/f64_trunc_const_sse41.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_sse41"]
-
-(module
-    (func (result f64)
-        (f64.const -1.32)
-        (f64.trunc)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 f20f10050c000000     	movsd	xmm0, qword ptr [rip + 0xc]
-;;   14:	 660f3a0bc003         	roundsd	xmm0, xmm0, 3
-;;   1a:	 4883c408             	add	rsp, 8
-;;   1e:	 5d                   	pop	rbp
-;;   1f:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/f64_trunc/f64_trunc_param_sse41.wat b/winch/filetests/filetests/x64/f64_trunc/f64_trunc_param_sse41.wat
deleted file mode 100644
index 67e945d45181..000000000000
--- a/winch/filetests/filetests/x64/f64_trunc/f64_trunc_param_sse41.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_sse41"]
-
-(module
-    (func (param f64) (result f64)
-        (local.get 0)
-        (f64.trunc)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 f20f11442408         	movsd	qword ptr [rsp + 8], xmm0
-;;    e:	 4c893424             	mov	qword ptr [rsp], r14
-;;   12:	 f20f10442408         	movsd	xmm0, qword ptr [rsp + 8]
-;;   18:	 660f3a0bc003         	roundsd	xmm0, xmm0, 3
-;;   1e:	 4883c410             	add	rsp, 0x10
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_add/const.wat b/winch/filetests/filetests/x64/i32_add/const.wat
deleted file mode 100644
index 5d8f4779c4d3..000000000000
--- a/winch/filetests/filetests/x64/i32_add/const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-	(i32.const 10)
-	(i32.const 20)
-	(i32.add)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b80a000000           	mov	eax, 0xa
-;;   11:	 83c014               	add	eax, 0x14
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_add/locals.wat b/winch/filetests/filetests/x64/i32_add/locals.wat
deleted file mode 100644
index f588a4b22a58..000000000000
--- a/winch/filetests/filetests/x64/i32_add/locals.wat
+++ /dev/null
@@ -1,35 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i32)  
-        (local $bar i32)
-
-        (i32.const 10)
-        (local.set $foo)
-
-        (i32.const 20)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        i32.add
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c893424             	mov	qword ptr [rsp], r14
-;;   15:	 b80a000000           	mov	eax, 0xa
-;;   1a:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1e:	 b814000000           	mov	eax, 0x14
-;;   23:	 89442408             	mov	dword ptr [rsp + 8], eax
-;;   27:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   2b:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   2f:	 01c1                 	add	ecx, eax
-;;   31:	 89c8                 	mov	eax, ecx
-;;   33:	 4883c410             	add	rsp, 0x10
-;;   37:	 5d                   	pop	rbp
-;;   38:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_add/max.wat b/winch/filetests/filetests/x64/i32_add/max.wat
deleted file mode 100644
index 8887f4e336eb..000000000000
--- a/winch/filetests/filetests/x64/i32_add/max.wat
+++ /dev/null
@@ -1,17 +0,0 @@
-;;! target = "x86_64"
-(module
-    (func (result i32)
-	(i32.const 0x7fffffff)
-	(i32.const 1)
-	(i32.add)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b8ffffff7f           	mov	eax, 0x7fffffff
-;;   11:	 83c001               	add	eax, 1
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_add/max_one.wat b/winch/filetests/filetests/x64/i32_add/max_one.wat
deleted file mode 100644
index 10301746101b..000000000000
--- a/winch/filetests/filetests/x64/i32_add/max_one.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-	(i32.const 0x80000000)
-	(i32.const -1)
-	(i32.add)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b800000080           	mov	eax, 0x80000000
-;;   11:	 83c0ff               	add	eax, -1
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_add/mixed.wat b/winch/filetests/filetests/x64/i32_add/mixed.wat
deleted file mode 100644
index b9c22b6cb1ba..000000000000
--- a/winch/filetests/filetests/x64/i32_add/mixed.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const -1)
-	(i32.const 1)
-	(i32.add)
-     )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b8ffffffff           	mov	eax, 0xffffffff
-;;   11:	 83c001               	add	eax, 1
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_add/params.wat b/winch/filetests/filetests/x64/i32_add/params.wat
deleted file mode 100644
index d5b0647abd78..000000000000
--- a/winch/filetests/filetests/x64/i32_add/params.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i32) (param i32) (result i32)
-	(local.get 0)
-	(local.get 1)
-	(i32.add)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   18:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   1c:	 01c1                 	add	ecx, eax
-;;   1e:	 89c8                 	mov	eax, ecx
-;;   20:	 4883c410             	add	rsp, 0x10
-;;   24:	 5d                   	pop	rbp
-;;   25:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_add/signed.wat b/winch/filetests/filetests/x64/i32_add/signed.wat
deleted file mode 100644
index 306fe771682b..000000000000
--- a/winch/filetests/filetests/x64/i32_add/signed.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const -1)
-	(i32.const -1)
-	(i32.add)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b8ffffffff           	mov	eax, 0xffffffff
-;;   11:	 83c0ff               	add	eax, -1
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_add/unsigned_with_zero.wat b/winch/filetests/filetests/x64/i32_add/unsigned_with_zero.wat
deleted file mode 100644
index 2ad5e3c2134f..000000000000
--- a/winch/filetests/filetests/x64/i32_add/unsigned_with_zero.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const 1)
-     	(i32.const 0)
-    	(i32.add)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 83c000               	add	eax, 0
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_and/const.wat b/winch/filetests/filetests/x64/i32_and/const.wat
deleted file mode 100644
index 6f0559288cf0..000000000000
--- a/winch/filetests/filetests/x64/i32_and/const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const 1)
-        (i32.const 2)
-        (i32.and)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 83e002               	and	eax, 2
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_and/locals.wat b/winch/filetests/filetests/x64/i32_and/locals.wat
deleted file mode 100644
index e4b7cfd0ceb5..000000000000
--- a/winch/filetests/filetests/x64/i32_and/locals.wat
+++ /dev/null
@@ -1,35 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i32)  
-        (local $bar i32)
-
-        (i32.const 1)
-        (local.set $foo)
-
-        (i32.const 2)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i32.and)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c893424             	mov	qword ptr [rsp], r14
-;;   15:	 b801000000           	mov	eax, 1
-;;   1a:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1e:	 b802000000           	mov	eax, 2
-;;   23:	 89442408             	mov	dword ptr [rsp + 8], eax
-;;   27:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   2b:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   2f:	 21c1                 	and	ecx, eax
-;;   31:	 89c8                 	mov	eax, ecx
-;;   33:	 4883c410             	add	rsp, 0x10
-;;   37:	 5d                   	pop	rbp
-;;   38:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_and/params.wat b/winch/filetests/filetests/x64/i32_and/params.wat
deleted file mode 100644
index 91dc71b32c3d..000000000000
--- a/winch/filetests/filetests/x64/i32_and/params.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i32) (param i32) (result i32)
-        (local.get 0)
-        (local.get 1)
-        (i32.and)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   18:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   1c:	 21c1                 	and	ecx, eax
-;;   1e:	 89c8                 	mov	eax, ecx
-;;   20:	 4883c410             	add	rsp, 0x10
-;;   24:	 5d                   	pop	rbp
-;;   25:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_clz/lzcnt_const.wat b/winch/filetests/filetests/x64/i32_clz/lzcnt_const.wat
deleted file mode 100644
index 0cb5d6a2e30d..000000000000
--- a/winch/filetests/filetests/x64/i32_clz/lzcnt_const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_lzcnt"]
-
-(module
-    (func (result i32)
-        (i32.const 1)
-        (i32.clz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 f30fbdc0             	lzcnt	eax, eax
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 5d                   	pop	rbp
-;;   1a:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_clz/lzcnt_local.wat b/winch/filetests/filetests/x64/i32_clz/lzcnt_local.wat
deleted file mode 100644
index 40606c9bdd63..000000000000
--- a/winch/filetests/filetests/x64/i32_clz/lzcnt_local.wat
+++ /dev/null
@@ -1,27 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_lzcnt"]
-
-(module
-    (func (result i32)
-        (local $foo i32)
-
-        (i32.const 2)
-        (local.set $foo)
-
-        (local.get $foo)
-        (i32.clz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   16:	 b802000000           	mov	eax, 2
-;;   1b:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1f:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   23:	 f30fbdc0             	lzcnt	eax, eax
-;;   27:	 4883c410             	add	rsp, 0x10
-;;   2b:	 5d                   	pop	rbp
-;;   2c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_clz/lzcnt_param.wat b/winch/filetests/filetests/x64/i32_clz/lzcnt_param.wat
deleted file mode 100644
index 1a146ed38552..000000000000
--- a/winch/filetests/filetests/x64/i32_clz/lzcnt_param.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_lzcnt"]
-
-(module
-    (func (param i32) (result i32)
-        (local.get 0)
-        (i32.clz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   11:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   15:	 f30fbdc0             	lzcnt	eax, eax
-;;   19:	 4883c410             	add	rsp, 0x10
-;;   1d:	 5d                   	pop	rbp
-;;   1e:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_clz/no_lzcnt_const.wat b/winch/filetests/filetests/x64/i32_clz/no_lzcnt_const.wat
deleted file mode 100644
index 7c68d949720a..000000000000
--- a/winch/filetests/filetests/x64/i32_clz/no_lzcnt_const.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const 1)
-        (i32.clz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 0fbdc0               	bsr	eax, eax
-;;   14:	 41bb00000000         	mov	r11d, 0
-;;   1a:	 410f95c3             	setne	r11b
-;;   1e:	 f7d8                 	neg	eax
-;;   20:	 83c020               	add	eax, 0x20
-;;   23:	 4429d8               	sub	eax, r11d
-;;   26:	 4883c408             	add	rsp, 8
-;;   2a:	 5d                   	pop	rbp
-;;   2b:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_clz/no_lzcnt_local.wat b/winch/filetests/filetests/x64/i32_clz/no_lzcnt_local.wat
deleted file mode 100644
index 9aba3c943bb3..000000000000
--- a/winch/filetests/filetests/x64/i32_clz/no_lzcnt_local.wat
+++ /dev/null
@@ -1,31 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i32)
-
-        (i32.const 2)
-        (local.set $foo)
-
-        (local.get $foo)
-        (i32.clz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   16:	 b802000000           	mov	eax, 2
-;;   1b:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1f:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   23:	 0fbdc0               	bsr	eax, eax
-;;   26:	 41bb00000000         	mov	r11d, 0
-;;   2c:	 410f95c3             	setne	r11b
-;;   30:	 f7d8                 	neg	eax
-;;   32:	 83c020               	add	eax, 0x20
-;;   35:	 4429d8               	sub	eax, r11d
-;;   38:	 4883c410             	add	rsp, 0x10
-;;   3c:	 5d                   	pop	rbp
-;;   3d:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_clz/no_lzcnt_param.wat b/winch/filetests/filetests/x64/i32_clz/no_lzcnt_param.wat
deleted file mode 100644
index 545b3d5a59f4..000000000000
--- a/winch/filetests/filetests/x64/i32_clz/no_lzcnt_param.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i32) (result i32)
-        (local.get 0)
-        (i32.clz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   11:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   15:	 0fbdc0               	bsr	eax, eax
-;;   18:	 41bb00000000         	mov	r11d, 0
-;;   1e:	 410f95c3             	setne	r11b
-;;   22:	 f7d8                 	neg	eax
-;;   24:	 83c020               	add	eax, 0x20
-;;   27:	 4429d8               	sub	eax, r11d
-;;   2a:	 4883c410             	add	rsp, 0x10
-;;   2e:	 5d                   	pop	rbp
-;;   2f:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_ctz/bmi1_const.wat b/winch/filetests/filetests/x64/i32_ctz/bmi1_const.wat
deleted file mode 100644
index 6cc13634fd23..000000000000
--- a/winch/filetests/filetests/x64/i32_ctz/bmi1_const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_bmi1"]
-
-(module
-    (func (result i32)
-        (i32.const 1)
-        (i32.ctz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 f30fbcc0             	tzcnt	eax, eax
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 5d                   	pop	rbp
-;;   1a:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_ctz/bmi1_local.wat b/winch/filetests/filetests/x64/i32_ctz/bmi1_local.wat
deleted file mode 100644
index 09f8144e6129..000000000000
--- a/winch/filetests/filetests/x64/i32_ctz/bmi1_local.wat
+++ /dev/null
@@ -1,28 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_bmi1"]
-
-(module
-    (func (result i32)
-        (local $foo i32)
-
-        (i32.const 2)
-        (local.set $foo)
-
-        (local.get $foo)
-        (i32.ctz)
-    )
-)
-
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   16:	 b802000000           	mov	eax, 2
-;;   1b:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1f:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   23:	 f30fbcc0             	tzcnt	eax, eax
-;;   27:	 4883c410             	add	rsp, 0x10
-;;   2b:	 5d                   	pop	rbp
-;;   2c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_ctz/bmi1_param.wat b/winch/filetests/filetests/x64/i32_ctz/bmi1_param.wat
deleted file mode 100644
index 9e05d460c723..000000000000
--- a/winch/filetests/filetests/x64/i32_ctz/bmi1_param.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_bmi1"]
-
-(module
-    (func (param i32) (result i32)
-        (local.get 0)
-        (i32.ctz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   11:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   15:	 f30fbcc0             	tzcnt	eax, eax
-;;   19:	 4883c410             	add	rsp, 0x10
-;;   1d:	 5d                   	pop	rbp
-;;   1e:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_ctz/no_bmi1_const.wat b/winch/filetests/filetests/x64/i32_ctz/no_bmi1_const.wat
deleted file mode 100644
index 7a334760f74c..000000000000
--- a/winch/filetests/filetests/x64/i32_ctz/no_bmi1_const.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const 1)
-        (i32.ctz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 0fbcc0               	bsf	eax, eax
-;;   14:	 41bb00000000         	mov	r11d, 0
-;;   1a:	 410f94c3             	sete	r11b
-;;   1e:	 41c1e305             	shl	r11d, 5
-;;   22:	 4401d8               	add	eax, r11d
-;;   25:	 4883c408             	add	rsp, 8
-;;   29:	 5d                   	pop	rbp
-;;   2a:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_ctz/no_bmi1_local.wat b/winch/filetests/filetests/x64/i32_ctz/no_bmi1_local.wat
deleted file mode 100644
index cf4be6ccc56e..000000000000
--- a/winch/filetests/filetests/x64/i32_ctz/no_bmi1_local.wat
+++ /dev/null
@@ -1,30 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i32)
-
-        (i32.const 2)
-        (local.set $foo)
-
-        (local.get $foo)
-        (i32.ctz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   16:	 b802000000           	mov	eax, 2
-;;   1b:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1f:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   23:	 0fbcc0               	bsf	eax, eax
-;;   26:	 41bb00000000         	mov	r11d, 0
-;;   2c:	 410f94c3             	sete	r11b
-;;   30:	 41c1e305             	shl	r11d, 5
-;;   34:	 4401d8               	add	eax, r11d
-;;   37:	 4883c410             	add	rsp, 0x10
-;;   3b:	 5d                   	pop	rbp
-;;   3c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_ctz/no_bmi1_param.wat b/winch/filetests/filetests/x64/i32_ctz/no_bmi1_param.wat
deleted file mode 100644
index 48d50e8e063c..000000000000
--- a/winch/filetests/filetests/x64/i32_ctz/no_bmi1_param.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i32) (result i32)
-        (local.get 0)
-        (i32.ctz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   11:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   15:	 0fbcc0               	bsf	eax, eax
-;;   18:	 41bb00000000         	mov	r11d, 0
-;;   1e:	 410f94c3             	sete	r11b
-;;   22:	 41c1e305             	shl	r11d, 5
-;;   26:	 4401d8               	add	eax, r11d
-;;   29:	 4883c410             	add	rsp, 0x10
-;;   2d:	 5d                   	pop	rbp
-;;   2e:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_divs/const.wat b/winch/filetests/filetests/x64/i32_divs/const.wat
deleted file mode 100644
index a34457f0789a..000000000000
--- a/winch/filetests/filetests/x64/i32_divs/const.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-	(i32.const 20)
-	(i32.const 10)
-	(i32.div_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b90a000000           	mov	ecx, 0xa
-;;   11:	 b814000000           	mov	eax, 0x14
-;;   16:	 83f900               	cmp	ecx, 0
-;;   19:	 0f8409000000         	je	0x28
-;;   1f:	 99                   	cdq	
-;;   20:	 f7f9                 	idiv	ecx
-;;   22:	 4883c408             	add	rsp, 8
-;;   26:	 5d                   	pop	rbp
-;;   27:	 c3                   	ret	
-;;   28:	 0f0b                 	ud2	
diff --git a/winch/filetests/filetests/x64/i32_divs/one_zero.wat b/winch/filetests/filetests/x64/i32_divs/one_zero.wat
deleted file mode 100644
index 3d310fba093b..000000000000
--- a/winch/filetests/filetests/x64/i32_divs/one_zero.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-	(i32.const 1)
-	(i32.const 0)
-	(i32.div_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b900000000           	mov	ecx, 0
-;;   11:	 b801000000           	mov	eax, 1
-;;   16:	 83f900               	cmp	ecx, 0
-;;   19:	 0f8409000000         	je	0x28
-;;   1f:	 99                   	cdq	
-;;   20:	 f7f9                 	idiv	ecx
-;;   22:	 4883c408             	add	rsp, 8
-;;   26:	 5d                   	pop	rbp
-;;   27:	 c3                   	ret	
-;;   28:	 0f0b                 	ud2	
diff --git a/winch/filetests/filetests/x64/i32_divs/overflow.wat b/winch/filetests/filetests/x64/i32_divs/overflow.wat
deleted file mode 100644
index 8237dfb92f23..000000000000
--- a/winch/filetests/filetests/x64/i32_divs/overflow.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-	(i32.const 0x80000000)
-	(i32.const -1)
-	(i32.div_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b9ffffffff           	mov	ecx, 0xffffffff
-;;   11:	 b800000080           	mov	eax, 0x80000000
-;;   16:	 83f900               	cmp	ecx, 0
-;;   19:	 0f8409000000         	je	0x28
-;;   1f:	 99                   	cdq	
-;;   20:	 f7f9                 	idiv	ecx
-;;   22:	 4883c408             	add	rsp, 8
-;;   26:	 5d                   	pop	rbp
-;;   27:	 c3                   	ret	
-;;   28:	 0f0b                 	ud2	
diff --git a/winch/filetests/filetests/x64/i32_divs/params.wat b/winch/filetests/filetests/x64/i32_divs/params.wat
deleted file mode 100644
index 8dfff2bc2b9e..000000000000
--- a/winch/filetests/filetests/x64/i32_divs/params.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i32) (param i32) (result i32)
-	(local.get 0)
-	(local.get 1)
-	(i32.div_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b4c2408             	mov	ecx, dword ptr [rsp + 8]
-;;   18:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   1c:	 83f900               	cmp	ecx, 0
-;;   1f:	 0f8409000000         	je	0x2e
-;;   25:	 99                   	cdq	
-;;   26:	 f7f9                 	idiv	ecx
-;;   28:	 4883c410             	add	rsp, 0x10
-;;   2c:	 5d                   	pop	rbp
-;;   2d:	 c3                   	ret	
-;;   2e:	 0f0b                 	ud2	
diff --git a/winch/filetests/filetests/x64/i32_divs/zero_zero.wat b/winch/filetests/filetests/x64/i32_divs/zero_zero.wat
deleted file mode 100644
index 8f4766020265..000000000000
--- a/winch/filetests/filetests/x64/i32_divs/zero_zero.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-	(i32.const 0)
-	(i32.const 0)
-	(i32.div_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b900000000           	mov	ecx, 0
-;;   11:	 b800000000           	mov	eax, 0
-;;   16:	 83f900               	cmp	ecx, 0
-;;   19:	 0f8409000000         	je	0x28
-;;   1f:	 99                   	cdq	
-;;   20:	 f7f9                 	idiv	ecx
-;;   22:	 4883c408             	add	rsp, 8
-;;   26:	 5d                   	pop	rbp
-;;   27:	 c3                   	ret	
-;;   28:	 0f0b                 	ud2	
diff --git a/winch/filetests/filetests/x64/i32_divu/const.wat b/winch/filetests/filetests/x64/i32_divu/const.wat
deleted file mode 100644
index f90362399d5a..000000000000
--- a/winch/filetests/filetests/x64/i32_divu/const.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-	(i32.const 20)
-	(i32.const 10)
-	(i32.div_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b90a000000           	mov	ecx, 0xa
-;;   11:	 b814000000           	mov	eax, 0x14
-;;   16:	 31d2                 	xor	edx, edx
-;;   18:	 f7f1                 	div	ecx
-;;   1a:	 4883c408             	add	rsp, 8
-;;   1e:	 5d                   	pop	rbp
-;;   1f:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_divu/one_zero.wat b/winch/filetests/filetests/x64/i32_divu/one_zero.wat
deleted file mode 100644
index 6f463954b8cf..000000000000
--- a/winch/filetests/filetests/x64/i32_divu/one_zero.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-	(i32.const 1)
-	(i32.const 0)
-	(i32.div_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b900000000           	mov	ecx, 0
-;;   11:	 b801000000           	mov	eax, 1
-;;   16:	 31d2                 	xor	edx, edx
-;;   18:	 f7f1                 	div	ecx
-;;   1a:	 4883c408             	add	rsp, 8
-;;   1e:	 5d                   	pop	rbp
-;;   1f:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_divu/params.wat b/winch/filetests/filetests/x64/i32_divu/params.wat
deleted file mode 100644
index 00c979d80763..000000000000
--- a/winch/filetests/filetests/x64/i32_divu/params.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i32) (param i32) (result i32)
-	(local.get 0)
-	(local.get 1)
-	(i32.div_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b4c2408             	mov	ecx, dword ptr [rsp + 8]
-;;   18:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   1c:	 31d2                 	xor	edx, edx
-;;   1e:	 f7f1                 	div	ecx
-;;   20:	 4883c410             	add	rsp, 0x10
-;;   24:	 5d                   	pop	rbp
-;;   25:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_divu/signed.wat b/winch/filetests/filetests/x64/i32_divu/signed.wat
deleted file mode 100644
index 31dfe5423a9e..000000000000
--- a/winch/filetests/filetests/x64/i32_divu/signed.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-	(i32.const -1)
-	(i32.const -1)
-	(i32.div_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b9ffffffff           	mov	ecx, 0xffffffff
-;;   11:	 b8ffffffff           	mov	eax, 0xffffffff
-;;   16:	 31d2                 	xor	edx, edx
-;;   18:	 f7f1                 	div	ecx
-;;   1a:	 4883c408             	add	rsp, 8
-;;   1e:	 5d                   	pop	rbp
-;;   1f:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_divu/zero_zero.wat b/winch/filetests/filetests/x64/i32_divu/zero_zero.wat
deleted file mode 100644
index 189be7acd08e..000000000000
--- a/winch/filetests/filetests/x64/i32_divu/zero_zero.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-	(i32.const 0)
-	(i32.const 0)
-	(i32.div_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b900000000           	mov	ecx, 0
-;;   11:	 b800000000           	mov	eax, 0
-;;   16:	 31d2                 	xor	edx, edx
-;;   18:	 f7f1                 	div	ecx
-;;   1a:	 4883c408             	add	rsp, 8
-;;   1e:	 5d                   	pop	rbp
-;;   1f:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_eq/const.wat b/winch/filetests/filetests/x64/i32_eq/const.wat
deleted file mode 100644
index f3ebed6e8e51..000000000000
--- a/winch/filetests/filetests/x64/i32_eq/const.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const 2)
-        (i32.const 3)
-        (i32.eq)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b802000000           	mov	eax, 2
-;;   11:	 83f803               	cmp	eax, 3
-;;   14:	 b800000000           	mov	eax, 0
-;;   19:	 400f94c0             	sete	al
-;;   1d:	 4883c408             	add	rsp, 8
-;;   21:	 5d                   	pop	rbp
-;;   22:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_eq/locals.wat b/winch/filetests/filetests/x64/i32_eq/locals.wat
deleted file mode 100644
index 3e989893fe29..000000000000
--- a/winch/filetests/filetests/x64/i32_eq/locals.wat
+++ /dev/null
@@ -1,36 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i32)
-        (local $bar i32)
-
-        (i32.const 2)
-        (local.set $foo)
-        (i32.const 3)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i32.eq)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c893424             	mov	qword ptr [rsp], r14
-;;   15:	 b802000000           	mov	eax, 2
-;;   1a:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1e:	 b803000000           	mov	eax, 3
-;;   23:	 89442408             	mov	dword ptr [rsp + 8], eax
-;;   27:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   2b:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   2f:	 39c1                 	cmp	ecx, eax
-;;   31:	 b900000000           	mov	ecx, 0
-;;   36:	 400f94c1             	sete	cl
-;;   3a:	 89c8                 	mov	eax, ecx
-;;   3c:	 4883c410             	add	rsp, 0x10
-;;   40:	 5d                   	pop	rbp
-;;   41:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_eq/params.wat b/winch/filetests/filetests/x64/i32_eq/params.wat
deleted file mode 100644
index 1dd06d350179..000000000000
--- a/winch/filetests/filetests/x64/i32_eq/params.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i32) (param i32) (result i32)
-        (local.get 0)
-        (local.get 1)
-        (i32.eq)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   18:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   1c:	 39c1                 	cmp	ecx, eax
-;;   1e:	 b900000000           	mov	ecx, 0
-;;   23:	 400f94c1             	sete	cl
-;;   27:	 89c8                 	mov	eax, ecx
-;;   29:	 4883c410             	add	rsp, 0x10
-;;   2d:	 5d                   	pop	rbp
-;;   2e:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_eqz/const.wat b/winch/filetests/filetests/x64/i32_eqz/const.wat
deleted file mode 100644
index d6624bef9cad..000000000000
--- a/winch/filetests/filetests/x64/i32_eqz/const.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const 1)
-        (i32.eqz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 83f800               	cmp	eax, 0
-;;   14:	 b800000000           	mov	eax, 0
-;;   19:	 400f94c0             	sete	al
-;;   1d:	 4883c408             	add	rsp, 8
-;;   21:	 5d                   	pop	rbp
-;;   22:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_eqz/local.wat b/winch/filetests/filetests/x64/i32_eqz/local.wat
deleted file mode 100644
index a1631bc8195e..000000000000
--- a/winch/filetests/filetests/x64/i32_eqz/local.wat
+++ /dev/null
@@ -1,28 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i32)
-
-        (i32.const 2)
-        (local.set $foo)
-
-        (local.get $foo)
-        (i32.eqz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   16:	 b802000000           	mov	eax, 2
-;;   1b:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1f:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   23:	 83f800               	cmp	eax, 0
-;;   26:	 b800000000           	mov	eax, 0
-;;   2b:	 400f94c0             	sete	al
-;;   2f:	 4883c410             	add	rsp, 0x10
-;;   33:	 5d                   	pop	rbp
-;;   34:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_eqz/param.wat b/winch/filetests/filetests/x64/i32_eqz/param.wat
deleted file mode 100644
index 66b55364521e..000000000000
--- a/winch/filetests/filetests/x64/i32_eqz/param.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i32) (result i32)
-        (local.get 0)
-        (i32.eqz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   11:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   15:	 83f800               	cmp	eax, 0
-;;   18:	 b800000000           	mov	eax, 0
-;;   1d:	 400f94c0             	sete	al
-;;   21:	 4883c410             	add	rsp, 0x10
-;;   25:	 5d                   	pop	rbp
-;;   26:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_ge_s/const.wat b/winch/filetests/filetests/x64/i32_ge_s/const.wat
deleted file mode 100644
index 9acb3ca8574c..000000000000
--- a/winch/filetests/filetests/x64/i32_ge_s/const.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const 2)
-        (i32.const 3)
-        (i32.ge_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b802000000           	mov	eax, 2
-;;   11:	 83f803               	cmp	eax, 3
-;;   14:	 b800000000           	mov	eax, 0
-;;   19:	 400f9dc0             	setge	al
-;;   1d:	 4883c408             	add	rsp, 8
-;;   21:	 5d                   	pop	rbp
-;;   22:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_ge_s/locals.wat b/winch/filetests/filetests/x64/i32_ge_s/locals.wat
deleted file mode 100644
index 8b98ffd97d8a..000000000000
--- a/winch/filetests/filetests/x64/i32_ge_s/locals.wat
+++ /dev/null
@@ -1,36 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i32)
-        (local $bar i32)
-
-        (i32.const 2)
-        (local.set $foo)
-        (i32.const 3)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i32.ge_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c893424             	mov	qword ptr [rsp], r14
-;;   15:	 b802000000           	mov	eax, 2
-;;   1a:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1e:	 b803000000           	mov	eax, 3
-;;   23:	 89442408             	mov	dword ptr [rsp + 8], eax
-;;   27:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   2b:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   2f:	 39c1                 	cmp	ecx, eax
-;;   31:	 b900000000           	mov	ecx, 0
-;;   36:	 400f9dc1             	setge	cl
-;;   3a:	 89c8                 	mov	eax, ecx
-;;   3c:	 4883c410             	add	rsp, 0x10
-;;   40:	 5d                   	pop	rbp
-;;   41:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_ge_s/params.wat b/winch/filetests/filetests/x64/i32_ge_s/params.wat
deleted file mode 100644
index d48e6f02047a..000000000000
--- a/winch/filetests/filetests/x64/i32_ge_s/params.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i32) (param i32) (result i32)
-        (local.get 0)
-        (local.get 1)
-        (i32.ge_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   18:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   1c:	 39c1                 	cmp	ecx, eax
-;;   1e:	 b900000000           	mov	ecx, 0
-;;   23:	 400f9dc1             	setge	cl
-;;   27:	 89c8                 	mov	eax, ecx
-;;   29:	 4883c410             	add	rsp, 0x10
-;;   2d:	 5d                   	pop	rbp
-;;   2e:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_ge_u/const.wat b/winch/filetests/filetests/x64/i32_ge_u/const.wat
deleted file mode 100644
index a30e1cde0b8b..000000000000
--- a/winch/filetests/filetests/x64/i32_ge_u/const.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const 2)
-        (i32.const 3)
-        (i32.ge_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b802000000           	mov	eax, 2
-;;   11:	 83f803               	cmp	eax, 3
-;;   14:	 b800000000           	mov	eax, 0
-;;   19:	 400f93c0             	setae	al
-;;   1d:	 4883c408             	add	rsp, 8
-;;   21:	 5d                   	pop	rbp
-;;   22:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_ge_u/locals.wat b/winch/filetests/filetests/x64/i32_ge_u/locals.wat
deleted file mode 100644
index 3b58fccc1dff..000000000000
--- a/winch/filetests/filetests/x64/i32_ge_u/locals.wat
+++ /dev/null
@@ -1,36 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i32)
-        (local $bar i32)
-
-        (i32.const 2)
-        (local.set $foo)
-        (i32.const 3)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i32.ge_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c893424             	mov	qword ptr [rsp], r14
-;;   15:	 b802000000           	mov	eax, 2
-;;   1a:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1e:	 b803000000           	mov	eax, 3
-;;   23:	 89442408             	mov	dword ptr [rsp + 8], eax
-;;   27:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   2b:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   2f:	 39c1                 	cmp	ecx, eax
-;;   31:	 b900000000           	mov	ecx, 0
-;;   36:	 400f93c1             	setae	cl
-;;   3a:	 89c8                 	mov	eax, ecx
-;;   3c:	 4883c410             	add	rsp, 0x10
-;;   40:	 5d                   	pop	rbp
-;;   41:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_ge_u/params.wat b/winch/filetests/filetests/x64/i32_ge_u/params.wat
deleted file mode 100644
index 15113b4f4642..000000000000
--- a/winch/filetests/filetests/x64/i32_ge_u/params.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i32) (param i32) (result i32)
-        (local.get 0)
-        (local.get 1)
-        (i32.ge_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   18:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   1c:	 39c1                 	cmp	ecx, eax
-;;   1e:	 b900000000           	mov	ecx, 0
-;;   23:	 400f93c1             	setae	cl
-;;   27:	 89c8                 	mov	eax, ecx
-;;   29:	 4883c410             	add	rsp, 0x10
-;;   2d:	 5d                   	pop	rbp
-;;   2e:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_gt_s/const.wat b/winch/filetests/filetests/x64/i32_gt_s/const.wat
deleted file mode 100644
index b17c30142da7..000000000000
--- a/winch/filetests/filetests/x64/i32_gt_s/const.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const 2)
-        (i32.const 3)
-        (i32.gt_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b802000000           	mov	eax, 2
-;;   11:	 83f803               	cmp	eax, 3
-;;   14:	 b800000000           	mov	eax, 0
-;;   19:	 400f9fc0             	setg	al
-;;   1d:	 4883c408             	add	rsp, 8
-;;   21:	 5d                   	pop	rbp
-;;   22:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_gt_s/locals.wat b/winch/filetests/filetests/x64/i32_gt_s/locals.wat
deleted file mode 100644
index 48326497a5ea..000000000000
--- a/winch/filetests/filetests/x64/i32_gt_s/locals.wat
+++ /dev/null
@@ -1,36 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i32)
-        (local $bar i32)
-
-        (i32.const 2)
-        (local.set $foo)
-        (i32.const 3)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i32.gt_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c893424             	mov	qword ptr [rsp], r14
-;;   15:	 b802000000           	mov	eax, 2
-;;   1a:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1e:	 b803000000           	mov	eax, 3
-;;   23:	 89442408             	mov	dword ptr [rsp + 8], eax
-;;   27:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   2b:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   2f:	 39c1                 	cmp	ecx, eax
-;;   31:	 b900000000           	mov	ecx, 0
-;;   36:	 400f9fc1             	setg	cl
-;;   3a:	 89c8                 	mov	eax, ecx
-;;   3c:	 4883c410             	add	rsp, 0x10
-;;   40:	 5d                   	pop	rbp
-;;   41:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_gt_s/params.wat b/winch/filetests/filetests/x64/i32_gt_s/params.wat
deleted file mode 100644
index 92aaa8c60d01..000000000000
--- a/winch/filetests/filetests/x64/i32_gt_s/params.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i32) (param i32) (result i32)
-        (local.get 0)
-        (local.get 1)
-        (i32.gt_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   18:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   1c:	 39c1                 	cmp	ecx, eax
-;;   1e:	 b900000000           	mov	ecx, 0
-;;   23:	 400f9fc1             	setg	cl
-;;   27:	 89c8                 	mov	eax, ecx
-;;   29:	 4883c410             	add	rsp, 0x10
-;;   2d:	 5d                   	pop	rbp
-;;   2e:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_gt_u/const.wat b/winch/filetests/filetests/x64/i32_gt_u/const.wat
deleted file mode 100644
index d0e958d65aeb..000000000000
--- a/winch/filetests/filetests/x64/i32_gt_u/const.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const 2)
-        (i32.const 3)
-        (i32.gt_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b802000000           	mov	eax, 2
-;;   11:	 83f803               	cmp	eax, 3
-;;   14:	 b800000000           	mov	eax, 0
-;;   19:	 400f97c0             	seta	al
-;;   1d:	 4883c408             	add	rsp, 8
-;;   21:	 5d                   	pop	rbp
-;;   22:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_gt_u/locals.wat b/winch/filetests/filetests/x64/i32_gt_u/locals.wat
deleted file mode 100644
index 078cdf5d4b26..000000000000
--- a/winch/filetests/filetests/x64/i32_gt_u/locals.wat
+++ /dev/null
@@ -1,36 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i32)
-        (local $bar i32)
-
-        (i32.const 2)
-        (local.set $foo)
-        (i32.const 3)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i32.gt_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c893424             	mov	qword ptr [rsp], r14
-;;   15:	 b802000000           	mov	eax, 2
-;;   1a:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1e:	 b803000000           	mov	eax, 3
-;;   23:	 89442408             	mov	dword ptr [rsp + 8], eax
-;;   27:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   2b:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   2f:	 39c1                 	cmp	ecx, eax
-;;   31:	 b900000000           	mov	ecx, 0
-;;   36:	 400f97c1             	seta	cl
-;;   3a:	 89c8                 	mov	eax, ecx
-;;   3c:	 4883c410             	add	rsp, 0x10
-;;   40:	 5d                   	pop	rbp
-;;   41:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_gt_u/params.wat b/winch/filetests/filetests/x64/i32_gt_u/params.wat
deleted file mode 100644
index c88a487abfed..000000000000
--- a/winch/filetests/filetests/x64/i32_gt_u/params.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i32) (param i32) (result i32)
-        (local.get 0)
-        (local.get 1)
-        (i32.gt_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   18:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   1c:	 39c1                 	cmp	ecx, eax
-;;   1e:	 b900000000           	mov	ecx, 0
-;;   23:	 400f97c1             	seta	cl
-;;   27:	 89c8                 	mov	eax, ecx
-;;   29:	 4883c410             	add	rsp, 0x10
-;;   2d:	 5d                   	pop	rbp
-;;   2e:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_le_s/const.wat b/winch/filetests/filetests/x64/i32_le_s/const.wat
deleted file mode 100644
index 69346f153438..000000000000
--- a/winch/filetests/filetests/x64/i32_le_s/const.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const 2)
-        (i32.const 3)
-        (i32.le_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b802000000           	mov	eax, 2
-;;   11:	 83f803               	cmp	eax, 3
-;;   14:	 b800000000           	mov	eax, 0
-;;   19:	 400f9ec0             	setle	al
-;;   1d:	 4883c408             	add	rsp, 8
-;;   21:	 5d                   	pop	rbp
-;;   22:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_le_s/locals.wat b/winch/filetests/filetests/x64/i32_le_s/locals.wat
deleted file mode 100644
index b75c90ff013e..000000000000
--- a/winch/filetests/filetests/x64/i32_le_s/locals.wat
+++ /dev/null
@@ -1,36 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i32)
-        (local $bar i32)
-
-        (i32.const 2)
-        (local.set $foo)
-        (i32.const 3)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i32.le_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c893424             	mov	qword ptr [rsp], r14
-;;   15:	 b802000000           	mov	eax, 2
-;;   1a:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1e:	 b803000000           	mov	eax, 3
-;;   23:	 89442408             	mov	dword ptr [rsp + 8], eax
-;;   27:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   2b:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   2f:	 39c1                 	cmp	ecx, eax
-;;   31:	 b900000000           	mov	ecx, 0
-;;   36:	 400f9ec1             	setle	cl
-;;   3a:	 89c8                 	mov	eax, ecx
-;;   3c:	 4883c410             	add	rsp, 0x10
-;;   40:	 5d                   	pop	rbp
-;;   41:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_le_s/params.wat b/winch/filetests/filetests/x64/i32_le_s/params.wat
deleted file mode 100644
index ce246a347d72..000000000000
--- a/winch/filetests/filetests/x64/i32_le_s/params.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i32) (param i32) (result i32)
-        (local.get 0)
-        (local.get 1)
-        (i32.le_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   18:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   1c:	 39c1                 	cmp	ecx, eax
-;;   1e:	 b900000000           	mov	ecx, 0
-;;   23:	 400f9ec1             	setle	cl
-;;   27:	 89c8                 	mov	eax, ecx
-;;   29:	 4883c410             	add	rsp, 0x10
-;;   2d:	 5d                   	pop	rbp
-;;   2e:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_le_u/const.wat b/winch/filetests/filetests/x64/i32_le_u/const.wat
deleted file mode 100644
index 99e66f46c2c0..000000000000
--- a/winch/filetests/filetests/x64/i32_le_u/const.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const 2)
-        (i32.const 3)
-        (i32.le_u)
-    )
-)
-
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b802000000           	mov	eax, 2
-;;   11:	 83f803               	cmp	eax, 3
-;;   14:	 b800000000           	mov	eax, 0
-;;   19:	 400f96c0             	setbe	al
-;;   1d:	 4883c408             	add	rsp, 8
-;;   21:	 5d                   	pop	rbp
-;;   22:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_le_u/locals.wat b/winch/filetests/filetests/x64/i32_le_u/locals.wat
deleted file mode 100644
index a4d89a53ac08..000000000000
--- a/winch/filetests/filetests/x64/i32_le_u/locals.wat
+++ /dev/null
@@ -1,37 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i32)
-        (local $bar i32)
-
-        (i32.const 2)
-        (local.set $foo)
-        (i32.const 3)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i32.le_u)
-    )
-)
-
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c893424             	mov	qword ptr [rsp], r14
-;;   15:	 b802000000           	mov	eax, 2
-;;   1a:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1e:	 b803000000           	mov	eax, 3
-;;   23:	 89442408             	mov	dword ptr [rsp + 8], eax
-;;   27:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   2b:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   2f:	 39c1                 	cmp	ecx, eax
-;;   31:	 b900000000           	mov	ecx, 0
-;;   36:	 400f96c1             	setbe	cl
-;;   3a:	 89c8                 	mov	eax, ecx
-;;   3c:	 4883c410             	add	rsp, 0x10
-;;   40:	 5d                   	pop	rbp
-;;   41:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_le_u/params.wat b/winch/filetests/filetests/x64/i32_le_u/params.wat
deleted file mode 100644
index 7c9f2b9c5b9a..000000000000
--- a/winch/filetests/filetests/x64/i32_le_u/params.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i32) (param i32) (result i32)
-        (local.get 0)
-        (local.get 1)
-        (i32.le_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   18:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   1c:	 39c1                 	cmp	ecx, eax
-;;   1e:	 b900000000           	mov	ecx, 0
-;;   23:	 400f96c1             	setbe	cl
-;;   27:	 89c8                 	mov	eax, ecx
-;;   29:	 4883c410             	add	rsp, 0x10
-;;   2d:	 5d                   	pop	rbp
-;;   2e:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_lt_s/const.wat b/winch/filetests/filetests/x64/i32_lt_s/const.wat
deleted file mode 100644
index 5a436151961f..000000000000
--- a/winch/filetests/filetests/x64/i32_lt_s/const.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const 2)
-        (i32.const 3)
-        (i32.lt_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b802000000           	mov	eax, 2
-;;   11:	 83f803               	cmp	eax, 3
-;;   14:	 b800000000           	mov	eax, 0
-;;   19:	 400f9cc0             	setl	al
-;;   1d:	 4883c408             	add	rsp, 8
-;;   21:	 5d                   	pop	rbp
-;;   22:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_lt_s/locals.wat b/winch/filetests/filetests/x64/i32_lt_s/locals.wat
deleted file mode 100644
index f31c40fa8509..000000000000
--- a/winch/filetests/filetests/x64/i32_lt_s/locals.wat
+++ /dev/null
@@ -1,36 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i32)
-        (local $bar i32)
-
-        (i32.const 2)
-        (local.set $foo)
-        (i32.const 3)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i32.lt_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c893424             	mov	qword ptr [rsp], r14
-;;   15:	 b802000000           	mov	eax, 2
-;;   1a:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1e:	 b803000000           	mov	eax, 3
-;;   23:	 89442408             	mov	dword ptr [rsp + 8], eax
-;;   27:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   2b:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   2f:	 39c1                 	cmp	ecx, eax
-;;   31:	 b900000000           	mov	ecx, 0
-;;   36:	 400f9cc1             	setl	cl
-;;   3a:	 89c8                 	mov	eax, ecx
-;;   3c:	 4883c410             	add	rsp, 0x10
-;;   40:	 5d                   	pop	rbp
-;;   41:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_lt_s/params.wat b/winch/filetests/filetests/x64/i32_lt_s/params.wat
deleted file mode 100644
index cc1975eca8de..000000000000
--- a/winch/filetests/filetests/x64/i32_lt_s/params.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i32) (param i32) (result i32)
-        (local.get 0)
-        (local.get 1)
-        (i32.lt_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   18:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   1c:	 39c1                 	cmp	ecx, eax
-;;   1e:	 b900000000           	mov	ecx, 0
-;;   23:	 400f9cc1             	setl	cl
-;;   27:	 89c8                 	mov	eax, ecx
-;;   29:	 4883c410             	add	rsp, 0x10
-;;   2d:	 5d                   	pop	rbp
-;;   2e:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_lt_u/const.wat b/winch/filetests/filetests/x64/i32_lt_u/const.wat
deleted file mode 100644
index 853c47ab9314..000000000000
--- a/winch/filetests/filetests/x64/i32_lt_u/const.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const 2)
-        (i32.const 3)
-        (i32.lt_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b802000000           	mov	eax, 2
-;;   11:	 83f803               	cmp	eax, 3
-;;   14:	 b800000000           	mov	eax, 0
-;;   19:	 400f92c0             	setb	al
-;;   1d:	 4883c408             	add	rsp, 8
-;;   21:	 5d                   	pop	rbp
-;;   22:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_lt_u/locals.wat b/winch/filetests/filetests/x64/i32_lt_u/locals.wat
deleted file mode 100644
index 0a82d4057feb..000000000000
--- a/winch/filetests/filetests/x64/i32_lt_u/locals.wat
+++ /dev/null
@@ -1,37 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i32)
-        (local $bar i32)
-
-        (i32.const 2)
-        (local.set $foo)
-        (i32.const 3)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i32.lt_u)
-    )
-)
-
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c893424             	mov	qword ptr [rsp], r14
-;;   15:	 b802000000           	mov	eax, 2
-;;   1a:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1e:	 b803000000           	mov	eax, 3
-;;   23:	 89442408             	mov	dword ptr [rsp + 8], eax
-;;   27:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   2b:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   2f:	 39c1                 	cmp	ecx, eax
-;;   31:	 b900000000           	mov	ecx, 0
-;;   36:	 400f92c1             	setb	cl
-;;   3a:	 89c8                 	mov	eax, ecx
-;;   3c:	 4883c410             	add	rsp, 0x10
-;;   40:	 5d                   	pop	rbp
-;;   41:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_lt_u/params.wat b/winch/filetests/filetests/x64/i32_lt_u/params.wat
deleted file mode 100644
index 37faf572285e..000000000000
--- a/winch/filetests/filetests/x64/i32_lt_u/params.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i32) (param i32) (result i32)
-        (local.get 0)
-        (local.get 1)
-        (i32.lt_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   18:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   1c:	 39c1                 	cmp	ecx, eax
-;;   1e:	 b900000000           	mov	ecx, 0
-;;   23:	 400f92c1             	setb	cl
-;;   27:	 89c8                 	mov	eax, ecx
-;;   29:	 4883c410             	add	rsp, 0x10
-;;   2d:	 5d                   	pop	rbp
-;;   2e:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_mul/const.wat b/winch/filetests/filetests/x64/i32_mul/const.wat
deleted file mode 100644
index cef93e5a1b5f..000000000000
--- a/winch/filetests/filetests/x64/i32_mul/const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-	(i32.const 10)
-	(i32.const 20)
-	(i32.mul)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b80a000000           	mov	eax, 0xa
-;;   11:	 6bc014               	imul	eax, eax, 0x14
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_mul/locals.wat b/winch/filetests/filetests/x64/i32_mul/locals.wat
deleted file mode 100644
index 32aab2b9e0e6..000000000000
--- a/winch/filetests/filetests/x64/i32_mul/locals.wat
+++ /dev/null
@@ -1,35 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i32)  
-        (local $bar i32)
-
-        (i32.const 10)
-        (local.set $foo)
-
-        (i32.const 20)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        i32.mul
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c893424             	mov	qword ptr [rsp], r14
-;;   15:	 b80a000000           	mov	eax, 0xa
-;;   1a:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1e:	 b814000000           	mov	eax, 0x14
-;;   23:	 89442408             	mov	dword ptr [rsp + 8], eax
-;;   27:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   2b:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   2f:	 0fafc8               	imul	ecx, eax
-;;   32:	 89c8                 	mov	eax, ecx
-;;   34:	 4883c410             	add	rsp, 0x10
-;;   38:	 5d                   	pop	rbp
-;;   39:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_mul/max.wat b/winch/filetests/filetests/x64/i32_mul/max.wat
deleted file mode 100644
index 9b842365ef6b..000000000000
--- a/winch/filetests/filetests/x64/i32_mul/max.wat
+++ /dev/null
@@ -1,17 +0,0 @@
-;;! target = "x86_64"
-(module
-    (func (result i32)
-	(i32.const 0x7fffffff)
-	(i32.const -1)
-	(i32.mul)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b8ffffff7f           	mov	eax, 0x7fffffff
-;;   11:	 6bc0ff               	imul	eax, eax, -1
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_mul/max_one.wat b/winch/filetests/filetests/x64/i32_mul/max_one.wat
deleted file mode 100644
index d384d6ab4397..000000000000
--- a/winch/filetests/filetests/x64/i32_mul/max_one.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-	(i32.const 0x80000000)
-	(i32.const -1)
-	(i32.mul)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b800000080           	mov	eax, 0x80000000
-;;   11:	 6bc0ff               	imul	eax, eax, -1
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_mul/mixed.wat b/winch/filetests/filetests/x64/i32_mul/mixed.wat
deleted file mode 100644
index 063aa3214ca5..000000000000
--- a/winch/filetests/filetests/x64/i32_mul/mixed.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const -1)
-	(i32.const 1)
-	(i32.mul)
-     )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b8ffffffff           	mov	eax, 0xffffffff
-;;   11:	 6bc001               	imul	eax, eax, 1
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_mul/params.wat b/winch/filetests/filetests/x64/i32_mul/params.wat
deleted file mode 100644
index 6ec764f3ca5c..000000000000
--- a/winch/filetests/filetests/x64/i32_mul/params.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i32) (param i32) (result i32)
-	(local.get 0)
-	(local.get 1)
-	(i32.mul)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   18:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   1c:	 0fafc8               	imul	ecx, eax
-;;   1f:	 89c8                 	mov	eax, ecx
-;;   21:	 4883c410             	add	rsp, 0x10
-;;   25:	 5d                   	pop	rbp
-;;   26:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_mul/signed.wat b/winch/filetests/filetests/x64/i32_mul/signed.wat
deleted file mode 100644
index ef48e29706df..000000000000
--- a/winch/filetests/filetests/x64/i32_mul/signed.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const -1)
-	(i32.const -1)
-	(i32.mul)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b8ffffffff           	mov	eax, 0xffffffff
-;;   11:	 6bc0ff               	imul	eax, eax, -1
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_mul/unsigned_with_zero.wat b/winch/filetests/filetests/x64/i32_mul/unsigned_with_zero.wat
deleted file mode 100644
index 79cde3b2cddc..000000000000
--- a/winch/filetests/filetests/x64/i32_mul/unsigned_with_zero.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const 1)
-     	(i32.const 0)
-    	(i32.mul)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 6bc000               	imul	eax, eax, 0
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_ne/const.wat b/winch/filetests/filetests/x64/i32_ne/const.wat
deleted file mode 100644
index 1f8e0c3f03a0..000000000000
--- a/winch/filetests/filetests/x64/i32_ne/const.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const 2)
-        (i32.const 3)
-        (i32.ne)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b802000000           	mov	eax, 2
-;;   11:	 83f803               	cmp	eax, 3
-;;   14:	 b800000000           	mov	eax, 0
-;;   19:	 400f95c0             	setne	al
-;;   1d:	 4883c408             	add	rsp, 8
-;;   21:	 5d                   	pop	rbp
-;;   22:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_ne/locals.wat b/winch/filetests/filetests/x64/i32_ne/locals.wat
deleted file mode 100644
index 1086d1775438..000000000000
--- a/winch/filetests/filetests/x64/i32_ne/locals.wat
+++ /dev/null
@@ -1,36 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i32)
-        (local $bar i32)
-
-        (i32.const 2)
-        (local.set $foo)
-        (i32.const 3)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i32.ne)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c893424             	mov	qword ptr [rsp], r14
-;;   15:	 b802000000           	mov	eax, 2
-;;   1a:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1e:	 b803000000           	mov	eax, 3
-;;   23:	 89442408             	mov	dword ptr [rsp + 8], eax
-;;   27:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   2b:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   2f:	 39c1                 	cmp	ecx, eax
-;;   31:	 b900000000           	mov	ecx, 0
-;;   36:	 400f95c1             	setne	cl
-;;   3a:	 89c8                 	mov	eax, ecx
-;;   3c:	 4883c410             	add	rsp, 0x10
-;;   40:	 5d                   	pop	rbp
-;;   41:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_ne/params.wat b/winch/filetests/filetests/x64/i32_ne/params.wat
deleted file mode 100644
index 5a095154f5be..000000000000
--- a/winch/filetests/filetests/x64/i32_ne/params.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i32) (param i32) (result i32)
-        (local.get 0)
-        (local.get 1)
-        (i32.ne)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   18:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   1c:	 39c1                 	cmp	ecx, eax
-;;   1e:	 b900000000           	mov	ecx, 0
-;;   23:	 400f95c1             	setne	cl
-;;   27:	 89c8                 	mov	eax, ecx
-;;   29:	 4883c410             	add	rsp, 0x10
-;;   2d:	 5d                   	pop	rbp
-;;   2e:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_or/const.wat b/winch/filetests/filetests/x64/i32_or/const.wat
deleted file mode 100644
index 908089d4370e..000000000000
--- a/winch/filetests/filetests/x64/i32_or/const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const 1)
-        (i32.const 2)
-        (i32.or)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 83c802               	or	eax, 2
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_or/locals.wat b/winch/filetests/filetests/x64/i32_or/locals.wat
deleted file mode 100644
index 22cd613adc3e..000000000000
--- a/winch/filetests/filetests/x64/i32_or/locals.wat
+++ /dev/null
@@ -1,35 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i32)  
-        (local $bar i32)
-
-        (i32.const 1)
-        (local.set $foo)
-
-        (i32.const 2)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i32.or)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c893424             	mov	qword ptr [rsp], r14
-;;   15:	 b801000000           	mov	eax, 1
-;;   1a:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1e:	 b802000000           	mov	eax, 2
-;;   23:	 89442408             	mov	dword ptr [rsp + 8], eax
-;;   27:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   2b:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   2f:	 09c1                 	or	ecx, eax
-;;   31:	 89c8                 	mov	eax, ecx
-;;   33:	 4883c410             	add	rsp, 0x10
-;;   37:	 5d                   	pop	rbp
-;;   38:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_or/params.wat b/winch/filetests/filetests/x64/i32_or/params.wat
deleted file mode 100644
index a18ec5d2afbf..000000000000
--- a/winch/filetests/filetests/x64/i32_or/params.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i32) (param i32) (result i32)
-        (local.get 0)
-        (local.get 1)
-        (i32.or)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   18:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   1c:	 09c1                 	or	ecx, eax
-;;   1e:	 89c8                 	mov	eax, ecx
-;;   20:	 4883c410             	add	rsp, 0x10
-;;   24:	 5d                   	pop	rbp
-;;   25:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_popcnt/const.wat b/winch/filetests/filetests/x64/i32_popcnt/const.wat
deleted file mode 100644
index 7a68bf3c2385..000000000000
--- a/winch/filetests/filetests/x64/i32_popcnt/const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_popcnt", "has_sse42"]
-
-(module
-    (func (result i32)
-      i32.const 3
-      i32.popcnt
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b803000000           	mov	eax, 3
-;;   11:	 f30fb8c0             	popcnt	eax, eax
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 5d                   	pop	rbp
-;;   1a:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_popcnt/fallback.wat b/winch/filetests/filetests/x64/i32_popcnt/fallback.wat
deleted file mode 100644
index 9dadfd649da2..000000000000
--- a/winch/filetests/filetests/x64/i32_popcnt/fallback.wat
+++ /dev/null
@@ -1,32 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-      i32.const 15
-      i32.popcnt
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b80f000000           	mov	eax, 0xf
-;;   11:	 89c1                 	mov	ecx, eax
-;;   13:	 c1e801               	shr	eax, 1
-;;   16:	 81e055555555         	and	eax, 0x55555555
-;;   1c:	 29c1                 	sub	ecx, eax
-;;   1e:	 89c8                 	mov	eax, ecx
-;;   20:	 41bb33333333         	mov	r11d, 0x33333333
-;;   26:	 4421d8               	and	eax, r11d
-;;   29:	 c1e902               	shr	ecx, 2
-;;   2c:	 4421d9               	and	ecx, r11d
-;;   2f:	 01c1                 	add	ecx, eax
-;;   31:	 89c8                 	mov	eax, ecx
-;;   33:	 c1e804               	shr	eax, 4
-;;   36:	 01c8                 	add	eax, ecx
-;;   38:	 81e00f0f0f0f         	and	eax, 0xf0f0f0f
-;;   3e:	 69c001010101         	imul	eax, eax, 0x1010101
-;;   44:	 c1e818               	shr	eax, 0x18
-;;   47:	 4883c408             	add	rsp, 8
-;;   4b:	 5d                   	pop	rbp
-;;   4c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_popcnt/reg.wat b/winch/filetests/filetests/x64/i32_popcnt/reg.wat
deleted file mode 100644
index e22caef10fbc..000000000000
--- a/winch/filetests/filetests/x64/i32_popcnt/reg.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_popcnt", "has_sse42"]
-
-(module
-    (func (param i32) (result i32)
-      local.get 0
-      i32.popcnt
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   11:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   15:	 f30fb8c0             	popcnt	eax, eax
-;;   19:	 4883c410             	add	rsp, 0x10
-;;   1d:	 5d                   	pop	rbp
-;;   1e:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_rems/const.wat b/winch/filetests/filetests/x64/i32_rems/const.wat
deleted file mode 100644
index c26fe91c865f..000000000000
--- a/winch/filetests/filetests/x64/i32_rems/const.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-	(i32.const 7)
-	(i32.const 5)
-	(i32.rem_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b905000000           	mov	ecx, 5
-;;   11:	 b807000000           	mov	eax, 7
-;;   16:	 99                   	cdq	
-;;   17:	 83f9ff               	cmp	ecx, -1
-;;   1a:	 0f850a000000         	jne	0x2a
-;;   20:	 ba00000000           	mov	edx, 0
-;;   25:	 e902000000           	jmp	0x2c
-;;   2a:	 f7f9                 	idiv	ecx
-;;   2c:	 89d0                 	mov	eax, edx
-;;   2e:	 4883c408             	add	rsp, 8
-;;   32:	 5d                   	pop	rbp
-;;   33:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_rems/one_zero.wat b/winch/filetests/filetests/x64/i32_rems/one_zero.wat
deleted file mode 100644
index fc4ddcc1437a..000000000000
--- a/winch/filetests/filetests/x64/i32_rems/one_zero.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-	(i32.const 1)
-	(i32.const 0)
-	(i32.rem_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b900000000           	mov	ecx, 0
-;;   11:	 b801000000           	mov	eax, 1
-;;   16:	 99                   	cdq	
-;;   17:	 83f9ff               	cmp	ecx, -1
-;;   1a:	 0f850a000000         	jne	0x2a
-;;   20:	 ba00000000           	mov	edx, 0
-;;   25:	 e902000000           	jmp	0x2c
-;;   2a:	 f7f9                 	idiv	ecx
-;;   2c:	 89d0                 	mov	eax, edx
-;;   2e:	 4883c408             	add	rsp, 8
-;;   32:	 5d                   	pop	rbp
-;;   33:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_rems/overflow.wat b/winch/filetests/filetests/x64/i32_rems/overflow.wat
deleted file mode 100644
index c142baee6d64..000000000000
--- a/winch/filetests/filetests/x64/i32_rems/overflow.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-	(i32.const 0x80000000)
-	(i32.const -1)
-	(i32.rem_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b9ffffffff           	mov	ecx, 0xffffffff
-;;   11:	 b800000080           	mov	eax, 0x80000000
-;;   16:	 99                   	cdq	
-;;   17:	 83f9ff               	cmp	ecx, -1
-;;   1a:	 0f850a000000         	jne	0x2a
-;;   20:	 ba00000000           	mov	edx, 0
-;;   25:	 e902000000           	jmp	0x2c
-;;   2a:	 f7f9                 	idiv	ecx
-;;   2c:	 89d0                 	mov	eax, edx
-;;   2e:	 4883c408             	add	rsp, 8
-;;   32:	 5d                   	pop	rbp
-;;   33:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_rems/params.wat b/winch/filetests/filetests/x64/i32_rems/params.wat
deleted file mode 100644
index fdc065d6f6a9..000000000000
--- a/winch/filetests/filetests/x64/i32_rems/params.wat
+++ /dev/null
@@ -1,27 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i32) (param i32) (result i32)
-	(local.get 0)
-	(local.get 1)
-	(i32.rem_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b4c2408             	mov	ecx, dword ptr [rsp + 8]
-;;   18:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   1c:	 99                   	cdq	
-;;   1d:	 83f9ff               	cmp	ecx, -1
-;;   20:	 0f850a000000         	jne	0x30
-;;   26:	 ba00000000           	mov	edx, 0
-;;   2b:	 e902000000           	jmp	0x32
-;;   30:	 f7f9                 	idiv	ecx
-;;   32:	 89d0                 	mov	eax, edx
-;;   34:	 4883c410             	add	rsp, 0x10
-;;   38:	 5d                   	pop	rbp
-;;   39:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_rems/zero_zero.wat b/winch/filetests/filetests/x64/i32_rems/zero_zero.wat
deleted file mode 100644
index 4e72472214b7..000000000000
--- a/winch/filetests/filetests/x64/i32_rems/zero_zero.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-	(i32.const 0)
-	(i32.const 0)
-	(i32.rem_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b900000000           	mov	ecx, 0
-;;   11:	 b800000000           	mov	eax, 0
-;;   16:	 99                   	cdq	
-;;   17:	 83f9ff               	cmp	ecx, -1
-;;   1a:	 0f850a000000         	jne	0x2a
-;;   20:	 ba00000000           	mov	edx, 0
-;;   25:	 e902000000           	jmp	0x2c
-;;   2a:	 f7f9                 	idiv	ecx
-;;   2c:	 89d0                 	mov	eax, edx
-;;   2e:	 4883c408             	add	rsp, 8
-;;   32:	 5d                   	pop	rbp
-;;   33:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_remu/const.wat b/winch/filetests/filetests/x64/i32_remu/const.wat
deleted file mode 100644
index e1bff6f8dbe5..000000000000
--- a/winch/filetests/filetests/x64/i32_remu/const.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-	(i32.const 7)
-	(i32.const 5)
-	(i32.rem_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b905000000           	mov	ecx, 5
-;;   11:	 b807000000           	mov	eax, 7
-;;   16:	 31d2                 	xor	edx, edx
-;;   18:	 f7f1                 	div	ecx
-;;   1a:	 89d0                 	mov	eax, edx
-;;   1c:	 4883c408             	add	rsp, 8
-;;   20:	 5d                   	pop	rbp
-;;   21:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_remu/one_zero.wat b/winch/filetests/filetests/x64/i32_remu/one_zero.wat
deleted file mode 100644
index 554600597d82..000000000000
--- a/winch/filetests/filetests/x64/i32_remu/one_zero.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-	(i32.const 1)
-	(i32.const 0)
-	(i32.rem_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b900000000           	mov	ecx, 0
-;;   11:	 b801000000           	mov	eax, 1
-;;   16:	 31d2                 	xor	edx, edx
-;;   18:	 f7f1                 	div	ecx
-;;   1a:	 89d0                 	mov	eax, edx
-;;   1c:	 4883c408             	add	rsp, 8
-;;   20:	 5d                   	pop	rbp
-;;   21:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_remu/params.wat b/winch/filetests/filetests/x64/i32_remu/params.wat
deleted file mode 100644
index 20e49a219173..000000000000
--- a/winch/filetests/filetests/x64/i32_remu/params.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i32) (param i32) (result i32)
-	(local.get 0)
-	(local.get 1)
-	(i32.rem_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b4c2408             	mov	ecx, dword ptr [rsp + 8]
-;;   18:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   1c:	 31d2                 	xor	edx, edx
-;;   1e:	 f7f1                 	div	ecx
-;;   20:	 89d0                 	mov	eax, edx
-;;   22:	 4883c410             	add	rsp, 0x10
-;;   26:	 5d                   	pop	rbp
-;;   27:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_remu/signed.wat b/winch/filetests/filetests/x64/i32_remu/signed.wat
deleted file mode 100644
index 752fcdd6eed6..000000000000
--- a/winch/filetests/filetests/x64/i32_remu/signed.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-	(i32.const -1)
-	(i32.const -1)
-	(i32.rem_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b9ffffffff           	mov	ecx, 0xffffffff
-;;   11:	 b8ffffffff           	mov	eax, 0xffffffff
-;;   16:	 31d2                 	xor	edx, edx
-;;   18:	 f7f1                 	div	ecx
-;;   1a:	 89d0                 	mov	eax, edx
-;;   1c:	 4883c408             	add	rsp, 8
-;;   20:	 5d                   	pop	rbp
-;;   21:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_remu/zero_zero.wat b/winch/filetests/filetests/x64/i32_remu/zero_zero.wat
deleted file mode 100644
index c20de67f3ed9..000000000000
--- a/winch/filetests/filetests/x64/i32_remu/zero_zero.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-	(i32.const 0)
-	(i32.const 0)
-	(i32.rem_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b900000000           	mov	ecx, 0
-;;   11:	 b800000000           	mov	eax, 0
-;;   16:	 31d2                 	xor	edx, edx
-;;   18:	 f7f1                 	div	ecx
-;;   1a:	 89d0                 	mov	eax, edx
-;;   1c:	 4883c408             	add	rsp, 8
-;;   20:	 5d                   	pop	rbp
-;;   21:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_rotl/16_const.wat b/winch/filetests/filetests/x64/i32_rotl/16_const.wat
deleted file mode 100644
index 55b6028e268b..000000000000
--- a/winch/filetests/filetests/x64/i32_rotl/16_const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const 1)
-        (i32.const 512)
-        (i32.rotl)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 c1c000               	rol	eax, 0
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_rotl/8_const.wat b/winch/filetests/filetests/x64/i32_rotl/8_const.wat
deleted file mode 100644
index 03d60e38bacd..000000000000
--- a/winch/filetests/filetests/x64/i32_rotl/8_const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const 1)
-        (i32.const 2)
-        (i32.rotl)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 c1c002               	rol	eax, 2
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_rotl/locals.wat b/winch/filetests/filetests/x64/i32_rotl/locals.wat
deleted file mode 100644
index 3c9f3c350cfe..000000000000
--- a/winch/filetests/filetests/x64/i32_rotl/locals.wat
+++ /dev/null
@@ -1,34 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i32)  
-        (local $bar i32)
-
-        (i32.const 1)
-        (local.set $foo)
-
-        (i32.const 2)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i32.rotl)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c893424             	mov	qword ptr [rsp], r14
-;;   15:	 b801000000           	mov	eax, 1
-;;   1a:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1e:	 b802000000           	mov	eax, 2
-;;   23:	 89442408             	mov	dword ptr [rsp + 8], eax
-;;   27:	 8b4c2408             	mov	ecx, dword ptr [rsp + 8]
-;;   2b:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   2f:	 d3c0                 	rol	eax, cl
-;;   31:	 4883c410             	add	rsp, 0x10
-;;   35:	 5d                   	pop	rbp
-;;   36:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_rotl/params.wat b/winch/filetests/filetests/x64/i32_rotl/params.wat
deleted file mode 100644
index c53c48db1494..000000000000
--- a/winch/filetests/filetests/x64/i32_rotl/params.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i32) (param i32) (result i32)
-        (local.get 0)
-        (local.get 1)
-        (i32.rotl)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b4c2408             	mov	ecx, dword ptr [rsp + 8]
-;;   18:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   1c:	 d3c0                 	rol	eax, cl
-;;   1e:	 4883c410             	add	rsp, 0x10
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_rotr/16_const.wat b/winch/filetests/filetests/x64/i32_rotr/16_const.wat
deleted file mode 100644
index d3190d05e150..000000000000
--- a/winch/filetests/filetests/x64/i32_rotr/16_const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const 1)
-        (i32.const 512)
-        (i32.rotr)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 c1c800               	ror	eax, 0
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_rotr/8_const.wat b/winch/filetests/filetests/x64/i32_rotr/8_const.wat
deleted file mode 100644
index f2b66bdbd677..000000000000
--- a/winch/filetests/filetests/x64/i32_rotr/8_const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const 1)
-        (i32.const 2)
-        (i32.rotr)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 c1c802               	ror	eax, 2
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_rotr/locals.wat b/winch/filetests/filetests/x64/i32_rotr/locals.wat
deleted file mode 100644
index fab967bd2665..000000000000
--- a/winch/filetests/filetests/x64/i32_rotr/locals.wat
+++ /dev/null
@@ -1,34 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i32)  
-        (local $bar i32)
-
-        (i32.const 1)
-        (local.set $foo)
-
-        (i32.const 2)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i32.rotr)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c893424             	mov	qword ptr [rsp], r14
-;;   15:	 b801000000           	mov	eax, 1
-;;   1a:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1e:	 b802000000           	mov	eax, 2
-;;   23:	 89442408             	mov	dword ptr [rsp + 8], eax
-;;   27:	 8b4c2408             	mov	ecx, dword ptr [rsp + 8]
-;;   2b:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   2f:	 d3c8                 	ror	eax, cl
-;;   31:	 4883c410             	add	rsp, 0x10
-;;   35:	 5d                   	pop	rbp
-;;   36:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_rotr/params.wat b/winch/filetests/filetests/x64/i32_rotr/params.wat
deleted file mode 100644
index b7c5452153d0..000000000000
--- a/winch/filetests/filetests/x64/i32_rotr/params.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i32) (param i32) (result i32)
-        (local.get 0)
-        (local.get 1)
-        (i32.rotr)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b4c2408             	mov	ecx, dword ptr [rsp + 8]
-;;   18:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   1c:	 d3c8                 	ror	eax, cl
-;;   1e:	 4883c410             	add	rsp, 0x10
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_shl/16_const.wat b/winch/filetests/filetests/x64/i32_shl/16_const.wat
deleted file mode 100644
index 1196dbd3c8dc..000000000000
--- a/winch/filetests/filetests/x64/i32_shl/16_const.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const 1)
-        (i32.const 512)
-        (i32.shl)
-    )
-)
-
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 c1e000               	shl	eax, 0
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_shl/8_const.wat b/winch/filetests/filetests/x64/i32_shl/8_const.wat
deleted file mode 100644
index 219b21bc71d2..000000000000
--- a/winch/filetests/filetests/x64/i32_shl/8_const.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const 1)
-        (i32.const 2)
-        (i32.shl)
-    )
-)
-
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 c1e002               	shl	eax, 2
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_shl/locals.wat b/winch/filetests/filetests/x64/i32_shl/locals.wat
deleted file mode 100644
index 0d05168acb59..000000000000
--- a/winch/filetests/filetests/x64/i32_shl/locals.wat
+++ /dev/null
@@ -1,34 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i32)  
-        (local $bar i32)
-
-        (i32.const 1)
-        (local.set $foo)
-
-        (i32.const 2)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i32.shl)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c893424             	mov	qword ptr [rsp], r14
-;;   15:	 b801000000           	mov	eax, 1
-;;   1a:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1e:	 b802000000           	mov	eax, 2
-;;   23:	 89442408             	mov	dword ptr [rsp + 8], eax
-;;   27:	 8b4c2408             	mov	ecx, dword ptr [rsp + 8]
-;;   2b:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   2f:	 d3e0                 	shl	eax, cl
-;;   31:	 4883c410             	add	rsp, 0x10
-;;   35:	 5d                   	pop	rbp
-;;   36:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_shl/params.wat b/winch/filetests/filetests/x64/i32_shl/params.wat
deleted file mode 100644
index 099ac2940b9f..000000000000
--- a/winch/filetests/filetests/x64/i32_shl/params.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i32) (param i32) (result i32)
-        (local.get 0)
-        (local.get 1)
-        (i32.shl)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b4c2408             	mov	ecx, dword ptr [rsp + 8]
-;;   18:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   1c:	 d3e0                 	shl	eax, cl
-;;   1e:	 4883c410             	add	rsp, 0x10
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_shr_s/16_const.wat b/winch/filetests/filetests/x64/i32_shr_s/16_const.wat
deleted file mode 100644
index 47d18ef5cb69..000000000000
--- a/winch/filetests/filetests/x64/i32_shr_s/16_const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const 1)
-        (i32.const 512)
-        (i32.shr_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 c1f800               	sar	eax, 0
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_shr_s/8_const.wat b/winch/filetests/filetests/x64/i32_shr_s/8_const.wat
deleted file mode 100644
index e6b1611961c7..000000000000
--- a/winch/filetests/filetests/x64/i32_shr_s/8_const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const 1)
-        (i32.const 2)
-        (i32.shr_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 c1f802               	sar	eax, 2
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_shr_s/locals.wat b/winch/filetests/filetests/x64/i32_shr_s/locals.wat
deleted file mode 100644
index c1794d59050f..000000000000
--- a/winch/filetests/filetests/x64/i32_shr_s/locals.wat
+++ /dev/null
@@ -1,34 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i32)  
-        (local $bar i32)
-
-        (i32.const 1)
-        (local.set $foo)
-
-        (i32.const 2)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i32.shr_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c893424             	mov	qword ptr [rsp], r14
-;;   15:	 b801000000           	mov	eax, 1
-;;   1a:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1e:	 b802000000           	mov	eax, 2
-;;   23:	 89442408             	mov	dword ptr [rsp + 8], eax
-;;   27:	 8b4c2408             	mov	ecx, dword ptr [rsp + 8]
-;;   2b:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   2f:	 d3f8                 	sar	eax, cl
-;;   31:	 4883c410             	add	rsp, 0x10
-;;   35:	 5d                   	pop	rbp
-;;   36:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_shr_s/params.wat b/winch/filetests/filetests/x64/i32_shr_s/params.wat
deleted file mode 100644
index 58ad20ab54fd..000000000000
--- a/winch/filetests/filetests/x64/i32_shr_s/params.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i32) (param i32) (result i32)
-        (local.get 0)
-        (local.get 1)
-        (i32.shr_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b4c2408             	mov	ecx, dword ptr [rsp + 8]
-;;   18:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   1c:	 d3f8                 	sar	eax, cl
-;;   1e:	 4883c410             	add	rsp, 0x10
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_shr_u/16_const.wat b/winch/filetests/filetests/x64/i32_shr_u/16_const.wat
deleted file mode 100644
index 0149d331739c..000000000000
--- a/winch/filetests/filetests/x64/i32_shr_u/16_const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const 1)
-        (i32.const 512)
-        (i32.shr_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 c1e800               	shr	eax, 0
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_shr_u/8_const.wat b/winch/filetests/filetests/x64/i32_shr_u/8_const.wat
deleted file mode 100644
index 065f2aef3409..000000000000
--- a/winch/filetests/filetests/x64/i32_shr_u/8_const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const 1)
-        (i32.const 2)
-        (i32.shr_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 c1e802               	shr	eax, 2
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_shr_u/locals.wat b/winch/filetests/filetests/x64/i32_shr_u/locals.wat
deleted file mode 100644
index 02b3a85b03bb..000000000000
--- a/winch/filetests/filetests/x64/i32_shr_u/locals.wat
+++ /dev/null
@@ -1,34 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i32)  
-        (local $bar i32)
-
-        (i32.const 1)
-        (local.set $foo)
-
-        (i32.const 2)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i32.shr_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c893424             	mov	qword ptr [rsp], r14
-;;   15:	 b801000000           	mov	eax, 1
-;;   1a:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1e:	 b802000000           	mov	eax, 2
-;;   23:	 89442408             	mov	dword ptr [rsp + 8], eax
-;;   27:	 8b4c2408             	mov	ecx, dword ptr [rsp + 8]
-;;   2b:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   2f:	 d3e8                 	shr	eax, cl
-;;   31:	 4883c410             	add	rsp, 0x10
-;;   35:	 5d                   	pop	rbp
-;;   36:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_shr_u/params.wat b/winch/filetests/filetests/x64/i32_shr_u/params.wat
deleted file mode 100644
index af61f5f1fd5b..000000000000
--- a/winch/filetests/filetests/x64/i32_shr_u/params.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i32) (param i32) (result i32)
-        (local.get 0)
-        (local.get 1)
-        (i32.shr_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b4c2408             	mov	ecx, dword ptr [rsp + 8]
-;;   18:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   1c:	 d3e8                 	shr	eax, cl
-;;   1e:	 4883c410             	add	rsp, 0x10
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_sub/const.wat b/winch/filetests/filetests/x64/i32_sub/const.wat
deleted file mode 100644
index 27959188d959..000000000000
--- a/winch/filetests/filetests/x64/i32_sub/const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-	(i32.const 10)
-	(i32.const 20)
-	(i32.sub)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b80a000000           	mov	eax, 0xa
-;;   11:	 83e814               	sub	eax, 0x14
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_sub/locals.wat b/winch/filetests/filetests/x64/i32_sub/locals.wat
deleted file mode 100644
index b8d1ea817ec7..000000000000
--- a/winch/filetests/filetests/x64/i32_sub/locals.wat
+++ /dev/null
@@ -1,35 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i32)  
-        (local $bar i32)
-
-        (i32.const 10)
-        (local.set $foo)
-
-        (i32.const 20)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        i32.sub
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c893424             	mov	qword ptr [rsp], r14
-;;   15:	 b80a000000           	mov	eax, 0xa
-;;   1a:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1e:	 b814000000           	mov	eax, 0x14
-;;   23:	 89442408             	mov	dword ptr [rsp + 8], eax
-;;   27:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   2b:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   2f:	 29c1                 	sub	ecx, eax
-;;   31:	 89c8                 	mov	eax, ecx
-;;   33:	 4883c410             	add	rsp, 0x10
-;;   37:	 5d                   	pop	rbp
-;;   38:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_sub/max.wat b/winch/filetests/filetests/x64/i32_sub/max.wat
deleted file mode 100644
index c988bd609388..000000000000
--- a/winch/filetests/filetests/x64/i32_sub/max.wat
+++ /dev/null
@@ -1,17 +0,0 @@
-;;! target = "x86_64"
-(module
-    (func (result i32)
-	(i32.const 0x7fffffff)
-	(i32.const -1)
-	(i32.sub)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b8ffffff7f           	mov	eax, 0x7fffffff
-;;   11:	 83e8ff               	sub	eax, -1
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_sub/max_one.wat b/winch/filetests/filetests/x64/i32_sub/max_one.wat
deleted file mode 100644
index e2d82efc7cc1..000000000000
--- a/winch/filetests/filetests/x64/i32_sub/max_one.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-	(i32.const 0x80000000)
-	(i32.const 1)
-	(i32.sub)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b800000080           	mov	eax, 0x80000000
-;;   11:	 83e801               	sub	eax, 1
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_sub/mixed.wat b/winch/filetests/filetests/x64/i32_sub/mixed.wat
deleted file mode 100644
index b44d7e41b6cf..000000000000
--- a/winch/filetests/filetests/x64/i32_sub/mixed.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const -1)
-	(i32.const 1)
-	(i32.sub)
-     )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b8ffffffff           	mov	eax, 0xffffffff
-;;   11:	 83e801               	sub	eax, 1
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_sub/params.wat b/winch/filetests/filetests/x64/i32_sub/params.wat
deleted file mode 100644
index 223f15fed10d..000000000000
--- a/winch/filetests/filetests/x64/i32_sub/params.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i32) (param i32) (result i32)
-	(local.get 0)
-	(local.get 1)
-	(i32.sub)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   18:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   1c:	 29c1                 	sub	ecx, eax
-;;   1e:	 89c8                 	mov	eax, ecx
-;;   20:	 4883c410             	add	rsp, 0x10
-;;   24:	 5d                   	pop	rbp
-;;   25:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_sub/signed.wat b/winch/filetests/filetests/x64/i32_sub/signed.wat
deleted file mode 100644
index 675b03ee0c71..000000000000
--- a/winch/filetests/filetests/x64/i32_sub/signed.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const -1)
-	(i32.const -1)
-	(i32.sub)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b8ffffffff           	mov	eax, 0xffffffff
-;;   11:	 83e8ff               	sub	eax, -1
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_sub/unsigned_with_zero.wat b/winch/filetests/filetests/x64/i32_sub/unsigned_with_zero.wat
deleted file mode 100644
index 1792f1bf828a..000000000000
--- a/winch/filetests/filetests/x64/i32_sub/unsigned_with_zero.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const 1)
-     	(i32.const 0)
-    	(i32.sub)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 83e800               	sub	eax, 0
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_xor/const.wat b/winch/filetests/filetests/x64/i32_xor/const.wat
deleted file mode 100644
index 91ffc0f6bed7..000000000000
--- a/winch/filetests/filetests/x64/i32_xor/const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i32.const 1)
-        (i32.const 2)
-        (i32.xor)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 83f002               	xor	eax, 2
-;;   14:	 4883c408             	add	rsp, 8
-;;   18:	 5d                   	pop	rbp
-;;   19:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_xor/locals.wat b/winch/filetests/filetests/x64/i32_xor/locals.wat
deleted file mode 100644
index c6280a594c1e..000000000000
--- a/winch/filetests/filetests/x64/i32_xor/locals.wat
+++ /dev/null
@@ -1,35 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i32)  
-        (local $bar i32)
-
-        (i32.const 1)
-        (local.set $foo)
-
-        (i32.const 2)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i32.xor)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c893424             	mov	qword ptr [rsp], r14
-;;   15:	 b801000000           	mov	eax, 1
-;;   1a:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1e:	 b802000000           	mov	eax, 2
-;;   23:	 89442408             	mov	dword ptr [rsp + 8], eax
-;;   27:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   2b:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   2f:	 31c1                 	xor	ecx, eax
-;;   31:	 89c8                 	mov	eax, ecx
-;;   33:	 4883c410             	add	rsp, 0x10
-;;   37:	 5d                   	pop	rbp
-;;   38:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i32_xor/params.wat b/winch/filetests/filetests/x64/i32_xor/params.wat
deleted file mode 100644
index 66135e34329b..000000000000
--- a/winch/filetests/filetests/x64/i32_xor/params.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i32) (param i32) (result i32)
-        (local.get 0)
-        (local.get 1)
-        (i32.xor)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   18:	 8b4c240c             	mov	ecx, dword ptr [rsp + 0xc]
-;;   1c:	 31c1                 	xor	ecx, eax
-;;   1e:	 89c8                 	mov	eax, ecx
-;;   20:	 4883c410             	add	rsp, 0x10
-;;   24:	 5d                   	pop	rbp
-;;   25:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_add/const.wat b/winch/filetests/filetests/x64/i64_add/const.wat
deleted file mode 100644
index 68fc1f71af28..000000000000
--- a/winch/filetests/filetests/x64/i64_add/const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-	(i64.const 10)
-	(i64.const 20)
-	(i64.add)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c00a000000       	mov	rax, 0xa
-;;   13:	 4883c014             	add	rax, 0x14
-;;   17:	 4883c408             	add	rsp, 8
-;;   1b:	 5d                   	pop	rbp
-;;   1c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_add/locals.wat b/winch/filetests/filetests/x64/i64_add/locals.wat
deleted file mode 100644
index 8e6f591249bf..000000000000
--- a/winch/filetests/filetests/x64/i64_add/locals.wat
+++ /dev/null
@@ -1,36 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (local $foo i64)  
-        (local $bar i64)
-
-        (i64.const 10)
-        (local.set $foo)
-
-        (i64.const 20)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        i64.add
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 4531db               	xor	r11d, r11d
-;;    b:	 4c895c2410           	mov	qword ptr [rsp + 0x10], r11
-;;   10:	 4c895c2408           	mov	qword ptr [rsp + 8], r11
-;;   15:	 4c893424             	mov	qword ptr [rsp], r14
-;;   19:	 48c7c00a000000       	mov	rax, 0xa
-;;   20:	 4889442410           	mov	qword ptr [rsp + 0x10], rax
-;;   25:	 48c7c014000000       	mov	rax, 0x14
-;;   2c:	 4889442408           	mov	qword ptr [rsp + 8], rax
-;;   31:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   36:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   3b:	 4801c1               	add	rcx, rax
-;;   3e:	 4889c8               	mov	rax, rcx
-;;   41:	 4883c418             	add	rsp, 0x18
-;;   45:	 5d                   	pop	rbp
-;;   46:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_add/max.wat b/winch/filetests/filetests/x64/i64_add/max.wat
deleted file mode 100644
index c4a42ee0927f..000000000000
--- a/winch/filetests/filetests/x64/i64_add/max.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-;;! target = "x86_64"
-(module
-    (func (result i64)
-	(i64.const 1)
-	(i64.const 0x7fffffffffffffff)
-	(i64.add)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c001000000       	mov	rax, 1
-;;   13:	 49bbffffffffffffff7f 	
-;; 				movabs	r11, 0x7fffffffffffffff
-;;   1d:	 4c01d8               	add	rax, r11
-;;   20:	 4883c408             	add	rsp, 8
-;;   24:	 5d                   	pop	rbp
-;;   25:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_add/max_one.wat b/winch/filetests/filetests/x64/i64_add/max_one.wat
deleted file mode 100644
index 2116ed63a80e..000000000000
--- a/winch/filetests/filetests/x64/i64_add/max_one.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-	(i64.const 0x8000000000000000)
-	(i64.const -1)
-	(i64.add)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48b80000000000000080 	
-;; 				movabs	rax, 0x8000000000000000
-;;   16:	 4883c0ff             	add	rax, -1
-;;   1a:	 4883c408             	add	rsp, 8
-;;   1e:	 5d                   	pop	rbp
-;;   1f:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_add/mixed.wat b/winch/filetests/filetests/x64/i64_add/mixed.wat
deleted file mode 100644
index 422e3b9c2402..000000000000
--- a/winch/filetests/filetests/x64/i64_add/mixed.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (i64.const -1)
-	(i64.const 1)
-	(i64.add)
-     )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c0ffffffff       	mov	rax, 0xffffffffffffffff
-;;   13:	 4883c001             	add	rax, 1
-;;   17:	 4883c408             	add	rsp, 8
-;;   1b:	 5d                   	pop	rbp
-;;   1c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_add/params.wat b/winch/filetests/filetests/x64/i64_add/params.wat
deleted file mode 100644
index d91e2fa9f886..000000000000
--- a/winch/filetests/filetests/x64/i64_add/params.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i64) (param i64) (result i64)
-	(local.get 0)
-	(local.get 1)
-	(i64.add)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 48897c2410           	mov	qword ptr [rsp + 0x10], rdi
-;;    d:	 4889742408           	mov	qword ptr [rsp + 8], rsi
-;;   12:	 4c893424             	mov	qword ptr [rsp], r14
-;;   16:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   1b:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   20:	 4801c1               	add	rcx, rax
-;;   23:	 4889c8               	mov	rax, rcx
-;;   26:	 4883c418             	add	rsp, 0x18
-;;   2a:	 5d                   	pop	rbp
-;;   2b:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_add/signed.wat b/winch/filetests/filetests/x64/i64_add/signed.wat
deleted file mode 100644
index 654cb74227d4..000000000000
--- a/winch/filetests/filetests/x64/i64_add/signed.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (i64.const -1)
-	(i64.const -1)
-	(i64.add)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c0ffffffff       	mov	rax, 0xffffffffffffffff
-;;   13:	 4883c0ff             	add	rax, -1
-;;   17:	 4883c408             	add	rsp, 8
-;;   1b:	 5d                   	pop	rbp
-;;   1c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_add/unsigned_with_zero.wat b/winch/filetests/filetests/x64/i64_add/unsigned_with_zero.wat
deleted file mode 100644
index c18551921d4e..000000000000
--- a/winch/filetests/filetests/x64/i64_add/unsigned_with_zero.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (i64.const 1)
-     	(i64.const 0)
-    	(i64.add)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c001000000       	mov	rax, 1
-;;   13:	 4883c000             	add	rax, 0
-;;   17:	 4883c408             	add	rsp, 8
-;;   1b:	 5d                   	pop	rbp
-;;   1c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_and/32_const.wat b/winch/filetests/filetests/x64/i64_and/32_const.wat
deleted file mode 100644
index 41a5cec93cb0..000000000000
--- a/winch/filetests/filetests/x64/i64_and/32_const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (i64.const 2)
-        (i64.const 3)
-        (i64.and)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c002000000       	mov	rax, 2
-;;   13:	 4883e003             	and	rax, 3
-;;   17:	 4883c408             	add	rsp, 8
-;;   1b:	 5d                   	pop	rbp
-;;   1c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_and/64_const.wat b/winch/filetests/filetests/x64/i64_and/64_const.wat
deleted file mode 100644
index 0037bd20d2a8..000000000000
--- a/winch/filetests/filetests/x64/i64_and/64_const.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (i64.const 9223372036854775806)
-        (i64.const 9223372036854775807)
-        (i64.and)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48b8feffffffffffff7f 	
-;; 				movabs	rax, 0x7ffffffffffffffe
-;;   16:	 49bbffffffffffffff7f 	
-;; 				movabs	r11, 0x7fffffffffffffff
-;;   20:	 4c21d8               	and	rax, r11
-;;   23:	 4883c408             	add	rsp, 8
-;;   27:	 5d                   	pop	rbp
-;;   28:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_and/locals.wat b/winch/filetests/filetests/x64/i64_and/locals.wat
deleted file mode 100644
index 6ad83197733f..000000000000
--- a/winch/filetests/filetests/x64/i64_and/locals.wat
+++ /dev/null
@@ -1,35 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (local $foo i64)
-        (local $bar i64)
-
-        (i64.const 2)
-        (local.set $foo)
-        (i64.const 3)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i64.and)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 4531db               	xor	r11d, r11d
-;;    b:	 4c895c2410           	mov	qword ptr [rsp + 0x10], r11
-;;   10:	 4c895c2408           	mov	qword ptr [rsp + 8], r11
-;;   15:	 4c893424             	mov	qword ptr [rsp], r14
-;;   19:	 48c7c002000000       	mov	rax, 2
-;;   20:	 4889442410           	mov	qword ptr [rsp + 0x10], rax
-;;   25:	 48c7c003000000       	mov	rax, 3
-;;   2c:	 4889442408           	mov	qword ptr [rsp + 8], rax
-;;   31:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   36:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   3b:	 4821c1               	and	rcx, rax
-;;   3e:	 4889c8               	mov	rax, rcx
-;;   41:	 4883c418             	add	rsp, 0x18
-;;   45:	 5d                   	pop	rbp
-;;   46:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_and/params.wat b/winch/filetests/filetests/x64/i64_and/params.wat
deleted file mode 100644
index c8500bbe9756..000000000000
--- a/winch/filetests/filetests/x64/i64_and/params.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i64) (param i64) (result i64)
-        (local.get 0)
-        (local.get 1)
-        (i64.and)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 48897c2410           	mov	qword ptr [rsp + 0x10], rdi
-;;    d:	 4889742408           	mov	qword ptr [rsp + 8], rsi
-;;   12:	 4c893424             	mov	qword ptr [rsp], r14
-;;   16:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   1b:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   20:	 4821c1               	and	rcx, rax
-;;   23:	 4889c8               	mov	rax, rcx
-;;   26:	 4883c418             	add	rsp, 0x18
-;;   2a:	 5d                   	pop	rbp
-;;   2b:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_clz/lzcnt_const.wat b/winch/filetests/filetests/x64/i64_clz/lzcnt_const.wat
deleted file mode 100644
index 24d482debccb..000000000000
--- a/winch/filetests/filetests/x64/i64_clz/lzcnt_const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_lzcnt"]
-
-(module
-    (func (result i64)
-        (i64.const 1)
-        (i64.clz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c001000000       	mov	rax, 1
-;;   13:	 f3480fbdc0           	lzcnt	rax, rax
-;;   18:	 4883c408             	add	rsp, 8
-;;   1c:	 5d                   	pop	rbp
-;;   1d:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_clz/lzcnt_local.wat b/winch/filetests/filetests/x64/i64_clz/lzcnt_local.wat
deleted file mode 100644
index 6a0fffd4d029..000000000000
--- a/winch/filetests/filetests/x64/i64_clz/lzcnt_local.wat
+++ /dev/null
@@ -1,27 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_lzcnt"]
-
-(module
-    (func (result i64)
-        (local $foo i64)
-
-        (i64.const 2)
-        (local.set $foo)
-
-        (local.get $foo)
-        (i64.clz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c893424             	mov	qword ptr [rsp], r14
-;;   15:	 48c7c002000000       	mov	rax, 2
-;;   1c:	 4889442408           	mov	qword ptr [rsp + 8], rax
-;;   21:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   26:	 f3480fbdc0           	lzcnt	rax, rax
-;;   2b:	 4883c410             	add	rsp, 0x10
-;;   2f:	 5d                   	pop	rbp
-;;   30:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_clz/lzcnt_param.wat b/winch/filetests/filetests/x64/i64_clz/lzcnt_param.wat
deleted file mode 100644
index ad31e7a5adc0..000000000000
--- a/winch/filetests/filetests/x64/i64_clz/lzcnt_param.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_lzcnt"]
-
-(module
-    (func (param i64) (result i64)
-        (local.get 0)
-        (i64.clz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48897c2408           	mov	qword ptr [rsp + 8], rdi
-;;    d:	 4c893424             	mov	qword ptr [rsp], r14
-;;   11:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   16:	 f3480fbdc0           	lzcnt	rax, rax
-;;   1b:	 4883c410             	add	rsp, 0x10
-;;   1f:	 5d                   	pop	rbp
-;;   20:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_clz/no_lzcnt_const.wat b/winch/filetests/filetests/x64/i64_clz/no_lzcnt_const.wat
deleted file mode 100644
index 9176b554367d..000000000000
--- a/winch/filetests/filetests/x64/i64_clz/no_lzcnt_const.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (i64.const 1)
-        (i64.clz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c001000000       	mov	rax, 1
-;;   13:	 480fbdc0             	bsr	rax, rax
-;;   17:	 41bb00000000         	mov	r11d, 0
-;;   1d:	 410f95c3             	setne	r11b
-;;   21:	 48f7d8               	neg	rax
-;;   24:	 4883c040             	add	rax, 0x40
-;;   28:	 4c29d8               	sub	rax, r11
-;;   2b:	 4883c408             	add	rsp, 8
-;;   2f:	 5d                   	pop	rbp
-;;   30:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_clz/no_lzcnt_local.wat b/winch/filetests/filetests/x64/i64_clz/no_lzcnt_local.wat
deleted file mode 100644
index 2186bb4cc889..000000000000
--- a/winch/filetests/filetests/x64/i64_clz/no_lzcnt_local.wat
+++ /dev/null
@@ -1,31 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (local $foo i64)
-
-        (i64.const 2)
-        (local.set $foo)
-
-        (local.get $foo)
-        (i64.clz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c893424             	mov	qword ptr [rsp], r14
-;;   15:	 48c7c002000000       	mov	rax, 2
-;;   1c:	 4889442408           	mov	qword ptr [rsp + 8], rax
-;;   21:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   26:	 480fbdc0             	bsr	rax, rax
-;;   2a:	 41bb00000000         	mov	r11d, 0
-;;   30:	 410f95c3             	setne	r11b
-;;   34:	 48f7d8               	neg	rax
-;;   37:	 4883c040             	add	rax, 0x40
-;;   3b:	 4c29d8               	sub	rax, r11
-;;   3e:	 4883c410             	add	rsp, 0x10
-;;   42:	 5d                   	pop	rbp
-;;   43:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_clz/no_lzcnt_param.wat b/winch/filetests/filetests/x64/i64_clz/no_lzcnt_param.wat
deleted file mode 100644
index 718e17f0eeda..000000000000
--- a/winch/filetests/filetests/x64/i64_clz/no_lzcnt_param.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i64) (result i64)
-        (local.get 0)
-        (i64.clz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48897c2408           	mov	qword ptr [rsp + 8], rdi
-;;    d:	 4c893424             	mov	qword ptr [rsp], r14
-;;   11:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   16:	 480fbdc0             	bsr	rax, rax
-;;   1a:	 41bb00000000         	mov	r11d, 0
-;;   20:	 410f95c3             	setne	r11b
-;;   24:	 48f7d8               	neg	rax
-;;   27:	 4883c040             	add	rax, 0x40
-;;   2b:	 4c29d8               	sub	rax, r11
-;;   2e:	 4883c410             	add	rsp, 0x10
-;;   32:	 5d                   	pop	rbp
-;;   33:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_ctz/bmi1_const.wat b/winch/filetests/filetests/x64/i64_ctz/bmi1_const.wat
deleted file mode 100644
index aabb57a1b86d..000000000000
--- a/winch/filetests/filetests/x64/i64_ctz/bmi1_const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_bmi1"]
-
-(module
-    (func (result i64)
-        (i64.const 1)
-        (i64.ctz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c001000000       	mov	rax, 1
-;;   13:	 f3480fbcc0           	tzcnt	rax, rax
-;;   18:	 4883c408             	add	rsp, 8
-;;   1c:	 5d                   	pop	rbp
-;;   1d:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_ctz/bmi1_local.wat b/winch/filetests/filetests/x64/i64_ctz/bmi1_local.wat
deleted file mode 100644
index e002320cc27b..000000000000
--- a/winch/filetests/filetests/x64/i64_ctz/bmi1_local.wat
+++ /dev/null
@@ -1,27 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_bmi1"]
-
-(module
-    (func (result i64)
-        (local $foo i64)
-
-        (i64.const 2)
-        (local.set $foo)
-
-        (local.get $foo)
-        (i64.ctz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c893424             	mov	qword ptr [rsp], r14
-;;   15:	 48c7c002000000       	mov	rax, 2
-;;   1c:	 4889442408           	mov	qword ptr [rsp + 8], rax
-;;   21:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   26:	 f3480fbcc0           	tzcnt	rax, rax
-;;   2b:	 4883c410             	add	rsp, 0x10
-;;   2f:	 5d                   	pop	rbp
-;;   30:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_ctz/bmi1_param.wat b/winch/filetests/filetests/x64/i64_ctz/bmi1_param.wat
deleted file mode 100644
index b607754a4191..000000000000
--- a/winch/filetests/filetests/x64/i64_ctz/bmi1_param.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_bmi1"]
-
-(module
-    (func (param i64) (result i64)
-        (local.get 0)
-        (i64.ctz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48897c2408           	mov	qword ptr [rsp + 8], rdi
-;;    d:	 4c893424             	mov	qword ptr [rsp], r14
-;;   11:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   16:	 f3480fbcc0           	tzcnt	rax, rax
-;;   1b:	 4883c410             	add	rsp, 0x10
-;;   1f:	 5d                   	pop	rbp
-;;   20:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_ctz/no_bmi1_const.wat b/winch/filetests/filetests/x64/i64_ctz/no_bmi1_const.wat
deleted file mode 100644
index 5c17cc86c83b..000000000000
--- a/winch/filetests/filetests/x64/i64_ctz/no_bmi1_const.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (i64.const 1)
-        (i64.ctz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c001000000       	mov	rax, 1
-;;   13:	 480fbcc0             	bsf	rax, rax
-;;   17:	 41bb00000000         	mov	r11d, 0
-;;   1d:	 410f94c3             	sete	r11b
-;;   21:	 49c1e306             	shl	r11, 6
-;;   25:	 4c01d8               	add	rax, r11
-;;   28:	 4883c408             	add	rsp, 8
-;;   2c:	 5d                   	pop	rbp
-;;   2d:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_ctz/no_bmi1_local.wat b/winch/filetests/filetests/x64/i64_ctz/no_bmi1_local.wat
deleted file mode 100644
index 3c595d5fb845..000000000000
--- a/winch/filetests/filetests/x64/i64_ctz/no_bmi1_local.wat
+++ /dev/null
@@ -1,30 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (local $foo i64)
-
-        (i64.const 2)
-        (local.set $foo)
-
-        (local.get $foo)
-        (i64.ctz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c893424             	mov	qword ptr [rsp], r14
-;;   15:	 48c7c002000000       	mov	rax, 2
-;;   1c:	 4889442408           	mov	qword ptr [rsp + 8], rax
-;;   21:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   26:	 480fbcc0             	bsf	rax, rax
-;;   2a:	 41bb00000000         	mov	r11d, 0
-;;   30:	 410f94c3             	sete	r11b
-;;   34:	 49c1e306             	shl	r11, 6
-;;   38:	 4c01d8               	add	rax, r11
-;;   3b:	 4883c410             	add	rsp, 0x10
-;;   3f:	 5d                   	pop	rbp
-;;   40:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_ctz/no_bmi1_param.wat b/winch/filetests/filetests/x64/i64_ctz/no_bmi1_param.wat
deleted file mode 100644
index d8f669f11075..000000000000
--- a/winch/filetests/filetests/x64/i64_ctz/no_bmi1_param.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i64) (result i64)
-        (local.get 0)
-        (i64.ctz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48897c2408           	mov	qword ptr [rsp + 8], rdi
-;;    d:	 4c893424             	mov	qword ptr [rsp], r14
-;;   11:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   16:	 480fbcc0             	bsf	rax, rax
-;;   1a:	 41bb00000000         	mov	r11d, 0
-;;   20:	 410f94c3             	sete	r11b
-;;   24:	 49c1e306             	shl	r11, 6
-;;   28:	 4c01d8               	add	rax, r11
-;;   2b:	 4883c410             	add	rsp, 0x10
-;;   2f:	 5d                   	pop	rbp
-;;   30:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_divs/const.wat b/winch/filetests/filetests/x64/i64_divs/const.wat
deleted file mode 100644
index 1c32a1f926cd..000000000000
--- a/winch/filetests/filetests/x64/i64_divs/const.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-	(i64.const 20)
-	(i64.const 10)
-	(i64.div_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c10a000000       	mov	rcx, 0xa
-;;   13:	 48c7c014000000       	mov	rax, 0x14
-;;   1a:	 4883f900             	cmp	rcx, 0
-;;   1e:	 0f840b000000         	je	0x2f
-;;   24:	 4899                 	cqo	
-;;   26:	 48f7f9               	idiv	rcx
-;;   29:	 4883c408             	add	rsp, 8
-;;   2d:	 5d                   	pop	rbp
-;;   2e:	 c3                   	ret	
-;;   2f:	 0f0b                 	ud2	
diff --git a/winch/filetests/filetests/x64/i64_divs/one_zero.wat b/winch/filetests/filetests/x64/i64_divs/one_zero.wat
deleted file mode 100644
index fee46ab16572..000000000000
--- a/winch/filetests/filetests/x64/i64_divs/one_zero.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-	(i64.const 1)
-	(i64.const 0)
-	(i64.div_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c100000000       	mov	rcx, 0
-;;   13:	 48c7c001000000       	mov	rax, 1
-;;   1a:	 4883f900             	cmp	rcx, 0
-;;   1e:	 0f840b000000         	je	0x2f
-;;   24:	 4899                 	cqo	
-;;   26:	 48f7f9               	idiv	rcx
-;;   29:	 4883c408             	add	rsp, 8
-;;   2d:	 5d                   	pop	rbp
-;;   2e:	 c3                   	ret	
-;;   2f:	 0f0b                 	ud2	
diff --git a/winch/filetests/filetests/x64/i64_divs/overflow.wat b/winch/filetests/filetests/x64/i64_divs/overflow.wat
deleted file mode 100644
index 884fdd9fcaac..000000000000
--- a/winch/filetests/filetests/x64/i64_divs/overflow.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-	(i64.const 0x8000000000000000)
-	(i64.const -1)
-	(i64.div_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c1ffffffff       	mov	rcx, 0xffffffffffffffff
-;;   13:	 48b80000000000000080 	
-;; 				movabs	rax, 0x8000000000000000
-;;   1d:	 4883f900             	cmp	rcx, 0
-;;   21:	 0f840b000000         	je	0x32
-;;   27:	 4899                 	cqo	
-;;   29:	 48f7f9               	idiv	rcx
-;;   2c:	 4883c408             	add	rsp, 8
-;;   30:	 5d                   	pop	rbp
-;;   31:	 c3                   	ret	
-;;   32:	 0f0b                 	ud2	
diff --git a/winch/filetests/filetests/x64/i64_divs/params.wat b/winch/filetests/filetests/x64/i64_divs/params.wat
deleted file mode 100644
index ff5e0ae00ba5..000000000000
--- a/winch/filetests/filetests/x64/i64_divs/params.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i64) (param i64) (result i64)
-	(local.get 0)
-	(local.get 1)
-	(i64.div_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 48897c2410           	mov	qword ptr [rsp + 0x10], rdi
-;;    d:	 4889742408           	mov	qword ptr [rsp + 8], rsi
-;;   12:	 4c893424             	mov	qword ptr [rsp], r14
-;;   16:	 488b4c2408           	mov	rcx, qword ptr [rsp + 8]
-;;   1b:	 488b442410           	mov	rax, qword ptr [rsp + 0x10]
-;;   20:	 4883f900             	cmp	rcx, 0
-;;   24:	 0f840b000000         	je	0x35
-;;   2a:	 4899                 	cqo	
-;;   2c:	 48f7f9               	idiv	rcx
-;;   2f:	 4883c418             	add	rsp, 0x18
-;;   33:	 5d                   	pop	rbp
-;;   34:	 c3                   	ret	
-;;   35:	 0f0b                 	ud2	
diff --git a/winch/filetests/filetests/x64/i64_divs/zero_zero.wat b/winch/filetests/filetests/x64/i64_divs/zero_zero.wat
deleted file mode 100644
index ed9c5786149a..000000000000
--- a/winch/filetests/filetests/x64/i64_divs/zero_zero.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-	(i64.const 0)
-	(i64.const 0)
-	(i64.div_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c100000000       	mov	rcx, 0
-;;   13:	 48c7c000000000       	mov	rax, 0
-;;   1a:	 4883f900             	cmp	rcx, 0
-;;   1e:	 0f840b000000         	je	0x2f
-;;   24:	 4899                 	cqo	
-;;   26:	 48f7f9               	idiv	rcx
-;;   29:	 4883c408             	add	rsp, 8
-;;   2d:	 5d                   	pop	rbp
-;;   2e:	 c3                   	ret	
-;;   2f:	 0f0b                 	ud2	
diff --git a/winch/filetests/filetests/x64/i64_divu/const.wat b/winch/filetests/filetests/x64/i64_divu/const.wat
deleted file mode 100644
index 7d740b482d54..000000000000
--- a/winch/filetests/filetests/x64/i64_divu/const.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-	(i64.const 20)
-	(i64.const 10)
-	(i64.div_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c10a000000       	mov	rcx, 0xa
-;;   13:	 48c7c014000000       	mov	rax, 0x14
-;;   1a:	 4831d2               	xor	rdx, rdx
-;;   1d:	 48f7f1               	div	rcx
-;;   20:	 4883c408             	add	rsp, 8
-;;   24:	 5d                   	pop	rbp
-;;   25:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_divu/one_zero.wat b/winch/filetests/filetests/x64/i64_divu/one_zero.wat
deleted file mode 100644
index 05d7609d0f97..000000000000
--- a/winch/filetests/filetests/x64/i64_divu/one_zero.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-	(i64.const 1)
-	(i64.const 0)
-	(i64.div_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c100000000       	mov	rcx, 0
-;;   13:	 48c7c001000000       	mov	rax, 1
-;;   1a:	 4831d2               	xor	rdx, rdx
-;;   1d:	 48f7f1               	div	rcx
-;;   20:	 4883c408             	add	rsp, 8
-;;   24:	 5d                   	pop	rbp
-;;   25:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_divu/params.wat b/winch/filetests/filetests/x64/i64_divu/params.wat
deleted file mode 100644
index 37f3be4423d5..000000000000
--- a/winch/filetests/filetests/x64/i64_divu/params.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i64) (param i64) (result i64)
-	(local.get 0)
-	(local.get 1)
-	(i64.div_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 48897c2410           	mov	qword ptr [rsp + 0x10], rdi
-;;    d:	 4889742408           	mov	qword ptr [rsp + 8], rsi
-;;   12:	 4c893424             	mov	qword ptr [rsp], r14
-;;   16:	 488b4c2408           	mov	rcx, qword ptr [rsp + 8]
-;;   1b:	 488b442410           	mov	rax, qword ptr [rsp + 0x10]
-;;   20:	 4831d2               	xor	rdx, rdx
-;;   23:	 48f7f1               	div	rcx
-;;   26:	 4883c418             	add	rsp, 0x18
-;;   2a:	 5d                   	pop	rbp
-;;   2b:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_divu/signed.wat b/winch/filetests/filetests/x64/i64_divu/signed.wat
deleted file mode 100644
index 67571edf9500..000000000000
--- a/winch/filetests/filetests/x64/i64_divu/signed.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-	(i64.const -1)
-	(i64.const -1)
-	(i64.div_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c1ffffffff       	mov	rcx, 0xffffffffffffffff
-;;   13:	 48c7c0ffffffff       	mov	rax, 0xffffffffffffffff
-;;   1a:	 4831d2               	xor	rdx, rdx
-;;   1d:	 48f7f1               	div	rcx
-;;   20:	 4883c408             	add	rsp, 8
-;;   24:	 5d                   	pop	rbp
-;;   25:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_divu/zero_zero.wat b/winch/filetests/filetests/x64/i64_divu/zero_zero.wat
deleted file mode 100644
index f5b0849bebc9..000000000000
--- a/winch/filetests/filetests/x64/i64_divu/zero_zero.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-	(i64.const 0)
-	(i64.const 0)
-	(i64.div_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c100000000       	mov	rcx, 0
-;;   13:	 48c7c000000000       	mov	rax, 0
-;;   1a:	 4831d2               	xor	rdx, rdx
-;;   1d:	 48f7f1               	div	rcx
-;;   20:	 4883c408             	add	rsp, 8
-;;   24:	 5d                   	pop	rbp
-;;   25:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_eq/32_const.wat b/winch/filetests/filetests/x64/i64_eq/32_const.wat
deleted file mode 100644
index 42e7dd0d814b..000000000000
--- a/winch/filetests/filetests/x64/i64_eq/32_const.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i64.const 2)
-        (i64.const 3)
-        (i64.eq)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c002000000       	mov	rax, 2
-;;   13:	 4883f803             	cmp	rax, 3
-;;   17:	 b800000000           	mov	eax, 0
-;;   1c:	 400f94c0             	sete	al
-;;   20:	 4883c408             	add	rsp, 8
-;;   24:	 5d                   	pop	rbp
-;;   25:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_eq/64_const.wat b/winch/filetests/filetests/x64/i64_eq/64_const.wat
deleted file mode 100644
index 22938f022182..000000000000
--- a/winch/filetests/filetests/x64/i64_eq/64_const.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i64.const 9223372036854775806)
-        (i64.const 9223372036854775807)
-        (i64.eq)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48b8feffffffffffff7f 	
-;; 				movabs	rax, 0x7ffffffffffffffe
-;;   16:	 49bbffffffffffffff7f 	
-;; 				movabs	r11, 0x7fffffffffffffff
-;;   20:	 4c39d8               	cmp	rax, r11
-;;   23:	 b800000000           	mov	eax, 0
-;;   28:	 400f94c0             	sete	al
-;;   2c:	 4883c408             	add	rsp, 8
-;;   30:	 5d                   	pop	rbp
-;;   31:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_eq/locals.wat b/winch/filetests/filetests/x64/i64_eq/locals.wat
deleted file mode 100644
index 8884b9d68459..000000000000
--- a/winch/filetests/filetests/x64/i64_eq/locals.wat
+++ /dev/null
@@ -1,37 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i64)
-        (local $bar i64)
-
-        (i64.const 2)
-        (local.set $foo)
-        (i64.const 3)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i64.eq)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 4531db               	xor	r11d, r11d
-;;    b:	 4c895c2410           	mov	qword ptr [rsp + 0x10], r11
-;;   10:	 4c895c2408           	mov	qword ptr [rsp + 8], r11
-;;   15:	 4c893424             	mov	qword ptr [rsp], r14
-;;   19:	 48c7c002000000       	mov	rax, 2
-;;   20:	 4889442410           	mov	qword ptr [rsp + 0x10], rax
-;;   25:	 48c7c003000000       	mov	rax, 3
-;;   2c:	 4889442408           	mov	qword ptr [rsp + 8], rax
-;;   31:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   36:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   3b:	 4839c1               	cmp	rcx, rax
-;;   3e:	 b900000000           	mov	ecx, 0
-;;   43:	 400f94c1             	sete	cl
-;;   47:	 4889c8               	mov	rax, rcx
-;;   4a:	 4883c418             	add	rsp, 0x18
-;;   4e:	 5d                   	pop	rbp
-;;   4f:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_eq/params.wat b/winch/filetests/filetests/x64/i64_eq/params.wat
deleted file mode 100644
index aed5174e312f..000000000000
--- a/winch/filetests/filetests/x64/i64_eq/params.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i64) (param i64) (result i32)
-        (local.get 0)
-        (local.get 1)
-        (i64.eq)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 48897c2410           	mov	qword ptr [rsp + 0x10], rdi
-;;    d:	 4889742408           	mov	qword ptr [rsp + 8], rsi
-;;   12:	 4c893424             	mov	qword ptr [rsp], r14
-;;   16:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   1b:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   20:	 4839c1               	cmp	rcx, rax
-;;   23:	 b900000000           	mov	ecx, 0
-;;   28:	 400f94c1             	sete	cl
-;;   2c:	 4889c8               	mov	rax, rcx
-;;   2f:	 4883c418             	add	rsp, 0x18
-;;   33:	 5d                   	pop	rbp
-;;   34:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_eqz/32_const.wat b/winch/filetests/filetests/x64/i64_eqz/32_const.wat
deleted file mode 100644
index 257d0f0067e4..000000000000
--- a/winch/filetests/filetests/x64/i64_eqz/32_const.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i64.const 1)
-        (i64.eqz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c001000000       	mov	rax, 1
-;;   13:	 4883f800             	cmp	rax, 0
-;;   17:	 b800000000           	mov	eax, 0
-;;   1c:	 400f94c0             	sete	al
-;;   20:	 4883c408             	add	rsp, 8
-;;   24:	 5d                   	pop	rbp
-;;   25:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_eqz/64_const.wat b/winch/filetests/filetests/x64/i64_eqz/64_const.wat
deleted file mode 100644
index 7326c59dedec..000000000000
--- a/winch/filetests/filetests/x64/i64_eqz/64_const.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i64.const 9223372036854775807)
-        (i64.eqz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48b8ffffffffffffff7f 	
-;; 				movabs	rax, 0x7fffffffffffffff
-;;   16:	 4883f800             	cmp	rax, 0
-;;   1a:	 b800000000           	mov	eax, 0
-;;   1f:	 400f94c0             	sete	al
-;;   23:	 4883c408             	add	rsp, 8
-;;   27:	 5d                   	pop	rbp
-;;   28:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_eqz/local.wat b/winch/filetests/filetests/x64/i64_eqz/local.wat
deleted file mode 100644
index 849164e6cc7f..000000000000
--- a/winch/filetests/filetests/x64/i64_eqz/local.wat
+++ /dev/null
@@ -1,28 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i64)
-
-        (i64.const 2)
-        (local.set $foo)
-
-        (local.get $foo)
-        (i64.eqz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c893424             	mov	qword ptr [rsp], r14
-;;   15:	 48c7c002000000       	mov	rax, 2
-;;   1c:	 4889442408           	mov	qword ptr [rsp + 8], rax
-;;   21:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   26:	 4883f800             	cmp	rax, 0
-;;   2a:	 b800000000           	mov	eax, 0
-;;   2f:	 400f94c0             	sete	al
-;;   33:	 4883c410             	add	rsp, 0x10
-;;   37:	 5d                   	pop	rbp
-;;   38:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_eqz/param.wat b/winch/filetests/filetests/x64/i64_eqz/param.wat
deleted file mode 100644
index 48972c40b832..000000000000
--- a/winch/filetests/filetests/x64/i64_eqz/param.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i64) (result i32)
-        (local.get 0)
-        (i64.eqz)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48897c2408           	mov	qword ptr [rsp + 8], rdi
-;;    d:	 4c893424             	mov	qword ptr [rsp], r14
-;;   11:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   16:	 4883f800             	cmp	rax, 0
-;;   1a:	 b800000000           	mov	eax, 0
-;;   1f:	 400f94c0             	sete	al
-;;   23:	 4883c410             	add	rsp, 0x10
-;;   27:	 5d                   	pop	rbp
-;;   28:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_ge_s/32_const.wat b/winch/filetests/filetests/x64/i64_ge_s/32_const.wat
deleted file mode 100644
index c95e0fbdcba3..000000000000
--- a/winch/filetests/filetests/x64/i64_ge_s/32_const.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i64.const 2)
-        (i64.const 3)
-        (i64.ge_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c002000000       	mov	rax, 2
-;;   13:	 4883f803             	cmp	rax, 3
-;;   17:	 b800000000           	mov	eax, 0
-;;   1c:	 400f9dc0             	setge	al
-;;   20:	 4883c408             	add	rsp, 8
-;;   24:	 5d                   	pop	rbp
-;;   25:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_ge_s/64_const.wat b/winch/filetests/filetests/x64/i64_ge_s/64_const.wat
deleted file mode 100644
index 6afa197c514e..000000000000
--- a/winch/filetests/filetests/x64/i64_ge_s/64_const.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i64.const 9223372036854775806)
-        (i64.const 9223372036854775807)
-        (i64.ge_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48b8feffffffffffff7f 	
-;; 				movabs	rax, 0x7ffffffffffffffe
-;;   16:	 49bbffffffffffffff7f 	
-;; 				movabs	r11, 0x7fffffffffffffff
-;;   20:	 4c39d8               	cmp	rax, r11
-;;   23:	 b800000000           	mov	eax, 0
-;;   28:	 400f9dc0             	setge	al
-;;   2c:	 4883c408             	add	rsp, 8
-;;   30:	 5d                   	pop	rbp
-;;   31:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_ge_s/locals.wat b/winch/filetests/filetests/x64/i64_ge_s/locals.wat
deleted file mode 100644
index 6339d2f2312c..000000000000
--- a/winch/filetests/filetests/x64/i64_ge_s/locals.wat
+++ /dev/null
@@ -1,37 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i64)
-        (local $bar i64)
-
-        (i64.const 2)
-        (local.set $foo)
-        (i64.const 3)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i64.ge_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 4531db               	xor	r11d, r11d
-;;    b:	 4c895c2410           	mov	qword ptr [rsp + 0x10], r11
-;;   10:	 4c895c2408           	mov	qword ptr [rsp + 8], r11
-;;   15:	 4c893424             	mov	qword ptr [rsp], r14
-;;   19:	 48c7c002000000       	mov	rax, 2
-;;   20:	 4889442410           	mov	qword ptr [rsp + 0x10], rax
-;;   25:	 48c7c003000000       	mov	rax, 3
-;;   2c:	 4889442408           	mov	qword ptr [rsp + 8], rax
-;;   31:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   36:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   3b:	 4839c1               	cmp	rcx, rax
-;;   3e:	 b900000000           	mov	ecx, 0
-;;   43:	 400f9dc1             	setge	cl
-;;   47:	 4889c8               	mov	rax, rcx
-;;   4a:	 4883c418             	add	rsp, 0x18
-;;   4e:	 5d                   	pop	rbp
-;;   4f:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_ge_s/params.wat b/winch/filetests/filetests/x64/i64_ge_s/params.wat
deleted file mode 100644
index 49a3ab656f81..000000000000
--- a/winch/filetests/filetests/x64/i64_ge_s/params.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i64) (param i64) (result i32)
-        (local.get 0)
-        (local.get 1)
-        (i64.ge_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 48897c2410           	mov	qword ptr [rsp + 0x10], rdi
-;;    d:	 4889742408           	mov	qword ptr [rsp + 8], rsi
-;;   12:	 4c893424             	mov	qword ptr [rsp], r14
-;;   16:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   1b:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   20:	 4839c1               	cmp	rcx, rax
-;;   23:	 b900000000           	mov	ecx, 0
-;;   28:	 400f9dc1             	setge	cl
-;;   2c:	 4889c8               	mov	rax, rcx
-;;   2f:	 4883c418             	add	rsp, 0x18
-;;   33:	 5d                   	pop	rbp
-;;   34:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_ge_u/32_const.wat b/winch/filetests/filetests/x64/i64_ge_u/32_const.wat
deleted file mode 100644
index 5f08ad8d0726..000000000000
--- a/winch/filetests/filetests/x64/i64_ge_u/32_const.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i64.const 2)
-        (i64.const 3)
-        (i64.ge_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c002000000       	mov	rax, 2
-;;   13:	 4883f803             	cmp	rax, 3
-;;   17:	 b800000000           	mov	eax, 0
-;;   1c:	 400f93c0             	setae	al
-;;   20:	 4883c408             	add	rsp, 8
-;;   24:	 5d                   	pop	rbp
-;;   25:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_ge_u/64_const.wat b/winch/filetests/filetests/x64/i64_ge_u/64_const.wat
deleted file mode 100644
index 3ecb689cd8f1..000000000000
--- a/winch/filetests/filetests/x64/i64_ge_u/64_const.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i64.const 9223372036854775806)
-        (i64.const 9223372036854775807)
-        (i64.ge_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48b8feffffffffffff7f 	
-;; 				movabs	rax, 0x7ffffffffffffffe
-;;   16:	 49bbffffffffffffff7f 	
-;; 				movabs	r11, 0x7fffffffffffffff
-;;   20:	 4c39d8               	cmp	rax, r11
-;;   23:	 b800000000           	mov	eax, 0
-;;   28:	 400f93c0             	setae	al
-;;   2c:	 4883c408             	add	rsp, 8
-;;   30:	 5d                   	pop	rbp
-;;   31:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_ge_u/locals.wat b/winch/filetests/filetests/x64/i64_ge_u/locals.wat
deleted file mode 100644
index f8b2d35f9134..000000000000
--- a/winch/filetests/filetests/x64/i64_ge_u/locals.wat
+++ /dev/null
@@ -1,37 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i64)
-        (local $bar i64)
-
-        (i64.const 2)
-        (local.set $foo)
-        (i64.const 3)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i64.ge_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 4531db               	xor	r11d, r11d
-;;    b:	 4c895c2410           	mov	qword ptr [rsp + 0x10], r11
-;;   10:	 4c895c2408           	mov	qword ptr [rsp + 8], r11
-;;   15:	 4c893424             	mov	qword ptr [rsp], r14
-;;   19:	 48c7c002000000       	mov	rax, 2
-;;   20:	 4889442410           	mov	qword ptr [rsp + 0x10], rax
-;;   25:	 48c7c003000000       	mov	rax, 3
-;;   2c:	 4889442408           	mov	qword ptr [rsp + 8], rax
-;;   31:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   36:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   3b:	 4839c1               	cmp	rcx, rax
-;;   3e:	 b900000000           	mov	ecx, 0
-;;   43:	 400f93c1             	setae	cl
-;;   47:	 4889c8               	mov	rax, rcx
-;;   4a:	 4883c418             	add	rsp, 0x18
-;;   4e:	 5d                   	pop	rbp
-;;   4f:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_ge_u/params.wat b/winch/filetests/filetests/x64/i64_ge_u/params.wat
deleted file mode 100644
index 2ca43e57eba1..000000000000
--- a/winch/filetests/filetests/x64/i64_ge_u/params.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i64) (param i64) (result i32)
-        (local.get 0)
-        (local.get 1)
-        (i64.ge_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 48897c2410           	mov	qword ptr [rsp + 0x10], rdi
-;;    d:	 4889742408           	mov	qword ptr [rsp + 8], rsi
-;;   12:	 4c893424             	mov	qword ptr [rsp], r14
-;;   16:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   1b:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   20:	 4839c1               	cmp	rcx, rax
-;;   23:	 b900000000           	mov	ecx, 0
-;;   28:	 400f93c1             	setae	cl
-;;   2c:	 4889c8               	mov	rax, rcx
-;;   2f:	 4883c418             	add	rsp, 0x18
-;;   33:	 5d                   	pop	rbp
-;;   34:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_gt_s/32_const.wat b/winch/filetests/filetests/x64/i64_gt_s/32_const.wat
deleted file mode 100644
index e7e8410cb185..000000000000
--- a/winch/filetests/filetests/x64/i64_gt_s/32_const.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i64.const 2)
-        (i64.const 3)
-        (i64.gt_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c002000000       	mov	rax, 2
-;;   13:	 4883f803             	cmp	rax, 3
-;;   17:	 b800000000           	mov	eax, 0
-;;   1c:	 400f9fc0             	setg	al
-;;   20:	 4883c408             	add	rsp, 8
-;;   24:	 5d                   	pop	rbp
-;;   25:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_gt_s/64_const.wat b/winch/filetests/filetests/x64/i64_gt_s/64_const.wat
deleted file mode 100644
index fea7b152f292..000000000000
--- a/winch/filetests/filetests/x64/i64_gt_s/64_const.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i64.const 9223372036854775806)
-        (i64.const 9223372036854775807)
-        (i64.gt_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48b8feffffffffffff7f 	
-;; 				movabs	rax, 0x7ffffffffffffffe
-;;   16:	 49bbffffffffffffff7f 	
-;; 				movabs	r11, 0x7fffffffffffffff
-;;   20:	 4c39d8               	cmp	rax, r11
-;;   23:	 b800000000           	mov	eax, 0
-;;   28:	 400f9fc0             	setg	al
-;;   2c:	 4883c408             	add	rsp, 8
-;;   30:	 5d                   	pop	rbp
-;;   31:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_gt_s/locals.wat b/winch/filetests/filetests/x64/i64_gt_s/locals.wat
deleted file mode 100644
index 10c5c4ec360a..000000000000
--- a/winch/filetests/filetests/x64/i64_gt_s/locals.wat
+++ /dev/null
@@ -1,37 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i64)
-        (local $bar i64)
-
-        (i64.const 2)
-        (local.set $foo)
-        (i64.const 3)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i64.gt_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 4531db               	xor	r11d, r11d
-;;    b:	 4c895c2410           	mov	qword ptr [rsp + 0x10], r11
-;;   10:	 4c895c2408           	mov	qword ptr [rsp + 8], r11
-;;   15:	 4c893424             	mov	qword ptr [rsp], r14
-;;   19:	 48c7c002000000       	mov	rax, 2
-;;   20:	 4889442410           	mov	qword ptr [rsp + 0x10], rax
-;;   25:	 48c7c003000000       	mov	rax, 3
-;;   2c:	 4889442408           	mov	qword ptr [rsp + 8], rax
-;;   31:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   36:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   3b:	 4839c1               	cmp	rcx, rax
-;;   3e:	 b900000000           	mov	ecx, 0
-;;   43:	 400f9fc1             	setg	cl
-;;   47:	 4889c8               	mov	rax, rcx
-;;   4a:	 4883c418             	add	rsp, 0x18
-;;   4e:	 5d                   	pop	rbp
-;;   4f:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_gt_s/params.wat b/winch/filetests/filetests/x64/i64_gt_s/params.wat
deleted file mode 100644
index 5e30853e0a9a..000000000000
--- a/winch/filetests/filetests/x64/i64_gt_s/params.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i64) (param i64) (result i32)
-        (local.get 0)
-        (local.get 1)
-        (i64.gt_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 48897c2410           	mov	qword ptr [rsp + 0x10], rdi
-;;    d:	 4889742408           	mov	qword ptr [rsp + 8], rsi
-;;   12:	 4c893424             	mov	qword ptr [rsp], r14
-;;   16:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   1b:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   20:	 4839c1               	cmp	rcx, rax
-;;   23:	 b900000000           	mov	ecx, 0
-;;   28:	 400f9fc1             	setg	cl
-;;   2c:	 4889c8               	mov	rax, rcx
-;;   2f:	 4883c418             	add	rsp, 0x18
-;;   33:	 5d                   	pop	rbp
-;;   34:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_gt_u/32_const.wat b/winch/filetests/filetests/x64/i64_gt_u/32_const.wat
deleted file mode 100644
index 9daca9975754..000000000000
--- a/winch/filetests/filetests/x64/i64_gt_u/32_const.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i64.const 2)
-        (i64.const 3)
-        (i64.gt_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c002000000       	mov	rax, 2
-;;   13:	 4883f803             	cmp	rax, 3
-;;   17:	 b800000000           	mov	eax, 0
-;;   1c:	 400f97c0             	seta	al
-;;   20:	 4883c408             	add	rsp, 8
-;;   24:	 5d                   	pop	rbp
-;;   25:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_gt_u/64_const.wat b/winch/filetests/filetests/x64/i64_gt_u/64_const.wat
deleted file mode 100644
index 88abfae9da04..000000000000
--- a/winch/filetests/filetests/x64/i64_gt_u/64_const.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i64.const 9223372036854775806)
-        (i64.const 9223372036854775807)
-        (i64.gt_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48b8feffffffffffff7f 	
-;; 				movabs	rax, 0x7ffffffffffffffe
-;;   16:	 49bbffffffffffffff7f 	
-;; 				movabs	r11, 0x7fffffffffffffff
-;;   20:	 4c39d8               	cmp	rax, r11
-;;   23:	 b800000000           	mov	eax, 0
-;;   28:	 400f97c0             	seta	al
-;;   2c:	 4883c408             	add	rsp, 8
-;;   30:	 5d                   	pop	rbp
-;;   31:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_gt_u/locals.wat b/winch/filetests/filetests/x64/i64_gt_u/locals.wat
deleted file mode 100644
index 9890d2ca6bb1..000000000000
--- a/winch/filetests/filetests/x64/i64_gt_u/locals.wat
+++ /dev/null
@@ -1,37 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i64)
-        (local $bar i64)
-
-        (i64.const 2)
-        (local.set $foo)
-        (i64.const 3)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i64.gt_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 4531db               	xor	r11d, r11d
-;;    b:	 4c895c2410           	mov	qword ptr [rsp + 0x10], r11
-;;   10:	 4c895c2408           	mov	qword ptr [rsp + 8], r11
-;;   15:	 4c893424             	mov	qword ptr [rsp], r14
-;;   19:	 48c7c002000000       	mov	rax, 2
-;;   20:	 4889442410           	mov	qword ptr [rsp + 0x10], rax
-;;   25:	 48c7c003000000       	mov	rax, 3
-;;   2c:	 4889442408           	mov	qword ptr [rsp + 8], rax
-;;   31:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   36:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   3b:	 4839c1               	cmp	rcx, rax
-;;   3e:	 b900000000           	mov	ecx, 0
-;;   43:	 400f97c1             	seta	cl
-;;   47:	 4889c8               	mov	rax, rcx
-;;   4a:	 4883c418             	add	rsp, 0x18
-;;   4e:	 5d                   	pop	rbp
-;;   4f:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_gt_u/params.wat b/winch/filetests/filetests/x64/i64_gt_u/params.wat
deleted file mode 100644
index e2e9d8654c3f..000000000000
--- a/winch/filetests/filetests/x64/i64_gt_u/params.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i64) (param i64) (result i32)
-        (local.get 0)
-        (local.get 1)
-        (i64.gt_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 48897c2410           	mov	qword ptr [rsp + 0x10], rdi
-;;    d:	 4889742408           	mov	qword ptr [rsp + 8], rsi
-;;   12:	 4c893424             	mov	qword ptr [rsp], r14
-;;   16:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   1b:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   20:	 4839c1               	cmp	rcx, rax
-;;   23:	 b900000000           	mov	ecx, 0
-;;   28:	 400f97c1             	seta	cl
-;;   2c:	 4889c8               	mov	rax, rcx
-;;   2f:	 4883c418             	add	rsp, 0x18
-;;   33:	 5d                   	pop	rbp
-;;   34:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_le_s/32_const.wat b/winch/filetests/filetests/x64/i64_le_s/32_const.wat
deleted file mode 100644
index 36785c4afe94..000000000000
--- a/winch/filetests/filetests/x64/i64_le_s/32_const.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i64.const 2)
-        (i64.const 3)
-        (i64.le_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c002000000       	mov	rax, 2
-;;   13:	 4883f803             	cmp	rax, 3
-;;   17:	 b800000000           	mov	eax, 0
-;;   1c:	 400f9ec0             	setle	al
-;;   20:	 4883c408             	add	rsp, 8
-;;   24:	 5d                   	pop	rbp
-;;   25:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_le_s/64_const.wat b/winch/filetests/filetests/x64/i64_le_s/64_const.wat
deleted file mode 100644
index 190995d9e518..000000000000
--- a/winch/filetests/filetests/x64/i64_le_s/64_const.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i64.const 9223372036854775806)
-        (i64.const 9223372036854775807)
-        (i64.le_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48b8feffffffffffff7f 	
-;; 				movabs	rax, 0x7ffffffffffffffe
-;;   16:	 49bbffffffffffffff7f 	
-;; 				movabs	r11, 0x7fffffffffffffff
-;;   20:	 4c39d8               	cmp	rax, r11
-;;   23:	 b800000000           	mov	eax, 0
-;;   28:	 400f9ec0             	setle	al
-;;   2c:	 4883c408             	add	rsp, 8
-;;   30:	 5d                   	pop	rbp
-;;   31:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_le_s/locals.wat b/winch/filetests/filetests/x64/i64_le_s/locals.wat
deleted file mode 100644
index d363621c3b18..000000000000
--- a/winch/filetests/filetests/x64/i64_le_s/locals.wat
+++ /dev/null
@@ -1,37 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i64)
-        (local $bar i64)
-
-        (i64.const 2)
-        (local.set $foo)
-        (i64.const 3)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i64.le_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 4531db               	xor	r11d, r11d
-;;    b:	 4c895c2410           	mov	qword ptr [rsp + 0x10], r11
-;;   10:	 4c895c2408           	mov	qword ptr [rsp + 8], r11
-;;   15:	 4c893424             	mov	qword ptr [rsp], r14
-;;   19:	 48c7c002000000       	mov	rax, 2
-;;   20:	 4889442410           	mov	qword ptr [rsp + 0x10], rax
-;;   25:	 48c7c003000000       	mov	rax, 3
-;;   2c:	 4889442408           	mov	qword ptr [rsp + 8], rax
-;;   31:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   36:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   3b:	 4839c1               	cmp	rcx, rax
-;;   3e:	 b900000000           	mov	ecx, 0
-;;   43:	 400f9ec1             	setle	cl
-;;   47:	 4889c8               	mov	rax, rcx
-;;   4a:	 4883c418             	add	rsp, 0x18
-;;   4e:	 5d                   	pop	rbp
-;;   4f:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_le_s/params.wat b/winch/filetests/filetests/x64/i64_le_s/params.wat
deleted file mode 100644
index 1df814ef2f03..000000000000
--- a/winch/filetests/filetests/x64/i64_le_s/params.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i64) (param i64) (result i32)
-        (local.get 0)
-        (local.get 1)
-        (i64.le_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 48897c2410           	mov	qword ptr [rsp + 0x10], rdi
-;;    d:	 4889742408           	mov	qword ptr [rsp + 8], rsi
-;;   12:	 4c893424             	mov	qword ptr [rsp], r14
-;;   16:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   1b:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   20:	 4839c1               	cmp	rcx, rax
-;;   23:	 b900000000           	mov	ecx, 0
-;;   28:	 400f9ec1             	setle	cl
-;;   2c:	 4889c8               	mov	rax, rcx
-;;   2f:	 4883c418             	add	rsp, 0x18
-;;   33:	 5d                   	pop	rbp
-;;   34:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_le_u/32_const.wat b/winch/filetests/filetests/x64/i64_le_u/32_const.wat
deleted file mode 100644
index 18601bf4e19b..000000000000
--- a/winch/filetests/filetests/x64/i64_le_u/32_const.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i64.const 2)
-        (i64.const 3)
-        (i64.le_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c002000000       	mov	rax, 2
-;;   13:	 4883f803             	cmp	rax, 3
-;;   17:	 b800000000           	mov	eax, 0
-;;   1c:	 400f96c0             	setbe	al
-;;   20:	 4883c408             	add	rsp, 8
-;;   24:	 5d                   	pop	rbp
-;;   25:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_le_u/64_const.wat b/winch/filetests/filetests/x64/i64_le_u/64_const.wat
deleted file mode 100644
index 0b11355deafa..000000000000
--- a/winch/filetests/filetests/x64/i64_le_u/64_const.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i64.const 9223372036854775806)
-        (i64.const 9223372036854775807)
-        (i64.le_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48b8feffffffffffff7f 	
-;; 				movabs	rax, 0x7ffffffffffffffe
-;;   16:	 49bbffffffffffffff7f 	
-;; 				movabs	r11, 0x7fffffffffffffff
-;;   20:	 4c39d8               	cmp	rax, r11
-;;   23:	 b800000000           	mov	eax, 0
-;;   28:	 400f96c0             	setbe	al
-;;   2c:	 4883c408             	add	rsp, 8
-;;   30:	 5d                   	pop	rbp
-;;   31:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_le_u/locals.wat b/winch/filetests/filetests/x64/i64_le_u/locals.wat
deleted file mode 100644
index 85eddc58343f..000000000000
--- a/winch/filetests/filetests/x64/i64_le_u/locals.wat
+++ /dev/null
@@ -1,37 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i64)
-        (local $bar i64)
-
-        (i64.const 2)
-        (local.set $foo)
-        (i64.const 3)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i64.le_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 4531db               	xor	r11d, r11d
-;;    b:	 4c895c2410           	mov	qword ptr [rsp + 0x10], r11
-;;   10:	 4c895c2408           	mov	qword ptr [rsp + 8], r11
-;;   15:	 4c893424             	mov	qword ptr [rsp], r14
-;;   19:	 48c7c002000000       	mov	rax, 2
-;;   20:	 4889442410           	mov	qword ptr [rsp + 0x10], rax
-;;   25:	 48c7c003000000       	mov	rax, 3
-;;   2c:	 4889442408           	mov	qword ptr [rsp + 8], rax
-;;   31:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   36:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   3b:	 4839c1               	cmp	rcx, rax
-;;   3e:	 b900000000           	mov	ecx, 0
-;;   43:	 400f96c1             	setbe	cl
-;;   47:	 4889c8               	mov	rax, rcx
-;;   4a:	 4883c418             	add	rsp, 0x18
-;;   4e:	 5d                   	pop	rbp
-;;   4f:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_le_u/params.wat b/winch/filetests/filetests/x64/i64_le_u/params.wat
deleted file mode 100644
index 113b16ffacad..000000000000
--- a/winch/filetests/filetests/x64/i64_le_u/params.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i64) (param i64) (result i32)
-        (local.get 0)
-        (local.get 1)
-        (i64.le_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 48897c2410           	mov	qword ptr [rsp + 0x10], rdi
-;;    d:	 4889742408           	mov	qword ptr [rsp + 8], rsi
-;;   12:	 4c893424             	mov	qword ptr [rsp], r14
-;;   16:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   1b:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   20:	 4839c1               	cmp	rcx, rax
-;;   23:	 b900000000           	mov	ecx, 0
-;;   28:	 400f96c1             	setbe	cl
-;;   2c:	 4889c8               	mov	rax, rcx
-;;   2f:	 4883c418             	add	rsp, 0x18
-;;   33:	 5d                   	pop	rbp
-;;   34:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_lt_s/32_const.wat b/winch/filetests/filetests/x64/i64_lt_s/32_const.wat
deleted file mode 100644
index fcc8359cec5a..000000000000
--- a/winch/filetests/filetests/x64/i64_lt_s/32_const.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i64.const 2)
-        (i64.const 3)
-        (i64.lt_s)
-    )
-)
-
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c002000000       	mov	rax, 2
-;;   13:	 4883f803             	cmp	rax, 3
-;;   17:	 b800000000           	mov	eax, 0
-;;   1c:	 400f9cc0             	setl	al
-;;   20:	 4883c408             	add	rsp, 8
-;;   24:	 5d                   	pop	rbp
-;;   25:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_lt_s/64_const.wat b/winch/filetests/filetests/x64/i64_lt_s/64_const.wat
deleted file mode 100644
index 01c8e29abfcf..000000000000
--- a/winch/filetests/filetests/x64/i64_lt_s/64_const.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i64.const 9223372036854775806)
-        (i64.const 9223372036854775807)
-        (i64.lt_s)
-    )
-)
-
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48b8feffffffffffff7f 	
-;; 				movabs	rax, 0x7ffffffffffffffe
-;;   16:	 49bbffffffffffffff7f 	
-;; 				movabs	r11, 0x7fffffffffffffff
-;;   20:	 4c39d8               	cmp	rax, r11
-;;   23:	 b800000000           	mov	eax, 0
-;;   28:	 400f9cc0             	setl	al
-;;   2c:	 4883c408             	add	rsp, 8
-;;   30:	 5d                   	pop	rbp
-;;   31:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_lt_s/locals.wat b/winch/filetests/filetests/x64/i64_lt_s/locals.wat
deleted file mode 100644
index 0a10518f54c9..000000000000
--- a/winch/filetests/filetests/x64/i64_lt_s/locals.wat
+++ /dev/null
@@ -1,38 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i64)
-        (local $bar i64)
-
-        (i64.const 2)
-        (local.set $foo)
-        (i64.const 3)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i64.lt_s)
-    )
-)
-
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 4531db               	xor	r11d, r11d
-;;    b:	 4c895c2410           	mov	qword ptr [rsp + 0x10], r11
-;;   10:	 4c895c2408           	mov	qword ptr [rsp + 8], r11
-;;   15:	 4c893424             	mov	qword ptr [rsp], r14
-;;   19:	 48c7c002000000       	mov	rax, 2
-;;   20:	 4889442410           	mov	qword ptr [rsp + 0x10], rax
-;;   25:	 48c7c003000000       	mov	rax, 3
-;;   2c:	 4889442408           	mov	qword ptr [rsp + 8], rax
-;;   31:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   36:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   3b:	 4839c1               	cmp	rcx, rax
-;;   3e:	 b900000000           	mov	ecx, 0
-;;   43:	 400f9cc1             	setl	cl
-;;   47:	 4889c8               	mov	rax, rcx
-;;   4a:	 4883c418             	add	rsp, 0x18
-;;   4e:	 5d                   	pop	rbp
-;;   4f:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_lt_s/params.wat b/winch/filetests/filetests/x64/i64_lt_s/params.wat
deleted file mode 100644
index daafe27aa99d..000000000000
--- a/winch/filetests/filetests/x64/i64_lt_s/params.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i64) (param i64) (result i32)
-        (local.get 0)
-        (local.get 1)
-        (i64.lt_s)
-    )
-)
-
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 48897c2410           	mov	qword ptr [rsp + 0x10], rdi
-;;    d:	 4889742408           	mov	qword ptr [rsp + 8], rsi
-;;   12:	 4c893424             	mov	qword ptr [rsp], r14
-;;   16:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   1b:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   20:	 4839c1               	cmp	rcx, rax
-;;   23:	 b900000000           	mov	ecx, 0
-;;   28:	 400f9cc1             	setl	cl
-;;   2c:	 4889c8               	mov	rax, rcx
-;;   2f:	 4883c418             	add	rsp, 0x18
-;;   33:	 5d                   	pop	rbp
-;;   34:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_lt_u/32_const.wat b/winch/filetests/filetests/x64/i64_lt_u/32_const.wat
deleted file mode 100644
index c7fc90921e5b..000000000000
--- a/winch/filetests/filetests/x64/i64_lt_u/32_const.wat
+++ /dev/null
@@ -1,20 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i64.const 2)
-        (i64.const 3)
-        (i64.lt_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c002000000       	mov	rax, 2
-;;   13:	 4883f803             	cmp	rax, 3
-;;   17:	 b800000000           	mov	eax, 0
-;;   1c:	 400f92c0             	setb	al
-;;   20:	 4883c408             	add	rsp, 8
-;;   24:	 5d                   	pop	rbp
-;;   25:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_lt_u/64_const.wat b/winch/filetests/filetests/x64/i64_lt_u/64_const.wat
deleted file mode 100644
index 9de200f0052f..000000000000
--- a/winch/filetests/filetests/x64/i64_lt_u/64_const.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i64.const 9223372036854775806)
-        (i64.const 9223372036854775807)
-        (i64.lt_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48b8feffffffffffff7f 	
-;; 				movabs	rax, 0x7ffffffffffffffe
-;;   16:	 49bbffffffffffffff7f 	
-;; 				movabs	r11, 0x7fffffffffffffff
-;;   20:	 4c39d8               	cmp	rax, r11
-;;   23:	 b800000000           	mov	eax, 0
-;;   28:	 400f92c0             	setb	al
-;;   2c:	 4883c408             	add	rsp, 8
-;;   30:	 5d                   	pop	rbp
-;;   31:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_lt_u/locals.wat b/winch/filetests/filetests/x64/i64_lt_u/locals.wat
deleted file mode 100644
index eb5197430270..000000000000
--- a/winch/filetests/filetests/x64/i64_lt_u/locals.wat
+++ /dev/null
@@ -1,37 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i64)
-        (local $bar i64)
-
-        (i64.const 2)
-        (local.set $foo)
-        (i64.const 3)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i64.lt_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 4531db               	xor	r11d, r11d
-;;    b:	 4c895c2410           	mov	qword ptr [rsp + 0x10], r11
-;;   10:	 4c895c2408           	mov	qword ptr [rsp + 8], r11
-;;   15:	 4c893424             	mov	qword ptr [rsp], r14
-;;   19:	 48c7c002000000       	mov	rax, 2
-;;   20:	 4889442410           	mov	qword ptr [rsp + 0x10], rax
-;;   25:	 48c7c003000000       	mov	rax, 3
-;;   2c:	 4889442408           	mov	qword ptr [rsp + 8], rax
-;;   31:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   36:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   3b:	 4839c1               	cmp	rcx, rax
-;;   3e:	 b900000000           	mov	ecx, 0
-;;   43:	 400f92c1             	setb	cl
-;;   47:	 4889c8               	mov	rax, rcx
-;;   4a:	 4883c418             	add	rsp, 0x18
-;;   4e:	 5d                   	pop	rbp
-;;   4f:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_lt_u/params.wat b/winch/filetests/filetests/x64/i64_lt_u/params.wat
deleted file mode 100644
index c0697c6614d0..000000000000
--- a/winch/filetests/filetests/x64/i64_lt_u/params.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i64) (param i64) (result i32)
-        (local.get 0)
-        (local.get 1)
-        (i64.lt_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 48897c2410           	mov	qword ptr [rsp + 0x10], rdi
-;;    d:	 4889742408           	mov	qword ptr [rsp + 8], rsi
-;;   12:	 4c893424             	mov	qword ptr [rsp], r14
-;;   16:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   1b:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   20:	 4839c1               	cmp	rcx, rax
-;;   23:	 b900000000           	mov	ecx, 0
-;;   28:	 400f92c1             	setb	cl
-;;   2c:	 4889c8               	mov	rax, rcx
-;;   2f:	 4883c418             	add	rsp, 0x18
-;;   33:	 5d                   	pop	rbp
-;;   34:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_mul/const.wat b/winch/filetests/filetests/x64/i64_mul/const.wat
deleted file mode 100644
index 45d0f1525d4a..000000000000
--- a/winch/filetests/filetests/x64/i64_mul/const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-	(i64.const 10)
-	(i64.const 20)
-	(i64.mul)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c00a000000       	mov	rax, 0xa
-;;   13:	 486bc014             	imul	rax, rax, 0x14
-;;   17:	 4883c408             	add	rsp, 8
-;;   1b:	 5d                   	pop	rbp
-;;   1c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_mul/locals.wat b/winch/filetests/filetests/x64/i64_mul/locals.wat
deleted file mode 100644
index dde76c30b3aa..000000000000
--- a/winch/filetests/filetests/x64/i64_mul/locals.wat
+++ /dev/null
@@ -1,36 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (local $foo i64)  
-        (local $bar i64)
-
-        (i64.const 10)
-        (local.set $foo)
-
-        (i64.const 20)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        i64.mul
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 4531db               	xor	r11d, r11d
-;;    b:	 4c895c2410           	mov	qword ptr [rsp + 0x10], r11
-;;   10:	 4c895c2408           	mov	qword ptr [rsp + 8], r11
-;;   15:	 4c893424             	mov	qword ptr [rsp], r14
-;;   19:	 48c7c00a000000       	mov	rax, 0xa
-;;   20:	 4889442410           	mov	qword ptr [rsp + 0x10], rax
-;;   25:	 48c7c014000000       	mov	rax, 0x14
-;;   2c:	 4889442408           	mov	qword ptr [rsp + 8], rax
-;;   31:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   36:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   3b:	 480fafc8             	imul	rcx, rax
-;;   3f:	 4889c8               	mov	rax, rcx
-;;   42:	 4883c418             	add	rsp, 0x18
-;;   46:	 5d                   	pop	rbp
-;;   47:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_mul/max.wat b/winch/filetests/filetests/x64/i64_mul/max.wat
deleted file mode 100644
index 092774b90360..000000000000
--- a/winch/filetests/filetests/x64/i64_mul/max.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-(module
-    (func (result i64)
-	(i64.const 0x7fffffffffffffff)
-	(i64.const -1)
-	(i64.mul)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48b8ffffffffffffff7f 	
-;; 				movabs	rax, 0x7fffffffffffffff
-;;   16:	 486bc0ff             	imul	rax, rax, -1
-;;   1a:	 4883c408             	add	rsp, 8
-;;   1e:	 5d                   	pop	rbp
-;;   1f:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_mul/max_one.wat b/winch/filetests/filetests/x64/i64_mul/max_one.wat
deleted file mode 100644
index f2153c3580d1..000000000000
--- a/winch/filetests/filetests/x64/i64_mul/max_one.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-	(i64.const 0x8000000000000000)
-	(i64.const -1)
-	(i64.mul)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48b80000000000000080 	
-;; 				movabs	rax, 0x8000000000000000
-;;   16:	 486bc0ff             	imul	rax, rax, -1
-;;   1a:	 4883c408             	add	rsp, 8
-;;   1e:	 5d                   	pop	rbp
-;;   1f:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_mul/mixed.wat b/winch/filetests/filetests/x64/i64_mul/mixed.wat
deleted file mode 100644
index 25fe02977df8..000000000000
--- a/winch/filetests/filetests/x64/i64_mul/mixed.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (i64.const -1)
-	(i64.const 1)
-	(i64.mul)
-     )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c0ffffffff       	mov	rax, 0xffffffffffffffff
-;;   13:	 486bc001             	imul	rax, rax, 1
-;;   17:	 4883c408             	add	rsp, 8
-;;   1b:	 5d                   	pop	rbp
-;;   1c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_mul/params.wat b/winch/filetests/filetests/x64/i64_mul/params.wat
deleted file mode 100644
index 149eac4a6eb3..000000000000
--- a/winch/filetests/filetests/x64/i64_mul/params.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i64) (param i64) (result i64)
-	(local.get 0)
-	(local.get 1)
-	(i64.mul)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 48897c2410           	mov	qword ptr [rsp + 0x10], rdi
-;;    d:	 4889742408           	mov	qword ptr [rsp + 8], rsi
-;;   12:	 4c893424             	mov	qword ptr [rsp], r14
-;;   16:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   1b:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   20:	 480fafc8             	imul	rcx, rax
-;;   24:	 4889c8               	mov	rax, rcx
-;;   27:	 4883c418             	add	rsp, 0x18
-;;   2b:	 5d                   	pop	rbp
-;;   2c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_mul/signed.wat b/winch/filetests/filetests/x64/i64_mul/signed.wat
deleted file mode 100644
index 3dd7bc04382f..000000000000
--- a/winch/filetests/filetests/x64/i64_mul/signed.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (i64.const -1)
-	(i64.const -1)
-	(i64.mul)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c0ffffffff       	mov	rax, 0xffffffffffffffff
-;;   13:	 486bc0ff             	imul	rax, rax, -1
-;;   17:	 4883c408             	add	rsp, 8
-;;   1b:	 5d                   	pop	rbp
-;;   1c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_mul/unsigned_with_zero.wat b/winch/filetests/filetests/x64/i64_mul/unsigned_with_zero.wat
deleted file mode 100644
index 695606db36cf..000000000000
--- a/winch/filetests/filetests/x64/i64_mul/unsigned_with_zero.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (i64.const 1)
-     	(i64.const 0)
-    	(i64.mul)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c001000000       	mov	rax, 1
-;;   13:	 486bc000             	imul	rax, rax, 0
-;;   17:	 4883c408             	add	rsp, 8
-;;   1b:	 5d                   	pop	rbp
-;;   1c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_ne/32_const.wat b/winch/filetests/filetests/x64/i64_ne/32_const.wat
deleted file mode 100644
index 01e53867e2eb..000000000000
--- a/winch/filetests/filetests/x64/i64_ne/32_const.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i64.const 2)
-        (i64.const 3)
-        (i64.ne)
-    )
-)
-
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c002000000       	mov	rax, 2
-;;   13:	 4883f803             	cmp	rax, 3
-;;   17:	 b800000000           	mov	eax, 0
-;;   1c:	 400f95c0             	setne	al
-;;   20:	 4883c408             	add	rsp, 8
-;;   24:	 5d                   	pop	rbp
-;;   25:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_ne/64_const.wat b/winch/filetests/filetests/x64/i64_ne/64_const.wat
deleted file mode 100644
index b5907a137b0b..000000000000
--- a/winch/filetests/filetests/x64/i64_ne/64_const.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (i64.const 9223372036854775806)
-        (i64.const 9223372036854775807)
-        (i64.ne)
-    )
-)
-
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48b8feffffffffffff7f 	
-;; 				movabs	rax, 0x7ffffffffffffffe
-;;   16:	 49bbffffffffffffff7f 	
-;; 				movabs	r11, 0x7fffffffffffffff
-;;   20:	 4c39d8               	cmp	rax, r11
-;;   23:	 b800000000           	mov	eax, 0
-;;   28:	 400f95c0             	setne	al
-;;   2c:	 4883c408             	add	rsp, 8
-;;   30:	 5d                   	pop	rbp
-;;   31:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_ne/locals.wat b/winch/filetests/filetests/x64/i64_ne/locals.wat
deleted file mode 100644
index 49090a56e9e7..000000000000
--- a/winch/filetests/filetests/x64/i64_ne/locals.wat
+++ /dev/null
@@ -1,38 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i32)
-        (local $foo i64)
-        (local $bar i64)
-
-        (i64.const 2)
-        (local.set $foo)
-        (i64.const 3)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i64.ne)
-    )
-)
-
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 4531db               	xor	r11d, r11d
-;;    b:	 4c895c2410           	mov	qword ptr [rsp + 0x10], r11
-;;   10:	 4c895c2408           	mov	qword ptr [rsp + 8], r11
-;;   15:	 4c893424             	mov	qword ptr [rsp], r14
-;;   19:	 48c7c002000000       	mov	rax, 2
-;;   20:	 4889442410           	mov	qword ptr [rsp + 0x10], rax
-;;   25:	 48c7c003000000       	mov	rax, 3
-;;   2c:	 4889442408           	mov	qword ptr [rsp + 8], rax
-;;   31:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   36:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   3b:	 4839c1               	cmp	rcx, rax
-;;   3e:	 b900000000           	mov	ecx, 0
-;;   43:	 400f95c1             	setne	cl
-;;   47:	 4889c8               	mov	rax, rcx
-;;   4a:	 4883c418             	add	rsp, 0x18
-;;   4e:	 5d                   	pop	rbp
-;;   4f:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_ne/params.wat b/winch/filetests/filetests/x64/i64_ne/params.wat
deleted file mode 100644
index 0d08508c8f57..000000000000
--- a/winch/filetests/filetests/x64/i64_ne/params.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i64) (param i64) (result i32)
-        (local.get 0)
-        (local.get 1)
-        (i64.ne)
-    )
-)
-
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 48897c2410           	mov	qword ptr [rsp + 0x10], rdi
-;;    d:	 4889742408           	mov	qword ptr [rsp + 8], rsi
-;;   12:	 4c893424             	mov	qword ptr [rsp], r14
-;;   16:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   1b:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   20:	 4839c1               	cmp	rcx, rax
-;;   23:	 b900000000           	mov	ecx, 0
-;;   28:	 400f95c1             	setne	cl
-;;   2c:	 4889c8               	mov	rax, rcx
-;;   2f:	 4883c418             	add	rsp, 0x18
-;;   33:	 5d                   	pop	rbp
-;;   34:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_or/32_const.wat b/winch/filetests/filetests/x64/i64_or/32_const.wat
deleted file mode 100644
index dd35d78d05f5..000000000000
--- a/winch/filetests/filetests/x64/i64_or/32_const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (i64.const 2)
-        (i64.const 3)
-        (i64.or)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c002000000       	mov	rax, 2
-;;   13:	 4883c803             	or	rax, 3
-;;   17:	 4883c408             	add	rsp, 8
-;;   1b:	 5d                   	pop	rbp
-;;   1c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_or/64_const.wat b/winch/filetests/filetests/x64/i64_or/64_const.wat
deleted file mode 100644
index 0af959edb4ac..000000000000
--- a/winch/filetests/filetests/x64/i64_or/64_const.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (i64.const 9223372036854775806)
-        (i64.const 9223372036854775807)
-        (i64.or)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48b8feffffffffffff7f 	
-;; 				movabs	rax, 0x7ffffffffffffffe
-;;   16:	 49bbffffffffffffff7f 	
-;; 				movabs	r11, 0x7fffffffffffffff
-;;   20:	 4c09d8               	or	rax, r11
-;;   23:	 4883c408             	add	rsp, 8
-;;   27:	 5d                   	pop	rbp
-;;   28:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_or/locals.wat b/winch/filetests/filetests/x64/i64_or/locals.wat
deleted file mode 100644
index 248936ac9155..000000000000
--- a/winch/filetests/filetests/x64/i64_or/locals.wat
+++ /dev/null
@@ -1,35 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (local $foo i64)
-        (local $bar i64)
-
-        (i64.const 2)
-        (local.set $foo)
-        (i64.const 3)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i64.or)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 4531db               	xor	r11d, r11d
-;;    b:	 4c895c2410           	mov	qword ptr [rsp + 0x10], r11
-;;   10:	 4c895c2408           	mov	qword ptr [rsp + 8], r11
-;;   15:	 4c893424             	mov	qword ptr [rsp], r14
-;;   19:	 48c7c002000000       	mov	rax, 2
-;;   20:	 4889442410           	mov	qword ptr [rsp + 0x10], rax
-;;   25:	 48c7c003000000       	mov	rax, 3
-;;   2c:	 4889442408           	mov	qword ptr [rsp + 8], rax
-;;   31:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   36:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   3b:	 4809c1               	or	rcx, rax
-;;   3e:	 4889c8               	mov	rax, rcx
-;;   41:	 4883c418             	add	rsp, 0x18
-;;   45:	 5d                   	pop	rbp
-;;   46:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_or/params.wat b/winch/filetests/filetests/x64/i64_or/params.wat
deleted file mode 100644
index bf19e78fd4e6..000000000000
--- a/winch/filetests/filetests/x64/i64_or/params.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i64) (param i64) (result i64)
-        (local.get 0)
-        (local.get 1)
-        (i64.or)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 48897c2410           	mov	qword ptr [rsp + 0x10], rdi
-;;    d:	 4889742408           	mov	qword ptr [rsp + 8], rsi
-;;   12:	 4c893424             	mov	qword ptr [rsp], r14
-;;   16:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   1b:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   20:	 4809c1               	or	rcx, rax
-;;   23:	 4889c8               	mov	rax, rcx
-;;   26:	 4883c418             	add	rsp, 0x18
-;;   2a:	 5d                   	pop	rbp
-;;   2b:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_popcnt/const.wat b/winch/filetests/filetests/x64/i64_popcnt/const.wat
deleted file mode 100644
index 99d4973269f8..000000000000
--- a/winch/filetests/filetests/x64/i64_popcnt/const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_popcnt", "has_sse42"]
-
-(module
-    (func (result i64)
-      i64.const 3
-      i64.popcnt
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c003000000       	mov	rax, 3
-;;   13:	 f3480fb8c0           	popcnt	rax, rax
-;;   18:	 4883c408             	add	rsp, 8
-;;   1c:	 5d                   	pop	rbp
-;;   1d:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_popcnt/fallback.wat b/winch/filetests/filetests/x64/i64_popcnt/fallback.wat
deleted file mode 100644
index 5e2c49440783..000000000000
--- a/winch/filetests/filetests/x64/i64_popcnt/fallback.wat
+++ /dev/null
@@ -1,39 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-      i64.const 15
-      i64.popcnt
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c00f000000       	mov	rax, 0xf
-;;   13:	 4889c1               	mov	rcx, rax
-;;   16:	 48c1e801             	shr	rax, 1
-;;   1a:	 49bb5555555555555555 	
-;; 				movabs	r11, 0x5555555555555555
-;;   24:	 4c21d8               	and	rax, r11
-;;   27:	 4829c1               	sub	rcx, rax
-;;   2a:	 4889c8               	mov	rax, rcx
-;;   2d:	 49bb3333333333333333 	
-;; 				movabs	r11, 0x3333333333333333
-;;   37:	 4c21d8               	and	rax, r11
-;;   3a:	 48c1e902             	shr	rcx, 2
-;;   3e:	 4c21d9               	and	rcx, r11
-;;   41:	 4801c1               	add	rcx, rax
-;;   44:	 4889c8               	mov	rax, rcx
-;;   47:	 48c1e804             	shr	rax, 4
-;;   4b:	 4801c8               	add	rax, rcx
-;;   4e:	 49bb0f0f0f0f0f0f0f0f 	
-;; 				movabs	r11, 0xf0f0f0f0f0f0f0f
-;;   58:	 4c21d8               	and	rax, r11
-;;   5b:	 49bb0101010101010101 	
-;; 				movabs	r11, 0x101010101010101
-;;   65:	 490fafc3             	imul	rax, r11
-;;   69:	 48c1e838             	shr	rax, 0x38
-;;   6d:	 4883c408             	add	rsp, 8
-;;   71:	 5d                   	pop	rbp
-;;   72:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_popcnt/reg.wat b/winch/filetests/filetests/x64/i64_popcnt/reg.wat
deleted file mode 100644
index e03ff7ea3933..000000000000
--- a/winch/filetests/filetests/x64/i64_popcnt/reg.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-;;! target = "x86_64"
-;;! flags = ["has_popcnt", "has_sse42"]
-
-(module
-    (func (param i64) (result i64)
-      local.get 0
-      i64.popcnt
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48897c2408           	mov	qword ptr [rsp + 8], rdi
-;;    d:	 4c893424             	mov	qword ptr [rsp], r14
-;;   11:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   16:	 f3480fb8c0           	popcnt	rax, rax
-;;   1b:	 4883c410             	add	rsp, 0x10
-;;   1f:	 5d                   	pop	rbp
-;;   20:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_rems/const.wat b/winch/filetests/filetests/x64/i64_rems/const.wat
deleted file mode 100644
index 44c6156b485f..000000000000
--- a/winch/filetests/filetests/x64/i64_rems/const.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-	(i64.const 7)
-	(i64.const 5)
-	(i64.rem_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c105000000       	mov	rcx, 5
-;;   13:	 48c7c007000000       	mov	rax, 7
-;;   1a:	 4899                 	cqo	
-;;   1c:	 4883f9ff             	cmp	rcx, -1
-;;   20:	 0f850a000000         	jne	0x30
-;;   26:	 ba00000000           	mov	edx, 0
-;;   2b:	 e903000000           	jmp	0x33
-;;   30:	 48f7f9               	idiv	rcx
-;;   33:	 4889d0               	mov	rax, rdx
-;;   36:	 4883c408             	add	rsp, 8
-;;   3a:	 5d                   	pop	rbp
-;;   3b:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_rems/one_zero.wat b/winch/filetests/filetests/x64/i64_rems/one_zero.wat
deleted file mode 100644
index 19e6f79b4cae..000000000000
--- a/winch/filetests/filetests/x64/i64_rems/one_zero.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-	(i64.const 1)
-	(i64.const 0)
-	(i64.rem_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c100000000       	mov	rcx, 0
-;;   13:	 48c7c001000000       	mov	rax, 1
-;;   1a:	 4899                 	cqo	
-;;   1c:	 4883f9ff             	cmp	rcx, -1
-;;   20:	 0f850a000000         	jne	0x30
-;;   26:	 ba00000000           	mov	edx, 0
-;;   2b:	 e903000000           	jmp	0x33
-;;   30:	 48f7f9               	idiv	rcx
-;;   33:	 4889d0               	mov	rax, rdx
-;;   36:	 4883c408             	add	rsp, 8
-;;   3a:	 5d                   	pop	rbp
-;;   3b:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_rems/overflow.wat b/winch/filetests/filetests/x64/i64_rems/overflow.wat
deleted file mode 100644
index 2d7046c8463d..000000000000
--- a/winch/filetests/filetests/x64/i64_rems/overflow.wat
+++ /dev/null
@@ -1,26 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-	(i64.const 0x8000000000000000)
-	(i64.const -1)
-	(i64.rem_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c1ffffffff       	mov	rcx, 0xffffffffffffffff
-;;   13:	 48b80000000000000080 	
-;; 				movabs	rax, 0x8000000000000000
-;;   1d:	 4899                 	cqo	
-;;   1f:	 4883f9ff             	cmp	rcx, -1
-;;   23:	 0f850a000000         	jne	0x33
-;;   29:	 ba00000000           	mov	edx, 0
-;;   2e:	 e903000000           	jmp	0x36
-;;   33:	 48f7f9               	idiv	rcx
-;;   36:	 4889d0               	mov	rax, rdx
-;;   39:	 4883c408             	add	rsp, 8
-;;   3d:	 5d                   	pop	rbp
-;;   3e:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_rems/params.wat b/winch/filetests/filetests/x64/i64_rems/params.wat
deleted file mode 100644
index e2d58fd90a84..000000000000
--- a/winch/filetests/filetests/x64/i64_rems/params.wat
+++ /dev/null
@@ -1,27 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i64) (param i64) (result i64)
-	(local.get 0)
-	(local.get 1)
-	(i64.rem_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 48897c2410           	mov	qword ptr [rsp + 0x10], rdi
-;;    d:	 4889742408           	mov	qword ptr [rsp + 8], rsi
-;;   12:	 4c893424             	mov	qword ptr [rsp], r14
-;;   16:	 488b4c2408           	mov	rcx, qword ptr [rsp + 8]
-;;   1b:	 488b442410           	mov	rax, qword ptr [rsp + 0x10]
-;;   20:	 4899                 	cqo	
-;;   22:	 4883f9ff             	cmp	rcx, -1
-;;   26:	 0f850a000000         	jne	0x36
-;;   2c:	 ba00000000           	mov	edx, 0
-;;   31:	 e903000000           	jmp	0x39
-;;   36:	 48f7f9               	idiv	rcx
-;;   39:	 4889d0               	mov	rax, rdx
-;;   3c:	 4883c418             	add	rsp, 0x18
-;;   40:	 5d                   	pop	rbp
-;;   41:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_rems/zero_zero.wat b/winch/filetests/filetests/x64/i64_rems/zero_zero.wat
deleted file mode 100644
index 18204ecc9bcd..000000000000
--- a/winch/filetests/filetests/x64/i64_rems/zero_zero.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-	(i64.const 0)
-	(i64.const 0)
-	(i64.rem_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c100000000       	mov	rcx, 0
-;;   13:	 48c7c000000000       	mov	rax, 0
-;;   1a:	 4899                 	cqo	
-;;   1c:	 4883f9ff             	cmp	rcx, -1
-;;   20:	 0f850a000000         	jne	0x30
-;;   26:	 ba00000000           	mov	edx, 0
-;;   2b:	 e903000000           	jmp	0x33
-;;   30:	 48f7f9               	idiv	rcx
-;;   33:	 4889d0               	mov	rax, rdx
-;;   36:	 4883c408             	add	rsp, 8
-;;   3a:	 5d                   	pop	rbp
-;;   3b:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_remu/const.wat b/winch/filetests/filetests/x64/i64_remu/const.wat
deleted file mode 100644
index a668f329e83a..000000000000
--- a/winch/filetests/filetests/x64/i64_remu/const.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-	(i64.const 7)
-	(i64.const 5)
-	(i64.rem_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c105000000       	mov	rcx, 5
-;;   13:	 48c7c007000000       	mov	rax, 7
-;;   1a:	 4831d2               	xor	rdx, rdx
-;;   1d:	 48f7f1               	div	rcx
-;;   20:	 4889d0               	mov	rax, rdx
-;;   23:	 4883c408             	add	rsp, 8
-;;   27:	 5d                   	pop	rbp
-;;   28:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_remu/one_zero.wat b/winch/filetests/filetests/x64/i64_remu/one_zero.wat
deleted file mode 100644
index 1e76584db83b..000000000000
--- a/winch/filetests/filetests/x64/i64_remu/one_zero.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-	(i64.const 1)
-	(i64.const 0)
-	(i64.rem_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c100000000       	mov	rcx, 0
-;;   13:	 48c7c001000000       	mov	rax, 1
-;;   1a:	 4831d2               	xor	rdx, rdx
-;;   1d:	 48f7f1               	div	rcx
-;;   20:	 4889d0               	mov	rax, rdx
-;;   23:	 4883c408             	add	rsp, 8
-;;   27:	 5d                   	pop	rbp
-;;   28:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_remu/params.wat b/winch/filetests/filetests/x64/i64_remu/params.wat
deleted file mode 100644
index 276143fceb59..000000000000
--- a/winch/filetests/filetests/x64/i64_remu/params.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i64) (param i64) (result i64)
-	(local.get 0)
-	(local.get 1)
-	(i64.rem_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 48897c2410           	mov	qword ptr [rsp + 0x10], rdi
-;;    d:	 4889742408           	mov	qword ptr [rsp + 8], rsi
-;;   12:	 4c893424             	mov	qword ptr [rsp], r14
-;;   16:	 488b4c2408           	mov	rcx, qword ptr [rsp + 8]
-;;   1b:	 488b442410           	mov	rax, qword ptr [rsp + 0x10]
-;;   20:	 4831d2               	xor	rdx, rdx
-;;   23:	 48f7f1               	div	rcx
-;;   26:	 4889d0               	mov	rax, rdx
-;;   29:	 4883c418             	add	rsp, 0x18
-;;   2d:	 5d                   	pop	rbp
-;;   2e:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_remu/signed.wat b/winch/filetests/filetests/x64/i64_remu/signed.wat
deleted file mode 100644
index e51e01e3cc3a..000000000000
--- a/winch/filetests/filetests/x64/i64_remu/signed.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-	(i64.const -1)
-	(i64.const -1)
-	(i64.rem_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c1ffffffff       	mov	rcx, 0xffffffffffffffff
-;;   13:	 48c7c0ffffffff       	mov	rax, 0xffffffffffffffff
-;;   1a:	 4831d2               	xor	rdx, rdx
-;;   1d:	 48f7f1               	div	rcx
-;;   20:	 4889d0               	mov	rax, rdx
-;;   23:	 4883c408             	add	rsp, 8
-;;   27:	 5d                   	pop	rbp
-;;   28:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_remu/zero_zero.wat b/winch/filetests/filetests/x64/i64_remu/zero_zero.wat
deleted file mode 100644
index 4037015caa74..000000000000
--- a/winch/filetests/filetests/x64/i64_remu/zero_zero.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-	(i64.const 0)
-	(i64.const 0)
-	(i64.rem_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c100000000       	mov	rcx, 0
-;;   13:	 48c7c000000000       	mov	rax, 0
-;;   1a:	 4831d2               	xor	rdx, rdx
-;;   1d:	 48f7f1               	div	rcx
-;;   20:	 4889d0               	mov	rax, rdx
-;;   23:	 4883c408             	add	rsp, 8
-;;   27:	 5d                   	pop	rbp
-;;   28:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_rotl/16_const.wat b/winch/filetests/filetests/x64/i64_rotl/16_const.wat
deleted file mode 100644
index f335ff226707..000000000000
--- a/winch/filetests/filetests/x64/i64_rotl/16_const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (i64.const 1)
-        (i64.const 512)
-        (i64.rotl)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c001000000       	mov	rax, 1
-;;   13:	 48c1c000             	rol	rax, 0
-;;   17:	 4883c408             	add	rsp, 8
-;;   1b:	 5d                   	pop	rbp
-;;   1c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_rotl/8_const.wat b/winch/filetests/filetests/x64/i64_rotl/8_const.wat
deleted file mode 100644
index 1fac4db9940f..000000000000
--- a/winch/filetests/filetests/x64/i64_rotl/8_const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (i64.const 1)
-        (i64.const 2)
-        (i64.rotl)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c001000000       	mov	rax, 1
-;;   13:	 48c1c002             	rol	rax, 2
-;;   17:	 4883c408             	add	rsp, 8
-;;   1b:	 5d                   	pop	rbp
-;;   1c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_rotl/locals.wat b/winch/filetests/filetests/x64/i64_rotl/locals.wat
deleted file mode 100644
index 124a0565b941..000000000000
--- a/winch/filetests/filetests/x64/i64_rotl/locals.wat
+++ /dev/null
@@ -1,35 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (local $foo i64)  
-        (local $bar i64)
-
-        (i64.const 1)
-        (local.set $foo)
-
-        (i64.const 2)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i64.rotl)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 4531db               	xor	r11d, r11d
-;;    b:	 4c895c2410           	mov	qword ptr [rsp + 0x10], r11
-;;   10:	 4c895c2408           	mov	qword ptr [rsp + 8], r11
-;;   15:	 4c893424             	mov	qword ptr [rsp], r14
-;;   19:	 48c7c001000000       	mov	rax, 1
-;;   20:	 4889442410           	mov	qword ptr [rsp + 0x10], rax
-;;   25:	 48c7c002000000       	mov	rax, 2
-;;   2c:	 4889442408           	mov	qword ptr [rsp + 8], rax
-;;   31:	 488b4c2408           	mov	rcx, qword ptr [rsp + 8]
-;;   36:	 488b442410           	mov	rax, qword ptr [rsp + 0x10]
-;;   3b:	 48d3c0               	rol	rax, cl
-;;   3e:	 4883c418             	add	rsp, 0x18
-;;   42:	 5d                   	pop	rbp
-;;   43:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_rotl/params.wat b/winch/filetests/filetests/x64/i64_rotl/params.wat
deleted file mode 100644
index 978a14d7051d..000000000000
--- a/winch/filetests/filetests/x64/i64_rotl/params.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i64) (param i64) (result i64)
-        (local.get 0)
-        (local.get 1)
-        (i64.rotl)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 48897c2410           	mov	qword ptr [rsp + 0x10], rdi
-;;    d:	 4889742408           	mov	qword ptr [rsp + 8], rsi
-;;   12:	 4c893424             	mov	qword ptr [rsp], r14
-;;   16:	 488b4c2408           	mov	rcx, qword ptr [rsp + 8]
-;;   1b:	 488b442410           	mov	rax, qword ptr [rsp + 0x10]
-;;   20:	 48d3c0               	rol	rax, cl
-;;   23:	 4883c418             	add	rsp, 0x18
-;;   27:	 5d                   	pop	rbp
-;;   28:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_rotr/16_const.wat b/winch/filetests/filetests/x64/i64_rotr/16_const.wat
deleted file mode 100644
index b685eaba7c89..000000000000
--- a/winch/filetests/filetests/x64/i64_rotr/16_const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (i64.const 1)
-        (i64.const 512)
-        (i64.rotr)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c001000000       	mov	rax, 1
-;;   13:	 48c1c800             	ror	rax, 0
-;;   17:	 4883c408             	add	rsp, 8
-;;   1b:	 5d                   	pop	rbp
-;;   1c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_rotr/8_const.wat b/winch/filetests/filetests/x64/i64_rotr/8_const.wat
deleted file mode 100644
index 75132e828f6b..000000000000
--- a/winch/filetests/filetests/x64/i64_rotr/8_const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (i64.const 1)
-        (i64.const 2)
-        (i64.rotr)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c001000000       	mov	rax, 1
-;;   13:	 48c1c802             	ror	rax, 2
-;;   17:	 4883c408             	add	rsp, 8
-;;   1b:	 5d                   	pop	rbp
-;;   1c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_rotr/locals.wat b/winch/filetests/filetests/x64/i64_rotr/locals.wat
deleted file mode 100644
index cac36da8d4a7..000000000000
--- a/winch/filetests/filetests/x64/i64_rotr/locals.wat
+++ /dev/null
@@ -1,35 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (local $foo i64)  
-        (local $bar i64)
-
-        (i64.const 1)
-        (local.set $foo)
-
-        (i64.const 2)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i64.rotr)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 4531db               	xor	r11d, r11d
-;;    b:	 4c895c2410           	mov	qword ptr [rsp + 0x10], r11
-;;   10:	 4c895c2408           	mov	qword ptr [rsp + 8], r11
-;;   15:	 4c893424             	mov	qword ptr [rsp], r14
-;;   19:	 48c7c001000000       	mov	rax, 1
-;;   20:	 4889442410           	mov	qword ptr [rsp + 0x10], rax
-;;   25:	 48c7c002000000       	mov	rax, 2
-;;   2c:	 4889442408           	mov	qword ptr [rsp + 8], rax
-;;   31:	 488b4c2408           	mov	rcx, qword ptr [rsp + 8]
-;;   36:	 488b442410           	mov	rax, qword ptr [rsp + 0x10]
-;;   3b:	 48d3c8               	ror	rax, cl
-;;   3e:	 4883c418             	add	rsp, 0x18
-;;   42:	 5d                   	pop	rbp
-;;   43:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_rotr/params.wat b/winch/filetests/filetests/x64/i64_rotr/params.wat
deleted file mode 100644
index 0154d42ee7a8..000000000000
--- a/winch/filetests/filetests/x64/i64_rotr/params.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i64) (param i64) (result i64)
-        (local.get 0)
-        (local.get 1)
-        (i64.rotr)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 48897c2410           	mov	qword ptr [rsp + 0x10], rdi
-;;    d:	 4889742408           	mov	qword ptr [rsp + 8], rsi
-;;   12:	 4c893424             	mov	qword ptr [rsp], r14
-;;   16:	 488b4c2408           	mov	rcx, qword ptr [rsp + 8]
-;;   1b:	 488b442410           	mov	rax, qword ptr [rsp + 0x10]
-;;   20:	 48d3c8               	ror	rax, cl
-;;   23:	 4883c418             	add	rsp, 0x18
-;;   27:	 5d                   	pop	rbp
-;;   28:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_shl/16_const.wat b/winch/filetests/filetests/x64/i64_shl/16_const.wat
deleted file mode 100644
index bc06f3f1ca05..000000000000
--- a/winch/filetests/filetests/x64/i64_shl/16_const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (i64.const 1)
-        (i64.const 512)
-        (i64.shl)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c001000000       	mov	rax, 1
-;;   13:	 48c1e000             	shl	rax, 0
-;;   17:	 4883c408             	add	rsp, 8
-;;   1b:	 5d                   	pop	rbp
-;;   1c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_shl/8_const.wat b/winch/filetests/filetests/x64/i64_shl/8_const.wat
deleted file mode 100644
index fa1ab6aefa68..000000000000
--- a/winch/filetests/filetests/x64/i64_shl/8_const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (i64.const 1)
-        (i64.const 2)
-        (i64.shl)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c001000000       	mov	rax, 1
-;;   13:	 48c1e002             	shl	rax, 2
-;;   17:	 4883c408             	add	rsp, 8
-;;   1b:	 5d                   	pop	rbp
-;;   1c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_shl/locals.wat b/winch/filetests/filetests/x64/i64_shl/locals.wat
deleted file mode 100644
index 1f531bee1a1f..000000000000
--- a/winch/filetests/filetests/x64/i64_shl/locals.wat
+++ /dev/null
@@ -1,35 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (local $foo i64)  
-        (local $bar i64)
-
-        (i64.const 1)
-        (local.set $foo)
-
-        (i64.const 2)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i64.shl)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 4531db               	xor	r11d, r11d
-;;    b:	 4c895c2410           	mov	qword ptr [rsp + 0x10], r11
-;;   10:	 4c895c2408           	mov	qword ptr [rsp + 8], r11
-;;   15:	 4c893424             	mov	qword ptr [rsp], r14
-;;   19:	 48c7c001000000       	mov	rax, 1
-;;   20:	 4889442410           	mov	qword ptr [rsp + 0x10], rax
-;;   25:	 48c7c002000000       	mov	rax, 2
-;;   2c:	 4889442408           	mov	qword ptr [rsp + 8], rax
-;;   31:	 488b4c2408           	mov	rcx, qword ptr [rsp + 8]
-;;   36:	 488b442410           	mov	rax, qword ptr [rsp + 0x10]
-;;   3b:	 48d3e0               	shl	rax, cl
-;;   3e:	 4883c418             	add	rsp, 0x18
-;;   42:	 5d                   	pop	rbp
-;;   43:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_shl/params.wat b/winch/filetests/filetests/x64/i64_shl/params.wat
deleted file mode 100644
index e76c72140042..000000000000
--- a/winch/filetests/filetests/x64/i64_shl/params.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i64) (param i64) (result i64)
-        (local.get 0)
-        (local.get 1)
-        (i64.shl)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 48897c2410           	mov	qword ptr [rsp + 0x10], rdi
-;;    d:	 4889742408           	mov	qword ptr [rsp + 8], rsi
-;;   12:	 4c893424             	mov	qword ptr [rsp], r14
-;;   16:	 488b4c2408           	mov	rcx, qword ptr [rsp + 8]
-;;   1b:	 488b442410           	mov	rax, qword ptr [rsp + 0x10]
-;;   20:	 48d3e0               	shl	rax, cl
-;;   23:	 4883c418             	add	rsp, 0x18
-;;   27:	 5d                   	pop	rbp
-;;   28:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_shr_s/16_const.wat b/winch/filetests/filetests/x64/i64_shr_s/16_const.wat
deleted file mode 100644
index 879fceef0435..000000000000
--- a/winch/filetests/filetests/x64/i64_shr_s/16_const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (i64.const 1)
-        (i64.const 512)
-        (i64.shr_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c001000000       	mov	rax, 1
-;;   13:	 48c1f800             	sar	rax, 0
-;;   17:	 4883c408             	add	rsp, 8
-;;   1b:	 5d                   	pop	rbp
-;;   1c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_shr_s/8_const.wat b/winch/filetests/filetests/x64/i64_shr_s/8_const.wat
deleted file mode 100644
index a0db161b013f..000000000000
--- a/winch/filetests/filetests/x64/i64_shr_s/8_const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (i64.const 1)
-        (i64.const 2)
-        (i64.shr_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c001000000       	mov	rax, 1
-;;   13:	 48c1f802             	sar	rax, 2
-;;   17:	 4883c408             	add	rsp, 8
-;;   1b:	 5d                   	pop	rbp
-;;   1c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_shr_s/locals.wat b/winch/filetests/filetests/x64/i64_shr_s/locals.wat
deleted file mode 100644
index cb8575cc244b..000000000000
--- a/winch/filetests/filetests/x64/i64_shr_s/locals.wat
+++ /dev/null
@@ -1,35 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (local $foo i64)  
-        (local $bar i64)
-
-        (i64.const 1)
-        (local.set $foo)
-
-        (i64.const 2)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i64.shr_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 4531db               	xor	r11d, r11d
-;;    b:	 4c895c2410           	mov	qword ptr [rsp + 0x10], r11
-;;   10:	 4c895c2408           	mov	qword ptr [rsp + 8], r11
-;;   15:	 4c893424             	mov	qword ptr [rsp], r14
-;;   19:	 48c7c001000000       	mov	rax, 1
-;;   20:	 4889442410           	mov	qword ptr [rsp + 0x10], rax
-;;   25:	 48c7c002000000       	mov	rax, 2
-;;   2c:	 4889442408           	mov	qword ptr [rsp + 8], rax
-;;   31:	 488b4c2408           	mov	rcx, qword ptr [rsp + 8]
-;;   36:	 488b442410           	mov	rax, qword ptr [rsp + 0x10]
-;;   3b:	 48d3f8               	sar	rax, cl
-;;   3e:	 4883c418             	add	rsp, 0x18
-;;   42:	 5d                   	pop	rbp
-;;   43:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_shr_s/params.wat b/winch/filetests/filetests/x64/i64_shr_s/params.wat
deleted file mode 100644
index 8ea569c2815c..000000000000
--- a/winch/filetests/filetests/x64/i64_shr_s/params.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i64) (param i64) (result i64)
-        (local.get 0)
-        (local.get 1)
-        (i64.shr_s)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 48897c2410           	mov	qword ptr [rsp + 0x10], rdi
-;;    d:	 4889742408           	mov	qword ptr [rsp + 8], rsi
-;;   12:	 4c893424             	mov	qword ptr [rsp], r14
-;;   16:	 488b4c2408           	mov	rcx, qword ptr [rsp + 8]
-;;   1b:	 488b442410           	mov	rax, qword ptr [rsp + 0x10]
-;;   20:	 48d3f8               	sar	rax, cl
-;;   23:	 4883c418             	add	rsp, 0x18
-;;   27:	 5d                   	pop	rbp
-;;   28:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_shr_u/16_const.wat b/winch/filetests/filetests/x64/i64_shr_u/16_const.wat
deleted file mode 100644
index f82683de5ebd..000000000000
--- a/winch/filetests/filetests/x64/i64_shr_u/16_const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (i64.const 1)
-        (i64.const 512)
-        (i64.shr_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c001000000       	mov	rax, 1
-;;   13:	 48c1e800             	shr	rax, 0
-;;   17:	 4883c408             	add	rsp, 8
-;;   1b:	 5d                   	pop	rbp
-;;   1c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_shr_u/8_const.wat b/winch/filetests/filetests/x64/i64_shr_u/8_const.wat
deleted file mode 100644
index 4db9d78fc14f..000000000000
--- a/winch/filetests/filetests/x64/i64_shr_u/8_const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (i64.const 1)
-        (i64.const 2)
-        (i64.shr_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c001000000       	mov	rax, 1
-;;   13:	 48c1e802             	shr	rax, 2
-;;   17:	 4883c408             	add	rsp, 8
-;;   1b:	 5d                   	pop	rbp
-;;   1c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_shr_u/locals.wat b/winch/filetests/filetests/x64/i64_shr_u/locals.wat
deleted file mode 100644
index 409286742956..000000000000
--- a/winch/filetests/filetests/x64/i64_shr_u/locals.wat
+++ /dev/null
@@ -1,35 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (local $foo i64)  
-        (local $bar i64)
-
-        (i64.const 1)
-        (local.set $foo)
-
-        (i64.const 2)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i64.shr_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 4531db               	xor	r11d, r11d
-;;    b:	 4c895c2410           	mov	qword ptr [rsp + 0x10], r11
-;;   10:	 4c895c2408           	mov	qword ptr [rsp + 8], r11
-;;   15:	 4c893424             	mov	qword ptr [rsp], r14
-;;   19:	 48c7c001000000       	mov	rax, 1
-;;   20:	 4889442410           	mov	qword ptr [rsp + 0x10], rax
-;;   25:	 48c7c002000000       	mov	rax, 2
-;;   2c:	 4889442408           	mov	qword ptr [rsp + 8], rax
-;;   31:	 488b4c2408           	mov	rcx, qword ptr [rsp + 8]
-;;   36:	 488b442410           	mov	rax, qword ptr [rsp + 0x10]
-;;   3b:	 48d3e8               	shr	rax, cl
-;;   3e:	 4883c418             	add	rsp, 0x18
-;;   42:	 5d                   	pop	rbp
-;;   43:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_shr_u/params.wat b/winch/filetests/filetests/x64/i64_shr_u/params.wat
deleted file mode 100644
index f4772e206600..000000000000
--- a/winch/filetests/filetests/x64/i64_shr_u/params.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i64) (param i64) (result i64)
-        (local.get 0)
-        (local.get 1)
-        (i64.shr_u)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 48897c2410           	mov	qword ptr [rsp + 0x10], rdi
-;;    d:	 4889742408           	mov	qword ptr [rsp + 8], rsi
-;;   12:	 4c893424             	mov	qword ptr [rsp], r14
-;;   16:	 488b4c2408           	mov	rcx, qword ptr [rsp + 8]
-;;   1b:	 488b442410           	mov	rax, qword ptr [rsp + 0x10]
-;;   20:	 48d3e8               	shr	rax, cl
-;;   23:	 4883c418             	add	rsp, 0x18
-;;   27:	 5d                   	pop	rbp
-;;   28:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_sub/const.wat b/winch/filetests/filetests/x64/i64_sub/const.wat
deleted file mode 100644
index 36cc0afa57d3..000000000000
--- a/winch/filetests/filetests/x64/i64_sub/const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-	(i64.const 10)
-	(i64.const 20)
-	(i64.sub)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c00a000000       	mov	rax, 0xa
-;;   13:	 4883e814             	sub	rax, 0x14
-;;   17:	 4883c408             	add	rsp, 8
-;;   1b:	 5d                   	pop	rbp
-;;   1c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_sub/locals.wat b/winch/filetests/filetests/x64/i64_sub/locals.wat
deleted file mode 100644
index bcccf49a97ea..000000000000
--- a/winch/filetests/filetests/x64/i64_sub/locals.wat
+++ /dev/null
@@ -1,36 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (local $foo i64)  
-        (local $bar i64)
-
-        (i64.const 10)
-        (local.set $foo)
-
-        (i64.const 20)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        i64.sub
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 4531db               	xor	r11d, r11d
-;;    b:	 4c895c2410           	mov	qword ptr [rsp + 0x10], r11
-;;   10:	 4c895c2408           	mov	qword ptr [rsp + 8], r11
-;;   15:	 4c893424             	mov	qword ptr [rsp], r14
-;;   19:	 48c7c00a000000       	mov	rax, 0xa
-;;   20:	 4889442410           	mov	qword ptr [rsp + 0x10], rax
-;;   25:	 48c7c014000000       	mov	rax, 0x14
-;;   2c:	 4889442408           	mov	qword ptr [rsp + 8], rax
-;;   31:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   36:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   3b:	 4829c1               	sub	rcx, rax
-;;   3e:	 4889c8               	mov	rax, rcx
-;;   41:	 4883c418             	add	rsp, 0x18
-;;   45:	 5d                   	pop	rbp
-;;   46:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_sub/max.wat b/winch/filetests/filetests/x64/i64_sub/max.wat
deleted file mode 100644
index 513f778dd6ff..000000000000
--- a/winch/filetests/filetests/x64/i64_sub/max.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-(module
-    (func (result i64)
-	(i64.const 0x7fffffffffffffff)
-	(i64.const -1)
-	(i64.sub)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48b8ffffffffffffff7f 	
-;; 				movabs	rax, 0x7fffffffffffffff
-;;   16:	 4883e8ff             	sub	rax, -1
-;;   1a:	 4883c408             	add	rsp, 8
-;;   1e:	 5d                   	pop	rbp
-;;   1f:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_sub/max_one.wat b/winch/filetests/filetests/x64/i64_sub/max_one.wat
deleted file mode 100644
index 0c016679fcf9..000000000000
--- a/winch/filetests/filetests/x64/i64_sub/max_one.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-	(i64.const 0x8000000000000000)
-	(i64.const 1)
-	(i64.sub)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48b80000000000000080 	
-;; 				movabs	rax, 0x8000000000000000
-;;   16:	 4883e801             	sub	rax, 1
-;;   1a:	 4883c408             	add	rsp, 8
-;;   1e:	 5d                   	pop	rbp
-;;   1f:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_sub/mixed.wat b/winch/filetests/filetests/x64/i64_sub/mixed.wat
deleted file mode 100644
index f72526a219dc..000000000000
--- a/winch/filetests/filetests/x64/i64_sub/mixed.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (i64.const -1)
-	(i64.const 1)
-	(i64.sub)
-     )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c0ffffffff       	mov	rax, 0xffffffffffffffff
-;;   13:	 4883e801             	sub	rax, 1
-;;   17:	 4883c408             	add	rsp, 8
-;;   1b:	 5d                   	pop	rbp
-;;   1c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_sub/params.wat b/winch/filetests/filetests/x64/i64_sub/params.wat
deleted file mode 100644
index 0ca133666a39..000000000000
--- a/winch/filetests/filetests/x64/i64_sub/params.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i64) (param i64) (result i64)
-	(local.get 0)
-	(local.get 1)
-	(i64.sub)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 48897c2410           	mov	qword ptr [rsp + 0x10], rdi
-;;    d:	 4889742408           	mov	qword ptr [rsp + 8], rsi
-;;   12:	 4c893424             	mov	qword ptr [rsp], r14
-;;   16:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   1b:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   20:	 4829c1               	sub	rcx, rax
-;;   23:	 4889c8               	mov	rax, rcx
-;;   26:	 4883c418             	add	rsp, 0x18
-;;   2a:	 5d                   	pop	rbp
-;;   2b:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_sub/signed.wat b/winch/filetests/filetests/x64/i64_sub/signed.wat
deleted file mode 100644
index 7ce14cfdf804..000000000000
--- a/winch/filetests/filetests/x64/i64_sub/signed.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (i64.const -1)
-	(i64.const -1)
-	(i64.sub)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c0ffffffff       	mov	rax, 0xffffffffffffffff
-;;   13:	 4883e8ff             	sub	rax, -1
-;;   17:	 4883c408             	add	rsp, 8
-;;   1b:	 5d                   	pop	rbp
-;;   1c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_sub/unsigned_with_zero.wat b/winch/filetests/filetests/x64/i64_sub/unsigned_with_zero.wat
deleted file mode 100644
index fb738db05dce..000000000000
--- a/winch/filetests/filetests/x64/i64_sub/unsigned_with_zero.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (i64.const 1)
-     	(i64.const 0)
-    	(i64.sub)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c001000000       	mov	rax, 1
-;;   13:	 4883e800             	sub	rax, 0
-;;   17:	 4883c408             	add	rsp, 8
-;;   1b:	 5d                   	pop	rbp
-;;   1c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_xor/32_const.wat b/winch/filetests/filetests/x64/i64_xor/32_const.wat
deleted file mode 100644
index 1f964074b0db..000000000000
--- a/winch/filetests/filetests/x64/i64_xor/32_const.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (i64.const 2)
-        (i64.const 3)
-        (i64.xor)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c002000000       	mov	rax, 2
-;;   13:	 4883f003             	xor	rax, 3
-;;   17:	 4883c408             	add	rsp, 8
-;;   1b:	 5d                   	pop	rbp
-;;   1c:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_xor/64_const.wat b/winch/filetests/filetests/x64/i64_xor/64_const.wat
deleted file mode 100644
index 34b0b14230ca..000000000000
--- a/winch/filetests/filetests/x64/i64_xor/64_const.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (i64.const 9223372036854775806)
-        (i64.const 9223372036854775807)
-        (i64.xor)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48b8feffffffffffff7f 	
-;; 				movabs	rax, 0x7ffffffffffffffe
-;;   16:	 49bbffffffffffffff7f 	
-;; 				movabs	r11, 0x7fffffffffffffff
-;;   20:	 4c31d8               	xor	rax, r11
-;;   23:	 4883c408             	add	rsp, 8
-;;   27:	 5d                   	pop	rbp
-;;   28:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_xor/locals.wat b/winch/filetests/filetests/x64/i64_xor/locals.wat
deleted file mode 100644
index bb8d8f050d3a..000000000000
--- a/winch/filetests/filetests/x64/i64_xor/locals.wat
+++ /dev/null
@@ -1,35 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (result i64)
-        (local $foo i64)
-        (local $bar i64)
-
-        (i64.const 2)
-        (local.set $foo)
-        (i64.const 3)
-        (local.set $bar)
-
-        (local.get $foo)
-        (local.get $bar)
-        (i64.xor)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 4531db               	xor	r11d, r11d
-;;    b:	 4c895c2410           	mov	qword ptr [rsp + 0x10], r11
-;;   10:	 4c895c2408           	mov	qword ptr [rsp + 8], r11
-;;   15:	 4c893424             	mov	qword ptr [rsp], r14
-;;   19:	 48c7c002000000       	mov	rax, 2
-;;   20:	 4889442410           	mov	qword ptr [rsp + 0x10], rax
-;;   25:	 48c7c003000000       	mov	rax, 3
-;;   2c:	 4889442408           	mov	qword ptr [rsp + 8], rax
-;;   31:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   36:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   3b:	 4831c1               	xor	rcx, rax
-;;   3e:	 4889c8               	mov	rax, rcx
-;;   41:	 4883c418             	add	rsp, 0x18
-;;   45:	 5d                   	pop	rbp
-;;   46:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/i64_xor/params.wat b/winch/filetests/filetests/x64/i64_xor/params.wat
deleted file mode 100644
index 152779402190..000000000000
--- a/winch/filetests/filetests/x64/i64_xor/params.wat
+++ /dev/null
@@ -1,22 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func (param i64) (param i64) (result i64)
-        (local.get 0)
-        (local.get 1)
-        (i64.xor)
-    )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 48897c2410           	mov	qword ptr [rsp + 0x10], rdi
-;;    d:	 4889742408           	mov	qword ptr [rsp + 8], rsi
-;;   12:	 4c893424             	mov	qword ptr [rsp], r14
-;;   16:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   1b:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   20:	 4831c1               	xor	rcx, rax
-;;   23:	 4889c8               	mov	rax, rcx
-;;   26:	 4883c418             	add	rsp, 0x18
-;;   2a:	 5d                   	pop	rbp
-;;   2b:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/if/as_binop.wat b/winch/filetests/filetests/x64/if/as_binop.wat
deleted file mode 100644
index 1b62a5f54032..000000000000
--- a/winch/filetests/filetests/x64/if/as_binop.wat
+++ /dev/null
@@ -1,58 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func $dummy)
-  (func (export "as-binary-operand") (param i32 i32) (result i32)
-    (i32.mul
-      (if (result i32) (local.get 0)
-        (then (call $dummy) (i32.const 3))
-        (else (call $dummy) (i32.const -3))
-      )
-      (if (result i32) (local.get 1)
-        (then (call $dummy) (i32.const 4))
-        (else (call $dummy) (i32.const -5))
-      )
-    )
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   18:	 85c0                 	test	eax, eax
-;;   1a:	 0f840f000000         	je	0x2f
-;;   20:	 e800000000           	call	0x25
-;;   25:	 b803000000           	mov	eax, 3
-;;   2a:	 e90a000000           	jmp	0x39
-;;   2f:	 e800000000           	call	0x34
-;;   34:	 b8fdffffff           	mov	eax, 0xfffffffd
-;;   39:	 8b4c2408             	mov	ecx, dword ptr [rsp + 8]
-;;   3d:	 50                   	push	rax
-;;   3e:	 85c9                 	test	ecx, ecx
-;;   40:	 0f8417000000         	je	0x5d
-;;   46:	 4883ec08             	sub	rsp, 8
-;;   4a:	 e800000000           	call	0x4f
-;;   4f:	 4883c408             	add	rsp, 8
-;;   53:	 b804000000           	mov	eax, 4
-;;   58:	 e912000000           	jmp	0x6f
-;;   5d:	 4883ec08             	sub	rsp, 8
-;;   61:	 e800000000           	call	0x66
-;;   66:	 4883c408             	add	rsp, 8
-;;   6a:	 b8fbffffff           	mov	eax, 0xfffffffb
-;;   6f:	 59                   	pop	rcx
-;;   70:	 0fafc8               	imul	ecx, eax
-;;   73:	 89c8                 	mov	eax, ecx
-;;   75:	 4883c410             	add	rsp, 0x10
-;;   79:	 5d                   	pop	rbp
-;;   7a:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/if/as_br_if_last.wat b/winch/filetests/filetests/x64/if/as_br_if_last.wat
deleted file mode 100644
index c0dbbdc9dff7..000000000000
--- a/winch/filetests/filetests/x64/if/as_br_if_last.wat
+++ /dev/null
@@ -1,48 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "as-br_if-last") (param i32) (result i32)
-    (block (result i32)
-      (br_if 0
-        (i32.const 2)
-        (if (result i32) (local.get 0)
-          (then (call $dummy) (i32.const 1))
-          (else (call $dummy) (i32.const 0))
-        )
-      )
-      (return (i32.const 3))
-    )
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   11:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   15:	 85c0                 	test	eax, eax
-;;   17:	 0f840f000000         	je	0x2c
-;;   1d:	 e800000000           	call	0x22
-;;   22:	 b801000000           	mov	eax, 1
-;;   27:	 e90a000000           	jmp	0x36
-;;   2c:	 e800000000           	call	0x31
-;;   31:	 b800000000           	mov	eax, 0
-;;   36:	 50                   	push	rax
-;;   37:	 59                   	pop	rcx
-;;   38:	 b802000000           	mov	eax, 2
-;;   3d:	 85c9                 	test	ecx, ecx
-;;   3f:	 0f850a000000         	jne	0x4f
-;;   45:	 50                   	push	rax
-;;   46:	 b803000000           	mov	eax, 3
-;;   4b:	 4883c408             	add	rsp, 8
-;;   4f:	 4883c410             	add	rsp, 0x10
-;;   53:	 5d                   	pop	rbp
-;;   54:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/if/as_if_cond.wat b/winch/filetests/filetests/x64/if/as_if_cond.wat
deleted file mode 100644
index 5d1aae101372..000000000000
--- a/winch/filetests/filetests/x64/if/as_if_cond.wat
+++ /dev/null
@@ -1,43 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func $dummy)
-  (func (export "as-if-condition") (param i32) (result i32)
-    (if (result i32)
-      (if (result i32) (local.get 0)
-        (then (i32.const 1)) (else (i32.const 0))
-      )
-      (then (call $dummy) (i32.const 2))
-      (else (call $dummy) (i32.const 3))
-    )
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   11:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   15:	 85c0                 	test	eax, eax
-;;   17:	 0f840a000000         	je	0x27
-;;   1d:	 b801000000           	mov	eax, 1
-;;   22:	 e905000000           	jmp	0x2c
-;;   27:	 b800000000           	mov	eax, 0
-;;   2c:	 85c0                 	test	eax, eax
-;;   2e:	 0f840f000000         	je	0x43
-;;   34:	 e800000000           	call	0x39
-;;   39:	 b802000000           	mov	eax, 2
-;;   3e:	 e90a000000           	jmp	0x4d
-;;   43:	 e800000000           	call	0x48
-;;   48:	 b803000000           	mov	eax, 3
-;;   4d:	 4883c410             	add	rsp, 0x10
-;;   51:	 5d                   	pop	rbp
-;;   52:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/if/as_testop.wat b/winch/filetests/filetests/x64/if/as_testop.wat
deleted file mode 100644
index d2213e7d885a..000000000000
--- a/winch/filetests/filetests/x64/if/as_testop.wat
+++ /dev/null
@@ -1,39 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "as-test-operand") (param i32) (result i32)
-    (i32.eqz
-      (if (result i32) (local.get 0)
-        (then (call $dummy) (i32.const 13))
-        (else (call $dummy) (i32.const 0))
-      )
-    )
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   11:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   15:	 85c0                 	test	eax, eax
-;;   17:	 0f840f000000         	je	0x2c
-;;   1d:	 e800000000           	call	0x22
-;;   22:	 b80d000000           	mov	eax, 0xd
-;;   27:	 e90a000000           	jmp	0x36
-;;   2c:	 e800000000           	call	0x31
-;;   31:	 b800000000           	mov	eax, 0
-;;   36:	 83f800               	cmp	eax, 0
-;;   39:	 b800000000           	mov	eax, 0
-;;   3e:	 400f94c0             	sete	al
-;;   42:	 4883c410             	add	rsp, 0x10
-;;   46:	 5d                   	pop	rbp
-;;   47:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/if/break_value.wat b/winch/filetests/filetests/x64/if/break_value.wat
deleted file mode 100644
index 4a49c2498b2c..000000000000
--- a/winch/filetests/filetests/x64/if/break_value.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func (export "break-value") (param i32) (result i32)
-    (if (result i32) (local.get 0)
-      (then (br 0 (i32.const 18)) (i32.const 19))
-      (else (br 0 (i32.const 21)) (i32.const 20))
-    )
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   11:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   15:	 85c0                 	test	eax, eax
-;;   17:	 0f840a000000         	je	0x27
-;;   1d:	 b812000000           	mov	eax, 0x12
-;;   22:	 e905000000           	jmp	0x2c
-;;   27:	 b815000000           	mov	eax, 0x15
-;;   2c:	 4883c410             	add	rsp, 0x10
-;;   30:	 5d                   	pop	rbp
-;;   31:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/if/nested.wat b/winch/filetests/filetests/x64/if/nested.wat
deleted file mode 100644
index 9db93d4d4b25..000000000000
--- a/winch/filetests/filetests/x64/if/nested.wat
+++ /dev/null
@@ -1,79 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "nested") (param i32 i32) (result i32)
-    (if (result i32) (local.get 0)
-      (then
-        (if (local.get 1) (then (call $dummy) (nop)))
-        (if (local.get 1) (then) (else (call $dummy) (nop)))
-        (if (result i32) (local.get 1)
-          (then (call $dummy) (i32.const 9))
-          (else (call $dummy) (i32.const 10))
-        )
-      )
-      (else
-        (if (local.get 1) (then (call $dummy) (nop)))
-        (if (local.get 1) (then) (else (call $dummy) (nop)))
-        (if (result i32) (local.get 1)
-          (then (call $dummy) (i32.const 10))
-          (else (call $dummy) (i32.const 11))
-        )
-      )
-    )
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   18:	 85c0                 	test	eax, eax
-;;   1a:	 0f8451000000         	je	0x71
-;;   20:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   24:	 85c0                 	test	eax, eax
-;;   26:	 0f8405000000         	je	0x31
-;;   2c:	 e800000000           	call	0x31
-;;   31:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   35:	 85c0                 	test	eax, eax
-;;   37:	 0f8405000000         	je	0x42
-;;   3d:	 e905000000           	jmp	0x47
-;;   42:	 e800000000           	call	0x47
-;;   47:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   4b:	 85c0                 	test	eax, eax
-;;   4d:	 0f840f000000         	je	0x62
-;;   53:	 e800000000           	call	0x58
-;;   58:	 b809000000           	mov	eax, 9
-;;   5d:	 e95b000000           	jmp	0xbd
-;;   62:	 e800000000           	call	0x67
-;;   67:	 b80a000000           	mov	eax, 0xa
-;;   6c:	 e94c000000           	jmp	0xbd
-;;   71:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   75:	 85c0                 	test	eax, eax
-;;   77:	 0f8405000000         	je	0x82
-;;   7d:	 e800000000           	call	0x82
-;;   82:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   86:	 85c0                 	test	eax, eax
-;;   88:	 0f8405000000         	je	0x93
-;;   8e:	 e905000000           	jmp	0x98
-;;   93:	 e800000000           	call	0x98
-;;   98:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   9c:	 85c0                 	test	eax, eax
-;;   9e:	 0f840f000000         	je	0xb3
-;;   a4:	 e800000000           	call	0xa9
-;;   a9:	 b80a000000           	mov	eax, 0xa
-;;   ae:	 e90a000000           	jmp	0xbd
-;;   b3:	 e800000000           	call	0xb8
-;;   b8:	 b80b000000           	mov	eax, 0xb
-;;   bd:	 4883c410             	add	rsp, 0x10
-;;   c1:	 5d                   	pop	rbp
-;;   c2:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/if/singular.wat b/winch/filetests/filetests/x64/if/singular.wat
deleted file mode 100644
index d2dd7f160c94..000000000000
--- a/winch/filetests/filetests/x64/if/singular.wat
+++ /dev/null
@@ -1,38 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func $dummy)
-  (func (export "singular") (param i32) (result i32)
-    (if (local.get 0) (then (nop)))
-    (if (local.get 0) (then (nop)) (else (nop)))
-    (if (result i32) (local.get 0) (then (i32.const 7)) (else (i32.const 8)))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   11:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   15:	 85c0                 	test	eax, eax
-;;   17:	 0f8400000000         	je	0x1d
-;;   1d:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   21:	 85c0                 	test	eax, eax
-;;   23:	 0f8400000000         	je	0x29
-;;   29:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   2d:	 85c0                 	test	eax, eax
-;;   2f:	 0f840a000000         	je	0x3f
-;;   35:	 b807000000           	mov	eax, 7
-;;   3a:	 e905000000           	jmp	0x44
-;;   3f:	 b808000000           	mov	eax, 8
-;;   44:	 4883c410             	add	rsp, 0x10
-;;   48:	 5d                   	pop	rbp
-;;   49:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/loop/as_binary_operand.wat b/winch/filetests/filetests/x64/loop/as_binary_operand.wat
deleted file mode 100644
index e052a607bf22..000000000000
--- a/winch/filetests/filetests/x64/loop/as_binary_operand.wat
+++ /dev/null
@@ -1,33 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "as-binary-operand") (result i32)
-    (i32.mul
-      (loop (result i32) (call $dummy) (i32.const 3))
-      (loop (result i32) (call $dummy) (i32.const 4))
-    )
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 4883ec08             	sub	rsp, 8
-;;   1d:	 e800000000           	call	0x22
-;;   22:	 4883c408             	add	rsp, 8
-;;   26:	 b803000000           	mov	eax, 3
-;;   2b:	 6bc004               	imul	eax, eax, 4
-;;   2e:	 4883c408             	add	rsp, 8
-;;   32:	 5d                   	pop	rbp
-;;   33:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/loop/as_br_if_first.wat b/winch/filetests/filetests/x64/loop/as_br_if_first.wat
deleted file mode 100644
index e917ae2d8853..000000000000
--- a/winch/filetests/filetests/x64/loop/as_br_if_first.wat
+++ /dev/null
@@ -1,17 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func (export "as-br-if-first") (result i32)
-    (block (result i32) (br_if 0 (loop (result i32) (i32.const 1)) (i32.const 2)))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b902000000           	mov	ecx, 2
-;;   11:	 b801000000           	mov	eax, 1
-;;   16:	 85c9                 	test	ecx, ecx
-;;   18:	 0f8500000000         	jne	0x1e
-;;   1e:	 4883c408             	add	rsp, 8
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/loop/as_br_if_last.wat b/winch/filetests/filetests/x64/loop/as_br_if_last.wat
deleted file mode 100644
index ae60997f92eb..000000000000
--- a/winch/filetests/filetests/x64/loop/as_br_if_last.wat
+++ /dev/null
@@ -1,17 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func (export "as-br-if-last") (result i32)
-    (block (result i32) (br_if 0 (i32.const 2) (loop (result i32) (i32.const 1))))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b901000000           	mov	ecx, 1
-;;   11:	 b802000000           	mov	eax, 2
-;;   16:	 85c9                 	test	ecx, ecx
-;;   18:	 0f8500000000         	jne	0x1e
-;;   1e:	 4883c408             	add	rsp, 8
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/loop/as_br_value.wat b/winch/filetests/filetests/x64/loop/as_br_value.wat
deleted file mode 100644
index 1076b2754d97..000000000000
--- a/winch/filetests/filetests/x64/loop/as_br_value.wat
+++ /dev/null
@@ -1,14 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func (export "as-br-value") (result i32)
-    (block (result i32) (br 0 (loop (result i32) (i32.const 1))))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 4883c408             	add	rsp, 8
-;;   15:	 5d                   	pop	rbp
-;;   16:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/loop/as_call_value.wat b/winch/filetests/filetests/x64/loop/as_call_value.wat
deleted file mode 100644
index 0bbf59f47b23..000000000000
--- a/winch/filetests/filetests/x64/loop/as_call_value.wat
+++ /dev/null
@@ -1,28 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $f (param i32) (result i32) (local.get 0))
-  (func (export "as-call-value") (result i32)
-    (call $f (loop (result i32) (i32.const 1)))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   11:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   15:	 4883c410             	add	rsp, 0x10
-;;   19:	 5d                   	pop	rbp
-;;   1a:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 bf01000000           	mov	edi, 1
-;;   15:	 e800000000           	call	0x1a
-;;   1a:	 4883c408             	add	rsp, 8
-;;   1e:	 4883c408             	add	rsp, 8
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/loop/as_if_condition.wat b/winch/filetests/filetests/x64/loop/as_if_condition.wat
deleted file mode 100644
index 1fd26be50b73..000000000000
--- a/winch/filetests/filetests/x64/loop/as_if_condition.wat
+++ /dev/null
@@ -1,28 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "as-if-condition")
-    (loop (result i32) (i32.const 1)) (if (then (call $dummy)))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 85c0                 	test	eax, eax
-;;   13:	 0f840d000000         	je	0x26
-;;   19:	 4883ec08             	sub	rsp, 8
-;;   1d:	 e800000000           	call	0x22
-;;   22:	 4883c408             	add	rsp, 8
-;;   26:	 4883c408             	add	rsp, 8
-;;   2a:	 5d                   	pop	rbp
-;;   2b:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/loop/as_if_else.wat b/winch/filetests/filetests/x64/loop/as_if_else.wat
deleted file mode 100644
index 263cef9fcd62..000000000000
--- a/winch/filetests/filetests/x64/loop/as_if_else.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func (export "as-if-else") (result i32)
-    (if (result i32) (i32.const 1) (then (i32.const 2)) (else (loop (result i32) (i32.const 1))))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 85c0                 	test	eax, eax
-;;   13:	 0f840a000000         	je	0x23
-;;   19:	 b802000000           	mov	eax, 2
-;;   1e:	 e905000000           	jmp	0x28
-;;   23:	 b801000000           	mov	eax, 1
-;;   28:	 4883c408             	add	rsp, 8
-;;   2c:	 5d                   	pop	rbp
-;;   2d:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/loop/as_if_then.wat b/winch/filetests/filetests/x64/loop/as_if_then.wat
deleted file mode 100644
index ad64ddaeb5fb..000000000000
--- a/winch/filetests/filetests/x64/loop/as_if_then.wat
+++ /dev/null
@@ -1,19 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func (export "as-if-then") (result i32)
-    (if (result i32) (i32.const 1) (then (loop (result i32) (i32.const 1))) (else (i32.const 2)))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 85c0                 	test	eax, eax
-;;   13:	 0f840a000000         	je	0x23
-;;   19:	 b801000000           	mov	eax, 1
-;;   1e:	 e905000000           	jmp	0x28
-;;   23:	 b802000000           	mov	eax, 2
-;;   28:	 4883c408             	add	rsp, 8
-;;   2c:	 5d                   	pop	rbp
-;;   2d:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/loop/as_local_set_value.wat b/winch/filetests/filetests/x64/loop/as_local_set_value.wat
deleted file mode 100644
index b808cd14a8b7..000000000000
--- a/winch/filetests/filetests/x64/loop/as_local_set_value.wat
+++ /dev/null
@@ -1,18 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func (export "as-local-set-value") (result i32)
-    (local i32) (local.set 0 (loop (result i32) (i32.const 1))) (local.get 0)
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   16:	 b801000000           	mov	eax, 1
-;;   1b:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1f:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   23:	 4883c410             	add	rsp, 0x10
-;;   27:	 5d                   	pop	rbp
-;;   28:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/loop/as_test_operand.wat b/winch/filetests/filetests/x64/loop/as_test_operand.wat
deleted file mode 100644
index a71e162071df..000000000000
--- a/winch/filetests/filetests/x64/loop/as_test_operand.wat
+++ /dev/null
@@ -1,29 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "as-test-operand") (result i32)
-    (i32.eqz (loop (result i32) (call $dummy) (i32.const 13)))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 b80d000000           	mov	eax, 0xd
-;;   1e:	 83f800               	cmp	eax, 0
-;;   21:	 b800000000           	mov	eax, 0
-;;   26:	 400f94c0             	sete	al
-;;   2a:	 4883c408             	add	rsp, 8
-;;   2e:	 5d                   	pop	rbp
-;;   2f:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/loop/as_unary_operand.wat b/winch/filetests/filetests/x64/loop/as_unary_operand.wat
deleted file mode 100644
index b8d579e9732c..000000000000
--- a/winch/filetests/filetests/x64/loop/as_unary_operand.wat
+++ /dev/null
@@ -1,31 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "as-unary-operand") (result i32)
-    (i32.ctz (loop (result i32) (call $dummy) (i32.const 13)))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 b80d000000           	mov	eax, 0xd
-;;   1e:	 0fbcc0               	bsf	eax, eax
-;;   21:	 41bb00000000         	mov	r11d, 0
-;;   27:	 410f94c3             	sete	r11b
-;;   2b:	 41c1e305             	shl	r11d, 5
-;;   2f:	 4401d8               	add	eax, r11d
-;;   32:	 4883c408             	add	rsp, 8
-;;   36:	 5d                   	pop	rbp
-;;   37:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/loop/break_inner.wat b/winch/filetests/filetests/x64/loop/break_inner.wat
deleted file mode 100644
index 2451dca5a640..000000000000
--- a/winch/filetests/filetests/x64/loop/break_inner.wat
+++ /dev/null
@@ -1,55 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func (export "break-inner") (result i32)
-    (local i32)
-    (local.set 0 (i32.const 0))
-    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (block (result i32) (br 2 (i32.const 0x1)))))))
-    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (loop (result i32) (br 2 (i32.const 0x2)))))))
-    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (block (result i32) (loop (result i32) (br 1 (i32.const 0x4))))))))
-    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (i32.ctz (br 1 (i32.const 0x8)))))))
-    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (i32.ctz (loop (result i32) (br 2 (i32.const 0x10))))))))
-    (local.get 0)
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   16:	 b800000000           	mov	eax, 0
-;;   1b:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1f:	 448b5c240c           	mov	r11d, dword ptr [rsp + 0xc]
-;;   24:	 4153                 	push	r11
-;;   26:	 b801000000           	mov	eax, 1
-;;   2b:	 59                   	pop	rcx
-;;   2c:	 01c1                 	add	ecx, eax
-;;   2e:	 894c240c             	mov	dword ptr [rsp + 0xc], ecx
-;;   32:	 448b5c240c           	mov	r11d, dword ptr [rsp + 0xc]
-;;   37:	 4153                 	push	r11
-;;   39:	 b802000000           	mov	eax, 2
-;;   3e:	 59                   	pop	rcx
-;;   3f:	 01c1                 	add	ecx, eax
-;;   41:	 894c240c             	mov	dword ptr [rsp + 0xc], ecx
-;;   45:	 448b5c240c           	mov	r11d, dword ptr [rsp + 0xc]
-;;   4a:	 4153                 	push	r11
-;;   4c:	 b804000000           	mov	eax, 4
-;;   51:	 59                   	pop	rcx
-;;   52:	 01c1                 	add	ecx, eax
-;;   54:	 894c240c             	mov	dword ptr [rsp + 0xc], ecx
-;;   58:	 448b5c240c           	mov	r11d, dword ptr [rsp + 0xc]
-;;   5d:	 4153                 	push	r11
-;;   5f:	 b808000000           	mov	eax, 8
-;;   64:	 59                   	pop	rcx
-;;   65:	 01c1                 	add	ecx, eax
-;;   67:	 894c240c             	mov	dword ptr [rsp + 0xc], ecx
-;;   6b:	 448b5c240c           	mov	r11d, dword ptr [rsp + 0xc]
-;;   70:	 4153                 	push	r11
-;;   72:	 b810000000           	mov	eax, 0x10
-;;   77:	 59                   	pop	rcx
-;;   78:	 01c1                 	add	ecx, eax
-;;   7a:	 894c240c             	mov	dword ptr [rsp + 0xc], ecx
-;;   7e:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   82:	 4883c410             	add	rsp, 0x10
-;;   86:	 5d                   	pop	rbp
-;;   87:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/loop/cont_inner.wat b/winch/filetests/filetests/x64/loop/cont_inner.wat
deleted file mode 100644
index 0495e828e7c6..000000000000
--- a/winch/filetests/filetests/x64/loop/cont_inner.wat
+++ /dev/null
@@ -1,26 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func (export "cont-inner") (result i32)
-    (local i32)
-    (local.set 0 (i32.const 0))
-    (local.set 0 (i32.add (local.get 0) (loop (result i32) (loop (result i32) (br 1)))))
-    (local.set 0 (i32.add (local.get 0) (loop (result i32) (i32.ctz (br 0)))))
-    (local.set 0 (i32.add (local.get 0) (loop (result i32) (i32.ctz (loop (result i32) (br 1))))))
-    (local.get 0)
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   16:	 b800000000           	mov	eax, 0
-;;   1b:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1f:	 448b5c240c           	mov	r11d, dword ptr [rsp + 0xc]
-;;   24:	 4153                 	push	r11
-;;   26:	 e9fbffffff           	jmp	0x26
-;;   2b:	 4883c408             	add	rsp, 8
-;;   2f:	 4883c410             	add	rsp, 0x10
-;;   33:	 5d                   	pop	rbp
-;;   34:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/loop/deep.wat b/winch/filetests/filetests/x64/loop/deep.wat
deleted file mode 100644
index baaba767072b..000000000000
--- a/winch/filetests/filetests/x64/loop/deep.wat
+++ /dev/null
@@ -1,67 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func $dummy)
-  (func (export "deep") (result i32)
-    (loop (result i32) (block (result i32)
-      (loop (result i32) (block (result i32)
-        (loop (result i32) (block (result i32)
-          (loop (result i32) (block (result i32)
-            (loop (result i32) (block (result i32)
-              (loop (result i32) (block (result i32)
-                (loop (result i32) (block (result i32)
-                  (loop (result i32) (block (result i32)
-                    (loop (result i32) (block (result i32)
-                      (loop (result i32) (block (result i32)
-                        (loop (result i32) (block (result i32)
-                          (loop (result i32) (block (result i32)
-                            (loop (result i32) (block (result i32)
-                              (loop (result i32) (block (result i32)
-                                (loop (result i32) (block (result i32)
-                                  (loop (result i32) (block (result i32)
-                                    (loop (result i32) (block (result i32)
-                                      (loop (result i32) (block (result i32)
-                                        (loop (result i32) (block (result i32)
-                                          (loop (result i32) (block (result i32)
-                                            (call $dummy) (i32.const 150)
-                                          ))
-                                        ))
-                                      ))
-                                    ))
-                                  ))
-                                ))
-                              ))
-                            ))
-                          ))
-                        ))
-                      ))
-                    ))
-                  ))
-                ))
-              ))
-            ))
-          ))
-        ))
-      ))
-    ))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 b896000000           	mov	eax, 0x96
-;;   1e:	 4883c408             	add	rsp, 8
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/loop/effects.wat b/winch/filetests/filetests/x64/loop/effects.wat
deleted file mode 100644
index 80614f981487..000000000000
--- a/winch/filetests/filetests/x64/loop/effects.wat
+++ /dev/null
@@ -1,41 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $fx (export "effects") (result i32)
-    (local i32)
-    (block
-      (loop
-        (local.set 0 (i32.const 1))
-        (local.set 0 (i32.mul (local.get 0) (i32.const 3)))
-        (local.set 0 (i32.sub (local.get 0) (i32.const 5)))
-        (local.set 0 (i32.mul (local.get 0) (i32.const 7)))
-        (br 1)
-        (local.set 0 (i32.mul (local.get 0) (i32.const 100)))
-      )
-    )
-    (i32.eq (local.get 0) (i32.const -14))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 48c744240800000000   	
-;; 				mov	qword ptr [rsp + 8], 0
-;;   11:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   16:	 b801000000           	mov	eax, 1
-;;   1b:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   1f:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   23:	 6bc003               	imul	eax, eax, 3
-;;   26:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   2a:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   2e:	 83e805               	sub	eax, 5
-;;   31:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   35:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   39:	 6bc007               	imul	eax, eax, 7
-;;   3c:	 8944240c             	mov	dword ptr [rsp + 0xc], eax
-;;   40:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   44:	 83f8f2               	cmp	eax, -0xe
-;;   47:	 b800000000           	mov	eax, 0
-;;   4c:	 400f94c0             	sete	al
-;;   50:	 4883c410             	add	rsp, 0x10
-;;   54:	 5d                   	pop	rbp
-;;   55:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/loop/empty.wat b/winch/filetests/filetests/x64/loop/empty.wat
deleted file mode 100644
index c6cae3e065d0..000000000000
--- a/winch/filetests/filetests/x64/loop/empty.wat
+++ /dev/null
@@ -1,15 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func (export "empty")
-    (loop)
-    (loop $l)
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/loop/for.wat b/winch/filetests/filetests/x64/loop/for.wat
deleted file mode 100644
index cbeb993b6e9c..000000000000
--- a/winch/filetests/filetests/x64/loop/for.wat
+++ /dev/null
@@ -1,47 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func (export "for-") (param i64) (result i64)
-    (local i64 i64)
-    (local.set 1 (i64.const 1))
-    (local.set 2 (i64.const 2))
-    (block
-      (loop
-        (br_if 1 (i64.gt_u (local.get 2) (local.get 0)))
-        (local.set 1 (i64.mul (local.get 1) (local.get 2)))
-        (local.set 2 (i64.add (local.get 2) (i64.const 1)))
-        (br 0)
-      )
-    )
-    (local.get 1)
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec20             	sub	rsp, 0x20
-;;    8:	 48897c2418           	mov	qword ptr [rsp + 0x18], rdi
-;;    d:	 48c744241000000000   	
-;; 				mov	qword ptr [rsp + 0x10], 0
-;;   16:	 4c893424             	mov	qword ptr [rsp], r14
-;;   1a:	 48c7c001000000       	mov	rax, 1
-;;   21:	 4889442410           	mov	qword ptr [rsp + 0x10], rax
-;;   26:	 48c7c002000000       	mov	rax, 2
-;;   2d:	 4889442408           	mov	qword ptr [rsp + 8], rax
-;;   32:	 488b442418           	mov	rax, qword ptr [rsp + 0x18]
-;;   37:	 488b4c2408           	mov	rcx, qword ptr [rsp + 8]
-;;   3c:	 4839c1               	cmp	rcx, rax
-;;   3f:	 b900000000           	mov	ecx, 0
-;;   44:	 400f97c1             	seta	cl
-;;   48:	 85c9                 	test	ecx, ecx
-;;   4a:	 0f8526000000         	jne	0x76
-;;   50:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   55:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   5a:	 480fafc8             	imul	rcx, rax
-;;   5e:	 48894c2410           	mov	qword ptr [rsp + 0x10], rcx
-;;   63:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   68:	 4883c001             	add	rax, 1
-;;   6c:	 4889442408           	mov	qword ptr [rsp + 8], rax
-;;   71:	 e9bcffffff           	jmp	0x32
-;;   76:	 488b442410           	mov	rax, qword ptr [rsp + 0x10]
-;;   7b:	 4883c420             	add	rsp, 0x20
-;;   7f:	 5d                   	pop	rbp
-;;   80:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/loop/multi.wat b/winch/filetests/filetests/x64/loop/multi.wat
deleted file mode 100644
index 365cccb8e684..000000000000
--- a/winch/filetests/filetests/x64/loop/multi.wat
+++ /dev/null
@@ -1,46 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func $dummy)
-  (func (export "multi") (result i32)
-    (loop (call $dummy) (call $dummy) (call $dummy) (call $dummy))
-    (loop (result i32) (call $dummy) (call $dummy) (i32.const 8) (call $dummy))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 4883ec08             	sub	rsp, 8
-;;   1d:	 e800000000           	call	0x22
-;;   22:	 4883c408             	add	rsp, 8
-;;   26:	 4883ec08             	sub	rsp, 8
-;;   2a:	 e800000000           	call	0x2f
-;;   2f:	 4883c408             	add	rsp, 8
-;;   33:	 4883ec08             	sub	rsp, 8
-;;   37:	 e800000000           	call	0x3c
-;;   3c:	 4883c408             	add	rsp, 8
-;;   40:	 4883ec08             	sub	rsp, 8
-;;   44:	 e800000000           	call	0x49
-;;   49:	 4883c408             	add	rsp, 8
-;;   4d:	 4883ec08             	sub	rsp, 8
-;;   51:	 e800000000           	call	0x56
-;;   56:	 4883c408             	add	rsp, 8
-;;   5a:	 4883ec08             	sub	rsp, 8
-;;   5e:	 e800000000           	call	0x63
-;;   63:	 4883c408             	add	rsp, 8
-;;   67:	 b808000000           	mov	eax, 8
-;;   6c:	 4883c408             	add	rsp, 8
-;;   70:	 5d                   	pop	rbp
-;;   71:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/loop/nested.wat b/winch/filetests/filetests/x64/loop/nested.wat
deleted file mode 100644
index e272e78f83bf..000000000000
--- a/winch/filetests/filetests/x64/loop/nested.wat
+++ /dev/null
@@ -1,32 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "nested") (result i32)
-    (loop (result i32)
-      (loop (call $dummy) (block) (nop))
-      (loop (result i32) (call $dummy) (i32.const 9))
-    )
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 4883ec08             	sub	rsp, 8
-;;   1d:	 e800000000           	call	0x22
-;;   22:	 4883c408             	add	rsp, 8
-;;   26:	 b809000000           	mov	eax, 9
-;;   2b:	 4883c408             	add	rsp, 8
-;;   2f:	 5d                   	pop	rbp
-;;   30:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/loop/singular.wat b/winch/filetests/filetests/x64/loop/singular.wat
deleted file mode 100644
index 4631e0b05868..000000000000
--- a/winch/filetests/filetests/x64/loop/singular.wat
+++ /dev/null
@@ -1,16 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func (export "singular") (result i32)
-    (loop (nop))
-    (loop (result i32) (i32.const 7))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b807000000           	mov	eax, 7
-;;   11:	 4883c408             	add	rsp, 8
-;;   15:	 5d                   	pop	rbp
-;;   16:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/loop/while.wat b/winch/filetests/filetests/x64/loop/while.wat
deleted file mode 100644
index e9773ab92a2e..000000000000
--- a/winch/filetests/filetests/x64/loop/while.wat
+++ /dev/null
@@ -1,41 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func (export "while-") (param i64) (result i64)
-    (local i64)
-    (local.set 1 (i64.const 1))
-    (block
-      (loop
-        (br_if 1 (i64.eqz (local.get 0)))
-        (local.set 1 (i64.mul (local.get 0) (local.get 1)))
-        (local.set 0 (i64.sub (local.get 0) (i64.const 1)))
-        (br 0)
-      )
-    )
-    (local.get 1)
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 48897c2410           	mov	qword ptr [rsp + 0x10], rdi
-;;    d:	 4c893424             	mov	qword ptr [rsp], r14
-;;   11:	 48c7c001000000       	mov	rax, 1
-;;   18:	 4889442408           	mov	qword ptr [rsp + 8], rax
-;;   1d:	 488b442410           	mov	rax, qword ptr [rsp + 0x10]
-;;   22:	 4883f800             	cmp	rax, 0
-;;   26:	 b800000000           	mov	eax, 0
-;;   2b:	 400f94c0             	sete	al
-;;   2f:	 85c0                 	test	eax, eax
-;;   31:	 0f8526000000         	jne	0x5d
-;;   37:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   3c:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   41:	 480fafc8             	imul	rcx, rax
-;;   45:	 48894c2408           	mov	qword ptr [rsp + 8], rcx
-;;   4a:	 488b442410           	mov	rax, qword ptr [rsp + 0x10]
-;;   4f:	 4883e801             	sub	rax, 1
-;;   53:	 4889442410           	mov	qword ptr [rsp + 0x10], rax
-;;   58:	 e9c0ffffff           	jmp	0x1d
-;;   5d:	 488b442408           	mov	rax, qword ptr [rsp + 8]
-;;   62:	 4883c418             	add	rsp, 0x18
-;;   66:	 5d                   	pop	rbp
-;;   67:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/nop/nop.wat b/winch/filetests/filetests/x64/nop/nop.wat
deleted file mode 100644
index 7b8c00c4439c..000000000000
--- a/winch/filetests/filetests/x64/nop/nop.wat
+++ /dev/null
@@ -1,15 +0,0 @@
-;;! target = "x86_64"
-
-(module
-    (func
-        nop
-    )
-)
-
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/return/as_block_first.wat b/winch/filetests/filetests/x64/return/as_block_first.wat
deleted file mode 100644
index 6c9afecdb36b..000000000000
--- a/winch/filetests/filetests/x64/return/as_block_first.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "as-block-first")
-   (block (return) (call $dummy))
-  )
-)
-  
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/return/as_block_last.wat b/winch/filetests/filetests/x64/return/as_block_last.wat
deleted file mode 100644
index ea01847ff449..000000000000
--- a/winch/filetests/filetests/x64/return/as_block_last.wat
+++ /dev/null
@@ -1,26 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "as-block-last")
-   (block (nop) (call $dummy) (return))
-  )
-)
-  
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 4883c408             	add	rsp, 8
-;;   1d:	 5d                   	pop	rbp
-;;   1e:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/return/as_block_mid.wat b/winch/filetests/filetests/x64/return/as_block_mid.wat
deleted file mode 100644
index 8def330c17a0..000000000000
--- a/winch/filetests/filetests/x64/return/as_block_mid.wat
+++ /dev/null
@@ -1,26 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "as-block-mid")
-   (block (call $dummy) (return) (call $dummy))
-  )
-)
-  
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 4883c408             	add	rsp, 8
-;;   1d:	 5d                   	pop	rbp
-;;   1e:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/return/as_block_value.wat b/winch/filetests/filetests/x64/return/as_block_value.wat
deleted file mode 100644
index 717579c80292..000000000000
--- a/winch/filetests/filetests/x64/return/as_block_value.wat
+++ /dev/null
@@ -1,27 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "as-block-value") (result i32)
-   (block (result i32) (nop) (call $dummy) (return (i32.const 2)))
-  )
-)
-  
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 b802000000           	mov	eax, 2
-;;   1e:	 4883c408             	add	rsp, 8
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/return/as_br_if_cond.wat b/winch/filetests/filetests/x64/return/as_br_if_cond.wat
deleted file mode 100644
index 07d40a31f434..000000000000
--- a/winch/filetests/filetests/x64/return/as_br_if_cond.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "as-br-if-cond")
-   (block (br_if 0 (return)))
-  )
-)
-  
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/return/as_br_value.wat b/winch/filetests/filetests/x64/return/as_br_value.wat
deleted file mode 100644
index 858f90716357..000000000000
--- a/winch/filetests/filetests/x64/return/as_br_value.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "as-br-value") (result i32)
-   (block (result i32) (br 0 (return (i32.const 9))))
-  )
-)
-  
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b809000000           	mov	eax, 9
-;;   11:	 4883c408             	add	rsp, 8
-;;   15:	 5d                   	pop	rbp
-;;   16:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/return/as_call_fist.wat b/winch/filetests/filetests/x64/return/as_call_fist.wat
deleted file mode 100644
index 957f75bce804..000000000000
--- a/winch/filetests/filetests/x64/return/as_call_fist.wat
+++ /dev/null
@@ -1,28 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
-  (func (export "as-call-first") (result i32)
-    (call $f (return (i32.const 12)) (i32.const 2) (i32.const 3))
-  )
-)
-  
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 897c2414             	mov	dword ptr [rsp + 0x14], edi
-;;    c:	 89742410             	mov	dword ptr [rsp + 0x10], esi
-;;   10:	 8954240c             	mov	dword ptr [rsp + 0xc], edx
-;;   14:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   19:	 b8ffffffff           	mov	eax, 0xffffffff
-;;   1e:	 4883c418             	add	rsp, 0x18
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b80c000000           	mov	eax, 0xc
-;;   11:	 4883c408             	add	rsp, 8
-;;   15:	 5d                   	pop	rbp
-;;   16:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/return/as_call_last.wat b/winch/filetests/filetests/x64/return/as_call_last.wat
deleted file mode 100644
index 6405080c4968..000000000000
--- a/winch/filetests/filetests/x64/return/as_call_last.wat
+++ /dev/null
@@ -1,28 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
-  (func (export "as-call-last") (result i32)
-    (call $f (i32.const 1) (i32.const 2) (return (i32.const 14)))
-  )
-)
-  
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 897c2414             	mov	dword ptr [rsp + 0x14], edi
-;;    c:	 89742410             	mov	dword ptr [rsp + 0x10], esi
-;;   10:	 8954240c             	mov	dword ptr [rsp + 0xc], edx
-;;   14:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   19:	 b8ffffffff           	mov	eax, 0xffffffff
-;;   1e:	 4883c418             	add	rsp, 0x18
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b80e000000           	mov	eax, 0xe
-;;   11:	 4883c408             	add	rsp, 8
-;;   15:	 5d                   	pop	rbp
-;;   16:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/return/as_call_mid.wat b/winch/filetests/filetests/x64/return/as_call_mid.wat
deleted file mode 100644
index 665c7711c482..000000000000
--- a/winch/filetests/filetests/x64/return/as_call_mid.wat
+++ /dev/null
@@ -1,28 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
-  (func (export "as-call-mid") (result i32)
-    (call $f (i32.const 1) (return (i32.const 13)) (i32.const 3))
-  )
-)
-  
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 897c2414             	mov	dword ptr [rsp + 0x14], edi
-;;    c:	 89742410             	mov	dword ptr [rsp + 0x10], esi
-;;   10:	 8954240c             	mov	dword ptr [rsp + 0xc], edx
-;;   14:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   19:	 b8ffffffff           	mov	eax, 0xffffffff
-;;   1e:	 4883c418             	add	rsp, 0x18
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b80d000000           	mov	eax, 0xd
-;;   11:	 4883c408             	add	rsp, 8
-;;   15:	 5d                   	pop	rbp
-;;   16:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/return/as_func_first.wat b/winch/filetests/filetests/x64/return/as_func_first.wat
deleted file mode 100644
index 1c6e84b7fe5d..000000000000
--- a/winch/filetests/filetests/x64/return/as_func_first.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "as-func-first") (result i32)
-   (return (i32.const 1)) (i32.const 2)
-  )
-)
-  
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 4883c408             	add	rsp, 8
-;;   15:	 5d                   	pop	rbp
-;;   16:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/return/as_func_last.wat b/winch/filetests/filetests/x64/return/as_func_last.wat
deleted file mode 100644
index daa2374db072..000000000000
--- a/winch/filetests/filetests/x64/return/as_func_last.wat
+++ /dev/null
@@ -1,12 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-)
-  
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/return/as_func_mid.wat b/winch/filetests/filetests/x64/return/as_func_mid.wat
deleted file mode 100644
index 5ca871890cf7..000000000000
--- a/winch/filetests/filetests/x64/return/as_func_mid.wat
+++ /dev/null
@@ -1,27 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "as-func-mid") (result i32)
-   (call $dummy) (return (i32.const 2)) (i32.const 3)
-  )
-)
-  
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 b802000000           	mov	eax, 2
-;;   1e:	 4883c408             	add	rsp, 8
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/return/as_func_value.wat b/winch/filetests/filetests/x64/return/as_func_value.wat
deleted file mode 100644
index 7e5f92928738..000000000000
--- a/winch/filetests/filetests/x64/return/as_func_value.wat
+++ /dev/null
@@ -1,27 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-    (func (export "as-func-value") (result i32)
-        (nop) (call $dummy) (return (i32.const 3))
-    )
-)
-  
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 b803000000           	mov	eax, 3
-;;   1e:	 4883c408             	add	rsp, 8
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/return/as_if_cond.wat b/winch/filetests/filetests/x64/return/as_if_cond.wat
deleted file mode 100644
index 644b37009024..000000000000
--- a/winch/filetests/filetests/x64/return/as_if_cond.wat
+++ /dev/null
@@ -1,26 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "as-if-cond") (result i32)
-   (if (result i32)
-    (return (i32.const 2)) (then (i32.const 0)) (else (i32.const 1))
-   )
-  )
-)
-  
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b802000000           	mov	eax, 2
-;;   11:	 4883c408             	add	rsp, 8
-;;   15:	 5d                   	pop	rbp
-;;   16:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/return/as_if_else.wat b/winch/filetests/filetests/x64/return/as_if_else.wat
deleted file mode 100644
index 350d0d52cb23..000000000000
--- a/winch/filetests/filetests/x64/return/as_if_else.wat
+++ /dev/null
@@ -1,34 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-
-  (func (export "as-if-else") (param i32 i32) (result i32)
-   (if (result i32)
-    (local.get 0) (then (local.get 1)) (else (return (i32.const 4)))
-   )
-  )
-)
-  
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   18:	 85c0                 	test	eax, eax
-;;   1a:	 0f8409000000         	je	0x29
-;;   20:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   24:	 e905000000           	jmp	0x2e
-;;   29:	 b804000000           	mov	eax, 4
-;;   2e:	 4883c410             	add	rsp, 0x10
-;;   32:	 5d                   	pop	rbp
-;;   33:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/return/as_if_then.wat b/winch/filetests/filetests/x64/return/as_if_then.wat
deleted file mode 100644
index 1e4093810019..000000000000
--- a/winch/filetests/filetests/x64/return/as_if_then.wat
+++ /dev/null
@@ -1,34 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-
-  (func (export "as-if-then") (param i32 i32) (result i32)
-   (if (result i32)
-    (local.get 0) (then (return (i32.const 3))) (else (local.get 1))
-   )
-  )
-)
-  
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   18:	 85c0                 	test	eax, eax
-;;   1a:	 0f840a000000         	je	0x2a
-;;   20:	 b803000000           	mov	eax, 3
-;;   25:	 e904000000           	jmp	0x2e
-;;   2a:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   2e:	 4883c410             	add	rsp, 0x10
-;;   32:	 5d                   	pop	rbp
-;;   33:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/return/as_loop_first.wat b/winch/filetests/filetests/x64/return/as_loop_first.wat
deleted file mode 100644
index d7384ea4109d..000000000000
--- a/winch/filetests/filetests/x64/return/as_loop_first.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "as-loop-first") (result i32)
-   (loop (result i32) (return (i32.const 3)) (i32.const 2))
-  )
-)
-  
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b803000000           	mov	eax, 3
-;;   11:	 4883c408             	add	rsp, 8
-;;   15:	 5d                   	pop	rbp
-;;   16:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/return/as_loop_last.wat b/winch/filetests/filetests/x64/return/as_loop_last.wat
deleted file mode 100644
index a54d311666ba..000000000000
--- a/winch/filetests/filetests/x64/return/as_loop_last.wat
+++ /dev/null
@@ -1,27 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "as-loop-last") (result i32)
-   (loop (result i32) (nop) (call $dummy) (return (i32.const 5)))
-  )
-)
-  
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 b805000000           	mov	eax, 5
-;;   1e:	 4883c408             	add	rsp, 8
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/return/as_loop_mid.wat b/winch/filetests/filetests/x64/return/as_loop_mid.wat
deleted file mode 100644
index ac6c76a5f9f2..000000000000
--- a/winch/filetests/filetests/x64/return/as_loop_mid.wat
+++ /dev/null
@@ -1,27 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "as-loop-mid") (result i32)
-   (loop (result i32) (call $dummy) (return (i32.const 4)) (i32.const 2))
-  )
-)
-  
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 b804000000           	mov	eax, 4
-;;   1e:	 4883c408             	add	rsp, 8
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/return/as_return_value.wat b/winch/filetests/filetests/x64/return/as_return_value.wat
deleted file mode 100644
index 1e010497dd6c..000000000000
--- a/winch/filetests/filetests/x64/return/as_return_value.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "as-return-value") (result i64)
-    (return (return (i64.const 7)))
-  )
-)
-  
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c007000000       	mov	rax, 7
-;;   13:	 4883c408             	add	rsp, 8
-;;   17:	 5d                   	pop	rbp
-;;   18:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/return/nullary.wat b/winch/filetests/filetests/x64/return/nullary.wat
deleted file mode 100644
index 78f57cf6d313..000000000000
--- a/winch/filetests/filetests/x64/return/nullary.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "nullary") (return))
-)
-  
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/return/type_i32.wat b/winch/filetests/filetests/x64/return/type_i32.wat
deleted file mode 100644
index 09a89241b7d2..000000000000
--- a/winch/filetests/filetests/x64/return/type_i32.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-
-  (func (export "type-i32-value") (result i32)
-   (block (result i32) (i32.ctz (return (i32.const 1))))
-  )
-)
-  
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 b801000000           	mov	eax, 1
-;;   11:	 4883c408             	add	rsp, 8
-;;   15:	 5d                   	pop	rbp
-;;   16:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/return/type_i64_value.wat b/winch/filetests/filetests/x64/return/type_i64_value.wat
deleted file mode 100644
index e4be29d6febf..000000000000
--- a/winch/filetests/filetests/x64/return/type_i64_value.wat
+++ /dev/null
@@ -1,25 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-
-  (func (export "type-i64-value") (result i64)
-   (block (result i64) (i64.ctz (return (i64.const 2))))
-  )
-)
-  
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 48c7c002000000       	mov	rax, 2
-;;   13:	 4883c408             	add	rsp, 8
-;;   17:	 5d                   	pop	rbp
-;;   18:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/select/f32.wat b/winch/filetests/filetests/x64/select/f32.wat
deleted file mode 100644
index 7f5f9bb29985..000000000000
--- a/winch/filetests/filetests/x64/select/f32.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func (export "select-f32") (param f32 f32 i32) (result f32)
-    (select (local.get 0) (local.get 1) (local.get 2))
-  )
-)
- 
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 f30f11442414         	movss	dword ptr [rsp + 0x14], xmm0
-;;    e:	 f30f114c2410         	movss	dword ptr [rsp + 0x10], xmm1
-;;   14:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;   18:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   1d:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   21:	 f30f10442410         	movss	xmm0, dword ptr [rsp + 0x10]
-;;   27:	 f30f104c2414         	movss	xmm1, dword ptr [rsp + 0x14]
-;;   2d:	 83f800               	cmp	eax, 0
-;;   30:	 0f8404000000         	je	0x3a
-;;   36:	 f20f10c1             	movsd	xmm0, xmm1
-;;   3a:	 4883c418             	add	rsp, 0x18
-;;   3e:	 5d                   	pop	rbp
-;;   3f:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/select/f64.wat b/winch/filetests/filetests/x64/select/f64.wat
deleted file mode 100644
index b517c1dd7694..000000000000
--- a/winch/filetests/filetests/x64/select/f64.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func (export "select-f64") (param f64 f64 i32) (result f64)
-    (select (local.get 0) (local.get 1) (local.get 2))
-  )
-)
- 
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec20             	sub	rsp, 0x20
-;;    8:	 f20f11442418         	movsd	qword ptr [rsp + 0x18], xmm0
-;;    e:	 f20f114c2410         	movsd	qword ptr [rsp + 0x10], xmm1
-;;   14:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;   18:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   1d:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   21:	 f20f10442410         	movsd	xmm0, qword ptr [rsp + 0x10]
-;;   27:	 f20f104c2418         	movsd	xmm1, qword ptr [rsp + 0x18]
-;;   2d:	 83f800               	cmp	eax, 0
-;;   30:	 0f8404000000         	je	0x3a
-;;   36:	 f20f10c1             	movsd	xmm0, xmm1
-;;   3a:	 4883c420             	add	rsp, 0x20
-;;   3e:	 5d                   	pop	rbp
-;;   3f:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/select/i32.wat b/winch/filetests/filetests/x64/select/i32.wat
deleted file mode 100644
index b8ef0b597256..000000000000
--- a/winch/filetests/filetests/x64/select/i32.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func (export "select-i32") (param i32 i32 i32) (result i32)
-    (select (local.get 0) (local.get 1) (local.get 2))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 897c2414             	mov	dword ptr [rsp + 0x14], edi
-;;    c:	 89742410             	mov	dword ptr [rsp + 0x10], esi
-;;   10:	 8954240c             	mov	dword ptr [rsp + 0xc], edx
-;;   14:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   19:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   1d:	 8b4c2410             	mov	ecx, dword ptr [rsp + 0x10]
-;;   21:	 8b542414             	mov	edx, dword ptr [rsp + 0x14]
-;;   25:	 83f800               	cmp	eax, 0
-;;   28:	 0f45ca               	cmovne	ecx, edx
-;;   2b:	 89c8                 	mov	eax, ecx
-;;   2d:	 4883c418             	add	rsp, 0x18
-;;   31:	 5d                   	pop	rbp
-;;   32:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/select/i64.wat b/winch/filetests/filetests/x64/select/i64.wat
deleted file mode 100644
index b104ce967925..000000000000
--- a/winch/filetests/filetests/x64/select/i64.wat
+++ /dev/null
@@ -1,24 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func (export "select-i64") (param i64 i64 i32) (result i64)
-    (select (local.get 0) (local.get 1) (local.get 2))
-  )
-)
- 
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec20             	sub	rsp, 0x20
-;;    8:	 48897c2418           	mov	qword ptr [rsp + 0x18], rdi
-;;    d:	 4889742410           	mov	qword ptr [rsp + 0x10], rsi
-;;   12:	 8954240c             	mov	dword ptr [rsp + 0xc], edx
-;;   16:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   1b:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   1f:	 488b4c2410           	mov	rcx, qword ptr [rsp + 0x10]
-;;   24:	 488b542418           	mov	rdx, qword ptr [rsp + 0x18]
-;;   29:	 83f800               	cmp	eax, 0
-;;   2c:	 480f45ca             	cmovne	rcx, rdx
-;;   30:	 4889c8               	mov	rax, rcx
-;;   33:	 4883c420             	add	rsp, 0x20
-;;   37:	 5d                   	pop	rbp
-;;   38:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/unreachable/as_block_broke.wat b/winch/filetests/filetests/x64/unreachable/as_block_broke.wat
deleted file mode 100644
index e79cec6d8ebe..000000000000
--- a/winch/filetests/filetests/x64/unreachable/as_block_broke.wat
+++ /dev/null
@@ -1,27 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func $dummy)
-  (func (export "as-block-broke") (result i32)
-    (block (result i32) (call $dummy) (br 0 (i32.const 1)) (unreachable))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 b801000000           	mov	eax, 1
-;;   1e:	 4883c408             	add	rsp, 8
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/unreachable/as_block_first.wat b/winch/filetests/filetests/x64/unreachable/as_block_first.wat
deleted file mode 100644
index 9aa1aadd5e43..000000000000
--- a/winch/filetests/filetests/x64/unreachable/as_block_first.wat
+++ /dev/null
@@ -1,14 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func (export "as-block-first") (result i32)
-    (block (result i32) (unreachable) (i32.const 2))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 0f0b                 	ud2	
-;;    e:	 4883c408             	add	rsp, 8
-;;   12:	 5d                   	pop	rbp
-;;   13:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/unreachable/as_block_last.wat b/winch/filetests/filetests/x64/unreachable/as_block_last.wat
deleted file mode 100644
index ae9b1fdf6939..000000000000
--- a/winch/filetests/filetests/x64/unreachable/as_block_last.wat
+++ /dev/null
@@ -1,26 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "as-block-last")
-    (block (nop) (call $dummy) (unreachable))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 0f0b                 	ud2	
-;;   1b:	 4883c408             	add	rsp, 8
-;;   1f:	 5d                   	pop	rbp
-;;   20:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/unreachable/as_block_mid.wat b/winch/filetests/filetests/x64/unreachable/as_block_mid.wat
deleted file mode 100644
index 68bc648f368a..000000000000
--- a/winch/filetests/filetests/x64/unreachable/as_block_mid.wat
+++ /dev/null
@@ -1,27 +0,0 @@
-;;! target = "x86_64"
-
-(module 
-  (func $dummy)
-  (func (export "as-block-mid") (result i32)
-    (block (result i32) (call $dummy) (unreachable) (i32.const 2))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 0f0b                 	ud2	
-;;   1b:	 4883c408             	add	rsp, 8
-;;   1f:	 5d                   	pop	rbp
-;;   20:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/unreachable/as_block_value.wat b/winch/filetests/filetests/x64/unreachable/as_block_value.wat
deleted file mode 100644
index 59d644a44ca6..000000000000
--- a/winch/filetests/filetests/x64/unreachable/as_block_value.wat
+++ /dev/null
@@ -1,26 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "as-block-value") (result i32)
-    (block (result i32) (nop) (call $dummy) (unreachable))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 0f0b                 	ud2	
-;;   1b:	 4883c408             	add	rsp, 8
-;;   1f:	 5d                   	pop	rbp
-;;   20:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/unreachable/as_br_if_cond.wat b/winch/filetests/filetests/x64/unreachable/as_br_if_cond.wat
deleted file mode 100644
index cf89065332bf..000000000000
--- a/winch/filetests/filetests/x64/unreachable/as_br_if_cond.wat
+++ /dev/null
@@ -1,15 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func (export "as-br_if-cond")
-    (block (br_if 0 (unreachable)))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 0f0b                 	ud2	
-;;    e:	 4883c408             	add	rsp, 8
-;;   12:	 5d                   	pop	rbp
-;;   13:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/unreachable/as_br_value.wat b/winch/filetests/filetests/x64/unreachable/as_br_value.wat
deleted file mode 100644
index 851f9000d4e3..000000000000
--- a/winch/filetests/filetests/x64/unreachable/as_br_value.wat
+++ /dev/null
@@ -1,15 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func (export "as-br-value") (result i32)
-    (block (result i32) (br 0 (unreachable)))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 0f0b                 	ud2	
-;;    e:	 4883c408             	add	rsp, 8
-;;   12:	 5d                   	pop	rbp
-;;   13:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/unreachable/as_call_first.wat b/winch/filetests/filetests/x64/unreachable/as_call_first.wat
deleted file mode 100644
index 251b5d507cce..000000000000
--- a/winch/filetests/filetests/x64/unreachable/as_call_first.wat
+++ /dev/null
@@ -1,27 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func $dummy3 (param i32 i32 i32))
-  (func (export "as-call-first")
-    (call $dummy3 (unreachable) (i32.const 2) (i32.const 3))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 897c2414             	mov	dword ptr [rsp + 0x14], edi
-;;    c:	 89742410             	mov	dword ptr [rsp + 0x10], esi
-;;   10:	 8954240c             	mov	dword ptr [rsp + 0xc], edx
-;;   14:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   19:	 4883c418             	add	rsp, 0x18
-;;   1d:	 5d                   	pop	rbp
-;;   1e:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 0f0b                 	ud2	
-;;    e:	 4883c408             	add	rsp, 8
-;;   12:	 5d                   	pop	rbp
-;;   13:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/unreachable/as_call_last.wat b/winch/filetests/filetests/x64/unreachable/as_call_last.wat
deleted file mode 100644
index 4a9d971d2d25..000000000000
--- a/winch/filetests/filetests/x64/unreachable/as_call_last.wat
+++ /dev/null
@@ -1,28 +0,0 @@
-;;! target = "x86_64"
-
-
-(module
-  (func $dummy3 (param i32 i32 i32))
-  (func (export "as-call-last")
-    (call $dummy3 (i32.const 1) (i32.const 2) (unreachable))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 897c2414             	mov	dword ptr [rsp + 0x14], edi
-;;    c:	 89742410             	mov	dword ptr [rsp + 0x10], esi
-;;   10:	 8954240c             	mov	dword ptr [rsp + 0xc], edx
-;;   14:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   19:	 4883c418             	add	rsp, 0x18
-;;   1d:	 5d                   	pop	rbp
-;;   1e:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 0f0b                 	ud2	
-;;    e:	 4883c408             	add	rsp, 8
-;;   12:	 5d                   	pop	rbp
-;;   13:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/unreachable/as_call_mid.wat b/winch/filetests/filetests/x64/unreachable/as_call_mid.wat
deleted file mode 100644
index 620bde9934f9..000000000000
--- a/winch/filetests/filetests/x64/unreachable/as_call_mid.wat
+++ /dev/null
@@ -1,27 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func $dummy3 (param i32 i32 i32))
-  (func (export "as-call-mid")
-    (call $dummy3 (i32.const 1) (unreachable) (i32.const 3))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec18             	sub	rsp, 0x18
-;;    8:	 897c2414             	mov	dword ptr [rsp + 0x14], edi
-;;    c:	 89742410             	mov	dword ptr [rsp + 0x10], esi
-;;   10:	 8954240c             	mov	dword ptr [rsp + 0xc], edx
-;;   14:	 4c89742404           	mov	qword ptr [rsp + 4], r14
-;;   19:	 4883c418             	add	rsp, 0x18
-;;   1d:	 5d                   	pop	rbp
-;;   1e:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 0f0b                 	ud2	
-;;    e:	 4883c408             	add	rsp, 8
-;;   12:	 5d                   	pop	rbp
-;;   13:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/unreachable/as_func_first.wat b/winch/filetests/filetests/x64/unreachable/as_func_first.wat
deleted file mode 100644
index 34b86a4cb8ed..000000000000
--- a/winch/filetests/filetests/x64/unreachable/as_func_first.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "as-func-first") (result i32)
-    (unreachable) (i32.const -1)
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 0f0b                 	ud2	
-;;    e:	 4883c408             	add	rsp, 8
-;;   12:	 5d                   	pop	rbp
-;;   13:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/unreachable/as_func_last.wat b/winch/filetests/filetests/x64/unreachable/as_func_last.wat
deleted file mode 100644
index c77c2fd86e1c..000000000000
--- a/winch/filetests/filetests/x64/unreachable/as_func_last.wat
+++ /dev/null
@@ -1,26 +0,0 @@
-;;! target = "x86_64"
-(module
-  (func $dummy)
-  (func (export "as-func-last")
-    (call $dummy) (unreachable)
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 0f0b                 	ud2	
-;;   1b:	 4883c408             	add	rsp, 8
-;;   1f:	 5d                   	pop	rbp
-;;   20:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/unreachable/as_func_mid.wat b/winch/filetests/filetests/x64/unreachable/as_func_mid.wat
deleted file mode 100644
index 196275fa2cd5..000000000000
--- a/winch/filetests/filetests/x64/unreachable/as_func_mid.wat
+++ /dev/null
@@ -1,27 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func $dummy)
-  (func (export "as-func-mid") (result i32)
-    (call $dummy) (unreachable) (i32.const -1)
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 0f0b                 	ud2	
-;;   1b:	 4883c408             	add	rsp, 8
-;;   1f:	 5d                   	pop	rbp
-;;   20:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/unreachable/as_func_value.wat b/winch/filetests/filetests/x64/unreachable/as_func_value.wat
deleted file mode 100644
index a0054ac38685..000000000000
--- a/winch/filetests/filetests/x64/unreachable/as_func_value.wat
+++ /dev/null
@@ -1,27 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func $dummy)
-  (func (export "as-func-value") (result i32)
-    (call $dummy) (unreachable)
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 0f0b                 	ud2	
-;;   1b:	 4883c408             	add	rsp, 8
-;;   1f:	 5d                   	pop	rbp
-;;   20:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/unreachable/as_if_cond.wat b/winch/filetests/filetests/x64/unreachable/as_if_cond.wat
deleted file mode 100644
index a605c8e7931e..000000000000
--- a/winch/filetests/filetests/x64/unreachable/as_if_cond.wat
+++ /dev/null
@@ -1,15 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func (export "as-if-cond") (result i32)
-    (if (result i32) (unreachable) (then (i32.const 0)) (else (i32.const 1)))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 0f0b                 	ud2	
-;;    e:	 4883c408             	add	rsp, 8
-;;   12:	 5d                   	pop	rbp
-;;   13:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/unreachable/as_if_else.wat b/winch/filetests/filetests/x64/unreachable/as_if_else.wat
deleted file mode 100644
index 74e7406dbb7d..000000000000
--- a/winch/filetests/filetests/x64/unreachable/as_if_else.wat
+++ /dev/null
@@ -1,23 +0,0 @@
-;;! target = "x86_64"
-
-
-(module
-  (func (export "as-if-else") (param i32 i32) (result i32)
-    (if (result i32) (local.get 0) (then (local.get 1)) (else (unreachable)))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   18:	 85c0                 	test	eax, eax
-;;   1a:	 0f8409000000         	je	0x29
-;;   20:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   24:	 e902000000           	jmp	0x2b
-;;   29:	 0f0b                 	ud2	
-;;   2b:	 4883c410             	add	rsp, 0x10
-;;   2f:	 5d                   	pop	rbp
-;;   30:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/unreachable/as_if_then.wat b/winch/filetests/filetests/x64/unreachable/as_if_then.wat
deleted file mode 100644
index f685209c0307..000000000000
--- a/winch/filetests/filetests/x64/unreachable/as_if_then.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func (export "as-if-then") (param i32 i32) (result i32)
-    (if (result i32) (local.get 0) (then (unreachable)) (else (local.get 1)))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   18:	 85c0                 	test	eax, eax
-;;   1a:	 0f8402000000         	je	0x22
-;;   20:	 0f0b                 	ud2	
-;;   22:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   26:	 4883c410             	add	rsp, 0x10
-;;   2a:	 5d                   	pop	rbp
-;;   2b:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/unreachable/as_if_then_no_else.wat b/winch/filetests/filetests/x64/unreachable/as_if_then_no_else.wat
deleted file mode 100644
index 8ebd7f36ca6f..000000000000
--- a/winch/filetests/filetests/x64/unreachable/as_if_then_no_else.wat
+++ /dev/null
@@ -1,21 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func (export "as-if-then-no-else") (param i32 i32) (result i32)
-    (if (local.get 0) (then (unreachable))) (local.get 1)
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec10             	sub	rsp, 0x10
-;;    8:	 897c240c             	mov	dword ptr [rsp + 0xc], edi
-;;    c:	 89742408             	mov	dword ptr [rsp + 8], esi
-;;   10:	 4c893424             	mov	qword ptr [rsp], r14
-;;   14:	 8b44240c             	mov	eax, dword ptr [rsp + 0xc]
-;;   18:	 85c0                 	test	eax, eax
-;;   1a:	 0f8402000000         	je	0x22
-;;   20:	 0f0b                 	ud2	
-;;   22:	 8b442408             	mov	eax, dword ptr [rsp + 8]
-;;   26:	 4883c410             	add	rsp, 0x10
-;;   2a:	 5d                   	pop	rbp
-;;   2b:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/unreachable/as_loop_broke.wat b/winch/filetests/filetests/x64/unreachable/as_loop_broke.wat
deleted file mode 100644
index a17e8d9d50fc..000000000000
--- a/winch/filetests/filetests/x64/unreachable/as_loop_broke.wat
+++ /dev/null
@@ -1,29 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func $dummy)
-  (func (export "as-loop-broke") (result i32)
-    (block (result i32)
-      (loop (result i32) (call $dummy) (br 1 (i32.const 1)) (unreachable))
-    )
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 b801000000           	mov	eax, 1
-;;   1e:	 4883c408             	add	rsp, 8
-;;   22:	 5d                   	pop	rbp
-;;   23:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/unreachable/as_loop_first.wat b/winch/filetests/filetests/x64/unreachable/as_loop_first.wat
deleted file mode 100644
index e05e8db58374..000000000000
--- a/winch/filetests/filetests/x64/unreachable/as_loop_first.wat
+++ /dev/null
@@ -1,16 +0,0 @@
-;;! target = "x86_64"
-
-
-(module
-  (func (export "as-loop-first") (result i32)
-    (loop (result i32) (unreachable) (i32.const 2))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 0f0b                 	ud2	
-;;    e:	 4883c408             	add	rsp, 8
-;;   12:	 5d                   	pop	rbp
-;;   13:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/unreachable/as_loop_last.wat b/winch/filetests/filetests/x64/unreachable/as_loop_last.wat
deleted file mode 100644
index 2b81848c78db..000000000000
--- a/winch/filetests/filetests/x64/unreachable/as_loop_last.wat
+++ /dev/null
@@ -1,28 +0,0 @@
-;;! target = "x86_64"
-
-
-(module
-  (func $dummy)
-  (func (export "as-loop-last")
-    (loop (nop) (call $dummy) (unreachable))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 0f0b                 	ud2	
-;;   1b:	 4883c408             	add	rsp, 8
-;;   1f:	 5d                   	pop	rbp
-;;   20:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/unreachable/as_loop_mid.wat b/winch/filetests/filetests/x64/unreachable/as_loop_mid.wat
deleted file mode 100644
index 6843244b6431..000000000000
--- a/winch/filetests/filetests/x64/unreachable/as_loop_mid.wat
+++ /dev/null
@@ -1,28 +0,0 @@
-;;! target = "x86_64"
-
-
-(module
-  (func $dummy)
-  (func (export "as-loop-mid") (result i32)
-    (loop (result i32) (call $dummy) (unreachable) (i32.const 2))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883c408             	add	rsp, 8
-;;   10:	 5d                   	pop	rbp
-;;   11:	 c3                   	ret	
-;;
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 4883ec08             	sub	rsp, 8
-;;   10:	 e800000000           	call	0x15
-;;   15:	 4883c408             	add	rsp, 8
-;;   19:	 0f0b                 	ud2	
-;;   1b:	 4883c408             	add	rsp, 8
-;;   1f:	 5d                   	pop	rbp
-;;   20:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/unreachable/as_return_value.wat b/winch/filetests/filetests/x64/unreachable/as_return_value.wat
deleted file mode 100644
index 2e97d9ba6ab7..000000000000
--- a/winch/filetests/filetests/x64/unreachable/as_return_value.wat
+++ /dev/null
@@ -1,15 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func (export "as-return-value") (result i64)
-    (return (unreachable))
-  )
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 0f0b                 	ud2	
-;;    e:	 4883c408             	add	rsp, 8
-;;   12:	 5d                   	pop	rbp
-;;   13:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/unreachable/type_i32.wat b/winch/filetests/filetests/x64/unreachable/type_i32.wat
deleted file mode 100644
index 307a68203c65..000000000000
--- a/winch/filetests/filetests/x64/unreachable/type_i32.wat
+++ /dev/null
@@ -1,13 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func (export "type-i32") (result i32) (unreachable))
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 0f0b                 	ud2	
-;;    e:	 4883c408             	add	rsp, 8
-;;   12:	 5d                   	pop	rbp
-;;   13:	 c3                   	ret	
diff --git a/winch/filetests/filetests/x64/unreachable/type_i64.wat b/winch/filetests/filetests/x64/unreachable/type_i64.wat
deleted file mode 100644
index d5239c5680a0..000000000000
--- a/winch/filetests/filetests/x64/unreachable/type_i64.wat
+++ /dev/null
@@ -1,13 +0,0 @@
-;;! target = "x86_64"
-
-(module
-  (func (export "type-i64") (result i32) (unreachable))
-)
-;;    0:	 55                   	push	rbp
-;;    1:	 4889e5               	mov	rbp, rsp
-;;    4:	 4883ec08             	sub	rsp, 8
-;;    8:	 4c893424             	mov	qword ptr [rsp], r14
-;;    c:	 0f0b                 	ud2	
-;;    e:	 4883c408             	add	rsp, 8
-;;   12:	 5d                   	pop	rbp
-;;   13:	 c3                   	ret	
diff --git a/winch/filetests/src/disasm.rs b/winch/filetests/src/disasm.rs
deleted file mode 100644
index 482a86a4a758..000000000000
--- a/winch/filetests/src/disasm.rs
+++ /dev/null
@@ -1,71 +0,0 @@
-//! Disassembly utilities.
-
-use anyhow::{bail, Result};
-use capstone::prelude::*;
-use std::fmt::Write;
-use target_lexicon::Architecture;
-use winch_codegen::TargetIsa;
-
-/// Disassemble and print a machine code buffer.
-pub fn disasm(bytes: &[u8], isa: &Box<dyn TargetIsa>) -> Result<Vec<String>> {
-    let dis = disassembler_for(isa)?;
-    let insts = dis.disasm_all(bytes, 0x0).unwrap();
-
-    let disassembled_lines = insts
-        .iter()
-        .map(|i| {
-            let mut line = String::new();
-
-            write!(&mut line, "{:4x}:\t ", i.address()).unwrap();
-
-            let mut bytes_str = String::new();
-            let mut len = 0;
-            for b in i.bytes() {
-                write!(&mut bytes_str, "{:02x}", b).unwrap();
-                len += 1;
-            }
-            write!(&mut line, "{:21}\t", bytes_str).unwrap();
-            if len > 8 {
-                write!(&mut line, "\n\t\t\t\t").unwrap();
-            }
-
-            if let Some(s) = i.mnemonic() {
-                write!(&mut line, "{}\t", s).unwrap();
-            }
-
-            if let Some(s) = i.op_str() {
-                write!(&mut line, "{}", s).unwrap();
-            }
-
-            line
-        })
-        .collect();
-
-    Ok(disassembled_lines)
-}
-
-fn disassembler_for(isa: &Box<dyn TargetIsa>) -> Result<Capstone> {
-    let disasm = match isa.triple().architecture {
-        Architecture::X86_64 => Capstone::new()
-            .x86()
-            .mode(arch::x86::ArchMode::Mode64)
-            .build()
-            .map_err(|e| anyhow::format_err!("{}", e))?,
-
-        Architecture::Aarch64 { .. } => {
-            let mut cs = Capstone::new()
-                .arm64()
-                .mode(arch::arm64::ArchMode::Arm)
-                .build()
-                .map_err(|e| anyhow::format_err!("{}", e))?;
-
-            cs.set_skipdata(true)
-                .map_err(|e| anyhow::format_err!("{}", e))?;
-            cs
-        }
-
-        _ => bail!("Unsupported ISA"),
-    };
-
-    Ok(disasm)
-}
diff --git a/winch/filetests/src/lib.rs b/winch/filetests/src/lib.rs
deleted file mode 100644
index 6b435b701a8f..000000000000
--- a/winch/filetests/src/lib.rs
+++ /dev/null
@@ -1,169 +0,0 @@
-pub mod disasm;
-
-#[cfg(test)]
-mod test {
-    use super::disasm::disasm;
-    use anyhow::Context;
-    use cranelift_codegen::settings::{self, Configurable};
-    use serde_derive::{Deserialize, Serialize};
-    use similar::TextDiff;
-    use std::str::FromStr;
-    use target_lexicon::Triple;
-    use wasmtime_environ::ModuleTranslation;
-    use wasmtime_environ::{
-        wasmparser::{Parser as WasmParser, Validator},
-        DefinedFuncIndex, FunctionBodyData, ModuleEnvironment, ModuleTypes, Tunables, TypeConvert,
-    };
-    use winch_codegen::{lookup, TargetIsa};
-    use winch_test_macros::generate_file_tests;
-
-    #[derive(Clone, Debug, Serialize, Deserialize)]
-    struct TestConfig {
-        target: String,
-        flags: Option<Vec<String>>,
-    }
-
-    /// A helper function to parse the test configuration from the top of the file.
-    fn parse_config(wat: &str) -> TestConfig {
-        let config_lines: Vec<_> = wat
-            .lines()
-            .take_while(|l| l.starts_with(";;!"))
-            .map(|l| &l[3..])
-            .collect();
-        let config_text = config_lines.join("\n");
-
-        toml::from_str(&config_text)
-            .context("failed to parse the test configuration")
-            .unwrap()
-    }
-
-    /// A helper function to parse the expected result from the bottom of the file.
-    fn parse_expected_result(wat: &str) -> String {
-        let mut expected_lines: Vec<_> = wat
-            .lines()
-            .rev()
-            .take_while(|l| l.starts_with(";;"))
-            .map(|l| {
-                if l.starts_with(";; ") {
-                    &l[3..]
-                } else {
-                    &l[2..]
-                }
-            })
-            .collect();
-        expected_lines.reverse();
-        expected_lines.join("\n")
-    }
-
-    /// A helper function to rewrite the expected result in the file.
-    fn rewrite_expected(wat: &str, actual: &str) -> String {
-        let old_expectation_line_count = wat
-            .lines()
-            .rev()
-            .take_while(|l| l.starts_with(";;"))
-            .count();
-        let old_wat_line_count = wat.lines().count();
-        let new_wat_lines: Vec<_> = wat
-            .lines()
-            .take(old_wat_line_count - old_expectation_line_count)
-            .map(|l| l.to_string())
-            .chain(actual.lines().map(|l| {
-                if l.is_empty() {
-                    ";;".to_string()
-                } else {
-                    format!(";; {l}")
-                }
-            }))
-            .collect();
-        let mut new_wat = new_wat_lines.join("\n");
-        new_wat.push('\n');
-
-        new_wat
-    }
-
-    #[generate_file_tests]
-    fn run_test(test_path: &str) {
-        let binding = std::fs::read_to_string(test_path).unwrap();
-        let wat = binding.as_str();
-
-        let config = parse_config(wat);
-        let wasm = wat::parse_str(&wat).unwrap();
-        let triple = Triple::from_str(&config.target).unwrap();
-
-        let binding = parse_expected_result(wat);
-        let expected = binding.as_str();
-
-        let shared_flags = settings::Flags::new(settings::builder());
-        let mut isa_builder = lookup(triple).unwrap();
-        for flag in config.flags.iter().flat_map(|f| f) {
-            isa_builder.set(&flag, "true").unwrap();
-        }
-        let isa = isa_builder.finish(shared_flags).unwrap();
-
-        let mut validator = Validator::new();
-        let parser = WasmParser::new(0);
-        let mut types = Default::default();
-        let tunables = Tunables::default();
-        let mut translation = ModuleEnvironment::new(&tunables, &mut validator, &mut types)
-            .translate(parser, &wasm)
-            .context("Failed to translate WebAssembly module")
-            .unwrap();
-        let types = types.finish();
-
-        let body_inputs = std::mem::take(&mut translation.function_body_inputs);
-
-        let binding = body_inputs
-            .into_iter()
-            .map(|func| compile(&isa, &types, &translation, func).join("\n"))
-            .collect::<Vec<String>>()
-            .join("\n\n");
-        let actual = binding.as_str();
-
-        if std::env::var("WINCH_TEST_BLESS").unwrap_or_default() == "1" {
-            let new_wat = rewrite_expected(wat, actual);
-
-            std::fs::write(test_path, new_wat)
-                .with_context(|| format!("failed to write file: {}", test_path))
-                .unwrap();
-
-            return;
-        }
-
-        if expected.trim() != actual.trim() {
-            eprintln!(
-                "\n{}",
-                TextDiff::from_lines(expected, actual)
-                    .unified_diff()
-                    .header("expected", "actual")
-            );
-
-            eprintln!(
-                "note: You can re-run with the `WINCH_TEST_BLESS=1` environment variable set to update test expectations.\n"
-            );
-
-            panic!("Did not get the expected translation");
-        }
-    }
-
-    fn compile(
-        isa: &Box<dyn TargetIsa>,
-        module_types: &ModuleTypes,
-        translation: &ModuleTranslation,
-        f: (DefinedFuncIndex, FunctionBodyData<'_>),
-    ) -> Vec<String> {
-        let module = &translation.module;
-        let types = &translation.get_types();
-
-        let index = module.func_index(f.0);
-        let sig = types[types.function_at(index.as_u32())].unwrap_func();
-        let sig = translation.module.convert_func_type(&sig);
-
-        let FunctionBodyData { body, validator } = f.1;
-        let mut validator = validator.into_validator(Default::default());
-        let buffer = isa
-            .compile_function(&sig, module_types, &body, &translation, &mut validator)
-            .expect("Couldn't compile function");
-
-        disasm(buffer.data(), isa).unwrap()
-    }
-}
diff --git a/winch/src/compile.rs b/winch/src/compile.rs
deleted file mode 100644
index 2d8b929022d6..000000000000
--- a/winch/src/compile.rs
+++ /dev/null
@@ -1,71 +0,0 @@
-use anyhow::{Context, Result};
-use clap::Parser;
-use cranelift_codegen::settings;
-use std::{fs, path::PathBuf, str::FromStr};
-use target_lexicon::Triple;
-use wasmtime_environ::{
-    wasmparser::{Parser as WasmParser, Validator},
-    DefinedFuncIndex, FunctionBodyData, ModuleEnvironment, ModuleTranslation, ModuleTypes,
-    Tunables, TypeConvert,
-};
-use winch_codegen::{lookup, TargetIsa};
-use winch_filetests::disasm::disasm;
-
-#[derive(Parser, Debug)]
-pub struct Options {
-    /// The input file.
-    input: PathBuf,
-
-    /// The target architecture.
-    #[clap(long = "target")]
-    target: String,
-}
-
-pub fn run(opt: &Options) -> Result<()> {
-    let bytes = fs::read(&opt.input)
-        .with_context(|| format!("Failed to read input file {}", opt.input.display()))?;
-    let bytes = wat::parse_bytes(&bytes)?;
-    let triple = Triple::from_str(&opt.target)?;
-    let shared_flags = settings::Flags::new(settings::builder());
-    let isa_builder = lookup(triple)?;
-    let isa = isa_builder.finish(shared_flags)?;
-    let mut validator = Validator::new();
-    let parser = WasmParser::new(0);
-    let mut types = Default::default();
-    let tunables = Tunables::default();
-    let mut translation = ModuleEnvironment::new(&tunables, &mut validator, &mut types)
-        .translate(parser, &bytes)
-        .context("Failed to translate WebAssembly module")?;
-    let types = types.finish();
-    let body_inputs = std::mem::take(&mut translation.function_body_inputs);
-
-    body_inputs
-        .into_iter()
-        .try_for_each(|func| compile(&isa, &translation, &types, func))?;
-
-    Ok(())
-}
-
-fn compile(
-    isa: &Box<dyn TargetIsa>,
-    translation: &ModuleTranslation,
-    module_types: &ModuleTypes,
-    f: (DefinedFuncIndex, FunctionBodyData<'_>),
-) -> Result<()> {
-    let index = translation.module.func_index(f.0);
-    let types = &translation.get_types();
-    let sig = types[types.function_at(index.as_u32())].unwrap_func();
-    let sig = translation.module.convert_func_type(sig);
-    let FunctionBodyData { body, validator } = f.1;
-    let mut validator = validator.into_validator(Default::default());
-    let buffer = isa
-        .compile_function(&sig, module_types, &body, &translation, &mut validator)
-        .expect("Couldn't compile function");
-
-    println!("Disassembly for function: {}", index.as_u32());
-    disasm(buffer.data(), isa)?
-        .iter()
-        .for_each(|s| println!("{}", s));
-
-    Ok(())
-}
diff --git a/winch/src/filetests.rs b/winch/src/filetests.rs
deleted file mode 100644
index 6917736c90c8..000000000000
--- a/winch/src/filetests.rs
+++ /dev/null
@@ -1,25 +0,0 @@
-use std::process::Command;
-
-use anyhow::Result;
-use clap::Parser;
-
-#[derive(Parser, Debug)]
-pub struct Options {
-    /// Passes extra arguments to `cargo test --package winch-filetests`. For example, to run a single
-    /// test, use `-- --test-threads 1 --test single_test_name`.
-    #[clap(last = true, value_parser)]
-    cargo_test_args: Vec<String>,
-}
-
-pub fn run(opts: &Options) -> Result<()> {
-    Command::new("cargo")
-        .arg("test")
-        .arg("--package")
-        .arg("winch-filetests")
-        .arg("--")
-        .args(&opts.cargo_test_args)
-        .spawn()?
-        .wait()
-        .map(|_| ())
-        .map_err(|e| anyhow::anyhow!("Failed to run cargo test: {}", e))
-}
diff --git a/winch/src/main.rs b/winch/src/main.rs
deleted file mode 100644
index 9984b86d3f42..000000000000
--- a/winch/src/main.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-mod compile;
-mod filetests;
-
-use anyhow::Result;
-use clap::Parser;
-
-/// Winch compilation and testing tool.
-#[derive(Parser)]
-enum Commands {
-    /// Compile a Wasm module to the specified target architecture.
-    Compile(compile::Options),
-    /// Run the filetests.
-    Test(filetests::Options),
-}
-
-fn main() -> Result<()> {
-    match Commands::parse() {
-        Commands::Compile(c) => compile::run(&c),
-        Commands::Test(t) => filetests::run(&t),
-    }
-}
diff --git a/winch/test-macros/Cargo.toml b/winch/test-macros/Cargo.toml
deleted file mode 100644
index a6f5b83c0ea5..000000000000
--- a/winch/test-macros/Cargo.toml
+++ /dev/null
@@ -1,20 +0,0 @@
-[package]
-authors = ["The Winch Project Developers"]
-name = "winch-test-macros"
-description = "Winch test macros"
-license = "Apache-2.0 WITH LLVM-exception"
-repository = "https://github.com/bytecodealliance/wasmtime"
-version = "0.0.0"
-publish = false
-edition.workspace = true
-
-[lib]
-proc-macro = true
-test = false
-doctest = false
-
-[dependencies]
-quote = "1.0"
-syn = { workspace = true, features = ["full"]}
-proc-macro2 = "1.0"
-glob = { workspace = true }
diff --git a/winch/test-macros/src/lib.rs b/winch/test-macros/src/lib.rs
deleted file mode 100644
index e0d34506bfa3..000000000000
--- a/winch/test-macros/src/lib.rs
+++ /dev/null
@@ -1,82 +0,0 @@
-extern crate proc_macro;
-
-use std::path::Path;
-
-use glob::glob;
-use proc_macro::TokenStream;
-use quote::quote;
-use syn::ItemFn;
-
-fn get_test_name_for_root(root: &Path, path: &Path) -> String {
-    let test_name = path
-        .strip_prefix(root)
-        .unwrap()
-        .to_str()
-        .unwrap()
-        .replace("/", "_")
-        .replace("\\", "_")
-        .replace(".wat", "");
-
-    format!("winch_filetests_{}", test_name)
-}
-
-/// Generate a test case for every .wat file in the filetests directory.
-/// This should only be used from the filetests crate.
-#[proc_macro_attribute]
-pub fn generate_file_tests(_attr: TokenStream, input: TokenStream) -> TokenStream {
-    // Parse the input as a function.
-    let input = proc_macro2::TokenStream::from(input);
-
-    let fn_ast: ItemFn =
-        syn::parse(input.clone().into()).expect("Failed to parse tokens as function");
-
-    // Get the function's name and body.
-    let name = &fn_ast.sig.ident;
-
-    let filetests_dir = Path::new(env!("CARGO_MANIFEST_DIR")).join("../filetests/filetests");
-
-    let test_file_entries = glob(format!("{}/**/*.wat", filetests_dir.to_str().unwrap()).as_str())
-        .expect("Failed to read glob pattern");
-
-    // Create a list of test cases by opening every .wat file in the directory.
-    let test_cases = test_file_entries.map(|entry| {
-        let path = entry.expect("Failed to read glob entry");
-
-        let full = path.to_str().expect("Path for file was empty");
-
-        let test_name = proc_macro2::Ident::new(
-            &get_test_name_for_root(&filetests_dir, &path),
-            proc_macro2::Span::call_site(),
-        );
-        quote! {
-            #[test]
-            fn #test_name() {
-                #name(#full);
-            }
-        }
-    });
-
-    // Assemble the output by combining the function and test cases.
-    let output = quote! {
-        #input
-
-        #(#test_cases)*
-    };
-
-    output.into()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_get_test_name_for_root_unix() {
-        let root = Path::new("/home/user/Documents/winch/filetests/filetests");
-        let path = Path::new("/home/user/Documents/winch/filetests/filetests/simd/simple.wat");
-
-        let test_name = get_test_name_for_root(root, path);
-
-        assert_eq!(test_name, "winch_filetests_simd_simple");
-    }
-}